TowardsDataScience-博客中文翻译-2022-四-

TowardsDataScience 博客中文翻译 2022（四）

原文：TowardsDataScience

协议：CC BY-NC-SA 4.0

机器学*中 5 个典型的初学者错误

原文：https://towardsdatascience.com/5-typical-beginner-mistakes-in-machine-learning-3544bd4109b

如果你要建立你的第一个模型，要注意并避免这些

数据科学和机器学*越来越受欢迎。这个领域的人数每天都在增长。这意味着有很多数据科学家在构建他们的第一个机器学*模型方面没有丰富的经验。这是很容易出错的地方。

善良好奇的在 Unsplash 上拍摄的

让我们来谈谈机器学*解决方案中最常见的初学者错误，以确保您意识到并将避免它们…

1.没有在需要的地方使用数据规范化

很容易获取特征，将它们放入模型中，并期望它给出预测。但在某些情况下，这种简单方法的结果可能会令人失望，因为缺少了一个非常重要的部分。

某些类型的模型需要数据规范化。这些包括线性回归、经典神经网络等等。这些类型的模型使用特征值乘以训练的权重。在非标准化特征的情况下，一个特征的可能值的范围可能与另一个特征的可能值的范围非常不同。

让我们假设，一个特性的值在【0，0.001】范围内，另一个特性的值在【100000，200000】范围内。对于使两个特征同等重要的模型，第一个特征的权重将比第二个特征的权重大 100，000，000 倍。巨大的重量可能会给模型带来严重的问题。例如，在存在一些异常值的情况下。此外，评估各种要素的重要性变得非常困难，因为大的权重可能意味着该要素很重要，也可能仅仅意味着它的值很小。

归一化后，所有的特征都在相同的取值范围内，通常为【0，1】或 [-1，1] 。在这种情况下，权重将在相似的范围内，并且将紧密对应于每个特征的实际重要性。

总的来说，在需要的地方使用数据标准化将会产生更好更准确的预测。

2.认为功能越多越好

有人可能会认为，把所有可能的特性都包括进来是个好主意，期望模型自动选择和使用最好的特性。

实际上，这很少是真的。在大多数情况下，具有明智设计和精选功能的型号将明显优于具有 10 倍多功能的类似型号。

模型的特征越多，过度拟合的风险就越大。即使在完全随机的数据中，模型也能够发现一些信号——有时更弱，有时更强。当然，随机噪声中是没有真实信号的。但是，如果我们有足够多的噪声列，那么该模型就有可能根据检测到的错误信号使用其中的一部分。当这种情况发生时，模型预测质量将会降低，因为它们将部分基于随机噪声。

在这种情况下，有各种各样的特征选择技术可以提供帮助。描述它们超出了本文的范围。但是要记住的主要事情是——你应该能够对你拥有的每个特性进行推理，为什么这个特性会对你的模型有帮助。

3.在需要外推的情况下使用基于树的模型

树模型很容易使用，同时也很强大。这就是它们受欢迎的原因。然而，在某些情况下使用基于树的模型可能是错误的。

树模型无法外推。这些模型永远不会给出比在训练数据中看到的最大值更大的预测值。而且它们也永远不会输出比训练中的最小值更小的预测。

吉利·斯图尔特在 Unsplash 上拍摄的照片

但是在某些任务中，推断能力可能非常重要。例如，如果模型预测股票价格，那么将来股票价格可能会比以往任何时候都要高。在这种情况下，基于树的模型将不能直接使用，因为它们的预测将接*历史最高价格。

这个问题有各种各样的解决方法。一种选择是预测变化或差异，而不是直接预测值。另一个解决方案是为这样的任务使用不同的模型类型。线性回归或神经网络能够外推。

4.在不需要的地方使用数据规范化

我知道，之前我谈到了数据标准化的必要性。但事实并非总是如此。

基于树的模型不需要数据归一化，因为要素原始值不用作乘数，异常值不会影响它们。

神经网络可能也不需要显式规范化，例如，如果网络内部已经包含层处理规范化(如 Keras 库的 BatchNormalization )。

在某些情况下，即使是线性回归也可能不需要数据标准化。这是当所有的特征已经在相似的值范围内并且具有相同的含义时。例如，如果模型应用于时间序列数据，并且所有特征都是同一参数的历史值。

实际上，应用不需要的数据规范化不一定会损害模型。大多数情况下，这些情况下的结果与跳过的规范化非常相似。然而，进行额外的不必要的数据转换会使解决方案变得复杂，并且会增加引入一些错误的风险。

5.在训练集和验证/测试集之间泄漏信息

制造数据泄露比人们想象的要容易。考虑下面的代码片段:

数据泄漏的特征示例

实际上，这两个特征(sum_feature 和 diff_feature)都是不正确的。它们会泄漏信息，因为在拆分为训练/测试集之后，具有训练数据的部分将包含来自测试行的一些信息。这将导致更高的验证分数，但是当应用于真实的数据模型时，性能会更差。

正确的做法是先将训练/测试分开。然后才应用特征生成功能。一般来说，分别处理训练集和测试集是一种很好的特征工程模式。

可能有些情况下，一些信息必须在两者之间传递——例如，我们可能希望测试集使用相同的标准缩放器,该缩放器用于训练集并在其上被训练。但这只是几个案例，需要逐案决定和验证。

最后的话

从错误中吸取教训是有好处的。但是从别人的错误中学*更好——希望提供的错误例子能帮助你。感谢阅读！

如果您有兴趣阅读我未来关于数据科学、机器学*和 Python 编程的文章，请关注我。

Pyspark 中重新实现的 5 个有用的熊猫函数

原文：https://towardsdatascience.com/5-useful-pandas-functions-reimplemented-in-pyspark-2619d2359d38

在 pyspark 中重新实现缺失的熊猫函数

照片由戴安娜·帕克豪斯在 Unsplash 上拍摄

介绍

Pandas 是 Python 中最流行的数据辩论工具之一，因为它具有直观的数据结构和丰富的 API。在 Pandas 和 Pyspark 之间切换的用户可能会注意到，某些 Pandas 方法或属性没有 Pyspark 等价物。

在本文中，我们将研究 Pyspark 中没有的一些常用的 Pandas 方法和属性，以及如何在 Pyspark 中创建我们自己的等效自定义方法。我们将使用pd_df和ps_df分别代表熊猫和 Pyspark 数据帧。

需要以下导入:

import pyspark
from pyspark.sql.window import Window
from pyspark.sql import functions as f

形状

熊猫的.shape属性允许我们检查数据帧的行数和列数。

pd_df.shape>> (45211, 17) # number of rows, columns

为了在 Pyspark 中获得类似的输出，我们可以通过包含一个新的shape()方法来扩展pyspark.sql.DataFrame。

我们可以找到 Pyspark 数据帧的形状

ps_df.shape()>> (45211, 17) # number of rows, columns

信息

Pandas 的.info()方法为我们提供了每一列的数据类型和空值数量

pd_df.info()

作者图片

下面的代码片段展示了 Pyspark 的等效代码。

对 Pyspark 数据帧执行.info()会返回相关的 Pyspark 数据类型，这些数据类型可能与 Pandas 数据类型不同。

ps_df.info()

重新命名

Pandas 的.rename方法允许我们使用字典重命名多个列，其中键是当前列名，值是新列名{"old_col_name":"new_col_name"}。

Pyspark 允许用.withColumnRenamed方法重命名 Pyspark 数据帧。

sp_df = spdf.withColumnRenamed('old_col_name', 'new_col_name')

为了重命名多个列，我们多次调用.withColumnRenamed方法:

sp_df = spdf.withColumnRenamed('old_col_name1', 'new_col_name1').withColumnRenamed('old_col_name2', 'new_col_name2')

让我们创建一个 Pyspark .rename()方法，它允许我们使用映射器字典重命名多个列。

我们现在可以使用以下方式重命名pyspark.sql.DataFrame:

new_df = ps_df.select('marital', 'age').rename({'marital':'marital_status', 'age':'customer_age'})
new_df.show(n = 5)

作者图片

值计数

熊猫的.value_counts()计算具有唯一列组合的行数。

pd_df.value_counts('marital')

在派斯帕克

与 Pandas .value_counts()类似，有一个使用normalize参数来标准化频率的选项。

ps_df.value_counts('marital')

作者图片

ps_df.value_counts('marital', normalize = True)

作者图片

复制

Pandas 的.duplicated方法返回一个布尔序列来表示重复的行。我们的 Pyspark 对等函数将返回 Pyspark 数据帧，其中有一个名为duplicate_indicator的附加列，其中True表示该行是重复的。

ps_df\\
  .select(['age', 'job', 'marital', 'education', 'balance'])\\
  .duplicated(subset = ['age', 'job', 'marital', 'education'], orderby = ['balance'], ascending = True, keep = 'first')\\
  .show()

.duplicated()的 pyspark 当量

结论

在本文中，我们研究了 5 个常用的 Pandas 方法/属性，并在 Pyspark 中创建了它们的对等物。Pyspark 中的这些方法可以作为快速数据探索和清理的便利功能。你可以在这个 github 资源库中找到完整的代码。

• 加入 Medium 阅读更多类似的故事
• 关注我关于熊猫的教程

用 Python 处理大型数据集的 3 种方法

原文：https://towardsdatascience.com/5-ways-to-deal-with-large-datasets-in-python-9a80786c4182

作为一名数据科学家，我发现自己越来越需要处理“大数据”。我戏称为的大数据对应的数据集，虽然并不真的那么大，但却大到足以让我的计算机努力处理它们，并真的减慢一切。

米卡·鲍梅斯特在 Unsplash 上的照片

这个问题并不新鲜，就像所有事情一样，不存在放之四海而皆准的神奇公式。最佳方法将取决于您的数据和应用程序的目的。然而，最流行的 解决方案通常属于下述类别之一。

1.通过优化数据类型减少内存使用

当使用 Pandas 从文件中加载数据时，它会自动推断数据类型，除非另有说明。大多数情况下，这样做很好，但是推断的类型不一定是优化的。此外，如果数字列包含缺失值，那么推断的类型将自动为 float。

我最*使用这个方法进行了一项分析，我主要处理表示年、月或日的整数类型:

使用 Pandas 加载文件并指定 dtypes(图片由作者提供)

对于这种特殊的情况，指定数据类型可以大大减少所使用的内存。请注意，在上面的例子中，我使用了熊猫类型熊猫。Int16Dtype 强制包含缺失值的列为 Int 类型。这是通过使用熊猫在内部实现的。NA，而不是 numpy.nan

处理大型数据集时，优化数据类型需要事先了解您正在处理的数据。在未知数据集的纯探索阶段，它可能没有用。

2.将数据分割成块

当数据太大而不适合内存时，您可以使用 Pandas 的 chunksize 选项将数据分割成块，而不是处理一个大块。使用此选项创建一个 迭代器 对象，该对象可用于遍历不同的块并执行过滤或分析，就像加载完整数据集时所做的一样。

下面是一个使用该选项遍历 Yelp 评论数据集的示例，提取每个块的最小和最大评论日期，然后重建评论的完整时间跨度:

从最初的探索性分析到模型训练，都可以使用分块，并且只需要很少的额外设置。

3.利用懒惰评估

惰性求值指的是将表达式的求值延迟到实际需要该值时进行的策略。惰性求值是一个重要的概念(尤其在函数式编程中使用)，如果你想了解更多关于它在 Python 中的不同用法，你可以从这里开始。

惰性评估是构建分布式计算框架的基础，如 Spark 或 Dask 。尽管它们是为集群设计的，但是您仍然可以利用它们在您的个人计算机上处理大型数据集。

与 Pandas 的主要区别在于，它们不直接将数据加载到内存中。相反，在 read 命令期间发生的是，它们扫描数据，推断数据类型，并将其分成分区(到目前为止没有什么新内容)。计算图是为这些分区独立构建的，只有在真正需要的时候才执行(这就是懒惰的原因)。

我在另一篇文章中提供了一个使用 Pyspark 对大于内存的数据集进行探索性分析的例子，并在另一篇文章中写了关于 Spark 核心原则的内容，所以我在这里不再重复。 Dask 也很受欢迎例子不难找到(要比较两者，你可以从这里开始)。Dask 的语法模仿了 Pandas 的语法，所以看起来很熟悉，但是，它仅限于 Python 的使用，而 Spark 也可以在 Java 或 Scala 中工作。

其他库，如 Vaex 或 Modin 提供了类似的功能，但我个人没有使用过它们。

摆脱数据科学常规的 5 种方法

原文：https://towardsdatascience.com/5-ways-to-escape-a-data-science-rut-4db5148adc72

用这些成长的想法打开你的发展之门

托马斯·马图在 Unsplash 上的照片

介绍

我们都知道墨守成规的感觉。某一天，你有动力去学*新的东西，开始新的项目，一头扎进数据科学的世界——第二天，你就感觉自己只是在走过场。过了一段时间后，你看起来不像是在朝着目标努力，而更像是在消磨时间或无休止地做额外的工作。

当我们发现自己像这样在兜圈子时，重要的是检查我们的日常工作，并找到新的方法让事情变得有趣。这里有 5 个想法可以让你走出创造力的低谷，并帮助你重新爱上数据科学。

1.进行一些数据科学交叉培训

我最*读了一篇关于领导力的文章，其中的主要观点是，当提高力量时，交叉训练比加倍有氧运动更好。

“要想从好变得更好，你需要从事相当于交叉培训的商业活动。例如，如果你是技术专家，即使深入钻研技术手册也不会让你获得像沟通这样的互补技能，这种技能会让你的专业知识更明显，更容易被同事了解。”(发表在《哈佛商业评论》上

机器学*中改变游戏规则的创新也来自交叉训练。以图像转换器模型为例:这些最先进的计算机视觉(CV)模型(优于 CNN)在很大程度上基于最初为自然语言处理(NLP)设计的模型。数据科学交叉培训不仅限于连接 CV 和 NLP 等专业，它还跨越多个领域。原来中的注意就是你所需要的 执行的语言翻译。现在，变形金刚模型正被应用于从医学图像分割到语音识别的方方面面。

感觉卡住了？自己进行一些交叉训练。如果你的专业是监督学*，查一下强化学*技术，看看你能学到什么。或者如果你对面部识别的对象检测感兴趣，看看你能从医学机器学*中的对象检测研究中学到什么。

2.收集你自己的数据并将其可视化

数据可视化是一项重要的技能。无论您是在建模前使用数据可视化作为探索工具，还是创建交互式工具来讲述数据故事，清晰有效地传达信息的可视化都至关重要。

我最喜欢的磨练数据可视化技能的方法之一是收集我自己的数据，勾画一些可视化，然后看看我如何使用数据可视化工具实现它们。首先，绞尽脑汁寻找你一直想回答的问题。你邻居的狗一周吠几次？你一天检查多少次你的电子邮件？相对于黑色汽车，有多少辆白色汽车从你的窗前经过？世界是你的！

然后，开始收集数据。当您收集自己的数据而不是使用在线开放数据时，您可以完全创造性地控制要收集的功能和收集的节奏。我还发现，当你自己创建数据集时，更容易知道数据集的哪些方面是有趣的。一旦你得到了你的数据，拿起纸和笔，勾画出一些潜在的形象。数量重于质量——设定一个 5 分钟左右的计时器，然后在纸上画一堆草图。当时间到了，花一两个小时试着编写你最喜欢的可视化代码。如果你想在开始素描之前寻找一些灵感，我推荐你查看一下视觉复杂性或信息是美丽的中一些有趣的插图。

3.从基本原则中学*数据科学方法

从基本原则开始学*数据科学方法是一种很好的方式，可以在摆脱常规的同时提高您的数学和统计技能。像《走向数据科学的 T4》这样的出版物是一个很好的地方，可以找到关于数据科学主题的可访问的指南和温和的介绍。以下是我最喜欢的几个，可以帮助你开始，但你可以随意搜索，找到你自己的主题:

• SHAP 价值观准确地解释了你希望别人如何向你解释。如果你对可解释的人工智能感兴趣，你需要知道沙普利附加解释值或 SHAP 值。本指南介绍了这种与模型无关的特性重要性技术的基础及其博弈论基础。在进入 SHAP python 库及其文档以了解更多信息之前，请阅读马赞蒂的指南。
• 理解梯度下降背后的数学原理。梯度下降是机器学*中最重要的优化技术之一。它包含了如此多的重要算法和技术，所以花一个下午来确保你理解它是如何工作的是值得的。
• 吉布斯采样由作者解释。我为这个动手教程感到骄傲。使用二元正态的例子和一系列的可视化，我走过 Gibbs 抽样和如何从复杂的目标分布中抽样。如果你对马尔可夫链蒙特卡罗(MCMC)算法和贝叶斯统计感兴趣，本教程是一个很好的地方来建立对幕后涉及的统计的直觉。

4.阅读一篇最新的研究论文

好吧，听我说完。我知道数据科学和机器学*研究论文可能会令人生畏——它们通常信息密集，理论性太强，在行业中没有用处，或者完全无聊。然而，能够打开一篇你感兴趣的前沿研究论文是有真正价值的。数据科学和机器学*的研究进展以闪电般的速度发生，跟上可能是让你的工作脱颖而出的真正优势。如果你做得对，阅读研究也可以很有趣。

让研究变得有趣的关键是选择正确的论文。您希望找到(a)与您感兴趣的主题相关，(b)您和您的同行感兴趣，以及(c)有相关源代码供您探索和学*的研究。我最喜欢的寻找这些宝石的网站是代码为的论文。这个网站汇编了机器学*研究的最新成果，并按主题进行了分类，这样你就可以浏览你感兴趣的内容。除了全文和摘要链接，目录中的每个列表都有社区中其他人如何与研究互动的指标。正如所暗示的，所有的研究论文都有代码库和数据集。

5.跟随一些新的数据科学灵感

在社交媒体(Twitter、Medium、LinkedIn、YouTube 等)上关注正确的数据科学家、机器学*工程师和技术专家。)是跟上最新技术、工艺和趋势的好方法。合适的个人也创造迫使我们深入思考数据科学如何与世界互动的内容。识别一些新的声音可能正是你所需要的，以疏通你的发展。

社交媒体可能是一个可怕的地方，所以如果你是数据科学社交媒体的新手，这里有一些技巧和资源可以帮助你开始。

• 关注那些做着你尊敬的工作的消息来源。像 ML 系统设计专家 Chip Huyen 这样的个人和像 GovTech 公司 Civis Analytics 这样的公司博客都属于这一类。
• 关注那些让你了解专业领域最新动态的账号。Andrew Gelman 的推特账户让我了解他实验室的工作。 Mike Lopez 的 Twitter 帮助我了解体育分析领域有趣的新发展。
• 关注那些让你思考或挑战你的假设的报道。尝试 Cortnie Abercrombie 人工智能伦理以及人工智能/人工智能系统如何放大现有的社会和人口偏见。或者跟随 Allie Miller 了解一切。
• 关注有趣的或让你发笑的账户。见神经网络猜测模因(不客气)。

*Acknowledgments: A big thank you to the wonderful, soon-to-be-doctor Claire Hoffman for proofreading and editing this article. If you liked this story and want to read more, follow me on Medium and subscribe via my referred members link here:* [https://sethbilliau.medium.com/membership](https://sethbilliau.medium.com/membership).

使用 whylogs profile visualizer 检查数据和模型的 5 种方法

原文：https://towardsdatascience.com/5-ways-to-monitor-data-models-with-whylogs-profile-visualizer-8f1048f8f72e

发现数据漂移并确保机器学*模型质量

使用 whylogs profile visualizer 在示例数据集上使用 uniform_integers 功能制作的双直方图。图片由作者提供。

开源的 whylogs profile visualizer 支持使用 Python 对机器学*和数据工程中的数据进行可视化观察。将可视化添加到数据可观察性中，可以进一步提取和增强可以在 whylogs 数据记录配置文件中捕获的信号，以帮助您了解数据中发生的情况，快速识别和纠正问题，并保持高性能数据和机器学*模型的质量和相关性。profile visualizer 与您的日志记录代码一起在 Jupyter 笔记本中运行，并增强了开源 whylogs 库的解释能力，迅速成为 ML 模型和数据管道的数据日志记录和监控标准。

作为 Slack 上强大而负责任的人工智能社区的一员，我直言不讳地表达了我对可视化分析的热情，像往常一样，WhyLabs 团队的成员向我介绍了正在开发的 profile visualizer。这进一步激发了我的好奇心，即一旦数据集或模型进入生产阶段，可视化如何弥补数据可观测性中存在的差距——观察它在世界上的表现。

Felipe Adachi 编写了示例代码笔记本，这是我学*使用 profile visualizer 的基础，我在这篇文章中突出显示了其中的摘录，并添加了其他示例，您可以从我自己的笔记本中尝试。两者都是对这个帖子的逐步补充。Felipe 和 Danny Leybzon 都慷慨地回答了我的问题，并在我写这篇文章时，从他们作为 whylogs 和 profile visualizer 的维护者的角度，以及为了开发刚刚发布的 v1 代码库的准确性，提供了反馈。

学*有效地使用个人资料可视化工具

• 检查在管道的关键输入和输出接合点记录的数据
• 一眼就能看出两个数据分布的差异
• 快速查明机器学*操作中的数据漂移

开始吧！

---

审查记录和统计资料

简而言之，在深入剖析 profile visualizer 之前，了解数据记录的价值和 whylogs profiles 的工作原理是非常重要的。如今，随着机器学*和人工智能的集成，数据管道以无与伦比的速度流动，其规模可能使监控数据变得困难。出于同样的原因监控你的数据比以往任何时候都更重要，以保持其完整性。

第一步是在靠*数据工作流的地方捕获日志，在数据进入或退出管道的地方，或者在数据经过可能引入或突出问题的主要转换的地方，例如丢失值或上游数据类型的变化没有被考虑。为了使用 profile visualizer，这意味着使用 Python 记录数据概要。

图片由 cottonbro 通过 Pexels 根据作者许可进行修改组合。

profile visualizer 可以与您在 whylogs profiles 中捕获的任何类型的数据一起使用，以检测不同的导致漂移的情况以及其他数据质量和模型性能问题。这包括结构化或非结构化数据，以及批处理或流数据。whylogs 配置文件是对您的数据的轻量级总结，它被很好地校准到适合于数据监控的范围和*似程度，不多也不少。与监控和可视化特别相关的是 whylogs 配置文件的轻量级性质，以及与传统采样方法相比，它们对异常值更敏感。可能表明质量问题的罕见事件很容易发现。

然而，以一种比必要的更具体的方式记录数据很容易成为团队和基础设施的资源拖累，并且成为一种新形式的技术债务。选择记录这些汇总的统计数据，而不是存储哪怕是很小的详细数据样本，也可以为您节省因数据所有权和隐私相关法规的强化而面临巨额法律罚款的风险。

如何直观地检查单个概要文件的统计数据

首先，使用统包功能统计来查看单个 whylogs 数据配置文件的任何功能。执行这种单变量分析(或对一个要素的分析)是在探索性分析过程中描述数据、预测模式以及了解基数、集中趋势、离差、可变性和缺失值发生率等关键方面的快速方法。

包含这篇文章中的这个例子和其他例子的全部代码的 Jupyter 笔记本可以在 Colab 中打开，或者下载，或者与同一个 GitHub 存储库中的其他例子一起使用。我在这篇文章中提到了数据特性，因为我更多地是从数据科学而不是工程的角度来看待可视化工具。无论您将这些数据称为变量、特征还是数据列，您都可以使用这些图表和报告来查看您的数据并提前发现问题。

为配置文件可视化工具准备一个笔记本

首先，安装最*发布的whylogs v1 包和viz包来使用 profile visualizer。我使用一台 macOS 机器，默认情况下在其终端运行 zsh shell 语言，因此运行下面的第一个代码单元就可以了。如果您之前已经安装了 whylogs，请确保包含--upgrade选项，因为 profile visualizer 仅在最*的 whylogs v1 版本之后才可用。

这个代码要点还展示了几种不同场景的 install 命令。您的操作系统和您选择运行 install 命令的位置会影响哪种语法适合您。对于 Z shell (Zsh)，必须用硬括号对viz包进行转义，以防止它被解释为模式。通过在命令前加上感叹号直接在你的 Jupyter 笔记本中安装包，在这种情况下，如果你不想看到安装过程的所有自动输出，尝试添加-q quiet 命令选项。

为示例加载数据

使用 profile visualizer 比较来自著名机器学*数据集的两个剖面图的一个示例非常有趣！加载数据，然后打印熊猫数据帧的简明摘要。

请注意，质量特性包含整数值。在演示过程中，您将把它转换成分类数据类型，以制作快速图表，通过“好”或“坏”的角度来查看您的数据。

初始化配置文件可视化工具

在导入了本例所需的 Python 库之后，加载葡萄酒质量数据集，将数据帧记录到 whylogs 配置文件中，并生成一个配置文件视图，以便与 profile visualizer 一起使用。然后，实例化“NotebookProfileViewer”并设置您的目标配置文件。这篇文章中的大部分代码也可以在一本 Jupyter 笔记本中找到。选择“在 Colab 中打开”按钮或直接下载笔记本。

完成后，一行代码就可以获得各种有用的汇总统计数据，如基于柠檬酸特性的示例所示。

visualization**.**feature_statistics(feature_name**=**"citric acid", profile**=**"target")

统计数据描述了你的数据。每种类型的总结都是对其他总结的补充。图片由作者提供。

要素统计数据由最基本但仍能提供大量信息的数据聚合的顶级波段组成。不同值的百分比可以表示一致性程度(高%)或不一致性程度(低%)。这里，您可以看到目标配置文件中只有 18%的柠檬酸值是不同的。

分位数统计说明数据如何分布在出现的值范围内。在 UCI 葡萄酒数据集的这一部分中，柠檬酸的四分位数范围 0.3 相对于 1.0 较低。如果你对数据的印象是，中间的 50%的值应该在中间值附*相互靠*。相反，较高的 IQR(如 0.8)将显示范围内分布更广的值。

在描述性统计中，变异系数是标准差除以平均值。作为比率，它独立于其要素的单位比例，并且可以与数据中另一个要素的 CV 进行比较，只要两个要素都具有从零开始的连续数值比例。例如，柠檬酸的 0.72%或 72% CV 表示广泛分散的值。例如，如果将它与另一个特征的 CV . 30 进行比较，您会发现柠檬酸比另一个特征分散得更广。然而，当 CV 方程接*零时，它对均值的微小差异很敏感，在这种情况下，标准差本身更能提供信息，因此在上下文中考虑所有这些统计数据很重要。

如何比较两个数据配置文件

profile visualizer 带来了激动人心的改进，可以在笔记本中直接使用两个 whylogs 配置文件进行直观比较。接下来的步骤将引导您运行漂移汇总报告，以了解所有数据集要素的统计信息以及代表目标和参考配置文件之间漂移量的每个属性的差异。然后，简短的演示说明了可视化工具可用于关注两个配置文件中的单个数字或分类特征的图表类型，以及每个图表最有用的时间。

对照基线目标监控您的数据，并能够看到它，就像当您还不清楚时的水晶球一样！一旦机器学*模型投入生产，数据质量就会恶化，监控模型的性能以检测漂移或模型输入和输出数据之间关系的变化也很重要。

可视化工具可以帮助您发现机器学*中数据漂移的一个原因是选择偏差，当模型根据不代表其打算执行的整个群体的数据进行训练时，就会引入选择偏差。下面的示例通过使用有偏见的标准将数据集分成两个分析组来说明这种常见情况。然而，要理解漂移的不同根本原因，以及每种原因何时会出现在模型数据的模式中，一本关于数据漂移的初级读本是一本很好的读物。

在配置文件可视化工具中初始化目标和引用配置文件

现在，将葡萄酒质量案例研究中的数据集分成两组，以有意创建一个样本选择偏差场景，其中训练样本不代表总体。像以前一样加载葡萄酒质量数据集。第一组将包括酒精含量等于或低于 11 的葡萄酒，并将被视为您的基线(或参考)数据集，第二组将包括酒精含量高于 11 的葡萄酒，作为您的目标数据集。

准备两个组，然后将每个组的 whylogs 配置文件传递给配置文件可视化工具，以便在目标配置文件和参考配置文件之间进行比较。quality是一个数字特征，代表葡萄酒的质量。将其转换为分类特征，将每种葡萄酒分为好坏。任何高于 6.5 的都是好酒。否则就糟了。

现在，用whylogs分析数据帧，并创建profile_views作为输入到NotebookProfileVisualizer的参数。

如果这看起来像是一个很大的设置，那么你很幸运，因为从现在开始，获得各种相关的图表和报告只需要简单的代码。

查看您的个人资料的汇总漂移报告

同时并排比较目标和参考轮廓的许多特征。在汇总漂移报告中，您将看到概览统计数据，例如观测值和缺失像元的数量，以及每个要素分布的比较。在报告中会为您计算每个特定数值或分类特征的漂移，并且会显示与每个特征的漂移严重性相关的警报。

您只需要输入一行代码，就可以对您在上面的步骤中实例化 profile visualizer 时已经传递给它的概要文件运行概要漂移报告。

visualization.summary_drift_report()

葡萄酒质量示例数据配置文件的汇总漂移报告，显示其包含的一些单个特征的直方图，以及每个特征的差异、计数和均值。作者视频。

请注意，在汇总漂移报告的右上角有一个搜索输入框，您也可以在其中搜索特定的数据特征，如“质量”或按推断类型过滤。下面的代码要点显示了从开始到结束的代码，以制作一个总结漂移报告。

数字特征的双直方图叠加剖面图

使用直方图可以在高层次上快速看出单个数字特征的差异，直方图提供了数据分布和频率的大致情况。当使用关键整数或浮点数据功能时，profile visualizer 中的双直方图是一个图表，您可以在此图表中先发制人地捕捉到未预料到的变化，例如，在生产中监控机器学*模型，并使用该知识重新评估您的数据收集和选择，直到您找到根本原因为止。

当前目标和参考配置文件的直方图显示在一个图形中，带有预设的颜色编码和不透明度，可有效区分两个配置文件，并在数据层重叠的地方产生混合色调。直方图的框大小是在初始化 profile visualizer 时分配的。这种动态的宁滨确保了一个共同的尺度，区间范围，以及你在解读图表时所做的比较的保真度。

在本例中，重点关注两个数据剖面的“密度”特征。从这个简洁的图表中，您可以评估两个剖面中“密度”的相似性，查看两个数据集相交的值的范围，并通过一目了然的平均值差异来衡量。同样，只需一行代码，就可以用覆盖在目标数据上的参考数据制作一个双直方图。

visualization.double_histogram(feature_name="density")

直方图一次显示两个分布图的分布、频率、平均值和异常值之间的对齐或差异。图片由作者提供。

很快，我们的“密度”目标数据和参考数据之间出现了巨大的变化。虽然蓝色的目标条和橙色的参考条仍然稍微向右倾斜，但这种变化可以从几个方面看出来。

• x 轴上的值的分布总体上缩小了，从接*轴跨度的目标扩展到更接*其平均值的参考聚类，如果要计算的话，超出 1-2 标准偏差的范围更小。
• 参考文献中的频率现在更加标准化；而更多的随机性出现在目标中。
• 参考值的平均值比目标值的平均值多* 100 个数据点。

在我们的例子中，这并不奇怪，因为这两个配置文件被有意分开，以说明选择偏差，将低酒精含量的葡萄酒放在一个数据配置文件中，将高酒精含量的葡萄酒放在另一个数据配置文件中。很明显，如果这样一个模型遇到的葡萄酒超出了它被训练的酒精范围，那么这个关于训练数据选择的决定将导致糟糕的性能，并且需要重新训练。

想象一个模型在生产中的真实场景。如果本例中的目标是模型首次部署到生产环境中时记录的输入数据的概要文件，而引用是在同一输入点但在稍后时间记录的概要文件，那么您对可观察性的期望是，这两个概要文件以及在该点记录的任何其他概要文件看起来相同，或者仅显示可接受程度的差异。换句话说，如此明显的变化表明输入到模型中的数据可能存在问题，因此任何结果输出也可能存在问题。

参见分类特征的分布

在分布图中，您的两个配置文件之间的分类数据元素的差异将会很明显。使用基于您在数据准备步骤中创建的“质量”特征的图表，您将看到每个葡萄酒数据档案中有多少是“好”的，有多少是“差”的。你会记得你将数值高于 6.5 的葡萄酒归类为“好”。

和上面的例子一样，一行代码就构成了“质量”特性的分布图。

visualization.distribution_chart(feature_name="quality")

并排比较两个数据配置文件的“质量”特征。图片由作者提供。

你注意到的第一件事可能是目标酒和参考酒之间“坏”酒分布的巨大差异，参考酒显示更多的“坏”劣质酒。您应该还记得，您将酒精含量等于或低于 11 的葡萄酒归为一类，形成了参考资料。从表面上看，这确实导致了样本选择偏差的情况，正如本例所预期的那样，我们看到偏差导致了基于原始数据集中的原始数字质量度量的特征“质量”的两个轮廓之间的漂移。

查看分类特征分布的差异视图

另一种更快查看分类特征分布差异的方法是只查看绘制在单个条形图中的两个分布图之间的特征差异。和以前一样，一行代码就可以在您的个人资料上生成图表。

visualization.difference_distribution_chart(feature_name="quality")

很明显，尽管这两个档案中“好”葡萄酒的分布几乎相同，但“坏”葡萄酒的分布却有很大的不同。图片由作者提供。

使用这种图表类型，你的眼睛做的跟踪工作最少，来来回回比较棒线，让你得到与标准分布图相同的结论，但认知工作更少。一张图也有助于加强你从另一张图中得到的发现，两者都说明了你在工作中可能遇到的这种类型的偏见。

您还可以通过下载并以 HTML 文件的形式发送此图表或 profile visualizer 中的任何可视报告和图表，与组织中的任何人轻松共享。

总结

在 whylogs GitHub 存储库中，除了 profile visualizer 示例之外，还有许多其他有用的代码示例，用于学* whylogs 的不同特性，例如使用约束和 visualizer 来更主动地监控质量。

profile visualizer 使用来自数据的视觉线索来检测数据集漂移和质量问题。它将可视化分析引入了 Python 中的开源 whylogs 库，并提供了数据集或机器学*模型在设计场景中表现如何的证据。有了它，当您的数据需要调试或完全重启时，您将不会措手不及。

用您自己的数据试试开源的 whylogs profile visualizer！

无论您是数据工程师、数据科学家、机器学*工程师，还是团队中的所有成员，您都可以通过 profile visualizer 的图表更快地关注数据和模型的健康状况，并减少对工作流程的中断。profile visualizer 为您节省了时间和精力，让您可以将数据和模型投入到工作中，从而扩展您的运营、最小化风险并取悦您的客户。

感谢

非常感谢在本学*资源中使用来自 UCI 机器学*资源库的葡萄酒质量数据集。

页（page 的缩写）科尔特斯、塞德伊拉、阿尔梅达、马托斯和雷伊斯。

通过物理化学特性的数据挖掘建立葡萄酒偏好模型。在决策支持系统中，爱思唯尔，47(4):547–553，2009。

Dua d .和 Graff c .(2019 年)。UCI 机器学*知识库[http://archive . ics . UCI . edu/ml]。加州欧文:加州大学信息与计算机科学学院。

成功执行数据科学创新项目的 5 种方法

原文：https://towardsdatascience.com/5-ways-to-successfully-execute-your-data-science-innovation-projects-80b012e02ac6

由 Unsplash 上的 Kvalifik 拍摄的照片

根据我的经验，大部分老牌公司的“创新”努力都集中在提出想法上。以黑客马拉松为例——最好的黑客马拉松将企业的不同部分聚集在一起，提出解决客户问题的好主意。但是在你的职业生涯中，你参加过多少次黑客马拉松？你想出的主意有多少有了结果？人们希望在工作中找到意义，而不能提供这种意义的公司将很难留住人才。

我最*读了维贾伊·戈文达拉扬和克里斯特林布尔的《超越理念》。他们认为，组织应该将精力从提出想法转移到执行上。在这篇文章中，我将谈论你可以做些什么来确保你可以执行你的数据科学和人工智能创新项目。

1。如果很复杂，创建一个独立的专门团队

许多组织渴望拥有“创新文化”。对他们来说，这意味着每个人都可以提出想法并付诸实践。现实情况是，人们有一份全职工作要做，这造就了今天的 P&L。这意味着你在要求人们“挤进去”。当达到季度收入目标的压力来临时，创新通常会落到最底层，进展可能会很慢。有些公司可以让它发挥作用；丰田被认为是最早创造持续改进文化的公司之一。很重要的一点是，要让这个模型中谁在做贡献，谁不在做贡献。但这些项目总是规模有限。你不能在某人的办公桌旁交付大规模的创新项目。

对于雄心勃勃的复杂创新，活动必须从 BAU 业务中分离出来。这并不是说 BAU 角色的人不能参与进来(事实上他们应该参与进来，因为他们提供了关于客户想要和需要的有价值的输入)，但是需要有一个专门的团队，有一个具体的计划。

这是我最常看到的错误；公司要求人们将创新项目作为案头工作的一部分，当 BAU 的优先事项接手时，项目不可避免地会夭折。

2。招到合适的人。

这听起来很明显——但是如果没有这个，我们还不如不谈其他的。对于这些项目来说，时间压力是不可避免的，并且很容易做出决定，让现有的过渡人员“同步”移动。如果你没有内部的技能，就去找外部的，即使找到合适的人需要更长的时间。有太多内部人士的创新项目将默认 BAU 的工作方式和现有的组织模式。不仅仅是技能，从外部招聘的个人自然会挑战现有的工作方式，他们更容易建立新的工作方式，因为他们不知道旧的工作方式是什么。当然，团队不能完全是外部的，因为他们不了解这个组织，但是 Govindarajan 和 Trimble 认为外部的人不应该少于四分之一。

3。任命正确的领导者

创新项目领导者的背景将显著影响所做的重点和决策。在数据科学领域，这通常意味着在技术/业务重点之间做出决定。在这篇文章中不可能回答什么是正确的，因为它取决于项目，但是有一个常见的陷阱要避免。无论你做什么，不要让别人把时间分配在领导 BAU 的工作和创新项目上。这是一件很有诱惑力的事情，但不可避免的是，经营 BAU 的方法不会带来创新。

4。创建新的指标/政策

如果像管理 BAU 业务一样衡量、评估和奖励他们，那么建立一个单独的团队就没有什么意义了。我见过一些组织没有落入第一个陷阱，而是成立了一个专门的团队来设计、构建一些新软件的原型。但该项目的领先优势仍然是根据他们 200 万英镑的销售目标来衡量的。几年后，软件产生的数据远不止这些，但在最初几年，这显然是无法实现的。考虑到浮动薪酬与销售目标如此紧密地联系在一起，这个人在领导这个项目上的表现要糟糕得多。

总的来说，创新项目的领导者应该得到更多的定性评估。更多的是他们经历的过程，而不是他们带来的结果。要寻找的关键事情包括快速学*，建立一系列实验，并使用这些实验的结果来调整计划(而不是直觉)。

5。不要惹恼 BAU 作战

作为一个敬业的团队，建立一种“我们对抗他们”的文化是一种诱惑。这不可避免地会造成紧张，而且是徒劳的。BAU 的业务产生收入，因此为创新买单，而创新很少与今天的业务完全无关。从个人角度来看，如果你是 BAU 业务的负责人，而一位同事不断提到“违反规则”，你很难不把它当成个人问题。不可避免的是，当打起来时，BAU 业务的经理总是会赢。一般来说，他们的级别更高，拥有良好的人际关系网，他们的压力是现在就实现收入。最有效的创新领导者意识到，要取得成功，他们需要与 BAU 的业务部门合作，并创造一种文化，在这种文化中，对现有利润中心不屑一顾是不可接受的。

大多数这些都是显而易见的，但当涉及到执行时，人们会让展示进步的压力影响他们，他们会屈服于当时容易的事情。如果你只做一件事，请人全职做这个项目，这是一个很好的开始！

参考文献

Govindarajan，v .和 Trimble，C. (2013) 超越理念:简单、强大的成功创新规则。

---

我喜欢为商业用户写关于数据科学的文章，我热衷于使用数据来提供切实的商业利益。

你可以在 LinkedIn 上与我联系，并在 Medium 上关注我，了解我的最新文章。

转变 Seaborn 数据可视化的 5 种方法

原文：https://towardsdatascience.com/5-ways-to-transform-your-seaborn-data-visualisations-1ed2cb484e38

数据可视化| Python | Seaborn

简单而容易的代码来增强你的 seaborn 散点图

卢卡斯摄影:https://www.pexels.com/photo/white-printer-paper-590011/

Seaborn 是一个流行的 python 数据可视化库，构建在 matplotlib 之上。尽管 matplotlib 是最流行的数据可视化库之一，但它有许多缺点。这包括需要更多的代码来创建高级图形。这就是 seaborn 的用武之地。它为 matplotlib 提供了一个高级接口，使得用简短的代码生成图表变得更加容易。

在本文中，您将发现 5 种不同的方法来快速转换您的 seaborn 数据可视化。你将看到如何从默认的情节到一个根据你的需要定制的，更具视觉吸引力的情节。

增强默认 seaborn 散点图之前和之后。图片由作者提供。

如果您经常使用 matplotlib，那么我建议您查看我以前的文章:

</7-simple-ways-to-enhance-your-matplotlib-charts-a232823efed9>

数据源

在下面的例子中，我们将看到如何用 seaborn 增强散点图。为此，我们将使用一个更大数据集的子集，该数据集曾被用作 Xeek 和 FORCE 2020 (Bormann 等人，2020) 举办的机器学*竞赛的一部分。它是在挪威政府的 NOLD 2.0 许可下发布的，详细信息可以在这里找到:挪威开放政府数据许可(NLOD) 2.0 。

完整的数据集可通过以下链接获得:https://doi.org/10.5281/zenodo.4351155。

本文中的所有示例都可以用于任何数据集。

导入库和数据

对于本教程，我们将需要导入， seaborn ， matplotlib 和 pandas 。

然后使用 pandas 方法read_csv()将数据读入数据帧。我们还将计算密度孔隙度(DPHI)栏，我们将使用它来绘制中子孔隙度(NPHI)。

这是可选的，并且只适用于这种类型的数据。

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as pltdf = pd.read_csv('data/Xeek_Well_15-9-15.csv')df['DPHI'] = (2.65 - df['RHOB'])/1.65df.describe()

当我们运行上面的代码时，我们用新的 DPHI 列得到下面的数据摘要。

Xeek / Force 2020 数据集中 15/9–15 井测井测量的统计总结。图片由作者提供。

创建起始地块

一旦我们的数据被加载，我们可以用一行代码创建一个简单的 Seaborn 散点图。x 轴将设置为 NPHI(中子孔隙度)，y 轴设置为 DPHI(密度孔隙度)，我们将颜色点设置为岩性。

sns.scatterplot(x='NPHI', y='DPHI', hue='LITH', data=df)

seaborn 生成的默认散点图显示岩性变化。图片由作者提供。

用这段代码生成的图看起来已经很合理了，可以直接用于快速可视化。然而，我们可以通过改变几个参数来进一步改进它。

设置 Seaborn 图的图形大小

我们首先要改变的是体型。目前，该地块看起来有点拥挤和狭小。

为了改变图形大小，我们将调用plt.figure()并传入一个figsize参数。

plt.figure(figsize=(7,7))
sns.scatterplot(x='NPHI', y='DPHI', hue='LITH', data=df)

更改图形大小后的 Seaborn 散点图。图片由作者提供。

生成的图感觉不那么狭窄，图例也位于不与任何数据点重叠的位置。

设置 Seaborn 打印样式

Seaborn 附带的功能允许您通过一个简单的调用来改变您的绘图风格。它允许自定义背景颜色，网格线颜色和刻度线。

Seaborn 内置了五个主题:

• 黑暗网格
• 白色网格
• 黑暗
• 白色
• 一会儿

为了使用这些主题，我们调用sns.set_style()并传递我们选择的主题。

sns.set_style('whitegrid')plt.figure(figsize=(7,7))
sns.scatterplot(x='NPHI', y='DPHI', hue='LITH', data=df)

使用 sns.set_style()应用 whitegrid 样式后的 Seaborn 散点图。图片由作者提供。

这里是不同风格的并列:

不同 seaborn 风格的插图。图片由作者提供。

设置 Seaborn 环境

默认情况下，标签尺寸在我们的图中显得很小。如果我们计划在一次会议的报告或海报上展示我们的情节，那么这些文字可能很难阅读。我们可以手动更改标题、轴和图例的字体大小，但如果我们很急，需要尽快使用，我们可以通过简单的调用来更改。

我们可以用 Seaborn 通过使用sns.set_context()函数并传入以下内容之一来控制这一点:

• 纸张(最小字体大小)
• 笔记本(笔记本中的默认大小)
• 讨论
• 海报(最大字体)

sns.set_style('whitegrid')
sns.set_context('talk')plt.figure(figsize=(7,7))
sns.scatterplot(x='NPHI', y='DPHI', hue='LITH', data=df)

使用 sns.set_context()应用“talk”上下文样式后的 Seaborn 散点图。图片由作者提供。

我们的图现在更易于展示，但是，我们需要通过将图例移到图的右侧来进一步调整它的样式，这样我们就不会模糊任何点。

设置颜色

Seaborn 使用的默认配色方案开箱即用，但是，如果我们想改变这一点，并将所有绘图的默认颜色设置为特定的颜色，该怎么办？

使用调色板

一种选择是指定一个自定义调色板，并应用 matplotlib 中许多可用的颜色映射之一。你可以在这里找到可用彩色地图的完整列表。

让我们把我们的彩色地图改成绿色。由于我们有 7 个类别，我们还可以为n_colors指定一个值。该色图对比高值和低值，同时保持一致性，并且是色盲友好的。

sns.set_style('whitegrid')
sns.set_context('notebook')
sns.set_palette('viridis', n_colors=7)plt.figure(figsize=(7,7))
sns.scatterplot(x='NPHI', y='DPHI', hue='LITH', data=df)

使用 sns.set_palette()应用 Viridis 颜色图后的 Seaborn 散点图。图片由作者提供。

定义自定义颜色

另一个选择是指定我们自己的配色方案。例如，也许我们有行业定义的类别颜色，我们希望保持这种配色方案。我们可以通过向sns.palette()传递一个颜色名称列表来实现。

可用颜色的完整列表可在这里找到。或者，如果我们找不到我们喜欢的颜色，我们可以提供十六进制的颜色。如果你想制作自己的调色板，我强烈推荐去看看 coolors.co。

sns.set_style('whitegrid')
sns.set_context('notebook')
sns.set_palette(['grey', 'salmon', 'blueviolet', 'blue', 'pink', 'teal', 'skyblue'])plt.figure(figsize=(7,7))
sns.scatterplot(x='NPHI', y='DPHI', hue='LITH', data=df)

使用 sns.set_palette()应用自定义颜色列表后的 Seaborn 散点图。图片由作者提供。

在 Seaborn 设置 X 和 Y 限制

你可能注意到了，我们的原点(0，0)是浮动的。这可以通过调用plt.xlim()和plt.ylim()并传入我们希望图形覆盖的最小和最大值来轻松解决。

sns.set_style('whitegrid')
sns.set_palette('viridis', n_colors=7)sns.set_context('notebook')plt.figure(figsize=(7,7))
sns.scatterplot(x='NPHI', y='DPHI', hue='LITH', data=df)
plt.ylim(0,0.8)
plt.xlim(0,0.8)

应用 x 轴和 y 轴限制后的 Seaborn 散点图。图片由作者提供。

现在我们的图形从原点开始看起来好多了。显然，如果我们的数据集中出现了负值，我们可能会在不希望出现负值的情况下对其进行调查。

摘要

在这个简短的教程中，我们看到了如何通过几个简单的调用来增强 Seaborn 生成的基本散点图。这不仅使一个更具视觉吸引力的情节，而且让我们能够控制它的可读性，为我们的目标观众。

增强默认 seaborn 散点图之前和之后。图片由作者提供。

感谢阅读。在你走之前，你一定要订阅我的内容，把我的文章放到你的收件箱里。 你可以在这里做！*或者，您也可以* 注册我的简讯 免费将更多内容直接发送到您的收件箱。

其次，通过注册会员，你可以获得完整的媒介体验，并支持我和其他成千上万的作家。每月只需花费你 5 美元，你就可以接触到所有精彩的媒体文章，也有机会通过写作赚钱。如果你用 我的链接报名，你直接用你的一部分费用支持我，不会多花你多少钱。如果你这样做了，非常感谢你的支持！

参考

博尔曼，彼得，奥桑德，彼得，迪里布，法哈德，曼拉尔，投降，&迪辛顿，彼得。(2020).机器学*竞赛 FORCE 2020 井测井和岩相数据集[数据集]。芝诺多。http://doi.org/10.5281/zenodo.4351156

使用 Seaborn 热图的 5 种方法(Python 教程)

原文：https://towardsdatascience.com/5-ways-to-use-a-seaborn-heatmap-python-tutorial-c79950f5add3

使用热图显示混乱矩阵、时间序列变化、温度变化、相关矩阵和 SHAP 相互作用值

(来源: flaticon )

热图可以让您的数据栩栩如生。百搭又抢眼。在许多情况下，它们可以突出显示数据中的重要关系。具体来说，我们将讨论如何使用它们来观想:

• 用于模型准确性的混淆矩阵
• 显示组间运动的时序数据
• 显示温度变化的时间序列数据
• 一个相关矩阵
• 平均值 SHAP 相互作用值

在此过程中，您将了解到定制热图的不同方法。我们将讨论创建它们的代码，你可以在 Github 上找到完整的项目。

首先，您可以观看此视频进行概述:

什么是热图？

让我们从讨论什么是热图以及为什么它们如此有用开始。你可以在图 1 中看到一个例子。y 轴上是变量 1。在这种情况下，变量 1 可以采用不同的 4 个值。即“V1-1”是变量 1 的第一个值。类似地，我们在 y 轴上有变量 2。还有第三个变量。这是每个单元格内的值。每个单元格的颜色由该变量的值决定。

图 1:示例热图(来源:作者)

因此，使用热图，我们能够可视化 2D 平面上 3 个变量之间的关系。这些关系可能很复杂。这就是使用颜色的原因。它可以突出关系的重要方面，使它们更容易理解。

我们应该记住，热图仍然是有限的。变量 1 和变量 2 需要是离散的或分类的。或者，如果它们是连续的，我们需要能够将它们分组。另一方面，变量 3 需要是一个连续的变量。希望在我们讨论下面的 5 个热图时，这一点会很清楚。

1)混淆矩阵

我们的第一张热图，在图 2 中，是混乱矩阵的可视化。这来自于一个用来预测一段文字语言的模型。y 轴给出了文本的实际语言。x 轴给出了模型预测的语言。对角线上的数字给出了正确预测的次数。非对角线给出了错误预测的数量。例如，英语(eng)被错误地预测为德语(deu) 11 次。

图 2:相关矩阵(来源:作者)

当你的目标变量有很多类时，像这样可视化一个混乱矩阵是很有用的。它可以突出模型哪里出了问题。例如，我们看到该模型最常混淆葡萄牙语(por)和西班牙语(spa) (124 次)或西班牙语和葡萄牙语(84 次)。这是有道理的，因为在所有的语言中，这两种语言在词汇上是最相似的。

热图代码

要创建此热图，我们首先要导入下面的包。热图函数来自 seaborn 包(第 6 行)。我们将对所有 5 个热图使用相同的包。确保您已经安装了它们。

我们有一个 2D 阵列用于填充下面的热图。这些给出了正确和错误预测的数量。您可以看到第一个子阵列(第 2 行)对应于图 2 中热图第一行的值。所有热图都是使用类似于此图的 2D 阵列填充的。如果您需要将此代码用于另一个热图，您可以用您的 2D 阵列替换此混淆矩阵。

现在，我们已经对 2D 数组进行了硬编码。下面的文章将带你了解我们是如何得到这些数字的。总而言之，我们已经使用 NLP 技术建立了一个神经网络。然后，我们使用这个模型来预测测试数据集中的文本语言。你在上面看到的数字来自这些预测。

使用这个 2D 数组，我们创建一个熊猫数据帧( conf_matrix_df )。我们使用不同的语言作为列名和行名。

最后，我们使用 seaborn heatmap 函数(第 5–9 行)来可视化这个数据帧。除了 conf_matrix_df， 我们还传递了几个参数。 cmap 给出配色方案。将此设置为“冷温”会为我们提供红色和蓝色单元格。将 不能 设置为 true 会给出每个单元格中的数字。没有它，我们就只有颜色。 fmt 定义了颜色的格式。在创建其他热图时，我们将看到这些参数的一些变化。

最后一个参数是VMAX。这定义了色标的最大值。如果您没有为此参数传递值，它将默认为热图中的最大值。在这种情况下，它是正确的法语(fra)预测数(即 4999)。我们将该值设置为 200，因为这样更容易区分不正确的预测。你可以在图 3 中看到我们的意思。此热图是使用 vmax 的默认值创建的。

图 3:没有 vmax 的关联矩阵(来源:作者)

2)群体间的运动

我们的第二张热图展示了我们如何可视化分类变量随时间的变化。具体来说，我们显示了美国城市的空气质量指数(AQI)。y 轴表示 2010 年的空气质量指数水平，x 轴表示 2016 年的水平。单元格值给出了从一个级别移动到另一个级别的城市的数量。例如，我们可以看到 20 个城市从不健康(敏感人群)水平改善到中等水平。

图 4:一段时间内的空气质量指数水平(来源:作者)

AQI 是 0 到 500 之间的值。数值越高，空气污染程度越高。空气质量指数是使用 4 种不同的污染物计算的——二氧化氮(NO2)、二氧化硫(SO2)、一氧化碳(CO)和臭氧(O3)。具体来说，为了得到最终的空气质量指数，我们取这 4 种污染物的最大空气质量指数。在图 5 中，您可以看到不同关注级别的 AQI 范围。我们在热图中使用了这些级别。

图 5:空气质量指数水平(来源: AirNow

为了创建热图，我们首先加载数据集(第 2 行)。你可以在 Kaggle 上找到这个数据集。每天都有读数。我们只对阅读的年份感兴趣。因此，我们创建了一个包含阅读年份的列(第 5–6 行)。

这是一个 x 轴和 y 轴上的变量最初是连续变量的例子。如前所述，我们需要对这个变量进行分组。下面的 aqiGroup 函数就是用来做这个的。它将根据 AQI 值返回一个级别。它使用与图 5 中相同的范围。

为了得到最终的 2D 矩阵，我们需要做一些数据处理。我们首先使用 4 种污染物的值计算 AQI 值(第 2 行)。然后对于每个城市，我们计算每一年的最大 AQI(第 5 行)。因此，您在热图中看到的数值实际上是基于 2010 年和 2016 年的最大 AQI 值。最后，我们使用 aqiGroup 函数对 AQI 值进行分组(第 8 行)。

我们得到了 2016 年(第 2-3 行)和 2010 年(第 6-7 行)的所有 AQI 值。然后我们连接这些表(第 10 行)。在某些情况下，一个城市可能一年有一个读数，而另一年没有。在这种情况下，我们用“无读数”替换丢失的值(第 11 行)。这个最终数据集 AQI 将包含每个城市在 2016 年和 2010 年的水平。

好了，现在我们有了这个数据集，我们可以用它来创建 2D 数组， hm_array 。这用于填充热图。这将与我们在第一个热图中看到的硬编码阵列具有相同的结构。该数组是在第 6 到 12 行创建的。其中，对于每个级别组合，我们计算 AQI 数据集中的记录数(第 10-11 行)。和以前一样，我们使用这个 2D 数组创建一个数据帧。我们使用 AQI 级别作为列名和行名。

最后，我们像以前一样创建热图。这次我们有不同的参数值。我们使用了不同的配色方案， cmap 。我们已经将 cbar 设置为 false。这隐藏了颜色栏。我们还使用了 线宽 和 线条颜色 参数来给出热图的黑色网格线。

3)温度随时间变化

类似于上一个热图，我们用这个来可视化时间序列数据。除了现在，我们展示了一个连续变量是如何随时间变化的。在图 4 中，您可以看到一段时间内的全球平均气温。从 1900 年到 2016 年每个月都有读数。在接下来的几个月里，你可以清楚地看到气候变化的影响。也许我们对“热图”这个术语的理解有点过于字面化了。

图 6:一段时间内的平均温度(来源:作者)

我们从加载数据集开始(第 1 行)。你可以在[数据中心]找到这个。数据集包含两个不同的温度读数来源。我们只选择 GISTEMP 读数(第 4 行)。然后我们为每个读数创建一个年和月的列(第 7-9 行)。

与之前一样，我们创建了一个用于填充热图的 2D 阵列。在之前的热图中，所有 2D 阵列都是对称的。情况并不总是如此。对于此热图，每个月都有一个子阵列(即 1 到 12)。这些子数组中的每一个都将包含从 1900 年到 2016 年每年的温度值。所以我们现在有一个 12x117 的阵列。我们用年份作为列名，用月份作为行名来创建一个数据帧。

我们像以前一样想象这个数据帧。最大的不同是我们将xtick labels参数设置为 10。这意味着只显示 x 轴上的第 10 个标签。您可以在图 6 的中看到这一点，其中只有 1900、1910、1920 等的标签..被显示。

4)相关矩阵

我们的第四张热图可能你已经看过了。一个常见的用途是可视化数据集中的相关性。例如，我们在图 7 中有一个房价数据集的相关矩阵。我们可以利用这一点来确定任何可能在我们的模型中引起问题的多重共线性。例如，X3 和 X4 呈负相关。最后一行还给出与目标变量 y 的相关性。我们可以利用这一点来了解是否有任何特征与 y 有显著关系。

图 7:相关矩阵(来源:作者)

为了创建这个热图，我们首先加载数据集(第 2 行)。你可以在 UCI 的机器学*知识库中找到它。使用这个数据集，我们创建一个相关矩阵(第 5 行)。结果将是一个熊猫的数据框架。列名和行名将与数据集中的要素名相同。

您可能已经注意到，在图 7 中，对角线上方的单元格是空白的。为此，我们首先需要创建一个遮罩。这是一个 2D 阵列，类似于我们用来填充以前的热图的阵列。对于要显示的单元格，数组的值应为“True”。否则，对于空白单元格，它们应该为“False”。我们使用下面的代码来创建遮罩。

最后，我们可以显示我们的热图。这一个的唯一区别是我们需要将掩码作为参数传递(第 8 行)。

5) SHAP 互动价值观

我们最后的热图可用于突出显示对模型预测很重要的特征。它是通过取平均 SHAP 相互作用值产生的。它在对角线上显示了平均主效应。比如我们可以看到，对于体验、学位、性能、销量，主效应大。类似地，平均相互作用效应在非对角线上。我们可以看到，体验、程度和绩效、销售互动的影响是显著的。

图 8:平均 SHAP 互动值(来源:作者)

我们不会讨论用于创建该热图的代码。如果你感兴趣，你可以在下面的文章中找到它。我们深入研究 SHAP 互动价值观。我们还使用这些值创建和解释其他图。这些用来解释你的机器学*模型。

我希望这篇文章对你有帮助！如果你想看更多，你可以成为我的 推荐会员 来支持我。你可以访问 medium 上的所有文章，我可以得到你的部分费用。

https://conorosullyds.medium.com/membership

你可以在|Twitter|YouTube|时事通讯上找到我——注册免费参加 Python SHAP 课程

图像来源

所有图片都是我自己的或从www.flaticon.com获得。在后者的情况下，我拥有他们的保费计划中定义的“完全许可”。

数据集源

热图 2，来源:美国污染数据，许可证:开放数据库许可证(ODbL) 1.0

热图 3 ，来源:全球气温时间序列，牌照:ODC-PDDL-1.0

热图 4 ，来源:房地产估价数据集数据集，牌照:CC0:公共领域

将直方图与机器学*算法结合使用的 5 种方法

原文：https://towardsdatascience.com/5-ways-to-use-histograms-with-machine-learning-algorithms-e32042dfbe3e

从特征工程的角度来看

机器学*的直方图特征工程(图片由作者提供)

特征工程是使用领域知识来创建使机器学*算法更好工作的特征的过程。这是应用机器学*的一个关键部分，通常是成功和不成功项目的区别。

另一方面，直方图被认为是数据预处理的第一步。这是用简单的基础进行数据探索的必要步骤:它总结了您的观察结果，并以简洁的方式呈现出来。

但是我们如何从直方图中提取特征呢？

让我们看看五种可以帮助我们提取特征的方法，这些特征可以使我们的模型更加健壮和高效。

测量直方图之间的距离

距离测量用于确定两个物体有多相似或不相似。它是许多机器学*算法中的关键元素。要素向量之间的距离函数为您提供了一种评估数据集中两个对象是否相似的方法。

换句话说，它为您提供了评估两个特征之间相似程度的标准。

测量距离有许多不同的方法，每种方法都有自己的优缺点。最常见的距离度量是欧几里德距离、曼哈顿距离和余弦相似性。

但是直方图之间的距离呢？

还有很多方法:库尔贝克-莱布勒散度，卡方统计，指数散度，海灵格距离，沃瑟斯坦距离…

两个直方图之间距离的图示(图片由作者提供)

后者是概率测度空间中非常自然的度量。这是一个非常通用的度量标准，用于测量将一个直方图改变为另一个直方图所需的“工作量”,并可用于比较不一定相同的分布。

归一化直方图

规范化数据非常重要，因为这有助于提高使用要素的算法的性能。当数据被归一化时，这意味着数据中的所有要素都在相同的比例上。

一些算法对数据的规模很敏感，规范化数据甚至可以帮助一些算法更快地收敛到一个解决方案。

介于 0 和 1 之间的归一化直方图(图片由作者提供)

但是归一化直方图还有其他原因:

1. 以确保数据均匀分布。
2. 以确保所有数据可见。
3. 使数据集之间的比较更容易。

更改宁滨方案

对于对高维特征向量敏感的机器学*算法，我们可以通过简单地使用较少数量的箱或较小范围的值来减少维数。

宁滨计划主要有两种类型:

• 等宽宁滨:在等宽宁滨中，每个箱子的宽度是相同的。这是最常见的宁滨。
• 等频宁滨:在等频宁滨中，每个箱包含相同数量的数据点。

等宽(左)和等频(右)宁滨示例(图片由作者提供)

还有其他类型的宁滨计划，但这是两个最常见的。等宽宁滨是最常见的宁滨类型，因为它最容易实现，也最容易理解。

然而，等频率宁滨可能更有效，因为它确保每个箱包含相同数量的数据点。

将直方图分成几部分

有几个原因可以解释为什么要将直方图分成几个部分。一个原因是，如果将两个或多个直方图分成几个部分，比较它们会更容易。

直方图分割示例(按作者分类的图像)

这是因为当数据被分成几个部分时，数据中的模式或趋势会变得更加明显。

例如，人口身高直方图可以按地理区域划分，并可能显示不同国家的身高分布不同。

组合直方图

这最后一部分非常具体。我举个例子解释一下。假设我们有一个图片数据集，我们想用方向梯度直方图进行分析，但是我们也想根据它们的颜色分量来分离数据。

两个组合直方图的示例

在这种情况下，我们可以将方向梯度直方图与颜色直方图结合起来，如下所示。

• 猪:[0.01，0.02，..]
• 颜色直方图:[0.02，0.03，..]
• 合计:【0.01，0.02，..,0.02, 0.03, ..]

我们可以连接两个直方图，甚至给每个直方图增加权重，以给予一个直方图或多或少的重要性:

• 结合权重:【0.01w1，0.02w1，..，0.02w2，0.03w2，..]

结论

为了更好地理解直方图所代表的数据，有多种方法可以操作直方图。通过测量直方图之间的距离，我们可以知道它们有多相似或不同。

我们还可以归一化直方图以便更容易地进行比较，更改宁滨方案以便更好地可视化数据，或者将直方图分割成几个部分以便更好地理解数据分布。

最终，我们可以将直方图结合在一起，形成可以帮助我们解决非常具体的机器学*问题的特征。

好奇想了解更多关于 Anthony 的工作和项目吗？在中、 LinkedIn 、 Twitter 上关注他。

需要技术作家？将您的请求发送到https://amigo CCI . io。

5 个网站下载预先训练好的机器学*模型

原文：https://towardsdatascience.com/5-websites-to-download-pre-trained-machine-learning-models-6d136d58f4e7

不需要训练机器学*模型，只需下载一个预先训练好的模型，让其他人来做繁重的工作

从计算机视觉到自然语言处理(NLP ),机器学*模型似乎每年都在各种任务和领域中实现更高的准确性。)为了做到这一点，在公司和研究机构工作的科学家和工程师会修改模型的架构，通常会使它们变得更加复杂，并使用令人印象深刻的大量数据来训练它们。举个例子，来自 OpenAI 的最新 NLP 模型，GPT-3，有1750 亿个参数(是的，那是一个 b)，在一台机器上训练它需要大约 355 年。但即使训练更简单的模型也可能很难:获得足够的数据以实现良好的性能通常是一个很大的挑战。这使得个人甚至小公司很难使用这些 ML 模型，如果他们不得不从头开始训练它们的话。

让别人帮你做这些繁重的工作约翰·阿拉诺在 Unsplash 上拍摄。]

幸运的是，我们可以通过使用预先训练的 ML 模型来解决这个问题。这已经成为 ML 中事实上的新趋势，理由很充分:它不仅节省了时间和金钱，而且意味着您将要使用的模型已经过测试，并且实现了非常好的(如果不是最先进的)性能。然而，找到预先训练的模型并不容易，因为还没有太多公开可用的资源。

这就是为什么我列出了我认为最好的 5 个下载预训练模型的网站。我真诚地希望这能帮助任何对使用 ML 感兴趣的人，如果是你，请在下面的评论中告诉我。没有任何进一步的行动，让我们从列表开始。

模型动物园

这可能是当今最受欢迎的预训练 ML 模型库。Model Zoo 有一个很好的、易于使用的界面，在其中你可以搜索可用的模型，通过关键词、任务和框架进行过滤。可以找 Tensorflow，PyTorch，Caffe 等几款。大多数模型都发布在 Github 上，所以你也可以在那里看到它们的许可和要求。

模型动物园可能已经成为预先训练的 ML 模型的最受欢迎的储存库。]

TensorFlow —模型&数据集

Tensorflow 提供了另一个受欢迎的资源。在这里，您可以找到:

• TensorFlow hub，tensor flow 的预训练模型库。
• 模型花园，一个用预先训练好的模型和例子创建的 Github 库。
• TensorFlow.js models ，可以在任何网络浏览器上运行的 TensorFlow 模型集合。

当然，这里的限制因素是所有这些模型都只能在 TensorFlow 上运行，所以如果您使用 PyTorch，请进入下一部分。

PyTorch Hub

PyTorch 也有一个专门用于预训练模型的部分，称为 PyTorch Hub(不是一个非常原始的名称，但是嘿，这不是这里重要的。)在这里，您可以按类别过滤模型，也可以使用关键字搜索模型。对于每个模型，您都可以找到简短的描述和使用说明，包括代码。

PyTorch Hub 包括使用每一个已发布模型的代码，甚至给你在 Google Colab 上使用的选项。]

证件代码

《带代码的论文》并不仅仅关注 ML 预训练模型，在这里还可以找到几个最先进的 ML 模型。该网站允许我们在大量已发表的论文中进行搜索，这些论文与它们的代码实现一起发布。你可以为你喜欢的任何任务和任何框架找到模型。不过筛选模型并不像前面三个网站那么容易，但是这个网站一个非常好的地方就是有代码的论文通常会先发布最新的 ML 模型。另外，你还可以找到与论文一起发表的数据集。

有代码的论文【图片由作者提供。]

抱紧脸🤗

最后，🤗本质上可能不是一个预训练的 ML 模型目录，但它确实包括几个用于 NLP 的预训练模型，范围从情感、机器翻译、摘要等等。另外，因为🤗实际上是一个 Python 库，一旦你安装了它，你只需要调用一个函数就可以使用所有包含的模型，非常方便易用。说到 NLP，🤗永远是我的首选。我也不得不承认我喜欢它的名字(或者实际上是它的表情符号。)

🤗是我最喜欢的 NLP 库【图片作者。]

还有一点

您可能已经注意到了，这些站点中的大多数会将您重定向到 github 存储库。Github 确实是你能找到的最大的预训练模型库。这意味着你可以随时在 Github 上搜索预先训练好的模型，并可能找到许多选项可供选择。

当然，你也可以找到很多其他的软件，但是软件仓库的质量没有保证。之前的网站的附加价值是他们已经选择了 Github 库，所以如果你决定直接在 Github 中搜索，你必须耐心找到你要找的东西。作为一个建议，总是检查项目中最后一次提交的日期，以查看项目的维护情况，并检查项目发布时使用的许可证。

其他有用的资源

• 如果您仍然想从头开始训练您的 ML 模型，那么您将需要一个好的数据集来完成这项工作。我用不同的数据集资源写了这篇文章，你可能会觉得有用。

</10-free-resources-to-download-datasets-for-machine-learning-2acfff33822>

• 用 Python 进行深度学*:如果你想用 Python 学*更多关于 ML 应用和模型的知识，这本书就是为你准备的！由 Keras 的创建者编写，它以实用的方式教授如何开发和部署 ML 模型。

https://www.amazon.com/gp/product/1617294438/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1617294438&linkCode=as2&tag=maufadel01-20&linkId=d59ef4f3727a9fa715dbac0fe6693b5e

5 个窗口函数示例，让您的 SQL 技能更上一层楼

原文：https://towardsdatascience.com/5-window-function-examples-to-take-your-sql-skills-to-the-next-level-2b3306650bb6

数据科学

如果你想掌握 SQL 中的数据操作，你需要理解窗口函数

照片由 Pexels 的 M Venter 拍摄

为了达到 SQL 的下一个专业水平，理解窗口函数是很重要的。窗口函数起初看起来令人生畏，但是一旦你理解了它们，你会发现它们有许多不同的应用。在我分享我的例子之前，我想为那些可能不熟悉的人解释一下它们是什么。我希望在这篇文章结束时，你将会探索在你自己的工作中使用窗口函数的方法。如果你已经熟悉了窗口函数，可以直接跳到第三个例子。

我分享的例子是我职业生涯中最常用的窗口函数，所以希望它们也适用于你的工作。

我将使用这个 SQLite 沙盒数据库作为我的代码示例:【https://www.sql-practice.com/

什么是窗口功能？

窗口函数是对数据集的多行执行计算，同时保持原始表的相同行数和行数的函数。

1。你的第一个窗口函数

在试图理解窗口函数时要记住的主要事情是，窗口函数维护表的原始行。对于我的第一个例子，我使用的查询与我在上一篇文章中写的关于在您的数据生涯中使用 SQL 技巧的查询相同。

这个例子是我想象的窗口函数的一个简单的用例。也就是说，如果你能掌握第一个例子，你就能把这个模式应用到很多不同的用例中。你掌握 SQL 中数据操作的能力一定会向前迈进一大步。

首先，我将解释上述窗口函数的输出是什么。输出将为您提供相同数量的行，并且您的最终列将是城市的最大权重。这意味着如果一个城市出现不止一次，那么权重值将会重复。这种重复经常发生在窗口函数中，因为我们在执行聚合时没有折叠表中的任何行。

下面是另一个查询，它给出了与上面完全相同的结果，只是时间更长，计算量更大。希望这能帮助你理解窗口函数的作用。

具体来说，一个典型的窗口子句将如下所示:

结束(

窗口函数可以是聚合窗口函数，也可以是内置窗口函数。下面是您可以使用的聚合函数的列表。你很可能已经熟悉这些。

下一部分是增加“T4”条款。 如果它没有 over 子句，那么它就不是窗口函数。

over 子句位于窗口定义之前。在这种情况下，我们使用 partition by。现在不要担心其他的窗口定义。最常见的两种是按划分的和按排序的，这就是我在本文中要介绍的全部内容。您可能已经猜到了， partition by 指定了聚合的级别。在这种情况下，我们告诉查询我们想要城市的最大权重。

就这样，这是你的第一个窗口函数🙌

2.真正最简单的窗口功能

好了，现在我们已经完成了你的第一个窗口函数，我想让你的大脑休息一下，让第二个例子变得非常简单。

当您不包括窗口定义时，您将对整个表进行聚合。这在特殊情况下会派上用场，所以我想我会快速展示一下，这样它就在你的脑海中，供你以后工作时使用。

下面是不带窗口函数的等效查询。

3.介绍“按窗口排序”定义

既然我们已经介绍了窗口函数的基本知识，我想介绍第二个窗口定义:ORDER BY。这正如它的名字所暗示的；它根据您选择的列对表格行中的数据进行排序。

在上面的例子中，这个窗口函数是按日期计算入院人数的累计。我不会为此包含一个等价的，因为我不认为不使用窗口函数就能做到这一点。这就是为什么我在文章的开头说窗口函数会让你在 SQL 中的数据操作技巧更上一层楼。

4.ROW_NUMBER 窗口函数

对于第四个例子，我想结合您到目前为止所学的一些内容，同时还添加了行号窗口功能。到目前为止，我只为第一个函数包含了聚合窗口函数，因为这是最简单的窗口函数子句类型，但是也有内置的窗口函数可用(确切地说有 11 个)。

本例中唯一的新概念是窗口函数开头的 row_number()函数。这将根据窗口定义分配一个连续的数字。在这种情况下，我们的定义是希望按城市分区，按出生日期降序排序。

如果你仍然不确定如何形象化这一点，这里是我在开始链接的 sql 实践网站的链接:https://www.sql-practice.com/。在该网站中键入删除了 where 子句的 SQL 代码，以了解发生了什么。

该查询回答的问题是，“每个城市中第二年轻的患者是谁？”。您也许能够轻松地编写一个等价的查询来查找每个城市中最年轻的患者，但是第二个或第三个呢？窗口函数使得一些困难的问题变得简单得多。

5。滞后和超前窗口功能

该窗口函数回答以下问题，“每个患者与下一个最高的人相比，身高有什么不同？”。

显然，这只是一个例子，寻找高度差异可能不是一个现实的问题，但有很多使用情况下，与数据集中的前一行进行比较是有用的-股票是一个常见的例子。

Lag 获取前一行的值并将其放在当前行上。默认的滞后是 1 行，但是您可以在 lag 函数中选择列之后立即指定该参数。

超前和滞后类似，只是作用方向相反。它获取下一行并将值放入当前行进行比较。

结论

这是窗口功能的概述。我希望它对您提高 SQL 技能有所帮助。如果你想要一个更高级的关于窗口功能或者我在这里没有提到的东西的教程，请在评论中告诉我。此外，如果你觉得有一个 SQL 主题你想了解更多，也请让我知道。

要阅读关于窗口函数的其他详细信息，请参考 SQLite 窗口函数文档。

https://medium.com/@andreasmartinson/membership

如果你喜欢这篇文章，请在 LinkedIn 上联系我，或者看看我的另一个故事:

</10-quick-sql-tips-after-writing-daily-in-sql-for-3-years-37bdba0637d0>

参考文献

1. sql-practice.com，SQL Practice.com
2. 内置聚合函数，SQLite 文档
3. 窗口功能，SQLite 文档

每个用户都应该知道的 6 个大查询 SQL 函数

原文：https://towardsdatascience.com/6-bigquery-sql-functions-every-user-should-know-9ed97b1cf72e

检查您的数据库是否也有它们

照片由来自佩克斯的克里斯蒂娜·莫里洛拍摄

在我的上一篇文章中，我讨论了可以简化查询的 4 大查询 SQL 快捷方式。从那时起，我发现了 6 个更有用的 SQL 函数，我希望我能早点知道，今天我想和大家分享一下。

1.生成数组

GENERATE_ARRAY 函数允许您创建一个数组，其起始值和结束值以步长值递增。如果您想要生成一系列具有特定序列的数字，这将非常有用。注意，查询结果只有一行数据，因为值在一个数组中。

作者创建的 GENERATE_ARRAY 查询示例的屏幕截图

2.生成日期数组

与 GENERATE_ARRAY 类似， GENERATE_DATE_ARRAY 函数允许您按步长间隔创建一个日期数组。如果您需要创建一系列具有特定间隔的日期，这将非常有用。我使用下面的 1 天间隔创建了 14 个日期，但是您可以使用 BigQuery 支持的任何间隔，例如周、月和年。

作者创建的 GENERATE_DATE_ARRAY 查询示例的屏幕截图

3.UNNEST

函数允许你为一个数组的每个值创建行。UNNEST 可以与 GENERATE_ARRAY 或 GENERATE_DATE_ARRAY 一起使用。当我需要一个日期的主列表来连接时，这个函数非常有用，这样可以确保我查询的时间段内的所有日期都有值。

在下面的查询中，我创建了一个名为 two_weeks 的 CTE ，然后对名为 date_array 的结果数组列使用 UNNEST 函数来创建每个日期的一行。为了让 UNNEST 正确工作，您必须在从和中查询的****或表名后添加一个逗号** ，然后在数组列上调用的 UNNEST 函数。注意，查询结果显示了 14 行，表明 UNNEST 为 date_array 中的每个日期创建了一行。**

作者创建的 UNNEST 查询示例的屏幕截图

4.最后一天

LAST_DAY 函数返回给定日期的当月最后一天。如果您需要提供一个月的最后一天来进行报告，这将非常有用。

在下面的查询中，我使用包含 2022 年每个月的第一天的 GENERATE_DATE_ARRAY 创建了一个名为 one_year 的 CTE，然后调用 LAST_DAY 函数来创建包含该月最后一天的第二列。查询结果显示 2022 年每个月的开始和结束。

作者创建的最后一天查询示例的屏幕截图

5 / 6.最小和最大

****最小返回一组值或列中的最小值，而最大显示最大值。注意，如果任何参数为空，则返回空值。

在下面的例子中，我使用了最小和最大函数来返回样本表 test_greatest_least 中 3 列的最小和最大值。请注意，最小和最大与最小和最大函数有何不同，后者查看表中一列的所有行。这里， col_a 上的 MIN 和 MAX 将返回 0 作为 10 行中的最小值，MAX 将返回 5。

作者创建的最小和最大查询示例的屏幕截图

最后的想法

虽然我提到的函数在 BigQuery 中可用，但 LAST_DAY、GREATEST 和 LEAST 等一些函数在 Redshift 和 Snowflake 等其他数据库中也可用。如果你有几分钟的时间，我强烈推荐阅读你的数据库文档，因为你永远不知道你可能会发现有用的功能。

注意:以上所有的查询都是在 大查询沙箱 上运行的，这对任何拥有谷歌账户的人来说都是免费的。

你可能也会喜欢…

**</4-bigquery-sql-shortcuts-that-can-simplify-your-queries-30f94666a046> **

机器学*初学者常犯的 6 个错误以及如何避免

原文：https://towardsdatascience.com/6-common-mistakes-machine-learning-beginners-make-and-how-to-avoid-them-b1f774d06838

我在旅途中犯过的错误，以及你如何避免在开始时像我一样

来自 Unsplash 的照片由 Lala Azizli 拍摄

机器学*是一个热门话题，越来越受欢迎。很容易理解为什么:AI 和机器学*正在接管！

然而，对于那些刚刚起步的人来说，这可能是无法承受的；关于这个问题有如此多的信息。

我自己在刚开始学*机器时也犯过一些错误，但我在这里告诉你如何避免这些错误。

在这篇博文中，我将讨论初学者在机器学*中会犯的 6 个常见错误，以及如何避免它们！

1.没有先清理您的数据

在开始之前清理数据是非常重要的。如果不首先清理数据，将更难做出任何与机器学*相关的决策，因为数据集中包含了所有“嘈杂”的特征。

例如，如果您的一列有一个字符串值，如“red ”,但另一列只有数值，则此功能可能有问题。

此外，您还想删除分类变量或用其他数字变量替换分类变量——毕竟，我们在进行机器学*时主要与数字打交道！

对于丢失的数据也是如此:不要只删除那些某些特性缺少条目的行；相反，尝试根据它们的整体分布(或类似的东西)使用平均值/模式值来估算它们。

清理数据可以让你做出更准确的预测——从而帮助你避免那些讨厌的错误！

要了解如何清理你的数据，你可以看看下面的帖子:

2.忽略异常值

离群值会对你的机器学*模型产生巨大的影响，所以不要忽视它们是很重要的。

有时它们只是由于数据中的噪声，但其他时候它们可能表示更严重的事情(如欺诈)。如果你不小心，这些异常值会完全扭曲你的结果，给你不准确的预测。

有几种方法可以处理异常值:

• 将它们从数据集中移除
• 使用 Box-Cox 变换或中值滤波等方法对它们进行变换
• 使用稳健的估计值，如中位数或修整均值，而不是常规均值

如何选择处理异常值实际上取决于您的数据和您试图执行的分析类型。但不管怎样，你都应该时刻意识到它们，并把它们考虑进去！

要了解如何检测和处理异常值，请查看下面的帖子:

https://www.analyticsvidhya.com/blog/2021/05/detecting-and-treating-outliers-treating-the-odd-one-out/

3.从庞大的数据集开始

当你第一次开始机器学*时，从庞大的数据集开始总是很诱人的。毕竟，你的数据越多，你的模型就越好，对吗？

嗯……不一定。

事实上，从太多的数据开始实际上对你的模型是有害的。这是因为在大型数据集上训练模型需要时间和资源，如果您的模型不能准确预测结果，您将不知道哪些特征实际上是重要的(因为将包括如此多的特征)。

因此，不要从一个庞大的数据集开始，而是尝试将其分成更小的块，并在每个块上训练不同的模型。一旦你找到了一个表现良好的模型，你就可以通过增加数据集的大小来扩大规模。

这种方法将帮助您避免过度拟合，这在处理大型数据集时可能是一个巨大的问题。

要了解如何处理不同大小的数据，请查看下面的帖子:

</17-strategies-for-dealing-with-data-big-data-and-even-bigger-data-283426c7d260>

4.过度拟合

过拟合是初学者在训练机器学*模型时面临的巨大问题。当您的模型过于特定于它所训练的数据时，就会发生这种情况-换句话说，如果您在具有大量要素和异常值的小型数据集上训练您的模型，那么一旦您将它应用到不存在这些变量的真实生活情况中，就不知道它会有多好！

为了避免过度拟合，请尝试使用交叉验证，而不是仅使用一个数据集进行分析。交叉验证允许您将数据分割成更小的块，以便每个块可以用作独立的测试集(这减少了过度拟合的机会)。这种方法对我来说创造了奇迹。

如果你仍然有过度拟合的问题，那么尝试使用更复杂的技术，如 boosting 或贝叶斯推理。这些方法将帮助您构建不太可能受过度拟合影响的模型。

要了解如何应对过度合身，请查看下面的帖子:

</8-simple-techniques-to-prevent-overfitting-4d443da2ef7d>

5.不懂基本的数学

这一点非常不言自明——如果你不理解机器学*背后的基本数学，那么你将很难正确实现它。

幸运的是，这可以通过参加一些在线课程或阅读相关内容来轻松解决。相信我:了解线性回归和矩阵运算的基础知识会让你的生活变得轻松许多！

一旦你很好地掌握了数学概念，试着将它们应用到一些现实世界的问题中。这是你真正开始学*一切是如何工作的地方。

要了解数据科学的数学知识，请查看下面的帖子:

6.坚持只有一种模式

当你第一次开始机器学*时，尝试建立一个能做所有事情的模型是很有诱惑力的。然而，这通常是失败的原因——因为不同的模型擅长预测某些事情(而对其他事情则很糟糕)。

例如:在对特征之间没有明显相关性的分类数据进行预测时，决策树往往表现良好。但当试图进行数值预测或解决回归问题时，它们并不十分有用。

逻辑回归适用于数字，但不适用于分类数据…这只是两个不同算法表现的例子！因此，如果你希望你的模型有最好的机会准确，那么对每个问题使用多种类型的分析，而不是只坚持一种。

这种方法也将帮助您避免过度拟合，因为您将有几个模型进行比较和对比。

要了解不同的模型，你可以看看下面的帖子:

</6-predictive-models-models-every-beginner-data-scientist-should-master-7a37ec8da76d>

今天开始练*

现在你知道了——初学者在开始机器学*时会犯的五个错误，以及如何避免它们！记住这些提示，你很快就会成为一名机器学*专家。

与 5k 以上的人一起加入我的电子邮件列表，免费获得“完整的 Python 数据科学小抄手册”

需要警惕的 6 个数据谬误

原文：https://towardsdatascience.com/6-data-fallacies-to-watch-out-for-74866fd20d2

数据素养

了解这些常见的逻辑陷阱将有助于您避免在分析中犯错误

在最*的一篇文章中，我从读写能力的一般定义开始定义了数据读写能力，并将其应用于数据世界:

这篇文章遵循类似的思路——它的灵感来自我在高中学到的逻辑谬误。如果你在论证推理中会犯逻辑错误，那么你在数据分析和统计推理中也会犯逻辑错误。

Geckoboard 的这篇博文是我研究的一个有用的起点:

https://www.geckoboard.com/best-practice/statistical-fallacies/

从那以后，我陷入了我经历最多的几个谬误。我为这篇文章挑选的六个是容易犯的常见错误。因此，请继续阅读，了解更多关于处理数据时可能会陷入的逻辑陷阱。

为了给每个谬误的解释增添一些色彩，我加入了我自己的经历，并从网上各种来源找到了一些有趣的例子。

收集数据时出现的错误

在进行分析之前，您需要数据！如果你必须自己收集数据，这里有一些要避免的谬误。

观察者效应(又名霍桑效应)

当你被人注视时，你的表现会有所不同吗？我知道我有。如果研究人员不小心，这种人类倾向会影响他们的数据。当观察者的存在或被观察的知识影响到收集的数据时，就会发生观察者效应。

作为一名工业工程实*生，我经常思考这个问题，因为我被要求收集生产线上的时间研究数据。我非常清楚，如果员工知道我在给他们计时，他们的表现可能会与平时不同(即使我明确表示我的测量并不是为了以任何方式评估他们的表现)。

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

这是制造环境中的另一个例子:

“当时，西部电气公司是美国电话电报公司唯一的电话设备供应商，霍桑工厂是一家技术先进的工厂，员工约 35，000 人。这些实验旨在研究照明水平对输出的影响。这一假设得到了发展，研究人员对不同的工人群体进行了研究，以了解不同的照明水平、清洁程度或工作站的不同位置是否会影响产量。

主要的发现是，无论工人面临什么样的变化，产量都会提高。但是，生产在研究结束时恢复正常。这表明被监视的员工工作更加努力。"[ 1

抽样偏误

抽样偏倚是指当您收集数据的样本总体不能代表您想要得出结论的总体时。获得有代表性的样本并不总是容易的——这会花费额外的时间和金钱。但是如果这些数据被用来做决定，而这些决定会影响你的样本人群之外的人的生活，那么你必须避免这个错误。

知道了这种逻辑谬误，让我回想起大学早期的日子，畏缩不前。有时我们必须收集数据并得出结论，我会调查我的朋友。如果我试图对整个美国人口甚至整个大学人口做出结论，我的样本是而不是代表整体。(好在这只是为了大学学分，而不是新产品或政策或其他什么。)

下面是一个测量技术可能存在不足的例子:

例如，一个“街上的人”采访选择了走过某个特定地点的人，这个采访将会过多地代表健康的人，他们比慢性病患者更有可能不在家。这可能是一种有偏抽样的极端形式，因为总体中的某些成员被完全排除在样本之外(即他们被选中的概率为零)。”[ 2

克里斯·巴尔巴利斯在 Unsplash 上的照片

生存偏差

有些人是幸运的——他们在逆境中生存下来。自然灾害、经济衰退、高风险的商业冒险等。当他们度过难关后，他们可能会回过头来想，成功比他们成功后更常见。或者，从外面看的人可能只听到成功的故事，而不是无数的失败或悲剧。

这就是生存偏差:当成功的群体被误认为是整个群体。由于幸存/成功的群体更加可见，人们开始认为它真的是整个群体(人口)。

这里有一个例子可以说明这种偏见如何影响我们在学校遇到的数据:

”商学院的学生可以回忆起独角兽初创企业在课堂上是如何受到欢迎的，这是学生应该努力追求的一个例子——成功的典型象征。尽管《福布斯》报道称 90%的初创企业都失败了，但所有的学位都致力于创业，许多学生声称他们有一天会创办一家初创企业并获得成功。[ 3

拉拉·阿兹利在 Unsplash 上的照片

解释结果时出现的错误

希望您没有任何错误地完成了数据收集。当你解释你的分析结果时，你仍然需要小心！

采摘樱桃

你可能听说过摘樱桃数据这句话。它指的是只选择支持你的论点的数据点或结果，并方便地省去为反论点提供证据的数据。

当我想到这个术语时，我会想到政治家使用数据。你可以只选择一部分研究结果放在演讲中，从而给研究结果增加许多积极或消极的因素。这符合他们的最大利益，不幸的是，这种情况相对普遍(在政治光谱的各个方面)。

你还会在媒体上看到摘樱桃:

“例如，考虑这样一种情况，一项基于某一领域数千名科学家的投入的新研究发现，99%的人同意对某一现象的共识立场，只有 1%的人不同意。在报道这项研究时，一名参与摘樱桃的记者可能会说:

最*的一项研究发现，有很多科学家不同意对这一现象的一致看法

这种说法代表了一个摘樱桃的例子，因为它只提到了一个事实，即研究发现一些科学家不同意关于所讨论现象的共识立场，而忽略了一个事实，即所讨论的研究也发现绝大多数科学家支持这一立场。"[ 4

赌徒谬误

“哇，他现在已经连续掷出三个 4 了——下一次不可能是 4 了！”

由阿洛伊斯·科门达在 Unsplash 上拍摄

你听过有人在游戏里说这样的话吗？一开始很直观，但是当你从逻辑上来看，你必须认识到掷骰子是一个独立的事件(从统计学上来说)。每次掷骰对下一次掷骰的概率没有影响。

这个例子把我们带到了赌徒谬误:“相信未来发生的随机事件的概率会受到该类事件的先前实例的影响。”[ 5

除了实际的赌博，这种谬误还可以在其他严重依赖历史数据的应用中看到，比如金融分析:

“赌徒谬误已经被证明会影响金融分析。投资者倾向于持有已经贬值的股票，卖出已经升值的股票。例如，他们可能会将股票价格的持续上涨视为该股即将崩盘的迹象，因此决定卖出。赌徒谬误可能在这里起作用，因为投资者是基于一个相当随机的事件(股票价格)的概率做出决策的，而这个概率是基于类似的过去事件的历史(其先前价格点的趋势)。这两者没有必然联系。它过去的价格轨迹本身并不能决定它未来的轨迹。”

决定股票价格的因素很多，但是将数据简化为历史价格，并根据历史价格做出买卖决定，这似乎属于赌徒谬误的范畴。

虚假因果关系

仅仅因为两个变量相关并不意味着一个导致了另一个。相关性不等于因果关系！当假设一个变量的趋势导致了另一个变量的趋势，而没有考虑其他可能的因素和原因时，就会出现错误的因果数据谬误。

关于一些奇怪的例子，请看这个网站的图表。希望你们中没有人会说这些变量中的一个导致了另一个——尼克·凯奇不应该这样:

图由泰勒·维根 ( 授权分享)

结论

如果你曾经陷入这些数据谬误之一，你并不孤单！这就是为什么让人们查看你的数据分析是有建设性的，无论是为了工作还是学校，指出你在方法或推理中可能存在的盲点。

让我们一起努力提高我们的数据素养技能，并对数据谬误保持警惕！

6 种降维技术

原文：https://towardsdatascience.com/6-dimensionality-reduction-techniques-how-and-when-to-use-them-e4891c10b5db

如何以及何时使用它们

来自 Pexels 的 Rodion Kutsaiev 摄影

在大数据时代，数据科学家正在使用拥有越来越多功能的数据集。这导致了一个众所周知的效应:维度的诅咒。当特征数量增加时，在某一点之后，模型的性能会下降。这是因为数据点的密度将随着维度的增加而降低(没有添加任何样本)。其中一个主要的后果是，模型变得非常容易过度拟合。

为了克服由于高维导致的过拟合、训练时间和存储的问题，一种流行的方法包括对原始数据集应用降维技术。

在这篇文章中，我将描述你在做数据科学项目时必须知道的六种降维方法。我将展示这些方法在著名的 MNIST 数据集上的应用。最后，我会在最后一部分比较和详细说明何时使用哪种方法。

主成分分析

该算法是最著名的特征提取算法之一。PCA 是一种无监督的线性变换算法，通过确定数据的最大方差来产生新特征。算法如下:

• 构建数据的协方差矩阵
• 对矩阵应用特征分解，并按降序对特征值进行排序
• 通过投影前 k 个特征值的子集来变换数据

主成分分析应用于 MNIST 数据集

PCA 有几个好处，比如不迭代，因此耗时较少。此外，它很好地减少了过拟合。然而，它仅限于线性投影，因此不能很好地处理非线性数据。这就是为什么没有一个数字在投影的 PCA 上形成真正分开的簇的原因。

线性判别分析(LDA)

与前一种方法一样，这种方法是一种线性特征提取算法，但这次是有监督的。该方法创建了一个新的特征空间来投影数据，目标是最大化类的可分性。它通过创建两个距离矩阵来做到这一点:类间的和类内的。第一个计算每个类的平均值之间的距离。第二个函数计算每个类的平均值与该类中的数据之间的距离。****

算法如下:

• 构建两个距离矩阵
• 计算这些矩阵组合的特征值
• 对特征向量进行排序并构建 top-k 矩阵
• 投影新子空间的数据

应用于 MNIST 数据集的 LDA

选择前 k 个特征向量使得 LDA 类似于 PCA。然而，该算法的一个主要不便之处在于，在二元分类的情况下，在 LDA 之后将只有一个可用特征，而与最初可用特征的数量无关。

独立成分分析

在介绍一些非线性算法之前，我想强调一下独立分量分析方法。这是一种线性的监督特征提取算法，可生成统计上独立的新特征。这是通过减少给定数据集中的二阶和高阶相关性来实现的。

算法是这样的:

• 将数据分解成混合矩阵 A 和新的基矩阵 S
• 选择前 k 个组件
• 通过在那些 k 组件上投影来构建新的特征

IDA 应用于 MNIST 数据集

与前两种算法相比，ICA 搜索统计上独立的特征。它通过搜索非高斯特征来做到这一点。这种算法常用于盲源分离问题。该算法的一个限制是它不能分离高斯特征。

多维标度(MDS)

接下来我将介绍的三种方法是非线性降维技术。第一种是非线性、无监督的维数约简技术。它侧重于多维空间中数据之间的关系，如相似性或不相似性。MDS 将相似的数据放在一起表示，将不太相似的数据放在一起表示。它通过找到一个输出来最大化原始要素和修改后的要素的距离矩阵之间的相似性。

算法是:

• 计算数据的相异矩阵
• 通过将数据居中来计算核矩阵 K 。
• 应用特征分解
• 通过选择前 k 个特征向量获得新的特征空间

MDS 应用于 MNIST 数据集

小心使用这种方法，因为它计算量很大。

等距映射

这种方法来自于这样一个事实，即经典的缩放方法不能捕捉数据集中可能的非线性模式。这种非线性无监督方法通过在低维空间中保持数据之间的成对测地线距离来解决这个问题。它计算邻域图中所有数据对之间的最短路径，以*似它们之间的测地线距离。

这些步骤是:

• 构建数据的邻域图
• 计算测地线距离矩阵
• 将 MDS 应用于此测地线矩阵

ISOMAP 应用于 MNIST 数据集

正如我们可以观察到的将该方法应用于 MNIST 数据集，一些数字被很好地分离，但是对于类似的数字，例如 2 和 7，操作更复杂。这是因为 ISOMAP 是一种流形学*算法(最早的算法之一)，但由于它使用邻域图，有时会在元素之间建立错误的连接。非凸流形也很难用这种算法来分析。

t 分布随机邻居嵌入(t-SNE)

我将介绍的最后一个算法是基于流形的降维技术。它是一种非线性的无监督方法，由于保留了数据的结构，因此便于可视化。该算法首先将数据点之间的欧几里德距离转换为表示相似性的条件概率。之后，t-SNE 最小化来自低维和高维空间的概率之间的差异(使用 Kullback-Leibner 散度)。

概括的算法是:

• 应用随机邻居嵌入来获得条件概率
• 通过最小化概率之间的距离，将高维空间映射到低维空间

t-SNE 应用于 MNIST 数据集

通过保持局部结构，该算法特别适用于低维空间中的数据可视化，如可以证明上面的 MNIST 数据，其中大多数数字类被很好地分离。

结论

这六种降维技术代表了可用于此目的的各种方法。每种方法都有其特殊性和弱点，其中一些方法主要用于数据可视化，如 t-SNE。所有这些都与 Scikit-Learn 集成在一起，Scikit-Learn 提供了一种在机器学*管道中实现它们的简单方法。

通过下面的两个表格，我提供了整篇文章的有用摘要，详细说明了何时以及如何使用这些不同的特征提取算法。我们确实有一套工具来降低数据的维度，但每一种工具都必须在特定的环境中使用，才能真正有效。

6 本面向完全初学者的免费数据科学书籍

原文：https://towardsdatascience.com/6-free-data-science-books-for-complete-beginners-636810c0a06f

你需要的每本书都是免费的

汤姆·赫曼斯在 Unsplash 上的照片

数据科学是一个跨学科领域，需要包括计算机科学、数学、统计和机器学*在内的多个领域的广泛技能。作为学*数据科学的完全初学者，可能很难知道从哪里开始。

数据科学学位课程和训练营可以指导你完成结构化的课程。然而，如果你没有数千美元来支付这些课程，另一种选择是开发自己的课程，并使用免费或低成本的资源来学*。

我以前写过如何着手创建自己的个性化数据科学学*课程，可以在这里找到。免费资源在网上随处可见，但很难找到最好的。对于初学者来说，一个很好的学*来源是书籍，幸运的是，有几本免费的书籍可供阅读，涵盖了入门所需的概念。

在下面的文章中，我将为初学者介绍六本我最喜欢的免费书籍。本文中的每本书都涵盖了数据科学最重要的基础概念之一。我按照我个人推荐的顺序组织了这些标题。内容如下:

• Python 编程基础。
• 数据科学统计学。
• 熊猫进行数据分析。
• Python 数据科学工具包。
• 机器学*。
• 深度学*。

1.用正确的方法学* Python

彼得·温特沃斯、杰弗里·埃尔克纳、艾伦·b·唐尼和克里斯·梅耶斯

https://learnpythontherightway.com/#about

在这里免费阅读 。

Python 是数据科学的首选编程语言。因此，学*这种语言的编程基础是该领域初学者应该学*的第一件事。这本书不是专门针对数据科学编程的，而是涵盖了编写 Python 代码的一般概念。我建议先从这本书开始，然后再看本文后面推荐的书中涉及的数据科学 Python 包。

这本书假设没有编程知识，并介绍了 Python 语言和基本的通用编码原则。每章包含一个补充的 Youtube 视频，有助于进一步解释所涵盖的概念。

本书的作者还提供了一套实践教程，其中包含超过 15 个实用的 Python 项目，可以将您的知识付诸实践。

2.数据科学实用统计学

作者彼得·布鲁斯&安德鲁·布鲁斯

图片由 amazon.co.uk 的提供

在这里免费阅读。

这是迄今为止我发现的向初学者介绍数据科学中最重要的统计概念的最佳书籍之一。它涵盖了广泛的主题，包括数据采样，分布，统计实验和机器学*。

所有概念都用初学者友好的术语解释，并包括混合使用 R 和 Python 的实际代码示例。

3.熊猫:强大的 Python 数据分析工具包

韦斯·麦金尼和熊猫开发团队

图片来自pandas.org

在这里免费阅读。

Python 包 Pandas 是探索、转换、清理和处理数据科学数据的首选工具。这本书是该工具的完整用户指南。

它涵盖了一切，包括安装，基本使用，绘图和数据分析。它假设了 Python 的基础知识，这对于首先以正确的方式学* Python 中的概念非常重要，但对于初学者和更有经验的学*者来说，它是这一基本工具的极好的参考指南。

4.使用 Scikit-learn、Keras 和 Tensorflow 进行机器实践学*

作者奥雷连·杰龙

图片由amazon.co.uk提供

在这里免费阅读。

这本书使用一些最流行的 Python 机器学*包 Scikit-learn、Keras 和 Tensorflow 对机器学*进行了详细的实践介绍。

这本书在介绍机器学*的重要理论概念方面做得很好，包括机器学*系统的类型、过拟合和欠拟合，以及常见算法如何工作的描述。

有很多实用的内容，包括一个典型的端到端机器学*项目的完整演练。这本书将为这一领域的新手提供完整的介绍。

5.Python 数据科学手册

杰克·范德普勒斯

图片来自 jakevdp.github.io

在此免费阅读。

这本书是对 Python 数据科学工具包的很好的、广泛的介绍。它介绍了 NumPy 库，包括数组、数组计算和 Python 中的数据类型等概念。

它还对熊猫的数据分析和 Scikit-learn 的机器学*进行了很好的、初学者友好的介绍。

6.Fastai 和 Pytorch 的深度学*:没有博士学位的人工智能应用

由杰瑞米·霍华德和西尔万·古格创作

amazon.co.uk的形象礼仪

在这里免费阅读。

这本书是深度学*的实用入门。它的目标读者是程序员，所以在深入阅读本书之前，理解 Python 编程是必不可少的。然而，它并不假设对数学和统计学有深刻的理解，并包括一些对深度学*背后理论的优秀和简单的解释。

这是学*深度学*的理想的第一次介绍，并将让你开始开发你的第一个深度学*模型。

互联网上有大量免费或低价的学*数据科学的资源。这包括免费课程、大学讲座、教程、视频、博客帖子和书籍。在本文中，我提供了六本免费阅读的书籍的链接，这些书籍本身就可以为一个完全的初学者提供数据科学领域的优秀知识基础。

我以前写过几篇文章，涵盖了学*这些主题的各种免费资源。如果你想超越这些介绍性的概念，或者正在寻找教科书以外的资源，下面的链接将帮助你开始。

</10-free-resources-for-learning-natural-language-processing-81a380540cd1> https://rebecca-vickery.medium.com/data-science-learning-resources-ef034c8f2713

感谢阅读！

使用熊猫系列时的 6 个基本问题

原文：https://towardsdatascience.com/6-fundamental-questions-when-working-with-a-pandas-series-1d142b5fba4e

了解熊猫系列的特点

自由股票在 Unsplash 上的照片

Pandas 系列是一个一维数组，它可以有一个带标签的索引，即非数字索引。系列也可以被认为是表格中的一列，可以存储各种类型的数据。

1.你要熊猫做什么？

Python 的基本安装已经带来了四种不同的数据结构，其中可以存储任何数据类型:

• 列表是元素的有序集合。它是可变的，也能够存储重复的元素。
• 元组与列表非常相似，唯一的区别是不可更改。这意味着在创建元组之后，不能添加或删除任何元素。
• 集合不允许重复输入。同时，顺序也不固定。
• 从 Python 版本开始，字典是一个键值对的有序集合。

尽管您已经可以用这些数据结构处理许多用例，但是有些情况下它们是不够的。例如，不能用这些本机结构显示表。因此，存在所谓的模块，例如 Pandas 或 Numpy，其使得使用在基本安装中不可用的更多功能成为可能。同时，通常情况下，来自模块的数据结构比 Python 的标准数据对象更具性能。例如，Numpy 数组已经针对向量和矩阵计算进行了优化。

同样，还有许多其他应用程序的模块来补充 Python 编程语言及其功能。例如，模块 TensorFlow 或 Scikit-Learn 用于创建机器学*模型。

2.熊猫系列由哪些部分组成？

熊猫系列是在熊猫中使用的最基本的数据结构之一。它是一种一维的有序数据结构，例如，可以用来存储表列中的信息或向量中的数字。

它提供了使用标签索引的可能性。但是，如果没有明确指定，则会自动设置从零开始的数字索引。因此，熊猫系列中元素的顺序扮演着重要的角色，这一点也变得很明显。该序列被称为有序数据结构。这意味着两个具有不同顺序的相同元素的熊猫系列不是同一对象。

最简单的熊猫系列是空系列，其定义如下:

import pandas as pdseries_1 = pd.Series()
print(series_1)Out:
Series([], dtype: float64)

在熊猫系列函数中可以指定一些参数来改变对象的属性。如果没有明确指定，它们将被自动设置或使用默认值。以下参数可以设置，但不是必须设置:

• 数据:该参数定义系列中要存储的数据。可以使用不同的数据结构，比如一个列表、一个字典，甚至是一个单一的值。
• 索引:在索引的帮助下，可以为序列中的元素定义一个带标签的索引。如果未设置该参数，元素将从零开始自动编号。
• dtype :可选参数 dtype 设置系列的数据类型。如果系列中的所有数据都是相同的数据类型，这将特别有用。例如，您可以定义将数字存储为整数还是小数。
• 名称:该参数可以对系列进行命名。如果系列是数据帧的一部分，这尤其有用。那么这个名称就是数据帧中相应的列名。
• 复制:该参数只能取值 True 或 False，因此是一个布尔值。它指定传递的数据是否应该保存为副本。然而，在大多数情况下，这并不重要。

当使用所有这些参数时，一个完整定义的序列如下所示:

series_1 = pd.Series([1, 2, 3], index = ["A", "B", "C"], dtype = "int64", name = "Series of Integers", copy = False)
print(series_1)Out:
A    1
B    2
C    3
Name: Series of Integers, dtype: int64

3.如何从序列中检索数据？

当从 Pandas 系列中查询数据时，我们使用方括号中的索引，正如我们从 Python 列表中已经知道的。如果文本索引可用，我们就使用它，否则，可以使用数字索引:

series_1 = pd.Series(["first element", 2, "third element"])
print(series_1[0])series_1 = pd.Series(["first element", 2, "third element"], index = ["A", "B", "C"])
print(series_1["A"])Out:
first element
first element

可能会发生这样的情况，我们只知道要从序列中查询的元素，而不知道相应的索引。然而，在熊猫系列中，找出相关联的索引并不像例如使用列表那样容易。一种方法是将序列转换为列表然后使用“.”。指标"功能找出相应的指标:

series_1 = pd.Series(["first element", 2, "third element"], index = ["A", "B", "C"])
list(series_1).index(2)Out:
1

4.如何覆盖或添加序列中的值？

可以通过调用相应的索引来覆盖序列中的现有值:

series_1 = pd.Series(["first element", 2, "third element"], index = ["A", "B", "C"])
series_1["A"] = 1
series_1Out:
A                1
B                2
C    third element
dtype: object

如果要在现有系列中包含新值，也可以使用此调用。为此，只需使用一个尚未使用的索引:

series_1 = pd.Series(["first element", 2, "third element"], index = ["A", "B", "C"])
series_1["D"] = "fourth_element"
series_1Out:
A     first element
B                 2
C     third element
D    fourth_element
dtype: object

5.如何用条件查询数据？

特别是对于数字数据，从满足特定条件的系列中查询数据会很有用。为此，相应的过滤器定义在方括号中，而不是索引中。例如，这可用于输出序列中大于四的所有元素:

series_1 = pd.Series([1, 2, 3, 4, 5, 6, 7, 8], index = ["A", "B", "C", "D", "E", "F", "G", "H"])
series_1[series_1 > 4]Out:
E    5
F    6
G    7
H    8
dtype: int64

如果要同时使用几个条件，可以在连续的方括号中定义它们。请注意，条件由逻辑“and”连接，这意味着只输出满足所有条件的值。这使我们能够过滤所有大于 4 但不等于 8 的值，例如:

series_1 = pd.Series([1, 2, 3, 4, 5, 6, 7, 8], index = ["A", "B", "C", "D", "E", "F", "G", "H"])
series_1[series_1 > 4][series_1 != 8]Out:
E    5
F    6
G    7
dtype: int64

6.如何从字典创建一个系列？

除了列表，你还可以使用一个 Python 字典作为熊猫系列的数据。这样做的好处是不必显式指定索引。字典的键用作序列的索引，字典的值用作数据:

dict_1 = {"A": 1, "B": 2, "C": 3}
print(pd.Series(dict_1))Out:
A    1
B    2
C    3
dtype: int64

7.熊猫系列是用来做什么的？

熊猫系列主要用于熊猫数据框。它们用于构建这些类似表格的数据结构，因为数据帧的每一列都由一个单独的序列组成。

它还可以用来存储不同数据类型的一维数据，并使用它们执行计算。在机器学*领域，它们也可以用于存储一维向量和执行复杂的计算，如向量乘法。

8.如何从熊猫系列创建数据框架？

一个数据框基本上是几个熊猫系列的集合。因此，通过命名所使用的系列，可以相对容易地创建它。

series_1 = pd.Series(["first element", 2, "third element"], index = ["A", "B", "C"])
series_2 = pd.Series([4, 5, 6], index = ["A", "B", "C"])
series_3 = pd.Series(["i", "don't", "know"], index = ["A", "B", "C"])pd.DataFrame([series_1, series_2, series_3])Out:

重要的是，系列对象要么都有相同的索引，要么没有索引。否则，将为每个不同的索引创建一个单独的列，而其他行没有值:

series_1 = pd.Series(["first element", 2, "third element"], index = ["A", "B", "C"])
series_2 = pd.Series([4, 5, 6], index = ["A", "B", "C"])
series_3 = pd.Series(["i", "don't", "know"], index = ["A", "B", "D"])pd.DataFrame([series_1, series_2, series_3])Out:

9.熊猫系列和 Python 列表有什么区别？

本文至此，您可能已经有了这样的印象，熊猫系列和 Python 列表是两个非常相似的数据结构，它们的主要区别在于列表只能使用数字索引，而熊猫系列也允许文本索引。

该系列与列表的主要区别不在于它们的功能或结构，而在于它们的应用可能性。在数据科学领域，数列主要用作表格数据的初步阶段，而表格数据又要用图表来说明。这意味着可以具体地看待这个系列。

另一方面，列表用于临时存储复杂的数据结构，因此它倾向于留在后台，并作为复杂计算的工具。

这是你应该带走的东西

• Pandas 系列是一个一维数组，它可以有一个带标签的索引，即非数字索引。
• 它主要与熊猫数据框一起使用。在这里，您可以将系列视为单个表格列。
• 该系列在许多功能上类似于 Python 列表，不同之处在于列表不允许文本索引，但该系列允许。

如果你喜欢我的作品，请在这里订阅https://medium.com/subscribe/@niklas_lang或者查看我的网站* 数据大本营 ！还有，medium 允许你每月免费阅读 3 篇 。如果你希望有无限制的 访问我的文章和数以千计的精彩文章，不要犹豫，点击我的推荐链接:【https://medium.com/@niklas_lang/membership】每月花$5***获得会员资格**

*https://medium.com/codex/why-you-should-know-big-data-3c0c161b9e14 https://medium.com/@niklas_lang/understanding-mapreduce-with-the-help-of-harry-potter-5b0ae89cc88 *

作为一名数据科学家，6 个*惯应该包含在你的日常工作中，让你拥有一个长期快乐的职业生涯

原文：https://towardsdatascience.com/6-habits-to-include-in-your-daily-routine-for-a-long-happy-career-as-a-data-scientist-de733eae6250

所有这些*惯花费你不到 10 分钟的时间

约书亚·厄尔在 Unsplash 上的照片

数据科学 Reddit 现在是一个有趣的地方，许多数据科学家正在描述他们职业生涯中的倦怠和缺乏成就感的感觉。

许多人表示，他们感觉不到职业发展的动力，或者感觉自己已经停滞不前，需要新的挑战。

我想每个人在职业生涯中都至少有过一次这样的感觉，这也许就是为什么统计数据显示人们一生中平均从事超过 10 种不同的工作。

虽然人们很容易将对工作的失望视为转行的借口，但重要的是要记住，你一开始就经历了成为数据科学家的漫长而艰难的过程。因此，同样重要的是，要确保你在日常工作中尽一切可能，以确保你感到充实、充满活力，并受到鼓舞，继续作为一名数据科学家工作。

日常事务对你工作时的幸福感有很大影响，这就是为什么建立一些建设性的*惯很重要，这些*惯花费很少的时间，但会让你感到精神焕发，并准备好接受某一天扔给你的任何事情。

1.寻找一个自动化的琐碎任务

有一句名言建议我们应该以每天提高 1%为目标。我喜欢这样想，如果我们简单地观察我们周围的流程，并尝试思考如何将它们做得更好，我们每天可以提高 1%的效率。

当数据科学家进入他们的职业生涯时，最大的抱怨或体会之一是，大多数工作都是琐碎的。数据搜集、清理和准备可能占用项目所需时间的 80%，其中 10%用于项目规划，另外 10%用于实际的分析和可视化工作。这意味着你所做的 80%的工作，虽然对项目的成功至关重要，却是重复的，令人麻木的工作，这相当于每天 8 小时用奶酪刨丝器在你的额头上刮擦。

许多数据科学家通过自动化这些任务找到了喘息的机会，这样就可以花更多的时间做“有趣”的事情。在学*如何编码时，最大的体会之一就是你只需写几个命令就可以做大量的事情。这种认识可以让你在各种没人有时间做的琐碎任务上变得有创造力。

通过每天寻找一个自动化的琐碎任务，你会发现大量空闲时间可以用于项目的其他方面。他们说你 20%的工作产生了 80%的成果，所以通过花更多的时间在这至关重要的 20%上，你可能会产生一些惊人的成果。从个人经验来看，你自动化的任务可以简单到提醒你每隔一段时间眨一下眼睛或者自动分类你的电子邮件的闹钟，更不用说数据清理和处理了。重要的是，它会处理您原本需要手动完成的工作。

此外，自动化任务是一个伟大的精神休息和体操融入一个有趣的活动，不仅给你一个作为程序员伸展你的腿的机会，而且将很快得到回报。

2.每天花 10 分钟学*与数据科学相关的新技能

微学*是每天用不到 10 分钟的时间学*新的数据科学技能的一种可验证的方式。

养成这种*惯是一种很好的方式，可以让你保持兴趣，通过学*新技术或做事方式来提高自己作为数据科学家的技能。Medium、Reddit、Substack 和各种播客(见下文)是关于数据科学新进展的重要信息来源，可能会启发你尝试学*新的东西。

对于成人学*者来说，关键是要保持学*时间短，并且有明确的目标。这意味着将学*时间缩短到 10 分钟，目标在这段时间内很容易实现。这不仅让你有动力在学*中继续前进，因为完成它们需要的时间很短，而且也确保了你在一次学*后提高了你的技能。此外，完成一个*惯似乎并不困难，比你喝咖啡休息的时间还少。

根据我的经验，每天花 10 分钟学*一项技能不会立刻带来巨大的收益，但会随着时间的推移慢慢积累，在年底产生一些你可以引以为豪的东西。我看到的 10 分钟数据科学研究的一些用途包括学* R，敲掉多变量微积分技能的锈迹，更深入地理解 Excel 的各种功能，以及通过阅读行业时事通讯增加商业敏锐度。

3.在一个与你日常工作无关的激情项目上取得进展

我见过的最狂热的数据科学家通常是那些喜欢在工作之外从事自己的数据科学项目的人。他们对数据科学的真正热情似乎从未因为他们从事与日常工作完全无关的个人项目而减弱。

在我(包括我自己)做这些之前，我不会浪费你的时间列出所有你可以做的项目。然而，我想做的是，为您提供一些有趣的地方，您可以在那里检索免费数据进行工作:

https://data.nasa.gov/ https://data.worldbank.org/

这些激情项目应该是你可以每天拿出十分钟来添加一个功能或尝试一种新的分析或可视化的东西。没有什么太费力或费力的，但足以鼓励你尝试新技能。虽然您作为数据科学家的日常工作可能很单调，但这个项目不一定是也可以是您作为数据科学家真正伸展四肢的地方。

4.找出一个可以更有效完成的公司流程

许多数据科学家最*一直在说，他们觉得自己已经最大限度地发挥了他们对目前工作的公司的影响。我记得读过一个数据科学家的帖子，描述了他们如何优化每一个流程，揭示了公司如何更有效地工作的每一个可能的见解，并实施了他们能想到的尽可能多的新流程。

我总是乐观地认为，一个公司总有更多的事情可以做得更好。即使你从小处着手，比如说，用一种更有效的方法来检索客户数据，你也只能提高公司效率的很小一部分，当你处理的客户数据越多，这个比例就会越大。或者，你可以更有创意地设计一个插件，按照公司标准格式化每个人的代码。

这种日常*惯不仅证明了你对公司的持续价值，还让你在一天中获得了一些额外的精神锻炼，增强了你提升和改善技能以及你所供职公司的流程的灵感。

5.听一听激励你的数据科学播客或有声读物

你可能不想让自己一天 24 小时都被工作中的事情包围，这是公平的。然而，你可以听一些很棒的数据科学播客和有声读物，它们不会像试图强迫一个弱数据集向你展示答案那样耗费脑力。

下面建议的播客涉及从伦理人工智能到打破玻璃天花板再到作为数据科学家的职业发展的方方面面。我更喜欢听关于数据科学非技术方面的故事，这些故事挖掘了道德问题的本质，采访了我崇拜的数据科学家，以及如何成为一名更好的数据科学家，因为它们提供了从编程和数学的严格性中稍微休息一下的机会。

https://banana-data.buzzsprout.com/ https://www.widsconference.org/podcast.html https://theartistsofdatascience.fireside.fm/

当我们很少有人有时间阅读时，数据科学有声读物是获得一些额外知识的好方法。我喜欢听涉及更多学术或严谨话题的有声读物，因为听别人给你解释的东西往往比你自己读更能让你对这个话题有更清晰的理解。然而，在不止一个场合，我发现自己手忙脚乱地拿起笔来写下一个相关的想法，所以请确保你准备好了纸和笔，以确保你不会错过任何你刚刚想到的想法。

https://www.audible.com/pd/Weapons-of-Math-Destruction-Audiobook/B01JPA41ZU?source_code=BLGORWS0107160001 https://www.audible.com/pd/Big-Data-How-Data-Analytics-Is-Transforming-the-World-Audiobook/1629976091?source_code=BLGORWS0107160001 https://www.audible.com/pd/Naked-Statistics-Audiobook/B00CH3UI28?source_code=BLGORWS0107160001 https://www.audible.com/pd/Algorithms-of-Oppression-Audiobook/B07CX9GHJZ?source_code=BLGORWS0107160001

6.与他人分享你的经验和知识，以回报他人

我得到了我的第一份科技工作，这要归功于我和以前学校同事的关系。我联系了另一位学校同事，向他们推荐了一个非常适合我现在工作的公司的职位。

帮助你身边有才华的朋友和同事找到工作只是分享你的经验和知识并为你的成功买单的方式之一。这可以像帮助别人找到工作一样复杂，也可以像和在饮水机旁向你求助的同事分享小费一样简单。

例如，我通过撰写关于如何获得数据科学方面的工作、如何成为更好的数据科学家以及如何更有效地学*数据科学的文章，与“走向数据科学”社区分享我的经验和知识。我也在考虑把这些教导写成一本书，让更多的读者分享和阅读。

与他人分享你所知道的是一个令人惊讶的鼓舞人心和令人满足的日常*惯，因为它不仅向你展示你作为一名数据科学家已经走了多远，而且还帮助你周围的其他人获得同样的成功。数据科学是最难进入的领域之一，这就是为什么帮助他人学* Python、分享如何自动化数据清理的技巧或帮助他人准备演示文稿是一件如此重要的事情，需要养成这样的*惯。

其他一些帮助他人和分享知识的方法包括写博客，创建数据科学播客或 Twitter 账户，在 r/datascience 或 Quora 上回答问题，或者像许多数据科学家已经做的那样创建 Youtube 频道。

订阅将我的故事直接发送到您的收件箱:故事订阅

请成为会员，使用我的推荐链接获得无限制的媒体访问权限(我将收取少量佣金，无需额外费用):媒体会员

通过捐赠来支持我的写作，以资助更多像这样的故事的创作:捐赠

6 分层数据可视化

原文：https://towardsdatascience.com/6-hierarchical-datavisualizations-98318851c7c5

使用分层数据创建各种数据可视化

以下引用的个别图像

分层数据是一种数据结构，其中数据点通过形成树形结构的父子关系相互链接。分层数据是一种常见的数据结构，因此了解如何将其可视化非常重要。用于此的可视化技术与其他数据结构不同，因为需要维护层次关系。本文将展示六种类型的可视化。

数据集

使用的数据集是 flare 数据集，它显示了 Flare ActionScript 可视化库的层次关系。它显示了类的层次结构和类之间的联系。数据集可以作为 json 在这里下载。

树木

树形可视化显示具有节点(数据点)和边(节点之间的分层关系)的集合的分层数据。

1. 正常

耀斑数据集的树形图(Mike Bostock 在可观测到的上拍摄的图像)

正常树可视化是最常用的层次可视化类型。这很容易解释，因为传统的树结构广为人知。然而，大树可能会扭曲以适应屏幕，或者需要添加滚动功能来查看整个树，这使得可视化更加难以解释。

2。径向

耀斑数据集的径向树(由 Mike Bostock 在可观察到的上拍摄的图像)

辐射状树，有时也称为辐射状树状图，与普通的树可视化相同，但采用的是圆形格式。使用径向树的一个好处是它比普通树更紧凑，所以更适合大树。这种格式的缺点是，根据标签的显示方式，标签可能难以阅读。

分层图

分层图适用于显示空间关系，也称为整体的一部分。

1。正常

(图片由作者提供)

正常分层图将数据集的根节点或起点显示为最左侧的列，而最深的叶节点位于最右侧。这个使用 flare 数据集的特定示例显示了 flare 类中的层次关系。第一列是根，它表示整个 flare 类的大小，第二列是 flare 案例中的类的大小，依此类推。正常分层图的一个缺点是，如果大小比率很大，叶节点变得难以解释，尤其是在大树中。

2。径向

(图片由作者提供)

放射状分层图也称为旭日图，除了采用放射状格式之外，它遵循与普通分层图相同的概念。使用径向格式的一个好处是它更紧凑，因此对于较大的数据集很有用。一些缺点是，大小可能会因位置而有所偏差，因为靠*圆外侧的部分会比靠*内侧的相同大小的部分更大。这是因为内圈的周长自然比外圈小。此外，由截面产生的角度会使尺寸更难解释。两个分层图的代码都可以在这里找到。

树状图

树形图用一组嵌套的形状表示分层数据。这些形状用于显示相对于其面积的大小。树形图能够显示类别是如何根据层次结构的每一层来划分的。

1。正常

耀斑数据集的树形图(图片由作者提供)

普通的树形图由嵌套的矩形组成。普通树形图的一个好处是它提供了层次数据的清晰视觉。由于空间被划分成矩形，这允许观察者容易地看到与其父节点成比例的节点大小，这反过来对于比较非常有用。一个缺点是深树会使静态视觉混乱，因此深度大于三的数据集可以受益于增加的交互式功能以提高可读性。

2。圆形

耀斑数据集的循环打包(daktari 在 ObservableHQ 上拍摄的图像)

圆形树图，也称为圆形打包，类似于普通的树图，只是它使用嵌套的圆形。使用循环包装的好处是它清楚地突出了组之间的层次关系。缺点是它不能像普通的树形图那样有效地利用空间。类似于普通的树形图，它只清楚地显示三到四层，之后可视化就变得不清楚了。如果正在使用的数据的深度大于 4，则添加交互功能非常重要。

互动功能

可视化分层数据的一个常见缺点是可读性，尤其是对于大型数据集。树越宽越深，观众就越难理解所传达的信息。一个解决方案是使可视化具有交互性。

互动版的树状图(图片由作者提供)

1。滑块:改变深度

第一个解决方案是创建一个滑块，这样用户就可以控制深度或显示的级别数。这允许用户与可视化交互，以便他们可以看到当添加更多层时它是如何变化的。可以使用的两种类型的滑块是简单滑块和范围滑块。简单的滑块允许用户控制在可视化中显示多少级别。范围滑块仅显示两个深度值之间的数据点。上面的交互式树形图包括一个简单的滑块。

2。缩放:关注细节

大型分层可视化会使一些或所有节点难以看到。添加缩放功能允许用户单击某个部分以获得更详细的视图。在上面的树形图中，点击任何一个节点，它就会放大，给出它的后代的更详细的视图。再次点击同一节点将缩小到包括前一层。

3。工具提示:悬停以获取更多信息

工具提示允许用户将鼠标悬停在可视化的某个部分上，将出现一个包含附加信息的弹出窗口。当没有空间向每个节点添加标签时，也可以使用这种方法。在上面的例子中，你可以将鼠标悬停在任何节点上，名称和大小就会弹出。

4。亮点:引起对特定部分的注意

分层可视化很好地展示了整体数据，但是，如果有特定的部分需要突出显示，一个好的方法是突出显示预期的区域。

关于如何用 Python 创建这个交互式树形图的一步一步的教程，请查看我下面的文章。

引文

博斯托克，M. (2017 年 11 月 15 日)。树，径向整齐。可观察的。检索于 2022 年 6 月 23 日，发自 https://observablehq.com/@d3/radial-tree

博斯托克，M. (2021，10 月 27 日)。具有 Flare 类层次结构的 JSON 文件。https://gist . github . com/MBO stock/1044242 # file-readme-flare-imports-JSON。许可证:gpl-3.0

博斯托克，M. (2022 年 4 月 6 日)。树，整齐。可观察的。于 2022 年 6 月 23 日从https://observablehq.com/@d3/tree检索

达克塔里。(2019 年 2 月 5 日)。 D3 圆形包装。可观察的。于 2022 年 6 月 23 日从 https://observablehq.com/embed/@tasqon/d3-circle-packing?检索单元格=图表

6 Julia 框架来创建桌面 GUI 和 Web 应用程序

原文：https://towardsdatascience.com/6-julia-frameworks-to-create-desktop-guis-and-web-apps-9ae1a941f115

阿尔瓦罗·雷耶斯在 Unsplash 上拍摄的照片

Julia 用于许多深度技术应用，如机器学*和数据科学。但作为一种通用编程语言，Julia 也可以用于构建网站和交互式可视化。在本文中，我们将介绍 5 个 Julia 包，它们可以用来创建桌面 GUI 或 web 应用程序。

编辑:我和我的合著者很高兴地告诉大家，我们的新书《茱莉亚速成班》已经开始预售了:

https://logankilpatrick.gumroad.com/l/juliacrashcourse

精灵🧞‍♂️的网络应用

Genie.jl 是基于 Django 的纯 Julia web 框架。来自 Genie 网站:

Genie Framework 包含了使用 Julia Lang 快速构建生产就绪的 web 应用程序所需的全部内容。开发 Julia 后端，创建漂亮的 web UIs，与数据库集成，并设置高性能的 web 服务和 API。

像 Django 一样，Genie 不仅仅是一个独立的软件包，它是一个完整的生态系统！让我们看一个带有 Genie 的基本 hello world 示例:

# Genie Hello World!
using Genie
route("/helloworld") do
    "Hello and welcome to Genie!"
end# Powerful high-performance HTML view templates
using Genie.Renderer.Html
route("/html") do
    h1("Welcome to Genie!") |> html
end# JSON rendering built in
using Genie.Renderer.Json
route("/json") do
    (:greeting => "Welcome to Genie!") |> json
end# Start the app!
up(8888)

正如您所看到的，Genie 遵循了与 Django 相似的设计模式，并附带了 web 服务器、模板引擎、cookies、加密、认证、路由引擎、用 Julia 编写的后端视图等特性。

如果您想构建现代 web 应用程序，并且熟悉 Django，Genie 是正确的起点！你可以在这里了解更多:https://genieframework.com

有关 Genie 的全面视频教程，请查看:

朱莉娅中的 GTK 绑定

jl 是一个 Julia 包，构建在非常流行的 Gtk 窗口工具包之上。你可以在这里找到入门手册:https://Julia graphics . github . io/GTK . JL/latest/manual/getting started/

让我们看一个简单的例子:

using Gtkwin = GtkWindow("My First Gtk.jl Program", 400, 200)b = GtkButton("Click Me")
push!(win,b)showall(win)

首先，我们设置窗口的名称和尺寸。然后，我们创建一个带有特定文本标签的按钮对象，并将其推送到应用程序中。最后，我们通过调用showall来显示应用程序。

作者捕获的图像

Gtk.jl 已经被用来构建一些非常酷的应用程序。我强烈建议看看这个视频:

Makie.jl📊📉

Makie 是 Julia 生态系统中最受欢迎的可视化软件包之一。你能建造的东西有着难以置信的深度。

Gif 截图自 https://github.com/JuliaPlots/Makie.jl

Makie 允许您构建在 GPU 上运行的交互式可视化，也可以在您的浏览器中运行。Makie docs 最*也进行了大规模更新，所以那里的内容是最新的，非常有用:https://makie.juliaplots.org/stable/

我还建议去看看https://lazarusa.github.io/BeautifulMakie/，这是一个用 Makie 制作的非常好的动画图库。

Blink.jl，基于 Web 的 Julia 图形用户界面

Blink.jl 是围绕着电子的 Julia 包装器。它可以在本地窗口中提供 HTML 内容，并允许 Julia 和网页之间的通信。因此，通过这种方式，Blink 可以用作 GUI 工具包，为桌面构建基于 HTML 的应用程序。

我想不出更好的方式来重申这一点，所以以上是从 Blink docs 引用的。Blink 与其他软件包的不同之处在于，你可以使用它构建基于 HTML 的 GUI。

julia> using Blink

julia> w = Window() # Open a new window
Blink.AtomShell.Window(...)

julia> body!(w, "Hello World") # Set the body content

julia> loadurl(w, "http://julialang.org") # Load a web page

我们首先创建电子窗口，然后在窗口的 body 标签中添加一些文本，最后在窗口中加载一个 URL。如果您在本地运行这段代码，您会看到当我们执行这些命令时，窗口会动态变化。

作者捕获的图像

虽然我不认为 Blink 被广泛使用，但我在各种项目中用它玩得很开心。

破折号，由 Plotly📈

Dash 是 Dash 生态系统的一个 Julia 接口，用于在 Julia 中创建分析 web 应用程序，而不需要 JavaScript。这意味着您可以构建像 https://covid-county-dash.herokuapp.com一样令人印象深刻的仪表盘，并轻松部署它们！

你可能还想查看 Dash 网站https://dash.plotly.com/julia了解开始的细节。Dash.jl 上也有全面的文档:https://github.com/plotly/Dash.jl

带有软件包编译器的桌面应用📦

目前，创建一个可以在没有安装 Julia 的电脑上共享和运行的桌面应用程序的最佳方式是使用 PackageCompiler。PackageCompiler 允许您将整个 Julia 项目编译成 exe 文件。这个过程将所有的依赖项捆绑到一个文件中，使其可以分发。

我会注意到目前有一些关于你需要做什么来创建一个 exe 的限制。可能需要重写一些代码来使其兼容。有关使用 PackageCompiler 的分步演练，请查看:

你可以在文档中了解更多关于包编译器的信息:https://Julia lang . github . io/Package Compiler . JL/stable/apps . html

其他包🥈

上面突出显示的 5 个包只是 Julia 生态系统中现有包的一小部分。下面，我将添加一个我能找到的所有可视化包的半详尽列表，以防前 5 个不适合您的用例:

1. Plots.jl ，在 Julia 中可视化的强大便利
2. Interact.jl ，互动小工具玩你的 Julia 代码
3. Stipple.jl ，纯 Julia 的交互式数据应用的反应式 UI 库。
4. QML.jl ，为 Julia 程序建立 Qt5 QML 接口。
5. ClmGui.jl ，cimgui 的 Julia 包装器

我漏了一个吗？请随意评论这篇文章，我会把这个包添加到这个列表中！

作为数据分析师工作一年的 6 点收获

原文：https://towardsdatascience.com/6-learnings-from-working-as-a-data-analyst-for-ayear-8f5531e99f8a

一位(现在的)高级分析师关于如何在工作中取得成功的笔记

巴赫尔·凯里在 Unsplash 上拍摄的照片

嗨！我是 Rashi，我在芝加哥的一家健康保险公司工作。在去年开始全职工作之前，我在百事公司实*了*一年，从实*和一年的数据分析师经历中学到了经验、最佳实践，更重要的是数据分析师可能容易犯的错误。

在过去的两年里，我处理了大量的数据集，以及数百个数据点，每个数据集都回答了你想要的那么多问题。你每天只能从你的工作、你的错误、合作以及与同事谈论他们的挑战中学*。作为 2022 年的一名数据分析师，为了尽我所能成为最相关的人，我已经掌握了六条有价值的、最精华的经验，这些经验将伴随我处理数据的一生。

1.每次都验证您的数据和分析

作为一种社会措施，人类生活在生活的各个方面都寻求认可。那为什么你的数据分析也不行呢？

数据验证是确保数据集中一致性和准确性的过程。验证可以跨越数据类型、代码、格式、一致性和模型输出，并且可以在分析之前或之后进行。在任何数据科学生命周期中，数据验证都是创造最佳结果的一个非常关键的步骤，并且经常被忽略。

例如，公司要求你预测下一个假期的销售额。您对预测模型进行编码，并发送一个带有图表的产品销售预测 Excel 表。现在，一位高级经理给你(以及你的老板和其他 20 个人)发电子邮件，解释为什么一种高性能产品在假日季节的销售额低于平均水平。您开始验证您的分析，却发现您使用了错误的 VLOOKUP 来从产品 ID 填充产品名称。

作为数据分析师，我们的工作不仅是预测一个场景的绝对最佳状态，而且还要—

1. 验证数据连接是否正确:左连接与内连接
2. 用你的分析结果来证实商业意识
3. 能够证明错误对业务意味着什么
4. 理解业务环境以解释分析的结论
5. 确认数据符合分析原则:共线性、处理空值、重复数据
6. 在发送前阅读邮件和附件内容两次

2.了解业务环境

作为数据分析师，我再怎么强调尽可能深入了解业务的重要性也不为过。

每次我和一个工作了至少 10 年的数据专家(在此之前，这一切都被称为数据科学和分析)交谈时，我总是在交谈中了解业务，以便更好地用数据讲故事。

除非你有相关的商业理解，否则我发现很难浏览一个项目的步骤。当你理解业务问题时，最重要的是，你知道向利益相关者问什么问题，数据和你的分析中期望什么。当我还是一名初级分析师，没有花时间去理解业务时，我的数据和分析往往会失去它应该产生的本质和影响。

对于手头的任何分析，除非你了解业务，否则你永远不会知道模型中的错误对业务意味着什么，为什么在产品推出后，一个人口较少的县的数字会被夸大，等等。

不管是什么行业，每天都要磨练你的商业头脑

3.了解 KPI 和数据点

每当我手头有一个新的问题陈述要处理，并且如果我不知道从头到尾的步骤，我已经学会为自己建立一个实践，在那里我与利益相关者进行面谈，了解对提问重要的指标，并记下企业希望知道的三件最重要的事情。

数据点基本上是数据分析的构建块。

他们的目的是接受或拒绝一个假设，发现趋势或模式，或做出预测。这些年来，我意识到，随着您对您的数据点和关键绩效指标有了更深刻的理解，这使我能够提出最适合业务目标的相当有效的建议。

数据不会说谎，因此，如果您能够将您的关键衡量指标与业务保持一致，数据将提供关于业务绩效的客观反馈。

4.做一个问题解决者和创新者

作为一名数据分析师，我(当然你也是)每天都面临着新的挑战——数据、业务问题陈述、组织协调、数据管理、质量等。当我开始的时候，我的态度是倾向于识别那些挑战，然后和我的经理谈论它们。

现在，作为一名分析师，您的经理可能并不总是理解您的挑战，或者能够为“您的”问题提出解决方案。当我们步入新的一年时，回想起来，我明白这种态度只能带我走这么远。

如果有挑战，我会改变我的视角来看更大的画面，我或其他人能做的下一件最好的事情是什么，并在团队中推荐创新(如果它得到批准，你就有了你的成就)。作为一名分析师，我现在不断想办法给公司增加价值。

创新是把现有的两样东西以一种新的方式组合在一起。

5.为企业翻译数据

数据的作用是让企业能够根据统计数据、趋势和见解做出决策。

在当今不断膨胀的数据世界中，人们需要和要求简单地理解这数百万千兆字节的数据。企业正在寻求越来越多的人来翻译数据以推动决策。数据从来都不漂亮，作为数据分析师，我们的工作就是让数据变得可口，并让企业从这些数据中获得真知灼见。

在过去的几年里，我参与了多个项目，现在我已经为自己开辟了一个利基市场，我喜欢在数据和业务的交叉领域工作。这是我作为分析师最大的收获之一。数据本身不会说话，也不会影响变化，而我作为一个数据分析师，必须能够组织和解读数据。

在我致力于创建战略路线图以支持影响 1700 万人的平台现代化的同时，我还致力于创建一个预测模型，在给定 x 个数据点的情况下预测下一季度的客户服务问题数量。作为数据的消费者，创建您的分析和可视化，同时牢记业务。

6.聪明工作

作为一名分析师，你不能一次又一次地为几乎相同的任务编码。你必须重用你的代码。开始的时候，我从来不热衷于版本控制，也不会为了改变数据点而保存结构。我发现保存一个 SQL 查询或者一个样本数据模型以备后用节省了我大量的时间，提高了我的生产力，并带来了版本控制方面的最佳实践。

第二，我现在强调的一件事是维护文档。
我知道作为一名数据专家，在 Word 文档中写下步骤听起来很无聊，但是相信我，文档帮助我和我的团队很好地理解了项目背景&更好地设定期望。其他成员也很容易迅速加入这一进程。

第三，(无论你能做什么)在你的团队中推动集中数据处理。虽然 100%的数据集中看起来像一个梦想，但它确实支持决策过程的持续改进

1. 促进更好的优化
2. 实现简单快速的数据管理
3. 邀请更好的跨职能协作
4. 将数据战略与业务目标、使命和愿景保持一致
5. 避免使用不同数据源的差异

作为一名分析师，你应该得到数据的一致性。

这就是我的博客的结尾。感谢您的阅读！请在评论中告诉我你感兴趣的项目，你的数据之旅，以及 2022 年你想要什么！

如果你喜欢看这样的故事，可以考虑从这个 链接 报名成为一名中等会员。

数据帐篷快乐！

Rashi 是一名来自芝加哥的数据奇才，他喜欢将数据可视化，并创造富有洞察力的故事来传达商业见解。她是一名全职的医疗保健数据分析师，周末喝一杯好咖啡，写一些关于数据的博客……

6 种鲜为人知的 SQL 技术每月为您节省 100 个小时

原文：https://towardsdatascience.com/6-lesser-known-sql-techniques-to-save-you-100-hours-a-month-10ceed47d3fe

使用这些简单的技术使您的分析和数据提取更容易

在八年的数据职业生涯中，我依靠一些简单但鲜为人知的 SQL 技术为自己节省了无数的时间来执行分析和构建 ETL 管道。

在本文中，我将分享六个反复出现的问题:

从表中查找和删除重复记录

with x as (select *, row_number() over(partition by [key],[key],[key] order by [key]) as rowRank from {schema}.{table})
select * from x where rowRank > 1;

没有比复制品更糟糕的了。可怕的重复记录给我的数据生命周期带来了巨大的痛苦。重复会弄乱任何分析或仪表板——尤其是那些不会因为简单的 DISTINCT 子句而消失的分析或仪表板。有多种方法可以识别重复项，但我发现上面的例子是最简单的。

只需将主查询包装在一个 CTE 中，在您希望检查的所有变量之后，添加一个在所有表键上分区的 row_number 函数。该分区必须包含所有表键才能正常工作，否则您可能会将非重复项错误分类。 row_number 函数在这里做的是对您提供的所有键实例进行排序。在 CTE 之后，运行一个简单的选择和过滤，其中新的row _ numberfunction字段大于 1。输出将返回所有重复的记录——因为任何具有 rowRank > 1 的记录在表中都有重复的键。此外，您可以通过运行以下命令来查看有多少重复记录:

*with x as (select *, row_number() over(partition by [key],[key],[key] order by [key]) as rowRank from {schema}.{table})
select [keys], max(rowRank) - 1 num_duplicates from x group by [keys];*

最后，如果您想删除所有的重复项，您实际上可以在 CTE 中使用 delete 语句！

*with x as (select *, row_number() over(partition by [key],[key],[key] order by [key]) as rowRank from {schema}.{table})
delete * from x where rowRank > 1;*

注意:delete 将永久地从表中删除记录——所以应该非常小心地使用它。测试这种方法的一种方法是创建一个有问题的表的临时副本，并在第一个副本上运行删除操作。然后在主表上执行删除之前做一些质量保证。

凯文·Ku 从派克斯拍摄的照片

从表中查询最*的一组记录

*select a.*, a.[date] from {schema}.{table} a 
join (select max(date) maxDate from schema.table) b 
on a.date = b.maxDate*

大多数数据专业人员都处理大量时间序列数据。然而，时间序列不仅仅是带有日期戳的值，它还可以是数据集的带有日期戳的版本。例如，在我目前的工作中，我们会定期“快照”数据集当天版本的副本，以便我们可以跟踪它如何随着时间的推移而变化。从表中获取最新的记录集(即最新的“版本”)变得很重要。上面的查询通过在最大日期字段上将有问题的表连接到自身来实现这一点。内部联接筛选出日期不等于最大日期的所有记录。或者，您可以使用左连接，然后使用 where 子句进行筛选:

*select a.*, a.[date], b.maxDate from {schema}.{table} a 
left join (select max(date) maxDate from schema.table) b 
on a.date = b.maxDate
where date = maxDate*

每月或每周开始/周末汇总每日数据

每月

*select [key], sum([field]),  DATEADD(month, DATEDIFF(month, 0, [date field]), 0) as month from {schema}.{table} group by [key]*

周初

*select [key], sum([field]),  DATEADD(wk, DATEDIFF(wk, 6, [date]), 6) as weekBeginning from {schema}.{table} group by [key]*

以上两种技术将允许您快速、轻松地在月初或周初对每日级别的时间序列数据进行分组。SQL 中还有其他日期函数可以做到这一点，但我发现这些是最简单的。这种技术还有助于在仪表板工具或 excel 中更容易地显示时间序列。例如，我经常喜欢使用以“YYYY-MM”的形式显示时间序列中连续几个月的视觉效果，以这种方式设置查询将使这一工作变得更加容易。

聚集自定义(案例时)类别的数据

*select [key], sum([field]), 
CASE WHEN date between '2022-09-01' and '2022-12-31' then 'Fall'
WHEN date between '2022-01-01' and '2022-03-31' then 'Winter'
WHEN date between '2022-04-01' and '2022-06-30' then 'Spring'
WHEN date between '2022-07-01' and '2022-08-31' then 'Summer' end as Seasons from {schema}.{table} group by 
CASE WHEN date between '2022-09-01' and '2022-12-31' then 'Fall'
WHEN date between '2022-01-01' and '2022-03-31' then 'Winter'
WHEN date between '2022-04-01' and '2022-06-30' then 'Spring'
WHEN date between '2022-07-01' and '2022-08-31' then 'Summer' end*

使用这种技术，您可以使用 CASE 语句和 GROUP BY 子句聚合自定义类别的数据。这可以在上面的一个语句中完成，或者如果你想避免使用长组，你可以使用 CTE。(注意:在 GROUP BY case 语句中，以“end”结尾，而不是像 SELECT 语句中那样以“end as”结尾)。

*WITH X as (select [key], [field]), 
CASE WHEN date between '2022-09-01' and '2022-12-31' then 'Fall'
WHEN date between '2022-01-01' and '2022-03-31' then 'Winter'
WHEN date between '2022-04-01' and '2022-06-30' then 'Spring'
WHEN date between '2022-07-01' and '2022-08-31' then 'Summer' end as Seasons from {schema}.{table})
select [key], sum([field]), Seasons from X group by Seasons* 

在这个例子中，我使用日期参数创建了一个“季节”字段，但是您可以做任何事情。

在同一个表中找出今天和昨天(或任意两个日期)的区别

*-- MS SQL SERVER 2016 or laterwith x as (
select *, row_number() over(partition by [keys] order by [date_field] desc) as dateOrder
from {schema}.{table}
where [date_field] >= dateadd(day,-2,getdate()))
,
x1 as (
select * from x where dateOrder = 1),
x2 as (select * from x where dateOrder = 2)
select [fields] from x1 
left join x2 on x1.key = x2.key (and x1.key = x2.key and x1.key = x2.key)
where x2.[key] is null -- POSTGRES SQL with x as (
select *, row_number() over(partition by [keys] order by [date_field] desc) as dateOrder
from {schema}.{table}
where [date_field] >= CURRENT_TIMESTAMP - interval '2 day'
,
x1 as (
select * from x where dateOrder = 1),
x2 as (select * from x where dateOrder = 2)
select [fields] from x1 
left join x2 on x1.key = x2.key (and x1.key = x2.key and x1.key = x2.key)
where x2.[key] is null*

这一个看起来非常合适，但是它是一个经常出现的用例。它的一些用途:

• 监视每天有多少新记录被添加到表中。
• 识别在“快照”表中的两个日期之间添加的新记录(即，正如我上面描述的，这些表具有相同数据集/数据源的时间戳副本)。

将一个表中的数据合并到另一个表中(最简单的方法)

*delete from {schema}.{target_table} where exists (select 1 from {schema}.{source_table} where {schema}.{source_table}.[key] = {schema}.{target_table}.[key])*

有许多方法可以将数据从一个表合并到另一个表。MS SQL 实际上有一个 MERGE 语句来做这样的事情。然而，我发现以上是在脚本化 ETL 管道中设置数据合并的最简单的方法。

我编写了大量代码来自动从 API 获取数据，然后例行公事地将新数据转储到数据库表中。通常，我的做法是让 Python 脚本拉回特定时间范围内的新数据(2 天-1 周或更长时间，具体取决于数据源)，然后将所有数据推送到临时表中。一旦新数据出现在临时表中，我就运行上面的 delete 语句，该语句将扫描生产表，查找新表中已经存在的记录。最后，一旦删除了目标表中所有已经存在的记录，我就运行一个简单的从临时表到目标表的插入操作。

我希望这些技术中至少有一种对您来说是新的，并且有助于简化您的查询和分析。如果你喜欢这篇文章，你可以在这里查看我的其他作品。如果您对从 REST APIs 获取数据感兴趣，那么这篇文章也会很有帮助。

来自银行业数据科学家的 6 堂课

原文：https://towardsdatascience.com/6-lessons-from-a-data-scientist-in-the-banking-industry-11dc4a8a7234

为什么我在数据科学领域的第一份工作不是我所期望的

安德烈·泰森在 Unsplash 上拍摄的照片

新衬衫，新鞋。我已经为我在爱尔兰最大银行之一的第一份工作做好了准备。我很兴奋。回想起来，我有很好的理由。我能够从事有影响力的项目，我学到了很多东西。事实上，最大的教训是:

数据科学不是我所期望的。

我期望在计算机科学、统计学和机器学*的前沿工作。运用新方法推动独特见解。自动化一切。简而言之，我成了围绕这一职业大肆宣传的牺牲品。

所以，我想和你分享我的经验。我希望我们可以避开炒作，提高您对数据科学家工作的理解。让我们开始学*第一课。

第一课:逻辑回归大有帮助

我的工作包括建立信用风险和欺诈模型。这些都是有影响力的模型。它们被用于大规模的贷款自动化。我说的是每年价值数十亿欧元的申请。你可能认为，在如此高的风险下，我会进行高级机器学*。你错了。

我专门用逻辑回归建立模型。我并不孤单。从银行业到保险业，金融世界的大部分都在回归。为什么？

因为这些模型管用。

回归模型的表现足够好。银行也普遍理解和接受这些标准。要采用一种新算法，它不仅要优于回归算法。改进还必须证明解释算法的努力是正确的。

通过回归，我最终得到了具有 8 到 10 个特征的模型。这些特征中的每一个都必须彻底解释清楚。一位非技术同事不得不承认他们捕捉到了现实中存在的关系。

有了回归，这就简单了。黑盒模型会更加难以解释。当然，我可以使用像 SHAP 或PDP 和 ICE Plots 这样的方法。问题是他们不会给我同样程度的确定性。我还需要解释我用来解释我的模型的方法。

这令人失望。离开大学后，我学到了很多关于随机森林、XGBoost 和神经网络的知识。我很高兴能应用这些技术。在第一周，我记得我的一位资深同事说:

“F 忘掉那些花哨的模特”

她是对的。许多数据科学家永远不会需要它们。

第二课:机器学*有很多应用

不那么令人失望的是意识到机器学*是多么有用。当我单独看到银行业的所有应用程序时，我就明白了。仅举几个例子:

• 信用风险——预测因财务困境导致的违约
• 欺诈—预测客户是否不打算偿还贷款
• 预先区域—识别陷入财务困境的客户
• 流失——识别打算离开银行的客户
• 营销——确定向其推销产品的最佳客户

这些模型用于自动化整个银行的流程。研究它们让我兴奋不已。这给了我机会去创造一些比我一个人更能影响世界的东西。这给了我很大的动力。非常需要的动力。

第三课:处理数据是一项艰苦的工作

在大学构建模型轻而易举——干净的数据集、预先设计的功能和自动化的超参数调整。我花了几个小时才达到 99.9%的准确率。想象一下，当我们三个人的团队花了 8 个月的时间来建立一个信用风险模型时，我有多惊讶。8 个月！

大部分时间都花在了构建数据集上。这不仅包括模型特征。我必须证明我所有的模特决策是正确的。为此，我纳入了抽样和代表性分析、细分分析、公平性分析和模型评估所需的任何变量。

我不得不从头开始构建这些变量。底层数据字段分布在多个具有不一致文档的表中(如果有的话)。一旦建成，调试就来了。哦，调试。想到这我还是会不寒而栗。

如果犯了错误(他们是)，他们将导致很多痛苦(他们做到了)。为了尽量减少这种情况，做了大量的测试。问题是没有什么可以与我的模型特征进行比较。我能做的就是:

• 感官检查。这包括可视化特性趋势，并用领域知识验证它们。收入突然下降有意义吗？是的，科维德。
• 单元测试。这意味着手动计算一些客户的特征值。

我不知道数据科学的这一面。这不是我听说的“2019 年最性感的工作”。太无聊了。然而，这是值得的。看到最终的模型，我充满了自豪。那是我的孩子。我的孩子，我立即送去批准数千笔贷款。

第 4 课:领域知识和软技能是关键

我很快意识到非技术技能是多么重要。沟通是关键。没有作业简介或措辞清晰的考试问题。有时，任务是以随意的方式描述的。我没想到我工作的一部分会是理解我被要求做什么。

我需要提高我的沟通技巧和领域知识，以便有效地应用我的技术技能。

随着我获得更多的经验，这变得更容易了。更确切地说，随着我对银行业的了解。一开始，我甚至不知道该问什么样的澄清性问题。有很多行话和 tla(三个字母的缩写词)。一旦我掌握了这门语言，我的生活就变得容易多了。

第五课:不要被花哨的标题所左右

数据科学家是一个热门的工作。它也只是一个职称。你可能会被期望做各种各样的任务。公司知道人们想成为数据科学家，他们会适当地推销他们的职位。

我和一群应届毕业生一起开始了我的工作。我很幸运。我最终从事了我认为是数据科学的工作。我的一些同学就没有这么幸运了。只有 SQL 和 excel。真的，他们应该被称为数据分析师。

回头一看，一个警讯是系里的学长都有“定量分析”的头衔。新来的大三学生都被称为“数据科学家”。工作突然变了吗？号码

当我开始下一份工作时，我会更少关注职位名称。我会问更多关于日常工作的问题。下一课教我也要询问做这项工作所用的工具。

第六课:工具很重要

一个普遍的观点是，你应该关注过程而不是工具。我认为这来自于从未使用过时技术的数据科学家。我同意过程是重要的。获得实施这些流程的最佳工具也同样重要。

旧工具正在流失。它们在银行业也很丰富。

大学毕业后，我有了使用 Python 的经验。您可以用几行代码构建复杂的模型和交互式可视化。在银行业，我们有特别助理。SAS 可以做 Python 所能做的一小部分，而付出的努力却是多倍的。我觉得这有点令人泄气。我知道我可以用开源工具做得更好，但是没有办法使用它们。

使用旧工具也让我的技能变得不那么有市场。该行业发展迅速。当我开始申请新工作时，我意识到了这一点。95%的数据科学工作申请会提到 Python、Pytorch、TensorFlow 等工具。公司希望员工对最新技术有经验。

最后，所有的工作都有不利的一面。我对我的第一次经历很满意。我完成了有趣的项目。我的工作确实对爱尔兰经济产生了重大影响。要是我有更好的工具来做这项工作就好了。

我希望这篇文章对你有帮助！如果你想看更多，你可以成为我的https://conorosullyds.medium.com/membership推荐会员来支持我。你可以访问 medium 上的所有文章，我可以得到你的部分费用。

**https://conorosullyds.medium.com/membership

你可以在|Twitter|YouTube|时事通讯上找到我——注册免费参加 Python SHAP 课程**

我从开发开源项目中学到的 6 个教训

原文：https://towardsdatascience.com/6-lessons-i-learned-from-developing-open-source-projects-4617e26f247c

数据科学家的视角

开源是一个如此神奇的概念！通过整合整个社区的资源、技能和知识，我们可以创造出孤立的工具。从这些合作中产生的工具不仅仅是它们各部分的总和。

因此，我们数据科学家使用这种免费的软件，这种软件推动了如此多的技术，同时仍有机会参与其开发。

在过去的几年里，我非常幸运地参与了开源项目，并有机会开发和维护了几个软件包！

开发开源不仅仅是编码

在此期间，有许多障碍需要克服，也有许多教训需要吸取。从棘手的依赖性和 API 设计选择到与用户群的交流。

不管是作为一名作者、维护者还是开发者，从事开源工作都是令人望而生畏的！通过这篇文章，我分享了我在这个领域的一些经验，希望对那些想开发开源软件的人有所帮助。

1.文档被低估了

当你创建开源软件时，你通常不是专门为自己制作软件包。来自各种不同背景的用户将会使用你的软件。适当的文档对帮助这些用户开始有很大的帮助。

然而，不要低估文档对您的包的可用性的影响！你可以用它来解释复杂的算法，给出大量的教程，展示用例，甚至允许交互式的例子。

尤其是数据科学相关的软件，涉及到复杂的算法时，可能会很难理解。像对待故事一样对待这些解释经常帮助我使它们更加直观。

相信我，写好文档本身就是一种技能。

另一个好处是编写可靠的文档减少了花在问题上的时间。如果用户能在你的文档中找到答案，他们就没有理由问问题。

文档中概述了 KeyBERT 的工作原理。

然而，创建文档不仅仅是写文档。可视化你的算法或软件在使它变得直观方面有很大的帮助。当你想在文档中形象化算法原理时，你可以从杰伊·阿拉姆马那里学到很多东西。他的可视化甚至出现在官方的数字文档中！

2.社区就是一切

你的用户群，社区，是你的软件的重要组成部分。由于我们正在开发开源软件，可以肯定地说，我们希望他们参与到开发中来。

通过参与社区，您可以吸引他们分享问题和错误，但也可以提出进一步开发的请求和好想法！所有这些都有助于为他们创造一些东西。

开源社区不仅仅是各个部分的总和

BERTopic 中的许多核心功能，如在线主题建模，由于受到用户的高度要求而得以实现。因此，社区非常活跃，在发现问题和开发新功能方面提供了巨大的帮助。

由社区实现特性请求有很长的路要走！此处节选讨论。

3.绝佳的学*机会

无论您的包将被使用数百万次还是仅仅几次，创建一个包都是学*更多关于开源、MLOps、单元测试、API 设计等的绝好机会。在开发开源软件的过程中，我学到了比日常工作中更多的技能。

与社区本身的互动也是一个巨大的学*机会。他们会告诉你他们喜欢或不喜欢哪些设计。有时，我看到同一个问题在几个月的时间里出现了几次。这表明我应该重新考虑设计，因为它不像我预期的那样用户友好！

最重要的是，开发开源项目给了我与其他开发者合作的机会。

4.压力会很大

在工作之外从事你自己的开源项目也有它的缺点。对我来说，最重要的一点是维护包、回答问题和参与讨论可能是相当多的工作。

如果你有内在的动力，这肯定会有所帮助，但这仍然需要相当长的时间来确保一切都在一起。

幸运的是，当回答问题、展示用例等时，你可以向你的社区寻求帮助。

在过去的几年里，我已经学会了在遇到重大变化的时候放松一点。尤其是当它涉及到依赖性的时候，有时候你能做的事情实在太多了！

5.Github 明星不等于质量！

知道你的包使用的频率对理解它有多流行有很大的帮助。然而，许多人仍在使用 Github stars 将一个包等同于质量和受欢迎程度。

确保定义正确的指标。GitHub 明星可以仅仅因为营销得当而被夸大。很多明星并不意味着受欢迎。

作为数据科学家，我们必须首先理解我们到底在测量什么。GitHub 星无非就是用户给一个包打个星。它甚至不意味着他们已经使用了该软件或它实际上正在工作！

KeyBERT 的下载次数。比 Github stars 好得多的指标。

技术上来说，我可以付钱给一千个人来开始我的回复。相反，我关注各种统计数据，比如下载和分叉，还有我每天收到的问题数量。

例如，如果你的软件包出现在黑客新闻上，这很好，但它不会告诉你它是否被持续使用。

6.API 设计心理学

作为一名心理学家，我倾向于把很多注意力放在我的包装设计上。这包括像文档和教程这样的东西，但它甚至转化为我如何编码。

确保这个包易于使用和安装会使采用变得更加简单。特别是当你关注模块化和透明性这样的设计理念时，一些包会成为使用的热点。

用 BERTopic 进行主题建模的模块化设计。

在开发新功能的同时，从心理学家的角度出发，让我们更容易知道应该关注什么。用户在找什么？我怎样才能用一种解释算法的方式编码？为什么用户实际上在用这个套餐？我的代码的主要缺点是什么？

花时间了解普通用户推动采用

所有上述情况往往导致一个基本但重要的规则；
保持超级简单

就个人而言，如果我发现一个新的包很难安装和使用，我就不太可能在我的工作流程中采用它。

感谢您的阅读！

如果你和我一样，对人工智能、数据科学或心理学充满热情，请随时在LinkedIn上添加我，或在 Twitter 上关注我。你也可以在我的 个人网站 上找到我的一些内容。

所有未注明出处的图片均由作者创作

6 个让你的下一份数据分析工作变得更好的技巧

原文：https://towardsdatascience.com/6-looker-tips-that-will-power-up-your-next-data-analysis-job-404971a82939

探索从基础到高级的六个技巧，帮助你在下一个项目中用 Looker 完成更多

马库斯·温克勒在 Unsplash 上的照片

什么是 Looker？

Looker 是谷歌的商业智能(BI)工具。它完全基于网络，本质上是多平台的。我很高兴与 PowerBI、Tableau、SAS 和其他公司一起工作。然而，由于其漂亮的表示层、强大的 LookML 建模语言以及与 GitHub 的集成，Looker 仍然是我最喜欢的 BI 平台。

Looker 有一个很棒的培训环境，你可以用它来学*平台的基础知识。我强烈建议你从那里开始。我将使用本文中提供的培训环境和样本数据。查看旁观者连接。

给超级用户一些建议怎么样？

在过去的几年里，我在 Looker 中开发了一些技巧和窍门，可能对每个人都有好处。其中一些相当简单，但也许你还没有遇到过。其他的是真正的超级用户技巧，会让你的长相更上一层楼。我将从基本的技巧开始，以几个我绝对喜欢的结束。

1. 表格计算
2. 另存为便于共享的外观
3. 分组维度
4. 用于清理维度的 CASE 语句
5. 在单值切片中手动设置目标
6. 从 SQL Runner 创建快速浏览器

表格计算

这个技巧非常简单，但是有巨大的力量。作为 Looker Explorer 的用户，您可能希望对您的数据执行额外的计算，这些计算不属于所提供的测量。实现这一点的方法是通过表格计算。将表格计算想象成在 Excel 的单元格中输入公式。您可以从其他列获取数据，并对其执行许多不同的操作，从简单的加/减/乘/除到更高级的计算，如统计测试。

在这个简单的例子中，我将通过将两个收入除以订单项目计数来得到每个订购项目的平均收入。您可以选择如何格式化数据，并给它一个更好的名称。

作者图片

我们可以在这里看到我们的表计算的结果。它们会以绿色显示，给你一个视觉指示，表明它们不是尺寸(蓝色)或尺寸(褐色)。****

作者图片

注意:表格计算只适用于已经显示在列中的数据。如果删除其中一个度量，计算将会失败。

另存为便于共享的外观

另一个很基础的，但是值得一提。早期使用 Looker 的一个限制是非常强大的探索功能只能通过更昂贵的分析师层级许可证获得。探索功能是人们可以自助服务自己的数据分析的方式，但如果没有许可证，他们将只能利用控制面板上的内容。**

但是，将浏览保存到外观有一个例外！从齿轮图标中，选择保存>为外观，然后给它一个名称和位置。**

作者图片

保存后，你可以与他人分享这些照片，他们甚至可以调整你设置的滤镜来体验一下自己探索的感觉。**

作者图片

分组维度

这个特殊的技巧花了我一段时间才发现，但现在我一直在使用它。当您的数据需要分类信息，您希望更好地呈现数据时，不要害怕；您可以使用组选项创建合成类别。**

首先，从选择要分组的维度开始。然后，从菜单中选择组选项(三个垂直点)。**

作者图片

接下来，您创建您想要教它如何对数据进行分组的条件。我正在为这个零售服装数据集创建一个分类特征，包括上衣、下装，以及另一个名为其他的包罗万象的类别。(选择分组剩余值选项创建一个总括类别。)**

作者图片

现在我们可以看到我们的新维度以及它是如何对我们的数据进行分组的。超级快速简单。

作者图片

用于清理维度的 CASE 语句

欢迎来到我的超级用户版块！假设您想要做一些类似于上面的分组示例的事情，但是您希望它更持久。您可以通过直接利用 Explorer 的 LookML 定义中的CASE语句来实现这一点。在下面的情况中，我有两个条件，这两个条件对于一个失败的工作来说都是一样的。通过使用这种方法，我将这两个归为一类失败。我也用这个来清理标签和大写每个单词的第一个字母。**

***dimension:  status{
    label: "Status"
    description: "Status of the job (success, failure, cancelled)."
    type: string
    case: {
      when: {
        sql: ${TABLE}.status='cancelled';;
        label: "Cancelled"
      }
      when: {
        sql: ${TABLE}.status='failure' or
          ${TABLE}.status='failed';;
        label: "Failed"
      }
      when: {
        sql: ${TABLE}.status='success' ;;
        label: "Success"
      }
      else: "Unknown"
    }
  }***

我喜欢使用这种方法的另一种方式是从数据库中清除值，并将它们转换成更易于阅读的格式。例如，我可能有一个值为US、UK、CA的列。我可以用一个CASE语句把它们变成United States、United Kingdom、Canada。

在单值切片中手动设置目标

这条建议是我最喜欢的建议的亚军。在设定 KPI 目标时，我们要做的一件基本事情就是为它们选择一个目标。当你有一个你想要达到的目标时，你不只是想看到一个与前一年的比较数字，看看你在这个目标上的表现如何！问题是您需要一种方法来为 Looker 中的度量设置目标值。我想出了这个方法，结果证明效果非常好！

当使用单值可视化时，您可以选择设置一个比较值。Looker 的工作方式是将结果的第一行显示为单值视图中的主值，第二行将作为比较值。在正常情况下，这是通过让您计算月环比或年同比来实现的。**

第一步是创建一个表计算，它将显示第一行的实际值，然后显示第二行和后续行的固定值。您可以用一个寻找行值的If语句来完成这个任务，我下面的例子使用了一个非常简单的硬编码年份。

注意:您可以利用now()功能让这变得更加智能，这样您的仪表板就不需要在一年结束时进行调整。如果你能做到这一点，你会得到加分！

作者图片

接下来，将视觉上的比较值设置为计算进度(带百分比)。就是这样！**

作者图片

注意 Target 表计算如何显示第一行的实际值和第二行的硬编码值。

为了实现这一点，隐藏了可视化中的其他列。对不是目标列的每一列都这样做。****

作者图片

更新

本周，在与同事交谈时，我学会了一种新方法来设定一个更容易的目标。像前面一样创建一个表计算，但是不用' if '语句，而是直接输入目标的数值！然后，确保取消隐藏值列和目标列。就是这样！

作者图片

从 SQL Runner 创建快速浏览器

今天的最后一条建议，也是迄今为止改变我游戏规则的一条。从 SQL Runner 中的查询创建浏览器的能力。让这个功能如此强大的是，您可以快速地跨多个表执行分析，而不需要所有的 LookML 配置。**

我如何使用这个？假设您的数据仓库中有几个一直在使用的大规模表。然后，您从另一个来源获得一组数据，并希望将它们连接在一起。在我的例子中，我可能会以 CSV 格式获取一些数据，这些数据包含来自不同来源的客户列表，我会将这些数据上传到仓库中的一个临时表中。一旦它在仓库中，我就可以执行与其他表的连接来完成任务。但是，因为这是临时的，所以我只想建立一些基础设施，使它永久地出现在 Looker 中。 SQL Runner 是实现这一切的绝佳场所。

转到 SQL Runner 并构建您的查询，就像下面这样简单，或者它甚至可以是用公共表表达式 (CTEs)构建的大规模查询。

***SELECT * 
FROM `cloud-training-demos.looker_ecomm.order_items` AS order_items
LEFT JOIN `cloud-training-demos.looker_ecomm.users` AS users 
ON order_items.user_id = users.id
limit 100***

一旦构建了查询，单击 Explore 选项。您会受到一些限制。默认情况下，它只有一个度量值(计数)。如果您需要一些特定的度量，您可以通过选择字段并选取所需的聚合(计数、求和、平均)来添加它们。在大多数情况下，您也不能将其保存到仪表板。但是您可以保存到 Explorer 的链接并与其他人共享。利用这个方法，我已经节省了无数的时间。试试看！

作者图片

结论

这就是了。六个快速观察技巧将帮助你提高和加快你的分析。Looker 是一个非常强大的 BI 工具；这些建议将帮助你充分利用它。我从三个基本技巧开始:表计算、将资源管理器保存为外观以及对维度进行分组。接下来，我分享了几个更高级的技巧。我首先从使用 CASE 语句清理数据开始。然后，我向您展示了如何在单值图块中手动设置目标。最后，我向您展示了如何在 SQL Runner 中通过查询创建浏览器。享受快乐建筑！

如果你喜欢阅读这样的故事，并想支持我成为一名作家，考虑注册成为一名媒体成员。一个月 5 美元，让你可以无限制地访问成千上万篇文章。如果您使用 我的链接 注册，我将为您赚取一小笔佣金，无需额外费用。

任何学*数据科学的人都应该知道的 6 种机器学*算法

原文：https://towardsdatascience.com/6-machine-learning-algorithms-anyone-learning-data-science-should-know-cb6c388a6fb3

用简单的英语解释机器学*算法

图片来自 Shutterstock，授权给 Frank Andrade

机器学*是任何学*数据科学的人都应该知道的领域之一。如果你是数据科学的新手，你可能听说过“算法”或“模型”这些词，但不知道它们与机器学*有什么关系。

机器学*算法分为有监督的和无监督的。

监督学*算法对标记的输入和输出数据(也称为目标)之间的关系进行建模。然后，该模型用于使用新标记的输入数据来预测新观察的标记。如果目标变量是离散的，我们处理的是分类问题，而如果目标变量是连续的，我们处理的是回归问题。

相比之下，无监督学*不依赖于标记的输入/输出数据，而是处理未标记的数据。

作者在 Canva 上制作的图像

这里有 6 个监督学*算法，任何学*数据科学的人都应该知道。

1.线性回归

线性回归是机器学*中使用的最简单的算法。该算法用于模拟两个或多个变量之间的关系。有两种类型的线性回归—简单线性回归和多元线性回归。

在简单线性回归中，有一个自变量和一个因变量，而在多元线性回归中，有多个自变量和一个因变量。

多元线性回归方程如下:

其中，y为因变量(目标值)，x1, x2, … xn为自变量(预测值)，b0为截距，b1, b2, ... bn为系数，n为观察次数。

在下图中，您将看到线性回归方程的简化版本。

作者图片

正如你在上面的图片中看到的，有一个线性关系，所以如果一个变量增加或减少，另一个变量也会增加或减少。

我们可以用线性回归来预测分数、工资、房价等。也就是说，预测精度不如其他算法。

2.SVM

支持向量机(SVM)是一种受监督的学*算法，主要用于分类问题。我们通常向 SVM 模型提供带标签的训练数据来对新文本进行分类。

当我们的样本数量有限并且速度是首要考虑因素时，SVM 是一个不错的选择。这就是当我们在文本分类中处理具有几千个标记样本的数据集时使用它的原因。

为了更好地理解 SVM 是如何工作的，让我们看一个例子。

在下图中，我们有两个标签(绿色和黄色)和两个特征(x 和 y)。假设我们想要构建一个分类器来发现我们的文本数据是绿色还是黄色。如果是这种情况，我们将在一个 n 维空间中绘制每个观察值(也称为数据点)，其中“n”是使用的特征的数量。

我们只有两个特征，所以观察结果绘制在二维空间中，如下图所示。

作者图片

SVM 获取数据点，并制作一个超平面来最好地区分这些类别。因为观察值是在二维空间中绘制的，所以超平面是一条线。

作者图片

这条红线也被称为决策边界。决策边界决定了数据点是属于一个类还是属于另一个类。在我们的例子中，如果数据点落在左侧，它将被分类为绿色，而如果它落在右侧，它将被分类为黄色。

3.决策图表

如果你对机器学*一无所知，你可能仍然知道决策树。

决策树是一种用于规划、统计和机器学*的模型，它使用决策/结果的树状结构来评估特定问题中涉及的可能事件。

这是一个决策树，评估人们想踢足球的场景。

来源:维基共享资源

每个正方形称为一个节点。决策树的最后节点被称为树叶。为了进行预测，我们从树根(第一个节点)开始。将评估决策树中的每个节点。然后我们沿着与评价一致的分支，跳到下一个节点。

决策树算法可用于解决回归和分类问题。我们使用决策树来建立一个模型，该模型可以通过学*从训练数据中推断出的决策树规则来预测目标变量的类或值。

4.随机森林

随机森林是许多决策树的集合。它结合了决策树的简单性和灵活性，从而提高了准确性。

要创建随机森林，首先，我们需要创建一个“引导”数据集。Bootstrapping 是从原始数据中随机选择样本(我们甚至可以多次选择同一个样本)。然后，我们使用自举数据集来创建决策树。

维基共享资源

这种方法被称为“装袋”如果我们多次重复前面的步骤，我们会得到很多树。这种树的多样性使得随机森林比单一的决策树更有效。

维基共享资源

如果随机森林用于分类任务，模型将选择每个决策树的预测模式。对于回归任务，模型从决策树中选择结果的平均值。

5.朴素贝叶斯

朴素贝叶斯是一种有监督的学*算法，使用条件概率来预测一个类。

朴素贝叶斯算法基于贝叶斯定理:

p(A|B): Probability of event A given event B has already occurred
p(B|A): Probability of event B given event A has already occurred
p(A): Probability of event A
p(B): Probability of event B

朴素贝叶斯假设每个特征都是相互独立的，但事实并非总是如此，所以在选择该算法之前，我们应该检查我们的数据。

特征相互独立的假设使得朴素贝叶斯比更复杂的算法更快；但是，这也使得该算法不太准确。

我们可以使用朴素贝叶斯来预测天气预报、欺诈检测等等。

6.逻辑回归

逻辑回归是一种监督的学*算法，常用于二元分类问题。这意味着我们可以使用逻辑回归来预测客户是否会流失，并发现邮件是否是垃圾邮件。

逻辑回归基于逻辑函数(也称为 sigmoid 函数)，它接受一个值，并分配一个介于 0 和 1 之间的概率。

这是逻辑回归的图表:

为了更好地理解逻辑回归是如何工作的，考虑一个场景，我们需要对一封电子邮件是否是垃圾邮件进行分类。

在图中，如果 Z 趋于无穷大，Y(我们的目标值)将变为 1，这意味着该电子邮件是垃圾邮件。但是，如果 Z 趋于负无穷大，Y 将变为 0，这意味着该邮件不是垃圾邮件。

输出值是一个概率，所以如果我们得到的值是 0.64，这意味着有 64%的机会，一封电子邮件将是垃圾邮件。

用 Python 学*数据科学？ 通过加入我的 10k+人电子邮件列表，获取我的免费 Python for Data Science 备忘单。

如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑报名成为一名媒体成员。每月 5 美元，让您可以无限制地访问数以千计的 Python 指南和数据科学文章。如果你使用我的链接注册，我会赚一小笔佣金，不需要你额外付费。

**https://frank-andrade.medium.com/membership **

学*数据科学时需要了解的 6 种机器学*算法

原文：https://towardsdatascience.com/6-machine-learning-algorithms-to-know-when-learning-data-science-6e45ef139b99

6 种流行的机器学*算法的简短说明

图片由来自 Pixabay 的烈斗·谢维勒拍摄

机器学*在过去十年左右变得非常流行，许多行业都采用新算法来自动化流程和提高生产率。

机器学*是人工智能的一个分支，涉及机器/计算机从数据中学*并生成结果，而无需显式编程。在传统编程中，我们提供输入数据和生成输出的规则。在机器学*中，我们让算法通过提供输入数据和答案来找出规则。

一旦这些算法经过训练，我们就可以用它们来对呈现给它们的任何新数据进行预测。

在这篇文章中，我们将看看你需要知道的 6 种常用的机器学*算法。

机器学*模型的类型

机器学*算法可以分为四种主要类型:监督、非监督、半监督和强化。前两种，有监督的和无监督的，是与本文讨论的算法相关的主要类别。

监督学*旨在通过使用带标签的数据集从示例中学*。这是输入数据与正确输出配对的地方。根据目标(输出)变量的数据类型，监督学*可以进一步细分为分类数据的分类或连续数据的回归。

无监督学*则相反，不依赖于标记数据集。相反，这些算法用于识别数据中隐藏的模式，这些模式可能不容易被人眼看到。无监督学*通常应用于探索性数据分析(EDA)过程中，包括基于相似性和维度减少的数据聚类，其中多个输入可以减少到更有意义的输入数量，同时最大化数据可变性。

线性回归

线性回归是一种受监督的机器学*算法，您将在数据科学之旅的早期遇到，并且您很可能在过去使用过它。

简而言之，您试图对两个(简单线性回归)或多个变量(多元线性回归)之间的关系进行建模。这使我们能够理解变量之间的关系，并推导出一个方程，我们可以用它来预测我们的目标变量。

通过一系列点的线性回归。图片由作者提供。

通过简单的线性回归，我们试图了解两个变量之间的关系:自变量(x)是我们的解释变量，因变量(y)是被研究的变量。例如，我们可能试图找出房价(因变量)与房屋面积(自变量)之间的关系。

在多元线性回归的情况下，我们有一个多对一的关系，其中我们有许多自变量(X1-Xn)和一个因变量(y)。

简单线性回归(一对一关系)和多元线性回归(多对一关系)的区别。图片由作者提供。

当我们运行线性回归时，我们得到如下所示形式的方程，其中y是我们的因变量，换句话说，我们的目标变量和x1, x2, x3 ... xn是自变量。

b0是 y 轴截距，b1, b2, b3 ... bn是每个变量的系数(乘数)。

简单线性回归方程与多元线性回归方程的比较。图片由作者提供。

尽管线性回归很容易实现，但是您必须小心异常值，因为它们会对导出的回归结果产生巨大影响。

决策树

决策树是一种受监督的机器学*算法，使用起来相当直观。我们每天都利用它们来做决策，尽管我们并不把它们称为决策树。

例如，我们可能在早上打开窗帘，查看天气情况。如果下雨，如果风不太大，我们可能要穿夹克或带把伞。同样，如果天气晴朗，我们可能想用帽子来保护自己；如果天气不好，我们可能想根据气温穿上暖和的夹克。

日常生活中使用的决策树示例。图片由作者提供。

决策树是类似于包含决策和可能结果的树状结构的模型。它们由根节点、决策节点和叶节点组成，根节点构成了树的起点，决策节点用于根据条件分割数据，叶节点构成了树的终点和最终结果。

一旦决策树形成，当新数据出现时，我们可以用它来预测值。

决策树可能会有一些问题，例如对训练数据的过度拟合或欠拟合，并且在解释它们变得更大时会变得很麻烦。

随机森林

随机森林是一种受监督的集成机器学*算法，它聚集了来自多个决策树的结果，并且可以应用于基于分类和回归的问题。

使用来自多个决策树的结果是一个简单的概念，并且允许我们减少单个决策树所经历的过拟合和欠拟合的问题。

为了创建随机森林，我们首先需要从主数据集中随机选择样本和特征的子集，这一过程称为“引导”。这些数据随后用于构建决策树。执行自举避免了决策树高度相关的问题，并提高了模型性能。

在下面的例子中，我们可能会从每个决策树中得到不同的结果。然后将这些结果汇总在一起，通过多数投票(分类)或平均(回归)的过程，我们得到最终结果。

岩石物理数据的随机森林算法示例。图片由作者提供。

此外，值得记住的是，随着随机森林中决策树数量的增加，计算时间和使用的资源也会增加。

人工神经网络

在你的数据科学和机器学*之旅的某个时候，你最终会看到一篇提到人工神经网络的文章。

这些是一种非常受欢迎的监督(主要是)机器学*算法，由一系列函数和互连节点(神经元)创建。他们受到人类大脑运作方式的启发——接受输入，通过识别数据中的模式来处理数据，然后输出最终结果。

典型的人工神经网络由三个主要部分组成:输入层、隐藏层和输出层。

输入层是网络中的第一层，是我们传递输入特性的地方。

隐藏层存在于输入层和输出层之间。它由多个节点组成，这些节点接受输入并使用激活函数、权重和偏差对其进行转换。隐藏层数可以大于 1，网络的隐藏层数越多，据说就越深。

输出层是网络中的最后一层，代表通过网络运行数据的最终结果。该图层可以由单个节点组成，如下图所示，也可以由多个节点组成，例如在多类分类问题中。

由输入层、单个隐藏层和单个输出节点组成的神经网络示例。图片来自麦当劳(2022)。

人工神经网络已经在许多应用中使用，包括:银行欺诈检测、图像处理、从图像中识别项目、时间序列预测等等。

支持向量机

支持向量机(SVM)是一种受监督的机器学*算法，可用于分类和回归(SVR)。它们是基于统计学*的健壮的机器学*算法，并且可以应用于线性和非线性问题。它们还提供了一种替代传统人工神经网络的数据驱动方法。

在分类中，支持向量机试图找到一个超平面(2D 空间中的一条线)，该超平面最佳地分离数据并允许对其进行分类。

超平面两侧最*的点称为支持向量。这些点对超平面的位置和方向影响最大。

支持向量分类(左)和支持向量回归(右)的示例。图片由作者提供。

在支持向量回归的情况下，它使用相同的基本原理，并试图通过在定义的阈值内具有最大点数的数据找到最佳拟合线。

支持向量机具有许多优点，例如能够处理与观测值相比具有大量特征的数据，处理非线性数据而不会变得不稳定。然而，当处理大型数据集时，它们在计算上可能变得昂贵，这是由于在优化期间使用了二次规划算法。

k 均值聚类

K-Means 聚类是一种非常常用的无监督机器学*算法，相对容易理解。它主要用于根据属性将相似的数据点组合在一起，从中我们可以识别数据中任何潜在的隐藏模式。

k-means 聚类算法综述。数字代表步骤的顺序。图片由作者提供。

给定一个数据集，k-均值聚类可用于通过最小化数据点和聚类中心点(质心)之间的距离将数据分成“k”个聚类。

每个聚类的质心在数据内的 k 个随机点初始化。然后，基于到最*质心的距离，将剩余的数据点分配给相关的聚类。

然后将质心调整到群集的中心点，并重新分配其周围的点。

这一过程持续到:

• 质心没有变化，换句话说，是稳定的
• 这些点保持在同一个聚类中
• 已经达到用户定义的最大迭代次数

K-means 聚类易于实现、理解，并且可以很好地扩展到大型数据集，但是，该算法要求您选择聚类的数量，并且可能不适用于所有数据集。

[## 如何使用 Python 使用无监督学*对测井数据进行聚类

towardsdatascience.com](/how-to-use-unsupervised-learning-to-cluster-well-log-data-using-python-a552713748b5)

摘要

这里介绍的算法只是您在数据科学之旅中会遇到的算法中的一小部分。有许多视频、文章和书籍详细介绍了这些算法，我强烈建议深入研究您感兴趣的算法。

感谢阅读。在你走之前，你一定要订阅我的内容，把我的文章放到你的收件箱里。 你可以在这里做！*或者，您可以* 注册我的简讯 免费获取更多内容直接发送到您的收件箱。

其次，通过注册会员，你可以获得完整的媒介体验，并支持我自己和成千上万的其他作家。它每个月只花你 5 美元，你可以完全接触到所有令人惊叹的媒体文章，也有机会用你的写作赚钱。如果你用 我的链接报名，你直接用你的一部分费用支持我，不会多花你多少钱。如果你这样做了，非常感谢你的支持！

多步预测的 6 种方法

原文：https://towardsdatascience.com/6-methods-for-multi-step-forecasting-823cbde4127a

如何使用 Python 预测时间序列的多个值

西蒙·伯杰在 Unsplash 上的照片

重要的事情先来。什么是多步预测？

多步预测就是预测时间序列的多个值的问题。

图 1:澳大利亚未来 12 个月外出就餐总支出(十亿)预测。图片作者。

大多数预测问题都被框定为提前一步预测。也就是说，根据最*的事件预测序列的下一个值。但是，对许多问题来说，预测一个单一的步骤是过于狭隘的。

提前预测许多步骤具有重要的实际优势。它减少了长期的不确定性，从而实现了更好的运营规划。图 1 显示了一个为时间序列的下 12 个值生成预测的示例。

预测很难。试图预测未来的许多步骤甚至更糟。当我们试图预测未来时，这一系列的不确定性增加了。

例如，预测明天的最高温度很简单。它会有点像今天的。但是，预测一个月后的最高温度要困难得多。

以下示例显示了误差在预测范围内是如何增加的:

图 2:预测 18 个步骤的性能。这些值表示相对于 t+1 时的误差的百分比增量(提前一步预测)。作者图片

图 2 显示了一个模型在预测范围内的表现(18 个步骤)。

误差随着预测范围的增加而增加。这个误差是上千个时间序列的平均值。我从 gluonts 库得到了它们。

在这个故事的其余部分，我将描述多步预测的 6 种方法。我还将展示如何使用 Python 实现它们。

首先，让我们从创建一个模拟时间序列开始。我用下面的代码做到了这一点:

下面是前几个的样子:

以第一排为例。目标是预测涉及目标变量 t+1，…，t+4 的值[4，5，6，7]。解释变量是过去的 4 个滞后(t，…，t-3)。

现在，让我们看看如何获得多步预测。

1.递归(也称为迭代)

最简单的多步预测方法是递归方法。它的工作原理是为一步预测训练一个单一的模型。也就是预测下一步。然后，使用之前的预测对模型进行迭代，以获得多个步骤的预测。

以下是实现它的方法:

我从头实现了递归，以阐明它是如何工作的。但是，可以使用 sktime 库中可用的方法【recursivetimeseriesregressionpredictor】、。

递归方法很吸引人，因为你只需要一个完整预测范围的单一模型。此外，您不需要提前确定预测范围。

但是，这也有严重的缺陷。用自己的预测作为输入来迭代同一个模型会导致误差的传播。这导致长期预测的预测性能较差。

2.直接的

直接方法为每个地平线建立一个模型。这里有一个片段:

scikit-learn 的 MultiOutputRegressor 类为每个目标变量复制了一个学*算法。在这种情况下，算法是线性回归。

这种方法避免了错误传播，因为不需要迭代任何模型。

但是，也有一些缺点。额外的模型需要更多的计算资源。此外，它假设每个视界都是独立的。通常，这种假设会导致糟糕的结果。

3.直接递归

顾名思义， DirectRecursive 试图融合 Direct 和 Recursive 的思想。为每个层位建立一个模型(直接跟随)。但是，在每一步，输入数据都随着前一个模型的预测而增加(遵循递归)。

这种方法在机器学*文献中被称为链接。scikit-learn 用 RegressorChain 类为它提供了一个实现。

4.数据作为演示器(DaD)

DaD 是一种用于多步预测的元学*算法。它试图减轻递归的错误传播问题。

其思想是使用训练集来纠正多步预测过程中出现的错误。它用这些修正迭代地丰富训练集。之后，使用丰富的训练数据执行递归方法。

作者提供了他们在 Github 中的实现。链接如下:

• https://github.com/arunvenk/DaD

除了预测，爸爸在强化学*问题上也表现不俗。查看参考文献[1]了解详情。

5.动态因子机器学*(DFML)

DFML 方法是专门为多元时间序列设计的。尽管如此，它的原则也可以应用于单变量。

其思想是使用降维方法(例如 PCA)对时间序列进行预处理。所以，不用预测 H 值，你只需要预测几个潜在变量。之后，您可以恢复转换以获得原始维度中的预测。

对于单变量时间序列，你可以这样做:

减少我们需要预测的变量数量的想法可以被视为预处理步骤。因此，我们实际上可以应用任何多步预测方法和 DFML。在上面的例子中，我们使用了直接，但也可以采用不同的方法。

6.多输出

到目前为止描述的方法是单输出方法— 它们一次模拟一个层位。

这可能是一个限制，因为它们忽略了不同地平线之间的依赖性。捕捉这种依赖性对于更好的多步预测可能很重要。

多输出模型解决了这个问题。这些符合一个单一的模型，该模型联合学*所有的预测范围。

通常，学*算法需要单个变量作为输出。这个变量被称为目标变量。然而，一些算法自然可以接受多个输出变量。

在这种情况下，我们应用 k-最*邻法。其他例子包括山脊、套索、神经网络或随机森林(以及诸如此类的东西)。

多输出方法有一个变体，将它的思想与直接相结合。该变体在预测范围的不同子集中应用了直接方法。该方法在参考文献[2]中有所描述。

实用建议

照片由贾维尔·阿莱格·巴罗斯在 Unsplash 上拍摄

那么，你应该使用哪种方法呢？

有一项系统研究表明多输出方法更好。文章还提到，对该系列进行非季节性调整非常重要。详见参考文献[2]。

如果有计算约束，应该避免直接或直接递归方法。除此之外，测试不同的方法，选择最适合您的数据的方法。

外卖

多步预测在许多领域都很重要。然而，预先预测多个步骤是一项困难的任务。

在这篇文章中，我描述了 6 种方法来帮助你解决这个问题。这些包括递归、直接、直接递归、DaD、DFML 和多输出。

感谢你的阅读，下一个故事再见！

参考

[1] Venkatraman、Arun、Martial Hebert 和 J. Andrew Bagnell。“改进学*时间序列模型的多步预测。”第二十九届 AAAI 人工智能会议。2015.

[2] Taieb，Souhaib Ben 等，“基于 NN5 预测竞赛的多步提前时间序列预测策略的回顾与比较”专家系统与应用39.8(2012):7067–7083。

用米托简化的 6 种最常见的熊猫方法

原文：https://towardsdatascience.com/6-most-common-pandas-methods-simplified-with-mito-2cd9fe729dab

与熊猫数据框架互动，就像它是一个 Excel 工作簿

由布鲁克·卡吉尔在 Unsplash 拍摄

Pandas 是数据科学家日常使用的数据科学库。它帮助我们清理数据，争论数据，甚至进行可视化。

我已经使用 Pandas 很长时间了，我意识到我在大多数数据科学项目中使用了一些方法。当涉及到使用数据帧时，它们是必不可少的，但是一遍又一遍地使用它们有时会变得有点乏味(并且您可能偶尔会忘记它们的语法)。

这就是为什么，在这篇文章中，我将向你展示如何使用一个叫做米托的库来简化 6 个最常见的熊猫方法。不使用 Python 代码，米托将允许我们与熊猫数据框架进行交互，就像它是一个 Excel 工作簿一样。

首要任务—安装米托

为了简化本文中列出的 6 种常见的熊猫方法，首先，我们需要安装米托，因此打开一个新的终端或命令提示符并运行以下命令(如果可能，将其安装在一个新的虚拟环境中):

python -m pip install mitoinstaller
python -m mitoinstaller install

请记住，您需要使用 Python 3.6 或更高版本以及 JupyterLab 才能让米托正常工作。

在这之后，重新启动 JupyterLab 内核，并刷新浏览器页面，开始使用米托。更多信息，你可以查看他们的 Github 和文档。

1.阅读 _csv

毫无疑问，read_csv是有史以来最常见的熊猫方法。读取文件以创建数据帧是每个数据科学项目的起点。

您可以导入一个 CSV 文件与几个点击使用米托。你只需要导入 mitosheet 并创建一个表。

**import** mitosheet
mitosheet.sheet()

运行上面的代码后，会出现一个紫色的工作表，您只需单击“Import”按钮，从您的工作目录导入任何数据集。

作者图片

在本例中，我导入了一个名为“sales-data.csv”的数据集，这是我自己为此例创建的，您可以在我的 Google Drive 中找到它。

请注意，在下面的单元格中，米托将生成 Python 代码，使这种导入成为可能。

2.值计数

另一种常见的熊猫方法是value_counts。这个方法允许我们获得一个列中唯一值的计数。使用米托，你只需点击几下鼠标就能获得与value_counts相同的功能。

让我们计算一下“产品”列中的独特元素。为此，您只需选择该列并单击过滤器按钮:

作者图片

此按钮打开的窗口有 3 个标签。每个选项卡将帮助我们替换本文中列出的一些常见的 Pandas 方法，所以请记住它！

选择“值”选项卡以获取米托唯一值的计数(和百分比)。

作者图片

3.astype

我不知道在 Pandas 中使用astype方法改变了多少次列的数据类型。

米托也可以通过几次点击来帮助我们改变数据类型！默认情况下，米托使用列名旁边的图标显示所有列的数据类型。

假设我们想将“date”列的数据类型设置为 date(当前设置为 string)。使用米托更改数据类型非常简单，只需单击过滤器图标，选择“过滤器/排序”选项卡，然后从“Dtype”下拉列表中选择任何数据类型。

作者图片

同样，细胞下方的有丝分裂表将显示代码自动生成的米托。

4.形容

这是我们在每次数据分析中使用的方法。describe方法帮助我们从数据中获得基本的统计数据，如平均值、中值和众数。

对米托来说，这样做很简单。我们只需点击任意列的过滤器图标，然后选择“Summary stats”选项卡。

作者图片

除了describe方法显示的典型信息之外，米托的汇总统计数据还有一个“count: NaN”行，显示一列中缺失数据(NaN)的数量。

5.菲尔娜

现实世界的数据集大多数时候都有缺失数据。这就是为什么，作为一名数据科学家，你必须学会如何处理丢失的数据。

一种解决方法是在熊猫身上使用fillna方法。也就是说，这种方法可以使用我们的 mitosheet 中的公式进行简化。

首先，我们需要通过单击“Add Col”按钮创建一个新列。然后，我们转到我们创建的列中的任何单元格，并编写以下公式:

=FILLNAN(series,’text-to-replace’)

其中series是缺失数据的列(在本例中，我从“收入”列中删除了一些值以生成缺失的数据)

作者图片

按回车键后，所有单元格将自动填充相同的公式。结果，来自“列 1”的所有 NaN 单元将在“列 2”中具有所需的值。

6.分组依据

这是我们每次想要聚集数据以便计数、求和等等时使用的方法。

我找不到用米托替换groupby方法的本地方法，但是有一个很好的变通方法，只需几次点击就可以实现。

我们只需要在米托使用“Pivot”选项。然后，我们必须选择要显示的行/列和数据。

假设我们想按产品对数据进行分组，然后对每组中的数量进行求和。为此，请按照以下步骤操作:

作者图片

与 1 万多人一起加入我的电子邮件列表，获取我在所有教程中使用的 Python for Data Science 备忘单(免费 PDF)

如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑报名成为一名媒体成员。每月 5 美元，让您可以无限制地访问数以千计的 Python 指南和数据科学文章。如果你使用我的链接注册，我会赚一小笔佣金，不需要你额外付费。

https://frank-andrade.medium.com/membership

6 熊猫数据框架任务任何学* Python 的人都应该知道

原文：https://towardsdatascience.com/6-pandas-dataframe-tasks-anyone-learning-python-should-know-1aadce307d26

确保你能够在 Pandas 中完成以下任务

在 Unsplash 上拍摄的 ThisisEngineering RAEng

当用 Python 编程时，尤其是在数据科学领域，可能没有人会避开库熊猫。在许多应用程序中，数据必须以表格的形式使用，在 Pandas DataFrames 的帮助下，这在 Python 中是最容易处理的。

确保你知道下面的命令，并且可以毫不费力地使用它们，这样你就可以节省时间，每天最大限度地利用熊猫。

例子

在本文中，我们使用以下数据作为示例来测试我们的命令:

对于我们的例子，我们简单地生成一个 DataFrame，其中有两列和日期作为索引。我们简单地使用 Numpy 随机填充数值。

1.添加新列

有几种方法可以将新列添加到现有的数据框架中。通过简单地用方括号定义新列，它将作为新列从右边添加到数据帧。

相反，如果我们希望在特定索引处插入新列，我们可以使用“df.insert()”来实现。

传递给该函数的第一个值是要插入的新列的索引，然后是列的名称，最后是要作为列插入的对象。最后一个参数指定是否允许该列重复。因此，如果具有相同名称和相同值的列已经存在，并且“allow_duplicates”设置为“False”，那么您将得到一条错误消息。

2.添加新行

如果以后要以新行的形式添加值，您可以简单地定义它并为它提供一个新的索引。传递的值列表必须与数据帧中的列数相匹配，这一点很重要。

3.删除列

与任何优秀的 Pandas 命令一样，删除列有几个选项。最简单的两种方法是使用函数“df.drop()”和列名，以及使用“axis=1”进行列选择。或者您可以使用标准 Python 函数“del”并定义相应的列:

4.删除空字段

当我们将空值传递给 DataFrame 或其他 Pandas 对象时，它们会自动被 Numpy NaNs(不是数字)替换。对于计算，如平均，这些字段不包括在内并被忽略。我们可以简单地用一个空的第三列来扩展现有的数据帧，该列只包含索引 01/01/2022 的值。然后，其余值自动设置为 NaN。

如果我们想要删除至少一列中有空值的所有行，我们可以使用下面的命令。

如果我们想删除缺少值的列，我们使用相同的命令并额外设置' axis = 1 '。否则，我们也可以用预定义的值填充空字段，例如用值 0。

在某些情况下，将缺失值显示为布尔值(真/假)也很有用。然而，在大多数情况下，DataFrame 对象太大，这不是一个有用的表示。

5.删除一行

如果我们不想只是从数据帧中删除空值，而是删除行，有两种方法可以做到。首先，我们可以通过使用我们想要删除的行的索引从数据帧中删除行。在我们的例子中，这是一个具体的日期，比如 01.01.2022:

通过这样做，我们删除了这个对象中的第一行。但是，在大多数情况下，我们还不知道要删除的具体行。然后，我们还可以将数据帧过滤为我们想要删除的行，然后输出相应行的索引。

在这种情况下，我们删除在“列 1”中检测到值大于 0.1 的所有行。这在“df”对象中总共留下了四行。

6.合并熊猫对象

Pandas 提供了几种连接系列或数据帧对象的方法。concat 命令通过第二个命名的对象来扩展第一个命名的对象(如果它们属于同一类型)。该命令当然可以用两个以上的数据结构来执行。

对于数据帧，代码行看起来是一样的。附加的“ignore_index”用于分配新的连续索引，而不是来自原始对象的索引。

Pandas 还允许使用“Merge”进行连接，大多数人可能对 SQL 很熟悉。

如果我们想执行一个内连接而不是左连接或右连接，我们再次使用 Concat 命令并加上' join = "inner " '。

这是你应该带走的东西

• 熊猫为处理缺失的价值观提供了许多可能性。您可以删除有问题的列/行，或者用值替换字段。
• 对于 Pandas，我们拥有与 SQL 相同的连接可能性。

如果你喜欢我的作品，请在这里订阅https://medium.com/subscribe/@niklas_lang或者查看我的网站* 数据大本营 ！还有，medium 允许你每月免费阅读 3 篇 。如果你希望有无限制的 访问我的文章和数以千计的精彩文章，请不要犹豫，点击我的推荐链接:【https://medium.com/@niklas_lang/membership】每月花$5***获得会员资格**

*https://medium.com/illumination/intuitive-guide-to-artificial-neural-networks-5a2925ea3fa2 </4-basic-commands-when-working-with-python-tuples-8edd3787003f> *

每位现代数据科学家必读的 6 篇论文

原文：https://towardsdatascience.com/6-papers-every-modern-data-scientist-must-read-1d0e708becd

该领域的每个人都熟悉的深度学*的一些最重要的现代基础的列表

照片由🇸🇮·扬科·菲利在 Unsplash 上拍摄

听我讨论这些关于 可讲解播客 【希伯来语】

数据科学家、机器学*专家、算法工程师、深度学*研究员——无论你的头衔可能是什么，如果使用机器学*的先进概念是你职业生涯的一部分，那么跟上最新的创新也是你日常任务的一部分。但是，为了站在所有最新技术的顶端，并真正理解它们是如何工作的，我们还必须熟悉它们所依赖的构件和基础。

深度学*领域正在快速发展，打破和创造每一个可能存在的指标的新纪录。随着它的发展，它创造了新的基本概念，允许前所未见的新架构和概念。

虽然我倾向于假设所有现代 ML 从业者都熟悉基本原理，如 CNN，，和甘，一些新的偶尔会被错过或遗漏。因此，这篇博文将讨论新的基础——我相信今天这个领域的每个人都应该熟悉的六篇论文。

你所需要的只是注意力

【 论文上 arXiv 】

这篇论文由谷歌的一个团队在 2017 年发布，向世界揭示了一种新的神经网络块，称为变压器— ，可以很容易地被标记为现代深度学*模型发展中最重要的里程碑之一。

转换器允许以并行方式处理序列，不像之前的技术水平那样严重依赖于 rnn 的类型。后者往往有几个主要缺点-RNN 图层必须依赖于先前输入的自身输出值。这导致训练时间缓慢，以及众所周知的消失/爆炸梯度问题，导致 RNNs 不足以找到序列中相距太远的单词之间的关系。

变形金刚能够通过使用两种新方法来解决这些问题——第一种，他们使用位置嵌入来标记序列中每个元素的位置，第二种是使用注意力，特别是自我注意力，以允许模型学*序列中不同元素之间的关系。

除了变形金刚本身之外，论文中充满了优化模型的小宝石。这里是我个人最喜欢的两个:

1. 作者严格提到他们使用层规范化而不是批规范化。总结最初的图层归一化论文，它基本上意味着归一化不是针对一批中的每个特征，而是针对整个样本(或图层)，每个样本本身。这篇论文证明了 LN 在很多情况下比 BN 更好，因为 Geoffrey Hinton 是三位作者之一，所以我相信他的话。
2. 注意事项中变压器的每个子层都由一个跳过层或残差块包裹(见下图)。这个模块背后的思想是，给定一个输入 x ，一个网络试图学*某个函数 H(x) ，它可以粗略地写成 H(x) = F(x) + x 。利用跳层机制，我们强制中间层学* F(x) ，按照原来的残差学*层，这样收敛更好。

由跳过层构成的残余块。摘自《你所需要的只是关注》

(2) BERT:用于语言理解的深度双向转换器的预训练

【 论文上 arXiv 】

由谷歌研究人员在 2019 年发布的 BERT 是一个不容忽视的 NLP 模型，并将 NLP 领域向前推进了一大步。BERT(代表来自变压器的双向编码器表示)是使用变压器开发的，并成为这些类型的模型可以容纳的功率的活生生的证明。我个人倾向于认为“注意力是你所需要的全部”和这篇论文多少有些互补；第一个描述了一个更一般的和“理论上的”方法，而后者将它用于一个特定的和定义明确的任务。

BERT 是革命性的，主要有两个原因:第一，它能够在 11 个自然语言处理任务中击败最先进的结果，第二，它被训练和设计用于微调，因此它可以很容易地匹配和定制任何特定的自然语言处理任务。

让 BERT 得到如此高效训练的一个关键因素是使用了单词片段嵌入，它允许模型将单词分解成片段，使要学*的词汇量变得更小。

(3)基于风格的生成对抗网络生成器体系结构

【 论文上 arXiv

这篇由 Nvidia Labs 于 2018 年底发表的论文向世界介绍了 StyleGAN 模型。自从 Ian Goodfellow 在 2014 年介绍了生成对抗网络 (GANs)以来，许多研究人员在提高 GAN 能力方面做了大量工作，但主要是通过关注鉴别器，因为更好的鉴别器最终会导致更好的生成器。然而，这种对生成器本身的关注不足导致“ …生成器继续作为黑盒运行，尽管最*做出了努力，但对图像合成过程各个方面的理解，例如随机特征的起源，仍然缺乏”。style gan 背后的想法是允许通过直接影响发生器本身，使用另一个输入(第二个图像)来调整输出图像的一些功能。

将一个输入的风格与生成的第二个输入混合是通过两个主要步骤完成的——首先，将风格输入插入到密集网络中，输出另一个学*向量。其次，应用一种新颖的“自适应实例归一化”(AdaIN)——原始图像输入被归一化，然后新的样式嵌入被混合:

但是我个人认为这篇论文最有趣的部分，是这个模型是如何被训练和评估的。想一想——没有网络可以学*的数据集。因此，研究人员所做的不过是非凡的数据科学——他们理解并利用了他们所拥有的数据。

当谈到损耗时，作者明确提到他们使用了标准 GAN 损耗，这是有意义的，因为 StyleGAN 产生的图像应该看起来很真实，就像任何常规 GAN 产生的图像一样。但是当涉及到评估时——也就是说，输出的风格确实被改变了——他们注意到了他们所谓的“特征纠缠”。他们声称，由于网络被训练的照片是真实的，一些面部特征是相互关联的——例如，长发通常会与女性联系在一起，胡须与男性联系在一起，蓝眼睛与白种人联系在一起，等等。因此，他们为大约 40 种这样的属性训练了一个分类器，并表明 StyleGAN 生成的照片比常规 GAN 具有更高的属性可分性。

(4)从自然语言监督中学*可转移的视觉模型

【 论文上 arXiv

OpenAI 于 2021 年初发布的这篇论文可能是零镜头分类算法中最伟大的革命之一，它提出了一种被称为对比语言图像预训练的新模型，简称 CLIP。

CLIP 在 4 亿对图像及其相应字幕的大规模数据集上接受了训练，并学会了将图像和自由文本嵌入到同一个嵌入空间，因此图像和自由文本描述将共享同一个潜在向量。CLIP 可以处理任何图像和任何英文文本，并且在零镜头分类任务中表现出了出色的能力。

此外，下面的一些工作已经表明，剪辑空间中的潜在向量遵循我们从 NLP 中熟悉的算法。也就是说，我们都知道，在 Word2Vec 潜在空间中，我们得到男人+皇后-女人=国王，那么在剪辑空间中，我们可以得到相同的等式，但是在使用单词男人和女人，以及国王和皇后的图像时。

(5)利用深度神经网络和树搜索来掌握围棋

[deep mind 网站上的论文 ]

DeepMind 在 2016 年初发布的这篇论文在强化学*方面取得了突破，它提出了alpha Go——一个以 5 比 0 击败欧洲围棋冠军的模型。这是有史以来第一个人工智能在全尺寸围棋比赛中击败人类职业选手，这一壮举此前被认为是至少十年后的事情。

AlphaGo 使用蒙特卡罗树搜索 (MCTS)来计算它的下一步棋——这意味着，它并不真正计算树中的每个节点，而是对可能的结果进行许多模拟。

AlphaGo 的作者表示，他们训练了一个策略梯度模型，该模型在监督学*模型的基础上进行优化，而监督学*模型又从记录的人类专家游戏中学*。但是这个庞大的网络太慢了，不能在真实游戏中模拟 MCTS，所以他们必须找到一个替代品。相反，他们训练了两个网络——一个轻量级策略梯度，它要弱得多，但也快 1000 倍以上，另一个价值网络，它预测游戏中每个州的价值(即获胜的机会)。这种价值网络通过重度政策梯度的自我游戏学*，从而直接从中学*。在 MCTS 模拟的每个时间步，轻量级网络用于从当前状态生成游戏性，直到游戏结束，并且它接收的奖励与当前状态的价值网络评估相结合，以便提供该状态的 Q 值评估。一旦所有模拟终止，AlphaGo 就会选择它在这些探索模拟中访问最多的州。

AlphaGo 的 MCTS 阶段，摘自《用深度神经网络和树搜索掌握围棋》

2017 年，在这篇论文发表一年后，DeepMind 发表了第二篇与围棋相关的论文，“在没有人类知识的情况下掌握围棋的游戏”，其中提出了 AlphaGo Zero ，它只使用自对弈进行训练，包含单个网络而不是两个网络——并以 100 比 0 击败 AlphaGo。

(6)用于 YouTube 推荐的深度神经网络

[ 谷歌研究论文 ]

这篇论文于 2016 年发布，揭示了 YouTube 中用于推荐的深度学*模型的架构。在许多方面，本文中描述的高级体系结构和方法至今仍在业界广泛使用。

本文是您可能想到的每一个使用深度学*的推荐问题的经典之作，涵盖了广泛的主题，如高级架构、处理大规模(使用候选生成和排名模型)、分类为极端多类分类、优化训练和测试数据以实现准确预测、功能的影响、增加网络的影响、使用和选择嵌入等等。底线是，如果你对推荐系统感兴趣，这是必须的。

这是我所有现代数据科学家必读的前 6 篇论文——如果你认为我错过了某篇论文，请告诉我！

6 种强大的学*技巧，帮助您掌握数据科学中最棘手的主题

原文：https://towardsdatascience.com/6-powerful-study-techniques-to-help-you-master-the-toughest-topics-in-data-science-a04d9c7a39b6

从费曼技术到莱特纳系统，这个指南有一个学*技术，帮助每个人学*数据科学。

埃里克·马苏尔在 Unsplash 上的照片

即使到了 2000 年的第二个十年，数据科学仍然是最受欢迎的领域之一，但也是最难进入和掌握的领域。

你听到的关于大学辍学者在三个月内学会编码，然后在 FAANG 公司获得 10 万美元的入门级工资的说法并不适用于数据科学领域的工作。

相反，任何渴望成为数据科学家的人似乎都是为这份工作而生的，拥有编码、分析和数学技能，似乎可以凭空产生美丽的可视化效果，完美地描述一个组织的业务问题和成功，甚至连眼睛都不用眨一下。

然而，这对于我们这些可能后来才接触数据科学的普通人或者那些正在寻找职业改变的人来说意味着什么呢？

幸运的是，许多研究技术可以被用于任何人的优势，帮助他们掌握数据科学中最困难的主题，这将有助于在该领域获得第一份工作。从费曼技术到 SQR3 方法，这里有一个学*技巧，适合每个想要扩展自己的知识并掌握进入这个迷人领域所需的一切的人。

1.间隔重复

间隔重复是“以逐渐增加的间隔复*信息”的过程。

举个例子，有人告诉你如何计算统计样本的平均值。了解这些信息很重要，但是如果你不经常使用，你可能会忘记如何计算平均值。但是，如果您定期回顾计算平均值的概念，您将更有可能记住这些信息，并能够在将来更有效地使用它们。

本质上，大脑包含突触，突触是神经元之间的连接。简而言之，突触用于传导神经元之间的神经脉冲，帮助大脑传输信息。很少使用的突触会变得更弱，甚至可能被大脑“修剪”。这使得更经常使用的突触变得更强(Kalat，J. W. (2022)。心理学导论。马萨诸塞州波士顿:森盖奇学*中心。

因此，间隔重复通过加强你大脑中检索和使用特定信息的突触而起作用。

有间隔的重复可以通过定期复*材料和从大脑中提取信息来完成。创建一个时间表是确保你定期复*资料的有效方法。或者，数字抽认卡工具 Anki 是一个非常棒的一体化间隔重复工具，它可以帮助你制定时间表，并确保你每天都有适量的练*。

这种技术的好处是:

增加词汇、方法、方程式和概念的记忆。

如何用它来研究数据科学:

间隔重复是练*使用数据科学中常用算法的好方法。虽然并非所有的数据科学项目都使用相同的算法，但在开始学*使用所有算法时，这可能是一个好主意。此外，随着时间的推移练*它们也是有益的，这样可以确保您不会丧失在下一个项目中快速有效地实现它们的能力。此外，算法在不同场景中的间隔重复将帮助您理解它们在不同情况下的应用，以及根据您选择实现的算法您可能获得的结果范围。

2.主动回忆

主动回忆是一种涉及“从你的大脑中检索信息”的学*技术。

大多数人通常认为学*是一种将信息输入大脑的行为(有时被称为被动学*方法)，而主动回忆通过迫使大脑主动记忆和检索信息来工作。

根据 2013 年进行的一项关于有效学*技巧的多机构调查研究，主动回忆被列为一项非常成功的学*技巧，已被证明可以提高学生在教育竞赛中的表现。

主动回忆可以通过创建练*题、练*测试或抽认卡来实现，你必须通过回忆你所知道的来回答这些问题。如果一个问题回答错误，回到你的笔记，了解你的答案遗漏了什么。然后，再次回顾这些问题，尝试提高之前的分数。

这种技术的好处是:

巩固你对话题的记忆，以及提高快速自信地回忆信息回答问题的能力。

如何用它来研究数据科学:

当您第一次开始学*数据科学的基础知识时，例如使用 Python 或 R 编程的基础知识，学*数据分析中涉及的基础数学，以及学*哪种类型的可视化最适合哪种场景，Active recall 是一个非常好的学*工具。通过在浏览每个主题时为自己制定一个问题列表，您可以在以后测试自己，看看您是否真正理解如何在每种情况下使用编程、数学或数据可视化。不仅如此，通过开发自己的主动回忆测试问题，你将学会以创造性的方式使用你所知道的信息，你将开始预测你将如何解决问题。

3.费曼技术

注:我有一篇详尽的文章详细介绍了如何使用费曼技术，可以在这里全文阅读: 如何使用费曼技术成为数据科学中最复杂概念的专家 。

费曼技术是由获得诺贝尔奖的物理学家理查德·费曼开发的，他是量子计算和纳米技术领域的先驱，由于他在康乃尔和加州理工学院发表的精彩演讲，他被称为【伟大的解释者】。

费曼技巧是一个理解任何主题的四步过程，通过主动学*发展对主题的真正理解。

费曼技巧可以分为四个步骤，对于一个给定的主题按顺序完成:

1. 选择一个概念来学*: 用自己的文字和脑力写下你已经知道的关于一个话题的一切。记下你必须用一个长而复杂的词来解释某事的任何地方，并确定你是否理解这个词的意思。如果你能用简单的术语解释这个词的意思，那太好了！如果没有，研究这个词及其用法，更深入地了解它的意思，然后尝试找出一种用简单语言描述这个词的方法。
2. 教给自己或别人:把一个概念教给别人确实决定了你自己是否理解这个概念。当你不能连贯地把某个主题教给别人时，很难欺骗自己相信自己是这个主题的专家。关键是以一种 10 岁孩子也能理解的方式来教授这个概念。
3. 找出你的知识缺口并返回到原始材料:在尝试向其他人教授该概念后，你将能够根据你解释该主题的难易程度以及你是否能够回答任何后续问题来找出你知识中的缺口。一旦你发现并填补了任何空白，是时候回去再次向别人传授这个概念了。该步骤是步骤 2 的迭代循环的一部分。这个循环应该根据需要重复多次，直到你完全理解这个主题。
4. 简化你的解释:这个过程的最后一步是修改你的解释，这样你就可以排除行话，使用简单的类比，便于日后回忆和解释。这一步迫使你简化概念，直到任何人都能完全理解为止。

这种技术的好处:

理解理论、技术和数学概念之间的联系。

如何用它来研究数据科学:

费曼技术是深入学*数据科学中最难理解的概念的一种很好的方式，因为它迫使你理解它们，以至于你可以向任何人解释它们。例如，无监督学*或描述性模型是机器学*的概念，因为没有确切的目标，所以理解起来可能很复杂。然而，学*如何解释无监督学*是如何工作的，以及理解在什么场景下描述性模型可以有益于基本水平，可以帮助你以简单的方式更好地理解它们。然后，如果到了你实现一个描述性模型的时候，你会以最简单的方式理解它应该如何工作以及你应该产生的结果。

4.SQR3 方法

SQR3 法是一种“阅读理解法，因其五个步骤而得名:调查、提问、阅读、背诵、复*”。

SQR3 方法的目的是从你读到的东西中收集并记住尽可能多的信息。在学*数据科学中更难的概念时，阅读可能是你经常要做的事情。因此，你最好确保你得到了你想要的。

SQR3 方法的五个步骤将按顺序完成:

1. 调查: 收集信息，为你将要阅读的内容做准备，包括标题、介绍或摘要、标题、表格或图表、章节目标、章节结尾问题以及任何其他关键特征。这些信息将为你将要阅读的内容提供一个基础，并让你知道你应该关注什么，以及阅读这篇文章的目标应该是什么。
2. 问题: 利用调查中收集的关键信息制定问题。这允许你在阅读的过程中挑选出关键的细节来回答这些问题。
3. 阅读: 回答你通过阅读养成的问题。现在也是时候看看你的答案在哪里可以有更多的信息，或者你应该在哪里开发额外的问题。
4. 背诵: 在你读完一节或一章后，试着根据记忆回答你所写的问题。这里的关键是不要继续阅读下一部分，直到你能凭记忆轻松地背诵出问题的答案。
5. 复*: 完成整篇阅读后，再把自己写过的题过一遍，看看自己是否还能凭记忆作答。如果没有，回顾你的问题和答案，以确保你巩固你的理解。

这种技术的好处是:

提升你的阅读理解能力，以确保你理解并记住你所读的内容。

如何用它来研究数据科学:

TowardsDataScience 是关于数据科学文章和操作方法的最佳在线资源之一。但是，你能肯定地说，你看了他们发表的文章，就把学到的东西都保留下来了吗？再者，如果一篇文章特别复杂，深入到数学或人工智能的错综复杂中，你能自信地用简单的术语解释你刚刚读到的内容吗？SQR3 方法的好处是，它将帮助你提高对你所阅读的每一篇 TowardsDataScience 文章的理解。不仅如此，你还能把你学到的东西应用到你自己的项目中，因为你清楚地理解了所展示的内容。当用于阅读和理解科学期刊文章时，这种技术也是有益的，可以帮助你专注于重要的信息并填补你的知识空白。

5.莱特纳系统

莱特纳系统是由德国科学记者塞巴斯蒂安·莱特纳在 1972 年开发的。

莱特纳系统是一种学*方法，即“使用抽认卡、卡盒和间隔重复计划系统”，该系统已被证明可以提高学*和记忆能力。这种方法是最早使用间隔重复的研究系统之一，并且随着越来越多的研究证明其有效性，这种方法越来越受欢迎。这种方法也包括主动回忆，因此可以认为是两种研究方法的混合(在上面单独讨论)。

系统使用三个抽认卡盒，方便间隔重复:

• 框 1: 包含新添加的新抽认卡和框 2 中回答错误的抽认卡。盒子 1 中的抽认卡每天都被检查。
• 框 2: 包含框 1 中回答正确的抽认卡和框 3 中回答错误的抽认卡。方框 2 中的抽认卡每隔一天检查一次。
• 框 3: 包含框 2 中回答正确的抽认卡和框 3 中回答正确的抽认卡(无变化)。方框 3 中的抽认卡每周审查一次。

正如你所看到的，这种方法与之前描述的间隔重复相同，也使用主动回忆的方面来确定一个概念是否需要更频繁或更不频繁地重复。

虽然手工写抽认卡很费时间，但是数字抽认卡工具，如安奇 T21，已经使这个过程现代化并大大加快了速度。

这种技术的好处是:

定期自测对题目的理解。

如何用它来研究数据科学:

莱特纳系统最适合在学*数据科学概念时使用。例如，您可以创建一套包含不同统计分析方法的抽认卡。这副牌将包括来自描述性和分析性统计的概念，一边是概念的名称，另一边是概念的描述和例子。通过使用间隔重复和主动回忆来浏览这些卡片，你可以放心，你将理解这个概念，并且能够在前进中保留这些知识。

6.思维导图

思维导图是与一个主题相关的想法和概念的视觉表现。

思维导图是很好的工具，可以将以前的知识与新的主题联系起来，也可以将新的信息和概念与你正在学*的主题联系起来。这些有意义的视觉表现可以帮助你直观地把握信息之间的联系。此外，创建思维导图是一种更吸引人的学*形式，可以帮助你创造性地、批判性地利用信息。

2002 年由 Barts 和伦敦医学和牙科学院的研究人员进行的一项研究发现思维导图可以提高 10-15%的记忆力。

要创建思维导图，在页面中央写下主题的名称。围绕中心主题写下关键词和概念，创建信息分支。然后，在关键字和概念上画出更多的分支，以提供更多的细节或链接更多的支持信息。

这种技术的好处是:

将概念相互联系起来。

如何用它来研究数据科学:

当关联数据科学中的不同概念时，思维导图是很好的工具。数据科学很复杂，分为编程、数学、数据分析和数据可视化。思维导图可以帮助你将不同的领域联系在一起，并理解它们之间的相互作用。例如，您可以发现不同的数据可视化如何被所使用的统计方法改变，或者机器学*和人工智能如何影响数据分析。数据科学中的一切都是相互关联的，思维导图提供了创建内部关系的图形表示的能力。

最后的想法。

数据科学是一门很难掌握的复杂学科，但不一定要非常刻苦。

通过开发智能学*方法，帮助您有效地处理材料，有可能学*数据科学中最难的概念。诀窍是使用正确的方法组合，产生对一个概念最全面的理解。

关键要点:

• 大脑只能保留这么多信息，所以定期重温你计划在未来需要的信息以确保其保留是至关重要的。
• 迫使你回忆信息并以新的创造性方式使用信息的主动学*方法有助于提高记忆力和概念性理解。
• 发展强大的阅读理解技能将确保你充分利用你的时间阅读，并记住你所吸收的东西。

关于测井数据和岩石物理学，你应该了解的 6 个 Python 库

原文：https://towardsdatascience.com/6-python-libraries-you-should-know-about-for-well-log-data-petrophysics-3dfde47856b8

发现 6 个很棒的 python 库，您现在就可以开始使用它们处理测井数据

照片由希特什·乔杜里在 Unsplash 拍摄

Python的一个伟大之处在于大量的开源库，这些库的开发是为了改善我们处理数据和理解数据的方式。在岩石物理学和地球科学领域，有许多有用的库，可以使处理测井数据变得更容易。

在本文中，我将向您介绍 6 个我最喜欢和最常用的 Python 库，它们可以帮助您完成一些任务，例如为特定文件格式加载数据，以实现数据的可视化。

如果你喜欢看视频形式的内容，你可以在下面找到它。

lasio —加载、编辑和创建。LAS 文件

测井 ASCII 标准(LAS)文件是存储和传输测井数据的常用文件格式。为了读取这些文件，Kent Inverarity 开发了一个名为 lasio 的专用 python 库来读写这些类型的文件。当数据被加载到 lasio 中时，它可以很容易地转换成其他文件格式，包括转换成一个 pandas dataframe 。

如何使用 lasio:

要安装 lasio ，您只需打开命令提示符或终端并键入pip install lasio。一旦安装了这个库，你就可以通过输入import lasio轻松导入到你的 Jupyter 笔记本中。

以下示例说明了如何加载 las 文件并查看井口信息。

首先我们需要导入 lasio，然后在函数的括号内调用lasio.read(),我们传递 las 文件的路径。

import lasio
las = lasio.read("15-9-19_SR_COMP.LAS")

加载文件后，我们可以创建一个简单的 for 循环，该循环将遍历 las 文件孔标题部分中的每个项目/条目，并打印出描述、助记符及其值

for item in las.well:
    print(f"{item.descr} ({item.mnemonic}): {item.value}")

这将返回:

Top Depth (STRT): 102.1568
Bottom Depth (STOP): 4636.514
Depth Increment (STEP): 0.1524
Null Value (NULL): -999.25
Field Name (FLD): Q15
NAME (WELL): 15/9-19
WELLBORE (WBN): 15/9-19 SR
COUNTRY (NATI): NOR
COUNTRY (CTRY): NOR
OPERATOR (COMP): STATOIL
PERM DATUM (PDAT): MSL
RIG NAME (COUN): NORTH SEA
STATE (STAT): NORWAY
PB WELL ID (PBWE): 15/9-19
PB WELLBORE ID (APIN): 15/9-19 SR
PB WELL NAME SET (PBWS): ALL

如果我们想将测井数据从一个 lasio 对象传输到一个 pandas 数据帧，我们可以简单地执行以下操作:

well = las.df()
well.head()

当我们查看数据帧的标题内容时，我们可以看到我们获得了前五行数据。

从 las.df()返回的 dataframe 显示了测井数据的前五行。图片由作者提供。

了解有关 lasio 的更多信息:

要更深入地了解 lasio，您可以在这里找到我关于使用测井 las 文件的文章或者查看我们的 YouTube 视频。

dlisio —与合作。DLIS 档案

另一种用于存储和传输测井数据的通用文件格式是 DLIS，代表数字测井交换标准。这些是比 LAS 文件和 CSV 文件复杂得多的二进制文件。它们能够存储多维阵列数据，如声波波形、钻孔图像和核磁共振 T2 分布。

Equinor 开发了 dlsio python 库,以便轻松处理 DLIS 和旧的 LIS 文件

如何使用 dlisio:

要安装 dlsio ，您只需打开命令提示符或终端并键入pip install dlisio。一旦安装了这个库，你就可以通过输入import dlisio轻松导入到你的 Jupyter 笔记本中。

以下示例说明了如何加载 dlis 文件并查看孔标题信息。

加载 dlis 文件时，值得记住的是，它们可以包含多组测井数据，这些数据存储在逻辑文件中。这可能包括多口井、来自同一口井的多个数据集以及不同级别的已处理数据。为了说明这一点，我们需要使用下面的语法，它允许第一个文件输出到f，任何后续的逻辑文件放入tail。

import dlisio
f, *tail = dlis.load('Data/NLOG_LIS_LAS_7857_FMS_DSI_MAIN_LOG.DLIS')

执行时，此代码返回:

LogicalFile(00001_AC_WORK)
[]

要查看文件的高级内容，我们可以使用.describe()方法。这将返回有关逻辑文件中的帧数、通道数和对象数的信息。当我们将其应用于f时，我们可以看到我们有一个包含 4 帧和 484 个通道(测井曲线)的文件，此外还有许多已知和未知的对象。

f.describe()

它返回:

------------
Logical File
------------
Description : LogicalFile(FMS_DSI_138PUP)
Frames      : 4
Channels    : 484Known objects
--
FILE-HEADER             : 1
ORIGIN                  : 1
AXIS                    : 50
EQUIPMENT               : 27
TOOL                    : 5
PARAMETER               : 480
CALIBRATION-MEASUREMENT : 22
CALIBRATION-COEFFICIENT : 12
CALIBRATION             : 341
PROCESS                 : 3
CHANNEL                 : 484
FRAME                   : 4Unknown objects
--
440-CHANNEL                  : 538
440-PRESENTATION-DESCRIPTION : 1
440-OP-CHANNEL               : 573

如上所示，我们的数据中有 4 个独立的帧。这些帧也可以表示不同的数据类型、不同的测井通道和不同阶段的处理数据。每个框架都有自己的属性，我们可以使用以下代码将这些属性打印成易于阅读的格式:

for frame in f.frames:

    # Search through the channels for the index and obtain the units
    for channel in frame.channels:
        if channel.name == frame.index:
            depth_units = channel.units

    print(f'Frame Name: \t\t {frame.name}')
    print(f'Index Type: \t\t {frame.index_type}')
    print(f'Depth Interval: \t {frame.index_min} - {frame.index_max} {depth_units}')
    print(f'Depth Spacing: \t\t {frame.spacing} {depth_units}')
    print(f'Direction: \t\t {frame.direction}')
    print(f'Num of Channels: \t {len(frame.channels)}')
    print(f'Channel Names: \t\t {str(frame.channels)}')
    print('\n\n')

这将返回以下摘要。这表明该文件中存在两个帧。第一帧包含钻头尺寸(BIT)、井径(CAL)、伽马射线(GR)和张力(TEN)的基本测井曲线。第二帧包含后处理的声波波形数据。

Frame Name: 		 60B
Index Type: 		 BOREHOLE-DEPTH
Depth Interval: 	 0 - 0 0.1 in
Depth Spacing: 		 -60 0.1 in
Direction: 		 DECREASING
Num of Channels: 	 77
Channel Names: 		 [Channel(TDEP), Channel(BS), Channel(CS), Channel(TENS), Channel(ETIM), Channel(DEVI), Channel(P1AZ_MEST), Channel(ANOR), Channel(FINC), Channel(HAZI), Channel(P1AZ), Channel(RB), Channel(SDEV), Channel(GAT), Channel(GMT), Channel(ECGR), Channel(ITT), Channel(SPHI), Channel(DCI2), Channel(DCI4), Channel(SOBS), Channel(DTCO), Channel(DTSM), Channel(PR), Channel(VPVS), Channel(CHR2), Channel(DT2R), Channel(DTRP), Channel(CHRP), Channel(DTRS), Channel(CHRS), Channel(DTTP), Channel(CHTP), Channel(DTTS), Channel(CHTS), Channel(DT2), Channel(DT4P), Channel(DT4S), Channel(SPCF), Channel(DPTR), Channel(DPAZ), Channel(QUAF), Channel(DDIP), Channel(DDA), Channel(FCD), Channel(HDAR), Channel(RGR), Channel(TIME), Channel(CVEL), Channel(MSW1), Channel(MSW2), Channel(FNOR), Channel(SAS2), Channel(SAS4), Channel(PWF2), Channel(PWN2), Channel(PWF4), Channel(PWN4), Channel(SVEL), Channel(SSVE), Channel(SPR2), Channel(SPR4), Channel(SPT4), Channel(DF), Channel(CDF), Channel(CLOS), Channel(ED), Channel(ND), Channel(TVDE), Channel(VSEC), Channel(CWEL), Channel(AREA), Channel(AFCD), Channel(ABS), Channel(IHV), Channel(ICV), Channel(GR)]Frame Name: 		 10B
Index Type: 		 BOREHOLE-DEPTH
Depth Interval: 	 0 - 0 0.1 in
Depth Spacing: 		 -10 0.1 in
Direction: 		 DECREASING
Num of Channels: 	 4
Channel Names: 		 [Channel(TDEP), Channel(IDWD), Channel(TIME), Channel(SCD)]Frame Name: 		 1B
Index Type: 		 BOREHOLE-DEPTH
Depth Interval: 	 0 - 0 0.1 in
Depth Spacing: 		 -1 0.1 in
Direction: 		 DECREASING
Num of Channels: 	 84
Channel Names: 		 [Channel(TDEP), Channel(TIME), Channel(EV), Channel(BA28), Channel(BA17), Channel(BB17), Channel(BC13), Channel(BD13), Channel(BB28), Channel(BA13), Channel(BB13), Channel(BC17), Channel(BD17), Channel(BA22), Channel(BA23), Channel(BA24), Channel(BC28), Channel(BA25), Channel(BA26), Channel(BA27), Channel(BA11), Channel(BA12), Channel(BA14), Channel(BA15), Channel(BA16), Channel(BA18), Channel(BA21), Channel(BC11), Channel(BC12), Channel(BC14), Channel(BC15), Channel(BC16), Channel(BC18), Channel(BC21), Channel(BC22), Channel(BC23), Channel(BC24), Channel(BC25), Channel(BC26), Channel(BC27), Channel(BB22), Channel(BB23), Channel(BB24), Channel(BD28), Channel(BB25), Channel(BB26), Channel(BB27), Channel(BB11), Channel(BB12), Channel(BB14), Channel(BB15), Channel(BB16), Channel(BB18), Channel(BB21), Channel(BD11), Channel(BD12), Channel(BD14), Channel(BD15), Channel(BD16), Channel(BD18), Channel(BD21), Channel(BD22), Channel(BD23), Channel(BD24), Channel(BD25), Channel(BD26), Channel(BD27), Channel(SB1), Channel(DB1), Channel(DB2), Channel(DB3A), Channel(DB4A), Channel(SB2), Channel(DB1A), Channel(DB2A), Channel(DB3), Channel(DB4), Channel(FCAX), Channel(FCAY), Channel(FCAZ), Channel(FTIM), Channel(AZSNG), Channel(AZS1G), Channel(AZS2G)]Frame Name: 		 15B
Index Type: 		 BOREHOLE-DEPTH
Depth Interval: 	 0 - 0 0.1 in
Depth Spacing: 		 -15 0.1 in
Direction: 		 DECREASING
Num of Channels: 	 12
Channel Names: 		 [Channel(TDEP), Channel(TIME), Channel(C1), Channel(C2), Channel(U-MBAV), Channel(AX), Channel(AY), Channel(AZ), Channel(EI), Channel(FX), Channel(FY), Channel(FZ)]

了解有关 dlisio 的更多信息:

要更深入地了解如何使用 DLIS 文件和 dlisio 库，请查看我的文章使用 Python 从 DLIS 加载测井数据

或者您可以在以下网址观看视频:

welly —用于测井数据的专用 Python 库

welly 库由 Agile Scientific 开发，用于帮助加载、处理和分析单井或多口井的测井数据。

该库允许探索 las 文件头中的元数据，还包含显示典型测井记录的绘图功能。此外，welly 库包含用于识别和处理数据质量问题的工具。

Welly 库可以在位于 https://github.com/agile-geoscience/welly的敏捷地球科学 GitHub 中找到

如何使用 welly:

要安装 welly，你只需打开一个命令提示符或终端，键入pip install welly。一旦安装了库，我们就可以开始导入 welly 库的特定模块。对于本例，我们将使用井和曲线模块。这些模块用于处理测井数据和单独的曲线。

from welly import Well
from welly import Curve

我们的 LAS 文件可以使用Well.from_las()方法加载。这将创建一个新的井对象。

well = Well.from_las('Data/15_19_F1B_WLC_PETRO_COMPUTED_INPUT_1.LAS')

现在我们的数据已经加载完毕，我们可以开始研究所选井的内容和元数据。如果我们调用我们的well对象，我们将看到一个包含井名、位置、坐标和曲线助记符列表的汇总表。

well

由 welly python 库生成的测井标题信息。图片由作者提供。

如果我们想更仔细地查看其中一条测井曲线，我们可以这样传递曲线的名称:

well.data['GR']

从 welly python 库生成的单个测井曲线标题。图片由作者提供。

了解更多关于 welly 的信息:

要更深入地了解这个库，请查看我的文章:使用 Welly Python 库探索测井数据

或者在以下播放列表中查看我在 welly 上的 YouTube 系列:

缺失编号-识别缺失的数据

测井测量中的缺失数据是许多岩石物理学家和地球科学家在处理测井数据时面临的一个非常普遍的问题。数据丢失可能有多种原因，包括工具和数据过时、工具传感器问题、工具故障等。

缺少 python 库非常有用，但是使用起来非常简单。

如何使用 missingno:

要安装 missingno ，您只需打开命令提示符或终端并键入pip install missingno。

一旦安装了库，我们就可以使用下面的约定将 missingno 和 pandas 一起导入。我们还可以加载一个 CSV 文件来展示 missingno 库的强大功能。

import pandas as pd
import missingno as msnodf = pd.read_csv('xeek_train_subset.csv')

在 missingno 库内，有四种图形用于显示数据完整性:柱状图、矩阵图、热图和树状图。每种方法在识别缺失数据方面都有自己的优势。

在这篇文章中，我们将看看柱状图。

条形图提供了一个简单的绘图，其中每个条形代表数据帧中的一列。条形的高度表示该列的完整程度，即有多少非空值。它可以通过调用以下命令来生成:

msno.bar(df)

在图的左侧，y 轴刻度范围从 0.0 到 1.0，其中 1.0 表示 100%的数据完整性。如果柱线小于此值，则表明该列中缺少值。

在图的右侧，标度以指数值度量。右上角代表数据帧内的最大行数。

在图的顶部，有一系列数字表示该列中非空值的总数。

在此示例中，我们可以看到许多列(DTS、DCAL 和 RSHA)有大量缺失值。其他列(如 WELL、DEPTH_MD 和 GR)是完整的，并且具有最大数量的值。

了解关于 missingno 的更多信息否:

关于 missingno 库的更多信息，请查看:在机器学*之前使用 missingno Python 库来识别和可视化丢失的数据

或者你可以在我的 YouTube 频道上观看以下视频:

熊猫-使用表格数据

pandas 库是最著名的处理数据的 Python 库之一。

如何使用熊猫:

要安装 pandas，你只需打开命令提示符或终端，输入pip install pandas。

一旦安装了库，我们就可以使用以下惯例导入 pandas:

import pandas as pd

如果我们有一个包含数据的 CSV 文件，如常规岩心分析(RCA)或偏差调查数据，我们只需通过以下操作加载它:

df = pd.read_csv('data/spwla_volve_data.csv')

我们可以调用.info()来提供数据帧中所有列的列表，以及它们的数据类型(例如，浮点、整数、字符串等)。)，以及每列中包含的非空值的数量。

df.info()
RangeIndex: 27845 entries, 0 to 27844
Data columns (total 16 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   wellName  27845 non-null  object 
 1   MD        27845 non-null  float64
 2   BS        27845 non-null  float64
 3   CALI      27845 non-null  float64
 4   DT        5493 non-null   float64
 5   DTS       5420 non-null   float64
 6   GR        27845 non-null  float64
 7   NPHI      27845 non-null  float64
 8   RACEHM    27845 non-null  float64
 9   RACELM    27845 non-null  float64
 10  RHOB      27845 non-null  float64
 11  RPCEHM    27845 non-null  float64
 12  RPCELM    27600 non-null  float64
 13  PHIF      27736 non-null  float64
 14  SW        27736 non-null  float64
 15  VSH       27844 non-null  float64
dtypes: float64(15), object(1)
memory usage: 3.4+ MB

下一组有用的方法是head()和.tail()函数。这些函数返回数据帧的前/后五行

df.head()

测井测量数据帧的前五行。单击以放大。图片由作者提供。

df.tail()

测井测量数据帧的最后五行。单击以放大。图片由作者提供。

了解更多关于熊猫的信息:

要更深入地了解一些与 pandas 相关的主题，您可以查看我的文章:使用 Pandas、Matplotlib 和 Seaborn 探索测井数据

如果你有兴趣看看使用熊猫图书馆可以做些什么，我制作了这个关于如何使用熊猫填充缺失数据的短片:

matplotlib —数据可视化

matplotlib 是我最喜欢的可视化测井数据的 Python 库之一。一旦了解了它的基本工作原理，它在处理测井数据时会变得非常强大。Matplotlib 是最流行的用于数据可视化和探索的 Python 库之一，被许多数据科学家、Python 编码员和机器学*爱好者使用。

该库可以用几行代码生成测井曲线、箱线图、散点图(交会图)。

如何使用 matplotlib:

要安装 matplotlib，您只需打开命令提示符或终端，然后键入pip install matplotlib。

任何 python 项目或笔记本的第一步都是导入所需的库。在这种情况下，我们将使用lasio加载我们的 las 文件，pandas存储我们的测井数据，以及matplotlib显示我们的数据。

import pandas as pd
import lasio
import matplotlib.pyplot as plt

为了读取数据，我们将使用 lasio 库，这是我们在之前的笔记本和视频中探索过的。

las = lasio.read("Data/15-9-19_SR_COMP.LAS")

通过调用df.plot()并传递我们的两个列，我们可以很容易地创建一个简单的情节

df.plot('GR', 'DEPTH')

伽马射线与深度的简单线图。图片由作者提供。

通过更多的代码，我们可以将上面的简单图转换成更全面的对数图，如下图所示

最终测井曲线显示了轨迹 1 中的伽马射线、轨迹 2 中的电阻率(对数标度)和轨迹 3 中的密度/neturon(每种标度都不同)。图片作者。

了解有关 matplotlib 的更多信息:

要了解更多有关使用 matplotlib 处理测井数据的信息，请查阅以下文章:

• 使用 Matplotlib 中的线图创建测井数据的简单测井图
• 使用 Pandas、Matplotlib 和 Seaborn 探索测井数据

或者在 YouTube 上查看我的 matplotlib 播放列表:

结论

有许多很棒的 Python 库，本文中列出的有:lasio、dlisio、welly、missingno、pandas 和 matplotlib，这些都是在 Python 中处理测井数据的很好的起点。我强烈推荐去看看它们，探索它们的能力。

感谢阅读！

如果您觉得这篇文章有用，请随时查看我的其他文章，这些文章从不同的角度研究了 Python 和测井数据。你也可以在GitHub找到我在这篇文章和其他文章中使用的代码。

如果你想联系我，你可以在LinkedIn或者我的 网站 找到我。

有兴趣了解更多关于 python 和测井数据或岩石物理学的知识吗？跟我上 中 。

如果你喜欢阅读这些教程，并且想支持我这个作家和创作者，那么请考虑报名成为一名 Medium 会员。一个月 5 美元，你就可以无限制地阅读数千篇各种主题的文章。如果您使用 我的链接 ， 注册，我将为您赚取一小笔佣金，无需额外费用！

https://andymcdonaldgeo.medium.com/membership

6 Python Matplotlib 特性创建更好的数据可视化

原文：https://towardsdatascience.com/6-python-matplotlib-features-to-create-better-data-visualizations-b9fc65b0430b

如何展示和展示什么一样重要

戈登·威廉姆斯在 Unsplash 上的照片

数据可视化在数据科学中非常重要。它用于许多任务，如探索性数据分析、模型评估、讲故事等。一个设计良好的数据可视化可以比简单的数字提供更多的信息。

数据可视化的两个主要组成部分是它们表示什么以及如何表示。它们代表的是要可视化的数据。“如何做”和数据一样重要。我们通常有许多可视化数据的方法，我们如何选择会产生很大的不同。

在本文中，我们将介绍 6 个有助于使可视化效果更具吸引力和信息量的特性。

获取数据

让我们从获得一些可视化的数据开始。我们可以通过 pandas-datareader 库轻松获得股票价格数据。下面的代码块导入我们需要的库，然后创建一个 Pandas 数据框，其中包含指定开始和结束日期之间的苹果股票价格。

import pandas as pd
from pandas_datareader import dataimport matplotlib.pyplot as plt
plt.style.use("seaborn-darkgrid")# read the data
aapl = data.DataReader(
    "AAPL", 
    start='2021-10-01',
    end='2021-12-31',
    data_source='yahoo'
)

苹果股票价格(图片由作者提供)

线形图

折线图用于显示一个或多个值如何随时间变化。我们可以创建一个每日收盘价的线图。

plt.figure(figsize=(12,6))
plt.plot(aapl["Close"])

(图片由作者提供)

既然我们有了数据和参考基准图，我们可以开始引入一些特性来改进它。

我们观察到苹果股票价格持续上涨。但是，剧情看起来是那么的平淡和平淡。它甚至没有显示这条线代表什么。因此，第一步是添加轴标签和标题。

1.坐标轴标签和标题

我们可以使用xlabel和ylabel方法添加轴标签。标题可以用title的方法添加。

plt.figure(figsize=(12,6))
plt.plot(aapl["Close"])# axis labels and title
plt.ylabel("Closing Price", fontsize=15)
plt.title("Apple Stock Price", fontsize=18)

(图片由作者提供)

2.预备之物

通过添加额外的线条，线形图可用于显示多条信息。例如，我们可以在同一个图上显示体积信息。

plt.figure(figsize=(12,6))plt.plot(aapl["Close"])# second line
plt.plot(aapl["Volume"])# axis labels and title
plt.ylabel("Closing Price", fontsize=15)
plt.title("Apple Stock Price", fontsize=18)

(图片由作者提供)

它显示了两条线，但其中一条只是直线。原因是这些变量的值范围之间的极端差异。

我们可以通过使用辅助 y 轴来解决这个问题。我们还需要添加第二个轴对象，这可以通过使用subplots方法来实现。如果你想了解更多关于 Matplotlib 的结构，这里有一个关于这个主题的详细帖子。

我们将使用twinx方法添加一个辅助 y 轴。

fig, ax1 = plt.subplots(figsize=(12,6))# second Axes object
ax2 = ax1.twinx()ax1.plot(aapl["Close"])
ax2.plot(aapl["Volume"], color="r")# axis labels and title
ax1.set_ylabel("Closing Price", fontsize=15)
ax2.set_ylabel("Volume", fontsize=15)
plt.title("Apple Stock Price", fontsize=18)

第一行创建第一个轴对象，称为“ax1”。然后，我们使用twinx方法创建另一个具有不同 y 轴的 Axes 对象。

因为我们现在有了轴对象，所以绘图功能应用于轴对象。类似地，我们不需要使用ylabel方法，而是需要使用set_ylabel方法，并为两个轴对象分配一个标签。

下面是该代码块如何创建:

(图片由作者提供)

3.神话；传奇

不清楚哪一行代表哪一条信息。因此，在这种情况下，传奇是绝对必要的。

fig, ax1 = plt.subplots(figsize=(12,6))# second Axes object
ax2 = ax1.twinx()ax1.plot(aapl["Close"])
ax2.plot(aapl["Volume"], color="r")# axis labels and title
ax1.set_ylabel("Closing Price", fontsize=15)
ax2.set_ylabel("Volume", fontsize=15)
plt.title("Apple Stock Price", fontsize=18)# add legends
ax1.legend(["Closing price"], loc=2, fontsize=12)
ax2.legend(["Volume"], loc=2, bbox_to_anchor=(0, 0.9), fontsize=12)

loc参数指定图例的位置，2 表示“左上”。bbox_to_anchor方法提供了一种更灵活的选择图例位置的方式。请随意查看文档以获取关于图例方法的更多详细信息。

我们的图现在看起来如下:

(图片由作者提供)

4.网格线

当我们有多个 y 轴时，网格线可能不会重叠，这导致了一种不吸引人的外观。我们可以使用grid方法从一个或两个轴上移除网格线。

fig, ax1 = plt.subplots(figsize=(12,6))# second Axes object
ax2 = ax1.twinx()ax1.plot(aapl["Close"])
ax2.plot(aapl["Volume"], color="r")# axis labels and title
ax1.set_ylabel("Closing Price", fontsize=15)
ax2.set_ylabel("Volume", fontsize=15)
plt.title("Apple Stock Price", fontsize=18)# add legends
ax1.legend(["Closing price"], loc=2, fontsize=12)
ax2.legend(["Volume"], loc=2, bbox_to_anchor=(0, 0.9), fontsize=12)# remove grid
ax1.grid(False)
ax2.grid(False)

(图片由作者提供)

5.文本

Matplotlib 允许向绘图添加文本和注释。在某些情况下，添加短信可能很有用。

fig, ax1 = plt.subplots(figsize=(12,6))# second Axes object
ax2 = ax1.twinx()ax1.plot(aapl["Close"])
ax2.plot(aapl["Volume"], color="r")# axis labels and title
ax1.set_ylabel("Closing Price", fontsize=15)
ax2.set_ylabel("Volume", fontsize=15)
plt.title("Apple Stock Price", fontsize=18)# add legends
ax1.legend(["Closing price"], loc=2, fontsize=12)
ax2.legend(["Volume"], loc=2, bbox_to_anchor=(0, 0.9), fontsize=12)# remove grid
ax1.grid(False)
ax2.grid(False)# add text
ax1.text(
   "2021-10-31", 
   170, 
   "Nice plot!", 
   fontsize=18, 
   color="green"
)

前两个参数指定文本的位置。第三个是情节上要写的文字。其余的参数定义视觉属性，如大小和颜色。

(图片由作者提供)

额外收获:我们还可以用rcParams.给我们的图添加一个框架。在执行下面两行之后，这些图将生成一个黑盒框架。

plt.rcParams["axes.edgecolor"] = "black"
plt.rcParams["axes.linewidth"] = 1

6.x 刻度和 y 刻度的大小

我们还可以通过使用tick_params参数来调整 x 刻度和 y 刻度的大小。

fig, ax1 = plt.subplots(figsize=(12,6))# second Axes object
ax2 = ax1.twinx()ax1.plot(aapl["Close"])
ax2.plot(aapl["Volume"], color="r")# axis labels and title
ax1.set_ylabel("Closing Price", fontsize=15)
ax2.set_ylabel("Volume", fontsize=15)
plt.title("Apple Stock Price", fontsize=18)# add legends
ax1.legend(["Closing price"], loc=2, fontsize=12)
ax2.legend(["Volume"], loc=2, bbox_to_anchor=(0, 0.9), fontsize=12)# remove grid
ax1.grid(False)
ax2.grid(False)# add text
ax1.text(
   "2021-10-31", 
   170, 
   "Nice plot!", 
   fontsize=18, 
   color="green"
)# tick size
ax1.tick_params(axis='both', which='major', labelsize=13)
ax2.tick_params(axis='both', which='major', labelsize=13)

(图片由作者提供)

最终的剧情似乎比我们创作的第一部好很多。我们在本文中介绍的内容也将有助于创建其他类型的图，如散点图、直方图、箱线图等。

如果你想在我发表新文章时收到电子邮件，别忘了订阅。

你可以成为 媒介会员 解锁我的全部写作权限，外加其余媒介。如果您使用以下链接，我将收取您的一部分会员费，无需您支付额外费用。

https://sonery.medium.com/membership

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

你需要商务智能工具的 6 个理由

原文：https://towardsdatascience.com/6-reasons-even-you-need-a-bi-tool-75be3b3b587f

理查德·罗伯茨，战略副总裁，活性成分

塞萨尔·卡利瓦里诺·阿拉贡在 Unsplash 上拍照

“我们有这个，”他们说。“我们在开源框架上编写脚本。这些脚本，我们的模型，让我们与众不同。我们不需要 Power BI、Tableau 或 Qlik 这样的工具。”

我和很多在 Active Ingredients 担任战略主管的数据科学家交谈过，这是我所听到的。一开始。然后，在我们一起工作时，我通常会听到这六个痛点:

(1)我们需要探索，而不是做准备

除非你足够幸运，有一个全职的专门的数据工程师，否则你可能会花 80%的时间准备数据，只有 20%的时间探索数据并找到见解。我所说的数据准备是指创建业务就绪数据的完整数据集成过程(清理、转换等)。现在最好的 BI 工具包括用于组合和转换数据的 DI 功能。有些甚至提供企业级 DI 平台，该平台提供无缝的分析数据管道和数据目录。

(2)我们需要安全、可信、可控的数据

如果你不相信你的数据，你的模型就一文不值，对吗？顶级工具提供数据沿袭可视化等附加功能，或让您通过集中式管理安全地管理您的数据，使用基于规则的治理来控制应用和数据的发布、共享和用户访问。你需要分类的数据。一些顶级 BI 工具具有智能数据分析功能，可以告诉您数据的准备程度，并自动显示数据质量问题。例如，识别什么可能是 PII，然后自动屏蔽该信息。最后，让您的数据可以通过元数据轻松搜索，这让您感觉像是一次购物体验，您可以通过数据源、主题或业务领域进行搜索。

(3)我们需要能够自由探索任何方向的关联

R，Python 等的脚本。在回答预先确定的问题方面非常强大，但是它们将您的分析限制在基于 SQL 的线性模型中。这种基于查询的方法限制了您可以探索的数据，因此也限制了您的发现。一些现代 BI 工具有一个“关联”引擎，可以让你自由地、动态地、从任何角度探索你的所有数据。这使您能够发现关联，并暴露出您可能没有查询过或根本无法用基于查询的方法找到的模式、趋势和异常值。

(4)我们需要可视化的完全灵活性

许多数据科学家使用开源库进行可视化。但是这些工具基于数据的预定义结构来构建视觉效果。通过使用一个可以从最细粒度级别聚合数据的引擎，您可以更加灵活地暴露数据中的模式。您可以即时创建衍生数据点，对数据进行分组，然后基于这些分组创建可视化效果，如基准测试、颜色编码，并跟踪多个可视化效果中的代码。此外，您可以利用最佳的可视化选项，通过地理分析和时间序列等特定属性来分析数据，这在使用开源库时可能会很棘手。

我们需要与他人合作

我一再从数据科学家那里听到的另一个主题是，缺乏团队解决问题以及数据和分析方面的知识共享。因此，他们的利益相关者经常持有零散的隐性知识，他们的领域专长没有得到充分利用。BI 工具可以使以异步方式与业务用户协作变得更加容易，这避免了浪费在会议或等待决策上的时间。具体来说，这些工具允许用户添加叙述，以给出业务背景或关于如何进一步完善和探索的建议(就像有人在 Word 或 Google Docs 中所做的那样)。集体智慧比个人智慧好得多。

(6)我们需要“讲述”这个故事

是的，一张图片胜过千言万语，但是……如果没有上下文、解释和叙述，可视化和仪表盘就像一个罗夏测试，每个人都解释他们想看到的东西。这就是为什么数据科学家(就像其他分析用户一样)需要让数据发出声音。讲述一个故事，解释你的发现，比如一个异常值扭曲了一个趋势，并提出你的建议。这有助于采取明智的行动，因为行动需要背景。

在我们的谈话结束时，我的数据科学家朋友给了我他们需要 BI 工具的六个理由。他们仍然可以使用外部 IDE 来创建和改进他们的 R、Python 或 Scala 脚本，然后将它们与商业智能工具一起使用来解决上述需求。当然，并不是所有的 BI 工具都能提供所有这些功能，您需要做一些研究来找到适合您需求的工具。

在评估各种工具时，请记住以下几点:

• 找出哪些用例对你最重要，然后把它们作为你的参考框架。例如，我们全球客户的“必备条件”之一是可扩展性和能够实时分析数据，而不必将数据存入内存，因此我们首先关注这些功能。
• 了解 TCO(总拥有成本)。我通常必须向首席财务官解释，便宜或免费的工具最终会比其他选择花费更多，因为这些工具通常需要额外的资源、人员和基础架构来满足企业级需求。
• 确保您的工具的部署选项与您或您的客户的整体数据策略兼容。如今，您应该能够在任何环境中部署您的 BI 工具，而无需更换系统或购买新系统。

如果你和数据打交道，我很想听听你对此的看法！

公司在数据治理方面失败的 6 个原因

原文：https://towardsdatascience.com/6-reasons-why-companies-fail-at-data-governance-6d13fdeda570

以及如何避免陷入同样的陷阱

有了正确的方法，数据治理就不会令人头疼。图片由活动创建者提供。

如今，无论我们走到云数据领域的哪个地方，我们都会听到一个响亮而清晰的信息:“您应该考虑数据治理”。这是我们全心全意赞同的观点，但我们想更进一步——你应该以不同的方式思考数据治理。

在本文中，我将分享数据治理计划失败的六大原因，即使是一些最好的数据团队也是如此，以及如何避免陷入同样的陷阱。

你认为数据治理关乎对错

在一家大型拼车公司，两个团队几个月来一直在努力协调他们的报告。无论他们做什么，他们都无法获得相同的结果，即使他们坚持以相同的方式定义他们的度量，从相同的表中查询并一行一行地遍历代码。DAS42 接受了挑战，我们的发现成为我们最喜欢的数据治理重要性的例子之一。

一个团队正在使用“大区域=‘美国和加拿大’”的过滤器。另一个团队使用了“国家代码= 1(美国)或 32(加拿大)”的过滤器。我们被告知，这是一回事。但是毫无疑问，我们查看了映射表，发现国家代码 1 包括波多黎各，但是大区域“美国和加拿大”不包括。

并不是一个团队是对的，另一个是错的。那就是他们都没有完全理解他们的指标中包含或排除了什么。

这是我们看到的最常见的数据治理错误之一，它给我们的客户带来了一些最有害和最令人沮丧的数据灾难。

仅仅指着一个查询或输出说“这是真理的源泉”——说“这个数字是对的，任何其他数字都是错的”——是不够的。这是因为从根本上来说，数据治理与对错无关。上面提到的两个团队都有有效的数字，这取决于用例——取决于当利益相关者说“我们希望这些数字用于美国和加拿大”时是什么意思。**

这并不是说没有所谓的“错误”号码。当然，我们也看到分析师试图用“姓氏不包含‘测试’”这样的条款来排除测试账户，这对以 Battesten 或 Contestanza 这样的姓氏命名的真实人类来说是一种可怕的耻辱。(我们还没有遇到一个叫泰斯蒂·麦克泰森的真人，但更奇怪的事情已经发生了。)

但是，如果你不能解释一个数字与其他数字的区别，那么把它奉为正确的数字是没有用的。

将你的思维模式从“我们需要知道这些数字中哪些是对的哪些是错的”转变为“我们需要理解这些数字，它们包含什么，是什么使它们不同，以及在什么情况下使用它们是合适的”。

你过分强调高管的认同

不要误解我们——当然，让受人尊敬的高级团队成员支持您的数据治理计划是您工具箱中的一个强大工具。但是，获得日常处理数据的人员的支持也是绝对必要的，这些人员包括您的一线员工、您的工程师、您的项目经理，他们必须对他们的流程进行更改，以便您能够完全实现一个受治理的框架。

在你开始试图获得领导地位和利益相关者的支持之前，重要的是要对你的数据治理战略的当前状态保持透明。考虑如何回答以下问题:

• 您如何衡量贵公司收集和存储的资产的数据质量？
• 您要让您的数据治理策略负责实现的 KPI 或总体目标是什么？
• 您是否有来自公司其他部门的领导和数据用户的跨职能参与？
• 公司中谁将负责实现您战略的 KPI 和目标？
• 你有什么样的制衡机制来确保 KPI 得到正确衡量，目标得以实现？

正如对数据管道的可见性有助于确保高数据质量一样，当涉及到让领导团队中的每个人都了解情况并对其负责时，数据治理策略及其增量过程的透明度也至关重要。

您认为实现数据治理是一个项目

在实施数据治理框架时，数据领导者会犯两个主要错误。首先是“定了就忘了”的心态。他们认为数据治理是一项需要完成的计划，一旦完成，他们就会进入下一步。第二个错误类似，是过度治理的倾向。虽然可以理解，但这两种方法都没有抓住数据治理的核心。

就像数据接收或质量保证一样，数据治理也是一个过程。这可能需要在前端付出更多的努力，但是数据治理并不是一个真正完成的项目。随着您公司的成长和发展，您的度量标准定义也将随之发展。上面提到的方法的问题是它们没有留下变化的空间。

请记住，数据治理不是关于您的度量标准的对错，而是关于改变您的公司对这些度量标准的文化方法。不要认为数据治理是一件需要完成的事情——要认为数据治理是一件需要采用的事情。

你认为工具会做所有繁重的工作

数据领域充斥着各种工具、托管服务、方法和框架，我们不否认其中许多确实可以帮助您将数据提升到新的水平。数据可观察性就是其中之一。但是，正如上文所强调的，数据治理不是一个单一的工具，也不是一个设置好就能解决所有问题的工作流，而是一个持续的过程，涉及判断、决策和差异化。

虽然数据目录和其他治理解决方案通常将自己标榜为公司所有数据问题的答案，但许多数据领导者发现，当涉及到手动需求时，这些工具甚至在最基本的方面都有所欠缺。

有一些工具和公司可以让事情变得更简单，自动化流程，并帮助你跳出你的假设。但是对于过去十年我们在数据领域看到的所有创新，仍然没有技术可以替代谈论你的公司、你的过程、你的定义、你的度量和你的目标的困难(并且非常令人满意)的工作。

您认为您可以单独专注于数据治理

我们见过的一些最认真的利益相关者宣称他们致力于实施数据治理，将数据治理放在他们的优先列表的首位，并搁置其他一切。他们想要统治一切，他们想要现在就做。这可能会导致几个问题。**

首先，它会导致利益相关者的沮丧和失望，因为他们看不到新的可交付成果形式的物质收益。(当然，我们中的一些人认为数据治理非常令人兴奋，但可能不是你公司的每个人都是这种特定的书呆子。)

第二，如果你没有采取迭代的方法，实践的教训可能来得太晚了。我们看到公司“治理一切”,然后，在他们完成并实施了一切后的几周内，发现他们错过了一些重要的东西……而且他们错过了所有的东西。我们在上面提到了获得各级利益相关者支持的重要性。

当您开始数据治理之旅时，选择几个关键示例。这些可能是您业务的基础—您可能需要定义您的类别或产品层次结构，以确定您的净运营收入或可用率，或者您可能需要定义您使用“客户”一词的含义。(不管怎样，你是如何排除那些测试账户的呢？)选择两到三个高影响区域进行治理。构建您的治理肌肉，并使其可持续——这是您可以在日常工作和“照常营业”的可交付成果之外做的事情。

给自己时间去吸取教训，然后继续下一个，下一个。

你不知道什么数据真正重要

一旦您确定了想要集中精力的最初几个领域，下一步就是确保您管理的数据确实值得被管理。并非所有数据都是平等的，在当今的经济环境下，说一些数据比其他数据更有价值并不准确。例如，预测公司下一季度收入的数据可能比一张放在雪花仓库积满灰尘的角落里的复制表格更值得你关注。

在推出治理策略之前，确定哪些数据对您的业务最重要，并相应地进行优先级排序。了解您最重要的资产——无论它们处于管道的哪个阶段——可以确保您的团队 a)花时间为企业实际使用的数据构建数据治理计划，b)告诉您数据是否可用、新鲜，最重要的是，是否准确。

有一种方法可以做到吗？为最引人注目的数据资产设置服务级别协议(SLA)和服务级别指标(sli ),例如，为 CFO 的季度指标仪表板提供的表格或为您的广告活动提供信息的 Salesforce 数据。

设置数据可靠性 SLA 有助于在您的数据、数据团队和下游消费者(无论是您的客户还是您公司的跨职能团队)之间建立信任并加强关系。如果没有这些明确定义的指标，消费者可能会做出有缺陷的假设，或者依赖关于您的数据平台的可靠性和可信度的轶事证据。换句话说，数据 SLA 有助于您的组织更加“数据驱动”数据——反过来，也有助于数据治理。

那么，我们开始吧。

对于大多数组织来说，数据治理被委托给几只孤狼，负责说服整个“数字人”团队去关心一些本质上难以量化的东西。如果这听起来像是一个陷阱，那是因为它确实是一个——但它不一定是。

最终，您的数据治理策略的目标将是确保整个公司的团队都有能力使用数据，而唯一的授权方式就是建立信任和教育。

****我们最大的建议:从几个关键功能领域(土地和扩展)开始治理计划，跟踪几个关键 SLA，并跨越几个关键数据资产。在一个越大(数据)越好的世界里，有时候从小处着手是值得的。

+++

这篇文章是用 特雷莎·科维奇) 写成的，Das42 的首席顾问。

有兴趣分享你的数据治理恐怖故事吗？伸出手去 巴尔 。

数据科学家将在衰退中坚持(甚至可能繁荣)的 6 个原因

原文：https://towardsdatascience.com/6-reasons-why-data-scientists-will-persevere-and-maybe-even-thrive-in-the-recession-800b5604b91a

克里斯·利维拉尼在 Unsplash 上的照片

意见

在 LinkedIn 帖子、在线对话和新闻文章都暗示末日即将来临的时代，数据科学家、工程师和分析师都不应该放弃希望，应该继续磨练自己的技能和才能。

虽然这篇文章的性质与我的大多数技术教程有所不同，但我觉得我没有在专栏中评论行业趋势和似乎是全球经济衰退的问题，这对数据科学界不公平。这件事始于本周早些时候，当时我注意到特斯拉的一位同事向我求救。一段时间前，我们作为专业人士相遇，在 LinkedIn 上，他们宣布他们的一些同事被裁员 10%，需要尽快找到新的工作。我为他们感到难过，并评估了他们在前沿技术自动化方面的背景如何能够通过我的关系在其他方面得到利用。沿着我的时间线往下滚动，我注意到我的网络中到处都有类似的故事:小型咨询公司倒闭，比特币基地取消工作邀请，网飞停止招聘。许多公司已经逆转，而不仅仅是放缓，他们在疫情看到的极端增长。我开始意识到，不利的经济状况现在正以一种比我们在路上和杂货店看到的价格变化更大的方式影响到我的朋友和家人的生活，但现在是在我们的生活中。

对于许多在过去十年中进入数据科学和工程界的专业人士来说，这种程度的课程调整是一种新的可怕遭遇——2008 年的上一次大衰退发生在十多年前，在 2020 年的下跌之后，金融市场出现了前所未有的复苏。也就是说，这种逆转不仅是对我们专业人士的挑战，也代表了一个机会。如果个人以正确的方式参与，这个机会可以为未来几十年的许多人设定积极和富有成效的基调，有许多原因将导致这一代创新者不仅取得成功，而且茁壮成长。

原因 1:提供了如此多有利可图的就业机会的现代技术行业的价值被过度夸大了，但还有其他行业同样需要我们，如果不是更多的话。

技术领域的市盈率有时会比批发或杂货店的市盈率高出几倍，虽然每个人都可能想要一部新 iPhone，但每个人都需要经常从杂货店购买食物。出于多种原因，我们对科技公司的估值一直很高，其中一个最大的原因是投机——我们相信这些公司不仅现在(有时甚至还没有)而且在未来都会实现巨大价值。利率上升和支出减少将极大地影响我们对这些技术公司的估值，因为我们对整个市场的预期已经降低(尽管我们的希望可能没有降低)。在经济低迷时期，一些最可靠的市场并不是最耀眼的市场，而是提供最稳定价值的市场，因为它们现在是、将来也永远是被需要的，这些公司同样需要数据科学家，如果不是比技术领域的大型创新者更需要的话。

原因 2:基于价值的公司需要高绩效的技术领导者，不仅要保持，还要增加他们的价值。

正如吉姆·科林斯在《从优秀到卓越》一书中所阐述的那样，Kroger 等基于价值的公司在与理解数据驱动决策重要性的商业领袖和工程师的合作中蓬勃发展。不遵循科学驱动的决策模型来推动业务发展的公司，无论是哪个行业的公司，以及尽职调查以安全研究和实验的公司，都将发现巨大的利润和扩张机会。执行这项伟大工作的是数据科学家，其中许多公司仍在积极招聘，并将继续招聘。如果你不相信我，去谷歌一下“数据科学家工作杂货店”。不仅仅是食品杂货在经济衰退中继续开展业务，医疗保健、教育机构和物流等领域的需求都将比以往任何时候都更加重视数据工程师，因为现在有效的预算和决策变得更加重要。

理由三:我们是工业 4.0 的领导者。

工业 4.0 是一个我们经常听到的术语；你可能在办公室的饮水机旁，在与同事的电话会议上，或者甚至在新闻中听到过。用这个词很容易联想到舞台存在。也许你会想象机器人正在快速组装汽车、飞机部件，指示它们需要自己维护，或者模拟最高效的仓库。甚至在 15 年前似乎还是科幻小说的东西现在已经成为现实，幕后的工业 4.0 将数据科学作为连接我们作为一个物种的整个生计的框架和基础。在一个日益自动化和数字化的世界中，能够发现和应用集成的值得信赖的个人将得到认可和优先考虑。在如今资源受限的社会中，需求正在发生变化，从“我们能带来什么新的东西”转变为“我们如何最大限度地利用我们所拥有的东西”。数据科学家将被要求拿出他们的 A-game 来保持重要业务的全速运转，并让创新者在风暴过去之前保持漂浮。闪耀的时刻就是现在。

理由四:我们可以利用这段时间来提升自己。

我并不是说工作停顿或错过机会是一件好事——一点也不是。我想说的是，这一次可能会提供一个机会来暂时改变我们的生活方式，充分利用我们所拥有的，并改善我们生活的基础。过去的每一分钟，我们都生活在互联网上可用内容最多的一分钟，以学*新技能，寻找新的爱好，发展我们的教育，并实践让我们的生活感到充实的事情。

理由五:我们可以随时拔掉。

今年我们周围有这么多坏消息，这可能是一个机会，部分拔掉插头，找出我们的优先事项。上个月我删除了一两个社交媒体账号，感觉压力和焦虑迅速减轻。我推荐加州新港的数字极简主义作为一种资源来重新审视我们的生活，以及我们在多大程度上分享或优先考虑他人的意见。我们花了太多时间在网上和“上网”,以至于错过了改善自己的机会。每天在 Instagram 上滚动 30 分钟，或者每天跑步、编码、阅读、绘画、烹饪、阅读媒体文章、观看教程、与孩子玩耍，甚至亲自社交 30 分钟，哪个更有用？我想让每个人在这些混乱的时刻拔掉一周的插头，看看他们之后的感觉如何，如果你已经这样做了，请在下面评论一下这给你带来的感受。

原因 6:与原因 5 类似，每天 30 分钟，我们数据科学家的工具箱里有工具来构建一些不可思议的东西。

不过，这个“东西”取决于你。你已经掌握了哪些副业(甚至是爱好)？

• 擅长分析？为自己/家人/朋友建立预算。找出你每个月花了多少钱，评估可自由支配的花费对你有多重要。
• 喜欢 Python 编程吗？尝试制作新的应用程序或游戏。几年前，我尝试为亚马逊 Alexa 程序制作新的技能，收到了各种各样的好处(甚至是一些报酬),这些都是我在一个下午制作的简短但有趣的程序。
• 比如网页脚本或者数字设计？建立一个网站来展示你的技能或者为你的社区提供服务。拥有一份专业的商业档案会让你和你的合作伙伴与众不同。
• 你是学生，需要补时间吗？撰写并展示您的作品！我开始在 Medium 上写博客，作为建立作品集展示给未来雇主的一种方式，甚至在这里展示我的作品的帮助下，我在亚马逊找到了工作。

现在，数据科学家可以利用无数的数字资源与他们自己和他们的社区互动。

我希望我在数据科学和工程领域的合作伙伴可以阅读这篇文章，并对接下来的事情感到有动力、有启发或有兴趣。这是一个充满挑战的时代，但我们都在一起，我们将坚持度过这段时间。衰退后的世界肯定会变得不同，对我们的技能、个性和天赋的需求只会随着时间的推移而增加。

请让我知道你的想法，并欢迎通过 LinkedIn 联系我，提出反馈、问题或看看我们如何合作！点击这里查看我关于数据分析和可视化的其他文章！

解释 6 种强化学*算法

原文：https://towardsdatascience.com/6-reinforcement-learning-algorithms-explained-237a79dbd8e

强化学*术语、基础和概念介绍(无模型、基于模型、在线、离线学*)

瑞安·菲尔兹在 Unsplash 上拍摄的照片

机器学*分为三个分支:监督学*、非监督学*和强化学*。

• 监督学*(SL) :关注在给定标签训练数据的情况下获得正确的输出
• 无监督学*(UL) :关注在没有预先存在标签的情况下发现数据中的模式
• 强化学*(RL) :关注代理如何在一个环境中采取行动以最大化累积回报

通俗地说，强化学*类似于婴儿学*和发现世界，如果有奖励(正强化)，婴儿可能会采取行动，如果有惩罚(负强化)，则不太可能采取行动。这也是强化学*与监督学*和非监督学*的主要区别，后者从静态数据集学*，而前者从探索中学*。

本文将涉及强化学*的术语和基本组件，以及不同类型的强化学*(无模型、基于模型、在线学*和离线学*)。本文最后用算法来说明不同类型的强化学*。

注意:这些方程基于 Stuart J. Russell 和 Peter Norvig 的教科书《人工智能:现代方法》(第四版，全球版),为保持数学方程格式一致，做了一些小改动。

目录

• 强化学*术语
• 基础知识:马尔可夫决策过程(MDP)
• 无模型与基于模型的强化学*
• 离线学*与在线学*
• 算法:直接效用估算
• 算法:自适应动态规划
• 算法:时间差学*(TD 学*)
• 算法:探索
• 算法:Q 学*
• 算法:SARSA

强化学*术语

在深入研究不同类型的强化学*和算法之前，我们应该熟悉一下强化学*的组成部分。

图 1:强化学*术语的图解——作者图片

• 代理:从环境中接收感知并执行动作的程序
• 环境:代理所处的真实或虚拟环境
• 状态:座席可以处于的状态
• 动作(A) :代理在给定状态下可以采取的动作
• 奖励(R) :采取行动的奖励(依赖于行动)，处于状态的奖励(依赖于状态)，或者在给定状态下采取行动的奖励(依赖于行动和状态)

在婴儿探索世界的例子中，婴儿(代理人)处于现实世界(环境)中，可以是哭泣、感到高兴或饥饿(状态)。因此，婴儿可以选择吃东西或睡觉(动作)，如果婴儿在饿的时候吃东西，他/她就会满足(奖励)。

正如文章开头提到的，强化学*涉及探索，强化学*的输出是最优策略。一个策略描述了在每个状态下要采取的动作；类似于说明书。比如政策可以是宝宝饿了就吃，不然就让宝宝睡觉。这也与监督学*形成对比，监督学*的输出只是单一的决策或预测，没有策略复杂。

最后，强化学*的目标是通过优化所采取的行动来最大化总的累积回报。和婴儿一样，我们不都想从生活中获得最大的累积利益吗？；)

基础知识:马尔可夫决策过程(MDP)

由于强化学*涉及到做出一系列最佳行动，它被认为是一个顺序决策问题，可以使用马尔可夫决策过程进行建模。

图 2:MDP 的例子——作者图片

按照前面的部分，状态(由 S 表示)被建模为圆圈，动作(由 A 表示)允许代理在状态之间转换。在图 2 中，还存在转移概率(由 T 表示)，其中T(S11, A1, S12)是在状态S11采取行动A1之后转移到状态S12的概率。我们可以认为动作A1向右，动作A2向下。为简单起见，我们可以假设转移概率为 1，这样采取行动A1将保证向右移动，而采取行动A2将保证向下移动。

参考图 2，让目标在状态S23结束，从状态S11开始，黄色状态是好的(奖励+1)，红色状态是坏的(奖励-1)，紫色是目标状态(奖励+100)。我们希望代理了解最佳行动或路线是通过采取行动A2-A1-A1向下-向右-向右，并获得总奖励+1+1+1+100。更进一步，利用金钱的时间价值，我们在奖励上应用了折扣因子γ，因为现在的奖励比以后的奖励更好。

综上所述，从状态S11开始执行动作A2-A1-A1的预期效用的数学公式如下:

图 3:从状态 S11 开始的预期效用—作者提供的图像

上面的例子是一个简单的说明，有各种变化，

• 转移概率可能不是 1，需要考虑行动中的不确定性，例如采取某些行动可能不总是保证成功向右或向下移动。因此，我们需要对这个不确定性取一个期望值
• 最佳动作可能还不知道，因此通用表示将把动作表示为来自状态的策略，用 π(S) 表示
• 奖励可能不是基于黄色/红色/紫色状态，而是基于前一个状态、动作和下一个状态的组合，由 R(S1，π(S1)，S2) 表示
• 问题可能不会在 4 个步骤内解决，它可能需要无限的步骤才能达到目标状态

考虑到这些变化，在遵循策略 π 的给定状态 s 下，确定期望效用 U(s) 的更一般的等式如下:

图 4:从状态 s 开始执行策略的预期效用(等式 16.2)——作者图片

用图 4 的话来说，一个州的预期效用是贴现回报的预期总和。

由此可见，一个国家的效用与其邻国的效用相关；假设选择了最优行动，一个状态的效用是过渡的预期回报加上下一个状态的贴现效用。在编码术语中，这被认为是递归。数学上，它指的是下面的等式，

图 5:遵循最优政策的国家效用(等式 16.5)——作者图片

在图 5 中，这是著名的贝尔曼方程，它求解最大效用并导出最优策略。最优策略是在一个状态下采取的行动，它将导致最大的当前效用加上下一个状态的贴现效用，考虑了所有可能的下一个状态的转移概率。

回到图 2 中的 MDP 问题，最优策略是这样的，如果代理处于状态S11、S12或S13，代理应该通过采取行动A2向下移动。而如果代理处于状态S21或S22，代理应该通过采取动作A1向右移动。最优策略是通过求解贝尔曼方程得出的，以执行获得最大当前和贴现未来回报的行动。

• 额外:在教科书中，MDP 用(S, A, T, R)来表示，分别代表一组状态、动作、转移函数和奖励函数。
• Extra : MDP 假设环境是完全可观测的，如果智能体不知道它当前处于什么状态，我们就用部分可观测 MDP (POMDP) 来代替！
• 额外:图 5 中的贝尔曼方程可用于求解最优策略，使用值迭代或策略迭代，这是一种将效用值从未来状态传递到当前状态的迭代方法。

强化学*类似于求解 MDP，但是现在转移概率和奖励函数是未知的，代理必须执行动作来学*

无模型与基于模型的强化学*

上一节中的 MDP 例子是基于模型的强化学*。在形式上，基于模型的强化学*有成分转移概率T(s1, a, s2)和奖励函数R(s1, a, s2)，它们是未知的，代表要解决的问题。

• 基于模型的方法对模拟很有用。
• 基于模型的 RL 的例子包括值迭代和策略迭代，因为它使用具有转移概率和奖励函数的 MDP。

另一方面，无模型方法不需要知道或学*转移概率来解决问题。相反，代理直接学*策略。

• 无模型方法对于解决现实生活中的问题很有用。
• 无模型 RL 的例子包括 Q 学*和策略搜索，因为它直接学*策略。

离线学*与在线学*

离线和在线学*也被称为被动和主动学*。

在离线(被动)学*中，通过学*效用函数解决问题。给定一个具有未知转移和回报函数的固定策略，代理人通过使用该策略执行一系列试验来学*效用函数。

• 例如，在自动驾驶汽车中，给定地图和要遵循的大致方向(固定政策)，带有错误控制(未知转移概率 —向前移动可能导致汽车稍微左转或右转)和未知行驶时间(未知奖励函数 —假设更快到达目的地导致更多奖励)，汽车可以重复运行以了解平均总行驶时间(效用函数)。
• 离线 RL 的例子包括值迭代和策略迭代，因为它使用了使用效用函数的贝尔曼方程(图 5)。其他示例包括直接效用估计、自适应动态规划(ADP) 和时间差学*(TD) ，这些将在后面的章节中详细阐述。

在在线(主动)学*中，通过学*计划或决策来解决问题。对于基于模型的在线 RL，有探索和开发组件。在开发阶段，代理通过假设固定的策略和学*效用函数，表现得像离线学*。在探索阶段，代理执行值迭代或策略迭代来更新策略。

• 如果使用值迭代更新策略，则使用最大化效用/价值的一步前瞻提取最佳动作。如果使用策略迭代更新策略，则最佳策略可用，并且可以按照建议执行操作。
• 以自动驾驶汽车为例，在探索阶段，汽车可能会学*到在高速公路上行驶时所用的总时间更快，并选择向高速公路行驶，而不是简单地沿大方向行驶(策略迭代)。在开发阶段，根据更新后的政策，汽车现在以更少的平均总时间(更高的效用)行驶。
• 在线学*的例子包括探索、Q-学*和 SARSA ，这些将在后面的章节中详细说明。

比较两者，当有太多的状态和动作以至于有太多的转移概率时，在线学*是优选的。在网上学*中探索和“边学边做”比在网下学*中一次学会所有东西更容易。然而，由于探索中的试错法，在线学*也可能很耗时。

注:在线学*和 On-Policy(以及 Off-Policy 的离线学*)是有区别的，前者指的是学*(策略可以改变或固定)，后者指的是策略(一系列试验是来自一个策略还是多个策略)。在本文的最后两节中，将使用算法来解释符合策略和不符合策略。

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

在了解了不同类型的强化学*之后，让我们深入研究算法！

№1.直接效用估计

类型:无模型，离线学*

在直接效用估计中，代理人使用固定策略执行一系列试验，一个状态的效用是从该状态开始的预期总报酬或预期的奖励-继续。

• 以自动驾驶汽车为例，如果汽车在一次试验中在一个网格(1, 1)上启动时，总的未来奖励为+100。在同一次试验中，赛车重新回到那个格子，从那一点开始，总的未来奖励是+300。在另一次试验中，赛车从那个格子出发，未来总奖励为+200。该网格的预期回报将是所有试验和所有访问该网格的平均回报，在本例中为(100 + 300 + 200) / 3。

优点:给定无限多次尝试，样本平均回报将收敛于真实的预期回报。

反对意见:预期奖励在每次试验结束时更新，这意味着代理人在试验结束前什么也没学到，导致直接效用估计收敛得非常慢。

№2.自适应动态规划

类型:基于模型，离线学*

在自适应动态规划(ADP)中，主体试图通过经验学*转移和奖励函数。通过计算从当前状态转移到下一个状态采取行动的次数来学*转移函数，而在进入该状态时学*回报函数。给定所学的转换和奖励函数，我们现在可以求解 MDP。

• 以自动驾驶汽车为例，假设在给定状态下尝试前进 10 次，如果汽车最终向前移动 8 次，向左移动 2 次，我们得知转移概率为T(current state, forward, front state) = 0.8和T(current state, forward, left state) = 0.2。

优点:由于环境是完全可观测的，所以简单地通过计数就可以很容易地学*转换模型。

缺点:代理学*过渡模型的能力限制了性能。这将导致问题对于大的状态空间是难以处理的，因为需要太多的试验来学*转变模型，并且在 MDP 中有太多的方程和未知数要解。

№3.时间差学*(TD 学*)

类型:无模型，离线学*

在时间差学*中，代理学*效用函数，并在每次转换后以学*速率更新该函数。

图 6:效用函数更新方程(方程 23.3)——作者图片

术语“时间差异”指的是连续状态之间效用的差异，并且基于该误差信号更新效用函数，该误差信号由如图 6 所示的学*速率来缩放。学*率可以是一个固定的参数，也可以是对一个状态的访问次数增加的递减函数，这有助于效用函数的收敛。

与每次尝试后学*的直接效用估计相比，TD 学*在每次转换后学*，使其更有效。

与 ADP 相比，TD 学*不需要学*转移和奖励函数，使其计算效率更高，但也需要更长的时间来收敛。

ADP 和 TD 学*是离线 RL 算法，但是存在作为在线 RL 算法一部分的主动 ADP 和主动 TD 学*！

№4.探测

类型:基于模型、在线学*、主动 ADP

探索是一个主动 ADP 算法。与被动 ADP 算法类似，代理试图通过经验学*转换和奖励函数，但主动 ADP 算法将学*所有动作的结果，而不仅仅是固定策略。

还有一个额外的探索功能，用于确定代理对在现有策略之外采取行动的“好奇”程度。探索功能应该随着效用的增加而增加，随着经验的增加而减少。

• 例如，如果州具有高效用，则探索功能倾向于更频繁地访问该州。由于贪婪的增加，探索功能随着效用增加。
• 例如，如果该州以前没有被访问过或者访问的次数不够多，则探索功能倾向于选择现有策略之外的动作。反之，如果多次访问该状态，探索功能就没有那么好奇了。由于好奇心下降，探索功能随着经验减少。

优点:勘探政策导致向零政策损失(最优政策)的快速收敛。

缺点:效用估计没有策略估计收敛得快，因为代理不会频繁出现低效用状态，因此不知道这些状态的确切效用。

№5.q 学*

类型:无模型、在线学*、主动 TD 学*、非策略

Q-Learning 是一种主动 TD 学*算法。图 6 中的更新规则保持不变，但是现在状态的效用被表示为使用 Q-function 的状态-动作对的效用，因此命名为 Q-Learning。下面的图 7 显示了被动 TD 学*与主动 TD 学*的更新规则的差异。

这种符号差异是由于被动 RL 具有固定的策略，使得每个状态将仅执行固定的动作，并且效用简单地依赖于状态。而在主动 RL 中，策略将被更新，并且效用现在取决于状态-动作对，因为每个状态可以按照不同的策略执行不同的动作。

图 7:被动 TD(上图)与主动 TD(下图，方程 23.7)的效用函数更新方程——作者图片

Q-Learning 是偏离策略，这意味着目标，或者下一个状态的效用，在下一个状态的可能行动上最大化 Q-function(不考虑当前策略！).这样，我们不需要下一个状态的实际动作。

优点:可以应用于复杂领域，因为它是无模型的，代理不需要学*或应用转换模型。

缺点:它不展望未来，在回报稀少的时候可能会有困难。与 ADP 相比，它学*策略的速度较慢，因为本地更新不能确保 Q 值的一致性。

№6.萨尔萨

类型:无模型、在线学*、主动 TD 学*、基于策略

SARSA 是一种主动 TD 学*算法。算法名 SARSA 来源于算法的组成部分，即状态、动作、奖励、(下一个)状态和(下一个)动作。这意味着在更新 Q 函数之前，SARSA 算法等待在下一个状态中采取下一个动作。相反，Q-Learning 是一种“SARS”算法，因为它不考虑下一个状态的动作。

由于这种差异，SARSA 算法知道在下一个状态中采取的动作，并且不需要在下一个状态中的所有可能动作上最大化 Q 函数。Q-Learning 与 SARSA 的更新规则的差异在下面的图 8 中示出。

图 8:Q-Learning 的效用函数更新方程(上图)与 SARSA(下图，方程 23.8)——作者图片

SARSA 是 On-Policy 作为目标，或者下一个状态的效用使用当前正在运行的策略中的 Q-function。这样，下一个状态的实际动作就知道了。

注:如果 Q-Learning 不探索其他动作，在下一个状态下遵循当前策略，则与 SARSA 相同。

优点:如果整体策略由另一个代理或程序控制，则符合策略，这样代理就不会脱离策略并尝试其他操作。

缺点 : SARSA 没有 Q-Learning 灵活，因为它不会偏离策略去探索其他策略。与 ADP 相比，它学*策略的速度较慢，因为本地更新不能确保 Q 值的一致性。

总之，这是讨论的 6 种算法，分为不同类型的强化学*。

图 9:6 种强化学*算法的总结

这 6 种算法是帮助形成对强化学*的基本理解的基本算法。还有更有效的强化学*算法，如深度 Q 网络(DQN)、深度确定性策略梯度(DDPG)，以及其他具有更实际应用的算法。

如果你一直读到最后，恭喜你！我一直觉得强化学*很有趣，因为它阐明了人类如何学*，以及我们如何将这些知识传授给机器人(当然还有其他应用，如自动驾驶汽车、国际象棋和阿尔法围棋，仅举几例)。希望你已经了解了更多关于强化学*，不同类型的强化学*，以及说明每种强化学*的算法。

面向数据科学家的 6 本软件工程书籍

原文：https://towardsdatascience.com/6-software-engineering-books-for-data-scientists-5134637b118

数据科学家从使用适当的软件工程最佳实践编写代码中受益匪浅。了解 6 本可以帮你实现这一目标的好书

照片由@ this is engineering@ Unsplash.com 拍摄

【免责声明:此帖子包含图书保管处的附属链接】

在我看来，数据科学家是科技行业中最令人兴奋的角色之一。作为一名数据科学家，你有能力学*与软件工程、统计、财务甚至项目管理相关的技能。

虽然这种技能的融合使这份工作非常令人兴奋，但它也给开始在这一领域工作的人带来了很多挑战，因为大多数人可能没有受过上述所有技能的正式培训。

数据科学家可能会纠结的一个领域与软件开发和工程有关。许多人通过经济学、统计学或市场营销进入这个行业，当谈到编码时，他们大多是自学的。虽然这应该庆祝，因为它展示了大多数数据科学家的弹性，但它不应该干扰数据科学家改善他们的软件工程和一般编码的需要。

除此之外，MLOps 和机器学*模型的适当部署(两者都与软件工程密切相关)对于想要走出 POC(概念验证)兔子洞的组织来说越来越重要。即使您不负责您的模型的部署，您至少应该警惕将来有人会查看您的代码。

我个人是有统计学背景的。在我职业生涯的前 7 年，我一直在为一些大公司工作，这些公司在数据科学领域还不太成熟。在那段时间，我主要专注于开发善于展示机器学*潜力的模型，而不是用适当的软件工程最佳实践来构建东西。自从加入 DareData Engineering ，我的整个心态发生了变化，因为我开始同时与不同的公司合作，并理解了以可扩展的方式正确开发事物的必要性。

在工作中学*时，书籍是我用来提高技能的主要媒介之一。与视频和书面文章捆绑在一起，我喜欢阅读一些好的工程相关书籍，这些书籍帮助我提高技术水平，或者给我带来对我来说未知的全新视角。

这篇文章的目标是给你一个 6 本书的列表，这些书与我写更好的代码的旅程非常相关(这是我每天都在努力改进的东西！)

这些书是技术性和非技术性书籍的混合体。其中大部分都有编码示例，但有几个与一般方法和最佳实践相关。请记住，这些书中的大部分可能更适合那些没有接受过正式软件工程师培训或刚刚开始职业生涯的人。开始吧！

务实的程序员

照片由 @afgprogrammer 拍摄

务实的程序员对于没有任何软件工程背景的人来说是一个极好的选择。

这本书主要通过故事和教训，给你一些关于实现、逻辑、软件管理等方面的很酷的技巧和原则。阅读它将为您带来开发数据科学模型和算法的新视角，例如，它将帮助您理解避免重复的重要性以及如何调试和测试代码的一些策略。

这本书的第一版于 1999 年出版，它的一些建议今天仍然适用——这是对这本书质量的一个很好的论证，因为在技术领域，东西往往很快就会过时。这也是理解软件开发中使用的一些术语和概念的一个很好的选择，当你和其他有阿瑟背景的人一起工作时，理解这些术语和概念可能有点困难。

这本书对于改进我的代码的整体架构非常重要，并且给了我大多数学*旅程的最终目标:我定义了对我的生产力和职业精神非常有价值的新*惯(在这种情况下，是在编写代码时)。

一个相关的细节:如果你已经非常熟悉软件工程，你可能不会从中获得太多的价值。

在这里找到它:

• 书库上的务实程序员

Python 的搭便车指南

图片来自 @cdr6934 @Unsplash.com

有什么比全世界几百个贡献者写的 Python 书更好？

一本真正实用的 Python 中级到高级实践指南。因为这不是集中在最基本的东西(如数据结构)或 Python 的机器学*组件上，它将帮助您开发适当的 Python 编码实践，并使用您可能没有合并到代码中的其他东西，如面向对象编程或测试。

如果你是一个自学的 Python 程序员，你会从阅读这本书中受益匪浅。无论是从提高代码可读性的角度还是从提高速度的角度来看，这本书都是那些觉得自己的 Python 技能在最*达到了一个平台期的人的绝佳选择。在世界上最著名的开源语言之一中，还有什么比阅读世界上数百名 Python 程序员的思想和观点更好的方法呢？

就我个人而言，在处理 Python 的特殊性时，我发现它极具启发性。Python 是一种如此独特的语言，有如此多的细节，以至于我发现很难找到一种超越基础的学*资源——幸运的是，我找到了这本书，它做到了这一点，同时保持了学*的乐趣和吸引力。

在这里找到它:

• Book Depository 上的 Python 搭便车指南

设计模式:可重用面向对象软件的元素

照片由@ kellysikkema@ unsplash . com 拍摄

一本理解软件设计模式的好书。难以理解如何设计你的函数或类？这应该是你的首选书籍！

设计模式展示了 23 种不同的设计模式，您可以用它们来构建代码的逻辑和结构。在构建机器学*管道时，您可能会发现自己一次又一次地实现相同类型的模式。这本书可以给你一些替代的结构，可以增加你的代码的趣味，提高可读性或性能。

如果你是自学编码的，这本书可能很适合你的学*之旅，因为它可以揭示一些你没有意识到的软件架构模式。

作为数据科学家，我们通常不会一开始编码就使用面向对象编程(OOP)。如果你的 OOP 之旅刚刚开始，你会发现这本书的帮助非常非常有用。

当我从以严格的函数式和线性方法编写代码跳到使用 OOP 时，它真的帮助了我——尽管我没有找到为数据科学和机器学*量身定制的例子，但阅读这篇文章给了我一些工具，我可以很容易地适应这个行业。

您可以在这里找到它:

• 书库设计模式

马丁·福勒的《重构》

照片由@ jstrippa@ unsplash . com 拍摄

最著名的软件架构书籍之一，马丁·福勒的重构是持续改进和交付世界的标准。

这本书给了我们一个极好的提示和想法，告诉我们如何不断提高代码的可读性、可用性和性能——这在我们所处的敏捷世界中是至关重要的。通过大量的实际例子，作者给出了几个可以在功能之外改进代码的场景。

我发现这与数据科学和机器学*世界极其相关。尽管这本书没有包含专门的例子，但是由于其不断变化的本质，重构技术非常适合数据科学项目。

尽管这本书使用了 Java 示例，这对大多数数据专业人员来说有点困难，但希望你和我一样觉得它很有价值。对我来说，这是在开发的第一阶段后如何改进代码的一个很好的机会，我已经学会了如何在高效的时间内解决改变代码片段的困难任务。

在以下链接中找到重构:

• 书库上的重构

devo PS 手册:如何在技术组织中创造世界级的敏捷性、可靠性和安全性

图片由@ thought catalog@ unsplash . com 提供

说到敏捷，DevOps 手册是一本“原则”书，聚焦于 devo PS 哲学和协作开发的最佳实践。这本书比我在这份名单上的其他书都要轻松，它特别适合那些希望继续他们的职业生涯，成为技术领导角色的技术人员。

虽然不像其他书籍那样具有技术性，但这本书详细讲述了一些故事，以揭穿围绕 DevOps 文化的神话，同时展示了一些来自一些最著名的科技公司(网飞、亚马逊、Etsy 等)的例子。)在世界上。

这本书在细节上特别有趣:

• 如何将持续交付整合到您的部署实践中；
• 如何围绕持续改进(CI)和持续交付(CD)的工作方式建立团队；
• 如何将业务和 IT 实践结合起来——这是大多数科技公司赖以发展的事情；

由于我的角色结合了领导能力和技术技能，这本书对于理解大型技术组织如何工作非常有价值。当谈到开发和组织团队时，他们的成功是巨大的，看一眼他们使用的一些原则是在我自己的项目中进行小的改变的一个很好的方式。

一个警告:如果你对 CI/CD 的概念已经相当有经验，这本书可能会有点短，对你来说没有什么新闻。

在以下链接中找到devo PS 手册:

• devo PS 图书保管手册

干净的代码:敏捷软件工艺手册

分解我庞大的 Python 函数的主要贡献者之一。作为大多数数据科学家，我倾向于开发巨大的函数，这些函数做很多事情，并且很难调试。你知道的..这个主函数吸收您的数据并转换每一个简单的列，然后添加 400 个新变量！

这本书摧毁了这种思维模式，提高了我编写干净代码的能力。

这本书的缺点(就像重构)是它是为 Java 编程量身定制的，我肯定我错过了一些围绕它的争论，因为我对这门语言不是很流利。即便如此，它教授的原则也可以移植到其他编程语言(如 Python 或 R ),并为我提供了一个非常好的视角，让我知道如何编写更简洁的代码。

好的一面是，这是一本非常实用的书——不要指望作者在展示例子时会有任何闪失。它直截了当，主要集中在实际例子上。

在以下链接中找到干净代码:

• 干净的代码:敏捷软件工匠手册

感谢你花时间阅读这篇文章！我花了大约两年的时间读完所有这些书，目前，我正在完成“ Clean Code ”。

当开发新项目时，我仍然会不时地重温它们，因为它们帮助我编写更好的机器学*和数据科学软件。阅读它们是迈向更好地编写代码的伟大旅程——当你成为一名数据科学家时，这是一个永无止境的旅程。

我希望你也能从中汲取一些价值，把它们放在你的书架上，对你的职业成长之旅会像它们对我一样有价值。有其他推荐补充吗？写在评论里吧！

https://medium.com/membership/@ivopbernardo

数据科学家的 6 个统计概念

原文：https://towardsdatascience.com/6-statistical-concepts-for-data-scientists-337016d07698

了解一些统计概念，这将有助于您成为数据科学家或分析师

【免责声明:此帖子包含一些我的 Udemy 课程的附属链接】

统计是数据科学家工作描述的主要组成部分之一。在对数据或模型做出结论时，了解统计学尤其重要，可以避免我们在构建模型或分析时可能陷入的常见陷阱。

在一个计算能力和人工智能创新每天都在提升的世界里，可能会有抛弃统计数据的诱惑。当人们可以用强大到甚至可以说话或看得见的模型构建一个简单的.fit时，为什么还要学* p 值、数据分布或相关性与因果关系？

有三个论点为丢弃统计数据提供了相反的观点:

• 使用最先进的人工智能无法解决大多数问题。
• 大多数组织没有准备好每天对模型进行再培训。
• 统计学是一门研究归纳能力并对你没有的数据做出估计和假设的科学。

在本帖中，我们将讨论 6 个统计概念，数据科学家可以研究这些概念来提高他们的统计知识，并更深入地了解统计世界的美丽。

数据分布

大多数变量遵循特定的数据分布。你可能见过随机变量，绘制时如下所示:

生成的随机“正态分布”—由作者生成的图像

这就是著名的代表正态分布的钟形曲线。但是还有很多其他的，比如对数正态分布:

生成随机的“对数正态分布”—图片由作者生成

分布由定义其形状的参数来表征。此外，变量的类型(连续或离散)是定义预期行为和变量取值的另一个重要特征。

您可以在下面的资源中查看有关数据分布的更多信息:

• 数据科学家的 5 种数据分布
• 数据分布概述

CLT(中心极限定理)

中心极限定理(CLT)是一个非常强大的规则，它将帮助你理解基于随机抽取的样本的总体均值。基本上，如果您有一个变量 x 并且您想要发现变量(μ)的真实平均值，您可以记录较小样本的平均值(建议至少为 n =30)，这些样本平均值将具有*似正态分布，其平均值与总体的μ相似。

最精彩的部分？不管潜在的人口分布是什么，这个规律都成立。例如，如果分布是对数正态并且你从该变量中随机抽取样本，样本均值也将趋向真实总体μ！

为了使 CLT 成立，从总体中抽取样本时必须考虑一些假设:

• 样本必须从总体中随机抽取。如果绘制有偏差的样本(例如，仅基于变量的筛选部分)，则 CLT 不适用于整个总体。
• n ≥ 30。如果确定底层数据分布正常，甚至可以少用一些数据。
• 样本是独立的。

关于 CLT 的更多详情:

• 维基百科的 CLT 页面(有技术和数学信息)；
• 统计学由吉姆·CLT 解释；

相关性与因果性

如果你在数据行业工作，你可能已经听过无数次了。理解这种说法是数据科学家的基础。在这个时代，发现虚假的相关性只需要几行代码，理解说某件事导致另一件事的影响更加重要。

当然，对于一些项目来说，这不是问题。但是大多数时候，当你在一个数据项目中，需要知道为什么现象是联系在一起的，而不仅仅是它们是如何联系在一起的。

说到数据科学项目，你真的需要了解你的用户在寻找什么。变量对结果的影响会以某种方式使用吗？例如，如果你正在建立一个客户流失模型，你发现打电话给客户的公司和客户流失之间存在正相关关系，这是否意味着该公司应该停止打电话给客户，他们将不再流失？不要！

通过进一步挖掘数据，您会发现还有第三个变量可以解释这种行为——该公司之所以给客户打电话，是因为他们的服务首先出现了一些问题，这也是他们不断抱怨的原因！

为了确保因果关系，必须进行某种类型的受控 A/B 测试或使用其他统计测试。观察研究是不够的，因为它们不能保证可交换性或不纯粹性。

在这里阅读更多关于相关性和因果性的内容:

• 可汗学院的文章
• 决策实验室的文章

集中趋势和分散

两个变量可能有完全相同的平均值，但它们的取值范围有很大的不同。理解这一点是理解采样和比较两个样本之间差异的关键。

集中趋势和分散是数据分布的两个极其重要的特征。集中趋势可以用不同的度量来测量，例如平均值、中间值或众数，而分散性可以用标准偏差或方差来测量。通过了解这两个参数和分布类型，您将能够部分地可视化分布的形状以及随机变量如何围绕其期望值流动。

发现这两个论点对于理解人们对随机变量未来行为的预期非常重要，特别是在比较样本或理解数据相似程度时。例如，在数据科学的背景下，理解集中趋势和分散将有助于您处理期望值并创建一些健壮的异常值检测技术。

您可以通过以下链接了解更多信息:

• 中央倾向的例子；
• 分散的例子；

p 值

p 值是假设零假设为真，我们在统计测试中观察到某个值的概率。

例如，在回归模型中，每个系数都有一个附加的 p 值。为什么？因为那个 p 值正被用来测试系数效应为 0 的假设。如果你的系数有一个低的 p 值(例如，0.01)，那么你就是在说这个系数为 0(也就是对结果没有影响)的概率大约是 1%，这是一个非常低的概率。

p 值对于理解统计假设检验非常重要，可以用一句话来概括:“如果我的零假设为真，我有多大可能看到这个 p 值？”。在统计测试中，你通常以拒绝你的零假设的低 p 值为目标。

重要的一点是:由于 p 值与检验零假设相关，因此 p 值并不意味着替代假设有效。

您可以通过以下链接了解有关 p 值的更多信息:

• 了解 p 值；

希望您喜欢这份总结，它为您在统计之旅中的下一步研究提供了很好的指导！其中一些概念对于您作为数据科学家或分析人员将面临的多项任务非常重要，例如:

• 当构建离群点检测时
• 回归模型
• 假设检验
• 基于数据分布构建要素
• 执行 A/B 测试

您认为属于本指南的其他统计概念有哪些？把它们写在下面的评论里吧！

如果你想参加我的 R 课程，请随时加入这里( 绝对初学者 R 编程 )或这里( 数据科学训练营) )。我的课程大体上适合初学者/中级开发人员，我希望有你在身边！

数据科学训练营课程 —图片作者

https://medium.com/membership/@ivopbernardo

成功的机器学*项目的 6 个步骤

原文：https://towardsdatascience.com/6-steps-towards-a-successful-machine-learning-project-3a56f59e2747

爱德华·豪厄尔在 Unsplash 上拍摄的照片

从概念验证到生产以及两者之间的过程

介绍

机器学*项目的旅程是一个复杂的过程。它需要对数据科学和统计技术的透彻理解，以及与研究、工程和产品团队合作的能力，以交付一流的机器学*驱动的产品。

在本文中，我们将探索并建立一个交付机器学*项目的基本框架。

• 项目启动
• 数据探索
• 数据处理
• 模型开发
• 模型评估
• 模型部署

1.项目启动:想法、需求和数据获取

成功制作一个机器学*项目的第一步是理解问题，解决问题，并产生一个符合你需求的结果。

在开始你的项目之前，你必须了解问题、数据和背景。你还需要知道目标，以及它如何与使用机器学*技术的可能性保持一致。

例如，假设您想让一位顾客再次到商店购物。你希望首先了解顾客在商店的一般购买行为。此外，要开发一个模型，你需要了解可用用户的类型——年龄、消费*惯、位置等。如果有足够的、高质量的数据可用，那么可以开发一个机器学*模型；然而，如果没有这样的用户级信息可用——尽管这个问题非常适合机器学*用例——那么建立一个模型就很有挑战性。

并非所有的数据点通常都可以在模型开发中使用的格式或数据库中获得。您还必须协调如何在此为下游任务提供数据。

2.数据探索

数据探索是检查数据以识别模式，并在您的问题环境中理解它们。这通常被称为“真正的数据科学”阶段，因为在这一阶段，你可以通过查看原始事实和数据，而不需要对它们可能意味着什么有任何先入为主的概念，从而进入正题。

这一步包括以不同的方式查看可用数据——例如，通过添加新变量或改变现有变量——然后查看这些变量之间是否有任何有趣的关系。例如:

• 对于男性来说，年龄和工资有相关性吗？如果是这样(有可能)，这对在类似公司工作的女性有什么影响？
• 当你比较一个变量和另一个变量时会发生什么？它们对彼此有任何影响吗？

这是模型开发过程的重要部分。在进行更详细的分析和开发模型之前，您可以在这里了解您的数据并决定您希望得到哪些问题的答案。

3.数据处理和特征选择

数据预处理是将原始数据转换成适合分析和模型开发的形式的过程。这是决定最终模型成功与否的最关键步骤之一。

有几种方法可以预处理您的数据。它可以包括以下一个或多个步骤:

• 从数据集中移除不相关的要素
• 填充缺失值
• 减小数据集和特征集的大小
• 将分类变量转换成数值变量(反之亦然)
• 标准化数据点

4.模型开发

现在是构建模型的时候了。有许多可用的开源算法和方法，您可能想为您的问题选择——然而，从简单的开始然后重复通常是明智的。

选择算法时，您可能需要考虑:

• 数据大小:数据有多大？需要快速处理还是慢速处理？你的算法是需要大量数据来学*，还是可以从有限的数据点学*？
• 问题类型:这种算法可以解决什么样的问题？给定的算法有特定的数据处理需求吗？模型对缺失数据的反应如何？
• 可用性:对于给定的算法，是否有可用的库或包？

5.模型评估

一旦模型定型，在部署之前评估模型并理解如何解释结果是至关重要的。

评估模型的方法之一是通过交叉验证。在此过程中，您在一些数据集上训练模型，然后在实际数据上使用它之前，在完全不同的训练集上测试它的性能。这有助于确保您的数据集不会有任何偏差，并有助于确保您的模型在实践中运行良好。

6.模型部署

现在您已经准备好了第一个模型，最后一步是将模型部署到生产中。这是机器学*中最重要的步骤之一，因为它允许你将你的数据用于现实世界的应用，甚至从中赚钱！

您可以在两种模型部署方法之间进行选择:手动或自动。手动意味着其他人必须一步一步地经历所有这些；相比之下，自动化意味着一切都是自动发生的，不需要任何人工干预。

然而，每种方法都有一些缺点。例如，手动部署非常耗时，并且比自动部署需要更多的资源；它还严重依赖于那些可能不擅长创建软件应用程序的人。

与手动部署相比，自动部署速度更快，占用的资源更少。此外，它不依赖任何人类互动。

结论

任何机器学*项目的旅程都是漫长的，需要时间和努力才能实现预期的结果。每一部分都有细微差别，在以后的文章中，我将更详细地介绍它们。我希望这篇文章能帮助你更好地规划你的下一个机器学*项目。

如果您有任何问题或意见，请在下面留下，我会在方便的时候尽快回复您

感谢阅读。如果你有任何反馈，请评论这篇文章，在 LinkedIn 上给我发消息，或者给我发邮件(shmkapadia[at]gmail.com)

如果你喜欢这篇文章，请阅读我在 NLP 上的其他文章

你应该知道的 6 个时间序列预测任务

原文：https://towardsdatascience.com/6-time-series-predictive-tasks-you-should-know-about-b899fb83b6bf

不同的问题是如何在时间序列中出现的以及与之相关的挑战

安德鲁·尼尔在 Unsplash 上拍照

在这篇文章中，我将描述 6 个可以和时间序列数据集放在一起的预测任务。这些任务中的每一个都有许多相关的应用。因此，如果您是一名处理时间序列数据的数据科学家，这些可能有助于从您的数据中提取价值。我所说的预测性是指目标是预测时间序列的未来状态，或者不容易观察到的当前状态的任务。

以下是每项任务的简要概述:

1. 时间序列预测:预测一个时间序列的未来值；
2. 时空预测:类似于时间序列预测，但针对几个位置或轨迹；
3. 超越预测:预测即将到来的值是否将超过预定义的阈值；
4. 异常检测(又称活动监控):及时检测需要采取行动的罕见但具有破坏性的事件；
5. 时间序列分类:将时间序列分类到预定义的类别中；
6. 生存分析:预测感兴趣的事件发生的时间。

1.时间数列预测法

(图片由作者提供)图 1:澳大利亚政府每月在制药项目上的支出(百万美元)。蓝色部分代表未来 24 个月的预测。源是 fpp2 R 包中可用的名为“ a10”的数据集。

预测是指预测一个时间序列(图 1)即将到来的观测值的过程。这是一个具有挑战性的问题，因为这是一个外推过程，并且在估计中存在很大的不确定性。模型依赖于从过去数据得出的假设，而这些假设通常不成立。

在之前的一篇文章中，我描述了在建模时间序列时需要考虑的几个重要方面。其中包括趋势或季节性等基本要素，以及反身性或变化检测等更复杂的问题。

除此之外，预测过程本身也带来了额外的挑战。例如，在大多数应用中，我们感兴趣的是提前预测许多值(例如，接下来 24 小时的每个值)。虽然大的预测范围是可取的，但由于不确定性的增加，这大大增加了任务的难度——预测短期或*期的未来更容易。

另一个挑战是不确定性的量化。预测特定值(点估计)有助于减少未来的不确定性。然而，提供一个似是而非的值区间对于最佳决策更好。或者，在二元事件的情况下，事件发生的概率。例如，“明天有 80%的可能性会下雨”这句话比简单地说“明天会下雨”更能说明问题。

另一个挑战是极端值的预测，这可能与某些领域相关。例如，在能源市场中，重要的是捕获能源负载峰值，以便有效管理电网。

2.时空预测

可以使用支持 GPS 的传感器在多个位置捕获时间序列。例如，几个浮标站放置在沿海不同的固定位置，测量海洋状况。对于时空数据，目标是预测每个位置的未来值。

照片由艾美奖 C 在 Unsplash 上拍摄

时空数据背后的主要挑战之一与它所带来的额外依赖性有关。给定位置的观测值不仅与该位置先前的观测值相关，还与其邻居的观测值相关。时空相关性的适当建模对于获得准确可靠的预测至关重要。

有时传感器不固定在某个位置，例如出租车车队中的 GPS 设备。有了这样的数据，目标可以是，例如，使用历史轨迹来预测正在进行的或即将到来的旅行的持续时间。

3.超越概率预测

(图片由作者提供)图 2:海浪高度时间序列。预测它是否超过预定义的阈值(红色虚线)对于确保海上作业的安全非常重要。源数据在处可用。

超越概率是一个预测问题，其目标是估计一个时间序列在预定的未来时期内超过预定阈值的概率。在极值(分布的尾部)高度相关的领域中，这项任务非常重要。

一个实际应用是通货膨胀率预测。如果通货膨胀率很有可能超过给定的百分比，那么中央银行可能会被提示提高利率。另一个例子是自然灾害，如洪水或地震。

通常，超越预测是二元分类问题，旨在预测阈值被超越的概率。然而，非二元问题也可以基于不同的阈值来定义。例如，股票市场交易者可能对根据价格变动预测买入、卖出或持有信号感兴趣。在预测价格回报方面超过正阈值可以用作买入信号；相反(预测价格回报低于负阈值)可以代表卖出触发。如果没有一个阈值被满足，那么交易者应该持有当前的头寸。

4.异常检测

有时我们感兴趣的是预测，而不是时间序列的一般行为(例如，在下一次观察中它是上升还是下降，以及各自的大小)，而是感兴趣的特定和罕见的事件。解决这种情况的预测任务是时间序列异常检测，也称为活动监控。

时间序列异常检测背后的主要目标是及时检测有趣但罕见的事件，这些事件在特定的应用领域可能具有破坏性。这对于决策制定至关重要，因为它使专业人员能够采取适当的行动来防止这些事件或减轻其后果。因此，从机器学*的角度来看，预测模型的输出是二进制的，这表示感兴趣的事件是否发生。

关于活动监控有两个主要挑战。首先是隐含在这个词中的适时。这一表述意味着，在发出有关即将发生的事件的警报的时间点和事件发生或开始的时间点之间，有一个适当的警告期。这个时间间隔对专业人员来说至关重要，因此他们可以评估形势并决定行动方针。第二个挑战是感兴趣的事件很少。因此，学*这些事件背后的概念代表了不平衡的学*问题。

这项任务有点类似于上文所述的超越预测。超越概率预测。然而，还是有一些重要的区别。超越预测通常(但不一定)与单个时间序列有关。另一方面，时间序列异常检测通常涉及随时间监控多个实体，这些实体可能经历或可能不经历感兴趣的事件。此外，在时间序列异常检测中，事件是任意定义的，并不特定于特定阈值的超出，尽管情况可能是这样。

5.时间序列分类

时间序列分类是给一个时间序列分配一个类的过程。这个问题类似于传统的分类，但是属性是按时间排序的。

时间序列分类和上述经典的时间序列预测任务有两个重要的区别( 1。时间序列预测)。首先，它代表一个分类任务，而预测通常是一个回归问题。第二，在时间序列分类中，每个观察值都是独立于其他时间序列的单独时间序列(通常是单变量和数字的)。在预测的情况下，每个观测值都是一个更大的时间序列的子序列，观测值之间存在一定程度的依赖关系。

有时目标是在不牺牲性能的情况下尽可能早地对时间序列进行分类，这代表了一个早期时间序列分类任务。每一项测量都可能是昂贵的，或者尽快采取行动可能是重要的。这导致了一种折衷，因为较少的观察通常会导致较差的性能。

虽然不太常见，但也有时间序列回归问题，其中与时间序列相关的目标变量是数字。

6.生存分析

生存分析的目标是预测感兴趣的事件发生的时间。这个问题通常与随着时间的推移观察一组实体(如人、设备)的领域相关。示例应用包括犯罪学(预测再犯前的时间)、工程可靠性(预测设备故障前的时间)或客户管理(预测客户流失前的时间)。

生存分析问题的关键挑战是观察值经常被删截——关于某些实体的信息只是部分可用的。这可能是因为在事件发生之前，实体可能停止被观察。

其他任务

还有其他时序任务，其主要目标是知识发现。这些本质上不是预测性的，但仍然非常相关。它们提供了有关时间序列的重要信息，并可用作预测任务的子程序。例子包括:

• 聚类:在时间序列中，聚类是指寻找彼此相似但与其他时间序列组不同的时间序列组的过程。聚类可用于查找完整时间序列组(全序列聚类)或查找更大时间序列内的子序列组(子序列聚类)；
• 总结:有时时间序列非常长，这给它们的处理带来了困难。因此，通常进行总结以减少它们的维数，同时仍然保留基本结构；
• Motif Discovery :在时间序列中，Motif 代表重复出现的模式——一个时间序列的子序列，在一段时间内大致重复。

如果你想让我详细阐述这些任务，请在评论中告诉我！

进一步阅读

[1]埃斯林、菲利普和卡洛斯·阿贡。"时间序列数据挖掘."美国计算机学会计算调查(CSUR)45.1(2012):1–34。

[2]玛丽安娜·奥利维拉。"时空数据的预测分析."(2021)博士论文。

[3]王，平，，钱丹. k .雷迪。"生存分析的机器学*:综述."美国计算机学会计算调查(CSUR)51.6(2019):1–36。

[4] Mueen，Abdullah 等，“时间序列主题的确切发现”2009 SIAM 数据挖掘国际会议论文集。工业和应用数学学会，2009 年。

[5] Bagnall，Anthony 等人，“时间序列分类大赛:对最*算法进展的回顾和实验评估”数据挖掘与知识发现31.3(2017):606–660。

处理空值的 6 个技巧

原文：https://towardsdatascience.com/6-tips-for-dealing-with-null-values-e16d1d1a1b33

本·赫尔希在 Unsplash 上的照片

包括迭代方法、平均值和中值填充以及分组依据、平均值和中值填充

空值是机器学*和深度学*中的一个大问题。如果您使用的是 sklearn、TensorFlow 或任何其他机器学*或深度学*包，则需要在将数据传递给机器学*或深度学*框架之前清理空值。否则，它会给你一个又长又难看的错误信息。

在本文中，我们将研究如何处理空值。首先，会有一些非常简单的方法，慢慢地我们会转向一些更复杂和更有效的方法。

为了演示空值的处理，我们将使用著名的 titanic 数据集。

import pandas as pd
import numpy as np
import seaborn as sns
titanic = sns.load_dataset("titanic")
titanic

预览已经显示了一些空值。让我们检查每一列中有多少个空值:

titanic.isnull().sum()

输出:

survived         0
pclass           0
sex              0
age            177
sibsp            0
parch            0
fare             0
embarked         2
class            0
who              0
adult_male       0
deck           688
embark_town      2
alive            0
alone            0
dtype: int64

年龄列有 177，embark_town 列有 2 个空值。但是 deck 列在 891 行数据中有最多的空值 688 行。出于机器学*或任何其他类型的数据分析目的，我想完全删除这个专栏。

我们将重点关注 age 和 embark_town 列，并处理这些列的空值。

开始吧！

我会从最简单的策略开始，慢慢走向更复杂的招数。

1.简单地放弃

如果您有足够大的数据，最简单的策略是使用下面的代码删除包含空值的行:

titanic.dropna()

但是泰坦尼克号的数据集并不太大。事实上在现实世界中，我们也没有足够的时间删除数据，因为在删除所有空值行后，我们没有足够的数据。

2.用零填充

另一个非常简单的方法。您可以用零填充所有的空值，从而使这个过程变得非常简单。我们可以用零填充年龄列中的空值，如下所示:

titanic['age'].fillna(0)

输出:

0      22.0
1      38.0
2      26.0
3      35.0
4      35.0
       ... 
886    27.0
887    19.0
888     0.0
889    26.0
890    32.0
Name: age, Length: 891, dtype: float64

看第 888 行。以前是空的，现在是零。这也是很幼稚的做法。尤其是在这种情况下，年龄不能为零。

3.向前和向后填充

这也是填充空值的常用技术。向前填充表示使用序列中的前一个值填充空值，向后填充表示使用序列中的下一个值填充空值。

titanic['age'].ffill()

输出:

0      22.0
1      38.0
2      26.0
3      35.0
4      35.0
       ... 
886    27.0
887    19.0
888    19.0
889    26.0
890    32.0
Name: age, Length: 891, dtype: float64

请注意，888 行现在是 19，和 887 行一样。

titanic['age'].bfill()

输出:

0      22.0
1      38.0
2      26.0
3      35.0
4      35.0
       ... 
886    27.0
887    19.0
888    26.0
889    26.0
890    32.0
Name: age, Length: 891, dtype: float64

该行 888 已经从行 889 取得了值。

4.平均和中间填充

在大多数情况下，我更喜欢这个，用平均值和中间值填充空值。这里我用的是中间值:

titanic['age'].fillna(titanic['age'].median(), inplace = True)
titanic['age']

输出:

0      22.0
1      38.0
2      26.0
3      35.0
4      35.0
       ... 
886    27.0
887    19.0
888    28.0
889    26.0
890    32.0
Name: age, Length: 891, dtype: float64

现在，行 888 中的空值是 28，这是列年龄的中间值。

5.使用 Groupby 的平均值和中间值填充

简单的方法是放入整个列的中间值或平均值。但是我喜欢更具体的方法来计算中间值和平均值。不是取整个年龄列的中值，把所有的空值都填满，而是用每个 pclass 和' alive '的平均年龄来填满空值会更准确。

让我们看看“pclass”和“alive”的平均年龄，如果它们有所不同的话:

titanic.groupby(['pclass', 'alive'])['age'].mean()

输出:

pclass  alive
1       no       43.695312
        yes      35.368197
2       no       33.544444
        yes      25.901566
3       no       26.555556
        yes      20.646118
Name: age, dtype: float64

是的，它们确实变化很大。

如果我们用相应的平均值填充这些组中每一组的空值，将会更准确。

titanic['age'].fillna(titanic.groupby(['pclass', 'sex'])['age'].transform('mean'))

输出:

0      22.00
1      38.00
2      26.00
3      35.00
4      35.00
       ...  
886    27.00
887    19.00
888    21.75
889    26.00
890    32.00
Name: age, Length: 891, dtype: float64

现在，888 排变成了 21 排。相比之下 28

分类空值插补

embark_town 列是一个分类列，我们仍然可以对它应用与上一个示例相同的过程。

但在此之前,“embark_town”列的值需要表示为数值:

titanic['embark_town'] = titanic['embark_town'].astype('category')
titanic['embark_town'] = titanic['embark_town'].cat.codes
titanic['embark_town']

输出:

0      2
1      0
2      2
3      2
4      2
      ..
886    2
887    2
888    2
889    0
890    1
Name: embark_town, Length: 891, dtype: int8

我将按“pclass”和“alive”对数据进行分组，并用中间值填充空值。

titanic['embark_town'] = titanic['embark_town'].fillna(titanic.groupby(['pclass', 'alive'])['embark_town'].transform('median'))

6.基于机器学*模型的迭代插补

这是输入空值的一种非常好且有效的方法。在这个过程中，每一列中的空值被填充。每一列作为一个指定的机器学*模型的标签逐一使用。

然后，具有非空值的行被用于训练机器学*模型，并且具有空值的行使用该训练的模型来预测。

在这个演示中，我只使用了几个列。还记得在开始时我们检查了哪些列有空值，我们看到 age、embark_town 和 deck 列有空值。

但是，该列有太多的空值，我们希望避免该列。但是出于演示的目的，我将在 titanic1 数据集中添加 deck 列。

我在这里使用 RandomForestRegressor。您可以使用任何其他回归模型。

from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
from sklearn.ensemble import RandomForestRegressor
titanic1 = titanic[['survived', 'pclass', 'age', 'sibsp', 'fare', 'embark_town']]

让我们现在做插补，我将插补数据集保存为 titanic2。

imptr = IterativeImputer(RandomForestRegressor(), max_iter=10, random_state=0)
titanic2 = pd.DataFrame(imptr.fit_transform(titanic1), columns = titanic1.columns)
titanic2

888 排年龄现在 32 了！

我们应该检查 titanic2 数据集中是否还有空值:

titanic2.isnull().sum()

输出:

survived       0
pclass         0
age            0
sibsp          0
fare           0
deck           0
embark_town    0
dtype: int64

任何列中都不再有空值。

这些都是我今天想分享的关于空值的技巧。

结论

如果您愿意，也可以为各个色谱柱选择不同的技术。如果您发现任何其他处理空值更有效的技术，请随时分享。

请随时在推特和脸书页面上关注我

更多阅读

https://pub.towardsai.net/how-to-create-and-use-multi-index-dataframe-to-scale-up-your-data-analysis-fa80ed025d42 https://pub.towardsai.net/an-overview-of-the-major-sql-query-clauses-and-most-commonly-used-functions-60720e2a20d7 https://pub.towardsai.net/data-analysis-91a38207c92b

作为新毕业生进入职场的 6 个小贴士

原文：https://towardsdatascience.com/6-tips-for-transitioning-into-the-workforce-as-a-new-grad-ef9c1b452e69

从换工作中学到的教训，以及我希望自己能早点知道的事情

克里斯·劳顿在 Unsplash 上的照片

从大学到职场的转变似乎是一件容易的事，但事实并非总是如此。一些数据科学和工程实*并不总是准确描述大学毕业后的工作情况。通常情况下，实*生会被分配一些他们喜欢的项目，或者一些到夏天结束时还没什么价值的小概念证明。说到这里，我想和你分享一些帮助我过渡到职场和新工作的小技巧。

1。读，读，读

无论是团队文档，代码文档，还是文章，都要跟上学*。了解最新技术、数据科学进步和行业公告。了解您的团队和公司利用哪些其他公司的数据平台，如仪表板工具、云开发和数据工程功能。了解您的团队可以利用的新工具和技术。

当涉及到行业的变化时，我们总是想创新和跟上时代。然而，算法、工具和技术的市场瞬息万变。当您决定保留现有技术或进行发展以适应新的需求时，了解这些变化会有所帮助。

我发现这很有帮助的一个例子是在报告和仪表板中。几年前，我必须和我的团队一起评估仪表板的市场工具。由于我们需要在一份报告中可视化并向不同的利益相关者展示大量数据，我们决定使用内部工具。当我们等待其他技术到达我们需要的地方时，这个内部工具将为我们提供所需的灵活性和可伸缩性。了解什么是可用的将帮助您做出这些决定，并根据需要进行调整。

2。提问

如果你找不到答案，请向团队中更资深的人寻求帮助。不要觉得你不能问别人问题。相反，人们会帮助你解决问题，而不是让你浪费时间自己解决问题。学会寻求帮助是一项很有价值的技能，在不同的项目中会派上用场。

我最喜欢的寻求帮助的方式之一是通过电话和屏幕共享联系一两个数据科学家。在这段时间里，我可以浏览我的代码，展示我的分析，并获得反馈和建议。一开始，我的问题是简单的语法错误问题或数据误解。尽管如此，把这些问题搞清楚总比在你把它们呈现给利益相关者之后才发现要好。现在，我可以与人们进行更专注的对话，并知道如何提出正确的问题。

3。做你的研究

边读边做研究，对你的新角色有更多的了解。花时间研究你不知道的算法，并确保你理解它们。如果你在工作中遇到问题，首先要做好调查，尝试解决问题。问所有你被卡住的问题是很好的，但是保持学*的最好方法之一是首先自己做研究，然后在你绞尽脑汁的时候问问题。

和我的经历类似，你可能会发现很多团队缺乏文档。或者文档不像人们希望的那样全面。没关系。这是开始保存文档的好时机。当你问问题和做研究时，记下你得到的发现。尽可能详细地记录您的代码和分析，以便当您回去或者需要将工作移交给新的人时，知道您在哪里停止了工作。

4。寻找导师

我极力主张，在职业生涯的早期找到一两个导师是一笔宝贵的财富。导师是那些能问你难题、帮你找到答案、教你了解你的团队/公司等等的人！找一个和你相处融洽，能为你辩护的人。寻找导师的另一个重要原因是获得关于你技能的建议和反馈。

当我第一次找到数据科学导师时，我经常和他见面，以提高我的讲故事技巧。我需要更好地理解在利益相关者面前展示我的分析的过程，这些利益相关者可能不完全理解我的工作背后的数据科学和算法。这位导师观看了我的演示，并对我可以改进的地方给出了可靠的反馈，例如分享指标和业务影响，而不是理论和算法。导师是获得改进领域反馈的宝贵财富。

如果你已经在你的职业生涯中呆了几年，开始指导吧。你可能会觉得自己太年轻或缺乏经验，但你有一些东西可以与学生和新毕业生分享。您可以帮助回答他们的问题，并在您的数据科学之旅中引导他们吸取经验教训。我喜欢在大学演讲，这是分享这些见解和回答学生问题的另一种方式。例如，两名精算师学生最*问，既然他们已经选好了专业，现在进入数据科学是否为时已晚。但是，当然不会，什么时候都不晚！

5。通过贵公司的网络

当你有时间的时候，把它作为一个和不同的人交往的机会。我喜欢建立关系网的一种方式是邀请我参加关于我感兴趣的话题的会议。这可能包括您感兴趣的特定数据科学项目、某人主持的知识传授会议或来自其他团队的演示。我经常要求被邀请参加会议和各种电话会议，以便更多地融入我的团队并结识新的个人。

建立关系网的另一个重要原因是寻找对数据科学感兴趣的人。这些人可能是工程师、营销人员、人力资源人员或其他对如何利用他们在团队中收集的数据感兴趣的人。与你和你的团队相比，社交是了解这些人在做什么的好方法。我发现，如果你不确定自己想在职业生涯中专注于数据科学领域，这一点尤为重要。这是探索你不同选择的好时机。

记住，如果这是你的第一份工作，这不是你的最后一份工作。你有机会做出改变，因为你知道在这个领域你对什么感兴趣，什么不感兴趣。向你交往的人学*，找到你喜欢做的事情。我想研究新技术，与利益相关者交流，了解数据科学和工程最佳实践。知道了这一点，我转过身来，以确保我专注于这个领域。对你来说，你可能会发现你喜欢的东西非常不同。这是你找出答案的时候了。

6。参与其中

另一种认识新朋友的方法是加入不同的团体。这些小组可以让你结识整个公司不同背景的人，同时分享共同的兴趣。例如，如果你想加入更多的技术团体，考虑期刊和图书俱乐部，人工智能和人工智能实践社区，以及数据科学实践社区。

在之前的工作中，我参与了管理人工智能和人工智能实践社区的人工智能和人工智能时事通讯。这份时事通讯让我能够与其他对数据科学感兴趣的人一起采访不同的个人和团队，分享行业的变化，并通过公司建立联系。通常，较大的组织会有这种类型的小组，你可以加入学*，如果他们没有，开始一个！

如果你不想参与你的内部组织，你可以考虑工作之外的团体。例如，我加入了演讲会，这是一个公共演讲俱乐部。虽然不是以数据科学为重点，但我可以向不同的观众进行关于数据科学主题的技术演讲，并获得关于我的演讲是否能被其他人理解的可靠反馈。这种反馈对我的职业生涯有所帮助，因为我现在可以轻松地向非技术和技术观众展示。

最后的想法

从大学到职场的转变似乎很简单，但事实并非总是如此。我对一些可用的数据科学和工程实*的主要抱怨是，它们不一定是毕业后工作的现实代表。一些帮助你度过过渡期的想法:

• 尽可能多的研究和阅读,( 1)帮助解决你的问题,( 2)跟上最新的趋势。卡住了就问问题。
• 找一个导师，经常和你的经理安排 1:1 的时间。利用这段时间讨论目标和成就。
• 建立关系网，尽早加入你的公司。这是一个了解你的公司和结识新朋友的好方法。

这是你弄清楚你喜欢和不知道数据科学的时候了。花些时间探索您的选择，并找出您希望在数据空间中的位置。

在你进入职场或换工作的过程中，哪些建议对你有所帮助？

感谢阅读！我希望你喜欢阅读我所学到的东西。要了解更多，请订阅我的简讯。

在你的下一个机器学*项目中支持特征工程的 6 种技术

原文：https://towardsdatascience.com/6-tips-to-power-feature-engineering-in-your-next-machine-learning-project-d61530eee11b

从数据创建新要素的技术

Vishnu Mohanan 在 Unsplash 上的照片

什么是特征工程？

机器学*中的特征工程是从现有数据中创建新特征。从学*的角度来看，原始数据中包含的信息可能是不够的。因此，您可能需要将这些数据转换为新的要素或列，以帮助您以更有助于学*的方式表示数据。建立模型的一般过程如下。

1. 探索性数据分析，包括数据清洗
2. 特征工程(本文)
3. 功能选择
4. 型号选择
5. 模型训练和评估

在所有这些步骤中，可以说最重要的是特征工程步骤。通过仅默认原始数据，您可能会错过提供有价值的上下文来解释行为发生的原因。无论是预测用户还是机器的行为，特征工程对于项目的成功都是至关重要的。可能需要做些什么的几个例子:

1. 缩放数字数据和编码分类数据
2. 将长格式文本转换成数值
3. 计算日期或时间之间的差异
4. 将数据聚合到一行中，例如求和、计数或计算平均值
5. 创建聚合日期窗口
6. 将来自不同来源的数据合并到一组观测数据中

我喜欢维基百科上提供的定义。它总结了使用领域知识提取新特征的思想:

特征工程或特征提取是利用领域知识从原始数据中提取特征(特性、性质、属性)的过程。与仅向机器学*过程提供原始数据相比，动机是使用这些额外的特征来提高来自机器学*过程的结果的质量。

我们可以从这一点开始。领域知识。

领域知识

特征工程的一个关键部分是将业务和领域知识应用到您的数据中，以创建最佳特征。关于如何创建要素，并没有单一的方法或规则，但是许多方法都要求您了解它们可能相关的背景。

在本例中，我们将使用的数据集是由作者合成生成的，代表购买软件的公司，并随机生成使用数据来模拟用户在日常使用软件时可能尝试的事件。

在集思广益讨论您可能想要创建的功能时，请考虑数据的背景。我们将创建几个特征来表示帐户对此的活跃程度。我们将在下面演示其中的一些。

首先，我们需要理解数据的结构和关系。

理解我们的数据结构

让我们用一个实体关系图或 ERD 来看这个可视化。实体关系图是可视化信息表格的最佳方式。我们可以在单个图像中看到我们需要的一切以及来自列、类型和关系的数据。

在我们的第一个表 OPPORTUNITIES 中，我们有一个组合键，它构成了由 ACCOUNT_ID 、 OPPORTUNITY_ID 、 RENEWAL_DATE 和 PRODUCT_CODE 组成的主键。主键允许我们唯一地识别一个机会。在事件表中，我们有一个外键与 ACCOUNT_ID 的关系。对于每个账户，我们有零到多个潜在事件。

作者图片

现在我们对数据结构有了一个大致的了解，我们可以导入我们的数据并开始特征工程的过程。

加载和清理数据

第一步是加载和清理我们的数据。在这里，我们还可以了解数据的大小和形状。

import pandas as pd

df_opp = pd.read_csv('opps.csv')
df_event = pd.read_csv('events.csv')

print(df_opp.shape)
print(df_event.shape)

(1000, 8)
(1000000, 7)

我们看到大约有 1，000 个机会和 1，000，000 个事件。

df_opp.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1000 entries, 0 to 999
Data columns (total 7 columns):
 #   Column      Non-Null Count  Dtype 
---  ------      --------------  ----- 
 0   ACCOUNT_ID  1000 non-null   object
 1   OPP_ID      1000 non-null   object
 2   ORDER_DATE  1000 non-null   object
 3   PRODUCT     1000 non-null   object
 4   QUANTITY    1000 non-null   int64 
 5   START       998 non-null    object
 6   END         998 non-null    object
dtypes: int64(1), object(6)
memory usage: 54.8+ KB

df_event.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1048575 entries, 0 to 1048574
Data columns (total 7 columns):
 #   Column      Non-Null Count    Dtype 
---  ------      --------------    ----- 
 0   ACCOUNT_ID  1048575 non-null  object
 1   COMPANY_ID  1048575 non-null  object
 2   USER_ID     1048575 non-null  object
 3   PROJECT_ID  977461 non-null   object
 4   DATE        1048575 non-null  object
 5   TYPE        1048575 non-null  object
 6   COUNT       1048575 non-null  int64 
dtypes: int64(1), object(6)
memory usage: 56.0+ MB

这两个表主要包含带有一个数字列的字符串(对象)。

df_event.head()

ACCOUNT_ID COMPANY_ID USER_ID PROJECT_ID       DATE
0  account420       org1      u1         p1 2019-05-10   
1  account399       org2      u2         p2 2019-05-06   
2  account399       org2      u3         p3 2019-06-24   
3  account122       org3      u4         p4 2019-04-30   
4   account61       org4      u5         p5 2019-08-07   

                                                TYPE  COUNT  
0  099664351c56c479154c4b1e649a727e3ac099cc26747c...      3  
1  78478722fa50547376912d1bc1b21d5f5fb60188015342...      1  
2  9e5fd45ed38136db73e76b46ad11a0200b7a4cbaae9bc1...      2  
3  85c11686c1e1d3072f30b05ff74fd93b92c5d37a1b7ba3...      1  
4  31ea88da80c3371a7e70ac8a9299974290c47e83b46170...      1

df_opp.head()

ACCOUNT_ID OPP_ID ORDER_DATE
0   account1   opp1 2020-04-23   
1   account1   opp1 2020-04-23   
2   account2   opp2 2020-04-16   
3   account2   opp2 2020-04-16   
4   account3   opp3 2020-04-09   

                                             PRODUCT  QUANTITY
0  cd5ba48bb6ce3541492df6f2282ca555a65397c168dc59...         4
1  1a5a6aac31b1d9e08401bd147df106c600254b2df05a3f...         2
2  28746a25d12d36a1c0956436cfd6959f0db252e3020928...         1
3  1a5a6aac31b1d9e08401bd147df106c600254b2df05a3f...         8
4  1a5a6aac31b1d9e08401bd147df106c600254b2df05a3f...         3

         START         END  
0 2020-04-24    2021-04-23  
1 2020-04-24    2021-04-23  
2 2020-04-17    2021-04-16  
3 2020-04-17    2021-04-16  
4 2020-04-10    2021-04-09

这个过程的一个典型部分是确保我们没有空值。在检查了数据(未显示)之后，我们有了一些东西。在我们的 OPP 表中有一些空值，为了简单起见，我们将删除这些空值，对于事件表，项目标识有一些空值，我们可以用另一个值填充，例如公司标识。需要理解处理空值的业务环境；这只是两个例子。

# Drop any null values from important variables
df_opp.dropna(inplace=True)

# Fill any missing PROJECT_IDS with the COMPANY_ID
df_event['PROJECT_ID'].fillna(df_event['COMPANY_ID'], inplace=True)

缩放数字数据和编码分类数据

一个非常简单的数据转换是对数字数据进行缩放和对分类数据进行编码。虽然数据的数值缩放不是特征工程，但它很重要，因为许多算法不喜欢未缩放的数据。

转换分类数据的一种常见方法是使用一种称为单热编码或 OHE 的过程。OHE 获取分类数据并将它们扩展到新列中，其中每个分类值都有一个新列，一个二进制值指示该分类是否在该行中。OHE 阻止模型预测序数值之间的值。更多关于 OHE 的信息，请查看:一个热门编码。

column_trans = ColumnTransformer(transformers=
        [('num', MinMaxScaler(), selector(dtype_exclude="object")),
        ('cat', OneHotEncoder(), selector(dtype_include="object"))],
        remainder='drop')

这方面的典型过程是包装和利用柱变压器。你可以在这里阅读更多关于这个过程的内容:停止一步一步地构建你的模型。利用管道实现流程自动化！

将长格式文本转换为数值

处理长文本数据的另一种常见方法是将文本的长度表示为一个数字，这在产品评论等情况下很有用。例如，长篇评论通常与更多负面或正面评论联系在一起吗？是不是越长的评论越有用，与之相关的产品就越畅销？您可能需要对此进行试验。我们的数据集没有长格式文本，但这里有一个如何做到这一点的例子。

df['text_len'] = df.apply(lambda row: len(row['text']), axis = 1)

计算日期或时间之间的差异

通常，日期本身在机器学*中不是一个有用的特征。与 2012 年 5 月 1 日相比，2021 年 1 月 5 日意味着什么？我们需要把这些转化成对学*更有用的东西。例如，无论客户是否会继续购买或订阅我们的理论产品，我们都在谈论销售机会。可能更有用的是捕捉客户最*是否活跃。不活跃的客户很可能不会重新购买我们的软件。

首先，您需要确保任何日期实际上都是日期-时间格式。为此，我们可以利用 Pandas to_datetime功能。

# Convert dates to datetime type
df_event['DATE'] = pd.to_datetime(df_event['DATE'])
df_opp['ORDER_DATE'] = pd.to_datetime(df_opp['ORDER_DATE'])
df_opp['START'] = pd.to_datetime(df_opp['START'])
df_opp['END'] = pd.to_datetime(df_opp['END'])

接下来，我们可以构建新的列来表示自他们上次使用软件以来的天数。在我们转换成日期-时间格式后，这是一个简单的减法操作，并将其存储为一个名为 DAYS_LAST_USED 的新列。

注意: 这个计算在我们的笔记本中是最后完成的，但是更适合这篇文章。

# Add a column for the number of days transpired since the last known event and the renewal date
df['DAYS_LAST_USED'] = (df['ORDER_DATE'] - df['DATE']).dt.days

将数据聚合到一行中，例如求和、计数或计算平均值

关键的一步是确保我们只有一行或一个观察来代表每个独特的机会。正如我们在导入过程中看到的那样，有 1，000 个客户，但有 1，000，000 个事件。我们需要将每个客户或机会的事件汇总到一行中。对于我们的例子，我们将通过 ACCOUNT_ID 来聚集事件。

熊猫对此有一个惊人的特点groupby叫.agg。我们可以在一次操作中用不同的聚合操作符聚合所有的列。在这里，您可以传递一个类似于sum或count的字符串。你可以使用像mean和std这样的 Numpy 函数，甚至可以传递一个自定义函数；它非常强大。点击阅读更多。

注意nunique——这是一种计算一列中唯一值数量的强大方法。对于分类数据非常强大。

df_agg = df_event.groupby(['ACCOUNT_ID'], as_index=False).agg(
    {
        # how many unique projects are they using 
        'PROJECT_ID':"nunique", 

        # how many different unique orgs 
        'COMPANY_ID':"nunique", 

        # how many total unique users 
        'USER_ID':'nunique', 

        # are the using the software recently
        'DATE':max, 

        # how many different features are they using 
        'TYPE':"nunique", 

        # what is their utilization 
        'COUNT':sum 
    }
)

df_agg.head()

ACCOUNT_ID  PROJECT_ID  COMPANY_ID  USER_ID       DATE  TYPE  COUNT
account1             6           1        6 2019-09-23    21    216
account10          116           1       19 2019-10-23   309  87814
account100           9           1        5 2019-10-29   188   1582
account101           3           1        1 2019-09-18    31    158
account102          35           1        3 2019-10-30   214  14744

聚合完成后，我们现在有了一个简单的数据框，其中每一列都有一个数字表示，包括产品最后一次使用的最大日期，然后可以使用它将其转换为数值，如上所示。

创建聚合日期窗口

另一个优秀的特性工程技术是基于滚动时间框架创建不同的聚合计数。例如，客户在过去一周、一个月或一个季度的活跃程度如何？与计算自帐户上次活动以来的天数类似，我们计算了这些时间窗口内的使用量。当然，越来越多的活跃用户，越来越*，越来越有可能暗示着继续使用软件的愿望。

Pandas 在处理时间序列数据方面具有令人难以置信的功能。你可以在这里了解更多信息。使用时间序列函数的一个注意事项是，您需要一个基于日期时间的索引。所以我们要做的第一件事是将索引设置到我们的日期列。

df_ts = df_event.set_index('DATE')

接下来，我们可以使用一个操作，该操作允许我们通过last天数(周、月、年)来聚合,并使用一个groupby操作和聚合器，比如我们上面所做的sum。因为我们想要存储其中的一些值，所以我们将首先计算它们，将它们保存为新的数据框，并将该列重命名为更具描述性的名称。

df_14 = df_ts.last('14D').groupby('ACCOUNT_ID')[['COUNT']].sum()
df_14.rename(columns={"COUNT": "COUNT_LAST_14"}, inplace=True)

df_30 = df_ts.last('30D').groupby('ACCOUNT_ID')[['COUNT']].sum()
df_30.rename(columns={"COUNT": "COUNT_LAST_30"}, inplace=True)

df_60 = df_ts.last('60D').groupby('ACCOUNT_ID')[['COUNT']].sum()
df_60.rename(columns={"COUNT": "COUNT_LAST_60"}, inplace=True)

最后，我们将merge这些放回到我们的主聚合数据框架中，添加我们的三个新特性。

df_agg = pd.merge(df_agg, df_14, on="ACCOUNT_ID", how='left')
df_agg = pd.merge(df_agg, df_30, on="ACCOUNT_ID", how='left')
df_agg = pd.merge(df_agg, df_60, on="ACCOUNT_ID", how='left')

# Finally - fill null values with Zeros for future modeling
df_agg.fillna(0, inplace=True)

df_agg.sample(10)

COUNT_LAST_14  COUNT_LAST_30  COUNT_LAST_60  
340        12107.0        46918.0          87659  
472           88.0         1502.0           2042  
295           47.0          262.0            412  
453          955.0         5921.0          13915  
242          175.0          663.0            946  
286          165.0         1106.0           2066  
461          469.0         3722.0           7984  
85           503.0         1954.0           4183  
46           157.0         1808.0           3165  
444            0.0            2.0              2

将来自不同来源的数据合并到一组观测数据中

最后，我们需要将我们新聚合的事件表和我们所有的特性合并到 OPPS 数据框架中。我们可以用上面同样的merge函数来做这件事。

# Merge the datasets on Account ID
df = pd.merge(df_opp, df_agg, on="ACCOUNT_ID")
df

ACCOUNT_ID OPP_ID ORDER_DATE
0   account1   opp1 2020-04-23   
1   account1   opp1 2020-04-23   
2   account2   opp2 2020-04-16   
3   account2   opp2 2020-04-16   
4   account3   opp3 2020-04-09   

                                  PRODUCT    QUANTITY      START
0  cd5ba48bb6ce3541492df6f2282ca555a65...           4 2020-04-24
1  1a5a6aac31b1d9e08401bd147df106c6002...           2 2020-04-24
2  28746a25d12d36a1c0956436cfd6959f0db...           1 2020-04-17
3  1a5a6aac31b1d9e08401bd147df106c6002...           8 2020-04-17
4  1a5a6aac31b1d9e08401bd147df106c6002...           3 2020-04-10

         END  PROJECT_ID       DATE  DAYS_LAST_USED  TYPE  COUNT
0 2021-04-23           6 2019-09-23             213    21    216
1 2021-04-23           6 2019-09-23             213    21    216
2 2021-04-16          22 2019-10-16             183   185  19377
3 2021-04-16          22 2019-10-16             183   185  19377
4 2021-04-09          27 2019-10-08             184    64    556

   COUNT_LAST_14  COUNT_LAST_30  COUNT_LAST_60  DAYS_LAST_USED  
0            7.0          136.0            216             213  
1            7.0          136.0            216             213  
2         1157.0        10109.0          19314             183  
3         1157.0        10109.0          19314             183  
4            7.0          372.0            556             184

现在你知道了！在我们最终的数据框中，我们有大约 1000 行(删除了空值后)附加了新创建的要素。我们可以基于这些新特征来执行特征选择。

关于本文的完整代码，请访问 GitHub

结论

特征工程可以说是机器学*中最关键的一步。特征工程通过使用领域和业务知识从数据中构造新信息，在数据中创建新列。我们讨论了处理分类数据的多种技术、处理日期时间数据的多种方法，以及如何将多个观察值聚合成可以合并回原始数据的新表示。虽然这只是触及了这个话题的表面，但我希望它能让你开始你的旅程！

如果你喜欢阅读这样的故事，并想支持我成为一名作家，考虑注册成为一名媒体成员。一个月 5 美元，让你可以无限制地访问成千上万篇文章。如果你使用 我的链接 注册，我会赚一小笔佣金，不需要你额外付费。

用 Python 处理超长时间序列数据的 6 个可视化技巧

原文：https://towardsdatascience.com/6-visualization-tricks-to-handle-ultra-long-time-series-data-57dad97e0fc2

使用几行 Python 代码处理长时间序列图的简单想法

在 Unsplash 上由 Waldemar Brandt 拍照

通常，时间序列图由代表时间轴的 X 轴和显示数据值的 Y 轴组成。这种可视化在显示数据随时间的进展方面很常见。它在提取洞察信息方面有一些好处，如趋势和季节效应。

在处理超长时间线时有一个问题。尽管使用数据可视化工具可以很容易地将长时间序列数据放入绘图区域，但结果可能会很混乱。下面我们来对比两个样本。

第一张图显示了 2021 年的每日气温数据。第二张图显示了 1990 年至 2021 年的每日气温数据。都柏林机场每日数据来自气象局。作者图片。

虽然我们可以在第一个图表上看到细节，但可以注意到，第二个图表由于包含较长的时间序列数据而过于密集，难以阅读。这有一个主要的缺点，即一些有趣的数据点可能会被隐藏。

为了解决这个问题，本文将介绍六种简单的技术，帮助更有效地呈现长时间序列数据。

处理长时间序列数据的方法示例。图片由作者提供。

检索数据

例如，本文将使用都柏林机场每日数据，其中包含自 1942 年以来在都柏林机场测得的气象数据。数据集由每日天气信息组成，如温度、风速、气压等。

有关都柏林机场每日数据的更多信息，请参见下面关于数据集的部分。

从导入库开始

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as snsimport plotly.express as px
import plotly.graph_objects as go
%matplotlib inline

阅读 CSV 文件

df = pd.read_csv('location/file name.csv')
df['date'] = pd.to_datetime(df['date'])
df.tail()

探索数据

df.info()

幸运的是，快速查看一下，数据集没有丢失值。

准备数据

我们将使用最高和最低温度数据。使用的时间段是从 1990 年到 2021 年，一共 32 年。如果您想选择其他变量或范围，请随意修改下面的代码。

创建月、年和月-年列供以后使用。

绘制时间序列图

从数据框中，下面的代码显示了如何绘制一个基本的时间序列图。稍后可以将结果与本文中的其他可视化结果进行比较。

plt.figure(figsize=(16,9))
sns.set_style('darkgrid')
sns.lineplot(data=df_temp, y='meantp', x ='date')
plt.show()

显示 32 年日平均气温的时间序列图。图片由作者提供。

如前所述，获得的图表过于密集。在下一节中，让我们看看如何处理这个问题。

处理超长时间序列数据的可视化

6 个简单的技巧可用于呈现长时间序列图:

• #1 放大和缩小
• #2 关注重要的事情
• #3 画线
• #4 使用分配
• #5 分组并应用色标
• #6 圈出线

技巧 1:放大和缩小

我们可以创建一个交互式图表，其中的结果可以放大或缩小，以查看更多的细节。这是扩展图表上密集区域的好主意。 Plotly 是一个有用的库，它将帮助我们创建一个交互式图表。

从我们拥有的数据框架中，我们可以直接用一行代码绘制一个简单的交互式时间序列图。

px.line(df_temp, x='date', y='meantp')

瞧啊。！

使用 Plotly 的带有放大功能的时间序列图。图片由作者提供。

从结果中，我们可以看到整体数据，同时能够放大我们想要扩展的区域。

诀窍 2:关注重要的事情

如果需要注意一些值，用标记突出显示数据点可能是一个很好的解决方案。向交互式绘图添加散点有利于标记有趣或关键的数据点，并放大以查看更多细节。

现在让我们在之前的互动情节中加入散点。例如，我们将分别关注高于和低于 20.5°C 和-5°C 的平均温度。

df_dot = df_temp[(df_temp['meantp']>=20.5)|(df_temp['meantp']<=-5)]fig = px.line(df_temp, x='date', y='meantp')
fig.add_trace(go.Scatter(x =df_dot.date, y=df_dot.meantp,
                         mode='markers',
                         marker=dict(color='red', size=6)))
fig.update_layout(showlegend=False)

使用 Plotly 的带有标记和放大功能的时间序列图。图片由作者提供。

诀窍 3:画线

与前面的技术一样，如果需要关注某些区域，画线可以分隔特定的数据值。例如，我将添加两条线来分隔平均温度高于和低于 20.5°C 和-5°C 的一天。

fig = px.line(df_temp, x='date', y='meantp')fig.add_hline(y=20, line_width=1.5,
              line_dash='dash', line_color='red')
fig.add_hline(y=-5, line_width=1.5,
              line_dash='dash', line_color='red')
fig.update_layout(showlegend=False)

使用 Plotly 的带线条和放大功能的时间序列图。图片由作者提供。

从结果来看，我们可以把注意力集中在线上或线下的数据点上。

诀窍 4:使用分销

箱线图是一种展示数据通过其四分位数分布的方法。箱线图上的信息显示了局部性、分布和偏斜度。该图也有助于区分异常值，即从其他观察中显著突出的数据点。

因为数据框架已经准备好了，我们可以只用一行代码直接绘制盒状图。

px.box(df_temp, x='month_year', y='meantp')

使用 Plotly 显示带有放大功能的数据分布的箱线图。图片由作者提供。

诀窍 5:分组并应用色阶

基本上，这种方法将时间序列图转换成热图。结果将显示月平均气温，我们可以使用色标来比较数据的大小。

为了方便绘图，需要将数据帧转换成二维。首先，让我们按年份和月份对数据框进行分组。

df_mean = df_temp.groupby(['year','month']).mean().reset_index()
df_mean.head()

解散堆叠数据框

df_cross = df_mean.set_index(['year','month'])['meantp'].unstack()
df_cross

使用 Plotly 只需一行代码即可绘制热图。

px.imshow(df_cross, height=700, aspect='auto',
          color_continuous_scale='viridis')

交互式热图显示了月平均气温。图片由作者提供。

诀窍 6:圈出这条线

当可视化时间序列数据时，通常会想到随着时间推移而移动的连续线条。对了，我们可以换个角度。这些线可以绘制成圆形图形，就像在时钟上移动它们一样。在这种情况下，雷达图可能是一个不错的选择。

理论上，雷达图是一种用于比较相同类别数据的可视化工具。我们可以应用这个概念，在圆圈周围绘制月份，以比较一年中同一时间的数据值。

准备一份月份、年份和颜色的列表，用于下一步。

months = [str(i) for i in list(set(df_mean.month))] + ['1']
years = list(set(df_mean.year))pal = list(sns.color_palette(palette='viridis',
                             n_colors=len(years)).as_hex())

使用 for 循环函数在雷达图上绘制线条。

fig = go.Figure()
for i,c in zip(years,pal):
    df = df_mean[df_mean['year']==i]
    val = list(df.meantp)*2
    fig.add_trace(go.Scatterpolar(r=val, theta=months,
                                  name=i, marker=dict(color=c)))
fig.update_layout(height=800)

创建交互式雷达图可以过滤结果，将光标悬停在数据点上可以显示信息。

交互式雷达图显示了月平均气温。图片由作者提供。

摘要

时间序列图是一个有用的图表，可以提取有见地的信息，如趋势或季节影响。但是，用简单的时间序列图显示超长时间序列数据会由于重叠区域而导致图表混乱。

本文展示了绘制长时间序列数据的 6 种可视化思想。我们可以通过使用交互功能和改变视角来使结果对读者友好。此外，一些方法也有助于关注重要的数据点。

最后，这些方法只是一些想法。我确信还有其他的可视化方法可以用来解决这个问题。如果有什么建议，欢迎随时留下评论。

感谢阅读。

以下是您可能会感兴趣的其他数据可视化文章:

• 8 用 Python 处理多个时序数据的可视化(链接)
• 用 Python 实现的 9 种可视化比条形图更引人注目(链接
• 9 用 Python 可视化显示比例，而不是饼状图(链接)
• 用 Python ( 链接)最大化聚类散点图

关于数据集

都柏林机场每日数据检索自 www.met.ie ，版权Metéireann。该数据集在知识共享署名 4.0 国际版下发布( CC BY 4.0 )。来源声明:Metéire ann 对数据中的任何错误或遗漏、其可用性或因其使用而产生的任何损失或损害不承担任何责任。

参考

维基媒体基金会。(2022 年 9 月 23 日)。时间序列。维基百科。于 2022 年 9 月 29 日从 https://en.wikipedia.org/wiki/Time_series 检索

都柏林机场每日数据。Data.Gov.IE。(未注明)。于 2022 年 9 月 29 日从 https://data.gov.ie/dataset/dublin-airport-daily-data?检索到 package_type=dataset

机器学*算法的 6 种特征编码方式

原文：https://towardsdatascience.com/6-ways-to-encode-features-for-machine-learning-algorithms-21593f6238b0

将分类变量编码成数字

照片由波普&斑马在挡泥板上拍摄

机器学*算法需要能够理解它接收的数据。例如，“小”、“中”、“大”等类别需要转换成数字。为了解决这个问题，我们可以将它们转换成数字标签，其中“1”代表小号，“2”代表中号，“3”代表大号。

但这真的是最好的方法吗？

将分类变量编码成数字的方法有很多，每种方法都有自己的优缺点。

为了发现它们，我们将看到以下编码分类变量的方法:

1. 独热/虚拟编码
2. 标签/序数编码
3. 目标编码
4. 频率/计数编码
5. 二进制编码
6. 特征散列

我们将用一个非常简单的数据框架来说明这些概念:一个 NBA 顶级球员的玩具数据集，以及他们在过去比赛中通过罚球获得的分数。

说明特征编码概念的玩具数据集(图片由作者提供)

我还推荐使用这个 python 库将分类变量编码成数字:

pip install category_encoders

在进一步挖掘之前，我们需要澄清一些概念:

• 名义变量是没有固有顺序的变量。它们只是可以相互区分的类别。
• 序数变量有一个固有的顺序。它们可以从最高到最低排列，反之亦然。
• 无监督 编码方法不利用目标变量对分类变量进行编码(例如，用一个公式对球员姓名进行编码，该公式计算他们得分)。
• 监督编码方法使用目标变量对分类变量进行编码。
• 分类变量的“基数”代表该变量所代表的类别数。
• 当一个变量用于训练但在推理时不可用时，目标泄漏发生。

独热/虚拟编码

在一键编码中，分类数据被表示为 0 和 1 的向量。这是通过为每个类别使用单独的虚拟变量来实现的，如果观察值属于该类别，则将虚拟变量的值设置为 1，否则设置为 0。

例如，如果有三个类别，每个类别可以表示为一个零向量，在对应于该类别的位置有一个 1。

from category_encoder import OneHotEncoder
OneHotEncoder(cols=['player']).fit(df).transform(df)

玩具数据集上的一键编码(图片由作者提供)

标签/序数编码

这可能是为机器学*算法编码特征的最简单的方式。在这种方法中，分类数据被转换成数字数据。每个类别都有一个数值。

通过我们的玩具数据集，我们可以随机给玩家分配数字，比如斯蒂芬·库里“1”，安东尼·爱德华兹“2”，杜灿·罗宾逊“3”。

但是如果我们需要对序数变量进行编码呢？

在这种情况下，我们可以为每个玩家手动定义映射。假设我们考虑一个订单，如斯蒂芬·库里

from category_encoder import OrdinalEncodermapping = [{'col': 'player', 'mapping': {"Stephen Curry": 1,  "Duncan Robinson": 2, "Anthony Edwards": 3}}]OrdinalEncoder(cols=['player'], mapping=mapping).fit(df).transform(df)

玩具数据集上的标签编码(图片由作者提供)

目标编码

目标编码是一种通过使用目标值对特征的分类值进行编码的技术。这种技术背后的思想是，如果特征是目标的良好预测器，那么它的值应该更接*目标。

• 目标均值编码:我们用目标值的均值替换类别。这种方法通常与平滑一起使用，以避免目标泄漏。
• 留一编码:这种方法与目标均值编码非常相似，但不同之处在于，在留一编码中，我们取除了我们要预测的样本之外的所有样本的目标值的均值。

例如，留一编码如下所示:

from category_encoder import TargetEncoder
TargetEncoder(cols=['player'], smoothing=1.0).fit(df, df['point']).transform(df)from category_encoder import LeaveOneOutEncoder
LeaveOneOutEncoder(cols=['player']).fit(df, df['point']).transform(df)

玩具数据集上的目标均值编码(图片由作者提供)

频率/计数编码

计数编码是一种使用类别计数来表示分类数据的方法。频率编码只是计数编码的标准化版本。

from category_encoder import CountEncoder
CountEncoder(cols=['player']).fit(df).transform(df)

玩具数据集上的计数编码(图片由作者提供)

from category_encoder import CountEncoder
CountEncoder(cols=['player'], normalize=True).fit(df).transform(df)

玩具数据集上的频率编码(图片由作者提供)

二进制编码

二进制编码是一种通过将类别编码为整数，然后将其转换为二进制代码，从而将分类数据转换为数字数据的技术。

from category_encoder import BinaryEncoder
BinaryEncoder(cols=['player']).fit(df).transform(df)

玩具数据集上的二进制编码(图片由作者提供)

特征散列

特征散列是一种使用固定大小的数组在高维空间中表示数据的方式。这是通过在散列函数的帮助下对分类变量进行编码来实现的。

from category_encoder import HashingEncoder
HashingEncoder(cols=['player']).fit(df).transform(df)

玩具数据集上的特征散列(图片由作者提供)

结论

那么，你应该用哪一个呢？

这取决于数据集、模型和您试图优化的性能指标。一般来说，一键编码是名义变量最常用的方法。它易于理解和实现，并且适用于大多数机器学*模型。为了对抗维数灾难，二进制编码可能是一个好的选择，因为它在编码分类变量时创建的列更少。

如果分类变量的顺序很重要，序数编码是一个很好的选择。例如，如果我们预测一所房子的价格，标签“小”、“中”和“大”将意味着小房子比中房子便宜，中房子比大房子便宜。标签很容易反转，不会增加数据的维度。

另一方面，目标编码是受监督的编码器，其捕获关于标签和潜在预测特征的信息。这种编码器不会增加特征空间的维数，但是会导致过拟合，并且容易出现目标泄漏。

频率和计数编码器也是监督方法，不会增加特征空间的维度。然而，这些方法只能在计数引用目标变量时使用，否则，所有具有相似基数的类别都将被同样计数。

当基数非常高时，特性散列是处理分类变量的好方法，因为它计算速度快，并且在添加类别时大小不会增长。

为了更深入地研究这个主题，我建议阅读以下有趣的文章:

• 哈希技巧

https://booking.ai/dont-be-tricked-by-the-hashing-trick-192a6aae3087

• 光谱编码

好奇想了解更多关于 Anthony 的工作和项目吗？在中、 LinkedIn 、 Twitter 上关注他。

需要技术写手？将您的请求发送到https://amigo CCI . io。

免费学*的 7 个最佳数据科学 YouTubers 视频

原文：https://towardsdatascience.com/7-best-data-science-youtubers-to-watch-for-free-learning-610ecc5ee847

查看这些创作者，了解数据科学学*的专家见解和实践示例

卡罗丽娜·格拉博斯基摄于 Pexels

数据科学是一个快速发展的领域，它结合了计算机科学、统计学和领域专业知识的元素，从数据中提取见解和知识。

有许多资源可以帮助个人学*数据科学，包括在线课程、教科书和博客。

学*数据科学的一个特别有用的资源是 YouTube，它有来自该领域专家的大量内容。

在本文中，我们将探索七个值得观看的最佳数据科学 YouTubers，每个人都提供了关于该领域的独特视角，并为学*者提供了有价值的见解和示例。

1.布兰登·福尔茨

Brandon Foltz 是一名数据科学家兼讲师，从事数据科学教学已经超过八年。

他的 YouTube 频道 Google Developers 提供了各种关于数据科学和机器学*的内容，包括教程、讲座和演示。

Foltz 的内容面向初学者和更高级的学*者，他涵盖了广泛的主题，包括数据可视化、机器学*算法和大数据技术。

福尔茨的内容的一个关键优势是他能够以清晰简洁的方式解释复杂的概念。

例如，在他的机器学*算法系列中，他将每个算法分解为关键组件，并以易于学*者理解的方式解释其工作原理。

他还提供了大量的例子和代码演示，以帮助学*者了解如何在实践中实现这些算法。

推荐视频:

• 《统计学 101:新手回归》
• 《统计学 101:建模方法》
• 《统计学 101:多元回归》

2.Sentdex

Sentdex 是一名数据科学家和软件开发人员，他运营着一个专注于机器学*和数据科学的 YouTube 频道。

他的内容面向初学者，涵盖了广泛的主题，包括数据可视化、机器学*和自然语言处理。

Sentdex 的方法是动手和实用的，重点是使用真实世界的例子和代码演示来说明关键概念和技术。

Sentdex 内容的突出特点之一是他使用了 Python，这是一种流行的数据科学编程语言。

他详细解释了如何使用 Python 完成数据清理、可视化和机器学*等任务，并提供了大量代码演示来帮助学*者了解如何在实践中实现这些技术。

推荐视频:

• “用 Python 实现视频上的面部识别”
• “用 Python 实现深度学*和神经网络”
• “用 Python 进行数据分析和数据科学”

3.爱德华卡。

爱德华卡！是一家数据科学和机器学*教育公司，运营着一个 YouTube 频道，提供关于这些主题的各种内容。

它们的内容面向初学者，涵盖了广泛的主题，包括数据可视化、机器学*和自然语言处理。

爱德华卡。的方法是动手和实用的，侧重于使用真实世界的例子和代码演示来说明关键概念和技术。

Edureka 的突出特点之一！的内容是使用交互式测验和练*来帮助学*者测试他们的理解和应用他们所学的知识。

例如，在他们的机器学*系列中，他们包括关于偏差和方差等关键概念的测验，以及要求学*者使用 Python 实现机器学*算法的练*。

这种互动方法有助于吸引学*者，并帮助他们更好地记住材料。

推荐视频:

• “2023 年需要学*的十大技术
• 《大数据初学者教程》
• “基于 Python 的 K-Means 聚类模型”

4.数据学校

数据学校是一个 YouTube 频道，由凯文·马卡姆运营，他是一名数据科学家和讲师，在该领域拥有超过 10 年的经验。

他的内容面向初学者，涵盖了广泛的主题，包括数据可视化、机器学*和自然语言处理。

马卡姆的方法是动手和实用的，侧重于使用真实世界的例子和代码演示来说明关键的概念和技术。

Data School 内容的突出特点之一是使用交互式练*和挑战来帮助学*者应用他们所学的知识。

例如，在他的机器学*系列中，马卡姆包括了要求学*者使用 Python 构建和评估机器学*模型的挑战。

推荐视频:

• “什么是机器学*，它是如何工作的”
• 《Scikit 入门-学*》
• “如何找到最佳模型参数”

5.代码基础

CodeBasics 是一个由数据科学家和软件开发人员团队运营的 YouTube 频道，他们创建各种主题的内容，包括数据科学、机器学*和 Python 编程。

他们的内容面向初学者，涵盖了广泛的主题，包括数据可视化、机器学*算法和自然语言处理。

CodeBasics 的方法是动手和实用的，重点是使用真实世界的例子和代码演示来说明关键的概念和技术。

CodeBasics 内容的突出特点之一是使用清晰简洁的解释来帮助学*者理解复杂的概念。

他们还提供了大量的代码演示，帮助学*者了解如何在实践中实现这些技术。

此外，它们包括交互式练*和挑战，以帮助学*者应用他们所学的知识。

推荐视频:

• “成为数据科学家的 3 项最重要技能”
• “数据科学的数学&统计学”
• 《初学数据科学》

6.科里·斯查费

科里·斯查费是一名软件开发人员兼讲师，他经营着一个专注于数据科学和机器学*的 YouTube 频道。

他的内容面向初学者，涵盖了广泛的主题，包括数据可视化、机器学*算法和自然语言处理。

斯查费的方法是动手和实用的，侧重于使用真实世界的例子和代码演示来说明关键的概念和技术。

斯查费的内容的突出特点之一是他使用清晰简洁的解释来帮助学*者理解复杂的概念。

推荐视频:

• 《Python 初学者教程:字符串》
• 《Matplotlib 教程:创作剧情》
• “编写更好代码的 10 个 Python 技巧和窍门”

7.肯·吉

Ken Jee 是一名数据科学家和讲师，他经营着一个专注于数据科学和机器学*的 YouTube 频道。

他的内容面向初学者，涵盖了广泛的主题，包括数据可视化、机器学*算法和自然语言处理。

Jee 的方法是动手和实用的，侧重于使用真实世界的例子和代码演示来说明关键概念和技术。

Jee 的内容的突出特点之一是他使用清晰简洁的解释来帮助学*者理解复杂的概念。

他还提供了大量代码演示来帮助学*者了解如何在实践中实现这些技术。此外，他包括互动练*和挑战，以帮助学*者应用他们所学。

Jee 的内容对于刚开始涉足数据科学领域的初学者特别有用。

他清晰简洁的解释和实际例子使学*者很容易掌握关键概念和技术，他的互动练*和挑战有助于吸引学*者，帮助他们更好地记住材料。

推荐视频:

• “如何从数据分析师成为数据科学家”
• “数据科学正在消亡吗”
• “2023 年我将如何学*数据科学”

结论

这七个数据科学 YouTubers 为对该领域感兴趣的学*者提供了大量有价值的资源。

无论您是刚刚起步，还是希望加深对数据科学的理解，这些渠道都提供了有价值的见解、示例和练*，帮助您学*和应用关键概念和技术。

与 5k+人一起加入我的邮件列表，免费获得《2023 年如何学*数据科学 cheat sheet》

2022 年免费学*的 7 个最佳数据科学 YouTubers

原文：https://towardsdatascience.com/7-best-data-science-youtubers-to-watch-for-free-learning-in-2022-3d8c07ae49a1

他们的视频具有教育性、娱乐性，最重要的是可以免费学*

来自 Pexels 的照片由 Eren Li

数据科学是 2022 年最重要和最受欢迎的技能之一。

如果你想学*数据科学，你很幸运！网上有很多很好的资源，包括 DataCamp、Coursera 和 Udacity。

但是，如果你正在寻找一种更非正式、更有趣的学*体验，Youtube 可能是适合你的地方。

在本帖中，我们将列出 7 个我最喜欢的提供免费学*内容的数据科学 Youtubers。

让我们从我的最爱开始吧！

1.自由代码营

Freecodecamp 是一个超过 800 万人的社区，他们每天一起学*编程。他们从 2015 年开始在 YouTube 上制作视频，目前拥有* 500 万订阅用户。

在他们的视频中，他们涵盖了机器学*、数据可视化、web 开发等主题。

这个频道在数据科学爱好者中如此受欢迎的原因是因为他们的视频非常实用。它们通常提供代码片段和演练，因此您可以跟随它们，边做边学。

如果你正在寻找一个更加互动的学*体验，那么 Freecodecamp 是一个完美的起点。

他们频道上的一些视频包括:

• 数据科学家的机器学*:回归
• 用数据树实现数据可视化
• 从零开始的 Web 开发:HTML、CSS 和 JavaScript 基础

点击这里查看他们的频道:Freecodecamp

2.编码列车

编码列车是丹尼尔·希夫曼创建的 YouTube 频道。五年多来，他一直在制作关于数据科学和编程主题的视频，目前他拥有* 200 万订户。

这个频道在 YouTubers 上如此受欢迎的原因是因为它非常实用。Daniel 经常提供代码片段和演练，因此您可以跟随他，边做边学。

他的视频非常有趣，同时也很有教育意义。如果你正在寻找一种更具互动性的学*体验，那么编码培训是一个很好的起点。

他的频道上的一些视频包括:

• 如何用 Python 制作一个基本的神经网络
• 如何使用 TensorFlow 进行机器学*和深度学*
• JavaScript 数据结构和算法介绍

点击这里查看他的频道:编码列车

3.数据科学 Jojo

数据科学 Jojo 是一个数据科学频道，拥有超过 80，000 名订户。他们提供关于机器学*、回归分析、SQL 和 Tableau 等数据科学主题的免费在线课程和视频教程。他的视频很容易理解，包括许多实用的技巧和例子。

Data Science Dojo 是 YouTube 上最受欢迎的数据科学频道之一的原因是因为他们展示材料的独特而迷人的方式。他们经常使用类比和故事来解释复杂的数据科学概念，使它们更容易理解。

他们频道上的一些视频包括:

• 表格中的回归分析
• 面向初学者的数据科学:面向数据科学的 Python 介绍
• 使用 scikit-learn 的机器学*:回归和分类

点击这里查看他们的频道:数据科学道场

4.华盛顿大学

如果你正在 YouTube 上寻找一种更学术的数据科学教育方法，那么看看华盛顿大学就知道了。这个频道有* 150，000 名订户，并提供由一些最好的教授讲授的免费数据科学课程。

这些视频涉及机器学*、数据挖掘和大数据等主题。他们还有一系列关于“Python 用于数据科学”的视频，如果你想学* Python，这是一个很好的资源。如果你有兴趣接受数据科学的正规教育，华盛顿大学是一个很好的起点。

他们频道上的一些视频包括:

• 使用 Weka 进行数据挖掘
• 使用 Hadoop 和 Spark 处理大数据
• 用于数据科学的 Python，第一部分:Python 编程简介

点击这里查看他们的频道:UWU

5.StatQuest

StatQuest 是由 Josh Starmer 创建的 YouTube 频道。他是一名数据科学家，专门研究机器学*和深度学*。他的视频信息量很大，他经常提供你在其他地方找不到的见解。

你应该看 StatQuest 的原因是因为 Josh 说话的风格非常清晰。他说得很慢，吐字清晰，这样更容易理解他在说什么。

他们频道上的一些视频包括:

• 偏差与方差权衡
• 基于支持向量机的线性分类
• 时间序列预测的神经网络

点击这里查看他的频道:StatQuest

6.科里·谢弗

Corey Shafer 是一名数据科学家和软件开发人员。他的频道有超过 800，000 名订户，他们观看他的视频是因为他们有趣的内容以及科里平易*人的个性。

你应该观看这个频道的原因是因为它专注于现实世界的问题，如使用机器学*模型预测比特币的价格，或创建一个识别动物的图像识别系统。

Corey 还有一个名为“从零开始的数据科学”的系列，以非常实用的方式带您了解数据科学的基础知识。

他的频道上的一些视频包括:

• 用机器学*预测比特币价格
• 使用 TensorFlow 构建图像识别系统
• 从零开始的数据科学:使用 K *邻(KNN)算法的机器学*

点击这里查看他的频道:科里·谢弗

7.Sentdex

Sentdex 是由哈里森·金斯利创建的 YouTube 频道。他有超过 100 万的订户，他们观看他的视频是因为视频内容丰富，以及哈里森平易*人的个性。

Sentdex 专注于 python 编程、机器学*和数据可视化主题，如 python 中的 matplotlib 绘图或如何将 seaborn 库与 Python 结合使用。

您应该观看这个频道的原因是因为它专注于 Python 编程、机器学*和数据可视化主题。哈里森说话的风格非常清晰，他让难懂的概念变得容易理解。

他的频道上的一些视频包括:

• 用于数据科学的 Python(第 0 部分):简介
• 用 Python 进行机器学*(第 0 部分):简介
• 使用 Python 的 Seaborn 库(第 0 部分):简介

点击这里查看他们的频道:Sentdex

结论

如果你想了解更多关于数据科学的知识，那么这些 YouTube 频道将是一个很好的起点。网上并不缺乏可用的资源，但找到合适的资源有时会很困难。不用说，还有很多其他的，所以不要被这个列表所限制。

与 5k 以上的人一起加入我的电子邮件列表，免费获得“完整的 Python for Data Science 备忘单手册”

开始深度学*项目的 7 篇最佳研究论文

原文：https://towardsdatascience.com/7-best-research-papers-to-read-to-get-started-with-deep-learning-projects-59e11f7b9c32

七篇最好的研究论文经受住了时间的考验，将帮助你创造惊人的项目

照片由UX在 Unsplash 上拍摄

研究论文是了解人工智能(AI)世界中引入和发现的几种新方法的不可或缺的一部分。所有的数据科学家和研究人员聚集在一个公共平台上，分享他们细致的工作和知识，以帮助蓬勃发展的人工智能社区达到更高的高度。

每天都有大量由技术人员提出的研究和创新，了解最新技术的整体体验可能会让人不知所措。对于一个正试图全神贯注于深度学*世界的初学者来说尤其如此。可能很难找出哪些研究论文是开发新项目和获得对主题的直观理解的最佳起点。

在本文中，我们将看看开发人员和数据科学爱好者必读的七篇最佳研究论文和数据科学研究论文。这些研究论文经受住了时间的考验，并为许多已经实现或未来将要实现的实现提供了基准。

对于深度学*来说，拥有自己的设备或系统来计算复杂的问题总是最好的。在继续阅读本文之前，我建议从下面提供的文章链接中寻找一些在众多价格范围内用于深度学*的最佳 PC 版本。

[## 在各种预算范围内，最适合深度学*的电脑

towardsdatascience.com](/best-pc-builds-for-deep-learning-in-every-budget-ranges-3e83d1351a8)

深度学*研究论文入门:

照片由 UX 印尼在 Unsplash

深度学*的领域是巨大的。有几个研究论文可供选择，因为每个介绍的作品都介绍了一个对数据科学和人工智能社区有用的新概念或方法。在文章的这一部分，我们将探讨七篇最有益和最有趣的研究论文，它们经受住了时间的考验。

1.ResNet:

研究论文: 用于图像识别的深度残差学*

作者:何、、、任、

总结:

数据科学家使用几种迁移学*模型来实现特定任务的最佳结果。AlexNet 模型是第一个在 2012 年赢得图像处理挑战的模型，从那以后，像 VGG-16 这样的迁移学*模型一直是深度学*中最有影响力的部分。

在本文中，我们将把重点放在 ResNet 体系结构上，因为 ResNet 网络比它的同类网络实现了更小的改进。考虑 ResNet 网络的另一个重要原因是，根据您计划包括的残差块的类型和数量，它有许多变化。部分 ResNet 结构有 ResNet-18 、 ResNet-34 、 ResNet-50 、 ResNet-101 等。

ResNet 体系结构利用了残余块。这个概念是非常重要的，因为它解决了其他浅层网络的一些问题，这些浅层网络受到消失或爆炸梯度问题的困扰。剩余块通过计算模型中当前和更深层的前一个块的输出之和。

意义(为什么要读这篇论文？):

迁移学*是深度学*的一个主要部分。我们可以利用从一个模型中学*到的信息，并利用这些数据在它的基础上构建另一个定制模型来执行大量的任务。即使不构建定制架构，我们也可以使用原始迁移学*模型来执行特定任务。使用迁移学*模型可以避免每次都需要从头开始创建和构建自己的模型。

2.YOLO:

茱莉亚·佐洛托娃在 Unsplash 上的照片

研究论文: 你只看一次:统一、实时的物体检测

作者:约瑟夫·雷德蒙，桑托什·迪夫瓦拉，罗斯·吉斯克，阿里·法尔哈迪

概要:

物体检测(与人脸识别并列)一直是深度学*模型的一个抓手。自从引入 YOLO 模型以来，我们已经能够通过在模型试图确定的特定重要对象周围创建边界框来解决复杂的对象检测问题。YOLO 网络利用一系列卷积神经网络来学*如何在训练期间实时检测物体。

自 2015 年首次发布以来，YOLO 模型一直在不断改进和发展。我们在每个版本中都对这些方法进行了实质性的改进，比如 YOLO-v2 和 YOLO-v3。在撰写本文时，最新的 YOLO 版本是 YOLO-v6 机制。这些架构中的每一个都在不断改进，以提高目标检测任务的效率。

意义(为什么要读这篇论文？):

计算机视觉是人工智能最受欢迎的分支之一。一个可以解决这些复杂的计算机视觉问题的深度学*模型，例如实时物体检测和人脸识别，具有很高的价值。YOLO 是解决高精度目标检测问题的最佳方法之一。如果观众对掌握计算机视觉的基础感兴趣，我建议观众看看下面提供的指南。

3.U-Net:

研究论文: U-Net:卷积网络用于生物医学图像分割

作者: 奥拉夫·龙内贝格、菲利普·费舍尔和托马斯·布罗克斯

总结:

分割的任务包括将图像的相似部分分类到一个簇中。所有相同的类被分类并分割成一个特定的实体。通过分割图像，可以消除图像的大部分复杂性，从而允许用户对图像处理和分析进行进一步的计算。

一旦对图像进行分割，它就为更有效地解释数据提供了许多可能性。U-Net 网络就是有效执行这项任务的一种模式。包括编码器和解码器型网络的 U-Net 模型架构接受需要分割的输入图像。

根据类别的数量和特定的任务类型，通过网络传输的图像要经过卷积、下采样和最终上采样几个阶段，以满足特定的任务。该网络还利用跳跃连接来避免任何退化问题，并在每次下采样到上采样阶段中执行有用的信息。

意义(为什么要读这篇论文？):

U-Net 是一篇革命性的论文，用于分割不同类型的计算机视觉问题。大量的任务，尤其是在医学图像处理领域，利用了 U-Net 架构。从 U-Net 网络中衍生出了几种变体，对细分项目也很有用。一旦我们有了一个 U-Net 模型来分割特定类型的图像，我们就可以利用该图像进行进一步的分析和计算。

4.批量标准化:

研究论文: 批量归一化:通过减少内部协变量移位加速深度网络训练

作者:谢尔盖·约菲，克里斯蒂安·塞格迪

概要:

在深度学*中，将数据标准化通常是一个好主意。让我们考虑一下 MNIST 数据集。在 MNIST 数据集中，一旦我们以 numpy 数组的形式获得数字 0–9 的灰度图像的值，我们就有了从 0–255 的值范围。将这些数据元素标准化和规范化到 0。和 1。浮动变量。

批量归一化图层执行的操作有些类似，即计算小批量均值和小批量方差来相应地归一化数据。批量标准化层有助于加快训练过程，并降低权重初始化的重要性。这些层也有助于调整模型训练，并稍微克服过度拟合的问题。

意义(为什么要读这篇论文？):

批量规范化层是大多数现代深度学*架构的组成部分。在构建任何类型的复杂神经网络时，批处理规范化层可以被认为是一个高度实用的实体。这些层从其中一层获取输入，并通过标准化数据将其映射到另一层，从而通过减少内部协变量偏移来加速计算。这些批量标准化层对于卷积神经网络特别有用，它们允许每一层更加独立地工作。

5.变压器:

阿瑟尼·托古列夫在 Unsplash 上的照片

研究论文: 关注是你所需要的

作者:

总结:

利用简单的递归神经网络来解决复杂的任务通常会导致高度复杂任务的几个主要问题。两个主要的缺点是爆炸和消失梯度，在较长的数据传输序列中基本信息丢失。长短期记忆(LSTM)模型能够解决 RNNs 的大多数基本问题。通过在序列到序列模型中利用这些 LSTM 网络，我们能够在各种各样的自然语言处理任务上获得非常成功的结果。

变压器网络利用编码器和解码器型结构与注意机制的连接。注意层提供了解码器和编码器之间的互连，允许它访问隐藏状态。这个过程允许模型对特定的实体(例如跨句子的关键字)具有更高的权重。有不同类型的注意机制，如点注意、自我注意和多头注意等。

意义(为什么要读这篇论文？):

变形金刚是一些最好的深度学*工具，对于解决各种自然语言处理任务非常有用。这些转换器能够执行复杂的语言任务，包括从一种语言到另一种语言的机器翻译、问答系统、聊天机器人、文本分类问题等等。变形金刚的可能性是无限的，这篇研究论文为受其启发的所有其他研究论文提供了一个伟大的概念基础平台，例如生成式预训练变形金刚 (GPT)和变形金刚 (BERT)模型的双向编码器表示。

6.生成性对抗网络(GANs):

ArtSpiley 在 Unsplash 上拍摄的照片

研究论文:https://arxiv.org/pdf/1406.2661.pdf

作者: 伊恩·古德菲勒、让·普盖-阿巴迪、迈赫迪·米尔扎、徐炳、大卫·沃德-法利、谢尔吉尔·奥泽尔、亚伦·库维尔、约舒阿·本吉奥

概要:

Ian Goodfellow 和他的团队在 2014 年首次推出的一篇更受欢迎的研究论文是生成敌对网络。这些架构深度学*框架在生成全新数据方面极具影响力。这些对立网络的功能利用了生成器和鉴别器网络，其中两种架构相互竞争以改善整体结果。

生成器尝试生成看起来像真实样本图像的独特数据。另一方面，鉴别器试图检测生成的样本，并将其分类为真或假。这两个网络在一个恒定的连续循环中同时被训练。一旦生成器能够绕过鉴别器检查系统并生成逼真的图像，我们就有了一个完全训练好的生成对抗网络。该模型可以为特定类型的数据从头开始生成唯一的数据。

意义(为什么要读这篇论文？):

生成性对抗网络有多种迭代和变化，如 DCGANs、Cycle GANs、SRGANs、W-GAN 等等。这些架构是当今深度学*领域中生成新数据时最常用的一些元素。随着生成网络现在比以前更受欢迎，等待这个分支的进步是巨大的。强烈建议从下面的研究论文开始，以跟上这些生成原型的持续发展。

7.自动编码器:

研究论文: 自动编码器

作者:

概要:

自动编码器是另一种类型的生成网络，可用于多种应用。自动编码器利用编码器和解码器类型的网络以及潜在的维度空间。自动编码器的编码器级接收输入，该输入可以被网络解释为包含向量的潜在维度空间。这些包含在潜在空间中的向量在本质上是压缩的。

因此，自动编码器对于将特定大小的原始图像压缩到潜在维度空间中的降维任务是有用的。利用这个压缩的潜在维度空间，解码器可以用更小的维度空间重建相同的图像。重建图像类似于原始图像，但是与原始图像相比具有较少的矢量。

意义(为什么要读这篇论文？):

自动编码器有许多应用程序，被数据科学家和深度学*研究人员使用。除了降维应用，正如我们之前讨论的，这些自动编码器对于图像去噪、特征提取和异常检测等任务也很有用。除了上面提到的应用之外，自动编码器的一种变体称为变分自动编码器，与 GANs 类似，对图像生成也很有用。因此，可以肯定地说，这些自动编码器在深度学*领域具有巨大的潜力。

结论:

Firmbee.com 在 Unsplash 上的照片

研究使好奇心正式化了。这是有目的的戳和撬。
— 佐拉·尼尔·赫斯顿

研究和创新是发展和学*不可或缺的支柱。现代研究的质量已经上升到更高的水平。它们中的每一个都包含了大量的知识，可供个人用来启发自己。高水平研究论文的质量对于深度学*来说尤其如此，深度学*涉及大量的研究和时间投入。

在这篇文章中，我们了解了经受住时间考验的七篇最佳研究论文的基本方面。因此，对于所有初学数据的科学家来说，它们是一笔资源丰富的资产，可以让他们了解更多，并进一步探索。我们也理解了这些研究论文的意义以及它们所涵盖的具体概念。在深入研究特定主题的研究论文的数百万个选项之前，我建议检查这些选项，以进一步了解深度学*的主题。

如果你想在我的文章发表后第一时间得到通知，请点击下面的链接订阅邮件推荐。如果你希望支持其他作者和我，请订阅下面的链接。

*https://bharath-k1297.medium.com/membership

如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。

看看我的一些与本文主题相关的文章，你可能也会喜欢阅读！

</7-python-programming-tips-to-improve-your-productivity-a57802f225b6>

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

你应该知道和避免的 7 种代码气味

原文：https://towardsdatascience.com/7-code-smells-you-should-know-about-and-avoid-b1edf066c3a5

#2 使用打印语句进行调试

由 charlesdeluvio 在 Unsplash 拍摄的照片

程序不一定要崩溃才能对其中的问题发出警报:一些其他因素可能会作为一个问题即将出现的严重警告。例如，如果你在房子的某个地方闻到煤气味或烟味，这可能表明你有煤气泄漏或有东西在燃烧。这两种情况都需要在成为重大问题之前进行调查(例如，你的房子爆炸)。

代码气味可以被认为是在你家里闻到煤气或烟味。您的代码不会因为它的存在而停止执行，但是在它失控之前，值得研究一下。这是一个指示性的警告，表明您的代码需要一些关注。

“气味是代码中的某些结构，它表明违反了基本设计原则，并对设计质量产生负面影响”。代码气味通常不是 bugs 它们在技术上并非不正确，也不会妨碍程序的运行。相反，它们指出了设计中的弱点，这些弱点可能会减慢开发速度，或者增加将来出现错误或失败的风险。糟糕的代码气味可能是导致技术债务的因素的指示器。”
-来源 : 维基百科

仅仅是代码气味的存在并不等同于 bug，但是它的气味值得关注，值得研究。所有程序员都会同意，在我们遇到 bug 之前阻止它需要更少的努力和花费更少的时间——消除代码气味是确保这一点的一种方法。

为了减少代码气味的数量，了解它们的样子是很重要的。在本文中，我们将按非时间顺序介绍其中的七个。

#1 使用打印语句进行调试

Print 语句可能是您在编程之旅中学*的第一个内置语句之一(即大多数人的第一个程序是print("Hello World"))。print 语句本身没有什么错误，只是开发人员经常过于依赖它们。

你如何知道自己是否过于依赖打印报表？如果你用它来调试你的代码。

Print 语句很容易实现，因此它在欺骗人们认为这是调试代码的最佳方式方面做得非常好。然而，使用 print 进行调试通常需要您在显示必要的信息以修复代码中的错误之前执行多次程序运行迭代——这需要更长的时间，尤其是当您返回并删除所有这些信息时。

有两种解决方案比使用打印调试更好:1)使用调试器一次运行一行程序，2)使用日志文件记录程序中的大量信息，这些信息可以与以前的运行进行比较。

我更喜欢使用日志文件，这可以通过内置的logging模块在 Python 中轻松完成。

**import** logging logging.basicConfig(
    filename = "log_age.txt", 
    level = logging.DEBUG,
    format = "%(asctime)s - %(levelname)s - %(message)s") logging.debug("This is a log message.") 

#2 重复代码

程序中最常见的代码味道很可能是重复的代码。识别重复代码是如此容易:您所要做的就是考虑在程序的不同部分中，您可以简单地复制和粘贴代码。因此，重复代码可以定义为在多个位置重复的代码。

**print**("What would you like for breakfast?")
breakfast = input()
**print**(f"One {breakfast} coming up")**print**("What would you like for lunch?")
lunch = input()
**print**(f"One {lunch} coming up")**print**("What would you like for dinner?")
dinner = input()
**print**(f"One {dinner} coming up")

表面上，重复代码看起来无害。当必须对代码进行更新或更改时，它就成了一个棘手的问题。更改重复代码的一个副本意味着必须对代码的所有区域进行更改，忘记这样做可能会导致程序中代价高昂且难以检测的错误。

这个问题的解决方案非常简单:对代码进行重复数据删除。通过利用函数或循环的力量，我们可以很容易地让代码在程序中出现一次。

**def** ask_meal(meal_of_the_day:str) -> str: 
    **print**(f"What would you like to eat for {meal_of_the_day}")
    meal = input()
    return f"One {meal} coming up"

meals_of_the_day = ["breakfast", "lunch", "dinner"]**for** meal **in** meals_of_the_day: 
    ask_meal(meal)

有些人将复制发挥到了极致，试图在复制和粘贴代码后的任何时候消除重复。虽然可能有一些程序员支持它，但有时它可能是多余的。复制粘贴代码一次或两次可能不会有问题，但如果出现三次，就创建一个函数或循环来修复它。

#3 神奇的数字

有时我们不得不在代码中使用数字；我们在源代码中使用的一些数字会给其他开发人员带来极大的困惑——如果您将来不得不重新访问这些代码，也会给自己带来困惑。这些数字被称为 幻数 。

“幻数或幻常数这个术语指的是在源代码中直接使用数字的反模式。”

• [ 来源 : 维基百科

幻数被认为是一种代码味道，因为它们没有给出任何关于它们为什么存在的指示——它掩盖了开发人员选择那个特定数字的意图。因此，您的代码可读性更差，您和其他开发人员将来更难更新或更改，并且更容易出现像打字错误这样的细微错误。

考虑以下场景:

**from** sklearn.model_selection **import** train_test_splitX_train, X_test, y_train, y_test = train_test_split(
    X, 
    y, 
    0.3, 
    0.7, 
    25, 
    True, 
    None
)

在上面的代码中，我们从 Scikit-learn 导入了train_test_split函数，并用一些似乎没有明确含义的超参数实例化了它。

使代码可读性更好的一个解决方案是添加信息性的注释，告诉我们为什么选择这个特定的数字。

**from** sklearn.model_selection **import** train_test_splitX_train, X_test, y_train, y_test = train_test_split(
    X # features array, 
    y # labels, 
    0.3 # test size, 
    0.7 # train size, 
    25 # random state, 
    True # shuffle, 
    None # stratify
)

解决这种代码味道的一个更有用的方法是使用一个 常量 。常数是每次执行程序时保持不变的有价值的数据。[我不确定其他语言，但是]在 Python 中，我们通常用大写字母来写常量，以告知他人(并提醒自己)它们的值在初始赋值后不应该改变。

您经常会看到在配置中定义的常量，或者在脚本开始时作为全局变量定义的常量。

**from** sklearn.model_selection **import** train_test_splitTEST_SIZE = 0.3
TRAIN_SIZE = 0.7
RANDOM_STATE = 25
SHUFFLE = True
STRATIFY = NoneX_train, X_test, y_train, y_test = train_test_split(
    X, 
    y, 
    TEST_SIZE, 
    TRAIN_SIZE, 
    RANDOM_STATE, 
    SHUFFLE, 
    STRATIFY
)

这有多大的可读性？

使用不同的常数而不是用一个常数来解决两个问题是很重要的。这样做的原因是，它们可以在将来独立更改，这通常会减少很多麻烦。

#4 保留注释掉的代码

当代码中的注释提供信息时，它无疑被视为一种好的实践。有时，我们甚至会暂时注释掉代码，看看在没有我们删除的代码行的情况下，剩余的代码是如何运行的——可能是在我们调试的时候——这本身也没有什么错。

当程序员变得懒惰时，它就会成为一个问题。这种懒惰的一个例子是注释掉代码，但是保留注释掉的代码。

就地注释掉代码的原因是代码味道，因为它是不明确的。其他程序员会将注释掉的代码视为一个完全的谜，并且不知道在什么条件下应该将它重新放入程序中。

walk()
# run()
sprint()
stop()

为什么run()被注释掉了？什么时候可以取消对run()的注释？如果不需要，那么删除代码。

#5 死代码

为了节省计算和内存，必须处理程序中的所有死代码。

**“死代码是一个程序的源代码中的一部分，它被执行，但其结果永远不会在任何其他计算中使用。”

• [ 来源 : 维基百科**

在你的程序中有死代码是非常误导人的。其他程序员阅读您的代码时可能不会马上理解，并认为它是代码的一个工作部分，而实际上，它除了浪费空间之外什么也没做。

# Code source: [https://twitter.com/python_engineer/status/1510165975253069824?s=20&t=VsOWz55ZILPXCz6NMgJtEg](https://twitter.com/python_engineer/status/1510165975253069824?s=20&t=VsOWz55ZILPXCz6NMgJtEg)**class** TodoItem: 
    **def** __init__(self, state=None):
        self.state = state if state else -1 

    **def** __str__(self): 
        if self.state == -1: 
            return "UNDEFINED"
        elif self.state == 0: 
            return "UNSET" 
        else: 
            return "SET"

乍一看，这段代码看起来不错，但是其中有一个 bug:这段代码永远不能被设置为 0，因为在self.state变量中的求值会将 0 设置为False。因此，将状态设置为 0 将返回UNDEFINED而不是UNSET。

class TodoItem: 
    def __init__(self, state=None):
        self.state = state if state is not None else -1 

    def __str__(self): 
        if self.state == -1: 
            return "UNDEFINED"
        elif self.state == 0: 
            return "UNSET" 
        else: 
            return "SET"

注 :见本 视频 由 Python 工程师得到完整解释。

#6 存储带数字后缀的变量

我已经被这种代码气味困扰过几次——直到今天我还没有完全摆脱它；有时，我们可能需要跟踪同一类型数据的几个实例。在这种情况下，重用一个名字并给它添加一个后缀，使它存储在程序中的一个不同的名称空间中，这是非常诱人的。

person_1 = "John" 
person_2 = "Doe"
person_3 = "Michael

这种代码味道之所以是代码味道，是因为后缀不能很好地描述每个变量中包含的内容或变量之间的差异。它也没有给出任何关于程序中有多少变量的指示——你不想搜索 1000 多行代码来确保没有其他的数字。

更好的解决方案是:

people = ["John", "Doe", "Michael"] 

不要把这当作改变所有以数字结尾的变量的指令:一些变量应该以数字结尾，尤其是当数字是你存储的数据的独特名称的一部分时。

#7 不必要的类(特定于 Python)

像 Java 这样的编程语言使用类来组织程序中的代码。Python 使用模块。因此，试图像在 Java 中一样使用 Python 中的类(来组织代码)是不会有效的。

Python 中的代码不需要存在于类中，有时，使用类可能是多余的。

以这门课为例:

**class** Human:
    **def** __init__(self, name: str): 
        self.name = name **def** introduction(self): 
        return f"Hi, my name is {self.name}"person = Human("Kurtis")
print(person.introduction()) """
Hi, my name is Kurtis
"""

为什么这个类不需要成为一个类的主要决定因素是它只有一个函数。根据经验，如果一个类只包含一个方法或者只包含静态方法，那么它不一定是 Python 中的类。不如写个函数来代替。

要了解这个概念的更多信息，请查看 Jack Diederich 在 PyCon 2012 上关于为什么我们应该"停止编写类"的演讲。

感谢阅读。

联系我:
LinkedIn
Twitter
insta gram

如果你喜欢阅读这样的故事，并希望支持我的写作，可以考虑成为一名灵媒。每月支付 5 美元，你就可以无限制地阅读媒体上的故事。如果你使用我的注册链接，我会收到一小笔佣金。

已经是会员了？订阅在我发布时得到通知。

**https://kurtispykes.medium.com/subscribe **

BigQuery 的 7 个成本优化实践

原文：https://towardsdatascience.com/7-cost-optimization-practices-for-bigquery-6f776582e62d

在需要的时候花钱

在 Unsplash 上由 micheile dot com 拍摄的照片

云的好处之一是其无限的可扩展性。数据存储、计算能力和网络都可以在大多数云计算基础设施中扩展，如 GCP 和 AWS。然而，可扩展性会导致云浪费—过度配置资源、非最佳数据存储、过多的闲置资源等。2021 年，公司可能会浪费高达 260 亿美元，这是有史以来最高的云浪费金额。

因此，在本文中，让我们看看 BigQuery 的一些成本优化实践——一个无服务器和多云化的数据仓库。根据谷歌的说法，与其他基于云的平台相比，BigQuery 已经是一个具有成本效益的数据仓库。但是我们仍然可以做很多事情来保持更低的成本。

如果您想知道如何监控 BigQuery 的成本，您可以查看我的另一篇文章 我如何为成本节约和容量规划构建实时 BigQuery 管道 。

1.选择正确的定价模式

BigQuery 提供了几种对成本有直接影响的计算定价模型。总的来说，BigQuery 提供了两种定价模型，并增加了一些内容。

按需定价:您为每个查询处理的字节数付费(每 TB 5 美元)。您可以通过减少查询处理的字节数来直接降低成本。

统一费率定价:您需要为专用的查询处理能力付费，以时间段来衡量(2000 美元/月/100 个时间段)。您可以通过使用更少的槽让您的查询更有效地运行来降低成本。

在选择定价模式方面，Google 给出了以下建议:

• 如果您刚开始使用少量数据，按需定价模式对您很有好处。您只需为您消费的内容付费，如果您不进行查询，这些插槽的容量将为零。如果您计划了具有可预测的扫描数据量的工作流(例如，在查询中使用重新加载窗口)，这种模式也是首选，因为您确切知道您将支付多少费用。
• 随着数据的增长，成本也会相应增加。如果您开始有更繁重的工作流或临时请求，您可能希望切换到弹性费率定价模式。它确保您不会对未经优化的即席查询感到惊讶。如果您的 BigQuery 项目对整个组织开放，包括不一定了解所有这些 SQL 最佳实践的人，这种情况就会发生。
• 按需定价模式和弹性费率定价模式并不相互排斥。BigQuery 引入了 Flex Slots ,它为短期预留了插槽。您可以将它用于需要额外容量的周期性工作负载，或者需要在短时间内处理大量数据的工作负载。(例如，由于某些用户活动，需要每月运行一次的报告管道，在国庆节期间，等等)。

很难说什么时候是转换到另一种定价模式的最佳时机。但是如果你觉得你支付的太多了(例如，超过$ 10K/月)，你可以随时为新的定价模式做一个概念验证，如果它不符合你的期望，就切换回来。

2.为短期表设置表过期时间

BigQuery 的存储有两种价格:

• 0.02 美元/GB 用于活动存储，包括在过去 90 天内修改过的表或表分区。
• 对于过去 90 天内未修改的长期存储，每 GB 0.01 美元。

您可以通过设置表的到期时间或数据集的默认表到期时间以及分区表的分区到期时间来控制存储成本。这在以下几种情况下很有用:

• 您有许多每日快照表，并且只想保留最* X 天的数据。然后，您可以将每个新快照表的到期时间设置为 X 天。
• 您有一个仅包含临时数据的操场数据集。然后，您可以将整个数据集的默认过期时间设置为 X 天。
• 您有一个按天进行分区的表，并且您只想要最* X 天的数据。然后，您可以设置分区过期时间。

BigQuery 中的表过期

这种简单的做法会自动清理空闲的表并节省存储成本。

3.分区和集群

分区您的数据可以帮助降低处理查询的成本并提高性能。您可以使用摄取时间或任何时间戳和日期列对表进行分区，并选择每天、每小时、每月和每年作为粒度。对于巨大的表，建议应用必需的分区过滤器，这样用户将被迫减少扫描的数据量。

例如，您对一个包含过去 12 个月的每日天气数据的weather表进行分区。分区字段为date，粒度为月。当你搜索2022–08–01的天气时，BigQuery 只扫描august分区中的数据。您只需为该分区中的数据付费，而不是整个表。

表分区(由作者创建)

最重要的是，您可以基于最多四列对您的表进行聚类。BigQuery 根据指定的列顺序对每个分区中的数据进行排序。当您的查询搜索这些列时，BigQuery 只扫描分区的相关块。

例如，我们向weather表添加 3 个聚类字段:date、country和city。当我搜索德国八月份的天气时，BigQuery 只会扫描一个分区和有限的可以找到德国数据的区块。

表聚类(由作者创建)

一个专业建议是使用更可能被筛选的列作为聚类字段。此外，划分字段也可以是聚类字段。在weather表中，date按月粒度进行分区，并按天级别在每个分区中排序。它将提高查询性能并降低成本。

4.使用增量表更新

当您构建数据管道时，一个重要的步骤是将数据接收到 BigQuery 中。如果表很小，您可以定期完全重新加载表。但是如果表很大，每次进行完全刷新是非常昂贵和耗时的，通常的做法是执行增量表更新。

例如，源表每天接收新记录，而每日计划查询捕获源表中的更改，并相应地更新目标表。执行完全刷新显然是浪费金钱，因为旧数据不会改变。

一个解决方案是定义一个重载窗口。为了不遗漏源表中的任何数据，通常重载窗口大于源表的更新频率。假设我们有一个 3 天的重装窗口。每天，该查询只从源表中选择最* 3 天的数据，并将其存储在 CTE 或临时表中。稍后，查询可以使用MERGE语句来更新目标表。

本例中的MERGE语句意味着‘如果临时表包含目标表中不存在的带有新date的记录，则插入该记录，否则更新目标表。’在这种情况下，“更新目标表”实际上不会改变任何东西，它只是用相同的数据覆盖它。

增量更新(由作者创建)

拥有一个重新加载窗口可以大大减少要扫描的数据量。您可以在数据管道中利用这种技术。

5.避免选择*只要你能+限制 100 是一个幻想

BigQuery 以列格式存储数据，这意味着它单独存储每一列。这也意味着SELECT *是一种非常昂贵的数据查询方式。一个简单的技巧是只选择您需要的列。您可以随时使用SCHEMA和PREVIEW选项卡来免费查看数据。

还要注意，应用限制条款并不能节省一分钱。如果希望扫描较少的行，则应用分区筛选器。

有/没有限制的查询(由作者创建)

6.INT64 列上的 ORDER BY 或 JOIN

在 BigQuery 中，使用INT64而不是STRING数据类型来连接列更便宜也更有效。这里有一篇关于列类型如何影响数据仓库中连接速度的有趣文章？

7.使用实体化视图

要回答分析问题，您需要一个组合了来自不同表的大量数据的复杂查询。一些流行的问题可以被问很多次，多次运行相同的复杂查询是浪费金钱。BigQuery 提供了物化视图,允许您在聚合事实表中汇总数据。它是一个预先计算的视图，定期缓存查询结果以提高性能和效率。

物化视图不是从基表中检索数据，而是从基表中只读 detla 变化来计算最新结果。而且一般速度更快，扫描数据更少。

物化视图(由作者创建)

例如，物化视图可用于聚合流数据、预过滤数据或预连接带有小表的数据。根据 BigQuery，当基表发生变化时，视图会在后台重新计算，以便可以返回新数据。

结论

和往常一样，我希望这篇文章对你有用，并能给你启发。BigQuery 为新用户提供免费积分，这很好，你可能不在乎一开始的费用，这没关系。但是，随着您的技术堆栈和数据不断增长，有一天您会撞墙并注意到您的账单呈指数级增长。如果你知道一些节省成本的小技巧，并且本文中的大部分小技巧都很容易实现，那将会很有帮助，这样你就可以从一开始就避免大额账单。干杯！

7 个数据科学图书馆，让你在 2022 年的生活更轻松

原文：https://towardsdatascience.com/7-data-science-libraries-that-will-make-your-life-easier-in-2022-56951c729747

弗洛里安·奥利佛在 Unsplash 上拍摄的照片

这些 Python 库今年将为您节省大量时间

在做数据科学的时候，你最终可能会浪费大量的时间编码，等待计算机运行某些东西。我选择了几个 Python 库，可以在这两种情况下节省您的时间。即使你只是将其中一个整合到你的武器库中，你仍然可以在下一次做项目时节省宝贵的时间。

奥普图纳

Optuna 是一个开源的超参数优化框架。这意味着它可以帮助你找到机器学*模型的最佳超参数。

最基本的(也可能是众所周知的)替代方案是 sklearn 的 GridSearchCV，它将尝试超参数的多种组合，并基于交叉验证选择最佳组合。

GridSearchCV 将在您预先定义的空间内尝试组合。例如，对于一个随机森林分类器，您可能想要测试估计器数量和树的最大深度的几个不同值。因此，您可以为 GridSearchCV 提供每个超参数的所有可能值，它会查看所有组合。

另一方面，使用 Optuna，您首先建议一个搜索空间，它将从那里开始查找。然后，它使用自己尝试的历史来确定接下来要尝试哪些值。它使用的方法是一种叫做“树形结构 Parzen 估计器”的贝叶斯优化算法。

这种不同的方法意味着，它不是天真地尝试任意值，而是在尝试之前寻找最佳候选值，这样可以节省时间，否则这些时间将用于尝试没有前途的替代方案(也可能产生更好的结果)。

最后，它是框架不可知的，这意味着你可以使用 TensorFlow，Keras，PyTorch 或任何其他 ML 框架。

ITMO_FS

ITMO_FS 是一个特征选择库，这意味着它可以帮助您为 ML 模型选择特征。你的观察值越少，你就越要小心不要有太多的特征，以避免过度拟合。所谓“谨慎”，我的意思是你应该规范你的模型。更简单的模型(更少的特性)通常也更好，因为它更容易理解和解释。

ITMO FS 可以帮助你做到这一点，算法分为 6 个不同的类别:监督过滤器，非监督过滤器，包装器，混合，嵌入式，集成(尽管它主要侧重于监督过滤器)。

“监督过滤器”算法的一个简单例子是根据特征与目标变量的相关性来选择特征。阿姆就是一个众所周知的“包装者”的例子。开个玩笑:)我指的是
“反向选择”，你试着一个接一个地删除特性，看看这会如何影响你的模型预测能力。

下面是一个如何使用 ITMO 函数及其对模型分数影响的普通示例:

>>> from sklearn.linear_model import SGDClassifier
>>> from ITMO_FS.embedded import MOS>>> X, y = make_classification(n_samples=300, n_features=10, random_state=0, n_informative=2)
>>> sel = MOS()
>>> trX = sel.fit_transform(X, y, smote=False)>>> cl1 = SGDClassifier()
>>> cl1.fit(X, y)
>>> cl1.score(X, y)
0.9033333333333333>>> cl2 = SGDClassifier()
>>> cl2.fit(trX, y)
>>> cl2.score(trX, y)
0.9433333333333334

ITMO_FS 是一个相对较新的库，所以它仍然有点不稳定，它的文档可以更好一点，但我仍然建议你尝试一下。

shap-hypetune

到目前为止，我们已经看到了用于特性选择和超参数调整的库，但是为什么不能同时使用这两种库呢？这是 shap-hypetune 的承诺。

我们先来了解一下什么是“SHAP”:

“SHAP(SHapley Additive exPlanations)是一种博弈论方法，用来解释任何机器学*模型的输出。”

SHAP 是用于解释模型的最广泛使用的库之一，它通过在模型的最终预测中产生每个特征的重要性来工作。

另一方面，shap-hypertune 受益于这种方法来选择最佳特征，同时也选择最佳超参数。你为什么想要那个？独立地选择特性和调整超参数可能会导致次优的选择，因为您没有考虑到它们之间的相互作用。同时做这两件事不仅考虑到了这一点，而且还为您节省了一些编码时间(尽管由于搜索空间的增加，可能会增加运行时间)。

搜索可以用三种方式完成:网格搜索、随机搜索或贝叶斯搜索(另外，它可以并行化)。

不过，有一个重要的警告:shap-hypertune 只适用于梯度增强模型！

PyCaret

PyCaret 是一个开源的、低代码的机器学*库，可以自动化机器学*工作流。它涵盖了探索性数据分析、预处理、建模(包括可解释性)和 MLOps。

让我们看看他们网站上的一些实际例子，看看它是如何工作的:

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')# compare models
best = compare_models()

来源:PyCaret 网站

在短短几行代码中，您已经尝试了多个模型，并通过主要的分类指标对它们进行了比较。

它还允许您创建一个基本应用程序来与您的模型进行交互:

from pycaret.datasets import get_data
juice = get_data('juice')
from pycaret.classification import *
exp_name = setup(data = juice,  target = 'Purchase')
lr = create_model('lr')
create_app(lr)

最后，您可以轻松地为您的模型创建 API 和 Docker 文件:

from pycaret.datasets import get_data
juice = get_data('juice')
from pycaret.classification import *
exp_name = setup(data = juice,  target = 'Purchase')
lr = create_model('lr')
create_api(lr, 'lr_api')
create_docker('lr_api')

没有比这更简单的了，对吧？

它是一个如此完整的库，以至于很难在这里涵盖所有内容，所以我可能会在不久的将来专门写一篇完整的文章来介绍它，但是我建议您现在就下载它，并开始使用它来了解它在实践中的一些功能。

流动者

floWeaver 从流的数据集生成 Sankey 图。如果你不知道什么是桑基图，这里有一个例子:

七十，CC BY-SA 4.0<https://creativecommons.org/licenses/by-sa/4.0>，通过维基共享

当显示一家公司或政府的转换渠道、营销旅程或预算分配的数据时，它们真的很有帮助(如上例)。条目数据应该是下面的格式:“源 x 目标 x 值”，创建这种类型的图需要一行代码(这很具体，但也很直观)。

格拉迪欧

如果你读过敏捷数据科学，你就会知道拥有一个前端界面，让你的终端用户从项目一开始就能与数据进行交互是多么有帮助。即使对你来说，它也能帮助你熟悉数据，发现任何不一致的地方。最常用的工具之一是 Flask，但它对初学者不太友好，它需要多个文件和一些 html、css 等知识。

Gradio 允许您通过设置输入类型(文本、复选框等)来创建简单的界面。)，您的功能和输出。虽然看起来比 Flask 的可定制性差一些，但是直观的多。

此外，由于 Gradio 现在已经加入了 Huggingface，他们提供了在互联网上永久托管您的 Gradio 模型的基础设施，而且是免费的！

Terality

理解 Terality 的最好方法是把它想象成“熊猫，但是更快”。这并不意味着完全替换 pandas，并且必须重新学*如何处理数据帧:Terality 与 Pandas 具有完全相同的语法。实际上，他们甚至建议你“将 Terality 作为 pd 导入”，并继续以你*惯的方式编码。

快了多少？他们的网站有时声称速度快 30 倍，有时快 10-100 倍。

另一个很大的特点是 Terality 允许并行化，它不在本地运行，这意味着你的 8GB 内存笔记本电脑将不再抛出内存错误！

但是它在幕后是如何工作的呢？理解 Terality 的一个很好的比喻是，他们在 Spark 后端增加了一个你在本地使用的 Pandas 前端，这个后端运行在他们的基础设施上。

基本上，你不用在你的电脑上运行，而是用他们的，以一种完全无服务器的方式(意味着不需要基础设施设置)。

那有什么条件呢？你每月只能免费处理 1TB 的数据。如果你需要更多，你每个月至少要付 49 美元。1TB/月对于测试该工具和个人项目来说可能绰绰有余，但是如果您需要它用于实际的公司用途，您可能需要付费。

如果你喜欢这篇文章，你可能也会喜欢这些:

https://medium.datadriveninvestor.com/why-machine-learning-engineers-are-replacing-data-scientists-769d81735553 </8-data-science-side-projects-for-2022-3da85d3251f9>

如果你想进一步讨论，请随时通过 LinkedIn 联系我，这将是我的荣幸(老实说)。

为了让你的简历脱颖而出，你应该做的 7 个数据科学项目

原文：https://towardsdatascience.com/7-data-science-projects-you-should-do-to-make-your-resume-stand-out-bd2d0983460c

将帮助你获得理想工作的数据科学项目

照片来自 Unsplash，由 Maria Teneva 拍摄

数据科学目前是一个热门领域，没有比做自己的数据科学项目更好的方式来表明你有资格胜任这份工作。

在这篇博文中，我们将看看 7 个数据科学项目，你可以利用空闲时间做这些项目，让你的简历脱颖而出。

1.回归项目

你应该考虑做的第一个项目是基于回归的项目。回归是用于确定两个变量之间关系强度的过程。

换句话说，它可以用来找出当一个变量改变时，另一个变量改变了多少。这使得回归成为数据科学家非常重要的工具。

要创建回归项目，请选择您感兴趣的数据集，并尝试确定不同变量之间的关系。

您可以做的一些回归项目包括:

• 寻找身高和体重的关系。
• 发现收入和教育之间的关系。
• 发现投票行为和年龄之间的关系。
• 找出高中生平均绩点和 SAT 成绩的关系。

这些项目中的每一个都可以在相对较短的时间内完成，它们会让你很好地理解回归是如何工作的。

2.分类项目

你应该考虑做的下一个项目是分类项目。分类项目将帮助您了解如何使用机器学*算法将新数据点分类到预定义的类别集中。

作为一名数据科学家，了解分类非常重要，因为它可以用于许多不同的应用，例如图像识别和文档标记。

您应该考虑做的一些分类项目包括:

• 将图像分为不同的类别。例如，您可以使用机器学*算法将动物图片分类到不同的类别(例如，哺乳动物、鸟类、爬行动物等。).
• 将文本文档分类成不同的类别。例如，你可以使用机器学*算法将《纽约时报》上的文章分成不同的类别(例如，政治、商业、体育等。).
• 将电子邮件分类成不同的类别。例如，你可以使用机器学*算法将电子邮件分类为“垃圾邮件”或“非垃圾邮件”
• 将博客文章分成不同的类别。例如，你可以使用机器学*算法将来自高流量网站的博客文章分类为“正面”或“负面”

3.集群项目

聚类是一种无监督的学*算法，它根据数据点的属性将数据点分组在一起。这种类型的项目将帮助您了解如何识别数据集中的聚类，并使用聚类算法将数据中的项目分组到桶或类别中，使人们更容易探索大型数据集。

作为一名数据科学家，了解群集非常重要，因为它用于从营销到欺诈检测的各种应用中。

您应该考虑进行的一些集群项目包括:

• 按主题对推文进行聚类。这可以用来了解公众对各种话题的情绪，或者跟踪 Twitter 上的信息传播。
• 按流派对电影或电视节目进行聚类。例如，您可以在 IMDB 数据集中对类型进行聚类，以发现与您喜爱的电影类型相似但不完全相同的电影的新子类别(例如，浪漫喜剧与戏剧)。
• 根据产品类型对杂货店中的商品进行分类(例如，洗衣液与除臭剂)。为此，您可以根据属性(例如，品牌、大小、颜色)对数据集中的项目进行聚类。
• 将客户分为不同的群体，以开展有针对性的营销活动。例如，您可以根据客户的购买历史或人口统计信息对客户进行分类。

4.情感分析项目

情感分析是识别和量化文本中表达的态度和情感的过程。

作为一名数据科学家，了解情绪分析非常重要，因为它可以用于深入了解客户反馈、产品评论甚至股票市场趋势。

你应该考虑做的一些情感分析项目包括:

• 分析客户反馈数据，识别积极和消极情绪。例如，你可以查看客户对新产品的评论，找出最常见的抱怨和赞扬。
• 分析 Twitter 数据，了解情绪如何随时间变化。例如，你可以在几周或几个月的时间里跟踪 Twitter 上围绕某个话题(如总统选举)的情绪。
• 将电影评论分为正面或负面。例如，你可以使用文本分类算法将烂番茄的评论分为“新鲜”(正面)或“糟糕”(负面)。
• 识别关于贵公司及其竞争对手的推文的情绪。例如，您可以跟踪 Yelp 对某个产品的评论，并确定情绪如何随时间变化。

5.推荐系统项目

推荐系统用于对产品和服务进行个性化推荐。

作为一名数据科学家，了解推荐系统非常重要，因为它有助于公司个性化营销活动并提高客户参与度。

您应该考虑进行一些推荐的系统项目，包括:

• 构建电影推荐系统。例如，您可以构建一个算法，根据用户对以前观看的电影的评分来推荐新电影。
• 为亚马逊上的产品建立推荐系统。这可以通过使用交替最小二乘法(ALS)等算法来实现。
• 为公司或零售网站建立产品推荐系统。例如，您可以将不同的产品链接在一起，推荐同一类别的商品(例如，“如果您喜欢此产品，您也会喜欢这些”)。
• 构建旅游推荐系统。例如，您可以使用位置数据来推荐用户当前位置附*的活动或餐馆。

6.NLP 项目

自然语言处理(NLP)是从文本数据中理解和提取信息的过程。

这种类型的项目将帮助你理解 NLP 的基础，以及如何从文本数据中提取信息。

作为一名数据科学家，了解 NLP 非常重要，因为它可以用于分析客户反馈、产品评论甚至法律文档。

您应该考虑做的一些自然语言处理项目包括:

• 分析客户反馈数据，了解客户如何用自己的话描述产品或服务(例如，反馈是否包含积极或消极的关键词？).
• 从法律文件中提取信息(例如，提取合同要点)。
• 从亚马逊上的产品描述中提取信息(例如，提取产品的特性和优点)。
• 从关于一家公司或其竞争对手的推文中提取信息。

7.人工神经网络项目

人工神经网络(ANN)是一种类似于大脑的机器学*算法。

它由相互连接的神经元组成，可以用来学*和识别数据中的模式。人工神经网络通常用于图像识别或自然语言处理等任务。

有许多不同类型的人工神经网络，所以你需要选择一个适合你的特定数据集和用例。

你应该考虑做的一些人工神经网络项目包括:

• 建立一个简单的人工神经网络来识别手写数字。
• 训练 ANN 预测股票市场价格。
• 建立一个人工神经网络将图像分类成不同的类别(例如，狗或猫)。
• 训练一个人工神经网络来识别文本文档的语言。

今天就提升你的简历

感谢阅读！如果你的简历需要提升，考虑做这 7 个数据科学项目中的一个，让它脱颖而出。

从构建人工神经网络或 NLP 算法到分析客户反馈和产品评论以获得洞察力，这些项目可以通过许多方式展示您的数据科学能力。

与 5k+人一起加入我的电子邮件列表，免费获得“2023 年如何学*数据科学的完整小抄手册”

每个人都必须知道的 7 个数据可视化最佳实践

原文：https://towardsdatascience.com/7-data-visualization-best-practices-everyone-must-know-b68ebe329b1e

数据可视化

以更有效的方式传达你的故事

米利安·耶西耶在 Unsplash 上拍摄的照片

对 21 世纪的大多数工作来说，可视化数据是一项基本技能。如果你从事数据科学工作，这一点毫无疑问，但这一技能对于大多数其他工作也至关重要，包括分析师、客户服务、运营、营销、金融、企业家等。这是因为可视化数据不仅仅是将数字转换成图表。在最好的情况下，这是一个讲故事的练*，有助于以视觉形式传达任何信息。除了图表，这项技能在写电子邮件、设计咖啡馆菜单、报告和演示幻灯片时也很有用。

在撰写本文时，我已经有了三年的工作经验，为高级管理层制作了许多演示幻灯片和图表，一年的商业分析硕士课程，以及一年的数据分析师经验。

这七个最佳实践是我在四年的职业生涯中收集到的，也是我在硕士学位课上学到的。

1.前注意属性

当看一个图像时，我们的大脑自然会首先注意几个不同的特征。这些特征或属性在学术上被称为前注意属性。这些是我们潜意识里注意到和处理的，甚至在分析数据、模式甚至破译眼前的东西之前。

为了说明，我们来看看下图。

数一数每张图片中的 3！你需要多少秒？

预先注意的属性:颜色|作者图片

在阅读说明之前，你注意到选项 B 中的数字 3 了吗？

在选项 A 和选项 B 中，这组数字完全相同。然而，在选项 A 中，我花了大约十秒钟来数 3 的数目，而在选项 B 中，我只花了两秒钟。

我们的眼睛很自然地被选项 b 中独特的颜色所吸引。这使得我们很容易注意到、识别图案和分析数据(在这种情况下，计算 3 的数量)。这是突出信息、传达信息的最直接、最简单的方式之一。

除了颜色，还有许多其他的预先注意属性，如下图所示。随意放大。

预先注意属性的示例|作者图片

从上图中，我们可以注意到六个示例中的这些差异:

1. 没有预先注意的属性
2. 大胆的
3. 颜色
4. 强调
5. 空间/段落的使用
6. 字体大小

每一种前注意属性都以不同的方式起作用，有些更明显，而有些则更微妙。根据使用案例、情况、读者和风格，一些预先注意的属性可能比其他属性更受青睐。但总的来说，有了预先注意的属性，读者就不会错过你想表达的观点。

下次你写电子邮件、报告或幻灯片时，看看添加这些预先注意的属性是否有助于传达你的信息并提升讲故事的体验。

2.数据-油墨比

数据墨水是图形不可擦除的核心(来自书本量化信息的可视化显示)。

简而言之，这意味着有效显示数据需要多少墨水。这应该尽可能保持最小。

让我们来看看下面的图像，使用一个虚拟数据对销售人员和他们各自的销售业绩。

数据-油墨比|作者提供的图像和数据

选项 B 在呈现数据时更清晰、更有效。在选项 A 中，有许多冗余信息(因此有更多的墨迹)分散了我们对数据的破译。例如，在选项 A 中:

1. 销售(美元)传奇是多余的，当标题和轴已经提到推销员。
2. x 轴的销售员这个词在读者已经知道是销售员名字的情况下是多余的，标题也提到了。x 轴职称业务员也是一样。
3. 背景颜色是不必要的墨水，可能会分散我们的注意力。
4. 网格线不是必需的。它们会增加墨水量，但不会增加任何值。
5. 有争议的是，y 轴也可以被删除，因为我们可以像选项 b 一样在每个条形图上放置精确的数字。但是，请参见第 4 节关于 y 轴的操作，以及为什么这可能是一个问题。

总之，选项 B 的数据-油墨比要小得多，是一个更好的选项。原则是不要让不重要的内容分散读者对相关信息的注意力。因此，读者可以更快地了解数据。

3.图表垃圾

有时，我们试图用视觉上吸引人的图像和图标来美化我们的观想。虽然它在某些情况下可能有用，但我们必须小心不要添加没有附加值的图片，这只会增加读者的认知负荷。

例如，以上面的销售人员图表为例，假设我们在图表上为每个销售人员添加了不同的销售人员图标。这是不必要的，这些图标会被归类为图表垃圾，只会减慢我们传达信息的速度。

4.操纵 y 轴

这是一个很常见的谬误，很容易被忽视，甚至被用作操纵工具。

想象一下，我们想要传达的信息是，本是 2022 年 6 月表现最差的。然后，我们截断 y 轴，并在选项 a 中显示图表。销售额的差异看起来确实很大。

截断的 y 轴|作者的图像和数据

利益相关者或图表的读者应该注意这个技巧。看选项 B，y 轴从 0 开始，销售额的差异不再明显。

在另一个极端情况下，为了隐藏销售中的巨大差异，可以将 y 轴的最大值扩展到一个非常大的数字，因此所有条形图的高度将或多或少相等。有时这可能是偶然的，有一个非常高的 bar 异常类别。

按作者操作 y 轴|图像和数据

5.谎言因素

有时，我们也想创建 3D 图表，而不是简单的条形图和折线图。例如，当想象原油价格上涨时，我们可能会认为用石油桶的形式(相对于条形图或折线图)来想象是一个天才和创造性的想法。

原油价格|作者提供的图片和数据

然而，这里有一个我们必须考虑的谎言因素。

• 价格标签与桶的高度相对应。
• 然而，人们会通过枪管的容积来感知它。
• 体积: π r h ，其中 r 为桶的半径，h 为桶的高度。

因此，使用此图表，价格上涨的影响被感知为比实际大得多(高π r)。

6.堆积条形图

在我的职业生涯中，堆叠条形图被大量使用，有时被滥用。特别是对于在一段时间内按类别分组的可视化指标，堆积条形图总是最受欢迎的。

使用关于网飞电影的数据集，我们展示了这些年来电影年龄认证的数量(例如，PG，PG-13，R)。

堆积条形图与小倍数|图片由作者提供，数据来自 Kaggle 数据集

堆积条形图(选项 A)的缺点是很难比较每个组成部分(除了最靠* x 轴的部分)。很难比较每种颜色的度量，因为它们的起点不同。

选项 B 是一个更好的选择。这种相对不太为人所知的图表被称为小倍数图表或面板图表，也称为刻面。通过将类别分解成多个更小的独立图表，我们可以轻松地比较每个类别的趋势。通过这种方式，我们也能够用折线图来可视化，这更适合于时间序列数据。

虽然这看起来像是创建许多折线图并将它们组合成一个图表，但细微的区别是所有这些图表都共享同一个 x 轴(数据墨迹更少)。这也可以使用可视化工具快速生成，如 Tableau、Power BI、R 等。不要烦恼，没有必要花费额外的时间来生成多个图表！

7.饼图之死

有些人对饼状图的喜爱超过了他们应该有的程度，真的。对我来说，使用饼状图实际上没有什么好处。理想情况下，饼图用于表示部分到整体的关系。然而，有其他更好更有效的方法来观想这一点。

下面是我制作的虚拟销售人员图表。

对照饼图|作者提供的图片和数据

在选项 A(饼图)中，从视觉上很难比较，例如，艾比是否比 T2 拥有更多的客户。我们的大脑不*惯区分哪个角度或馅饼面积更大。尤其是有很多商品(因此有很多颜色)的时候，很难一眼看出馅饼的大小。另一方面，选项 B 以条形图的形式对此进行可视化，这使我们能够立即区分哪个类别有更多的产品。这是因为比较一根棒的长度要容易得多。

然而，如果情况(例如，不可说服的老板或利益相关者)需要你创建一个饼状图，这些提示可能有助于更好地形象化它:

• 坚持 5 片或更少，包括“其他”类别。
• 仅使用饼图显示一个时间点的比较。
• 考虑将其转换为圆环图(与饼图相同，但中间是空心的)，以减少数据墨迹。

结论

谢谢你读到这里。我希望你喜欢阅读这篇文章，并发现上面的七个最佳实践是有用的。请在评论区分享您的评论和其他最佳实践！

PS:如果你喜欢数据可视化并愿意联系，我可以在 LinkedIn 找到你。

支持我！

https://nathanthandoko.medium.com/membership

加入我的电子邮件列表，每当我发布新帖子时都会收到通知！
https://nathanthandoko.medium.com/subscribe

查看我的其他文章:

7 天挑战—掌握 Ggplot2:第 4 天—惊人的统计图表

原文：https://towardsdatascience.com/7-day-challenge-mastering-ggplot2-day-4-stunning-statistical-graphs-a3d005e55e19

通过有洞察力的图表了解您的数据

Hồ Ngọc Hải 在 Unsplash 上拍照

第一句话

经过几周的期末考试，我现在可以休息了，继续我的 Ggplot2 学*挑战。

虽然有很多数据可视化的工具，但是我相信理解 R 可视化还是很有必要的。所说的 R 是一种专门为统计研究设计的语言，它包括美观的可视化工具，如 ggplot2、scatterplot3D 和其他有助于解释统计数据的工具。

下面是三篇关于 条形图线图 和SlopI ' draph的文章，我想分享一下我在寻找对统计有帮助的图表时的发现。

我们涵盖的内容

本文将介绍一些我认为统计挖掘所必需的统计操作的图表。有:

1. 显示数据分布的图形:直方图、箱形图、小提琴图、点状图、密度和抖动图。
2. 显示解释变量和响应变量之间关系的图表:散点图矩阵、镶嵌图。

资料组

EX2。TIPS，不同聚会中小费金额的记录，是我对本文所用数据集的选择。我在以前的文章中也使用了这个数据，因为它很容易生成。可以快速获取 R regclass包中的数据集。

library(regclass)
data(EX2.TIPS)
skim(EX2.TIPS)

图 1:数据汇总—按作者分类的图片

直方图

直方图是一种通过绘制不同高度的条形来可视化连续样本数据分布的方法。每个条柱代表一个数值范围，条柱越高，意味着相应范围内的数据越多。

在 ggplot2 中，您可以使用ggplot()和geom_histogram()轻松生成直方图。此外，我们还可以通过控制独特的属性来自定义图形，例如:

• bins:设置您想要在图表中显示的箱子数量。默认数字是 30。如果您希望您的直方图类似于密度图，您可以使用大量的面元。或者，如果你想让你的图更大，设置一个更小的箱数。
• fill:帮你自定义条块的填充颜色。垃圾箱的默认颜色是灰色，看起来很沉闷。
• color:控制箱子的颜色边框。
• binwidth:修改条形的宽度。
• scale_y_continuous(labels = percent):改变 y 轴来表示占总数的百分比。

我相信每个人都很熟悉直方图的基本图形。但是，下面是一些我认为有助于提供分析所需的更高级的属性:

• geom_vline:用于说明数据的平均值、偏离平均值的标准偏差数等。
• geom_density:结合密度图，传达更有见地的观点。
• geom_text:为重要点添加注释，如最小值、最大值、中间值等。

这是我在定制了图表的不同图层后得到的结果。在图中，我将可视化所有参加聚会的人的小费金额分布。

图 2a:完整的直方图——按作者分类的图像

图 2b:直方图代码—按作者分类的图像

密度图

如果您想将直方图与密度图结合起来，使图表更具洞察力，以下是您的操作方法:

图 2c:密度图—作者图片

当进行不同组的分布比较时，在唯一的图中绘制不同组的密度图有时是有用的。例如，下图显示了男性和女性的小费金额分布。看一下图表，很容易看出女人给的小费往往比男人少。

图 3:按性别划分的密度图——按作者划分的图像

在另一种情况下，如果您想要创建脊线可视化，可以尝试使用geom_density_ridges()进行可视化。我们甚至可以通过设置stat(quantile)到fill并调用calc_ecdf和geom = "density_ridges_gradient".来用不同的颜色填充数据分位数。下图描述了一周中每个人每天支付的小费数量。

图 4: D ensity ridges —作者图片

箱线图

通常，通过显示数据百分位数和平均值，箱线图或小提琴图可视化可以帮助理解数据分布和偏斜度。

使用 ggplot 的盒图可视化非常简单，例如使用ggplot()和geom_boxplot().，仍然使用“小费金额”数据，让我们看看这些数据如何按“工作日”分布。

图 5:添加平均分数的箱线图——作者图片

对于基本的箱形图，平均点不会显示在图形中。这就是为什么我们必须在剧情中加入stat_summary(fun="mean")才能让它出现。我们可以看到，对于每个级别的、、【中值】、、【小费金额】、各不相同。因此，我们可能会怀疑小费和一周中的天数之间的关系。

抖动图

有时，添加抖动点有助于探索数据的基本分布。在上面的例子中，让我们看看我是如何可视化添加了抖动点的图形的。

代码其实很简单，只需要给盒子剧情代码加一层geom_jitter()，下面就是结果:

图 6:方框图和抖动点的组合—作者图片

马赛克图

镶嵌图用于描述两个分类变量之间的模式，并检查它们之间的关系。例如，如果我想检查【工作日】和【白天 _ 夜晚】变量之间的关系，马赛克图可能是一个有用的方法。在下面的图 7 中:

• 每个条形的宽度代表相应的总值。由于周六的酒吧最宽，这意味着周六参加派对的人数最多。与此同时，根据数据，人们似乎在周五比其他日子出门少。
• 对于 x 的每一级，y 的分布是不同的。所以，我们可以怀疑 x 和 y 变量之间的关系。

图 7:分类变量的镶嵌图——作者图片

散点图矩阵

最后，检查变量之间关系的一个非常有用的可视化函数是ggpairs()。通过一行代码，我们可以快速生成所有变量的相关矩阵。例如，小费和账单之间的线性关系如下图所示。

library(GGally)ggpairs(EX2.TIPS[c("Tip.Percentage","Bill_in_USD","Tip_in_USD")])

图 8:相关矩阵——作者图片

临终遗言

在学*这些可视化的同时，我发现了一些学* R 有用的页面，分别是 R-blog 和R-charts。他们一步一步地描述生成你期望的图形。如果你想了解更多关于 ggplot 的知识，并以更复杂的方式定制你的图表，我强烈推荐这两个。

希望文章有帮助。

新年快乐。

参考

**https://r-charts.com/ https://www.r-bloggers.com/ **

聚类算法的 7 个评估指标

原文：https://towardsdatascience.com/7-evaluation-metrics-for-clustering-algorithms-bdc537ff54d2

用 Python 示例深入解释无监督学*评估指标

马库斯·斯皮斯克在 Unsplash 上的照片

在监督学*中，标签是已知的，可以通过将预测值与标签进行比较来计算正确程度，从而进行评估。然而，在无监督学*中，标签是未知的，这使得很难评估正确的程度，因为没有地面真理。

也就是说，好的聚类算法的聚类具有小的类内方差(类中的数据点彼此相似)和大的类间方差(类与其他类不同)。

有两种类型的聚类评估指标，

• 外在测量:这些测量需要基本事实标签，但在实践中可能无法获得
• 内在度量:这些度量不需要基础事实标签(适用于所有无监督学*结果)

本文将讨论聚类算法的各种评估指标，重点是它们的定义、直觉、何时使用它们，以及如何用sklearn库实现它们。所有算法的公式都可以在文章的附录部分找到。

注:我手动检查了所有的算法和公式，如果你需要计算，请联系我！另外，对于每种算法，变量和公式都用文字和等式来解释，以便更好地理解——更多信息请见附录:)

目录

外在措施

• 兰德指数
• 相互信息
• 垂直测量
• 福尔克斯-马洛得分

内在措施

• 轮廓系数
• 卡林斯基-哈拉巴斯指数
• 戴维斯-波尔丁指数

附录:措施公式

照片由安格拉·坎普在 Unsplash 上拍摄

外在测量需要地面真实标签，这可能是不可用的或需要人工标记。

№1.兰德指数

Rand Index (RI，ARI)通过进行成对比较来测量聚类分配之间的相似性。更高的分数意味着更高的相似性。

对于每一对，如果当它们在同一个聚类中时，预测该对在同一个聚类中，则认为是正确的(有点像“真正”)，如果当它们确实在不同的聚类中时，预测该对在不同的聚类中，则认为是正确的(有点像“真负”)。

图 1:兰德指数公式——作者图片

但是，兰德指数不考虑偶然性；如果群集分配是随机的，那么可能会有许多侥幸“真阴性”的情况。理想情况下，我们希望随机(统一)标签分配的分数接* 0，这需要随机调整。

调整后的 Rand 指数(ARI) 通过贴现一个机会标准化项来调整机会。ARI 的公式可以在本文的附录(图 2)中找到，以避免视觉混乱。

何时使用兰德指数

• 你想要可解释性 : RI 直观且易于理解。
• 您对聚类结构不确定:RI 和 ARI 不对聚类结构做出假设，并且可以应用于所有聚类算法。
• 你想要一个的比较基础 : RI 有界在[0, 1]区间，ARI 有界在[-1, 1]区间。有界范围便于比较不同算法之间的分数。

何时不使用 Rand 指数

• 您没有基本事实标签:RI 和 ARI 是外部度量，需要基本事实聚类分配。

实施兰德指数

from sklearn.metrics import rand_score, adjusted_rand_score
labels = [0, 0, 0, 1, 1, 1]
labels_pred = [1, 1, 2, 2, 3, 3]

RI = rand_score(labels, labels_pred)
ARI = adjusted_rand_score(labels, labels_pred)

№2.相互信息(MI、NMI、AMI)

互信息(MI、NMI、AMI)测量集群分配之间的一致性。更高的分数意味着更高的相似性。

聚类之间的一致程度通过联合概率和边际概率来计算。互信息有两种变体:归一化互信息(NMI) 和调整互信息(AMI) 。

归一化 MI 是指 MI 除以平均聚类熵，通常在文献中使用，而调整 MI 是指通过贴现机会归一化项对机会进行调整的归一化 MI。MI、NMI 和 AMI 的公式可在本文的附录中找到(图 3 和图 4)。

何时使用互信息

• 你需要一个的比较基础 : MI、NMI 和 AMI 的上界都是 1。

何时不使用交互信息

• 您没有基本事实标签:MI、NMI 和 AMI 是外部度量，需要基本事实聚类分配。

实现相互信息

from sklearn.metrics import (
    mutual_info_score,
    normalized_mutual_info_score,
    adjusted_mutual_info_score,
)
labels = [0, 0, 0, 1, 1, 1]
labels_pred = [1, 1, 2, 2, 3, 3]

MI = mutual_info_score(labels, labels_pred)
NMI = normalized_mutual_info_score(labels, labels_pred)
AMI = adjusted_mutual_info_score(labels, labels_pred)

№3.垂直测量

V-measure 使用条件熵分析来测量聚类分配的正确性。更高的分数意味着更高的相似性。

两个度量标准衡量聚类分配的正确性，这是直观的，因为它们来自监督学*。

• 同质性:每个集群只包含一个类的成员(有点像“精度”)
• 完整性:给定类的所有成员都被分配到同一个集群中(有点像“回忆”)

V-measure 是同质性和完整性度量的调和平均值，类似于 F-score 是精确度和召回率的调和平均值。同质性、完整性和 V-measure 的公式可以在本文的附录中找到(图 5)。

何时使用垂直测量

• 您需要可解释性 : V-measure 在同质性和完整性方面直观且易于理解。
• 您对聚类结构不确定:V-measure 不对聚类结构做出假设，并且可以应用于所有聚类算法。
• 您需要一个基础来进行比较:同质性、完整性和 V-measure 在[0, 1]范围内。有界范围便于比较不同算法之间的分数。

何时不使用垂直测量

• 您没有基本事实标签:同质性、完整性和 V-measure 是外在度量，需要基本事实聚类分配。
• 您的样本大小小于 1000，而聚类数大于 10: V-measure 不针对机会进行调整。这意味着随机标记不会产生零分，尤其是当聚类数量很大时。

实施垂直测量

from sklearn.metrics import (
    homogeneity_score,
    completeness_score,
    v_measure_score,
)
labels = [0, 0, 0, 1, 1, 1]
labels_pred = [1, 1, 2, 2, 3, 3]

HS = homogeneity_score(labels, labels_pred)
CS = completeness_score(labels, labels_pred)
V = v_measure_score(labels, labels_pred, beta=1.0)

№4.福尔克斯-马洛分数

Fowlkes-Mallows 分数使用成对精度和召回率来测量聚类分配的正确性。更高的分数意味着更高的相似性。

V-measure 是同质性("精度")和完整性("召回")之间的调和平均值，而 Fowlkes-Mallows 指数(FMI)是成对精度和召回的几何平均值，使用真阳性(TP)、假阳性(FP)和假阴性(FN)。

We Fowlkes-Mallows 评分不考虑真阴性(TN)，它不会受到偶然性的影响，也不需要偶然性调整，不像 Rand 指数和互信息。

TP、FP、FN 的定义以及 Fowlkes-Mallows 指数(FMI)的公式见本文附录(图 6 和图 7)。

何时使用 Fowlkes-Mallows 评分

• 你不确定聚类结构 : Fowlkes-Mallows Score 不对聚类结构做任何假设，可以应用于所有聚类算法。
• 你要一个的对比基础 : Fowlkes-Mallows 评分有一个上限1。有界范围便于比较不同算法之间的分数。

何时不使用福尔克斯-马洛分数

• 您没有基本事实标签:Fowlkes-Mallows 分数是外在的度量，需要基本事实聚类分配。

实现 Fowlkes-Mallows 评分

from sklearn.metrics import fowlkes_mallows_score
labels = [0, 0, 0, 1, 1, 1]
labels_pred = [1, 1, 2, 2, 3, 3]

FMI = fowlkes_mallows_score(labels, labels_pred)

照片由皮埃尔·巴明在 Unsplash 上拍摄

内在的措施不需要地面真相标签，使他们适用于所有聚类结果

№5.轮廓系数

剪影系数衡量聚类之间的距离与聚类内的距离。较高的分数表示更好定义的聚类。

样本的轮廓系数测量样本与下一个最*聚类中所有其他点相对于其聚类中所有其他点的平均距离。较高的比率表示该聚类远离其最*的聚类，并且该聚类被更好地定义。

一组样本的轮廓系数取每个样本的平均轮廓系数。该公式可在本文的附录中找到(图 8)。

何时使用轮廓系数

• 你要可解释性:廓形系数直观易懂。
• 你要一个的比较基础:剪影系数有一个[-1, 1]的范围，从不正确的聚类到高度密集的聚类，0是重叠的聚类。有界范围便于比较不同算法之间的分数。
• 您将好的聚类定义为定义明确的聚类:剪影系数遵循好的聚类的一般定义，即密集且分离良好。

何时不使用轮廓系数

• 您正在比较不同类型的聚类算法:基于密度的聚类算法的轮廓系数得分往往更高，与其他类型的聚类算法进行比较是不公平的。

实施轮廓系数

from sklearn.metrics import silhouette_score
data = [
    [5.1, 3.5, 1.4, 0.2],
    [4.9, 3\. , 1.4, 0.2],
    [4.7, 3.2, 1.3, 0.2],
    [4.6, 3.1, 1.5, 0.2],
    [5\. , 3.6, 1.4, 0.2],
    [5.4, 3.9, 1.7, 0.4],
]
clusters = [1, 1, 2, 2, 3, 3]

s = silhouette_score(data, clusters, metric="euclidean")

№6.卡林斯基-哈拉巴斯指数

Calinski-Harabasz 指数衡量的是组间离差和组内离差。较高的分数表示更好定义的聚类。

Calinski-Harabasz 指数或方差比标准衡量组间离差之和与组内离差之和，其中离差是距离平方之和。

较高的比率表示该分类远离其其他分类，并且该分类更加明确。该公式可在本文的附录中找到(图 9)。

何时使用卡林斯基-哈拉巴斯指数

• 你想要效率:卡林斯基-哈拉巴斯指数计算起来很快
• 你将好的集群定义为定义明确的集群 : Calinski-Harabasz 指数遵循好的集群的一般定义，即密集且分离良好。

何时不使用卡林斯基-哈拉巴斯指数

• 您正在比较不同类型的聚类算法:对于基于密度的聚类算法，Calinski-Harabasz 指数往往更高，与其他类型的聚类算法进行比较是不公平的。

实施卡林斯基-哈拉巴斯指数

from sklearn.metrics import calinski_harabasz_score
data = [
    [5.1, 3.5, 1.4, 0.2],
    [4.9, 3\. , 1.4, 0.2],
    [4.7, 3.2, 1.3, 0.2],
    [4.6, 3.1, 1.5, 0.2],
    [5\. , 3.6, 1.4, 0.2],
    [5.4, 3.9, 1.7, 0.4],
]
clusters = [1, 1, 2, 2, 3, 3]

s = calinski_harabasz_score(data, clusters)

№7.戴维斯-波尔丁指数

Davies-Bouldin 指数根据簇之间的平均距离来测量簇的大小。较低的分数表示更好定义的聚类。

Davies-Bouldin 指数衡量聚类之间的平均相似性，其中相似性将聚类的大小与聚类之间的距离进行比较。

较低的分数意味着该聚类与到另一个聚类的距离相比相对较小，因此定义良好。该公式可在本文的附录中找到(图 10)。

何时使用戴维斯-波尔丁指数

• 你想要可解释性:戴维斯-波尔丁指数比剪影分数更容易计算，它使用逐点距离。

何时不使用戴维斯-波尔丁指数

• 您正在比较不同类型的聚类算法:基于密度的聚类的 Davies-Bouldin 指数往往更高，与其他类型的聚类算法进行比较是不公平的。
• 除了欧几里德距离之外，您还需要其他距离度量:由质心距离计算的聚类大小将距离度量限制在欧几里德空间。

实施戴维斯-波尔丁指数

from sklearn.metrics import davies_bouldin_score
data = [
    [5.1, 3.5, 1.4, 0.2],
    [4.9, 3\. , 1.4, 0.2],
    [4.7, 3.2, 1.3, 0.2],
    [4.6, 3.1, 1.5, 0.2],
    [5\. , 3.6, 1.4, 0.2],
    [5.4, 3.9, 1.7, 0.4],
]
clusters = [1, 1, 2, 2, 3, 3]

DB = davies_bouldin_score(data, clusters)

结论

每种算法的特征总结如下:

表 1:聚类算法的特征—按作者分类的图片

我希望您已经更多地了解了评估聚类算法的不同方法——根据您是否有基本事实标签，使用内部和外部度量。在实践中，我们可能更关心集群是否有商业意义，而不是通过统计测量集群内部或之间的距离。尽管如此，这些评估指标仍然值得了解！

附录

兰德指数(ARI)公式

机会标准化项考虑在实际聚类分配和预测聚类分配中出现在同一聚类中的对的数量。

图 2:机会标准化术语和调整后的 Rand 指数的公式——作者图片

互信息公式(MI，NMI，AMI)

联合概率、边际概率和熵的公式构成了计算互信息的基础。

图 3:联合概率、边际概率和熵的公式——作者图片

图 4:MI、标准化 MI 和调整 MI 的公式——作者图片

V-measure 公式

图 5:同质性、完整性和 V-measure 公式——作者图片

福尔克斯-马洛得分公式

Fowlkes-Mallows 指数(FMI)是使用真阳性、假阳性和假阴性计算的。TP、FP 和 FN 的定义是通过计算成对点的数量来完成的，如果它们被分配在预测和实际标签的相同或不同聚类中的话。

图 6:TP、FP、TN、FN 的定义——作者图片

图 7:fowl KES-Mallows 评分公式——作者图片

轮廓系数公式

请注意，对于b的计算，它考虑的是距离样本本身最*的下一个聚类，而不是距离指定聚类最*的下一个聚类。

图 8:剪影系数公式—作者图片

卡林斯基-哈拉巴斯指数

图 9:卡林斯基-哈拉巴斯指数公式——作者图片

戴维斯-波尔丁指数

图 10:戴维斯-波尔丁指数公式——作者图片

相关链接

• sklearn文档:https://sci kit-learn . org/stable/modules/clustering . html # clustering-performance-evaluation

您可以使用 7 个函数在 Pandas 数据框架中创建新列

原文：https://towardsdatascience.com/7-functions-you-can-use-to-create-new-columns-in-a-pandas-dataframe-a6b480cf8b30

数据分析、数据清理和特征工程中的典型任务

莱尔·哈斯蒂在 Unsplash 上的照片

Pandas DataFrame 是一个二维数据结构，带有标记的行和列。一行代表一个观察值(即一个数据点)，列是描述观察值的特征。

我们有时需要创建一个新列来添加一条关于数据点的信息。这些列可以从现有列派生，也可以从外部数据源派生新列。

在本文中，我们将了解 7 个可用于创建新列的函数。

让我们从创建一个样本数据帧开始。

import numpy as np
import pandas as pddf = pd.DataFrame({ "division": ["A", "B", "A", "C", "B"],
    "category": ["101-A", "14-C", "1020-D", "112-A", "11-A"],
    "mes1": np.random.randint(10, 40, size=5),
    "mes2": np.random.randint(10, 60, size=5),
    "mes3": np.random.randint(10, 100, size=5)

})df

df(作者图片)

1.熊猫在哪里

Pandas 的 where 函数可用于根据其他列中的值创建一个列。

我们定义一个条件或一组条件，然后取一列。对于符合条件的行，此列中的值保持不变。其他值将替换为指定的值。

用一个例子更容易理解。假设我们希望根据 mes2 列上的条件更新 mes1 列中的值。

如果 mes2 中的值大于 50，我们要在 mes1 中的值上加 10。否则，我们希望保持值不变。下面是我们如何使用 where 函数来执行这个操作。

df["mes_updated"] = df["mes1"].where(

    df["mes2"] <= 50, 
    df["mes1"] + 10)df[["mes1", "mes2", "mes_updated"]]

(图片由作者提供)

正如我们在上面的输出中看到的，符合条件(mes2 ≤ 50)的值保持不变。其他值通过加 10 来更新。

2.哪里的数字

NumPy 的 where 功能比熊猫灵活。我们能够为符合给定条件的行赋值。这对于熊猫的 where 函数是不可能的，因为符合条件的值保持不变。

让我们做同样的例子。如果 mes2 中的值大于 50，我们要在 mes1 中的值上加 10。否则，我们要减去 10。

df["mes_updated_2"] = np.where(

    df["mes2"] <= 50, 
    df["mes1"] - 10,
    df["mes1"] + 10)df[["mes1", "mes2", "mes_updated_2"]]

(图片由作者提供)

3.数字选择

where 函数根据一组条件赋值。select 函数更进一步。它接受多组条件，并且能够为每组条件分配不同的值。

让我们基于以下条件创建一个新列:

• 如果除法是 A 并且 mes1 大于 10，则值为 1
• 如果除法是 B 且 mes1 大于 10，则值为 2
• 否则，该值为 0

conditions = [

  (df["division"] == "A") & (df["mes1"] > 10),
  (df["division"] == "B") & (df["mes1"] > 10)

]values = [1, 2]df["select_col"] = np.select(conditions, values, default=0)df[["division", "mes1", "select_col"]]

(图片由作者提供)

条件和相关值写在单独的 Python 列表中。默认参数指定不符合任何列出条件的行的值。

4。熊猫分配

Pandas 的分配功能可用于在一次操作中创建多个列。我们可以基于现有的列派生列，或者从头开始创建。如果我们采用后者，我们需要确保变量的长度与数据帧中的行数相同。

我们来做一个例子。

df = df.assign(

    cat1 = df["category"].str.split("-", expand=True)[0],
    mes_all = lambda x: x.mes1 ** 2 + x.mes2 * 10 + x.mes3,
    id = [1, 2, 3, 4, 5])

我们创建了 3 个新列:

• 第一个是类别列中字符串的第一部分，通过字符串拆分得到。
• 第二个是使用涉及 mes1、mes2 和 mes3 列的计算创建的。
• 第三个只是一个整数列表。

以下是新列:

(图片由作者提供)

5.熊猫插页

当我们为数据帧创建一个新列时，它被添加到末尾，因此它成为最后一列。insert 函数允许根据列索引指定新列的位置。

让我们创建一个 id 列，并将其作为数据帧中的第一列。

df.insert(0, "id", [1, 2, 3, 4, 5])df

(图片由作者提供)

insert 函数有 3 个参数:

• 第一个是新列的索引(0 表示第一个)。
• 第二个是新列的名称。
• 第三个是新列的值。

6.熊猫分裂了

在处理文本数据时，split 函数非常有用。假设我们有一个包含多条信息的文本列。我们可以拆分它，为每个部分创建一个单独的列。

注意:在 str 访问器下可以使用 split 函数。

让我们通过拆分 category 列来创建 cat1 和 cat2 列。

df[["cat1","cat2"]] = df["category"].str.split("-", expand=True)df[["category","cat1","cat2"]]

(图片由作者提供)

7.熊猫猫

cat 功能与 split 功能相反。它可用于通过组合字符串列来创建新列。在 str 访问器下也可以使用 cat 函数。

下面是我们如何通过合并 cat1 和 cat2 列来创建 category 列。

df["category"] = df["cat1"].str.cat(df["cat2"], sep="-")

在用于机器学*的数据分析、数据清理和特征工程的典型任务中创建新列。幸运的是，Pandas 通过提供几个函数和方法使它变得非常容易。在本文中，我们介绍了加速和简化这些操作的 7 个功能。

你可以成为 媒介会员 解锁我的全部写作权限，外加其余媒介。如果你已经是了，别忘了订阅如果你想在我发表新文章时收到电子邮件。

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

我从使用 ONNX 部署机器学*模型中学到的 7 个教训

原文：https://towardsdatascience.com/7-lessons-ive-learnt-from-deploying-machine-learning-models-using-onnx-3e993da4028c

一次构建，随处部署的绝佳方式

奥丽雅·丹尼尔维奇在的照片

在本帖中，我们将概述从一个在 AWS Lambda 函数中使用 ONNX 运行时 API 在 sci-kit 学*模型上运行推理的真实示例中获得的关键知识。这不是一个教程，而是一个指南，集中在有用的技巧，要考虑的要点，和可能会让你省掉一些挠头的怪癖！

ONNX 是什么？

开放神经网络交换(ONNX) 格式有点像把你的薯条蘸上奶昔；它不应该工作，但它就是工作。(嗯，反正对我来说)。

ONNX 允许我们使用所有我们知道并喜欢的训练框架(如 PyTorch 和 TensorFlow)来建立模型，并将其打包成许多硬件架构和操作系统支持的格式。ONNX 运行时是一个简单的 API，它是跨平台的，并提供最佳的性能来在 ONNX 模型上运行推理，只要你需要:云、移动设备、物联网设备，你能想到的！

我们选择的编程语言或运行时决定我们如何构建人工智能的日子已经一去不复返了。

要更深入地了解 ONNX，请查看本文: ONNX —变得简单。

我们怎么知道它有效？

在 Bazaarvoice ，我们通过增强产品的用户生成内容(UGC)来改善数百万人的电子商务体验。其中很大一部分是产品匹配的过程，或者换句话说，确定两种产品在零售商之间是相同的。由于唯一的产品标识符，大部分工作可以自动完成，但是，有数百万种产品缺少这种重要的数据。

为了解决这个问题，我们建立了一个机器学*模型，它可以自动化产品匹配过程，并在全球范围内部署它，现在它可以准确匹配世界上一些最大品牌的数百万种产品。

先决条件

虽然其中一些经验适用于多个工作流，但需要注意的是，它们是基于我的团队对我们使用的技术的经验:

• 机器学*模型是使用 scikit-learn 作为训练框架用 Python 编写的
• 我们使用 onnxruntime-node npm 包在 Node.js 环境中运行 ONNX 模型
• 使用无服务器框架将模型部署到 AWS Lambda

🌎第 1 课:一次构建，随处部署

ONNX 的最大卖点之一是它的多功能性和防止框架锁定的能力，所以不要陷入选择语言或部署环境，甚至是操作系统的困境。选择适合自己和项目的。

有许多与 ONNX 格式兼容的培训框架和各种流行的部署运行时。你可以在这里找到方便的兼容性指南。

关于 web 应用部署目标的更多信息可以在 ONNX 运行时文档中找到。

⚠️第二课:“错误:非张量类型暂时不被支持。”

标题中的错误是我们在试图使用 onnxruntime-node npm 包在 Node.js 运行时运行从 Python (scikit-learn)导出的 ONNX 模型时遇到的问题。

由于错误消息，所有线索都暗示问题出在 onnxruntime-node 包中，但是，问题的根源在于从 scikit-learn 到 ONNX 的转换代码。

修复非常简单，使用来自 onnx.ai 网站的 sklearn-onnx 示例代码示例，我们需要添加一个 **options** 变量，并将 **zipmap** 设置为 false :

# Convert into ONNX format
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType
initial_type = [('float_input', FloatTensorType([None, 4]))]
onx = convert_sklearn(clr, initial_types=initial_type, **options={'zipmap': False})**  # enables getting probabilities in Node
with open("rf_iris.onnx", "wb") as f:
    f.write(onx.SerializeToString())

通过将zipmap设置为 false，我们现在可以在 Node.js 运行时接收概率输出。

有关导出的更多信息，请参见 ONNX 教程 GitHub repo 。它为使用机器学*框架和云服务开发的模型提供了很好的描述和例子。

📚第 3 课:用于数据帧操作的 JavaScript 库

几个 npm 库提供了 DataFrame 风格的数据转换(拆分、连接、分组等)。选择最好的取决于您的用例。我们使用的两个库是 danfo.js 和 dataframe-js 。

danfo-js 建立在 tensorflow-js 之上，将数据处理、机器学*和人工智能工具带到 JavaScript 开发者的手中。它深受熊猫的启发。这意味着如果你熟悉熊猫 API，danfo.js 应该是一个平滑的过渡。

dataframe-js 是用更具功能性的编程启发的 API 构建的，所以如果你更熟悉 JavaScript，你可能会觉得使用 dataframe-js 比 danfo-js 更舒服。

danfo-js 和 dataframe-js 都非常适合我们的用例，并提供了复杂特征工程所需的所有功能。danfo-js 的主要缺点是包的大小。对于我们的无服务器应用程序来说，它太大了，而“dataframe-js”打包在 1Mb 以下，这是无服务器应用程序的理想选择。

选择库时要考虑的一些其他标准是:

• 语言支持(NodeJS vs browser JS vs Typescript)
• 依赖性(即，如果它使用底层库)
• 积极支持(积极的用户基础、积极的资源存储库等)
• JS 库的大小/速度
• 表演
• 功能/灵活性
• 易于使用
• 内置可视化功能

其他数据帧操作库包括:

• 数据伪造
• jsdataframe
• 数据框
• SQL 框架

📦第四课:使用 无服务器-插件-优化 插件

在进行无服务器部署时，保持项目包较小是非常重要的。下图显示了数据科学家最常用的一些库的 Python 包大小。我们可以看到他们如何吃掉 AWS Lambdas 和 Google Cloud 功能的大量部署规模限制。

流行框架的 Python 包大小和云部署限制。作者照片

然而，我们可以在这些限制内工作。ONNX 将 PyTorch、Tensorflow 和 pandas 等创建的模型转换成与相对较小的 ONNX 运行时包(~13MB)兼容的模型。这适用于某些情况，但是添加一个庞大的 node_modules 文件夹，超出部署限制的情况仍然很常见。

无服务器-插件-优化 插件显著减小了无服务器包的大小。在我们的例子中，插件允许我们在 50Mb 之内轻松地打包我们的模型、依赖项和代码。AWS Lambdas 的 zip 文件部署限制。

要允许 AWS Lambda 访问 onnxruntime-node 包和 onnx 模型，请将以下几行添加到您的serverless.yml文件中:

custom:
 optimize:
 external: ['onnxruntime-node', 'onnxruntime-common']
 includePaths: ['PATH_TO_ONNX_MODEL']

🚀第 5 课:将onnxruntime-node部署到 AWS

使用 onnxruntime-node 时需要注意的重要一点是 其中 你正在运行的 app 决定了 你应该如何 安装包。如果在部署时没有将它安装到正确的体系结构和/或平台上，您将会看到抛出缺失模块错误，如下所示:

Runtime.ImportModuleError: Error: Cannot find module '../bin/napi-v3/linux/x64/onnxruntime_binding.node'

大多数本地节点模块使用 node-pre-gyp ，它使用一个安装脚本来为您的 OS、arch 和 v8 ABI 组合搜索预构建的二进制文件，如果没有一个可用的，则回退到本地构建。

这意味着一个简单的npm install onnxruntime-node在本地运行时可以工作，但是在云函数中无服务器运行时，我们需要明确地安装到我们的环境中。

在我们的例子中，我们使用的 AWS Lambda 具有 x64 架构，并在 Linux 机器上运行，因此我们必须在部署 之前运行 的 npm 安装命令是:

npm install --arch=x64 --platform=linux onnxruntime-node

📅第 6 课:日程安排

如果您需要您的模型按计划自动运行，而不想手动运行您的模型——如果您使用 AWS，请尝试将 EventBridge 添加到您的无服务器配置。使用 cron 表达式或速率表达式设置时间表。

以下是添加到serverless.yml文件的配置示例:

events:
 - http:
   path: really-cool-onnx-project
   method: post
 - eventBridge:
   enabled: true
   schedule: cron(0/20 6-13 * * ? *) # Runs every 20 minutes between 6am and 2pm (UTC) every day
   input:
    stageParams:
     stage: prod

需要注意的重要一点是，如果您的 AWS Lambda 函数在 EventBridge 调用期间超时，它将一直调用，直到执行完成。

Google Cloud Functions 和 Azure Functions 也都有基于 cron-job 的调度能力，分别有云调度器和定时器触发器。

📈第 7 课:高效扩展无服务器应用

在性能和成本之间找到最佳平衡是大规模运行无服务器应用的一个重要方面。

在我们的用例中，我们为每次 AWS Lambda 调用生成 10，000 个产品的预测。这是需要处理的大量数据。出于这个原因，理解 Lambda 的两个方面以优化性能是很重要的:执行时间(避免超时)和成本效率。

我们用六种不同的 Lambda 内存大小配置测试了我们的无服务器应用程序，并推断了我们在内存大小、执行时间和成本方面可以找到的任何结果。

使用六种不同的 Lambda 内存大小配置测试我们的无服务器应用的结果

如您所见，随着内存大小翻倍，执行时间几乎减半——直到它稳定在 4096MB，达到收益递减点。使用更高的分配内存大小也** 增加了 Lambda 函数可用的虚拟 CPU 的数量，从而节省了成本，因为它减少了总执行时间。**

2048MB 的内存大小最终成为最便宜的——令人惊讶的是甚至比 256MB 还便宜，同时还快了大约 10 倍。因此，对于我们的用例，2048MB 是性能和成本之间的最佳平衡。

结束语

希望这篇帖子在用 ONNX 和 Serverless 开发的时候对你有所帮助。在 Bazaarvoice，我们通过在全球范围内使用 ONNX 提供人工智能解决方案来支持这些技术。如果您想了解更多关于我们的 ONNX 解决方案的信息，请查看由我们的一位机器学*工程师所做的本次会议报告。

💻 If you have any questions, please reach out / [matthewleyburn.com](https://matthewleyburn.com/)

你用过 ONNX 吗？在评论里告诉我，说说你们的经历吧！

中心极限定理的 7 个常见问题

原文：https://towardsdatascience.com/7-most-asked-questions-on-central-limit-theorem-82e95eb7d964

理解中心极限定理的重要性

迈克尔·奥尔森在 Unsplash 上的照片

在本帖中，我们将解开统计学中最重要的定理之一:T4 中心极限定理。我将向你介绍这个定理的各个方面，并讨论为什么它为许多统计应用奠定了基础。

#1:什么是中心极限定理？

中心极限定理指出，给定足够大的样本量，不管总体中的数据分布如何，样本均值的抽样分布将*似为正态分布。

如果这个定义听起来很抽象，让你感到困惑，不要担心。这篇文章将把这个复杂的定义分解成更容易理解的部分。

#2:什么是抽样分布？

与描述总体中所有可能值的频率的样本分布(或数据分布)不同，抽样分布描述来自同一总体的多个样本的样本统计量(例如样本均值)的分布(即重复抽样)。

例如，我们从总体中收集 100 个数据点，并计算样本均值。我们重复这个过程 1000 次，有 1000 个不同的样本均值。这 1000 个样本均值的分布称为样本均值的抽样分布。

#3:中心极限定理的条件是什么？

为了让中心极限定理发挥作用，我们需要确保满足以下 3 个条件。

1. 样本量足够大。
2. 样本为独立同分布(IID)随机变量。
3. 人口分布有有限方差。

#4:如果人口分布不正态，中心极限定理是否成立？是啊！

在总体中，基础数据可以遵循不同种类的分布，例如，正态、左偏、右偏、均匀分布等。

不管总体分布如何，只要样本量足够大，样本均值的抽样分布将接*正态分布。这是统计学中一个强有力的定理。

#5:需要多大的样本量才能产生正态*似？

请记住，在中心极限定理的上下文中讨论的“样本大小”不仅仅是一个样本的样本大小，它适用于抽样分布中的所有样本(即，所有样本需要具有来自同一总体的相同且足够大数量的观察值)。

样本量越大，样本均值的抽样分布就越接*正态分布。

通常，我们认为 30 的样本量足够大。

• 如果样本量小于 30 ，中心极限定理不再适用。只有当总体分布也是正态分布时，样本均值的抽样分布才服从正态分布。
• 如果样本量大于 30 ，则适用中心极限定理，无论人口分布如何，抽样分布都将遵循正态分布。然而，强偏斜分布需要更大的样本量。

#6:样本大小如何影响均值的抽样分布？

随着样本量的增加，

• 抽样分布将收敛于正态分布。
• 抽样分布的平均值将收敛于总体平均值
• 而样本分布的标准差(又名，spread，均值的标准差【T7，】SEM)，等于σ/√n，会更小。

这很容易用一点数学来证明。

随着样本量(n)的增加，公式的分母变大，然后 SEM 变得更小，抽样分布变得更紧，而更 精确样本均值可以用来估计总体均值。

作者图片

#7:为什么中心极限定理很重要？

1. 正态假设:

在现实世界的数据中，异常值、偏斜度和不对称性是很常见的。许多统计实践，如假设检验、置信区间和 t 检验，都是基于正态假设的。使用适当的样本量和中心极限定理有助于我们解决数据的非正态性问题。

2.估算的精度:

实际上，我们通常只有一组随机样本。我们经常使用统计推断来使用样本统计(例如，样本均值)估计总体参数(例如，总体均值)。样本均值是总体均值的最佳线性无偏估计量(蓝色)。然而，使用点估计(如样本均值)来推断总体均值是不够的，因为它几乎总是不准确的。

如果我们一次又一次地随机抽取样本并计算所有样本的平均值。这将是对人口平均数的一个非常好的估计。样本均值的抽样分布还允许我们量化变异性，即样本均值和总体均值之间的差异。

幸运的是，我们不需要重复抽样来估计样本均值的抽样分布。如果我们一次又一次地抽取随机样本，中心极限定理允许我们仅仅基于一组随机样本来这样做。

此外，中心极限定理的性质告诉我们，随着样本量的增加，我们对总体均值的估计将更加精确，并且可变性更小。

结论:

当数据不是正态分布时，中心极限定理证明了统计推断的正态性假设，并告诉我们用更大的样本量来提高总体均值估计的精度。

如果你想探索更多与统计相关的帖子，请查看我的文章:

• 7 中心极限定理最常问的问题
• 标准差 vs 标准差:有什么区别？
• 3 种最常见的曲解:假设检验、置信区间、P 值
• 线性回归模型中误差项是否呈正态分布？
• 线性回归模型中的 OLS 估计量是否呈正态分布？
• 什么是正则化:偏差-方差权衡
• 方差 vs 协方差 vs 相关性:有什么区别？
• 置信区间 vs 预测区间:有什么区别？
• I 型和 II 型错误哪个更糟糕？

感谢您的阅读！！！

如果你喜欢这篇文章，并且想请我喝杯咖啡，请点击这里。

您可以注册一个 会员 来解锁我的文章的全部访问权限，并且可以无限制地访问介质上的所有内容。如果你想在我发表新文章时收到电子邮件通知，请订阅。

2022 年数据科学家必读的 7 本书

原文：https://towardsdatascience.com/7-must-read-books-for-data-scientists-in-2022-aa87c0f9bffb

照片由思想目录在 Unsplash 上拍摄

帮助你成为更好的数据科学家的技术和非技术书籍

阅读无疑是数据科学家最重要的品质之一。随着大量信息通过 YouTube 视频、课程和博客涌入(是的，我明白了其中的讽刺)，我们认为我们可以获得数据科学家理解技术概念所需的一切。然而，从阅读书籍中可以获得如此多的东西，我们可能会因为其他来源的信息过载而错过。因此，我决定写一些与当今数据科学家相关的知识渊博的标题。

排名不分先后，我读过的一些最有趣的书帮助我成为了一名数据科学家。让我们开始吧！

1.魔鬼经济学:一个流氓经济学家探索一切事物隐藏的一面

作者:斯蒂芬·j·杜布纳和史蒂芬·列维特

书籍封面的副本(来源:维基百科)

如果你没有听说过这本书，那你一定是生活在岩石下，这本书是由芝加哥大学经济学家史蒂芬·列维特和《纽约时报》记者斯蒂芬·j·杜布纳于 2005 年出版的。它已经被认为是经济学家中最受欢迎的书籍之一，但这本书对数据科学家的重要性没有得到足够的强调。

这本书研究了人们的一些日常信念，并应用计量经济学和数据挖掘方法来揭穿这些信念，如“是什么导致了美国犯罪的减少？”“为什么毒贩和他们的父母住在一起？”、“老师阅卷时作弊吗？”。作者提出了一些古怪的假设，然后遵循结构化数据分析方法来证明这一点，这是数据科学家经常做的事情。

这本书的重点不是教你如何进行数据分析或如何使用尖端技术。相反，这本书侧重于数据科学的基础:提出正确的问题，在数据中寻找模式，识别正确的数据源，打破传统智慧，并提出更多的问题。

事实上，我会向刚进入这个领域的人强烈推荐这个，看看你是否有兴趣从事数据科学的全职工作。

2.算法赖以生存的

作者:布莱恩·克里斯蒂安和汤姆·格里菲斯

的封面图片算法被 点击 PT Medika

这本书不仅仅是给数据科学家的，几乎每个人都可以从中受益。任何想要探索算法世界的人都必须阅读这本书。Christian 和 Griffiths 通过探索各种计算机科学算法如何应用于我们的日常生活，提供了对这些算法的深入理解。算法生存法则通过简单的写作和相关的轶事，帮助解决常见的决策问题，并阐明人类思维的运作。

处理真实世界数据的数据科学家需要彻底理解算法和数据结构以及统计和概率知识，这本书是深入研究算法及其相关概念的完美方式。

请注意，这本书不仅仅是关于编程或解决编码问题。它不会教你如何用各种语言编写所有不同的排序算法，相反，它会给你一个现实世界的例子，说明排序在哪里应用，以及它如何使世界变得不那么复杂。作者确实讨论了像时空复杂性、最优搜索等技术概念，但即使是这样，也是以技术人员和非技术人员都能理解的方式讨论的。

这种技术概念的可访问性是我喜欢这本书的原因，也是我向数据科学家推荐这本书的原因，因为数据科学也是一个多样化的领域，人们来自经济学、统计学、心理学、商业等背景。这本书确保算法不仅仅被计算机科学家垄断，而且这种知识可以与来自各种背景的人分享。

3.黑天鹅:极不可能事件的影响

作者:纳西姆·尼古拉斯·塔勒布

来自 Goodreads 的书《黑天鹅》的封面

这是一位前期权交易员写的书，出版于 2007 年。它讨论了罕见的和不可预测的异常事件的极端影响，以及人类倾向于为这些事件寻找简单的解释。这些异常事件被称为‘黑天鹅事件’。

根据 Investopedia 的说法，黑天鹅是一种不可预测的事件，超出了正常情况下的预期，具有潜在的严重后果。它们有三个主要特征:

• 它们极其罕见
• 它们产生了严重而广泛的影响
• 人们经常试图提出解释，解释为什么它们在事后是显而易见的

具有讽刺意味的是，这本书正好在本世纪最大的黑天鹅事件之一——2008 年金融危机——之前出版。当我写这篇文章时，我们正在摆脱另一个黑天鹅事件，即 Covid19 疫情。

“黑天鹅事件”这个名字来源于这样一个故事:所有的天鹅都是白色的，这曾经是一个普遍的观念，因为人们从来没有见过其他东西来说服他们。然而，他们震惊地发现了一只黑天鹅，这最终让他们意识到黑天鹅的存在实际上在基因上是可能的。

这本书有很多关于不确定性、概率、风险和人类决策的内容。作为数据科学家，我们经常处理异常值，并提出了许多方法来处理它们。然而，这些事件不仅仅是离群值，学*如何处理它们本身就是一种技能。塔勒布讨论了如何不去试图预测黑天鹅事件，我们应该建立对负面事件的鲁棒性，并学会利用正面事件。对于任何处理现实世界数据的人来说，这都是一本很好的读物，因为现实世界的数据会受到像这样的全球性事件的影响。

4.数学毁灭武器

作者:凯茜·奥尼尔

大规模杀伤性武器封面图片保拉·盖特

这本书由哥伦比亚大学数据科学项目的前主任撰写，于 2016 年出版，并于 2019 年获得欧拉图书奖。

这本书探讨了数据科学和大数据如何越来越多地被用于强化社会中预先存在的不平等。Cathy O'Neil 分析了大数据算法在保险、教育、金融、警务等领域的应用，并展示了这些算法如何加剧我们社会中存在的种族主义、不平等和偏见。

这本书增加了当前围绕机器学*系统的可解释性和公平性的讨论。强烈建议初出茅庐和经验丰富的数据科学家了解他们所构建模型的真实影响，尤其是在处理社会经济应用时。

5.用数据讲故事

作者:科尔努斯鲍默·奈弗利克

来自威利的书的封面

数据科学不仅仅是构建复杂的模型和对数据应用高级统计概念。它还确保技术和非技术的利益相关者理解您从数据中呈现的分析。这里的一个主要因素是你从你的数据中讲述的故事，这本书是了解更多的最佳途径。

这本书深入研究了有效的可视化和沟通的世界，从你的数据中制作一个关键的故事。作者提供了理论和现实世界例子的平衡，可以转化为你的日常工作。这本书展示了如何使用传统和非常规的工具从你的数据中挖掘见解，并以一种令人愉快的方式呈现出来。重点关注的一些内容是如何:

• 理解语境的重要性
• 为每种情况选择适当的图表
• 将观众的注意力引向你想要的地方
• 消除相关信息周围的混乱
• 将设计的概念融入你的数据可视化

我曾亲身经历过这样的情况，我知道项目的所有技术方面，但我仍然无法说服利益相关者或我的领导我的项目的影响，因为我无法解释一个令人信服的故事。我现在希望我早些时候读过这本书，并从中吸取教训。对于那些已经确定了技术概念，并希望了解更多关于展示结果和令人信服的工作故事情节的资深数据科学家来说，这是一个很好的建议。

6.深度学*用 PyTorch 循序渐进

作者:丹尼尔·戈多伊

深度学*与 PyTorch 图书封面来自亚马逊

PyTorch 是脸书 AI 研究(FAIR)团队在sou Smith chint ala的领导下，于 2017 年开发的优化深度学*框架。自从发布以来，PyTorch 已经成为深度学*社区中非常受欢迎的框架，尤其是在研究人员中(包括我自己)。

数据科学家必须了解 PyTorch，因为这是一个非常有用的工具。PyTorch 的专业知识可以帮助你在工业界和学术界工作，PyTorch 的受欢迎程度只会越来越高。

这本书是开始学* PyTorch 的好地方，因为作者以非常清晰明了的方式写作，初学者和专家都可以理解。他涵盖 PyTorch 的基础知识，如张量和梯度，以及 PyTorch 在计算机视觉和 NLP 领域的应用。

7.构建机器学*驱动的应用:从想法到产品

作者:艾曼纽·阿梅森

杰克·卡拉姆卡的封面

如果我不谈论将 ML 模型部署到生产中，任何关于数据科学书籍的文章都是不完整的，这是现实世界数据科学的一个重要方面。在这个时代，知道如何构建数据应用程序已经成为数据科学家的一项基本技能。

这本书解决了机器学*中模型部署过程的复杂性，并为解决这个问题提供了一个框架。这本书的主要焦点是创建一个易于理解的指南，帮助人们浏览开发基于 ML 的应用程序的过程。作者关注了模型部署的以下几个方面:

• 计划 ML 应用并确定成功标准。
• 部署过程和缺陷
• 微调 ML 模型
• 在部署阶段后监控模型

这本书推荐给有一些行业经验的数据科学家，他们也希望进入产品开发领域。还需要精通 Python 编程。

结论

在本文中，我谈到了一些帮助我成为更好的数据科学从业者的书籍，我希望这些书籍也能帮助其他数据科学家。显然还有很多书我想提及，所以我可能会写另一篇类似的文章。我也总是乐于接触新书，所以如果你有任何建议，请在回复中提出。

[## 使用 Streamlit 创建多页面应用程序(高效！)

towardsdatascience.com](/creating-multipage-applications-using-streamlit-efficiently-b58a58134030)

会让你大吃一惊的 7 个 Python 单句程序

原文：https://towardsdatascience.com/7-python-one-liners-that-will-blow-your-mind-479d5b2ab93a

少即是多？

摄影Lanty 摄影 Unsplash

一句话这个术语来自喜剧，其中一个笑话用一句台词来表达。一个好的一行程序据说是有意义的和简洁的。这个概念也存在于编程中。Python 一行程序是可以执行强大操作的简短程序。这在 Java 等其他语言中几乎是不可能的，所以它被认为是 Pythonic 的一个特性。

关于 Python 一行程序的争论

如果您是第一次看到一行程序，请记住 Python 一行程序是一把双刃剑。一方面，它让代码看起来很酷，这绝对是给你的同事或面试官留下深刻印象的一种方式。但另一方面，花哨的俏皮话可能会令人困惑，难以理解，并变成炫耀技能的一种方式。因此，在代码审查期间，一定会有一些争论。根据经验，一行程序在 Python 中非常受欢迎，但如果它走得太远，开始让人困惑，那么就该放弃它了。最终，您的代码需要具有可读性和可维护性。

无论如何，在本文中，我想给你一些可以提高代码质量的 Python 一行程序的实际例子。我还将向您展示一些有趣的俏皮话。无论如何，你必须知道用代码表达你的想法的所有可能的方式，这样你才能做出正确的决定。

交换两个变量

# normal
c = a
a = b
b = c# 1-liner
a,b = b,a

在正常情况下，当你交换两个变量时，你需要一个中间人。我在我的如何编写 Pythonic 代码文章中也提到了这个窍门。在 Python 中，一行就可以完成。右边是一个表达式，实际上是一个元组(b，a ),左边是表示元组中第一个和第二个变量的变量。

列表理解

result = []
for i in range(10):
    result.append(i**2)# use list comprehension
result = [i**2 for i in range(10)]

这是我在上一篇文章中提到的另一个 Pythonic 特性。它告诉 Python 如何处理列表中的每个元素。该列表包含for和if语句。例如:

#list comprehension with if
result = [i**2 for i in range(10) if i%2==0]#read file in one-line
[line.strip() for line in open(filename)]

列表/集合理解是一个如此强大的工具，每个人都必须知道它。它允许您编写优雅的代码，几乎和普通英语一样易读。每个列表理解包括 3 个要素:1)表达。任何有效的表达式，如i**2或line.strip()。2)成员。iterable 中的对象。3)可迭代。列表、集合、生成器或任何其他可迭代对象。

λ和映射函数

列表理解的下一个层次是 lambda 函数。查看从头开始学* Python Lambda。

与其他语言中添加功能的 lambda 形式不同，如果你懒得定义函数，Python lambdas 只是一种速记符号。

# traditional function with def
def sum(a, b):    
  return a + b# lambda function with name
sum_lambda = lambda x, y: x + y

Lambda 函数通常与 Python 高阶函数结合使用。有几个内置的高阶函数，如map、filter、reduce、sorted、sum、any、all。

map(lambda x:x**2, [i for i in range(3)]) 
# <map object at 0x105558a90>filter(lambda x: x % 2 == 0, [1, 2, 3])
# <filter object at 0x1056093d0>from functools import reduce
reduce(lambda x, y: x + y, [1, 2, 3])
# 6

值得注意的是，map和filter的返回是对象，不是函数的结果。如果想得到实际的结果，需要转换成类似list(map(lambda x:x**2, [i for i in range(3)])的列表。

打印时不换行

print是每种编程语言中最基本的语句之一。但是你看过 Python doc 中print接口的定义吗？

**print**(**objects*, *sep=' '*, *end='\n'*, *file=sys.stdout*, *flush=False*)

该功能打印对象，由sep分隔，后跟end。让我们来看看这个一行程序。

#for-loop
for i in range(1,5):
    print(i, end=" ")#one-liner
print(*range(1,5)) #1 2 3 4

由于print接受一个 iterable，我们可以直接使用*range(1,5)作为输入，它的输出与 for 循环相同。

海象

Walrus 操作符是 Python 3.8 以后的一个特性。它为表达式中间的赋值变量提供了新的语法:= 。是为了避免两次调用同一个函数。

这是 Python 文档中的一个例子。walrus operator 允许您在飞行途中进行计算，而不是预先单独计算。

# without walrus
discount = 0.0
mo = re.search(r'(\d+)% discount', "10% discount")
if mo:
  discount = float(mo.group(1))/100.0# with walrus
discount = 0.0
if (mo := re.search(r'(\d+)% discount', "10% discount")):
  discount = float(mo.group(1)) / 100.0

但是我发现 walrus 在 for/while 循环中非常有用，因为代码看起来非常整洁，就像普通的英语一样。

# without walrus
f = open("source/a.txt")
line = f.readline()
while line != '':
    print(line)
    line = f.readline()# with walrus
f = open("f.txt")
while (line := f.readline()) != '':
    print(line)

斐波纳契

好了，现在让我们来看看一些奇特的例子。你知道你可以用一行代码编写斐波那契算法吗？挺神奇的！

#for-loop
def fib(x):
    if x <= 2:
        return 1
    return fib(x - 1) + fib(x - 2)#1-liner
fib = lambda x: x if x<=1 else fib(x-1) + fib(x-2)

快速排序

如果你认为你还能处理它，让我们看看下一个层次的一行程序。这是快速排序的一个单行版本，一个著名的排序算法。

q = lambda l: q([x for x in l[1:] if x <= l[0]]) + [l[0]] + q([x for x in l if x > l[0]]) if l else []
q([])

在我看来，看着它，了解 Python 有多强大很好玩，但不要在工作中使用它。当一行程序变得太长而无法容纳一行时，是时候放弃它了。

结论

像往常一样，我希望您发现这篇文章很有用，并且学到了一种提高代码质量的新方法。请随意与一行程序分享您的经验。干杯！

参考

https://www.amazon.com/Python-One-Liners-Concise-Eloquent-Professional/dp/1718500505

提高生产力的 7 个 Python 编程技巧

原文：https://towardsdatascience.com/7-python-programming-tips-to-improve-your-productivity-a57802f225b6

通过修正一些常见的不良编程实践，使您的 Python 编码更加有效和高效

由 Unsplash 上的窗口拍摄

编码可以带来很多乐趣！获得你正在处理的问题的解决方案或者独自解决一个复杂的项目是非常令人兴奋的。然而，在完成特定任务的过程中，你可能会发现自己陷入了几次停顿。

即使你成功地构建了你努力完成的项目，也有很大的机会可以进行一些改进，以提高代码的质量、代码的可读性、降低空间和时间的复杂性，以及实现整体高生产率的其他必要的修正。

由于 Python 编程语言在数据科学、人工智能、物联网等领域的大量使用，它在当今社会的重要性与日俱增，仅仅了解这种语言是不够的。用这种语言编码的专业知识是获得最佳结果的必要条件。因此，在开发复杂项目时，应该遵循一些最佳实践。

本文假设读者对 Python 编程有基本的了解。如果您对 Python 没有足够的了解，我建议您查看我以前的一些文章，在这些文章中，我更方便地讨论了这个主题。我也推荐看看我之前的一部作品，在那里我们讨论了从下面提供的链接学*编程的十个最好的网站。

</10-best-free-websites-to-learn-programming-939ec029009b>

提高生产率的 7 个最佳 Python 编程实践:

照片由马库斯·温克勒在 Unsplash 上拍摄

在本文的这一部分，我将分解七个最重要的实践，我认为程序员在用 Python 编程时应该利用它们来获得最有益的结果。这些技巧不仅有助于您简化编码和生活，还能让您的 Python 项目获得最高的性能提升。

1.利用 F 弦:

Python 编程语言提供的最有用和最基本的工具之一是 f 字符串。它用最少的语法简化了字符串连接的过程。用更简单的话来说，有了这些 string，您可以轻松地将变量和字符串字符的用法结合在一起。让我们用一个例子来理解这个概念的意义。

fruit = "Apple"
color = "Red"print("%s is tasty. It is %s in color." %(fruit, color))
print("{0} is tasty. It is {1} in color." .format(fruit, color))

输出:

Apple is tasty. It is Red in color.
Apple is tasty. It is Red in color.

让我们在 f 字符串的帮助下，尝试打印完全相同的语句。下面是执行类似操作的代码片段。

print(f"{fruit} is tasty. It is {color} in color.")

输出:

Apple is tasty. It is Red in color.

请注意，f 字符串在 Python 3.6 以上的版本中可用。Python 的所有其他版本都不支持 f 字符串，因此，必须使用更普通的字符串连接方法。虽然提到的另外两种使用“%s”符号的方法和 format 方法在某些情况下是可用的，但是随着语句长度和可读性的增加，程序员必须开始适应 f 字符串以获得更好的结果。

2.使用 Try 和 Except 语句:

我发现的另一个主要条件缺乏实用性的地方是使用了 try 和 except 语句，这在很多情况下会派上用场。假设程序员想在达到某个条件后继续运行一个执行，但是他们不能这样做，因为会显示一个错误消息。一旦显示错误信息，程序的运行时间将被终止。

为了避免这些情况，我们可以利用 try 和 except 代码块。当条件满足时，将执行 try 语句中的代码块，以在代码行中产生所需的结果。但是，当代码没有产生令人满意的结果或导致错误发生时，except 语句会捕获这些异常。让我们看一个代码片段来理解一个例子。

a = 10
b = 0try:
    c = a/b
    print(f"Division Successful, The Quotient Is {c}")

except:
    print("Zero Division Error Has Most Likely Occurred.")

输出:

Zero Division Error Has Most Likely Occurred.

上面的代码块很容易理解。当除法任务可能时，执行正常除法的过程。但是，对于特定的失败情况，将返回零错误异常。当您正在读取用户的音频或图像输入，并且希望等到用户输入他们的输入，并且在没有输入的情况下不终止程序时，此选项也很有用。我还建议检查一下特定的异常情况和可以添加到这些代码块中的“finally”语句。

3.列表理解:

我们知道 Python 中的列表数据结构是这种编程语言的一个重要方面。列表是 Python 中最重要的数据结构之一，因为它们是可变的，并且您可以用列表的正确功能构建许多项目。它们是一种有序的数据结构，列表中的每个元素都被分配了一个特定的索引号，通过该索引号可以对其进行访问。

利用列表中的单个 for 循环，列表理解有助于简化更复杂的代码块。列表理解提供了一种创建列表的简洁方法。它们最常见的应用是创建新的列表，其中每个元素都是应用于另一个序列或 iterable 的每个成员的一些操作的结果，或者创建满足特定条件的那些元素的子序列。让我们看一个成功利用这些列表理解的例子。

squares = []
for x in range(10):
    squares.append(x**2)squares

输出:

现在，让我们看看代码片段，它允许我们通过利用列表理解更容易地接收相同的输出。

squares = [i**2 for i in range(10)]
print(squares)

如果您有兴趣学*更多关于 Python 中的列表数据结构的知识，并掌握与该主题相关的所有基本概念，我建议您查看我以前的一篇文章，在这篇文章中，我非常详细地介绍了该主题。下面是博客的链接，可以了解更多关于这个概念的信息。

4.熟悉数学运算:

丹-克里斯蒂安·pădureț在 Unsplash 上拍摄的照片

在处理任何类型的编程时，很有可能你会遇到一些需要你运用数学技巧来解决的问题。无论您选择哪个领域，了解 Python 为用户提供的一些数学工具都是非常重要的。Python 编程简化了大多数数学运算。让我们探索一下数学的一些基本功能，每个 Python 程序员都必须知道如何使用这些功能。下面是一个代码片段，涵盖了大多数基本概念。

a = 10 
b = 5add = a + b 
sub = a - b
mult = a * b
div = a / b
floor_div = a//b
mod = a % b
exp = a ** b

输出:

Sum = 15
Difference = 5
Product = 50
Quotient = 2.0
Floor Division = 2
Reminder = 0
Exponential Operation = 100000

除了这些基本的数学运算，Python 还允许其程序员独占访问数学库，通过数学库可以进行一些数学计算。让我们看一个简单的示例代码片段，其中我们在导入数学库模块后，对 int 类型变量使用了一些数学函数。

import matha = 5.6print("The rounded value is:", round(a))
print("The ceiled value is:", math.ceil(a))
print("The floored value is:", math.floor(a))

输出:

The rounded value is: 6
The ceiled value is: 6
The floored value is: 5

我建议你去看看数学库的其他基本概念，它们可以让你完成大部分必要的数学计算。即使你在编码时没有从事机器学*或深度学*项目，数学也很重要。如果您有兴趣了解更多关于简化数学主题的知识，如机器学*的微分和积分，请通过下面提供的链接查看我以前的一篇文章。

5.利用多个 Python 文件:

维克多·塔拉舒克在 Unsplash 上拍摄的照片

在处理较大的项目时，很明显完成项目所需的行数可能会非常庞大。有时候，这些代码行的范围可以从几百到几千个代码语句。在处理这样的项目时，通常最好将内容划分到单独的文件中，类似于您如何利用函数和类来降低信誉并提高整体效率。

让我们考虑一个你选择构建的游戏项目的例子。对于这些类型的项目，最好是利用一些或更多的 Python 文件来相应地分离代码。您可以为实用程序、资产创建单独的 Python 文件，并以您认为合适的方式划分其他必要的功能。在主 Python 文件中，您可以导入所有其他编程文件并创建所需的代码。

另一个理解在创建项目时使用多个文件的好例子是当你设计一个网站的时候。当进行网站设计时，如果您试图运行任何类型的项目，如机器学*示例或任何类似的项目，最好创建一个 Python 文件来存储一些基本的代码相关元素，同时利用其他附加的 HTML、CSS 或 JavaScript 文件进行整体设计。

6.处理操作系统功能:

照片由 Artiom Vallat 在 Unsplash 上拍摄

对于最复杂的项目来说，最基本的主题之一就是能够遍历不同的工作文件和目录。为了管理和操作大量文件夹并获取所需文件，我们将使用 Python 编程中的“os”库模块。它允许开发者通过允许使用依赖于操作系统的功能的可移植方式来管理目录结构。

为了理解操作系统模块的基本用途，让我们看看 Python 编程中经常使用的一些关键组件。下面代码片段中讨论的大部分元素都是基本的操作系统功能，经常用于构建 Python 项目。熟悉它们对于创建更复杂的项目是必要的。

import os# get current working directory
cwd = os.getcwd()
print("Current Working Directory", cwd)# Join directories
parent_dir = "D:/Cool Projects/Blogs/"
current_dir = "7 best Python Programming Tips/"
final_path = os.path.join(parent_dir, current_dir)
print(final_path)# Make a new directory
os.mkdir(final_path + "test/")

Python 编程中还有其他几个操作系统命令。强烈建议开发人员熟悉这些基本功能，因为它们对于构建、创建和开发更复杂的项目非常重要，在这些项目中，您需要访问用户各自的操作系统来保存文件、访问所需的文件等等。

7.更好地使用调试技术:

当您最终在处理 Python 代码时遇到错误时，您通常会得到追踪到错误位置的特定行。这些错误可能是逻辑错误、语法错误或运行时警告。虽然大多数与语法相关的错误在设计良好的集成开发环境和一些分析的帮助下更容易修复，但长时间停留在代码中的某个特定点并不罕见。

现在，这给我们带来了一个问题，我们可以做些什么来改进我们的方法，以调试由编程引起的不可避免的错误。确保使用大量的打印声明，以确保您的项目或您计划的方法按预期进行。您可以注释掉这些语句或稍后删除它们，但是在处理项目时，请确保您正在使用它们。

理想情况下，一旦您对 Python 编程语言的工作原理有了基本的了解，最好从一个简单的文本编辑器(如 Python IDLE)切换到其他流行的 IDE，如 Pycharm 或 Visual Studio 代码(有 Kite 支持)，这将通过突出显示 IDE 解释错误可能发生的实例来帮助您识别较小的错误或有时较大的错误。

每当你在编程的某一点上停滞不前的时候，谷歌一下这个错误并查看一个像 GitHub 或 Stack Overflow 这样的网站总是一个好主意。您可能遇到的几乎每一个常见的 bug 或错误都可能已经有人遇到过了，这个有用的社区为这些常见问题提供了多种解决方案。

在调试 Python 代码时，程序员还可以利用其他一些工具来获得更好的结果。然而，Python 本身提供了一个令人惊叹的内置工具来成功调试 Python 代码。查看我以前的一篇关于 PDB (Python 调试器)库的文章，通过下面提供的链接，可以有效地修复 Python 代码中的错误。

结论:

多梅尼科·洛亚在 Unsplash 上拍摄的照片

如果说调试是去除软件 bug 的过程，那么编程一定是把 bug 放进去的过程。
—艾德斯特拉

一旦你理解了基础知识，编程表面上看起来很容易。然而，无论你成为多么专业的程序员，你总是会遇到一些问题，需要你在互联网上寻找一段代码或额外的功能。你仍然可能犯最愚蠢的错误，或者没有以最有效的方式编写代码来达到预期的结果。事后看来，虽然所有这些提到的约束本身都很好，但适应最佳编码策略仍然非常有益。

在本文中，我们讨论了提高 Python 编程效率的七种最佳方法。这篇博客中提到的要点是一些最好的技术，可以部署到您自己的代码和项目中，以提高所获得结果的生产率和整体效率。遵循这些提示将帮助您创建更有效的 Python 代码，以构建更好更大的项目！

如果你想在我的文章发表后第一时间得到通知，请点击下面的链接订阅邮件推荐。如果你希望支持其他作者和我，请订阅下面的链接。

https://bharath-k1297.medium.com/membership

如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。

看看我的一些与本文主题相关的文章，你可能也会喜欢阅读！

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

帮助您更快学*数据科学的 7 个快速简单的提示

原文：https://towardsdatascience.com/7-quick-and-easy-tips-that-will-help-you-learn-data-science-faster-ca2605d0a38c

#3 是一个游戏改变者，它将让你远离编码教程的炼狱

Jackman Chiu 在 Unsplash 上的照片

就像爬山一样，学*数据科学没有捷径可走。

数据科学是一门包罗万象的学科，它利用编程、数学和设计的精华，从数据中产生有助于世界做出决策的故事。不幸的是，这也意味着任何想要学* it 的人都需要付出大量的努力和数月的时间来掌握完成这些令人垂涎的工作所需的技能。

幸运的是，你可以使用一些小技巧来帮助你铺平前进的道路。虽然它们不会是难以捉摸的、不存在的、将你直接带到顶峰的缆车，但它们将帮助你更有效地学*，并可能节省你的学*时间。

1.在开始之前知道你需要学*什么

如上所述，数据科学是一门包罗万象的学科，涉及编程、数学、核心计算、设计、行业知识和讲故事。

因为在短时间内要学的东西太多了，所以在开始之前明确知道自己需要学什么是很重要的。

这意味着深入研究你想要的数据科学职业类型，并查看所有必需的技能。数据科学职业在日常任务、技术要求和所需知识方面有很大差异。例如，与只需要知道算术、代数和统计的小公司数据分析师相比，在学术界工作的数据科学家可能对微分方程和数论有更高的要求。

在这个时候，在决定你想要什么样的数据科学工作时，诚实地面对自己是很重要的。这将极大地影响你需要学*的内容，并有助于你根据下面的提示制定学*计划。虽然每份工作的具体内容会因资历和行业而异(在 Indeed 或 LinkedIn 上研究具体的工作要求是一个很好的主意，可以获得更清晰的画面)，但数据科学领域的工作通常可以分为三大类:数据科学家、数据分析师和数据工程师。

这里有一个资源可以帮助你决定在数据科学领域寻找什么样的职业:

以下是一些资源，可帮助您决定需要为数据科学中的每种工作类型学*什么:

FAANG的数据工程职位需要哪些技能

2.建立一个学*计划，只给你开始学*所需的知识

你在网上看到的大多数学*计划都是深入的、奢侈的路线图，涉及的知识广度和深度都很大，只有通过多年的学*才能完成。

这些计划没有认识到的是，你只需要足够的知识就能找到工作——其余的技能可以在以后学*。这意味着，你只需要学*足够的知识，就能完成数据科学家的日常任务，你对公司贡献的真正价值可以随着时间的推移而积累。虽然每个人都想从第一天起就产生巨大的影响，但更有可能的是，你将通过几个月的高质量工作和在职学*来扩大你的影响。

因此，你需要建立一个学*计划，只给你开始学*所需的知识——不多也不少。

这可以通过查看互联网上现有的学*计划来完成，并减少脂肪。通过将您需要学*的内容减少到最低限度，您可以减少进入数据科学所需的时间，并腾出更多时间来掌握您将需要的确切技能。

3.从第一天开始做项目

正确学*数据科学的关键是将理论和实践结合起来。

虽然这听起来像是学*过程的不必要的延伸，但用实践经验来支持你的理论知识将有助于巩固你的学*，并将为更有效的知识保留打开大门。

将你的理论知识转化为实践知识的诀窍是从第一天开始做项目。每个项目不一定要改变生活，但它应该包含一些你学到的新东西。

例如，第一天你学*用 Python 写代码背后的理论知识。你那天的项目可能是编写代码，将“Hello World”打印到终端上。第二天，你将学*如何计算样本的平均值。你那天的项目可能是在你的 Python 程序中输入一列数字，并计算它们的平均值。第三天，您将学*数据可视化背后的理论。你那天的任务是想象你的数字列表，以及它的含义。

虽然这是一个愚蠢的例子，但它给了你一个将理论知识应用于实际问题的基础。在你的学*经历结束时，你可能会发现你的程序从第一天开始就把“Hello World”打印到控制台上，现在给你一个从互联网上搜集的数据的完整分析。关键是每天坚持推进你的项目，并推动自己吸收新知识。

4.找出你的学*弱点，不惜一切代价避免它们

如果自学揭示了一件事，那就是我们都有学*上的弱点，这些弱点使我们无法发挥最大的学*潜力。

学*上的弱点可能包括一些简单的事情，比如容易分心，不能按照时间表学*，或者学*方式不适合你的优势。

这些问题可能会很快导致您精心制定的数据科学学*计划的瓦解，还可能导致该过程花费不必要的时间。因此，你必须确定你的学*弱点，并准备一个计划来帮助你不惜一切代价避免这些弱点。

一些避免学*弱点的想法包括把你的手机放在另一个房间，使用网站拦截器，提前计划每天的学*时间表并把它放在显眼的位置，对不同的学*风格进行研究。

这里有一个很好的资源，可以帮助你了解更多关于学*风格以及如何改进自主学*过程的信息:

https://uwaterloo.ca/centre-for-teaching-excellence/teaching-resources/teaching-tips/tips-students/self-knowledge/understanding-your-learning-style

5.学*如何正确打字

虽然很少遇到只能用食指打字的数据科学爱好者，但重要的是要注意，学*如何正确打字可能意味着您完成学*的速度有天壤之别。

学*如何正确打字不仅包括学*如何不用看和以更快的速度打字，还包括学*在写笔记或代码时可以节省按键的快捷键。

这听起来可能是一个微不足道的任务，但人们发现，打字速度提高 20%可以让你每天节省 35 分钟，相当于每年节省 213 个小时，这仅仅是因为打字更快。

这里有一些资源可以帮助您学*如何更快地键入和使用键盘快捷键:

https://www.ratatype.com/learn/ https://dev.to/macmacky/my-vscode-shortcuts-settings-and-extensions-for-productivity-3chd

6.通过自动化你的学*计划来避免生产力下降

自学数据科学是一项棘手的任务，需要纪律、毅力和精神毅力。当你的学科不是每天 100%运行时，生产力就会下降，这会导致你完成数据科学研究的速度降低。

因为我们都是人，不能期望每天都以最高的效率运行，所以找到解决这个问题的方法很重要。解决办法？自动化你的学*时间表，这样你就不会浪费时间去计算你每天要学什么。

这可以通过编写一个简单的 Python 脚本来完成，该脚本为您提供了当天将要学*的内容的待办事项列表。虽然这需要一点预先的计划和几个小时的编码，但它可以通过向您展示当天您需要学*的内容来节省您每天宝贵的时间。想想看:如果你每天花 20-30 分钟来决定学什么，你可能会每周损失 2-3 个小时，而这些时间本来是可以用来学*的。

这里有一个很好的资源可以让你开始自动化你的日常事务，并且可以扩展到自动化你的学*计划:

7.承诺每天阅读一篇关于数据科学的文章

没有什么比阅读你感兴趣的文学作品更能激发大脑的活力。

没有外界输入的学*计划可能会变得单调乏味。因此，通过阅读讨论该领域最新想法的文章来保持数据科学的活力是至关重要的。

每天花 30 分钟阅读可以让你的大脑得到喘息的机会，一旦你重新开始学*，它就会变得更有效率，还可以激发想法或引发概念性的理解。在社交、求职甚至撰写自己的数据科学内容时，掌握最新的数据科学知识也是一项需要保持的宝贵技能。

以下是一些提供日常数据科学内容的资源:

https://towardsdatascience.com https://www.datasciencecentral.com/

最后的想法

学*数据科学可能是一项不值得羡慕的任务，需要耐心、决心和自律。虽然这可能是一个乏味的过程，上面列出的简单技巧可以通过提高你的学*效率和确保你有一个明确的旅行方向来大大加快这个过程。

关键要点

• 清楚地知道你需要从一开始就学*什么，在头脑中有一个清晰的画面，你希望你的数据科学工作看起来像什么。
• 精简你的学*计划，确保你只学*找工作所需的基本技能——其余的可以以后再学。
• 从项目的第一天开始，将你的理论知识转化为实践经验。
• 找出你学*的最佳方式，避免浪费时间。
• 学*如何正确打字和使用键盘快捷键来提高学*效率。
• 自动化你的学*时间表，减少浪费的时间去找出每天要学的东西。
• 让你的大脑休息一下，通过每天阅读一篇关于数据科学的文章来补充能量。

订阅将我的故事直接发送到您的收件箱:故事订阅

成为会员，使用我的推荐链接可以无限制地访问媒体(我将收取少量佣金，不需要你额外付费):媒体会员

强化学*的 7 个实际应用

原文：https://towardsdatascience.com/7-real-world-applications-of-reinforcement-learning-f80955cefcd5

我们离日常生活中的强化学*有多*？以下是强化学*的真实使用案例——从机器人到个性化你的网飞建议。

迈克尔·泽兹奇在 Unsplash 上的照片

强化学*是机器学*的一个子域，其中代理通过与他们的环境交互来学*做出决策。最*，它通过在围棋、象棋、Dota 和星际争霸 2 等游戏中实现超人水平的能力而广受欢迎。

在本文中，我列出了强化学*在现实世界用例中应用的 7 个例子。

1.使用 Wayve 的自动驾驶

由叶夫根尼·切博塔列夫在 Unsplash 拍摄

历史上，自动驾驶汽车的方法包括定义逻辑规则。这可能很难扩展到无人驾驶汽车在公共道路上可能遇到的无数情况。这就是深度强化学*可能有前途的地方。

Wayve 是一家总部位于英国的公司，自 2018 年以来一直在公共道路上测试自动驾驶汽车。在他们的论文“在一天内学会驾驶”中，他们描述了他们如何使用深度强化学*来训练一个使用单目图像作为输入的模型。奖励是车辆在没有安全驾驶员控制的情况下行驶的距离。该模型在驾驶模拟中进行训练，然后在现实世界中部署在 250 米的路段上。

虽然他们的自动驾驶汽车技术继续发展，但他们声称强化学*继续在运动规划中发挥作用(确保目标点和目的点之间存在可行的路径)。

2.个性化您的网飞推荐

自由股票在 Unsplash 上的照片

网飞在 190 多个国家拥有 2 亿用户。对于这些用户，网飞的目标是呈现最具娱乐性和相关性的视频。在贾斯汀·巴西利科(网飞大学机器学*和推荐系统主任)的演讲“网飞解释了推荐和个性化”中，他描述了他们如何通过结合四种关键方法来实现这一点:深度学*、因果关系、强化学*和目标。

面临的挑战是训练一个模型，优化用户的长期满意度，而不是即时满意度。强化学*可以通过引入探索来提供帮助，探索可以让模型随着时间的推移学*新的兴趣。

Justin 指出，由于高维数和大问题空间，强化学*在这种情况下很难应用。为了帮助这一点，该团队开发了手风琴——一种用于长期训练的模拟器。

3.优化沃尔玛的库存水平

照片由Marques Thomas @ querysprout . com在 Unsplash 上拍摄

沃尔玛是世界上最大的零售商和杂货商，拥有超过 4650 家店铺。沃尔玛必须不断转移未售出的库存，为新的更畅销的商品腾出空间。转移多余库存的通常策略是实施降价。这是一项费时费力的工作，需要逐个商店多次对打折商品重新贴标签。

为了降低运营成本，沃尔玛创造了一种优化降价的算法。该算法接收数据，包括销售数据、运营成本、商品的数量和类型，以及商品必须销售的动态时间框架。

该方法应用数据分析、强化学*和动态优化来为每个产品做出自动化决策，并为每个商店量身定制。其结果是降低了运营成本，增加了销售额，一些商店的待搬迁库存销售额增加了 15%。

4.使用 search.io 改进搜索引擎结果

诺德伍德主题公司在 Unsplash 上拍摄的照片

Search.io 是一款用于站内搜索查询的 AI 搜索引擎。他们使用“按等级学*”和强化学*技术来改进他们的搜索等级算法。

学*排名涉及使用机器学*模型，该模型在基于相关性评分的查询-结果对的数据集上训练。这种技术的一个缺点是输入(查询结果对得分)保持静态。

强化学*使用点击、销售、注册等形式的反馈，随着时间的推移帮助改进搜索算法。在这种情况下应用强化学*的挑战在于，搜索结果的质量通常从低开始，并且在开始满足客户期望之前需要时间和数据。

5.用 OpenAI 的 WebGPT 改进语言模型

李·坎贝尔在 Unsplash 上的照片

GPT-3 是一种用于生成类人文本的语言模型。这些语言模型的缺点是，在执行需要模糊的现实世界知识的任务时，倾向于“幻觉”信息。为了改善这一点，OpenAI 教 GPT-3 使用基于文本的网络浏览器。该模型能够从网页中搜索和收集信息，并使用这些信息来撰写开放式问题的答案。

该模型最初使用人类演示来训练。在此基础上，通过训练一个奖励模型来预测人类的偏好，可以提高模型的有用性和准确性。然后，使用强化学*或拒绝采样，针对该奖励模型对系统进行优化。结果是该系统被发现比 GPT-3 更“真实”。

6.利用 IBM 的 DSX 平台在金融市场上进行交易

在 Unsplash 上由 Austin Distel 拍摄的照片

由于高货币风险，金融行业一直不愿意应用机器学*。在这篇文章中，IBM 描述了一个用强化学*训练的交易系统。

在这种情况下，强化学*的优势在于能够学*做出预测，以解释算法的行为对市场状态产生的任何影响。这种反馈循环允许算法随着时间的推移自动调整，不断使其更加强大和适应性更强。回报函数是基于每笔交易的盈利或亏损。

该模型根据买入并持有策略和 ARIMA-GARCH(一种预测模型)进行评估。他们发现该模型能够捕捉头肩顶模式，这是一个不平凡的壮举。

7.加州大学伯克利分校的机器人技术

照片由帕特里西奥·达瓦洛斯在 Unsplash 上拍摄

开发机器人控制器是一项具有挑战性的任务。典型的方法包括仔细的建模，但是当暴露在意外的情况和环境中时容易失败。

加州大学伯克利分校的一个团队试图通过使用强化学*训练一个真正的双足机器人来解决这个问题。该团队能够开发出一种模型，从而对名为 Cassie 的机器人进行更加多样化和鲁棒的行走控制。

部署的模型能够执行各种行为，例如在现实世界中改变行走高度、快速行走、侧向行走和转弯。它对机器人本身(例如部分损坏的电机)和环境(例如地面摩擦力的变化和从不同方向被推动)的变化也很鲁棒。你可以在这个视频中观看凯西的行动。

结论

虽然强化学*在现实世界中的应用仍处于早期阶段，但我希望这个列表突出了该技术的潜力以及迄今为止已经发生的令人兴奋的进展。随着数据收集、模拟、处理能力和研究的不断发展，谁知道我们在未来几年还会看到什么？

如果强化学*领域让你兴奋，这里有一些我的其他文章，你可能会觉得有用:

• open ai 健身房出租车强化学*介绍
• 深度强化学*的实践介绍
• 8+强化学*项目创意

感谢阅读！

您应该将 Jupyterlab 用于数据科学的 7 个理由

原文：https://towardsdatascience.com/7-reasons-why-you-should-use-jupyterlab-for-data-science-7c2a3db8755a

米利安·耶西耶在 Unsplash 上拍摄的照片

Jupyter Notebook 已经成为任何使用 Python 的数据科学家和数据分析师的主要工具。事实上，大多数在线 Python 和数据科学课程都是使用 Jupyter Notebook 教授的。虽然 Jupyter Notebook 很简单，对初学者也很友好，但当你在进行一个大型数据分析项目时，它不再是最好的工具。

在本文中，我将与您分享 7 个令人信服的理由，说明您为什么应该在下一个数据项目中从 Jupyter 笔记本电脑转向 Jupyterlab。

Jupyterlab 是什么？

首先，你可能已经知道也可能不知道——JupyterLab 是最新的基于 web 的交互式开发环境，用于笔记本、代码和数据。通过 conda 或 pip 安装 Jupyterlab 非常简单:

conda install -c conda-forge jupyterlab

或者，

pip install jupyterlab

注意，如果你在 MacOS 上使用 Python 3，你应该使用 pip3 而不是 pip 。

为什么是 Jupyterlab？

Jupyterlab 比传统的 Jupyter 笔记本更好的原因有很多。以下是最重要的原因，我相信其中一些会让你大吃一惊。

#1.一切尽在一景

如果你曾经厌倦了仅仅为了查看根目录或者在 Jupyter 笔记本上创建一个新文件而不得不在不同的标签之间切换，我听你的！这是 Jupyterlab 将为您的数据科学生活带来的关键变化之一。它将传统的笔记本、文本编辑器、终端和目录查看器都放在一个视图下。它让一切对你来说更有效率，创造一个你会喜欢的更统一的体验。现在，您可以在笔记本上工作，与终端交互，并在 markdown 文件上书写，所有这些都可以同时进行！

Jupyterlab 发射器。

#2.观看 CSV 要好得多

您可能已经注意到，在 Jupyter notebook 中，我们只能将 CSV 文件作为文本文件查看。但是在 Jupyterlab 中，可以像在 Excel 中一样以表格格式查看。我还尝试在 Jupyterlab 中打开几百万行的大型 CSV 文件，它运行得非常好，没有任何故障。所以下次如果你因为超过一百万行而无法在 Excel 中打开 CSV 文件，你知道去哪里找。

在 Jupyterlab 中查看 CSV 文件。

不仅是 CSV，您还可以查看 PDF 文件、图片和 markdown 文件，这在您阅读 PDF 文档的同时处理项目报告时非常方便。

#3.笔记本电脑的第二视图

这绝对是我在 Jupyterlab 中最喜欢的功能之一:你可以为你的笔记本创建第二个视图，并将这两个视图并排放置进行比较。您只需右键单击您的笔记本标签标题，并选择 笔记本 的新视图。

好的一面是，您对其中一个视图所做的任何更改也将反映在另一个视图中，并保存在笔记本中！

Jupyterlab 笔记本电脑的第二个视图。

当我的笔记本变得更大，我不得不来回滚动时，我发现这个功能非常有用。例如，如果我想检查列的名称，不必一次又一次地打印数据帧或滚动到实际打印的位置，我只需在一个单独的视图中打开数据帧。这避免了我写多余的代码，也节省了我大量的滚动时间。

#4.拆分视图

第四个点是上面第三个点的延伸，但是这一次我们可以通过拖拽来进一步分割视图。现在，您可以同时查看和处理多个笔记本和文件。我只是喜欢一切都是如此灵活，它真的感觉像一个真正的 IDE，我可以控制我想如何安排我的工作流程。老实说，我一点也不怀念以前在 Jupyter 笔记本上工作时痛苦地切换标签的感觉。

Jupyterlab 中的拆分视图。

#5.重新排列笔记本中的单元格

第五点是你可以拖动单元格来重新排列它们。这在经典的 Jupiter 笔记本中是不可能的，这也是当我清理和重新排列我的笔记本以使其对观众有意义时最让我恼火的地方。这会让你大吃一惊，在拆分视图中，你可以将一个单元格从一个笔记本拖到另一个笔记本，这就是你如何将一个单元格从一个笔记本复制到另一个笔记本。你可能通常不需要这样做，但如果你这样做了，这是非常整洁的。

拖放单元格以在笔记本中重新排列它们，或者将单元格从一个笔记本复制到另一个笔记本。

#6.代码控制台

如果我们想测试一段代码或者检查一个函数返回什么，我们通常求助于代码控制台，因为这是运行代码最简单的方式。代码控制台实际上是为测试代码而设计的地方，因为它们提供了交互性。在 Jupyterlab 中，你所要做的就是在笔记本任意位置点击右键，选择 笔记本 新控制台。然后，您可以前往代码控制台，在这里使用您的代码。

使用代码控制台进行测试。

#7.降价同步预览

通常，您会希望与社区共享您的数据科学项目，或者简单地记录您所做的工作。在 Jupyter 笔记本上写 Markdown 是相当令人沮丧的，因为你必须一次又一次地运行你的单元格，仅仅是为了预览和检查文件看起来如何，以及你是否得到了正确的语法。在 Jupyterlab 中，您可以通过右键单击文件上的任意位置并选择 显示 markdown 预览 来预览 markdown 文件，现在您可以看到您的文档正在随着您的键入而实时更新。这个功能非常方便，可以节省你写文档的时间。

预览 Jupyterlab 中的降价功能。

Jupyterlab 已经成为我最喜欢的 Python 数据分析工具，我认为如果您是新手，您绝对应该尝试一下，看看它如何改进您的分析工作流或您的 Python 学*体验。这绝对是我为提高 Python 的工作效率所做的最好的事情之一。

如果你已经看到了这篇文章的这一部分，感谢你的阅读和关注！你也可以在下面我的 Youtube 频道找到这篇文章的视频版本。

如果你喜欢我关于数据科学的内容(以及偶尔与技术相关的东西和个人成长)，别忘了在 Medium 上关注我。

想要连接？ 你可以在LinkedIn，Youtube，或者GitHub上联系我。我随时欢迎快速聊天或虚拟咖啡:)。

增强 Matplotlib 图表的 7 种简单方法

原文：https://towardsdatascience.com/7-simple-ways-to-enhance-your-matplotlib-charts-a232823efed9

用这些简单的步骤改善你的 matplotlib 图形

照片由 Mikael Blomkvist 拍摄:https://www . pexels . com/photo/person-holding-white-ipad-on-brown-wood-table-6476589/

Matplotlib 是 Python 中最流行的数据可视化库之一。它通常是学* python 时遇到的第一个数据可视化库。尽管您可以用几行代码生成图形，但创建的图通常很差，视觉上没有吸引力，没有信息。

为了解决这个问题，我们可以用几行额外的代码来增强图形的交流能力。在本文中，我们将介绍如何从一个基本的 matplotlib 散点图转变为一个对最终用户/读者来说更具视觉吸引力和信息量更大的散点图。

增强 matplotlib 图形之前和之后。图片由作者提供。

导入库和数据

在以下如何在 matplotlib 中增强散点图的示例中，我们将使用一个更大数据集的子集，该数据集是 Xeek 和 FORCE 2020 (Bormann 等人，2020) 举办的机器学*竞赛的一部分。它是在挪威政府的 NOLD 2.0 许可下发布的，详细信息可以在这里找到:挪威开放政府数据许可(NLOD) 2.0 。

完整的数据集可以通过以下链接获得:https://doi.org/10.5281/zenodo.4351155。

对于本教程，我们将需要导入 matplotlib 和 pandas 。

然后使用 pandas 方法read_csv()将数据读入数据帧。我们还将计算一个密度孔隙度列，用于绘制中子孔隙度。

import pandas as pd
import matplotlib.pyplot as pltdf = pd.read_csv('data/Xeek_Well_15-9-15.csv')df['DPHI'] = (2.65 - df['RHOB'])/1.65df.describe()

当我们运行上面的代码时，我们用新的 DPHI 列得到下面的数据摘要。

Xeek / Force 2020 数据集中 15/9–15 井测井测量的统计总结。图片由作者提供。

创造一个基本情节

数据成功加载后，我们可以创建第一个散点图。为此，我们将在 x 轴上绘制中子孔隙度(NPHI ),在 y 轴上绘制密度孔隙度(DPHI)。

我们还会将图形大小设置为 10 x 8。

plt.figure(figsize=(10,8))plt.scatter(df['NPHI'], df['DPHI'])

通过这两行代码，我们得到了上面的图。看起来很淡，不是吗？让我们添加一些颜色，使它在视觉上更具吸引力，并允许我们获得一些数据的洞察力。

用第三个变量添加颜色

为此，我们将通过伽马射线(GR)对数据进行着色，并将颜色范围设置在 0 到 100 之间(vmin和vmax参数)。

我们需要使用plt.colorbar()来显示颜色条。

最后，我们将通过调用plt.xlim()和plt.ylim()将图表的 x 和 y 限制设置为从 0 到 0.8。这将使两个轴都从 0 开始，并达到最大值 0.8。

plt.figure(figsize=(10,8))plt.scatter(df['NPHI'], df['DPHI'], c=df['GR'], vmin=0, vmax=100, cmap='viridis_r')
plt.xlim(0, 0.8)
plt.ylim(0, 0.8)
plt.colorbar()

我们使用的彩色地图是反过来的绿色。这种颜色图在高值和低值之间提供了很好的对比，同时保持了均匀性并且是色盲友好的。

当我们运行上面的代码时，我们得到了下面的图。

matplotlib 的基本散点图显示密度孔隙度与中子孔隙度。图片由作者提供。

如果你想了解更多关于选择彩色地图的信息，以及为什么有些彩色地图并不适合所有人，那么我强烈推荐你在这里观看这个视频:

从图中删除脊线

我们要做的下一个改变是去掉围绕着图的黑框。这个盒子的每一面被称为一个书脊。移除顶部和右侧有助于使我们的情节更清晰，更具视觉吸引力。

我们可以通过调用plt.gca().spines[side].set_visible(False)来删除右轴和顶轴，这里边可以是顶部、右侧、左侧或底部。

plt.figure(figsize=(10,8))plt.scatter(df['NPHI'], df['DPHI'], c=df['GR'], vmin=0, vmax=100, cmap='viridis_r')
plt.xlim(0, 0.8)
plt.ylim(0, 0.8)
plt.colorbar()plt.gca().spines['top'].set_visible(False)
plt.gca().spines['right'].set_visible(False)

在去除了这些刺之后，我们的情节看起来更干净，也更少杂乱。此外，颜色条现在感觉像是情节的一部分，而不是看起来被分割开来。

移除右侧和顶部脊线(边缘)后的 Matplotlib 散点图。图片由作者提供。

添加标题和轴标签

当查看上面的散点图时，我们可能知道每个轴代表什么，但其他人如何理解这个图是关于什么的，颜色代表什么，什么相对于什么绘制？

为我们的绘图添加标题和轴标签是创建有效可视化的重要部分。这些可以简单地通过使用:plt.xlabel、plt.ylabel和plt.title来添加。在每个函数中，我们传递想要显示的文本和任何字体属性，比如字体大小。

此外，在标签中包含测量单位也是一种很好的做法。这有助于读者更好地理解情节。

plt.figure(figsize=(10,8))plt.scatter(df['NPHI'], df['DPHI'], c=df['GR'], vmin=0, vmax=100, cmap='viridis_r')
plt.xlim(0, 0.8)
plt.ylim(0, 0.8)
plt.colorbar(label='Gamma Ray (API)')plt.gca().spines['top'].set_visible(False)
plt.gca().spines['right'].set_visible(False)plt.title('Density Porosity vs Neutron Porosity Scatter Plot', fontsize=14, fontweight='bold')
plt.xlabel('Neutron Porosity (dec)')
plt.ylabel('Density Porosity (dec)')
plt.show()

当我们运行上面的代码时，我们得到了下面的图。我们马上就知道轴上画的是什么，图表是关于什么的，颜色范围代表什么。

向坐标轴添加标题和标签后的散点图。图片由作者提供。

添加模糊网格(可选)

根据绘图的目的，我们可能希望向添加一个网格，以便图表的读者可以直观方便地浏览绘图。如果我们想从图中定量提取值，这一点尤其重要。然而，有些时候网格线被认为是“垃圾”,最好不要使用。例如，如果您只想显示数据集中的总体趋势，而不想让读者过多关注原始值。

在本例中，我们将添加一些模糊的网格线，以便它们不会过多地影响数据。为此，我们需要在代码中添加plt.grid()。

plt.figure(figsize=(10,8))plt.scatter(df['NPHI'], df['DPHI'], c=df['GR'], vmin=0, vmax=100, cmap='viridis_r')
plt.xlim(0, 0.8)
plt.ylim(0, 0.8)
plt.colorbar(label='Gamma Ray (API)')plt.gca().spines['top'].set_visible(False)
plt.gca().spines['right'].set_visible(False)plt.title('Density Porosity vs Neutron Porosity Scatter Plot', fontsize=14, fontweight='bold')
plt.xlabel('Neutron Porosity (dec)')
plt.ylabel('Density Porosity (dec)')plt.grid()
plt.show()

然而，当我们这样做的时候，我们会发现网格线出现在我们的图的顶部，它看起来并不吸引人。

添加网格线后的散点图。图片由作者提供。

为了在后面绘制网格线，我们需要移动plt.grid()线，使其在调用plt.scatter()之前，并为zorder添加参数。这控制了图表组件的绘制顺序。应注意，这些值是相对于图上的其他项目而言的。

对于网格，我们希望zorder值小于我们用于散点图的值。在这个例子中，我将网格的zorder设为 1，散点图的zorder设为 2。

此外，我们将为网格添加更多的参数，即控制网格线颜色的color和控制网格线透明度的alpha。

plt.figure(figsize=(10,8))
plt.grid(color='lightgray', alpha=0.5, zorder=1)plt.scatter(df['NPHI'], df['DPHI'], c=df['GR'], vmin=0, vmax=100, cmap='viridis_r', zorder=2)
plt.xlim(0, 0.8)
plt.ylim(0, 0.8)
plt.colorbar(label='Gamma Ray (API)')plt.gca().spines['top'].set_visible(False)
plt.gca().spines['right'].set_visible(False)plt.title('Density Porosity vs Neutron Porosity Scatter Plot', fontsize=14, fontweight='bold')
plt.xlabel('Neutron Porosity (dec)')
plt.ylabel('Density Porosity (dec)')plt.show()

这将返回一个更好的情节，网格线不会太分散注意力。

网格线移动到图的后面和数据后面后的 Matplotlib 散点图。图片由作者提供。

更改磅值

下一步是改变每个数据点的大小。目前，这些点相对较大，在我们拥有高密度数据的地方，数据点可以相互重叠。

解决这个问题的一个方法是减少数据点的大小。这是通过plt.scatter()功能中的s参数实现的。在本例中，我们将它设置为 5。

plt.figure(figsize=(10,8))
plt.grid(color='lightgray', alpha=0.5, zorder=1)plt.scatter(df['NPHI'], df['DPHI'], c=df['GR'], vmin=0, vmax=100, zorder=2, s=5, cmap='viridis_r')
plt.xlim(0, 0.8)
plt.ylim(0, 0.8)
plt.colorbar(label='Gamma Ray (API)')plt.gca().spines['top'].set_visible(False)
plt.gca().spines['right'].set_visible(False)plt.title('Density Porosity vs Neutron Porosity Scatter Plot', fontsize=14, fontweight='bold')
plt.xlabel('Neutron Porosity (dec)')
plt.ylabel('Density Porosity (dec)')
plt.show()

当我们运行这段代码时，我们可以看到数据中更多的变化，并更好地了解一个点的真实位置。

更改点大小后的 matplotlib 散点图。图片由作者提供。

注释点

当创建数据可视化时，我们经常想把读者的注意力吸引到特定的兴趣点上。这可能包括异常数据点或关键结果。

要添加注释，我们可以使用下面一行:

plt.annotate('Text We Want to Display', xy=(x,y), xytext=(x_of_text, y_of_text)

其中xy是图表上我们想要指向的点，而xytext是文本的位置。

如果我们愿意，我们还可以包含一个从文本指向图表上的点的箭头。如果文本注释离所讨论的点较远，这很有用。

为了进一步突出显示一个点或者在一个点不存在的地方添加一个点，我们可以在现有的散点图之上添加另一个散点图，并传入一个 x 和 y 值，以及相应的颜色和样式。

plt.figure(figsize=(10,8))plt.grid(color='lightgray', alpha=0.5, zorder=1)plt.scatter(df['NPHI'], df['DPHI'], c=df['GR'], vmin=0, vmax=100, cmap='viridis_r',
            zorder=2, s=5)
plt.xlim(0, 0.8)
plt.ylim(0, 0.8)
plt.colorbar(label='Gamma Ray (API)')plt.gca().spines['top'].set_visible(False)
plt.gca().spines['right'].set_visible(False)plt.title('Density Porosity vs Neutron Porosity Scatter Plot', fontsize=14, fontweight='bold')
plt.xlabel('Neutron Porosity (dec)')
plt.ylabel('Density Porosity (dec)')plt.scatter(0.42 ,0.17, color='red', marker='o', s=100, zorder=3)
plt.annotate('Shale Point', xy=(0.42 ,0.17), xytext=(0.5, 0.05),
             fontsize=12, fontweight='bold', 
             arrowprops=dict(arrowstyle='->',lw=3), zorder=4)plt.show()

当这段代码运行时，我们得到了下面的图。我们可以看到，一个潜在的页岩点在图上用红色圆圈突出显示，一个清晰的注释用箭头指向它。

matplotlib 密度孔隙度与中子孔隙度散点图，带文本注释和箭头。图片由作者提供。

请注意，所选点仅用于突出显示目的，需要更详细的解释来确定该数据中的真实页岩点。

突出感兴趣的领域

如果我们想要突出显示绘图上的整个区域，我们可以添加一个简单的矩形(或另一个形状)来给该区域加阴影。

为此，我们需要从matplotlib.patches导入Rectangle，然后调用下面的代码行。

plt.gca().add_patch(Rectangle((x_position, y_position), width, height, alpha=0.2, color='yellow'))

x_position和y_position代表矩形的左下角。从那里开始添加宽度和高度。

我们还可以添加一些文本来表明该区域代表什么:

plt.text(x_position, y_position, s='Text You Want to Display, fontsize=12, fontweight='bold', ha='center', color='grey')

ha用于水平定位文本。如果设置为居中，则 x_position 和 y_position 代表文本字符串的中心。如果设置为 left，则 x_position 和 y_position 表示该文本字符串的左侧边缘。

from matplotlib.patches import Rectangleplt.figure(figsize=(10,8))plt.grid(color='lightgray', alpha=0.5, zorder=1)plt.scatter(df['NPHI'], df['DPHI'], c=df['GR'], vmin=0, vmax=100, cmap='viridis_r',
            zorder=2, s=5)
plt.xlim(0, 0.8)
plt.ylim(0, 0.8)
plt.colorbar(label='Gamma Ray (API)')plt.gca().spines['top'].set_visible(False)
plt.gca().spines['right'].set_visible(False)plt.title('Density Porosity vs Neutron Porosity Scatter Plot', fontsize=14, fontweight='bold')
plt.xlabel('Neutron Porosity (dec)')
plt.ylabel('Density Porosity (dec)')plt.scatter(0.42 ,0.17, color='red', marker='o', s=100, zorder=3)
plt.annotate('Shale Point', xy=(0.42 ,0.17), xytext=(0.5, 0.05),
             fontsize=12, fontweight='bold', 
             arrowprops=dict(arrowstyle='->',lw=3), zorder=4)plt.text(0.6, 0.75, s='Possible Washout Effects', fontsize=12, fontweight='bold', ha='center', color='grey')plt.gca().add_patch(Rectangle((0.4, 0.4), 0.4, 0.4, alpha=0.2, color='yellow'))plt.show()

这段代码返回下面的图，其中我们突出显示了我们的区域。

添加阴影区域后的 matplotlib 散点图，以突出冲刷造成的潜在影响。图片由作者提供。

摘要

在这个简短的教程中，我们看到了如何从一个由 matplotlib 生成的基本散点图到一个可读性更强、视觉效果更好的散点图。这表明，通过一点点工作，我们可以得到一个更好的情节，我们可以与他人分享，并轻松地让我们的故事。

我们已经看到了如何通过去除脊柱、添加网格线以帮助定性分析、添加标题和标签以显示我们正在显示的内容，以及突出我们想要引起读者注意的关键点来消除不必要的混乱。

增强 matplotlib 图形之前和之后。图片由作者提供。

感谢阅读。在你走之前，你一定要订阅我的内容，把我的文章放到你的收件箱里。 你可以在这里做！*或者，您也可以* 注册我的简讯 免费将更多内容直接发送到您的收件箱。

其次，通过注册会员，你可以获得完整的媒介体验，并支持我和其他成千上万的作家。每月只需花费你 5 美元，你就可以接触到所有精彩的媒体文章，也有机会通过写作赚钱。如果你用 我的链接报名，你直接用你的一部分费用支持我，不会多花你多少钱。如果你这样做了，非常感谢你的支持！

参考

博尔曼，彼得，奥桑德，彼得，迪里布，法哈德，曼拉尔，投降，&迪辛顿，彼得。(2020).机器学*竞赛 FORCE 2020 井测井和岩相数据集[数据集]。芝诺多。http://doi.org/10.5281/zenodo.4351156

7 个空间特性，提升您的 NLP 管道并节省时间

原文：https://towardsdatascience.com/7-spacy-features-to-boost-your-nlp-pipelines-and-save-time-9e12d18c3742

除了简单的命名实体识别任务之外，我从未使用过 spaCy。男孩，我错了。

由 Lucas Kapla 在 Unsplash 上拍摄的照片

我最*开始重新访问 spaCy 库，并尝试它的许多核心功能来执行低级语言任务。

如果您从未听说过它，spaCy 是一个现代自然语言处理库，它处理+66 种语言，提供最先进的速度，并具有用于命名实体识别任务、词性标记、实体链接等的各种组件。此外，它很容易通过定制组件和属性进行扩展。

作者截图

在本帖中，我将与您分享 7 个技巧，以充分利用 spaCy 并利用它来工业化和扩展您的 NLP 管道。

如果你是一名从事 NLP 项目的数据科学家，并且愿意改进自己的工具箱并学*新的强大工具，你绝对应该看看这篇文章。

事不宜迟，让我们来看看🔍

PS* :如果你是 spaCy 新手，推荐你看一下这个 链接 就可以入门了。

https://medium.com/membership/@ahmedbesbes

1—强大的管道:您需要的一切都封装在 Doc 对象中

我很少见过界面如此简单易用的库。

假设您想要接收一堆文本文档，应用一些处理，如标记化和词汇化，然后预测命名实体、词性(POS)标记和语法依赖。

如果您使用传统的库，这看起来像是一个接一个地调用和管道传输大量的后续函数。

然而，使用 spaCy，所有这些都可以在 3 行代码中完成。

• 进口空间(咄！)
• 加载预训练模型
• 将文本列表传递给模型并提取文档对象

**import spacy****nlp = spacy.load("en_core_news_sm")
texts = ... # texts loaded in a list
docs = nlp(docs)**

Doc 对象里面是什么？我听到你问了。

当你把一个文本传递给nlp对象时，spaCy 会把它变成一个Doc对象。

此 Doc 对象是处理管道的结果，该管道包括:

• 标记化
• 词性标注
• 依存句法分析
• 命名实体识别(NER)
• 以及更多您可以自己设计的定制组件

作者截图

更具体地说，Doc 对象是由令牌化算法产生的令牌对象列表。每个令牌将每个步骤的输出存储为一个属性。

以下是其中的一些:

• text:令牌的文本
• dep_:句法依存关系
• tag_:词性标签
• lemma_:令牌的基本形式，没有屈折后缀

要了解更多关于令牌属性以及可以从 Doc 对象中获得什么，请查看这个页面。

2 —一流的处理速度

spaCy 旨在处理大量文档，并用于工业环境。因此，它提供了对多处理的内置支持。

如果你在nlp对象中放入一大串文本，你不会得到任何加速。

为了加速推理，您必须使用nlp.pipe函数，设置n_process参数来利用多处理，并设置batch_size参数来启用批处理。

小心，批处理并不总是有效的。这取决于您的数据集和您使用的模型。查看此页面了解更多信息

仅启用您正在使用的组件

还有另一个技巧可以用来加速 spaCy 处理管道:当实例化 spaCy 对象时，只启用您感兴趣的组件。

例如，如果您想使用命名实体识别器组件，您不一定需要位置标记器或依赖解析器，因为这些组件独立于 NER 组件。

当加载一个模型时，您可以使用disable参数来禁用这些组件。

**import spacy****nlp = spacy.load("en_core_web_sm", disable=["tagger", "parser"])**

3-使用 Matcher 类进行高级模式匹配

有一个 spaCy 功能我忽略了很长时间，尽管它的效率令人难以置信，但我从未真正使用过。是匹配器类。

这个类是一个规则匹配引擎，允许您基于模式匹配标记序列。从概念上讲，这类似于正则表达式，但是这个类处理更复杂的依赖于标记注释(即属性)的模式。

spaCy 图案是什么样子的？

令牌模式是一个字典，它结合了令牌属性、操作符和属性。

如果您不确定什么是操作符和属性，请继续关注我，让我们看看下面的例子。

→假设我们想在您的文档中匹配单词“Hello”。(非常简单，但也很公平)

为此，我们将编写一个使用令牌文本属性的模式。

**pattern = [
   {"TEXT": "Hello"}
]**

然后，将此模式添加到匹配器中。

**from spacy.matcher import Matcher****nlp = spacy.load("en_core_web_sm")****matcher = Matcher(nlp.vocab)
matcher.add("HelloPattern", [pattern])**

一旦空间文档被传递给匹配器，我们将获得元组形式的匹配(match_id，token_start，token_end)。

**doc = nlp("Hello my friend!")****matcher(doc)****[(10496072603676489703, 0, 1)]**

以下是完整的代码:

→如果我们想使模式不区分大小写，我们可以使用 LOWER 键:

**{"LOWER": "hello"}**

→现在，假设我想匹配一个文档中的所有名词。简单！用 POS 键就行了。在这种情况下，依赖空间令牌的属性是有用的。

**{"POS": "NOUN"}**

→如果想匹配所有以“爱”或“恨”为基础形式(即 lemma)的表征怎么办？使用与IN属性结合的 LEMMA 键。

**{"LEMMA": {"IN": ["love", "hate"]}}**

→你如何发现连续出现的两个名词？您使用 POS 属性并将其与{n}操作符结合使用。

**{"POS": "PROPN", "OP": "{2}"}**

到目前为止，我们只看到了单个令牌的模式。当您将多个模式堆叠在一起以匹配标记序列(即短语)时，实际上会变得更加有趣。

下面是 Matcher 类派上用场的一些用例:

• 匹配两个连续令牌“买入/卖出”和“比特币/dogecoin”的组合。

• 根据标记的位置属性匹配标记序列。这为什么有用？想象一下，出于某种原因，您希望匹配由一个形容词后跟一个名词组成的表达式(快乐的电影，糟糕的餐馆)

**pattern = [
    {"POS": "ADJ"},
    {"POS": "NOUN"}, 
]**

• 匹配日期，电子邮件，网址，数字

**pattern_email = [["LIKE_EMAIL": True]]
pattern_url = [["LIKE_URL": True]]
pattern_num = [["LIKE_NUM": True]]**

• 匹配基于其引理和词性标签的记号

**# Matches "love cats" or "likes flowers"
pattern_lemma_pos = [
    {"LEMMA": {"IN": ["like", "love"]}}, 
    {"POS": "NOUN"}
]**

• 根据令牌的长度匹配令牌

**pattern_length = [
    {"LENGTH": {">=": 10}}
]**

要了解更多关于匹配引擎的功能，请看这个页面。这将为您提供属性、操作符、属性的语法以及如何组合它们的详细概述。

您还可以使用基于规则的匹配器浏览器，它允许您交互式地创建令牌模式，并在您的输入文本上显示检测结果。

作者截图

4—将知识库与统计模型相结合，以改进 NER 任务

通过使用 spaCy 提供的 EntityRuler 类，您可以基于命名实体的字典构建自己的命名实体识别器。

→这意味着如果您需要检测一堆文档中的这些命名实体， 您不必实现搜索逻辑或正则表达式来匹配它们 。您只需要将模式传递给 EntityRuler，将实体标尺作为组件添加到管道中，并将文档传递给 spaCy 来为您处理检测。

当使用 EntityRuler 时，您可以在空白模型中注入模式，也可以在已经有 NER 组件的模型中注入模式:在这种情况下，spaCy 完成将统计模型的预测与基于规则的模式相结合的工作。

让我们来说明这两种情况；

****→例#1:给空白模型添加实体标尺从一个空白的英文模型开始，给它添加图案。在这个例子中，我们采用了一个没有 NER 模块的空间模型，并向它传递了一个我们希望检测为命名实体的模式列表。

这是一个很简单的例子，看起来不是很有用。实际上，当您添加一个带有不同标签的大型模式列表(例如，疾病列表、化合物、技术术语、非常具体的组织名称等)时，实体标尺非常有用。)预训练的模型不能检测(即训练的)。

→示例#2:向具有 NER 组件的模型添加实体标尺 从具有经过训练(即统计)的 NER 组件的 spaCy 英语模型开始，并向其添加先前未检测到的附加实体的模式列表。潜在的目标是提高模型的性能。

以下是添加实体标尺改善统计模型预测的一个用例:检测生物医学实体🧪.

模式是从知识库和本体中构建和管理的，然后被注入到空间模型中。

为什么不重新培训一名新的 NER 模特呢？

虽然这似乎是一种有效的方法，但重新训练模型肯定效率较低，因为它需要大量的数据。事实上，你感兴趣的新模式必须出现在不同的上下文中(如句子)，这样模型才能捕捉到它们。在一个训练好的模型上添加这些模式通常是一个快速的胜利。

在哪里放置实体标尺，在 NER 组件之前还是之后？

实体标尺可以添加在 NER 组件之前或之后。

→如果将其添加到 NER 组件之前，该组件将考虑现有的实体跨度，并围绕其调整预测。在大多数情况下，这是 spaCy 推荐的方式。

→如果添加在 NER 组件之后，实体标尺将仅在跨度不与现有实体重叠时添加跨度到doc.ents。

您可以在此了解更多关于组合统计模型和实体标尺的信息。

5 —范围、实体和依赖关系的丰富可视化

spaCy 提供了内置的可视化工具(displaCy 和 displaCy-ent ),能够显示有趣的标记属性，如词性(POS)标记、语法依赖图、命名实体或范围。

这种可视化是直接从浏览器或 jupyter 笔记本上完成的。

我个人经常使用 displaCy 来可视化命名实体，以便调试我的模型。

→这里有一个显示命名实体可视化工具的演示

作者截图

→这里有一个演示依赖关系图的显示可视化工具(水平滚动以可视化整个图形)

作者截图

下面是一个可视化实体的代码示例。

如果您从笔记本上运行它，您将得到以下输出:

作者截图

如果您将样式属性设置为dep，您将得到以下输出:

作者截图

【Streamlit 用户奖励📍spaCy 可视化工具也可以嵌入到 Streamlit 应用程序中。如果你像我一样是 Streamlit 的粉丝，你可以使用 spacy-streamlit ，这是一个帮助你将 spacy 可视化集成到你的 web 应用程序中的包。

6—多种预训练语言模型

spaCy 为许多语言提供了预训练模型(+66)。对于每种语言，都有不同大小的模型，这取决于它们的架构和训练语料库。

例如，如果你对英语感兴趣，你会发现这三种不同的模式:

• 网络版(12MB)
• 网络版(40MB)
• en _ core _ web _ LG(560 米)

这些模型在内存消耗和准确性方面(略有)不同。它们都支持相同的任务。有趣的是，只有中型和大型模型有词向量(即嵌入)。

可以在这里 了解型号 。

您还可以在这里查看社区使用 spaCy 所产生的内容。

7—丰富的开源项目和插件库

spaCy 有一个充满活力的社区，它在构建开源项目、培训语言模型和开发可视化或高级语言任务的插件方面做了令人惊叹的工作。

希望你能在这个页面上找到这些参考项目。

这有助于开始或激发灵感，并且在大多数情况下，有助于解决官方图书馆尚未解决的问题。

资源

• https://medium . com/besedo-engineering/spacy-matchers-guidelines-c 38207 f 884d 7
• https://course.spacy.io/en/chapter1
• https://www.youtube.com/watch?v=BXzFAjtenHM&ab _ channel =爆炸
• https://youtu.be/mDiC6at1TlE
• https://medium . com/forward-data-science/in-depth-spacy-tutorial-for-初学者-nlp-2ba4d961328f

感谢阅读🙏

如果你做到了这一步，我想感谢你的时间，我希望你和我一样喜欢这些关于空间的小贴士。

spaCy 非常强大，这篇文章绝不是对它所有特性的详尽概述。显然，在培训管道和与变形金刚库的集成之间还有更多的内容要涵盖。

但这可能是另一篇文章的主题。

不管怎样，我今天就到这里了。下次见！👋

新到中？你可以每月订阅 5 美元，并解锁各种主题的无限文章(技术、设计、创业……)你可以通过点击我的推荐链接来支持我

**https://ahmedbesbes.medium.com/membership **

从头开始实现转换器

原文：https://towardsdatascience.com/7-things-you-didnt-know-about-the-transformer-a70d93ced6b2

关于变压器，你可能不知道的 7 件令人惊讶的事情

在 Unsplash 上由 Silas Baisch 拍摄

介绍

为了更好地熟悉变形金刚的具体细节，我决定从头开始实现“注意力是你所需要的全部”一文中的原始架构。我以为我知道所有该知道的事情，但是令我自己惊讶的是，我遇到了几个意想不到的实现细节，这让我更好地理解了所有事情是如何在幕后工作的。

这篇文章的目的不是讨论整个实现——有很多很好的资源可以讨论——而是为了强调 我发现的特别令人惊讶或有见地的七件事，以及你可能不知道的。我将通过使用超级链接机器人指向我的代码中的特定行来具体说明这一点🤖(试试吧！).代码应该很容易理解:它有很好的文档记录，并使用 Github 动作自动进行单元测试和类型检查。

这个帖子的结构很简单。前三点围绕实施多头关注；最后四个是关于其他组件的。我假设你对变形金刚和多头注意力有概念上的熟悉(如果没有；一个很好的起点是图解变形金刚，它极大地帮助了我更好地理解多头注意力背后的机制。也是涉及最多的一点。

**Table of Contents**[Introduction](#29a2)
1\. [Multi-head attention is implemented with one weight matrix](#81ba)
2\. [The dimensionality of the key, query and value vectors is not a hyperparameter](#e7de)
3\. [Scaling in dot-product attention avoids extremely small gradients](#5d70)
4\. [The source embedding, target embedding AND pre-softmax linear share the same weight matrix](#1f65)
5\. [During inference we perform a decoder forward pass for every token; during training we perform a single forward pass for the entire sequence](#0c55)
6\. [Transformers can handle arbitrarily long sequences, in theory](#f5d8)
7\. [Transformers are residual streams](#7ea0)
[Wrapping up](#2830)

1。多头注意力通过一个权重矩阵实现

在我们深入研究之前；回想一下，对于每个注意力头，我们需要一个查询、键以及每个输入令牌的值向量。然后我们计算注意力分数作为一个查询和句子中所有关键向量之间的比例点积的软最大值🤖)。下面的等式一次计算每个输入标记的所有值向量的注意力加权平均值。 Q 是为所有输入令牌堆叠 q 查询向量的矩阵； K 和 V 对 k ey 和Vvalue 向量做同样的事情。

那么，我们如何有效地为所有令牌和头文件获得这些查询、键和值向量？事实证明，我们可以使用单个权重矩阵 W一次性完成这个。这不同于人们在阅读论文或图解变压器后可能期望的三个投影权重矩阵。让我们来看看这是如何工作的。

假设我们的输入由4个记号组成:[“嘿”、“怎么样”、“是”、“你”]，我们的嵌入大小是512。暂时忽略批处理，让X作为行的4x512矩阵堆栈令牌嵌入。

设W是一个有512行和1536列的权重矩阵。我们现在将放大这个512x1536维度权重矩阵W ( 🤖 )找出为什么我们需要1536维度和如何乘以X得到矩阵P(对于 p 项目)包含我们需要的所有查询、键和值向量。(代码中的🤖我称这个矩阵为qkv

多头注意力背后的矩阵乘法

得到的4x1536矩阵P=X@W中的每一个元素都是 X【一个嵌入】中的一个行向量和 W中的一个列向量 【某些权重】之间的(换句话说:点积)的和。****

作为矩阵乘法的复*，下图展示了当两个3x3矩阵相乘时，如何计算简单3x3矩阵的第一个元素。同样的策略也适用于我们更大的矩阵X和W。

举例:如何计算 3×3 矩阵乘法中的第一个元素？作者和 Rosalie Gubbels 的图片。

所以，我们投影矩阵中第i行P[i, :]的每个元素都是i第令牌 嵌入 X[i, :]和W中权重列之一的线性组合。这意味着我们可以简单地在权重矩阵W中堆叠更多的列，从而为嵌入在X中的每个令牌创建更多独立的线性组合(标量)。换句话说，P中的每个元素都是嵌入在X中的令牌的不同标量“视图或“摘要”，由W中的一列加权。这是理解带有“查询”、“键”和“值”向量的八个“头”如何在P的每一行中隐藏的关键。

揭示注意力和查询、关键和价值向量

我们可以将我们为W选择的1536列(最终作为P中的列数)分解到1536 = 8 * 3 * 64中。在 P中，我们现在发现了隐藏在每一行中的八个头，每一个都有三个 64 维向量！每个这样的“向量”或“块”由嵌入令牌的64不同加权线性组合组成，我们选择 以某种方式解释。你可以在下图中看到P的可视化表示以及如何分解它。分解也发生在代码中(🤖)。

P=X@W 包含所有头部的查询、键和值投影。作者和 Rosalie Gubbels 的图片。

对于一个批次中的多个句子，简单地想象一下在 P“后面”的第三维，它将 2D 矩阵变成 3D 矩阵。

编码器-解码器注意

对于编码器-解码器来说，这稍微复杂一些。回想一下，编码器-解码器关注允许每个解码器关注由最顶端的编码器输出的嵌入

为了引起编码器-解码器的注意，我们需要查询向量用于解码器令牌嵌入，以及键和值向量用于最顶层的编码器令牌嵌入。这就是为什么我们将W一分为二——一个512x512和一个512x1024矩阵(🤖 ) —并执行两个独立的投影:一个从编码器的嵌入中获得键和值向量(🤖)，一个用于获得解码器嵌入的查询向量(🤖)。

最后，注意我们确实需要第二个权重矩阵 ( 🤖)在多头注意力中混合来自每个头的值向量，并获得每个令牌的单个上下文嵌入(🤖)。

2.关键字、查询和值向量的维度是而不是超参数

我从未真正考虑过这个问题，但我总是假设查询、键和值向量的维度是一个超参数。结果，被动态设置为嵌入维数除以头数 : qkv_dim = embed_dim/num_heads = 512/8 = 64 ( 🤖)。

这似乎是 Vaswani 等人的设计选择，以保持多头注意力中的参数数量恒定，而不管选择的头数。虽然您可能认为参数的数量会随着头的增加而增加，但实际情况是查询、键和值向量的维度会减少。

如果我们看看上面显示R=X@W的图，并想象单头注意力，这就变得很清楚了。X、W和R中的元素数量保持八个头不变，但是我们解释R 中的元素的方式改变了。使用单个头，我们每个令牌嵌入只有一个查询、键和值投影(P中的一行)，它们将跨越每行的三分之一:512元素—与嵌入大小相同。

你可能会想，多头有什么意义呢？嗯，Vaswani 等人认为，它允许头部捕捉不同的“表征子空间”。比如说；一个头可能跟踪句法关系，而另一个更关注位置信息。有相当多的工作调查这在实践中是否确实发生，例如在翻译中。事实上，几年前在总结中我自己也做了一些这方面的工作。

3。点积注意力的缩放避免了极小的梯度

类似于前一点，我从来没有真正思考过为什么我们用一些常数来划分注意力逻辑🤖但是这实际上很简单。

回想一下，每个 logit 都是一个查询和一个关键向量之间的点积(即元素乘积之和)的结果。因此，更大的维度数qkv_dim会导致该总和中更多的乘积——导致注意力逻辑中更高的方差。正如我们在下面的例子中看到的，对具有高方差的 logits 进行 softmax 变换会导致极小的输出概率——因此微小的梯度。

4.源嵌入、目标嵌入和预 softmax 线性共享相同的权重矩阵

我们现在从多头注意力转移到“权重绑定”——序列到序列模型的常见做法。我发现这很有趣，因为嵌入权重矩阵实际上弥补了相对于模型其余部分的巨大数量的参数。给定 30k 令牌的词汇表和 512 的嵌入大小，这个矩阵包含1530 万个参数！

想象一下有三个这样的矩阵:一个将源标记索引映射到嵌入，一个将目标标记映射到嵌入，一个将解码器的每个最顶层上下文化标记嵌入映射到目标词汇表(前 softmax 线性层)上的逻辑。是啊；这给我们留下了 4600 万个参数。

重量捆绑:三个红色方块共享相同的重量矩阵。作者和 Rosalie Gubbels 的图片。

在代码中你可以看到我初始化了主 transformer 类中的一个嵌入层(🤖)，我用它作为编码器嵌入(￠￠)，解码器嵌入(🤖)和解码器预软最大变换权重(🤖)。

5.在推理过程中，我们为每个令牌执行一次解码器前向传递；在训练中，我们在整个序列中执行一次向前传球

这一点对某些人来说可能是显而易见的——尤其是那些从事序列到序列任务的人——但是对于理解一个变形人实际上是如何被训练的却至关重要。

推理

假设我们处于推理模式，在这种模式下，我们自回归(一个接一个)预测目标令牌。转换器总是输出批中每个令牌的词汇分布。基于批次中最后一个令牌索引的的输出分布预测下一个令牌🤖****)。这意味着我们基本上抛弃所有先前指数的所有输出分布。

培训和教师强制

这与我们使用老师强迫的培训形成对比。在训练期间，我们只执行一次正向通过解码器，而不管序列长度 ( 🤖)。我们(老师) 强制——一次性喂完整批。这给了我们所有下一个令牌预测，为此我们计算平均损失。

注意每个标记预测都是基于先前的地面实况标记，而不是先前预测的标记！还要注意，这种单次前向传递等同于仅使用地面真实令牌作为输入并忽略先前预测的自回归解码(！)，但效率要高得多。我们使用一个注意力** 掩码来限制解码器自我注意力模块关注未来令牌(标签)并作弊。**

我认为，认识到这种称为教师强制的训练方式不仅适用于翻译模型，也适用于最受欢迎的预训练自回归语言模型，如 GPT-3，是很有用的。

6.理论上，变压器可以处理任意长的序列…

…然而，实际上，多头注意力具有[计算和内存需求](https://ai.googleblog.com/2021/03/constructing-transformers-for-longer.html#:~:text=With commonly available current hardware,summarization or genome fragment classification)，将序列长度限制在 512 个令牌左右。事实上，像 BERT 这样的模型对输入序列长度施加了硬限制，因为它们使用学*嵌入而不是正弦编码。这些学*到的位置嵌入类似于令牌嵌入，并且类似地仅适用于达到某个数量的预定义位置集(例如，对于 BERT 为 512)。

7.变形金刚是残余流

说到最后一点。我喜欢把一个变压器想象成多个“剩余流”。这类似于 LSTM 如何在逐个处理新令牌的同时保持从左到右的水平“内存流”，并通过门来调节信息流。

在一个 transformer 中，这个流不是跨令牌横向 运行，而是跨层(例如编码器)和子层(即多头关注和全连接层)纵向** 。每个子层使用剩余连接简单地将信息添加到剩余流中。这篇是一篇非常棒的博文，更详细地讨论了剩余流，而这篇是一篇很酷的论文，利用了“垂直递归”的概念。**

这个剩余流的结果是中间令牌表示的维数在所有(子)层中必须相同，因为剩余连接增加了** 两个向量(编码器中的例子:🤖)。最重要的是，因为编码器(和类似的解码器)层相互堆叠，它们的输出形状必须与输入形状匹配。**

正在总结…

感谢你阅读这篇文章！如果你喜欢它，有问题，或者发现了错误，请告诉我。你可以在推特上给我发消息，或者在 LinkedIn 上联系我。看看我在 jorisbaan.nl/posts 的其他博客。

尽管我写的代码很容易理解(它有很好的文档记录，经过单元测试和类型检查),请在实践中使用官方的 PyTorch 实现😁。

感谢 David Stap 提出从零开始实现变形金刚的想法，感谢 Dennis Ulmer 和 Elisa Bassignana 对本文的反馈，感谢 Lucas de Haas 的 bug 搜索会议和 Rosalie Gubbels 的视觉创作。我寻找灵感的一些伟大资源是 PyTorch transformer 教程和实现；菲利普·利佩的《变形金刚》教程；亚历山大·拉什的带注释的变形金刚和杰伊·阿拉玛的带插图的变形金刚。

让您的数据分析更加稳健的 7 个技巧

原文：https://towardsdatascience.com/7-tips-to-avoid-public-embarrassment-as-a-data-analyst-caec8f701e42

增强对结果的信心，建立更强大的个人品牌

在 Unsplash 上由 Ameer Basheer 拍摄的照片

想象一下:你一直在这个庞大的项目上努力工作。你刚刚完成了这副牌——在这一点上，这不再是一个演示，这是一种艺术。形象化是崇高的，故事简单易懂，建议是合乎逻辑的。重要的一天终于来了，你开始向关键决策者展示。你的开场白非常精彩，每个人都被吸引住了。

但是在第二张幻灯片进行到一半时，有人举手告诉你，他们在几周前别人做的另一个演示中看到了完全不同的数字。恐怖！你的心流中断，手心冒汗，膝盖发软，手臂沉重——你知道那首歌是怎么唱的。

在一些公司，这可能是相当普遍的。这可能有多种原因:糟糕的知识管理系统、缺乏数据分析的协作工具、缺乏质量检查等。为了避免这种情况发生在你身上，这里有 7 个建议:

#1:非技术领域的专家是你最好的朋友

• 非技术型中小企业可以对你正在研究的现象提供不同的视角。通过和他们一起看真实的例子，或者让他们解释一些数据点，你可以了解他们的决策过程，他们重视什么“特征”，或者他们认为什么是预期的或意外的。
• 它们还可以为您提供许多关于总体市场发展的背景信息，以及总体业务决策如何影响您所看到的数据(例如，市场季节性、新产品发布带来的收入增长等)。).这些元素可以让你的学*更加全面。

#2:最有可能的是，某个地方已经有人在做类似的事情了

• 做一个内部的“文献综述”可以让你了解已经研究了什么，是谁研究的。它可以帮助你在已经完成的工作的基础上快速启动你的研究，并帮助你找到一个已经研究过相同现象的同行。一旦你确定了这个同伴，你就可以分享知识，并有可能把他们作为集思广益的伙伴。
• 也可以让你更好的定位自己的学*。如果你知道过去已经研究过的东西，你可以确保你不是在重复发明轮子，你实际上是在回答一些以前从未回答过的问题——而且对这些问题有更大的兴趣。

#3:如果好得难以置信...这很可能好得令人难以置信

• 如果你得到的结果与普遍的看法相反，假设你错了，并仔细检查你的查询和数据源。如果一切都检查过了，也让同行检查一下。
• 一旦你提出自己的主张，你的工作应该会得到很多关注——意想不到的结果经常会出现。会有很多审查，所以你要想尽一切办法，因为你不想成为那个因为一个不正确的结果而引发很多混乱的人。

#4:如果你想走得快，就一个人走。如果你想去很远的地方，一起去

虽然来到一个房间，用一个全新的&颠覆性的想法震撼每个人的头脑是“酷”的，但在现实生活中，这种情况很少发生。把你的伙伴带到你的学*中来总是更好的。通过这样做:

• 你要确保他们很好地理解你从哪里来，如何到达那里。
• 他们可以帮助你将研究引向一个能产生更大价值的地方。
• 他们可以帮助塑造你所讲述的故事，以确保这个故事能引起他们和他们管理层的共鸣。
• 您可以在流程的早期获得他们的认同，他们可以直接思考如何将您的发现付诸实施。

#5:每项研究都有漏洞——找到它们

就像你不会不先训练就去参加大型体育赛事一样，你也不应该不经过至少一次排练就去参加重要会议。找一个你信任的人，让他们挑战你的工作，会有很大的帮助。它不仅可以帮助你准备你的故事，还可以帮助你了解哪些论点/数据点是薄弱的。你甚至可以更进一步，让他们毁掉你的作品，对他们能找到的一切吹毛求疵——这样在演示当天就没有什么会让你感到惊讶了。

#6:不要让你的嘴说出的话超过你大脑认可的速度

• 如果你结束了演示，有人开始质疑你的结果，最好是先清楚地了解这个问题，做自己的研究，然后线下再来找这个人。
• 试图现场回答数字差异可能会导致你做出不正确的假设，你稍后必须纠正这些假设——随着时间的推移，这可能会损害你的可信度。

#7:事情从来没有那么简单

• 上面介绍中提到的场景通常会在最初看起来简单明了的研究中实现。
• 当这个问题非常简单时，为什么还要费心去做一个文献综述或者招募跨职能的合作伙伴或者让你的研究被审查呢？
• 不幸的是，这是错误发生的地方——这会损害你的内部信誉。
• 后退一步，理解提问的大致背景，这一点总是很重要的。如果不清楚数据将如何被使用，或者它将被呈现给谁，最好是谨慎行事

今天就为你的个人品牌投保吧！

遵循这些提示将会降低你犯错的风险，以及失去组织信任的风险——这是数据分析师最重要的事情。

关于如何降低犯错的风险，你有什么建议可以分享吗？请在评论区告诉我！

感谢阅读！

如果你觉得“有趣”,可以看看我的其他文章:

https://medium.com/@jolecoco/what-training-at-the-gym-teaches-you-about-training-models-931e5878dc14 https://medium.com/@jolecoco/how-to-choose-which-data-projects-to-work-on-c6b8310ac04e

接下来

在下一篇文章中，我将讨论自举——以及为什么我喜欢这种方法！

让你在学* Python 时有一个良好开端的 7 个技巧

原文：https://towardsdatascience.com/7-tips-to-get-you-off-to-a-great-start-when-learning-python-c878113b8082

从 5 年的 Python 技能开发中获得的经验教训

来自 Pixabay 的 StockSnap 图像。

你有没有从朋友那里或者网上听说过 Python，想尝试一下却不知道从何下手？如果是这样，那么这篇文章是给你的。

大约 5-6 年前，我处于非常相似的境地。作为我工作的一部分，我需要为软件包中的一些方程编写一个自定义脚本。这个脚本比简单的方程要复杂一些，我需要在其中包含适当的逻辑。这是我转向 Python 并拼凑出我的第一个脚本的时候。

这些年来，我的 Python 编程技能有了很大的提高，教授了许多关于这个主题的课程，并开设了一个 YouTube 频道来分享我所学到的东西。如果你想学* Python，这里有一些我一路走来学到的技巧，希望对你也有帮助。

1.参加一门课程——但不要太多

Udemy 上 Python 可用的课程示例。图片由作者提供。

在各种各样的平台上有许多课程( Udemy 、 Coursera 、 EdX 等)，将带你从一个完全的新手到相当有能力编写 Python 代码。

我强烈推荐参加 Python 初学者课程，该课程将带您了解基本知识，包括什么是函数、变量类型、流控制以及使用常见库，如 matplotlib 、 pandas 和 numpy 。然而，在完成那门课程后，我会建议你动手做你自己的项目。你最不希望的就是被困在一个“教程地狱”里，在那里你所做的一切就是看视频和运行练*脚本。

这并不是说应该避免更高级的教程和课程，而是在你完成基础课程后从事项目和现实生活中的问题可以让你巩固你的学*并建立你的基本技能。然后在未来的某个时候，你可以根据自己的需求，确定自己想上的具体的高级课程。

2.使用 GitHub 建立投资组合

GitHub 概要文件是展示您的项目和编码能力的好方法。图片由作者提供。

如果你正在寻找一个新的职业或寻找你的第一份 Python 编程工作，那么拥有一份你的工作作品集是向潜在雇主展示你所知道的和你所学到的技能的一个很好的方式。

许多程序员使用 GitHub 作为存储和展示他们的项目的地方，这是开始你的作品集的好地方。

一个 GitHub 作品集应该是一种展示你的技能的方式，当它们被应用于现实世界的问题时。值得记住的是，即使你可以使用 GitHub 来存储你的课程作业，除了表明你已经学*了 Python 的基础知识之外，这些并不能向雇主传达太多信息。对于这些，我建议建立一个单独的存储库，并将所有的课程笔记/脚本保存在子文件夹中。

建议您在学*之旅的早期开始一个文件夹，因为它会让您熟悉版本控制和代码项目管理。

3.获取 IDE

一个 Visual Studio 代码的例子，一个用于编写和管理 Python 代码的 IDE。图片由作者提供。

当你开始编写 Python 代码时，你可能会在 Jupyter 笔记本上学*。这是一个很好的工具，但是，总有一天你会需要集成开发环境(IDE)的功能。

Jupyter Notebooks 可以被视为一种工具，用于快速构建代码原型、创建快速可视化，以及创建包含代码和理论的动态文档，这些文档可以轻松传递给我们的数据科学同事。

随着你的 Python 代码开始变得更加复杂，你将开始受到笔记本系统工作方式的限制。IDE 允许您使用多个文件构建更复杂的程序，更有效地管理这些文件，并提供了许多工具来帮助您在保持一致性的同时加快编码速度。Python 有两种流行的 ide:py charm和 Visual Studio Code ，它们各有优缺点。

4.写/谈论你学到的东西

在您开始发展 Python 技能时，Medium 是分享您的学*和知识的好方法。图片由作者提供。

当我开始学* Python 的时候，我所做的只是从课程和文章中获取内容。有些从未被记住，最终被遗忘了。

如果你真的想巩固你的知识，那么写作或谈论你所学到的是一个很好的方法。当你开始用自己的话分享你在机器学*算法或 Python 代码上所学到的东西时，你不仅会展示你所知道的，还会识别你所不知道的。这可以引导你进行进一步的研究，扩大你的知识面。

除了分享你的知识并贴在互联网上，你也开始建立你的个人品牌和个人资料。这可能需要时间，但它确实有帮助，而且你永远不知道它会把你带到哪里。这可能是一份新工作，也可能是未来项目的新联系人。

有很多地方你可以通过写作来分享你的知识。我强烈建议用媒体写作，而不是个人博客，因为你更容易被人看到。此外，你还可以从阅读你作品的人那里兼职赚钱。

如果你喜欢通过视频分享，那么 YouTube 是一个很好的起点。去年，我在 YouTube 上开设了一个频道，专注于 Python 和机器学*在地球科学领域的应用。这是我走出舒适区的一大步，但迄今为止这是一个伟大的旅程。你可以看看下面我的 YouTube 频道，看看我过去一年的进步。

https://www.youtube.com/channel/UCn1O_4_ApzbYwrsUdRoMmOg

5.从事一个项目

来自真实 Python 网站的示例项目。图片由作者提供。

当你开始学*所有这些新功能、工具、代码片段等时，这一切都很好，但是，人类的大脑很容易忘记你最*学过的内容。

课程和教程涵盖的内容可能非常全面。它们涵盖了许多主题和功能，这些主题和功能在您的学*过程中的这个阶段可能并不立即需要。帮助巩固所学知识的一个很好的方法是做项目。项目通过将所学付诸实践，帮助你朝着学* Python 的目标努力。

有许多文章列出了对初学者有帮助的各种项目，包括制作简单的计算器到更复杂的应用程序，如井字游戏和自动化电子邮件。

查看下面的网站和文章，寻找一些开始的灵感。

• https://realpython.com/tutorials/projects/
• https://medium . com/coders-camp/60-python-projects-with-source-code-919 CD 8 a6 e 512
• https://www . freecodecamp . org/news/python-projects-for-初学者/

6.不要害怕谷歌

matplotlib 中更改刻度标签的 Google 搜索示例。图片由作者提供。

当你第一次开始学* Python 时，你可能会感到畏惧，你会看到许多其他程序员似乎能够以极快的速度从头开始编写代码。

事实上，当学* Python 或任何其他编程语言时，你不必记住你所学的所有东西或记住每一段语法。(大多数)开发人员并没有将他们所学的每一段代码片段和功能都记在脑子里。相反，当他们遇到新事物或遇到他们无法轻松解决的问题时，他们可能会求助于谷歌并搜索他们遇到的问题。大多数情况下，其他人会遇到同样的问题，并在 StackOverflow 或 Reddit 上询问这个问题。

但是，请注意，当你遇到一个答案时，目标不是复制和粘贴你找到的内容，而是尝试并理解所提供的解决方案。如果你将代码复制粘贴到商业应用程序中，代码扫描工具会将其标记为剽窃。

7.记录您的代码

使用注释记录代码的例子。图片由作者提供。

当你刚开始用 Python 编码时，你可能非常渴望编写代码并让它工作，最终你会得到 x，y，a，b 等变量名，这是非常容易理解和理解的。然而，当你回头再看这段代码的时候，你可能会挠头，不知道它到底在做什么。

我刚开始的时候也是类似的情况。当我回顾我几个月前写的一些代码时，我对它在做什么以及为什么我以某种方式写它感到困惑。在这种情况下，用注释、文档字符串和适当的变量名来记录代码会有很大的帮助，尤其是当其他人正在查看您的代码时。

注释是解释代码背后原因的好方法，文档字符串有助于解释函数正在做什么，以及它们需要什么才能运行。

确保编写代码文档是成为一名优秀 Python 程序员的重要组成部分。如果及早练*，它将成为你以后职业生涯中的第二天性。

如果您想了解如何记录您的代码，请查看下面的这篇文章。

</5-essential-tips-to-improve-the-readability-of-your-python-code-a1d5e62a4bf0>

感谢阅读。在你走之前，你一定要订阅我的内容，把我的文章放到你的收件箱里。 你可以在这里做！*或者，您可以* 注册我的简讯 免费获取更多内容直接发送到您的收件箱。

其次，通过注册会员，你可以获得完整的媒介体验，并支持我自己和成千上万的其他作家。它每个月只花你 5 美元，你可以完全接触到所有令人惊叹的媒体文章，也有机会用你的写作赚钱。如果你用 我的链接报名，你直接用你的一部分费用支持我，不会多花你多少钱。如果你这样做了，非常感谢你的支持！

Python 的 itertools 的 7 个有用例子

原文：https://towardsdatascience.com/7-useful-examples-of-pythons-itertools-e561dc9f15ca

通过灵活的实用函数和范例节省时间和代码

Python itertools库为处理可重复项提供了非常有用的实用函数。通过熟练掌握itertools函数，您可以以新的方式组合它们，并使用它们作为构建模块，用很少几行代码解决复杂的问题。在本文中，你将看到 7 个应用itertools函数的实例。

如果您想继续下去，确保导入itertools以及matplotlib、seaborn和numpy 用于涉及可视化的例子。

import itertools
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

1.用 cycle()制作重复序列

函数将无限重复你给它的任何 iterable。通过使用islice()函数，您可以获得任意长度的序列，其中包含您选择的重复子序列。您可以使用它来快速生成一些周期性数据。下面的代码创建了一个 20 项的列表，包含重复序列 0，2，1，3，…

data = list(itertools.islice(itertools.cycle([0, 2, 1, 3]), 0, 20))
sns.lineplot(x=range(len(data)), y=data)

作者图片

除了cycle()，你可能还会发现count()很有用，它只是在一个无限迭代器中从一个给定的数字向上计数。

2.用组合()获得集合的所有可能组合

假设你和你的朋友想要制定一个烹饪计划，每周两个人为整个团队做饭。有多少独特的厨师组合？这是数学组合的经典案例，用combinations()就能轻松得到答案。

names = ["Alice", "Bob", "Charlie", "Dora", "Evgenia", "Farhat"]
print(list(itertools.combinations(names, 2)))# [('Alice', 'Bob'),
#  ('Alice', 'Charlie'),
#  ('Alice', 'Dora'),
#  ('Alice', 'Evgenia'),
#  ('Alice', 'Farhat'),
#  ('Bob', 'Charlie'),
#  ('Bob', 'Dora'),
#  ('Bob', 'Evgenia'),
#  ('Bob', 'Farhat'),
#  ('Charlie', 'Dora'),
#  ('Charlie', 'Evgenia'),
#  ('Charlie', 'Farhat'),
#  ('Dora', 'Evgenia'),
#  ('Dora', 'Farhat'),
#  ('Evgenia', 'Farhat')]

组合还会告诉你一组 N 个人互相握手所需的独特握手的数量，或者 N 个变量的协方差值的数量。

3.用产品()替换嵌套循环

在一副扑克牌中，你有 13 种面值和 4 种花色，总共 52 张牌。大家可以看到，牌的总数是 13 和 4 的乘积，所有牌的集合是面值的集合和花色的集合的笛卡尔积。您可以使用product()功能快速获得所有扑克牌的列表，而无需诉诸循环。我经常发现使用product()比创建难以阅读的嵌套循环要优雅得多。

values = ["Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"]
suits = ["Hearts", "Diamonds", "Clubs", "Spades"]
print(list(itertools.product(values, suits)))

另一个例子是数据集。假设您有几种语言的数据集，对于每种语言，您都有一个测试、训练和验证集。您可以使用product()，而不是使用嵌套循环来表示尽可能多的文件名。

datasets = ["english", "spanish", "arabic", "chinese", "japanese"]
splits = ["train", "test", "validation"]for dataset, split in itertools.product(datasets, splits):
    print(f"{dataset}_{split}.txt")# english_train.txt
# english_test.txt
# english_validation.txt
# spanish_train.txt
# ...

4.使用带有 compress()的布尔索引从列表中选择数据

如果您使用过像pandas这样的数据科学库，您可能*惯于使用布尔索引来索引一个系列或数据帧。换句话说，您可以获取一系列布尔值，如[True, False, False, True, ...]，并选择系列或数据帧中的行，这样结果就只包括相应布尔值为True的行。那么，你知道你实际上也可以用 Python 列表和 iterables 做到这一点吗？假设您只想要字母表中每三个字母的列表。您可以使用compress()函数，它接受一个 iterable 和一个 iterable 的真/假(或 1/0)值，并执行布尔索引。下面的代码以两种不同的方式实现这一点，每一种都使用不同的先前见过的itertools函数作为助手。

import stringprint(list(itertools.compress(string.ascii_lowercase, itertools.cycle([1, 0, 0]))))
# ['a', 'd', 'g', 'j', 'm', 'p', 's', 'v', 'y']print(list(itertools.compress(string.ascii_lowercase, map(lambda x: x % 3 == 0, itertools.count()))))
# ['a', 'd', 'g', 'j', 'm', 'p', 's', 'v', 'y']

5.用 accumulate()计算累积和与积

这里有一个有趣的问题:给定一个长度为 N 的列表，您的任务是创建一个函数，该函数采用两个索引 I 和 j(使得 i < j ),并计算位于索引 I 和索引 j 之间的子列表中的项目的总和。您可以对列表进行什么样的预计算以使这些查询尽可能快？

accumulate()函数从开始到结束计算列表中项目的累积和(默认情况下)。下面的代码生成一个随机的整数数组，用accumulate()在一行中预先计算一个累积和列表，并使用这个预先计算的数组返回子列表问题的常数时间解决方案。

original_list = np.random.randint(0, 100, (100,))
cumulative_list = list(itertools.accumulate(original_list))def query(i, j):
    return cumulative_list[j] - cumulative_list[i]

您可以提供另一个函数作为accumulate()的参数来改变行为，这样您就可以很容易地计算累积积或一些其他函数。

6.用 Repeat()无限重复一个值

假设您想要创建一个以人名作为关键字的字典，除了您想要每个人在创建字典时最初都有一个特定的默认值。您可以遍历名称列表，并将默认值与每个名称相关联。一种更优雅的方式是使用dict()构造函数、zip()函数和itertools.repeat()。repeat()函数将简单地在一个无限迭代器中重复相同的值，这意味着当你将它与一个有限列表压缩在一起时，将会生成精确的重复次数。dict()构造函数可以接受(键，值)元组的 iterable，初始化一个字典，每个键映射到每个值。我们可以不使用循环就完成我们想要的。

names = ["Alice", "Bob", "Charlie", "Dora", "Evgenia", "Farhat"]
names_dict = dict(zip(names, itertools.repeat("Default")))# {'Alice': 'Default',
#  'Bob': 'Default',
#  'Charlie': 'Default',
#  'Dora': 'Default',
#  'Evgenia': 'Default',
#  'Farhat': 'Default'}

7.用 starmap()在元组列表中映射函数

starmap()函数类似于 Python 的内置map()函数，它将函数应用于 iterable。不同之处在于，starmap()将一个双参数函数应用于元组的 iterable，例如starmap(lambda x, y: x ** y, [(2, 3), (3, 2), (1, 5)])将返回序列[8, 9, 1]的迭代器，即[2**3, 3**2, 1**5]。这种方法的一个潜在应用是计算列表中成对项目之间的差异。下面的代码使用zip()和列表切片从temps列表中创建一个成对条目的 iterable，然后应用减法函数。这就产生了一个每日温度变化的列表，我们可以将其绘制成柱状图。

temps = [70, 69, 69, 58, 55, 68, 81, 90, 89, 88, 75, 76, 74]
diffs = list(itertools.starmap(np.subtract, zip(temps[1:], temps[:-1])))
data = {"x": list(range(len(diffs))), "y": diffs}
sns.barplot(data=data, x="x", y="y")

作者图片

我们可以用同样的想法来创建一个函数导数的数值*似值。如果我们在 x 的一个小变化上有一个值序列(在这种情况下，正弦函数每 0.1 个单位计算一次)，我们将值的成对差除以 x 的变化，我们会得到一条看起来完全像余弦函数的曲线，它实际上是 sin(x)的导数。

x = np.linspace(0, 10, 100)
y = np.sin(x)              
diffs = list(itertools.starmap(lambda x, y: (x-y)/0.1, zip(y[1:], y[:-1]))) # this list is one shorter than the original list
sns.lineplot(x=x, y=y)
sns.lineplot(x=x[:-1], y=diffs)

蓝色曲线是根据原始列表绘制的，包含均匀分布的 x 值和相应的 sin(x)值。橙色曲线来自于使用 starmap()对列表中的值进行成对差分。图片作者。

虽然这是一个有些做作的例子，但希望您能看到这在各种情况下是如何有用的。您不局限于使用简单的函数，如减法和取幂，而是可以提供您自己的自定义函数作为starmap()的第一个参数。

结论

我希望你喜欢这些例子。这些功能你有什么喜欢的用法吗？关于itertools的伟大之处在于，一旦你*惯了它们，你就有无穷无尽的方法来混合和搭配它们。拥有这些方便的子例程在处理较难的问题时会有很大帮助，并最终使我的代码更加优雅和健壮。查看itertools 文档中更多的函数和例子！

你需要知道的 7 个有用的熊猫展示选项

原文：https://towardsdatascience.com/7-useful-pandas-display-options-you-need-to-know-51956e89aa2f

一步一步提升你的熊猫技能

熊猫图书馆提供了许多不同的选择。图片由作者使用 DALL-E 2 生成。

Pandas 是数据科学中常用的强大的 Python 库。它允许您从各种来源加载和操作数据集，并且通常是您在数据科学之旅中遇到的第一批库之一。

当使用熊猫时，默认选项将适合大多数人。但是，有时您可能希望更改显示内容的格式。熊猫有许多用户可配置的选项，允许你定制东西是如何显示的。

以下部分说明了更改这些默认设置的一些用例。可用选项的完整列表可在 这里 找到。

在本文中，我们将讨论:

• 控制显示行数
• 控制要显示的列数
• 压制科学记数法
• 控制浮点精度
• 控制十进制格式
• 改变后端绘图库
• 重置显示选项

1.控制熊猫数据框显示的行数

有时，在查看数据帧时，您经常希望看到比默认行数(设置为 10)更多的行数。这包括数据帧的前 5 行和后 5 行。

这可以防止 pandas 在调用 dataframes 时显示大量数据，从而降低计算机速度。

要生成此示例的示例数据，您可以使用以下代码:

arr_data = np.random.default_rng().uniform(0, 100, size=(100,5))
pd.DataFrame(arr_data, columns=list('ABCDE'))

pandas 使用默认选项生成的基本数据帧。图片由作者提供。

有两个选项可用于控制显示多少行。

第一个是display.max_rows，它控制在截断数据帧之前显示的最大行数。如果数据帧中的行数超过此数，则显示将被截断。默认情况下，该值设置为 60。

如果您想在 dataframe 被调用时显示所有的行，您需要更改display.max_rows选项并将其设置为None。请注意，如果您有一个非常大的数据帧，这可能会降低您的计算机速度。

pd.set_option('display.max_rows', None)

当您调用我们的数据框架时，您可以看到其中的每一行。

更改 max_rows 的默认选项后的 Pandas dataframe。图片由作者提供。

如果 dataframe 包含的行数多于max_rows设置的行数，那么您必须将display.min_rows参数更改为您想要显示的值。你还需要确保max_rows参数大于min_rows。

pd.set_option('display.min_rows', 20)

如果您将min_rows设置为20，当您调用数据帧进行查看时，您将看到数据帧顶部的 10 行和底部的 10 行。

2.控制数据帧中显示的列数

当处理包含大量列的数据集时，pandas 将截断数据帧显示以显示 20 列。要了解您的 dataframe 列是否已被截断，请查找下图中第 9 列和第 15 列之间的三个点(省略号)。

如果您想要生成上述数据，您可以使用以下代码:

arr_data = np.random.default_rng().uniform(0, 100, size=(100,25))
df = pd.DataFrame(arr_data)
df

要在显示屏上看到更多列，您可以像这样更改display.max_columns参数:

pd.set_option('display.max_columns', 30)

执行此操作时，最多会显示 30 列。然而，这可能会导致其他问题，例如当您想要在这样的帖子中显示图形时，它会变得难以阅读。

更改 max_columns 显示选项后的熊猫数据帧。图片由作者提供。

3.压制科学符号

当处理科学数据时，你经常会遇到非常大的数字。一旦这些数字达到数百万，熊猫会将它们重新格式化为科学符号，这可能是有帮助的，但并不总是如此。

要生成具有非常大的值的 dataframe，可以使用下面的代码。

arr_data = np.random.default_rng().uniform(0, 10000000, size=(10,3))
df = pd.DataFrame(arr_data)
df

显示非常大数的科学记数法的数据帧。图片由作者提供。

有时，您可能希望以完整形式显示这些数字，而不使用科学符号。这可以通过改变float_format显示选项并传入一个小的 lambda 函数来实现。这将重新格式化显示，使值不含科学记数法，最多有 3 个小数位。

pd.set_option('display.float_format', lambda x: f'{x:.3f}')

将科学记数法转换成数字后的熊猫数据图。图片由作者提供。

如果你想让它看起来更好，你可以在千位之间加一个逗号分隔符。

下面的代码可能看起来和上面的一样，但是如果你仔细观察代码的f'{x:部分，就会发现有一个逗号。

pd.set_option('display.float_format', lambda x: f'{x:,.3f}')

熊猫数据帧包含带有千位分隔符的大数。图片由作者提供。

4.更改数据帧内的浮点精度

有时，您正在处理的数据可能在小数点后有太多的值。这有时会使它看起来很乱。默认情况下，熊猫会在小数点后显示 6 个数值。

显示浮点数精确到小数点后 6 位的数据帧。图片由作者提供。

为了便于阅读，您可以通过调用display.precision选项来减少显示的值的数量，并传入您想要显示的值的数量。

pd.set_option('display.precision', 2)

当您查看原始数据帧时，您会看到我们的数字列的浮点精度已经降低到 2。

改变浮点精度后的数据帧。图片由作者提供。

记住，该设置仅改变数据的显示方式。它不会更改基础数据值。

5.控制浮点格式

有时，您处理的数字可能代表百分比或货币值。如果是这种情况，用正确的单位对它们进行格式化会很方便。

要将百分号附加到您的列中，您可以调用display.float_format选项，并使用 f 字符串传递您想要显示的格式:

pd.set_option('display.float_format',  f'{:,.3f}%')

熊猫数据框以百分比显示所有数值。图片由作者提供。

要以美元符号开始浮点数，您可以像这样更改代码:

pd.set_option('display.float_format',  f'${:,.2f}')

更改显示选项以在开头包含$符号后的熊猫数据帧。图片由作者提供。

6.更改默认熊猫绘图库

在进行探索性数据分析时，您经常需要快速绘制数据图。您可以使用 matplotlib 构建一个情节，然而，您可以使用熊猫通过.plot() 方法用几行代码来完成。

熊猫为我们提供了一系列绘图库供我们使用:

• matplotlib
• hvplot > = 0.5.1
• 全息视图
• 熊猫 _ 散景
• plotly > = 4.8
• 牛郎星

要更改当前实例的默认绘图库，您需要更改 pandas 的plotting.backend选项。

pd.options.plotting.backend = "hvplot"

一旦你这样做了，你就可以开始用.plot方法创建你的地块了

df.plot(kind='scatter', x='1', y='2')

将熊猫的后端绘图选项改为 hvplot 后，强大的交互式绘图。图片由作者提供。

7.重置熊猫显示选项

如果您想将特定选项的参数设置回默认值，您可以调用reset_option方法并传入您想要重置的选项。

pd.reset_option('display.max_rows')

或者，如果您已经更改了多个选项，您可以通过提供单词all作为参数，将它们全部改回默认值。

pd.reset_option('all')

一次更改多个选项

您可以利用字典的强大功能，然后遍历并设置每个选项，而不是逐个更改之前的设置。

这样做有助于节省时间，减少编写的代码量，并提高可读性。

import pandas as pd

settings = {
    'max_columns': 30,
    'min_rows':40,
    'max_rows': 30,
    'precision': 3
    }for option, value in settings.items():
    pd.set_option("display.{}".format(option), value)

摘要

Pandas 是一个强大的库，可以直接使用，但是，默认选项可能不适合您的需要。本文介绍了一些流行的选项，您可能希望更改这些选项来改进查看数据框的方式。

感谢阅读。在你走之前，你一定要订阅我的内容，把我的文章放到你的收件箱里。 你可以在这里做！*或者，您可以* 注册我的简讯 免费获取更多内容直接发送到您的收件箱。

其次，通过注册会员，你可以获得完整的媒介体验，并支持我和其他成千上万的作家。每月只需花费你 5 美元，你就可以接触到所有精彩的媒体文章，也有机会通过写作赚钱。如果你用 我的链接报名，你直接用你的一部分费用支持我，不会多花你多少钱。如果你这样做了，非常感谢你的支持！

7 用 Python 可视化表达等级随时间的变化

原文：https://towardsdatascience.com/7-visualizations-with-python-to-express-changes-in-rank-over-time-71c1f11d7e4b

使用 Python 可视化等级随时间的变化

澳大利亚八月在 Unsplash 拍摄的照片

排序数据是按数字顺序排列的数据位置。这是一种简单的信息交流方式，因为它有助于读者毫不费力地理解序列。排序是处理多个观察值或分类数据的好方法。

然而，事情总是在变化。随着时间的推移，排名的位置可以不断改变。可视化一段时间内的等级位置有助于通知变化和进展。

这篇文章将会用一些想法来引导你想象等级随时间的变化。

本文中使用 Python 进行数据可视化的示例，展示了等级随时间的变化。作者提供的图片

我们开始吧

检索数据

为了说明这里提到的方法可以应用于真实世界的数据集，我将使用来自 Kaggle ( 链接)的“首尔空气污染”数据集。数据由首尔市政府提供(链接)。这些数据是在知识共享许可的条款下由抄送使用的。

该数据集由 2017 年至 2019 年期间在韩国首尔 25 个区记录的空气污染数据组成:SO2、NO2、CO、O3、PM10 和 PM2.5。

在这篇文章中，我们将与一氧化碳(CO)一起工作，这是一种对人类有害的常见空气污染物。测量单位为百万分率 (ppm)。

输入数据

下载数据集后，从导入库开始。

import numpy as np
import pandas as pd
import math
import matplotlib.pyplot as plt
import seaborn as sns

%matplotlib inline

用熊猫看‘Measurement _ summary . CSV’

df = pd.read_csv('<file location>/Measurement_summary.csv')
df.head()

浏览数据

作为第一步，探索数据集总是一个好主意。幸运的是，下面的结果表明我们不必处理丢失的值。

df.info()

让我们看看变量“车站代码”的总数

df['Station code'].nunique()

## output
## 25

总共有 25 个区。

set(df['Station code'])

## output
## {101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
## 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125}

选择和准备数据

例如，我将选择车站代码 111-118。如果您想绘制其他站号，请随意修改下面的代码。

list_stations = [111, 112, 113, 114, 115, 116, 117, 118]
df_select = df[df['Station code'].isin(list_stations)]
df_select.head()

检索到的数据集尚未准备好进行绘制。有些列需要在使用前创建或修改。

## crete year_month, year and month columns
year_month = [i[0:7] for i in list(df_select['Measurement date'])]
df_select['year_month'] = year_month
df_select['year'] = [i[0:4] for i in year_month]
df_select['month'] = [i[-2:] for i in year_month]

## create district name column
district = [i.split(', ')[2] for i in df_select['Address']]
df_select['District'] = district

## change Station code column type
df_select = df_select.astype({'Station code': str})

## groupby with location and point of time
df_month = df_select.groupby(['Station code','District',
                              'year_month','year','month']).mean()
df_month.reset_index(inplace=True)
df_month.head()

这是重要的一步。本文的主要思想是为排名数据创建可视化。接下来，我们将创建一个列，用于对每个时间点的地区 CO 数(ppm)进行排名。

keep = []
for i in list(set(df_month['year_month'])):
    df = df_month[df_month['year_month']==i]
    order = df['CO'].rank(ascending=0)
    df['rank'] = [int(i) for i in order]
    keep.append(df)

df_month = pd.concat(keep)
df_month.sort_values(['year_month', 'Station code'], ascending=True,
                     inplace=True, ignore_index=True)
df_month.head()

在继续之前，我们将定义一个颜色字典，以便于绘图过程。

#extract color palette, the palette can be changed
list_dist = list(set(df_select['District']))
pal = list(sns.color_palette(palette='Spectral',
                             n_colors=len(list_dist)).as_hex())
dict_color = dict(zip(list_dist, pal))

数据可视化

本文旨在用一些可视化的思想来指导对数据进行排序。因此，获得的结果应该易于理解，同时允许读者比较不同时间点之间的数据等级。

在继续之前需要澄清一些事情。每张图都有它的优点和缺点。当然，没有什么是完美的。这里提出的一些想法可能只是为了一个吸引眼球的效果。但是它们都具有相同的目的，即显示数据等级随时间的变化。

本文中的图表可以分为两组:动画和图表。

动画

除了是一个吸引注意力的好主意，动画可以很容易地显示排名随时间的变化。

1.将条形图高度与动画条形图进行比较

Plotly 是一个制作交互式动画图形的有用图形库。应用动画条形图的概念是固定每个地区的位置。每个条形都将标注排名数字。通过这样做，可以比较一段时间内的一氧化碳含量。

import plotly.express as px
fig = px.bar(df_month, x='District', y='CO',
             color='District', text='rank',
             color_discrete_map= dict_color,
             animation_frame='year_month',
             animation_group='Station code',
             range_y=[0,1.2],
             labels={ 'CO': 'CO (ppm)'},
            )
fig.update_layout(width=1000, height=600, showlegend=False,
                  xaxis = dict(tickmode = 'linear', dtick = 1))
fig.update_traces(textfont_size=16, textangle=0)
fig.show()

瞧啊。！

动画条形图显示地区的月度排名和 CO(ppm)量。作者图片。

上面所附的结果可能看起来很快，因为这只是结果的一个例子。不用担心；有一个暂停按钮用于暂停，还有一个按钮用于选择特定的时间点。

2.带动画散点图的赛车

现在让我们换个角度，根据各个地区在不同时间点的排名来移动它们。散布点的大小可以用来显示一氧化碳数量。

为了方便用 Plotly 绘图，我们需要在 DataFrame 中添加两列，X 轴上的位置，以及注释文本。

ym = list(set(year_month))
ym.sort()

df_month['posi'] = [ym.index(i) for i in df_month['year_month']]
df_month['CO_str'] = [str(round(i,2)) for i in df_month['CO']]
df_month['CO_text'] = [str(round(i,2))+' ppm' for i in df_month['CO']]
df_month.head()

接下来，绘制动画散点图。

import plotly.express as px
fig = px.scatter(df_month, x='posi', y='rank',
                 size= 'CO',
                 color='District', text='CO_text',
                 color_discrete_map= dict_color,
                 animation_frame='year_month',
                 animation_group='District',
                 range_x=[-2,len(ym)],
                 range_y=[0.5,6.5]
                )
fig.update_xaxes(title='', visible=False)
fig.update_yaxes(autorange='reversed', title='Rank',
                 visible=True, showticklabels=True)
fig.update_layout(xaxis=dict(showgrid=False),
                  yaxis=dict(showgrid=True))
fig.update_traces(textposition='middle left')
fig.show()

哒哒…

动画散点图显示地区的月度排名和 CO(ppm)量。作者图片。

图表

动画图表通常受限于只能表达一个时间点。为了显示多个时间点，可以应用一些图表和方法来一次展示多个时间点。

3.使用凹凸图绘制线条

基本上，凹凸图应用多条线来显示排名随时间的变化。使用 Plotly 绘制凹凸图允许用户在将光标悬停在每个数据点上时过滤结果并提供更多信息，如下面的结果所示。

import plotly.express as px
fig = px.line(df_month, x = 'year_month', y = 'rank',
              color = 'District',
              color_discrete_map= dict_color, 
              markers=True,
              hover_name = 'CO_text')
fig.update_traces(marker=dict(size=11))
fig.update_yaxes(autorange='reversed', title='Rank',
                 visible=True, showticklabels=True)
fig.update_xaxes(title='', visible=True, showticklabels=True)
fig.update_layout(xaxis=dict(showgrid=False),
                  yaxis=dict(showgrid=False) )
fig.show()

凹凸图显示了各区的排名和每月的一氧化碳含量(ppm)。可以过滤结果并提供更多信息，如图所示。作者图片。

4.创建条形图的照片拼贴

一个简单的柱状图可以表达一个时间点的排名。有了很多时间点，我们可以创建很多条形图，然后组合成一个照片拼贴。首先使用 Seaborn 库创建一个条形图。

df_select = df_month[df_month['year_month']=='2017-01']
fig, ax = plt.subplots(figsize=(15, 6))

sns.set_style('darkgrid')
sns.barplot(data = df_select,
            x = 'District', y ='CO',
            order=df_select.sort_values('CO', ascending=False)['District'],
            palette=dict_color)
ax.bar_label(ax.containers[0],
             labels=df_select.sort_values('CO', ascending=False)['CO_str'],
             label_type='edge', size=11)
plt.ylabel('CO (ppm)')
plt.title('2017-01')
plt.show()

条形图按排名显示各区的一氧化碳含量(ppm)。作者图片。

使用 for-loop 函数创建不同时间点的条形图。请注意，下面的代码会将图表导出到您的计算机，以便以后导入。

keep_save = []
for t in ym:
    df_ = df_month[df_month['year_month']==t]
    fig, ax = plt.subplots(figsize=(8.5, 5))
    sns.set_style('darkgrid')
    sns.barplot(data = df_,
                x = 'District', y ='CO',
                order = df_.sort_values('CO', ascending=False)['District'],
                palette=dict_color)
    ax.bar_label(ax.containers[0],
                 labels=df_.sort_values('CO', ascending=False)['CO_str'],
                 label_type='edge', size=11)
    plt.ylim([0, 1.2])
    plt.ylabel('CO (ppm)')
    plt.title(t)
    plt.tight_layout()
    s_name = t + '_bar.png'
    keep_save.append(s_name)
    plt.savefig(s_name)
    plt.show()

创建一个函数来合并图表。我发现了一个很好的代码来组合这个链接上堆栈溢出的许多情节。

应用函数。

## get_collage(n_col, n_row, width, height, save_name, 'output.png')
# width = n_col * figure width
# height = n_row * figure height 

get_collage(12, 3, 12*850, 3*500, keep_save, 'order_bar.png')

哒哒…

照片拼贴的一部分结合了条形图，显示了各区的排名和每月的二氧化碳含量(百万分之几)。作者图片。

结果显示每个地区的月度 CO 值，同时显示一段时间内的排名顺序。因此，我们可以同时比较多个时间点的区域等级和污染量。

5.想象有圆形条形图的条形图

与前面的想法相同的概念，我们可以将普通的条形图变成圆形条形图(又名赛道图)，并将它们组合成照片拼贴。

如前所述，凡事都有利弊。由于每个条形的长度比例不相等，圆图上的每个条形可能很难比较。然而，这可以被认为是一个很好的选择，以创造一个引人注目的效果。

从创建圆形条形图的示例开始。

圆形条形图按等级显示各区的一氧化碳含量(百万分之几)。作者图片。

应用 for-loop 函数获得其他圆形条形图。结果将导出到您的计算机中，以便以后导入。

使用函数获取照片拼贴。

get_collage(12, 3, 12*860, 3*810, keep_cir, 'order_cir.png')

一张照片拼贴画的一部分结合了圆形条形图，显示了各区的排名和每月的二氧化碳含量(百万分之几)。作者图片。

6.另一种用径向条形图想象条形图的方法

用径向条形图改变条形图的方向，从中心开始。这是另一个吸引注意力的方法。然而，可以注意到，彼此不靠*的条很难比较。

从一个放射状条形图的例子开始。

放射状条形图按等级显示各区的一氧化碳含量(ppm)。作者图片。

应用 for-loop 函数创建其他径向条形图。结果也将导出到您的计算机，以便以后导入。

应用该函数获得一个照片拼贴。

get_collage(12, 3, 12*800, 3*800, keep_rad, 'order_rad.png')

一张照片拼贴画的一部分结合了放射状的条形图，显示了各区的排名和每月的二氧化碳含量(百万分之几)。作者图片。

7.在热图中使用颜色

通常，热图是一种常见的图表，用于将数据呈现为二维图表，并用颜色显示值。对于我们的数据集，可以应用颜色来显示等级数。

首先用 pd.pivot()创建一个数据透视表。

df_pivot = pd.pivot(data=df_month, index='District',
                    columns='year_month', values='rank')
df_pivot

获得数据透视表后，我们可以用几行代码轻松创建热图。

plt.figure(figsize=(20,9.5))
sns.heatmap(df_pivot, cmap='viridis_r', annot=True, cbar=False)
plt.show()

应用热图显示地区排名随时间的变化。作者图片。

通过颜色和注释，我们可以找出 CO 值最高(黄色)和最低(深蓝色)的地区。随着时间的推移，可以注意到排名的变化。

摘要

本文介绍了用 Python 代码表达数据等级随时间变化的七种可视化思想。如前所述，凡事都有利弊。重要的是找到适合数据的正确图表。

我敢肯定，随着时间的推移，有比这里提到的更多的数据排名图。本文仅用一些思路指导。如果有什么建议或推荐，欢迎随时留言评论。我很乐意看到它。

感谢阅读

这些是我的数据可视化文章，您可能会感兴趣:

• 8 用 Python 处理多个时序数据的可视化(链接)
• 6 可视化与 Python 技巧处理超长时间序列数据(链接)
• 9 用 Python 可视化显示比例，而不是饼状图(链接)
• 9 个比条形图更引人注目的 Python 可视化(链接)

参考

• 首尔市政府。(2021 年 5 月)。韩国首尔的空气污染测量信息。检索于 2022 年 11 月 23 日，来自https://www . ka ggle . com/datasets/bappekim/air-pollution-in-Seoul
• 서울시 대기오염 측정정보 。서울열린데이터광장.检索于 2022 年 11 月 26 日，来自https://data . Seoul . go . kr/dataList/OA-15526/S/1/dataset view . do

提高数据仓库性能的 7 种方法

原文：https://towardsdatascience.com/7-ways-to-improve-performance-of-your-data-warehouse-4544456bcc3

通过应用以下步骤来改善数据仓库的低性能

哈雷戴维森在 Unsplash 上的照片

P oor 性能是数据仓库(DWH)名声不佳的主要原因之一。无论何时交付 DWH，都应该有一个性能改进策略。这确保了 DWH 保持相关性，并按时满足业务最终用户的要求。

通常，缓慢的 DWH 会产生多种下游影响，例如不完整的批处理作业导致缺少报告，或者仪表板加载缓慢导致用户沮丧。最糟糕的是，当这种情况持续几周甚至几个月，而没有采取任何措施来改善这种情况时，随着时间的推移，最终用户的信心会受到侵蚀。

让我们确保我们不会成为 DWH 死亡的原因。今天，我们将学*提高 DWH 表现的七种方法。

1.索引

想象一下，走进一家超市买糖；你会看到 10 个不同的过道，没有标签或指示。你必须扫描整个超市才能找到商品。你可能会幸运地在第一个过道找到它，或者非常不幸地在第十个过道的最后一个架子上找到它。

添加一些搜索功能或索引可以大大提高您更快找到您的项目的机会。索引将给定列中的值存储在可搜索的结构中，这允许查询读取更少的数据来查找信息。

例如，一个包含 1000 行人名的表，主键为，没有索引，每次在 WHERE 子句中搜索名字时，都需要对整个表进行扫描。然而，如果索引被添加到主键列和名字列中，那么搜索标准是严格的。这减少了查询所需的读取次数，从而减少了获取信息的时间。

然而，并不是所有的阳光和彩虹都有索引。它们有开销，索引太多会降低 DWH 的插入和更新操作的速度。同样，给超市里的所有东西贴上标签会减缓货架的堆叠过程。

2.压缩

现代云 DWH 像红移使用自动编码/压缩，所以你可能必须配置它。传统上，压缩通过减少冗余/重复数据值来帮助节省大量磁盘空间。

例如，假设您已在 DWH 上设置了变更数据捕获，并对未结记录使用高端日期，如“31/12/9999”。您可以将该日期值压缩为一条记录。其余的记录可以用价值 2 位的非常经济的替代值来引用。这使您不必在磁盘上重复存储上述日期。

如果您不知道变更数据捕获的各种方法，请查看下面的文章:

https://medium.com/geekculture/6-different-types-of-slowly-changing-dimensions-and-how-to-apply-them-b152ef908d4e

除了多值压缩，最好还进行行值压缩。如果有一行只是“Y”和“N”的值，并且数据类型是 Char(1000)，那么所有这些字节都没有用。压缩它可以节省大量的磁盘空间，而不会影响查询的输出。

请注意，并非所有的行和列都可以或应该被压缩，因为它们可能会对正常功能产生意外影响。建议不要压缩使用行级安全性的主键列或行。

3.收集统计数据

收集统计信息是一种帮助 DWH 以最佳方式形成执行计划的方法，有助于提高查询的性能。收集统计数据的最常见过程是在 ETL 作业完成后立即进行。随着新数据进入 DWH，拥有特定表的最新统计信息有助于所有后续查询及其执行计划。

收集经常用于下游连接、聚合或排序的列的统计数据是非常重要的。此外，有时，拥有陈旧的统计数据比没有统计数据更糟糕。这意味着不准确的表统计可能会导致较差的查询执行计划。所以要保持这些数据的更新。

像索引和其他性能技术这样的统计数据收集也有全表扫描的开销；有一些创建样本统计数据的方法可以减轻这种负担，帮助保持统计数据的新鲜。

4.创建构建基块和视图

建议不要直接转到底层数据表，而是在构建块或视图中对最常用的查询执行一些预聚合。这有助于快速获得信息，而不必反复查询同一个表。

即使如此，视图仍然会查询基础表；聚集索引视图将临时存储所需的信息，从而加快查询响应速度。取决于 DWH 的设置(高度标准化等。)，可能需要构建模块来帮助获得最终答案。

占据磁盘空间的物化视图可以作为普通聚合的替代方案。它将减少所需的数据量，并允许快速检索相同的常见聚合查询。

有 101 种错误编写查询的方式，只有少数几种可以优化

5.分区和分片

分区是在逻辑上将大表分成更小的、可管理的块。因为表现在是更小的块，所以整个查询运行得更快，因为它需要扫描的数据更少。

分区，也称为“垂直分区”，或可归类为数据的规范化，是一种垂直划分数据表的方法，如下所示:

作者图片:垂直分割

水平分区，也称为“分片”，将数据水平划分，通常位于不同的数据库实例上，这降低了单台服务器的性能压力。

作者图片:水平分割

记得索引吗？分区有助于减小表的大小，进而减小索引的大小，这进一步加快了 DWH 操作的速度。但是，分区也增加了查询的复杂性，并增加了管理更多数据表的开销，尤其是备份。因此，在开始分片之前，尝试一些其他的性能技术。

6.查询优化

坦率地说，没有什么性能改进可以替代写得很差的查询。有 101 种错误编写查询的方式，只有少数几种可以优化。

学*查询构建和执行计划的基础知识是编写最佳查询的一种极好的方式。如今，有了更复杂的 ETL 工具，查询直接由工具本身编写。然而，在我看来，查询优化的强大知识是无可替代的。

例如，不使用 SELECT *，避免复杂的连接，使用 LIMIT 返回有限数量的行，在 WHERE 子句中使用索引列等。，是一些优化查询的方法。

您选择的 DWH 技术中的执行计划也将为提高查询性能提供有价值的见解。

7.数据最小化

这是一个不寻常的问题，但在今天这个数据伦理和隐私的时代却很重要。问问你自己，你是否需要所有这些数据来回答你的关键业务问题。由于数据湖的廉价存储和使用，该行业正处于数据昏迷状态。

消费者的每一个举动都会被跟踪、记录和存储。除了不道德之外，这也是一项巨大的责任，因为这些信息需要根据您所在地区的相关法规进行处理。那么，你能在不存储每一位数据的情况下生存吗？如果可以，你能清除这些数据或者不收集这些数据吗？

这将减少你拥有的数据量，降低存储数据的开销，使这个行业更具可持续性。

结论

这些是帮助你加快 DWH 的一些关键技术。尝试一次实施一种方法，定期微调你的 DWH 绩效策略。

如果你觉得这篇文章有帮助，请在下面留言告诉我。查看我在 Medium 上的其他帖子:

如果您没有订阅 Medium，请考虑使用我的推荐链接订阅。它比网飞便宜，而且客观上能更好地利用你的时间。如果你使用我的链接，我会获得一小笔佣金，而你可以在 Medium 上获得无限的故事。

我也定期在推特上写东西；跟着我这里。

用于处理大型数据集的熊猫的 8 种替代方案

原文：https://towardsdatascience.com/8-alternatives-to-pandas-for-processing-large-datasets-928fc927b08c

停止使用熊猫

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

Pandas 库已经成为 python 中数据操作的事实库，并被数据科学家和分析师广泛使用。然而，有时数据集太大，熊猫可能会遇到内存错误。以下是熊猫处理大型数据集的 8 个替代方案。对于每个备选库，我们将研究如何从 CSV 加载数据并执行一个简单的groupby操作。幸运的是，这些库中有许多与 Pandas 相似的语法，因此学*曲线不会太陡。

达斯克

Dask 在大于内存的数据集上提供多核分布式并行执行。

Dask 数据帧是一个大型并行数据帧，由许多较小的 Pandas 数据帧组成，沿索引拆分。这些 Pandas 数据帧可能存在于磁盘上，用于单台机器或集群中许多不同机器上的大内存计算。一个 Dask 数据帧操作触发对组成 Pandas 数据帧的许多操作。

pip install daskimport dask.dataframe as dd
df = dd.read_csv('../input/yellow-new-york-taxi/yellow_tripdata_2009-01.csv', dtype={'Tolls_Amt': 'float64'})
df2 = df.groupby('vendor_name').agg({'Passenger_Count':'mean'})

到目前为止，还没有执行任何计算。计算df2的结果

df2.compute()

Dask 不仅仅是一个数据操作库。 Dask-ML 提供可扩展的机器学*，可以与 Scikit-learn、Xgboost 和 LightBGM 等流行的机器学*库一起使用。

摩丁

Modin 使用 Ray 或 Dask 提供一种毫不费力的方式来加速你的熊猫笔记本、脚本和库。

pip install modinimport modin.pandas as pd
df = pd.read_csv('../input/yellow-new-york-taxi/yellow_tripdata_2009-01.csv')
df2 = df.groupby('vendor_name').agg({'Passenger_Count':'mean'})

数据表

Datatable是一个用于操作表格数据的 python 库。它支持内存不足的数据集、多线程数据处理和灵活的 API。

pip install datatablefrom datatable import dt, f, by
df = dt.fread('../input/yellow-new-york-taxi/yellow_tripdata_2009-01.csv', skip_blank_lines = True)
df2 = df[:, dt.mean(f.Passenger_Count), by('vendor_name')]

极地

Polars 是 Rust 中实现的一个速度惊人的数据帧库，使用 Apache Arrow Columnar 格式作为内存模型。

pip install polarsimport polars as pldf = pl.read_csv('../input/yellow-new-york-taxi/yellow_tripdata_2009-01.csv')
df2 = df.groupby('vendor_name').agg([pl.mean('Passenger_Count')])

Vaex

Vaex 是一个用于懒惰的核外数据框架(类似于熊猫)的 python 库，用于可视化和探索大型表格数据集

pip install vaexdf = vaex.read_csv('../input/yellow-new-york-taxi/yellow_tripdata_2009-01.csv')
df2 = df.groupby('vendor_name').agg({'Passenger_Count':'mean'})

Pyspark

Pyspark 是 Apache Spark 的 Python API，用于通过分布式计算处理大型数据集。

pip install pysparkfrom pyspark.sql import SparkSession, functions as f
spark = SparkSession.builder.appName("SimpleApp").getOrCreate()df = spark.read.option('header', True).csv('../input/yellow-new-york-taxi/yellow_tripdata_2009-01.csv')
df2 = df.groupby('vendor_name').agg(f.mean('Passenger_Count'))

到目前为止，还没有执行任何计算。计算df2的结果

df2.show()

树袋熊

考拉 项目通过在 Apache Spark 之上实现 pandas DataFrame API，使数据科学家在与大数据交互时更有效率。

由于考拉运行在 Apache Spark 之上，Spark 也必须安装。

*pip install pyspark
pip install koalasimport databricks.koalas as ks
from pyspark.sql import SparkSession
df = ks.read_csv('../input/yellow-new-york-taxi/yellow_tripdata_2009-01.csv')
df2 = df.groupby('vendor_name').agg({'Passenger_Count':'mean'})*

cuDF

cuDF 是一个 Python GPU DataFrame 库，构建在 Apache Arrow columnar 内存格式上，用于数据操作。cuDF 还提供了一个类似熊猫的 API，数据工程师&数据科学家会很熟悉，所以他们可以使用它来轻松地加速他们的工作流程，而无需进入 CUDA 编程的细节。

cuDF 可以通过 conda 安装，看看这个指南。

*import cudf
df = cudf.read_csv('../input/yellow-new-york-taxi/yellow_tripdata_2009-01.csv')
df2 = df.groupby('vendor_name').agg({'Passenger_Count':'mean'})*

结论

在本文中，我们研究了 8 个用于操作大型数据集的 python 库。它们中的许多都有与 Pandas 相似的语法，这使得学*曲线不那么陡峭。如果你想知道不同包的执行速度， H2O.ai 已经在其中一些包上创建了一个有用的 ops 基准。它比较了不同大小的数据集上各种包的执行速度，以及不同常见操作(如连接和分组)的执行速度。

我希望这是一个有用的开始，请在您处理 python 大型数据集的常用库下面留下评论。

加入 Medium 阅读更多这样的故事。

编写优秀 SQL 代码的最佳实践

原文：https://towardsdatascience.com/8-best-practices-for-writing-top-tier-sql-code-e1023996e459

由 pikisuperstar 创建的 Css 矢量—www.freepik.com

介绍

磨练编码技能的最简单也是最有效的方法之一就是让你的代码更具可读性。让你的代码可读会让它更易理解，更易重现，更易调试。让你的代码更具可读性的最好方法是执行一些规则或标准，使它一致和干净。

说了这么多，我要和你分享编写顶层 SQL 代码的八个技巧:

请务必点击 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！

1.大写关键字和函数

我从一个你可能已经在做的简单提示开始，这很好，但你会惊讶于许多人不支持这个提示:当涉及到关键字和函数时，确保它们是大写字母！

虽然这看起来有点吹毛求疵，但像这样的技巧会让你的代码更加清晰。

而不是:

select name, date_trunc(register_date, week) from customers

试试:

SELECT name, DATE_TRUNC(register_date, WEEK) FROM customers

2.缩进和对齐

为了建立在前一个例子的基础上，下一个技巧将集中在代码的缩进和对齐上。考虑两个例子——哪个更清晰？

SELECT name, height, age, salary, CASE WHEN age<18 THEN "child" ELSE    
"adult" END AS child_or_adult
FROM People LEFT JOIN Income USING (name)
WHERE height<=200 and age<=65

或者

SELECT 
   name
 , height
 , age
 , salary
 , CASE WHEN age < 18 THEN "child"
        ELSE "adult"
   END AS child_or_adult
FROM 
   People
LEFT JOIN 
   Income USING (name)
WHERE 
   height <= 200
   AND age <= 65

很明显，第二个更容易阅读，这完全归功于它的编程风格！特别是，请注意第二个示例中的代码是如何缩进和垂直对齐的。这使得从未看过您的代码的人更容易浏览它。

虽然您不必遵循这种精确的缩进和格式样式，但在整个代码中应用它并开发一致的样式是很重要的。

请务必点击 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！

3.对模式、表、列应用一致的案例类型

在编程中，有几种类型的案例，仅举几个例子:

• 茶包
• 帕斯卡凯斯
• 蛇 _ 案例

不管你的偏好是什么，重要的是确保你在整个代码中保持一致。

而不是:

SELECT 
   firstName
 , LastName
 , child_or_adult 
FROM 
   customers

试试:

SELECT 
   first_name
 , last_name
 , child_or_adult 
FROM 
   customers

4.避免选择*

这是一个重要的技巧，不仅对于格式化，而且对于查询优化(我们将在另一篇文章中讨论！).

即使您发现自己几乎使用了表中的每一列，写出您将需要的列也是一个好*惯。为什么？随着表的发展和更多列的添加/更改，指定列名将使将来识别潜在的错误变得容易。

而不是:

SELECT 
   *
FROM 
   customers

试试:

SELECT 
   name
 , height
 , age
 , salary
FROM 
   customers

请务必点击 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！

5.用公共表表达式模块化代码

使用公共表表达式(或 cte)对于模块化和分解代码非常有用——就像你将一篇文章分解成几个段落一样。

如果您想更详细地了解 cte，请查看本文,但是在其核心，cte 创建了一个临时表，允许您“查询一个查询”

而不是:

SELECT 
   name
 , salary
FROM 
   People
WHERE 
   name IN (SELECT DISTINCT 
              name 
           FROM 
              population 
           WHERE 
              country = "Canada"
              AND city = "Toronto")
   AND salary >= (SELECT 
                     AVG(salary)
                  FROM 
                     salaries
                  WHERE 
                     gender = "Female")

试试:

with toronto_ppl as (
   SELECT DISTINCT 
      name
   FROM 
      population
   WHERE 
      country = "Canada"
      AND city = "Toronto"
), avg_female_salary as (
   SELECT 
      AVG(salary) as avg_salary
   FROM 
      salaries
   WHERE 
      gender = "Female"
)SELECT 
   name
,  salary
FROM 
   People
WHERE 
   name IN(SELECT name FROM toronto_ppl)
   AND salary >= (SELECT avg_salary FROM avg_female_salary)

现在很容易看出 WHERE 子句正在过滤多伦多的名称。CTE 非常有用，不仅因为可以将代码分解成更小的块，还因为可以为每个 CTE 分配一个变量名(例如 toronto_ppl 和 avg_female_salary)。

说到变量名，这引出了我的下一个观点:

6.描述性变量名称

当您创建变量名时，您希望它们描述它们所代表的内容。考虑我之前的例子:

with toronto_ppl as (
   SELECT DISTINCT 
      name
   FROM 
      population
   WHERE 
      country = "Canada"
      AND city = "Toronto"
), avg_female_salary as (
   SELECT 
      AVG(salary) as avg_salary
   FROM 
      salaries
   WHERE 
      gender = "Female"
)SELECT 
   name
,  salary
FROM 
   People
WHERE 
   name IN(SELECT name FROM toronto_ppl)
   AND salary >= (SELECT avg_salary FROM avg_female_salary)

只需阅读变量名称本身，就可以清楚地看到，第一个 CTE 正在检索来自多伦多的人，第二个 CTE 正在获取女性的平均工资。

另一方面，这将是一个糟糕的命名约定的例子，(事实上我以前见过):

with **table_one** as (
   SELECT DISTINCT 
      name
   FROM 
      population
   WHERE 
      country = "Canada"
      AND city = "Toronto"
), **table_two** as (
   SELECT 
      AVG(salary) as **var_1**
   FROM 
      salaries
   WHERE 
      gender = "Female"
)SELECT 
   name
,  salary
FROM 
   People
WHERE 
   name IN(SELECT name FROM **table_one**)
   AND salary >= (SELECT **var_1** FROM **table_two**)

7.使用临时函数简化代码

临时函数是

1. 分解代码
2. 编写更干净的代码
3. 并且能够重用代码。

如果你想了解更多关于临时函数的内容， 你可以阅读这篇文章 。

考虑下面的例子:

SELECT name
       , CASE WHEN tenure < 1 THEN "analyst"
              WHEN tenure BETWEEN 1 and 3 THEN "associate"
              WHEN tenure BETWEEN 3 and 5 THEN "senior"
              WHEN tenure > 5 THEN "vp"
              ELSE "n/a"
         END AS seniority 
FROM employees

相反，您可以利用一个临时函数来捕获 CASE 子句。

CREATE TEMPORARY FUNCTION seniority(tenure INT64) AS (
   CASE WHEN tenure < 1 THEN "analyst"
        WHEN tenure BETWEEN 1 and 3 THEN "associate"
        WHEN tenure BETWEEN 3 and 5 THEN "senior"
        WHEN tenure > 5 THEN "vp"
        ELSE "n/a"
   END
);SELECT name
       , seniority(tenure) as seniority
FROM employees

有了临时函数，查询本身就简单多了，可读性更好，还可以重用资历函数！

8.有意义的评论

下面是写评论时最重要的规则:只在需要的时候写评论。

通过遵循前面的七个技巧(使用描述性名称、模块化代码、编写干净的代码等。)应该不需要写很多评论。

也就是说，当代码本身不能解释你想要达到的目的时，注释是有用的，也许是必需的。

下面是一个差评的例子:

# Getting names of people in Toronto, Canada
with table1 as (
   SELECT DISTINCT name
   FROM population
   WHERE country = "Canada"
         AND city = "Toronto"
)# Getting the average salary of females
, table2 as (
   SELECT AVG(salary) as var1
   FROM salaries
   WHERE gender = "Female"
)

这些是糟糕的注释，因为它告诉我们通过阅读代码本身我们已经知道了什么。记住，评论通常会回答你为什么做某事，而不是你在做什么。

感谢阅读！

务必 订阅此处 千万不要错过另一篇关于数据科学指南、诀窍和技巧、生活经验等的文章！

不确定接下来要读什么？我为你挑选了另一篇文章:

还有一个:

-特伦斯·申

• 如果您喜欢这个， 订阅我的媒介 获取独家内容！
• 同样，你也可以 关注我上媒
• 报名我的个人简讯
• 跟我上LinkedIn其他内容

快速入门 MLflow 跟踪的 8 个代码片段

原文：https://towardsdatascience.com/8-code-snippets-to-quickly-get-started-with-mlflow-tracking-63064d99d3ff

更好地记录实验和重现实验的技巧

照片由 Fotis Fotopoulos 在 Unsplash 上拍摄

作为一名数据科学家，我每天都在使用 MLflow。

我用它来跟踪机器学*实验，将模型推送到注册表并对其进行版本管理，并轻松地与同事就相同的项目进行协作。

在深入使用这个工具一年多后，我开始了解它的来龙去脉，作为对这段经历的总结 ，这篇文章是我经常使用的 8 个有用代码片段的汇总。

随意跳过你知道的，浏览那些你不太熟悉的。

事不宜迟，我们来看看吧！🔍

📚MLflow 术语的 30 秒快速回顾

之前在 MLflow 上写过帖子。如果您有兴趣了解更多关于这个 MLOps 工具的信息，这里有一个 6 分钟的故事，涵盖了基本知识⏬

MLflow 有四个组件。

我们今天感兴趣的一个叫做 MLflow Tracking :广义来说，你可以把它看作模型和机器学*项目的 GIT 仓库。

它允许您在一个中心位置，即一个远程服务器，跟踪参数、指标和文件(也称为工件)。

MLflow 跟踪被组织成实验，并且每个实验被分成运行(这就是你在这篇文章的其余部分需要知道的)。

作者图片— MLflow 术语

例如，一个实验可以专用于训练用于肺炎检测的计算机视觉模型，并且该实验中的每次运行将与特定的训练会话相关。因此，跑步与其他跑步不同，每次跑步都有:

• 一组特定的超参数:学*率、辍学率、层数等。
• 性能指标 : f1 分数、准确度等。
• 工件:这些可以是不同格式的文件:分类/误分类图像样本、用于视觉解释的激活图、CSV 文件中的预测、HTML 报告等。

考虑到这一点，现在让我们来看看有望让您提高工作效率的代码片段。

PS:在运行以下代码片段之前，您应该创建一个 MLflow 实验并启动一个 UI 服务器。如果不知道怎么做，可以查看我之前的* 帖子 。

1-记录运行中的数据

在 MLflow 上创建一个实验之后，记录数据可能是您与该工具的第一次交互。

要记录一些参数和指标，首先需要开始一次运行，并在其上下文中调用log_param和log_metric方法。

这两个方法将一个键和值作为第一个和第二个参数。

这里有一个例子:

或者，也可以使用log_param**s** 和log_metric**s** 的方法。在这种情况下，您必须传递一个参数或度量的字典。

👉在with语句后声明的run对象允许你访问当前运行的信息。

该信息可通过to_dictionary方法提取。

小心⚠️

当指标对您的数据有意义时，或者如果您想根据它们的值对您的跑步进行排序，请使用指标。例如，如果您想按递减的层数对运行进行排序，n_layers应该是一个度量而不是一个参数。

下面是当n_layers作为一个参数被记录时发生的情况:它被认为是一个字符串，递增顺序变成1、10、11等等。

作者截图— n_layers 被视为字符串

2-记录嵌套运行中的数据

不管出于什么原因，这种情况可能会发生，您可能希望在另一个运行中创建一个运行。语法和以前一样:唯一的区别是在创建嵌套运行时，您必须将nested参数设置为 True。

下面是 MLflow UI 上的视觉效果:可以折叠内部有嵌套运行的运行。

作者截屏—嵌套运行的示例

👉值得注意的是，这两个运行——父运行和嵌套运行——有两个不同的运行 id。

3-根据其 id 获取运行并访问其数据

给定运行 id，您可以提取一个运行对象，这允许轻松地访问它的数据:参数、度量、标签和元数据。

运行对象将有两个属性:

• data:封装了一个RunData对象，其中包含了度量、参数和标签

**>>> run.data.metrics
{'coverage': 0.76, 'f1': 0.83, 'precision': 0.76, 'recall': 0.92}****>>> run.data.params
{'dropout': '0.25', 'lr': '0.01', 'n_layers': '5', 'optimizer': 'Adam'}**

• info:它封装了一个RunInfo对象，该对象包含额外的运行元数据，比如开始和结束时间、run_id、实验 id 和工件 URI。

**>>> run.info.run_id
'5aa1f947312a44c68c844bc4034497d7'****>>> run.info.experiment_id
'418327'**

4-基于搜索查询过滤运行

您可以轻松搜索跑步记录。

让我们首先创建 50 个具有随机度量值和参数值的假运行。

如果您想要基于特定的过滤器搜索这些运行，您可以直接从界面中进行搜索。

例如，如果您想要过滤使用 SGD 作为优化器的运行，您必须在搜索框中输入以下查询:

**params.optimizer="sgd"**

用户截屏—基于搜索查询的过滤器运行

如果您想以编程方式实现这一点，您必须使用search_runs方法并将搜索查询传递给filter_string参数。

您还可以有更复杂的搜索查询。

👉点击 可以了解更多搜索语法 。

5-上传工件

除了参数和度量之外，运行还可能包含诸如 CSV 文件、二进制对象、HTML 页面、图像等工件。

要上传工件，请使用log_artifact。作为第一个参数，这个方法采用本地文件系统上的工件路径。

一旦工件被记录，您可以从 UI 中点击 run 并检查文件是否被正确上传。

图片由作者提供—上传的工件

如果我们想要提供一个目标文件夹来写入工件，我们可以在artifact_path参数中设置它。

例如，让我们将artifact_path设置到一个名为stats的文件夹中。

如果我们再次检查 UI，我们会看到stats_comparison.csv文件现在在stats文件夹中。

作者截屏——上传的工件和目标文件夹

我们也可以使用log_artifact**s**方法来上传一个目录的全部内容。

→简而言之:

• 您可以在每次运行时上传任何想要的工件
• 您可以自定义目标文件夹层次结构
• 要上传文件夹的全部内容，请使用log_artifact**s**
• 要上传单个文件，请使用log_artifact

6-下载工件

正如所料，下载运行的工件也是可能的:您可以通过调用download_artifacts方法来完成。

让我们使用之前的运行，在其中我们将图像记录为工件，并在本地创建一个downloads文件夹来下载它们。

download_artifacts除了运行 id 之外，还有两个重要的参数。

• path是 MLflow 跟踪服务器中所需工件的相对源路径
• dst_path是下载指定工件的本地文件系统目标目录的路径。该目录必须已经存在。

如果我们将path设置为**.**并将dst_path设置为**downloads**，那么运行中记录的所有内容都将被下载到**downloads**文件夹中。

但是您也可以将**path**参数设置为运行中任何想要的工件路径。你不必下载所有的东西。

7-更新现有运行

如果运行已经存在，您可以向其中添加更多数据，也可以更新现有数据。你所需要的只是它的运行 id。

让我们更新之前运行的指标。

以下是更新前的运行指标:

作者截图—更新前运行

让我们生成一些随机指标，并用它们来覆盖前面的指标。这是通常的语法。唯一的区别是您设置了run_id参数，而不是experiment_id。

如果我们在 UI 上再次检查相同的运行，我们将看到指标已经更新。

作者截图—更新后运行

⚠️关于更新运行参数的说明

出于某种原因，MLflow 不允许您覆盖现有运行的参数。

如果您运行以下代码:

您将面临以下错误:

作者截图—参数覆盖后的 MLflowException

我承认，更新运行参数在许多情况下都是有用的。如果你知道一个简单的方法，请在评论中告诉我。

8-创建并上传自定义 Pyfunc 模型

除了支持用通用框架(scikit-learn、Keras、Gluon 等)构建的机器学*模型的日志记录。)，MLflow 提供了将任意 python 代码包装在一个类中并使用它进行推理的灵活性。

当您的推理管道不标准时，这非常有用。当您的模型在预测时需要包含外部工件，或者当它需要发送多个输出或执行某种后处理时，可能会发生这种情况。

当您还需要在预测管道中集成一些业务逻辑时，使用自定义模型会很有价值:这是发挥创造力的地方。

👉让我们构建一个定制的 pyfunc 模型来演示这是如何实现的。

这个模型将使用一个经过训练的随机森林作为工件。它将通过添加一些数据验证来自定义推理，并将在一个字典中返回多个输出。

这只是一个例子，但是它应该给你一些灵感来开发更复杂的管道。

• 首先，让我们训练一个随机森林模型。为了简单起见，我们将使用虹膜数据集。
  一旦通过交叉验证对模型进行了训练和评估，我们将使用 joblib 库保存它。

• 我们准备了一个字典，列出了所有将与模型一起上传的工件。
  该字典将引用每个工件的本地路径，MLflow 稍后将负责上传它。

• 通过继承 PythonModel 类来定义 MLflow 包装器。

这个类必须覆盖两个方法:load_context和predict。

1. load_context接收一个上下文参数，其中包含模型的工件路径。该方法作为一个构造函数，用于将模型工件作为属性加载。
2. predict接收上下文和输入参数。inputs论证是一本字典。这是你获得创造力和定制推理逻辑的地方。

在下面的例子中，predict方法提取输入特征，验证它们的形状，并将它们传递给预加载的模型工件。

然后，它提取多个预测，如概率分数和预测标签，并用成功消息将所有内容打包到一个字典中。

• 为了上传定制模型，我们首先需要创建一个 AwesomeModel 类的实例，并将其传递给mlflow.pyfunc.log_model函数。
  这个函数也采用我们在下面定义的工件字典。

一旦模型被记录，它就在 MLflow UI 上变得可见。

注意 MLflow 是如何自动添加一个包含预先训练的随机森林模型的artifacts文件夹的。

作者截图—上传的 pyfunc 模型

• 现在给定运行 id，您可以本地加载模型并执行推理。
  一切都打包成这个模型。

酷吧？

资源:

这里有一个材料列表，您可以通过它来了解更多关于 MLflow 的信息:

• https://towards data science . com/5-tips-for-ml flow-experiment-tracking-c 70 AE 117 b 03 f
• https://towards data science . com/how-to-use-ml flow-on-AWS-to-better-track-machine-learning-experiments-BBC b8 ACD ed 65
• https://www . ml flow . org/docs/latest/tutorials-and-examples/tutorial . html

感谢阅读🙏

如果您已经做到了这一步，我想感谢您的宝贵时间，并希望您已经学到了一些关于有效使用 MLflow 的有用知识。

如果你知道其他 MLflow 技巧，请在评论中告诉我。

话虽如此，我还是祝你编码愉快💻。

下次见！👋

新到中？你可以每月订阅 5 美元，并解锁各种主题的无限文章(技术、设计、创业……)，你可以通过点击我的推荐链接来支持我。

https://ahmedbesbes.medium.com/membership

由 Karsten Winegeart 在 Unsplash 上拍摄

8 个 Codecademy 备选方案将带你去你需要去的地方

原文：https://towardsdatascience.com/8-codecademy-alternatives-that-will-get-you-where-you-need-to-go-2e82e25eecb6

当代码学院不合适的时候

photo by pix abay:https://www . pexels . com/photo/elbody-blur-bookcase-books-261895/。我没有得到任何报酬去推广任何一个 Codecademy 的替代品，或者 Codecademy 本身！

就在上个月，Codecademy 被 T2 以 5 . 25 亿美元的价格卖给了 Skillsoft。不算太寒酸，如果你问我的话，这完全是理所应当的。我就直说了吧，我喜欢 Codecademy。也许你想知道为什么我在一篇关于 Codecademy 替代品的文章中以此开头，但我想从历史开始，这样你就可以真正理解它的替代品有什么好处。

Codecademy 于 2011 年由一名哥伦比亚大学辍学生和他的哥伦比亚大学非辍学生朋友创办。这是最早的编码在线学*平台之一。这对当时来说是革命性的。在那之前，想要成为程序员的人必须获得计算机科学学位，或者观看粗糙的 YouTube 视频，自己想出命令行。有了 Codecademy 欢快的界面和免费的指导课程，突然间每个人都可以学*编码了。

Codecademy 筹集了 1250 万美元的资金后，其他聪明人有了一个好主意，也许用户友好的编码平台有市场。根据美国劳工统计局的数据，计算机科学就业市场开始升温，造成了熟练工人的短缺，这种情况至今依然存在。今天，Codecademy 有几十种替代方案。

因为大多数课程都有相似的定价，我将主要从其他方面比较这些 Codecademy 的选择。

为了便于比较，您应该知道 Codecademy 有一个免费层。要访问职业跟踪和扩展课程，你必须支付 Pro tier 的费用，每月 39.99 美元(如果按年计费，则为 19.99 美元)。

这是一个很好的平台。但它不是万能的。它有许多缺点，使得它在许多情况下不是完美的解决方案。如果你因为在谷歌上搜索“代码学院的替代方案”而偶然发现了这篇文章，那么你很可能正处于其中一种情况。

让我们进入我们的阵容，看看你是否能找到更好的选择。

数据营:深入数据科学

Codecademy 拥有坚实的数据科学职业道路。但它只有一个。正如您可能想象的那样，将所有数据科学职业知识纳入一门课程几乎是不可能的。虽然它深入研究了广泛的工具、语言和概念，但这种广度让人很难感觉到你已经从一门据称会给你职业知识的课程中获得了你真正需要的良好基础。

如果你想在(极其广阔的)数据科学领域获得更多的灵活性，Datacamp 是我推荐的 Codecademy 替代品。Datacamp 提供多种职业道路，这是有意义的，因为数据科学家不是一个企业集团。与 Codeacademy 相比，每个专题讲座将讨论一种语言和较少的概念和工具。然而，如果你参加了所有的 Datacamp 课程，你会比只参加一个 Codecademy 课程有更好的数据科学基础。即使你没有，你仍然有更多的灵活性来选择最吸引你的数据科学领域。

价格对比:两者具有可比性。对于 Datacamp 的专业版，你将每月支付 39.99 美元，或者如果你按年计费，每月 12.42 美元。

Code.org:不要付钱

通常，你会得到你所付出的。Code.org 是这个规则的一个很大的例外，因为它是一个完全免费的超级资源。哈迪·帕托维和阿里·帕托维兄弟创建这个非营利组织主要是因为 90%的美国学校不教代码。

从伦理上讲，Code.org 是所有 Codecademy 替代品中最酷的。这是一个非营利组织，致力于把编码素养带到高中，集中在农村和城市的学校。他们还花费大量资源吸引女性和少数民族学生，因为他们在大学之前最有可能得不到任何计算机科学教育。

主要问题是它是针对字面上的儿童。但老实说，当我开始编程时，我可能拥有和一个特别有进取心的 7 岁孩子一样的技能，因为我是上面提到的在大学之前没有接受任何计算机教育的女孩之一。我喜欢他们的迪士尼/电子游戏/动物导向课程。除了他们的课程，他们还提供“一小时的代码”教程，只需要一个小时就可以学到一些东西。这些对快速获胜很有帮助。

价格比较:字面上的免费。

freeCodeCamp:学* Web 开发

freeCodeCamp 有一个非常值得回味的起源故事。早在 2014 年，一位名叫昆西·拉森(Quincy Larson)的老师想要学*编码，这样他就能为他的学生制作更好的学*工具。他的旅程是如此曲折和痛苦，以至于他受到启发创建了 freeCodeCamp，以此来拯救其他人，使他们不必做和他一样的事情。

与 Codecademy 相比，FreeCodeCamp 就像是 web 开发领域的一个年长(而且免费)的姐妹。课程很紧张——整整 2080 个小时或大约一年的全职编码。它还与其他非营利组织广泛合作，构建网络应用程序。

唯一的缺点是它严重依赖于网络开发。

价格对比:还是免费的。名字里就有。

解决基本问题

Codeacademy 的问题是它倾向于硬塞所有的技能，而没有真正让你获得计算机科学的基础知识。

让我们明确一点:Codecademy 课程对初学者来说是不错的。他们会带你学*你需要的大部分技能。但是任何一个行业老手都知道，简历上列出的技能并没有多大意义。是作品集让你获得了面试机会，是你在面试中展示的实时技能让你获得了工作。

Codecademy 的课程，尤其是专业课程，会让你学到一些技能，甚至会为你的作品集带来一两个项目。但是你对计算机科学基础的理解永远不会受到真正的挑战。当谈到获得 Codecademy 的工作时，你可能会因为缺乏概念性的理解而感到失望。

相比之下，Boot.dev 则是关于建立强大的基础。这些课程围绕概念，并使用编码语言来帮助你掌握这些概念，如函数式编程或 Big-O 算法。

价格比较:Boot.dev 每月花费 29.99 美元，如果按年计费，则每月花费 16 美元。还有一个免费的沙盒版本。

Coursera:获取高质量的视频教程

Coursera 基本上是一个视频平台，从大量备受尊敬的机构那里获得资源。如果你在他们的网站上搜索“计算机科学”，你会看到从普林斯顿到 IBM 的视频课程选项。他们确实提供了一些指导性项目(比如用 Python 和 Flask 构建 web 应用程序)，但他们的优势在于他们庞大的内容库。

非常适合视频。对其他任何事情来说都没那么好。作为 Codecademy 的替代方案，它最适合那些正在寻找声望认证或喜欢视频学*的人。

价格比较:每月 39-79 美元

零到精通:针对真正的初学者

零到精通是一个有趣的例子。基本上，这是一群专家，他们制作了大量不同主题的视频课程，都在 Udemy 上。我自己是一个零到精通的老师——我的博客基础课程将在几周内推出。

ZTM 的伟大之处在于，特别是作为 Codecademy 的替代方案，它确实是从零开始的，顾名思义，这对初学者来说很棒。Codecademy 适合初学者吗？我认为这很大程度上取决于有问题的初学者。

与此同时,《零到精通》假设完全没有先验知识。你可以从有魅力、迷人的老师那里得到一些有用的信息。

尽管主要是视频教程，他们也提供练*册和项目来辅助完成。也有相当大范围的课程和赛道。我还喜欢它的一点是，它会定期更新，这对任何计算机科学/数据科学学*平台来说都是一个巨大的优势。

价格比较:每月 39.99 美元，或按年计费每月 23 美元。

edX:引导学*

还记得我说过在 Codecademy 这样的平台出现之前，你唯一的选择就是学位或者自己动手做吗？edX 是对那个时代的一种回归，但这是一种好的方式。哈佛大学和麻省理工学院合作建立了这个 MOOC，基本上就像是一个在线学位，但是非常便宜和灵活。

每门课程都有每周的学*顺序。学生们会得到一组混合有互动练*的短视频，让他们练*刚刚学到的概念。还有一个相当稳固的社区，与你在真实的校园课堂中得到的没有什么不同——学生和老师可以在论坛上发帖和回答问题。

总而言之，和 Coursera 挺像的，但是更多的是动手学*。它是如此有条理和有指导的。作为 Codecademy 的替代方案，它最适合那些不想只依赖视频课程的人

因为它非常受人尊敬，你也可以得到一个被很多大学接受的证书。因此，这就像一个学位精简版——完成一门课程后获得一个证书需要花费 50 到 300 美元。

价格比较:绝大多数 edX 课程都是免费的，但你必须支付一次性费用才能参加认证版本的课程。

DIY:仅限 DIY 者

我最后一个选择是自学。老实说，信息就在那里。如今，大多数开明的雇主并不真的需要证明你完成了这个新兵训练营或那个课程。如果你有一个项目组合，并能在面试中坚持自己的观点，你就成功了。

YouTube 视频，教科书，上面提到的任何/所有 Codecademy 替代品的免费层——所有这些都将帮助你 DIY 你知道如何编码的方法。我的生物学学位确实教会了我 R 的基础知识，但我从未真正“理解”它，直到我被迫实际上谷歌一下什么是 for 循环，并在我自己的代码中实现它。我这样做的动机是因为我渴望回答我的硕士们的一个研究问题，而没有人愿意帮助我。(很公平。)Google，StackOverflow，R 教材，GitHub，最重要的是，我满足好奇心的燃烧的欲望教会了我如何编码。

如果你根本不喜欢指导学*，DIY 学*是一个很好的选择。就我个人而言，我从来没有被一个告诉我下一步该做什么的屏幕激励过。课程资助的项目从未吸引过我。所以我知道还有像我一样的人。

价格:免费，但代价是许多沮丧而毫无结果的时间盯着你的屏幕乞求知道为什么代码不工作，并知道这是你自己的错，没有通过一个严格的学*计划。

什么是最好的代码替代方案？

永远不会有一个单一的 Codecademy 替代方案对每个想要学*编码的人来说都是完美的。每个平台都是由不同的人或团队开发的，他们有不同的动机和目标。每个人都从稍微不同的地方开始他们的编码之旅，并且有不同的需求。其中一些编码需求甚至还没有得到满足——很难找到一个面向非英语人士的编码课程或平台。

正如我所说的，当我在 2015 年尝试 Codecademy 时，对我来说“最好”的 Codecademy 替代方案是完全取消课程和计划，全部由我自己完成。这对很多人来说是行不通的。

我不想提供一个确定的或排名的列表，我想列出一个你需要自己做出选择的所有细节的列表。浏览这个 Codecademy 备选列表，看看哪一个适合你。你甚至会发现 Codecademy 毕竟是你最好的选择。这些选项中的大部分都提供了某种免费层，所以您应该可以随意尝试任何看起来有趣的选项。

不同意？你还有什么要补充的吗？请在评论中告诉我。

在 R 中学* 8 个很酷的 Dplyr 函数

原文：https://towardsdatascience.com/8-cool-dplyr-function-to-learn-in-r-8736d7fa899c

在本帖中，我们将检查一些最酷的 R 数据争论库中可用的重要函数——dplyr

图片来自Ales Nesetril@ unsplash . com

D plyr 是一个非常方便的库，你可以在 R 中使用。DP lyr是一个数据操作包，它是tidy verseuniverse 的一部分，universe 是一个库集合，目标是使 R 更快、更简单、更容易。**

除了可以通过安装包来访问的很酷的功能之外， Dplyr 利用了管道(%>%)结构，这是封装功能的更好方式。可以说，管道使你的 R 代码更容易调试和理解——有时，以牺牲一些速度为代价。

该库有几十个函数可用于执行数据操作和争论——在本文中，我们将探讨以下几个:

• filter —过滤行；
• arrange —对数据帧进行排序；
• mutate —创建新列；
• sample_n—从数据帧中取样 n 行；
• sample_frac —从数据帧中抽取一定百分比的行；
• summarize —执行聚合功能；
• group_by —按特定关键字对数据进行分组；
• inner, left and right_join—通过键组合多个数据帧；

在这篇文章中，对于一些函数，我们还将比较如何使用 R 基本代码实现相同的目标——在大多数情况下，这将帮助我们理解在一些 R 操作中使用 dplyr 的好处。

我们将使用starwars dataframe 来执行我们的示例，这是一个内置的数据集，您可以在运行library(dplyr)后立即使用。

在我们开始之前，不要忘记在 R:

**# Installing the dplyr Package
install.packages('dplyr')# Loading the library
library(dplyr)**

预览我们的starwars数据帧:

星球大战数据帧预览——作者图片

该数据帧包含 87 行和 14 个与《星球大战》系列中不同角色相关的变量。这个数据帧是一个可以用来玩dplyr库的玩具数据帧——我们将使用它来理解我们的dplyr函数的行为，并用一些例子来玩。

过滤器

我们将学*的第一个dplyr函数是filter。该函数广泛用于使用一个或多个条件从数据帧中过滤行。

Filter 是一个非常酷的功能，可以从数据帧中筛选出行——例如，让我们过滤掉所有在starwars表中属于Droid的物种:

**filter_droids <- starwars %>%
  filter(species == 'Droid')**

这段代码输出了星球大战系列数据中的 7 个字符:

从《星球大战》数据帧中过滤机器人——图片由作者提供

我们可以使用 base R 中的索引来实现完全相同的事情——有一个很大的警告:

**starwars[starwars$species == ‘Droid’,]**

上面的代码会产生一些NA’s——你必须添加一个额外的条件到Droid物种的 only 子集。这是使用filter功能的主要优势之一(自动删除 NA)——而不是通过%>%访问。

filter功能的另一个很酷的特性是我们可以灵活地添加更多的条件——例如，让我们只选择金色“皮肤”颜色的Droids:

**filter_droids_gold <- starwars %>%
 filter(species == ‘Droid’, skin_color == ‘gold’)**

这只输出一个 droid — C3PO！

从《星球大战》数据帧中过滤金色皮肤的机器人——图片由作者提供

通过给函数添加新的参数，我们提供了更多的条件。filter函数的这一特性使得您的代码更易于阅读和调试——尤其是当您有复杂的过滤器时。

安排

arrange根据特定列对表格进行排序。例如，如果我们想按高度排序我们的starwars数据帧，我们只需键入:

**sorted_height <- starwars %>%
 arrange(height)**

表格输出:

按照人物高度对星球大战数据帧进行排序——图片由作者提供

我们按照高度列对表格进行排序，从最短的字符到最高的字符。

我们如何颠倒身高顺序？超级简单，我们只需要在列前加一个-:

**reverse_sorted_height <- starwars %>%
 arrange(-height)**

按人物高度降序排列《星球大战》数据帧——图片按作者排序

在这种情况下，我们获得降序排列的数据—在输出中，我们可以看到亚雷尔·普夫是最高的一个，这是有意义的！

在 base R 中，您可以使用order和索引来模拟表排序:

**starwars[order(starwars$height),]**

使用 base R 的一个警告是，当我们想要按多列排序时，我们的代码会很快变得混乱。

在dplyr中，这很简单，你可能已经猜到了——我们只是给arrange函数添加了一个新的参数！

**sorted_hair_height <- starwars %>%
 arrange(hair_color, height)**

按多列排序星球大战数据帧——按作者排序图片

在这种情况下，我们按以下顺序输出字符:

• 首先，我们按字母顺序将角色按hair_color排序。
• 通过每个hair_color，排序由height应用。

很酷，因为我们可以用一个简单的函数方便地对表格进行排序。此外，我们可以通过简单地添加新的参数向排序顺序添加更多的列，这一事实使得arrange成为您想要执行排序操作时的首选函数。

使突变

mutate是一个很酷的向表格添加新列的功能。

例如，假设我想在星球大战表中添加一个新列，其中包含两列的乘积——height和mass。让我们称这个列为height_x_mass:

**starwars_df <- starwars %>%
  mutate(height_x_mass = height*mass)**

在上面的例子中，我将结果写入一个新表starwars_df，因为现有的列保留在mutate函数中。mutate所做的只是向现有数据帧添加一个新列。

让我们看看上面代码的结果对象——滚动到 R 预览器的最后一列:

在《星球大战》数据帧上用 Mutate 创建的新列——图片由作者提供

如果您滚动到 R 数据帧预览器的末尾，您可以看到我们的新列已创建！

此栏是height乘以mass的计算结果。让我们检查一个例子，第一行包含关于特许经营主角的数据— Luke Skywalker。

卢克身高 172 厘米，体重 77 公斤:

卢克·天行者数据来自斯塔沃斯数据框架——图片由作者提供

*我们期望Luke的height_x_mass是 17277，13.244。这是我们在第一行最后一列获得的值吗？让我们再检查一遍:

在《星球大战》数据帧上用 Mutate 创建的新列——图片由作者提供

确实是！

使用mutate,我们可以基于现有信息或全新的值创建新列。还有，你认为我们可以同时添加多个列吗？

让我们看看！

**starwars_df <- starwars %>%
 mutate(height_x_mass = height*mass,
 franchise = ‘Star Wars’)**

在星球大战数据帧上用 Mutate 创建的新列——图片由作者提供

不错！我们可以通过向函数添加一个新的参数来同时添加多个列——听起来很熟悉吧？这就是dplyr如此灵活的原因！

请注意，在上面的示例中，我们添加了两个新列:

• 正如我们已经讨论过的，带有height_x_mass的列。
• 名为franchise的新列包含所有行的字符串“星球大战”。

样本 N 和样本分数

当您使用 R 执行一些数据科学、统计或分析项目时，您可能需要在整个管道中进行某种类型的采样。

使用 R base 时，必须处理索引，这有点容易出错。

幸运的是，dplyr有两个非常酷的函数来执行样本:

• sample_n根据大量元素从数据帧中随机抽取行。
• sample_frac根据数据帧原始行的百分比从数据帧中随机抽取行。

让我们看看！

**starwars_sample_n <- starwars %>%
  sample_n(size=5)**

《星球大战》数据帧中的 5 行样本——作者图片

注意，sample_n函数的输出给了我们 5 行——参数size的编号。使用sample_frac，我们不是检索“整数行”,而是检索原始行的百分比——例如，如果我们想获得 1%的行，我们可以提供:

**starwars_sample_frac <- starwars %>%
 sample_frac(0.01)**

《星球大战》数据帧中 1%的行样本——作者图片

为什么我们在输出中只看到一行？

原始的starwars数据帧包含 87 行。87 的 1%是多少？0.87.这个数字被向上取整，我们最终只从表中检索到 1 行。

如果我们给sample_n函数 0.02，你能猜出我们将检索多少行吗？

**starwars_sample_frac <- starwars %>%
 sample_frac(0.02)**

《星球大战》数据帧中 2%的行样本——作者图片

0.02 * 87 等于 1.74 所以我们从表中抽取 2 行！

sample_n和sample_frac非常酷，因为只需修改一小部分代码，就可以在采样方法之间轻松切换。

概括

summarise是一个非常方便的编写汇总函数的包装器。例如，假设我们想要获得height变量的平均值——使用基数 R，我们可以:

**mean(starwars$height, na.rm=TRUE)**

这在技术上是正确的——我们使用na.rm从列值中移除 NA，然后将平均值应用于向量。在summarise中，我们可以进行以下操作:

**starwars %>%
 summarise(height_mean = mean(height, na.rm = TRUE))**

这也输出大约 174，即height列的平均值。使用summarise相对于基数 R 有两个很酷的特性:

• 的第一个特点是我们可以在不同的功能之间跳转:

****starwars %>%
 summarise(height_max = max(height, na.rm = TRUE))****

我修改了函数来计算列的max，而不是mean。你可以在这里查看T4支持的一些内置功能

• 第二个很酷的特性，可能也是最有用的，是你可以用group_by封装汇总函数来产生每组的值。例如，如果我想通过Species检查mean，我只需要:

****mean_height_by_species <- starwars %>%
 group_by(species) %>%
 summarise(height_mean = mean(height, na.rm = TRUE))****

酷！我可以在我的summarise之前执行一个group_by，输出每个species字符的平均高度。让我们看看输出数据帧:

通过小组示例进行总结—图片由作者提供

对于每个species，我们都有一个height_mean。这为我们提供了数据帧中每个特定species的所有字符的平均值height的概述。例如，从预告来看，伊渥克和阿列纳斯是平均身高最短的物种，这是有道理的！

在构建数据管道时，结合使用 summarise 和其他dplyr指令是很常见的。

如果你熟悉 SQL，在上面的例子中，我们用 3 行代码模拟了GROUP BY子句的行为。这是一个比基数 r 更容易使用的例子。

内部、左侧和右侧连接

说到SQL , dplyr有一些有趣的函数来执行数据帧连接。

假设我们有一个辅助数据框架，其中包含每个物种的虚拟起源，数据如下:

物种起源示例—作者图片

数据帧包含关于《星球大战》系列中一个物种的虚构起源的信息。我们可以使用连接将这个数据帧和starwars数据帧结合起来吗？

我们可以使用dplyr中的join功能来完成！先说一个inner_join:

****starwars_inner <- starwars %>%
 inner_join(species_origin, on=’Species’)****

inner_join函数在%>%之前的表和函数的第一个参数之间执行连接。在这种情况下，我们通过Species列连接starwars和species_origin数据帧。

该连接输出 36 个观察值和一个额外添加的列:

《星球大战》和《物种起源》数据框架内部连接的结果——图片由作者提供

注意，我们已经将origin列添加到了starwars数据帧中。自然，内连接只返回两个物种:Human和Ewok。由于我们正在执行一个inner_join，我们只返回键在两个数据帧中的行。

如果我们执行left_join，我们的数据帧的域会改变:

****starwars_left <- starwars %>%
 left_join(species_origin, on=’Species’)****

在这种情况下，返回的数据帧包含 87 行和附加列。当我们在species_origin中找不到该信息时,origin列会发生什么情况？让我们看看:

《星球大战》和《物种起源》数据帧左连接的结果——图片由作者提供

它被赋值给一个NA值！虽然我们从左边的表中取出所有的行(在%>%之前的数据帧)，但是在species_origin数据帧上没有匹配的species在origin上有一个NA值。

与inner_join和left_join类似，我们在dplyr中也有一个right_join:

****starwars_right <- starwars %>%
 right_join(species_origin, on=’Species’)****

在右连接中，主表是在函数的第一个参数中指定的表— species_origin。

对于 SQL 用户来说，这些dplyr函数将使他们向 R 的过渡更加容易，因为他们可以使用与大多数 SQL 实现相似的逻辑来执行连接。

我们完了！感谢你花时间阅读这篇文章，我希望你喜欢在dplyr世界中导航。可以说，在你的代码中使用dplyr会使你的代码更容易阅读和使用——这是在你的项目中消除代码债务的一个小小的推动。

我在 Udemy 上建立了一个R入门和一个** 学*数据科学的训练营 。这两个课程都是为初学者量身定做的，我希望你能在我身边！****

数据科学训练营:你成为数据科学家的第一步 —图片由作者提供

绝对初学者的 R 编程 —图片作者

****https://ivopbernardo.medium.com/membership

下面是这篇文章中例子的一个小要点:****

面向数据工程师和分析师的 8 种基本 Python 技术(带代码示例)

原文：https://towardsdatascience.com/8-essential-python-techniques-for-data-engineers-and-analysts-with-code-samples-5915b31ce724

这些是我重复使用最多的 Python 代码片段

即使是最有经验的程序员也要用谷歌搜索。

我重新搜索我一直使用的简单代码行，只是为了快速提醒语法。从这个意义上说，我真的是在为自己写这篇文章。这些是我作为数据通才反复使用的最常见的 Python 代码。

(以下所有示例都是使用 Python 3.6 或更高版本完成的)

将数据库中的数据查询成 Pandas 数据帧或 CSV 文件

https://gist . github . com/camw 81/1 CCA 77 c 0878d 60 B2 C1 c 0d 839649 a 7a

当 SQL 不足以进行分析或复杂的数据转换时，Python 可能是答案。但是在你争论任何数据之前，你必须把数据放到内存中，这样你就可以用它做一些事情。如果您的数据库在 MS SQL Server 上，使用 PYODBC 如果您在 Postgres 上，使用 PSYCOPG2，您可以使用 Python 轻松地编写查询和提取数据。从那以后，只需要将数据转换成易于使用的格式。为此，我喜欢熊猫。将查询数据放入 Pandas 非常简单，只需将列表转换成 CSV，然后使用 pandas read_csv 函数。或者，如果需要的话，您可以将 read_csv 构建到您的 run_sql 函数中。

发送带有完整错误代码输出的电子邮件警报

https://gist . github . com/camw 81/c 791 a 3 直流 992462059 接入 0562225ffc

监控自动化作业(cron 或其他)中的错误对于运行数据管道或其他代码至关重要。我广泛使用电子邮件提醒，当我在自动节奏上运行的任何脚本中断时提醒我。

为了快速找到问题的根源，我也非常喜欢在我的电子邮件中收到 Python 的完整回溯错误消息，这样我就能确切地知道在我修复脚本时要寻找什么。traceback 包允许您使用 traceback.format_exc() 来获取这些信息，然后将其作为一个字符串放入您的电子邮件中。

使用代码片段的最佳方式实际上是将函数调用到另一个脚本中，在该脚本中有您想要监控的代码。将您的代码包装在一个 try/except 语句中，然后在出现异常时执行 send_alert 函数，将完整的错误报告发送到您的电子邮件中。

在使用此代码之前，您需要有一个虚拟的电子邮件帐户设置。Gmail 是最简单的。对于本例，请确保您打开了“不太安全的应用程序访问”(见下面的截图)。

将 CSV 文件写入数据库(Postgres 或 SQL Server)

https://gist . github . com/camw 81/ff 53586 ad 228 F2 f 624522 ba 10 C9 e 5930

这是很多代码——但它是我每天使用的最重要的技术之一，用于从任何来源获取数据并将其推入数据库。上面的例子最适合使用 MS SQL Server——特别是 Azure SQL 数据库和 Azure Blob 存储。我将把链接放在这里到另一个你可以用于 POSTGRES 数据库的例子——这个例子稍微简单一点。

这里的基本思想是通过几个步骤将数据从 CSV 文件导入数据库:

1. 将 CSV 文件推入 blob 存储。
2. 通过在 SQL 数据库上创建外部数据源，将目标数据库表绑定到 blob 存储。
3. 创建一个临时表，您将在其中插入 CSV 文件。
4. 将 CSV 文件批量插入到临时表中
5. 最后，使用合并标准将临时表合并到最终表中。

有无数种方法可以让数据到达你想要的地方。这是我几乎每天都依赖的方法。

图片由this isensegining来自像素

从 REST API 取回多页数据

https://gist . github . com/camw 81/b5 c 723204 c 977 bb 5296 b 2393331301

每当我需要创建一个与 API 集成的 ETL 管道时，我会使用上面两段代码的一些迭代。许多 API 使用异步请求(您发出一个代码请求，然后在后台等待它完成)，我也将它包含在示例中。为了让代码工作，您需要为您正在使用的 API 交换端点 URL 和特定的分页键。如果 API 要求使用 client_id/client_secret 进行认证，那么您还需要遵循一个认证过程来获取访问令牌(我在的另一篇文章中有一个这样的例子)。一旦完成了这些，上面的代码示例将成为构建集成的良好起点。

为数据库插入清理和格式化 REST API JSON 结果

https://gist . github . com/camw 81/b5 c 723204 c 977 bb 5296 b 2393331301

对于我编写的几乎所有 API 集成，我都使用上述代码片段的变体。这种方法假设数据将以 JSON 格式返回——这意味着它应该可以处理大约 75%的 API 数据请求。格式化后，这个脚本将把 JSON 数据结构组织成表格格式(列表的列表),然后可以很容易地插入到 CSV 中——准备好推送到 DB。可能有一个更简单的方法来做到这一点，但这是我多年来一直使用的方法，它还没有让我失望。

清理 CSV 文件以插入数据库

import pandas as pdwrite_file = '~/directory/filename.csv'df = pd.read_csv(write_file)df = df.replace({‘\$’:’’}, regex = True)
df = df.replace({‘%’:’’}, regex = True)
df = df.replace({‘\,’:’’}, regex = True)
df = df.replace({“‘“:’’}, regex = True)
df = df.replace({“nan”:’’}, regex = True)

这是一个简单的方法，但是它为我节省了无数时间来清理混乱的数据源——比如手动创建的 CSV 文件。你们中的许多人可能遇到过这样的情况，有人希望将 OneDrive 或 GDrive 文件夹中的 CSV 文件推送到数据库中。问题是，这些文件的格式通常会使数据库插入变得很麻烦。幸运的是，Pandas 内置了 replace 函数，只需一行代码就能清除特定字符。

如果您的文件包含带有$或%或其他符号的数字，并且您希望将它们作为数字类型推入数据库，那么这个代码片段非常有用。用 replace 函数和 chosen 符号清理数据将会清除所有这些数据，使您使用的任何数据库都可以轻松地将数据作为数字类型读取。

创建结束日期和开始日期

import datetime #### Set todays date ####
today = datetime.datetime.now().date()#### Create to_date by adding or subtracting dates from today's date
to_date = today-datetime.timedelta(1) #### Create your from date by subtracting the number of days back #### you want to start
from_date = today-datetime.timedelta(7)#### Create timestamp of today's date using desired format
todaysdate = datetime.datetime.strftime(datetime.datetime.now(),'%Y-%m-%d')

大多数 API 在请求数据时都需要日期参数。该示例使用 Python 的 datetime 包，通过。timedelta()函数。我一直使用它来根据脚本运行的日期/时间，在我的脚本中构建自动的到/从日期计算。

分块处理大的 Python 列表

def chunker(seq, size):
 return (seq[pos:pos + size] for pos in range(0, len(seq), size))for group in chunker(order_items,100):
      for item in group:
# Do something to each group

这是一个我经常使用的小函数，用来把非常大的列表分块。这对于清理和格式化 JSON 数据(如上所示)非常有用，因为有时您会从 API 中提取大量数据，并希望对其进行处理，然后以可管理的块的形式将其推送到 DB 中。 chunker 函数允许你选择一次要处理多大的块，然后在每个块上运行你的代码。这个例子使用了一个 100 个条目的块，但是您可以根据需要调整这个数字。

这就是我在日常数据工程和分析工作中一直使用的 8 种 Python 技术。希望其中一些能让您的数据生活更轻松。

如果你喜欢这篇文章，你可以在这里找到我的其他作品。你也可以在推特上关注我 @camwarrenm

数据科学新手应该知道的 8 种机器学*算法

原文：https://towardsdatascience.com/8-machine-learning-algorithms-everyone-new-to-data-science-should-know-772bd0f1eca1

简要解释机器学*背后的算法

戴维·莱夫克在 Unsplash 上拍摄的照片

如果你刚开始接触数据科学，你也会很快接触到机器学*。下面我们列出了每个数据科学家都应该知道和了解的八个基本机器学*算法。如果你在阅读这篇文章的时候意识到你根本不知道这个算法或者还不够了解，那么请随意使用每种情况下链接的文章。在那里你会找到详细的解释，应用，以及每个算法的优缺点。

1.线性回归

回归用于建立两个变量 x 和 y 之间的数学关系。统计和机器学*基础处理如何用一个或多个变量 x 来描述变量 y。以下是一些示例:

• 学*时间(= x)对期末考试成绩(= y)有什么影响？
• 农业的实际收成取决于植物肥料的使用吗？
• 警察人数的变化能解释这个城市犯罪率上升的原因吗？

我们称变量 y 为因变量或回归变量，因为它的变化依赖于外部因素。

另一方面，变量 x 被称为自变量或回归变量，因为它是因变量变化的可能原因。

对于线性回归，我们试图找到描述 x 对 y 的影响的线性数学关系。在此过程中，算法通过最小化直线和所有数据点之间的总距离，将直线拟合到训练数据集。

如果我们只有一个独立变量，这些是线性回归需要拟合的参数:

• β0:与 y 轴的交点，例如不学*可以达到的考试成绩。
• β1:回归线的增加，例如多学*一小时对考试成绩的影响。
• u:错误项，如所有对考试成绩有影响但学*时间没有捕捉到的影响，如先验知识。
• y:变量，在线性回归的帮助下，你想预测哪个变量，在我们的例子中是期末考试成绩。
• x:变量，用作预测的基础，并对 y 有影响，在本例中，为考试学*的小时数。

https://databasecamp.de/en/ml/linear-regression-basics

2.逻辑回归

逻辑回归是回归分析领域的一个子类，它提供了使用普通比例因变量的机会。这意味着回归变量只能取有限数量的值。然后，逻辑回归结果被解释为数据点属于某个类别的概率。

在逻辑回归中，基础仍然是将回归方程拟合到一组给定的数据点。只是，在这种情况下，我们不能再用线性方程了，因为我们有一个有序回归方程。让我们用一个真实的例子来看看为什么:

我们的模型应该预测特定个人购买电动自行车的可能性。它使用的独立变量是个人的年龄。我们通过在街上随机采访人们得到的数据集如下:

电动自行车配送|图片:作者

从这个图表中，我们可以推断年轻人不太可能购买电动自行车(左下角)，而老年人大多拥有一辆(右上角)。即使在两个年龄组中都有异常值，我们会假设模型会推断随着年龄的增长，人们更有可能购买电动自行车。但是我们如何用数学方法来定义它呢？

首先，我们需要找到一个数学函数来表示图中的点分布，这显然不是一个线性函数。我们需要的是一个位于 y 轴上 0 和 1 之间的函数，因为有两个组也可以用 0 和 1 来表示。我们正在寻找的数学函数是 sigmoid 函数:

Sigmoid 函数曲线|图片:作者

其函数方程如下:

在电动自行车的例子中，这将转化为:

现在，我们已经为我们的逻辑回归打下了基础，我们可以通过使用我们的数据集开始迭代拟合参数 a 和 b。这样，我们将得到一个完全符合给定数据的函数:

购买电动自行车的逻辑回归|图片:作者

在现实生活中，函数符号与您在本文中看到的符号大部分不同。在那里，你重新安排它，使它具有类似于线性回归的形式:

https://databasecamp.de/en/ml/logistic-regression

3.支持向量机

支持向量机 (SVMs)属于机器学*算法，有其数学基础。它们是用来做分类的，比如图像分类。在这方面，它们比神经网络更有优势，因为它们可以被快速训练，并且不需要大量的训练数据来获得好的结果。

我们可以将 SVM 用于以下数据集，其中我们有两个类别(蓝色和黄色)以及两个特征(x 轴和 y 轴)。我们的算法应该学*我们的训练数据集的颜色分类。在二维空间中，数据集可能如下所示:

示例数据支持向量机|图片:作者

支持向量机试图拟合一个所谓的超平面，该超平面应该以可能的最佳方式将两个组分开。根据维度的不同，超平面可以是一条直线，就像我们的例子一样，也可以是多维的平面。

然后，可以使用合适的平面来将对象分类。在我们的例子中，位于平面图左侧的所有数据点都属于“黄色”类，位于右侧的所有数据点都属于“蓝色”类。

支持向量机|图片:作者

SVM 使用不同的训练跑来尽可能最佳地适应飞机。目标是最大化间隙，间隙是从每个组的最*点到超平面的距离，意味着平面应该完美地位于中间。

https://databasecamp.de/en/ml/svm-explained

4.决策图表

决策树以决策而闻名，并且已经找到了进入机器学*世界的方法。树状结构试图学*多个决策阶段及其可能的响应路径。决策树可用于回归分析或分类。

树有三个主要部分，即根、分支和节点。下面的例子是一个决策树关于我们是否应该进行户外运动。它有助于更好地理解结构:

决策树示例|图片:作者

在我们的例子中，节点“Weather”是根节点。它被用作我们决策过程的起点。一棵树通常只有一个根点，以便所有决策都有一个相似的起点。

从根节点开始，总共有三个分支(晴天、阴天、雨天)。其中两个后面是新的节点(晴雨)。在这些节点上，人们需要做出另一个决定。只有在天气多云的时候，一颗叶子才会落下来，也就是所谓的叶子。这意味着当天气多云时，一个人应该经常出去锻炼，至少决策树是这么告诉我们的。

在晴天或雨天，还要根据湿度做出另一个决定。如果天气晴朗，湿度值可能为“高”或“正常”。这意味着晴朗的天气加上高湿度并不是户外运动的最佳天气。

在雨天，还有一个重要的决策分支。在这种情况下，风在决策中变得更加重要。由此，我们可以推断出两条规律。如果天气下雨，风很大，就不应该在外面做运动。然而，在雨天和微风的情况下，人们可以到户外做一些运动。

5.随机森林

随机森林是来自监督学*领域的机器学*算法。它是所谓的集成模型，因为它由多个决策树组成。

每一棵单独的树都对手头的任务做出预测，例如，分类。然后,随机森林组合所有的个体决策，并得到大多数树支持的结果。但是为什么用多棵树预测同一个用例比用一棵树好呢？

这背后的意图是所谓的群体智慧。它的观点是，单个个人的决定总是比许多人的决定更糟糕。这是在 1906 年的一次博览会上首次发现的。

当时，一头公牛被展示给 800 名观众，要求他们估计这头公牛的重量。之后，应该通过称重动物来正式确认体重。一位数学家分析了这些估计值，发现人群估计值的中位数与实际体重只有 1 %的差距。然而，没有一个人提交更接*正确结果的估计。这使他引入了群体的智慧，即多数人的估计比一个人的估计要好。

我们可以将这一点应用到随机森林中，即不同决策树的集合将总是优于任何一个单独的树。

随机森林合奏|图片:作者

只有一个小条件需要满足:树和它们的错误不允许以任何方式与相关。这样，单棵树的误差可以由别人来补偿。

在我们的重量估算例子中，这意味着所有的估算都应该单独进行，而不需要事先讨论。否则，一个人可能会受到另一个参与者的估计的影响，因此他们的误差是相关的。然后，群众的智慧不再出现。

6.朴素贝叶斯

在朴素贝叶斯中，我们有另一种基于数学定理的基本分类方法，叫做贝叶斯定理。然而，只有当我们假设所有的特征都彼此不相关时，才能使用它。这就是算法幼稚的原因，因为这个假设通常是错误的。

贝叶斯定理描述了条件概率 P(A|B)的公式，条件概率 P(A | B)意味着当事件 B 已经发生时 A 发生的概率(如果我的快速测试是阳性的(=事件 B)，我有电晕(=事件 A)的概率是多少？).

贝叶斯定理的公式是:

• P(B|A) =如果事件 A 已经发生，事件 B 发生的概率
• P(A) =事件 A 发生的概率
• P(B) =事件 B 发生的概率

实际上，概率 P(A|B)很难找到。以电晕为例，我们需要一个更复杂的测试来确定这个人是否真的是阳性。逆概率 P(B|A)就好找多了。在我们的例子中，它测量了一个感染了冠状病毒的人快速检测呈阳性的可能性。

我们可以通过对已确诊感染的人进行快速检测来发现这种可能性。之后，我们可以计算这些测试中有多少实际上是阳性的，与进行了多少测试相比。现在，我们可以使用概率 P(B|A)，P(A)和 P(B)来计算条件概率 P(A|B)。

朴素贝叶斯算法|图片:作者

对于具有多个特征的数据集，算法保持不变，我们为特征 x 和类 k 之间的每个组合计算条件概率。之后，将一个特征的所有类概率相乘。具有最高总体概率的类是预测。

https://databasecamp.de/en/ml/naive-bayes-algorithm

7.感知器

感知器是神经网络的基本构建模块，也是监督学*的一部分。它包含单个神经元，通过使用激活函数和加权输入值来计算输出。

基本算法来自数学，后来用于计算机科学和机器学*。它试图模仿人类大脑的结构，并能够学*复杂的关系。

一个感知器可以有多个能够处理数值的输入。输入具有说明输入对于最终输出的重要性的权重。学*过程包括改变这些权重，以产生尽可能接*来自训练集的输出值。

感知机的结构|图片:作者

神经元计算输入值和输出权重的加权和。然后它被提供给激活函数，该函数是从 0 到 1 缩放的特殊函数。在其最简单的形式中，神经元只能有一个二进制输出(是/否，真/假，活动/不活动)。

在大多数情况下，所谓的 Sigmoid 函数被用作激活函数，因为它的范围从 0 到 1，并且在 x = 0 时急剧增加。这就是为什么它是二元分类的好方法。

8.人工神经网络

人工神经网络是单个感知器的进步，更加接*我们的人脑。它用于解决更困难的分类或回归问题。

基本神经网络使用多层感知器结构，其中一个感知器的输出只是下一层中另一个感知器的输入。然而，感知器的基本概念仍然被使用:

1. 权重因子决定了输入对于神经元的重要性。高权重意味着输入对于解决手头的问题非常重要。
2. 然后，我们通过将输入值和它们的权重相乘来计算加权和。此外，还有一个附加的偏差:

3.随后，结果被赋予所谓的激活函数。

激活功能的选择取决于使用情况。它可以是用于二元分类的 sigmoid 函数，也可以是其他阶跃函数。

信息通过网络的不同层传递:

• 输入层:包含我们从数据集获得的输入，这些输入应该通过网络进行处理。
• 隐藏层:一个或多个所谓的隐藏层以我们描述的方式接收输入并计算输出。根据架构的不同，它们的输出被传输到另一层神经元。这些层是隐藏的，因为这些层没有给出任何可见的结果，而是将它们的输出传递给其他神经元。
• 输出层:该层跟随最后一个隐层，计算网络的最终结果。

神经网络结构|图片:作者

该架构然后被给予训练，这使得网络学*如何为特定的用例产生完美的结果。一种使用具有特定数据点和相应结果的训练数据集。对于每个数据点，网络计算其结果，并将其与数据集的正确结果进行比较。

https://medium.com/codex/understanding-the-backpropagation-algorithm-7a2e3cb4a69c

如果计算结果不正确，则使用反向传播算法改变单个神经元的权重。通过对整个数据集反复重复这一过程，神经网络的性能正在提高。

https://medium.com/illumination/intuitive-guide-to-artificial-neural-networks-5a2925ea3fa2

这是你应该带走的东西

• 每个数据科学家都有扎实的机器学*算法知识。
• 在本文中，我们介绍了常用的算法，并简要解释了它们是如何工作的。
• 它们为今天使用的更先进的模型奠定了基础。

如果你喜欢我的作品，请在这里订阅https://medium.com/subscribe/@niklas_lang或者查看我的网站* 数据大本营 ！此外，媒体允许你每月免费阅读三篇文章。如果你想让无限制地访问我的文章和数以千计的精彩文章，不要犹豫，通过点击我的推荐链接:【https://medium.com/@niklas_lang/membership】每月花$ 5 获得会员资格*

** **

8 分钟满足 99%的 Git 需求

原文：https://towardsdatascience.com/8-minutes-to-cover-99-of-your-git-needs-2c904c43590a

通往 Git 和理解主要概念的更简单的途径

照片由 Praveen Thirumurugan 在 Unsplash 上拍摄

“这些都是什么命令？”“我要花多少小时才能全部学会？”“我应该按什么顺序使用它们？”

如果这些问题听起来很熟悉，那么你来对地方了。

Git 可能会非常令人沮丧和难以掌握，互联网上可用的信息量使它更加令人不知所措。

我们都经历过与 Git 打交道的痛苦，陷入了无法逃脱的黑洞，我们觉得没有人能把我们从我们制造的混乱中拯救出来。我们在这里不是教你如何在每一个困难的 Git 情况下重新站起来(这可能需要 8 分钟以上的时间)，而是给你做 Git 的正确方法，避免所有可能导致你失败的陷阱。预防总是胜于治疗。

在本教程中，我们将带着出现的问题走过标准的项目路径，并为您提供在 GitHub/GitLab 上高效推进工作的解决方案。

同步本地&远程

首先，我们需要将本地计算机与远程 Git 项目同步。

在大多数公司，你将会在一个已经构建好的 Git 项目上工作，要么是因为一个团队为你创建了公司认证的 Git 模板，要么是你被指派去改进一个现有的项目。我们还假设您的计算机和 GitHub/GitLab 之间已经建立了 SSH 连接。

如果不是这样，我建议您使用 GitHub/GitLab 的图形用户界面创建存储库，并创建和关联 Git SSH 密钥，或者您也可以在您的机器上编写 git init 来本地启动存储库。如果是这种情况，您可以直接进入分支部分。

要与 Git 项目同步(在远程 Git 上已经可用)，最简单的方法是在 Github 上点击“ Clone”或“Download ”上的向下箭头后，通过点击剪贴板复制粘贴 HTTPS 链接(在 GitLab 上只是“Clone”)。然后点击剪贴板复制存储库的链接。

现在打开一个 bash 命令，转到想要下载存储库的文件夹，输入(通过编写 git 克隆并粘贴复制的链接):

git clone https://github.com/random_user/random_project

恭喜您，您现在已经与random _ user/random _ project远程存储库同步了！

您也可以在本地已经有项目的情况下，因此 git pull 是您需要与远程存储库的最新更新同步的东西。

创建你的分支

假设现在你想添加一些开发，要么在现有的脚本/模块上，要么一个全新的开发。

最佳实践是始终创建一个分支。

一个分支就像是一个新的空间，你创造它来进行你的开发，不干扰主干道，它在 GitLab 中也被称为主分支，在 GitHub 中被称为主分支。

把主分支想成是每个人都同意工作质量足以被共享和克隆的地方。而你的甚至都没写。

要创建分支，最佳做法是键入:

git checkout -b "arli/first_development"

这个命令实际上做了两件事:

• 它创建了分支 arli/first_development
• 它会将您发送到分支机构 arli/first_development

但是，您也可以连续编写被上面的命令替换的两个子命令。

git branch"arli/first _ developmentt "如果您只想创建分支而不想切换到分支

git check outarli/first _ development如果要切换到分支

一条消息写: 切换到新的分支‘arli/first _ development’应该会出现。

你总是可以通过写 git branch 来检查你是否在好的分支中，一个星号应该出现在左边指示你在哪个分支中:

开始你的发展

太好了，现在是你工作的时间了！

… 3 小时后…

假设你努力开发了一个名为‘first _ script . py’的新脚本，并且改进了‘preprocessing . py’。

您可以通过输入以下命令来检查您是否取得了一些进展，并因此更改了一些本地文件:

git status

在这里你会看到:

因为您向现有的预处理添加了代码

您还将拥有:

来自你写的新' first_script.py' 。

你必须用命令添加这些改变(取决于你的 IDEfirst _ script . py可以在你创建的时候自动添加，但是下面的命令不会有任何伤害):

git add preprocessing.py
git add first_script.py

通过键入 git status ，您应该会看到:

提交您的工作

您改进了本地文件中的代码，这很好，但现在您需要将其推送到远程存储库，这样每个人都可以看到您疯狂的工作。

但是在推之前，你需要提交你的工作，而且你要经常提交！一个 经验法则(这很难尊重我同意)是:每一个承诺应该对应一个独特点的发展你解决。

为了提交您的工作，您还需要分配一个提交消息，它将告诉您提交的内容。

假设我们开发了开发 1 的第一个迭代:

git commit -m "first iteration development 1"

它应该告诉您，您修改了 2 个文件，与之前的状态相比，插入和删除的行数。您可以在每次修改文件时提交(不要忘记 git add )。

太好了，现在让我们来推动提交！

推动你的工作

一个推仅仅是将你的本地工作交付给远程存储库，或者有一个或者几个提交。

就写:

git push

你要面对这个通常的【致命】错误(其实根本不致命):

它告诉你要编写git push—set—upstream origin arli/first _ development而不仅仅是 git push。

每次你创建一个新的分支并推动它时，你都需要写这个。

我会给你一个不再写这个命令的方法。诀窍是修改一个内部 git 文件，它将自动创建并同步您在远程存储库上的本地分支，通过写(取决于您是否有 git 版本≥ 2.37 ，但是无论如何，执行这两个命令都没有坏处):

git config --global push.default current
git config --global --add --bool push.autoSetupRemote true

现在，执行 git push ，你就可以进行下一步了！

合并/拉取请求

在 GitLab 中称为“合并请求”，在 GitHub 中称为“拉取请求”。我将继续使用 GitLab 术语。

执行合并请求最简单的方法是转到 GitLab/GitHub GUI。

通常，你会发现一条横幅消息，告诉你你推进了一个分支，它建议你打开一个合并请求。

你可以点击它，然后继续提交合并请求:给一个标题，写一些关于你的发展的描述，分配一些你正在工作的审阅者，然后点击绿色的大提交合并请求。

如果您没有找到横幅，只需走标准路线，并转到合并请求文件夹，您将必须指定您的开发分支( arli/first_development )和目标分支(应该是 master )，然后单击比较分支并通过完成上面截图上的信息继续。

恭喜您，您的合并请求已提交。现在，需要有人对其进行合并(无论是你自己还是某些审核者都可以)。

合并合并请求:重定基还是不重定基

这里可能会发生两种情况:

M 戈尔按钮是绿色的，你(或者评论者)可以点击它，好工作你的工作现在与主分支合并了(并且不需要重设基础)！

如果你成功了，恭喜你，你已经完成了本教程！

然而，当你和不同的人在同一个项目上工作时，你迟早会面临可怕而令人沮丧的灰色合并按钮:

好的，跟着我，深呼吸，我们会解决这个问题的。

问题的出现是因为从现在到您最后一次将您的本地存储库与主分支同步之间，有人对同一个文件进行了更改，并且已经合并了一个您没有见过的修改版本，Git 出于预防措施，不会尝试将您的代码与他的代码合并。这就是 Git 让你做 rebase 的原因。

按照下面的步骤一个一个来。你需要在你的分支 arli/first_development 中，你的 master 分支(GitLab)可以被命名为 main (GitHub)，所以如果需要的话，在下面的代码中将 master 替换为 main 。

首先，获取同事合并的代码的最新版本:

git pull --rebase origin master

可能会因为有未提交的文件而出错。要么用 git add 和 git commit 提交它们，要么用 git restore 将它们恢复到以前的状态。

如果没有错误，写入 git 状态以了解哪个(哪些)文件处于冲突。

打开文件，搜索标记<<<<<<<头和标记 ======= 。在这两个标记中，你让你的同事和你做同样的代码。

在 ======= 和>>>>>>>之间你会发现你对文件的修改。通过选择您的版本或他的版本来解决冲突，并删除标记和未选择的代码版本。

对每个有冲突的文件重复该过程。当您没有在任何文件上留下标记时，您可以添加那些已解析的文件:

git add random_name_of_the_file_I_resolved.py
git add second_file_I_resolved.py 

提交您的更改:

git commit -m "Fix conflict with coworker work on A"

并使用以下代码完成重置:

git rebase --continue

强制(带租约)推回基数:

git push --force-with-lease

我们使用选项——force-with-lease而不是——force的原因是，如果当您正在做 rebase 时，其他人更新了您的分支，根据预防原则，Git 会告诉您有问题。

如果你面临这种非常罕见的情况，你将不得不重新开始 rebase 的所有步骤，但你需要从你的分支、远程分支(如果你单独在你的分支工作，这种情况不会发生)。

现在如果你进入你提交的合并/拉取请求的页面，你会发现，你的挣扎的终点，那个神圣的绿色合并按钮:

恭喜你，你已经成功推动你的工作，并将其与主/主分支合并。

使用本手册了解更多关于 Git 的信息:

Git 袖珍指南

无需额外费用，您可以通过我的推荐链接订阅 Medium。

https://medium.com/@arli94/membership

或者你可以在收件箱里收到我所有的帖子。做到这里 ！

编写行业标准代码的 8 个 Python 最佳实践

原文：https://towardsdatascience.com/8-more-python-best-practices-for-writing-industry-standard-code-64d97f42da5e

我进入软件行业后学到的一些 Python 最佳实践

照片由来自佩克斯的克里斯蒂娜·莫里洛拍摄

我最*读了 Anmol Tomar 的一篇关于 Python 最佳实践的好文章。它涉及简单而有效的最佳实践，可以提高您的代码质量。然后我觉得“嗯，我可以在 Anmol 的这个列表中再添加几个。”因此，我在这里，写这篇博客。在进入这个行业之前，我没有遵循这些最佳实践。但是在成为团队的一员后，我从我的同事那里学到了这些最佳实践，并希望我知道并尽早遵循这些小步骤。

“行业标准代码”听起来可能有些花哨。但它只不过是可读的、可重用的、可修改的代码。在工业界，我们在团队中工作。如果我在为一家公司工作时写了一些代码，我写的代码就归这家公司所有。一段时间后，一个完全不同的人，为同一家公司工作，应该能够阅读我的代码，理解它，对它进行改进，或者修复它的一个错误，或者将它与另一个软件集成。如果这是不可能的，软件业将不会超越个人。因此，只要你写的代码简单易懂，别人可以改进，你就是在写“行业标准代码”。

我在这里列出的 8 个最佳实践是 Anmol 在他的文章中提到的内容的补充。也一定要读一读。永远不会有“最佳实践”的详尽列表这些是我在这个行业学到的一些简单的方法，帮助我提高了我的编码水平，并在一个协作的环境中工作。所以永远不要把它当作一组有限的最佳实践。

1.不要在你的代码中使用随机值。将它们定义为常量。

比方说，您正在编写的这段代码有一行将质量(kg)转换为重量(N)。这是一个简单的一行程序，你必须将质量变量乘以 9.8 ms⁻。所以我们倾向于写一行像下面这样的代码。

不良做法

技术上是正确的。但是当有人在没有上下文的情况下阅读你的代码时，他们会想为什么是 9.8，它从哪里来。因此，将它定义为一个命名的常量并随后使用它总是好的。

良好实践

Python 不像大多数其他语言那样有常量定义。因此我们把它定义为另一个变量。但是我们使用ALL_CAPS作为命名约定来表示它是一个常量。定义常量时，最好在源文件的顶部定义(在导入之后)。如果项目很大，并且许多源文件共享项目级常量，您可以在一个constants.py文件中定义所有常量，并根据需要将它们导入到所需的源文件中。

2.使用动词作为函数和方法名

这听起来可能不太重要，但请听我说完。假设你正在编写一个函数来计算一个给定数字的质因数。很可能我们倾向于这样定义函数:

不良做法

然后当调用函数并将其输出赋给一个变量时，我们会想知道该给这个变量取什么名字，因为prime_factors已经被占用了。如果我们想在函数中定义一个局部变量，情况也是如此。但是如果我们稍微思考一下，我们几乎总是写一个函数或方法来“做某事”。函数和方法对数据执行操作。因此，将您的函数和方法命名为<do>_<something>是一个好主意。在这个特殊的例子中，我更喜欢下面的函数名。

良好实践

之后，我将使用prime_factors作为变量名来捕获函数调用的结果。

3.根据访问范围要求将成员定义为私有或受保护

将类的属性和方法定义为私有或受保护不是 Python 的语言特性。但这可以通过一个普遍公约来实现。公开仅必要的属性和方法始终是最佳实践。其他的都应该保护类的私有成员。受保护的成员是可以从类及其子类中访问的属性和方法，而私有成员只能从类本身中访问。

在 Python 中，以下约定用于定义受保护成员和私有成员。以单下划线_为前缀的成员受到保护，以双下划线__为前缀的成员是私有成员。

良好实践

正如我上面提到的，在 Python 中这只是一个约定。我们仍然有办法接*这些成员。但好的程序员不会。这向可能扩展您的程序的后续程序员表明，这些属性和方法并不意味着可以从外部访问。

即使您没有以面向对象的方式使用 Python(因为大多数人都没有)，您仍然可以对不打算在其他地方导入的函数采用相同的约定。只需在这样的函数名前面加上下划线。这将表明该函数是文件的本地函数，不应该被导入到其他地方。

4.不要导入*

过去我已经做过很多次了。当我想导入一些我在别处定义的组件时，我只需这样做:

不良做法

当我们在代码中执行import *时，模块中的所有实体都将被导入到当前的名称空间中。这严重影响了代码的可读性。当您有两行这样的代码时，读者将会忘记您所使用的实体是从哪里导入的。更糟糕的是，这种导入可能会隐藏早期导入或本地定义中的名称。

如果您正在访问许多实体，最好的办法是导入整个包或模块。然后，您可以稍后以<module>.<class>的身份访问这些类或函数。如果只导入一两个组件，使用from <package> import <class>格式。但很少使用它。

良好实践

5.使用代码格式化程序

如果我说许多样式(格式)最佳实践可以被强制或自动应用到您的代码中，那会怎么样？是的，开始使用代码格式化程序或 linter。在工业环境中，大多数组织都将 linter 作为 CI(持续集成)管道的一部分。当您尝试将一些代码推送到组织的 repo 时，它将被自动标记，如果没有遵循任何规定的最佳实践，它将引发一个错误，阻止代码的合并。

所以还是开始用比较好。布莱克是一个很好的代码格式化程序。它可以帮助你按照 PEP8 标准的规定格式化你的代码。一些 ide 有内置的代码格式化程序，你可以通过一个简单的快捷方式来使用它。Linters 不仅仅是代码格式化程序。它们是静态代码分析器。它们可以用来检查是否使用了正确的变量命名约定，检查错误等。Pylint 可以作为介绍棉绒的起点。

6.编写单元测试

这可能会非常耗时。但是，当在团队中工作或从事长期项目时，这是必不可少的。编写适当的单元测试使你的代码“标准化”。单元测试是一种机制，通过它可以测试源代码中各个逻辑单元的功能。您可以简单地隔离逻辑错误并防止它们向上传播。当在一个团队中工作时，这是必不可少的，因为如果一个功能上有缺陷的代码被合并，它会在与其他组件交互时导致错误。相信我，从长远来看，编写适当的单元测试实际上是节省时间的。Python 内置的 unittest 库非常适合对你的 python 代码进行单元测试。

7.记录错误

你的代码不是没有错误的。即使在林挺、单元测试、手工测试之后，偶尔在生产中失败的可能性也很高。相信我，没事的。这在业内是常有的事。重要的是你是否已经先发制人地采用了机制来捕捉哪里出了问题。只有当你有一个指向哪里出了问题的指针时，你才能修复错误。所以在代码中启用强制错误记录。这很简单——使用 python 日志。

良好实践

还可以根据项目的需要使用警告、信息和调试级别的日志记录。请记住，日志文件是您的“黑匣子”，如果您的代码在生产中失败，您将不得不使用它进行“事后分析”。

8.生成包含版本的 requirements.txt 文件

如果您在机器学*、数据科学或任何其他领域工作，并且这些领域的包在不断发展并获得重大更新，那么这就更容易理解了。您将创建一个虚拟环境，安装一些包并处理一个项目，然后交付。那你一段时间都不会碰这个项目。之后，你应该做一些改进。现在您尝试重新创建环境，您的代码很有可能会中断。嗯，原因是软件包经历更新，有时可能包含重大变更。

您可以通过遵循下面提到的最佳实践来简单地解决这个问题。

1. 每个项目都有单独的虚拟环境
2. 为每个项目使用一个requirements.txt文件来跟踪已安装的包
3. 当跟踪软件包时，使用确切的软件包版本来跟踪它们。

第三点很重要。如果您在 repo 中总是有工作包版本，那么每次您尝试重新创建环境时，都会安装该包的确切版本。因此，不会有任何突破性的变化。

您可以手动跟踪您安装的软件包，或者如果您正在维护一个适当的最小环境，您可以使用下面的 shell 命令来自动生成文件。

pip freeze > requirements.txt

编辑:正如塞萨尔·弗洛里斯在评论中提到的，使用pip freeze可能会导致问题，因为它也会跟踪二级依赖关系。因此，手动跟踪包裹将是最好的选择。

如果你需要更多关于 requirements.txt 的信息，这里有一篇好文章。

这就是我进入软件行业后学到的 8 个基本 Python 最佳实践。我希望这篇文章对你有用。此外，如果您认为应该包括任何评论/更多最佳实践，请在评论部分提出。

参考

[## 编写行业标准代码的 Python 最佳实践

towardsdatascience.com](/python-best-practices-for-writing-industry-standard-code-66b848783e0b) https://www.tutorialsteacher.com/python/public-private-protected-modifiers https://stackoverflow.com/questions/9916878/importing-modules-in-python-best-practice https://github.com/psf/black https://pypi.org/project/pylint/ https://learnpython.com/blog/python-requirements-file/

用于分析的 8 个更有用的熊猫功能

原文：https://towardsdatascience.com/8-more-useful-pandas-functionalities-for-your-analyses-ef87dcfe5d74

帕斯卡·米勒在 Unsplash 上的照片

用于分析的 8 个更有用的熊猫功能

它们可以让你的日常工作更轻松、更快捷

在这篇后续文章中(你可以在这里找到第一篇)，我想展示几个更有用的pandas方法/函数，它们是我最*在日常工作中一直在使用的。为了管理期望，这不是一篇展示pandas基本功能的文章，也没有特别的方法主题。事不宜迟，我们开始吧！

1.n 最小/n 最大

这些方法非常简单明了。它们根据某一列(或多列)返回具有最大/最小值的前 n 行。还值得注意以下几点(来自nlargest的文档):

这个方法相当于df.sort_values(columns, ascending=False).head(n)，但是性能更高。

首先，让我们创建一个示例数据帧:

作者图片

然后，我们选择在a列中包含最大值的 3 行。

df.nlargest(3, "a")

作者图片

您可能已经注意到，当我们创建 DataFrame 时，两列中都有重复的值。默认情况下，方法选择具有最大值的第一行。但是，我们可以更改此行为以包括所有事件。为此，我们指定了keep参数。

df.nlargest(3, "a", *keep*="all")

作者图片

我们还可以使用“first” / “last”作为keep参数的值，这将分别对第一次/最后一次出现进行优先级排序。

此外，我们还可以通过多列选择最大/最小值。为此，我们只需要提供一个列名列表，而不是单个名称。

2.隐藏索引/隐藏列

另一个有趣的功能是隐藏索引或列的选项。这在向风险承担者展示结果时尤其有用。这种情况在过去发生过很多次，当呈现一个过滤后的数据帧的片段时，有人会问左边奇怪的、看似随机的数字(指数)。利用hide_index，我们可以轻松避免回答这类问题的麻烦。

让我们使用与上一个示例相同的数据帧，并过滤掉a列中大于 5 的值。一气呵成，让我们隐藏索引。

df[df["a"] > 5].style.hide_index()

作者图片

注意:我们需要使用.style.hide_index()来访问该方法。

我们可以更进一步，也隐藏一列。我们使用以下语法来实现:

df[df["a"] > 5].style.hide_index().hide_columns("b")

作者图片

因为我们已经使用了style，我们不需要再次调用它。当然，我们可以一次隐藏多个列，我们只需要提供一个列名列表。

3.询问

我经常使用这个，我想你会很快明白为什么。在上面的例子中，我们过滤了值大于 5 的观察值。我们可以使用query方法应用相同的过滤。

df.query("a > 5")

代码返回完全相同的结果。就个人而言，我发现语法更容易写/读，尤其是当有多个条件时。例如，我认为

df.query("a > 5 and b < 3")

对眼睛来说比

df[(df["a"] > 5) & (df["b"] < 3)]

但这是个人偏好，最好了解过滤数据帧的最常见方法的替代方法。

4.第一个有效索引/最后一个有效索引

当我们想要找到第一个/最后一个非 NA 值的索引值时，这些方法非常方便。在没有有效索引的情况下，这些方法返回None。

作者图片

查看上面的数据帧，第一个有效索引(包含非 NA 值)应该是1。我们可以通过运行以下代码来验证我们的直觉:

df.first_valid_index()

实际上，运行该命令会返回1。我们还可以将该方法与apply结合起来，为每一列找到第一个有效的索引。

df.apply(lambda x: x.first_valid_index())

它返回以下内容:

a    1 
b    3

5.单调性/单调性递减

这个函数可能对我们的数据进行一些健全性检查很有用。它检查数据帧/序列中的值是否按升序/降序排序。你可以在这里阅读更多关于单调性的内容。

首先，让我们创建一个简单的数据框架:

df = pd.DataFrame(data={"a": [1, 2, 3, 4, 5, 6]})df

然后我们可以如下使用is_monotonic方法:

df[“a”].is_monotonic

答案是:

True

我们还可以检查相反的情况，即值是否按降序排列:

df["a"].is_monotonic_decreasing

答案自然是:

False

值得一提的是，这些函数不检查严格的单调性。这意味着它们允许重复值，例如，如果我们有这样一个值序列

[1, 2, 2, 3]

这些方法仍然表明序列是单调的。

最后，该方法不限于数字。我们也可以用它来约会:

pd.date_range("2000-01-01", "2000-01-31").is_monotonic

它返回一个True，假定范围已经排序。

6.替换

这是另一个不言自明的例子。它只是替换数据帧中的值。但是，有几种方法可以使用它。让我们用一个例子来展示更多的细节。

作者图片

我们可以做的第一件事是用另一个值替换整个数据帧中的所有值。使用下面的语法，我们用 999 替换所有的 2。

df.replace(2, 999)

作者图片

或者，我们也可以进行更复杂的替换。下面，我们仅将a列中的值替换为用单词表示的数字。

df.replace({"a" : {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"}})

作者图片

7.面具/哪里

在上面的例子中，我们已经替换了具体的值。但是，也有基于条件替换值的有用方法。它们是 if-else 语句，您可以在下面找到它们的简短描述:

• mask —替换条件评估为True的值，
• where —替换条件评估为False的值。

对于以下示例，我们使用与replace示例中相同的数据帧。mask方法的语法如下:

df["a"].mask(df["a"] < 4, "Less than 3")

它返回以下序列:

0    Less than 3 
1    Less than 3 
2    Less than 3 
3              4 
4              5 
Name: a, dtype: object

where非常类似，它只是替换了条件为False的值。

df["a"].where(df["a"] < 4, "More than 3")

它返回以下内容:

0              1 
1              2 
2              3 
3    More than 3 
4    More than 3 
Name: a, dtype: object

8.夹子

clip用边界值替换指定边界外的值。例如，它可以用作一种非常简单的异常值去除方法。

首先，让我们用一些数值创建一个数据帧。

作者图片

现在，让我们将所有值裁剪到[4，7]的范围内:

df.clip(4, 7)

作者图片

我们也可以使用clip方法只在一端裁剪值。使用下面的语法，我们只限制上限值:

df.clip(upper=7)

作者图片

在你走之前

今天到此为止。毫无疑问,pandas库还有许多更有趣、更有用的功能。我可能很快会写另一篇关于他们的文章。

您可以在我的 GitHub 上找到本文使用的代码。此外，欢迎任何建设性的反馈。我很乐意听到一些让您的工作更轻松的功能！你可以在推特上或者评论里联系我。

喜欢这篇文章吗？成为一个媒介成员，通过无限制的阅读继续学*。如果你使用这个链接成为会员，你将支持我，不需要你额外付费。提前感谢，再见！

您可能还会对以下内容感兴趣:

</9-useful-pandas-methods-you-probably-have-not-heard-about-28ff6c0bceee>

使用模型不可知解释技术时要避免的 7 个陷阱

原文：https://towardsdatascience.com/8-pitfalls-to-avoid-while-using-model-agnostic-interpretation-techniques-d0fcca544711

可解释机器学*的一般陷阱

图片由穆罕默德·哈桑来自 Pixabay

随着越来越多不容易解释的复杂机器学*算法被采用，可解释的机器学*技术在数据科学社区中越来越受欢迎。

模型不可知的解释技术不关心底层的模型，但是它们有能力解释模型并提供有洞察力的模型解释。用于机器学*模型的一些流行的模型不可知的解释技术是 【部分依赖图】置换特征重要性(PFI)、LIME、 和【SHAP】。如果应用不当，这些模型不可知的解释技术会导致错误的见解或结论。在本文中，我们将讨论在使用解释技术时要避免的一些常见的 8 个陷阱。

这篇文章的灵感来自 Christoph Molnar 和他的团队于 2021 年 8 月发表的一篇论文。我用通俗易懂的文字概括了这篇文章。

开始使用:

下面提到的 8 个陷阱指的是如果数据科学家使用解释技术，他们会在哪里出错。

1)假设一个适合所有人的可解释性:

有不同种类的解释技术服务于不同的目的。数据科学家首先需要考虑基于业务约束需要什么样的可解释性。

解决方案:任何单一的模型解释技术都不适合所有的用例或模型。SHAP 是计算特征对模型预测的重要性的首选方法，因为它可以计算每个实例中每个特征的 shapely 值。然而，置换特征重要性(PFI)优选地用于计算特征重要性 wrt 以进行模型概括。

(来源)，选择流行的模型不可知解释技术

2)模型泛化能力差:

模型解释技术基于模型是最佳拟合的假设来提供见解。模型解释和底层模型一样好。拟合不足或拟合过度的模型会导致错误的解释见解。

解决方案:数据科学家应该监控、跟踪和调试底层模型，并对其进行调整，以获得一个健壮的通用模型。

(来源)，偏差方差权衡

3)复杂模型的不必要使用:

有时简单和复杂的模型在期望的度量上有相似的性能。对于模型解释而言，简单模型应始终优先于具有可比性能的复杂模型。

解决方案:与具有内核的 SVM 或复杂的神经网络模型相比，线性回归和决策树等模型更易于解释。

( Source )， Top: 对线性回归模型(欠拟合)、随机森林(过拟合)和具有径向基核的支持向量机(良好拟合)的训练和测试数据的性能估计， Bottom: 对数据生成过程(DGP)——这是基本事实——和三个模型的性能估计

4)忽略特征相关性:

PFI、PDP、LIME 或 SHAP 等不可知模型解释技术可能会误导在多重共线性数据集上训练的机器学*模型。

解决方案:数据科学家应该使用各种统计测试和可视化来检查数据集中相关性的存在，并且应该在建模和解释之前对其进行处理。

(来源)，外推解释

5)忽略模型和*似不确定性:

许多解释技术只提供了一个平均估计值，并没有量化不确定性。忽略不确定性的来源会导致对数据中噪声的解释。

解决方案:数据科学家必须反复尝试计算指标，但使用不同的引导样本来量化不确定性。

(来源)，特征“x1”的部分相关性图

6)无法扩展到高维度设置:

对于人类思维来说，解释高维数据的结果是相当困难的。对高维数据集应用模型解释可能会导致大量的高维输出。此外，计算高维数据的模型解释在计算上是昂贵的。

解决方案:建议在特征工程管道中使用降维技术或将相似特征分组。

请参考我之前的文章了解 8 降维技术。

</8-dimensionality-reduction-techniques-every-data-scientists-should-know-1c594f0aa7f2>

7)不合理的随意解释:

大多数从业者对数据生成过程的偶然洞察感兴趣，这是模型不可知的解释技术所不能提供的。标准的监督 ML 模型被设计成仅仅利用关联，而不是模拟偶然的关系。

解决方案:数据科学从业者必须仔细评估是否可以对底层数据生成、学*模型和解释技术做出充分的假设。如果假设得到满足，那么随意的解释是可能的。

(来源)，重要特征数量与特征数量的关系图

结论:

在本文中，我们已经讨论了模型不可知解释技术的 7 个陷阱，例如，在不良的模型概括、依赖特征、特征之间的交互或者因果解释的情况下，在生成模型解释之前需要记住这些陷阱

参考资料:

[1]机器学*模型的模型不可知解释方法的一般陷阱(2021 年 8 月 17 日):【https://arxiv.org/pdf/2007.04131.pdf

感谢您的阅读

8 集关于机器学*对气候影响的精彩播客

原文：https://towardsdatascience.com/8-podcast-episodes-on-the-climate-impact-of-machine-learning-54f1c19f52d

这里有一个精心策划的列表，列出了 8 个关于机器学*的环境足迹以及如何减少它的精彩播客。

照片由 Foto-Rabe 拍摄

训练和服务机器学*模型可能需要大量的电力，只要不是所有的电力都来自可再生资源，机器学*领域就会排放大量的温室气体。例如，估计训练 GPT 3 号的碳足迹相当于驾驶一辆汽车往返月球的距离。

尽管减少机器学*对气候的影响很重要，但这个问题仍然没有得到太多的关注，关于这个主题的播客也很少。

然而，我发现了这 8 个关于机器学*的环境影响的精彩播客，或者关于帮助你作为数据科学家或机器学*工程师减少碳足迹的相关主题。

绿色艾

这一集的主角是人工智能研究人员罗伊·施瓦茨和杰西·道奇，他们是论文“绿色人工智能”的作者。他们讨论了他们的论文，以及让人工智能研究更加关注计算效率的必要性。

【Emma Strubell 参与的大型 NLP 模型培训的环境影响

卡耐基梅隆大学的副教授 Emma Strubell 讨论了她的论文“NLP 中深度学*的能源和政策考虑”,其中断言 GPT-2 的碳足迹与五辆汽车的总碳足迹相似。

【Amber Mckenzie 的人工智能和机器学*对环境的影响

这一集很有趣，因为两位主持人似乎对软件和硬件工程很了解。有趣的想法被提出来，例如“数据中心将开始建造专用发电厂吗？”以及“芯片短缺是否会迫使公司专注于模型效率？”。

https://kaspergroesludvigsen.medium.com/the-10-most-energy-efficient-programming-languages-6a4165126670

微软的 Asim Hussain 介绍可持续发展软件设计和绿色软件基金会

微软与包括 Linux 基金会在内的许多其他组织合作，建立了绿色软件基金会，其工作重点是减少开发和操作软件系统对环境的影响。虽然这一集不是专门针对机器学*的，但它触及了与可持续数据科学家相关的主题，如微软的可持续软件工程原则和温室气体协议。

微软如何引领可持续软件的发展

这是微软的 Asim Hussain 的另一集，尽管这一集的问题和讨论是不同的，所以它们都绝对值得一听。

用 CodeCarbon 测量您的 ML 影响

在这一集里，你将了解如何轻松测量电力消耗，从而计算任何计算过程的碳足迹。

绿色软件工程

这一集关注的是软件工程原理，它可以让你的代码更加节能。例如，主人和客人提到一些有效的设计模式和编程语言。他们还讨论了代码速度如何不一定节能，以及如果所有的电力都来自可再生能源，我们是否还需要关注代码的能效。

您的云有多环保？

这一集从上述任何一集都没有讨论过的观点出发，介绍了可用于监控云运营的能源使用的工具。这是另一个不特定于数据科学的插曲，但对于对可持续发展感兴趣的数据科学家来说仍然是相关的。

想了解关于机器学*对环境的影响以及如何减轻这种影响的最新播客吗？去喜欢这个 Spotify 播放列表，它包含了上面提到的剧集，当我找到更多关于机器学*碳足迹的播客剧集时，我会扩展它。

你知道不在列表上的一集吗？请在评论区分享它来帮助我和其他数据🙏💚

如果你和我一样对如何让机器学*——以及一般的数据科学——更环保感兴趣，请不要犹豫，在 LinkedIn 上和我联系。

预测困难的 8 个原因

原文：https://towardsdatascience.com/8-reasons-why-forecasting-is-hard-481755a05325

以下是让预测成为如此棘手任务的原因，以及如何应对这些问题

Jukan Tateisi 在 Unsplash 上拍摄的照片

预测是数据科学中一个热门而又困难的问题。

从非平稳性到噪声和缺失值，挑战的出现有多种原因。解决这些问题可能是提高预测性能的关键。

介绍

时间序列是按时间排序的数值序列。这些数据集的关键方面是观测值之间的时间依赖性。过去发生的事情会影响未来的发展。

时间序列代表跨许多应用程序的真实世界系统。实例出现在金融、零售或运输等领域。

因此，时间序列分析是数据科学中的一个热门话题。它使专业人员能够做出数据驱动的决策。

但是，从时间序列中学*具有挑战性。在这个故事中，我列出了预测是一项困难任务的几个原因。

1.非平稳性

平稳性是时间序列中的一个核心概念。如果时间序列的属性(如平均水平)不随时间变化，则时间序列是静态的。正如我在上一篇文章中所说的:观察不取决于它们被观察的时间。

许多现有的方法都是在时间序列是平稳的假设下工作的。但是，趋势或季节性之类的东西打破了平稳性。

转换时间序列可以减少这个问题。例如，差异有助于稳定系列的水平。取对数可以稳定方差。

有几种统计测试来检查时间序列是否是平稳的。这些包括增强的迪基-富勒、菲利普-佩龙或 KPSS 测试。

2.对多重视野的兴趣

西蒙·伯杰在 Unsplash 拍摄的照片

预测通常被定义为预测时间序列的下一个值。

但是，提前预测许多值具有重要的实际优势。它减少了长期的不确定性，从而实现了更好的运营规划。

预测未来会增加不确定性。因此，对于更长的时间范围，预测变得更加困难。

在之前的一篇文章中，我描述了 6 种不同的多步预测方法。

3.对罕见事件的兴趣

照片由尼克·费因斯在 Unsplash 上拍摄

通常，我们对预测罕见病例感兴趣。这些是分布的尾部。

以能源生产为例。预测用电高峰对于管理电网的供需至关重要。

通常，罕见的事件会带来重大的长期后果。一个典型的例子是股市崩盘。这些事件导致许多投资者倾家荡产。

罕见事件可能会影响数据分布，从而导致当前模型过时。更多关于原因 5(改变点)的信息请见下文。

关于罕见事件的主要挑战是…嗯，它们是罕见的。

关于这些案例以及它们是如何发生的信息很少。因此，预测模型很难预测它们。

有几种方法可以改进极值的预测。其中包括:

• 使用对成本敏感的模型；
• 利用面向极端情况的统计分布；
• 对训练数据的分布进行重采样。

4.额外的依赖项和维度

除了时间之外，时间序列通常还有额外的相关性。

时空数据是一个常见的例子。每个观察结果都在两个维度上相关联。具有其自身的滞后(时间相关性)和附*位置的滞后(空间相关性)。

时空数据是多元时间序列的一个特例。这些时间序列由多个变量表示。

额外的变量可能包含有价值的信息。因此，对它们进行建模可能对提高预测性能至关重要。

5.改变点

照片由 Unsplash 上的hkon grim stad拍摄

事情会随着时间而变化。代表这些事物的时间序列的数据分布也是如此。

重大变化被称为变化点。当它们突然发生时，这些变化被称为结构突变。其他时候，变化发生得更慢。这些被称为渐变。

在文献中，变化点检测是一个被充分研究的主题。查阅参考文献[1]进行全面阅读。

有时改变点是已知的。

市场崩溃或战争爆发，会深刻影响组织的运作。然而，还不清楚人们应该如何应对这种变化。旧的观察结果不像以前那么有用了，因为分布已经改变了。但是，几乎没有关于新分布的信息。

检测和适应变化对于保持模型最新非常重要。监控这些模型的性能是检测变化的好方法。

6.低信噪比

不严格地说，信噪比量化了时间序列的可预测性。

信号是数据的相关部分。你试图模拟和理解的东西。但是，这种信号往往被背景噪声——看似随机的不可预测的波动——所掩盖。

有时候，这种背景噪音根本就是知识匮乏。我们不知道哪些因素影响了数据。也可能这些因素很难量化。所以，这个系列的运动看起来是随机的。

金融数据是一个普遍存在低信噪比的臭名昭著的例子。

7.噪音和缺失值

图 2:床边监护仪捕捉到的医院病人的生理信号。原始信号有噪声。局部回归平滑了它们的动态。链接为数据源。图片作者。

噪声可能源于数据收集不足。

现实世界的系统被噪音和缺失值所困扰。图 2 描述了这个问题。它显示了医院病人的生物信号。原始变量不稳定。但是，在应用局部回归(黄土)后，它们的动态变得更加清晰。

由于设备故障，可能会出现噪音和缺失值。传感器故障导致数据丢失。或者有干扰，导致错误的读数。

噪声也可能是由于贴错标签造成的。当注释者给数据分配了错误的标签时，就会出现这种情况。

适当的预处理步骤可能有助于增强该系列的信号。例子包括卡尔曼滤波器或指数平滑。

8.小样本量

有时，时间序列包含少量的观察值。在这种情况下，算法可能没有足够的数据来建立足够的模型。

这个问题可能是由于低采样频率引起的。例如，时间序列只能按月或按年观察。或者它们所代表的事物不常发生(例如极端天气事件)。

在零售领域，您可能会遇到冷启动问题。这指的是新产品的信息很少的情况。

由于变化，可能会出现数据缺乏的情况(见第 5 点。以上)。如果发生重大变化，历史数据就会过时。然后，您需要反映新分布的新数据。

正如我在之前的一篇文章中所写的，如果有足够的数据，机器学*模型会更好。否则，你应该选择简单的解决方案。

使用全球预测模型可以缓解缺乏数据的问题。这些利用许多时间序列来建立模型。你可以在之前的故事中了解更多。

外卖

在这篇文章中，我描述了你在预测任务中遇到的 8 个挑战。这里有一个总结:

1. 非平稳性:当数据属性随时间变化时；
2. 多步提前预测:对长期预测感兴趣；
3. 极值:极少数情况下的兴趣；
4. 额外相关性:对准确预测至关重要的额外变量；
5. 变化:检测分布的变化；
6. 低信噪比:时间序列可预测性低时；
7. 噪声:数据的随机波动；
8. 小样本:数据不足时。

感谢您的阅读，下一个故事再见！

进一步阅读

[1] Aminikhanghahi、Samaneh 和 Diane J. Cook。"时间序列变点检测方法综述."知识和信息系统51.2(2017):339–367。

[2] Karpatne，Anuj 等，“面向地球科学的机器学*:挑战与机遇” IEEE 知识与数据工程汇刊31.8(2018):1544–1554。

Python 中单变量探索性数据分析(EDA)的 8 个 Seaborn 图

原文：https://towardsdatascience.com/8-seaborn-plots-for-univariate-exploratory-data-analysis-eda-in-python-9d280b6fe67f

了解如何使用 seaborn 和 matplotlib 一次可视化和分析一个变量

照片由 Pixabay 来自 像素

数据探索，尤其是探索性数据分析(EDA)，是数据科学项目中我最喜欢的部分。一组新数据带来了挥之不去的好奇和兴奋，有机会发现微妙的关系和意想不到的趋势。

在以前的一篇文章中，我介绍了我每次在新数据集上使用的 11 个基本 EDA 代码块。今天的文章关注 seaborn 可视化图，用于单变量分析(一次关注一个特征)。在数据科学流程的任何阶段使用这些图。

加载库和数据

我们将探索来自 Kaggle 的车辆数据集 <#45d1>。还要注意，在本文中，单词“变量”、“特性”和“列”的意思都是一样的。

打开一个新的 Jupyter 笔记本并导入所需的库。Seaborn依赖于matplotlib,我们将同时导入它们。另外，设置style和font。

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
sns.set_style('darkgrid')
sns.set(font_scale=1.3)

接下来，我们加载csv file并运行一些 EDA 代码行，以获得数据的总体概述。

cars = pd.read_csv('Car details v3.csv')
cars.head()

作者图片

cars.shape
#(8128, 13)cars.dtypes

作者图片

通过这些结果，我们了解了数据集的大小(行数=8128，列数=13)、列名和它们的数据类型，并显示了 5 行，以便对数据中的值有所了解。

单变量分析

前缀“Uni”的意思是一，意味着“单变量分析”是一次分析一个变量。

对于数字特性，我们希望知道存在的值的范围以及这些值(或值组)出现的频率。

对于分类特征，我们想知道唯一类的数量以及它们出现的频率。

第 1 部分:数字特征

这些是带有数字的要素，您可以对其执行数学运算。它们又进一步分为离散(边界清晰的可数整数)和连续(可以取某个范围内的任意值，甚至小数)。

我们首先使用 df.describe()显示每个数字特征的汇总统计数据。这向我们展示了实际的统计数据。

cars.describe()

数字要素的汇总统计数据

为了更直观地理解这种分布，我们需要用图形将它们可视化。

1。直方图— **sns.histplot()**

直方图将值分组到不同的范围(或条块)中，条形的高度显示有多少个值落在该范围内。

作者直方图

从直方图中，我们将得到以下结果:

• 数据的范围。最小值和最大值位于直方图的相对边缘。高度集中的区域也很明显。高条是大多数数据点所在的位置，而稀疏表示的范围显示为间隙或短条。
• 特征的形状或偏斜度。要素可以是右偏的(尾部向右)、左偏的(左尾)、正态分布的(一个中心)或随机分布的(没有明显的模式，多个峰值)。
• 异常值的存在。这些显示为最左边或最右边的孤立条。

下面的代码为我们的目标变量selling price创建了一个 seaborn 直方图。

sns.histplot(x='selling_price', data=cars);

作者直方图

下面的代码利用一个循环为所有数字变量创建单独的直方图。

cols = 3
rows = 3
num_cols = cars.select_dtypes(**exclude**='object').columnsfig = plt.figure( figsize=(cols*5, rows*5))for i, col in enumerate(num_cols):

    ax=fig.add_subplot(rows,cols,i+1)

    sns.histplot(x = cars[col], ax = ax)

fig.tight_layout()  
plt.show()

2。KDE 剧情— **sns.kdeplot()**

“内核密度估计”图通过将所有点标准化为出现在一条曲线下，创建了一个平滑版本的直方图。

作者的 KDE 情节

它最适用于比较一个变量在另一个变量组之间的分布，这个概念被称为分段单变量分布。

下面的代码比较了engine sizes如何在fuel types之间分配。我们通过hue=’fuel’按照燃料类型分割数据。

sns.kdeplot(x='engine_cc', data=cars, hue='fuel')

作者的 kdeplot

3。带直方图的 KDE 图— **sns.histplot(kde=True)**

我们可以用如下的 KDE 曲线显示一个直方图。见这篇文章了解 kde 和直方图。

sns.histplot(x='selling_price', data=cars, kde=True)

作者 kde 直方图

4。地毯图— **sns.rugplot()**

rug plot 在 x 轴上绘制记号，显示各个数据点的位置。

作者的 Rugplot

密集区域是大多数观测值都落在其中的地方，而分笔成交点的高度则无关紧要。

Rug 图是对直方图的补充，因为我们可以看到异常数据点的位置。下面的代码为kilometers driven特征创建了一个褶皱图和直方图。注意异常位置。

sns.rugplot(x='km_driven', data=cars, height=.03, color='darkblue')
sns.histplot(x='km_driven', data=cars, kde=True)

作者的皱纹图和直方图

5。箱形图— **sns.boxplot()**

一个箱线图显示一个数字特征的分布、中心和偏斜度。它将数据分成包含大约 25%数据的部分。

作者创作的箱线图插图

异常值，如果存在，在两端显示为圆点。从框中伸出的触须代表最小值和最大值。方框描述了四分位数间距，并保存了 50%的数据。

箱线图比直方图占用更少的空间，因为它们不太详细。它们还定义了四分位位置，有利于快速比较不同的要素或分段。

下面的代码创建了一个mileage特性的箱线图。

sns.boxplot(x=cars['mileage_kmpl'])

作者的箱线图

假设您想要比较两个相关列的分布情况；也许他们有相同的测量单位。我们可以创建一个方框图，并在data中传递两列，如下所示。

sns.boxplot(data=cars.loc[:, ['engine_cc', 'max_power_bhp']])

作者的箱线图

下面的代码在一个循环中为所有的数字变量创建箱线图。

cols = 3
rows = 3
num_cols = cars.select_dtypes(exclude='object').columnsfig = plt.figure(figsize= (15,9))for i, col in enumerate(num_cols):

    ax=fig.add_subplot( rows, cols, i+1)

    sns.boxplot(x=cars[col], ax=ax)

fig.tight_layout()  
plt.show()

按作者列出的所有要素的箱线图

6。小提琴剧情— **sns.violinplot()**

小提琴图结合了盒子图和内核密度图。这意味着除了显示四分位数之外，它还展示了潜在的分布，例如不同峰值的存在和位置。

图片来自来源

下面的代码创建了一个year数据的 seaborn violin 图。

sns.violinplot(x=cars["year"])

作者的小提琴情节

7。带状图— **sns.stripplot()**

一个带状图实现了一个散点图来显示一个特征的单个观察值的分布。

密集位置表示有许多重叠点的区域，您可以快速发现异常值。然而，与箱线图不同的是，建立相对中心是很困难的，对于较小的数据集来说，这是最好的。

下面的代码创建了一个selling price的带状图。

sns.stripplot(x=cars["selling_price"]);

作者的带状图

第 2 部分:分类特征

这些是可能值数量有限的列。例如性别、国家或年龄组。

在创建图之前，我们将首先运行汇总统计数据，显示每个要素的唯一类的数量等信息。这将告诉我们哪些特征可以被有效地可视化。如果有太多的类，情节是混乱和不可读的。

cars.describe(include='object')

作者图片

现在我们可以想象上面强调的四个分类特征。

8。计数图— **sns.countplot()**

计数图比较分类特征的不同类别及其出现频率。想象一个条形图，其条形高度显示每个类在数据中出现的次数。

按作者统计情节

下面的代码使用循环为唯一类小于 10 的分类要素创建计数图。

cols = 4
rows = 1
fig = plt.figure(figsize= (16,6))all_cats = cars.select_dtypes(include='object')cat_cols = all_categs.columns[all_categs.nunique() < 10]for i, col in enumerate(cat_cols):

    ax=fig.add_subplot(rows, cols, i+1)

    sns.countplot(x=cars[col], ax=ax)

    plt.xticks(rotation=45, ha='right')

fig.tight_layout()  
plt.show()

作者计数图

9。饼状图—**plt.pie()**

一个饼图在一个圆形图中显示一个分类变量的百分比分布。

按作者排列的饼图

饼图在可视化社区中不是很受欢迎。首先，当组数超过四个时，图表会显得混乱。第二，有时切片的宽度不是直观清晰的。

Seaborn 不实现饼图。我们将使用 matplotlib 版本。

与 seaborn 图不同，饼状图不计算引擎盖下的计数。因此，我们将使用Series.value_counts()获得计数。

df = cars['transmission'].value_counts()###df
Manual       7078
Automatic    1050
Name: transmission, dtype: int64

接下来，我们使用plt.pie()创建饼图，并向它传递每个组的值、每个切片的标签(可选)，以及如何显示切片内的值(可选)。

plt.pie(df, labels=df.index, autopct="%.0f%%");

按作者排列的饼图

autopct = “%.0f%%”创建格式化字符串。(%.0f)是舍入到 0 位小数的浮点值的占位符。最后一部分(2 个百分比符号)由占位符(%)和要打印的实际百分比符号组成。

结论

单变量分析只涵盖了数据探索的一个方面。它检查单个要素的分布，以确定它们在数据中的重要性。下一步是理解特征之间的关系和相互作用，也称为双变量和多变量分析。

我希望你喜欢这篇文章。所有的代码和数据文件都在这个 GitHub 链接中。

欢迎您订阅此处每当我发布数据科学文章时，您都会收到电子邮件提醒。如果你不是一个媒体成员，你可以通过这个链接加入来支持我作为一个作家，我将赚取一小笔佣金。感谢您的阅读，祝您的数据之旅一帆风顺！

参考文献

1. https://www.kaggle.com/datasets/nehalbirla/vehicle-dataset-from-cardekho?ref=hackernoon.com&select=Car+details+v3.csv尼哈尔·比拉尼尚特·维尔马和尼基尔·库什瓦哈的车辆数据集在【DbCL】下获得许可

成为 IT 或 DS 专家应该做的 8 件事

原文：https://towardsdatascience.com/8-things-you-should-do-to-get-hired-as-it-or-ds-specialist-5dfc8f9b9765

蒂姆·莫斯霍尔德在 Unsplash 上的照片

成为 IT 或 DS 专家应该做的 8 件事

作为 IT 和 DS 部门的负责人，我花了大量的时间招聘人员，如果你想被录用，这就是我要与你分享的！

我担任 IT 和 DS 部门的主管已经两年多了。我白手起家建立了这个部门，从一开始，招聘员工就是我日常头疼的事情之一。因此，通过这篇文章，我希望帮助 IT 和 DS 专家尽最大努力获得他们梦想中的工作，并为招聘经理节省一些时间。

这里我应该提到，当我们考虑 it 和 DS 领域的劳动力市场时，现在是一个“卖方市场”。然而，这主要是针对有经验的专业人士。由于大量的在线课程和对 IT 职业的大肆宣传，竞争非常激烈，年轻专家的处境最*变得相当艰难。使用下面的建议，你可以大大增加你在成百上千竞争开发人员职位的候选人中脱颖而出的机会。

1。定义你的目标

首先，如果你决定找一份 IT 或 DS 方面的专员的新工作，你应该非常真诚地回答自己:你的目标是什么？你想成为你所在领域的专家或未来的经理吗？也许，你实际上并不知道，只是想获得一些经验？你只是在找高薪还是目标是得到感兴趣的项目？请注意——你不能回答“我什么都想要”——优先考虑最重要的事情。你也可以说“我想要所有事情的平衡”，这和第一句话不一样，因为你在每个领域都做出了一点牺牲(工资没那么高，项目有点一般，等等)。)但有了这个选择，你就有了相当多的工作机会可供选择，也有更多的机会对你得到的工作感到满意。

甚至在你打开一个有职位空缺的网站之前，确定你的目标是很重要的，因为根据它你可以筛选工作机会。写下你的优先事项，然后继续前进！

2.了解你的能力

当您了解自己的优先事项时，您应该了解自己作为 IT 或 DS 专家的能力—这非常重要！你不可能擅长所有的事情，这没关系。一个称职的招聘经理明白每个人在团队中都有自己的角色。如果你说你什么都擅长，那就更糟糕了——这会立刻成为雇主考验你和找到你的界限的一个挑战。然而，如果你什么都知道，那么，对你有好处，去得到它们！

不要同时申请同一家公司的几个互不相关的职位(例如 python 中层开发人员和 DS 的团队领导)。那必然会导致把你加入黑名单！在最坏的情况下，甚至可能损害你在几家公司的声誉(不同公司的 HR 经常交流)。

因此，写下您的堆栈和每项技术的知识水平，从 1 到 10。将这些信息添加到你的简历中。继续前进。

3.公平对待你的能力水平

这很简单——不要试图欺骗雇主说你比实际情况要好。重要的一点是，你也不要试图欺骗自己你比实际情况更糟糕！找到平衡和地面真相。你可以使用一些网站来检查你的知识，或者你可以让资深同事在初级-中级-高级的范围内公正地评估你的水平。

虽然为了减轻你的痛苦，你可以使用这个*似的尺度(它不是每个人的基本事实，而是“医院里的平均体温”):

• 0 年相关工作经验，你刚刚完成学业——很可能你是一名实*生
• 0.5-2 年相关工作经验——很可能你是一名优秀的初级开发人员(接* 2 年——接*中级职位，通常他们被称为“初级+”)。作为一个好的初学者，你应该非常了解相关的基本堆栈，你只是还需要获得更多的实践经验，学*一些额外的技术，并对这些基本技术有更深的理解。
• 2-5 年相关工作经验——很可能你是一名优秀的中级开发人员。你非常了解你的堆栈，你有一些代码审查的经验，可能领导过 1-2 个初级或培训生，你有广泛的专业知识和你的堆栈的不同应用的经验。
• 5-10 年相关工作经验——很可能你已经是高级开发人员或团队领导，甚至是 CTO。可能的职位之间的差异是如此之大，因为现在一切不仅取决于你的硬技能，而且主要取决于软技能。而且，我会说，现在你大概 30+岁左右了。你还有时间，但现在是开始思考前进方向的最佳时机:你会成长为一名领导者吗？或者你想改变你的筹码？或者你可以自己创业？最好现在就开始朝着选定的方向前进。

4.申请前做好功课

许多开发人员实际上并不关心他们将简历发送到哪里。他们不会对他们申请的公司做任何调查。这是一个巨大的错误，会在面试中让雇主产生很多疑虑:如果你不在乎你在哪里工作，你随时都可能离开，雇主无法预测或者理解你为什么要离开。当然，每个雇主都明白这一点，并且更愿意避免风险(意思是避免雇用你)。因此，如果你对某个职位感兴趣——做出努力，研究公司，向他们表明你确实关心你将去哪里工作，并向他们解释原因。

这很难，但会给你一些额外的加分:谷歌一下招聘公司的最佳实践，找一些经理的名字(可能用 LinkedIn)和他们的演讲、工作或面试。提及一些你在面试中发现的东西，你可能会为你准备的深度而惊讶，那么你一定会在其他候选人中脱颖而出！

5.如有必要，进行测试

有些雇主不会问候选人，但有些雇主会让候选人选择是否准备好做一些小的测试案例作为家庭作业。不用说，如果你拒绝了，你获得工作的机会就会大大减少。不过你也应该记住，让一个高级职位的候选人参加这样的考试是没有意义的。它通常用于检查学员、初级和中级开发人员的知识，并确定他们的能力水平。

6.努力完成你的交付

嗯，我知道作为一名开发人员，你的工作是写好代码，而不是谈论它。然而，在远程工作的世界中，通过 Zoom 或 messenger 进行有效和高效的沟通变得至关重要。所以这也是招聘经理在面试时要考虑的事情。以下是一些在面试中更好地进行在线交流的简单技巧:

• 不要急:三思而后言。与其说些废话，不如要求 30 秒的思考时间。
• 不要紧张也不要害怕:招聘经理希望看到你所有的优秀品质，此外，如果你已经在面试阶段——经理已经在你身上下了赌注！所以放轻松，展现自己最好的一面。
• 结构化你的答案:无论你说什么，试着使你的答案结构化(查阅 make 麦肯锡的概念)
• 多说:招聘经理想听听你的知识，你的思维过程。你能传达它的唯一方式是大声说出来。不要封闭的回答他“是的，我知道什么是 REST API”——告诉他什么是REST API。

使用这个建议，你会在面试中尽你所能！

7.更新您的技术知识

这似乎是显而易见的，但许多候选人忽略了这一步——为技术面试做准备！仔细阅读职位描述，雇主要找的栈，google 空缺中使用的所有术语，那里提到的所有框架和库。

这种准备不会用技术代替实践经验，但是，说“我知道这是什么，但是，我还没有机会用它工作”(这可以算作你的答案的 0.5 分)比只说“我不知道”(这是一个纯粹的 0 分答案)要好。

8.面试前练*

好吧，即使你是一个真正优秀的 IT 专家，你的沟通技巧也很棒，花 30 分钟在镜子前练*回答技术问题和讲述你的经历也是值得的。

谷歌面试问题到你梦想的公司。通常，各个公司的产品都非常相似，但有时，某个公司或该公司使用的堆栈会定义一些特性。

有趣的是，现在市场如此火爆，以至于 It 专家可以忽略我在这篇文章中提供的所有建议，仍然会因为他们的技术技能或甚至只是高需求而找到工作。

然而，如果你遵循我的建议，你将大大增加你得到一份理想工作的机会，同时也将节省大量找工作和面试的时间。你还会让这个世界上的几个招聘经理更开心，为你的因果报应加分:)

感谢您的阅读！点击拍手按钮支持我，并在媒体上跟随我！👏

如果您使用我的推荐链接成为这里的中级会员，您也将极大地支持我和我的工作！

为数据科学创建引人注目的演示文稿的 8 个技巧

原文：https://towardsdatascience.com/8-tips-for-creating-a-compelling-presentation-for-data-science-dd48c09683b0

每位分析师和数据科学家都可以学*的技巧，以制作令人信服的演示文稿

宇宙时间旅行者在 Unsplash 上拍摄的照片

作为数据科学家或分析师，我们花费无数的时间来完善我们分析数据的能力，建立机器学*模型，并跟上最新的技术趋势。然而，每个人都需要的一项技能是创建引人注目的演示文稿的能力。

每个数据科学家、分析师和数据工程师都需要擅长构建一个令人信服的演示文稿。

以下是我 20 多年来收集的向高管、客户和同事展示的技巧和诀窍。这些技巧并不局限于数据科学，任何人在创建演示文稿时都可以使用；让我们快速浏览一下。

1. 从大纲开始
2. 用情境、复杂性和解决方案讲故事
3. 每张幻灯片一分钟的规则
4. 三的法则
5. 将幻灯片标题作为结果写入
6. 大声朗读标题
7. 集中你的观众的注意力
8. 创建引人注目的数据可视化

我们开始吧！

从大纲开始

开始演示时，他们通常会打开 PowerPoint、Keynote 或他们选择的工具，并立即开始尝试构建演示文稿。当然，这个问题是，你将在幻灯片上迭代 100 次，很可能最终删除你已经创建的大部分内容。

一个更好的方法是从一个大纲开始，和你在英语 101 中所学的没什么不同。但是不要认为这是你想要创建的幻灯片的大纲。把大纲想象成你将要讲述的故事。创建大纲有两种常见的方法。第一种是简单地使用有序列表并通过你故事的想法或部分来构建你的大纲(我将在接下来讲述故事的部分)。如果你是一个更加视觉化的人，你可以使用思维导图并以类似的方式构建它。

一旦你有了大纲，创建支持内容就变得轻而易举了。

用情境、复杂性和解决方案讲故事

一个经典的讲故事框架是英雄之旅。大意是，一个英雄去旅行，引入一些障碍；最后，英雄可以克服那个障碍，从此每个人都过着幸福的生活。

在我们的业务演示中，我们可以使用一个类似的框架，称为情境-复杂-解决或 SCR 。我第一次接触到 SCR 是通过芭芭拉·明托的书金字塔原理，他在麦肯锡咨询公司工作时推广了这个方法。这种结构非常适合创造一个商业故事。这是一个简单的框架，让你在结构中保持有组织，带来面向行动的结果，并符合三原则，我将在后面介绍。

• 情境:关于当前状态的事实。
• 并发症:根据情况需要采取行动。
• 解决方案:采取或建议采取措施解决复杂问题。

使用我们的大纲格式，这里是一个过于简化的 SCR 的例子。在实践中，您将引入更多的细节作为节点的子项。利用 SCR 将帮助你创造一个干净的，引人注目的故事！

作者图片

每张幻灯片一分钟的规则

这个简单有效。考虑到每个主要内容幻灯片将花费一分钟来演示，而不是创建您的演示并排练时间。如果你有一个 20 分钟的演示，目标是 20 张包含内容的幻灯片。你不应该把分隔线、封面或闭幕标志幻灯片算在内。这些年来我发现，一般来说，有些会花更长时间，有些会更短，但平均来说，他们会花大约一分钟。

消除计算你需要创建多少内容的压力。

三的法则

另一个指导原则是三个的法则。三的规则很简单:在构建你的结构、你的故事的各个部分或者你幻灯片上的项目符号的数量时，坚持三个并且只有三个项目。

苹果已经在他们的展示和产品线中实现了这一点，而科学已经向表明我们的大脑喜欢模式，而三是形成模式所需的最小数字。

利用三法则来组织你的幻灯片将有助于你的观众记住你的内容并简化演示。你可能会想，“越多的信息越好，用四个、六个或八个要点。没有人能完全理解，所以把它缩减到三个最有影响力的信息。

如果你有稍微多一点的信息，另一个技巧是像下面的图片一样三乘三地组织它。

作者图片

将幻灯片标题作为结果写入

我经常看到数据科学家写他们的幻灯片标题描述幻灯片上的内容，而不是幻灯片的结果或收获是什么。这个简单的练*可以让你不费吹灰之力就能极大地改善你的演讲。让我们来看几个例子。

• 算法训练和验证 vs. 以 92%的准确率预测客户流失
• Q1 交谈率与直接联系的客户购买的可能性高出 5 倍
• 利用 XGBoost 对客户进行分类与机器学*将成交率提高了 22%

很明显，像这样的例子更能吸引你的观众。记住，你的幻灯片标题是你的幻灯片的结果！

大声朗读标题

有很多文章会告诉你不要大声朗读你的幻灯片。直接从你的幻灯片上阅读你的内容肯定会让你的观众厌烦并失去他们的注意力。

然而，我对这条规则有一个警告；大声读出你的幻灯片标题。

根据 Naegle :

阅读和语言处理使用相同的认知渠道——因此，由于认知超载，观众可以阅读幻灯片，听你说话，或者两者兼而有之(两者都很差)。

通过在开始每张幻灯片时只阅读标题，观众将能够更容易地理解信息，这比边听边读文字要容易得多。虽然一开始可能会觉得不舒服，但你可以和一些同事一起练*一下，然后自己看看！

对于幻灯片的其余部分，请不要阅读内容，尤其是当您使用大量项目符号列表或有序列表时。如上所述，阅读你所有的内容可能会很单调。

集中你的观众的注意力

当你的幻灯片上有不止一个单词或数字时(这也是一个非常强大的练*)，你可以利用技巧或属性将观众的注意力集中在最重要的单词上。这些注意力吸引器被称为前注意属性。

当你的眼睛和大脑第一次看到幻灯片时，在最初的几分之一秒内，你会被不同的突出元素所吸引。物品可以是粗体、斜体，或者不同的颜色或尺寸。它们与正文不同的事实是你如何能集中你的注意力。

这方面的一个很好的例子改编自斯蒂芬·诺的《挖掘视觉的力量》。当我们看第一段文字时，它们都倾向于融合在一起。如果我们问你，“告诉我有多少个数字 7”，这需要一点时间。

作者图片

然而，当你看第二张图时，我们已经接入了粗体和颜色的预先注意属性，我们可以看到每一个七。

作者图片

这个概念也直接适用于构建数据可视化，我们将在接下来讨论。

创建引人注目的数据可视化

仅这一部分就可以保证写一整篇文章(或一本书)来讨论它。好消息是已经有很好的了。我推荐两个你应该马上买的:

1. 用数据讲故事作者科尔·努斯鲍默·克纳弗里克
2. 数据故事作者南希·杜阿尔特

这两本书都涵盖了如何建立一个更好的可视化。阅读这些内容，研究它们，并在每次构建视觉效果和演示文稿时参考它们。

结论

学*如何令人信服地展示您的数据科学项目结果是您可以学*的最重要的技能之一。我们讨论了如何从大纲开始，利用讲故事的框架来组织你的演讲，一分钟规则和三分钟规则。我们还讨论了如何通过将标题写成结果而不是主题来形成更好的标题。我们讨论了两种吸引观众注意力的方法:演讲时大声朗读你的标题，以及通过粗体和颜色等方法挖掘预先注意的属性。最后，我们讲述了如何创建引人注目的数据可视化。遵循这些作为你下一次演讲的指导方针，我相信你能够创造出一个令人信服的演讲。

如果你喜欢阅读这样的故事，并想支持我成为一名作家，考虑注册成为一名媒体会员。一个月 5 美元，让你可以无限制地访问成千上万篇文章。如果您使用 【我的链接】 注册，我将为您赚取一小笔佣金，无需额外费用。

使用散景在 Python 中创建数据可视化的 8 个技巧

原文：https://towardsdatascience.com/8-tips-for-creating-data-visualizations-in-python-using-bokeh-d7a01701503d

使用散景库创建数据可视化的快速提示和示例

卢卡斯·布拉塞克在 Unsplash 上的照片

Python 是一个很好的创建数据可视化的开源工具。有许多可用的数据可视化库，包括 Matplotlib、Seaborn 和 Bokeh。

Bokeh 是一个 Python 数据可视化库，旨在创建 交互式 图表。虽然可以免费使用，但通常需要大量的时间来学*细节。

下面是我在使用散景创建数据可视化的过程中学到的一些技巧。

注:所有显示的示例，包括代码和数据集，都可以在 这里 找到。

1-设置图表标题、轴标题和轴标签的格式，以便于阅读

格式良好的标题和标签可以提高图表的可读性和可用性。易于阅读的标题、标签和轴允许用户快速查看和处理可视化。

设计数据可视化时，记住标题和标签的格式很重要，包括字体粗细、字体大小和字体颜色。

例如，下面的条形图按经验级别显示了数据科学专业人员的平均工资。该可视化使用标题和标签的默认值。

按作者分类的图像:带有默认标题和轴标签的条形图

更改默认设置可以增强数据的可视化。下面是我在用散景格式化图表标题和坐标轴时使用的一些技巧。

• 粗体图表&轴标题 —粗体标题使其突出。这使得用户更容易快速找到识别信息。
• 居中图表标题 —默认情况下，图表标题左对齐。将标题居中，用对称元素平衡视觉效果。
• 增加图表字体&轴标题 —增加标题的字体大小，使其更容易阅读。确保坐标轴标题小于图表标题，这样它们就不会压倒图表。
• 设置轴范围 —默认情况下，轴不从 0 开始。正如我们在上面的例子中所看到的，这导致条形看起来偏离了 x 轴。要格式化 x 或 y 轴的范围，使用 Range1d 功能。
• 用 刻度格式化器修改轴标签——Bokeh 包含几个刻度格式化器，如numeratickformatter和categoricalticktformatter。这些刻度格式化程序可以更改 x 轴和 y 轴刻度标签的格式。在上面的例子中，numeratickformatter可以删除 y 轴的科学记数格式。查看散景文档以查看适用于您的版本的格式化程序。
• 用自定义标签覆盖轴标签 —当标签包含以千、百万等为单位的大数字时，自定义会有所帮助。使用自定义标签创建别名或简称。例如，如果标签显示值“1，000，000”，自定义标签可以将显示更改为“1M”，以便于阅读。

下图显示了应用这些技术后的条形图。虽然这些变化很细微，但它们提高了图表的可读性和可用性。

作者图片:修改了标题和标签的条形图

2-创建交互式图例

图例为数据可视化提供了有用的上下文，允许用户快速识别相似的数据点—无论是通过颜色、形状还是大小。使用 Python 中的散景库，用户可以创建交互式图例。交互式图例隐藏或隐藏部分数据。当有大量组时，或者如果几个数据点重叠时，交互式图例会很有帮助。

例如，下面的线形图显示了 2013 年至 2019 年因加州野火而被烧毁的总英亩数。这个线图上有 6 个县，有几条重叠的线。

图片作者:加州野火线形图

创建交互式图例允许用户选择要从视图中移除的项目。可以通过将人物的 click_policy 设置为“隐藏”或“静音”来“隐藏”或“静音”项目，如下面的命令所示。

# Set Legend Click Policy for Figure 'p' 
p.legend.click_policy="mute"

我更喜欢将图例中的项目静音，因为静音的项目会显示为灰色，而不是完全从视图中移除。这样，用户可以专注于他们想要的组，同时确保完整的数据集得以呈现。

注意:如果静音项目，应为绘制的每条线指定 muted_color 和 muted_alpha 字段。查看此可视化的完整代码 此处 。

在加州野火折线图中， click_policy 设置为“静音”，灰色为 muted_color ，0.2 为 muted_alpha 值。通过从视图中移除特定的县，用户能够更快、更有效地在更小的范围内比较县。例如，如果用户想要比较洛杉矶的野火和圣地亚哥的野火，这将是困难的，因为几条线重叠。在下图中，除了洛杉矶和圣地亚哥之外的所有县都被静音，这样可以更容易地比较这两个县之间的总烧毁英亩数。

作者图片:加州野火线形图，部分县被屏蔽

交互式图例也可以应用于其他可视化。下面的散点图按种族显示了学生数学和阅读成绩之间的关系。添加交互式图例会有所帮助，因为有几个重叠的数据点。要创建带有交互式图例的散点图，请单独绘制每个组。我们可以看到，通过屏蔽组 A、B 和 C，我们能够轻松地比较组 D 和 E。点击 查看此数据可视化 的完整代码。

作者图片:带有交互式图例的散点图

3-通过将图例放置在图形外部来最大化空间

在 Python 中，许多数据可视化(如折线图、散点图和条形图)允许您使用简单的命令添加图例。用户通常会保留图例的默认位置，或者将图例移动到包含可视化的图内的某个地方，例如左上角或右上角。虽然在大多数情况下这是好的，但也有图例覆盖可视化关键区域的情况。在下面的按国家划分的巧克力平均等级条形图中，默认图例位置包括比利时和英国，因此很难确定两者孰高孰低。

按作者分类的图像:带有默认图例位置的条形图

如果可视化有几个数据点，或者如果向可视化添加图例会导致覆盖关键信息，请将可视化放置在图形的一侧。

作者图片:图例位于图右侧的条形图

通过将图例移出框架，我们能够完整地看到可视化效果，同时将图例作为有用的参考。

要在图形 p 的右侧添加图例，请使用以下命令。

p.add_layout(Legend(), ‘right’)

注意:要使用散景中的图例功能，请导入以下功能。查看此可视化的完整代码 此处 。

from bokeh.models import Legend
from bokeh.models import Range1d

4-添加工具提示

工具提示，通常称为悬停文本，是当您将光标移动到可视化效果或可视化效果的部分上时出现的文本。使用工具提示与查看者共享其他信息。Bokeh 库允许将工具提示添加到几种可视化类型中，包括条形图、折线图和散点图。

要向可视化添加工具提示，请导入悬停工具功能，如下所示。

from bokeh.models.tools import HoverTool

以下面的条形图为例，按国家列出的巧克力平均等级。此图表中的工具提示显示光标悬停在其上的国家的国家名称和平均等级。

作者图像:启用工具提示的条形图

类似于设置图表标题和标签的格式，您还需要记住如何在工具提示中设置文本的样式！

在下面的条形图按经验水平平均工资中，工具提示包含了关于经验水平和平均工资的信息，单位为美元。

作者图像:启用工具提示的条形图

默认情况下平均工资文本不自动格式化为货币；然而，经过几处修改，我们可以将文本格式化为包含美元符号和逗号。创建数据可视化以格式化工具提示时，添加了以下代码行。查看本可视化完整代码 此处为 。

# Add hover text 
p.add_tools(HoverTool(tooltips=[(“Experience Level”, “@types”), 
 (“Average Salary (USD)”, “$@values{0,0}”)]))

工具提示还可以包含 x 轴和 y 轴以外的信息。以下散点图按性别显示了学生的数学和阅读成绩。本示例中的工具提示显示了每个学生的性别、数学分数和阅读分数。

作者图像:启用工具提示的散点图

5-使用选项卡组织数据可视化

使用 Bokeh，可以使用选项卡显示数据可视化。与仪表板类似，每个选项卡都由自己的内容组成。选项卡显示彼此相关的多个可视化效果，无需生成仪表板，也无需在 Jupyter 笔记本中滚动多个图像。它们对于显示同一图形的不同视图也很有用。

下图显示了如何使用选项卡来显示散点图的变体。第一个散点图按性别显示学生的数学和阅读成绩，第二个散点图按种族显示学生的数学和阅读成绩。

作者图像:Bokeh 示例中的 tab 对象

要创建带有标签的对象，使用以下命令导入标签和面板小部件。

 from bokeh.models.widgets import Tabs, Panel

一旦创建了图形，就可以将它们添加到选项卡式对象中。以下代码片段显示了如何创建学生成绩散点图的选项卡式对象。在这里 查看这个可视化 的完整代码。

# Create tab panel for scatterplot visualizations

# Create the two panels 
tab1 = Panel(child = p, title = 'Student Math and Reading Scores by Gender')
tab2 = Panel(child = r, title = 'Student Math and Reading Scores by Race')

# Add the tabs into a Tabs object
tabs_object = Tabs(tabs = [tab1, tab2])

# Output the plot
show(tabs_object)

虽然上面的例子显示了每个选项卡一个可视化，但是可以为每个选项卡添加多个可视化——只要记住布局和整体流程就行了！

6-删除网格线

默认情况下，网格线出现在使用散景创建的数据可视化效果上。通过从可视化中移除网格线来减少视觉混乱。这使得用户更容易查看和解释手头的数据。

查看下面的按经验级别划分的平均工资条形图，我们会看到自动添加的网格线。

按作者分类的图像:带有默认网格线的条形图

通过删除网格线，可视化效果变得不那么杂乱，如下图所示。

按作者分类的图像:移除网格线的条形图

在散景中，移除网格线是一个快速的过程，可以通过将 grid_line_color 设置为“无”来完成。点击 查看此可视化 的完整代码。

p.xgrid.grid_line_color = None
p.ygrid.grid_line_color = None

7-使用预定义的颜色和调色板

颜色是任何数据可视化的关键部分，决定使用正确的颜色需要时间。散景库附带了几种预定义的颜色和调色板。

可用的调色板可能因您使用的散景版本而异。要查看单个颜色名称的列表，请点击查看散景文档。

要查看特定版本的可用调色板，请查看散景官方文档，或运行以下命令。此命令根据运行的散景版本列出可用的调色板。

bokeh.palettes.all_palettes.keys()

散景调色板由不同的大小组成。要查看调色板中可用的特定十六进制颜色以及可用的不同大小，请使用以下命令。该命令列出了' Set3 '调色板的可用尺寸，包括十六进制颜色。

bokeh.palettes.all_palettes[‘Set3’]

要导入特定大小的调色板，请运行以下命令。该命令导入尺寸 3 设置 3 调色板。

from bokeh.palettes import Set3_3

或者，通过指定调色板名称来导入调色板中的所有尺寸。以下示例显示了如何为 Cividis 调色板导入所有尺寸。

from bokeh.palettes import cividis

可能很难解释十六进制颜色。要快速查看这些十六进制颜色，您可以使用如下函数。

from IPython.display import Markdown, display

def printColorPalette(color_palette):
 display(Markdown(‘<br>’.join(
 f’<span style=”color: {color}; font-family: courier;”><span>{color}: </span>&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;</span>’
 for color in color_palette
 )))

这个函数获取一个十六进制数的列表，并打印出十六进制数和相应的颜色块。下图显示了各种尺寸的 Cividis 、 Set3 和光谱调色板的输出。

作者图片:使用函数打印各种调色板

更多示例 v 查看完整代码 此处 。

8-直接在 Jupyter 笔记本中显示可视化效果

在 Jupyter Notebook 中创建散景可视化效果时，默认设置会在新网页中显示输出。直接在笔记本中显示可视化效果，以便快速排除故障和开发可视化效果。

要在 Jupyter Notebook 中显示散景数据可视化，请导入以下函数。

from bokeh.io import output_notebook, show
from bokeh.resources import INLINE

在开发任何可视化之前，调用 Bokeh 的[**output_notebook()**](https://docs.bokeh.org/en/latest/docs/reference/io.html#bokeh.io.output_notebook)函数，如下所示。

output_notebook(resources=INLINE)

一旦设置了可视化的输出，使用 show() 功能为每个数据可视化显示笔记本中的输出。

例如，下图显示了如何调用函数 show() 来显示 Jupyter 笔记本中的散点图 p 。

作者图片:Jupyter 笔记本中显示的数据可视化

直接在笔记本中显示可视化效果有助于将可视化效果保存在一个文档中。这使得稍后引用可视化变得容易，而不必重新运行整个笔记本。

这是一些用散景增强数据可视化的方法！所有的例子，包括代码和数据集，都可以在这里找到。

Payal 是 IBM 的一名数据科学家。在业余时间，她喜欢阅读、旅游和写作。如果你喜欢她的作品， 关注或订阅 她的列表，不要错过一个故事！

以上文章是个人观点，不代表 IBM 的立场、策略或观点。

参考文献

[1]: Larxel。"巧克力分级"卡格尔，https://www.kaggle.com/datasets/andrewmvd/chocolate-ratings2022 年 12 月 8 日访问。(CC0:公共领域许可证)

[2]:沙哈内，绍拉布。"数据科学工作薪水数据集." Kaggle ，www . ka ggle . com/datasets/saurabhshahane/data-science-jobs-salary2022 年 12 月 8 日访问。(CC0:公共领域许可证)

【3】:阿瑞斯。"加州野火(2013 年至 2020 年)." Kaggle ，https://www . ka ggle . com/datasets/ananthu 017/California-wild fire-incidents-2013 20202022 年 12 月 8 日访问。(CC0:公共领域许可证)

[4]:肖汉，阿满。"学生在考试中的表现." Kaggle ，https://www . ka ggle . com/datasets/whenamancodes/students-performance-in-examings2022 年 12 月 8 日访问。(CC0:公共领域许可证)

为视觉相似性建立强大的深度学*模型的 8 个技巧

原文：https://towardsdatascience.com/8-tips-to-build-powerful-deep-learning-models-for-visual-similarity-738eb6f69275

3 个月浓缩的一般最佳实践，使您的暹罗网络表现良好，并产生高质量的嵌入

哈维·卡夫雷拉在 Unsplash 上的照片

答不久前，我参加了前公司举办的数据科学挑战赛。目的是帮助海洋研究人员更好地根据鲸鱼的吸虫外观来识别鲸鱼。

更具体地说，我们被要求为测试集的每个图像预测来自完整数据库(训练+测试)的前 20 个最相似的图像。

这不是一个标准的分类任务。

我花了 3 个月的时间做原型，最终在最终(私人)排行榜的 300 名参与者中名列第三。

对于这个故事，宙斯是我家的 GPU 驱动的服务器。没错，它有名字。

决赛(私人)排行榜

但是让我们不要进入这个挑战的细节。

这篇帖子的目的是和大家分享 我的关于构建视觉相似性任务强嵌入模型的小技巧 。这次挑战是一次极好的学*机会，我尝试了许多不同的技术。因此，我将在这里与大家分享什么是最有效的，什么是无效的，我将详细说明我在这个过程中采取的不同步骤。

事不宜迟，让我们来看看🔍

PS:以下实验的代码在我的 Githubrepo上。

1 —将问题形式化，选择正确的损失？

我首先问自己的潜在问题是:我如何构建一个可以有效嵌入其特征并用于相似性任务的鲸鱼爪的数字表示？

我们的目标是构建一个模型，生成输入图像的“良好”表示:作者的一张鲸鱼的图片

第一种方法:分类

我最初采用的天真方法是训练一个卷积神经网络(CNN ),使用标准的 softmax 交叉熵损失对图像的标签集(鲸鱼 id)进行分类，然后将最后一个完全连接的层的输出作为嵌入。不幸的是，训练网络来优化交叉熵并不能产生良好的相似性嵌入向量。 在这个问题中效率不是很高的原因是交叉熵只学*如何将图像映射到标签，而不学*输入之间的相对距离(或相似度)。

当你需要嵌入视觉相似性任务时，你的网络应该在训练时明确地学*如何在彼此之间比较和排列项目。如果你想了解更多，我推荐这篇帖子。

从分类到度量学*

学*相互比较和排列输入的有效嵌入的任务被称为 度量学* 。 这是一个经过充分研究的课题，已经应用于人脸识别或图像检索等热门应用中。
我不会在这篇文章中讨论什么是度量学*。有很好的教程解释的很好这里和这里。

我将介绍我在这次挑战中试验的两个损失函数。

• 三重损失
• 弧面损失

1.三重损失

2015 年，谷歌在 FaceNet 论文中介绍了三重态损失。
作者通过设计一个系统来探索人脸嵌入的新技术，该系统学*从人脸图像到紧致欧氏空间的映射，其中距离直接对应于人脸相似性的度量。
提出的方法优化了嵌入本身，而不是没有明确解决问题的中间损失。

来源:https://omoindrot.github.io/triplet-loss

这种损失由三组数据定义:

• 代表引用的锚图像
• 与主播同级的正面形象
• 不同类别的负像

并且以这样的方式优化模型的权重:

• 锚的嵌入和正图像的嵌入之间的欧几里德距离，即 d(a，p)很低
• 锚的嵌入和负像的嵌入之间的欧几里德距离，即 d(a，n)很高

三重态损失可以形式化为:

L = max(d(a，p) — d(a，n) + margin，0)

根据定义，这种损失的下限为 0。所以优化网络会尽可能把它推向 0。培训完成后:

• d(a，p)变得很小~0
• d(a，n)大于 d(a，p) +余量

我用了一些训练技巧来提高三连音缺失训练:

• 硬采样:我使用硬三连音只是为了优化损失。
  一个硬三元组(A，p，n)满足这个不等式:d(a，n) < d(a，p)
• PK 采样:我在我的 PyTorch 数据加载器中使用了一个采样器来确保每一批都是 PK 大小的，由 P 个不同的类组成，每个类有 K 个图像。
• 在线生成三胞胎

你可以在我的 Github repo 上找到这些技巧的实现细节，如果你想了解更多这些技术，我推荐你阅读这篇论文。

2.弧形面

我在挑战结束前三周遇到了这种失败，在我尝试的那一刻，我就被它的有效性震惊了。

ArcFace loss 已于 2019 年(CVPR)推出，其主要目标是通过学*用于人脸识别的高区分度特征来最大化人脸类别的可分性。根据该论文的作者，该方法在最常见的人脸识别基准上优于三重损失、内损失和间损失。

来源:ArcFace 论文

当给定从网络中提取的特征向量和相应的地面真实值(在本例中为鲸鱼 id)时，arcface 会学*一个权重矩阵来将计算映射到一个新的空间，在该空间中计算特征和目标之间的角度。因此，这个空间有一个几何解释。
然后给这个角度增加一个余量，回复到原来的空间，应用交叉熵 softmax loss。这种损失的主要好处是过渡到一个新的空间，在那里分离性被最大化。尽管如此，ArcFace 与 softmax 交叉熵损失并无不同，因此训练开销很小。

来源:ArcFace 论文

当我用 ArcFace 做实验时，我注意到三重态损失的一些好处:

• ArcFace 可以很好地适应大量的类
• 它减轻了在训练三重损失时遇到的硬样本挖掘的问题(因为它不需要一个)。它需要的只是数据和相应的标签。
• 它提供了一个很好的几何解释
• 它提供了稳定的训练
• 它收敛得更快
• 最重要的是，用这种损失训练的单个模型比用三重损失训练的五个模型的混合模型表现得更好。

这就是为什么我在最终提交的作品中使用了它。

ArcFace 是我的解决方案的基石。现在，让我们来看看帮助我有效设置培训的不同步骤。

2-成为数据🗂的一员

这是不言而喻的，但我还是要说:花尽可能多的时间检查你的数据。无论你是在计算机视觉还是 NLP 领域工作，深度学*模型，就像任何其他模型一样，都是垃圾进垃圾出。不管它有多少深层。如果你给它提供质量差的数据，你就不要指望有好的结果。

我对这个挑战的数据做了几件事(这个过程显然适用于度量学*任务中的任何数据集):

• 我去掉了那些分辨率很低或者根本看不到鲸爪的嘈杂和混乱的图像
• 我丢弃了只有一个图像的类:这被证明是非常有效的。这背后的原因是度量学*任务需要一点关于每个类的上下文:每个类一个图像显然是不够的。
• 我提取了鲸鱼尾巴的包围盒，以便丢弃任何周围的噪音(水溅声、海浪声)并放大相关信息。这后来作为一个注意机制。
  为了做到这一点，我在 makesense.ai 上标注了大约 300 头福禄克鲸后，从头开始训练了 Yolo-V3 福禄克探测器，make sense . ai 是由 Piotr Skalski 构建的图像标记工具。
  我还用这个优秀的 repo 训练了 Yolo-V3 模型。

作者截图

按键学*👨‍🏫 : 与复杂的建模相比，适当清理数据可能会让你赢得更多分数。

3 —不要低估迁移学*的力量🔄

在比赛的前几周，我使用了 ImageNet 预训练模型(renset34、densenet121 等。)作为骨干。还好，我的模型在一段时间后收敛了。

然后我调查了 Kaggle 座头鲸识别比赛数据。

• 尽管有排行榜指标，但这场比赛与我们的挑战非常相似
• 这些数据和我们的结构一样，有着同样的阶级不平衡问题
• 这些吸虫和我们的竞争对手看起来不太一样。他们来自另一个物种——但这没什么。

卡格尔鲸的侥幸——来源:卡格尔

我立即决定使用三重损失对 ImageNet 预训练模型进行微调。

事情的发展很有趣:

• 这产生了巨大的影响！我在排行榜上跳了起来
• 网络能够更快地聚合(在 30%的时间内)

主要收获👨‍🏫 :

• 迁移学*很少会有伤害。如果你从预先训练了 1000 个普通物体(动物、汽车等)的 ImageNet 模型开始。)，更有可能的是，在你的类似数据集上的预训练网络更好。
• 迁移学*是一种间接的方式，可以给你的培训带来更多的数据

4-输入形状非常重要📏📐 🔍

关于这项挑战的数据，有一个重要的细节值得一提:它的高分辨率。由于专业设备，部分图像达到 3000x1200 像素甚至更高。

当我开始比赛时，我将我的网络的输入大小设置为 224x224 像素，就像我在大多数图像分类问题中通常做的那样。

然而，当我开始改变输入大小时，我的性能得到了提升。480x480 是最适合我的输入图形。

主要学*内容👨‍🏫 :

• 如果您正在处理高分辨率图像，请尝试增加网络的输入大小。ImageNet 推荐的默认 224x224 输入形状并不总是最佳选择。有了更大的输入形状，你的网络可以学*具体的小细节来区分不同的鲸鱼。
• 越大不一定越好。如果您将输入形状增加到 1000 像素左右，您很可能会遇到以下两个问题:

1. 慢速训练:随着输入形状的增加，你的网络有更多的参数，这显然需要更多的计算能力，并且由于过度拟合也不能保证收敛。
2. 小图像性能差:当微小图像被上采样到 1000x1000px 分辨率时，原始信号被破坏。

5 —复杂的架构不一定是最佳选择🤹

如果你对计算机视觉生态系统有点熟悉，你可能听说过一些流行的架构，如 VGG 或 ResNet，或者不太可能听说过最*的复杂架构，如 ResNet-Inception-V4 或 NASNet。

代表性深度神经网络架构的基准分析:论文

以下是项重要学*👨‍🏫经过三个月的实验，我终于明白了:

• 大而深的最先进的主干并不总是最佳的选择:如果你的数据集很小(就像这次挑战中的那个)，它们很快就会过度适应，如果你的计算资源很少，你就无法训练它们
• 好的方法是从简单的网络开始，逐步增加复杂性，同时监控验证数据集的性能
• 如果您计划在 web 应用程序中发布您的解决方案，您必须考虑模型大小、内存消耗、推理时间等。

6 —设计稳健的管道⚙

我制定的培训计划包括 5 个主要步骤:

培训管道—来源:我的 Github 回购

• 第一步:dataloder 连接到数据库，批量向网络提供图像和相应的标签。它还负责在不同时期之间调整数据，并应用动态数据增强。
  重度增强已作为正则化效果应用于更好的泛化。变换包括:高斯噪声和模糊、运动模糊、随机雨(模拟飞溅效果)、颜色偏移、亮度、色调和饱和度的随机变化、锐化、透视的随机变化、弹性变换、随机旋转、仿射变换(平移和剪切)和随机遮挡(增加概括能力)
• 第二步:向前传球。该模型将图像作为输入并生成特征。
• 步骤 3 :计算特征和目标之间的弧面损失
• 第四步:反向传播。计算损耗 w.r.t .模型参数的梯度
• 步骤 5:Adam 优化器使用损失的梯度更新权重。该操作在每个批次上执行。

7 —顶级教练的一般训练技巧👨‍🏫

在这次比赛中，我做了很多实验。以下是我列出的让训练安全、可重复、稳健的建议。

• 固定种子以确保再现性。您很可能必须在脚本的开头编写这几行代码

更多详情此处。

• 亚当是一个安全的优化器。但是，您不应该忘记将重量衰减设置为非零值。这起到了规则化的作用，防止了损耗波动。使用值:1e-3
• 大幅增强确实提高了结果。我从简单的旋转和平移开始，但是当我添加上面提到的转换时，我得到了更好的结果。扩充缓解了数据缺乏的问题，提高了模型的稳定性和泛化能力。为了建立一个有效的增强管道，我强烈推荐白蛋白库。
• 使用学*率计划程序来降低整个培训过程中的学*率。这防止损失停留在局部最小值。
  我最终选择的是一个预热调度程序，后面是余弦退火。
  它基本上从一个小的学*速率开始，在几个时期内达到目标值(开始学*速率)(这被称为预热阶段),然后按照余弦退火法降低学*速率，直到结束学*速率。
  预热阶段起到了调整作用，以防止早期过度拟合。

来源:researchgate.ne

• 在每个时期结束时监控损失值和其他指标。我用 Tensorbaord 画的。
• 伪标签可以给你一个优势:这种技术常用于 Kaggle 比赛。它包括根据您的训练数据训练一个模型，使用它对测试数据进行预测，获得最有信心的预测(> 0.9 的概率)，将它们添加到原始训练数据中，然后再次重新训练。
• 确保你有合适的硬件。我可以使用一台 11Gb GPU 内存和 64GB RAM 的 GPU 服务器。在软件方面，我使用的是带有 PyTorch 1.1.0 和 torchvision 0.3.0 的 conda 虚拟环境。
  在 480px 分辨率的图像上用 ArcFace loss 训练 Densenet121 主干每个历元大约需要 1 分钟。收敛大约是 90 个纪元。
• 通过记录您的模型来记录您的体验，并在培训结束时或培训期间保存它们。你会在我的 Github repo 中发现这是如何做到的。

8-分而治之:将多个模型组合成一个最终提交⚡

我使用之前的管道和以下参数训练了两个模型:

Github 回购

让我在最终得分中占据优势的是我将它们组合在一起的方式。这是一个简单的元嵌入技术，在自然语言处理中非常常用。

它包括在所有样本上生成每个模型的嵌入，然后连接它们。

元嵌入模型——作者的图像

该方法用于生成训练和测试数据集的元嵌入。然后，使用相同的计算来生成提交。

按键学*👨‍🏫：

• 当基础模型在主干架构(resnet34 与 densenet121)、图像输入大小(480 与 620)、正则化方案(丢失与不丢失)方面不同时，元嵌入级联技术提供了有趣的嵌入
• 每个单独的基础模型“看到”不同的东西:组合它们的嵌入产生一个新的混合模型，具有增强的表示能力。

最后的话🙏

我要感谢整个 GDSC 团队，感谢他们把这次挑战变成了一次很好的学*机会，感谢 Lisa Steiner 给了我们把知识应用到新领域的机会。

我希望你能在这里找到可以在其他计算机视觉和深度学*项目中使用的资源。

参考📜

• face net:【https://arxiv.org/pdf/1503.03832.pdf】T4
• 为三重失认人辩护:https://arxiv.org/pdf/1703.07737.pdf
• 排名损失、对比损失、差额损失、三联损失、铰链损失:https://gombru.github.io/2019/04/03/ranking_loss/
• 三重缺失:https://omoindrot.github.io/triplet-loss
• ArcFace 论文:https://arxiv.org/pdf/1801.07698.pdf
• 解释 arc face loss:https://medium . com/1-minute-papers/arc face-additive-angular-margin-loss-for-deep-face-recognition-d 02297605 f8d

新到中？你可以每月订阅 5 美元，并解锁各种主题的无限文章(技术、设计、创业……)你可以通过点击我的推荐链接来支持我

https://ahmedbesbes.medium.com/membership

由 Unsplash 上的 Karsten Winegeart 拍摄

8 用 Python 处理多个时间序列数据的可视化

原文：https://towardsdatascience.com/8-visualizations-with-python-to-handle-multiple-time-series-data-19b5b2e66dd0

避免多时间序列图中重叠线条的可视化想法

朱莉安娜在 Unsplash 拍摄的照片

奇异博士，一个虚构的角色，是我最喜欢的超级英雄。他令人难以置信的能力之一是预见事件的可能性。如果我能像他一样同时看到很多东西，那该多好。事实上，我不需要任何超能力也能做到。只要一个正确的可视化和 Python 类型就足够了。

多重时间序列数据

单线时间序列图有助于用长序列表示数据。它由代表时间线的 X 轴和显示值的 Y 轴组成。这是一个标准的方法，因为这个概念简单易懂。该图可以帮助我们提取一些洞察信息，如趋势和季节效应。

然而，多时间序列图上的多条线会使事情变得困难。让我们考虑下面的例子。

第一张图:多时间序列线图显示 2019 年首尔 25 个区的 PM2.5。第二张图片:径向图中的相同数据集。首尔的空气污染来自 Kaggle 的数据。作者图片。

这似乎有些夸张，但有时可能会遇到这种数据，如下图所示。第一张图字里行间很难分辨，很难读懂。对于相同的数据集，第二张图中的径向图有助于处理重叠图，这将在本文中作为一个想法进行解释。

本文将使用 Python 代码演示 8 种可视化思想，以应对绘制多个时序数据时的混乱。让我们开始吧。

检索数据

为了处理一个真实的案例，我将使用 Kaggle( 链接)的首尔数据集中的空气污染。数据由首尔市政府提供。它是关于 2017 年至 2019 年期间来自韩国首都首尔 25 个区的空气污染信息，包括 SO2、NO2、CO、O3、PM10 和 PM2.5。

本文以 25 个地区的 PM2.5 为主要变量，绘制成多条时间序列线。PM2.5 被定义为直径小于 2.5 米的细小颗粒物质。它被认为是一种导致短期健康影响的污染。

从许多位置可视化 PM2.5 有助于比较污染如何影响城市。

输入数据

从导入库开始。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import matplotlib.ticker as ticker

和熊猫一起读 Measurement_summary.csv。

df = pd.read_csv('<file locaion>/Measurement_summary.csv')
df.head()

浏览数据

现在我们已经导入了数据集。继续检查每个列的缺失值和数据类型。

df.info()

好消息是没有丢失值。下一步是检查不同站点代码的数量。

df['Station code'].nunique()###output:
###25

总共有 25 个站。检查车站代码。

list_scode = list(set(df['Station code']))
list_scode###output:
### [101, 102, 103, 104, ..., 125]

预处理数据

从 101 到 125，车站代码代表首尔的区。就个人而言，使用地区名称更便于标记可视化，因为它更便于阅读。将从“地址”列中提取姓名以创建“地区”列。

list_add = list(df['Address'])
District = [i.split(', ')[2] for i in list_add]df['District'] = District

创建一个包含 25 个地区名称的列表供以后使用。

list_district = list(set(District))

准备另外三列，YM(年月)、年和月，以应用一些图表。为了更容易形象化，我们将他们分组为平均每月数据框架。

绘图数据

现在一切都准备好了，让我们做多重时间序列图。

多时间序列线图显示了 2017 年至 2019 年首尔 25 个区的月平均 PM2.5。图片由作者提供。

重叠的线条很难辨认。2017 年可以看到很多站的 PM2.5 量都是同向的。但 2018 年和 2019 年，污染线肆意而为，难以分辨。

可视化想法

本文的主要目的是用 Python 的一些可视化思想来指导处理多个时间序列数据。

在继续之前，我需要澄清一些事情。正如我们已经看到的，本文中推荐的可视化主要用于处理重叠图，因为这是绘制多个时间序列数据的主要问题。

每张图都有它的优点和缺点。显然，没有什么是完美的。有些可能只是为了一个吸引眼球的效果。但是它们都有相同的目的，在类别之间比较序列。

1.什么都不改变，只是让剧情互动起来。

Plotly 是一个用于制作交互式图形的图形库。交互式图表有助于放大具有重叠线条的区域。

使用plottly创建交互式多时序线图的结果。作者图片。

使用 Plotly，还可以制作交互式面积图。

用颜色填充线条下的区域。图片由作者提供。

2.与多个小时间序列逐一比较。

有了 Seaborn 库，我们可以做小倍数的时间序列。这些图背后的想法是一条一条地绘制每条线，同时仍然将它们与其他线的轮廓进行比较。官网链接上的代码是这里是。

小型多重时间序列图的一部分。作者图片。

3.使用小平面网格更改视点

Seaborn 的 FacetGrid 可以用来制作多点网格。在这种情况下,“月”和“年”属性分别设置为行和列。从另一个角度来看，这些值可以同时进行纵向的月度比较和横向的年度比较。

小平面网格图的一部分。作者图片。

4.在热图中使用颜色

热图将数据表示成二维图表，用颜色显示数值。为了处理时间序列数据，我们可以在垂直维度上设置组，在水平维度上设置时间轴。颜色的不同有助于区分不同的群体。

旋转数据框

热图显示了 2017 年至 2019 年首尔 25 个区的月平均 PM2.5。图片由作者提供。

5.在雷达图中应用角度

我们可以在 Plotly 中设置散点图的角轴，以创建一个交互式雷达图。每个月将被选为圆上的一个变量。比如在本文中，我们会创建一个雷达图，对比 25 个区 2019 年的月均 PM2.5。

仅使用 2019 年的数据过滤数据框

df_19 = df_monthly[df_monthly['Year']=='2019']

创建雷达图。使用 Plotly 的一个好处是雷达图是交互式的。所以我们可以很容易地过滤图表。

使用 Plotly 创建交互式雷达图的结果。作者图片。

让我们更进一步，逐一填充每个不同的雷达区域，并将每个区域与其他区域进行比较。然后创建一个照片拼贴。

定义一个函数来创建一个照片拼贴。我发现了一个很好的方法，可以在栈溢出时组合这个链接中的图。

使用该功能

瞧啊。！…

照片拼贴画中的一些雷达图。作者图片。

6.喜欢圆形条形图的条形图(跑道图)

圆形条形图(又名赛道图)的概念非常简单，因为它只是一个圆圈中的条形图。我们可以按月绘制圆形条形图，然后制作照片拼贴，沿着时间对比过程。

下图显示了我们将要创建的圆形条形图的示例。这个图表的缺点是很难在类别之间进行比较。对了，用吸睛的效果来获得关注是个不错的选择。

圆形条形图，图片由作者提供。

定义一个函数来创建圆形条形图

应用该功能

创建照片拼贴

圆形条形图显示了 2017 年至 2019 年首尔 25 个区的每月 PM2.5。作者图片。

7。从中心开始绘制径向图

像圆形条形图一样，径向图基于使用极坐标而非笛卡尔坐标的条形图。当比较相距较远的类别时，这种图表类型很不方便，但它是引起注意的绝佳选择。它可以用在信息图表中。

下图显示了 2019 年 1 月 25 个区的平均 PM2.5 的径向图示例。

放射状的情节，图片由作者提供。

应用该功能

创建照片拼贴

辐射图显示了 2017 年至 2019 年首尔 25 个区的每月 PM2.5。作者图片。

8.显示具有重叠密度的密度(山脊图)

通过将轴设置为时间轴，重叠密度(山脊图)可用于多个时间序列数据。像圆形条形图和放射状图一样，山脊图更能引起人们的注意。Seaborn 官网上的代码是这里是。

下图显示了 2019 年某区 PM2.5 密度的山脊图示例。

重叠密度(山脊图)，图片由作者提供。

定义用于创建山脊图的函数

应用该功能

创建照片拼贴

照片拼贴画中的一些山脊图。作者图片。

摘要

本文展示了一些可视化的 Python 代码示例，用于处理多时间序列图中的重叠线。两个主要的概念是使用交互式的情节和分离他们。交互式图表有助于允许用户自由选择类别的选项，而分隔图表有助于用户轻松比较它们。

这些只是一些想法。我确信，除了本文中提到的图表，还有更多处理多个时间序列数据的可视化方法。如果您有任何问题或建议，请随时留下评论。感谢阅读。

这些是关于数据可视化的其他文章，您可能会感兴趣。

• 用 Python 可视化光速(链接)
• 用 NASA 数据和 Python ( 链接)可视化看不见的二氧化硫
• 用 Python 分 4 步进行图像颜色提取(链接)

参考

• 首尔市政府。(2021 年 5 月)。韩国首尔的空气污染测量信息。2022 年 4 月 24 日检索自https://www . ka ggle . com/datasets/bappekim/air-pollution-in-Seoul
• 作者:Plotly Technologies Inc .书名:协作数据科学出版社:Plotly Technologies Inc .出版地点:马萨诸塞州蒙特利尔出版日期:2015 URL: https://plot.ly

进入法昂需要 80 天

原文：https://towardsdatascience.com/80-days-to-get-into-faang-5c77f27d5224

我是如何在有限的准备时间内征服技术面试的

图片由凯利·西克玛在 Unsplash 上拍摄

临* 2021 年底，我在考虑找份新工作。我曾计划在发出申请之前，花至少六个月的时间来更新我的数据结构和算法(DSA)知识。具有讽刺意味的是，在我开始这个计划的 2 周后，FAANG 的一名招聘人员向我提供了一个机器学*的机会。

经过“仔细”的考虑，我决定继续面试，同时尽可能多地从 LeetCode(一个练* DSA 的在线平台)中学*。在我看来，这只是一个获得更多面试经验的机会。我从来没有想过我会在所有的技术回合中表现出色。我不知道，在我最初计划的 80 天后，我会收到他们的邀请。

我在 LeetCode 上的提交历史，当时我得到了 offer。

这篇文章将总结我的旅程。更重要的是，它将概述和解决我的主要准备工作，日常事务，斗争，以及我如何克服这些。我将主要关注技术面试。我希望这将有助于任何有抱负的 SWE/MLE 寻找下一个大的飞跃。

请注意，系统设计、ML 设计和行为面试同等重要(如果不是更重要的话)，你也应该花大量的时间来准备它们。在上图中，较浅绿色的日子是我花额外时间学*非编码的日子。

目录

∘ 1。最重要的事情∘2。主要对手
∘ 3。资源
∘ 4。结论

1。最重要的事情

就是要有计划。并坚持下去。

破解技术面试的旅程是一场马拉松。事情在变得容易之前会变得困难。很有可能你需要至少六个月的持续训练和准备，然后才能开始适应处理更难的问题和面试。因此，制定一个计划并坚持下去是非常重要的。一个设计良好的计划会给你一个清晰的行动项目和进展路线图。这也能让你避免拖延或偏离轨道。

我最初的 6 个月计划是这样的:

• 每天花 30 分钟回顾关键概念，直到感觉舒服为止；
• 在 LeetCode 上做 50-100 道简单题；
• 然后做 50-100 个中等题；
• 然后开始做难题，参加竞赛。

(注意，我的计划中没有时间表。我相信设定目标并真正完成和理解每一步比给自己一个 X 周的期限来完成 Y 个问题更有帮助。)

因为我决定用很少的时间来完成面试，所以我修改了计划:

(“996”在中国是一种流行的工作时间表，员工被要求一周工作 6 天，早上 9 点到晚上 9 点。在这里，997 只是 996 + 1 额外的一天:我每天学* 12 个小时，每周 7 天。)

换句话说，我醒着的大部分时间都在为面试做准备(好像我没有选择)。此时我也有一份全职工作。但是一两年后，你的工作效率会变得非常高，并且可以在不到三个小时内完成大部分日常任务。

我不会建议任何人尝试这个计划。就我个人而言，我发现自己非常幸运能够做到这一点。但是我再也不会尝试了。这肯定会让你筋疲力尽。赢得比赛的关键是一致性。

2.主要对手

我最努力的是保持自律和相信自己。然而，我发现在技术面试准备中，精神挑战通常不会被公开讨论(或者根本不会)。如果你在学*中遇到这些问题，要知道你并不孤单，你有能力克服它们。

• 冒名顶替综合征:

一路走来，你可能会发现只是要学的东西太多，概念太抽象，或者问题太难。

有这种感觉是完全正常的。但是，请记住，这座知识之山是要经过很长一段时间才能被征服的，无论谁想要获得它，都必须经历一个类似的过程。如果你读这篇文章是为了寻找旅途的动力或建议，我想说你已经在精神上有了一个很好的开始。

听起来可能很老套，但如果你打算在 6 个月内每天只提高 1%的话，这里有一个结果:

也就是说，你会比现在好 6 倍。

最后，如果事情仍然难以承受，我的建议是定期休息，并着眼于更长的时间，比如 1-2 年。

• 邓宁-克鲁格效应；

图片来自维基百科

感觉不知所措很容易，说服自己已经知道如何解决问题也同样容易。毕竟，LeetCode 的目标只是得到一个可接受的解决方案。

有些问题我会纠结很多，然后我会看提示，论坛，我会告诉自己我知道如何解决它们。但当我一周后遇到同样的问题时，我的大脑会一片空白。

这里只有一个解决办法，那就是对自己诚实。对于那些我仍然需要参考提示和讨论论坛的问题，我会在个人清单中跟踪它们，并在一周后重新访问它们。

• 缺乏动力:

这也许是我们所有人面临的最大挑战。从日常事务中走出来，踏上一段需要长时间太多努力的旅程，并不容易。我强烈建议你找一个动力的来源来帮助引导你完成这个过程。问问自己:为什么要做这一跳？金钱是唯一的驱动力吗？如果是的话，保持这种决心可能会很有挑战性。

有一个支持的来源也同样重要。可能是任何人:你的朋友，你爱的人，甚至你的论坛用户。有人谈论你的进步和奋斗是非常宝贵的。如果你有一个朋友一起训练和准备，你会发现这个过程非常愉快。

也就是说，如果你能坚持每天至少学*一个小时，坚持至少 8 周，你会发现动力和支持不再是问题。至此，学*已经成为一种*惯，成为你一天中半潜意识的一部分。无论你决定做什么，这个*惯都将是你未来成功的重要因素。甚至在我拿到 offer 之后，我还是刻意的试图保持这个*惯。在我不能研究任何问题的日子里，我会有一种“学*退缩”的感觉。这对你的健康有害，所以不要停止学*。

3。资源

现在，有很多免费的资源可以用来学* DSA。你可能会找到比我列出的更好的资源，那就更好了。以下是帮助我开始的资源摘要:

• 基本概念:维基+ YouTube 视频。
• 对于算法:麻省理工学院 6.006:算法简介。对于一个技术面试来说，有些讲座太多了，所以只看那些你觉得相关的:二分搜索法、西普、BFS、DFS、DP……我从这门课上学到了大部分图形知识，我为 BFS 编写的代码风格几乎与这些讲座中介绍的伪代码完全相同。
• [你的语言]中的编程面试元素:这本书非常有帮助，有很多很好的提示和解释。这本书里有很多你在别处找不到的见解(例如，位操作对我来说一直是一个很难的话题，但这本书让它变得容易理解得多)。平装书的另一大好处是你可以在任何地方阅读。
• LeetCode 讨论:如果你是 DSA 新手，讨论部分可能会很吓人。顶级解决方案有时会非常复杂。尽管如此，还是有一些非常好的帖子有非常详细的解释。花点时间阅读这些，确保你理解了。对我来说，这是唯一最重要的知识来源。
• LeetCode Premium:我发现免费讨论已经足够有帮助了。然而，如果你想真正关注一两家特定的公司，或者看看锁定的问题，你可以使用 Premium。也就是说，出于额外的预防措施，我确实购买了两个月的保费。
• 对于系统设计和 ML 设计面试:这本身就是一个巨大的话题。在这篇文章中，我将重点讨论技术面试。

4。结论

征服 FAANG 面试是一个漫长的旅程。然而，我相信付出的努力是值得的。从大的方面来看，你将花费 6 个月到 1 年的时间来显著地改善你未来的职业生涯，这很可能是 30 年或更长。换句话说，越早开始，投资回报越好。(并不是说如果你开始的太晚，那就不要打扰。不管怎样，这仍然是一项伟大的投资。)

在旅程的最后，你可能会发现 DSA 很有趣。我知道我做到了，这已经成为我日常娱乐的一部分。既然找工作的压力已经消除，我发现自己期待着每周的比赛，作为工作周的一个休息。

写这篇文章时，我在 LeetCode 上的提交历史。

在这篇文章中，我概述了处理编码面试的主要资源和障碍，以及我如何克服它们。希望这将有助于你自己的冒险，并祝你未来的职业生涯好运！

如果你愿意支持 Thu，你可以考虑注册成为一名中等会员。每月支付 5 美元，你就可以无限制地阅读媒体上的故事。如果你使用他的推荐链接，Thu 也会得到一小笔佣金。

https://medium.com/@tdinh15/membership

改进数据可视化游戏的 9 种可行方法

原文：https://towardsdatascience.com/9-actionable-ways-to-improve-your-data-visualization-game-384923e54044

图文并茂

亚历山大·辛恩在 Unsplash 上的照片

有一句来自 Patrick Winston 的名言:

你在生活中的成功很大程度上取决于你的说话能力、写作能力和想法的质量，按此顺序排列”

虽然他没有明确地说数据可视化，我谦恭地相信他会同意我们绘制数据的能力属于写作范畴。而且，就像写作一样，有很多陷阱，我们都很容易陷入其中，除非我们事先很好地意识到它们。

在本文中，我总结了多年来我在如何提高数据可视化技能方面获得的一些主要见解。这些大致分为两类:我们应该经常做的事情和如何更好地交流想法。正如在我的大多数文章中一样，我试图给你尽可能多的可行的建议。到本文结束时，您应该已经掌握了一些新的技巧和一些新的资源来获得灵感。

#1 解释一切

一个好的情节最重要的方面是自成一体。它应该表明它显示什么(标题)，它的轴代表什么(轴标签)，使用的测量单位，它覆盖的数值范围，以及它有什么系列。换句话说，你的情节应该能够独立存在，不需要其他任何东西。你唯一的退路应该是情节的标题。

最糟糕的阅读经历之一是在浏览一篇文章时发现一个看起来很棒的情节，然后发现如果不阅读整篇文章你就无法理解它所表达的内容。它充满了缩写和自定义符号。虽然你可能认为这可能会让人们阅读你的作品，但这更有可能让他们关闭它，继续下一个。

快速检查表:你的图有标题，每个轴有标签，数值范围清晰，有网格(或者暗示)，数列命名恰当。任何其他添加也应该清楚。例如，如果你要做对数图，确保这很容易被注意到。

这是一个本可以更好的情节:

图片由作者

这里的主要问题不是情节本身，而是没有被它解释的信息量。请注意需要在标题上放置多少信息来填补所有的空白。例如，色带可以指示阴影与采样密度相关。

图片由作者

来自同样的作品，这里有一个好得多的情节。X 轴显示三个设置(自由落体、布朗运动和重力)，每个设置都有三个子设置(仅 SAP、仅 KD 和 KD + SAP)和三个系列(单一、SSE 和 AVX)。Y 轴代表时间，由于我们熟悉 10 的幂，可以看到它是用对数绘制的。

多做一点:蛋糕上的樱桃是每一格顶端的数字。大多数人很难理解对数图的数字含义。我们可以同时传达指数级的速度提升，同时通过显示实际数字呈现直观的结果视图。通常很难在不造成视觉污染的情况下显示每个数据点背后的数字。然而，只要有可能，请去做。尤其是在处理对数标度这样的事情时。

#2 框定您的数据

视觉上，每个情节都应该表明一切，并且足够全面，以便观众能够理解所代表的数值。这意味着在数据周围有一些网格和清晰框架的暗示。时刻提醒自己，剧情是视觉表，不是画面。你不会弄脏桌子的，对吧？不要让数字难以看清。

先说一个不好的例子:

图片由作者

我们只知道这里有一堆曲线。有的超过 100 个，剧情到 32000 个对象结束。我们可以相互比较数列，但我们没有真正的数字意义——除非你拿起尺子和铅笔来勾画一些参考值。现在考虑以下情况:

图片由作者

这一次，我们不需要一把尺子来看黑色曲线在< 20, the green one ends almost at 40, etc. The added markings and the subtle grid make all the difference. One could write a relatively accurate table out of this visualization without the need for a ruler or some other device.

处的结束，多走一步:在图中添加框架和箭头会非常有效。这个想法是引导你的观众走向本质。当可视化复杂或有噪声时，这些添加可能很重要。这里有一个例子:

图片由作者

#3 使用多种工具

看上面的情节。当我们需要向绘图添加框、文本和箭头时，使用 Matplotlib 这样的工具可能会令人望而生畏。获得正确的定位是一件痛苦的事情，每当你需要重新定位东西的时候，你总是需要做一些反复试验的工作。当我们试图找到更好的字体大小或颜色时也是如此——无休止的猜测循环。

更好的方法是将内容导出到另一个应用程序。我最引以为豪的大部分情节都是通过几个工具和少量的图像编辑完成的。例如，使用 PowerPoint 或幻灯片添加箭头和方框要比在绘图库中或通过 Excel 容易得多。你也可以使用免费的工具来试颜色，比如 Paint.Net 的和它的滤镜，比如色调-饱和度和亮度-对比度。

更进一步:大多数绘图包导出到 SVG 。因此，你可以使用利用这种格式的 Inkscape 和 Adobe Illustrator 工具轻松修改任何内容。另外，SVG 是一种基于 XML 的文件格式，因此您可以在 VS Code 上打开它，并通过使用查找和替换工具来做一些事情，例如大量的颜色更改。

LaTeX 提示: LaTeX 不支持 SVG。但是，您可以将 SVG 文件转换为 PDF，并将其作为图像包含在内，以实现矢量质量可视化。

#4 使用一致的尺度

在我继续之前，看看这三个情节。它们展示了两个过程的演变。曲线越低越好。在这种情况下，以下哪一项取得了最佳效果？

图片由作者提供。

如果你说中间的蓝色曲线，你是…不对对吗？

问题是这些都是相同的曲线。图与图之间变化的是 Y 轴刻度。一个从 0 到 1，第二个从 0.085 到 1.285，第三个从 0 到 0.5。从某种意义上说，这些只是相同曲线的不同缩放。下面是我们为所有三幅图设置相同范围时它们的样子:

图片由作者提供。每个图使用相同的 Y 轴设置。

特别是当你使用多张图比较同一问题的几种方法时，一定要确保它们使用相同的观察尺度。再者，使用合理的尺度。例如，如果你的数据是一个百分比，坚持 0-100 的范围。如果一个变量的范围只能是 1 到 2，那么就使用它。

在这种情况下，恶意的策划者喜欢利用这个“小错误”来故意改变我们对数据的看法。例如，考虑下面的三幅图。左边，我们有原始数据；在中心位置，我们有一个精心选择的比例，使蓝色的方法看起来比橙色的曲线好得多；在右边，轴范围使它看起来像两种方法收敛到相同的值。千万不要这样。

图片由作者提供。极其恶意的 Y 轴设置。

这里有另一个例子，说明秤是如何被用来有意误导人们的。在下面的图表中，这家虚构的公司增长了 1.1%，然后是 1.2%和 1.5%。增长率相对适中，但可视化使公司看起来像是呈指数增长——甚至有一个箭头！

更进一步:这里有两篇很棒的文章展示了恶意行为者如何利用数据可视化撒谎。如何用图表撒谎和误导统计。两部作品都有真实的情节，展示了这些战术在实践中是如何运用的。确保你永远不会犯这些错误(也不会上当)。

#5 遵循预设的配色方案

除非你是一名设计师或者有很强的审美感，否则坚持使用经过反复试验的配色方案。我们几乎没有理由不这样做——而且这样可以节省时间。Matplotlib 的文档有一篇很棒的文章介绍了他们的彩色地图及其背后的想法。对于 Excel 用户来说，手工复制这些颜色就可以了。

以下是一些可用预设的快速概述:

使用 matplotlib 生成

可用的色彩映射表被整齐地分为顺序的、发散的、循环的、定量的和混杂的。此外，它们提供了感觉上一致的方案，这在考虑打印为灰度时的打印效果时非常有用。

在杂项类别中，有两个值得注意。首先，cubehelix 是一个优秀的方案。其次，Jet 是我们与火焰和夜视联系在一起的配色方案——它几乎总是有效。

使用 matplotlib 生成

多做一点:如果你觉得你需要自己的调味汁，你可以在 Paint.net 或 Photoshop 上得到一些这样的彩色地图，通过调整色调和饱和度来开发新的创意。然后，您需要复制颜色或直接编写更改脚本。这里有两个样本玩喷射和立方体螺旋颜色地图色调和饱和度:

使用 matplotlib 生成。由作者编辑。

#6 尽可能使用语义

想象一下比较美国、巴西和加拿大。你会用哪种颜色？如果是脸书、推特、Youtube 和 Instagram，你会怎么选择？我们很自然地把国家和他们的国旗联系在一起，把品牌和他们的标志联系在一起。这种联系可能意味着某些选择。例如，考虑以下情况:

图片由作者提供。来自国际货币基金组织的数据

左边是绿色的美国，红色的巴西，蓝色的加拿大。这完全是武断的。在右边，我把美国重新映射成浅蓝色，巴西重新映射成绿色，加拿大重新映射成红色。如果你熟悉这些国家，你会把这些颜色和各自的国旗联系起来。这是语义的显式使用。你可能会说这里的蓝色比美国国旗上使用的颜色浅，但这比把它涂成绿色(或巴西涂成红色)要好。

对了，剧情显示美国 GDP 在 20 左右… 20 什么？几十亿？万亿？你可能知道答案，但不是每个人都知道。还有，GDP 代表什么？这是一个故意的错误标签的例子(检查提示 1)。标题应该是“国内生产总值(GDP)”，而轴标签应该是“数万亿美元”。

第二个例子是对 2020 年美国总统选举结果的有问题的解读:

来源:维基百科。由作者编辑。

除了蓝色和红色，没有任何媒体会把民主党和共和党描绘成其他颜色(请看原版)。这里的整个想法是利用观众与我们想要呈现的内容之间已经存在的关系，这样他们就可以直观地理解数据。

多做一点:有时，语义可能非常微妙，并且仅限于特定的受众。例如，在下图中，颜色表示算法的来源。绿色解决方案是基线，蓝色解决方案来自子弹库，其余的方法来自不同的来源。这种关系对于那些不熟悉主题的人来说不是很明显，但是对他们有很大的帮助。

图片由作者

#7 强调关系

再次考虑上面的情节。一些系列使用开放标记(例如，未填充的正方形)，而其他系列使用封闭标记(例如，填充的正方形)。这是显示解决方案相关的简便方法。例如，两个 DBVT 系列共享方形标记，一个打开，另一个关闭。BF/SAP 和 Grid BF/SAP 也是如此。

有很多微妙的方式来表现关系。例如，仔细分配标记可以创造奇迹。除此之外，我们还可以使用其他工具，比如线条样式和填充阴影。例如，如果我们有并行 DBVT F 和并行 DBVT D 解决方案，我们可以用虚线表示串行方法，用实线表示并行方法。同样，我们可以在平行的对应物上附加一个 P。

以下是关于如何使用自定义标记关联系列的一些想法:

传达标记之间关系的简单想法。作者图片

第一个选项允许我们呈现两个变量(填充/未填充和串行/并行)。第二行可以表示基线方法、优化 A、优化 B 和 A + B。第三行可以显示一些属性的增加的级别，例如优化积极性。最后，第四行使用字母，允许 4 个以上的变体。

多做一点:事实上，不要。取而代之的是一个表格或多个图。有时候，最好是让事情更简单、更有重点，而不是试图将所有事情都塞进一个单一的主情节中。

#8 注意灰度

虽然听起来可能很老套，但很多人还是会打印东西，而且很多时候，他们不会用彩色来做。因此，请始终确保您的地块在有限的颜色设置下工作。如果你认为这太多了，就把这当作一个对比检查。如果您的绘图仍然在灰度下工作，则您选择的配色方案有足够的对比度来取悦广大观众。

考虑下面的灰度图:

图片由作者提供。

尽管没有颜色，通过跟随标记和整体灰色阴影来识别每条曲线还是相对容易的。此外，注意唯一的黑色曲线相对于其他曲线的权重。我建议在你最想引起注意的地方使用黑色。例如，你自己提出的方法。

更进一步:更极端的说法是，你也可以把所有东西都变成黑色，以模拟一台有故障的打印机。下面是上面全黑的情节。我们不再能够完全区分 DBVT F 和 AxisSweep 或者 CGAL 和 KD-Tree，但是我们仍然能够理解发生了什么。你可以使用 Paint.Net的颜色曲线功能或者改变对比度来复制这个。

图片由作者提供。

#9 作为灵感来源的画廊

大多数情况下，您想要绘制的并不是一个简单的 2D 数据集，该数据集很容易放入散点图中。取而代之的是一个多维度或者层次性的问题，没有清晰的可视化。在这种情况下，你最好的选择是浏览画廊寻找灵感。

我的三大灵感来源是:

• Seaborn 的示例图库
• Plotly 的文档
• 带代码的论文简讯

这里的想法是看一眼每个样本，然后想，“如果我这样绘制，我的数据可能会是什么样子？”或者，“这个图显示了我需要的维数吗？”例如，这个可以在一个压缩空间中显示几个变量，而绘图矩阵可以是一个很好的方式来一次可视化几个维度。从 Plotly 来看，有一些很酷的可视化效果，比如风玫瑰图和三元图。

你可能想知道为什么《带代码的报纸》会在这里。如果你现在就去看看，你会发现，除了阅读建议，他们还从他们的作品中挑选了最具知识性的图表和情节。如果你问我，这是一个可视化的灵感金矿。做我的客人，绕着最后几期走一走。

在某种程度上，相关工作也是一种画廊。例如，假设您正在撰写一篇关于小说分类体系结构的学术论文，但不确定要绘制什么以及如何绘制。对你来说，有很多关于这个话题的论文，你可以从中得到一些启发。把你看到的每一个不可思议的情节都保存一张图，以备后用，这是一个明智的投资。这里是一个很好的起点。

暂时就这些了。如果你对这篇文章有任何问题，或者你想让我对你的任何视觉化的东西发表评论，请随意评论或者联系我。你也可以订阅每当我在这里发布的时候就会收到通知。我尽我所能每周出版。

如果你是中新，我强烈推荐订阅。对于数据和 IT 专业人员来说，中型文章是 StackOverflow 的完美组合，对于新手来说更是如此。当注册或为我买杯咖啡:)时，请考虑使用我的会员链接

感谢阅读:)

初学者的 9 个最佳机器学*模型

原文：https://towardsdatascience.com/9-best-machine-learning-models-for-beginners-2bcd8386774d

你应该学*的模型有线性回归、支持向量机的逻辑回归和主成分分析

照片来自 Pexels，由 Kindel Media

机器学*是计算机科学中最令人着迷的领域之一。

它在许多行业都有应用，任何人都可以了解它。

在这篇博客文章中，我将为初学者回顾一些 9 大机器学*模型，这样你就可以开始学* ML 了！

1.线性回归

线性回归是你应该了解的第一批机器学*模型之一。这是一种简单的方法来衡量变量之间的关系，这使得它非常容易理解。

如果你想根据平方英尺或卧室数量来预测房价，这将是一种方法！训练后，线性回归会为最符合数据的直线生成一个方程。

为什么要用线性回归？

线性回归的主要好处是它非常容易解释。在训练一个模型后，你可以很容易地理解两个变量之间的关系，这在某些情况下，当你需要解释你的机器学*模型如何做出像欺诈检测或流失预测这样的决策时，效果很好。

线性回归方程是总结两个变量之间关系的好方法。它可用于根据一个变量的已知值预测另一个变量的值。

应用程序

可以使用线性回归的实际应用包括:

• 根据平方英尺或卧室数量预测房价
• 根据库存水平和其他因素预测销售
• 确定哪些变量对客户的购买决策很重要

2.逻辑回归

逻辑回归是另一个你应该尽早学*的模型。当因变量是分类变量(即只有有限数量的可能值)时，使用逻辑回归。

它可用于预测某件事是否会发生(例如，某人是否会购买某件产品)或确定哪些因素对确定感兴趣的结果最重要。

为什么使用逻辑回归？

逻辑回归的主要好处是解释结果相对容易。这是因为系数(即参数的估计值)对应于每个变量对结果预测的贡献程度。

简单来说，逻辑回归的工作原理是试图找到将数据分成两组的最佳直线。一组由因变量等于 1 的所有情况组成(即预测他们会购买该产品)，另一组由因变量等于 0 的所有情况组成(即预测他们不会购买该产品)。

应用程序

您可以使用逻辑回归的实际应用包括:

• 确定决定学生成功的最重要因素
• 在给定库存水平和其他因素的情况下，预测客户是否会购买产品
• 根据个人喜好和其他个人信息来确定某人是否愿意成为捐献者。

3.决策树

决策树是另一种类型的机器学*模型，通常用于分类任务。

它们的工作方式是将数据集分成越来越小的子集，直到每个子集只包含具有相似属性的实例，这意味着您可以通过查看新示例在树结构中所处位置的相关特征来轻松对其进行分类。

为什么要使用决策树？

决策树的主要好处是它们相对容易理解和解释。这是因为树结构使得很容易看到每个特征如何对新示例的分类做出贡献。

决策树的另一个好处是，它们对过度拟合相对健壮，这意味着即使你有很多数据，它们仍然会做出很好的预测。这是因为树结构有助于减少数据中的噪声，并区分不同类型的示例。

应用

随机森林可能有用的实际应用包括:

• 识别植物或动物的种类
• 预测房价
• 根据消费*惯对顾客进行分类

4.随机森林

随机森林是一种集成机器学*模型，这意味着它是通过组合多个模型来创建的。众所周知，集合方法在减少过度拟合方面特别好

在随机森林的情况下，这涉及到创建许多决策树，然后使用它们来投票决定每个实例中的最佳预测。

为什么使用随机森林？

使用随机森林的好处之一是它对过度拟合相对健壮，这意味着即使你有很多数据，它仍然会做出好的预测。这是因为森林中的单个决策树能够抵消数据中的一些噪声。

使用随机森林的另一个好处是相对容易解释。这是因为每个决策树都可以单独查看，它们之间的交互可以使用一个称为“森林图”的图形来可视化。

应用

随机森林可能有用的实际应用包括:

• 预测葡萄酒的质量
• 星系分类
• 确定某人将来是否可能患糖尿病

5.k-最*邻

k-最*邻算法(kNN)是一个简单的机器学*模型，它存储所有可用的案例，并通过与这些已知案例的相似性对新案例进行分类。

他们的工作方式是通过查看一组训练示例的属性，然后使用这些信息来预测新示例是否具有与这些已知案例相似或不同的属性。

这使得他们可以做出很好的预测，即使你只有少量的数据。

为什么要用 K *邻呢？

k-NN 的主要优点是运行速度非常快，效率非常高，适合在大型数据集上使用。

应用

k-NN 可能有用的实际应用包括:

• 根据过去的交易预测客户行为
• 出于营销目的将客户分成不同的群体
• 使用医学图像确定肿瘤是良性的还是恶性的

6.朴素贝叶斯

朴素贝叶斯算法是一种简单的分类算法，常用于文本分类。它基于贝叶斯定理，可用于分类和回归任务。

他们的工作方式是通过使用统计方法来预测一个新的例子是否属于一个类别或另一个类别，基于它被赋予的特征。

为什么要用朴素贝叶斯？

朴素贝叶斯模型的一个优点是，您不需要像其他模型那样多的数据来获得良好的预测。

这是因为他们能够从不同示例之间的相似性中学*，而不会被数据集中不相关的细节所迷惑。

应用

朴素贝叶斯可能有用的实际应用包括:

• 根据内容识别垃圾邮件
• 预测某人将要说的下一个词
• 给动物图片分类

7.k 均值聚类

K-Means 聚类是一种用于聚类分析的技术，聚类分析是将数据点分组为聚类的过程。它可以用于识别数据中的模式，并提高机器学*模型的性能。

为什么要使用 K-Means 聚类？

k-means 聚类的一个优点是速度非常快，计算效率高。这使得它成为一种迭代细化集群的好技术，并且经常用于交互式数据挖掘。

k-means 聚类的准确性取决于您选择查看的聚类数以及这些聚类是如何定义的。但是，通过在算法初始化阶段选择适当的聚类中心，可以提高其预测能力

应用

k 均值聚类通常用于:

• 识别客户群
• 根据联系人或联系对社交网络进行细分
• 将大型数据集划分为预定数量的簇

8.支持向量机

支持向量机(SVM)是一种监督学*算法，可用于分类和回归任务。

它创建了一个超平面来分隔数据集中的不同数据类，最大化它们之间的距离，同时尽量减少错误分类示例带来的错误。

支持向量机已被证明在处理高维数据时表现良好，并经常用于文本分类或图像识别任务。

为什么要用支持向量机？

支持向量机的一个优点是，它们能够很好地从训练数据推广到新的例子。这使得他们不太可能过度适应你训练他们的数据，从而在实践中获得更好的表现。

与其他机器学*算法相比，它们的训练速度也相对较快。

应用

支持向量机的实际应用包括:

• 在句子中识别单词是名词还是动词
• 将图像分类为汽车或卡车
• 识别一个人的语音

9.主成分分析

主成分分析(PCA)是一种用于减少数据集中维数的技术。

它通过识别主成分来做到这一点，主成分是解释数据中最大差异的方向。PCA 可用于简化数据可视化并提高机器学*模型的性能。

为什么使用主成分分析

使用 PCA 的主要好处是减少了数据集中的维数。这使得数据更容易可视化，同时防止过度拟合并提高模型性能。

其他优势包括:

• 与线性模型一起使用时，提高了预测准确性
• 计算强度低于 k-均值聚类
• 有助于识别数据中的重要特征

选择一个并开始练*

这个列表中的模型从简单到复杂，它们使用不同类型的方法。在大多数情况下，这些模型可以用于任何类型的可用数据集。

你练*使用它们的次数越多，你就越能理解每一种方法何时最有效。然而，当它来临时，没有什么可以代替直接投入到一个项目中去尝试！

与 5k 以上的人一起加入我的电子邮件列表，免费获得“完整的 Python 数据科学备忘手册”

数据科学起步的 9 个误区

原文：https://towardsdatascience.com/9-myths-about-starting-in-data-science-2eee6541aac2

想着转行做数据？检查大三找工作的常见偏见。

我的第一个数据分析项目很有趣。图片:捷克(https://www.czechitas.cz/en)，经捷克 z.ú许可发布。

你是否正在考虑在一个有前途的数据科学领域开始新的职业生涯？如果一个前煤矿工人或歌剧演员能做到这一点，你可能也能做到。

我去过那里，但不是在矿井里，也不是用我的高音折磨观众。我从写关于电动汽车和科技产品的文章跳到了用 Python 写代码。

免责声明:数据科学是一个宽泛的术语，包括数据科学家、数据工程师、数据分析师等工作，甚至包括那些仍然乐于使用 MS Excel 或 MS Access 的古怪的人。

我参加的第一个关于数据的课程是一个为期 3 个月的关于数据(SQL、Python 和 Power BI)的强化课程，该课程来自捷克组织，其目标是让更多女性进入 IT 和数据行业。但这不是最后一次。学*永远不会停止，即使是在被雇佣之后。

有哪些常见的神话或误解可以阻止可疑人员追求他们在新兴数据领域找到工作的目标？

1)你不必是数学天才

当然，成为其中一员并没有坏处。但是你在数字方面的天赋可能会浪费在数据科学上。去最*的赌场旅游，玩专业水平的扑克，或者只是让一些博彩公司输钱。

除了研究中的某些数据工作，你不需要比一个懒惰的高中生懂更多的数学。当然，如果你这样做就更好了，但即使是最复杂的机器学*模型现在也是高度自动化的。例如，你不需要记住贝叶斯定理的方程，你的计算机需要，所以你可以专注于其他事情。

2)认证可以是钻石，也可以是垃圾

有些认证很难通过，证明你的技能使你与众不同。但更常见的是，你可以找到注册时需要付费的证书，甚至在获得证书后，必须输入数据字段并不是什么特别或必要的事情。

例如，你可能不需要支付超过 200 欧元来获得 SQL 查询编写认证。大多数公司可以很容易地测试你在这方面的知识，如果他们发现这对他们未来的员工有用的话。

此外，如果你很少搜索，你可以完全免费获得有用的认证考试(否则要付费)。例如，任何人都可以参加 Azure 女士的各种考试，而无需支付 1 美元或 1 欧元。

3)高级分析师和开发人员也使用堆栈溢出

当你有不明白的地方或者你的高级同事使用了你人生中第一次听到的术语时，不要害怕提问。数据是一个快速发展的领域，所以很多事情都在快速变化，你不可能总是在所有领域都跟上速度。

此外，请放心，即使你更有经验的同事也可能至少一周一次(如果不是每天)在 Stack Overflow 网站或类似网站上谷歌回答他们的一些任务。

4)编码和编程不仅仅是像谢尔顿这样的人的事

当然，Sheldon Cooper 是一个理论物理学家，所以我们不确定他是否真的懂 Java 或者 PHP，但是我想你已经明白了主要的意思。

你知道吗，大多数数据分析师都讨厌饼图。图片:捷克，经捷克 z.ú许可出版。

此外，我没有编造关于煤矿工人辞去煤矿工作成为软件开发人员的故事，也没有编造转行做数据分析的歌剧歌手的故事。这些都是真实事件。

5)演示文稿最重要的不是它的内容

如果你从事任何一种办公室工作，你会被要求在生活中做很多演示。尽管如此，被要求为他人展示物品的人通常会问的第一个问题是:

• 我演讲的主题是什么？
• 演示要多长时间？

这不是最重要的问题。相反，你应该问:

• 我将向谁介绍？
• 谁会是我的观众？年轻人？有经验的专业人士？什么国籍，性别等。？

话题可能是一样的，但是你说的内容对愿意听你说话的人来说会有很大的不同。

你说什么不重要，重要的是你怎么说。图片:捷克(https://www.czechitas.cz/en)，经捷克 z.ú许可发布。

即使你花了很多天来构建和调整一些复杂的机器学*算法，如果你正在给商业用户做演示，他们很可能不会关心它。他们只对最终结果感兴趣，以及它对他们的业务和客户有什么影响。

6)你不可能全部抓到；没有人是小智

AWS、MS Azure、GCP，现在甚至雪花和其他公司都加入了“云战争”以决定最终哪家云供应商将统治他们。几乎在数据科学和数据分析的每个领域都有许多相互竞争的技术和工具。

你不可能全部掌握，而且尝试也没有意义。只有一个来自托盘镇的主人能抓住他们，这是因为他一路上得到了他特别的黄色朋友的帮助。

7)机器学*和神经网络很酷，但是…

大多数公司实际上不需要使用深度学*或无监督机器学*方法的解决方案。

他们可能没有足够的数据或足够干净的数据来使这些算法正常工作，或者他们根本不需要使用 ML 的复杂解决方案，当更简单、更便宜的东西可用时。仅仅使用简单的统计方法通常就足够了。

8)不需要 MS Excel，但是…

Excel 中的电子表格有许多局限性，还有许多更实用的工具可以做同样的事情，但速度更快，功能也更多。

但是迟早，你会遇到这样一个人，他的巅峰技能意味着在电子邮件交流中发送和接收 Excel 文件作为附件。你需要找到与这个人的共同点，即使你知道你可以用 Python 代码自动完成同样的任务。

有些人只是想用过去 10 年来一直使用的方式获得 Excel 报表。你可以试着改变他们的观点，给他们看其他的选择，但是这并不总是有效的。

9)人力资源人员通常不知道 IT 或数据团队想要什么

这并不奇怪。即使是 IT 和数据专业人员也发现很难跟上不断发展的领域。因此，指望人力资源专家来做是不可能的。

有时您需要向他们指出，如果一个人在 Power BI 中非常擅长数据可视化，那么使用 Tableau 这样的工具对他们来说可能是小菜一碟。或者你实际上并不需要 X 年以上的经验来操作某些工具，因为它们可以在几天或几周内学会。当然，你可以试着说服他们，他们可能不相信你，但那不是你的问题。

大三学生对数据科学领域的常见偏见总结:

• 不需要“爱因斯坦数学水平”的知识。
• 并不是所有的数据和 IT 认证在市场上都有真正的价值。明智地选择它们。
• 不要害怕提问和谷歌解决方案。
• 编程并不是一项仅限于门萨俱乐部成员的活动(该俱乐部要求其成员是智商最高的 2 %的人之一)。
• 在展示某样东西时，对谁来说比展示什么更重要。
• 你不可能抓住所有的神奇宝贝，也不可能掌握科技市场上的所有技术。
• 拥有机器学*技能很好，但不是交易的破坏者。
• MS Excel 还没有过时。
• 工作描述中的一些人力资源要求可能不现实。所以，不要犹豫，也申请那些你不需要勾选所有选项的工作。

你是否渴望将你的职业生涯转换到数据科学领域，并且你可能对进入未知领域有些恐惧？那么这篇文章的一个重要观点是:

不要相信告诉你不可能(从完全不同的领域进入数据科学)的其他人，也不要相信你大脑中告诉你同样事情的焦虑的声音。

如果你有足够的决心，就会成功。在你完成所选的数据课程或训练营后，这可能不会马上发生，但如果你坚持，最终你会到达那里。如果煤矿工人做到了，你也可以。

任何学* Python 的人都应该知道的 9 个一行程序

原文：https://towardsdatascience.com/9-one-liners-anyone-learning-python-should-know-29fdea7c540c

使用这些一行程序使您的 Python 代码简洁

图片来自 Shutterstock，授权给 Frank Andrade

当我们开始学* Python 时，我们通常会编写完成工作的代码，而不会关注我们代码的可读性以及它有多简洁和高效。

这很好，但是有一些方法可以在不忽略可读性的情况下使我们的 Python 代码更短。这就是一行程序的全部内容(如果您正确使用它们的话)。

这里是任何学* Python 的人都应该知道的 9 个一行程序。

如果你不想看，可以看我的 YouTube 视频。

1.If — Else 语句

if-else 语句是我们在 Python 中学*的第一批语句之一。它用于执行给定条件的真和假部分。

我们经常使用这种说法，但是你知道它可以简化成一行代码吗？在这种情况下，if 和 else 语句将位于同一行。

age = 18valid = "You're an adult"
invalid = "You're NOT an adult"**print**(valid) **if** age >= 18 **else** **print**(invalid)

2.基于现有列表创建列表

列表是存储数据的一种常见方式，但是您知道吗？您可以使用一行代码基于现有列表创建一个新列表。

确实如此！它被称为 list comprehension，它提供了一个简短的语法来基于现有列表的值创建一个列表。列表理解比制作列表的函数和循环更紧凑。

下面是语法，我们将使用。

[expression **for** item **in** list]

这里有一个例子:

words = ['united states', 'brazil', 'united kingdom']

capitalized = [word.title() **for** word **in** words]>>> capitalized
['United States', 'Brazil', 'United Kingdom']

看起来好多了，不是吗？记住，我们应该让代码对用户友好，所以不要在一行中写很长的理解列表。

3.词典理解

与列表理解类似，Python 中也有字典理解。想法是一样的。Dictionary comprehension 提供了一个简短的语法，可以在一行代码中创建一个字典。

下面是语法，我们将使用:

{key: value **for** key, value **in** iterable}

这里有一个例子:

dict_numbers = {x:x*x **for** x **in** range(1,6) }>>> dict_numbers
{1: 1, 2: 4, 3: 9, 4: 16, 5:25}

4.加入词典

加入字典有不同的方法。可以使用update()方法、merge()运算符，甚至字典理解。

也就是说，在 Python 中有一种更简单的连接字典的方法。这是通过使用解包操作符**实现的。我们只需要在我们想要组合的每个字典前面添加**，并使用一个额外的字典来存储输出。

dict_1 = {'a': 1, 'b': 2}
dict_2 = {'c': 3, 'd': 4}merged_dict = {******dict_1, ******dict_2}>>> merged_dict
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

在我们将**操作符应用到字典之后，两者都将扩展它们的内容并组合起来创建一个新字典。

5.删除列表中的重复项

有时我们需要确保列表中没有任何重复的值。虽然没有一种方法可以轻松地处理它，但是您可以使用集合来消除重复。

集合是项目的无序集合，其中每个元素都是唯一的。这意味着，如果我们把我们的列表变成一个集合，我们可以删除重复的。然后我们只需要再次将集合转换成列表。

让我们看一个基本的例子来掌握它的窍门。

numbers = [1,1,1,2,2,3,4,5,6,7,7,8,9,9,9]

>>> **list**(**set**(numbers))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

6.用 Python 在一行中分配多个变量

每当你需要给多个变量赋值时，不用一行一行的赋值，你可以在 Python 中一行的赋值(甚至是不同类型的变量)。

a, b, c = 1, "abc",  True>>> a
1>>> b
'abc'>>> c
True

更紧凑，不是吗？但是要小心！你分配的变量越多，给它们分配错误值的机会就越大。

7.从列表中筛选值

假设我们想从列表中过滤一些值。您可以使用许多方法来做到这一点，但是一个简单的方法是使用filter()函数。

下面是filter函数的语法:

**filter**(function, iterable)

如果您在filter函数中添加一个lambda函数，事情会变得更好！

让我们通过从列表中过滤偶数来掌握它的窍门。

my_list = [10, 11, 12, 13, 14, 15]>>> **list**(**filter**(**lambda** x: x%2 == 0, my_list ))
[10, 12, 14]

8.按关键字对字典排序

对字典进行排序不像对列表进行排序那么简单——我们不能像对列表那样使用sort() 或sorted()对字典进行排序。

好消息是，我们可以将字典理解与sorted()函数结合起来，按关键字对字典进行排序。

让我们看一看。在下面的例子中，我们将按产品名称对字典进行排序。

product_prices = {'Z': 9.99, 'Y': 9.99, 'X': 9.99}>>{key:product_prices[key] **for** key **in** **sorted**(product_prices.keys())}
{'X': 9.99, 'Y': 9.99, 'Z': 9.99}

9.按值对字典排序

类似于按键排序字典，我们需要使用sorted()函数和 list comprehension 来按值排序字典。但是，除此之外，我们还需要添加一个lambda函数。

首先，让我们看看sorted()函数的所有参数。

sorted(iterable, key=None, reverse=False)

为了按值对字典进行排序，我们需要使用键参数。此参数接受作为排序比较的键的函数。这里我们可以使用一个lambda函数来简化事情。

假设我们有一个包含人口值的字典，我们想按值对它进行排序。

population = {'USA':329.5, 'Brazil': 212.6, 'UK': 67.2}

>>> **sorted**(population.items(), **key**=**lambda** x:x[1])
[('UK', 67.2), ('Brazil', 212.6), ('USA', 329.5)]

现在唯一剩下的就是加字典理解了。

population = {'USA':329.5, 'Brazil': 212.6, 'UK': 67.2}

>>> {k:v **for** k, v **in** **sorted**(population.items(), **key**=**lambda** x:x[1])}
{'UK': 67.2, 'Brazil': 212.6, 'USA': 329.5}

用 Python 学*数据科学？ 通过加入我的 10k+人电子邮件列表，获取我的免费 Python for Data Science 备忘单。

如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑报名成为一名媒体成员。每月 5 美元，让您可以无限制地访问数以千计的 Python 指南和数据科学文章。如果你使用我的链接注册，我会赚一小笔佣金，不需要你额外付费。

https://frank-andrade.medium.com/membership

帮助我获得第一份数据分析师工作的 9 个 SQL 核心概念

原文：https://towardsdatascience.com/9-sql-core-concepts-that-helped-me-get-my-first-data-analyst-job-a582f892276f

掌握 SQL 的第一步

图片来自 Shutterstock，授权给 Frank Andrade

如果我必须重新开始我的数据科学之旅，我会首先学* SQL。

我不太喜欢 SQL，但最有可能的是，你需要 SQL 来通过数据科学/分析师面试，无论你的职位如何，你都会经常使用 SQL 来创建查询并与公司的数据库进行交互。

以下是帮助我通过第一次数据分析师面试的 9 个 SQL 核心概念。

数据

为了展示您应该知道的 9 个 SQL 核心概念，我们将使用一个包含 100 多名顶级足球运动员信息的表。您可以在这里下载这些数据，并将其导入您的数据库。

下面是我们将使用的表格，我将其命名为players_description。

Initial table: players_description

+----+-------------------+------------+-----+-----+---------------+
| ID |     FirstName     |  LastName  | Age | ... | Team_Position |
+----+-------------------+------------+-----+-----+---------------+
|  1 | Lionel Andrés     | Messi      |  32 | ... | RW            |
|  2 | Cristiano Ronaldo | dos Santos |  34 | ... | LW            |
|  3 | Neymar            | da Silva   |  27 | ... | CAM           |
|  4 | Jan               | Oblak      |  26 | ... | GK            |
|  5 | Eden              | Hazard     |  28 | ... | LW            |
|  6 | Kevin             | De Bruyne  |  28 | ... | CAM           |
|  7 | Marc-André        | ter Stegen |  27 | ... | GK            |
|  8 | Virgil            | van Dijk   |  27 | ... | LF            |
|  9 | Luka              | Modrić     |  33 | ... | CM            |
| 10 | Mohamed           | Salah      |  27 | ... | RW            |
| .. |     ...           |   ...      | ... | ... | ...           |
+----+-------------------+------------+-----+-----+---------------+

1.选择指令

SELECT 语句允许我们从数据库中选择数据。这是 SQL 中最常见的语句，所以请记住下面的语法。

让我们从players_description表中选择列FirstName、LastName和Height。

Query:**SELECT** FirstName, LastName, Height
**FROM** players_description;Output:+---------------------+--------------+--------+
|      FirstName      |   LastName   | Height |
+---------------------+--------------+--------+
| "Lionel Andrés"     | Messi        |    170 |
| "Cristiano Ronaldo" | "dos Santos" |    187 |
| Neymar              | "da Silva"   |    175 |
| Jan                 | Oblak        |    188 |
| Eden                | Hazard       |    175 |
| Kevin               | "De Bruyne"  |    181 |
| Marc-André          | "ter Stegen" |    187 |
| Virgil              | "van Dijk"   |    193 |
| Luka                | Modrić       |    172 |
| Mohamed             | Salah        |    175 |
+---------------------+--------------+--------+

2.选择不同的语句

每当我们想从一列中选择唯一的元素时，我们就使用 SELECT DISTINCT 语句。

让我们从players_description表中看到独特的Team_Position。

Query:**SELECT** **DISTINCT** Team_Position
**FROM** players_description;Output:+---------------+
| Team_Position |
+---------------+
| RW            |
| LW            |
| CAM           |
| GK            |
| LF            |
| CM            |
| ST            |
| CDM           |
| LM            |
| RM            |
| RB            |
| CF            |
| CB            |
| RAM           |
| LAM           |
+---------------+

3.WHERE 子句

WHERE 子句允许我们在查询中添加一个条件。只有满足条件的值才会在输出表中返回。

让我们创建一个查询，只过滤那些Height大于 180cm 的球员。

Query:**SELECT** FirstName, LastName, Height
**FROM** players_description
**WHERE** Height>180;Output:+---------------------+--------------+--------+
|      FirstName      |   LastName   | Height |
+---------------------+--------------+--------+
| "Cristiano Ronaldo" | "dos Santos" |    187 |
| Jan                 | Oblak        |    188 |
| Kevin               | "De Bruyne"  |    181 |
| Marc-André          | "ter Stegen" |    187 |
| Virgil              | "van Dijk"   |    193 |
| Kalidou             | Koulibaly    |    187 |
| Harry               | Kane         |    188 |
| Alisson             | Becker       |    191 |
| David               | "De Gea"     |    192 |
| Giorgio             | Chiellini    |    187 |
+---------------------+--------------+--------+

4.COUNT()、AVG()和 SUM()函数

SQL 中一些最常见的函数是 COUNT“COUNT()”、average“AVG()”和 SUM“SUM()”。

如果我们考虑一下以前学过的 WHERE 子句，下面是 COUNT()、AVG()和 SUM()的语法。

让我们看看我们能从巴塞罗那俱乐部得到什么启示。

Query 1: Let's see how many Barcelona players are in our table**SELECT COUNT**(Playerid)
**FROM** players_description
**WHERE** Club="FC Barcelona";Output 1:+-----------------+
| COUNT(Playerid) |
+-----------------+
|              15 |
+-----------------+Query 2: Calculate the average height of Barcelona players**SELECT AVG**(Height)
**FROM** players_description
**WHERE** Club="FC Barcelona";Output 2:+-------------+
| AVG(Height) |
+-------------+
|    181.2667 |
+-------------+Query 3: Sum the wage of Barcelona players**SELECT** **SUM**(Wage_eur)
**FROM** players_description
**WHERE** Club="FC Barcelona";Output 3:+---------------+
| SUM(Wage_eur) |
+---------------+
|          3945 |
+---------------+

5.以...排序

每当我们想对输出表进行升序或降序排序时，我们就使用 ORDER BY 关键字。

让我们找出谁是我们桌上最高的球员。

Query:**SELECT** FirstName, LastName, Height
**FROM** players_description
**ORDER** **BY** Height **DESC**;Output:+-----------+-------------+--------+
| FirstName |  LastName   | Height |
+-----------+-------------+--------+
| Thibaut   | Courtois    |    199 |
| Gianluigi | Donnarumma  |    196 |
| Jiří      | Pavlenka    |    196 |
| Wojciech  | Szczęsny    |    195 |
| Niklas    | Süle        |    195 |
| Zlatan    | Ibrahimović |    195 |
| Gerard    | Piqué       |    194 |
| Virgil    | "van Dijk"  |    193 |
| Samir     | Handanovič  |    193 |
| Manuel    | Neuer       |    193 |
+-----------+-------------+--------+

6.和/或运算符

我们可以将 WHERE 子句与不同的运算符(如 AND/OR)结合使用。

下面是要使用的语法。

这是这些运算符之间的区别。

• 如果所有条件都为真，则显示一条记录
• 或者在任何条件为真时显示一条记录

让我们看一些用 AND/OR 的例子。

Query: Show players from France (FRA) with height greater than 180cm.**SELECT** FirstName, LastName, Height, Nationality
**FROM** players_description
**WHERE** Height>180 **AND** Nationality="FRA";Output:+-----------+-----------+--------+-------------+
| FirstName | LastName  | Height | Nationality |
+-----------+-----------+--------+-------------+
| Paul      | Pogba     |    191 | FRA         |
| Hugo      | Lloris    |    188 | FRA         |
| Aymeric   | Laporte   |    189 | FRA         |
| Karim     | Benzema   |    185 | FRA         |
| Samuel    | Umtiti    |    182 | FRA         |
| Raphaël   | Varane    |    191 | FRA         |
| Clément   | Lenglet   |    186 | FRA         |
| Lucas     | Hernández |    182 | FRA         |
| Stéphane  | Ruffier   |    188 | FRA         |
+-----------+-----------+--------+-------------+Query: Show players that are from France (FRA) or that have a height greater than 180cm.**SELECT** FirstName, LastName, Height, Nationality
**FROM** players_description
**WHERE** Height>180 **OR** Nationality="FRA";Output:+---------------------+--------------+--------+-------------+
|      FirstName      |   LastName   | Height | Nationality |
+---------------------+--------------+--------+-------------+
| "Cristiano Ronaldo" | "dos Santos" |    187 | PRT         |
| Jan                 | Oblak        |    188 | SGP         |
| Kevin               | "De Bruyne"  |    181 | BLX         |
| Marc-André          | "ter Stegen" |    187 | DEU         |
| Virgil              | "van Dijk"   |    193 | NPL         |
| Kylian              | Mbappé       |    178 | FRA         |
| Kalidou             | Koulibaly    |    187 | SEN         |
| Harry               | Kane         |    188 | UK          |
| Alisson             | Becker       |    191 | BRA         |
| David               | "De Gea"     |    192 | ESP         |
+---------------------+--------------+--------+-------------+

7.操作员之间

BETWEEN 运算符选择给定范围内的值(例如，数字、文本或日期)。该运算符是包含性的，这意味着开始值和结束值都包含在内。

让我们来看看哪些球员年龄在 20 岁到 30 岁之间。

Query:**SELECT** FirstName, LastName, Age
**FROM** players_description
**WHERE** Age **BETWEEN** 20 **AND** 30;Output:+------------+--------------+-----+
| FirstName  |   LastName   | Age |
+------------+--------------+-----+
| Neymar     | "da Silva"   |  27 |
| Jan        | Oblak        |  26 |
| Eden       | Hazard       |  28 |
| Kevin      | "De Bruyne"  |  28 |
| Marc-André | "ter Stegen" |  27 |
| Virgil     | "van Dijk"   |  27 |
| Mohamed    | Salah        |  27 |
| Kylian     | Mbappé       |  20 |
| Kalidou    | Koulibaly    |  28 |
| Harry      | Kane         |  25 |
+------------+--------------+-----+

8.在/不在运算符中

当我们想要在 WHERE 子句中指定多个值时，我们使用 IN 操作符。

让我们得到一份为巴塞罗那俱乐部或皇家马德里队效力的球员名单。

Query:**SELECT** FirstName, LastName, Age, Club
**FROM** players_description
**WHERE** Club **IN** ('FC Barcelona', 'Real Madrid');Output:+-----------------+--------------+-----+----------------+
|    FirstName    |   LastName   | Age |      Club      |
+-----------------+--------------+-----+----------------+
| "Lionel Andrés" | Messi        |  32 | "FC Barcelona" |
| Eden            | Hazard       |  28 | "Real Madrid"  |
| Marc-André      | "ter Stegen" |  27 | "FC Barcelona" |
| Luka            | Modrić       |  33 | "Real Madrid"  |
| Sergio          | Ramos        |  33 | "Real Madrid"  |
| Luis            | Alberto      |  32 | "FC Barcelona" |
| Sergio          | Busquets     |  30 | "FC Barcelona" |
| Antoine         | Griezmann    |  28 | "FC Barcelona" |
| Thibaut         | Courtois     |  27 | "Real Madrid"  |
| Gerard          | Piqué        |  32 | "FC Barcelona" |
+-----------------+--------------+-----+----------------+

9.像-不像运算符

当我们想要在列中搜索特定的模式时，我们使用 LIKE 操作符。

我们可以在模式中使用不同的通配符。以下是两种最常见的通配符:

• %:表示零个、一个或多个字符
• _:表示单个字符

让我们过滤那些名字以字母“s”开头的玩家

Query:**SELECT** FirstName, LastName
**FROM** players_description
**WHERE** FirstName **LIKE** 's%';Output:+-----------+------------------+
| FirstName |     LastName     |
+-----------+------------------+
| Sergio    | Agüero           |
| Sergio    | Ramos            |
| Sergio    | Busquets         |
| Samir     | Handanovič       |
| Sadio     | Mané             |
| Samuel    | Umtiti           |
| Sergej    | Milinković-Savić |
| Saúl      | Ñíguez           |
| Serge     | Gnabry           |
| Stefan    | "de Vrij"        |
| Stéphane  | Ruffier          |
| Salvatore | Sirigu           |
| Sokratis  | Papastathopoulos |
| Sergio    | Canales          |
+-----------+------------------+

您可以使用%和_创建许多模式。在这里你可以找到其中的一些。

学* SQL —数据专业人员最需要的技能。 加入我的 20k+人电子邮件列表，获取我的免费 SQL 备忘单。

如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑报名成为一名媒体成员。每月 5 美元，让您可以无限制地访问数以千计的 Python 指南和数据科学文章。如果你使用我的链接注册，我会赚一小笔佣金，不需要你额外付费。

https://frank-andrade.medium.com/membership

比条形图更引人注目的 9 种 Python 可视化

原文：https://towardsdatascience.com/9-visualizations-that-catch-more-attention-than-a-bar-chart-72d3aeb2e091

使用 Python 创建引人注目的图表，以代替条形图。

照片由巴迪·阿巴斯 在 Unsplash 上拍摄

条形图是一种二维图形，在 X 轴或 Y 轴上有矩形条。我们使用矩形条通过比较高度或长度来比较离散类别中的值。这个图表在数据可视化中很典型，因为它易于创建和理解。

但是，在某些情况下，例如创建信息图或向公众展示需要引起人们注意的数据，条形图可能不够吸引人。有时使用过多的条形图可能会导致显示效果不佳。

数据可视化中有多种图表。实际上，图形可以改进或改变形式。本文将展示九个想法，你不仅可以用它们来代替条形图，还可以让获得的结果看起来更好。

本文中有两个可视化的例子，可以用来代替条形图来引起注意。图片由作者提供。

免责声明！！

这篇文章的意图不是反对条形图。每个图表都有它的优点。本文旨在展示比条形图更能吸引注意力的可视化效果。顺便说一句，它们并不完美；它们也各有利弊。

让我们开始吧。

检索数据

从导入库开始

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns%matplotlib inline

为了表明本文中提到的方法可以应用于现实世界的数据，我们将使用维基百科上按二氧化碳排放量列出的国家列表中的数据。这篇文章展示了 2018 年二氧化碳排放量的主权国家和领土名单。

本文根据知识共享署名-类似共享 3.0 未授权许可的条款使用了来自维基百科的数据。

我按照有用的步骤从网络下载数据，将维基百科表抓取到数据帧。

使用 BeautifulSoup 解析获得的数据

例如，我将选择最后一列，2018 年二氧化碳排放量/总排放量，不包括 LUCF(土地利用-变化和林业)，并只过滤二氧化碳排放量在 200 到 1000 MTCO2e (二氧化碳当量公吨)之间的国家。

如果您想要使用其他列或更改 CO2 排放范围，可以修改以下代码。

得到数据帧后，我们将对二氧化碳排放量进行分类，得到另一个数据帧。正常数据帧和排序数据帧都将用于以后的绘图。创建两个数据帧的原因是为了表明结果可能不同。

df_s = df.sort_values(by='emission_2018', ascending=False)
df_s.head(9)

现在一切都准备好了，让我们绘制一个条形图，以便稍后与其他可视化结果进行比较。

柱状图显示了 2018 年各国二氧化碳排放量在 200 到 1000mtco 2e之间。数据来自维基百科。图片由作者提供。

在继续之前，我们将定义一个函数来提取一个颜色列表，供以后在每个可视化中使用。

应用该函数获得颜色列表。

pal_vi = get_color('viridis_r', len(df))
pal_plas = get_color('plasma_r', len(df))
pal_spec = get_color('Spectral', len(df))
pal_hsv = get_color('hsv', len(df))

形象化

在本文中，有 9 个可视化，我们可以将它们分为两组:

修改矩形条

• 圆形条形图(又名赛道图)
• 放射状条形图
• 树形图
• 华夫饼图表
• 交互式条形图

改变形式

• 圆形分格统计图表
• 雷达图
• 泡泡图
• 圆形包装

1. 用圆形条形图改变方向(又名赛道图)

圆形条形图的概念是表示围绕圆心的条形。每个小节从相同的度数开始，并向相同的方向移动。能完成循环的人价值最高。

这是一个吸引读者注意力的好主意。顺便说一句，停在圆圈中间的小节很难读。请注意，每个小节的长度并不相等。靠*中心的长度会比远离中心的长度短。

用数据框画一个圆形条形图

圆形条形图显示了 2018 年各国二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

用排序后的数据框绘制一个圆形条形图

圆形条形图显示了 2018 年各国二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

2。从中心开始用放射状条形图

放射状条形图的概念是改变条形的方向。每个条形不是具有相同的方向，而是从圆心开始，以不同的方向移动到圆的边缘。

请注意，彼此不相邻的条形可能很难比较。标签沿着径向条处于不同的角度；这会给用户带来不便。

用数据框绘制一个径向条形图

放射状条形图显示了 2018 年各国二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

用排序后的数据框绘制一个径向条形图

放射状条形图显示了 2018 年各国二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

3。使用区域与树形图进行比较

树形图通过使用矩形区域来帮助显示分层数据。即使我们的数据没有层次结构，我们仍然可以通过只显示一个层次结构级别来应用树形图。

绘制树形图时，通常数据从最大值开始降序排列。如果有许多矩形，请注意小的可能很难阅读或区分。

用创建一个互动的树形图:

Treemap 显示了 2018 年各国的二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

4。将小方块与华夫饼图结合

除了这个奇特的名字，华夫饼干图也是创建信息图的一个好主意。它由许多小方块组合成一个大矩形，使结果看起来像一个华夫饼干。

通常，这些方块以 10 乘 10 的布局排列，以显示比率或进度。顺便说一下，可以改变方块的数量以适应数据。

绘制一张显示每个国家二氧化碳排放量的饼状图

华夫格图显示了 2018 年各国二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

结果可能看起来很吸引人，色彩丰富，但很难区分颜色的深浅。这可以被认为是华夫格图的局限性。因此，可以说华夫格图适用于比较几类数据。

为了避免阅读上的困难，让我们将每个国家一个接一个地与其他国家相对照。然后，将它们组合成照片拼贴画。使用下面的代码，请考虑这些图将在您的计算机上导出，以便以后导入。

绘制每个国家的华夫饼图表

2018 年，一个国家的二氧化碳排放量与其他国家的二氧化碳排放量之间的饼状图示例。图片由作者提供。

现在我们有了每个国家的华夫饼图表，让我们定义一个函数来创建一个照片拼贴。我在下面找到了一个很棒的代码，把 Stack Overflow( link )的情节组合起来。

应用该函数获得一个照片拼贴

# to create a fit photo collage: 
# width = number of columns * figure width
# height = number of rows * figure heightget_collage(5, 5, 2840, 1445, save_name, 'Collage_waffle.png')

照片拼贴的一部分，结合了每个国家的华夫饼图表。图片由作者提供。

5。除了使条形图互动之外什么也不改变

我们可以把一个简单的条形图变成一个交互式的。如果您想继续使用条形图，这是一个好主意。获得的结果可以播放或过滤的方式，用户想要的。是一个有用的库，可以帮助你轻松地创建一个交互式的饼状图。

唯一关心的是向最终用户显示交互式条形图；应该有一个说明解释如何使用该功能。

绘制交互式条形图

交互式条形图显示了 2018 年各国二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

6。在饼图中显示百分比

饼图是数据可视化中的另一种典型图表。它基本上是一个圆形的统计图，分成若干片以显示数字比例。普通的饼状图可以转换成交互式的饼状图，以便可以播放或过滤结果。我们可以使用 Plotly 创建一个交互式饼图。

与使用交互式条形图一样，如果读者是最终用户，应该有一个说明来解释如何使用该功能。

绘制交互式饼图

交互式饼图显示了 2018 年各国二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

7。用雷达图围绕一个圆绘图

雷达图是显示多元数据的图形化方法。相比之下，条形图主要用于分类数据。为了应用带有分类数据的雷达图，我们可以将每个分类视为多元数据中的一个变量。每个类别的值将从中心绘制。

对于许多类别，用户会发现很难比较位置不相邻的数据。这可以通过应用带有分类数据的雷达图来解决。因此，用户可以确定哪些值高于或低于其他值。

用数据框绘制雷达图。

雷达图显示，2018 年各国的二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

用排序后的数据框绘制雷达图。

雷达图显示，2018 年各国的二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

8。在气泡图中使用多个圆圈

理论上，气泡图是一个散点图，具有不同大小的数据点。这是显示三维数据、X 值、Y 值和数据大小的理想绘图。

应用没有 X 和 Y 值的分类数据的气泡图的一个好处是，我们可以按照我们想要的方式定位气泡。例如，下面的代码显示了如何垂直绘制气泡。

创建 X 值、Y 值和标签的列表。然后，将它们作为列添加到数据框架中。如果您想要在水平方向绘制气泡，请在 X 和 Y 列之间交替值。

绘制垂直气泡图

垂直气泡图显示了 2018 年各国二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

为了更进一步，我们可以用不同的形式显示气泡。让我们试着把它们画在一个圆形的方向上。

为此，我们需要计算 X 和 Y 坐标。从 360 度除以行数开始。然后，用余弦和正弦函数转换度数，分别得到 X 和 Y 坐标。

沿圆周方向绘制气泡

圆形气泡图显示了 2018 年各国二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

可以注意到，我们定位气泡越复杂，我们失去的空间就越多。我们可以用垂直或水平气泡图为其他可视化节省空间。

9。用圆形包装聚集气泡

最后，让我们将没有重叠区域的气泡分组。圆形包装是绘制气泡图的好主意，同时节省空间。我们需要计算每个气泡的位置和大小。幸运的是，有一个名为 circlify 的库使得计算变得容易。

圆形包装的一个缺点是很难区分大小相*的气泡。这可以通过给每个气泡标上它的值来解决。

绘制圆形包装

圆形包装显示 2018 年各国二氧化碳排放量在 200 至 1,000 MTCO2e 之间。图片由作者提供。

摘要

条形图没有问题。实际上，条形图简单易用。然而，任何图表都是完美的，适合每一份工作。数据可视化有时需要引起注意，例如创建信息图，条形图可能无法提供吸引力。

本文展示了九种可视化效果，显示了与条形图相同的数据维度，引起了人们的注意。顺便说一下，这些图表也有它们的缺点。请考虑它们可能难以阅读或不适合用于正式报告。

如果有什么建议或推荐，欢迎随时留言评论。感谢阅读。

以下是您可能会感兴趣的关于数据可视化的其他文章:

• 9 用 Python 可视化显示比例或百分比，而不是饼图(链接)
• 8 用 Python 处理多个时间序列数据的可视化(链接
• 用 Python 处理超长时间序列数据的 6 个可视化技巧(链接)
• 超越云:用 Python 代替 Word Cloud 的 4 种可视化(链接)

参考

• 维基媒体基金会。(2022 年 5 月 18 日)。二氧化碳排放国家名单。维基百科。2022 年 8 月 3 日检索，来自https://en . Wikipedia . org/wiki/List _ of _ countries _ by _ carbon _ CO2 _ emissions
• 拉克霍迪亚，N. (2021 年 1 月 11 日)。将维基百科表格抓取成数据帧。中等。2022 年 8 月 3 日检索，来自https://medium . com/analytics-vid hya/web-scraping-a-Wikipedia-table-into-a-data frame-c 52617 E1 f 451

9 用 Python 可视化显示比例或百分比，而不是饼图

原文：https://towardsdatascience.com/9-visualizations-to-show-proportions-or-percentages-instead-of-a-pie-chart-4e8d81617451

用 Python 创建替代饼状图的方法

由 Elle inlom 在 Unsplash 上拍摄

饼图是显示分类数据比例的典型图表。基本上，这是一个分成若干部分的圆形图形，用来显示数据占总数的比例。通过计算等于 100%的总 360 度，面积可以用百分比表示。

该图表经常用于数据可视化，因为其概念易于创建，结果也易于理解。

然而，有一些有争议的问题。一些消息来源解释说，人类很难从图上的切片中测量数量(链接)。而且信息会被扭曲，误导读者(链接)。

幸运的是，饼状图不是我们可以使用的唯一选择。有各种图形可以表示比例或百分比。本文将介绍九种替代方法，它们可以像饼图一样展示相同的数据维度。

本文中的一些可视化示例。图片由作者提供。

免责声明！！

这篇文章的意图不是反对饼状图。每个图表都有它的优点和缺点。主要目的是指导一些图表，这些图表可以用与总数相比的比例或百分比来表示数据。

请考虑到这些可视化并不完美；它们也有利弊。

让我们开始吧。

检索数据

从导入库开始

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns%matplotlib inline

为了说明本文中提到的方法可以应用于现实世界的数据，我将使用维基百科上按煤炭产量列出的国家列表中的数据。本文列出了截至 2020 年煤炭产量超过 500 万吨的主权国家和地区。

来自维基百科的数据是根据知识共享署名-类似共享 3.0 未授权许可的条款使用的。

我按照有用且实用的步骤从网上下载数据，将维基百科的一个表格抓取到一个数据帧。

下载后，用 BeautifulSoup 解析下载的数据

在这篇文章中，我将选择一些 2020 年煤炭产量的欧洲国家。例如，选定的国家有俄罗斯、德国、波兰、捷克共和国、乌克兰、罗马尼亚、希腊和保加利亚。

如果您想选择其他国家或更改年份，请随意修改下面的代码。

list_country = ['Russia', 'Germany', 'Poland', 'Czech Republic',
                'Ukraine', 'Romania', 'Greece', 'Bulgaria']

熔化数据帧，并创建一个百分比列以备后用

在继续之前，让我们绘制一个饼图，以便与本文后面获得的结果进行比较。

饼图显示了 2020 年煤炭产量超过 500 万吨的欧洲国家的比例。与所选数据集中的其他国家/地区进行比较时的百分比。图片由作者提供。

数据可视化

本文将介绍 9 种可视化方法来代替饼图。这些备选方案可分为两组:

圆形图形

• 哑铃图(又名杠铃图)
• 泡泡图
• 圆形包装
• 交互式饼图
• 交互式圆环图

其他形式

• 树形图
• 华夫饼图表
• 条形图
• 堆积条形图

1 用哑铃图(又名杠铃图)比较每个类别

哑铃图是比较两个数据点的图表。如前所述，比较饼图中的切片可能很困难。我们可以用哑铃图对每一类进行比较。

顾名思义，哑铃图由两个用一条直线统一的圆形图形组成。通常，Dumbell 图表用于比较数据值。在本文中，我们将设置 X 轴范围从 0 到 100 %,以显示煤炭产量的百分比。

例如，我们可以比较国家或显示每个国家与其他国家相比的百分比。首先，我们将创建另一个数据框架来应用哑铃图。

画出 2020 年煤炭产量最高的两个国家

哑铃图比较了所选数据集中 2020 年煤炭产量最高的两个欧洲国家。图片由作者提供。

画出每个国家与其他国家相比的百分比

哑铃形图表显示了与所选数据集中其他国家的数据相比，每个欧洲国家的煤炭产量的百分比。图片由作者提供。

结果看起来不错，但是数据点都是相等的。这可能不方便进行国与国之间的比较。我们可以通过根据百分比值改变圆形大小来改善结果。不同的尺寸将有助于比较不同类别的百分比。

哑铃形图表显示了与所选数据集中其他国家的数据相比，每个欧洲国家的煤炭产量的百分比。图片由作者提供。

2 使用带有气泡图的圆形区域

我们可以使用气泡图中的多个圆，而不是饼图中的一个圆。基本上，气泡图是一个具有不同大小数据点的散点图。这是显示三维数据、X 值、Y 值和数据大小的理想绘图。

使用气泡图替代饼图的好处是，我们不必担心 X 和 Y 值。气泡可以按照我们想要的方式定位。例如，让我们水平绘制气泡。

在绘制之前对值进行排序将使结果看起来有条理。

添加 X 和 Y 列

df_coal['Y'] = [1]*len(df_coal)
list_x = list(range(0,len(df_coal)))
df_coal['X'] = list_x
df_coal

绘制气泡图

气泡图显示了 2020 年煤炭产量超过 500 万吨的欧洲国家。与所选数据集中的其他国家/地区进行比较时的百分比。图片由作者提供。

应用气泡图的一个问题是绘图空间。绘制的圆越多，需要的面积就越大。

3 用圆形包装组织气泡

圆形包装由多个具有较少间隙和无重叠区域的圆形组成。当处理许多圆形图形时，这种技术有助于节省绘图空间。

圆形包装的一个缺点是很难区分大小相*的气泡。一个简单的解决方法是给每个圈标上它的信息。

在绘图之前，我们需要计算每个圆的大小和位置。幸运的是，可以使用一个名为 circlify 的库来简化计算。

绘制圆形包装

圆形包装显示了 2020 年煤炭产量超过 500 万吨的欧洲国家。与所选数据集中的其他国家/地区进行比较时的百分比。图片由作者提供。

4 坚持用饼状图……没问题……我们来做个互动饼状图吧。

尽管饼状图有一些缺点，如前所述，我们不能否认它很容易理解。了解你的观众是必须的。如果你的读者不*惯复杂的图表，饼图仍然是传达信息的好选择。

我们可以制作一个交互式饼图来改进一个典型的饼图。通过这样做，读者可以过滤和处理图表，以获得他们想要的数据。然而，有时，读者可能不知道这些功能。应该有说明或注释来告知如何使用它。

Plotly 是一个创建交互式图表的有用库。

交互式饼图显示了 2020 年煤炭产量超过 500 万吨的每个欧洲国家。与所选数据集中的其他国家/地区进行比较时的百分比。图片由作者提供。

5 切掉中心，创建一个交互式圆环图

实际上，圆环图是一个中间空白的饼图。顺便说一下，一些消息来源解释说它比饼状图有一些优势，例如便于读者叙述或者可以在中心添加更多信息( link1 和 link2 )。

交互式圆环图与交互式饼图有一些相同的优点和缺点。我们还可以用 Plotly 创建一个交互式圆环图。

交互式圆环图显示了 2020 年煤炭产量超过 500 万吨的每个欧洲国家。与所选数据集中的其他国家/地区进行比较时的百分比。图片由作者提供。

6 使用带树形图的矩形区域

理论上，树形图是显示分层数据的可视化方式。在一个大矩形内，使用多个矩形区域来比较比例。即使我们的数据没有层次，我们仍然可以应用该方法来显示比例贡献。

与饼图相同，总面积之和等于 100%。

需要考虑的一件事是，如果价值观之间有太多的类别或差异，小区域可能很难与其他区域区分开来。

绘制一张树状图

Treemap 显示了 2020 年煤炭产量超过 500 万吨的欧洲国家。与所选数据集中的其他国家/地区进行比较时的比例。图片由作者提供。

7 将小矩形与华夫饼图表结合起来

我们使用了一个饼图和圆环图；现在是时候做一个华夫图了。有了这个花里胡哨的名字，这个图形将多个大小相同的小矩形组合成一个大矩形图形。

华夫格图通常用于显示任务的进度百分比。因此，我们可以应用这个概念来显示分类数据的百分比。

绘制一个华夫饼图表

华夫格图显示了 2020 年煤炭产量超过 500 万吨的欧洲国家。与所选数据集中的其他国家/地区进行比较时的百分比。图片由作者提供。

尽管结果看起来不错，但可以注意到区分相*的颜色可能很困难。这可能是对许多分类数据应用华夫图的一个缺点。

为了解决这个问题，我们可以绘制每个类别的百分比，并将它们组合成一张照片拼贴画。请注意，下面代码的结果将被导出到您的计算机上，以便以后导入。

绘制华夫饼图表的结果，该图表显示每个国家相对于所选数据集中其他国家的百分比。图片由作者提供。

定义一个函数来创建一个照片拼贴。我在下面找到了一段很棒的代码，用来组合来自 Stack Overflow( link )的情节。

应用该功能

# to create a fit photo collage: 
# width = number of columns * figure width
# height = number of rows * figure heightget_collage(1, 7, 644, 123*7, keep_sname, 'collage_waffle.png')

瞧啊。！

华夫格图显示了 2020 年煤炭产量超过 500 万吨的每个欧洲国家。与所选数据集中的其他国家/地区进行比较时的百分比。图片由作者提供。

现在我们可以比之前的结果更清楚地看到每个国家的百分比。照片拼贴也可以用作信息图。

第八回 基本带条形图

另一个典型的图形是条形图，它是一个二维图形，在 X 轴或 Y 轴上有矩形条。这些条形用于通过比较高度或长度来分析数据值。与饼图相比，条形图需要更多的空间来处理大量的类别。

在本文中，我们将通过使用 Plotly 来改进一个普通的条形图，当光标悬停在条形图上时显示信息。建议在绘图前对数据进行排序，以便于分析。

创建交互式条形图的一个好处是，当光标悬停在每个条形图上时，带有小注释文本的类别更容易阅读。

条形图显示了 2020 年煤炭产量超过 500 万吨的每个欧洲国家。与所选数据集中的其他国家/地区进行比较时的百分比。图片由作者提供。

9 使用堆叠条形图节省空间

堆积条形图是一种显示单个数据点占总数的比例的条形图。根据这个概念，我们将应用一个堆积条形图来显示我们拥有的数据的比例。总面积等于 100%。

它和条形图有同样的问题。如果有太多的类别或类别之间的差异，小区域可能很难阅读。创建交互式堆积条形图将有助于在光标悬停在该区域上时显示信息。

绘制堆积条形图

堆积条形图显示了 2020 年煤炭产量超过 500 万吨的每个欧洲国家。与所选数据集中的其他国家/地区进行比较时的百分比。图片由作者提供。

我们可以注意到，在这种情况下，堆积条形图与条形图相比可以节省绘图区域。

总结

饼图是典型的数据可视化。它具有节省绘图空间、易于理解等优点。然而，没有什么是完美的。有一些缺点，如读者很难估计数量，信息可能会被扭曲。

这篇文章展示了 9 种替代饼图的方法。请考虑到它们也各有利弊。

我敢肯定，除了本文中提到的，还有更多图表可以显示比例或百分比。如果有什么建议，欢迎留言。

最后，条形图是另一个和饼图一样常用的图表。顺便说一句，使用太多的条形图可能会导致单调的显示。如果你正在寻找可以代替条形图使用的想法，你可能会发现文章 9 可视化比条形图更吸引人的注意。

感谢阅读。

以下是您可能会感兴趣的关于数据可视化的其他文章:

• 9 个比条形图更引人注目的 Python 可视化(链接)
• 用 Python 处理超长时间序列数据的 6 个可视化技巧(链接)
• 8 用 Python 处理多个时序数据的可视化(链接)
• 使用 Python ( 链接)最大化聚类散点图

参考文献

• 维基媒体基金会。(2022 年 4 月 21 日)。煤炭生产国家列表。维基百科。2022 年 9 月 3 日检索，来自https://en . Wikipedia . org/wiki/List _ of _ countries _ by _ coal _ production
• 拉克霍迪亚，N. (2021 年 1 月 11 日)。将维基百科表格抓取成数据帧。中等。2022 年 8 月 3 日检索，来自https://medium . com/analytics-vid hya/web-scraping-a-Wikipedia-table-into-a-data frame-c 52617 E1 f 451

用一行代码加载 93 个数据集

原文：https://towardsdatascience.com/93-datasets-that-load-with-a-single-line-of-code-7b5ffe62b655

你如何即时地从几十个例子中找出一个政治、体育、教育和其他框架。

TLDR:如果你对老一套的示例数据感到厌倦，请将这篇文章收藏起来。它会向你展示* 100 个你以前可能没有用过的例子。每个示例加载一行代码。

例子来自政治、教育、健康、体育、科技，也只是为了好玩。

图片来源:作者在 Canva 创作的插图。

介绍

F 数据科学中的培训、测试、演示或其他相关目的需要数据。快速加载示例数据集(在一行代码中)通常非常容易。如果你像我一样，也许你已经陷入了有一个或两个“去”选择的实践中。

为了增加工作的多样性，我列出了一行代码中加载的* 100 个数据源。我希望其他人也会发现这个列表很有用。

数据来源按字母顺序包括:datausa.io、ESPN(体育)、五卅八(体育、政治、其他)、维基百科等。在准备本文时，我避免了一些更常见的数据源选项，比如 Kaggle。这篇文章是关于扩展我们的工作到新的例子。

因为我搜寻了一些不太常见的例子，所以本文将向您展示如何在一行代码中快速加载一系列数据帧，从而拓宽您的视野。

本文将展示 Python、R 和 Stata 中的许多数据框。本文底部讨论的一些限制。

为什么是三个软件

为什么不是三个？真的，不管你用的最多的编码语言是什么，我只是想尽可能的帮助更多的人。我用 Python 演示了每一个例子。大多数例子也引用 Stata 和/或 r。

这三个软件选项是我最常使用的三个。你想在这里看到另一种语言吗？让我知道，我们可以合作添加第四个(或第五个)。此外，如果您还不知道:

Python——“Python 是一种编程语言，可以让你快速工作，更有效地集成系统。”Python.org对于大多数数据工作，您还需要 Pandas——它是“一个快速、强大、灵活且易于使用的开源数据分析和操作工具，构建于 Python 编程语言之上。”Pandas.Pydata.org。同样有用的是，这篇文章大量使用了pd.read_html()。我建议读者也阅读一下这个方便的熊猫方法的完整文档。

R—“R 是一个用于统计计算和图形的自由软件环境。它可以在多种 UNIX 平台、Windows 和 MacOS 上编译和运行。”R-Project.org。在 R 中从在线 csv 文件加载数据的主要工具是read.csv()。

stata——“数据科学的统计软件”Stata.com。以下解决方案使用 Stata 的import delimited命令(用于 CSV 文件)及其use命令(用于 Stata dta 文件)。这两个命令都支持 url internet 网址。

1–4538 数据

根据维基百科，“FiveThirtyEight，有时被翻译为 538，是一个专注于民意调查分析、政治、经济和体育博客的美国网站。”该网站还提供或制作博客、YouTube 视频和播客。

到目前为止，我还没有找到一个优雅的解决方案，可以从网上找到的zip文件中获取数据，然后在一行代码中加载所有数据。如果有人有，告诉我。同时，也值得一读Five 38 的数据存档，它将大部分数据封装在一个zip中。

支持率调查结果

我想到我会在下学期的统计学课上把这些数据推荐给学生。这将是他们学期项目的素材。

# Python
pd.read_csv('[https://projects.fivethirtyeight.com/polls/data/favorability_polls.csv'](https://projects.fivethirtyeight.com/polls/data/favorability_polls.csv'))// Stata
import delimited [https://raw.githubusercontent.com/mwaskom/seaborn-data/master/attention.csv](https://raw.githubusercontent.com/adamrossnelson/BirdsDataCreation/main/BirdVarietyData_March2021.csv)# R
read.csv("[https://raw.githubusercontent.com/mwaskom/seaborn-data/master/attention.csv](https://raw.githubusercontent.com/adamrossnelson/BirdsDataCreation/main/BirdVarietyData_March2021.csv)")

去年总统民调结果

这个有 16，700 多行。

# Python
pd.read_csv('[https://projects.fivethirtyeight.com/polls/data/president_polls_historical.csv](https://projects.fivethirtyeight.com/polls/data/president_polls_historical.csv)')// Stata
import delimited [https://projects.fivethirtyeight.com/polls/data/president_polls_historical.csv](https://projects.fivethirtyeight.com/polls/data/president_polls_historical.csv)# R
read.csv("[https://projects.fivethirtyeight.com/polls/data/president_polls_historical.csv](https://projects.fivethirtyeight.com/polls/data/president_polls_historical.csv)")

参议院和众议院投票结果(历史性)

# Python House
pd.read_csv('[https://projects.fivethirtyeight.com/polls/data/house_polls_historical.csv](https://projects.fivethirtyeight.com/polls/data/house_polls_historical.csv)')
# Python Senate
pd.read_csv('[https://projects.fivethirtyeight.com/polls/data/senate_polls_historical.csv](https://projects.fivethirtyeight.com/polls/data/senate_polls_historical.csv)')// Stata House
import delimited [https://projects.fivethirtyeight.com/polls/data/house_polls_historical.csv](https://projects.fivethirtyeight.com/polls/data/house_polls_historical.csv)
// Stata Senate
import delimited [https://projects.fivethirtyeight.com/polls/data/senate_polls_historical.csv](https://projects.fivethirtyeight.com/polls/data/senate_polls_historical.csv)# R House
read.csv("[https://projects.fivethirtyeight.com/polls/data/house_polls_historical.csv](https://projects.fivethirtyeight.com/polls/data/house_polls_historical.csv)")
# R Senate
read.csv("[https://projects.fivethirtyeight.com/polls/data/senate_polls_historical.csv](https://projects.fivethirtyeight.com/polls/data/senate_polls_historical.csv)")

5–11 个杂项启动器数据文件

这些鲜为人知的资源是从网上收集的数据。它们中很少是用来作为数据源的。然而，它们很有用，值得一看。

全球食品价格

这需要一段时间(大文件包括 2，050，638 条记录和 18 列)。

# Python
pd.read_csv('[https://data.humdata.org/dataset/4fdcd4dc-5c2f-43af-a1e4-93c9b6539a27/resource/12d7c8e3-eff9-4db0-93b7-726825c4fe9a/download/wfpvam_foodprices.csv](https://data.humdata.org/dataset/4fdcd4dc-5c2f-43af-a1e4-93c9b6539a27/resource/12d7c8e3-eff9-4db0-93b7-726825c4fe9a/download/wfpvam_foodprices.csv)')// Stata
import delimited [https://data.humdata.org/dataset/4fdcd4dc-5c2f-43af-a1e4-93c9b6539a27/resource/12d7c8e3-eff9-4db0-93b7
726825c4fe9a/download/wfpvam_foodprices.csv](https://data.humdata.org/dataset/4fdcd4dc-5c2f-43af-a1e4-93c9b6539a27/resource/12d7c8e3-eff9-4db0-93b7-726825c4fe9a/download/wfpvam_foodprices.csv)# R
read.csv("[https://data.humdata.org/dataset/4fdcd4dc-5c2f-43af-a1e4-93c9b6539a27/resource/12d7c8e3-eff9-4db0-93b7-726825c4fe9a/download/wfpvam_foodprices.csv](https://data.humdata.org/dataset/4fdcd4dc-5c2f-43af-a1e4-93c9b6539a27/resource/12d7c8e3-eff9-4db0-93b7-726825c4fe9a/download/wfpvam_foodprices.csv)")

维基百科 HTML 表格

维基百科中的表格经常需要改进。它们不是为数据分析而优化的。如果您正在寻找关于数据清理、准备或争论主题的示例数据，这些表格是很好的选择，因为它们模拟了没有为分析目的准备的“真实世界”数据。

这些数据的另一个挑战是 Python Pandas 有一个开发良好且成熟的读取 HTML 数据表的解决方案。Stata 和 R 中的等效解决方案不太成熟。因此，本节只提供 Python 代码。

蛇(真蟒蛇)易于在其他平台加载pd.read_html()及相关工具。

# Python
pd.read_html('[https://en.wikipedia.org/wiki/Pythonidae')[2](https://en.wikipedia.org/wiki/Pythonidae')[2)]

列出了 10 种蟒蛇的表格。图片鸣谢:亚当·罗斯·尼尔森(作者)。

美国 NFL 体育场的桌子怎么样？运动爱好者的好选择。

# Python
pd.read_html('https://en.wikipedia.org/wiki/National_Football_League')[3]

美国总统的名单。

# Python
pd.read_html('https://en.wikipedia.org/wiki/List_of_presidents_of_the_United_States')[1]

世界国家列表。

# Python
pd.read_html('https://en.wikipedia.org/wiki/List_of_sovereign_states')[0]

英国人口普查数据

# Python
pd.read_html('[https://en.wikipedia.org/wiki/London](https://en.wikipedia.org/wiki/London)')[6]

英国人口普查数据是展示快速饼状图的好地方。

df['2011 United Kingdom Census[223]'].loc[1:]\
   .set_index('Country of birth')\
   .plot.pie(y='Population', 
             legend=False)

饼状图中来自维基百科的英国人口普查数据。图片鸣谢:亚当·罗斯·尼尔森(作者)。

州缩写和代码

你多久需要一次州名缩写和代码的列表(在美国)？Clerk.org 来救援了。

# Python
states = pd.read_html(http://app02.clerk.org/menu/ccis/Help/CCIS%20Codes/state_codes.html)[0]

12–16 来自 ESPN.com 的数据

NFL 球场上座率记录。这些数据是过去 20 年的。以下是过去 5 年的代码。有人对想象疫情的萧条感兴趣吗？

# Python
pd.read_html('[http://www.espn.com/nfl/attendance/_/year/2021'](http://www.espn.com/nfl/attendance/_/year/2021'), 
             header=1)[0]
pd.read_html('[http://www.espn.com/nfl/attendance/_/year/2020'](http://www.espn.com/nfl/attendance/_/year/2021'), 
             header=1)[0]
pd.read_html('[http://www.espn.com/nfl/attendance/_/year/2019'](http://www.espn.com/nfl/attendance/_/year/2021'), 
             header=1)[0]
pd.read_html('[http://www.espn.com/nfl/attendance/_/year/2018'](http://www.espn.com/nfl/attendance/_/year/2021'), 
             header=1)[0]
pd.read_html('[http://www.espn.com/nfl/attendance/_/year/2017'](http://www.espn.com/nfl/attendance/_/year/2021'), 
             header=1)[0]

17 只假鸟

所谓的假鸟数据来自我之前的一些文章，这些文章演示了生成假数据的过程，后来还演示了 k *邻。您可以使用以下内容加载这些数据:

# Python
pd.read_csv('[https://raw.githubusercontent.com/adamrossnelson/BirdsDataCreation/main/BirdVarietyData_March2021.csv](https://raw.githubusercontent.com/adamrossnelson/BirdsDataCreation/main/BirdVarietyData_March2021.csv)')// Stata
import delimited [https://raw.githubusercontent.com/adamrossnelson/BirdsDataCreation/main/BirdVarietyData_March2021.csv](https://raw.githubusercontent.com/adamrossnelson/BirdsDataCreation/main/BirdVarietyData_March2021.csv)# R
read.csv("[https://raw.githubusercontent.com/adamrossnelson/BirdsDataCreation/main/BirdVarietyData_March2021.csv](https://raw.githubusercontent.com/adamrossnelson/BirdsDataCreation/main/BirdVarietyData_March2021.csv)")

虚构的鸟类数据。图片鸣谢:亚当·罗斯·尼尔森(作者)。

18–26 作为数据源的 Stata 集合

如上所述，Stata 是一个统计、数据分析和数据科学平台，它还附带有大量数据，可用于培训演示。下面的代码将加载我最喜欢的十个选项，包括 auto(类似于 Seaborn 的 mpg)、bplong、bpwide(虚构的血压)、cancer(药物试验数据中的患者存活率)、Census(stata 提供的 1980 年美国人口普查数据)、nlsw88(全国妇女纵向调查，1988 年摘录)、sp500(标准普尔 500 股票数据)和 voter (1992 年美国总统选举人)。

# Python
pd.read_stata('http://www.stata-press.com/data/r15/auto.dta')
pd.read_stata('http://www.stata-press.com/data/r15/bplong.dta')
pd.read_stata('http://www.stata-press.com/data/r15/bpwide.dta')
pd.read_stata('http://www.stata-press.com/data/r15/cancer.dta')
pd.read_stata('http://www.stata-press.com/data/r15/census.dta')
pd.read_stata('http://www.stata-press.com/data/r15/nlsw88.dta')
pd.read_stata('http://www.stata-press.com/data/r15/sp500.dta')
pd.read_stata('http://www.stata-press.com/data/r15/voter.dta')
pd.read_stata('http://www.stata-press.com/data/r15/pop2000.dta')// Stata
sysuse auto
sysuse bplong
sysuse bpwide
sysuse cancer
sysuse census
sysuse nlsw88
sysuse sp500
sysuse 2p500
sysuse voeter

Stata 自带的一些数据也可以从其他来源获得。例如，nlsw88数据也在 rdrr.io 和rdocumentation.org处。

27–36 作为数据源的 Seaborn 集合

Seaborn 附带的数据众所周知。网上一些最好的项目例子涉及到 Seaborn 收录库中的数据。我最喜欢用tips数据来教初学者统计学。

对于中级或有经验的用户来说，这些 Seaborn 数据是经常使用的。它们被设计成可以在 Python 中快速加载。然而，如果你在 Stata(或者其他可以在线打开 CSV 的工具)中，你也可以使用这些。各种聪明的解决方案将 Seaborn 带到了 R。然而，要在 R 中使用这些数据，最简单的方法是使用 R 的read.csv()。

在这里，我演示了多个单行选项，加载我的 Seaborn 收藏夹注意，车祸，锻炼，企鹅，mpg，钻石，航班，虹膜，提示和泰坦尼克号数据。

# Python
df = sns.load_dataset('attention')
df = sns.load_dataset('car_crashes')
df = sns.load_dataset('exercise')
df = sns.load_dataset('penguins')
df = sns.load_dataset('mpg')
df = sns.load_dataset('diamonds')
df = sns.load_dataset('flights')
df = sns.load_dataset('iris')
df = sns.load_dataset('tips')
df = sns.load_dataset('titanic')// Stata
import delimited [https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)attention.csvimport delimited [https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)car_crashes.csvimport delimited [https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)exercise.csvimport delimited [https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)import delimited [https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv)import delimited [https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)diamonds.csvimport delimited [https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)flights.csvimport delimited [https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)iris.csvimport delimited [https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)tips.csvimport delimited [https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)titanic.csv# In R
read.csv("[https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)attention.csv")
read.csv("[https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)car_crashes.csv")
read.csv("[https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)exercise.csv")
read.csv("[https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)")
read.csv("[https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv)")
read.csv("[https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)diamonds.csv")
read.csv("[https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)flights.csv")
read.csv("[https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)iris.csv")
read.csv("[https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)tips.csv")
read.csv("[https://raw.githubusercontent.com/mwaskom/seaborn-data/master/](https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv)titanic.csv")

37–53 数据 USA.io 数据

该网站负责分享来自美国政府的数据。数据涉及一系列主题，包括城市、州、行业、工作、大学、学位、健康等等。该平台还支持用户在线生成可视化的能力，而无需首先下载数据。

此外，从技术上讲，在 Python 中，这段代码需要一个额外的导入import requests。不要把它算作第二行代码(我不这么认为)。

城市数据示例

纽约州纽约市所说的世界语言。

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?Geography=16000US3651000&' \
                  + 'measure=Languages%20' \
                  + 'Spoken&drilldowns=Language%20' \
                  + 'Spoken%20at%20Home')\
             .json()['data'])

伊利诺伊州芝加哥出生年龄(出生地)。

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?Geography=16000US1714000&' \
                  + 'measures=Birthplace,Birthplace%20' \
                  + 'Moe&drilldowns=Place%20of%20Birth,Age')\
             .json()['data'])

状态数据示例

弗吉尼亚外国战争的退伍军人。下表比较了

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?Geography=04000US51,01000US&' \
                  + 'measure=Veterans,Veterans%20' \
                  + 'Moe&drilldowns=Period%20of%20Service')\
             .json()['data'])

该数据概述了明尼苏达州与邻*各州相比的美国公民百分比。

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?measure=Citizenship%20' \
                  + 'Status&drilldowns=' \
                  + 'Citizenship&Geography=04000US27,' \
                  + '04000US27:neighbors,' \
                  + '04000US27:parents,04000US27:similar')\
             .json()['data'])

行业数据示例

高薪职业(医生)。

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?PUMS%20Industry=31-33&measure=Total%20' \
                  + 'Population,Total%20Population%20MOE%20' \
                  + 'Appx,Average%20Wage,Average%20Wage%20' \
                  + 'Appx%20MOE,yiopop%20RCA,Record%20' \
                  + 'Count&Record%20Count%3E=5&Workforce%20' \
                  + 'Status=true&drilldowns=Detailed%20' \
                  + 'Occupation&order=Average%20Wage&sort=desc')\
             .json()['data'])

分行业收入分配。

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?Geography=01000US&measure=' \
                  + 'Total%20Population,Total%20' \
                  + 'Population%20MOE%20Appx,Record%20' \
                  + 'Count&drilldowns=Wage%20' \
                  + 'Bin&Workforce%20Status=true&Record%20' \
                  + 'Count>=5')\
             .json()['data'])

收入分配数据。图片鸣谢:亚当·罗斯·尼尔森(作者)。

作业数据示例

失业保险索赔。

# Python
pd.DataFrame(requests\
     .get('[https://datausa.io/api/covid19/employment/latest/')\](https://datausa.io/api/covid19/employment/latest/')\)
     .json()['data'])

按工业部门分列的失业情况。

# Python
pd.DataFrame(requests\
             .get('[https://api-ts-uranium.datausa.io/'](https://api-ts-uranium.datausa.io/') \
                  + 'tesseract/data.jsonrecords?cube=BLS%20' \
                  + 'Employment%20-%20Supersector%20' \
                  + 'Only&drilldowns=Month%20of%20' \
                  + 'Year,Supersector&measures=NSA%20' \
                  + 'Employees&State=04000US06') \
             .json()['data'])

经济学

中等家庭收入。

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?measure=Household%20' \
                  + 'Income%20by%20Race,Household%20' \
                  + 'Income%20by%20Race%20' \
                  + 'Moe&Geography=04000US06:' \
                  + 'neighbors:parents,04000US06,' \ 
                  + '04000US06:similar') \
             .json()['data'])

普通工作中按性别分列的工资。

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?Geography=04000US06' \
                  + '&measure=Average%20Wage,Average%20' \
                  + 'Wage%20Appx%20MOE,Total%20' \
                  + 'Population,Total%20Population%20' \
                  + 'MOE%20Appx,Record%20' \
                  + 'Count&drilldowns=Gender&Employment%20' \
                  + 'Time%20Status=1&Detailed%20' \
                  + 'Occupation=1191XX,412010,412031,' \
                  + '533030,291141&Record%20Count%3E=5')\
             .json()['data'])

大学数据示例

比较菲尼克斯-亚利桑那大学按收入分组的财政资助和其他机构和机构类型按收入分组的财政资助。机构类型包括

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?University=484613:' \
                  + 'similar,484613,484613:parents&' \
                  + 'measures=Median%20Grant%20' \
                  + 'Or%20Scholarship%20' \
                  + 'Award&drilldowns=Income%20Range')\
             .json()['data'])

按机构类型分列的录取率。对于这一项，你必须用被录取的学生人数除以被录取的学生人数来计算录取率。

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?University=15:similar,15,15:' \
                  + 'parents&measures=Admissions%20' \
                  + 'Total,Applicants%20Total')\
             .json()['data'])

在计算出接受率后，Pandas 迅速进行了数据可视化工作。

按大学类型显示录取率的条形图。图片鸣谢:亚当·罗斯·尼尔森(作者)。

学位数据示例

该网站通过 CIP 代码对其学位数据进行排序和组织。如果你不熟悉 CIP 代码，它们是“教学程序分类”代码。这些代码表示支持准确跟踪和报告研究领域/学术专业的方案。

由郡授予的学位(在美国)。

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?CIP=2401&drilldowns=' \
                  + 'County&measure=Completions')\
             .json()['data'])

按学位类型授予的学位。

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?CIP=2401&measure=' \
                  + 'Completions&drilldowns=' \
                  + 'Degree&order=Completions&sort=desc')\
             .json()['data'])

健康数据示例

患者与初级保健比率。

pd.DataFrame(requests\
             .get('[https://datausa.io/api/'](https://datausa.io/api/') \
                  + 'data?measure=Patient%20to%20' \
                  + 'Primary%20Care%20Physician%20' \
                  + 'Ratio,Patient%20to%20Primary%20' \
                  + 'Care%20Physician%20Ratio%20' \
                  + 'Data%20Source%20Years&Geography=' \
                  + '04000US06:neighbors,04000US06') \
             .json()['data'])

每天的新 Covid 病例。

# Python
pd.DataFrame(requests\
             .get('[https://datausa.io/api/covid19/statesnew')\](https://datausa.io/api/covid19/statesnew')\)
             .json()['data'])

54–59 犯罪数据

该数据最初来自 fbi.gov，包括人口数据和按类别分类的犯罪数据(财产、盗窃、暴力等)。)从 1960 年到 2019 年的美国各州。感谢瑞安·惠特科姆、朱明财和管波，他们通过 GitHub 维护这个网站，省去了从.zip文件中挖掘数据的需要。

# Python
pd.read_csv('[https://corgis-edu.github.io/'](https://corgis-edu.github.io/') \
            + 'corgis/datasets/csv/state_crime/' \
            + 'state_crime.csv')// Stata
import delimited [https://corgis-edu.github.io/corgis/datasets/csv/state_crime/state_crime.csv](https://corgis-edu.github.io/corgis/datasets/csv/state_crime/state_crime.csv)# R
read.csv("[https://corgis-edu.github.io/corgis/datasets/csv/state_crime/state_crime.csv](https://corgis-edu.github.io/corgis/datasets/csv/state_crime/state_crime.csv)")

服务呼叫

这里的每个例子有* 500，000 条记录，是过去几年里来自新奥尔良市的“服务电话”。点击前往 data.gov 探索岁月。

# Python (2016)
pd.read_csv('[https://data.nola.gov/'](https://data.nola.gov/') \
            + 'api/views/wgrp-d3ma/' \
            + 'rows.csv?accessType=DOWNLOAD')
# Python (2015)
pd.read_csv('[https://data.nola.gov/'](https://data.nola.gov/') \
            + 'api/views/w68y-xmk6/' \
            + 'rows.csv?accessType=DOWNLOAD')
# Python (2014)
pd.read_csv('[https://data.nola.gov/'](https://data.nola.gov/') \
            + 'api/views/jsyu-nz5r/' \
            + 'rows.csv?accessType=DOWNLOAD')// Stata (2016)
import delimited [https://data.nola.gov/](https://data.nola.gov/')api/views/wgrp-d3ma/rows.csv?accessType=DOWNLOAD
// Stata (2015)
import delimited [https://data.nola.gov/](https://data.nola.gov/')api/views/w68y-xmk6/rows.csv?accessType=DOWNLOAD
// Stata (2014)
import delimited [https://data.nola.gov/](https://data.nola.gov/')api/views/jsyu-nz5r/rows.csv?accessType=DOWNLOAD# R (2016)
read.csv("[https://data.nola.gov/](https://data.nola.gov/')api/views/wgrp-d3ma/rows.csv?accessType=DOWNLOAD")
# R (2015)
read.csv("[https://data.nola.gov/](https://data.nola.gov/')api/views/w68y-xmk6/rows.csv?accessType=DOWNLOAD
# R (2014)")
read.csv("[https://data.nola.gov/](https://data.nola.gov/')api/views/jsyu-nz5r/rows.csv?accessType=DOWNLOAD")

纽约市停止提问和搜身数据

这个有争议的项目包括由纽约市警察随机截停、盘问和搜身。NYC.gov 网站公布了这些数据。如下所示，CSV 中仅包含部分年份。

# Python (2016)
pd.read_csv('[https://www1.nyc.gov/'](https://www1.nyc.gov/') \
            + 'assets/nypd/downloads/' \
            + 'excel/analysis_and_planning/' \
            + 'stop-question-frisk/sqf-2016.csv')
# Python (2015)
pd.read_csv('[https://www1.nyc.gov/'](https://www1.nyc.gov/') \
            + 'assets/nypd/downloads/' \
            + 'excel/analysis_and_planning/' \
            + 'stop-question-frisk/sqf-2015.csv')// Stata (2016)
import delimited [https://www1.nyc.gov/assets/nypd/downloads/excel/analysis_and_planning/stop-question-frisk/sqf-2016.csv](https://www1.nyc.gov/assets/nypd/downloads/excel/analysis_and_planning/stop-question-frisk/sqf-2016.csv)
// Stata (2015)
import delimited [https://www1.nyc.gov/assets/nypd/downloads/excel/analysis_and_planning/stop-question-frisk/sqf-2015.csv](https://www1.nyc.gov/assets/nypd/downloads/excel/analysis_and_planning/stop-question-frisk/sqf-2015.csv)# R (2016)
read.csv("[https://www1.nyc.gov/assets/nypd/downloads/excel/analysis_and_planning/stop-question-frisk/sqf-2016.csv](https://www1.nyc.gov/assets/nypd/downloads/excel/analysis_and_planning/stop-question-frisk/sqf-2016.csv)")
# R (2015)
read.csv("[https://www1.nyc.gov/assets/nypd/downloads/excel/analysis_and_planning/stop-question-frisk/sqf-2015.csv](https://www1.nyc.gov/assets/nypd/downloads/excel/analysis_and_planning/stop-question-frisk/sqf-2016.csv)")

60 个虚构的平均绩点数据

大多数学校(高中或大学)的学生在任何一个学期的平均绩点都有独特的分布。这个虚构的数据复制了这种分布。多种多样的变量让你试验学期 gpa，累计 gpa，专业，经济资助等。

# Python
pd.read_stata('[https://raw.githubusercontent.com/'](https://raw.githubusercontent.com/') \
              + 'adamrossnelson/StataQuickReference/' \
              + 'master/exampledata/mock_fictional_gpa.dta')// Stata
use https://raw.githubusercontent.com/adamrossnelson/StataQuickReference/master/exampledata/mock_fictional_gpa.dta

这是虚构的学期 gpa 数据的独特分布(以直方图的形式)。

虚构 GPA 数据的直方图。图片鸣谢:亚当·罗斯·尼尔森(作者)。

61–66 来自 Burkardt 教授

偶尔，教授或老师会在网上收藏一些数据文件。数学和软件教授 burkardt有大约 50 个 CSV 文件。在本文中，我将展示如何在一行代码中加载其中的 10 个。

airtravel.csv-1958-1960 年间，每月横跨大西洋的航空旅行，乘客数以千计。有 4 个字段，“月”、“1958 年”、“1959 年”和“1960 年”，以及 12 个记录，“一月”到“十二月”。还有一个初始标题行。

ford_excorts.csv——福特护航待售。有 23 条年份，里程，价格的记录。

homes.csv-国内销售统计。五十家销售，销售价格，要价，居住面积，房间，卧室，浴室，年龄，面积，税收。

hw_25000.csv——25000 个人的身高体重每条记录包括 3 个值:指数、身高(英寸)、体重(磅)。

news_decline.csv-2009-2011 年 6 个电视新闻杂志的平均每夜收视率。每个记录包括 4 个值:显示名称，2009，2010，2011。存储了六个记录，分别是“60 分钟”、“48 小时神秘”、“20/20”、“晚间新闻”、“星期五日期新闻”和“星期日日期新闻”

# Python
pd.read_csv('[https://people.sc.fsu.edu/~jburkardt/data/csv/airtravel.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/airtravel.csv)')
pd.read_csv('[https://people.sc.fsu.edu/~jburkardt/data/csv/ford_escort.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/ford_escort.csv)')
pd.read_csv('[https://people.sc.fsu.edu/~jburkardt/data/csv/homes.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/homes.csv)')
pd.read_csv('[https://people.sc.fsu.edu/~jburkardt/data/csv/hw_25000.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/hw_25000.csv)')
pd.read_csv('[https://people.sc.fsu.edu/~jburkardt/data/csv/mlb_players.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/mlb_players.csv)')
pd.read_csv('[https://people.sc.fsu.edu/~jburkardt/data/csv/news_decline.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/news_decline.csv)')// Stata
import delimited [https://people.sc.fsu.edu/~jburkardt/data/csv/airtravel.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/airtravel.csv)
import delimited [https://people.sc.fsu.edu/~jburkardt/data/csv/ford_escort.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/ford_escort.csv)
import delimited [https://people.sc.fsu.edu/~jburkardt/data/csv/homes.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/homes.csv)
import delimited [https://people.sc.fsu.edu/~jburkardt/data/csv/hw_25000.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/hw_25000.csv)
import delimited [https://people.sc.fsu.edu/~jburkardt/data/csv/mlb_players.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/mlb_players.csv)
import delimited [https://people.sc.fsu.edu/~jburkardt/data/csv/news_decline.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/news_decline.csv)# R
read.csv("[https://people.sc.fsu.edu/~jburkardt/data/csv/airtravel.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/airtravel.csv)")
read.csv("[https://people.sc.fsu.edu/~jburkardt/data/csv/ford_escort.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/ford_escort.csv)")
read.csv("[https://people.sc.fsu.edu/~jburkardt/data/csv/homes.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/homes.csv)")
read.csv("[https://people.sc.fsu.edu/~jburkardt/data/csv/hw_25000.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/hw_25000.csv)")
read.csv("[https://people.sc.fsu.edu/~jburkardt/data/csv/mlb_players.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/mlb_players.csv)")
read.csv("[https://people.sc.fsu.edu/~jburkardt/data/csv/news_decline.csv](https://people.sc.fsu.edu/~jburkardt/data/csv/news_decline.csv)")

67–68 个欧洲数据源(data.europa.eu)

除颤器

欧洲各地关于除颤器的地理位置数据如何？

# Python
pd.read_csv('[https://admin.aedmap.org/'](https://admin.aedmap.org/') \
            + 'media/upload/defibmap_393_.csv')// Stata
import deliminted [https://admin.aedmap.org/](https://admin.aedmap.org/')media/upload/defibmap_393_.csv# R
read.csv('[https://admin.aedmap.org/](https://admin.aedmap.org/')media/upload/defibmap_393_.csv')

2010 年伦敦年度调查

根据其在 data.europa.eu 上的条目，这一数据“来自 BMG 研究公司在 2010 年初对大伦敦地区 1490 名居民进行的面对面调查……(它探讨了)市长政策和优先考虑的领域，包括治安和安全、环境、交通、奥运会和伦敦生活。”

为了理解这些数据，你将需要数据字典，因为原始数据不包括变量名。

# Python
pd.read_csv('[https://s3-eu-west-1.amazonaws.com/'](https://s3-eu-west-1.amazonaws.com/') \
            + 'londondatastore-upload/' \
            + 'gla-als-2010-responses.csv')// Stata
import delimited [https://s3-eu-west-1.amazonaws.com/londondatastore-upload/gla-als-2010-responses.csv](https://s3-eu-west-1.amazonaws.com/londondatastore-upload/gla-als-2010-responses.csv)# R
read.csv("[https://s3-eu-west-1.amazonaws.com/londondatastore-upload/gla-als-2010-responses.csv](https://s3-eu-west-1.amazonaws.com/londondatastore-upload/gla-als-2010-responses.csv)")

69–71 加州大学欧文分校机器学*知识库

作为对机器学*社区的一项服务，提供了 600 多种数据文件，涉及许多主题和许多格式。在这里找到完整的图书馆。下面是一些值得注意的例子，不一定是最受欢迎的，但很受欢迎。

红酒和白酒

与红色和白色相关的两个数据集。

# Python
pd.read_csv('[https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv](https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv)')
pd.read_csv('[https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv](https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv)')// Stata
import delimited [https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv](https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv)
import delimited [https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv](https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv)# R
read.csv("[https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv](https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv)")
read.csv("[https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv](https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv)")

按姓名分类的性别/按性别分类的姓名

用性别映射名字，并给出计数和概率。

# Python
pd.read_csv('[https://archive.ics.uci.edu/ml/machine-learning-databases/00591/name_gender_dataset.csv](https://archive.ics.uci.edu/ml/machine-learning-databases/00591/name_gender_dataset.csv)')// Stata
import delimited [https://archive.ics.uci.edu/ml/machine-learning-databases/00591/name_gender_dataset.csv](https://archive.ics.uci.edu/ml/machine-learning-databases/00591/name_gender_dataset.csv)# R
read.csv("[https://archive.ics.uci.edu/ml/machine-learning-databases/00591/name_gender_dataset.csv](https://archive.ics.uci.edu/ml/machine-learning-databases/00591/name_gender_dataset.csv)")

72 火山数据

在这里，我展示了你可以从史密森尼博物馆的volcano.si.edu获得的少数数据文件之一。从史密森尼学会网站的一行代码中获取数据有点棘手。但是谷歌的一点魔力在各种 GitHub 网站上找到了他们的文件。注意，对于这个 CSV，代码需要额外的参数来标识带有列名的行号。

# Python
pd.read_csv('[https://raw.githubusercontent.com/'](https://raw.githubusercontent.com/') \
            + 'ptillemans/volcanoes/master/' \
            + 'GVP_Volcano_List_Holocene.csv', header=1)# Stata
import delimited [https://raw.githubusercontent.com/ptillemans/volcanoes/master/GVP_Volcano_List_Holocene.csv](https://raw.githubusercontent.com/ptillemans/volcanoes/master/GVP_Volcano_List_Holocene.csv), varnames(2)

纽约市的 73 只松鼠

来自“纽约市数据部”的数据来自 thesquirrelcensus.com 的纽约松鼠普查。读取数据，但不是真正的纽约市计划，对不对？在 GitHub 的帮助下，只需一行代码就可以加载这些数据。

# Python
pd.read_csv('[https://raw.githubusercontent.com/'](https://raw.githubusercontent.com/') \
            + 'ptillemans/volcanoes/master/' \
            + 'GVP_Volcano_List_Holocene.csv', header=1)// Stata 
import delimited [https://raw.githubusercontent.com/rfordatascience/tidytuesday/master/data/2019/2019-10-29/nyc_squirrels.csv](https://raw.githubusercontent.com/rfordatascience/tidytuesday/master/data/2019/2019-10-29/nyc_squirrels.csv)# R
read.csv('[https://raw.githubusercontent.com/rfordatascience/tidytuesday/master/data/2019/2019-10-29/nyc_squirrels.csv](https://raw.githubusercontent.com/rfordatascience/tidytuesday/master/data/2019/2019-10-29/nyc_squirrels.csv)')

74 份加州车牌申请

2015 年和 2016 年收到的个性化车牌申请(23k +)加州 DMV。显然不是所有的申请。这个会让你咯咯笑。

# Python
pd.read_csv('[https://raw.githubusercontent.com/'](https://raw.githubusercontent.com/') \
            + 'veltman/ca-license-plates/master/' \
            + 'applications.csv')// Stata
import delimited [https://raw.githubusercontent.com/veltman/ca-license-plates/master/applications.csv](https://raw.githubusercontent.com/veltman/ca-license-plates/master/applications.csv)# R
read.csv('[https://raw.githubusercontent.com/veltman/ca-license-plates/master/applications.csv](https://raw.githubusercontent.com/veltman/ca-license-plates/master/applications.csv)')

75–81 个来自 iWebLists.com 的例子

在 iWebLists.com，该网站建议你可以“学*(晦涩难懂的)问题的答案，然后测试你聪明的朋友！”该网站很容易从 Pandas 的 HTML 表格中获取列表。

注意，这个站点的代码需要来自requests.get()的帮助和使用header()参数。不是最漂亮的代码(有更好的实现，但是你可以清理它)。本文的目标是用一行代码演示数据。

持续时间最长的百老汇秀

# Python
pd.read_html(requests.get('[https://www.iweblists.com/'](https://www.iweblists.com/') \
                          + 'entertainment/broadway/' \
                          + 'LongestRunningBroadwayShows.html',
                          headers={'User-Agent': 
                                   'Mozilla/5.0 ' \
                                   + '(Macintosh;' \
                                   + 'Intel Mac OS X 10_10_1) ' \
                                   + 'AppleWebKit/537.36 ' \
                                   + '(KHTML, like Gecko) ' \
                                   + 'Chrome/39.0.2171.95 ' \
                                   + 'Safari/537.36'}).text)[0]

洛格斯特河

# Python
pd.read_html(requests.get('[https://www.iweblists.com/'](https://www.iweblists.com/') \
                          + 'world/geography/LongestRivers.html',
                          headers={'User-Agent': 
                                   'Mozilla/5.0 ' \
                                   + '(Macintosh;' \
                                   + 'Intel Mac OS X 10_10_1) ' \
                                   + 'AppleWebKit/537.36 ' \
                                   + '(KHTML, like Gecko) ' \
                                   + 'Chrome/39.0.2171.95 ' \
                                   + 'Safari/537.36'}).text)[0]

篮球冠军得主

# Python
pd.read_html(requests.get('[https://www.iweblists.com/'](https://www.iweblists.com/') \
                          + 'sports/ncaa/' \
                          + 'BasketballChampionships.html',
                          headers={'User-Agent': 
                                   'Mozilla/5.0 ' \
                                   + '(Macintosh;' \
                                   + 'Intel Mac OS X 10_10_1) ' \
                                   + 'AppleWebKit/537.36 ' \
                                   + '(KHTML, like Gecko) ' \
                                   + 'Chrome/39.0.2171.95 ' \
                                   + 'Safari/537.36'}).text)[0]

碗火柴(玫瑰色和橙色)

最后一个将多个数据字段合并到一列中。解析出这些单独的数据元素将是一个很好的挑战。

# Python
pd.read_html(requests.get('[https://www.iweblists.com/'](https://www.iweblists.com/') \
                          + 'sports/ncaa/' \
                          + 'RoseBowlandOrangeBowl.html',
                          headers={'User-Agent': 
                                   'Mozilla/5.0 ' \
                                   + '(Macintosh;' \
                                   + 'Intel Mac OS X 10_10_1) ' \
                                   + 'AppleWebKit/537.36 ' \
                                   + '(KHTML, like Gecko) ' \
                                   + 'Chrome/39.0.2171.95 ' \
                                   + 'Safari/537.36'}).text)[0]

Rose & Orange Bowl 数据摘录。图片鸣谢:亚当·罗斯·尼尔森(作者)。

世界政府首都城市

# Python
pd.read_html(requests.get('[https://www.iweblists.com/'](https://www.iweblists.com/') \
                          + 'world/government/' \
                          + 'Capitals.html',
                          headers={'User-Agent': 
                                   'Mozilla/5.0 ' \
                                   + '(Macintosh;' \
                                   + 'Intel Mac OS X 10_10_1) ' \
                                   + 'AppleWebKit/537.36 ' \
                                   + '(KHTML, like Gecko) ' \
                                   + 'Chrome/39.0.2171.95 ' \
                                   + 'Safari/537.36'}).text)[0]

世界政府世界领导人

# Python
pd.read_html(requests.get('[https://www.iweblists.com/'](https://www.iweblists.com/') \
                          + 'world/government/' \
                          + 'WorldLeaders.html',
                          headers={'User-Agent': 
                                   'Mozilla/5.0 ' \
                                   + '(Macintosh;' \
                                   + 'Intel Mac OS X 10_10_1) ' \
                                   + 'AppleWebKit/537.36 ' \
                                   + '(KHTML, like Gecko) ' \
                                   + 'Chrome/39.0.2171.95 ' \
                                   + 'Safari/537.36'}).text)[0]

欧洲联盟成员资格

# Python
pd.read_html(requests.get('[https://www.iweblists.com/'](https://www.iweblists.com/') \
                          + 'world/government/' \
                          + 'EuropeanUnion.html',
                          headers={'User-Agent': 
                                   'Mozilla/5.0 ' \
                                   + '(Macintosh;' \
                                   + 'Intel Mac OS X 10_10_1) ' \
                                   + 'AppleWebKit/537.36 ' \
                                   + '(KHTML, like Gecko) ' \
                                   + 'Chrome/39.0.2171.95 ' \
                                   + 'Safari/537.36'}).text)[0]

82–85 表格数据

作为一个重要的数据可视化软件提供商，Tableau 提供了一个示例数据库。以下是几个受欢迎的选择。

好莱坞有利可图的故事

# Python
pd.read_csv('[https://public.tableau.com/s/sites/default/files/media/HollywoodsMostProfitableStories.csv](https://public.tableau.com/s/sites/default/files/media/HollywoodsMostProfitableStories.csv)')// Stata
import delimited [https://public.tableau.com/s/sites/default/files/media/HollywoodsMostProfitableStories.csv](https://public.tableau.com/s/sites/default/files/media/HollywoodsMostProfitableStories.csv)# R
read.csv("[https://public.tableau.com/s/sites/default/files/media/HollywoodsMostProfitableStories.csv](https://public.tableau.com/s/sites/default/files/media/HollywoodsMostProfitableStories.csv)")

FIFA 18 球员评分

# Python
pd.read_csv('[https://public.tableau.com/s/sites/default/files/media/fifa18_clean.csv](https://public.tableau.com/s/sites/default/files/media/fifa18_clean.csv)')// Stata
import delimited [https://public.tableau.com/s/sites/default/files/media/fifa18_clean.csv](https://public.tableau.com/s/sites/default/files/media/fifa18_clean.csv)# R
read.csv("[https://public.tableau.com/s/sites/default/files/media/fifa18_clean.csv](https://public.tableau.com/s/sites/default/files/media/fifa18_clean.csv)")

Tenis 温布尔登冠军

# Python
pd. read_csv('[https://public.tableau.com/s/sites/default/files/media/wimbledons_champions.csv](https://public.tableau.com/s/sites/default/files/media/wimbledons_champions.csv)')// Stata
import delimited [https://public.tableau.com/s/sites/default/files/media/wimbledons_champions.csv](https://public.tableau.com/s/sites/default/files/media/wimbledons_champions.csv)# R
read.csv("[https://public.tableau.com/s/sites/default/files/media/wimbledons_champions.csv](https://public.tableau.com/s/sites/default/files/media/wimbledons_champions.csv)")

美国房屋销售，1963 年至 2016 年

# Python
pd.read_csv('[https://public.tableau.com/s/sites/default/files/media/enigma-us.gov_.census.eits_.ressales-e7513e56d76050c05caf638306055c98_1.csv](https://public.tableau.com/s/sites/default/files/media/enigma-us.gov_.census.eits_.ressales-e7513e56d76050c05caf638306055c98_1.csv)')// Stata
import delimited [https://public.tableau.com/s/sites/default/files/media/enigma-us.gov_.census.eits_.ressales-e7513e56d76050c05caf638306055c98_1.csv](https://public.tableau.com/s/sites/default/files/media/enigma-us.gov_.census.eits_.ressales-e7513e56d76050c05caf638306055c98_1.csv)# R
read.csv("[https://public.tableau.com/s/sites/default/files/media/enigma-us.gov_.census.eits_.ressales-e7513e56d76050c05caf638306055c98_1.csv](https://public.tableau.com/s/sites/default/files/media/enigma-us.gov_.census.eits_.ressales-e7513e56d76050c05caf638306055c98_1.csv)")

2016 年总统候选人支出

# Python
pd.read_csv('[https://public.tableau.com/s/sites/default/files/media/2016_presidential_candidate_expenditures.csv](https://public.tableau.com/s/sites/default/files/media/2016_presidential_candidate_expenditures.csv)')// Stata
import delimited [https://public.tableau.com/s/sites/default/files/media/2016_presidential_candidate_expenditures.csv](https://public.tableau.com/s/sites/default/files/media/2016_presidential_candidate_expenditures.csv)# R
read.csv("[https://public.tableau.com/s/sites/default/files/media/2016_presidential_candidate_expenditures.csv](https://public.tableau.com/s/sites/default/files/media/2016_presidential_candidate_expenditures.csv)")

美国最受欢迎的婴儿名字

# Python
pd.read_csv('[https://public.tableau.com/s/sites/default/files/media/TopBabyNamesbyState.csv](https://public.tableau.com/s/sites/default/files/media/TopBabyNamesbyState.csv)')// Stata
import delimited [https://public.tableau.com/s/sites/default/files/media/TopBabyNamesbyState.csv](https://public.tableau.com/s/sites/default/files/media/TopBabyNamesbyState.csv)# R
read.csv("[https://public.tableau.com/s/sites/default/files/media/TopBabyNamesbyState.csv](https://public.tableau.com/s/sites/default/files/media/TopBabyNamesbyState.csv)")

86 百老汇剧院数据

来自百老汇联盟(百老汇工业的国家贸易协会)。

# Python
pd.read_csv('[https://think.cs.vt.edu/corgis/datasets/csv/broadway/broadway.csv](https://think.cs.vt.edu/corgis/datasets/csv/broadway/broadway.csv)')// Stata
import delimited [https://think.cs.vt.edu/corgis/datasets/csv/broadway/broadway.csv](https://think.cs.vt.edu/corgis/datasets/csv/broadway/broadway.csv)# R
read.csv("[https://think.cs.vt.edu/corgis/datasets/csv/broadway/broadway.csv](https://think.cs.vt.edu/corgis/datasets/csv/broadway/broadway.csv)")

87 家医院的数据

与心脏病发作、急诊护理、预防性护理、中风护理和其他状况相关的数据。

# Python
pd.read_csv('[https://think.cs.vt.edu/corgis/datasets/csv/hospitals/hospitals.csv](https://think.cs.vt.edu/corgis/datasets/csv/hospitals/hospitals.csv)')// Stata
import delimited [https://think.cs.vt.edu/corgis/datasets/csv/hospitals/hospitals.csv](https://think.cs.vt.edu/corgis/datasets/csv/hospitals/hospitals.csv)# R
read.csv("[https://think.cs.vt.edu/corgis/datasets/csv/hospitals/hospitals.csv](https://think.cs.vt.edu/corgis/datasets/csv/hospitals/hospitals.csv)")

88 泰特博物馆艺术收藏

泰特美术馆的艺术元数据。不是他们收藏的所有作品，而是很多。

# Python
pd.read_csv('[https://think.cs.vt.edu/corgis/datasets/csv/tate/tate.csv](https://think.cs.vt.edu/corgis/datasets/csv/tate/tate.csv)')// Stata
import delimited [https://think.cs.vt.edu/corgis/datasets/csv/tate/tate.csv](https://think.cs.vt.edu/corgis/datasets/csv/tate/tate.csv)# R
read.csv("[https://think.cs.vt.edu/corgis/datasets/csv/tate/tate.csv](https://think.cs.vt.edu/corgis/datasets/csv/tate/tate.csv)")

89 起致命的警察枪击事件

一名警察卷入了美国的致命枪击事件。

# Python
pd.read_csv('[https://think.cs.vt.edu/corgis/datasets/csv/police_shootings/police_shootings.csv](https://think.cs.vt.edu/corgis/datasets/csv/police_shootings/police_shootings.csv)')// Stata
import delimited [https://think.cs.vt.edu/corgis/datasets/csv/police_shootings/police_shootings.csv](https://think.cs.vt.edu/corgis/datasets/csv/police_shootings/police_shootings.csv)# R
read.csv("[https://think.cs.vt.edu/corgis/datasets/csv/police_shootings/police_shootings.csv](https://think.cs.vt.edu/corgis/datasets/csv/police_shootings/police_shootings.csv)")

90 个食品数据

来自美国农业部的食物成分数据库

# Python
pd.read_csv('[https://think.cs.vt.edu/corgis/datasets/csv/food/food.csv](https://think.cs.vt.edu/corgis/datasets/csv/food/food.csv)')// Stata
import delimited [https://think.cs.vt.edu/corgis/datasets/csv/food/food.csv](https://think.cs.vt.edu/corgis/datasets/csv/food/food.csv)# R
read.csv("[https://think.cs.vt.edu/corgis/datasets/csv/food/food.csv](https://think.cs.vt.edu/corgis/datasets/csv/food/food.csv)")

91 位亿万富翁

几十年来超级富豪的数据库。

# Python
pd.read_csv('[https://think.cs.vt.edu/corgis/datasets/csv/billionaires/billionaires.csv](https://think.cs.vt.edu/corgis/datasets/csv/billionaires/billionaires.csv)')// Stata
import delimited [https://think.cs.vt.edu/corgis/datasets/csv/billionaires/billionaires.csv](https://think.cs.vt.edu/corgis/datasets/csv/billionaires/billionaires.csv)# R
read.csv("[https://think.cs.vt.edu/corgis/datasets/csv/billionaires/billionaires.csv](https://think.cs.vt.edu/corgis/datasets/csv/billionaires/billionaires.csv)")

92 古腾堡计划

古腾堡计划中最受欢迎的 1000 本书。

# Python
pd.read_csv('[https://think.cs.vt.edu/corgis/datasets/csv/classics/classics.csv](https://think.cs.vt.edu/corgis/datasets/csv/classics/classics.csv)')// Stata
import delimited [https://think.cs.vt.edu/corgis/datasets/csv/classics/classics.csv](https://think.cs.vt.edu/corgis/datasets/csv/classics/classics.csv)# R
read.csv("[https://think.cs.vt.edu/corgis/datasets/csv/classics/classics.csv](https://think.cs.vt.edu/corgis/datasets/csv/classics/classics.csv)")

93 恐龙数据

我保留了一个基于有趣的“datasaRus”示例的 CSV。保留这个 CSV 文件使得用一行代码加载更加容易。

# Python
pd.read_stata('[https://github.com/adamrossnelson/'](https://github.com/adamrossnelson/') \
              + 'StataQuickReference/blob/master/' \
              + 'exampledata/' \
              + 'DatasaRusCorrelationModified.dta?raw=true')// Stata
use [https://github.com/adamrossnelson/StataQuickReference/blob/master/exampledata/DatasaRusCorrelationModified.dta?raw=true](https://github.com/adamrossnelson/StataQuickReference/blob/master/exampledata/DatasaRusCorrelationModified.dta?raw=true)

假设的 x hypo_x和假设的 y hypo_y的散点图显示了为什么这个数据很有趣(以及它是如何得名的)。

“datasaRus”数据的散点图。图片鸣谢:亚当·罗斯·尼尔森(作者)。

限制

这篇文章有一些限制和警告。

行延续

对于一些例子，本文使用了行继续符。在 Python 中，反斜杠\完成了行的延续。在 Stata 中，三重正斜杠///起了作用。就本文而言，换行(或续行)不算第二行代码。

串并置

为了使代码在中型平台上看起来更好，并避免奇怪的换行，本文还在一些地方使用了字符串连接。

索引列表表格列表

正如你在pd.read_html()的文档中看到的，这段代码返回了熊猫数据帧的列表。方括号中的列表索引跟在pd.read_html()[i]后面，这里i表示列表上的索引，它查找感兴趣的数据帧。

本文还使用了requests.get().json()或requests.get().json()[data]从网上抓取并识别 json 数据。在上面的几个例子中，方括号符号隔离了感兴趣的数据。

感谢阅读

你准备好了解更多关于数据科学职业的信息了吗？我进行一对一的职业辅导，并有一份每周电子邮件列表，帮助专业求职者获取数据。联系我了解更多信息。

把你的想法和主意发给我。你可以写信只是为了说声嗨。如果你真的需要告诉我是怎么错的，我期待着尽快和你聊天。推特:@ adamrossnelsonLinkedIn:亚当罗斯尼尔森。

99 条关于数据分析的经验教训，来自于将前 5 名置于 5 个 Kaggle 分析挑战中

原文：https://towardsdatascience.com/99-lessons-on-data-analysis-from-placing-top-5-in-5-kaggle-analytics-challenges-453d5e7b4581

大师班:如何应对 Kaggle 分析挑战

(图片由作者提供)

我不得不同意批评者的观点: Kaggle 分析挑战与编写真实世界的数据分析报告没有太大关系。但我喜欢它们，因为它们能教会你很多用数据讲故事的基本原理。

Kaggle Analytics 面临的挑战与编写真实世界的数据分析报告没有太大关系。但是[…]他们可以教你很多东西[…]。

这篇文章原本是一篇有段落和图片的恰当的文章。但是第一稿已经超过 7000 字，所以你只能得到一个列表条。

在这篇文章中，我分享了迄今为止让我跻身五大 Kaggle Analytics 挑战前五名的“秘方”。

不要把这个列表误解为规则的集合。在我之前获奖的 Kaggle 笔记本中，我并不总是遵循这些提示。相反，这个列表是我一路走来学到的教训的集合。

对于本文，我将提供 Python 中的代码片段，其中包含来自 Pandas、Matplotlib 和 Seaborn 库的函数。随意使用您喜欢的任何编程语言和补充可视化库。

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

准备

1. 了解探索性和解释性数据分析的区别。

“当我们进行探索性分析时，就像在牡蛎中寻找珍珠一样。我们可能要打开 100 个牡蛎[……]才能找到两颗珍珠。当我们在向观众传达我们的分析时，我们真的希望处于解释空间，这意味着你有一个你想解释的具体事情，一个你想讲述的具体故事——可能是关于那两颗珍珠的。”— [3]

2.阅读问题陈述—理解问题陈述。

3.获得整个数据集的概览:

• 文件结构是什么？
• 整个数据集有多少个文件？
• 文件之间有什么关系？
• 什么是公共键列？

4.使用df.info()获得数据集中每个文件的概览:

• 一个文件中有多少列？
• 一个文件中有多少行？
• 列名是什么意思？
• 您拥有什么类型的数据(例如，数字、分类、时间序列、文本等。)?

5.阅读数据集的描述。

6.用df.nunique()检查唯一值的合理性和基数。

7.获取缺失值的概述。

# Display the percentage of missing values
df.isna().sum(axis = 0) / len(df) * 100# Visualize the missing values
sns.heatmap(df.isna(),       
            cbar = False,    
            cmap = "binary") 

8.如果你有一个大的数据集，你不需要查看所有的数据——但是不要在你的选择上偷懒。

9.做好准备，不是你创造的每一个情节都会出现在最终报告中。反正做了很多情节。

10.对于 单变量分析只需要三种类型的图:直方图或箱线图用于数值特征，柱状图(计数图)用于分类特征。

# Explore numerical features
sns.histplot(data = df, 
             x = num_feature)
sns.boxplot(data = df, 
            y = num_feature)# Explore categorical features
sns.countplot(data = df, 
              x = cat_feature)

11.记录你在代码中所做的事情——以后你会感谢自己的。

12.在探索性数据分析(EDA)期间，数据清理和特性工程应该自然地发生。

13.数字特征可以伪装成分类特征，反之亦然。

14.注意伪装成不可信值的 NaN 值(例如-1、0 或 999)。有时，它们会在看起来并不可疑的分布中显示为可疑的峰值。

*# Replace invalid values with NaN
invalid_value = 9999df["feature"] = np.where((df["feature"] == invalid_value), 
                          np.nan, 
                          df["feature"])*

15.不要忽略离群值。你可能会发现一些有趣的东西。

16.看看边缘案例(前 5 名和后 5 名)。

17.通过将一个特征分割成多个特征或将多个特征组合成一个新特征来创建新特征。

*# Splitting features
df["main_cat"] = df[feature].map(lambda x: x.split('_')[0])
df["sub_cat"] = df[feature].map(lambda x: x.split('_')[1])df[["city", "country"]] = df["address"].str.split(', ', expand=True)# Combining features
df["combined"] = df[["feature_1", "feature_2"].agg('_'.join, axis=1)
df["ratio"] = df["feature_1"] / df["feature_2"]*

18.根据文本要素创建计数和长度要素。

*# Creating word count and character count features
df["char_cont"] = df["text"].map(lambda x: len(x))
df["word_count"] = df["text"].map(lambda x: len(x.split(' ')))*

19.datetime64[ns]特性包含很多新特性:

*# Convert to datetime data type
df["date"] = pd.to_datetime(df["date"], 
                            format = '%Y-%m-%d')# Creating datetimeindex features
df["year"] = pd.DatetimeIndex(df["date"]).year
df["month"] = pd.DatetimeIndex(df["date"]).month
df["day"] = pd.DatetimeIndex(df["date"]).dayofyear
df["weekday"] = pd.DatetimeIndex(df["date"]).weekday
# etc.*

20.对于坐标，第一个数字始终是纬度，第二个是经度(但是在绘制坐标时，纬度对应于 y 轴，经度对应于 x 轴)。

*# Splitting coordinates into longitude and latitude
df["lat"] = df["coord"].map(lambda x: x.split(", ")[0]))
df["lon"] = df["coord"].map(lambda x: x.split(", ")[1]))*

21.使用附加数据扩展数据集。它展示了你的创造力。您有三种方法可以获得额外的数据(按工作量降序排列):

• 创建你自己的数据集，
• 找到一个数据集并将其导入 Kaggle，
• 或者使用 Kaggle 上已经可用的数据集(我更喜欢这个)。

22.合并两个数据帧时，不要丢失有价值的数据点。此外，确保键列的拼写在两个数据帧中匹配。通过使用len(df)检查结果数据帧的长度，再次检查您的工作。

*

23.查看评估标准。

开始探索数据之前(图片由作者提供)

探索性数据分析

24.接受你(可能)无法查看数据中的所有关系。如果 n 是特征的数量，查看每一个可能的组合将会以(n+(n/2)+(n/3)的指数放大。

25.从绘制一些(随机)关系开始——只是为了熟悉数据。

26.不要在 EDA 期间浪费时间创建花哨的数据可视化(我保证我们稍后会实现)。

27.领域知识为王。做一些研究来熟悉这个话题。

28.投入一些时间去思考你想探索哪些方面。头脑风暴出一系列值得回答的问题。如果不知道从哪里开始，就从挑战主持人建议的研究问题开始。

29.在开始多元分析之前，先了解一下可能的关系(但请记住，以下两种方法都只考虑数字特征)。

# Display pair plot
sns.pairplot(df)# Display correlation matrix
sns.heatmap(df.corr(),         
            annot = True,      
            fmt = ".1f",       
            cmap = "coolwarm", 
            vmin = -1,         
            vmax = 1)

30.在每个情节之后，用要点的形式记录你的发现。

31.二元分析只需要四种类型的图:

• 两个数字特征之间关系的散点图

sns.scatterplot(data = df, 
                x = "num_feature_1", 
                y = "num_feature_2")

• 分类特征和数字特征之间关系的箱线图

sns.boxplot(data = df, 
            x = "cat_feature", 
            y = "num_feature")

• 两个分类特征之间关系的热图或条形图

temp = pd.crosstab(index = df["cat_feature_1"],
                   columns = df["cat_feature_2"])

# Bar chart
temp.plot.bar()# Heatmap
sns.heatmap(temp, annot = True)

32.groupby()方法是你多元分析的好朋友。

# How many feature_1 per feature_2?
df.groupby("feature_2")["feature_1"].nunique()# What is the average feature_1 for each feature_2?
df.groupby("feature_2")["feature_1"].mean()

33.有时间序列数据吗？使用线图进行趋势分析。

sns.lineplot(data = df, 
             x = "time_feature", 
             y = "num_feature")

34.您可以进行多变量分析，而无需学*任何新的图:

• 三个数字特征之间关系的色调或大小散点图

sns.scatterplot(data = df, 
                x = "num_feature_1", 
                y = "num_feature_2",
                hue = "num_feature_3")sns.scatterplot(data = df, 
                x = "num_feature_1", 
                y = "num_feature_2",
                size = "num_feature_3")

• 两个数字特征和一个分类特征之间关系的色调或样式散点图

sns.scatterplot(data = df, 
                x = "num_feature_1", 
                y = "num_feature_2",
                style = "cat_feature")sns.scatterplot(data = df, 
                x = "num_feature_1", 
                y = "num_feature_2",
                hue = "cat_feature")

• 两个分类特征和一个数值特征之间关系的分组条形图或箱线图

sns.barplot(data = df,
            x = "cat_feature_1", 
            y = "num_feature", 
            hue = "cat_feature_2")sns.boxplot(data = df,
            x = "cat_feature_1", 
            y = "num_feature", 
            hue = "cat_feature_2")

• 三个分类特征之间关系的堆积分组条形图

35.总是怀疑你的发现。花些时间对你的图表进行理智检查和反复检查，找出数据谬误，如辛普森悖论 [2]。

"一种现象，其中一种趋势出现在不同的数据组中，但当这些组被组合时就消失或逆转。"— [2]

36.读，读，读。通过研究扩展你的 EDA。

37.建模可用于数据分析。例如，您可以构建一个线性回归模型来预测下一年的值，您可以应用聚类来创建一个新的要素，或者您可以使用要素重要性来获得洞察力。

38.花一分钟来确保你正确地解释了这些情节。

39.确保你有足够多的情节(或洞察力来围绕它们构建一个故事)。

40.重构您的代码。它帮助您检测错误，并使您的代码对您的受众来说更容易访问和重现。

41.在这个阶段，如果各种数据可视化没有给人留下深刻印象，那也没关系。

将点点滴滴连接起来 EDA 之后的感悟(图片由作者提供)

解释性数据分析

42.讲故事比数据可视化更重要——相信我，我赢得一等奖时用的大多是条形图。

43.选择一个明确的主题，围绕这个主题写一个故事。确保你回答的问题对竞赛主持人有用。

44.Kaggle Analytics 挑战赛的参赛作品是而不是一组图。它需要引言、正文和结论。

45.根据你的发现创建一个大纲。

46.不要犹豫丢弃你目前为止的大部分情节。

47.告诉你的听众关于数据集的情况。您正在处理哪些数据？有多少个数据点？是否添加了外部数据？

48.解释你做了什么。

49.展示你没看到的。你是否有一个有趣的假设，但数据并不支持它？展示并讨论它。

50.不要仅仅因为你认为数据可视化很酷就加入一个观点。如果发现与你讲述的整个故事不相关，删掉它。

51.写初稿。

52.现在是幻想情节的时候了(看，我遵守了我的诺言)。

53.如果你知道你想要显示什么，你会做更好的数据可视化。

54.仔细检查您正在使用的指标是否适合您想要显示的内容。例如，要衡量一个平台的受欢迎程度，你会使用账户总数还是日活跃用户平均数？

55.避免虚荣指标。

56.从专家那里获得一些灵感——但是要明白枯燥的数据可视化(也就是条形图)通常是最有效的。

57.根据您想要显示的(分布、关系、组合、比较)，决定使用哪种数据可视化。

58.你的最佳选择是这些六种类型的图及其变体:条形图、热图、直方图、散点图、箱线图和线图。

59.请记住，单个数字和表格也可以是数据可视化。

60.请不要使用饼图。另外，请不要使用环形图。如果你的剧情是以一个甜点命名的，那就不要用(还有做的时候，知道不应该)。

61.用条形图替换文字云。

62.拜托，拜托，请不要用 3D 特效。

63.有意使用 choropleth 地图(不仅仅是因为你有地理数据)。

64.定义调色板。至少有一种亮色和一种对比色。

# Set color theme
highlight_color = "#1ebeff"
contrast_color = '#fae042'from matplotlib.colors import LinearSegmentedColormap
custom_palette = LinearSegmentedColormap.from_list(" ",  [highlight_color,  '#ffffff', contrast_color])
plt.cm.register_cmap("custom_palette", custom_palette)

65.确保根据您的目的使用正确的调色板:

• 有序值的顺序(例如 1、2、3、…、)
• 具有中性中间值的相反值发散(例如-1，0，1)
• 分类值的定性

66.当你需要从上下文信息中转移焦点时，灰色是你的朋友。

67.确保你的颜色是色盲和影印安全。

68.像成年人一样想象:给你的图添加一个标题和标签。

69.如果合适，添加图例。

70.设置合适的字体大小。

plt.rcParams.update({"font.size": 14}) 

71.保持简单。从情节中去除任何干扰和冗余。

72.不要在 0 以外的任何地方开始你的条形图的数量轴。

73.不要比较两个不同轴范围的图。

74.不要用你的数据可视化误导你的观众，例如忽略 72。和 73。

75.将注释直接添加到绘图中。

ax.annotate("Annotation text", 
            xy = (x_pos, y_pos))

76.如果您正在处理有序分类数据，请确保对条形图中的条形进行排序，以正确表示有序要素。

77.利用前注意加工。

78.考虑“移动优先”(因为你的大部分读者会在他们的手机上阅读你的报告)。

79.看看每一个数据可视化。它在没有上下文的情况下传达了信息吗？如果没有，修改。

有效地传达你的见解——探索性和解释性数据分析的区别(图片由作者提供)

收尾

80.写第二稿。

81.数据可视化应该总是伴随着一些文本。将项目符号转换成文本。光靠情节是不够的。

82.修改和编辑你的第二稿。

83.在报告的开头使用引人注目的图片。(你可以在 Unsplash 上找到很棒的照片，但一定要注明出处。)

84.没人想看你的代码——把它藏起来。

85.也隐藏控制台警告。

import warnings # Supress warnings
warnings.filterwarnings("ignore")

86.查看您的细胞输出。如果它不是数据可视化，那么它必须有助于讲述你的故事。否则，也隐藏它。

87.以洞察力为先导——没有人会阅读你报告中的每一个字。在开头以项目符号的形式添加一个摘要。

88.用粗体突出你文章中的重点(因为没有人会去读你报告中的每一个字)。

89.一定要写好结论。我说过没人会读你报告的每一个字吗？

90.使用拼写检查器。语法上我喜欢。

91.确保选中挑战评估标准的所有复选框。

92.唷，表情符号。爱他们或恨他们——只要答应我不要过度，好吗？

93.请记住，您的受众可能不是数据科学家。你的分析可行吗？

94.引用你的消息来源。

95.花些时间想出一个好标题。

96.让一个朋友检查你的报告和/或大声读出来。

97.让报告休息几天。

98.给你的报告做最后的检查。

99.放下完美主义，屈服。

喜欢这个故事吗？

如果你想把我的新故事直接发到你的收件箱里，一定要订阅https://medium.com/subscribe/@iamleonie！

成为一名媒体会员，阅读更多来自我和其他作家的故事。报名时可以使用我的 推荐链接 支持我。我将收取佣金，不需要你额外付费。

*https://medium.com/@iamleonie/membership

在LinkedIn和ka ggle！

参考

[1]下面我列出了我的获奖 Kaggle 笔记本产品组合，供您参考:

• 2022: 《隐藏的宝石》中一提之后会发生什么？参加隐藏宝石笔记本比赛 ( 第一名)
• 2021: 《云里雾里》为 2021 Kaggle 机器学*&数据科学调查(5 名获奖者中的 1 名)
• 2020 年:布卢姆前的马斯洛为 LearnPlatform 新冠肺炎对数字学*的影响(5 个获奖者中有 1 个)
• 2020:https://www.kaggle.com/code/iamleonie/impact-potential-analysis-of-water-use-efficiencyCDP 用水效率影响潜力分析——解开气候方案 ( 第三名)
• 2019: 日本:崛起女性之国参加 2019 Kaggle 机器学*&数据科学调查 ( 第 4 名)

[2] geckoboard，《数据谬误》。geckoboard.com。https://www . geckoboard . com/best-practice/statistical-fallacies/(2022 年 8 月 14 日访问)

[3] Nussbaumer Knaflic，C. (2015 年)。用数据讲故事。约翰·威利的儿子们。**

为学术界以外的数据科学工作面试做准备的 5 步清单

原文：https://towardsdatascience.com/a-5-step-checklist-to-preparing-for-data-science-job-interviews-outside-of-academia-67f9d77e64

这份清单将帮助你成功竞争一份数据科学行业的工作

约书亚·索蒂诺在 Unsplash 上拍摄的照片

数据科学是一门独特的学科，可以将你从学术界带到工业界，然后再回来。

虽然你们中的许多人在学术界接受了培训，甚至可能获得了第一份工作，但这可能不是你想在职业生涯中一直待下去的地方。因此，开始准备如何计划离开学术界，进入工业界的数据科学工作非常重要。这些工作可能涉及商业预测、私人科学研究、医疗保健优化等等。

数据科学的这些应用都是多种多样的，然而你可以预期的面试类型将遵循相同的公式。学术界和工业界工作的数据科学面试之间的一个区别是一般面试。技术面试很容易被认为几乎是相同的。然而，公司试图了解你是谁和你的能力的一般面试在学术界和工业界会有所不同。

因此，了解行业中的一般面试是如何进行的，以及你应该如何准备这些面试是至关重要的。这将包括如何用通俗的术语解释你的研究或以前的教育，研究你申请的公司，以及在面试结束时确定好的问题——因为让我们面对现实吧，面试是他们面试你的机会，也是你面试他们的机会。

这份简单的清单将帮助您确保您已经勾选了成功准备行业数据科学职位一般面试所需的所有方框。

1.阅读、理解并记住数据科学职位描述的关键组成部分

这一点似乎不言自明。

然而，我接触过的许多招聘人员在面试不知道职位是什么、工作职责是什么、公司是谁以及他们想要什么样的背景要求的候选人时，总是感到惊讶。

因此，似乎有必要提醒您，在申请之前阅读并理解职位描述是您成功获得数据科学工作的关键因素之一。

为了更进一步，你必须记住工作描述中的一些关键要素和关键词。这些因素的存在是有原因的，也是招聘者希望你能接触到的，以显示你的理解和能力。

能够在你的回答中加入一些关键的短语和成分是一个很好的方式来显示你已经阅读了工作描述，你对他们的问题感到满意，并且你觉得你可以为公司提供这种能力。

例如，如果一份工作描述列出了诸如 Excel、Python 和 Tableau 等技术，你就有了一个完美的段落来解释你过去是如何成功地使用这些技术的。或者，如果他们在寻找能融入团队的人，你可以描述一次你解决团队冲突的经历。此外，如果他们在寻找能够开发预测性机器学*模型的人，你可以描述一下你在大学期间开发了一个预测网站访问者跳出率的模型。

2.不仅要研究你申请的数据科学职位，还要研究公司本身

同样，这一点似乎和第一点一样不言自明，但仍然需要加以说明。

以我的经验来看，招聘人员寻找的不仅是技术人才，还有融入公司文化和团队活力的能力。这意味着他们在寻找一个不仅适合这份工作，而且适合公司的人。

因此，如果你能从面试一开始就展示出对公司、其目标、流程和信念的理解，这对招聘人员是非常有益的。所有这些信息通常都可以在公司网站或社交媒体上找到。

这不仅是一个很好的机会去了解你将来可能为谁工作，也是一个很好的机会去看看你是否喜欢为他们工作。发现你真的不同意一家公司的使命宣言，并发现你不想为他们工作，这没有什么错。如果有什么不同的话，那就是把你从糟糕的处境中解救出来。因此，花必要的时间去真正了解一家公司，看看你是否能融入他们的公司文化。

在行业职位中，数据科学家可以在一家公司内扮演多种不同的角色，这就是为什么您必须确定自己在大计划中的位置。以下是我在调查一家公司时喜欢留意的一些事情:

• 对于数据科学团队将如何为公司或公司的客户提供价值，没有清晰的路线图。
• 对数据科学家的期望不一致——这可以在将工作描述与公司网站上的内容进行比较时发现。
• 依赖过时的工具或流程。

这里需要注意的关键点是，根据数据科学团队在组织中所占的比重，网站上可能没有这些信息。因此，了解上述信息的最佳方式是在面试结束时提问，这将在下文第 5 点中讨论。

3.写下并记住你的学士/硕士/博士学位中重要的数据科学实例，这些实例产生了一些有影响力的东西

众所周知，数据科学家的价值在于他们对公司的影响。无论是开发新的机器学*模型来为公司节省数千美元，还是改进旧的算法来更快地产生结果，数据科学家都需要能够尽快投入运行并产生影响。

在面试中展示这一点的最好方法之一是突出你所受教育中直接(或大部分)适用于这份工作的例子。

这将涉及到浏览旧的项目和论文，挑选出几个关键的例子来说明你是如何开发出有影响力的东西的。正如我们将在下一节中讨论的，这些例子的解释应该简化，以便任何行业的任何人都可以理解它们做了什么，它们是如何工作的，以及它们为什么工作。

你的例子应该遵循这种格式，以确保给出你的作品的全貌:

1. 这个项目的目标是什么(你试图解决什么问题)？
2. 你在处理什么样的数据？
3. 你是如何决定解决这个问题的？
4. 你创造了什么，它是如何工作的？
5. 为什么会成功？
6. 结果如何？
7. 你的结果有什么影响(你的结果如何有助于实现项目的目标或解决问题)？

你对格式中每一点的回答不应该超过一句话。简洁明了应该是两个词，可以描述你的答案一旦完成。

例句:(1) 该项目的目标是确定气候变化对北极和南极的影响比对地球其他地方的影响更大。 (2) 本项目数据来自全球环流气候模型，是气候系统各个组成部分的https://medium.com/predict/what-climate-models-tell-us-about-future-global-precipitation-patterns-e7b52d2447aa*的数学表示，包括大气、陆地、海洋、海冰。* (3) 这个项目是通过绘制气候模型数据来解决的，以了解不断上升的大气温度如何集中在两极附*，而在其他地方则不太集中，以及开发一个预测模型来了解未来温度将如何上升。 (4) 我创造了一个机器学*模型，它能够根据历史趋势预测未来两极的温度。这个模型之所以有效，是因为我有可追溯到 19 世纪 50 年代的气候数据，这些数据提供了全球气温指数增长的清晰图像，尤其是在两极。 (6) 结果发现，我们正朝着极地气温升高超过 3.5 摄氏度 的工业化前水平前进，远高于 IPCC 所希望的 1.5 摄氏度 。这些结果是有影响力的，因为它们提供了地球正在变暖的额外证据。

4.预演你的回答，保持在 60-75 秒之间，以便后续提问

行业内的一般面试不应该超过 30 分钟。如果他们这样做了，那这家公司要么是真的不擅长面试，要么是他们没有得到他们想要的答案。

30 分钟似乎很长，但当你试图让别人理解你的回答时，你会感觉像在和时间赛跑。

因此，你必须排练你的答案，并保持在 60-75 秒之间。这不仅会给你一个准备好的、优雅的形象，而且如果你的面试官对你的回答感兴趣的话，还会给后续问题留出时间。

准备过程中这一步的关键是找到问题的答案，这些答案没有术语，任何人都容易理解，不管是什么行业或教育背景。你的相关研究或教育可能非常具体，这意味着你用那种经历对问题做出的任何回答可能只有来自那种背景的人才能理解。

例如，如果你申请的是汽车行业的数据科学工作，而你的教育背景是生物医学数据科学，那么你的研究可能会作为一个例子，但可能很难被一个完全不同行业的招聘团队理解。不仅如此，我们还可以假设，一个技术招聘团队也可能来自不同的背景和教育，尽管他们在职业生涯的这个阶段都在同一个行业工作。

因此，在解释你的相关研究或教育的细节时，你的答案应该没有行话，并围绕一般数据科学术语，任何具有一般背景的人都可以理解。

我的研究涉及开发一个机器学*模型，以分析阳光损伤对患者患皮肤癌概率的影响。这可以应用于汽车行业，因为我的研究涉及概率测试，可以用多种方式来确定车辆制造中的因果关系。

简短、甜蜜、切中要害，这个例子没有令人困惑的生物医学术语，而是深入研究的本质，以及它与公司可能雇用你做的工作的相关性。它也足够短，招聘人员可以问后续问题，让你得到更具体或扩展你的工作描述。

以我的经验来看，一直都是你给出回应后得到的后续问题给了你出彩的机会。在这里，你可以详细阐述并展示你对所谈论的事情的真正兴奋。如果你对自己的回答感到兴奋，你的招聘人员也会对你的回答感到兴奋。

5.想出在面试结束时问的好问题，让你对数据科学职位有更多的了解

许多求职者忘记了面试是公司了解你的机会，也是你了解他们的机会。

在学术界，候选人可能不倾向于确保某个职位非常适合他们，因为竞争激烈，预算低，职位有限。然而，在行业中，数据科学家可以更灵活地选择符合他们信仰、文化和需求的公司。

作为一般面试准备的一部分，准备一份 2-5 个问题的清单是至关重要的，你可以在面试结束时问这些问题，这将让你很好地了解你将来可能会为谁工作。这些问题可能包括是否允许您在家工作，向风险承担者提交数据分析结果的政策是什么，以及由于缺少软件工程部门，您的团队是否需要编写生产就绪的代码。诸如此类的问题是深入了解工作文化、期望和业务能力的好方法。

例如，发现一家公司没有可以将你所有的数据科学代码合并到现有流程中的软件工程部门，这可能是一个危险信号，表明这家公司要么非常小，要么非常便宜。如果你正在寻找一份可以专注于创建机器学*模型而不必担心将代码集成到现有流程中的工作，这可能是一个问题。或者，如果你正在寻找一家公司，在那里你可以扩展你的技能，并对你的模型的使用和实现有更多的控制权，这对你来说可能是一个好兆头。

关键是要设计一些问题，既能揭示对你来说很重要的细节，又能表达出你对所申请公司的兴趣和渴望。对工作的真正兴趣可能是你和另一个候选人之间的一个关键决定因素，因为行业公司通常都在寻找每天都会兴奋地来上班的人。

以下是一些让你开始的问题:

1. “公司希望从数据科学团队那里获得什么影响？”
2. “数据科学团队中有多少工作是自我指导的，而不是由公司的其他部门指导的？”
3. “我将与之共事的数据科学团队成员的背景如何？”
4. “是鼓励数据科学团队开发新的算法和模型，还是主要关注实施已有的算法/模型？”
5. "这个角色需要多少数据工程或软件工程？"

订阅让我的故事直接发到你的收件箱:故事订阅

请成为会员，使用我的推荐链接获得无限制的媒体访问权限(我将免费向您收取少量佣金):媒体会员

通过捐赠来支持我的写作，以资助更多像这样的故事的创作:捐赠

因果人工智能的 6 分钟介绍

原文：https://towardsdatascience.com/a-6-minute-introduction-to-causal-ai-50d92ffb5e91

快速了解现代人工智能系统是如何失败的，以及因果关系如何有所帮助

卡尔豪泽在 Unsplash 上拍摄的照片

现代人工智能系统使得解决许多以前认为计算机无法解决的问题变得容易。您可能听说过其中的一些成功案例，例如:

• 【GPT-3】:根据您提供的任何初始提示生成类似人类的文本段落。
• alpha fold:预测蛋白质在 3D 空间中的形态。现代生物学的真正突破。
• DALLE-2 :从文本描述中创建极其详细和逼真的图像。

这些系统如此之好，以至于他们甚至让那些致力于开发它们的人相信它们是有感知能力的。

然而，尽管取得了成功，这些系统中的许多可以被认为是技术鹦鹉。鹦鹉可以模仿它们的主人，但并不真正知道它们在说什么，也不知道它们为什么这么说。

类似地，现代人工智能系统可以模仿它们从以前的数据中学*到的模式，而无需了解正在解决的问题的真实背景，也不理解为什么会返回给定的预测。现代人工智能系统是大规模的鹦鹉，GPT-3 是在大约 30 亿个网页上训练的，并且具有巨大的社会影响。

这种鹦鹉学舌的最终结果是现代人工智能系统遭受以下三个 B:

1. 盲目的
2. 有偏见的
3. 易碎

这三个 B 意味着现代人工智能系统在处理它们所应用的微妙、复杂和高风险的应用程序方面存在缺陷。让我们探索一下因果关系的方法能有什么帮助。

盲目的

现代人工智能系统看不到数据点之间的关系类型，也缺乏它们用来解决的问题的背景。

为了说明这一点，考虑一下经验年限和收入之间的关系。通常，一个人的经验与其收入相关:经验越多，收入越高。反过来也是如此:收入越高，经历越多。你可以称这种双向关联为联想关系。

图 1:显示工作年限和收入之间正相关的图表。

另一种关系是因果关系。在这种情况下，一个变量引起另一个变量的变化。一个人挣的收入是因为他多年的经验。与联想关系不同，因果关系是单向的；一个人的经历并不是由他们的收入引起的。

因果技术为你提供了从因果关系中分离出关联的工具。通过干预系统，将某人的经验设定为一个给定值，你可以观察这将如何改变他们的收入。通过干预，你可以确定经验和收入之间的关系类型(因果或关联)，以及它的流向(经验导致收入)。你可以把干预看作是回答某种“如果”问题的一种方式:如果我是 45 岁，而不是 31 岁，我会挣多少钱？

现代人工智能系统非常擅长识别数据中的关联，这些关系是它们成功的基础。然而，由于这些系统传统上对因果关系视而不见，它们从数据中反复学*误导性的关联。这些误导性的关联，或者说虚假的关联，对于人工智能系统来说可能是致命且危险的。

直觉上，当我们不期望它在未来以过去的方式存在时，相关性就是虚假的。你可以在这里找到一个很棒的虚假相关性列表。消除虚假的相关性是随机对照试验的基础；证明假设的科学黄金标准。

因果人工智能是强大的，因为它允许你使用现有的观察数据来识别和消除虚假的相关性——而不需要进行受控试验。

有偏见的

虚假相关性无处不在，现代人工智能系统会定期学*这些相关性。这些相关性经常会引入有害的偏见，下面的例子证明了这一点:

• 谷歌的照片应用将黑人归类为大猩猩
• 一个微软聊天机器人被推特变得激进
• 一种被广泛采用的犯罪预测软件被发现标记黑人被告为“高风险”的比率是其他人的两倍

为了说明因果技术如何有所帮助，让我们扩展之前考虑的收入预测示例，添加一些其他变量，如表 1 所示。

表 1:收集的进一步数据有助于预测不同人群的收入。

由于表 1 所示的观察数据中的历史偏见，接受过 it 培训的 AI 系统学会将女性与低收入联系起来。为了确保您的模型生成有用且安全的预测，需要控制这种偏差。

因果技术允许创建显示变量之间关系的因果图。此图中的每个箭头展示了一个变量如何对另一个变量产生因果影响，例如，经验对收入有因果影响。这允许您明确表示数据中的偏差。

图 2:映射上表 1 所示变量之间关系的简化因果图示例。

一旦你有了一个因果图，你相信它准确地描述了数据是如何相互关联的，它就可以被操纵来控制一系列不同的因素，包括消除偏差。

一种操纵可能是干预德国女工程师的性别，看看这将如何影响她们的收入。或者，通过控制性别，你可以从因果图中移除性别的影响。其结果是对其他因素对收入影响的无偏估计。

图 3:一个经过处理的因果图，已经对性别进行了控制——去除了它对其他数据点的影响。

易碎

现代人工智能系统是精密的系统，需要密切的微调以确保它们被正确配置。尽管接受了大量数据的训练，但从人类的角度来看，它们仍然可能以令人惊讶或微不足道的方式失败。图 4 显示了当奶牛在沙滩上而不是在田野里时，图像处理算法是如何识别不出奶牛的。尽管图像分类器在训练期间已经显示了成千上万的奶牛图像。

图 4:当将现代物体检测器应用于奶牛图像时，当背景不是绿色时，它很难识别它们——这表明这些算法可能会失败。 来源 。

对于本博客中提到的现代人工智能系统的类型，对看不见和不熟悉的数据进行可靠预测的能力通常被称为一般化。因果机器学*以不同的方式处理一般化，因为现在观察到的数据和相应的因果图都被考虑-参见下面的图 5。

图 5:可视化多个因果图如何描述相同的数据。从数学上来说，所有这些因果图都是对数据的有效描述，然而直觉上只有最左边的图是正确的。

因此，因果模型试图从一组条件下的行为推广到另一组条件下的行为。应根据测试因果模型对不断变化的条件的稳定性的标准来选择因果模型，例如，当进行干预时。科学家在进行对照试验以确定因果关系时遵循这一原则。

其结果是，因果模型对现实世界中不断变化的条件更加稳健，能够更快地适应数据的巨大变化。这些优势使得人工智能研究人员开始将这些来自因果人工智能的一般化概念嵌入到他们正在构建的系统中。

结论

这是对因果人工智能的简要介绍，讨论了它带来的一些优势，以及这些优势如何帮助克服现代人工智能算法的盲目、偏见和脆弱的本质。

以下是三个关键要点:

1. 因果图:通过指定观察数据之间的关系，您可以更好地理解问题领域，减少偏差，并对图表进行操作，以模拟各种情况。
2. 操纵:通过操纵因果人工智能，可以对场景进行建模，并回答假设问题。这些操作允许对问题进行更深入的探索，并提供回答假设情况的能力。
3. 概括:因果人工智能更好地概括了看不见的数据，因为它是为了适应不断变化的环境而构建的，而不仅仅是不断变化的数据。

笔记

*很明显，决定一个人收入水平的因素不止这些。这些将在一个更完整的模型中建立起来，参见“偏见”一节，但为了简单起见，最初我们只考虑影响收入的多年经验，其余因素作为隐藏变量。

A/A 测试建立对实验平台的信任

原文：https://towardsdatascience.com/a-a-testing-establishes-trust-in-experimentation-platform-db30387d5bf9

我们如何通过各种 A/A 测试来确保实验平台的可靠性

投稿人: Max 李、、

照片由亚历克斯·舒特在 Unsplash 上拍摄

想象一下你的 A/B 测试平台的误报率高达 50%。你也可以完全放弃 A/B 测试，开始抛硬币来决定你的产品上市。假阳性率高于 50%也不是不可能。在开发我们的百分位数测试时，我们使用 A/A 测试来排除导致误报率高于 50%的测试方法。A/A 测试揭示假阳性，对于建立对 A/B 测试平台的信任至关重要。A/A 测试已经成为 Wish 的标准实践，并帮助我们评估假设和识别错误。

在 A/A 测试中，实验桶(如控制和处理)是相同的。从你的 A/A 测试返回的任何有统计学意义的结果都是假阳性。一个值得信赖的 A/B 测试平台应该很少有来自 A/A 测试的假阳性(如果应用的阈值是标称的p-值< 5%)，大约为 5%。

这篇文章分享了我们如何通过各种 A/A 测试获得对我们的 A/B 测试平台的信心。

A/A 测试(图片来自 Wish 的龚铭)

回顾性 A/A 测试检测实验偏差

我们对每个实验进行回顾性的 A/A 测试(即任务前测试)。A/B 测试比较来自控制用户组和来自治疗用户组的度量数据。预分配测试进行相同的比较，除了在用户第一次接触实验之前 X(例如，60)天生成度量数据。预分配测试的统计显著性结果表明 A/B 测试中存在偏差。

当实验前对照桶和处理桶之间的度量存在预先存在的差异时，我们无法判断 A/B 测试期间出现的度量差异是固有的还是由处理引起的。通过对用户进行适当的随机化，不应该存在统计上显著的预先存在的差异，因为两组用户在实验之前有相同的经历。

来自预分配测试的小的p-值表明实验特征的看似显著的度量影响可能是由于用户分配期间引入的偏差。例如，由于不正确的实验设置，应用程序最新版本的用户都被分配到治疗。在这种情况下，即使没有实验中的新用户体验，治疗用户也可能比控制用户更活跃，购买更多。分配前测试会发现，治疗使用者甚至在实验之前就已经有了更多的购买。

我们随意为每个 A/B 测试运行预分配测试，并使用保守阈值:p-值< 0.0005。在实践中，有偏差的 A/B 测试通常会产生非常重要的 p 值，并导致几个指标的预分配警告。

即使 A/B 测试平台总体上是可靠的，特定实验的不正确设计或不幸运的用户分裂(即随机化)仍然可以使 A/B 测试有偏差。预分配测试评估特定实验和特定用户划分的假阳性。

A/A 测试显示假阳性

揭示不同环境下的误报

我们为不同的场景创建各种 A/A 测试，例如转换漏斗中的多个步骤(例如，产品印象、点击、添加到购物车和购买)、客户端和服务器端实验、注销和登录实验等。

此外，我们鼓励不同的团队保持他们的 A/A 测试，以确保假阳性在他们的领域得到很好的控制。例如，一个主要试验视频购物体验的团队应该对视频购物页面进行 A/A 测试。当他们在视频购物页面上运行的其他实验中出现意外结果时，运行 A/A 测试将作为基线。

揭示实验的假阳性

每当 A/B 测试的结果看起来可疑时，我们鼓励 Wish experiments 做的第一件事就是运行一个并行的 A/A 测试——一个与可疑 A/B 测试配置相同的 A/A 测试，除了两个实验桶之间的用户体验没有区别。

我们对平台的一些重大改进始于通过这些 A/A 测试发现的问题。例如，之前的 A/A 测试揭示了我们的分配算法的一些缺点，这导致了显著的改进。

揭示由新开发引入的假阳性

我们不断改进我们的实验平台。在每个主要开发之后，我们运行 A/A 测试。A/A 测试通常是新开发后的第一项检查，以防止高假阳性率。例如，由于 A/A 测试发现的问题，我们改进了注销实验的初始实现。

结论

A/A 测试是在 A/B 测试平台中建立信任的重要工具。细节往往是魔鬼。尽管 A/B 测试的概念是琐碎的，但是正确地进行 A/B 测试却异常困难。全面的 A/A 测试对于系统地评估 A/B 测试平台是必不可少的。A/A 测试评估假阳性并验证 A/B 测试平台的可靠性。我们之前的出版物介绍了评估假阴性的方法。

感谢

感谢史成熙、、托德·霍兹和罗伯·雷思玛设计了 A/A 测试，感谢龚铭设计了这些情节。我们也感谢 Pai Liu 的支持，以及 Pavel Kochetkov、Lance Deng 和 Delia Mitchell 的反馈。

二进制数据的 A/B 检验:两个样本比例 z 检验

原文：https://towardsdatascience.com/a-b-testing-with-binary-data-two-sample-proportions-z-test-5c222d7772ad

找出营销活动中两个用户群之间的统计差异

“但你不再听到这首歌了。你已经走了，我的孩子，进入你的故事。你知道你永远不会变成一条鱼，你永远不会到达伊塞克湖，或者看到白色的船，或者对它说:“你好，白色的船，是我”？你游走了。”
― 钦吉兹·艾特玛托夫，白色蒸汽船

吉尔吉斯斯坦冬季的伊塞克湖。照片由麦克·杜丁在 Unsplash 上拍摄

介绍

在当今数据驱动的世界中，我们总是听到关于 数据驱动决策 及其在各种评估中的重要性，如医疗试验、预测选举、估计营销活动的效果等。用来做出这些决定的一个强大工具是 假设检验 。

作为一名数据科学家，我发现与机器学*和深度学*相比，假设检验领域被忽视了。另一方面，我认为有必要更加强调如何使用每项测试，选择哪些测试以及如何正确地解释结果。

在本帖中，我想讨论如何 解读双样本比例z-检验 的结果，以及如何理解比例的差异是否具有统计显著性。在进入正题之前，我们先讨论一下假设检验和 A/B 检验以及它们之间的联系。

什么是假设检验，它是如何工作的？

假设检验是一种统计程序，允许使用样本数据得出关于总体的结论。在假设检验中，我们评估关于总体的两个互斥的陈述，并决定哪一个由数据支持[1]。

应用假设检验的一个巨大好处是，您可以使用样本数据得出关于整个人口的结论。然而，这也带来了一个折衷，您需要考虑样本误差。

A/B 检验及其与假设检验的联系

A/B 测试 是中的一种 应用，在科技公司中广泛使用。例如，一家公司想要了解哪个广告的转化率更高。在这种情况下，我们运行一个假设测试，我们将用户分成一个控制组和一个治疗组，并向他们展示不同的广告。然后，我们选择了一个指标来衡量每个小组的参与程度。

A/B 测试 也有其 的弊端 :

• 它可以帮助你比较两个选项，但不能评估你没有考虑过的选项
• 由于 新奇效应 和 厌恶等因素，在对现有用户进行测试时可能会产生有偏差的结果。

新奇效果: 现有用户可能会对新版本产生优势，因为他们可能会对这种变化感到兴奋，即使在更长的时期内这对他们没有任何好处

变更厌恶: 现有用户可能会因为对变更不满和/或更*惯旧版本而给予旧版本优势[2]。

二进制数据的 A/B 检验:两样本比例检验

首先，我们来谈谈二进制数据。 二进制数据 只能有两个值:1 或 0，男性或女性，通过或失败等。当我们计算比例或百分比时，二进制数据很有用。如果你能把一个观察结果分成两类——你就有了一个二元变量。

二进制数据遵循几种分布中的一种。最常见的是二项分布。 二项式分布 是一种概率分布，表示在给定的一组假设或参数下，一个值取两个独立值之一的可能性【3】。

二项式分布的一个例子。图片来源于作者

二项分布有以下 假设 :

1. 只有 2 种可能的结果 。例如 0 或 1、通过或失败等)
2. 每次审判 都是 独立——一次审判的结果不影响另一次审判。例如，抛一枚公平的硬币
3. 概率 随时间保持 常数 。例如，在生产中，随着时间的推移，可能会出现生产缺陷产品的变化
4. 试验次数 为 固定【1】。

当我们在假设检验和二项分布的背景下谈论二元数据时，我们也可以听到事件、试验和比例。

事件 —结果的集合或二进制数据中的两个值之一。

试验 —每组中被测试的人数或项目数。

比例 —事件/审判[1]。

当我们想要检查两个总体的比例是否存在差异时，我们应用两样本比例 z - 检验。让我们通过一个 Python 代码的例子来理解测试是如何工作的，以及如何解释它的结果。

营销活动的双样本比例 z 检验

数据

我正在使用来自 Kaggle 的营销活动数据集。提供数据集是为了发现广告是否成功，公司可以从广告中获得多少，以及两组之间的差异是否具有统计学意义[4]。

让我们看一下数据

**

数据清理

让我们做一些简单的数据清理和汇总数据，看看每个组的比例是多少。

*# Drop a column
df.drop(columns=[‘Unnamed: 0’], inplace=True)# Let us rename columns
df.columns = ['user_id', 'test_group', 'converted', 'total_ads',
              'most_ads_day', 'most_ads_hour']# Let's rename 'ad' and 'psa' to 'treatmen' and 'control'
df.replace({'test_group':{'ad':'treatment',
                          'psa':'control'}}, inplace=True)# Calculate conversion rate/proportion per user group
df_gr = df.groupby('test_group').agg({'converted':'sum',
                                 'user_id':'nunique'}).reset_index()df_gr.columns = ['test_group', 'converted', 'unique_users']
df_gr['proportion'] = (df_gr['converted']) / df_gr['unique_users']*

让我们看看每个用户群的比例

治疗组的转化率高于对照组，分别为 2.55%和 1.78%。让我们了解一下这种差异在统计上是否显著。

假设检验

我们将对照组的转化率命名为比例 1 ( p1 )，将处理组的转化率命名为比例 2 ( p2 )。

然后，

• H0: p1 = p2
• H1: p1 < p2(左尾)

零假设表示比例没有差异，而另一个假设表示比例 1 小于比例 2。即存在广告的效果。

在我们开始应用双样本比例 z 检验之前，让我们计算一下这个比例差异所需的最小样本量。

估计样本量

*def z_calc(p1, p2, n1, n2):
    p_star = (p1*n1 + p2*n2) / (n1 + n2)
    return (p2 - p1) / math.sqrt(p_star*(1 - p_star)*((1.0 / n1) + (1.0 / n2)))def sample_required(p1, p_diff, alpha):
    if p_diff <= 0:  # p_diff = p2-p1
        raise ValueError("p_diff must be > 0")
    n = 1
    while True:
        z = z_calc(p1, p1+p_diff, n1=n, n2=n)
        p = 1 - stats.norm.cdf(z)
        if p < alpha:
            break
        n += 1
    return nsample_size = sample_required(df_gr[['proportion'][0]][0],
                             (df_gr[['proportion'][0]][1] -       df_gr[['proportion'][0]][0]),
0.05)*

每组的样本量为 1，942。让我们将用于分析的 样本量 设置为【20，000】，这远远高于所需的最小样本量，略低于最小用户群规模(治疗组为 23，524 个用户)。通常，样本量越大，结果就越接*总体结果。

随机抽样

*# Split the data into 2 dataframes for each group
df_tr = df[df[‘test_group’] == ‘treatment’]
df_ctrl = df[df[‘test_group’] == ‘control’]# Take random samples
df_tr_sample = df_tr.sample(n=20000, random_state=23)
df_ctrl_sample = df_ctrl.sample(n=20000, random_state=23)df_sample = pd.concat([df_tr_sample, df_ctrl_sample], ignore_index=True)# Calculate proportions
df_sample_gr = df_sample.groupby('test_group').agg({'converted':'sum',
                                 'user_id':'nunique'}).reset_index()df_sample_gr.columns = ['test_group', 'converted', 'unique_users']
df_sample_gr['proportion'] = (df_sample_gr['converted']) / df_sample_gr['unique_users']*

随机样本数据的比例

估计统计显著性

*# Looking at df_sample_gr, let us fill in the success numbers and the total sample sizes for each groupnumber_of_successes = [348, 497]
total_sample_sizes = [20000, 20000]# Calculate z-test statistic and p-value
test_stat, p_value = proportions_ztest(number_of_successes, total_sample_sizes, alternative='smaller')*

结果🎉

假设在实验开始前建立了 5%的显著性水平。在这种情况下，我们看到我们的 结果是统计显著的 和 我们有证据拒绝零假设 。

P 值 显示样本证据反对零假设的强度。如果低于显著性水平，则您的结果在统计上是显著的。换句话说，p 值告诉您样本数据与空值的矛盾程度。较低的 p 值代表了反对零的更有力的证据。

摘要

• 双样本比例测试 允许您 比较两个用户组 的比例，这在市场营销中用于评估转换率/其他基于二进制数据的指标的差异
• 结果显示，在对照组和治疗组之间存在统计学上的显著差异
• 随着测试的进行，我们学*了如何计算双样本比例测试的样本量，并了解了假设和 A/B 测试之间的差异。

感谢您的阅读，请在下面评论您对 A/B 测试及其在现实问题中的应用的看法。

博文的 Jupyter 笔记本可以在我的 GitHub 上找到。

关于作者

Aigerim 是一名工程师出身的数据科学家，喜欢从数据中寻找见解。她坚信，通过更好地理解数据和应用机器学*算法，我们可以让世界变得更美好。

Aigerim 是一名数据科学家@ Rakuten，通过提供见解和致力于创建可扩展的数据科学产品，帮助各种外部客户做出更好的商业决策。

在空闲时间，Aigerim 喜欢阅读书籍，喜欢跑步和与她的助手 Taquito 一起去狗公园🐶

最后，请通过 Linkedin 和 Medium 联系 Aigerim。

参考

1. 弗罗斯特 J. (2020)。假设检验:数据驱动决策的直观指南。吉姆出版社的统计。
2. Udacity 关于 A/B 测试的课程:https://www.udacity.com/course/ab-testing-ud 257
3. **二项式分布如何工作。(2021 年 10 月 9 日)。Investopedia。2022 年 7 月 3 日检索，来自https://www . investopedia . com/terms/b/binomialdistribution . ASP
4. 法维奥·巴斯克斯。(2021).营销 A/B 测试(许可证:CC0:公共领域；版本 1)[数据集]。卡格尔。https://www . ka ggle . com/datasets/faviovaz/marketing-ab-testing

随机森林的 A/B 测试

原文：https://towardsdatascience.com/a-b-testing-with-random-forest-b3c1421224dd

基于随机森林的一般非参数 A/B 检验

图 1:来自原始论文的图(作者)“使用随机森林进行双样本测试”显示了测试的 p 值和变量重要性(左)以及数据在两个判别分量上的投影(右)。

撰稿人:洛里斯·米歇尔，杰弗里·纳夫

A/B 测试在商业决策中的重要性并不是一个新话题。我们可以将读者引向这个故事来很好地概括 A/B 测试背后的主要步骤和挑战。

然而，在选择测试统计数据时，有时会发现这是一项具有挑战性的任务，因为缺少比较 A 组和 b 组的精确指标。事实上，我们可能无法提前知道两组中潜在的数据偏移会是什么情况。然而，我们仍然希望获得一个有效的统计检验，该检验可以:

• 检测A 组和 B 组之间复杂的变化模式(这意味着该测试具有对抗广泛备选方案的能力)；
• 告知分布变化(如果测试不合格，提供关于分布差异的见解)。

在这个故事中，我们想要讨论一个最*的关于在双样本测试中使用分类的研究系列，它允许构造非常灵活的非参数测试，就像我们的 论文 中建议的那样。

如何利用分类做 A/B 测试？

一般的双样本检验问题是基于两组样本(A: X_1，…，X_2 和 B: Y_1，..Y_2)假设分别来自两个不同的分布 P 和 Q，不管它们实际上是否来自同一分布，即 P=Q(零假设)。

想象一下，我们给来自 A 组的样品贴上一个标签(比如 1)，给来自 B 组的样品贴上另一个标签(比如 0)，与分类相对应的是一个有趣的类比:

如果可以根据给定的比随机更好的分类度量(例如准确度)在两组样本 A 和 B 之间进行分类(辨别),那么这应该见证两组之间的分布差异。相反，如果组 A 和 B 之间存在分布差异，则(适当的)分类器应该能够检测到这种差异，从而比随机地对这两个组进行更好的分类(再次根据某个分类度量)。

测试和分类概念之间更正式和详尽的比较可以在 Kim et al. 2016 中找到。我们现在提出一个我们在论文中做出的具体选择，即使用随机森林算法及其非常著名的 out-of-bag 度量。

随机森林和袋外(OOB)措施

随机森林是统计学*中非常著名的算法(我们可以将读者引向这篇的帖子以获得对随机森林的直观理解)。当涉及到分类任务时，它在真实数据集上的良好性能使它成为机器学*中非常受欢迎的算法(参见例如 Delgado et al. 2012 )。

在我们的论文中，我们建议使用随机森林算法中著名的出袋(OOB)度量(参见这篇文章以直观理解 OOB 度量)。更具体地说，我们使用每组(A 和 B)的 OOB 准确度之和作为测试统计量和使用排列构建有效测试。图 2 提供了一个可视化描述我们的过程的模式，对于正式的演示，我们将读者引向我们的 页面 r，特别是关于我们的测试的更多细节和上下文的介绍。

图 2:hypo RF 测试程序示意图(作者)。在右侧，我们可以看到 p 值(上图)和变量重要性(下图)是如何通过排列产生的。

例子

作为一个玩具说明性示例，我们考虑来自 5 维上的两个分布 P 和 Q 的样本，它们具有以下特性:

• P 和 Q 都是多元正态分布，有标准正态余量；
• P 具有作为协方差矩阵(独立边缘)的单位矩阵，而 Q 与 P 的不同之处仅在于在其第四和第五分量之间具有正相关性 0.8。

在图 1 中，我们可以观察到 P 值相当小(例如，显著性为 5%)，这表明测试将拒绝空值(P=Q ),并能够根据左下方的变量重要性图发现分布变化的驱动因素(即使在这种情况下，变化仅出现在相关性中)。右图显示了采样点的最后两个分量。在左上角，估计的平均值，按组成部分和类别，这表明，如果只看边际，没有明显的分布差异。我们可以看到，根据零阈值(红色虚线)，最后两个分量被提取为相关变量。

结论

当涉及到 A/B 检验(双样本检验)时，通常情况下，当实验设计允许时，非常简单和基本的检验(t 检验、二项式检验等)就足够了。然而，值得记住的是，受机器学*分类启发的现代方法可以提供有效和强大的双样本测试。当事先不知道 A 组和 b 组之间的潜在差异时，这些测试可以在复杂的环境中帮助数据科学家。

免责声明和资源: 我们意识到我们遗漏了许多细节(效率、关于何时使用或不使用此类测试的指导、功率研究等)，但希望能够打开思维的视野。我们的 页面R中可以找到 M 矿石的详细信息以及与现有测试的比较，并查看 CRAN 上的 R-package hypolf。

A/B 测试、隐私和在线回归

原文：https://towardsdatascience.com/a-b-tests-privacy-and-online-regression-b07ab46aa782

因果数据科学

如何在不存储个体水平数据的情况下运行实验

封面图片，由作者使用nightcafe生成

AB 测试，又名随机对照试验，被广泛认为是计算治疗(药物、广告、产品等)对相关结果(疾病、公司收入、客户满意度等)的因果影响的黄金标准技术。该程序包括将一组受试者(患者、使用者、顾客……)随机分为治疗组和对照组，并对治疗组进行治疗。随机性确保两组之间的预期差异由治疗引起。

在 A/B 测试中，一个潜在的隐私问题是，为了评估治疗的效果，需要在整个实验过程中存储许多用户的数据。如果我们可以即时运行实验，这不是问题，但是当实验持续时间很长时，这可能会成为一个问题。在这篇文章中，我们将探索这个问题的一个解决方案:在线回归。我们将看到如何估计(有条件的)平均治疗效果，以及如何使用中心极限定理和 bootstrapping 进行推断，一次一个观察值，仅存储汇总信息。

⚠️:我已经省略了一些方程式后面的代数运算。如果你想看更多的背景代数，让我知道，我会很高兴地添加另一部分。

简单的例子

假设我们是一家金融科技公司。我们为我们的移动应用程序设计了一个新的用户界面(UI ),我们希望了解它是否会降低我们的交易速度。为了评估新用户界面对交易速度的因果影响，我们计划运行一个 A/B 测试或随机控制试验:我们将用户随机分成两组，向其中一组展示新用户界面，并比较两组的平均交易速度。

我们有一个主要问题:由于隐私原因，我们不能存储事务级信息。此外，我们不能一次性完成实验，因为我们只在交易完成时观察交易。我们能做什么？

先来看看数据。我从[src.dgp](https://github.com/matteocourthoud/Blog-Posts/blob/main/notebooks/src/dgp.py)导入数据生成过程dgp_credit()，从[src.utils](https://github.com/matteocourthoud/Blog-Posts/blob/main/notebooks/src/utils.py)导入一些绘图函数和库。为了不仅包括代码，还包括数据和表格，我使用了 Deepnote ，一个类似 Jupyter 的基于网络的协作笔记本环境。

首先，我生成整个数据集。然后，我们将研究如何在数据动态到达的情况下执行实验分析。

我们有 100 个用户的信息，我们观察他们是否被随机分配了newUI，他们的connection速度和transfer速度。

首先，让我们通过在治疗指标(newUI)上回归感兴趣的结果(transfer速度)来估计治疗效果。随机化确保newUI的系数是因果治疗效果的无偏估计。

newUI的系数为正(6.5008)，但无统计学意义(p=0.113)。

我们怀疑connection速度也会影响transfer速度，对其进行分析可能会增加其功率。让我们运行同样的回归，添加log(connection)作为协变量。

实际上，估计的系数没有太大变化，但是标准误差已经减小，系数现在在 5%的水平上具有统计显著性(p = 0.031)。

为了理解我们如何一次运行一个数据点的线性回归，我们首先需要一个简单的线性代数回顾。

首先，让我们定义 y 因变量，transfer速度，以及 X 解释变量，newUI指示器，log(connection)速度和一个常数项。

OLS 估计量由下式给出

OLS 估算公式，作者图片

事实上，我们得到了与使用smf.ols命令完全相同的数字！

我们可以一次一个观察值地计算 OLS 系数βT4 吗？

答案是肯定的！假设我们有 n 个观察值，并且我们刚刚收到第 n+1 个观察值:一对(xₙ₊₁，yₙ₊₁).为了计算 β̂ₙ₊₁，我们只需要在内存中存储两个对象:

• β̂ₙ，先前估计的 β
• (Xₙ'Xₙ)⁻，X'X)⁻的前值

首先，我们如何更新(X'X)⁻？

更新规则(X'X)⁻，图片由作者提供

更新完(X'X)⁻)之后，我们可以更新 β̂ 。

更新β 的规则，图片作者

请注意，这个过程不仅是隐私友好的，而且是记忆友好的。我们的数据集是一个 100×4 的矩阵，而 X'X)⁻是一个 3×3 的矩阵，β是一个 3×1 的矩阵。我们只存储 12 个号码，而不是多达 400 个！

我们现在准备估算我们的 OLS 系数，一次一个数据点。然而，我们不能真的从第一次观察开始，因为我们不能对矩阵 X'X 求逆。我们至少需要 k+1 个观测值，其中 k 是 X 中变量的个数。

为了安全起见，我们使用 10 次观察中的一次热启动。

我们得到了完全相同的系数！不错！

我们是如何到达那里的？随着数据的积累，我们可以绘制出β̂估计值的演变图。动态标绘功能稍微麻烦一点，不过你可以在[src.figures](https://github.com/matteocourthoud/Blog-Posts/blob/main/notebooks/src/figures.py)里找到。

正如我们所看到的，随着数据点数量的增加，估计值似乎变得越来越不稳定。

这是真的吗？像往常一样，我们不仅对newUI对支出影响的点估计感兴趣，我们还想了解这个估计有多精确。

推理

我们已经看到了如何“在线”估计治疗效果:一次一个观察。我们可以用同样的方法计算估计量的方差吗？

首先，让我们回顾一下 OLS 估计量的方差是什么样子的。在基线假设下，OLS 估计量的方差由下式给出:

OLS 估计量的方差公式，作者图片

其中 σ̂ 是残差e=(y−x'β̂的方差。

回归表报告了系数的标准误差，即 Var(β̂) 对角元素的平方根。

让我们检查一下，使用矩阵代数我们确实会得到相同的数。

的确，我们得到了完全相同的数字！

我们已经有方法在线更新 β̂: (X'X)⁻ )的一部分方差。我们如何更新σ̂？这是更新残差平方和的公式。

按作者更新图像的规则

为了从残差平方和 S 中得到残差方差 σ̂ ，我们需要除以自由度:n–k = 100–3。

注意顺序很重要！S 是使用 X'X)⁻和β̂ 的旧值计算的，因此必须首先更新。

我们现在可以一次一个观测值地计算 β̂ 及其估计方差。

我们确实得到了同样的结果！

如前所述，我们可以绘制 OLS 系数估计值随时间的演变，并增加正负一个标准差的置信区间。

正如我们所看到的，OLS 估计量的估计方差确实随着样本量的增加而减小。

引导程序

到目前为止，我们已经使用了中心极限定理背后的渐*假设来计算估计量的标准误差。然而，我们有一个特别小的样本。我们进一步检查模型残差的经验分布。

残差好像特别偏！在如此小的样本中，这可能是一个问题。

大样本理论的另一种选择是自助法。我们不再依赖中心极限定理，而是通过替换对数据集进行重新采样来*似估计量的分布。我们可以在线自举吗？

答案再次是肯定的！关键是用从均值(和方差)等于 1 的泊松分布中提取的整数权重对每个观察值进行加权。对于每个观察值，我们重复这个过程多次，并存储各自的中间估计值。我们将得到 K ，即自举样本的数量，而不是在任何时间点对 β 的单一中间估计。

(X'X)⁻和 β̂ 的更新规则变为

更新规则(X'X)⁻与引导权重，按作者排序的图像

和

使用引导权重更新 β̂ 的规则，图片作者

其中 w 是泊松权重。

我们现在可以运行在线评估。我们自举 K=1000 不同于 β̂ 的估计。

我们可以通过计算自举系数向量的标准差来估计治疗效果的标准差。

估计的标准误差与以前的值[5.05，3.01，1.49]略有不同，但相差不是很远。

最后，有些人可能想知道"为什么对离散重量而不是连续重量进行采样？”。的确，我们可以。这个过程被称为贝叶斯引导，你可以在这里找到更详细的解释。

结论

在这篇文章中，我们看到了如何运行一个实验，而不存储个人水平的数据。我们如何能够做到这一点？为了计算平均治疗效果，我们不需要每一个单独的观察值，但是存储一个更紧凑的表示就足够了。

该过程不仅是隐私友好的，而且是存储器高效的，因为反向得分矩阵(X'X)⁻和估计系数 β̂ 通常具有比数据集小得多的维度(只要 X 的维度小，这可能是随机控制试验中的情况)。

参考

[1] W. Chou，无资料保留的随机对照试验 (2021)，工作论文。

相关文章

• 实验、窥视和最佳停止
• 贝叶斯自举

密码

你可以在这里找到 Jupyter 的原始笔记本:

https://github.com/matteocourthoud/Blog-Posts/blob/main/notebooks/online_reg.ipynb

感谢您的阅读！

我真的很感激！🤗如果你喜欢这个帖子并且想看更多，可以考虑 关注我 。我每周发布一次与因果推断和数据分析相关的主题。我尽量让我的帖子简单而精确，总是提供代码、例子和模拟。

还有，一个小小的 免责声明 :我写作是为了学*所以错误是家常便饭，尽管我尽力了。当你发现他们的时候，请告诉我。也很欣赏新话题的建议！

Scikit Learn 中管道的基本介绍

原文：https://towardsdatascience.com/a-basic-introduction-to-pipelines-in-scikit-learn-bd4cee34ad95

使用 Python 中的 sklearn 创建第一个 ML 管道的 101

照片由西格蒙德在 Unsplash 上拍摄

管道

管道是一排管子，你可以把东西从一边放到另一边，而不会中断。

将这个概念转移到我们的领域，数据科学，管道将是按顺序放置的许多操作，其中每个输出都成为下一个任务的输入，就像一个链。

管道是一组按顺序发生的任务，其中一个任务的输出成为下一个任务的输入，直到它最终输出最终产品。

管道的好处是，它们使我们的数据准备更快。此外，用它创建的对象也可以很容易地用于测试集，使我们更容易处理尚未转换的测试集或新数据。

数据科学管道图。图片由作者提供。

准备

让我们从模块导入开始。

# Basics
import pandas as pd
import numpy as np# Pipeline
from sklearn.pipeline import Pipeline# Scaler for standardization
from sklearn.preprocessing import StandardScaler# Modeling
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

然后，我们将仅为演示目的创建一个数据集。

# Create dataframe
amt1 = np.random.randint(100,999, 1000)
amt2 = np.random.choice(np.random.randint(1500,200000), 1000)
b= np.random.randn(1000)
x = 0.195
x2 = 0.377df = pd.DataFrame({ 'group': np.random.choice([1, 2, 3], 1000),
'amt1': amt1,  'amt2': amt2,
'type': np.random.choice([11, 12, 21, 22, 3], 1000),
'result': ((amt1*x) + (amt2*x2) + b) })

数据集看起来像这样。我们将创建一个回归模型来预测结果变量。

数据集已创建。图片由作者提供。

如我们所见， amt2 的比例比 amt1、高得多，因此我们将在训练模型之前将它们放在相同的比例中。因此，一旦我们知道我们的步骤是什么，我们就可以创建一个包含两个元素的元组列表，其中第一个是步骤的名称，第二个是它的实例，如下所示:

( name_of_the_step', Instance() )

另一个提醒:确保您在管道中使用的实例是 sklearn 包的一部分，因为我担心它不能与来自其他库的方法一起工作。

建设您的第一条管道

让我们构建我们的第一个管道，并从sklearn中了解一些Pipeline() 方法。

1. 知道你想执行什么步骤。创建元组列表。

# Create the steps to be performed
steps = [('scale', StandardScaler()),
         ('LR', LinearRegression()) ]

2.创建管道对象。

pipe = Pipeline(steps)

3.拟合，预测，评分。

# Fit the pipeline
pipe.fit(X,y)# Score (for classification)
pipe.score(X, y)# Predict
pipe.predict(X.iloc[[0]])**[OUT]: array([15935.34117995])**

好的。我们刚刚创建了一个管道，将df数据框作为输入，在解释变量中应用缩放，并拟合一个线性回归模型。不错！

接下来，让我们在这些知识的基础上再做一点构建，并带来一个包含分类变量的数据集，这样我们就可以应用其他转换，并了解ColumnTransformer方法如何也可以非常有用地混合两个管道。

多层管道

在这一节中，我们将获得数据集Tips(native from seaborn)—，因为它有分类变量和数值变量—来处理预处理数据的管道，并用决策树模型对其建模。

让我们用df = sns.load_dataset("tips")加载数据。

Tips 数据集，内置于 seaborn。图片由作者提供。

就像我们以前学过的，我们首先必须知道我们要做哪些步骤。

• 我们需要对分类变量进行热编码。
• 我们想要调整数值变量。我们实际上不需要，因为这些数字在一个相似的规模上。但是在这种情况下，我们这样做只是为了学*。

如果你注意到，上面的每一个项目符号代表不同类型的变量:分类变量和数字变量。因此，在这种情况下，我们必须创建两个不同的管道。

首先，让我们在训练和测试中拆分数据集。

X = df.drop('tip', axis=1)
y = df.tip# Train test Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=12)

接下来，我们可以为OneHotEncoding创建管道。

# Tasks to perform
cat_steps = [('OHE', OneHotEncoder(drop='first', 
                                   handle_unknown='ignore'))]# Pipeline object
pipe_cat = Pipeline(cat_steps)

接下来，我们将为数字部分创建管道。

# Tasks to perform
num_steps = [('scale', StandardScaler()) ]# Pipeline object
pipe_num = Pipeline(num_steps)

好的。现在我们有两个管道对象。但是要将它们粘合在一起，使它们作为一个单独的变压器工作，我们必须使用sklearn中的ColumnTransformer方法。正在导入。

from sklearn.compose import ColumnTransformer

接下来，我们将收集分类变量和数值变量的名称作为列表，将它们作为列名输入，由每个管道进行转换。注意，我们调用了ColumnTransformer，并传递了 3 个元素的元组(name, pipeline_object, columns_to_transform)。

# Extracting the names of the categorical variables
categorical_vars = X.select_dtypes('category').columns.tolist()# Extracting the names of the numerical variables
numerical_vars = X.select_dtypes('number').columns.tolist()# Creating the multilayer pipe
one_pipe = ColumnTransformer(transformers=[
          ('numbers', pipe_num, numerical_vars),
          ('categories', pipe_cat, categorical_vars) ] )

如果您想看看这个转换的结果是什么样的，只需运行下面的代码。虽然，这不是模型拟合的必要步骤。

one_pipe.fit_transform(X)
**[OUT]:**
array([[ 1.,  0.,  1., ...,  0.,-0.31471131, -0.60019263],        
[ 0.,  1.,  1.,     ...,  0.,   -1.06323531,  0.45338292],        
[ 0\.        ,  1.,  1., ...,  0.,0.1377799 ,  0.45338292],

现在我们的数据已经预处理，我们可以建模。我们将添加一个带有SelectKBest的特征选择工具，并为此使用决策树回归器。

因此，下一步是导入DecisionTreeRegressor和SelectKBest并创建最后一个管道，将预处理和建模收集到一个对象中。

from sklearn.tree import DecisionTreeRegressor
from sklearn.feature_selection import SelectKBest, f_regression, mutual_info_regression# Final Pipeline
modeling = Pipeline([('preprocess', one_pipe),
('feature_selection', SelectKBest(score_func=f_regression, k=4)), ('model', DecisionTreeRegressor(criterion='absolute_error',
                                 min_impurity_decrease=0.006)) ])# Fit
modeling.fit(X_train, y_train)

这个最终的管道对象将执行以下步骤:

• 将数据作为输入，运行预处理管道。记住它是由执行一个热编码的pipe_cat和执行缩放的pipe_num组成的。
• 使用f_regression评分为模型选择 4 个最佳变量。
• 预处理后的数据将符合DecisionTreeRegressor模型。

我们可以评估该模型以查看结果。

# Predict
preds = modeling.predict(X_test)# Data Frame with some predictions
pd.DataFrame({'y_true': y_test, 'prediction': preds}).head(10)

接下来看看结果预测。

实际与预测。图片由作者提供。

我们看到有一些很好的预测。有些当场正确，有些不太好。让我们检查回归的度量。

# Mean Absolute Error
mean_absolute_error(y_test, preds)**[OUT]: 0.8914285714285712**

平均来说，我们会少 89 美分。tips 的真实数据平均值为 3.11。因此，0.89/3.11 大约是该值的 28%，表明我们的预测可能高达 30%。它不是最好的模型，但它服务于我们帖子的目的，展示如何在 Scikit Learn 中使用管道。

在你走之前

这篇文章向你介绍了 Scikit learn 的Pipeline方法。

• pipelines 是一个在单个对象中链接许多转换的对象。
• 定义步骤，并将它们放入格式为[('name of the step', Instance())]的元组列表中
• 数字数据和分类数据的管道必须分开。
• 我们可以使用ColumnTransformer方法合并两个或更多的管道。但是它不支持估计器(用于建模的算法)。

如果你喜欢这些内容，请关注我的博客，或者在 Linkedin 上找到我。

http://gustavorsantos.medium.com/

参考

https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html#sklearn.pipeline.Pipeline https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectKBest.html#sklearn.feature_selection.SelectKBest

批量过大:寻找适合 GPU 的批量大小

原文：https://towardsdatascience.com/a-batch-too-large-finding-the-batch-size-that-fits-on-gpus-aef70902a9f1

一个简单的函数，用于确定 PyTorch 型号的批量大小，该批量可以填充 GPU 内存

我相信你们中的许多人都有以下痛苦的经历:你在你的 GPU 上开始多个 ML 实验以通宵训练，当你 10 个小时后回来检查时，你意识到进度条几乎没有移动，因为硬件利用不足，或者更糟的是，所有实验都因内存不足(OOM)错误而失败。在这个迷你指南中，我们将实现一个自动方法来为您的 PyTorch 模型找到批量大小，该批量大小可以充分利用 GPU 内存而不会导致 OOM！

在 Unsplash 上由娜娜杜瓦拍摄的照片

除了模型架构和参数数量，批处理大小是控制实验使用的 GPU 内存量的最有效的超参数。找到可以充分利用加速器的最佳批量的适当方法是通过 GPU 配置文件，这是一种监控计算设备上的进程的过程。 TensorFlow 和 PyTorch 都提供了关于如何在其框架中执行概要分析的详细指南和教程。此外，批量大小会极大地影响模型的性能。例如，一个大的批量会导致较差的泛化能力，如果你对这个话题感兴趣的话，可以看看沈世爱关于批量对训练动态的影响的博客文章。

然而，如果你只是想训练一个模型来测试一个想法，那么通过剖析或执行超参数搜索来寻找最佳批量可能是多余的，尤其是在项目的早期阶段。一种常见的方法是，在使用nvidia-smi或[nvitop](https://github.com/XuehaiPan/nvitop)之类的工具监控 GPU 利用率的同时，用小批量训练模型，从而找到一个不需要 OOM 就可以拟合模型的值。然后，如果模型未充分利用 GPU 内存，则增加该值，并重复该过程，直到达到内存容量。但是，这种手动过程可能非常耗时。更令人恼火的是，当你不得不在不同内存大小的不同 GPU 上运行实验时，你必须为每台设备重复相同的过程。幸运的是，我们可以将这个繁琐的迭代过程转换成代码，并在实际实验之前运行它，这样您就知道您的模型不会导致 OOM。

这个想法很简单:

1. 初始化您的模型。
2. 将批次大小设置为 2(对于 BatchNorm)
3. 创建将样本形状作为真实数据的虚拟数据。
4. 训练模型进行n步骤(向前和向后传球)。
5. 如果模型运行时没有出现错误，则增加批量并转到步骤 3。如果 OOM 升高(即 PyTorch 中的RuntimeError),则将批量设置为之前的值并终止。
6. 返回最终的批量大小。

把它写成代码

如您所见，该函数有 7 个参数:

• model —你想要拟合的模型，注意，该模型将在函数结束时从内存中删除。
• device — torch.device应该是 CUDA 设备。
• input_shape —数据的输入形状。
• output_shape —模型的预期输出形状。
• dataset_size —数据集的大小(当批处理大小已经大于数据集的大小时，我们不想继续搜索)。
• max_batch_size —设置要使用的最大批量的可选参数。
• num_iterations —增加批量前更新模型的迭代次数，默认为 5 次。

让我们快速浏览一下函数中发生了什么。我们首先将模型加载到 GPU，初始化 Adam optimizer，并将初始批处理大小设置为 2(如果您没有使用 BatchNorm，可以从批处理大小 1 开始)。然后我们可以开始迭代过程。首先，我们检查当前的批处理大小是否大于数据集的大小或所需的最大批处理大小，如果是，我们就中断循环。否则，我们创建虚拟输入和目标，将它们移动到 GPU 并拟合模型。我们用 5 个步骤训练模型，以确保向前或向后传球都不会导致 OOM。如果一切正常，我们将批量乘以 2，并重新拟合模型。如果在上述步骤中发生了 OOM，那么我们将批量减少 2 倍并退出循环。最后，我们从内存中清除模型和优化器，并返回最终的批量大小。就是这样！

注意，在 OOM 的情况下，不是简单地将批量大小除以 2，而是可以继续搜索最优值(即，二分搜索法批量大小，将批量大小设置为中断值和最后工作值之间的中点，并继续步骤 3。)来找到最适合 GPU 的批量大小。然而，请记住 PyTorch/TensorFlow 或其他进程可能会在实验过程中请求更多的 GPU 内存，您可能会面临 OOM 的风险，因此我更喜欢有一些回旋的空间。

现在让我们把这个功能投入使用。在这里，我们将 ResNet50 拟合在由 FakeData 数据集生成的大小为(3, 224, 224)的 1000 个列车合成图像上。简单来说，我们首先调用get_batch_size=(model=ResNet(), input_shape=IMAGE_SHAPE, output_shape=(NUM_CLASSES,), dataset_size=DATASET_SIZE)来获取能够充分填满 GPU 内存的批量大小。然后，我们可以初始化模型和数据加载器，并像平常一样训练模型！

下面的 GIF 是在 Nvidia RTX 2080 8GB 上运行示例代码的屏幕记录。我在find_batch_size函数中添加了一些打印语句，以显示它正在测试的批处理大小，并注意随着函数增加批处理大小，GPU 内存使用量也在增加。我们的脚本确定批处理大小为 16 会导致 OOM，并运行其余的训练代码，批处理大小为 8，GPU 内存利用率约为 66.8%。

在 Nvidia RTX 2080 8GB 上运行示例代码，该脚本确定批量大小为 16 会导致 OOM。[作者 GIF

当我们在 Nvidia RTX 2080Ti 11GB 上运行完全相同的代码时，我们能够以 16 的批处理大小和 90.3%的 GPU 内存利用率运行。

在 Nvidia RTX 2080Ti 11GB 上运行示例代码，该脚本确定批量大小为 32 会导致 OOM。[图片由作者提供]

你有它！您可以将一个简单的函数添加到训练脚本的开头，以找到一个可以充分利用 GPU 内存而不用担心 OOM 错误的批处理大小。

最后，这里有一些关于批量大小及其对深度神经网络的影响的文章和论文。

• 历元对批量对迭代
• 批量大小对训练动态的影响
• 训练一个神经网络的最佳批量是多少？
• 关于深度学*的大批量训练:泛化差距和尖锐极小值
• 不衰减学*率，增加批量

对初学者友好的 Kubernetes 介绍

原文：https://towardsdatascience.com/a-beginner-friendly-introduction-to-kubernetes-540b5d63b3d7

没必要这么复杂，对吧？

通过动手 MLFlow 部署示例

洛伦佐·埃雷拉在 Unsplash 上的照片

让我们开始吧。

如果你正在阅读这篇文章，很可能是因为你听说过这个时髦词“Kubernetes”(K8s)，你很可能在技术领域。您可能也对什么是容器化(或者称为 Docker / dockerization)有所了解，所以我将跳过这个细节，直接进入 K8s 是什么。

介绍

简而言之，K8s 只是一个容器编排框架。这实质上意味着 K8s 是一个旨在自动化容器化应用的生命周期的系统——从可预测性、可伸缩性到可用性。

如果您正在使用 Kubernetes 来设置您的数据科学基础架构，请务必查看一下Saturn Cloud，这是一个可扩展、灵活的数据科学平台，提供包括 GPU 在内的计算。

我们为什么需要 Kubernetes？

K8s 的兴起和需求背后的驱动原因源于微服务的使用越来越多，远离传统的单片类型的应用。因此，容器为这些单独的微服务提供了完美的主机，因为容器管理依赖性、独立、与操作系统无关和短暂等优点。

具有许多组件的复杂应用程序通常由数百甚至数千个微服务组成。如果我们要使用定制的程序或脚本来管理所有这些不同的组件，在确保可用性的同时扩展这些微服务是一个极其痛苦的过程，因此需要一种适当的方式来管理这些组件。

线索 Kubernetes 。

Kubernetes 的优势

Kubernetes 承诺使用以下功能解决上述问题:

1. 高可用性 —这意味着无论您有新的更新要推出，还是有一些意外的 pods 崩溃，您的应用程序都将一直正常运行。
2. 可伸缩性——这确保了应用程序的高性能，无论是单个用户还是一千个用户同时涌入你的应用程序。
3. 灾难恢复 —这确保了如果您的物理或基于云的基础架构发生意外，您的应用将始终拥有最新的数据和状态。

它是如何在引擎盖下工作的

K8s 使用主从式架构，其中一个节点充当主节点，在集群中发号施令，而其他节点充当从节点/工作节点，执行由主节点决定的应用程序工作负载。

简单的 Kubernetes 建筑

带有一个主节点和两个工作节点的简单 K8s 设置如下所示:

带有一个主节点和两个从节点的 K8s 设置示例(由作者举例说明)

主节点

顾名思义，主节点是集群的老板，决定集群状态和每个工作节点的工作。为了设置一个主节点，需要在其上运行 4 个进程:

1。API 服务器

• 主入口点供用户与集群交互(即集群网关)；当我们使用kubectl时，它是发送请求的地方
• 用于认证和请求验证的看门人，确保只有特定用户能够执行请求

2。调度器

• 决定下一个 pod 将在哪个节点上旋转，但不旋转 pod 本身( kubelet 这样做)

3。控制器管理器

• 检测群集状态变化(例如，pod 正在死亡)并尝试将群集恢复到其原始状态
• 例如，如果一个 pod 意外死亡，控制器管理器向调度器发出请求，以决定哪个节点启动新的 pod 来替换死亡的 pod。库伯莱然后旋转新的吊舱。

4。etcd

• 集群脑！
• 群集状态的键值存储
• 所做的任何群集更改都将存储在此处
• 这里不存储应用程序数据，只存储集群状态数据。记住，主节点不做工作，它是集群的大脑。具体来说， etcd 存储集群状态信息，以便上面的其他进程知道关于集群的信息

从属/工作节点

每个 worker 节点必须安装 3 个节点进程，以允许 Kubernetes 与它进行交互，并在每个节点内独立启动 pod。需要的 3 个过程是:

1。库伯莱又名*kubelet*

• 与节点和容器交互
• 负责获取配置文件并使用容器运行时启动 pod(见下文！)安装在节点上

2。容器运行时间

• 安装的任何容器运行时(例如， Docker ， containerd )

3。库贝代理又名*kube-proxy*

• 实现 Kubernetes 服务概念的一部分的网络代理
• 位于节点之间，智能地转发请求(节点内或节点间转发)

库伯内特斯的成分

现在我们知道了 K8s 的工作原理，让我们来看看 Kubernetes 中一些最常见的T4 组件，我们将使用它们来部署我们的应用程序。

1.豆荚

• K8s 的最小单元，通常包含应用程序的实例
• 容器上的抽象
• 每个 pod 都有自己的 IP 地址(公有或私有)
• 短暂—重新创建 pod 时的新 IP 地址

2。服务

• 因为 pod 本来就是短暂的，所以服务提供了一种方法来“给予”pod 一个永久的 IP 地址
• 使用服务，如果 pod 终止，其 IP 地址在重新创建时不会改变
• 充当几乎的负载平衡器，将流量路由到 pod，同时保持静态 IP
• 像负载平衡器一样，服务也可以是内部的或外部的，其中外部服务是面向公众的(公共 IP ),内部服务是针对内部应用的(私有 IP)

3。入口

• 有了服务，我们现在可以在某个端口上公开一个 web 应用程序，比如 IP 地址 10.104.35 上的 8080。实际上，在[http://10.104.35:8080](http://10.104.35:8080.) 上访问面向公众的应用是不切实际的。
• 因此，我们需要一个具有正确域名的入口点(例如，https://my-domain-name.com)，然后将请求转发给服务(例如，[http://10.104.35:8080](http://10.104.35:8080)) ))
• 本质上， Ingress 向集群【1】内的服务公开来自集群外的 HTTP 和 HTTPs 路由。
• SSL 终止(又称为 SSL 卸载 ) —即服务及其 pod 的流量是明文
• 也就是说，单独创建入口资源没有任何效果。还需要一个入口控制器来满足入口。

Ingress 如何与 Ingress 控制器一起工作(由作者说明)

4。入口控制器

• 对群集中服务的传入流量进行负载平衡
• 还管理需要与外部服务通信的服务的出口流量

Ingress 和 Ingress 控制器有什么区别？

入口包含路由流量的规则，决定传入请求应该路由到集群中的哪个服务。

Ingress 控制器是 Ingress 的实际实现，负责第四层或第七层代理。入口控制器的例子有 入口 NGINX 控制器 和 入口 GCE 。每个云提供商和其他第三方提供商将拥有自己的入口控制器实施方案。

完整名单可以在 这里 找到。

5.配置图

• 顾名思义，它本质上是一个配置文件，您希望公开给用户修改

6.秘密

• 也是一个配置文件，但用于存储密码等敏感信息
• Base64 编码

7.卷

• 用于持久数据存储
• 因为 pod 本身是短暂的，所以卷用于持久存储信息，以便现有的和新的 pod 可以引用应用程序的某些状态
• 几乎就像您的豆荚的“外部硬盘驱动器”
• 卷可以本地存储在运行 pod 的同一个节点上，也可以远程存储(例如云存储，NFS)

8.部署

• 用于定义 pod 的蓝图
• 实际上，我们处理的是部署，而不是 pod 本身
• 部署通常有副本，因此当应用程序的任何组件失效时，总会有备份
• 然而，像数据库这样的组件不能被复制，因为它们是有状态的应用程序。在这种情况下，我们需要 Kubernetes 组件: StatefulSet 。这很难做到，通常情况下，数据库应该托管在 Kubernetes 集群之外

好吧，那可能太多了，难以消化。让我们开始动手练*吧！一定要花些时间重新阅读上面的内容，以便清楚地了解整个 K8s 架构中每个组件的职责。

我们来练*一下！

因为本文的重点是理解 K8s 的组件本身，而不是如何设置 K8s 集群，所以我们将简单地使用minikube来设置我们自己的本地集群。之后，我们将部署一个简单但现实的应用程序—一个 MLFlow 服务器。

如果你想了解源代码，我已经把它们包含在 GitHub repo 这里。

我们将建立什么

一个典型的应用程序有一个带有后端服务的 web 服务器来保存数据——这是我们今天要复制和部署的目标。为了让事情变得更简单，我们将部署一个 MLFlow web 服务器，它将数据保存在谷歌云平台(GCP)上的云 SQL 数据库中。

设置如下所示:

具有远程跟踪服务器、后端和工件存储的 ml flow(图片来源: MLFlow 文档)

对于那些不知道的人来说，MLFlow 主要是一个实验跟踪工具，允许数据科学家通过记录数据和模型工件来跟踪他们的数据科学实验，并可以选择使用 MLFlow 定义的标准化包来部署他们的模型。出于本文的目的，我们将使用 PostgreSQL 后端(托管在云 SQL 上)和 blob 存储(在 Google 云存储上)部署 MLFlow 跟踪 web 服务器。

在此之前，我们必须安装一些东西(如果你已经安装了这些东西，请跳过)。

装置

1. 码头工人
2. K8s 命令行工具，kubectl。我们最好的朋友——我们用它来与我们的 K8s 星团互动，不管它是 minikube 、云还是混合星团
3. Minikube 安装指南
4. 谷歌云 SDK
5. kubectl、kubens、kubectx可选电动工具。按照这个安装。

设置本地集群

从minikube start开始你的集群。就是这样！您已经用一个命令创建了自己的本地 Kubernetes 集群:)

您可以验证上面列出的各种组件是用minikube status创建的。如果您有几个 K8s 集群上下文，请确保切换到 minikube。

# Check context
kubectx# If not on minikube, switch context
kubectx minikube

对于本地集群设置，让我们从设置外部组件开始，然后继续部署 Kubernetes 对象。

1。为 MLFlow 创建一个 docker file

我们首先需要一个将要部署的 MLFlow web 服务器的 Docker 映像。不幸的是，MLFlow 没有我们可以在 DockerHub 上使用的官方图像，所以我在这里创建了一个供大家使用。让我们从 DockerHub 中调出我创建的图像。

docker pull davidcjw/example-mlflow:1.0

[ 可选的 ]要测试映像是否在本地工作，只需运行:

docker run -p 8080:8080 davidcjw/example-mlflow:1.0

2。在 GCP 上创建一个云 SQL (PostgreSQL)实例

这将用于存储记录到 MLFlow 跟踪服务器上的运行的元数据。如前所述，在 Kubernetes 集群之外创建有状态应用程序更容易。

• 首先，在 GCP 上创建一个账户和项目，如果你还没有的话
• 使用 CLI 和以下命令创建一个实例:

gcloud sql instances create <**your_instance_name**> \
  --assign-ip \
  --authorized-networks=<**your_ip_address**>/32 \
  --database-version=POSTGRES_14 \
  --region=<**your_region**> \
  --cpu=2 \
  --memory=3840MiB \
  --root-password=<**your_password**>

要找到<your_ip_address>，简单谷歌“我的 ip 是什么”。对于<region>，可以指定离你比较*的地区。对我来说，我指定了asia-southeast1。

**NOTE!** These configs are intended for this example deployment and not suitable for production environments. For production environments, you would want to have minimally **multi-zonal availability** connected over a **Private IP**.

3。创建一个谷歌云存储桶

这将用于存储用户记录的数据和模型人工制品。在 GCP 上创建一个桶，并为以后记录 URI。对于我自己，我已经使用下面的命令在gs://example-mlflow-artefacts创建了一个:

gsutil mb -l <**your_region**> gs://example-mlflow-artefacts

4。在本地 **minikube** 集群上创建 ConfigMap 和 Secret

现在，激动人心的部分—在我们的 Kubernetes 集群上部署所需的各种组件。在此之前，了解一些关于 K8s 对象的事情是绝对必要的。

Kubernetes 资源是使用具有特定格式的.*yaml*文件创建的(请参考 Kubernetes 文档[2]了解您正在创建的任何资源类型)。它们用于定义哪些容器化的应用程序在哪个端口上运行，更重要的是，用于定义这些应用程序如何运行的策略。

**.yaml**文件有效地定义了我们的集群状态！****

描述 Kubernetes 对象 ( *.yaml*文件):

• 总是以apiVersion、kind开头，并有metadata
• apiVersion:定义 Kubernetes API 的版本号(如果您使用的版本处于稳定模式，通常是 v1)
• kind:定义组件类型(如 Secret、ConfigMap、Pod 等)
• metadata:唯一标识一个对象的数据，包括name、UID和namespace ( 以后会详细介绍！)
• spec(或规格)/ data:特定于组件的细节

4a。**让我们从 ConfigMap 开始，因为当我们使用部署部署我们的 MLFlow 应用程序时，将需要这些配置(注意 : 资源创建的顺序很重要，特别是当有配置或秘密附加到部署时)。

# configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: mlflow-configmap
data:
  *# property-like keys; each key maps to a simple value*
  DEFAULT_ARTIFACT_ROOT: <**your_gs_uri**>
  DB_NAME: postgres
  DB_USERNAME: postgres
  DB_HOST: <**your_cloud_sql_public_ip**>

💡 亲提示！ 始终有一个官方 K8s 文档的标签处于打开状态，因此您可以参考他们为每个 K8s 组件准备的示例 *.yaml* 文件。

****4b。接下来，让我们为秘密创建一个。请注意，机密必须是 base64 编码的。只需使用以下工具即可完成:

echo -n "<your_password>" | base64

我们唯一需要编码的是我们之前在 Cloud SQL 上创建 PostgreSQL 实例时定义的密码。让我们对其进行 base64 编码，并将标准输出复制到下面的.*yaml*文件中。

# secrets.yaml
apiVersion: v1
kind: Secret
metadata:
  name: mlflow-postgresql-credentials
type: Opaque
data:
  postgresql-password: <**your_base64_encoded_password**>

使用以下方式应用配置映射和密码:

kubectl apply -f k8s/configmap.yaml
kubectl apply -f k8s/secrets.yaml>>> configmap/mlflow-configmap created
>>> secret/mlflow-postgresql-credentials created

太好了！我们现在可以引用我们创建的秘密和配置。

5。创建部署和服务

5a。**先说部署。为了理解部署，让我们后退一步，回忆一下部署和 Pod 之间的主要区别在于，前者有助于创建将要部署的 Pod 的副本。因此，部署的yaml文件包含了 Pod 的配置，以及我们想要创建的副本数量。**

如果我们看一下下面的yaml文件，我们会注意到metadata和spec在配置中出现了两次，第一次在配置文件的顶部，第二次在“模板键的下面。这是因为在下面定义的所有内容"模板"键都用于 Pod 配置。****

简而言之，一个 Pod 组件部署我们应用程序的一个实例，而一个部署(通常)由该 Pod 的多个部署组成。如果我们部署中的副本数量为 1，那么它基本上与单个单元相同(但是可以选择纵向扩展)。

# deployment.yaml
**apiVersion**: apps/v1
**kind**: Deployment
**metadata**:
  **name**: mlflow-tracking-server
  **labels**:
      **app**: mlflow-tracking-server
**spec**:
  **replicas**: 1
  **selector**:
    **matchLabels**:
      **app**: mlflow-tracking-server-pods
  # Pod configurations defined here in `template`
  **template**:
    **metadata**:
      **labels**:
        **app**: mlflow-tracking-server-pods
    **spec**:
      **containers**:
        - **name**: mlflow-tracking-server-pod
          **image**: davidcjw/example-mlflow:1.0
          **ports**:
            - **containerPorts**: 5000
          **resources**:
            **limits**:
              **memory**: 1Gi
              **cpu**: "2"
            **requests**:
              **memory**: 1Gi
              **cpu**: "1"
          **imagePullPolicy**: Always
          **env**:
          - **name**: DB_PASSWORD
            **valueFrom**:
              **secretKeyRef**:
                **name**: mlflow-postgresql-credentials
                **key**: postgresql-password
          - **name**: DB_USERNAME
            **valueFrom**:
              **configMapKeyRef**:
                **name**: mlflow-configmap
                **key**: DB_USERNAME
          - **name**: DB_HOST
            **valueFrom**:
              **configMapKeyRef**:
                **name**: mlflow-configmap
                **key**: DB_HOST
          - **name**: DB_NAME
            **valueFrom**:
              **configMapKeyRef:**
                **name**: mlflow-configmap
                **key**: DB_NAME
          - **name**: DEFAULT_ARTIFACT_ROOT
            **valueFrom**:
              **configMapKeyRef**:
                **name**: mlflow-configmap
                **key**: DEFAULT_ARTIFACT_ROOT

需要回答两个重要问题:pod 副本如何组合在一起以被部署识别为一个副本？2)部署如何知道它属于哪一组 pod 副本？

1. template > metadata > labels:与其他组件如 ConfigMap 和 Secret 不同，此元数据关键字labels是强制性的，因为在此部署下创建的每个 pod 副本将具有唯一的 ID(例如， mlflow-tracking-xyz ， mlflow-tracking-abc )。为了能够将它们作为一个组来共同识别，使用了标签，使得这些 pod 副本中的每一个都将接收这些相同的标签集。
2. selector > matchLabels:用于确定本次部署下的吊舱组。注意这里的标签必须与【1】中的标签完全匹配。

作者图片

****其他关键配置:

• replicas:用于确定 pod 副本的数量
• containers > image:每个 pod 使用的图像
• containers > env:我们在这里指定将在每个 pod 中初始化的环境变量，从我们之前创建的 ConfigMap 和 Secret 中引用。

5b。 服务 —如上所述，服务几乎像负载平衡器一样用于将流量分配给每个 pod 副本。因此，以下是关于服务的一些重要注意事项。**

• selector:这个键值对应该与之前在部署中指定的template > metadata > labels相匹配，这样服务就知道将请求路由到哪组 pod。
• type:默认为ClusterIP，这是集群的内部 IP 地址(其他服务类型的列表可以在这里找到)。对于我们的用例，我们将使用NodePort在节点 IP 地址的端口上公开我们的 web 应用程序。请注意NodePort的值只能在 30000–32767 之间。
• targetPort:这是您的 pod 公开应用程序的端口，在部署中指定。

apiVersion: v1
kind: Service
metadata:
  labels:
    app: mlflow-tracking-server
  name: mlflow-tracking-server
spec:
  type: NodePort
  selector:
    app: mlflow-tracking-server-pods
  ports:
  - port: 5000
    protocol: TCP
    targetPort: 5000
    nodePort: 30001

****5c。整合在一起

事实上，您可以将几个.yaml配置放在一个文件中——特别是部署和服务配置，因为我们将一起应用这些更改。为此，只需使用---在一个文件中区分这两个配置:

# deployment.yaml
apiVersion: v1
kind: Deployment
...
---
apiVersion: v1
kind: Service
...

最后，我们使用kubectl apply -f k8s/deployment.yaml应用这些更改。恭喜你。您现在可以通过<node_IP>:<nodePort>访问您的 MLFlow 服务器。以下是如何找出你的node_IP是什么:

kubectl get node -o wide# or equivalently:
minikube ip

如果你是苹果芯片或 Windows 用户…

如果你像我一样使用 Darwin(或 Windows，WSL)上的 Docker 驱动程序，使用上述方法将无法直接到达节点 IP。完成此链接中列出的步骤 4 和 5，以访问您的应用程序。

清理

最后，我们完成了测试应用程序，清理就像minikube delete --all一样简单。

如果您正在使用 Kubernetes 来设置您的数据科学基础架构，请务必查看一下 土星云 ，这是一个可扩展、灵活的数据科学平台，提供包括 GPU 在内的计算。

最后的话

感谢您的阅读，希望这有助于您了解 Kubernetes。如果你发现了任何错误，或者你想在另一篇文章中了解更多，请告诉我！

支持我！ —如果你喜欢我的内容并且没有订阅 Medium，请考虑支持我并通过我在这里的推荐链接订阅 ( 注意:你的一部分会员费将作为推荐费分摊给我)。

参考

【1】什么是 Ingress？
【2】Kubernetes 文档
【3】娜娜的 Kubernetes 速成班
【4】访问应用(Minikube)