TowardsDataScience 博客中文翻译 2019（二百六十一）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

如何防止种族主义机器人

原文：https://towardsdatascience.com/how-to-prevent-racist-robots-20a0dde6bec0?source=collection_archive---------33-----------------------

什么是算法公平，为什么它很重要？

你遇到过这种情况吗？

你在给你的同事讲故事，你提到了你的种族(不是白人)。突然，你的(白人)同事打断你并宣布:

You sure about that, Chad?

和你的老板谈论与你的女性身份有关的事情？为什么你一定要把性别带进来？如果你想被平等对待，那就不要提醒我你是女人。”

想结婚，摄影师却拒绝你服务？“你是同性恋只是巧合！我听着不像是歧视！”

在美国有许多受 T4 压迫的人群。系统性压迫是复杂的，但我们闭上眼睛，塞住耳朵，并不意味着不公正将不复存在。这只意味着我们站在它的中间，忽略它。

无知不是福。这只会让你变得无知。

尽管如此，许多人不理解或试图理解有色人种、女性、LGBTQ 人群、不同能力人群或其他任何目标人群的经历。他们选择忽略“他者”应该指出的是，这往往是善意的，但其结果却恰恰相反。机器每天做出的某些决定也是如此。

在他们的学术文章“算法公平”中，作者提出，如果我们(和我们的机器)想要利用这些信息做出重要决策，我们应该包括种族和其他代表受压迫群体的因素。如果我们忽视这些重要的因素，我们会弊大于利。为什么？我们来分解一下文章是怎么说的。

算法是一组步骤、规则或计算，计算机通常都有自己遵循的算法。我们越来越普遍地使用算法来做决策。仅举几个常见但重要的例子:医生决定某人是否有患病风险，法官设定保释金，学校分析申请。

一次又一次的事实表明，我们的“机器人”正在接受我们人类的偏见，做出歧视性的决定。来自文章:

因为用于训练这些算法的数据本身带有刻板印象和过去的歧视，所以很自然地会担心偏见正在被“烤熟”

因此，一个常见的反应是排除敏感因素，训练机器人宣布:

为什么这是个坏主意？在说之前，我们必须知道一个关键词的定义:公平。公平意味着公正。相等意味着“相同”因此，请记住，公平并不意味着平等。

The Difference Between Equality and Equity

当我们平等待人时，我们给予每个人同样的支持。当我们公平对待他人时，我们会给予每个人所需的支持，这样结果才会公平。

当然，我们的世界更加复杂…

Another idea: True liberation means no one cares about watching the game?

…但是这些知识足以帮助我们理解这篇文章。文章做了这样一个实验:

想象一下，我们有两个不同的大学招生顾问。一位名叫埃里卡的辅导员很有效率。Erica 的目标始终是录取在大学期间表现最好的学生。所以，她看着学生的申请，她使用机器学习模型来预测那个学生的大学平均绩点会是多少。艾丽卡所要做的就是选择最有潜力的学生。

另一个顾问法拉是公平的和高效的。Farrah 也想要最有潜力的学生，但她对申请者一视同仁。在实验中，他们将学生群体限定为非西班牙裔白人学生和黑人学生。因此，预测模型中唯一需要“不同”处理的变量是种族。Farrah 必须选择大学 GPA 最高的学生，确保有一定比例的黑人学生。

所以埃里卡是有效率的，她只想要在大学里表现最好的申请者。法拉是公平的，她希望申请人在大学里表现最好结合她想最大限度地增加黑人学生的数量。

他们使用的模型能够预测大学的 GPA，因为实验涉及到随着时间的推移跟踪申请人。所以，他们有一堆高中数据以及他们最终的大学平均绩点来显示他们在大学的真实表现。

Erica 以两种方式运行这个模型:排除种族，包括种族。不管是哪种模式，记住她总是有效地选择——预测平均绩点最高的学生。

Farrah 运行了包括种族在内的模型，她设置了不同的阈值，试图消除黑人申请者可能遇到的一些系统性偏见。例如，我们可能会担心一个黑人申请者没有参加 SAT 预备课程，而一个白人学生参加了。然后，如果这两个学生获得相同的 SAT 分数，该模型将预测黑人学生将有更高的大学 GPA。这只是 Farrah 对模型阈值进行的许多复杂调整中的一个例子。

结果非常棒:

• 最能预测申请人在大学表现的模型总是将种族因素考虑在内，即使在 Erica 的案例中，她只关心效率。这可能看起来违反直觉或令人困惑。换句话说，当人们处理申请并猜测申请人将如何上大学时，它带有我们所有的偏见，所以我们经常想从等式中去掉种族，以欺骗自己认为我们是公平的。然而，实际上由一个数学模型为我们做出预测更有效(准确)，因为他们的预测是基于数字，而不是基于有偏见的预感。因此，在模型中包含种族因素会更有效。
• 当 Farrah 对门槛进行公平调整时，无论她试图录取多少比例的黑人学生，使用种族意识预测器都会导致相对更多的黑人申请人被大学录取。因此，为了更加公平，有必要在模型中包含种族因素。
• 总之:永远包括种族。机器人应该能看到颜色。

“在没有法律约束的情况下，出于公平原因，我们应该纳入性别和种族等变量……纳入这些变量可以提高公平和效率。”

他们使用各种机器学习模型进行了这项实验，但他们一致发现，“让算法盲目进行种族划分的策略无意中损害了公平性。”

虽然这篇文章有一个老生常谈的结论，但解决算法偏差并不容易。我们如何定义什么是公平的？正如另一位名叫莎拉·谢弗勒的研究员指出的:

有许多不同的衡量公平的标准，它们之间有所取舍。那么……系统在多大程度上符合我们想要实现的公平理念呢？

即使一些科学家同意什么是公平的，我们也经常必须确保用不同的公平阈值实现我们的算法是合法的。正如我们在平权法案的历史中所看到的，举个例子，对于什么应该被合法实施，经常会有不同的意见。

我对几件不同的事情充满希望:

• 我希望我们能利用与他人相处的受教育机会，向他们解释为什么正确看待一个人的整个环境是非常有价值的，而不是抱着“无知是福”的心态。
• 我也希望那些受分析推理驱动的人能够理解像我们刚刚重复的文章。我们通过在我们的科学中包括像种族这样的受保护的因素，而不是忽视它，来尽可能做出最好的预测。这有利于所有人，不管我们对“公平”的定义是什么。

我们希望这两种情况能够汇聚成一个社会，在机器的帮助下，不断地为更大的利益做出决定。

如何用 12 种最流行的编程语言打印“Hello World”

原文：https://towardsdatascience.com/how-to-print-hello-world-in-top-12-most-popular-programming-languages-736d49c6c61c?source=collection_archive---------12-----------------------

Img source: yen.io

你好，世界！

当你开始学习编程时，或者当你只是在学习一门新的编程语言时，首先要做的事情之一就是做一些非常简单的事情。你要做的第一步是打印一个简单的文本。当你读这篇文章的时候，你可能知道哪一篇文章是最常见的，也是我所指的那一篇。

我正在谈论的文本是你好世界。

当你刚刚踏上一个重要的旅程时，这篇文章应该是你向世界问候的一种方式。尽可能多的学习之旅。

如果你很好奇，想看看如何在 12 种最流行的编程语言中做到这一点，那么让我们开始吧。不过在我们开始之前有一件事:流行度的排序是基于 GitHub 和 Tiobe 的，正如这里的所示。

1.Java 语言(一种计算机语言，尤用于创建网站)

2.C

3.计算机编程语言

4.C++

5.C#

6.Visual Basic。网

7.Java Script 语言

8.服务器端编程语言（Professional Hypertext Preprocessor 的缩写）

9.目标-C

10.结构化查询语言

11.红宝石

12.矩阵实验室

这些例子来自下面的库，在那里你可以找到更多的例子。

它是开源的，如果你知道其他没有列出的编程语言，你也可以对它做出贡献。

如何从零开始编程 UMAP

原文：https://towardsdatascience.com/how-to-program-umap-from-scratch-e6eff67f55fe?source=collection_archive---------4-----------------------

生命科学的数理统计和机器学习

以及如何改善 UMAP

Image source

这是我的专栏 生命科学的数理统计和机器学习 的第十三篇文章，我试图解释一些在生物信息学、生物医学、遗传学等领域使用的神秘分析技术。以一种简单的方式。在上一篇文章 中，我首先直观地解释了 UMAP 背后的数学原理。学习它的最好方法是从头开始为 UMAP 编程，这就是我们今天要做的。这篇文章的想法是要表明，每个人都可以相对容易地创建自己的邻居图降维技术，这种技术甚至可以提供比 UMAP 更好的可视化效果。这将是大量的编码，扣好安全带！

构建高维概率

作为测试数据集，我们将使用癌症相关成纤维细胞(CAFs) scRNAseq 数据。我们从导入 Python 库(主要使用 numpy 和 scikit-learn)开始，查看数据矩阵并检查数据集的维度。请注意，这里的行是细胞，列是基因，最后一列包含聚类结果的编码，即每个细胞属于 id 为#1、2、3 和 4 的 4 个聚类之一:

从一开始就要定义的一个重要的全局变量是初始高维 scRNAseq 数据集的平方成对欧几里德距离的矩阵，这个矩阵将在未来的代码中大量使用。在这里，我们还定义了局部连通性 参数 rho ，作为到第一个最近邻居的距离，关于该参数含义的更详细解释，参见上一篇文章。

使用平方成对欧几里德距离的矩阵，我们将计算高维空间中的概率矩阵。知道了这个矩阵，我们可以很容易地计算出每个细胞的熵和最近邻的数量，k = 2^Entropy.请注意函数的自变量*。这意味着作为的函数的概率矩阵将在以后用于二分搜索法过程，该过程为固定数量的最近邻居计算最优。***

这里的一个技巧是，为了方便起见，我们为每个第 I 个单元计算一个 1D 概率数组，这意味着为平方成对欧几里德距离矩阵的每个第 I 行(或列)(从第 I 个单元到数据集中所有其他单元的距离)。这样做是因为等式中有未知的 σ_i :

我们必须使用二分搜索法来为数据集中的第 I 个单元格找到 σ_i 。对于每个第 I 个单元格，给定高维概率的 1D 数组，我们可以对数组的元素求和，并根据定义计算最近邻的数量， k :

所以现在我们有了一个函数，它为每个第 I 个单元格的每个 σ_ i 生成最近邻的数量、 k 、(标量)值。我们可以固定最近邻值的数量(期望的 k 超参数)并将该函数输入到二分搜索法过程中，以便计算每个第 I 个单元的 σ_i 。

计算 σ_i 对于每个细胞，我们得到 n 个细胞的概率 1D 阵列，它们一起构建了一个高维概率矩阵。根据 UMAP 算法，该矩阵必须满足对称条件**😗*

然而，根据我的经验，下面更简单的对称条件提供了一个更好的可视化，我们将在后面看到。

我鼓励读者尝试不同的方法来获得高维概率的对称矩阵，并检查最终的可视化是如何变化的。

构建低维概率

接下来，我们将计算高维相邻图的布局，即根据 UMAP 定义的低维概率矩阵:

由于 UMAP 算法的目标是找到低维嵌入的最佳坐标， y_i ，其通过梯度下降过程被更新，我期望 a 和 b 参数也应该在每个梯度下降迭代中被更新。然而，在最初的 UMAP 算法中，它们似乎在最开始就被固定为 min_dist 超参数的期望值:

同样，在这里我看到了改进和实验的空间。为了简单起见，下面我将设置 a=1 和 b=1 ，以便得到一种 UMAP 和 tSNE 的混合。那么低维概率矩阵由下式给出:

学习低维嵌入

最后，我们将编码 UMAP 的代价函数，即交叉熵**，请参见上一篇文章了解该代价函数如何保持全局距离的详细信息。实际上，我们感兴趣的不是交叉熵本身，而是稍后将在梯度下降过程中使用的梯度。**

请注意 CE_gradient 函数中的 Q 矩阵。不应该根据 UMAP 算法对其进行归一化。然而，根据我的经验，这种规范化提高了低维可视化。我再次鼓励每个人在这里尝试。最后，我们用图拉普拉斯算子初始化低维嵌入的坐标 y_i ,并启动梯度下降过程:

交叉熵似乎在减少，并达到一个平台。请注意，这里为了简单起见，我实现了常规梯度下降，而不是 UMAP 最初实现使用的随机梯度下降。这是因为这篇文章的目的是展示 UMAP 的想法，而不是提供一个优化的漂亮的代码。现在，我们可以将低维嵌入可视化:

我们还可以很容易地动画显示不同的聚类是如何从拉普拉斯嵌入开始形成的，这是通过将每次迭代的图合并到 gif 文件中来完成的。

UMAP 的从头实现看起来工作良好，4 个细胞群的集群清晰可辨。如果我们在上面的低维嵌入中运行聚类算法，那么它们在识别细胞群体时不会有问题。

让我们将上图与最初的 UMAP Python + numba 实现进行比较。我们将使用 n_neighbors = 15 和 min_dist = 0.25，即与之前的从零开始 UMAP 实现中相同的 UMAP 超参数值。

我们在这里可以看到，从某种意义上说，与最初的 UMAP 实现相比，从头开始的实现提供了更独特的集群。这是由于在方法上应用了小的改变，例如略微不同的对称条件和交叉熵梯度中 Q 矩阵的归一化。

摘要

在这篇文章中，我们了解到用 Python 从头开始实现 UMAP 相对容易。因此，我的预测是，UMAP 只是一个开始，在不久的将来，单细胞基因组学研究领域将会出现更多、可能更好的降维技术。很简单调整低维和高维分布，制定更好的标准化和对称条件，更好的成本函数，并利用吸引力/排斥力来解决 N 体问题，以获得更好的低维表示。

在下面的评论中让我知道生命科学中的哪些分析技术对你来说似乎特别神秘**，我会在以后的帖子中尽量涉及它们。检查我的 github 上的帖子中的代码。在 Medium 关注我，在 Twitter @NikolayOskolkov 关注我，在 Linkedin 关注我。下一次，我将转向进化生物学，并展示如何利用古代 DNA 来估算种群数量，敬请关注。**

如何在线发布 Jupyter 笔记本——10 分钟内使用 AWS！

原文：https://towardsdatascience.com/how-to-publish-a-jupyter-notebook-online-using-aws-in-10-minutes-7f87f2b0cc50?source=collection_archive---------15-----------------------

无论您是在构建您的数据科学组合，还是需要与同事或朋友共享资源，了解如何在 AWS 上在线发布 Jupyter 笔记本都非常重要。

期待结果

在本文结束时，您将拥有一个可以通过互联网访问的 Jupyter 笔记本，网址如下:

Example result of this tutorial

步骤 0:创建 AWS 帐户

首先，你需要一个 AWS 账户。在这里设置非常容易。拥有一个账户是免费的，因为你为你使用的服务付费。

对于新帐户，AWS 在第一年给予巨大的折扣，称为免费层，本文中介绍的所有内容都是免费的。如果你是一个有经验的 AWS 用户(没有免费层)，你将为你的笔记本支付少量的流量。详见本文下面的免责声明。

