准备 AWS 数据库专业认证— 7 个步骤
带有视觉主题风景地图的指南
当我通过认证考试时，LinkedIn 认证组的一些社区成员问我的准备情况，并指出 Safari Books Online、Packt Publishing 或 Udemy 没有课程。
在这里，我详细介绍了建议的准备步骤，并分享了我创建的帮助我准备考试的技术主题景观图。
了解知识领域
了解认证的 5 个方面。这是第 0 步。
- 特定于工作负载的数据库设计
- 部署和迁移
- 管理和运营
- 监控和故障排除(包括性能)
- 数据库安全
最初不要太在意权重，对所有的都同等重要。
RDS 和 Aurora 总是最常见的话题，但这仅仅是因为它们有大量的风格和版本。
AWS 上的数据库是一个非常庞大的主题，涉及 AWS 架构知识和数据库知识的交叉。虽然解决方案体系结构助理或解决方案架构师专业认证不是强制性的，但了解这些主题非常重要。
参加考试准备培训—第一关
在 AWS 培训和认证站点进行的考试准备:AWS 认证数据库-专业培训应该是您的第一步。但是，我建议您在第一次通过时，以快节奏的方式进行培训，并浏览主题。
这个想法是将你自己的经验与认证考试的要求对应起来。可能有些领域你有很深的知识，很好地符合考试要求，而有些领域你可能不会在日常工作中遇到，需要一些关注。
阅读架构良好的白皮书
这是准备工作的第 2 步，理解数据库作为整个 AWS 架构的一部分的重要性。
数据库部分是最重要的。
AWS 数据库专业主题前景
完成这些步骤后，转到步骤 3。重点是我创建的主题风景图。用这个来发展你自己的覆盖范围和准备地图。
我在这里用神奇的绘图工具 draw.io 重新创建了我的学习地图。
下面是你阅读和使用它的方法:对于每一个内圈的项目，从外圈里挑选一个项目，阅读或思考它。通过实践经验或从视频和最佳实践文档中使用的知识，了解组合(内圈+外圈)，如何最好地使用它，它如何影响您的架构/设计，以及如何最好地处理它。
以下是预期的范围和深度(根据我的经验):
- 希望对 Neptune、QLDB、DocumentDB、CloudFormation 和 elastic cache(memcached)有基本的了解。
- 对红移、弹性缓存(Redis)、网络、安全、成本和 Lambda 有中等水平的了解
- 关于 Dynamo、RDS(各种风格)、Aurora (MySQL 和 PostgreSQL)、迁移和 HA 的详细知识水平。
阅读 AWS 文档中的最佳实践部分
这是第 4 步，您将逐步导航到 AWS 文档中的每个产品，并专门查看每个产品的“最佳实践”部分。
吸收知识，反思建议。
AWS 回复:发明视频
准备的第五步应该是在 YouTube 上看 AWS re:Invent 2017 视频(DAT3xx 和 DAT4xx)。2017 年的所有视频(以及 2016 年的一些视频)都有适当的深度，有助于准备工作。
re:Invent 2018/2019 中的一些新功能有助于实现新功能。
给出了一些链接
AWS re:Invent 2017:新发布！亚马逊 Neptune 概述和客户用例(DAT319)
AWS re:Invent 2017:新发布！亚马逊海王星上的深潜(DAT318)
AWS re:invent 2017:迁移到 Amazon Au (DAT315)并在其上运行的实践者指南
AWS re:invent 2017:从 Oracle 和 SQL Server 迁移到亚魔卓的最佳实践(DAT309)
AWS re:invent 2017:在 AWS 上运行 PostgreSQL 的最佳实践(DAT314)
AWS re:invent 2017:深入探索亚马逊关系数据库服务(RDS) (DAT302)
AWS re:invent 2017:深入了解亚马逊 Aurora MySQL 兼容版(DAT301)
AWS re:invent 2017:深入了解亚马逊 Aurora PostgreSQL 兼容版(DAT402)
AWS re:invent 2017:elastic cache 深度挖掘:最佳实践和使用模式(DAT305)
AWS re:invent 2017:将数据库和数据仓库迁移到云:获取 St (DAT317)
AWS re:invent 2017:将您的 SQL Server 数据库迁移到 Amazon RDS (DAT312)
AWS re:invent 2017:在亚马逊 RDS 上运行 Oracle 数据库(DAT313)
AWS re:invent 2017:重复什么时候用哪个数据库？
AWS re:invent 2017:~ REPEAT ~ Amazon dynamo db(dat 403-R)的高级设计模式
参加考试准备培训—第二遍
我建议再参加一次考试准备培训，这是第二次，现在重点更加突出。
此外，这也是浏览培训中列出的所有链接的时间。
参加模拟考试
此时，您应该已经准备好参加认证考试了。
参加模拟考试可能会有帮助，如果只是为了评估难度水平，以及最后一分钟的检查，以确保你对主题有体面的覆盖面。
不要因为模拟考试只有 20 道题，权重和覆盖面计算无法和真题匹配，就去关注分数。
结论
这份 AWS 数据库专业认证考试准备指南和可视化主题景观图应该对数据库从业者和数据架构师有用。
为 TensorFlow 对象检测准备开放图像数据集
使用开放图像创建张量流对象检测数据集的指南
数据是建立深度学习模型时要考虑的最强支柱之一。数据越精确，模型越有经验。为了训练深度学习模型，你需要大量的数据，你可能想要创建自己的数据，或者你可以使用互联网上的公共数据集，如可可女士、 ImageNet 、开放图像等。
有时，这些数据集遵循不同的格式，而您想要定型的模型遵循另一种格式。当数据非常大时，使数据可供模型使用变得很麻烦。这是我在创建自己的物体探测器时偶然打开的。
目标检测是计算机视觉的一个分支，它可以定位图像中的特定目标。我使用了 Tensorflow 对象检测 API 来创建我的自定义对象检测器。为了创建我的探测器，我从开放图像 V4 数据集创建了我的数据。数据集包含 600 个类和总共约 170 万幅图像，分为训练集、验证集和测试集。它已经更新到 V6，但我决定用 V4，因为有两个工具我们很快就会看到。
为了训练一个 Tensorflow 物体检测模型，你需要创建TF records，它使用了以下:
1。图像
2。图像注释
“打开图像”既有图像，也有它们的注释。但是，所有的注释都放在一个文件中，当您需要特定类的数据时，这个文件会变得很笨拙。为了处理这个问题，我决定将数据转换成 PASCAL VOC 格式。现在，你可能会问什么是 PASCAL VOC？简而言之，PASCAL VOC 格式为每个图像创建一个 XML 文件，该文件包含图像中每个对象的边界框的坐标。很有条理，对吧？如果你想了解更多关于 PASCAL VOC 的知识，这里的是一个很棒的参考。
现在说得够多了，让我们看看实际情况吧！
但是但是但是！在我们开始之前，你可能想和我一起走，所以这是我的 github 回购的笔记本。我们开始吧！
我建议使用 google colab，因为这些工具可能需要的一些文件很大，可能对未来的用例没有用处。
- 这个工具让我们可以下载特定类别和特定数量的图像。通过克隆 repo 下载该工具。
- 下载完成后，您会发现一个 classes.txt 文件。这里您需要提到您想要收集其数据的类名。你可以在这里找到课程列表。例如，我将采取类’手机’和 98 个图像相同。
- 粘贴以下代码:
当您第一次运行脚本时，该工具可能会要求您下载一些文件，允许它。下面是提示符的样子
开放图像数据集工具包的屏幕截图
该工具为每个分割创建目录，并为这些目录中的每个类创建子目录。
4.现在，让我们使用以下脚本来看看每个类的文件数量:
输出以查看手机目录中的文件
嗯（表示踌躇等）…但是我提到了 98 张图片，对吧？它会创建一个名为“Label”的文件夹，其中包含每个图像的注释。
让我们看看文件夹“标签”包含什么:
标签目录中的内容
我们为每个图像获取一个注释文件。但是，我们说完了吗？没有。注释不符合 PASCAL VOC 格式。因此，我们需要另一种工具，可以将这些注释转换成所需的格式。
这个工具为我们做最后的工作。克隆它。我稍微修改了这个工具，让名字中有一个以上单词的类可以在我的报告中找到这里。
完成后，运行以下命令来转换注释文件:
这里， sourcepath 是每个类的“标签”文件夹的位置， dest_path 是存储 XML 注释的位置。
一旦创建了 XML 注释，我们就不再需要 txt 注释了。让我们删除它们:
这将删除所有类别目录中名为“Label”的所有文件夹。
现在您已经有了过滤后的数据集！😀
提示:一旦数据集准备好，使用 labelImg 验证注释。对象有时可能被错误地注释。
就是这样，伙计们！感谢您的阅读😊
为变压器预培训准备数据—书面报告
为 Transformer (BERT、RoBERTa、XLM、XLNet 等)收集、连接、重排和标记所需的数据。)预培训
Devlin 等人的 BERT 论文的截图(2018)
仅在一年多前，瓦斯瓦尼等人(2017)推出的 Transformer 模型的最知名化身，Devlin 等人(2018)推出的BI 方向En 编码器 R 表示来自Ttransformers(更好地称为 BERT )模型，此后在自然语言处理(NLP) 社区中变得非常受欢迎。这不仅是因为它在一系列 NLP 任务上的最先进的结果，也是因为它可以通过他们自己的库公开获得，还因为越来越受欢迎的 T21 变形金刚库。
伯特和其他变形金刚像罗伯塔、和 XLNet 都是在多伦多图书语料库数据集(朱等人，2015)和英语维基百科的串联上(以及其他)被预训练的。由于前者不再公开提供，而后者需要大量的预处理，这篇文章展示了收集、连接、重排和标记自己试验这些变压器模型所需的数据所涉及的一切(和代码)。
收集(和预处理)数据
多伦多图书语料库数据集
如前所述，朱等人(2015)的多伦多图书语料库(TBC) 数据集已不再公开。然而，数据集的来源仍然可用。因此，您可以按照我之前的这篇文章自己复制 TBC 数据集:
复制不再公开的多伦多图书语料库数据集，从其…
towardsdatascience.com](/replicating-the-toronto-bookcorpus-dataset-a-write-up-44ea7b87d091)
英语维基百科
虽然 维基百科转储 是免费提供的，但在准备用于变压器预训练之前，它们仍然需要被提取、清理和预处理。因此，类似于 TBC 数据集，您可以在我之前的另一篇文章之后这样做:
[## 为 NLP 模型训练预处理 Wikipedia 转储—书面报告
下载、提取、清理和预处理 NLP 模型的维基百科转储(例如像 BERT 这样的变压器…
towardsdatascience.com](/pre-processing-a-wikipedia-dump-for-nlp-model-training-a-write-up-3b9176fdf67)
➕🔀串联和混排数据
现在，您已经收集了多伦多图书语料库数据集和英语维基百科，我们可以继续连接和重组这两者。这可以在 Bash 或类似的软件中使用下面的代码很简单地完成:
cat tbc_replica.txt en_wiki.txt | shuf >> concat_shuffled.txt
💥将数据符号化
收集、连接和重组数据后，现在剩下的就是对数据进行标记。在理想情况下，我们会动态地对数据进行标记，但是出于性能原因，我们会对数据进行预标记。为此，我们使用最近发布的速度惊人的 标记器库 ，也是通过下面的代码由 HuggingFace 实现的:
要对数据进行令牌化，首先在这里下载 vocab 文件，然后在您的终端中运行下面的命令:python3 tokenize_data.pyconcat_shuffled.txt bert-base-uncased-vocab.txt
**就这样，大功告成！**现在，您可以使用您刚刚准备好的数据，自己开始试验这些 Transformer 模型。🤗
参考
[1] J. Devlin 等人， Bert:用于语言理解的深度双向变换器的预训练 (2018)， arXiv 预印本 arXiv:1810.04805 。
[2]瓦斯瓦尼等人，注意力是你所需要的全部 (2017)，神经信息处理系统进展(第 5998–6008 页)。
[3]朱等，【书与电影的对齐:通过看电影和看书走向故事化的视觉解释】 (2015)，IEEE 计算机视觉国际会议论文集(第 19–27 页)。
预处理和准备面部数据集，为 CNN 模型做好准备
让我们使用 Google Colab、TensorFlow 和 Dlib 从 IMDB-WIKI 数据集中提取人脸，并以 CNN 友好的格式存储在 Google Drive 中。
来源:IMDB-WIKI 数据集
你好朋友们。在本文中，我将对 IMDB-WIKI 数据集进行预处理，从这些图像中提取人脸，并将它们与其他有用的信息(如姓名、年龄和性别)一起保存到 Google Drive。数据将作为对象本身存储在。泡菜格式。最棒的是，你不必在你的机器上运行一行代码，而是在 Google Colab 上运行。
在深入研究我们的代码之前，我将简要介绍一下 Google Colabs。你是否曾经担心过你的电脑处理能力不够或者你缺少一个 GPU，现在你不必再担心了，因为谷歌已经通过谷歌实验室提供了一个解决方案。通过你的浏览器在谷歌的服务器上使用 GPU 进行令人眼花缭乱的快速执行。
Google Colabs 为用户提供了一个 Jupyter 笔记本，用于交互式编码体验。它与 GitHub 无缝连接。您创建的所有笔记本都存储在您的 google drive 中。
由于我们将使用 Google Colabs，我建议您学习 Jupyter 笔记本的工作原理，因为它会让您对环境感到更加舒适。如果你想了解更多关于 Google Colab 的信息，你可以阅读这篇由 fuat 撰写的 Google Colab 免费 GPU 教程。
在我们开始编码之前，让我简单介绍一下我们将如何从这里开始。
- 我将在 Google Colab 上创建一个笔记本
- 我们将把 Google drive 安装到笔记本上。
- 我们将使用这个笔记本来提取和处理数据集，并将其保存在我们的 Google Drive 中。
在本文结束时，您将准备好使用 CNN 模型的数据集。
我们开始吧。
在本文中，我详细解释了预处理过程中需要的每个步骤。我还解释了每一行代码，这样你就不会感到困惑。
1)创建您的第一个笔记本
访问 Google Colabs 主页。您将看到一个欢迎笔记本。如果您还没有登录您的 Google 帐户，请登录。已经签到的可以跳过这一步。
图 1:显示 Colab 笔记本上的登录按钮
登录后，您将看到一个弹出框。点击右下角的“新建笔记本”按钮。
图 2:创建新笔记本
将创建一个新笔记本，您将被重定向到该笔记本。它也将被保存在你的硬盘中一个名为 Colab Notebooks 的文件夹中。
现在将你的笔记本重命名为“extract _ data _ and _ preprocess . ipynb”。
2)开始编码
打开您创建的“extract data _ and _ preprocess . ipynb”笔记本。
将运行时类型改为 GPU:
- 点击运行时选项，然后转到“更改运行时类型”。
- 选择硬件加速器选项，将其从无更改为 GPU 并保存。
图 4:将运行时改为 GPU
将你的谷歌硬盘安装到你的笔记本上。
**Note:** You will be able to mount your drive only after you have connected to a runtime. To connect to a runtime if not connected already click on the connect button on the top right corner.
图 5:安装 Google Drive
现在，我们必须导入我们将在整个数据预处理过程中使用的所有包。
代码块 1:导入所需的包。
在 Colab 中，可以在不同的单元格中编写代码，并以您喜欢的任何顺序逐一执行它们。现在，执行导入所有包的单元格。
我们将使用 dlib 的基于 CNN 的人脸识别模型来从我们的数据集中的图像中检测和提取人脸。基于 CNN 的模型比 dlib 中的 Hog 模型慢，但更精确。要了解更多关于他们的区别，请阅读由阿伦·彭努萨米撰写的文章基于 CNN 的 dlib 人脸检测器。
我们必须下载 CNN 模型运行所需的权重。因此，在一个新的单元格中，让我们编写代码来下载权重。
代码块 2:下载 Dlib 的 CNN 人脸识别模型的权重。
我来解释一下代码:
**第 2 行:**我已经使用 Keras 库中的 get_file 函数下载了权重。下载的文件将存储为“mmod _ human _ face _ detector . dat . bz2”
第 3 行:‘cache _ subdir’—此处必须给出下载文件的存储路径。
第 4 行:‘origin’—待下载文件的下载网址
**第 6–10 行:**在这些行中，使用 bz2 包打开下载的压缩文件，以二进制格式读取内容并存储在“mmod_human_face_detector.dat”文件中。该文件稍后将被 CNN 模型使用。
接下来让我们下载数据集。IMDB-WIKI 数据集拥有超过 45 万张图片。处理这么多的图像并从中提取数据将花费很多时间，所以我将只使用维基数据集中的那些图像。那些希望使用 IMDB-WIKI 的人可以在下面的代码中替换“dataset_url”，将“data_key”值更改为“IMDB ”,将“mat_file”值更改为“imdb.mat”。
代码块 3:下载和提取数据集。
**第 1–2 行:**数据集的下载 URL 和将从文件中提取的文件夹名称。文件夹名称与提取无关，稍后我们的代码中将会用到它。
**第 4–7 行:**使用与之前相同的功能，并给它一个不同的下载 URL。我们将“extract”参数设置为 True，这样函数将自己提取数据集。之前我们没有使用相同的函数提取，因为 bz2 文件格式不支持提取。
第 9 行:‘wiki’是所有图像元数据存在的密钥。当您加载。mat 文件并查看它。
**第十行:**的名字。包含图像元数据的 mat 文件。
现在已经下载并提取了数据集。让我们加载。解压缩的文件夹中存在 mat 文件。由于文件是 MatLab 格式，我们必须将其转换为 Python 数据类型。
代码块 4:加载。mat 文件和初始化所需变量
第 1 行:我们正在加载。使用 scipy 包处理数据格式转换的 mat 文件。
**第 2 行:**加载的文件为字典格式。它有一个关键的“维基”，其中有其余的数据。为了更好地理解加载文件中的所有数据，您可以打印字典或访问 IMDB_WIKI 网站。
**第 3 行:**我们将所有图像的路径加载到 route 变量中。文件中的数据不是一种非常容易访问的格式，所以不要与我使用的多维数组访问相混淆。
**第 4–9 行:**初始化所有基本变量。
准备数据集的所有要求现在都已完成。在我们开始处理它之前，让我们编写代码来看看我们从数据集得到了什么，我们是如何处理它的，以及我们将要存储什么。
代码块 5:查看我们将要存储哪种图像的代码
**第 1 行:**创建 dlib 的基于 CNN 的人脸检测模型的对象。的。作为参数传递的 dat 文件是我们首先下载并提取的文件。
**第 6 行:**选择一个随机索引，从该路径加载图像并显示。
第 7 行:让这一行保持原样，我将在下一步简要解释。
**第 8 行:**从给定路径加载图像
**第 9 行:**由于 OpenCV 使用 BRG 格式，我们正在将图像转换为标准的 RGB 格式。
**第 10 行:**查找给定图像的面部坐标。它将返回图像中人脸的坐标列表。
**第 11–22 行:**使用 dlib 模型提供的人脸坐标，我们在人脸周围画一个方框。然后，我们使用 TensorFlow 提供的 crop_to_bounding_box 函数裁剪出该区域。然后我们显示两幅图像。裁剪后的人脸图像是每幅图像将要拍摄和存储的内容。
当您执行上面的单元时，您将看到来自您的数据集中的两个随机图像，这将向您显示图像将如何被处理。
图 6:显示提取的人脸样本。(来源:IMDB-WIKI 数据集)
终于到了处理整个数据集并从中提取我们需要的数据的时候了。
代码块 6:处理图像并提取人脸和其他所需数据。
**第 4 行:**对数据集中的所有图像运行一个循环，“I”是我们用来从 route 变量中的列表获取第 I 个路径的索引。然后，我们在该路径获取图像。这样，我们可以读取数据集中的所有图像。
**第 7 行:**使用 try-except 块，不要让一些错误的图像阻止我们的进程。
**第 8–9 行:**我正在访问的数据是创建该数据集的人对图像集的面部评分。所以我们忽略了所有没有人脸的图片。这将加快提取速度。我们还检查我们试图访问的图像的性别数据是否也可用。这将有助于我们忽略数据集中存在的所有破损图像。
**第 10–14 行:**如前所述，读取图像并检测其中的人脸。
**第 15 行:**我们只考虑一个只有一张脸的图像。
**第 18 行:**取 CNN 模型返回的人脸坐标。有时，当人脸出现在图像的角落时，模型往往会给出图像外部的坐标，使用 max 函数，我们可以确保坐标在图像内部。
**第 19–22 行:**获取脸部的高度和宽度。该模型返回“左上”和“右下”坐标。在下一行中，我们确保坐标在图像中。
**第 24 行:**使用 TensorFlow 的 image 类提供的函数从图像中裁剪人脸。
**第 28 行:**将图像大小调整为 32x32，因为图像大小对于任何 CNN 模型的训练都无关紧要，所以，我们可以减少图像所消耗的空间。
**第 31 行:**将提取的、调整大小的面部图像附加到图像列表。
**第 32 行:**出生日期以序数日期格式给出。因此，使用 datetime 类，我们将序数日期转换为 datetime 类对象，从中我们可以单独提取年份。
**第 33–35 行:**将各个数据添加到各自的数组中。
**第 37–51 行:**处理上述过程中发生的异常。所有阵列中数据的一致性非常重要。因此，当错误发生时，我们从列表中弹出图像数据和其他元数据。
现在我们已经完成了数据集的处理，是时候将数据存储到我们的驱动器中了。
代码块 7:保存包含所有已处理数据的字典。
**第 1–7 行:**用我们提取的数据创建字典。
**第 8–9 行:**检查我们将要存储数据的目录是否存在，如果不存在，我们就创建它。
**第 10–12 行:**我们在追加二进制模式下创建一个文件，并将我们的字典转储到其中。
**Note:** While dumping a huge object to Google Drive, it is advisable to break the data into parts and store it. The session may crash and the runtime will restart if a large file is being stored in the drive.
我附上了我的“extract _ data _ and _ preprocess . ipynb”笔记本的链接供你参考https://colab . research . Google . com/drive/1 u5 or-riuleztsmo 7 en _ h85 _ HqgIPEVlN。
希望这篇文章值得你阅读。
如有任何疑问，请随时联系我。
Instagram: nachijr4
电子邮件:nachi2muthu13@gmail.com
中等:纳赤木图
领英:纳奇穆图
预处理数据:特征缩放
sklearn 的一些重要特征缩放技术
一般来说，在更新每个机器学习模型的特征时，特征缩放是一个必要甚至是必不可少的步骤。*为什么这很重要？*很简单，因为我们用于预测或聚类的每个算法背后都隐藏着一些数学公式。这些数学公式几乎没有意识到每个要素之间的数值范围的变化，当涉及到梯度下降时，这一点是显而易见的！
事实上，未经缩放的数据会导致可视化困难，更重要的是，它们会降低许多机器学习算法的预测性能。这种类型的数据也可以减缓许多基于梯度的估计量的收敛，或者完全阻止它。
事实上，许多估计量是在假设所有特征在可比尺度上变化的情况下设计的。特别是，基于梯度的估计器通常假设训练数据已经标准化(具有单位方差的中心特征)。一个显著的例外是基于决策树的估计器，它对数据的任意缩放都是鲁棒的。
让我们举一个例子:假设你正在进行房价预测，你将拥有以下类型的特征:价格、表面、房间数量等。当然，这个数据框架的价值尺度根据特征是完全不同的。但是，您必须使用相同的算法来处理它们。这就是特性缩放的必要性所在！您的算法确实需要混合[0… 100，000]美元的价格、[10… 500]平方米的面积、从[1…10]房间。因此，缩放包括将这些数据放在同一级别。
如果您没有明智地应用特征缩放，您将会观察到缓慢的学习和降低的性能。
幸运的是， Scikit-Learn 将帮助我们再次完成这项工作，但是在使用任何技术之前，我们必须了解每种技术是如何工作的。
基本上，Scikit-Learn(sk Learn .预处理)提供了几种缩放技术，我们将回顾 4:
- 标准缩放器
- 最小最大缩放器
- MaxAbsScaler
- 鲁棒定标器
首先，我们将创建随机数据集以及一些图形函数，这将有助于我们更好地理解上述不同技术的效果。
以下是 Python 代码:
在这段代码中，除了 trace 函数之外，我们还在一个 DataFrame (Pandas)中创建了 6 个数据集。
让我们看看我们的数据集是什么样的:
标准缩放器
我们将从风险可能最小的:StandardScaler()开始我们的缩放技术之旅。
这种技术假设数据是正态分布的。该函数将重新计算每个特征，以便数据以 0 和 1 为中心。
标准化公式统计
因此，标准化去除了平均值，并将数据缩放到单位方差。然而，当计算经验平均值和标准偏差时，异常值仍然有影响。
最小最大缩放器
这种技术通过在给定的范围(默认为[0，1])上调整来变换每个特征(x)。可以通过参数 feature_range = tuple (min，max)更改该范围。为了简单起见，下面是每个特征的变换公式:
如果这种技术可能是最广为人知的，那么它特别适用于分布不是高斯分布或者标准差很小的情况。但是，MinMaxScaler()对异常值非常敏感。在这种情况下，我们快速切换到最后一种技术:RobustScaler()。
MaxAbsScaler
当值的分布很稀疏并且有很多整数时，这种缩放技术很有用。绝对值映射在范围[0，1]内。事实上，对于只有正值的数据，此缩放器的行为与 MinMaxScaler()类似，因此也存在较大的异常值。
鲁棒定标器
RobustScaler()技术使用与 MinMaxScaler()相同的缩放原理。但是，它使用四分位数范围而不是最小-最大值，这使得它在异常值方面更加可靠。以下是重新加工特征的公式:
- Q1 (x):第一个分位数/ 25%
- Q3 (x):第三个分位数/ 75%
与以前的缩放器不同，这个缩放器使用一些基于百分位数的居中和缩放统计数据。因此，它们不受非常大的边际异常值的影响。因此，变换后的特征值的结果范围比先前的定标器更大，更重要的是，大致相似。
结论
让我们总结一下我们刚刚遇到的特征缩放技术:
- 使用
[**MinMaxScaler**](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html#sklearn.preprocessing.MinMaxScaler)或[**MaxAbsScaler**](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MaxAbsScaler.html#sklearn.preprocessing.MaxAbsScaler)可以将特征缩放到一个范围，通常在零和一之间。 [**MaxAbsScaler**](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MaxAbsScaler.html#sklearn.preprocessing.MaxAbsScaler)是专门为缩放稀疏数据而设计的，[**RobustScaler**](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.RobustScaler.html#sklearn.preprocessing.RobustScaler)不能适用于稀疏输入，但您可以对稀疏输入使用transform方法。- 如果您的数据包含许多异常值，使用数据的平均值和方差进行缩放可能不会很好。在这种情况下，你需要用
[**RobustScaler**](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.RobustScaler.html#sklearn.preprocessing.RobustScaler)来代替。
这篇文章所基于的 Jupyter 笔记本可以在这里找到。
参考
- 比较不同标量对有异常值的数据的影响。https://sci kit-learn . org/stable/auto _ examples/preprocessing/plot _ all _ scaling . html
- 预处理数据。https://scikit-learn.org/stable/modules/preprocessing.html
- 我应该标准化数据吗？http://www . FAQs . org/FAQs/ai-FAQ/neural-nets/part 2/section-16 . html
张量流 CNN 模型中的预处理层 2
一种使 CNN 模型更不容易出错、更易于开发人员使用的技术
来源:pexels.com
机器学习新手最常犯的一个错误是忘记标准化输入图像。难怪！当你进行迁移学习时，每个模型需要不同的输入标准化。比如 VGG需要从 RGB 图像中减去这个矢量【123.68，116.779，103.939】。 MobileNetV2 需要区间< -1，1 >的输入。PyTorch 模型通常使用不同的归一化方法。这个技巧可以在将来为您节省大量时间和 bug。在将图像输入到模型之前，不需要进行标准化，您可以简单地将该层添加到您的模型中(计算图)。
使用旧的 TensorFlow 1(安息吧),您可以简单地向图形添加预处理操作，并冻结该模型。然而，在 TensorFlow 2+中，您需要创建自己的预处理层。
因此，首先定义我们的预处理方法(这是针对 MobileNetV2 的):
然后创建从 tf.keras.layers.Layer 继承的自定义层，并在输入上使用 call 方法中的函数:
创建模型时，在调用预训练模型的基础模型之前插入层(tf.keras 的功能 API):
就这样！
从现在开始，您的模型总是只接受 RGB [0，255]图像，并且输入的规范化在模型内部完成。如果您以 Keras .h5 格式保存了这样一个模型，那么不要忘记在模型加载期间指定定制对象。我总是建议将模型保存为 SavedModel 或 TFLITE 格式，因为模型中的一切都被冻结了，可以随时部署了！
用预处理层你:
- 节省了其他人调试你的模型的大量时间。
- 在使用您的模型时，您不需要告诉您的客户以任何方式标准化图像。将不同版本/架构的模型部署到移动设备上的计算机视觉应用程序时，这通常很痛苦。
下次见！
米哈尔
在 Python 中预处理文本数据:Kaggle 简介
作为一名数据科学家，您将不可避免地与文本数据打交道。处理文本数据(如推文、摘要或报纸文章)与处理传统的数字数据(如温度或金融数据)截然不同。
这种差异不比预处理期间大。虽然数字数据的预处理很大程度上依赖于数据(哪些列缺少大量数据？是否有任何列没有准备好进入模型？是否需要对任何列进行一次性编码？)，文本数据的预处理实际上是一个相当简单的过程，尽管理解每个步骤及其目的并不那么简单。
预处理文本数据的目的是将数据从原始的可读形式转换成计算机更容易处理的格式。大多数文本数据以及我们将在本文中使用的数据都是以文本字符串的形式出现的。预处理是获取原始输入数据并准备将其插入到模型中的所有工作。
这篇文章介绍了完成 Kaggle 的灾难推文挑战的整个过程。尽管本文包含了整个过程，但我们主要关注预处理步骤。本文描述了典型的文本数据预处理所涉及的各个阶段，并解释了每个阶段的基本原理和效果。有关其他步骤的更多信息，请参见每个部分中包含的链接。
这个 Kaggle 数据集由使用灾难相关语言的推文组成。目标是创建一个分类器，可以确定包含灾难相关语言的推文是否实际上是关于灾难的，或者是出于不同的非紧急目的使用相同的语言。
例如，推文“@bbcmtd 批发市场着火了【http://t.co/lHYXEOHY6C ”和“哭着要更多！“让我燃烧吧”都包含关键词“燃烧”，但其中只有一个是指灾难。对我们来说，很明显，前一条推文描述的是杂货店的火灾，而第二条推文指的不是真正的火灾或灾难——更有可能是一场音乐会。然而，如果一名数据科学家想从 Twitter 上搜集关于真实灾难的推文，以提醒医疗服务，他们将面临一个挑战:他们必须建立一个分类器，可以分辨出尽管两条推文都包含一个表示“着火”的单词，但其中只有一条描述的是真正的危险火灾。
事实证明，构建这样的分类器并不困难——我们将使用逻辑回归模型来完成。从我们阅读的 tweet 到我们的模型可以学习的数据的关键是预处理。
方法
对于本文，我们将基本上完成 Kaggle 挑战；即，为灾难推特数据集建立分类器。我们的大部分解释将集中在预处理部分，尽管我们将链接到每个其他步骤的有用文章。我们的方法包括数据导入、数据探索、预处理、模型训练和呈现结果。总的来说，这种方法相当简单，因为本文主要关注的是预处理。
首先当然要导入相关的包:
数据导入
接下来，我们导入数据。最简单的方法是首先从 Kaggle 下载数据，可以在这里找到。然后，阅读 CSV 的使用熊猫。显然，路径取决于计算机上各自的文件位置。
数据探索
首先，让我们看一下我们的数据:
灾难推文数据由四列组成:“关键词”、“位置”、“文本”和“目标”。“关键词”指的是推文中表示潜在灾难的特定单词。只有当 Twitter 用户在发送推文时标记了位置，才会存在“位置”数据。“文本”包含推文的文本。最后，“目标”是我们的因变量——如果推文指的是合法的灾难，则为 1；如果推文是误报，则为 0。
显然，在“关键字”和“位置”栏中有许多“不”字。但是有多少？这些列中的数据密度可能是一个问题。
“关键词”实际上有 99%的密度，但“位置”只有 67%的密度。我们会放弃它，因为它丢失了太多的数据。我们也将删除“关键字”,但原因不同。“关键字”是重复的，因为它只包含“文本”中的一个词。“keyword”将提供零洞察力来发现灾难性推文和非灾难性推文之间的区别，这两种推文都具有关键字“finding”。我们将删除这两列，只将“文本”作为独立变量。“文本”具有 100%的密度。
关于文本数据的探索性数据分析，我推荐这篇文章。
预处理
我们的预处理方法包括两个阶段:准备和矢量化。准备阶段包括清理数据和剔除多余内容的步骤。步骤是 1。删除 URL 和 Twitter 句柄，2。将所有文本变为小写，请按 3。删除号码，请按 4。删除标点，请按 5。标记化，6。删除停用字词，和 7。词汇化。停用词是通常不添加任何意义的词。例如，查看 NLTK 停用词的列表。
标记化步骤获取一个文本字符串，并将其转换成一个标记列表(单词)。它通过解析字符串和用空格分隔来实现这一点。这意味着’ hello world '变成了[‘hello ‘，’ world’]。在准备步骤之后执行此步骤非常重要，因为标记化会将标点符号作为单独的标记。
引理化步骤获取记号，并将每个记号分解成它的引理。一个引理本质上是一个词的基本形式，切断了变位和变位的途径。例如，“不同”会变成“不同”，“奔跑”会变成“奔跑”，“卡车”会变成“卡车”。词汇化甚至可以将“was”变成“be ”,因为 nltk 词汇化器利用了词汇表，而不是仅仅依赖于算法。
下面是准备步骤的代码。remove_urls()使用了我在 StackOverflow 上发现的一个棘手的正则表达式操作。其他函数都是不言自明的。
现在让我们将“text”列通过这个预处理管道。我们不必担心 NaNs，因为我们之前看到“text”列具有 100%的密度。
您可能已经注意到，预处理()函数有一个额外的行，它重新加入了标记列表。我们实际上更喜欢符号列表，但是我们的矢量器不接受符号列表作为输入，只接受字符串。
我们的数据现在看起来像这样:
在我们将训练数据放入矢量器之前，我们还需要准备测试数据。为了分别转换训练和测试数据，矢量器必须适合整个文本语料库(包括训练和测试数据集)。
对测试数据做同样的预处理。
现在，我们将训练和测试“pp_text”列合并到我们的文本语料库中。
现在我们已经为矢量化做好了准备。我们使用方便的 scikit-learn 工具 TfidfVectorizer。
该向量机已被应用于语料库。现在我们转换训练和测试数据。在本文中，我们将只使用 train_transform 数据。当我们在看不见的数据上测试我们的模型时，将使用 test_transform 数据。
我们现在有两个变量准备回归。y 列仍然是之前的“目标”列，通知我们这条推文是否是真正的灾难推文。x 列现在看起来像这样:
刚刚发生了什么？到目前为止，我们的所有步骤都有助于准备数据，但没有彻底改变它。现在我们的数据甚至无法识别。
根据 scikit-learn 的网站介绍， TfidfVectorizer 实际上是 CountVectorizer 后跟 TfidfTransformer 。CountVectorizer 首先获取我们的文本文档，并对它们进行标记，就像我们之前所做的那样(但是后来没有这样做，因为这个函数不接受标记化的数据作为输入)。一旦数据被标记化，CountVectorizer 就会收集一个由每个唯一标记组成的单词包，并为每个单词分配一个数字。最后，CountVectorizer 将标记化的文本数据表示为标记计数矩阵，如下所示:
此图像显示了 CountVectorizer 矩阵的前六行。这些行告诉我们，在文档 0 中，单词 368、3403、4146、5201、8491 和 11223 都出现了一次。我们对这些计数感兴趣，因为如果一个单词在一个文档中出现多次，这个单词可能非常重要。
TfidfTransformer 只是将这个令牌计数矩阵转换成一个词频-逆文档频率(tf-idf)表示。使用 tf-idf 很重要，因为简单地使用令牌计数可能会产生误导。以前，我们假设如果一个单词在一个文档中出现多次，那么它就是重要的。如果这个词在整个语料库中非常常见呢？那么它在我们当前文档中的高频率就不那么重要了，因为这个词在其他地方出现得如此频繁。
Tf-idf 通过将频率(基本上是计数)乘以逆文档频率(1/文档频率)来达到平衡。这意味着，如果单词 1 在文档 A 中出现一次，但在整个语料库中也出现一次，而单词 2 在文档 A 中出现四次，但在整个语料库中出现 16 次，则单词 1 将具有 1.0 的 tf-idf 分数，而单词 2 将仅获得 0.25 的分数。单词 2 在文档 A 中的重要性被其在语料库中的高频率所冲淡。(这是对实际 tf-idf 方程的简化解释，比较复杂。)
因此，我们得到了文档 0 的这种表示:
注意，在 CountVectorizer 表示中，文档 1 中的所有标记只出现了一次。现在，在 tf-idf 表示中，一些令牌比其他令牌具有更高的分数。Tf-idf 为我们的数据增加了一层细微差别。
我们的数据没有经过预处理，我们已经准备好进入建模阶段。
型号
现在是将我们的数据分成训练集和验证集的好时机。
现在，我们可以使用 scikit-learn 训练我们的模型，即逻辑回归。
结果
我们的模型已经被训练好了。现在让我们得到它对验证集的预测。
在我们的验证集上测试模型的结果呢？
这个结果明显好于抛硬币，这是一个好迹象。为了真正了解我们的模型是否表现良好，我们必须将其与 Kaggle 排行榜上其他人的表现进行比较。
我们在现实中表现如何？我使用本文中描述的模型对 Kaggle 给出的测试数据进行预测，然后将这些预测提交给 Kaggle。结果呢？准确度分数为 0.80572，略好于我们的验证集结果。这使我们在 3341 个提交的作品中排名第 1266 位(尽管前 428 个提交的作品都有超过 0.99 的分数——高得可疑)。干得好。
结论
预处理文本数据是一个漫长的过程，但实际上非常简单。尽管不同文本数据科学任务的预处理可能有所不同，但当您下次必须进行文本预处理时，了解一个文本预处理示例会非常有帮助。我希望这篇使用 Python 进行文本预处理的指南对您有所帮助。
如果您想要最终完成 Kaggle 提交，剩下的唯一步骤是使用我们训练的模型来预测 test_transform 数据，格式化和导出这些结果，并将它们提交给 Kaggle。这些步骤显示在我这篇文章的要点这里。
资源
预处理的有用资源:
下一步:更快发布列表交叉向上:确定以前的词汇:其他语言。的目录索引
nlp.stanford.edu](https://nlp.stanford.edu/IR-book/html/htmledition/stemming-and-lemmatization-1.html) [## sk learn . feature _ extraction . text . tfidf vectorizer-sci kit-learn 0 . 22 . 2 文档
class sk learn . feature _ extraction . text . tfidf vectorizer(input = ’ content '，encoding='utf-8 '，decode _ error = ’ strict '……
scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.TfidfVectorizer.html) [## sk learn . feature _ extraction . text . count vectorizer-sci kit-learn 0 . 22 . 2 文档
class sk learn . feature _ extraction . text . count vectorizer(input = ’ content '，encoding='utf-8 '，decode_error=‘strict’…
scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.CountVectorizer.html#sklearn.feature_extraction.text.CountVectorizer) [## sk learn . feature _ extraction . text . tfidftransformer-sci kit-learn 0 . 22 . 2 文档
将计数矩阵转换为归一化的 tf 或 tf-idf 表示，tf 表示词频，而 tf-idf 表示…
scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.TfidfTransformer.html#sklearn.feature_extraction.text.TfidfTransformer)
延伸阅读:
让我们更好地理解我们新清理的数据集
medium.com](https://medium.com/@kamilmysiak/nlp-part-3-exploratory-data-analysis-of-text-data-1caa8ab3f79d) [## sklearn.linear_model。逻辑回归-sci kit-学习 0.22.2 文档
逻辑回归(又名 logit，MaxEnt)分类器。在多类的情况下，训练算法使用一对其余…
scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html)
在 Python 中预处理文本
建立情感分类器的一步
这篇文章是关于建立情感分类器的三篇连续文章中的第二篇。在第一篇文章的中我们进行了探索性的文本分析之后，是时候对我们的文本数据进行预处理了。简单地说，预处理文本数据就是做一系列的操作，将文本转换成表格形式的数值数据。在本帖中，我们将探讨三种不同复杂度的方法来预处理文本到 tf-idf 矩阵，为模型做准备。如果你不确定什么是 tf-idf，这篇文章用一个简单的例子来解释。
照片由 Domenico Loia 在 Unsplash 上拍摄
在我们开始之前，让我们后退一步，快速地看一下更大的画面。 CRISP-DM 方法概述了成功的数据科学项目的流程。数据预处理是数据准备阶段的关键任务之一。
CRISP-DM 工艺流程摘录
0.Python 设置
这篇文章假设读者(👀是的，你！)可以访问并熟悉 Python，包括安装包、定义函数和其他基本任务。如果你是 Python 的新手，这个是一个很好的起点。
我在 Jupyter 笔记本里测试过 Python 3.7.1 的脚本。
让我们在开始之前确保您已经安装了以下库:
◼️ 数据操作/分析: numpy，pandas ◼️ 数据分区:sk learn ◼️文本预处理/分析: nltk ◼️ 拼写检查器: 拼写检查器(pyspellchecker 安装时
一旦你安装了 nltk ，请确保你已经从 nltk 下载了*【停用词】和【wordnet】*语料库，脚本如下:
import nltk
nltk.download('stopwords')
nltk.download('wordnet')
如果你已经下载了，运行这个会通知你。
现在，我们准备导入所有的包:
# Setting random seed
seed = 123# Measuring run time
from time import time# Data manipulation/analysis
import numpy as np
import pandas as pd# Data partitioning
from sklearn.model_selection import train_test_split# Text preprocessing/analysis
import re, random
from nltk import word_tokenize, sent_tokenize, pos_tag
from nltk.util import ngrams
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from nltk.tokenize import RegexpTokenizer
from sklearn.feature_extraction.text import TfidfVectorizer
from spellchecker import SpellChecker
1.数据📦
我们将使用 IMDB 电影评论数据集。您可以在这里下载数据集，并将其保存在您的工作目录中。保存后，让我们将其导入 Python:
sample = pd.read_csv('IMDB Dataset.csv')
print(f"{sample.shape[0]} rows and {sample.shape[1]} columns")
sample.head()
让我们来看看情绪之间的分歧:
sample['sentiment'].value_counts()
在样本数据中，情感是平均分配的。我们先把数据分成两组:训练和测试。我们将留出 5000 箱进行测试:
# Split data into train & test
X_train, X_test, y_train, y_test = train_test_split(sample['review'], sample['sentiment'], test_size=5000, random_state=seed,
stratify=sample['sentiment'])# Append sentiment back using indices
train = pd.concat([X_train, y_train], axis=1)
test = pd.concat([X_test, y_test], axis=1)# Check dimensions
print(f"Train: {train.shape[0]} rows and {train.shape[1]} columns")
print(f"{train['sentiment'].value_counts()}\n")print(f"Test: {test.shape[0]} rows and {test.shape[1]} columns")
print(test['sentiment'].value_counts())
在这篇文章中，我们将使用序列进行预处理实验。只有当我们需要评估最终模型时，我们才会预处理测试。让我们检查一下训练数据集的头部:
train.head()
好了，我们开始预处理吧！✨
2.预处理文本
根据我们的处理方式，我们可以得到不同的 tf-idf 矩阵。在构建模型时，尝试不同的预处理方法是很好的。我们将研究以下 3 种方法:
- 更简单的方法
- 简单方法
- 不太简单的方法
虽然在这篇文章中我们只讨论了将文本预处理成 tf-idf 矩阵，但是您可能还想探索其他的方法。
对于每一种方法，我们一定会衡量运行时性能，因为这是一个重要的考虑因素，特别是如果模型将被生产。我们将在下一篇文章中测试哪种方法更适合这个模型。在我们开始之前，为了使事情变得简单，让我们定义一个函数来帮助我们检查不同的方法:
def inspect(vectoriser, X):
# Fit and transform
start = time()
print(f"There are {vectoriser.fit_transform(X).shape[1]} columns.\n")
end = time()
print(f"Took {round((end-start),2)} seconds.\n")
# Inspect tokens
tokens = list(vectoriser.vocabulary_.keys())
tokens.sort()
print(f"Example tokens: {tokens[:50]}\n")
# Inspect ignored tokens
ignored = vectoriser.stop_words_
if len(ignored)==0:
print("No token is ignored.")
elif len(ignored)>50:
print(f"Example ignored tokens: {random.sample(ignored, 50)}")
else:
print(f"Example ignored tokens: {ignored}")
2.1.更简单的方法 1️⃣
让我们从三个中最简单的开始。在这种方法中，我们将让 sklearn 的 TfidfVectorizer 做所有的预处理，而不使用任何额外的定制函数。让我们使用默认参数来感受一下我们将获得多少列:
vectoriser = TfidfVectorizer()
inspect(vectoriser, X_train)
相当快。输出超过 97，000 列，前 50 个标记大部分是数字。现在，让我们调整一些参数来进一步清理标记，并更好地控制预处理:
# Simpler approach
vectoriser = TfidfVectorizer(token_pattern=r'[a-z]+', stop_words='english', min_df=30, max_df=.7)
inspect(vectoriser, X_train)
虽然上述两个版本花费的时间差不多，但后者的列数要少 7-8 倍。在这里，我们要求 TfidfVectorizer 做一些事情:
◼ token_pattern=r'[a-z]+':标记成字母标记——这意味着我们丢弃数字和标点符号。如果您不熟悉正则表达式 , [a-z]+意味着令牌必须只由字母组成。
◼ stop_words='english’:去掉停止字。
◼ min_df=30:移除稀有令牌。当一个令牌出现在少于 30 条评论中时，我们认为它是稀有的。这将大大减少令牌的数量。尝试在没有该参数的情况下运行脚本，并查看令牌的数量。
◼ max_df=.7:删除超过 70%文档中的令牌。这意味着如果一个令牌包含在超过 31.5K 个评论中，那么我们将忽略它们。实际上并没有很多单词因为这个而被排除在外。因此，我们甚至可以保留这个特性的默认值。
max_df和min_df有助于令牌选择。换句话说，在这两者的帮助下，我们可以丢弃那些或者太频繁可能对情感分类没有用处或者太罕见可能导致过度拟合的令牌。
**📍这里有一个提示:**如果我们这样定义参数:
TfidfVectorizer(token_pattern=r'[a-z]+', max_df=.5)
在匹配矢量器之后，您可以通过运行vectoriser.stop_words_来找出哪些令牌由于max_df=.5条件而被排除。当我们调用inspect函数时，输出的’*示例被忽略的标记’*部分显示了那些被排除的单词的片段。现在，我鼓励你运行上面的脚本并检查vectoriser.stop_words_。你看到了什么？你看到的大多是停用词吗？尝试将这些值更改为. 5、. 6、. 8 或. 9，然后重新运行以观察被排除的单词如何变化。这有助于理解调整某些参数如何影响预处理。现在，如果你热衷于添加stop_words='english’或min_df=30(不要同时添加两个，一次添加一个以了解单个参数)，并检查这次排除了哪些令牌。我们将在下一篇文章中构建模型时进一步调整这些参数。
🔗如果您热衷于了解更多关于参数的信息，这里有 文档 。
这种方法是一种🍰，是不是？我喜欢这种方法，尤其是因为它做一些基本的事情真的又好又快。在我看来，从简单开始总是好的，只有在提高性能的情况下才增加复杂性。
2.2.简单方法 2️⃣
总有改进的余地。例如，在以前的方法中，单词“播放”、“播放”、“正在播放”和“已播放”被认为是 4 种不同的标记。如果我们去掉这些屈折变化的词尾，使这些符号正常化为一个唯一的符号“play”，这不是很好吗？这就是我们在这部分要做的事情！
为了使屈折词尾正常化，我们将使用一种叫做引理满足的技术。另一种选择是词干。如果你想了解这两者的区别，我在这里简单解释了一下区别。
词条释义有助于将单词转换成词典形式。以我们之前的例子为例，让我们将它们进行比较，看看输出是什么样的:
lemmatiser = WordNetLemmatizer()
for word in ['play', 'plays', 'playing', 'played']:
print(lemmatiser.lemmatize(word, 'v'))
酷，所有的单词现在都转换成‘玩’了。注意我们如何在lemmatize方法中传递 v 作为第二个参数？‘v’是一个词性标签。事实上，准确的词汇匹配依赖于我们随单词一起提供给词汇匹配器的词性(POS)标签。为了演示这一点，让我们重新运行前面的脚本，做一点小小的改动，将“v”变成“n”:
lemmatiser = WordNetLemmatizer()
for word in ['plays', 'playing', 'played']:
print(lemmatiser.lemmatize(word, 'n'))
这一次，并不是所有的词都转换成了玩。这个简单的例子展示了词性标签如何影响引理满足的有效性。那么到底什么是词性标签呢？简单地说，它指的是这个词的语法范畴。单词“movie”是一个名词，而“watch”根据上下文可以是动词也可以是名词。名词和动词都是词类的例子。在第一次运行中，我们告诉 lemmatiser 提供的单词是动词(因此是‘v’)，在第二次运行中是名词(因此是‘n’)。使用 nltk 的 词性标注器: pos_tag()，我们可以用词性来标注每个单词。
我们将很快创建一个自定义函数，根据标签进行词性标注和词汇匹配。我们将这个函数传递给TdidfVectoriser() *的analyzer参数。*当我们这样做时，以前使用的一些参数如token_pattern, stop_words将不再受支持。因此，我们还必须在自定义函数中包含一个标记化步骤:
def preprocess_text(text):
# 1\. Tokenise to alphabetic tokens
tokeniser = RegexpTokenizer(r'[A-Za-z]+')
tokens = tokeniser.tokenize(text)
# 2\. POS tagging
pos_map = {'J': 'a', 'N': 'n', 'R': 'r', 'V': 'v'}
pos_tags = pos_tag(tokens)
# 3\. Lowercase and lemmatise
lemmatiser = WordNetLemmatizer()
tokens = [lemmatiser.lemmatize(t.lower(), pos=pos_map.get(p[0], 'v')) for t, p in pos_tags]return tokens
这里需要注意的一点是，pos_tag()和lemmatiser.lemmatize()对词性标签使用不同的命名约定，所以我们必须将由 nltk 标签器生成的词性映射到 lemmatiser 能够理解的名称。这就是我们有pos_map的原因。现在，让我们预处理数据并评估:
vectoriser = TfidfVectorizer(analyzer=preprocess_text, min_df=30, max_df=.7)
inspect(vectoriser, X_train)
它将列数减少到 10，754。与更简单的方法中的 12，805 列相比，列数减少了约 16%。在我的电脑上花了大约 11 分钟，比这慢了 85 倍。如果我们仔细想想，词条满足不会改变评论中的每一个词。就拿“这部电影太棒了”来说吧。句子为例。唯一受益于引理满足的词是“was”。所以记住这一点，如果你需要更快地完成词条满足，有时对所有单词使用默认的词性是很好的。在这种情况下，我们的自定义函数简化为:
# Simple approach
def preprocess_text(text):
# 1\. Tokenise to alphabetic tokens
tokeniser = RegexpTokenizer(r'[A-Za-z]+')
tokens = tokeniser.tokenize(text)
# 2\. Lowercase and lemmatise
lemmatiser = WordNetLemmatizer()
tokens = [lemmatiser.lemmatize(t.lower(), pos='v') for t in tokens]return tokensvectoriser = TfidfVectorizer(analyzer=preprocess_text, min_df=30, max_df=.7)
inspect(vectoriser, X_train)
列数与我们使用的词性标注器非常接近，但只花了大约一分钟。因此，在这两个版本之间，我更喜欢对这个文本数据集使用默认的词性标签。值得注意的是，如果我们不给pos参数提供值，lemmatiser 默认为‘n’。一般来说，我通常喜欢使用’ v '作为默认，因为我发现它在一般情况下规范化更多的单词。但是，更合适的默认pos将取决于数据。
2.3.不那么简单的方法 3️⃣
在这种方法中，我们将进一步清理数据。基于从探索性数据分析中获得的知识和一般预处理思想，我们将做以下工作:
◼纠正错别字:【chr acter】到【character】
◼将英式拼法转换为美式拼法:【realize】到【realize】
◼去掉停用词
def convert_to_american(token):
# Copied from [here](https://scikit-learn.org/stable/modules/feature_extraction.html)
token = re.sub(r"(...)our$", r"\1or", token)
token = re.sub(r"([bt])re$", r"\1er", token)
token = re.sub(r"([iy])s(e$|ing|ation)", r"\1z\2", token)
token = re.sub(r"ogue$", "og", token)
return tokendef correct_typo(tokens):
spell = SpellChecker()
return [spell.correction(t) if len(spell.unknown([t]))>0 else t for t in tokens]
def preprocess_text(text):
# 1\. Tokenise to alphabetic tokens
tokeniser = RegexpTokenizer(r'[A-Za-z]+')
tokens = tokeniser.tokenize(text)
# 2\. Lowercase and lemmatise
lemmatiser = WordNetLemmatizer()
tokens = [lemmatiser.lemmatize(t.lower(), pos='v') for t in tokens]# 3\. Correct spelling (this won't convert 100% )
tokens = correct_typo(tokens)
# 4\. Convert British spelling to American spelling (this won't convert 100%)
tokens = [convert_to_american(t) for t in tokens]# 5\. Remove stopwords
stop_words = stopwords.words('english')
stop_words.extend(['cannot', 'could', 'done', 'let', 'may' 'mayn', 'might', 'must', 'need', 'ought', 'oughtn',
'shall', 'would', 'br'])
tokens = [t for t in tokens if t not in stop_words]
return tokens
除了这些，我们可以继续添加其他层来纠正和清理。但是，每个额外的步骤都会增加复杂性和运行时间，而不能保证模型性能的提高。在预处理文本时，通常可以尝试以下一些方法，这些方法在我们的例子中不是特别有用，但在其他例子中可能有用:
◼清理垃圾，如 html 标签、电子邮件地址、网址
◼将数字转换成文字，而不是丢弃它们
◼将表情符号或表情符号转换成文字
好了，让我们预处理并检查输出:
vectoriser = TfidfVectorizer(analyzer=preprocess_text, min_df=30, max_df=.7)
inspect(vectoriser, X_train)
在我开始运行这段代码的几个小时后，它仍然在运行。因为我认为它花费的时间太长，所以我不得不中断内核来停止查询。为了了解这种方法比前两种方法慢多少，我使用下面的脚本将数据集的大小减少到其大小的 1/9:
train = train.sample(5000, random_state=seed)
我在这个更小的数据子集上运行了所有三种方法。下面是三种方法的比较:
不太简单的方法比其他两种方法更标准化代币，但成本非常高。与其他方法相比，预处理至少要花费 1000 倍的时间。当数据集增长时，这个比率可能会变得更糟。因此，进一步追求不那么简单的方法是不实际的，除非它被优化为运行更快。
👂如果你有一台比我更好的计算机，这个运行时间问题可能不一定会成为你的一个限制，在这种情况下，你可以自由地继续追求。
您想访问更多这样的内容吗？媒体会员可以无限制地访问媒体上的任何文章。如果您使用 我的推荐链接成为会员，您的一部分会费将直接用于支持我。
谢谢你看我的帖子。希望您已经学会了一些不同的预处理文本的实用方法，可以应用到您的下一个 NLP 项目中。在下一篇文章中，我们将构建一个情感分类器。以下是该系列另外两篇文章的链接:◼️python 中的探索性文本分析
◼️python 中的情感分类
以下是我的其他 NLP 相关帖子的链接:
◼️Python 中的简单 word cloud
(下面列出了一系列关于 NLP 介绍的帖子)
◼️ 第一部分:Python 中的预处理文本
◼️ 第二部分:词条满足和词干的区别
◼️ 第三部分:TF-IDF 解释
◼️ 第四部分:python 中的监督文本分类模型
再见🏃💨
为机器学习(图像识别)预处理图像
照片由 Jye B 在 Unsplash 上拍摄—【https://unsplash.com/photos/RuTMP0iI_ek
我在 JKU 学习期间，有一个为机器学习项目预处理图像的任务。在学习算法中使用原始图像之前，有必要对其进行清理，因此我们创建了一个预处理函数。我认为这对其他人也很有用，所以我想分享一点我的方法。该文件是以一种易于理解的方式构建的，并且应该具有类似教程的效果。
目录
预处理错误
在为机器学习任务处理图像时，经常会遇到一些错误。这些是:
- 正确的文件扩展名，代表图像文件(如 jpg)
- 特定的文件大小
- 该文件可以作为图像读取(取决于用于进一步处理的库)
- 图像数据具有可用信息(不止一个值)
- 图像有一定的宽度和高度
- 没有重复的图像
加工文件
该函数有 3 个参数:
- 包含图像文件的输入目录
- 输出目录，有效图像将被复制到该目录
- 包含错误的日志文件
我的解决方案递归搜索允许的图像文件。这是通过get_files功能完成的。
check_files函数获取文件并返回带有相应错误代码的图像列表。
validate_file函数检查图像中的各种常见错误，并返回错误编号。如果没有发生错误，错误代码将为 0。
separate_files功能将区分有效图像和无效图像。
copy_valid_files功能会将有效文件复制到定义的“输出目录”文件夹中。
函数在指定的日志文件路径中创建一个日志文件，包含所有有错误的文件。
整个pre_processing函数最终返回有效文件的数量。
Python 代码
python 文件可以在我的数据科学收藏库中找到:https://github.com/Createdd/DataScienceCollection
在这里，您可以通过 Github Gist 检查代码:
关于
丹尼尔是一名企业家、软件开发人员和律师。他的知识和兴趣围绕商业法和编程机器学习应用发展。从本质上说，他认为自己是复杂环境的问题解决者，这在他的各种项目中都有所体现。如果你有想法、项目或问题，不要犹豫，立即联系我们。
连接到:
呈现随机森林分类器的特征重要性
机器学习
如何建立一个随机森林分类器，提取特征重要性，并漂亮地呈现出来。
Sebastian Unrau 在 Unsplash 上的照片
W 当报告我的机器学习模型的结果时，我总是试图呈现出比*更多的东西“我达到了高达 91%的准确率。”*因为这一句话无法体现我在建模过程中所做的这么多工作。
尽管有监督的机器学习模型旨在获得尽可能高的准确性，但您总是可以展示一些副产品，以使您的结果对应用领域有所启发。展示特性的重要性是一个好主意。
在这篇文章中，我将以 随机森林分类器 为例，展示如何生成，提取，呈现特征重要性。
数据的收集、清理、和拆分同样重要，但与这里的主题没有那么大的关联，所以有兴趣的可以在这里参考我以前的一篇文章:
[## 使用三种机器学习模型基于勒布朗数据的端到端游戏预测方案
综合指导一个二元分类问题使用三个不同的分类器，包括逻辑…
towardsdatascience.com](/end-to-end-project-of-game-prediction-based-on-lebrons-stats-using-three-machine-learning-models-38c20f49af5f)
建一条管道。
塞缪尔·西亚尼帕尔在 Unsplash 上拍摄的照片
首先，导入我们需要的所有模块如下:
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.model_selection import StratifiedKFold
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
import plotly.express as px
第二，建立超参数训练功能。
def train_hyper_tune(X,y):
# create the pre-processing component
my_scaler = StandardScaler()
my_imputer = SimpleImputer(strategy="median")
# define classifiers
## Classifier : Random Forest Classifier
clf_RF = RandomForestClassifier(random_state=0)
# define pipeline
## clf_RF
pipe = Pipeline([('imputer', my_imputer), ('scaler', my_scaler), ('rf_model',clf_RF)])
# create hyperparameter space
## clf_RF
param_grid = {
'rf_model__n_estimators' : [50,100],
'rf_model__max_features' : [0.8,"auto"],
'rf_model__max_depth' : [4,5]
}
# set GridSearch via 5-fold cross-validation
## clf_RF
grid = GridSearchCV(pipe2, cv=5, param_grid=param_grid)
# run the hyperparameter tunning
grid.fit(X,y)
# return results of the tunning process
return grid,pipe
在上面的函数中，我使用 sklearn 中强大的 管道模块对数据进行预处理，并在管道中建模。函数GridSearchCV用于在定义为 param_grid 的超参数空间中寻找最佳超参数。
训练模型。
布鲁斯·马斯在 Unsplash 上的照片
通过执行如下超参数训练过程:
my_grid,my_pipe= train_hyper_tune(X_train, y_train)
网格搜索的每次迭代的结果都存储在 my_grid 中。
然后，我将最佳超参数传递给我的训练函数，如下所示:
def train_on_entire(X,y,pipe,grid_res):
# fit pipeline
pipe.set_params(**grid_res.best_params_).fit(X, y)
# return the newly trained pipeline
return pipemy_entire_pipe = train_on_entire(X_train,y_train,my_pipe,my_grid)
完成了。 my_entire_pipe 是我最终训练好的模型。
我可以在 从未接触过的 测试数据集上检查我的最终模型的性能。
my_entire_pipe.score(X_test, y_test)
这给了我高达 0.901 的精度！
提取特征重要性。
威尔·斯图尔特在 Unsplash 上拍摄的照片
我之所以说 sklearn 中的 管道模块强大，是因为它可以让你追溯到你管道中每一个经过训练的组件。
提取被训练管道的部件(裕丰)
随机森林分类器的特征重要性保存在模型本身中，所以我需要做的就是提取它并将其与原始特征名称相结合。
d = {'Stats':X.columns,'FI':my_entire_pipe[2].feature_importances_}
df = pd.DataFrame(d)
要素重要性数据框如下所示:
特征重要性(裕丰)
到目前为止，我已经有了做以下可视化所需的一切。
在统计图中展示特征的重要性。
实际上，有很多方法可以呈现特性的重要性，比如柱状图，或者箱线图，如果你已经为一个健壮的度量做了 N 次建模的话。
我本人对 花花公子排行榜 情有独钟，原因可以在我之前的一篇帖子中找到，如下:
我的真实故事。生成统计图的命令行花费了一个博客作者 200 美元。
medium.com](https://medium.com/@jianan.jay.lin/is-one-line-of-command-worth-200-dollars-6f43884aa21f)
在制作图之前，我只是将特征重要性按升序排序。
df = df.sort_values(by='FI', ascending=0)
然后，生成如下的统计图:
fig = px.bar_polar(df, r="FI", theta="Stats",
color="Stats", template="plotly_dark",
color_discrete_sequence= px.colors.sequential.Plasma_r)
fig.show()
鸡冠图 1 由俞峰
哎呦！为什么看起来这么丑？
在再次检查特征重要性数据框后，我发现名为“ +/- ”(代表篮球中的加/减，估计一个篮球运动员对球队的贡献)的特征已经主导了特征空间。
这个结果表明这个特征对我们的预测模型是最重要的。既然我建立的模型是基于 勒布朗詹姆斯的 统计来预测比赛结果，那么用 +/- 来评估他的表现比其他基础统计更有预测力也是合理的。
然而，我们总是可以通过放大图形来检查所有其他特征的重要性。
df_drop = df[df.Stats != '+/-']
fig = px.bar_polar(df_drop, r="FI", theta="Stats",
color="Stats", template="plotly_dark",
color_discrete_sequence= px.colors.sequential.Plasma_r)
fig.show()
鸡冠图二由俞峰
现在我们看到几个其他的特性出现在前面，比如比赛分数( GmSC ) ，以及投篮命中率(【FG %】)。
我也很惊讶，这个名为***【G】***的特性，排名竟然比很多我认为应该重要的其他特性都要靠前，比如辅助( AST )。
***【G】***实际上是一个赛季的比赛指数， 1 表示一个赛季的第一场比赛， 82 表示一个赛季的最后一场比赛。这个特征表现出重要性的事实表明 勒布朗詹姆斯 可以沿着整个赛季的进程调整自己对比赛的影响。
就是这样。随机森林分类器中特征重要性的表示。
如果你喜欢读这篇文章，请关注我的 中型 以下是我的一些其他帖子:
从弹性网开始，记得调好定义 l1 范数之比的超参数。
towardsdatascience.com](/a-practical-suggestion-in-linear-regression-cb639fd5ccdb) [## NBA 球员统计数据 R 包“ggplot2”中数据可视化的实践指导
应用于 NBA 数据的 R 数据可视化工具“ggplot2”的 6 分钟之旅。
towardsdatascience.com](/hands-on-guidance-of-data-visualization-in-r-package-ggplot2-of-nba-players-stats-d812ed272d66) 
在《星球大战》宇宙中呈现 Neo4j 图形数据科学的多节点标签支持和图形可变性特征
浏览 Neo4j 图形数据科学库中的算法执行和图形可变性功能的节点过滤器，并使用星球大战网络
文章于 2022 年 4 月 30 日更新，以遵循新的 GDS 2.0 语法
我决定暂时停止观看我强烈推荐的鲍勃·罗斯的绘画之乐，并检查 Neo4j 图形数据科学 2.0 版中的一些新语法。
对我来说，一个非常酷的 GDS 功能是在执行图形算法时能够通过标签过滤节点。类似于关系，我们可以用 relationshipTypes 参数选择哪些应该被图算法考虑，我们可以用新的 nodeLabels 参数过滤哪些节点应该被使用。我们还将看看投影图的可变性特性。
我喜欢寻找新的社交网络，以免我的博客文章变得无聊和重复。在这里，我们将深入研究星球大战世界。由于 Evelina Gabasova 的帮助，人物之间的互动在 GitHub 上可用。我们将把它与 Florent Georges 提供的数据集结合起来，Florent Georges 抓取了星球大战 API 并添加了来自维基百科的描述。
图表模式和导入
星球大战图表模式
我们的图表由与其他角色有交互关系的角色组成。 X 的值指示交互发生在哪一集，例如交互 1 指示第一集的交互。每个角色也属于一个物种，该物种被表示为与物种节点的关系。
我们将从导入交互社交网络开始。数据集有点棘手，因为角色在每集中都没有唯一的 id。相反，在每一集中，一个新的 id 被确定为 JSON 文件的“nodes”元素中的字符的从零开始的索引。为了缓解这个问题，我们使用apoc.cypher.runMany过程为每一集运行两个事务。首先，我们存储节点，并根据从零开始的索引为它们赋值。在第二个事务中，我们使用该值存储字符之间的链接。每集都重复这一过程。
UNWIND range(1,7) as episode
CALL apoc.load.json('https://raw.githubusercontent.com/evelinag/StarWars-social-network/master/networks/starwars-episode-' + toString(episode) + '-interactions.json')
YIELD value as data
CALL apoc.cypher.runMany("
WITH $data.nodes as nodes
UNWIND range(0,size(nodes)-1) as value
MERGE (c:Character{id:nodes[value].name})
SET c.value = value RETURN distinct 'done'
;
WITH $data as data, $episode as episode
UNWIND data.links as link
MERGE (source:Character{value:link.source})
MERGE (target:Character{value:link.target})
WITH source, target, link.value as weight, episode
CALL apoc.create.relationship(source,'INTERACTS' + episode, {weight:weight}, target) YIELD rel
RETURN distinct 'done'", {data:data, episode:episode},{statistics:true,timeout:10})
YIELD result RETURN result
我们将继续用该物种的信息丰富我们的图表。不幸的是，两个数据集之间的字符名称并不完全匹配。我们可以使用几种方法来找到与角色名字最接近的匹配。APOC 图书馆有一整块区域致力于文本相似程序。我决定使用全文搜索索引来匹配角色的名字。我们首先在字符的 id 属性上定义全文搜索索引。
CALL db.index.fulltext.createNodeIndex(
"names",["Character"],["id"])
每个全文搜索查询可能会返回多个结果，但是我们将只查看顶部的结果。如果顶部结果的分数高于任意阈值，在我们的例子中是 0.85，我们将假设它是相同的字符。我们可以看一些例子:
CALL apoc.load.json('https://raw.githubusercontent.com/fgeorges/star-wars-dataset/master/data/enriched.json') YIELD value UNWIND value.people as person
CALL db.index.fulltext.queryNodes("names",
replace(person.name,'é','e'))
YIELD node,score
RETURN person.name as species_dataset_name,
collect(node)[0].id as interactions_dataset_name
LIMIT 5
结果
或多或少，物种数据集包含全名，而交互数据集只包含角色的名。因为全文搜索匹配看起来很好，所以让我们继续将附加信息存储到图中。
CALL apoc.load.json('https://raw.githubusercontent.com/fgeorges/star-wars-dataset/master/data/enriched.json')
YIELD value
UNWIND value.people as person
// search for characters
CALL db.index.fulltext.queryNodes("names",
replace(person.name,'é','e'))
YIELD node,score
// collect the top hit
WITH person, collect([node,score])[0] as top_hit
WITH person, top_hit[0] as node, top_hit[1] as score
// threshold
WHERE score > 0.85
// enrich characters
SET node += apoc.map.clean(person,
['films','vehicles','starships','species'],['n/a'])
WITH node, person.species as person_species
UNWIND person_species as species
MERGE (s:Species{id:species})
MERGE (node)-[:BELONG_TO]->(s)
我们还将导入关于该物种的额外元数据。
CALL apoc.load.json('https://raw.githubusercontent.com/fgeorges/star-wars-dataset/master/data/enriched.json')
YIELD value
UNWIND value.species as species
MATCH (s:Species{id:species.url})
SET s += apoc.map.clean(species,
['films','homeworld','people','url'],['n/a','unknown'])
不幸的是，我们还没有给我们所有的角色分配物种。一些字符出现在第一个数据集中，而没有出现在第二个数据集中。由于这篇博文的重点不是展示如何有效地搜索互联网，所以我准备了一个 CSV 文件，我们可以用它来指定缺失物种的值。
LOAD CSV WITH HEADERS FROM
"https://raw.githubusercontent.com/tomasonjo/blogs/master/Star_Wars/star_wars_species.csv" as row
MATCH (c:Character{id:row.name})
MERGE (s:Species{name:row.species})
MERGE (c)-[:BELONG_TO]->(s)
有些物种只有一两个成员，所以我决定把它们归为“其他”物种。这样，我们将使我们进一步的图形分析更加相关。
MATCH (s:Species)
WHERE size((s)<-[:BELONG_TO]-()) <= 2
MERGE (unknown:Species{name:'Other'})
WITH s, unknown
MATCH (s)<-[:BELONG_TO]-(character)
MERGE (unknown)<-[:BELONG_TO]-(character)
DETACH DELETE s
多节点标签支持
我们现在可以看看多节点标签投影，以及它如何允许我们在执行图形算法时过滤节点。因为我们将使用原生投影，我们必须根据他们的种族给角色分配二级标签。我们将使用apoc.create.addLabels程序来分配二级标签。
MATCH (c:Character)-[:BELONG_TO]->(species)
CALL apoc.create.addLabels([id(c)], [species.name]) YIELD node
RETURN distinct 'done'
如果你对 GDS 图表目录的概念不熟悉，你可能想看看我以前的博客帖子。我们将使用 array 选项来描述我们想要投影的节点标签。属于所有五个物种的节点将被投影。交互网络中的所有关系也将被投影并被视为无向和加权的。由于给定的一对节点之间可能有不止一个关系，我们投影一个多重图。
CALL gds.graph.project('starwars',
['Other','Human','Droid','Neimodian','Gungan'],
{INTERACTS1:{type:'INTERACTS1', orientation:'UNDIRECTED', properties:['weight']},
INTERACTS2:{type:'INTERACTS2', orientation:'UNDIRECTED', properties:['weight']},
INTERACTS3:{type:'INTERACTS3', orientation:'UNDIRECTED', properties:['weight']},
INTERACTS4:{type:'INTERACTS4', orientation:'UNDIRECTED', properties:['weight']},
INTERACTS5:{type:'INTERACTS5', orientation:'UNDIRECTED', properties:['weight']},
INTERACTS6:{type:'INTERACTS6', orientation:'UNDIRECTED', properties:['weight']}})
首先，让我们计算整个投影图上的加权 PageRank 。
CALL gds.pageRank.stream('starwars',
{relationshipWeightProperty:'weight'})
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name as name, score
ORDER BY score DESC LIMIT 5
结果
结果并不令人惊讶，也许除了汉索罗似乎是银河系中最重要的人物。这是因为阿纳金·天行者和达斯·维德在我们的网络中被视为两个独立的实体，否则阿纳金可能会在上面。尽管如此，从 PageRank 评分来看，所有前五个角色的重要性都非常相似，没有人真正脱颖而出。
假设我们想找到冈根人社交网络中最重要的人物。在带有节点标签参数的算法中，我们可以只考虑冈根人。
CALL gds.pageRank.stream('starwars',{nodeLabels:['Gungan'],
relationshipWeightProperty:'weight'})
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).id as name, score
ORDER BY score DESC LIMIT 5
正如你所料，传奇人物加·加最终胜出。
我们还可以结合节点和关系过滤器。我们将在第五集和第六集中根据人类和其他物种的互动网络来计算 PageRank。
CALL gds.pageRank.stream('starwars',{nodeLabels:['Other','Human'],
relationshipTypes:['INTERACTS5','INTERACTS6'],
relationshipWeightProperty:'weight'})
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name as name, score
ORDER BY score DESC LIMIT 5
结果
看起来卢克和莱娅已经长大了。节点过滤特性的增加允许我们在描述我们想要考虑作为图算法的输入的投影图的子集时非常精确。完成分析后，我们可以从目录中删除投影图。
CALL gds.graph.drop('starwars')
图形可变性
有了图形可变性特性，图形算法在先前支持的流和写之上有了第三种模式变异。我们可以看看官方文档来更好地了解它提供了什么:
*mutate*模式与*write*模式非常相似，但不是将结果写入 Neo4j 数据库，而是在内存图形中提供。注意，*mutateProperty*必须事先不存在于内存图形中。这使得可以在同一个内存图形上运行多个算法，而无需在算法执行期间将结果写入 Neo4j。
基本上， mutate 模式与 write 模式几乎相同，只是它不直接将结果写入 Neo4j 存储的图形，而是将结果存储到同一个内存中的投影图形，该图形用作图形算法的输入。稍后，如果我们愿意，我们仍然可以使用gds.graph.writeNodeProperties过程将内存中图形的变异属性存储到 Neo4j 中。
我们将从投影一个新的内存图形开始。这次我们将使用 cypher projection 。在节点查询中，我们将只过滤第一集出现的字符。我们还提供了标签列，这将允许我们在执行算法时过滤节点。如果仔细观察， labels 列是数组的形式，这意味着单个节点可以有多个标签。同样，通过 cypher projection，我们可以提供一个虚拟标签，如查询所示。
*CALL gds.graph.project.cypher('starwars_cypher',
'MATCH (species)<-[:BELONG_TO]-(c:Character)
// filter characters from first episode
WHERE (c)-[:INTERACTS1]-()
RETURN id(c) as id, [species.name] as labels',
'MATCH (c1:Character)-[r]-(c2:Character)
RETURN id(c1) as source, id(c2) as target,
type(r) as type, r.weight as weight',
{validateRelationships:false})*
Cypher Projection 的一个特性是 validateRelationships 参数。如果我们试图投影节点查询中没有描述的节点之间的关系，默认设置会抛出一个错误。因为我们在节点查询中只投射第一集的角色，但是试图在关系查询中投射所有角色之间的交互，所以我们会得到一个错误。我们可以在关系查询中添加一个过滤器，或者只是将 validateRelationship 参数设置为 false。这样，在图形投影期间，节点查询中未描述的节点之间的所有关系都将被忽略。
最后，我们可以尝试一下用于社区检测的鲁文算法的变异模式。我们将在物种内部而不是在整个网络上调查第一集的社区结构。为了实现这一点，我们必须为每个物种分别运行算法，并且只考虑来自具有节点标签参数的给定物种的角色，并且只考虑来自具有关系类型参数的第一集的交互。为了定义用于将结果存储到内存图的指定属性，我们使用了 mutateProperty 参数。
*MATCH (s:Species)
CALL gds.louvain.mutate('starwars_cypher',
{nodeLabels:[s.name], mutateProperty: s.name + '_1',
relationshipTypes:['INTERACTS1']})
YIELD communityCount
RETURN s.name as species, communityCount*
结果
我们现在可以使用第一集中角色社区的变异属性作为种子属性来计算第二集中的社区。通过给每个节点分配一个唯一的 id 来初始化 Louvain 算法。使用seed property参数，我们可以定义每个节点的初始唯一 id。如果你想了解更多关于种子属性和它的用例，我写了一篇关于它的博客文章。
*MATCH (s:Species)
CALL gds.louvain.mutate('starwars_cypher',
{nodeLabels:[s.name], mutateProperty: s.name + '_2',
relationshipTypes:['INTERACTS2'], seedProperty: s.name + '_1'})
YIELD communityCount
RETURN s.name as species, communityCount
ORDER BY communityCount DESC*
结果
我们可以观察到第二集中的社区数量略有减少。要将变异的属性写回 Neo4j 存储图，我们可以使用gds.graph.writeNodeProperties过程。
*CALL gds.graph.writeNodeProperties('starwars_cypher',
['Human_1','Human_2'])*
我们现在可以检查第一集里人类的社区结构。
*MATCH (c:Human)
WHERE exists (c.Human_1)
RETURN c.Human_1 as community,
count(*) as size,
collect(c.id) as members*
结果
并在第二集中考察这些社区是如何进化的。
*MATCH (c:Human)
WHERE exists (c.Human_2)
RETURN c.Human_2 as community,
count(*) as size,
collect(c.id) as members*
结果
结论
有了多节点标签支持，我们能够在内存中投影整个图，并非常具体地描述我们希望用作图算法输入的子图，因为我们现在可以过滤节点和关系。图形可变性允许我们链接各种图形算法，而不需要删除和重新创建具有新计算属性的投影图。在我看来，这是 Neo4j 图形数据科学库的一大特色。
如果你心中有任何很酷的数据集，你想让我分析，或者有任何关于你接下来想看到什么的反馈，请告诉我。与往常一样，代码可以在 GitHub 上获得。
在深度学习中保护数据隐私|第 1 部分
理解联邦学习的基础及其使用 PyTorch 的实现
链接到第二部分(将 CIFAR10 分发到真实世界/非 IID 数据集):
https://towardsdatascience . com/preserving-data-privacy-in-deep-learning-part-2-6c2e 9494398 b
链接第三部分(非 IID 数据集联合学习的实现):https://towardsdatascience . com/preserving-data-privacy-in-deep-Learning-part-3-AE 2103 c 40 c 22
照片由 Harsh Yadav 拍摄
非常感谢著名数据科学家阿克谢·库尔卡尼先生对本教程的启发和指导。
在数据和数字化革命的世界中，越来越多的个人信息被共享和存储，这开辟了保护数据隐私的新领域。但是，什么是数据隐私，为什么需要保护它？
照片由谷歌人工智能
数据隐私定义了特定信息/数据应如何处理，或者谁有权根据其相对重要性进行访问。随着 AI(机器学习和深度学习)的引入，可以从这些模型中提取大量的个人信息，这对个人数据被暴露的人会造成不可挽回的损失。因此，在实现各种机器学习模型的同时，需要保留这些数据。
在这一系列教程中，主要关注的是保护深度学习模型中的数据隐私。您将探索不同的方法，如联合学习、差分隐私和同态加密。
在本教程中，您将发现如何在机器学习模型上使用联邦学习来保护数据隐私。完成本教程后，您将了解:
- 联邦学习的基础
- 在客户端之间划分数据(用于联合学习)
- 模型架构
- 全局权重中分散权重的聚合
介绍
F 深度学习，也称为协作学习，是一种深度学习技术，其中在多个分散的边缘设备(客户端)或服务器上对其个人数据进行训练，而不与其他客户端共享数据，从而保持数据的私密性。它旨在训练机器学习算法，例如，在具有本地数据集的多个设备(客户端)上的深度神经网络，而无需显式交换数据样本。
照片由谷歌人工智能拍摄
这种训练同时发生在其他设备上，成百上千的设备。在用不同的数据在不同的设备上训练相同的模型之后，它们的权重(训练的概要)被发送到全局服务器，在那里进行这些权重的聚合。使用不同的聚合技术来充分利用在客户端设备上学习的权重。在聚合之后，全局权重再次被发送到客户端，并且训练在客户端的设备上继续。在联合学习中，这整个过程被称为一轮通信，这是为了进一步提高模型的准确性而进行的通信次数。
Google AI 拍摄的照片
联邦学习使人工智能算法能够从位于不同地点的大量数据中获得经验。这种方法使几个组织能够协作开发模型，而不必彼此共享敏感数据。经过几轮沟通后，共享模型(全局模型)接触到的数据范围比任何单个客户端拥有的数据范围都要大得多，同时，它也了解了客户端特有的特性。
有两种类型的联合学习:
- **集中式联邦学习:**在这种设置中，中央服务器用于编排算法的不同步骤，并在学习过程中协调所有参与节点。服务器负责在训练过程开始时选择节点，并负责聚合接收到的模型更新(权重)。是系统的瓶颈。
- **分散联邦学习:**在这种类型中，节点能够协调自己以获得全局模型。此设置可防止单点故障，因为模型更新仅在互连节点之间交换。
现在我们已经清楚了什么是联合学习，让我们继续在 PyTorch 中从头构建一个，并在 CIFAR10 数据集上训练它。借助本教程，我们将了解联邦学习的基本流程。我们既不会详细讨论服务器-客户端通信在现实世界中是如何工作的，也不会讨论聚合技术，这将在接下来的教程中讨论。在本研究中，数据集被随机分为客户端，所有本地模型将在同一台机器上接受训练。我们走吧。
1.导入所有相关的包
导入相关模块
照片由谷歌人工智能
2.超参数
- num_clients :客户端总数，进一步用于将数据集划分为 num_clients，每个客户端具有相同数量的图像。
- num_selected :通信回合中从 num_clients 中随机选择的客户端数量。用于培训部分。通常，num_selected 大约是 num_clients 的 30%。
- num_rounds :通信轮次总数。在每轮通信中，随机选择 num_clients，在客户端设备上进行训练，然后将各个模型权重聚合到一个全局模型中。
- 时期:每个选定客户端设备上的本地训练回合总数。
- batch_size :将数据分批加载到数据加载器中。
3.将 CIFAR 10 加载并划分到客户端
本教程中使用了 CIFAR10 数据集。它由 10 类 32×32 像素的 60，000 幅彩色图像组成。有 50，000 个训练图像和 10，000 个测试图像。在训练批次中，每个类有 5000 个图像，总共有 50000 个图像。在 PyTorch 中，CIFAR 10 可以在 torchvision 模块的帮助下使用。
在本教程中，图像被平均划分到客户端，从而代表了平衡(IID)的情况。
第 6–11 行定义了加载图像时要使用的训练数据的图像增强和归一化方法。第 14–15 行用给定的增量加载训练数据。进行 traindata_split，第 18 行，它将训练数据拆分成 num_clients，即在我们的例子中是 20 个。最后，使用 train_loader(第 21 行)将图像输入神经网络以训练模型。
第 24–27 行定义了测试图像的标准化方法。第 30–32 行定义了一个 test_loader，用于生成给定模型的测试结果。
4.构建神经网络(模型架构)
本教程中使用了 VGG19 (16 个卷积层，3 个全连接层，5 个 MaxPool 层和 1 个 SoftMax 层)。VGG 还有其他变体，如 VGG11、VGG13 和 VGG16。
5.用于联合训练的辅助函数
client_update 函数在私有客户端数据上训练客户端模型。这是在 num_selected 客户处进行的一轮本地培训，在我们的例子中是 6 个。
server_aggregate 函数聚集从每个客户端接收的模型权重，并用更新后的权重更新全局模型。在本教程中，取权重的平均值并聚合到全局权重中。
测试函数是标准函数，将全局模型和测试加载器作为输入，返回测试损失和准确度。
6.训练模型
一个全局模型和单独的 client_models 在 GPU 上用 VGG19 初始化。在本教程中，SGD 用作所有客户机模型的优化器。
也可以用 VGG11、VGG13 和 VGG16 代替 VGG19。其他优化器也是可用的，人们可以检查链接了解更多细节。
第 2–5 行创建了一个列表，用于跟踪训练和测试数据集的损失和准确性。个人客户培训从第 8 行开始，即沟通环节。最初，从 num_clients 中选择 num_selected 个客户端(第 10 行)，即从 20 个可用客户端中随机选择 6 个客户端。使用 client_update 函数为每个选定的客户端(第 12–14 行)进行培训。现在，权重的聚合使用上面定义的 server_aggregate(第 18 行)函数进行。这将更新全局模型，全局模型是用于预测的最终模型。在更新全局模型之后，在上面定义的测试函数的帮助下，这个全局模型被用于测试训练(第 20 行)。
这个过程持续 num_rounds，在我们的例子中是 150 次通信。这是联邦学习的最基本层次的例子，它可以进一步应用于一个真正的基于客户机的系统。
7.结果
对于 6 个选定的客户端，每个客户端在 150 轮通信的顶部运行 5 个本地时期，下面是截断的测试结果。
因此，在 150 轮沟通后，该模型使用联合学习达到了大约 89.8 %的准确率。但是它与在相同数据集上训练的标准 SGD 模型相比如何呢？为了进行比较研究，在没有联邦学习的情况下，使用标准 SGD 优化器对训练数据训练 VGG19 模型。为了确保一个平等的比赛场地，所有的超参数都是相同的，它被训练了 200 个纪元。
标准 SGD 模型在 200 个周期后给出大约 94%的测试准确度。因此，与原始模型相比，我们的联合学习表现良好，准确率约为 90%。
摘要
在本教程中，您发现了如何使用 PyTorch 的联邦学习来保护深度学习模型中的数据隐私。
具体来说，您学到了:
- 什么是数据隐私，为什么需要保护数据隐私？
- 联邦学习的基础及其在平衡的 CIFAR-10 数据集上的实现。可以为任何图像分类问题建立类似的模型。
下面是快速修改整个过程的流程图。
结论
联合学习是机器学习模型中保护数据隐私的最佳方法之一。通过仅发送模型的更新权重而不是数据，确保了客户端数据的安全性。同时，全球模型可以从客户特定的特征中学习。但是不要对这个模型过于兴奋，因为上述结果在现实世界中不太可能出现。客户端持有的真实联邦数据大多是非独立的，并且是同分布的(非 IID)。因此，为了解决真实世界/非 IID 数据集的问题，请继续关注本系列的下一部分。
在接下来的教程中，您不仅将了解如何在联邦学习中处理非 IID 数据集，还将了解联邦学习中的不同聚合技术、模型权重的同态加密、差分隐私及其与联邦学习的混合，以及更多有助于保护数据隐私的主题。
链接到第二部分(将 CIFAR10 分发到真实世界/非 IID 数据集):
https://towards data science . com/preserving-data-privacy-in-deep-learning-part-2-6c2e 9494398 b
链接第三部分(非 IID 数据集联合学习的实现):https://towardsdatascience . com/preserving-data-privacy-in-deep-Learning-part-3-AE 2103 c 40c 22
参考
[1] Felix Sattler，来自非 IID 数据的健壮且通信高效的联邦学习， arXiv:1903.02891
[2] H.Brendan McMahan， 从分散数据中进行深度网络的通信高效学习 *，*第 20 届人工智能与统计国际会议论文集(AISTATS) 2017。JMLR: W & CP 第 54 卷
在深度学习中保护数据隐私|第 2 部分
将一个平衡的数据集分布到一个非 IID/真实世界的数据集中，并进一步划分到用于联合学习的客户端中。
链接到第一部分(联邦学习基础):https://towards data science . com/preserving-data-privacy-in-deep-Learning-part-1-a 04894 f 78029
链接第三部分(非 IID 数据集联合学习的实现):https://towardsdatascience . com/preserving-data-privacy-in-deep-Learning-part-3-AE 2103 c 40c 22
照片由 Harsh Yadav 拍摄
非常感谢著名数据科学家阿克谢·库尔卡尼先生对本教程的启发和指导。
上图类似于非 IID(独立同分布)数据集。如果每个随机变量(图像)具有与其他随机变量相似的概率分布，并且都是相互独立的，则随机变量(图像)的集合是独立且同分布的。在本系列的第 1 部分中，我们使用了 CIFAR10 数据集，这是一个 IID 类型的示例，但是对于真实世界的用例，需要有一个非 IID 数据集来表示真实世界的场景。那么，什么是非 IID 数据呢？要为联合学习积累非 IID 数据，需要对当前数据集(CIFAR10)进行哪些更改？
这些是本教程将回答的一些问题。本博客是在深度学习中保护数据隐私系列的第 2 部分，重点关注将 CIFAR10 分发到非 IID 数据集，并在客户端之间进一步划分。完成本教程后，您将了解:
- 非 IID 数据集
- 将平衡数据集转换为非 IID 数据集和真实数据集
- 形成封装了该非 IID/真实世界数据集的一部分的客户端
- 使用联合学习的图像分类用例
与非 IID 数据集相似。照片由 Harsh Yadav 拍摄
现实生活中的数据(指对象、值、属性和其他方面)本质上是非独立且同分布的(非 IID)。相比之下，大多数现有的分析或机器学习方法都是基于 IID 数据的。因此，需要一种合适的方法来处理这种类型的真实数据集。本教程将介绍非 IID 数据集的基础，从而为实现各种联邦学习技术来处理从非 IID 数据中获得洞察力的问题打开舞台。非线性是一个常见的问题，导致深度学习模型的性能不稳定。在文献中，非 IID 图像分类问题在很大程度上研究不足。
NICO (带有上下文的非 IID 图像数据集)就是这样一个基准数据集，可以进一步用于开发最先进的机器学习模型来处理非 IID 数据。
在这个系列中，CIFAR 10 被用作基准数据集，并且进一步被转换成非 IID 数据集。要了解更多关于联邦学习的基础知识，请阅读本系列的第 1 部分。在本教程中，我们将创建两种不同类型的数据集，一种是复制现实生活中的数据，即现实世界数据集，另一种是非 iid 数据集的极端示例。
真实世界数据集: CIFAR 10 被随机分成给定数量的客户端。因此，一个客户端可以有任意数量的类的图像，比如说，一个客户端只有 1 个类的图像，而另一个客户端有 5 个类的图像。这种类型的数据集复制了真实世界的场景，其中客户端可以有不同类型的图像。
图 1:真实数据集，其中 CIFAR10 被划分为 20 个客户端
**非 IID 数据集:**现实世界的数据集也属于这一类别。但是，在这种情况下，会进行不同类型的分发，其中 CIFAR10 数据集根据每个客户端的类参数进行划分。例如，如果每个客户端的类别=2，则所有客户端将具有从所有类别中随机选择的任意两个类别的图像。
图 2:非 IID 数据集，每个客户端的类=2
从上面的图像中，我们可以知道所有的客户端都有来自任意两个类的图像，但是存在一些异常值，其中一些客户端有来自两个以上类的图像，而一些客户端与其他客户端相比有非常少数量的图像(client_20)。这种异常值确保所有客户端都有一组唯一的图像。这是非 IID 数据集的一个极端例子。我们还可以将 CIFAR10 数据集划分为每个客户端的类= 1，其中所有客户端都将拥有来自一个类的图像，只有一些异常值。
让我们深入到编码部分，更详细地理解它。
1.导入库
2.超参数
- classes_pc: 每个客户端的类，用于通过在客户端之间创建类的不平衡表示，将平衡数据集划分为非 IID 数据集。例如，如果 classes_pc=1，则所有客户端将仅具有来自一个类别的图像，从而在客户端之间产生广泛的不平衡。(参考:图 2)
- num_clients :要分发图像的客户端总数。
- batch_size: 将数据分批加载到数据加载器中。
- real_wd: 我们正在创建两种类型的数据集，一种是真实世界数据集(图 1)，另一种是极端的非 IID 数据集(图 2)。如果 real_wd 为 TRUE ，则创建复制真实生活的数据集，即真实世界数据集(图 1)。如果 real_wd 为 FALSE (默认)，则创建极端非 IID 数据集。
3.创建发行版
get_cifar10 函数下载 cifar10 数据集并返回 x_train，y_train 用于训练，x_test，y_test 用于测试。第 5–6 行从 torchvision 下载数据集，第 8–9 行将其转换为 NumPy 数组。
clients_rand 函数为客户端创建一个随机分布，这样每个客户端都有任意数量的图像。它是将在接下来的代码片段中使用的助手函数之一。
split _ image _ data _ realwd函数将给定的图像分割成 n 个客户端。它返回一个分割，该分割进一步用于创建真实世界的数据集。这整个片段都有注释来解释按顺序发生的事情。要了解更多关于这个发行版的内容，请阅读本系列的第 2 部分。
现在，我们将为非 IID 数据集创建一个类似的分割，如上所述(使用图表)。要了解更多关于这个发行版的内容，请阅读本系列的第 2 部分。
shuffle_list 函数接受上述函数(split_image_data_realwd 或 split_image_data)的输入，分别对每个客户端的图像进行混洗。
下面的代码片段将拆分转换为数据加载器(在这一部分中完成了图像增强),以将其作为训练模型的输入。
get_data_loader 函数使用上述辅助函数，并将 CIFAR10 数据集转换为真实世界或非 IID 类型，视需要而定。
现在，我们已经准备好了创建真实世界或非 IID 数据集的所有函数，联邦学习可以进一步使用这些函数来开发最先进的模型。
现在，我们已经成功创建了这些数据集，让我们来探索对象分类的一些潜在用例，这些用例可以进一步用于联合学习，并确保个人数据安全。
插图由 Harsh Yadav 绘制
摘要
在本教程中，您了解了如何使用 PyTorch 为影像分类准备非 IID/真实世界数据集。
具体来说，您学到了:
- 什么是非 IID(独立同分布)数据集。
- 如何将平衡分布转换成非 IID/真实世界。
- 对象分类的潜在用例。
下面是将 CIFAR10 数据集转换为客户端的整个过程的快速修订流程图，可进一步用于联合学习。
结论
非 IID 数据很难训练，联邦学习也是如此。真实世界/非 IID 数据集被划分成客户端(num_clients ),这些客户端可以被联邦学习进一步使用并保持数据隐私。
在本系列的下一部分中，我们将在联邦学习中使用这个数据集。请继续关注下一部分，它将探索在非 IID 数据集上的联邦学习中使用的新的聚合和通信技术。在接下来的教程中，您将了解联邦学习的不同聚合技术、模型权重的同态加密、差分隐私以及它与联邦学习的混合。
链接第三部分(非 IID 数据集联合学习的实现):https://towardsdatascience . com/preserving-data-privacy-in-deep-Learning-part-3-AE 2103 c 40c 22
参考
[1] Felix Sattler，来自非 IID 数据的健壮且通信高效的联合学习， arXiv:1903.02891
[2]岳鹤，走向非独立影像分类:数据集与基线， Elsevier
在深度学习中保护数据隐私|第 3 部分
非独立同分布(非 IID)数据集上联邦学习的实现。
链接到第 1 部分(联合学习的基础):https://towards data science . com/preserving-data-privacy-in-deep-Learning-part-1-a 04894 f 78029
链接到第二部分(将 CIFAR10 分发到真实世界/非 IID 数据集):
https://towardsdatascience . com/preserving-data-privacy-in-deep-learning-part-2-6c2e 9494398 b
隐私是本世纪最重要的方面之一，无论是私人数据的物理隐私还是虚拟隐私。照片由 Harsh Yadav 拍摄
非常感谢著名数据科学家阿克谢·库尔卡尼先生对本教程的启发和指导。
什么是联合学习？什么是非 IID 数据集？要在联邦学习中积累非 IID 数据，需要做哪些改变？这类深度学习方法有哪些用例？
这些就是你在这里的一些问题。本博客是在深度学习中保护数据隐私系列的第 3 部分，重点关注使用非 IID 数据集实现联合学习。在本系列的第 1 部分中，我们探索了联邦学习的底层架构及其使用 PyTorch 的基本实现。但是第 1 部分无法处理真实世界的数据集，在真实世界中，任何客户端都可以拥有任意数量的来自给定类的图像。为了解决这个问题，在第 2 部分中，我们将 CIFAR 10(平衡数据集)分发到非 IID/真实世界分发中，并进一步将其划分为客户端。现在，为了构建真实世界/非 IID 数据集的联合学习模型，我正在编写本教程。在本系列的这一部分中，我们将对非 IID 客户机(在第二部分中)使用联合学习的架构(在第一部分中)。因此，它可以被认为是联合学习的一个真实世界的用例。
完成本教程后，您将了解:
- 联合学习
- 非 IID 数据的联合学习架构
- 联邦学习中的再培训和交流方法
- 加权平均作为聚集技术
什么是联合学习？(快速回顾)
深度学习是一种隐私保护方法，旨在在拥有个人数据的多个设备(客户端)上训练人工智能模型，而无需显式交换或存储数据样本。全局模型(权重)被传送到这些设备，在这些设备中，实际的训练同时发生，合并了客户特定的特征，然后用在各个设备的训练期间学习的所有新特征来更新(聚集)全局模型。
Google keyboard 的下一个单词预测是联合学习的一个杰出例子。联邦学习处理设备历史(打字历史)来建议对 Gboard 的查询建议模型的下一次迭代的改进。
由 Kiki Siepel 在 Unsplash 上拍摄的照片
联邦学习与花的学习非常相似。就像所有的花瓣(客户端)都由花梗(全局服务器)持有，每个花瓣都有不同的尺寸和模式，但与组成花的其他花瓣相似(非 IID 数据集)，以及所有的营养物质(模型的权重)如何由花梗同时转移到花瓣，花是联合学习的真实类比。
要深入了解使用 Pytorch 的联邦学习的基本实现，请阅读本系列的第 1 部分。
现在，我们可以开始本博客的下一个也是最激动人心的部分了，开始玩代码吧。本教程使用 PyTorch，通过将平衡的 CIFAR10 数据集转换为非 IID/真实世界的数据集，从头开始构建一个联合学习模型。有许多联合学习的聚合技术，但是这项研究实现了所有权重的加权平均值。
1.导入库
2.超参数
- classes_pc: 每个客户端的类，此外，这用于通过在客户端之间创建类的不平衡表示来将平衡数据集划分为非 IID 数据集。例如，如果 classes_pc=1，则所有客户端将仅具有来自一个类别的图像，从而在客户端之间产生广泛的不平衡。
- num_clients :要分发图像的客户端数量。
- num_selected: 在每轮通信开始时从 num_clients 中随机选择的客户端的数量。用于全球模型的培训阶段。通常，num_selected 约为 num_clients 的 30–40%。
- num_rounds: 全局模型训练的总通信轮数。在每一轮沟通中，对单个客户的培训同时进行。
- **时期:**每个客户端设备上的本地训练回合数。
- batch_size: 将数据批量加载到数据加载器中。
- baseline_num: 要保存在全局服务器上的基线图像的总数，用于在聚合之前重新训练客户端的模型。这种在全局服务器上重新训练所有模型的技术处理非 IID/真实世界的数据集。
- retrain_epochs: 从参与通信回合的所有客户端接收模型权重后，全局服务器上的再训练回合总数。
3.将平衡的 CIFAR10 转换并划分为非 IID 数据集。
CIFAR10 数据集被转换为极端非 IID 数据集(参见第二部分)。CIFAR10 由 60，000 张 32x32 像素的彩色图像组成 10 类。训练集由 50，000 幅图像组成，剩余的 10，000 幅图像用于测试目的。
下面是代码，将在本系列的第 2 部分中详细解释。请前往第 2 部分以更详细地理解以下片段。
要更深入地了解上述函数，请阅读本系列的第 2 部分，其中详细解释了每一个函数。
4.构建神经网络(模型架构)
本教程中使用了 VGG19 (16 个卷积层，3 个全连接层，5 个 MaxPool 层和 1 个 SoftMax 层)。
5.联邦学习的辅助函数
baseline_data 函数为基线数据创建一个加载器，在全局服务器上聚集权重之前，客户端的模型在该加载器上被重新训练。“num”是在全局服务器上对客户端模型进行再训练的图像数量。第 9–10 行获取 CIFAR10 数据，并打乱训练集。第 12 行从这个混洗的数据集中选择 num 个图像，随后它被用于在第 14 行创建数据加载器。
client_update 函数根据给定的私有客户端数据训练客户端模型。这是为每个选定的客户端，即 num_sleected(在我们的例子中是 6)进行的本地培训回合。
client_sync 函数将客户端模型(训练前)与全局权重同步。在特定客户端没有参与先前的通信回合的情况下，它是有帮助的，因此它确保所有选择的客户端具有来自全局模型的先前训练的权重。
server_aggregate 函数聚集从每个客户端接收的模型权重，并用更新后的权重更新全局模型。在本教程中，将计算权重的加权平均值。在本系列的第 1 部分中，平均值被用作聚合方法，而不是加权平均值。
测试函数是使用测试数据集评估全局模型的标准函数。它返回测试损失和测试准确性，用于不同方法的比较研究。
现在，我们已经完成了数据的所有预处理和联邦学习的一些辅助函数。因此，让我们深入研究模型的训练，即使用非 IID 数据集的联合学习。
6.训练模型
照片由谷歌人工智能
全局模型，客户端的模型用 VGG19 初始化，训练在 GPU 上完成。第 6–11 行，在 GPU (Cuda)上用 VGG19 初始化模型。在第 14 行，优化器(SGD)和学习率一起被定义。我们还可以在优化器中添加动量项。在第 17 行，基线数据被添加到具有‘baseline _ num’图像的加载器，即，如上定义的 100 个图像。
使用上述函数将非 IID 数据装载到 train_loader 中，这确保了数据是非 IID 数据。class _ PC = 2，num_clients=20，batch_size=32。
第 1–4 行创建了一个列表，用于跟踪模型在训练和测试数据集上的损失和准确性。第 7 行开始在通信回合(num_rounds)中训练单个客户端。在每一轮通信中，首先，用全局权重更新选定的客户端。然后，在客户端设备上训练本地模型，之后在全局服务器上进行再训练。在重新训练客户端的模型之后，将进行权重的聚合。
第 9 行从 num_clients 中选择 num_selected 个客户端，即从总共 20 个客户端中随机选择 6 个客户端。使用 client_sync(第 15 行)完成客户端设备上的训练(第 13–17 行)，其中在训练之前使用全局权重更新本地模型，然后使用 client_update 函数(第 16 行)开始训练。一旦本地模型在设备本身上被训练，确保私有数据的隐私，它们就被发送到全局服务器。首先，使用基线数据对这些模型进行再训练(第 12-17 行)。接下来是将这些局部模型(权重)聚合(第 27 行)成一个全局模型。在更新全局模型之后，在上面定义的测试函数的帮助下，这个全局模型被用于测试训练(第 28 行)。
这个过程持续 num_rounds，在我们的例子中是 150 次通信。这是使用非 IID 数据集的联邦学习的例子，对于真实世界的数据集(在第 2 部分中定义)也可以做类似的事情，这可以进一步应用于一个真实的基于客户机的系统。
7.结果
对于 6 个选定的客户端，每个客户端运行 5 个本地时期，并在全局服务器上保留 20 个时期，在 150 轮通信的顶部，下面是截断的测试结果。
在全局服务器上重新训练的联合学习的准确性
相比之下，本教程中使用的方法给出了大约 72% 的准确度，而本系列第 1 部分中使用的方法在非 IID 数据集上应用时给出了大约 35% 的准确度。此外，当前的方法(在全球服务器上重新训练)与其他可用的方法相比要稳定得多。
在对这种方法(保留在具有加权平均值的全局服务器上)与第部分第 1 中使用的方法(即具有平均值的基本联合学习)的比较研究中，方法 2(在全局服务器上重新训练)远远优于第 1 部分中使用的方法。整个教程展示了在全局服务器上保留来处理数据集的非 IID 问题的重要性。因此，这项研究是处理非 IID 数据集问题的一个很好的方法，可以用于现实世界的用例中。
摘要
在本教程中，您发现了如何使用 PyTorch 的联邦学习来保护深度学习模型中的数据隐私，并且可以应用于现实世界的问题。
具体来说，您学到了:
- 非 IID 数据集上联邦学习的实现
- 加权平均值作为聚合技术(我们在第 1 部分中使用了权重的平均值)
- 在用全局服务器上的基线数据训练和重新训练客户端的模型之前，用全局权重同步客户端。
下面是快速修改整个过程的流程图。
非 IID 数据集的联邦学习流程图，作者插图
结论
联合学习是机器学习模型中保护数据隐私的主要方法之一。通过仅发送模型的更新权重，而不是数据，确保了客户端数据的安全性。这种用基线数据重新训练每个客户模型的方法处理了非 IID 数据的问题。此外，每个客户端模型的同步与全局权重以及加权平均值作为技术的集合，有助于获得该模型的良好准确性。本教程处理非 IID 数据集的极端情况，但是当用于现实生活中的数据时，它比我们的结果表现得更好，这是因为当前数据实际上比我们在现实生活场景中处理的数据更加截断。
在接下来的教程中，您不仅将了解联合学习中的不同聚合技术，还将了解模型权重的同态加密、差分隐私及其与联合学习的混合，以及一些有助于保护数据隐私的更多主题。
参考
[1] Felix Sattler，来自非 IID 数据的健壮且通信高效的联合学习， arXiv:1903.02891
[2] H.Brendan McMahan， 从分散数据中进行深度网络的通信高效学习 *，*第 20 届人工智能与统计国际会议论文集(AISTATS) 2017。JMLR: W & CP 第 54 卷
根据 262，144 次模拟，杜达总统将坚定地再次当选
在总统决选前对趋势的详细分析给了 Trzaskowski 追赶现任的空间。
来源:安杰伊·杜达·脸书简介
免责声明:本文无意支持任何一位竞选波兰共和国总统的候选人。它只专注于提供以往总统选举的数据见解，并为本周日举行的决胜选举的可能结果建模。
由于波兰目前的政治平衡，今年的总统选举尤为激烈。
现任总统杜达正在努力争取连任，以维护执政党法律与正义党(PiS)目前的政治话语。
另一方面，反对派支持者试图通过选举公民纲领党副主席 rafatrzaskowski 来打破现政府的立法权。
这一选择很有分量，因为下一次议会选举将于 2023 年举行，Trzaskowski 的成功可能会引发提前大选。
来源:tvn24.pl
在第一轮投票中，杜达总统获得了 43.50%的选票，这是自 1989 年以来的第二好成绩。
然而，他能否战胜 Trzaskowski 仍不确定。过去一周的民意调查显示，没有明显的热门人选。
虽然几乎四分之三的选民决定支持两个最大政党的候选人，但 Szymon hoownia 和 Krzysztof Bosak 的选民本周将有至关重要的发言权。
资料来源:ewybory.eu，截至 2020 年 7 月 6 日
在过去几个月里，hoownia 和 Bosak 的选民结构都发生了变化。此外，民意调查通常包括一部分坚定的未决选民，这可能会扭曲结果。
为此，我决定分析波兰 2005 年、2010 年和 2015 年的前三次总统选举。基于投票之间的趋势和相关性，我试图提取合理的参数，并模拟本周日可能的结果。
为什么我只分析最后三个？这是因为 2005 年是波兰政治平衡的转折点。自那以后，只有两个政党交替当选执政——法律与正义党(PiS)和公民纲领党(PO)。
我将在接下来的部分深入探讨这个问题，但是如果你觉得对波兰的政治环境感到舒服，可以随意跳过它！
政治背景
2005 年之前，总统府以及议会多数席位都掌握在民主左翼联盟(SLD)手中。
由于 2002 年末的腐败丑闻，也就是所谓的莱文事件，他们开始失去公众的支持。此后，三大政治力量开始出现，并形成新的力量平衡。
保守派的法律与正义党(PiS)、自由派的公民纲领党(PO)和波兰共和国的社会民主自卫党(SO)，重点关注农村事务。由于 SO 领导人 Andrzej Lepper 的古怪性格，它在与 PiS 和 PO 的竞选中失败了。
这两人本打算在 2005 年议会选举后创建一个联合政府。然而，在 PiS 在总统和大选中获胜后，联盟从未取得成果，PiS 和 PO 最终站在了政治光谱的对立两极。
自那以后，波兰政坛找到了平衡，两党的支持者在投票模式上基本保持一致。随着议会多数党的更迭——(2005-2007 年)PiS，(2007-2015 年)PO，(2015 年至今)PiS，没有一个外部政党能够获得足够的选票份额来破坏这一分裂。
在总统办公室也观察到类似的模式，分别由卡钦斯基(PiS)——2005 年，科莫洛夫斯基(PO)——2010 年，杜达(PiS)——2015 年获得。
由于投票习惯相对稳定，我决定将过去三次总统选举纳入我的分析。
在这篇文章中，我试图从历史数据中提取投票模式，并用它们来模拟本周日在……惊喜，惊喜——PiS 和 PO 候选人——安杰伊·杜达和 rafatrzaskowski 之间进行的决胜选举的潜在结果。
我们能从以前的选举中学到什么？
在接下来的两个部分中，我将展示过去总统选举的深刻见解以及它们对决胜选举最终结果的影响。
如果你对数学废话不感兴趣，跳转直接进入 谁领先 位！；)
我决定打破逐个县的投票模式，这使我能够调查当地的模式。
以下图中的每个点代表一个县。我还关注候选人相对于合格选民总数的投票份额，而不是总投票份额。这样，我们可以在我们的模型中考虑县投票率的变化。
总统选举中投票率的变化本身似乎并没有太大的不同。回归道岔的均方根误差(RMSE)保持在 2 个百分点的界限内。
前一次选举中的第一次投票率与第一次投票率
类似地，投票偏好基本保持不变，因为人们支持他们在以前的选举中投票支持的同一政党的候选人。
这是意料之中的，因为历史上 PiS 在农村地区和小城市更受欢迎。另一方面，PO 一直在城市地区取得强劲的成绩。
今年，当前的支持度与 2015 年的支持度之间有着特别强的相关性。回归系数大于 1 表明 2015 年有强烈偏好的县更支持同一政党的候选人。
杜达总统也注意到了这种回归的一个相对较大的截距——0.079。这意味着他设法在全国范围内将他的选民基础统一提高了大约 8 个百分点。
第一轮投票结果与上次选举的第一轮投票结果
这些结果表明，在过去的 5 年里，波兰政治舞台上的两极分化越来越严重，因为任何一方的选民都更加积极。
事实上，自 1990 年第一次民主选举以来，第三方候选人获得的选票份额(26.04%)位居第二。在 2010 年因斯摩棱斯克空难而举行的选举期间，这一数字只有所下降，斯摩棱斯克空难是波兰现代史上最具分裂性的事件之一。
为了确保在本周日获胜，这场比赛本质上归结为两个决定性因素——动员候选人自己的选民和说服大多数第三方选民。第三方选民在过去的总统选举中被证明是至关重要的。
让我们来看看 2005 年的总统选举，PiS 候选人莱赫·卡钦斯基在第一轮投票中以 33.10%的得票率位居第二，输给了他的 PO 对手唐纳德·图斯克，得票率为 36.33%。
虽然图斯克明显领先，但第三名的安杰伊·莱珀(15.11%)的选民显示出对卡钦斯基的强烈支持。最好的说明是回归莱珀在每个县关于卡钦斯基和图斯克在两次投票之间选民基础增加的结果。
每个县的候选人相对于 Andrzej Lepper 结果有所增加。
可以观察到民主左翼联盟候选人第四马雷克·博罗夫斯基的相反趋势，但与莱珀相比，他的选民基础相对较小且分布更均匀，这并没有弥补卡钦斯基支持率的上升。
卡钦斯基凭借与莱珀相似的选民基础，以 54.04%的总票数赢得了选举。
每个县的候选人相对于马雷克·博罗夫斯基结果的增加。
这是故事的一部分——第三方候选人对第二轮投票的结果有着重大(甚至是决定性)的影响。
然而，在第二轮投票之前动员自己的选民一直是两次投票之间为期两周的马拉松的重要组成部分。事实证明，并非偶然。
让我们来看看在第一轮决胜选举之前，每个候选人的选民基础的增长情况。
每个县的候选人相对于他们自己的结果有所增加。
特别是在 2010 年和 2015 年，两党候选人在每个县都取得了与其最初支持度成比例的收益。
这突出了一个事实，即许多主要政党的选民决定只在第二轮投票中投票，而最终决定必须在第二轮投票中做出。
科莫洛夫斯基的增长与他的初步结果特别相关，突出了 PO 的选民努力阻止杜达上任。
建模和假设
模拟选民基础的增加归结为候选人自己的结果，以及他们说服第三方选民的能力。
因此，我们可以拟合线性模型，根据候选人的投票结果和第三方选票的份额来预测候选人在每个县的增长。我故意不把对手的选票份额作为独立变量，因为它与候选人自己的结果负相关。最终模型是:
%增加= b0 + b1 x 候选人结果+ b2 x 第三方投票+ 误差
对最近三次选举中的两党候选人运行该模型，得到以下模型:
# standard deviation of each coefficient is given in bracketsTusk, 2005 increase = -0.041(0.005) + OWN x 0.329(0.021) + OTHER x 0.238(0.019)Komorowski, 2010 increase = 0.02(0.007) + OWN x 0.092(0.013) + OTHER x 0.206(0.046)Komorowski, 2015 increase = 0.001(0.004) + OWN x 0.536(0.013) + OTHER x 0.084(0.032)Kaczynski, 2005 increase = -0.106(0.01) + OWN x 0.423(0.049) + OTHER x 0.994(0.026)Kaczynski, 2010 increase = -0.045(0.006) + OWN x 0.257(0.011) + OTHER x 0.481(0.044)Duda, 2015 increase = -0.006(0.008) + OWN x 0.474(0.009) + OTHER x 0.267(0.06)
一些有趣的细节立刻引起了我的注意。
首先，PiS 一贯更擅长在第三方势力强大的县增加选民基础。2010 年的情况也是如此，当时 napieraski 的结果与科莫洛夫斯基的结果高度相关，减少了 napieraski 对 b2 的影响。
第二，两党都严重依赖于在决胜选举期间前往投票站的不太活跃的选民的推动。
然而，每个缔约方的增长能力似乎有限。将 b1 系数与第一轮投票中获得的结果进行比较，表明在更高支持水平上动员的能力下降。
PO 候选结果与 b1:
30.46% — (0.500–0.700)?
33.77% — 0.536
36.33% — 0.329
41.54% — 0.092
PiS 候选结果与 b1:
33.10% — 0.423
34.76% — 0.474
36.46% — 0.257
43.50% — (0.150–0.300)?
第一轮投票结果较低表明动员能力较高，选民基础有机增长。因此，更高的级别限制了这种能力，因为许多选民已经在第一轮投票中参加了投票。
考虑到这一点，我选择了一个相对较宽的系数范围，我们可以根据历史趋势预期看到这些系数。这是:
Trzaskowski B1:0.500–0.700
杜达 B1:0.150–0.300
对 b2 进行类似的假设。随着每次连续的选举，PiS 拦截第三方选民的能力减弱。今年，这可能是一项特别困难的任务，因为 Szymon Hoł ownia 的选民往往与更自由的价值观联系在一起。
尽管如此，说服第三方选民对两位候选人来说都是一项具有挑战性的任务，因此我们可以预计 b2 系数的低值与 2015 年选举相似。
Trzaskowski B2:0.150–0.300
杜达 B2:0.200–0.350
最后，b0 截距表明所有县的支持度均有增加。在投票人数大幅增加的情况下，这些数字往往会特别高，比如在 2015 年。
平均而言，他们倾向于将分数正常化，因为在任何一个县，任何一位候选人都很少获得少于 7-8%的合格选票。从历史上看，这个截距稍微有利于 PO 候选人。
Trzaskowski B0:(-0.040)—(-0.020)
杜达 B0:(-0.070)——(-0.040)
为了建模，我假设这些参数是均匀分布的。将每个区间截断成 8 个均匀分布的值，并模拟这些值的每个组合，得到了 262，144 个选举模拟。
谁领先？
选票的中间份额使杜达总统以总票数的 50.97% 处于领先地位，紧随其后的是 Trzaskowski49.03%。
百分比分数的标准偏差为 1.91%，这使得 Trzaskowski 的获胜边界与平均值的标准偏差不到一个。
该模型显示杜达总统有 68.8%的机会赢得本周日的选举。
两名候选人的投票份额分配
这仍然是一个相对较小的差额，极大地依赖于参数假设的有效性。
仅仅依靠过去的三次选举，这些参数很难建模。它们只能从总体投票模式和当前的政治平衡中间接推断出来。
预计投票率将达到 65.49%，标准差为 2.51%。鉴于这些结果，杜达预计将获得 1008 万张选票，而 Trzaskowski 目前约有 970 万张选票。
道岔分布
Trzaskowski 怎么做才能缩小差距？
由于高度的两极分化，动员他自己的选民似乎是一个特别有效的策略。
b1 达到 0.65 以上水平的模拟，使他与他的对手处于平等地位。Trzaskowski 目前的选民基础具有巨大的有机增长潜力，他的竞选团队应该努力利用这一事实。
你怎么想呢?
你认为这个分析遗漏了什么吗？
你认为我的假设是否正确？
也许你想更详细地谈谈这个模型？
随时联系！
[## Cezary Klimczuk -数据科学家|伦敦大学学院毕业生
www.linkedin.com](https://www.linkedin.com/in/cezary-klimczuk-423522129/)
我在 Jupyter Notebook 中使用 Python 进行了所有分析。
我下载并清理了 pkw.gov.pl 的选举数据。请随时访问我的 GitHub 页面 ，更深入地探索我的项目！
总统选举预测
我的预测依赖于每个州的流行数据的历史数据
承认
感谢阿斯玛·巴拉卡特帮助我收集这项研究所需的数据！
介绍
许多因素会影响选举结果，如新冠肺炎、弹劾、经济、失业率、自然灾害应对、气候变化、外交政策、人们对自己政党的忠诚度、辩论、总统身高以及许多其他因素。在本文中，我将只关注每个州普选的历史数据。
模型
建模和分析中使用的编程语言是 SAS 9.4。使用的模型是 PROC 单变量。
结果
为了测试我的模型，我预测了 2016 年的选举，并将结果与实际值进行了比较。总体而言，算法显示特朗普将在 2016 年获胜，这确实发生了。此外，它预测他将赢得 2020 年的选举。然而，通过检查状态的结果，我发现代码预测了 11 个错误的状态，进一步的细节如下。
我们应该收集历史上多长时间的数据？
这种模式完全依赖于人们对其政党的忠诚。它不包括任何其他因素。我们收集了自 1960 年以来每个政党的普选百分比。
选择 1960 年是暂定的。我认为大多数人不会改变他们的政党。因此，我搜索了美国的平均预期寿命，发现它大约是 78 岁，这意味着我应该回到 1940 年选举以来的数据。然而，通过一些反复试验，我发现 1960 年给出了最准确的结果。尽管如此，还需要进一步的实验来进行更准确的验证。
模型精度
我通过使用我的算法来预测 2016 年的选举，验证了这些实验。如图 1 所示，该算法正确预测了 39 个州和哥伦比亚特区，错过了 11 个州。然而，它预测共和党将以 311 张选举人票赢得 2016 年选举。民主党仅获得 224 票，接近共和党和民主党分别获得 304 票和 227 票的实际结果。
图 1:2016 年结果测得的模型精度
根据图 1，模型准确率为 78.43%。这个模型还有很大的改进空间，可以提高它的准确性。(请阅读文章末尾的更正)
二话没说，给你表:
表 1:结果
您可以从这里下载表 1 中列出的文件:
http://engyfoda.com/MYPREDICTIONSISA_2.xlsx
还可以下载以下文件:
民主党的 2020 年文件:http://engyfoda.com/DEMOCRATSISA.xlsx民主党的 2016 年文件:【http://engyfoda.com/DEMOCRATS2016.xlsx】T4共和党的 2020 年文件:http://engyfoda.com/REPUBLICANISA.xlsx共和党的 2016 年文件:http://engyfoda.com/REPUBLICAN2016.xlsx
注意:在上述文件中，最后一个变量(L)是每个州的选举人票。
形象化
通过比较我对 2016 年选举的预测和 2016 年实际结果的两张地图，图 2 和图 3，这是模型错过的 11 个州:
1.科罗拉多州(实际胜出的候选人是:希拉里)
2。伊利诺伊州(实际胜出的候选人是:希拉里克林顿)
3。密歇根州(实际胜出的候选人是:唐纳德·特朗普)
4。内华达州(实际获胜的候选人是:希拉里克林顿)
5。新罕布什尔州(实际获胜的候选人是:希拉里克林顿)
6。新墨西哥州(实际胜出的候选人是:希拉里)
7。北卡罗来纳州(实际获胜的候选人是:希拉里克林顿)(这是错误的。请阅读文末更正)
8。宾夕法尼亚州(实际胜出的候选人是:唐纳德·特朗普)
9。弗吉尼亚州(实际获胜的候选人是:希拉里克林顿)
10。西弗吉尼亚州(实际获胜的候选人是:唐纳德·川普)
11。威斯康星州(实际获胜的候选人是:唐纳德·特朗普)
图 2:我对 2016 年选举的预测
图 3:2016 年选举的实际结果
下面是我对 2020 年预测的可视化，如图 4 所示。通过比较我对 2016 年和 2020 年的预测，图 2 和图 4，只有西弗吉尼亚州从民主党转向共和党，导致共和党的选举人票从我 2016 年预测的 307 张增加到 2020 年预测的 311 张。由于该算法在 2016 年的结果中已经错过了 11 个州，这种错过在 2020 年的预测中仍然存在。所以我可以断定，算法对 2020 年的预测是川普以 78.43%的概率获胜。
图 4:2020 年预测
模型缺陷
该模型源于人们对其政党的忠诚度，而在 2020 年选举中，人们的偏好可能会因其他因素而改变。例如，许多共和党人反对特朗普，许多民主党人不赞成在 LGBT 和堕胎的性自由中占据自由概念，这违反了他们的宗教信仰。
而且这种分析只依赖两方的结果，不考虑对方的结果。如果我们收集第三方的结果并将其注入到模型中，一些州的结果会有所提高。
此外，仅使用两位小数。向模型输入更精确的数据将会提高它的准确性。
原始数据
每个州的原始数据可以从这里下载:
阿拉巴马，阿拉斯加，亚利桑那，阿肯色州，加利福尼亚州，科罗拉多州，康涅狄格州，特拉华州，佛罗里达州，佐治亚州，夏威夷，爱达荷州，伊利诺伊州， 马萨诸塞州，密歇根州，明尼苏达州，密西西比州，密苏里州，蒙大拿州，内布拉斯加州，内华达州，新罕布什尔州，新泽西州，新墨西哥州，纽约州 罗德岛，南卡罗来纳州，南达科他州，田纳西州，得克萨斯州，犹他州，佛蒙特州，弗吉尼亚，华盛顿，西弗吉尼亚，威斯康辛州
结论
这种模式完全依赖于人们对其政党的忠诚。可以为以后的工作做几个步骤。首先，做进一步的实验来验证时间回到哪一年会让我们得到更准确的结果。其次，增加输入数据文件中的小数位数可能会影响模型的性能。第三，在模型中加入更多的因素，如各州对新冠肺炎的反应、失业率以及对自然灾害的反应。自然灾害的应对可以是一篇全新的文章来研究和比较他们与每一位总统的数据。自 2016 年以来，野火、飓风和洪水的数量有所增加。总之，本文仅仅是一个开始，还有提高模型准确性的空间。
无论你的政党是什么，请投票。
Engy Fouda，
作者，使用 SAS Studio 学习数据科学
修正
我写道，该模型在 2016 年预测北卡罗来纳州是错误的，但它是正确的预测。唐纳德·特朗普在 2016 年赢得了北卡罗来纳州。我在输入两个实际投票时犯了一个错误；我把它们调换了。这一修正将模型准确率提高到 80.39%，因为它在 2016 年的选举中错过了 10 个州，而不是 11 个州。
压力脉动带来更好的浓缩咖啡
压力曲线的时髦方式
五年前，我爱上了杠杆咖啡机。他们能够像半自动机器一样进行压力分析，但是没有成本。主要警告:杠杆机器需要艺术性。随着时间的推移，我学会了如何制作美味的浓缩咖啡。我还买了一些杠杆机器，并失去了购买更昂贵的压力剖面机的欲望，因为压力剖面是杠杆机器的标准功能。我仍然在阅读这些新机器，我发现了一个有趣的想法:压力脉动。
压力剖面
大多数咖啡店里的普通浓缩咖啡机对热水(理想温度为 90℃)施加恒定的压力(理想压力为 9 巴)来制作浓缩咖啡。更先进的机器给出一些调整压力的时间间隔。更好的是，你可以用类似于杠杆机器的非常低的压力进行预输注，这样，你就可以用压力进行注射。
压力剖面包括在整个发射过程中修改压力。你可以从低压开始，高压结束；你可以在高压下开始，在低压下结束。两者给了镜头不同的味道。
最近十年的进步已经使 PID 控制的温度和压力至少在咖啡店里为大众所接受。这些机器把所有的艺术性都简化成了一门科学，因为每次拍摄都可以根据水温、压力和体积进行复制。
压力脉动
最近看到浓缩咖啡三期，看到一个有趣的段子:“这成为了 Simonelli 集团脉冲喷射技术的基础，用在 Aurelia Wave 浓缩咖啡机上。对于浓缩咖啡萃取的三个阶段，咖啡师可以选择不同的流速通过圆盘。
所以我研究了奥雷利亚波，但是关于脉冲是如何工作的信息很少。保密可能是故意的，但我有一个聪明的想法:我可以尝试在手动机器上脉冲。
我用帕沃尼琴的次数更多了，所以我尝试了一次断奏。拉的时间比较长，但是结果很惊人。到目前为止，这是我一生中最好的一次拍摄。
André Eiermann 用 Aurelia Wave 做了一些测试，他没有发现 TDS 差异，但他确实注意到了味道差异。我想知道在多点测量 TDS提取的体积是否会显示机器设置之间的更大差异。我认为他的实验没有达到应有的彻底程度，但这绝对是一个好的开始。他尝试测试了很多变量，对实验进行优先排序需要大量的试验、错误和直觉。
理论上，压力脉冲类似于在注射中间进行多次预输注。因此，基于对预灌输的了解，人们会期望在给定的输出体积中有相同或更高的提取。一般来说，使用预浸泡，浓缩咖啡比没有更高的提取率。Aurelia Wave 在预输注过程中确实会产生喷射脉冲，但我没有在手动杠杆机器上尝试过。
脉动过程
对于杠杆机器，我们有一系列的选择。这些说明假定类似于 la Pavoni 或 Kim Express 或 Flair:
- 预输注 15 秒
- 绽放 15 秒
- 脉冲 15 到 45 秒，直到达到所需的重量输出。
脉冲频率和持续时间是主要变量。目前，让脉冲提供近乎稳定的咖啡流似乎很重要。我的很多脉动都是基于拍摄过程中的视觉，并使用脉动来获得暗咖啡。副作用更少。
实验
我的意图是尝试不同持续时间的不同脉冲方法。问题是，用杠杆机器，我拉了更多的工匠镜头，我是根据我用相机在底部看到的进行调整的。像 DE1Pro 这样的像样的浓缩咖啡机本来可以帮助控制更多的变量，但我认为杠杆机器上的脉冲固有的一点是视觉上看到无底的 portafilter 和咖啡师进行实时调整之间的反馈。
为了收集数据，我试着交替使用压力脉冲拍摄和常规压力拍摄。常规压力注射仍然具有预注入和起霜，因为仅在注入期间施加脉冲。我也把我的大部分镜头作为断续浓缩咖啡镜头，因为它们味道更好，提取率更高。随着时间的推移，我积累了大量数据，然后我从这些数据中提取了一组数据点，其中机器、咖啡豆和重量对于常规压力射击和压力脉冲射击是相同的。
原始数据！
我最后得到了 17 个数据对，还不够统计意义。然而，它们很适合定性检查。建立一个足够大的统计数据集的困难意味着我必须拍摄 30 多对照片，这在我进行其他实验以及拨入新的咖啡烘焙时是很困难的。最重要的是，我发现压力脉冲改善了我的投篮，所以不这样做，我知道我没有尽我所能投出最好的球。话虽如此，我还是把我的数据归纳到下面这个。
数据:整合和清理
我用来比较的两个主要指标是提取率和最终得分。提取率由从圆盘中提取到杯中的咖啡量决定，而提取率由使用数字折射计(Atago) 测量总溶解固体(TDS)来确定。所有 17 对都有最终得分指标，但只有 9 对数据有 TDS 指标，因为我在开始收集这些配对数据点后开始收集 TDS 测量值。
最终得分是 7 项指标(强烈、浓郁、糖浆、甜味、酸味、苦味和余味)的记分卡的平均值。当然，这些分数是主观的，但它们符合我的口味，帮助我提高了我的拍摄水平。分数有一些变化。我的目标是保持每个指标的一致性，但有时粒度很难确定。
首先，从提取率来看，在大多数情况下，压力脉冲与常规注射相同或更好。该图在 x 轴上显示了常规压力提取，在 y 轴上显示了相应的压力脉冲提取。
当看最终得分时，趋势是相似的，但是有更多的情况下脉冲没有帮助。然而，这又回到了一个论点，即脉冲将提供相同或更好的提取，而不是更差的提取，因为它与预灌输相似。
红色圈出的数据点是非断奏镜头。剩下的都是断断续续的镜头。
以下是一些平均值的总体总结。我不能说这些分布在统计学上是显著的，但是它们已经足够有趣了，以至于我在所有的照片中都使用了压力脉冲。我还应该注意到，因为我不经常拉非断奏的镜头，所以我不太确定它的影响。从我在有压力脉动和没有压力脉动的情况下拍摄的非断奏照片来看，我没有注意到味道上的巨大差异。我怀疑的是在拍摄开始时提取率更高，但我没有数据支持这一说法。最近我还使用了更长时间的预输注，这是一个额外的变量。
我还有一些其他想探索的东西。我目前已经在数据表中添加了脉冲数以及预输注、开花和输注的时间。希望这能让我对压力脉动有更深入的了解。显然，如果我有一个压力计或 DE1Pro，我可以更好地控制和测量脉冲以及每个脉冲的压力峰值。同时，下面是我在研究压力脉动时想到的一系列实验:
- 每脉冲峰值压力
- 啁啾信号 vs 开/关
- 射击时间内的脉冲长度
- 预输注和压力脉动
总之，目前的证据表明压力脉冲(包括喷射脉冲)比恒压更好。关于手动机器的压力脉动的最好的部分是，它是一种容易应用和适应自己使用的方法；它不需要额外的硬件。
对于 Aurelia 波，我希望有人检查 1:1 输入/输出比下喷射脉冲的性能差异，因为我的实验表明提取受脉冲影响很大。
如果你愿意，可以在 Twitter 和 YouTube 上关注我，我会在那里发布不同机器上的浓缩咖啡照片和浓缩咖啡相关的视频。你也可以在 LinkedIn 上找到我。
扫一扫
728
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
