TowardsDataScience 博客中文翻译 2020（五百零八）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

如何使用 Docker 在 AWS 上部署仪表板应用程序

原文：https://towardsdatascience.com/how-to-use-docker-to-deploy-a-dashboard-app-on-aws-8df5fb322708?source=collection_archive---------3-----------------------

由卡洛斯·穆扎在 Unsplash 上拍摄

如何与更广泛的受众分享您的分析仪表板的分步指南

仪表板是探索数据和模型行为的绝佳方式。它们也是与技术和非技术涉众沟通的不可或缺的工具。我假设你不需要任何说服——你已经花了很多时间精心打磨你的 R Shiny 或 Python Dash web 应用程序！你为自己创造的东西感到自豪…但是仪表板只在你的笔记本电脑上工作。您如何允许其他人访问您的仪表板？

“我们大多数人需要听音乐才能理解它有多美。但这通常不是我们展示统计数据的方式:我们只展示音符，不播放音乐。”— 汉斯·罗斯林

本指南假设您已经准备好部署仪表板应用程序。如果不是这样，您可以通过克隆这个 Github repo 来完成。*不了解 Docker 或 AWS。*本次回购中的仪表板应用程序使用联合分析来分析用户对电动汽车的偏好。你可以在这里了解这个应用的更多信息。然而，您不需要理解这个仪表板做什么来遵循这个指南。仪表板的预览如下所示:

用于联合分析的仪表板应用程序

应用程序的文件结构如下所示:

图一。Python Dash web 应用程序的代码

在上面的 web 应用程序中，dashboard.py包含了应用程序代码。当用户与仪表板交互时，联合分析由dashboard.py中的函数触发，这些函数随后调用analyze.py中的相关联合函数来对Data和Precomputed Data文件夹运行计算。README.md是唯一依赖于Figures文件夹的文件。

Docker 如何帮助在云上部署？

Docker 使您能够部署一个包含所有所需部分(即库、依赖项)的应用程序，并将其作为一个单独的映像发布。我们可以在任何安装了 Docker 的主机上运行这些映像(即在任何 Docker 引擎上)，而不考虑架构或操作系统。这些运行的实例被称为容器。如果该映像在您的笔记本电脑上成功运行，您可以保证它可以在任何 Docker 引擎上运行。由于许多云平台支持 Docker 映像的运行，我们可以很容易地在云中部署仪表板应用程序。

现在我们对 web 应用程序和 docker 有了更多的了解，我们可以继续在 AWS 上部署它。

步骤 0:先决条件

要完成这项工作，您需要在系统上安装 Docker 以及一个 AWS 帐户。

子步骤 0a:在系统上安装 Docker

在您的系统上安装 Docker 的说明可从这里获得。如果你想在 Windows 或 OSx 上运行 Docker，你需要安装 Docker Desktop。由于 Docker 最初是为 Linux 构建的，Docker Desktop 将运行一个 Linux 虚拟机，该虚拟机随后启动基于 Linux 的映像。

子步骤 0b:注册 AWS 帐户

你可以在这个链接注册免费使用 AWS 服务一年。

子步骤 0c:安装 AWS 命令行界面

命令行界面(CLI)允许您从命令行调用 AWS 服务。您可以按照这里的说明安装 AWS CLI。

以下说明假设您已经安装了 CLI 版本 1。

步骤 1:为容器化准备仪表板应用程序

您的本地系统和 docker 容器之间有两个差异，可能会导致部署中的问题:

1. 网络配置
2. 文件系统

网络配置

在 Python Dash 的情况下，默认是让 app 在localhost运行。但是，在这种情况下，您只能从本地计算机访问服务器。该应用通常使用以下样板文件在本地部署*😗

if __name__ == '__main__':
    .
    .
    app.run_server(debug=True)

上面的代码不允许您从 Docker 引擎访问 dashboard 应用程序，因为该应用程序只能由容器访问。我们需要在dashboard.py中明确指定主机，以便从容器外部访问仪表板应用程序。

if __name__ == '__main__':
    .
    .
    app.run_server(host='0.0.0.0', port=8050, debug=True)