对了，我和 AWS 没有隶属关系:我就是喜欢这种做法，所以想在这篇文章里和大家分享一下。

步骤 1:将 Jupyter 笔记本另存为。html 文件

为了使您的笔记本可以在线访问，您需要将其导出为 HTML 文件。HTML 是静态网站的语言，它将被 AWS 认可。

为了使您的笔记本可以在线访问，您需要将其导出为 HTML 文件。

• 在 Jupyter 笔记本上，当你的笔记本准备发布时，进入*‘文件’→‘下载为’→‘HTML(。html)'*

Save your Jupyter Notebook as HTML

• 使用网站 URL 可接受的名称(避免空格和某些字符)将 HTML 文件保存在您记得的位置。

步骤 2:创建一个 S3 存储桶

在 AWS 中，我们将使用 S3 服务。S3 是 AWS 服务，允许文件存储和建立静态网站。我们使用它是因为它很便宜并且很容易安装。

S3 是 AWS 服务，允许文件存储和建立静态网站。

S3 的所有东西都用所谓的水桶。存储桶就像一个文件夹，你可以把你的文件放在里面。要与 S3 合作，你必须做一个桶，让我们开始吧:

• 转到 aws.amazon.com 并登录 AWS 管理控制台。
• 在“服务”下拉菜单中，单击 S3

Navigate to S3

• 在 S3 菜单中，点击“创建铲斗”,将出现以下菜单:

Create an S3 bucket

• 作为一个桶名，注意使用一些适当的东西，因为它将是你的 URL 的一部分！作为一个地区，采取一些接近你的网站访问者会在哪里(虽然这并不重要)。然后单击下一步。
• 现在，他们会询问您的访问偏好。我们希望给予每个人访问权限，因为每个人都应该能够通过互联网访问您的笔记本。

Give everyone access to your website

• 在下一个屏幕中，单击 next 并创建 bucket。

步骤 3:将您的 bucket 配置为静态网站

S3 服务可用于制作静态网站，但也经常用作文件存储。

就访问权限而言，文件存储和网站托管并不完全相同:在网站上，你希望每个人都可以访问，而对于文件存储，你可能希望将访问权限限制在选定的一组人。

在本例中，我们希望托管一个静态网站，因此有必要按如下方式指定此 S3 存储桶的属性:

• 你的。html 笔记本实际上是所谓的静态网站，我们需要通过“属性”→静态网站托管来指定

AWS S3 Console

• 在*“静态网站托管菜单”中，将“索引文档”*设置为您的 HTML-notebook 文件的确切名称。

S3 Static Website Hosting

• 在这个菜单的顶部，你可以看到“端点”，这是你可以访问你的网站的终点。所以你最后会需要它。点击*‘保存’*继续。

步骤 4:上传您的笔记本

最后一步是将你的 HTML 笔记本上传到你的桶中。这样做很容易:

• 在*“概览”菜单中，点击“上传”*，然后拖放您的。步骤 1 中的 html 文件。
• 在*‘设置权限选项卡’中选择‘授予公共读取权限’*

AWS S3 access permissions

• 保留其他设置，单击下一步，然后发布。

仅此而已！您现在可以分享了！

只需在任何浏览器中使用步骤 3 中的 URL 即可查看您的笔记本。

Our Jupyter notebook is online!

祝贺您，现在全世界都可以访问您的文件了！

免责声明:
除非你有很大的流量，否则这种方法是免费的，如果你在 AWS 免费层(你的 AWS 帐户的第一年)，并且在第一年后有一个非常小的月费。我与你分享这种方法，因为我喜欢它。我和 AWS 没有任何关系，有很好的替代品，例如 GitHub pages 或 GitHub Gists，或者任何其他云提供商。无论使用这种方法还是其他方法，我都不接受 AWS 上发生的任何费用的任何责任或义务。

AWS source of billing information

非常感谢您的阅读，敬请关注更多精彩的数据科学文章！

如何将你的机器学习放入 Docker

原文：https://towardsdatascience.com/how-to-put-your-machine-learning-in-a-docker-6b372849fa93?source=collection_archive---------15-----------------------

你是一名数据科学家，你了解业务问题，你收集数据，执行一些功能工程，并提出了一个惊人的机器学习模型，可以在本地 IDE 上很好地预测东西。

但是接下来呢？

换句话说，如何将您的模型部署到生产环境中，或者轻松地与其他人共享，以便他们可以在本地 PC 上运行和评估它，并在**看不见的数据上运行，**无需安装任何库、依赖项、图形界面(IUPython、Jupyter Notebook…)，或者查看您的代码。

Docker 是这个问题的答案之一，因此，我们将在接下来的段落中看到如何将你的模型包含在一个 Docker 中，并将其分发给其他人。

在这个例子中，我们将使用一个简单的线性回归模型。

让我们从启动我们的库开始:

import warnings
warnings.filterwarnings(**"ignore"**, category=FutureWarning)

import sys
import pandas as pd
from sklearn.linear_model import LinearRegression

之后，我们将需要导入数据:
**训练数据:**我们的模型将从中学习的数据。
测试数据:将由任何需要根据看不见的数据评估你的模型的人引入。

测试数据和训练数据应该有，很明显，与外形相同的。

TestData = sys.argv[1]
# Read the data that will serve for training and the test data
X_full = pd.read_csv(**"TrainingData.csv"**, index_col=**'x001'**)
# Read the data that will serve for testing
X_test = pd.read_csv(**TestData**, index_col=**'x001'**)

我们将把目标数据从整体数据中分离出来:

#separate target from predictors in both training and test data
y = X_full.y
y_test=X_test.y

X_full.drop([**'y'**], axis=1, inplace=True)
X_test.drop([**'y'**], axis=1, inplace=True)

然后，我们将应用我们的模型:

 model=LinearRegression()
model.fit(X_full,y)
preds = model.predict(X_test)

接下来，我们将把预测输出结果保存在文件 outputTest.txt. 中

# Save test predictions to file
output = pd.DataFrame({**'Id'**: X_test.index,**'Y Original'**: y_test, **'Y predicted'**:preds})
output.to_csv(**'/data/outputTest.txt'**, index=False)

现在我们已经有了基本模型，我们将试着把它放到一个 docker 上。
为此，我们首先需要创建 docker 映像创建所需的文件，即 Dockerfile 和 requirement.txt

#DockerFile:

FROM python:3
COPY Your_python_code.py./
COPY requirements.txt ./
COPY **TrainingData.csv** ./

RUN pip install -r requirements.txt
CMD ["python", "wallet.py", "/data/**testData.csv**"]

#requirements.txt(不需要下载数学库，因为它会自动添加 python3)。

pandas
sklearn

然后，我们将 TrainingData.csv、Your_python_code.py DockerFile 和 requirements.txt 放在同一个文件夹中，打开一个终端，转到该文件夹，启动以下程序:

docker build -t <your_docker_image_name> .
# dont forget the . at the end.

然后，我们将图像推送到我们在 DockerHub 中的帐户(我们假设您在 docker hub 上有一个帐户，如果没有，您可以免费创建一个，然后在您的 PC/MAC 上启动 docker 应用程序) :

docker push <your_docker_image_name>

现在你的模型在 Docker hub 中，你可以与你的朋友分享它。你可以要求他们做以下事情:

1-从 Docker Hub 获取图像:

docker pull <your_docker_image_name>

2-运行容器:

docker run -v <path>:/data/ <your_docker_image_name>

其中 是您的训练数据的本地路径 testdata . CSV .
在这个例子中，您的文件应该按照 requirements.txt 命名为 testdata . CSV

示例 :
如果您的 testData.csv 在/var/files/中，那么您应该运行:

*docker run -v /var/files/:/data/ <your_docker_image_name>*

输出 :
将创建一个输出文本文件 outputTest.txt ，包含 3 列:
ID、Y 的实际值和 Y 的预测值。
输出将保存在 <路径> 目录中，在上面的示例
中，输出将保存在 /var/files/ 中，并命名为
outputTest.txt

请在这个要点上找到完整的代码。

一如既往，希望你学到了新东西:)

萨拉姆。

如何生产 PyTorch

原文：https://towardsdatascience.com/how-to-pytorch-in-production-743cb6aac9d4?source=collection_archive---------8-----------------------

Photo by Sharon McCutcheon on Unsplash

ML 好玩，ML 流行，ML 无处不在。大多数公司使用 TensorFlow 或 PyTorch。例如，有些老同性恋更喜欢咖啡。大部分都是关于谷歌和脸书之战。

我的大部分经验都去了 PyTorch，即使大部分教程和在线教程都用 TensofFlow(或者希望是 bare numpy)。目前，在 Lalafo(人工智能驱动的分类)，我们正在与 PyTorch 玩得开心。不，真的，我们试过 caffe，它太棒了，除非你还没有花几天时间安装它。更好的是，PyTorch 现在是 1.0，我们从 0.3 开始使用它，它非常简单和健壮。啊啊…也许这里稍微调整一下，那里稍微调整一下。大多数问题都很容易解决，没有给我们带来任何问题。在公园散步，真的。

在这里，我想分享在生产中使用 PyTorch 最常见的 5 个错误。考虑用 CPU？多线程？使用更多的 GPU 内存？我们已经经历过了。现在让我也来引导你。

错误# 1——在推理模式下存储动态图

如果您以前使用过 TensorFlow，您可能会意识到 TF 和 PT 之间的关键区别——静态图和动态图。由于每次模型改变时都要重建图形，所以调试 TFlow 非常困难。这需要时间、努力和你的希望。当然现在 TensorFlow 更好。

总的来说，为了使调试更容易，ML 框架使用了与 PyTorch 中所谓的Variables相关的动态图。您使用的每个变量都链接到前一个变量，为反向传播建立关系。

下面是它在实践中的样子:

在大多数情况下，您希望在模型定型后优化所有计算。如果你看火炬界面，有很多选项，特别是在优化方面。eval模式、detach和no_grad方法造成的很多混乱。让我解释一下它们是如何工作的。在模型被训练和部署后，这里是你关心的事情:速度，速度和 CUDA 内存不足异常。

为了加速 pytorch 模式，你需要将它切换到eval模式。它通知所有层在推理模式下使用 batchnorm 和 dropout 层(简单说就是停用 dropout)。现在，有一种detach方法，它从计算图中删除变量。当你从零开始构建模型时，它是有用的，但是当你想要重用最先进的模型时，它就不那么有用了。一个更全局的解决方案是在torch.no_grad上下文中向前回绕，通过不在结果中存储图形链接来减少内存消耗。它节省了内存，简化了计算，从而提高了速度，减少了内存的使用。答对了。

错误 2——没有启用 cudnn 优化算法

在 nn 中有很多布尔标志可以设置。模块，你必须知道的存储在 cudnn 命名空间。使用cudnn.benchmark = True启用 cudnn 优化。为了确保 cudnn 寻找最优算法，通过设置cudnn.enabled = True启用它。NVIDIA 在优化方面给你带来了很多好处。

请注意，您的数据必须在 GPU 上，模型输入大小不应变化。数据的形式越多样化，可以进行的优化就越少。例如，为了标准化数据，可以对图像进行预处理。总的来说，要有创意，但不要太多。

错误 3——重用 JIT 编译

PyTorch 提供了一种简单的方法来优化和重用来自不同语言的模型(阅读 Python-To-Cpp)。如果你足够勇敢，你可能会更有创造力，用其他语言注入你的模型(我不是，CUDA: Out of memory是我的座右铭)

如果输入的形状不变，JIT 编译允许优化计算图形。这意味着如果你的数据没有太大的变化(见错误 2 ), JIT 是一个不错的选择。老实说，与上面提到的no_grad和cudnn相比，这并没有太大的不同，但是可能会。这只是第一个版本，潜力巨大。

请注意，如果您的模型中有conditions，它将不起作用，这在 RNNs 中是常见的情况。

完整文档可在 pytorch.org/docs/stable/jit网站上找到

错误#4 —试图使用 CPU 实例进行扩展

作为云中的虚拟机，GPU 非常昂贵。即使你查 AWS 一个实例也要 100 $/天左右(最低价0.7$/h)参考:aws.amazon.com/ec2/pricing/on-demand/。我使用的另一个有用的备忘单是 www.ec2instances.info 每个从 3d 年级毕业的人都会想:“好吧，如果我买 5 个 CPU 实例而不是 1 个 GPU 会怎么样”。试过在 CPU 上运行 NN 模型的人都知道这是个死胡同。是的，你可以为 CPU 优化一个模型，但是最终它还是会比 GPU 慢。我强烈建议放松一下，忘掉这个想法，相信我。

错误 5——处理向量而不是矩阵

• cudnn -检查
• no_grad -检查
• GPU with correct version of CUDA -检查
• JIT-compilation -检查

万事俱备，还能做什么？

现在是时候运用一点数学知识了。如果你记得大多数神经网络是如何使用所谓的张量来训练的。张量从数学上讲是一个 N 维数组或者多线性几何向量。你可以做的是将输入分组(如果你愿意的话)到张量或矩阵中，并输入到你的模型中。例如，使用图像数组作为发送到 PyTorch 的矩阵。性能增益等于同时传递的对象数量。

这是一个显而易见的解决方案，但很少有人真正使用它，因为大多数时候对象是一个接一个处理的，从架构上建立这样的流程可能有点困难。别担心，你会成功的！

下一步是什么？

关于如何在 PyTorch 中优化模型，肯定有更多的技巧。我会继续张贴我们在野外使用脸书小子的经验。你呢，你有什么技巧可以在推理上取得更好的表现？

原载于 2019 年 2 月 18 日【tarasmatsyk.com】。

如何在生产中 Pytorch:第 2 部分。体系结构

原文：https://towardsdatascience.com/how-to-pytorch-in-production-part-2-architecture-20fc9a423617?source=collection_archive---------16-----------------------

Photo by Isaac Smith on Unsplash

最近我做了一个关于将 PyTorch 模型部署到产品中的演讲。你可以在这里找到幻灯片事件驱动 ML 。简而言之，我们从一个简单的原型开始，到一个生产就绪的可扩展解决方案。在这篇文章中，我想分享我们的发现。

我们是谁，我们做什么

基本上，Lalafo 是一个分类器。如果你想卖旧手机，你可以找我们。这就是现代纸质广告。然而，这里的商业模式非常简单，我们真正想做的是把它带到下一个层次。到目前为止，常规发布时间大约需要 2 分钟。我们的目标是将这个时间减少到几秒钟。我不是在开玩笑。为了实现这一目标，我们需要变得更加技术化。我们的一个助手是 AI，它用于填充价格，描述，照片分类和我们关于用户和类似项目的数据。最终目标是这样的(简而言之:你拍一张照片，剩下的我们来做):

到目前为止，我们正在整合下一个版本的移动应用程序的所有内容，并进行用户测试，以确保它是一个爆炸。

这一切是如何开始的？

或者说，如何在一天内造出一个原型。

说实话，每当一个商业人士来找你说:“我想造一辆自动驾驶汽车，你能做到吗？”。当然，作为软件工程师，我们有解决方案。

