借助 Google Colab 自动化 Kaggle 竞赛
如何有效使用 colab 笔记本，创建 Kaggle 管道
当我开始研究 Kaggle 问题时，我在 Kaggle 笔记本上工作压力很大。在 Spyder 和 Jupyter 笔记本上工作过之后，我对在 Kaggle 上工作感到不舒服。在找出一些实用程序的过程中，比如增加 RAM、通过 API 加载数据、使用 GPU 等，我发现 Colab 解决方案更容易获得(也许这是 Google 的事情！).我在 Colab 中找到了一些简单的技巧，使使用 Colab 更容易，并创建了一个 Kaggle ML 管道来自动化这个过程。
Google Colab 是一个免费的 Jupyter/IPython 笔记本环境，不需要设置，完全在云中运行。
如何充分利用 Colab？
在创建一个新的 Python 笔记本后，确保将运行时类型更改为 GPU，您将分配到约 12.72 GB RAM 和英伟达特斯拉 P4 或英伟达特斯拉 K80 或英伟达特斯拉 P100 GPU 约 7.1 GB 作为 GPU。通过运行以下命令，可以将内存分配增加到大约 25.51 GB RAM，将 GPU 增加到大约 16 GB。
d=[]
while(1):
d.append('1')
上面的命令试图扩展(由于‘append’命令)RAM，并在此过程中崩溃。在上次内存分配崩溃后，点击“获取更多内存”。然后，您可以通过运行以下命令来检查分配的 GPU。
!nvidia-smi
Kaggle 管道:
我正在考虑 Kaggle IEEE-CIS 欺诈检测竞赛，我现在将一步一步地分解 colab 中一个典型的 Kaggle 机器学习管道。
1.从 API 调用下载数据集:
首先下载您的 API 令牌，方法是转到您的 Kaggle 我的帐户(https://www.kaggle.com/Your-Username/account))，转到“API”部分，然后单击“创建新的 API 令牌”。您现在将下载一个名为“kaggle.json”的文件。你必须把这个文件上传到你的笔记本上。
from google.colab import files
uploaded = files.upload()
您可以使用下面给出的代码来下载和解压缩数据集。
!mkdir -p ~/.kaggle
!cp kaggle.json ~/.kaggle/
!chmod 600 ~/.kaggle/kaggle.json
!kaggle competitions download --force ieee-fraud-detection
#Unzip the downloaded files
!unzip sample_submission.csv.zip
!unzip test_identity.csv.zip
!unzip test_transaction.csv.zip
!unzip train_identity.csv.zip
!unzip train_transaction.csv.zip
现在，您可以以最有效的方式访问大小约为 1.2 GB 的数据集。
2.预处理和数据争论:
使用熊猫，读取这种规模的数据集有时需要几分钟。为了有效地使用提供的 RAM 和 GPU，我们可以使用 dask 包在不到一秒的时间内读取这些大数据集！！
import dask.dataframe as dd
train_identity = dd.read_csv('train_identity.csv')
train_transaction = dd.read_csv('train_transaction.csv')
test_identity = dd.read_csv('test_identity.csv')
test_transaction = dd.read_csv('test_transaction.csv')
sub = dd.read_csv('sample_submission.csv')
# let's combine the data and work with the whole dataset
train = dd.merge(train_transaction, train_identity, on='TransactionID', how='left')
test = dd.merge(test_transaction, test_identity, on='TransactionID', how='left')
说到数据争论，我接着改变了必要的数据类型，并训练和测试数据分割。这可以根据他们的风格和舒适度来做。你可以通过 colab 为我进行数据角力的步骤。
3.特征工程和特征选择:
这可以根据数据集的类型来完成，自由地创建新的特征并使用特征选择技术，如递归特征消除、BORUTA、基于树的特征选择等。我在“SelectFromModel”的帮助下使用了“sklearn feature_selection ”,并使用“XGBClassifier”来进行特征选择。
4.模型构建:
我使用 XGboost 来拟合数据，使用 gridsearchCV 或 randomsearchCV 或贝叶斯优化等超参数技术来选择参数，这些超参数优化技术的详细版本将包含在以后的博客中。
5。提交文件:
在对测试数据进行验证之后，可以将 Kaggle 的进一步“提交数据”预测添加到管道中，以确保在预测之后下载文件。
请从这个 colab 检查详细的 Kaggle 管道，我在提交文件上收到了大约 0.93 的分数，运行管道的最短时间为大约 5 分钟。然后，我们可以通过更改参数网格和使用不同的模型(如 LightGBM、Catboost、Adaboost 等)来改进模型，从而实现自动化。
专业提示:
除此之外，如果您担心 colab 可能会断开连接，您可以通过在浏览器中单击 Ctrl+ Shift + i，运行下面的一小段 Javascript 代码。
**function** **ClickConnect**(){
console.log("Working");
document.querySelector("colab-toolbar-button#connect").click()
}**setInterval**(ClickConnect,60000)
结论:
处理 Kaggle 竞赛中提供的大型数据集可能是一个耗时的过程。如果我们可以有效地利用 google colab 笔记本来创建管道，那么我们就可以利用 dask 等并行计算库，并有效地使用 GPU 来加速和自动化数据建模过程。
参考资料:
使用 AWS Lightsail 自动化 python 脚本
请跟随我在 AWS Lightsail Ubuntu 实例上自动化 python 脚本的过程。
在我作为一名数据科学家的工作中，我逐渐意识到自动化工作流的每个方面是多么必要。当大多数人听到数据科学这些词时，他们往往会想到机器学习和 AI，但实际上数据科学家的大部分时间都花在了各种工作上。在这篇博客中，我将关注使用 AWS Lightsail 的数据收集自动化。
下面概述的项目都托管在我的 github 上
1.创建一个 AWS Lightsail Ubuntu 实例
2.将专用 IP 地址应用于实例
3.在 Ubuntu 实例上安装 Python3.7 和 PIP
4.将 python 存储库克隆到实例
- python 脚本将调用 reddit 的 api，并将来自 reddit.com/r/learnpython 的所有提交内容存储到一个 csv 文件中
5.创建每小时运行一次的 cron 作业
在亚马逊网络服务上创建一个 Ubuntu LightSail 实例
如果你是个人开发者或个人项目爱好者，Lightsail 可以帮助你部署和管理基本的云资源。如果你只是需要虚拟专用服务器，亚马逊 Lightsail 是最容易上手 AWS 的方法。Lightsail 包括快速启动项目所需的一切——虚拟机、基于固态硬盘的存储、数据传输、DNS 管理和静态 IP。创建实例后，您可以轻松地连接到它。您可以使用 Lightsail 控制台、Lightsail API 或 Lightsail 命令行界面(CLI)来管理实例。(【https://lightsail.aws.amazon.com/】T4)
首先，你需要在亚马逊 LightSail 注册。第一个月是免费的，这将给你足够的时间来决定这项服务是否是你所需要的。
登录后，您应该会看到 Lightsail 仪表盘。
Lightsail 仪表板
创建一个 Ubuntu 实例
1.单击“创建实例”按钮(上面圈出的)。
2.在 pick your instance image 下，选择 Linux/Unix
3.仅选择操作系统
4.选择 Ubuntu 18.04
创建 ubuntu 实例
5.选择您的实例计划:对于这个项目，我将使用最便宜的选项($3.50)，因为它足以运行大多数 python 脚本。还有，别忘了第一个月是免费的！
6.命名实例:对于这个项目，我将实例命名为“Ubuntu-Automation”
7.选择创建实例
选择创建实例后，您将返回到 AWS LightSail 仪表板。创建 Ubuntu 实例需要几分钟时间。创建实例时，状态将为“待定”,如下图所示:
待定创建
创建实例后，状态将变为“正在运行”。您还将看到分配给该实例的 IP 地址，对于我的实例，IP 地址是 3.227.241.208。此 IP 地址是动态的，每次重新启动实例时都会改变。根据您计划托管的项目，可能有必要设置一个静态 IP 地址。
Ubuntu 实例已创建并正在运行
创建一个静态 IP 地址
创建静态 IP 是可选的，只有在项目需要时才是必需的。我将创建一个静态 IP 地址，因为出于安全原因，我只向这个 IP 地址打开我的 SQL server。在初始设置之后，我更喜欢从我的本地机器 SSH 到 Ubuntu 实例，拥有一个静态 IP 使这个过程更容易。
1.在 Lightsail 仪表板中选择“网络”选项卡
2.点击“创建静态 IP”
网络仪表板
3.在“附加到实例”下选择您的 Ubuntu 实例服务器
4.给静态 IP 一个名称
5.点击“创建”
然后，您应该会看到新的静态 IP 地址。此 IP 地址不会改变。
向前迈进，我的静态 IP 地址将是 18.213.119.58，这是我将在这个项目的其余部分使用。
Python 自动化
对于这个项目，我将创建一个调用 Reddit API 的 python 脚本，并收集来自 reddit.com/r/learnpython.的所有新提交内容。对于本文的范围，我不会回顾这个特定的脚本是如何工作的，但是，你可以在 GitHubLink 查看所有代码。
使用 SSH 连接到 Ubuntu 实例
从 Lightsail dashboard 中，您可以使用基于 web 的 SSH 工具连接到您的 Ubuntu 实例。在初始设置之后，我更喜欢使用 SSH，因为它更简单，但是我确实发现使用基于 web 的工具更容易与我在这篇博客中回顾的设置进行交互。
终端 SSH 连接
在右上角选择帐户>帐户。这将带您到帐户仪表板，您可以在那里下载您的 SSH 密钥。
在 Lightsail 帐户面板中，选择“SSH 密钥”,然后下载。
- 在本地计算机上，导航到~/。通过运行命令 cd ~/来运行 ssh。嘘
cd ~/.ssh
- 将下载的密钥复制到此位置
- 要检查密钥是否已复制到该位置，请运行命令 ls 列出所有文件。(请注意，此方法仅适用于基于 Unix 的操作系统。)
ls
要通过 SSH 连接，请运行以下命令
ssh -i ~/.ssh/lightsail.pem -T ubuntu@{your_lightsail_IP_address}
我的 Ubuntu 服务器的 IP 地址是 18.213.119.58。为了连接，我将使用以下命令
第一次连接时，您会看到以下消息:
选择“是”连接到您的 Ubuntu 实例。
连接后，您将看到以下内容:
基于 web 的 SSH 连接和本地终端 SSH 连接都是有效的并且可以工作。我只是更喜欢通过终端连接。
在 Ubuntu 实例上获取 python 脚本
我将 python 脚本下载到 Ubuntu 实例的首选方法是通过 Git。
git clone [https://github.com/Landstein/AWS-Lightsail.git](https://github.com/Landstein/AWS-Lightsail.git)
(如果你的 ubuntu 实例上有你需要的配置文件，而你又不想让它托管在 github 上，你可以使用亚马逊的 S3 来传输)
安装 Python3.7 和 PIP
对于安装 Python 和 PIP，我建议通过 Lightsail 仪表板使用基于 web 的 SSH。
在存储库文件夹中运行以下命令，该命令将运行以下代码并安装 Python3.7 和 PIP。
bash install_python.sh
安装 Python 库
接下来安装 python 库 praw 和 pandas。运行批处理文件 python_libraries.sh。
Praw: Python reddit aPI 包装器
熊猫:数据处理和分析
bash python_libraries.sh
设置 Cron 作业
cron 软件实用程序是一个基于时间的作业调度程序，在类似 unix 的计算机操作系统中。设置和维护软件环境的用户使用 cron 来安排作业(命令或 shell 脚本)在固定的时间、日期或间隔定期运行。它通常会自动进行系统维护或管理——尽管它的通用性质使它在从互联网下载文件和定期下载电子邮件等方面非常有用(wikipeida.com)。
为了完全自动化这个过程，最后一步是让 cron 作业定期运行。
对于这个项目，我打算让我的脚本每小时运行 15 分钟。cron 命令将如下所示:
15 * * * * /usr/bin/python3 /home/ubuntu/AWS-Lightsail/learnpython_to_csv.py >> ~/cron.log 2>&1
如果你想尝试为你的 cron 任务设置不同的时间间隔，我建议你先看看https://crontab.guru/。
创建 Cron 作业
使用以下命令将编辑器设置为 vim
export EDIOTR=vim
进入 vim 并编辑 cron 作业
crontab -e
此时，VIM 将启动，您将能够编辑您的 cron 作业。
- 按 I 键进入插入模式
- 进入插入模式后，将 cron 作业复制并粘贴到编辑器中
- 按退出键
- 按:(冒号)、w(写)、q(退出)保存并退出 vim
:wq
现在您已经完成了，您的脚本将按照 cron 作业中给定的时间间隔运行。
要检查您的 cron 作业，您可以运行命令 crontab -l 来查看所有当前的 cron 作业。
crontab -l
出于日志记录的目的，打印语句和错误将存储在 cron.log 文件中。
cat cron.log
如果您看到类似的输出，这意味着一切都在工作！
cron.log
设置视频:
基于来自 Google BigQuery 的数据，在 Google Data Studio 中自动生成报告
来源:沉积照片
将报告配置为使用 Google App 脚本自动更新，并在 Data Studio 中可视化数据
关于使用 Google Data Studio
为那些还不知道数据工作室的人说几句:
- 首先，Data Studio 很方便，因为它有很多第三方服务的连接器。他们可以很容易地连接到几乎任何数据源。谷歌的原生连接器和其他公司开发的连接器都可用，例如 Yandex。度量，Yandex。目录、脸书、推特等。如有必要，您可以创建自己的连接器。
- 该服务易于使用，并且易于可视化数据。多个源可以连接到一个仪表板。
- 在 Data Studio 中与同事共享报告很容易，让他们能够查看或编辑报告。同事不需要获得授权，他们只需点击链接打开仪表板。
- 该工具的几乎所有功能都可以在免费版本中获得。
下面是 Data Studio 中的一个示例报告，其中包含一个在线商店的主要 KPI 和流量来源:
这是一个交互式控制面板，您可以在其中看到指标如何随时间、渠道、设备类别等发生变化。一份报告中可以有多页。这就是它如此方便的原因:一旦您设置了一个仪表板并与同事共享了一个链接，那么就不需要再做任何更改了(除非您添加了新的参数)。只要选择正确的日期，获取最新的信息。
现在让我们来解释一下如何才能创造出这样的美。我们基于来自 Google BigQuery 的数据构建报告，该报告将根据指定的时间表自动更新。
第一步。从 Google BigQuery 收集数据
BigQuery 有现成的库和连接器，可以让你从 CRM 系统上传交易、客户和项目信息到云存储。OWOX BI 将帮助您自动收集 GBQ: 中的所有其他数据
- 用户在网站上的行为(未采样的实时数据)。
- 广告服务的成本数据。
- 来自通话跟踪系统的通话和聊天数据。
- 来自电子邮件服务的电子邮件信息。
将不同来源的数据合并到 BigQuery 后，您需要:
- 使用 SQL-query 选择您希望在报告的单独表格中看到的指标。
- 使用 Google App 脚本设置一个规则来更新此表中的数据。
- 在 Data Studio 中，将表与 GBQ 中的数据连接起来，并将其可视化。
用 OWOX BI 组合数据和自动生成报告的示意图如下:
第二步。在 Google BigQuery 中准备一个包含报告数据的表格
我们没有详细描述这些指令，因为我们假设您熟悉 Google BigQuery 接口。如果您需要复习如何处理表创建，请查看这篇文章:Google 中的 BigQuery 数据结构:如何开始使用云存储。
为了节省 Google BigQuery 资源，我们建议您首先创建一个 SQL-query 来生成一个表，其中包含您在特定时间段内需要的一组参数和指标:
进行查询并将结果保存为单独的 BigQuery 表:
然后创建一个视图，只在更短的时间内计算相同的指标。例如，您创建了一个十二月的源表。然后，每天视图将请求昨天的数据并将其添加到表中。
为此，运行另一个查询并单击保存视图:
第三步。创建自动更新表格的应用程序脚本
现在您需要创建一个脚本，该脚本将自动启动视图并将更新后的数据从视图发送到源 BigQuery 表。
为此，打开 Apps 脚本，单击创建脚本，命名它，并编写以下代码，用您自己的表替换项目名称、数据集和 BigQuery 表。
填写表格，在您的电子邮件中获得代码的全文
然后单击时钟图标设置脚本运行的时间表。单击右下角的添加触发器按钮。选择时间触发事件源，指定所需的运行频率，然后单击保存。
准备好了！现在，GBQ 表中的数据将根据指定的时间表进行更新。
第四步。在 Google Data Studio 中创建报告
进入 Data Studio 主页，点击左上角的 New，选择 Report。然后点击右下角的 Create Data Source 并选择 BigQuery:
然后指定包含报告数据的项目、数据集和 GBQ 表，并单击右上角的链接:
在打开的窗口中，您将看到存储在连接表中的所有参数和指标，您可以使用这些参数和指标。在这里，如果需要，您可以通过单击右侧指标来重命名它们。
您还有机会创建自己的定制指标。使用“添加字段”按钮和公式(如果您单击问号，会出现帮助):
定义字段后，单击右上角的“添加到报告”按钮:
然后选择可视化工具(图形类型)，并在操控板上突出显示要放置它的区域。
控制面板在右侧打开，您可以根据需要定制报告:添加用于比较的参数、定制过滤器、日期范围、仪表板样式等。
然后剩下的就是使用 Grant Access 按钮与同事共享报告。
使用来自 Google BigQuery 的数据自动生成 Google Sheets 中的报告
来源:沉积照片
如何基于来自 Google BigQuery 的数据设置自动更新和发送 Google Sheets 中内置的电子邮件报告
为什么要 Google BigQuery？
在我们谈论设置之前，对于那些不熟悉云存储服务的人来说，先说几句 Google BigQuery 的特性和好处。
Google BigQuery 的优势:
- 快速云解决方案，让您能够在几秒钟内处理数 TB 的数据
- 适合小型和大型公司
- 经济高效且易于扩展
- 不需要服务器、容量预留和维护
- 透明的定价策略—只为处理的数据付费，没有隐藏的费用
- 数据处理的灵活性——用 SQL 访问包含数据的表，还可以使用 JavaScript 函数
- 可靠性和安全性得到了众多证书的证实——PCI DSS、ISO 27001、SOC 2 和 SOC 3 Type II——因此您可以安全地存储客户的信用卡号、电子邮件地址和其他个人信息
易于自动化数据交换
Google BigQuery 的另一个值得强调的特性是它与外部服务的方便集成。该存储库有大量现成的库和连接器，使得自动化数据交换变得容易。例如，使用 OWOX BI ，你可以从谷歌分析、广告源、电话跟踪服务、电子邮件简讯等导入数据。into BigQuery:
以下是使用 BigQuery 的一些更有用的工具:
BigQuery 数据传输服务
BigQuery 最近推出了一款数据传输服务工具，可以自动传递来自谷歌广告服务的数据。它目前使用以下服务:
- 谷歌广告
- 活动经理
- 谷歌广告经理
- 油管（国外视频网站）
您可以通过几次点击来设置集成，之后来自这些服务的所有信息都会自动在 BigQuery 中提供给您。
在 Google BigQuery 中组合数据
要基于完整的数据构建报告并实现自动化，您需要在 BigQuery 中组合来自不同来源的数据。这里有一个如何做到这一点的例子:
- 首先，在谷歌分析中从你的网站收集数据。
- 使用 Google Sheets 从其他来源补充信息。
- 添加来自广告服务的成本数据——例如，通过 OWOX BI。
- 将所有这些数据导入 BigQuery。如果您是 Google Analytics 360 的客户，您可以使用 BigQuery 导出功能来完成这项工作。如果你没有 Google Analytics 360，你可以连接 OWOX BI，用它将数据从 Google Analytics 导入 Google BigQuery。
- 将信息从你的 CRM 和 ERP 系统转移到 BigQuery 并与你网站的数据相结合。
- 同样在 BigQuery 中，从任何种类的 Google Sheets 下载更多信息
- 如果您使用通话跟踪，请将通话和聊天数据上传到 BigQuery。OWOX BI 集成了五种通话/聊天服务。
- 对电子邮件时事通讯做同样的事情。
- 最后，使用数据传输服务，它从 Google 和 YouTube 广告服务导入数据
使用 OWOX BI BigQuery 报表附加组件
在您组合了 Google BigQuery 中的所有数据，通过一个关键参数将其链接起来，并构建了必要的报告之后，您可以自动将这些报告上传到 Google Sheets。为此，请使用 OWOX BI BigQuery Reports 插件。它类似于 Google Analytics Sheets 插件，但是需要 SQL 语法知识。要在 BigQuery 中访问数据，您需要构建一个 SQL 查询，之后您将在 Google Sheets 中看到所需结构的数据。
如何基于 Google BigQuery 数据在 Google Sheets 中创建报告
首先，在你的 Chrome 浏览器中安装 BigQuery Reports 插件。为此，打开一个 Google Sheets 文档，转到 OWOX BI BigQuery Reports 选项卡，并选择 Add a new report。
如果这是你第一次使用这个插件，你需要提供你的 Google BigQuery 帐户的访问权限。
图片由作者提供
之后，指定您想要在报告中查看其数据的项目。然后从下拉列表中选择一个 SQL 查询(如果您之前创建了查询)，或者通过单击“添加新查询”添加一个新查询。
图片由作者提供
您可以立即在 SQL 查询中将先前指定的动态参数添加到报表中。选择报告的日期，并通过单击“添加并运行”按钮运行查询。
此时，附加组件将在 BigQuery 中访问您的数据并执行计算。然后，在您的表中，将出现一个单独的工作表，其中包含查询结果。
现在您可以可视化这些数据，创建数据透视表，等等。
图片由作者提供
基于 BigQuery 数据自动更新报告
为了避免每次需要数据时都必须手动运行查询，您可以设置一个计划报告。为此，请转到附加组件–> OWOX BI big query 报告–>计划报告。
选择报告更新的频率(每小时、每天、每周或每月一次)。然后指定开始 SQL 查询的时间。如有必要，激活电子邮件提醒以更新报告。保存设置。
图片由作者提供
完成了。现在，您的报告将根据设定的计划自动更新。
使用 Google App 脚本通过电子邮件发送报告
最后，为了不错过 KPI 中的重要变化，您可以使用 Google App Script 配置通过电子邮件发送报告。
首先，让您的开发人员准备一个脚本，其中包含电子邮件地址和发送消息的条件，可以是定期发送，也可以是响应特定指标的重要更改。
您可以将此代码用作模板:
// Send an email with two attachments: a file from Google Drive (as a PDF) and an HTML file.
**var** file = DriveApp.getFileById('abcdefghijklmnopqrstuvwxyz');
**var** blob = Utilities.newBlob('Insert any HTML content here', 'text/html', 'my_document.html');
MailApp.sendEmail('mike@example.com', 'Attachment example', 'Two files are attached.', {
name: 'Automatic Emailer Script',
attachments: [file.getAs(MimeType.PDF), blob]
});
你可以阅读谷歌帮助中的开发者指南，了解更多关于如何构建这些代码的信息。
然后在表格中打开您需要的报告，进入工具–>脚本编辑器。将会打开一个新窗口，您需要在其中粘贴脚本。
单击时钟图标，设置脚本启动的时间表。现在点击右下角的+添加触发器按钮。然后选择事件源—时间触发器，并从列表中选择通过电子邮件发送报告的频率。最后，单击保存。
搞定了。现在，报告将会发送到您的电子邮件中，您不会错过任何内容，并且能够及时对您的营销活动进行更改。
用 Python 和 Gmail 发送电子邮件
用几行代码发送电子邮件
这篇文章将解释如何在 Google 帐户中设置应用程序密码，并使用 Python 在几行代码中发送电子邮件，用于自动报告、测试自动化或 CI/CD 故障通知等。
Google 帐户设置
要使用 Gmail 帐户通过第三方应用程序(如 Python 脚本)发送电子邮件，我们需要设置应用程序密码。出于安全原因，普通 Gmail 密码仅限于网络登录。从 2020 年开始，即使你打开了谷歌账户中的“不太安全的应用访问”选项，也无法使用 Python 脚本中的普通密码登录你的 Gmail 账户。
首先，您需要启用两步验证。只需进入您的 Google 帐户>安全>登录 Google，选择两步验证并按照说明进行操作。
启用两步验证
接下来，创建一个应用程序密码。只需选择“两步验证”下的“应用程序密码”，您将看到如下窗口。在“选择应用程序”下拉列表中选择“其他”。
应用程序密码/步骤 1
输入一个名称，例如 Python，然后单击“生成”。请注意，该名称与 Python 脚本没有任何联系，可以是任何名称。
应用程序密码/步骤 2
然后你会得到一个新的应用程序密码。复制并保存不带空格的 16 字符密码，例如 xnwbjmgvjeeevlgc，以便在 Python 脚本中使用。
应用程序密码/步骤 3
用 yagmail 发送电子邮件
yagmail 是 Python 标准库 smtplib 的包装器，使得发送邮件变得非常容易。
要在 Python 中安装 yagmail，只需运行pip install yagmail。
下面是发送带有两个附件的电子邮件的示例脚本。
这段代码非常简单，不言自明，所以几乎不需要任何解释。除了您的 Gmail 用户名和应用程序密码，您只需定义收件人、主题和内容，就像从 web Gmail 写电子邮件一样。内容是一个列表，第一个元素是正文部分，其余是附件。在本例中，我们从脚本所在的同一文件夹中附加了“pytest.ini”和“test.png”。
要运行这个脚本，只需在任何平台上运行python send_gmail_by_yagmail.py，Windows、Linux 或 MacOS。您将在收件人帐户中收到一封电子邮件，如下所示。
示例电子邮件
要发送一组收件人，只需将“收件人”更改为一个列表。
to = [‘user1@gmail.com’, ‘user2@yahoo.com’]
注意，yagmail 默认使用 gmail SMTP 服务器，你可以显式定义 SMTP 服务器和端口。
host = 'smtp.gmail.com'
port = 465
with yagmail.SMTP(user, password, host, port) as yag:
使用 Python 标准库
我们也可以使用 Python 标准库，不需要安装任何额外的包来发送邮件。
首先，我们导入标准的 email 和 smtplib 包，并定义相关的变量。
- Gmail 用户名和应用程序密码
- Gmail 主机和端口
- 到
- 科目
- 正文内容
- 附件
标准库/第 1 部分
其次，我们用上面的信息定义一个电子邮件对象。消息被定义为 MIMEMultipart，这样我们可以添加附件，每个部分都是一个 MIMEText 对象，它也支持二进制文件。
标准库/第 2 部分
最后，我们调用 smtplib 登录并发送消息。
标准库/第 3 部分
你可以在这里找到完整的脚本 send_gmail_standard_lib.py 。当然要运行，只需输入python send_gmail_standard_lib.py。
Python 3.6+中的变化
上面两个例子支持 Python 3.5 甚至更低版本。Python 3.6 中引入了新的 EmailMessage API 来定义电子邮件。更多细节可以参考最新的文档和一个例子这里。
常见问题解答
在非英语 Windows 操作系统上，您可能会遇到如下 UnicodeDecodeError 错误。
server = smtplib.SMTP_SSL(smtp_host, smtp_port)
File "C:\Program Files (x86)\Python37-32\lib\smtplib.py", line 1031, in __init__
source_address)
File "C:\Program Files (x86)\Python37-32\lib\smtplib.py", line 261, in __init__
fqdn = socket.getfqdn()
File "C:\Program Files (x86)\Python37-32\lib\socket.py", line 676, in getfqdn
hostname, aliases, ipaddrs = gethostbyaddr(name)
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc3 in position 2: invalid continuation byte
这似乎是 Python smtplib 模块的一个 bug。原因是您的计算机名包含非英语字符。因此，解决方法是简单地用英文字符重命名您的计算机名。
参考
https://github.com/kootenpv/yagmail
https://mp.weixin.qq.com/s/AMYeOiMX7URc_PFczqQ-5Q
https://docs.python.org/3/library/smtplib.html
https://docs.python.org/3/library/email.html
Reddit Post: TextBlob 和 VADER 的自动化情感分析流程
使用 VADAR 和 TextBlob python 库找到 Reddit 子群的情绪
被困在付费墙后面？阅读这篇文章，我的朋友链接在这里。
你有没有想过如何从一个用户的评论中找到一个 subreddit 的情绪？或者想在加入之前检查不同主题的 subreddit 极性？如果你正在寻找这些问题的答案，那么这篇文章将会给你很大的帮助。在这篇文章中，我们将发现 subreddit 的整体情绪。
这里给不知道什么是 subreddit 和 reddit 的人解释一下。
Reddit 是一个社交分享网站，它分为更小的社区，称为子社区。subreddit 只是一个专门讨论特定主题的板块。
用户，Reddit 的组成部分，加入这些社区并提交他们的想法和经验。然后，其他用户通过对这些想法的评论来表达他们的观点。
开始了解情绪分析所需的库:
1.PRAW
Reddit 提供了一个 API 来从他们的站点获取信息。我们将使用 Python 库 PRAW 与 Reddit API 进行交互。
2.VADER
VADER (Valence Aware 字典和情感推理器)是一个基于词典和规则的情感分析工具，专门针对社交媒体中表达的情感。我们将使用 VADER 对 Reddit 评论和话题进行情感分析。
3.文本 Blob
TextBlob 是一个用于处理文本数据的 Python 库。它为自然语言处理(NLP)任务提供了一个 API，如词性标注、名词短语提取、情感分析、分类、翻译等。
注意:代码的最终版本可以在本文末尾找到。
让我们导入这些库
import praw
from textblob import TextBlob
# VADER can be accessed by the NLTK library.
import nltk
# Download the VADAR tool and access it through the NLTK library.
nltk.download(‘vader_lexicon’)
from nltk.sentiment.vader import SentimentIntensityAnalyzer
在我们开始收集情绪分析数据之前，我们需要创建一个 Reddit 应用程序。访问此页面创建一个应用程序，并获取所需的身份验证和详细信息。
reddit_api = praw.Reddit(client_id=’my_client_id’,
client_secret=’my_client_secret’,
user_agent=’my_user_agent’)
Reddit_api 对象与 Reddit API 建立连接。我们将使用它的函数获取帖子和评论等子编辑信息。
我们使用 showerthoughts subreddit 来获得前 5 名每周帖子的数据。如果您想检查其他子编辑的极性，只需用您的子编辑名称替换 showerthoughts 即可。
top_posts = Reddit.subreddit(‘showerthoughts’).top(‘week’, limit=5)
此外，我们可以用小时、月和年来代替周。该限制将帖子限制为 5 个。有关 Reddit API 配置的更多信息，请访问本页。
下一步是获取每个子编辑中的数据:文章标题、评论和回复。subreddit 上的帖子分为两部分，标题和评论部分。有些标题有一小段描述，代表文章作者的观点。大多数投票的评论及其回复显示在评论区的顶部。
标题部分的实现
for submission in top_posts:
print("Title of the post :", submission.title)
注释部分的实现
我已经使用递归复制了 subreddit 帖子的整个评论部分。
def replies_of(top_level_comment,
count_comment,
sub_entries_textblob,
sub_entries_nltk):
if len(top_level_comment.replies) == 0:
count_comment = 0
return
else:
for num, comment in enumerate(top_level_comment.replies):
try:
count_comment += 1
print(‘-’ * count_comment, comment.body)
text_blob_sentiment(comment.body,
sub_entries_textblob)
nltk_sentiment(comment.body, sub_entries_nltk)
except:
continue
replies_of(comment,
count_comment,
sub_entries_textblob,
sub_entries_nltk)
Reddit 帖子的标题和评论部分
情感分析所需的子编辑数据现已可用。我们将在 TextBlob 工具中传递数据，并获取情绪。
def text_blob_sentiment(review, sub_entries_textblob):
analysis = TextBlob(review)
if analysis.sentiment.polarity >= 0.0001:
if analysis.sentiment.polarity > 0:
sub_entries_textblob[‘positive’]=
sub_entries_textblob[‘positive’]+1
return ‘Positive’
elif analysis.sentiment.polarity <= -0.0001:
if analysis.sentiment.polarity <= 0:
sub_entries_textblob[‘negative’]=
sub_entries_textblob[‘negative’] + 1
return ‘Negative’
else:
sub_entries_textblob[‘neutral’]=
sub_entries_textblob[‘neutral’] + 1
return ‘Neutral’
TextBlob 的所有函数都可以从分析变量中访问。我们将使用 analysis .情操来了解句子的极性得分。根据极性得分，我们将句子分为阳性、阴性和中性。所有句子的情感已经被统计并存储在变量 sub_entries_textblob 中。
对 VADER 工具遵循相同的过程，传递数据，并将情感存储在 sub_entries_nltk 中。
sia = SentimentIntensityAnalyzer()
def nltk_sentiment(review, sub_entries_nltk):
vs = sia.polarity_scores(review)
if not vs[‘neg’] > 0.05:
if vs[‘pos’] — vs[‘neg’] > 0:
sub_entries_nltk[‘positive’]=
sub_entries_nltk[‘positive’] + 1
return ‘Positive’
else:
sub_entries_nltk[‘neutral’]=
sub_entries_nltk[‘neutral’] + 1
return ‘Neutral’
elif not vs[‘pos’] > 0.05:
if vs[‘pos’] — vs[‘neg’] <= 0:
sub_entries_nltk[‘negative’]=
sub_entries_nltk[‘negative’] + 1
return ‘Negative’
else:
sub_entries_nltk[‘neutral’]=
sub_entries_nltk[‘neutral’] + 1
return ‘Neutral’
else:
sub_entries_nltk[‘neutral’]=sub_entries_nltk[‘neutral’] + 1
return ‘Neutral’
我们可以使用 sia 对象访问 VADER 函数。sia.polarity 将一个句子作为输入，并将情感得分作为输出。从 nltk _ 情操()句子分类成积极，消极和中性的情绪。
如果您打印 sub_entries_nltk 和 sub_entries_textblob 变量，我们将获得正面、负面和中性情绪的总数。从计数中，我们将得出子涡旋的总体极性。
结论
在本文中，人们可以学习如何使用 PRAW python 库从 Reddit 获取信息，并发现 subreddit 的观点。此外，了解文本块和 VADER 工具是如何轻松实现情感分析的。这篇文章帮助你复制 subreddit 帖子的整个评论部分，并附上每个评论及其回复。
作者其他文章
这是完整的代码
自动化枯燥的工作:如何从命令行创建并打开一个名为 Jupyter 的笔记本
今天我醒来，我意识到即使我喜欢自动化事情，我还是不断重复下面的行为:
- 我决定开始一项新实验。
- 我在终端上运行 jupyter-notebook 。
- 我在仪表板中创建了一个新笔记本。
- 我给笔记本重新命名。
- 我开始黑。
我一直想输入jupyter-notebook experiment . ipynb，然后出现一个命名的笔记本。这将为我节省大约 10 秒钟的宝贵时间，我可能会用这些时间来研究更多关于冠状病毒的数字！
因此，这里有一个在你的生活中永远不要给笔记本重新命名的快速方法。它在 MacOs 和 Linux 上运行得非常好，你也可以在 Windows 上做类似的事情。
- 打开您的 bash 个人资料。我的位于/。*bash*RC(“”自动展开到你的主目录)。
- 将以下代码添加到文件的底部:
new-notebook() {
echo "{
\"cells\": [],
\"metadata\": {},
\"nbformat\": 4,
\"nbformat_minor\": 2
}" > $(pwd)/$1
jupyter-notebook $(pwd)/$1
}
3.关闭并重新打开终端，或者运行 source ~/.bashrc. 这将让您开始使用刚刚创建的函数。
全部完成！资料来源:亚历山大·奈特(CC0)
如果您键入new-notebook example . ipynb，它将在当前工作目录中创建一个同名的新笔记本，并立即打开它。
请注意，该命令假设您将包含**。文件名中的 ipynb** 扩展名。如果您想避免这样做，只需修改函数代码，如下所示:
new-notebook() {
echo "{
\"cells\": [],
\"metadata\": {},
\"nbformat\": 4,
\"nbformat_minor\": 2
}" > $(pwd)/$1.ipynb
#or maybe 'jupyter-notebook', if that's what you use
jupyter-notebook $(pwd)/$1.ipynb
}
重新激活 bash 概要文件后，您现在可以使用该命令，例如，使用 new-notebook example2 。
一个建议:我建议不要尝试使用 jupyter-notebook 作为命令名。一方面，我发现的唯一重载 bash 函数的技巧相当令人讨厌，可以说**最少*。另一方面，如果我们不乐观，重载 jupyter-notebook 命令的意外行为可能会导致数据丢失。为了安全起见，最好用一个新名字！*
学到了什么？单击👏说“谢谢！”并帮助他人找到这篇文章。
利用 Sklearn 管道实现机器学习模型的自动化
在本教程中，我们将了解如何加快机器学习算法开发中的模型实现步骤。
在 Unsplash 上由 Hitesh Choudhary 拍摄的照片
很多时候，在处理机器学习问题时，我们会遇到这样的机器学习任务，我们希望预处理我们的数据，并用不同的分类器测试我们的模型，以选择最佳的一个。在这种情况下，在训练数据上单独拟合每个分类器，然后测试模型是非常繁琐的，更不用说还涉及到大量的冗余编码。此外，如果您的算法涉及交叉验证，并且您的预处理步骤涉及规范化或标准化等操作，则在学习之前对完整的训练集执行规范化或标准化将会影响测试集的规模。如果所有这些问题都有一个单一的解决方案，那不是很好吗？
嗯，有！Scikit-Learn 有一个管道模块，它提供了解决上述问题的简单方法。
Pipeline 是一个按顺序应用一系列变换和一个最终估计器的函数。管道的目的是组装几个步骤，这些步骤可以在设置不同参数的同时进行交叉验证。
现在让我们来看一个实现，它将展示我们如何使用管道来简化手头的任务。
在这里，我将使用 Iris 数据集，将其标准化，并测试分类器的数量，以查看哪一个给出了最佳结果。在这里，我将使用 KNN、SVM、随机森林和逻辑回归来测试算法。
首先，我们需要导入所有需要的模块。
现在，我们将从 Scikit-Learn 导入 Iris 数据集，并将其分成训练集和测试集。
接下来，我们将从 Scikit-Learn 中列出分类器名称及其各自的功能。最后，把它们连在一起。这一步将确保我们将所有分类器连同它们的名称一起一次性传递给我们的管道函数。
这里需要注意的一点是，我们将为所有分类器的所有超参数选择默认值。
现在，我们将定义将分类器的 zip 以及训练和测试数据作为输入的函数，准备带有分类器的 Standardscalar 管道，并将管道的结果馈送到我们稍后将定义的 fit_classifier() 函数。
最后，我们定义前面提到的 fit_classifier() 函数。该功能接收管道和列车测试数据。它用 pipeline.fit() 拟合管道来训练数据，计算预测和准确度分数。
现在是时候测试我们的算法了。
运行上面的行之后，我们得到以下结果。
分类器和准确度分数
最后，我们将看到分类器及其各自的准确度分数。
上面的运行给出了以下结果。
决赛成绩
你有它！我们刚刚看到 Scikit-Learn 的管道功能如何让生活变得更简单。
如果你觉得有用，不妨在这里 多看看我的文章 。
如果你有什么建议，请在评论里告诉我。
自动化这 3 个(无聊！！)用 Python 做 Excel 任务！
不用再打开数百个 Excel 文件
让我们来学习如何自动化一些枯燥的 Excel 任务！资料来源:Nik Piepenbreier
Excel 无处不在。无论好坏，它基本上是工作场所中数据分析的默认应用程序。在你的日常生活中，你可能需要完成许多无聊的任务，这让你思考，“一定有更好的方法”。Python 在那边！
所有这些例子在 VBA 都是可能的，但是 VBA 可能很乏味，嘿，我们喜欢 Python！
合并多个 Excel 文件
让我们将多个 Excel 文件合并成一个文件！资料来源:Nik Piepenbreier
您可能会发现自己有许多 Excel 工作簿(例如每月销售报告)。有一天，你被要求计算所有这些报表的总销售额。我们可以使用 Pandas 库轻松地将 Excel 工作簿与 Python 结合起来。
您可以使用 pip 或 conda 安装 Pandas:
pip install pandas
conda install pandas
对于本教程，让我们加载三个独立的 Excel 工作簿，它们链接到下面:
- 文件一:https://github . com/datagy/medium data/raw/master/January . xlsx
- 文件二:https://github . com/datagy/medium data/raw/master/junior . xlsx
- 文件三:【https://github.com/datagy/mediumdata/raw/master/march.xlsx
我们可以看到数据直到第 4 行才真正开始，所以我们需要 Pandas 从那一行开始导入工作表。在下面的代码中，我们将使用 read_excel 和 append 函数。
将 Excel 文件与 Python 相结合。资料来源:Nik Piepenbreier
让我们看看我们在这里做了什么:
- 在第 1 部分中，我们导入了 pandas，创建了一个包含所有 URL 的列表，并生成了一个名为 combined 的空白数据帧。
- 在第 2 节中，我们遍历了文件中的每个 URL，将每个文件读入一个数据帧(“df”)，跳过前三行，并将其附加到组合的数据帧中。
- 在第 3 节中，我们编写生成一个名为 combined.xlsx 的新 Excel 文件，其中包含我们合并的 Excel 工作簿！
从各种工作簿中获取值
使用 Python，很容易从多个文件中获得任何值！资料来源:Nik Piepenbreier
我们再来看另一个例子！假设我们只需要从每个销售报告中获得多伦多的总数，并将它们收集到一个列表中。我们知道总数存储在每个工作簿的单元格 F5 中。如果您正在跟进，如果您将文件存储在本地，这个包就可以工作。用上面的链接下载文件并保存到你的机器上。
对于这个例子，我们将使用另一个名为 openpyxl 的库。您可以使用以下代码安装 pip 或 conda:
pip install openpyxl
conda install openpyxl
让我们开始编码吧！
用 Python 从多个工作簿中获取单元格。资料来源:Nik Piepenbreier
让我们一步一步地分解它:
在 Windows 中复制文件路径。资料来源:Nik Piepenbreier
在第 1 节中，我们:
- 生成了一个包含所有文件链接的列表(“文件”)。在 Windows 中，我们可以按住 Shift 键并单击鼠标右键，然后使用“复制为路径”来获取它的路径。
- 您可能希望将字符串转换为原始字符串，方法是在它前面加上前缀“r”。
- 我们还生成了一个空列表来存储我们的值。
在步骤 2 中，我们
- 使用 openpyxl 遍历文件。
- 的。load_workbook()方法加载一个文件。
- 我们使用[‘Sheet1’]和[‘F5’]来引用工作簿和工作表对象中的工作表名称和单元格引用。
- 最后，我们使用。value 属性提取单元格的值，并将其追加到值列表中。
在工作簿中应用公式
让我们在多个工作簿中应用相同的公式！资料来源:Nik Piepenbreier
让我们看看最后一个例子！在每个 Excel 工作簿中，我们都有跨行的汇总，但没有销售额的总计。同样，我们可以打开每个工作簿并添加一个公式，或者我们可以使用 Python 来完成这项工作！
我们将再次使用 openpyxl。如果您需要安装它，请查看上面的说明。上面也有下载文件的链接。
在工作簿中插入公式！资料来源:Nik Piepenbreier
在这段代码中，我们再次填充了一个文件列表。for 循环打开每个文件，并将“Sheet1”分配给一个变量 Sheet。
然后，我们将字符串’ =SUM(F5:F8)'赋给单元格 F9，并使用。属性将货币样式直接分配给单元格。更多单元格样式可在官方文档中找到。
结论:用 Python 自动化 Excel
Python 使得使用 Excel 文件变得非常容易！在本文中，我们学习了如何组合各种 Excel 文件、获取特定值以及在工作簿中添加公式。
让我们使用 Python 创建可追踪的、可复制的代码，让我们复制我们的分析设计。虽然您可能一整天都在使用 Excel 工作簿，但是 Python 可以自动完成一些随之而来的繁琐任务。
使用 Airflow 自动将云 SQL 数据同步到 BigQuery
使用私有 IP 连接和云 SQL 代理保护您的数据和工作负载
斯科特·韦伯在 Unsplash 上拍摄的照片
如果你正在使用 GCP (Google Cloud Platform)来存储你的数据，很可能你正在使用 BigQuery 作为你的数据仓库或者数据湖解决方案(或者作为它的一部分)。存储交易数据的一些解决方案包括数据存储、云扳手和云 SQL。在许多情况下，尤其是从本地迁移到 GCP 时，云 SQL 是事务性数据的自然选择，因为它提供了托管 MySQL 和 PosgreSQL。
有许多方法可以将云 SQL 数据同步到 BigQuery。一个解决方案是使用带有云 SQL BigQuery 特性的联邦查询。尽管这种解决方案具有速度快、成本低的优势，但它至少有一个限制:还不可能将云 SQL 联邦查询与私有云 SQL 实例一起使用，这意味着留给您的是不太安全的公共实例。本文介绍了一种高度安全、自动化和生产就绪的方式，将您的云 SQL 数据导入 BigQuery。
你会得到什么
在本文结束时，您将获得
- 在 GCP 上构建云 SQL 数据同步到 BigQuery 工作流的详细分步指南。
- 访问包含用于构建工作流程的所有材料的 gitlab 存储库。您将能够使用存储库代码作为实现您自己的数据同步工作流的起点。
你需要跟进什么
这篇文章对于至少对 GCP 有基本了解的读者来说是最有价值的。如果你想知道这三个字母代表什么，我建议你花点时间在这里好好了解一下 GCP。我还假设你接触过阿帕奇气流和库伯内特斯。如果不是这样，你可以在 Udemy 上查看这篇优秀的气流介绍。你也可以在这里找到 Kubernetes 的快速入门。
要跟进，你需要的是一个 GCP 项目。如果你没有可用的项目，或者如果你只是想在现有项目中不产生任何费用的情况下尝试一下，你可以创建一个新的谷歌账户，并使用该账户创建一个免费的 GCP 账户和项目。
你会做什么
在接下来的几分钟内，您将:
- 设置 Apache 气流
- 创建云 SQL 实例
- 设置 Airflow 和云 SQL 之间的私有连接
- 创建大查询数据集
- 编写和部署数据同步任务
- 将新的模拟数据插入云 SQL
- 监控同步任务
设置 Apache 气流
请记住，Airflow 是一种工具，其目的是协调、自动化和监控批处理作业。在我们的上下文中，实际的同步工作是通过调用 GCP API 来完成的，我们将在 编写和部署数据同步任务 时看到。
在 GCP 上安装 Airflow 有很多选择，包括在谷歌计算引擎或谷歌 Kubernetes 引擎上定制安装。在这里，我们部署了一个 Google Cloud Composer 环境资源，它提供了一个 GKE 集群(以及其他 GCP 资源),并在该集群上安装了 Airflow。
要创建部署，请执行以下操作:
-
打开您的云 shell，并将其配置为使用正确的 GCP 项目。将<project_id>替换为您打算使用的 GCP 项目的 ID:</project_id>
-
如果适用，启用编写器 API(这可能需要 2 分钟)
-
创建一个名为“cloud-composer”的服务帐户，并为其指定角色“roles/composer.worker”、“roles/cloudsql.client”、“roles/bigquery.user”和 roles/bigquery.dataEditor。
-
使用 VPC 本地和专用 GKE 集群创建名为“data-synchronization-env”的 composer 环境。请耐心等待，直到 设置好气流和云之间的私有连接 SQL 我会在这里详细介绍一下 VPC 本地和私有 GKE 集群。为环境分配“cloud-composer”服务帐户。分配给服务帐户的云 SQL 和 BigQuery 角色由 Airflow 用来读取云 SQL 数据库和创建 BigQuery 同步表。
大约 30 分钟后，您的 cloud composer 环境应该在 GCP 项目的默认 VPC 网络中启动并运行。
创建云 SQL 实例
我们的云 SQL 到 BigQuery 同步架构的主要优势之一是，它实施了安全最佳实践。实际上，我们将使用私有实例，而不是为云 SQL 数据库使用公共实例。
在创建私有云 SQL 实例之前，我们需要在 GCP 项目中的 VPC 网络(这里我们选择“默认”VPC 网络)和云 SQL 实例所在的 VPC 网络之间创建一个 VPC(虚拟私有云)对等连接。“默认”网络上的实例将能够使用该 VPC 对等连接连接到私有云 SQL 实例。要了解更多关于创建云 SQL 私有实例的信息，请查看这个。
以下四个命令创建一个云 SQL MySQL 私有实例:
-
如果适用，启用服务网络 API
-
创建一个地址范围，并使用它来创建 VPC 对等连接。用您的项目 id 替换<project_id>(这可能需要 1 分钟)。</project_id>
-
创建云 SQL 私有实例
为了能够连接到 SQL 实例，让我们创建一个云 SQL 用户。我还将创建一个数据库，我们将在本文后面将其同步到 BigQuery。
-
创建云 SQL 实例用户，用适当的值替换<user_name>。主机“cloudsqlproxy~%”的值使得无法从云 sql 代理服务器进程之外的其他地方连接到用户<user_name>的实例。</user_name></user_name>
-
在云 SQL 实例中创建一个数据库。称这个数据库为“经典模型”
-
从其 sql 转储文件中导入流行的‘classic models’数据库。为此，我们首先创建一个 GCS bucket。为了方便起见，用您的 GCP 项目的名称来命名这个存储桶。
-
复制 GCS (Google 云存储)中的 sql 转储文件。
-
检索云 SQL 实例正在使用的服务帐户:注意“serviceAccountEmailAddress”字段的值
-
将存储桶“cloudsql-to-bigquery”上的 storage.objectAdmin 角色授予该服务帐户。用上一步中检索到的电子邮件地址替换<service_account_email_address></service_account_email_address>
-
执行转储文件导入
设置 Airflow 和云 SQL 之间的私有连接
回想一下，我们的 Airflow 安装运行在一个私有的 VPC 本地 GKE 集群上。一方面，顾名思义，私有集群是一种没有为工作节点分配公共 IP 的集群。事实上，我们不需要通过互联网公开我们的 GKE 工人。首先，将公共 IP 分配给工作节点可能会导致安全漏洞。其次，公共 IP 在这里没有用，因为云 SQL 实例不能通过公共 IP 连接访问。
另一方面，VPC 本地意味着 GKE 集群使用别名 IP 地址范围将流量从一个 pod 路由到另一个 pod。事实上，就 IP 路由而言，VPC 本地 GKE 集群有许多有用的好处。例如，当启用 VPC 本地模式时，集群 VPC 网络和通过 VPC 网络对等连接到它的任何网络之间存在本地路由。更多关于 VPC 本地集群的信息可以在这里找到。
如果到目前为止，为气流创建的 GKE 集群正在名为“default”的默认 VPC 内运行。至于云 SQL 实例，它运行在一个 VPC 网络中，该网络位于一个由 GCP 代表我们管理的项目中。既然 GKE 的工作人员属于两个不同的网络，并且没有公共 IP，他们怎么可能与 SQL 实例通信呢？
还记得我们之前在我们的项目“默认”VPC 网络和云 SQL 实例所在的 VPC 网络之间建立了一个 VPC 对等连接。这意味着我们的 GKE 工作人员和我们的云 SQL 实例可以通过私有 IP 连接进行本地通信，这要归功于启用了 VPC 本地模式。您可以在云控制台上找到有关这种对等的详细信息。
打开云控制台，点击菜单(左上角的汉堡图标)，向下滚动直到找到‘VPC 网络’。悬停在“VPC 网络”上。在下拉列表中，单击“VPC 网络对等”。
GKE 集群 VPC 网络和云 SQL 托管网络之间的 VPC 对等连接，图片由作者提供
此时，我们已经为云 SQL 到 BigQuery 的同步作业做好了准备，因为执行这些作业的 GKE 工作人员无法从互联网上访问。然而，我们可以更进一步，加密 GKE(或气流)和云 SQL 之间的连接。
传统上，这是使用 SSL 证书完成的，这意味着配置和管理 SSL 证书的开销。
加密到云 SQL 实例的连接的一种更简单的方法是使用云 SQL 代理。云 SQL 代理的工作方式是，让一个本地进程(称为代理客户端)运行在连接发起的环境中，让一个“远程”进程(称为代理服务器)运行在与云 SQL 实例相同的环境中。请访问这个文档，获得关于云 SQL 代理的全面解释。
我们在 GKE 上安装 SQL 代理，方法是创建一个运行 SQL 代理进程的 pod，然后创建一个服务在内部向集群公开该 pod。
但是在到达那里之前，我们需要设置 kubectl 二进制文件来与集群通信。为了实现这一目标:
-
通过运行以下命令获取 GKE 群集名称。复制“名称”字段下的值
-
连接到集群并配置 kubectl 二进制文件。用先前命令的值替换<cluster_name></cluster_name>
-
获取云外壳服务器 IP 地址
-
将云 shell 服务器列入白名单，以便 GKE 集群主服务器接受来自它的传入连接。确保在上一步中将<cluster_name>替换为集群名称，将<shell_server_ip_address>替换为 IP 地址</shell_server_ip_address></cluster_name>
我们现在准备在 GKE 集群上安装 SQL 代理。首先，在集群中为代理相关资源创建一个名称空间。为此，创建一个空文件，并将其命名为“namespace.yaml”。然后将以下内容复制到文件中:
创建 cloud-sql-to-bq 命名空间的 GKE 清单
现在创建名称空间:
然后创建一个名为“pod.yaml”的文件。然后将以下内容复制到文件中。请确保用您的 GCP 项目 ID 的值替换<project_id>。</project_id>
创建云 sql 代理 pod 的 GKE 清单
继续创建运行云 SQL 代理流程的 pod
现在，代理运行在 GKE 集群内的 pod“cloud-SQL-proxy”的容器“airflow-sqlproxy”中。最后，创建一个名为“service.yaml”的文件，并向其中添加以下内容。
创建云 sql 代理服务服务的 GKE 清单
将该清单应用到 GKE 集群，以实际创建服务，该服务将代理流程公开给集群中运行的其余 pod。
就是这样！我们已经在 GKE 工作者(以及气流工作者)和云 SQL 实例之间配置了一个私有的加密连接。架构现在看起来像这样:
架构图:为 Airflow 和云 SQL 之间的通信而设置的云 SQL，图片由作者提供
创建大查询数据集
在您的 GCP 项目中创建一个 bigquery 数据集，以保存将要从云 SQL 同步的所有表。
编写和部署数据同步任务
从云 SQL 到 BigQuery 的实际数据同步是由 Airflow DAG(有向无环图)处理的。DAG 由三个任务组成:
- 第一个任务将数据从云 SQL 实例数据库“classicmodels”导出到之前创建的 GCS 存储桶。这是使用气流MySqlToGoogleCloudStorageOperator完成的
到云 SQL 实例的连接是私有的和加密的(因为使用了私有实例和云 SQL 代理)，并使用 Airflow 连接字符串“cloud_sql_proxy_conn”。
要配置此连接字符串:
- 打开气流用户界面。打开云控制台。接下来，单击控制台右上角的菜单栏。向下滚动直到找到“Composer”并点击它。然后点击“数据-同步-环境”菜单。在出现的水平栏上，单击“环境配置”。下一步向下滚动，直到你找到“气流网络用户界面”。单击“Airflow web UI”旁边的链接。使用正确的 google 帐户进行身份验证。气流用户界面如下所示:
气流用户界面，图片由作者提供
2.点击“管理”并在打开的下拉列表中选择“连接”。使用以下信息创建连接。将<user_name>替换为您之前创建的云 SQL 实例用户名，并点击“保存”。</user_name>
MysqlToGoogleCloudStorageOperator 的气流连接
-
第二个任务使用GoogleCloudStorageToBigQueryOperator将数据从 GCS 存储桶导入 BigQuery 表
-
第三个任务通过 BigQueryOperator 从第二步创建的表中创建一个聚合表。为了使事情看起来更具体一些，我在这个任务中根据销售数字计算了 classicmodels 示例数据库中的前 5 名雇员。
-
创建一个名为“cloud_sql_to_bq.py”的文件，并将 DAG 代码片段复制到其中。
-
通过查找字段“dagGcsPrefix”的值来检索云合成器 dags 目录的名称
-
将文件“cloud_sql_to_bq.py”复制到 Cloud Composer dags 目录中
过一会儿，您的 DAG 应该开始运行，当它结束时，您应该在 BigQuery 数据集中找到您的新表。
恭喜你！您已经成功部署了数据同步 DAG 并实施了目标体系结构的所有部分:
架构图:云 SQL 数据同步到 BigQuery，图片由作者提供
将新的模拟数据插入云 SQL
为了让同步作业在每次运行时获取新数据，我在 GKE 上创建了一个 CRON 作业，它每 2 分钟运行一次，向“classicmodels”数据库的“employees”表添加新数据。
我不会在这里花太多时间讨论新的数据插入过程，因为它偏离了我们的主题。如果你有兴趣了解更多关于我是如何实现这个过程的，请耐心听我讲完，你将会看到一个 Gitlab 库，里面有迄今为止讨论过的所有材料。
监控同步任务
Airflow modern 用户界面(UI)为任务监控提供了许多有用的功能，包括工作流和任务状态、自定义图表、使用标准 SQL 的即席查询。此外，Cloud Composer 还提供本机指标和仪表盘来监控气流作业和 GKE 集群。
同步作业计划每 2 分钟运行一次(在现实生活中，您不会有这么高的运行速度)。下图显示了上次作业运行的结果。
同步作业的成功 dag 运行执行图，按作者显示的图像
总结
在本文中，我展示了一种将数据从云 SQL 同步到 BigQuery 的安全方法，使用完全同步而不是增量同步。完整的代码可以在这个 gitlab 私人仓库中获得。如果你有兴趣，请发一个访问请求给我，地址是 marcgeremie@gmail.com的，我很乐意将你添加到资源库中。
结束注释
可以肯定地说，本文中实现的架构已经可以投入生产了。尽管如此，还是有一些方法可以改进它。其中包括:
- 为高可用性的云 SQL 实例添加故障转移副本。
- 为云 SQL 实例添加一个读取副本，并从副本中读取同步作业，而不是直接从主实例中读取。
- 不要使用在 cloud Composer GKE 集群中运行作业的操作符MySqlToGoogleCloudStorageOperator，考虑使用数据流或 Spark 操作符将表从云 SQL 导出到 GCS。
- 考虑使用增量同步代替完全同步，以降低作业成本并提高性能。
- 本文使用了一个 MySQL cloud SQL 实例。然而，它可以很容易地用 PosgreSQL cloud SQL 实例进行复制，只需对命令进行最少的更改。
参考
- https://cloud.google.com/sql/docs/mysql/sql-proxy?hl=en
- https://cloud . Google . com/kubernetes-engine/docs/concepts/private-cluster-concept
- https://cloud . Google . com/kubernetes-engine/docs/concepts/alias-IPS
- https://medium . com/grensenittet/copy-data-from-cloud-SQL-to-big query-using-Apache-air flow-b 51 BDB 277463
使用 Python 自动化您的数据管理规程
如何提高企业数据质量和简化您的工作流程
任何与数据打交道的人都知道数据质量的重要性。无论你是在 excel 中进行基本分析，还是用决策树预测销售趋势，糟糕的数据总会让你举步维艰。将责任推给过度工作的数据管理员和贪婪的数据消费者很容易，但最终还是要由数据专业人员来承担这两者之间的联系。那么，您如何提升您企业的数据管理能力并倡导更有效的分析呢？自动化您的数据质量指标。
许多人以多种方式定义了数据质量指标。我喜欢使用 4 V 的和 4 C 的来构建关于质量的对话，因为它们易于记忆、营销和可视化:
4 C 标准
完整性 —预期的数据有多少？“重要”栏是否已填写？
一致性 —数据集之间的数据值是否相同？
符合性 —数据是否符合规定的格式？
好奇心 —利益相关者了解和/或参与了数据管理生命周期吗？
4 V 的
卷 —呈现多少信息？
速度 —输入数据的频率是多少？数据处理和传播的频率如何？
多样性 —存在哪些类型的数据？数据是结构化的、非结构化的还是半结构化的？
真实性 —数据可信吗？有哪些内在的差异？
我用几个 Python 包来快速测量和社会化这些概念。熊猫有很多内置的方法来调查数据:我用的是。描述用条件格式查找模式。为了得到更可靠的报告，我使用了熊猫概况，它可以很容易地嵌入到 Jupyter 笔记本中或者保存到 HTML 文件中。
**import pandas as pd
import** pandas_profilingdf = read_csv("raw_data.csv")
df.describe()profile = pandas_profiling.ProfileReport(df)
profile.to_file("profile.html")
Matplotlib 和 seaborn 是绘制数据的很好的库。我最近一直在探索如何创建快速、通用和引人入胜的可视化效果，可以很容易地嵌入到网站中。这里有一个很棒的指南告诉你如何做到这一点。
企业中的数据规程
到目前为止，我们已经检查了一些陈腐的理论，以构建一个数据质量社会化的概念框架，并拥有可视化和呈现度量的基本工具。**是时候自动化了！**作为数据专业人员，我们通过揭露脏数据和阐明数据债务来教育和激励企业管理数据以进行有效分析，这一点至关重要。自动化可以通过保持透明度和问责制将最佳实践固化为规程。
我最近在做一个项目，主要关注数据摄取，计算按特许经营分组的 全球产品的利润率。这项努力最初是为了更好地理解盈利能力，但很快就失去了控制。像大多数拥有全球足迹的企业一样，我的客户通过收购将运营成本最小化的公司(如分销商)来简化供应链，从而实现战略增长。
IT 整合跟不上运营计划；以前计算利润的努力被证明是不成功的，因为不同的 ERP 系统(总共超过 15 个)，混乱的术语，高乘务员流动率等。
来自世界各地的数据管理员会派个人。csv 文件通过电子邮件发送给商业智能团队，在企业数据仓库中与发票销售数据手动合并。预先打包的报告被传递给领导层，附带无数的警告，被确信其他利益相关者在稀释数据的数据管理员破坏。数据质量如此混乱以至于基本利润分析的可见性都无法达到，更不用说持续了。精疲力竭的 B.I 小组需要一些帮助！
问题定式化
数据 完整性 和 符合性 给利润计算带来了重大问题:不完整的数据会以多种不同的格式从没有结构的管理者那里涌入。 流速 不一致，不经常从各个群体中流出，在那里名声不佳 准确性低 。
最终，我将通过对利润计算进行高级分析来解释盈利能力和市场份额，从而为项目做出贡献。但是，如果没有有效的数据管理来计算数据科学管道中的利润率，我有很多机会来自动化一个有效的管道，并告知利益相关者数据质量。
战略
我们与数据管理员、所有者和治理委员会合作，仅确定利润计算所需的相关值，并按功能进行组织:产品到产品映射、成本、计量单位转换和附加属性。模板被复制以适应每个全球特许经销商，因此数据管理员只负责维护他们的资产。我们总共会有 50 多个文件！
我构建了一个 SharePoint 站点来托管文档存储库中的模板，它相当于 SharePoint 中的目录文件夹。然后，我创建了一个简单的 python 脚本来遍历“文件夹”以按功能连接文件，添加了额外的列，如“修改日期”、“初始文件名”和一个“完整性”度量，该度量计算相对于总数(按行)填充了多少列。超过 50 个文件减少到 4 个，代表每个功能数据资产。为了传播数据质量概念，我使用 pandas-profiling 按功能构建数据质量报告，并嵌入到 SharePoint 站点上。
B.I 团队厌倦了手动将平面文件上传到数据仓库。我使用了 pyODBC 来建立到企业 SQL 服务器的连接，并且只加载了满足适当“完整性”分数的记录。
**import** pyodbc
conn = pyodbc.connect(**'Driver={SQL Server};'
'Server=<server>;'
'Database=<database>;'
'Trusted_Connection=yes;'**)
cursor = conn.cursor()sql_query = **"SELECT * FROM table_name"** cursor.execute(sql_query)
cursor.fetchall()sql_df = pd.read_sql(sql_query, conn)
一旦将记录加载到数据仓库中，我就可以查询记录，并通过交叉引用具有信息模式和列约束的数据来检查 一致性*；如果列的 VARCHAR 限制为 5，并且值的长度等于 10，则不会加载记录。我将这个“错误日志”存储在 SharePoint 站点上，供数据管理员在需要时参考。*
最后，我们计算加载到 SQL Server 中的记录的利润，并将结果存储在 plotly 图形中，以提供关于特许经营业绩的即时反馈。一个漂亮的动画形象化描述了预期记录、已提供记录、已加载记录、有利润的记录以及一段时间内总收入的百分比。领导可以快速查看哪些数据管理员正在积极地贡献高质量的数据，哪些没有，以及哪里出现了主要的差异。最终结果是一个整合的平台，通过自动化管道实时更新数据质量指标，从而消耗特许经营的利润率。数据专业人员可以专注于将见解转化为行动，而不是“赶猫”。
结论
数据管理远不如分析和高级技术那么吸引人，但同样重要。如果管理不当，糟糕的数据将会分散您进行深刻分析的注意力，并困扰您企业中有才华的数据专业人员。虽然过于简单，但本文概述的方法阐明了人员、流程、数据和技术如何相互作用，以产生企业的整体指标。在跳到“有趣的东西”之前，通过关注数据管理生命周期的基础，项目团队可以快速地从吸收数据转向理解数据。
总的来说，我的贡献每年将为企业节省 400 多个小时的人工工作。此外，我们还促成了一种缺乏数据管理的文化，并在此过程中帮助整合了数据质量战略。开始自动化您的数据管理纪律！
使用 TanD 自动化您的机器学习工作流程
用几个终端命令训练和部署您的 ML 模型，根本不需要代码
来源:https://cdn . pix abay . com/photo/2019/04/14/10/28/gears-4126485 _ 1280 . jpg。访问时间:2020 年 8 月 24 日
这是一个关于 TanD 的帖子，一个自动化机器学习工作流程的无代码框架。它的目的是展示如何使用它来自动化您的机器学习工作流任务，以将您的时间花在对您来说重要的事情上。
你可以在这里查看 GitHub 回购。
数据科学家、机器学习工程师或任何从事数据建模工作的人的工作流程都是重复的:在一些预处理的数据集上迭代地训练和部署模型，编写相同的函数来导入数据，一次又一次地拟合和部署一些机器学习模型，这很无聊，而且根本没有效率。
在这种背景下，开发了 TanD(训练和部署)框架来自动化这一机器学习工作流的一部分，以缓解数据科学家的生活，让他们把时间花在对他们来说重要的事情上。
它是如何工作的
类似于“Django for Machine Learning”，TanD 的主要思想很简单:通过一些终端命令和对一个.json文件的一些设置，用户能够训练一个 ML 模型(在 PyTorch 或 sklearn 上)，将它记录到mlflow中，自动创建一个 API 来参考它。只需几个命令，您甚至可以将它部署到 AWS 上，无需编写任何代码。
让你在工作中想怎么懒就怎么懒，而不会影响工作质量。在使用它的 CLI 生成项目模板之后，您可以插入您的数据集，让它为您完成工作，或者指定复杂的 train 函数和 API 端点。
我们现在将展示如何使用 TanD 来自动化 UCI 心脏病数据集上从训练到部署的 ML 工作流。
设置项目
我们首先必须安装 TanD，这很容易做到:
pip install train-and-deploy
如果您想遵循本教程的部署部分，您还应该安装 AWS CLI 、 ElasticBeanstalk CLI ，并设置您的 AWS CLI 凭证。不要担心，我们在这里展示的一切都可以用自由层来完成，尽管 API 将是可伸缩和有弹性的。为此，您也可以遵循 AWS 文档中的说明。
要创建一个 TanD 项目，必须在终端上运行命令。我们将使用 PyTorch 模板，尽管您可以使用 sklearn one 来跟踪所有内容:
tand-create-project --template pytorch-structured-classification## or if you prefer: tand-create-project --template sklearn-structured-classification
这将在文件夹上创建项目文件，并加载一个默认数据集(我们将使用它)，这就是上面提到的 UCI 心脏病。我们现在将逐一查看这些文件:
├── app.py
├── config.json
├── data
│ └── data.csv
├── Dockerfile
├── env_files
│ ├── app.env
│ ├── docker_app.env
│ └── train.env
├── lib
│ ├── __init__.py
│ ├── model.py
│ └── preprocess.py
├── mlflow-server.sh
├── requirements.txt
├── test_app.py
└── train.py
数据
数据文件夹包含将要使用的数据集。阳光下无新事。
配置
config.json文件遵循以下结构:
其中训练子字典包含与数据集和网络架构相关的训练参数。注意，我们必须指定包含标签的列，并在labels列表中按顺序命名它们。to_drop包含在定型之前应该从数据集中删除的所有列。
mlflow子目录包含与实验的mlflow记录相关的参数。
环境文件
env_files文件夹包含用于模型训练和部署的环境变量源文件。train.env为训练期间实验的mlflow记录设置变量；
MLFLOW_TRACKING_URI=sqlite:///database.db
MLFLOW_DEFAULT_ARTIFACT_ROOT=./mlruns/
两者都可以设置为本地路径或云托管路径。为了简单起见，我们将保留它们的默认值，但是注意，为了可伸缩性，您应该设置自己的mlflow db 和存储路径。
app.env包含与服务于模型的 API 相关的环境变量:
MLFLOW_TRACKING_URI="sqlite:///database.db"
MLFLOW_DEFAULT_ARTIFACT_ROOT="./mlruns/"
API_TOKEN="TOKEN123"
MODEL_STAGE="Production"
除了出现在train.env上的那些，我们在这里有模型的阶段，它将由mlflow加载器在生产中获取，还有一个令牌，它必须作为请求参考 API 的TOKEN头传递。
如果用户想在本地运行一个Docker，那么docker_app.env在一个单独的文件中包含变量。
Dockerfile 文件
当然，它包含了基于 FastAPI 构建服务于模型的图像的指令。
解放运动
Lib 包含模型架构(或者，在sklearn项目中，一个将config.json中选择的模型映射到sklearn模型的解析器)。
还包含preprocess.py，具有preprocess功能。在训练之前，我们在数据集中放置任何应该完成的预处理操作，这比仅仅删除列更复杂(或者我们可以在配置上保持在to_drop)。我们今天不会使用定制的预处理程序。
最后是主要文件:
火车
在执行任何所需的预处理操作后，train.py文件使用配置根据数据路径给出的数据训练模型。它将模型存储在mlflow上，这样就可以在生产中读取它，以及许多指标，如准确性、AUC-ROC、AUPR、精确度、召回、NPV 等…
如果您运行多次，它将保存不同的运行及其指标，您将能够在mlflow UI 中设置生产模型，只需运行:
bash mlflow-server.sh
这个脚本还从预处理的数据中创建了一个请求模型，存储在request_model.json中。该文件既用于测试模型，也用于新请求的验证和重新排序。
应用
TanD 模型模板包括一个简单的 FastAPI 应用程序，用于服务模型，受$API_TOKEN保护。它包括端点:
/进行健康检查；/update-model用于通过请求使 API 在mlflow指定的后端获取最新的生产阶段模型—需要$API_TOKEN；和/predict接收特征并返回模型预测—需要$API_TOKEN。
试验
为了确保一切正常，包括对 API 所有端点的测试。设置好适当的环境变量后，只需运行:
pytest
如果通过了，你就可以走了。
我们现在准备继续训练模型，测试 API，最后部署它。
训练模型
要训练模型，只需运行:
source env_files/train.env && python train.py
它将执行操作并将其记录到mlflow。您可能希望看到以下结果:
bash mlflow-server.sh
您将看到带有以下内容的用户界面:
注意，除了度量标准，它还存储了大量的度量标准和图表来帮助您评估模型。来源:我卑微的机器打印。
训练脚本还保存对预测的每个要素的分析，以便可视化给定每个分类要素的预测比例和每个类的连续要素的分布。(这有助于检查模型是否有任何“欺骗”的特征，并对学习有一些解释)。
对于心脏病预测为阳性的情况，该图像将是:
大量的图表有助于评估模型和理解它学到了什么。
你也可以在那里看到混淆矩阵，PR 和 ROC 曲线。
之后你可能会想
source env_files/app.env && pytest
断言一切正常。
一旦我们训练了这个模型，我们就能够开始探索 API，用Docker运行它，甚至用几个终端命令将它部署到 AWS。
运行 API
我们现在将展示运行一个 TanD 项目 API 的三种方法:本地，通过Docker和部署到 AWS ElasticBeanstalk。
本地运行
要在本地运行 API，您可以在具有适当要求的环境中运行:
uvicorn app:app --reload --host 0.0.0.0 --port 8000
这样，API 就可以在您的本地网络上打开了。你可以用一个curl帖子请求来测试一下:
curl --header "Content-Type: application/json" \
--header "TOKEN: $API_TOKEN" \
--request POST \
--data '{"age":1,"sex":1,"cp":1,"trestbps":1,"chol":1,"fbs":1,"restecg":1,"thalach":1,"exang":1,"oldpeak":1,"slope":1,"ca":1,"thal":1}' \
http://localhost:8000/predict
码头运行
您可能希望通过Docker运行它，这是一种可用于在云服务的通用虚拟机上部署它的方法。在 TanD 项目的根上构建它非常简单:
docker build . -t tand-app:v1
当您运行它时，一定要传递适当的环境文件和 API 使用的变量。您可以将它们设置在env_files/docker_app.env:
docker run -p 8000:8000 --env-file env_files/docker_app.env tand-app:v1
同样，您可以使用相同的命令来测试它，只需记住为请求使用正确的令牌:
curl --header "Content-Type: application/json" \
--header "TOKEN: $API_TOKEN" \
--request POST \
--data '{"age":1,"sex":1,"cp":1,"trestbps":1,"chol":1,"fbs":1,"restecg":1,"thalach":1,"exang":1,"oldpeak":1,"slope":1,"ca":1,"thal":1}' \
http://localhost:8000/predict
使用 AWS ElasticBeanstalk 部署它
TanD 还帮助您在 AWS EB 上部署它，这是一个很好的方法，因为它具有弹性和可伸缩性，同时仍然易于使用(通过我们的助手)。如果您按照上面的建议设置了 AWS CLI 凭据，安装了它，并安装了 ElasticBeanstalk CLI，那么现在就可以开始了。
要准备在 AWS 上部署您的 TanD 项目，请在项目根目录下运行:
tand-prepare-aws-eb-deployment --init-git
我们传递这个--init-git标志，因为 ElasticBeanstalk 使用了来自.git目录的一些信息，以便在部署期间将项目上传到 AWS S3。这样，在部署之前，TanD 创建了一个 g it 存储库，并提交了使其工作的所有内容。
如果您已经初始化了一个 git 存储库，您不必传递那个标志，只需记住添加并提交所有内容。
该脚本将创建一个脚本来部署 TanD 项目根目录上的应用程序、deploy-aws-eb.sh和.ebextensions目录，其中填充了一些用于部署的默认.config文件，遵循以下结构:
├── .ebextensions
├── options.config
├── cron.config
└── scaling.config
options.config为项目设置环境变量，同app.env—mlflow后端、模型阶段、API token。这就是环境变量传递给 EB 的方式。cron.config在部署的应用程序的每个实例上创建一个 cron 作业来每日查询 APIupdate-model端点，因此它从mlflow后端获取最新的生产阶段模型。这样，如果您运行不同的实验并想要部署不同的模型，您可以通过mlflowUI 进行，它将在生产中更新。scaling.config为您的 API 设置缩放配置。我们将这些参数设置为我们的应用程序可以拥有的最小和最大实例数、实例类型和缩放标准。我们将最后一个默认为延迟，但是您可以自由地这样做。
然后，我们可以通过一个简单的:
bash deploy-aws-eb.sh
部署大约需要 5 分钟。之后，您可以使用以下命令检查链接:
eb open
然后用相同的 curl 命令测试它(记住正确设置链接和 API 令牌):
curl --header "Content-Type: application/json" \
--header "TOKEN: $API_TOKEN" \
--request POST \
--data '{"age":1,"sex":1,"cp":1,"trestbps":1,"chol":1,"fbs":1,"restecg":1,"thalach":1,"exang":1,"oldpeak":1,"slope":1,"ca":1,"thal":1}' \
http://YOUR_LINK_GOES_HERE/predict
至此，我们结束了项目教程。
结论
作为一个结论，我们可以看到，TanD 允许您非常快速地训练和部署您的 ML 模型，只需要一些设置和终端命令，根本不需要任何代码，但是让您可以自由地适应和更改项目模板。
为了训练和部署您的项目，您只做了 6 个终端命令并检查了config.json上的一些设置:
tand-create-project --template pytorch-structured-classification## check config.json for your datasetsource train.env && python train.py
source app.env && pytest## run API as you will:tand-prepare-aws-deployment --init-git
bash deploy-aws-eb.sh
有了 TanD，你就可以自动化你的 ML 工作流程的很大一部分，节省你的时间去做对你来说重要的事情，或者只是偷懒和开心。
如果你喜欢这个帖子，考虑给它一些掌声或者主演 GitHub repo ，它有助于项目获得更多的可见性。
如果你想和我谈谈这个项目，有一些见解，只是想聊天的批评，你可以在 LinkedIn 上 ping 我或者在回购中创建一些问题。
参考资料:
TanD 是一个简单、无代码、灵活和可定制的框架，用于自动化机器学习工作流。用和…
github.com](https://github.com/piEsposito/TanD) [## MLflow -机器学习生命周期的平台
机器学习生命周期的开源平台 MLflow 是一个开源平台，用于管理机器学习生命周期
mlflow.org](https://mlflow.org/) [## 心脏病 UCI
https://archive.ics.uci.edu/ml/datasets/Heart+Disease
www.kaggle.com](https://www.kaggle.com/ronitf/heart-disease-uci)
使用 Process Manager 2 (PM2)自动化您的 Python 脚本
一个重要的 PYTHON 技巧
以新冠肺炎数据收集为例的分步指南
插图作者:金彩云
在数据科学中，您可能需要定期运行或处理您的 Python 脚本，尤其是数据收集，以使您的工作流程保持最新，因为它直接关系到您的结果准确性。您可能有一个 Python 脚本，每隔 1、2、…、 xx 分钟/小时运行一次，或者每天早上 6 点、晚上 9 点、 yy 点/晚上运行一次。而且每次都自己做又累又无聊。
这就是为什么自动化或计划你的脚本是重要的！！
当你在网上搜索它的时候，可能已经有几篇文章在讨论它了。如果您使用的是 Windows，您可以考虑使用一个 Windows 任务调度器，您可以使用它来调度您的 Windows 系统运行任何 execute(。exe)或批处理(。bat)文件。虽然它有一个好看的用户界面，但有些人仍然不太喜欢它。(来源 此处 )
或者如果你使用的是 macOS 或者 Linux，你可以考虑使用一个 Crontab 。但是当您有太多的脚本或作业需要管理/记录时，您可能会发现很难管理。
那么，让我们检查一下这个替代方案>>>
PM2 是另一个选择！
PM2 是为 Node.js 应用构建的流程管理器。
根据我使用 Node.js 进行 web 开发的经验，我不得不使用 CRON 来调度和管理几个 Node.js 应用程序，这给了我一段非常艰难的时间，直到我认识了 PM2 ！！从那以后我的生活好多了。PM2 让我的应用程序永远运行，并在我更新应用程序时自动重新加载。此外，我可以在任何应用程序上使用 CRON 或重启延迟手动安排重新加载时间，它可以在所有操作系统上完美运行！！
嘿等等…，PM2 不是仅限于 Node.js 应用吗？
**不！**没错， PM2 意在服务 Node.js 应用，但不限于 Node.js 运行时。在我使用 PM2 一段时间后，我意识到它可以用来管理任何编程脚本/运行时！从那时起，我用 Python 试了一下，效果很好！
在本文中，我将展示一个例子，展示如何使用 PM2 来调度和自动化您的 Python 脚本！！
我们开始吧！
PM2 装置
安装也可以在一条线上完成，您可以使用npm或yarn。
$ **npm install pm2@latest -g**
# OR
$ **yarn global add pm2**
# Done!
# Check if program runs.
$ **pm2 -v**
vx.x.x
如果你在 Windows 10 上安装了 PM2，第一次运行时，你可能会遇到一个错误，因为当前用户有一个未定义的执行策略。您可以通过以下代码修复它:
$ **Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Unrestricted**
使用 PM2 运行 Python 脚本
安装完成后，您可以使用$ **pm2 start** <script name>命令通过 PM2 启动任何 python 脚本。
如果您有多个作业要运行，我还建议您给每个作业起一个有意义的名字，这样您以后就不会混淆了。可以用**--name** <name>给每个作业命名。默认情况下，当你启动任何.py文件时，PM2 会用 Python 运行你的脚本。但是，如果您的机器上安装了多个版本的 Python，您可以使用**--interpreter** <interpreter name: node, python, python3, python3.x, ...>选择特定的 Python 版本。
总的来说，启动 python 脚本的命令如下所示:
$ **pm2 start** job1.py --**name** job1 --**interpreter** python3
根据 PM2 的默认设置，它会试图让你的应用程序永远运行，这意味着你的脚本将在完成后立即自动重启。
嗯，对一台机器来说可能太多了！因此，有两种方法可以将 Python 脚本设置为定期运行 PM2: 1 .使用重启延迟 2。使用 cron
通过“重启延迟”自动重启
您可以使用**--restart-delay** <xxxx ms>选项将 Python 脚本设置为定期运行。这样，在 Python 脚本完成工作后，它将等待xxxx毫秒，直到下一次重启。
例如，如果您希望您的脚本在每次作业后每 10 秒重启一次，您通常可以在 Python 中使用while & time.sleep，如下所示:
**while True:**
...
**time.sleep(10)**
有了 PM2，你不再需要while循环，你可以保持你的代码干净，把重启工作留给 PM2 。在每个作业后以 10 秒钟的睡眠时间运行脚本的命令如下所示:
$ **pm2 start job1.py --name job1-10s-delay --interpreter python3 --****restart-delay 10000**
使用“cron”自动重启
您还可以使用 cron 选项通过**--cron** <'cron pattern'>来调度您的 Python 脚本。使用--no-autorestart禁用 PM2 自动重启选项也很重要，这样它就不会在完成一个任务后自动重启，只会遵循 cron 表达式。
例如，每 1 小时(在第 0 分钟)重新启动脚本的命令如下所示:
$ **pm2 start .\testPm2.py --cron '0 * * * *' --no-autorestart**
关于 cron 的一个提示:如果你是第一次接触 cron 。它是 Unix 操作系统中基于时间的作业调度程序。 cron schedule 表达式允许您让您的程序在特定的时间定期重启。cron 的格式是'<minutes 0:60> <hour 0:24> <day of month 1:31> <month 1:12> <day of week 0:6>'.我推荐你可以尝试通过这个网站创建自己的 cron 表达式:这里。
让我们结束这无聊的部分，让我们一起经历一个真实世界的例子！
真实世界的例子
抓取全球新冠肺炎数据
假设您想每隔 5 分钟从 Worldometer 监控并存储新冠肺炎病例的数据。使用beautiful soap 4就可以轻松做到。例如，我的 Python 脚本(getcovid 19 data . py)将允许您从 Worldometer 获取新冠肺炎案例数据，并将数据存储到 CSV 文件( world_corona_case.csv )。
getCovid19Data.py(使用 bs4 抓取新冠肺炎的 Python 脚本)
而不是在脚本中使用while循环和time.sleep()或者使用常规的 cron 每 5 分钟重启一次脚本。
您可以使用 PM2 和重启延迟 *(5 分钟=300000 毫秒)*来完成:
$ **pm2 start getCovid19Data.py --name covid19-5minInt** **restart-delay** **300000**
或者，您可以使用 PM2 和cron*(5min = ’ */5 * * * *)*来完成
$ **pm2 start getCovid19Data.py --name covid19-5minInt --cron '*/5 * * * *' --no-autorestart**
就是这样！现在，Python 脚本将每 5 分钟运行一次。现在您可以用这个命令检查您的日志
**$ pm2 l**
将显示列表。您可以在这里看到所有使用 PM2 运行的作业，这些作业将包含所有在后台运行的 Node.js 应用程序或 Python 脚本。
PM2 表显示了所有应用程序的列表
您可以使用命令pm2 log <id or name>查看特定作业的日志。在本例中，您可以使用以下命令:
$ pm2 log 0
作业 id 为“0”的 PM2 日志
从日志状态可以看到，Python 脚本每 5 分钟存储一次新冠肺炎数据，剩余的[~1.6 到 2.5 秒]是 Python 脚本每次请求数据并保存添加更新数据到CSV文件的时间。现在，让我们检查下面结果CSV文件中的结果。PM2 很好用！
将 PM2 与 cron 一起使用时，getcovid 19 data . py sscript 产生的 CSV 结果
一些其他有用的 PM2 命令
当你用 PM2 运行多个进程时。您可能希望对每个项目进行不同的操作。以下是我最常用的一些有用命令的列表。
$ **pm2 stop <name or id>** #stop specific process$ **pm2 restart <name or id>** #restart specific process$ **pm2 flush <name or id>** #Clear logs of specific process$ **pm2 save** #save list of all application$ **pm2 resurrect** #brings back previously saved processes
$ **pm2** **startup** #Command for running PM2 on startup
作者单词
我希望您喜欢这篇文章，它可以帮助您更容易地安排 Python 脚本，并将其应用到您的 Python 工作流中。如果您有任何问题、意见或建议，请随时与我分享。
关于我&查看我所有的博客内容:链接
平安健康！
感谢阅读。👋😄
自动化您的重复性报告！
自动化 R 脚本
来源:https://thumbs . gfy cat . com/impressive instructiveiberian emerald lizard-small . gif
什么是 R 脚本自动化，为什么？
在大多数用例中，R 用于分析数据、运行统计测试和构建模型。在这样做的过程中，数据科学家通过编写代码不断地与 R 进行交互，并从这些交互中产生结果。最终，这些结果被存储、共享或以报告的形式呈现。但是，如果您必须每天或以其他类型的定期间隔复制报告，该怎么办呢？嗯，你总是可以调出 R 脚本，重新运行脚本。但是，如果它是自动完成的，而不需要您在中间启动 R 和运行脚本，不是更好吗？
在本文中，我们将知道如何做到这一点！
我们在这里要做的事情的大纲
概括地说，本文有两个部分:
首先，在本文中，我们将创建一个使用实时数据的报告，即定期更新的数据源。
其次，一旦创建了报告，我们将自动执行每天重新创建报告的过程，以捕获更新的数据。
第 1 部分:创建报告:
因为这篇文章的目标是自动复制一个已经构建好的报告，所以我已经创建了一个报告并发布在这里:【http://rpubs.com/arafath/CRAN_Report。
请随意访问该报告，并在您的工作站中重新创建它。你可以给 RMarkdown 脚本起个和我一样的名字( ‘CRAN_Download_Report。Rmd’ )并将其保存在您想要保存的相同位置。存储 bat 文件和其他输出。
该报告中所做的如下所示:
- 从综合存档网络(CRAN)调用 API 下载包的每日和每周下载计数，
- 加载 R 中的数据，
- 计算一些基本的统计数据，
- 可视化数据
- 生成包含基本统计数据和视觉效果的报告(html 格式)。
使用的数据:
CRAN 有一个 API 调用，我们可以使用它来获得特定时间内任何包被下载的总次数。我们将使用名为 cranlogs 的包来调用 api。
第 02 部分:自动化报告复制
一旦我们有了一个可以产生我们想要的结果的 R 脚本，复制工作流程看起来如下:
- 打开 R 控制台或一些 IDE
- 加载所需的 R 脚本
- 运行脚本以产生结果
在这一步中，我们将知道如何告诉 R 自动完成上述所有步骤**。这样，R 也将完成第 01 部分中提到的所有步骤。**
自动化是如何工作的:
为了自动重新运行 R 脚本，我们将使用 Windows 任务调度程序(WTS)。使用任务计划程序，用户可以要求 windows 执行批处理文件(。蝙蝠)。批处理文件包含一系列可以由命令行解释程序执行的命令。
我们将创建一个批处理文件，每天自动运行一个 R 脚本。在 R 脚本中，它被指示调用。创建报告的 Rmd 文件。
创建 R 脚本来运行。Rmd 文件
您可以在 R 脚本中复制并粘贴以下代码，并将其另存为 run。R (我的 r 脚本文件名):
# Loading libraries [install the libraries before if not already installed]
library(knitr)
library(rmarkdown)
library(mailR)# Knits rmd file (.Rmd is saved in the working directory)
knit('CRAN_Download_Report.Rmd')# Creates the html output
render("CRAN_Download_Report.md")# sending email notification
send.mail(from = "youremail@gmail.com",
to = c("testemail@gmail.com"),
cc = 'youremail@gmail.com',
replyTo = c("Reply to someone else <youremail@gmail.com>"),
subject = "Report update status",
body = "Daily report on CRAN package download is updated!",
smtp = list(host.name = "smtp.gmail.com", port = 587, user.name = "youremail", passwd = "password", tls = TRUE),
authenticate = TRUE,
send = TRUE)
这个 R 脚本所做的基本上是编织 rmd 文件并生成一个 html 报告，将它保存在工作目录中并发送一个电子邮件通知。
从窗口的命令外壳运行 R
在创建批处理文件之前，我们可以从命令终端手动运行我们的 R 脚本，并检查它是否按预期运行。
设置目录
打开 windows 命令外壳。在窗口中搜索“cmd”或“命令提示符”并打开它。它将打开黑色的命令外壳。
现在，使用“cd”命令将命令目录更改到您想要的位置，后跟您想要的文件位置(ref: image01)。
图片 01
从命令行运行 R
我们将使用的命令结构如下: <r.exe location=“”>CMD BATCH <.r file=“” location=“”/></r.exe>
这里，
- R.exe 位置是你的 R 可执行文件所在的文件位置。执行这个文件应该会打开 R 控制台。
- 。r 文件位置是保存 r 脚本的文件位置，该脚本将调用。Rmd 文件。
- 文件保存位置是您想要保存执行输出的位置。
为了简单起见，我使用与 R 工作目录和位置相同的文件位置来保存任何输出。
在我的案例中，这些是确切的位置:
R.exe location = "C:\Program Files\R\R-3.6.1\bin\x64\R.exe"
.R file location = "C:\Users\ahossa1\Personal\Learning\Automating R Script\run.R"
file saving location = "C:\Users\ahossa1\Personal\Learning\Automating R Script\test.Rout"
这是我电脑中的最后一行代码(ref: image02):
"C:\Program Files\R\R-3.6.1\bin\x64\R.exe" CMD BATCH "C:\Users\ahossa1\Personal\Learning\Projects\Automating R Script\run.R" "C:\Users\ahossa1\Personal\Learning\Projects\Automating R Script\CRAN.Rout"
图片 02
一旦您输入命令(image02)并执行它，它应该运行 R 脚本，该脚本将编织 rmarkdown 文档并保存报告。您应该还会收到一封带有通知的电子邮件！
使用命令行指令创建批处理文件
我们可以将命令行指令(image02)保存为. bat 文件并保存。然后，在我们需要重新创建报告的任何时候，我们都可以执行。bat 文件，它会自动调用命令行界面并执行 R 脚本。
为此，请打开一个文本文件(。txt)。将 Windows shell 命令粘贴到。txt 文件，用扩展名保存。球棒。
在我的电脑里，我把它命名为“run.bat”。
在不需要定期重新创建报表的情况下，可以使用这个。bat 档。你所要做的就是双击(或单击)。bat 文件和报告将使用更新的数据生成。
使用 Windows 任务计划程序自动执行命令行活动
现在我们将要求我们的计算机自动调用。bat 文件定期。
- 在 Windows 搜索栏中搜索“任务计划程序”并打开应用程序。下面是它在我的电脑上的样子
图片 03
2.选择创建基本任务(图 03 红色标记)
3.为任务命名
图片 04
4.下一步，选择一个触发器。我选择了日报。
图片 05
5.转到下一步并选择开始时间。
图片 06
6.转到下一步，选择启动程序作为操作。
图片 07
7.下一步，加载程序/脚本(。bat 文件)。
图片 08
瞧！！我们完成了！
现在每天下午 3:30。下面的 CRAN 包下载报告将被创建，并将发送电子邮件通知！
使用 BioBert 从 Spark NLP 中的文本自动检测药物不良事件(ADE)
在 Spark NLP 和 BioBert 的帮助下，第一个端到端预训练模型和管道可大规模检测药物不良反应。
药物不良反应(ADRs)或药物不良事件(ADEs)对患者具有潜在的巨大危险，是发病率和死亡率的主要原因 [[1]](http://Pirmohamed et al.2004] Munir Pirmohamed, Sally James, Shaun Meakin, Chris Green, Andrew K Scott, Thomas J Walley, Keith Farrar, B Kevin Park, and Alasdair M Breckenridge. 2004. Adverse drug reactions as cause of admission to hospital: prospective analysis of 18,820 patients. BMJ, 329(7456):15–19.) 。许多药品不良反应很难被发现，因为它们发生在特定条件下的特定人群中，并且可能需要很长时间才能暴露。医疗保健提供者在销售产品前进行临床试验以发现药物不良反应，但通常数量有限。因此，需要上市后药物安全性监测来帮助发现药物上市后的不良反应【2】。
最近，医疗报告[【3】](http://H Gurulingappa and J Fluck. 2011. Identification of adverse drug event assertive sentences in medical case reports. In 1st international workshop on knowledge discovery and health care management (KD-HCM) co-located at the European conference on machine learning and principles and practice of knowledge discovery in databases (ECML PKDD), pages 16-27.)或社交网络数据[【4】](http://Rachel Ginn, Pranoti Pimpalkhute, Azadeh Nikfarjam, Apur Patki, Karen Oconnor, Abeed Sarker, Karen Smith, and Graciela Gonzalez. 2014. Mining Twitter for Adverse Drug Reaction Mentions: A Corpus and Classification Benchmark. In proceedings of the 4th Workshop on Building and Evaluating Resources for Health and Biomedical Text Processing (BioTxtM).)等非结构化数据已被用于检测包含 ADR 的内容。发表在科学生物医学文献中的病例报告非常丰富，并且生成迅速。社交网络是非结构化格式的冗余数据的另一个来源。虽然包含 ADR 的单个 tweet 或脸书状态可能没有临床意义，但大量的这些数据可能会暴露严重或未知的后果。
假设需要从各种非结构化的资源(如推特、新闻、网络论坛等)中收集 ADR。)以及科学论文(即 PubMed、arxiv、白皮书、临床试验等。)，我们希望建立一个端到端的 NLP 管道来检测文本是否包含可能的 ADR，并提取 ADR 和提到的药物实体。
规模上的 NLP:Spark NLP
Spark NLP 是一个构建在 Apache Spark ML 之上的自然语言处理库，每天被下载到 10K，总共有 150 万次。它是发展最快的 NLP 库之一，支持 Python、R、Scala 和 Java 等流行的编程语言。它为机器学习管道提供了简单的、高性能的&精确的 NLP 注释，可以在分布式环境中轻松扩展。
Spark NLP 提供了 330 多种经过预训练的管道和模型，支持超过 46 种语言。它支持最先进的转换器，如 BERT、XLNet、ELMO、ALBERT 和通用句子编码器，可以在集群中无缝使用。它还提供了标记化、词性标注、命名实体识别、依存解析、拼写检查、多类文本分类、多类情感分析以及更多 NLP 任务。如需更多信息和 Colab 笔记本样品，我们强烈建议您查看我们的车间报告。
Spark NLP 医疗图书馆中的 ADRs 模型
我们首先进行了深入的研究，以收集 NLP 研究人员和医疗保健专业人员使用的所有可用的 ADR 数据集(PsyTAR、CADEC、Drug-AE、TwiMed ),我们汇编了一个包含 40K 个样本和 10K ADR 阳性句子的数据集。然后我们在 Spark NLP 中训练了几个文本分类和命名实体识别(NER) 模型，使用 BioBert 语言模型，并作为预训练模型和流水线随 Spark NLP Enterprise 2.6.2 发布。
Spark NLP 医疗保健版(许可)
药品不良事件 NER 模型
我们发布了 4 种不同的阿德 NER 模型，每一种都根据系统的局限性和所需的精确度，在不同的嵌入上进行训练。
ner_ade_biobert:用 768d BioBert 嵌入(biobert_pubmed_cased)训练
ner_ade_clinicalbert:用 768d BioBert 嵌入式(biobert_clinical_cased)训练
ner_ade_clinical:200d 临床手套嵌入训练
ner_ade_healthcare:100d 保健手套嵌入训练
阿德·NER 可以提取两个实体:ADE和DRUG
您还可以在同一管道中使用 ADE NER 和断言状态模型，并检测 ADE 检测到的否定范围(gastric problems将被检测为absent)。
就像所有其他 Spark NLP 模型一样，您也可以在任何 Spark 数据帧上运行它，并获得每一行的预测。
阿德 NER 管道公司
艾德·NER 的预测样本
我们想看看我们的 NER 算法在基准 ADE 数据集上与最先进的(SOTA) [结果相比有多好，我们最终获得了新的 SOTA 精度，其 宏平均值为 90.51 ！](http://Giorgi, John, et al. “End-to-end Named Entity Recognition and Relation Extraction using Pre-trained Language Models.” arXiv preprint arXiv:1912.13415 (2019))
我们的阿德 NER 模型击败了 Giorgi，John 等人(2019)在相同的训练和测试分裂中使用相同的 BioBert 版本报告的 SOTA 结果。
药物不良事件(ADE)分类模型
我们发布了 3 个不同的 ADE 分类模型，每个模型都根据不同的嵌入进行了训练，这取决于系统的局限性和所需的精确度。
classifierdl_ade_biobert:用 768d BioBert 嵌入进行训练(biobert_pubmed_cased)
classifierdl_ade_conversational_biobert:在 会话短句 上用 768d BioBert 嵌入进行训练。
classifierdl_ade_clinicalbert:经过 768d BioBert 临床嵌入训练(biobert_clinical_cased)
ADE 分类器将返回True或False以表明文本是否与可能的药物不良事件或反应有关。以下是一些预测:
正如所有其他 Spark NLP 模型的情况一样，您也可以将其包装在 LightPipeline 中，并获得给定文本的预测。
最后，让我们将我们的分类算法与基准 ADE 数据集上的【SOTA】[结果进行比较。正如你所看到的，我们最终获得了新的 SOTA 精确度，F1 的分数为 92.15 ！](http://Huynh, Trung, et al. “Adverse drug reaction classification with deep neural networks.” Coling, 2016.)
我们还发布了 ADE 预训练管道以避免您从头开始构建管道。下面是如何在 Spark NLP 中使用它，只需一行代码，就可以一次提取给定文本的命名实体和 ADE 状态。
从 *Spark NLP for Healthcare 3.1.2 开始，*现在我们也有了 ADE 关系提取模型(re)来查找药物和 ADE 实体之间的关系。请参见这款笔记本上的详细笔记。
结论
在这篇文章中，我们宣布了一种新的分类和 NER 模型，用于从临床和对话文本中检测和提取药物不良事件。你可以在这个 Colab 笔记本上找到所有代码和更多示例，如果你想在自己的数据上尝试它们，你可以申请 Spark NLP Healthcare 免费试用许可。
Spark NLP 库在企业项目中使用，在 Apache Spark 和 TensorFlow 上本地构建，并提供一体化的最新 NLP 解决方案，为机器学习管道提供简单、高性能和准确的 NLP 符号，可在分布式环境中轻松扩展。
如果您想了解更多信息并开始练习 Spark NLP，请查看以下资源。您还可以参加我们的 2020 年 NLP 峰会，并结识 50 多位来自业界的杰出演讲者！
为什么我们需要另一个 NLP 库？
towardsdatascience.com](/introduction-to-spark-nlp-foundations-and-basic-components-part-i-c83b7629ed59) [## 基于 Bert 和通用语句编码器的 Spark NLP 文本分类
用 Bert 和 Spark NLP 中的通用语句编码器训练 SOTA 多类文本分类器，只需几个…
towardsdatascience.com](/text-classification-in-spark-nlp-with-bert-and-universal-sentence-encoders-e644d618ca32) [## Spark 自然语言处理中基于 BERT 的命名实体识别(NER)
用 BERT 在 Spark NLP 中的几行代码训练一个 NER，获得 SOTA 精度。
towardsdatascience.com](/named-entity-recognition-ner-with-bert-in-spark-nlp-874df20d1d77) [## 约翰·斯诺实验室/spark-NLP-车间
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/JohnSnowLabs/spark-nlp-workshop/tree/master/tutorials/Certification_Trainings)
使用 PyCaret 的自动化异常检测
一个开源的机器学习库——py caret！！
图片来源——un splash
PyCaret 是一个开源库，它通过各种模块提供了各种机器学习功能，其中之一就是异常检测。
PyCaret 的异常检测模块是一个无人监管的机器学习模块，用于识别数据中存在的极值，这些极值有时可能表明可疑活动或异常情况。
PyCaret 的异常检测模块提供了十二种不同的异常检测技术，根据您正在处理的问题进行选择。它还允许我们通过一个名为“**setup”**的函数，使用传递给该函数的各种参数值来执行特征工程任务。
在本文中，我们将对 PyCaret 本身提供的一个数据集应用 PyCaret 提供的三种异常检测技术。本文涵盖的三种技术是— 隔离林、K 最近邻和聚类。
在我们实现这些技术之前，让我们先来看看我们需要按照特定的顺序执行的步骤，以便通过使用下面的函数来识别数据中的异常。这些步骤对于 PyCaret 为异常检测提供的所有技术都是通用的。
- get_data() —此函数用于访问 PyCaret 数据集。这是一个可选步骤。
- setup() —该函数初始化环境，并在异常检测之前执行所需的预处理任务。它唯一需要的参数是“数据”参数中的数据帧，但下面是可以通过设置功能实现的各种预处理任务的示例。
**setup**(*data, categorical_features = None, categorical_imputation = ‘constant’, ordinal_features = None, high_cardinality_features = None, numeric_features = None, numeric_imputation = ‘mean’, date_features = None, ignore_features = None, normalize = False, normalize_method = ‘zscore’, transformation = False, transformation_method = ‘yeo-johnson’, handle_unknown_categorical = True, unknown_categorical_method = ‘least_frequent’, pca = False, pca_method = ‘linear’, pca_components = None, ignore_low_variance = False, combine_rare_levels = False, rare_level_threshold = 0.10, bin_numeric_features = None, remove_multicollinearity = False, multicollinearity_threshold = 0.9, group_features = None, group_names = None, supervised = False, supervised_target = None, session_id = None, profile = False, verbose=True*)
- create_model() —此函数创建模型，并在设置阶段作为参数传递的数据集上对其进行训练。因此，该函数要求在使用之前调用 setup()函数。
df = pd.read_csv(path_to_csv) # to access your own dataset
or
df = get_data(“anomaly”) # to access PyCaret’s anomaly datasetsetup_data = setup(data=df)
sample_model = create_model(“iforest”)
- plot_model() —该函数获取 create_model()函数期间创建的训练模型，并绘制 setup()函数期间传递的数据。因此，该方法要求在调用之前调用 setup()和 create_model()函数。返回的图用不同的颜色清楚地显示异常数据。
plot_model(sample_model)
- predict_model() —此函数获取经过训练的模型，并使用它对新数据进行预测。新数据必须是熊猫数据帧的形式。该函数的输出是一个数据帧，其中包含名为“标签的预测以及相关的决策得分。
Label = 0 表示正常数据或内嵌数据
标签= 1 表示异常或异常值
现在，当我们对 PyCaret 异常检测函数的工作原理有了一个基本的了解后，让我们开始实际的实现吧。
**# Importing PyCaret dependencies.**
from pycaret.datasets import get_data
anomaly = get_data(“anomaly”)**# Importing anomaly detection module.**
from pycaret.anomaly import ***# Initializing the setup function used for pre-processing.**
setup_anomaly_data = setup(anomaly)
隔离林实现
# Instantiating Isolation Forest model.
iforest = create_model(“iforest”)# Plotting the data using Isolation Forest model.
plot_model(iforest)# Generating the predictions using Isolation Forest trained model.
iforest_predictions = predict_model(iforest, data = anomaly)
print(iforest_predictions)# Checking anomaly rows. Label = 1 is the anomaly data.
iforest_anomaly_rows = iforest_predictions[iforest_predictions[“Label”] == 1]
print(iforest_anomaly_rows.head())# Checking the number of anomaly rows returned by Isolaton Forest.
print(iforest_anomaly_rows.shape) **# returned 50 rows**
前 5 个异常行(标签 1)
使用隔离林创建的异常图(异常以黄色突出显示)
基于隔离林的异常图
K 最近邻(KNN)实现
# Instantiating KNN model.
knn = create_model(“knn”)# Plotting the data using KNN model.
plot_model(knn)# Generating the predictions using KNN trained model.
knn_predictions = predict_model(knn, data = anomaly)
print(knn_predictions)# Checking KNN anomaly rows. Predictions with Label = 1 are anomalies.
knn_anomaly_rows = knn_predictions[knn_predictions[“Label”] == 1]
knn_anomaly_rows.head()# Checking the number of anomaly rows returned by KNN model.
knn_anomaly_rows.shape **# returned 46 rows**
前 5 个异常行(标签 1)
使用 K 个最近邻创建的异常图(异常以黄色突出显示)
基于 KNN 的异常图
聚类实现
# Instantiating Cluster model.
cluster = create_model(“cluster”)# Plotting the data using Cluster model.
plot_model(cluster)# Generating the predictions using Cluster trained model.
cluster_predictions = predict_model(cluster, data = anomaly)
print(cluster_predictions)# Checking cluster anomaly rows. Predictions with Label = 1 are anomalies.
cluster_anomaly_rows = cluster_predictions[cluster_predictions[“Label”] == 1]
print(cluster_anomaly_rows.head())# Checking the number of anomaly rows returned by Cluster model.
cluster_anomaly_rows.shape # returned 50 rows
前 5 个异常行(标签 1)
使用聚类创建的异常图(异常以黄色突出显示)
基于聚类的异常图
参考
基于深度学习的石棉纤维检测
理解大数据
基于深度学习语义分割的建筑工地有害石棉纤维自动检测
作者:Soma Biswas，Debmalya Biswas
摘要。** 空气中的可吸入纤维，如石棉等都有害健康，职业健康与安全指南和法律要求对所有含石棉的材料进行检测和鉴定。然而，石棉纤维的检测和鉴定是一个复杂、耗时和昂贵的过程。 在这项工作中，我们提出了一种基于深度学习的语义分割模型，能够自动化石棉分析过程，将周转时间从几小时减少到几分钟。所提出的深度神经网络提供了分析过程的端到端自动化，从转换输入扫描电子显微镜(SEM)图像开始，到识别和计数图像中的纤维数量，到掩蔽所识别的纤维区域并重新排列以通过能量色散光谱(EDS)进行有效处理。最后，我们提供了基于 U-Net 的语义分割模型的实现细节，该模型能够以高达 95%的准确度检测和计数 SEM 图像中的石棉纤维(空气样本)。
这篇论文已经被接受在 2021 年第 50 届 IEEE 应用图像模式识别(AIPR)(论文)上发表
1 导言
石棉是一种天然存在的硅酸盐，具有纤维状结构，由于其柔韧性、丰富性、耐火性和耐腐蚀性，通常被称为“奇迹矿物”。这些技术特点和低成本导致石棉被用于许多领域，尤其是建筑业，例如，作为混凝土或树脂化合物的一种成分。像其有用的属性一样，石棉是一种严重的污染物，可导致肺部疾病，如石棉沉滞症、间皮瘤和其他类型的癌症。这些疾病可能有很长的潜伏期。
1990 年，瑞士是首批禁止石棉的国家之一；大多数其他国家在 90 年代紧随其后。然而，在五十年代、六十年代和七十年代，石棉仍然存在于许多建筑物的建筑材料中。为了保护工人和居民的健康，现行的瑞士法律要求任何超过 1990 年的建筑需要在拆除或改造以及回收/处理建筑材料之前进行石棉检查[1，2]。
在过去，重点放在石棉的主要矿点，如喷雾石棉或纤维水泥。然而，如今含有极低浓度(低于 0.1%)石棉的材料仍被视为对工人健康的威胁，因此需要取样分析。举个例子，从 2010 年开始对瓷砖水泥进行分析，从 2017 年开始对石膏进行分析，这些样品中大约有 20%含有石棉。
不幸的是，石棉纤维的检测和鉴定是一个复杂而耗时的过程。如果不确定是否存在石棉，则从现场收集样本(空气或固体，视情况而定),并使用扫描电子显微镜(SEM)和能谱仪(EDS)进行分析。通常通过使用特殊设计的泵收集样品，该泵迫使空气通过镀金过滤器，利用静电相互作用收集颗粒和纤维。在分析之前，使用氧等离子体蚀刻去除样品的有机成分。然后在扫描电镜下分析过滤器的随机选择部分，以寻找薄至 3 米和短至 5 米的石棉纤维。还根据规定的纤维计数规则对单根纤维进行计数，并根据纤维类型进行分类。通过使用 EDS 分析纤维的化学成分来进行分类。最后，对石棉纤维的浓度进行评估，并与规范(因国家而异)定义的标准值进行比较。如果评估的石棉浓度超过一定值，则需要根据指南进行进一步处理。
SEM 图像和 EDS 结果用于各种领域中不同类型材料的形态和化学分析，如医疗技术[3，4]，法医学[5]，建筑行业[6，7]等。然而，分析过程通常是耗时的，因为操作者在获得样品的电子图像后，需要用肉眼手动识别感兴趣的物体，然后选择获得 eds 光谱的位置。因此，这种方法不仅费时，而且费力，并有可能产生偏见。
在这项工作中，我们提出了一个基于深度学习(DL)的语义分割模型来自动化分析过程。所提出的模型能够识别和计数纤维的数量，其中神经网络掩蔽所识别的纤维区域并重新排列它们，使得它们可以作为输入提供给能量色散光谱(EDS)。
自动化过程如图 1 所示。
**图一。**基于 DL 的自动化石棉分析(图片由作者提供)
- 自动成像软件设置为无人值守运行，用于扫描电镜图像采集，为操作员腾出时间进行数据解释。
- 在 SEM 图像中有效地识别和定位纤维，例如，识别单根纤维、团块、部分覆盖有非石棉颗粒/灰尘的纤维等。；使用基于 DL 的图像识别技术。这些技术适应石棉纤维的形态特征，并提供石棉计数。
- 通过使用自动 EDS 程序对所识别的纤维位置进行化学分析，从而生成报告，该报告显示了在样品中发现的纤维数量，并且石棉的化学成分和长宽比符合规范分析过程的标准指南。
自动化过程有可能将石棉分析的周转时间减少到几分钟，而不是目前的手工处理时间 1-2 小时；预计成本降低高达 25%。
本文的其余部分组织如下:在第 2 部分，我们扩展图 1 以提供每个步骤的细节，子部分对应于图像捕获和图像分析(语义分割和纤维计数)阶段。第 3 节提供了实现细节，包括语义分割模型的训练规范和准确性结果。第 4 节对论文进行了总结，并为未来的工作提供了方向。
2 自动化分析
在本节中，我们展开图 1 来提供每个步骤的细节。图 2 示出了扩展的过程。
**图二。**自动化石棉分析步骤(图片由作者提供)
2.1 SEM 图像捕捉
使用标准成像软件收集 SEM 图像。收集几组图像，每组包含 100 个 SEM 图像。对于每组图像，工作距离(WD)、高电压(HV)、放大率、亮度和对比度被设置为特定值。所有 SEM 图像可以存储在计算机的本地硬盘上，也可以直接上传到云中，以便执行下一步。这些 SEM 图像然后被提供作为基于深度学习的语义分割模型的输入。
2.2 图像分析
如图 2 所示，整个过程包括预处理、语义分割、纤维计数，随后是负责优化 EDS 处理的神经网络输出的后压制步骤。我们从语义分割模型开始，它构成了图像分析模块的核心。
2.2.1 语义切分
语义分割指的是一种能够给图像中的每个像素分配类别(标签)的图像识别模型。这允许语义分割模型输出对象在图像中的位置、该对象的形状、哪个像素属于哪个对象等。因此，基于深度学习的语义分割模型包括训练神经网络以输出输入图像的逐像素掩码。
在文献中已经提出了不同的神经网络用于语义分割，例如 FCN [8]、SegNet [9]和 U-Net [10]。在这项工作中，我们将重点放在 UNet 架构上，它似乎对我们的问题域有效。
U-Net 是一种端到端的语义分割模型，它建立在基于卷积神经网络(CNN)的图像分类模型上；通过以编码器-解码器的方式堆叠一堆卷积层。编码器对图像进行下采样，给出图像的压缩特征表示，解码器使用例如转置卷积的方法对图像进行上采样，给出分段输出(不同于使用数学插值的其他方法)。直观地说，编码器由一堆传统的卷积和最大池层组成(在图像分类模型的线上)。因此，它能够捕捉图像的“是什么”信息。由于“在哪里”信息在语义分割中同样重要，解码器能够通过逐渐应用上采样来恢复“在哪里”信息(精确定位)。
我们遵循[10]中概述的原始 U-Net 架构，稍加修改即可接受 1024 x 768 x 3 的输入图像(在[10]中输入图像的大小为 572x572x3)。U-Net 的好处是它不包含任何密集层，因此它可以接受任何大小的图像。
2.2.2 预处理
本模块的目的是在提供所有 SEM 图像作为语义分割的输入之前，验证它们的质量。如果任何 SEM 图像被确定为在锐度、亮度、对比度或放大率方面不适于处理；该层试图通过执行必要的图像变换来纠正这一点。如果不成功，它会将图像返回到“图像捕获”层，突出显示问题，并在 SEM 图像捕获过程中提供解决问题的建议。
2.2.3 纤维数
回想一下，在 SEM 图像分析的某些特定情况下，如石棉(空气样品)分析，需要计算图像中纤维的长度、宽度和长宽比。此外，我们还需要确定图像视野中可见纤维的数量。这确定了图像中石棉纤维的浓度，如果发现石棉浓度超过了某一阈值，根据指导方针，这将要求进一步的处理。
给定一个语义分割输出，其中图像中的(分类的)纤维的像素已经被屏蔽，我们使用 OpenCV HoughLines()函数[11]来计算图像的长度和数量。下面提供了相应的 python 代码片段:
def **get_fiber_details**(img): model = get_model()
model.load_weights('Segmentation.h5)
img= get_image(file) y_pred = model.predict(img[None,...].astype(np.float32))[0]
y_pred = np.round(y_pred.reshape((IMAGE_H,IMAGE_W, NUMBER_OF_CLASSES)),0) for i in range(IMAGE_W):
for j in range(IMAGE_H):
if y_pred[j,i]>0:
img[j,i,1]=255
img[j,i,2]=0
img[j,i,0]=0
else:
img[j,i,1]=0
img[j,i,2]=0
img[j,i,0]=0 edges = cv2.Canny(img, 25,255)
lines = cv2.HoughLinesP(edges, 1, np.pi/180, 30, maxLineGap=250)
cnt=0
for line in lines:
x1, y1, x2, y2 = line[0]
print(x1, y1, x2, y2, math.sqrt((x1-x2)**2)+((y1-y2)**2))
cnt=cnt+1**print**('No of fibers: '+str(cnt)).........................................(Sample)**Output**72 764 166 167 356503.0
131 64 630 618 307415.0
66 764 188 136 394506.0
75 440 303 722 79752.0
91 468 291 715 61209.0
497 738 950 384 125769.0
141 94 637 590 246512.0
.........................No of fibers: 147
2.2.4 后处理
此步骤的目标是为 EDS 处理准备输出。能量色散 X 射线光谱(EDS)是一种分析技术，通常与 SEM 集成，用于分析样品的元素组成或化学特性。为了进行 EDS，通常，首先在样品表面收集 SEM 图像，然后在图像上手动标记具体位置，用于感兴趣物体的化学分析。一旦在图像上识别出所有感兴趣的位置，这些 XY 坐标被手动传送到 EDS 程序的用户界面，以对这些位置进行化学分析。这个手动过程非常耗时。
在自动化过程中，由 get_fiber_details 函数提供被识别纤维的(x，y)坐标作为输出。后处理包括以这样的方式对纤维进行分类，即在 EDS 过程中，SEM 内的样品台需要在两个指定位置之间移动最短的距离(相对于电子束)。因此，该步骤的输出是在图像中检测到的纤维的(x，y)坐标的优化图，这有助于减少 EDS 处理，进一步导致更有效的分析。该位置图被直接上传到 EDS 用户界面，用于对物体执行 EDS。
3 实施
语义分割模型使用 100 个铁石棉(空气样本)进行训练，训练/验证集的比例为 80-20。所有 100 个 SEM 图像将采用相同的成像参数拍摄，即尺寸、分辨率、亮度、对比度、HV、WD，所有图像的每个参数都是相同的。原则上，这些图像可以在不同位置的相同样本上收集，或者在具有相同对象的不同样本上收集。图 3 示出了从训练语义分割模型中使用的样本注释图像。
**图三。**用于训练的示例注释图像(作者提供的图像)
图 4 示出了屏蔽了检测到的纤维的 U-Net 语义分割模型的相应输出。正如可以观察到的，我们用我们的模型实现了> 95%的准确度(精确度)，仅用 100 幅图像进行了训练。
图 4。 U-Net 语义分割输出(图片由作者提供)
4 结论
鉴于石棉对健康的危害，我们提出了一种基于深度学习的语义分割神经网络来自动化石棉分析过程。据我们所知，这是第一篇报道使用语义分割进行石棉分析的实用性的文章。正如在实施部分中所概述的，至少对于空气样本图像，结果是相当有希望的，在空气样本图像中，我们能够基于在 100 个带注释的图像上训练的模型获得> 95%的准确度。
将来，我们计划扩展模型以适应大量的石棉样品，其中石棉纤维可能形成巨大的团块，只有很少的单纤维是可见的。在团块的图像中识别这些单纤维是困难和费时的。我们希望多类语义分割模型在这里将是成功的，因为它将能够检测和分类作为图像中的对象的纤维和纤维团。
参考
[1]https://asca-vabs . ch/asca/498/VDI _ richt linie _ 3492 _ jun 2013 . pdf
[2]“石棉:取样、分析和清理程序分析师指南”，ISBN: 9780717628759，系列代码:HSG248，2005。
[3] M. Scimeca，A. Orlandi，I. Terrenato，S. Bischetti，E. Bonanno，“通过 EDX 微量分析评估非小细胞肺癌中的金属污染物”，《欧洲组织化学杂志》，第 58 卷(3):2403，2014 年。
[4] M. Scimeca，A. Pietroiusti，F. Milano，L. Anemona，A. Orlandi，L. T. Marsella 等.“组织学标本的元素分析:揭开纳米石棉纤维面纱的方法”, Eur J histo chem，第 60 卷:2573 页，2016 年。
[5] M. E. Taylor，“法医科学中的扫描电子显微镜技术”，《法医科学学会杂志》，第 13 卷，第 269-280 页，1973 年。
[6] B. R. Bandli，M. E. Gunter，“石棉标准参考材料的扫描电子显微镜和透射电子背散射衍射检查、不同形态的闪石颗粒以及滑石矿石的颗粒相鉴别”，显微镜和微量分析，第 20 卷，第 1805-1816 页，2014 年。
[7] B.R. Bandli，M. E. Gunter，(2001 年)。使用纺锤台和扫描电子显微镜鉴定和表征矿物和石棉颗粒:以美国利比蒙大拿州闪石-石棉为例，《显微镜》，第 49 卷，第 191-199 页，2001 年。
[8] J. Long，E. Shelhamer，T. Darrell，“用于语义分割的全卷积网络”，IEEE 计算机视觉和模式识别会议论文集，第 3431–3440 页，2015 年。
[9] V. Badrinarayanan，A. Kendall 和 R. Cipolla，“ SegNet:用于图像分割的深度卷积编码器-解码器架构”，载于《IEEE 模式分析和机器智能汇刊》，第 39 卷，第 2481-2495 页，2017 年。
[10] O. Ronneberger，P. Fischer，T. Brox，“ *U-Net:卷积网络用于生物医学图像分割”，*载于:医学图像计算和计算机辅助干预，LNCS，第 9351 卷:234–241 页，2015 年。
[11]开源计算机视觉(OpenCV)，https://opencv.org/
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
