在这里免费获得前三章。

如何在 Python 类中创建只读和删除证明属性

原文：https://towardsdatascience.com/how-to-create-read-only-and-deletion-proof-attributes-in-your-python-classes-b34cd1019c2d?source=collection_archive---------25-----------------------

对类中的属性施加控制

图片由 Charles Deluvio 通过 Unsplash 提供

控制你的属性

本教程将演示如何在 Python 类中创建只读和防删除属性。通过这种方式，可以对您的属性应用额外的控制层，确保您的类按预期使用。虽然在 Python 中有多种方法可以创建只读和防删除属性，但使用 setattr 和 delattr dunder 方法是快速控制对象中属性的一种便捷方法。

示例:雇员类

设置属性一次

举例来说，假设我们正在创建一个简单的 Employee 类，它需要在对象中设置三个值。这些值将是雇员的姓名、年龄和唯一的 id 号。这些属性值将在属性中设置；并且用下划线表示，表示它们是私有属性，不打算在类外使用。

一旦设置了__init__方法，就有必要定义神奇的方法__setattr__。在这种方法中，我们可以应用一些简单的逻辑来施加强大的属性控制。在给出的例子中，当属性在对象初始化期间首先被设置时，方法将调用方法。我们可以通过应用以下逻辑来防止_name属性被重置。

为了实现这一点，我们可以编写一个条件，当设置一个新属性时，如果该属性等于_name 并且已经有一个值，那么程序将退出并引发一个内置的AttributeError异常，并在标准错误(stderr)输出中显示一条定制消息。_name属性是在对象初始化期间设置的，因此对该属性的任何重置都会引发异常并终止程序。

我们还可以进一步控制，确保_age和_id_number属性都是整数类型。我们可以创建一个列表，并在将它们设置为整数之前检查_age和_id_number属性是否在最后。下面的 setattr 方法显示了实现这一点的代码。

**注意:**在所示的例子中，当设置一个属性时，它不是使用 setattr 魔术方法中的 object.attribute 语法来设置的，而是使用object.__dict__[key] = value。如果我们使用前一种方法，将会启动一个无休止的递归循环，因为 object.attribute 语法将调用 setattr 方法！

现在，让我们创建一个 Employee 对象，并检查是否已经设置了属性。如图所示，属性已经设置，并且是正确的类型。

现在，假设我们想要重新设置_name属性，尽管它已经被设置了。在这种情况下，会引发AttributeError异常，并向控制台输出一条消息，通知用户 name 属性已经被设置，并且不能被重新设置。

删除证明属性

为了证明我们的名称属性删除，我们可以简单地向 dunderlattr 方法添加一些逻辑。这里，我们说如果用户试图从对象中删除属性名，将会出现一个AttributeError异常，通知用户名称属性不能被删除。但是，我们仍然允许用户删除 Employee 对象中任何其他属性的行为。

当我们试图从 Employee，emp_1 对象中删除受保护的 name 属性时，会引发一个AttributeError异常。

奖励:自定义信息类

虽然AttributeError类很好地向用户解释了当用户试图删除_name属性时程序为什么会退出，但是通过构建一个定制的异常类，这个原因可以变得甚至更加明确。

我们可以编写一个自定义的DeletionException类，如果用户试图删除_name属性，这个类将被引发。当DeletionException类被引发时，我们还可以有效地告诉用户 name 属性当前是什么。该消息可以打印到标准错误输出中。

为此，我们创建了一个DeletionException类，它从基本异常类继承并接受一个参数，这里是属性的初始值。当类被实例化时，例如当它被引发时，这个值在DeletionException对象中被设置。当它被引发时，我们将原始的 name 属性作为唯一的参数传递给该类。这发生在__delattr__方法内部。

当引发时，将调用__str__方法并打印出一条消息，通知用户不能删除 Employees 对象中的原始 name 属性。

摘要

可以通过定制逻辑修改 dunder 方法 setattr 和 delattr，以保护属性并控制它们的访问。此外，可以添加定制的异常类来有效地通知用户为什么属性受到保护。

如何创建实时人脸检测器

原文：https://towardsdatascience.com/how-to-create-real-time-face-detector-ff0e1f81925f?source=collection_archive---------1-----------------------

使用 Python、TensorFlow/Keras 和 OpenCV

实时人脸检测器。不是我——照片由西蒙·罗本从派克斯拍摄

在本文中，我将向您展示如何使用 Python、TensorFlow/Keras 和 OpenCV 编写实时人脸检测器。

我马上会注意到，所有代码文件都可以在这个 repo 中获得。

https://gitlab.com/Winston-90/me_not_me_detector/

首先，在理论部分我会告诉你一些对我们有用的概念(迁移学习和数据扩充)，然后我会在实践部分部分进行代码分析。

注意，您必须安装 TensorFlow 和 OpenCV 库来运行这段代码。你可以手动完成，或者在你下载了 repo 之后简单地运行pip install -r requirements.txt 命令。你也可以用 conda 命令conda install -c conda-forge numpy, opencv, tensorflow 来完成。

问题陈述

在这里，我想建立一个面部检测器，也可以区分我和其他人。你可以在本文末尾看到我的工作成果。

初始任务可以分为两个子任务:

1. 为人脸分类训练一个模型。
2. 调整模型，使其与作为检测器的网络摄像头一起工作。

更详细地说，该任务可以分为以下几个阶段:

1. 数据集集合。
2. 寻找迁移学习的基础模型。
3. 训练一个模特。
4. 将分类器转换为检测器。

在我开始分析这些阶段之前，我想非常简要地概述一下对我们有用的概念。

理论部分

在这一点上，我必须说，这个教程是不详细的，因为它可以。例如，我不会解释什么是卷积或者为什么在 CNN 架构中需要池层。当然，你需要知道这些才能理解 CNN 是如何工作的，但我认为如果我解释所有的概念，这个教程会太繁琐。另一方面，其他人已经解释了很多东西，而且做得比我好。例如，在这里你可以读到 CNN 的概况，而在这里——关于流行的 CNN 架构。

卷积神经网络

由于我们正在讨论图像识别，我们将使用 CNN —卷积神经网络，这种架构在这项任务中取得了最大的成功。

典型的卷积神经网络架构。 公共领域

与经典神经网络(这里我指的是FDN——前馈神经网络)不同，在 CNN 中，神经元是:

• 首先:以矩阵(张量)的形式排列，而不是数组，
• 其次:它们只与前一层的一小部分神经元相连，因此层之间并不完全相连。

这种方法允许您显著减少网络参数的数量，并使图像的模板搜索更有效。

前馈神经网络 vs 卷积神经网络。作者图片

在这张图的底部，我想说明一下，CNN 中的层是一个张量(经常被画成平行六面体)。我将把张量作为矩阵序列来讲。所以这些张量中的每一个都是一系列的矩阵，像披萨盒一样一个接一个的叠在一起。反过来，矩阵只是以矩阵形式排列的神经元序列，而不是像在经典网络中那样的阵列。

迁移学习

迁移学习是这项任务中最重要的概念，因为从头开始构建人脸分类器非常困难(几乎不可能)。迁移学习是在自己的任务中使用预先训练好的模型的过程。

转移学习。作者图片

这种情况发生如下。你找到一个为类似任务训练过的模型(例如，识别 1000 类图像，就像在 ImageNet 中一样，而你只需要识别少数几类)。然后使用它的权重(冻结它们，这意味着它们不会改变)，并在您的小数据集上完成模型的训练。之后还可以解冻所有权重，继续用极小的学习率训练模型。

由于 CNN 架构和图像识别任务的特征，该过程变得可能(但是也可以用于不同的架构)。网络学会从一层到另一层(从输入到输出)看到模式，它们变得越来越复杂。事实证明，所有问题的一般模式大致相同，这允许我们使用预先训练的权重。

数据扩充

图像分类问题中的另一个重要概念是数据扩充。数据扩充是通过对原始图像应用一些变换来人为增加数据集大小的过程。例如，我们可以使用水平和垂直反射、小旋转或放大、颜色反转等等。这将显著增加数据集的大小，从而提高网络的概化能力。

在上面的例子中(文章中的第一个图像)，当偏移值很高时，有时会出现只有部分图像可见的情况。一方面，这是好的(在头部不可见的图像情况下，网络可以通过爪子和尾巴而不是通过口鼻来学习识别猫)，但如果你过度进行这样的转换，也会使网络混淆。

TensorFlow 中有多种数据扩充方法。我们可以生成图像并保存到磁盘，或者我们可以将生成器直接传送到网络。我选择了第一个选项，这样做更明确。但是这里也有两种方法:生成随机数量的图像或者生成特定图像的几个版本。您可以在data_augmentation.ipynb笔记本中看到这两个选项的实现。我使用了第二个选项，并专门为每张图像生成了五个转换。

实用部分

项目结构

该项目的结构如下:

me_not_me_detector
├───article
├───datasets
│   ├───face_dataset_test_images
│   │   ├───me      # contains TEST images for ME class
│   │   └───not_me  # contains TEST images for NOT_ME class
│   ├───face_dataset_train_aug_images (optional)
│   │   ├───me      # contains aug TRAIN images for ME class
│   │   └───not_me  # contains aug TRAIN images for NOT_ME class
│   └───face_dataset_train_images
│       ├───me      # contains TRAIN images for ME class
│       └───not_me  # contains TRAIN images for NOT_ME class
├───models
│   .gitignore
│   data_augmentation.ipynb
│   me_not_me_classifier.ipynb
│   me_not_me_classifier_model_comparison.ipynb
│   me_not_me_detector.ipynb
│   README.md
└── requirements.txt

先说文件夹。

• article文件夹包含本教程的数据。
• models文件夹包含了用于测试和进一步使用的训练模型。
• datasets文件夹包含三个文件夹——用于训练集、测试集和扩充训练集(可选)。其中每一个都包含两个子文件夹，用于两个类- me 和 not_me 。在一般情况下，它包含 N 类分类问题的 N 个子文件夹。

现在我们来谈谈代码文件——jupyter 笔记本。

• data_augmentation.ipynb文件从初始数据集创建一个扩充数据集，并提供关于数据集的一些信息。
• 文件包含训练和测试五个不同模型的代码。
• me_not_me_classifier.ipynb file 做同样的事情，但是针对一个特定的模型。您可以将它作为构建自己的分类器的示例。
• me_not_me_detector.ipynb文件使用 OpenCV 库，将分类器变成实时检测器。

其他文件用作附加文件:

• .gitignore包含 git 中不会推送的文件，
• requirements.txt包含了运行这些代码需要安装的库列表，等等。

1.数据集集合

首先，我们需要收集一个数据集。我用我的照片和我家人的照片来训练模型，但是你也可以在其他一些人脸数据集上训练模型。我只使用了个人照片来检查这样一个小数据集是否足以让模型显示出可接受的质量。

我从每张照片中裁剪出面部，并将它们的大小调整为 250x250(您不必这样做，因为 TensorFlow 可以为您完成)。以下是初始数据集中的一些照片示例:

初始数据集照片。作者图片

我一共收集了 215 张照片，其中 82 张是我，133 张是非 _ 我。

对于测试集，我立即搁置了 20 张照片。这可以自动完成，但我是手动完成的，因为数据集太小。对于列车组，我应用了来自data_augmentation.ipynb笔记本的数据增强代码。因此，数据集增加了五倍！(每张照片生成五张照片)。以下是生成的照片示例:

增强照片。作者图片

当数据集准备好时，我们可以开始训练模型。

2.寻找迁移学习的基本模式

这里没有什么复杂的——我只是使用了在 ImageNet 数据集上训练的不同模型。如果他们没有很好的准确性，那么我想我会使用类似 VGGFace 模型的东西比如这里的。但是我得到的质量足够好。我们可以用以下代码加载预训练模型:

3.训练模特

现在，我们必须冻结这些权重，在模型上添加一些层，并在我们的小数据集上训练模型。

正如我前面说过的，me_not_me_classifier_model_comparison.ipynb文件包含了不同型号的代码。你可以用它来做你自己的实验。下面的代码示例摘自me_not_me_classifier.ipynb。这里我们将使用 ResNet50 作为初始模型。

在导入库和数据集加载之后，我们完全按照上面的代码加载预训练模型。之后，我们需要恢复模型的顶部——密集的部分。请注意，这部分因型号不同而不同。要知道你需要哪些层，你可以加载带顶层和不带顶层的模型，调用 model.summary() 方法，看看它们有什么不同:

为了添加层，我使用了 TensorFlow 函数 API 。当然，你需要一些关于 TensorFlow 和 CNN 的知识，但你也可以尝试添加不同的层，获得非原创的架构。在我的例子中，我们需要一个全局平均池层和密集层。不要忘记预先冻结其他重量。

之后，我们继续配置模型。我添加了一个 ModelCheckpoint 对象，以便在出错时将模型保存在磁盘上，同时作为一种正则化技术，我还添加了提前停止。作为一种优化方法，我使用了具有标准学习率值的 Adam。我也尝试使用各种调度技术，但是它们没有带来多少结果。

所以现在我们可以开始训练了。结束后，你将有一个现成的模型。您可以通过me_not_me_classifier.ipynb文件中的测试部分代码来检查其功能。

4.将分类器转换为检测器

现在我们必须使用 OpenCV 库进行网络摄像头访问和人脸检测。

坦率地说，由于分类器和检测器的定义，短语“将分类器转换为检测器”是不正确的。分类器(理解为图像分类器)是一种模型，它接收图像作为输入，并在输出端给出一个可能类别的标签(在我们的例子中，是 me 或 not_me )。检测器(理解为面部检测器)是一种模型，其接收图像作为输入，并且如果该图片中存在面部，则输出面部周围的边界框的坐标。

我用这个短语来说明最终的程序(它仍然是一个分类器)现在也给出了人脸在图片中的确切位置。此外，现在它可以在照片中同时有几个人脸的情况下正确工作。

训练一个人脸检测器是一件非常困难的事情(主要是因为数据很难标注)，所以我会使用 OpenCV 提供的人脸检测器。使用起来非常简单。在下面的代码中，faces 变量是图像中所有面孔的数组。对于每个面，边界框有四个值:

• 左上角的 x-x 坐标，
• 左上角的 y-y 坐标，
• w —边界框的宽度，
• h-边界框的高度。

以下代码在网络摄像机图像中实时突出显示您的面部，如下图所示。

用 OpenCV 进行人脸检测。照片由西蒙·罗本从派克斯拍摄

现在剩下的就是加载预先训练好的模型，将人脸所在的图像片段传递给它，并在屏幕上显示文本！事实上，在这个阶段我面临一个小困难——模型只是有时认出我。发生这种情况是因为我训练她在图像上“留有空白”，不仅仅是脸部的位置。

我可以向数据集添加不同比例的图像，但我决定诚实地这样做。为此，我编写了函数 get_extended_image() ，用某个系数 k 来增大裁剪后的图像的大小，k 越大，人脸周围的面积越大。为了解释这个函数的操作(或者更让你迷惑)，我给出下图(为简单起见，这里 k = 0.3。没有观察到刻度。注意，左上坐标是(0，0))。你也可以看到不同 k 参数的我的脸的剪报(根据 OpenCV，它使用 BGR 而不是 RGB，但不是调整颜色，让我们想象我是一个头像)。对于结果模型，我使用 k = 0.5。

get_extended_image()函数说明。作者图片

具有不同 k 参数的 get_extended_image()的图像。作者图片

我想指出的是，我使用了 MobileNet 作为基础模型。最初，我使用的是 ResNet50 ，因为它显示的质量最好，但图像滞后了一点，而更轻的 MobileNet 则没有这些问题。我在一台配有 i7–10750h 和 32G 内存的电脑上测试了所有这些。

就是这样！您可以在me_not_me_detector.ipynb笔记本中找到完成的代码，但是注意，要使用它，您需要在models 文件夹中有一个模型，否则您将在加载模型单元格中得到一个错误。这是结果。

实时人脸检测器的视频演示

我必须说，虽然模型相当简单，但它已经很好地识别了我，例如，如果脸部的一部分被覆盖。另外，我的数据集中没有威利姆·达福的照片，所以模特以前没有见过他。

面具识别中的人脸呢——你可以看到，如果我的鼻子被完全遮住，程序就会停止识别我的脸(或者当它旋转太多的时候)。但是这在检测器侧是一个问题，因为它停止将图像传输到模型。这是因为 OpenCV 人脸检测器通常看不到戴面具的人。但我认为，如果你能收集一个大型数据集，你也可以教你的模型区分戴面具的人。

让我感到惊讶的是——当脸的下半部分被遮住时，模特比上半部分更容易认出我。你可以看到，当我戴上帽子或者用手遮住额头时，模特开始怀疑。我想这是因为在我所有的照片中，我的头都是敞开的，而且我只有一种发型。

好模式！作者图片

结论

下面，我展示了使用或不使用数据扩充(本例中为 x5 数据扩充)的不同模型的训练结果。最佳质量(99%的验证准确性)由 ResNet50 显示。但正如我上面所说，我使用了基于 MobileNet 的模型，因为它在实时操作中表现得很好。

不同车型的训练结果。作者图片

这些结果表明，数据扩充可以显著提高模型的质量。在这种情况下，验证损失下降了 10 倍，但这是关于非常少的数据集。我试图生成更多的图像，并获得更多的准确性。该参数(数据集的系数增加，因此为每幅图像生成的增强图像的数量)可以通过交叉验证来选择。我在 MobileNet 中得到的最好的模型是验证损失= 0.09886，验证准确度= 0.9589，数据集增加系数= 15。

数据集大小对 MobileNet 示例中模型质量的依赖性。作者图片

与此同时，学习过程变得非常缓慢。有道理，数据集规模增加，学习时间也增加。您可以在下面看到训练时间对数据集大小的依赖关系图，它几乎是线性的。

MobileNet 示例中数据集大小对学习时间的依赖性。作者图片

下表是上一个表的扩展版。在这里，您可以看到参数的数量、模型的深度和测试精度。请注意，图层被计为 model.layers 对象的数量，这并不完全正确，但给出了模型深度的概念。测试准确性没有太多的统计能力，因为我只有 20 张测试图像。

扩展结果。作者图片

关于 VGG 的一件事。我用两个 1024 密集层替换了两个 4096 密集层，模型显示了大致相同的结果，尽管参数数量分三次下降(从 1.34 亿下降到 4100 万，可训练值从 1.19 亿下降到 2700 万)。该型号的磁盘大小为 368 MB。

从所做的工作中，我可以得出以下结论。有些比较明显，有些不太明显:

• 你需要收集的数据集应该尽可能的多样化，同时尽可能的接近真实数据。
• 更简单的模型训练速度更快，预测速度更快，占用硬盘空间更少。更简单的模型有更少的参数，但是，同时，可以更深入。
• 迁移学习是一种非常强大的技术，即使只有很小的数据集，它也能让你解决你的任务。
• 数据扩充技术允许你显著地提高模型的质量，但是它也增加了训练时间。您可以通过交叉验证选择数据扩充系数。
• 结果很大程度上取决于随机初始化。因此，即使是相同参数的训练过程也要运行几次。例如，在 22 分钟和 150 个历元中，我在没有数据增强的情况下使用 ResNet50 得到的验证损失结果为 0.1334，比常规 ResNet50 好 39%。

现在我要再说一句让你更加困惑的话。

网络的卷积部分(上至稠密层)将原始图像转化为某个高维空间中的点(这类似于嵌入的概念)，稠密层再在这个空间中构建分离超平面。

因此，最好建立一个模型来更好地定位这些点，然后您可以使用更简单的分类器。当然，构建这些表示的规则非常复杂，这就是为什么我们需要具有大量参数的深度模型。

一个能够很好地创建嵌入的网络能够解决最初没有被训练过的任务。所以，一个好的模型会把我所有的照片彼此靠近(在某个高维空间)定位，把威利姆·达福所有的照片彼此靠近定位。但同时，这两个点云的位置应该相距很远。现在，当你向网络展示另一个人的照片时，它将能够说这是而不是 _me ，但是除此之外，它将能够给出他最像的人或者注意到这个人不在数据集中。这是度量学习的变体，这里使用三重损失。

感谢您的阅读！

• 我希望这些材料对你有用。在媒体上关注我以获得更多类似的文章。
• 如果您有任何问题或意见，我将很高兴得到任何反馈。在评论中问我，或者通过 LinkedIn 或 Twitter 联系我。
• 为了支持我作为一名作家，并获得数以千计的其他媒体文章，使用我的推荐链接获得媒体会员资格(不收取额外费用)。

如何用谷歌图表和熊猫数据框创建简单的可视化

原文：https://towardsdatascience.com/how-to-create-simple-visualizations-with-google-charts-and-pandas-dataframes-fa711299f0c9?source=collection_archive---------11-----------------------

数据可视化

谷歌图表能让你创造出令人愉悦的互动情节，但不能直接阅读熊猫数据。这里我们创建了一个简单的 Python Web 应用程序来结合这两种技术。

作者图片

Google Charts 已经存在很多年了，我都不记得了，所以我想我们可以有把握地认为它是一项成熟稳定的技术。

它还可以用来创建吸引人的图表和图形。

月最高和最低温度-2018 年。图片作者。

在这里，我们可以看到一个简单的交互式折线图，当您将鼠标悬停在图上的某个点上时，它会向您显示该数据点的详细信息。

我们将看看如何使用 HTML 和 Javascript 中的一些基本样板代码、Pandas dataframes 和一个简单的 Flask web 应用程序来创建这样的图表。下面，我们将开发完整的代码。(在本文的最后，我将包含一个应用程序的链接，您可以在这里看到运行中的代码，并下载代码和示例数据。)

以下是以下内容的概要:

• 编写一个基本的 Flask 应用程序(可选)
• 使用样本 HTML 和 Javascript 显示图表
• 创建熊猫数据框架并将其转换成与谷歌图表兼容的形式
• 将烧瓶代码和网页放在一起作为一个应用

创建并运行 Flask 应用程序

这是创建和运行 Flask 应用程序的一个非常简单的介绍。如果您已经知道如何做到这一点，那么您可以安全地跳过这一部分。

Flask 是一个 web 应用程序微框架，这意味着它是一个用于开发 web 应用程序的非常轻量级的库。创建您的第一个 Flask 应用程序很容易，但首先您需要用 pip 或 conda 安装它，例如:

pip3 install flask

接下来，打开一个新目录，用下面的代码创建一个文件 app.py :

from flask import Flask
app = Flask(__name__)
@app.route('/')
def root():
   return 'Hello'

代码非常简单。第一行导入烧瓶库；第二个创建一个 Flask 对象(将被运行)；剩下的部分定义了一条路线。一个路由是一个网页，或者端点，而 @app.route 装饰器定义了 url，在这种情况下它是根 url(即/)。下面是一个函数定义，它告诉 Flask 服务器当这个特定的端点被请求时该做什么——在这个例子中，只需返回字符串“Hello”。

现在打开终端窗口，导航到正确的目录，并键入:

python3 -m flask run

(注意:我在一个标准的 Linux 环境中使用 Python3，这里，如果你使用一个不同的环境，Python3 是默认的——例如，portable Python 或 Conda——那么你的命令可能是 python 而不是 python3。)

这将启动 Flask 服务器，结果应该是这样的:

运行 Flask 应用程序-作者图片

Flask 现在正在运行您的应用程序，它可以从 url 获得， http://127.0.0.1:5000 ，所以在浏览器的地址栏中键入它，您应该会看到类似这样的内容:

跑步烧瓶应用程序——作者图片

我们稍后将使用模板将 Flask 应用程序连接到网页，但现在，这就是我们需要了解的关于 Flask 的全部内容。

一个简单的谷歌图表

现在我们来看一个可以在许多不同的应用程序中重用的模板 HTML 页面。基本文件布局如下所示:

<!DOCTYPE html>
<html>
  <head>
    <script>
      // Script 1 — where the data gets loaded
    </script> <! — Script 2 — Load the AJAX API →
    <script src=”https://www.gstatic.com/charts/loader.js">   
    </script> <script>
      // Script 3 — Where we create and display a chart
    </script>
  </head>
  <body> <! — the div where a chart will be displayed →
    <div style=”width:600px; height:300px” id=”chart1"></div> </body>
</html>

这是一个简单的 HTML 文件，文件体只有一个

，文件头有 3 个脚本。是显示图表的地方，并被赋予了一个 id——我还赋予了它一个高度和宽度。id 是强制性的，尺寸不是——您可以随意改变高度和宽度，或者完全不考虑它们。

主要逻辑来自三个脚本。第一个脚本 1 是我们加载数据的地方。对于第一个示例，我将在本地创建数据，但稍后我们将从 Pandas 数据框架中加载它。第二个脚本，脚本 2，加载一个 Google Charts API，脚本 3 将使用它。和脚本 3。它本身负责创建和显示图表的主要工作。

我们马上会看到这些是如何工作的，但值得指出的是，如果你想创建自己的应用程序，你只需要修改脚本 1 和 HTML。所以只需要很少的 Javascript 编程。

脚本 2 已经定义，我们不需要修改它。

脚本 3 相当长，但是，同样，一旦我们定义了它，我们不需要改变它。这是:

<script>
  // Load the Visualization API and the corechart package
  google.charts.load(‘current’, {‘packages’:[‘corechart’]}); // Set a callback for when the API is loaded
  google.charts.setOnLoadCallback(drawChart);

  // This is the callback function which actually draws the chart
  function drawChart(){
    google.visualization.drawChart({
      "containerId": **containerId**,
      "dataTable": **data**,
      "chartType": **chartType**,
      "options": **options** });
  }
</script>

这里发生的事情是，我们从 Google 加载可视化 API，然后设置一个回调函数，该函数将在 API 完成加载时运行。回调函数是 drawChart 并完全按照它所说的去做。

drawChart 简单地从 Google API 调用另一个同名函数，并传递一些参数，我们将在稍后的脚本 1 中定义这些参数。让我们检查一下这些参数。

containerId 是将显示图表的< div >的 Id。

数据是要绘制的实际数据。

chartType 是我们想要的绘图类型，例如，折线图、饼图、柱形图。

选项可以包括图表的多个不同选项，例如标题。

我们将在脚本 1 中定义这些选项。

定义数据

为了获得一个有效的 web 页面，首先我们将在本地定义数据——稍后我们将从 python 应用程序导入数据。

您可以用几种不同的方式定义 Google Charts 的数据，但是对于我们的目的来说，最简单的方式是一个简单的表格。这是停在我家街道上的汽车数量和品牌表:

但是我们需要将其格式化为 Javascript 二维数组中的行列表。这与 Python 中的列表列表非常相似。看起来像是:

[
  ["Car","Number"],
  ["Audi", 3],
  ["BMW", 2],
  ["Mercedes", 1],
  ["Opel", 3],
  ["Volkswagen", 4]
]

列表中的第一项是列名列表，其余的是数据行。

这是脚本 1，它包含了我们之前看到的数据和选项..

<script>
  data = [
    ["Car","Number"],
    ["Audi", 3],
    ["BMW", 2],
    ["Mercedes", 1],
    ["Opel", 3],
    ["Volkswagen", 4]
  ]; chartType = "ColumnChart";
  containerId = "chart1";
  options = {"title":"Cars parked in my road"};
</script>

我们首先看到的是包含 car 表的变量数据。接下来是我们将要绘制的图表的类型，然后是图表将要绘制到的< div >的 id。最后，我们为图表设置选项——这里只是标题，但是根据我们想要绘制的图表类型，可能还有其他选项。稍后您将看到如何使用这些选项。

如果你把这些脚本和上面的 HTML 模板放在一起，你就有了一个工作网页。您可以在浏览器中打开它并查看结果图。

停在我的道路上的汽车柱形图-图片由作者提供

这里有一个巧妙的技巧:改变线路

chartType = “ColumnChart”;

到

chartType = “PieChart”;

保存并重新加载网页，然后…

那很容易！

好的，但这只是一个简单的独立演示，实际上我们想从其他地方获取数据。这就是我们接下来要去的地方。

熊猫数据框到谷歌数据表

我们可以看到示例中提供的数据格式是一个列表列表。列表的第一个元素是包含列标题的列表，其余元素包含构成表格行的数据。

虽然这在概念上与熊猫数据帧没有太大的不同，但我们确实需要做一些工作来将两者转换。

让我们首先编写一些 Python 代码来加载我们的数据，并创建一个 dataframe 来表示我们想要绘制的数据。

如果你下载程序文件，你会在根目录中找到一个名为 london2018.csv 的文件，我们将把它加载到一个熊猫数据帧中，如下所示:

url = ‘london2018.csv’
weather = pd.read_csv(url)

数据帧看起来像这样:

weather.csv —图片由作者提供

这是 2018 年伦敦天气统计的记录(来自英国气象局数据)。 Tmax 和 Tmin 是 2018 年各月的最高和最低气温， Rain 是以毫米为单位的总降雨量， Sun 是总日照时数。

我们将生成一个温度图表，我们只需要 Tmax 和 Tmin 以及 Month 列，因此我们创建了一个我们需要的数据的新数据框架，如下所示:

title = “Monthly Max and Min Temperature”temps = weather[[‘Month’,’Tmax’,’Tmin’]]temps[‘Month’] = temps[‘Month’].astype(str)

请注意，我还将月列转换为字符串，因为将其视为数字没有多大意义，并且我还为图表创建了一个标题。

所以现在我们有了想要的数据；我们只需要将它转换成谷歌图表将处理的形状。我们通过从图表中提取值并将它们转换成列表来实现这一点。这将为我们提供列表中的值，这正是我们在图表中需要的。一个问题是:没有包含列名。这很容易解决，我们提取列名，然后将结果列表附加到值列表的顶部。

d = temps.values.tolist()c = temps.columns.tolist()d.insert(0,c)

现在，我们将数据和标题捆绑到一个 JSON 字符串中，可以传递给 web 页面。

tempdata = json.dumps({'title':title,'data':d})

我们使用内置于 Flask 中的模板机制将数据传递给网页。像这样:

return render_template('weather.html', tempdata=tempdata)

函数 render_template 找到模板【weather.html并通过将传递给它的数据插入模板来创建一个网页。

整合应用程序

所以现在我们需要修改我们的 html 文件，使之成为一个模板。这意味着将 Script 1 改为将 JSON 数据加载到 Javascript 变量中的脚本，方法是在要传递的数据所在的位置放置命名的占位符。(一个宫托是一对双花括号，里面有名字。)

在我们的例子中，只有一个数据项叫做 tempdata 。因此，我们将脚本 1 中的代码替换为:

<script> tdata = JSON.parse({{tempdata|tojson|safe}});
  tempdata = tdata.data;
  temptitle = tdata.title;
  chartType = "LineChart";
  containerId = "chart1";
  options = {"title":temptitle};</script>

名称用双花括号{{name}}括起来，这里我们也是说数据要转换成 json，并且包含‘安全’的 HTML，也就是说，我们不希望任何特殊字符转换成转义序列。

将数据放入模板后，我们将它分配给变量 tdata 并从中为数据和标题设置变量。

所以我们最终得到了两个文件，如清单 1 和清单 2 所示。

清单 1。烧瓶计划——作者图片

清单 2。网页——作者图片

现在这一点是重要的:首先，我们将 Flask app app.py ，其次，Flask app 希望 HTML 文件被称为weather.html(正如我们在清单中看到的那样)，所以确保您给它起了那个名字。最后，Flask 希望它的模板是一个名为 templates 的目录，该目录与 Flask 应用程序在同一个目录中。

当你运行 flask 应用程序时，你会看到下面的页面。

除此之外，Google Charts 还有很多其他功能，但我希望这是一个有用的介绍，可以让你用 Python 应用程序生成这些功能。感谢阅读。

源代码

当你下载完文件后，将它们解压到一个空文件夹中，用 python -m flask run 运行 Flask app(如上)。

时事通讯

我可能会进一步研究这些代码和/或就这个主题写更多的文章。如果你想了解最新的文章，请考虑在这里订阅我偶尔发布的免费时事通讯。

如何为您的数据科学项目创建出色的 Web 应用程序

原文：https://towardsdatascience.com/how-to-create-stunning-web-apps-for-your-data-science-projects-c7791102134e?source=collection_archive---------7-----------------------

数据科学家不必学习 HTML、CSS 和 JavaScript 来构建网页。

在 Unsplash 上由Meagan carscience拍摄的照片

Web 开发不是数据科学家的核心能力。大多数数据科学家都懒得学习不同的技术来做这件事。这不是他们喜欢的咖啡。

然而，大多数数据科学项目也有软件开发部分。开发人员有时对问题有不同的理解，他们使用离散的技术。它经常会导致问题，并且毫无成效地消耗两个团队的宝贵时间。

此外，Tableau 和 Power BI 等可视化工具更侧重于数据探索。然而，这只是一个完整的数据科学项目的一部分。如果你需要集成一个机器学习模型，它们还远远不够完美。

Streamlit 允许你为你的数据科学项目开发网络应用。这个开源库的 API 完全是 python 的。因此，你不必学习任何其他网络技术来使用它。此外，它简单易学，修改灵活。

本文是对 Streamlit 的介绍。我们将构建一个交互式 web 应用程序，它接受用户输入，运行 K-means 算法，并在 web 界面中即时绘制结果。

到这篇短文的结尾，我们已经涵盖了

• 安装 Streamlit 并试水；
• 构建交互式网络应用程序；
• 使用用户输入运行 K-means 算法；
• 使用缓存提高性能，以及；
• 在云上部署它；

这里是链接到部署版本。如果你想先睹为快，就去看看吧。

为开发建立 Streamlit。

这个非凡的工具有一个令人尴尬的简单设置，几乎所有 Python 用户都熟悉它。使用 PyPI。

pip install streamlit

也可以使用 conda 等流行的 python 包管理器。

完成后，您可以使用安装时附带的 hello world 应用程序对其进行测试。在终端窗口中执行下面的命令来启动开发服务器。

streamlit hello

hello world 应用程序是一套出色的可视化工具，您可以使用 Streamlit 来完成。上述命令将启动一个本地开发服务器，并在默认浏览器中打开链接。您还可以在同一页面上找到源代码。此外，这个示例应用程序还提供了许多高级教程的链接，可以帮助您自学。

现在设置已经完成，让我们创建一个应用程序来与我们的机器学习模型进行交互。

通过 Streamlit web 应用程序使用机器学习模型。

下面的应用程序使用 Pandas、Scikit-Learn、Matplotlib、Seaborn 和 Streamlit。开始之前，请确保您已经安装了所有必需的软件包。如果没有，下面的命令将为您完成。

pip install pandas scikit-learn matplotlib seaborn streamlit

创建您的第一个 web 应用程序

使用以下内容创建一个名为“quickstart.py”的文件。

来自作者的代码片段。

上面的文件很简单。为了便于说明，我在文件中添加了一些部分。

在主应用程序部分，我们有三行代码。我们向页面添加了标题和描述。然后我们在页面上显示数据框。“st.write”功能是一个一体化的解决方案。您几乎可以将任何内容传递给这个函数，Streamlit 足够智能，可以在 UI 中显示正确的小部件。为了了解不同的 Streamlit 函数，这里有一个备忘单。

让我们用下面的命令运行我们的初始应用程序。

streamlilt run quickstart.py

像 hello 应用程序一样，这个命令将启动一个新的开发服务器。在您的浏览器上，您会看到以下内容。

截图来自作者。

恭喜你，你刚刚创建了你的第一个 web 应用程序；没有 HTML，CSS，绝对没有 JavaScript。

但这只是初步的。一个网络应用可以做很多很酷的事情。它可以与用户实时互动，并更新其内容。让我们看看我们如何能做它。

添加交互

在 Streamlit web 应用程序中实现互动毫不费力。Streamlit API 包含几个小部件。您可以使用它们来获取用户输入并将它的值存储在一个变量中。其余的就像任何其他 python 程序一样。

让我们添加一个复选框来切换数据集显示。毕竟，没有人开发一个 web 应用程序来查看原始数据。用以下内容替换数据框显示(第 30 行)。

来自作者的代码片段。

如果刷新浏览器，现在可以看到一个复选框来切换数据框显示。

截图来自作者。

但是应用程序中间的切换按钮并不令人满意。让我们把它移到边栏。

向应用程序添加边栏

又是一个轻松的动作。Streamlit API 具有侧栏属性。您在主应用程序中创建的所有小部件也可以在这个侧栏属性中使用。

使用“st.sidebar”属性创建侧栏变量。然后将我们在主应用程序部分添加的复选框分配移动到侧边栏部分。请注意，我们现在使用“st.sidebar.checkbox”而不是“st.checkbox”

来自作者的代码片段。

在上面的代码中，我们还向侧边栏添加了一个滑块。这个小部件将捕获用户选择的集群数量。下面是输出的样子。

截图来自作者。

下一步，我们将使用用户选择的聚类数运行 K 均值算法。

使用实时输入运行 K-Means。

用下面的代码扩展导入、助手函数和主应用程序部分。

代码片段来自作者。

在上面的代码中，我们创建了一个函数来运行 K-Means 算法。它将数据框和聚类数作为参数，并返回一个 Matplotlib 图。

K-Means 聚类的示例超出了本项目的范围。这是一个机器学习算法，这才是我们关心的。不过你可以参考我之前的帖子描述一下。

我们使用 n_clusters 变量作为 run_forecast 函数的第二个参数，该变量捕获上一节中的滑块值。

如果你刷新页面，你会看到一个仪表板，接受用户输入，运行机器学习算法，并即时更新用户界面。

截图来自作者。

即使你是一个经验丰富的开发人员，这种级别的交互和与后端 ML 的集成也是一项艰巨的任务。尤其是如果你是一个不知道如何开发 web 应用的数据科学家，这可能会花费你数周的时间。

通过缓存提高性能。

数据科学管道中的一些任务非常耗时。然而，这种任务很少对相同的输入产生不同的结果。您可以使用 Streamlit 内置的缓存功能来存储它们的值以供将来使用。

虽然这听起来可能很复杂，但用 streamlit 做起来很简单。你的耗时任务应该是一个函数，你用 @ts 包装它。缓存装饰器。只要输入参数是相同的，并且函数体没有被改动，Streamline 就会从缓存中获取它。

在我们构建的应用程序中，我们调用外部 URL 来下载数据。如果它是一个活动的 API，您可能不想缓存它。但在我们的情况下，它不是。因此，让我们通过用下面的代码替换该行来缓存它。

来自作者的代码片段。

第一次重新加载时，您可能会在浏览器上看到消息“正在处理加载数据”。但随后的再装不会有那个音符。这是因为请求是从缓存中提取的，而不是从外部 URL 下载的。

在互联网上部署

如果您注意到了 Streamlit 控制台，您还会看到一个网络 URL。这意味着，如果您的防火墙允许，您的应用程序可以通过内部网访问。

但是如果你想在你的网络之外分享，我们有很多选择。正如文档所说，Streamlit 应用程序可以在 Python 应用程序工作的任何地方工作。

1. Streamlit 推荐“Streamlit 共享”选项。你可以将你的代码放在 GitHub 存储库中，并配置 Streamlit 共享来为你的应用服务。
   Streamlit 共享是免费的，但目前只接受邀请。您可以为自己申请邀请。
2. 你可以把它部署在云平台上。这里有一篇文章展示了如何用 AWS EC2 free 实例做到这一点。
3. 您可以配置一个反向代理。Nginx 和 Apache 之类的代理服务器可以配置为服务于应用程序，并限制特定用户的访问。

请务必阅读关于部署的 Streamlit 社区指南,探索您可用的众多选项。

以下是我如何在 Streamlit Share 上部署这个教程应用程序的。再一次，Streamlit 的便利让我大吃一惊。

第一步:将你的代码放入 GitHub 公共库。 我已经将我的代码添加到这个 GitHub repo 中。我们需要确保它包含一个 requirement.txt 文件以及所有的依赖项。

第二步:使用你的 GitHub 账号登录Streamlit。

第三步:在 Streamlit 控制台上创建一个新应用。 从下拉列表中选择您的 git hub repo，或者在 URL 中选择 past。选择要用于部署的分支。最后，选择主文件名并单击 deploy。

作者截图。

大约一分钟后，我的应用程序将在 Streamlit Share 上直播。但是部署时间可能因项目需求而异。

请注意，streamlit 共享目前只接受邀请。但我没等太久就拿到了。Streamlit 的部署文档包含了更多关于这方面的有用信息。

结论

不用说，Streamlit 解决了数据科学项目中的一个关键问题。它让数据科学家能够构建 web 应用程序，与他们的机器学习模型进行交互。

在这篇介绍性文章中，我们探讨了如何将 Streamlit 与 K-Means 聚类结合使用。虽然这是一个微不足道的应用程序，但它阐明了这项技术的核心概念。除了开发之外，我们还看到了如何在 Streamlit 中轻松管理缓存以提高性能。最后，我们讨论了部署选项。

细流远不止这些。请查看他们的官方文档，里面充满了优秀的教程。还有，他们的 API 备忘单有助于快速开发。

网络应用是一个很好的解决方案。但是在某些情况下，您可能不得不考虑与您的 ML 模型交互的其他方式。或许，为您的模型构建一个命令行界面会有所帮助。

谢谢你的阅读，朋友。看来你和我有许多共同的兴趣。一定要看看我的个人博客。

在 LinkedIn 、 Twitter 、 Medium 上跟我打招呼。我会为你打破僵局。

还不是中等会员？请使用此链接 成为 的会员。你可以享受成千上万的有见地的文章，并支持我，因为我赚了一点佣金介绍你。

如何创建 Tableau(业务)仪表板并利用容器

原文：https://towardsdatascience.com/how-to-create-tableau-business-dashboards-and-utilize-containers-90c0ec2b7e75?source=collection_archive---------9-----------------------

在本文中，我将给出如何创建业务仪表板的技巧，特别是如何利用容器。

Guillaume Bolduc 在 Unsplash 上拍摄的照片

(你也可以在 我的网站 上找到这篇文章以及其他文章和更多有趣的东西)

本文将部分基于我这个周末从超级商店数据集创建的工作簿，它是专门为本文制作的。

仪表板也可以在 Tableau 公共配置文件中找到， 此处，如果您想下载它并查看容器在仪表板中的使用情况。

仪表板的最终外观如下，稍后我将剖析仪表板的每个部分。

如何利用 Tableau 中的容器创建业务仪表板的 10 个技巧

这篇文章将基于我在创建业务仪表板时经常使用的 10 个技巧。其中许多将针对如何使用容器。

这些不是“神圣的真理”，但它们是我在尝试了许多不同的东西后，发现对我最有效的东西，我觉得分享这些东西很好。

提示如下:

1. 画一个你想要的仪表盘的草图
2. 从一个固定尺寸的较小仪表板开始
3. 从一个垂直/水平浮动容器开始
4. 给容器着色，从“后端”容器开始，以便更容易地构建仪表板
5. 使用转换键移动集装箱
6. 合并容器时，将容器放在的“正确位置”
7. 利用并学习如何阅读项目层级****
8. 使用“均匀分布内容”和“固定宽度”****
9. 使用“空白对象”作为各部分之间的分隔物
10. 从固定尺寸更改为“范围-最小尺寸”****

1.如果仪表板应该是水平/垂直的，请快速勾画出您希望仪表板的外观和设计

上面仪表板的快速草图

如果你在开始操作仪表板之前已经决定了你想要什么和你想要它在哪里，这将是一个比以后改变它更容易的过程。

尝试决定你想在哪里有仪表板的主要领域，你想有过滤器，你想有多少可视化和类似的方面。

这里你还应该看看你的设计是更“垂直”还是“水平”。我将构建的这个仪表板有非常具体的“行”,最好构建在垂直主题上。

2.从固定尺寸的较小仪表板开始

固定尺寸较小的仪表板(1000 x 800)

使用较小的固定尺寸仪表板比使用较大范围或自动仪表板更容易设置设计。

我通常会启动一个尺寸为 1000 px * 800 px 的新仪表板，并在我的笔记本电脑上进行最初的设计。

后来，当我以一种好的方式得到容器设计时，我换了一个更大的、范围大小的仪表板，准备用于生产环境。

3.从一个垂直/水平浮动容器开始，稍后您将“修复”它

****

启动浮动容器

我总是发现使用后端浮动容器更容易，当你完成设计后，你可以在后台“修复”它。

当您在第一层使用浮动容器而不是固定容器时，在内部插入新容器并让它们在正确的位置对齐似乎更容易。

(提示:按下容器时按住 shift ，如上图，不需要在下面的菜单中切换到浮动)

4.对容器进行着色/重命名，并从“后端容器”开始，以便更容易地构建仪表板

着色/重命名的容器具有更好的结构

下面是一个例子，我已经开始建立上面的仪表板。顶部容器被重命名为“过滤器容器”,颜色为灰色。

画布的主垂直容器名为“画布容器”，三个画布容器以不同的方式命名和着色。

通过使用这种结构,很容易找到您想要使用的容器**,并在正确的容器中插入新的容器和新的纸张。**

5.使用 shift 键在容器和移除的平铺容器之间移动

******

移除平铺的容器，如果你设法“把它贴在背景中”**

大多数人可能都知道，可以按住 shift 键来移动容器，并将它们合并到其他容器中。

但是如果你也想把一个容器从后面移出(不把它转换成 UI 中的浮动容器),你可以这样做，如果你在项目层次结构中移除平铺的容器。

6.合并容器时，将容器放在“正确的位置”

放下集装箱的正确方法，以便与之前的集装箱对齐

如果你有一个包含多个容器的层次结构，有时很难将新的容器放到正确的位置。有一些有用的技巧可以正确做到这一点。

a)如果您看到顶部图片中的虚线**，这意味着新容器被放入仪表板中最外面的容器中**

b)如果您事先在容器中有两个项目，您可以将新项目放在中间**，它将始终放在仪表板上最外面的容器中**

**c)如果你有一个垂直的容器，**容器的底部是最困难的部分，把它放在别的地方，然后在物品周围移动。

**d)如果你有一个卧式容器，**容器最右边的部分是最难的部分，把它放在别的地方，然后在物品周围移动。

7。利用并学习如何阅读项目层次结构(目录)

项目层次结构

项目层次结构类似于一篇较长文章中的目录，它更容易看到不同部分之间的相互关系，并获得整个仪表板设计的概述。****

您可以重命名项目层次中的所有部分，也可以直接移除项目，使其成为浮动/固定或平均分配项目。****

从本文中仪表板的特定层次结构中，我们可以看到:

**仅第 1 级

• 后端容器**

第二级
→-标题+过滤器容器-
→-顶部画布过滤器容器下面再往下****

**第三级

• 滤镜容器在“标题+滤镜”容器

• 三个不同的容器在“滤镜下的画布”容器内**

我认为项目层次结构是以正确的方式构建仪表板的最佳帮助之一。

8.使用“均匀分布内容”和“固定宽度”****

如果你想控制项目在不同显示之间切换时如何自动调整大小，那么如果你学会恰当地使用“平均分配内容”、“固定宽度”和“固定高度”，会有很大帮助。

我的一些规则是，我总是将过滤器和文本框放在它们自己的容器中，其中固定高度**(如果在顶部)固定宽度(如果在右侧/左侧)。**

这些不是在移动到更大显示时必须调整大小的仪表板项目，而是仪表板中的重要图表在不同大小之间移动时会适当调整大小。

如果您正确使用“平均分配内容”,当您在不同大小的显示屏之间移动时，您将不会在仪表板中有任何不必要的空白区域。

9.使用“空白对象”作为各部分之间的分隔物

****

如果你想要在不同的部分之间有一些特定的线条，你可以包括“空白对象”。

**设置分隔线的背景，然后编辑分隔线的高度，我通常设置 2 为分隔线的高度。**

10。包括填充，使仪表板更加直观

结论

有许多方法可以增强一个 Tableau 仪表板，容器在其中的许多方面发挥了很大的作用。

在本文中，我讨论了创建更好的 Tableau(业务)仪表板的 10 种不同方法。

其中最重要的是利用项目层次**，知道如何使用浮动与固定容器，并知道如何**“平均分配内容”与“固定宽度/固定高度”容器/仪表板项目。

我希望这些提示能在你阅读这篇文章的过程中对你使用 Tableau 仪表盘有所帮助。

感谢您的阅读

非常感谢你阅读我的博客！

请在下面留下您对内容的看法，或者希望就您如何利用容器或构建仪表板进行讨论。

我很想听听其他人是如何看待这些事情的。

**如果你喜欢阅读我的故事，并愿意支持我成为一名作家，可以考虑使用[这个链接](http://That’s it from my end for this blog. Thank you for reading! Let me know in the comments if you too learned something the hard way and wish your degree taught you. I would love to know more about your journey and thoughts. If you enjoy reading stories like these and want to support me as a writer, consider signing up to become a Medium member using this link (and I can earn a small commission with no extra cost to you!)) **，注册成为一名媒介会员，我和你可以赚取一小笔佣金，不需要额外的费用。

问题或询问

如果您有任何问题或建议，请联系我

祝大家这周过得愉快

如何为数据科学模型创建时间要素

原文：https://towardsdatascience.com/how-to-create-time-features-for-data-science-models-22b902df5115?source=collection_archive---------36-----------------------

为您的机器学习算法创建分类时间箱的独特方法

由卢卡斯·布拉塞克在 Unsplash 拍摄的照片【1】。

目录

1. 介绍
2. 创建时间要素
3. 摘要
4. 参考

介绍

数据科学建模最困难的部分之一是利用时间。时间可以有多种用途。有特定于时间序列的建模，但是您也可以用不同的方式来看待时间。我们将研究这种方法，即将时间转换成一个分类变量( s )。虽然转换后顺序将被剥离，但时间的周期性仍将能够被您使用的机器学习算法识别。对于本例，我们将使用新兴算法 CatBoost 来正确使用这些时间特性。例如，正常情况下，订购的时间是一天中从 0 到 24 的小时数。但是，算法仍然足够智能，可以将要素视为 bin 或类别(也可以是对象或分类数据类型)，而不是数字数据类型。话虽如此，如果您想了解如何将时间戳转换为分类特征以用于数据科学建模的独特方法，请继续阅读下面的内容。

创建时间要素

使用的代码示例(相同时间特征值)。作者截图[2]。

下面，我们将描述用例或一般问题，以便您可以看到创建时间功能有用的示例。我们将展示这段对话的 Python 代码。最后，我们将在一些简单的代码后看看我们的特性是什么样的。对于未来的工作，您还可以通过将时间要素用作分类/对象或数值数据类型来比较模型，比较它们在精度或误差方面的变化。

用例

用例是预测进入餐馆的人数。尽管我们可以使用一天中的几个小时或一天中的半个小时作为数字特征，但就本文而言，我们可以使用这两个特征作为分类特征，最终将由 CatBoost 机器学习算法进行目标编码。

密码

from datetime import datetime, timedelta
import pandas as pd
import numpy as npdate_today = datetime.now()
date_range = pd.date_range(date_today — timedelta(7), date_today, freq='D')df = pd.DataFrame({'date_time_stamp': date_range})
df.head(5)

在上面的代码片段中，我们首先导入必要的库。接下来，我们创建从现在的到过去七天的随机时间戳数据。然后，我们可以查看带有df.head()的时间戳，它们都是一个主数据帧的一部分。

df['hour'] = ['{}:{:02d}'.format(r.hour, (r.minute // 60) * 60) for r in df['date_time_stamp']]
df['30_min'] = ['{}:{:02d}'.format(r.hour, (r.minute // 30) * 30) for r in df['date_time_stamp']]df[['date_time_stamp', 'hour', '30_min']].head(5)

在这个代码块中，我们看到我们正在创建两个时间特征。第一个是小时特性，它本质上是说— *这个非常具体的时间戳在哪个小时？*下一部分与此类似，但更细化，它说的是— 这一分钟的半小时是多少？

例如，如果时间戳的分钟是 12:46 pm，那么30_min将是 12:30 ( 本质上是从 12:30 到 1:00 pm 的一组值)

df.dtypes

在最后这段代码中，我们看到可以查看列的数据类型。第一个将返回datetime64[ns]，两个新计算的要素将在分类要素列表中使用，作为object或categorical数据类型。

这些特性在算法中是如何工作的

• 这两个要素以及您可以进一步创建的其他要素可用于 CatBoost 模型的分类要素列表中，CatBoost 模型的一部分将使用目标编码，简单来说，就是特定时间要素条柱的平均目标。

半小时/ 30 分钟示例(不同的时间特征值)。作者截图[3]。

您可以在上面的第一个屏幕截图中看到，两个时间特性的输出具有相同的值，这是因为半小时周期仍在 30 的另一侧。如果您在 30+的日期时间尝试这样做，您将看到该值发生变化。那就是第二张截图不一样的地方，紧接着上图。出于用例的考虑，您最有可能期望餐厅的人数在大约12:00和12:30以及6:00和6:30(分别为午餐和晚餐时间)时具有最高的平均目标值，而当餐厅关门前有一股人流时，可能会有一些新的发现，也许是9:30。

摘要

时间很重要，在开发数据科学模型时不应忽视。然而，它可能是棘手的，可以以多种方式消耗。我们创建时间特征的方式是独特的，因为我们将一个示例时间戳转换为两个分类特征。我们看到，当时间为 13:14 时，半小时功能或30_min与小时功能相同，但当时间为 13:32 时，则不同。当然，在数据科学模型中，时间还有更多使用方式。

总而言之，我们执行了以下操作:

* created a mock dataset* isolated a timestamp* created two features from that one timestamp* realized those two features could be used as categorical features

我希望你觉得我的文章既有趣又有用。如果您同意《时代》杂志的这一专题创作，请随时在下面发表评论——为什么或为什么不同意？在你的机器学习算法中，还有哪些利用时间的方式？你使用的主要技术和 Python 库是什么？

参考

[1]照片由卢卡斯·布拉塞克在Unsplash(2017)上拍摄

[2] M.Przybyla，所用代码示例截图(相同时间特征值)，(2021)

[3] M.Przybyla，半小时/ 30 分钟截图示例(不同时间特征值)，(2021)

如何创建 Xarray 数据集

原文：https://towardsdatascience.com/how-to-create-xarray-datasets-cf1859c95921?source=collection_archive---------9-----------------------

从头开始定义数据集

阿瑟·富兰克林在 Unsplash 上的照片

[Xarray](https://xarray.pydata.org/en/stable/)是一个开源的 Python 包，用于处理带标签的多维数据集。在处理地球科学界常见的 NetCDF 格式的数据时，它是必不可少的。

用xarray打开 NetCDF 文件很简单。

ds = xr.open_dataset("/path/to/file.nc")

然而，创建一个可以保存到 NetCDF 文件的xarray对象需要更多的工作。在这篇文章中，我将回顾如何做到这一点。我将首先介绍如何将[pandas](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) 数据帧转换为[xarray](https://xarray.pydata.org/en/stable/generated/xarray.Dataset.html) 数据集，然后介绍如何从头开始创建数据集。

目录

1。pandas data frame to xarray dataset
∘1.1 如何添加元数据和更改变量名？
∘ 1.2 创建多维数据集
∘ 1.3 如何保存我的数据？
2。从头开始创建 Xarray 数据集
∘ 2.1 具有一个坐标的数据集
∘ 2.2 具有多个坐标的数据集
∘ 2.3 具有坐标矩阵的数据集
∘ 2.4 具有坐标向量和矩阵的数据集
3 .最终想法

1.熊猫数据帧到阵列数据集

从数据帧开始，您可以直接将其转换为数据集。

ds = df.to_xarray()

这可能是一个很好的起点，因为它为您创建了一个xarray对象。在下面的例子中，我用一个变量y和一个索引x创建了一个 dataFrame。然后我用to_xarray()把它变成一个xarray对象。

该数据集的格式还不是很好。以下是ds.info()输出:

作者图片

理想情况下，info()应该告诉你一些关于变量和整个数据集的元数据。例如，变量属性可以包括units，这对于温度之类的东西很重要，而全局属性可以包括原始数据源或数据集的创建者。目标是为用户提供一些数据的上下文。

在下一小节中，我们将向该数据集添加一些元数据。

对于气候和预报(cf)，元数据有一个标准的约定。关于这一点的讨论超出了本文的范围，但这里有两个资源可供感兴趣的人参考:

• cfconventions.org
• cf 惯例概述

请注意，这篇文章是为了说明一个概念，因此我可能会偏离常规标准。

1.1 如何添加元数据和更改变量名？

随着对象的创建，我们可以开始添加元数据和改变变量/坐标名称。

字典key:value对用于重命名变量/坐标和添加属性。下面是基本语法:

• 重命名变量 : ds.rename({“old_name” : “new_name”})
• var 属性: ds[“var”].attrs = {“attribute_name”:”attribute_value”}
• 全局属性:

下面的代码片段首先重命名坐标和变量，然后创建变量和全局属性。

(注:xarray 没有熊猫那样的 **inplace=True** 选项。)

下面是添加一些元数据后的ds.info()输出

作者图片

这是一个格式良好的数据集。用户可以很快理解这个数据集代表什么以及谁创建了它。在第 2 节中，我们将从头开始创建相同的数据集。

1.2 创建多维数据集

对于多个维度，只需在set_index()中包含一个维度列表。然后，您可以像以前一样添加元数据和更改变量

1.3 如何保存我的数据？

对更改感到满意后，可以将它们保存到 NetCDF 文件中:

ds.to_netcdf('/save/to/this/path/file.nc')

在下一节中，我将从头开始创建数据集。如果您想要将一个大的NumPy数组或列表保存为 NetCDF，这将非常有用。

2.从头开始创建 Xarray 数据集

以下语法用于创建带有xarray的数据集:

ds = xr.Dataset(data_vars, coords, attrs)

一个完整的数据集由三个字典组成:

• data_vars:关键是变量名，值是由
  (dimensions, data, variable_attributes)
  • dimensions →名称列表
  • data →数据可以是任意格式(Pandas、Numpy、list 等)。)
  • variable_attributes → 可选属性字典
• coords:定义坐标及其属性
• attrs : 可选全局属性字典

属性是可选的，但是强烈建议使用。

2.1 具有一个坐标的数据集

下面使用xr.Dataset()创建与上一个例子相同的数据集。

data_vars :用一维time定义变量velocity，包含units和long_name两个属性。

坐标:定义time坐标，其维度也称为时间。

属性:定义全局属性creation_data、author和email

2.2 具有多个坐标的数据集

如果数据是多维的，通常会有多个坐标。

在这里，我创建了一个数据集，其中变量有两个维度，x和y，以及两个坐标，lat和lon。

在前面的示例中，坐标和尺寸同名。这个例子说明它们不需要相同。

2.3 带坐标矩阵的数据集

在前面的例子中，每个坐标由一个矢量表示。但是，在某些情况下，将坐标表示为矩阵是有意义的。这在不规则网格上的地球系统模型中很常见。

让我们以前面的例子为例，使用np.meshgrid()将每个坐标转换成一个矩阵

np.meshgrid从坐标向量创建坐标矩阵。行网格在cols的长度上重复rows，列网格在rows的长度上重复cols。这是每个网格。

作者图片

现在让我们使用矩阵表示的坐标创建一个数据集。

这表示与以前相同的数据，唯一的区别是每个坐标表示为矩阵而不是向量。这是为了说明一个概念。在大多数情况下，将坐标表示为向量更有意义。

2.4 带有坐标向量和矩阵的数据集

坐标可以是矩阵和向量的混合。你只需要确保变量中的所有维度都在你的坐标中。

让我们创建一个具有三个维度的数据集， time、lat和lon。空间维度(lat、lon)将分别由矩阵表示，而time将是向量。

3.最后的想法

希望这有助于您创建自己的数据集并扩充现有数据集。

如果您的数据很小或者已经在熊猫数据框架中。那么使用to_xarray()是创建初始对象最简单的方法。在任何其他情况下，从头开始创建数据集可能更容易。

我介绍了两种表示坐标的方法:向量或矩阵。我的建议是尽可能保持坐标为向量。如果数据不在规则的网格上，通常使用矩阵来存储坐标信息。

如果创建数据集时出现错误，首先要检查的是维度。很容易将维度打乱顺序。

我的另一条建议是，尽管在创建数据集时属性是可选的，但最好总是包含它们，这样您和其他人就可以轻松地解释数据集。我更喜欢在创建数据集对象后添加属性。这是我认为提高可读性的个人喜好。

感谢您的阅读，我很乐意帮助您解决任何问题

如何用 Python 创建第一个线性规划求解器

原文：https://towardsdatascience.com/how-to-create-your-first-linear-programming-solver-in-python-284e3fe5b811?source=collection_archive---------10-----------------------

了解这些软件包是如何工作的，以及如何创建您的第一个求解器。

由夏嫣·胡伊津加在 Unsplash 拍摄的照片

线性编程

线性规划(LP)是通过求解线性方程来获得问题的最优解的方法。

好吧，对你来说还是个谜？那么让我试着简化更多。

线性规划将寻找一个问题，并使用像 x 和y这样的变量将它转换成数学方程。之后，就是尝试这些变量的数字，直到你达到最佳解决方案，可能是最大或最小的可能值。

如果我给你等式 x + y = 10 并求 *x 的最大值，*这就是 LP 的一个好例子。

之所以称之为线性是因为那些类似于 xy 的数学表达式可以表示为空间中的一条线，这意味着如果我通过找到 x 和 y 的值来解方程，并将结果组合绘制在二维图形上，结果将是一条线。

看，是一条线！[ x + y = 10 ]。图片由作者提供。

解释概念

在本节中，我的意图是将线性规划应用于一个非常简单的问题，这将使我们充分理解如何将我们的问题转化为一个方程，线性解算器如何工作以及如何对它们进行编程。

最重要的事情首先。在编码之前，让我们回顾一些概念。

• 目标函数:那就是目标，你实际要解决的问题(比如利润最大化，损失最小化，空间分配最优化)。
• 约束:罐和斜面。在解决问题的过程中，什么会发生，什么不会发生(例如，值不能为负，容器中的最大可用空间)。
• 变量:问题的可变部分(如产品、价格、利润、规模)。

解决者（solver 的复数形式）

Python 中有几个可用的 LP 求解器包。其中有 SciPy，PuLP，CVXOPT。在本教程中，我们将使用PuLP。

使用 pip 安装它:

pip install pulp # for Jupyter Notebooks
!pip install pulp

问题是

想象一下，我们有一个 100 米乘 100 米的正方形区域，我们必须从 0 点到右上角画一条最长的 45 度对角线。但是，让我们想象一下，在距离上边距 5 米的地方有一个栅栏，在距离右边距 5 米的地方又有一个栅栏。我想知道如果我必须停在围栏上，我的 X 和 Y 的最大值是多少(我画最长线的坐标)。

问题的可视化。图片由作者提供。

就像我说的，这是一个非常简单的问题。你大概自己算出来答案是 x=95，y=95 吧？这也是我方法的一部分。既然你已经知道了答案，让我们来研究一下我们可以建立的逻辑，让计算机得到结果。

目标函数

如前所述，目标函数是我们的目标，是我们想要完成的，是我们试图解决的。

目标函数就是我们要解决的问题。

在我们的例子中，我们想要画一条对角线。你是否同意我的观点，为了在 2D 图上画一条对角线，我们所要做的就是给 X 和 Y 赋予相同的值？

(x=10，y=10)，(20，20)…。(80,80).X = Y =直线。图片由作者提供。

此外，我们希望将值加到最大值。这样，我们的目标函数就变成了 x + y 。

限制

在这个问题中，我们只有两个简单的约束:直线不能在栅栏之后，值不能为负。

约束是目标函数必须遵循的规则。

现在，为了将约束转化为数学形式，我们必须再次使用 x 和 y。让我们进行逻辑思考。如果场地是 100 x 100，我们有一个距离顶部 5 米、距离右侧 5 米的围栏，我们应该说 x 不能高于 100–5(*a . k . a . 95)。*这同样适用于 *y，*因为这意味着线越过了围栏。

1. 0 ≤ x ≤ 95
2. 0≤ y ≤ 95

创建求解器

下一步是使用纸浆来创建我们的解决方案，并找到最大的对角线结束坐标值。

将模块导入 Python 会话:

from pulp import LpMaximize, LpProblem, LpStatus, LpVariable

创建求解器和变量的实例。注意这里的lowBound参数将作为一个约束来防止负值。upBound参数并不那么重要，因为它会被 fence 约束覆盖，但是知道它的存在还是很好的。

# Create the **maximization** problem
model = LpProblem(name='Field Problem', sense=LpMaximize)# Initialize the **variables**
x = LpVariable(name="x", lowBound=0, upBound=100)
y = LpVariable(name="y", lowBound=0, upBound=100)

下一步是向模型添加约束。第一个元素是 LpConstraint 实例。第二个元素是您希望为该约束提供的名称。我们可以创建 x≥0 和 y≥0，但正如前面所解释的，这已经被考虑到了。

# **Add the constraints** to the model. Use += to append expressions to the modelmodel += (x <= 95, "margin_X") #it cannot go past the fence
model += (y <= 95, "margin_Y")

现在我们将目标函数添加到模型中。

# Objective Function
obj_func = x + y# Add Objective function to the model
model += obj_func

如果您想在求解之前查看刚刚创建的模型，只需调用您的模型名称。在那里你会看到它是如何从逻辑上将问题解读为数学问题的。以 x 和 Y 小于 95 为条件，最大化函数 x+y。

modelField_Problem: 
MAXIMIZE 
1*x + 1*y + 0 
SUBJECT TO 
margin_X: x <= 95  
margin_Y: y <= 95 

VARIABLES 
x <= 100 Continuous 
y <= 100 Continuous

求解。

status = model.solve()

打印报告。

print(f"status: {model.status}, {LpStatus[model.status]}")
print(f"objective: {model.objective.value()}")
for var in model.variables():
    print(f"{var.name}: {var.value()}")for name, constraint in model.constraints.items():
    print(f"{name}: {constraint.value()}")**[OUT]:**
status: 1, Optimal 
objective: 190.0 
**x: 95.0 
y: 95.0** 
margin_X: 0.0 
margin_Y: 0.0

不出所料， x 和 y 的最大值是 95。

# The field solution plot# Create a plot space
plt.figure(figsize=(8,8))# Dimensions of the field.
xlimits=[0,100,0,100]
ylimits=[0,0,100,100]# Plot field
plt.scatter(xlimits,ylimits)
# Plot line SOLUTION
plt.plot([0,x.value()], [0,y.value()], c='red')
# Plot MAX POINT
plt.scatter(x.value(),y.value(), c='red')
# Plot Fence 1
plt.vlines(95, 0,100, linestyles='--', colors='red')
# Plot Fence 2
plt.hlines(95, 0,100, linestyles='--', colors='red')# Annotations
plt.annotate(f'Optimal Value: {x.value(), y.value()} --->', xy=(47, 96));

解决方法。图片由作者提供。

在你走之前

这篇文章的目的是给你一个温和的和用户友好的 Python 线性编程的介绍。这个例子非常简单，但我们的想法是从这里开始，理解基本概念，以便能够将其应用于更复杂的问题。

如果你想深入了解，这里有一个来自 Real Python 的很好的教程。

如果这些内容对你有用，请关注我的博客。

https://medium.com/gustavorsantos

2021 年如何用 Coursera 创建自己的数据科学课程

原文：https://towardsdatascience.com/how-to-create-your-own-data-science-curriculum-with-coursera-in-2021-36feda936ead?source=collection_archive---------15-----------------------

用 Python 学习数据科学和机器学习基础的初学者友好方法

作者在他的无电缆管理的工作站上紧张地工作。感谢山姆·伯克的照片。

我在苹果工作的时候，我们有一套系统。如果您的设备有问题，您可以走进办公室，告诉我们问题所在，然后我们会让您知道如何当场解决问题，或者记下您的姓名，以便我们可以为您预约与技术人员一对一的时间。

我是一名技术人员，所以一旦我完成了一个客户，我就会看着名单，然后去找下一个。

一天，一个女孩拿着她的 iPhone 进来寻求帮助。我走过去和她打招呼，注意到她在一个蓝色的应用程序中滚动。

我问她这是什么应用。

她说是 Coursera。

那是什么？我问。

这是一个你可以学习不同东西的应用程序。

真的吗？你在大学学习吗？

不再是了，我只是觉得学点东西总是好的。

她不知道，但那一句话改变了我的一生。在那之前，我只在需要的时候学习:为了工作，为了学校。当然，有时我会追随自己真正的好奇心(玩电子游戏，学习烹饪)，但她的话说明了一个事实，如果我真的想，我可以学任何我想学的东西。任何事。

有趣的是偶遇会有这种效果。

我自己的路

那天晚上，我回到家，搜索她告诉我的那个蓝色应用的名字。就好像我发现了一个新的世外桃源。你可以选择你想学的，明天就有课了。

什么？

在那之前，我一直在大学学习(并且失败了)。我考虑过要学什么，但是必须在特定的时间特定的地点不适合我。我 17 岁开始上大学。我只想坐在草地上看女孩。

唉，我从来没有真正使用过 Coursera，直到几年前苹果商店的女孩告诉我。

我离开了苹果公司，决定学习如何开发我正在帮助解决问题的程序。

在第四次学习编码的时候(前三次我都放弃了)，我偶然发现了机器学习。换句话说，编写代码来使用数学在数据中寻找模式。

我想，我必须学会这个。

由于我认为我已经在大学度过了足够的时间，所以我整理了一份在线课程清单，以创建我自己的人工智能硕士学位。

你猜怎么着？

很多都来自那个女孩给我看的蓝色应用。

你自己的路

如果说 2020 有什么明确的话，那就是每个人都必须对自己的健康和教育负责。

现在是 2021 年(或者更晚，如果你在未来读到这篇文章，顺便说一句，你好)，物理采集规则仍然悬而未决，许多人(也许你)正在转向在线资源学习，而不是传统资源。

这篇文章不是关于大学和在线学习的争论。做任何适合你的事。

这篇文章演示了如何使用 Coursera 快速拼凑自己的数据科学和机器学习课程。

然而，不要误以为你可以很快地完成课程，因为工作已经结束了。

学习任何有价值的东西，尤其是网上学习，不适合胆小的人。如果你还没有，你将不得不培养一种责任感。这就是开发你自己的课程能为你做的。这会让你陷入困境。

数据科学和机器学习课程示例

人们总是问我，为什么不用免费资源呢？

我告诉他们，当然，你可以使用免费资源。但是我发现它们对我来说不太管用。我刚用 Coursera 的时候，他们是按月收费的。我马上就知道我要付多少钱。知道我在为某样东西付钱让我更认真地对待它。

但是你不是付了大学学费吗？

是的。但是我没有看到钱从我的账户里出来。我以为它是免费的，我以为它是神奇的。我花了 5 年时间完成了一个 3 年的学位，最终负债 35，000 美元(与其他人相比，这是一笔可观但微不足道的债务)。

具体时间到了。

大约一年前，我写了一篇名为学习机器学习的 5 个初学者友好步骤的帖子，通过在互联网上收集资源来学习机器学习的基础知识。

这篇文章的重点是让读者从对编程一无所知尽快用 Python 编程语言编写机器学习代码。

因此，为了开始 2021 年，我想我会复制这个帖子，通过 Coursera Plus 提供一些 Coursera 课程。

但是等等…这不仅仅是简单的复制。我还整理了一个想法模板，你可以用它来记录你的进展。

如果你以前从未使用过概念，在点击右上角的“复制”按钮之前，探索一下模板并点击一些东西(不要担心，你不能破坏它)，然后你将能够改变它以适应你的需要。

使用 data 和 Coursera 课程创建的数据科学课程示例。你可以复制一份，然后点击右上角的“复制”按钮，根据自己的需要进行编辑。为什么是观念？又好玩又免费。

你可以在 YouTube 上看到上面的概念模板和课程的视频演示。

现在，用一个步骤列表来减少一点互动怎么样？

注: 如果你正在读这篇文章，并认为“哇，这听起来像是 Coursera 的广告”，你是对的。Coursera 找到我，问我是否有兴趣写一篇帖子，专门帮助学生用 Coursera 整合他们自己的课程，我说有。也就是说，把这条消息作为一个披露，如果你点击这个帖子中的链接，并支付一些东西，金额不会改变，但我会得到你支付的金额的一部分(我用来创建这样的资源的资金)。

第一步:学习如何学习专业化

**是什么:**发现并复制艺术家、数学家、音乐家等的最佳学习技巧。

**为什么它很重要:**如果你要开始自己的学习之旅，你最好学会如何学习。学会如何学习是终极元技能。因为如果你能学会如何学习，你就能学到任何东西。

我建议每个人都学习这门课程，不管他们是学习数据科学、机器学习还是粒子物理。你可以在我的博客上查看我的完整评论文章。

第二步: Python 为大家特殊化

**是什么:**这个专业化将帮助你从零编程能力到能够编写 Python 代码。

**为什么重要:**如果你想进入数据科学和机器学习领域，很有可能你会去写 Python 代码。但是如果以前没有使用过 Python 语言，很难编写 Python 机器学习代码。所以使用这个专门化来熟悉 Python 的基本概念。

第三步:用 Python 应用数据科学

**它是什么:**现在你已经掌握了一些基本的 Python 技能，是时候开始对它们进行裁剪，以便能够处理数据了。这种专门化将使您熟悉流行的 Python 数据科学库，如 pandas、matplotlib 和 scikit-learn。

**为什么重要:*因为 Python 是一种通用编程语言，你几乎可以用它做任何事情。但是好消息是，你在 Python 中为每个人学习的基础知识可以在这里使用。更具体地说，您将开始学习如何使用:

• pandas —一个广泛的数据分析库，用于处理 Excel 电子表格中的数据(行和列)。
• matplotlib —一个 Python 库，用于使用您的数据创建可视化绘图。
• scikit-learn —一个广泛的机器学习库，具有许多预先构建的机器学习模型和功能，用于准备和转换数据。

第四步:机器学习专门化

**是什么:**如何诊断机器学习问题？是回归吗？分类？聚类？信息检索？这个专业将教你如何回答这些问题，并建立能够在数据集内学习模式的系统。

**为什么重要:**Python 专业的应用数据科学教会了你如何操作和可视化数据，现在在机器学习专业中，你将学习如何编写机器学习代码来查找数据中的模式。

第五步:机器学习专用数学

**是什么:**如果你一直想知道机器学习算法如何能够学习数据中的模式，有一个答案:数学。主要是通过线性代数和多元微积分的结合(加上一些其他的)。

机器学习数学专业将帮助您理解为许多最有效的机器学习算法提供动力的基础数学。

**重要提示:**数据是自然的压缩形式，数学可以用来发现数据中的模式，代码可以用来执行大规模的数学运算。上面的步骤主要是让你尽快编写代码。然而，随着您了解的越来越多，您可能会想要发现您正在编写的代码是如何工作的。

这个专业将带你深入机器学习算法的内部工作，并进一步加强你对你正在编写的代码的理解。

为什么是这些？

在 Coursera Plus 上有 3000 多个专业/课程。对你来说太多了。

我挑选的这些来自我自己的个人经历(我已经浏览过了)，或者因为它们的内容是世界一流的，正是你开始学习数据科学和机器学习所需要的。但话虽如此，如果有什么能激发你的兴趣，那就去做吧。

经历这一切需要多长时间？

按你自己的速度走。但是如果你把所有推荐的时间表加起来，你可能会在 12-18 个月之间结束。

然而，永远不要低估速度的力量。建议的时间表适用于平均水平为的学生。你是普通人吗？还是你渴望学习？如果你是后者，记住，没有速度限制。

我需要 Coursera Plus 吗？

不。你可以单独挑选任何你想要的课程。然而，如果你打算经历以上所有，Coursera Plus 提供了一个很大的折扣。

我试过了，不喜欢…可以退款吗？

是的。注册 Coursera Plus 后你还有 14 天时间。

但这是我自己经历的另一件趣闻。我过去报了一个课程，害怕自己做不到。所以我给支持团队发了邮件，询问退款政策是什么。他们告诉我两个星期。

结果我没有得到退款。我完成了课程，挣扎着，错过了最后期限，但是当我从另一边出来时，我知道的比我开始时多得多。

基本面之后

这篇文章的主要观点是互联网让你可以创造自己的学习之旅。Coursera 是一个非凡的资源，我强烈推荐它，但它只是众多资源中的一个。

我们所说的一切都可以在 Coursera 之外学到。你甚至可以使用概念课程模板，用所有免费资源复制它，并跟踪你的进度。

假设你做了，你创建了自己的课程，不管是不是 Coursera 驱动的。你下一步应该做什么？

那个问题值得单独写一篇文章。但是最起码:分享你的作品。

写下你所学到的。用你自己的名字创建一个博客。搜索“如何用 GitHub 页面创建博客”或开始在 Medium 上写作。

不要担心别人已经写了你想写的东西。写下你所学到的东西的练习会进一步帮助你的学习。

六个月前的你会想知道什么？写下来。

关于这方面的更多信息，我推荐阅读“像我这样的初级数据科学家如何获得经验？”。

高级技能呢？

这篇文章已经涵盖了基本原理。如果你想拓展你的知识，我会推荐所有的 deeplearning.ai 课程和所有的 fast.ai 课程。

之后，你就完成了课程。开始你自己的项目。课程教授基础知识，自我驱动的项目帮助你学习细节(无法教授的知识)。

如何创建自己的仇恨推特探测器

原文：https://towardsdatascience.com/how-to-create-your-own-hate-tweet-detector-704508c34cd0?source=collection_archive---------13-----------------------

一步一步的教程，关于开发一个机器学习分类算法来检测 Python 中的仇恨推文

乔恩·泰森在 Unsplash 上的照片

发布一条仇恨的推文会有什么后果？

在推特层面，推特可以采取以下行动:

1. 将推文标记为包含有争议或误导的信息
2. 要求您删除该推文，然后才能再次发布
3. 隐藏违规的推文，等待删除

在账户层面，这些行动是针对惯犯或做了特别恶劣事情的人采取的:

1. 要求编辑配置文件或媒体内容，并使其在编辑前不可用
2. 将帐户设置为只读模式会阻止推文、转发或类似功能
3. 要求验证帐户所有权，以检测拥有多个帐户的匿名用户
4. 永久暂停

Twitter 不同的“地狱圈”旨在确保没有用户会因为无意中发布了冒犯性的消息而受到过于严厉的惩罚。因此，除非你是一个惯犯，否则你不太可能删除你的帐户或将其置于只读模式。

仇恨言论真的那么普遍吗？

近年来，仇恨推特业务已经远远超出了柠檬水摊位。早在 2018 年第一季度，脸书就对 250 万条仇恨言论内容采取了行动，但在 2020 年最后一个季度，脸书对高达****2690 万条仇恨言论采取了行动。所以每个月大约有 900 万英镑左右。

脸书和推特都已经开发了检测仇恨言论的专有算法，因为它们看到了仇恨言论的恶毒和阴险性质，特别是在社交媒体平台上，因为它能够煽动暴力。能够开发这样的检测模型将被证明对任何初创公司都是有用的，特别是社交媒体，或者任何希望监控 Reddit 等在线论坛或公司内部通信中的仇恨言论的公司。

开发部署模型的步骤

马尔科·比安切蒂在 Unsplash 上拍摄的照片

下面是我对从原始数据到准备部署的模型的进展的粗略概述:

1. 环境设置
2. 数据收集
3. 数据准备
4. 模型训练和评估
5. 超参数调谐
6. 模型预测法
7. 模型部署

您将在以下笔记本中找到该项目的完整代码:

https://github.com/datascisteven/Medium-Blogs/blob/main/Hate-Tweet-Detector/Hate_Tweet_Detector.ipynb

环境设置

照片由布雷特·乔丹在 Unsplash 拍摄

要创建环境，请将environment.yml放在您想要创建项目的文件夹中，并从终端中的同一个文件夹运行以下代码:

$ conda env create -f environment.yml

数据收集

开发任何有监督的机器学习算法机器的第一步是数据收集，即获得有标签的数据集。我从 Davidson 数据集开始，因为它已经包含了数据库中实际的 tweet 文本，我可以开始这个项目了，但是大多数带标签的数据库只提供 tweet ID。

由于数据集呈现出巨大的阶级不平衡，我进行了彻底而狂热的搜索，寻找额外的带标签的数据集来支持我的少数阶级，并偶然发现了这个网站:hatespeechdata.com。我最终决定了来自哥本哈根大学、亚里士多德大学和 HASOC 2019 共享任务数据集的数据集。

最初的戴维森数据集总共包括 24783 条推文，其中 23353 条(或 94.2%)被标记为非仇恨，1430 条(或 5.8%)被标记为仇恨。在将额外的少数民族实例合并到数据集之后，我通过将少数民族类实例增加到 7025 条(或 30.1%)仇恨推文(总共 30378 条推文)来解决类不平衡问题。

Twitter API

让我们来看看如何从 Twitter 上下载自己的一组仇恨推文。

对于只有 tweet IDs 的数据集，您需要申请一个开发人员帐户来访问 Twitter API 以获取 tweet 文本。公平的警告，它可能不是一个立竿见影的过程。Twitter 联系我，向我详细介绍我的项目细节。

完成后，创建一个应用程序从 Twitter 获取 API 键，然后将它们放在一个config.py文件中，无论它们是被赋给变量，还是作为值放在字典中，等等。

将这个config.py文件放入.gitignore以保持 API 密匙私有。要使用密钥，请将模块导入您的笔记本电脑:

from config import keys

如果keys是一个字典，我们可以很容易地用字典的不同键来检索 API 键:keys[‘key_value’]。

Twitter 要求以特定的格式提交 id，每批不超过 100 个，以字符串格式提交，id 之间用逗号分隔，不能有空格。

第一个函数创建一个字符串列表，其中每个字符串是一批 100 个逗号分隔的 tweet IDs:

这段代码是在 Postman 代理的帮助下生成的，当前一个函数生成的列表作为tweets_ids:传递给下面的函数时，第二个函数生成请求字段的数据帧

为了您的方便，我已经在 repo 中包含了我的组合数据集combined.csv,以防您想跳过这些数据收集步骤。

数据准备

为了在机器学习算法中使用自然语言，我们必须将单词转换为数字，这是算法可以识别的形式。

推文与文本

让我们想想一条推文与任何一篇文学文本有何不同:

1. 可能语法不正确
2. 拼写可能不正确(即缩写、组合词、重复字母，如 FML、F$ckMyLife、Fuuuuuu$$ my life)
3. 使用特殊字符，如#或@和表情符号

这里的目标是删除任何特殊字符，用户名，URL 链接，转发，任何不会增加句子语义的东西。

所以在这里进行一些无耻的自我宣传，但如果你需要快速刷新正则表达式，请查看我的帖子: To RegEx or Not To RegEx，第一部分 和To RegEx or Not To RegEx，第二部分 。

用于预处理推文的代码

我将简要讨论我在创建用于预处理推文的函数时的思维过程:

第一个函数用于词汇化，它返回每个单词的根形式，即“dimension”、“dimensional”和“dimensionality”都作为“dimension”返回。第二个功能是创建一个标记化和词条化的 tweets 列表，其中停用词和少于 3 个字符的词使用模块gensim进行标记化，这会自动降低所有词的大小写。

预处理功能的组件

1. 转发是 Twitter 上转发的消息，包含 RT 标签和转发的 tweet 文本，有时还包含用户名。我决定保留转发的文本，但删除“RT @username ”,因为用户名没有增加语义值。
2. 推文通常包含其他网站、推文、在线媒体等的 URL 链接。我删除了 http 和 bit.ly 链接，后者是一个 URL 缩短服务。
3. Unicode characters 有一个 HTML 代码，以下面两个字符&#开头，后面跟着一个数字，可以指表情符号、符号、标点符号等。除了常规的标点符号之外，我还删除了这些，但在删除标点符号之前，我删除了 URL 链接。
4. Hashtags 是前面有一个哈希(#)符号的单词或短语，用于标识它与特定主题相关，我决定保留这个短语，因为它通常具有一些语义值。
5. 我将任何 1+的空白改为单个，并删除了任何前导和尾随空白。
6. 我按照内部大写的指示，将所有连接的单词(如 AaaaBbbbCccc)分开。
7. 我删除了所有大于 2 的重复字母，因为在英语中没有一个字母重复两次以上的例子。

我们最终得到的是一个小写单词的字符串，这些单词要么是词干化的，要么是词干化的，由空格分隔，并且在数据帧的每一行中都删除了停用词、1 个和 2 个字母的单词、特殊字符、用户名、标点符号、额外的空格和 URL 链接:

“lemma space separate lowercase tweet”

模型训练和预测

让我们通过下面的步骤创建一个管道，TfidfVectorizer()，它结合了CountVectorizer()和TfidfTransformer()的功能，前者将文本转换为令牌计数矩阵，后者将该矩阵转换为规范化的 tf-idf 表示。

然后，我们在训练集上拟合模型，这里的X-train是预处理的 tweet 文本。我们不需要使用fit_transform，因为TfidfVectorizer()包含一个变压器:

一旦我们符合这个模型，我们就可以继续进行预测，并将任何推文分类为讨厌或不讨厌:

我们必须通过preprocess()函数传递推文，并使用经过训练的管道进行预测。这条推文最终被归类为仇恨推文。

注意:通过比较 6 种不同的算法并使用 GridSearchCV 执行超参数调整，确定这是最好的。结果位于以下报告中:

下一步是什么？

1. 您可以包含额外的标注数据集来改善类别不平衡。
2. 您可以对预处理函数进行额外的调整。
3. 您可以尝试不同的分类算法，包括 Doc2Vec 或神经网络。

在下一篇博客中，我将仔细看看最后一步:部署。我将看看我们作为数据科学家可以部署模型的不同方式。

在GithubLinkedIn上与我联系，或者通过 [邮箱](mailto: datascisteven@gmail.com) 。在下面的 网站 看看我以前的博客和转帖。

如何创建自己的机器人日记

原文：https://towardsdatascience.com/how-to-create-your-own-robojournalist-36b463c91025?source=collection_archive---------29-----------------------

遵循我的一步一步的指导，用 Python 创建你的第一个数据到文本的新闻自动化系统

照片由雅诺什·迪格尔曼在 Unsplash 上拍摄

最近，我一直在想，我该如何向我的祖父解释我对自动新闻的自然语言生成的研究。我想，我可以创建一个简单的机器人记者来写他最喜欢的运动——足球。不幸的是，他已经在几年前去世了，但我会给你看。

期待什么？

在本文中，我将向您展示如何使用 Python 创建基于模板的新闻自动化系统。该方法本身非常简单，但是当您希望将一些重复的数据表示为书面报告，并确保输出如实地表示底层数据时，它确实很有用。

优点:

• 简单—不需要 NLP 方面的专业知识，您只需要了解您的数据。
• 流利——你造出的句子语法正确。
• 准确—不包括黑盒解决方案，输出将总是真实的。

缺点:

• 不可转移-对于下一个数据集，您需要重复整个过程。
• 费力-设计模板和微调输出需要时间和精力，而且每当您有不同形状的数据或来自不同领域的数据时都需要时间和精力。
• 重复—所有报告都相同。这可以通过添加替代模板或添加单词/替换单词来解决，请查看我的文章robo journalism——如何解决重复问题。

创建简单新闻自动化系统的分步指南

你是否有一些重复的数据进来，想以文本形式呈现给你的朋友/关注者/诸如此类的人？遵循这 6 到 7 个步骤来实现。

第一步:选择要报告的数据

我将使用《体育参考》提供的描述最近欧洲足球锦标赛的数据集。他们提供现成数据的 CSV 导出。这里可以找到。

步骤 2:加载数据并替换丢失的值

第三步:决定报道什么

我选择了以下数据字段进行报告

• 轮次
• 一天
• 日期
• 家庭(团队)
• 得分
• 离开(团队)
• 举办地点
• 笔记

步骤 4:创建模板

我对模板的想法很简单:我列出我想包含的句子。在句子模板中，定义的属性所在的位置被表示为{列名}。

步骤 5:将数据嵌入到模板中

我们有个小问题。我们提到 cadence 的第三个模板并不适用于所有活动，仅适用于跑步。这些缺失的值在我们的数据中用两条虚线表示。解决方案:在输出报告之前，删除最后包含两个破折号的任何句子。

第六步:输出

现在我们有了:关于 2021 年欧洲足球锦标赛的报道。我只包括了关于最后五场比赛的报道。

步骤 7:转换数据以微调输出

使用这种方法，您将获得与模板和输入数据一样好的输出。因此，通过对输入数据进行一些简单的转换，您将获得更好的输出。

我有没有让你疑惑，如何让输出更生动？查看我的文章robo journalism——如何应对重复,并关注如何在你自己的 NLG 系统上应用我的想法的分步指南😊

如何创建自己的 VS 代码服务器

原文：https://towardsdatascience.com/how-to-create-your-own-vs-code-server-fa7812d308b0?source=collection_archive---------4-----------------------

在家工作与远程工作不同

约书亚·阿拉贡在 Unsplash 上拍摄的照片

Visual Studio Code 是一个免费的、轻量级的、跨平台的代码编辑器。它可能不像 IntelliJ Idea 或 PyCharm 那样是一个成熟的 IDE，但它是一个强大的、不受干扰的工具，拥有专门的粉丝群和蓬勃发展的生态系统。

近年来，VS Code 已经成为许多开发人员喜欢的编辑器，不管他们的背景、语言和选择的技术如何。因此，下一个合乎逻辑的步骤是尝试在任何地方运行 VS 代码。例如，我们已经看到 GitHub 如何将其集成到代码空间中，在那里您可以生成一个即时开发环境，并调整您的存储库中的代码。

在家工作与远程工作不同。远程工作意味着在世界上的任何地方全天 24 小时工作。

然而，GitHub 代码空间的缺点是定价。目前，这项服务处于公测阶段，可以免费使用。但是 GitHub 将会在 Codespaces 正式发布时宣布价格。不幸的是，我们在相应页面上得到的细节并不令人鼓舞。没有免费层，没有小实例，整体价格虚高。

如果您可以构建自己的服务器，或者租用一个较小的实例，甚至使用 GPU 或 TPU 加速获得一个较大的实例，会怎么样？此外，在下面的故事中，我们看到了如何使用远程开发来隔离您的项目并与您的团队成员轻松协作。

但是，如果您可以将 VS 代码与您的项目依赖项一起打包，创建一个真正灵活的环境，实现在世界上任何地方、任何时间工作的梦想，或者没有任何麻烦地加入新的团队成员，会怎么样呢？让我们看看如何创建自己的 VS 代码服务器！

学习率是为那些对 AI 和 MLOps 的世界感到好奇的人准备的时事通讯。你会在每周五收到我关于最新人工智能新闻和文章的更新和想法。在这里订阅！

创建自己的 VS 代码服务器

在这个故事中，我们将在 GCP 上使用一个 VM，但是你应该很容易使用任何机器或 VM 提供者。

首先，在 GCP 上启动一个虚拟机，至少有 2 个 vCPU 内核、1GB 内存和 32GB 标准存储。请注意，这个低端选项在代码空间上不可用。具有这种配置的虚拟机与 Codespaces 的预算产品之间的差异是每月 4 美元(一天 8 小时，一周 5 天)。在代码空间，你要支付大约 13.5 美元，而在 GCP 大约 9.5 美元。

差别不是很大，但是使用你自己的虚拟机给了你更多的灵活性；你可以根据自己的需要精确调整它，当你需要更大马力时扩大它的规模，当你测试一个新想法时，你可以放弃。

您的实例将在几秒钟内准备好。点击右边的SSH按钮，连接到机器并安装 VS 代码服务器。

连接到虚拟机实例—按作者排序的图像

为了安装一个 VS 代码服务器，我们将通过编码器使用code-server。要安装它，请运行以下命令:

curl -fsSL https://code-server.dev/install.sh | sh

等待几秒钟，然后通过执行code-server启动服务器。VS 代码实例将开始监听localhost以避免向外界暴露自己。这是至关重要的，因为有人可以完全接管你的机器使用 VC 代码终端。

那么，如何连接到服务器呢？最简单的方法是使用 SSH 转发。首先，停止服务器并运行以下命令来禁用密码身份验证方法，然后重新启动服务器:

sed -i.bak 's/auth: password/auth: none/' ~/.config/code-server/config.yamlsudo systemctl restart code-server@$USER

假设您已经设置了一个项目范围的 SSH 密钥，启动您的本地终端并运行以下命令:

ssh -i [path/to/your/private/key] -N -L 8080:127.0.0.1:8080 [user]@<instance-ip>

最后，启动一个终端并导航到[http://127.0.0.1:8080/](http://127.0.0.1:8080/)。你现在有了自己的 VS 代码服务器！

浏览器中的 VS 代码—作者图片

如需详细文档，请访问 GitHub 上的code-server 文档页面。

结论

Visual Studio Code 是一个免费的、轻量级的、跨平台的代码编辑器，是一个强大的、不受干扰的工具，拥有专门的粉丝群和蓬勃发展的生态系统。

将它作为一个网络应用程序来运行，可以让你在世界上的任何地方，使用任何媒介(甚至是你的 iPad)来工作。此外，您可以将其与您的项目一起打包到孤立的容器中，并创建一个无缝的入职流程。所以，继续构建你自己的 VS 代码服务器吧。

关于作者

我叫 Dimitris Poulopoulos ，我是一名为 Arrikto 工作的机器学习工程师。我曾为欧洲委员会、欧盟统计局、国际货币基金组织、欧洲央行、经合组织和宜家等主要客户设计和实施过人工智能和软件解决方案。

如果你有兴趣阅读更多关于机器学习、深度学习、数据科学和数据运算的帖子，请在 Twitter 上关注我的 Medium 、 LinkedIn 或 @james2pl 。此外，请访问我的网站上的资源页面，这里有很多好书和顶级课程，开始构建您自己的数据科学课程吧！

如何创建您的个人数据科学学习课程

原文：https://towardsdatascience.com/how-to-create-your-personal-data-science-learning-curriculum-676329562331?source=collection_archive---------14-----------------------

由 envato elements 的 hoangpts 使用图像创建(经许可)。

加上我整理的数据科学课程列表

1.介绍

数据科学是一个快速发展的领域，因为它为企业和行业带来了巨大的价值和数据驱动的洞察力。作为一种职业，数据科学家被誉为 21 世纪最性感的https://hbr.org/2012/10/data-scientist-the-sexiest-job-of-the-21st-century，这也是发表在《哈佛商业评论》上的标志性文章的标题。

每个有抱负的数据科学家在他们的数据科学学习旅程中都会遇到的一个问题是: 一个人到底应该如何学习数据科学？ 这个问题的答案可能会有很大的不同，这取决于学习者可以获得的独特机会和资源。

您可能想知道以下问题:

• 我应该攻读数据科学的研究生学位吗？
• 我应该参加训练营以获得数据科学技能吗？
• 我应该找一个能指导我进入数据科学领域的导师吗？
• 我可以接受数据科学方面的在职培训吗？
• 作为一个自考的人可以自己学习数据科学吗？

以上问题都是有效选项。

在本文中，我们将重点关注后一种选择，即如何作为自学者自学数据科学。怎么会？通过设计你自己的个人学习课程。

让我们开始吧！

如何创建你的个人数据科学学习课程 @ 数据教授 YouTube 频道

2.自学数据科学

就我个人而言，当我在 2004-2005 年作为一名生物学本科背景的博士生开始学习数据科学时，我基本上是自学的。当时，术语数据科学还不存在，而是使用术语数据挖掘和机器学习*。*

对我来说，我可以肯定地证明，这一旅程并不容易，道路也不清晰。我在我的一些 YouTube 视频中探索过这个故事( 一个生物学家如何成为一个数据科学家 和 成为一个数据科学家(读博士或不读博士) )。长话短说，我想应用机器学习来分析和理解生物数据集。

了解我现在所知道的，再加上现在存在的关于数据科学的学习资源的指数增长，我可以说，这些天的学习环境对于闯入数据科学的初学者来说更加友好。

让我们在本文的后续部分更深入地探讨如何自学数据科学。

3.创建您的个人学习课程

有很多关于数据科学的学习资源(我们将在本文中介绍),但并非所有这些都是通用的。正是因为这个原因，重要的是我们要弄清楚哪些话题是我们最感兴趣的，并专注于这些话题，而不是试图分散我们的精力，试图了解一切。

如果你想制定自己的学习计划或个人学习课程，从为什么开始。

你为什么学习数据科学？

您打算如何使用和应用数据科学？

通过回答这些问题，您将能够找出您对数据科学中的哪些特定主题最感兴趣，以及哪些主题能够帮助您解决数据问题。

为什么为了学习而将宝贵的时间集中在学习数据科学中的琐碎主题上，而这并不能提供您需要的结果？

一旦明确了原因，您将能够自信地在数据科学主题的丛林中导航，并特别关注那些可以帮助您从点 A* 到点 B 获得所需结果的主题。*

4.关于数据科学的免费学习资源

有大量与数据科学相关的学习资源。让我们考虑免费路线和付费路线(在下一节)。

先说免费的学习资源。

4.1.油管（国外视频网站）

YouTube 通常被认为是互联网上仅次于谷歌的第二大搜索引擎。很多时候，你可以在 YouTube 上找到你想要了解的东西。尽管如此，并不是所有你想学习的主题都在一个完整的结构化课程中提供。然而，你无法打败 YouTube 上免费提供的精彩内容。

以下是一些 YouTube 频道，您一定要订阅其中的数据科学内容:

• 数据教授(是的，那是我自己的 YouTube 频道😎)
• 肯吉
• 克里斯·纳伊克
• 代码基础
• 黄婷婷
• 丹尼尔·伯克
• 尼古拉斯·雷诺特

4.2.博客和网站

博客也是学习数据科学各种主题的重要资源。很多时候，你会谷歌感兴趣的特定主题，你会点击顶部的搜索结果，然后会带你到包含数据问题解决方案的网站和博客。

这里有一些很棒的博客和网站:

• 数据教授@ Medium (←是的那也是我自己关于 Medium 的博客😎)
• 走向数据科学
• 向着艾
• 自由代码营
• 极客书店
• 机器学习掌握度
• Kaggle Learn

4.3.书

书籍是很好的资源，我会不时地节约使用，作为各种感兴趣话题的参考。

在我个人从零开始自学的学习过程中，我试图从书本中学习编码概念，但根据我自己的经验，我主要是解决任意的问题，这不能让我参与到学习中。不幸的是，这让我把学习编码搁置了一段时间。

在我随后的尝试中，我改变了学习方式，不再仅仅依靠书本上的例子来学习，而是使用我自己的数据问题作为学习的基础。在那里，我会搜索、阅读与手头问题相关的精选书籍章节和教程。这给了我即时的满足感，让我在学习过程中保持动力。

现在，让我们探索一些免费的图书资源。其中有几本书是免费(软拷贝形式)和收费(硬拷贝和软拷贝形式)提供的。

• 这本长达百页的机器学习书籍 ( 阅读电子书 ) 提供了机器学习中关键概念的简明高层次概述。
• Python Data Science Handbook:Essential Tools for Working with Data(阅读电子书)提供了初学者友好的概念和示例代码，用于使用 Python 执行 EDA 和机器学习模型构建。
• 机器学习的数学 ( 阅读电子书)提供了机器学习中底层数学的解释。
• 处理几乎任何机器学习问题 ( 阅读电子书)是一本实用的食谱，为读者提供示例代码，帮助他们启动自己的项目。
• 统计学习介绍:R 中的应用 ( 阅读电子书)提供了统计学习中的关键主题以及伴随的 R 实践的广泛且技术性较低的覆盖范围。

4.4.播客

我经常发现播客是一种很好的补充资源，可以增加学习体验，因为它们经常提供由经验丰富的数据科学家和数据工程师分享的数据科学的见解和背景。

• 肯最近的邻居
• 数据科学的艺术家
• 数据帧(由数据营提供)
• 超级数据科学(乔恩·克罗恩)
• 在数据科学领域建立职业生涯(杰奎琳·诺利斯和艾米丽·罗宾逊)
• 走向数据科学
• 实用 AI(Changelog Media)

5.数据科学的付费学习资源

在现有的付费学习资源中，我们将把大学和训练营排除在外，因为从技术上来说，它们采用讲师和导师的方式，通常在现场实时提供。这种方法的伟大之处在于它提供了结构化的课程。也许是另一篇文章的主题。

5.1.书

书籍也是自学数据科学的重要资源，但根据我自己的学习经历，它们可能不是最吸引人的途径。当然，几乎有一本书可以满足你在数据科学中可能遇到的任何主题，但我经常发现它最好作为补充学习资源，与你正在学习的课程(稍后将讨论)一起使用。我经常发现书籍有助于深入探究我感兴趣的特定主题。因此，在我们弄清楚我们想读哪本书之前，我们首先要弄清楚我们想探索什么主题。因此，为了最大化从书本中学习的益处，我们需要精心设计我们自己的个人学习课程。

5.2.学习平台

学习平台也是自学的好方法，因为它们提供结构化的课程*，与大学和训练营提供的课程非常相似。另一个伟大的事情是异步学习方法，它适应了职业人士的生活方式，学习者可以在业余时间学习并取得进步。*

事实上，有好几个平台可供选择，你应该选择哪一个呢？坦率地说，所有的平台都提供了很好的内容，也许交易的破坏者在于每个平台的细微差别。让我们看看这些平台的不同类别，这可能有助于您决定哪个最适合您的需求或学习风格。

5.2.1.定价

为什么要付费上课程？
虽然如果课程是免费的就好了，但就像生活中的所有努力一样，创建课程需要大量的计划和时间来创建内容，这也需要在学习平台上托管视频内容的费用。

创建一个高质量的课程需要时间和金钱，那么这些是如何融资的呢？在 YouTube 等免费平台上，部分广告收入流向了内容创作者以及附属链接(如本文中的链接)，这些收入用于资助内容创作者，以便他们可以创作更多精彩的内容。

由于这些学习平台不提供广告，因此最终支持讲师的平台融资方式是来自课程和订阅销售的收入。

有哪些定价方案？
学习平台通常按课程收费(如 Udemy)或按订阅收费(如 Coursera、DataCamp、DataQuest、O'Reilly Learning、Udemy Business 等)。).

订阅计划——正如你所看到的，大多数平台在订阅的基础上收费，同时提供一些免费的课程内容或免费试用期，以测试它们是否适合你。这种做法的好处就像自助餐一样，你可以无限制地使用课程，而坏处是你可能会付出高昂的代价，如果你正在学习新东西，这是没问题的，但我经常发现自己支付订阅费，我可能很少访问，特别是在繁忙的工作时间表。

按课程付费——Udemy 似乎是唯一提供按课程付费模式的平台。这似乎是最灵活的，因为它以直接的方式工作。你只需支付你所学课程的费用，不多也不少。对于您付费的课程，您将无限期地拥有课程的使用权。例如，我总是能够访问一两年前购买的课程。这样做的一个缺点是，你可能会积累和储存课程，很少访问它们。对此，一个简单的补救办法是在推进学习之旅时自律、坚持和坚持，这样你就能实现你为自己设定的预期目标，无论是成为一名数据科学家还是提高技能。

5.2.2.教练

知名的学习平台，如 Udemy、DataCamp、Coursera 等。热衷于吸引该领域的顶级和有才华的专家，这在平台上教授的内容中得到了很好的反映。

例如，我的好朋友 Ken Jee(他全职负责数据科学，兼职是 YouTube 上的内容创作者)在 Udemy 上开设了一门课程。其他知名的数据科学 YouTubers 和才华横溢的教育家，如 Tina Huang、Daniel Bourke 和 Giles McMullen-Klein，也在 Udemy 平台上创建了数据科学课程。

除了数据科学之外，其他的导师还包括安吉拉·于和，她们在 Udemy 上开设了广受欢迎的课程，教授如何编程。

受到这些才华横溢的 YouTuber 课程创建者的启发，希望我能找到时间和动力来创建自己的数据科学课程。请在评论中告诉我，我应该创建哪个课程。

5.2.3.证书

学位和证书在职场人士中一直很受欢迎，因为它们经常被用作向雇主展示知识/技能的证明。其中一些学习平台在学员完成一门课程后授予证书(如 Udemy、DataCamp 等)。)而另一些则是在完成一系列课程后(如 Coursera)。

作为一名 YouTube 用户(查看我的 YouTube 频道， 数据教授 )，我经常被观众问及证书的价值。我诚实的回答是，这些课程所包含的知识总是有益于一个人的学习之旅。但是为了将新获得的知识内在化，为了将这些知识转化为可操作的技能，使之成为你内在的一部分，那么学习不会在获得证书后停止。相反，我总是建议将新获得的知识/技能应用到项目中。

6.看看 Udemy 平台

以下是我对 Udemy 平台的真实看法，它是一个供自学的数据科学家使用的付费学习资源。

Udemy 上的一个课程截图。

让我用简洁的要点来总结一下。

• 价格和灵活性 —首先，Udemy 有两个版本:(1)针对典型用户的普通计划，按课程销售(我们将在本节中介绍)和(2) Udemy Business(这是一种基于组织的订阅服务，提供。对于普通计划，用户可以购买课程并终身访问，这与基于订阅的计划相比可能更经济。鉴于我们选修了许多课程，订阅也可能是经济的。但是如果我们有节制地学习课程，那么购买个别课程可能更划算。还应注意的是，一旦订阅结束，就失去了对这些课程的访问权。偶尔，一些课程也可以在输入特殊的访问代码后完全免费提供
• 讲师 —如上所述，涵盖数据科学的课程主题由 Ken Jee、Daniel Bourke、Angela Yu 和柯尔特·斯蒂尔等天才教育家授课。
• 课程主题 — Udemy 拥有大量课程，不仅涵盖数据科学和机器学习，还包括艺术、通信、商业等。这可能有助于提供提高技能的机会来学习各种技术和软技能。
• 课程内容 —除了视频，课程还可能配备辅助材料来帮助学习体验。比如 Daniel Bourke 的 完全机器学习&数据科学 Bootcamp 2021 在 Github 上也自带代码、工作簿和模板(Jupyter 笔记本)。
• 教学模式 —课程通过小视频进行教学，这些视频被分成几个部分，这可能有助于跳到你感兴趣的特定主题。这可能非常类似于 YouTube，但有一个额外的好处，即在完成课程后，会授予结业证书。另一个好处是课程范围内各种主题的全面覆盖(这可能是也可能不是 YouTube 视频的情况，YouTube 视频可能是关于特定主题的独立视频，如果我们想更深入地探索该主题，可能会让我们悬而未决)。

7.精选课程清单

这里是根据主题分类的学习数据科学的顶级课程的精选列表。

计算机编程语言

• Python 绝对初学者 贾尔斯·麦克马伦-克莱因著
• 代码 100 天——2021 年 Python Pro 训练营全集 作者 Angela Yu
• 现代 Python 3 训练营 柯尔特·斯蒂尔著

结构化查询语言

• 终极 MySQL 训练营:从 SQL 初学者到专家 作者柯尔特·斯蒂尔
• SQL — MySQL 用于数据分析和商业智能365 个职业
• SQL for Tech 与数据科学访谈Tina Huang

机器学习

• 完全机器学习&数据科学训练营 2021 作者丹尼尔·伯克
• 机器学习 A-Z:数据科学中的实践 Python&R作者:基里尔·叶列缅科
• 何塞·波尔蒂利亚 Python 数据科学和机器学习训练营
• 2021 年 TensorFlow 开发者证书:零到精通 作者:丹尼尔·伯克

模型部署

• Web 开发者 Bootcamp 用 Flask 和 Python 作者何塞·萨尔瓦蒂耶拉
• 学习 Jesse E. Agbe 的 Streamlit Python

职业

• 如何在数据科学领域开始职业生涯 2021 作者 Ken Jee

8.将新发现的知识转化为实际应用

随着时间的推移，通过完成越来越多的证书来积累知识当然很好，但同样重要的是将这些知识/技能用于构建不断增长的项目组合。因此，我强烈推荐建立一个作品集网站(和 GitHub 个人资料),你可以用它来展示你惊人的作品。

相信我，这是一个游戏改变者，因为他们不仅可以作为其他志同道合的同行的有用资源，而且你的工作也可能激励那些正在开始类似旅程的人。当知道有人从你的项目和内容中获益良多时，这种喜悦和兴奋会激励你继续你的项目分享努力。

事实上，反复使用新发现的知识的过程也有助于巩固它，这样随着时间的推移，你最终会掌握它。俗话说得好，熟能生巧！

9.时间管理

尽管如此，我总是以完成而不是完美为目标。在我看来，完美是我们对作品的个人看法，可能是真的，也可能不是。例如，今天对我们来说似乎完美的东西，5 年后对我们来说可能是平庸的。

我总是喜欢这样想。假设我们有一周的时间来完成任务。可能需要 20%的时间来达到 80%的完美，而剩下的 80%的时间来完成任务。回到过去，我会追求完美，用额外的 80%的时间做些琐碎的调整。

当然，偶尔你会想花额外的时间来创造一个杰作，但并不是所有的任务都必须是杰作。

为什么？

因为根据我自己的经验，这可能会导致拖延症，也可能会导致倦怠。由于时间是有限的，我们必须充分利用时间。要学的和要做的事情实在太多了，因此我们不能陷入困境或停留在一个特定的主题上(只知道足够完成任务并继续前进)。

结论

总之，我们探索了一些自学者可以用来学习数据科学的学习资源。特别是，我们已经了解了一些免费和付费资源以及每种资源的独特优势和弱点，同时还分享了我的一些经验和技巧，介绍如何在学习和实施数据科学时最佳地利用这些资源。

公开

• 这篇文章中可能有附属链接，我可能会从合格的购买中获得，这将有助于未来内容的创建。

接下来读这些

• 数据科学如何掌握 Python
  下面是数据科学需要的必备 Python
• 如何掌握数据科学的熊猫
  下面是数据科学需要的必备熊猫
• 如何用 Python 构建 AutoML 应用
  使用 Streamlit 库的分步教程
• 学习数据科学的策略
  打入数据科学的实用建议
• 如何免费搭建一个简单的作品集网站
  不到 10 分钟从头开始的分步教程

✉️ 订阅我的邮件列表，获取我在数据科学方面的最佳更新(偶尔还有免费内容)!

关于我

我是泰国一所研究型大学的生物信息学副教授和数据挖掘和生物医学信息学负责人。在我下班后的时间里，我是一名 YouTuber(又名数据教授)制作关于数据科学的在线视频。在我做的所有教程视频中，我也在 GitHub 上分享 Jupyter 笔记本(数据教授 GitHub 页面)。

*https://www.youtube.com/dataprofessor

在社交网络上与我联系

✅YouTube:http://youtube.com/dataprofessor/
♇网站:http://dataprofessor.org/(在建)
♇LinkedIn:https://www.linkedin.com/company/dataprofessor/
♇Twitter:https://twitter.com/thedataprof
♇Facebook:http://facebook.com/dataprofessor/
♇github:https://github.com/dataprofessor/
ϝInstagram:】*

粉碎你的数据带回家面试的 12 个策略

原文：https://towardsdatascience.com/how-to-crush-your-data-take-home-interview-a0b9f7c97d6?source=collection_archive---------9-----------------------

揭开数据面试中最令人沮丧的一步

采访模因，公共领域

T 对于试图获得数据科学或分析工作的人来说，最令人沮丧的事情莫过于花 10 个小时纠结于一项带回家的任务——进行详尽的分析、创建可解释的可视化、训练模型等。—只是收到一封固定的拒绝邮件，当你要求对你的工作进行反馈时，却碰了壁。

像许多渴望从事数据工作的人一样，我对这种经历并不陌生。

不管是好是坏，带回家的作业是许多公司数据角色面试过程中不可或缺的一部分。它们可能非常模糊，几乎总是比公司要求的花费更多的时间来完成一项彻底的工作，并且不提供你在工作中会有的工具(用于数据清理/处理的帮助功能，用于更快和更强大的可视化的可视化工具，如 Tableau/Looker/Mode Analytics)。

然而，带回家的作业可以创造公平的竞争环境，因为对你的评估是基于你的工作成果，而不是你的背景。对于缺乏经验的人来说，这是一个让自己与众不同并展示技能的好机会。

在我做这些带回家的任务的 4 年里，**我已经把我的带回家→现场转换提高到 90%以上，而没有全职工作经验。**这篇文章的其余部分介绍了一些策略，这些策略对我完成这些任务并参加现场面试非常有效，我希望你也能发现它们的价值。

2 种带回家的数据

在深入探讨特定策略之前，我想区分两种带回家的作业——分析带回家的作业和机器学习带回家的作业。

顾名思义，分析带回家侧重于分析。通常，会给你一些不同的数据表(销售数据、产品使用数据等。)你必须弄清楚如何按摩和连接在一起。这些带回家的问题中有许多是根本原因分析问题，其中某个特定指标呈上升或下降趋势，要求您解释是什么推动了这种变化。根本原因问题也可能有一个统计显著性成分，在这里你被要求证明趋势是否是公司应该关注的事情。

偶尔，你会接到一个更具体的任务，比如计算一个特定的指标(从免费产品到付费产品的转化，流失，NPS，等等。)，随着时间的推移对其进行跟踪，并对您的发现进行评论。

另一方面，机器学习带回家需要你应用机器学习来解决一个特定的问题。在这些面试中，你会花很多时间思考特征工程、模型选择、超参数调整和评估。可能会有一些评估指标作为基准(例如，80%的准确率、65%的 F1 分数等。)，但通常不会告诉你什么是“好的表现”。

分析带回家的小贴士

通过分析带回家，**你的目标是进行彻底的分析，为公司提供具体的建议。**你越容易让评分者了解你的思考过程并理解你的结果，你就越有可能表现出色并进入现场面试。以下策略帮助我不断将分析带回家转化为现场分析:

1.花时间理解和清理数据

虽然深入研究并开始将表连接在一起可能很有诱惑力，但退一步花时间理解数据是至关重要的。在浏览数据时，请记住以下几点:

标识符列

• 应该是主键的列实际上是唯一的吗？如果不是，您将如何处理重复值(保留第一个值，保留最后一个值，等等)。)?

数字列

分类列

• 计算每个类别的频率。最常见/最不常见的类别是什么？
• 有没有可以通过一些简单的文本操作合并在一起的类别(例如，相同的类别名称但不同的大小写，清晰的错别字)？
• 在问题的上下文中，是否存在没有意义的值(例如，当您知道所有订单都应该来自美国时，来自俄罗斯的订单)？
• 是否存在缺失值？处理丢失的数据本身可能是一整篇文章，但是这篇文章是一个关于如何思考这个问题的很好的资源。

时间戳列

• 时间序列中是否有间隔(例如，错过一整天或多天，数量少得惊人的几天)？
• 是否存在缺失值？处理丢失的数据本身可能是一整篇文章，但是这篇文章是如何思考这个问题的好资源。

自由文本栏目

有时这些列只是元数据(url、产品描述等。)，但它们也可能包含有价值的信息(如客户反馈)。如果一个专栏似乎有助于你的分析，你可以用它来寻找支持你的发现的轶事和/或创建额外的专栏(文本长度，某些关键词的出现/频率等。)在你的分析中探索。

加盟表

一旦您清理了数据并需要将表合并在一起，您将需要非常仔细地考虑连接类型。在连接两个表之前，考虑一下输出应该是什么样子(例如，用户应该有一个订单还是多个订单？是否应该包括没有订单的用户？).如果您在连接数据之前已经考虑了输出应该是什么样子，那么您可以验证结果是否符合您的预期，并在必要时调试您的代码。

2.系统地寻找根本原因

对于根本原因分析，您可以通过检查特定指标的输入来系统地深入问题。

举个具体的例子，让我们假设你正在调查最近的销售下滑。首先，我们要确定销售的组成部分。

总销售额=订单数量*平均订单价值

如果我们计算每日订单数量和每日平均订单价值，我们可以确定哪些组件导致了下降(可能是一个或两个)。如果您想更严格一点，您可以绘制不同的订单值百分比(第 10、25、50、75、90、95 等。)而不仅仅是平均订单值。

然后，对于正在下降的总销售额的输入，我们要确定它们的输入。

如果订单数量减少，我们需要计算每日访客数量以及从访客到订单的每日转换率，因为订单数量=访客数量*订购的访客百分比(假设每位访客最多 1 个订单)。

如果平均订单价值下降，我们将需要计算每天每个订单的商品数量和每天平均订购商品价格，因为平均订单价值=每个订单的商品数量*购物车中商品的平均价格。

使用这种递归方法，**我们继续向下钻取下降的指标，直到所提供的数据不允许进一步探索。**例如，如果我们只知道订单的价值，而不知道内容，那么我们将无法分析平均订单价值的输入，并可能停止探索该路径。

3.线段，线段，线段

细分是开启分析洞察力的关键。分段的目标是沿着某个维度分割您的数据，以便您可以评估不同组之间的绩效。在产品分析设置中，一些常见的细分包括免费与付费用户、设备类型(桌面 web 与移动 web 与原生应用程序)、流量来源(来自搜索引擎的人、付费营销、直接在浏览器中键入您公司的 URL 的人，等等。)，以及星期几。

我倾向于尝试许多可能的细分，看看什么提供有趣的结果。如果您不确定从哪里开始，分类列是分段的良好候选。有时，你会想过滤掉低容量的类别，或者将它们归入“其他”类别，以消除可视化中的混乱。

您还可以从数字列创建布尔列(例如，如果用户在周末有活动，用户是否花费了超过$50)，或者通过创建不同的存储桶来离散化列(例如，时间戳到早晨/下午/晚上，将值排序到$ 10–20、$ 20–30、$30+的存储桶)。

4.策划一切

虽然仅通过查看表格就可以诊断根本原因或分析细分，但是将您的发现直观地传达给其他人要容易得多。无论您是计算一段时间内指标的价值、比较不同细分市场的指标，还是进行任何其他分析，花点时间将数据可视化都会让给你的带回家的东西评分的人更容易理解你的发现。

机器学习的小技巧带回家

有了机器学习带回家，**你的目标是展示你对解决问题的机器学习技术的理解。**根据我的经验，我发现让你的假设变得清晰并能够证明你所做的决定比你的模型的性能更重要。以下是我将机器学习带回家转化为现场面试的技巧。

1.花时间理解和清理数据

类似于带回家的分析，花时间理解你正在处理的数据集是值得的，并且应该提高你的结果的质量。在浏览数据时，请记住以下几点:

标识符列

您可能希望从模型中排除这些要素，因为标识符本身并不对信息进行编码，并且可能会被模型用来记忆标签，这不会推广到看不见的数据。

您可能需要标识符来将表连接在一起并形成您的初始数据集，它们也可以用于功能工程(例如，该用户有多少次活动/购买)，但它们对于模型训练或评估来说应该不是必需的。

数字列

• 绘制列值的直方图以检查分布。分布是什么样的？在值的范围非常大的情况下，进行对数变换可能是有意义的，这样模型权重就不会太大，尤其是对于线性或逻辑回归模型。
• 有离群值吗？对于 ML 任务，我通常不会一开始就删除离群值，但是注意到它们的存在是很好的。训练基线模型后，您可以尝试移除异常值并比较模型性能。
• 在问题的上下文中，是否存在没有意义的值(例如，一个 12 英尺高的人，在某些情况下为负$金额)？您可能希望从数据集中删除这些行。
• 是否存在缺失值？处理丢失的数据本身可能是一整篇文章，但是这篇文章是如何思考这个问题的好资源。
• 特性是如何相互关联的？您可能希望删除高度相关的要素以避免共线性问题，尤其是对于线性或逻辑回归模型。

分类栏

时间戳列

• 时间序列中是否有间隔(例如，错过一整天/多天，数量少得惊人的几天)？
• 是否存在缺失值？处理丢失的数据本身可能是一整篇文章，但是这篇文章是一个关于如何思考这个问题的很好的资源。

自由文本栏

有时这些列只是元数据(url、产品描述等。)，但其他时候他们可能会有有价值的信息(如客户反馈)。如果一个列似乎包含对您的预测任务有价值的信息，您可以从中生成特征(文本长度、某些关键字的外观/频率等。).

2.从简单开始

我总是从拟合一个简单的可解释的模型开始——线性回归用于回归任务，逻辑回归用于分类任务。这些模型训练速度非常快，不需要太多调整，这使您能够快速迭代特性。

我首先在所有特征上拟合一个模型。然后，通过检查系数的大小，我衡量了特征的相对重要性，并尝试删除系数非常小的特征。线性回归对异常值特别敏感，因此如果基线模型似乎不能很好地拟合数据，您可能需要移除异常值。

在进入更复杂的模型之前，我总是试图通过移除无信息的特征并创建新的特征来改善基线结果。如果基线模型过度适合训练数据，可以尝试的另一种方法是正则化。

3.尝试使用更复杂的模型来提高性能

在你完成了一些功能工程以尝试和改善基线模型结果之后，尝试一个更复杂的模型可以帮助你提高预测任务的性能，同时也突出了合理的机器学习实践的知识。

通常，对于更复杂的模型，我使用随机森林或 XGBoost，并使用在基线模型上产生最佳性能的特性集。这些模型有更多的超参数，这让您有机会展示对超参数调整的理解。

考虑到带回家的时间限制，我对一些关键参数进行了简单的网格搜索。对于随机森林，我调整的参数是树的数量、特征的最大数量、深度、叶子中样本的最小数量以及分割节点的样本的最小数量。如果您的模型过度拟合，减少树深度、一个叶中的最小样本数和分割一个节点的最小样本数应该会产生正则化效果。

在非常不平衡的数据集的情况下，我发现修改类权重以给予少数类更多权重是有用的，因为否则模型可能总是预测多数类。

4.更深入地了解模型性能

由于你想展示对整个建模过程的理解，花几分钟深入挖掘模型性能将有助于你脱颖而出，因为大多数人止步于性能指标(准确度、精确度、召回率等)。).对于分类任务，简单地为您的基线模型和更复杂的模型绘制一个混淆矩阵，并对您观察到的差异进行评论，应该足以显示您的思维过程，而不会花费大量时间。对于回归任务，评论每个模型的哪些特性是最重要的，这是显示对模型能力的更深层次理解的一种简单方式。

一般提示

1.花时间彻底地做好准备工作

虽然招聘人员或招聘经理经常会告诉你不要花超过 4 或 6 个小时的时间，但我往往会花超过建议的时间，尤其是对我真正感兴趣的公司。由于评分者没有真正的方法来验证你花了多少时间，其他申请人可能会花更多的时间，如果你花的时间比竞争对手少得多，你的工作就很难脱颖而出。最终，结果比解释给你更多的时间你会做什么更令人印象深刻，尽管评分者最大的意图是不惩罚不完整的分析。

2。使用 Markdown 记录你的思考过程

理想情况下，你有机会向评分者讲述你的思考过程，但这种情况很少出现在带回家的作业中。所以，你要尽你所能，让评分者在评估你的作业时，能容易地跟上你的思维过程。如果你用的是 Jupyter 笔记本，我发现一个非常有效的方法是在相关代码之前或之后添加标记单元格来记录假设和结论。如果您没有添加 markdown 的能力，在代码中注释假设和结论是一种替代方法，尽管可读性较差。

3.即使不需要，也要做一个演示

你可以做的另一件事是制作一个简短的幻灯片来总结你的作业，让你的评分者评估你的课后作业变得非常容易。演示可以让你更好地控制评分者的叙述，让他们的注意力集中在最重要的发现上。在这里，内容比审美更重要——15 分钟应该足以完成演示。我的演讲结构如下:

• 简单介绍一下问题
• 流程概述(数据清理和探索、分析或模型)
• 突出显示主要结果
• 建议/结论/未来的工作

并不是你笔记本里的所有代码或可视化效果都会产生有意义的结果，但是你会希望保留它们以向评分者展示你所探索的事物的广度。有一个单独的演示文稿可以避免用不相关的结果分散评分者的注意力，同时让您可以保留所有的笔记本代码。

4.回顾性创建辅助函数

为了更有效地完成未来的接收任务，我建议在提交接收任务后检查一下，找出可能对其他接收任务有益的代码片段(数据清理、生成图、创建分段等)。).这确实需要一些前期投资，但是将这些代码片段重写为您可以重用的通用函数，可以大大减少您在将来的任务中实现类似质量所需的时间。

结论

数据面试的带回家作业可能是一件痛苦的事，但对许多公司来说，在这个过程中，它们是一种不可避免的罪恶。我希望这有助于揭开传统黑箱作业的神秘面纱，我也很想听听其他在这些作业中对你很有效的策略。

如何使用 Fargate Spot 和 Prefect 降低您的 AWS ECS 成本

Python 中的无服务器数据工程管道

照片由 Kampus 出品来自 Pexels

P refect 是一个灵活的工具，用于编排现代数据堆栈。与市场上的许多其他解决方案相比，它不会将您束缚于任何特定的执行框架或云提供商——无论您是想使用 GCP 上的Kubernetes、 AWS ECS 、裸机服务器，还是诸如 Coiled 的按需分布式 Dask 集群，Prefect 都能满足您的需求。与任何灵活的平台一样，您需要配置一些东西来让 Prefect 知道您的数据工作流应该在哪里运行。在本文中，我们将研究如何利用 AWS ECS Fargate 上的 spot 实例作为您的经济高效的执行层。

**Table of contents**· [Spot instances & Prefect](#2587)
  ∘ [Why spot instances?](#0e6b)
  ∘ [What value does Prefect provide in managing containers deployed to spot instances?](#5281)
· [Architecture](#a7fb)
· [Prefect Setup](#af91)
  ∘ [Sign up or sign in](#e80f)
  ∘ [Create an API Key](#55d2)
  ∘ [Install Prefect](#98be)
  ∘ [Create a service account for the ECSAgent](#f88c)
· [AWS Setup](#3338)
  ∘ [Store the ECSAgent’s API Key as an encrypted parameter](#7f59)
  ∘ [Configure the ECS cluster](#ad64)
  ∘ [Prepare the IAM roles](#4ba7)
  ∘ [Task execution role](#43f9)
  ∘ [Task role](#6f39)
  ∘ [Create a CloudWatch log group](#d836)
  ∘ [Register a task definition for the ECSAgent](#bb0c)
  ∘ [Look up your subnet IDs](#1fd5)
  ∘ [Start a continuously running ECS Service for the ECSAgent](#566f)
  ∘ [Validate the agent setup in the Prefect UI](#29bd)
· [Deploy an example Prefect flow](#5b72)
  ∘ [Build a custom Docker image for your Prefect flows](#1e8c)
· [Conclusion](#a041)

Spot 实例和完美

为什么点实例？

首先，为什么首先要使用 spot 实例呢？原因很简单:节约成本。即时实例的成本比按需实例低 70%。

Prefect 在管理部署到 spot 实例的容器方面提供了什么价值？

虽然 spot 实例可以节省大量成本，但它们有一个明显的缺点:它们可以在两分钟的通知后关闭。提督有助于克服这一缺点，因为:

• 它提供了可见性，其中作业由于 spot 实例关闭而失败，
• 由于名为 Lazarus 的服务，它可以自动重启此类失败的工作流。正如提督文献所解释的:

“Lazarus 流程旨在优雅地重试由 Prefect 无法控制的因素导致的故障。最常见的需要 Lazarus 干预的情况是基础设施问题，例如 Kubernetes pods 在能够完成一次运行之前无法运行或被删除。

• 提督自动化许多繁琐的任务，否则你将不得不做部署你的工作负载到 ECS，如创建和注册新的任务定义，注销旧的任务定义，等等。
• 提督也允许你直接从提督用户界面修改“运行 ECS 任务”的元数据。这样，您可以在特定的每次运行的基础上调整工作流所需的资源，如 CPU 和内存。

体系结构

在您的 AWS 帐户中，您创建了一个带有perfect ECS agent流程的 ECS 服务。这个过程不断地轮询 Prefect Cloud API 以获得新的流运行。然后，当注入您为每个特定运行(例如，CPU、内存)提供的元数据时，Prefect 会自动将计划的流运行部署为 ECS 任务。 ECS 控制平面负责提供基础设施并将集装箱放置在 ECS 数据平面上。

在本文中，我们将重点关注使用 Fargate 作为您的数据平面，ECS 允许您为每个 ECS 集群添加多达六个容量提供者。这样，您的 ECS 数据层可以同时使用FARGATE_SPOT、FARGATE、EXTERNAL本地服务器和自我管理的定制EC2实例，可能使用 GPU。容量提供程序允许您定制群集资源，以满足您期望的延迟、维护和容量需求。

完美设置

注册或登录

如果您还没有帐户，注册一个“标准”的提督云帐户。虽然也有一个“入门”选项，但标准版有更多的功能。这两个计划都有一个非常慷慨的 10，000 次免费成功任务运行的等级。你可以在这里找到更多关于那个的信息。

创建 API 密钥

一旦登录，您就可以创建一个 API 密匙来使用 Prefect Cloud 验证您的本地开发环境。

完美的云用户界面——作者图片

安装提督

要在本地计算机上安装带有 AWS 子模块的提督，请使用:

pip install "prefect[aws]"

然后，您可以切换到 Prefect Cloud 后端，并使用您之前生成的 API 密钥进行身份验证:

prefect backend cloud
prefect auth login --key **<**YOUR-API-KEY**>**

成功认证后，您现在可以注册新的流，启动新的代理，并在 Prefect Cloud UI 中查看它们。

**注意:**旧版本的提督使用的 API 令牌对代理和用户有不同的作用域。从 0.15.0 开始，你应该使用 API 键。如果你想知道更多，这篇博文解释了这一变化的原因。

为 ECSAgent 创建服务帐户 API 密钥

虽然 API 密匙是为认证用户而设计的，但服务帐户 API 密匙是为机器而设计的，即自动化过程，如完美代理和 CI/CD 工具。要为 ECSAgent 创建新密钥，请转到团队的服务帐户页面。

AWS 设置

下面演示的整个设置可以在 this GitHub Gist 中找到，作为一个 bash 脚本，您可以调整并运行它:

bash prefect_ecs_agent_deploy_script.bash

在运行它之前，您需要用您的帐户 ID 替换AWS_ACCOUNT_ID,并设置其他变量，如代码注释中所述。

在接下来的小节中，我们将从要点开始逐步介绍所有步骤，以便您理解创建了哪些资源，以及如何根据您的用例调整这个脚本。

将 ECSAgent 的 API 密钥存储为加密参数

为了在我们的 AWS ECS 服务中安全地访问先前创建的服务帐户的 API 密钥，我们希望将它作为加密的秘密存储在 AWS 系统管理器参数存储中。确保设置您的 AWS 区域、API 键，并调整其他变量:

*export* AWS_REGION=us-east-1
*export* ECS_CLUSTER_NAME=prefectEcsCluster
*export* ECS_LOG_GROUP_NAME=/ecs/prefectEcsAgent
*export* ECS_SERVICE_NAME=prefectECSAgent
*export* PREFECT_API_KEY=yourPrefectCloudAPIKey
*export* AWS_PAGER=""aws ssm put-parameter --type SecureString --name PREFECT__CLOUD__API_KEY --value $PREFECT_API_KEY --region $AWS_REGION

AWS_PAGER变量被设置为禁用 AWS CLI 的分页输出。

配置 ECS 群集

*aws* ecs create-cluster --cluster-name $ECS_CLUSTER_NAME \
--capacity-providers FARGATE_SPOT FARGATE \
--default-capacity-provider-strategy \
capacityProvider=FARGATE_SPOT,weight=3 \
capacityProvider=FARGATE,base=1,weight=2 \
--region $AWS_REGION

我们设置了base=1,因为至少 ECSAgent 进程的一个 ECS 任务将作为 ECS 服务全天候运行。由于该服务必须始终运行以实现健壮的调度，因此为该流程使用 spot 实例没有意义。

通过利用权重，我们指定了FARGATE_SPOT和FARGATE之间的比率，这意味着我们 60%的流量将被部署到FARGATE_SPOT，40%将在FARGATE容量提供商上运行。你应该根据你的需要调整这个比例。

请注意，FARGATE_SPOT应该仅用于可中断的工作负载，例如常规(例如每小时)批处理作业。如果您喜欢标准的 Fargate 集群，请使用:

*aws* ecs create-cluster --cluster-name $ECS_CLUSTER_NAME \
--region $AWS_REGION

准备 IAM 角色

AWS 区分了任务执行角色(授予启动任务中定义的容器的访问权限的一般角色)和任务角色，后者在容器启动后授予实际应用程序权限。您可以在本文的第 4 部分找到更详细的解释:

任务执行角色

#1.创建承担信任策略的角色:

*cat* <<EOF *>ecs_tasks_trust_policy.json* {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "ecs-tasks.amazonaws.com"
        ]
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
EOF

*aws* iam create-role --role-name prefectECSAgentTaskExecutionRole \
--assume-role-policy-document file://ecs_tasks_trust_policy.json --region $AWS_REGION

#2.附加一般服务角色策略AmazonECSTaskExecutionRolePolicy:

*aws* iam attach-role-policy --role-name prefectECSAgentTaskExecutionRole \
--policy-arn "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"

#3.附加我们的自定义角色策略，因为 ECS 任务将需要从任务环境变量中的 AWS 系统管理器参数存储中检索 API 密匙。

*cat* <<EOF *>ecs_tasks_execution_role.json* {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ssm:GetParameters"
      ],
      "Resource": "*"
    }
  ]
}
EOF

*aws* iam put-role-policy --role-name prefectECSAgentTaskExecutionRole \
--policy-name prefectECSAgentTaskExecutionRolePolicy \
--policy-document file://ecs_tasks_execution_role.json

请注意，您可以将范围缩小到我们需要的特定秘密，而不是"Resource": “*":

"Resource": "arn:aws:ssm:YOUR_REGION:YOUR_AWS_ACCOUNT_ID:parameter/PREFECT__CLOUD__API_KEY"

任务角色

该角色需要授予对 AWS 资源的完全访问权限，如 CloudWatch、EC2、ECS、IAM、S3 等。对于每次流运行，Prefect 都会创建一个新的 ECS 任务定义。在这样做的时候，它需要为一个流检索关于您的 VPC、子网、安全组和 IAM 权限的信息。此外，必须授权 it 部门创建新的 CloudWatch 日志流，并为每次流运行放置日志。下面的策略描述了必要的权限:

*# permissions needed by Prefect to register new task definitions, deregister old ones, and create new flow runs as ECS tasks**cat* <<EOF *>ecs_task_role.json* {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ec2:AuthorizeSecurityGroupIngress",
                "ec2:CreateSecurityGroup",
                "ec2:CreateTags",
                "ec2:DescribeNetworkInterfaces",
                "ec2:DescribeSecurityGroups",
                "ec2:DescribeSubnets",
                "ec2:DescribeVpcs",
                "ec2:DeleteSecurityGroup",
                "ecs:CreateCluster",
                "ecs:DeleteCluster",
                "ecs:DeregisterTaskDefinition",
                "ecs:DescribeClusters",
                "ecs:DescribeTaskDefinition",
                "ecs:DescribeTasks",
                "ecs:ListAccountSettings",
                "ecs:ListClusters",
                "ecs:ListTaskDefinitions",
                "ecs:RegisterTaskDefinition",
                "ecs:RunTask",
                "ecs:StopTask",
                "iam:PassRole",
                "logs:CreateLogStream",
                "logs:PutLogEvents",
                "logs:DescribeLogGroups",
                "logs:GetLogEvents"
            ],
            "Resource": "*"
        }
    ]
}
EOF*aws* iam create-role --role-name prefectTaskRole --assume-role-policy-document file://ecs_tasks_trust_policy.json --region $AWS_REGION*aws* iam put-role-policy --role-name prefectTaskRole --policy-name prefectTaskRolePolicy --policy-document file://ecs_task_role.json

**注意:**上面提到的一些权限被定义为允许在 ECS 上启动临时 Dask 集群。如果你想把范围缩小到绝对必要的提督标准权限，这个 Github 问题可以帮到你。

当使用带有 AWS ECS 的提督时，您可能希望使用 S3 作为提督存储和结果后端。因此，向任务角色添加 S3 权限是可行的。以下是如何创建允许对特定 S3 时段执行任何操作的任务角色。

*# adjust it to include permissions needed by your flows
cat* <<EOF *>ecs_task_role_s3.json* {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:*"
      ],
      "Resource": "arn:aws:s3:::*prefect*"
    }
  ]
}
EOF*aws* iam put-role-policy --role-name prefectTaskRole --policy-name prefectTaskRoleS3Policy --policy-document file://ecs_task_role_s3.json

上述策略授予对名称中包含单词“prefect”的 S3 存储桶执行任何操作的访问权限 —为了提高安全性，您可以指定想要与 Prefect 一起使用的确切的 S3 存储桶名称。

创建云观察日志组

在执行期间，每个 ECS 任务将容器日志发送到 CloudWatch 日志流。日志流被分成日志组。为了让 ECS 任务发送这些容器日志，我们需要创建日志组并在任务定义中指定它。

aws logs create-log-group --log-group-name $ECS_LOG_GROUP_NAME --region $AWS_REGION

为 ECSAgent 注册任务定义

我们最终可以为我们的总监的 ECSAgent 流程注册任务定义。

*# search-replace the AWS_ACCOUNT_ID below with your AWS account ID. Also, replace or add ECS Agent labels**cat* <<EOF *>prefect_ecs_agent_task_definition.json* {
    "family": "$ECS_SERVICE_NAME",
    "requiresCompatibilities": [
        "FARGATE"
    ],
    "networkMode": "awsvpc",
    "cpu": "512",
    "memory": "1024",
    "taskRoleArn": "arn:aws:iam::AWS_ACCOUNT_ID:role/prefectTaskRole",
    "executionRoleArn": "arn:aws:iam::AWS_ACCOUNT_ID:role/prefectECSAgentTaskExecutionRole",
    "containerDefinitions": [
        {
            "name": "$ECS_SERVICE_NAME",
            "image": "prefecthq/prefect:latest-python3.8",
            "essential": true,
            "command": [
                "prefect",
                "agent",
                "ecs",
                "start"
            ],
            "environment": [
                {
                    "name": "PREFECT__CLOUD__AGENT__LABELS",
                    "value": "['prod']"
                },
                {
                    "name": "PREFECT__CLOUD__AGENT__LEVEL",
                    "value": "INFO"
                },
                {
                    "name": "PREFECT__CLOUD__API",
                    "value": "https://api.prefect.io"
                }
            ],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-group": "$ECS_LOG_GROUP_NAME",
                    "awslogs-region": "$AWS_REGION",
                    "awslogs-stream-prefix": "ecs",
                    "awslogs-create-group": "true"
                }
            },
            "secrets": [
                {
                    "name": "PREFECT__CLOUD__API_KEY",
                    "valueFrom": "arn:aws:ssm:$AWS_REGION:AWS_ACCOUNT_ID:parameter/PREFECT__CLOUD__API_KEY"
                }
            ]
        }
    ]
}
EOF

*aws* ecs register-task-definition --cli-input-json file://prefect_ecs_agent_task_definition.json --region $AWS_REGION

查找您的子网 id

要将此 ECS 任务作为连续运行的服务运行，我们必须选择此任务应在其中运行的 VPC 和子网。在本演示中，我们将使用默认 VPC 及其对应的公共子网。每个地区都有默认的 VPC，所以除非需要，否则不必创建任何新的 VPC。

以下是您如何查找所选地区的 id:

或者，您可以从 AWS CLI 中查找这些 id:

aws ec2 describe-subnets --region $AWS_REGION

为了方便起见，下面是如何提取 id 并将它们导出为环境变量的方法——我们将在下一节中使用它们:

export VPC=$(aws ec2 describe-vpcs --filters Name=is-default,Values=true)export VPC_ID=$(echo $VPC | jq -r '.Vpcs | .[0].VpcId')SUBNETS=$*(aws* ec2 describe-subnets --filters Name=vpc-id,Values=$VPC_ID --region $AWS_REGION*)**export* SUBNET1=$*(echo* $SUBNETS | *jq* -r '.Subnets | .[0].SubnetId'*)
export* SUBNET2=$*(echo* $SUBNETS | *jq* -r '.Subnets | .[1].SubnetId'*)
export* SUBNET3=$*(echo* $SUBNETS | *jq* -r '.Subnets | .[2].SubnetId'*)*

为 ECSAgent 启动持续运行的 ECS 服务

此服务的好处是，ECS 控制面板将确保此过程始终运行。如果出现问题，ECS 将为我们的完美代理创建一个新的容器。

*aws* ecs create-service \
    --service-name $ECS_SERVICE_NAME\
    --task-definition $ECS_SERVICE_NAME:1 \
    --desired-count 1 \
    --launch-type FARGATE \
    --platform-version LATEST \
    --cluster $ECS_CLUSTER_NAME \
    --network-configuration awsvpcConfiguration="{subnets=[$SUBNET1, $SUBNET2, $SUBNET3],assignPublicIp=ENABLED}" --region $AWS_REGION

在完美用户界面中验证代理设置

如果一切按预期运行，我们应该看到一个新的 ECSAgent 准备好部署新的流运行。

完美代理页面-按作者分类的图片

部署一个示例完美流

如果您还没有任何完美的项目，您可以从 CLI 创建它:

prefect create project “ECS_Flows”

现在，您可以使用 ECSRun 部署一个示例流，它将为 ECS 任务提供元数据，例如:

• 自定义容器image，
• ECS 代理labels，
• 为您的流定制 AWS 权限，以task_role_arn的形式提供，
• 还有cpu和memory。

注意，在这个流中，我们还指定了S3存储——这将把流文件上传到指定的 S3 存储桶。

确保用您的 AWS 帐户 ID 替换123456。

此外，如果您向您的ECSRun提供一个定制的 ECR 映像，请确保也显式地指定execution_role_arn，否则，您将得到一个 ClientException，告诉您 Fargate 需要任务定义具有执行角色 ARN 来支持 ECR 映像。您可以这样指定:

RUN_CONFIG = ECSRun(
    labels=["prod"],
    task_role_arn="arn:aws:iam::XXX:role/prefectTaskRole",
    execution_role_arn="arn:aws:iam::XXX:role/prefectECSAgentTaskExecutionRole",
    run_task_kwargs=dict(cluster="prefectEcsCluster", launchType="FARGATE",),
    image="XXX.dkr.ecr.us-east-1.amazonaws.com/prefect-custom-image:latest"
)

为您的完美流程构建一个定制的 Docker 映像

如果您的流需要定制的包依赖项，比如pandas或scikit-learn，那么创建一个已经包含这些依赖项的定制容器映像被认为是最佳实践。以下是你如何做到这一点。

cat <<EOF >Dockerfile
FROM prefecthq/prefect:latest-python3.9
RUN pip install --upgrade pip \\
&& pip install pandas scikit-learn boto3
EOF

然后，要构建 Docker 映像并将其推送到 ECR，请使用:

export AWS_REGION=us-east-1
export AWS_ACCOUNT_ID=123456789
export IMAGE_NAME=prefect-custom-image
export IMAGE_TAG=latest

docker build -t $IMAGE_NAME .aws ecr create-repository --repository-name $IMAGE_NAME --region $AWS_REGIONdocker tag "$IMAGE_NAME":"$IMAGE_TAG" "$AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/$IMAGE_NAME":"$IMAGE_TAG"aws ecr get-login-password | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.comdocker push "$AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/$IMAGE_NAME":"$IMAGE_TAG"

现在您可以在您的ECSRun 运行配置中指定这个映像(流程要点中的第 14 行)。

结论

在本文中，我们研究了如何将 AWS ECS Fargate 设置为完美代理。我们调查了各种容量提供商配置以优化成本，并解释了根据您的需求定制此设置所需的所有步骤。

资源:

• https://AWS . Amazon . com/blogs/AWS/AWS-fargate-spot-now-generally-available/
• Fargate spot —成本节约演示:https://Tom Gregory . com/AWS-fargate-spot-vs-fargate-price-comparison/
• 深潜:https://AWS . Amazon . com/blogs/compute/deep-dive-into-fargate-spot-to-run-your-ECS-tasks-for-up-to-70-less/
• https://ecsworkshop.com/capacity_providers/fargate/

物流和仓储中的数据分析

原文：https://towardsdatascience.com/how-to-data-analysis-in-logistics-and-warehousing-4ceaa276d5d4?source=collection_archive---------17-----------------------

如何开始物流和仓储领域的分析

由 Timelab Pro 在 Unsplash 上拍摄的照片

在物流和仓储领域，当然有很多软件可以帮助你优化路线、仓库利用率和供应链管理。但是这方面的基本 KPI 是什么呢？无论您是数据科学家、分析师还是业务分析师，了解各个部门的实际工作都很有用。他们的目标是什么？他们是如何直接或间接挣钱的？如何衡量成功？这些问题及其各自的答案帮助我了解了各个部门的关键数字。

数据来源

第一个问题当然是从哪里获得可能的 KPI 数据和进一步的分析。通常，此类数据的来源有:

• ERP 系统
• 订单管理系统
• 材料管理系统
• 路线优化系统
• 而且几年以来 IOT 的传感器也越来越多

由于此类系统在数据量方面增长迅速，建议建立一个可靠的数据平台—点击此处了解更多信息。

为什么这个领域的重要性会增加

尤其是在科罗纳疫情时代，我们看到了拥有可靠供应链的重要性。为了监控和优化这些供应链，需要传感器和系统[1]。通过提供这些数据，可以定义重要的 KPI。只有通过这种方式，内部业务流程才变得可见和可衡量。各个领域只能通过这种方式进行优化，包括材料管理、仓储、运输、采购等。—供应链得到优化。

KPI

这是我在这个领域遇到的一些关键绩效指标。当然，这只是 KPI 的一小部分，但我认为其中一些是最重要的，因为它们经常出现在文献中。

你的供应商有多可靠？

• 供应商的可靠性=按时交付且状况良好的货物数量/货物总量
• 每周都有多批新货。

您的客户满意度如何？

• 顾客退货的好商品[2]。
• 客户退回损坏的物品[2]。
• 返回供应商库存。

马库斯·斯皮斯克在 Unsplash 上的照片

仓库 KPI

• 仓库利用率=占用面积/总面积
• 材料流出的总和
• 储存时间
• 存货成本率=存货成本/存货价值

运输关键绩效指标

• 准时交货[3]
• 每次运输成本

摘要

物流和仓储关键指标用于衡量公司的发展并实施适当的持续改进措施。这些数据、系数和百分比的收集为最终实现最高物流质量的决策提供了坚实的基础。为了更深入的探究，请使用下面的资源。

资料来源和进一步阅读

[1] B. Sai Subrahmanya Tejesh，S. Neeraja，使用物联网和开源框架的仓库库存管理系统(2018)，
亚历山大工程杂志，第 57 卷，第 4 期，

[3]新加坡采购与材料管理研究所，物流行业关键绩效指标 (2019)

机器学习中如何处理不平衡数据集

原文：https://towardsdatascience.com/how-to-deal-with-an-imbalanced-dataset-in-machine-learning-4f89a1967868?source=collection_archive---------24-----------------------

6 种不同的技术来解决你将面临的最常见的问题之一。

照片由陈伶俐·桑特兰在 Unsplash 上拍摄

不平衡的数据集是我们需要处理的一个常见问题，是每个机器学习面试问题集合中的一个主要部分。

让我们从一个例子开始:

假设你正在尝试建立一个分类模型，你有两个类:猫和狗。不幸的是，你的数据非常不准确:有 950 张猫图片和 50 张狗图片。

如果你的模型把每张图片都归类为猫(哑巴吧？)，你就 95%准确了！想一想。数据集中的分布很快成为一个大问题。

让我们试着解决这个问题。

1.确保您正确地描述了问题

在很多情况下，不均衡的班级可能会提供一个以不同的方式看待问题的机会。

制造缺陷、信用卡欺诈、垃圾邮件。这些问题属于同一类别:数据集中的绝大多数样本将代表正常类，只有少数异常代表不同类。

大多数时候，你最好将这些视为异常检测问题，你的主要目标是识别数据集中的异常值。

作为一个相关的提示，确保你使用正确的算法来解决你的问题。例如，基于决策树的模型在处理不平衡的类方面非常出色。当处理结构化数据时，这可能就是您所需要的。

2.在这些问题上，准确性不是最好的性能指标

当数据集不平衡时，精确度不是一个好的性能指标。

相反，根据您的具体问题，您应该查看以下内容:

• 精确度、召回率、F 值
• 混淆矩阵
• ROC 曲线

3.收集更多数据

我总是喜欢从这里开始。

在我们的例子中，我们也许能够找到更多的狗的图片添加到数据集中，并减少差异。

不幸的是，收集更多的数据并不总是一个选项。但有时确实如此，然而许多团队过早地诉诸合成增强。

4.用合成数据扩充数据集

只有当收集更多的数据不可行时，我才会去编造假样本。当处理非结构化数据(比如图像、视频、文本、音频)时，这是一个很好的方法。

例如，您可以通过转换现有的图片来创建新的狗图片:

• 改变图像的对比度
• 做水平翻转
• 向两个方向轻微旋转图片
• 添加一些噪声

结合这些技术可以产生许多看起来和原始图片一样真实的新样本。

对于结构化数据(想想表格数据)，扩充要困难得多，有时甚至不可能。

5.对数据集进行重新采样

有三种不同的方法可以对数据集进行重采样:

• 过采样:多次拍摄我们拥有的图片。
• 欠采样:取一些我们有的图片，丢弃其余的。
• 结合两种技术:对一个类进行过采样，同时对另一个类进行欠采样。

例如，我们可以通过以下方式对数据进行重新采样:

• 每张狗图片使用 4 次。这将以总共 400 张狗图片(50 张现有图片× 4)结束。)
• 使用每隔一张猫图片。这将导致总共 475 张猫图片(950 张现有图片÷ 2)。)

请记住，过采样和欠采样会给你的数据集带来偏差:你是在通过任意改变现有样本来改变数据分布。这可能会有后果，所以要仔细考虑。

6.适当调整每个类别的权重

训练样本的可选权重数组，用于加权损失函数(仅在训练期间)。)

成本敏感学习是另一种相关的技术，您也可以使用它根据每个类的权重来惩罚模型的结果。我写了一篇关于成本敏感学习的简短介绍，应该会有所帮助。

一锤定音

这些我一般都是按顺序想的。现在，系统地沿着这个清单往下走已经成了第二天性。

大多数情况下，需要不止一种技术来解决问题。每一次，实验都会告诉你正确的方法。

如何在 Python 中处理不平衡的多类数据集

原文：https://towardsdatascience.com/how-to-deal-with-imbalanced-multiclass-datasets-in-python-fe0bb3f2b669?source=collection_archive---------7-----------------------

数据预处理

这是一个现成的教程，介绍了用 imblearn 和 scikit-learn 平衡多类数据集的一些技巧

图片由 Gidon Pico 提供，来自 Pixabay

在运行机器学习模型时，不平衡的数据集通常会产生较差的性能，尽管在某些情况下，评估指标会产生良好的结果。这可能是因为该模型擅长预测多数阶级，但在预测少数阶级时性能较差。由于评估指标计算的是多数类和少数类之间的平均值，所以最终的性能看起来还可以。

多数类是指数据集中代表性最强的类，而少数类是指数据集中代表性较弱的类。换句话说，多数阶级比少数阶级有更多的样本。在这种情况下，数据集是不平衡的。

在大多数情况下，平衡可以提高模型的性能，尽管这并不总是正确的。

在本教程中，我处理多类数据集。多类数据集是指输出类的数量大于 2 的数据集。我提出两种策略来平衡多类数据集:

• 流水线欠采样和过采样
• 玩级重。

加载数据集

import pandas as pddf = pd.read_csv('glass.csv')
df.head()

作者图片

该数据集由 214 个样本和 7 个类别组成。

准备数据

我构建了两个变量，X和y，分别包含输入特征和输出类。为此，我计算输入特征，并将它们存储到一个名为features的变量中。

features = []
for feature in df.columns:
    if feature != 'target':
        features.append(feature)
X = df[features]
y = df['target']

通过利用由sklearn库提供的train_test_split()函数，将数据集分成两部分:训练集和测试集。我将测试集大小设置为0.2(即整个数据集的 20%)。

from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=100)

现在，我计算训练集中每个目标类的样本数。我利用了value_counts()函数。我注意到数据集是不平衡的。

平衡仅适用于训练集。

import matplotlib.pyplot as pltcount = y_train.value_counts()
count.plot.bar()
plt.ylabel('Number of records')
plt.xlabel('Target Class')
plt.show()

作者图片

建立不平衡模型

在平衡训练集之前，我计算了具有不平衡数据的模型的性能。我利用一个KNeighborsClassifier进行测试。我还从scikitplot库中导入了其他有用的函数，来绘制 ROC 和 precision recall 曲线。具体来说，首先我建立模型，然后我拟合训练集，最后我通过应用于测试集的predict_proba()函数计算模型的性能。

from sklearn.neighbors import KNeighborsClassifier
from scikitplot.metrics import plot_roc
from scikitplot.metrics import plot_precision_recallmodel = DecisionTreeClassifier()
model.fit(X_train, y_train)
y_score = model.predict_proba(X_test)
y_pred = model.predict(X_test)# Plot metrics 
plot_roc(y_test, y_score)
plt.show()

plot_precision_recall(y_test, y_score)
plt.show()

作者图片

作者图片

流水线欠采样和过采样

第一种策略涉及流水线的创建，该流水线对多数类进行欠采样，对少数类进行过采样。这里的要点是定义一个阈值，该阈值划分多数类和少数类，以及每个类所需的样本数。在这个特定示例中，我们将阈值设置为等于每个类别的期望样本数。

一种可能的解决方案是将阈值设置为类中样本数量的中值。因此，我可以将阈值设置为 19，并考虑样本数量大于阈值的多数 a 类。类似地，少数类是样本数量少于阈值的类。

我计算中间值，并将其转换为整数。

import numpy as np
n_samples = count.median().astype(np.int64)

现在我可以对最具代表性的类进行欠采样。首先，我禁止警告。

import warnings
warnings.filterwarnings('ignore')

然后，我定义一个效用函数，它接收数据集、阈值(n_samples)和相关类(majority或minority)作为输入。该函数返回一个dict,其中包含属于相关类的每个类的期望样本数。

def sampling_strategy(X,y,n_samples, t='majority'):
    target_classes = ''
    if t == 'majority':
        target_classes = y.value_counts() > n_samples
    elif t == 'minority':
        target_classes = y.value_counts() < n_samples
    tc = target_classes[target_classes == True].index
    #target_classes_all = y.value_counts().index
    sampling_strategy = {}
    for target in tc:
        sampling_strategy[target] = n_samples
    return sampling_strategy

现在我对大多数类进行欠采样。我利用了imblearn库。

from imblearn.under_sampling import ClusterCentroids
under_sampler = ClusterCentroids(sampling_strategy=sampling_strategy(X_train,y_train,n_samples,t='majority'))
X_under, y_under = under_sampler.fit_resample(X_train, y_train)

我注意到多数类中的记录数量被设置为n_samples。

作者图片

然后，我对较少表示的类进行过采样。我利用了SMOTE过采样策略。

from imblearn.over_sampling import SMOTE
over_sampler = SMOTE(sampling_strategy=sampling_strategy(X_under, y_under,n_samples, t='minority'),k_neighbors=2)
X_bal, y_bal = over_sampler.fit_resample(X_under, y_under)

最终我有了一个平衡的数据集。

作者图片

我在新的平衡数据集上训练模型，我注意到 ROC 曲线改善了，而精确召回曲线似乎降低了。然而，看看类别 3，在原始模型中的精确度和召回率低于平衡模型。这意味着该模型现在能够更好地预测少数民族阶层。

model = KNeighborsClassifier()
model.fit(X_bal, y_bal)
y_score = model.predict_proba(X_test)y_pred = model.predict(X_test)# Plot metrics 
plot_roc(y_test, y_score)
plt.show()

plot_precision_recall(y_test, y_score)
plt.show()

作者图片

作者图片

玩重量级游戏

平衡的替代方法是在构建模型时指定原始数据集中的类权重。这允许算法给予少数类更多的重要性。可以通过sklearn.utils库的 class_weight() 函数计算类权重。

from sklearn.utils import class_weightclasses = np.unique(y_train)
cw = class_weight.compute_class_weight('balanced', classes, y_train)
weights = dict(zip(classes,cw))

现在我可以将类权重作为输入提供给一个分类器，比如一个DecisionTreeClassifier，并计算模型的性能。我没有像在教程的前一部分那样使用KNeighborsClassifier，因为它不支持类权重。

from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier(class_weight=weights)
model.fit(X_train, y_train)
y_score = model.predict_proba(X_test)y_pred = model.predict(X_test)# Plot metrics 
plot_roc(y_test, y_score)
plt.show()

plot_precision_recall(y_test, y_score)
plt.show()

作者图片

作者图片

摘要

在本教程中，我已经说明了如何执行多类数据集的平衡。可以采用两种可能的策略:欠采样后跟随过采样，或者定义类权重。

如果你对数据预处理感兴趣，可以在我的主页找到其他文章。

如果你想了解我的研究和其他活动的最新情况，你可以在 Twitter 、 Youtube 和 Github 上关注我。

感谢阅读！你可以从我的 Github 库下载完整代码。

相关文章

。

如何处理 Julia 中的缺失数据

原文：https://towardsdatascience.com/how-to-deal-with-missing-data-in-julia-a6527bbac213?source=collection_archive---------28-----------------------

Julia 如何处理缺失数据的概述。

(src =https://pixabay.com/images/id-693865/

介绍

数据收集和观察的一个不幸的副产品是产生缺失值的趋势。虽然这有许多潜在的原因，但最终在分析和使用这些数据的生命周期时，我们需要去掉缺失的值。如果缺少值，很可能无法以任何方式分析、可视化、拟合模型或利用您的数据。也就是说，对于使用任何编程语言的任何数据科学家来说，能够检测并消除数据中的缺失值是绝对必要的。

Julia 语言是最近因其在数据科学领域的能力而受到关注的一种编程语言。Julia 有一种独特的处理值的方式，与其他语言中的大多数实现略有不同。也就是说，任何可能正在学习这门语言的人都可能想知道一些基本的数据处理技术来处理一些丢失的数据。今天我想谈谈这一点。如果您想看看本文中使用的代码的运行情况，您也可以查看这里的笔记本:

笔记本

失踪类型

在缺失值方面，Julia 与其他编程语言最大的不同可能是用于存储空值的不同类型。在 Julia 中，缺失值有三种不同的存储方式。第一种类型是缺失类型。缺失类型的独特之处在于它在 Julia 语言中有自己的类型。这意味着我们可以使用 typeof()来查看这个类型，并且我们还可以通过具有多个分派的函数来传递它。

作者图片

z = missing
println(typeof(z))
println(z)

将它与多个分派一起使用看起来像这样:

example(z::Int64) = println("It's an integer!")
example(z::Missing) = println("It's missing!")

作者图片

example(missing)
example(5)

下一种类型的缺失值是您可能已经习惯的值，即 NaN。虽然在 Python 中这可能是由 NumPy 库提供的，但在 Julia 中却不是这样。Julia 中的 NaN 值实际上不是一个类型，它的类型是 Float64。也就是说，它继承了 Number > Real > Float Float64 的所有调度。Julia 通常很擅长检测您正在处理的数据类型，并且在处理连续特征时通常用 NaN 代替 missing。当然，情况并不总是这样，但不管怎样，这肯定是关于 NaNs 的一件值得注意的事情。Julia 中的 nan 也用以下语法表示:

nan = NaN

如您所见，如果我们打印出 NaN 的类型，我们会看到返回 Float64:

作者图片

**println(typeof(nan))**

同样重要的是要注意到，朱莉娅有我所说的传染性 NaNs。这只是我的说法，任何与 NaNs 的操作都会返回 NaN。实际上，我认为这是一个可怕的数据，因为像这样的东西可能会丢失数据。例如，考虑下面的代码:

h = 5
h += NaN

这将使得 h == NaN，这不是最优的。比起这样的事情，我更喜欢扔一个。幸运的是，Float64 类型是用 Julia 本身编写的，所以如果我想的话，我可以发出一个 pull 请求来修改它……我正在考虑。

最后一种类型的缺失是一无所有。当然，这种类型在编程中很常见。然而，它通常与数据中的丢失值无关，虽然这肯定没有 NaNs 或 missings 常见，但我以前见过这种情况。记住这一点，这是一件很重要的事情，以防万一你碰巧遇到了这样的数据集。

h = nothing

你很可能熟悉这种类型。它通常用于初始化，不太用于数据操作。也就是说，在我们讨论缺少值或类型的话题时，这当然值得一提。由于 Julia 是动态类型的，这也意味着这个新类型是开放的，无需分配就可以重定义。换句话说，我们只注册别名，而不为与之对应的数据分配位，因为没有位。这当然证明了它用于初始化是正确的，我认为在这方面它没有被充分利用。我们可以做的最后一件有趣的事情是调用 code_llvm 宏，这对于优化 Julia 代码和更好地理解该语言非常方便。我真的很喜欢这个宏，以防你看不出来。

returnnothing() = nothing

作者图片

真实处理

现在我们已经了解了不同种类的错过，请允许我揭示一些实际处理它们的方法。关于 missings、NaNs 和 nothing，你应该知道的第一件事是，只有 nothing 可以在布尔上下文中使用。这意味着任何带有布尔值返回的按位运算符，例如==、

z = nothing
z == nothingtruez = NaN
z == NaNfalsez = missing
z == missingmissing

这里使用 typeof(z)也没有太大的区别。考虑到这一点，我们如何使用条件来检测我们丢失的值呢？在 Julia 中，我们实际上使用方法来做到这一点。这两个方法是 isnan()和 ismissing()。

z = NaN
b = missing
if isnan(z) & ismissing(b)
    println("This is true")
end

在大多数情况下，您可能不必降低到使用条件来处理数据的水平。然而，Julia 数据生态系统相对来说还不成熟，所以不要期望永远不必在循环中做这样的事情。记住，解决这些问题的典型方法是使用 DataFrames.jl 包。

using DataFrames
df= DataFrame(:A => [5, 10, NaN, NaN, 25], :B => ["A", "B", "A", missing, missing])

作者图片

对于 DataFrames，使用 dropmissing()方法删除这些丢失的值相对容易。和 Julia 中的很多函数一样，我们也可以使用 dropmissing！()变更类型而不是变更该类型的副本:

dropmissing!(df)

作者图片

好的，现在我们没有遗漏，但是我们还有 NaNs。正如我所说的，这些也会破坏连续值，以及用于分析的返回结果，所以去掉它们也很重要。下面是一个求和的示例，由于这个错误的观察结果，它将返回 NaN:

sum(df[!, :A])

不幸的是，这个有点不同，因为它比这个方法调用要困难得多。不管怎样，这并不困难。然而，我们将需要通过 filter()方法(或 filter！()方法)来获取这些数据。我们也可以对思念和虚无做同样的事情，以摆脱它们。我们甚至可以将它发送出去，这样我们打电话就方便多了！此外，您可以修改 DataFrames.jl 的本地版本来做到这一点(正如我所做的！)

dropbad!(df::DataFrame, col::Symbol) = filter(:A => x -> !any(f -> f(x), (ismissing, isnothing, isnan)), df)

现在让我们称这个新方法为:

dropbad!(df, :A)

结论

在 Julia 中处理数据有其独特的方式，但在许多方面都很有意义。也就是说，我认为这可能会给那些从 Python 等其他语言继承过来的人带来一些问题。虽然在 Julia 中缺少值并不一定会更难处理，但我会说这有点独特，可能不是大多数人所习惯的。关于 Julia 的一个很棒的事情是，大多数基于 Julia 的方法都被扩展到各种不同的包，这使得学习每个包以及它是如何工作的变得容易得多，不管你以前是否使用过它。感谢您的阅读，希望这篇文章对您有所帮助！

如何处理标准 SQL 中的空值

原文：https://towardsdatascience.com/how-to-deal-with-null-values-in-standard-sql-1bffce0c55cd?source=collection_archive---------6-----------------------

1.识别— 2。理解— 3。行动

凯利·西克玛在 Unsplash 上的照片

谁能声称每天都能处理质量和可靠性无可挑剔的数据库呢？我个人不能，老实说，这是我喜欢做数据分析师的部分原因。即使数据清理很少是数据科学中最好的部分，但能够操作数据并从中获得洞察力仍然是必不可少的。

在上一篇关于数据科学的文章中，我们仔细研究了如何使用 SQL 处理数据库中的重复数据。在这里，我们想要解决许多数据分析师每天都会遇到的另一个常见问题:处理数据库中的空值。什么是空值？如何识别他们？如何处置他们？下面是我将尝试回答的一些问题。

请注意，以下代码是用标准 SQL 编写的(例如，与 SQL Server 或 Transact-SQL 相反)，这是 Google BigQuery 中使用的 SQL 语言变体。根据您使用的数据库管理系统(RDBMS ),语法和使用的函数可能会有细微的变化。更多细节可以阅读 Google BigQuery 文档。

简介:null 还是空白？

在深入探讨 SQL 中处理空值的技术细节之前，我们必须首先定义空值的含义。特别是，空值必须与空白值区分开来:

• 空数据库字段意味着对于给定记录没有值。它表示缺少值。
• 一个空白的数据库字段意味着对于一个给定的记录有一个值，这个值为空(对于一个字符串值)或 0(对于一个数值)。

这两种情况不能混淆，否则会导致错误解释数据并将空值作为 null 值处理。在本文中，我将使用一个名为“website _ CRM”(具有随机值)的测试数据库，它包含 10 行 7 列:

测试数据库 Marie Lefevre

我们假设这个数据库是一个电子商务网站的客户数据库。为了说明 null 值和空白值之间的区别，请仔细查看第 9 行。对于名为 Iliana I 的客户，字段“州”、“年龄”和“美国纳税人”为空值，而字段“电话”为空。这意味着他们没有填写前三个字段(空值)，而是填写了“电话”字段并输入了空值。

第一步:识别和想象

首先，我们希望确定我们的数据集中是否有空值。有两种方法可以在数据集中查找空值，这取决于您对所操作数据的先验知识。

如果您已经知道在哪个字段(或列)中可能有您想要的空值，您可以直接在感兴趣的字段上应用条件WHERE IS NULL。在我们的示例中，如果我们知道“国家/地区”不是必填字段，而我们希望按地理区域分析客户的划分，我们希望只调查这一列。这段代码可以实现这一点:

如果您对正在调查的字段没有一个精确的概念 —或者如果您想要获得数据集中空值的完整概述，您必须首先清楚地了解每列中可能存在的空值以及空值的数量。为了获得这个概述，您可以使用下面的代码片段(从堆栈溢出中检索):

在我们的例子中，输出如下:

玛丽·勒费夫尔

第二步:理解和决定

既然您已经确定了数据库中存在空值的位置，那么您可以更进一步，调查是什么导致了这些空值。数据库包含空值有许多原因。让我们回答三个“背景调查”问题，以便更好地理解它们。

1.某些字段的所有行都为空吗？

在我们的示例中,“年龄”字段始终为空。其中一个原因可能是字段对于网站的顾客来说不是强制性的:在网上订购时，除了特定的商品，你不需要告知你的年龄。由于年龄是个人数据，客户在网上购物时可能不愿意分享这些信息。

这也可能表明网站上的潜在 bug。在这两种情况下，对于任何企业来说，监控数据库中 null 值的出现次数以及它如何随着时间的推移而演变都是至关重要的，尤其是当所有条目都为 null 时。在这种情况下，这可能会导致产品团队更深刻的反思:如果没有人填写这些信息，继续向客户询问这些信息是否有意义？

2.几个字段的行数都是空的吗？

有意或无意地，一些字段可以相互关联，其中一个字段填写的信息依赖于另一个字段。因此，更好地理解字段的相互依赖性可以帮助您解释为什么一些字段具有给定数量的空值。

在我们的例子中，这将对应于字段“state”和“us _ 纳税人”:这两列各有 7 个空值。当查看整个表时，我们在这里看到没有填写“州”字段的客户居住在美国以外的国家。如果“美国纳税人”字段不是必填的，这将解释这七个客户在网上订购“您是美国纳税人吗？”时不需要勾选最后一个框。

3.剩下的案例有哪些？

最终，你需要看看前面两步之后仍然无法解释的边缘情况。它们可以对应于数据输入中的错误或简单地对应于异常情况。在这两种情况下，调查是什么导致了这些剩余的空值对于改进您的产品或用户体验非常有指导意义。

在我们的电子商务示例中，有趣的是一位在线客户(Carla C .)没有提供他们的电子邮件地址。虽然通过电子邮件接收订单确认和采购账单是必要的，但是这个字段怎么可能不是强制的呢？无论如何，这种数据输入在未来必须成为不可能。这就是为什么调查导致空值的原因对业务至关重要:这可能是由于人为错误(例如，客户忘记提供电子邮件地址)或技术错误(例如，网站在保存表单时遇到错误，因此无法保存填写的值)。

照片由 Hadija Saidi 在 Unsplash 上拍摄

第三步:行动和修改

根据您从前面的步骤中得出的结论，现在是时候对这些空值产生影响了。他们应该保持现在的样子，还是应该不惜一切代价将他们移除？我确定了三种处理它们的方法:

• 用中性值替换空值，例如“不适用”或“-”
• 用有意义的值替换空值
• 让空值为空

对于决定替换空值的情况，让我们应用最合适的 SQL 函数。

IFNULL:简单的一个

顾名思义，如果输入值为空，函数IFNULL(expr, null_result)将返回某个值。

在我们的例子中，我们希望使字段“state”中的空值更加明确，因此我们选择用中性词代替空值，如“data not available”。这同样适用于“年龄”字段。此外，我们希望从字段“us _ taobar”中删除所有空值。让我们假设所有没有回答“是”的顾客都没有在美国纳税。因此，如果这个字段为空，我们要返回“否”。结合前面的更改，将得到以下代码片段:

IFNULL(状态，'数据不可用')
IFNULL(年龄，'数据不可用')
IFNULL(美国 _ 纳税人，'否')

COALESCE:清单 1

函数COALESCE(expr[, ...])返回第一个非空表达式的值。要使用它，您需要预先定义要用来替换空值的术语的优先级顺序。

在我们的例子中，我们希望确保字段‘email’没有空值。原因可能是我们的支持团队将此字段用作客户的联系点。因此，我们希望该字段等于，优先级顺序如下:

1. 客户的电子邮件地址(如果有)
2. 否则，如果有的话，客户的电话号码
3. 否则，客户的名称

为此，我们不能使用 IFNULL 函数，因为它只能显示空值的一个替代值。所以我们使用下面这段代码:

联合(电子邮件、电话、姓名)

案例:复杂的案例

最后，当需要处理几种情况时，可以使用CASE expr WHEN expr_to_match THEN result [...] [ELSE else_result] END函数，包括更复杂的情况，其中 IFNULL 或 COALESCE 不足以替换空值。

在我们的示例中，如果字段“国家”为空，我们希望以特定顺序应用以下规则:

1. 如果“国家”不为空，那么我们就取这个值
2. 否则，如果“state”不为空并且属于美国的一个州，我们希望在“country”字段中写入“United States”
3. 否则，如果“州”不为空，我们希望将这个“州”值复制到“国家”字段中
4. 否则，我们就写“没有国家”

在标准 SQL 中，这对应于下面这段代码:

事例
当国家不为空时，则国家
当州在('阿拉巴马'，'阿拉斯加'，'亚利桑那'，'…'，'佛罗里达州'，'堪萨斯州'，'华盛顿州')时，则国家
当州不为空时，则国家
否则‘没有国家’
结束

最终产出和结论

总而言之，我们构建了下面这段代码:

在应用了上面所有的修改之后，我们最终得到了一个干净的表。不仅在视觉上更漂亮，而且用有意义的值替换空值使得读者更容易理解表格。作为一个数据分析师，这是弥足珍贵的。更重要的是，这将使非技术用户能够更好地利用您的数据库，同时降低误解某些不包含值的字段(相对于空值)的风险。

测试数据库 Marie Lefevre

现在它是你的了！**你如何处理空值？**识别空值真的比清除空值容易吗？请在下面分享您的技巧，并讨论您在 SQL 方面的最佳实践。

如何处理规则重叠？

原文：https://towardsdatascience.com/how-to-deal-with-overlapping-rules-16bc0446af66?source=collection_archive---------33-----------------------

入门

尤其是当规则的预测相互矛盾时。

来自 Pixabay 的塞普蒂米乌的图片。

当一个人想要建立一个可解释的模型时，他通常会在两个主要的内在可解释算法家族之间犹豫不决:基于树的算法和基于规则的算法。它们之间的主要区别之一是，基于树的算法生成具有不相交规则的树，这具有诸如复制子树问题的缺点[1]，而基于规则的算法生成规则集并允许重叠规则，这可能是一个问题。事实上，当两个(或更多)规则同时被激活时，您如何做出决定呢？当规则的预测相互矛盾时，这就更成问题了。

在这篇短文中，我介绍了从一组规则中获得单个预测的两种方法，这两种方法比平均预测更重要，但保留了预测的可解释性。

使用专家汇总方法

如果您不熟悉专家的聚合理论，我建议您阅读我以前的文章“如何选择最佳模型？”。这个想法很简单:把每一个规则看作是专门的专家，通过一个凸组合来聚集他们的预测。与规则相关的权重在每次预测后都会改变:如果专家的预测是好的，则权重会增加，否则会减少。因此，权重可以解释为我们在时间 t 对每个专家的信任度。

不幸的是，规则可能没有被激活。这意味着新的观察不满足他们的条件。他们被称为“睡眠专家”。问题是我如何评估一个没有被激活的规则的可信度？常见的方法有两种。首先是说“没有信息我不会做决定”。这样，休眠规则的权重保持不变，直到它再次激活。二是问“这个规则是睡觉好吗？”。以这种方式，通过考虑集合预测而不是规则的预测来评估休眠规则的新权重。如果聚集预测是好的，则意味着该规则一直是正确的，否则意味着该规则应该一直是活动的。这两种方法都有问题。但是已经证明它们提供了相似的结果。

使用分区技巧

划分是一个非常不同的想法，更“统计”。其思路是将规则集形成的覆盖变成分隔单元格的分割(如下图所示)。因此，预测将是单元中观察值的平均值，而解释将是规则的结合。

图片来自作者。

有人可能会反对建造这种隔墙非常费时。而且是正确的。所以，为了解决这个问题，有一个分区技巧。其思想是要理解，计算预测值不需要完全描述分区。诀窍是识别包含新观察值 x 的分区的唯一单元。通过创建二进制向量，如果新的观察值 x 满足规则的条件，则其值为 1，否则为 0，对包含 x 的单元的识别是简单的向量运算序列。因此，计算预测的复杂度是 O(nR) ，，其中 n 是训练集中的点数，而 R 是规则数。下图是这个过程的图解(更多细节我参考[2])。

图片来自作者。

这种方法的主要问题是我们无法控制细胞的大小。换句话说，如果包含新观察值的单元格太小，您可能会根据太少的过去观察值做出决定。如果训练集中的数据很少，就会出现此问题。可以解释为情况不明。

结论

我已经介绍了两种方法，即使您的过程基于重叠的规则，也可以做出决定。这两种方法各有利弊。第一种基于专家聚集理论，在实践中运行良好，并为规则增加了一个置信度得分。第二种，基于划分技巧，理论上更好。如[3]中所述，这是生成回归函数的可解释一致估计量的好方法。

参考

[1] G.Bagallo 和 D.Haussler，经验学习中的布尔特征发现 (1990)，载于《机器学习》，5(1):71–99。斯普林格。

[2] V.Margot，J-P. Baudry，F. Guilloux 和 O. Wintenberger，规则归纳划分估计器 (2018)，模式识别中的机器学习和数据挖掘国际会议 288–301。斯普林格。

[3] V.Margot，J-P. Baudry，F. Guilloux 和 O. Wintenberger，使用数据相关覆盖的一致回归(2021 年)，载于《电子统计杂志》。数理统计研究所和伯努利学会。

关于我们

Advestis 是一家欧洲合同研究组织(CRO ),对统计学和可解释的机器学习技术有着深刻的理解和实践。Advestis 的专长包括复杂系统的建模和时间现象的预测分析。

领英:【https://www.linkedin.com/company/advestis/】T4

如何在 VS 代码中调试 Flask 应用程序

原文：https://towardsdatascience.com/how-to-debug-flask-applications-in-vs-code-c65c9bdbef21?source=collection_archive---------1-----------------------

如何使用 flask 创建一个基本的 web 服务，然后在 VS 代码集成开发环境中单步调试并完全调试代码

由 Unsplash 上的 Clément Hélardot 拍摄

介绍

Flask 应用是使用 flask 库用 Python 编程语言开发的 web 服务应用。

它们是快速开发任何编程语言(包括 Python、C#)都可以使用的 web 服务的好方法。NET、Java 等。但是直到最近，我还不知道如何在 VS 代码中调试，这样我就可以一步一步地调试 flask 应用程序代码。

本文展示了一个简单的分步指南，它将使您能够完成设置和配置，从而轻松调试 flask 应用程序。

步骤 1:开发一个基本的烧瓶应用程序

出于本教程的目的，我们将使用基本应用程序来探索如何调试 flask 应用程序如下-

您应该在 VS 代码环境中创建 flask 应用程序，并且应该创建一个。py 文件，并将其命名为app.py。

有一些方法可以修改配置，为您的代码文件使用不同的名称app.py,但是因为您在 flask web app 中只允许使用一个 Python 文件(在 flask web app 中，您可以创建任意多的 web 服务),所以更改它似乎没有多大意义。

如果到目前为止您一直在学习，那么您的 VS 代码环境和 Python 代码应该是这样的

作者图片

步骤 2:创建并配置一个 launch.json 配置文件

如果您单击 ide 左侧的“运行和调试”图标，或者键入 Ctrl+Shift+D，您将看到“运行和调试”窗口。

现在点击“创建 launch.json 文件”链接，当提示“选择调试配置”时，选择“Python 文件调试当前活动的 Python 文件”。

作者图片

VS 代码现在会自动为您创建一个 launch.json 配置文件，该文件预先填充了一些基本设置。

首先要做的是删除注释，因为这些注释会在稍后执行 flask 应用程序时导致错误/警告-

作者图片

下一步是最关键的。当 VS 代码创建 launch.json 文件和相关的配置时，它不包括必要的配置来告诉环境和 web 服务器在哪里可以找到 conda 环境，这必须手动添加，否则调试将永远无法在 VS 代码中工作。

1. 在你的电脑上找一找你的 Anaconda 文件夹，其中包含一个名为_conda.exe的文件
2. 在 launch.json 中为名为"python.condaPath"的参数创建一个新的配置行，其值指向正确的路径

完成的 launch.json 文件应该如下所示

作者图片

注意:在 Windows 环境中有三种方式可以启动 VS 代码

1. 转到 Windows 开始菜单，启动 VS 代码
2. 启动 Anaconda 环境并点击 VS 代码下的“Launch”
3. 启动 Anaconda 命令提示符并键入“code”

只有在使用第一种方法时，才需要在 launch.json 中添加一行来设置"python.condaPath"。

如果您使用方法 2 或 3，这将指示 VS 代码环境使用基本 conda 环境，因此不需要额外的配置。

步骤 3:启动调试器

下一步是回到代码文件中，在编辑器的空白处单击，在代码中创建一些断点。在下面的例子中，我点击了第 33 行和第 39 行-

作者图片

现在回到“运行和调试”窗口，点击“Python: Current File”旁边的绿色箭头，开始调试会话

作者图片

当您启动调试器时，可能会收到“Exception has occure:system exit message ”,但这并不重要，不会阻止您调试代码。

只需点击调试工具栏中的蓝色“播放”按钮，调试会话将继续-

作者图片

如果一切正常，你在终端窗口得到的最后一条消息将是-

* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

步骤 4:调用 Web 服务

您现在需要打开一个 web 浏览器，在 URL 中键入http://127.0.0.1:5000/,以调用正在调试器和 VS 代码 ide 中运行的 web 服务

作者图片

一旦按下return键，您将看到以下内容-

1. 浏览器调用已经调用了 web 服务
2. 在 VS 代码中，web 服务已被调用，并在调试器中您添加断点的地方暂停
3. 现在，您可以使用 VS 代码调试工具栏来调试代码

作者图片

当您单步执行代码并退出 web 服务函数时，web 服务的输出将返回给调用该服务的 web 浏览器

作者图片

如果您想要调用返回所有数据科学书籍的第二个服务，请返回到 web 浏览器并修改 URL，如下所示

[http://127.0.0.1:5000/api/v1/resources/books/all](http://127.0.0.1:5000/api/v1/resources/books/all)

现在将在调试器中调用和暂停第二个 web 服务。一旦你完成了代码并执行了函数，代表数据科学手册库的 json 将作为输出返回给浏览器

作者图片

结论

第一次用 VS 代码设置 flask web 应用程序的调试有点笨拙，尤其是当你不知道把最重要的"python.condaPath": "C:\\Users\\GHarrison\\Anaconda3"行添加到launch.json文件中的时候。

然而，对于 web 服务来说，一旦完成一次，它将只适用于所有后续会话，并且一旦这些 web 服务超出这里给出的基本示例的规模，成为真实世界的复杂 web 服务，能够单步调试 flask web 应用程序的能力就变得至关重要。

感谢您的阅读！

如果你想联系我讨论这些话题，请在 LinkedIn 上找我—https://www.linkedin.com/in/grahamharrison1或者发邮件给我ghar rison @ Lincoln college . AC . uk。

如果你想通过订阅来支持作者和全世界 1000 个为文章写作做出贡献的人，请使用这个链接——https://grahamharrison-86487.medium.com/membership(注意:如果你使用这个链接注册，作者将收到一定比例的费用)。

如何用 TensorBoard 调试你的深度学习管道

原文：https://towardsdatascience.com/how-to-debug-your-deep-learning-pipeline-with-tensorboard-d27d3f8795e?source=collection_archive---------29-----------------------

关于如何提高深度学习实验吞吐量的互动示例。

使用 TensorBoard 对 10 个平假名字符类进行 UMAP 分割(图片由作者提供)

当我们开发深度学习模型时，我们经常会在管道中遇到各种各样的问题。这包括我们处理数据的方式的问题，将数据传递到我们的模型的方式的错误，甚至在评估阶段的错误。数据科学家面临的主要挑战之一是使这些数据(尽可能)透明，以确保使用工具箱中的正确工具(预处理策略、模型层、评估标准等)。).然而，为了实现这一点，我们经常不得不在试错的基础上做一系列实验，包括显示定制图和跟踪变量。这就是 TensorBoard 来提升我们工作流程的地方！

tensor board 到底是什么？

TensorBoard 是一款专为深度学习管道打造的高级分析工具，可处理各种数据源(图像、视频、音频、结构化数据等)。).它允许我们通过自动化的可视化绘图来调试我们的管道。它还跟踪我们实验的历史，以便我们可以运行多个版本，并观察哪个模型配置对性能有最好的影响。这对于超参数调整特别有用。另一个我非常喜欢的功能是能够将我们的模型嵌入到 2D/3D 空间中(通过聚类方法),并观察每个单独数据点之间的相关性。

在本教程中，我将向您展示一个标准的图像分类示例，它使用了包含日本平假名字符集的K-MNIST(Kuzushiji-MNIST)数据集。我们将使用 PyTorch 来构建和评估我们的模型，并将其发送到 TensorBoard 进行分析，只需在我们的代码中添加简单的 2-3 行代码！

数据

K-MNIST 是一组日本 Kuzushiji 人物，基于经典 MNIST 。除了在这种情况下，目标不是数字，而是代表一组平假名字符(上例中的每一行)。每一行的第一个例子是汉字的现代平假名，而其余的是用 Kuzushiji - 风格书写的，这是 150 多年前在旧日本手稿和书籍中使用的。这个数据集是如何创建的背后的故事真的很有趣，因为它通常允许以这种风格编写的旧日本文学作品被翻译成现代汉字并用于教育系统。你可以在这里阅读更多关于 Clanuwat 等人的工作。

我们将在中使用这个数据集来构建一个用于字符识别的基本 PyTorch ConvNet (别担心，你不需要真正懂日语，我也不需要)。那么，让我们开始吧:)。

依赖关系

此示例是在 Python 3.7 环境中制作的，包括以下软件包的最新版本:

• 火炬和火炬视觉——建模
• 标准绘图、计算包— matplotlib、seaborn、numpy(应已安装在 Conda 上)
• 注意:如果你已经在你的环境中安装了tensor flow*，你可以使用这个工具清除任何与文件处理相关的 TensorBoard 错误。*

这里还有其他的进口货:

基本配置

让我们也添加几个默认变量，以便稍后使用。这些包括字符的类名、一些超参数、路径和图像的大小。

初始化张量板

这只需一个调用就可以完成，这个调用将生成一个 runs/k-mnist 目录，我们的数据将由 TensorBoard API 在其中编码。

读取数据

我们可以使用 PyTorch DataLoader 类轻松加载我们的 K-MNIST 数据用于训练和验证。我们还可以指定加载后要执行的自定义转换。在这种情况下，我们将把图像转换成 PyTorch 张量，并归一化图像通道(使用与处理 MNIST 所用参数相同的参数)。

想象一些例子

在我们真正进入 TensorBoard 的自动化部分之前，让我们先来看看如何分析一些自定义图像。对于这个例子，我们将通过从 ubyte 格式加载它们作为 numpy 数组来查看原始字符。接下来，我们将创建两个简单的函数:

• 一个用于显示前 25 个字符及其类别索引的 5x5 网格
• 一个在单独的图像中显示 25 个字符中的每一个

我们将把这两个函数的输出记录到 TensorBoard 中。对于网格，我们将暂时将 matplotlib 图形保存到缓冲区，然后使用 PIL 将其转换为张量，然后将其传递给 TensorBoard。我们这样做是因为张量板只处理张量输入。为了绘制单个图像，我们可以简单地将 numpy 数组转换为张量，并以不同的全局步长传递每个图像。

现在，为了查看记录的输出，我们需要在一个单独的终端中启动 TensorBoard API ，并在本地运行时托管它。我们可以通过切换到我们的项目文件夹并运行下面的代码来实现。张量板输出将位于http://localhost:6006。

tensorboard --logdir=runs/k-mnist --samples_per_plugin "images=100, text=100"

这里， logdir 是我们在初始化 SummaryWriter 时创建的目录。注: *--samples_per_plugin* 允许我们为特定的张量板模块增加可跳过的样本数量。在我们的例子中，在图像和文本方面，我们超过了这个限制，增加它给了我们完整的输出集。

托管 TensorBoard 后，我们将看到以下页面:

TensorBoard 图片(注意:在此阶段，您将只能看到当前选项卡)—作者图片

在 TensorBoard 中可视化图像数据允许您交互式调整对比度和亮度，以及滚动多个示例，这对于观察您的数据非常有用。

创建数据加载器

为了使模型训练更加节省内存，我们需要使用批处理。这在 PyTorch 中通过**数据加载器很容易完成。**简单指定批量大小以及是否打乱训练/val 集合。

创建一个简单的 CNN 模型并记录模型摘要

TensorBoard 图:跟踪模型结构(图片由作者提供)

这有助于我们交互式地追踪模型结构，从输入形状开始，一直到预测。每个箭头还描述了每个单元的形状，这对于识别模型中的形状不匹配非常有用。这是一个简单的例子，但是对于更大、更深层次的架构来说，这些图节省了大量的调试时间。

训练预测器

在我们开始训练之前，我们应该确保我们正在我们的 GPU 设备上训练(如果可用的话)。这可以通过设置活动 PyTorch 设备来实现:

为了使代码更具可读性和可复制性，让我们构建一个包含一些输入参数和辅助函数的kmnistpoirder类。我们将设置目标历元数、批量大小、损失函数和 TensorBoard writer 对象。 loss_batch 函数将允许我们计算交叉熵损失，反推并更新单个批次的权重。 get_correct_examples 函数是一个简单的一行程序，用于获取单个批次中正确样本的数量，这将帮助我们计算精确度**。除了，**我们还需要使用 Softmax 函数计算每个类别的概率，因此我们可以使用 get_probs 在一个步骤中提取预测的类别和概率。注意:to(dev)确保我们将批处理发送到正确的设备，否则我们将得到内存分配错误。 最后，我们的 fit() 函数将由两个阶段组成:

• 训练模式:遍历每一批，对历元中的批损失、正确和总样本进行求和。这将不断更新模型权重。之后，只需将它们打印出来，并将列车损失和精度记录为张量板标量。
• 评估模式:遍历每个验证批次，并对历元中的损失、正确和总实例进行求和(不要指定优化器，此步骤的权重应被冻结)。然后类似地，将验证损失和精度记录为张量板标量。

我们还将添加一个 save()和 load() 方法，以便保留模型状态供将来使用。现在，我们可以通过运行三行代码来训练和保存我们的模型:

现在，我们可以自动跟踪模型性能，而不必进行任何自定义绘图。我们跟踪的指标将记录在标量选项卡上，在这里我们可以观察每个时间步长的损失/准确性。这允许我们看到当前配置的潜在问题(例如，在什么点上我们的模型开始过拟合)。

张量板标量:在训练期间跟踪模型性能(图片由作者提供)

在这个例子中，我们可以看到我们的模型收敛得相当好，因为我们达到了 95%的验证准确度，并且我们的验证损失曲线变得平滑。但是，我们仍然可以做进一步的分析，以确保我们的模型是稳定的。

精确召回曲线

为了可视化每个平假名字符的每类性能，我们可以很容易地使用 TensorBoard 的 精确召回曲线模块。首先，我们加载验证数据，并提取每个批次的预测类别和概率。然后，我们将它们堆叠在一个列表中，并将输出记录到 TensorBoard。遍历每个类，我们需要传递一个布尔数组，指定哪个输出对应于相应的类和概率集(也是一个递增的全局步骤，这样我们就不会覆盖任何一个类)。

在 prcurves 选项卡中，我们可以观察到每个平假名字符的精度-召回权衡。您将看到，随着模型在所有类上都取得了良好的性能，所有的斜率都严重向右偏移。如果我们突出显示右上区域，我们可以放大并看到每个类的真阳性/阴性和假阳性/阴性的实际比率。

TensorBoard PR 曲线:获得每类性能(图片由作者提供)

地块分类错误

类似于我们之前显示的图像网格，我们也可以绘制一个自定义的错误网格，以便观察哪些字符被错误分类。我们只需要再次加载验证数据，获得预测的类并将它们附加到一个列表中，分别保存真实/预测的类(仅当它们不同时)，以及实际的图像。然后我们可以用第一个 25 错误分类的例子创建一个网格，和以前一样。同时，我们还可以添加一些文本数据来记录到 TensorBoard 中，比如每个示例的预测与实际输出。我们将添加图像索引，以便将该信息与显示的网格相关联。

TensorBoard:显示分类错误(图片由作者提供)

我们将在图像选项卡上看到我们的错误网格，并在文本选项卡上看到我们为每个示例记录的类。

超参数调谐

我们还可以使用 hparams 轻松利用 TensorBoard 来调整我们的 K-MNIST 预测器的超参数。首先，我们需要修改我们的培训类来支持这一点，增加几行代码:

我们将首先添加学习率、优化器名称、批量大小(调优目标)，以及 TensorBoard writer 对象。然后，在我们的 fit() 函数的末尾，我们将简单地添加这些用于监控的参数:

• 第一个参数:超参数字典(名称:值)
• 第二个参数:用于监控的性能指标字典(名称:值)

在这种情况下，我们将记录纪元验证准确性/损失。这将生成一个性能表，突出显示每个超参数组合的这些值的变化。现在，让我们定义一个搜索网格和一个整体的 optimize() 函数来装饰我们的训练管道。这将迭代每个学习率/批量大小/优化器组合，并生成总共 27 个模型组合(在 3x3 网格上)。这可能需要一些时间来计算(在我的例子中大约需要 30 分钟)，所以请随意减少参数的数量。注意:由于批量大小和学习率的选择会导致不稳定的配置，某些模型组合的性能会非常差。对于较大的**学习率，模型更容易在* 局部极小值 处初始化，由于步长过大，无法从训练数据中获得牵引力。这是一个例子，其中调整你的 学习率/批量 是必要的。*

TensorBoard hparams:交互式调整您的模型(图片由作者提供)

在表视图中，我们可以观察每个超参数配置的性能指标。在我们的例子中，获得的最佳性能是我们最初使用的(Adam，批量:32，学习率:0.001)，达到大约 95%的验证准确性。我们还可以在平行坐标视图中更好地可视化这一点，在这里我们可以更改指标的比例，并在超参数网格中跟踪每个模型的性能。

特征检查/降维

TensorBoard 支持的另一个非常酷的功能是 2D/3D 空间中的特征投影。这允许您应用聚类方法，如 PCA 或 T-SNE，以便可视化个体组之间的相似性和某些类别特征内的识别模式。最棒的是，它是互动的，所以你可以实时观察。

让我们看一个简单的例子。我们将从验证数据(图像和标签)中每批随机挑选 16 个示例，将它们在一个维度上堆叠在一起，并创建一个 TensorBoard 嵌入来可视化这组示例。图像将在两个维度上被挤压(批量维度和宽度高度通道)。这将构建计算相似性的特征向量。为了可视化，原始 PyTorch 图像张量将被传递到 label_img 并且元数据将是平假名字符的真实类。

*投影仪选项卡最初将显示我们随机批次的 PCA。这是一种降维方法，将我们的输入特征压缩到 3 个可观察的维度中。然后，您可以按类别标签给图着色，以便区分每个字符类别。你也可以使用 T-SNE 和 UMAP 等方法来运行其他模拟。在这里，您可以随意尝试不同的方法、参数和采样策略，看看分布是如何变化的。*

TensorBoard 投影仪:在 2D/3D 空间中可视化您的特征(图片由作者提供)

注意:如果投影仪选项卡没有出现，请尝试从命令行重新运行 TensorBoard 并刷新浏览器。

用 TensorBoard 完成工作后，也要经常用 writer.close() 关闭自己的 writer，从内存中释放*。***

最后的想法

TensorBoard 通常是一个很好的分析工具，可以帮助调试你的深度学习管道，无论是在数据层面还是模型层面。我可以肯定地说，它节省了您自己创建定制图和跟踪性能指标的大量时间。因此，这是一个很好的工具，因为您可以生成和测试更多的实验/模型配置，并立即跟踪您的管道中哪些有效，哪些无效，以及哪些需要修复。

希望你喜欢这个教程:)。距离我上次写已经有一段时间了，但是我很想在将来写更多，所以如果你对代码或博客中提到的信息有任何建议/问题，请告诉我。

这个库(本质上只是一个 Jupyter 笔记本)可以在 GitHub 上本地克隆。

参考文献

如何使用谷歌地图的 API 决定晚餐分组

原文：https://towardsdatascience.com/how-to-decide-on-dinner-grouping-using-google-maps-api-75edaa78fc9d?source=collection_archive---------48-----------------------

随着新加坡从新冠肺炎疫情中恢复过来，新加坡政府已经开始允许人们八人小组聚会。我的教会团体(37 人)想一起吃晚饭。因此，我决定用 R 写一些代码，让我们尽可能以最好的方式组织晚餐！(为保护隐私，使用了假名)

分类要求

1. 人们呆在新加坡各地
2. 有 5 个晚餐地点
3. 人们在世界不同地区进行研究。
4. 我们需要先根据地区然后根据晚餐地点对人们进行分类。
5. 每组最多 5 人，每组必须至少有 2 人来自同一地区。

这看起来是一个有趣的挑战！

测量便利性

考虑到这些需求，我不得不开始考虑如何实现这一点。为了确保人们去最方便的地方，我们可以使用的最明显的度量标准是从他们的房子到晚餐地点的旅行时间。为了找到答案，我使用了mapsapi,它允许我们访问谷歌地图 API 套件中的方向 API。下面是我如何使用它的一个例子！(注:MRT 代表大众捷运是新加坡的地铁)

一旦我有了旅行时间，我所要做的就是按不同地点的旅行时间降序排列(同时按研究区域分组),这将允许我将它们归入不同的组。

查找旅行时间

以下是(假)数据的样子:

所以我们有了这些人的名字，他们的研究区域和离他们家最近的地铁站。我创建了 5 个额外的空列(用来存储到 5 个地点的旅行时间)，然后运行一个循环来使用mp_directions填充它。

问题是……它以字符串的形式返回旅行时间，返回类似“1 小时 15 分钟”和“55 分钟”的结果(正如你在上面的例子中看到的)。因此，我需要做些事情将它们转换成数值，这样我们就可以对它们进行排序。我使用 if/else 和stringr完成了这个任务

我对所有 4 个位置都这样做了，将它包装在一个更大的 for 循环中，以考虑所有不同的位置。完成后，这就是数据帧的样子！

排序和更多排序

有了旅行时间，我们现在要找到离一个人最近的位置所要做的就是找到最小值。为了做到这一点，我使用了apply，逐一检查每一行，并对它们进行排序，以找到最低值，然后是第二低的值等等。我还使用了names(),以便将它存储为地点的名称。

最后，我把它按地区分组，然后把它们从第一到第五选择排列起来。

组的分配

分类工作完成后，剩下要做的就是找出人与人之间的分配。我决定一次做一个地区，因为它们必须按地区分类。

首先，我决定使用count快速浏览一下分配情况。

从数据来看，璧山显然是大多数人最集中的地方。然而，只有一组人能到场。在整理过程中，我得到的指示是尽我所能让大多数人都方便。不幸的是，有限的地点意味着一些人将不得不去 T4 旅游。

我决定优先考虑旅行时间，但也要确保每个晚餐地点至少有两个人来自同一个地区。我根据最近的位置，第二个最近的位置进行过滤，然后从每个区域中切掉前三个名字。

我不会用剩下的排序来烦你，但我基本上检查了每个位置并把它们切片，确保每个人都被分配到一个组。

也就这样了！这不是一个非常困难的问题，但如果手动完成，可能会很乏味。使用 Google Maps API 可以让人们更容易找到地点之间的距离，然后相应地对它们进行排序。

如何为您的机器学习模型确定完美的距离度量

原文：https://towardsdatascience.com/how-to-decide-the-perfect-distance-metric-for-your-machine-learning-model-2fa6e5810f11?source=collection_archive---------8-----------------------

曾经怀疑过哪种距离度量对您的用例最有利吗？

塔内利·拉蒂宁在 Unsplash 上拍摄的照片

声明:你不需要每个 ML 模型都有一个距离度量，但是如果你需要的话，请继续读下去，选出最好的一个。

距离度量在机器学习和深度学习中起着重要的作用。像 k-NN，K 表示聚类，深度学习中使用的损失函数等机器学习算法都依赖于这些度量。

因此，了解不同类型的距离度量对于决定何时使用哪种度量非常重要。例如，k-NN 经常使用欧几里德距离进行学习。但是，如果数据是高维的呢？欧氏距离还会有价值吗？不，不会的，因为我们知道，欧几里德距离对于高维空间来说并不是一个好的度量(参见这个链接了解更多信息)。所以我想你现在可以理解，知道你的距离度量可以帮助你从一个差的分类器到一个精确的模型。

在这篇博客中，我们将介绍一些最常用的距离度量及其用例和缺点，以及如何在 python 中实现它们。我们将讨论的问题如下:

• 欧几里得距离
• 曼哈顿距离
• 切比雪夫距离
• 闵可夫斯基距离
• 汉娩距
• 余弦相似性
• 雅克卡相似性
• 索伦森-戴斯指数

欧几里得距离

欧几里德距离是最常用的距离度量之一。从数学上来说，它是两个不同数据点之间的差异之和的平方根。下面是计算两个 k 维向量之间距离的公式。

作者图片

应用/优点:

• 高度直观、易于理解、易于使用的指标
• 它应该用在 KNN 或 K 均值等算法中，在这些算法中，我们有低维数据，数据点之间的直线距离足以衡量这些点的相似性。

图像来源

缺点:

• 它会受到输入要素比例的影响，这意味着根据每个要素的单位，计算的距离可能会有偏差。因此，标准化输入特征至关重要。
• 对高维数据无效/无用

python 中计算欧几里德距离的函数:

from math import sqrtdef euclidean_distance(a, b):
    return sqrt(sum((e1-e2)**2 for e1, e2 in zip(a,b)))#ORfrom scipy.spatial.distance import euclidean
dist = euclidean(row1, row2)
print(dist)

曼哈顿距离

作者图片

它通常被称为出租车距离或城市街区距离。想象你在一个城市街区，有两组平行的道路，水平的和垂直的，如图所示。所以，如果你想从一个点旅行到另一个点，你只能以直角移动。

然后计算两点之间的距离代表曼哈顿距离。

作者图片

应用/优点:

• 当数据集中存在离散/二进制属性时，曼哈顿距离度量更有效，因为它考虑了可从给定属性值中实际获取的路径。

缺点:

• 对于数据集中的浮动属性，它并不代表最佳距离。
• 对于高维数据，它比欧几里德距离更好，但在性能方面仍不是最佳选择。

python 中计算曼哈顿距离的函数:

def manhattan_distance(a, b):
    return sum(abs(e1-e2) for e1, e2 in zip(a,b))#ORfrom scipy.spatial.distance import cityblock
dist = cityblock(row1, row2)
print(dist)

切比雪夫距离

切比雪夫距离被定义为所有坐标维度中两个向量之间的最大差值。换句话说，它就是沿每个轴的最大距离

作者图片

应用/优点:

• 这一指标通常用于物流问题。例如，计算车辆从一个地方到另一个地方所需的最小步数，假设车辆在一个网格中运动，因此只有八个可能的方向(上、右上、右、右下、下、左下、左、左上)

缺点:

• 它只能用于特定的问题。它不能像欧几里得那样适用于任何通用问题。

python 中计算切比雪夫距离的函数:

def chebyshev_distance(a, b):
    return max(abs(e1-e2) for e1, e2 in zip(a,b))#ORfrom scipy.spatial.distance import chebyshev
dist = chebyshev(row1, row2)
print(dist)

闵可夫斯基距离

Minkowski 概括了上面讨论的所有距离度量，如欧几里德、曼哈顿和切比雪夫。它也被称为 p-范数向量，因为它添加了一个称为“p”的参数，允许计算不同的距离度量。公式是:

作者图片

对于 p=1 —曼哈顿距离

对于 p=2 —欧几里德距离

对于 p =无穷大—切比雪夫距离

由于这是一个更通用的距离度量，不同的 p 值将导致不同的利弊。我们已经在上面讨论了其中的一些。

python 中计算闵可夫斯基距离的函数:

def minkowski_distance(a, b, p):
    return sum(abs(e1-e2)**p for e1, e2 in zip(a,b))**(1/p)#ORfrom scipy.spatial import minkowski_distance
dist = minkowski_distance(row1, row2)
print(dist)

汉娩距

这是迄今为止最简单的一个。它等于两个数据点之间不同的值的数量。假设两个数据点 x 和 y 如下:

x = [1，2，3，0，2，4]

y = [1，3，3，0，1，4]

那么汉明距离= 2 至于 index(假设 index 从 0 开始)1 和 4 在 x 和 y 上的值是不同的，它通常用于计算两个二进制字符串之间的距离。

优势/优点:

• 当数据从一台计算机发送到另一台计算机时，它通常用于错误检测。

缺点:

• 因为它用于通过比较每个值来找出两个数据点之间的差异，所以它们必须具有相等的长度。
• 它不包含数据点的实际值/幅度。因此，当特征量起重要作用时，不建议使用。

python 中计算汉明距离的函数:

def hamming_distance(a, b):
    return sum(abs(e1 - e2) for e1, e2 in zip(a, b)) / len(a)#ORfrom scipy.spatial.distance import hamming
dist = hamming(row1, row2)
print(dist)

余弦相似性

它也是最常用的距离度量之一。它用于通过计算两个向量/数据点之间的余弦角来找出它们之间的相似性。

作者图片

为了更好地理解，如果两个向量重合或方向相同，那么它们之间的余弦相似度将为 1，如果它们完全相反，则为-1。

优势/优点:

• 适用于高维数据，应该在理想情况下用于这些数据。
• 它被用来寻找许多事物之间的相似性，如文本嵌入、图片嵌入或指纹嵌入。

缺点:

• 类似于汉明距离，在余弦相似性中不考虑向量的大小；只考虑他们的方向。

python 中计算余弦相似性的函数:

from numpy import dot
from numpy.linalg import normdef cosine_similarity(a,b):
    return dot(a, b)/(norm(a)*norm(b))#ORfrom scipy.spatial.distance import cosine
dist = 1 - cosine(row1, row2)
print(dist)

雅克卡相似性

Jaccard 相似度用于计算相似度，它强调两个有限样本集之间的相似性，而不是向量之间的相似性。它被定义为集合的交集的大小，除以这些集合的并集的大小。

作者图片

例如，如果两个集合有两个共同的实体，并且总共有 7 个唯一的实体，那么相似性将是 2/7。

优势/优点:

• Jaccard 相似性被用作评估深度学习中的图像分割模型的度量，其中模型必须对图像的每个像素进行分类。它被用来计算与地面事实相比，我们分割所需实体的准确程度。它可以类似地用于其他应用。

缺点:

• Jaccard 的相似性高度依赖于数据的大小。大型数据集会显著影响相似性，因为在这种情况下，当交集保持较低时，并集可能会大幅增加。

python 中计算 Jaccard 相似性的函数:

import numpy as npdef jaccard_similarity(x,y):
    intersection = np.logical_and(x, y)
    union = np.logical_or(x, y)
    similarity = intersection.sum() / float(union.sum())
    return similarity#ORfrom sklearn.metrics import jaccard_scoresimilarity = jaccard_score(a, b)
print(similarity)

索伦森-戴斯指数

索伦森-戴斯指数与雅克卡相似性非常相似。索伦森-戴斯指数更直观一些，因为它可以被视为两个集合之间的重叠百分比，该值介于 0 和 1 之间:

作者图片

s rensen-Dice 指数也用作图像分割的度量。

结论

在这篇博客中，我们讨论了实践中广泛使用的各种距离度量。每种度量在某些情况下是有利的，而在另一些情况下是不利的。希望这篇博客能帮助你决定哪种度量更适合你的用例。

成为 介质会员 解锁并阅读介质上的许多其他故事。

如何在 Altair 中整理条形图

原文：https://towardsdatascience.com/how-to-declutter-a-bar-chart-in-altair-e721f5c0ad87?source=collection_archive---------20-----------------------

数据可视化

关于如何通过流行的 Python 数据库提高条形图可读性的一些技巧和提示

照片由内森·杜姆劳在 Unsplash 上拍摄

最近我读了一本非常有趣的书，作者是 Jose Berengueres，书名为数据可视化简介&讲故事:数据科学家指南。在本书中，作者描述了许多从数据集中提取一个非常有趣的故事的技术。受这本书的启发，在本文中，我描述了一个在 Altair 中整理条形图并从表示的数据中提取一个故事的策略。

Altair 是一个流行的用于数据可视化的 Python 库。还有许多其他用于数据可视化的 Python 库，比如 Matplotlib 和 Seaborn。在本教程中，我将描述 Altair，留待将来分析其他数据 Viz 库时使用😃

在本教程中，我将演示如何在 Altair 中构建一个条形图，以及如何对其进行整理。

整理图表意味着删除所有不必要的东西，这些东西会分散读者获取正确信息的注意力。

作为一个用例，我利用了欧盟统计局提供的活产和粗出生率数据集。该数据集包含从 2009 年到 2020 年每个欧洲国家的活产婴儿数量。

目标是通过整理一个基本条形图，从数据中提取一些有意义的信息，重点是上一期(2019–2020)。

目录:

• 加载并清理数据集
• 条形图基础
• 数据聚合
• 最终清理

1 加载并清理数据集

我下载了。XSLX 文件和我通过read_excel()函数加载的熊猫数据帧:

import pandas as pddf = pd.read_excel('../sources/eu_live_births.xlsx', header=7, sheet_name="Sheet 1", na_values=':')
df.head(10)

作者图片

数据集非常脏，因此我通过只选择感兴趣的列来清理它。

df = df[['TIME', '2019', '2020']]
df.head()

作者图片

我将TIME列重命名为Country

df.rename(columns={'TIME' : 'Country'}, inplace=True)

然后我删除列 2020 和 2019 的NaN值

df.dropna(subset=['2020'],inplace=True)
df.dropna(subset=['2019'],inplace=True)

我删除了前六行，它们是相对于整个欧洲的:

df = df.iloc[6:]

2 建立一个基本的条形图

现在我用 2020 年的数据构建了一个原始条形图:

import altair as alt
bars = alt.Chart(df).mark_bar().encode(
    x=alt.X('2020:Q'),
    y=alt.Y('Country:N'),
)

作者图片

条形图很难阅读，因此我通过sort='-x'参数订购 DESC 棒材(使用x订购 ASC)。

bars = alt.Chart(df).mark_bar().encode(
    x=alt.X('2020:Q'),
    y=alt.Y('Country:N', sort='-x'),
)

作者图片

截断到前 10 个国家是对该条形图的唯一改进。然而，截断数据并不是理解现象的最佳解决方案。因此，我遵循另一种策略，即把国家聚合到宏观区域(或地区)。

3 数据汇总

我的原始数据集不包含任何聚合信息，因此我应该增加一个新列，包含每个国家的宏观区域。

我加载数据集:

df_regions = pd.read_csv('../sources/eu_regions.csv', sep=';')

作者图片

我定义了一个函数，它接收一个国家作为输入，并返回它的子区域。该函数还管理异常。

def get_region(x):
    south_exceptions = ['Cyprus', 'Turkey']
    east_exceptions = ['Armenia', 'Azerbaijan']
    if x in south_exceptions:
        return 'Southern Europe'
    if x in east_exceptions:
        return 'Eastern Europe'
    row = df_regions[df_regions['Country'] == x]
    return row['Subregion'].iloc[0]

现在我丰富了我的原始数据集:

df['Region'] = df['Country'].apply(lambda x: get_region(x))

作者图片

现在，我构建聚合条形图。我利用transform_aggregate()函数来计算每个区域的平均值。我要感谢Soner y ldr RM，他让我在题为 3 个例子来展示 Python Altair 不仅仅是一个数据可视化库的文章中发现了transform_aggregate()函数。

bars = alt.Chart(df).mark_bar().encode(
    x=alt.X('avg_value:Q'),
    y=alt.Y('Region:N')
).**transform_aggregate**(
   avg_value = 'average(2020)', groupby = ['Region']
)

作者图片

在比较数量时，绝对值不是最佳解决方案。因此，我计算了 2020 年相对于 2019 年的活产减少/增加百分比:

import mathdf['2020_2019'] = -(df['2020'] - df['2019'])/df['2019']

我再次绘制条形图:

bars = alt.Chart(df).mark_bar().encode(
    x=alt.X('avg_value:Q'),
    y=alt.Y('Region:N')
).transform_aggregate(
   avg_value = 'average(2020_2019)', groupby = ['Region']
)

作者图片

图表很清楚:东欧经历了最大的百分比下降。这一方面可能是要讲的故事。

4 最终清理

现在，故事已经从数据中提取出来，我可以进一步整理图表。首先，我设置了图形标题:

bars = alt.Chart(df).mark_bar().encode(
    x=alt.X('avg_value:Q'),
    y=alt.Y('Region:N')
).transform_aggregate(
   avg_value = 'average(2020_2019)', groupby = ['Region']
)**.properties(
     height = 300
)**

作者图片

然后，我把标签贴在栅栏附近:

bars = alt.Chart(df).mark_bar().encode(
    x=alt.X('avg_value:Q'),
    y=alt.Y('Region:N')
).transform_aggregate(
   avg_value = 'average(2020_2019)', groupby = ['Region']
)**text = bars.mark_text(
    align='left',
    baseline='middle',
    dx=3,
    fontStyle='bold',
    fontSize=20
).encode(
    text=alt.Text('avg_value:Q', format=",.3f")**
)final_bar = (bars + text).properties(
     height = 300
)

作者图片

我移除轴:

bars = alt.Chart(df).mark_bar().encode(
    x=alt.X('avg_value:Q', **axis=None**),
    y=alt.Y('Region:N', **title=''**)
).transform_aggregate(
   avg_value = 'average(2020_2019)', groupby = ['Region']
)text = bars.mark_text(
    align='left',
    baseline='middle',
    dx=3,
    fontStyle='bold',
    fontSize=20
).encode(
    text=alt.Text('avg_value:Q', format=",.3f")
)final_bar = (bars + text).properties(
     height = 300
)
final_bar

作者图片

我加上标题:

bars = alt.Chart(df).mark_bar().encode(
    x=alt.X('avg_value:Q', axis=None),
    y=alt.Y('Region:N', title='')
).transform_aggregate(
   avg_value = 'average(2020_2019)', groupby = ['Region']
)text = bars.mark_text(
    align='left',
    baseline='middle',
    dx=3,
    fontStyle='bold',
    fontSize=20
).encode(
    text=alt.Text('avg_value:Q', format=",.3f"),

)final_bar = (bars + text).properties(
    height = 300,
    **title = 'Percentage Decrease in Live Births (2020-2019)'**
).**configure_title(
    fontSize=24
)**

作者图片

最后，我将重点介绍一个地区(南欧)的情况:

bars = alt.Chart(df).mark_bar().encode(
    x=alt.X('avg_value:Q', axis=None),
    y=alt.Y('Region:N', title=''),
    **color=alt.condition(alt.datum.Region == 'Southern Europe', alt.value('#8B0000'), alt.value('grey'))**
).transform_aggregate(
   avg_value = 'average(2020_2019)', groupby = ['Region']
)text = bars.mark_text(
    align='left',
    baseline='middle',
    dx=3,
    fontStyle='bold',
    fontSize=20
).encode(
    text=alt.Text('avg_value:Q', format=",.3f"),

)final_bar = (bars + text).properties(
    height = 300,
    title = 'Percentage Decrease in Live Births (2020-2019)'
).configure_title(
    fontSize=24
)

作者图片

摘要

在本文中，我举例说明了一个在 Altair 中整理条形图并使其可读性更好的实例。清理需要以下操作:

• 为初步数据探索构建一个基本条形图
• 聚合数据，如果聚合数据不可用，则搜索另一个数据集
• 绘制聚合数据并提取故事
• 通过删除轴、添加标题和突出显示文章，执行最终的整理。

如果你已经走到这一步来阅读，对我来说，今天已经有很多了。谢谢！你可以在本文中读到更多关于我的信息。

相关文章

如何减少数字通信的碳足迹

原文：https://towardsdatascience.com/how-to-decrease-the-carbon-footprint-of-digital-communication-f3186673818c?source=collection_archive---------14-----------------------

蜜琪拉·威登霍夫在 Unsplash 上拍摄的照片

利用系统动力学评估电子邮件行为对温室气体排放的影响

介绍

如今，通过数字工具交流是非常正常的。我们有与朋友聊天的社交媒体平台，进行工作面试的视频电话服务，当然，还有传统的电子邮件。有人会认为通过电子邮件发送信息是使用实体信件的“绿色替代方案”。当然，我们会考虑从 A 地到 B 地运输过程中的二氧化碳排放，我们也知道造纸所需的砍伐树木对环境的负面影响。那么，就气候中立信息共享而言，电子邮件是圣杯吗？本文将通过回顾电子邮件的碳足迹，讨论电子邮件数据结构的重要性，并对电子邮件行为如何影响二氧化碳排放进行实验，来发现这个问题。这篇文章的新颖之处在于，我们将量化电子邮件行为对碳足迹的影响。为此，我们将应用模拟技术系统动力学。

电子邮件的碳足迹

电子邮件背景

电子邮件导致的温室气体排放

已经有很多关于电子邮件中二氧化碳排放的文章，它们经常提到同一个来源:“香蕉有多糟糕？”:万物的碳足迹”，发表于 2010 年，作者是碳足迹研究者、万维网发明者蒂姆·伯纳斯·李的兄弟迈克·伯纳斯-李。该研究对电子邮件进行了分类，并对每封邮件的平均排放量进行了如下描述:

1)垃圾邮件:0.3 克二氧化碳

2)普通邮件:4g 二氧化碳

3)带附件的邮件:50g CO2

这些二氧化碳成本主要是由运行电子邮件设备所需的能源引起的，这些设备为网络基础设施供电，必须访问网络基础设施以传输电子邮件，以及存储内容的数据中心【3】。根据 Berners-Lee 的数据，我们还可以推断电子邮件的大小会影响二氧化碳的排放量:电子邮件越大，排放的二氧化碳就越多。2021 年，我们在全球每天收发的电子邮件数量约为 3200 亿封，预计这一数字还会进一步增加【4】。虽然垃圾邮件看起来不太受气候影响，但我们需要考虑与普通邮件相比垃圾邮件的数量。下面我们重点来揭晓几个国家每日发送邮件【6】的比例:

1)美国:96 亿封邮件(总量)，86 亿封邮件(垃圾邮件)。

2)德国:90 亿封电子邮件(总量)，79 亿封电子邮件(垃圾邮件)

3)中国:87 亿封电子邮件(总量)，85 亿封电子邮件(垃圾邮件)

4)英国:86 亿封电子邮件(总量)，77 亿封电子邮件(垃圾邮件)

5)俄罗斯联邦:84 亿封电子邮件(总计)，81 亿封电子邮件(垃圾邮件)

由于这些国家和其他几个国家一样，是全球电子邮件统计的领导者，我们可以计算加权平均值来表示全球电子邮件流量中垃圾邮件的百分比:92%。进一步的研究得出的结果是，大约 24%的商务邮件有附件。

有了这些数据，让我们来推断一下全球电子邮件的年二氧化碳排放量(我们接受四舍五入):

• 每年发送的电子邮件数量= 3200 亿 x 365 天= 117.8 万亿
• 每年发送的垃圾邮件数量= 117.8 万亿* 0.92 = 108.4 万亿
• 每年发送的常规电子邮件数量= 117.8 万亿* 0.08 * 0.76 = 7.2 万亿
• 每年发送的带附件的电子邮件数量= 117.8 万亿* 0.08 * 0.24 = 2.3 万亿

使用这些结果，我们现在可以计算每种电子邮件类型的年度二氧化碳排放量，如下表所示:

每种电子邮件类型的电子邮件数量和二氧化碳排放量(图片由作者提供)

这导致二氧化碳总排放量约为 1.763 亿吨。相当庞大的数字——为了让它更有形，我们可以将其转化为 2120 万个家庭一年的能源消耗，甚至 21 万亿部智能手机充电；或者说得更具体一点:相当于汽车【8】行驶了 4423 亿英里，这甚至比全德承认的所有汽车一年的行驶里程还要多(3767 亿英里【9】)。然而，如果我们将其与 2020 年全球化石燃料的二氧化碳排放量(近 350 亿吨【10】)相比较，我们的电子邮件仅占温室气体排放量的 0.5%。尽管如此，我们可以清楚地声明，电子邮件并不像许多人预期的那样对气候没有影响。

大型电子邮件的驱动因素

在我们评估减少二氧化碳排放的手段之前，我们希望了解电子邮件的数据结构以及它通常包含哪些类型的信息。基本上，一封电子邮件由三部分组成:信封、标题和正文。信封封装了消息，并包含发送电子邮件所需的所有信息。典型的信息是目的地地址、电子邮件优先级及其安全级别。标头由与消息传输相关的字段组成，如“收件人”、“抄送”或“发件人”。每个头字段指的是指定字段名、冒号和值的一行 ASCII 文本。消息的主体部分包含发送者感兴趣的实际内容。它通常由文本、签名和附件【11】组成。考虑到这些因素，我们可以暗示正文是邮件大小的主要驱动因素。所以让我们仔细看看尸体。

电子邮件的数据格式

影响体型的不仅仅是纯粹的核心信息量。在专业邮件客户端应用程序中，您可以选择正文的格式，这也会影响大小，如下图所示(来自 MS Outlook 的截图)。

MS Outlook 中的格式选项(图片由作者提供)

为了评估数据格式对电子邮件大小的影响，我创建了一个样本邮件，其中包含称呼、问候、一些“lorem ipsum”内容和我当前公司的签名。然后，我改变了一些文字格式，例如粗体和彩色。最后，我将邮件作为文件保存到我的电脑上，但不是一次而是多次以不同的格式保存。首先，我使用了“HTML”格式，这需要 39 KB。然后，我使用了“富文本”格式，需要 66.5 KB。最后，我使用了“纯文本”格式，这需要 19.5 KB。因此，我们可以得出结论，我们有三种不同的消息大小，尽管正文内容完全相同(除了格式，纯文本丢失了)。此外，如果我删除我的签名，我可以进一步减少电子邮件的大小。当然，我们谈论的是大数据时代的千字节。但是当我们将这些结果放在一起时，我们可以看到格式(和签名使用)之间的百分比差异非常显著(见下表)。因此，即使我们不减少电子邮件的数量，我们也可以通过减少网络流量和存储消耗来影响全球二氧化碳排放量，同时保持共享相同的信息。当然，这种论证建立在电子邮件的成熟度是 HTML 格式的假设之上，这是我观察到的，尤其是在商业环境中，但在私人领域接收时事通讯或广告时也是如此。不幸的是，我找不到一个可靠的研究来量化使用电子邮件格式的百分比。

邮件格式对邮件大小的影响(图片由作者提供)

电子邮件附件

大邮件的另一个驱动因素是附件的使用。在早期，只需通过电子邮件发送文件副本，就可以与收件人共享文档，这非常有用。一方面，这是一种让公司以外的人访问该文件的简单方法。另一方面，简单地拖放副本也比发送指向内部文件共享的链接并验证此人是否有访问权限更方便(这通常需要管理文件共享的 it 专家的帮助)。如今，共享集中存储的文件变得更加容易，甚至与外部团体也是如此。主要基于云的专业办公软件套件，例如微软 365【12】和谷歌工作空间【13】，提供了自己轻松管理文件访问的功能，甚至将访问权限授予外部合作伙伴。有了这些功能，实际上不再需要将文件副本作为电子邮件附件发送。此外，如果发送的是副本而不是原始文件的链接，也会有一些缺点。例如，如果您在发送电子邮件后发现文档中有打字错误或更大的问题，您仍有机会更新原始文档，收件人将通过链接访问更新后的原始文件。但是，如果你发送了文件的副本，你就必须再次发送修改过的文件，并指出你的错误。共享链接而不是副本的另一个好处是能够协作处理同一个文件。此外，后台的文档管理系统通常关心版本控制。因此，如果任何贡献者犯了错误，您可以简单地恢复以前的版本。这种协作方式还消除了发送和存储同一文件的多个版本的需要，如 File_V1、File_V1.9、File_final_REALLY_2 等

电子邮件行为对碳足迹的影响

我们已经回顾了电子邮件的二氧化碳排放量，并讨论了导致大邮件的驱动因素。在本节中，我们想评估如果我们改变这些驱动因素，二氧化碳排放量会发生什么变化。为此，我们将应用系统动力学(SD)作为模拟技术，使用 AnyLogic 作为建模软件。这一选择的主要原因是，当在单代理活动不相关的更大规模上处理连续效果流时，SD 是非常强大的。SD 的数学基础是微积分。

实验描述

让我们从基于每日发送邮件的基本费率开始，总结在下表中。

每日邮件费率(图片由作者提供)

下图展示了我为进行实验而开发的 SD 模型。它区分电子邮件类型(垃圾邮件、普通邮件、附件)以及普通电子邮件的格式。股票变量计算一段时间内电子邮件的数量，而黄色变量计算每种电子邮件(子)类型的二氧化碳排放量。红色变量将单个排放量相加，得出一年内电子邮件的总二氧化碳排放量。

系统动力学模型(图片由作者提供)

接下来，我们想进行一些实验，这些实验涉及以下问题:

1)如果我们经常从 HTML 邮件中删除我们的签名会怎么样？

2)如果我们少发带签名的 HTML 邮件，多发纯文本邮件会怎么样？

3)如果我们在电子邮件中发送更多的文件链接而不是附件，会怎么样？

4)如果我们减少我们发送的电子邮件的收件人数量会怎么样？

不幸的是，我找不到一份说明有多个收件人的电子邮件比例的研究。因此，我需要做一些假设。让我们假设，特别是在商业环境中，我们经常向多个收件人发送邮件。至少我经历过，人们经常把他们的经理或其他感兴趣的人放在 CC，而不期望他们有任何行动。所以，这样的邮件对他们来说是一种“零信息”。而且“收件人”的选择往往没有意义。取而代之的是，现有的邮件列表被重新用来传播只影响部分收件人的信息。所以我想构建的是下面的情况:

• 有一定比例的全球电子邮件流量是由同一封电子邮件发送给多个收件人造成的。
• 通过限制电子邮件收件人，有可能降低这一比例。

在我的实验中，我假设 30%的电子邮件流量是由这种效应引起的。此百分比适用于普通电子邮件以及带附件的电子邮件。然后，我将通过场景 1(节省 10%的电子邮件)和场景 2(仅通过减少不相关的电子邮件收件人来节省 30%的电子邮件)来研究电子邮件流量的减少。

结果

下图显示了单个实验的结果，并设置了它们之间的关系。蓝线指的是原始的电子邮件产品，当然，在图表的顶部。我们清楚地看到，附件的减少(橙色线)对二氧化碳排放的影响最大。

电子邮件行为对全球二氧化碳排放量的影响(百万吨)

现在，让我们关注我们的潜在杠杆对全球二氧化碳排放的特殊影响。我们需要考虑之前计算的年度 CO2 排放量(1.76 亿吨)与 SD 模拟(1.69 亿吨)不同。这是因为我估计“常规”邮件 80%是 HTML，20%是纯文本。由于纯文本邮件排放的二氧化碳较少，模拟的年总排放量低于之前简单计算的结果。表格显示，将带有附件的电子邮件数量减半，用带有链接的 HTML 电子邮件取而代之，可以减少 30%的二氧化碳排放量。电子邮件收件人减少 30%将节省 6.9%的二氧化碳成本，而减少 10%将节省 2%。使用纯文本而不是 HTML 可以减少 5%的温室气体排放。签名的去除具有最低的影响，至少减少 0.4%的 CO2 排放。

测试杠杆的结果比较(图片由作者提供)

幸运的是，我们还可以计算电子邮件导致的二氧化碳排放的绝对减少量，这也显示在表格中。同样，为了对这些数字有更好的感觉，让我们搜索一下日常生活中我们都知道的对应词:

• 减少带有附件的电子邮件将会减少相当于1000 万辆汽车 驾驶一年的二氧化碳排放量。
• 当我们只减少 10%的接收者时，我们将节省相当于4120 亿部智能手机充电的温室气体排放量。
• 即使是最后一个杠杆，我们减少 50%的电子邮件签名，也会产生积极的环境影响，相当于 148 个风力涡轮机运行一整年。
• 如果我们采取所有这些措施，我们将减少二氧化碳排放量，相当于 100 万辆油罐车的汽油排放量。

正如我们之前指出的，全球电子邮件流量预计将进一步增加，百分比减少将在未来节省更多的绝对二氧化碳排放量。

结论

我们已经看到，电子邮件并不像预期的那样对气候没有影响。但相反，电子邮件数据结构中不必要的开销产生的数字垃圾会排放大量的二氧化碳。有许多杠杆可以显著影响排放，尤其是使用连杆代替附件。但其他一些更琐碎的行为，比如避免巨大的电子邮件签名，也会对温室气体排放产生显著影响。当然还有更多可能的手段，我们在本文中没有涉及，比如删除对商业或私人目的不再重要的旧邮件。关键信息是，不花钱就能节省二氧化碳排放相当容易——只要调整我们人类的电子邮件行为就能实现。可以进行进一步的研究，以评估应用我们在本文中分析的杠杆的系统措施的技术发展或组织。

【1】https://wirtschaftslexikon . gabler . de/definition/e-mail-33576

【2】https://www . FAZ . net/aktuell/technik-motor/digital/ray-Tomlinson-der-er finder-der-email-ist-tot-14109850 . html

【3】https://www . BBC . com/future/article/2020 03 05-why-your-internet-habits-is-as-clean-as-you-think

【4】https://de . statista . com/statistik/daten/studie/252278/umfrage/prognose-zur-zahl-der-tae glich-versendeter-emails-weltweit/

【5】https://www . statista . com/statistics/1270488/spam-emails-sent-daily-by-country/

【6】https://www . statista . com/statistics/1270459/daily-emails-sent-by-country/

【7】https://medium . datadriveninvestor . com/email-attachments-generate-near-6-000-needly-and-unsecure-files-per-employee-per-year-year-a 38385 bec 7 a 4

【8】https://www . EPA . gov/energy/green-gas-equivalences-calculator

【9】https://www . kba . DE/DE/Statistik/Kraftverkehr/verkehr 千米/vk _ inlaenderfahrleistung/vk _ inlaenderfahrleistung _ node . html；jsessionid = 3680 DFA 2 faf 0d 0754 d8e 522 Fe 14 cc1 e . live 21321

【10】https://ourworldindata.org/co2-emissions

【11】https://www.geeksforgeeks.org/e-mail-format/

【12】https://365 tips . be/en/share-files-in-office-365-best-practice/

【13】https://support.google.com/a/users/answer/9296687?hl=en

【14】https://www . ener guide . be/en/questions-answers/do-I-emit-CO2-when-I-surf-the-internet/69/

如何用代码定义和部署基础设施

原文：https://towardsdatascience.com/how-to-define-and-deploy-infrastructure-with-code-c5af4bddc566?source=collection_archive---------37-----------------------

Pulumi 是 Terraform 和 CloudFormation 的替代产品，它允许您使用自己喜欢的编码语言定义 AWS(以及其他服务，如 Azure 和 GCP)服务。

探索 Pulumi CLI

普鲁米简介

Pulumi 允许您通过结合 IaaS(基础设施即服务)的安全性和可靠性以及您所熟悉的编程语言的能力来构建云应用和基础设施。您可以使用自己选择的编程语言来定义基础设施，使用循环、条件和函数，并在不同的项目中重用这些设计模式，而不是使用 JSON、YAML 或定制的 IaaS 语言来定义基础设施。例如，下面是我们如何使用 Terraform HashiCorp 配置语言创建一个带有已分配安全组的 EC2 实例:

Terraform:使用分配的安全组创建 Ubuntu 18.04 实例

相比之下，下面是我们如何使用 Pulumi JavaScript AWS API 完成类似的任务:

Pulumi (AWS JS API):使用分配的安全组创建一个 Ubuntu 18.04 实例

如您所见，使用 Terraform 和 Pulumi 创建资源的总体逻辑是相似的。您可以过滤正确的 Amazon 机器映像，定义符合您的用例的定制安全组，将标记应用到您的资源，并基于这些 ami 和安全组定义服务器。主要区别在于创建资源的语言，对于您的用例来说，最好的工具可能取决于您对 HashiCorp 配置语言或 JSON (Terraform)以及更多通用编码语言的熟悉程度，如 Python 、 JavaScript 、 Go 和 C# (Pulumi)。

问题的介绍

作为一名软件工程顾问，很多时候我需要为公司部署一次性项目(供内部或外部使用)。在这些部署过程中，我通常会重复相同的过程:

1. 创建一个临时服务器，
2. 创建一个生产服务器，
3. 在两台服务器上安装必要的依赖项，
4. 允许准备和生产服务器相互连接，
5. 并为部署配置生产环境

以前，我会用 AWS 命令行或 AWS EC2 web 界面逐一完成这些步骤。但是，在我第二次手动完成这些任务后，我决定投入时间学习云形成、地形和普鲁米。在意识到 Pulumi 提供了最少的入门障碍(因为与 JSON 和 YAML 相比，我更熟悉 JavaScript 和 Python)之后，我决定使用它来自动化这些重复的部署过程。

我如何使用 Pulumi 来解决这些问题

在阅读了 pulumi 的 AWS 文档和一些教程之后，我安装了 Pulumi 命令行工具:

**brew install pulumi** # mac

然后为这个项目创建了一个目录，换成它，并运行:

**pulumi new aws-javascript** 
# aws tells pulumi we want to use the AWS Pulumi API
# javascript tells pulumi we want to use the JS AWS API

最后，编写代码前的最后一步是确保设置了正确的 AWS 概要文件。要配置 AWS 概要文件，请运行:

aws configure --profile "[name for profile]"

然后，输入正确的访问密钥 ID 和秘密访问密钥并运行:

aws use [name for profile]

为项目选择正确的 AWS 概要文件。从这里，打开 index.js 并开始定义您的基础设施。对于我的具体用例，我想创建两个服务器，一个用于试运行，另一个用于生产。我还希望它们存在于同一个 VPC 中，具有相同的安全组。为了实现这一愿景，我将代码分成了四个部分:

1.从 pulumi 访问配置变量

类似于为项目创建环境变量， pulumi 配置变量允许您定义可以在 pulumi 脚本中访问的特定于项目的值。对于我的具体用例，我想对 PEM 文件的名称保密，所以我使用以下命令创建了一个 keyName 配置变量:

**pulumi config set keyName [name_of_PEM_file]**

有了这个配置变量集，我就可以在我的 pulumi 脚本中访问分配给 keyName 的值，使用:

**const pulumi = require("@pulumi/pulumi");
const config = new pulumi.Config();
const keyName = config.get("keyName");**

2.过滤并检索正确的 AMI ID

在这之后，我需要过滤 Amazon 机器映像注册表，找到我想要创建的服务器的 AMI 名称和所有者。对于这个项目，鉴于我想使用 Ubuntu 18.04，我采取了以下步骤:

• 导航到 AWS EC2 主页，点击实例，然后点击启动实例

AWS EC2 例程页

• 滚动到您想要创建的实例，复制 AMI ID

Ubuntu 18.04 的 AMI ID

• 导航回 EC2 仪表板主页面，点击左侧边栏图片部分下的 AMIs 。

• 在搜索栏中，粘贴您复制的 AMI ID ，并记下 AMI Name 和 Owner 的值。您将需要这两个值来过滤 pulumi 中的正确 AMI。

有了 AMI 名称和 AMI 所有者之后，您可以将这两个值输入到您的脚本中，如下所示:

过滤正确的 AMI: Ubuntu 18.04

3.定义服务器的安全组，包括入站和出站规则

在正确筛选出正确的 AMI ID 后，您可以为您的服务器定义安全组。以下脚本提供了一个简单的例子:

在第一行，我们将我们的安全组命名为 3dvation-grp 。然后，我们定义入站(入口)和出站(出口)规则。在第 3–9 行，我们提供了入站规则的描述，定义了其协议，提供了一系列端口，最后定义了允许该入站规则的 IP 地址。然后，在第 12–27 行，我们定义了两个出站规则:

1. 允许临时服务器 ssh 到生产服务器的出站规则(通过端口 22 ssh)
2. 允许克隆 GitHub 库的出站规则(端口 43 上的 HTTPS，CIDR 块基于来自api.github.com/meta的 git 结果)。

总之，这些入站和出站规则为我们的两个实例提供了这个特定用例所需的所有功能。

4.定义和创建试运行和生产 EC2 实例

最后，在定义了安全组之后，我们使用以下代码创建了临时服务器和生产服务器:

在第 2 行和第 9 行，我们将**serverSize**("*T2 . micro "*)常量赋给 **instanceType** 键。在第 3 行和第 10 行，我们将新创建的安全组的 ID 分配给两台服务器(确保它们存在于同一个组中)。然后，在第 4 行和第 11 行，我们定义了可以用来访问每个服务器的 **PEM** 文件的名称，在第 5 行和第 12 行，我们分配了应该用来创建每个服务器的 AMI 的 ID。

完成这些步骤后，您可以运行:

pulumi up

部署更改并创建临时服务器和生产服务器。一旦这个过程成功完成，您就可以登录 AWS 并看到您的两个新服务器！

审查和成果

在本文中，我们了解了 Pulumi 及其相对于 AWS CloudFormation 和 Terraform 等其他 IaaS 提供商的一些优势。我们经历了一个实际的用例，在这个用例中，我们为两台服务器创建了一个 VPC，定义了安全组的入站和出站规则，然后创建了试运行和生产 EC2 实例。

电子邮件:danielmurph8@gmail.com

领英:【https://www.linkedin.com/in/dmurphy1217/

如何删除熊猫中的一个栏目

原文：https://towardsdatascience.com/how-to-delete-a-column-in-pandas-cc4120dbfc25?source=collection_archive---------14-----------------------

从 pandas 数据框架中删除列

照片由夏羽·亚伊奇在 Unsplash 上拍摄

介绍

从 pandas 数据帧中删除列是一项相当常见的任务。在今天的简短指南中，我们将探讨如何通过名称删除特定的列。更具体地说，我们将讨论如何使用以下命令删除列:

• del命令
• drop()方法
• pop()法

此外，我们将讨论如何通过指定索引而不是名称来删除列。

首先，让我们创建一个示例 pandas 数据框架，我们将在本指南中使用它来演示一些概念。

import pandas as pd df = pd.DataFrame({
    'colA':[1, 2, 3], 
    'colB': ['a', 'b', 'c'],
    'colC': [True, False, False],
})print(df)#    colA colB   colC
# 0     1    a   True
# 1     2    b  False
# 2     3    c  False

使用 del 删除列

如果您想要删除特定的列，您的第一个选项是调用如下所示的del:

**del df['colC']**print(df)#    colA colB
# 0     1    a
# 1     2    b
# 2     3    c

只有当您希望删除一列时，这种方法才有效。如果您需要一次删除多个列，请阅读以下部分。

另外，需要注意的是del df.colCT16 不能用！语法必须与上面示例中显示的语法相同。

使用删除多个列。丢弃()

[pandas.DataFrame.drop](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.drop.html)方法用于从行或列中删除指定的标签。

为了删除列，您需要指定如下所示的axis=1:

**df = df.drop(['colA', 'colC'], axis=1)**print(df)#   colB
# 0    a
# 1    b
# 2    c

注意，如果您想删除列，而不必将结果重新分配给df，您需要做的就是将inplace指定给True:

**df.drop(['colA', 'colC'], axis=1, inplace=True)**

使用删除列。流行()

另一个选项是[pandas.DataFrame.pop](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.pop.html)，它返回被删除的列，并最终将其从原始数据帧中删除。

**df.pop('colB')**

将返回我们希望从 DataFrame 中删除的列colB:

0    a
1    b
2    c

我们可以验证该列确实已经从原始框架中删除:

print(df) colA   colC
0     1   True
1     2  False
2     3  False

按索引删除列

在上面的小节中，我们探讨了如何通过名称删除特定的列。但是，您可能还需要通过引用特定列的索引来删除该列。

为此，可以使用[pandas.DataFrame.drop](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.drop.html)方法。假设我们想要删除索引分别为0和2的列colA和colC，我们可以这样做，如下所示:

**df.drop(df.columns[[0, 2]], axis=1, inplace=True)**

最后的想法

在今天的简短指南中，我们探讨了如何通过名称或索引以各种方式删除 pandas 数据帧中的特定列。

您可能也对阅读如何重命名熊猫数据帧的列感兴趣。如果是这样，请不要错过下面的文章。

此外，下面的文章讨论了如何根据特定条件执行正确的行选择。

如何在 R 中删除你保存的工作空间

原文：https://towardsdatascience.com/how-to-delete-your-saved-workspace-in-r-699c45c3304a?source=collection_archive---------27-----------------------

清理你无法摆脱的工作空间

当您退出 RStudio 时，您会看到一个弹出窗口，询问“将工作区图像保存到~/。RData？”如果你不确定，你可能会选择保存。毕竟，它是的默认。另外，储蓄是好事。对吗？

退出 R 会话弹出窗口。图片作者。

嗯……这要看情况。下次加载 RStudio 时，工作区(全局环境)中的所有内容都将保持原样。如果将数据加载到 R 中花费了很长时间，那么这就太棒了。不用再经历那个繁琐的过程了！唷！

但是如果，相反，你有一堆你不想再看到的无用的垃圾呢？你可能会想，好吧，我就清空我的工作空间，继续工作。只是这一次，在我 R 会话结束的时候，我会点击 不保存 。没什么大不了的！

下一次你加载 RStudio 时，那个你以为已经删除的讨厌的工作区将会恢复到以前的辉煌。你再试试——清除，退出，不保存，加载。*等等，什么？？？*这次- rm(list = ls())，退出，不保存，加载。但是……为什么？！

JESHOOTS.COM在 Unsplash 上拍照。

通过保存工作空间，R 将全局环境保存为。RData 文件。每次启动 R 时，这些文件都用来恢复您的工作区。删除您的工作环境实际上并不会删除。RData 文件-它们还在那里。这就是为什么你可以清空你的工作空间，以为它永远消失了，却发现它在你下次启动 r 时又弹出来了。

清理你无法摆脱的工作空间

如果你发现自己有这个问题，不要担心！这里有一个解决方案。事实上，不止一个！快速而肮脏的选择是清空你的工作空间，退出，然后选择保存。这一次，R 将保存一个空的工作区，下次重启 R 时将重新加载它。

第二个选项是运行:unlink(。RData”)。这实际上不会删除您的环境，但会删除保存的。RData 文件。如果没有保存的文件，启动时就没有任何东西可以加载。只要确保不要再点击保存，否则你就只能写新的了。RData 文件，您必须再次删除它们。

调整您的设置

如果您认为自己近期内不需要保存工作区，那么您可能希望 R 停止询问这个问题。这可以通过全局选项菜单的常规选项卡进行更改。要导航到全局选项菜单，从 RStudio 的菜单栏中选择工具(位于最顶端)。全局选项可以在工具菜单的最底部找到。

查找全局选项菜单。图片作者。

点击全局选项后，会出现一个选项框。在常规选项卡下，您应该会看到一个工作区部分。如果你有。RData 文件，但不希望每次启动 R 时都加载它们，可以取消选中“Restore”旁边的复选框。启动时将数据存入工作区。或者，如果您不想在关闭 RStudio 时保存您的工作空间，请从“保存工作空间至”旁边的下拉菜单中选择从不。出口处的 RData。既然 R 知道了你的偏好，它就不会再问你是否愿意保存了！

选项框。图片作者。

有了这些解决方案，希望您保存的工作空间将一去不复返。再见永不，工作区！👋

原载于 2021 年 6 月 17 日https://thatdarndata.com。

如何交付成功的数据演示

原文：https://towardsdatascience.com/how-to-deliver-a-successful-data-presentation-bfd23684197d?source=collection_archive---------48-----------------------

我从向高层领导做报告中学到的经验

图片由皮克斯拜的 Gerd Altmann 提供

在您的数据分析职业生涯中，可能会有这样一个时刻，您需要向高层领导展示您的数据结果。这将是一个关键的时刻，因为一个成功的演示会给公司内参与批准你的薪酬和晋升的人留下永久的印象。当我成为一名数据科学家，然后成为一名数据分析师时，我不得不从反复试验中学习如何有效地展示。幸运的是，我的演示从来不是一场灾难，但如果我知道我现在在做什么，它会更好。今天，我想和大家分享我的建议，告诉大家如何进行成功的数据演示，以提高你在高层领导中的知名度。

提供解决问题的方法

围绕演示主题研究高层领导提到的问题，并尝试找到提供解决方案的数据见解。高管们一直在努力提高业务绩效，任何能提供问题解决方案的人都会引起他们的注意。

例如，您是一名数据分析师，为一家电子商务公司的营销提供支持。年复一年，销售额一直在下降，你被要求调查原因，并将你的发现提交给高层领导。你会发现，将网站访客按渠道分类后，销售额下降是因为有机搜索占了总销售额的 50%。经过进一步的调查，访客下降对应的网站变化发生在同一天。一旦网站修好，销售额应该会再次上升。找到原因并为销售等重要 KPI 提供解决方案，会让高层领导注意到你，并在下次谈话中提到你的名字时在他们的脑海中留下好印象。

将影响转化为收入

讨论收入时，高管们会注意到。即使 KPI 提高了 1%,也可能转化为数百万美元。如果百分比变化不理想，计算您提出的任何建议对收入的影响。

例如，您是一名移动应用程序的产品分析师，被要求向高层领导提交价格上涨测试的结果。最有可能的是，你会报告相对于控制的转化率较低，因为每当你提高价格，转化率下降，因为人们不太可能为同样的产品支付更多。给高层领导的演示应该少关注价格的下降，多关注价格上涨带来的销售增量。如果转换率和增量销售都是负数，那么就没有什么好故事可讲，建议应该是保持在当前价位。然而，如果转换率下降，但销售额增加，那么就应该采用新的价格。不管测试结果如何，显示您考虑了多个 KPI 来提出建议，向高层领导表明您从不同的角度评估了结果。

提供建议

优秀的数据分析师提供可操作的见解来推动业务绩效。即使没有问题，您也可以提供下一步建议来改进业务 KPI。

在价格测试的例子中，让我们假设提高价格不会导致更高的转化率或增加销售额。如果目标是增加销售，有很多不需要提高价格的方法。你可以建议改变应用程序，以提高转化率或测试限时折扣优惠。领导层喜欢有能改善业务的想法的人，展示这种主动性表明了你帮助业务增长的热情。

进行一次练习

如果可能的话，先和你的利益相关者进行一次练习，以获得反馈。利益相关者提出的问题通常也是高层领导提出的问题，这将让你有机会在实际演示之前研究答案。如果不可能进行一次练习，让利益相关者回顾一下内容，确认你要表达的观点是清楚的。在向 CDO(首席数字官)做演示之前，除了练习之外，我还开会审查了内容。最终的结果是一个很棒的演示，如果没有反馈，我自己是无法完成的。

表现出自信

向高层领导陈述可能会让你恐慌。不幸的是，除了经常练习演讲，我没有找到克服紧张的方法。我越了解我的演示材料，我就越容易向他人演示。如果你紧张，这不是世界末日。向高层领导提供有价值的、可操作的见解有助于他们对你有一个积极的看法。

知道如何有效地呈现数据结果是数据分析角色的一项重要技能。我花了很多尝试和错误来学习如何做一个伟大的演讲，但是有了这些建议，我希望你能尽快成功。

你可能也会喜欢…

如何交付人工智能管道

原文：https://towardsdatascience.com/how-to-deliver-an-ai-pipeline-9c6fbfc29d3b?source=collection_archive---------18-----------------------

实践教程

一步一步，从想法到生产

通往完整数据管道的道路漫长而曲折。由罗迪翁·库察耶夫在 Unsplash 上拍摄的照片

人工智能市场正处于成长期。在建模和工程中，技术栈正在成熟，过程正在成形。这确实是一个成为数据科学家/工程师的美好时代:乘着早期的浪潮，帮助创建其他人将在未来几十年遵循的模式。每个人都提出了自己的解决方案来部署他们的 ML 特性。

本文旨在通过一个直接来自烤箱的真实示例，对我们的项目流程进行演练，重点关注数据科学/工程流程。我们希望你能挑选一些我们使用的技术，并将它们整合到你自己的队伍中！

蓝图

在进去之前，我们需要讨论一下过程本身。人工智能项目的实施涉及三个主要的能力层次:数据科学、数据工程和前端。

我们人工智能特征过程的蓝图。图片作者。

一切从一个想法开始。公司里的某个人有了灵感，这种火花被写进了一份文件，用通俗易懂的语言重新开始。数据科学团队将该文档编译成一个摘要，展示我们如何解决该问题并执行它。我们的前端团队可以开始创建实体模型，让我们的利益相关者体验一下这个抽象的特性会是什么样子。这种快捷方式使得证明特性的影响更加容易。

该摘要然后被用作临时分析的基础，自由式建模以测试和证明该抽象想法有价值。Jupyter 和 Excel 表格比比皆是。在这个阶段，没有什么是一成不变的，也没有什么是合理设计的，因为在处理 ML 时，自由是创新的关键。

如果临时分析成功，我们将继续进行概念验证阶段。这是将前一阶段找到的解决方案工程化的第一步:代码将尽可能接近具有适当封装和质量的产品代码。它可以被认为是我们管道内模型的试驾，调整后视镜和座椅角度。与此同时，我们的数据工程团队开始绘制它在我们当前架构中的样子，计划 PoC 如何进入我们的管道。

概念证明经过适当的测试和评估后，我们让数据科学团队去从事其他项目。现在，数据工程将开始将 PoC 的集成到管道，前端团队可以使用 PoC 的输出来创建真实数据原型。

两个团队都准备好了，是时候将所有东西整合到最终产品中了。我们用生产原型测试它，然后通过淘汰旧版本来确认它。瞧。

现在，让我们看看这个过程是如何在一个新的命名实体识别特性上工作的！

这个想法

我们仪表板的一个基本块是方面分析。我们从非结构化的用户生成的文本内容中提取代表产品或服务属性的实体，从句子中提取它们的相对情感，并使用我们的定制分类法对它们进行汇总。

方面术语“崩溃”和“视频”被提取为方面，然后被分类为负面的。与问题相关的术语通常是负面的。图片作者。

这种类型的分析是非常细粒度的:方面通常由 1-3 个标记组成。我们没有得到问题的全部背景:我们提取了问题的核心(崩溃)和根源(视频)。

所以，解决的办法是立刻识别和提取整个东西。

提取整个句子。图片作者。

我们一个 RFC 的标题。摘要由多个队友审阅，人们在文本中进行评论，内容随着异步输入而不断发展。图片作者。

https://github.com/rust-lang/rfcs https://www.infoq.com/news/2017/12/react-rfc-process/

我们的 RFC 有一个特定的结构:

• 待解决问题的背景；
• 问题定义；
• 提出的解决方案以及架构/建模建议**；**
• 所解决问题的成本和收益；
• 成功的定义描述 RFC 实现结束时产生的工件。

这个特定想法的(非常)简短的 RFC 如下所示:

背景:方面太细，不能识别关于特定问题的上下文短语。

目标:从句子中提取问题(代表用户在使用产品时遇到的问题的多标记字符串)。

可能的解决方案:自定义 NER，使用 spacy | Tensorflow | PyTorch、gensim Phraser，后跟分类器、语法分析，找到问题的根源。

**成本和收益:**一个月用于模型开发，另一个月用于管道集成和原型开发。两名数据科学家，一名工程师和一名前端开发人员。

成功的定义:将提取器集成到管道中，分析结果显示在最终产品中。

验证标准

有了目标，我们开始计划如何实现。在项目进行到一半时，我们如何知道我们“足够好”呢？或者“到达那里”实际上是否可行？像这样的探索性任务可能需要几个月的来回互动，测试新的想法，提出新的问题和新的解决方案…突然你陷入了一个循环，甚至忘记了项目的意义。

设定一个停止探索问题并继续前进的期限是必要的。在这个想法探索阶段之后，我们应该很好地掌握我们需要考虑的变量。我们需要有标签的数据吗？多少钱？有我们可以使用的实现模型吗？类似项目的绩效如何？

验证阶段是 RFC 创建过程的一部分:在进入 ML 模型的本质之前，作者必须考虑项目的截止日期和完成的定义。一个简单的时间盒将帮助团队相应地安排任务，交付的定义将指导您的工作。

我们在这里做的是以产品为中心的交付:我们对成功的定义是将问题提取器集成到我们当前的管道中，并在最终产品中显示分析结果。没有准确性，没有度量，没有绒毛。这意味着我们对架构本身的创建感兴趣，而不是增强一个模型。

下面有一个关于数据项目管理的有趣阅读链接。最佳 Scrum 实践部分有一些关于项目边界的信息。

https://neptune.ai/blog/data-science-project-management-in-2021-the-new-guide-for-ml-teams

即席建模

自由式建模:只是一个(关键)板和一个梦想。照片由雅各布·本辛格在 Unsplash 上拍摄

RFC 获得批准，我们开始开发土地。第一站是特别建模:在我们通常的架构之外的建模工作，可以使用任何可用的工具来快速交付明显的结果。对于一些公司来说，这是通常的数据科学工作的范围，由软件和数据工程师来实现。

我们采用 OSEMN 框架来管理流程的这一步:获取、清理、探索、建模、解释。此即席分析的输出将是一个问题提取模型，其中包含一份关于提高其准确性和召回率的可能方法的报告。

</5-steps-of-a-data-science-project-lifecycle-26c50372b492>

让我们在项目的背景下讨论这些阶段。

• **获取:**我们的输入是用户生成的数据。由于我们已经有了一个电子商务用户评论的数据库，我们不需要原始信息来源…但我们需要手动标记句子以找到问题子串。为此，我们采用Prodigy作为我们的标注工具，并定义一组评论，这些评论将被注释以生成我们的训练数据集。

Prodigy 命名实体注释器。注意实体之间的重叠:一个问题可能涉及一个产品特性。图片作者。

• 擦洗:因为我们的数据在注释之前已经被适当地擦洗了，所以我们不需要在这里做太多。我们可以将数据集一分为二，通过类型来分隔实体，或者使用某种相似性度量来丢弃过于相似的句子。
• 探索:我们正在钻研数据，手动分析带注释的句子以及自动化的 EDA。在我们的数据集中，最简单(也是最重要)的度量是实体类型的平均标记数:这个度量显示了实体的语义复杂性。这将是我们任务难度的代理标准。

我们选择的探索性指标。请注意，发行的令牌数很高，而零售商和个人实体的发生率很低。图片作者。

只需将您的数据输入训练脚本，并更改配置来训练自定义空间管道。来源。

**https://www.machinelearningplus.com/nlp/training-custom-ner-model-in-spacy/

模型分析

咻。经过所有这些步骤，我们终于有了一个工作的 NER 模型。现在，让我们看看指标！

哦…有点低，不是吗？0.15 F1——分数只是让人心灰意冷。图片作者。

指标非常低。分数与每种类型的实体的平均令牌数负相关:问题和正面体验(POS_EXP)是具有最高令牌数和最低分数的实体。

但是我们从问题提取结果中看到了有趣的词云。很明显某些东西被提取出来了，但是我们的度量标准没有察觉到那个价值。

发布笔记本电脑评论词云。这里有很多有用的信息:重启、无响应、关机。

问题提取器的问题不在模型，而在评估:正常的评分方法依赖于严格匹配，其中提取的实体必须与注释的实体相同。这意味着以下提取将被视为完全失败:

句子:笔记本电脑开始不断重启。
注释:开始不断重启
提取:不断重启

粒子“不断重启”是问题的核心。即使我们没有实体的完整上下文，我们仍然可以挽救它！我们知道许多评论都引用了关键词“重启”，帮助生产特定笔记本电脑的品牌识别问题。

因此，我们需要将我们的度量从严格转移到部分，使部分匹配计入与注释实体外观成比例的总得分。

现在好多了，0.15 到 0.40。不是最好的，但是可以用！

这里的寓意是指标讲故事。有时候，一个指标向您描述的故事并不是数据想要讲述的故事！模型输出的临床分析总是很重要的，并且永远不应该被忽视。

有时，即使一个被认为坏了的模型也能给你的客户带来巨大的价值。

建筑规划

图片作者。

特别分析阶段的结论是，该功能有前途。这将以某种方式在最终产品中表现出来，并且由工程团队来组织将新创建的 ner 模型集成到我们当前架构中的方式。我们不会等待数据科学团队的另一次迭代来提高分数:讨论从基线建立的那一刻开始。没有概念的证明是有影响的，除非它是具体的！

一个新特性的架构应该遵循这三个原则:

• 首先，它必须足够模块化，这样升级就容易了。如果您以类似于微服务的方式集成数据丰富管道，并在数据实体之间保持合理的分离级别，就可以做到这一点。
• 第二，它应该符合先前的架构决策。只有在绝对需要的情况下，新特性才应该引入新的架构格式，我们的目标是降低复杂性和不确定性。
• 第三，它应该考虑一些基本的可观察性指标。在新部署生成的不断扩大的待办事项列表中，很容易忽略可观察性。在项目的早期阶段，准备适当的日志和度量要容易得多。

本质上，这就是 MLOps:一组良好的实践，引导模型从概念到产品。

https://www.coursera.org/learn/mlops-fundamentals https://thechief.io/c/editorial/top-10-open-source-mlops-tools/

所以，回到退出计划。在 birdie.ai 这里，我们有一些预先存在的架构来运行我们的数据丰富过程，大量使用 AWS 基础设施。我们需要选择一个脚手架来执行新的模型。

AWS Lambda +阶跃函数数据处理流水线。图片作者。

第一种模式涉及 AWS Lambdas 和 Step 函数，通过不需要重型机器的浓缩函数来处理大量数据。点火函数从 Athena 数据库中检索数据，并将其发送到一个队列。这个队列由一个单独的 Step 函数或 Kubernetes 服务使用，通过一个带有拼花压缩和适当的 Hive 分区的 Firehose 流将结果发送给 S3。可以使用 Athena 表来研究结果。Lambda 通过 Cloudwatch 日志密切控制，cloud watch 日志是一种字典，其中包含关于每个 Lambda/Step 函数执行的格式化信息。

问题是，我们用的是变形金刚模型。我们将需要 GPU 驱动的机器，而 Lambda 不适合它。Kubernetes 服务将是云不可知的，并允许我们使用 GPU 机器，但我们需要更多的努力来实现这种方法的可观察性:也许可以将一名 Kubernetes 专家带到公司，或者花一些时间来开发一些基本的集群性能分析。

来自 S3 触发器管道的 AWS 批处理作业。图片作者。

我们的第二种模式依赖于由 S3 文件插入触发的 AWS 批处理作业。每当一个拼花文件进入 S3 存储桶时，就会触发一个批处理作业来读取该文件，并对其行进行某种类型的处理，然后将结果迭代地存放到一个 Firehose 流中。脚本的复杂性抵消了流水线的简单性:批处理作业必须经过适当的多重处理，才能使用机器的所有处理能力。

它非常符合我们的需求！AWS 批处理作业可以为我们的功能带来 GPU 的全部功能，而不会给我们当前的管道增加太多复杂性，我们的一个方面提取管道使用 SpaCy 命名实体识别模型从评论中提取产品属性。我们可以改变它的用途，以使用新的问题提取模型。

我们的游戏计划现在正致力于重组我们之前的一个管道来执行问题提取。这意味着如果数据科学团队交付一个经过测试的、可扩展的推理代码，开发时间将从几天缩短到小时。

https://analyticsindiamag.com/why-data-scientists-should-follow-software-development-standards/ https://bigdata-madesimple.com/how-software-engineers-and-data-scientists-can-collaborate-together/

前端原型

现在，我们有了一个模型和一个架构，以一种可扩展的、可观察的方式交付那些推论…但是如何向我们的客户展示这个特性呢？

在这里的 birdie.ai ，我们对用户生成内容的见解是通过网络仪表盘传达的。这些仪表板由不同的开发人员管理，这些开发人员由数据分析师和前端工程师组成，不受数据科学家和工程师的控制。

这并不是说数据和产品之间存在不可逾越的鸿沟，因为我们参与了产品发现、影响和价值讨论:我们脱离了后端和前端应用程序开发，专注于数据结构化。

数据科学团队的重点随着公司的目标而转移。图片作者。

一些产品和公司不需要前端，直接从数据分析师收集的报告中提供见解。在这些情况下，数据小组可能需要执行仪表板操作，并测量与用户相关的指标。你可以说这些公司是前装。相比之下，更关注数据获取、丰富和架构的公司是后装。

我们能够使用 Tableau 快速制作一个连接到产品分析仪表板的工作原型。将 Tableau 仪表板连接到 HTML 页面真的很容易！

https://www.zuar.com/blog/embedded-analytics-how-to-embed-tableau-dashboards-into-a-web-page/

使用 Tableau 的原型问题浏览器。我们建立了一个问题类型的层次结构，可以在多个级别进行分析:图像质量组包含艺术模式、亮度差和颜色组；亮度差包括所有涉及亮度或太暗的问题。图片作者。

这些是从特定品牌的电视评论中提取的问题，我们已经可以看到关于音频、亮度和内置应用程序商店的投诉。我们评论基数的一小部分，范围在几亿。我们希望这将是营销分析师的一个方便的温度计，给他们用户最关心的问题。

这个特性掌握在我们能干的前端工程师和他们的 HTML 魔法手中。数据科学团队正在升级我们的 NER 模型，工程团队则负责管道指标。我们正处于流水线的最后一步:完全集成特性的交付。很高兴看到一个想法从开始到结束被执行，并有客户的反馈和兴趣。

我们希望这次通过我们的方法的旅行能在您的数据之旅中帮助您！

感谢joo Augusto Leite共同撰写这篇文章，并在《贸发会议联系 2021》中作为数据专题讲座发表！**

如何部署 Flask API

原文：https://towardsdatascience.com/how-to-deploy-a-flask-api-8d54dd8d8b8a?source=collection_archive---------10-----------------------

将您的 API 部署到 Google 云平台

图片由费德里科·布尔加拉西在 Unsplash 上拍摄

对我们许多人来说，构建第一个 API 是创建有影响力的工具的重要一步，这些工具有一天可能会被许多开发人员使用。但是这些 API 通常不能在我们的本地机器上使用。

幸运的是，部署 API 非常容易。假设你不知道你现在在做什么——你可能会在 10 分钟左右部署你的第一个 API。

我没开玩笑，超级简单。让我们开始吧。

在开始之前

有几个先决条件。这些可能会让你稍微超过 10 分钟，但我保证不会花很长时间！我们将使用谷歌的云服务来部署我们的 API，即GoogleCloudPplatform(GCP)。

你将需要输入帐单细节，但如果这是你第一次上 GCP，你会得到几百💲免费学分的价值。如果你想避免任何账单，确保你在完成后删除了你的项目。

1. 注册 GCP 并选择/创建一个项目 —记下项目名称。
2. 启用计费
3. 启用云构建 API 。
4. 安装并初始化云 SDK 。

初始化后，您可能需要选择之前创建的项目。

应用引擎初始化

我们将使用 GCP 应用引擎服务来部署我们的 Flask API。要使用它，我们需要将 App Engine 添加到我们选择的项目中，然后安装 Python 的 App Engine 扩展。

从您选择的提示窗口中，我们使用项目名称(使用您的项目名称)创建一个新的 App Engine 应用程序，并选择一个地区。

gcloud app create --project=*aurelio-330516*

然后，我们安装 Python 的 App Engine 扩展:

gcloud components install app-engine-python

现在，我们已经具备了将我们的 API 部署到 GCP 的应用引擎所需的所有先决条件。让我们继续讨论 Flask API 本身。

准备和部署

在盲目地将我们的 API python 脚本扔向 GCP 的应用引擎并抱最好的希望之前，我们应该确认它是可行的。我们可以通过模拟应用引擎环境来做到这一点，但首先，我们需要一个 API。

我将使用这个 API 脚本。它并没有做什么特别有趣的事情，但是它很简单，因此对我们的例子很有用。你可以在这里看到我是如何构建它的。

除了 API 脚本main.py —您还需要包含一个./data目录，其中包含两个文件 users.csv 和locations . CSV。总之，这意味着我们有一个如下所示的单一目录:

API 目录结构— 作者的图像(和所有其他图像)。

回到模拟。为了模拟 App Engine 环境，我们将使用gunicorn来运行一个本地WEBSserverGatewayIinterface(WSGI)服务器。在此之前，您可能需要pip install gunicorn —然后，在相同的环境中，我们运行 API:

API 服务器的初始化。

然后我们可以前往http://0.0.0.0:8080/users。如果 API 按预期运行，我们应该会看到一个小的 JSON 响应，如下所示:

浏览器中的 API 响应。

Gunicorn 正在使用我们的 Python 环境——所以我们在main.py脚本顶部导入的库已经安装好了。我们也知道我们正在使用(在我的例子中)Python 3.8。

当我们将 API 部署到 GCP 时，这是一个问题。App Engine 将不知道我们需要使用这些包，也不知道我们正在使用 Python 3.8。因此，我们必须在目录中再添加两个文件:

• requirements.txt将包含一个 Python 包列表，供 App Engine 安装。
• app.yaml将运行时设置为使用 Python 3.8。

这些文件将如下所示:

这就是我们所需要的。现在，我们通过在包含所有文件的目录中运行gcloud app deploy来进行部署。这需要一点时间来部署，之后我们应该会看到我们部署的 API 的 URL！

部署详细信息，突出显示的是 API 网址。

前往该 URL，后跟/users端点，将返回我们之前看到的相同的 JSON 对象:

来自云托管版本的 API 响应。

这意味着我们的 API 已经启动并正在运行，我们可以像对待任何其他 API 一样发出请求了！

这就是使用 GCP 的应用引擎部署 Flask APIs 的快速演练。

我希望你喜欢它！如果你有任何问题，请通过推特或在下面的评论中告诉我。如果你想要更多这样的内容，我也在 YouTube 上发布。

感谢阅读！

🤖《变形金刚》NLP 课程 70%的折扣

*除另有说明外，所有图片均出自作者之手

如何在 Kubernetes 中部署 Flask API 并将其与其他微服务连接

原文：https://towardsdatascience.com/how-to-deploy-a-flask-api-in-kubernetes-and-connect-it-with-other-micro-services-af16965b67fe?source=collection_archive---------1-----------------------

实践教程

关于如何使用强大的容器编排工具 Kubernetes 实现微服务架构的实践教程。

Kubernetes 是一个强大的容器编排工具，它自动化了容器的部署和管理。如果您有一个包含一种服务的简单轻量级应用程序，就不要使用 Kubernetes 了。如果您的应用程序有一个由几个组件协同工作的微服务架构，那么 Kubernetes 的优势就会显现出来。它是一个用于自动化部署、扩展和管理容器化应用程序的“开源系统”,具有多种优势，包括:

• 基于需求的简单(自动)扩展
• 通过分配工作负载，使您的应用程序在部分故障的情况下仍能正常工作，从而使应用程序具有容错能力
• 自动化运行状况检查和自我修复流程
• 负责微服务之间的通信，并在所有资源上平衡传入流量

一开始从 Kubernetes 开始可能会令人望而生畏，但是如果你掌握了它的主要概念，并在官方网站上使用了优秀的教程，你会很容易上手。

在这篇博客中，我将:快速概述 Kubernetes
2 的主要概念。演示如何启动您自己的本地集群
3。在您的集群上部署 MySQL 数据库
4。设置一个 Flask 应用程序，作为 REST API 与数据库通信

Kubernetes 基础知识

在这一节中，我将介绍 Kubernetes 的基础知识，但没有太多的细节；请阅读官方文档，深入了解。

Kubernetes 集群由一个主节点和一个或多个**工作节点组成。**这种建筑是 Kubernetes 的主要特色之一。正如您将看到的，您的微服务分布在不同的节点上，因此如果其中一个工作节点出现故障，它们将保持健康。主机负责管理集群，并公开 API，您可以通过该 API 与集群进行通信。默认情况下， worker nodes 带有一些组件，包括一些预安装的软件，这些软件支持运行流行容器服务的容器，如 Docker 和 containerd。

在 Kubernetes 集群上部署自己的应用程序有三个基本概念:部署、Pods 和服务。

• 一个部署是提供给主关于如何创建和更新你的应用的一组指令。有了这些指令，主将在各个工作节点上调度并运行你的应用。部署由主持续监控。如果您的应用程序的一个实例关闭(例如，如果一个工作节点关闭)，它将被一个新的实例自动替换。

带有部署的 Kubernetes 集群(来源:https://kubernetes . io/docs/tutorials/kubernetes-basics/deploy-app/deploy-intro/)

• 一个 Pod 是 Kubernetes 平台内的原子单位。它代表一组一个或多个容器以及这些容器的一些共享资源(共享存储、唯一的集群 IP 地址等。).如果您创建了一个部署，这个部署将创建容器，其中包含容器。每个 pod 绑定到一个工作节点。重要的是要理解一个工作者节点可以有多个pod、，如果当前工作者节点失败，所有这些 pod 将在不同的可用工作者节点上重建。

带有几个窗格的工作节点的概述(来源:https://kubernetes . io/docs/tutorials/kubernetes-basics/explore/explore-intro/)

• 一个服务基本上定义了一组pod的逻辑集合，并定义了如何访问它们的策略。这是必要的，因为pod可以关闭并重启(例如，如果工作节点被删除或崩溃)。一个服务在一组 pod 之间路由流量，并允许 pod 在不影响您的应用程序的情况下死亡和复制。定义服务时，您可以指定服务的类型。默认情况下，Kubernetes 创建一个 ClusterIP 服务，这使得您的服务只能从集群内部访问。你可能想向外界公开你的一些服务(例如前端)。在这种情况下，您可以创建一个负载平衡器服务，该服务创建一个外部负载平衡器并为其分配一个固定的外部 IP，因此可以从集群外部访问它(例如在您的浏览器中)。

开始使用您自己的集群

如果你想让你的集群快速工作:这个博客中的所有代码(和一个解释性的自述文件)都可以在这里找到。我们将要构建的应用程序由两个微服务组成。MySQL 数据库
2。一个 Flask 应用程序，它实现了一个 API 来访问和执行数据库上的 CRUD(创建、读取、更新和删除)操作。

先决条件 : 已经安装了*kubectl**minikube*(【https://kubernetes.io/docs/tasks/tools/】)。并确保您的* Docker CLI 通过命令 *eval $(minikube docker-env)* 在您的集群中使用 Docker 守护程序*。不用担心:如果你重启你的终端，你会自动再次使用你自己的* Docker 守护进程*。最后通过命令* *minikube start* 启动您的本地集群。*

首先:当建立一个 MySQL 数据库时，我们需要考虑两件事。1)要访问数据库，我们需要配置一些凭据；2)我们需要一个持久的数据库卷，以便在节点意外关闭时不会丢失所有数据。

创造秘密

Kubernetes 有自己的方法来处理你的敏感信息，通过配置 Kubernetes 的秘密。这可以用一个简单的 YAML 文件来完成。这些秘密可以由集群中的任何 pod 通过指定环境变量来访问(我们将在后面看到)。机密应该指定为 base64 编码的字符串。所以首先我们必须通过你的终端得到你的密码的编码版本:echo -n <super-secret-passwod> | base64。复制输出并将其嵌入到下面的db_root_password 字段的 secrets.yml 文件中。 metadata.name 字段很重要，因为我们必须在稍后的阶段指定它，所以一定要记住它**

你现在可以通过你的终端kubectl apply -f secrets.yml将秘密添加到你的集群中。并通过kubectl get secrets.检查秘密，看看是否有效

持久卷

持久卷是一种生命周期独立于 Pod 的存储资源。这意味着如果一个箱关闭，存储将继续。由于 Kubernetes 拥有在任何时候重启 pods 的权限，所以将数据库存储设置为持久卷是一个很好的做法。持久卷可以是本地文件系统上的目录，也可以是云提供商的存储服务(例如 AWS 弹性块存储或 Azure 磁盘)。在创建持久* 卷时，可以指定持久卷*的类型。在本教程中，您将使用一个 hostPath 类型，它将在您的 minikube 节点上创建一个卷。但是，请确保在生产环境中使用另一种类型(参见文档)，因为如果在使用 hostPath 类型时删除 minikube 节点，您的数据将会丢失。

让您的应用程序使用由两部分组成的持久卷*:
1。指定卷的实际存储类型、位置、大小和属性。
2。指定一个永久卷声明，为您的部署请求永久卷的特定大小和访问模式。*

创建一个 persistent-volume.yml 文件，并指定文件的大小(在本例中为 2GB)、访问模式和存储路径。spec.persistentVolumeReclaimPolicy指定如果持久卷声明* 被删除，应该做什么。对于像 MySQL 数据库这样的有状态应用程序，如果声明被删除，您希望保留数据，这样您就可以手动检索或备份数据。默认回收策略继承自持久卷的类型，因此最好总是在 yml 文件中指定它。*

同样，您可以通过kubectl apply -f persistent-volume.yml添加存储。并通过kubectl describe pv mysql-pv-volume和kubectl describe pvc mysql-pv-claim查看您创建的资源的详细信息。由于您制作了一个主机路径类型持久卷*，您可以通过登录 minikube 节点minikube ssh 找到数据，并导航到指定的路径(/mnt/data)。*

部署 MySQL 服务器

*有了我们的秘密和持久卷(claim ),我们就可以开始构建我们的应用程序了。首先我们将部署一个 MySQL 服务器。拉最新的 mysql 镜像docker pull mysql并创建 mysql-deployment.yml 文件。这个文件有几个值得一提的地方。我们指定只旋转一个 pod ( spec.replicas: 1)。部署将管理所有标签为由spec.selector.matchLabels.app: db指定的db的 pod。template字段及其所有子字段指定了 *pod 的特征。*它将运行镜像 *mysql，也将被命名为 mysql ，并在flaskapi-secrets secret 中查找 db_root_password 字段，并将该值设置为MYSQL_ROOT_PASSWORD环境变量。此外，我们指定容器公开的端口，以及应该将哪个路径安装到持久卷spec.selector.template.spec.containers.volumeMounts.mountPath: /var/lib/mysql。在底部，我们还指定了一个名为 mysql 的LoadBalancer类型的服务，这样我们就可以通过这个服务访问我们的数据库。

现在可以用kubectl apply -f mysql-deployment.yml部署 MySQL 服务器了。并通过kubectl get pods查看 pod 是否正在运行。

创建数据库和表

在实现 API 之前，我们必须做的最后一件事是在 MySQL 服务器上初始化数据库和模式。我们可以使用多种方法做到这一点，但是为了简单起见，让我们通过新创建的服务来访问 MySQL 服务器。由于运行 MySQL 服务的 pod 只能从集群内部访问，因此您将启动一个临时 pod 作为mysql-client :
1。通过终端kubectl run -it --rm --image=mysql --restart=Never mysql-client -- mysql --host mysql --password=<your_password>设置mysql-client。填写您在 secrets.yml 文件中指定的(解码)密码。
2。创建数据库、表和模式。你可以做任何你想做的事情，但是为了确保样品瓶应用程序能够正常工作，请做如下操作:
CREATE DATABASE flaskapi; USE flaskapi;
CREATE TABLE users(user_id INT PRIMARY KEY AUTO_INCREMENT, user_name VARCHAR(255), user_email VARCHAR(255), user_password VARCHAR(255));

部署 API

最后，是时候部署 REST API 了。以下要点演示了一个 Flask 应用程序的示例，该应用程序仅使用两个端点来实现 API。一个用于检查 API 是否正常工作，另一个用于在数据库中创建用户。在 GitHub repo 中，您可以找到 python 文件，该文件具有读取、更新和删除数据库中条目的端点。连接到数据库 API 的密码是从通过创建秘密而设置的环境变量中获取的。其余的环境变量(例如MYSQL_DATABASE_HOST)是从之前实现的 MySQL 服务中获取的(稍后我将解释如何确保 Flask 应用程序可以访问这些信息)。

要在您的 Kubernetes 集群中部署这个应用程序，您必须通过创建一个简单的 docker 文件来制作这个 Flask 应用程序的映像。没什么特别的，准备你的容器，安装需求，复制文件夹内容，运行 Flask app。转到 GitHub repo 找到构建映像所需的 Dockerfile 和 requirements.txt 文件。在 Kubernetes 集群中部署 Flask 应用程序之前，首先必须构建映像，并通过docker build . -t flask-api将其命名为 flask-api 。

现在是时候为实现 RESTful API 的 Flask 应用程序定义部署和服务*了。部署将启动 3 个 pod(在*flask app-deployment . yml*的spec.replicas: 3 字段中指定),在这些*pod*中的每一个内，从您刚刚构建的 *flask-api* 映像创建一个容器。为了确保 Kubernetes 使用本地构建的映像(而不是从 Dockerhub 之类的外部 repo 下载映像)，请确保将imagePullPolicy设置为never。为了确保 Flask 应用程序可以与数据库通信，应该设置一些环境变量。db_root_password是从你创建的*秘密*中获取的。每个启动的容器继承环境变量和所有运行的服务的信息，包括 T4 和 T5 地址。所以你不用担心必须指定 MySQL 数据库的host和port给 Flask 应用。最后，您将定义一个LoadBalancer 类型的*服务*来在三个 pod 之间划分传入的流量。*

向 API 发出请求

您现在已经准备好使用我们的 API 并与您的数据库进行交互了。最后一步是通过你的终端minikube service flask-service向外界公开 API 服务。您现在将看到类似这样的内容

结论

卷曲在你的终端。要创建一个用户，提供一个带有名称、电子邮件和密码字段的 json 文件。比如:curl -H "Content-Type: application/json" -d '{"name": "<user_name>", "email": "<user_email>", "pwd": "<user_password>"}' <flask-service_URL>/create。如果您也实现了 API 的其他方法(如 GitHub repo 中所定义的)，那么您现在可以通过curl <flask-service_URL>/users查询数据库中的所有用户。

结论

在本实践教程中，您将设置部署*、服务和*pod，通过部署 Flask 应用程序并将其与其他微服务(本例中为 MySQL 数据库)连接来实现 RESTful API。您可以继续在本地运行它，或者在远程服务器(例如云中)上实现它，并将其投入生产。随意克隆 repo 并随意调整 API，或者添加额外的微服务。

如果您有任何其他问题、意见或建议，请随时联系我！

关于作者

Rik Kraan 是一名放射学博士，在荷兰数据科学咨询公司 Vantage AI 担任数据科学家。通过rik.kraan@vantage-ai.com联系

如何在 AWS ECS 上部署 Flask API(第 3 部分)

如何在 AWS ECS 上对接和部署 Flask API 的分步指南

照片由达拉斯里德在 Unsplash 上拍摄

数据科学领域的一个重要方面是你永远不会停止学习。一旦你对数据争论和机器学习感到舒适，下一步通常是学习如何让你的 ML 模型进入“生产”以供他人使用。下一步不仅需要你知道如何使用 Flask、Django 或 FastAPI 等工具构建 API，还需要你了解 Docker & Cloud (AWS、Azure、GCP)栈。这篇文章旨在帮助你解决最后两个问题:Docker & Cloud。

如果您一直在关注我的电影推荐引擎组合项目 4 部分系列，到目前为止，我们已经介绍了协作过滤的理论(第 1 部分)以及如何创建 Flask API(第 2 部分):

在这里，我们将介绍如何在 AWS 上部署我们在第 2 部分中构建的 Flask API。

教程结构

1. AWS 上最流行的 API 部署选项的快速概述

2. 克隆包含必要 API 文件的 GitHub repo

3. 将 API 归档

4. 将 Docker 图像推送到 Amazon ECR

5. 在 AWS ECS 上创建一个任务来运行 API，并使用分配的公共 url 对其进行测试。

6. AWS 上最流行的 API 部署选项的快速概述

在决定如何在 AWS 上部署后端 API 时，我发现了两种主要方法:

I)带有 API 网关的 AWS Lambda 功能

或者

ii)基于 Docker 映像在 ECS 上创建任务。

即使配置任务、负载平衡器、安全组等。与使用 AWS Elastic Beanstalk 相比，在 AWS ECS 上手动安装可能会更复杂，它使您能够更好地理解并根据您的项目需求正确设置每个组件。

我之所以选择 Docker Containers 和 ECS 而不是 Lambda 函数来部署这个 API，是因为 Lambda 函数要求您添加额外的层来配置库(如 pandas ),以便与 python 运行时兼容，如果您不是严格在 Linux 操作系统上构建 Docker 映像，这可能会很麻烦。

让我们开始吧。

2。克隆包含必要 API 文件的 GitHub repo

a) 克隆以下回购:

[https://github.com/kuzmicni/movie-rec-engine-backend](https://github.com/kuzmicni/movie-rec-engine-backend)

[https://drive.google.com/drive/folders/1FH6bWCcw1OoRf4QJaFaf4gIegIGSEx9r](https://drive.google.com/drive/folders/1FH6bWCcw1OoRf4QJaFaf4gIegIGSEx9r?usp=sharing)

您的代码结构应该如下所示:

c) 创建虚拟环境&安装必需的库

conda create --name py37_tut python=3.7
conda activate py37_tut
pip install Flask Flask-Cors pandas

运行应用编程接口

python application.py

e) 在一个单独的终端中运行测试 API

curl -X POST http://0.0.0.0:80/recms -H 'Content-Type: application/json' -d '{"movie_title":"Heat (1995)"}'

应该从 API 获得以下输出:

3。将 API 归档

我假设您已经安装了 docker，并且熟悉创建 docker 映像。让我们确保您安装了 docker:

docker version

应该得到类似的东西:

我们对 API 进行 Docker 化的方式实质上是基于名为 Dockerfile 的模板构建 Docker 镜像，该模板包含关于哪些文件需要复制以及如何运行 API 的指令。

Dockerfile:

FROM python:3.7COPY ./* ./app/WORKDIR /app/RUN pip install -r requirements.txtEXPOSE 80CMD ["python", "application.py"]

本质上，这个 Docker 文件(即蓝图)指示的是将我们当前目录中的所有文件复制到 Docker image /app/ 文件夹中，安装 requirements.txt 文件中指定的库，暴露端口 80 并将 Flask API 作为服务器运行。

要构建名为 flask-api 的 Docker 映像，请确保您与 Docker 文件在同一个目录中(即/movie-rec-engine-backed ),并在您的终端中执行:

docker build -t flask-api .

应该得到:

现在我们准备把它推送到 AWS 弹性容器注册中心(ECR)。

4。将 Docker 图像推送到亚马逊 ECR

我假设您已经安装了 aws-cli，并且已经通过 aws configure 命令输入了您的访问密钥和密钥。

在 ECR 中创建一个存储库:

单击“创建存储库”，保留默认的私有选项，并将您的存储库命名为“flask-api-repo”

b) 将 Docker 图像推送到 ECR

点击创建的“flask-api-repo”并选择“查看推送命令”

在您的终端中运行所提供的说明，但步骤 2 除外，因为我们已经构建了映像:

aws ecr get-login-password --region **<your-region>** | docker login --username AWS --password-stdin **<your-account-alias>**.dkr.ecr.**<your-region>**.amazonaws.comdocker tag flask-api **<your-account-alias>**.dkr.ecr.**<your-region>**.amazonaws.com/flask-api-repo:latestdocker push **<your-account-alias>**.dkr.ecr.**<your-region>**.amazonaws.com/flask-api-repo:latest

推送映像后，您可以刷新 repo，应该会看到以下内容:

5。在 AWS ECS 上创建一个任务来运行 API，并使用分配的公共 url 对其进行测试

是时候创建一个运行该图像的任务了！

转到 ECS。

a)创建一个集群

选择:“仅网络”选项

集群名:flask-api-cluster

选择:创建 VPC 并保留默认选项

点击“创建”。

b)定义任务

在 ECS 中，单击任务定义

单击“创建新任务定义”按钮

选择“FARGATE”

选择“下一步”

输入任务定义名称:flask-api-task

选择默认的“ecsTaskExecRole ”,或者您也可以在 IAM 中创建一个具有更多访问权限的新角色。

c)指定任务大小

任务内存(GB): 1GB

任务 CPU: 0.5 vCPU

d)添加容器

选择“添加容器”

容器名称:烧瓶-API-容器

对于 URI 形象，我们需要抓住我们的 URI 形象。只需在新标签中重新打开 aws 控制台，导航到 ECR flask-api-repo 并复制图像 URI:

返回并将 URI 粘贴到图像*字段中

输入:

软限制:128

端口映射:80

将其余部分保留为默认值，然后单击页面底部的“添加”按钮

向下滚动并点击“创建”

你应该看看

单击“查看任务定义”

e)运行任务

现在，在“操作”中选择“运行任务”

选择“FARGATE”

任务数量:1

对于子网:选择两个选项(我选择 a 和 b)

除了安全组*点击编辑

选择“创建新的安全组”

安全组名*: flask-api-sg

点击“保存”

现在，我们应该看到我们的新任务处于“PROVISIONING”状态。等一会儿，直到它变成“运行”

点击“任务”并向下滚动找到公共 IP。现在将 IP 粘贴到您的浏览器中，您应该会看到:

测试部署的 API

让我们通过终端测试一下。

假设你得到的公共 IP 是1.2.3.4，那么在终端中，你可以运行:

curl -X POST **1.2.3.4**/recms -H 'Content-Type: application/json' -d '{"movie_title":"Heat (1995)"}'

并且应该得到:

这意味着您的 API 已成功部署！

结束语

需要注意的事项:

您可能需要试验您的 EcsTaskRole，并确保安全组具有允许流量访问 API 的规则。

将 Docker 映像推送到 ECR 并在 ECS 中创建任务会在您的 AWS 帐户上产生费用，因此请确保停止任务并删除所有相关资源。

现在我们准备使用第四部分中的 Vue.js 构建电影推荐引擎前端！

如何用 FastAPI、Docker 和 Github 动作部署机器学习模型

具有 CI/CD 的端到端管道

照片由西格蒙德在 Unsplash 上拍摄

你是一名数据科学家，在一家软件公司工作。

您刚刚训练了一个模型，您对它很满意，因为它在您的本地交叉验证中表现很好。

现在是将该模型投入生产的时候了，以便您组织中的其他团队可以使用它并将其嵌入到他们的应用程序中。

这是数据科学家面临的非常普遍的情况。管理起来既麻烦又痛苦，但是使用正确的工具，这个过程可以顺利进行。

在本教程中，我将展示一个端到端的用例来解释将模型投入生产的工作流程。这是一篇相对较长的文章，所以请随意跳到你感兴趣的部分。

以下是我们将要介绍的内容:

1. 生产机器学习和 API 简介
2. FastAPI 特性的快速概述
3. 使用 FastAPI 和 SpaCy 构建推理 API
4. 用 Docker 和 docker-compose 封装 API
5. 将 API 部署到 AWS EC2，并使用 Github Actions CI/CD 自动化流程

我希望你准备好了。事不宜迟，让我们直接开始吧🚀。

PS:所有代码在Github上都有。

新到中？你可以每月订阅 5 美元，解锁我写的不限数量的关于编程、MLOps 和系统设计的文章，以帮助数据科学家(或 ML 工程师)编写更好的代码。

将模型投入生产意味着什么？

在我们更进一步之前，让我们从一个共同点开始。

从广义上来说，不涉及很多细节，将模型投入生产是一个过程，在这个过程中，模型被集成到现有的 IT 环境中，并可供其他团队使用和消费。

为了使这个过程尽可能高效，应该仔细管理许多步骤:数据存储、服务、工件记录、资源管理等等。

作者制作和修改的图像

如果你的模型从未离开过你的本地电脑，而你所有的实验都在 jupyter 笔记本上，那么你很可能还没有准备好投入生产。

不过不用担心。本教程旨在帮助您开始使用 API 将模型投入生产。

API 到底是什么？

是 A 应用程序 P 编程 I 接口的简称。它只是两个相互通信的独立应用程序之间的中介。

如果您是一名开发人员，并且希望您的应用程序可供其他开发人员使用和集成，您可以构建一个 API 作为您的应用程序的入口点。因此，开发人员必须通过 HTTP 请求与该 API 进行通信，以使用您的服务并与之交互。

作者图片

将 API 视为应用程序的抽象(用户看不到你的代码，也不安装任何东西，他们只是调用 API)和与第三方(开发者、应用程序、其他 API 等)集成的简化。)

API 无处不在。数据科学世界也不例外。

什么是 FastAPI，为什么它适合生产机器学习？

FastAPI 目前是构建可在生产环境中伸缩的健壮的高性能 API 的首选框架。

截图—https://fastapi.tiangolo.com

FastAPI 最近越来越受欢迎，用户在 web 开发人员、数据科学家和 ML 工程师中的采用率大幅上升。

让我通过展示我能想到的最有趣的特性来解释围绕这个框架的所有宣传。

然后，我们将转到在特定用例中使用 FastAPI 的部分。

PS:这个列表并不详尽，如果你想有一个全局的概述，你可以参考 官方 文档。

1)简单的语法

FastAPI 的语法很简单，这使得它使用起来很快。它实际上类似于 Flask 的语法:因此，如果您正在考虑从 Flask 迁移到 FastAPI，迁移应该很容易。

实例化 Flask 和 FastAPI 应用程序是一样的。然而，与 Flask 不同，FastAPI 没有集成 web 服务器。FastAPI 是专门为构建 API 而设计的。它没有责任为他们服务。

FastAPI 做一件事，而且做得很好。

服务 API 是 uvicorn 的责任，这是一个很好的选择，因为 uvicorn 是一个使用 uvloop 和 httptools 的闪电般快速的 ASGI 服务器实现。

烧瓶:

FastAPI:

在两个库中，为 HTTP 请求定义路由和附加处理程序遵循相同的语法。你用装修工。

FastAPI 的语法甚至更简单:每个特定的 HTTP 请求都有一个装饰器，不像 Flask 将请求类型作为参数传递给 route 装饰器。

烧瓶:

FastAPI:

在 Flask 和 FastAPI 中，path 参数都是从我们传递给 route 的路径中解析出来的。对于 FastAPI，我们将这些参数作为参数添加到函数中。我个人认为 FastAPI 在这种特殊情况下的语法更容易阅读和理解。

烧瓶:

FastAPI:

在 FastAPI 中提取查询参数要容易得多:您只需将它们作为处理程序的参数，FastAPI 会处理剩下的事情:它从 route 中解析它们，并将它们转换成您指定的类型。

当使用 Flask 时，您必须调用request类，单独获取每个参数并应用一些最终的后处理。

烧瓶:

FastAPI:

要快速了解 FastAPI 的语法，请看这个链接。

2)一个超快的框架

根据独立网站 techempower 的说法，FastAPI+uvicon 是最快的网络服务器之一。

这是一个执行基本任务的性能比较，比如 JSON 序列化、数据库访问和服务器端模板合成。每个框架都在现实的生产配置中运行。

来源:https://techempower.com

3)异步请求

FastAPI 带来了以前的 web 框架如 Flask 和 Django 所缺乏的新特性:异步请求。

异步编程是一种编程模式，它使代码能够独立于主应用程序线程运行。异步编程在许多用例中使用，例如事件驱动的系统、高度可伸缩的应用程序以及 I/O 绑定的任务，例如通过网络读写文件。

如果在处理程序中使用异步函数，那么在调用该函数之前，必须将async添加到处理程序中，并添加await参数。

你可以在这里了解更多关于异步编程的知识。

4)使用 Pydantic 的现代 python 类型

FastAPI 与 Pydantic 集成在一起，用标准的 python 类型对请求和响应主体进行类型化。

这在运行时强制验证，并通过允许您的 IDE 正确地自动完成并检测与类型相关的错误来提高您的编码效率。

在下面的例子中，我们设计了一个小的 API 来发布工作申请并接收随机的决定。请求体遵循 Application 类中定义的模式。它仅仅意味着它必须具有:

• 类型为字符串的first_name键
• 类型为字符串的last_name键
• 一个类型为 int 的age键
• 类型为字符串的degree键
• 一个可选的类型的interest键字符串

类似地，您可以使用决策类中定义的模式键入 API 响应。

这有什么用呢？

假设您不小心向 first_name 字段传递了一个整数。FastAPI 将检测类型不匹配，并相应地引发错误。

你可以在这里了解更多关于 Pydantic 的信息。

5)字符串查询参数的验证

FastAPI 允许通过在字符串查询参数上添加约束来验证用户输入。例如，您可以设置最大或最小长度，或者设置查询必须匹配的正则表达式。

你可以在这里了解更多关于字符串验证的信息。

6)数值参数的验证

同样，当使用数字参数时，您可以通过使用gt(大于)和le(小于或等于)来设置一个范围作为约束。

你可以在这里了解更多关于数字验证的信息。

7)更好的错误处理和自定义消息

使用 FastAPI，您可以用特定的消息和状态代码来定义和引发自定义错误。这有助于其他开发人员在使用您的 API 时轻松理解错误并进行调试。

你可以在这里了解更多关于错误处理的信息。

8)遵循 OpenAPI 标准的自动文档生成

一旦您开始使用 FastAPI，就会自动为您生成交互式 API 文档和探索。

在本地启动 API 后，您可以通过此链接[http://localhost:8000/docs](http://localhost:8000/docs)访问它。

您将看到您创建的每条路由的文档，以及一个交互式界面，您可以直接从浏览器测试每个端点。

作者提供的图片

9)世界一流的文档，学习并开始使用框架

我很少见过如此完整且易于理解的文档。由塞巴斯蒂安·拉米雷斯领导的 FastAPI 团队已经完成了记录每一段代码的惊人工作。

你可以在这里开始学习如何使用 FastAPI，坦白地说，没有更好的选择了。

作者图片

使用 FastAPI 和 Spacy 创建匿名化 API

让我们进入有趣的部分。

在我之前的一篇帖子中，我构建了一个 Streamlit 应用程序，它通过检测带有空间模型的命名实体来匿名化文本。要使用这个应用程序，你必须打开一个浏览器并与用户界面互动。

但是，

如果我们可以创建一个 API 端点来做同样的事情，这样开发人员就可以在不使用 UI 的情况下轻松地与这个程序进行交互，会怎么样？

这看起来像是 FastAPI 的完美工作。

下面的图表代表了我们将要构建的 API 的模式:

作者图片

我们将只定义一个路由，它将接受路径/entities上的 POST 请求，并且它将期望一个包含三个字段的请求体:

作者图片

• 文本:要匿名的文本
• model _ size:NER 模型的尺寸(默认为“sm”)
• model _ language:NER 车型的语言(默认为“en”)

作为输出，API 将返回一个包含两个键的 JSON 对象:

作者图片

• **实体:**提取的实体列表。每个实体是一个 JSON，包含四个键( start :文本中实体的起始索引， end :结束索引， type :实体的类型， text :实体的值)
• **匿名化 _ 文本:**将实体匿名化的原始输入文本

为了设置请求和响应体的类型，我们将使用 Pydantic。

• 对于请求的主体，我们将UserRequestIn定义为 BaseModel 类的子类。它会有三个属性:text, model_language和model_size。
  我本可以将model_language和model_size的类型设置为 string，但是，为了本教程，我为它们定义了两个类:ModelLanguage 和 ModelSize。这两个类继承自str和Enum。使用 Enum 的想法是限制每个字段的可能值。对于语言，我们只需要英语(“en”)和法语(“fr”)，对于大小，我们需要三个可能的值(“sm”表示小，“md”表示中，“lg”表示大)。
• 至于响应的主体，我们定义了EntitiesOut类，再次作为 BaseModel 的子类。如前面的响应主体截图所示，它将有两个键:实体和anonymous ized _ text。
  anonymous _ text是一个字符串，而 entities 是一列 EntityOut 对象。EntityOut 只是一个 BaseModel 类，表示每个实体的模式:它有四个字段:start (int)、end (int)、type (str)和 text (str)。

如您所见，使用 Pydantic 为您的请求和响应构建定制类型非常直观。通过组合其他复杂类型，你可以变得更有创造力。

既然已经创建了数据模型，我们就可以开始构建 API 了:首先，我们用 Spacy 加载语言模型。这些模型将保存在ml/models/文件夹中。

然后，我们将定义 API 路由和处理程序。

这里发生了一些事情:

• 在装饰器@app.post中，我们将路径设置为entities/，并将response_model参数设置为EntitiesOut。在这里，FastAPI 强制响应体遵循在EntitiesOut类中用 Pydantic 声明的模式。
• 处理程序的第一个参数是请求体:我们将其类型设置为UserRequestIn以强制输入验证。
• 剩下的就是纯 python 代码:我们提取数据，调用模型，并匿名化检测到的实体。
• 最后返回一个字典，有两个键:实体和anonymouzed _ text。

现在一切都应该可以在本地运行了。进入项目的根目录，运行uvicorn api.main:app --reload

作者提供的图片

要检查 API 是否在工作，您可以打开http://localhost:8000/docs来查看交互界面，在这里您可以从浏览器尝试 API。

作者图片

用 Docker 打包 API

既然 API 在本地工作，我们可以构建一个 Docker 映像来打包它的依赖项，并在一个隔离的执行环境中运行它，也就是一个容器。

您可以将容器视为虚拟机，尽管它们不像虚拟机那样提供严格的隔离。

Docker 映像由Dockerfile定义，它基本上是 Docker 构建映像的一组指令。

图像通常建立在其他基础图像之上。这些图像可以从 Docker Hub 中提取，这是 Github 的一个等价物，但是是针对 Docker 图像的。

这是我们 API 的 docker 文件。它包含在项目的根目录中。

让我们一行一行地详细说明发生了什么:

1. 我们指出我们从python:3.7开始的基本图像。Docker 在构建映像时从中央存储库中取出它。
2. Python 依赖项(fastapi、uvicorn 和 spacy)在镜像中使用pip安装。
3. 我们将api/文件夹的内容(从主机)复制到/api/api/文件夹(在镜像上)
   PS:这个文件夹是在镜像中自动创建的
4. 我们将 PYTHONPATH 变量设置为/api
5. 我们为后续的 CMD 命令设置工作目录。这仅仅意味着 Dockerfile 文件的最后一行将从工作目录中执行。
6. 我们向 Docker 表明，容器将在运行时监听端口 8000。
7. ENTRYPOINT允许配置作为可执行文件运行的容器。
8. 我们设置要执行的命令(我们将省略uvicorn命令，因为它已被声明为入口点。

现在我们将定义一个 docker-compose，它将为我们的 API 创建一个服务。
我本可以只使用 Dockerfile，因为 docker-compose 是一个定义多容器应用程序的工具，而且我们目前只有一个容器。

但是为了本教程，让我们来看看它是如何完成的:一般来说，您可能希望在单独的容器中运行多个服务，docker-compose 是将它们组合在一起的一个很好的工具。

我们在同一位置再次创建一个docker-compose.yaml文件。

作者提供的图片

在这个文件中，我们将 docker-compose 的版本设置为 3(最新的)。我们为服务命名(anonymization-api)，为构建步骤设置 Dockerfile 的路径，并将端口 8000(在容器上)映射到端口 8000(在主机上)。

最后，我们运行这个命令，它将为容器内部的 API 提供服务，并使它可以从主机访问。

**docker-compose up --build**

在 AWS 上启动并配置 EC2 实例

让我们创建一个 EC2 实例，我们将在其中用 Docker 部署 API。

• 首先，连接到您的 AWS 帐户，转到 EC2 部分并选择一个发行版。这个教程我推荐 Ubuntu 20.04 LTS。

作者截图

• 举个例子:我们不会在这里发疯。我们就挑一个比较小的:a t2.medium。

作者截图

• 现在启动实例。
• 创建一个弹性 IP 地址，并将其关联到正在运行的实例。这样，每次我们重新启动实例时，这个 IP 都不会改变。

作者截图

• 添加一个新的安全组(我将其命名为 fastapi)以允许端口 8000 上的入站流量。

作者截图

• 然后，将其添加到实例安全组:

作者截图

现在，实例已经准备好接受端口 8000 上的请求。

• 使用您的终端 SSH 到它。
• 按照 ubuntu 的官方文档安装docker和docker-compose
• 生成一个 ssh 密钥，并将其添加到您的 Github 帐户，这样它就可以无缝地执行 git 克隆(我们将在下一节中使用它)

在 Github 操作上创建部署工作流

Github Actions 是 Github 的 CI/CD 服务。它允许您基于 git 提交、合并或拉取请求等事件自动测试、构建和部署应用程序。

要了解更多关于 Github 动作的信息，请看一下这个 链接 。

要在 repo 中添加工作流程，请点击操作选项卡。

作者截图

然后，点击自行设置工作流程。

作者截图

一个 YAML 文件将被自动创建在一个workflows文件夹中，该文件夹将被创建在回购根目录下的一个.github文件夹中。

在我们的例子中，我们将工作流设置为仅在主分支上的推送请求时触发。

作者截图

将被触发的作业将在一个远程服务器上运行，GitHub Actions 将通过 **SSH Remote 命令连接到该服务器。**在其他情况下，该作业可能在 Github 运行程序上运行，例如 Github 提供的实例。

SSH Remote Commands 是一个定制的 GitHub 动作，你可以在市场上找到。它是免费使用的，你只需要在uses部分之后调用它。

将使用以下参数调用 SSH 远程命令 Github 操作

• 主机:服务器的主机名(即其公共 IP)
• 用户名:ssh 用户名
• key:ssh 私钥的内容
• 脚本:ssh 连接建立后将执行的脚本

该脚本将列出 SSH 连接建立后将在服务器上运行的命令:

• 克隆回购
• 光盘放进去
• 运行 docker-compose build 和 up 命令。

git clone git@github.com:ahmedbesbes/anonymization-api.git
cd anonymization-api
sudo docker-compose up --build -d

前面的参数host、username和key不会硬编码到 YAML 文件中。他们永远不会。这个信息很敏感。

它们将被存储为 Github Secrets 并用$符号引用，就像你调用环境变量一样。

要创建 Github secrets，请转到存储库的设置，然后单击左侧选项卡上的 secrets。Github 机密总是在 Github repo 的范围内定义。

作者截图

然后通过设置它们的名称(用大写字母)和它们的值来定义你的秘密。

作者截图

下面是你如何设置USERNAME秘密的例子。

作者截图

现在你可以提交、推动并期待奇迹的发生！

一旦你推送你的代码(在测试本地一切正常之后)，你会注意到，在点击动作标签之后，一个新的运行正在排队等待开始。

通过点击它，您可以看到构建的不同步骤。

作者截图

一旦 API 成功地部署在您的远程服务器上，启动 Postman 并在 API 端点上执行一些请求来检查它是否正常工作。

作者截图

有后！🎊现在 API 已经部署好了，可以工作了，并准备好接受请求。

结论和后续步骤

到目前为止，已经涵盖了很多内容。

我们了解了 FastAPI 提出的有趣特性。然后，我们用这个框架构建了一个 API，最后用 Docker 部署在 AWS 上。

为了使部署过程尽可能顺利，我们还使用了 GitHub Actions 工作流，该工作流在每次推送时被触发，并使用自定义操作。

现在，为了使这个 API 更适合生产，我们可以考虑这些特性(我可能会在未来的博客文章中涉及它们)

• 为 API 设置域名
• 通过添加 HTTPS 来保护 API
• 使用gunicorn代替unicorn进行部署
• 添加数据库服务(例如 PostgreSQL)来存储输入和预测:这是应用异步请求的好机会。

资源:

这里是我在学习 FastAPI 和部署时浏览的一些高质量资料。

https://fastapi.tiangolo.com/ https://www.starlette.io/ https://medium.com/@calebkaiser/why-we-switched-from-flask-to-fastapi-for-production-machine-learning-765aab9b3679 https://testdriven.io/blog/moving-from-flask-to-fastapi/

感谢阅读！🙏

我希望这篇文章对你有用。如果你对改进我建立的工作流程有任何建议，请不要犹豫，在 Github 或评论中提出。

同样，代码可以在我的回购上获得:请随意在你的项目上试用。

我就讲到这里，下次见！

照片由卡斯滕·怀恩吉尔特在 Unsplash 上拍摄

如何将 Python 无服务器功能部署到 Vercel

原文：https://towardsdatascience.com/how-to-deploy-a-python-serverless-function-to-vercel-f43c8ca393a0?source=collection_archive---------9-----------------------

让基础设施来承担重担。

照片由克里斯蒂娜·莫里路从派克斯拍摄

ercel 是一个提供无服务器运行时的平台，也称为功能即服务(FaaS)。但是，为什么我需要去无服务器？好吧，如果你需要去无服务器或没有直接的答案。通常，无服务器功能无需维护即可扩展。此外，您只在需要时才运行该函数。

我一直使用无服务器函数作为 API 端点。我对无服务器功能的特点很感兴趣。比如我不用担心基础设施；相反，我可以专注于问题。这篇文章教你如何在 Vercel 上部署一个 python 无服务器函数。我们开始吧！

设置

在这篇文章中，我将使用 GitHub 和 Vercel 。首先，我们将创建一个 git 存储库，这样我们就可以用 Vercel 连接它。

这是我创建的库的链接。将代码下载到本地机器后，可以在 api 文件夹中看到一个名为index.py的 python 文件。根据 Vercel 针对 Python 的文档，如果一个 Python 文件有一个单一的 HTTP handler 变量，继承自 api 目录内的 BaseHTTPRequestHandler 类处理程序，Vercel 会将其作为一个无服务器函数。

让我们来分解一下index.py文件的各个成分。

from http.server import BaseHTTPRequestHandler
from urllib import parse
class handler(BaseHTTPRequestHandler):
    def do_GET(self):
        s = self.path
        dic = dict(parse.parse_qsl(parse.urlsplit(s).query))
        self.send_response(200)
        self.send_header('Content-type','text/plain')
        self.end_headers()
        if "name" in dic:
            message = "Hello, " + dic["name"] + "!"
        else:
            message = "Hello, stranger!"
        self.wfile.write(message.encode())
        return

对于这个例子，我们想要处理查询字符串。如果查看文档,path实例变量包含请求路径。为了方便起见，现在让我们将path变量解析到一个字典中。此外，我已经将 HTTP 状态代码设置为 200，并将内容类型设置为纯文本。

以下代码行在字典中查找一个名为name的键。如果密钥存在，变量message将包含Hello,，后跟name!，否则为Hello, stranger!。你可以在这里阅读更多关于高级 Python 用法的内容。最后，我将返回message的编码内容，默认情况下是 utf-8。

现在，让我们转到 Vercel 以便能够导入我们的项目。

单击继续

单击 Continue 后，您应该会看到下面的对话框。

把你的 git 库链接

在我的例子中，我将使用我的 git 存储库链接，它是https://github.com/lifeparticle/vercel-python。现在点击继续，最后点击部署。

对于这篇文章，我们将不配置构建和输出设置

现在，您应该会在浏览器上看到如下所示的对话框。点击“访问”按钮，访问您的无服务器功能。在本例中，我的无服务器函数的地址是由 Vercel 生成的https://vercel-python.lifeparticle.vercel.app/。我们需要在基本 URL 的末尾添加 api/file_name 来访问该函数。添加之后，我们有了一个看起来像 https://vercel-python.lifeparticle.vercel.app/api/index 的 URL。

点击访问

现在，如果你访问链接 …

无查询字符串与查询字符串

对于第一个函数调用，我们没有提供任何查询字符串。因此它显示你好，陌生人！在第二个调用中，提供了名称菠萝。

由于我们已经将 GitHub 项目与 Vercel 链接起来，对主分支的任何更改都将触发生产部署。如果您想选择一个不同的分支作为生产分支，请遵循这个文档。

包裹

现在您知道了如何将 python 无服务器函数部署到 Vercel！欢迎来到充满新可能性的世界。如果您想将 Ruby 无服务器功能部署到 Vercel，请访问下面的链接。编码快乐！

如何用 FastAPI、Docker 和 Traefik 部署安全 API

原文：https://towardsdatascience.com/how-to-deploy-a-secure-api-with-fastapi-docker-and-traefik-b1ca065b100f?source=collection_archive---------2-----------------------

配置 HTTP S 的指南

照片由飞:D 在 Unsplash

当我们部署一个 API 来服务一个机器学习模型时，我们很少关心那个绿色的挂锁，它使得 HTTP 连接被认为是安全的，浏览器是快乐的。

作者图片

我们通常认为 HTTPS 是理所当然的，我们可能认为它只是通过一些简单的配置就可以打开*。*

事实是，添加 HTTPS 需要几个步骤。

这就是这篇文章的目的:解释为什么 HTTPS 很重要，以及当你用 Python 构建 web 应用和 API 时，如何将它添加到你的部署中。

以下是我们将在本帖中介绍的内容:

1. HTTPS 简介:它是如何运作的，为什么你应该关注它？
2. 用 FastAPI 构建 API
3. 介绍 Traefik 及其如何处理 HTTPS
4. 通过 Docker 集成 FastAPI 和 Traefik
5. 在 AWS 上部署

这个指南将最终帮助您添加 HTTPS 到您的项目。您可以重用以下代码来构建安全的项目。

事不宜迟，让我们直接开始吧🚀

PS:此代码在Github上有。*

PS:如果你想了解更多关于 FastAPI、Docker 和 Github 的动作，一定要看看我之前的* 帖子 。*

* *

复制本教程需要什么

• 注册的域名。你可以花几块钱在 T42 买到一个
• 安装在本地机器上的 Docker 和 docker-compose:你可以遵循官方的文档
• 部署 API 的远程服务器:我在 AWS EC2 上使用了一个t2-medium实例。任何同等的东西都应该是好的。
  确保这个实例有固定的 IP 地址。
• *在您的域提供者上，创建一个指向实例 IP 地址的 A 记录。我目前拥有 ahmedbesbes.com，为了这个教程，我创造了以下记录:**ssl.ahmedbesbes.com。*你可以通过选择任何你想要的子域来对你的域做同样的事情。
  OVH 的界面看起来是这样的( OVH 是我的域名提供商)

作者截图

什么是 HTTPS，你为什么要关心它？

HTTPS 是基于加密协议的 HTTP。这个协议被称为传输层安全性( TLS )，它以前被称为安全套接字层( SSL )。

换句话说，HTTPS 是加密的，以增加数据传输的安全性。

它是如何工作的？

HTTPS 背后的协议 TLS 使用不对称的公钥基础设施。该系统使用两种不同的密钥来加密双方之间的通信:

1. 私人钥匙🔐:此密钥由网站所有者控制，它是私有的，位于远程 web 服务器上。它用于解密由公钥加密的信息
2. 公钥🔑:任何希望以安全方式与服务器交互的人都可以使用此密钥。这个密钥的作用是加密数据,私钥稍后会解密这些数据。

图片由作者修改

我们为什么需要 HTTPS？

HTTPS 是一个非常有用的协议。您需要它有三个主要原因:

• *隐私:这样就没人能拦截或偷听你的消息(消息可以是你发布给朋友的文字，你填写表格的信用卡信息，图像，视频，或者你通过网络上传的任何东西)。当通过 HTTPS 发送时，该数据被**加密，*即变成一个长的字母数字串。
• 完整性:这样你发送的信息在到达目的地的途中不会被任何形式的操纵。
• 认证:这样你请求的远程服务器就能确定你就是你声称的那个人

除了给你的应用增加一个安全层，HTTPS 还是高质量软件实践的保证。这对于建立可信的用户群非常重要。

主要的互联网公司都非常重视 HTTPS。事实上，谷歌在 2014 年宣布拥有 HTTPS 将提高你在搜索结果中的排名。谷歌还让 Chrome 将所有没有 HTTPS 的网站标记为不安全。

看完这个谁还想访问你的网站？(图片由作者提供)

是时候将 HTTPS 添加到您的应用程序中了！

用 FastAPI 构建最小 API

在这一节中，我们将在一个非常简单的例子上安装并运行 FastAPI。接下来我们将看到如何保护它。

在进入代码之前，下面是项目结构的样子:

作者截图

让我们从创建虚拟环境开始:

***mkdir fastapi-ssl && cd _
pipenv install fastapi***

没什么特别的，我们将创建一个有两条路线的 API:

• 一个处理 GET 请求并在浏览器上显示以下 JSON 响应

***{"message": "Hello FastAPI + SSL"}***

• *另一个处理 **POST 请求。*这个路由需要一个包含两个键:text和author的主体，并发回一个 JSON 对象作为响应，其中包含已经发送的相同的text和author以及一个附加的status消息。

***{"status": "message received", "text": "Hello", "author": "Ahmed"}***

下面的代码定义了这两条路线。

一个非常简单的 API，有两条路径

查看这篇文章，了解更多关于用 FastAPI 构建 API 的信息。

什么是 Traefik？它如何帮助 HTTPS？

在用 Docker 打包 app 之前，我们先介绍一下 Traefik。

Traefik 是一个开源的反向代理和负载平衡器，适用于基于 HTTP 和 TCP 的应用程序，它简单、动态、自动、快速、功能全面、经过生产验证，提供指标，并与每一种主要的集群技术集成…

Traefik 的目标是拦截来自互联网的传入 HTTP 请求，并将它们路由到 Docker 运行的专用容器。它可以将任何 DNS 记录附加到正在运行的服务上。

特拉菲克在中间

Traefik 是云原生的。这意味着它可以轻松地与 Docker 和 Kubernetes 等云技术集成。在本教程中，我们将 Traefik 链接到 Docker。

上面的樱桃:Traefik 自动支持让我们加密证书。这意味着它会自动为您处理这些文件的创建和更新，以确保 HTTPS 配置正确。

让我们加密什么？

Let's Encrypt 是一个免费的、自动化的、开放的认证机构(CA)，为公众的利益而运行。这是由互联网安全研究小组(ISRG) 提供的服务。

Let's Encrypt 是一个会为我们颁发免费 SSL 证书的组织。

什么是 SSL 证书？

SSL 证书允许网站拥有 HTTPS。

它是一个保存在部署应用程序的远程服务器上的文件。它使 SSL/TLS 加密成为可能，并保存诸如公钥和网站身份等信息。

当客户端(例如您的浏览器)尝试连接到安全网站时，它首先会获得此证书的副本。这允许客户端检查远程服务器的身份并获得公钥，以便启动加密会话。

为 HTTPS 设置 Traefik

让我们从配置 Traefik 开始。这可以使用下面的 TOML 文件来完成。该文件将位于services/traefik中

Traefik 配置文件

让我们详细介绍一下每一部分都发生了什么:

**[entrypoints]**

此部分指定 Traefik 将侦听的端口。这些端口是 80 和 443 。80 是默认的 HTTP 端口，443 是 HTTPS 端口。我们将分别称它们为web和websecure。

然后，我们告诉 Traefik 将 HTTP 重定向到 HTTPS。

**[accessLog]**

这个部分告诉 Traefik 将日志打印到stdout以了解谁给谁打了电话。

**[providers]**

在本节中，我们将配置所谓的提供者。

**提供商是基础设施组件，无论是编排器、容器引擎、云提供商还是键值存储。其思想是，Traefik 查询提供者 API，以便找到有关路由的相关信息，当 Traefik 检测到变化时，它会动态更新路由。

我们希望 Traefik 在 Docker 容器前充当代理，所以我们将选择 Docker 作为提供者之一。

将exposedByDefault设置为false仅仅意味着 Traefik 不会在所有容器前充当代理。它只会在那些有 docker-compose 中描述的特定标签的人面前这样做。(我们将在下面的 Docker 部分介绍这些标签)

**[certificatesResolvers.letsencrypt.name]**

本节配置证书解析器。换句话说，Traefik 将通过 ACME 协议与 Let's Encrypt 通信:要做到这一点，您必须设置一个有效的电子邮件地址和文件名，Traefik 将把它从 Let's Encrypt 接收的信息保存在这里。当 Traefik 与 Let's Encrypt 通信时，可以成功生成和更新证书。

使用 Docker 准备部署

在本节中，我们在 docker-compose 文件中定义了两个容器:一个用于 FastAPI web 服务，另一个用于启动 Traefik。

注意，您可以有多个运行不同服务的容器，Traefik 会将流量路由到这些容器。

让我们详细说明每个容器中发生了什么:

— **api**

我们首先通过引用以下 Dockerfile 文件的路径来构建映像:

然后，我们定义将被 Traefik 读取的 docker 标签

• traefik.enable=true确保 Traefik 看到该容器并将流量路由到该容器
• 其他标签定义了指向容器的 DNS 记录(ssl.ahmedbesbes.com，也就是我为这个 API 设置的域)。他们还告诉 Traefik 使用 TLS 并使用 Let's Encrypt 来解析证书。

————**traefik**

我们首先从官方注册中提取图像。

我们将容器上的端口 80 和 443 映射到主机上的端口 80 和 443。

我们定义了三个卷:

1. 第一个卷使 Traefik 知道其他容器
2. 第二个卷将 Traefik 配置文件传递给容器
3. 第三个卷将生成的证书保存在主机上，这样就不会在每次容器重新启动时重新生成它们。这很重要，因为 Let's Encrypt 对您可以获得的证书数量有限制

在 AWS 上部署

确保本地一切正常，连接到虚拟机，克隆存储库，并在根目录下运行以下命令:

***docker-compose up --build -d***

为了让 Github 动作的部署更顺利，看看我之前的帖子。

资源

下面是我用来学习 HTTPS、Traefik 和用 Docker 部署 FastAPI 应用程序的资源的汇编列表。

不要犹豫，让我知道你在这方面找到的其他有用的资源😉

*https://howhttps.works/ https://www.valentinog.com/blog/traefik/ https://fastapi.tiangolo.com/tr/deployment/docker/ https://www.digitalocean.com/community/tutorials/how-to-use-traefik-v2-as-a-reverse-proxy-for-docker-containers-on-ubuntu-20-04 https://traefik.io/blog/traefik-2-tls-101-23b4fbee81f1/ https://www.digitalocean.com/community/tutorials/how-to-use-traefik-v2-as-a-reverse-proxy-for-docker-containers-on-ubuntu-20-04

https://www . cloud flare . com/fr-fr/learning/SSL/what-is-https/

感谢阅读🙏

让我们结束它。这篇文章提供了一个机会:

• 了解 HTTPS 及其带来的好处
• 了解关于 Traefik 以及如何使用它作为反向代理来创建 HTTPS 连接的更多信息
• 使用 Docker 通过 Traefik 部署和管理 FastAPI

我希望这是在您的项目中实施 HTTPS 的良好开端。

同样，代码可以在 Github 上获得:你可以随意使用它或者为你的项目修改它。

我就讲到这里，下次见！

照片由卡斯滕·怀恩吉尔特在 Unsplash 上拍摄

如何将张量流模型部署到 Vertex AI

原文：https://towardsdatascience.com/how-to-deploy-a-tensorflow-model-to-vertex-ai-87d9ae1df56?source=collection_archive---------11-----------------------

在 Vertex AI 中使用保存的模型和端点

在本文中，我将带您了解如何将 TensorFlow/Keras 模型部署到 Vertex AI 中，并从中获得预测。

概念

这里有几个重要的概念，所以我们进行的时候可以参考这个图表。代码片段来自 GitHub 中的这个笔记本。

向 Vertex AI 部署模型的步骤。由我图解。

基本思想是客户端访问端点。每个端点都与一个 URL 相关联。客户端发送一个带有 JSON 有效负载的 HTTP Post 请求，其中包含预测方法的输入。

端点包含许多顶点 AI 模型对象，它在这些对象之间划分流量。在上图中，80%的流量流向模型 1，10%流向模型 2，其余流向模型 3。

顶点 AI 模型是一个对象，它引用了在各种框架(TensorFlow、PyTorch、XGBoost 等)中构建的模型。).每个框架都有预构建的容器映像。如果你使用的是不被 Vertex AI 直接支持的 ML 框架，你也可以引入你的容器。

TensorFlow 容器图像会查找已保存的 Model 文件，当您从训练代码中调用 model.save(…)时，默认情况下 Keras/TensorFlow 2.0 模型会导出为这种格式。

第一步。在 Keras 中保存训练模型

在 TensorFlow 2.0 中编写机器学习模型的推荐方法是使用 Keras API。简而言之，它包括以下步骤:

# 1\. Create a tf.data Dataset
train_dataset = read_dataset(training_data_uri, train_batch_size)
eval_dataset = read_dataset(validation_data_uri, eval_batch_size)# 2\. Create a Keras Model
inputs = tf.keras.layers.Input(...)
layer_1 = tf.keras.layers.... (inputs) 
...
outputs = tf.keras.layers.Dense(...)(layer_n)
model = tf.keras.Model(inputs, output)
model.compile(optimizer='adam',
              loss='binary_crossentropy',
               metrics=['accuracy'])# 3\. Train
model.fit(train_dataset, validation_data=eval_dataset, ...)# 4\. Save model
EXPORT_PATH = 'gs://{}/export/flights_{}'.format(bucket,
                                     time.strftime("%Y%m%d-%H%M%S"))
model.save(EXPORT_PATH)

上面的关键步骤是，你的训练程序将训练好的模型保存到谷歌云存储的一个目录中。

第二步。上传模型

我建议您为每个模型使用一个唯一的显示名称(Vertex AI 确实分配了一个唯一的模型 id，但它是一个不透明的数字，不可读)。

给模型分配一个唯一的名称，因为顶点 AI 分配的唯一 ID 不是人类可以理解的

一种简单的方法是在您想要使用的名称后面附加一个时间戳，这样每次您上传一个模型时，您就有了一个新的名称:

TIMESTAMP=$(date +%Y%m%d-%H%M%S)
MODEL_NAME=flights-${TIMESTAMP}

然后，将保存的模型文件上传到上面的模型，为您的 ML 框架指定预建顶点容器:

gcloud beta ai models upload --region=$REGION \
     --display-name=$MODEL_NAME \
     --container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-6:latest \
     --artifact-uri=$EXPORT_PATH

第三步。创建端点

您还希望端点有一个唯一的名称，但是您不会创建多个端点。只有一个。因此，不需要时间戳。在创建端点之前，只需验证它不存在:

ENDPOINT_NAME=flights
if [[ $(gcloud ai endpoints list --region=$REGION \
        --format='value(DISPLAY_NAME)' --filter=display_name=${ENDPOINT_NAME}) ]]; then
    echo "Endpoint $ENDPOINT_NAME already exists"
else
    # create model
    echo "Creating Endpoint $ENDPOINT_NAME for $MODEL_NAME"
    gcloud ai endpoints create --region=${REGION} --display-name=${ENDPOINT_NAME}
fi

第四步。将模型部署到端点

将模型部署到端点，确保指定您需要的机器类型(包括 GPU 等。)和流量分流:

gcloud ai endpoints deploy-model $ENDPOINT_ID \
  --region=$REGION \
  --model=$MODEL_ID \
  --display-name=$MODEL_NAME \
  --machine-type=n1-standard-2 \
  --min-replica-count=1 \
  --max-replica-count=1 \
  --traffic-split=0=100

因为这是第一个模型，我们发送 100%的流量到这个模型

— traffic-split=0=100

如果我们有一个旧的模型，我们将指定两个模型之间的相对分割。要将 10%的流量发送到新型号，将 90%的流量发送到旧型号，我们需要:

--traffic-split=0=10,OLD_DEPLOYED_MODEL_ID=90

请注意，所有这些命令都需要模型 ID 和端点 ID(而不是模型名称和端点名称)。要从名称中获取 ID(假设您使用了我推荐的唯一名称):

MODEL_ID=$(gcloud ai models list --region=$REGION \
           --format='value(MODEL_ID)' \
           --filter=display_name=${MODEL_NAME})ENDPOINT_ID=$(gcloud ai endpoints list --region=$REGION \
              --format='value(ENDPOINT_ID)' \
              --filter=display_name=${ENDPOINT_NAME})

如果你没有使用唯一的名字(坏主意！)，您可以获得最近部署的模型或端点的 id:

ENDPOINT_ID=$(gcloud ai endpoints list --region=$REGION \
              --format='value(ENDPOINT_ID)'\
              --filter=display_name=${ENDPOINT_NAME} \
              **--sort-by=creationTimeStamp | tail -1**)

把这些放在一起。

下面是上面的所有代码片段，便于复制粘贴:

## CHANGE
EXPORT_PATH=gs://some-bucket/some-model-dir
TF_VERSION=2-6
ENDPOINT_NAME=flights
REGION=us-central1##TIMESTAMP=$(date +%Y%m%d-%H%M%S)
MODEL_NAME=${ENDPOINT_NAME}-${TIMESTAMP}
EXPORT_PATH=$(gsutil ls ${OUTDIR}/export | tail -1)
echo $EXPORT_PATHif [[ $(gcloud ai endpoints list --region=$REGION \
        --format='value(DISPLAY_NAME)' --filter=display_name=${ENDPOINT_NAME}) ]]; then
    echo "Endpoint for $MODEL_NAME already exists"
else
    # create model
    echo "Creating Endpoint for $MODEL_NAME"
    gcloud ai endpoints create --region=${REGION} --display-name=${ENDPOINT_NAME}
fiENDPOINT_ID=$(gcloud ai endpoints list --region=$REGION \
              --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME})
echo "ENDPOINT_ID=$ENDPOINT_ID"# delete any existing models with this name
for MODEL_ID in $(gcloud ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME}); do
    echo "Deleting existing $MODEL_NAME ... $MODEL_ID "
    gcloud ai models delete --region=$REGION $MODEL_ID
done# upload model
gcloud beta ai models upload --region=$REGION --display-name=$MODEL_NAME \
     --container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.${TF_VERSION}:latest \
     --artifact-uri=$EXPORT_PATH
MODEL_ID=$(gcloud ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME})
echo "MODEL_ID=$MODEL_ID"# deploy model to endpoint
gcloud ai endpoints deploy-model $ENDPOINT_ID \
  --region=$REGION \
  --model=$MODEL_ID \
  --display-name=$MODEL_NAME \
  --machine-type=n1-standard-2 \
  --min-replica-count=1 \
  --max-replica-count=1 \
  --traffic-split=0=100

第五步。调用模型

下面是客户端如何调用您已经部署的模型。假设他们在一个名为 example_input.json 的 JSON 文件中有输入数据:

{"instances": [
  {"dep_hour": 2, "is_weekday": 1, "dep_delay": 40, "taxi_out": 17, "distance": 41, "carrier": "AS", "dep_airport_lat": 58.42527778, "dep_airport_lon": -135.7075, "arr_airport_lat": 58.35472222, "arr_airport_lon": -134.57472222, "origin": "GST", "dest": "JNU"},
  {"dep_hour": 22, "is_weekday": 0, "dep_delay": -7, "taxi_out": 7, "distance": 201, "carrier": "HA", "dep_airport_lat": 21.97611111, "dep_airport_lon": -159.33888889, "arr_airport_lat": 20.89861111, "arr_airport_lon": -156.43055556, "origin": "LIH", "dest": "OGG"}
]}

他们可以发送 HTTP 帖子:

PROJECT=$(gcloud config get-value project)
ENDPOINT_ID=$(gcloud ai endpoints list --region=$REGION \
              --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME})curl -X POST \
  -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
  -H "Content-Type: application/json; charset=utf-8" \
  -d [@example_input](http://twitter.com/example_input).json \
  "[https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/endpoints/${ENDPOINT_ID}:predict](https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/endpoints/${ENDPOINT_ID}:predict)"

他们将得到 JSON 格式的结果:

{
  "predictions": [
    [
      0.228779882
    ],
    [
      0.766132474
    ]
  ],
  "deployedModelId": "2339101036930662400",
  "model": "projects/379218021631/locations/us-central1/models/3935868997391613952",
  "modelDisplayName": "flights-20211102-064051"
}

当然，它是一个 REST API，所以您可以从几乎任何语言中调用它。也有可用的客户端 API 库。

利益

在本文中，我向您展示了如何在 Vertex AI 上部署一个经过训练的 TensorFlow 模型。

Vertex AI 为机器学习模型提供了一个完全管理的、自动缩放的、无服务器的环境。只有在您使用 GPU 时，您才能享受到为其付费的好处。因为模型是容器化的，所以依赖关系管理得到了关注。端点负责流量分流，允许您以方便的方式进行 A/B 测试。

好处不仅仅是不必管理基础架构。一旦你的模型被部署到 Vertex AI，你无需任何额外的代码就可以获得许多简洁的功能——可解释性、漂移检测、监控等等。

尽情享受吧！

更多关于 Vertex AI 的阅读:

1. 给谷歌云上的新统一 ML 平台 Vertex AI 一个旋转 :
   我们为什么需要它，无代码 ML 培训到底有多好，所有这些对数据科学工作意味着什么？
2. 如何将 TensorFlow 模型部署到 Vertex AI :在 Vertex AI 中使用保存的模型和端点
3. 使用 Python 在 Vertex AI 上开发和部署机器学习模型:编写让你的 MLOps 团队满意的训练管道
4. 如何在 Vertex AI 中为超参数调整构建 MLOps 管道 :
   为超参数调整设置模型和协调器的最佳实践

如何将 Azure 机器学习模型部署为安全端点

原文：https://towardsdatascience.com/how-to-deploy-azure-machine-learning-models-as-a-secure-endpoint-704382bc71fd?source=collection_archive---------12-----------------------

了解如何使用 Azure API 管理构建 MLOps 管道，以将模型部署为安全端点。

1.介绍

机器学习运营( MLOps )的目标是在生产中部署和维护机器学习模型。MLOps 管道的一个常见工件是最终用户应用程序可以使用的实时评分端点。关键是使用网络隔离和身份验证来保护此端点。在这篇 blogpost 和 git repo [blog-mlopsapim-git](https://github.com/rebremer/blog-mlopsapim-git)中，讨论了 Azure 中的 MLOps 管道，它执行以下操作:

• 1.创建 Azure DevOps 项目并创建 Azure ML、AKS 和 API 管理基础架构
• 2.在 Azure ML 中训练和创建模型
• 3a。将模型作为 docker 映像部署在隔离的 Azure Kubernetes 集群上
• 3b。使用 Azure API 管理和 Azure AD 公开安全端点

另请参见下图:

1.架构概述，图片由作者提供

这个项目是基于克莱门斯·西布勒所做的伟大工作，可以在这里找到。在这篇博文的剩余部分，将会更详细地解释这个项目。在下一章中，将描述如何设置 MLOps 项目。

2.设置 MLOps 项目

在本章中，将创建一个 MLOps 项目。在这方面，需要做以下工作:

• 2.1 先决条件
• 2.2 创建 Azure DevOps 项目
• 2.3 创建服务连接
• 2.4 替代变量

2.1 先决条件

本教程需要以下资源:

• Azure 账号
• 天蓝色 DevOps
• Azure CLI (推荐，也用于故障排除)

随后，转到 Azure 门户并创建一个资源组，所有 Azure 资源都将部署在该资源组中。这也可以使用以下 Azure CLI 命令来完成:

az group create -n <<your resource group>> -l <<your location>>

2.2 创建 Azure DevOps 项目

Azure DevOps 是一个工具，可以持续地构建、测试和部署你的代码到任何平台和云。创建新项目后，单击存储库文件夹并选择导入以下存储库:

• 【https://github.com/rebremer/blog-mlopsapim-git

也见下图。

2.2 将存储库添加到您的 Azure DevOps 项目中，图片由作者提供

2.3 创建服务连接

从 Azure DevOps 访问资源组中的资源需要服务连接。转到项目设置，服务连接，然后选择 Azure 资源管理器，另见下图。

2.3.1 将存储库添加到您的 Azure DevOps 项目，image by author

选择服务主体身份验证，并将范围限制到您之前创建的资源组，另请参见下图。

2.3.2 按作者将范围限制到资源组、图像

2.4 替代变量

转到您的 repo，找到[pipelines/german-credit-config.yml](https://github.com/rebremer/blog-mlopsapim-git/blob/master/pipelines/german-credit-config.yml)并修改值以指向您的工作区，也见下文

variables: 
  #
  ml_workspace_connection: '<<service connection created in 2.3>>'  
  ...
  # subscription 
  ml_subscription_id: '<<your subscription>>'
  ...
  # apim
  ml_apim_name: '<<your apim name'
  ml_apim_email: '<<your email address>>'
  ml_location: 'westeurope'
  ml_tenant_id: '<<your tenant id>>'

所有其他变量都可以替换，但这不是成功构建所必需的。MLOps 项目现在可以运行了。

3.使用 Azure API 管理部署 MLOps 管道

在这一章中，项目开始运行，MLOps 管道将被部署，生成安全端点作为主要工件。在这方面，需要做以下工作:

• 3.1 MLOps 管道描述
• 3.2 运行管道
• 3.3 测试安全端点

3.1 MLOps 管道描述

在这个 git repo 中，创建了四个管道，它们将在下一章中运行。管道可以描述如下:

• [pipelines/1-german-credit-infrastructure.yml](https://github.com/rebremer/blog-mlopsapim-git/blob/master/pipelines/1-german-credit-infrastructure.yml) -部署带有数据集的 Azure ML 工作区、VNET 的私有 AKS 集群和 Azure Api 管理
• [pipelines/2-german-credit-train-and-register.yml](https://github.com/rebremer/blog-mlopsapim-git/blob/master/pipelines/2-german-credit-train-and-register.yml) -自动训练和注册模型
• [pipelines/3a-german-credit-deploy.yml](https://github.com/rebremer/blog-mlopsapim-git/blob/master/pipelines/3a-german-credit-deploy.yml) -将训练好的模型部署到 AKS 集群，创建私有端点和密钥认证。密钥更新是部署过程的一部分。
• [pipelines/3b-german-credit-apimoperation.yml](https://github.com/rebremer/blog-mlopsapim-git/blob/master/pipelines/3b-german-credit-apimoperation.yml) -部署暴露私有 AKS 端点的 APIM 端点。APIM 的用户身份验证基于 Azure AD。反过来，APIM 后端是 AKS 私有端点的一部分，密钥身份验证用于向 AKS 端点进行身份验证。密钥更新是部署过程的一部分。

在下一章中，将描述如何部署管道 1。对于其他三个管道，可以遵循类似的过程。

3.2 运行管道

转到您的 Azure DevOps 项目，选择管道，然后单击“新建管道”。转到向导，选择您之前创建的 Azure Repos Git 和 git repo。在“配置”选项卡中，选择“现有的 Azure Pipelines YAML 文件”,然后选择可以在 git repo 中找到的[pipelines/1-german-credit-infrastructure.yml](https://github.com/rebremer/blog-mlopsapim-git/blob/master/pipelines/1-german-credit-infrastructure.yml),也见下文。

3.2.1 在管道配置向导中，选择现有的 Azure 管道 YAML 文件，按作者排序的图像

一旦创建了管道，它就会立即运行，如下所示。

3.2.2 Azure DevOps 部署现代数据管道，图片由作者提供

作业运行后，部署所有资源并执行测试。随后，运行属于管道文件夹的所有其他管道，如 3.1 中所述。

如果所有管道都运行成功，那么在 API 管理中会创建一个 API，指向私有 AKS 集群的 URL

3.3 在 API 中成功部署，图像由作者提供

随后，score 操作使用 JWT 令牌验证来验证传入的 Azure AD 请求，并使用带密钥的命名值向 AKS 私有端点进行身份验证，另请参见[api_policy_template.xml](https://github.com/rebremer/blog-mlopsapim-git/blob/master/pipelines/scripts/api_policy_template.xml)。

3.3.测试安全端点

在所有管道运行之后，部署一个由 API 管理器公开的端点。身份验证需要 Azure 承载令牌。通常，托管身份或服务主体用于创建承载令牌。在 github 中，可以找到一个用服务主体生成的承载令牌进行测试的例子。

作为一个快速测试，也可以决定使用以下 CLI 命令从已经登录的用户创建一个承载令牌。

az account get-access-token --query accessToken --output tsv

然后，令牌可以被复制并在下面的脚本(或 Postman)中使用

token = resp.json()['access_token']
#
url = 'https://<<your apim>>.azure-api.net/testprivv2/score'
#
test_data = {
  'data': [{
    "Age": 20,
    "Sex": "male",
    "Job": 0,
    "Housing": "own",
    "Saving accounts": "little",
    "Checking account": "little",
    "Credit amount": 100,
    "Duration": 48,
    "Purpose": "radio/TV"
  }]
}

headers = {'Content-Type':'application/json', 'Authorization': 'bearer ' + token}
resp = requests.post(url, json=test_data, headers=headers)

print("Prediction (good, bad):", resp.text)

4.结论

机器学习操作( MLOps )旨在部署和维护生产中的机器学习模型。MLOps 管道的一个常见工件是由最终用户应用程序使用的 REST 端点。在 blogpost 和 git repo [blog-mlopsapim-git](https://github.com/rebremer/blog-mlopsapim-git),中，讨论了一个项目，该项目 1)所有的基础设施，2)构建和训练一个模型，3a)部署模型作为端点，3b)保护端点，参见下面的体系结构。

4.架构概述，按作者列出的图像

如何使用 GitHub 操作将 dbt 部署到生产环境中

原文：https://towardsdatascience.com/how-to-deploy-dbt-to-production-using-github-action-778bf6a1dff6?source=collection_archive---------2-----------------------

如何将 dbt 部署到生产环境中。

由萨姆·劳埃德在 Unsplash 上拍摄的照片

随着现代数据栈的兴起，越来越多的人使用 dbt 作为数据转换的主要工具，也就是数据建模。Fishtown 的员工创造了一个令人惊叹的 dbt 云产品，能够满足大大小小的数据团队的需求。借助 dbt Cloud，任何分析师，无论是经验丰富的还是新手，都可以轻松地开始建模并将数据转换管道部署到生产中。

我强烈推荐看看 dbt Cloud，因为该产品不仅仅是帮助您部署 dbt。首先，让我们看看如何不应该将 dbt 部署到生产环境中。

不要做什么

有许多方法可以将 dbt 部署到生产环境中。然而，并不是所有的方法都是好的。以下是一些不太好的方法:

启动一个计算实例？

洛伦佐·埃雷拉在 Unsplash 上的照片

一种常见的方法是启动计算实例并安装所需的包。从这里，人们可以运行一个 cron 作业来按计划执行git pull和dbt run。

这是一个经典的过度解决方案，因为 dbt 不需要大量的资源来运行。dbt 实际做的是编译查询，并将它们发送到您的数据仓库并等待响应。如果您想要管道故障通知，您通常也必须自己实现。

此外，大多数时候，您的实例将会闲置浪费您的资金，因为 dbt 通常一天只运行几分钟到不到一个小时。使用此选项也没有简单的解决方案来实现 CI/CD。

好的，气流呢？

照片由 Michal Matlon 在 Unsplash 上拍摄

嗯，看情况。如果生产中还没有气流运行，现在可能就不需要了。还有比这更简单/优雅的解决方案(dbt Cloud，GitHub Actions，GitLab CI)。此外，这种方法与使用计算实例有许多共同的缺点，例如浪费资源，并且没有 CI/CD 的简单方法。

但是，如果您的团队使用 Airflow 或任何其他管道编排器，您可以考虑编写一个 dag 来触发 dbt。特别是当你在不同的时间间隔有不同的摄入，需要触发 dbt 或随后的任务时。

使用 dbt 云在生产中部署 dbt

在我看来，这是首选。借助 dbt Cloud，您拥有一个永远免费的开发人员席位，一个人的数据团队绝对可以利用这个席位。如果您的团队规模较大，您可以每人每月支付少量费用，并获得以下所有功能:

• 基于浏览器的 IDE
• 作业调度
• 每日不限跑步次数
• 记录和警报
• 数据文档
• GitHub 和 GitLab 集成
• 源新鲜度报告
• 根据拉取请求构建

使用 GitHub 动作在生产中部署 dbt

因为 dbt 总是使用 git 部署，所以利用您选择的 git 提供者的 CI/CD 功能是将 dbt 部署到生产环境的最佳方式。使用这种方法，您将获得很大的灵活性。

让我们看看如何使用 GitHub Action s 来做到这一点。免费配额对您和您的团队来说可能足够了，但是如果您有一个大型团队或者在其他项目中使用 GitHub Action，您可能会达到配额并需要升级。

为 GitHub 操作设置 dbt 配置文件

在您的存储库的根目录下创建一个profiles.yml文件。每次运行时，dbt 都会在 settings 中查找这个文件进行读取。

如果使用不同于 BigQuery 的数据仓库，请确保相应地更改参数。按照这里的指令，环境变量可以被定义为 GitHub 中的存储库机密。

注意，我们对不同的环境有两个不同的目标:dev 和 prod。运行 dbt run 将默认为 dev(由 target 键配置)。如果您想在 prod 目标上运行，请使用dbt run --target prod。

设置凭据

在使用 GitHub 操作运行任何东西之前，您需要一个服务凭证来验证对您的数据仓库的访问。强烈建议您为此创建一个专用凭据，而不是使用您自己的帐户。这样，如果您由于某种原因无法访问您的帐户，该服务仍将运行。

请务必授予您的帐户必要的权限。在上面的例子中，我们使用 BigQuery，这意味着创建一个github-action服务帐户，授予它对数据源的读权限和对数据目的地的写权限。

如果您使用文件凭证(服务帐户而不是用户名和密码)，您仍然可以像上面一样使用 GitHub secret，并使用echo命令将其写入文件。

dbt 按计划运行

您可以使用下面的模板来添加在 cron 时间表上运行的 GitHub Actions 作业。将此文件添加到您的 repo 中的.github/workflows/文件夹。如果文件夹不存在，请创建它们。

这个脚本将为大多数 dbt 工作流执行必要的步骤。如果您有另一个特殊命令，如 snapshot 命令，您可以在中添加另一个步骤。

使用 cron 调度触发该工作流。上面配置的计划意味着每天在 UTC 时间上午 5 点和下午 5 点运行工作流。所有时间都采用 UTC，因此您可能希望将时间表转换为您的本地时间。

就是这样，作业每天会被触发两次，如果作业失败会通知你。

合并时运行 dbt

许多开发团队的一个常见工作流程是，每当代码库发生变化时，就创建pull requests。对上面的yml文件进行简单的修改就可以实现这一点。

push:
    branches:
      - main

使用拉取请求进行测试

此事件的工作流脚本与上面的非常相似。一个主要的区别是，这个工作流将在开发环境而不是生产环境中运行。这确保了任何更改在部署到生产环境之前都经过验证、审查和测试。

您可以看到我们不需要指定目标，因为 dev 是我们的profiles.yml文件中的默认目标。每次有一个pull request到 main，这个工作流就会运行。

一次成功的工作流运行—作者提供的图片

在较小的型号上，GitHub Actions 只需要 1 分钟就可以完成所有工作。还不错！如果你有太多的模型或者太多的数据，那么每次都运行是没有意义的。我将在以后的文章中解决这个问题。

林挺与 sqlfluff

在编写 SQL 模型时，我错过的一件事是一个好的 linter。遵循一致同意的约定是很重要的，这样你的代码库就不会随着时间的推移而失去控制。使用 dbt 的林挺有点复杂，因为它实际上是使用不同方言的 Jinja SQL。

我也在这里分享我们的 sqlfluff 配置，供你参考。

结论

这星期就这些了。我们涵盖了:

• 为 GitHub 操作设置 dbt 和凭证
• 在 cron 调度上运行 dbt
• 对 main 的 pull 请求运行 dbt
• 使用 sqlfluff 的林挺 dbt 代码

✌️

如何在 Streamlit 上部署交互式 Pyvis 网络图

原文：https://towardsdatascience.com/how-to-deploy-interactive-pyvis-network-graphs-on-streamlit-6c401d4c99db?source=collection_archive---------12-----------------------

使用 Python 在线发布您美丽的网络图，并简化它，让全世界都能看到并与之互动

作者图片

网络图的可视化有助于我们更好地理解多个实体之间的复杂关系。

除了静态图像，Python 库如Pyvis允许我们为网络可视化构建高度交互图形。与其让这些图表闲置在您本地的 Jupyter 笔记本和文件中，不如将它们部署到网上供其他人使用。

在本文中，我们将了解到将 Pyvis 交互式网络图部署为 Streamlit web 应用程序，并让您的用户手动选择要可视化的节点。

在 pyvis BSD 许可下使用的网络|图像示例

内容

【1】目标【2】分步指南(3)总结**

(1)目标

Streamlit 是一个开源的 Python 库，可以轻松创建和共享用于数据科学的定制 web 应用。所有这些只需要几行代码就可以在几分钟内完成。

这个项目的目标是在线发布 Pyvis 网络图，以便用户可以访问 web app 并直接与图形进行交互。

本文基于 网络分析和药物-药物相互作用的可视化 项目。因此，我们将再次使用来自斯坦福网络分析项目http://snap.stanford.edu/biodata/datasets/10001/10001-ChCh-Miner.html的公开药物相互作用数据集。

****

要查看最终完成的网络图 web 应用程序，您将很快学会如何创建，请单击 此处 或观看下面的 gif 。

药物相互作用网络图应用程序演示|作者图片****

(2)分步指南

****步骤 1 —初始设置****

我们首先安装 Streamlit 和其他必要的 Python 网络库:

****pip install **streamlit** **pyvis** **networkx******

要确认 Streamlit 已经成功安装，您可以在命令提示符下执行streamlit hello:

作者图片

****步骤 2-文件夹结构和 Python 脚本****

我们通过创建如下所示的项目文件夹来设置项目的组件:

空荡荡的。py 文件( pyvis_network_app.py )构成了后续步骤中所有 Python 代码的主文件。**

****步骤 3-导入依赖关系和数据****

我们填充空白的。py 文件，方法是导入必要的依赖项和数据集。**

******# Import dependencies**
import streamlit as st
import streamlit.components.v1 as components
import pandas as pd
import networkx as nx
from pyvis.network import Network**# Read dataset**
df_interact = pd.read_csv('data/processed_drug_interactions.csv')****

步骤 4—定义布局

由于 Streamlit 应用程序本质上是一个网站，我们需要计划如何组织网站布局。例如，我们可以首先通过用st.title定义一个 title 元素来创建一个标题头:

******# Set header title**
st.title('Network Graph Visualization of Drug-Drug Interactions')****

我们还想让用户选择他们希望在网络图中可视化的项目(又名节点)。我们可以通过用st.multiselect定义一个多选下拉菜单 菜单来做到这一点。

这样，用户现在可以选择他们想要的节点。因为药品节点太多，我通过预选几个药品缩小了物品清单。

******# Define selection options and sort alphabetically**
drug_list = ['Metformin', 'Glipizide', 'Lisinopril', 'Simvastatin',
            'Warfarin', 'Aspirin', 'Losartan', 'Ibuprofen']
drug_list.sort()**# Implement multiselect dropdown menu for option selection**
selected_drugs = st.multiselect('Select drug(s) to visualize', drug_list)****

******步骤 5 —流量控制******

st.multiselect返回用户从下拉菜单中选择的条目的 Python 列表。基于这些选择的项目，我们可以构建用户希望可视化的定制网络图。

我们实现了流控制，以便在初始站点加载时显示欢迎消息(当用户还没有选择任何项目时),并在用户选择了至少一个项目时生成网络图。

******# Set info message on initial site load**
if len(selected_drugs) == 0:
   st.text('Please choose at least 1 drug to get started')**# Create network graph when user selects >= 1 item**
else:
   # *Code for filtering dataframe and generating network*****

Streamlit 从上到下运行，因此当选择发生变化(例如，添加或删除项目)时，将基于新项目集生成新的网络图。

为了使本文简洁，上面省略了创建网络图的代码(在 else 语句中)。您可以在步骤 6 中的要点中查看完整的代码。

步骤 6 —在本地和 Streamlit 云上显示 HTML

生成的 Pyvis 网络图被导出为一个 HTML 文件，在读入 Streamlit 应用程序进行显示之前，我们会先将其保存到一个文件夹中。

在本地运行app时，我们可以创建一个指定的目标文件夹(如 /html_files )来保存网络图 html 文件。

为了解决这个问题，我们可以使用 Streamlit webserver 默认的临时文件夹 ( /tmp )来保存 HTML 文件。从那里，我们可以在加载 HTML 文件进行显示之前读取它。****

为了考虑本地和在线运行的场景，我们可以在我们的脚本中实现一个 try-except 块:

********# Save and read graph as HTML file (on Streamlit Sharing)**
try:
   path = '/tmp'
   drug_net.save_graph(f'{path}/pyvis_graph.html')
   HtmlFile = open(f'{path}/pyvis_graph.html','r',encoding='utf-8')**# Save and read graph as HTML file (locally)**
except:
    path = '/html_files'
    drug_net.save_graph(f'{path}/pyvis_graph.html')
    HtmlFile = open(f'{path}/pyvis_graph.html','r',encoding='utf-8')******

然后我们创建一个 Streamlit 组件 来显示 HTML 代码。

********# Load HTML into HTML component for display on Streamlit**
components.html(HtmlFile.read())******

要在本地查看应用程序，您可以在您的命令提示符中执行以下命令(从项目目录中):

******streamlit **run** pyvis_network_app.py******

完整的 Python 脚本:

第 7 步—在 Streamlit 云上部署

现在我们的 Python 脚本已经完成，我们可以在 Streamlit 共享 上部署我们的网络图。除了脚本，我们还需要在文件夹中包含一个requirements . txt文件。

在注册并收到邀请后，您可以登录并选择您的网络图 app 的 GitHub repo，然后点击部署按钮。

Streamlit 实际分享|在 Apache 许可证 2.0 下使用的图片

您的应用程序的网络链接基于您的 GitHub 帐户、回购和分行。比如这个 app 的链接是:【https://share.streamlit.io/】T2肯尼特伦蒂/pyvis-network-graph-streamlit/main/pyvis _ network _ app . py****

一旦部署完成，您就可以与全世界分享您的应用了！随后，每次您执行 Git 推送来更新 Python 脚本时，应用程序都会自动刷新以反映这些更改。****

Fernand De Canne 在 Unsplash 上拍摄的照片

(3)总结

在本文中，我们看到了如何在 Streamlit 的帮助下轻松地在线部署交互式 Pyvis 网络图。你可以在这里查看最终产品。

还有更多的功能可以增强用户的 Streamlit web 应用体验，所以请查看文档。您也可以在此 GitHub repo 中访问该项目的代码。

在你走之前

欢迎您加入我们的数据科学学习之旅！点击此媒体页面，查看我的 GitHub ，了解更多精彩的数据科学内容。享受在 Streamlit 上部署网络图的乐趣！

******

参考

• 马林卡·齐特尼克，&朱尔·莱斯科维奇。(2018).生物快照数据集:斯坦福生物医学网络数据集集合
• 使用 Streamlit 将 Excel 变成漂亮的 Web 应用程序******

如何将大规模深度学习模型部署到生产中

原文：https://towardsdatascience.com/how-to-deploy-large-size-deep-learning-models-into-production-66b851d17f33?source=collection_archive---------4-----------------------

部署具有 GB 规模的培训的深度学习模型，并将它们作为商业产品在线托管

部署大型深度学习模型——图片来自 Pexels 的亚历山大·奈特

学习如何将深度学习模型从本地机器作为离线产品部署到在线产品是非常重要的，但主要挑战之一是训练模型的大规模。这篇文章将展示在部署更大规模的深度学习模型时，不同的解决方案和方法。

训练后的深度学习模型

在选择了具有最佳调整和预测时间的最佳算法之后，您最终完成了模型的训练。
是时候告诉你的朋友你的成功并庆祝一下了，对吗？如果您希望在线部署模型，并快速预测响应和管理大规模的训练负载，则情况并非如此！

另一方面，Web 服务更便宜，可以提供免费空间来部署 ML 模型，但在规模方面有限制，如 Heroku Platform 和 Streamlit Cloud 或者，你必须为部署深度学习模型支付昂贵的服务。但同样，当涉及到需要 GPU 或 TPU 高计算能力的千兆字节训练模型时，大小将是一个巨大的挑战。

如果模型是在 GPU 或 TPU 云服务中训练的，则 CPU 性能可用性是一个问题。深度学习模型可能会遇到缓慢的在线处理，或者可供其他应用程序使用，例如通过 API 调用。并且由于深度学习模型的巨大规模和其他问题，例如在 TPU 上运行和训练模型以及在 CPU 上部署，因此很难部署深度学习模型。因此，选择如何部署具有与本地机器或 Colab 笔记本培训相同性能的云服务是硬件考虑的关键。

在深度学习中部署模型

通过使用像 Streamlit、 Flask 和 Django 这样的 Python 框架，有许多不同的方式将深度学习模型部署为 web 应用。然后，使用 Flask RESTful 为模型服务构建一个 REST API，以便与其他在线应用程序进行交互，并使您的模型在被调用时及时动作。(这里有一篇构建 API 的好文章)。

在构建了 web 应用程序接口之后，是时候将大尺寸的 TensorFlow 、 Keras 或 PyTorch 模型部署到真实环境中了。下面的例子使用 Streamlit 加载张量模型，但是通过阅读带下划线的特定库的文档，确保如何保存和加载您自己的模型。

大型训练模型存储在哪里，如何存储？

有许多方法，但让我们展示最常用和最容易使用的免费方法，但有基于您消费多少和存储数据的区域的限制(继续提供免费服务，然后您可以在免费订阅的基础上以更低的价格扩展它)。亚马逊 S3 和谷歌云存储可以归类为**【云存储】**工具。找到更多关于亚马逊 S3 和谷歌云存储的信息，创建一个存储桶(保存数据的容器)来存储你的 Gb 大小的模型。

• 下面是一个使用 AWS S3 云存储 的例子
• 在 GCP (Google 云平台)创建云存储的代码示例如下所示:

# Colab Notebook! Run code in each cell
from google.colab import auth
auth.authenticate_user()  # Authenticate your cloud account# your project ID in GCP ( from google console my project ) 
CLOUD_PROJECT = 'axial-trail-334'# storage name
BUCKET = 'gs://' + 'axial-trail-334' + '-tf2-safarji-model' 
print(BUCKET)# with $ or !gcloud config set project 'axial-trail-334'
!gcloud config set project $CLOUD_PROJECT # with $  (create the BUCKET)
!gsutil mb $BUCKET# Revoked credentia
ls!gcloud auth revoke --all## with $  (check BUCKET) 
!gsutil ls -r $BUCKET 

这样，您就可以将模型部署到 AI 平台上了。在人工智能平台中，模型资源包含不同版本的模型。模型名称在项目中必须是唯一的。首先，让我们创建一个模型。

# Create model in Google Cloud (GCP) after following above steps 
MODEL = 'newmodel-T5'!gcloud ai-platform models create $MODEL --regions=us-central1# check google

• 在人工智能平台云平台，你会看到你的模型如下:

GCP 控制台——来自作者

• 基于您的模型类型 TensorFlow 或其他创建您的模型部署版本。

GCP 控制台——来自作者

重要提示:如果保存模型的桶大小以 Gb 为单位非常大，由于大小超出限制，您将无法获得如下所示的 AI 平台服务。

GCP 控制台——来自作者

遗憾的是，此限制目前不可调整，但未来可能会调整。与此同时，您需要调整 vocab 和嵌入大小，或者减少模型的整体大小。此外，请联系谷歌云，根据您的项目名称调整每个项目的配额【cloudml-feedback@google.com】。

*问题是他们的人工智能平台规模的大多数云提供商接受大型模型。

还有别的解决方法吗？

是的，您可以选择一个定制深度学习云实例 (VM)和大小来部署您的模型在 GPU 和 TPUs 方面所需的最佳要求。然而，存储模型的桶将是相同的，并通过 GCP 将它加载到新服务器的新实例中，或 AWS 实例中。

***最重要的是:***AWS 中还有另外一个服务，可以部署大型变形金刚:

https://aws.amazon.com/sagemaker/

云服务中的存储桶

在云服务中创建存储桶之后，是时候存储和加载模型了。下面是加载的一个片段:

注意:确保使用缓存和其他策略来优化基于您使用的框架的 web 应用程序中的模型加载，因为这将有助于避免每次使用或预测时再次调用模型所耗费的时间和带宽。

结论:

训练大规模的深度学习模型只是数据科学项目的一个方面，该项目投入大量精力使其在生产中(在线)可用。在这篇文章中，我们展示了在部署更大规模的深度学习模型时可以遵循的不同解决方案和方法。

根据您的应用程序，您可能需要选择一个可用选项，哪些云服务和哪些自定义实例支持模型部署和基础架构。然而，这篇文章只是我在部署大型深度学习模型时所经历的一个例子。但是我认为它为云服务和云存储工具方面的另一个概述提供了一个起点。生产中的深度学习模型还有很多其他后续动作，包括在 GPU 和 TPU 上的训练评测；然而，这些是为下一篇文章准备的。

参考资料:

https://cloud.google.com/ai-platform/prediction/docs/deploying-models https://aws.amazon.com/getting-started/hands-on/build-train-deploy-machine-learning-model-sagemaker/ https://www.tensorflow.org/tutorials/keras/save_and_load https://acloudguru.com/videos/cloud-provider-comparisons/cloud-provider-comparisons-aws-vs-azure-vs-gcp-storage?utm_campaign=11244863417&utm_source=google&utm_medium=cpc&utm_content=469352928666&utm_term=_&adgroupid=115625160932&gclid=Cj0KCQiA2NaNBhDvARIsAEw55hjHEBCHxdry4t-gA2qgkNZll1W-yT1ELlVPnKOkzP1e_0UgutXWVvMaAk9iEALw_wcB

这篇文章中的所有源代码以及更多内容可以在我的 GitHub 上找到:https://gist.github.com/A-safarji

如何部署机器学习模型

原文：https://towardsdatascience.com/how-to-deploy-machine-learning-models-601f8c13ff45?source=collection_archive---------2-----------------------

在网络上部署机器学习模型的最简单方法

介绍

我将介绍在 web 上部署机器学习应用程序的最简单的方法。在之前的笔记本中，我已经使用线性和基于树的模型建立了机器学习模型。事实证明，经过超调优的 XGboost 模型表现最佳。这就是为什么今天我们将使用 XGboost 构建一个鱼体重预测 web 应用程序。一般来说，部署 ML 模型有不同的选项，比如 Flask、Django、Streamlit 等。今天我将使用 Streamlit，因为这是最简单快捷的方法，而且不需要任何 web 开发知识。

ML 模型部署演示(作者供图)

∘ 简介
∘ 鱼重预测应用
∘ 是怎么做到的？∘结论:

鱼体重预测应用

你可以在这里看到演示。

这里可以看到 GitHub 代码。

怎么做到的？

有三个主要的 python 文件来构建应用程序。

作者照片

1. model.py —构建 ML 模型并保存。

2。prediction.py —测试保存的 ML 模型。

3。main.py —运行 web 应用程序的主文件。

为了自己构建和部署 ML 项目，需要遵循以下 7 个步骤。

第一步:使用 Pycharm IDE 创建一个新的虚拟环境。

Pycharm IDE，作者照片

第二步:安装必要的库。

在这里的 requirements.txt 中，我创建了所有需要安装的库。您可以使用以下方式下载并安装该文件:

pip install -r /path/to/requirements.txt

或者您可以使用 pip 逐个安装每个库。

第三步:建立最佳机器学习模型并保存。

model.py 在这个文件中，我创建了一个机器学习模型，并保存为 JSON 文件 best_model.json 。

best_xgboost_model.save_model("best_model.json")

你可以在我的上一篇文章中看到 ML 模型是如何构建的详细解释。

第四步:测试加载的模型。

prediction.py 在这个文件中，我测试了加载的模型，并使用。

np.save('classes.npy', label_encoder.classes_)

第五步:创建 main.py 文件

• 步骤 5.1 导入库和数据集

import streamlit as st
import pandas as pd
from sklearn.preprocessing import  LabelEncoder
import xgboost as xgb
import numpy as npst.header("Fish Weight Prediction App")
st.text_input("Enter your Name: ", key="name")
data = pd.read_csv("fish.csv")

• 步骤 5.2:加载保存的标签编码器类

encoder = LabelEncoder()
encoder.classes_ = np.load('classes.npy',allow_pickle=True)

• 步骤 5.3:加载保存的最佳模型

# load model
best_xgboost_model = xgb.XGBRegressor()
best_xgboost_model.load_model("best_model.json")

• 步骤 5.4:在网页上显示数据帧

如果复选框被选中，显示训练数据

if st.checkbox('Show dataframe'):
    data

作者照片

• 步骤 5.5:选择鱼种

从所有鱼的独特值中选择鱼的名称。

st.subheader("Please select relevant features of your fish!")
left_column, right_column = st.columns(2)
with left_column:
    inp_species = st.radio(
        'Name of the fish:',
        np.unique(data['Species']))

作者照片

• 步骤 5.6:使用滑动窗口选择每个特征值

input_Length1 = st.slider('Vertical length(cm)', 0.0, max(data["Length1"]), 1.0)
input_Length2 = st.slider('Diagonal length(cm)', 0.0, max(data["Length2"]), 1.0)
input_Length3 = st.slider('Cross length(cm)', 0.0, max(data["Length3"]), 1.0)
input_Height = st.slider('Height(cm)', 0.0, max(data["Height"]), 1.0)
input_Width = st.slider('Diagonal width(cm)', 0.0, max(data["Width"]), 1.0)

作者照片

• 步骤 5.7:制作预测按钮

一旦用户点击该按钮，物种输入将从文本转换为相关的数字，然后所有输入的特征与特定的形状连接起来，模型预测就完成了！

if st.button('Make Prediction'):
    input_species = encoder.transform(np.expand_dims(inp_species, -1))
    inputs = np.expand_dims(
        [int(input_species), input_Length1, input_Length2, input_Length3, input_Height, input_Width], 0)
    prediction = best_xgboost_model.predict(inputs)
    print("final pred", np.squeeze(prediction, -1))
    st.write(f"Your fish weight is: {np.squeeze(prediction, -1)} Gram")

作者照片

第六步:上传本地项目到 Github

您可以使用 git 上传您的本地项目，或者您可以将文件夹拖放到 GitHub 上的一个空存储库中。

第七步:在 细流 上创建账户

最后一步是创建一个账户，点击“从现有的 repo”连接到你的 GitHub 库

Streamlit，作者照片

结论:

没错，就是洒脱。在一般建筑中，机器学习应用主要由两部分组成。第一步是构建模型，第二步是部署和监控模型。今天，我们已经使用 Streamlit 完成了部署部分。这个简单的应用程序只是说明了该模型是如何部署的，它可以作为其他大型项目的样本。在下一篇文章中，我还将尝试使用另一种方法来部署 ML 模型。

如果你想了解更多关于应用数据科学的信息，这里是我的新 YouTube 频道——AI 学院与朋友

https://www.youtube.com/channel/UCvlF0PPaQ2GAuqYKJT4UpJQ

我希望你喜欢它，现在可以开始自己创建漂亮的应用程序。

如果你喜欢我的文章，想看即将到来的故事，请在 medium 上关注我。

https://medium.com/@gkeretchashvili

如何使用 FastAPI 将机器学习模型部署为微服务

原文：https://towardsdatascience.com/how-to-deploy-machine-learning-models-as-a-microservice-using-fastapi-b3a6002768af?source=collection_archive---------8-----------------------

使用 FastAPI 实施微服务| Ashutosh Tripathi | Data Science Duniya

截至目前，FastAPI 是使用 python 3.6+版本构建微服务的最流行的 web 框架。通过将机器学习模型部署为基于微服务的架构，我们使代码组件可重用、高度维护、易于测试，当然还有快速响应时间。FastAPI 是基于 ASGI(异步服务器网关接口)而不是 flask 的 WSGI (Web 服务器网关接口)构建的。这就是它比基于 flask 的 API 更快的原因。

它有一个数据验证系统，可以在运行时检测到任何无效的数据类型，并以 JSON 格式向用户返回错误输入的原因，这使得开发人员不必显式地管理这个异常。

在这篇文章中，我们的目标是在 FastAPI 的帮助下，将机器学习模型部署为微服务。所以我们会把重点放在那部分，而不是放在模型训练上。

github repository 中也提供了完整的源代码。你会在文章的末尾看到资源库的链接。

第一步。准备好您想要为其创建 API 的模型

为了创建用于预测的 API，我们需要准备好模型，因此我编写了几行代码来训练模型，并将其作为 LRClassifier.pkl 文件保存在本地磁盘中。我没有关注探索性的数据分析、预处理或特性工程部分，因为这超出了本文的范围。

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
import pickle# Load dataseturl = "[https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data](https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data)"names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']dataset = pd.read_csv(filepath_or_buffer=url,header=None,sep=',',names=names)# Split-out validation datasetarray = dataset.valuesX = array[:,0:4]y = array[:,4]X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1, shuffle=True)classifier = LogisticRegression()classifier.fit(X_train,y_train)save the model to diskpickle.dump(classifier, open('LRClassifier.pkl', 'wb'))load the model from diskloaded_model = pickle.load(open('LRClassifier.pkl', 'rb'))result = loaded_model.score(X_test, y_test)print(result)

Jupyter 上面的代码片段:

逻辑回归 python 代码片段

第二步。使用 FastAPI 框架创建 API

从头开始，这样就不会出现任何错误:

• 打开 VS 代码或者你选择的其他编辑器。我使用 VS 代码
• 使用文件菜单可以打开您想要工作的目录
• 打开终端并创建虚拟环境，如下所示:
• python -m venv venv 名称
• 使用 venv-name\Scripts\activate 激活 venv

安装库:

• pip 安装熊猫
• pip 安装数量
• pip 安装 sklearn
• pip 安装 pick
• pip 安装 FastAPI

导入库，如下面的代码所示。

• 创建一个FastAPI“实例”并将其分配给 app
• 这里的app变量将是FastAPI类的一个“实例”。
• 这将是创建所有 API 的主要交互点。
• 这个app就是下面命令中uvicorn所指的那个:

• 这里 main 是你写代码的文件的名字。您可以给出任何名称，但必须是在命令中代替 main 执行时使用的名称。
• 当您需要从客户端(比如说浏览器)向您的 API 发送数据时，您将它作为请求体发送。
• 一个请求主体是客户端发送给你的 API 的数据。一个响应体是你的 API 发送给客户端的数据。
• 您的 API 几乎总是要发送一个响应主体。但是客户端不一定需要一直发送请求体。
• 为了声明一个请求体，你使用 Pydantic 模型及其所有的能力和好处。
• 然后将数据模型声明为从BaseModel继承的类。
• 对所有属性使用标准 Python 类型。
• 在我们的例子中，我们希望预测鸢尾物种，因此将创建一个数据模型作为具有四个参数的类，这四个参数是物种的维度。
• 现在创建一个端点，也称为名为“预测”的路由
• 添加一个我们创建的数据模型类型参数“IrisSpecies”。
• 现在，我们可以将数据作为 json 发布，它将在 iris 变量中被接受。
• 接下来，我们将在变量 loaded_model 中加载已经保存的模型。
• 现在，按照我们在机器学习中的方式执行预测，并返回结果。
• 现在你可以运行这个应用程序，并看到 FastAPI 创建的漂亮的用户界面(UI ),它使用现在称为 openAPI 的 Swagger 作为后端来设计文档和 UI。
• 下面给出了完整的代码，你可以简单地复制和粘贴，它将工作，如果你遵循上述步骤正确。

from fastapi import FastAPI
from pydantic import BaseModel
import pickle
import numpy as np
import pandas as pdapp = FastAPI()class IrisSpecies(BaseModel):sepal_length: floatsepal_width: floatpetal_length: floatpetal_width: float@app.post('/predict')async def predict_species(iris: IrisSpecies):data = iris.dict()loaded_model = pickle.load(open('LRClassifier.pkl', 'rb'))data_in = [[data['sepal_length'], data['sepal_width'], data['petal_length'], data['petal_width']]]prediction = loaded_model.predict(data_in)probability = loaded_model.predict_proba(data_in).max()return {'prediction': prediction[0],'probability': probability}

VS-API 创建的代码片段:

执行应用程序:

现在，如果您可以看到通过输入 url 创建的漂亮的 UI:127 . 0 . 0 . 0:8000/docs

下面您会看到 API 端点是作为 POST 请求创建的。

点击终点，它将展开如下。

现在点击尝试一下，粘贴尺寸得到预测。

我粘贴了一些虚拟尺寸，然后点击执行。

现在你可以看到它已经以 99%的准确率预测出它是鸢尾花。

您可以从任何地方直接调用这个 api，如下所示:

import requestsnew_measurement = {"sepal_length": 1.2,"sepal_width": 2.3,"petal_length": 1.4,"petal_width": 2.8}response = requests.post('[http://127.0.0.1:8000/predict](http://127.0.0.1:8000/predict)', json=new_measurement)print(response.content)>>> b'{"prediction":"Iris-setosa","probability":0.99}'

所以这就是使用 FastAPI 创建 API 的全部内容。

FastAPI 还提供了自动创建的精美文档。只需在浏览器中输入 127.0.0.0:8000/redoc

Github 资源库包含完整的源代码，请点击此处。

本文到此为止。希望你喜欢阅读。分享您对 FastAPI 体验的想法。此外，您可以使用注释来询问在实施过程中是否有任何问题。

由于您已经到达这里，这表明您对机器学习模型部署感兴趣，因此为什么不也阅读这篇文章呢:

可能让你损失惨重的 5 个模型部署错误

推荐文章:

• 使用 Python |机器学习构建逻辑回归模型的分步指南
• 主成分分析完全指南——机器学习中的 PCA
• K-最近邻算法完全指南——使用 Python 实现 KNN
• 参考 Python 笔记本，了解适合初学者的重要 ML 算法

如何部署机器学习模型

原文：https://towardsdatascience.com/how-to-deploy-machine-learning-models-ec50d3daf365?source=collection_archive---------5-----------------------

逐步概述

作者创建的图像

Jupyter 笔记本是机器学习模型死亡的地方。

等等——什么？

与你可能在大学里学到的不同，在 Jupyter 笔记本或 R Studio 脚本中构建模型只是这个过程的开始。如果你的流程以笔记本中的模型结束，那么这些模型几乎肯定不会为你的公司创造价值(有些例外可能是它只用于分析或者你在网飞工作)。

这并不意味着你的模型不优秀。我肯定他们是。但这可能确实意味着付钱给你的人对结果并不超级兴奋。

一般来说，公司不关心最先进的模型，他们关心的是真正为客户创造价值的机器学习模型。

从笔记本中的优秀模型到可以集成到产品的一部分或由非技术用户访问的模型的过程是我在这篇文章中想要谈论的。

所以，如果你想让你的模型不再死在笔记本上，并真正创造价值，请继续读下去。

模型是代码，代码需要被信任

您的第一步将是让您的代码达到一个您可以放心投入生产的质量水平。我想强调这一步中应该发生的 3 件重要的事情:有一个好的自述文件，编写干净的函数，测试你的代码。

好的读物非常重要。他们应该允许任何人(包括你自己)容易地看到为什么写这个代码，做了什么假设，存在什么约束，以及如何使用代码。对于机器学习代码，你还应该描述和/或链接到已经运行的实验，这样人们就可以查看创建你的模型的过程。不要害怕在你的阅读材料中加入图片、gif 和视频。它们有助于更容易理解。

这篇文章不会教你写干净的函数所需要知道的一切。但是需要记住一些重要事项:

• 使用易于理解的函数和变量名
• 函数应该只做一件事
• 包括文档和使用类型
• 使用 PEP8 等风格指南

最后，但同样重要的是，您需要测试您的代码！测试可以让你确信你的代码如预期的那样运行，并且当你进行修改时，你实际上没有破坏任何东西。最简单的起点是单元测试。对于 Python，查看 pytest 和 unittest 库来管理您的测试。

将你的代码容器化

你可能听说过 Docker。Docker 是迄今为止开发人员最流行的封装代码的方式。但是 Docker 是什么？Docker 在其网站上声明:

容器是一个标准化的软件单元，它允许开发人员将他们的应用程序从环境中隔离出来，解决了“它在我的机器上工作”的头痛问题。对于今天数百万的开发者来说，Docker 是构建和共享容器化应用的事实标准。

Docker 是一种容器化你的应用程序的方式，容器化将你的应用程序从它的环境中隔离出来。简单地说，这意味着如果你能让你的代码在本地机器上的 Docker 中运行，那么它应该能在任何地方运行。这一点变得越来越重要，因为许多人转向 AWS 等云提供商来部署他们的应用程序。

首先，下载 Docker，创建一个 Docker 文件，告诉 Docker 如何为您的应用程序构建环境，从您的 Docker 文件构建您的 Docker 映像，最后运行您的 Docker 映像。

每一个步骤都有些复杂，但是只要看看 Docker 网站上的入门教程，你就能很好地将代码装入 Docker。

使您的模型易于访问

作者创建的图像

你现在有了干净的、容器化的代码，但是没有简单的方法让你的用户与你的机器学习模型交互。

解决这个问题最简单的方法是将你的模型放在一个 API 后面，并通过一个网页公开它。

应用程序接口(API)是一种允许应用程序与您的代码(在我们的例子中是模型)进行交互的方式。例如，如果您为一个分类模型创建一个 API，那么您的 API 将接收必要的数据来进行预测(通常是 JSON 格式的)，然后返回基于这些数据的预测。API 有用的原因有很多，但最重要的一个原因是它在代码和用户界面之间建立了分离。您通常通过 web 请求与 API 进行交互。

Python 有两个很棒的库，让这个过程变得非常简单。首先，FastAPI 使得为您的模型创建 API 变得非常简单。其次，Python 中的请求库使得与 API 的通信变得容易。

一旦有了模型的 API，就需要为用户创建一个前端应用程序。许多数据科学家害怕这一步，因为他们对如何创建网站知之甚少或一无所知。还好有解决的办法！Streamlit Python 库。Streamlit 是一个库，允许您在不了解任何网站创建知识的情况下用 Python 创建 web 应用程序。他们也有很棒的文档，所以去看看，开始为你的模型构建你的 web 应用程序。

至此，您已经有了后端 API 代码、前端 web 应用程序和连接两者的 web 请求。将这些作为单独的应用程序，使用 Docker 进行容器化。

部署到云

到目前为止，您的所有工作都是在本地机器上完成的。如果事情进展顺利，您的机器上运行着一个前端 web 应用程序，允许您访问您的机器学习模型预测。

但问题是，只有你可以访问这个网络应用！

为了解决这个问题，我们将把你的应用程序部署到云中，因为你已经把你的代码容器化了，这个过程实际上非常简单。

三个主要的云提供商是 AWS、谷歌云和微软 Azure。它们都提供了非常相似的功能，对于学习来说，你不会真的挑错。我建议你选择目前免费额度最多的云。

无论您选择哪种云，我都会首先关注他们的平台即服务产品。谷歌有谷歌应用引擎，亚马逊有弹性豆茎，微软有 Azure 应用服务。所有这些服务都让您可以轻松地将 Docker 容器部署到云上。

一旦您的 web 应用程序和 API 容器部署到这些平台，您将拥有一个公共 URL，您或任何人都可以访问它来与您的机器学习模型进行交互。恭喜你！

如何了解更多

如何在 Kubernetes 上简单部署

原文：https://towardsdatascience.com/how-to-deploy-on-kubernetes-in-simple-words-aba6f42cc888?source=collection_archive---------42-----------------------

行业笔记

在 Kubernetes 集群上部署 web 应用程序的行动手册

由乔尔·里维拉-卡马乔在 Unsplash 上拍摄的照片

我最近在 RapidAPI 上开发了一个名为 Owl 的上下文化的最相似单词 API 服务。这对我来说是一个伟大的旅程，所以我决定与你分享它发展的各个阶段。在本文中，我想分享一个关于如何使用 Kubernetes** 部署容器化 web 应用程序的分步指南(创建、连接、部署和公开)**。您可以在您的数据科学项目以及您正在开发的任何其他 web 应用程序中使用该指南。如果你想了解更多关于 OWL API 的内容，你可以阅读这篇文章:如何计算单词相似度——比较分析。

在本文中，我想分享关于如何使用 Kubernetes 部署容器化 web 应用程序的分步指南(创建、连接、部署和公开)。

https://www.amazon.com/gp/product/B08D2M2KV1/ref=dbs_a_def_rwt_hsch_vapi_tkin_p1_i0

第 0 步—为什么选择 Kubernetes？->可扩展性🔑

在我构建 OWL API 的过程中，为了构建一个比当前解决方案更好的“最相似单词”服务，我面临了许多 NLP 挑战。除了这些挑战，我还需要部署 OWL API ，这样它就可以管理 大量的 API 请求。我本可以使用简单的 VPS(虚拟专用服务器)进行部署，但我确信我很快就会面临可扩展性问题。这就是我决定使用 Kubernetes 技术的原因。

Kubernetes 是一个开源容器编排器，用于容器化应用程序的可伸缩部署。

所以，我假设您已经准备好部署一个容器化的应用程序。您面临的问题是如何部署它，以便它可以在需要时以最少的参与进行扩展。

步骤 1—如何“创建”Kubernetes 集群？

—我应该使用哪种云基础架构？☁

您必须使用您所使用的云基础设施的控制面板来创建 Kubernetes 集群。我最近和 OVH 云和谷歌云合作过。在这两个集群上创建 Kubernetes 集群的过程很简单，但是有所不同。你应该找到他们自己的指南，在那里他们描述得很透彻。例如，您可以在下面的链接中找到创建集群的 OVH 指南。

https://docs.ovh.com/ca/en/kubernetes/creating-a-cluster/

OVH 是一家法国云计算公司，提供 VPS、专用服务器和其他网络服务。他们是世界上最大的云提供商之一，但不如 GCP 或 AWS 有名。我也不知道他们直到几个月前，但我强烈推荐他们，因为 OVH 的界面是用户友好的，其成本更合理的竞争对手，如 AWS 或 GCP。如果你没有充分的理由使用 AWS 或 GCP，我强烈推荐 OVH 云。

—在哪里🍄魔法🍄会发生什么？->负载平衡器

为了确保您的 Kubernetes 集群可以在需要时扩展，请确保在此步骤中启用自动扩展选项。另外，选择您希望在集群中运行的节点的正确数量。随着您向群集中添加的节点数量的增加，每月成本也会增加。

你可以在 OVH 获得的 Kubernetes 服务是一种托管的 Kubernetes 服务，这主要意味着在需要时自动管理扩展。神奇的是由一个名为负载平衡器的节点完成的，这个节点将所有到达的任务分配到一组资源上，以使整个过程更有效地工作。负载平衡有不同的策略，这不是本文的重点。所以，这里不多描述了。

步骤 2—如何“连接”到 Kubernetes 集群？

—“kube config”就是你所需要的！(几乎所有😃)

创建 Kubernetes 集群后，您必须能够从控制面板下载一个**【key】**来从远程机器连接到集群。密钥主要是一个YAML文件，其中包含连接到 Kubernetes 集群所需的一切(例如，集群地址和所需的凭证)。您不能更改或修改该文件中的任何值。所以，你只需要从控制面板中找出必须下载的地方。

为了在远程机器和 Kubernetes 集群之间建立一个经过验证的连接，您需要这个文件。此密钥的格式在 GCP 或 OVH 等云基础架构中有所不同，这在现阶段并不重要。唯一重要的事情是您必须将该文件保存在一个安全的地方，并将KUBECONFIG环境变量的值设置为该文件的地址。如果使用 Linux 终端，可以使用下面的代码设置KUBECONFIG的值。

export KUBECONFIG=\\path\\to\\config\\kubeconfig.yml

—还需要一样东西:“KUBECTL”👍

一旦将KUBECONFIG环境变量的值设置为相应文件的地址，就可以开始使用 Kubernetes 集群了。Kubernetes 命令行工具或kubectl是您开始使用集群所需的全部工具。kubectl允许您对 Kubernetes 集群运行命令，例如，部署应用程序或检查集群资源。不过如何安装 **kubectl** **？**你可以阅读这篇文章的作者写的。

kubectl(即 Kubernetes 命令行工具)允许您对 Kubernetes 集群运行命令，例如部署应用程序或检查集群资源。

步骤 3—如何在 Kubernetes 集群上“部署”？

在前面的步骤中，您创建了一个 Kubernetes 集群，并构建了一个经过身份验证的连接来使用它。现在，您必须在集群上部署容器化的应用程序。

—创建部署清单😮

请不要混淆！“manifest”只是一个YAML文件，其中的部署细节如“如何映射外部端口？或如何设置环境变量？”决心已定。您可以将下面的代码用作部署清单的模板。

apiVersion: v1
kind: Service
metadata:  
  name: MY-SERVICE  
  labels:    
    app: MY-APP
spec:  
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
    name: http
  - port: 443
    targetport: 443
    protocol: TCP
    name: https
  selector:
    app: MY-APPapiVersion: apps/v1
kind: Deployment
metadata:  
  name: MY-DEPLOYMENT
  labels:
    app: MY-APP
spec:  
  replicas: 1
  selector:
    matchLabels:
      app: MY-APP
  template:
    metadata:
      labels:
        app: MY-APP
    spec:
      containers:
      - name: MY-APP
        image: IMAGE-NAME
        ports:
        - containerPort: 80

关于上述部署清单的几点说明如下。

• 端口 80 和 443 在LoadBalanacer节点上打开。因此，如果您想在https上运行 web 应用程序，相应的端口(即 443)是打开的。
• MY-SERVICE、MY-APP和MY-DEPLOYMENT必须替换为您想要在项目中使用的名称。您在此处分配的内容将在步骤 4 中使用，在该步骤中，您要将群集公开到 internet。
• 必须用您想要部署的容器化应用程序的完整名称/地址来替换IMAGE-NAME。如果你需要动态地改变这个变量的值，把它声明为一个环境变量(即$IMAGE-NAME)并使用[envsubst](https://www.gnu.org/software/gettext/manual/html_node/envsubst-Invocation.html)库。

—提交部署 Manifest🧨

要进行部署，您必须使用kubectl向 Kubernetes 集群提交部署清单文件，如上所述。对于第一轮部署，您必须使用kubectl apply命令，而在下一轮部署中，您必须使用kubectl replace命令。为什么？因为您基本上是用集群上已经存在的版本替换一个新版本！您可以使用下面的代码提交一个replace命令。

kubectl replace -f path/to/manifest/manifest.yml

完成这一步后，运行kubectl get services。如果服务部署正确，您将会看到如下结果。

NAME         TYPE         CLUSTER-IP   EXTERNAL-IP  PORT(S)     AGE kubernetes   ClusterIP     X.X.X.X     <none>       443/TCP      X
MY-SERVICE   LoadBalancer  X.X.X.X     <none>          X         X

步骤 4—如何向互联网“公开”Kubernetes 集群？🔥

**祝贺你！你差不多完成了。**在步骤 3 中，您部署了应用程序。唯一剩下的事情就是将负载平衡器节点暴露给互联网。换句话说，您应该为 LoadBalancer 节点获取一个公共 IP，让流量通过它。尝试使用下面的代码将 internet 流量打开到 LoadBalancer 节点。

kubectl expose deployment MY-DEPLOYMENT --type=LoadBalancer --name=MY-SERVICE

获取公共 IP 需要几秒钟。然后，尝试kubectl get services找出服务可用的外部 IP！现在，您已经完全完成了部署过程！🎉

遗言

在各种情况下，您可能需要删除 Kubernetes 集群。例如，您想要部署最新的版本，并且您按照书上说的做每件事。然而，部署没有通过。在这种情况下，集群很有可能被锁定在不健康的状态，无法正确响应您的命令。您必须删除集群。要删除 Kubernetes 集群，您必须删除Service和Deployment对象。您可以使用命令kubectl delete deployments MY-DEPLOYMENT或kubectk delete services MY-SERVICE。

请注意，删除过程总是会产生一些不必要的后果，例如负载平衡器节点的外部 IP 发生变化。因此，在决定删除集群时，一定要小心谨慎。

感谢阅读！❤️

如果你喜欢这个帖子，想支持我…

• 跟我上 中 ！
• 在 亚马逊 上查看我的书！
• 成为 中的一员 ！
• 连接上Linkedin！
• 关注我的 推特 ！

https://pedram-ataee.medium.com/membership

如何在 Heroku 上免费部署 FastAPI 应用程序

原文：https://towardsdatascience.com/how-to-deploy-your-fastapi-app-on-heroku-for-free-8d4271a4ab9?source=collection_archive---------5-----------------------

如何让您的应用全天候保持活跃

图片来自 Pixabay 的 mohamed_hassan

注意:Heroku 免费版本不再提供。请阅读 从 Heroku 到 Deta 免费托管 Python 项目 免费托管 FastAPI。

介绍

Heroku 是一个云平台即服务(PaaS)，支持 Ruby on Rails、Java、Node.js、Scala、Clojure、Python、PHP 和 Go。Heroku 的免费版本每月提供 550-1000 dyno 小时。如果没有人使用你的应用程序，你的应用程序会在 30 分钟后休眠。如果你的每月动态时间在限制范围内，你的应用程序将永远免费。

Dynos 是 Heroku 平台上隔离的虚拟化 Linux 容器。

在本文中，您将了解到在 Heroku 上设置和运行 FastAPI 项目并使其全天候活动是多么容易。

我目前在 Heroku 主持这个 FastAPI 网站作为演示。

**Table of Contents**
· [Introduction](#fa53)
· [Git](#d66a)
· [Setting up Your Heroku Account](#6e50)
· [How to Create the requirement.txt for FastAPI on Heroku](#9e18)
· [runtime.txt](#eb9a)
· [Procfile](#0457)
· [Environment Variables](#8642)
· [How to Upload to Heroku](#73c2)
· [How to Add a Subdomain](#5bbe)
· [How to Keep Your App Active 24/7](#3c12)
  ∘ [cron-job.org](#7cd1)
· [How to fix a failed cron-job](#b1d7)
  ∘ [Kaffeine](#beb1)
· [How to Rename Your App](#6ba6)
· [How to ssh to Heroku](#c69f)
· [Conclusion](#fc09)
· [Newsletter](#ad04)
· [References](#2fbb)

饭桶

我使用 Gitstart 来自动化 Git 初始化。从您的终端，它运行git init。添加.gitignore和 README 文件，并提交一条消息。这在 Github 中创建了一个新的 repo，它会推送所有的文件。

$ mkdir my_new_project
$ cd my_new_project
$ gitstart

设置您的 Heroku 帐户

个人账户每月有 550 小时的免费动态时间。除了这些基本小时数之外，使用信用卡[1]进行验证的帐户还将获得额外的 450 小时，添加到每月免费动态配额中。[2]

你需要给 Heroku 添加 SSH 密钥。[3]
安装 Heroku CLI [4]
然后从您的终端登录 Heroku 并创建一个 Heroku 应用程序:

$ heroku login
$ heroku create

heroku 创造产出。图片作者。

您可以向 Heroku 应用程序添加自定义域。[5]

如何在 Heroku 上为 FastAPI 创建 requirement.txt

Heroku 需要requirement.txt来安装你的 Python 包。pipreqs [6]基于项目中的导入生成它。

$ pip install pipreqs
$ cd my_new_project
$ pipreqs ./
# if you already have the requirement.txt
$ pipreqs --force ./

由于pipreqs是基于import生成的，您需要手动将以下内容添加到requirements.txt中。

uvicorn==0.12.3
aiofiles==0.6.0
python-multipart==0.0.5
jinja2==2.11.2

你需要uvicorn来启动 Heroku 上的 ASGI 服务器。静态文件需要使用aiofiles。如果你的项目有一个表单，添加python-multipart。如果您的项目使用模板引擎，添加jinja2。

runtime.txt

Heroku 使用默认的 Python 版本。为了使用某个 Python 版本，在你的 Python 版本中添加runtime.txt。例如:

python-3.8.6

Procfile

Heroku 需要 Procfile。[7]

如果应用程序目录中有main.py ，则添加以下内容:

web: uvicorn app.main:app --host=0.0.0.0 --port=${PORT:-5000}

如果根目录中有main.py:

web: uvicorn main:app --host=0.0.0.0 --port=${PORT:-5000}

环境变量

Heroku 不使用.env文件。相反，将.env文件中的值添加到配置变量中。您可以在“设置”选项卡下找到它。

向配置变量添加环境变量。图片作者。

如何上传到 Heroku

现在，您已经准备好将您的项目推向 Heroku:

$ git push heroku main
$ heroku open

heroku open命令在浏览器中打开您的项目。

git 在终端上推 heroku main。图片作者。

如何添加子域

我正在使用 Cloudflare，这是我必须要做的。

选择“CNAME”作为类型。为该名称添加您的子域名。为内容添加您的 Heroku 域。你的 Heroku 域名有点像，serene-example-4269.herokuapp.com。

下图显示了如何添加toolbox.mywebsite.com子域。

向 Cloudflare 添加子域。

如何让您的应用全天候保持活跃

30 分钟不活动后，Heroku 应用程序进入空闲状态。您可以使用heroic ps找到您的应用程序流程。

heroku ps 输出显示空闲。图片作者。

你可以在最后一行找到“闲置”。

这是我的另一个应用程序进程状态，显示为“启动”。

heroku ps 输出出现。图片作者。

cron-job.org[8]和凯费恩[9]提供免费服务。双方都会在预定的时间访问您的 URL。

cron-job.org

您可以通过添加 URL 和执行时间表来创建 cronjob。

cron-job.org 克朗乔布斯标签。图片作者。

对于您的 cronjob，您需要每 15 分钟选择一次。如果每 30 分钟设置一次，可能会延迟 5 到 15 秒。

为 cronjob 选择每 30 分钟一次。图片作者。

您可以轻松编辑或删除您的 cronjob。

如何修复失败的 cron 作业

您的 cron-job 可能无法告知“响应数据太大”或“输出太大”。

作者图片

cron-job.org 从您的 URL/脚本接受高达 4 kB 的响应数据。要解决这个问题，您可以创建一个返回 JSON 字符串而不是 HTML 页面的端点。

卡夫芬

Kaffeine 每 30 分钟对你的 Heroku 应用进行一次 pings 操作，这样它就永远不会进入睡眠状态。

Kaffeine 网站。

如何从 Kaffeine 移除你的应用

网站中的链接不起作用，但如果你点击下面的链接，它对我有用。

从 Kaffeine 移除您的应用程序。

如何重命名您的应用程序

$ heroku apps:rename new_app_name

当你重命名你的应用程序时，不要忘记更新你的 cron 作业。

如何向 Heroku 宋承宪

你可能想对 Heroku 说些什么。heroku ps:exec确实如此。

$ heroku ps:exec
Establishing credentials... done
Connecting to web.1 on ⬢ demo-desuyo...
~ $

结论

Heroku 为您的项目提供最长 1000 小时的免费托管，该项目使用的内存低于 512MB。你可以用你的域名。如果您需要自定义域上的 SSL，您需要升级到爱好层。

cron-job.org 和卡夫丁峡谷提供了一个 cronjob 访问您的网址，以避免睡眠。

通过 成为 会员，获得媒体上所有故事的访问权限。

请订阅。

参考

1. 账户验证
2. 自由动态小时数
3. SSH 按键
4. Heroku CLI
5. 为应用程序定制域名
6. pipreqs
7. 过程文件
8. cron-job.org
9. 卡夫芬

如何使用 PostgreSQL 导出汇总统计数据

原文：https://towardsdatascience.com/how-to-derive-summary-statistics-using-postgresql-742f3cdc0f44?source=collection_archive---------2-----------------------

使用 PostgreSQL 导出数值和分类字段的汇总统计数据

活动发起人在 Unsplash 上的照片

在本文中，我们将讨论如何使用 SQL 获得数字和分类列/字段的汇总统计数据。我们将使用从 Tableau 公共样本数据集下载的网飞电影和电视节目数据集(https://public.tableau.com/en-us/s/resources并转到样本数据**)。**该数据集由截至 2019 年网飞可用的电视节目和电影组成，由 Tableau 从 Kaggle 获取，数据集的更新版本可在 Kaggle 上找到。然而，对于本文，我们将使用在 Tableau 样本数据集中可用的旧版本，并将其导入到 Postgres 中。本文假设读者对 SQL 查询和统计有基本的了解。下面是我们将在整篇文章中使用的 网飞 _titles 的快照。

网飞 _ 标题表(图片由作者提供)

数字变量的汇总统计

常用的数字变量汇总统计有均值、中值、最小值、最大值、范围、标准差、方差、Q1、Q3、IQR 和偏度。

的意思是

在 PostgreSQL 中，使用 AVG() 函数计算数值字段/列的平均值。我们将计算 持续时间 _ 分钟 字段的平均值，如下所示。

**SELECT** 
 **AVG**(duration_minutes) **AS** mean
  **FROM** netflix_titles;

作者图片

中间值

在 PostgreSQL 中，没有直接计算数值字段/列的中值的函数。然而，由于中位数是第 50 个百分位数，我们可以用它来代替中位数。使用 PERCENTILE_CONT() 函数计算数值变量的百分比。我们将计算 持续时间 _ 分钟 字段的中值，如下所示。

**SELECT 
 PERCENTILE_CONT**(0.5) **WITHIN GROUP** (**ORDER BY** duration_minutes) **AS** median
  **FROM** netflix_titles;

作者图片

WITHIN GROUP 子句创建可用于执行聚合的有序数据子集。 PERCENTILE_CONT 将所需的百分位作为参数，本例中为 0.5，即第 50 个百分位。

最小值

在 PostgreSQL 中，使用 MIN() 函数找到数值字段/列的最小值。我们将找到duration _ minutes字段的最小值，如下所示。

**SELECT** 
 **MIN**(duration_minutes) **AS** min 
  **FROM** netflix_titles;

作者图片

最大值

在 PostgreSQL 中，使用 MAX() 函数找到数值字段/列的最大值。我们将找到duration _ minutes字段的最大值，如下所示。

**SELECT** 
 **MAX**(duration_minutes) **AS** max 
  **FROM** netflix_titles;

作者图片

范围

在 PostgreSQL 中，没有直接计算数值字段/列范围的函数。然而，由于范围是最大值和最小值之间的差值，我们可以用它作为范围的代理。

**SELECT** 
 **MAX**(duration_minutes) - **MIN**(duration_minutes) **AS** range
    **FROM** netflix_titles;

作者图片

标准偏差

在 PostgreSQL 中，使用 STDDEV() 函数计算数值字段/列的标准偏差。我们将计算 持续时间 _ 分钟 字段的标准偏差，如下所示。

**SELECT** 
 **ROUND**(**STDDEV**(duration_minutes), 2) **AS** standard_deviation
    **FROM** netflix_titles;

作者图片

或

我们还可以将标准差计算为方差的平方根，如下所示。

**SELECT** 
 **ROUND**(**SQRT**(**VARIANCE**(duration_minutes)), 2) **AS** stddev_using_variance
    **FROM** netflix_titles;

作者图片

差异

在 PostgreSQL 中，使用 VARIANCE() 函数计算数值字段/列的方差。我们将计算 持续时间 _ 分钟 字段的方差，如下所示。

**SELECT** 
 **ROUND**(**VARIANCE**(duration_minutes), 2) **AS** variance
    **FROM** netflix_titles;

作者图片

或

我们也可以将方差计算为标准差的平方，如下所示。

**SELECT** 
 **ROUND**(**POWER**(**STDDEV**(duration_minutes), 2), 2) **AS** variance_using_stddev
    **FROM** netflix_titles;

作者图片

Q1

在 PostgreSQL 中，没有直接计算数值字段/列的第一个四分位数(Q1)的函数。然而，由于 Q1 是第 25 个百分点，我们可以用它来代表 Q1。我们将计算 持续时间 _ 分钟 字段的 Q1，如下所示。

**SELECT**
 **PERCENTILE_CONT**(0.25) **WITHIN GROUP** (**ORDER BY** duration_minutes) **AS** q1
    **FROM** netflix_titles;

作者图片

Q3

在 PostgreSQL 中，没有直接计算数值字段/列的第三个四分位数(Q3)的函数。但是，由于第 3 季度是第 75 个百分点，我们可以用它来代替第 3 季度。我们将计算 持续时间 _ 分钟 字段的 Q3，如下所示。

**SELECT**
 **PERCENTILE_CONT**(0.75) **WITHIN GROUP** (**ORDER BY** duration_minutes) **AS** q3
    **FROM** netflix_titles;

作者图片

IQR

在 PostgreSQL 中，没有直接计算数值字段/列的四分位间距(IQR)的函数。然而，由于 IQR 是第三季度和 Q1 之间的差异，我们可以用它作为 IQR 的代理。我们将计算 持续时间 _ 分钟 字段的 IQR，如下所示。

**SELECT**
 **PERCENTILE_CONT**(0.75) **WITHIN GROUP** (**ORDER BY** duration_minutes) -
 **PERCENTILE_CONT**(0.25) **WITHIN GROUP** (**ORDER BY** duration_minutes) **AS** iqr
     **FROM** netflix_titles;

作者图片

歪斜

在 PostgreSQL 中，没有直接计算数值字段/列的偏斜度的函数。然而，由于偏斜度是 *3 (均值-中值)/标准差，我们可以用它来代替偏斜度。我们将计算 持续时间 _ 分钟 字段的偏斜度，如下所示。为了让代码更具可读性，我们将使用 CTE 来计算平均值、中值和标准差。

**WITH** mean_median_sd **AS**
(
 **SELECT** 
  **AVG**(duration_minutes) **AS** mean,
  **PERCENTILE_CONT**(0.5) **WITHIN GROUP** (**ORDER BY** duration_minutes) **AS** median,
  **STDDEV**(duration_minutes) **AS** stddev
   **FROM** netflix_titles
)**SELECT** 
 **ROUND**(3 * (mean - median)**::NUMERIC** / stddev, 2) **AS** skewness
  **FROM** mean_median_sd;

作者图片

将所有这些放在一起

我们将把前面讨论的所有函数放在一起，并在一个表中返回它们。在下面的查询中，我们将创建两个 cte，即 summary_stats (每列返回一个前面讨论过的统计信息)和row _ summary _ stats(每行返回一个统计信息)。

**WITH RECURSIVE**
summary_stats **AS**
(
 **SELECT** 
  **ROUND**(**AVG**(duration_minutes), 2) **AS** mean,
  **PERCENTILE_CONT**(0.5) **WITHIN GROUP** (**ORDER BY** duration_minutes) **AS** median,
  **MIN**(duration_minutes) **AS** min,
  **MAX**(duration_minutes) **AS** max,
  **MAX**(duration_minutes) - **MIN**(duration_minutes) **AS** range,
  **ROUND**(**STDDEV**(duration_minutes), 2) **AS** standard_deviation,
  **ROUND**(**VARIANCE**(duration_minutes), 2) **AS** variance,
  **PERCENTILE_CONT**(0.25) **WITHIN GROUP** (**ORDER BY** duration_minutes) **AS** q1,
  **PERCENTILE_CONT**(0.75) **WITHIN GROUP** (**ORDER BY** duration_minutes) **AS** q3
   **FROM** netflix_titles
),row_summary_stats **AS**
(
**SELECT** 
 1 **AS** sno, 
 'mean' **AS** statistic, 
 mean **AS** value 
  **FROM** summary_stats
**UNION
SELECT** 
 2, 
 'median', 
 median 
  **FROM** summary_stats
**UNION
SELECT** 
 3, 
 'minimum', 
 min 
  **FROM** summary_stats
**UNION
SELECT 
** 4, 
 'maximum', 
 max 
  **FROM** summary_stats
**UNION
SELECT** 
 5, 
 'range', 
 range 
  **FROM** summary_stats
**UNION
SELECT 
** 6, 
 'standard deviation', 
 standard_deviation 
  **FROM** summary_stats
**UNION
SELECT 
** 7, 
 'variance', 
 variance 
  **FROM** summary_stats
**UNION
SELECT 
** 9, 
 'Q1', 
 q1 
  **FROM** summary_stats
**UNION
SELECT 
** 10, 
 'Q3', 
 q3 
  **FROM** summary_stats
**UNION
SELECT 
** 11, 
 'IQR', 
 (q3 - q1) 
  **FROM** summary_stats
**UNION
SELECT 
** 12, 
 'skewness', 
 **ROUND**(3 * (mean - median)**::NUMERIC** / standard_deviation, 2) **AS** skewness 
  **FROM** summary_stats
)**SELECT** * 
 **FROM** row_summary_stats
  **ORDER BY** sno;

作者图片

分类变量的汇总统计

分类变量常用的汇总统计数据有模式、基数(唯一类别的数量)、频率和相对频率。

方式

在 PostgreSQL 中，使用 MODE() 函数计算分类字段/列的模式。我们将计算 评级 字段的模式，如下所示。

**SELECT** 
 **MODE**() **WITHIN GROUP** (**ORDER BY** rating) **AS** mode
  **FROM** netflix_titles;

作者图片

基数

在 PostgreSQL 中，没有直接计算分类字段/列的唯一值数量的函数。但是，我们可以计算变量的不同值，如下所示。

**SELECT** 
 **COUNT**(**DISTINCT** rating) **AS** cardinality
  **FROM** netflix_titles;

作者图片

频率和相对频率

在 Postgres 中，我们可以使用 GROUP BY 和 COUNT 来计算类别变量中类别的出现频率。对于相对频率，我们将使用 CTE 来计算评级字段中值的总数，并使用它来计算相对频率。因为，不是所有的数据库都支持窗口函数，我们将使用 CTE。我们还将讨论如何使用窗口函数计算相对频率。

**WITH** total_count **AS**
(
**SELECT**
 **COUNT**(rating) **AS** total_cnt
  **FROM** netflix_titles
)**SELECT** 
 rating,
 **COUNT**(rating) **AS** frequency,
 **ROUND**(**COUNT**(rating)**::NUMERIC** / 
    (**SELECT** total_cnt **FROM** total_count), 4) **AS** relative_frequency
    **FROM** netflix_titles
     **GROUP BY** rating
   **ORDER BY** frequency **DESC**;

作者图片

在上面的例子中，我们已经创建了一个 CTE 来捕获 rating 字段中的值的计数。然后，我们使用它来计算 评级 字段中每个类别的百分比/相对频率。由于 Postgres 支持窗口函数，我们将看到一种使用窗口函数计算相对频率的更简单的方法。我们将使用 OVER() 来计算每组评分的总数，这也就是 评分 字段中值的总数。

**SELECT** 
 rating,
 **COUNT**(rating) **AS** frequency,
 **ROUND**(**COUNT**(rating)**::NUMERIC** / **SUM**(**COUNT**(rating)) **OVER()**, 4) **AS** relative_frequency
    **FROM** netflix_titles
     **GROUP BY** rating
      **ORDER BY** frequency **DESC**;

作者图片

文章到此结束。我们已经讨论了计算常用数值字段汇总统计数据的各种函数，如均值、中值、最小值、最大值、Q1、Q2、IQR 等。以及基数、频率等分类字段。汇总统计可用于了解数据分布，也有助于识别潜在的异常值。

如何为月球着陆器🛸设计强化学习奖励函数

照片来源于Nasa；作者代码

想象外星人👽受到攻击，而你正试图让 Lander🛸登陆月球，你会考虑哪些因素来成功完成任务？

以下是一些注意事项:

• 在着陆垫上着陆 vs 离开着陆垫
• 低速着陆 vs 高速坠毁
• 使用尽可能少的燃料对使用大量燃料
• 尽快接近目标 vs 悬在空中

罚什么？奖励什么？如何平衡多重约束？如何在我们的奖励函数中表现这些想法？

强化学习中的奖励函数

强化学习(RL)是机器学习中的一个分支，它利用代理训练中的试错问题解决方法。在我们的例子中，代理将尝试着陆月球着陆器，比如说，10k 次，以学习如何在不同的状态下做出更好的行动。

奖励功能是一个激励机制，它使用奖励和惩罚来告诉代理什么是正确的，什么是错误的。逆向物流中代理人的目标是最大化总报酬。有时我们需要牺牲眼前的回报，以最大化总回报。

月球着陆器奖励函数中的规则

月球着陆器奖励功能中的奖励和惩罚规则的一些想法可以是:

• 以足够低的速度降落在正确的地方，给予高额奖励
• 如果着陆器在着陆区外着陆，则给予处罚
• 根据剩余燃料的百分比给予奖励
• 如果在表面着陆时速度超过阈值(坠毁),给予很大的惩罚
• 给予距离奖励以鼓励着陆器接近目标

如何用 python 代码表示规则

作者代码

如上图所示，变量fuel _ conservation是一个介于 0 和 1 之间的值。当成功降落在着陆场时，收到的奖励会乘以fuel _ conservation以鼓励着陆器尽量少用燃料。

如果着陆器在目标点之外着陆，我们会给它一个-10 的小惩罚。如果着陆器以很高的速度坠毁，我们会给一个很大的惩罚-100。

distance _ reward = 1-(distance _ to _ goal/distance _ max) * 0.5*使用 0.5 的幂，随着着陆器越来越接近着陆垫，为代理提供平滑的奖励梯度。

# Encourage lander to use as little fuel as possible
# i.e. 0.85, or 0.32
fuel_conservation = fuel_remaining / total_fuelif distance_to_goal is decreasing:
    if speed < threshold:
        if position is on landing pad:
            # Land successfully; give a big reward
            landing_reward = 100
            # Multiply percentage of remaining fuel
            reward = landing_reward * fuel_conservation
        else:
            # Landing outside of landing pad
            reward = -10
    else:
        # Crashed
        reward = -100
else:
    # Encourage agents to approach the surface instead of
    # hanging in the air
    distance_reward = 1 - (distance_to_goal / distance_max)**0.5
    reward = distance_reward * fuel_conservation

结论

在本文中，我们以月球着陆器为例，演示如何构建一个带有奖惩规则的高级奖励函数。

在 RL 模型的培训过程中，奖励功能指导代理从试验和错误中学习:

• 我该怎么办？如何在行动之间进行选择？
• 最大化总回报的更好行动是什么？
• 如何评价不同状态下动作的好/坏？

祝着陆愉快！希望外星人会和平到来。👽☮️✌️🕊🛸

参考资料:

报名参加🦞:的 Udemy 课程

具有机器学习和统计的推荐系统

https://www . udemy . com/course/recommender-system-with-machine-learning-and-statistics/？referral code = 178d 030 ef 728 f 966 d62d

如何为 NLP 项目检测和翻译语言

原文：https://towardsdatascience.com/how-to-detect-and-translate-languages-for-nlp-project-dfd52af0c3b5?source=collection_archive---------1-----------------------

从具有多种语言的文本数据到单一语言

图片来自 Pixabay

本文更新于 2022 年 6 月 20 日

对于说西班牙语的人，你可以在这里阅读这篇文章的翻译版本

祝你新年快乐，2021 年到了，你做到了💪**。** 2020 年已经过去，尽管对世界各地的许多人来说，2020 年是艰难而奇怪的一年，但仍有许多值得庆祝的事情。2020 年，我明白了我们所需要的只是我们所爱的人、家人和朋友的爱和支持。

“面对逆境，我们有一个选择。我们可以痛苦，也可以变得更好。那些话是我的北极星。”-卡林·沙利文

这将是我 2021 年的第一篇文章，我将谈论数据科学家或机器学习工程师在从事 NLP 项目时可能面临的一些语言挑战，以及如何解决这些挑战。

假设你是一名数据科学家，被分配到一个 NLP 项目中，分析人们在社交媒体(如 Twitter)上发布的关于新冠肺炎的内容。你的首要任务之一是为新冠肺炎找到不同的标签(例如 #covid19 ),然后开始收集所有与新冠肺炎相关的推文。

当您开始分析收集到的与新冠肺炎相关的数据时，您会发现这些数据是由世界各地的不同语言生成的，例如英语、斯瓦希里语、 西班牙语 、中文、印地语等。在这种情况下，在开始分析数据集之前，您将有两个问题需要解决，第一个是识别特定数据的语言，第二个是如何翻译这些数据

那么如何才能解决这两个问题呢？

图片来自 Pixabay 的图米苏

第一个问题:语言检测

第一个问题是知道如何检测特定数据的语言。在这种情况下，您可以使用一个名为 langdetect 的简单 python 包。

l angdetect 是一个由 Michal Danilák 开发的简单 python 包，支持开箱即用的 55 不同语言**(ISO 639-1 代码)的检测:**

af, ar, bg, bn, ca, cs, cy, da, de, el, en, es, et, fa, fi, fr, gu, he,
hi, hr, hu, id, it, ja, kn, ko, lt, lv, mk, ml, mr, ne, nl, no, pa, pl,
pt, ro, ru, sk, sl, so, sq, sv, sw, ta, te, th, tl, tr, uk, ur, vi, zh-cn, zh-tw

安装语言检测

要安装 langdetect，请在您的终端中运行以下命令。

pip install langdetect

基本示例

检测文本的语言:例如“Tanzania ni nchi inayoongoza kwa utalii barani Afrika”。首先，从 langdetect 导入 detect 方法，然后将文本传递给该方法。

输出:“软件”

该方法检测到所提供的文本是用斯瓦希里语(‘SW’)编写的。

你也可以使用 detect_langs 方法找出排名靠前的语言的概率。

输出:[sw:0.9999971710531397]

****注:你还需要知道，语言检测算法是不确定的，如果你对一个太短或太不明确的文本运行它，你可能每次运行它都会得到不同的结果。

在语言检测之前调用下面的代码，以便得到一致的结果。

现在，您可以通过使用 langdetect python 包来检测数据中的任何语言。

第二个问题:语言翻译

你需要解决的第二个问题是将文本从一种语言翻译成你选择的语言。在这种情况下，你将使用另一个有用的 python 包，名为Google _ trans _ new。

google_trans_new 是一个免费的、无限制的 python 包，它实现了 Google Translate API，还执行自动语言检测。

安装 google_trans_new

要安装 google_trans_new，请在您的终端中运行以下命令。

pip install google_trans_new

基本示例

要将文本从一种语言翻译成另一种语言，您必须从google_trans_new模块导入google_translator类。然后你必须创建一个google_translator类的对象，最后将文本作为参数传递给翻译方法，并使用 lang_tgt 参数指定目标语言，例如 lang_tgt="en "。

在上面的例子中，我们将一个斯瓦希里语的句子翻译成英语。下面是翻译后的输出。

Tanzania is the leading tourism country in Africa

默认情况下，translate()方法可以检测所提供文本的语言，并将英语翻译返回给它。如果要指定文本的源语言，可以使用 lang_scr 参数。

这里是所有语言的名称及其简写符号。

{'af': 'afrikaans', 'sq': 'albanian', 'am': 'amharic', 'ar': 'arabic', 'hy': 'armenian', 'az': 'azerbaijani', 'eu': 'basque', 'be': 'belarusian', 'bn': 'bengali', 'bs': 'bosnian', 'bg': 'bulgarian', 'ca': 'catalan', 'ceb': 'cebuano', 'ny': 'chichewa', 'zh-cn': 'chinese (simplified)', 'zh-tw': 'chinese (traditional)', 'co': 'corsican', 'hr': 'croatian', 'cs': 'czech', 'da': 'danish', 'nl': 'dutch', 'en': 'english', 'eo': 'esperanto', 'et': 'estonian', 'tl': 'filipino', 'fi': 'finnish', 'fr': 'french', 'fy': 'frisian', 'gl': 'galician', 'ka': 'georgian', 'de': 'german', 'el': 'greek', 'gu': 'gujarati', 'ht': 'haitian creole', 'ha': 'hausa', 'haw': 'hawaiian', 'iw': 'hebrew', 'hi': 'hindi', 'hmn': 'hmong', 'hu': 'hungarian', 'is': 'icelandic', 'ig': 'igbo', 'id': 'indonesian', 'ga': 'irish', 'it': 'italian', 'ja': 'japanese', 'jw': 'javanese', 'kn': 'kannada', 'kk': 'kazakh', 'km': 'khmer', 'ko': 'korean', 'ku': 'kurdish (kurmanji)', 'ky': 'kyrgyz', 'lo': 'lao', 'la': 'latin', 'lv': 'latvian', 'lt': 'lithuanian', 'lb': 'luxembourgish', 'mk': 'macedonian', 'mg': 'malagasy', 'ms': 'malay', 'ml': 'malayalam', 'mt': 'maltese', 'mi': 'maori', 'mr': 'marathi', 'mn': 'mongolian', 'my': 'myanmar (burmese)', 'ne': 'nepali', 'no': 'norwegian', 'ps': 'pashto', 'fa': 'persian', 'pl': 'polish', 'pt': 'portuguese', 'pa': 'punjabi', 'ro': 'romanian', 'ru': 'russian', 'sm': 'samoan', 'gd': 'scots gaelic', 'sr': 'serbian', 'st': 'sesotho', 'sn': 'shona', 'sd': 'sindhi', 'si': 'sinhala', 'sk': 'slovak', 'sl': 'slovenian', 'so': 'somali', 'es': 'spanish', 'su': 'sundanese', 'sw': 'swahili', 'sv': 'swedish', 'tg': 'tajik', 'ta': 'tamil', 'te': 'telugu', 'th': 'thai', 'tr': 'turkish', 'uk': 'ukrainian', 'ur': 'urdu', 'uz': 'uzbek', 'vi': 'vietnamese', 'cy': 'welsh', 'xh': 'xhosa', 'yi': 'yiddish', 'yo': 'yoruba', 'zu': 'zulu', 'fil': 'Filipino', 'he': 'Hebrew'}

检测和翻译 Python 函数

我创建了一个简单的 python 函数，您可以检测文本并将其翻译成您选择的语言。

python 函数接收文本和目标语言作为参数。然后，它检测所提供的文本的语言，如果文本的语言与目标语言相同，则它返回相同的文本，但如果不相同，则它将所提供的文本翻译成目标语言。

示例:

在上面的源代码中，我们将句子翻译成斯瓦希里语。以下是输出结果:-

Natumai kwamba, nitakapojiwekea akiba, nitaweza kusafiri kwenda Mexico

包扎

在本文中，您了解了当您拥有不同语言的文本数据并希望将数据翻译成您选择的单一语言时，如何解决两种语言难题。

恭喜👏，你已经做到这篇文章的结尾了！

你可以在这里下载本文用到的笔记本:https://github.com/Davisy/Detect-and-Translate-Text-Data

如果你学到了新的东西或者喜欢阅读这篇文章，请分享给其他人看。在那之前，下期帖子再见！也可以通过 Twitter @Davis_McDavid 联系到我。

最后一件事: 在以下链接中阅读更多类似这样的文章。

**https://medium.com/datadriveninvestor/how-to-deploy-your-nlp-model-to-production-as-an-api-with-algorithmia-e4081854d524 https://chatbotslife.com/how-to-use-texthero-to-prepare-a-text-based-dataset-for-your-nlp-project-734feea75a5a https://davis-david.medium.com/meet-the-winners-of-swahili-news-classification-challenge-60f5edd7aa9 **

如何检测数据集中的常量、准常量要素

原文：https://towardsdatascience.com/how-to-detect-constant-quasi-constant-features-in-your-dataset-a1ab7aea34b4?source=collection_archive---------15-----------------------

使用 fast_ml 进行特征选择

由红色齐柏林飞艇在 Unsplash 拍摄的照片

介绍

在大多数情况下，顶尖数据科学家与其他人有两个区别:特征创建和特征选择。即，创建捕捉关于业务或客户的更深/隐藏的洞察力的特征，然后做出关于为您的模型选择哪些特征的正确选择。

特征选择在机器学习中的重要性

机器学习模型的质量取决于你的数据——垃圾进，垃圾出。(这里的垃圾意味着坏数据/数据中的噪声)。

在一个广泛的特性工程步骤之后，你会得到大量的特性。您可能无法使用模型中的所有功能。您可能会对只给模型添加那些重要的特性感兴趣，或者删除那些没有任何预测能力的特性。

这篇文章是为了确认所有那些不变的特征。它可以有两种类型:

1. 恒定特征:所有记录中的值相同。
2. 准常数特征:其中一个值占优势 99.9%。

我们来详细了解一下这个

1.常量值(所有记录中的相同值)

图片作者。数据集中具有常数值的要素

如示例图像所示，对于数据中的所有记录，只有 Toyota 作为 Car Make 中的值。你的机器学习模型不会通过训练保持这一功能来学习任何有见地的东西。你最好放弃这个功能。同样，还可能有更多这样的特性，您需要一种更加自动化的方式来识别这些特性。

1)使用get_constant_features函数获取所有常量特征。

图片作者。在一行代码中，您可以检测到所有具有常量值的特性

2)将所有恒定特征存储为列表，以便从数据集中移除。

图片作者。所有不变的特性作为一个列表

3)从数据集中删除所有此类要素。我们可以看到功能的数量从 301 下降到了 268。

图片作者。从数据集中移除所有恒定要素

2。准常数(其中一个值是显性的~99%记录)

图片作者。数据集中具有常数值的要素

如示例图所示，在您的数据中，“凯美瑞”占记录的 99.9%。你的机器学习模型不会通过训练保持这一功能来学习任何有见地的东西。或者更糟的是，你的模型会从边缘案例中学习，导致过度拟合。你最好放弃这个功能。同样，还可能有更多这样的特性，您需要一种更加自动化的方式来识别这些特性。

1)使用get_constant_features函数获取所有常量特征。

图片作者。在一行代码中，您可以检测到所有具有准常数值的特性

• 阈值:用于定义要消除的数据的准度的临界值。99%、99.9%、98%等。

2)将所有拟常数特征存储为列表，以便从数据集中移除。

图片作者。所有的准常数特性作为一个列表

3)从数据集中删除所有此类要素。我们可以看到，功能的数量从 268 个减少到了 123 个。

摘要

两个常量的代码片段&准常量特性:

from fast_ml.utilities import display_all
from fast_ml.feature_selection import get_constant_features**# Use the function to get the results in dataframe**
constant_features = get_constant_features(df)
display_all(constant_features)**# All the constant features stored in a list**
constant_features_list = constant_features['Var'].to_list()**# Drop all the constant features from the dataset**
df.drop(columns = constant_features_list, inplace=True)

感谢阅读！！

• 如果你喜欢这个，跟随我在媒体了解更多。
• 有兴趣合作吗？我们上 Linkedin 连线吧。
• 请随意写下您的想法/建议/反馈。
• 卡格尔链接
• Fast_ml 链接

笔记本可在以下位置获得，并附有完整的功能代码:

https://www.kaggle.com/nextbigwhat/detect-constant-and-quasi-constant-features

如何检测、评估和可视化数据中的历史漂移

原文：https://towardsdatascience.com/how-to-detect-evaluate-and-visualize-historical-drifts-in-the-data-7b2903c6da4f?source=collection_archive---------28-----------------------

显然，阴谋和 Mlflow

图片作者。

TL；DR: 您可以查看数据的历史漂移，以了解您的数据是如何变化的，并选择监控阈值。这里有一个例子，显然，Plotly，Mlflow 和一些 Python 代码。

我们经常谈论在实时数据上检测漂移。

目标是检查当前分布是否偏离训练或过去的某个时期。当漂移被检测到时，你知道你的模型在一个相对未知的空间中运行。是时候做点什么了。

但是这里有很多细微的差别。漂移是多大的漂移？如果只有 10%的特征漂移，我应该在意吗？应该按周看漂移还是按月看漂移？

细节决定成败。答案在很大程度上取决于模型、用例、重新培训的容易程度(或可能性)以及性能下降给你带来的损失。

这里有一个过程可以帮你想清楚。

再来看历史数据漂移！

为什么要看过去的数据漂移？

我们的目标是学习漂移动力学。我们的数据过去发生了多大的变化？

这很有用，原因有二:

首先，我们可以了解模型的衰变纲图。

图片作者。

我们分享了一个关于如何提前检查模型再培训需求的类似想法。在那里，我们观察了模型性能如何随时间变化。

现在，我们来看看数据是如何变化的。你可以选择其中一个。如果我们知道我们将不得不在生产中等待地面真相标签，那么理解数据漂移就特别有帮助。

假设数据以恒定的速度变化，我们可以使用这种分析来设定我们的预期。并准备适当的基础设施。

用例是高度动态的吗？是否应该做好频繁再培训的准备，建立自动流水线？

其次，这种分析可以帮助我们定义模型监控触发器。

图片作者。

**一旦模型投入生产，我们可能需要检查数据漂移。**我们的触发器应该有多敏感？我们需要发生什么来应对漂移？

要选择阈值和条件，我们需要了解我们的数据在过去是如何变化的。这是一种微妙的平衡！我们不希望有太多的假警报，但我们也希望对有意义的变化做出反应。

我们可以对过去的数据运行几次漂移检查(模拟不同的漂移阈值和监控窗口)并探索结果。

这里有一个例子来说明如何做到这一点。

定义漂移检测逻辑

让我们从 Kaggle 获取一个自行车共享数据集。我们将使用它来探索过去的数据漂移。你可以在这个例子 Jupyter 笔记本中跟随它。

在现实生活中，您可以对训练数据进行类似的处理。

为了决定我们的漂移检测逻辑，我们应该做一些假设。

图片作者。

首先，我们要定义比较窗口。

例如，我们可以逐月查看数据。这个选择取决于你对数据的理解。数据是如何产生的？背后的真实世界过程是怎样的？你认为它变化的速度有多快？

这里有一些提示:

• 如果你的数据有已知的季节性，你可以考虑它。例如，进行一周一周的比较，而不是一天一天的比较，以避免对周末模式反应过度。或者相互比较不同年份的 12 月份数据。
• 如果你知道模型退化的速度，就以此为起点。我们在之前已经分享过这种方法。如果你知道你的模型在一个月内降级，你可以看看周漂移，看看你能提前多长时间预测这种下降，以及它看起来如何。
• **你可以建立几个漂移“视图”，设定不同的预期。**比如同时看周线和月线漂移，设置不同的阈值。用例定义了它:你可以有多个季节或者其他已知的模式。

你总是可以测试一些假设，看看这会如何改变结果。

作者图片

我们的第二个假设是漂移检测阈值。

我们可以使用统计测试来评估单个要素的漂移，并根据 P 值来判断结果。

但是为了对其进行操作或实现监控触发器，我们通常需要一些“是”或“否”的决定或整个数据集的聚合数。为此，我们可以在统计测试的结果之上实现一些定制的逻辑。

例如，我们可以查看漂移特征的份额，并且仅当超过 50%的漂移特征具有统计上的显著变化时才发出警报。

我们还可以操纵统计测试的置信水平。通常的默认值是 0.95，但是您可能有理由将其设置为 0.99 或 0.9，例如。

这里有一些提示:

• 您可以只关注关键特性。您可以根据重要性为特征分配不同的权重，或者仅对顶部特征运行漂移检测。并非所有的漂移都是一样的。次要特性的变化通常不会影响关键性能指标。
• **如果你有很多弱项，你可以看看整体漂移。**但是在这种情况下，您可以增加阈值来定义漂移已经发生(根据更高的置信水平和特征数量)。

在我们的例子中，我们有几个月的数据。让我们定义一下我们的假设:

• 我们用第一个月作为训练数据。
• 我们逐月进行漂移比较。
• 我们将测试单个要素和数据集的漂移。
• 在数据集漂移的情况下，我们将统计测试的置信水平设置为 0.95。我们将同等重视所有要素，如果超过 50%的要素发生漂移，则认为我们的数据集发生了漂移。

它在代码中的样子

要查看所有细节，请查看我们的示例 Jupyter 笔记本。

为了实现这种方法，我们将使用以下库:

• JSON 、 pandas 和 NumPy 作为处理数据所需的标准库。
• Plotly ，来可视化我们的数据漂移。
• 显然是，使用统计测试计算漂移。
• Mlflow ，记录结果。

一旦我们导入了库，我们就加载了数据。看起来是这样的:

作者图片，Jupyter 笔记本中的数据集预览。

我们定义列映射来指定特征类型。这显然是执行正确的统计测试所需要的。

data_columns = {}
data_columns['numerical_features'] = ['weather', 'temp', 'atemp', 'humidity', 'windspeed']

我们还定义了我们的参考数据(第一个月)和随后的时间段来评估漂移。我们将每个月的数据视为一次实验。

reference_dates = ('2011-01-01 00:00:00','2011-01-28 23:00:00')experiment_batches = [
    ('2011-02-01 00:00:00','2011-02-28 23:00:00'),
    ('2011-03-01 00:00:00','2011-03-31 23:00:00'),
    ('2011-04-01 00:00:00','2011-04-30 23:00:00'),
    ('2011-05-01 00:00:00','2011-05-31 23:00:00'),  
    ('2011-06-01 00:00:00','2011-06-30 23:00:00'), 
    ('2011-07-01 00:00:00','2011-07-31 23:00:00'), 
]

接下来，我们实现了两个自定义函数。他们在显然由概要提供的统计测试结果之上引入逻辑。

**第一个帮助检测数据集漂移。**它将返回关于整体漂移的单一真真或假响应。我们可以设置统计测试的置信水平，并选择漂移特征的阈值。我们也可以通过设置 get_ratio 为 TRUE 来获得漂移特性的份额。

**第二个有助于检测特征漂移。**显然已经在 JSON 概要文件输出中返回了各个特性的 P 值。我们添加这个函数来获得每个特性的二进制响应:1 表示漂移，0 表示不漂移。我们可以设置统计测试的置信水平。并且，我们仍然可以通过将 get_pvalues 设置为 TRUE 来获得每个特征的 P 值。

您可以按照这个示例构建自己的定制逻辑。

可视化特征漂移

先说特征漂移。

我们调用我们的函数来评估单个特征的漂移。

features_historical_drift = []**for** date **in** experiment_batches:
    drifts = detect_features_drift(raw_data.loc[reference_dates[0]:reference_dates[1]], 
                           raw_data.loc[date[0]:date[1]], 
                           column_mapping=data_columns, 
                           confidence=0.95,
                           threshold=0.9)

    features_historical_drift.append([x[1] **for** x **in** drifts])

features_historical_drift_frame = pd.DataFrame(features_historical_drift, columns = data_columns['numerical_features'])

然后，我们使用 Plotly 将结果可视化在热图上。我们将检测到漂移的时间段标为红色。

这是我们得到的结果:

作者形象，情节可视化。

哎哟！一点都不稳定。

事实是，我们采用了一个季节性很强的用例。我们的数据实际上与天气有关。温度、湿度、风速模式逐月变化很大。

这给了我们一个非常明确的信号，我们需要考虑最新的数据，并经常更新模型。

如果我们想以更精细的方式来看，我们可以绘制 P 值。我们将 get_pvalues 设置为真，然后生成一个新的绘图。

作者形象，情节可视化。

在更细微的变化的情况下，将 P 值视为梯度而不仅仅是漂移的布尔真/假可能会有所帮助。

可视化数据集漂移

现在让我们调用一个函数来计算数据集漂移。

知道了数据的不稳定性，我们将阈值设得很高。只有当 90%的特征在分布上有统计变化时，我们才称之为漂移。

dataset_historical_drift = []**for** date **in** experiment_batches:
    dataset_historical_drift.append(detect_dataset_drift(raw_data.loc[reference_dates[0]:reference_dates[1]], 
                           raw_data.loc[date[0]:date[1]], 
                           column_mapping=data_columns, 
                           confidence=0.95))

这就是逐月统计的结果。

作者形象，情节可视化。

您还可以设置一个更细粒度的视图，并使用每个月内的漂移特征份额绘制一个图。

作者形象，情节可视化。

根据不同的用例，您可以选择不同的方式来显示这些数据，比如条形图。

记录漂流物

当我们的目标是探索或分享信息时，可视化是很有帮助的。

但是我们可能还想简单地记录其他地方的特性和数据集漂移测试的数字结果。例如，我们想记录一个实验结果的漂移值。

或者，我们想为生产中的模型跟踪它。

一旦我们定义了漂移条件，我们就可以监控它们是否得到满足。我们希望得到一个布尔响应，无论生产中是否发生了漂移，或者基于某个阈值触发警报。

要记录漂移结果，我们可以使用 Mlflow 跟踪。这是一个管理 ML 生命周期的流行库。在这种情况下，我们显然使用和我们的自定义函数来生成输出(数据集漂移度量)，然后用 Mlflow 记录它。

你可以按照我们在 Jupyter 笔记本中的例子来做。这很简单！

以下是 Mlflow 界面中的结果。我们记录了每次运行的数据集漂移指标。

图片由作者提供，Mlflow 界面截图。

或者这是一个扩展视图:

图片由作者提供，Mlflow 界面截图。

适应您的用例

您可以将这个示例应用到您的用例中。

例如，您可以修改漂移检测逻辑来更好地考虑手头的用例。您可以测试几种组合，并选择合适的窗口和漂移条件。

你也可以用其他的 报道 **。**例如，除了数据漂移之外，您还可以生成一个性能报告来记录模型质量指标。然后，您可以遵循类似的步骤，使用 Plotly 来分析您的模型衰减测试的结果，从而可视化历史模型性能。

**当然，这种方法也适用于生产。**尤其是当您有批量模型运行时。例如，您定期对数据和预测运行漂移检查，并使用 Mlflow 进行记录，或者简单地将其写入数据库。

你一直在看你的数据漂移吗？让我们知道！

最初发表于https://evidentlyai.com并与 埃琳娜·萨穆伊洛娃 合著。

在 appeally AI，我们创建了开源工具来分析和监控机器学习模型。在 GitHub 上查看我们的 项目，喜欢就给它一颗星！

想留在圈子里吗？

• 报名参加 我们的每月简讯。
• 关注 推特 和Linkedin。
• 加入我们的 不和谐社区 聊天连线。

如何检测、处理和可视化异常值

原文：https://towardsdatascience.com/how-to-detect-handle-and-visualize-outliers-ad0b74af4af7?source=collection_archive---------15-----------------------

当我刚开始开发数据科学项目时，我不关心数据可视化或离群点检测，我只关心创建酷模型。但是，当我开始检查其他数据科学家的代码时，我意识到数据质量甚至比模型本身更重要，所以我开始更多地关注探索性数据分析(EDA)部分，我意识到我是多么愚蠢。

介绍

几乎在任何数据科学项目中，我们都必须了解我们将要处理的数据。根据我们从事的项目，这些数据会有很大差异，但每个项目的流程几乎都是相同的:

1. 从源(读取数据。csv，。xlsx，关系数据库…)
2. 检查每一列的描述性统计数据(平均值、最大值、最小值、标准偏差、中位数……)
3. 数据清理和数据争论(删除或填充 NaN、inf 和-inf 值，删除无用的列，创建新列……)
4. 使用不同类型的图(条形图、散点图、箱线图等)可视化数据
5. 处理异常值(如果可能，删除或转换它们)
6. 创建、训练和测试模型
7. 迭代最佳模型，进行微调、特性选择和 A/B 测试
8. 选择最佳模型并部署它

当然，详细解释这一过程需要很长时间，所以在这篇文章中，我将把重点放在异常检测、处理和可视化上。但是等一下…什么是离群值，为什么我应该关心它们？

根据维基百科，这是离群值的定义:

在统计学中，异常值是与其他观察值显著不同的数据点。异常值可能是由于测量中的可变性造成的，或者它可能表明实验误差；后者有时被排除在数据集之外。异常值会在统计分析中引起严重的问题。

一些异常理论

既然我们已经了解了什么是异常值以及为什么处理它们很重要，我们可以从一些理论开始。

正态分布和标准偏差[2]

上图显示了一个完美的正态分布数据集。如果我们仔细观察曲线的中心，我们会看到数据集的平均值的标准偏差为 0，根据理论，正态分布数据集的 99.7%的数据点距离平均值的标准偏差在 3 到-3 之间。这意味着标准偏差大于 3 或小于-3 的所有值都将被视为异常值。

用 Python 可视化离群值

检测异常值的一个非常有用的方法是可视化它们。显示异常值的最佳图表类型是箱线图。但是，在可视化之前，让我们加载一个数据集:

Scikit-learn 的加州住房数据集

箱形图

正如我之前所说的，当谈到离群值可视化时，盒状图是掌握关于数据离群值的有价值信息的最简单的方法。但是在可视化任何异常值之前，让我们理解什么是箱线图及其不同的组成部分:

箱形图的组成部分[3]

正如我们在上面的图像中看到的，箱线图有许多组成部分，每一部分都有助于我们表示和理解数据:

• Q1。 25%的数据低于该数据点。
• **中位数。**数据集的中心值。它也可以表示为 Q2。50%的数据都在这个数据点以下。
• Q3。 75%的数据都在这个数据点以下。
• **最小值。**数据集中非异常值的最小值数据点。
• **最大。**数据集中非离群值的最大值的数据点。
• **IQR。**代表 Q1 和 Q3 之间的所有值。

一旦我们理解了盒状图的所有组成部分，让我们针对数据集中的给定变量对其进行可视化:

哇！看起来在我们的数据集的 MedInc 变量中有许多异常数据点。但是，如果我们想检查熊猫的数据框中的这些行呢？我们怎样才能只选择这些行呢？

在下面的段落中，我们将看到如何使用 Python 和 scipy 包来检测异常值。

从头开始检测异常值

正如我们在文章开头所说的，所有偏离平均值 3 或-3 个标准差的数据点都是异常值。让我们为 MedInc 列(中等收入列)编码:

这些是异常值:

中间异常行

如果我们移除所有医学异常值，这将是数据集:

无医学异常值的数据集

用 Scipy 检测异常值

有一种更简单的方法来检测异常值。多亏了 scipy 包，我们可以计算任何给定变量的 z 值。z 得分让您了解一个数据点离平均值有多少标准差。因此，如果 z 得分为-1.8，我们的数据点将偏离平均值-1.8 个标准偏差。让我们检查代码:

如果我们显示数据框，结果将与我们之前从头开始的方法相同:

使用 z-score 对异常值行进行 MedInc

使用 z-score 的无医学异常值数据集

处理异常值

我们已经学会了如何检测和可视化异常值，但是我们如何处理它们呢？这个问题没有简单的答案，但我会尽量简短。答案是，这在很大程度上取决于你正在做的项目类型:

如果您正在进行探索性数据分析(EDA)，您的一些见解可能是错误的，因为异常值可能会让您得出错误的结论。为了防止这种情况，您还应该从其余数据中单独分析您的异常值，并尝试重复分析以消除异常值。一旦你完成了这个迭代过程，你的洞察力将更加一致。

在您创建机器学习模型的情况下，离群值可能会使您的模型表现不佳。为了防止这种情况发生，你可以尝试不同的方法。这里有两个例子:

• 如果您有大量数据，但离群值很少，您可以尝试删除它们，并用较少的数据训练您的模型。
• 如果异常值是由错误的测量(如传感器收集的数据)引起的，您可以尝试使用平均值来更改异常值。

摘要

在这篇文章中，我们看到:

1. 离群值的定义
2. 关于异常值和数据分布的一些理论
3. 如何可视化离群值
4. 如何检测异常值
5. 如何处理异常值

参考

如何检测 Python 应用程序中的内存泄漏

原文：https://towardsdatascience.com/how-to-detect-memory-leakage-in-your-python-application-f83ae1ad897d?source=collection_archive---------12-----------------------

标准的 Python 库，可以显示每一行的内存使用和执行时间

来自佩克斯的路易斯·金特罗的照片

看到我们如何在 python 中提高测量算法的性能是很有趣的。大约十年前，当我开始用 python 编程时，我将时间存储在代码中不同点的变量中。这肯定是最丑陋的方式，但在那个时候，我认为我很聪明。

几年后，当我学会使用 python 中的 decorators 时，我创建了一个函数来做同样的事情。我以为我变聪明了。

但是 python 生态系统在过去十年中已经变得非常庞大。它的应用超越了数据科学和 web 应用开发。随着这一发展，我们改进了用 Python 进行性能审计的方法。

在云计算时代，对资源使用的更精确测量的需求很高。如果你使用 AWS、Azure、G-Cloud 或任何其他云基础设施，通常你必须为资源小时付费。

此外，Python 是机器学习和分布式计算等数据密集型应用的流行语言。因此，理解概要分析和性能审计对于每个 Python 程序员来说都是必不可少的。

在本文中，我们将讨论，

• 测量执行时间的又快又脏的方法；
• 提取运行持续时间的准确摘要；
• 在不同点拍摄内存快照；

在继续之前，让我们也讨论一下我多年来一直使用的老派方法。

我再也不会用以前的学校方法了。

这个方法是我刚开始编程时的做法。我存储函数执行前后的时间值。区别在于这个过程运行了多长时间。

下面的代码片段计算小于输入值的质数。在函数的开头和结尾，我写了代码来捕捉时间和计算持续时间。如果我需要编写另一个需要性能审计的函数，我将不得不再次做同样的事情。

这个方法我用了好几年。我遇到的最大问题是我的代码库被快照时间填满了。即使在一个小规模的项目中，这些重复的行也很烦人。它降低了代码的可读性，使调试成为一场噩梦。

当我了解到装修工人时，我很兴奋。他们可以让我的 python 代码再次变得漂亮。我只需要在每个函数的顶部放置一个装饰器。

装饰器接受一个函数，添加一些功能，并返回修改后的。这是我的计算和打印执行时间。

我创建了一个装饰器来捕捉执行函数前后的时间，并在上面的代码中打印出持续时间。我可以注释任何函数，它会打印每次执行的持续时间。

如你所见，我写了第二个函数— skwer。然而，这一次我没有重复任何时间捕获代码。相反，我也注释了 skwer。

装饰者是伟大的时间节省者。有了它们，代码看起来更整洁了。但是对于这种捕获执行时间的方法有一个警告。

如果你的脚本包含一个递归函数，一个调用自己的函数，这将是一个混乱。我已经使用了一段时间的一个变通方法是将装饰器附加到一个包装函数上。

Python 有一些标准库可以方便地解决这些问题。其中两个跟踪运行持续时间的是“timeit”和“cProfile”

测量执行时间的最快方法。

Python 标准安装包括 time it——一种测量执行时间的便捷方法。

有了 timeit，你不必重写代码来捕捉时间和手工计算。此外，time 它捕获语句的执行。因此不必担心递归函数调用。

还有，IPython 笔记本有一个很棒的神奇功能，可以打印电池的运行时长。在 Jupyter 笔记本上工作时，这个功能非常有用。

全面的性能统计信息集合。

时间这是一种收集性能统计数据的便捷方式。然而，它并没有深入到发现程序的哪些部分是最慢的。

另一个标准 Python 库 cProfile 可以做得更好。

运行上面的脚本将为您提供每行的说明性摘要。

Python 解释器在 6 毫秒内运行了 21894 个函数来执行我们脚本中的四行代码。解释器花了大部分时间运行第三行，在那里我们定义了 Fibonacci 函数。

很了不起。在大规模的应用程序中，我们知道 cProfile 的瓶颈在哪里。

在另一个函数中执行我的应用程序函数，也是在一个字符串中，这是一种不适。但是，cProfile 有一个更方便的方法。用哪个是你个人的喜好。

当使用 cProfile 进行审计时，我通常更喜欢 Profile 类而不是 run 方法。是的，run 方法很方便。然而，我喜欢 Profile 类，因为它不希望我在另一个类中运行函数。我有做我需要的事情的灵活性。

内存泄漏侦探。

timeit 和 cProfile 都简化了 Python 程序员的一个关键问题。查明代码在哪里花费了大部分运行时间是进一步优化机会的暗示。

然而，运行时间并不是衡量算法性能的正确标准。许多其他外部因素扭曲了实际执行时间。通常是操作系统控制它，而不是代码本身。

运行时间不是性能的衡量标准。它只是资源使用的一个代理。

由于这些外部的复杂性，我们不能断定一个长时间运行的函数确实是一个瓶颈。

Python 标准库也有一种精确估计资源使用的方法——trace malloc。

Tracemalloc 代表跟踪内存分配，是一个标准的 Python 库。它允许您在代码的不同点获取内存使用的快照。以后你可以比较一下。

这里有一个 tracemalloc 的基本例子。

运行上面的代码将输出每一行的内存使用情况。类似于 cProfile，但是是内存而不是运行时间。

代码的第四行是最重要的内存消耗者。解释器已经检查了这一行 28 次，每次都使用了 424B 的内存。

在示例应用程序中，这个数量很小。但是在实际应用中，这将是重要和关键的。

进一步的 tracemalloc 允许快照之间的比较。有了这个特性，我们甚至可以创建不同组件的内存使用图。

上面的代码将打印出每一行消耗了多少内存，以及自上次快照以来增加了多少。

在我们的代码中，我们计算了第 9 行中的第 30 个斐波那契数，并拍摄了我们的第一张快照。然后我们计算第 40 个斐波那契数列，再取一个。输出显示我们已经使用了 4664B 的额外内存，并且对第 5 行多执行了 11 次。

结论

成功运行软件的一个关键方面是准确测量它使用了多少资源。这种理解允许工程师优化 CPU 内核和内存来运行应用程序。

今天，我们在许多项目中广泛使用 Python。由于其广泛的社区和生态系统，使用在最近几年成倍增长。

本文主要关注如何追溯 Python 程序中的执行时间和内存使用情况。Python 的标准库允许我们在行的层次上找到这些矩阵，即使是在多模块应用程序上。

我们讨论了三个内置的 python 库来进行性能审计。Timeit 最方便，与 Jupyter 笔记本完美融合。cProfile 是一个全面的执行时间记录器。最后，我们讨论了 tracemalloc，它允许我们在不同的点拍摄内存快照并进行比较。

我希望在 Python 中测量性能现在已经非常清楚了。但是如何让 Python 运行得更快呢？与 Java 和 C++相比，它仍然被认为是一种缓慢的编程语言。查看我之前关于提升 Python 脚本性能的文章。

感谢阅读，朋友！看来你和我有许多共同的兴趣。我很乐意通过 LinkedIn、T2、Twitter 和 Medium 与你联系

如何用 Python pyod 检测异常值

原文：https://towardsdatascience.com/how-to-detect-outliers-with-python-pyod-aa7147359e4b?source=collection_archive---------16-----------------------

数据预处理

关于 pyod 库使用的快速教程。

威尔·梅尔斯在 Unsplash 上拍照

异常值检测是一种预处理技术，它允许识别数据集中的奇怪的数据点。

数据预处理还包括:

• 缺失值
• 标准化
• 正常化
• 格式化
• 宁滨
• 删除重复。

数据集中的异常值检测包括发现具有异常行为的项目。离群值检测可以被认为是一种预处理技术，以及缺失值检测、规范化、标准化、数据格式化、数据宁滨和删除重复项。在 Sergio Santoyo 的这篇有趣的文章中可以找到异常值检测的快速介绍。

存在不同的异常值检测技术:

• 极值分析:这种方法假设太大或太小的值都是异常值。这项技术包括 Z 检验和学生的 t 检验；
• 概率和统计模型:这些方法假设数据的特定分布。离群点是概率低的点；
• 线性模型:这些方法利用每个数据点到特定平面的距离来发现异常值。这些技术包括 PCA(主成分分析)；
• 基于接近度的模型:在这些模型中，离群点是指从其余观察中分离出来的点。这些技术包括聚类分析、基于密度的分析和最近邻法；
• 信息论模型:在这些模型中，离群值增加了描述数据集的最小代码长度；
• 高维离群点检测:这些模型实现了特定的方法来处理高维稀疏数据。

在本教程中，我利用了pyod Python 库，它支持以下异常值检测技术:

• 基于邻近的
• 线性的
• 盖然论的
• 离群系综
• 神经网络。

pyod库的完整文档可以在这个链接中找到。在本教程中，我只关注前三种技术。

这个教程可以从我的 Github 库下载。

构建数据集

首先，我从头开始构建数据集:我构建一个正弦波，然后通过手动添加三个异常值来扰动它。我利用numpy库的sin()函数来构建正弦波。

import numpy as npX = np.arange(0,100)
Y = np.sin(50*X)

在波动扰动之前，我通过matplotlib库绘制了它。

import matplotlib.pyplot as pltplt.plot(X,Y)
plt.scatter(X,Y)
plt.grid()
plt.ylabel('Y')
plt.xlabel('X')
plt.show()

作者图片

现在我通过修改一些 Y 值来扰动正弦波。最后，我有 3 个异常值。

Y[5] = 1.25
Y[60] = -2
Y[85] = 1.4
n_outliers = 3

我画出了扰动后的波形。3 个异常值的存在是清楚的。

plt.plot(X,Y)
plt.scatter(X,Y)
plt.grid()
plt.ylabel('Y')
plt.xlabel('X')
plt.show()

作者图片

基于邻近的模型

这些模型将异常值视为与其余观察值隔离的点。基于邻近度的主要模型包括:

• 聚类分析
• 基于密度的分析
• 最近的街区。

pyod库实现了以下算法:

• LOF(局部异常因素)
• COF(基于连通性的异常因素
• 基于聚类的局部离群因子
• 局部相关积分
• 基于直方图的异常值分数
• kNN (k 最近邻)
• 平均 KNN
• MedKNN(中位数 KNN)
• 子空间离群点检测
• ROD(基于旋转的异常检测)

在本教程中，我利用了KNN模型。首先，我将Y数据改造成可以作为KNN()模型输入的格式。然后，我构建了KNN模型，并用Y来拟合它。最后，我通过predict()函数预测异常值。

from pyod.models.knn import KNNY = Y.reshape(-1, 1)
clf = KNN()
clf.fit(Y)outliers = clf.predict(Y)

outliers变量是一个数组，如果Y中对应的值是离群值0，则包含1，否则包含0。因此，我可以通过名为where()的numpy函数来计算异常值的位置。在这个例子中，算法正确地检测出异常值。

np.where(outliers==1)

它给出了以下输出:

(array([ 5, 60, 85]),)

我绘制结果。首先我计算Y_outliers和X_outliers，以及Y_inliers和X_inliers。

Y_outliers = Y[np.where(outliers==1)]
X_outliers = X[np.where(outliers==1)]
Y_inliers = Y[np.where(outliers==0)]
X_inliers = X[np.where(outliers==0)]

然后，我画一个散点图。

plt.scatter(X_outliers, Y_outliers, edgecolor='black',color='red', label='outliers')
plt.scatter(X_inliers, Y_inliers, edgecolor='black',color='green', label='inliers')
plt.legend()
plt.grid()
plt.ylabel('Y')
plt.xlabel('X')
plt.show()

作者图片

每个异常值检测算法为每个数据点计算一个异常值。数据点的异常值越大，该数据点为异常值的概率就越高。我通过decision_function()计算异常分数。

anomaly_score = clf.decision_function(Y)

我绘制了一个直方图，其中显示了异常值，一条垂直线显示了算法用来检测异常值的最小异常值。

min_outlier_anomaly_score = np.floor(np.min(anomaly_score[np.where(outliers==1)])*10)/10
plt.hist(anomaly_score, bins=n_bins)
plt.axvline(min_outlier_anomaly_score, c='k')
plt.xlabel('Anomaly Score')
plt.ylabel('Number of data points')
plt.show()

作者图片

我可以手动定义异常值。例如，我可以考虑异常值大于 0.3 的所有数据点。在这种特定的情况下，手动定义并不好用，但在其他情况下，它可能是有用的。

raw_outliers = np.where(anomaly_score >= 0.3)
raw_outliers

它给出了以下输出:

(array([60, 85]),)

推广到其他模型

所描述的过程也可以推广到其他方法。为了避免重复代码，我定义了一个名为outliers_detection()的函数，它接收异常模型及其名称作为输入。该函数精确计算出我为KNN模型计算出的值。

def outliers_detection(model, name):
    clf = model
    clf.fit(Y)

    outliers = clf.predict(Y)

    Y_outliers = Y[np.where(outliers==1)]
    X_outliers = X[np.where(outliers==1)]

    Y_inliers = Y[np.where(outliers==0)]
    X_inliers = X[np.where(outliers==0)]
    print(X_outliers)

    plt.scatter(X_outliers, Y_outliers, edgecolor='black',color='red', label='outliers')
    plt.scatter(X_inliers, Y_inliers, edgecolor='black',color='green', label='inliers')
    plt.title(name)
    plt.legend()
    plt.grid()
    plt.ylabel('Y')
    plt.xlabel('X')
    plt.show()

    anomaly_score = clf.decision_function(Y)
    min_outlier_anomaly_score = np.floor(np.min(anomaly_score[np.where(outliers==1)])*10)/10
    plt.hist(anomaly_score, bins=n_bins)
    plt.axvline(min_outlier_anomaly_score, c='k')
    plt.xlabel('Anomaly Score')
    plt.ylabel('Number of data points')
    plt.show()
    return anomaly_score

线性模型

pyod库实现了以下线性模型:

• 主成分分析
• 最小协方差行列式
• 单类支持向量机
• 基于偏差的异常值检测。

在这个例子中，我使用了OCSVM模型。首先，我构建模型，然后调用outliers_detection()函数。

from pyod.models.ocsvm import OCSVM
model = OCSVM()
anomaly_score = outliers_detection(model, 'OCSVM')

该模型确定了以下异常值:

[ 5  6 29 30 53 54 60 65 77 85]

作者图片

作者图片

这个模型高估了异常值的数量。因此，我可以手动定义离群值。从前面的直方图中，我可以看到，例如，异常值可能是异常值大于 2.5 的所有数据点。

raw_outliers = np.where(anomaly_score >= 2.5)
raw_outliers

它给出了以下输出:

(array([ 5, 60, 85]),)

在这种情况下，算法会正确识别异常值。

或者，当我构建模型时，我可以指定要检测的异常值的百分比，前提是我事先知道异常值的数量。这可以通过设置contamination参数来完成。

model = OCSVM(contamination=n_outliers/len(Y))
anomaly_score = outliers_detection(model, 'OCSVM')

这给出了以下异常值:

[ 5 60 85]

概率模型

pyod库实现了以下概率模型:

• ABOD(基于角度的异常检测)
• FastABOD(基于角度的快速异常检测)
• COPOD(基于 Copula 的离群点检测)
• 中位数绝对偏差
• 随机异常值选择。

在下面的例子中，我主要关注ABOD模型。类似地，对于OCSVM模型，ABOD模型高估了异常值的数量。

from pyod.models.copod import COPOD 

model = COPOD()
anomaly_score = outliers_detection(model, 'COPOD')

该模型确定了以下异常值:

[ 6 29 30 53 54 60 76 77 78]

在这种情况下，识别出的异常值列表不包含任何实际的异常值。因此，在这个具体的例子中不应该使用这个算法。

摘要

在本教程中，我展示了如何使用 Python pyod库检测异常值。

可以通过手动设置阈值来修改基本算法，以区分正常数据点和异常值。

或者，可以通过指定污染百分比来修改基本模型。

相关文章

[## 如何在 Python 中处理不平衡的多类数据集

towardsdatascience.com](/how-to-deal-with-imbalanced-multiclass-datasets-in-python-fe0bb3f2b669)

时间序列预测中如何检测随机游走和白噪声

原文：https://towardsdatascience.com/how-to-detect-random-walk-and-white-noise-in-time-series-forecasting-bdb5bbd4ef81?source=collection_archive---------2-----------------------

找出目标是否值得预测

照片由 【鸢】像素 组成。除非另有说明，所有图片均为作者所有。

介绍

再强大的机器学习也不能预测一切。一个众所周知的领域是时间序列预测，在这个领域它可能会变得非常无助。

尽管有一大套自回归模型和许多其他时间序列算法可用，但如果目标分布是白噪声或遵循随机游走**，你就无法预测目标分布。**

因此，在进一步努力之前，您必须检测这样的分布。

在本文中，您将了解什么是白噪声和随机游走，并探索检测它们的成熟统计技术。

**https://ibexorigin.medium.com/membership

获得由强大的 AI-Alpha 信号选择和总结的最佳和最新的 ML 和 AI 论文:

https://alphasignal.ai/?referrer=Bex

在我们开始之前…

这是我关于时间序列预测系列的第三篇文章(你可以从这个列表，一个新的媒体特性中查看整个系列)。

第一个是关于每一个熊猫功能操纵 TS 数据，第二个是关于时间序列分解和自相关。

为了从这篇文章中获得最大收益，你至少需要理解什么是自相关。在这里，我将给出一个简单的解释，但如果你想更深入地了解我的上一篇文章。

自相关的简要说明

自相关涉及到寻找时间序列和其滞后版本之间的相关性。考虑这个分布:

滞后时间序列意味着将其向后移动一个或多个周期:

自相关函数(ACF)在每个滞后 k 找到时间序列与其滞后版本之间的相关系数。您可以使用statsmodels中的plot_acf函数来绘制它。它看起来是这样的:

x 轴是滞后 k，，y 轴是每个滞后的皮尔逊相关系数。红色阴影区域是置信区间。如果柱的高度在该区域之外，这意味着相关性在统计上是显著的。

什么是白噪声？

简而言之，白噪声分布是具有以下特征的任何分布:

• 零平均值
• 恒定方差/标准差(不随时间变化)
• 所有滞后的自相关为零

本质上，它是一系列随机数，根据定义，没有算法可以合理地模拟它的行为。

有一些特殊类型的白噪声。如果噪声是正常的(遵循一个正态分布，则称为高斯白噪声。让我们看一个直观的例子:

标准偏差为 0.5 的高斯白噪声分布

即使偶尔有尖峰，也看不到可辨别的模式，即分布完全是随机的。

验证这一点的最佳方法是创建 ACF 图:

白噪声分布在所有滞后处的自相关约为 0。

还有“严格的”白噪声分布，它们具有严格的 0 序列相关性。这不同于褐色/粉红色噪声或其他自然随机现象，在这些现象中存在微弱的序列相关性，但仍保持无记忆。

白噪声在预报和模型诊断中的重要性

照片由爱德蒙·邓蒂斯从像素拍摄

尽管白噪声分布被认为是死胡同，但它们在其他情况下可能非常有用。

例如，在时间序列预测中，如果预测值和实际值之间的差异代表一个白噪声分布，您可以为自己的出色工作而感到欣慰。

当残差显示任何模式时，无论是季节性的还是趋势性的，或者具有非零均值，这表明仍有改进的空间。相比之下，如果残差是纯粹的白噪声，那么您已经超出了所选模型的能力。

换句话说，该算法设法捕捉到了目标的所有重要信号和属性。剩下的是随机波动和不一致的数据点，它们不能归因于任何东西。

例如，我们将使用七月的 Kaggle 游乐场竞赛来预测空气中的一氧化碳含量。我们将保持输入“原样”，我们不会执行任何特征工程，我们将选择一个带有默认参数的基线模型:

为简洁起见，省略了初始化和训练/测试分割步骤

ACF 图中有一些模式，但它们在置信区间内。这两个图表明，即使使用默认参数，随机森林也可以从训练数据中捕获几乎所有的重要信号。

随机漫步

时间序列预测中更具挑战性但同样不可预测的分布是随机游走。与白噪声不同，它具有非零均值、非恒定标准差/方差，绘制时看起来很像正态分布:

这难道不像雅虎财经里的股票情节吗？

随机漫步系列总是以这种方式巧妙伪装，但它们仍然一如既往地不可预测。对今天价值的最佳猜测是昨天的。

初学者的一个常见困惑是将随机漫步视为一个简单的随机数序列。事实并非如此，因为在随机漫步中，每一步都依赖于前一步。

出于这个原因，随机游走的自相关函数和返回非零相关性。

随机漫步的公式很简单:

无论前面的数据点是什么，添加一些随机值，并继续下去，只要你喜欢。让我们用 Python 来生成这个，比如说，初始值为 99:

让我们也画出 ACF:

如你所见，前 40 个滞后产生了统计上显著的相关性。

那么，当可视化不是一个选项时，我们如何检测随机游走呢？

由于它们是如何产生的，区别时间序列应该隔离每个步骤的随机添加。取一阶差是通过将序列滞后 1 并从原始序列中减去它来完成的。熊猫有一个方便的diff功能来做到这一点:

如果你画一个时间序列的一阶差分，结果是白噪声，那么就是随机游走。

漂移随机游动

对常规随机行走的一个微小修改是添加一个常数值，称为随机漂移步长:

漂移通常用μ表示，就随时间变化的值而言，漂移意味着逐渐变成某种东西。

例如，即使股票不断波动，它们也可能出现正漂移，即随着时间的推移，总体上逐渐增加。

现在，让我们看看如何用 Python 来模拟这一点。我们将首先创建起始值为 25:

从上面的公式中，我们看到，我们需要在每一步添加所需的漂移。我们再加上漂移 5，看剧情:

尽管有剧烈的波动，这个系列还是有明显的上升趋势。如果我们进行差分，我们将看到该系列仍然是随机行走:

drifty_walk.diff().plot();