我们该怎么办？就我个人而言，我会去谷歌上输入“stack overflow how to a self-driven car”->回车。第一个答案会告诉您使用 JQuery，第二个会提示您从哪里开始。这就是我们应对图像识别挑战的方式，开始非常简单，这里是我们选择的一组技术:

我打赌这对你来说是显而易见的，以下是你得到的结果:

• 用于 PyTorch 模型的带 GPU 的 AWS
• 龙卷风在它上面处理 10K 问题
• 用于缓存预测的 Redis

老实说，这样的设置每分钟可以分类大约 200 张图像，如果我被要求为另一个模型提供 PoC，任何基于 AWS 的 Redis 的 python 异步框架都可以胜任。

200 这个数字是怎么来的？

这完全取决于度量，这里是我们定义的成功的图像处理。我们的分类流程如下:

• 你给我们发送一张带有POST请求的图片，
• 然后您使用GET来接收结果。
• 如果结果已准备好—图像处理速度足够快。

通常，需要 1 到 2 秒钟。考虑到这一需求，在线程池中运行 PyTorch 的 Tornado 每分钟可以处理 200 张图像。为什么选择 ThreadPool？等一下，我会解释的。

值得一提的是，我们有 8Gb 的 GPU 内存和大约 20Gb 的 RAM，其中 5Gb 由服务器消耗，原因是线程池和缓存队列。如果你想知道我们为什么不使用 ProcessPoolExecutor——那是因为 PyTorch，它不能很好地处理 python 并发，现在也不能。考虑到您必须考虑内存共享，线程池是一个非常简单的选择。我们幸福吗？没有。我们找到更好的方法了吗？我对此不太确定，不过，还有一种选择。

那又怎样？目前的方法有问题吗？

嗯，退一步说，AWS 很贵，线程化不是并行，Tornado 监控很难，伸缩性也不是那么明显(只是在 N 个 workers 服务器上面放上负载平衡器，我们称之为 python 方式)，ML 结果不持久等等。这就是我们开始考虑构建一个可扩展的分布式系统的地方。最初的计划是这样的:

我们有几个目标要实现:

1. 监控。(将数据点发送到流入液中，并使用 Grafana 进行监控)
2. 节省一些美元。(我们有机会采用 K8s，并选择 Hetzner 作为 it 提供商的 Linux 裸机)
3. 能够根据要求进行扩展
4. 玩得开心(我们决定采用 Go 进行数据处理和 API)
5. 持久性(选择 PSQL 来存储分类结果，以便我们可以构建报告和分析历史)
6. 可扩展(如果我们决定要添加更多的 ML，我们应该能够在最短的时间内完成)
7. SDK 友好的(API 用户应该也很高兴)

我们最后去了哪里？让我们回顾一下组件

这是我们最后得到的结果:

让我们逐一回顾一下差异和组件

API 与 ML

主要决定是将与客户端和数据处理层的交互分开。最后，我们有了 Go+Swagger+PostreSQL API，它消耗大约 20Mb 或 RAM，工作非常好，可以扩展 10 倍，而无需考虑新服务器(是的，我们的数据中心容量有限，但是，K8s 通过增加额外的容量来解决它)。

问题是在这两者之间放什么呢？我们有不同的选择，从 Redis、RabbitMQ、HTTP/gRPC 开始，到 Kafka 结束。主要的两个优点是:易于扩展分区和消息缓冲。主要缺点是再平衡。如果您以前使用过它—您知道它，否则请在实现您自己的消息总线之前测试 Redis 或 RabbitMQ。

监视

因为我们有一个可用的流入服务器，所以发送一些数据点并使用 Grafana 监控它们是一个非常合理的选择。这是一个活系统看起来像 atm 的样子:

如果我们必须选择的话，我们可能会选择哨兵或者麋鹿栈，在它上面使用 APM 。

节省一些美元

AWS 的成本比其他产品高得多，甚至更贵。我们订购了几台 GeForce GTX-1080，在 Hetzner 上使用 8Gb GPU，节省了 10 倍美元。对欧洲非常有效。此外，我不会说它是超级可靠的，但是，如果你把两个集群和一个负载均衡器放在它们之间——一切都工作得很好。无论如何，即使是 5 个集群也比 AWS 便宜 2 倍，高效 5 倍，对不起 Jeff。

能够根据要求进行扩展

如果你曾经在 K8s 或 infrastructure 中尝试过 helm 作为代码，你应该知道这里的伸缩只是一行代码的变化。一旦你进入 K8s，你就很容易升级一个 pod。另一个问题是去那里有多难，但我们很幸运地在另一方面获得了一些专业知识。

开心

Go 很有趣，它是一种静态类型的编译语言，被宣称为框架本身。goroutine 不仅有名，如果您在生产或生活中有任何问题，只需添加 go routine，它就会得到解决。

虽然我们确实玩得很开心，而且 go 确实是一种设计良好的语言，但它仍然给我们带来了一些痛苦。如果你来自一个有 25 年历史的语言，它有很多很多库，看起来 Go 没有很多，这是真的。需要数据库？编写普通的 SQL。需要一个 API 服务器？编写自己的中间件和请求解析器。需要文档吗？幸运的是它在那里。当然，如果我们谈论大摇大摆，也不完全完整。

一方面，它节省了我们一些时间，减少了打字带来的痛苦，另一方面，它还不太成熟，即使是 10 年前的语言，你也需要回馈社区。没有人们告诉你的那么糟糕，也没有那么甜蜜。对此半信半疑。无论如何，它工作得很好，我们将在小服务中坚持使用它。

坚持

第一个里程碑是 Redis，因为它很简单。你把 json 放到内存里，它活的好好的。直到…你没有内存了。多加点内存就行了。正确。然而，如果你有处理内存结束相当快。对我们来说，15 分钟的工作大约需要 1Gb。让我们把它增加到 1 小时，你得到 4Gb。RAM 绝对是一种便宜的资源，但是，你知道什么更便宜吗？磁盘空间和在 2k19 SSD 便宜得要命，快得像兔子。

所以我们决定使用关系数据库，将数据反规范化并存储在 PostgreSQL 中。工作得很好，我们不会离开它，除非我们厌倦了数据方案的维护，并希望使用 NoSQL。如果我们能以正确的方式去做。我们试图使用 MongoDB 作为 NoSQL 数据库来存储历史数据，因为你知道吗，每个大数据初创公司都应该使用 MongoDB——最终，我们花了更多时间来优化它，并编写代码来处理非结构化数据。下次我会再试一次。

可展开的

让我们再来看这幅画。

看到右边的容器了吗？每个 ML 任务都存在于自己的容器中，并且只做一件事。这要么是欧几里得距离的指数，要么是分类任务或回归——我们把它放在单独的盒子里。这允许我们在任何时候扩展瓶颈位置，而不需要调整系统的其余部分。如果分类很慢——添加更多的分类器，太多的 API 请求——再添加一个 API 服务器。每个盒子只负责一件事，而且做得很好。如果我们决定从 PyTorch 迁移到 Keras 或 tensor flow——我们可以迁移一个容器，然后看看情况如何。如果成功了——在整个系统中推广。听起来像个计划吗？

SDK 友好的

作为一名工程师，我真的很讨厌那些可以工作，但是要么不能工作，要么文档非常糟糕的系统。你所能做的就是玩玩它，猜猜看，谁知道当你上线的时候会有什么在等着你。我可能集成了 2017 年之前推出的所有第三方系统，记录不良的服务数量惊人。我们希望我们的用户有一个愉快的体验，我们为此而努力。

一个很好的起点是 swagger 文档，我们打算用它来自动生成 SDK 客户端。这基本上是亚马逊做的，一切都很好。然而，每个 AWS 客户端看起来都像是你在写 Java，不管你用的是什么语言。因此，在我们交付定义良好的 API 之后，下一个里程碑将是原生 SDK 客户端和…击鼓…如何使用它们的例子。真的，这么多 API 至少缺少例子，我甚至没有说文档可能会误导。

最后，我们在发布新的架构和试验更多可以作为特性添加的东西上已经进行了一半。在我们确保它功能丰富之后，我们将把它公之于众，让开发人员容易使用，并不断尝试扩展和性能调整，因为这很有趣。如果你想知道我们决定在 API 中做什么，让它可以扩展新的特性，请告诉我。

原载于 2019 年 3 月 26 日【tarasmatsyk.com】。

如何在 BigQuery 中查询和计算 Google Universal Analytics 数据

原文：https://towardsdatascience.com/how-to-query-and-calculate-google-analytics-data-in-bigquery-cab8fc4f396?source=collection_archive---------0-----------------------

带有示例查询的标准 SQL 指南

W 当我第一次开始在 BigQuery 中查询谷歌分析数据时，我很难解释隐藏在ga_sessions_导出表中的“原始”点击级数据。因为我找不到关于如何在 BigQuery 中计算 Google Analytics 指标的可靠指南，所以我决定自己写一个。我提供了许多示例查询，因此您不必重新发明轮子，希望您可以节省一些宝贵的时间。

更新:你喜欢这篇文章吗？那么你也会喜欢我的新网站【GA4BigQuery.com】:这是一个关于如何在 big query&rock your digital marketing Analytics 中查询谷歌分析数据的技巧、想法、示例查询和教程的数字指南。

我已经将本文中的大多数示例查询迁移到新网站，因为在一个地方维护所有内容更容易。这篇文章将留在网上，让你找到正确的地方。

我也在 BigQuery 中发表了一篇关于 查询 Google Analytics 4(之前为 App + Web)事件数据的文章。此内容将被迁移到【GA4BigQuery.com】中。

Image by Berber Bijlsma

目录

–Google Analytics 数据简介 big query
–多表
–用户–
–会话
–时间
–流量来源
–地理网络
–平台或设备
–页面追踪
–
–增强型电子商务(产品)
–自定义维度&自定义指标
–自定义渠道分组
–日内表格
–实时表格&查看

BigQuery 中的 Google 分析数据简介

The BigQuery User Interface

为什么是 BigQuery？

对于那些想知道为什么应该使用 BigQuery 来分析谷歌分析数据的人，请阅读这篇优秀的文章。一些大优势:

• 不再取样。永远不会。
• 无限数量的维度
• 将不同的范围合并在一份报告中(不适合胆小的人！)
• 计算目标完成情况，建立您自己的渠道分组并纠正数据错误，所有这些都基于过去的数据
• 将谷歌分析数据与第三方数据源相结合

陡峭的学习曲线

但是我们不要太激动。事实是，一旦你发现很多你习惯的谷歌分析指标无处可寻，钻研 BigQuery 可能会相当令人沮丧。

Google Analytics 用户，特别是高级用户对 BigQuery 感兴趣的原因是，Google 可以每天将原始的 Google Analytics 数据转储到 BigQuery 中。虽然这使得许多类型的分析无法在 Google Analytics 界面中执行，但它也没有提供任何基本的指标，例如，跳出率。(来源

这有两个方面:困难的部分是我必须计算我的查询中每一个“缺失”的谷歌分析指标。积极的影响:我在概念层面上对度量标准的理解有了很大的提高。

Source

另一个障碍

的 BigQuery 食谱在某些情况下帮助了我，但有时也显得不完整和过时。因为标准 SQL 语法是当今首选的 BigQuery 语言，并且许多旧的 Stackoverflow 条目正在使用(很快将被弃用？)遗留的 SQL 语法，我花了很多时间来思考我必须编写的 SQL 查询，以获得我想要的报告。除了我需要注意的计算度量之外，还有另一个障碍需要跨越:嵌套和重复的字段。

Google Analytics BigQuery 转储中的每一行都代表一个会话，并包含许多字段，其中一些字段可以是重复的和嵌套的*，例如 hits，它包含一组重复的字段，代表会话期间的页面视图和事件，以及 custom dimensions，它是一个单独的重复字段。这是 BigQuery 和普通数据库的主要区别之一。(来源)*

我的目标

有了这篇文章，我希望能为你省去一些麻烦。我将向您展示如何创建会话和用户级别的基本报告，稍后我将展示一些更高级查询的示例，这些查询涉及点击级别的数据(事件、页面浏览量)、结合不同范围的多个自定义维度、处理(增强的)电子商务数据以及将历史数据与实时或当天数据结合起来。

在家试试这个

没有谷歌云计费账户？进入 BigQuery 沙箱，它允许你使用 BigQuery web UI 而无需启用计费账户。要设置 Google Analytics to big query export，您需要 Google Analytics 360(Google 营销平台的一部分)。

Standard SQL in BigQuery

我假设您对作为查询语言的 SQL 和作为数据库工具的 BigQuery 有基本的了解。如果没有，我建议您先学习 SQL 入门课程，因为我不会详细介绍 SQL 语法，而是将重点放在如何从 BigQuery 中获取您的(自定义)Google Analytics 报告以供分析。所有查询示例都使用标准 SQL。

在本文中，我们将为 BigQuery 使用 Google Analytics 样本数据集，它包含来自 Google 商品商店的分析数据。

Google Merchandise Store

然而，如果你想用 Google Analytics 比较你的查询结果，我建议你使用你自己的 Google Analytics 数据集，因为我已经注意到 Google Analytics 中的 Google 商品商店数据和样本 BigQuery 数据集之间的差异。我在其他谷歌分析账户上测试了这些查询，它们匹配得相当好。

导出模式

为了更好地理解 BigQuery 中的ga_sessions_表，让我们看看 BigQuery 导出模式，它让我们了解了 BigQuery 中可用的原始 Google Analytics 数据字段。

尽管您可能会从 Google Analytics UI 中识别出许多维度和指标，但我知道这种模式可能有点令人不知所措。为了更好地理解我们的数据集，我们必须知道(嵌套)字段的结构。下一张图片代表来自ga_sessions_表的两行(= 2 个会话)。

Source

嵌套示例

如你所见，如果你需要自定义维度、自定义指标或任何点击量数据，即事件、页面浏览量或产品数据，我们的麻烦就来了。让我们查询我们的嵌套样本集:

*SELECT
  *
FROM
  `bigquery-public-data.google_analytics_sample.ga_sessions_20170801`
LIMIT
  2*

这给了我们 2 行，表示为平面表，如下所示:

记住，在这个例子中，只有第 2 行和第 14 行是我们表中真正的行。其他“行”实际上是嵌套字段，大多数情况下是NULL值。只有hits.product列填充了值。

为了处理这些字段，并能够查询我们的表以满足我们的需求，我们需要UNNEST函数。

这里的问题是它本质上是一个数组(实际上在 BigQuery 中它是一个“重复的记录”，但是你可以把它看作一个数组)。(…)这就是UNNEST函数的用武之地。它基本上允许你在一个数组中获取元素，然后展开每一个单独的元素。然后，可以将原始行与每个未嵌套的元素连接起来，将它们添加到表中。(来源)

我强烈推荐阅读这篇文章，它以 Firebase Analytics 样本数据集为例详细解释了UNNEST概念。

您只需UNNEST包含“重复字段”的记录。对于我们的谷歌分析数据集，这些可能涉及:

用户/会话范围

• 自定义维度

命中范围

• 打击
• hits.customDimensions
• hits.customMetrics

产品范围

• hits.product
• hits.product.customDimensions
• hits.product .自定义度量

为了确保您理解 BigQuery 导出模式的结构，我鼓励您看一看这个交互式可视化表示。

Source

好的。理论废话够多了。准备好行动了吗？我们来查询一下！

返回目录

多个表格

BigQuery 中的 Google Analytics 数据每天存储在一个表中。如果您只需要某一天的数据，查询中的FROM子句将如下所示:

*SELECT
  *
FROM
  `bigquery-public-data.google_analytics_sample.ga_sessions_20160801`*

在大多数情况下，您需要查询更长的时间段。输入_table_suffix。更多细节在这里，但是要查询谷歌分析数据的多个表格，你只需要这些例子。请注意，您可以将静态日期和动态日期结合使用，或者在最近 90 天左右的滚动期内只使用静态日期或动态日期。也可以在您的查询中包含日内表。

静态日期范围

当您对静态数据范围执行分析时，您应该使用固定的开始和结束日期。在本例中，我们选择 2016 年 8 月 1 日至 2017 年 8 月 1 日。

*SELECT
  *
FROM
  `bigquery-public-data.google_analytics_sample.ga_sessions_*`
WHERE
  _table_suffix BETWEEN '20160801'
  AND '20170801'*

动态日期范围

在本例中，我们选择“今天”——到昨天为止的 30 天。

*SELECT
  *
FROM
  `bigquery-public-data.google_analytics_sample.ga_sessions_*`
WHERE
  _table_suffix BETWEEN FORMAT_DATE('%Y%m%d',DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY))
  AND FORMAT_DATE('%Y%m%d',DATE_SUB(CURRENT_DATE(), INTERVAL 1 DAY))*

