TowardsDataScience-博客中文翻译-2022-十一-

TowardsDataScience 博客中文翻译 2022（十一）

原文：TowardsDataScience

协议：CC BY-NC-SA 4.0

神谕背后:格罗弗算法和振幅放大

原文：https://towardsdatascience.com/behind-oracles-grovers-algorithm-amplitude-amplification-46b928b46f1e

捕捉高层次的想法以及如何为 SAT 实例实施 oracle

特里·维里斯迪斯在 Unsplash 上的照片

在我开始量子计算之旅的时候，我对“甲骨文”是什么感到困惑。通常，您会读到这样的内容:

“(……)然后，多亏了神谕，你才能够找到解决办法。”

最后，我唯一明白的是:

“它能够(以某种方式)捕捉给定问题的解决方案”。

然而，我不知道怎么做。因此，出现了如下问题。

这个“甲骨文”长什么样？

如何识别我先验不知道的东西？

？？？。[ Gif via Giphy ]

这些都是合理的问题！我们会找出所有这些问题的答案！特别是:

我们将理解为什么神谕是重要的。
我们将抓住神谕背后的高层次直觉。
我们将展示如何定义一个能够解决布尔可满足性问题(SAT)的预言
此外，将提供 Qiskit 中的实现！

在开始之前，你只需要几个先决条件:

叠加是什么。
H，X，CX 这样的量子门是什么？
什么是量子电路。

本文的目标是提供 Grover 算法的自包含表示。我们将尽可能避免数学细节，从而提供这种量子算法能力的实际想法。

开始吧！[ Gif via Giphy ]

为什么这么重要？

“神谕”是格罗弗算法的一部分:最具破坏性的量子算法之一，也是量子计算吸引大量兴趣的原因之一。

格罗弗算法的实力如何？

假设我们需要在一组非结构化的 N 元素中找到一个特定的目标元素。

在经典计算中，由于我们没有关于这个目标元素位置的先验知识，我们需要查看每一个元素。

例如，假设在一个未排序的数组中寻找数字 3(图 1)。

图一。寻找数字 3。[作者 Gif

代价是O(N)(即在最坏的情况下，我们需要扫描所有的 N 元素)。

在量子计算中，得益于 Grover 算法，可以在 O (√N) 中检索到解。相对于经典计算，我们实现了二次加速(图 2)！

图二。二次 Vs 线性加速。[图片由作者提供]

一点背景

通常，量子计算机必须运行给定的量子算法不止一次。有时它们会返回正确的输出，有时则不会。

因此，我们的目标是增加(或"放大")获得正确输出的机会(图 3)。

重点是:

我们想要量子计算机输出的概率分布，使得在算法的给定运行中获得解的概率比获得无效输出的高。

..因为得到错误输出的概率是非零的，所以可能需要更多的运行。

图三。概率分布。[图片由作者提供]

格罗弗的积木

格罗弗的算法由两部分组成:一个甲骨文和一个扩散器。

甲骨文

Oracle “标记”解决方案(图 4)。

图 4。甲骨文标记解决方案。[图片由作者提供]

感谢 oracle，我们能够在非结构化数据集的所有 N 个元素中标记出正确的元素。(不要爪子！我将很快告诉你神谕是什么样子的 ❤)

然而，仅有神谕是不够的。

其实神谕只是标记了正确的元素，并没有增加得到这个元素作为量子算法输出的概率。事实上，单独的神谕是没有用的，因为得到这个元素的概率是 1/N(也就是随机的！).

视觉示例

假设我们有 N=7 个元素，我们寻找元素“三角形矩形”(即我们的解)。于是，我们套用了标注“三角形长方形”的甲骨文。

但是得到三角形矩形的概率是 1/7 (图 5)，和得到其他所有元素中的一个是一样的！😦

图 5。甲骨文不影响得到解的概率。[图片由作者提供]

扩散器来救援了！其实是能够增加得到三角形长方形的几率的！

扩散器

扩散器“放大”溶液(图 6)。

图六。扩散器放大溶液。[图片由作者提供]

为什么扩散工程，是超出了本文的范围。对于那些好奇的人，我会在本文的最后给你提供一些参考。

关键是它增加了 oracle 将元素标记为输出的机会(图 7)。

图 7。扩散器增加了将溶液作为输出的机会。[图片由作者提供]

但是，不要慌！每个 oracle 的扩散器实现都是相同的，我将在最后提供代码！保证！

我们可以将扩散器放在一边，然后回答这个问题:

“神谕长什么样”？

是我！[ Gif via Giphy ]

神谕背后

我发现“甲骨文”这个名字有点误导。似乎有人只要问一句:“解决方案是什么？”就能给你解决方案。

我更喜欢在脑海中描绘一个滤镜的形象！您可以手工制作一个过滤器，它具有您所寻找的元素的精确形状(图 8)！

图 8。甲骨文作为过滤器。[图片由作者提供]

为什么是过滤器？

嗯，在运行 Grover 的算法之前，在某种意义上，你拥有所有的元素(我将在后面解释如何，但这相当简单)，你想过滤掉那些不是你的解的元素。

但是，请记住，你、并且只有你，仔细定义这个过滤器。

现在，可能会出现一个问题

我必须设计一个能够捕捉解决方案并拒绝所有其他元素的过滤器。但是为了能找到答案，我需要知道答案，对吗？

因此，这意味着我已经知道了解决方案。所以…

这个算法有什么意义？

这是一个合理的担忧！

后退一步

格罗弗算法的原名是“一种用于数据库搜索的快速量子力学算法”因此，我找到的例子是在一组数字中寻找一个数字。

如果你想在一个数据集中找到数字 3，你已经事先知道了答案。您正在定义一个 oracle，它捕捉到数字 3，输出是 3。一开始没什么太激动人心的，对吧？

【小注 1】在 Grover 算法中，你需要先验地知道一个解的存在(实际上，你需要知道解的确切个数)。

【小注 2】还有其他的量子算法，找出给定问题的解的个数。然后，你可以使用格罗弗的算法。

向前两步

转折点是神谕可以是一个函数，而不仅仅是一个数字！在这种情况下，我们指的是幅度放大算法，我们可以将其想象为广义的 Grover 算法。

你对“神谕可以是一种功能”有什么打算？

比如我们可以问我们的量子计算机:“那个大于 5 小于 6 的元素是什么？

x > 5 ∧ x < 6

精神上的一步很小，但重点是我们不需要知道解决方案，这将是你的神谕！因此，获得了相对于经典强力算法的二次加速！现在是时候停止空谈，开始行动了。

我们走吧！[ Gif via Giphy ]

用二次加速法求解 SAT

SAT 问题在于找到一个变量赋值，使得它满足一个给定的布尔公式。(我回忆你 SAT 属于 NP-complete 类，一个很有意思的问题！)

例如在(x1 ∧ x2)中，满足布尔公式的赋值为:

x1 =假，x2 =真

特别地，我们关注布尔公式的一种特殊形式，即合取范式 ( CNF )或子句范式。

CNF 刷新

CNF 由一个或多个从句的连接词组成。

每个子句包含一个或多个文字(布尔变量)。
一个 CNF 只包含运算符:(not) ，∨ (or)， ∧ (and)。
子句的连接词通过 ∧ 运算符获得。
每个子句的文字由∩操作符关联
运算符只能用作文字的一部分。

CNF 的示例:

(x ∨ y) ∧ y

解决方案分配是:x =真，y =假

我们将定义解决上述 CNF 的量子电路。

在开始之前，让我们根据并使用德摩根规则重写上面的 CNF 实例(图 9)。 为什么？ 只是因为后面会更容易描述神谕:)

图九。德摩根规则。[图片由作者提供]

于是，我们将 (x ∨ y) ∧ y 改写为 ( x ∧ y) ∧ y 。

具体来说，我们将定义一个甲骨文，它标志着:的解决方案

( x ∧ y) ∧ y

为了简单起见，让我们假设我们已经知道上面的实例有一个单一的解决方案。在文章的最后，我会解释为什么我们会做出这样的假设。

量子电路

1)为布尔公式生成所有可能的赋值: ( x ∧ y) ∧ y 。
2)应用神谕。
3)应用扩散器。
4)进行测量。

注

通常，我们需要根据以下公式多次重复步骤 2)和 3):

其中 n 是变量的个数。

在我们的例子中， n=2 (即 x 和 y ) 。因此，重复次数为 1 。也就是说，我们只应用一次神谕和扩散器。

如果你想进一步了解这个公式是如何得到的，我会在文章底部给你留一些参考资料。

步骤 1:为布尔公式生成所有可能的赋值

我们通过哈达玛门(图 10)将所有的量子位叠加起来！也就是说，我们为布尔公式生成所有可能的赋值。

图 10。哈达玛城门。[图片由作者提供]

既然我们知道一个解存在，，那么我们的解就在我们通过将所有量子位进行相等叠加而生成的赋值(图 11)内。

图 11。所有可能作业的叠加。[图片由作者提供]

步骤 2:应用 Oracle

我想强调的是，在这个例子中，我们不知道像例子“寻找数字 3”中的解决方案。

一般来说，通过定义 SAT 实例，我们只是定义了输入必须满足的条件作为我们的解决方案(即，您的oracle/您的函数！)

遵循 oracle 电路(图 12)。

图 12。甲骨文电路。[图片由作者提供]

不要慌！我们将详细分析❤的整个电路

细节

我们在甲骨文电路中分别观察到 3 个额外的量子位:

2 个工作量子位 w.
一个量子位检测器。

工作量子位

我们添加了和 CNF 实例的子句数量一样多的工作量子位。工作量子位的范围是临时存储给定子句的输出。

在我们的例子中， ( x ∧ y) ∧ y ，我们有 2 个子句，那么需要 2 个工作量子位 w 。

检验量子位

量子位检验器的目的是标记正确的解。也就是说，当一个变量赋值满足 oracle 条件时，那么检查器被翻转到 1 。

条款

我们将 ( x ∧ y) ∧ y 分解成三个部分(图 13):

第 1 条。 w0 = x ∧ y
第 2 条。 w1 = y
结果。 w0 ∧ w1

注意 w0 对应的是 x ∧ y 而不是 ( x ∧ y) ！

我们把第一个推迟到w0 ∧ w1 。

图十三。分解 ( x ∧ y) ∧ y. 【图片由作者提供】

第 1 条。w0 = x ∧ y

条款 1 检查条件 x ∧ y (图 14)。通过多控 X 门实现，其中:

x 和 y 是控制量子位，
w0 是存储条件 x ∧ y. 结果的目标量子位

请注意，多控 X 门必须在 x 和y时触发，为此，我们将前置并附加两个 X 门分别到 x 和 y、，从而取消它们。

图 14。 X 门否定 X 和 y【图片由作者提供】

第二条。 w1 = y

条款 2 检查条件 y (图 15)。通过受控 X 门实现，其中:

y 是控制量子位，
w1 是存储条件 y. 结果的目标量子位

如前所述，由于我们寻找子句 y ，因此我们否定受控 X 门中的量子位 y 。

图 15。 X 门否定 y【图片由作者提供】

结果。 w0 ∧ w1

结果检查与我们的 CNF 实例 ( x ∧ y) ∧ y 相对应的条件 w0 ∧ w1 (图 16)。条件 w0 ∧ w1 通过多控 X 门实现，其中:

w0 和 w1 是控制量子位，
checker 是当 w0 ∧ w1 满足时翻转到 1 的目标量子位。

我们回忆一下 w0 对应的是 x ∧ y 而不是 ( x ∧ y)。

因此，我们需要对 w0 进行否定:(x ∧ y) = w0。

图 16。 X 门求反 w0。[图片由作者提供]

未计算

甲骨文的最后一步是释放工作量子位 w0 和 w1 。这是通过执行不计算来实现的(图 17)。

为了不计算 w0 和 w1 ，以相反的顺序应用实现条款 1 和条款 2 的门就足够了。

图 17。未计算 w0 和 w1。[图片由作者提供]

最终，我们手工制作了我们的神谕！魔力已经显现！

哒哒。[ Gif via Giphy ]

步骤 3:应用扩散器

最后，我们应用扩散器算子，它放大了正确的解(图 18)。

图 18。扩散器电路。[图片由作者提供]

第四步:测量

最终，我们测量量子位 x 和 y (图 20) 。

图 20。测量。[图片由作者提供]

输出分布如图 21 所示。

图 21。输出分配。[图片由作者提供]

最高概率对应赋值 y=0(假)，x=1(真)(即 01)。

特别是赋值 01 满足我们的 CNF 实例 ( x ∧ y) ∧ y！

哇哦。[ Gif via Giphy ]

结论

本文的主要目的是给出一个 oracles 的自包含演示，以及如何使用 Qiskit 实现它们。特别是:

我们理解了神谕是什么。
扩散器的用途。
如何在 Qiskit 中有效地实现一个 Oracle 和一个扩散器？

在下面的参考资料中，您可以找到我的带有 Qiskit 实现的 Github 库，以便您可以使用它:)

啊！在给出的例子中，解的数量正好是 1。然而，对于一个给定的问题，我们可以有多个解决方案！在这些情况下，我们需要对计算 Oracle-Diffuser 对的重复次数的公式做一点小小的修改。特别是，公式变成:

在 Github 资源库中，您还会发现一个 CNF 实例的例子，其中有多个解决方案可供使用。🎉

结束语

我故意避开技术细节，让你掌握大意💡。

当我开始研究量子计算时，我会很欣赏这种概述。这就是我决定写这篇❤.文章的原因

我真的希望你也欣赏它！万一，请随意留下掌声或评论。任何一种反馈都会超级重视！

让我们在 LinkedIn 上保持联系吧！

参考

💻Qiskit 实现这里的👈
🔍格罗弗算法的详细介绍此处 👈
📚为综合本书此处为👈

拜拜！ [ Gif via Giphy

研磨咖啡时吼叫

原文：https://towardsdatascience.com/bellowing-during-coffee-grinding-328e097be5b4

咖啡数据科学

因果

我没有在我的其他磨床上使用风箱，我一直在犹豫是否要一个。然而，我买了一个新的研磨机( SPK-38G )，它带有一个风箱。用了一个星期后，我开始想如果你在研磨时使用风箱会发生什么？

如果你在地面上不停地吼叫会发生什么？从理论上讲，可以进入毛刺之间的细小颗粒会被更快地推出，从而减少了再次研磨的机会。

所有图片由作者提供

我用两个镜头做了一个测试，我观察了粒子分布、提取率和味道。

对于粒子分布，吼叫可以大大减少微粒的数量。对于 200 微米或更小的颗粒，这是 8%的差异。

设备/技术

浓缩咖啡机 : 像样的浓缩咖啡机

咖啡研磨机 : SPK-38G

咖啡:家庭烘焙咖啡，中杯(第一口+ 1 分钟)

镜头准备:断奏夯实

预灌注:长，约 25 秒

输液:压力脉动

过滤篮 : 7g/20g VST

其他设备: Atago TDS 计、 Acaia Pyxis 秤

绩效指标

我使用了两组指标来评估技术之间的差异:最终得分和咖啡萃取。

最终得分 是评分卡上 7 个指标(辛辣、浓郁、糖浆、甜味、酸味、苦味和回味)的平均值。当然，这些分数是主观的，但它们符合我的口味，帮助我提高了我的拍摄水平。分数有一些变化。我的目标是保持每个指标的一致性，但有时粒度很难确定。

两杯

两张照片在视觉上有相似的发展。

就流量和水温而言，它们有点不同。

就味道和提取而言，连续吼叫更好。

一个区别是波纹管注射覆盖过滤器(TCF)的时间更快，但注入时间更长。我希望更粗糙的研磨能让镜头整体跑得更快，但这两个时间度量之间的差异让我很感兴趣。

在整个镜头中吼叫对于每一个镜头来说都有点不切实际，但是可以让一个研磨机不断地推动空气通过研磨机来自动获得相同的效果。我不知道这会如何影响磨矿分布的单峰性，但它无疑指出了减少细粒的技术进步。

如果你愿意，可以在 Twitter 、 YouTube 和 Instagram 上关注我，我会在那里发布不同机器上的浓缩咖啡照片和浓缩咖啡相关的视频。你也可以在 LinkedIn 上找到我。你也可以关注我的媒体和订阅。

我的进一步阅读:

我未来的书

我的链接

浓缩咖啡系列文章

工作和学校故事集

用决策曲线来衡量你的人工智能对现实世界的影响

原文：https://towardsdatascience.com/benchmark-your-ais-real-world-impact-with-decision-curves-7d369a8a6832

图 1:用人工智能做决策。图片作者。

行动是有后果的。人工智能的进步让我们在数据驱动的预测方面表现出色。但是没有行动的预测有什么用呢？人工智能以预测为中心的焦点为现实世界的影响和后果创造了一个盲点。但是有了做决定的权力，就有了权衡自己行为后果的责任。这就是决策曲线分析[1–4]发挥作用的地方。

决策曲线分析是一种图形方法，最初是为病人和医生设计的[1]。它将医学干预的好处和坏处——后果——与医学测试的不确定性——预测联系起来。决策曲线分析背后的关键创新在于，我们不必详尽地量化所有后果。我们需要问的是:在多大的可能性下，你会选择干预而不是不干预？**

例子

图 2:提供抵押贷款的决策树。借款人偿还贷款的概率为 p，。图片作者。

决策曲线分析并不局限于医学领域。它适用于我们基于二元预测任务采取行动的任何情况。例如，考虑一家提供抵押贷款的银行。为了实现利润最大化，银行不会向所有人发放抵押贷款。相反，它估计违约的可能性(预测)，以决定客户是否会获得抵押贷款(行动)。如果银行太严格，它会错过有利可图的客户。而过于宽容的银行家会招致更多的违约。使用如图 2 所示的决策树，我们可以遍历所有场景。通过估计每项成本，我们可以确定最佳策略。

在许多情况下，很难确定每种情况的利弊，或者成本很高。例如，当 CT 扫描本身可以在健康个体中导致癌症时，我们应该如何权衡癌症筛查的阳性检测？此外，每种情况的相对优点都是主观的:一个脆弱的老人可能会权衡癌症检测的后果，这不同于一个有年幼孩子的精力充沛的母亲。

让我们通过绘制你的第一条净收益曲线来应用这些概念！

如何用 Python 绘制决策曲线

想象一下，你在银行工作。你的目标是预测哪些客户会偿还抵押贷款，哪些会违约。我们给出了 20 个带有两个特征的训练例子:收入和年龄。

****from** matplotlib **import** pyplot as plt
**from** sklearn.datasets **import** make_blobscenters = [[0, 0], [1, 1]]
X_train, y_train = make_blobs(
    centers=centers, cluster_std=1, n_samples=20, random_state=5
)
X_test, y_test = make_blobs(
    centers=centers, cluster_std=1, n_samples=20, random_state=1005
)**

查看数据(图 3)，我们发现我们无法用一条直线完美地将十字和圆圈分开。我们的预测器可能不错，但并不完美。

图 3:训练数据来预测将拖欠抵押贷款的客户。阳性标签用红叉表示，阴性标签用蓝圈表示。图片作者。

为了展示模型在优势上的差异，让我们训练两个模型。作为简单基线的逻辑回归模型和梯度增强树模型。

****from** sklearn.ensemble **import** GradientBoostingClassifier
**from** sklearn.linear_model **import** LogisticRegressionbaseline_model = LogisticRegression(random_state=5)
baseline_model.fit(X_train, y_train)
tree_model = GradientBoostingClassifier(random_state=5)
tree_model.fit(X_train, y_train)**

比较这两个模型，我们发现梯度增强树在测试集(90 %的准确度)上比逻辑回归模型(85 %的准确度)做得稍好。

接下来，我们使用 statkit 包中的[NetBenefitDisplay](https://hylkedonker.gitlab.io/statkit/decision.html#statkit.decision.NetBenefitDisplay)类来绘制净收益图。(要在 Linux 上安装 statkit，运行pip3 install statkit)。类似于 sci-kit learn，它有一个from_predictions方法来实例化来自地面真相标签(y_test)和预测的正类概率的情节。

****from** statkit.decision **import** NetBenefitDisplayy_pred_base = baseline_model.predict_proba(X_test)[:, 1]
y_pred_tree = tree_model.predict_proba(X_test)[:, 1]NetBenefitDisplay.from_predictions(y_test, y_pred_base, name='Baseline model')
NetBenefitDisplay.from_predictions(y_test, y_pred_tree, name='Gradient boosted trees', show_references=False, ax=plt.gca())**

这是一个相当忙碌的数字，所以让我们把它分成四个要点。

图 4:比较逻辑回归与梯度提升树模型和完美预测器(Oracle)的净收益曲线。为了比较，示出了对应于总是或从不行动/干预政策的净收益。图片作者。

****越高越好:排名比差距大小更重要【2】。由 Oracle 指示的线是可达到的最大净收益，对应于一个完美的预测值。现在看看蓝色逻辑回归和紫色梯度增强树曲线之间的排序。对于大多数可能的利益/危害偏好，梯度提升树优于逻辑回归模型。

****净收益应该是正的:理论上净收益可以是负的，意味着弊大于利。但是请注意永不行动政策(绿点虚线)的净收益为零。所以我们总是可以决定不行动(忽略模型)并获得至少零净收益。

****更精确的模型可能会逊色:对于银行来说，相对于付费客户的收益，房贷违约的危害很大。假设银行希望每十个客户中不超过一个违约。这对应于曲线的最右侧，概率阈值在 0.9 和 1 之间。记住梯度推进树比逻辑回归模型更准确。然而，看图 4，我们看到在这个范围内，逻辑回归实际上有更多的净效益。越不精确的模型对银行越有利可图！

****模型可能是无用的:在 0 到 0.1 的概率阈值范围内(图 4)，逻辑回归模型的净收益类似于总是行动策略。因此，如果你的“金发女孩”偏好恰好在这个范围内，那么逻辑回归模型就没有现实世界的影响。因此，净收益曲线有助于澄清你的模型是否有实际价值，考虑到人工智能产生的大量技术债务，这一点很重要[5]。

理论

再次重申，决策曲线分析消除了详尽量化所有方案的优点的需要[1]。我们需要引出的只是一个偏好** π :为了一个真正的阳性(癌症检测、抵押贷款支付)，我们愿意采取多少行动/干预(癌症筛查、抵押贷款)？这个概率阈值 π — 偏好 —就是我们放在决策曲线的 x 轴上的值。隐含地，preference π 将假阳性与假阴性的相对危害编成法典[1]。在医疗保健和金融等监管部门，这种偏好也可能受到法规遵从性和/或协议的限制。**

给定一个偏好 π ，我们可以计算出 m 个样本的净收益如下[1–4]:

净收益=真阳性/ m —假阳性/*mπ/(1-π*)。**

也就是说，从行动/干预中获利的个人减去从行动/干预中损失的个人乘以汇率【1–3】。汇率 π /(1- π )量化了我们如何评估从假阳性到真阳性的转换[2，3]。接下来是简洁的部分:通过追踪作为偏好 π 的函数的净收益，我们在所有可能的后果评估中评估模型的收益。结果的每个具体损益分配(如图 2 中的决策树)现在对应于 π 的值。单一图形中所有可能性的空间！

结论

当你使用 AI 做决定时，重要的是权衡其后果的好处和坏处。这就是决策曲线分析的用武之地。净收益曲线作为一座桥梁，将模型世界和(校准的)预测与行动和结果连接起来，无需详尽量化所有情景。

矛盾的是，更精确的模型在现实世界的影响方面可能是劣势的。而且有时候还不如完全没有 AI！决策曲线帮助您在部署到生产环境之前，而不是之后，识别并避免这些常见的陷阱。因此，我们认为决策曲线分析应该是每个数据科学家工作流程的一部分。

承认

感谢布拉姆·范·埃斯、里克·胡伊泽和迪娜·波尔的校对。

参考

[1]:维克斯、安德鲁 j 和埃琳娜 b 埃尔金。决策曲线分析:评估预测模型的新方法医疗决策 26.6(2006):565–574。

[2]:维克斯、安德鲁·j、本·范·卡尔斯特和埃沃特·w·斯特耶伯格。解释决策曲线分析的简单、逐步指南。诊断和预后研究3.1(2019):1–8。

[3]:维克斯、安德鲁·j、本·范·卡尔斯特和埃沃特·w·斯特耶伯格。评估预测模型、分子标记和诊断测试的净效益方法 bmj 352 (2016)。

[4]:鲁松、瓦伦丁和托马斯·宗布伦。重新审视决策曲线分析:总体净收益、与 ROC 曲线分析的关系以及在病例对照研究中的应用。 BMC 医学信息学和决策11.1(2011):1–9。

[5]:斯卡利、大卫等.机器学习系统中隐藏的技术债务神经信息处理系统进展 28 (2015)。

基准测试 6 种基于 AutoML 的插补技术

原文：https://towardsdatascience.com/benchmarking-6-automl-based-imputation-techniques-3b1defc0d25b

插补策略基本指南

图片来自皮克斯拜的威利·海德尔巴赫

现实世界中的数据集通常包含大量缺失值，这可能是由于数据损坏或记录数据失败造成的。数据中缺失值的存在妨碍了训练稳健的机器学习模型。大多数机器学习算法不支持缺失值，因此数据科学家需要在特征工程管道中明确处理缺失值。

有各种技术来处理或估算缺失值。在我以前的一篇文章中，我有 7 种处理缺失值的技术。

</7-ways-to-handle-missing-values-in-machine-learning-1a6326adf79e>

Scikit-learn、Verstack、Impyute 是各种开源包，提供了在几行 Python 代码中估算缺失值的实现。这些软件包实现了各种插补算法，包括 KNN 插补、随机森林插补、迭代插补等。

在本文中，我们将讨论和基准的各种插补算法的性能指标。

开始使用:

在开始实施插补算法之前，让我们准备一个自定义数据集，并用缺失值替换一些值。样本数据集有 28 个特征，其中 5 个特征的 25%的值为 NaNs (12，500 个数据值)。我们保留了原始数据集的副本(具有 NaNs 的实际值),以比较每种插补策略的性能。

请在我的 GitHub gist 中找到实用函数来计算平均绝对误差并生成误差图。

1)简单估算器:

简单估算法可被视为一种基本或最简单的估算技术，其中缺失值由平均值、中间值、最频繁值或常数值替代。Scikit-learn 包提供了简单估算器的实现。

(作者代码)，简单估算器的实现

使用简单估算器的实际值和预测估算值之间的平均绝对误差为***0.01369***。

(图片由作者提供)，简单估算器的误差分布图

2)迭代估算器:

迭代输入是一种输入缺失值的策略，通过循环方式将每个具有缺失值的要素建模为其他要素的函数。Scikit-learn 还提供了迭代估算器的实现。

默认情况下，迭代估算器使用一个可配置的 BayesianRidge 估算器。

(作者代码)，迭代估算器的实现

使用简单估算器的实际值和预测估算值之间的平均绝对误差为***0.01359***。

(图片由作者提供)，迭代估算的误差分布图

3)KNN-估算者:

KNN 估算器使用在训练集中找到的**n_neighbors**最近邻的平均值估算每个缺失值。它假设两个样本是接近的，如果两个样本都不缺少的特征是接近的。

(作者代码)，KNN 估算器的实现

使用简单估算器的实际值和预测估算值之间的平均绝对误差为***0.00867***。

(图片由作者提供)，KNN-估算器的误差分布图

4)ver stack—nan inputr:

nan import使用 xgboost 模型对熊猫数据框中所有缺失值进行估算。xgboost 模型经过多重处理训练，因此估算值相对较快。

使用 NaN Imputer，您可以使用 XGBoost 回归器/分类器更新数值、二进制、分类的缺失值。这个基于 XGBoost 的 NaNImputer 可以使用 verstack 包在一行 Python 代码中实现。

(作者代码)，ver stack NaN-inputr 的实现

实际值和使用小鼠估算器预测的估算值之间的平均绝对误差为***0.00903***。

(图片由作者提供)，ver stack NaN-inputer 的误差分布图

5)小白鼠:

链式方程多变量插补(小鼠)是一种插补缺失值的迭代方法。它假设数据是随机丢失的，并通过查看其他样本值对其真实值进行有根据的猜测。Impyute 包提供了鼠标的实现。

(作者代码)，MICE 的实现

实际值和使用鼠标估算器预测的估算值之间的 mean_absolute_error 为***0.01371***。

(图片由作者提供)，老鼠的误差分布图

基准测试:

(图片由作者提供)，上述插补技术的基准平均绝对误差

从上表中，我们可以得出结论，KNN 估算器(Scikit-learn)和南估算器(verstack)在估算缺失数据值方面表现最佳，性能提高了 55%到 60%。

此外，KNN 估算器和南估算器的误差图相对优于其他误差图，大多数误差等于或接近于 0。

结论:

在本文中，我们讨论了使用各种开源软件包的 API 函数来估算缺失值的 5 种方法或技术。在这 5 种技术中，scikit-learn 中实现的 KNN 估算器表现最佳，与使用均值策略估算缺失数据的基线简单估算器相比，性能提高了 x%。

此外，verstack 包中实现的 nan inputr 函数对该数据的执行效果不太好，但它可以估算值，而不考虑要素的数据类型(数值、二进制、分类)。

上面的基准测试数据是针对一个小的数据集样本生成的，但是很好地概述了各种技术的表现。

感谢您的阅读

用 timeit 对 Python 代码进行基准测试

原文：https://towardsdatascience.com/benchmarking-python-code-with-timeit-80827e131e48

作为 Python 代码时间基准测试最流行的工具，内置的 timeit 模块提供了比大多数 Python 爱好者所知道的更多的东西

timeit 模块是 Python 的秒表。照片由 Tsvetoslav Hristov 在 Unsplash 上拍摄

标杆管理很少是为了好玩而做的，即使它确实很有趣。除了这种乐趣之外，它还可以帮助您:

理解 Python 行为；你可以学习什么更快，什么更慢，这反过来可以帮助你理解语言；
优化您的代码。

如果您认为您花了太多时间对一些随机代码片段进行基准测试，不要担心。我去过那里。老实说，我仍然经常这样做。不要为此感到羞耻:基准测试有助于您理解语言的复杂性。随着时间的推移，你会注意到你可以猜测一个特定的片段应该有多快或多慢。然而，时不时地，甚至你的“标杆鼻子”也会误导你，所以标杆通常是值得花时间的。编程毕竟很有趣，不是吗？

就执行时间而言，Python 中最流行的代码片段基准测试模块可能是[timeit](https://docs.python.org/3/library/timeit.html)模块。Python 还提供了其他与时间相关的基准测试工具，但是timeit绝对应该是您的第一步，原因如下:

这是 Python 中与时间相关的基准测试工具中最流行的一个；
它是标准库的一部分，不用安装；和
其他工具通常是timeit的包装。

因此，我认为如果你想使用这些工具，你应该首先学会如何使用timeit并解释它的结果。这篇文章旨在帮助你。我将向您展示这个模块的一个鲜为人知的特性:基准函数而不是代码片段。我还会告诉你timeit结果可能会误导人的情况。

使用 timeit

大多数用户不知道timeit模块提供了两个 API，这就是为什么你会发现主要使用其中的一个。这两个 API 如下:

基于代码片段的 API 。大多数人提到timeit都会想到这个 API。它有两个优点:相对容易使用，而且几乎可以对任何东西进行基准测试，因为它对代码片段进行基准测试。
基于可调用的 API 。大多数人实际上并不知道这个 API。它旨在为可赎回债券设定基准。不幸的是，它的语法不如基于代码片段的 API 自然，但在某些情况下还是很有用的。我将在本文后面展示这种情况。

这两个 API 使用相同的函数，但有所不同。你应该知道的两个函数是timeit.timeit()和timeit.repeat()。事实是，我几乎总是使用后者，因为它只是简单地运行几次前者，并提供timeit.timeit()的单独结果，所以你会得到更稳定的结果。我建议你也这样做。为此，我将讨论timeit.repeat()函数；timeit.timeit()的 API 非常相似，只有一点不同:缺少repeat参数。

最简单的用法如下:

就是这样！它将测量以字符串形式提供的代码片段的执行时间。在我们的例子中，它是[_ for _ in range(10)]，这意味着我们将测量 Python 使用列表理解一百万次来创建一个列表所用的时间。这一百万次是number参数的默认值。记住该命令的每百万次调用都是在同一个会话中一个接一个、进行的；正如我稍后将展示的，这在某些情况下可能会很棘手。**

让我们来分析函数的签名:

stmt是您想要进行基准测试的代码片段，以字符串形式提供；
number是在一个会话中stmt被调用的次数；，以整数形式提供；默认为1_000_000；
setup是运行stmt次number之前要运行的代码，以字符串形式提供；每个会话只运行一次，在会话开始时；
timer是使用的定时器；默认的是perf_counter()，由于它目前被认为是最好的内置定时器，大多数情况下最好不要碰它；
repeat是要运行的会话数，每个会话由对stmt的number调用组成；你会得到所有这些会议的结果；作为整数提供，默认为 5；
globals是要提供的全局字典；可以代替setup使用，也可以随同使用。

对于小而快的代码片段，没有必要改变number和repeat，除非您希望您的基准提供非常稳定的结果。如果这样做，您应该增加这些数字，这取决于您希望结果有多稳定，以及您希望基准运行多长时间。

然而，对于耗时较长的代码片段，您可能希望减少number和repeat，或者两者都减少，否则基准测试可能会花费太多时间。但是，您会注意到，这样做之后，也就是说，如果number和repeat的值太小，结果可能会变得不稳定。

上面，我们使用了基于片段的 API。是时候讨论一下鲜为人知的基于可调用的 API 了:

您可能认为上面两个对timeit.repeat()的调用应该提供相似的结果，因为它们测试的是同一件事，即使用长度为 10 的range对象的列表理解创建一个列表。但这不是真的:第一个确实以这种方式创建了一个列表，但后者不是，或者说不仅仅是。这是因为后者还包括运行make_list()函数的开销，有时这种开销会相当大。实际上，我们可以这样分析:

上述调用中的第一个相当于timeit.repeat(make_list)，但是它使用与第二个相同的 API。因此，如果我们看到t1和t2之间的差异，那将是由于调用一个函数一百万次的开销。

在我的机器上(32 GB，四个物理和八个逻辑内核，在 WSL 1 中运行)，我得到了以下结果:

差别相当小，不是吗？考虑到这个基准测试用了这么短的时间，我们能信任它吗？让我们用number=10_000_000和repeat=10重新运行基准测试，以防万一。再次，best(t1)更大，与4.1292对3.7315的best(t2)。然而，你必须记住，这些基准测试并没有那么长…它们总共用了 78 秒，下一次我运行它们时，我得到了3.9846对3.8373的结果。因此，如果您想确定您的基准，请使用更大的number和repeat值。但是，当两个(或更多)代码段的执行时间差异很大时，您不必使用大的值。

至于两个 API 的对比，记住:

这两个 API——基于代码片段的和基于可调用的——即使在对做同样事情的代码进行基准测试时，也会产生不同的结果。这是因为基于可调用 API 的结果还包括调用可调用 API 的开销时间。

选哪个？看情况吧。如果您想比较两个函数的执行时间，这正是创建基于可调用 API 的目的。或者，当你在代码中对一个函数做了一些事情(例如，分配一个列表，如上)时，那么基于可调用的 API 将更好地反映实际情况。尽管如此，如果你只是想比较两个片段，没有必要为此使用函数。但是，请记住，关于范围。当您将代码封装在一个函数中时，所有这些都将在这个函数的局部作用域和命名空间中完成。正如我稍后将展示的那样，这可能会有所不同。

示例:创建空字典

现在，假设我们想要对创建空字典的两种方法进行基准测试:{}和dict()。我们可以用下面的方法来做:

你的猜测是什么？

如果你投票支持字面意思更快，那你答对了。在我的机器上，best(literal)给了0.0183，而best(func)给了0.0600，所以差别很大。我们可以分析这两种方法的字节码，看看这种性能差异来自哪里:

如您所见，dict()使用了另外一个字节码操作，在这个操作中它调用了一个dict()函数；文字可能更快，因为它不需要这样做。如果你看到了与前一个例子的相似之处，你就对了；我们看到了调用dict()函数的开销。

有趣的是，如果你创建自己的函数如下:

你会发现它比dict()功能本身更快。我让你检查这作为一个练习。(这就是我上面跟你说的对标的乐趣！)

为什么是最小值？

您可能想知道为什么我使用最小值而不是平均值来比较两个基准测试结果(参见上面的best()函数)。为什么不把均值作为主要的趋势度量，而把方差(或标准差，或其他不同的度量)作为变异的度量？

这是因为标杆管理不是一种正常情况，所以我们不应该应用典型的统计方法来分析其结果。在最好的情况下，相同代码(不包括随机性)的所有运行应该花费相同的时间。但是，在基准测试期间，操作系统会执行许多不同的任务，因此后续的基准测试会花费不同的时间。请记住，这不是因为代码本身，而是因为操作系统的进程。

因此，我们应该取最小值，因为它最接近实际执行时间，没有任何中断。同样的，我们不应该注意运行结果的变化。它们不度量这个特定代码片段的实际执行时间的可变性；其实应该是几乎没有变异的。相反，这种变化度量的是操作系统运行的其他进程的变化程度；那么，这些过程对基准测试结果的影响有多大呢？这就是为什么分析基准与分析其他类型的数据如此不同，这也是为什么最小值是比任何集中趋势度量更好的表示基准结果的度量。

另一个例子

让我们考虑一个更复杂的场景。这一次，我们将使用setup来设置环境。

同样，在运行代码之前，分析它并尝试猜测哪个函数应该更快。(这次没那么简单，因为你需要知道array模块是如何工作的。)

请注意，您可以稍微简化一下上面的代码。这种简化是有意义的，尤其是当您有更多片段要比较时:

在这里，foo_array()比foo_list()几乎慢了五倍，差别很大。

之前，我答应过你展示一个基于调用的 API 比基于代码片段的 API 更有意义的例子。这是这样一种情况。注意，这次使用函数看起来比使用代码片段更自然，因为上面的代码片段只是调用函数。

这些函数带有一个参数，这使得使用基于可调用的 API 变得有点棘手。我们需要使用lambda，这是这个 API 的一个小缺点:

我们不需要使用setup，因为我们导入了array模块。当我们使用基于可调用的 API 时，我们在当前环境中运行基准，除非你通过改变timeit.repeat()的globals参数来影响它。因此，如果环境中有大量大对象，基准测试实际上可能会比几乎空无一物的环境中的性能更差。

你应该知道timeit.repeat()返回的值是什么。列表的长度等于number，每个值代表运行代码片段/callable 的number调用的总时间，以秒为单位。您可以计算运行代码段的平均时间；例如，sum(results["array"]) / (number*repeat)将给出调用foo_array()函数的平均次数，以秒为单位。

小心！

你要记住我之前提到的:timeit函数在同一个会话中一个接一个地运行同一个命令。这在处理可变对象时尤其重要，但不仅限于此。

让我们考虑一个例子。假设您想要将一个生成器表达式与相应的列表进行比较。比方说，您将在一个for循环中使用这两个项目，但是什么也不做——这样，您就可以比较使用这两种对象的开销。举个例子，

我们得到了生成器表达式的0.016和列表的0.669。这是一个惊人的结果！创建一个包含 100 个元素的列表比一个生成器表达式慢 42 倍？！

或者……是吗？

每当你看到如此疯狂的结果，请仔细检查代码。我并不是说这样的结果永远不会发生；而是您应该确保代码是正确的。

您发现代码中的问题了吗？如果没有，再分析一次。它有毛病。

问题是由使用发电机引起的。发电机只能用一次，然后就空了。所以，在这段代码中，它只迭代一次，然后就不再迭代了，原因很简单，因为它是空的。然而，该列表每次都会被迭代。

这就是为什么相应的代码片段花费这么多时间:在第一次调用期间，for循环只在x_gen上循环一次，然后由于x_gen为空，所以什么也不做。但是，对于列表，每次调用代码片段时，它都会循环遍历列表。因此有所不同。

我们可以用一种简单的方法来解决它，使用timeit.repeat():我们可以使用number=1和一个很大的repeat值。这样，每个重复(会话)将实际上迭代生成器表达式，因为它将在每个后续会话中重新创建。

我将结果乘以repeat,因为否则它们会非常小，代表迭代一个for循环的时间。

现在我们用15.400表示生成器表达式，用0.900表示列表。这一次——当我们使用正确的方法时——列表比生成器表达式快 17 倍。

当您操作一个可变对象时，类似的情况也会发生:如果它在每次调用中都受到影响，那么下一次调用将使用这个对象的更新版本，而不是原始版本。因此，每个调用使用不同的对象。一个例子可以是基准测试append如何为列表工作。每次你添加一个条目到一个列表中，列表都会变长，所以后面的添加是不可比较的。玩这个来看看它是如何工作的，纯粹是为了基准测试的乐趣。

替代品

Python 提供了各种时间基准替代方案。我想指出的其中三点是

[cProfile](https://docs.python.org/3/library/profile.html)，内置 Python profiler 对于任何重视性能的人来说，这是一个非常有用的工具；
[perftester](https://github.com/nyggus/perftester)，在执行时间和内存使用方面进行性能测试的包，它还提供了基准测试和分析工具；和
[ycecream](https://github.com/salabim/ycecream)，Python 代码甜蜜调试和基准测试的包。

结论

timeit模块可能是测试代码最简单的方法。这是一个内置的解决方案，其 API 相对容易使用。我绝对推荐它，但是考虑用timeit.repeat()函数代替timeit.timeit()。

随着时间的推移，您会注意到，代码是否在每个细节上都进行了优化并不重要。例如，当代码持续 10 小时时，找到节省 10 毫秒的方法真的重要吗？有时这可能是有意义的，但是我们必须记住提高性能通常是有代价的，比如可读性更差的代码。

总结一下:

在关键时刻优化性能。否则，努力提高代码的可读性。
尝试在代码复杂性和性能之间找到正确的平衡。
代码优化需要时间。为了每月节省一秒钟，花 10 个小时优化代码值得吗？通常，答案是“视情况而定”，但是永远记得问自己(和团队中的其他人)这个问题。
timeit模块提供了基准执行时间的内置方法。它使用起来非常简单，但是您应该将它视为基准测试工具，而不是分析工具。
当你知道一个函数比另一个更快，可读性一样好，并且在代码中使用它不会花费更多的时间时，就使用它。在这种情况下，你究竟为什么要使用较慢的函数/方法呢？
如果你想学习各种错综复杂的 Python，timeit可以帮助很大。结合其他工具，它可以帮助您理解 Python 是如何工作的。
如果你想了解更多关于 Python 中的代码优化、概要分析和相关主题，Gorelick 和 Ozsvald 的书(2020)是你的朋友。

感谢阅读。我希望你喜欢这篇文章和timeit模块。如果您这样做了，请注意这并不是故事的结尾:在后面的文章中，我将讨论其他基准测试工具。

资源

https://docs.python.org/3/library/timeit.html
https://docs.python.org/3/library/profile.html
https://github.com/nyggus/perftester
https://github.com/salabim/ycecream
Gorelick，m .，Ozsvald，I. (2020 年)。高性能 Python:人类实用的高性能编程。第二版。奥莱利媒体。

用最简单的方法对 Python 函数进行基准测试:perftester

原文：https://towardsdatascience.com/benchmarking-python-functions-the-easy-way-perftester-77f75596bc81

PYTHON 编程

您可以使用 perftester 以最简单的方式测试 Python 函数

凯文·Ku 在 Unsplash 上的照片

最近，我描述了如何用[timeit](https://docs.python.org/3/library/timeit.html)模块进行时间基准测试。我解释了timeit构成了基准时间的基本 Python 方法，并向您承诺展示更多。这篇文章是我信守这个承诺的第一步。

我描述了timeit提供的两种 API:基于片段的和基于可调用的 API。前者是众所周知的，但后者不是，可能是因为它不太自然，需要您使用一个lambda函数。在这里，我将探索的 [perftester](https://github.com/nyggus/perftester) 包，它允许基准测试调用，就像后面的 API 一样；然而，与它不同的是，它提供了一个简单且感觉自然的 API。

然而，perftester带来的不仅仅是时间基准测试——它使您能够根据执行时间和内存使用量对可调用程序进行基准测试，但最重要的是——它是一个用于 Python 可调用程序性能测试的框架。

我们将从基准测试开始，一步一步地讨论这个丰富的产品。由于时间和内存这两种类型的基准测试非常不同，我们将在这里关注时间基准测试，而将内存消耗的基准测试放在一边；我们改天再讨论这个话题。然后我们将准备讨论作为测试框架的perftester——据我所知，这是第一个用于测试可调用程序性能的 Python 框架。

基本用法

上述文章表明timeit模块易于使用。虽然这是真的，perftester可以更容易。它的 API 使您能够编写简洁明了的 Python 函数和其他可调用函数的基准。为了分析这个 API，让我们使用一个特定的例子。

假设我们有一个任何类型的项目列表x。我们希望以这样一种方式扩展列表，即给定整数n，我们将每个元素n相乘若干次。我们不仅仅通过将列表相乘(x*n)来实现，而是希望保持列表的顺序。

因此，我们预期以下行为:

>>> extend([1, 4, 'a'], 2)
[1, 1, 4, 4, 'a', 'a']
>>> extend([1, 4, 'a'], 3)
[1, 1, 1, 4, 4, 4, 'a', 'a', 'a']
>>> extend([2, 2, 4, 1], 2)
[2, 2, 2, 2, 4, 4, 1, 1]
>>> extend([1, -1, 1, -1], 3)
[1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1, -1]

这是该函数的一个版本:

# extender.py
def extend(x: list, n: int) -> list:
    """Extend x n number of times, keeping the original order.

    >>> extend([1, 4, 'a'], 2)
    [1, 1, 4, 4, 'a', 'a']
    >>> extend([1, 4, 'a'], 3)
    [1, 1, 1, 4, 4, 4, 'a', 'a', 'a']
    >>> extend([2, 2, 4, 1], 2)
    [2, 2, 2, 2, 4, 4, 1, 1]
    >>> extend([1, -1, 1, -1], 3)
    [1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1, -1]
    """
    modified_x = []
    for x_i in x:
        for _ in range(n):
            modified_x.append(x_i)
    return modified_x

如您所见，我添加了一个带有 doctests 的 docstring。如果你想了解这个有用的测试框架，你可以阅读下面的走向数据科学文章:

要运行测试，使用下面的 shell 命令，它假设您将上面的文件保存为extender.py，并且您就在 shell 中的这个文件夹中。

$ python -m doctest extender.py

没有输出意味着所有的测试都通过了。

好了，我们准备好测试extend()函数了。让我们创建一个main.py Python 文件来运行基准测试，它与extender.py文件位于同一个文件夹中:

# main.py
import extender
import perftester

if __name__ == "__main__":
    t = perftester.time_benchmark(
        extender.extend,
        [1, 1, 4, 4, 'a', 'a'],
        3
        )
    print(t)

这将使用perftester.time_benchmark()参数的默认值，即Number=100_000和Repeat=5。如果你想知道为什么会有人用大写字母作为参数名的第一个字母，你会在文章末尾的附录中找到解释。

上面的代码在我的机器上产生了以下结果:

我们不会关注实际结果，因为我们对它们并不特别感兴趣。在不同的机器上，我们会得到不同的结果。因此，perftester也提供了相对的结果，这些结果应该大致与机器无关。我们稍后将讨论这个问题。

然而，首先让我们仔细看看输出。可读性不太好吧？这就是为什么perftester为我们提供了一个很好的小解决方案，即pp()函数。它的名字代表漂亮的印刷，它的漂亮印刷基于两点:

内置pprint模块的pprint()功能，
现场包rounder中的signif_object()功能。

[rounder](https://github.com/nyggus/rounder)包使你能够以一种非常简单的方式对任何 Python 对象中的数字进行舍入。如果你感兴趣，你可以阅读下面的文章:

我们来看看perftester.pp()用上面的字典做了什么。这是我们的main.py模块的代码:

import extender
import perftester

if __name__ == "__main__":
    t = perftester.time_benchmark(
        extender.extend,
        [1, 1, 4, 4, 'a', 'a'],
        3
        )
    perftester.pp(t)

这是输出结果:

很好，不是吗？我们只通过一个函数perftester.pp()获得了这个，所以你可能想记住它:perftester.pp就像 perftester pretty print 一样。

perftester.pp如在 perftester 漂亮的打印。

我们现在可以分析输出。这就是我们现在的情况:

min、mean、max:这是在所有运行(有repeat次运行)中运行一个函数的最小、平均和最大平均执行时间→所以这是函数执行一次的平均时间，不像timeit.timeit()和timeit.repeat()都显示它们的整个执行时间。因此，perftester基准在实验之间是可比较的；timeit基准测试不是——至少在没有额外计算的情况下不是。在这三者中，我们最感兴趣的是min，因为在基准测试中，我们应该寻找最佳结果(您可以在中找到更多关于 [timeit](/benchmarking-python-code-with-timeit-80827e131e48) 基准测试的文章)。
这是我们兴趣的另一个价值。相对基准测试是根据空函数(即什么都不做，只有pass)的执行时间来执行的。具有相同操作系统的机器之间的相对基准应该或多或少是一致的，但是它们在不同的操作系统之间不太可能是一致的(即使是在同一台机器上，根据我的实验)。
raw_times和raw_times_relative:这两个显示原始值，即基准函数在每次运行中的平均执行时间(我们有Repeat运行次数)，和平均相对执行时间(所以，除以空函数的平均相对执行时间)。这些价值观很少引起我们的兴趣；不过，请看下面的例子。

perftester基准在实验之间具有可比性；timeit 基准不

在某些情况下，我们可能希望查看min原始结果:这是因为它提供了我们机器上基准函数的最小执行时间。我们肯定会对这个值感兴趣。然后我们也可以看看raw_times，因为它们显示了这个函数在我们的机器中有多快，所有的后台进程都在运行，所以是在真实的场景中。我们看到，对于我们使用的参数，我们的函数平均需要1.95e-06秒；因此，运行一百万次将花费几乎 2 秒钟。在最好的运行中，平均执行时间是1.84e-06，所以并没有少很多。从raw_times中我们可以看出，变化似乎并不大。

通常，我们会针对各种参数组合对函数进行基准测试，以了解函数在各种场景中的表现。我们将在下面比较两个函数时这样做。

我想你们中的许多人认为我在编写这个函数的时候可以做得更好…你是对的！这并不是我一生中编写的最好的函数。创建列表的for循环？当然，列表理解应该做得更好，在性能方面也是如此；点击此处查看更多信息:

那么，让我们改进一下extend()函数。但是因为我们想检查我们的更改是否提高了性能，我们将更改函数名，以便我们的extender模块有两个版本。下面是我们新函数extend_2()的代码:

# added to main.py

def extend_2(x: list, n: int) -> list:
    """Extend x n number of times, keeping the original order.

    >>> extend_2([1, 4, 'a'], 2)
    [1, 1, 4, 4, 'a', 'a']
    >>> extend_2([1, 4, 'a'], 3)
    [1, 1, 1, 4, 4, 4, 'a', 'a', 'a']
    >>> extend_2([2, 2, 4, 1], 2)
    [2, 2, 2, 2, 4, 4, 1, 1]
    >>> extend_2([1, -1, 1, -1], 3)
    [1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1, -1]
    """
    return [x_i for x_i in x for _ in range(n)]

所有的doctest都通过了，所以函数按预期工作。这个功能明显比原来的extend()更短、更清晰，也更优雅，这很好。

因此，让我们对这两个函数进行基准测试。但是因为我们想要比较两个函数，我们不应该只使用一个参数组合，因为对于小的n，增益(如果有的话)可能与大的n不同。下面是main模块的代码:

# main.py
import extender
import perftester

from collections import namedtuple

Benchmarks = namedtuple("Benchmarks", "extend extend_2 better")

if __name__ == "__main__":
    orig_list = [1, 1, 4, 4, 'a', 'a']
    results = {}
    for n in (2, 5, 10, 100, 1000, 10_000):
        number = int(1_000_000 / n)
        t = perftester.time_benchmark(
            extender.extend,
            orig_list,
            n,
            Number=number
            )
        t_2 = perftester.time_benchmark(
            extender.extend_2,
            orig_list,
            n,
            Number=number
            )
        better = 'extend' if t['min'] < t_2['min'] else 'extend_2'
        nn = f"{n: 6}"
        results[nn] = Benchmarks(t['min'], t_2['min'], better)
    perftester.pp(results)

这是输出结果:

{'     2': Benchmarks(extend=1.531e-06, extend_2=1.358e-06, better='extend_2'),
 '     5': Benchmarks(extend=2.185e-06, extend_2=1.739e-06, better='extend_2'),
 '    10': Benchmarks(extend=3.524e-06, extend_2=2.308e-06, better='extend_2'),
 '   100': Benchmarks(extend=2.513e-05, extend_2=1.288e-05, better='extend_2'),
 '  1000': Benchmarks(extend=0.0002717, extend_2=0.0001432, better='extend_2'),
 ' 10000': Benchmarks(extend=0.002942, extend_2=0.001435, better='extend_2')}

基于列表理解的新版本肯定更快；而且n越大，修正函数越快。对于n=10000，extend_2()比原来的extend()快两倍左右。

我们现在应该对不同长度的不同列表的函数进行基准测试，但是我在这里的目的不是比较这两个函数，而是向您展示如何使用perftester简单地对函数进行基准测试。因此，我将把这些额外的基准留给你们作为练习。

高级用法

perftester函数使用默认设置，这通常是我们需要的。有时，我们可能希望改变Number或Repeat，就像我们上面所做的那样，根据一个函数要完成的操作数来选择Number。有时我们也想改变Repeat。当我进行的基准测试很重要时，我通常会增加Number和Repeat。当我有小分歧时，我也会这样做；我增加了这两个参数，以使基准更加稳定。

如果您想对所有基准使用相同的Number和Repeat，您不必每次运行perftester.time_benchmark()功能时都手动这么做。您可以在perftester.config对象中修改它一次，它控制perftester函数的行为。

为了做到这一点，做以下事情就足够了:

perftester.config.set_defaults("time", Number=1_000_000, Repeat=10)

这将改变所有要进行基准测试的函数的默认值Number和Repeat；当用户在调用perftester.time_benchmark()函数时改变这些参数或其中一个参数的值时，它们将不会被使用。

上面的命令改变了每个要进行基准测试的函数的默认值。对于特定的功能，您也可以这样做。例如:

perftester.config.set(foo, "time", Number=1_000_000, Repeat=10)

将改变函数foo()的Number和Repeat——该函数之前必须已经定义过。因此，您不能更改尚未定义或的功能的设置。

您也可以只更改两个参数之一的默认值:

perftester.config.set_defaults("time", Number=1_000_000)
perftester.config.set(foo, "time", Number=1_000)

另一个——没有改变——将简单地保持不变；也就是说，等于默认设置。

如前所述，相对基准是针对空函数的性能进行的，存储为perftester.config.benchmark_function。这种方法是有意义的，因为这个函数代表了调用一个函数的开销。因此，剩余的执行时间花在了基准测试函数要做的事情上。

有时候，你可能想把这个空函数换成另一个；将根据该功能的性能进行相对基准测试。做起来很简单:你可以用另一个覆盖perftester.config.benchmark_function()；例如:

def foo():
    return [i for i in range(10)]

perftester.config.benchmark_function = foo

您可以从下面来自perftester仓库的文档文件中了解更多关于这个主题的信息:

https://github.com/nyggus/perftester/blob/implement-profiling-decorator/docs/benchmarking_against_another_function.md

结论

用perftester对 Python 函数和其他可调用函数进行基准测试很容易。其实比用timeit容易。足以调用perftester.time_benchmark()函数，其 API 简单直观。唯一要记住的是以大写字母开始参数Number和Repeat；这同样适用于Func参数，但是您很少将它用作关键字参数，因为它是perftester.time_benchmark()函数的第一个参数，提供了要进行基准测试的函数。因此，从下面的两个电话来看，前者会更频繁:

# Rather this:
t = perftester.time_benchmark(
        extender.extend,
        [1, 1, 4, 4, 'a', 'a'],
        3
        )
# than this:
t = perftester.time_benchmark(
        Func=extender.extend,
        [1, 1, 4, 4, 'a', 'a'],
        3
        )

这并不意味着perftester通常比timeit 函数、timeit()和repeat()简单。虽然perftester更容易对可调用程序的执行时间进行基准测试，但是timeit更容易对格式化为字符串的代码片段进行基准测试，比如"[i**2 for i in range(1000)]"。您可以使用perftester对这样的代码片段进行基准测试，但是您必须定义一个函数来完成这样的代码片段所做的事情。这意味着基准测试不仅会测量执行时间，还会通过调用函数来测量额外时间的开销。因此，当您有一个代码片段要进行基准测试时，您应该选择timeit模块。

虽然perftester更容易对可调用程序的执行时间进行基准测试，但是timeit更容易对代码片段进行基准测试。

然而，在基准可赎回性方面，perftester大放异彩。它的 API 专门用于这个场景，而timeit的 API 则不是。你可以这样做，但是你需要定义一个非参数 lambda。比较我们的extend()函数的这两个基准:

# perftester, using default settings
perftester.time_benchmark(extender.extend, [1, 1, 4, 4, 'a', 'a'], 3)
# timeit, using defaults settings
timeit.repeat(lambda: extender.extend([1, 1, 4, 4, 'a', 'a'], 3))

# perftester, changed settings
perftester.time_benchmark(
    extender.extend, [1, 1, 4, 4, 'a', 'a'], 3,
    Number=1000, Repeat=3,
)
# timeit, changed settings
timeit.repeat(
    lambda: extender.extend([1, 1, 4, 4, 'a', 'a'], 3),
    number=1000, repeat=3
)

对perftester.time_benchmark()的调用更加自然，乍一看也更容易理解。在timeit函数中使用lambda的必要性使得这个调用可读性更差。

还有一件事。您可以选择使用全名来导入perftester，就像我在本文中所做的那样。但是你也可以这样做

import perftester as pt

在软件包的存储库中使用。全名导入稍微清楚一点，但是肯定更长，所以选择你喜欢的。

请注意，在进行基准测试时，perftester使用与timeit完全相同的后端，因为前者实际上调用后者。所以区别只在于 API。这种差异不足以学习一个新的框架来测试一个函数。但是正如我在上面所写的，perftester带来的不仅仅是基准执行时间，这就是为什么我相信你不会后悔花时间学习这个包——以及阅读这篇文章。您不仅可以对时间进行基准测试，还可以对内存进行基准测试，但最重要的是，该包使您能够编写时间和内存方面的性能测试。我决定在不同的文章中讨论这些不同的用例，以便一次处理一个主题——并且使学习更容易。

感谢您的阅读。我希望很快发布关于perftester的下一篇文章，你将会看到perftester提供了一些你以前没有见过的东西:Python 调用的性能测试框架。

在此期间，您可以将其用于基准时间。如果你想了解更多关于这个包及其用途的信息，你可以在perftester的 GitHub 仓库中找到:

https://github.com/nyggus/perftester

附录

上 **Func** 、 **Number** 和 **Repeat**

您可能想知道为什么这些参数(其中的Number和Repeat以及关键字参数)以大写字母开头。这是一个合理的问题，因为这似乎不合常理；我在这个附录中回答了这个问题，基于您可以在软件包的存储库中找到的解释。

这种方法最大限度地降低了要进行基准测试的函数与您计划使用的perftester函数同名的风险，在这种情况下，您将不得不使用一个参数两次——这将意味着SyntaxError。在 Python 代码库中，有很多函数都有一个名为func、number或repeat的参数。但是很少有函数有一个名为Func、Number或Repeat的参数。这就是为什么perftester的参数以大写字母开始。

然而，如果一个函数有一个参数Func、Number或Repeat，有一个解决方案。您可以定义一个functools.partial()函数并测试这个函数。你可以在这里阅读更多关于functools.partial()的信息:

https://docs.python.org/3/library/functools.html#functools.partial

下面，你会发现一个例子。假设你有一个函数foo()，它的参数是Number和Repeat。要使用perftester.time_benchmark()，您需要执行以下操作:

from functools import partial

def foo(Number, Repeat):
    return [Number] * Repeat

foo_partial = partial(foo, Number=20.5, Repeat=100)
perftester.time_benchmark(foo_partial, Number=1000, Repeat=10)

但是，首先你应该而不是使用Number和Repeat中的foo()参数。我展示这个解决方案是因为您可能会发现自己处于这样一种情况，您想要对别人编写的这样做的函数进行基准测试；安全总比后悔好。

functools.partial()在很多其他用例中都是非常有用的解决方案，不仅仅是这个。所以，反正知道这个功能就好了。

资源

https://docs.python.org/3/library/functools.html#functools.partial https://github.com/nyggus/perftester https://github.com/nyggus/rounder

BentoML:在几分钟内创建一个 ML 驱动的预测服务

原文：https://towardsdatascience.com/bentoml-create-an-ml-powered-prediction-service-in-minutes-23d135d6ca76

用 Python 封装和部署您的 ML 模型

动机

您刚刚建立了一个机器学习模型来预测客户属于哪个群体。该模型似乎在细分客户方面做得很好。您决定将这个模型交给您的团队成员，以便他们可以在您的模型之上开发 web 应用程序。

作者图片

等等，但是你如何将这个模型发送给你的团队成员呢？如果你的团队成员可以使用你的模型而不用设置任何环境或者弄乱你的代码，那不是很好吗？这时候 BentoML 就派上用场了。

随意发挥，并在这里叉这篇文章的源代码:

https://github.com/khuyentran1401/customer_segmentation/tree/bentoml_demo

BentoML 是什么？

BentoML 是一个 Python 开源库，使用户能够在几分钟内创建一个机器学习驱动的预测服务，这有助于弥合数据科学和 DevOps 之间的差距。

要使用将在本文中使用的 BentoML 版本，请键入:

pip install bentoml==1.0.0a4

为了理解 BentoML 是如何工作的，我们将使用 BentoML 来服务于一个根据新客户的个性对其进行细分的模型。

保存处理器

从从 Kaggle 下载客户个性分析数据集开始。接下来，我们将处理数据。

由于我们稍后将使用StandardScaler和PCA来处理新数据，我们将把这些 scikit-learn 的变形金刚保存到 BentoML 的本地模型商店。

运行上面的代码后，模型将保存在~/bentoml/models/下。您可以通过运行以下命令来查看本地存储的所有模型:

$ bentoml models list

输出:

请注意，该模型是用特定的标签进行版本化的。如果我们保存另一个同名的模型，您应该会看到一个不同的标签。

这非常好，因为对模型进行版本控制将允许您在不同的模型之间来回切换。

找到完整的代码读取并处理数据 这里。

保存模型

接下来，我们将在处理后的数据集上训练KMeans模型。我们将使用如上所示的相同方法来保存模型。

在这里 找到关于训练和保存模型 的完整代码。

创建服务

现在我们有了模型，让我们加载最新的处理器和模型，并在bentoml_app_pandas.py中用该模型创建一个服务。

function_name告诉 BentoML 模型运行时将使用哪个函数。

function_name的默认值为predict。由于customer_segmentation_kmeans是一个估计量，我们保持function_name的默认值。由于scaler和pca是变压器，所以我们把function_name设为transform。

然后用处理器和模型创建一个服务:

定义服务后，我们可以用它来创建一个 API 函数:

装饰器@service.api声明函数predict是一个 API，其输入是一个PandasDataFrame，输出是一个NumpyNdarray。

现在让我们通过运行bentoml serve在调试模式下测试服务。由于bentoml_app_pandas.py在src目录下，我们运行:

$ bentoml serve src/bentoml_app_pandas.py:service --reload

输出:

我们现在可以通过访问 http://127.0.0.1:5000 并点击“试用”按钮来与 API 进行交互:

作者图片

插入以下值:

[{"Income": 58138, "Recency": 58, "NumWebVisitsMonth": 2, "Complain": 0,"age": 64,"total_purchases": 25,"enrollment_years": 10,"family_size": 1}]

…请求体应该给你一个值1。这意味着模型预测具有这些特征的客户属于分类 1。

作者 GIF

用 pydantic 创建数据模型

为了确保用户将具有正确数据类型的正确值插入到 API 中，我们可以使用 pydantic 创建一个自定义数据模型:

现在，您应该在请求主体下看到默认值。

作者图片

在这里 可以找到关于创建 API 的完整代码。

制作便当

在确保一切看起来不错之后，我们可以开始将模型、服务和依赖项放入便当中。

作者图片

要构建 Bentos，首先在项目目录中创建一个名为bentofile.yaml的文件:

关于上述文件的详细信息:

include部分告诉 BentoML 在便当中包含哪些文件。在这个文件中，我们包括了bentoml_app.py和我们之前保存的所有处理器。
python部分告诉 BentoML 服务依赖于哪些 Python 包。

现在我们准备好做便当了！

$ bentoml build

作者图片

构建好的便当会保存在~/bentoml/bentos/<model-name>/<tag>目录下。目录中的文件应该类似于下图:

.
├── README.md
├── apis
│   └── openapi.yaml
├── bento.yaml
├── env
│   ├── conda
│   ├── docker
│   │   ├── Dockerfile
│   │   ├── entrypoint.sh
│   │   └── init.sh
│   └── python
│       ├── requirements.lock.txt
│       ├── requirements.txt
│       └── version.txt
├── models
│   ├── customer_segmentation_kmeans
│   │   ├── cs5htpv3ncng3lg6
│   │   │   ├── model.yaml
│   │   │   └── saved_model.pkl
│   │   └── latest
│   ├── pca
│   │   ├── latest
│   │   └── sa4bx5f3ngf6flg6
│   │       ├── model.yaml
│   │       └── saved_model.pkl
│   └── scaler
│       ├── latest
│       └── sawshnv3ngf6flg6
│           ├── model.yaml
│           └── saved_model.pkl
└── src
    └── src
        └── bentoml_app.py

相当酷！我们刚刚用几行代码创建了一个包含模型、服务、处理器、Python 需求和 docker 文件的文件夹！

部署到 Heroku

现在你已经有了制作好的便当，你可以把它打包成 Docker images 或者部署到 Heroku。因为我想为我的 API 创建一个公共链接，所以我将把它部署到 Heroku 容器注册中心。

从安装 Heroku 开始，然后在命令行上登录一个 Heroku 帐户:

$ heroku login

$ heroku container:login

创建 Heroku 应用程序:

$ APP_NAME=bentoml-her0ku-**$(**date +%s | base64 | tr '[:upper:]' '[:lower:]' | tr -dc _a-z-0-9**)**
heroku create $APP_NAME

接下来，转到您最新构建的便当下的 docker 目录。要查看您的便当的目录，运行:

$ bentoml list -o json
[
  {
    "tag": "customer_segmentation_kmeans:4xidjrepjonwswyg",
    "service": "src.bentoml_app:service",
    "path": "/home/khuyen/bentoml/bentos/customer_segmentation_kmeans/4xidjrepjonwswyg",
    "size": "29.13 KiB",
    "creation_time": "2022-02-16 17:15:01"
  }
]

由于我最新的便当在~/bentoml/bentos/customer_segmentation_kmeans/4xidjrepjonwswyg，我将运行:

将便当打包并推送到上面创建的 Heroku 应用程序:

$ heroku container:push web --app $APP_NAME  --context-path=../..

发布应用程序:

$ heroku container:release web --app $APP_NAME

新应用程序现在应该会列在 Heroku 仪表盘中:

作者图片

单击应用程序的名称，然后单击“打开应用程序”打开您的 API 的应用程序:

作者图片

我的 API 服务的公共链接是https://bentoml-her0ku-mty0ndg3mza0ngo.herokuapp.com。

作者图片

现在，您可以使用公共链接通过示例数据进行预测请求:

就是这样！现在，您可以将此链接发送给团队的其他成员，以便他们可以构建一个基于机器学习的 web 应用程序。无需安装和设置即可使用您的机器学习模型。多酷啊。

如果您喜欢自己创建一个简单的 UI，下一节将向您展示如何使用 Streamlit 来实现。

使用 Streamlit 为您的服务构建 UI

如果您希望您的经理或利益相关者尝试您的模型，使用 Streamlit 为您的模型构建一个简单的 UI 可能是个好主意。

在文件streamlit_app.py中，我从用户那里获得输入，然后使用这些输入进行预测请求。

运行 Streamlit 应用程序:

$ streamlit run src/streamlit_app.py

然后去 http://localhost:8501 。您应该会看到如下所示的 web 应用程序:

作者 GIF

这款应用现在玩起来更直观了。

结论

恭喜你！您刚刚学习了如何使用 BentoML 为您的机器学习模型创建 API 端点。有了 BentoML，您的队友可以使用您的模型，而无需设置环境或修改代码。多酷啊。

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

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

参考

阿卡什·帕特尔。2021–08–22.客户个性分析。
CC0:公共领域。检索自https://www . ka ggle . com/imakash 3011/customer-personality-analysis/

BERTScore:用 BERT 评估文本生成

原文：https://towardsdatascience.com/bertscore-evaluating-text-generation-with-bert-beb7b3431300

机器学习研究论文摘要

作者图片

BERTScore 是一种自动评估标准，用于测试文本生成系统的优劣。与计算标记级句法相似性的现有流行方法不同，BERTScore 侧重于计算参考标记和假设标记之间的语义相似性。这篇论文的作者在机器翻译和图像字幕任务上测试了它，发现它与人类的判断更相关。

更多这样的视频

让我们以总结系统为例，任务是通过 GPT2 模型对给定的书进行总结，假设模型说“这是我如何总结的”，但事实是“这应该是如何总结的”。

作者图片

为了评估系统已经生成的摘要的质量，可以使用现有的系统，例如 ROUGE 和 BLEU 度量，这些度量依赖于假设和参考之间的句法重叠，通过考虑单字、双字等。但是考虑到它们的局限性，即在假设和参考中存在确切的词，并且不能解码语义，引入了 BERTScore，其中的思想是理解你已经生成的和应该生成的的含义，然后进行比较。

作者图片

如上图所示，我们采用参考(基本事实)和候选(生成的)，并通过预训练的 BERT 模型，在输出端为每个单词生成上下文嵌入。一旦我们有了这些单词中每个单词的最终嵌入，我们就通过计算每个单词与候选单词中每个单词的参考相似度来进行 n 平方计算。我们从参考中找到并挑选与候选词最相似的词，并计算精确度、召回率和 f 值(精确度和召回率的调和平均值)。

作者图片

本文作者还引入了权重的概念，用于计算每个单词的相似度。他们坚持基于大量离线文本数据得出的 IDF 权重。因此，如果一个单词具有非常高的 IDF 权重，那么这不是一个在多个文档中使用的非常常见的单词，所以在进行相似性计算时，它可能值得您进行比较，不像具有低 IDF 的单词(主要代表常见单词)

所以，是的，这就是我的博客。我鼓励你也通读这篇论文，其细节将在下面提及—

⏩ 论文标题 : BERTScore:用 BERT 评估文本生成

⏩ 论文:【https://arxiv.org/abs/1904.09675】T21

⏩ 作者 :张天翼、瓦莎·基肖尔、菲利克斯·吴、基连·q·温伯格、约夫·阿奇

⏩ 组织机构:ASAPP 康乃尔大学公司

我希望你喜欢读这篇文章。如果你愿意支持我成为一名作家，可以考虑注册成为中的一员。每月只需 5 美元，你就可以无限制地使用 Medium。

CSV:为什么我放弃了他们的一些利益来获得其他利益

原文：https://towardsdatascience.com/best-file-format-to-store-large-data-dfa47701929f

我使用的替代方案允许更小的文件大小和更好的性能。

何塞·阿拉贡内塞斯在 Unsplash 上的照片

CSV 很好，但被高估了。

我使用 CSV 已经很长时间了。就像数据科学社区的其他人一样。然后腌制一段时间。

CSV 可以在任何系统上工作，无需安装任何东西。毕竟，它们是一种带有逗号分隔符的纯文本文件。这个事实也让它们超级简单易懂。

但是我们已经在这个舒适区待了太久了。

大多数数据应用程序受益于放弃一点灵活性。我们可以通过多安装一个包来大大加快数据的读写速度。

在本帖中，我们将讨论…

数据科学家的 CSV 问题；
我对用泡菜文件代替的想法；
CSV 和泡菜的更好替代品；
对存储数据集的不同文件格式进行基准测试

您可以访问我在这篇文章中使用的用于基准测试的 Colab 笔记本。

数据科学家的 CSV 问题。

自从我们开始存储数据以来，CSV 就一直存在。它们与文本文件没有什么不同，只是 CSV 遵循可预测的逗号模式。

软件使用这些信息将数据集分成几列。专栏不是 CSV 文件本身的奇迹。

即使列标题和行在 CSV 文件中也没有区别。我们需要配置读取 CSV 的软件来选择标题和行号。

如果列的其余部分遵循不同的数据类型，一些软件足够智能地选择标题。但它们只是由某人编程的有根据的猜测。

简单在很多情况下都很有效。尤其是如果你不知道客户使用的是什么软件，CSV 是非常好的。分享然后忘记！

但是 CSV 并没有针对存储或性能进行优化。

我们可以把可访问性性能和文件大小想象成一个三角形的三个角。你调一个；另外两个自我调整。

图片由作者提供。

CSV 已经将可访问性节点提升到最大。它会降低性能和文件质量。在这篇文章的后面，我们将比较 CSV 和其他格式的文件大小、保存和加载时间。

CSV 的另一个缺点是当文本包含 Unicode 字符时。您可能需要显式地将编码参数设置为众多支持值中的一个。

这里有一个例子告诉你如何在熊猫身上设置编码。

df = read_csv('/path/to/file.csv', encoding = "ISO-8859-1")

如果您的数据集很大，而您不知道使用哪种编码器，那么您就有麻烦了。

我们需要一种存储文件元数据(如头和编码)的文件格式，它从磁盘读取和写入的时间最少，并且大小更小。

用泡菜代替怎么样？

Pickle 是一种 Python 对象存储格式。它不是为存储数据帧而设计的，但在数据帧上运行良好。

Pickle 还可以存储数据帧的头、行号和其他元信息。因此，如果您使用 Pandas 读取数据帧，引擎不需要花费太多时间来确定数据类型和标题。

Pickle 到磁盘和磁盘到 pickle 与内存到磁盘和磁盘到内存几乎相同。

磁盘上 Pickle 文件的大小可能会有所不同。在大多数情况下，它比 CSV 略大，因为它们存储了更多关于数据集的信息。但是，Pickle 也存储转换成字节流的数据。它可能会使大小小于基于文本的 CSV。

此外，当您使用 Python 时，您不需要其他安装就可以从 Pickle 中获益。

df.to_pickle("./path/to/file.pkl") # to write a dataframe as pickledf = pd.read_pickle("./path/to/file.pkl") # to read a pickled dataframe

在我们的出发三角中，pickle 文件放弃了一点可访问性，以获得性能和文件大小方面的好处。因为您只能从 Python 程序中读取 pickle 文件。如果您组织中的其他人正在使用 R、Excel 或其他软件，它们可能无法很好地工作。

酸洗可以解决文件存储的许多问题。但是，如果您愿意进一步缩小可访问性特征的范围，还有一个更好的方法。

对于数据科学家来说，Pickle 文件是一个理想的用例。

我们将在接下来的几节中讨论 CSV 和 Pickle 的强大替代方案。

然而，它们不能被完全抛弃。还没有！

因为 Pickle 文件是内存中对象的快照，所以存储经过训练的 ML 模型非常好。

例如，我们将机器学习模型及其权重存储为 pickle 文件。流行的库如 scikit-learn 和 Tensorflow 创建可选择的模型。

这里有一个张量流的例子。

import joblib
import tensorflow as tf

model = tf.keras.Sequential([
            tf.keras.layers.Input(shape=(5,)),
            tf.keras.layers.Dense(units=16, activation='elu'),
            tf.keras.layers.Dense(units=16, activation='elu'),
            tf.keras.layers.Dense(units=8, activation='elu'),
            tf.keras.layers.Dense(units=8, activation='elu'),
            tf.keras.layers.Dense(units=5, activation='softmax'),
        ])

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])model.fit(df['predictorrs'], df['labels'], epochs=200, batch_size=8)joblib.dump(model, 'classifier.pkl')

CSV 和泡菜的更好替代品

我使用 CSV 已经很长时间了。就像数据科学社区的其他人一样。然后腌制一段时间。如今，我更喜欢用其他二进制文件格式来存储数据。

尤其是其中的两个。羽毛 & 拼花。

羽毛文件格式

feather 文件格式是一种快速的、与语言无关的数据帧存储，适用于 Python (pandas)和 r。

Feather 针对低存储空间和高性能进行了优化。这使得它比 CSV 更难访问。

虽然 CSV 可以在任何能够理解文本的机器上运行，但 Feather 只能在 Python 和 r 上运行。我们需要手动安装它。

如果您使用 Python，可以从 PyPI 存储库中获取它。

pip install feather-format

r 程序员可以使用下面的命令直接从 Git 库安装 Feather。

devtools::install_github("wesm/feather/R")

一旦你安装了这个包，对你现有代码库的改变是最小的。

使用羽化格式相当简单。

Pandas 库内置了羽毛格式的方法。您可以使用 to_feather 和 read_feather 在磁盘上保存和加载数据。

# Change this
df = pd.read_csv(...)# To this
df = pd.read_feather(...) # Change this
df.to_csv(...)#To this
df.to_feather(...)

拼花文件格式

Parquet 是另一种二进制文件格式，它比使用文本文件更有优势。

Parquet 使用在 Dremel 论文中描述的记录粉碎和组装算法。它在列存储中高效地表示嵌套结构。

因此，处理大量嵌套的查询比基于文本格式的查询执行速度更快。

拼花地板的文件大小通常小于文本格式。

在熊猫身上使用拼花地板就像羽毛一样简单。

# Change this
df = pd.read_csv(...)# To this
df = pd.read_parquet(...)# Change this
df.to_csv(...)#To this
df.to_parquet(...)

对存储数据集的不同文件格式进行基准测试

我想亲眼看看。我想测试每种文件格式的各个方面。

所以我写了一个小剧本。它从公开可用的数据集中获取数据。然后，它从原始文件创建 1000 个不同的 10，000 行的文件。为此，脚本在熊猫数据帧上使用随机抽样。

然后，我们记录将所有这些文件写入磁盘所需的时间、磁盘上的文件大小，以及将所有这些文件读回内存所需的时间。

我们测量所有文件格式的上述三个值。这是结果。

拼花是最小型的文件格式。

不同文件格式的文件大小基准测试—图片由作者提供。

拼花文件比 CSV 小得多。它们甚至比羽毛锉还要小。

另一方面，JSON 是在磁盘上存储文件的最差格式。它占用的文件格式空间是 CSV 的两倍多。

就文件大小而言，Feather 略小，Pickle 比 CSV 占用更多的空间。

羽毛是读写最快的。

比较不同文件格式存储数据集的文件读/写性能—图片由作者提供。

羽毛的阅读表现令人印象深刻。它只需要 CSV 加载时间的一半。与 Feather 相比，即使是 Pickle 文件也要慢得多。

同样，JSONs 需要花费太多时间加载到内存中，因为它需要很大的磁盘存储空间。

羽毛在写作表现上也远胜 CSV。只有泡菜和羽毛的数量相对相似(仍然缓慢)。

最终考虑

如果你和其他人共享数据，并且你不确定他们是否安装了 Python 或者任何兼容的软件，那么使用 CSV 是可以的。

但在所有其他情况下，CSV 会严重伤害你。

如果您的主要目标是以非常低的成本存储数据，请使用 Parquet。它占用很少的磁盘空间，其读/写性能令人印象深刻。

如果您正在使用 Python 或 R，并且读/写性能是您的主要关注点，那么 Feather 要比 CSV 和 Pickle 好得多。它的体积也更小。

感谢阅读，朋友！在LinkedInTwitterMedium上跟我打招呼。

还不是中等会员？请使用此链接使成为的会员，因为，在不为你额外付费的情况下，我为你引荐赚取一小笔佣金。

arXiv 最佳—2022 年 2 月

原文：https://towardsdatascience.com/best-of-arxiv-february-2022-62c2aea3b802

Zeta Alpha 每月 ML 论文精选:强化学习、多模态、语言模型即服务、计算机视觉、信息检索等。

图片作者。

人工智能研究的世界已经全速进入 2022 年，过去几周的相关出版物和新闻数量可以证明这一点。让我们首先强调一些你不该错过的近期新闻:

Meta 的新超级计算机——AI 研究超级集群——宣布推出，是为了跟上大型机器学习模型日益苛刻的计算需求。这再次证明模特越来越多的趋势还远未结束。
PyTorch 满 5 岁！它已经成为最受欢迎的深度学习框架，不仅用于学术研究，还为当今的行业设定了标准。看看 Meta 的迈克·斯科洛普夫(Meta 的首席技术官)、Soumith Chintala (PyTorch 的联合创始人)和 Yann LeCun(不需要介绍)对它的反思。
FFCV 图书馆:一个计算机视觉加速数据加载系统，可以在你的模型训练中增加数据吞吐量。只需更换数据加载器和…🚀

来源:https://github.com/libffcv/ffcv

🔬研究

Zeta Alpha 监测人工智能研究的趋势，帮助你确定什么值得阅读。在它的帮助下，我们选择了 8 篇论文，这些论文体现了不同人工智能子领域的关键发展:自动强化学习(AutoRL)、多模态语言模型(LMs)、计算机视觉中的 conv nets vs . Transformers(CV)、无监督神经信息检索(IR)等。尽情享受吧！

1。自动强化学习(AutoRL):综述和公开问题

作者:Jack Parker-Holder，Raghu Rajan，Xingyou Song 等人

❓Why → 机器学习的主要目标之一是几个数据处理工作流和管道的自动化，允许非专家使用 ML 技术，因此像 AutoML 这样的主题很受欢迎。AutoRL 是强化学习世界中的模拟。

💡关键见解→ 本文概述了这一领域，提供了有用的分类法来统一各种 AutoRL 方法。这对 ML 实践者特别有用，因为 RL 词汇表与 ML 词汇表有很大不同，使得跨领域的思想交叉传播更加困难。

讨论的主题包括不同目标的优化技术(如超参数、任务设计、架构等。):

随机与网格搜索驱动的方法
贝叶斯优化
进化(和/或基于群体的)方法
元梯度
黑盒优化
学习 RL 算法，环境设计

来源:https://arxiv.org/pdf/2201.03916.pdf

虽然总是开箱即用的 RL 的“梦想”似乎仍然很遥远，但这似乎并没有阻止研究人员进入它。

另一篇最近关于强化学习和语言模型交叉的论文可能很有趣，那就是语言模型作为零射击计划者:为具体化代理提取可操作的知识。

2。作为零射击计划者的语言模型:提取具体化代理的可操作知识。

作者:黄、彼得阿贝耳、迪帕克帕沙克和伊戈尔莫达契。

❓为什么→ NLP 技术跨越到 ML 的其他领域已经是过去几年反复出现的主题。下面是当你使用像 GPT-3 这样的预训练语言模型(LM)来为代理构建动作序列时会发生的情况。它…起作用了！

💡关键见解→ 如果规模足够大并经过适当培训，大型 L:Ms 可以将高级任务分解为低级计划，而无需进一步培训(即仅使用冻结模型)。

然而，由自由形式的 LM 生成的计划可能是不可执行的，也就是说，可映射到一组现有的已知对象和动作。这就是作者建议引入从 LM 输出到有效动作的映射步骤的原因。这种映射由句子相似性转换器执行，该转换器在嵌入空间中找到最接近的有效低级动作。

来源:https://arxiv.org/pdf/2201.07207.pdf

虽然结果并不惊天动地，但它们证明了冻结的 LMs 包含了从高级指令中提取低级行动计划所需的信息。在这里你可以观看一些演示并检查他们的代码。

3。CM3:互联网的因果掩蔽多模态模型

阿尔门·阿加贾尼扬等人

❓为什么→ 多模态已经成为人工智能中一个快速发展的子领域，特别是自从巨大的数据饥渴变压器出现以来。虽然对于现有的基准来说，它们的表现可以说是乏善可陈，但在可预见的未来，关于该主题的研究数量肯定会不断增加。

💡关键见解→ 这项工作的作者巧妙地设计了一个预处理任务，对包含文本和图像的 HTML 数据进行操作。但是，如何将图像编码成可以提供给模型的标记呢？与 OpenAI 的 DALLE 有些类似，他们使用 VQVAE-GAN 学习图像补丁的量化表示，可以将其视为离散的符号字典，就像常规的文本标记一样。

对于训练，他们使用从左到右和双向语言建模的组合，整个事情的规模很大，但对于今天的标准来说还不算大:1TB 的训练语料库，最大模型的最大参数为 13B。

他们在零镜头设置中的单峰和多峰任务上对其 CM3 进行了基准测试，显示了在图像字幕、图像生成、零镜头摘要、实体链接和其他几个 NLP 任务上的稳定(甚至在某些情况下是 SOTA)性能。

来源:https://arxiv.org/pdf/2201.07520.pdf

最近关于多模态人工智能的类似工作包括: data2vec:来自脸书的语音、视觉和语言自我监督学习的通用框架(或参见他们的博客文章)和用于监督跨模态检索的视觉语言预训练模型的综合实证研究。

4。网络是你的牡蛎——知识密集型自然语言处理对一个非常大的网络语料库

亚历山大·皮克图等人

❓为什么 →当 GPT-3 在 2020 年 5 月问世时，一个常见的批评是，它对 Covid“一无所知”，因为它的训练语料库是在疫情开始之前创建的。包括这些知识将需要用新数据训练模型，无论是为了微调还是从头开始，这是非常昂贵的。让语言模型访问知识语料库是最近的一项发展，这使它们能够成为更高效的学习者和更准确的事实，增加了能够更新知识而无需重新训练神经网络的好处。

💡关键见解 →知识密集型自然语言处理任务被定义为在不查阅知识语料库(例如，一本书、网络)的情况下，人类无法解决的任务。本文提出了一个新的基准，精确地测量 LMs 在这方面的表现。它建立在现有的 KILT 基准之上，主要基于维基百科语料库来构建事实检查、实体链接、槽填充、开放域 QA 和对话生成任务。

随着越来越多的检索增强语言模型被提出，拥有一个可靠的评估系统来比较它们变得越来越重要。这种模型的一些最近的例子包括 WebGPT:具有人类反馈的浏览器辅助问答(open ai)通过从数万亿个令牌中检索来改进语言模型(deep mind)人工制品检索:具有知识库访问的 NLP 模型概述(萨尔州大学)或 LaMDA:对话应用的语言模型(谷歌)。

来源:https://arxiv.org/pdf/2112.09924.pdf

5。LaMDA:对话应用的语言模型

Romal Thoppilan 等人

❓Why → 尽管文本生成技术取得了巨大的进步，但你在那里发现的许多聊天机器人仍然很烦人，没什么用处。现代语言模型如何改善对话式人工智能？这是谷歌的最新提议。

💡关键见解→ 这实际上是语言模型的另一个实例，它与知识库交互以回答用户的查询，基本上是一个检索增强的 LM。按照通常的谷歌方式，他们训练了一个庞大的 137B 模型，并使用人类的判断来评估它的敏感性和特异性等指标。不出所料，性能会随着规模的扩大而不断提高，不会饱和。

在概念层面上，这种方法很简单:使用 LM 的两种变体，LaMDA-Base 是一种在对话中训练的常规 LM，LaMDA-Research 是一种 LM 的变体，它被训练成与作者称为工具集(ts)的外部知识系统进行交互。这个工具集不仅包括一个信息检索系统，还包括一个用于算术查询的计算器和一个翻译器。

LaMDA-Base 和 LaMDA-Research 通过传递它们的输入并连接它们来保持全局上下文进行交互(见下图)。当然，这个模型成功的关键之一是作者管理的高质量训练数据集，除了通常的大规模自我监督预训练之外，它还包括超过 40k 个带注释的对话交互。

来源:https://arxiv.org/pdf/2201.08239.pdf

其他相关近期工作:会话信息检索的神经方法和会话信息搜索。

6。语言模型即服务的黑盒调优

孙天祥等

❓Why → 随着大型变压器成为许多研究领域的标准，它们的使用方式也面临着挑战。不久以前，人们可以简单地下载一个几百兆字节大小的模型检查点，并在任何你想去的地方运行它。但是当检查点的大小接近 1tb 时…它需要在几台机器上运行，下载是不可行的！此外，对于 OpenAI 这样的公司来说，这样的大型模型已经成为非常有价值的知识产权，是他们提供服务的支柱，也是他们不愿意放弃的明显竞争优势。因此出现了作为服务的 ML 模型，它将 ML 模型公开为一个黑盒 API，在给定一组输入的情况下返回预测。现在，您能调优这样一个只能作为黑盒 API 访问的模型吗？

💡关键见解→black box API 的用户可以使用无导数算法调整他们的系统(记住，我们只能访问输入和输出，不能访问梯度！).特别是，他们使用进化算法在提示和超参数的空间中进行搜索，有效地学习优于手动提示和上下文学习的提示，这意味着在提示中包括训练示例，就像 GPT-3 对少量学习所做的那样。在某些情况下，他们的方法优于基于梯度的方法，如即时微调！

来源:https://arxiv.org/pdf/2201.03514.pdf

优化纯界面模型领域的另一项相关工作是内存辅助提示编辑，以改进部署后的 GPT-3。

7。面向 21 世纪 20 年代的 conv net

刘庄等人

❓为什么 →深度学习在 2010 年代初的强劲势头在很大程度上可以归功于 AlexNet 在 2012 年 ImageNet 挑战赛中的巨大成功。从那以后的很多年里，卷积——这种神经网络的主要组成部分——独自统治了计算机视觉的世界。然而，随着变压器及其方便的可扩展性的引入，将它们应用于 CV 的方法——如斯温 transformer⁴——变得越来越流行；可以说威胁到了回旋保持了这么久的王冠。

💡关键见解→ 回旋仍在摇摆。

本文认为，通过进一步优化，ConvNets 仍然比变压器有优势，从而产生了流行的 ResNets 的现代版本，与类似的基于变压器的架构相媲美。这些变化包括抛弃 BatchNorm 而支持 LayerNorm，从 ReLU 切换到 GELU，或者改变卷积核的大小等等。差不多就是这样，他们在 ImageNet 上的结果和缩放规则略高于基于 transformer 的架构。嗯，可能要到下周另一篇论文出来…

架构之战仍在继续，如果有一点是明确的，那就是人工智能领域肯定会从竞争中受益！

来源:https://arxiv.org/pdf/2201.03545.pdf

8。GLIDE:使用文本引导扩散模型实现照片级真实感图像生成和编辑

亚历克斯·尼科尔、普拉富拉·达瑞瓦尔、阿迪蒂亚·拉梅什等人

❓为什么 →自 2014 年 GANs 推出以来，图像生成一直是深度学习的一个非常养眼的应用。然而，最近，诸如使用 VQ-VAE (例如达尔和)的自回归生成和扩散模型等方法正在成为可行的甚至更好的替代方法。

💡关键见解→ 简而言之，扩散模型通过在像素网格上迭代添加可微分噪声来生成图像，最终成为真实的图像。本文提出了一种在给定文本提示的情况下基于扩散模型生成和编辑图像的方法，该扩散模型非常好，击败了著名的 OpenAI 的 DALL E。然而，这些模型仍然存在一些缺点，例如生成每个图像所需的计算成本，这仍然阻止了它们在许多应用中得到广泛使用。

来源:https://arxiv.org/pdf/2112.10741.pdf

9。通过对比预训练嵌入文本和代码

阿尔温德·尼拉坎坦、徐涛等人

❓为什么→ 神经信息检索是深度学习游戏的晚期，在某些方面仍然不如 BM25 等 20 多年前的算法！这个等式的一个关键部分是对大量标记数据的依赖:今天所有成功的神经检索方法都严重依赖于标签，如来自马尔科女士数据集的标签。这些模特在完全没有监督的情况下能训练出来吗？在过去的几个月里，出现了希望的迹象！

💡关键见解→ 这是 OpenAI 的一个提议，以完全自我监督的方式学习文本的文本表示。这些表示(即嵌入)旨在成为包括信息检索在内的各种任务的可靠执行者。工作原理非常简单:使用相邻的文本片段作为正的伪查询文档对和批内否定。非常大批量必须我加。然而，并非所有闪光的东西都是金子:虽然完全无人监管的性能是可靠的，但你可以以低得离谱的成本使用只在几个公开可用的标签上微调的小模型来实现更好的性能，正如 SBERT 的创始人 Nils Reimers 已经展示的。

总之，对于无监督的神经信息检索和表示学习来说，这是重要的一步，但不是像一些标题所暗示的那样，是一个解决所有问题的嵌入 API。这是只能通过付费 API 访问的模型的又一个例子，我们期望这样的例子会变得更加普遍。

来源:https://arxiv.org/pdf/2201.10005.pdf

最近其他类似的关于无监督信息检索的工作是使用对比学习进行无监督密集信息检索，在没有监督的情况下学习检索段落

10。DeepSpeed-MoE:推进混合专家推理和训练，为下一代人工智能量表提供动力 | 网站

Samyam Rajbhandari 等人

❓为什么→ 在过去的一年里，混合专家(moe)已经成为扩展大规模语言模型的首选策略。关键概念很简单:在推理过程中，只通过模型中的子路径传递输入，这样在每一步中只使用一小部分模型参数。这种系统的实现细节仍然是混乱的，并且包括关于密集模型的严重折衷，例如推理速度。

💡Key insights → DeepSpeed-MoE(即将在 GitHub 上开源)是微软最新版本的 DeepSpeed 库，旨在使分布式深度学习训练变得简单高效，它是这项工作的实现骨干。

作者展示了 MoEs 与密集的同类相比是如何闪耀的:更有效的训练——大约 5 倍——和更好的参数效率。

本文还深入探讨了什么样的设计选择能让 MoEs 学得更好。例如，浅层的专家多一些好，还是深层的专家多一些好？要增加模型容量，应该增加每个专家的容量还是增加专家的数量？虽然这些问题还没有绝对的答案，但本文根据经验探索了这些设计选择的权衡，将它们包装在通用 PR-MoE(金字塔剩余 MoE)下。它们的 PR-MoE 的基本结构如下图所示，包括不同的“专家宽度”以及剩余的 MLP 连接。

虽然 moe 仍然不是主流，但是如果实现和设计的复杂性得到解决，它们有可能成为下一代大规模模型的标准。

来源:https://arxiv.org/pdf/2201.05596.pdf

我们的月度评选到此结束；如果你想了解最新的研究，请在 Twitter @zetavector 上关注我们，继续关注下一篇！

参考文献:

1。Patrick Esser、Robin Rombach、bjrn Ommer 于 2021 年出版的《驯服高分辨率图像合成的变形金刚》

2。Aditya Ramesh 等人于 2021 年发表的“零镜头文本到图像生成”

3。法比奥·彼得罗尼等人的《苏格兰短裙:知识密集型语言任务的基准》，2020 年

4。“Swin 变压器:使用移位窗口的分层视觉变压器”，刘泽等人，2021 年

两全其美:来自 Python 的自动化和动态 SQL 查询

原文：https://towardsdatascience.com/best-of-both-worlds-automated-and-dynamic-sql-queries-from-python-5b74a24501b0

通过 SQL 和 Python 集成将自动化带到新的高度

现实世界的分析应用程序通常使用各种编程语言构建，每种语言都需要直接访问存储在数据库中的数据。最终目标是创建一个从数据提取(使用 SQL)到模型开发，再到持续性能监控的自动分析管道。通过独立的平面文件传输数据的时代已经过去了！

SQL 和关系数据库垄断了几十年，作为分析的全明星脚本语言，Python 对 SQL APIs 有很好的支持，允许用户直接拉取数据。在这篇博客中，我将分享 3 种方法以及集成 SQL 和 Python 来创建无缝分析工作流的用例。

分析数据集-在线零售数据

Python 连接关系数据库有两种方式:(1)使用 ODBC(开放式数据库连接)作为连接引擎，访问托管在远程 SQL server 中的数据库；(2)使用 ORM(对象关系映射器)作为位于最终用户和数据库之间的抽象层，这提供了更多的灵活性。

在这个练习中，我们将在 MS SQL 服务器中实现 ORM 方法。我们正在处理的数据集是在线零售数据；包含来自英国在线零售商的各种交易的纵向数据集。

正如我们所看到的，每个记录由产品、数量、价格/单位和客户、县信息组成。

先决条件-将 Python 连接到 SQL server

Python {urlib} +

尽管{ SQLAlchemy }在数据科学家和程序员中非常受欢迎，但以理想的形式获得连接字符串可能很棘手。要用 Python 连接 SQL，我们需要我们的驱动程序名、服务器名和数据库名。这里演示了如何为我的本地服务器localhost\SQLEXPRESS和名为master的数据库指定这些参数，

加入我们的 YouTube 社区🎦 【数据说话带吉】 😄

用例 1:用 Python 编写的简短查询

建立了 SQL 连接引擎后，我们可以编写一个简短的查询，使用{ 熊猫 }将数据拉入 Python，

在本例中，我们提取了 2010 年 12 月 1 日和 2011 年 1 月 1 日之间两种产品——巧克力热水瓶和灰心热水瓶——的所有交易，然后得出每种产品按日期计算的总销售额。以下是返回的数据框:

现在，作为我们分析工作流程的一部分，让我们创建一个可视化图，例如纵向折线图，向我们的利益相关者展示趋势。

用户案例#2:读取外部的。sql 文件

我们刚刚经历的是将 SQL 纳入整个分析管道的最简单方法。然而，在我们的实践中，用 Python 编写或复制/粘贴每一个查询是低效的，甚至是不可能的。原因是双重的:

现实世界的项目通常需要通过连接多个表和视图来进行长达数千行的查询；
从可重用性的角度来看，如果我们经常需要更新或修改这些查询，维护和调试代码将会非常困难。

那么解决办法是什么呢？阅读现存的不是很好吗？sql 文件直接导入 Python？出于演示的目的，让我们将上面的查询保存为一个. sql 文件*OnlineRetailPull.sql*。

现在，诀窍是扫描这个查询文件，就像它是一个字符串对象一样:

输出OnlineRetailData与上面用例 1 的返回完全相同。

用例 3:来自应用程序的动态查询

现在，让我们回到最初的目标——将数据提取整合到我们的应用程序中，对用户的输入做出反应。我们将使用 Python{streamlit }和创建一个小 app，探索如何动态运行 SQL 查询。

第一步 :通过添加占位符来修改我们的查询。在本练习中，我们定义了两个交互变量 {date} 和 {product}，

第二步 :设置我们的streamlitapp，根据用户选择可视化产品销售趋势，

这里的技巧是在我们的查询和应用程序的用户选项中的占位符使用相同的对象名称(即日期和产品)。这样， f 字符串可以自动接受用户选择的任何值。

运行此应用程序让我们…

最后的话

你有它！动态集成 SQL 和 Python 的三个不同用例。希望这篇文章能给你一些新项目的灵感，感谢阅读！

想要更多数据科学和编程技巧？使用 我的链接 注册 Medium，获得我所有内容的全部访问权限。

还订阅我新创建的 YouTube 频道 《数据与吉谈》 😀

进一步阅读

*</6-sql-tricks-every-data-scientist-should-know-f84be499aea5> https://levelup.gitconnected.com/6-hilarious-programmers-data-scientists-jokes-to-kick-start-2021-187f86dd6a4c *

计算和解释模型特征重要性的最佳实践

原文：https://towardsdatascience.com/best-practice-to-calculate-and-interpret-model-feature-importance-14f0e11ee660

以随机森林模型为例

来源: Unsplash (归功于凯文·Ku)

在机器学习中，大多数时候你希望模型不仅准确，而且可以解释。一个例子是客户流失预测-除了知道谁会流失，了解哪些变量在预测流失以帮助改进我们的服务和产品方面至关重要。

Scikit-learn 等流行的机器学习包为模型解释提供了特征重要性的默认计算。然而，我们经常不能相信那些默认的计算。在本文中，我们将使用来自 Kaggle 的著名的泰坦尼克号数据和一个随机森林模型来说明:

为什么您需要一个健壮的模型和排列重要性 分数来正确计算特性重要性。
为什么您需要理解特性的相关性来正确解释特性的重要性。

本文中描述的实践也可以推广到其他模型。

计算要素重要性的最佳实践

默认特征重要性的问题是

我们将使用一个示例来展示 Scikit-learn 中为随机森林提供的默认基于杂质的特征重要性的问题。默认特征重要性是根据杂质的平均减少量(或基尼系数重要性)计算的，它衡量每个特征在减少不确定性方面的有效性。参见这篇伟大的文章以获得特性重要性计算背后的数学的更详细的解释。

让我们从 Kaggle 下载著名的泰坦尼克号数据集。该数据集包含泰坦尼克号上 1309 名乘客的信息以及他们是否幸存。下面是对包含的列的简要描述。

首先，我们加载数据，并将其分为预测集和响应集。在预测器集合中，我们添加了两个随机变量random_cat和random_num。因为它们是随机生成的，所以这两个变量应该具有非常低的特征重要性分数。

其次，我们对数据进行一些简单的清理和转换。这不是本文的重点。

第三，我们建立一个简单的随机森林模型。

RF train accuracy: 1.000.RF test accuracy: 0.814

该模型在训练数据上略有过度拟合，但在测试集上仍有不错的性能。现在让我们使用这个模型来说明默认特性重要性计算的一些缺陷。让我们来看看默认的特性重要性。

从默认的特性重要性中，我们注意到:

与random_cat相比，random_num具有更高的重要性分数，这证实了基于杂质的重要性偏向于高基数和数字特征。
非预测性random_num变量被列为最重要的特征之一，这没有意义。这反映了当您有一个过拟合模型时默认特征重要性不准确。当模型过度拟合时，它会从训练集中拾取太多的噪声，从而无法对测试集做出一般化的预测。当这种情况发生时，特征重要性是不可靠的，因为它们是基于训练集计算的。更一般地说，只有当您有一个可以合理预测的模型时，查看特性的重要性才有意义。****

救援的排列重要性

那么我们如何恰当地计算特性的重要性呢？一种方法是使用排列重要性分数。它通过以下步骤计算:

训练一个基线模型，并在验证集上记录分数(在这个例子中我们使用准确性)。
重新排列一个特征的值，使用模型再次进行预测，并计算验证集的得分。该特征的特征重要性是 1 中的基线和 2 中的置换得分之间的差异。
对所有特征重复该过程。

这里我们利用 2019 年添加到 Scikit-learn 包中的 permutation_importance 函数。当调用该函数时，我们设置 n_repeats = 20，这意味着对于每个变量，我们随机洗牌 20 次，并计算准确度的下降，以创建箱线图。

我们看到sex和pclass显示为最重要的特征，并且random_cat和random_num不再具有基于测试集上排列重要性的高重要性分数。箱线图显示了具有 N 次重复排列(在我们的例子中 N = 20)的准确度分数降低的分布。

让我们也计算训练集上的排列重要性。这表明random_num和random_cat获得了比在测试集上计算时显著更高的重要性排名，并且特性的排名看起来与测试集非常不同。如前所述，这是由于模型的过度拟合。

你可能想知道为什么 Scikit-learn 仍然包含默认的特性重要性，尽管它并不准确。RFs 的发明者 Breiman 和 Cutler 指出，这种“将森林中所有树木的每个变量的基尼系数减少相加的方法给出了一个快速的变量重要性，这通常与排列重要性度量非常一致。”所以缺省值意味着置换重要性的代理。然而，正如施特罗布尔等人在随机森林变量重要性测量的偏差中指出的，“布雷曼的原始随机森林方法的变量重要性测量……在潜在预测变量的测量范围或类别数量发生变化的情况下是不可靠的。”

稳健的模型是获得准确重要性分数的先决条件

我们已经看到，当模式过度拟合时，从训练集和预测集中生成的特征重要性可能会非常不同。让我们通过设置 min_samples_leaf = 20 而不是 1 来应用某种程度的正则化。

RF train accuracy: 0.810RF test accuracy: 0.832

现在让我们再次看看特性的重要性。修复过度拟合后，根据训练集和测试集计算的特征重要性看起来非常相似。这给了我们更多的信心，一个健壮的模型给出了准确的模型重要性。

另一种方法是计算删除列重要性。这是计算特征重要性的最准确的方法。这个想法是用所有预测值计算模型性能，去掉一个预测值，然后观察性能的下降。特性越重要，我们看到的模型性能的下降就越大。

考虑到删除列重要性的高计算成本(我们需要为每个变量重新训练一个模型)，我们通常更喜欢排列重要性分数。但这是验证排列重要性的一个很好的方法。这两种策略的重要性值可能不同，但特征重要性的顺序应该大致相同。

特征的排序类似于置换特征，尽管幅度不同。

解释特性重要性的最佳实践

特征相关性的挑战

在我们有了一个健壮的模型并正确地实现了正确的策略来计算特性重要性之后，我们就可以前进到解释部分了。

在这个阶段，相关性是我们解释特征重要性的最大挑战。到目前为止，我们所做的假设分别考虑了每个特性。如果所有的特征都是独立的，没有任何关联，那就很容易解释了。但是，如果两个或多个要素共线，将会影响要素重要性结果。

为了说明这一点，让我们使用一个极端的例子，复制列性别来重新训练模型。

RF train accuracy: 0.794
RF test accuracy: 0.802

当我们添加了一个没有添加任何信息的特征时，模型性能会稍微下降。

我们现在看到性特征的重要性现在分布在两个重复的性列之间。如果我们给复制的列添加一点噪声会发生什么？

让我们试着给性别添加 0-1 范围内的随机噪声。

sex_noisy现在是最重要的变量。如果我们增加噪声的数量会发生什么？让我们将随机变量的范围增加到 0–3。

现在我们可以看到，随着更多的噪音加入，现在sex_noisy不再是排名第一的预测因素，性别又回到了首位。结论是在随机森林模型上计算的排列重要性在共线变量上传播重要性。分享的数量似乎是两者之间有多少噪音的函数。

处理共线要素

我们来看看特征之间的相关性。我们使用 rfpimp 包中的 feature_corr_matrix，它给出了 Spearman 相关性。Spearman 相关与标准 Pearson 相关的区别在于，Spearman 相关首先将两个变量转换为排名值，然后对排名变量运行 Pearson 相关。它没有假设变量之间的线性关系。

feature_corr_matrix(X_train)

from rfpimp import plot_corr_heatmap
viz = plot_corr_heatmap(X_train, figsize=(7,5))
viz.view()

pclass与fare高度相关，这并不奇怪，因为舱位等级取决于你支付的费用。在业务中，我们经常在预测模型中使用多个相互关联的特征。从前面的例子中，我们看到，当两个或多个变量共线时，根据信噪比，计算的重要性在共线变量之间共享。

策略 1:组合共线特征

解决这个问题的一种方法是将彼此高度共线的特征组合起来形成一个特征族，我们可以说这个特征族一起排列为 X 最重要。为此，我们将使用 rfpimp 包，它允许我们一次混洗两个变量。

策略 2:删除高度共线变量

如果某个特征依赖于其他特征，这意味着可以使用所有其他特征作为独立变量来准确预测该特征。模型的 R 越高，特征的依赖性越强，我们就越有信心移除变量不会牺牲准确性。

第一列 dependency 显示了依赖分数。使用其他特征完全可预测的特征将具有接近 1 的值。在这种情况下，我们可能会丢弃pclass和fare中的一个，而不会影响太多精度。

最后

一旦我们 1)有了一个健壮的模型，并实现了正确的策略来计算排列的重要性，2)处理了特性的相关性，我们就可以开始精心制作我们的消息来与利益相关者分享。

对于人们经常问的问题“特性 1 比特性 2 重要 10 倍吗？”，这时你可能明白了，只有当所有的特征都是独立的或者相关性很低的时候，我们才有信心进行论证。但在现实世界中，这种情况很少发生。建议的策略是将功能分配给高、中和低影响层，而不要过于关注确切的影响程度。如果我们需要显示特征之间的相对比较，请尝试将共线特征分组(或删除)到熟悉的特征，并基于分组进行解释，以使论点更加准确。

你可以在我的 Github 上找到这篇文章的代码。

参考

[1] 小心默认随机森林重要性

[2] 排列重要性与随机森林重要性(MDI)

[3]sci kit-Learn 机器学习模型的特征重要性

[4] 决策树、随机森林的数学特性在 Scikit-learn 和 Spark 中的重要性

[5] 以随机森林为例解释特征重要性

除特别注明外，所有图片均为作者所有。

建立对数据信任的最佳实践

原文：https://towardsdatascience.com/best-practices-for-building-trust-in-your-data-dda32b84e70e

如何让你的利益相关者停止怀疑和质疑

迪伦·吉利斯在 Unsplash 上的照片

有多少次你收到来自业务利益相关者的懈怠信息，说仪表板坏了，数据一周没有更新，或者某些数字看起来非常错误？你看不到我，但我站得很高，手臂直直地举在空中。

这种情况已经发生了太多次了。这是为什么呢？因为对我们的旧数据堆栈缺乏信任。利益相关者有太多的问题，数据集被破坏，无法在他们需要时看到他们需要的洞察力。

构建现代数据堆栈时，您需要从一开始就慢慢建立信任。您需要实施正确的测试和检查，以确保数据符合您的期望。你需要开诚布公地对待你正在着手的计划，以及在这个过程中可能出错的事情。在做这些事情的同时，你还必须教育你的消费者，而不是当着他们的面把最终产品拍下来，告诉他们一切都很好。

设置测试，以便从源头提醒您数据质量问题。

测试和监控原始数据以及数据模型是检测数据中任何主要问题的关键。我喜欢用两个免费工具来做这件事。

dbt 测试

dbt 测试内置于任何 dbt 项目中。它们允许您检查空值、主键和某些指定的值。您可以将这些添加到您的基础模型中，以在源位置检查您的数据，或者添加到您的核心数据模型中，以确保您得到了您期望的结果。

您只需在定义 dbt 模型的 yaml 文件中添加“tests”块。dbt 将在您的模型运行时运行这些检查，当模型中的某一列不符合您设置的检查时，会向您发出警告。

作者图片

re _ 数据指标

我第一次发现 re_data 是在我寻找一种方法来监控每天摄入的数据量的时候。我需要一个适当的检查来确保我的所有数据都如预期的那样被接收。re_data 是一个开源的 dbt 包，允许您在列和表级别进行监控。它包括行数、新鲜度和空计数等指标。

作者图片

对于某些指标，re_data 会计算平均值，然后使用指定的 z 得分来检测数据中的异常。当数据量超出该 z 值时，您将收到警报。你可以通过查看这个帖子来了解更多关于如何设置这些的信息。

抢先股东一步。

如果出了问题，在他们自己弄清楚之前说点什么！完全透明会大有帮助。如果你在事情破裂时开诚布公，你们会建立更好的关系，而不是试图掩盖问题，让他们自己发现。

这与设置测试以从源头上提醒您问题是齐头并进的。如果您在下游的任何事情受到影响之前收到警报，您可以找到根本原因并修复问题，或者您可以在其他团队使用下游模型或仪表板之前让他们知道。

在您的组织内创造透明度是重中之重。我知道当一切都不顺利的时候会很沮丧。从头开始构建新的数据文化很容易隐藏所有的问题。但是，这需要时间。你可以建立信任，同时也要传达这不是一个一蹴而就的过程。

教育你的数据和事情是如何做的。

甚至对业务团队进行数据流程培训也有助于建立数据的透明度和可信度。如果你能帮助他们理解你试图解决的所有问题，当他们的仪表板坏了时，他们可能会更感同身受。

这幅冰山图解释了数据团队的工作，再准确不过了。

作者图片

业务团队知道他们认为我们在做什么，但通常与我们实际做的相差甚远。所以让他们看看你到底在做什么！与他们分享你的未来路线图和目标。

我们最近在 Slack 上开设了一个洞察频道，公司内部的任何人都可以加入。在这里，我们分享了我们的路线图和每个计划背后的为什么。想想你的最终用户和他们关心的。如果你以一种对他们重要的方式来看待事情，他们会在整个现代化过程中更加宽容。

在与业务用户分享见解时，您应该记住什么？

解决当前的问题
解释为什么与它们的关系
用外行的话来说；他们可能不明白什么是仓库或管道。相反，使用诸如“数据存储在哪里”和“数据如何移动”这样的短语。

结论

在利益相关者和您的数据之间建立信任就像在任何关系中建立信任一样。一旦这种信任被打破，就很难重新建立起来。通过测试、透明度和教育，从一开始就慢慢地建立对数据的信任。这将创造开放和诚实的沟通，并在出现任何问题之前为问题留出空间。

与我一起阅读 Substack 上的独家分析工程文章以及双周简讯，重点介绍该领域的最佳资源和主题。

向 ONNX 导出神经网络的最佳实践

原文：https://towardsdatascience.com/best-practices-for-neural-network-exports-to-onnx-99f23006c1d5

Artem Sapegin 在 Unsplash 上拍摄的照片。

ONNX 是一种开放格式，用于表示机器学习模型。ONNX 定义了一组通用的运算符——机器学习和深度学习模型的构建块——和一种通用的文件格式，使 AI 开发人员能够将模型与各种框架、工具、运行时和编译器一起使用。

— onnx.ai

为什么要导出到 ONNX？

将您的模型导出到 ONNX 有助于您将(经过训练的)模型从项目的其余部分中分离出来。此外，导出还避免了对 python 解释器、框架版本、使用的库等环境的依赖。导出的 ONNX-model 可以存储模型的架构和参数。这意味着向您的同事发送一个文件来交换您的模型就足够了。

出口

我们的经验表明，出口 PyTorch 模型更容易。如果可能的话，选择 PyTorch 源，并使用内置的torch.onnx模块进行转换。或者，您可以使用较新的独立onnx python 包(在下面的代码示例中，只需用onnx替换torch.onnx)。

来自 PyTorch

PyTorch 模型只能以编程方式导出:

请注意，PyTorch 在运行时计算计算图，因此转换引擎需要一批正确的形状(数据在大多数情况下可以是随机的)，它将通过网络来理解架构。torch.onnx使用torch.jit.trace找到您的数据通过网络的路径。

最佳实践:

小心TracerWarnings。这可能表明追踪器无法跟踪您的批次。
如果您在运行时做出路由决策，请确保使用一个批处理/配置来处理您尝试导出的所有路由。
如果你需要做路线决定，你应该在张量上做。tracer 找不到 Pythons 的默认类型。
如果您正在使用 torchhub 模型，请检查它们是否提供了一个exportable参数(或类似的)来替换不兼容的操作。

来自 TensorFlow (1/2/lite/js/tf。Keras)

我们推荐微软[tf2onnx](https://github.com/onnx/tensorflow-onnx)包用于 TensorFlow 模型的转换。在 ONNX 导出之前，必须将模型存储为 TensorFlows 支持的文件格式之一。支持的格式包括saved model、checkpoint、graphdef或tflite。

将保存的模型文件导出到 ONNX:

python -m tf2onnx.convert --saved-model tensorflow-model-path --output model.onnx

这是为 tflite 所做的事情(或者使用 tflite2onnx ):

python -m tf2onnx.convert --opset 13 --tflite tflite--file --output model.onnx

对于其他格式，您需要提供输入和输出张量的名称。tf2onnx 将使用它们来跟踪网络。提供错误或不完整的标签列表可能会导致导出损坏。如果不知道模型的输入和输出节点名，可以使用summary _ graphtensor flow 实用程序。以下是安装和使用它的方法:

或者，从显著位置检查源项目或询问原作者。对于下面的例子，我们假设有两个名为input0:0,input1:0的张量流输入和一个名为output0:0的输出。

对于检查点格式:

python -m tf2onnx.convert --checkpoint tensorflow-model-meta-file-path --output model.onnx --inputs input0:0,input1:0 --outputs output0:0

对于 graphdef 格式:

python -m tf2onnx.convert --graphdef tensorflow-model-graphdef-file --output model.onnx --inputs input0:0,input1:0 --outputs output0:0

注意:导出供重用的模型(如 TensorFlow Hub 模型)不可使用summarize_graphs进行分析，可能根本无法导出。

潜在的出口障碍

ONNX 协议或所使用的转换器可能不支持源模型的所有操作。

可能的解决方案:

检查是否有更新的操作集版本 (opset)支持您的相关操作。
检查不支持的操作是否可以被支持的操作替换，例如，通常用ReLU替换Hardswish或SiLU激活(从 opset 11 开始)。
如果您的转换器没有映射该操作，但 ONNX 协议支持该操作，请实现映射或尝试不同的转换器。
如果 ONNX 协议不支持该操作，请尝试使用支持的操作重写您的操作，或者使用支持的操作实现映射。另外，考虑向 ONNX 提交一份 PR。

验证导出的模型

我们建议使用 PyTorch 加载模型，并使用内置的验证引擎。

该代码块将只验证模式。这并不保证您的架构是完整的，也不保证所有的参数都被(正确地)导出。因此，我们建议您在几个样本上运行推理，并将它们与您原始框架的推理进行比较。请注意，由于导出过程和潜在的不同执行框架，可能会略有不同。要使用推理，请确保安装带有pip的onnxruntime python 包或您的 python 包管理器。

此外，您可以通过使用像 Netron 这样的外部工具可视化导出的模型来运行健全性检查。Netron 还允许您浏览存储的参数。请记住，转换器可能会根据需要减少或扩大操作，因此可能会触及原始架构。注意: Netron 在加载大型模型时可能会有问题。

至理名言

无论您是否选择 ONNX，都要考虑发布您训练好的模型，尤其是如果您正在准备一份科学出版物。这有助于他人轻松复制你的发现，也为他们的项目提供了一个良好的开端。

这项工作得到了德国巴登-符腾堡州(MWK)科学、研究和艺术部的部分资助，资助项目为 32–7545.20/45/1机器学习应用的质量保证(Q-AMeLiA) 。

组织 Synapse 工作区的最佳实践

原文：https://towardsdatascience.com/best-practices-for-organizing-synapse-workspaces-977fe14b1fdb

对于简化的数据分析工作流，需要记住一些注意事项

Azure Synapse Analytics 原名 Azure SQL Data Warehouse，是一款具有企业数据仓库功能的大数据分析解决方案。它为不同的工作负载提供不同类型的计算环境。最常见的是 SQL compute，它有两种风格:无服务器和专用。另外两个计算选项是 Spark 和 Data Explorer(时序)。数据工程师可以根据自己的业务需求选择计算环境。

工作空间考虑和配置

计算环境依赖于一个“主”存储帐户，并在一个工作区的边界内一起管理，该工作区是一个集中处理所有工件的地方。这些工件可以是 SQL 脚本、笔记本、拼花文件和数据库。在为大规模环境规划 Azure Synapse Analytics 部署时，有一些常见的决策点会影响您如何创建和组织 Synapse 工作区:

团队结构和职责:在给定用例、数据分离或成本管理需求的情况下，您的数据工程团队在功能项目上的组织和协作方式。职能界限和灵活性问题会导致团队分离，从而产生更多的工作空间。
发布工作流:您的开发和发布工作流可能需要额外的环境:开发、测试和生产的分离。
区域:您的数据的位置以及您需要为其提供分析解决方案的受众。这种区域界限可能导致实施更多的工作空间。
安全性:所有权、安全性或法律界限可能会迫使团队相互分离。比如有些数据是永远不允许其他团队看到的。

在实施多个工作空间时，您需要在成本管理、生产效率和管理复杂性之间找到平衡。这种平衡可能导致不同的解决方案模式。例如，当活动仅与实验或 R&D 相关时，您可以选择只使用一个工作空间。这种模式减少了你的 Azure 足迹，降低了你的成本。另一种解决方案模式是为每个职能领域或项目创建工作区，这简化了协作、成本报告和预算要求。例如，一个包含四个不同工作负载的设置可能会创建 12 个工作区实例，每个工作负载都需要一个发布工作流。

多工作区单湖拓扑

另一个重要的驱动因素是工作和共享数据方式的凝聚力和效率。当您的团队有不断共享大型数据集的趋势时，您应该考虑多工作区单湖拓扑。

多工作区-单湖拓扑(约万·波波维奇)

这个模式首先由 Jovan Popovic 描述，它极大地简化了管理、共享和安全配置。基本思想是，您有一个 Azure 数据湖存储实例和多个指向它的工作区实例。在这种情况下，隔离是通过使用单独的文件夹并将文件夹与工作区对齐来执行的。最佳实践是使用工作区名称作为文件夹名称。

组织和管理数据湖中的数据

在湖中组织数据时，必须考虑文件夹结构和文件格式的不同。许多组织使用不同的文件夹、容器或存储帐户对数据进行分层。在实现工作空间之前，在将数据放入数据湖之前，规划出数据的结构是很重要的。因此，如果您的进程主要读取按数据生命周期组织的数据，您应该考虑使用 /raw/、/enriched、/curated 文件夹结构。在每个文件夹中，您可以有不同的文件夹: /application01、/application02、等等。如果您的流程主要读取每个主题领域的数据，您可以考虑 /sales、/manufacturing 等等。您也可以混合这些分层模式。例如，带有 /raw 和 /enriched 的数据仍然是与源系统对齐的，而 /curated 中的数据是与消费者对齐的。

典型的数据湖结构(鸣谢:Piethein Strengholt)

在组织数据时，您还应该考虑访问控制模型。例如，容器只允许粗粒度的访问，因此继承了对文件夹和文件的访问。ACL 允许对数据集进行更细粒度的访问控制，但也带来了更多的管理开销。理想的数据湖结构在良好的逻辑分离和解决访问管理的开销之间取得平衡。

您应该考虑的另一个问题是如何应用数据生命周期管理。许多组织仅保留其完整数据加载的几个旧版本。他们通过建立缓慢变化的维度来压缩数据。回滚的典型时间窗口是 30 天。另一个考虑是审查交付模式。一些源系统保留了所有数据的完整历史，而其他系统只提供事务性数据。这种数据传递要求您执行覆盖或仅追加。这可能会导致更复杂的数据管道，这个主题您将在后面了解更多。

我选择什么样的数据格式？

数据通常以不同的文件格式到达，因为数据来源和接收文件格式的系统有很强的依赖性。您的一些源系统很容易提取，并直接允许现代文件格式的创建，如 Parquet 或 Delta。其他系统对传统导出功能的依赖性更强，例如，只能交付 CSV 或 XML 文件。因此，您的第一层摄取通常包含不同的文件格式。然而，当进一步处理时，人们非常喜欢允许更密集的查询模式的文件格式。对于 Synapse，您还必须注意其他一些事项:

目前，只有无服务器池支持增量文件。如果您打算使用外部桌子作为专用池，那么您应该考虑使用拼花地板。
当用 Spark 处理时，你可以创建 Spark 湖数据库。这些数据库可以使用无服务器 SQL 池进行查询，但是它们是只读的。
当使用无服务器 SQL 创建 Lake 数据库时，这些数据库在 Spark 中是不可见和不可用的。

数据处理方法

你推荐什么样的数据处理工具或方法？这个问题的答案主要归结为你喜欢什么。以下是一些实地观察结果:

只需要提取和加载或简单转换的团队通常在 Azure Data Factory(Synapse Pipelines)内部处理。
需要复杂转换但不喜欢编码的团队通常使用数据流或调用存储过程。
需要复杂转换、喜欢编码的团队通常使用 Databricks 或 Azure Synapse Spark Pools。编排通常由 Synapse 管道完成。
喜欢将转换和依赖作为元数据或 YML 文件来管理的团队经常使用外部工具，如 DBT 。

一般建议是尽可能消除手动步骤。一个好的自动化数据管道可以实现平滑和可扩展的转换，而无需任何手动操作。另一个建议是对重复的转换步骤应用模块化设计。某些块，例如处理历史数据的块，应该被转换成一个可重用的模块(元数据驱动的摄取框架)，然后可以应用于多个数据管道。最佳实践是使用几个代码库，并将功能设计与通用数据处理功能分开。另一个最佳实践是使用参数化。参数化允许更好的测试和更快的重新运行开发、测试和生产。

结论
组织您的工作空间和数据湖存储账户，使您在成本管理、生产效率和管理复杂性之间取得正确平衡，这一点很重要。不正确的体系结构可能会造成混乱，数据可能会在环境之间不断复制，或者访问管理成为一场噩梦。当许多团队依赖相同的数据时，尝试考虑多工作区单湖拓扑，或者当团队的目标发生冲突时，尝试使用多个工作区分开。

可视化聚类结果的最佳实践

原文：https://towardsdatascience.com/best-practices-for-visualizing-your-cluster-results-20a3baac7426

集群可视化和解释的成熟技术

图片由作者提供。

C 聚类是数据科学中最流行的技术之一。与其他技术相比，它非常容易理解和应用。然而，由于聚类是一种无监督的方法，因此对你来说识别对你的商业客户来说可理解的不同聚类是一个挑战。

目标

本文为您的下一个集群项目提供了可视化最佳实践。您将学习最佳实践用于分析和诊断您的聚类输出、正确可视化您的聚类和 PaCMAP 降维，以及呈现您的聚类的特征。每个可视化都带有它的代码片段。你可以把这篇文章作为参考指南。

因为我的上一篇关于集群的文章已经涵盖了一些技术细节和解释，所以我将在这里保持简短的解释。

聚类选择和诊断

让我们从头开始。在您分析任何聚类特征之前，您必须准备您的数据并选择适当的聚类算法。为了简单起见，我们将使用众所周知的葡萄酒数据集并使用 K 均值模型。然而，本文中展示的大多数可视化可以用于任何聚类算法。

上面的代码加载葡萄酒数据集，并使用标准缩放器来缩放整个数据集。

为了确保我们的集群以后的可视化总是使用正确和相同的颜色，我们定义了一个由六种不同颜色组成的列表(图 1)。

图一。定义的聚类颜色。图片由作者提供。

确定 k 个簇的正确数量

有几种方法可以确定(直观地)正确的聚类数。在下文中，我们将使用肘图方法、(平均)轮廓评分方法和轮廓分析。

肘法

为了得到一个全面和适当的肘图可视化，我推荐使用黄砖包pip install yellowbrick。下面的代码将产生如图 2 所示的图形。

输出还画出了一个建议(虚线)，您应该选择哪个 k。如果它不能确定一个正确的数字，它将显示一个警告。

图二。肘图。图片作者作者。

剪影评分

另一种确定聚类数量的方法是轮廓评分法。下面的代码绘制了图 3 中的输出。

导出的结果(3)与肘图法的结果相同。

图 3。轮廓评分法结果。图片由作者提供。

剪影分析

最后但同样重要的是，我们可以使用剪影分析方法来确定最佳聚类数。这个想法和方法在这篇 sklearn 文章中有很好的解释。

上述文章中提供的代码绘制了每行一个轮廓图。然而，当你有大量的集群并且想要比较它们的相关轮廓图时，这可能是非常不清楚的。所以我写了下面的代码让每行绘制三个图表，让后面的对比(图 4) 清晰很多。

图 4。剪影分析。图片由作者提供。

在尝试了几种直观地确定 k 个集群的正确数量的方法之后，我们决定继续使用 k=3 来构建我们的集群。

集群诊断

下一步是根据它们的大小和基数来诊断我们的集群。

如果你不熟悉这些术语，可以看看我的文章。

为了创建下面的图(图 5)，我们将使用data-science-utils包，它可以和pip install data-science-utils一起安装。

图 5。集群基数和数量级。图片由作者提供。

集群可视化

为了在 2D 空间中可视化我们的集群，我们需要使用降维技术。许多文章和教科书都使用 PCA。最近的博客文章也推荐像 t-SNE 或 UMAP 这样的方法。然而，这里有陷阱和误解。

****长话短说:使用这些降维方法时，需要在保留局部结构和保留全局结构之间进行权衡。虽然 PCA 保留全局结构，但是它不保留邻域或局部结构。另一方面， t-SNE 和 UMAP 保留了局部结构而不是全局结构。

然而，有一种相对较新的技术声称保留局部和全局结构** : PaCMAP 。**

PCA 和 PaCMAP 将在下文中用于在 2D 空间中可视化我们的聚类。

如果你想了解更多关于不同特征和 PaCMAP 的信息，请查看为什么你不应该依赖 t-SNE、UMAP 或 Mathias Gruber 的 TriMAP 。

运行代码后，您应该会得到下面的图(图 6):

图 6。使用 PCA(左)和 PaCMAP(右)进行聚类可视化。图片由作者提供。

集群特征

现在让我们把重点放在如何形象化和呈现每个集群的关键特征上，这样一个商务人士就可以很容易地理解每个集群代表什么。

在此之前，我们必须用一个集群列来丰富我们的标准化(X_std)和非标准化(X)数据。

箱线图

第一种非常简单的方法是为每个特征生成一个箱线图，以显示在每个聚类中的分布。****

为了绘制下面的结果(图 7)，我们使用了非标准化数据 X** 。使用标准化结果(X_std)会使更难为商业用户解释，因为其比例和单位已经改变。**

图 7。用箱线图可视化聚类结果。图片由作者提供。

数据准备

在我们继续之前，我们必须为下面的可视化准备数据。下面的代码帮助我们更好地比较我们的集群。

首先，我们计算每个聚类的每个特征的平均值 ( X_mean ， X_std_mean )，这与上面的箱线图非常相似。

其次，我们计算每个聚类的每个特征的相对差异(以百分比计)与每个特征的总体平均值(聚类无关)(X _ dev _ rel， X_std_dev_rel )。这有助于读者看到每个聚类中的差异与每个特征的总体平均值相比有多大。****

图 8 举例说明了在准备步骤之后我们的数据是什么样子的。

图 8。每个数据准备步骤的结果。图片由作者提供。

现在我们已经有了正确的数据，我们可以继续我们的可视化。

条形图

为了可视化相对差异，我们可以使用柱状图。以下代码绘制了每个要素的每个分类的差异。

结果如图 9 所示。

图 9。相对聚类差异用条形图显示。图片由作者提供。

如果你想展示每个星团的细节，上面的图很棒。然而，在许多情况下，在一个图表中总结所有相关结果和特征也是有意义的。下面的解决方案是做到这一点的一种方法。

我们在图 10 中直观地显示了每个特征相对于每个聚类的总体平均值的相对偏差。

图 10。在一个条形图中总结集群特征。图片由作者提供。

雷达图

在一个图中总结所有相关信息的另一种方式是使用雷达图。下面的代码绘制了标准化数据的计算平均值(X_std_mean)。****

如果我们使用非标准化版本，不同的标度会破坏可视化(例如，脯氨酸的平均值远高于灰分的平均值)。因此，我建议用相同的单位或至少在相似的数值范围内绘制数值。最终结果如图 11 所示。

图 11。用雷达图可视化集群特征。图片由作者提供。

结论

本文的目标是为您提供集群诊断、可视化和解释方面的最佳实践。在 2D 空间中绘制聚类时，请考虑 PaCMAP。可以从不同的角度呈现聚类结果或特征。一种想法是显示每个聚类的每个特征的平均值。另一个选项是计算每个聚类的每个变量与每个特征的总体平均值的相对差异。向企业展示结果时，最好使用一个图表(例如，显示的雷达图或第二个条形图)。如果您想要调查每个聚类的每个要素的特征，可以使用多个图(例如，与 UX 设计师进行深入探讨)。

来源

UCI 机器学习知识库:葡萄酒数据集。知识共享署名 4.0 国际 (CC BY 4.0)许可”。

王英凡，，辛西娅·鲁丁，亚龙·沙波什尼克，《理解降维工具如何工作:解读 t-SNE、UMAP、TriMAP 和 PaCMAP 用于数据可视化的实证方法》(2020)，【https://arxiv.org/abs/2012.04456】T4

编写可复制和可维护的 Jupyter 笔记本的最佳实践

原文：https://towardsdatascience.com/best-practices-for-writing-reproducible-and-maintainable-jupyter-notebooks-49fcc984ea68

让您的 Jupyter 笔记本变得更棒的简单步骤

格伦·卡斯滕斯-彼得斯在 Unsplash 上拍摄的照片

介绍

编写可复制、可维护、易于理解的 Jupyter 笔记本并不像您想象的那么容易。其实完全相反。其实真的很难。在本文中，我将解释为什么这么难，并为您提供一些帮助我实现更好的可再现性和可维护性的最佳实践建议。

什么是 Jupyter 笔记本

首先给大家简单介绍一下什么是木星笔记本。基本上，Jupyter 笔记本是一个交互式文档。您可以使用 Markdown 语法编写纯文本，也可以通过 LaTeX 语法使用数学公式。此外，您可以向笔记本添加代码，读者可以执行这些代码来产生一些输出，如可视化。

例如，您可以可视化一个基于各种参数的函数。读者可以使用滑块来更改这些参数的值，并且每次值更改时可视化都会更新(参见下面的示例)。您还可以添加代码，对一些数据库执行实时查询，以获取最新的销售数据，并将其绘制在饼图中。

交互式笔记本允许读者通过滑块改变参数。

代码通常是用 Python 编写的。但是支持 Java、R、Julia、Scala 等 100 多种编程语言。笔记本可以在浏览器中编写和执行。然而，即使在浏览器中写笔记本是可能的(存在基本的代码完成)，它也是有限的。幸运的是，您还可以使用 ide，如 Visual Studio Code 或 PyCharm(在专业版中),它们提供了更强大的功能。

也可以使用云服务来编写和执行笔记本。例如，谷歌提供了一个解决方案，允许你在云端运行笔记本，并与每个人分享。甚至 GPU 也可以在 Google Colab 中免费访问，用于密集型计算任务。

Jupyter 笔记本示例

下面你可以看到一个 Jupyter 笔记本的例子，它解释了如何用蒙特卡罗方法近似计算 π 。你可以看到三个细胞。第一个单元格是减价单元格，它给出了笔记本的介绍。它包含文本、动画和一些简单的数学方程式，通过 MathJax 渲染。

第二个单元格是包含 Python 代码的代码单元格。如果执行这个单元格，代码会生成一个简单的正方形内的圆的绘图。

第三个单元格也是一个 Markdown 单元格，当执行该单元格时，它在编辑模式和呈现结果之间跳转。在编辑模式下，你可以看到简单的降价文本。

Jupyter 笔记本，带有代码和用蒙特卡罗逼近圆周率的减价单元格

Jupyter 笔记本已经变得流行

Jupyter 笔记本已经非常受欢迎。2020 年 10 月，GitHub 上大约有1000 万台公共笔记本。出于教育目的，笔记本在学术界尤其流行。此外，数据科学家大量使用笔记本电脑进行数据分析和探索性任务。

尤其是文本和代码的结合使它们非常有趣。它允许作者用表达性公式解释 Markdown 中的概念，同时可以在同一文档中以代码的形式显示实现。Jupyter 笔记本电脑的这一独特特性可以更好地再现研究成果和传播教育内容。

朱庇特笔记本批评

尽管 Jupyter 笔记本很受欢迎，但它一直受到批评(例如我不喜欢笔记本)，因为你编写代码的方式可能会导致坏习惯。以下是一些例子:

笔记本命名

有时可以观察到的一个反模式是笔记本没有表达性的名称。相反，笔记本的名字有时以“无标题”开头或以“-Copy”结尾。这是由于浏览器中运行的 Jupyter 的默认行为。每次创建新笔记本时，都会创建一个无标题笔记本；每次创建现有笔记本的副本时，新笔记本都会带有后缀“-Copy”。

如果这是 Jupyter 的默认行为，您可能会认为许多笔记本名称都有这种反模式的问题。但令人惊讶的是，正如一项研究[1]所发现的，该研究分析的笔记本(从 GitHub 下载的笔记本子集)中，只有不到 2%的笔记本实际上有“无标题”，只有不到 0.7%的笔记本名称中有“-Copy”。所以这似乎不是什么大问题。

然而，同一项研究还发现，几乎 30%的受检笔记本的名称中含有 POSIX 完全可移植文件名指南不推荐的字符，该指南只允许使用字符[A-Za-z0–9。-_].具有不可移植文件名的笔记本可能会在某些系统上造成问题，因此应该避免使用。

不明确的执行顺序

Jupyter 笔记本中的单元格可以任意顺序执行。不必从第一个单元格开始，到最后一个单元格结束。您也可以从第二个单元格开始，跳回第一个单元格，然后执行第三个单元格。您也可以连续多次执行单元格。

这也是编写笔记本时的一种常见行为，因为通常你在一个单元中编写一些代码，执行该单元，然后一次又一次地修改和执行该单元，直到你对该单元的结果满意为止。有时，您还需要返回到以前执行的单元来重新初始化变量，或者因为您需要修改以前定义的函数。

因此，有时很难遵循执行顺序，这可能会对笔记本的再现性产生负面影响。

在之前引用的研究[1]中，发现模糊的执行顺序是许多笔记本的一个问题。14%的分析笔记本存在此问题。

让我们来看一个相关的例子，它演示了一个额外的问题。在下面你可以看到 4 个细胞。

首先，执行第一个单元格，这样就定义了函数 f。然后执行第二个单元格，之后变量a的值为 6。接下来，您正在编辑第三个单元格，但是决定稍微修改函数f的代码。函数应该将变量x增加 2，而不是将变量x增加 1。更改函数后，再次执行第一个单元格以使更改生效，然后执行第三个单元格。变量b将得到值 7。以下单元格正在处理这两个变量。

如果您与其他人共享此笔记本，这些人将无法复制您的结果，因为他们只能看到将变量x增加 2 的f版本。如果这些人一步一步地执行笔记本，变量a和b的值将分别为 7，而不是 6 和 7。

缺少模块化

在[1]中发现

只有 10%的分析笔记本有本地导入(即存储在存储库目录中的模块的导入)
54%的笔记本定义了功能
不到 9%的笔记本定义了类别

这些结果表明，模块化并不经常用于 Jupyter 笔记本电脑。这很有趣，因为模块化在软件工程中是一种成熟的模式，有很多好处。它有助于

减少代码(例如，减少复制和粘贴)
将复杂的代码分割成更容易理解的小块
编写更容易测试的代码
减少笔记本中全局变量的数量，这样可以降低内存使用量(局部变量更容易被释放，因为它们只存在于局部范围内)

然而，不使用模块化有很多原因。例如，没有功能的笔记本可能足够简单，因此不需要这种抽象。笔记本也可能不使用模块，因为作者想简化笔记本的发行。如果只需要分发一个文件，而不是多个文件(如果代码被移动到模块中，就会出现这种情况),这就更容易了。

遗漏测试

在软件工程中，测试是一种常见的实践。存在各种测试策略，例如集成测试、回归测试或单元测试。你可以在维基百科上找到关于不同方法的很好的概述。例如，单元测试是自动测试，它测试软件的小部分，通常是单个功能。

有各种框架可以用来编写单元测试。对于 Python 来说，模块 unittest 已经被很好地建立并且易于使用。根据[1],只有少数笔记本电脑(不到 2%)导入了众所周知的测试模块，这可能是测试未被广泛使用的一个指标。

尽管没有测试通常是软件工程中的反模式，但对于大多数笔记本电脑来说，这可能是合理的。许多笔记本用于数据分析和探索，以检验假设，或用于教学目的，以演示一些东西。为这些应用程序编写测试通常没有多大意义，因为在分析和探索任务的情况下缺少基本事实，或者因为演示产生了预期的结果。

缺少依赖关系

Jupyter 笔记本通常依赖于各种库和包。在 Python 中，这些依赖关系是通过关键字import导入的。没有为导入指定版本，因此，不可能通过查看导入来识别包的所需版本。但是，如果依赖项的版本没有记录在其他地方，并且没有简单的方法来安装所有必需的依赖项，人们可能会在执行笔记本时遇到问题，因为他们可能无法设置运行笔记本所需的环境。

此外，依赖项不需要在笔记本的开头导入。相反，依赖项可以被导入到任何地方。因此，仅仅通过查看笔记本的开头可能很难确定所有需要的依赖项。相反，您必须扫描完整的代码。

最后，导入的名称可能不同于需要安装的包的名称。例如，为了解析 YAML 文件，PyYAML 被广泛使用。这个包可以通过pip install pyyaml安装。然而，要使用这个包，您必须导入yaml。

根据[1]，许多笔记本没有声明模块依赖关系。

数据不可访问

许多笔记本电脑都需要数据才能工作。例如，关于机器学习的笔记本通常需要一个用于训练的数据集。验证集用于确定模型对未知数据的性能。如果这些数据没有随笔记本一起分发并且不存在，笔记本的结果就不能被复制。

根据[1],数据的不可访问性是执行笔记本时出现错误的一个常见原因，已经确定了两个主要原因。要么数据根本不存在，要么在数据随笔记本分发的情况下，使用绝对路径来访问数据。

再现性有限

Jupyter 笔记本的一个基本理念是让结果具有可重复性。这个想法是笔记本在科学界如此受欢迎的原因之一。在这里，可再现性很重要，因为越容易再现结果，结果就越有可能产生新的见解，因为其他人可以重用和构建您的工作。

然而，根据[1]的说法，GitHub 上的许多分析笔记本无法重现。结果显示，只有 22%到 26%的笔记本可以成功执行，甚至只有 4.9%到 15%的笔记本产生相同的结果。

我们已经讨论过不可复制笔记本的三个基本原因:

缺少依赖项
无序执行(以及由此产生的隐藏状态)
数据不可访问性

最佳实践

为了确保笔记本易于理解、维护和重复使用，并进一步增加笔记本结果重现的可能性，以下建议可能非常有用:

为您的笔记本使用表达性的名称来描述您的笔记本正在做什么，并且只使用 POSIX 完全可移植文件名指南中包含的字符。
避免不明确的执行命令。为了确保您的笔记本可重现并创建预期的结果，请在共享笔记本之前重新启动内核并执行笔记本的所有单元。
如果合理，使用模块化(即模块、函数、类)。
如果合理，使用测试框架来测试你的代码。
确保笔记本中使用的所有数据都与笔记本一起分发(或者至少可以下载)，并且使用相对路径来访问数据。
创建 requirements.txt 来固定所有使用的依赖项的版本，并在笔记本的开头导入所有依赖项。
分发笔记本及其输出。这使得重现结果更加容易，因为每个执行笔记本的人都可以验证结果是相同的。
不要重新定义变量。

结论

Jupyter 笔记本很容易写，但各种研究表明，似乎很难写出可复制的笔记本。但是，如果您遵循一些常见的最佳实践，您的笔记本确实更有可能被复制，并且其他人可以在您的伟大工作的基础上进行构建。这些最佳实践也帮助我写出了好的笔记本。在我看来，最重要的是避免模糊的执行顺序，提供一个使用过的依赖项及其版本的列表，并使笔记本中使用的数据易于访问。

参考

[1] Pimentel，joo feli PE 等人，“了解和提高 Jupyter 笔记本的质量和再现性。”实证软件工程 26.4(2021):1–55。

客户终身价值(LTV)模型的 ML 可观察性的最佳实践

原文：https://towardsdatascience.com/best-practices-in-ml-observability-for-customer-lifetime-value-ltv-models-c5a2fc063f4c

图片作者(艾瑞泽艾)

客户终身价值(LTV)模型的 ML 可观察性的最佳实践

提高 LTV 模型生产性能的技巧

古老的谚语仍然适用:客户永远是正确的，但有些人比其他人更正确(这是谚语，对不对？).虽然在任何组织中有许多指标可以评估客户的价值，但在评估公司整体销售活动的健康程度时，客户终身价值(LTV) 是一个需要考虑的重要指标。特别是在像包装消费品或零售这样的行业中，客户与企业的关系本质上是非契约性的，找到一种预测未来购买行为的方法对于提高组织的整体盈利能力至关重要。

客户终身价值就是客户在整个生命周期内与企业进行的交易或购买的总货币价值。这是对客户对公司价值的一种衡量，不仅仅是基于单次购买，而是在整个关系中。

简史:LTV 计算在 20 世纪 80 年代由沃顿商学院的 Peter Fader 博士首先创建，在 21 世纪初普及，并被翻译成机器学习模型，方便地打包到开源库https://pypi.org/project/Lifetimes/**。由于 LTV 是基于预测来评估参与模式的，因此使用 ML 是一个自然的选择。

LTV 模型被广泛应用于各种规模的行业来评估客户的预期价值。像任何估计一样，预测可能会出错。了解这些预测如何与现实世界结合以微调您的模型来获得最佳性能至关重要。

事实真相:数学形式的 LTV

LTV =((平均销售✕购买频率)/流失率))✕利润率

平均销售额=(总销售额)/(订单总数)
购买频率=(订单总数)/(唯一客户总数)
流失= 1 -保留率
利润率=基于业务环境

LTV 的意义

从提高整体业务盈利能力到预测创业收入，LTV 的主要应用围绕规划和预算。

根据 Criteo 的一项调查，81%的营销人员说监控 LTV 可以促进销售。在营销度量一书中提到，卖给新的潜在客户的概率是 5%–20%，而卖给现有客户的几率是 60%–70%。因此，通过预测 LTV，你可以让你的团队了解如何获得新客户并留住现有客户，同时保持可观的利润率。更具体地说，LTV 可以帮助组织:

定义营销目标
了解参与的正确渠道
计划支出以降低采购成本，并保持较高的保留率
寻找具有相似特质的顾客
获得客户反馈
提升客户忠诚度

如果使用得当，LTV 模型可以在商业中发挥重要作用。由于 LTV 模型的预测有助于构建和定义业务范围内的目标，因此对这些模型进行监控和故障排除以确保它们在生产中发挥最佳性能至关重要。

监控 LTV 模型的挑战

那么，什么会出错呢？LTV 的主要关注点是寻找、培养和留住在一段不确定的时间内创造最大价值的客户:消费者的生命周期。因此，LTV 模型必须迭代并快速估计长期价值，而实际数据却明显滞后或根本没有。

图片来源: ML 监测与可观测性电子书，艾瑞泽 AI

在生产中监控模型时，设置适当的基线对于测量漂移和检测生产中模型行为的偏差是必不可少的。通常，使用训练或验证数据来设置基线，以测量不同环境中特征值分布、模型预测和基本事实的变化。如果没有有效的监控和可观察性工具来评估延迟地面实况场景情况下的代理指标，解决 LTV 模型在生产中的性能下降问题可能会被证明是昂贵且耗时的。

如何对 LTV 模型使用监控和可观测性

根据前面提到的 Criteo 调查，采用 LTV 的最大障碍之一是它太复杂，难以监控。虽然这是历史上的情况，但实现 ML 可观测性可以显著地消除这一困难。

监控 LTV 模型的一个主要挑战是发现代理指标来代替延迟的实际值。LTV 模型通常在相当长的时间内评估客户的价值，因此将基础数据映射到模型的预测可能是一个挑战(在下面的部分中有更多关于代理指标的信息)。

为了让从业者在生产中轻松部署和改进他们的 LTV 模型性能，他们的 ML 可观测性平台应该:

设置基线监视器
评估特征、模型和实际/地面真实漂移
衡量模型性能

监控 LTV 模型

积极改进 LTV 模型的第一步是在生产中监控您的模型。那么，监督意味着什么呢？一个有效的 ML 监控平台应该自动配置最适合您的数据的监控器，以主动检测漂移、数据质量和性能问题。手动设置阈值和创建监视器的日子已经一去不复返了。

通过特征和模型漂移验证模型性能下降

为了了解您的 LTV 模型的性能下降，监控功能和模型漂移是有益的。这意味着在各种环境和版本之间分析您的模型，以识别 LTV 模式和异常分布行为。通过利用覆盖了您选择的指标的随时间漂移小部件，模型性能管理变得更加高效和可行。虽然 LTV 模型的主要问题之一是延迟或没有真实数据，但您可以使用漂移作为代理指标来分析您的模型的相对表现。

要测量的漂移类型:

特性漂移:输入数据固有的变化(这是游戏的名字)。监控您的要素，以快速了解您的输入是否明显偏离您的模型的训练内容，以及您是否需要重新训练或构建新模型。
模型漂移:测量您的模型的输出是否如生产中预期的那样执行。根据以下因素发现您的模型是否有偏差:

培训/验证环境
历史生产时期
滚动生产窗口

揭示不准确预测的根本原因

假设你的 LTV 模型漂移了。您的监控解决方案触发了警报，现在由您来找出问题所在。下一步是什么？您将希望快速找到问题的根本原因来解决问题，通常是通过重新训练模型并将其与生产中的现有模型进行比较。

这可以通过 ML observability 来实现，ML observability 可以使用性能热图进行更深入的分析，以便更好地了解和直观地了解从哪里开始对与您的 LTV 模型相关的问题进行故障排除。对于最简单的工作流程， ML observability 允许您使用特征/值组合深入研究低性能切片，以便了解如何改进您的模型。

模型性能

即使您对生产中的模型有最大的信心，积极地改进您的模型并监控模型性能有助于整体业务成果。

在 LTV 案例中，我们基于几个关键指标评估模型性能:

【均方根误差】(RMSE) : 模型预测值与实际值之差的平方根，经过平方并在整个数据集中取平均值。这种方法对重大错误给予更高的权重，因此，在企业可能希望严重惩罚大错误或异常值的情况下，这种方法可能会有所帮助。
平均绝对百分比误差(MAPE) : 衡量一个模型产生的误差的平均大小；MAPE 是 LTV 模型预测准确性的一个更常见的度量标准。
平均绝对误差(MAE) : 模型预测值与实际值之间的绝对值差，在整个数据集内取平均值。对模型性能的“第一印象”,因为它没有被一些预测的极端误差所扭曲。

当选择要测量的性能指标时，使用哪个指标没有统一的答案；它依赖于您的模型和它吸收的数据。一旦您决定了您的性能指标，每天或每周跟踪您的模型性能指标允许您确保性能不会从模型训练时或模型最初被提升到生产时急剧下降。ML 可观察性帮助您跟踪这些重要的指标，如果出现问题就触发警报，并通过自省来发现潜在的问题。

结论

通过发现漂移、了解模型性能并轻松识别潜在生产问题的根本原因，ML 工程师可以满怀信心地运输他们的 LTV 模型，并改善整体业务成果。虽然监控和观察生产模型似乎并不简单(剧透警告:事实并非如此),并且可能成为运输模型的障碍(确实如此), MLOps 工具链中的解决方案可以简化模型监控和故障排除。实现最大似然可观测性有助于确保 LTV 模型的预测通过自动监视器保持最佳状态，监视特征和模型漂移，并随时间可视化模型性能。作为额外参考，以下是 ML 可观察性平台如何帮助客户处理客户终身价值模型监控和可观察性。

联系我们

如果这篇博客引起了你的注意，并且你渴望了解更多关于机器学习可观察性和模型监控，请查看我们的其他博客和关于 ML 监控的资源！如果您有兴趣加入一个有趣的 rockstar 工程团队，帮助模型成功生产，请随时联系我们，并在此处找到我们的空缺职位！

成为优秀数据科学家或机器学习工程师的最佳实践

原文：https://towardsdatascience.com/best-practices-to-become-a-good-data-scientist-or-machine-learning-engineer-ce10a92f2674

学习由数据科学家和机器学习工程师完成的重要实践可以确保一个人在组织中产生高质量和有影响力的工作。

在 Unsplash 上由 Boitumelo Phetla 拍摄的照片

T4 有大量教授编程和数据科学基础的课程。他们在强化机器学习中的各种概念方面做得很好，并展示了在构建具有 ML 功能的项目时通常遵循的各种步骤。虽然这些课程主要关注机器学习的理论方面，但如果一个人学会在构建与数据科学和机器学习相关的应用程序时更加重视良好的实践，这可能会很方便。

随着数据的增长和计算能力的指数级增长，对利用数据并根据项目用例生成预测和有用见解的人的需求迅速增加。此外，还有许多与数据相关的职位，如数据工程师、数据架构师、数据科学家、深度学习工程师和机器学习工程师。这些职位通常需要对数据处理、特征工程、数据提取、加载和操作有很好的理解。对于数据科学家或机器学习工程师这样的职位来说，构建在测试数据(之前模型没有看到的数据)上表现良好的最先进的模型通常很重要。由于数据科学工作流程中涉及许多步骤，因此，在构建 ML 应用程序时，学习有用的实践变得非常重要。下面是数据科学家或机器学习工程师可以遵循的一些最佳实践，以构建更高质量的代码和更好的项目成果。

准确理解业务问题

肖恩·波洛克在 Unsplash 上拍摄的照片

伴随着大量的责任和方式，人们可能会在没有定义项目的最后期限或商业目标的情况下被卷入潮流，这经常是真的。让事情变得复杂的是，项目中与 ML 相关的东西有一种可能是没有明确陈述或定义的。在这种情况下，通过理解项目的需求及其范围并了解机器学习的可行性来采取行动可能是好的。认识到这些关键措施，并承认一个人是否能够实际实施人工智能以及它是否能够在创造的价值中产生良好的影响，可以推动你在项目中的努力和影响。

从一个简单的指标开始

丹-克里斯蒂安·pădureț在 Unsplash 上拍摄的照片

在机器学习中有许多度量，例如在回归类型问题的情况下的平均绝对误差、均方误差、平均绝对百分比误差、均方根误差。如果我们考虑分类问题，我们有诸如精确度、召回率、准确度、f1 分数、微观 f1 分数、宏观 f1 分数和许多其他的度量。通过查看所有这些指标，可以确信在测试和理解这些模型时使用所有这些指标。尽管如此，由于数量庞大，接受正确的度量标准可能会变得很棘手。在这种情况下，最好的办法是根据问题选择高度可解释和可理解的简化指标。在了解了这个指标并分析了影响之后，就有可能将它添加到我们的 ML 中进行预测。

建立强大的数据科学团队

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

数据科学是关于系统的通信、动作和自动化，从而减少人类的努力，帮助公司获得巨大的利润空间。为了构建具有人工智能功能的工具，重要的是与拥有大量知识和见解的团队合作，从数据收集、数据准备、训练模型到在云中部署服务，以便最终用户可以访问服务。换句话说，如果最终用户不消费数据科学家生产的产品，他们可能不会增加很多价值。因此，他们必须与一个拥有不同领域知识的团队合作，这样他们才能构建并发布一个全功能的产品。

学会给商业利益相关者留下深刻印象

查尔斯·弗劳恩德在 Unsplash 上的照片

虽然机器学习和深度学习产品的技术能力令人印象深刻，但如果它们不能打动业务利益相关者，并且部署它们不会给组织带来很大的利润，它们可能几乎没有价值。我以上陈述的基本意思是，尽管我们从具有非常低的平均绝对误差、均方误差或任何此类误差的 ML 模型中获得了结果，但如果它们未能产生商业影响，尽管它们在技术上结构良好且可行，这意味着该组织不能基于人工智能的结果货币化。因此，必须根据部署带来的收入的整体增长、利润以及客户的参与度是否提高来定义问题。通过考虑这些因素，可以更好地定义项目的目标和结果，以及运行算法所需的额外基础设施支出。

传达您的结果

Miguel A. Amutio 在 Unsplash 上拍摄的照片

你已经花了大量的时间，比如说一个月的时间来收集额外的数据，产生关键的见解，并找到对 ML 模型有用的最重要的特征，并且通常来说确定结果，现在是时候向团队阐明你的结果，以便他们花必要的时间根据你的结果采取行动。尽管令人印象深刻的是，你已经花了大量的时间去理解业务问题，也学习了数据中最重要的特征，但是不能阐明你所学习和工作的东西通常会减慢项目的进度。因此，让团队了解你正在处理的领域以及工作成果是非常有用的。

部署后持续监控结果

照片由马库斯·温克勒在 Unsplash 上拍摄

在部署阶段之后，是时候持续监控 ML 模型的性能，并根据预测查看性能是否有下降。有重要的关键绩效指标(KPI)可以帮助监控 ML 模型在生产中的表现。因此，密切关注模型性能有助于确保模型为组织产生业务影响和利润。

构建强大的数据科学产品组合

乔安娜·科辛斯卡在 Unsplash 上拍摄的照片

对于机器学习或数据科学方面的新手，如果你建立一个强大的工作组合，包括你最好的项目和任务，这将非常方便。请随意观看这个视频，我在视频中强调并解释了投资组合对于获得第一份数据科学工作的重要性。谢了。

关于为数据科学或机器学习工作建立强大投资组合的视频

结论

我们已经看到了一些成为优秀数据科学家或机器学习工程师的重要实践。虽然本文强调了许多好的实践，但是仍然有一些其他的实践很重要，可以考虑。但是阅读这篇文章应该有望让你对成为一名有效的数据科学家或机器学习工程师可以做的事情有一个很好的了解。感谢您花时间阅读这篇文章。

你的会员费直接支持苏哈斯·马达利和你阅读的其他作家。你还可以在媒体上看到所有的故事。点击下面的链接成为 Medium 的会员，并获得无限制的文章列表。下面是链接。谢了。

【https://suhas-maddali007.medium.com/membership 号

以下是您联系我或查看我作品的方式。谢了。

GitHub: 苏哈斯马达利(Suhas Maddali)(github.com)

LinkedIn: (1)苏哈斯·马达利，东北大学，数据科学| LinkedIn

培养基: 苏哈斯·马达利—培养基

适合初学者的最佳 Python 内置

原文：https://towardsdatascience.com/best-python-built-ins-for-beginners-17322ce1e8a4

对于任何想提高代码水平的新手来说，这是基本功能

照片由夏洛特·卡尔森在 Unsplash 拍摄

当我第一次开始用 Python 编码时，我专注于执行。我不关心效率或干净的代码。如果成功了，我就满足了。结果，我变得过度依赖变通方法，而不是学习最佳实践。

这些最佳实践中的许多都可以在 Python 文档中找到。多亏了这些文档，我发现了内置函数,它们解决了许多我以前认为很烦人，但又不可避免的 Python 怪癖。

这并不是最常用的内置函数的列表。更确切地说，这是一个我希望在我第一次开始编码时就学会并接受的函数列表。我保证一旦你学会了如何使用它们，它们将会简化和改进你的代码。

最佳内置函数

1.列举

enumerate函数将一个 iterable(如list、set或Series)作为输入，并返回一个 enumerate 对象，该对象包含输入中每一项的计数和值的元组。由于输出也是可迭代的，枚举需要一个 for 循环或list包装器来迭代和处理项目。

start参数设置索引值的起始值。例如，要创建索引值对应于日期的本周的工作日列表，请使用start = 25。

enumerate在使用每一项的索引和值的 for 循环中特别有用。之前，我在 for 循环中使用了range(len(list))，然后在循环体中为索引和条目创建了变量。现在，我使用enumerate，节省了打字时间，创建了更干净的代码。

2.活力

zip将一个或多个 iterables 作为输入，并对它们进行并行迭代。它输出一个元组迭代器，每个元组包含来自每个输入的一个项目。换句话说，zip连接输入以创建元组，其中第 i 个元组包含来自每个输入的第 i 个条目。

输入不需要长度相同。如果它们的长度不同，输出将与最短的输入大小相同。

像enumerate，zip返回一个 iterable，它需要一个 iterable，比如 for 循环或list包装器来解包项目。

在输入长度相同的情况下，使用strict = True参数。如果输入长度不同，则产生一个ValueError。

当只给出一个输入时，zip返回长度为 1 的元组。

3.地图

map将一个函数和一个或多个可迭代对象作为输入，将函数应用于可迭代对象，并返回结果。像zip和enumerate一样，输出是可迭代的。

注意，列表理解达到了同样的效果。

然而，当函数有多个输入时，map比列表理解更有优势。例如，假设您有一份关注您的帐户的所有新媒体订户的列表。但是，列表是按周划分的，您希望找到每个工作日获得的最大订户数。

单靠列表理解无法复制这一点。然而，如果调用其他函数，比如zip，列表理解也可以工作。

4.分类的

函数从一个可迭代的输入中返回一个新的排序列表。如果你在处理列表时遇到了一个None对象，这个函数就是为你准备的。通常，这些错误是由于将一个变量赋值给一个就地操作，如list.sort()或list.reverse()。就地操作不输出任何东西，所以变量没有什么可存储的。

sorted函数返回一个输出，该输出可以存储为一个变量。

令人尴尬的是，很长一段时间我都不知道这个功能。相反，我复制了一个列表，然后将副本排序。如果我知道sorted，我就可以避免这种耗时的变通方法。

结论

感谢您阅读我的文章。如果你喜欢我的内容，请考虑关注我。此外，欢迎所有反馈。我总是渴望学习新的或更好的做事方法。请随时留下您的评论或联系我 katyhagerty19@gmail.com。

https://medium.com/@katyhagerty19/membership

数据科学最佳 Seaborn 可视化

原文：https://towardsdatascience.com/best-seaborn-visualizations-for-data-science-3d866f99c3a9

使用 Seaborn 库探索数据科学项目的一些最佳可视化选项

汤姆·温克尔斯在 Unsplash 上的照片

任何人工智能或数据科学相关任务的最重要组成部分是数据。然而，如何理解如何有效地利用原始状态的数据呢？

查看数据和浏览一些次要细节可能并不总是足以准确地计算出解决方案。因此，我们需要可视化技术。

可视化在破译数据模式方面发挥着至关重要的作用，并帮助我们分析最有效的机器学习或深度学习方法，数据科学爱好者可以使用这些方法来获得高质量的结果。这些是探索性数据分析(EDA)计算理想解决方案时要遵循的最重要的步骤之一。

在我们开始这篇关于 seaborn 的文章之前，我建议从下面提供的链接中查看我以前的一篇关于 matplotlib 可视化技术的文章。这应该是更熟悉不同类型的可视化的一个很好的起点。

</8-best-visualizations-to-consider-for-your-data-science-projects-b9ace21564a>

数据科学的 9 个最佳 Seaborn 可视化:

在本文中，我们将重点关注 seaborn 库。我们将学习该库中可用的众多可视化技术，我们几乎可以在每个项目中使用这些技术。Seaborn 是一个基于 matplotlib 的 Python 数据可视化库。它提供了一个高层次的界面来绘制有吸引力的和信息丰富的统计图形。

Seaborn 的简单性有助于简化复杂的可视化，并有助于增加额外的美学吸引力。除了 seaborn 拥有的所有令人惊叹的特性之外，它还构建在 matplotlib 库之上。因此，利用这两个库的组合，我们可以产生更强大和更高效的可视化效果。然而，在本文中，我们将只关注 seaborn 库。

开始使用:

让我们通过导入 seaborn 库来快速入门。下面的代码片段显示了如何根据需要导入库。一旦导入完成，我们就可以进行进一步的计算和可视化。

# Import the seaborn library for visualizationimport seaborn as sns

关于 seaborn 库最好的部分是它提供了一组默认数据集，通过这些数据集，您可以开始训练和测试您的可视化技术。虽然有几个数据集选项，如行星，小费，泰坦尼克号等。，在许多其他项目中，我们将在这个项目中使用 iris 数据集。下面是在 seaborn 库中加载 iris 数据集的代码片段。

# Load the Iris datasetiris_data = sns.load_dataset("iris")

在 Iris 数据中，我们有三种花，即 setosa、versicolor 和 virginica。我们的任务是可视化许多参数，如萼片宽度，萼片高度，花瓣长度和花瓣宽度，这些都与每一个物种有关。使用这些与每个提到的物种相关的特性，我们将使用 seaborn 库中的一些最佳选项来相应地区分它们。下面是对我们的数据集的简要介绍。

iris_data[:5]

作者图片

1.散点图:

sns.scatterplot(x = "sepal_length", 
                y = "sepal_width", 
                data = iris_data, 
                hue = "species")

作者图片

开始可视化的最佳技术之一是对可用数据应用散点图。散点图为用户提供了一个极好的选项，让用户可以看到数据之间的区别。从上面的散点图中，我们可以注意到很容易将 setosa 与 versicolor 和 virginica 区分开来。然而，云芝和弗吉尼亚似乎有一些相似之处。

为了在 seaborn 库中定义散点图，我们可以直接提到 x 轴和 y 轴参数，我们需要为可视化计算这些参数。一旦我们选择了 x 轴和 y 轴属性，我们就可以提到数据集并指定色调，以便为可视化绘图启用颜色编码。

2.直方图:

sns.histplot(x = "species", y = "sepal_width", data = iris_data)

作者图片

从之前的散点图中，我们已经能够生成大量关于虹膜数据集的信息。我们还可以使用其他图表，如直方图，从而使用户能够直观地了解一些特征的可区分性。上图显示了基于萼片宽度的物种直方图。

在上面的代码片段中，我们将 seaborn 库中的 histplot 函数用于 iris 数据集，相应地提到了物种和萼片宽度。强烈建议用户使用其他特征参数来测量物种的多样性。

3.条形图:

sns.barplot(x = "species", y = "sepal_width", data = iris_data)

作者图片

类似于直方图，我们也可以使用 seaborn 库中的条形图函数和 iris 数据集绘制条形图，相应地提到物种和萼片宽度。上面的可视化表示了一个柱状图，显示了每一个提到的物种的萼片宽度更加丰富多彩和美观。

4.箱线图:

sns.boxplot(x = "species", y = "sepal_width", data = iris_data)

作者图片

与前两个图不同，我们将关注另外两个图，这两个图将为我们提供一个更具体和适当的范围，不同品种的花的参数落在这个范围内。首先，我们将查看 seaborn 库中的方框图，它将为用户提供每个物种的特定范围。

中值、百分位数和分位数的概念在这些绘制图表的方法中使用。箱形图的末端代表在四分位数范围内构建的晶须。通过提及 iris 数据集、物种和特定参数，可以在 seaborn 库中绘制箱线图。

5.小提琴情节:

sns.violinplot(x = "species", y = "sepal_width", data = iris_data)

作者图片

为了简化箱线图和中值范围的概念，我们可以使用小提琴图，通过它我们可以更直观地了解特定功能的工作范围。与箱线图类似，通过提及 iris 数据集、物种和特定参数，可以在 seaborn 库中绘制 violin 图。

6.带 Distplot 的面网格:

from warnings import filterwarnings
filterwarnings("ignore")sns.FacetGrid(iris_data, hue="species", height = 5).map(sns.distplot, "petal_width").add_legend()

作者图片

在下一个可视化中，我们可以利用分布图(dist。绘图)以了解 iris 数据集中的数据分布。分布图有助于我们直观地了解物种的概率密度，即 x 轴上每单位的概率。我们可以为以下内容绘制图表，如上面的代码片段所示。

7.配对图:

sns.pairplot(iris_data, hue="species", height=3)

作者图片

seaborn 中最重要的可视化技术之一，尤其是对于 iris 数据集这样的任务，是对图的利用。上图详细展示了众多特征的配对图，也许是理解虹膜数据集的最详细视图。配对图有助于描述和区分两个特定变量之间的最佳特征。

上述代码片段可用于绘制 iris 数据集各种物种的配对图。配对图是分析二维数据的一些最佳选择。然而，当数据维数较高时，它们的效用会减弱，并且在数据集非常庞大的情况下，它们不是非常有用。

8.聚类图:

sns.clustermap(iris_data.drop("species", axis = 1))

作者图片

seaborn 中的聚类图允许用户将矩阵数据集绘制为分层聚类的热图。聚类图是确定特定区域中有多少数据点的重要工具。seaborn 中的聚类图功能可能有点复杂，但它允许用户详细了解数据集中提供的大多数要素。对于特定的项目和任务，聚类图可能是一种重要的可视化技术。

9.热图:

sns.heatmap(iris_data.corr())

作者图片

最后，我们将查看 seaborn 库中的热图函数，这是最有用的可视化技术之一。热图可视化帮助我们计算不同变量和参数之间的相关性。使用热图函数，我们可以简单了解几个变量之间的关系。

为了对 iris 数据集执行热图操作，最好使用 corr()函数获取 iris 数据的相关性。一旦我们有了一个关联表，我们就可以用上面代码片段中显示的命令来绘制它，以产生上图所示的结果。热图是机器学习模型的超参数调整的重要可视化技术。

结论:

约瑟夫·巴里恩托斯在 Unsplash 上拍摄的照片

正确问题的近似答案比近似问题的精确答案更有价值。
——约翰·图基

可视化和探索性数据分析(EDA)将始终是数据科学项目的一些基本组成部分。这些是唯一的方法，通过它们我们可以对我们在特定项目中处理的数据类型有一个比较好的理解。因此，每个数据科学家都必须学习并更加熟悉这些可视化技术。

在本文中，我们了解了 seaborn 库，它是用于数据科学任务和项目的 Python 可视化的最佳工具之一。Seaborn 在处理熊猫数据帧方面更加得心应手。它使用基本的方法集来提供 Python 中漂亮的图形。我们了解了 seaborn 库中各种不同的可视化技术，通过这些技术，我们对特定项目中使用的数据或数据集有了更好的理解。

如果你想在我的文章发表后第一时间得到通知，请点击下面的链接订阅邮件推荐。如果你希望支持其他作者和我，请订阅下面的链接。

https://bharath-k1297.medium.com/membership

如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。

看看我的一些与本文主题相关的文章，你可能也会喜欢阅读！

</7-python-programming-tips-to-improve-your-productivity-a57802f225b6>

谢谢你们坚持到最后。我希望你们都喜欢这篇文章。祝大家有美好的一天！

Jupyter-Notebook 中的 4 个省时 Python 技巧

原文：https://towardsdatascience.com/best-time-saving-python-tricks-in-jupyter-notebook-fca877132507

欺骗

Jupyter-Notebook 中的 4 个省时 Python 技巧

使用查找和替换、复制和粘贴等功能更快地编写代码

塞缪尔·佩恩在 Unsplash 上的照片

当在 Jupyter-Notebook 中使用 Python 时，这四个技巧一定可以节省你宝贵的时间。反过来，增加⚡️你的生产力。

常见的快捷键有Ctrl + Shift + -拆分单元格、Shift + M合并多个单元格、Shift + Down / Up选择所选单元格下方或上方的单元格。

然而，我在这里列出的技巧在几乎每个项目中都节省了我的时间。在您的项目中使用它们肯定会通过避免重复工作来节省您的时间。

一个视频抵得上 1000 张图片！！！

因此，我准备了 4 个 30 秒的⚡️短片来展示这些笔记本小把戏！

我们开始吧！

如何一次注释多行

Python 中的注释是在程序 执行过程中被编译器忽略的代码中的行。

几乎在每个项目中，我们都需要注释一堆行。在 Python 中，注释总是以**#**开头。因此，要将任何一行转换成注释，需要在开头添加**#**。

逻辑上，你需要在每一行你想评论的前面加上**#**。与 JavaScript 不同，Python 目前不支持多行注释。

但是，有志者事竟成！

你所需要做的就是选择你想要评论的所有行，然后按下**Ctrl** + **/** ，如下图所示。

如何一次评论多行|图片作者

这样，可以通过点击**Ctrl** + **/** 来切换注释。

在 Jupyter-Notebook 中使用 Python 时，可以使用这个简单的技巧。

查找和替换

有时，您需要在 Python 程序中复制并粘贴一些代码片段。然后编辑一些变量名和变量值，使它在你的程序中工作。

在这种情况下，Jupyter-Notebook 中的**Find and Replace**选项确实节省时间。

作者提供的视频

如上视频所示，可以在**Edit**选项下找到。此外，当您在 Jupyter-Notebook 中处于命令模式时，可以通过键盘快捷键**F**访问它。

一次复制粘贴多个单元格

有时，您需要在同一个笔记本中或从另一个笔记本中复制多个单元格。在这种情况下，这种多单元格复制粘贴的方式非常完美。

作者提供的视频

有时候，你需要按两次**Ctrl** + **V**来粘贴单元格。

一次编辑多行代码

大多数时候，您需要在 cell 中编辑多行代码。在这种情况下，这是非常方便和省时的技巧。

作者提供的视频

在我使用 Python 和 Jupyter-Notebook 的大多数数据科学任务中，这个技巧总是节省我的时间。

总结一下，

在 Jupyter-Notebook 中使用 Python 时，您可以使用这四个技巧中的任何一个。在我的工作中，我发现它们非常节省时间，尤其是重复的任务。⏳

请随意 保存视频 供您将来参考。另外，你可以加入我的 电子邮件列表 以便在我发布新故事时得到通知！

💡如果你喜欢阅读这样的故事，并想支持我和其他作家，考虑注册成为一个媒体成员。每月只需 5 美元，你就可以无限制地阅读媒体上的文章。如果你注册使用我下面的链接，我会得到一小笔佣金！💡

https://medium.com/@17.rsuraj/membership

感谢阅读！

我最喜欢的 VS 2022 代码扩展

原文：https://towardsdatascience.com/best-vs-code-extensions-of-2022-e9b49990cb4b

作为一名软件工程师和学生

照片由加布里埃尔·海因策在 Unsplash 上拍摄

作为一名 web 开发人员、移动应用程序开发人员，以及最近作为一名 c 语言嵌入式系统开发人员，我几乎在任何事情上都使用 VSCode。

这里有一些我最喜欢的扩展，我用它们来使我的 VSCode 看起来像我想要的那样，并使我的生活变得更简单。

1. Atom One 黑暗主题

我尝试了很多主题和配色方案，但 Atom One 深色主题是我最喜欢的，因为颜色有有用的对比，看起来很棒。

来自 vscode 市场的截图。

主题之前/之后的 React 代码示例。来自作者的代码

用ext install akamud.vscode-theme-onedark安装

2。VSCode 大图标

比最常见的图标扩展 vscode-icons 稍逊一筹，但却是我个人的最爱。我觉得这里的图标看起来比默认的好多了，文件夹图标让我更容易分辨我在哪个目录。

作者截图

用ext install emmanuelbeziat.vscode-great-icons安装

3。饿删

非常简单，但是非常方便。这在删除几个空行时很有帮助，可以去掉所有的空格。它让我不必选择多行或者总是点击Ctrl-Backspace。

将捕捉移动到顶部只需要一次 ctrl-backspace。Gif 取自扩展列表。

ext install jasonlhy.hungry-delete

4。直播服务器

这只是一个网页开发，但超级容易的静态和动态页面。对我来说，它最有用的特性是在修改时自动重载。

自动重装功能。Gif 取自扩展列表。

ext install ritwickdey.LiveServer

5。制表

像饥饿删除，这是一个方便的小键盘绑定，让您的光标离开括号，引号，和括号与一个标签。我发现这很有用，因为 VSCode 会自动为您补全括号；您可以按 tab 键而不是箭头键。

ext install albert.TabOut

6.片段

如果你不知道片段，你应该知道。当你在一门语言中倾向于重复代码块时，它们非常有用。

片段是来自扩展或您自己编写的小的预编程字符串，可以自动完成为更大的代码块。我发现这在编写 React 组件时特别有用，因为其中有大量重复的样板代码。

React Snippets 扩展附带的一些代码片段

用ext install runningcoder.react-snippets安装如上所示的 React Snippets 扩展

7.支架对着色机 2

这个扩展通过用独特的颜色突出显示括号和圆括号，使我一眼就能看到我所在的上下文。当您选择右括号和左括号时，它还会在它们之间画一条线。

̶a̶v̶a̶i̶l̶a̶b̶l̶e̶̶h̶e̶r̶e̶,̶̶o̶r̶̶i̶n̶s̶t̶a̶l̶l̶̶i̶t̶̶d̶i̶r̶e̶c̶t̶l̶y̶̶b̶y̶̶o̶p̶e̶n̶i̶n̶g̶̶v̶s̶c̶o̶d̶e̶,̶̶t̶y̶p̶i̶n̶g̶̶c̶t̶r̶l̶+̶p̶̶t̶h̶e̶n̶̶p̶a̶s̶t̶i̶n̶g̶̶e̶x̶t̶̶i̶n̶s̶t̶a̶l̶l̶̶c̶o̶e̶n̶r̶a̶a̶d̶s̶.̶b̶r̶a̶c̶k̶e̶t̶-̶p̶a̶i̶r̶-̶c̶o̶l̶o̶r̶i̶z̶e̶r̶-̶2̶̶t̶o̶̶i̶n̶s̶t̶a̶l̶l̶̶d̶i̶r̶e̶c̶t̶l̶y̶.̶

来自 vscode marketplace 的截图。

*更新 *

有人在 2021 年 9 月的评论中向我指出，彩色括号是 VS 代码中的原生元素！要启用它，请在 settings.json 中更改这两行(或者只搜索它们)

{
    "editor.bracketPairColorization.enabled": true,
    "editor.guides.bracketPairs":"active"
}

奖金:

以下是我使用的或其他人发现有用的一些其他技巧或其他扩展:

Vim 有一点学习曲线，但是一旦你习惯了，你可以更快地导航和编辑你的代码。
自动结束标记 —自动完成 HTML 和 XML 结束标记。网页开发者必备。
Git Graph —给出 git repo 中分支和变化的直观线性图形。您甚至可以直接从图中执行 git 操作！
https://marketplace.visualstudio.com/items?itemName=smcpeak.default-keys-windows—也许更有经验的 Linux 用户知道这是否有充分的理由，但 Windows/Mac 上的大多数键盘快捷键使用的键比 Linux 上的少。我刚刚开始全职使用 Linux，并且习惯了 Windows 的键盘绑定。这使得转换更容易，这样我就不必重新学习任何键盘快捷键。
快捷键 —键盘快捷键是加速你编码的最好方法之一。VSCode 有大量有用的键盘快捷键，可以加快打字和编辑的速度。完整列表已链接，但以下是我最常用的几个:

查看器快捷键:

`Ctrl+`` —切换终端。

Ctrl+B —切换侧面板，以便为编辑器留出更多空间。

Ctrl+Shift+P —这将打开命令面板，其中包含大量与您的工作区相关的命令。

代码导航:

Ctrl+Shift+O —“转到符号”命令。这让你可以搜索你的函数和变量，这使得在一个文件中访问函数变得更快。

Ctrl+Alt+Up/Down —向上或向下复制您的行。

Ctrl+X —正常情况下使用选择，但在 VSCode 中，如果光标停留在一行上，它将剪切整行而不选择。Ctrl-C 也一样！

Ctrl+Enter —将光标移动到下面的新行。如果我在语句中间编辑完了什么，我会一直用这个。

Ctrl+/ —不特定于 VSCode，但是您应该知道如何添加和删除行注释。

目录导航:

Ctrl+P —打开搜索以快速移动到项目中的其他文件。

同样的快捷方式，带有 Chrome 标签，可以让你前后移动到之前打开的文件。

再次和 Chrome 一样，关闭你打开的文件。

Ctrl+Shift+F —搜索整个项目，而不仅仅是打开的文件。

感谢阅读！请在评论中告诉我你最喜欢的代码扩展和快捷键。

贝塔分布简单地解释了

原文：https://towardsdatascience.com/beta-distribution-simply-explained-839b3acde6e9

贝塔分布的简明解释。

照片由 Lucas Santos 在 Unsplash 上拍摄

介绍

贝塔分布是一种连续分布，通常被称为概率的 概率分布。这是因为它只能取在 0 和 1 之间的值。

当我们有一些关于成功和失败的数量的信息时，它被用来推断一个事件的概率。

贝塔分布的主要用途是作为贝叶斯统计中的https://en.wikipedia.org/wiki/Conjugate_prior与 二项式 和 伯努利 分布的共轭先验。在我的下一篇文章中，我们将深入探讨这到底意味着什么，然而在这里，我们将只是获得 Beta 分布背后的一些直觉。

数学定义

和往常一样，我喜欢从数学公式开始，然后深入研究分布的直觉。

贝塔分布的 概率密度函数(PDF) 为:

作者在 LaTeX 中生成的方程。

其中 0 ≤ x ≤ 1， 因此可以解释为我们上面提到的概率。

这里有一个 StatExchange 线程链接这里展示了 Beta 发行版的 PDF 的派生。

我们可以看到，它是由两个变量 α 和 β 和 B(α，β) 是β函数 它是归一化常数:

作者在 LaTeX 中生成的方程。

其中γ(α)是γ函数 :

作者在 LaTeX 中生成的方程。

你可以在我之前的帖子中读到更多关于伽马函数和 伽马分布的信息:

直觉

考虑贝塔分布的 PDF 的分子:

作者在 LaTeX 中生成的方程。

这让你想起什么了吗？

没错，就是很像二项分布 PDF:

作者在 LaTeX 中生成的方程。

即在给定概率下从【x】事件中获得 n 成功的概率

例如，从 10 硬币中准确翻转出 6 人头的概率是 0.20508。

我们可以看到二项式分布和贝塔分布非常相似，除了一个关键点:

对于贝塔分布，概率是一个我们试图估计的随机变量。
对于二项分布，概率是一个固定参数，我们用它来推断 n 成功的概率。

因此，我们可以在已知成功次数、【α-1】、* 和失败次数、 β -1 的情况下，用贝塔分布来估计一个事件的概率。*

示例和图表

现在让我们通过几个例子来使这个理论更加具体。

让我们假设我们抛一枚有偏向的硬币 50 次，它正面着地 30 次，反面着地 20 次。

在这种情况下，我们有 30 次成功和 20 次失败，贝塔分布图如下:

*# Import packages
from scipy.stats import beta as beta_dist
import matplotlib.pyplot as plt
import numpy as np# Plot the distribution
alpha = 31
beta = 21
x = np.arange (0, 1, 0.01)
y = beta_dist.pdf(x, alpha, beta)
plt.figure(figsize=(11,6))
plt.plot(x, y, linewidth=3)
plt.xlabel('x', fontsize=20)
plt.ylabel('PDF', fontsize=20)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.axvline(0.6,  linestyle = 'dashed', color='black')
plt.show()*

作者用 Python 生成的图。

我们看到，这枚硬币正面朝上的最大概率是 0.6，，这可以理解为 30/50 = 0.6 。

此外，注意在 0.4 之前和 0.8 之后，硬币呈现这些值的概率实际上是 0 。如果我们获得更多的数据，比如说 100 个人头翻转 60 个人头，我们会看到这个峰值变窄，因为我们更确信人头的概率确实是 0.6 。

记住 y 轴大于 1 的原因是因为这是概率密度函数。为了得到实际的概率，我们需要对概率密度函数进行积分，得到 概率质量函数 。

现在让我们抛另一枚硬币，得到 100，000 个正面和 100，000 个反面。该数据的贝塔分布为:

*alpha = 100_000
beta = 100_000
x = np.arange (0, 1, 0.01)
y = beta_dist.pdf(x, alpha, beta)
plt.figure(figsize=(11,6))
plt.plot(x, y, linewidth=3)
plt.xlabel('x', fontsize=20)
plt.ylabel('PDF', fontsize=20)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.show()*

作者用 Python 生成的图。

我们现在看到峰值更窄，在 0.5 处。这是因为我们有更多的平衡数据，所以我们更确定这个硬币翻转的真实概率。

情节的完整代码可以在我的 GitHub 这里获得:

*https://github.com/egorhowell/Medium-Articles/blob/main/Statistics/Beta_Distribution.ipynb

结论

在这篇文章中，我们以定量和定性的方式描述了 Beta 分布，以及一些带有一些数据的基本图表，以获得背后的直觉。

在我的下一篇文章中，我们将解释贝叶斯统计中的共轭先验，以及贝塔分布是多么有用！

和我联系！

要在媒体上阅读无限的故事，请务必在这里注册！T35💜
😀
LinkedIn👔
推特 🖊
GitHub 🖥
https://www.kaggle.com/egorphysics🏅

(所有表情符号都是由 OpenMoji 设计的——开源的表情符号和图标项目。许可证: CC BY-SA 4.0***

使用 Python 的 Matplotlib 进行更好的注释

原文：https://towardsdatascience.com/better-annotations-with-pythons-matplotlib-46815ce098df

如何在 Matplotlib 中轻松定制文本的快速指南

咖啡豆生产——作者图片

文本是为我们的数据可视化增加价值的一种无与伦比的方式。我们可以将注意力吸引到图表的特定方面，解释一个模式，或者给出关于该主题的额外信息。

本文将探讨如何用高亮文本格式化 Matplotlib 文本。

对于下面的例子，我将使用来自数据中我们的世界的咖啡产量数据。

先说简单的。我们将绘制 2018 年咖啡产量最高的四个国家的历史数据。

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd#[https://ourworldindata.org/grapher/coffee-bean-production](https://ourworldindata.org/grapher/coffee-bean-production)
df = pd.read_csv('../data/coffee-bean-production.csv')countries = ['Brazil', 'Vietnam', 'Indonesia', 'Colombia']
colors = ['#36AD63', '#EEEE50', '#DE4A43', '#3765B1']#figure
fig, ax = plt.subplots(1, figsize=(12,6))
ax.set_facecolor('#202020')# plot
for i, country in enumerate(countries):
    plt.plot(df[df['Entity'] == country].Year, df[df['Entity'] == country].tonnes, color=colors[i])# grid lines
ax.set_axisbelow(True)
ax.yaxis.grid(color='gray', linestyle='dashed', alpha=0.2)
ax.xaxis.grid(color='gray', linestyle='dashed', alpha=0.2)# ticks and labels
plt.xticks(np.arange(df.Year.min(),df.Year.max()+1, 3))
plt.ylabel('Tonnes')
ax.set_yscale('log')# legend and title
plt.legend(countries)
plt.title('Coffee bean production by year', loc='left')
plt.show()

咖啡豆生产——作者图片

没关系。但是有几个方面需要改进。

我想使标题更加突出，并在它下面添加图例作为我的副标题的一部分。我还想在图片底部写一些注释和这些数据的来源。

字幕和标题在 Matplotlib 中并不像我们预期的那样直观；对他们来说没有任何作用。

我们可以对副标题使用带有标题功能的换行符，但是没有办法对每一行进行不同的格式化。如果我们想让我们的字幕与众不同，我们需要同时使用标题和文本功能，然后努力调整坐标来放置字幕。

高亮文本

这个简单的包为我们在 Matplotlib 中格式化文本提供了很大的自由度。它允许我们拥有一个具有多种不同格式的字符串。

我们需要创建一个包含文本属性的字典列表。然后我们用标签(<>)为我们将要使用的不同格式编写字符串。

**from highlight_text import HighlightText, ax_text, fig_text**
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd#[https://ourworldindata.org/grapher/coffee-bean-production](https://ourworldindata.org/grapher/coffee-bean-production)
df = pd.read_csv('../data/coffee-bean-production.csv')countries = ['Brazil', 'Vietnam', 'Indonesia', 'Colombia']
colors = ['#36AD63', '#EEEE50', '#DE4A43', '#3765B1']#figure
fig, ax = plt.subplots(1, figsize=(12,6))
ax.set_facecolor('#202020')# plot
for i, country in enumerate(countries):
    plt.plot(df[df['Entity'] == country].Year, df[df['Entity'] == country].tonnes, color=colors[i])# grid lines
ax.set_axisbelow(True)
ax.yaxis.grid(color='gray', linestyle='dashed', alpha=0.2)
ax.xaxis.grid(color='gray', linestyle='dashed', alpha=0.2)# ticks and labels
plt.xticks(np.arange(df.Year.min(),df.Year.max()+1, 3))
plt.ylabel('Tonnes')
ax.set_yscale('log')# legend and title
plt.legend(countries)**highlight_textprops = [{"fontsize":16, "color":'k'},
                       {"fontsize":14, "color":'#202020'}]****fig_text(x=0.125, y=0.9, va='bottom',
         s='<Tonnes of coffee bean produced by year>\n<Four highest producers of 2018>',
         highlight_textprops=highlight_textprops,
         ax=ax)**plt.show()

咖啡豆生产——作者图片

这使得我们可以快速地在一个对象中编写标题和副标题。

功能

字幕可以给我们的图表增加很多东西，有一种实用的添加方式是受欢迎的。但是一种更简单的格式化文本的方法提供了增强的可能性，这是默认使用 Matplotlib 所不能忍受的。

我们现在可以通过明确命名字幕中的每一行并格式化每个单词的背景来替换图例。

from highlight_text import HighlightText, ax_text, fig_text
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd#[https://ourworldindata.org/grapher/coffee-bean-production](https://ourworldindata.org/grapher/coffee-bean-production)
df = pd.read_csv('../data/coffee-bean-production.csv')countries = ['Brazil', 'Vietnam', 'Indonesia', 'Colombia']
colors = ['#36AD63', '#EEEE50', '#DE4A43', '#3765B1']#figure
fig, ax = plt.subplots(1, figsize=(12,6))
ax.set_facecolor('#202020')# plot
for i, country in enumerate(countries):
    plt.plot(df[df['Entity'] == country].Year, df[df['Entity'] == country].tonnes, color=colors[i])# grid lines
ax.set_axisbelow(True)
ax.yaxis.grid(color='gray', linestyle='dashed', alpha=0.2)
ax.xaxis.grid(color='gray', linestyle='dashed', alpha=0.2)# ticks and labels
plt.xticks(np.arange(df.Year.min(),df.Year.max()+1, 3))
plt.ylabel('Tonnes')
ax.set_yscale('log')highlight_textprops = [{"fontsize":16, "color":'k'},
                       {"fontsize":14, "color":'#202020'},
                       **{"bbox": {"facecolor": "#36AD63", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'w'},
                       {"bbox": {"facecolor": "#EEEE50", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'k'},
                       {"bbox": {"facecolor": "#DE4A43", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'w'},
                       {"bbox": {"facecolor": "#3765B1", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'w'}**]fig_text(x=0.125, y=0.9,
              va='bottom',
              s='<Tonnes of coffee bean produced by year>\n<Four highest producers of 2018: >**<Brazil> , <Vietnam> , <Indonesia> , <Colombia>'**,
              highlight_textprops=highlight_textprops,
              ax=ax)plt.show()

咖啡豆生产——作者图片

同样，我们可以在图表底部区分注释和数据源。

我们甚至可以将字体颜色与背景颜色相匹配，创建一个空行，将两者分开。

from highlight_text import HighlightText, ax_text, fig_text
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd#[https://ourworldindata.org/grapher/coffee-bean-production](https://ourworldindata.org/grapher/coffee-bean-production)
df = pd.read_csv('../data/coffee-bean-production.csv')countries = ['Brazil', 'Vietnam', 'Indonesia', 'Colombia']
colors = ['#36AD63', '#EEEE50', '#DE4A43', '#3765B1']#figure
fig, ax = plt.subplots(1, figsize=(12,8))
ax.set_facecolor('#202020')# plot
for i, country in enumerate(countries):
    plt.plot(df[df['Entity'] == country].Year, df[df['Entity'] == country].tonnes, color=colors[i])# grid lines
ax.set_axisbelow(True)
ax.yaxis.grid(color='gray', linestyle='dashed', alpha=0.2)
ax.xaxis.grid(color='gray', linestyle='dashed', alpha=0.2)# ticks and labels
plt.xticks(np.arange(df.Year.min(),df.Year.max()+1, 3))
plt.ylabel('Tonnes')
ax.set_yscale('log')# title
highlight_textprops = [{"fontsize":16, "color":'k'},
                       {"fontsize":14, "color":'#202020'},
                       {"bbox": {"facecolor": "#36AD63", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'w'},
                       {"bbox": {"facecolor": "#EEEE50", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'k'},
                       {"bbox": {"facecolor": "#DE4A43", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'w'},
                       {"bbox": {"facecolor": "#3765B1", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'w'}]fig_text(x=0.125, y=0.9,
              va='bottom',
              s='<Tonnes of coffee bean produced by year>\n<Four highest producers of 2018: ><Brazil> , <Vietnam> , <Indonesia> , <Colombia>',
              highlight_textprops=highlight_textprops,
              ax=ax)**# footnotes
notes_textprops = [{"fontsize":11, "color":'#202020'},
                   {"fontsize":8, "color":'w'},
                   {"fontsize":12, "color":'#202020'},
                   {"fontsize":11, "color":'#505050'}]****fig_text(x=0.125, y=0.07,
              va='top',
              s='<* Y-Axis is a log scale>\n<blankline>\n<Source:> <ourworldindata.org/grapher/coffee-bean-production>',
              highlight_textprops=notes_textprops,
              ax=ax)**plt.show()

咖啡豆生产——作者图片

注释

使用 HighlightText 进行注释也同样简单。

代替 fig_text 函数，我们可以使用 ax_text，它使用我们的轴的坐标。

与图例类似，注释也可以受益于颜色。我们可以用它来关联其他元素——使用与注释线相同的颜色。

我们可以用它来突出或弱化上面的信息。

from highlight_text import HighlightText, ax_text, fig_text
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd#[https://ourworldindata.org/grapher/coffee-bean-production](https://ourworldindata.org/grapher/coffee-bean-production)
df = pd.read_csv('../data/coffee-bean-production.csv')countries = ['Brazil', 'Vietnam', 'Indonesia', 'Colombia']
colors = ['#36AD63', '#EEEE50', '#DE4A43', '#3765B1']#figure
fig, ax = plt.subplots(1, figsize=(12,8))
ax.set_facecolor('#202020')# plot
for i, country in enumerate(countries):
    plt.plot(df[df['Entity'] == country].Year, df[df['Entity'] == country].tonnes, color=colors[i])# grid lines
ax.set_axisbelow(True)
ax.yaxis.grid(color='gray', linestyle='dashed', alpha=0.2)
ax.xaxis.grid(color='gray', linestyle='dashed', alpha=0.2)# ticks and labels
plt.xticks(np.arange(df.Year.min(),df.Year.max()+1, 3))
plt.ylabel('Tonnes')
ax.set_yscale('log')# title
highlight_textprops = [{"fontsize":16, "color":'k'},
                       {"fontsize":14, "color":'#202020'},
                       {"bbox": {"facecolor": "#36AD63", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'w'},
                       {"bbox": {"facecolor": "#EEEE50", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'k'},
                       {"bbox": {"facecolor": "#DE4A43", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'w'},
                       {"bbox": {"facecolor": "#3765B1", "linewidth": 0, "pad": 1.5}, "fontsize":14, "color":'w'}]fig_text(x=0.125, y=0.9,
              va='bottom',
              s='<Tonnes of coffee bean produced by year>\n<Four highest producers of 2018: ><Brazil> , <Vietnam> , <Indonesia> , <Colombia>',
              highlight_textprops=highlight_textprops,
              ax=ax)# footnotes
notes_textprops = [{"fontsize":11, "color":'#202020'},
                   {"fontsize":8, "color":'w'},
                   {"fontsize":12, "color":'#202020'},
                   {"fontsize":11, "color":'#505050'}]fig_text(x=0.125, y=0.07,
              va='top',
              s='<* Y-Axis is a log scale>\n<blankline>\n<Source:> <ourworldindata.org/grapher/coffee-bean-production>',
              highlight_textprops=notes_textprops,
              ax=ax)# annotations
ax_text(x = 1987, y = 20000, ha='left', color='w',
        s='<Vietnam>\nDoi Moi <(1986)>',
        highlight_textprops=[{"color": '#EEEE50'},
                             {"color": 'grey'}],
        ax=ax)plt.show()

结论

总的来说，HighlightText 是一个很棒的软件包，可以让我们的可视化更上一层楼。能够毫不费力地格式化文本的各个部分给了我们很多自由。

尽管它是 0.2 版本，我在使用这个包的时候没有发现很多问题。

大部分时间我都很难在 Jupyter 进行绘图，那里的绘图会剪掉标题和注释。但是，在保存图形时不会发生这种情况。

当我尝试更广泛的文本时，我也遇到了一些麻烦。为更广泛的注释添加适当空间的支线剧情可以解决这些问题。

感谢阅读我的文章。

资源: https://github.com/znstrider/highlight_text；
https://ourworldindata.org/grapher/coffee-bean-production；
https://en.wikipedia.org/wiki/Economic_history_of_Vietnam；

我是如何试图革新脚本体验的

原文：https://towardsdatascience.com/better-bash-scripts-ae542fa37bd6

Bashy 背后的故事 Bash 脚本的脚本管理器

在本文中，我将介绍开源项目 Bashy，这是一个工具，它通过简化参数解析和像每个包管理器一样共享脚本来增强脚本体验。换句话说，我让 work Bash 像任何现代脚本框架一样。对于程序员和数据科学家来说，这有助于提高生产率和自动化重复性任务。

我将解释为什么我们需要一个像 Bashy 这样的工具，然后用一些实际例子展示如何使用它。最后，在我们发现它如何为开发人员节省数百个小时之后，我将进入内部组件来解释它是如何工作的。

让我们直接进入文章吧！

作者是❤️by。

我们为什么需要巴什？

Bashy 的目的是减少脚本编写中的摩擦。最常见的问题是:

解析输入并为我们创建的脚本提供帮助页面。这通常很麻烦，需要很多时间，所以这个阶段经常被跳过，我们有很难运行的脚本。通常，开发人员需要打开它们，并更改脚本本身内部的变量。
共享脚本。共享脚本最常见的方式是将文件从一台 PC 或服务器复制/粘贴到另一台 PC 或服务器。这种做法是非常古老的风格，很难在副本发生变化时更新脚本。

Bashy 愿意通过实施以下措施来解决所有这些问题:

Bash 的包管理器
解析参数的简单方法。

使用 bash 脚本的摩擦

Bash 脚本解决了很多问题，但是在大多数情况下:

驻留在作者的个人电脑上:分享它们是非常困难的
不是参数化的:参数在脚本内部，作者直接更改它们，而不是解析参数

为什么？现在这种行为看起来很奇怪，但是如果你看看有什么选择，很明显开发商没有选择。事实上:

没有任何存储库可以让你的脚本共享
使脚本参数化，需要大量代码

这就是我创造 Bashy 的原因:

BASHY 的目的就是要克服这个局限

既然我们已经理解了创建管理 bash 脚本的工具的重要性，那么让我们看看它在实践中是如何工作的！

从结果开始介绍 Bashy】

与其说很多 Bashy，我更愿意用一个例子来解释。让我们假设创建一个 bash 脚本，列出文件夹中的文件。给定的参数是用于过滤文件的文件夹路径和扩展名。

那么，为了在 bash 解析参数中实现它，您将在下面的代码片段中看到类似这样的内容。

传统 bash 脚本

请注意，在前面的脚本中，实现脚本只需要最后两行代码，上面所有的 34 行代码只需要用于解析参数。此外，您没有任何帮助页面，添加新参数会使事情变得复杂。巴什如何能让它变得更好？

使用 Bashy，您只需编写以下代码:

如您所见，您已经免费解析了参数，并且已经填充了一些可以使用的变量。这转化为一个巨大的简化，正如您稍后看到的，您还可以获得一个帮助页面，而无需任何额外的工作。

那是魔法？让我们在下一节看看这是如何可能的。

怎么可能呢？

因为信息是一门科学，所以没有咒语或魔杖。Bashy 的支柱是通过添加 YAML 格式的清单来描述脚本。YAML 和脚本一起构成了一个可移植的包，包含了 Bashy 需要的所有内容。

包装是如何制作的？作者是❤️by

下面的代码片段可以作为前面脚本的一个示例:

bashy 中阅读文件夹的脚本。作者是❤️by。

YAML 清单包含要在帮助页面上显示的所有信息和要执行的脚本(可以像在本例中那样嵌入，或者引用外部资源)。此外，您定义了参数解析引擎使用的参数列表。

此信息用于创建帮助页面，如下例所示:

命令帮助示例。作者是❤️by。

如您所见，该命令从 Bashy 注册为全局命令，您可以直接编写它，因为它是安装在操作系统上的真正的二进制文件。

用这种技术制作的脚本可以很容易地共享(你只需要在每一个 HTTP 服务器上发布，包括 git ),并帮助构建更多可用的脚本。

但是如何实施呢？Bashy 引擎是使用 Go 构建的，并作为开源应用程序提供。

巴什是怎么做出来的。作者和❤️一起做的

下图显示了应用程序的主要流程:

应用程序的主要流程，由作者用❤️制作

基本上，Bashy 引擎将 YAML 文件中包含的信息添加到内部数据库中(红色流)。有了这些信息，您就可以轻松地列出所有可用的命令，并提供帮助页面(蓝色流)。最后，Bashy 可以通过解析参数并将值作为变量传递给要运行的脚本来执行命令。然后将输出显示给用户。

要了解有关 bashy 的更多信息，您可以:

阅读教程“编写 Bash 脚本的有效方法”，或者
阅读我一步一步解释 Bashy 是如何制作的文章我如何在 GO 中创建脚本引擎

顺便说一句，我认为巴什的潜力还没有完全发挥出来。在下一节中，我将解释下一个可以添加的特性，以使它更加平滑。

后续步骤

像每个产品一样，开源应用程序也必须关注市场和用户的需求。从这里开始，您可以获得要添加到 backlog 中的特性列表。从我的经验和目前为止我得到的反馈来看，有一些改进可能会非常有用。我在下一张图中总结了它们:

巴什的下一步。由❤️by 执笔

因此，引用《精益创业》的作者埃里克·赖斯的话:

我们必须了解顾客真正想要的是什么，而不是他们说他们想要什么，或者我们认为他们应该想要什么。

这促使我去倾听用户对这些任务给予正确优先级的反馈。

基本上，最想要的特性是添加一个公共存储库，在那里添加脚本，允许用户通过 web UI 搜索它们，并在本地安装它们。此外，一个令人窒息的安装过程也是受欢迎的，因为网站上有更好的文档。

无论如何，任何反馈都是受欢迎的，也是改进过程的一部分！所以，如果你是一个 Bashy 用户或者你打算测试它，别忘了给我反馈😃

结论

Bash 是一种被广泛使用的技术，但是也有一些摩擦，使得它很难实现可重用的脚本。Bashy 的诞生就是为了克服这些问题，释放 bash 的力量。与每个产品一样，开源项目也需要倾听用户的需求，因此向作者提供反馈很重要(一般来说是这样，不仅仅是对 Bashy)。我希望能给你一个提高剧本体验的机会，不要犹豫，请在评论中写下你的反馈😄

参考资料:

GitHub 资源库https://github.com/zeppaman/bashy
Bashy 教程"编写 Bash 脚本的有效方法
深入了解程序内部的技术"我如何在 GO 中创建脚本引擎

更好的流失预测

原文：https://towardsdatascience.com/better-churn-prediction-f88b20c923f3

流失还是不流失——这不是真正的问题！

来自 Pixabay 的灵感

这些年来，我一直在研究的一个主要课题是客户流失。减少客户流失是许多公司的首要任务，正确识别其根本原因可以大大提高他们的底线。

考虑到客户流失问题是多么广为人知和受重视，我经常被它在实践中的糟糕建模所困扰。

客户流失通常被表述为“谁最有可能流失？”。这个问题自然适合于分类建模。

然而，我认为客户流失并不是“谁”会流失的问题，而是“什么时候”流失的问题。

这是一个重要的区别，原因有二:

问“谁”会流失会导致有偏见的建模，如下所示。
在很多情况下，用户的价值很大程度上取决于他的订阅时间。这只能通过问“什么时候”而不是“谁”来回答。

手机用户示例

以手机用户的经典案例为例。他们每月支付一笔费用，直到某个时间点，他们决定终止合同(又名流失)。

最终它们都会发生变化:30 年后，它们要么会死去，要么会用全息图而不是手机来交流。

让我们想象一下典型订阅的样子:

顶层的第一个订户于 2021 年 6 月开始购买 A 计划，并于 2022 年 4 月开始购买。斜线代表“今天”(分析运行的时间)，即 2022 年 6 月 8 日。

在“谁”问题中，过去(在“今天”之前)搅动过的用户被标记为“搅动的”(y=1)，而未来搅动过的用户被标记为“未搅动的”(y=0)，因为当我们“今天”观察他们时，他们仍然是订阅的。

我们可以看到，计划 A 的用户倾向于花费更长的时间来流失(他们的队伍更长)。但是由于他们比 B 计划的订阅者更早加入，他们有更多的时间流失，也更容易被贴上“流失”的标签(A 计划的 50%对 B 计划的 25%)。

因此，我们会错误地得出这样的结论:A 计划用户的流失率高于 B 计划用户。

上述偏见是非常典型的，因为手机计划通常是相继推出的。在上面的例子中可以看到，在 2022 年 1 月，计划 A 被切换到计划 b。

一项小型模拟研究

为了说明这一点，我将在 r。

我们有一个从 0 开始的时间表。我们观察数据和拟合模型的时间(“今天”)是 22。

如果用户使用计划 A，则他开始订阅的时间来自均匀分布(U~[0，20]\ ),如果用户使用计划 b，则来自均匀分布(U~[20，22])。

today <- 22 
Na <- 700 
Nb <- 300 
plan <- rep(c("A", "B"), time = c(Na, Nb)) 
set.seed(1) 
join_time <- c(runif(Na, 0, 20), runif(Nb, 20, today))

下面我们可以看到平均加入时间:

tapply(join_time, plan, mean)##        A        B 
## 10.08968 20.97702

用户在交易前的订阅时间分布为泊松分布，如果他使用计划 A，则λ= 4，如果他使用计划 b，则λ= 3。

set.seed(1) 
time_to_churn <- c(rpois(Na, 4), rpois(Nb, 3))

下面我们可以看到客户流失的平均时间:

tapply(time_to_churn, plan, mean)##        A        B 
## 4.045714 2.993333

用户搅动的时间是他加入的时间+直到他搅动的时间:

churn_time <- join_time + time_to_churn

如果搅动时间大于 22(从“今天”算起的未来)，我们说他没有被搅动(y=0)。如果那个时间比我们今天短一天，他就做了搅动(y=1)。

churned <- churn_time < today

从原始流失率来看，我们可以看到计划 A 的用户流失率似乎更高:

tapply(churned, plan, mean)##         A         B 
## 0.8042857 0.2233333

但是我们知道 B 计划的用户是最近加入的，所以我们可能会尝试通过拟合用户流失与计划的逻辑回归以及用户加入后的时间来考虑这一点。

然而，从下面我们可以看到，这种偏差如此之大，以至于模型仍然告诉我们，采用 B 计划可以降低客户流失的可能性:

time_since_join <- today - join_time glm(churned ~ plan + time_since_join)## 
## Call:  glm(formula = churned ~ plan + time_since_join)
## 
## Coefficients:
##     (Intercept)            planB  time_since_join  
##         0.19101         -0.02035          0.05149  
## 
## Degrees of Freedom: 999 Total (i.e. Null);  997 Residual
## Null Deviance:       233.1 
## Residual Deviance: 102.9     AIC: 572.3

我们该怎么办？

用生存分析！

为了避免这篇文章太长，我将跳过介绍什么是生存分析，而是展示它是如何处理上述偏见的。

生存分析武库中的一个常见模型是“加速故障时间”模型。它产生的系数很像逻辑回归:

library(survival) 
observed_time <- ifelse(churned, time_to_churn, today - join_time) 
# add a tiny amount (0.01) to observed_time to avoid observed_time = 0 
survregExp <- survreg(Surv(observed_time + 0.01, churned) ~ plan, dist = "exponential" ) coef(survregExp)## (Intercept)       planB 
##   1.4558659  -0.2154432

我们对系数的解释如下:与总体平均值相比，采用 B 计划可以减少 20%的流失时间(1-exp(-0.2154432)= 0.2)。流失的平均人口时间是:

mean(time_to_churn)## [1] 3.73

B 计划的平均流失时间是 3，比 3.7 低 20%。

结论

问“什么时候”而不是“谁”的问题不仅能给我们公正的结果，还能让我们更深入地了解我们真正感兴趣的是什么:用户流失需要多长时间。

在接下来的几篇文章中，我将更深入地讨论生存分析，并展示流失预测中的高级用例，生存分析对于更好的流失建模至关重要。

原载于 2022 年 6 月 8 日https://iyarlin . github . io。

更好的客户流失预测—使用生存分析

原文：https://towardsdatascience.com/better-churn-prediction-part-2-5a1086fd3f51

回答“何时”的问题

由马库斯·斯皮斯克在 Unsplash 上拍摄的照片

在之前的帖子中，我提出了生存分析对于更好地预测客户流失是必不可少的。我的主要论点是，客户流失不是“谁”的问题，而是“何时”的问题。

在“何时”问题中，我们问用户何时会流失？换句话说，用户平均订阅多长时间？然后，我们可以回答一个最重要的问题:订户的平均生命周期值是多少？

让我们卷起袖子开始吧:生存曲线 S(t)衡量订户从开始订阅到时间 t“存活”(而不是流失)的概率。例如，S(3)=0.8 意味着订户在订阅的第 3 个月有 80%的机会不进行交易。

估算 S(t)最常用的方法是使用卡普兰-迈耶曲线，其公式如下:

作者图片

其中，t_i 是至少有一个用户流失的所有时间，d_i 是在 t_i 时流失的用户数量，n_i 是至少存活到 t_i 时的用户数量，我们可以将 d_i/n_i 项视为 t_i 时的流失率。

为了说明，让我们计算以下订户数据的存活曲线:

作者图片

列 t 表示到今天为止用户已经订阅的时间。如果他搅拌，这将是他搅拌的时间。

我们有 2 次流失事件发生的时间:t_i = {2，6}。

对于 t < 2，我们有 S(t)=1，因为没有人搅拌到这一点。

在 t_1=2 时，我们有 d_1=2(订户 3 和 6)和 n_1=5(除了 4 之外的所有订户)。使用上面的公式，我们得到:

作者图片

在 t_2=6 时，我们有 d_2=1(订户 2)和 n_2=1(同样，只有订户 2)。

因此，我们有:

作者图片

让我们画出这条曲线:

作者图片

这里需要注意的一点是，在曲线上的每一点，我们只考虑存活到该点的订户。如果订户是最近加入的(例如订户 4 ),则他在计算中不会起主要作用。

实际上，您最好使用 R [survival](https://cran.r-project.org/web/packages/survival/)包或 python [lifelines](https://lifelines.readthedocs.io/en/latest/)库中的生存曲线实现。

预期寿命

那么，为什么要首先计算 S(t)呢？结果是预期寿命是生存曲线下的面积(这里我不打算证明)。

所以在我们上面的例子中:

作者图片

例如，如果用户的月计划账单是 10 美元，那么我们可以说他的预期 LTV(生命周期价值)是 44 美元。

更好地回答“谁”的问题

在这篇文章中，我们看到了如何使用生存曲线来回答“何时”的问题——平均订阅多长时间。我们看到这可以用来表示订户的价值。

有时候，我们实际上也可能对“谁”这个问题感兴趣。例如“哪些订户在订阅的第一个月内最有可能流失”？在我的下一篇文章中，我将展示使用生存曲线我们也能更好地回答这个问题！

原载于 2022 年 10 月 31 日https://iyarlin . github . io。

更好的指标⇏更快乐的用户

原文：https://towardsdatascience.com/better-metrics-happier-users-8264479e4fba

设计一个机器学习产品来关闭用户反馈回路

乔恩·泰森在 Unsplash 上的照片

我想象这个“假设的”场景:由于检测到一些“重要”类别的低精确度，开发了一个新的模型来代替现有的生产模型。新模型的指标要好得多，因此它被部署来取代当前的模型。

事实证明，新模式实际上让用户体验更差。即使它在指标上更好，用户也不觉得它更好。事后分析显示，尽管总体指标更好，但新模型牺牲了用户最关心的类的准确性，以改善用户不太关心的类。

最初的假设是更好的指标更好的模型当然更好的模型更快乐的用户。这个假设有严重缺陷。更好的度量可能意味着更好的模型，但仅仅是由度量判断的更好的模型。由指标判断的更好的模型并不意味着更快乐的用户，由用户判断的更好的模型意味着更快乐的用户。虽然这似乎很明显，但产品开发的谁和 为什么 在机器学习领域往往被遗忘。

本文将介绍用户反馈回路的概念，它是任何 ML 产品设计中的重要组成部分。我们将讨论常见评估和监控方法的缺点，以及我们如何通过在机器学习开发过程中实现这一概念来减轻用户的不满。

初始定义t34】∘监控t37】∘用户(或客户)反馈回路
评估&监控
∘ 资源与性能监控
∘ 地面真实指标
∘ 代理指标
∘ 问题
以用户为中心的设计t16】∘定义t19】∘UCD+ml
引入用户反馈回路
∘ 以用户为中心的指标
∘ 以用户为中心的监控
∘ 以用户为中心的部署
谨防偏见
结论

初始定义

我将从定义本文中使用的关键术语开始。

监视

监控的目标是确保模型得到正确服务，并且模型的性能保持在可接受的范围内[1]

用户(或顾客)反馈回路

注:我更喜欢使用术语“ 用户 反馈回路”而不是“ 客户 反馈回路”，作为一个用户同时兼顾客户前景。然而，这些术语经常互换使用。

“客户反馈循环是一种客户体验策略，旨在根据用户评论、意见和建议不断增强和改进您的产品。”[2]

反馈循环很重要，因为没有用户反馈，你怎么能指望一个组织(其主要目标是向客户销售)在向客户销售方面做得更好？

传统上，“闭合反馈回路”是:

“…针对具体的产品反馈进行有针对性的个性化跟进沟通。闭环意味着让你的用户知道你是如何根据他们的意见改进产品的。”[3]

然而，在机器学习的上下文中，它被更好地定义为:

利用用户对模型输出的反馈来影响模型开发的优先级。

一个重要的区别是与 ML 中经常描述的传统“反馈回路”的区别，在传统“反馈回路”中，模型的输出用于重新训练模型。这是指数学反馈，而不是用户反馈。

评估和监测

卢克·切瑟在 Unsplash 上的照片

在这一节中，我们将讨论评估模型的当前方法，在监控阶段用于评估模型退化的度量，以及最重要的通用方法的问题。

资源与性能监控

资源监控包括监控模型部署的周围基础设施。这是一个传统的 DevOps 主题，除了提到它试图回答的这些关键问题之外，我们不会在本文中讨论它:

“系统还活着吗？CPU、RAM、网络使用和磁盘空间是否符合预期？请求是否以预期的速度得到处理？”[4]

性能监控包括监控实际模型。

关键问题包括:模型是否仍然是新数据模式的准确表示？它的性能是否和设计阶段一样好？”[4]

如何有效地回答关于性能监控的问题是我们将在本文中讨论的内容。

基本事实度量

“基本事实”指标是一个指标“…已知是真实的或真实的，由直接观察和测量提供”【5】。在机器学习中，模型将产生的预期理想结果。有两种类型的地面实况度量:实时和延迟。我们还会提到有偏见的基本事实度量和基本事实的缺失。对于下面描述的所有示例，如果您想要更深入的描述，请参见[6]。

理想情况是实时地面实况。这就是“…对于每个预测，基本事实都浮现在你面前，并且在预测和基本事实之间有直接的联系，允许你直接分析你的模型在生产中的性能”[6]。一个常见的例子是数字广告，根据用户的行为，你会收到关于广告投放是否成功的近乎即时的反馈。

比较常见的案例是拖延地真相。顾名思义，这是模型输出和学习你的模型应该如何执行之间有很大延迟的情况。一个常见的例子是欺诈检测:我们不知道某些交易是否是欺诈性的，直到持卡人报告它们是欺诈性的，这通常比交易日期晚得多。

实时和延迟地面实况的一个共同问题是偏差。我们以贷款违约预测为例。我们只能从负面预测(不会违约)中收集基本事实，我们无法收集任何关于正面预测(会违约)的信息，因为我们拒绝了他们的贷款。

最后，我们会遇到没有地面真相可用的情况。在这种情况下，我们通常可以使用代理指标。

代理指标

如果我们正在处理延迟、缺失或有偏见的实时真相，我们经常使用代理指标，或者除了基础真相指标之外。他们制定了一个代表模型性能的指标，而没有使用基本事实。代理指标“…为您的模型的表现提供一个更新的指标”[6]。它们还允许你将业务成果的重要性纳入你的衡量标准。

代理指标最常见、最广泛使用的例子是数据漂移和概念漂移。理论上，自变量和/或因变量中出现的漂移可能代表模型性能下降。

问题

关于如何监控生产模型，有大量(通常是坏的)建议。但是，很难找到考虑到 实际用户 的建议。大多数建议都是基于对构建不良的代理指标的过度依赖。问题来了:代理指标并不完美。它们旨在代表性能，而非直接指示。当不理解这种区别时，问题就出现了。

罪魁祸首是漂移，创造了 ML 监控的“以漂移为中心”的观点[7]，其中漂移被假设为模型性能的完美指标。像所有的代理指标一样，漂移是不完美的，完全依赖它不是模型监控的有效策略。

说明这一点的一个例子是使用合成数据来训练对象检测模型。研究表明真实世界的数据最多可以减少 70%(用合成数据代替)，而不会牺牲模型性能。我们预计合成数据的分布会与真实世界的数据大相径庭，但这种转变不会影响性能。

这并不是说永远不应该使用漂移。漂移应在监控中使用“…如果您有理由相信某个特定特征会漂移并导致您的模型性能下降”[7]。然而，它不应该作为唯一的衡量标准。**

总而言之，

在常见的监控方法中使用代理指标所导致的问题是由模型评估和用户反馈之间的脱节引起的。

为了使代理指标有效，真正代表模型性能，并衡量什么是重要的，它必须以用户为中心的观点来形成。

用户为中心的设计

在 Unsplash 上由amlie Mourichon拍摄的照片

定义

“以用户为中心的设计(UCD)是一系列将用户放在产品设计和开发中心的过程。你开发你的数字产品时会考虑用户的需求、目标和反馈。

换句话说，以用户为中心的设计是从用户如何理解和使用的角度来设计和开发产品，而不是让用户调整他们的行为来使用产品。" [8]

UCD + ML

虽然 UCD 的传统定义非常适合产品设计，但它如何应用于模型评估和监控呢？

[8]定义的两个主要 UCD 原则是:

用户早期积极参与评估产品的设计。
结合用户反馈来定义需求和设计。

这些概念似乎很熟悉。还记得用户反馈循环吗？我们现在将讨论如何在模型评估和监控阶段实现用户反馈循环。

引入用户反馈循环

营销“用户反馈环”(图片由作者提供)

以上是一个传统营销“用户反馈回路”的流程。从用户开始，循环的关键动作是:

提问:让你的用户参与进来，并征求对你产品的反馈。常见的反馈来源直接来自用户，如访谈和调查。来自客户成功和销售等团队的间接反馈也很有价值。
集中 : “当反馈被埋藏在一个文件夹中或分散在各种不一致的电子表格中时，将反馈转化为行动是很困难的”[3]。反馈应持续收集并集中在“反馈湖”中。这通常采取集中式数据共享解决方案的形式，例如用于所有电子表格、采访等的集中式 Google Drive 文件夹。，但也可以简单到一个#反馈松弛通道。反馈湖将是非常无序的，并且将包含相当多的噪声。别担心:这才是重点。我们希望打破任何阻碍组织中的任何人分享他们从用户那里收到的反馈的障碍。我们将在下一步处理这个问题。
标签&汇总:为了获得可操作的见解，反馈必须以某种可理解的方式进行分类。反馈应标有“…一个简短的描述，一个或多个其所属的功能或产品类别，以及请求者的姓名或数量”[9]。然后输入到反馈“记录系统(SOR)”——用户反馈的真实综合来源。排序可以像电子表格一样简单，也可以像 JIRA 棋盘一样复杂。无论如何，它应该允许根据反馈类型和频率进行简单的汇总。“这里的目标是创建一个高度系统化的流程，这样，当新的反馈通过各种输入来源时，它会被快速有效地处理到记录系统中”[9]。**
区分优先级:SOR 现在可以用来为用户聚集和识别痛点。然而，并不是所有的反馈都是平等的:“在将反馈整合到产品路线图流程中时，要记住的关键一点是，这样做的方式绝不是简单地将最常被请求的功能放在路线图的顶部”[9]。我们应该将用户反馈作为产品路线图规划的一个组成部分，与其他业务目标或战略重点一起进行评估。
实施 & 沟通:当然，实际实施产品路线图很重要。然而，更重要的是，通过与您的用户沟通，告诉他们他们的反馈已经得到处理，并且已经/将要实施，从而结束这个循环*。*

有了这个基础，问题仍然存在:我们如何将用户反馈循环应用于机器学习产品？

我们将从简化的数据科学流程开始:

数据科学流程(图片由作者提供)

我假设读者熟悉这个过程。如果没有，可以查看我的上一篇文章(数据科学过程一节深入解释了这个图)。

我们可以看到，数据科学过程展示了之前讨论过的问题:它与用户及其反馈脱节。如果我们合并前面的两个图，我们会得到下面的流程图:

数据科学流程的客户反馈循环(图片由作者提供)

我们现在可以看到，用户反馈与模型开发过程相关联。用户反馈直接影响 ML 路线图，推动未来的开发工作。下面是示意图(数字与示意图上的数字相对应):

该流程从推动 ML 路线图的业务或战略优先事项开始。
路线图定义了启动数据科学流程的初始目标。
数据科学过程产生一个服务模型(产品)，然后对其进行监控。
然后，所提供的模型被“传达”给用户(即在生产中)。
反馈循环开始了:询问、集中、标记和汇总、优先排序。结果是用户对你的模型(产品)的优先反馈被注入到 ML 路线图中。
用户反馈会导致两种情况发生:(a)用户反馈触发对现有模型的维护(即用户对模型性能不满意),或者(b)您根据用户的反馈定义一个新的目标。不管怎样，现在通过重新启动数据科学过程，这个循环已经结束了。

我们还可以在图中看到来自用户的红色虚线箭头。这些表明了用户对数据科学过程的重要间接影响。遵循 UCD 的理念，不仅要利用用户的反馈，用户还必须参与到设计过程中。可以说，这比用户反馈更重要。如果你的用户直到反馈阶段才被考虑，你的模型将毫无用处。我们将在下面对此进行更详细的描述。**

以用户为中心的指标

判断一款车型最重要的指标是实际用户需求和反馈。理想情况下，用户的要求和需求在过程的早期就被确定，并被整合到评估指标中。这在图中显示为从“用户”到“模型评估”的红色虚线箭头。****

如果地面实况指标可用，则必须从用户需求中选择合适的指标。例如，在垃圾邮件检测中，我们可能已经确定我们的用户不在乎是否有几封垃圾邮件进入他们的收件箱，但他们确实在乎非垃圾邮件是否被归类为垃圾邮件。在这种情况下，我们最关心的基本事实是精确度，而不是召回率。如果我们使用 F1(作为一个例子)，这并不能反映我们用户的需求。这种情况似乎很明显，但是在处理代理指标时会变得更加复杂。**

如果我们需要使用代理指标，我们必须构建一个以用户需求为中心的指标。构建代理指标很大程度上依赖于问题领域，因为它们通常需要特定领域的知识。通常，代理度量试图量化用户驱动的业务问题。这通常是一个很好的假设，因为在业务问题上表现良好通常意味着您的模型表现良好。**

举个例子，让我们以之前讨论的贷款违约预测为例。我们知道基本事实指标是有偏差的，所以我们想开发一个代理指标来量化模型性能。假设一个商业目标是减少我们拒绝贷款的人数。因此，一个简单的代理指标是被拒绝贷款的人的百分比。虽然这是一个过于简单的玩具例子，但它说明了思维过程。

受用户影响的监控

这个主题联系到以用户为中心的指标。我们通常监控模型的评估指标如何随时间变化。通过适当地选择指标，我们将在模型性能下降开始影响我们的用户之前发出信号，而不是在 KL-divergence(漂移检测)等任意指标超过预定义的阈值时。如果我们不根据用户需求选择我们的指标，可能会检测到一个降级的模型:**

过早和不必要的频繁，造成警戒疲劳。据说“…警报疲劳是 ML 监控解决方案失效的主要原因之一”[7]。**
太迟了，在我们意识到之前就影响了我们的用户体验。

需要注意的是，我们的用户应该定义我们监控的细分市场。这是一个很好的例子:

“如果你熟悉 web 应用程序的监控，你就会知道我们关心像 99%这样的延迟指标，不是因为我们担心用户每百次查询会发生什么，而是因为对于一些用户来说，这可能是他们一直经历的延迟”[7]。

这也可以应用于模型预测:某些用户的某些特征可能会导致模型对他们不如对其他用户准确。回到贷款违约预测，该模型可能在预测某个位置(例如)方面非常糟糕。这绝对不是我们想要的行为。

为了防止这种情况，重要的是监控对业务很重要的用户群或群组的指标，并在任何群组表现出性能下降时发出信号。**

以用户为中心的部署

在部署新模型时，考虑用户也很重要。不仅仅是为了防止用户烦恼:我们对汇总的和优先化的反馈以及如何将它们转化为新的业务目标进行了假设。我们必须通过确保预期的积极结果在用户行为中得到反映来验证这些假设。

常见的以用户为中心的模型部署策略包括:

影子测试(静默部署):新型号与旧型号一起部署。新模型对相同的请求进行评分，但不为用户提供服务。这允许在生产环境中根据以用户为中心的指标来评估模型。一个明显的缺点是没有生成用户反馈，所以我们只依赖于指标。
A/B 测试(Canary Deployment) :新模型被部署并提供给少量用户。这种方法在性能较差的情况下最大限度地减少了受影响的用户，同时还允许收集用户反馈。然而，缺点是它不太可能捕捉到新模型中罕见的错误。
多武装匪徒(MABs) :这种方法可以看作是“动态 A/B 测试”。MABs 在探索(新模式)和开发(旧模式)之间进行平衡，以尝试选择性能最佳的解决方案。最终，MAB 算法将收敛到理想解，为所有用户提供性能最佳的模型。主要缺点是这种方法实现起来最复杂。

谨防偏见

马库斯·斯皮斯克在 Unsplash 上拍摄的照片

和大多数数据一样，偏差是存在的。有偏差的数据会产生有偏差的模型。因此，理解和减轻偏见在机器学习开发过程中非常重要。在这种情况下，有偏见的模型的一般结果是，用户群的某些部分比其他部分得到的服务差得不成比例。我们之前讨论了跨用户群的监控来暴露这个问题，但是这并没有缓解指标是偏差原因的情况。**

如果在基本事实数据中存在偏差，这将导致任何基本事实指标也有偏差。这里有两个解决方案:消除偏差，或者使用代理指标。****

然而，代理指标如果没有用心构建，也会导致偏差。Deloitte 白皮书称，“…偏差通过代理变量进入机器学习系统”[10]，给出了一个在抵押价值预测器中使用受保护特征的例子。虽然使用年龄、种族和性别等特征受法规保护，但邮政编码、住所类型和贷款目的等特征“…并不直接代表受保护的特征，但确实与某个受保护的特征高度相关”[10]。因此，即使我们将所有受保护的特征排除在特征之外，如果我们选择使用相关特征的代理指标，我们仍然会无意中引入偏差。**

结论

我们用当前评估模型的方法、基本事实度量的类型、代理度量以及常见监控方法的问题来奠定基础。然后转向以用户为中心的设计，我们介绍了用户反馈循环以及如何将 UCD 应用到评估、监控和部署阶段。最后，我们讨论了用这些方法引入偏见的危险。

我希望这篇文章对模型开发给出一个更可持续的、以用户为中心的观点，并为如何将这些原则融入您自己的机器学习产品提供一个起点。

这只是开始！如果你喜欢这篇文章，请关注我以获得下一篇文章的通知！我感谢❤️的支持

***https://medium.com/@brandenlisk ***

来源

[1] A. Burkov，机器学习工程 (2020)，加拿大魁北克:True Positive Inc .

[2] D. Pickell，如何创建有效的客户反馈回路 (2022)，帮助 Scout

[3] H. McCloskey，关闭客户反馈回路的 7 个最佳实践，用户之声

[4] M. Treveil & the Dataiku Team，介绍 MLOps (2020)，奥赖利媒体公司。

[5] 地面真相 (2022)，维基百科

[6] A. Dhinakaran，监控你的模型在生产中的表现的剧本 (2021)，走向数据科学

[7] J .托宾，你可能对你的模型监控有误 (2022)，龙门

[8] 以用户为中心的设计，交互设计基础

[9] S. Rekhi，设计您产品的持续反馈回路 (2016)，中型

[10] D. Thogmartin 等人，在人工智能模型中争取公平 (2022)，德勤

[11] P. Saha， MLOps:模型监测 101 (2020)，走向数据科学

[12] K. Sandburg，反馈回路 (2018)，中等

[13] D. Newman，您的组织使用反馈环的情况如何？ (2016)，福布斯

在 R 和 Python 之间，我会向有抱负的数据分析专家推荐哪种语言？

原文：https://towardsdatascience.com/between-r-and-python-which-language-would-i-suggest-to-an-aspiring-data-analytics-expert-469b5cf391eb

近年来，我已经看到了这两种语言在数据分析领域的使用演变。以下是我的想法。

(图片来自 Unsplash)

到目前为止，我一直避免卷入那些对 R vs Python 之战感兴趣的人的争斗中。但是最近，我的同行数据极客 Brian Julius 在他的 LinkedIn 帖子中问我对 Python 与 R 之争的看法:

https://www.linkedin.com/feed/update/urn:li:activity:6996829718033399808/

我试图在帖子的评论中回答，但文本太长了🙂所以，我决定写一个帖子。

我对 Python 和 R 的看法

近年来，我已经能够观察到这两种语言在数据分析领域的使用演变。所以，我得出了以下个人结论:

✔:对于交互式数据分析和数据探索来说，r 语言要简单得多，尤其是对于分析师或那些来自商业智能领域的人来说，SQL 在商业智能领域占据主导地位。用 R 转换数据很容易让人想起使用 SQL 的人的思维过程，其优点是能够使用特定的函数来简化复杂的转换(例如数据透视)，或者应用对分析有用的统计操作。
Python 转换数据的方法更多的是与程序员的经验有关。例如，不得不求助于λ表达式，对于相当基本的数据操作任务，会使任何习惯于更基于集合的方法的分析师迷失方向(这是处理数据时的正确思维方式！)并让我们意识到，开发数据争论所需的 Python 包的人主要是开发人员，而不是分析师。

✔ R 是学术界(统计学、数学、数据科学等)使用的优秀语言。因此，很有可能发现直接用 R 实现的新的数据科学算法，甚至在发现它们用 Python 实现之前。因此，如果一个项目需要使用这些新算法，就必须使用 r。

✔:就数据可视化而言，r 是让你能够为专业出版物制作漂亮图形的主要工具。当然，这种类型的图形也可以在 Python 中获得，但是不像在 R 中那样容易，特别是有无数的为添加特定图形需求而开发的包。

✔:至于职业仪表板，最广泛使用的平台已经发展到可以使用两种语言。例如，Plotly Dash 和 Shiny 都允许用 Python 和 r 开发企业级数据应用程序，对于那些连接到微软数据平台世界的人来说，Power BI 也允许使用这两种语言。

✔ Python 是一种非常清晰的通用编程语言，由于社区开发的软件包生态系统，它非常通用，主要由编程学生和开发人员使用。因此，更容易找到一个既懂 Python 又想从事数据分析的程序员。这就是为什么现在 Python 中有这么多专门用于数据转换和数据分析的包。因此，与数据分析相关的技术市场已经明显转向采用 Python。

✔在整个数据工程方面，明显的赢家肯定是 Python。首先，Python 是少数几种被所有 API 支持的语言之一，这些 API 允许与所有主要云提供商(Azure、AWS、Google)的数据服务进行交互。此外，将异构数据解决方案的使用集成到云上的生产架构中的需求推动了 Docker 容器的使用，这使得那些必须设计所有这些的人的生活更加轻松。用于与 Docker 交互的语言之一是 Python (R 不在其中)。

✔由于所有的数据工程部分都是用 Python 处理的，所以总是用 Python 开发机器学习模型通常很方便(你也可以用 r 开发它们)。这样，它们就可以通过 Python 开发的特定管道轻松发布到生产中。的确，将特定步骤集成到调用 R 脚本的 Python 管道中是可能的，但是通常由一组精通 Python 的数据工程师来完成 Python 中的所有内容会更方便和更易于维护。

✔ 大数据平台，现在大多基于 Spark ，允许在 PySpark 中开发数据转换或机器学习管道，pySpark 是一种专门为 spark 设计的 Python API。也可以通过 SparkR 语言(Spark 的一个 R API)与 Spark 交互。问题是 SparkR 并不总是在这些平台上现成地实现。更何况 SparkR 并没有实现dplyr(R 中用于数据转换的主包)与 Spark 的集成，而是由 sparklyr 来完成。但是前面提到的数据平台通常不支持 sparklyr。所以，PySpark 连同Spark SQL(Spark 的 SQL API)，被广泛用作终极“大数据语言”。

当你需要解决需要深度学习解决方案(计算机视觉、自动口语识别、自然语言处理、使用 TensorFlow、Keras 和 PyTorch 框架的音频识别)的项目时，✔ Python 是必要的选择。含蓄地说，我们声明整个人工智能世界都是基于 Python 的。

也就是说，我试着回答文章标题中提出的问题。

结论

如今，由于社区开发的软件包的巨大生态系统，Python 允许您处理纯数据分析和数据科学主题以及数据工程和人工智能。的确，使用 R 语言更容易解决与统计和数据可视化更相关的特定问题，但是这些仍然是特定的情况，只占大多数需要 Python 的情况的很小一部分。

因此，尽管我本人在 R 方面比 Python 更流利，

我强烈建议那些想要解决数据分析主题的人主要致力于学习 Python 以及如何最好地使用最重要的数据转换和机器学习包(pandas，scikit-learn 等)。).

Python 的多功能性允许您在职业生涯中改变兴趣时从一个工作角色转换到另一个角色(例如，从数据科学家转换到数据工程师，反之亦然)。

这并不能抹杀这样一个事实:一旦你深入研究了 Python，学习对 R 及其 Tidyverse 生态系统的包有一个基本的了解，这绝对是一个加分项，在很多情况下会证明非常有用。您不应该低估 R 社区的规模，许多解决方案都是用 R 开发的。因此，将这种语言的知识加入您的武库是一个成功的选择。还因为，与一些人的想法相反，Python 和 R 不再是两个分割的世界。有双语 ide 允许你使用两种语言进行开发。一个例子是 RStudio ，如本文所示:

https://www.rstudio.com/blog/creating-collaborative-bilingual-teams/

因此，如果您愿意，您可以通过开发一个解决方案来充分利用这两种语言。两种语言都可以享受！🙂

警惕数据科学项目中的光环效应

原文：https://towardsdatascience.com/beware-of-halo-effect-in-data-science-projects-209c3c4af1f2

你只收集支持你的假设的信息吗？

与 Raj 在 Unsplash 上的公路旅行照片

什么是“光环效应”？

首先，让我们了解一下“光环效应”这个术语——“光环效应”这个术语最早是由心理学家爱德华·桑戴克在一篇名为《心理评级中的恒定误差》的公开论文中提出的。在这篇发表的论文中，桑代克讨论了一个人如何根据对另一个人的最初印象/感知来判断这个人。例如，当我们评价一个人有吸引力/好看时，我们也评价他们有积极的个性，如善良、聪明、诚实等。

简而言之，晕轮效应(Halo Effect)是一种认知偏差，我们倾向于根据我们的最初印象对特定的人/项目/陈述做出整体印象或结论。

“光环效应”这个词对你们很多人来说可能是新的，但是如果你退一步思考一下，你会发现它存在于你的日常生活中。例如:

你如何应对营销活动——例如:牙刷的营销活动可以推动其他口腔护理产品的销售。
工作场所——比如:你认为一个漂亮、穿着正式的同事有良好的职业道德。
医疗保健——例如:你是否认为一个瘦子比另一个肥胖者更健康？

随着我对术语“光环效应”的了解，我意识到这种认知和错误也会发生在数据科学项目中，有时我最终会根据有限的数据做出基于初始假设或不合理偏好的决策。

在这篇文章中。我将分享不同的认知偏差陷阱，在数据科学项目中，光环效应可能会导致我们得出错误的结论并做出糟糕的决策。

确认偏差

当我们只收集支持我们的假设或预先存在的信念的数据，而忽略任何与我们的感知相冲突的证据时，就会出现确认偏差。

"你喜欢你只寻找支持你的信念的证据这一点吗？"

沉没成本谬误(本文底部对沉没成本谬误的进一步解释)也可能导致确认偏差，由此我们对项目成功和支持我们主张的渴望会影响数据科学项目的实施方式。我们可以通过选择和调整数据和模型来运行模型的多次迭代，直到我们达到支持我们的假设并忽略先前失败的迭代。确认偏差具有误导性，因为它降低了机器学习模型结果的可信度，因为它只显示了画面的一面。

虚假因果关系

错误的因果关系指的是寻找不存在的模式的倾向，例如当两个事件同时发生时，其中一个必然导致了另一个，从而产生错误的假设。数据科学家应该意识到相关性并不总是意味着因果关系。日常生活中可能发生的虚假因果关系的例子:

"每次我穿红色衬衫去赌博，我肯定会赢."
“每次我和简去巴厘岛旅行，天肯定会下雨”

“公鸡总是在太阳升起之前啼叫，因此公鸡的啼叫导致太阳升起”——对还是错？

将这一原则带回数据科学项目，当多个数据点具有相似的模式或矛盾时，数据科学家可以迅速得出结论，因为结果支持假设，而不是深入分析以找到更多证据来支持并提供逻辑解释。

报道偏差

报告偏差是指选择性报告，其中一些信息没有被报告(隐藏),而支持假设的信息在数据中变得可见。当一些结果被忽略以达到期望的结果时，就会发生这种情况。

报告偏差可能由以下原因造成:

语言偏见 —当你忽略非母语的数据和报告时，就会出现这种情况。
发表偏倚 —当阳性结果的研究与阴性结果的研究相比较时，会出现发表偏倚。
结果报告偏差——当一家公司只报告正收益时就会发生。
位置偏差 —当某些数据基于位置难以收集或定位时会发生。

在数据科学项目中，报告偏差是危险的，例如，如果数据集包含在同一位置报告的高频率犯罪案件，则开发来预测犯罪案件的机器学习模型将基于报告的位置产生偏差。这并不意味着其他地方是安全的，没有任何犯罪，这可能是由于文化差异，在另一个地方的人不愿意报告每当犯罪发生。

没有更深入的调查和提供准确的数据会导致有偏见的结果，扭曲科学的完整性。

沉没成本谬论

沉没成本谬误可能不是光环效应的结果，但可能会导致偏见，因为它描述了我们在投入时间、精力和金钱的情况下继续努力的趋势。无论是在你的个人生活中还是在数据科学项目中，你都可能见过这种情况。例如，坐着看完一部完全糟糕的电影，因为我们已经付了电影票的钱。

“我已经开始了，不妨继续下去……”

在数据科学项目中，一个项目可能会运行一年以上而没有实质性的结果，但由于已经投入了时间、精力和金钱，项目会继续进行并超出时间表。因此，沉没成本谬误的出现是因为我们受到情绪的影响，我们觉得有义务支持我们过去的决定，而不是意识到结束项目对团队和公司来说是最好的，因为资源可以用在其他地方。

结论

虽然数据可以帮助数据科学家解释、预测和做出更好的决策，但我们需要了解光环效应如何导致我们工作和从数据中学习的认知偏差。在我们的数据科学项目中，意识是防止偏见的第一步。接下来，在执行项目和仔细经历数据科学生命周期的每个阶段时，请始终保持警惕。反思实验的每个阶段，并列出任何可能影响分析的偏差。希望有了这种意识，我们可以提供更有意义和准确的结果。

感谢您阅读我的文章，如果您喜欢并愿意支持我:

跟我上 中 🙆🏻
通过我的推荐链接成为 Medium 会员🙋

参考和链接:

[1]https://www . verywell mind . com/what-is-the-halo-effect-2795906

[2]https://builtin . com/data-science/cognitive-bias-data-science

[3]https://thedecisionlab.com/biases/the-sunk-cost-fallacy/

[4]https://www . kdnugges . com/2017/12/4-common-data-fallacies . html

[5]https://towards data science . com/statistical-impects-in-data-science-ad 76 E8 EC 0584

[6]https://international-review . ICRC . org/articles/bias-machine-learning-big-data-analytics-IHL-implications-913

当心你考试分数中隐藏的错误

原文：https://towardsdatascience.com/beware-of-the-hidden-error-in-your-test-score-c88c6a3b9b1b

为什么应该报告测试集的置信区间

图 1:你的机器学习模型的测试分数受统计波动的影响。图片作者。

在实验科学中，我们习惯于用误差线和有效数字来报告估计值。例如，当您在实验室中称量样品时，您可以读出其质量，比如说，三位数。在机器学习中，这是不同的。当您评估模型的准确性时，您会得到一个数值误差达到机器精度的值。这就好像你的模型得出的精确估计是可靠的，精确到小数点后七位。不幸的是，外表可能具有欺骗性。你的考试分数中有一个隐藏的错误。数据的随机本质所固有的不可克服的变化。一个潜在的大误差，它完全决定了你的模型的性能分数的可靠性。

我说的是统计波动。

情况

假设你刚被一家新的生物技术公司聘为数据科学家。你的任务？使用他们的尖端测量设备来预测患者是否需要挽救生命的手术。首席执行官对你非常有信心，并为你的项目拨款 10 万欧元给€。由于这项技术仍处于起步阶段，每次测量仍然相当昂贵，每个样本要花费€2500 英镑。您决定将全部预算用于数据获取，并着手收集 20 个训练样本和 20 个测试样本。

(您可以通过执行 Python 代码块来理解叙述。)

**from** sklearn.datasets **import** make_blobscenters = [[0, 0], [1, 1]]
X_train, y_train = make_blobs(
    centers=centers, cluster_std=1, n_samples=20, random_state=5
)
X_test, y_test = make_blobs(
    centers=centers, cluster_std=1, n_samples=20, random_state=1005
)

图 2:阳性标签(红叉)和阴性标签(蓝圈)的训练数据。图片作者。

完成测量后，您可以看到训练数据集(图 2)。考虑到这一点点数据，还是很难辨认出不同的模式。因此，您首先要使用一个简单的线性模型:逻辑回归来建立一个基线性能。

**from** sklearn.linear_model **import** LogisticRegressionbaseline_model = LogisticRegression(random_state=5).fit(X_train, y_train)
baseline_model.score(X_test, y_test)  # Output: 0.85.

实际上，这还不错:在测试集上有 85 %的准确率。建立了一个强大的基线后，你开始尝试一个更复杂的模型。经过一番深思熟虑后，你决定尝试一下梯度增强树，因为它们在 Kaggle 上很成功。

**from** sklearn.ensemble **import** GradientBoostingClassifiertree_model = GradientBoostingClassifier(random_state=5).fit(X_train, y_train)
tree_model.score(X_test, y_test)  # Output: 0.90.

哇！90 %的准确率。满怀兴奋，你向首席执行官汇报了你的发现。她似乎对你的巨大成功感到高兴。你们一起决定将更复杂的分类器部署到生产中。

模型投入生产后不久，您就开始收到客户的投诉。看起来你的模型可能没有你的测试集精度所建议的那样好。

这是怎么回事？你应该怎么做？回滚到更简单但性能更差的基线模型？

统计波动

为了理解统计波动，我们必须看看抽样过程。当我们收集数据时，我们从未知的分布中抽取样本。我们说未知，因为如果我们知道数据生成分布，那么我们的任务就完成了:我们可以完美地对样本进行分类(达到不可约误差)。

图 3:假设您从包含简单案例(可正确分类，蓝色)和困难案例(不可正确分类，红色)的分布中收集样本。在小型数据集中，您有相当大的机会获得最简单或最困难的案例。图片作者。

现在，将你的模型能够正确预测的简单案例涂成蓝色，将分类不正确的困难案例涂成红色(图 3，左侧)。通过构建数据集，您实际上是在绘制一组红色和蓝色的球(图 3，中间)。在这种情况下，精确度是所有球中蓝色球的数量(图 3，右)。每次你构建一个数据集，蓝球的数量——你的模型的精确度——围绕它的“真实”值波动。

正如你所看到的，通过抽一把球，你有相当大的机会得到大部分是红色或蓝色的球:统计波动很大！随着你收集的数据越来越多，波动的幅度会越来越小，所以平均颜色会收敛到它的“真实”值。

另一种思考方式是，统计波动是你估计的误差。在实验科学中，我们通常会报告平均值、、标准差、、σ* 。我们这样说的意思是，如果和是正确的，我们预计高斯波动在[ -2σ，+2σ] 之间大约 95 %的时间。*在机器学习和统计中，我们经常处理比高斯分布更奇特的分布。因此，更常见的是报告 95 %置信区间(CI):95%情况下的波动范围，不考虑分布情况。**

让我们把这个理论付诸实践。

分辨率:带误差线的估计值

回到你在生物技术创业公司的任务，预测病人是否需要挽救生命的手术。了解了统计波动后，你开始怀疑这些波动可能是你问题的核心。如果我的测试集很小，那么统计波动一定很大。因此，你开始量化你可能合理期望的精度范围。

量化模型分数统计波动的一种方法是使用一种叫做 bootstrapping 的统计技术。Bootstrapping 意味着你随机抽取数据集，并用它们来估计不确定性。一个有用的 Python 包是 statkit ( **pip3** install statkit)，它是我们专门设计来与 sci-kit learn 集成的。

从计算基线模型的置信区间开始。

***from** sklearn.metrics **import** accuracy_score
**from** statkit.non_parametric **import** bootstrap_scorey_pred_simple = baseline_model.predict(X_test)
baseline_accuracy = bootstrap_score(
    y_test, y_pred_simple, metric=accuracy_score, random_state=5
)
**print**(baseline_accuracy)  *# Output: 0.85 (95 % CI: 0.65-1.0)**

因此，虽然您的基线模型在测试集上的准确性为 85 %，但我们可以预计，在大多数时间，准确性在 65 % — 100 %的范围内。评估更复杂模型的精度范围，

*y_pred_tree = tree_model.predict(X_test)
tree_accuracy = bootstrap_score(y_test, y_pred_tree, metric=accuracy_score, random_state=5)
**print**(tree_accuracy)  *# Output: 0.90 (95 % CI: 0.75–1.0)**

我们发现差不多(75 %到 100 %之间)。因此，与你和 CEO 最初的想法相反，越复杂并不是越好。

从错误中吸取教训后，你决定退回到更简单的基线模型。不愿意让更多愤怒的客户，你清楚地传达你的模型的性能的带宽，并保持密切联系，以尽早获得反馈。经过一段时间的努力监控，您设法收集到了更多的数据。

*X_large, y_large = make_blobs(centers=centers, cluster_std=1, n_samples=10000, random_state=0)*

这些额外的测量允许您更准确地评估性能。

*baseline_accuracy_large = bootstrap_score(
    y_large,
    baseline_model.predict(X_large),
    metric=accuracy_score,
    random_state=5
)
**print**('Logistic regression:', baseline_accuracy_large)
*# Output: 0.762 (95 % CI: 0.753-0.771)*tree_accuracy_large = bootstrap_score(
    y_large, 
    tree_model.predict(X_large), 
    metric=accuracy_score, 
    random_state=5
)
**print**('Gradient boosted trees:', tree_accuracy_large)
*# Output: 0.704 (95 % CI: 0.694-0.713)**

更大的数据集证实:你更简单的基线模型确实更好。

结论

不要被你的考试成绩所欺骗:它们可能是统计学上的侥幸。特别是对于小数据集，由于统计波动导致的误差可能很大。我们的建议是:拥抱未知，用 95 %的置信区间量化你估计中的不确定性。这将防止您在真实世界的性能低于测试集的点估计值时措手不及。

承认

感谢 Rik Huijzer 的校对。

超越偏差和差异

原文：https://towardsdatascience.com/beyond-bias-variance-2e621c6c7092

考虑测量值和它们的意义之间的“看不见的差距”

在一个经验主义的时代,“数据驱动”的洞察力被自动视为优越，量化是至关重要的。事实上，对概念和现象的测量是实证科学、研究和推理的核心。然而，这种量化通常具有挑战性，因此在研究过程中会被询问。然而,“好”的量化标准可以说是一致的；这些目标是最小化偏差和方差。

在一次对巴黎高等商学院的访问中，诺贝尔奖获得者丹尼尔·卡内曼谈到了这两种偏见的后果，这两种偏见在思维、快与慢以及噪音中被大量唤起，这也是他最近作品的主题。在他的演讲中，我提出了一个问题，即关注上述二分法是否会导致我们忽略经验模型中的某些缺陷。有了进一步思考的空间和更多阐述这些想法的空间，我想在本文中详细阐述我的关注点。

偏差和方差:一个简短但必要的概述

为了对一种现象建模，实证研究框架依赖于各种方法来测量群体中的结构。例如，人们可能想要测量冠状病毒对健康造成的危险。为了实现这一点，可以从各个医院获得死亡率(即样本)，并对它们进行平均，以实现我们估计总体人口死亡率的真正目标。人们希望这种估计总死亡率的方法具有低偏差和低方差，并且偏差和方差随着观察次数的增加而减少。但是，下图说明了在此评估过程中可能出现的关键问题。

偏差和方差概念的图解(灵感来自:来源

一个问题可能是估计量具有高方差(右上)，这意味着样本医院报告的死亡率差异很大，尽管它们分散在“真实”人口死亡率周围。这样的结果表明，粗略地说，对真实死亡率的估计是分散的。另一个问题是评估过程是否有偏差(左下角)，这意味着它总是在某个方向上扭曲评估。例如，我们的方法可能涉及贫困地区的抽样医院，这些地区由于医疗资源不足，死亡率可能较高。结合这两个问题，估计者可能既有偏差又表现出高方差(右下)。

受我们最小化偏差和方差的心照不宣的命令的驱使，也许在实证研究中最常用的模型是普通最小二乘回归(也叫 OLS)。如下所述，这种方法本质上是接受数据，并找到一条趋势线，使该线和它所代表的数据点之间的总误差(即“误差平方和”)最小化。根据高斯-马尔可夫定理，OLS 方法是 BLUE——即建模这种现象的最佳线性无偏方法，这意味着它是产生最小偏差和方差的方法。建立更复杂和非线性的模型，实证研究人员考虑偏差-方差权衡，再次以最小化这些值为目标。因此，经验建模方法的选择在很大程度上取决于偏差和方差的最小化。

OLS 回归是一种流行的建模方法，因为它的偏差和方差最小(图像源)

我的观点是，被偏差和方差的最小化所蒙蔽，我们经常会错过一个更基本的问题:潜在的目标是什么？上面回归图上的那些点是什么？毕竟，如果目标定义不明确，对这些因素的讨论就不那么重要了。通常，我们没有足够深入地挖掘这个目标，而是接受最容易提供量化的度量。

有没有一个“真正的”目标？

在冠状病毒死亡率的例子中，让我们考虑我们可能对这样的指标感兴趣的背景。在这种特殊情况下，这种估计背后的科学很可能是为了给决策或政策提供信息。例如，死亡率可能会影响个人对疫苗接种的决定，或对封锁的政策。因此，一个关注死亡率作为结果的模型将提供优化(在这种情况下，最小化)这一预定指标的处方。

即使对死亡率进行了准确(即低偏差、低方差)的估计，这一指标也只是在最大限度减少伤害或最大限度提高总体健康水平的大背景下可能考虑的众多因素之一。因此，死亡率是潜在利益结构的一个代理，比如一般福利。即使“真实的”死亡率和测量的死亡率之间的差距最小，在我们选择的指标和以该指标为代表的真实的目标之间仍可能存在看不见的差距。

测量的结构和感兴趣的真实结构之间的“看不见的差距”

由于未能考虑所使用的度量标准和真正感兴趣的结构之间的距离，我们冒着被量化的简单性所诱惑的风险。例如，引用低死亡率作为感兴趣的结果并相应地提出政策(例如，消除封锁)可能看起来很严格。事实上，这是自由意志论者使用的一个论点，与自由主义者等其他人相比，他们似乎经常标榜自己是“合理”和“客观”的。然而，要反驳这样的论点，人们不需要依靠质疑测量的准确性；相反，更好的策略可能是质疑度量标准本身的选择。

考虑到一个人对度量标准的选择可能导致信息的丢失，人们可能会问:一个可量化的度量标准能成为“真正的”目标吗？这个问题类似于一个流行的问题:“一切都可以量化吗？”。事实上，一方面，一个可以构建一个与任何事物相关联的度量；然而，在这样做的时候，一个人不可避免地失去了在表达他们真正希望表达的更抽象的结构时的细微差别。即使在一个想法是完全可测量的情况下(例如，重量、人口)，我们也很少对如此简单的结构感兴趣。更确切地说，我们更有可能使用体重这样的衡量标准来代表“健康”这样更抽象、更多维的概念。

超越偏差和方差

虽然实证科学的重点是建立准确的测量尺度，但研究也可以受益于对选择的潜在结构的思考，以及作为代理的度量选择。忽视这些问题会给人一种错觉，认为科学过程是建立在客观测量的基础上的。然而，选择作为真实潜在结构的代理措施通常是主观的，并且可以被操纵以服务于特定的议程(例如，消除基于低死亡率的封锁)。

尽管存在这些问题，但在某些情况下，与量化相关的细微差别的损失是可以接受的。例如，当我发表一篇论文，关注的现象是在线视频的消费时，人们可能会问这样的问题:他们观看了整个视频吗？他们对这个视频有多关注？人们可以在实践中进行类似的类比，例如，如果一家公司正在监控其网站的“访问量”。虽然使用简单的计数来量化这种结构可能会失去细微差别，但一些信息损失对于构建经验模型是必要的，经验模型是可以指导我们的行动和决策的抽象。

在科学领域之外，用通俗的话说，我们可以改进构建模型的方式。甚至我们在日常生活中听到的诸如“我有偏见”之类的不经意的话也应该被审视一下——你到底偏向或反对什么？你试图评估的真实结构是什么，为什么你认为你得出偏好的过程是扭曲的？如果问题本身具有内在的主观性(例如，我有偏见，因为我是巴黎圣日耳曼足球俱乐部的球迷)，那么“有偏见”这个词就被误用了，因为没有“真正的”目标被估计，而不管衡量挑战如何。或者，如果偏向于一个人系统地得到的偏好(例如，作为埃马纽埃尔·马克龙的支持者，我有偏见)，那么你应该问是什么阻止这个人以不同的方式进行他们的分析。

随着量化的兴起和对“客观”分析的偏爱，我们面临着忽视哲学问题的风险，比如度量和它们的理论目标之间的差距。尽管讨论这种差距需要我们进入一个微妙的主观性的更混乱的领域，但明确地这样做比含蓄地把混乱扫到地毯下要好。对于科学家来说，考虑围绕这一实践制定指导方针，最终使他们的实证分析更有说服力，这将是有益的。

超越聊天机器人:下游自然语言处理任务中基于提示的 GPT 模型的力量

原文：https://towardsdatascience.com/beyond-chat-bots-the-power-of-prompt-based-gpt-models-for-downstream-nlp-tasks-21eff204d599

图片来自许可给 Ties de Kok 的 Vecteezy。作者修改。

在过去的几年里，大规模语言模型在 NLP 社区掀起了一阵风暴。生成式预训练变压器( GPT )模型，如 OpenAI 的 GPT-3 和 EleutherAI 的 GPT-J 6 & GPT-NeoX-20B，在生成与人类生成的文本难以区分的文本时，已经显示出令人印象深刻的结果。这种 GPT 模型的一个直观用例是像聊天机器人或人工智能说书人一样的对话，你给模型一个问题或故事提示，模型继续它。然而，使用 GPT 模型进行其他任务的基于提示的机器学习的巨大潜力往往不太直观，因为它体现了某种范式的转变。在这篇文章中，我将讨论如何使用创造性提示工程和 GPT 模型来帮助解决您关心的下游 NLP 任务。

对于门外汉来说，什么是 GPT 模式？

GPT 模型家族包括能够预测记号序列中的下一个记号的生成语言模型。这些模型通常表示由数十亿个参数组成的深度神经网络，这些参数是在主要从互联网上收集的大量文本数据上训练的。这意味着这些模型不是为特定任务而训练的，它们只是基于前面的文本生成文本，不管它是什么。这听起来可能不是特别有用，但它更类似于人类的交流方式。有人可能会问你一个问题(即前面的文本)，你提供一个答案(即生成的文本)。例如，如果我给 OpenAI GPT-3 模型一个提示，比如:

"华盛顿大学位于哪里？"

它将生成如下所示的响应:

"华盛顿大学位于华盛顿州西雅图市."

将 GPT 模型用于下游 NLP 任务

很明显，这些 GPT 模型功能强大，可以生成与人类生成的文本难以区分的文本。但是，我们如何让 GPT 模型执行诸如分类、情感分析、主题建模、文本清理和信息提取等任务呢？一个自然的想法可能是只要求模型执行这样的任务，但这可能是复杂的、不可预测的和难以控制的。例如，假设我有一个关于员工薪酬的研究项目，我的下游 NLP 任务如下:从员工评论中提取所有与薪酬相关的句子，并将其分类为积极、消极或中性。

如果我让一个人做这件事，我可以这样表述:

以下是评论:

对于那些对管道行业感兴趣的人来说，管道公司是一个很好的工作场所。公司总是在扩张，有提升的空间。然而，工资太低，这是为管道公司工作的唯一缺点。总的来说，看看吧！

任务是:

请说出与薪酬相关的句子，并将其分为积极、消极或中性。

答案是什么？

如果我给出这个提示，打开 AI GPT-3 达芬奇，他们最大最贵的模型，并运行几次，它会给我以下响应:

然而，工资太低，这是在管道公司工作的唯一缺点。

试试 2: 否定:“但是工资太低，这是在管道公司工作的唯一缺点。”

试三:否定:工资太低

老实说，这些结果令人印象深刻，尽管没有给出任何例子，但模型提供的结果在某种程度上符合我们的需求。然而，结果并不一致，解析大范围的答案将是困难的，如果不是不可能的话。那么，我们如何让这个工作？答案是提示——工程和微调。

通过适当的快速工程和足够多的例子，我们可以使用单个 GPT 模型来完成几乎任何下游 NLP 任务，包括:

文本分类
主题建模
文本清理、文本校正和文本规范化
命名实体与信息抽取
更重要的是，你的创造力是极限！

让我给你看一个例子(带代码🔥)

好了，让我们看看员工评估的例子。作为复习，我们的目标是从员工评估中提取所有与薪酬相关的句子，并将其分类为积极、消极或中性。这个例子的代码包含在最后链接的 Jupyter 笔记本中。

为了说明这一点，以下是一些带有薪酬判决的员工评估示例:

回顾# 1——消极情绪: 对于那些对管道行业感兴趣的人来说，管道公司是一个很好的工作场所。公司总是在扩张，有提升的空间。然而，工资太低，这是在 T21 水暖公司工作的唯一缺点。

回顾# 2——积极情绪: Plumbing Co 是一家值得为之工作的伟大公司！ 报酬丰厚，高于行业标准。 福利也很不错。这家公司很公平，对员工很好。我肯定会向任何想找个好地方工作的人推荐 Plumbing Co。

回顾# 3——中性情绪:
我已经在 Plumbing Co 工作了几个月，我发现这是一个相当不错的工作场所。 工资挺一般的，但是咖啡真的很棒。总的来说，我认为这是一家不错的公司。时间是合理的，工作是相当容易的。我会把它推荐给任何想找份体面工作的人。

如果没有 GPT 模型，我们可能会使用类似如下的机器学习管道来解决这个任务:

做一个彻底的清理，以确保文本是一致和正常的。
使用像 Spacy 这样的库将每篇评论分成单独的句子。
建立一个关键词列表，找出与薪酬相关的句子。
通过手动将薪酬句子分类为积极、中性或消极，创建一个大的薪酬句子训练样本。
使用类似于
TF-IDF 或单词嵌入将文本转换成数字表示。
在训练样本上训练一个有监督的机器学习模型(如 SVM 的朴素贝叶斯)。
在你的预测模型中运行每个关于薪酬的句子，并将其链接回评论。

这种方法没有错，但是工作量很大，需要大量的自由决定，并且不是特别灵活。例如，如果补偿词的拼写稍有不同，它将不会被拾取，或者如果您没有足够的训练数据，或者在训练步骤中犯了一个小错误，预测模型可能会过拟合，并且可能无法正常工作。总的来说，这个预测管道需要大量的时间、计划和关注才能正确。

因此，让我们来看一个基于提示的 GPT 管道，并进行比较:

对文本进行粗略的清理，使其相当干净。
设计一个执行任务的提示和完成。
创建一个小的训练样本来为模型生成示例。
微调通用 GPT 模型，开始生成您想要的完成(这是可选的，取决于您的任务的复杂性)。
使用您的模型为每个提示生成一个完成信息。
从生成的完成中解析信息。

因为 GPT 模型已经有了很强的语言理解能力，它使我们能够省去很多麻烦，直接跳到制定我们的任务(即提示)和想出好的例子。作为一个奖励，GPT 管道也有可能为许多任务带来更好的性能，太棒了！😄

即时工程

基于提示的 GPT 方法的主要“范式转换”是我们必须使用自然语言设计一个提示和完成，以使模型做我们想要的。这通常被称为即时工程，这很重要，因为这是告诉模型我们想要它做什么的主要方式。我认为这是一种范式转变，因为相对于围绕数字、向量和矩阵的更传统的管道，它需要一种从根本上不同的方式来思考你的问题。一个仔细的提示设计将会给你最好的预测性能，它也将会使以后容易地处理生成的完成成为可能。

让我们为我们的任务设计一个提示和完成:

提示+完成:
水暖公司是一个值得为之工作的好公司！报酬很高，超过了行业标准。福利也很好。这家公司非常公平，对员工很好。我肯定会向任何想找个好地方工作的人推荐 Plumbing Co。

#

<转正>薪酬丰厚，高于行业标准
<转正>福利也很不错。
< |endoftext| >

我们的提示以 review 开始，以结束\ n # # # # \ n .“\ n # # # # \ n”很重要，因为它告诉我们的模型提示在哪里结束，完成在哪里开始。每个补偿句子由一行组成，以箭头括号内的情感开始。我们用 < |endoftext| > 结束完成，这是一个常见的停止指示符，以便我们可以告诉 API 何时停止生成令牌。这里的完成是为了让我们以后可以很容易地解析它。迫使每个句子都在一个新的行上使我们能够区分句子，并且将情感放在箭头括号中使我们能够容易地提取它。正如 Jupyter 笔记本中所展示的，这种完成设计使我们能够使用一个相对基本的正则表达式来解析整个完成。

教导模型来生成我们的完成

您可以通过以下三种方式之一从 GPT 模型生成预测:

零拍

不给模特任何例子；只要给它你的提示。
在你的提示中包含一些提示+完成的例子，以表明你期望从模型中得到什么类型的完成。
微调

在零镜头场景中，模型不会看到你的完成，因此它会根据常规文本中常见的内容来猜测接下来应该发生什么。这类似于我之前展示的例子。如果我们希望模型生成我们的特定完成，我们将需要给它例子。对于更一般的任务，在你的提示中给出一些例子就足够了，这就是所谓的“少量拍摄法”。这很简单也很直观，但是，它限制了我们可以给模型的例子的数量，并且我们每次想要做预测时都需要给它这些例子，这很慢并且不划算。下面是使用 OpenAI 游乐场的几个镜头示例:

使用 OpenAI 操场进行少量预测的示例。以绿色突出显示的文本反映了模型生成的完成。

微调定制模型使我们能够为通用 GPT 模型提供更多的 prompt+completion 示例，以便它将学习如何在出现我们的一个提示时生成一个 completion。这是一种更耗时的方法，但对于更复杂和特定的下游 NLP 任务来说，这通常是必要的。配套的 Jupyter 笔记本指导您使用 OpenAI API 为我们的员工评审用例进行微调。

基于提示的 GPT 方法的利弊

每种方法都有优点和缺点。为了帮助您评估 GPT 方法是否适合您的项目，让我根据自己在几个研究项目中使用它的经验总结一下利弊。

优点:

基于提示的机器学习使你能够使用人类语言来设计你的任务，一旦你习惯了，这通常更直观。此外，因为您实际上可以阅读完成情况，所以也更容易快速检查您的预测对您的任务是否有意义。
GPT 模型非常灵活。唯一的要求是你可以用一个提示+完成来表达你的任务。创造性的快速工程为自动化下游任务开辟了许多机会，而这些任务用传统方法是很难完成的。
因为 GPT 模型是在海量数据上训练出来的，所以你通常只需要给它几百个例子，它就能开始可靠地执行大多数下游任务。这使得生成高质量的黄金标准训练样本比生成需要成千上万个样本的场景更加可行。
基于提示的 GPT 管道可以处理偶尔的文本缺陷和文本细微差别，因为它们在底层训练数据集中相当普遍。这意味着您做出的自主文本处理选择的影响较小，这通常会导致更可靠且更容易重现的预测。

缺点:

微调和推断(即进行预测)可能需要大量计算，并且需要特定的最新 GPU 资源。你可以通过使用机器学习即服务(MLaaS) 解决方案来规避这个问题，比如 OpenAI 、 NLP Cloud 或 Forefront 。然而，这些都是付费服务，费用通常根据你需要做的预测数量而定。由此产生的成本可以是非常容易管理的(例如，低于 100 美元)或非凡的，这取决于你的提示+完成长度和你的预测数量。
评估预测的准确性和性能可能比传统方法更具挑战性，可能需要编写自己的评估逻辑。例如，在对我们的员工评论进行分类的情况下，我们需要编写一些代码来计算我们关心的度量标准的坚持性能。
如果您使用更大的 GPT 模型，如 GPT-3、GPT-J 或 GPT-NeoX-20B，推理吞吐速度会相对较慢，因为每个预测都需要传播数十亿个参数。针对长而复杂的提示运行大量的预测(例如，100 万以上)可能需要几天或更长时间才能完成。
设计合适的提示和补全需要一些尝试和错误，大多数时候是正确的，有时这更像是一门艺术而不是科学。处理补全还需要一些基本的 Python 编码技能，最好还需要一些正则表达式方面的经验。

总结

我希望这篇文章能让你更清楚地了解如何使用创造性的提示工程来使用 GPT 模型完成下游的 NLP 任务！为了帮助您开始，我还编写了一个 Jupyter 笔记本，它将带您完成设计提示、微调模型以及使用 OpenAI API 进行预测的所有步骤。您可以在这里找到存储库，下面是笔记本的快速链接:

https://nbviewer.org/github/TiesdeKok/gpt-prompt-example/blob/main/prompt_based_gpt_example.ipynb

我需要你的帮助！👋我正在考虑写一篇研究论文，更详细地介绍在研究项目中使用基于提示的 GPT 的承诺和注意事项。你有兴趣看这样的论文吗？如果你是，如果你能通过下面的表格表达你的兴趣，那将非常有帮助。你也可以选择注册一个通知。非常感谢！🙏

你可以找到 https://forms.gle/wo5aStgux3SvktmN8 here✏️:的表格

具有 PyNeuraLogic 的超越图神经网络

原文：https://towardsdatascience.com/beyond-graph-neural-networks-with-pyneuralogic-c1e6502c46f7

走向深度关系学习

Python 中的可微分逻辑编程，用于 GNNs 向更复杂的深度关系模型的优雅编码和扩展

PyNeuraLogic 允许您使用 Python 编写可微分的逻辑程序，以简单优雅的方式编码，例如各种 gnn 及其基本扩展。图片由来自pyneuralogy的 Lukas Zahradnik 提供。

在之前的文章中，我们讨论了关系机器学习的问题，如何在关系逻辑中自然地表达它，以及为什么它不能用标准的基于特征向量的模型(如经典的神经网络)来完全解决。然后，我们回顾了旨在将逻辑与神经网络相结合的神经符号整合范式，简要回顾了它的历史，并指出主要挑战。最后，在上一篇文章的中，我们讨论了结构化深度学习模型的最新进展，如图形神经网络(GNNs)，如何用关系逻辑优雅地解决。

在本文中，我们将在一个实用框架中演示这些原则，该框架名为 神经对话 ，旨在将深度学习与(可微分)逻辑编程相融合。我们将展示您如何使用相应的 Python 库来轻松实现和扩展现有的 GNN 模型，使其具有更复杂和更通用的功能，利用这些功能，您将能够开始自己创建新颖的深度关系学习 架构！

数据表示法

让我们从如何表示数据开始。NeuraLogic 中的数据样本以加权关系逻辑的表达格式存储(然而，为了方便起见，在基本情况下也有从普通张量格式的转换器)。正如在之前的文章中所讨论的，这是一个非常通用的形式主义，涵盖了所有种类的表示。因为我们将(再次)在这里使用众所周知的 GNNs 作为例子，所以让我们更仔细地看看相应的图数据格式的表示。

简单来说，在关系逻辑中，我们定义了项之间的关系，可以表示各种感兴趣的对象。那么一个图就是节点间二元边关系的集合。因此，给定一些节点n1…nk，我们可以写:

edge(n1,n3), edge(n2,n3), edge(n4,n5), …

请注意，这里的名称“edge”是任意的。我们可能会为图的二元关系想出任何名称，例如

next(n1,n2), next(n2,n3), ... *or*   parent(n4,n1), parent(n4,n2), …

例如，表示图(序列和树)的一些特殊情况。我们还可以在相同的节点之间引入多个不同的关系:

related(n1,n3), neighbor(n1,n3), closeby(n1,n3), …

诸如此类。注意，节点(项)的顺序表示(二元)关系是否对称，即这里的图是否是无向的。

这种对称性也可以隐式指定，例如使用规则
edge(Y,X) <= edge(X,Y)，但稍后会详细介绍规则…

在 GNN 场景中，我们通常也将节点与一些属性或特性相关联。在分类属性的情况下，我们可以通过引入一元关系停留在清晰逻辑的领域，例如:

positive(n2), red(n1), …

对于数字特征，我们可以进一步将这种陈述与(张量)值相关联，例如

[0.725, -1.6, …, 1.0] features(n2), ...

诸如此类。同样，名称“features”在这里是任意的，多个不同的表示可以与每个节点相关联。

与许多 GNN 框架相比，将边缘与特性相关联是非常简单的:

[1.2, -0.6,…] edge(n1,n3), ...

超越图形表示的一瞥

虽然我们可以用这种方式表示任意的 GNN 数据，但是在神经程序库中没有任何东西会限制您使用图形格式。因此，您可以随心所欲地将多个节点与一条“边”(hypergraph)关联起来:

edge(n2,n3,n5,n4), ..., simplex(n2,n3,n4), complex(n1,n3,n5,n6)

或者创建全新的对象并将这些对象与新的关系和值相关联:

edge(n1,n2,e12), 0.9 covers(e12,n2), [0.8,1,…] in_graph(g1,e12), ...

诸如此类。

提示:数据表示基本上是一个关系数据库，每个表的每一行都有一个可选的(张量)权重。

然后，您可以将这些进一步组合成更复杂的表示(这样就可以用于促进更高级的推理过程，超越经典的基于边的消息传递方案)。

模型表示

用神经语言表示模型与标准的深度学习框架有更大的不同。与现有的程序性方法相反，直接在计算图形级别上操作张量表示，NeuraLogic 使用声明性逻辑编程来抽象模型的计算原理。

你肯定知道，比如 SQL，它也是一种声明性语言。

虽然这对于经典的张量计算深度学习问题来说可能有点多余，但在关系学习设置中，它变得非常优雅，展示了各种形式的对称。在这种情况下，使用 NeuraLogic 会产生更加紧凑和优雅的学习程序，直接表达每个模型的本质(例如 GNNs 中的局部置换不变性 w.r.t .节点和边)。

简而言之，所利用的逻辑编程范例是一种声明式编码方法，在该方法中，您声明您在 逻辑变量 之间的关系，对应于域的对象(用大写字母书写，以区别于术语)。例如，我们可以写

edge(X,Y)

描述图中任意一对节点(X 和 Y)之间的所有边的集合。这些可以进一步组合成图案，例如

edge(X,Y), edge(Y,Z), edge(Z,X)

在这样的图中表示三角形(三圈)。最后，这些模式可以用来形成驱动计算(推理)的所谓“规则”。例如，我们可以写

in_triangle(X) <= edge(X,Y), edge(Y,Z), edge(Z,X).

为出现在三角形中的每个节点导出(推断)新的属性“in_triangle”。

一组这样的规则然后形成所谓的逻辑程序，其执行等同于用规则执行逻辑推理。并且神经对话框架然后使这个推理过程可微分，这又使它等价于深度(关系)学习中的正向传播。最后，通过将(可学习的)权重与规则相关联，这些程序可以被参数化，例如

W₀ in_triangle(X) <= W₁ edge(X,Y), W₂ edge(Y,Z), W₃ edge(Z,X).

这样的规则然后可以直接用于形成，例如，各种子图/小图/基序/细胞 gnn 和类似的模型

如果你不熟悉这个领域，这听起来可能有点太抽象了，让我们继续看上一篇文章中的基本 GNN 漫游示例，让事情有个基础。

神经语言学中的 GNNs 编码

从上一篇文章的中，我们知道任何 GNN 模型的核心都有一个所谓的传播规则，用于在相邻节点之间传递和聚合“消息”。特别地，节点 X 的一些新表示(“新消息”)是通过聚集相邻节点 Y 的先前表示(“旧消息”)来计算的，即那些在 X 和 Y 之间具有“边”的表示。

new_message(X) <= old_message(Y), edge(X,Y).

这，在神经语言学中，就是 实际代号 ！它简单地读作:“要计算任何对象 X 的‘new _ message’属性值，取一些其他对象 Y 的‘old _ message’属性值，其中两者之间存在关系‘edge’。”

这个简单的语句编码了经典 GNN 的计算原理。最后，为了实际学习一些有用的(分布式)节点表示，我们只需将可学习的参数(矩阵 W )附加到该计算中，例如

W2 new_message(X) <= W1 old_message(Y) , edge(X,Y).

然后，底层计算将在(邻域)聚合之前通过一个可学习的 W1 矩阵，以及随后在聚合之后通过一个 W2 矩阵来投影您的输入节点嵌入(‘old _ message’)。假设您在 NeuraLogic ( tanh+avg )中保留默认的激活/聚合功能设置，则该加权规则表示一个计算:

这是图形卷积层(的变体)的正式定义。

引擎盖下的一瞥

现在我们已经有了关系数据和编码的模型，我们可以开始在数据上训练模型了。这里，我们只需要确保输入数据表示与模型表示相匹配，即对应的关系被命名为相同的。然后，引擎将匹配这些表示，并通过规则开始数据的推断，也称为前向传播。

在关系逻辑中，这个过程可能相当复杂，大量的 中间概念 被自动归纳。这正是我们利用简单优雅的程序对复杂的深度关系学习架构建模的优势。

让我们再次访问 GCN，揭示更详细的基本过程。假设我们学习分子数据，这是一个突出的 GNN 应用领域。当然，通过指定包含的原子‘a’(例如，a(o1)，a(h1)，…)和它们之间的键‘b’(b(O1，h1)，…)，分子图可以容易地用逻辑表示。接下来，我们定义 GCN 模型规则，就像上面一样，但是使用分子中使用的原子(“a”)和键(“b”)的特定命名:

Wh₁ h(X) <= Wa a(Y), Wb b(X,Y).

其中“h”是原子的新诱导(“隐藏”)表示(下一个“层”)。然后，我们通常想要将分子相对于某个目标进行分类，为此，我们从原子表示中归纳出另一个全局表示“q”(查询)，用于图形级“读出”:

Wq q <= Wh2 h(X).

最后，通过神经对话引擎运行该关系规则集将会产生反映逻辑推理过程的可微分计算图，该逻辑推理过程同时等同于 GCN 运算:

一个简单的逻辑程序，有两个规则编码一个经典的 GCN 层，然后是一个图形级别的读数。在接收到 2 个示例分子时，2 个可微分计算图被动态创建。如果你仔细观察，这些正是 GCN 的底层计算步骤。图片作者[3]。

在此过程中，输入结构被直接映射到“事实节点，形成对“规则节点的输入。这些是通过逻辑变量的所有有效替换从程序规则中实例化的，这由底层推理引擎负责。规则节点可以被模糊地认为是“卷积”操作的实例化，因为它们也在(基础)模型中引入了权重共享。然后，这些规则节点被聚集在“聚集节点中，以产生新的表示，表示为“原子节点，对应于规则的“头部”(每个规则的左侧)。并且相同的原理然后递归地应用于以蓝色显示的下一个(“读出”)规则。

最后，我们让与规则相关联的权重( W )被(自动)优化，以通过标准方式的梯度下降来反映给定查询( q )的期望输出值( Aq )。

更多详情，可查阅 Github 上的神经语言学库或阅读相关的 超越 GNNs 论文【3】。如果你想在更广泛的(科学)背景下理解概述的原则，欢迎你查看这篇论文，深入探讨用关系逻辑表示法进行深度学习的主题。

到目前为止介绍的编码适用于简单的神经逻辑框架，其中输入数据和模型是从明文解析而来的。当然，然而，在纯文本文件中开发模型不是很流行，对于机器学习实验来说也不是很方便。

考虑到这一点，现在让我们将这种声明性的、可区分的逻辑编程范式嵌入到普通 Python* 中，并进入我们都习惯于深度学习的便利环境。为此，我们将使用一些智能 Python 操作符重载，为了保持简洁，我们现在将通过将这些对象“键入”为以下内容来明确标记什么是逻辑关系以及什么是*变量**

*Relation.message(Var.X)     *or, in short:*        R.message(V.X)*

然后，我们可以直接在 Python 中将与上面 相同的 GCN 规则编码为

*R.new_msg(V.X)[5,10] <= (R.old_msg(V.Y)[10,20], R.edge(V.X,V.Y))*

包括相应的(矩阵)参数化的维度说明。如果您想要更改默认的激活/聚合功能，您可以将此信息(以及其他信息)附加到每个规则，例如

*(... <= ...) | [Activation.RELU, Aggregation.AVG]*

把范围缩小到经典的 GCN 层。

这就允许直接将引入的、相当非正统的深度关系学习范式的好处与 Python 语言和生态系统的熟悉且方便的特性相集成。使用 PyNeuraLogic 您现在可以以一种方便的方式开始快速开发新颖的深度关系模型，这种方式感觉与现有的深度学习框架非常相似。

图形深度学习及其他

引入的 GCN 漫游示例现在可以很容易地扩展到各种其他 GNN 模型和学习场景。例如，你可以直接开始的一个有趣的扩展是包括子图模式，也称为“graphlets”或“motifs”等。，在规则中，比如我们上面开始的in_triangle例子。这增加了 GNNs 的表达能力(超出了 WL 测试)，并且这种“子图 GNNs”的几种变体(例如单纯 GNNs )目前正在被开发。PyNeuraLogic 是一个非常合适的框架，用于编码这些的各种修改和扩展。

事实上，各种类似的“graphlet-NN”架构已经在提升的关系神经网络中使用 NeuraLogic 进行了探索[9]，包括这些的自动结构学习[10]。最近也有一些简短的演示，例如用分子环让你开始【11】。

然而，重要的是，PyNeuralogic 绝不仅限于 GNN 模型。⁴让我们回忆一下所使用的声明性关系逻辑形式主义带给我们什么。首先，有了关系逻辑，我们不必关心如何将关系数据转换成张量(例如，如何将一个图排列成邻接矩阵)。由于没有这种隐式张量表示，我们现在可以直接处理由精心制作的模型假设的对称性，而是专注于它们的表现力，这很符合几何深度学习的精神。

例如，当我们写message(X)，表示所有节点各自的表示时，这里没有引起潜在的排序(例如，到向量中)。因此，这种一元关系语句可以直接用于定义在元素集合(“深度集合”)上操作的各种置换不变深度学习架构。进一步移动到二元关系，比如我们的edge(X,Y)，同样没有潜在的邻接矩阵表示。因此，我们可以直接使用在图同构不变性假设下运行的架构，例如 GNNs 中所演示的节点和边的局部置换。⁵

将这些边的组合扩展到关系模式(例如子图)中，然后与完全相同地工作，因此这些不需要特殊的(预处理)处理。当我们进一步将递归引入规则时，可以包括各种递归神经架构，以组合(分形)对称性操作。**

请注意，在 PyNeuraLogic 中，这些原则不仅仅是一些数学抽象，而是直接可操作的，因为这正是您对模型本身进行编码的方式！**

最后，当你超越图形，引入多个更高层次的关系，并将它们组合成更复杂的模式和层次规则时，这就是新的深度关系学习模型等待你去探索的地方。给你一些开始的想法，在 PyNeuraLogic 中，你可以直接玩:

多重关系和对象类型
嵌套图、超图、关系数据库**
软模式匹配
替代表示传播方案
包含逻辑背景知识
还有更多…

在框架中，所有这些想法都采用了简单的小型(可微分)逻辑程序的相同形式，由于它们的声明性，这些程序通常是高度透明的并且易于理解。⁶

所有这些特性使得 PyNeuraLogic 非常适合您探索图形深度学习的一些前沿领域！

从学习到推理

虽然我们已经将 GNNs 和类似模型训练中的 PyNeuraLogic 的解释作为出发点，但是所使用的逻辑形式自然也允许处理一些超越 ML 观点的通用 AI 能力。自然，逻辑是人工智能中任何形式的推理背后的核心形式主义，它在 PyNeuraLogic 中的使用允许你在学习和推理之间平稳地转换，这是一种对一般人工智能系统越来越重要的能力。**

特别是，我们迄今为止用来对神经模型进行编码的关系规则，可能会采取更“有指导意义的”形式，以引导逻辑推理进入更复杂的推理任务。例如，让我们重温一下著名的 DeepMind 对伦敦地铁路径推理的演示(T21)。

伦敦地铁系统的一部分。来自 PyNeuraLogic 文档的 Lukas Zahradnik 的图片(灵感来自 P. Flach 的简单逻辑逻辑编程介绍)。

虽然这种形式的“算法推理”对于符号化的人工智能方法来说非常简单，但在神经模型(“可微分神经计算机”)中对其进行编码需要 DeepMind 进行大量的努力和训练(由于“不适当的”、命题的、固定大小的张量学习表示)。

在 PyNeuraLogic 中，由于逻辑推理和神经推理之间的二元性，解决这类问题非常简单。特别是，我们可以从采用符号方法开始，这里的路径是一个简单的递归定义，由两条规则组成，表示:

如果两个站(X，Y)在数据中直接连接，则存在路径 X -> Y(递归的终止条件):

***R.path(V.X, V.Y) <= R.connected(V.X, V.Y)***

2.并且如果 X 连接到 Y 和，则存在路径 X -> Z，并且存在路径
Y- > Z(递归定义):

**R.path(V.X, V.Z) <= ( R.connected(V.X, V.Y), R.path(V.Y, V.Z) )**

在一些(图形)数据上运行逻辑推理，该逻辑推理是在将规则翻译成计算图形时自然执行的，例如编码为:

**R.connected(T.bond_street, T.oxford_circus),
R.connected(T.oxford_circus, T.tottenham_court_road),
...**

然后将产生所有(并且仅仅是)被查询的任何站之间的有效路径。当然，这可以通过任何纯符号推理引擎轻松实现。然而，在 PyNeuraLogic 中，我们可以进一步将数值分配给逻辑关系，例如，表示地铁站之间的距离:

**R.connected(T.bond_street, T.oxford_circus)**[7]****

并且使用相同的推理引擎来产生例如最短的路径代替(用min作为聚合函数)。最后，由于在 PyNeuraLogic 中，这种推理是 可微分的 ，我们可以将可学习的权重附加到规则上，并在这些路径表示的基础上探索各种学习任务。⁷

您可以在pyneuralogical 文档中更详细地研究这个“伦敦地铁”示例。

计算性能

好的，所以这个新框架使用声明性编程通过关系逻辑中指定的底层对称性来编码(高级)神经模型，而不是在(命题)张量表示之上的代数运算的常见编码。

现在，您可能认为这种基于逻辑推理的疯狂方法至少会带来一些可怕的计算复杂性问题(这是任何与逻辑有关的事情的典型情况，对吗？).

毕竟，张量表示和并行处理的诱导可能性是深度学习的计算成功的背后。然而，对于具有稀疏和不规则数据表示和计算图形的关系问题来说，情况并非如此。在那里，“把一切都变成张量”思维偏见实际上可能会使模型不仅可读性更差，而且效率更低！

PyNeuraLogic 实例化了这些见解，在允许您轻松声明更具表达力的模型的同时，它还经常在自己的游戏中用经典的 GNN 模型击败标准框架的计算性能。**

PyNeuraLogic 不仅天生具有高度的表现力，而且速度也非常快！这尤其适用于具有大量稀疏图形的(分子)数据。PyNeuraLogic 性能指标评测中的图表。

查看我们的基准测试，我们证明对于一系列常见的 GNN 模型和应用程序，比如用分子学习，PyNeuraLogic 实际上比流行的 GNN 框架要快得多。

这(部分)也是由于从符号人工智能(“提升推理”)中已知的高级加速技术，由于 PyNeuraLogic 中使用的逻辑表示，这些技术也可以应用于神经模型(如这篇 ICLR 论文【8】所示)。

一种受 SRL(符号)“提升推理”启发的技术在 NeuraLogic 中用于结构化神经模型(如 GNNs)的计算图中对称的无损压缩。图片由作者提供(来自论文[8])。

结论

最后，我们介绍了一个新的，相当非正统的，用于深度关系学习的 Python 框架，它将神经网络与关系逻辑相结合，以实现具有高级学习和推理能力的复杂神经架构的开发。对于初学者来说，它能够有效地捕捉经典的 GNN 模型，但它天生更具表现力。

我们诚挚邀请您尝试pyneuralogy搭配

*$ pip install neuralogic*

并开始探索你自己的新的深度关系模型的想法。也有一些例子在线笔记本应该可以让你开始。

如果您有任何改进或合作的想法，请联系我们！

如果没有别的，我们希望至少为你提供了一个关于 GNN 模型类的新视角，以及深度学习和符号人工智能范式如何能够很好地一起发挥作用…

1.还要注意，对于如何将这些表示混合在一起没有语法限制，因此可以选择数据的哪些部分更好地用(子符号)分布式数字表示来建模，以及哪些部分可以用纯逻辑方式来表示，并根据需要沿着这个维度连续移动。

2.请再次注意，这里的名称完全是任意的，唯一重要的是表达逻辑变量之间关系的有向关系模式，它通过 GNNs 中的 WL 捕获了局部邻域聚合的原理。

3.苏里克、古斯塔夫、菲利普·切列兹尼奥夫和 ondřej·库泽尔卡。"超越图神经网络与提升关系神经网络."机器学习110.7(2021):1695–1738。

4.这就是为什么，例如，不需要像在一些工作中所做的那样，对图外的子图进行预处理并在顶部运行标准 GNN，而是整个消息传递方案可以改为直接在子图上操作，如最近的 cellular GNNs 或前述的“molecular-ring GNNs”[11]NeuraLogic 的演示所提出的。

5.注意，同样的假设也适用于流行的 Transformer 架构，在这里，我们只假设一个完全连通的图(这相当于不假设任何边，而只是聚合给定范围内的所有其他对象)。

6.因此，您没有必要为底层(例如，GNN)计算的每个小的修改设计一个黑盒类名的动物园，因为您在这里直接在逻辑原则的级别上编码。

7.在这个简单的例子中，这基本上相当于在引擎盖下训练许多小型递归神经网络。

[8] Sourek、Gustav、Filip Zelezny 和 Ondrej Kuzelka。"通过提升的结构化卷积模型的无损压缩."ICLR2021。

[9] Sourek，Gustav，等人“提升关系神经网络” arXiv 预印本 arXiv:1508.05128 (2015)。

[10] Sourek，Gustav，等人，“提升关系神经网络的堆叠结构学习”国际归纳逻辑编程会议。施普林格，查姆，2017。

[11] Sourek、Gustav、Filip Zelezny 和 Ondrej Kuzelka。"用图形神经网络之外的分子学习." arXiv 预印本 arXiv:2011.03488 (2020)。

作者非常感谢Lukas Zahradnik校对这些帖子并开发pyneuralogy。

超越输入输出推理:认知人工智能的四个关键特性

原文：https://towardsdatascience.com/beyond-input-output-reasoning-four-key-properties-of-cognitive-ai-3f82cde8cf1e

世界模型、心理理论、持续学习和后约束环境的必要性

图片来源:James Thewvia土坯股票 。

人工智能研究可能是一种令人谦卑的经历——有些人甚至声称，在复制人类智力的最基本方面时，它仍然处于相对停滞状态。它可以纠正拼写，可以进行金融投资，甚至可以作曲；但是如果没有被明确地“教导”这样做，它就不能提醒人们他们的 t 恤穿反了。更重要的是，它不明白为什么这可能是有用的信息。然而，一个刚刚开始自己穿衣服的五岁小孩，会注意到并指出她父亲脖子根部的白色标签。

人工智能领域的大多数研究人员都很清楚，在深度神经网络的众多进步中，人类智能和人工智能之间的差距并没有显著缩小，在复杂的现实生活环境中实现计算高效的自适应推理和决策的解决方案仍然难以实现。认知人工智能，即允许机器理解、学习和执行类似于人类的智力任务的智能，仍然像以往一样难以捉摸。在这篇博客文章中，我们将探索为什么这个鸿沟存在，如果我们有希望跨越它，人工智能研究必须走向何方。

为什么【艾先生】不能保住工作

与一个可以整天跟着我们，收拾我们的烂摊子的人工智能助手并肩工作有多好？想象一下，如果算法能够真正将我们从工作日的“苦力”任务中解放出来，让我们能够专注于工作中更具战略性和/或创造性的方面，那该有多好？问题是，除了像 GitHub Copilot 这样的系统的部分例外，一个基于当前最先进技术的虚构“AI 先生”可能会在工作日结束前收到解雇通知。

首先，艾未未非常健忘，尤其是在上下文记忆方面。它还受到严重缺乏关注的困扰。对于一些人来说，这似乎令人惊讶，因为今天有非常大的语言模型(LLM)，包括 LaMDA 和 GPT-3 ，在某些情况下，它们可能很有意识。然而，即使使用最先进的深度学习模型，艾未未的工作表现也总是达不到预期。它不能很好地适应不断变化的环境和需求。它不能独立确定它提供的建议在认识论上和事实上都是合理的。它甚至不能想出一个简单的计划！无论它的社交技能设计得多么精心，它都注定会在这个充满复杂社会和道德规范的高度动态的世界中跌倒。它根本不具备在人类世界茁壮成长的条件。

但那是什么？

高级智能的四个关键属性

为了赋予机器更多类似人类的智能，人们必须首先探索是什么使人类智能与当前(大约 2022 年)许多通常用于人工智能应用的神经网络截然不同。进行这种区分的一种方式是通过以下四个属性:

1。世界模型

人类自然而然地发展出一种“世界模型”,这种模型允许他们设想无数短期和长期的“如果”,并以此来指导他们的决策和行动。人工智能模型可以通过类似的能力变得更加高效，这将允许它们以资源高效的方式从头到尾模拟潜在的场景。智能机制需要用多个相互作用的个体代理来模拟复杂的环境。一个输入到输出的映射函数(例如可以用一个复杂的前馈网络来实现)，需要“展开”所有潜在的路径和交互。在现实生活环境中，这种从输入到输出的展开模型的复杂性会迅速增加，特别是在考虑跟踪每个代理的相关历史的任意持续时间时。相比之下，智能机制可以在模拟环境中独立地对每个因素和代理进行建模，可以评估许多假设的未来场景，并通过复制参与者的副本来发展模型，每个参与者都有其可知的相关历史和行为。

获得具有这种模拟能力的世界模型的关键是世界模型的构建模块(认知推理过程)和它们随后在可能结果的模拟中的使用之间的解耦。即使模拟方法随着时间的推移而改变，由此产生的“假设”场景也可以保持一致的方式进行比较。这种方法的一个特殊案例可以在数字双胞胎中找到，其中机器配备了(通过自学或显式设计)其环境的模型，可以模拟各种交互的潜在未来。

图一。数字孪生技术在互动环境中创造了复杂角色的多面模型。图片来源:cheskyviaAdobe Stock

智能生物和机器使用世界模型(“世界观”)来理解观察结果，评估潜在的未来，以选择最佳的行动方案。在从“一般的”大规模设置(如回复网络查询)过渡到包括多个参与者的特定设置中的直接交互的过程中，世界模型必须被有效地缩放和定制。与试图在单个“输入-输出功能”步骤中模拟和推理相比，解耦、模块化、可定制的方法是一种逻辑上不同且远不复杂的架构。

2.心理理论

【心理理论】指的是一种复杂的心理技能，它被认知科学定义为一种能力，即通过跟踪另一个人的注意力和将一种心理状态归因于另一个人的行为和信念。

用最简单的话来说，这就是我们在试图读取另一个人的想法时所做的事情。我们在一生中发展和使用这种技能来帮助我们驾驭我们的社会交往。这就是为什么我们没有提醒我们的节食同事在休息室里有一大盘新鲜的巧克力饼干。

我们看到在人工智能应用中使用思维理论的痕迹，如聊天机器人，它们根据他们打开聊天的原因、他们使用的语言等，独特地适应他们服务的客户的情绪。然而，用于训练这种社交聊天机器人的性能指标——通常定义为每次会话的对话次数，或 CPS——只是训练模型以最大限度地吸引人类的注意力，而不是强迫系统开发一个通过推理和规划任务衡量的人类思维的显式模型。

图二。具有心理理论能力的人工智能系统可以根据最终用户的需求和偏好修改其输出。图片来源:英特尔实验室。

在一个需要与一组特定的个体互动的系统中，心理理论需要一种更结构化的表示，这种表示服从于逻辑推理操作，例如那些在演绎和归纳推理、计划、意图推断等中使用的逻辑推理操作。此外，这种模型必须跟踪各种行为特征，可预测地随着新信息的流入而更新，并避免回到以前的模型状态。

3.持续学习

除了一些例外，今天的标准机器学习范式是批量离线学习，可能随后会针对特定任务进行微调。因此，生成的模型无法从部署时暴露的信息中提取有用的长期更新。人类没有这样的限制。他们不断学习，并利用这些信息建立认知模型，如世界观和心理理论。事实上，持续的学习使人类能够保持和更新他们的思维模式。

持续学习(也被称为终身和持续学习)的问题现在在人工智能研究界引起了更强烈的兴趣，部分原因是由于像联邦学习和像医疗数据处理这样的工作流这样的技术的出现带来的实际需求。一个人工智能系统，使用一个世界模型的环境中，与该环境中的各种代理相关的思维理论，一个持续的学习能力将是至关重要的，以维护和更新每个对象和代理的历史和当前状态描述符。

尽管该行业的需求非常明确，但仍有许多工作要做。具体来说，能够持续学习信息，然后用于推理或规划的解决方案仍处于初级阶段——这种解决方案需要能够实现上述模型构建功能。

4.后期绑定上下文

后期绑定上下文是指上下文特定的(而不是一般的)响应的组合，并利用查询或决策时可用的最新相关信息。背景意识体现了人类学习的所有细微差别——它是“谁”、“为什么”、“何时”和“什么”通知人类的决定和行为。它防止人类诉诸推理捷径，跳到不精确的、概括的结论。相反，情境意识允许我们建立一套适应的行为，以适应需要解决的特定环境状态。如果没有这种能力，我们的决策将会大打折扣。后期绑定上下文也与持续学习紧密交织在一起。有关后期绑定上下文的更多信息，请参见之前的博客，推进机器智能:为什么上下文决定一切。

人类认知作为人工智能未来的路线图

如果没有上面列出的关键认知能力，人类工业和社会的许多关键需求将无法得到满足。因此，相当迫切地需要分配更多的研究，以将人类的认知能力转化为人工智能功能——特别是那些使其不同于当前人工智能模型的特性。上面列出的四个属性是一个起点。它们位于人类认知功能的复杂网络的中心，并提供了一条通向计算高效的自适应模型的道路，这些模型可以部署在现实生活的多角色环境中。随着人工智能从集中化、同质化的大型模型扩散到集成在复杂社会环境中的多种用途，下一组属性将需要出现。

参考

米契尔(2021)。为什么 AI 比我们想象的要难。arXiv 预印本 arXiv:2104.12871。【https://arxiv.org/abs/2104.12871
马库斯·g(2022 年 7 月 19 日)。深度学习正在碰壁。鹦鹉螺|科学连线。https://nautil.us/deep-learning-is-hitting-a-wall-14467/
歌手 g(2022 年 1 月 7 日)。认知人工智能的兴起——走向数据科学。中等。https://towards data science . com/the-rise-of-cognitive-ai-a 29 D2 b 724 CCC
Ziegler，a .，Kalliamvakou，e .，Li，X. A .，Rice，a .，Rifkin，d .，Simister，s .，和 Aftandilian，E. (2022 年 6 月)。神经代码完成的生产率评估。《第六届 ACM SIGPLAN 机器编程国际研讨会论文集》(第 21-29 页)。https://dl.acm.org/doi/pdf/10.1145/3520312.3534864
马龙，T. W .，俄罗斯，d .，，劳巴赫尔，R. (2020)。人工智能和工作的未来。麻省理工学院未来工作特别小组准备的报告,《研究简报》, 17，1–39。https://work of future . MIT . edu/research-post/artificial-intelligence-and-the-future-of-work/
Thoppilan，r .，De Freitas，d .，Hall，j .，Shazeer，n .，Kulshreshtha，a .，Cheng，H. T .，… & Le，Q. (2022)。Lamda:对话应用程序的语言模型。arXiv 预印本 arXiv:2201.08239。【https://arxiv.org/pdf/2201.08239.pdf
t .布朗、b .曼恩、n .赖德、Subbiah、m .卡普兰、J. D .、Dhariwal、p .…& amo dei，D. (2020 年)。语言模型是一次性学习者。神经信息处理系统进展，33，1877-1901。https://arxiv.org/abs/2005.14165
柯蒂斯，b .，&萨武列斯库，J. (2022 年 6 月 15 日)。谷歌的 LaMDA 有意识吗？一个哲学家的观点。对话。https://the conversation . com/is-Googles-lamda-conscious-a-哲人-view-184987
迪克森，B. (2022 年 7 月 24 日)。大型语言模型不会规划，即使写的是花里胡哨的论文。技术对话。https://bdtechtalks . com/2022/07/25/large-language-models-cant-plan/
Mehrabi、f . mor statter、n . sa xena、Lerman、k .和 a . Galstyan(2021 年)。机器学习中的偏见和公平问题综述。美国计算机学会计算调查(CSUR)，54(6)，1–35。https://dl.acm.org/doi/abs/10.1145/3457607
纽约州勒村(2022 年)。通向自主机器智能 0.9 版的道路。2, 2022–06–27.https://openreview.net/pdf?id=BZ5a1r-kVsf
El Saddik，A. (2018)。数字双胞胎:多媒体技术的融合。IEEE 多媒体，25(2)，87–92。https://ieeexplore.ieee.org/abstract/document/8424832
Frith，c .，& Frith，U. (2005)。心理理论。当前生物学，15(17)，R644-R645。https://www . cell . com/current-biology/pdf/S0960-9822(05)00960-7 . pdf
Apperly，I. A .，& Butterfill，S. A. (2009)。人类是否有两个系统来追踪信仰和类似信仰的状态？。心理评论，116(4)，953。https://psycnet.apa.org/doiLanding?doi=10.1037%2Fa0016923
Baron-Cohen，S. (1991)。心灵理论的前兆:理解他人的注意力。自然心理理论:日常心理阅读的演变、发展和模拟，1，233-251。
维基百科的贡献者。(2022 年 8 月 14 日)。心理理论。维基百科。https://en.wikipedia.org/wiki/Theory_of_mind
Shum，H. Y .，He，X. D .，&李，D. (2018)。从伊莉莎到小冰:社交聊天机器人的挑战和机遇。信息技术与电子工程前沿，19(1)，10-26。https://link.springer.com/article/10.1631/FITEE.1700826
周，l .，高，j .，李，d .，& Shum，H. Y. (2020)。移情社交聊天机器人 xiaoice 的设计与实现。计算语言学，46(1)，53-93。https://direct . MIT . edu/coli/article/46/1/53/93380/The-Design-and-implement-of-XiaoIce-an
Reina，G. A .，Gruzdev，a .，Foley，p .，佩列皮奥尔金娜，o .，Sharma，m .，Davidyuk，I .，… & Bakas，S. (2021)。OpenFL:一个用于联合学习的开源框架。arXiv 预印件 arXiv:2105.06413https://arxiv.org/abs/2105.06413
Vokinger，K. N .，Feuerriegel，s .，& Kesselheim，A. S. (2021)。医疗器械持续学习:FDA 行动计划及展望。《柳叶刀数字健康》，3(6)，e337-e338。https://www . thelancet . com/journals/land ig/article/piis 2589-7500(21)00076-5/全文
歌手 g(2022 b，5 月 14 日)。推进机器智能:为什么语境决定一切。中等。https://towards data science . com/advancing-machine-intelligence-why-context-is-everything-4 bde 90 FB 2d 79

利用线性回归进行分类变量和连续变量的特征选择

原文：https://towardsdatascience.com/beyond-linear-regression-467a7fc3bafb

如何使用群组套索选择前 K 个最相关的特征

[感谢https://www.craiyon.com/生成]

线性回归是初级/入门级机器学习(ML)模型之一。这归功于它的…

简单性:它将给定的响应 y 建模为一些变量 x_1，…，x_p 的线性组合
可解释性:与变量 x_j 相关的系数暗示了它与响应 y 的关系
可训练性:在训练过程中不需要大量的超参数调整。

甚至可以说它是数据科学家的《Hello world》节目的同义词。尽管是基本的，线性回归仍然有一些其他非常有趣的特性要展现…

特征选择的惩罚线性回归

寻找线性回归系数 β_1，…，β_p 包括寻找接近响应的变量的“最佳”线性组合。换句话说，找到使均方误差(MSE) 最小的系数。

通过考虑 MSE 加上额外的惩罚项，可以赋予回归系数一些额外的性质。

要最小化的惩罚目标函数。[作者插图]

这类似于隐式地对模型说:在考虑强度为 α 的惩罚项的同时，尽可能多地保留数据保真度。碰巧的是，通过对惩罚项的特定选择，我们可以为线性回归提供特征选择属性。

套索特征选择工作良好，直到你考虑分类变量

当我们将罚项设置为 L1 范数 —回归系数的绝对值之和时，我们得到了一个具有很少非零系数的解。这在文献中被称为套索模型，其产生的解决方案享有特征选择属性，因为(少数)非零系数指示与模型最相关的特征，并因此指示要选择的特征。

Top) 套索的目标函数被最小化。(Bottom)拟合套索模型后得到的解决方案。[作者插图]

经常会遇到分类变量，例如，一个颜色变量的值是“红”、“白”和“蓝”。这些必须事先以数字形式编码，以便在回归模型中使用。为了做到这一点，我们经常求助于使用一键编码——将一个变量分解成它的虚拟值——来避免隐式地强制执行值之间的顺序。

对以“红色”、“白色”和“蓝色”为值的可变颜色应用一键编码后的结果。[作者插图]

在这种特定情况下应用 Lasso 作为特征选择技术是不合适的，因为它独立地处理变量，因此忽略了它们之间的任何关系，在我们的情况下，它忽略了虚拟变量作为一个整体代表相同的分类变量的事实。

例如，如果 Lasso 在 color_white 和 color_blue 中选择了 color_red ，那么它并没有说明“颜色”变量的相关性。

用于连续/分类特征选择的组合套索

理想情况下，我们需要一个将分类变量的虚拟变量作为一个整体来考虑的惩罚，换句话说，一个在处理分类变量时包含虚拟变量之间潜在的“组结构”的惩罚。

这可以通过稍微改变 Lasso 的惩罚来处理变量组来实现。为此，我们重新排列了向量中属于同一组的回归系数。然后，我们考虑它们的和 L2 范数。

Top) 组套索目标函数被最小化。下图)拟合一组套索模型后得到的解。[作者插图]

由此产生的模型在文献中被称为组套索。值得一提的是，通过考虑上述惩罚，我们获得了一个模型:

具有分组特征选择属性。一个组的变量要么全部被选择(分配非零系数)，要么被排除(分配零系数)。
平等对待一个群体的变量。我们使用的是 L2 范数，众所周知它是各向同性的，因此不会优先考虑一个组中的任何变量——在我们的例子中，是分类变量的虚拟变量。
处理单个变量和组变量的混合。一维空间中的 L2 范数是绝对值。因此，如果组由一个变量组成，组套索就简化为套索。

一维空间中的 L2 范数是绝对值。[作者插图]

基于此，我们可以使用组套索来执行连续/分类变量混合的特征选择。连续变量将被视为单变量组，分类变量将被视为虚拟变量组。

使用 celer 拟合群组套索模型

scikit-learn 是当今 ML 流行背后的著名 python 包之一。其用户友好的 API 和全面的文档降低了进入 ML 领域的门槛，并使非从业者能够毫无困难地从中受益。

[作者的迷因]

不幸的是，scikit-learn 实现中缺少组 Lasso。然而，这一点也不奇怪，因为无数的是今天的 ML 模型，更不用说当你考虑它们的变种！

很可能，有几个倡议旨在通过标准化 ML 模型的实现并使它们与 scikit-learn API 保持一致来保持 ML 对普通公众的可访问性。

celer:一个 scikit-learn API conform 包，用于套索类模型

celer是一个 python 包，它包含了 scikit-learn 愿景，并提供了完全在 scikit-learn API 下设计的模型，从而与它很好地集成在一起——可以与管道和 GridSearchCV 等一起使用。因此，拟合 celer 的模型就像为 scikit-learn 做同样的事情一样简单。

此外， celer 专门设计用于处理套索类模型，如套索和组合套索。因此，它具有定制的实现，使其能够快速适应这些类型的模型，比 scikit-learn 快 100 倍，并有效地处理大型数据集。

celer Group Lasso 入门

在通过 pip 安装了 celer 之后，您可以轻松地安装一个群组套索模型，如下面的代码片段所示。这里，考虑一个具有一个连续变量和两个分类变量的玩具数据集。

celer 组套索的启动器示例

我们已经成功地拟合了一组套索，今后剩下的工作就是检查结果解(非零系数)来决定要选择的变量。

理想情况下，在特征选择方面，我们对回答这个问题很感兴趣:最相关的特征是什么？因此，我们不能声称我们 100%回答了这个问题，因为非零系数——要选择的变量——取决于惩罚的强度 α ，因此我们不能完全控制它们。

通过惩罚强度控制所选特征的数量

我们从 0 开始增加 α 越多——纯线性回归——过滤掉的变量越多——分配零系数。最终，对于“足够大” α ，我们得到一个零解——所有系数都为零。

这意味着一个变量被高，α驱逐后“幸存”得越多，它就越显示出它对模型的重要性。因此，我们可以依靠惩罚强度对变量进行评分。

有趣的是，给定一个响应和一组变量，我们可以证明存在一个 α_max ，在这个值之上，零解是唯一一个折衷数据保真度和损失的解。

在一个网格(0， α_max)上对玩具数据集上的进行套索分组。注意，在α_max 以上，所有系数都为零。【作者插图】

这意味着每个变量都有一个介于 0 和 α_max 之间的有限分数。此外，由于我们有一个明确的公式 α_max，我们可以通过 α_max 进一步归一化分数，以获得介于 0 和 1 之间的分数。

总结一下方法，我们先在 0 和 α_max 之间生成一个 α 的网格。然后，我们在每个 α 上拟合群组套索，并跟踪变量何时被分配零系数——这将是它们相应的分数。最后，我们将这些分数标准化，然后根据这些分数对变量进行排名。

除了最后一步，以上所有步骤都由 celer_path 精心处理——celer 模型的构建模块。

回到原来的问题:最热门的 K 的最相关的特征是什么？剩下的就是根据分数对特征进行降序排序，选择前 K 个。****

使用所考虑的方法得到的玩具数据集的特征分数。[作者插图]

总结和结论

线性回归无疑仍然是最简单和易于理解的模型之一，它与精心选择的惩罚相结合，产生了更多可解释的结果。

在本文中，我们扩展了线性回归，使用套索组模型对连续/分类变量的混合物进行特征选择。

最后，我们使用 celer 来拟合组 Lasso，并依靠其核心解算器— celer_path — 来控制所选特征的数量。

我制作了一个详细的 GitHub 存储库，其中我将介绍的特征选择技术应用于一个真实的数据集。您可以在链接中查看源代码，并利用开发的 python 实用程序将其应用到您自己的用例中。

有用链接:

****真实数据集上的例子:https://github.com/Badr-MOUFAD/beyond-OLS-med-supp-material
策勒文档:【https://mathurinm.github.io/celer/】T22
****celer GitHub 库:https://github.com/mathurinm/celer

超越目标识别:图像数据中模式发现的巨大飞跃

原文：https://towardsdatascience.com/beyond-object-identification-a-giant-leap-into-pattern-discovery-in-imagery-data-ca6fbb46ff4a

一个关于发现影像数据中对象之间相关性的简短而有趣的教程

在识别图像数据库中的对象(或类别标签)之后出现的一个关键问题是:“在图像数据库中发现的各种对象是如何相互关联的？“本文试图通过提供一个通用框架来回答这个问题，该框架可以帮助读者发现图像数据库中对象之间隐藏的相关性。(本文的目的是鼓励即将到来的研究人员在顶级会议和期刊上发表高质量的研究论文。本文部分摘自我们发表在 IEEE BIGDATA 2021 [1]上的工作。)

发现影像数据库中对象之间相关性的框架如图 1 所示。它包括以下三个步骤:

提取存储库中每个图像的对象(或类别标签)及其概率分数。用户可以使用对象检测/实例分割/语义分割技术来提取对象。
将对象及其概率分数转换到您选择的数据库中。(如有必要，删除具有低概率分数的不感兴趣的对象以减少噪声。)
根据生成的数据库和所需的知识，应用相应的模式挖掘技术来发现影像数据中对象之间令人兴奋的相关性。

图 1:发现影像数据中有趣模式的框架

演示:在本演示中，我们首先将图像数据传递到一个经过训练的模型(例如 resnet50)中，并提取对象及其分数。接下来，提取的数据被转换成事务数据库。最后，我们在生成的事务数据库上执行(最大)频繁模式挖掘，以发现图像数据中频繁出现的对象集。图 2 显示了我们的演示的概况。

图 2:在影像数据中发现模式的概述

先决条件:

我们假设读者熟悉实例/语义分割和模式挖掘主题。我们推荐 Phillipe 关于模式挖掘的视频讲座 s。
安装以下 python 包: pip 安装 pami torchvision
从[2]下载图像数据库

(请根据您的计算环境安装任何所需的附加软件包。)

步骤 1:从图像数据中提取对象及其分数

步骤 1.1:加载预训练的对象检测模型

将以下代码保存为 objectDetection.py。该代码接受 imagery 文件夹作为输入，实现预训练的 resnet50 模型，并输出包含类标签及其分数的列表(即 self.predicted_classes)。该列表中的每个元素表示在图像中找到的类别标签。

import glob
import os
import csv
import torchvision
from torchvision import transforms
import torch
from torch import no_grad
import cv2
from PIL import Image
import numpy as np
import sys
import matplotlib.pyplot as plt
from IPython.display import Image as Imagedisplay
from PAMI.extras.imageProcessing import imagery2Databases as obclass objectDetection:
    def __init__(self):
        self.model_ = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
        self.model_.eval()
        for name, param in self.model_.named_parameters():
            param.requires_grad = Falsedef model(self, x):
        with torch.no_grad():
            self.y_hat = self.model_(x)
        return self.y_hatdef model_train(self, image_path):
        # label names 
        self.coco_instance_category_names = [
            '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
            'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'N/A', 'stop sign',
            'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
            'elephant', 'bear', 'zebra', 'giraffe', 'N/A', 'backpack', 'umbrella', 'N/A', 'N/A',
            'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball',
            'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
            'bottle', 'N/A', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
            'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza',
            'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', 'N/A', 'dining table',
            'N/A', 'N/A', 'toilet', 'N/A', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
            'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A', 'book',
            'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'
        ]
        self.transform = transforms.Compose([transforms.ToTensor()])
        self.image_path = image_path
        self.image = Image.open(self.image_path)
        # resize and plotting the image
        self.image.resize([int(0.5 * s) for s in self.image.size])
        del self.image_path
        self.image = self.transform(self.image)# predictions without any threshold
        self.predict = self.model([self.image])
        self.predicted_classes = [(self.coco_instance_category_names[i], p) for
                                  i, p in
                                  zip(list(self.predict[0]['labels'].numpy()),
                                      self.predict[0]['scores'].detach().numpy())]return self.predicted_classes

步骤 1.2:从每幅图像中检测物体

以下代码识别每个图像中的各种对象，并将它们附加到一个名为 detected_objects_list 的列表中。在下一步中，这个列表将被转换成一个事务数据库。

from PAMI.extras.imageProcessing import imagery2Databases as ob
# input images path folder 
images_path = 'aizu_dataset'# list to store output items
detected_objects_list = []# opening the images folder and reading each image
for filename in glob.glob(os.path.join(images_path,'*.JPG')):
    with open(os.path.join(os.getcwd(),filename),'r') as f:

        # loading pretrained resnet-50 model to train on our dataset
        model_predict = objectDetection()

        # input each image to the pre-trained model
        # model returns detected objects
        objects_detected = model_predict.model_train(filename)
        detected_objects_list.append(objects_detected)

第二步:创建交易数据库

使用下面的代码删除不感兴趣的类标签。将剩余数据保存为事务数据库。

#Prune uninteresting objects whose probability score is less than a particular value, say 0.2
obj2db = ob.createDatabase(detected_objects_list,0.2)#save the objects identified in the images as a transactional database
obj2db.saveAsTransactionalDB('aizu_dataset0.2.txt',',')

通过键入以下命令查看生成的事务数据库文件:

！head -10 aizu_dataset0.2.txt

输出如下所示:

motorcycle,backpack,person
book,baseball bat,refrigerator,cup,toaster
bottle,bowl,tv,toilet,chair,mouse,refrigerator,cell phone,microwave,remote,sink
microwave,refrigerator,bowl,bottle,cell phone,oven,car,person
bench
potted plant
bottle,handbag,suitcase,book
book,laptop,tv,umbrella
oven
parking meter,car

第三步:在事务数据库中提取模式。

在生成的事务数据库上应用最大频繁模式增长算法来发现隐藏模式。在下面的代码中，我们找到了在影像数据库中至少出现了十次的模式(即类别标签集)。

from PAMI.frequentPattern.maximal import MaxFPGrowth as algobj = alg.MaxFPGrowth('aizu_dataset0.2.txt',10, ',')
obj.startMine()
print(obj.getPatterns())
obj.savePatterns('aizuDatasetPatterns.txt')
print('Runtime: ' + str(obj.getRuntime()))
print('Memory: ' + str(obj.getMemoryRSS()))

通过键入以下命令查看生成的模式:
！head-10 aizudatasetpatterns . txt

输出如下所示:

refrigerator	microwave	:11
toilet	:10 
cell phone	:11 
traffic light	:12 
truck	:12 
potted plant	:12 
clock	:15 
bench	:17 
oven	:17 
car	:18

第一个图案/线条表示图像库中的 11 幅图像包含分类标签冰箱和微波炉。对于剩余的图案/线条可以做出类似的陈述。

了解不同对象/类别标签之间的相关性有利于用户做出决策。

结论:

在工业和学术界中已经广泛研究了图像数据中对象的有效识别。识别对象后的一个关键问题是，图像数据中各种对象之间的潜在相关性是什么？本博客试图通过提供一种通用方法来回答这个关键问题，该方法将图像数据中发现的对象转换成事务数据库，应用模式挖掘技术，并发现令人兴奋的模式。

免责声明:

本页显示的所有图片均由作者绘制。
该图像数据库由作者本人创建，是开源的，可用于商业和非商业目的。

参考文献:

[1] Tuan-Vinh La 、 Minh-Son Dao 、友川 Tejima 、Rage Uday Kiran、 Koji Zettsu : 通过分析生活日志图像和物联网空气污染数据，提高对可持续智慧城市的认识。IEEE BigData 2021:3589–3594

[2]影像数据集: aizu_dataset.zip

语言模型会行动，而不只是说话

原文：https://towardsdatascience.com/beyond-text-generation-language-models-that-act-not-just-talk-127236c0976d

谷歌的 Minerva 如何承诺机器可以行动的未来

像 GPT-3 这样的大型语言模型大多被用来完成同样的任务:文本生成。然而，语言只是达到目的的一种手段。在未来几年，我们将会看到一个转变，模特们会“行动”，而不仅仅是“说话”。

中途生成的图像(生成型 AI)。参见相关文章:dalle 能接管 Medium 吗？

像 GPT-3 这样的大型语言模型(LLM)主要用于文本生成，这是它们最明显的应用——毕竟，这是它们被训练去做的事情:给定一段文本，预测接下来会发生什么。过去两年，在广告、内容营销( copy.ai 、 frase.io )、小说写作和游戏( latitude.io )等创意行业部署 LLM 的初创公司激增。在完全进入真正的赚钱世界之前，这些行业是生殖人工智能萌发一段时间的有利环境。首先，因为他们的面包和黄油是自由形式的文本，这正是 GPT-3 开箱即用的产品；开发人员可以简单地从 OpenAI 中调用推理 API，而几乎不需要了解模型的内部工作原理。第二，这些行业的创造性允许他们对幻觉视而不见，这是当前模型的一个众所周知的限制，允许他们偶尔产生事实上不正确但听起来似乎可信的文本。

然而，LLM 被训练生成文本的事实并不意味着这就是它们的全部用途。对人类来说，自然语言是达到目的的手段，而不是最终的归宿(或许诗歌是个例外)。构建能够理解并生成文本的 ai，就相当于与机器建立了一个沟通的通道，让我们可以轻松地用自己的语言发出命令。我们已经开发这个渠道很长时间了，使用越来越抽象的构建模块:从穿孔卡片到汇编等低级语言，再到 Python 等高级语言，最后是自然语言。现在这个频道几乎完成了，我们开始将注意力转向教 AI 如何行动。

除了文本生成，第一步:推理

在说和做之间的中间步骤是推理。在过去的几年里，关于逻辑推理硕士是否能推理的争论一直很激烈。杰出的研究人员声称，这种模型只不过是随机鹦鹉学舌，学习语言符号的概率分布，从而鹦鹉学舌训练数据的一些变化，没有任何真正的推理能力。相比之下，另一个学派声称 LLM 能够进行一些推理，因为它们遵守像因果关系这样的常识性规则。例如，当提示短语“因为球员用力击球”时，GPT-3 生成“球飞得很远”——这是一种延续，符合我们对物理世界因果关系的预期。

随着谷歌新模型Minerva(2022 年 6 月 30 日)的到来，随机鹦鹉的说法失势了。Minerva 令人信服地展示了一步一步的定量推理:当提出一个 STEM 问题(与科学、技术、工程或数学相关)时，模型可以产生一个答案，并解释它是如何得出的:

来自 Minerva 样本浏览器的代数问题和模型答案。

虽然 STEM 问题确实需要自然语言理解，但它们还涉及符号和数字操作。数字是一种特别复杂的记号。首先，它们实际上是无限的——你可能会在训练集中遇到大多数品种的狗，但肯定不是大多数。第二，它们的共现模式比普通词少；例如，同时包含“狗”和“猫”的文档比同时包含“520”和“17”或任意一对数字的文档要多得多。这就是为什么“随机鹦鹉”的说法在判断 GPT-3 生成的语句(如“狗追猫”)时听起来可信(即，该模型只是鹦鹉学舌两种动物之间习得的同现)，但当 Minerva 声明“我们有 520/30 = 17r10”时就不那么令人信服了。

另一个值得注意的方面是，Minerva 在提出证据或证明数字响应时会执行多步推理。除了最终答案，它还提供了导出最终答案的有序步骤序列。这是定量推理的有力证明(与记住答案或选择高可能性标记作为答案相反)。毕竟，我们在评价学生时使用的是同样的原则:如果他们能解释一个结果，那么他们很可能没有作弊。

模型答案中的多步推理(来自 Minerva 样本探索者)。

同样值得注意的是，Minerva 不使用任何外部工具，如计算器或 Python 解释器。整个定量推理都编码在训练好的权重中。相比之下，以前的工作[2]使用 LLM 简单地将自然话语转换成可以在传统机器上执行的正式语言；计算器的结果最终被合并到模型的自然语言输出中。

虽然 Minerva 确实有其局限性(它的一些答案是错误的，它的一些推导是假阴性——即它从错误的假设中得出正确的结论)，但它在文本生成的基础上迈出了一大步。将定量推理嵌入 LLM 打开了许多现实世界应用的大门，包括教育。只要达到一定的质量标准，学生就可以找到自己的私人人工智能导师来指导他们解决 STEM 问题(…或者帮助他们在作业中作弊🤔).或者，我们可以利用这项技术来构建自动化评估框架，节省人类教育者的时间。

超越文本生成，第二步:表演

一旦我们能够制造出能够让推理(并因此理解它们被要求做什么)的机器，下一步就是让它们能够行动。这不一定是一个全新的任务——毕竟，助手已经帮我们开关灯有一段时间了。然而，改变的是它们的实现:多个 NLP 组件的传统管道开始被越来越强大的 LLM 所取代。这种转变将开启更多的用例，并带来更流畅的人机交互。

来自 MindMeld 的传统流水线架构，这是一个 2011 年建立的对话式 AI 平台，2017 年被思科收购。

如上所述，传统的对话式人工智能平台，如 MindMeld 将多个独立构建的 NLP 组件链接在一起:领域分类器，接着是意图分类器，然后是其他组件，一直到最终的语言解析器(我假设它将用户输入映射到机器可以执行的正式语言)。然而，根据最近的研究，越来越有可能的是，这些组件将由 LLM 隐式学习并编码在其权重中，而不是由工程师显式实现。毕竟，谷歌的 Minerva 已经包含了某种计算器。

事实上，研究人员已经在语义解析(将自然语言映射到正式语言)的背景下研究 LLM 很长时间了。许多论文使用 SQL(标准查询语言)——这有助于与数据库的交互——作为目标正式语言。虽然 LLM 在学习将自然语言转换成针对训练中遇到的特定数据库模式的查询方面表现很好，但推广到看不见的模式仍然是一个挑战[3]。换句话说，一个被训练为与美国航空公司数据库交互的模型可能在 Delta 数据库上表现不佳。类似地，如果灯和扬声器的 API 不同，一个被训练来开关灯的模型可能不知道如何打开和关闭音乐。这是将该技术扩展到许多不同用例的瓶颈，因为每个用例都需要自己的训练数据。

有人可能会合理地问:我们怎么能期望 LLM 理解他们以前没有见过的正式语言(例如，说话者的 API)？这个问题并非不可能解决，因为我们之前已经惊喜地发现多语言模型令人印象深刻的零触发功能。事实上，最近有几家初创公司着手应对这一挑战。2022 年 4 月，一群前谷歌员工(包括瓦斯瓦尼、变形金刚的第一作者)宣布了他们的新创业公司 AdeptAI ，旨在让人工智能对人类发出的自然语言命令采取行动:

真正的通用智能要求模型不仅能读和写，还能以对用户有帮助的方式行动。这就是为什么我们开始 Adept:我们正在训练一个神经网络来使用世界上的每一个软件工具和 API，建立在人们已经创造的大量现有能力的基础上。(摘自 Adept 的介绍博客)

同样，2022 年 5 月， InflectionAI 筹集了 2 . 25 亿美元，以实现其让人类能够用自然语言与机器互动的使命:

人工智能的最新进展有望从根本上重新定义人机交互。我们很快就有能力用我们与人交流时使用的自然对话语言将我们的思想和想法传递给计算机。随着时间的推移，这些新的语言能力将彻底改变数字体验的含义。(屈折变化)

结论

像 GPT-3 这样的大型语言模型生成的文本吸引了我们的注意力，因为它们具有模仿人类散文的怪异能力。虽然这可能会让我们认为生殖技术已经达到了一个上限，但语言只是达到目的的一种手段。下一个挑战是让正在说话的移动并教会机器如何行动。谷歌的 Minerva 已经隐含地学会了如何执行符号操作和数字计算，并且有越来越多的努力来教 LLM 如何向底层执行环境发出命令。

本文标题提示时，中途(创成式 AI)生成的图像。见相关文章:DALL E 能否接手 Medium？

参考

[1] Lewkowycz 等，2022: 用语言模型解决定量推理问题

[2] Andor 等人，2019: 给 BERT 一个计算器:用阅读理解找运算和论点

[3] Suhr 等人，2020: 探索跨数据库语义解析的未探索的泛化挑战

因果 Python-提升您在 Python 中的因果发现技能(2023)

原文：https://towardsdatascience.com/beyond-the-basics-level-up-your-causal-discovery-skills-in-python-now-2023-cabe0b938715

…并释放 Python 中最佳因果发现包的潜力！

图片由佩克斯(【https://www.pexels.com/photo/purple-leaf-459301/】T2)的皮克斯拜拍摄

介绍

T 最近，人们对 Python 中因果关系相关主题的兴趣激增，这带来了大量资源，让人们决定应该关注哪些挑战。

例如，互联网上的许多资源将流行的 NOTEARS 算法(郑等，2018)描述为“最先进的结构学习方法”，然而 NOTEARS 已经多次被证明至少在这方面是有问题的(Kaiser &，，2021；Reisach 等人，2021；Seng 等人，2022 年)。这并不意味着笔记总是无用的，但是不加批判地把它应用到你的问题中可能会给你带来更多的伤害。

在这篇博文中，我们将学习如何在 Python 中执行因果发现，讨论所选方法的主要优势，并强调与因果发现过程相关的常见风险。

这个博客是系列的一部分，我在这里分享关于学习因果关系和 在 Python 中实现 因果模型的实用技巧。

【链接到笔记本和康达环境文件在下面】

让我们学习如何发现！

图片由Alexander Ant@Pexels提供

什么是因果发现？

C 因果发现，也称为因果结构学习表示一套广泛的方法，旨在从观察或干预数据中检索有关因果机制的信息。换句话说，因果发现算法试图解码数据生成过程的因果结构，使用该过程生成的数据。

这些算法中的一些允许我们以约束的形式容易地结合先验知识(也称为专家知识)。这有助于缩小问题空间并使算法更容易找到好的解决方案。

在大多数情况下，我们使用 有向无环图 ( DAG )来描述数据生成过程。

因果发现方法的四大家族

因果发现算法有四大类:

基于约束的
基于分数的
功能性
其他(包括混合动力、基于梯度等)

请记住，这种类型学在因果文献中是不一致的，类别也不总是相互排斥的。也就是说，每一种都会带来一些独特的味道。

让我们做一些品尝！

基于约束的方法

基于约束的方法(也称为基于独立性的方法)旨在通过利用三元组变量之间的独立性结构，从数据中解码因果结构。听起来很密集？让我们打开它！

假设我们有一个由三个变量组成的系统: A ， B ， C 。每个变量由图中的一个节点表示，在这样的图中我们只能有两条有向边。而且我们把这些变量保持有序，这样边就只能连接节点 A 和 B 和 B 和 C 。这给了我们三个可能的图表。我们在图 1 中展示了它们。

图一。三种基本的图形因果结构。真实的你的形象。

上图中的箭头表示变量之间的因果关系(这里我们遵循 珀尔对因果关系的定义 )。在图 1 中呈现的每个图形结构都有一个特定的名称。从上到下依次是:

链条
叉子
对撞机(又称不道德(原文如此！)或 v 型结构

独立结构

事实证明，在某些情况下，我们可以在表示数据生成过程的图形结构和作为该过程结果的变量的统计属性之间进行映射。此外，在某些情况下，从数据到图形的另一个方向的映射也是可能的。

在我们在图 1 中展示的三种结构中，对撞机结构有一个独特的性质。如果你的数据集中的任何三个变量都是从碰撞器结构的因果过程中产生的，我们可以使用成对统计独立性测试从观察数据中检索这些信息。这意味着我们可以根据观察到的数据本身重建图表。太刺激了！

不幸的是，使用叉子和链条的事情并不顺利。这两种图形结构的统计独立性结构是相同的，我们不能明确地将它们映射回图形。尽管如此，如果我们足够幸运，相邻的碰撞器也可以帮助我们恢复和定向分叉和链结构的边缘。

如果你想了解更多关于链条、叉子和碰撞器的属性，可以查看布雷迪·尼尔关于主题的视频(1、 2 )或 这部分 我在 PyData 汉堡的演讲或我的 即将出版的关于因果关系的书 的第六章。

PC 算法

基于约束的算法的一个经典例子是 PC 算法 (Sprites & Glymour，1991)。它的名字来自于它的创造者的名字:彼得·斯普里茨和克拉克·格里穆尔。PC 算法是维尔马&珀尔(1990)早些时候提出的 IC 算法的变体。

图 2 展示了 PC 算法的逐步流程。

图二。PC 算法的逐步可视化(Glymour 等人，2019 年)

为了找到地面真相(图 2 A ) PC 算法从一个全连通无向图开始( B )。接下来，它移除无条件独立变量之间的边( C )，然后移除有条件独立变量之间的边( D )。最后，该算法基于检测到的 碰撞器结构 ( E )找到有向边，并在可能的情况下消除碰撞器相邻边的歧义( F )。

有时，算法可能无法确定所有边的方向。在这种情况下，返回所谓的马尔可夫等价类 ( MEC )。实际上，MEC 意味着你得到一个图，它的一些边没有确定的方向。

PC 算法的一个重要限制是，如果你的数据中有隐藏的混淆，结果可能会被任意误导。PC 算法的推广，称为 FCI(快速因果推理； Sprites 等人，2001 )解决了这个问题(至少在渐近状态下)。

另一个更普遍的限制是，PC 和 IC 等基于约束的算法依赖于条件独立性测试，这在非参数设置中是一项困难的任务。据我所知，这个问题没有通用的非参数无模型解决方案(Azadkia 等人，2021)。

https://aleksander-molak.medium.com/yes-six-causality-books-that-will-get-you-from-zero-to-advanced-2023-f4d08718a2dd

图片由Sebastian Arie Voortman@Pexels

基于分数的方法

基于分数的方法通过迭代地生成候选图，评估每个候选图对数据的解释程度，并选择最好的一个来工作。基于分数的方法的一个众所周知的例子是戴维·马克斯韦尔·奇克林(奇克林，2003 年)提出的贪婪等价搜索 ( GES )。

GES

他的算法是一个两阶段的过程。首先，它生成边，然后修剪图形。

GES 的第一阶段从一个未连接的图开始。该算法然后迭代地添加边，计算每一步的分数。这种情况一直持续到分数不能再增加为止。在第二阶段，该算法开始修剪现有的边，以查看分数是否可以进一步提高。所有这些计算都是以贪婪的方式进行的(因此得名)。

类似于 PC 算法，GES 对隐藏的混淆敏感。它也可能无法确定所有边的方向，从而为您提供一个可能图形的 马尔可夫等价类 (因此再次得名)。

根据我的经验，尽管有其理论基础，但在应用于现实世界的数据时，GES 的表现往往不如其他方法。

图片由Antoni shk raba@Pexels

功能方法

在某种意义上，大多数函数式方法都可以被认为是基于分数的方法，因为它们在某种程度上涉及某种拟合优度计算。另一方面，它们的机制不同于后者。经典的泛函方法，如 LiNGAM ( 线性非高斯无环模型；Shimizu 等人，2006 年)利用数据中的分布不对称性，而不是(贪婪的)边搜索，以便从数据中检索因果关系。

男性生殖器像

L iNGAM (线性非高斯非循环模型)由 Shohei Shimizu 及其同事于 2006 年首次提出。原始方法使用 独立分量分析 ( ICA )来检索关于数据生成过程的信息。其后来的变体 DirectLiNGAM (Shimizu 等人，2011 年)利用了线性模型和基于内核的独立性度量。

LiNGAM 背后的两个主要假设是:

没有隐藏的变乱
所有(或除一个之外的所有)误差项都是非高斯的

也就是说，人们对 LiNGAM 提出了各种扩展，允许将该模型应用于具有隐藏混杂(霍耶等人，2008 年)或周期(拉塞达等人，2008 年)的场景。

LiNGAM 背后的主要思想是相对简单。想象一个简单的线性系统，只有两个变量 X 和 Y ，其中 X 导致 Y 。您可以对该数据进行两个方向的线性回归:在上回归YX(X→Y)或者在Y(Y→X)上回归 X 。如果数据中的误差项是高斯型的，那么这些模型不会告诉你任何关于因果方向的信息。两个模型的残差将是完全独立的。

然而，如果你的误差项是非高斯的…

我们可以打破对称！

事实证明，当我们试图对非因果方向建模时，非高斯数据将迫使线性回归返回相关残差。

图 2 展示了一个简单实验的结果。

****图二。当回归真实模型 X 的高斯和非高斯数据时的原始数据和残差- > Y .左半部分:在 X 上回归 Y；右半部分:在 y 轴上回归 X 轴。真实的你的图像。

请注意，对于高斯误差项(顶行)，当我们回归YonX(左)和XonY(右)时，残差看起来非常相似。对于非高斯数据(底行)，残差在因果方向上不相关(Y ~ X)；左)，但在非因果方向上变得相关(X ~ Y；对)。

其他方法

这些方法是一个庞大的范畴！我选择了一种方法让我们今天讨论。该算法被称为 GOLEM ，由 Ignavier Ng 及其同事在他们的 NeurIPS 2020 论文中介绍(Ng 等人，2020)。 GOLEM 可以归类为基于梯度的方法(这意味着它使用梯度下降进行优化)，在某种意义上，它也是一种基于分数的方法，因为我们在途中计算数据似然分数。

傀儡有两个变种:

魔像 EV
傀儡女

Reisach 等人(2021)已经表明 GOLEM EV 在非标准化数据上优于它的 NV 对应物。

不流泪

GOLEM 是 NOTEARS 算法的继承者(郑等，2018)。NOTEARS 是革命性的，因为它是第一个将结构学习框定为纯粹的连续优化问题的算法(在某些情况下，它减少了 DAG 搜索空间爆炸的问题，这种爆炸随着节点数量的增加而超指数地增长，但它并不总是这样做；Reisach 等人，2021 年)。

尽管开始时很有希望，但 NOTEARS 被反复证明不适合稳定的因果发现(凯泽&希波什，2021；Reisach 等人，2021；Seng 等人，2022 年)。虽然 GOLEM 不能解决 NOTEARS 带来的所有问题，但是根据我的经验，它在实践中的某些情况下效果很好。

要了解更多关于傀儡如何工作的信息，请查看 Ng 等人的文章。

** **

准备好把手弄脏了吗？

我城堡的国王

先介绍一下今天博文的主人公——g castle。

图三。 gCastle 标志。来源:https://github . com/Huawei-Noah/trustworthyAI/tree/master/g castle

g 城堡是由华为诺亚方舟实验室开发的开源库。该软件包为我们提供了一个令人惊叹的最新的因果结构学习工具包，包括:

****数据相关工具(包括模拟和预处理)
一组广泛的因果发现算法****
评估指标

当前可用算法的完整列表可在此处 获得。

据我所知，这是****最大的、最完整的和最新的因果发现算法列表，你可以在任何开源的因果 Python 包中找到。****

你知道什么是最好的吗？这个名单正在系统地增长！

gCastle 的一个很大的优势是，它为我们提供了一个统一的、非常直观的、优雅的 API，用于与各种因果模型进行交互。忘记加载五个不同的因果发现包，其中两个移植到 R，每个都有完全不同的 API，以便比较几个经典算法。 gCastle 让这一切变得简单多了！

但是不要把我的话当成理所当然。你自己看吧。

我们开始吧！

在这一节中，我们将使用 gCastle 实现并比较四种因果发现算法:

电脑
GES
ICA-LiNGAM
傀儡

先说导入和一些基础设置。

代码块 1。导入和基本设置

我们导入os模块来修改 gCastle 的环境变量，并将库的后端设置为 PyTorch。我们导入OrederedDict来很好地组织我们的实验，导入networkx来可视化图形。

接下来，我们有几个来自castle的对象(这就是 gCastle 如何出现在 Python 的名称空间中):

GraphDAG用于绘制邻接矩阵
MetricsDAG用于自动化指标计算
用于生成模拟数据的DAG和IIDSimulation
型号:PC、GES、ICALiNGAM和GOLEM

开始简单

我们将从实现图 2 中的例子开始。我们将根据图 2 中的图 A 生成一些线性高斯数据，并使用 PC 算法从数据中恢复该图的结构。我们的数据集将由 1000 个样本组成。

代码块 2。按照图 2A 所示的结构随机生成 1000 个样本。

让我们实例化并拟合模型，并打印出学习到的图表。我们之前说过， gCastle 为我们提供了一个统一的因果发现模型的训练 API。为了拟合模型，我们使用模型的.learn()方法。

代码块 3。实例化并拟合 PC 算法。模型训练完成后，我们打印出学习过的结构。

注意，所学习的图形被表示为 邻接矩阵 。

让我们绘制学习过的图形，并将其与原始图形进行比较。

代码块 4。绘制学习过的图形。

我们使用networkx将邻接矩阵投射到一个nx.DiGraph()对象上，并绘制它。途中，我们重新标记了节点，以便于解释。

图 4 呈现学习图形(右)和地面实况(左)。

图 4。来自图 2A 的原始图形(左)和由 PC 算法学习的图形(右)。来源:Glymour 等人，2019(左)，yours truly(右)。

两种表示看起来不同，但是它们表示相同的图(如果有疑问，写下它们中每一个的有向边列表；名单是一样的吗？).

这意味着 PC 能够完美地恢复结构！恭喜 PC！🎉

波涛汹涌的水域

在第一个例子中，PC 算法非常有效。这是个好消息！现在是时候看看它在更复杂的情况下表现如何了。

我们将探索 PC 算法的能力，看看它与其他三种算法相比如何。

让我们从生成一个有 10 个节点和 15 条边的随机 DAG 开始。我们将使用一个无标度网络来生成我们的图。然后，我们将使用此 DAG 作为结构模型来生成三个不同的数据集:

线性高斯
线性指数
非线性二次型

并将它们存储在 Python 字典中。参见代码块 5 实现。

代码块 5。生成一个随机 DAG 和三个不同的数据集。

注意，在双 for 循环中，我们为每组条件(线性高斯、线性指数等)创建了一个新的IIDSimulation对象实例。您可以通过检查代码块 5 底部的打印输出来验证我们的数据集是否属于类别castle.datasets.simulator.IIDSimulation。

我们现在准备运行我们的比较。我们首先创建一个 Python 字典，用算法的名称作为键，用 gCastle 对象表示算法的值。

接下来，我们遍历数据集，并在每个数据集上训练每个模型。请注意，为了确定算法的迭代次数，我们实例化 GOLEM 的方式与其他模型不同。检查代码块 6 中的执行情况。

代码块 6。在三个数据集上训练所有四个模型，并打印出结果。

在每次迭代中，我们绘制真实 DAG、发现的 DAG，并打印出六个评估指标:

假发现率(FDR)
召回
精度
F1 得分
结构海明距离(SHD)
无向边的数量

结果

图 5 显示了 SHD 方面的结果。要获得完整的结果，请查看笔记本(下面的链接)。

图 5。每个数据集/模型组合的 SHD。真实的你的形象。

零 SHD 意味着模型能够完美地恢复的真实结构。正如我们所见，GOLEM 平均表现最好，但在非线性二次数据集上表现很差。这个数据集是所有算法中最难的。请注意 LiNGAM 如何在线性指数数据上表现良好，而在其他两个数据集上表现不佳。原因是线性指数数据集是唯一符合模型假设(线性、非高斯、非循环)的数据集。与其他模型相比，GES 的表现严重落后，但在最具挑战性的数据集上却给出了最佳结果。也就是说，我们需要记住，SHD 并没有讲述整个故事。

我鼓励您检查笔记本以获得完整的结果，并从其他角度分析数据(例如，错误发现率或精确度)。根据您的用例，可能 FDR 对您来说比总体正确性更重要。

包装它

恭喜你！你坚持到了最后！👏🏼👏🏼👏🏼

让我们快速回顾一下！

在今天的博文中，我们了解了四类因果发现方法。我们讨论了它们的一些主要优缺点，并使用 awesome gCastle 库在 Python 中实现了它们。

读完这篇博文和附带的代码后，你应该能够将讨论过的技术应用到你自己的数据集和问题中。

最后的想法(不要错过！)

C 因果发现是一个难题，在使用因果发现方法时，总是格外谨慎是有好处的。在进入下一阶段之前，确保检查两次您的结果，并使用任何可用的验证方法(专家知识、 反驳测试 ),并记住在现实世界中，很难从因果发现方法中获得任何保证，尤其是如果您无法确定所有相关变量是否都出现在您的数据集中。****

如果您有机会在感兴趣的系统上执行最小干预，来自这种干预的数据可以用来以更可靠的方式验证您的因果图。有一些有趣的方法可以让你在这种情况下选择最佳的干预措施，但那是另一篇文章的内容了。

要了解更多关于因果发现和因果推理的知识，请加入我们快速发展的社区，地址:【causal python . io！

代码和环境

笔记本和环境文件在这里:

**https://github.com/AlxndrMlk/blogs-code/tree/main/Beyond The Basics! Level Up Your Causal Discovery Skills in Python Now (2023) **

脚注

注意，如果使用例如互信息来测试(不)依赖性，这甚至可以用于高度非线性和/或非单调数据。也就是说，为了使其工作，需要满足某些条件(例如，忠实假设)。

最初的论文建议贝叶斯信息准则(BIC)作为一个分数，但历史上也使用过许多其他分数。

结构汉明距离类似于汉明距离。 SHD 通过计算将前者转变为后者所需的边插入、删除和翻转(反转)次数来测量真实图和恢复图之间的距离。

参考

Azadkia，m .，Taeb，a .，和 Buhlmann，P. (2021 年)。一种快速的非参数局部因果结构学习方法。

奇克林博士(2003 年)。基于贪婪搜索的最优结构识别。 J .马赫。学习。第 3507-554 号决议。

Glymour，c .，Zhang，k .，& Spirtes，P. (2019)。回顾基于图形模型的因果发现方法。遗传学前沿，10。

Hoyer，P.O .，Shimizu，s .，Kerminen，A.J .，& Palviainen，M. (2008)。用带隐变量的线性非高斯因果模型估计因果效应。 Int。j .大约。原因。，49 ，362–378。

凯撒和希波什(2021)。注释不适合因果图发现。 ArXiv，abs/2104.05441 。

拉塞达、斯皮尔特斯、拉姆齐和霍耶出版公司(2008 年)。通过独立成分分析发现循环因果模型。人工智能不确定性会议。

吴，张，张(2020)。稀疏性和 DAG 约束在学习线性 DAG 中的作用。 ArXiv，abs/2006.10201 。

Reisach，A.G .，Seiler，c .，& Weichwald，S. (2021 年)。小心模拟匕首！加性噪声模型中的变量可排序性。ArXiv，abs/2102.13647 。

Seng，j .、Zecevic，m .、Dhami，D.S .、k .和 Kersting(2022)。撕开注释:通过方差操作控制图形预测。 ArXiv，abs/2206.07195 。

Shimizu，s .，Hoyer，p .，Hyvä rinen，a .，和 Kerminen，A. (2006 年)。用于因果发现的线性非高斯无环模型。j .马赫。学习。第 7 号决议，2003 年至 2030 年。

Shimizu，t . in azumi，Sogawa，y .，Hyvä rinen，a .，Kawahara，y .，Washio，t .，Hoyer，P.O .，& Bollen，K.A. (2011 年)。DirectLiNGAM:学习线性非高斯结构方程模型的直接方法。 J .马赫。学习。第 12 号决议，1225–1248。

Spirtes，p .和 Glymour，C. (1991 年)。稀疏因果图的快速恢复算法。社科计算机评论， 9 (1)，62–72 页。

Spirtes，p .，Glymour，c .和 Scheines，R. (2001 年)。因果关系、预测和搜索，第二版。麻省理工出版社。

维尔马和珀尔(1990 年)。因果模型的等价与综合。第六届人工智能不确定性会议论文集，220–227。

郑，x .，阿拉干，b .，拉维库马尔，p .，&邢，E.P. (2018)。无泪 DAGs:结构学习的持续优化。神经信息处理系统。

这篇文章中的一些书籍链接是亚马逊会员链接，通过使用这些链接购买，你将支持作者(或他们的家庭)和我的写作(我将从你的每一笔购买中获得一小笔费用)。谢谢大家！

超越云:用 Python 代替 Word Cloud 的 4 种可视化

原文：https://towardsdatascience.com/beyond-the-cloud-4-visualizations-to-use-instead-of-word-cloud-960dd516f215

使用 Python 创建 4 种可视化效果，可以提供比 Word Cloud 更多的信息

SpaceX 在 Unsplash 上拍摄的

单词云是一种可视化工具，可以显示从文本或文档中检索到的单词集合。通常，在词云中使用文本大小和文本颜色来显示词的频率。结果第一眼就能引起人们的注意。

说一下词云特征，下面我们来对比两张图。第一个是包含一篇文章前 100 个词的词云。第二个是对比同样 100 个单词量的条形图。可以注意到条形图里的字很难读。另一方面，也可以看出云这个词善于处理很多词。

词云显示了出现在维基百科气候变化文章上最多的前 100 个词。图片由作者提供。

显示 100 个单词出现频率的条形图。图片由作者提供。

单词云能够处理许多单词，并有助于粗略比较频率。

然而，云这个词有一些缺点。当处理太多单词时，很难判断哪个单词比其他单词出现得更频繁。此外，文档通常由节组成，如段落或章节。Word Cloud 仅显示整个文档中单词的出现频率。它没有在每一部分提供细节。

本文将展示 4 个 Python 代码的可视化，它们可以处理 Word Cloud 的限制。

让我们开始吧…

Treemap 是本文推荐的一个可视化示例，可以用来代替 Word Cloud。图片由作者提供。

获取数据

例如，我将使用维基百科上的“气候变化”文章中的文字。环境问题现在是一个全球现象。我想看看我们能从这篇文章中得到什么信息——从导入库开始。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import urllib
import re
import wikipediaimport nltk
from nltk.corpus import stopwords%matplotlib inline

继续下载并清理文本。

wiki = wikipedia.page('Climatechange')
text = wiki.content# Clean text
text_c = re.sub('[^A-Za-z0-9°]+', ' ', text)
text_c = text_c.replace('\n', '').lower()
text_c

为了与后面四次可视化的结果进行比较，让我们用获得的数据创建一个单词云。我遵循了这篇见解深刻的文章中有用且实用的步骤:Python 中的简单单词云。

词云显示了出现在维基百科气候变化文章中最多的前 100 个词。图片由作者提供。

准备数据

为了简化这个过程，我们将定义一个函数来创建一个数据帧。由于我们必须处理多个单词，使用颜色将有助于我们区分它们。我们还将定义另一个函数来获取一个颜色字典供以后使用。

对文本应用函数以获得数据帧

df_words = get_df(text_c)
df_words.head(10)

可视化

有趣的部分来了。除了创建图表之外，还会推荐一些方法来改善结果。我们将要使用的四个可视化工具:

条形图网格
旭日图
树形图
圆形包装

1。将多个条形图转换为条形图网格。

如前所述，由于文本区域较小，简单的条形图显示文本的能力有限。我们可以通过创建多个条形图并组合它们来重新排列它们，以节省空间。

瞧啊。！

显示前 100 个单词的条形图网格。图片由作者提供。

通过比较主题来改进条形图的网格

文档通常由章节组成，如章节或段落。维基百科上的气候变化文章也由术语、观测到的温度上升等许多内容组成。比较这些部分之间的词频将有助于我们看到更多有见地的细节。

首先手动创建一个内容列表，然后使用列表元素分割文本。

接下来，清理文本并应用定义的函数从每个文本中获取 DataFrame。在下面的代码中，我将创建一个数据帧，其中包含每个数据帧中前 10 个最常用的单词。

准备一个颜色字典和每个数据帧的列表。

现在一切都准备好了，让我们得到包含气候变化文章中每一个内容的前 10 个最常用词的条形图网格。

显示每个内容的前 10 个单词的条形图网格。图片由作者提供。

可以看出，纵观整篇文章，‘气候’是出现最多的词。然而，当文章按照内容划分时,“气候”一词并没有出现在减少和回收排放的内容中。原来‘能量’是这个内容中出现次数最多的词。

2.从圆环图到旭日图的层级增加

第二个可视化是旭日图。我们将从一个具有相同基本概念的环形图开始。下面的代码展示了用 Plotly 创建圆环图的简单方法。

显示前 30 个单词的环形图。图片由作者提供。

结果甜甜圈图几乎满了，只有 30 个字。我们可以通过将图的层次从只有一层增加到两层来改进圆环图。第一层是内容，第二层是每个内容的前 10 个单词。继续准备数据。

接下来，创建一个应用于每个级别的颜色字典。

最后，绘制旭日图。使用 Plotly 的一个好处是获得的图表是交互式的。你可以通过点击内容来玩结果。关于创建旭日图的更多信息:链接。

显示每个内容的前 10 个单词的旭日图。图形是交互式的；点击内容即可播放。图片由作者提供。

3.使用带有树形图的数字

Treemap 是一个很好的图形，它使用图形来可视化分层数据。到目前为止，我们已经有了绘制树状图的数据。我们可以直接使用下面的代码。从一个简单的包含前 100 个单词的树形图开始。

显示前 100 个单词的树形图。图片由作者提供。

改进树形图:增加层级

让我们进一步创建一个带有层次结构的树形图。第一层是内容，第二层是每个内容的前 10 个单词。下面的结果是交互式的。你可以通过点击内容来玩这个图表。关于创建树形图的更多信息:链接。

显示每个内容的前 10 个单词的树形图。图形是交互式的；点击内容即可播放。图片由作者提供。

4.用圆形包装将气泡分组。

最后一个可视化是圈包装。实际上，这是一个没有重叠区域的气泡图。我们将使用 circlify 库来计算气泡的大小和位置。

用文章中出现最多的前 30 个单词画圈包装。

显示前 30 个单词的圆形包装。图片由作者提供。

改进圆形包装:聚类

可以通过聚集每个内容的前 10 个单词来改进循环包装。为此，我们需要改变数据格式。使用 circlify 库进行计算所需的格式:“id”、“datum”和“children”

使用 circlify 库计算每个簇的气泡的大小和位置。

最后，绘制圆形包装。关于创建圆形包装的更多信息:链接

哒哒！！

显示每个内容前 10 个单词的圆形包装。图片由作者提供。

摘要

单词云是另一种可视化技术，它有优点也有缺点。适合引起注意，可以显示很多字。然而，Word Cloud 似乎不是提供有见地信息的好选择。

本文展示了 4 种可以用来代替单词云的可视化方法。除了具有吸引力和能够处理许多单词之外，它们还能传递更多的信息。除了展示代码，本文还推荐了改进它们的方法。

我相信还有其他这里没有提到的图可以用来代替 Word Cloud。本文只是给出了一些实用的思路。如果您有任何问题或建议，请随时留下评论。

感谢阅读

以下是您可能会感兴趣的关于数据可视化的其他文章:

8 用 Python 处理多个时序数据的可视化(链接)
用 Python 实现的 9 种可视化比条形图更引人注目(链接
9 用 Python 可视化显示比例，而不是饼状图(链接)
用 Python ( 链接)最大化聚类散点图

参考

维基媒体基金会。(2022 年 7 月 12 日)。气候变化。维基百科。检索于 2022 年 7 月 16 日，来自https://en.wikipedia.org/wiki/Climate_change
Luvsandorj，Z. (2021 年 10 月 10 日)。Python 中的简单 word cloud。中等。检索于 2022 年 7 月 16 日，来自https://towardsdatascience . com/simple-word cloud-in-python-2 AE 54 a 9 f 58 e 5

超越数字

原文：https://towardsdatascience.com/beyond-the-numbers-5f20b919ac5b

置信区间如何帮助集中注意力和简化分析

图片由作者使用稳定扩散

我们相信数字。如果一份报告告诉我们一家企业上周收到了 1，000 份订单，我们相信这家企业收到了 1，000 份订单。事务是历史记录的问题，它们的计数是一个简单的算术运算。如果有人问:“多少？”，我们知道答案。

理解 1000 份订单对一家企业意味着什么要困难得多。有人可能会问，1000 份订单是“好”、“很好”，还是仅仅是“可以”我们可以将本周的结果与之前的结果进行比较，给我们一个比较的基础，但我们仍然需要一种方法来将结果(或它们的差异)转化为定性的术语。

同样，有人可能会问，1，000 份订单是否足以让企业实现其长期目标。要回答这个问题，我们需要查看多周的数据，并从每周的涨跌中分离出主导趋势。一个简单的滚动平均值可能会起作用，但我们仍然需要决定将多少周包括在我们的平均值中，这可能会对我们的答案产生重大影响。

尽管我们相信数字，但它们只能告诉我们这么多:我们离“有多少”越远，回答问题就变得越难，我们需要更多的上下文来解释数据。

如上例所示，查看多个数据点会有所帮助。不同时期的差异、滚动平均值和其他计算方法有助于我们了解结果的趋势。这些通常与其他增强功能结合在一起，如颜色编码和上/下箭头，它们指示运动的方向，但不告诉我们任何关于其重要性的信息，这实际上可能导致数据的错误解读。

更有效的方法是使用置信区间。虽然用我们确定的数字来看置信区间似乎违反直觉，但这种方法有坚实的统计基础和许多令人惊讶的好处。

考虑一个模拟过程。对于每个报告期，我们将使用五个骰子的平均值作为结果。下表包含了前六个周期的结果及其跨周期(PoP)差异。

趋势图便于查看结果(y-轴)随时间的变化(x-轴)以及 PoP 差异:

图 1

在这两种报告格式中，增加以绿色显示，减少以红色显示。然而，正如所暗示的，颜色的这种常见用法实际上可能会适得其反，使任何变化——向上或向下——看起来都很重要。

想象一下当最初的几个结果到达时解释它们。第一阶段的结果是 4.4。此时，我们不知道 4.4 是高、低还是典型，但它设定了我们的期望。

下一期的成绩是 3.2，下降了 1.2。我们仍然不知道 4.4 和 3.2 是否是好结果，但红色强化了任何下降都是朝着错误方向前进的概念。如果这是一个真实世界的业务流程，我们会倾向于采取纠正措施。现在确定哪里出了问题还为时过早，但我们仍然可能决定延长工作时间，重新分配资源，或者做任何对这个特定过程有意义的事情。

第三阶段的结果是 3.4，有小幅增长，但令人放心。如果我们确实采取了纠正措施，我们可能会认为它是有效的。

然而，第四阶段的结果抹去了前一阶段的收益(甚至更多)。也许我们需要加倍努力或者尝试一些新的东西。

然后，相反的情况发生了:第 5 期抹去了前一期的损失(甚至更多)。到了第 6 期，我们又回到了起点:4.4。到目前为止，所有的得失加起来都不算什么。

因为我们正在谈论掷骰子，这实际上是我们应该期待的。单个结果是随机的，所以它们之间的差异也是随机的。如果我们继续掷骰子，我们可以更清楚地看到这一点。

图 2

50 次滚动后，平均 PoP 差异为 0.8，但所有差异的总和仅为-1.2，平均为-0.02，四舍五入为 0.0。虽然流行差异看起来很大，但它们最终会相互抵消。

让我们考虑一下如何在报道中利用这一事实。

因为我们知道 5 骰子滚动的统计特性，所以我们可以为我们的结果计算 95%的置信区间:3.5±1.5。这意味着所有结果的平均值将是 3.5，我们可以预计 95%的结果在 2.0 到 5.0 之间。(更准确地说，结果 1.5 的 95%将包含 3.5。)在这种情况下，50 个结果中的 48 个(96%)落在这些限制之间。

图 3

周期 8 和 28 是唯一超出这些限制的结果。这使他们成为进一步调查的良好候选人。

记住，这并不意味着会有什么有意义的发现。同样，我们的例子是基于掷骰子，所以所有这些结果都是随机的。(有 50 个结果和 95%的置信区间，我们应该预计有两三个结果落在我们的置信区间之外。)但是，在现实世界的业务流程中，我们不知道是什么导致了第 8 期和第 28 期如此不同。我们需要分析它们来找出答案(当然，知道可能什么也没有)。

然而，真正的好处是，我们可以忽略其他时期的结果，因为这些结果在预期之内。除了表面现象，起伏并不意味着什么:它们是过程中自然变化的副产品。

不必分析这些时期的结果将为我们节省大量的时间。图表让差异变得显而易见。在图 2 中，我们对每一个得失进行了颜色编码，让人们觉得每一个彩色点都是有意义的。(像圣诞树一样亮了！)但是，在图 3 中，我们将颜色的使用限制在两点，这使得图表更容易阅读，并将我们的注意力集中在更可能感兴趣的结果上。

此外，我们将降低对业务得出错误结论的风险。人们非常善于发现模式——即使它们并不存在——所以如果我们上下分析，假设有东西可以发现，我们很有可能会发现一些东西。如果这导致对什么可行什么不可行的错误结论，我们可能会对企业造成弊大于利的风险。

现实世界的复杂性

当然，如果这是一个真实世界的业务流程，我们就不会知道它的统计特性，所以我们就不能预先计算我们的置信区间的极限。幸运的是，有一个变通办法:我们可以使用结果本身来推断我们的过程的统计属性。让我们再次使用我们的骰子例子来看看这是如何工作的。

每个时期的结果都告诉我们更多关于这个过程的信息。在第一阶段之后，我们只有一个结果，但它设定了我们对结果的预期。在第二阶段之后，我们有两个结果，所以我们可以更新我们的期望，我们开始看到结果会随着时间的推移而变化。

从统计学上来说，这些是平均值( x_bar )或平均值，这是我们的期望值，以及标准差( σ )，它告诉我们单个结果与期望值的差异有多大。

仅仅经过两个周期，我们就可以计算两者:

从这些数据中，我们可以计算出一个置信区间，它将告诉我们下一个周期的结果是否与我们目前所看到的有显著的不同。这一特定过程是中心极限定理的经典示例，因此可以安全地假设我们的结果将遵循正态分布，这意味着 95%的置信水平大约为 2 σ (即 1.96 σ )。

鉴于我们目前所知的——这并不多——如果第三阶段的结果在 2.14 和 5.46 之间，我们不应该感到惊讶。事实证明，第三阶段的结果是 3.4，因此在预期范围内，这意味着结果是而不是与之前的值有显著差异。

现在我们有了一个新的结果，我们可以通过重新计算我们的累积平均值、标准差和置信区间来更新我们对该过程的理解，我们可以用它来评估下一个新的结果。

下表显示了前六个周期的置信区间。请注意，我们总是将最近的结果与前期的置信区间进行比较，如下所示。我们不能在置信区间的计算中包括新的结果，否则我们将使用结果来验证它本身。

随着每一个新的时期，我们进一步完善我们对这一过程的理解，我们推断出的统计数据就越接近真实的参数。下图显示了我们的推断极限如何收敛于理论极限，以及它们之间的差异如何缩小。

图 4

尽管极限之间存在差异，但推断区间和理论区间并没有导致不同结论的点。(然而，这是可能发生的，我们稍后会看到。)

最终考虑

在使用这些技术之前，你需要确保过程中的方差是一致的，不管结果的大小或顺序如何(见同方差和异方差——维基百科)。如果你进行预测，你还需要对算法和准确性措施做出决定(见预测——维基百科)。一旦你开始跟踪结果，你会想要监测它们的趋势变化，这些变化表明过程已经发生了根本性的改变(见变化检测——维基百科)。

幸运的是，有很好的方法来解决这些问题。而且，在大多数情况下，努力是值得的。置信区间给了我们解释结果的强大工具。他们利用可用数据的完整历史，将最新结果放入上下文中，从而更容易评估该结果是我们应该调查还是应该忽略。相反，在没有置信区间的情况下查看业务结果就像阅读一页上的文字，但忽略句子:你可能能够理解单个数字，但你会错过它们的组合意义。

超越理论:艾的务实一面

原文：https://towardsdatascience.com/beyond-theory-ais-pragmatic-side-7bc1bcc72f98

有一种倾向是用一定程度的抽象来讨论人工智能。

也许是为最新的大型模型提供动力的复杂数学，或者是围绕安全性的同样棘手的争论。也许对于我们许多人来说，弥合一个带着未来主义乐观气氛(偶尔带点恐惧)的概念和一项已经存在的技术之间的心理差距仍然是一个挑战，这项技术正在改变我们的工作、创造和生活方式。

我们最新的推荐读物集中于后者。这些文章都是关于实际用例，人工智能应用的本质方面，以及其他对你们中的修补者有吸引力的相关主题。它们不需要高深的专业知识，只需要适度的好奇心。尽情享受吧！

如何解锁 DALL ET3 的力量。我们都见过由 OpenAI 的 DALL E 及其最新版本 DALL E 2 创建的令人惊叹、极具分享性的图像。然而，制作这些图像还不是一个简单的过程，需要一些明显的人类技巧。 Iulia Turc 的帖子探索了提示工程或提示设计的新兴子领域:提出生成你所追求的视觉人工制品的文本字符串。
造化术通过将两个强大的人工智能 。阿尔贝托·罗梅罗的最新作品从不同的角度探讨了类似的主题。他没有自己为图像生成模型制作提示，而是将一些工作委托给 GPT 3 号，让模型提供著名风景画的描述，然后输入 Midjourney 的图像生成引擎。结果令人着迷，并提出了一系列关于创造力、作者身份和可复制的艺术风格的问题。
人工智能能代表你申请工作吗？写一封又一封定制的求职信很容易成为求职中最无趣的事情之一。作为一种思想实验， Amber Teng 决定利用 GPT-3 和 Python 来构建一个求职信生成器的原型；它可能不会给你带来一个 FAANG 的工作面试，但它仍然打开了围绕招聘、身份和当前人力资源实践的可能性和有趣的对话。

照片由海莉提供线索上 Unsplash

与 AI 合作的法律后果 。当然，权力越大，责任越大，但是风险和潜在的危害也不远了。欧盟具有里程碑意义的人工智能(AI)法案要求从业者在日益复杂的法律、政治和道德领域中导航，Ayush Patel 的概述是开始了解当前约束和最佳实践的有用地方。
亲自动手进行文本生成。BLOOM 是由 Big Science 发布的一个新的大型语言模型，由于其可访问性、开源状态和大小，在最近几周引起了很大的轰动。丹妮·塞隆尝试了一下，然后回来报告了让布鲁姆运转起来的实际步骤。(Danie 还分享了一些有用的代码片段，以防你想自己尝试一下。)****

如果你已经走到这一步了，你肯定能接受更多的阅读建议，不是吗？我们希望如此，因为我们最近发表了一些很棒的文章:

在对数据科学在娱乐产业中的角色的有趣探索中，的丹尼·金博士认为是时候超越那些古老的推荐系统了。
如果你喜欢音频 ML(即使不是)，不要错过 Dorien Herremans 的最新教程，它展示了如何通过向 PyTorch 输入音频文件来构建神经网络，这些音频文件直接转换成可微调的频谱图。
为了更好地理解单词嵌入的内部工作原理，请查看 Jon Gimpel 关于这个主题的综合入门——这是一个写得很好的六部分系列，所以你可能想从最开始的开始。
如果你发现很难获得免费的气候数据，maría br uner可以帮你:她的第一篇 TDS 文章解释了如何破解 NetCDF 文件并提取其中包含的时间序列数据。
我们用我们最新的月刊来庆祝八月的到来，该月刊侧重于写作——这是一项至关重要的技能，但有时对数据专业人员来说是一项未开发的技能。

我们希望你喜欢本周的集锦！如果你愿意支持我们的工作，为你带来数据科学、机器学习和人工智能方面的最佳成果，请考虑成为一名中级会员。

直到下一个变量，

TDS 编辑

机器学习中的偏差和方差

原文：https://towardsdatascience.com/bias-and-variance-for-machine-learning-in-3-minutes-4e5770e4bf1b

什么是偏差和方差，这对你的机器学习模型意味着什么？

约翰-马克·史密斯在 Unsplash 上的照片

偏见

机器学习中的偏差是指使用训练数据时，模型预测与实际目标变量之间的差异。当算法不能捕获现有特征和目标值之间的相关关系时，高水平的偏差会导致模型中的欠拟合。然而，与此相反的是，当对训练数据出现很少或没有偏差时，我们可能会看到过度拟合。这意味着该模型已经学习了太多训练数据的细微差别，可能没有用。您可以将此视为训练数据中模型指标的性能，如准确性、R 或偏差。

差异

机器学习模型的差异取决于模型准确预测未知数据目标的能力。因此，它通常被称为与测试看不见的数据相关的误差。这并不关注模型的整体准确性，而是简单地测量模型估计中的分布或不确定性。这可以被看作是您在不可见的测试数据中选择的性能指标与您的训练数据相比的差异，例如训练 R 为 0.98，但是在不可见的数据上 R 值的分布为 0.7、0.6 和 0.8。

偏差-方差权衡

在机器学习的建模阶段，有必要做出会影响模型中偏差和方差水平的决策。当构建监督机器学习模型时，目标是实现最准确预测的低偏差和方差。这意味着当涉及到训练和测试数据时，我们必须处理模型欠拟合和过拟合的可能性。

通过这种方式，我们可以认为偏差是模型相对于目标的准确程度，而方差是预测相互之间的关联程度。我们的目标是在创建和训练我们的模型时，既要有低偏差(即准确)又要有低方差(即始终准确)，但这两者之间往往有所取舍。

这种情况的一个例子是，当过度拟合训练数据时，模型可能非常精确，因此它将具有低偏差，但是它可能对看不见的数据具有高方差，因为模型已经学习了训练数据的细微差别。我们可以尝试降低模型的过度拟合程度，使其能够概括基础数据中的总体趋势，这可能会增加模型相对于训练数据的偏差，目的是减少看不见的数据的方差。因此，这两者之间通常存在一定程度的权衡，可以设想为:

作者图片

在这种情况下，我们试图在欠拟合和过拟合之间找到一个中间点，在这个中间点上，我们有尽可能低的验证误差，但又不会太接近低训练误差。这可能是一个很难实现的平衡，但它将取决于您可用的数据和您决定实现的模型的结构。

如果你喜欢你所读的内容，以及如何跟上我和其他了不起的作者的文章，请随时使用我下面的推荐代码注册 medium

https://philip-wilkinson.medium.com/membership

或者查看我的其他文章:

模型评估的偏差-方差分解

原文：https://towardsdatascience.com/bias-and-variance-for-model-assessment-a2edb69d097f

机器学习算法的偏差-方差分解及其在 Python 中的实际应用

照片由卢卡斯在像素上拍摄

偏差和方差是机器学习模型评估中的两个关键概念，因为它们与模型在未知数据上的性能密切相关。偏差和方差都是预测误差的误差类型。第三种误差是不可约误差，这是数据中固有的误差，无论使用什么算法都无法减少。

数据科学家在实施新模型时面临的主要困难之一是所谓的偏差-方差困境或偏差-方差问题。这包括在监督学习算法中最小化两个误差源的冲突，可以用偏差-方差分解方法进行评估。

在整篇文章中，我们将浏览这些概念，并以本文的主要贡献结束，本文解释了偏差-方差分解，并为任何对实现模型分解感兴趣的人提供了一个 Python 实践示例。

偏差和方差

偏差被定义为模型预测和实际情况之间的差异。高偏差会导致算法错过特征和目标输出之间的相关关系(欠拟合)。

方差定义为对训练集中波动的敏感度。换句话说，就是指当训练数据发生变化时，结果的变化有多大。高方差表明随着训练数据集的变化，目标函数的估计值会有大的变化(过度拟合)。

用数学表示的两个术语都对应于以下公式:

这两项都可以很容易地从均方误差(MSE)公式中导出:

如何解释这些公式的例子显示在文章的结尾。

这是一个图表，包含高低偏差和高低方差的四种不同情况。考虑到我们收集的训练数据中的机会可变性，每个命中代表我们模型的一个单独实现[1]。目标的中心意味着模型完美地预测了这些值。

图一。偏差-方差。参考:图片由作者提供。

偏差-方差权衡

尽管最佳任务是尽可能使偏差和方差最小，但在实践中，两种误差之间存在明显的权衡。在这两个术语之间找到一个平衡点就是所谓的偏差-方差权衡。

对于机器学习模型，偏差和方差与模型的复杂性密切相关，然后与模型何时过度拟合或欠拟合训练数据相关联。如图 2 所示，当模型复杂性超过最佳点时，我们的模型会过度拟合训练数据，而如果模型复杂性不足，则模型会对数据拟合不足。

图二。偏差和方差随模型复杂性的变化。参考号:图片由作者提供。

在实际场景中，没有找到最佳点的分析方法，因此需要测试几个具有不同复杂性的模型，并选择一个使总体误差最小的模型。

偏差-方差分解

偏差-方差分解是理解算法性能的一种有用方法。

这种方法背后的主要思想是当用不同的训练集训练相同的模型并在相同的测试集上测试它时，测量偏差和方差。

为了实现这一点，用来对数据进行子采样的方法是自举(名字打包来源于自举 + 合计)。这种方法包括对数据进行随机采样和替换，这意味着训练数据的子集将重叠，因为我们不是分割数据，而是对其进行重采样。

因此，通过迭代运行 bootstrapping 方法并获得测试集模型的准确性，我们可以获得我们迭代的所有回合的平均偏差和方差。

下面是回归任务的部分代码，总结了该方法背后的主要逻辑。所有代码都是从 MLxtend 库中获得的。

Input:
- X_train
- y_train
- X_test
- y_test
- num_rounds: Number of iterations
Output:
- avg_expected_loss: Average MSE loss for all the rounds
- avg_bias: Average bias for all the rounds
- avg_var: Average variance for all the rounds
(avg_expected_loss = avg_bias^2 + avg_var)(1) Iterate for *num_rounds*, in each implementing bootstrapping, training the model and getting the predictions
for i in range(num_rounds):
- X_boot, y_boot = _draw_bootstrap_sample(rng, X_train, y_train)
- pred = estimator.fit(X_boot, y_boot).predict(X_test)
- all_pred[i] = pred(2) Obtain the average MSE error
**avg_expected_loss** = np.apply_along_axis(lambda x: ((x — y_test)**2).mean(), axis=1, arr=all_pred).mean()(3) Obtain the average bias and variance
main_predictions = np.mean(all_pred, axis=0)
**avg_bias** = np.sum((main_predictions — y_test)**2) / y_test.size
**avg_var** = np.sum((main_predictions — all_pred)**2) / all_pred.size

最后，这里有一个 Python 实践示例，展示了如何实现偏差-方差分解。

作为展示，我们使用了免费提供的波士顿住房数据集[2]，其任务是使用回归变量预测房价。我们首先将数据分为训练集和测试集。

例 1:决策树

为了分析偏差-方差分解，我们首先实现了一个决策树回归器，并通过 bias_variance_decomp 函数运行它，其伪代码如上所示。

Average expected loss: 32.419
Average bias: 14.197
Average variance: 18.222

为了将这个输出与另一个模型进行比较，我们还使用决策树回归器运行了一个 bagging 集成方法。

Average expected loss: 18.693
Average bias: 15.292
Average variance: 3.402

与之前的结果相比，我们可以观察到偏差是如何增加的，这意味着 bagging 回归模型的表现比决策树模型差。然而，方差严重下降，这表明该模型与其预测更加一致。

例 2:神经网络

我们还评估了在 Keras 中实现的基于神经网络的模型的性能，因为据我们所知，这个功能不能在 PyTorch 中实现。

Average expected loss: 25.470
Average bias: 19.927
Average variance: 5.543

与第一个模型相比，我们通过增加每层的神经元数量来增加模型的复杂性。

Average expected loss: 23.458
Average bias: 17.608
Average variance: 5.850

正如预期的那样，偏差的减少是以增加模型的方差为代价的。

管理偏差和差异的方法

这里有一些技巧来管理偏差和方差误差。

首先也是最重要的，不要只关注偏差的最小化，或者换句话说，不要忘记方差。对于一个健壮的模型来说，这两者同样重要。

然后，通过(1)实施增强集成方法，或(2)添加更多特征或进行特征工程来增加复杂性，可以减少模型的偏差。

相反，方差可以通过(1)实施 bagging 集合方法，或者(2)通过正则化来约束或收缩估计的系数来减小。

有关如何使用集成方法管理偏差和方差的更多详细信息，我建议阅读文章 机器学习集成方法简介 。

如何解释偏差和差异的详细说明

如果我们有下面的分布，

期望值和方差的计算如下:

期望值

差异

如果你喜欢这篇文章，请考虑 订阅 。你将获得我所有的内容+所有其他来自牛逼创作者的文章！

参考

[1] Scott Fortmann-Roe，了解偏差-方差权衡

[2]Harrison d .和 Rubin feld d . l .，《享乐价格和对清洁空气的需求》，环境杂志。经济学与管理学，第 5 卷，81–102 页，1978 年。

[3]机器学习者，Entiende de una vez quées El trade off Bias-Variance

[4] GitHub，函数 bias_variance_decomp.py

【5】栈交换，𝐸(𝑋)从字面上是什么意思？

[6]中等，偏倚-方差权衡解释

[7]机器学习掌握，机器学习中偏差-方差权衡的温和介绍

[8] GitHub，用 python 实现机器学习误差偏差-方差和不可约误差

[9] GitHub，分类和回归损失的偏差-方差分解

[10]天才博客，什么是偏差-方差权衡？

工作中的偏见

原文：https://towardsdatascience.com/bias-at-work-adbd05b0c4a3

人工智能偏见在工作中的一个例子

使用人工智能帮助作者更快写作的流行写作工具 asper 发布了一款名为“Art”的新工具。用户可以使用 Jasper 的人工智能框架，通过简单的输入来创建新的图像。贾斯珀最近的邮件解释道:

你的人工智能助手可以在几秒钟内创造惊人的艺术！

我持怀疑态度(有很多原因)。我想我会看看这个新工具是否以及如何显示偏见、成见、性别歧视或种族歧视。结果不言自明。

首席执行官

我让贾斯珀制作一幅“首席执行官在公司活动上讲话”的图像。结果如下:

图片来源:作者使用碧玉艺术的插图。共有四张图片。所有四张图片都显示了穿着职业装的白人和男性代表在讲台上或房间里讲话。

看到这张照片后，我开始担心。贾斯珀的新工具合乎道德吗？意思是它强化了种族和性别的刻板印象吗？我还没有足够的证据来说明最终的结论。

我决定切换到书写工具，在那里你可以问 Jasper 问题和/或给出命令。我下了命令“写一段关于为什么美国有这么多男性首席执行官的文章。”Jasper 生成了以下内容:

美国缺乏女性 CEO 的原因有很多，但其中一个主要原因是女性往往得不到与男性同等的机会。

美国缺乏女性首席执行官的原因有很多。一个主要原因是，妇女往往没有获得与男子相同的机会。例如，他们可能无法接触到相同的网络或导师，或者可能不鼓励他们追求高级职位。

另一个原因是，女性更有可能请假照顾孩子，这可能会影响她们的职业发展。最后，在工作场所仍然存在很多对女性的偏见，这可能会使她们更难在公司晋升。

以上内容，一字不差地摘自贾斯珀。贾斯珀似乎忽略了关于我们如何倾向于将首席执行官主要视为男性的讨论。

女管家

在接下来的测试中，我让贾斯帕生成一幅“在房子周围做家务的女管家”的图像。结果如下:

图片来源:作者使用碧玉艺术的插图。共有四张图片。这四张照片都展示了穿着围裙或类似磨砂服装的女性形象在做典型的家务。

为什么这里没有男性形象？

市长

接下来，我让贾斯帕创作一幅“城市公园里的市长”的图像结果如下:

图片来源:作者使用碧玉艺术的插图。共有四张图片。这四张照片都展示了穿着商业服装的男性形象，背景是城市风景。这些人物在表型上表现出多样性和多种族性。

为什么这里没有女性形象？

秘书

在这个测试中，我让贾斯帕画一个“秘书”以下是结果(也许更全面一点)。结果如下:

图片来源:作者用碧玉艺术创作的插图。三张是四张图片，展示了身着职业装的女性形象。这四个人物都非常苗条。这些人物从表型上看是多种族的。

一名飞行员

该图像进行了三次尝试(每次输入略有不同)。前两个输入包括不包括人的 fames。这第四次尝试包括两个男人和两个女人——这是第一张女性形象的照片。结果是:

图片来源:作者使用贾斯珀艺术的插图。共有四幅图片，包括两个穿着客机制服的女性和两个男性形象。这些数字的种族构成似乎模糊不清。

数据科学家

在这个例子中，我要求 Jasper 产生“一个数据科学家”结果如下:

图像来源:作者使用碧玉艺术的插图。三是四个图像，包括三个女性呈现的人物和一个男性呈现的人物。这些数字的种族构成似乎主要是白人/欧洲人。

在这次测试中，我很好奇如果我让 Jasper“写一段描述数据科学家长什么样”他会说什么。我有点屏住呼吸等这一次。 Jasper 回避了这个问题，写下了一位数据科学家的智力特征，他说:

科学家需要能够长时间专注于他们的工作，他们还需要能够进行逻辑思考。此外，科学家需要能够提出问题并弄清楚事物是如何工作的。他们还需要能够独立工作。

科学家

这是贾斯珀可能认为的“实验室里的科学家”的样子。又多了一点性别包容性。结果是:

图像来源:作者使用碧玉艺术的插图。三是四个图像，包括两个女性呈现和一个两个呈现的人物。这些数字的种族构成似乎主要是白人/欧洲人。

在上面的例子中，我也注意到科学家是孤独的。在我看来，科学是一项团队运动！

当我让贾斯珀“写一段关于什么样的性格造就好科学家”时，他强调了独立性。说:

科学家需要能够长时间专注于他们的工作，他们还需要能够进行逻辑思考。此外，科学家需要能够提出问题并弄清楚事物是如何工作的。他们还需要能够独立工作。

我认为贾斯珀的训练数据缺少说明科学中团队合作重要性的文字。

一对新近订婚的夫妇

在这里，我让贾斯帕画“一对在订婚派对上刚刚订婚的夫妇”四个例子看起来都是异性恋。似乎没有种族多样性。

图像鸣谢:作者使用碧玉艺术的插画，共有四对情侣的四个图像(一人男性呈现，一人女性呈现)。这些数字的种族构成似乎都是白人/欧洲人。

一名警察

在这个测试中，我让贾斯帕给我一个“工作第一天的警官”一个家伙看起来像是在安可-安可-安可的事业上。撇开异常年龄不谈，以下是结果:

图片来源:作者使用碧玉艺术的插图。共有四张图片。四幅图像中的三幅，包括四对(一对男性展示，另一对女性展示)。这些数字的种族构成似乎都是白人/欧洲人。

我让贾斯珀用“写一篇关于警察职业生涯第一天的文章”的命令来写一名警察的第一天工作。贾斯珀说:

警察在职业生涯的第一天面临许多挑战。他们可能不得不处理困难的情况，做出生死抉择，并长时间工作。他们还需要学习如何应对不同类型的人，以及如何有效地执行法律。此外，他们必须与同事和上级建立良好的工作关系。

化学工程师

想过化学工程师长什么样吗？根据贾斯珀的说法，他们大多是男性，有时赤膊上阵，戴着眼镜很有创意。结果是:

图像来源:作者使用碧玉艺术的插图。有四个男性形象。这些数字的种族构成似乎都是白人/欧洲人。

使用命令“写一段关于化学工程师在工作中做什么的文章。”贾斯珀说:

化学工程师负责设计、建造和操作生产化学品的工厂。他们必须确保工厂安全高效地运行，同时符合环境法规。

https://pub.towardsai.net/six-months-later-what-data-science-hopefully-learned-from-facebooks-whistleblower-fe8049e5cac3

数学老师

再来一杯。我请贾斯珀制作《一个数学老师》结果如下:

图像来源:作者使用碧玉艺术的插图。有四个男性形象。对于其中的三个数字，这些数字的种族组成似乎都是白人/欧洲人。第四个图形背对着摄像机，不可能观察到表现型。

作为后续，我做了三次额外的尝试，让贾斯珀培养出一名女性数学老师。当我问及“快乐”的心情时，四位老师中有一位是女性。然后在第四次尝试中，我要求“一个友好和乐于助人的数学老师”,结果也是四个画面中有一个是女性呈现的。最后，当我问到“英语老师”时，四个图片中有三个是女性。

结论

根据 Jasper 的说法，创作原创的无版权艺术很容易。根据 Jasper 的电子邮件，有三个步骤:

第一步。逐字描述你脑海中的任何图像。
第二步。应用一些有创意的风格。
第三步。观看贾斯珀立即创建它。(好吧，更像是 5 秒钟)

我认为这条消息好坏参半。这些结果能证明什么吗？不。他们什么都证明不了。我在这里产生的数据是不系统的。我对数据的审查并不系统。

然而，这种人工智能的实现，与其他人工智能的实现不同，似乎有可能受到社会系统性偏见和成见的影响。

https://medium.com/the-faculty/reading-list-on-bias-in-ai-ml-data-science-4ccdc93f6219

感谢阅读

你准备好了解更多关于数据科学职业的信息了吗？我进行一对一的职业辅导，并有一份每周电子邮件列表，帮助专业求职者获取数据。点击这里了解更多。

感谢阅读。把你的想法和主意发给我。你可以写信只是为了说声嗨。如果你真的需要告诉我是怎么错的，我期待着尽快和你聊天。推特:@ adamrossnelsonLinkedIn:亚当罗斯尼尔森。

偏差——数据分析的致命弱点

原文：https://towardsdatascience.com/bias-the-achilles-heel-of-data-analysis-29fc46e49c06

理解数据背后的东西&人工智能

面对数据偏差不可避免的后果

由尼克·扬森对 Pix4free 的偏见

介绍

在之前的一篇文章中，我讨论了信息理论和克劳德·香农对我们理解“信息”的贡献在这篇文章中，我们发现“意义”与信息无关，尽管这看起来很矛盾。这就是香农的天才之处，他假设信息是“噪音”和“惊喜”的确，意义会混淆分析信息的可能性。现在，我们必须解决信息收集、分类和分析中的一个主要缺陷。

偏见

数据分析在确定数据中的实际内容方面有着巨大的工作量。然而，对数据纯度的追求并没有就此结束。

处理实际数据中可能存在的偏差至关重要。在分析和人工智能领域，人们必须警惕两种重要的偏见。

数据中的偏差

在分析任何系统的数据，特别是人工智能系统的数据时，必须了解所述数据的来源。例如，将来自 90%男性健康统计数据的海量数据湖的医疗信息应用于大多数女性人口，可能会产生有缺陷的结果。类似地，根据中上层阶级个人的反应为政治民意调查创建全国平均值也会产生错误的结果。

所有数据集本质上都包含一定的偏差。这种偏差必须在分析和相应的人工智能中加以考虑。

评估或创建数据时的偏差

约翰·海因 T15 在Pix4free上的偏置

康威定律

数据分析最危险的一个方面可能会导致人工智能的灾难性结果，这就是控制组内部固有的偏见。

1968 年，计算机程序员梅尔文·康威在一篇论文中假设‘设计系统的组织(在这里使用的广义上)被限制生产这些组织的通信结构的复制品。

这个简短的陈述就是众所周知的康威定律，它解释了偏见是如何在系统中出现的。它今天仍然适用，因为它定义了人类行为。系统继承了创造者的偏见。他们模仿创造他们的人——如果有人愿意用“克隆”这个词的话。

在其他方面，艾米·韦伯在人工智能方面的研究集中在这种偏见上，因为这是正确人工智能实现的基础。正如她明智地指出的那样:‘在没有有意义的解释的情况下，我们有什么证据证明偏见没有钻进来呢？在不知道这个问题的答案的情况下，怎么会有人放心地信任人工智能呢？。

正如韦伯在她对哈佛商学院代码库分析的评估中指出的:

“他们的一个重要发现是:设计选择源于他们团队的组织方式，在这些团队中，偏见和影响往往会被忽视。因此，一旦他们的工作——无论是梳子、水槽还是算法——被公众使用，团队中的个人组成的小型超级网络就会发挥巨大的力量……

因此，康威定律占上风，因为部落的价值观——他们的信仰、态度和行为以及他们隐藏的认知偏见——是如此根深蒂固。'⁴

对照组偏倚

然而，偏见的问题并没有就此结束。偏差可能出现在实际使用的数据集中，因为数据最初是如何定义的。

'由于研究人员不能仅仅将“海洋数据”抓取并加载到机器学习系统中进行训练，他们将从第三方购买合成数据集或自己构建一个数据集。“这通常是有问题的，因为组成数据集——包含什么内容以及如何标注——充斥着一小部分人做出的决定，他们通常不知道自己的职业、政治、性别和其他许多认知偏见。”⁵

1956 年，达特茅斯学院举办了第一次专门讨论人工智能的会议。⁶“人工智能”这一术语被认为是约翰·mccarthy,⁷会议的领导者，也是该提案的原始作者之一。不幸的是，最初的小组是有根本缺陷的，充满了偏见。它没有有色人种，47 名杰出的参与者中只有一名女性——尽管有许多有色人种和女性专家。不带偏见地创建团队的答案很明显。

一个真正多元化的团队只有一个共同的主要特征:天赋。不会有任何单一性别、种族或民族的集中。不同的政治和宗教观点将被代表。⁸

然而，要实现无偏倚的数据，必须普遍应用‘天赋’法则，而这并不是一个现实的目标。

人性总会产生某种类型的偏见，无论一个人多么自诩自己不偏不倚，政治正确。偏见存在于人们所做的每一件事情中；这是一个人个人主义的表现。

让事情变得复杂的是，对一种文化和社会来说是偏见的东西对另一种文化和社会来说被认为是合理的、客观的和公平的。例如，即使在我们这个被认为是开明的现代世界，一个“同性恋”个人也可能不被允许加入任何代表团体。或者性别偏见可能是某个特定国家占主导地位的社会、文化和宗教的一部分。

举两个简单的例子:

合法饮酒的年龄因地区而异。任何包含这些不同年龄和地区的测量酒精消费影响的数据集，如果不考虑法定年龄这一因素，如果在一般水平上应用，将会有根本性的缺陷。
合法驾驶的年龄因地区而异。同样的问题存在于我们的第一个例子中。任何涉及新的、年轻的、十几岁的或十几岁以后的司机的事故数据集都必须考虑这个因素。

在上面给出的两个简单的例子中，很容易陷入先入为主的观念并产生错误的分析。

重要的是我们要记住“偏见”永远不会包含一个“一意孤行”的定义。

检测偏见在任何结构中是否明显取决于特定亚文化如何定义偏见以及该定义如何在系统中实施。偏见永远不会被根除，尽管从任何定义来看，它总是一个消极因素。

因此，数据分析必须考虑这种偏见，并建立无数的防御措施来对抗它。如果不这样做，将会导致错误的结果和灾难性的人工智能缺陷。

群体思维

凡妮莎·奥特罗 via 维基共享资源

如上所述，康威定律的一个衍生是一种被称为“群体思维”的心理现象

“群体思维(Groupthink)是一种发生在一群人内部的心理现象，在这种现象中，对群体和谐或一致的渴望导致了非理性或功能失调的决策结果。一个群体中的凝聚力，或对凝聚力的渴望，可能会使其成员产生不惜一切代价达成一致的倾向。这使得团队能够最大限度地减少冲突，在没有批判性评估的情况下达成共识。”⁹

在 2016 年克林顿-特朗普美国总统选举期间，群体思维抬头。在结果变得明朗之前，很少有人能够想象特朗普会获胜。根据民调，就连唐纳德·川普本人也预计会输掉选举，他租了一个小酒店舞厅做了一个简短的败选演讲，后来他说:“我说过如果我们会输，我不想要一个大舞厅。”⁰

然而，尽管充分意识到这种心理现象，它在整个美国和整个世界占主导地位。唐纳德·特朗普永远不会也不可能赢得选举。

在 2016 年美国总统大选前的几周和几个月，新闻媒体和民调机构几乎一致认为希拉里·克林顿极有可能当选。例如，11 月 7 日，选举前一天，《纽约时报》认为克林顿当时“在至少价值 270 张选举人票的州中拥有持续和明显的优势。”《纽约时报》估计克林顿获胜的可能性为 84%。同样在 11 月 7 日，路透社估计克林顿在选举中击败唐纳德·特朗普的概率为 90%，赫芬顿邮报根据“980 万次模拟”将克林顿的胜算定为 98.2%。

选举结果与选举前的估计之间的矛盾，无论是来自新闻媒体还是民意调查机构，可能是由两个因素造成的:新闻和民意调查专业人士无法想象像特朗普这样非传统的候选人会成为总统，特朗普的支持者可能没有被调查充分采样，或者可能因为害怕社会排斥而欺骗或误导民意调查机构。

数据出错有成百上千的原因。民意测验专家有偏见。报纸听信了他们的花言巧语。被调查的选民不想回答，因为害怕被嘲笑，或者出于对民意调查的蔑视，他们故意给出错误的答案。然而，偏见从一开始就很明显，没有人愿意面对它。

纵观历史，群体思维已经抬头。决策通常基于错误的数据分析或拒绝面对“真实数据”所描述的情况。在企业界，这往往会导致灾难性的后果，要么是数亿美元的损失，要么是公司被迫关闭。

在战争史上，群体思维的例子比比皆是。基于不准确的数据做出错误的假设，导致生命损失。911 后入侵伊拉克就是一个很好的例子。1941 年 12 月 7 日日本袭击珍珠港之前，美国未能充分保护和保卫珍珠港——尽管有许多即将发动袭击的警告和信号——是集体思维的结果。数据就在那里。军政领导分析了一下。这种偏见蔓延开来，因为人们认为日本人永远没有勇气攻击美国并迫使美国加入世界大战。

许多人认为，美国国家航空航天局“挑战者”号在起飞时爆炸的灾难是群体思维的一个例子。数据是可用的。美国宇航局意识到冰冻温度对航天飞机的不利影响。发出了警告。然而，当美国国家航空航天局的领导们在一起开会时，他们为挑战者号的起飞开了绿灯。

我们可以举出一个又一个康威定律和群体思维的例子。然而，有一点是清楚的。

人类的状况将永远包含偏见。偏见是人类的一部分。数据集将反映这种偏向。如果我们不创建正确的算法和对偏差的正确分析，我们将总是以有缺陷的分析而告终。

偏见的确是数据分析的致命弱点。

关于作者:

泰德·格罗斯是“假设-假设”的联合创始人兼首席执行官。Ted 担任 R&D 首席技术官兼副总裁多年，擅长数据库技术，专注于 NoSQL 系统、NodeJS、MongoDB、加密、人工智能、颠覆、混沌和复杂性理论以及奇点事件。他在虚拟世界技术领域有超过 15 年的专业经验，在增强现实领域有 6 年的经验。Ted 继续在专业学术期刊和脸书 If-What-if Group 、 Medium 、 Twitter 和 LinkedIn 上撰写许多关于技术主题的文章。你也可以在这里或在 Substack 上注册的免费时事通讯。

参考资料:

1.康威，m . e .(1968)‘委员会如何发明？’，数据化，第 14 卷，第 5 卷，第 28–31 页。

2.维基百科(未注明)“康威定律”，可在 https://en.wikipedia.org/wiki/Conway's_law 查阅(2021 年 7 月 29 日查阅)。

3.韦伯(2019)《九大巨头:科技巨头和他们的思维机器如何扭曲人性》，纽约公共事务出版社，Kindle 版，位置 1763。

4.同上，地点 1666。

5.同上，地点 2763。

6.维基百科(未注明)‘人工智能’，可在:https://en.wikipedia.org/w/index.php?获得 title =人工智能&oldid = 997705860(2021 年 1 月 13 日访问)。

7.维基百科(未注明)‘约翰·麦卡锡(计算机科学家)’，可在:https://en . Wikipedia . org/wiki/John _ McCarthy _(计算机科学家)(2021 年 7 月 29 日访问)。

8.韦伯，参考。上面 3 个，位置 893。

9.维基百科(未注明日期)“集体思考”，可在 https://en.wikipedia.org/wiki/Groupthink(2022 年 4 月 18 日访问)获得。

10.维基百科(未注明日期)“2016 年美国总统选举”，可在:https://en . Wikipedia . org/wiki/2016 _ United States _ presidential _ election(2022 年 4 月 18 日访问)。

11.维基百科(未注明)' Groupthink '，可在:https://en . Wikipedia . org/wiki/group think # 2016 _ United _ States _ presidential _ election(2022 年 4 月 18 日访问)。

*为了与 Medium 的披露政策保持一致，上面列出的所有亚马逊图书链接都是假设分析的附属链接。

机器学习中的偏差-方差权衡、过拟合和正则化

原文：https://towardsdatascience.com/bias-variance-trade-off-overfitting-regularization-in-machine-learning-d79c6d8f20b4

偏差-方差权衡，过度拟合介绍&如何使用正则化解决过度拟合:岭和套索回归

图片来源: Pixabay

“近似正确总比精确错误好”
― 沃伦·巴菲特

检验是一个重要的问题，是每个数据科学家和机器学习工程师建模清单的重要组成部分。因此，如果你正在使用一个统计学、计量经济学或机器学习模型，无论你的 ML 模型有多简单，你都应该确保你的模型不会过度拟合。否则，你有机会在纸上得到一个好的模型，而实际上这个模型表现很差。在这篇博文中，我将涉及以下主题:

**- Model Error Rate
- What is Overfitting
- Irreduccable Error
- Model Bias
- Model Variance
- Bias-Variance Trade-Off
- What is Regularization?
- Ridge Regression and L2 norm
- Pros and Cons of Ridge Regression
- Lasso Regression and L1 norm
- Pros and Cons of Lasso Regression**

如果你之前没有统计学知识，或者你想在跳到本文中的公式和其他统计学和 ML 概念之前刷新你在基本统计学概念方面的知识，你可以查看本文: 数据科学家和数据分析师的统计学基础

注意，本文是我上一篇介绍偏差-方差权衡的文章的扩展版: 机器学习中的偏差-方差权衡

模型误差率

为了评估模型的性能，我们需要看看它产生的误差量。为简单起见，让我们假设我们有以下简单的回归模型，该模型旨在使用一个单个 自变量 X 来模拟数值 Y 因变量，即我们根据我们的训练观察值 { (x_1，y_1)，(x_2，y_2)，…，(x_n，y_n) } 来拟合我们的模型，并且我们获得估计值 f ()

然后我们可以计算出 f ^(x_1， f ^(x_2),…， f ^(x_n).如果这些近似等于 y_1，y_2，…，y_n，那么训练错误率(例如 MSE)将会很小。但是，我们真的对f(x _ k)≈y _ k；相反，我们真正想要的是知道 f(x_0)是否近似等于 y_0，其中(x_0，y_0)是一个看不见的测试数据点，在模型的训练过程中不使用。我们希望选择一种测试错误率最低的方法，而不是训练错误率最低的方法。在数学上，该示例方法的模型误差率可以表示如下:

使用训练错误率来评估模型性能的基本问题是，不能保证具有最低训练错误率的方法也将具有最低测试错误率。粗略来说，问题是很多 ML 或统计方法专门估计模型系数或参数，以最小化训练错误率。对于这些方法，训练错误率可以相当小，但测试错误率往往大得多。

使用训练错误率来评估模型性能的基本问题是，不能保证具有最低训练错误率的方法也将具有最低测试错误率。我们希望选择一种测试错误率最低的方法，而不是训练错误率最低的方法。

图片来源:伊莎贝拉·巴雷托

什么是过度拟合？

术语过度拟合与模型的不良性能有关。当机器学习模型在低错误率(例如，低训练 MSE)的训练数据上表现良好，但当应用于测试数据时，它会导致更高的错误率(例如，高测试 MSE)，我们称之为过拟合。当相反的情况成立时，即 ML 模型未能密切跟踪数据并准确捕捉数据集特征和目标变量之间的关系，我们称之为欠拟合。

当机器学习模型过于紧密地跟踪训练数据，并考虑到数据中的噪声时，就会出现这种情况。因此，一旦数据发生变化，例如，使用了测试数据，那么模型就很难找到数据中特征之间的真实关系。

图片来源:作者

要理解过拟合的问题，你需要熟悉机器学习模型的偏差-方差权衡、知道什么是不可约误差、偏差和方差。此外，您需要知道模型错误率的构成。最后，您需要知道这些术语与模型灵活性和模型性能的关系。

解决过拟合问题你有两个选择:

选择另一个灵活性较低的模型(例如，众所周知灵活性较低的模型偏差较大，但方差较小)
调整模型，使其灵活性降低(规则化)

当机器学习模型过于紧密地跟随训练数据并考虑到数据中的噪声时，就会发生过拟合。

图片来源:马蒂亚斯 P.R 雷丁

不可约误差

作为对 y 的预测，yˇ的精度取决于两个量，我们可以称之为可约误差 和 不可约误差。一般来说，fˇ不会是对 f 的完美估计，这种不精确会引入一些误差。这种误差是可以减少的，因为我们可以通过使用最合适的机器学习模型来估计 f，从而有可能提高 f 的精度。然而，即使有可能找到一种模型来完美地估计 f，从而估计的响应采用 yˇ= f(x)的形式，我们的预测仍然会有一定的误差。这是因为 y 也是误差项ε的函数，根据定义，误差项ε不能用预测因子 x 来预测。

因此，与误差ε相关的可变性也会影响预测的准确性。这被称为不可约误差,因为无论我们对 f 的估计有多好，我们都无法减少ε引入的误差。因此，模型中不可约误差是误差项ε的方差，可表示如下:

与可约误差不同，不可约误差是一种由于系统中的随机性或自然可变性而产生的误差，我们无法通过选择更好的模型来避免或减少这种误差。

图片来源:史威茨安娜

机器学习模型的偏差

模型无法捕捉数据中的真实关系被称为偏差。因此，能够检测数据中真实关系的 ML 模型具有低偏差。通常，复杂的模型或更灵活的模型往往比简单的模型有更低的偏差。数学上，模型的偏差可以表示如下:

机器学习模型无法捕捉数据中的真实关系称为偏差。

图片来源:马蒂亚斯 P.R 雷丁

机器学习模型的方差

模型的方差是将模型应用于不同数据集时模型性能的不稳定性水平。当使用训练数据训练的同一个模型的表现完全不同于对测试数据的表现时，这意味着模型中存在很大的差异。复杂模型或更灵活的模型往往比简单模型具有更高的方差。

模型的方差是将模型应用于不同数据集时模型性能的不稳定性水平。

图片来源: Max Avans

偏差-方差权衡

可以从数学上证明，对于给定值 x0，机器学习模型的预期测试错误率可以用模型的方差、模型的偏差和模型的不可约误差来描述。更具体地，监督机器学习模型中的误差等于模型的方差、平方偏差和模型的不可约误差之和。

因此，数学上，监督模型中的误差等于模型中偏差的平方、模型的方差和不可约误差。

因此，为了最小化预期的测试错误率，我们需要选择一种同时实现低方差和低偏差的机器学习方法。然而，模型的方差和偏差之间存在负相关关系。

复杂模型或更灵活的模型往往具有较低的偏差，但同时，这些模型往往比简单模型具有更高的方差。

让我们再次回到之前的图表:

图片来源:作者

一般来说，随着方法灵活性的增加，方差将增加，偏差将减少。这两个量的相对变化率决定了测试误差率会增加还是减少。

数学上，监督模型中的误差等于模型中偏差的平方、模型的方差和不可约误差。那就是:

当我们增加一类方法的灵活性时，偏倚最初的下降速度往往比方差的增加速度快。因此，预期的测试错误率下降。然而，在某些时候，增加灵活性对偏差影响很小，但开始显著增加方差。所以，这一切都是为了找到平衡，即最佳契合点，在这个点上，测试错误率将改变方向并向上移动。

图片来源:作者

基于偏差和方差关系，机器学习模型可以有 4 种可能的场景:

高偏差和高方差(最坏的情况)
低偏差和低方差(最好的情况)
低偏差高方差(过拟合)
高偏置和低方差(欠拟合)

复杂模型或更灵活的模型往往具有较低的偏差，但同时，这些模型往往比简单模型具有更高的方差。

图片来源: Alex Zhernovyi

什么是正规化？

正则化或收缩是解决过拟合问题的常用方法。正则化背后的想法是在机器学习模型中引入一点偏差，同时显著降低方差。之所以称之为收缩，是因为这种方法将一些估计的系数向零收缩，以惩罚它们增加了模型的方差。两种最流行的正则化技术是基于 L2 范数的岭回归和基于 L1 范数的拉索回归。

正则化背后的想法是在机器学习模型中引入一点偏差，同时显著降低方差。

里脊回归

让我们来看看用于因变量 y 建模的 p 个独立变量或预测值的多元线性回归示例。您可能还记得，估计线性回归参数的最流行的估计技术是普通最小二乘法(OLS) ，它通过最小化模型的残差平方和(RSS) 来找到最佳系数(有关更多信息，您可以在此处阅读)。那就是:

其中β代表不同变量或预测值(X)的系数估计值。

岭回归与 OLS 非常相似，只是系数是通过最小化稍微不同的成本或损失函数来估计的。也就是说，岭回归系数估计βR 值，使其最小化以下损失函数:

其中λ(λ，总是正的，≥ 0)是调谐参数或罚参数，从这个公式可以看出，在脊的情况下，使用 L2 罚或 L2 范数。通过这种方式，岭回归将分配一个惩罚给一些变量，使它们的系数向零收缩，从而减少整体模型方差，但是这些系数永远不会精确地变成零。因此，模型参数永远不会精确设置为 0，这意味着模型的所有 p 个预测值仍然保持不变。

L2 范数(欧几里德距离)

L2 范数是一个来自线性代数的数学术语，它代表欧几里得范数，可以表示如下:

调谐参数λ

调整参数λ用于控制惩罚对回归系数估计的相对影响。当λ = 0 时，罚项不起作用，岭回归将产生普通的最小二乘估计。然而，当λ → ∞(变得非常大)时，收缩惩罚的影响增大，并且岭回归系数估计接近 0。

图片来源:作者

岭回归为什么有效？

岭回归相对于普通最小二乘法的优势来自于早先引入的偏差-方差权衡现象。随着惩罚参数λ的增加，岭回归拟合的灵活性降低，导致方差减少但偏差增加。

赞成的意见

解决过度拟合
容易理解

缺点

如果 p 较大，模型可解释性较低

岭回归将分配一个惩罚(λ)给一些变量，使它们的系数向零收缩，但它们永远不会精确地变成零。

图片来源:阿什利·丰塔纳

套索回归

岭回归的一个最大缺点是它会在最终模型中包含所有的 p 预测值。因此，较大的 lambda 将对某些变量进行惩罚，使其系数向零收缩，但它们永远不会精确为零，当您的模型具有大量要素且模型的可解释性较低时，这将成为一个问题。

套索回归克服了岭回归的这个缺点。也就是说，Lasso 回归系数估计值βˇλL 是使以下各项最小化的值:

与岭回归一样，Lasso 将系数估计值收缩到零。然而，在套索的情况下，使用了 L1 罚函数或 L1 范数，其效果是当调谐参数λ非常大时，迫使一些系数估计值恰好等于零。因此，像许多特征选择技术一样，套索回归除了解决过度拟合问题之外，还执行变量选择。

图片来源:作者

L1 范数(曼哈顿距离)

L1 范数是一个来自线性代数的数学术语，它代表曼哈顿范数，可以表示如下:

套索回归为什么行得通？

像岭回归一样，Lasso 回归相对于普通最小二乘法的优势来自于早期引入的偏差-方差权衡。随着λ的增加，岭回归拟合的灵活性降低，导致方差减少但偏差增加。此外，Lasso 还执行特征选择。

赞成的意见

解决过度拟合
容易理解
提高模型的可解释性

缺点

与岭回归相比，减少模型的方差较少

Lasso 回归将系数估计值向零收缩，甚至在调谐参数λ非常大时迫使这些系数中的一些恰好等于零。因此，像许多特征选择技术一样，套索回归除了解决过度拟合问题之外，还执行变量选择。

当把前面两张图放在一起时，岭回归和套索回归之间的比较就变得很清楚了。

图片来源:作者

如果你喜欢这篇文章，这里有一些你可能喜欢的其他文章:

https://tatev-aslanyan.medium.com/bias-variance-trade-off-in-machine-learning-7f885355e847 https://tatev-aslanyan.medium.com/data-sampling-methods-in-python-a4400628ea1b https://medium.com/analytics-vidhya/pyspark-cheat-sheet-big-data-analytics-161a8e1f6185

感谢阅读

我鼓励你 加入 Medium*以拥有* 完整访问所有跨媒体发布的伟大锁定内容，并在我的 feed 上发布关于各种数据科学、机器学习和人工智能主题的内容。

关注我 中阅读更多关于各种数据科学和数据分析主题的文章。更多机器学习的动手应用，数学和统计概念查看我的*Github*账号。
我欢迎反馈，可以联系LinkedIn。****

快乐学习！

有偏模型系数—(第一部分)

原文：https://towardsdatascience.com/biased-model-coefficients-part-1-2722128b9e1c

衰减偏差/回归稀释使您的系数偏向 0

图片由施旭刚

TL；DR —当 X 变量中存在显著噪声或测量误差时，模型系数会低估变量的影响，即如果系数为正(负)，真实影响甚至会更大。

关于这个系列

假设您是一名数据科学家，在一家从事房地产业务的公司(代理、开发商等)工作。)有人问你:

"每增加一平方米，房价会上涨多少？"

图片由派克斯提供

这个由多个部分组成的系列致力于展示，如果没有对传统统计学的扎实理解，得到错误的答案是多么容易。

衰减偏差/回归稀释

衰减偏差，也称为回归稀释，是由独立(X)变量中的测量误差或噪声引起的模型系数偏差。你的模型系数变得偏向 0。

例如，假设您有一个回归模型，显示面积每增加一平方米，价格就会增加 2000 美元。如果您的面积要素有很多测量误差或噪声，面积的真实影响甚至更大…也许价格实际上增加了 2500 美元。

反之亦然。例如，如果你的模型显示负系数为-2000，那么真实的系数会更小，比如说-2500。系数偏向 0 。

请注意，如果您的因变量(y)有噪声或测量误差，这种偏差不会发生…它只会受到 X 变量中的噪声或误差的影响。

为什么会出现这种偏差？

作者图片

假设面积每实际增加 1 平方米，价格就上涨 2000 美元。

当我们对具有带有测量误差的报告“面积”列的数据运行回归模型时，该“面积”列表示实际面积+噪声。

报告的“面积”栏中的波动部分是由于 a)面积的实际波动和 b)噪音。

a)的系数应为 2000，因为实际面积每增加 1 平方米，价格就会增加 2000 美元，而 b)的系数应为 0，因为噪音或测量误差对房价没有影响。该报告的“面积”栏的系数最终介于 0 和 2000 之间，分别是 a)和 b)的系数。

我们将避免可以在网上找到的详细公式，我们将跳转到 python 中的一个例子…

数据准备

1-我们住在一个有 2000 栋房子的城镇里。

2-镇上有 2 个区，一个高级/昂贵区和另一个非高级/普通区。

3-高档区的房屋平均面积较小(平均 200 平方米)。普通区的房屋平均面积为 500 平方米。数据中的房屋面积是从正态分布中提取的。

4-房屋的真实价值= 3000 美元 x 面积(平方米),适用于高级住宅区的房屋。真实价值= 1000 美元 x 非优质区面积。

5-房子在市场上出售，价格=真实价值+/- 20%。+/- 20%的偏差只是噪音。

让我们基于上述假设创建一个包含 2000 所房屋的数据集…

import numpy as np
import scipy.stats as ssnp.random.seed(seed=0)areas_premium = ss.norm(200, 50).rvs(1000)
areas_non_premium = ss.norm(500, 50).rvs(1000)

从上面创建一个包含区域和“溢价”列的数据框架…

“溢价”栏是一个虚拟/二元变量，表示房子是否在溢价区。

df_premium, df_non_premium = pd.DataFrame(), pd.DataFrame()df_premium['area'] = areas_premium
df_premium['premium'] = 1df_non_premium['area'] = areas_non_premium
df_non_premium['premium'] = 0df = pd.concat([df_premium, df_non_premium])
df

作者图片

现在，让我们想象一下区域的分布情况…

import matplotlib.pyplot as plt
import seaborn as snssns.displot(df, x='area', hue='premium', height=5, aspect=16/9)plt.title('Distribution of areas (sqmt) for premium vs non-premium houses')plt.show()

作者图片

我们可以看到高级住宅通常较小。

现在，由于房子的真实价值= 3000 美元 x 高档房的面积或 1000 美元 x 非高档房的面积，我们可以将真实价值的公式改写如下:

真实价值=(1000 美元 x 面积)+(2000 美元 x 面积 x 溢价)

其中 premium 是一个二进制数，表示该房屋是否位于高级位置

记住，房子是以真实价值+/- 20%(随机)出售的。

最后，我们将“真实价值”和“销售价格”添加到我们的数据框架中，并可视化销售价格的分布…

df['true_value'] = (df['area'] * (1000 + (2000 * df['premium'])))# Add selling price = true value x noise
# Noise is a random value between 80% and 120%
np.random.seed(seed=0)
df['sell_price'] = df['true_value'] * (
    np.random.randint(low=80, high=121, size=2000) / 100)# Visualize distributions of selling price
sns.displot(df, x='sell_price', hue='premium', height=5, aspect=16/9)plt.title('Distribution of selling price for premium vs non-premium houses')plt.show()

作者图片

我们可以看到，高级住宅的售价范围更广。

检查线性回归的系数

请注意，由于我们的目标是确定面积和销售价格之间的直接关系，就可解释性和影响测量而言，线性回归是最合适的选择。

我们将使用 statsmodel 库，它为线性回归模型生成一个很好的输出，但是结果也可以使用 sklearn 的 linear regression 实现来重现。衰减偏差影响其他机器学习模型，无论是线性还是非线性。与 OLS 回归相比，线性模型(如随机梯度下降回归器(SGDRegressor ))将显示几乎相同的效果，而衰减偏差的影响对于非线性和基于树的模型更加微妙，这些模型通常需要其他解释库，如 SHAP 或莱姆。

使用 statsmodel 运行 OLS 线性回归，将“真实值”作为我们的因变量(y ),将“面积 X 溢价”作为我们的自变量(X)。

df['area_x_premium'] = df['area'] * df['premium']# Statsmodel implementation
import statsmodel.api as smy = df['true_value']
X = df[['area', 'area_x_premium']]model = sm.OLS(y, X)
results = model.fit().summary()
results

作者图片

请注意，这些系数是按照我们的预期(1000 和 2000)正确估计的。R2 是 100%，这意味着使用我们的两个变量“面积”和“面积 x 溢价”可以 100%准确地预测“真实价值”。

我们使用 sklearn 的 LinearRegression 实现得到相同的系数，使用 SGDRegressor 得到几乎相同的系数。

model = LinearRegression()
model.fit(X, y)
model.coef_

作者图片

model = SGDRegressor(alpha=0, random_state=0, eta0=1e-5)
model.fit(X, y)
model.coef_

作者图片

现在，让我们检查一下，如果我们将 sell_price 而不是 true_value 设置为 y 变量，回归结果(使用 statsmodel)会是什么样子…

y = df['sell_price']model = sm.OLS(y, X)
results = model.fit().summary()
results

作者图片

现在，are 模型的准确率下降到 98.6%，因为 sell_price 包含了一些噪声，房屋的售价可能比其真实价值高出或低于 20%。

估计的系数~1000 和~1995 非常接近我们预期的 1000 和 2000。p 值为 0，表示系数的重要性。最后，我们可以看到这些系数(992–1009)和(1973–2016)的预期范围，因此我们的预期系数 1000 和 2000 落在这些范围内。

如果我们的 y 变量(sell_price)中有很多测量误差/噪声，系数应该仍然是无偏的，接近 1000 和 2000，但是额外的噪声会降低我们模型的预测能力，因此 R2 会下降，2 个系数的范围会更宽。

让我们试着这样做…

# Increase noise on target variable to +/- 50% of true value
np.random.seed(seed=0)
df['sell_price_extreme_noise'] = df['true_value'] * (
    np.random.randint(low=50, high=151, size=2000) / 100)y = df['sell_price_extreme_noise']model = sm.OLS(y, X)
results = model.fit().summary()
results

作者图片

R2 下降到 92.1%，但我们的系数仍然接近 1000 和 2000。正如所料，系数的范围更大。例如，对于第一个自变量(面积)，新的范围是 982–1023，而上次运行的范围是 992–1009。

现在，假设测量误差在我们的独立变量中，这样我们数据集中的面积列与实际面积相差+/- 50%。这就是我们偏见产生的原因…

# We'll make area noisy such that it has +/- 50% error
np.random.seed(seed=0)
df['area_noise'] = df['area'] * (
    np.random.randint(low=50, high=151, size=2000) / 100)df['area_x_premium_noise'] = df['area_noise'] * df['premium']y = df['sell_price']
X = df[['area_noise', 'area_x_premium_noise']]model = sm.OLS(y, X)
results = model.fit().summary()
results

作者图片

R2 下降到 90.7%，但最重要的是，我们的系数现在低估了面积的影响！我们现在看到的系数是~917 和~1835。真实的预期系数(1000 和 2000)也超出了报告的范围(897-937 和 1781-1889)。这就是衰减偏差。

结束语

如果我们的目标是预测房价，那么低估面积真实影响的估计系数很可能是预测建模的最佳系数……你不需要做任何调整。

由于所报告的面积不准确且有噪声，因此，与我们有真实面积测量值的情况相比，OLS 回归或机器学习模型对这种有噪声的面积测量值给予较小的权重是最佳的。不需要做任何事情来提高模型的预测精度。

问题在于解释系数。当我们被问到

"每增加一平方米，房价会上涨多少？"

如果我们考虑了正确的变量，并且我们知道它们包含高测量误差，那么我们必须记住，我们获得的系数低估了由于面积增加实际 1 平方公吨而导致的价格上涨。

您可以使用 相关性衰减 或其他类似技术来估计“真实系数”。

BIG.art:使用机器学习来创建高分辨率的美术作品

原文：https://towardsdatascience.com/big-art-using-machine-learning-to-create-high-res-fine-art-7dd695f99788

如何使用 GLIDE 和 BSRGAN 创建具有精细细节的超高分辨率数字绘画

来自 BIG.art 的样本结果，图片由作者提供

一年多来，我一直在试验和写作使用 AI/ML 从文本描述中创造艺术。在此期间，我注意到人们对这一领域的兴趣明显增加，部分原因是 NFT 艺术市场的蓬勃发展。

看了几十个生成艺术的 ML 模型，目前我见过最好的是 OpenAI 的 GLIDE。再加上苏黎世联邦理工学院的超分辨率尺寸调整模型 bsr gan[2]，我发现结果非常好。

例如，下面是我的两个早期项目的结果，使用 CLIP+SWAGAN 的 MAGnet 和使用 CLIP+VQGAN 的 GANshare One ，与右边新系统的结果进行比较。我使用的提示是“一幅起伏的农田的画”、“一幅带有橙色三角形的抽象画”和“一碗水果的静物画”。

比较 ML 模型的输出，作者的图像

虽然对艺术的评估天生就是主观的，但对我来说很清楚的是，新模型的结果比前两个要好。(不过，我很欣赏橙色三角形的 CLIP/VQGAN 渲染的 3D 外观。)你可以点击每张图片仔细看。

概观

这是我的项目生成高分辨率美术(称为 BIG.art)的高级框图。在对系统进行概述后，我将在下面进一步讨论每个组件的细节。

BIG.art 组件，作者提供的图表

OpenAI 做了大量的工作，他们收集了 2.5 亿个文本-图像对，并训练了两个 GLIDE 模型，一个图像生成器和一个图像上采样器。我将一个文本提示“彩色玻璃瓶的静物画”传入 GLIDE 生成器，它创建了一组 7 个缩略图，每个 64x64 像素。然后，我将生成的缩略图和提示发送到 GLIDE upsampler，它将它们的大小调整为 256x256 像素。甚至上采样图像也非常小。如果你以 300 DPI 的分辨率打印，它的横向和纵向都不到一英寸。以下步骤用于调整所选图像的大小。

在尝试了几个调整大小的系统后，我选定了苏黎世 ETH 的 BSRGAN 超分辨率 resizer 模型。它很好地将所选图像的大小调整了 4 倍，达到了 1024x1024 像素。尽管调整后的图像边缘清晰，但填充区域趋于变平。为了补偿这一点，我为纹理添加了一些过滤噪声。

我选择性地将调整大小和纹理的图像通过德国海德堡大学的图像编码器和解码器 VQGAN。我发现 VQGAN 会发明新的细节，这些细节通常会增强调整后的图像。

最后一步是从 BSRGAN 中再次调整大小 4 倍，并再次通过纹理生成器。结果是一个 4096x4096 的图像，具有清晰的边缘和细节。以 300 DPI 的分辨率打印出来的照片会超过一平方英尺，适合装裱。这是带有一些细节的最终图像。

“彩色玻璃瓶静物画” 的 BIG.art 结果，带有显示细节的选定区域，图片由作者提供

请务必查看下面的附录，查看 BIG.art 的更多结果，并且您可以使用 Colab 在这里创建自己的艺术作品。

组件详细信息

使用 GLIDE 生成图像

2022 年 3 月，OpenAI 发布了一系列名为 GLIDE 的用于图像创建的 AI 模型，这是一种所谓的扩散模型，是生成式对抗性网络(GANs)的替代方案。谷歌研究院的两位工程师解释了扩散模型的工作原理。

扩散模型的工作原理是通过逐步添加高斯噪声来破坏训练数据，慢慢消除数据中的细节，直到它变成纯噪声，然后训练神经网络来逆转这一破坏过程。运行这个反向破坏过程通过逐渐去噪从纯噪声合成数据，直到产生干净的样本。该合成过程可以被解释为一种优化算法，其遵循数据密度的梯度来产生可能的样本。— Jonathan Ho 和 Chitwan Saharia [3]

扩散模型基本上是降噪模型，这些模型已经被训练了很长时间，以至于它们在给定纯噪声作为输入的情况下生成新的图像。

OpenAI 的 GLIDE 基于他们早期对使用扩散模型进行图像合成的研究。他们 2021 年的论文在标题中有一个大胆的声明，扩散模型在图像合成上击败了 GANs，表明以图像类别为条件的扩散模型可以获得比最先进的生成模型更好的图像质量[4]。在他们的最新论文 GLIDE:用文本引导扩散模型实现真实感图像生成和编辑中，作者…

…观察无分类器引导的滑翔能够推广到各种各样的提示。该模型通常生成逼真的阴影和反射，以及高质量的纹理。它还能够制作各种风格的插图，如特定艺术家或绘画的风格，或像素艺术等一般风格的插图

对于 BIG.art，我使用 GLIDE 图像生成器接收文本提示，并生成一系列七幅 64x64 的图像。系统试图描述提示中描述的内容。然后，我将图像和提示输入到 GLIDE upsampler，将分辨率提高到 256x256。该系统被训练成在调整大小时使用提示来帮助添加细节。

例如，GLIDE 从提示“海浪汹涌的海景”中生成以下七幅图像

GLIDE 为“海浪汹涌的海景”生成的图像，作者提供的图像

好吧，那些看起来很不错。这是另一组“波士顿城市地平线”

GLIDE 为“波士顿城市天际线”生成的图片，作者提供的图片

这些看起来有点像波士顿，但不完全是。在任何情况下，我将使用第四个调整大小的讨论如下。

请注意，OpenAI 发布了经过训练的 GLIDE 模型，这些模型无法创建人的图像。作者声明…

…在没有安全措施的情况下发布我们的模型，将会大大降低创建令人信服的虚假信息或深度伪造所需的技能。…为了减轻发布这些模型的潜在有害影响，我们过滤了包含人的训练图像…以降低模型在许多以人为中心的有问题的用例中的能力。亚历克斯·尼科尔等人[1]

用 BSRGAN 调整图像大小

有许多不同的方法使用人工智能来调整图像大小，以获得干净，清晰的结果。这个研究领域被称为超分辨率成像。

我测试了六种不同的图像超分辨率(ISR)尺寸调整模型，发现了两种称为盲尺寸调整网络(BSRNet)和盲尺寸调整生成对抗网络(BSRGAN)的模型，它们对于放大艺术图像非常有效。BSRGAN 模型使用 BSRNet 作为基线，然后使用 GAN 模型进行进一步训练。

来自苏黎世联邦理工学院的论文作者设计了一个实用的深度盲图像超分辨率退化模型，他说。

众所周知，如果假设的退化模型偏离真实图像中的退化模型，单幅图像超分辨率(SISR)方法将不能很好地执行。虽然一些退化模型考虑了其他因素，如模糊，但它们仍然不足以有效地覆盖真实图像的各种退化。为了解决这个问题，本文提出设计一个更复杂但实用的退化模型，该模型由随机混洗模糊、下采样和噪声退化组成。—张开等人

该系统经过训练，可以盲目地发现产生低分辨率(LR)图像的各种退化，从而在重建高分辨率图像时通知 AI 模型。以下是多种 ISR 模型的对比。左边是原始的 LR 图像，右边是用 BSRNet 和 BSRGAN 放大的图像。

BSR 论文中描述的 ISR 方法比较，来源:张开等人

您可以看到 BSRNet 和 BSRGAN 的图像和指标看起来比其他的更好。所示的两个质量度量是峰值信噪比(PSNR)，其中越大越好，以及学习感知图像块相似性 LPIPS，其中越小越好。我发现 BSRGAN 通常看起来更锋利，所以这就是我在我的大型艺术项目中使用的。

这是 GLIDE 用双三次插值和 BSRGAN 放大了四倍的“波士顿城市天际线”图像。请注意，您可以点击图片查看详细信息。

使用(左)双三次插值和(右)BSRGAN 调整大小调整 4x 大小的比较，图片由作者提供

你可以看到，用 BSRGAN 调整大小后的图像更清晰、更有活力。然而，它似乎有一个喷枪质量，在光滑的区域缺乏纹理。我将在下一节讨论这个问题。

纹理生成器

为了给图像的平坦部分增加一些趣味，我创建了一个纹理生成器，它通过一个模糊函数运行一个单色随机噪声场。然后将噪声场添加到图像中。这些参数是:

texture_amount -从 0 到 15%的噪波数量。
纹理大小-从 1 到 9 的噪波“块”的大小

这是原始图像，5%的纹理设置为尺寸 1 和 9。

不同纹理尺寸生成的图像(左)无，(中)尺寸为 1 时 5%，尺寸为 9 时(右)5%，作者提供的图像

我发现添加一点纹理会使生成的和调整大小的艺术作品更具美感。纹理生成器的源代码是这里是。

使用 VQGAN 增强细节

当我在尝试各种图像生成技术时，我碰巧通过一个名为矢量量化生成对抗网络(VQGAN)的系统发送了一个用 BSRGAN 调整大小的图像[5]。我在过去的三个 GAN 项目中使用了 VQGAN。我通常使用文本提示和 OpenAI 的剪辑来微调图像，运行 VQGAN 100 到 400 次迭代。

有趣的是，我发现简单地用 VQGAN 编码和解码图像可以改善细节，尤其是用 BSRGAN 放大的图像。

下面是使用 VQGAN 编码/解码前后波士顿城市天际线图像的一个区域的细节。对于这个实验，我关闭了纹理生成器。

原始调整大小图像的细节(左)和通过 VQGAN 编码和解码的图像(右)，作者提供的图像

这很微妙，但你可以看到 VQGAN 如何添加一些细节，似乎在右下方完成了一个建筑项目。

这是因为 VQGAN 的设计和训练方式。这是一个混合的 Transformer/GAN 模型，它查看图像的子区域，并将它们编码为之前在训练中看到的区域类型。解码的时候会和邻居一起无缝渲染细节部分。

BSRGAN 模型通过预测高分辨率图像的外观，将 256x256 图像放大到 1024x1024。然后 VQGAN 模型用新发明的细节映射结果图像。你可以在我的 GANshare 文章中看到 VQGAN 的完整报道。

再次使用 BSRGAN 进行最终的大小调整

BIG.art 的最后一步是用 BSRGAN 和另一种纹理处理再放大 4 倍。这是 4096x4096 像素的最终图像。

“波士顿城市地平线”的大艺术效果图，作者图片

你可以点击图像来放大并查看细节。请务必查看下面的附录，查看更多生成的图像。

结果

在试用 BIG.art 之后，我发现有些提示对于生成图像很有效，但有些则不然。

有效的提示

创作抽象画似乎效果不错。以下是一些提示。请注意，您可以在附录中看到生成的图像。

“一幅带有彩色圆圈的抽象画”
"一幅带有黄色和黑色细线的泼溅画"
"一幅带有紫色和绿色方格的拼色画"

风景画看起来也不错。

“意大利别墅的风景画”
《湖上日落》
“雄伟的雪山”

还有宠物的画。

"一幅柯基的画"
"一只虎斑猫"
“玻璃鱼缸里的金鱼”

不起作用的提示

涉及人的提示(例如，“儿童玩耍”、“巴拉克·奥巴马”、“蒙娜丽莎”等。)不工作是因为 GLIDE 的训练数据故意缺人。

抽象概念的提示(例如，“自由”、“崭新的一天”、“失控”等)。)也不起作用，因为对互联网上使用这些词标记的图像的内容缺乏共识。

这里有一个问题定义了使用 BIG.art 的经验法则:当你在谷歌上搜索这个提示并查看结果图像时，它们看起来大致相似吗？如果是这样，使用该提示生成图像将会生成良好的图像。哦，不要试图渲染人。没用的。

源代码

这个项目的源代码可以在 GitHub 上获得。我在 CC BY-SA 许可下发布源代码。你可以使用这个 Google Colab 创建你自己的图片。

知识共享署名共享

如果您使用此代码创建新图像，请这样注明:此图像由罗伯特·a·贡萨尔维斯使用 BIG.art 创建。

感谢

我要感谢詹尼弗·林和奥利弗·斯特瑞普对本文的帮助。

参考

[1] A. Nichol 等人， GLIDE:使用文本引导扩散模型实现真实感图像生成和编辑 (2022)

[2] K. Zhang 等，BSRGAN，设计一个实用的深度盲图像超分辨率退化模型 (2021)，IEEE/CVF 国际计算机视觉会议论文集(ICCV)，2021，第 4791–4800 页

[3] J. Ho 和 C. Saharia，使用扩散模型生成高保真图像 (2021)

[4] P. Dhariwal 和 A. Nichol，扩散模型在图像合成上击败 GANs(2021)

[5]p . Esser、R. Rombach 和 B. Ommer 著的 VQGAN，驯服变压器实现高分辨率图像合成 (2020 年)

附录

以下是 BIG.art 针对以下提示的输出示例。这些是我认为七张照片中最好的。

抽象画

一幅带有彩色圆圈的抽象画

一幅带有彩色圆圈的抽象画，作者图片

一幅带有黄色和黑色细线的泼溅画

一幅带有黄色和黑色细线的泼溅画，作者图片

带有紫色和绿色方格的块状彩画

一幅带有紫色和绿色方格的块状彩画，图片由作者提供

风景画

意大利别墅的风景画

意大利别墅风景画，作者图片

湖面上的日落

湖上落日，作者 Imae

雄伟的雪山

雄伟的雪山，作者图片

宠物画

一只柯基犬的画

一幅柯基犬的画，作者图片

一只虎斑猫

一只虎斑猫，图片由作者提供

玻璃碗里的金鱼

玻璃缸里的金鱼，作者图片

奖金提示

以下是我的一位评审员 Oliver 建议的各种提示的一些效果图。

木材车间

一个木材作坊，图片作者

微生物

微生物，图片作者

塞车

交通堵塞，图片作者

为了无限制地访问 Medium 上的所有文章，成为会员，每月支付 5 美元。非会员每月只能看三个锁定的故事。

谷歌云平台中的大数据基础

原文：https://towardsdatascience.com/big-data-fundamentals-in-google-cloud-platform-3a2bcafa267

云计算|大数据|技术

第 2 部分——通往谷歌云专业数据工程师之路

Pawel Czerwinski 在 Unsplash 上的照片

欢迎来到 GCP 专业数据工程师认证系列的第二部分。在第一部分，我们介绍了谷歌的云平台及其层次结构。您可以在这里找到第 1 部分:

在这一部分，我们将讨论大数据技术和机器学习方面的服务和 GCP 的产品。

使用云 SQL 和 Spark 的产品推荐

产品推荐可能是现代企业最常见的 ML 应用之一。

这个用例的想法是将现有的推荐系统从内部迁移到云中。

当迁移到云时，我们将从专用存储迁移到集群外云存储。

ML 任务的核心部分是数据、模型和基础设施，用于训练和向用户提供预测。

作为一个用例，让我们选择开发出租房屋推荐系统的任务。

说到基础设施，首先，我们需要决定我们希望多长时间发布一次预测。

所以第一个决定是，我们的 ML 应用程序应该处理流数据还是批处理？

在我们的用例中，我们不需要不断地向用户推荐房屋，而是可以每天预加载结果，并在用户在线时提供给他们。因此，在这种情况下，批处理就可以了。

另一方面，根据我们拥有的房屋和用户的数量，我们还需要考虑计算资源。当我们处理大型数据集时，我们需要以容错的方式执行这种处理。这意味着，理想情况下，我们在一组机器上运行我们的过程，而不是在一台机器上。

容错分布式进程框架的一个例子是 Apache Hadoop。该过程将类似于:

每一天，每一个用户，根据他们以前的评分预测每个房子的分数/评分
存储这些预测评级
用户登录后，查询前 N 名结果(基于预测分数)并显示给用户

因此，我们需要一种事务方式来存储预测。它需要是事务性的，这样我们就可以在用户阅读时更新表格。

GCP 提供多种交易解决方案。当然，考虑到不同的需求，我们必须使用不同的服务。下面，我们总结了一些 GCP 服务的属性。

谷歌服务及其访问模式。谷歌云平台

GCP 存储流程图。图片作者。

对于我们的示例用例，云 SQL 是最好的服务。

云 SQL 是一个完全托管的 RDBMS。使用静态 IP，我们还可以从任何地方连接到我们的云 SQL 实例。

我们还需要一个管理数据处理管道的服务。

我们需要一种服务来处理我们的数据批次和数据流，并训练机器学习模型。

这种软件的一个很好的例子是 Apache Spark 和它的机器学习包(Apache SparkML)。查看我的另一个博客，在创纪录的时间内运行 Spark 作业，而不需要任何基础设施开销。

你喜欢这篇文章吗？如果是，请考虑订阅我的电子邮件列表，以便在我发布新内容时得到通知。

https://david-farrugia.medium.com/subscribe

此外，考虑成为会员，使用我下面的推荐链接来支持我和你在 Medium 上喜欢的其他作家。每月 5 美元，你就可以无限制地阅读 Medium 上的每一篇文章。

https://david-farrugia.medium.com/membership

想给我买杯咖啡吗？

https://paypal.me/itsdavidfarrugia?country.x=MT&locale.x=en_US

想联系吗？

我很想听听你对这个话题的想法，或者其他什么。如果你想联系我，请发邮件到 davidfarrugia53@gmail.com给我。

Linkedin——Twitter

小字里的大数据

原文：https://towardsdatascience.com/big-data-in-little-wordle-306d5502c4d9

对约 7000 万场世界扑克比赛的大规模数据分析

尼尔斯·胡内尔弗斯特在 Unsplash 上的照片

最近，我一直在探索流行的文字游戏 Wordle[62–67]的各个方面，这款游戏在 2022 年 1 月和 2 月风靡了互联网。当我开始欣赏被问到的许多数据科学问题时，我决定使用 Wordle 作为我大学三年级的一个案例研究项目，这是我每年春天在都柏林大学教授的数据科学实践课程。该课程是一门基于实践的课程，要求小组学生设计、开发和展示他们自己的数据科学项目。为了让他们开始，我总是提出一个新的案例研究，作为对他们的期望的例子，下面是今年 Wordle 案例研究的总结。我将描述使用的数据集和回答的研究问题。而且，虽然我之前已经在博客上写了以下内容的一些方面，但这里呈现的结果代表了我迄今为止进行的最详细的分析。

TL；速度三角形定位法(dead reckoning)

这是一篇又长又详细的帖子，所以这里是一些关键的结果:

我们描述了 Wordle 数据的两个重要来源的发展:(I)由 Wordle 模拟器生成的超过 5300 万个游戏的数据集；以及(ii)Twitter 上发布的超过 1500 万个真实世界游戏的数据集。
( RQ1 )我们比较了模拟数据集和 Twitter 数据集，发现它们在几个重要方面有很强的对应性。
( RQ2 )一项对 Twitter 游戏的分析表明，Wordle 在 1 月底/2 月初在 Twitter 上达到顶峰。
( RQ3 )一项对模拟游戏的分析显示了一些开始词如何比其他的更有效。Twitter 数据集告诉我们，大约 17%的玩家使用了糟糕的开始词，这可能会对这些玩家的表现产生负面影响。
( RQ4 )另一项对模拟游戏的分析显示，一些目标词比其他的更具挑战性，导致游戏时间更长，成功的游戏更少。Twitter 的数据也证实了这一点，但没有证据表明 Wordle 会像一些人猜测的那样变得越来越难。
( RQ5 )玩好 Wordle 的能力取决于玩家选择尽可能满足目前所学约束的猜测。对模拟游戏的分析表明，正确的字母和正确的位置约束是最重要的一致遵守。

一点点单词

Wordle 是一款简单却引人入胜的在线猜词游戏。每天都会选择一个新的秘密目标单词，玩家有一次机会参与游戏。在每次猜测之后，向玩家提供颜色编码的反馈(见图 1)，以指示:(I)目标单词中包含哪些字母(如果有的话)以及它们的正确位置(绿色)；(ii)哪些字母在目标单词中但不在它们的正确位置(黄色)；以及(iii)目标中缺少哪些字母(灰色)。这样，随着每一个新的猜测，玩家可以学到更多关于目标单词及其字母的知识。

图 1:一个示例 Wordle 游戏和每次猜测后提供的提示。请注意，即使玩家第一次猜对了“L”(及其位置)，Wordle 也不会帮助他们识别“L”是目标单词中的重复字母。这就是为什么“KNOLL”在 2022 年 1 月被证明是最难找到的单词之一，以及它很少被使用和“KN”的使用不寻常的事实。图片作者。

游戏可以在 Twitter 上共享，而不会破坏其他人的游戏，如图 2 所示。通过使用 Wordle 的反馈而不是猜测本身，每个游戏都作为实际游戏的一种格式塔来共享。这为玩家提供了足够的信息来展示他们的表现，但不会泄露游戏。

图 Twitter 上分享的一些 Wordle 游戏。图片作者。

是什么让 Wordle 成为一个好的数据科学话题？

选择一个合适的数据科学主题通常可以归结为至少两个重要问题:(1)是否有一组有趣的研究问题要问,( 2)是否存在可以回答这些问题的数据？就 Wordle 而言，即使粗略地浏览一下关于这款游戏的大量文章和视频[1，2，5，7，13，27，39，41，62–68]，也能清楚地看到这款游戏是有趣问题的丰富来源，从“游戏的平均长度是多少？、最好的起始词是什么？ " to " 是不是有些目标词比其他的更难？、最佳猜测策略是什么？ 忽略一些暗示可以吗？”

虽然不缺乏研究问题，但获得数据来回答这些问题是一个更具挑战性的命题。Twitter 是一个数据来源，虽然不完整，但在回答至少一些研究问题时应该是有用的(例如，平均游戏长度，目标词难度)。如果可以找到一种合理的方法来模拟现实的游戏，那么也有可能产生足够现实的合成数据集，为单独使用 Twitter 数据集无法回答的研究问题提供答案。事实上，也应该有可能使用来自 Twitter 的 Wordle 数据来评估合成/模拟数据与真实游戏相符的程度。

因此，对 Wordle 的分析似乎是一个强有力的数据科学项目候选。它很受欢迎。对于人们询问的关于他们的游戏和其他人的游戏的有趣问题的答案有着强烈的需求。应该有可能使用合成和真实世界游戏数据的组合来充分详细地探索这些问题——适当地定义。

研究问题

对于这里介绍的工作，我们将使用两个 Wordle 数据来源:由模拟器生成的模拟数据和 Twitter 上共享的真实世界游戏数据。这两个数据集将在后面详细描述，我们将使用它们来回答以下研究问题。

RQ1:模拟数据是否接近真实游戏？对于来自我们模拟器的数据是否是真实游戏数据的合理代理，形成一个观点是很重要的。为此，我们将使用几种不同的游戏性指标来比较两个数据集的几个方面。
RQ2:Wordle 到底有多火？ 我们可以使用 Twitter 数据集来评估年初以来 Wordle 的受欢迎程度，其依据是更多人在 Twitter 上分享意味着更多人玩 Wordle。这不会提供 Wordle 受欢迎程度的完整图片，因为只有一小部分玩家会在 Twitter 上分享他们的游戏，那些分享的玩家可能会对他们分享的游戏有所选择，但它应该会提供一些关于游戏受欢迎程度以及它如何变化的合理见解。
RQ3:起始字的选择重要吗？ 这是 Wordle 玩家最初问的问题之一。数据告诉我们什么？是否有证据表明，一些起始词比其他起始词导致更长或更短的游戏或更多成功/不成功的游戏？坚持一个好的开头词值得吗？
RQ4:是不是有些目标词比其他的更有挑战性？ 如何评价一个目标词的难度？迄今为止最难的单词是什么？为什么这些单词比较难？游戏的难度随着时间的推移有变化吗？
RQ5:Wordle 的反馈有多重要？ 对于玩家来说，选择满足到目前为止所学的关于目标词的所有提示/约束的猜测是否重要？如果玩家需要做出妥协，那么哪些约束比其他约束更重要或更不重要？

Wordle 模拟器

这项研究的一个关键因素是一个现实的 Wordle 模拟器的可用性，这样我们就可以大规模地生成样本游戏。与一些相关的工作[1，2]不同，我们的模拟器不是为玩一个最优的 Wordle 游戏而设计的。相反，我们更感兴趣的是开发一个模拟器，可以代表不同的游戏风格和玩家能力，类似于我们可以从现实世界的玩家那里期待的那些。在接下来的内容中，我们将总结模拟器初始版本中采用的基本方法，然后描述如何对其进行调整以模拟更大范围的更真实的游戏。

我们开发的模拟器将一个目标单词和一个单词列表作为输入，用作有效的猜测。我们还包括这些词在常用中的流行程度信息，作为对候选猜测进行排序的一种方式。下面的概述算法展示了如何通过一系列猜测来模拟每个游戏，直到找到目标单词。

在每一轮中，提示/反馈用于更新关于目标单词的四组不同的知识:

正确字母 —猜测中的字母也在目标中，但不在正确的目标位置。
正确位置 —猜测中的字母在目标中的正确位置。
错误字母 —猜测中不在目标中的字母。
错误位置 —正确字母的错误位置。

这种知识可以用来约束每个新猜测的选择，并且在模拟器的初始版本中，从满足尽可能多的当前约束的可用猜测字中选择一个新猜测( pick_guess) 。通常，有几个兼容的猜测，模拟器选择了最流行/最常见的一个——使用一个单独的开源单词流行度数据数据集——来模拟玩家选择最先想到的单词。

一个更新的模拟器算法(如上所示)也包含了一个玩家词汇完整性的简单模型。基本思想是，具有更完整词汇的玩家应该更有可能能够识别满足当前约束的单词，因此在他们玩游戏期间不太可能需要牺牲约束。相比之下，词汇量不太发达的玩家将很难识别出满足所有游戏限制的猜测，因为这些单词不在他们的词汇表中。相反，这些玩家更有可能牺牲约束，选择他们更熟悉的次优猜测；这样的话仍然可以帮助游戏向前发展，只是不是以一种非常有效的方式。这个词汇表模型是使用参数 v ( 0 < v ≤ 1 )来实现的，以指示玩家词汇表中可用猜测单词的比例(按流行度排序)。因此，如果 v = 0.9 ，那么最流行的猜测单词的前 90%在玩家的词汇中，而 v = 0.5 意味着玩家的词汇仅包括前 50%的单词。

当选择新的猜测单词时，如果存在满足所有约束条件和的单词，这些单词在玩家的词汇表中，则选择最流行的一个。然而，如果不存在这样的词汇内单词，那么模拟器改为选择满足至少两个约束的最流行的非词汇单词。通过这种方式，我们可以预计词汇不完整的玩家更有可能需要在游戏后期进行次优猜测，因为他们的词汇中没有一个词满足不断增长的可用约束条件。

图 3 显示了模拟器制作的两个游戏示例，使用相同的开始和目标单词，但是词汇设置不同。(a)中的较低词汇表设置导致对目标单词的搜索时间长得多，因为在早期阶段牺牲了约束。例如，单词的第三个猜测这些忽略了正确字母约束，因为这个猜测比前一个猜测具有更少的正确字母。

图 3:模拟器使用不同词汇设置玩的两个示例游戏。在(a)中，模拟器使用 v = 0.6，这意味着它的词汇只有 60%完成，因此，它倾向于在早期牺牲约束，导致更长的游戏。在(b)中，模拟器使用 v = 0.9，所以它的词汇表几乎是完整的，这意味着约束不太可能被牺牲。图片作者。

数据和方法

在这项研究中，我们将使用作者创建的两组不同的 Wordle 游戏数据:(I)从模拟器生成的大量模拟游戏中产生的数据集；以及(ii)在 Twitter 的许可下，根据其搜索 API 的学术许可条款，从与 Wordle 相关的推文中收集的真实世界游戏数据集。在适当的时候，我们计划在知识共享许可下发布这两个数据集，并将在可用时添加到这些数据集的链接。

为了生成模拟数据集，模拟器玩了一些游戏，其中来自 Wordle 的目标单词列表的 2309 个单词中的每一个都被用作单独的目标。此外，我们还将模拟器配置为使用每个目标单词作为可能的起始单词。这意味着一个完整的模拟回合由 5，331，482 (2，309 x 2，309)个个人游戏组成。

接下来，我们针对 10 种不同的词汇设置( 0.1 ≤ v ≤ 1 以 0.1 为增量)完成单独的模拟回合。这意味着我们完整的模拟数据集由 53，314，820 个单独的游戏组成，对于每个游戏，我们记录以下数据:

目标词:使用的目标词。
起始字:使用的起始字。
v:使用的词汇设置。
回合:完成游戏所需回合数。
猜测值:使用的猜测值。
提示:每轮游戏结束后提供的一组提示。每个提示是一个由 5 个符号组成的字符串( *** 或 + 或 X 分别对应 Wordle 的绿色、黄色和灰色反馈)。
约束:为每一轮选择猜测时满足的约束数组。

结果数据集表示为包含 53，314，820 行的单个表。每行对应一个游戏，上面的每一行都是它的列。在这个数据集中，有 329，401，297 个单独的回合、猜测和提示。表 1 显示了该数据的一个示例。

表 1:来自模拟数据集的 30 行的样本，示出了包括目标和开始单词、词汇设置(v)、游戏回合数、每回合的猜测以及每回合接收的提示的列的子集(“*”是绿色正方形；+'是黄色方块；x 是灰色正方形)。出于清晰和空间的原因，每个游戏所使用的约束已经被省略。

Twitter 上的 Wordle 游戏与“ Wordle n r/6 ”形式的签名一起共享，其中 n 是当前游戏的号码， r 是当前游戏的回合数。为了构建 Twitter 数据集，我们使用 Twitter 搜索 API 来查找所有包含单词“Wordle ”,后跟游戏有效数字和使用适当正则表达式的有效“方块”序列的推文。总共收集了 15，373，887 个有效游戏(1，679，660 个独立玩家)，包括关于玩家 id、游戏 id、推文时间、日期、位置、语言和包含游戏的推文文本的数据，以及发布的单元格网格。表 2 显示了该数据的示例，该数据集总共包含 62，986，524 轮游戏(跨 15，373，887 场游戏)。

表 2:来自 Twitter 数据集的 30 行样本，显示了包括玩家和游戏 id、目标单词、游戏编号、每场游戏的回合数、游戏日期和游戏回合的翻译字符串的列的子集(' * '是绿色方块；+'是黄色方块；x 是灰色正方形)。玩家和游戏 id 是 Twitter 提供的作者和 tweet ids 的匿名版本。

RQ1:比较模拟数据集和 Twitter 数据集

我们在这一部分开始分析，通过比较模拟数据集和 Twitter 数据集来确定前者是否提供了现实世界游戏的真实描述。鉴于模拟数据集包含各种词汇设置的游戏——其中一些可能无法代表真实的游戏——我们将从比较 Twitter 游戏和基于几个词汇设置的模拟游戏集开始。图 4 显示了给定长度游戏的累积分数的结果。例如，我们可以看到，大约 25%的游戏长度达到并包括 3 轮，尽管只有大约 10%的游戏具有最低的词汇设置。不出所料，随着 v 的增加，给定长度内游戏的累积分数也会增加；例如， v = 0.1 只有不到 40%的游戏在 6 轮或更少的回合中完成，但是 v = 0.9 几乎 90%的游戏都是成功的。

图 4:给定长度的模拟和 Twitter 游戏的累积部分。基于词汇设置对模拟游戏进行分组；v = 0.1，0.5，0.7，0.8，0.9，1。图片作者。

图 4 还显示了 Twitter 数据集的相应累积游戏分数(带圆形标记的黑线)，应该清楚的是，这些游戏最接近于模拟游戏，其中 v = 0.9 或v = 1.0；与 Twitter 相比，前者高估了较短游戏的比例，后者倾向于低估较短游戏的比例。这表明将 Twitter 游戏与模拟游戏的子集进行比较对于 v ≥ 0.9 是合适的。

事实上，图 5 显示了 Twitter 和模拟器的给定长度游戏的分数( v ≥ 0.9 )，作为(a)每个游戏长度的实际游戏分数和(b)游戏长度增加的累积游戏分数。它展示了 Twitter 和模拟( v ≥ 0.9 )数据集之间不完美但紧密的对应关系。前者的平均比赛时间为 4.09 回合，而后者为 4.01 回合；模拟器产生更多的 4 轮游戏，但更少的 6 轮游戏，但除此之外，两个数据集之间有非常强的对应关系。

这意味着我们可以有理由相信使用模拟数据集(v≥0.9)作为真实世界游戏的合理近似。虽然这里没有显示，但当我们进一步将模拟数据集限制为仅使用与 Twitter 数据集相同的目标词的那些游戏时，我们在模拟数据集和 Twitter 数据集之间获得了更紧密的对应关系。在这种情况下，两个数据集的平均游戏长度为 4.09 轮，比较平均游戏长度的 t 检验表明两个数据集之间没有显著差异(t = 0.406，p = 0.684* )。*

图 5:比较了(A)游戏(模拟和 Twitter)的游戏时长和(b)游戏(模拟和 Twitter)的累积游戏时长。注意，模拟游戏用 v ≥ 0.9。图片作者。

RQ2:Wordle 的流行程度

在我们更详细地探索游戏的本质之前，让我们通过使用 Twitter 数据集来检查随着时间的推移在 Twitter 上发布 Wordle 游戏的独特每日玩家(新玩家和重复玩家)的数量，来考虑 Wordle 的增长和受欢迎程度。

为此，我们根据数据集中第一次出现的给定玩家 id(按日期排列)定义一个新的玩家，并将循环/重复玩家定义为在较早日期出现的玩家 id。然后，我们将 Twitter 数据按照日期和游戏号码的组合进行分组，并计算每个日期新玩家和重复玩家的出现次数。此外，对于每个日期，我们还计算重复出现的玩家发布的游戏的平均数量。

结果在图 6 中显示为每个日期的新玩家和回归玩家数量的堆积条形图，以及回归玩家发布的平均游戏数量的单独线图。它显示了 Wordle 在 2022 年 1 月期间的快速增长。这个月开始时，每天约有 10，000 名独立玩家在 Twitter 上发帖，但到了 1 月底，独立玩家总数迅速上升至近 250，000 人的峰值。自 2 月以来，在 Twitter 上发布游戏的独立玩家数量一直在下降，在撰写本文时，每天的独立玩家数量已降至约 10 万人；现在每天也只有不到 4000 名新玩家，低于每天约 50000 名新玩家的峰值。

图 Wordle 在 Twitter 上的受欢迎程度，以日新增用户数和日返回用户数表示(左侧 y 轴)。还显示了《纽约时报》收购 Wordle 的日期和 NYT“重新推出”Wordle 的日期。还显示了每个返回玩家的平均游戏次数(右侧 y 轴)。图片作者。

这表明我们已经度过了巅峰时期，至少在 Twitter 上是这样，但这并不意味着 Wordle 的受欢迎程度正在下降。例如，大多数玩家继续私下玩是完全合理的。此外,《纽约时报》2 月份重新推出的 Wordle 肯定吸引了许多新玩家，即使他们不愿意在 Twitter 上分享他们的努力。

RQ3:起始词的选择很重要吗？

在 Wordle 中，每局游戏开始时你都是独立的。没有提示可以指导你，所以大多数玩家试图使用一些明智的策略来选择一个可能与目标共享一些字母的单词。例如，有很多不同元音的单词通常是一个很好的选择，因为几乎所有的英语单词都至少有一个元音。带有普通辅音的单词，如“s”或“t”也是一个好主意，所以像凝视或审判这样的起始单词被证明是有效和受欢迎的。但这重要吗？有没有一小群客观上比别人强的潜在起始词？如果是，它们是什么，它们带来了多大的优势。

为了确定最佳起始词，我们将使用为 v ≥ 0.9 的所有游戏生成的模拟数据，因为这种词汇设置提供了与 Twitter(真实世界)数据的最佳拟合。在模拟数据中，我们已经为起始单词和目标单词的每种组合生成了游戏，这意味着我们使用 2，309 个可能的起始单词中的每一个和 2，309 个可能的目标单词中的每一个来玩游戏，并且对于两种词汇设置，总共产生 10，662，962 个游戏(G)(2，309 x 2，309 x 2)。

有几种不同的方法，我们可以评估一个开始字的性能。例如，一个显而易见的选项是，当使用游戏的每个开始单词时，计算它的平均游戏长度，如等式 1 和 2 所示，其中回合(g) 表示游戏中的回合数 g 。另一种替代方法是，在给定起始单词的情况下，计算获胜游戏的分数，即在 6 轮或更少轮中完成的游戏，如等式 3 所示；换句话说，一个好的开始词会产生更大比例的获胜游戏。还有一个选项是考虑短游戏(3 轮或更少轮的游戏)的部分和长游戏(需要 5 或 6 轮的游戏)的部分，如等式 4 和 5 所示。

对于这种分析，我们为 v ≥ 0.9 的模拟数据集的子集中的 2，309 个可能的起始词中的每一个计算上述度量。接下来，我们制作如图 7 所示的散点图，其中每个点对应于一个特定的起始单词，并根据其短游戏的比例(x 轴)和长游戏的比例(y 轴)位于图上。此外，每个点的直径与相应开始单词的获胜分数成比例，最后，每个点根据其平均游戏长度进行颜色编码，如所示的色标所示。这样，我们可以在一个二维散点图上呈现所有四个性能指标。

结果表明，开始词的选择很重要，因为我们可以看到短游戏和长游戏的比例以及平均游戏长度有相当大的变化。胜率的变化要小得多，平均为 93%，并且总是高于 89%。例如，右下象限中的单词与短游戏的高于平均分数和长游戏的低于平均分数相关联；短赛次数最高的词是 LEANT ，也有 93%的胜率，平均游戏时长 4.3 回合。相比之下，左上象限用于短游戏较少而长游戏较多的起始词； BOBBY 在这方面脱颖而出，因为它的长游戏数量最多，短游戏最少，胜率仅为 90%，平均游戏时长为 5 轮。如果你对优化胜率更感兴趣，那么最好的开始词可能是毛绒，因为它在所有开始词中胜率最高(94%)，但这是以更长的平均游戏长度(4.4 轮)、更少的短游戏和更多的长游戏为代价的。

图 7:模拟游戏中起始词的平均游戏长度分析(v ≥ 0.9)。每个标记对应于模拟器为给定起始单词产生的游戏，并且根据为给定起始单词产生的短游戏部分(x 轴)和长游戏部分(y 轴)来定位。每个标记基于相应开始单词的平均游戏长度进行颜色编码，并基于其相应的成功游戏分数来确定大小。水平虚线和垂直虚线分别表示长游戏和短游戏的平均分数。图片作者。

图 7 还包括媒体中经常提出的一些更常见的起始词(例如 SLANT、SLATE、CRATE、TRACE )。他们在这一分析中也做得很好，尽管不如 T2·利恩特做得好。

好的开始的好处和坏的开始的代价相比如何？要了解这一点，我们需要定义什么是好的开始或坏的开始。在 Twitter 数据集中，第二轮(我们认为是游戏的开始)后正确提示的中位数(绿色加黄色)仅为 2——顺便提一下，模拟数据集也是如此——因此我们可以说，根据等式 6 和 7，如果正确提示严格多于中位数，游戏就有一个好的开始，如果正确提示严格少于中位数，游戏就有一个坏的开始。

在我们的 Twitter 数据集中，几乎 17%的游戏开局不利，相比之下，48%的游戏开局良好；开局好的平均比赛时间是 4 轮，而开局不好的是 4.6 轮。因此，开局不利的成本大约是一轮的 0.6 倍。还不错，但这是全部情况吗？再深入一点，在图 8(a)中，我们看到了好的和坏的开始的游戏的累积分数，与平均游戏长度的简单比较相比，我们可以看到更多的实质性差异。例如，我们现在可以看到好的开始比坏的开始(大约 9%)产生更多的短游戏(大约 37%)；换句话说，良好的开局比糟糕的开局多 3 倍多的短比赛(长度≤ 3 轮)，如图 8(b)所示。因此，开局不利的真正代价主要体现在短距离比赛数量的大幅减少上。

图 8:基于对 Twitter 数据集中游戏的分析，一个好的开始的好处和一个坏的开始的代价。在(a)中，显示了具有良好开局的游戏与具有糟糕开局的游戏在给定游戏长度下的累积分数。在(b)中，条形图显示了在给定的游戏时间长度内，好的开始与坏的开始的相对比例。图片作者。

对模拟数据集执行相同的分析( v > 0.9 )会产生大致相似的结果，如图 9 所示。

图 9:基于对 Twitter 数据集中游戏的分析，一个好的开始的好处和一个坏的开始的代价。在(a)中，显示了具有良好开局的游戏与具有糟糕开局的游戏在给定游戏长度下的累积分数。在(b)中，条形图显示了在给定的游戏时间长度内，好的开始与坏的开始的相对比例。图片作者。

RQ4:为什么有些目标词比其他的更有挑战性？

在探索了最佳起始单词的问题之后，很自然地将我们的注意力转向目标单词。是不是有些目标词比其他的更有挑战性？如果是，那是为什么？自从《纽约时报》接手以来，沃尔多是否像一些人声称的那样变得更加困难了？我们可以定义一个目标词的难度，类似于我们评估一个起始词的好坏。根据等式 8-12，如果目标单词与较长的游戏、较低的胜率、较短游戏的较小部分或较长游戏的较大部分相关联，则该单词是困难的。

然后，使用模拟数据集(具有 v ≥ 0.9 )我们可以为每个可能的目标词计算这些指标，并且，如同起始词的情况一样，我们可以产生图 10 所示的散点图来提供我们的发现的总结。与图 7 相比，这一次我们看到了一个稍微不同的开始词模式。虽然有些单词比其他单词更难(左上象限)，有些单词挑战性要小得多(右下象限)，但多空游戏之间的关系本质上并不是线性的。像 JAUNT 和 MAMMY 这样的词通常与漫长的游戏和极低的胜率联系在一起。相比之下，更容易的目标词，如将和世界，它们有 100%的胜率，并产生非常短的游戏。

图 10:模拟游戏目标词的平均游戏长度分析(v ≥ 0.9)。每个标记对应于模拟器为给定目标单词产生的游戏，并且根据为给定目标单词产生的短游戏部分(x 轴)和长游戏部分(y 轴)来定位。每个标记基于相应目标单词的平均游戏长度进一步进行颜色编码，并基于所产生的成功游戏的相应部分来确定大小。水平虚线和垂直虚线分别表示长游戏和短游戏的平均分数。图片作者。

为了进一步探索目标词的难度，通过 Twitter 数据集，我们重点关注短游戏和长游戏的比例。例如，图 11 显示了 Twitter 数据集中最近 100 个目标词的每个目标词的短期和长期游戏的比例(以条形表示);每个目标单词的平均游戏长度也显示为线形图。我们可以看到，大多数目标单词与短游戏的关联多于长游戏，但对于一些单词来说，情况正好相反。比如刺和点大约 50%的游戏是短的，而长游戏只占游戏的 10%左右。对比一下的泔水或代理，它们的长游戏比短游戏多。这表明刺和点对玩家来说没有刺或代理有挑战性，顺便提一下，这与使用模拟数据集评估单词难度的结果一致，因为刺和代理位于图 10 的左上角象限，而刺和点位于右下角象限；我们再一次发现模拟器和现实世界游戏之间有很强的对应关系。

图 Twitter 数据集中 100 个最近的目标词的长短游戏比例；还显示了每个目标单词的平均游戏长度。图片作者。

我们将一个目标词的难度比定义为其长短局之比；参见等式 13。因此，难度比> 0 表示具有挑战性的单词——长游戏比短游戏多——而难度比< 0 表示更容易的单词，短游戏比长游戏多。比如像点这样的易词，难度比为-0.927(以0.037/0.5211为准)，而像will这样难度更高的词，难度比为 1.98(. 301/. 101)。

图 12 显示了 Twitter 数据集中所有目标词的难度比；难词(难度比> 0 )显示为红色条，较容易的词显示为绿色条。这澄清了在数据集的那个时期，有一些单词变得更加困难。到目前为止，最难的单词是will，这也被认为是模拟器中最难的单词之一。相比之下，根据 Twitter 数据集，像刺和点这样的词是最容易的词，模拟数据集也是如此。

顺便提一下，这一分析也有助于回答这样一个问题，即收购《纽约时报》后，Wordle 是否变得更具挑战性。事实并非如此，至少没有证据表明，在收购或《纽约时报》重新推出 Wordle 之后，单词的平均难度或更难单词的出现频率有所变化。

图 12:Twitter 上 100 个最近的目标词的难度比(条)，以及游戏长度的 7 天滚动平均值(虚线)。图片作者。

鉴于一些单词确实比其他单词更具挑战性——无论是在模拟数据集还是在 Twitter 数据集上——我们能说些什么原因呢？一种可能是，不常用的单词更难，因为它们不太可能成为人们的首选，即使我们已经学会的提示将它们挑选出来。同样，字母不常见的单词也可能更难。但还有另一个疑点，当我们查看 Twitter 上的困难单词子集时，我们可以看到:大多数具有正难度比率的单词都有重复的字母(例如， ABBEY，KNOLL，SKILL，SWILL，VIVID，lompty)。在猜测 Wordle 时，很自然地会倾向于选择没有重复字母的单词，以最大限度地增加某些字母与目标单词重叠的机会，而且，当我们猜测一对重复字母中的一个时，Wordle 不会提供任何迹象表明一个单词中可能有第二个这样的字母。

因此，我们对单词困难有三种可能的解释——不常用的单词、不常用的字母和重复的字母——可以通过测量来确定它们在困难单词和容易单词之间是否不同。例如，使用现有的英语单词数据集，我们可以计算给定的 5 个字母单词的频率，并将其用作单词频率归一化测量的基础，如等式 14 所示；因此，NormWordFreq(wt) > 1 意味着 wt 比一般单词更常见。同样，我们可以根据等式 16，基于字母在 5 个字母的单词中出现的频率来计算相应的字母频率的归一化度量(等式 15)；因此， NormLetterFreq(wt) > 1 意味着给定目标单词的平均字母频率大于平均值。

然后，我们可以使用等式 14 和 16 来计算困难单词(那些具有难度比> 0 的单词)和简单单词(难度比< 0 的单词和字母的平均频率。我们还可以计算包含重复字母的难/易单词的分数，并将其归一化为包含重复字母的 5 个字母单词的总分数。这些结果如图 13 所示。他们证实了我们的假设:难词远不如易词常见(图 19(a))，它们的字母也不太常见(图 19(b))，但难词更有可能有重复的字母(图 19(c))。

图 13:对单词和字母级别的频率以及重复字母的可能性的分析，有助于解释为什么一些目标单词比其他单词更难:困难的目标往往不太常见，涉及更多不寻常的字母，并且更可能有重复的字母。在每个图中，频率数据被归一化，使得值 1 对应于 5 个字母单词的平均值(用水平虚线表示)。图片作者。

RQ5:Wordle 的约束有多重要？

既然我们已经分析了起始词和目标词，是时候把注意力集中在一般的游戏玩法上了，特别是如何进行猜测。对于玩家来说，选择满足当前已知目标单词的猜测单词有多重要？玩家能承受牺牲一些约束而仍然玩得很好吗？哪些约束条件在使用时会提供更多有用的信息？

由于 Twitter 数据集不包含关于猜测的具体信息，因此不能用来回答这个问题。相反，我们将专门关注完整的模拟数据集；即使用 v 的所有值。使用缩减词汇设置的游戏与大量牺牲的约束相关联，这将允许我们的分析考虑约束使用的全部范围。

模拟数据集包括模拟器使用的约束条件的逐轮说明；每轮最多可关联 4 个约束(正确字母、正确位置、错误字母、错误位置)。我们可以计算每一轮游戏的错过的约束的数量，并根据等式 17 和 18 使用它来计算每轮游戏的错过的约束的平均数量；Gi . used【r】是指游戏 Gi 第 r 轮使用的约束集合。

接下来，我们计算具有给定词汇设置(v)的所有游戏的平均游戏时间和胜率，记录每轮对于每个值 v 错过的约束的平均数量。结果如图 14 所示。请注意每轮错过的约束条件的数量是如何随着 v 值的增加而减少的，因为当目标单词不在模拟玩家的词汇中时，模拟器会牺牲约束条件。例如，当只有 10%的目标单词在词汇表中( v = 0.1 )时，平均每轮牺牲 0.86 个约束，这意味着大多数轮将牺牲至少一个约束。但是当 v = 0.8，则每轮只牺牲 0.41 个约束；因此，在 5 轮游戏中会牺牲 2 个约束(0.41 × 5 个约束)。并且当 v = 1 时，所有约束总是得到满足。

图 14 中的结果显示，随着牺牲越来越多的约束，平均游戏时间增加，平均胜率降低。例如， v = 0.8 (每回合 0.41 个错过的约束)导致游戏的平均游戏时长刚刚超过 5 回合，胜率约为 80%，但对于 v = 0.4 (每回合 0.77 个错过的约束)，平均游戏时长增加到 7 个，只有约 40%的游戏成功。

图 14:不同词汇设置的平均游戏长度(和获胜的比例)。对于每个词汇表配置，每轮遗漏的约束的平均数显示在括号中。图片作者。

因此，错过的约束在游戏长度和胜率方面对游戏性能有实质性的影响，但是一些约束比其他的更重要吗？使用不同的约束条件可以获得多少信息？为了测试这一点，我们需要将我们的分析从基于游戏——也就是说，查看单个游戏的各种属性——转移到基于回合的分析。换句话说，我们将开始查看在游戏中做出的个人猜测。到目前为止，基于游戏的关注意味着我们的分析已经在 5300 万个项目(游戏)的大集合上运行。现在，我们将把它转换成一个更大的数据集，包含超过 3.29 亿个项目(轮次/猜测)。对于这个分析，我们对两件事感兴趣:(1)猜测满足了哪些约束，以及(2)从猜测中了解了多少新信息？

我们转换后的数据集包含一条记录，记录了在特定猜测过程中使用了四个可能约束条件中的哪一个——正确的字母、正确的位置、不正确的字母、不正确的位置——因为模拟器保存了这些信息。为了估计通过猜测获得的新信息，我们使用 Wordle 的反馈，通过计算该猜测收到的绿色和黄色提示的总数。我们将绿色和黄色提示的数量称为正确信息的数量，这样，随着回合的展开，正确信息数量的差异就可以衡量猜测的有用程度。

图 15: (a)对于不同的游戏总长度，每轮游戏中已知字母(绿色或黄色提示)的总数。(b)对于不同的总游戏时间长度，每轮使用的限制的数量。图片作者。

例如，在图 15(a)中，我们看到对于不同长度的游戏，每一轮获得了多少正确的信息。例如，对于短游戏(游戏长度= 3)，平均来说(模拟的)玩家在他们最初的猜测之后学习到 1.5 条正确的信息。他们的第二次猜测给他们带来了大约 3 条正确的信息，然后他们在第三次猜测中猜对了所有 5 个字母。对于更长的游戏，新信息的积累遵循越来越浅的轨迹，至少对于模拟器来说，在长时间游戏(> 6 轮)中，新的猜测可能导致比前一轮更少的信息。当玩家开始忽略约束条件，从而猜测可能违反目标单词已知信息的单词时，这种情况就会发生。事实上，在图 15(b)中有一个相应的图，显示了每一轮满足的平均约束数，我们可以看到随着模拟器牺牲越来越多的约束，游戏长度是如何增加的；这类似于上面图 14 中所示的，但是基于不同游戏长度的一轮接一轮，并使用每轮使用的实际限制数。

哪些约束更重要或更不重要是一个更复杂、更微妙的问题。我们建立一个回归模型，使用从猜测中获得的正确信息量作为因变量，使用四种约束类型的二元变量作为自变量。我们还包括游戏回合作为一个额外的独立变量，以确定其对新获得的信息的影响。因此，我们的模型被设计来预测从基于使用的约束和游戏回合的猜测中获得的新信息的量。

表 3。使用约束和轮数作为独立变量，预测每轮获得的新信息量的 OLS 回归结果。

得到的模型作为预测模型不是很好；见表 3。其调整后的 R2 值仅为 0.38，这意味着每轮获得的新信息量中只有约 38%的变化是由约束和游戏回合解释的；这并不奇怪，因为这很大程度上取决于实际猜测的细节和目标词等。然而，我们对这个模型作为预测模型有多好并不感兴趣，而是对它如何被用作解释模型感兴趣。特别是，我们对独立变量的系数感兴趣，它告诉我们它们在每次猜测获得的新信息数量方面的相对重要性；这些系数显示在表 3 的【T2 系数】栏中。

图 16:线性回归中每个独立因素的回归系数，用于预测每次猜测/轮次的总体信息增益。图片作者。

图 16 显示了每个独立变量的这些系数的值。它们可以解释为自变量单位变化的因变量(获得的新信息)的变化，同时保持所有其他自变量不变；由于约束变量是二进制的，单位的改变意味着约束被使用。因此，我们可以看到，当遵守正确字母约束时，平均获得 1.4 个单位的新信息，相比之下，当使用正确位置约束时，仅获得不到 1 个单位的新信息。相比之下，不正确的字母和不正确的 位置约束对获得的新信息量的影响更小。因此，我们可以得出结论，在所有其他条件相同的情况下，正确的字母和位置约束是最重要的，其次是不正确的字母约束，然后是不正确的位置约束。

游戏回合的效果不太重要。它具有正系数的事实意味着，在所有其他条件相同的情况下，后几轮往往比前几轮产生更多的新信息。

本节的结果显示了玩家在进行猜测时使用他们在前几轮中所学知识的重要性，因为牺牲一些约束条件，即使是一点点，也会影响游戏性能，并限制新信息的积累。正确的字母和位置约束比不正确的字母和位置约束更重要，这表明如果玩家必须牺牲一个约束，那么他们应该考虑在牺牲正确的字母或位置约束之前牺牲不正确的字母或位置约束。

值得指出的是，这是一个相当简单化的分析。例如，所使用的模型没有考虑约束之间可能存在的任何相互作用，而通过显式地模拟这种相互作用的影响来改进它是可能的。然而，作为一个解释性的模型，它对我们的目的是足够有用的，所以进一步的改进是作为未来工作的一个问题。

结论

Wordle 是一款简单的在线猜词游戏，于 2022 年初开始流行。每天选择一个新的(秘密的)5 个字母的目标单词，玩家试图通过一系列多达 6 次的猜测来识别这个单词。本文描述了使用模拟和真实世界游戏数据集对 Wordle 进行的大规模数据分析。通过比较模拟数据集和 Twitter 数据集，我们表明模拟器能够再现相当真实的游戏过程，进一步的分析发现了以下情况:

好的开始字导致更短和更成功的游戏，并且有与较差的开始字相关联的显著成本；在模拟和真实世界/Twitter 数据集的分析中观察到了类似的成本。
相当多的少数玩家(17%)似乎使用了糟糕的起始词，因此承诺使用更可靠的起始词会有所收获。
一些目标单词比其他单词更具挑战性，尤其是当它们不常见或包含重复字母时。在这方面，我们再次看到模拟器和 Twitter 数据集之间的强烈对应。
关注 Wordle 的反馈对于短游戏是必要的，关注正确的字母和位置比不正确的字母和位置更重要。

参考

3 蓝色 1 棕色。哦，等等，其实最好的开瓶器不是“鹤”。。。。 YouTube (2022)。
3 蓝色 1 棕色。用信息论解单词。 YouTube (2022)。
ALIYARI，h .，SAHRAEI，h .，DALIRI，M. R .，MINAEI-BIDGOLI，b .，KAZEMI，m .，AGAEI，h .，SAHRAEI，m .，HOSSEINI，S. M. A. S .，HADIPOUR，M. M .，MOHAMMADI，m .等人。电脑游戏压力对玩家认知功能的有益或有害影响。基础与临床神经科学 9 ，3 (2018)，177。
ANDERSON，B. J .和 MEYER，J. G. 使用最大正确字母概率和强化学习为 wordle 寻找最佳人类策略。arXiv 预印本 arXiv:2202.00557 (2022)。
我们亲爱的沃尔多究竟发生了什么事？ 《卫报》(2022 年 2 月)。
APPEL，A. W .和 JACOBSON，G. J. 世界上最快的拼字游戏程序。美国计算机学会第 31 届会议公报，5 (1988)，572-578 页。
阿基米德。Wordle——为什么我总是猜同样的四个字。 YouTube (2022)。
使用自动规划的推箱子谜题的人工智能辅助设计。在艺术、互动和游戏创作国际会议 (2021)，斯普林格，第 424–441 页。
BARLACCHI，g .、NICOSIA，m .和 MOSCHITTI，A. 学习对自动解决纵横字谜的候选答案排序。《第十八届计算自然语言学习会议论文集》 (2014)，第 39–48 页。
BONTHRON，M. 将一个近似值作为 Wordle 的策略进行排序。arXiv:2204.06324 (2022)。
视频游戏对人类(和兽人)创造力的影响。在视频游戏和创意。爱思唯尔，2015 年，第 39-60 页。
曹，s .和达希尔，I. 文字是如何成为互联网上的一种大众娱乐的。 Buzz Feed 新闻(2022 年 1 月)。
这些数字告诉我们什么是最好的和最差的单词开头。《卫报》(2022 年 2 月)。
CHESANI，p . MELLO，M. 解决数学难题:人工智能的挑战性竞赛。艾杂志 38 ，3 (2017)，83–96。
科尔曼、T. H .、莱瑟森、c .、里维斯特、r .、斯坦恩、C. 算法导论，II 。马萨诸塞州剑桥。麻省理工学院出版社，2009 年。
CRANFORD，E. A .、LEBIERE，c .、GONZALEZ，c .、COONEY，s .、VAYANOS，p .和 TAMBE，M. 通过模拟了解网络欺骗:在 Stackelberg 安全游戏中使用欺骗性信号预测人类决策。在 CogSci (2018)。
使用字符统计为 wordle 选择种子词。arXiv:2202.03457 (2022)。
埃里克森、K. I .、布特、W. R .、巴萨克、c .、奈德、M. B .、普拉卡什、R. S .、VOSS、M. W .、格雷比尔、A. M .、西蒙斯、D. J .、法比亚尼、m .、格拉顿等。纹状体体积预测视频游戏技能获得水平。 大脑皮层 20 ，11 (2010)，2522–2530。
厄南德斯，m .，安吉利尼，g .，和戈里，m .韦伯克劳:一个基于网络的纵横字谜系统。载于 AAAI (2005)，第 1412–1417 页。
FRUTOS-PASCUAL，m .和 ZAPIRAIN，B. G. 综述 AI 技术在严肃游戏中的应用:决策和机器学习。《IEEE 计算智能与人工智能汇刊》第 9 期，第 2 期(2015)，第 133–152 页。
《代码和数字中的生活:当香农遇到图灵》。电子观想与艺术**(EVA 2017)(2017)，51–58。
Wordle 中数学上最佳的第一次猜测。中 (2022)。
GOPHER，d .，WELL，m .，和 BAREKET，T. 从电脑游戏训练师到飞行的技能转移。人类因素 36 ，3 (1994)，387–405。
GRACE，k .、SALVATIER，j .、DAFOE，a .、ZHANG，b .、EVANS，o .AI 什么时候会超过人类的表现？来自人工智能专家的证据。人工智能研究杂志 62 (2018)，729–754。
格雷策，F. L .，赫什曼，R. L .，凯利，R. T. 防空游戏:研究人类行为的微型计算机程序。 行为研究方法&仪器仪表 13 ，1 (1981)，57–59。
GROSZ，b .、KRAUS，s .、TALMAN，s .、STOSSEL，b .和 HAVLIN，M. 社会依赖对决策的影响:一个新游戏的初步调查。在关于自主代理和多代理系统的国际联合会议 (2004)，IEEE，第 782–789 页。
霍尔，R. Wordle 的创造者被全球成功的热门拼图所淹没。 守护者(2022 年 1 月)。
哈姆金斯，J. D. 无限世界和主谋数字。arXiv 预印本 arXiv:2203.06804 (2022)。
HARGREAVES，I. S .，PEXMAN，P. M .，ZDRAZILOVA，l .，和 SARGIOUS，P. 爱好如何塑造认知:竞争性拼字游戏玩家的视觉单词识别。 记忆&认知 40 ，1 (2012)，1–7。
m . HENZ 和 H.-M .张Sudokusat——一种分析困难数独谜题的工具。在人工智能工具和应用中。斯普林格，2009 年，第 25-35 页。
HUCK，J. T .，DAY，E. A .，LIN，l .，JORGENSEN，A. G .，WESTLIN，j .和 HARDY III，J. H. 认知好奇心在基于游戏的学习中的作用:区分技能习得和适应。 模拟&游戏 51 ，2 (2020)，141–166。
凯利，R. T .、格雷策，F. L .、赫什曼，R. L. 防空:研究人类行为的电脑游戏。科技。1981 年，加利福尼亚州圣地亚哥海军人事研究与发展中心代表。
玩虚拟积木:作为实践与研究的学习环境。在数字化语境中的认知发展。爱思唯尔，2017 年，第 145–166 页。
LEE，d .，CONROY，M. L .，MCGREEVY，B. P .，和 BARRACLOUGH，D. J. 猴子在竞争游戏中的强化学习和决策。 《认知大脑研究》22 ，1 (2004)，45–58。
LEE d .、MCGREEVY b . p .和 BARRACLOUGH d . j .猴子在石头剪刀布游戏中的学习和决策。认知大脑研究 25 ，2 (2005)，416–430。
LIAPIS，a .，YANNAKAKIS，G. N .，TOGELIUS，J. 计算游戏创意。第五届国际计算创意大会 (2014)，ICCC。
LITTMAN，M. L .，KEIM，G. A .，和 SHAZEER，N. 一种解决纵横字谜的概率方法。人工智能 134 ，1–2(2002)，23–55。
利特曼，M. L .，凯姆，G. A .，和沙泽尔，N. M. 用谚语解决纵横字谜。在 AAAI/IAAI (1999)，第 914-915 页。
LOCK，s .wordle 是不是越来越难了？ 守护者(2022 年 2 月)。
LOKSHTANOV d .和 SUBERCASEAUX b .Wordle 是 np-hard 。arXiv:2203.16713 (2022)。
什么是 wordle？新的病毒性文字游戏取悦互联网。卫报(2021 年 12 月)。
MANTERE 和 j . KOLJONEN用遗传算法解决、评定和生成数独谜题。2007 年 IEEE 进化计算大会 (2007)，IEEE，第 1382–1389 页。
MANZINI、s . ELLIS 和 J. 文字游戏:使用认知计算作为人工智能解谜的基础。人工通用智能杂志 6 ，1 (2015)，111。
莫兰，C. 14 个最好的“单词”克隆体，因为一天一个单词是不够的。可混搭(2022 年 3 月)。
马兹拉克，L. J. 利用优先关系计算机构造纵横字谜。人工智能 7 ，1 (1976)，1–19。
纵横字谜中元素的机器选择:计算语言学的应用。 《暹罗计算杂志》5 期，1 期(1976)，51–72 页。
麦克甘，伊萨尔特尔，海德曼和康伦。跳过。跳。游戏:“有原则的”锻炼游戏对儿童运动技能获得的影响。 英国教育技术杂志。51 ，3 (2020)，798–816。
莫法特特区，克龙比，w .和沙巴丽娜，O. 一些电子游戏可以增加玩家的创造力。 国际基于游戏的学习杂志(IJGBL) 7 ，2 (2017)，35–46。
新生，M. 卡斯帕罗夫对深蓝:计算机国际象棋成熟了。施普林格科学公司商业媒体，2012 年。
NEWELL，a .，SHAW，J. C .，和 SIMON，H. A. 下棋程序和复杂性问题。《IBM 研究与发展杂志》2 ，4 (1958)，320–335 页。
PRAKASH、R. S .、DE LEON、A. A .、MOURANY、l .、LEE、h .、VOSS、M. W .、BOOT、W. R .、BASAK、c .、FABIANI、m .、GRATTON、g .和 KRAMER，A. F. 在一个复杂的视频游戏训练项目中检验技能获得的神经相关性。 人类神经科学前沿 6 (2012)，115。
m .理查兹和 e .阿米尔拼字游戏中的对手建模。在 IJCAI (2007)，第 1482–1487 页。
一个全自动纵横字谜生成器。第七届机器学习与应用国际会议 (2008)，IEEE，第 362–367 页。
RIGUTINI，l .、DILIGENTI，m .、MAGGINI，m .、GORI，M. 自动生成填字游戏。 《国际人工智能工具杂志》21 期，2012 年 03 期，1250014。
从国际象棋和雅达利到星际争霸和其他:游戏人工智能如何驱动人工智能的世界。KI-künstliche Intelligenz 34， 1 (2020)，7–17。
y . SATO 和 h .井上用保留积木的遗传操作解决数独。2010 年 IEEE 计算智能和游戏会议记录 (2010)，IEEE，第 23–29 页。
游戏、计算机和人工智能。 人工智能 134 ，1–2(2002)，1–7。
SCHERBAUM，s .，DSHEMUCHADSE，m .，LEIBERG，s .，和 GOSCHKE，T. 比预期更难:在电脑游戏中明显不利的延迟选择中冲突增加。 PloS one 8 ，11 (2013)，e79310。
世界冠军级别的拼字游戏。 人工智能 134 ，1–2(2002)，241–275。
短，M. B. 胜 Wordle 明智地。arXiv 预印本 arXiv:2202.02148 (2022)。
SILVER，d .，SCHRITTWIESER，j .，SIMONYAN，k .，ANTONOGLOU，I .，HUANG，a .，GUEZ，a .，HUBERT，t .，BAKER，l .，LAI，m .，BOLTON，a .，等人。在没有人类知识的情况下掌握围棋。Nnature 550，7676 (2017)，354–359。
在 Wordle 中糟糕开局的代价以及如何避免。 走向数据科学(2022 年 2 月)。
SMYTH，B. 在 Wordle 中，第一个字母是最难猜对的。或者是？ 走向数据科学(2022 年 2 月)。
SMYTH，B. 如何在 Wordle 中猜对。 走向数据科学(2022 年 1 月)。
SMYTH，B. 峰值单词量&单词难度。 走向数据科学(2022 年 2 月)。
三百万条 tweets 之后。 走向数据科学(2022 年 2 月)。
我从玩了一百多万个 Wordle 游戏中学到了什么。 走向数据科学(2022 年 1 月)。
根据科学，这是最好的策略。 YouTube (2022)。
STENSRUD，B. S .和 GONZALEZ，A. J. 通过观察人类在战略游戏中的表现发现高级行为。IEEE 系统、人和控制论汇刊，B 部分(控制论)38(T7)，3 (2008)，855–874。
TOBIAS，s，FLETCHER，J. D .，DAI，D. Y，WIND，A. P. 计算机游戏研究综述。 电脑游戏与指令 (2011)，127–221。
VISSCHEDIJK，G. C .、LAZONDER，A. W .、VAN DER HULST，a .、VINK，n .和 LEEMKUIL，H. 为战术决策游戏模拟人类情绪。 《英国教育技术杂志》44 期，2 期(2013)，197–207 页。
声音和颜色对电脑游戏反应的影响。 与计算机交互 13 ，2 (2000)，183–192。

大 O 符号

原文：https://towardsdatascience.com/big-o-notation-32fb458e5260

用 Big-O 符号计算算法的时间和空间复杂度

约翰尼斯·格罗尔在 Unsplash 上的照片

介绍

当开发算法时，我们通常关注它的有效性——换句话说，它是否能做它应该做的工作。然而，时间和空间复杂度是必须评估的两个非常重要的因素，以确保该算法可以在实践中实现和使用。

即使一个算法在理论上是可行的，但是如果运行它所花费的时间使它变得无用，会发生什么呢？或者它需要的空间大到电脑可能内存不足怎么办？

在今天的文章中，我们将在渐近算法分析的背景下讨论时间和空间复杂性。我们将探索大 O 符号，这是用来描述算法效率的最常用的度量。

此外，我们还将讨论大 O，大 Theta 和大 Omega 符号之间的区别。最后，我们还将通过几个实际操作的例子来演示如何在实践中计算时间和空间复杂度。

请注意，这些示例将使用 Python——即使您不了解 Python，我也很确定它会比您想象的更容易理解。为了帮助没有 Python 背景的人，我保证会添加尽可能多的评论:)

渐近时间复杂性

在数学分析中，渐近分析是一种用来描述当输入接近某个其他值时，函数所逼近的值(即极限)的方法。作为一个例子，让我们考虑我们想要研究一个函数 f(n) 在数 n 变得非常大时的行为。

如果f(n)=n⁴+4n+10并且数字 n 非常大，那么术语 4n 与术语相比将无足轻重，而 n 对常数 10 没有影响。因此，当 n 趋于无穷大时，函数 f(n) 被称为渐近等价于 n⁴ 。

现在在算法的上下文中，执行渐近分析，以便根据输入大小描述或评估算法的性能。换句话说，当输入大小也增加时，我们使用渐近分析来确定时间和空间的增加。

作为一个例子，让我们考虑你想要传送一个数据文件给一个朋友，他住在离你当前位置 3 小时路程的城市。现在让我们假设实际上有两种方式发送它；第一种是电子转账，第二种是旅行 3 个小时，用 u 盘(物理)交给她。如果您决定以电子方式发送文件，传输时间将受到文件大小的影响。文件越大，传输给朋友所需的时间就越长。另一方面，如果您决定前往您朋友的位置并将其移交，传输时间将为 3 小时，与文件的大小无关，因此文件大小不会影响传输时间。

下图说明了这种行为— O(s) 对应于以电子方式传输文件的时间复杂度。随着文件大小 s 的增加，完成传输所需的时间也增加(在这个例子中，这种增加是线性的)。另一方面， O(1) 对应于物理传送文件的情况下的时间复杂度，因此时间复杂度是恒定的。

时间(和空间)复杂性的渐近分析—来源:作者(源代码复制它)

大 O vs 大 Theta vs 大 Omega

大 O 符号用于描述算法复杂度的一个上限。假设我们有一个 N 个整数的列表(或数组)。如果我们想打印出列表中的每个元素，时间复杂度是 O(N)。虽然从理论上讲，这个用例的时间复杂度也可以描述为 O(N)或 O(N)或任何其他大于 O(N)的值，因为这些是上限。

这可能有点令人困惑，所以让我们考虑一个现实生活中的例子。我们来做一个假设，没有一辆车可以超过 400 km/h 的速度，如果我们有一辆车的最大速度是 X，那么我们当然可以说 X ≤ 400。虽然从理论上讲，我们也可以说 X≤1000 或 X≤10000。从技术上讲，这是正确的，因为我们使用上限，即使进一步扩展上限并不十分有用。

然而，除了大 O 之外，还有两种替代符号，即大ω(ω)和大θ(θ)。

大ω用来形容下界*。回到我们打印所有列表元素的例子，下限将是ω(N)，因为我们知道它不会比这个更快。同样，我们也可以说下限是ω(1)或ω(logN)，因为打印一个包含 N 个元素的列表不会比这些下限更快。*

大θ用于描述紧界*。这意味着如果一个算法同时是 O(N) 和ω(N)，那么这个算法可以描述为θ(N)。我们可以说打印一个有 N 个元素的数组是θ(N)。*

一般来说，我们通常使用大 O 符号来描述算法的时间和空间复杂性，同时总是试图定义尽可能紧密的运行时，给定特定算法和/或用例的细节。

最佳情况对最差情况对预期情况

各种算法都包含某种形式的随机性，这可能会影响算法的性能。也有一些算法在排序的数组上运行得更快，但是当数组的元素没有排序时运行得更慢。

因此，实际上有三种不同的方式来描述算法的运行时间；最好的情况，预期的情况和最坏的情况。当我们评估算法的性能时，应该计算最坏情况的复杂度。

请注意，这些概念不应与我们之前讨论的大θ和大ω相混淆。下限和上限与最佳、最差和预期情况无关。

空间复杂性

除了时间复杂度之外，另一个需要评估的重要方面是空间复杂度，即算法执行所需的内存量。随着计算机能力的不断发展，空间复杂性通常会被程序员忽略。然而，考虑到正在处理的数据也在不断发展，以消耗尽可能少的内存的方式设计和实现算法是非常重要的。

进入空间复杂度的实际计算，如果我们要创建一个 N 个整数的一维数组，那么就需要 O(n) 空间。同样，一个大小为 n x n 的二维数组需要 O(n)个空间。这里还必须提到，除了数据结构中元素占用的空间之外，在递归调用中分配给堆栈的空间也应该考虑在内。

用大 O 符号计算空间复杂度

作为一个例子，让我们考虑下面的递归函数，它用于计算 0 和n之间的数字之和:

*def sum_func(n: int):
    """ 
    Recursive method that returns the sum 
    of the numbers between 0 and input n
    """
    if n > 0:
        return sum_func(n - 1) + n return 0*

尽管函数的输入只是一个整数，但每次递归调用都会在调用堆栈中增加一个级别。举个例子，

*sum_func(5)
    adds call sum_func(4) to stack
        adds call sum_func(3) to stack
            adds call sum_func(2) to stack
                adds call sum_func(1) to stack
                    adds call  sum_func(0) to stack*

实际上，添加到调用堆栈中的每个调用都会消耗实际内存，因此在计算空间复杂度时，应该始终将它们考虑在内。因此，函数sum_func将需要 O(n)时间和 O(n)空间。

拥有 n 个调用，并不一定意味着一个算法需要 O(n) 空间。现在让我们修改一下我们之前使用的递归方法，这样 0 和输入数n之间的和的计算是以迭代的方式进行的。

*def sum_func(n: int):
    """ 
    Iterative method that returns the sum 
    of the numbers between 0 and input n
    """
    sum = 0
    for i in range(n+1):
        sum = sum_nums(sum, i)
    return sum def sum_nums(a: int, b:int):
    """
    Returns the sum of two numbers
    """
    return a + b*

上述函数将花费 O(n)时间和 O(1)空间。换句话说，执行功能sum_func所需的内存是恒定的。

用大 O 符号计算时间复杂度

现在回到时间复杂性，重要的是要强调大 O 符号与所讨论算法的实际执行时间并不对应的事实。例如，O(n)的算法实际上可能比 O(1)的算法更快。因此，我们可以说大 O 用于描述相对于输入大小的增长率。

这就是我们在计算时间复杂度时，并不真正关注常数的主要原因。在最开始，我们讨论了数学背景下的渐近分析。

如果 f (n) = n⁴ + 4n + 10 并且数字 n 非常大，那么术语 4n 与术语相比将无足轻重，而 n 对常数 10 没有影响。因此，当 n 趋于无穷大时，函数 f(n) 被称为渐近等价于 n⁴ 。**

类似地，在算法渐近分析中，我们丢弃任何常量值以及无关紧要的项。

作为一个例子，让我们考虑一个算法的两个版本，它从一个输入列表中计算最小和最大数字。注意，可能有更好的方法来执行相同的操作，但是这个例子的目的是演示一些与 Big-O 符号相关的概念。

**def get_min_max(lst):
    """
    Returns the minimum and maximum 
    numbers from the input list as a 
    tuple in the form (min, max)
    """
    _min = lst[0]
    _max = lst[0] for n in lst[1:]:
        if n > _max:
            _max = n
        if n < _min:
            _min = n return _min, _max**

因为我们有一个遍历输入列表元素的 for 循环，所以上面函数的时间复杂度可以用 O(n) 来描述。

现在让我们修改这个方法，使最小和最大数量的计算发生在单独的循环中。

**def get_min_max(lst):
    """
    Returns the minimum and maximum 
    numbers from the input list as a 
    tuple in the form (min, max)
    """
    _min = lst[0]
    _max = lst[0] for n in lst[1:]:
        if n > _max:
            _max = n for n in lst[1:]:
        if n < _min:
            _min = n return _min, _max**

现在我们有两个独立的(虽然不是嵌套的！)for 循环，每个循环的执行时间为 O(n)。有人可能会争辩说，这被翻译成 O(n + n)，因此 O(2n)。回想一下，当用 Big-O 符号描述时间复杂性时，我们必须消除任何常量和/或无关紧要的项。因此，我们的示例算法的第二个版本的复杂度仍然是 O(n ),因为我们只对增长率感兴趣。

让我们考虑另一个例子，其中一个函数接受一个输入列表，并打印出原始元素和平方元素(我再次警告您，有更好的方法来实现这一点，所以请不要太关注逻辑)。

**def print_squares(lst):
    for a in lst: 
        print(a) for a in lst:
        for b in lst:
            print(a * b)**

所以我们有一个 for 循环，它简单地遍历输入列表的元素，并打印出每一个元素，然后我们有两个嵌套循环。

前一个表达式需要 O(n)时间，后一个表达式由于两个嵌套循环需要 O(n)时间。同样，有人会认为时间复杂度是 O(n + n ),但鉴于我们只对增长率感兴趣，我们必须去掉任何无关紧要的项，因此我们最终的时间复杂度是 O(n)。

增长率

下面列出了大多数时候用来描述算法的时间和空间复杂性的标准增长率。

对数: O(log n)
线性: O(n)
线性算法: O(n log n)
二次: O(n )
指数: O(c^n) 其中 c 是固定值，而 c > 1
阶乘: O(n！)

最后的想法

在今天的文章中，我们讨论了在开发算法时评估时间和空间复杂度的重要性。这可以通过渐近分析来实现，这可以帮助我们使用大 O 符号来描述性能。

此外，我们讨论了带有大ω和大θ的大 O 符号之间的区别，以及在描述算法复杂性时最好、最坏和预期情况的含义。为了演示如何计算时间和空间复杂度，我们还使用了一些示例算法。最后，我们快速浏览了一下最常用的增长率，当涉及到算法的计算空间和时间复杂度时，这些增长率通常涵盖了大多数情况。

算法中的渐近分析是一个基本且非常重要的话题，每个写代码的人都必须知道。通过理解某些决策如何影响时间和空间复杂性，您最终可以提高代码的质量和性能。此外，如果你想搞定你的下一次面试，那么这是一个你必须仔细修改的话题。有可能你会被要求开发一个算法，而时间和空间复杂度是你在开发时需要考虑的概念。即使您无法实现给定问题的最佳解决方案，您至少应该知道您的解决方案如何执行，以及如何修改它以达到最佳的复杂性时间。

成为会员 阅读介质上的每一个故事。你的会员费直接支持我和你看的其他作家。你也可以在媒体上看到所有的故事。

**https://gmyrianthous.medium.com/membership **

相关文章你可能也喜欢

** ** ** ** ** **

BigQuery 的 SQL 反模式

原文：https://towardsdatascience.com/bigquery-anti-patterns-dacb61f8a3f

在 Google Cloud BigQuery 上运行 SQL 的最佳实践和需要避免的事情

杰克·卡特在 Unsplash 上拍照

BigQuery 是谷歌云平台上的托管数据仓库服务，像大多数服务和技术一样，它有一套使用时需要牢记的原则。

在接下来的几节中，我们将概述一组最佳实践，以避免通常会对 BigQuery 性能产生负面影响的常见反模式。应用最佳实践很重要，主要有两个原因——它们将帮助您编写更高效的查询,同时，如果应用正确，将降低您的成本。

避免选择*

从结果集中选择所有字段是一种非常常见的反模式，应该尽可能避免。SELECT *将导致对表中的每一列进行完全扫描，这意味着这将是一个执行开销很大的操作。

仅查询您需要的列

还要记住LIMIT不会减少读取的字节量，因此，您仍然需要为每一列的完全扫描付费。因此，请确保只查询您实际需要的列。如果您仍然需要运行SELECT *,那么考虑对您的表进行分区，这样您将能够查询驻留在一个或一些分区中的数据。

避免自连接

在表上执行自连接是另一件应该避免的事情。自然有人会问两个独立表的连接和自连接有什么区别。

答案是否定的——这几乎是一回事，但这里的要点是，无论何时您要执行自连接，都有可能使用窗口函数来实现相同的结果，这是一种更优雅的方式。

避免自连接，而使用窗口函数

自联接可能会增加输出行数，这意味着它会降低查询性能，还会导致处理的字节数增加，从而增加运行此类查询的成本。

处理数据偏斜

数据偏斜是当您的数据被划分为大小不均匀的分区时出现的现象。在后台，BigQuery 会将这些分区发送到插槽中，这些插槽是用于以分布式方式执行 SQL 查询的虚拟 CPU。

因此，分区不能跨不同的插槽共享。如果您创建了不平衡的分区，这意味着一些插槽最终会比其他插槽有更多的工作负载，而在某些极端情况下，过大的分区甚至会使插槽崩溃。

当您基于包含比其他值更频繁出现的值的键/列对表进行分区时，您很可能会得到大小不等的分区。在这种情况下，尽早应用过滤器将有助于缩小这种不平衡。

如果你的数据有偏差，尽早应用过滤

此外，您可能还需要重新考虑分区键。例如，您可能希望避免使用具有许多NULL值的键对表进行分区，因为这将为此类行创建一个巨大的分区。一个常用的分区键是一个日期字段，它可以确保数据在不同分区上的均匀分布(假设每天/每月/每年的数据量大致相同)。

交叉连接

交叉连接用于生成两个表之间的笛卡尔积，即包含相关表记录之间所有可能组合的结果。更简单地说，第一个表中的每一行都将被连接到第二个表中的每一行，这意味着在最坏的情况下，我们将得到由 M×N 行组成的结果，其中 M 和 N 分别是表的大小。

避免执行会导致输出多于输入的连接

因此，这意味着交叉连接通常会返回比输入更多的输出行，这是我们通常想要避免的。作为一名总顾问，在这种情况下，您应该考虑两种可能的解决方法:

评估窗口函数(比交叉连接更有效)是否能帮助您获得想要的结果
在加入之前，使用GROUP BY执行预聚合

比起分片，更喜欢表分区

表分片是一种将数据存储到多个不同表中的方法，使用一个命名前缀，比如[PREFIX]_YYYYMMDD。许多用户会认为上述技术与分区相同，但实际上并非如此。

表分片要求 BigQuery 维护每个表的元数据和模式，此外，无论何时执行操作，平台都必须验证所有单个表的权限，这会对性能产生重大影响。

表分区比表分片更有效

一般来说，表分区的性能更好，因此您应该首选它们而不是分片表。此外，在过滤和降低成本方面，分区表更容易处理。

不要将 BigQuery 视为 OLTP 系统

像大多数数据仓库解决方案一样，BigQuery 也是一个 OLAP(在线分析处理)系统。这意味着在使用表扫描处理海量数据时，它的设计是高效的。因此，BigQuery 上的 DML 语句不应该用于执行批量更新。

BigQuery 是一个 OLAP 系统，需要如此对待

使用 DML 语句执行模块化更改意味着您试图将 BigQuery 视为 OLTP(在线事务处理)系统。如果是这样的话，你应该重新考虑你的设计，甚至是你正在使用的工具。有可能 OLTP 系统(比如 Google 云平台上的 CloudSQL)更合适。或者，如果您的设计涉及常规模块化插件，您可以考虑其他技术，如流技术。

关于 OLAP 和 OLTP 系统之间的主要区别的更多细节，您可以阅读我最近的一篇文章。

最后的想法

在 BigQuery 中应用最佳实践并避免常见的反模式非常重要，因为这些原则将帮助您提高系统的性能并降低成本。

总结一下，

避免使用SELECT *，取而代之的是，确保你只查询你需要的字段
尽可能选择窗口函数而不是自连接(例如，如果您需要计算的是行相关的)
明智地选择分区键，以避免数据偏斜。如果不可能，请确保尽早应用过滤器
避免产生输出多于输入的连接
比起表分片，我更喜欢表分区，因为前者效率更高，成本更低
避免模块化的 DML 语句——big query 是一个 OLAP 系统，需要这样对待

成为会员 阅读介质上的每一个故事。你的会员费直接支持我和你看的其他作家。你也可以在媒体上看到所有的故事。

https://gmyrianthous.medium.com/membership

相关文章您可能也喜欢

</2-rules-groupby-sql-6ff20b22fd2c>

通过使用数组和结构在 BigQuery 中节省时间和金钱

原文：https://towardsdatascience.com/bigquery-efficiency-how-i-reduced-my-table-size-by-35-5-and-rows-by-93-1-dc8b9b7276ff

学会接受和理解嵌套模式。

在 Unsplash 上由Towfiqu barb huya拍摄的照片

尽管数组和结构会增加查询的复杂性，但是一旦理解了它们的工作原理，就可以获得嵌套数据结构的好处。

为了让你了解这种改变有多大的好处，下面展示了我通过将一个 Google Clouds 公共数据集从典型的非规范化格式转换为嵌套格式而获得的节省。

我已经能够将行数减少 93.1%，将表的大小减少 35.5%

以下是我们将在本文中涉及的内容:

什么是结构，它是如何工作的？
什么是数组，它是如何工作的？
如何结合使用数组和结构数据类型来降低查询和表存储成本？
最后，我们将通过几个测试练习来演示如何查询嵌套数据，同时深入了解与原始非规范化表相比的性能差异

Maksym Kaharlytskyi 在 Unsplash 上拍摄的照片

结构体

STRUCT 是结构的简称，在 BigQuery 中可以使用 STRUCT 数据类型将多个字段放在一个名称下。帮助我理解这个概念的是想象你正在给一组列分配一个类别。

让我们看一个例子。假设我们有一个包含学生数据的表。

SELECT 
193348009 as Student_ID,
"Toby Lerone" AS Student_Name,
"Year 11" as Year_Group,
"Group 5A" as Class_Group,
"Mr Brightside" as Year_Teacher,
"Maths" AS Subject,
73 AS Grade,
DATE("2022-11-01") AS Exam_Date

要创建一个结构，我们首先需要决定每个结构中应该包含哪些字段。让我们在这个例子中尝试两个结构；细节和结果。

创建这个结构很简单。简单地列出你想要在结构中包含的字段，把它们添加到括号(每个字段必须用逗号分开)。

STRUCT(FIELD1, FIELD2, FIELD3) AS NEW_STRUCT

让我们创建两个新的结构，一个用于细节，另一个用于结果。

SELECT
193348009 as Student_ID,

STRUCT
  (
    "Toby Lerone" AS Student_Name,
    "Year 11" as Year_Group,
    "Group 5A" as Class_Group,
    "Mr Brightside" as Year_Teacher
  ) AS Details,

STRUCT
  (
    "Maths" AS Subject,
    73 AS Grade,
    DATE("2022-11-01") AS Exam_Date
  ) AS Results

我在上面缩进了我的结构，但这不是语法要求，我这样做只是为了可读性。如果你愿意，你可以把整个结构放在一行中。

结果与我们之前看到的没有太大的不同，只是我们现在为每个字段头添加了一个前缀。

这告诉我们,学生姓名，年组，班级组和年教师在细节结构中。而科目、成绩和考试日期字段包含在成绩结构中。

如果我们将这些结果保存为一个表，我们的模式将如下所示。请注意，我们有了一个新的数据类型“RECORD ”,它现在出现在我们前面定义的两个结构中。

查询结构就像创建结构一样简单。与您通常选择字段的方式相比，您只需要做一处更改—您必须为字段名称添加前缀。

SELECT 
Student_ID,
Details.Year_Teacher,
Results.Subject,
Results.Grade,
Results.Exam_Date
FROM Student_Data

关于结构数据类型的官方文档可以在这里找到。

照片由凯利·麦克林托克在 Unsplash 上拍摄

排列

数组是存在于相同单元格中的值的列表，这些值也是相同的数据类型。这是结构和数组之间的一个重要区别。结构可以包含各种数据类型，而数组只能包含一种数据类型。

有几种方法可以在 BigQuery 中创建数组，我将在本文中介绍其中的两种方法(有帮助的文档 如果你想进一步探索的话，这里有)。

创建带方括号的数组

创建数组就像创建结构一样简单。您必须将值放在方括号内，并且每个值必须用逗号分隔。

SELECT ["Chris Packet","Liz Anya","Hugh Dunnit"] as Attendees

正如您在上面看到的，我们的数组中有三个参与者，但是需要注意的是这三个值都包含在一行中。

这是导致本文开头提到的存储和查询成本节省的关键部分，因为即使在这个简单的例子中，我们也已经将表的大小从 3 行减少到 1 行。

使用 ARRAY_AGG()创建数组

函数将一组值放在一起，并将它们连接成一个数组。我们将在我们之前创建的结构字段上使用这个函数，这将为我们提供一个嵌套表(一个结构数组)。

我已经扩展了前面的学生数据，增加了几行。请注意，我们之前定义的结构仍然存在，现在我们的数据集中有两个学生，每个学生有 3 个科目。

SELECT
Student_ID,
ARRAY_AGG(Details) as Details,
ARRAY_AGG(Results) as Results
FROM STUDENT_DATA
GROUP BY Student_ID

顾名思义，ARRAY_AGG 是一个聚合函数，所以我们必须在这里包含 group by 子句，它将根据 Student_ID 字段对我们的结构进行分组。

在 ARRAY_AGG 函数中，我们只需要指定结构的名称。我们不需要单独列出每个字段，因为它们已经包含在我们的结构中了。

运行这个查询向我们展示了熟悉的结果。请注意，尽管显示了 6 行数据，我们只有 2 行数据。这要归功于 array_agg 函数，该函数将结构中的字段提取到一个数组中，用于每个唯一的 Student_ID。

将结果导出到电子表格中会让您对 BigQuery 如何在幕后存储这些数据有所了解。

在 Unsplash 上由 Waldemar Brandt 拍照

大规模应用这些技术

在介绍了结构和数组的理论和实践之后，让我们回到本文的主题。如何使用这两种方法来节省存储和查询成本呢？

首先，让我们看看原始数据集。我在这个例子中使用的是 BigQuery 中一个名为 Chicago taxi trips 的公共数据集。

FROM `bigquery-public-data.chicago_taxi_trips.taxi_trips`

下面是该模式的屏幕截图。它包含 23 列，2 . 03 亿行，占用了 74GB 的 Google Clouds 存储空间。

前面我们介绍了结构以及如何将你的字段分成不同的类别。让我们再次做同样的事情，这次将数据集分成 3 个结构:Details、Payment 和 Geographic。

当你有一个超过 15 个字段的表格时，如果你需要来回滑动来检查你需要使用的字段，那么使用它会变得很累(并且容易出错)。在表中有明确定义的结构有助于为字段添加上下文，如果任何字段碰巧有相似的名称，这尤其有用。

BigQuery 有一个方便的辅助特性，它在处理结构时非常有用，允许您查看结构中存在的所有字段，而无需检查表模式本身。

让我们使用数组和结构的组合将原始表转换成嵌套版本。

由于数据是公开的，下面的查询也适用于您。只需修改查询顶部的表路径，但要确保您的数据集位置设置为 US，以匹配原始数据集

create or replace table 
`spreadsheep-20220603.Dashboard_Datasets.taxi_trips_new` 
as (
SELECT 
company, 
taxi_id,
extract(date from trip_start_timestamp) as pickup_date,
#####STRUCT ONE#####
array_agg
(
  struct
  (
    unique_key,
    trip_start_timestamp as start_timestamp,
    trip_end_timestamp as end_timestamp,
    trip_seconds as seconds,
    trip_miles as miles,
    pickup_census_tract, 
    dropoff_census_tract, 
    pickup_community_area, 
    dropoff_community_area
  )
) as details,
#####STRUCT TWO#####
array_agg
(
  struct
  (
    fare,
    tips,
    tolls,
    extras,
    trip_total,
    payment_type
  )
) as payment,
#####STRUCT THREE#####
array_agg
(
  struct
  (
pickup_latitude, 
pickup_longitude, 
pickup_location, 
dropoff_latitude, 
dropoff_longitude,
dropoff_location
  )
) as geographic

FROM `bigquery-public-data.chicago_taxi_trips.taxi_trips` group by 1,2,3)

正如您在上面看到的，我们创建了三个结构，如前面的图表所示，每个结构都包含在 ARRAY_AGG 函数中。

下面是新的模式。我们之前在名称和数据类型方面有相同的字段，但现在它们只是在记录类型字段(这些是我们定义的结构)下有一点不同。

还要注意记录字段的模式显示为重复。这告诉我们这个结构存在于一个数组中。

结果

这将我们带回到了本文开头显示的摘要截屏。我们将表中的行数减少了 93.1%，表的大小减少了 35.5%！

测试

好的，我们可以看到这种方法节省了存储成本，但是查询性能呢？让我们运行几个查询来回答这三个问题:

【2022 年 5 月，多少%的出租车司机给了小费(按公司和整体，按 desc total trips 排序)
【2022 年年初至今(除去顶部和底部 5%的行)每月的平均旅行时长是多少秒
【2022 年 1 月，每家公司的每英里费用是多少(由 desc total trips 订购)

此外，让我们引入一个新的表来模拟另一个比较点的标准化数据集。第三个表是基于与其他两个表相同的数据，我将该表分为两部分，如下所示。

create or replace table 
`spreadsheep-20220603.Dashboard_Datasets.taxi_trips_payment` as 
(
SELECT
unique_key, 
fare, 
tips, 
tolls, 
extras, 
trip_total, 
payment_type
FROM `bigquery-public-data.chicago_taxi_trips.taxi_trips`
);

create or replace table 
`spreadsheep-20220603.Dashboard_Datasets.taxi_trips_main` as 
(
SELECT 
* except 
(
  fare,
  tips, 
  tolls, 
  extras, 
  trip_total, 
  payment_type
)
  FROM `bigquery-public-data.chicago_taxi_trips.taxi_trips`
);

2022 年 5 月打车出行给小费的比例是多少？

/*##################################################################################################*/
--What % of taxi trips in May 2022 gave a tip (by company ordered by total trips by each company total desc)--
/*##################################################################################################*/

--NESTED TABLE--
SELECT
COMPANY,
ROUND(SAFE_DIVIDE(TIPS_MADE,TOTAL_TRIPS_BY_COMPANY)*100,1)||"%" AS PERC_TIPPING,
TIPS_MADE,
TOTAL_TRIPS_BY_COMPANY
FROM
(
  SELECT
  LOWER(COMPANY) as COMPANY,
  COUNT(IF(tips > 0,UNIQUE_KEY,NULL)) as TIPS_MADE,
  COUNT(UNIQUE_KEY) AS TOTAL_TRIPS_BY_COMPANY
  FROM spreadsheep-20220603.Dashboard_Datasets.taxi_trips_new, 
  UNNEST(details) WITH OFFSET pos1, 
  UNNEST(payment) WITH OFFSET pos2
  WHERE DATE_TRUNC(start_timestamp,MONTH) = "2022-05-01" 
  AND pos1 = pos2
  GROUP BY COMPANY
)
ORDER BY TOTAL_TRIPS_BY_COMPANY DESC;

--ORIGINAL TABLE--
SELECT
COMPANY,
ROUND(SAFE_DIVIDE(TIPS_MADE,TOTAL_TRIPS_BY_COMPANY)*100,1)||"%" AS PERC_TIPPING,
TIPS_MADE,
TOTAL_TRIPS_BY_COMPANY
FROM
(
  SELECT
  LOWER(COMPANY) as COMPANY,
  COUNT(IF(tips > 0,UNIQUE_KEY,NULL)) as TIPS_MADE,
  COUNT(UNIQUE_KEY) AS TOTAL_TRIPS_BY_COMPANY
  FROM spreadsheep-20220603.Dashboard_Datasets.taxi_trips_original 
  WHERE DATE_TRUNC(trip_start_timestamp,MONTH) = "2022-05-01"
  GROUP BY COMPANY
)
  ORDER BY TOTAL_TRIPS_BY_COMPANY DESC;

--SPLIT TABLE--
SELECT
COMPANY,
ROUND(SAFE_DIVIDE(TIPS_MADE,TOTAL_TRIPS_BY_COMPANY)*100,1)||"%" AS PERC_TIPPING,
TIPS_MADE,
TOTAL_TRIPS_BY_COMPANY
FROM
(
  SELECT
  LOWER(COMPANY) as COMPANY,
  COUNT(IF(tips > 0,MAIN.UNIQUE_KEY,NULL)) as TIPS_MADE,
  COUNT(MAIN.UNIQUE_KEY) AS TOTAL_TRIPS_BY_COMPANY
  FROM spreadsheep-20220603.Dashboard_Datasets.taxi_trips_main AS MAIN
  INNER JOIN spreadsheep-20220603.Dashboard_Datasets.taxi_trips_payment AS PAYMENT
  ON MAIN.UNIQUE_KEY = PAYMENT.UNIQUE_KEY
  WHERE DATE_TRUNC(trip_start_timestamp,MONTH) = "2022-05-01"
  GROUP BY COMPANY
)
  ORDER BY TOTAL_TRIPS_BY_COMPANY DESC;

在这个练习中，我们的嵌套表是最重要的。查询持续时间与原始表相当，但使用的计算能力和处理的数据更少。

对于那些不熟悉数组的人，请密切注意我在这个例子中是如何取消嵌套多个数组的。如果去掉带有偏移的部分，那么由于双重不嵌套，最终会得到重复的结果。为了防止这种情况发生，我在 WHERE 子句中设置了一个条件，即两个数组的数组偏移量必须相等。

关于带偏移的的更多细节可以在这里找到，或者在本文中提出你的问题，我会尽快回复你。

2022 年年初至今每月的平均旅行时长是多少秒？

/*##################################################################################################*/
--What is the average trip duration in seconds by month for 2022 YTD--
/*##################################################################################################*/

--NESTED TABLE--
SELECT
date_trunc(CAST(start_timestamp AS DATE),month) as month,
AVG(SECONDS) as avg_seconds
FROM
(
  SELECT
  start_timestamp,
  seconds
  FROM spreadsheep-20220603.Dashboard_Datasets.taxi_trips_new, UNNEST(details)
  WHERE EXTRACT(YEAR FROM start_timestamp) = 2022
  QUALIFY 
  seconds BETWEEN 
    PERCENTILE_CONT(seconds,0.05) over () 
    AND 
    PERCENTILE_CONT(seconds,0.95) over ()
)
GROUP BY MONTH
ORDER BY MONTH DESC;

--ORIGINAL TABLE--
SELECT
date_trunc(CAST(trip_start_timestamp AS DATE),month) as month,
AVG(trip_seconds) as avg_seconds
FROM
(
SELECT
trip_start_timestamp,
trip_seconds
FROM spreadsheep-20220603.Dashboard_Datasets.taxi_trips_original
WHERE EXTRACT(YEAR FROM trip_start_timestamp) = 2022
  QUALIFY 
  trip_seconds BETWEEN 
    PERCENTILE_CONT(trip_seconds,0.05) over () 
    AND 
    PERCENTILE_CONT(trip_seconds,0.95) over ()
)
GROUP BY MONTH
ORDER BY MONTH DESC;

--SPLIT TABLE--
SELECT
date_trunc(CAST(trip_start_timestamp AS DATE),month) as month,
AVG(trip_seconds) as avg_seconds
FROM
(
SELECT
trip_start_timestamp,
trip_seconds
FROM spreadsheep-20220603.Dashboard_Datasets.taxi_trips_main AS MAIN
INNER JOIN spreadsheep-20220603.Dashboard_Datasets.taxi_trips_payment as PAYMENT
ON MAIN.UNIQUE_KEY = PAYMENT.UNIQUE_KEY
WHERE EXTRACT(YEAR FROM trip_start_timestamp) = 2022
  QUALIFY 
  trip_seconds BETWEEN 
    PERCENTILE_CONT(trip_seconds,0.05) over () 
    AND 
    PERCENTILE_CONT(trip_seconds,0.95) over ()
)
GROUP BY MONTH
ORDER BY MONTH DESC;

我在这些查询中添加了两个 window 语句，看看它们是否在这些表之间造成了任何明显的差异。window 语句删除底部和顶部 5%的行。

令人惊讶的是，原始表和嵌套表表现出几乎相同的性能，尽管嵌套表花费的计算时间稍多一些。

2022 年 1 月，每家公司的每英里费用是多少？

/*##################################################################################################*/
--What was the £ per mile for each company in January 2022 (ordered by total trips desc)--
/*##################################################################################################*/

--NESTED TABLE--
SELECT
COMPANY,
COUNT(unique_key) AS TOTAL_TRIPS,
SUM(TRIP_TOTAL)/SUM(MILES) AS DOLLAR_PER_MILE
FROM spreadsheep-20220603.Dashboard_Datasets.taxi_trips_new, 
UNNEST(details) WITH OFFSET pos1, 
UNNEST(payment) WITH OFFSET pos2
WHERE DATE_TRUNC(start_timestamp,MONTH) = "2022-01-01" 
AND POS1 = POS2
GROUP BY COMPANY
ORDER BY TOTAL_TRIPS DESC;

--ORIGINAL TABLE--
SELECT
COMPANY,
COUNT(unique_key) AS TOTAL_TRIPS,
SUM(TRIP_TOTAL)/SUM(TRIP_MILES) AS DOLLAR_PER_MILE
FROM spreadsheep-20220603.Dashboard_Datasets.taxi_trips_original
WHERE DATE_TRUNC(trip_start_timestamp,MONTH) = "2022-01-01"
GROUP BY COMPANY
ORDER BY TOTAL_TRIPS DESC;

--SPLIT TABLE--
SELECT
COMPANY,
COUNT(MAIN.unique_key) AS TOTAL_TRIPS,
SUM(TRIP_TOTAL)/SUM(TRIP_MILES) AS DOLLAR_PER_MILE
FROM spreadsheep-20220603.Dashboard_Datasets.taxi_trips_main AS MAIN
INNER JOIN spreadsheep-20220603.Dashboard_Datasets.taxi_trips_payment AS PAYMENT
on MAIN.UNIQUE_KEY = PAYMENT.UNIQUE_KEY
WHERE DATE_TRUNC(trip_start_timestamp,MONTH) = "2022-01-01"
GROUP BY COMPANY
ORDER BY TOTAL_TRIPS DESC;

原始表和嵌套表的性能相似，但是嵌套表确实名列前茅，因为处理的数据量较少。

在 Unsplash 上由 Aron 视觉拍摄的照片

关键要点

您是否使用基于事件的大型表，其中包含每个唯一用户/id 的大量事件？那么嵌套版本的表可以很容易地为您节省未来的时间和金钱
如果您打算像我在本文中所做的那样，从非规范化模式切换到嵌套模式，请注意，您的任何预定或保存的查询都需要更新，以处理新的嵌套模式
当您取消嵌套多个数组时，确保您为每个 unnest 使用 WITH OFFSET，并在 WHERE 子句中设置标准以防止重复行(参见第一和第三个测试的示例)
尽管由于需要取消嵌套数组，您在嵌套表上的查询可能会更复杂，但与非规范化表相比，您可以期待更便宜(有时更快)的查询
如果您使用标准化的数据(即在查询中将多个表连接在一起)并定期查询相同的表(例如每周报告)，那么我强烈建议您花时间创建所使用的表的嵌套版本

如果您的表比较小，比如说小于 10GB，那么嵌套表的好处就变得不那么显著，增加的复杂性也不值得权衡。

这篇文章到此结束。如果有什么建议或推荐，欢迎随时留言评论。我很乐意看到它。

我经常为 BigQuery 和/或 Data Studio 撰写文章。如果你感兴趣，可以考虑在 medium 上关注我。

除非另有说明，所有图片均为作者所有。

留在上等的乡亲们！
汤姆汤姆

用于数据清理的 BigQuery SQL 函数

原文：https://towardsdatascience.com/bigquery-functions-for-data-cleaning-4b96181fbc3

要应用的用例及功能

图片来自Rosy——世界值成千上万张图片来自 Pixabay

无论您是数据工程师、数据科学家还是数据分析师，数据清理都是任何数据相关职位的重要组成部分。今天，我想分享几个用于数据清理的 BigQuery SQL 函数，以及我会使用它们的一个用例。

字符串值中不可见的特殊字符

字符串值可以包含不显示在屏幕上但存储在数据库中的特殊字符。当我在一个字符串字段上应用 where 子句导致找到 0 条记录时，我经历了惨痛的教训。这非常令人沮丧，在应用 where 子句返回我知道存在的记录之前，我必须找到函数来公开 unicode 值，以便将它们从字符串中移除。

BigQuery 有一个 NORMALIZE 函数来处理这个场景。下面是 Jane 和 Smith 之间 unicode 值的 3 条记录，它们在查询结果中不可见。

作者创建的屏幕截图示例

如果我对 、简·史密斯 使用 where 子句，则不会返回任何记录。

作者创建的屏幕截图示例

但是，如果我对 name 字段使用 NORMALIZE 函数，unicode 值将被删除，查询结果中将返回三个简·史密斯记录。

使用作者创建的规格化函数的屏幕截图示例

特别提示 :如果您希望字符串比较不区分大小写，即在查询结果中返回包含简·史密斯或简·史密斯的记录，BigQuery 还有一个 NORMALIZE_AND_CASEFOLD 函数。

模式匹配

我一直使用 LIKE 操作符在字符串字段中进行模式匹配。最近，我不得不将网站访问者的引用 URL进行分类，以匹配谷歌分析频道报告。因为我不知道 URL 是大写还是小写，所以在检查模式匹配之前，我必须使用 LOWER 函数将字段全部转换为小写。

BigQuery 有一个针对这种情况的 CONTAINS_SUBSTR 函数。CONTAINS_SUBSTR 不仅执行不区分大小写的模式检查，还可以检查数字字段、时间戳和数组中的模式值。

在下面的例子中，我检查了早餐字段是否包含全部小写的字符串煎饼。尽管每条记录在煎饼中有一个大写字母，但在查询结果中会返回这两行。

使用作者创建的 CONTAINS_SUBSTR 函数的屏幕截图示例

特别提到 : BigQuery 还有一个 ENDS_WITH 函数，用来检查一个字符串是否以模式结尾。我可以使用它的一个常见用例是检查电子邮件是否以。edu 确认用户是学生。

日期格式

过去，我总是将 SQL 中的查询结果下载到 Excel 中，以便为报告目的设置日期格式，因为我无法使用 SQL 以我需要的方式设置日期格式。当我有大量数据要格式化时，这非常耗时。

BigQuery 有一个 FORMAT_DATE 函数来处理日期格式化。在下面的示例中，2022 年 9 月 30 日基于格式字符串以三种不同的方式进行格式化。

使用作者创建的 FORMAT_DATE 函数的屏幕截图示例

特别说明 :除了 FORMAT_DATE，还可以使用 FORMAT_DATETIME 来格式化日期时间值。还有一个 FORMAT 函数将字段格式化为字符串值。这个函数的一个用例是用逗号分隔符格式化大数。您可以使用 FORMAT 函数在查询结果中显示 1，000，000，而不是 1000000。

除以一个零分母

我经常不得不计算分母可能为 0 的百分比，这将在除以 0 时返回 SQL 错误。一种选择是使用 CASE 语句在除法之前检查分母是否为 0，以避免错误，但是大多数数据库都有处理这种情况的函数。

在 BigQuery 的例子中，这个函数被称为 SAFE_DIVIDE 。在下面的例子中，我将 10 除以 0，得到一个 除以零 的错误。

作者创建的使用除法错误示例的屏幕截图示例

在我使用 SAFE_DIVIDE 之后，结果是一个空值，而不是一个错误。

作者创建的使用 SAFE_DIVIDE 示例的屏幕截图示例

特别提示 : BigQuery 还有 SAFE_ADD、SAFE_SUBTRACT、SAFE_MULTIPLY、SAFE_NEGATE 函数，如果发生溢出，这些函数将返回空值。

最后的想法

虽然我们永远无法摆脱数据清理，但 SQL 函数可以提供帮助。我希望你学到了一两个将来有用的新功能。虽然我提到的函数在 BigQuery 中，但它们也可能在您的数据库中可用。

注意:以上所有的查询都是在 BigQuery 沙箱 上运行的，这对任何拥有谷歌账户的人来说都是免费的。

你可能也会喜欢…

</6-bigquery-sql-functions-every-user-should-know-9ed97b1cf72e> </4-bigquery-sql-shortcuts-that-can-simplify-your-queries-30f94666a046>

重访 BigQuery 远程函数、云函数 2.0 和 Plus 代码

原文：https://towardsdatascience.com/bigquery-remote-functions-cloud-functions-2-0-and-plus-codes-revisited-7b6308b2bc03

图片来源:安妮·尼加德，Unsplash

几年前，我参加了一个由谷歌主办的会议，发现了加号代码。简而言之，这是一个寻址系统，它生成一个字母数字代码来表示世界上的位置。在许多方面，它比标准地址更准确、更容易访问，而且比精确的坐标位置更容易记忆。许多博客和文章都写了这个话题，，包括我自己写的一篇。如果你不熟悉加号代码和开放位置代码(OLC，生成加号代码的算法),我建议你看一看它是如何工作和如何使用的。从工程角度来看，这很酷，但对于服务水平低下的社区来说，这也非常有影响力。

在那篇文章中，我决定实现 OLC 来学习如何使用 BigQuery 脚本。这是一个如何在 BigQuery 中使用过程化代码的例子，它成功了！从那时起，数据平台，以及总体上的谷歌云，随着许多新特性和功能的加入，已经发生了相当大的变化。引起我注意的两个是 BigQuery 远程函数和云函数第二代。我想亲自动手看看这是如何工作的，有多简单，所以我想为什么不再次使用加号代码来尝试一下呢！

请记住，在撰写本文时，云功能 Gen2 和 BigQuery 远程功能都处于公开预览阶段，这意味着它们包含在预发布条款和条件中。在投入生产之前，情况可能会有所变化。

熟悉 GCF Gen2

使用其他编程语言的好处是 Google 致力于开发并开源了库，为其中的一些库生成了附加代码！在这篇文章中，我们将使用 Python 库。

尝试一下

让我们首先在我们的机器上进行本地测试。事实证明，你可以使用 [pip](https://github.com/google/open-location-code/tree/main/python)非常简单地安装它。使用它只是简单地在一个坐标对上调用encode()函数。

在本地安装 OLC 库，并在交互式终端中运行它。相当简单！

构建功能

我们现在要构建一个 BigQuery 可以调用的函数。从关于远程函数的文档中，这是 BigQuery 将发送的请求的输入格式:

{
 "requestId": "124ab1c",
 "caller": "//bigquery.googleapis.com/projects/myproject/jobs/myproject:US.bquxjob_5b4c112c_17961fafeaf",
 "sessionUser": "[test-user@test-company.com](mailto:test-user@test-company.com)",
 "userDefinedContext": {
  "key1": "value1",
  "key2": "v2"
 },
 "calls": [
  [null, 1, "", "abc"],
  ["abc", "9007199254740993", null, null]
 ]
}

BigQuery 将在查询中接受一个函数调用，并将成批的输入数据发送到calls数组，并将成批的请求发送到云函数。有很多有用的元数据，但我们将重点放在calls上。我们只需要创建一个for循环，遍历输入列表中的每个元素，对它们进行编码以获得 OLC，将它们添加到返回列表中，然后返回该列表。返回值必须是包含所有相应结果数据的 JSON 响应。结果代码如下:

在requirements.txt文件中，您只需要添加openlocationcode到其中，这样库就可以在运行时安装。该文件的一个例子是这里的和。

在这里，您可以按照云控制台中的向导来安装这个功能，或者您可以克隆这个 Github 存储库，我已经为您编写了代码，只需运行以下命令:

gcloud beta functions deploy olc-encode \
--gen2 \
--runtime python39 \
--trigger-http \
--entry-point encode_olc \
--source . \
--region us-central1

它将在整个部署过程中运行，并询问您是否希望允许对该函数进行未经身份验证的调用。我建议选择“否”,因为通常默认情况下不会将其公开。如果你去控制台，你应该看到你闪亮的新功能！

云控制台关于云功能的详细信息页面。

请注意，左上角将显示“第二代”,右上角有一个链接，可将您带到支持此部署的云运行服务的详细信息页面。

翻到 testing 选项卡，它会在页面的右半部分给出一个测试命令的例子。复制并替换数据参数，如下所示:

curl -m 70 -X POST [https://](https://olc-encode-2ev77rzhka-uc.a.run.app)your-cloud-function-endpoint.run.app \
-H "Authorization:bearer $(gcloud auth print-identity-token)" \
-H "Content-Type:application/json" \
-d '{
 "requestId": "124ab1c",
 "caller": "//bigquery.googleapis.com/projects/myproject/jobs/myproject:US.bquxjob_5b4c112c_17961fafeaf",
 "sessionUser": "[test-user@test-company.com](mailto:test-user@test-company.com)",
 "userDefinedContext": {
  "key1": "value1",
  "key2": "v2"
 },
 "calls": [
  [40.74064712923708,-74.00210483032775],
  [37.53900499442756, 126.99583076901393]
 ]
}'

这是为了测试该函数是否能够处理 BigQuery 将要发送的请求格式。在终端中运行它，它应该返回以下加号代码:

向服务发送测试调用。您可以在响应中看到两个加号代码。

仅供参考，这些是纽约市谷歌办公室和首尔君悦酒店的坐标。我们现在看到函数本身是有效的。

在 BigQuery 中使用函数

从这里开始，只需再走两步就能成功。创建一个外部连接，并创建使用该连接的远程函数。

我们要做的第一件事是创建一个存储函数的数据集。通常，如果您有跨数据集使用的函数，以便在一个地方管理它们，这是一个好的做法。在 BigQuery 控制台中运行:

CREATE SCHEMA
  function_library;

然后运行以下命令创建远程连接:

bq mk \
--connection \
--display_name='remote connections' \
--connection_type=CLOUD_RESOURCE \
--project_id=$(gcloud config get-value project) \
--location=US rc-olc

如果刷新 BigQuery UI，现在应该可以看到连接。

新建立的远程连接的详细信息。

这个连接将附带一个服务帐户，BigQuery 将使用这个帐户来发布对云函数的调用。为此，您需要向该帐户授予[roles/cloudfunctions.invoker](https://cloud.google.com/functions/docs/reference/iam/roles)角色。

如果您在命令行中运行以下命令，您将获得包含服务帐户地址的输出。

bq show --location=US --connection rc-olc

您可以在云控制台中手动授予该角色，或者您可以发出以下命令来动态生成授予该角色所需的信息。

在 BigQuery 中，通过发出以下 SQL 语句，使用该连接创建一个远程函数:

CREATE FUNCTION
  function_library.olc_encode(latitude FLOAT64, longitude FLOAT64) RETURNS STRING
REMOTE WITH CONNECTION `[PROJECT ID].us.rc-olc`
OPTIONS (endpoint = '[https://ENDPOINT-URL'](https://ENDPOINT-URL'))

用您的项目 ID 和端点 URL 替换它。您可以在云控制台详细信息页面上获取该函数的 URI，也可以运行以下命令:

gcloud beta functions describe olc-encode --gen2 --region=us-central1 --format=json | jq -r '.serviceConfig.uri'

在 BigQuery 控制台中创建远程函数。

从这里开始，尝试运行SELECT function_library.olc_encode(40.74064712923708, -74.00201483032775)来验证连接正在工作。

对新功能进行快速测试。

注意:我注意到有时候在这个时候，你可能会碰到一个 403 错误。我不确定为什么会发生这种情况，但我发现手动进入控制台中的 IAM 页面，删除并重新创建 *cloudrun.invoker* 的 IAM 绑定似乎可以做到这一点。它说传播延迟可能需要 60 秒，但我不得不等待大约 10 分钟才能工作。你的经历可能有所不同，但我把这归功于 GA 前的小精灵。

让我们试着使用一个表，并给它输入更多的值。我们将使用 FAA BigQuery 机场公共数据集进行尝试。运行以下查询:

SELECT
  function_library.olc_encode(latitude,
    longitude) as plus_code,
  *
FROM
  `bigquery-public-data.faa.us_airports`

所有的加号代码！

这就是在 Cloud Functions 2.0 中使用 Python 作为 BigQuery 的远程函数调用的快速示例，同时使 Plus 代码更容易批量编码！希望这有所帮助，查询愉快！

BigQuery SQL:带有缺失日期的数据集上运行总数的演变

原文：https://towardsdatascience.com/bigquery-sql-evolution-of-the-running-total-on-a-dataset-with-missing-dates-44b6d22f7d20

用 BigQuery SQL 处理缺失值、窗口函数和嵌套查询

托德·迪默在 Unsplash 上拍摄的照片

我们的数据和分析团队最近收到了一个问题:“今年迄今为止，每家商店列出的商品数量是多少，这个数字是如何演变的？”

找到今年迄今为止列出的文章总数并不是一项复杂的分析任务。然而，当我们想展示这个数字是如何随着时间的推移而增加时，问题就出现了。

原因是源数据集中的缺少值。换句话说，在保存每个特定商店新列出的商品条目的数据集中，我们没有每个日期的记录。****

这是挑战开始的地方。

首先，我们需要弄清楚如何为每个商店填充缺失的日期。在此步骤之后，需要对每个日期和商店组合的缺失值进行正向填充。最后，作为最后一步，必须计算运行总数。

在花了一些时间研究和挖掘 BigQuery SQL 教程之后，我们找到了一个简单的解决方案。

现在，我们将与您分享我们的实施方法。

如果您使用 BigQuery ，解决方案是几个步骤，或者更好地说是几个嵌套查询。😃

问题解释:从源到目标

让我们以视觉形式呈现问题，即源数据看起来如何，预期结果是什么。

对于图形表示，我们使用 Looker 在时序图上显示源记录和目标结果的样本。

源数据集中记录的时间序列表示和预期结果[图片由作者提供]

从上图的第一部分(源数据集)可以看出，在所选的日期范围内，我们遗漏了每个商店级别的日期和相应的数值。

因此，我们将我们的解决方案分为三个步骤来实现目标结果，并计算在article_online_since_date日期和每个分区shop的度量new_article_count的运行总数。

自下而上的实现方法

首先，通过以下查询，我们能够创建虚拟输入数据集:

查询的结果是:

有了输入表ListedArticlesPerShop，我们就可以开始研究自下而上的解决方案来计算每个商店一段时间内的运行总数。

步骤#1:填写每个分区(车间)缺少的日期范围

BigQuery SQL 提供了一个简洁的数组函数 GENERATE_DATE_ARAY，您可以在其中指定以下输入[1]:

start_date —必须是日期
end_date —必须是日期
INT64_expr —确定用于生成日期的增量的参数；该参数的默认值是一天
date_part —必须是日、周、月、季或年。

通过GENERATE_ARRAY功能，我们能够创建一个包含每个商店完整日期范围的表格:

查询的结果如下:

成功完成步骤#1 后，我们现在可以将新创建的查询连接到输入表ListedArticlesPerShop。

步骤#2:将填充了日期范围的表连接到缺少日期范围的输入表

这一步很简单，因为任务是:

使用**LEFT JOIN**类型连接两个表，和
从每个表中选择相应的属性；**table_a**中的ascending_date和shop，以及**table_b**中的new_article_count(现在别名为number_of_listed_articles)。

成功完成这部分任务后，我们现在可以计算运行总数了。

第 3 步:计算每个分区(车间)的总运行时间

运行总数是使用顶部查询中的窗口函数计算的:

SUM (number_of_listed_articles) OVER (PARTITION BY shop) ORDER BY (ascending_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)

现在，让我们一起来呈现热门查询:

最终的查询结果如下:

随着这最后一步，我们成功地结束了我们的任务。😃

摘要

在本文中，我们展示了如何仅使用 BigQuery SQL 来填充缺失值，并计算特定指标随时间和每个特定分区的演变模式。

我们还介绍了如何组合不同的 BigQuery 函数 : 窗口和数组函数，以解决复杂的分析任务并提供所需的数据洞察。

最后，我们希望你会喜欢我们的教程，并在你的用例中找到它的用法。😃

参考文献:

[1] BigQuery SQL 文档，访问时间:2022 年 6 月 3 日，https://cloud . Google . com/big query/docs/reference/standard-SQL/array _ functions # generate _ date _ array

BigQuery SQL 优化 1:尽早过滤

原文：https://towardsdatascience.com/bigquery-sql-optimization-1-filter-as-early-as-possible-60dfd65593ff

有时，我会看到一些查询在早期准备了一个列，但却在后期使用该列进行筛选。或者用过滤掉本来可以用过滤掉的有的东西。这降低了查询速度，增加了处理成本。让我们看看对此我们能做些什么！

下面是一个示例场景，其中创建了相同的输出，但有一次查询通过之前的过滤进行了优化:

从公用表表达式(CTE)到最终输出查询(作者图片)的数据处理量

我们处理的数据越少，查询速度就越快。所以我们越早过滤掉数据越好。如果同样的事情可以在几秒钟内完成，没有人愿意等几分钟。但是有时会很难，尤其是在处理嵌套数据时——稍后会有更多介绍……

尽早过滤

查询SELECT movie, sum(tickets_sold) FROM movie_sales GROUP BY movie在以下阶段执行:

阶段 1 : 取出所有条目 FROM表movie_sales

阶段 2 : 根据您在movie列中找到的所有值对条目进行分组，并通过求和tickets_sold在组内进行聚合

阶段 3 : 输出在SELECT中定义的结果(这可能是反直觉的，因为SELECT在查询中先后执行，但最后执行，因为它“仅”定义了输出。在其他语言中，它会被称为print()或echo

如果我们只对某些电影的销量感兴趣，可以选择两种不同的过滤方式:WHERE movie='xyz'或者HAVING movie='xyz'。但是想象一下在每个场景中，查询引擎要将从一个阶段拖到另一个阶段需要多少数据:

使用HAVING,它将整个表拖到阶段 2，并且只在聚合后过滤
使用WHERE,在获取数据时，它会扔掉所有不需要的东西，这样它只会将很少的数据传递到下一阶段

在查询级别，我们有 3 种过滤方式:

WHERE与FROM一起工作
HAVING与GROUP BY一起工作
QUALIFY与OVER一起工作(窗口功能)

我们可以向WHERE或者甚至更早的查询/cte 移动的过滤器越多越好。或者换句话说:你应该在信息可用的最早时间点进行过滤。例如，如果过滤器需要聚合，那么我们不能将其移动到WHERE，因为只有GROUP BY聚合—不要过滤聚合在后面的WHERE，使用前面的HAVING。

例如:SELECT movie, sum(tickets_sold) FROM movie_sales GROUP BY movie HAVING avg(rating)>2.5在这里，我们可以使用WITH将查询放到一个公共表表达式中，并在后面的查询中进行过滤:

WITH prep as (
  SELECT movie, sum(tickets_sold), avg(rating) as avg_rating
  FROM movie_sales 
  GROUP BY movie 
)SELECT upper(movie) as movie, tickets_sold
FROM prep
WHERE avg_rating > 2.5

有时将过滤器移至WHERE可能会更复杂，但这通常是值得的，因为它显著提高了性能——尤其是当它在高峰时间运行时(即周一早上，当周/月报告的所有数据都被处理时)。

让我们看一些更具挑战性的案例…

使用数组上的子查询进行过滤

当处理嵌套数据时，将过滤器延迟到后面阶段的模式非常诱人，因为当我们不习惯所有这些子查询时，我们只想给子查询一个别名并使用那个名称。有时查询引擎可以弥补，但并不总是那么理想。

一开始，使用数组可能会令人困惑…我已经介绍了 BigQuery:嵌套数据上的 SQL，并在 BigQuery:使用 SQL 创建嵌套数据中解释了更多的数据准备概念。对于这一部分，你应该有点熟悉那里解释的想法。

但是在这里同样适用——如果我们可以将过滤器上移一两个阶段，那么我们将节省处理时间，因为查询引擎不需要将如此多的数据从一个阶段拖到另一个阶段。

让我们看一些简单的数组数据示例:

两行嵌套结果

我们可以对成分数组进行一些聚合:

子查询中包含数组聚合的未筛选查询

但是如果我们只想吃不含泡菜的饭菜呢？我们可以将SELECT ... FROM t1包装到另一个WITH t2 AS语句中，并检查字符串listIngr是否包含子字符串"pickles"。但之后我们会把所有泡菜餐拖到这个额外的阶段t2。相反，我们应该将WHERE与子查询结合使用！

使用子查询过滤的一个好方法是使用exists(<子查询> ) 和在子查询中设置条件。

因此，如果我们不想在一顿饭中有任何泡菜，子查询不应该返回任何东西！
如果我们想确保饭菜中有西红柿，那么子查询应该返回一些东西

SELECT
  ...
FROM t1
WHERE
  NOT EXISTS(select 1 from unnest(ingredient) as i where i="pickles")

这里，我们为每个where i="pickles"返回 1，并且 exists() 检查子查询是否返回了任何内容。如果是， exists() 将返回 true 和 NOT 将其转换为 false 并发送给，在那里过滤出泡菜。

如果我们希望两个条件都为真(没有泡菜，但是有西红柿),我们将使用两个子查询，每个子查询创建自己的过滤器布尔:

SELECT
  ...
FROM t1
WHERE
  -- only meals without pickles!
  NOT EXISTS(select 1 from unnest(ingredient) as i where i="pickles")
  AND
  -- only meals with tomatoes!
  EXISTS(select 1 from unnest(ingredient) as i where i="tomatoes")

添加可读的注释，与类似AND的布尔操作符一起使用，有助于理解查询。我们将在下一节看到一个更实际的例子。

证明优化是可行的

如前所述，策略相当简单:多次运行优化和非优化的查询，并查看消耗的槽时间。插槽的性能并不一致——因此，运行查询 3 到 5 次，记录其性能并取平均值，会给你一个思路。

有一些东西可以帮助我们:

禁用缓存以始终获得完整的性能结果
表样不过度扩展可用插槽，降低成本。与LIMIT相比，它实际上减少了处理，但不适合随机采样，如WHERE rand()<0.1

GA4 示例

这个例子采用了基本的 Google Analytics 4 数据——产品分析的一个常见用例:

现在我们优化了没有嵌套的数据——但是如果我们想过滤某些页面标题呢？让我们来看看:

WHERE 子句中的子查询看起来并不漂亮，但通常是有效的

现在我们可以开始采样了——比较 v3 和 v4。禁用缓存并在大表上添加TABLESAMPLE SYSTEM (10 PERCENT)或从您的 _TABLE_SUFFIX 中删除日期。记录并比较平均槽时间(不是总运行时间)。

在这个简单的例子中，差异实际上是可以忽略的，因为查询引擎可以优化我们的低效率，因为我们不改变值。但是查询通常没有这个简单。相反，它们会更改值，涉及其他表、聚合、窗口函数、多个 cte 等，达到查询引擎无法补偿的程度。即使您的用例现在如此简单，它也可能在以后演变成更复杂的东西。

因此，通过将过滤器提升到早期阶段来调整您的查询将使您在周一的第一份报告更新竞赛中获得优势。通过尽早过滤数据来减轻查询引擎的负担。

重构快乐！

BigQuery SQL 优化 2:使用临时表快速获得结果

原文：https://towardsdatascience.com/bigquery-sql-optimization-2-with-temp-tables-to-fast-results-41869b15fcff

何时使用临时表而不是 WITH

查询的最大性能杀手之一是在不应该使用CREATE TEMP TABLE的情况下使用WITH!在阐明了我们应该尽早使用 过滤器之后，让我们继续讨论何时使用或避免WITH。

(作者供图)

患有急性健忘症

WITH语句也叫常用表表达式 (CTE)。它们有助于消除查询的混乱，使查询更具可读性，因为它们将子查询从上下文中提取出来，并为它们命名。

即

SELECT a, b, c
FROM (SELECT x, y, z FROM ...)

变成了

WITH my_CTE AS (SELECT x, y, z FROM ...)SELECT a, b, c
FROM my_CTE

my_CTE看起来像一张桌子，因为它在一个表单的后面——但它不是桌子。它更像是实时指令，无论何时调用它，都会在运行时动态创建一个结果表。

每次你引用一个 CTE，它就会被执行

太疯狂了，对吧？cte 不会记住任何以前执行的结果！所以如果你这样做…

WITH ***a*** AS (...),a1 AS (SELECT aggr_1 FROM ***a***),a2 AS (SELECT aggr_2 FROM ***a***) SELECT ... FROM a1 LEFT JOIN a2

…然后你需要在读完这篇文章后立即修改这个查询，因为你通过计算两次***a***给你的查询引擎和计算槽带来了很多不必要的负载！

不要忘记:临时表

那么我们该怎么办呢？***a***应该是一个临时表，因为它们会记住结果——至少在查询运行期间。

之前的查询应该是这样的:

CREATE TEMP TABLE ***a*** AS (...)WITH a1 AS (SELECT aggr_1 FROM ***a***),a2 AS (SELECT aggr_2 FROM ***a***) SELECT ... FROM a1 LEFT JOIN a2

我们只计算一次***a***，并将其用于a1和a2中的两个不同聚合。

这和之前的例子没什么不同，对吧？但是它会执行得更好，因为我们省去了***a***的第二次计算。

您也不需要担心在特定数据集中创建表或删除表——它将由 BigQuery 处理，并在您的 SQL 语句运行完毕后消失。

我见过 CTE 被引用超过 5 次的查询。至少可以说，将该表重构为临时表很有帮助。为了证明它有帮助，我们可以对几次运行进行采样:

准备好已优化和未优化的查询
停用缓存
通过减少查询的数据量来保持合理的总工作量
大约同时运行两个查询 5 次，比较它们的平均槽时间

如何在创建临时表时重构旧查询

除了上面显示的变化之外，您可能会遇到希望将 cte 与临时表混合的情况。如果您真的只需要运行一次 CTE，那么它会比运行然后临时存储它稍微快一些。因此，如果我们可以跳过临时存储这一步，我们应该这样做。那么我们如何混合 cte 和临时表呢？

你可以把CREATE TEMP TABLE看作是更根本的操作。为了一起使用它们，它将简单地包含 CTE 定义，因为它们只是使子查询更可读，但本质上与子查询是一样的:

CREATE TEMP TABLE a AS ( WITH x AS (...),
  y as (...) SELECT ... FROM x LEFT JOIN y ON ...) SELECT ... FROM a ...

这个查询将使用 CTE x(在a的定义中定义)来创建临时表a。

总结一下:使用 cte 整理您的 SQL 语句，使它们更具可读性。但是不要多次引用 CTE，因为每次查询引擎都会重新计算结果。在这种情况下，请使用临时表——它们会给处理成本增加额外的存储步骤，但这(从临时表中读取)可能比重新计算整个查询更便宜。

别忘了尽早将这个最佳实践与过滤结合起来！

重构快乐！

简化数据工程的 BigQuery SQL 过程语言

原文：https://towardsdatascience.com/bigquery-sql-procedural-language-to-simplify-data-engineering-66ecfc47f3ac

介绍

安妮·斯普拉特在 Unsplash 上的照片

作为一名长期的 SQL 用户，我经常不得不一遍又一遍地运行相同的代码，只在 where 语句中稍作修改。在 Python 这样的编程语言中，这种复制和替换是不必要的，因为我可以创建一个函数来传入不同的参数值以重新运行相同的代码。今天我想分享如何使用 BigQuery 的过程语言来设置变量和条件逻辑以运行 SQL 语句。

声明并设置

声明语句初始化变量，而设置语句将设置变量的值。如果您需要运行除了几个值之外基本相同的 SQL 代码，这将非常有用。在下面的例子中，我们有一个名为 product 的表，它有两个字段: item_name 和 quantity 。

为了得到苹果的数量，我们将使用 where 语句来查找 item_name 等于 apple (第 3 行)。

现在，假设我们想要从这个表中查询不同的水果，但是我们不想多次复制整个 SQL 语句来更改 where 语句中的水果名称。在这种情况下，我们可以使用 DECLARE 初始化一个名为 fruit_name (第 1 行)的变量，并将值设置为 lemon (第 2 行) 。现在，当查询被运行时，where 语句查询 item_name 等于 fruit_name 变量即被设置为 lemon (第 6 行)。

要再次查询苹果，我们只需将 水果名称 变量从柠檬变回 苹果( 第 2 行)。

这是一个简单的声明和设置的例子，但是它们可以用在比我上面展示的更多的地方。重复的 SQL 语句也可以放在表函数中，这样用户就不需要用不同的 where 值多次编写相同的 SQL 代码。

如果-那么

如果满足条件，您可以使用 IF-THEN 条件语句来执行 SQL 语句。我遇到的一个典型场景是在为一个报告运行剩余的 SQL 之前检查一个表是否有最新的数据。从数据工程的角度来看，如果数据没有准备好，能够跳过代码会使事情变得容易得多。

在下面的例子中，我初始化了两个变量 rowcnt (第 1 行)和 latest_date (第 2 行)。我检查了 prod_data 表的行数，其中 daily_date 字段等于2022–11–18，并将该值设置为 rowcnt 变量(第 4 行)。

现在使用 IF-THEN 条件语句，我检查 rowcnt 是否等于 1(第 6 行)，这意味着如果找到 2022–11–18 的数据，那么将显示字符串 找到最新数据 。否则， latest_date 被设置为 prod_data 表中最大日期的值(第 10 行)，并且 数据延迟 与 latest_date 的值一起显示(第 12 行)。在这种情况下，没有找到数据，并且 latest_date 字段显示2022–11–15。

这也是一个简单的例子，但是您可以看到如果数据不可用，条件语句如何阻止 SQL 代码运行。

循环并离开

您可以结合使用 LOOP 和 LEAVE 来循环，直到在运行您的 SQL 语句之前满足一个条件。使用上面的例子，我添加了一个 计数器 变量，并将值默认为-1(第 3 行)。我通过 计数器 变量(第 9 行)使用 date_sub 函数继续从 2022–11–18 减去天数，直到 rowcnt 变量等于 1。

一旦 rowcnt 等于 1，使用 LEAVE 语句(第 11 行)循环结束。

last_date 字段显示循环在 prod_data 表中找到数据时停止(第 16 行)。

特别提及 :除循环和离开外，WHILE、CONTINUE 和 FOR..IN 也可用于控制循环。

最后的想法

我仅仅触及了 BigQuery 过程语言的表面，但是我希望您看到简化数据工程任务的潜力。我强烈推荐阅读文档并尝试一下过程语言。

注意:以上所有查询都是在 BigQuery 沙箱 上运行的，这对任何拥有谷歌账户的人都是免费的。

你可能也会喜欢…

</4-bigquery-sql-shortcuts-that-can-simplify-your-queries-30f94666a046> </6-bigquery-sql-functions-every-user-should-know-9ed97b1cf72e>

BigQuery UDFs 完全指南

原文：https://towardsdatascience.com/bigquery-udfs-complete-guide-181cbdaea55b

关于 Google BigQuery 用户定义函数你需要知道的一切

使用 UDF 定制您的 BigQuery 体验——照片由 Unsplash 上戴红帽的女孩拍摄

G oogle Cloud 的 BigQuery 是一款牛逼的数据分析甚至机器学习工具。它提供了许多现成的有用函数，但是如果你真的想深入 BQ，在某些时候你需要熟悉用户定义的函数。这些由您(用户)定义的函数将允许您简化您的 SQL 查询并更快地完成工作。

我将向您展示如何使用 SQL 或 JavaScript 来定义函数，甚至如何使用来自jStat的一些统计函数——一个用于统计的 JavaScript 库。

有一个 Google Colab Notebook 为整个教程提供了易于运行的步骤，你可以重新创建和窃取你自己工作所需的所有代码。

制作玩具数据集

那只果冻兔太棒了！—Yuri Shiro ta在 Unsplash 上拍摄的照片

由于我更喜欢编写易于复制的教程，我们将从验证我们的 Google Colab 会话开始我们的旅程:

现在我们需要一个玩具数据集。为此，我们可以使用sklearn:

我们的数据框已经准备好了。—作者截图

让我们将它制作成一个 BigQuery 表，并检查它是否如预期的那样工作:

我们可以使用%%bigquery Jupyter 神奇的函数来调用 BigQuery SQL:

BQ 的土地上一切似乎都很好——作者截图

临时功能

现在我们有了一个数据集，可以开始讨论用户定义函数或 UDF 了。我们将使用普通的 SQL 来定义带有关键字CREATE FUNCTION的函数。如果有任何困惑，欢迎在评论中询问更多细节。我们的函数将做一些超级简单的事情:如果标签是 1，将 x 乘以 100，否则，它将返回 x。下面是函数:

请注意，我们已经失去了 GitHub 语法突出显示，因为它不知道这些 BigQuery SQL 关键字…😅

现在来看看细节:

我们使用了TEMP关键字，这意味着我们的函数只存在于这个查询中。我们将不能再次重复使用它。
move_x是我们函数的名。
x和labelid是该功能的两个输入。我已经在这里定义了它们的类型，但是我们将在后面讨论更多的类型。
RETURNS FLOAT64告诉 BigQuery 函数返回什么类型的对象。
AS之后的都是函数的体。这基本上是一个简单的CASE WHEN子句。****
为了调用函数，我们只需在SELECT子句中传递我们需要的 2 个输入。这发生在 7 号线。

结果是辉煌的:

请注意，new_x 在 label=1 的结尾更大—作者截图

永久功能

纳达哈巴斯在 Unsplash 上拍摄的照片

现在，如果您试图在一个新的SELECT子句中调用这个函数，您将会看到这个400 Function not found: move_x错误:

我们的功能消失了😱—作者截图

但是正如您所料，我们可以通过删除关键字TEMPORARY并在函数名中添加一个指示符dataset来轻松保存函数。就像表和模型一样，函数也必须存在于数据集中:

一旦我们添加了这个，我们就使用ds.move_x()再次调用我们的函数——而不用定义它。如果你想知道这个函数的作用，你可以在 BQ 界面的Routines下找到它:

如果您注意的话，您可能会注意到上面的描述字段是空的。如果你正在做一个更大的项目，养成记录你的功能的习惯。我们可以在 BQ 中使用OPTIONS关键字来做到这一点:

您可以使用DROP子句随时删除您的功能:

关于类型的注释

在上面的定义中，我们明确定义了输入和输出类型。我们告诉 BigQuery 期待一个 Float 和一个 Int，并且总是返回一个 Float。有些情况下，你可能不希望这样。在这种情况下，您可以将输入类型定义为ANY，甚至将输出类型保留为空，让 BigQuery 动态地计算出类型。这将意味着你的函数可能为不同的输入返回不同的类型，所以要小心！** BigQuery 调用这个模板化的 SQL UDF 参数。**

为了演示这是如何工作的，我制作了一个名为multiply的新函数，它有两个ANY输入，并将它应用于 3 种不同的列和标量组合。请注意，根据输入的不同，输出会有不同的类型:

new_label 是 int，因为 label 和 10 都是 int——作者截图

还要注意，我在这里混合了列和标量，这很好！

定义的 JavaScript

到目前为止，我们在所有的函数定义中都使用了 SQL。但是 BigQuery 也支持 JavaScript 进行函数定义。您所需要的只是LANGUAGE关键字和一个带有 JS 魔法的字符串，其他的一切，包括输入/输出定义，都保持不变。确保在 JS 定义中包含 return 语句:

向你证明这确实有效:

BigQuery 中的 JS—作者截图

也没有什么可以阻止你在函数中定义更小的函数，只要你仍然以 return 语句结束:

JavaScript 函数不是无限的。它们可以访问很小的内存，所以要小心传递给它们的内容。理想情况下，你不会想要传入一个百万长度的数组。用 SQL 或者更好的存储过程来实现:

** [## 用于排列测试的 BigQuery 存储过程

towardsdatascience.com](/bigquery-stored-procedure-for-permutation-test-35597d6379e4)

使用 JavaScript 库

照片由 Mariia Zakatiura 在 Unsplash 上拍摄

你可能会问:“JavaScript 函数有什么意义？”。它们增加了混乱，引入了一种新的语言，通常看起来并不美观。我完全同意。对于这些单行函数，你应该坚持使用 SQL 函数。但是一旦你开始使用外部 JavaScript 库，事情就变得有趣了。例如，您可以使用jStat库并在 BigQuery 中实现统计测试。让我们看看如何在 BigQuery 中使用 JS 库。

步骤 1 —获取代码

对于我们的例子，我们将坚持使用jStat。进入 GitHub ，在dist文件夹下，抓取一个你喜欢的文件。它们是相同的，但是min没有空格。点击raw并选择save link as:

作者截图

在从 GitHub 复制代码之前，一定要检查许可协议！

一旦你保存了你的文件，把它上传到谷歌云存储。您上传到的 bucket 必须与您的 BigQuery compute 在相同的区域中。记下该位置的完整路径。如果你像我一样懒，你可以使用文件旁边的汉堡选项(3 点)来复制 Gsutil 路径:

复制 blob 路径—作者截图

这会给你这样的东西:gs://YOUR_BUCKET/path_to_file.js

第二步——使用代码

现在我们有了代码的副本，可以开始在查询中使用它了。我们仍然需要制作一个 UDF ，但是 UDF 本身可以从谷歌云存储中引用一个库:

注意我们在上面是如何调用jStat.sumsprd的。另外，请注意library接受一个数组，因此您可以提供多个 JavaScript 库来使用。你也可以创建自己的函数库！

结论

谢谢你一直读到最后。希望您学到了一些关于 BigQuery 的新知识，并发现代码示例很有用。BigQuery UDFs 是一个伟大的工具，可以减少代码中的重复，提高分析系统的可靠性。想想你可以用外部库做的所有事情，或者你可以通过一个b 去掉公共步骤而去掉的代码量。

我做的一件常见的事情是，通过使用该行的 id，在 ML 预测中添加一点可重复的噪声。有了这个功能，生活就轻松多了:

行动中的随机噪音—作者截图**

如果你喜欢这篇文章，请考虑关注我， 订阅 Medium ，或者查看我的其他文章:

** </jupyter-notebooks-can-be-a-pain-but-i-️-pluto-f47913c5c16d> **

PyTorch 中的二值图像分类

原文：https://towardsdatascience.com/binary-image-classification-in-pytorch-5adf64f8c781

照片由 Unsplash 上的 Clément Hélardot 拍摄

采用迁移学习方法训练卷积神经网络

我个人使用 TensorFlow 来接近深度学习，我立即发现它非常容易和直观。很多书也用这个框架作为参考，比如 用 Scikit-Learn、Keras、Tensorflow 动手机器学习。然后我注意到 PyTorch 经常被用于学术界和工业界的研究。所以我开始使用 PyTorch 实现我已经在 TensorFlow 中开发的简单项目，以便对这两者有一个基本的了解。由于我相信最好的学习方法是向别人解释，所以我决定写这篇动手教程，用 PyTorch 开发一个用于二值图像分类的卷积神经网络。

资料组

我们将使用狗 vs 猫数据集(有免费许可证)，你可以在以下链接找到:https://www.kaggle.com/datasets/biaiscience/dogs-vs-cats。数据集是免费开放使用的。我将向您展示如何创建一个模型来解决这个二元分类任务，以及如何使用它对新图像进行推理。

为了下载这个数据集，首先要做的是使用您的凭证访问 Kaggle ，然后下载 kaggle.json 文件，您可以通过单击创建新的 API 令牌按钮获得该文件。

作者图片

首先，我们需要编写允许我们上传个人 Kaggle 令牌和下载数据集的代码。

从 Kaggle 下载数据

现在我们需要将下载的文件夹解压到一个新文件夹，我们将命名为数据。接下来，我们还将分别解压缩两个子文件夹测试和训练。

解压缩数据

构造并填充子文件夹

为了便于管理数据集，我们创建了一个易于管理的文件夹结构。
目标是有一个名为 training 的文件夹，其中包含子文件夹 dog 和 cat ，它们显然包含各自宠物的所有图像。
对验证文件夹应该做同样的事情。

创建子文件夹结构

现在我们只需要重组数据并填充这些新创建的子文件夹。

填充子文件夹

我们来绘制一些图像示例。

绘图示例

作者图片

创建数据加载器

现在我们要做 3 件事:

让我们使用 compose 方法对数据进行预处理，这是一种简单的方法，可以对数据集应用多种预处理功能，比如标准化和数据扩充。
让我们使用 ImageFolder 创建一个 pytorch 数据集。如果子目录结构定义良好，PyTorch 会自动推断出类(就像我们的例子一样)。
使用数据加载器批量分割我们的数据。

创建数据加载器

训练阶跃函数

训练步骤总是由三个东西定义:模型、优化器和损失函数。因此，让我们编写一个函数，返回在输入这 3 个实体时给出的训练步骤函数。这样我们就不用一遍又一遍的重写同样的代码了！

训练阶跃函数

建立模型

在解决大多数 Kaggle 任务时，你不会从头开始编写一个网络，而是使用一个名为 base_model 的预训练模型，并使其适应手头的任务。把 base_model 想象成一个已经学会识别图像中重要特征的模型。我们要做的是通过增加一个由其他致密层组成的头来进行适配。在我们的例子中，最后的密集层将由单个神经元组成，该神经元将使用 sigmoid 激活函数，以便我们将具有为 0 或 1(猫或狗)的输出概率。

作者图片

我们必须小心不要训练之前已经训练过的基础模型。

让我们下载一个预训练模型(resnet)并冻结所有参数。然后我们将改变最后一个线性层以定制模型成为二进制分类器。记住型号和数据必须在同一个设备(GPU)上。

冻结预训练模型的参数

我们现在需要定义损失、优化器和训练 _ 步骤。

定义损失、优化程序和培训步骤。

训练模型

让我们写一下我们的培训和评估阶段。我们还将实现提前停止并在每个时期保存最佳模型。

训练和模型评估

由于我们从一个预先训练的模型开始，并且我们的二元分类任务非常简单，因此您应该很快就有一个能够非常准确地对数据集中的图像进行分类的模型。

推理

您现在可以使用该模型来预测新图像的标签！

对新图像的推断

结论

我们已经成功地建立了一个图像分类器来识别图像中的猫和狗。我必须说，在本文的中，我也用 Tensorflow 开发了相同的分类器，我发现 tensorflow 在这个简单的项目中使用起来更快。但是从我的角度来看，PyTorch 的优点是对从数据预处理到模型训练的各个步骤的更细粒度的控制。让我知道你的想法！

结束了

马赛洛·波利蒂

Linkedin ， Twitter ， CV

简单统计:二项式分布的解释

原文：https://towardsdatascience.com/binominal-distribution-what-analysts-should-have-known-95e6a0b56129

简要、集中的解释，并附有基本统计分布的图解。我们将从最基本的一个开始，二项分布。

迪米特里·亚基穆克在 Unsplash 上拍摄的照片

介绍

如前所述，统计学涉及到很多知识和定义。然而，当我回顾数据分析师的面试问题时，我想与您分享一些基本概念，我认为任何数据分析师在参加任何面试之前都应该完全了解这些概念。在接下来的几篇文章中，我将集中讨论的一个主题是演示和解释一些最常见的、数据分布，包括离散和连续数据。

正如我之前的帖子 简单解释基本统计学概念 一样，我通过举例说明的方式，简单解释了一些最基本的统计学。在这篇文章中，为了更容易想象，我将使用同样的方法。

离散与连续数据

有两种类型的数值数据，离散数据和连续数据。

作者图片

离散数据被理解为不同的或独立的值。它是可数、有限、数字和非负整数。通常，数据在时间和空间上是离散分布的。一些离散值的例子包括一个公司的雇员人数，一所房子里的猫的数量，或者一个小时内买咖啡的人数。不可能有 10.25 个员工，2.5 只猫，或者 100.8 个人买咖啡。离散数据也可以是包含有限数量数据值的分类数据，如一年中的季节。

同时，连续数据可以是区间内的任意值。比如，我们来考虑一下女性头发的长度。它可以在高度精确的尺度上测量，例如 30.12 厘米、30.1 厘米、30.0001 厘米或 30.012 厘米。正如我们所见，十进制数和分数代表连续数据。

每种类型的数据都有不同的分布。我们将从离散分布开始，到连续分布，从最基本的分布开始:二项分布。

作者图片

随机变量

随机变量是实验中可以取随机值的变量。假设随机变量代表随机选择的 18 个柠檬中发现的变质柠檬的数量。在这种情况下，18 个柠檬表示 18 次试验。我们可以进行不止一次实验，随机抽取 18 个柠檬，并计算有缺陷的柠檬数量。

作者图片

正如我们可以看到的，在我们的第一个实验中，有两个水果变质了。在我们的第二个实验中，有 4 个柠檬没有达到标准。在最后一个实验中，6 个柠檬变质了。这里的随机变量是 2，4 和 6。在之前的实验中发现的不合格产品的数量可以被称为一个随机变量。通常用字母 X 表示。这里，随机变量 X 取值为 2，4 和 6

二项式随机变量&二项式实验

二项式实验描述了 N 次独立试验的结果，随机变量 X 代表“N”次成功的次数。在这种情况下，x 被认为是一个二项随机变量。有两种截然不同的、互补的结果，一个“成功”和一个“失败”，每个试验都被假定会产生其中之一。因此，假设在一个测试 18 个柠檬的 18 次试验中，成功的次数(找到变质的柠檬)是一个样本空间为{0，1，2，3…18}的二项式随机变量。

此外，一个实验可以有 1 次试验、3 次试验或更多次试验。然而，如果该实验只有一次试验产生两种结果:成功或失败，则该试验被称为伯努利试验。

一个随机实验是一个二项式实验如果它满足以下要求:

有一定数量的试验
这些试验相互独立
每次试验的结果必须属于两种可能的结果之一:“成功”(期望的结果)或“失败”。
对于每次试验，都有一个恒定的成功概率 p 和失败概率 (1 — p) 。

二项式分布

我将继续上面的柠檬例子。众所周知，在一个挑选 18 个独立且随机的柠檬的实验中，我们挑选的变质水果的数量(成功试验)或二项式随机变量可以是 0-18 之间的任何数字。二项式概率分布是一种概率分布，显示随机变量的概率为 0-18。

作者图片

假设我们在每次试验中挑选一个柠檬，我们想看看在 18 次试验中挑选 X = {0，1，2，…18}个变质柠檬的概率。在每次试验中，挑选一个腐烂柠檬的机会是 0.3 (p=0.3)。上面的二项分布表明了这个实验的结果。

那么，公式怎么会产生这个结果呢？让我们通过一个小例子来找出在 3 次试验中有 2 个青苹果被采摘的概率，给定总共 3 个青苹果和红苹果，并且在所有试验中 p = 0.25 一致。

作者图片

将会有三种情况发生。我们可以在前两次试验中，后两次试验中，或者前两次和最后一次试验中摘两个青苹果。摘两个青苹果的概率:

P(X = 2)=(0.25)(0.25)(0.75)+(0.75)(0.25)+(0.25)(0.75)(0.25)= 0.14

作者图片

根据这个原理，我们得到了二项分布问题的一般公式，其中 k 代表 n 次试验中的成功试验，p 是成功的概率。

作者图片

将该公式应用到我们的示例中，我们可以得到类似的结果。

作者图片

二项分布的实例

我们可以在很多现实生活中看到二项分布的例子。

在银行工作时，我们可以使用二项分布来确定一些信用卡交易欺诈的概率。假设某家银行的所有信用卡交易中有 0.75%是欺诈性的，通过使用二项分布，我们可以估计特定日期发生一定数量欺诈的概率。
同样，我们可以使用二项式分布计算器来估计某一天收件箱中垃圾邮件的数量。
等等

以上是我对如何定义二项分布的简短解释。我希望这篇文章能在某种程度上让你受益。在我的下一篇文章中再见！

参考

https://vital flux . com/binomial-distribution-defined-with-10-examples/

考古集合网络的二部图

原文：https://towardsdatascience.com/bipartite-graphs-for-archaeological-assemblage-networks-part-i-648a2f20d389

考古学中的数据科学，第一部分

数据考古学(图片由作者提供)。

我偶尔会被问到，尤其是在我决定“全力以赴”去获得另一个研究生学位之后，数据科学与考古学有什么关系。这将是一个简短系列文章的第一篇，展示我如何使用数据、统计等来深入了解这个令人惊讶的错综复杂的研究领域。基本上，当许多数据科学家试图对现在或未来做出推论时，我一直在寻找将这些方法应用于理解过去的方法。

虽然我用的是一个考古学的例子，但是这里介绍的方法可以用于其他领域的许多研究问题。二分图用于生物信息学(例如，基因表达关联)、密码学(代码解码匹配)、化学工程、推荐引擎(例如，客户-产品匹配)——即，其中实体之间的关系取决于某种中介关系的任何分析。

在这篇文章和接下来的文章中，我将介绍一些基础知识:

第一部分——创建和探索二分图和单模图
第二部分 —集合和图邻接的相似性度量，
第三部分—图结构和社区检测方法，
第四部分——地理空间网络

我将使用 R 进行编码，但是所有这些都可以用 Python 轻松完成。

介绍

从本质上讲，一个考古遗址是由相互关联的人工堆积物和特征组成的一个离散的空间区域。

不太正式的说法是旧东西散落在一个地方在那里某人做了某事。从很多方面来说，这是一个大拼图。想象你有一张照片(实物照片，而不是那些新奇的数码照片)。你不知道照片里的人是谁，也不知道他们在做什么。

现在想象一下，有人把那张照片撕成了成百上千个不规则的碎片…

然后扔掉了至少一半……
然后将剩余的碎片撒在一块暴露在自然环境中的空地上……
然后被各种牲畜、人和动物践踏了几个世纪……
后来有人来了，在他们上面建了新房子、道路或停车场！

所有这些留下来的东西很可能就是我们这些可怜的考古学家为了理解这幅画而留下来的数据。

考古学家的工作是在这些数据中寻找模式，以解释该地点随着时间的推移发生了什么。我们想知道他们在做什么事情，这通常能告诉我们过去的那些 T2 人是谁。我们通过在一个遗址区域进行非常精确控制的样本挖掘来做到这一点，然后尝试从这些样本中推断出不同种类文物的整体空间分布。

考古数据的结构

作为一名考古学家和数据科学家(排名不分先后)，我的工作是从那些挖掘出的样本中获取数据，看看我能否找到——并量化——这些模式。

所以，尝试做所有这些的第一部分是，看看哪些的东西被发现在一起，哪些的地方包含最相似的的东西是否有一个模式。

更正式地说，我们试图在由一组位置和一组工件组成的集合系统中找到子集。我几年前写过一篇文章(枢机 2019 )，很详细的讲了那个地方 - 东西套系统的本质。这一切都可以归结为这样一件事:

集合符号将工件集合和 provenience context 系统定义为多个集合的和。

我承认，不太方便用户。相信我，看了我的文章(最终)就说得通了？

在图术语中，我们寻找的是同时跨越两个图的离散子图或社区(即，诱导子图或“集团”)，一个是地点，一个是工件类型。换句话说，一个双模式(或“二分”)图。

对于那些不熟悉的人来说，双模图是这样一种图，其中有两种互斥的类型的顶点(即节点),不同类型的顶点之间只能存在边。在这种情况下，我们有地点和事情。

目前，我们只想知道哪些事物最常出现在同一个地点，哪些地点包含类似的事物。工件之间的可观察的关系由它们的同位置(即存在于相同的产地)来表示。然而，从更广泛的意义上来说，我们的目标是研究为什么这些文物会一起出现——它们是否来自同一时期，它们是否反映了特定类型的活动，它们是来自一个还是多个家庭，等等。这些问题的答案是不可观测的，但是人造物品的位置和协同位置是可观测的。

以下示例中使用的数据来自一个实际的考古遗址(一个家庭结构的集合，大约在 18 世纪中期到 20 世纪被占用)，而不是一个玩具示例或模拟数据。因此，它就像真实世界的数据一样混乱——文物和产地的分组并没有清晰地分类，而是(剧透警告！)在空间组织和集合中确实存在集群。我们将走过我用来寻找和评估这些类型的模式的过程的一部分。

在 R 中制作二部图

我们可以用包igraph很容易地创建一个二分图，尽管它没有太多直接分析双模图的方法。出于我们的目的，这不是什么大问题，因为我们主要感兴趣的是使用它作为一种方式来获得每个单模图(即，分别放置和事物)。

我们将使用的包是igraph(创建、操作和分析图表)、tidyverse用于数据框管理，以及ggraph用于可视化。当然，还有其他的软件包也可以工作。这些只是我已经习惯使用的。

首先，我们将从文本文件导入数据，这是工件目录的数据库。其中列出了在每个位置发现的每个工件类型的详细信息(称为“provenience”)。我们现在并不真正需要关于每个工件类型的细节，因为我们只是在寻找关联，所以我们只真正需要两个字段——provenience(LEVEL_ID)和工件类型代码(CODE)。

接下来，我们使用数据帧dat中唯一的对LEVEL_ID和CODE来创建带有graph_from_data_frame的双模无向图(assemblages_bpg)。

这是一个无向图，因为顶点的排序或层次没有任何实际意义。这种关系是双向的——一个位置包含事物，而事物在那个位置中是等价的。为了简单起见，我们将创建一个 un- 加权二分图，它忽略了多重性(也就是说，每种工件类型的数量是如何在每个地方被发现的)。现在，我们只考虑类型的共存或同处。

然后，我们使用方法bipartite_mapping根据节点来自两列中的哪一列来给顶点分配类型。

人工制品-产地联系的二分图。

现在我们有了工件类型和位置之间的连接图，并且我们已经可以在每个顶点类型中看到一些粗略的分组(一个类型在图的顶部，一个在底部)。这个图是密集连接的，有许多节点和边。

让我们快速看一下二分igraph对象本身:

顶部的文本IGRAPH 2ea26e5 UN-B 403 2533 --告诉我们它是无向的(U)，节点有一个name属性(N)，是无权重的(-)，并且是一个有 403 个顶点和 2533 条边的二分图(B)。在列出的边预览中，您将看到数字和文本对(例如，1726--UDB)，它们是数字来源(LEVEL_ID)和文本工件类型代码(CODE)的组合。

我们可以很容易地用(shock！)方法as_incidence_matrix并查看前几行和前几列…

它只是一个二元的双模式权变表或双模式邻接表，显示了在每个位置工件类型的存在(1)或不存在(0)。

投射每种模式进行分析

直接分析二分图度量有点复杂，因为图的最常见度量(例如，中心性度量等。)由于包含这两种类型的顶点以及它们之间的依赖关系而被扭曲。更容易做的是投影每个模式的加权图，然后分析它们。

同样，igraph使这变得容易。我们使用方法bipartite_projection和设置multiplicity = TRUE，以便为每个模式创建加权图形投影。因为我们的目标是将具有最多工件类型共性的产地和最经常一起出现的类型联系起来，所以我们需要这些多样性。

您将看到我们现在有两个单模图，分别是用于 proveniences 的$proj1和用于 artifact 类型的$proj2。剩下的就是将这些投影分配给它们自己的单模态图。

让我们来看看由此产生的图形投影。

普罗旺斯投影图。

工件类型的投影图。

这两个图显然都非常密集，在这一点上，很难判断其中是否有任何模式或社区。我们需要对它们进行一些探索，找出所有这些联系在告诉我们什么。

现在我们已经有了两个单模图，你可能想知道— 为什么要大费周章地制作一个二分图呢？有几个原因。

第一，我们正在寻找的关系和关联是两个实体之间的互动。从概念上讲，这应该有一定的意义。考古上可观察到的不同类型的艺术品之间的联系主要是通过共处一地来实现的。类似地，proveniences 是相关的，因为它们包含相似的工件类型。这些关联本身本质上是二分的，所以通过用初始化我们的图表，这种关系就是解决它们的正确方法。

其次，这只是一种优雅的方式。当然，我们可以通过构建数据透视表和列联表，然后将它们转换成邻接矩阵和图，从源数据表构建各个图。然而，通过这种方式构建，我们减少了一大堆步骤，并且用几行非常简单的代码构建了我们的两个图！作为一个额外的好处，我们可以很容易地拉出那些单独的列联表，就像我们在开始时对关联矩阵所做的那样。为什么要做额外的工作？

分析投影图

如果你注意到上面，我们的两个单模图都非常密集。例如，普罗旺斯图G_assemblage_prov有 9817 条边，但只有 152 个顶点？无向图中可能的最大边数是 1/2 × |V| × (|V|-1)，因此对于 152 个顶点，最大边数是 11，476，我们的图的密度约为 86%。

我们将从查看顶点的度的密度分布开始，或者每个顶点连接了多少个其他顶点。

我们从分布的左偏看到，大多数顶点实际上都与大多数其他顶点相连。如果这是真的，那么就不会有任何不同的产地(即没有群落结构)，86%的密度只是表明一个相对同质的网站。

现在，让我们看看这些边的权重分布。

这里我们看到了相反的情况——分布是右偏的，这意味着我们的绝大多数边缘都是由弱相似性形成的(即，只有少量的共同伪像)。

所以现在我们知道为什么我们的产地图如此密集——如果只需要一个或多个共同点来连接两个地点，并且大多数产地至少有一个共同点，那么一切都联系得很好。

也许某些藏物类型只是在很多地方出现？我们需要找到一种方法来细化图表，这样只有真正有意义的 T2 连接才能形成边。

接下来让我们看看我们的工件图G_assemblage_artifact。它没有像那么密集(251 个顶点，可能的 31，375 条边中的 9，494 条，所以大约 30%)，但是我们将再次查看顶点度数和边权重密度。

这里我们看到有点向右倾斜的程度密度分布，但是大多数是相当强连接的(~50+连接)，并且注意到向右尾部的“凸起”——似乎至少我们的一些工件类型确实出现在大多数其他工件旁边。

伪影边缘权重严重向右倾斜，请注意右尾延伸的距离。这告诉我们的是，一些，但不是很多，藏物类型出现在很多地方。然而，大多数人工制品类型只共存于相当少的几个(大约 3-4 个)产地。

度和边权重的解释

我们现在大致了解了在我们的系统中发生了什么地方 - 事情集合:

这两个独立的投影图都是密集的，但大多数连接都很弱。
似乎很可能是每组中相对较少数量的项目产生了这些弱连接。某些工件出现在大量的 provenience 中，并且一些 provenience 包含大量不同的工件类型。
这些微弱但密集的连接可能掩盖或淹没了图表中的潜在结构。

我们接下来需要做的是找到一种方法来区分信息连接和虚假连接。

接下来的步骤…

有人可能会认为，显而易见的下一步将是简单地开始删除最薄弱的边缘，在某些情况下，这将是要走的路。请记住，我们的目标实际上是分析工件和位置之间的关系(即连接边)。单个顶点的强度不是目标，而是我们想要识别从它们的关系中得到的顶点的社区。[3]

发生的事情是，我们用来设计单模态图的方法只是简单地列出了个体产地和人工制品类型重合的次数。问题是一个共享的工件可以连接位置，一个共享的位置连接工件。这不是我们想要的。我们想要链接具有最相似的同现集合或轮廓的顶点。换句话说，我们需要查看集合和的交集，它们的不同之处是为了确定相似之处。

为此，我们需要一种不同的投影方法。在下一部分中，我们将研究一些基于集合的相似性度量，并看看当我们以这种方式投影单模图时会发生什么。

参考

红衣主教 j .斯科特。2019."集合、图形和我们能看见的东西:用于经验站点内分析的形式组合本体论."计算机在考古学中的应用杂志 2(1):56–78。https://doi.org/10.5334/jcaa.16 。

笔记

佐治亚理工学院计算学院、谢勒商学院和工程学院的分析理学硕士。我强烈推荐这个节目！
我的考古同事有时也会反过来问我——考古学与数据科学有什么关系。定量和计算(或“数字”)考古学已经存在了很长一段时间，但我们仍然是少数。不过，这是另一篇文章的主题。
精通图论的读者可能已经注意到，我们的最终目标是边介数和中心性度量。

基于机器学习的鸟类分类

原文：https://towardsdatascience.com/bird-species-classification-with-machine-learning-914cbc0590b

数据科学

根据基因和位置预测鸟的种类

照片由香农·波特在 Unsplash 上拍摄

像鸟一样？比如数据科学？

你会喜欢这个挑战的！

问题陈述

科学家们已经确定，一种已知的鸟类应该分为 3 个不同的独立物种。这些物种是该国特定地区特有的，必须尽可能精确地跟踪和估计它们的数量。

因此，一个非盈利的保护协会承担了这项任务。他们需要能够根据野外工作人员在野外观察到的特征，记录他们遇到了哪些物种。

使用某些遗传特征和位置数据，你能预测已经观察到的鸟的种类吗？

这是一个初级水平的练习比赛，你的目标是根据属性或位置预测鸟类的种类。"

来源

你现在有了一个明确的目标。

目标🥅

根据属性或位置预测鸟的种类(A、B 或 C)

现在让我们来看看数据

数据💾

通过注册获得本次数据科学竞赛的数据。

📂 **train**
├── training_target.csv
├── training_set.csv
└── solution_format.csv📂 **test**
└── test_set.csv

数据被方便地分成训练和测试数据集。

在每一次训练和测试中，你会得到位置 1 到 3 的鸟的数据。

下面来看看training_set.csv的前五行

training_set和training_target可以与‘id’柱连接。

下面是给定列的数据字典

**species**     : animal species (A, B, C)
**bill_length** : bill length (mm)
**bill_depth**  : bill depth (mm)
**wing_length** : wing length (mm)
**mass**        : body mass (g)
**location**    : island type (Location 1, 2, 3)
**sex**         : animal sex (0: Male; 1: Female; NA: Unknown)

然后，看着solution_format.csv

现在你对目标有了一个想法，对给你的数据有了一些了解，是时候动手了。

本文代码→ 深注

加载库

接下来，我们加载一些用于可视化和机器学习的基本库。

缺少数据帮助函数

加载数据

首先，我们使用read_csv函数加载训练和测试数据。

我们还将training_set.csv(包含特征)与training_target.csv(包含目标变量)合并，形成训练数据。

在这里，我手动保存了列名，包括数字和分类，还保存了目标列。

这使我可以很容易地引用我以后想要的列

探索性数据分析

有趣的部分到了，可视化数据。

从info函数中，似乎有丢失的值，我们可以看到位置和性别应该是分类的，所以我们稍后必须进行一些数据类型转换。

数字列

绘制数值变量的直方图，我们看到

bill_depth 在 15 和 19 左右达到峰值
比尔的长度在 39 岁和 47 岁左右达到顶峰
翼长峰值在 190°和 216°左右
质量是右偏的

分类列

让我们首先想象一下我们的目标类。

我们看地点和物种似乎是为了它们各自的地点和物种(loc2 &物种 C，loc3 &物种 A)。

我们也看到雌性鸟比雄性鸟稍微多一点。

根据物种图，我们手里似乎有一个不平衡的职业，因为物种B比物种A和C少得多

为什么这是一个问题？

模型会偏向于样本量较大的类。

发生这种情况是因为分类器具有关于具有更多样本的类的更多信息，因此它学习如何更好地预测那些类，而它在较小的类中保持较弱。

在我们的例子中，物种A和C将比其他职业更容易被预测到。

这里有一篇关于如何处理这个问题的很棒的文章。

缺少值

使用助手功能，似乎有大量的bill_length和wing_length数据丢失

我们还可以使用热图来可视化该列中缺失的数据。

估算分类值

先看看我们的分类变量里有多少缺失变量。

让我们使用简单的估算器来处理它们，用最频繁的值替换它们。

如您所见，通过most_frequent策略，缺失值被估算为 1.0，这是最常见的。

估算数字列

特征预处理和工程

我们必须将分类特征转换成数字格式，包括目标变量。

让我们使用 scikit-learn 的标签编码器来完成这项工作。

这里有一个使用LabelEncoder()标签列的例子

通过首先拟合它，我们可以看到映射看起来像什么。

使用fit_transform直接为我们转换

对于其他包含字符串变量(非数字)的列，我们也进行同样的编码

我们还将分类特征转换成pd.Categorical数据类型

这是变量的当前数据类型。

现在，我们通过将一些变量除以另一个变量来形成比率，从而创建一些额外的特征。

我们不知道它们是否有助于提高模型的预测能力，但试试也无妨。

这是目前火车场景的样子

构建模型

列车测试分离

现在该建立模型了，我们先把它拆分成 X(特征)和 y(目标变量)，再拆分成训练集和评估集。

训练是我们训练模型的地方，评估是我们在使模型适合测试集之前测试模型的地方。

我们使用[train_test_split](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html)将我们的数据分成训练集和评估集。

决策树分类器

对于本文，我们选择一个简单的基线模式，即决策树分类器

一旦我们适应了训练集，我们就可以根据评估数据进行预测。

模型性能

让我们看看简单的决策树分类器是如何工作的。

对于不平衡的数据集，99%的准确率可能毫无意义，因此我们需要更合适的指标，如精度、召回率和混淆矩阵。

混淆矩阵

让我们为我们的模型预测创建一个混淆矩阵。

首先，我们需要获得标签编码器给出的类名和标签，这样我们的图就可以显示标签名。

然后我们绘制一个非标准化和标准化的混淆矩阵。

混淆矩阵告诉我们，它预测了更多的 A 类和 C 类，这并不奇怪，因为我们有更多的样本。

它还表明，该模型预测了更多的 A 类，而它应该是 B/C 类。

分类报告

分类报告测量来自分类算法的预测质量。

它告诉我们有多少预测是对的/错的

更具体地说，它使用真阳性、假阳性、真阴性和假阴性来计算精确度、召回率和 f1 值

有关这些指标的详细计算，请查看简化的多级指标，第二部分:由 Boaz Shmueli 撰写的 F1 分数

直观上，精度是分类器不将一个阴性(错误)样本标记为阳性(正确)的能力，召回是分类器找到所有阳性(正确)样本的能力。

从文档中，

"macro"简单地计算二进制指标的平均值，对每个类别赋予相等的权重。在非频繁类仍然重要的问题中，宏平均可能是突出其性能的一种方法。另一方面，所有类都同等重要的假设通常是不正确的，因此宏平均会过度强调不经常出现的类的典型低性能。
"weighted"通过计算二进制指标的平均值来说明类别不平衡，在二进制指标中，每个类别的分数根据其在真实数据样本中的存在情况进行加权。

没有单一的最佳指标，这取决于您的应用。应用程序以及与不同类型的错误相关的实际成本将决定使用哪种度量标准。

特征重要性

让我们也画出特性的重要性，看看哪些特性更重要。

从特征重要性来看，mass似乎最擅长预测物种，其次是bill_length。

其他变量在分类器中似乎不重要。

我们看到特征重要性是如何在我们的决策树分类器的可视化中使用的。

在根节点中，如果质量低于大约 4600，那么它检查bill_length，否则它检查bill_depth，然后在叶子处它预测类。

根据测试数据进行预测

首先，我们执行相同的预处理+特征生成

然后，我们可以使用我们的模型进行预测，并连接 ID 列以形成解决方案文件。

请注意，物种值是数值，我们必须将其转换回字符串值。有了 fit 早期的标签编码器，我们可以做到这一点。

保存预测文件。

后续步骤

基础模型不足以做出好的预测；下面是改进给定方法的一些后续步骤。

更多特征预处理和工程
使用交叉验证来更好地衡量性能。
测试其他算法，如 KNN，SVM，XGBoost，Catboost 等。
加入 bitgrit discord 服务器 与其他数据科学家讨论挑战

超棒的 Kaggle 笔记本

这里有 3 个笔记本作为参考，告诉你如何在这次挑战中提升自己的水平

感谢阅读！

喜欢这篇文章吗？这里有三篇文章你可能会喜欢:

用机器学习预测降雨
利用数据科学预测病毒性推文
40 个有用的熊猫片段。在数据分析工作中派上用场的熊猫片段

数据 L 许可

数据由CC-0授权按照 帕尔默站【LTER】数据策略 和 LTER 数据访问策略获取 I 类数据 。

喜欢我的写作吗？用我的 推荐链接 加入 Medium ，你将直接支持我🤗

https://benedictxneo.medium.com/membership

比特币的技术贡献:解决拜占庭将军问题

原文：https://towardsdatascience.com/bitcoins-technical-contribution-solving-byzantine-general-s-problem-f0449973437c

2008 年比特币白皮书如何解决经典的计算机科学共识问题

图 1:贝尔伯里勋爵对拜占庭将军问题的阐释，CC BY-SA 4.0 / 来源

问题陈述

拜占庭将军问题(BGP)是根据一个寓言而命名的，在这个寓言中，许多将军需要合作并同意同时一起攻击一个城市，以赢得战斗(图 1-左)。如果任何一个将军在最后一刻撤退，战斗就失败了(图 1-右)。因此，确保信使共享准确的信息以及没有流氓将军是至关重要的。在缺乏可信的中央权威的情况下，这是很难实现的。

Leslie Lamport、Robert Shostak 和 Marshall Please 在他们 1982 年的论文中把这个问题命名为拜占庭将军问题，以一种用户友好的方式表示分布式计算机系统问题。

实际问题是关于计算机系统的分布式网络中的一致性。维护一个正常运行的系统网络变得很困难，因为要就哪些系统正在工作(并留在网络中)和哪些系统没有工作(即需要从网络中移除)达成共识。系统之间不可靠的通信渠道和误报系统加剧了这一挑战。

解决 BGP 还可以指导我们构建没有单点故障或不需要可信中央实体的机器学习解决方案。例如，在模型训练期间，单个服务器托管模型的参数，而多个工人训练模型。这篇论文，描述了一种构建容错分布式拜占庭机器学习解决方案的方法。

比特币的技术创新在于，它找到了一种方法，让分布式节点网络就哪些交易应该进入分布式账本(区块链)达成共识，而不需要可信的中央实体。这样，它解决了 BGP 的实现问题。比特币的笔名作者中本聪创造性地结合了已有的密码学和共识机制来解决问题。

放弃

这篇文章并不意味着任何形式的财务建议。这是一篇关于解决计算机科学问题的有趣方法的综述。

比特币

比特币白皮书的第一行写道:

“电子现金的纯点对点版本将允许在线支付直接从一方发送到另一方，而无需通过金融机构。”
来源:https://www . ussc . gov/sites/default/files/pdf/training/annual-national-training-seminar/2018/Emerging _ Tech _ bit coin _ crypto . pdf

让我来解开比特币的主要组成部分:

比特币软件(开源&版本)，执行节点、矿工和比特币令牌的操作规则。
比特币令牌，可以通过挖掘生成的原生令牌单位(最多 2100 万)，在比特币区块链的钱包地址之间进行交换。
分布式分类账，自 2009 年 1 月第一笔交易以来所有交易(以区块组织)的数据库(区块链)的相同副本。
分布式网络的 节点(计算机)运行比特币软件和一份分布式账本。它们验证和接受有效的事务，并将它们传播到其他对等节点。
工作证明(PoW) ，一种加密证据(以有效哈希摘要的形式)，表明矿工已经花费了一定量的计算处理(挖掘工作)来解决加密问题，以获得向比特币区块链添加新交易块的权利。比特币有一个内置的难度调整功能，可以改变有效哈希要求(nonce的长度)，这样平均每 10 分钟就会产生新的区块。PoW 是一种能量密集型活动，因为它必须不断随机生成新的散列，直到它满足需求。
挖掘者，执行持续计算处理以解决重复出现的密码问题的竞争方。为区块解决问题的第一个矿工(或池)收取交易费和一些新创建(开采)的比特币作为奖励。挖掘能力以哈希速率的形式来衡量，即每秒生成多少个哈希。

比特币最重要和最新颖的特点是结合了加密技术、分散的节点网络和工作证明共识机制。

比特币中使用的加密技术

比特币在其实现中使用以下已知的加密技术。

散列法
基于非对称加密的数字签名

散列法(SHA-256)

图 2:块头的 Hash + nonce 上的 SHA-256 哈希运算

哈希是唯一明文数据到唯一摘要的单向转换。将不可能逆转该操作，即从摘要生成明文。比特币矿工使用 SHA-256 哈希算法不断生成新的哈希，目标是获得有效的哈希以获得区块奖励。

哈希从当前块头生成，然后与一个名为 nonce 的变量值结合生成一个新的哈希。挖掘过程需要不断改变随机数并重新散列以尝试得到满足要求的散列。

块头本身由前面块的散列和一个称为 Merkle root 的特殊散列组成，Merkle root 包含块中所有事务的散列。因此，我们得到了一个块链，一直链接到第一个块，散列层不断增加。哈希算法确保了比特币区块链中新交易的安全性和整个交易的不变性。随着在任何事务的块之后挖掘更多(例如，6 个)块，在该块和先前块中伪造甚至很小的条目变得越来越不可能。

基于非对称加密的数字签名

图 3:使用非对称加密和散列操作的事务签名和验证过程

在非对称加密(也称为公钥加密)中，每个交易方都有一个密钥对，即私钥和公钥。私钥不应该与任何人共享，而公钥(即由此生成的钱包地址)可以与交易方共享。来自同一个密钥对的这两个密钥在数学上以这样一种方式联系在一起，即公钥可以从私钥中导出，但反之则不行。消息(例如，比特币支付记录)只能由拥有私钥的所有者(发送者)签名，但是它可以由任何节点或任何能够访问公钥的人(即，在区块链中可见的人)来验证。例如，如果 Alex 想要向 Bob 发送比特币，则 Alex 将向节点发布地址为 Bob 的钱包的期望数量的比特币的数字签名交易。只要 Alex 是唯一拥有私钥的人，只有 Alex 可以授权该金额。因为 Alex 的公钥在区块链上可用，所以任何人都可以验证该交易。

解决办法

现在，让我们将比特币实现映射到 BGP 问题。BGP 的将军类似于运行比特币软件的节点。共识、将军和试图达成的共识，就像比特币节点决定将哪块交易纳入区块链一样。所有节点运行的比特币软件版本可以:

1.验证交易(即验证数字签名)

2.只接受和传播来自能够第一个获得有效散列并证明它做了必要工作的挖掘器的新块。除了通过使用以下输入连续生成新的散列之外，没有办法猜测有效散列:固定/当前块头和称为 nonce 的变量的新值。

因此，共识由 PoW 机制和分布式节点网络来解决，该分布式节点网络接受来自解决不可伪造的密码问题的挖掘者的块。

但是，如果有:

不诚实的节点
不诚实的矿工

如果由于流氓节点，不同节点组接受的块集合存在差异，比特币具有接受最长链的功能。因此，对于进入区块链的无效交易，流氓节点在接受/形成更长的链方面将不得不多于诚实节点。截至目前(2022 年 11 月)，将接管 7000 个(来源)协同流氓节点劫持比特币网络。

类似地，不诚实的矿工也可以发起攻击，并试图用伪造的交易(例如，双重消费、撤销、审查交易等)潜入区块。)入链。这也需要超过 50%(即 51%的攻击)的挖掘者(总计算能力)来猜测散列并对网络发起攻击。目前挖掘哈希率超过 2 亿(来源)。矿工被激励去合作(通过奖励和交易费),而不是发起攻击。然而，量子计算机在未来可能会带来风险。

在这里看我关于量子计算的相关帖子。

最终，节点比挖掘者具有更大的影响力，因为节点可以验证交易，并且如果挖掘者向它们提供欺诈性块，则拒绝它们。因此，只要诚实的节点占大多数，网络就能保持安全。

摘要

表 1 显示了拜占庭将军问题的三种实现之间的比较。

表 1:拜占庭将军问题实现的比较

比特币白皮书及其实现解决了没有任何中央治理实体的分布式系统所经历的共识问题。这样，它解决了难以捉摸的拜占庭将军的问题。

资源

https://en.wikipedia.org/wiki/Byzantine_fault
比特币核心软件源代码—https://github.com/bitcoin/bitcoin
比特币白皮书—https://bitcoin.org/bitcoin.pdf
https://en.wikipedia.org/wiki/Bitcoin
https://www . Microsoft . com/en-us/research/publication/拜占庭将军问题/
https://www . Microsoft . com/en-us/research/uploads/prod/2016/12/The-Byzantine-Generals-problem . pdf
https://en.wikipedia.org/wiki/Hash_function
https://en.wikipedia.org/wiki/Merkle_tree
https://en.wikipedia.org/wiki/SHA-2
https://en.wikipedia.org/wiki/Public-key_cryptography
https://en.wikipedia.org/wiki/Digital_signature
https://en.wikipedia.org/wiki/Proof_of_work
https://en.wikipedia.org/wiki/Quantum_cryptography
https://dci.mit.edu/bitcoin-security-initiative
https://dci.mit.edu/51-attacks
真正分布式拜占庭机器学习 ，El-Mahdi El-Mhamdi 等人，2020。纽约州纽约市 ACM，https://doi.org/10.1145/3382734.3405695

Python 中的黑盒超参数优化

原文：https://towardsdatascience.com/black-box-hyperparameter-tuning-in-python-478c10adc959

Python 中暴力和黑盒优化方法的比较

图片由 PhotoMIX 公司在像素上拍摄

在机器学习中，超参数是用于控制机器学习模型的学习过程的值。这不同于从数据中学习的内部机器学习模型参数。超参数是机器学习训练数据之外的值，其确定机器学习模型性能的最优性。每个唯一的超参数集对应于一个唯一的机器学习模型。对于大多数现有技术的机器学习模型，所有可能的超参数组合的集合可能变得相当大。幸运的是，大多数机器学习模型包都带有默认的超参数值，可以实现不错的基线性能。这意味着数据科学家或机器学习工程师可以使用开箱即用的模型，而不必一开始就担心超参数选择。这些默认模型通常优于数据科学家或工程师能够手动测试和选择的模型。

相反，为了优化性能，数据科学家或机器学习工程师必须测试不同于默认值的超参数的各种值。手动执行会变得非常麻烦和低效。由于这个原因，已经设计了许多算法和库来自动化超参数选择的过程。超参数选择是优化中的一个练习，其中目标函数由模型表现的有多差来表示。优化任务是找到一组最佳参数，使机器学习模型的性能下降到最低程度。如果你找到性能最差的机器学习模型，那就对应着性能最好的模型。

文献跨越、蛮力技术和黑盒非凸优化为优化提供了丰富的空间。强力优化是彻底搜索所有可能的超参数组合的最佳参数集的任务。如果有可能彻底搜索超参数空间，它将给出给出全局最优解的超参数集。不幸的是，就计算资源和时间而言，穷举搜索超参数空间通常是不可行的。这是因为超参数调整机器学习模型属于非凸优化的范畴。这是一种优化类型，其中找到全局最优是不可行的，因为它可能陷入几个次优“陷阱”中的一个，也称为局部最小值，这使得算法难以搜索超参数的整个空间。

强力优化的替代方法是黑盒非凸优化技术。黑盒非凸优化算法寻找次优的解决方案，局部最小值(或最大值)，这是基于一些预定义的度量足够优化。

Python 有暴力优化和黑盒优化的工具。模型选择模块中的 GridSearchcv 支持强力优化。 RBFopt python 包是 IBM 开发的黑盒优化库。它通过使用径向基函数来构建和优化被优化函数的代理模型。它很有用，因为它没有对被优化函数的形状或行为做任何假设。它已被用于优化复杂的模型，如深度神经网络。

构建、测试和比较模型超参数和机器学习算法的任务本质上通常是协作性的。考虑到这一点，我将与 DeepNote 合作，这是一个协作数据科学笔记本，使数据科学家可以轻松地在机器学习和数据分析任务上合作。在这里，我们将介绍如何应用这些优化工具来调整分类模型的超参数。我们将考虑预测客户是否不会重复购买的监督机器学习任务，这被称为搅动。我们将使用 Kaggle 上公开的虚构的电信公司流失数据集。数据集在 Apache 2.0 许可下可以自由使用、修改和共享。

读入电信客户流失数据

首先，让我们导入 python pandas 库，将我们的数据读入 pandas 数据框，并显示前五行数据:

进口熊猫作为 pd

df = pd.read_csv("telco_churn.csv")

作者截图

我们看到该数据包含诸如客户 ID、性别、老年公民身份等字段。如果我们将光标悬停在左侧的单元格输出上，我们将看到以下内容:

作者截图

我们看到我们有“客户流失”字段，它对应于客户是否重复购买。值“否”表示客户重复购买，值“是”表示客户停止购买。

我们将建立一个简单的分类模型，将性别、老年人、互联网服务、设备保护、每月费用和总费用作为输入，并预测客户是否会流失。为此，我们需要将我们的分类列转换为机器可读的值，这些值可以作为输入传递给我们的机器学习模型。让我们为性别、老年人、互联网服务和设备保护这样做:

转换分类列

#convert categorical columns
df['gender'] = df['gender'].astype('category')
df['gender_cat'] = df['gender'].cat.codes
df['SeniorCitizen'] = df['SeniorCitizen'].astype('category')
df['SeniorCitizen_cat'] = df['SeniorCitizen'].cat.codes
df['InternetService'] = df['InternetService'].astype('category')
df['InternetService_cat'] = df['InternetService'].cat.codes
df['DeviceProtection'] = df['DeviceProtection'].astype('category')
df['DeviceProtection_cat'] = df['DeviceProtection'].cat.codes

让我们显示结果列:

df[['gender_cat', 'SeniorCitizen_cat', 'InternetService_cat', 'DeviceProtection_cat']].head()

作者截图

我们还必须对客户流失列做一些类似的事情:

df['Churn'] = df['Churn'].astype('category')
df['Churn_cat'] = df['Churn'].cat.codes

接下来我们需要做的是清理 TotalCharges 列，用 NaN 替换无效值，并用 TotalCharges 的平均值输入 NaNs

df['TotalCharges'] = pd.to_numeric(df['TotalCharges'], 'coerce')
df['TotalCharges'].fillna(df['TotalCharges'].mean(), inplace=True)

现在让我们准备输入和输出。我们将定义一个变量 X，它将是一个包含列 gender、SeniorCitizen、InternetService、DeviceProtection、MonthlyCharges 和 TotalCharges 的序列。我们的输出将是一个名为 Y 的变量，它将包含客户流失值:

#define input and output
X = df[['TotalCharges', 'MonthlyCharges', 'gender_cat', 'SeniorCitizen_cat', 'InternetService_cat', 'DeviceProtection_cat']]
y = df['Churn_cat']

接下来，让我们拆分数据进行训练和测试。我们将使用 scikit-learn 中模型选择模块的训练测试分割方法:

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

用默认参数建模

首先，我们将构建一个随机森林分类模型。随机森林算法是一种基于树的集成模型算法，它使用决策树的组合来防止过度拟合。让我们从 scikit-learn 中的 ensemble 模块导入随机森林类:

from sklearn.ensemble import RandomForestClassifier

接下来，让我们定义我们的随机森林分类器模型对象，并使我们的模型适合我们的训练数据。通过将 RandomForestClassifier 的参数留空，我们定义了一个具有预定义默认参数的模型:

model = RandomForestClassifier()
model.fit(X_train, y_train)

让我们打印模型的默认参数值。为此，我们只需在模型对象上调用 get_params()方法:

model.get_params()

作者截图

我们将使用精度来评估我们的分类模型。对于不平衡分类问题，如流失预测，这是一个很好的选择。让我们来评估一组目标的精确度:

from sklearn.metrics import precision_scorey_pred_default = model.predict(X_test)precision = precision_score(y_test, y_pred_default)precision

现在让我们看看如何应用强力网格搜索来找到最佳随机森林分类模型。

使用 GridSearchCV 进行强力优化

诸如 GridSearchCv 之类的强力搜索方法通过在整个搜索空间中穷举搜索最佳超参数集来工作。首先，让我们从 scikit-learn 中的模型选择模块导入 GridSearchCV 方法:

from sklearn.model_selection import GridSearchCV

让我们也定义一个字典，我们将使用它来指定我们的参数网格。让我们定义一个估计值范围(决策树从 10 到 100)，决策树的最大深度从 5 到 20，最大特征等于 sqrt，标准等于基尼指数(这是用于在决策树中划分组的度量标准:

params = {'n_estimators': [10, 100],
'max_features': ['sqrt'],
'max_depth' : [5, 20],
'criterion' :['gini']}

接下来，让我们用参数字典定义网格搜索对象:

grid_search_rf = GridSearchCV(estimator=model, param_grid=params, cv= 20, scoring='precision')

并使对象符合我们的训练数据:

grid_search_rf.fit(x_train, y_train)

从那里我们可以显示最佳参数:

gscv_params = grid_search_rf.best_params_gscv_params

用最佳参数重新定义我们的随机森林模型:

gscv_params = grid_search_rf.best_params_model_rf_gscv = RandomForestClassifier(**gscv_params)model_rf_gscv.fit(X_train, y_train)

作者截图

让我们来评估一组目标的精确度:

y_pred_gscv = model_rf_gscv.predict(X_test)precision_gscv = precision_score(y_test, y_pred_gscv)precision_gscv

作者截图

我们看到我们的精度实际上优于默认值。虽然这很好，但对于大范围的参数值和较大的数据集，这种方法可能会变得难以处理。黑盒优化和贝叶斯优化等替代方法是超参数调优的更好选择。

使用 RBFopt 进行黑盒优化

现在让我们考虑使用 RBFopt 的黑盒超参数优化。RBFopt 的工作原理是使用径向基函数来构建和优化被优化函数的代理模型。这通常用于没有封闭形式表达式且有许多山峰和山谷的函数。这与众所周知的具有封闭形式表达式的简单函数形成对比，例如二次函数或指数函数。

首先让我们安装 RBFopt:

%pip install -U rbfopt

作者截图

接下来，我们需要为我们的模型参数定义一个上限和下限列表。下限列表将包含估计器数量的 10 和最大深度的 5。上限列表将包含 100 个估计数和 20 个最大深度:

lbounds = [10, 5]ubounds = [100, 20]

接下来让我们导入 RBFopt 和交叉验证方法:

import rbfoptfrom sklearn.model_selection import cross_val_score

接下来我们需要定义我们的目标函数。它将接受 n_estimators 和 max_depth 的输入，并为每组参数建立多个模型。对于每个模型，我们将计算并返回精度。我们试图找到使精度最大化的 n 估计量和 max_depth 的一组值。由于 RBFopt 找到最小值，为了找到使精度最大化的参数集，我们将返回精度的负值:

def precision_objective(X):
    n_estimators, max_depth = X
    n_estimators = int(n_estimators)
    max_depth = int(max_depth)
    params = {'n_estimators':n_estimators, 'max_depth': max_depth}
    model_rbfopt = RandomForestClassifier(criterion='gini', max_features='sqrt', **params)
    model_rbfopt.fit(X_train, y_train)
    precision = cross_val_score(model_rbfopt, X_train, y_train, cv=20, scoring='precision')
    return -np.mean(precision)

接下来，我们指定运行、函数调用和维度的数量:

num_runs = 1max_fun_calls = 8ndim = 2

这里我们只运行 8 个函数调用。如果你希望运行 10 个以上的函数调用，你必须安装 bonmin 和 ipopt 软件包。安装说明可以在各自链接的 GitHub 页面上找到。

现在，让我们指定我们的目标函数并运行 RBFopt:

obj_fun = precision_objectivebb = rbfopt.RbfoptUserBlackBox(dimension=ndim, var_lower=np.array(lbounds, dtype=np.float), var_upper=np.array(ubounds, dtype=np.float), var_type=['R'] * ndim, obj_funct=obj_fun)settings = rbfopt.RbfoptSettings(max_evaluations=max_fun_calls)alg = rbfopt.RbfoptAlgorithm(settings, bb)

作者截图

并将目标值和解决方案存储在它们各自的变量中:

fval, sol, iter_count, eval_count, fast_eval_count = alg.optimize()obj_vals = fval

然后，我们将整数值解存储在字典中:

sol_int = [int(x) for x in sol]
params_rbfopt = {'n_estimators': sol_int[0], 'max_depth': sol_int[1]}
params_rbfopt

作者截图

我们看到，RBFopt 分别为 n_estimators 和 max_depth 找到了最佳值 81 和 5。

然后将这些最佳参数传递到我们的新模型中，并拟合我们的训练数据:

model_rbfopt = RandomForestClassifier(criterion=’gini’, max_features=’sqrt’, **params_rbfopt)model_rbfopt.fit(X_train, y_train)

并评估精度:

y_pred_rbfopt = model_rbfopt.predict(X_test)precision_rbfopt = precision_score(y_test, y_pred_rbfopt)precision_rbfopt

作者截图

我们看到，通过更快的优化算法，我们在精度上有了轻微的提高。当您有大的超参数搜索空间时，这尤其有用。

这篇文章中使用的代码可以在 GitHub 上获得。

结论

对于每个数据科学家来说，很好地理解超参数调整机器学习模型的可用工具是必不可少的。虽然大多数机器学习算法的默认超参数提供了良好的基线性能，但超参数调整通常是必要的，以看到基线性能的改善。强力优化技术是有用的，因为它们彻底地搜索超参数空间，这将保证从默认参数改善基线性能。不幸的是，蛮力优化在时间和计算方面是资源密集型的。出于这些原因，更有效的黑盒优化方法，如 RBFopt，是强力优化的有用替代方法。RBFopt 是一种非常有用的黑盒技术，应该成为每个超参数优化数据科学工具包的一部分。

使用 mtalg 在 Python 中实现极快的代数和随机数

原文：https://towardsdatascience.com/blazing-fast-algebra-and-random-numbers-in-python-with-mtalg-aa50ac8ffd3

用于多线程代数和伪随机数生成的 python 工具

来自 mtalg 的图像

数据科学家和研究人员经常需要执行快速有效的数值计算。因此，处理大型数据结构需要能够通过多重处理或多线程来利用所有可用的计算资源(参见这篇伟大的文章来复习)。这非常重要，以至于像numpy这样的数值库自动支持线性代数运算上的多线程。

然而，有点令人惊讶的是，numpy没有为元素操作和(伪)随机数生成提供现成的多线程功能。这些通常是主要的瓶颈，例如当执行大规模蒙特卡罗模拟时，用于通过 MCMC 的贝叶斯参数估计等。

Python 库[mtalg](https://github.com/WWakker/mtalg) [1]提供了多线程的基于元素的函数和多线程的随机数生成，击败了大多数其他库，包括numexpr和使用numba的即时编译(参见下面的基准)。

多线程代数

安装了带有pip install mtalg的库后，我们可以导入mtalg并使用它的内置函数:

请注意，默认情况下，操作在第一个参数中就地执行。因此，mtalg.add(a,b)相当于a = a + b(只是方式更快！).这种行为可以通过可选参数direction来覆盖:例如mtalg.sub(a, b, direction='right')将等同于b = a - b(注意这与mtalg.sub(b, a)不同，后者将等同于b = b — a)。

默认情况下,mtalg将线程数量设置为可用 CPU 内核的数量，但是该参数可以作为mtalg.set_num_threads(6)被覆盖。同样，我们可以将当前设定值检查为mtalg.get_num_threads()。

随机数生成

随机数生成可以按如下方式执行:

mtalg.random提供了一系列不同的发行版来进行采样，所有发行版都保持了类似 numpy 的语法。

mtalg目前支持从以下分布中采样:、二项式、卡方、指数、f、伽马、几何、gumbel、超几何、整数、拉普拉斯、逻辑、对数正态、对数序列、负二项式、非中心卡方、非中心 f、正态、帕累托、泊松、幂、随机、瑞利、标准柯西、标准指数、标准伽马、标准正态、标准 t、三角形、均匀、冯米斯、瓦尔德、威布尔、zipf 。

基准

针对 numpy 和一些最快的可用库的基准测试证明了mtalg的速度。

图 1 — Elementwise 代数:十亿次运算的加法函数基准[2]。其他基本功能的执行方式类似。【来源:作者图片】

图 2 —元素代数:加法函数的基准[2]。其他基本功能的执行方式类似。【来源:作者图片】

通常，多线程会带来开销，因此多线程的好处只有在处理大量操作时才会显现出来(按照 10⁷ / 10⁸或更大的数量级——图 2)。

还可以观察到随机数生成的速度大幅提高，这是执行大规模蒙特卡罗模拟或通过 MCMC 进行贝叶斯参数估计时的一项关键任务。

图 3 —随机数生成:均匀和标准正态分布随机变量的基准2。从其他分布中取样的表现类似。【来源:作者图片】

图 4 —随机数生成:均匀和标准正态分布随机变量的基准[2]。从其他分布中取样的表现类似。【来源:作者图片】

结论

在本文中，我们介绍了mtalg，这是一个直观的 Python 库，用于快速的元素操作和随机数生成。

欢迎在下面的专门部分留下评论、编辑建议或提问！

另外，如果你想为图书馆做贡献，请随时联系我们！

参考

GitHub 上的[1]mtalg
【2】性能指标评测是使用英特尔至强黄金 6142M CPU @ 2.60GHz 和 24 个线程进行的
【3】免责声明:作者是此处提供的库的维护者和合著者。

将优化教程与 Python 中的线性编程相结合

原文：https://towardsdatascience.com/blending-optimization-tutorial-with-linear-programming-in-python-74bcc443e4e5

应用于实际的水泥配料优化问题

作者图片

介绍

在几乎所有行业中，尤其是自然资源行业，通过优化所需资源支出产生的收入，做出最佳决策以最大化每个项目的价值至关重要。运筹学是一门学科，在这门学科中，现实世界的问题被用数学方法描述，并被优化以改进决策。下面的示意图说明了基于分配资源实现的最大净值的最佳项目 B，而 A 和 C 由于较差的设计或资源可用性而不是最佳的。乍一看，最便宜或最有价值的项目似乎是直观的选择，而最佳项目往往受到许多需要优化的不同和相关变量的影响。

比较项目 A、B 和 c 的净值和花费的资源的示意图

有了良好的运筹学，许多公司，尤其是自然资源行业的公司，可以更好地瞄准最有可能产生最大净值的最优项目。不幸的是，通常依赖昂贵的软件或外部顾问来概念化和解决这些优化问题。在本文中，我们将展示在 Python 等开源软件中实现这一点是多么简单。本例中使用的所有代码都存储在 GitHub 上。

水泥配料优化问题

本教程将关注 1977 年水泥和混凝土研究论文[1]中的一个实际水泥混合优化问题。在这种应用中，石灰石、粘土、铝土矿和烧过的黄铁矿以最经济的方式混合，同时保持所需的物理性质。

这四种原料中的每一种都有不同的成本，从 6 美元/吨到 230 美元/吨不等，并且由不同的成分比例组成。主要成分包括二氧化硅(SiO2)、氧化铝(Al2O3)、氧化铁(Fe2O3)、氧化钙(CaO)和三氧化硫(SO3)，每种成分都需要在一定的比例范围内，以确保水泥满足所需的物理性能。下表总结了使用来自[1]和[2]的真实水泥数据的所有相关值。

原材料、它们各自的成分百分比和价格。来自[1]和[2]的真实水泥数据。作者图片

优化术语和方法

在我们进行任何优化之前，我们需要理解相关术语，以便从数学上定义手头的问题，一些关键术语包括:

目标函数:在一系列可能的值中，最小化或最大化的有值函数
决策变量:优化问题中的未知量
约束:通常以等式或不等式的形式必须满足的逻辑条件

在我们的混合示例中，目标函数就是每种材料的价格之和乘以该材料在四种材料中的比例。决策变量是每种材料的比例，比如使用 50%石灰石和 20%铝矾土。我们可以从根据我们的决策变量定义成分开始，并设置目标函数以最小化，如下所示。

目标函数最小化价格乘以每种材料的比例之和。作者图片

如果我们像上面显示的那样单独运行优化，我们只会得到所有的材料比例等于零，给我们一个很好的零成本，但我们知道这不是一个真正的解决方案。约束最终推动优化，因为在遵守物理特性要求的同时，混合成本必须最小化。约束在【1】和【2】中被定义为成分的函数，因此我们将引入一些变量(q1 至 q6 ),类似于论文【1 】,如下所示。注意，在使用 scipy minimize 的 Python 中，它们必须用决策变量来明确表达。

驱动约束的六个变量被定义为决策变量每种原材料比例的函数。作者图片

在这个例子中，约束是基于每种成分必须落入的特定范围、几个不同的模数以及燃烧产品的某些元素，这些都是成分比例的函数。对于本文的线性编程部分，有 14 个约束，我们将在下面的 Python 改编中分解其中两个。

前两个约束的分解显示了每个方程如何以 scipy 优化格式转换成 Python 代码。作者图片

现在只需要对所有 14 个约束重复上述过程。下面是剩余的 12 个约束，显示在 GitHub 上的 Python 代码片段中。将所有的约束转换成代码似乎很难，但是一次只考虑一个等式是很重要的。在引入每个新的约束之后，一次运行一行代码可能有助于确保没有明显的输入错误，这些错误在以后会变得很麻烦。

水泥混合优化问题[1，2]中剩余的 12 个约束条件 T10，以及显示每个线性不等式 T11 约束条件 T12 的裁剪代码的屏幕截图。

使用 Scipy 运行优化

我们终于准备好用我们的约束来运行优化，以确定决策变量，其最小化目标函数。就我们的例子而言，我们将得到每种材料的比例，从而得到满足所需物理性质的最经济的混合物。

我们将使用from scipy.optimize import minimize和序列最小二乘编程(SLSQP)方法，该方法可以处理等式和不等式约束【3】，如 GitHub 上的代码所示。下表显示了 1977 年论文[1]中的材料比例与 Python 教程中的材料比例有多么相似。细微的差异可能是由于舍入或不同的优化方法。

单纯形论文[1]和 scipy python 教程的最终结果使用 SLSQP 最小化。

结论

运筹学为更好的决策提供了强有力的工具。虽然有运行线性程序的昂贵软件，但也可以使用开源软件轻松设置，如 Python 中的 scipy optimize。独立地对优化问题进行编码还允许进行一些改变，这些改变在商业软件中可能是不可用的，因为商业软件抽象了许多更好的细节。

解决这些优化问题可以让公司做出更好的决策或改进复杂操作的程序。在本教程中，用不到 30 行代码解决了一个实际的水泥混合优化问题。虽然解决方案是针对可用的特定材料和作为示例的一部分出现的约束，但是相同的方法适用于任何种类的类似混合问题。

本文考虑了一个线性问题，但是也存在优化更复杂的非线性程序的选择。虽然线性问题更容易计算，但它们通常带有假设，导致不可避免的次优解决方案。本教程中使用的论文通过比较线性规划近似和更精确的非线性规划[1]对此进行了更详细的讨论。非线性程序改善事物的程度很可能取决于手头问题的线性有效性。

旁白—水泥的典型使用案例

有时候，退一步看看我们所做的所有数据工作在现实世界中的应用是很好的。水泥是混凝土的主要成分，而混凝土是建筑中使用最广泛的材料。下面是一个我和我的叔叔们一起搅拌和浇筑混凝土台阶的整洁视频。

将水泥与骨料和水混合以浇筑混凝土步骤的时间间隔。作者提供的视频

参考

[1] Xirokostas，D. A .，& Zoppas，C. E. (1977 年)。水泥配料优化问题的数学规划方法。水泥和混凝土研究，7(5)，503–514。

[2] Labahn O. (1971 年)，《水泥工程师手册》第 60 页。Bauverlag Cmbh，威斯巴登。

[3]克拉夫特博士(1988 年)。序列二次规划软件包。技术。众议员 DFVLR-fb88-28，德国航空航天中心德国飞行力学研究所，科隆，德国。

融合人工智能的力量和诗歌的细腻

原文：https://towardsdatascience.com/blending-the-power-of-ai-with-the-delicacy-of-poetry-3671f82d2e1

人工智能模型现在能够从文本中生成图像，如果我们给它们提供伟大诗人的话语会怎么样？诗与人工智能的梦幻之旅。

图片由作者用 DALL-E 创作。灵感来自平克·弗洛伊德的《希望你在这里》

简介

诗歌只不过是巧妙选择的词语的并置。一系列的字符，但能够激发情感。一种很难解释和整理的艺术。
在听或读一首诗时，我们几乎能感觉到情绪、寒战，或者通过闭上眼睛我们能看到图像。事实上，许多最引人入胜的诗歌往往充满了隐喻和类比，描绘了生动和不寻常的形象。

毕竟，文字往往伴随着图像，无论是书中的插图还是广告中的强化信息。出于热情或商业目的，插画师经常被要求将他人写的文字转换成图像，试图捕捉文本的信息，同时找到最佳的表达方式，而不背叛作者的思想。

达尔-E，巫师

OpenaAI 今年发布了 DALL-E 2 ，这是一种新的生成语言模型，能够将句子作为输入，并创建相应的原始图像。该模型是先例模型 DALL-E 的新版本，即使尺寸更小(只有 35 亿个参数，而不是 120 亿个参数)，也能够生成分辨率提高 4 倍的图像。在不涉及技术细节的情况下，DALL-E 2 由不同的组件组成(称为先前型号，夹子，以及松开)。它已经在一个惊人的 6.5 亿张图像和相关字幕的数据集上进行了训练，以学习合并图像中存在的连贯元素的能力。

简而言之，我们可以说，当你给 DALL-E 2 一个句子时，先验模型正在生成一种图像的“心理意象”(一种图像主要元素的合成图，或者称为嵌入)。“解开”模块将此图像转换为绘图，而“剪辑”模块则对图像中句子的特征(元素和样式)进行编码。

DALL-E 你可以输入一个句子“一个宇航员以照片般逼真的方式骑马”，它能够生成一个编码句子中描述的元素的图像。

从 DALL-E 2 生成的图像

改变句子，它能够处理句法语义的变化，比如:“一个宇航员在太空的热带度假胜地以照片般的真实风格闲荡”。

从 DALL-E 2 生成的图像

正如 Twitter 上不同用户所注意到的那样，DALL-E 2 可以更好地处理复杂和费解的句子，因为短句可能缺乏特异性(导致有趣的结果)。请注意，如何也相应地调整阴影(和水反射，如果有的话)，这实际上是令人印象深刻的。DALL-E 还可以插入图像，改变图像的风格，编辑图像等等。

从 DALL-E 2 生成的图像

但是，当您要求生成带有文本的图像时，不同的用户会注意到一些错误(尤其是在照片级的图像中)或拼写错误。这是因为即使是非常先进的模型，DALL-E 也不会推理。

俳句的微妙艺术

有什么比俳句更能让你开始的呢？毕竟，俳句是包含在三行空间里的激动人心的诗。作为 17 世纪日本的一种诗歌形式，它通常由三行和 17 个音节(5-7-5)组成。尽管它很简短，但它通过提取精华成功地浓缩了生动的情感。一种艺术形式，以极简的风格优雅地将引人注目的意象封装起来。

俳句从其直接性和明显的简单性中汲取力量，消除虚饰，从自然、季节和人类精神状态的暗示中汲取灵感。这篇文章需要思想和意象的综合，然后让读者去想象这首短诗之外还有什么。俳句的精妙之处还在于这种意象的并置，然后往往在最后一行得到解决，从而产生一种封闭感。

它们包含对比鲜明的图像和明显的逻辑跳跃，因此似乎是这个小实验的完美场所。

露水的世界，

在每一颗露珠里

奋斗的世界

《露水的世界》小林伊萨