如上图修改dashboard.py并保存。一旦构建并运行了 docker 映像，我们就可以在[http://0.0.0.0:8050](http://0.0.0.0:8050)通过 web 浏览器访问仪表板。在 R 闪亮的情况下，只要我们在步骤 2 中露出适当的端口，仪表板就应该可以从[http://127.0.0.1:<port](http://127.0.0.1:8001)>处接近。我们可以在 R Shiny 应用程序代码中指定要使用的端口:

options(shiny.port = 8100)

文件系统

docker 容器的文件系统反映了 Linux 系统的文件系统。其根目录下包含bin、etc、mnt、srv、sys等文件夹。如果构建一个 Python Dash app，通常的做法是将 app 的源代码存储在根目录下的app文件夹中。在闪亮的情况下，我们可以在srv文件夹里面创建一个子文件夹shiny-server来存储源代码。

因此，当应用程序被容器化时，我们在源代码中指定的任何相对路径几乎肯定不起作用，因为容器将当前路径作为其根目录(默认)。最简单的解决方案是将容器的当前目录改为指向源代码的位置。我们将在步骤 2 中看到如何做到这一点。

另一个(次优)解决方案是修改源代码，这样我们就可以给出绝对路径。例如，在dashboard.py中，我们可以将第 16 行和第 17 行修改为:

folderStr = "/app/Data/"  # old version was "./Data"
destFolder = "/app/Precomputed Data/"

这种方法带来的问题是仪表板应用程序变得更难维护。让我们在dashboard.py中保持文件路径不变。相反，我们将在步骤 2 中明确更改工作目录。

第二步:从你的 dashboard 应用程序构建一个 Docker 图像

我们创建一个文件夹DashboardImage,我们将在其中填充 Docker 图像的原始内容。最终，任何 Docker 引擎都可以使用这个 Docker 映像来运行 dashboard 应用程序。让我们在DashboardImage中创建以下文件结构:

图二。仪表板图像的内容

让我们更仔细地看看这个目录的内容:

• app文件夹:除了README.md和Figures文件夹，我们将 Dashboard app 内容(如图 1 所示)复制到这个文件夹中。
• Figures文件夹:将仪表盘 app 的Figures文件夹复制到这里。这个文件夹只有README.md需要。
• README.md:将README.md从app文件夹移到这里。
• Dockerfile:用于创建满足仪表板应用程序要求的图像的指南。
• requirements.txt:只有当你的仪表板是用 Python 写的时候才需要。它列出了运行 Dashboard 应用程序所需的库。通过在这里指定所需的 Python 包，我们使Dockerfile更具可读性。有了闪亮的，我们省略这个文件，在Dockerfile中显式安装所需的包。

子步骤 2a:编写 requirements.txt 文件

requirements.txt文件应该包含您的仪表板需要的所有库。它可能看起来像这样:

dash
dash-renderer
dash-core-components
dash-html-components
dash-table
plotly
numpy
pandas
scipy
matplotlib
seaborn

仪表板需要前六个库才能正确呈现。analyze.py需要剩余的库来执行联合分析。

子步骤 2b:编写 Dockerfile 文件

Dockerfile包含设置仪表板应用程序的说明。Dockerfile分层构建图像。每行都有格式:<指令>自变量>。让我们创建以下Dockerfile:

FROM continuumio/miniconda3COPY requirements.txt /tmp/
COPY ./app /app
WORKDIR "/app"RUN conda install --file /tmp/requirements.txtENTRYPOINT [ "python3" ]
CMD [ "dashboard.py" ]

第一行从 Dockerhub(一个公共的容器库)中提取一个基本映像。基本映像包含 Miniconda，它位于基本 Ubuntu 发行版之上。如果你想部署一个闪亮的应用程序，你可以选择rocker/shiny图片。

第二行和第三行将requirements.txt文件和app文件夹从主机上的应用程序文件夹复制到 Docker 容器根目录下的tmp文件夹和app文件夹。如果这些文件夹不存在，则会自动创建。第四行将工作目录设置为app文件夹。这一行是适应容器文件结构的首选解决方案，因为它只需要对Dockerfile进行更改。

第五行安装requirements.txt中指定的每个包。对于一个闪亮的应用程序，你需要明确指定你想要安装的每个包。例如:

RUN R -e "install.packages(c('package1', 'package2', 'package3'))"

我们还想为闪亮的应用程序公开正确的端口。因此，我们将在Dockerfile中包含以下行:

EXPOSE <PORT NUMBER>

ENTRYPOINT指定当图像作为容器运行时将执行的命令。如果我们在运行 docker 映像时没有指定参数，Docker 将使用CMD行中显示的默认参数来执行，这将使 Python 运行 dashboard 应用程序。注意，我们不需要指定应用程序的绝对路径，即/app/dashboard.py，因为我们已经将工作目录更改为/app。在 R 中，我们使用CMD来执行闪亮的服务器。

第三步:建立你的码头工人形象

一旦创建了内容，我们就可以构建一个 docker 映像。为了创建图像conjoint_dashboard，进入DashboardImage文件夹并运行以下程序:

docker build -t conjoint_dashboard .

Docker 通过Dockerfile一行一行地构建软件层。

要确认关于图像的一些基本细节，运行docker images。

REPOSITORY             TAG     IMAGE ID       CREATED        SIZEconjoint_dashboard     latest  b50b2d7a61cc   6 seconds ago  2.32GBcontinuumio/miniconda3 latest  406f2b43ea59   4 months ago   430MB

您还可以通过运行以下命令来检查映像是否构建正确:docker run conjoint_dashboard。回想一下在步骤 1 中，我们修改了dashboard.py以使主机可以在[http://0.0.0.0:8050](http://0.0.0.0:8050)访问。从 docker 机器(即您的计算机)上，在上述地址打开一个 web 浏览器，检查仪表板是否按预期工作。

第四步:上传你的 Docker 图片到 Amazon 注册

我们需要确保我们的图像在 AWS 中可用。为此，我们需要执行以下步骤:

• 在 ECR(AWS 弹性容器注册中心)中创建一个存储库dashboard。我们特意给 AWS 存储库取了一个与我们构建的映像不同的名称，这样我们就可以很容易地区分这两者。
• 为您的 AWS 帐户创建访问密钥
• 使 Docker 客户端能够向 AWS 注册中心进行身份验证
• 将conjoint_dashboard推入dashboard仓库

子步骤 4a:在 ECR 中创建存储库

登录 AWS 管理控制台。您的首次登录将使用您的 root 帐户。登录后，搜索“ECR”。弹性容器注册中心(ECR)是一个完全托管的 Docker 容器注册中心。一个注册中心是一个储存库的集合。点击开始创建新的存储库。我们将存储库命名为dashboard，并单击创建存储库。

子步骤 4b:创建访问密钥

我们将为 root 帐户创建一个访问密钥。避免使用 root 帐户是一个很好的做法，因为它提供了对 AWS 资源的无限制访问。然而，为了简化过程，我们将使用 root 帐户部署应用程序。

要创建访问密钥，请单击您的帐户名，然后单击我的安全凭证。

在新屏幕中，打开访问密钥(访问密钥 ID 和秘密访问密钥)下拉菜单，点击创建新的访问密钥。创建密钥后，您将收到以下消息。

下载凭据并将其存储在安全的地方。

子步骤 4c:使 Docker 客户端能够通过 AWS 进行身份验证

使用您新创建的访问密钥，您将需要在终端中使用以下命令配置您的aws_access_key_id和aws_secret_access_key:

aws configure set aws_access_key_id <YOUR_ACCESS_KEY>
aws configure set aws_secret_access_key <YOUR_SECRET_KEY>

我们还需要设置区域和输出格式。您所在的地区可以从 AWS 管理控制台中找到。

然后，我们可以在终端中运行以下命令:

aws configure set default.region <YOUR_REGION>
aws configure set default.output json

我们现在可以尝试登录 ECR:

$(aws ecr get-login --no-include-email --region <YOUR REGION>)

您应该会收到一条登录成功的消息。

子步骤 4d:将构建的仪表板推入 AWS 存储库

我们首先用新创建的仪表板存储库的 URI 来标记conjoint_dashboard。您可以通过点击dashboard存储库在 AWS 管理控制台中找到 URI:

我们通过在终端中运行以下命令，用上面的 URI 标记图像conjoint_dashboard:

docker tag conjoint_dashboard <ACCOUNT NUM>.dkr.ecr.<REGION>.amazonaws.com/dashboard

我们现在可以将图像推送到存储库。

docker push <ACCOUNT NUM>.dkr.ecr.<REGION>.amazonaws.com/dashboard

将conjoint_dashboard图像上传到注册表所需的时间取决于您的互联网连接。图片推送后，点击 ECR 中的dashboard即可找到图片。

您将需要图像 URI 来部署仪表板应用程序。图像标签latest显示在 URI 的末尾(冒号后),表示仪表板的版本。

步骤 5:使用 ECS 部署 Docker 容器

弹性容器服务(ECS)运行和管理 Docker 容器。它是高度可伸缩的，允许自动部署更多的容器来满足需求。返回 AWS 管理控制台的主页，搜索“ECS”。

进入 ECS 后，让我们单击开始按钮。您将被带到步骤 1:容器和任务。容器定义描述了容器的需求以及系统应该如何运行容器。通过点击配置按钮，我们可以配置容器来容纳仪表板应用程序。

我们只需要填充前两个字段。我们将容器命名为conjoint_dashboard，并用在步骤 4 结束时给出的图像 URI 填充第二个字段。点击更新。

向下滚动到任务定义并点击编辑。在这里，我们可以指定容器的硬件要求。我们如下填充这些字段，然后保存。

当我们点击下一个的时，我们将被带到服务定义页面。这些字段是预先填充的，因此单击下一个的进入集群定义。我们需要做的就是将集群命名为“联合”，然后点击下一步*。然后您可以查看配置并点击创建。*

这个过程需要几分钟。完成后，点击查看服务。

步骤 6:访问仪表板服务

默认情况下，该服务只允许端口 80 上的流量。这是一个问题，因为 Docker 容器只能在端口 8050 上访问。因此，我们需要改变安全组的规则。点击安全组标识符。

页面加载后，点击入站规则选项卡和编辑规则按钮。

点击保存规则前，按如下方式重新填充字段。

我们可以通过单击 ECS 侧栏中的集群并单击conjoint来检查服务是否正在运行。页面加载后，点击任务选项卡，然后点击任务标识符。

将显示任务配置。

我们可以看到任务正在运行，并且可以在地址[http://13.239.27.169:8050](http://13.239.27.169:8050.)访问。当然，你的 IP 会不一样。用您的 IP 地址代替上面的 IP 地址，您应该可以访问您的仪表板。为了快速浏览这个应用程序，你可以观看这个链接。

访问 AWS 上的仪表板

结论

你有它！通过仔细遵循这些步骤，您将成功地在 AWS 上部署了一个仪表板应用程序。通过在步骤 5 中正确配置 ECS 设置，还可以使服务可扩展，随着需求的增加自动部署新任务。

感谢阅读！如果你觉得这些材料有用，你可能也会觉得我最近写的一篇文章很有趣:不，深度学习是不够的

如何在 BigQuery 中使用动态 SQL

原文：https://towardsdatascience.com/how-to-use-dynamic-sql-in-bigquery-8c04dcc0f0de?source=collection_archive---------2-----------------------

格式化字符串，并使用立即执行

比方说，我们想要查找过去 3 天加拿大各省确诊的 COVID 病例数。有一个 BigQuery 公共数据集，里面有 Johns Hopkins 发布的信息，我们可以如下查询:

SELECT 
 *   
FROM `bigquery-public-data`.covid19_jhu_csse.confirmed_cases
WHERE country_region LIKE 'Canada'

我们得到:

每个日期都有一栏

呀！每个日期都有一栏。我们如何找到最近三天的数据？

BigQuery 中的动态 SQL！图片由来自 Pixabay 的 Jim Semonik 拍摄

获取列的信息模式

我们可以使用 INFORMATION_SCHEMA 来获取列的列表，并使用以下命令来查找最近三天:

SELECT 
   column_name, 
    parse_date('_%m_%d_%y', column_name) AS date
FROM 
  `bigquery-public-data`.covid19_jhu_csse.INFORMATION_SCHEMA.COLUMNS
WHERE 
    table_name = 'confirmed_cases' AND 
    STARTS_WITH(column_name, '_')
ORDER BY date DESC LIMIT 3

这将返回:

表中的最近天数

创建动态 SQL 语句

您可以使用 EXECUTE IMMEDIATE 运行动态 SQL 语句。例如，假设我们有一个列名为 _5_18_20 的变量，这就是如何使用它来执行 SELECT 语句:

DECLARE col_0 STRING;
SET col_0 = '_5_18_20';**EXECUTE IMMEDIATE** **format**("""
  SELECT 
     country_region, province_state, 
    ** %s** AS cases_day0
  FROM `bigquery-public-data`.covid19_jhu_csse.confirmed_cases
  WHERE country_region LIKE 'Canada'
  ORDER BY cases_day0 DESC
""", **col_0);**

仔细看看上面的查询。首先，因为我声明了一个变量，等等。，这是一个 BigQuery 脚本，其中每个语句都以分号结束。

然后，我使用 BigQuery 的字符串格式函数来创建我想要运行的语句。因为我要传入一个字符串，所以我在格式字符串中指定了%s，并传入 col_0。

结果包括两个阶段:

第二阶段的结果是:

编写过去 3 天的脚本

我们可以结合以上三个想法——INFORMATION _ SCHEMA、脚本和立即执行来获得过去 3 天的数据。

DECLARE columns ARRAY<STRUCT<column_name STRING, date DATE>>;SET columns = (
  WITH all_date_columns AS (
    SELECT column_name, parse_date('_%m_%d_%y', column_name) AS date
    FROM `bigquery-public-data`.covid19_jhu_csse.INFORMATION_SCHEMA.COLUMNS
    WHERE table_name = 'confirmed_cases' AND STARTS_WITH(column_name, '_')
  )
  SELECT ARRAY_AGG(STRUCT(column_name, date) ORDER BY date DESC LIMIT 3) AS columns
  FROM all_date_columns
);EXECUTE IMMEDIATE format("""
  SELECT 
     country_region, province_state, 
     %s AS cases_day0, '%t' AS date_day0,
     %s AS cases_day1, '%t' AS date_day1,
     %s AS cases_day2, '%t' AS date_day2
  FROM `bigquery-public-data`.covid19_jhu_csse.confirmed_cases
  WHERE country_region LIKE 'Canada'
  ORDER BY cases_day0 DESC
""", 
columns[OFFSET(0)].column_name, columns[OFFSET(0)].date,
columns[OFFSET(1)].column_name, columns[OFFSET(1)].date,
columns[OFFSET(2)].column_name, columns[OFFSET(2)].date
);

步骤:

• 将列声明为一个数组变量，该变量将存储最近 3 天的列名和日期
• 将列设置为获取 3 天的查询结果。请注意，我正在使用 ARRAY_AGG，这样我就可以将完整的结果集存储在一个变量中。
• 格式化查询。请注意，我使用`%t '来表示时间戳(有关详细信息，请参见字符串格式文档),并传入了六个参数。

结果是:

使用立即执行

除了使用字符串格式，您还可以使用如下命名变量:

EXECUTE IMMEDIATE """
  SELECT country_region, province_state, _5_18_20 AS cases 
  FROM `bigquery-public-data`.covid19_jhu_csse.confirmed_cases 
  WHERE country_region LIKE [**@country**](http://twitter.com/country)
  ORDER BY cases DESC LIMIT 3
"""
**USING 'Canada' AS country;**

您也可以使用问号来处理位置变量:

EXECUTE IMMEDIATE """
  SELECT country_region, province_state, _5_18_20 AS cases 
  FROM `bigquery-public-data`.covid19_jhu_csse.confirmed_cases 
  WHERE country_region **LIKE ?**
  ORDER BY cases DESC **LIMIT ?**
"""
**USING 'Canada', 3;**

USING 子句在某些情况下很棘手。例如，以下内容不起作用:

*EXECUTE IMMEDIATE """
  SELECT country_region, province_state, ? AS cases -- PROBLEM!!!
  FROM `bigquery-public-data`.covid19_jhu_csse.confirmed_cases 
  WHERE country_region LIKE ?
  ORDER BY cases DESC LIMIT ?
"""
USING '_5_18_20', 'Canada', 3; -- DOESNT WORK!!!!*

这是因为第一个参数被解释为:

*'_5_18_20' AS cases*

因此，不能通过使用。因此，我推荐使用 String FORMAT()来创建立即执行的查询，因为它没有这些问题。

下一步是什么？PIVOT()，就是这样！

动态 SQL 特性是在 big query 10 岁生日的时候发布的。这里有一个视频，一些 BigQuery 的朋友祝它生日快乐:

来自 10 年前的第一个用户线程对在几秒钟内处理 60B 记录赞不绝口，并对近乎实时的查询(事情越变越多……)深思熟虑。在同一个线程中是第一个功能请求…枢轴:

动态 SQL 最终使这成为可能， Felipe Hoffa 承诺他将编写一个函数，最终能够在 BigQuery 中使用 PIVOT()——敬请期待。

尽情享受吧！

感谢我的同事Jagan r . Athreya对使用格式的有益讨论和建议，并感谢feli PE Hoffa的怀旧之旅。

中的 DynamoDB 流和 AWS Lambda 入门。网络核心

原文：https://towardsdatascience.com/how-to-use-dynamodb-streams-with-aws-lambda-and-net-core-62db43ae98c1?source=collection_archive---------14-----------------------

使用 AWS Lambda 在 C#中使用 DynamoDB 流的分步教程

事件驱动编程在当今的软件世界中非常流行。用松散耦合的、可独立部署的、易于扩展的组件来构建一个系统有很多优点。可以利用无服务器工具来创建其中的一些组件；一个 AWS，这通常意味着使用 DynamoDB 和 Lambda。在本文中，我们将构建一个小型的事件驱动系统，其中 DynamoDB 是我们的事件源，Lambda 函数被调用来响应这些事件。为此，我们将使用一个名为 DynamoDB Streams 的特性。

在一个表上启用 DynamoDB 流后，对该表的所有修改都会被记录下来，并按顺序推送到流中。AWS 没有指定流的内部，但是它们非常类似于 Kinesis 流(并且可能在幕后使用它们)。)有多种方法来使用流，包括使用 Kinesis 客户端库(AWS 提供的 SDK)，但最简单的方法之一是将流配置为 Lambda 函数的触发器。

现在，让我们浏览启用 DynamoDB 流的过程，编写一个简短的 Lambda 函数来使用流中的事件，并将 DynamoDB 流配置为 Lambda 函数的触发器。我们将一步一步来，但如果你想跳到最后，检查源代码和 Terraform，直接去我的 GitHub repo 。如果你需要复习 DynamoDB 的基础知识，可以看看我写的关于开始使用 DynamoDB 的文章。

先决条件

为了准确地遵循这个指南，你需要安装 Visual Studio 2019 和 AWS 工具包。我在这里使用这种设置是因为它与 Lambda 紧密集成；只需点击一下，即可将您的代码发布到 AWS。

我包含了一个 Terraform 文件来创建 DynamoDB 表(包括它的索引和流)。如果你以前没有使用过 Terraform，这是一个很棒的工具，可以让你把基础设施写成代码。或者，您可以使用 AWS 管理控制台手动创建和配置 DynamoDB 表。

创建 DynamoDB 表和流

我们先来看一下 Terraform 文件 main.tf 。该文件只包含一个资源(基础设施对象)——我们的 DynamoDB 表。在这个资源中，定义了表的每个属性和索引(在的前一篇文章中概述了全局和辅助索引)。)

启用流所需的两个参数是 stream_enabled(布尔)
和 stream_view_type(枚举)。steam_view_type 允许您选择将多少数据推送到流中。您可以从四个选项中进行选择:

• KEYS_ONLY —仅修改记录的分区和排序键
• NEW _ IMAGE 更新记录的所有属性
• OLD_IMAGE —修改前记录的所有属性
• 新图像和旧图像-修改前后的所有属性

在我们的示例中，我们将选择 NEW_AND_OLD_IMAGES，这样我们可以获得尽可能多的信息。一般来说，您会希望在使用最少数据量的同时选择满足您需求的选项。

如果您想使用 Terraform 在 AWS 中运行这个数据库，唯一需要的先决条件是您的机器上已经存储了共享 AWS 凭证(如果您曾经使用过 AWS CLI，那么您已经准备好了。)下载 Terraform 并添加到你的路径中。编辑 main.tf 文件，并将“profile”更改为您自己的 AWS 概要文件的名称。然后在包含。tf 文件并运行以下两个命令:

Terraform 将执行生成基础设施所需的所有 AWS APIs。如果您对 terraform 文件进行了更改，您可以再次运行“terraform 应用”来执行更新。当你用完后，执行“terraform destroy”将从你的 AWS 环境中删除你的所有更改。

创建一个 Lambda 来使用该流

有了我们的表，让我们为 Lambda 函数编写代码来使用它。打开 Visual Studio 201 并创建一个新的 AWS Lambda 项目(。NET Core c#)；一旦安装了 AWS Toolkit for Visual Studio，就可以使用这个模板。当提示选择蓝图时，选择“空函数”,因为我们要从头开始。

看看我们项目的 NuGet 依赖项。模板已经添加了基本 Lambda 函数所需的包。

我们需要再添加一个依赖项。从管理 Nuget 包窗口，搜索并安装 Amazon.Lambda.DynamoDBEvents。看一看它，然后我们将讨论它:

在顶部附近，我们为 Amazon 添加了一个 using 指令。Lambda.DynamoDBEvents 命名空间。然后我们转到模板提供的 Lambda 函数(FunctionHandler)，它接受一个字符串和一个 ILambdaContext 作为参数。ILambdaContext 包含关于 Lambda 函数的有用信息，比如内存限制、剩余执行时间和日志访问，所以我们将保留这些信息。我们用 DynamoDBEvent 替换了 string 参数；此对象包含 DynamodbStreamRecord 对象的列表。每个 DynamodbStreamRecord 都是对 DynamoDB 表的单个数据修改的描述。

当我们配置 Lambda 来监听 DynamoDB 流时，我们将选择一个最大批处理大小和一个收集该批处理的时间窗口。因此，我们的函数需要能够在每次被调用时处理多个 DynamodbStreamRecord。所以我们添加了一个循环来遍历 DynamoDBEvent 中的每一项并执行一些操作。在我们的示例中，操作是使用 ILambdaContext。Logger 将关于事件的信息写入 CloudWatch，但是您可以修改函数的内容以适应您的用例。

代码准备就绪后，我们可以通过在解决方案资源管理器中右键单击项目并选择“发布到 AWS Lambda”来将函数发布到 AWS。"为您的新 Lambda 函数选择一个名称和一个 AWS 区域。

下一个屏幕将询问关于 Lambda 的更多细节。我们将对默认值进行的唯一更改是选择一个 IAM 角色；这指定了 Lambda 在执行期间必须与其他 AWS 服务交互的特权。基于 AWSLambdaDynamoDBEecutionRole 创建一个新角色—这允许对 DynamoDB 流的列表和读取访问，以及对 CloudWatch 日志的写入访问。然后继续把你的函数上传到云端。

Lambda 配置— AWS 控制台

最后一步，导航到 AWS 控制台的 Lambda 部分，选择我们刚刚发布的函数。

我们将添加一个触发器，以便每当记录被添加到 DynamoDB 流中时启动 Lambda 函数。从功能配置屏幕中选择“添加触发器”并选择 DynamodDB。您将看到下面的屏幕，为我们的事件源编写详细信息。

确保选择了所需的 DynamoDB 表，然后查看其他选项。批处理大小是每次执行时发送给我们的函数的 DynamodbStreamRecords 的最大数量。批处理窗口决定了流从表中读取事件并调用 Lambda 函数的步调，以秒为单位。对于这个例子，默认的选择就足够了，但是在现实世界中，您会希望根据您的用例来定制这些选择。较短的批处理窗口对于需要接近实时地对更新做出反应的应用程序来说是有意义的，而较长的窗口(和较大的批处理大小)在处理单个项目是快速操作并且可以在批处理过程之间暂停的情况下可能更具成本效益。

测试和验证

是时候试试我们创造的东西了。前往 AWS 控制台中的 DynamoDB 表，并开始进行更改。添加一些新记录。修改现有记录。我们如何知道我们的流和 Lambda 是否在工作？嗯，由于我们的 Lambda 写入 CloudWatch，我们必须检查日志。在 AWS 控制台中导航到 CloudWatch，并从侧栏中选择 log groups。

您应该会看到一个与 Lambda 函数同名的组。打开它，你会发现一个日志流列表。Lambda 函数的每个执行上下文将创建一个流。作为参考，第一次调用函数时，会创建一个执行上下文(函数的临时运行时环境)。连续调用你的函数会遇到相同的上下文，直到十分钟后你的函数才执行。冷却期过后，再次调用 Lambda 将导致函数被加载到一个新的执行上下文中(这就是所谓的冷启动。)对函数的多次同时调用也可能导致创建新的执行上下文，因为一个执行上下文一次只能处理一个请求。

无论如何，您应该看到至少一个日志流。如果没有，请尝试刷新页面；有时日志需要一段时间来传播。如果你仍然运气不好，检查你为 Lambda 配置的触发器，确保它被设置到正确的 DynamoDB 表。此外，如果您的批处理窗口大小被设置为大于零的任何值，那么您必须等到它到期时，流才会收集所有的表修改。当您点击流时，您应该会看到类似如下的日志:

您还可以进入 CloudWatch 指标，显示有关您的功能的更多信息。下面你会发现一个令人兴奋的函数调用图；你可以看到我们在 2:25 从 0 到 1。

概述

流允许有趣的用例，否则在 DynamoDB 中很难支持这些用例。每当一个用户超过他当前的最高分，我们就可以给他发电子邮件。我们还可以聚合数据并将其写入另一个表中；也许我们会跟踪某个游戏的高分在某个时间窗口内改变了多少次。流还支持数据复制；这在我们希望在更适合这类活动的数据库(如 SQL Server 或 Redshift)中运行分析查询的情况下非常有用。)花几分钟时间试用它们，看看它们是否适合您未来应用程序中的用例。

如何在 Javascript 中使用 Generator 和 yield

原文：https://towardsdatascience.com/how-to-use-generator-and-yield-in-javascript-d1771bf698cd?source=collection_archive---------49-----------------------

更好的编程

你知道 JavaScript 里有个叫“生成器”的东西吗？

由Thomas re abourg在 Unsplash 拍摄的照片

前段时间我写了一篇文章解释了生成器的概念以及如何在 Python 中使用它们，但是你知道 JavaScript 也有自己版本的生成器吗？这其实是一个很多开发 JavaScript 应用的人都不知道它存在的概念，所以今天我们要介绍的是 JavaScript 中的生成器。

什么是发电机？

在 ES6 中，我们引入了伟大的新功能，如箭头函数、扩展操作符和生成器等等，但是什么是生成器呢？生成器是一个与普通函数相反的函数，它允许函数退出并在以后重新进入，并在重新进入时保留其上下文(变量绑定)。

让我们把它分解开来，一步一步地研究发电机，这样我们都可以理解它们是如何工作的。当我们执行一个常规函数时，解释器会将所有代码运行到那个函数中，直到函数完成(或者抛出一个错误)。这就是所谓的运行至完成模型。

让我们以一个非常简单的函数为例:

function regularFunction() {
    console.log("I'm a regular function")
    console.log("Surprise surprice")
    console.log("This is the end")
}regularFunction()-----------------
Output
-----------------
I'm a regular function
Surprise surprice
This is the end

还没有什么新奇的东西，正如你所期望的，这是一个常规函数，它会一直执行到最后或者返回值。但是如果我们只想在任意点停止函数来返回值，然后继续呢？这时，发电机就出现了。

我的第一个生成器函数

function* generatorFunction() {
    yield "This is the first return"
    console.log("First log!")
    yield "This is the second return"
    console.log("Second log!")
    return "Done!"
}

在我们执行这个函数之前，你可能会想知道一些事情，首先什么是function*？这就是我们用来将函数声明为生成器的语法。而yield呢？与 return 不同的是，yield将通过保存函数的所有状态来暂停函数，并在随后的调用中从该点继续。在这两种情况下，表达式都将返回给调用方执行。

我们的功能到底发生了什么？让我们通过调用函数来找出答案:

generatorFunction()-----------------
Output
-----------------
generatorFunction {<suspended>} {
    __proto__: Generator
    [[GeneratorLocation]]: VM272:1
    [[GeneratorStatus]]: "suspended"
    [[GeneratorFunction]]: ƒ* generatorFunction()
    [[GeneratorReceiver]]: Window
    [[Scopes]]: Scopes[3]
}

等等，什么？当我们调用一个生成器函数时，这个函数不会被自动触发，而是返回一个迭代器对象。这个对象的特别之处在于，当调用方法 next()时，生成器函数的主体被执行，直到第一个yield或return表达式。让我们来看看它的实际应用:

const myGenerator = generatorFunction()
myGenerator.next()-----------------
Output
-----------------
{value: "This is the first return", done: false}

如前所述，生成器一直运行到第一条yield语句，并生成一个包含value属性和done属性的对象。

{ value: ..., done: ... }

• value属性等于我们产生的值
• done属性是一个布尔值，它只在生成器函数返回值时设置为true。(未屈服)

让我们再次调用next()，看看我们会得到什么

myGenerator.next()-----------------
Output
-----------------
First log!
{value: "This is the second return", done: false}

这次我们首先看到我们的生成器主体中的console.log被执行并打印First log!，以及第二个生成的对象。我们可以继续这样做:

myGenerator.next()-----------------
Output
-----------------
Second log!
{value: "Done!", done: true}

现在第二个console.log语句被执行，我们得到一个新的返回对象，但是这次属性done被设置为true。

属性的值不仅仅是一个标志，它是一个非常重要的标志，因为我们只能迭代一个生成器对象一次！。不相信我？尝试再次呼叫next():

myGenerator.next()-----------------
Output
-----------------
{value: undefined, done: true}

还好它没有崩溃，但是我们只是得到了未定义的结果，因为value和done属性仍然设置为 true。

产生迭代器

在我们进入一些场景之前，yield 操作符还有一个特殊性，那就是yield*。让我们通过创建一个函数来解释它，这个函数允许我们迭代一个数组，我们可以天真地想到这样做:

function* yieldArray(arr) {
    yield arr
}const myArrayGenerator1 = yieldArray([1, 2, 3])
myArrayGenerator1.next()-----------------
Output
-----------------
{value: Array(3), done: false}

但这并不是我们想要的，我们想要产生数组中的每个元素，所以我们可以尝试这样做:

function* yieldArray(arr) {
    for (element of arr) {
        yield element
    }
}const myArrayGenerator2 = yieldArray([1, 2, 3])
myArrayGenerator2.next()
myArrayGenerator2.next()
myArrayGenerator2.next()-----------------
Output
-----------------
{value: 1, done: false}
{value: 2, done: false}
{value: 3, done: false}

现在我们得到了想要的结果，但是我们能做得更好吗？是的，我们可以:

function* yieldArray(arr) {
    yield* arr
}const myArrayGenerator3 = yieldArray([1, 2, 3])
myArrayGenerator3.next()
myArrayGenerator3.next()
myArrayGenerator3.next()-----------------
Output
-----------------
{value: 1, done: false}
{value: 2, done: false}
{value: 3, done: false}

太棒了，通过使用 yield* expression，我们可以迭代操作数，并产生它返回的每个值。这适用于其他生成器，数组，字符串，任何可迭代的对象。

既然您已经了解了 JavaScript 中的所有生成器，那么它们有什么用处呢？

发电机的使用

关于生成器的伟大之处在于它们是惰性计算的，这意味着在调用next()方法后返回的值，只有在我们明确请求后才被计算。这使得生成器成为解决多种场景(如下所示)的好选择。

生成一个无限序列

正如我们在 Python 文章中看到的，生成器适合生成无限序列，这可以是从质数到简单计数的任何东西:

function* infiniteSequence() {
    let num = 0
    while (true) {
        yield num
        num += 1
    }
}for(i of infiniteSequence()) {
    if (i >= 10) {
        break
    }
    console.log(i)
}-----------------
Output
-----------------
0
1
2
3
4
5
6
7
8
9

注意，在这种情况下，我在i >= 10时退出循环，否则，它将永远运行(或者直到手动停止)。

实现 iterables

当你需要实现一个迭代器时，你必须用一个next()方法手工创建一个对象。此外，您必须手动保存状态。

假设我们想创建一个只返回I、am、iterable的 iterable。如果不使用发电机，我们将不得不做这样的事情:

const iterableObj = {
  [Symbol.iterator]() {
    let step = 0;
    return {
      next() {
        step++;
        if (step === 1) {
          return { value: 'I', done: false};
        } else if (step === 2) {
          return { value: 'am', done: false};
        } else if (step === 3) {
          return { value: 'iterable.', done: false};
        }
        return { value: '', done: true };
      }
    }
  },
}
for (const val of iterableObj) {
  console.log(val);
}-----------------
Output
-----------------
I
am
iterable.

有了发电机，这就简单多了:

function* iterableObj() {
    yield 'I'
    yield 'am'
    yield 'iterable.'
}for (const val of iterableObj()) {
  console.log(val);
}-----------------
Output
-----------------
I
am
iterable.

更好的异步？

一些人认为生成器有助于改进承诺和回调的使用，尽管我更喜欢简单地使用 await/async。

警告

当我们使用发电机时，并不是所有的东西都闪闪发光。设计有一些限制，有两个非常重要的考虑因素:

• 生成器对象只能一次性访问。一旦用完，就不能再迭代了。为此，您必须创建一个新的生成器对象。
• 生成器对象尽可能不允许随机访问，例如数组。由于值是一个接一个生成的，您无法获得特定索引的值，您将不得不手动调用所有的next()函数，直到您到达所需的位置，但是之后，您将无法访问先前生成的元素。

结论

生成器函数对于优化我们的应用程序的性能非常有用，并且有助于简化构建迭代器所需的代码。

我希望您现在已经很好地理解了 JavaScript 中的生成器，并且可以在您的下一个项目中使用它们。

感谢阅读！

Jupyter 笔记本如何使用 Git / GitHub

原文：https://towardsdatascience.com/how-to-use-git-github-with-jupyter-notebook-7144d6577b44?source=collection_archive---------1-----------------------

这是一个针对 Jupyter 笔记本用户的综合性 Git 教程。如果你已经熟悉某一部分，可以随意跳过。最后你将能够-

• 将您的笔记本推送到 GitHub 存储库
• 开始版本化您的笔记本
• 在 GitHub 上查看笔记本拉取请求
• 了解如何恢复到特定版本
• 获得反馈并与您的同事讨论笔记本电脑的变化
• 轻松共享您的笔记本供他人查看

创建 GitHub 帐户

如果您没有 GitHub 帐户，请在这里创建一个。

在本地设置 Git

• 下载并安装Git 的最新版本。
• 通过在终端上运行以下命令，在 git 中设置您的姓名和电子邮件

>> git config --global user.name "Mona Lisa"
>> git config --global user.email "email@example.com"

• 通过缓存您的密码，用 GitHub 连接您的本地 git 客户端。

创建新存储库

GitHub 存储库就像你在云中的超级文件夹。您可以存储文件(笔记本、数据、源代码)，查看这些文件的历史更改，打开问题，讨论更改等等。人们通常为每个项目创建一个存储库。

让我们继续在 GitHub 上创建一个存储库。创建后，您将看到如下页面，复制突出显示的存储库 URL。

克隆存储库

让我们通过在终端上运行以下命令，在我们的机器上克隆 GitHub 存储库。它将在我们的机器上创建 projectA 目录，该目录链接到 GitHub 上的 amit1rrr/projectA 存储库。将[https://github.com/amit1rrr/projectA.git](https://github.com/amit1rrr/projectA.git)替换为上一步中您自己的存储库 URL

>> git clone https://github.com/amit1rrr/projectA.git
   Cloning into 'projectA'...
   warning: You appear to have cloned an empty repository.

将笔记本推送到 GitHub

我们的存储库现在是空的，让我们把一些笔记本推到它。我们将两个笔记本复制到我们克隆项目的目录下，

>> cp /some/path/analysis1.ipynb /path/of/projectA/
>> cp /some/path/scratch.ipynb /path/of/projectA/

假设我们要将[analysis1.ipynb](https://github.com/amit1rrr/projectA.git)推送到 GitHub。我们首先需要告诉本地 git 客户端开始跟踪文件—

>> git add analysis1.ipynb

您可以检查哪些文件正在被 git 状态跟踪，

您可以看到[analysis1.ipynb](https://github.com/amit1rrr/projectA.git) 在“待提交的变更下，因此它被我们的本地 git 客户端跟踪。现在让我们提交更改—

# -m flag provides a human friendly message describing the change
>> git commit -m "Adds customer data analysis notebook"

提交只是创建一个您可以随时恢复的检查点。现在最后把这个提交给 GitHub —

>> git push

现在你可以访问 GitHub 上的库页面查看你的提交。

在分支中发展

假设您正在进行一个跨越多天的大型项目，但是您需要定期提交正在进行的工作作为备份。方法是创建一个特征分支。

每个存储库都有一个默认的分支(通常是“主或“主”)，存储已完成工作的最新版本。团队中的每个成员都可以创建自己的功能分支来存储他们的 WIP 提交。当他们在一个特征分支中的工作准备好被共享时，他们可以创建一个 pull 请求供同行评审&随后将特征分支合并到 master 中。让我们用具体的步骤来解决这个问题。

假设我即将开始一个分析客户数据的新项目。首先，我将创建一个新的分支，

>> git checkout -b customer_data_insights

然后，我将创建/编辑一些笔记本和其他文件来进行实际的分析。当我准备好提交我的 WIP 时，我将执行通常的 git add，git commit，git push。在 git 推送时，您会看到以下错误，因为 GitHub 上还不存在这个分支。

简单地通过复制错误中显示的命令首先推动分支，

>> git push --set-upstream origin customer_data_insights

然后使用 git push 将您的提交推送到这个新创建的分支。

创建拉式请求

假设您已经在 feature branch 上工作了一段时间，它已经准备好进入黄金时间了。最有可能的是，你想先与你的同事分享它，在合并到主分支之前得到他们的反馈。这就是拉请求的作用。

您可以从 GitHub UI 创建拉请求。转到您的项目页面->拉式请求选项卡->单击“新建拉式请求”。

选择要合并到主控形状的分支。验证提交和更改的文件列表。点击“创建拉式请求”。

在下一页上，提供标题并简要描述您的更改，单击“创建拉动式请求”。

查看笔记本提取请求

GitHub pull 请求对于同行评审来说非常棒，因为它们可以让您并排看到更改并对其进行评论。但是在 Jupyter 的例子中，GitHub 显示了 JSON 的差异，这些差异真的很难理解(见下文)。

GitHub 上的笔记本差异

您可以使用 ReviewNB 来解决笔记本差异问题。它向您展示了丰富的差异&让您可以对任何笔记本单元格进行评论，以便与您的团队讨论变化。

丰富的差异和评论

一旦你的更改被队友批准，你就可以从 GitHub UI 合并它们。

或者从命令行运行 git merge + git push，

恢复到特定的笔记本版本

如果您想暂时回到提交，签出文件，然后回到您所在的位置，那么您可以简单地签出所需的提交。最后运行*“git check out master”*返回到当前状态。

如果你真的想回到一个旧的状态，并在那里做一些改变，你可以从那个提交开始一个新的分支—

>> git checkout -b old-state <some-commit-id>

你也可以在 GitHub 上浏览旧的提交，方法是进入你的项目页面->提交。打开所需的提交，点击“查看文件，查看提交时的笔记本状态。

分享你笔记本的只读链接

当你在 GitHub 上浏览存储库中的笔记本时，它会将它们呈现为 HTML 格式。所以像这种分享笔记本的只读链接非常方便。如果它是一个私有的存储库，与你共享链接的人需要有一个 GitHub 帐户，并且有权限访问你的存储库。

出于安全考虑，GitHub 不会在笔记本中运行任何 Javascript。如果您的笔记本电脑包含交互式小工具，您可以使用 nbviewer 或 ReviewNB 。

结论

如果您是 Git 的新手，可能需要一些时间来适应所有的命令。但是这是一种在软件项目中得到证实的合作方式&在数据科学工作中也被广泛使用。您可以将其与 ReviewNB 结合使用，以消除工作流程中的一些问题。

黑客快乐！

非技术性的 Google Colab

原文：https://towardsdatascience.com/how-to-use-google-colab-for-data-science-for-free-49c3353624e?source=collection_archive---------45-----------------------

当我们寻求执行分析时，有多种方式来运行分析或训练模型。最流行的方法是在您的计算机上下载 Anaconda 框架，并在 Jupyter 笔记本(以前称为 Python 笔记本)上工作。

数据科学中的笔记本是什么？

很简单，我们在大学里用笔记本做什么？我们做笔记，记下问题，解决问题，并试图整理我们的想法。数据科学或与之相当的编码通过 Jupyter 笔记本电脑实现。我们本地的这些笔记本使用我们计算机的硬件。

我本地机器上的 Jupyter 笔记本(图片由作者提供)

当我们想要训练更复杂的模型或使用更多的数据时，我们的局部可能是不够的。购买和维护硬件的成本可能很高。相反，如果您的硬件与您的数据科学不兼容，并且您有一台装有互联网浏览器的 PC，您可以免费做同样的事情！

为了训练更复杂的模型，我们希望利用并行处理来训练模型。我们可以在 Google Colab 上免费使用 GPU 来实现这一点。(记住，我们笔记本电脑上的 CPU，云上的 CPU 和 GPU)。

人们可以利用多种框架来尝试数据科学，Google Colab 是设置时间最少、速度最快的框架之一。这篇文章是为想尝试一下的非技术人员准备的。如果有任何问题，请随时通过 LinkedIn 或电子邮件联系我，我很乐意帮忙。欢迎在下面评论你想了解的更多信息(技术或其他方面)。接下来，我可以通过电子邮件快速回复。

照片由安朵斯瓦斯在 Unsplash 上拍摄

让我们深入了解一下云:Google Colab Edition。

[## 谷歌云平台基础(GCP)

云是一个复杂的空间。这并不像大多数人想象的那样简单。让我们简化一下…

towardsdatascience.com](/the-cloud-google-cloud-platform-gcp-made-easy-anish-mahapatra-3d0aed3fe7fa)

运行 Google Colab 笔记本

前往 Google Drive 并登录您的 Google 帐户。

点击新建图标(图片由作者

从这里，点击更多并选择谷歌合作实验室。

点击谷歌合作实验室，如图所示(图片由作者提供)

这将在 Google Colab 上打开一个新的 Python 笔记本。或者你可以去 Google Colab 打开一个新的笔记本。

Google Colab 中的新笔记本(图片由作者提供)

尝试进口熊猫，以确保它是有效的。

示例代码(图片由作者提供)

你现在有一个功能齐全的谷歌 Colab 笔记本。

在 Google Colab 上打开一个现有的 Jupyter 笔记本

假设您已经在本地 Jupyter 笔记本上做了一些工作——您可以直接复制代码，也可以通过文件菜单选项下的上传笔记本选项上传笔记本。

上传笔记本的选项(图片由作者提供)

如何将数据接收到 Colab 笔记本中

转到 Google Drive，创建一个新文件夹来存储您的数据。使用上传文件选项上传您的数据集和驱动器中的其他资料。

上传你需要的文件(图片由作者提供)

您现在应该有文件(。csv ),你需要在你的谷歌驱动器。接下来，我们将在 Google Colab 上安装 Google Drive。为此，我们需要允许 Google Colab 访问 Google Drive。

我会保持简单，我会给你一个方法，使用它。

# Since this notebook is from Google Colab, mounting Google Drive for authentication tokenfrom google.colab import drivedrive.mount('/content/drive')

一旦运行它，您应该会看到类似这样的内容:

(图片由作者提供)

点击该链接，您将进入另一个页面，在 Google Colab 上验证您的 Google Drive。

点击允许认证你的账户(图片由作者提供)

现在将生成一个唯一的代码，将其复制并粘贴到 Google Colab 的文本框中。

输入唯一的代码并点击回车(图片由作者提供)

您现在应该会看到类似下面的消息。

(图片由作者提供)

干得好！现在，您已经将 Google Drive 安装到了 Google Colab 上。这意味着你现在可以在 Google Colab 上访问 Google Drive 中的信息。

如何读取. csv 文件作为熊猫数据帧

这很简单。想象 Google Drive 是您的本地设备，并相应地加载数据——下面是一个示例

摄取一个. csv 文件作为熊猫数据帧(图片由作者提供)

别忘了进口熊猫套餐！

你现在可以在 Google Colab 上运行你的代码了。这就是你在云上度过大部分时间的方式。

如何使用 GPU 进行模型训练

1. 您可以通过将鼠标悬停在图标上来查看 RAM 和磁盘的使用情况，如下所示。

(图片由作者提供)

2.转到运行时选项

(图片由作者提供)

3.当您要训练模型时，请选择 GPU 作为选项

(图片由作者提供)

4.然后，运行所有细胞

(图片由作者提供)

好了，你现在是 Google Colab 的中级用户了。

[## Jupyter 笔记本崩溃了，所以我在 15 分钟内就把我的数据科学项目部署到了云中(对于…

你可以用一个很老很老的系统免费进行奇特的数据科学研究——只要动动脑筋，从这个博客中获得帮助。

medium.com](https://medium.com/datadriveninvestor/jupyter-notebook-crashed-so-i-deployed-my-data-science-project-in-the-cloud-in-15-minutes-for-56edc0ac4d0d)

奖金

黑暗模式！

进入设置->网站，选择黑暗。

(图片由作者)

在上面编码感觉更舒服

黑暗模式(图片来自作者

使用这些新发现的知识开始学习数据科学。请随意通过 mu Github 获取一些灵感。或者进入 Kaggle 开始。

[## anishmahapatra01 —概述

每天尝试新事物—专业数据科学家追求数据硕士…

github.com](https://github.com/anishmahapatra01/)

neptune.ai 我偶然发现的一个很棒的附加资源，可以帮助你进一步了解如何在 Google Colab 中处理文件。

[## 如何在 Google Colab 中处理文件:你需要知道的一切- neptune.ai

谷歌合作实验室是一个免费的 Jupyter 笔记本环境，运行在谷歌的云服务器上，让用户…

海王星. ai](https://neptune.ai/blog/google-colab-dealing-with-files)

干得好！所以，关于我的一点点。我是一家顶级数据科学公司的数据科学家，目前正在攻读数据科学硕士学位。我花很多时间学习和工作。如果你喜欢这个，给我点爱！😄我也写关于千禧一代的生活方式、咨询、聊天机器人和金融！如果您对此有任何问题或建议，请随时通过 LinkedIn联系我或关注我这里，我很想听听您的想法！

[## Anish Mahapatra —数据科学家— Mu 适马公司| LinkedIn

我正在努力理解数学、商业和技术如何帮助我们在未来做出更好的决策…

www.linkedin.com](https://www.linkedin.com/in/anishmahapatra/)

作为本系列后续步骤的一部分，我将发布更多关于我们如何在现实世界中利用云的用例。欢迎关注我并与我联系了解更多信息！

[## Anish Mahapatra —中等

阅读 Anish Mahapatra 在媒体上的文章。专业数据科学家攻读数据科学硕士学位。在…工作

medium.com](https://medium.com/@anishmahapatra)

如何在 pandas 中使用 groupby()和聚合函数进行快速数据分析

原文：https://towardsdatascience.com/how-to-use-groupby-and-aggregate-functions-in-pandas-for-quick-data-analysis-c19e7ea76367?source=collection_archive---------22-----------------------

初学者指南使用这个强大的组合在熊猫

图片来自 Pixabay

简介

当您开始学习 pandas 中的数据分析时，您应该学习的第一个函数是如何使用 groupby()函数以及如何将其结果与聚合函数相结合。这相对来说比较简单，可以让你快速地做一些强大而有效的分析。

在本文中，我们将解释:

什么是 groupby()函数，它是如何工作的？

什么是聚合函数，它们是如何工作的？

如何一起使用 groupby 和 aggregate 函数

在本文结束时，您应该能够应用这些知识来分析您选择的数据集。

让我们开始吧。我们将在这里使用虹膜数据集，所以让我们开始加载它在熊猫。

加载虹膜数据集

您可以使用下面的代码加载 iris 数据集并检查它的前几行:

from sklearn import datasets
import pandas as pddata = datasets.load_iris()
df = pd.DataFrame(data.data,columns=data.feature_names)
df['target'] = pd.Series(data.target)
df.head()

通过目测数据集，您可以看到我们拥有的唯一分类变量是目标。您可以使用 unique()函数来检查它取什么值:

df.target.unique()
array([0, 1, 2])

我们可以看到它有三个值:0、1 和 2。

使用 groupby()

既然您已经检查了目标列是分类的以及它取什么值，那么您可以尝试使用 groupby()函数。顾名思义，它应该将你的数据分组。在这种情况下，它将把它分成代表不同花卉种类的三组(我们的目标值)。

df.groupby(df.target)<pandas.core.groupby.generic.DataFrameGroupBy object at 0x1150a5150>

如您所见，groupby()函数返回一个 DataFrameGroupBy 对象。乍一看不是很有用。这就是你需要集合函数的原因。

什么是聚合函数？

聚合函数是接受一系列条目并返回一个以某种方式汇总它们的值的函数。

好的例子有:

count()，

max()，

min()，

均值()，

std()，

描述()

正如我提到的，你可以在一系列的条目中使用它们。让我们将它应用于数据集的其中一列:

df['sepal length (cm)'].mean()5.843333333333334

我们可以看到萼片长度列的平均值是 5.84。

现在让我们使用 describe()函数，它将给出更多的汇总统计数据。

df['sepal length (cm)'].describe()count    150.000000
mean       5.843333
std        0.828066
min        4.300000
25%        5.100000
50%        5.800000
75%        6.400000
max        7.900000
Name: sepal length (cm), dtype: float64

您可以看到，它给出了与前一个函数相同的平均值和一些附加信息:计数、最小值、最大值、标准值和四分位数范围。

同时使用 groupby()和聚合函数

现在是时候把你学到的东西结合在一起了。好消息是，您可以在 groupby 对象上调用聚合函数，这样您将获得每个组的结果。

让我们用 iris 数据集再次证明这一点:

df.groupby(df.target).mean()

如你所见，我们的索引列没有给出组名(在我们的例子中是 0、1 和 2)以及每列和每组的平均值。

你可以看到，第 0 组的平均花瓣长度(1.46 厘米)比其他两组的平均花瓣长度(1 (4.26 厘米)和 2(5.52 厘米)小得多。看起来这可能是被分析的花卉之间的一个重要差异。

您还可以对 group by 对象使用 describe()来获取我们组的所有描述性统计信息:

df.groupby(df.target).describe()

如您所见，该表为您提供了所有组和所有列的描述性统计数据。如果很难读懂，你也可以一次只看一栏:

df.groupby(df.target)['sepal length (cm)'].describe()

正如您在这些例子中看到的，将 groupby 和 aggregate 函数一起使用非常简单明了。

规则是首先使用 groupby 函数创建 groupby 对象，然后调用聚合函数计算每个组的信息。

总结

在本文中，您了解了 groupby 函数，以及如何在 pandas 中将它与聚合函数结合使用。

我希望你能够应用你所学的知识，对你选择的数据集进行快速分析。

原载于 aboutdatablog.com: 如何在 pandas 中使用 groupby()和 aggregate 函数进行快速数据分析，2020 年 5 月 6 日。

PS:我正在 Medium 和aboutdatablog.com上写文章，深入浅出地解释基本的数据科学概念。你可以订阅我的 邮件列表 在我每次写新文章的时候得到通知。如果你还不是中等会员，你可以在这里加入。

下面还有一些你可能喜欢的帖子

* [## 对熊猫中的数据框进行排序

如何快速有效地排序数据帧

towardsdatascience.com](/sorting-data-frames-in-pandas-a5a3af6f346a) [## 当你开始与图书馆合作时，7 个实用的熊猫提示

解释一些乍一看不那么明显的东西…

towardsdatascience.com](/7-practical-pandas-tips-when-you-start-working-with-the-library-e4a9205eb443) [## Jupyter 笔记本自动完成

数据科学家的最佳生产力工具，如果您还没有使用它，您应该使用它…

towardsdatascience.com](/jupyter-notebook-autocompletion-f291008c66c)*

如何将本地存储与 AWS 前哨一起用于人工智能工作负载

原文：https://towardsdatascience.com/how-to-use-high-performance-local-storage-for-ai-workloads-on-aws-outposts-3203b2853cc4?source=collection_archive---------42-----------------------

一起更好:内部云计算+共享数据

米歇尔在 Unsplash 上的照片

从无人驾驶汽车和金融交易到交通系统，许多用例需要近实时和本地处理数据的能力。事情正在发生，我们需要尽快做出决定。没有时间将所有数据传输回公共云。

因此，许多组织选择将其公共云项目扩展到私有的本地位置，构建混合云解决方案。

AWS 前哨是采用云优先计划的组织满足本地数据处理或低延迟要求的方式之一。借助前哨机架，您可以在数据中心部署 AWS 计算硬件。

这篇文章介绍了混合云人工智能工作流，并描述了如何将本地存储与 AWS 前哨配对。在本文中，我使用 Pure Storage FlashBlade 作为示例存储服务器，因为它支持来自同一设备的文件和对象存储。

人工智能部署的混合云模型

随着数据科学团队将其模型投入生产，他们必须支持更大规模的数据接收和数据处理，作为推理的一部分。

通常，将大型数据集转移到公共云中的性能损失(或成本)令人望而却步。或者，从边缘到公共云的连接可能不可靠。由于这些限制，拥有大量数据摄取的团队正在将人工智能推理从公共云迁移到边缘数据中心。

注意:在这种情况下，我们使用“边缘”来表示分布式计算模型，其中服务交付在多个边缘站点执行，例如主机托管设施。

团队可以在公共云中集中模型开发，然后将最终模型部署到边缘数据中心进行推理。团队可以在边缘执行初始分析，以识别异常或有趣的数据点，并将其发送回公共云进行进一步分析或重新培训。

混合云部署示例。(图片由作者提供)

例如，一家自动驾驶汽车公司可能有一个车队，每天每辆车都会产生 2TB 的数据日志。然而，他们的计算机视觉训练数据集可能没有足够的特定路标变体样本(汽车可能会遇到的其他东西)。因此，该公司的数据科学家可能会在边缘位置执行推理，以提取具有这些高价值异常的数据点，然后将这些数据点输入到模型再训练中。

完整的数据集被摄取到本地服务器中，AWS 前哨——甚至可能是一个 GPU 前哨配置——可以用作推理的边缘计算。

从前哨 EC2 实例访问本地服务器上的数据

亚马逊的高级解决方案架构师 Josh Coen 写了一篇很棒的文章，强调了前哨站和相邻存储设备之间联网路径的简单性。

建立连接后，很容易开始使用这些外部数据集。在这一节中，我将演示前哨站中的 EC2 实例如何与本地文件和对象数据进行交互。

先决条件

• 前哨站配置:在前哨站中启动一个 EC2 实例(通过 AWS 前哨站控制台)。验证该实例可以 ping 通本地网络上的设备。
• FlashBlade 配置:为文件测试创建一个子网、一个数据 VIP 和一个文件系统。为对象测试创建一个对象存储用户和一个存储桶。

连接到文件存储器

使用 data vip 将文件系统挂载到实例内部的一个目录中。示例:

mkdir -p /mnt/datasets
mount -t nfs 10.21.239.11:/datasets /mnt/datasets

就是这样！

通过ls确认 EC2 实例中挂载的文件系统的内容是否如预期的那样出现。

注意:为了通过每个挂载点的多个 TCP 连接提高性能，请使用 nconnect 挂载选项。了解更多: 使用 nconnect 轻松提升 NFS 性能 。

连接到对象存储器

与区域内实例的流程一样，具有 S3 访问权限的 IAM 角色必须与实例关联，用户才能访问 S3。(更多信息，请参考 AWS 命令行界面用户指南。)

使用aws configure命令为 FlashBlade 对象存储用户添加访问密钥 ID 和秘密访问密钥。

就是这样！

使用aws s3 ls命令验证 EC2 实例可以访问 FlashBlade 上的存储桶。因为系统使用自定义端点而不是默认的 AWS S3，所以使用之前在 FlashBlade 上创建的数据 VIP 指定一个--endpoint-url。

aws --endpoint-url http://10.21.239.11 s3 ls

此时，Outpost EC2 实例已准备好使用存储在 FlashBlade 上的文件和对象数据。

访问前哨站内 EMR 集群的本地数据集

通常，仅从边缘的原始数据直接进行推断是不够的。组织经常选择在运行推理之前对数据进行预处理或操作。你可以使用像 AWS EMR 这样的服务在哨站内部执行预处理步骤。

内部推理管道示例。支持文件和对象协议工作负载。(图片由作者提供)

为了简化基础架构，组织可以在整个边缘分析管道中使用相同的共享存储。

部署

一旦运行了集群实例，集群工作负载就可以很容易地访问本地存储服务器上的数据。

关于启动集群的说明，请参见我的帖子:在 AWS 前哨站上创建 Amazon EMR 集群

要从该群集访问 FlashBlade S3 上的对象，请提交包含 FlashBlade 端点和凭据的作业。示例:

spark-submit --conf spark.hadoop.fs.s3a.endpoint=http://10.21.239.11 \
             --conf "spark.hadoop.fs.s3a.access.key=####" \
             --conf "spark.hadoop.fs.s3a.secret.key=####" \
             --master yarn \
             --deploy-mode cluster \
             wordcount.py \
             s3a://emily-outpost-bucket/sample.txt

或者，在 spark-defaults.conf 文件中记录 FlashBlade 规格，以便在默认情况下自动使用它们。

vi /etc/spark/conf.dist/spark-defaults.conf

将以下几行添加到文件的底部:

spark.hadoop.fs.s3a.endpoint 10.21.239.11  # YOUR DATA VIP
spark.hadoop.fs.s3a.access.key=####
spark.hadoop.fs.s3a.secret.key=##### Suggested tuning for FlashBlade performance 
performance.spark.hadoop.fs.s3a.fast.upload true
spark.hadoop.fs.s3a.connection.ssl.enabled false
spark.hadoop.mapreduce.fileoutputcommitter.algorithm.version 2
spark.hadoop.mapreduce.input.fileinputformat.split.minsize 541073408

现在，您可以提交作业，而无需在线指定 FlashBlade 规格:

spark-submit --master yarn \
             --deploy-mode cluster \
             wordcount.py \
             s3a://emily-outpost-bucket/sample.txt

外卖食品

混合云部署变得越来越普遍，尤其是为了支持边缘分析。使用 FlashBlade 作为示例存储服务器，我们演示了通过 AWS outbound EC2 实例使用本地文件和对象存储的快速步骤。这使得数据科学家能够部署边缘推理管道，这些管道可以使用大型数据集并在本地执行分析。

使用带有前哨的高性能本地存储有助于消除向公共云发送分析查询的延迟，并有助于防止将所有边缘数据推送到公共云所带来的传输时间(甚至可能有助于遵守数据治理要求)。通过将易于管理的计算和存储基础架构配对，混合云部署变得更加容易。

有关导航前哨的信息，另请参见:

[## 在 AWS 前哨上启动 EC2 实例

视觉向导

medium.com](https://medium.com/@emwatz/launch-ec2-instances-on-aws-outposts-fc4a0e12bd27) [## 在 AWS 前哨站上创建 Amazon EMR 集群

视觉向导

medium.com](https://medium.com/@emwatz/create-amazon-emr-clusters-on-aws-outposts-bec702ec3bae)

如何在 Google Colab 中使用 Kaggle 数据集

原文：https://towardsdatascience.com/how-to-use-kaggle-datasets-in-google-colab-bca5e452a676?source=collection_archive---------27-----------------------

使用 kaggle API 将数据集直接下载到 colab。

照片由尼克·费因斯在 Unsplash 拍摄

Kaggle 是数据科学领域非常受欢迎的平台。它的名气来自比赛，但也有许多数据集，我们可以在实践中工作。在这篇文章中，我们将看到如何将数据集从 Kaggle 直接导入到 google colab 笔记本中。

我们首先转到 Kaggle 上的帐户页面来生成一个 API 令牌。在帐户页面上，我们向下滚动到 API 部分。

如果有以前生成的 API 令牌，我们应该通过单击“使 API 令牌过期”来使其过期。如果没有，我们可以单击“创建新的 API 令牌”直接生成令牌。点击后，会下载一个名为 kaggle.json 的文件。

然后，我们在 colab 中打开一个新的笔记本，并运行以下命令。

!pip install -q kaggle

然后我们需要上传 kaggle.json 文件。

from google.colab import filesfiles.upload()

选择从 kaggle 下载的“kaggle.json”。我们需要将这个文件保存到一个名为 kaggle 的目录中。运行以下命令来完成此任务:

!mkdir ~/.kaggle!cp kaggle.json ~/.kaggle/

我们现在使用以下命令更改文件的权限:

!chmod 600 ~/.kaggle/kaggle.json

我们现在可以在 kaggle 上看到数据集:

!kaggle datasets list

要下载特定的一个:

!kaggle datasets download -d "name_of_the_dataset"

例如:

!kaggle datasets download -d ruchi798/tv-shows-on-netflix-prime-video-hulu-and-disney

我们现在在 colab 中有可用的数据:

让我们把它读入熊猫的数据帧:

import numpy as np
import pandas as pddf = pd.read_csv("/content/tv-shows-on-netflix-prime-video-hulu-and-disney.zip")df.head()

我们不必每次都经历所有这些步骤。一旦完成这些步骤，下次我们只需将 kaggle.json 上传到 colab，然后下载数据集。

!kaggle datasets download -d kianwee/agricultural-raw-material-prices-19902020

我们总是可以用!kaggle datasets list来检查可用的数据集

我认为 kaggle 和 google colab 是数据科学领域的两个主要参与者。两者都对社区做出了贡献，从而推动了数据科学的发展。在两者之间建立联系是件好事。

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

如何使用 Lambda 获得高效的 Python 代码

原文：https://towardsdatascience.com/how-to-use-lambda-for-efficient-python-code-ff950dc8d259?source=collection_archive---------13-----------------------

使用 lambda 对元组进行排序并为您的数据科学创意创建复杂函数的技巧

检索自 Gideon Pyzer

动机

这张图让你想起了什么？波的振幅放大？这个怎么做？你仔细看看图表，发现了一些有趣的事情。看起来像是随着 x 的增加，y 轴上的值先下降到-1，然后上升到 1，再下降到-2，然后上升到 2，依此类推。这给了你一个想法，图表可以用这样的列表来制作

[0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5, -6, 6, -7, 7, -8, 8, -9, 9]

如果您将上述列表中的matplotlib用作参数，您应该得到与上图接近的图形:

这看起来很容易。一旦您理解了如何使用列表创建图形，您就可以轻松地重新创建波形图。但是如果你想创建一个更酷的图表，需要一个更大的列表，像这样呢？

你肯定不想手动写上面的单子，单子上有 200 个数字。因此，您必须弄清楚如何使用 Python 来创建编号范围为(n，m)的列表

但是从 0 开始，按-1，1，-2，2，…n 进行。

如果我们认识到按元素|0|、|-1|、|1|、|-2|、|2|的绝对值排序的列表，…，n .所以有排序和绝对值的东西会起作用？答对了。我将向你展示如何用lambda在一行代码中轻松创建这种功能。

顺便问一下，Lambda 是什么？

嘿，很高兴你这么问。Python 中的lambda关键字提供了声明小型匿名函数的快捷方式。它的行为就像常规函数一样。它们可以作为函数对象的替代。让我们举一个如何用 lambdas 代替 function 的小例子:

def mult(x,y):
  return x*ymult(2,6)

结果:12

我们可以用lambda让上面的代码更短

mult = lambda x, y: x*y
mult(2,6)

但是我们需要定义乘法的名称吗？毕竟，我们只是想创建一个可以将两个数相乘的函数，对吗？我们可以将上面的函数简化为更简单的代码:

(lambda x, y: x*y)(2, 6)

那看起来更短。但是为什么你要费心去学习lambda，只是为了节省几行代码呢？因为lambda可以帮助你轻松创造更复杂的东西。比如根据字母表对元组列表进行排序:

tuples = [(1, 'd'), (2, 'b'), (4, 'a'), (3, 'c')]sorted(tuples, key=lambda x: x[1])

结果:

[(4, 'a'), (2, 'b'), (3, 'c'), (1, 'd')]

这给了你一个如何使用lambda创建上面的图表的提示。准备好了吗？这是:

import matplotlib.pyplot as pltnums = plt.plot(sorted(range(-100, 101), key=lambda x: x * x))plt.plot(nums)

给我们图表:

何时使用lambda的其他启示:

想创建一个函数来计算一个数的另一个数的幂吗？我们可以使用嵌套函数和lambda的组合:

def power(n):
  return lambda x: x**npower_3 = power(3)list(map(power_3,[2,3,4,5]))

结果:

[8, 27, 64, 125]

或者使用lambda来操作pandas数据帧

import pandas as pd
df = pd.DataFrame([[1,2,3],[4,5,6]], columns=['a','b','c'])

#Create the 4th column that is the sum of the other 3 columnsdf['d'] = df.apply(lambda row: row['a']+row['b']+row['c'],axis=1)

结论

恭喜你！现在你知道如何使用lambda作为函数的快捷方式。当你想在短时间内创建一个无名函数时，我鼓励你使用lambda。你也可以像上面一样把它作为一个高阶函数的参数，或者和像filter()、map()、apply()这样的函数一起使用。

我希望这篇教程能给你一些动机和理由来用lambda切换你的一些 Python 代码。随着您越来越多地为您的数据科学项目引入更复杂的代码，代码中的一个小变化可以在时间和效率上给您带来巨大的回报。

在这个 Github repo 中，您可以随意派生和使用本文的代码。

我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上与我联系。

如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:

[## 高效 Python 代码的计时

如何比较列表、集合和其他方法的性能

towardsdatascience.com](/timing-the-performance-to-choose-the-right-python-object-for-your-data-science-project-670db6f11b8e) [## 使用 Python 最大化您的生产力

你创建了一个待办事项清单来提高效率，但最终却把时间浪费在了不重要的任务上。如果你能创造…

towardsdatascience.com](/maximize-your-productivity-with-python-6110004b45f7) [## cy thon——Python 函数的加速工具

当调整你的算法得到小的改进时，你可能想用 Cython 获得额外的速度，一个…

towardsdatascience.com](/cython-a-speed-up-tool-for-your-python-function-9bab64364bfd) [## 如何从头开始构建矩阵模块

如果您一直在为矩阵运算导入 Numpy，但不知道该模块是如何构建的，本文将展示…

towardsdatascience.com](/how-to-build-a-matrix-module-from-scratch-a4f35ec28b56)

如何将机器学习用于药物发现

原文：https://towardsdatascience.com/how-to-use-machine-learning-for-drug-discovery-1ccb5fdf81ad?source=collection_archive---------15-----------------------

由 wowomnom 在 Envato 元素上定制一个图形(带许可证)

数据科学

一步一步的实用生物信息学教程

1.介绍

我们可能已经看到机器学习以这样或那样的形式应用。例如，机器学习已经与计算机视觉一起用于自动驾驶汽车和自助结账便利店，用于零售市场购物篮分析(即找到通常一起购买的产品)，用于推荐系统的娱乐，等等。

这代表了 生物信息学教程 系列的第一篇文章(感谢 Jaemin Lee 关于将我的文章发展成系列的建议！).在本文中，我将探索机器学习如何用于药物发现，特别是通过一步一步地向您展示如何在 Python 中建立一个简单的回归模型来预测分子的溶解度(即对数值)。需要注意的是，药物的溶解度是药物发现、设计和开发中一个重要的理化性质。在此，我们将转载一篇名为“ESOL:从分子结构直接估算水溶性” 的研究文章，作者是 John S. Delaney。

这款笔记本的灵感来自 Pat Walters 在 【预测水溶性——比看起来更难】 上的精彩博文，他在博文中重现了线性回归模型，其性能与 Delaney 的相似。这个例子在 Walters 合著的书、生命科学的深度学习:将深度学习应用于基因组学、显微镜学、药物发现等】、中也有简要描述。

YouTube 视频 “使用 Python 进行计算药物发现的数据科学” 中提供了展示本文所述实施的教程视频:

目录

1.introduction
2。材料
2.1Computing environmen t
2.2 Installing prerequisite Python librar y
2.3。 Datase t
3方法
3.1 Datase t
3.1.1 读取数据集
3.1.2。Examining the SMILES data
3.2。 Working with SMILES strin g
3.2.1。convertit a molecule from the SMILES string to an rdkit object
3.2.2。Working with the rdkit object
3.2.3。Convert list of molecules to rdkit object
3.3 转换分子列表到 rdkit 对象。计算分子描述符s
3.3.1。Calculating LogP, MW and RB descriptors
3.3.2。计算芳香比例(T33) 3.3.2.1。芳香原子数(T34)3.3.2.2。重原子数(T35)3.3.2.3 计算芳香比例(AP)描述符
3.4。数据集准备
3.4.1Creating the X Matrix
3.4.2。首页 〉外文书 〉文学 〉西洋文学 〉Creating the Y Matrix (T41) 3.5数据分割
3.6 线性回归模型(T46)(T47) 结果
4.1(T51)线性回归模型(T52)(T53) 4.1.1 预测 X_train 数据的 LogS 值
4.1.2。预测 X_test 数据的 LogS 值
4.2。(T56) 比较线性回归方程(T57) Deriving the Linear Regression Equatio n
4.3.1 基于列车集
4.3.2。基于完整数据集(用于比较)(T63) 4.4。 Scatter plot of experimental vs. predicted Log S
4.4.1。Vertical Plot
4.4.2。横向 Plot

2.材料

从学术背景来看，检索关于如何进行实验的信息的研究论文的最重要部分之一必须是材料和方法部分，因为它将基本上告诉我们需要什么材料以及做了什么和如何做。因此，在这一部分，我将讨论您需要开始做些什么。

2.1.计算环境

首先，决定你是想在本地计算机上工作还是在云上工作。如果你决定在本地计算机上工作，那么任何可以安装 Python 和 Jupyter notebook 的计算机(我推荐安装 conda 或 Anaconda )就足够了。如果你决定在云上工作，那就去谷歌实验室吧。

2.2.安装必备 Python 库

rdkit 库是一个 Python 库，它允许我们处理化学结构和计算它们的分子属性(即用于量化每个分子的分子特征，我们可以随后在机器学习模型的开发中使用)。

我们现在将安装 rdkit 库，启动一个新笔记本，并确保创建一个包含以下文本的文本单元格:

**# Install rdkit**

在这个文本单元格的正下方，您想要创建一个新的代码单元格，并用以下代码块填充它:

**! wget https://repo.anaconda.com/miniconda/Miniconda3-py37_4.8.2-Linux-x86_64.sh 
! chmod +x Miniconda3-py37_4.8.2-Linux-x86_64.sh 
! bash ./Miniconda3-py37_4.8.2-Linux-x86_64.sh -b -f -p /usr/local 
! conda install -c rdkit rdkit -y 
import sys 
sys.path.append('/usr/local/lib/python3.7/site-packages/')**

上面的 2 个单元格应该看起来像下面的截图:

以上 2 个单元格(文本和代码单元格)的渲染。

2.3.数据集

我们现在将下载 Delaney 溶解度数据集，该数据集作为论文 ESOL:直接从分子结构中的补充文件提供。

下载数据集
下载到 Jupyter 笔记本如下:

**! wget https://raw.githubusercontent.com/dataprofessor/data/master/delaney.csv**

3.方法

3.1.资料组

3.1.1。读入数据集
读入我们从上述单元格下载的 CSV 数据。将数据分配到sol数据框中。

**import pandas as pd
sol = pd.read_csv('delaney.csv')**

显示sol数据帧给我们提供了以下信息:

sol 数据框的内容。

3.1.2。检验 SMILES 数据
化学结构由一串称为 SMILES 符号的文本编码，这是简化分子输入行输入系统的首字母缩写。让我们看看sol数据帧中微笑列的内容。

**sol.SMILES**

运行上面的单元将为我们提供:

溶胶含量。SMILES(sol 数据框架中的 SMILES 列)。

每条线代表一种独特的分子。要选择第一个分子(第一行)，键入sol.SMILES[0]，我们将看到的输出是ClCC(Cl)(Cl)Cl。

3.2.使用微笑字符串

3 . 2 . 1。将一个分子从 SMILES 字符串转换成一个 rdkit 对象**
让我们从导入必要的库函数开始:

**from rdkit import Chem**

现在，应用MolFromSmiles()函数将 SMILES 字符串转换为 rdkit 分子对象:

**Chem.MolFromSmiles(sol.SMILES[0])**

这将产生以下输出:

<rdkit.Chem.rdchem.Mol at 0x7f66f2e3e800>

3.2.2。使用 rdkit 对象
让我们对查询 SMILES 字符串执行一个简单的原子计数，我们首先将它转换成一个 rdkit 对象，然后应用GetNumAtoms()函数。

**m = Chem.MolFromSmiles('ClCC(Cl)(Cl)Cl')
m.GetNumAtoms()**

这会产生以下输出:

6

3 . 2 . 3。将分子列表转换为 rdkit 对象** 但是在我们进行任何描述符计算之前，我们必须先将 SMILES 字符串转换为 rdkit 对象，如 3.2 节所述。这里我们将做和上面描述的一样的事情，但是我们将利用 for 循环来遍历微笑字符串列表。

**from rdkit import Chem****mol_list= []
for element in sol.SMILES:
  mol = Chem.MolFromSmiles(element)
  mol_list.append(mol)**

接下来，我们将检查新的 rdkit 对象是否正在填充 mol_list 变量。

**len(mol_list)**

上面的行返回:

1144

这相当于 1144 个分子。现在，我们将看看变量的内容。

**mol_list[:5]**

这会产生以下输出:

[<rdkit.Chem.rdchem.Mol at 0x7f66edb6d670>,
 <rdkit.Chem.rdchem.Mol at 0x7f66edb6d620>,
 <rdkit.Chem.rdchem.Mol at 0x7f66edb6d530>,
 <rdkit.Chem.rdchem.Mol at 0x7f66edb6d6c0>,
 <rdkit.Chem.rdchem.Mol at 0x7f66edb6d710>]

3.3.计算分子描述符

我们现在将通过一组用于建模的分子描述符来表示数据集中的每个分子。

为了预测对数(水溶性对数)，Delaney 的研究使用了 4 个分子描述符:

1. cLogP (辛醇-水分配系数)
2. MW (分子量)
3. RB(可旋转债券数量)
4. AP (芳香比例=芳香原子数/重原子数)

不幸的是，rdkit 很容易计算前 3 个。至于 AP 描述符，我们将通过手动计算 rdkit 可以计算的芳香原子数与重原子数的比率来计算。

3 . 3 . 1。计算 LogP、MW 和 RB 描述符** 我们现在将创建一个名为generate()的自定义函数，用于计算 3 个描述符 LogP、MW 和 RB。

**import numpy as np
from rdkit.Chem import Descriptors*****# Inspired by: https://codeocean.com/explore/capsules?query=tag:data-curation*

def generate(smiles, verbose=False):

    moldata= []
    for elem in smiles:
        mol=Chem.MolFromSmiles(elem) 
        moldata.append(mol)

    baseData= np.arange(1,1)
    i=0  
    for mol in moldata:        

        desc_MolLogP = Descriptors.MolLogP(mol)
        desc_MolWt = Descriptors.MolWt(mol)
        desc_NumRotatableBonds = Descriptors.NumRotatableBonds(mol)

        row = np.array([desc_MolLogP,
                        desc_MolWt,
                        desc_NumRotatableBonds])   

        if(i==0):
            baseData=row
        else:
            baseData=np.vstack([baseData, row])
        i=i+1      

    columnNames=["MolLogP","MolWt","NumRotatableBonds"]   
    descriptors = pd.DataFrame(data=baseData,columns=columnNames)

    return descriptors**

让我们应用generate()函数对sol.SMILES(来自df数据帧的微笑列)执行实际的描述符计算，并将描述符输出分配给df变量。

df = generate(sol.SMILES)
df

df数据帧的输出如下所示。

测向数据帧的内容。

3 . 3 . 2。计算芳香比例** 如上所述，计算芳香比例的方程式是用芳香原子数除以重原子数得到的。

3.3.2.1。芳香原子数
这里我们将创建一个自定义函数来计算芳香原子数。有了这个描述符，我们可以用它来计算 AP 描述符。

计算单个分子中芳香原子数的例子。

**SMILES = 'COc1cccc2cc(C(=O)NCCCCN3CCN(c4cccc5nccnc54)CC3)oc21'****m = Chem.MolFromSmiles(SMILES)****aromatic_atoms = [m.GetAtomWithIdx(i).GetIsAromatic() for i in range(m.GetNumAtoms())]****aromatic_atoms**

这给出了以下输出。

[False,  False,  True,  True,  True,  True,  True,  True,  True,  False,  False,  False,  False,  False,  False,  False,  False,  False,  False,  False,  True,  True,  True,  True,  True,  True,  True,  True,  True,  True,  False,  False,  True,  True]

现在让我们创建一个名为AromaticAtoms()的自定义函数。

**def AromaticAtoms(m):
  aromatic_atoms = [m.GetAtomWithIdx(i).GetIsAromatic() for i in range(m.GetNumAtoms())]
  aa_count = []
  for i in aromatic_atoms:
    if i==True:
      aa_count.append(1)
  sum_aa_count = sum(aa_count)
  return sum_aa_count**

现在，应用AromaticAtoms()函数来计算查询 SMILES 字符串的芳香原子数。

**AromaticAtoms(m)**

输出是:

19

这意味着有 19 个芳香原子(即有 19 个原子是芳香环的一部分)。

现在让我们扩大规模，并将其应用于整个微笑列表。

**desc_AromaticAtoms = [AromaticAtoms(element) for element in mol_list]****desc_AromaticAtoms**

现在，打印出结果。

[0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 6, 0, 0, 0, 0, 6, 6, 0, 6, 6, 6, 6, 6, 0, 6, 6, 0, 0, 6, 10, 6, 6, 0, 6, 6, 6, 6, 10, 6, 0, 10, 0, 14, 0, 0, 14, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, ...]

恭喜你！我们现在已经计算了整个数据集的芳香原子数。

3.3.2.2。重原子数
这里，我们将使用 rdkit 库中的一个现有函数来计算重原子数。

计算单个分子重原子数的例子。

**SMILES = 'COc1cccc2cc(C(=O)NCCCCN3CCN(c4cccc5nccnc54)CC3)oc21'
m = Chem.MolFromSmiles(SMILES)
Descriptors.HeavyAtomCount(m)**

这将产生以下输出。

34

让我们扩大到整个微笑列表。

**desc_HeavyAtomCount = [Descriptors.HeavyAtomCount(element) for element in mol_list]
desc_HeavyAtomCount**

现在，打印出结果。

[6, 5, 6, 5, 8, 4, 4, 8, 10, 10, 10, 9, 9, 10, 10, 10, 9, 9, 9, 8, 8, 4, 8, 4, 5, 8, 8, 10, 12, 4, 9, 9, 9, 15, 8, 4, 8, 8, 5, 8, 8, 12, 12, 8, 6, 8, 8, 10, 8, 12, 12, 5, 12, 6, 14, 11, 22, 15, 5, ...]

3.3.2.3。计算芳香比例(AP)描述符
现在让我们把芳香原子数和重原子数结合在一起。

计算单个分子的例子。

**SMILES = 'COc1cccc2cc(C(=O)NCCCCN3CCN(c4cccc5nccnc54)CC3)oc21'
m = Chem.MolFromSmiles(SMILES)
AromaticAtoms(m)/Descriptors.HeavyAtomCount(m)**

输出是:

0.5588235294117647

让我们放大并计算整个微笑列表。

**desc_AromaticProportion = [AromaticAtoms(element)/Descriptors.HeavyAtomCount(element) for element in mol_list]
desc_AromaticProportion**

这给出了输出:

[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.6, 0.6, 0.6, 0.6666666666666666, 0.6666666666666666, 0.6, 0.6, 0.6, 0.6666666666666666, 0.6666666666666666, 0.6666666666666666, 0.75, 0.75, 0.0, 0.75, 0.0, 0.0, 0.0, 0.0, 0.6, 0.5, 0.0, 0.6666666666666666, 0.6666666666666666, 0.6666666666666666, 0.4, 0.75, 0.0, 0.75, 0.75, 0.0, 0.0, 0.75, 0.8333333333333334, 0.5, 0.75, 0.0, 0.75, 0.75, 0.6, 0.75, 0.8333333333333334, 0.5, ...]

现在让我们把这个新计算的芳烃比例描述符放到一个数据帧中。

芳烃比例描述符数据帧的内容。

3.4.数据集准备

3.4.1。创建 X 矩阵 让我们将 2 个数据帧中的所有计算描述符合并到 1 个数据帧中。在此之前，让我们先来看看我们将要组合的两个数据帧(df和df_desc_AromaticProportion)以及组合后的数据帧将会是什么样子，如下图所示。

组合两个包含描述符的数据帧以形成 X 矩阵的图示。

让我们实际上结合 2 个数据帧来产生 X 矩阵。

**X = pd.concat([df,df_desc_AromaticProportion], axis=1)
X**

通过组合两个数据帧创建的 X 矩阵数据帧的内容。

3 . 4 . 2。创建 Y 矩阵** Y 矩阵将从我们在本教程中要预测的 1 列中创建，这是对数值。在sol数据框中，日志值包含在measured log(solubility:mol/L)栏中。

让我们再看一下sol数据框。

sol.head()

突出显示日志列的 sol 数据框架的内容。

对应于测得溶解度值(对数)的第二列(指数为 1)将用作 Y 矩阵。因此，我们将选择第二列(在上图中以蓝色突出显示)。

Y = sol.iloc[:,1]
Y

Y 矩阵的内容(对数列)。

3.5.数据分割

我们现在将继续使用 80/20 的拆分比率来执行数据拆分(即我们通过将test_size参数指定为 0.2 来完成此操作)，由此初始数据集的 80%将用作训练集，而数据集的剩余 20%将用作测试集。

**from sklearn.model_selection import train_test_split****X_train, X_test, Y_train, Y_test = train_test_split(X, Y,
                                                    test_size=0.2)**

3.6.线性回归模型

由于 Delaney 的最初研究和 Walters 的调查使用线性回归进行建模，因此为了便于比较，我们也将使用线性回归。

**from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score****model = linear_model.LinearRegression()
model.fit(X_train, Y_train)**

在运行上面的代码块时，我们将看到下面的输出，它基本上打印出了用于模型构建的参数。

LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)

4.结果

4.1.线性回归模型

4.1.1。预测 X_train 数据的对数值 来自第 3.6 节的训练模型将应用于此，以预测训练集中所有样本(分子)的对数值(X_train)。

**Y_pred_train = model.predict(X_train)****print('Coefficients:', model.coef_)
print('Intercept:', model.intercept_)
print('Mean squared error (MSE): %.2f'
      % mean_squared_error(Y_train, Y_pred_train))
print('Coefficient of determination (R^2): %.2f'
      % r2_score(Y_train, Y_pred_train))**

这将生成以下预测结果。

Coefficients: [-0.7282008  -0.00691046  0.01625003 -0.35627645]
Intercept: 0.26284383753800666
Mean squared error (MSE): 0.99
Coefficient of determination (R^2): 0.77

让我们逐行分析上面的输出:

• 在第一行，Coefficients列出了每个独立变量的回归系数值(即由 LogP、MW、RB 和 AP 组成的 4 个分子描述符)
• 在第二行中，Intercept实际上是 X = 0 时回归线经过的 y 截距值。
• 在第三行中，Mean squared error (MSE)用作误差测量值(即越低越好)。
• 在第四行中，Coefficient of determination (R²)是皮尔逊相关系数值的平方值，并用作线性回归模型的拟合优度的度量(即越高越好)

4 . 1 . 2。预测 X_test 数据的对数值** 接下来，来自 3.6 节的训练模型也将应用于此，以预测训练集中所有样本(分子)的对数值(X_train)。

我们将打印出如下预测性能:

**Y_pred_test = model.predict(X_test)****print('Coefficients:', model.coef_)
print('Intercept:', model.intercept_)
print('Mean squared error (MSE): %.2f'
      % mean_squared_error(Y_test, Y_pred_test))
print('Coefficient of determination (R^2): %.2f'
      % r2_score(Y_test, Y_pred_test))**

上述代码块产生以下预测结果。

Coefficients: [-0.7282008  -0.00691046  0.01625003 -0.35627645]
Intercept: 0.26284383753800666
Mean squared error (MSE): 1.11
Coefficient of determination (R^2): 0.75

4.2.比较线性回归方程

德莱尼的工作提供了以下线性回归方程:

LogS = 0.16 - 0.63 cLogP - 0.0062 MW + 0.066 RB - 0.74 AP

由 Pat Walters制作的复制品提供了以下内容:

LogS = 0.26 - 0.74 LogP - 0.0066 MW + 0.0034 RB - 0.42 AP

本教程的复制给出了以下等式:

• 基于列车组(如下文第 4.3.1 节所示)

LogS =  0.26 - 0.73 LogP - 0.0069 MW 0.0163 RB - 0.36 AP

• 基于完整的数据集(如下文第 4.3.2 节所示)

LogS =  0.26 - 0.74 LogP - 0.0066 MW + 0.0032 RB - 0.42 AP

4.3.推导线性回归方程

4 . 3 . 1。基于以下代码块中的训练集**
，我们将使用第 3.6 节中构建的线性回归模型，其中训练集用于模型构建。为了便于参考，我将代码放在这里:

**from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score****model = linear_model.LinearRegression()
model.fit(X_train, Y_train)**

因此，我们只需直接从包含在model变量中的先前构建的模型中打印出方程(即，通过调用模型变量的各个列)。

**yintercept = '%.2f' % model.intercept_
LogP = '%.2f LogP' % model.coef_[0]
MW = '%.4f MW' % model.coef_[1]
RB = '%.4f RB' % model.coef_[2]
AP = '%.2f AP' % model.coef_[3]****print('LogS = ' + 
      ' ' + 
      yintercept + 
      ' ' + 
      LogP + 
      ' ' + 
      MW + 
      ' ' + 
      RB + 
      ' ' + 
      AP)**

运行上述代码块会得到以下等式输出:

LogS =  0.26 -0.73 LogP -0.0069 MW 0.0163 RB -0.36 AP

4 . 3 . 2。基于完整的数据集(用于比较)**
这里我们将使用整个数据集来训练一个线性回归模型。fit()功能允许使用 X 和 Y 数据矩阵作为输入参数来训练full ( 即线性回归模型)中定义的模型。

**full = linear_model.LinearRegression()
full.fit(X, Y)**

这会产生以下输出:

LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)

我们现在将打印出预测性能。

**full_pred = model.predict(X)****print('Coefficients:', full.coef_)
print('Intercept:', full.intercept_)
print('Mean squared error (MSE): %.2f'
      % mean_squared_error(Y, full_pred))
print('Coefficient of determination (R^2): %.2f'
      % r2_score(Y, full_pred))**

这将生成以下输出:

Coefficients: [-0.74173609 -0.00659927  0.00320051 -0.42316387]
Intercept: 0.2565006830997185
Mean squared error (MSE): 1.01
Coefficient of determination (R^2): 0.77

最后，我们将打印出线性回归方程。

**full_yintercept = '%.2f' % full.intercept_
full_LogP = '%.2f LogP' % full.coef_[0]
full_MW = '%.4f MW' % full.coef_[1]
full_RB = '+ %.4f RB' % full.coef_[2]
full_AP = '%.2f AP' % full.coef_[3]****print('LogS = ' + 
      ' ' + 
      full_yintercept + 
      ' ' + 
      full_LogP + 
      ' ' + 
      full_MW + 
      ' ' + 
      full_RB + 
      ' ' + 
      full_AP)**

这将产生以下输出。

LogS =  0.26 -0.74 LogP -0.0066 MW + 0.0032 RB -0.42 AP

4.4.实验测井与预测测井的散点图

在开始之前，让我们快速检查一下训练集和测试集的可变维度。

这里我们正在检查列车组的尺寸。

**Y_train.shape, Y_pred_train.shape**

这会产生以下尺寸输出:

((915,), (915,))

这里我们检查测试集的维度。

**Y_test.shape, Y_pred_test.shape**

这会产生以下尺寸输出:

((229,), (229,))

4.4.1。垂直曲线图 现在让我们通过散点图来可视化实验对数值与预测对数值的相关性。我们将在两个散点图中分别显示测井曲线的实验值和预测值。在第一个版本中，我们将垂直堆叠两个散点图。

**import** **matplotlib.pyplot** **as** **plt****plt.figure(figsize=(5,11))

*# 2 row, 1 column, plot 1*
plt.subplot(2, 1, 1)
plt.scatter(x=Y_train, y=Y_pred_train, c="#7CAE00", alpha=0.3)

*# Add trendline*
*# https://stackoverflow.com/questions/26447191/how-to-add-trendline-in-python-matplotlib-dot-scatter-graphs*
z = np.polyfit(Y_train, Y_pred_train, 1)
p = np.poly1d(z)
plt.plot(Y_test,p(Y_test),"#F8766D")

plt.ylabel('Predicted LogS')

*# 2 row, 1 column, plot 2*
plt.subplot(2, 1, 2)
plt.scatter(x=Y_test, y=Y_pred_test, c="#619CFF", alpha=0.3)

z = np.polyfit(Y_test, Y_pred_test, 1)
p = np.poly1d(z)
plt.plot(Y_test,p(Y_test),"#F8766D")

plt.ylabel('Predicted LogS')
plt.xlabel('Experimental LogS')

plt.savefig('plot_vertical_logS.png')
plt.savefig('plot_vertical_logS.pdf')
plt.show()**

预测值与实验值的散点图(显示为垂直图)。

4.4.2。水平图 在第二个版本中，我们将水平放置两个散点图，如下面的代码块所示。

**import** **matplotlib.pyplot** **as** **plt****plt.figure(figsize=(11,5))

*# 1 row, 2 column, plot 1*
plt.subplot(1, 2, 1)
plt.scatter(x=Y_train, y=Y_pred_train, c="#7CAE00", alpha=0.3)

z = np.polyfit(Y_train, Y_pred_train, 1)
p = np.poly1d(z)
plt.plot(Y_test,p(Y_test),"#F8766D")

plt.ylabel('Predicted LogS')
plt.xlabel('Experimental LogS')

*# 1 row, 2 column, plot 2*
plt.subplot(1, 2, 2)
plt.scatter(x=Y_test, y=Y_pred_test, c="#619CFF", alpha=0.3)

z = np.polyfit(Y_test, Y_pred_test, 1)
p = np.poly1d(z)
plt.plot(Y_test,p(Y_test),"#F8766D")

plt.xlabel('Experimental LogS')

plt.savefig('plot_horizontal_logS.png')
plt.savefig('plot_horizontal_logS.pdf')
plt.show()**

预测值与实验值的散点图(显示为水平图)。

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

关于我

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

[## 数据教授

数据科学、机器学习、生物信息学、研究和教学是我的激情所在。数据教授 YouTube…

www.youtube.com](https://www.youtube.com/dataprofessor?sub_confirmation=1)

在社交网络上与我联系

✅YouTube:http://youtube.com/dataprofessor/
♇网站:http://dataprofessor.org/(在建)
♇LinkedIn:https://www.linkedin.com/company/dataprofessor/
♇Twitter:https://twitter.com/thedataprof
♇Facebook:http://facebook.com/dataprofessor/
♇github:https://github.com/dataprofessor/
♇insta gram:https://www.instagram.com/data.professor/【t19

来自《走向数据科学》编辑的注释: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。