静态和动态日期的组合

我们知道我们的数据集中有 366 个日表，所以我们可以在这里使用固定的结束日期(20170801)，但是通常我更喜欢固定开始日期和动态结束日期的组合(在本例中:今天减一)。如果新数据被添加到我们的数据集中，它会自动包含在我们的查询中。在本例中，我们选择 2016 年 8 月 1 日至昨天。

*SELECT
  *
FROM
  `bigquery-public-data.google_analytics_sample.ga_sessions_*`
WHERE
  _table_suffix BETWEEN '20160801'
  AND FORMAT_DATE('%Y%m%d',DATE_SUB(CURRENT_DATE(), INTERVAL 1 DAY))*

返回目录

用户

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。

用户维度

用户类型
会话计数

用户指标

用户
新用户
%新会话
每个用户的会话数量
点击

示例查询

* [## 用户:维度和指标(UA)

此示例查询包含以下所有 Google Analytics 用户维度和指标。如果你只需要一个维度…

www.ga4bigquery.com](https://www.ga4bigquery.com/user-dimension-metrics-ua/)

返回目录*

会议

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的# comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。

会话维度

-

会话指标

会话
跳出率
跳出率
平均值。会话持续时间

示例查询

* [## 会议:维度和指标(UA)

此示例查询包含以下所有 Google Analytics 会话维度和指标。如果你只需要一个…

www.ga4bigquery.com](https://www.ga4bigquery.com/session-dimensions-metrics-ua/)

返回目录*

时间

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。

时间维度

日期
年份
ISO 年份
年份月份
年份月份
年份星期
年份星期
ISO 年份星期
ISO 年份星期
月份日期
星期日期
星期名称
小时
分钟
日期小时和分钟

时间度量

-

示例查询

* [## 日期和时间:维度和指标(UA)

此示例查询包含以下所有 Google Analytics 日期和时间维度和指标。如果你只需要一个…

www.ga4bigquery.com](https://www.ga4bigquery.com/date-time-dimensions-metrics-ua/)

返回目录*

流量来源

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或指标，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。

交通来源维度

推荐路径
完整推荐人
默认频道分组
活动
来源
媒介
来源/媒介
关键词
广告内容
社交网络
社交来源推荐
活动代码

流量来源指标

-

示例查询

* [## 流量来源:维度和指标(UA)

此示例查询包含以下所有 Google Analytics 流量来源维度和指标。如果你只需要一个…

www.ga4bigquery.com](https://www.ga4bigquery.com/traffic-sources-dimensions-metrics-ua/)

返回目录*

地理网络

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。

地理网络维度

洲
亚洲
国家
地区
地铁
城市
纬度
经度
网络域
服务提供商
城市 ID

地理网络度量

-

示例查询

* [## 地理网络:维度和指标(UA)

此示例查询包含以下所有 Google Analytics 地理网络维度和指标。如果你只需要一个…

www.ga4bigquery.com](https://www.ga4bigquery.com/geo-network-dimensions-metrics-ua/)

返回目录*

平台或设备

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。

平台或设备尺寸

浏览器
浏览器版本
操作系统
操作系统版本
移动设备品牌
移动设备型号
移动输入选择器
移动设备信息
移动设备营销名称
设备类别
浏览器大小
数据源

平台或设备指标

-

示例查询

* [## 平台和设备:维度和指标(UA)

此示例查询包含以下所有 Google 分析平台和设备维度和指标。如果你只需要…

www.ga4bigquery.com](https://www.ga4bigquery.com/platform-and-device-dimensions-metrics-ua/)

返回目录*

页面跟踪

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或指标，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。

页面跟踪尺寸

主机名
页面
上一页路径
页面路径一级
页面路径二级
页面路径三级
页面路径四级
页面标题
登陆页面
第二页
退出页面

页面跟踪指标

入口
浏览量
独特浏览量
页面/会话
出口
%出口
平均。页面上的时间

示例查询

* [## 页面跟踪:维度和度量(UA)

此示例查询包含以下所有 Google Analytics 页面跟踪维度和指标。如果你只需要一个…

www.ga4bigquery.com](https://www.ga4bigquery.com/page-tracking-dimensions-metrics-ua/)

返回目录*

事件跟踪

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。

事件跟踪维度

事件类别
事件动作
事件标签

事件跟踪指标

总事件数
唯一事件数
事件值
平均值。值
带事件的会话
事件/带事件的会话

示例查询

* [## 事件跟踪:维度和指标(UA)

此示例查询包含以下所有 Google Analytics 事件跟踪维度和指标。如果你只需要一个…

www.ga4bigquery.com](https://www.ga4bigquery.com/event-tracking-dimensions-metrics-ua/)

返回目录*

目标转换

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或指标，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。

目标转换维度

目标完成位置
目标上一步-1
目标上一步-2
目标上一步-3

目标转化指标

目标 XX 完成情况

示例查询

* [## 目标转换:维度和指标(UA)

此示例查询包含以下所有 Google Analytics 目标转换维度和指标。如果你只需要…

www.ga4bigquery.com](https://www.ga4bigquery.com/goal-conversions-dimensions-metrics-ua/)

返回目录*

(增强型)电子商务(交易)

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。

(增强的)电子商务维度

交易 ID

(增强的)电子商务指标

交易
电子商务转换率
收入
平均。订单价值
每会话价值
运费
税
每用户收入
每用户交易

示例查询

* [## (增强)电子商务交易:维度和指标(UA)

此示例查询包含以下所有谷歌分析电子商务交易的维度和指标。如果你只是…

www.ga4bigquery.com](https://www.ga4bigquery.com/enhanced-ecommerce-transactions-dimensions-metrics-ua/)

返回目录*

电子商务(产品)

当输入产品范围时，您必须验证增强型电子商务是否在谷歌分析中启用。如果是这样，您可以安全地使用 hits.product 字段。如果只测量“标准”电子商务:使用 hits.item 字段。

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的-- comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。

电子商务维度

产品 SKU
产品
产品类别

电子商务指标

数量
唯一采购
平均。价格
产品收入
平均。数量

示例查询

* [## 电子商务产品:维度和指标(UA)

当进入产品范围时，您必须验证谷歌分析中是否启用了增强型电子商务。如果是这样，你就…

www.ga4bigquery.com](https://www.ga4bigquery.com/ecommerce-products-dimensions-metrics-ua/)

返回目录*

增强型电子商务(产品)

当进入产品范围时，您必须验证谷歌分析中是否启用了增强型电子商务。如果是这样，您可以安全地使用 hits.product 字段。如果只测量了“标准”电子商务:使用 hits.item 字段。

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或指标，查看示例查询中的-- comments,并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY中)。

增强的电子商务维度

产品 SKU
产品
产品类别(增强型电子商务)
产品品牌
产品变型

增强的电子商务指标

数量
唯一购买量
产品收入
平均值。价格
平均值。数量
购买到明细比率
购物车到明细比率
产品添加到购物车
产品结账
产品明细视图
产品退款
产品从购物车中移除
退款金额

示例查询

* [## 增强型电子商务产品:维度和指标(UA)

当进入产品范围时，您必须验证谷歌分析中是否启用了增强型电子商务。如果是这样，你就…

www.ga4bigquery.com](https://www.ga4bigquery.com/enhanced-ecommerce-products-dimensions-metrics-ua/)

返回目录*

自定义维度和自定义指标

该示例查询包含以下所有 Google Analytics 维度和指标。如果您只需要一个维度或度量，查看示例查询中的# comments，并从SELECT子句中复制您需要的部分。确保您还添加了正确计算结果所需的任何附加条件(在FROM、WHERE、GROUP BY和ORDER BY)。

自定义维度

自定义维度 XX(用户)
自定义维度 XX(会话)
自定义维度 XX(点击)
自定义维度 XX(产品)

自定义指标

【自定义指标 XX 值(命中)】T23【自定义指标 XX 值(产品)

示例查询

* [## 自定义维度和指标(UA)

此示例查询包含以下所有 Google Analytics 自定义维度和指标。如果你只需要一个…

www.ga4bigquery.com](https://www.ga4bigquery.com/custom-dimensions-metrics-ua/)

返回目录*

自定义频道分组

如果需要默认通道分组，只需使用通道分组尺寸即可。但是，建立自己的频道分组可能有各种原因。例如，当您使用当天数据时，因为通道分组维度不可用。或者当您需要“修复”历史数据的数据质量问题时，因为这对于 Google Analytics UI 中的默认频道分组维度是不可能的。

我将向您展示如何镜像 BigQuery 中默认频道分组的标准 Google Analytics 定义。如果您使用这个查询作为起点，那么创建您自己的定制或默认频道分组就不再那么困难了。

示例查询

* [## 教程:如何创建自己的自定义频道分组(UA)

如果需要默认的渠道分组，就使用渠道分组维度。然而，可以有各种…

www.ga4bigquery.com](https://www.ga4bigquery.com/tutorial-how-to-create-your-own-custom-channel-grouping/)

返回目录*

当天表格

对于每个导出到 BigQuery 的 Google Analytics 视图，一个ga_sessions_intraday_表也将在一天内被导出多次。让我们看看这是如何工作的:

在每个数据集中，为每天的导出导入一个表。每日表格的格式为“ga_sessions_YYYYMMDD”。

日内数据大约每天导入三次。日内表格的格式为“ga_sessions_intraday_YYYYMMDD”。在同一天，当天数据的每次导入都会覆盖同一表中的前一次导入。

每日导入完成后，前一天的日内表将被删除。对于当天，直到第一次日内导入，没有日内表。如果日内表写入失败，则保留前一天的日内表。

在每日导入完成之前，当天的数据不是最终数据。您可能会注意到日内和每日数据之间的差异，这是基于跨越上次日内导入时间界限的活动用户会话。(来源)

在查询中包含当天数据和历史数据的最简单方法是将通配符与更宽的_table_suffix过滤器结合使用。在这个条件下，它将包括数据集中任何以ga_sessions_开始并包含格式为YYYYMMDD的日期的表。

注意:确保你的数据集不包含任何标题以 ga_sessions_ 开头的表格！

示例查询

* [## 如何查询日内表(并将其与日历表结合)- UA

对于每个导出到 BigQuery 的 Google Analytics 视图，ga_sessions_intraday_ table 将被导出多个…

www.ga4bigquery.com](https://www.ga4bigquery.com/how-to-query-an-intraday-table-and-combine-it-with-daily-tables-ua/)

返回目录*

实时表格和视图

如果您没有看到当天的表格，而是看到实时表格和视图，则您的 Google Analytics 视图启用了流导出。要查询这些数据并将其与来自ga_sessions_表的历史数据相结合，需要另一种方法。

每天,“流式导出”创建 1 个新表和该表的 1 个(BigQuery)视图:

table:ga _ real time _ sessions _ YYYYMMDD 是一个内部的 staging 表，它包括一天中发生的所有活动的所有会话记录。大约每 15 分钟连续导出一次数据。当会话跨越多个导出操作时，此表中包含会话的多条记录。

ga_realtime_sessions_YYYYMMDD 表不应用于查询(并且不受 Google Analytics 技术支持的支持)。对这些表的查询可能会产生意外的结果，因为它们可能包含某些会话的重复记录。请改为查询 ga _ real time _ sessions _ view _ YYYYMMDD 视图。

view:ga _ real time _ sessions _ view _ YYYYMMDD 位于导出的表的顶部，用于对跨导出边界存在的重复会话的多个记录进行重复数据删除。在此表中查询已消除重复的流数据。(来源)

在撰写本文时，这个每日生成的实时视图只能用遗留 SQL 查询。任何标准的 SQL 查询都会导致以下错误:

为了能够使用标准 SQL，我们必须创建自己的实时视图。

示例查询

* [## 如何查询实时表和视图(并将其与每日表相结合)

如果您没有看到当天的表格，但看到了实时表格和视图，您的 Google Analytics 已启用流导出…

www.ga4bigquery.com](https://www.ga4bigquery.com/how-to-query-realtime-tables-and-views-and-combine-it-with-daily-tables-ua/)

返回目录*

引入流式商业智能

原文：https://towardsdatascience.com/how-to-query-the-future-a4a5e951d23e?source=collection_archive---------14-----------------------

New capabilities in business intelligence help anticipate what lies ahead

一种新形式的自助服务分析有助于业务用户了解运营情况

十多年来，商业智能在观点上一直没有突破。

Tableau、QlikView 和 PowerBI 等自助式商业智能工具有助于人们更轻松地理解他们的数据。但是那些工具只分析已经发生的事情。分析历史数据假设过去观察到的模式、异常和机制将在未来发生。

现在，商业智能正在发生变化。通过结合流分析和自助式可视化探索，业务分析师可以询问和回答有关未来的问题。就像《少数派报告》中的预防犯罪部门一样，这种新型的商业智能可以帮助商业分析师预测未来的情况，实时检测它们，并在为时过晚之前采取行动。

The snapshot images that proved that horses do leave the ground, and sparked the invention of the motion picture camera.

导致电影诞生的赌注

流式 BI 的创建类似于 19 世纪后期电影的发明。

1872 年，利兰·斯坦福雇佣摄影师爱德华·迈布里奇帮助他解决一个赌局，即马匹在奔跑时离开地面。这花了几年时间，但迈布里奇完善了一种方法，从多台相机拍摄一系列快照，这些快照被马折断的细线绊倒。

他的快照揭示了人眼看不到的东西:马奔跑时离开地面。幻灯片二和三展示了这一事实的快照。斯坦福赢了他的赌注。

但更重要的是，迈布里奇的技术捕捉到了运动感。受他的工作影响，第一部电影摄影机于 1892 年问世。

像 19 世纪 80 年代的相机一样，现有的 BI 工具也是为快照而构建的。它们显示已经发生的事情，就像一张静止的照片。就像斯坦福的赌注一样，对华尔街的押注开启了一种思考商业智能的新方式。

流式商业智能的诞生

五年前，“闪电崩盘”在华尔街非常普遍。当交易算法对新闻事件等刺激反应过度时，就会发生闪电崩盘。例如，2012 年，一家公司在 45 分钟内损失了 4 . 4 亿美元。

银行需要一种新的方法来检测和阻止闪电崩盘。正如一位交易主管所说—

“我需要一个实时的数据仓库，在那里我可以询问数百个关于未来的问题，并在这些情况即将发生时得到实时通知，以便我可以在为时已晚之前采取行动。”—电子交易副总裁

这个请求就像斯坦福大学的赌注，但对于商业智能和数据仓库。来自麻省理工学院和剑桥大学的技术专家着手回答华尔街的“询问未来”挑战。

解决方案是连续查询处理(CQP)，这是一种结合了流分析和基于推送的查询模型的技术。CQP 允许商业智能用户向数据流中注入问题。对数据流中的每一个数据更改都评估查询。当查询的结果集发生变化时，BI 可视化会自动更新。或者，如果用户没有盯着屏幕，就会发出警报，提醒他们注意当前的情况。

流式 BI 就像一个可查询的业务数据监控摄像头。它有助于用算法增强人类的智能。

流动商业智能在行动

让我们来看看 BI 流的一天。下面的短片展示了 BI 分析来自一级方程式赛车中嵌入的传感器的物联网数据流。

业务分析师可以通过要求系统连续绘制汽车的位置来实时监控汽车的位置。这里显示了对油门、转速和制动压力的实时分析，但也可以考虑数百个因素。流动 BI 揭示了静态快照永远无法展示的东西:运动、方向、关系、动量。

Streaming BI at work: Query the future.

但是流式 BI 如何查询未来？

在这个例子中，用户为汽车的位置创建了一个地图。BI 工具记录这种连续查询:

从物联网流中选择连续*[位置、转速、油门、刹车]

CQP 记录这个问题并评估数据流上的每一个滴答。车动了，数据就变了，地图也变了。你只要设置好，然后忘记它。计算会改变。关系会变。视觉元素会改变。

这是未来查询的最简单的例子:“当汽车移动时，告诉我它在哪里。”但是可以登记成千上万的这种连续的问题:告诉我司机什么时候走了一条次优的路径进入发夹弯；告诉我轮胎磨损何时降低；告诉我天气预报什么时候变化。

与传统商务智能一样，流式商务智能也是自助服务。因此，查询未来就像查询 Excel 电子表格一样简单:您只需打开一个到流数据的连接，创建一些图表，然后进行探索。

AI can’t apply human judgment and reason. Image from the University of Wyoming.

流式商业智能通过算法意识增强了人类的判断能力

在下注思考中，世界扑克锦标赛冠军安妮·杜克解释了计算机和人类为什么是不同种类的决策。当需要上下文、判断和直觉时，人类表现出色。算法更擅长关联海量数据。

例如，算法通常会将顶部涂有鲜奶油的乌龟图像误认为卡布奇诺，正如加里·马库斯在重启人工智能:建立我们可以信任的人工智能中所描述的那样。自己看看算法是如何猜测上图中的 40 张图片的。

另一方面，人类无法关联海量数据。如果我在一分钟内向你闪现一百万个图像，你就没用了。但是电脑可以做出很好的猜测。

流式 BI 平衡了这些决策优势:来自计算机的算法洞察力和来自上下文的人类判断。

连续查询不仅仅针对原始数据；您可以将算法注入到查询中。例如，“告诉我我的车什么时候可以通过”检测一个算法条件:“可以通过”可以是，例如，用 r 编写的预测模型。

方法的另一个变化是流式 BI 的用户体验是基于推送的，而不是基于请求-响应的。CQP 不断评估流数据；当查询结果改变时，新的信息被推到可视化。或者，分析师可以通过文本消息、电子邮件或警报请求获得特别重要查询的提醒。基于推送的 BI 使分析比以往任何时候都更具沉浸感。

通过这种方式，流式 BI 平衡了人类的理解和算法洞察力。

改变你的想法

对未来的质疑是如此新鲜，以至于我经常被问到，“我该拿它做什么？”以下是如何思考它帮助解决的问题。

首先，想想你拥有的经常变化的数据:销售线索、交易、联网汽车、移动应用、可穿戴设备、社交媒体更新、客户电话、机器人、信息亭、社交媒体活动、网站、客户订单、聊天消息、供应链更新、文件交换。

接下来，想想以“告诉我什么时候”开头的问题这些问题可以包含数学、规则，甚至是用 Python 编写的数据科学模型，每天可以被回答数百万或数十亿次。

流式商业智能问题以“告诉我什么时候”开始

这些问题是在你不看的时候回答的。串流 BI 会通知你问题已回答；你不必坐以待毙。去喝咖啡吧。

流 BI 问题是关于未来的问题:告诉我 当一个高价值客户走进我的店。告诉我什么时候一件设备出现故障迹象。告诉我 当一架载有高优先级乘客的飞机即将着陆时，乘客可能会错过转机。

流式商务智能就像一个算法监控摄像头

流式 BI 就像是数字业务的算法感知监控摄像头。这里有一些公司已经使用它的例子。

罗马和墨尔本的机场从预订、登记、安全摄像头、自动驾驶汽车、飞机和维护设备中获取流数据。他们的分析师可以问:告诉我一架没有登机口的飞机什么时候着陆；告诉我什么时候有一个行李被卡住了，威尔可能会错过航班，或者告诉我们什么时候在任何安检线等待超过 5 分钟。这种算法意识有助于机场运营人员在问题失控之前做出反应并解决问题。

这些算法有助于判断问题的紧迫性，因此人类可以决定该做什么。

流 BI 有助于将信息针从流干草堆中分离出来。

银行风险管理人员可以监控交易、订单、市场数据、客户活动、账户活动和风险指标，以发现可疑交易。算法可以根据风险评估算法，人类可以判断那个风险是否可以接受。

供应链、物流和运输公司可以实时分析数以千计的互联车辆、集装箱和人员。串流商务智能通过识别最具影响力的路线问题，帮助分析师优化交付。

智能城市分析师可以监控紧急车辆的 GPS 数据流、交通数据和警方报告数据，以帮助他们对紧急情况做出快速反应。

像 Anadarko 这样的能源公司监控物联网工业设备以避免石油生产问题发生，并预测何时对设备进行维护。康菲石油公司说这些系统可以导致“数十亿美元”的节约。

华尔街的闪电崩盘呢？它们不再经常发生了。

快照不会死。它们只是旧闻了

快照 BI 没有死。像静态照片一样，它们对于报告、预测和月度报表来说仍然是必不可少的。但是，流式商业智能可以将你的观点转移到未来，并在算法洞察力和人类判断之间取得平衡。

每一份移动数据都成为改变业务方式的机会。与其等待环境来控制你，不如你自己掌握控制权。你预料到了。你表演。

流式商业智能是数字商业 BI 的未来，未来就在眼前。

了解更多

更多，请查看这个 3 分钟 如何查询未来中序列 。有关如何在流式 BI 中应用数据科学模型的更多信息，请阅读 为什么您应该了解流式数据科学 。

关于作者

马克·帕尔默是 TIBCO software 公司分析部的 SVP。作为 StreamBase 的 CEO，他被《时代》杂志评为将改变你生活的 科技先锋之一 。

图片署名为头条文章: 杰西布瑟 上un splash。谢谢大家！

如何快速比较数据集

原文：https://towardsdatascience.com/how-to-quickly-compare-data-sets-76a694f6868a?source=collection_archive---------5-----------------------

如何快速总结两个数据集之间的差异

Photo by Joshua Sortino on Unsplash

时不时地，你会需要比较两个数据集；要么证明没有区别，要么强调它们之间的确切区别。根据数据的大小，您可能有许多选择。

在我的上一篇文章中，*用 Python 比较数据的 3 种快速方法，*我们讨论了许多比较数据的方法。然而，我们讨论的选项都不能给你一个快速、详细的摘要，或者让你适应数据集之间的微小差异。

[## 在 Python 中比较数据的 3 种快速方法

对于任何从事分析工作的人来说，收到比较数据的请求都太熟悉了。不管那是…

medium.com](https://medium.com/financeexplained/3-quick-ways-to-compare-data-in-python-65201be10b6)

在这篇文章中，我想给你提供另一种选择；我相信这将会非常有帮助。这一次，我想让您注意 DataComPy python 库。

什么是 DataComPy 库？

正如他们的 GitHub 页面上所强调的，DataComPy 库是一个用来比较两个熊猫数据帧并提供描述差异的人类可读输出的包。

示例输出如下所示:

DataComPy Comparison
--------------------DataFrame Summary
-----------------DataFrame  Columns   Rows
0  Original       18  36634
1       New       18  36634Column Summary
--------------Number of columns in common: 18
Number of columns in Original but not in New: 0
Number of columns in New but not in Original: 0Row Summary
-----------Matched on: policyid
Any duplicates on match values: No
Absolute Tolerance: 0
Relative Tolerance: 0
Number of rows in common: 36,634
Number of rows in Original but not in New: 0
Number of rows in New but not in Original: 0Number of rows with some compared columns unequal: 2
Number of rows with all compared columns equal: 36,632Column Comparison
-----------------Number of columns compared with some values unequal: 2
Number of columns compared with all values equal: 16
Total number of values which compare unequal: 2Columns with Unequal Values or Types
------------------------------------Column Original dtype New dtype  # Unequal   Max Diff  # Null Diff
0  eq_site_limit        float64   float64          1  190601.40            0
1  hu_site_limit        float64   float64          1   79375.76            0Sample Rows with Unequal Values
-------------------------------policyid  eq_site_limit (Original)  eq_site_limit (New)
2    206893                  190724.4                123.0policyid  hu_site_limit (Original)  hu_site_limit (New)
3    333743                  79520.76                145.0

Photo by Franki Chamaki on Unsplash

它是如何工作的？

DataCompPy 要求您提供一列(可以只有一列)作为连接的键。您还可以设置它，使它基于索引工作。如果库在连接键上检测到重复项，那么它将对剩余的字段进行排序，并根据该行号进行连接。

算出例子

让我们探索一些用例，并确保我们知道如何将其付诸实践。我们需要做的第一件事是安装库。打开命令行窗口，键入以下内容:

pip install datacompy

然后，我们可以继续在 Python 脚本中导入库。在示例中，我将使用一些本地样本数据集:

import datacompy, pandas as pddf1 = pd.read_csv('FL_insurance_sample.csv')df2 = pd.read_csv('FL_insurance_sample - Copy.csv')print(df1.head(10))

返回:

如何使用 DataComPy

要使用该库，您只需要以下脚本框架:

import datacompyimport pandas as pddf1 = pd.read_csv('FL_insurance_sample.csv')df2 = pd.read_csv('FL_insurance_sample - Copy.csv')compare = datacompy.Compare(df1,df2,join_columns='policyID',  #You can also specify a list of columns eg ['policyID','statecode']abs_tol=0, #Optional, defaults to 0rel_tol=0, #Optional, defaults to 0df1_name='Original', #Optional, defaults to 'df1'df2_name='New' #Optional, defaults to 'df2')print(compare.report())

要根据您的喜好调整上面的脚本，您需要注意以下几点:

• abs_tol 和 rel_tol 分别代表绝对公差和相对公差。它们允许您指定数值之间的偏差公差。
• 您可以将 join_columns 替换为 on_index=True 来连接索引。
• 如果你想要两个数据集之间的交集，你可以使用compare . intersect _ columns()

查看 他们的文档 以了解特性的全部细节。

我希望你觉得这是有用的。

如果您觉得这篇文章有用，您可能还会对以下内容感兴趣:

[## 如何比较大文件

了解如何使用 Python 比较大文件

towardsdatascience.com](/how-to-compare-large-files-f58982eccd3a) [## 构建用于比较数据的 Python UI

如何快速让您的非技术团队能够比较数据

towardsdatascience.com](/building-a-python-ui-for-comparing-data-13c10693d9e4) [## 在 Python 中比较数据的 3 种快速方法

对于任何从事分析工作的人来说，收到比较数据的请求都太熟悉了。不管那是…

medium.com](https://medium.com/financeexplained/3-quick-ways-to-compare-data-in-python-65201be10b6)

拆箱为什么和如何阅读一篇研究文章？

原文：https://towardsdatascience.com/how-to-read-a-research-paper-c13b3f109b7f?source=collection_archive---------13-----------------------

Source of Image: https://libparlor.com/2017/09/27/research-101-qualitative-research-approaches/

世界上有这么多有趣的研究领域，我相信我们每个人在一生中的某个时候都曾设想过创造出一些至今无人想到的东西。如此渴望向世界展示我们有勇气做一些不平凡的事情。但是当你开始的时候，你会意识到世界是多么的广阔，世界上有那么多的人为了解决一个问题或者发明一个令人惊奇的东西而想出那么多巧妙的主意。

就在这一刻，我们意识到，为了推进我们的研究思路，我们需要了解人们以前做过什么。我们中的许多人选择这样做是为了从其他想法中获得灵感，而其他人这样做是为了确保他们不会花费几周、几个月甚至几年的时间来做世界上其他地方的其他人已经做过的事情。因此，在围绕我们的问题范式探索研究世界的旅程中，我们会遇到研究论文。

这些研究论文通常充满了技术术语和数学方程式，足以吓到任何人。特别对于一个人来说，刚入门，好像特别恐怖。我当然不是能告诉你阅读技术研究论文或出版物的最佳方法的专家，但我肯定能与你分享我通常是如何在 30 分钟或更短时间内不仅阅读而且理解一篇论文的。

相信我，当我第一次看报纸的时候，我也很害怕。我看着论文，甚至还没看一页，就开始觉得我需要学习这么多东西，才能开始领会论文的内容。相信我！每个人都会这样！觉得自己知道的还不够是正常的。事实上，正是在这一点上，我们开始意识到我们还需要学习多少，这很重要，因为世界上没有人知道一切。所以你至少可以继续努力。

总的来说，在你直接阅读任何研究出版物之前，如果你是初学者，我建议你试着掌握你感兴趣的领域的基础知识。例如，如果您选择的问题陈述是在自然语言处理(NLP)领域，那么您应该考虑了解如何解释自然语言并将其可视化，如何使用不同的模型和框架处理自然语言，以及 NLP 中使用的最流行的算法是什么。当你对基础知识有了足够的了解后，就可以开始阅读你想阅读的研究论文了。

一篇研究论文通常分为以下几个部分。

研究论文部分:

1.摘要

2.介绍

3.相关著作

4.主要部分(通常分为子部分，如详细描述想法、采取的方法等)

5.实验/实验装置

6.结果

7.结论

8.确认

9.参考

请注意，这是一般研究论文的结构，根据研究领域和作者偏好的写作风格可能会略有不同。

在我们详细了解每一节之前，我先跟大家分享一下我的策略。

我使用的一个简单的技术是打印出这张纸。对于那些喜欢在笔记本电脑、iPad 或平板电脑上阅读的科技达人来说，这听起来可能很烦人。请原谅我。我保证有效！随身携带一支铅笔和荧光笔。两者都很重要。我来解释一下原因。用铅笔在空白处或边上对你读到的任何部分做简短的笔记。使用荧光笔，突出你认为重要的区域。这听起来可能很幼稚，但是相信我，它对你的注意力有神奇的效果。诀窍是用你自己的话每隔一两段写下你所理解的内容。这不仅有助于你记住文章的内容，也有助于你让自己保持在正确的轨道上，专注于阅读文章。

**招数一:**打印出纸张。用铅笔对你正在阅读的任何部分做简短的笔记，并用荧光笔突出重点。

另一点要记住的是，不要被看起来疯狂的数学方程式吓到。请记住，论文的作者也曾和你一样是初学者，他们确实希望别人理解他们的工作。所以请放心，他们确实解释了那些看起来疯狂的方程的意思。耐心点。另一件要记住的事情是，不要把方程看成一个整体，而要先理解方程中的单个元素。这有助于你更快地理解整体思想。毕竟，成功的一个秘诀是坚持不懈，直到你到达你想到达的地方。

**诀窍二:**不要害怕看起来疯狂的数学方程式。不要把方程看成一个整体，先试着理解方程中的单个元素。这有助于你更快地理解整体思想。

让我试着详细说明每一部分代表什么，以及如何最大化你的理解。

在你开始阅读一篇研究论文之前，第一步是阅读摘要。摘要通常简短扼要，是论文中整个工作的总结。如果你理解了摘要想要表达的意思，那么你就能更好地理解文章。如果你没有完全理解抽象，那么不要灰心。随着论文的展开，你会明白它的意思。

摘要:简短扼要地总结论文中提出的全部工作。

接下来是介绍。引言通常是论文的一部分，它介绍论文背后的总体思想，但不涉及太多的细节。例如，引言可以包括简要解释为什么论文讨论的研究领域是相关的，以及论文展示的工作如何是解决该领域问题的好方法。像阅读一部戏剧或一本书的介绍那样阅读介绍。这是为了引起你的兴趣，让你对论文中讨论的观点感到好奇。

简介:介绍论文背后的总体思路，但不涉及太多实施细节。

我们关注的下一部分是与相关的工作。本节提到了为解决同一问题而做的其他相关工作，这些工作值得一提，并强调了它们的优点和缺点。由于两个原因，这一部分对你来说特别重要。第一个原因是，阅读这一部分有助于你了解人们提出了哪些其他方法来解决你的目标问题或类似的相关问题。这有助于你找到一个起点，开始看你感兴趣的论文。转到参考文献部分，使用引用号识别论文并阅读它！你读得越多，你就会越有见识。需要注意的一点是，不要把论文作者所说的一切都当成真理。请记住，论文中未提及的任何内容都是作者自己的观点，众所周知，每个人都有权以不同的方式看待事物。所以在形成你的观点之前，你必须阅读一篇论文。阅读这一部分的第二个原因是因为这有助于你理解作者的方法如何从其他竞争方法中脱颖而出。明智的做法是知道外面还有什么，以及它们和你正在阅读的报纸之间的区别。简而言之，相关工作提供了一系列研究文章，增加了我们在研究中的呼吸，可以帮助我们更好地制定和概念化我们的问题。

相关工作:谈论全球其他研究相同或相似问题的研究者的想法和方法。

你通常会遇到的下一个部分是这篇论文的关键。主要部分通常被细分为更小的子部分，每个子部分解释作者正在呈现的一个概念、元素或组件。它还包括问题公式。这一节对于理解本文的观点至关重要。不要忘记在你阅读的段落旁边的空白处做笔记。每隔几段，停下来，试着问自己这是关于什么的，你学到了什么。然后把它写在空白处。这有多重好处。一个显而易见的好处是，无论何时你再次打开这份文件，你都不必再通读一遍。你可以在一边读你的解释，然后就完事了。另一个好处是，与只读一遍的内容相比，你更容易记住自己手写的内容。它增加你的记忆能力。

主要部分:通常被细分为更小的子部分，每个子部分解释作者正在展示的一个概念、元素或组成部分。

在这部分之后是实验设置或实验部分。这一部分通常解释关于论文的实现细节，包括关于作者如何划分他们的训练、验证和测试集(在机器学习、视觉、NLP、相关论文的情况下)的细节，以及他们进行了哪些实验来展示他们的想法是惊人的。这些实验包括针对预期研究领域中的基准数据集和基线进行测试。这一节让你深入了解如何计划你自己的实验，以及有哪些基线模型可供你测试。

实验设置或实验:解释关于论文的实现细节，包括数据集、评估指标和针对已知基准模型和数据集进行的实验。

下一节是结果。本节使用与研究领域相关的不同评估指标，强调论文中提到的模型、网络或想法的性能和效率。这一部分可用于确定一个想法对您来说有多好，您可以使用本文的研究结果或从他们的想法中获得灵感来帮助构建您自己的模型。

**结果:**强调论文中提到的模型、网络或想法的性能和效率。

标题为结论的部分给出了论文中提出的想法的最终更精确的总结，以及它与其他模型相比的表现。它有时也提到未来的研究范围。这有助于你巩固对论文的理解，并对照作者的结论再次检查你得出的结论。

结论:给出最终更精确的总结，以及预期研究领域的未来工作范围。

确认是可选部分。在这一部分，作者通常感谢在他们的工作过程中帮助他们的机构或赞助商，以及使他们的工作得以完成的任何资助细节。如果你的目的只是阅读研究论文中提到的观点，你可以跳过这一部分。

致谢 : 包含了帮助他们的工作取得成功的赞助商的详细信息(包括行业和学术资助)。

最后但同样重要的是*参考文献或参考书目部分。*本节包含了整篇论文中以某种方式引用的所有研究论文或出版物的列表。这一部分可以作为一个起点来寻找你感兴趣的领域的类似论文。

参考文献或参考书目: C 包含本文引用的所有出版物的列表。

一旦你读完整篇论文，我建议你用自己的话写一个简短的总结，介绍这篇论文的内容和它引入了什么新事物。你也可以写一两行关于你在报纸上发现的有趣的东西，甚至是你在阅读报纸时大脑中闪现的新想法，你可以在以后继续。这不仅有助于我们在以后的时间里更快地将论文作为一个整体保留下来，而且还能确保那些我们一时兴起并随后忘记的短暂的精彩想法不会在日复一日的单调乏味中丢失。

技巧 3: 用自己的话写一篇简短的总结，介绍这篇论文的内容以及它引入了什么新事物。

我希望这篇文章能帮助你有朝一日成为一名伟大的研究者！

如果你喜欢这篇文章，请在 medium 或 LinkedIn 上关注我，或者与你的朋友分享这篇文章！

感谢您的阅读！

永远不要放弃，总有一天世界会认识到你的潜力。这是成功的关键。坚持学习就好！

使用 PyTorch Lighting 简化和扩展您的 PyTorch 代码

原文：https://towardsdatascience.com/how-to-refactor-your-pytorch-code-to-get-these-42-benefits-of-pytorch-lighting-6fdd0dc97538?source=collection_archive---------13-----------------------

如果你没有听说过，现在有一个非常简单的方法可以使用 PyTorch，并免费获得非常先进的功能！

PyTorch Lightning 是 PyTorch 上的一个非常轻量级的包装器，它更像一个编码标准，而不是一个框架。如果您将 PyTorch 代码重构为 Lightning 格式，您将获得顶级研究团队的附加功能，而无需所有工作。这种格式可以让您摆脱大量的样板代码，并使其具有高度的可重复性。

酷吧。让我们从 PyTorch 库中获取快速风格转换教程，并将其转换为 Lightning 格式。

图像加载

首先，让我们定义一些工具来帮助我们操作图像

变压器

接下来，我们将定义变压器网络来处理输入(不是 BERT 使用的类型)。

VGG 网

接下来，我们定义我们想要用于特征提取的 VGG 网

培训代码

前面的文件是独立的文件，我们通常希望它们与我们的主训练脚本分开。这不是闪电的事情，只是一般的软件工程最佳实践。

在本节中，我们定义了大部分培训逻辑。每个项目都有不同的做法。在最乐观的情况下，所有代码都在一个单独的(很长的)文件中，其中包含了您需要训练的所有要素。在正常情况下，该代码分布在多个文件中，这使得无法看到该方法的高级视图。

这是 PyTorch 回购的版本。

根据存储库的说明，您可以运行这个文件，它应该可以工作。

Running instructions

然而，这远非最佳。例如，如果您想使用 16 位精度呢？还是在多个 GPU 上训练？还是多机？还是加梯度积累？还是加早停？还是 tensorboard 测井？或者，或者，或者……—你明白了。这段代码会迅速膨胀，变得非常复杂。

这就是 PyTorch 闪电出现的地方。

步骤 1:设计照明模块

为了开始重构，我们需要浏览冗长的主文件，提取出我们将添加到 LightningModule 中的真正重要的内容。

照明模块

我们创建了一个名为 FastStyleTransfer 的类，它将样式传输的主要成分包含在一个 lightning 模块中:

现在我们寻找闪电模块的主要成分:

1. 优化器，学习率调度程序
2. 培训、验证和测试数据
3. 训练循环中会发生什么
4. 验证循环中发生了什么
5. 模块执行什么计算(转发)

模型计算

首先，让我们找到这个模型的核心计算。这很难，因为这些总是分散在代码中，这使得核心科学贡献很难精确定位。

首先，看起来我们需要这个变压器:

看起来我们也需要这张 VGG 网:

看起来我们在这里也做了一些预训练循环缓存:

因为我没有读过这篇特别的论文，但是我熟悉风格转换，看起来他们在预先计算 gram_matrix。像这样的任何类型的缓存操作都是 init 函数的很好的候选，这个函数在 Lightning 中只被调用一次。

看起来这是核心的计算部分。在 lightning 中，我们将这些整合到一个功能中

注意一些事情:

1. 现在很清楚这篇论文的主要计算单位是什么了。
2. 我将一组超参数(hparams)传递给构造函数。这是可选的，但几乎是标准的做法。这通常是一个 Argparse 对象。
3. 注意我们去掉了对 GPU 的任何调用(例如:没有。todevice()或。cuda())…闪电会帮你处理的。

现在，如果你想理解这篇论文的代码，你可以看看 init，知道这篇论文需要一个 VGG 网，一个 gram_style 矩阵和一个 convnet(他们称之为 transformer)。记住，这不是 BERT 中使用的变压器网络。

训练循环

接下来我们看看计算是如何应用的。通常这是在内部循环中(所有的东西在批处理之后和之前。向后)

注意这段代码非常混乱。有大量调用将内存转移到 gpu(。到(设备))。有管理计数器(coung+= n_batch)等…

这是深度学习项目 80%的复杂性所在。让我们把这个移到我们的照明模块。

内部训练循环(上面黄色的东西)进入 training_step。training_step 实际上只是在黄色代码所在的位置被调用:

注意关于 training_loop 的一些事情:

1. 现在发生的事情非常清楚。对于快速风格转换，使用 convnet(变压器)对输入进行编码，归一化，通过 vgg 运行每个输入，然后计算一些损耗。
2. 没有提到 optimizer 或 zero_grad 或任何有关培训的内容。
3. 没有对的调用。cuda 或 gpu 内存管理。
4. forward 中的东西不需要在 forward 函数中。可以在 training_step。但是如果你想在产品中使用这个模型，或者在一个 API 后面，或者与其他 PyTorch 代码一起使用，你通常想把核心计算的东西放在前面。

这里要传达的信息是，要理解一篇论文在做什么，你所要做的就是看看 lightning 模块的 training_step！

优化器

我们需要做的最后一件事是告诉 Lightning 使用什么优化器。我们在第 47 行找到了优化器:

我们将把这个优化器添加到这个 lightning 模块函数中:

如果我们在训练更复杂的东西(比如 GAN)，我们可以在这里返回多个优化器。对于您返回的每个优化器，您还可以添加一个学习率调度器。

然而，这项工作只使用了一个优化器。

数据加载器

接下来，我们寻找培训、验证和测试数据加载器。如果他们不使用数据加载器，你必须转换他们的代码来使用数据加载器

幸运的是，我们找到了这个数据加载器代码。现在我们把它变成闪电。

Lightning 还允许您为验证和测试定义不同的数据加载器。这是同一个想法:

装饰器 data_loader 确保您的数据只被调用一次。但是，如果您需要重新加载每个纪元或做一些更深奥的事情，可以选择禁用它。

就是这样！现在我们有了完整的照明模块:

在底部，我们做了一个小小的添加。每个项目都有一组通常通过 ArgumentParser 传递的参数。然而，这些论点中有些是针对整个项目的，有些只适用于这个特定的 LightningModule。最好在 LightningModule 中耦合这些参数，这样就可以很容易地看到参数是从哪里传入的。

训练

就是这样！我们只是将所有需要的相关代码提取到一个 LightningModule 模块中。现在我们创建一个培训脚本，它将为我们运行培训。如果我们有其他项目或不同的风格转换方式，我们可以使用同一个教练来运行它们，只要它们是照明模块。

就是这样！教练将自动运行你的照明模块，并处理所有复杂的训练。有了上面这三行，你就获得了训练循环所需的一切:

1. 自动后退，步进
2. 自动验证检查
3. 自动张量板
4. 自动提前停止
5. 自动检查点
6. …大约 100 种其他免费的东西。

如果你想在几个图形处理器上运行？

如果您想要在 32 个节点上运行，每个节点有 8 个 GPU？

您可以使用这样的 SLURM 脚本提交这个任务:

这就是事情的全部。

展开性

但是等等，你会说…这对于你的用例来说太简单了？别担心，闪电是由我设计的(我的研究都是在 NYU 和费尔进行的)，对研究人员来说是尽可能灵活的。以下是一些例子:

需要自己的后传？覆盖此挂钩:

需要自己的放大器初始化吗？覆盖此挂钩:

想深入到添加自己的 DDP 实现吗？覆盖这两个挂钩:

像这样的钩子有 10 个，我们会根据研究人员的要求增加更多。

底线是，对于一个新用户来说，Lightning 使用起来很简单，如果你是一名从事前沿人工智能研究的研究人员或生产团队，它可以无限扩展。

项目健康

还记得那些你不必写的代码吗？闪电测试它和文件它超级适合你。此外，我们有超过 53 的贡献者——许多来自世界顶级人工智能实验室，每天都在添加新功能。

最后，我们有非常清晰的贡献者指南、核心价值观和极高的代码质量标准。我们使用持续集成进行测试，通常使用闪电标志的各种排列来训练完整的模型。

全部功能

Lighting 有超过 42 个功能，通过标志或挂钩实现，让您对研究/生产过程的每个部分进行无限控制。

今天试试闪电！

用人工智能制作烟鬼混音。

原文：https://towardsdatascience.com/how-to-remix-the-chainsmokers-with-a-music-bot-6b920359248c?source=collection_archive---------11-----------------------

这是“建造人工智能音乐发生器”系列的第四部分(也是最后一部分)。我们将使用我们的多任务音乐模型来混音一首 EDM 歌曲。它将专注于音乐制作，仅用于娱乐目的。

以防你错过: 第一部 ， 第二部 ， 第三部 。

在本帖中，我们将重新混音排行榜冠军歌曲——烟鬼乐队的《玫瑰》。首先，我们将使用 Ableton 和 HookTheory 重新创建合唱。然后，我们将使用我们的 MusicTransformer 模型来生成新的旋律。

这是它听起来的一个小秘密:

背景

之前，我们向您展示了如何构建和训练音乐模型。结果很酷，但似乎缺少了些什么…

更多的生产！！！

大家都知道，想要你的歌有更大的冲击力，就需要层层叠叠的声音。

我不知道怎么做到的，但是烟鬼 做到了 。

所以让我们从他们的歌曲《玫瑰》的副歌部分借用一些声音。
如果你不知道，这里是 drop(又名合唱):

第一部分。在阿伯顿重建合唱团

我们的第一步是将歌曲分解成各个部分——乐器、音符、鼓和人声。这样我们就可以在混音时重复使用这些元素。

构建那个引导音

“烟鬼”在“玫瑰”上做了一个非常酷的大师课，他们解释了他们是如何创造出这些听起来很棒的合成器的。

事实证明，这些乐器中的很多都受到了 Sylenth 预设的极大启发。如果你不知道 Sylenth，它是一个虚拟合成器，带有许多开箱即用的优秀乐器(预设)。

以下是他们在合唱中的领唱:

我们所需要做的就是加载相同的预设，并修改与他们相同的参数。现在我们有了领先的合成器！

抄写这首歌

HookTheory 恰好有这首歌的确切音符和和弦。

让我们将 MIDI 导出并导入到 Ableton！

制作其他层

鼓:我用我所有的样本用耳朵重现了节拍。

人声:谢天谢地，人声样本可以在网上找到。烟鬼们举办了一场混音比赛，他们在比赛中发布了录音。

把这一切都投入到艾伯顿

以下是我们的盗版翻拍听起来像:

够好了。现在让我们重新混合一下。

第二部分。REEEE-MIX！！

是时候使用上一篇的多任务音乐模式了。

让我们把之前下载的原始 MIDI 音符作为我们模型混音的基础。

这是音乐机器人:

You can play the original song here.

现在我们都准备好开始生成了。

我将向你展示两种不同的混音方式，但这是从开始到结束的一般流程:

我们的第一次令牌屏蔽混音

为了创作我们的第一首混音，我们要预测歌曲的“音高”。换句话说，我们将删除一些音符(仅音高)，并让模型填充空白。

**输入:**音符音高被擦除/屏蔽。音符长度保持不变。

预测语境:概念上，模型知道原曲的节奏，但不知道听起来是什么样的(歌曲音高被屏蔽)。

**输出:**期望得到一首音符完全不同，但节奏相同的歌。

我们开始吧。

1. 将预测类型切换到“音高”。

2.按下那个神奇的按钮，我们就会得到:

Link to remix here

**Red/Blue** notes are the predictions. 
**Green/white-striped** notes are from the original melody

观察:

• 所有的音符都改变了音高，但保持相同的位置和持续时间。这正是我们所希望的。请记住，只有音符音高被抹掉。
• 序列最末端的蓝色音符完全没有遮盖。它有助于保持几个完整的笔记作为模型的指南。

3.保存预测输出，并将其拖到我们的 Ableton 项目中:

4.这是我们的创作！

大约需要 5 次尝试才能产生听起来合理的东西。你可以通过向下拨动右下角的“创造力”控制键来选择更高的稳定性。

创作新的旋律

重新混合“音高”产生了完全不同的声音和风格。这一次，我们将保留更多的原始特征，并保持和弦进行不变。

输入:歌曲的原和弦进行。旋律被完全抹去。

预测上下文:seq 2 seq 模型将使用和弦并将它们“翻译”成新的旋律。

**输出:**与原和弦配合良好的新旋律。

同样的步骤，不同的开关。

1. 切换“旋律”开关并按下红色按钮:

Link to remix here

**Red notes** are the predictions. 
**Blue notes** are the chords (used by the model to predict the melody). 
**Green/white-striped notes** are the original melody

2.将预测导入到 Ableton 中，我们可以得到:

嗯，还不错！

自己试试吧！

如果你拥有 Ableton，你可以在这里下载整个项目。

关于音乐一代人工智能的结束语

我想我们都同意这个人工智能远没有达到人类的水平。

我使用了链锯“drop ”,因为一只带键盘的猴子可以产生 MIDI 音符，用那些原始的合成器和人声听起来很棒。制作和编曲一首完整的歌曲更是一项艰巨的任务。

然而，人工智能在音乐中仍然有很多价值。虽然这种模式不会马上创造出惊人的成功……但更多地把它看作是制片人/作曲家激发新想法的另一种工具。

就像烟鬼们把 Sylenth 中的一个预设变成了一个令人敬畏的主音一样，我认为 MusicAutobot 也可以以同样的方式充当灵感启动器。

感谢你大老远跑来。

构建和分享这个个人项目对我来说是一大乐趣，我希望它对你来说也是一点娱乐。

我将很快发布另一个系列，介绍如何在网络上部署深度学习模型——使用 Flask、Vue 和 Github 页面。你可以在媒体上关注我来了解这方面的更新。

我也很乐意听到你的反馈或者关于你已经建立或创造的任何东西！在推特上联系我。

向了不起的人大声喊出来胡克理论让这一切成为可能耶鲁安给灵感

如何从数据表中删除%符号

原文：https://towardsdatascience.com/how-to-remove-sign-from-data-table-baa37598982a?source=collection_archive---------18-----------------------

将包含%符号的列从字符串转换为数字类型

Columns x5, x6, and x7 contain the % sign, and hence are treated as string type so they can’t be used for numerical calculations.

数据争论是将原始的非结构化数据转换为可用于进一步分析(如数据可视化或建模)的形式的过程。有时，在讨论完数据后，您可能会注意到一些列可能包含符号，如美元符号($)、加号(+)、减号(-)或百分号(%)。任何包含这些符号之一的数据列都被视为字符串类型，因此不能用于数值计算。

在本文中，我将展示如何从数据列中删除百分号(%)。然后，一旦%符号被删除，我们将把列从字符串转换为数字类型，使其适合数字操作和计算。可以使用类似的方法来删除不需要的符号，如加号(+)、减号(-)等。

我将用一个从 pdf 文件中提取的数据集来说明这个例子，如下所示:

Data table originally in a pdf file. Source of original file: http://www.ijastnet.com/.

a)将表格复制并粘贴到 Excel 中，并将文件保存为 table_1_raw.csv

数据以一维格式存储，必须进行整形、清理和转换。

b)导入必要的库

import pandas as pdimport numpy as np

c)导入原始数据并重塑数据

df = pd.read_csv("table_1_raw.csv", header=None)df2 = pd.DataFrame(df.values.reshape(25,10))column_names = df2[0:1].values[0]df3 = df2[1:]df3.columns = df2[0:1].values[0]df3.head()

d)使用字符串处理工具执行数据辩论

我们从上表中注意到，列 x5 、 x6 和 x7 是用百分比表示的，因此我们需要去掉百分比(%)符号:

df4['x5'] = list(map(lambda x: x[:-1], df4['x5'].values))df4['x6'] = list(map(lambda x: x[:-1], df4['x6'].values))df4['x7'] = list(map(lambda x: x[:-1], df4['x7'].values))

e)将数据转换成数字形式

我们注意到列 x5 、 x6 和 x7 的列值具有字符串数据类型(即使在删除了%符号之后)，因此我们需要将它们转换为数字数据，如下所示:

df4['x5'] = [float(x) for x in df4['x5'].values]df4['x6'] = [float(x) for x in df4['x6'].values]df4['x7'] = [float(x) for x in df4['x7'].values]

f)查看转换数据的最终形式

df4.head(n = 5)

g)将最终数据导出至 csv 文件

df4.to_csv('table_1_final.csv',index = False)

总之，我们已经展示了如何从数据列中删除百分号(%)，以及如何将该列转换为数字类型以使其适合数字计算。可以使用类似的方法来删除不需要的符号，如加号(+)、减号(-)等。

如何用海滩时间取代电脑时间——贝壳的魔力

原文：https://towardsdatascience.com/how-to-replace-computer-time-by-beach-time-the-magic-of-the-shell-dcb690ac5175?source=collection_archive---------34-----------------------

Beach in San Sebastian — Photo by Athena Lam on Unsplash

我编程越多，我就越懒。我只是不明白，为什么我应该做一些电脑自己能做得更好、更快、更可靠的事情。在我接近懒惰工作者的过程中，我发现 shell 脚本是一个很好的朋友和助手。虽然在过去，您可以经常使用 Windows(如果您愿意的话)，但在越来越多的计算在云中执行，服务器大多基于 Linux 的时代，在我看来，每个数据科学家和数据工程师都应该至少对 shell 脚本有一个基本的了解。(奖金:*看到我最喜欢的时间，当 shell 脚本实际上使我高兴的时候，在底部的附录。提示:它确实包含了大量的海滩时间。因为我相信，在内心深处，我们都想把时间花在做其他事情上，而不是手动移动文件，所以我想与您分享我对 shell 的个人基本知识的介绍。希望它能让你的生活变得轻松一点(如果你愿意的话，还能让你在海滩上多待些时间:)。

基础:移动和基本的文件操作

四处走动

如果你登录了，你可能想知道的第一件事是你在哪里(提示:你可能在你的主目录中)。您可以通过将当前工作目录打印到屏幕上来找到答案:

# print working directory
pwd

接下来，您应该通过键入以下命令列出它的内容

# list contents of current directory
ls

许多 bash 命令允许修饰符，即所谓的标志。它们主要由一个字母组成，在命令后面加上一个“-”。您可以通过一个接一个地写入多个标志来组合它们。有许多可能的标志。这里有一些例子

# include hidden files
ls -a# include hidden files and print more details 
ls -la# list only directory (without content)
ls -1d directoryname

要了解有关命令的更多信息，请使用手册(手册页):

# print manual for mycommand
man mycommand# for example:
man ls

为了四处移动，您使用cd(改变目录)命令:

# change to directory called mydirectory inside current directory
cd mydirectory# change to directory above
cd ..# move to directory which is also inside the directory above (basically a "parallel" directory)
cd ../mydirectory# change into previous work directory
cd -

高级移动

您可以使用pushd / popd在堆栈中添加/删除目录。一旦添加到堆栈中，您就可以在堆栈中的目录之间跳转。请注意，在构建您的堆栈时，您需要添加两次最终目录，因为最终位置总是会被覆盖(听起来比实际复杂，只要尝试一下，您就会明白我的意思)。

# add mydirectory to stack
pushd mydirectory# show directories in stack
dirs -v # delete top repository from stack
popd # change to directory numbered n (eg 2) in the stack
cd ~2

与文件和文件夹的基本交互

您可以通过以下方式创建一个简单的文本文件

# create a text file called mynewtextfile.txt
touch mynewtextfile.txt

文件由以下人员复制、移动或删除:

# copy file
cp oldfilename newfilename# move/rename file
mv oldfilename newfilename# delete file
rm oldfilename

为了创建(制作)新目录:

mkdir mynewdirectory

目录像文件一样被复制、移动和删除。然而，复制和删除需要-r(递归)标志:

# copy directory
cp -r folder_old folder_new# delete directory
rm –r folder_to_remove# rename directory (does not require -r flag)mv old_folder new_folder

与文件交互和将命令链接在一起——稍微不太基本

与文本文件交互

既然我们知道了如何移动文件，我们还想用它们做一些有用的事情。

有四个主要选项可以访问文本文件的内容。我建议尝试一下，看看它们能做什么，它们的行为有何不同。

# prints whole file to screen
cat mytextfile# prints file to screen one screenful at a time
more mytextfile# prints file to screen, allowing for backwards movement and returns to previous screen view after finishing
# note: less does not require the whole text to be read and therefore will start faster on large text files then more or text-editors
less mytextfile# use a text editor (for example nano or here vi)
vi mytextfile

关于编辑的选择:我个人是 Vim 的忠实粉丝。然而，我承认一开始它确实有一个陡峭的学习曲线。如果你想从对初学者更友好的东西开始，你可以看看 nano。然而，为了将来，请记住 VIM，一旦您熟悉自己的工作方式，文本处理的速度将会惊人。

还可以返回文档的前 n 行或后 n 行

# show first 10 rows of a document
head -10 mytextfile# show last 10 rows of a document
tail -10 mytextfile

使用grep在文档中查找文本

# look for the string python in mytextfile
grep python mytextfile# search case-insensitive
grep -i python mytextfile# return line-numbers with the results
grep -n python mytextfile# search for a filename ("mybadfilename" in the example) (case insensitive) in all files with the ending *.py and return the occurences together with the line number
grep -in mybadfilename *.py

在上一个例子中，我们已经看到了一个占位符的例子。*.py 表示所有以. py 结尾的文件。

重定向输出

一些命令打印到屏幕上。为了将输出重定向到一个文件，我们可以使用>和>>。>>将输出附加到现有文件，或者如果文件尚不存在，则创建一个新文件。相反，>总是创建一个新文件。如果同名文件已经存在，它将覆盖该文件。以下是如何将grep -in mybadfilename *.py命令的输出重定向到文件的示例:

# creates new file; if file exists, overwrites it
mycommand > mytextfile
# example:
grep -in mybadfilename *.py > myoutputfile# appends output to file; if myoutputfile does not exist yet, creates it
mycommand >> mytextfile
# exammple:
grep -in mybadfilename *.py >> myoutputfile

如果除了将输出重定向到文件，我们还想要将输出打印到屏幕上，我们可以使用| tee。注意，完整的命令需要出现在|之前。

# print output to screen plus re-direct it to file
mycommand | tee myoutputfile# example:
grep -in mybadfilename *.py | tee myoutputfile

在前面的示例中，我们已经看到了管道(|)命令的用法。它是如何工作的？|将输出重定向到通常“从右边”获取输入的函数，因此输入应该在函数调用之后。一个例子:如前所述，grep需要语法grep sth filename。但是，您可能有一个返回输出的程序，并且想要在这个输出中寻找一些东西。这就是|发挥作用的地方。例如，ps aux显示系统上运行的所有进程。您可能希望搜索包含特定字符串的进程，例如 launch_。你应该这样做:

# grep for the string launch_ in the output of ps aux
ps aux | grep launch_

变量和脚本

变量

Bash 是一种脚本语言，不是类型化的。使用=符号定义和分配变量。变量名、=符号和值之间不能有任何空格。您可以使用$后跟变量名来访问变量的内容。您可以使用echo打印到屏幕上。

# define string variable
my_string_variable="this_is_a_string"# define numeric variable
my_numeric_variable=3# print variable to screen
# (will print this_is_a_string to the screen)
echo $my_string_variable

变量通常用于定义路径和文件名。当变量在文本中被重新求解时，需要在变量名周围加上{}。例如，考虑刚刚创建的变量 my_string_variable。假设你想打印’ this_is_a_string_1 '。为了打印变量 my_string_variable 的内容，后跟 _1，请在变量名两边使用{}:

# incorrect (bash will think that the variable is called "my_string_variable_1"):
echo $my_string_variable_1# instead use:
echo ${my_string_variable}_1

在第二个例子中，bash 解析对 this_is_a_string 的引用，然后将 _1 追加到结果字符串中。

环

Bash 使用for ... do ... done语法进行循环。该示例显示了如何使用循环将文件 myfilename1 和 myfilename2 重命名为 myfilename1.bac 和 myfilename2.bac。请注意，列表元素之间没有逗号分隔。

rename files by appending a .bac to every filename
# no comma between list elements!
for myfilename in myfilename1 myfilename2
do
  mv $filename ${filename}.bac;
done

为了遍历整数列表，首先使用序列生成器生成一个列表:

for i in $(seq 1 3)
do
 echo $i
done

注意:$()打开一个子 shell，在这里解析()的内容。然后将结果返回到外壳。在上面的例子中，seq 1 3产生的序列 1 2 3 被传递回外壳，然后在外壳中循环。例如，这种行为可用于循环包含特定模式的文件:

for myfile in $(ls *somepattern*)
do
  cp myfile myfile.bac
done

编写和执行(非常)基本的脚本

要创建脚本，创建一个包含 bash 语法的文本文件，使其可执行并运行它。让我们看一个非常基本的(公认非常无用的)例子。创建包含以下内容的文件:

#!/bin/bash# print myfilename.txt
echo "Hello World!"exit 0

并将其保存为 print_hello_world.sh。注意文件的第一行，它告诉 shell 使用哪个解释器。您可以通过为所有者添加执行权限来使其可执行，并由。/scriptname:

# add execution rights for file myfirstbashscript.sh for the owner of the file
chmod u+x print_hello_world.sh# run 
./print_hello_world.sh

如果不是硬编码“Hello World！”，您希望用户将待问候的传递给脚本，您可以将它作为变量传递给脚本。让我们用以下内容创建一个新文件 print_hello_user.sh:

#!/bin/bash# print "Hello " + user-input 
echo "Hello " $1exit 0

如果我们给它执行权，像这样执行

./print_hello_user.sh "Universe"

它会将“Hello Universe”打印到屏幕上。为什么？“Universe”作为文件名作为名为 1 的变量传递给脚本后的第一个输入变量，然后通过 print 语句中的$1 命令引用它。

最后的提示和技巧

• 尽可能使用 tab 补全:要自动补全，请按“Tab”键。如果有多个选项，按“Tab”两次以显示所有选项。
• ESC + .将从上一行带回最后一个令牌。例子:cp file_a file_b；然后在下一行ESC + .会产生 file_b。
• 括号结束:你可以使用{}来缩短你的代码。例如，如果你想重命名一个文件，你可以输入mv myfilename{,.bac}。这作为mv myfilename myfilename.bac执行。对于交互式工作非常有用(虽然我不会在脚本中使用它)。
• tail -f myfilename : tail filename在执行点产生尾部。但是，您可能希望能够在编写输出脚本时跟踪它们。tail -f照常开始tail，但是当新的行出现在输出文件的末尾时，继续追加。
• watch -n somenumber command每隔几秒执行一次命令。例如，watch -n 2 ls每 2 秒运行一次 ls。观看文件传输非常棒。

结论

在这篇文章中，我们看了使用 shell 的基本介绍。我们已经看到了如何在 shell 环境中定位自己，如何四处移动以及一些与文件的基本交互。最后，我们已经创建并运行了我们的第一个脚本，并查看了一些我最喜欢的技巧。虽然这应该会给您一个好的开始，但这只是对 shell 脚本这个怪异而奇妙的世界的一个小小的介绍。如果你想了解更多，这里的是一个很好的、广泛的脚本备忘单，可能会对你有进一步的帮助。有关该主题的完整内容，请查看 Mendel Cooper 的对 shell 脚本艺术的深入探索。和往常一样， StackOverflow 也提供了大量的建议和帮助:)玩得开心！

*附录:Shell 脚本如何让我花更多时间在沙滩上

我在圣塞巴斯蒂安攻读博士学位，圣塞巴斯蒂安是巴斯克地区的首府，也是著名的“La Concha”海滩的所在地。我的论文非常注重计算，需要协调许多不同的技术。我仍然天真地记得设置我的计算机来自动生成大量用于计算的输入文件，将计算提交给超级计算中心，等待它们完成，从输出中提取相关数据，可视化结果，创建一个完整的网页层次结构，并将所有这些推送到网络服务器，这样来自世界各地的多人就可以协作查看结果。只需按一下按钮，它就能完全自动地完成所有这些工作，而且做得非常可靠，从未出错。而我呢？我正在海滩享受午餐:)

原载于https://walken ho . github . io。

如何用 TensorFlow-2.0 替换张量中的索引值

原文：https://towardsdatascience.com/how-to-replace-values-by-index-in-a-tensor-with-tensorflow-2-0-510994fe6c5f?source=collection_archive---------6-----------------------

NumPy 中一个看似简单的操作如何在一些不幸的情况下变成 TensorFlow 的噩梦

你有没有尝试过根据数组的索引只替换数组的某些值？

>>> import numpy as np
>>> a = np.array( [1,2,3,4,5] )
>>> print(a)[1 2 3 4 5]>>> i = [ 0, 1, 3 ]
>>> a[i] = -1
>>> print(a)[-1 -1  3 -1  5]

一个更复杂的用例可能是，例如，将某个阈值以上的所有值削波到最大值:

>>> import numpy as np
>>> a = np.array( [1,2,3,4,5] )
>>> print(a)[1 2 3 4 5]>>> a_max = 3
>>> i = np.where( a > a_max)
>>> a[i] = a_max
>>> print(a)[ 1  2  3  3  3]

事实证明，如果数组由一个张量表示，这种明显简单的操作在 TensorFlow 中是不允许的(但如果数组是一个 tf，这种操作是允许的。变量对象)。如果您尝试，最有可能的结果是这样的错误:

AttributeError: 'tensorflow.python.framework.ops.EagerTensor' object has no attribute 'assign'

事实上，我必须承认，我花了很长时间才想出如何解决这个经常出现的问题。在 StackOverflow 上有很多问题，人们在那里讨论同一个问题(例如，见这个)。我认为从 TensorFlow 操作的角度来看，最简单的方法是过滤希望将保留在一个向量中的元素，创建另一个向量，用希望替换的屏蔽值来“填充空白”(例如零、无穷大、一些其他默认值)，最后给出两者之和的结果。

我在这里给出一个例子来过滤一个向量的前 k 个元素，但是这个过程是非常通用的，包括以下步骤:

1. 确定要删除的索引。通常，它们由布尔值向量表示，如**【真、假、假、…、真】**
2. 将这个向量转换成包含实际索引的两个数组( idx_keep ， idx_replace )。这可以用很多方法来实现，但是我相信使用 tf.where 是最简洁的方法。
3. 用要替换的值创建一个向量。在这个例子中，新值将是 -inf ，复制 N 次，其中 N =要替换的元素的数量= len(idx_replace)
4. 用要保留的值创建一个向量。我通过使用函数 tf.gather( a，idx_keep ) 来完成这个任务，这个函数几乎相当于类似于 a[[0，1，3]] 的东西
5. 创建上面两个集合的稀疏向量。恼人的部分是稀疏向量的索引必须是 2D，即使只有一维。我做的方法是创建零向量，然后我把它们和索引向量“堆叠”在一起。
6. 将两个稀疏向量转换为密集向量，并将它们相加。
7. 返回结果。

下面是一个代码示例:

A graphical representation of the workflow

不可否认，至少对于一些特定的情况，比如上面描述的裁剪，存在一个基于三参数版本的tf.where的更快的解决方案:

result = tf.where(condition, x, y)

返回的张量包含条件为True的x元素和条件为False的y元素。因此，在我们的例子中，上述函数可以简化为:

a = tf.where(tf.less_equal(a, a_max), a, a_max)

或者更明确地说:

def top_k_filtering(logits, top_k=5):
   "Set values less than the k'th largest to -Inf."
   kth_largest = tf.math.top_k(logits, top_k)[0][-1]
   return tf.where(logits < kth_largest, -Inf, logits)

跟 TensorFlow 玩得开心！

如何在 fastai 中恢复中断的训练课程

原文：https://towardsdatascience.com/how-to-resume-an-interrupted-training-session-in-fastai-77c4f36cd3a1?source=collection_archive---------13-----------------------

如果使用 fit_one_cycle 的训练中途中断，该怎么办？

Courtesy of Gratisography@Pexels

如果您有一个庞大的数据集、一个庞大且训练缓慢的网络，并且您的训练会话在几个小时的训练后被中断，您会怎么做？发生这种情况的原因有很多:

• 因为你在谷歌 Colab 笔记本上达到了你的连续 12 小时“免费”操作时间；
• 您暂时失去了与 Colab 或 Kaggle 的联系；
• 因为你的电脑因为某种原因停了。我住在巴西，电力短缺是常事…

fast.ai 采用的 fit_one_cycle() 方法使用变化的、自适应的学习速率和动量，遵循速率先增加后减少的曲线，而动量则相反，如下图所示。

Cyclical learning rate and momentum variation in fit1cycle. Learning rate highlighting by Roger Mao.

如果您在第 10 个时段(比如说 20 个时段)中中断训练，然后再次开始 9 个时段以上的训练，**您将不会获得与不间断地训练 20 个时段相同的结果，**因为从头开始的新训练，即使您从上一个时段加载权重，也将采用新的学习速率和动量策略，并再次经历该循环。你想要的是从你在循环中被打断的地方开始。

Learning rate and momentum graphs for one fit1cycle training policy, divided into three consecutive training sessions. Image by PPW@GitHub

什么是 fit1cycle？

Fit1cycle 是 Leslie N. Smith 开发的超收敛策略。它被用作 fast.ai 中的标准培训策略。有关详细信息，请参见下文:

• https://docs.fast.ai/callbacks.one_cycle.html
• 神经网络超参数的训练方法:第 1 部分——学习速率、批量大小、动量和权重衰减—https://arxiv.org/abs/1803.09820
• 超级收敛:使用大学习率快速训练残差网络—https://arxiv.org/abs/1708.07120

如果你想看更多的论文，请点击这个链接:莱斯利·n·史密斯论文。我们不会在这个帖子中进入细节。媒体上有几篇帖子以简单易懂的方式介绍和讨论了第一轮训练政策:

• karan Bir Chahal 将训练神经网络的速度提高了 10 倍；
• Yogesh gur jar 内置正则化的超收敛；
• 超收敛:Aditya Gupta 使用大学习率非常快速地训练神经网络；
• Fast.ai Part1 v2/v3 笔记—学习率—从 SGDR 到 1cycle 和超收敛(Roger Mao)；
• [用 fastai 复制 Leslie N. Smith 的论文。](http://Reproducing Leslie N. Smith’s papers using fastai” by Kushajveer Singh)

Kushajveer Singh 的最后一个帖子是一个非常有说明性的 Jupyter 笔记本，值得一看。还有一篇来自 Nachiket Tanksale 的非常有趣的文章，名为寻找好的学习率和单周期政策，其中讨论了周期学习率和动量。

我如何恢复训练？

为此，您必须首先能够记录您停止的位置，然后从该点恢复训练周期，并使用该周期部分的正确超参数。你要做的第一件事就是保存你的网络:

# Do not forget to import the callback function
from fastai.callbacks import SaveModelCallback# Train with the callback function set to save weights every epoch
learn.fit_one_cycle(20, max_lr=slice(1e-5,1e-6), 
       callbacks=[SaveModelCallback(learn, every='epoch',  
                  monitor='accuracy', name='saved_net')])

这将使您的网络在每个时期都被保存，您提供的名称后跟*_ #时期*。所以在时段#3，文件 saved_net_3.pth 将被写入。您可以在完成以下操作后加载此文件:

• 重新创建了数据束和
• 用这个特定的数据集群重新实例化了网络。

重装后。pth 文件，你可以重新开始你的训练，只是你要再次告诉 fit_one_cycle 考虑 20 个历元，而是从历元#4 开始训练。

Fast.ai 采用特殊的回调来实现这一点。要了解如何做到这一点的细节，请看这里:

• 把一个长周期的政策分成几个小周期——PPW 的 GitHub

怎么编码？

fast.ai 中的 fit_one_cycle 方法已经开发出来，允许您告诉它从周期的哪个部分恢复中断的训练。恢复培训的代码如下所示:

# Create a new net if training was interrupted and you had to 
# restart your Colab sessionlearn = cnn_learner(data, models.<your_model_here>, 
                    metrics=[accuracy, error_rate])# If you're resuming, only indicating the epoch from which to 
# resume, indicated by ***start_epoch=<epoch#>*** will load the last 
# saved .pth, it is not necessary to explicitly reload the last 
# epoch, you only should **NOT** change the name given in 
# name=<callback_save_file>: when resuming fast.ai will try 
# to reload ***<callback_save_file>_<previous_epoch>.pth***# Unfreeze the network
learn.unfreeze()# Use start_epoch=<some_epoch> to resume training...
learn.fit_one_cycle(20, max_lr=slice(1e-5,1e-6), 
                    ***start_epoch=<next_epoch#>***,
                    callbacks=[SaveModelCallback(learn, 
                    every='epoch', monitor='accuracy', 
                    ***name=<callback_save_file>***)])

…fast.ai 会告诉你“已加载<回调 _ 保存 _ 文件> _ <上一个 _ 纪元# > ”，恢复训练。

您可以在此查看 fit_one_cycle 方法支持的所有参数:

• https://docs.fast.ai/train.html#fit_one_cycle

如何将这种恢复策略嵌入到我的网络中？

这篇文章的重点是告诉你如何在 fast.ai 中轻松恢复训练，如果被中断的话。如果你是 fast.ai 的新手，为了找到一些背景并学习如何将上面的代码集成到训练网络的整个过程中，请查看我们在下面的 TowardsDataScience 中的帖子:

图像分类:

• 深度学习用 fastai 诊断皮肤图像——学习从皮肤镜图像中识别皮肤癌和其他病症Aldo von Wangenheim；
• Aldo von Wangenheim 利用 fastai 进行疟疾检测的深度学习和医学图像分析；

语义分割:

• 人工智能&古生物学:利用深度学习搜索微化石奥尔多·冯·万根海姆；

我们学到了什么？

在这篇文章中，我们简要介绍了 fast.ai 采用的超级收敛 fit1cycle 训练策略，并展示了一些易于阅读的发布材料，如果你想深入研究，可以使用这些材料，而不必阅读 Leslie N. Smith 的科学论文。

我们还向您展示了如何以一种非常简单实用的方式，使用 fast.ai 的 fit_one_cycle() 方法的一些附加参数来执行完全可中断和可恢复的训练周期。