毁灭数独——一个数据科学项目
第 1 部分:介绍和项目设计
这就是你在本系列结束时的观感。不过，山羊胡子可不能保证。
照片由范明在 Unsplash 拍摄
当我年轻而愚蠢的时候(我只保留了这两个特征中的一个)，我想象与人工智能一起工作包括花大量的时间设计和实现一个显示某种智能的软件，不管这意味着什么。《黑客帝国》于 1999 年上映，当时我 15 岁，很容易被那些视觉效果所打动:可以说，这部电影对我未来的生活方向产生了相当大的影响。
在我的衣柜上，但那是以后的事了。
到目前为止，我已经作为一名数据科学家工作了大约 7 年，尤其是在过去的两年半时间里，在离开学术界进入行业工作之后，我对这个主题的看法发生了重大变化。如果我必须描述我每天都在做什么，我会说我基本上花时间试图解决与数据有关的问题，这些问题通常需要某种人工智能魔法才能解决。
然而，我意识到，从外部的角度来看，接受一个请求、一个想法并将其转化为实际产品的复杂性可能并不明显。我认为人们很容易专注于更有趣的部分，如花哨的神经网络和奇异的数据集，而忘记数据科学项目中对其成功至关重要的所有其他方面:我指的是像部署、数据预处理以及最重要的项目设计，即制定从零到最终产品工作所需的路线图。
所以我认为把这个过程作为一个整体来写会很有趣:我看到了很多关于各个部分的教程(特别是关于前面提到的深度学习相关的东西)，但没有多少关于如何把这些部分放在一起，更没有多少花合理的时间来解释一些选择背后的原因或探索为什么有些道路不应该走。请允许我填补这个空白。
介绍
做或不做【一个从零开始的完整的数据科学项目】，没有尝试(其实我鼓励尝试)。
照片由吉米·阮在 Unsplash 上拍摄
我是大卫·西尔弗关于强化学习的工作的超级粉丝，我经常开玩笑说 DeepMind 的目标是通过创造在特定游戏中比任何人都好的人工智能来破坏我们其余人的游戏。
所以我想沿着这条路走下去会很有趣，尽管是从一个非常不同的角度。
想象一下，你有一个非常种族主义的老阿姨，她将气候变化归咎于移民(她否认这一点:逻辑高于她)，通过她的 facebook 账户传播各种错误信息，并且是韦斯特博罗浸信会的铁杆会员。当她在的时候，鸟儿停止歌唱。如果你不必去想象，只要把注意力放在愉快的想法上，时间最终会为你解决这个问题。
凯伦阿姨的生活中只有一个快乐的来源:每周二，每周一期的“数独 eXXtreme 4000”被送到她的邮箱里，她珍惜在那些谜题上度过的每一刻。
我们的目标是摧毁那种幸福。
为了做到这一点，我们将设计并实现一个系统，允许你从包含数独网格的杂志页面上拍摄一张照片，并在几秒钟内自动解决它。
摘要
本文是系列文章的一部分:
- 第 1 部分:介绍和项目设计
- 第二部分:数据预处理
- 第三部分:数字识别和数独求解器
- 第 4 部分:部署和追溯
你应该有个计划
就像玩乐高一样，第一步是弄清楚你需要哪些部件。
照片由哈维·卡夫雷拉在 Unsplash 上拍摄
当我开始一个新项目时，我会花相当多的时间来确保几个问题有明确的答案(或者至少尽可能清楚):
- 我在做什么？这个项目的最终目标是什么？
- 我怎样才能做到这一点？
这是一个迭代过程，从任务的高级描述开始(在我们的例子中，它类似于*“给定一张数独的图片，返回另一张完成的拼图的图片”*)，然后将其分解为更小的任务，直到它们变得清晰、原子化，这些任务可以简化为一些特定的问题，这些问题有算法形式的解决方案。
它不一定是完美的:不管你在计划方面有多好，肯定会有你忽略的东西，你必须在飞行中调整你的轨迹，在这个阶段没有必要专注于细节。只要原计划足够好，提供了一个好的起点，那就可以了。
让我们画一些形状。
项目分解
我很确定他在某个时候说过。
来源:照片由米尔乔兰在 flickr 上拍摄，由 2.0 授权 CC
技术说明:我用米罗来画图表，坦白地说，这是一个非常好的发明，让青霉素看起来像四年级学生的苏打火山。抱歉，亚历山大，这就是事实。
如我之前所说，你的出发点是问题的定义，仅此而已。所以从一张白纸开始，你应该得到这个:
作者图片
这并不多，当然你很有可能真的知道下一步该去哪里，但是让我们一步一步来。
顺便说一下，我将使用颜色来编码任务的状态:
作者图片
下一件自然的事情当然是将任务分成第一组更小、更易管理的任务。当我开始考虑这个项目需要什么组件时，我用自下而上的方法提出了四个主要任务。
作者图片
- 在某种程度上，我希望有一个数独的结构化表示，这是一个代表 81 个单元格的 9 x 9 数组，其中包含 1 到 9 之间的一个数字或者为空。有了这种格式的信息，即使我不一定知道如何做到这一点(这就是为什么那个块有一个红色的边框)，我希望一个算法应该能够解决这个难题。
- 然而，为了获得该信息，需要扫描网格并识别每个单元格中存在的数字(或者检测出它是空白的)。幸运的是，如果任何数据科学都需要做一些事情，那就是臭名昭著的手写数字识别教程，所以这一部分应该被覆盖(绿色边框)。但真的是这样吗？🧙
第三部剧透(如果一切顺利，我将在两周后出版):实际上比那要复杂一点，但是我找到了一个优雅的解决意外挫折的方法，如果我可以这么说的话，🧐. - 我们希望我们的系统能够处理在“自然”环境中拍摄的数独网格图像，而没有任何太强的约束。因此，我们必须对输入图像进行某种预处理，以便从杂志的整页中整齐地裁剪和旋转网格。加上促进负责数字识别的组件的工作所需的潜在的任何其他调整。
- 最后，如果我们能够以一种良好的格式呈现作品，比如说一个网络应用程序，你上传你的图像，它会与另一张图像一起显示在一边，显示谜题的解决方案，这将是一个不错的选择。边框是黄色的，因为虽然我过去做过类似的事情，但这不是我认为自己是专家的项目的一个方面，所以我想记住，这一部分可能比我更熟悉的部分需要更多的努力或研究。
进一步扩展第 3 点描述的活动，我们得到最终(可以这么说)的细分版本:
这甚至不是我的最终形式！
作者图片
目前这已经足够好了。在整个项目中，你可能会发现有些任务比你预期的复杂或多或少，或者它们必须被进一步分割成更小的任务。你甚至可能忘记了一些你在计划时没有想到的事情。这很正常，当你从一个产品的想法到实际实现它时，这是必然会发生的。
接下来是什么
暂时就这样了。我们仍然只写了 0 行代码，但是可以说任何项目中最重要的部分之一已经完成了。计划就像乐队中的贝斯手，只有当它不见了的时候你才会注意到它。在接下来的文章中，我将介绍如何实现上图中列出的所有任务，从数据接收/预处理开始。一周后见！
你的快乐很快就会成为遥远过去的记忆，凯伦阿姨。
【1】向这些年来与我同台的所有贝斯手道歉。你知道这是事实。
破坏数独——一个数据科学项目(第 2 部分:数据预处理)
在数据预处理中，您可以对输入图像进行调整，以便在后续步骤中使用。万一你觉得还没准备好，害怕把事情搞砸，记住这个发生的**。
Ecce Home，前、后、后After byCea。由 2.0 在 CC 下授权**
欢迎来到本系列文章的第二篇,该系列文章致力于如何利用数据科学作为惹恼一位不愉快的亲戚的借口！
摘要
本文是系列文章的一部分:
- 第一部分:简介和项目设计
- 第 2 部分:数据预处理—您正在阅读它！
- 第三部分:数字识别和数独解算器
- 第 4 部分:部署和追溯
图像预处理
数据预处理任务的分解。
作者图片
为了决定图像必须经过什么样的转换，有必要了解下一个组件(数字分类器)将需要什么样的格式。对于我们的例子，因为我们计划使用基于 MNIST 数据集的图像分类器，所以格式是 28 x 28 灰度图像，只包含一个数字。
如果输入图像只包含数独网格(我们将它分成 9 行 9 列)，识别 81 个单元格将是一个相对琐碎的任务*。然而，事实并非如此:理想情况下，我们希望用户能够用手机拍一张照片，然后传给应用程序。*
因此，我们需要一个额外的步骤，将网格从页面的其余内容中分离出来，补偿旋转，并裁剪边界。然而，要做到这一点，我们首先必须对图像进行一些标准调整，以便于下面的步骤。
原始输入图像。
作者图片
对图像的初始调整包括使用高斯滤波器和阈值的一些基本去噪，以去除大部分缺陷并获得二进制图像。我们还将反转颜色，因为这是用于执行几何操作的算法的要求，我们将使用该算法来检测网格并扭曲图像，使其最终成为正方形。
基本预处理(高斯滤波和阈值处理)后的输入图像。
作者图片
然后，我们必须首先确定网格所在的区域，然后应用所需的变换将其扭曲成正方形。这分两步完成，最终结果是这样的:
扭曲和裁剪后从图像中提取的网格。
作者图片
此时，将图像分割成 81 个单元格是微不足道的。任务完成[几乎]！
能偷多少就偷多少
关于时间管理的重要说明:上面的大部分代码不是我写的，而是取自各种来源，要么是 stackoverflow 评论，要么是 quadrillions 之一“用深度学习解决数独！”在媒体上或其他地方的教程。见鬼，我甚至不完全理解它的某些部分，我只是玩玩它，直到我足够信任它可以工作，并且在这个过程中不会烧坏我的电脑。
在这个星球上生活了 36 年，看了无数集《神秘博士》,我明白了一件事:时间是一种资源，通常情况下，你没有足够的时间。所以请允许我尽可能明确地说:
不要重新发明该死的轮子。
如果一个任务足够具体，很可能在某个黑暗的房间里已经有人写了一段代码来解决它。所以去抓住它，而不是花几个小时自己实现它。
最后一笔
快好了。我们仍然有一个问题:如果你只是通过将图像水平和垂直划分为 9 个部分来分割图像，其中一些可能会包含部分边界，如果你的数字分类器不是最擅长的，这可能会是一个问题。
看着你，字面上任何训练有素的分类器对 MNIST 。
因此，在我们进入有趣的部分之前，我们消耗了大量的精力，只是为了看到 Karen 阿姨脸上的笑容消失，花几行代码来识别并从网格中删除剩菜是一个好主意。
最后的预处理步骤:从原始单元格(左)中，我们首先从网格中删除可能保留的块(中)，最后将其大小调整为 28 x 28 像素(右)，因为这是我们将要使用的分类器的预期图像大小。
作者图片
就这些了，伙计们
暂时就这样了。你可以找到我在这个仓库中使用的 jupyter 笔记本，然而上面的要点涵盖了所有必要的(和有趣的部分)。
下周，是时候我们打开图形处理器，让神经元滚动:没有数字会保持不被识别。
[1]我们最终将使用与略有不同的东西*，但在我计划的时候，这似乎是一个合理的选择，所以我暂时这么称呼它。*
[2]我开始尝试复杂的东西，结果每边只剪了 10%左右。很管用。
破坏数独——一个数据科学项目(第三部分:数字识别和数独求解器)
数字五。或者，根据每一个训练有素的 MNIST 分类器，一个 6。或者八，或者蝙蝠侠的标志，为什么不呢。瑞安·约翰斯在 Unsplash 上拍摄的照片
好吧，这是你真正关心的一篇文章，其中 GPU 升温和损耗曲线是平坦的:今天我们将讨论该项目的两个核心部分，即如何识别九个数字中的哪一个出现在每个数独单元中，我们事先识别并分离了这些数字(查看本系列的第二篇文章中的细节)，并从那里着手解决这个难题。哦，我们还会用 2020 年的魔法 : AI 。
但首先，快速回顾一下我们是如何走到这一步的。
之前(和下周)，在这个系列中
- 第一部分:简介和项目设计
- 第二部分:数据预处理
- 第 3 部分:数字识别和数独求解器——你正在阅读！
- 第 4 部分:部署和追溯
弗兰克·维西亚在 Unsplash 拍摄的照片
我们从一个相对简单的想法开始:设计并实现一个系统，该系统将一张数独网格清晰可见(但不一定对齐/居中)的图片作为输入，并返回该谜题的解。
我们花了相当多的时间来组织我们的工作，以便我们至少对各种任务的难度有一个粗略的想法(因此我们必须分配给每一项任务多少时间)，并且我们处理了第一个主要的工作包，数据预处理。
现在，我们相信我们的系统正确地处理了输入图像，并把网格中的 81 个单元干净整洁地分开了:是时候做有趣的事情了。
第二步:解决数独
如果你正在读这篇文章，你可能很擅长数学，因此会注意到我把第二步放在第一步之前，尽管 2 被一致认为大于 1。我发誓这是有原因的。
如果你还记得的话，在计划的时候，我给每一个子任务分配了一个估计的难度等级，红色代表我所知甚少或者一无所知的子任务。解算器就是其中之一。虽然我几乎可以肯定在 Github repo 中有一种算法形式的解决方案，但我还没有正确地搜索它，所以我不愿意想当然地在专注于数字识别任务之前研究这一部分，另一方面，我认为我知道如何解决这个问题。哦，讽刺的是。
最终项目组织结构图。颜色表示估计的难度。
作者图片
无论如何，一个简短的搜索就足以找到一个片段，它确实做到了这一点，所以这一整节的目的只是为了强调关注你对首先不太有信心的地方的重要性，以便通过找到一个解决方案(比如在这种情况下)或找到一些变通办法来尽早摆脱这种不确定性。
第一步:识别数字
在这一点上唯一缺少的是数字分类器，一旦插入我们的系统，这个项目基本上就结束了。
我预计这是一个相对容易的部分:每个接触深度学习的人，特别是 CNN 的人，都必须经历在臭名昭著的手写数字识别数据集 MNIST 上训练模型的初始仪式，并且可以在睡梦中产生这样的分类器，所以我确实这样做了。
不幸的是，虽然在 MNIST 的测试集上表现得相当好，但在流水线的前一步中产生的实际图像(包含一位数字的孤立单元网格)上的结果至少可以说是相当令人失望的。当然，大多数时候它仍然是正确的，但是请记住，为了让这个系统工作，即使一个错误也会导致不正确的结果。在这个项目中，我遇到了第一个真正的障碍，不得不去处理它。
两步故障排除
糟透了，但这种事时有发生。为了解决这样的问题，我尝试回答以下两个问题:
- 为什么它不起作用？
- 我能做些什么呢？
为了回答第一个问题，并找出为什么我的表现如此糟糕(相对而言)，我分析了被错误分类的图像，注意到大多数错误发生在数字 1 上，它经常(错误地)被标记为 7 。在其他情况下，图像有某种噪声(小块非黑色像素)，预处理步骤没有去除这些噪声，这显然足以混淆模型并产生错误的预测，尽管数字本身在图像中显示得很清楚！
左侧是来自 MNIST 数据集的数字 1 的样本。在右边，从实际的数独网格中提取的 1。尽管非常相似，但在 MNIST 上训练的分类器可能无法正确分类右边的那个，而是预测为 7。作者图片
老实说，这并没有真的让我吃惊:我对 MNIST 数据集有严重的问题，我写了一篇> 1000 字的长篇大论，为什么它是着火的垃圾。简而言之，虽然它是对图像分类问题的一个很好的介绍，但当应用于一种与大多数在线教程中呈现的问题略有不同的问题时(数字打印的数字而不是手写的数字)，它并不真正起作用。
我设计的解决方案基于一个神圣的原则，即你应该尽最大努力训练一个数据模型，这个数据与你希望模型工作的数据尽可能相似。如果你在为你的下一个额头纹身寻找报价，请考虑前面的句子。
我所做的是使用 Python PIL 包生成一个合成数据集，在一个正方形画布上以略微不同的大小和位置绘制各个数字。对于每张图片，都从与杂志中使用的字体最相似的列表中选择一种字体，以提高模型的泛化能力。此外，这些图像是在模型训练时动态创建的因此不需要磁盘空间，因为它们没有被保存。
这种生成数据的方式，加上一些标准的数据扩充(实际上只是旋转，加上一些定制的椒盐噪声，以使其对图像中的缺陷具有抵抗力)，产生了一个模型，尽管并不完美，但产生了明显更好的结果。
还有一个小细节需要讨论:数字分类器可以识别从 0 到 9 的数字，但是数独单元格要么包含从 1 到 9 的数字要么为空。我发现处理这种情况的最简单的方法是首先使用一些试探法来查看单元格中是否有任何东西(通过简单地计数有多少像素与背景颜色不同，并确定一些合理的阈值)，并且只有在实际分类中有一些东西在进行时。这有一个额外的好处，即避免在无用的计算上浪费大量的时间和资源(计算白色像素比在 CNN 上运行推理要便宜得多)。
无聊(但是有用！)工具/物流 blabla
在我回到我的 Factorio megabase 之前，我想多说几句我在这个项目中使用的工具。
我真的不想卷入整个文本编辑器/IDE 帮派战争，已经流了太多的血。我个人使用 Vim(有大量插件，检查我的)。vimrc 如果你感兴趣的话)因为我超级老了但是我对这个话题没有强烈的看法，用什么让你开心。
另一方面，最近我一直在使用一个实验跟踪/簿记工具来跟踪正在运行/已经完成的实验。即使对于像这样的超小型项目，我也建议使用它，因为它会以增加几行代码为代价，使您的生活变得更加简单。有几个工具，我个人很喜欢，也想建议使用神圣的(加上综合可视化)。
最后，这是一个简单的问题，Jupyter 笔记本非常适合数据探索和快速原型制作。使用它们！
搞定了。
就是这样！这次是真的！流水线现在完成了，我们有了从原始输入图像到谜题解决方案的清晰路径。下周，我们将通过使用 Docker 将其打包成 web 应用程序的形式来完成该项目。
你可以在 this Github repo 中找到这一系列文章的笔记本和代码。
七天后见！
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/matteobarbieri/sudoku)
破坏数独——一个数据科学项目(第 4 部分:部署和恢复)
这不是我。我希望我也这么可爱。
Photo by 大家好，我是尼克🎞号上的 Unsplash
如果你偶然看到这篇文章，我强烈建议你从这个系列的第一部分开始，原因很明显。
这是他们旅程的终点(谁？)说。我们的计划是记录从一个想法到一个产品所需的活动，尽管这是一个简单且范围有限的活动，我们也这样做了。我尊重时间表！
别谢我，真正的英雄不需要那个。
本系列的其他文章
- 第一部分:简介和项目设计
- 第二部分:数据预处理
- 第三部分:数字识别和数独解算器
- 第 4 部分:部署和恢复—您正在阅读这篇文章！
简单回顾一下，现在我们已经完成了从图像到数独谜题答案的数据管道。今天，我们通过设置一个漂亮的基于 web 的前端来包装我们的产品，从而结束了这个循环。
然而，在我们开始之前，一个快速的前提。
没有独角兽这种东西
我所说的独角兽是指在非常优秀的人，拥有数据科学项目所需的所有技能，即项目管理、前端和后端开发、机器学习工程，甚至更多。
我认为自己在 Python 编程和机器学习相关的东西方面相当熟练，但是至少可以说，我对于如何最好地部署一个应用程序(比如我在本系列中所做的那个)的知识是有限的。这意味着，当然，我可以把一些可能有用的东西放在一起，而不会让整个服务器机房着火，但是很可能任何熟练的都会发现我的实现充其量是次优的。
因此，不要期望这个特定的部分是你可能找到的关于如何部署产品的最好的指南，把它作为一个快速原型，以一种整体体面的方式完成工作。
【不那么】动态二人组:前端+后端
尽管不想在这一部分花太多时间(主要是因为我在这个特定任务中缺乏专业知识，所以效率不是特别高)，但我仍然想将负责显示内容的前端，与负责繁重工作的后端(基本上是我到目前为止描述的所有代码)分开。当然这里有点矫枉过正，但它符合“真实开发应用程序”的模拟场景。最终的系统将如下所示:
用户上传一张与前端交互的图片，前端将图片传递给后端进行处理。然后，结果被传回前端并显示给用户。因为我不会画画，所以人类在这里就像钻石，因为他们都是由碳构成的。图片作者。
我选择使用 flask 作为后端，因为我已经很熟悉它了，它可以很好地与用 Python 编写的其余代码配合使用，我选择使用 Node.js 作为前端，因为我从来没有借口玩它，这似乎是一个很好的选择。
我真的不想太详细地介绍我是如何做的，因为这里真的没有什么特别聪明的地方，只是你通常对前端的 HTML/JS/CSS ( bootstrap )和异步请求的混合，以及后端的超级标准推理功能，加上一点点 PIL 魔法来绘制原始网格上的解决方案(即缺失的数字)。它看起来是这样的:
一个来自前端的解决了的难题的截屏。请注意，输入图像实际上是一本杂志的一整页，但是为了便于比较，我只包括了裁剪过的网格。作者图片
像往常一样，你会在这个项目的回购中找到代码。注意，为了让系统工作，你必须自己训练一个模型(按照本系列的前一篇文章中的说明)或者下载我训练的那个模型(在 repo 中有一个叫做download_data.sh的脚本可以做到这一点)。您还需要用于在输出图像上书写数字的.ttf字体文件(这也由脚本负责)。
将所有的事情归档
如果我是负责人，我会把不通过 docker 容器或类似的东西来部署东西的任何方式都定为非法。我不是在说“你被罚款”是违法的，我说的是最起码的无期徒刑。
强制容器图片。
照片由马克西姆·霍拉维尔在 Unsplash 拍摄
因此，为了使部署尽可能不痛苦，我为两个服务(后端和前端)中的每一个创建了一个映像，并用 docker-compose 编排它们。同样，这里没有什么特别的，只有标准的设置来显示正确的端口并安装包含所需数据(模型和字体)的文件夹。
就这样，我们结束了！不过，还有一件事。
重新流行
Sebastiano Piazzi 在 Unsplash 上拍摄的照片
这是一个很好的实践，一旦一个项目(或者甚至是它的一部分)已经完成，回顾一下什么做得好，什么做得不好，这样下次你就可以改进和做得更好。这被称为“进行追溯”(“追溯”的简称)。
什么进展顺利
我真的觉得我应该受到表扬。花大量时间做计划最终得到了回报:一旦决定了要做的事情，就只需要使用你觉得舒服的任何任务管理解决方案来组织工作了(我是一个超级酒鬼)，当然还要找时间去做。
除了我们将在下一段讨论的一个小例外，一切都进行得或多或少很顺利。
什么不太顺利
唯一出现一些意外挑战的部分是数字识别组件的实现。无需过多讨论细节(您可以在专门讨论该部分的文章中找到更深入的讨论)，我最初计划使用的方法并不像预期的那样有效，因此有必要找到一条替代路线。
老实说，我认为这更像是一个“学习机会”，而不是规划时的一个实际错误，因为提前预见数据或给定方法的问题是不可能的，也因为它迫使我找到一个优雅的解决方案，否则我不会想到，这是一个我将带到未来项目中的经验。
作者的最后一句话
我写这个系列来挑战我自己，以产生我希望你会发现是高质量的内容，带有相当数量的幽默，使它可以忍受。我试过了(显然成功了，耶，我！)每周一写一篇新文章，以避免势头减弱。
请随时通过 LinkedIn 与我联系，我总是渴望与任何对此感兴趣的人讨论数据科学相关的话题。
此外，如果你是一名数据科学家新手或想成为数据科学家的人，却不知道该怎么做才能在这个神奇的行业找到一份工作，给我写封短信:我非常乐意给你这方面的建议🙃
感谢阅读！
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/matteobarbieri/sudoku) [## 马特奥·巴比耶里-数据科学家-佩尔塔里昂| LinkedIn
数据科学家，深度学习爱好者，Python 爱好者。我获得了计算机科学博士学位，主要研究分析…
www.linkedin.com](https://www.linkedin.com/in/barbierimatteo/)
Python 中基于规则的 App Store 评论情感分析
利用“VADER”来识别基于用户评论的用户情绪
通过阅读这篇文章，您将学会用 Python 分析和执行基于规则的情感分析。我们将使用名为VADER的Python包，并在一款名为 Clash of Clan 的手机游戏的 app store 用户评论数据集上测试它。
基于官方文档，VADER (Valence Aware 字典和情感推理器)是:
…一个基于词汇和规则的情绪分析工具，专门针对社交媒体中表达的情绪*。*
与传统的机器学习方法不同，VADER使用的方法是针对社交媒体帖子的。它可能不太适合文学或新闻文章。然而，一个主要的优点是推理时间非常快，您可以在简单的笔记本电脑上顺利运行。
本教程有 3 个部分:
- 设置
- 履行
- 结论
让我们继续下一部分，开始安装必要的模块。
1.设置
Python 包
你可以通过pip install在 Python 中轻松安装VADER。强烈建议您在继续安装之前创建一个虚拟环境。激活您的虚拟环境并运行以下命令。
pip install vaderSentiment
在读取数据集时，我们还需要另一个名为pandas的模块。通过以下命令安装它:
pip install pandas
资料组
转到下面的链接，将整个数据集下载到项目的根目录下。您应该有一个名为clash-of-clans.csv的csv文件，其中包含以下数据。
在下一节中，我们将编写一些 Python 代码。
2.履行
在本教程中，我将使用Jupyter Notebook。话虽如此，您也可以在一个Python文件中正常运行它。
导入
在文件的顶部添加以下导入声明。
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
import pandas as pd
初始化
接下来，初始化SentimentIntensityAnalyzer类的一个实例。我们将在每次计算或分析文本的情感时重用这个实例。
analyzer = SentimentIntensityAnalyzer()
数据帧
确保clash-of-clan.csv和你的文件在同一个目录下。通过read_csv函数加载数据集。如果您将文件存储在其他位置，请修改文件的路径。
df_coc = pd.read_csv("./clash-of-clans.csv", encoding="utf-8")
df_coc.head()
您应该在控制台上看到以下输出。如果您运行的是 Python 文件而不是 Jupyter Notebook，格式可能会略有不同。
情感分析
你可以通过这个模块提供的polarity_scores函数来计算单个文本的情感。
vs = analyzer.polarity_scores('I felt terrible today')
print(vs)
您将得到一个包含 4 个键/值对的字典，如下所示:
{'neg': 0.508, 'neu': 0.492, 'pos': 0.0, 'compound': -0.4767}
供你参考，
pos、neu和neg分数是属于每个类别的文本的比例(因此这些应该加起来都是 1…或者用浮动操作接近它)。如果你想对一个给定的句子进行多维度的情感测量，这些是最有用的指标。
compound分数是通过对词典中每个单词的化合价分数求和来计算的，根据规则进行调整，然后归一化到-1(最极端的负面)和+1(最极端的正面)之间。如果你想对一个给定的句子进行单一的一维情感测量，这是最有用的度量。称之为“标准化加权综合得分”是准确的。
通常，阈值设置如下:
positive—compound得分≥ 0.05negative—compound得分≤ -0.05neutral—compound在-0.05 和 0.05 之间
创建一个新函数，并在其中插入以下代码。这个函数接受一个输入文本，并基于复合分数返回文本的情感。情感标签包括:
positive— 2neutral— 1negative— 0junk——-1
def calc_vader_sentiment(text):
sentiment = 1 vs = analyzer.polarity_scores(str(text))
compound = vs['compound'] if(compound == 0):
sentiment = -1
elif(compound >= 0.05):
sentiment = 2
elif(compound <= -0.05):
sentiment = 0 return sentiment
一旦创建了上面的函数，创建一个新的由三列组成的DataFrame:
uid—数据的唯一标识符。我们将使用索引作为 uidtext—用户评论的文本label—情感分析得分
运行列表理解中的calc_vader_sentiment函数如下
df = pd.DataFrame({
'uid': list(df_coc.index.values),
'text': df_coc['Content'],
'label': [calc_vader_sentiment(x) for x in df_coc['Content']]
})
它应该需要几秒钟来计算分数，因为我们有大约 50000 行数据。通过运行下面的代码，您可以简单地查看前 10 个结果。
df.head(10)
您应该会得到以下结果。
保存到文件
如果你想把它保存到一个文件中，你可以通过 pandas 模块提供的to_csv函数来完成。根据您的偏好修改文件的名称。
df.to_csv("sentiment_result.csv", encoding='utf8', index=False)
3.结论
让我们回顾一下今天所学的内容。
我们首先简要介绍了VADER及其功能。然后，我们通过 pip install 安装了必要的模块，并从Kaggle下载了clash-of-clan.csv数据集。
之后，我们继续实现我们自己的代码，通过使用由VADER计算的复合分数来计算用户评论的情感分数。
除此之外，我们还学会了将最终输出保存到一个 csv 文件中，以供将来参考。
感谢你阅读这篇文章。希望在下一篇文章中再见到你！
参考
使用 Supervisor 在单个 Docker 容器中运行多个服务
您是否曾经遇到过这种情况，您希望在同一个容器中运行两个或更多的轻量级服务？
虽然 Docker 提供了一个 Docker-compose 工具，用于在多个容器中构建和运行多服务应用程序。Docker-compose 需要一个 YAML 文件来配置您的多个服务。但是有时我们希望在同一个容器中运行两个或更多的轻量级服务。
在本文中，我将解释如何使用“Supervisor”工具在同一个 docker 容器中启动多个服务。
那么什么是主管呢？
管理程序是一种工具，它允许我们像操作系统一样在 Linux 中同时管理多个不同的进程。监督工具需要一个*。conf* 文件，我们在其中指定进程和与该进程相关的不同选项，如输出日志位置、自动启动、自动重启等。
我将使用的示例服务
我将在同一个容器中运行两个不同的服务“运行 Django app 的 Gunicorn 服务器”和“Redis 服务器”。因此，在我创建的示例项目中，包含一个简单的 Django REST API，用于从 Redis 服务器添加和获取数据。在生产环境中，这两个服务在具有生产级配置的独立容器中使用。为了便于演示，我将在一个 docker 容器中运行这两个服务。
项目目录结构
开始构建项目的一个好方法是拥有一个整洁清晰的项目结构。因此，考虑到这一点，我们将使用下面的代码目录结构:
multi_service
├── django_app
│ ├── db.sqlite3
│ ├── django_app
│ ├── manage.py
│ ├── redis_test
│ └── requirements.txt
├── Dockerfile
└── supervisor
└── service_script.conf
在本地测试我们的服务(Django App 和 Redis)
在 docker 中发布服务之前，首先，让我们在本地测试它们。您可以使用下面的链接从 GitHub 下载完整的项目。
网址:https://github.com/aakash-rathore/docker_multi_services.git
要测试 Redis 服务器，只需使用以下命令下载它:
Using apt package installer
$ sudo apt-get install redis-server
# Use apk add (For alpine linux)
# apk add redis
现在使用以下命令运行服务器:
$ redis-serve
您将看到服务正在运行:
本地 redis 服务器测试
为了在本地测试 Django 应用程序，我们将使用 Gunicorn 服务器。使用以下命令在 gunicorn 服务器中运行应用程序:
$ gunicorn --bind 0.0.0.0:8000 django_app.wsgi
该命令的输出如下所示:
在本地运行 gunicorn
主管配置文件
按照上面指定的目录结构创建一个文件***【service _ script . conf】***。按照下面的配置添加 django 和 redis 服务:
## service_script.conf
[supervisord] ## This is the main process for the Supervisor
nodaemon=true ## This setting is to specify that we are not running in daemon mode
[program:redis_script] ## This is the part where we give the name and add config for our 1st service
command=redis-server ## This is the main command to run our 1st service
autorestart=true ## This setting specifies that the supervisor will restart the service in case of failure
stderr_logfile=/dev/stdout ## This setting specifies that the supervisor will log the errors in the standard output
stderr_logfile_maxbytes = 0
stdout_logfile=/dev/stdout ## This setting specifies that the supervisor will log the output in the standard output
stdout_logfile_maxbytes = 0
## same setting for 2nd service
[program:django_service]
command=gunicorn --bind 0.0.0.0:8000 django_app.wsgi
autostart=true
autorestart=true
stderr_logfile=/dev/stdout
stderr_logfile_maxbytes = 0
stdout_logfile=/dev/stdout
stdout_logfile_maxbytes = 0
docker 文件创建
现在我们将开始制作 docker 文件。添加图层的步骤如下:
基础镜像- >安装所需工具- >添加源代码- >添加配置文件- >启动服务
最终 Dockerfile 如下:
# Base Image
FROM alpine
# Installing required tools
RUN apk --update add nano supervisor python3 redis
# Adding Django Source code to container
ADD /django_app /src/django_app
# Adding supervisor configuration file to container
ADD /supervisor /src/supervisor
# Installing required python modules for app
RUN pip3 install -r /src/django_app/requirements.txt
# Exposing container port for binding with host
EXPOSE 8000
# Using Django app directory as home
WORKDIR /src/django_app
# Initializing Redis server and Gunicorn server from supervisord
CMD ["supervisord","-c","/src/supervisor/service_script.conf"]
构建和测试
最后，使用下面的命令构建 docker 映像:
$ docker build -t multi_service:1 .
成功构建操作后的输出:
docker 构建成功
现在使用上面构建的映像运行 docker 容器:
$ docker run -it -p 8000:8000 multi_service:1
这里 docker 容器是在非守护模式下运行的如果你想在守护模式下运行它使用 ‘-d’ 选项，上面命令的输出:
运行 docker 的输出
让我们在 API 测试工具中测试 django 应用程序，我使用的是一个轻量级的“高级 REST 客户端”,可以在 Google Chrome 扩展商店中找到。您可以使用 Postman、Curl 或任何其他工具进行测试:
测试添加用户功能:
测试添加用户功能
测试获取用户:
测试提取用户功能
结论
在本文中，我解释了如何在一个 docker 容器中运行多个服务(Django app 和 Redis server)。最后，我们还做了一些测试来检查这两个服务是否都在运行。
请在下面留下您对本文的评论，如果您在上面指定的任何步骤中遇到问题，您可以通过 Instagram 和LinkedIn联系我。
使用 Python 原生编译 Julia 代码
通过切换语言来加速 Python
我经常讨论使用 Julia 的好处，因为有很多好处。Julia 是一种可扩展的、高性能的高级语言，易于学习，几乎可以完成任何工作。对于数据科学家来说尤其如此，因为 Julia 的重心是统计计算和函数程序。在 Julia 的核心，它是一种为科学家用数据做统计而创造的语言，这种直接的意图使它在特定的事情上非常棒。
虽然我可以花很多年谈论 Julia 如何更快，具有更好的浮点精度，并且打字非常简单，但这不是我今天在这里的原因。虽然我已经表达了我的担忧，也可能夸大了我对朱莉娅的喜爱，但有一个大话题我还没有和朱莉娅谈过:
多才多艺
使用 Python 语言的一个巨大好处是 Python 是通用的。如果你不想使用 web 请求，可能有一个包装器，如果你想把时间戳从 Unix 转换成 UTC，有一个库。这是一个很大的好处，因为这意味着你的语言将永远支持你的工具。我已经提到过 Julia 的包是它最大的缺陷，但尽管如此，Julia 最初是在 2012 年发布的，也就是 8 年前。朱莉娅反驳说:
可翻译。
首先，我们有令人惊奇的包 PyCall.jl，它允许调用 Python 包，甚至在虚拟环境中。在数据科学领域，能够调用数百万个 Python 包是一件大事。
布丁中真正的水果是，反过来也是可能的。没错，从 Python 本地运行 Julia 非常容易。这很重要，因为我们都知道 Python 有时会相当慢。我承认，在大多数情况下，Python 很棒，但是当 Python 让你失望时，它真的会让你进退两难，不知道下一步该做什么。
PyJulia 或 julia.py 允许您发送类似 SQL 查询的代码行，并为实际返回标识一个返回变量。简而言之，你可以通过向 Julia 编译器发送字符串来运行 Python 中的 Julia。当然，第一步是从您的包管理器中获取 Julia，我将使用 APT。
sudo apt-get install julia
现在它就像进入朱莉娅 REPL，然后安装 PyCall 与]或使用 Pkg 一样简单。
julia
julia> using Pkg; Pkg.add("PyCall")
(or)
julia> ]
pkg> add "PyCall"
对于一些 Julia 包，包括 PyCall，我推荐构建代码:
julia> ]
pkg> build "PyCall"
现在，用退格键退出 Pkg，按 ctrl/command+D 退出朱莉娅 press。我们现在可以用 pip 安装我们的 Python 包了，我将使用 pip3。
sudo pip3 install julia
既然我们所有的依赖关系都得到了满足，我们就可以跳到笔记本上进行尝试了！第一步是使用 Julia 库中的安装方法:
import julia as jl
jl.install()
现在我们可以导入 Julia 可执行文件，并用它运行字符串代码！
from julia import Julia
jl = Julia()
average = jl.run("using Lathe.stats: mean; array = [1,5,4,5,6]; m = mean(array); return(m)")
所以…酷！
但这意味着什么呢？嗯，任何用 Julia 开发的包都可以用 Python 开发。不仅如此，该包还可以在 R 中与 JuliaCall.R 一起使用。我已经开始为 Julia 的车床机器学习模块开发包装器，这些包装器将在 native Julia 下与 Python 和 R 一起使用。我真的很高兴 Julia 代码既更快，又同时使该包在最流行的统计语言中通用。这对 Julia 开发者来说是一个很大的好处，因为我们不必为了维护一个 Python 和 R 版本而重写代码。当然，随之而来的是在编译时使用 Julia 而不是 Python 的实际好处。
下降趋势
在计算中没有什么是如此简单的，所以用这种了不起的方法翻译代码，也有一些不幸的问题。虽然很少，但我承认必须安装 Julia 和 PyCall 依赖项有点乏味，特别是对于一个以前从未使用过 Julia 的 Python 包的最终用户来说。此外，Julia 的版本控制和兼容性给这个包带来了很大的问题，让 PyJulia 运行起来可能会很困难。我遇到的问题主要是在 Unix 所有权中，编译器在我的非所有目录(由 root 所有)中，由于权限被拒绝，我将得到退出状态 1。
这当然是通过在我的 Python 位置上使用 chown 并在 Julia 的情况下做同样的事情来解决的。
除了这个问题，还有它的写作方式，有点乏味。诚实地说，通过字符串发送单行代码并不是最理想的，如果你打算在代码中使用引号，并使用字符串，那么在 Python 中的“、”和”之间导航将会非常困难。没什么大不了的，但绝对是需要注意的。
结论
总之，多才多艺是朱莉娅的一大优势。Julia 代码不仅速度快，而且扩展性极强，还可以写成其他语言。这是一个很大的优势，因为您的 mill Julia 包可以在一个包装器中轻松运行，并且当它在本地系统上更新时，可以与原始的 Julia 包一致地更新，所以…酷！我非常期待能让 R 和 Python 都了解 Lathe，这样更多的人就能使用 Lathe，并希望能喜欢上它。
在网站上运行 Python 代码:探索 Brython
Python 中的 JavaScript 等效脚本
作为 Python 的长期追随者，我从未停止对这种语言的探索，每天都在寻找它的实现。在一个晴朗的日子里，我了解了旨在取代 Javascript 的 web 脚本的 Brython。它允许你在网页上直接使用 Python 脚本来处理 DOM(文档对象模型)元素和事件，全部使用我们最喜欢的语言 Python。让我们深入了解如何为你的下一个项目实现这样的脚本，以及我是如何使用这项技术赢得比赛(第二名)的！
在此之前，如果你想探索 Python 的 android 方面，那么一定要看看我在 Medium 上的 Python 系列中的 Android 应用程序。
[## 用 Python 构建 Android 应用程序:第 1 部分
使用 Python 构建 Android 应用程序的分步指南
towardsdatascience.com](/building-android-apps-with-python-part-1-603820bebde8) 
什么是 Brython？
Javascript 被认为是支持网页交互性的网络语言。没有人想浏览可以用 HTML 和一点 CSS 构建的静态页面。Brython 提供了一种使用 Python 与网页元素进行交互的直观方式。在过去，python 也在使用 Django/Flask 的后端脚本中得到应用，允许用户快速开发可扩展的网站。而 Bython 也专注于在客户端应用这一点。从 Brython 开始，您有两种选择:
您在本地下载 Brython 包，然后将它包含在您的文件中。这可以使用 pip 来完成:
pip install brython
然后在一个空文件夹中，
brython-cli --install
或者，
直接使用 Brython CDN，它会在新的更新发布后立即更新，让您不必手动更新软件包。
<script src="https://cdn.jsdelivr.net/npm/brython@3.8.10/brython.min.js"> </script> <script src="https://cdn.jsdelivr.net/npm/brython@3.8.10/brython_stdlib.js"> </script>
使用 Brython 做一些基本的事情
让我们复习一些基础知识，开始开发一些很酷的项目。请注意，这要求您对 DOM 有一个基本的了解，熟悉基本的 Javascript 将是一个加分项，尽管不是必需的。在您的 IDE 中，填充一个基本的 HTML 代码，放置一个输入字段和一个带有 id 的 span 标记。另外，使用 script 标记添加 Brython CDN。它可能应该是这样的:
作者代码
现在，使用 Python 脚本将这个输入事件绑定到 span 标记。为此，我们将使用浏览器中的文档。任何类型的脚本都将封装在 text/python 类型的脚本标签中，这也可以在 body 标签下定义。需要做的另一个更改是在 body 标记()中包含 οnlοad=“brython()”。这是一个脚本，它将使我们能够实时显示文本:
作者代码
这里，我们使用了浏览器模块中的文档对象将输入(文本)的 id 绑定到函数 show_text()。这个函数使用它们的 id 将输入标记的值分配给 span 标记。这里有一个 GIF 来展示这个 HTML 页面在加载浏览器时做了什么:
作者 GIF
再举个例子！
让我们看另一个例子，看看如何使用 Brython 进行 API 调用，这是最令人兴奋的部分。考虑一个场景，您希望主持一个基于 web 的机器学习项目。您创建了一个模型，现在将它作为 API 在任何云平台上使用，比如 Heroku、GCP 或 AWS。作为一名 python 开发人员，您可能不太熟悉 web 开发，并且发现很难处理网站的延迟响应或缓慢加载。你可以使用 GitHub 页面轻松托管你的网站，但它不支持 flask 或 Django 框架(目前)。
为了处理这种情况，您可以轻松地创建一个基本的 HTML 网页(或者使用一点 CSS 从 bootstrap 获得帮助)，要求用户输入所需的参数，然后您的 Brython 脚本向您的模型主机发出请求，您在网页上显示结果。这将有利于网站托管在 GitHub 上，使管理代码库更容易，而且它将一直运行。让我们来看一下创建一个 API 调用来返回一个随机笑话的脚本:
作者代码
首先，查看该文件的输出:
作者 GIF
这里，get joke 按钮被绑定到 API 调用函数，该函数对服务器进行 AJAX 调用，返回结果，然后呈现给显示标签。
获胜的剧本
我得到的问题陈述是从给定的 API 中获取歌词，并在网络上显示出来。它需要音乐艺术家作者和我们想要歌词的标题/歌曲名。下面是同样的 GIF:
作者 GIF
如果你想探究这个的源代码，那么这里有 GitHub 库链接。
结论
我们看到了如何使用 Brython 将基于 python 的脚本直接实现到网页中。毫无疑问，就速度、可用性、代码的可维护性和理解性而言，目前 Javascript 是不可替代的。这些 python 脚本需要熟悉 DOM，而只有使用 JS 才能更好地练习和理解 DOM。这最适合那些希望在 web 上展示其后端和前端 python 技能的人。很多人都用 Pygame 和海龟库做过游戏、图形。你可以在谷歌上了解更多。
这就是我的观点，在 medium 上关注我可以收到更多类似这些有趣文章的通知。说完了，合十礼！
更新:Brython 的高级使用案例—
[## Python 在前端:使用 Brython 的 ML 模型 Web 界面
本文作为数据科学博客简介的一部分发表，机器学习是一个迷人的领域…
www.analyticsvidhya.com](https://www.analyticsvidhya.com/blog/2021/07/python-on-frontend-ml-models-web-interface-with-brython/)
一些链接:
使用 Python 和基本前端的 Dockerized GitHub 动作。
towardsdatascience.com](/github-action-that-automates-portfolio-generation-bc15835862dc) [## 家庭团体有那么糟糕吗？结果会让你震惊
分析 WhatsApp 群聊&构建网络应用
towardsdatascience.com](/is-family-group-that-bad-results-will-shock-you-573f64e194be) [## Kaustubh Gupta -机器学习作家- upGrad | LinkedIn
嗨，我是一名 Python 开发人员，能够进行 Web 抓取、Selenium 自动化、数据科学、后端 Web 开发…
www.linkedin.com](https://www.linkedin.com/in/kaustubh-gupta-612767ab/)
在 Sublime Text (Mac)上运行 Python 3
只需要一分钟
弗洛里安·奥利佛在 Unsplash 上拍摄的背景照片
Sublime Text 是编程中使用最广泛的轻量级文本编辑器之一。如果你是一个 Python 程序员，你可能没有运行你喜欢的 Python 版本。本教程解释了如何运行 Python 3.7 获得 Sublime 文本。
如果你喜欢视频教程，这是我的 YouTube 视频:
检查您的 Sublime 文本使用的是哪个版本
创建新的 Python 文件。我把我的**命名为 scratch.py。在运行 Python 代码之前，将文件保存为. py 扩展名是很重要的。**否则，你将无法执行 Python 代码。此外，拥有一个临时 Python 文件来运行快速代码总是好的。
现在键入以下代码:
import sys
print(sys.version)
要运行代码，请按下命令 B 或转到工具- >构建。
如你所见，我的崇高文本运行的是 Python 2.7。要将此更改为 Python 3.7，我们必须添加一个“构建系统。”
添加 Python 3 作为构建系统
转到工具->构建系统->新建构建系统…
注意，在我的构建系统列表中，我有 Python 和 Python 3。Python 自动来，运行 2.7。Python3 是我们要添加的。
一旦你点击新建构建系统… 你将被带到一个名为 untitled.sublime-build 的新窗口。
我们需要更改花括号之间的文本。首先删除括号中的代码。接下来复制并粘贴以下代码:
"cmd": ["python3", "-i", "-u", "$file"],
"file_regex": "^[ ]File \"(...?)\", line ([0-9]*)",
"selector": "source.python"
您可能需要按 Tab 键来缩进第二行和第三行。现在按下命令 S 保存文件。将该文件重命名为您希望称为构建系统的名称。简明易懂的东西。我把我的命名为 Python3 。注意，不要改扩展名，必须是。宏伟的建筑。也不要改变路径。 Sublime Text 默认会把它放在正确的路径上。
一旦你点击保存，关闭文件，这样你就回到了你的 scratch.py 文件。现在转到 Tools - > Build System，选择 Python3(或任何您命名的构建系统)。如果你没有看到你的新构建系统，你可能需要退出 Sublime Text 并重新打开它。
现在运行相同的代码来测试您使用的 Python 版本。
这就对了，Python 3.7 开始运行了。编码快乐！
如果你想看我在 Sublime Text 中运行 python 3 的视频教程，请点击这个链接:https://youtu.be/IprbE2C_rsEv
立即在 AWS Spot 实例上运行 StyleGAN2 ADA
在 AWS 上运行 StyleGAN2，与预训练的模型一起玩，或者从头开始训练一个模型。
示例使用有限数量的训练数据为几个数据集生成图像，使用 StyleGAN2 ADA 进行训练(图像来自“使用有限数据训练生成式对抗网络”论文)。
介绍
最近 NVIDIA 发表了一篇名为“用有限数据训练生成对抗网络的论文，并发布了代码。他们提出了一种自适应鉴别器增强(ADA)机制，可以稳定 StyleGAN2 训练，并在小数据集上取得明显更好的结果。
在本文中，我们将展示如何在 AWS Spot 实例上快速运行这段代码。
启动 AWS Spot 实例
“Spot 实例是未使用的 EC2 实例，其可用价格低于按需价格。因为 Spot 实例使您能够以大幅折扣请求未使用的 EC2 实例，所以您可以显著降低 Amazon EC2 的成本。”
— 现场实例，AWS 文档
为了启动一个 Spot 实例并在环境中运行 Docker 容器，我们将使用 Spotty 。Spotty 是一个开源工具，旨在简化云中深度学习模型的开发。
使用 pip 安装最新版本:
pip install -U spotty
Spotty 只需要在项目的根目录中有一个描述实例和容器参数的spotty.yaml配置文件。而且我们已经在原回购的这个叉里给你准备好了。
使用以下命令克隆项目:
git clone [https://github.com/spotty-playground/stylegan2-ada](https://github.com/spotty-playground/stylegan2-ada)
默认情况下，Spotty 将在us-east-1区域启动一个p2.xlarge Spot 实例，但是，如果需要，您总是可以在spotty.yaml文件中更改这些参数。
在启动实例之前，请确保您已经安装并配置了 AWS CLI。更多信息，请参见安装 AWS CLI 和配置基础知识。
要启动实例，请从项目根目录运行以下命令:
spotty start aws-1
等待实例启动:
Bucket "spotty-stylegan2-ada-la4gun6uy92a-eu-central-1" was created.
Syncing the project with the S3 bucket...
Creating IAM role for the instance...
Preparing CloudFormation template...
- volume "stylegan2-ada-aws-1-workspace" will be created
- availability zone: auto
- on-demand instance
- AMI: "Deep Learning AMI (Ubuntu 16.04) Version 35.0" (ami-01955a821cfdfaf73)Volumes:
+-----------+------------+------------+-----------------+
| Name | Mount Path | Type | Deletion Policy |
+===========+============+============+=================+
| workspace | /workspace | EBS volume | Retain Volume |
+-----------+------------+------------+-----------------+Waiting for the stack to be created...
- launching the instance... DONE
- preparing the instance... DONE
- mounting volumes... DONE
- syncing project files... DONE
- building Docker image... DONE
- starting container... DONE+---------------------+---------------+
| Instance State | running |
+---------------------+---------------+
| Instance Type | p2.xlarge |
+---------------------+---------------+
| Availability Zone | us-east-1e |
+---------------------+---------------+
| Public IP Address | 100.26.50.220 |
+---------------------+---------------+
| Purchasing Option | Spot Instance |
+---------------------+---------------+
| Spot Instance Price | $0.2700 |
+---------------------+---------------+Use the "spotty sh" command to connect to the container.
就是这样！只需连接到容器并使用代码:
spotty sh aws-1
Spotty 使用 tmux ，所以如果你的互联网连接断开了，你也不会丢失你的进度。有关 tmux 的更多信息，请阅读官方文档或 Tmux 备忘单。
例子
生成 MetFaces 图像
met faces 模型生成的图像。
连接到容器后，使用以下命令通过预先训练的模型生成图像:
python generate.py — outdir=out/metfaces — trunc=1 — seeds=85,265,297,849 \
— network=[https://nvlabs-fi-cdn.nvidia.com/stylegan2-ada/pretrained/metfaces.pkl](https://nvlabs-fi-cdn.nvidia.com/stylegan2-ada/pretrained/metfaces.pkl)
该命令将在out/metfaces/目录中生成 4 幅图像。您可以使用以下命令将它们下载到您的本地计算机上:
spotty download aws-1 -i 'out/*'
使用 FFHQ 模型将图像投影到潜在空间
在这个例子中，我们将展示如何使用自定义的 Spotty 脚本。
要找到一个潜在向量并生成一个进展视频，将一个目标图像target.jpg放到本地机器上的data/目录中，并运行以下命令:
spotty run aws-1 projector-ffhq -p TARGET=data/target.jpg -p OUTPUT_DIR=out/projection
该脚本将在一个 tmux 会话中运行。因此，即使您的互联网连接断开，该进程仍将运行，您可以在以后的任何时间重新连接它。
脚本完成后，使用Ctrl+b, x组合键关闭 tmux 窗口，并将结果下载到您的本地机器:
spotty download aws-1 -i 'out/*'
完成后，不要忘记停止实例！使用spotty stop命令。如果不再需要这些数据，请删除 EBS 卷。
像海军上将一样管理您的数据科学团队…
管理一个数据科学团队很难！我们需要从任何可能的地方获取灵感，纳尔逊海军的文化就是一个起点。
勒穆埃尔·弗朗西斯·阿博特的《纳尔逊肖像》
“如果把自己的船放在敌人的船旁边，任何一个船长都不会做错什么” 霍雷肖·纳尔逊上将，特拉法尔加战役前，1805 年
现在请容忍我。我承认这种比较听起来有点牵强。事实上，对西洋镜迷来说，这听起来有点像“法老的商业秘密” **[1]。**然而，我想说服你，关于领导力的一些事情是基本的，作为管理(或渴望管理)数据团队的人，我们应该从更远的地方寻找如何建立团队文化的灵感。追随胜利者通常是值得的，对吗？
首先，我们应该明白纳尔逊既聪明又勇敢。他在特拉法尔加战役前夕的胜利计划是将他的战船排成两行，向法国人发起冲锋。差不多就是这样。他把击沉法国船只的决定权留给了各个指挥官，只要他们认为合适。最终，英国赢得了一场令人震惊的胜利，确保了英国是世界上占主导地位的海上力量——直到大约一个世纪后美国真正开始行动。
这些都很有趣，但这和数据科学有什么关系呢？
首先，让我们看看隐含的领导风格。尼尔森没有为他的队长们提供一份需要完成的任务清单，也没有试图对他们的时间进行微观管理。相反，他告诉他们“只要你在和敌人战斗，你就是在做正确的事情，我会支持你”。换句话说，他提供了一个广泛的目标，并允许他们做任何他们需要做的事情来实现它。
现在，如果你雇佣了合适的人，你的数据科学家将会变得聪明、积极和独立。也许你决定效仿纳尔逊的做法，为自己制定一个远大的目标:
“如果数据科学家将模型投入生产，他们不会犯很大的错误” 一些数据科学负责人，在 2019 年的某个时候
听起来很棒，对吧？发布指令，然后让一群聪明人想出如何做实际工作。与此同时，你可以早点离开，去高尔夫球场(美国)或酒吧(英国)。
要理解为什么这种方法本身行不通，我们可以回到纳尔逊和他的海军。纳尔逊在海军文化的背景下发布了他的命令，这种文化基于一套共享的技能、经验和信仰。他知道他可以相信他的队长会实现他的目标，因为他知道他们如何思考和战斗。
那么这种共享文化是由什么组成的呢？这些与数据科学相关吗？这是我看到的七个相似之处:
- 技能很重要
在纳尔逊的时代，成为一名海军军官的训练要从 12 岁开始。这些孩子在现役战斗舰上服役，在那里他们与一名更有经验的下级军官(他自己通常是青少年)搭档，后者会向他们展示真正的诀窍。
海军军官候补生亨利·威廉·拜恩顿 13 岁(1780 年)。是的，像这样的孩子被放在了火线上。
我找不到这些海军军官候补生的伤亡率，很大程度上是因为似乎没有人对记录它感兴趣。可以说，当幸存者到达指挥位置时，他们从很小的时候就已经积累了大量的技术知识。
你的数据科学团队必须了解大量技术和事实材料。我们将在另一篇文章中回到技术到底是什么。现在让我们说它是软件技能、统计学和机器学习的某种结合。数据科学负责人的部分工作是确保团队拥有这些技能。传统上，这意味着从组织外部雇佣人员。然而，随着数据科学在大型组织中的地位越来越稳固，它也成为毕业生轮换计划或类似计划中年轻内部候选人的热门选择。确保合适的人得到合适的培训是这项工作的一个重要部分。最后，就像尼尔森的队长一样，你必须确信你团队中的每个人都知道并理解一个共享的知识体系。
2。练习，练习，练习
特拉法尔加战役之前，法国被封锁。这就是英国对拿破仑大陆封锁的回应——你们没有封锁我们，是我们封锁了你们！英国船只连续几个月滞留在海上，扰乱了法国的贸易。这实际上是把法国军舰困在港口里。到特拉法尔加战役时，英国水手只是更擅长航海，并不是因为他们有什么天生的优势，而仅仅是因为他们做得更多。
数据科学团队的成员必须通过研究数据科学来提高数据科学水平。这听起来微不足道，但它提出了平衡的难题。你必须推动人们获得适合他们的体验。有些任务是人们想做的，因为他们以前做过，并且擅长做。然后是人们想做的任务，因为他们以前从未做过，希望 让 擅长它们。最后，有些任务没人想做，因为它们很无聊。不管怎样，你必须确保合适的人得到合适的体验，并且所有必要的工作都完成了。最后，就像英国船上的船长站在海上一样，你需要对你团队的经验充满信心。
3。扁平层级
纳尔逊用莎士比亚的短语“一帮兄弟”来形容他和他的高级队长的关系。他似乎认为自己是平等者中的第一人，历史学家认为这表明了“为国家服务的社会平等”。纳尔逊总是在重大交战前咨询一群船长，以检查和改进他的计划。
作为数据科学的负责人，你必须与团队的高级成员保持良好、开放的关系。他们会知道你不知道的事情，会有你没有的经历。你需要利用这些知识。然而，扁平层级的危险在于，你最终会得到“偶然的层级”，在这种层级中，有人最终会占据主导地位。如果这是一个*# iamverysmart***【3】**的人，他肯定，肯定知道所有的答案，那么你试图培养的开放文化正在被摧毁。在这种情况下，你只需要让某个人成为临时领导，这个人必须具备维持开放性的必要个性。这可能不是那个认为应该是他们的人！我们要达到的目的是尼尔森成功实现的。没有人怀疑纳尔逊拥有舰队的最终指挥权，船长对他们的船只负有责任。然而，这种层级是足够扁平的，以至于计划可以被共同讨论和改进。
4。成功孕育成功
胜利很重要。在特拉法尔加战役之前，英国海军赢得了一系列战役:1794 年 6 月 1 日的辉煌战役、1795 年的格罗依战役、1797 年的圣文森特角战役、1797 年的坎伯唐战役、1798 年的尼罗河战役和 1801 年的哥本哈根战役。到了 1805 年，他们预计会赢，而且他们确实赢了。
作为个人，你的数据科学家应该已经有了“精英”心态。他们可能已经在大学、学术界，或者更好的是在工作场所取得成功，发展了这一点。你的工作是将这转化为精英 团队 的心态。最后，当项目开始出错时，你会看到人们做非凡的事情，因为“交付是我们的工作”。在这种文化中，一个失败的项目是不可想象的。然后，这种成功反馈到团队是成功团队的共同信念中，这产生了更多的努力工作以带来更多的成功，如此循环。正如纳尔逊的海军一样，成功的文化孕育着更多的成功。
5。精英管理规则
好吧，我们不应该过分强调这一点。按照现代标准，纳尔逊和他同时代的人都是“男性，脸色苍白”。然而，以下是对他们背景的描述:
“作为一个乡村牧师的儿子，他(纳尔逊)来自从下层绅士到中产阶级的广泛社会阶层，正是这些阶层为皇家海军提供了如此多的军官。他可能会与他同时代的国旗名单圣文森特，邓肯，康华里，基思，加德纳，甘比尔，科林伍德，和兄弟 Bridport 和胡德；圣文森特的父亲是一个省律师，邓肯的邓迪教务长，加德纳的一名军官，甘比尔的巴哈马副总督，科林伍德的一个商人，和胡德的另一个牧师。【5】**
当大陆海军由贵族子弟领导的时候，英国海军是根据功绩从中产阶级中提拔的。
您的数据科学团队必须保持不变。不管你喜不喜欢，你正处于一场激烈的资源争夺战中。如果你是一个面向内部的团队，会有一堆人想要外包你。如果你是对外面对，会有几十个饥渴的竞争对手。像尼尔森一样，你需要你能得到的最好的人，不考虑任何其他因素。
6。卡在
1757 年 3 月 14 日，海军上将约翰·宾被行刑队处决。根据军事法庭的说法，面对敌人，他“没有尽最大努力”。历史学家认为，Byng 被处决是为了解决启蒙运动观点和更古老、更血腥的战争观点之间的争论，启蒙运动认为战争现在是关于科学的兵力部署(在这种情况下，按照命令在优势敌人面前撤退是合理的行动过程)。更简洁地说，按照伏尔泰的说法，他被处决是为了“鼓励其他人”。不管是什么原因，从 Byng 时代到 Trafalgar 时代及以后，皇家海军的行动经常带有极端侵略性。宁可死在敌人手中，也不要被行刑队羞辱。
当然，你不希望你的数据科学家表现出极端的攻击性。你可能也不会被允许执行其中的任何一个——尽管这听起来很诱人。然而，在每个数据科学项目的某个时候，你会将已经完成的工作抛在身后，不得不依靠你的能力去做一些新的事情。这可能很可怕，但这是工作的一部分！你的团队文化必须鼓励大胆的“能行”精神，鼓励人们迈出未知的第一步。就像纳尔逊的海军一样，当事情看起来很困难时退缩是不能容忍的。
7。资源决定成败
资源对纳尔逊海军的影响可以用下面的图表来概括:
事实证明，钱很重要。详细讨论见[4]。
实际上，到特拉法尔加时代，英国人已经比他们的大陆对手多花了两个半世纪。他们有更多的船，更多的枪和更多的战士。这是他们不断获胜的一个重要原因。
在数据科学的旧时代，传说你可以给一个聪明人一支圆珠笔，一个新的记事本和一台计算机。然后你可以退一步，期待他们创造奇迹。那个世界已经结束了——如果它曾经存在过的话。你的团队在一个由大型科技巨头、经验丰富的外部咨询公司和专注的初创企业提供的 API 组成的宇宙中工作。它将受到可支配资源的限制，受限于工时、计算资源以及花费在数据质量和数量上的资源。因此，你需要对什么是可能的持现实态度，并将你要解决的问题与你必须投入的资源相匹配。最后，就像尼尔森一样，比你的直接竞争对手规模更大会有所帮助——如果这不可能，至少在相同的支出水平上。
这就是为什么你的数据科学团队应该像尼尔森的海军一样的七个原因。归根结底，这不是你为团队设定的广泛目标。这是容易的部分。难的是建立你设定目标的文化和环境，所以你可以相信你的团队会成功实现。
脚注
***【1】*如果你不是一个西洋镜迷，你几乎肯定应该是。这是一部英国情景喜剧，在 channel4.com 和网飞播出。《法老的商业秘密》这一集的精彩之处在于，它讲述了一个主角试图让他的白痴商业书籍出版。
请看弗朗兹·库切的《为了政党还是国家:爱德华时代英格兰的民族主义和流行保守主义的困境》。是的，我知道纳尔逊不是爱德华七世时代的人，但第一章涵盖了之前的几年。毕竟是历史书。
【3】#我很聪明的人们的闪避诱发震中当然是https://www.reddit.com/r/iamverysmart/
***【4】*皇家海军从 1653 年特克萨尔战役胜利到 1805 年特拉法尔加战役胜利的全要素生产率。帕特里克·卡尔·奥布莱恩
***【5】*纳尔逊与英国海军:航海术、领导力、独创性。北美罗杰
***【6】*男子气概、军国主义和十八世纪文化，1689-1815。朱莉娅·巴尼斯特
运行你的第一个交易算法！
编码或选择一个算法，回测它，并使用羊驼中的纸张或货币帐户运行它。
菲利普·格利克曼在 Unsplash 上的照片
免责声明:本文内容不构成理财建议。这只是一个关于如何为交易机器人建立基础设施的教程。
动机
一张图片胜过千言万语。请看下面 S&P500 指数和一些组成 ML 401k 投资组合的共同基金的表现比较，并做出你自己的结论。
(来源:https:/finance . Yahoo . com)
S&P500 vs FSELX
S&P500 对雷西斯
S&P500 对 S&P500？
正如你所看到的，这些共同基金的表现与 S&P500 相比并没有那么好。除此之外，获取这些基金的业绩/风险指标并不简单。夏普比率，最大下降，阿尔法，贝塔——祝你好运。
我们不应该盲目地依赖公司来管理我们的财务。归根结底，这是我们的未来，我们对此最感兴趣。
但是谁有时间管理投资组合呢？这就是我们需要自动化的原因。
让我们看看如何部署我们的第一个交易算法。
建筑
你需要:
- **量子密码。**自己写或者在社区搜索。那里有很多好东西，但鉴于目前新冠肺炎市场的波动性，我建议采取市场中性策略(小市场相关性，小贝塔)。
- PythonAnywhere 账户(你需要 5 美元/月的计划):https://www.pythonanywhere.com/
- 羊驼账号(免费！)
https://alpaca . markets
我应该成为一名艺术家。
建立基础设施
- 羊驼
一旦您创建并验证了您的羊驼账户，点击“转到纸质账户”并点击“您的 API 密钥”中的“查看”按钮。记下 key_id、secret_key 和 base_url。
- PythonAnywhere
创建虚拟环境
《时代》杂志 2015 年虚拟现实封面催生了一个经典迷因。Pic: @PellyNV
我们先用 python 3.6 创建一个虚拟环境，安装 pylivetrader。
Pylivetrader 是让羊驼理解量子算法的软件包。这个包允许您获得 Quantopian 和 Alpaca 的算法订单执行的回溯测试功能，所有这些都与 PythonAnywhere 粘合在一起，同时在云中不间断地运行。
在创建和升级你的账户(最便宜的计划)后，你需要用 Python 3.6 创建一个虚拟环境并安装 pylivetrader。
在 PythonAnywhere 上打开 bash 并键入以下命令:
$ python3.6 -m venv venv
$ source venv/bin/activate
(venv)$ pip install pylivetrader
注意 pylivetrader 将只与 Python 3.6 一起工作。
安装在虚拟环境中的所有包只能在同一个虚拟环境中访问，这里称为’ venv ‘。’ venv ‘内部的 Python 版本也将被限制为 3.6(在这种特殊情况下)；然而，您仍然可以使用’ venv '之外的其他 python 版本。为此，只需输入 deactivate。
(venv)$ deactivate
您可以通过键入以下内容直接跳回虚拟环境:
$ source venv/bin/activate
上传量子算法
关闭 bash 并转到“文件”，创建一个名为 algo.py 的新空文件，并粘贴以下代码:
from pylivetrader.api import order_target, symbol
def initialize(context):
context.i = 0
context.asset = symbol('AAPL')
def handle_data(context, data):
# Compute averages
# data.history() has to be called with the same params
# from above and returns a pandas dataframe.
short_mavg = data.history(context.asset, 'price', bar_count=100, frequency="1m").mean()
long_mavg = data.history(context.asset, 'price', bar_count=300, frequency="1m").mean()
# Trading logic
if short_mavg > long_mavg:
# order_target orders as many shares as needed to
# achieve the desired number of shares.
order_target(context.asset, 100)
elif short_mavg < long_mavg:
order_target(context.asset, 0)
保存并关闭它。我们需要一个配置文件来访问羊驼；还记得 api_key 和 secret 吗？我们现在需要它们。
创建一个名为 config.yaml 的新文件，并添加以下定义 :
key_id: 'your key_id'
secret: 'your secret'
base_url: [https://paper-api.alpaca.markets](https://paper-api.alpaca.markets)
保存并关闭它。我们差不多完成了:最后要做的事情是安排一个将在云中不间断运行的任务。
转到“任务”，一直向下滚动到“始终在线任务”，然后键入以下命令:
source venv/bin/activate && pylivetrader run -f algo.py --backend-config config.yaml
稍后，任务将开始运行:
最后，进入你的羊驼纸账户，检查订单是否通过。
一旦你准备好用真钱开始，为你的钱帐户获得 api 密钥和秘密，并更新 config.yaml 文件。
结论
在本文中，我们使用 PythonAnywhere 和 Alpaca 完成了运行 Quantopian 算法的步骤。
根据您的算法，您可能需要包含更多的导入以使其工作。您可以在这里找到每种情况下需要导入的包的列表:
https://alpaca . markets/docs/alpaca-works-with/zip line-to-pylivetrader/
最后，如果你决定运行你的羊驼货币账户，我强烈建议使用市场中性算法(空头和多头头寸比例相等)。我的苹果股票布林线交易算法一直很好地应对了冠状病毒危机引起的波动。可以在这里查看:https://towards data science . com/back testing-bollinger-bands-on-apple-stock-using-quanto pian-6be 2e 4824 f 43
我希望你喜欢这篇文章！请不要犹豫评论或分享您的结果。
谢谢
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
在 Docker 中运行您的本地数据库！🐳
用于本地开发的 Docker 数据库映像:
如何使用 docker 建立本地开发数据库？快速简单。
照片由 Ishant Mishra 在 Unsplash 拍摄
当建立一个新项目时，有时会有一个全面的先决条件列表，以便能够运行一个项目。在这个简短的教程中，我们将使用 docker 映像建立一个本地数据库。例如，我们将使用 PostgreSQL，但是您可以自由选择您的数据库。
**先决条件:**你首先也是唯一需要的就是 Docker。我下载了 Docker 桌面以便在我的 mac 上开始使用(你可以自由使用你喜欢的任何 Docker 安装)。
我们开始吧！🙌
✌️My 3 个主要原因
我使用 docker 数据库映像进行本地开发的三个主要原因，以及我认为您也应该这样做的原因:
- 它使本地开发设置变得容易。一个简单的抽象，使用一行设置来设置数据库！
- 它不要求您在计算机上安装任何数据库(或数据库的特定版本)。
- 它隔离了数据库环境。它允许我同时运行多个版本和实例，而不会遇到麻烦。
我通常将它作为选项添加到我的README文件的项目设置中。然后人们可以决定做什么——要么用手动方式做，要么用简单的方式做😄
您并不局限于使用 PostgreSQL 映像 — docker 拥有所有常见数据库的数据库映像，如 Redis、MySQL、Oracle 等。找到你的最爱。
让我们装运那个集装箱吧！
我们将使用 Postgres 映像启动一个新的 docker 容器来运行数据库:
$ **docker run --name my_postgres -p 5432:5432 -e POSTGRES_PASSWORD=postgres postgres**
这就对了。我们基本上完成了——在一行中，您已经设置好了所有的东西😄 🤷♀(如果你没有安装任何图像，docker 会问你是否要下载)。让我们看看我们刚刚创建的内容:
--name my postgres创建一个名为my_postgres的 docker 容器。-p是设置端口的标志。5432:5432将内部 docker 端口映射到外部端口，这样我们可以有一个从外部到 docker 映像的门。端口5432是一个 Postgres 特定的端口——如果使用另一个数据库映像，您可能需要更改它。-e是环境变量的标志。我们加上了POSTGRES_PASSWORD。- 最后一部分
postgres是我们将使用的 docker 图像(如果您使用另一个数据库，您应该更改它)
现在您有了一个名为my_postgres的 docker 容器，它在端口 5432 上运行 PostgreSQL 数据库。数据库将name、username和password设置为 postgres 。
👩💻一些细节
好了，让我们继续看一些 docker 标志和命令:
-d如果你想在后台运行你的数据库作为守护进程。如果没有d标志，您需要让您的容器一直在一个单独的终端中运行，以访问您的数据库。您可以通过运行docker start <docker_name>或docker stop <docker_name>来启动和停止容器。docker postgres:latest如果你想确保使用最新的 Postgres 镜像。docker pull postgres拉最新的 Postgres 图片。docker images列出您电脑上的所有图像。docker ps -a查看所有创建的容器(具有指定端口的容器是运行中的容器)。docker rm <docker_ID>或docker rm <docker_name>移除码头集装箱。- 从 docker 容器中清除所有数据库数据。即使您有几个 docker 容器在运行，您仍然会访问相同的数据，因为它被写入相同的位置。
💅哪里可以欣赏我的新数据库？
您可以选择您喜欢的数据库 GUI 工具并连接到您的数据库。我喜欢用 DBeaver *。*使用以下命令连接到我们在 Docker 容器中运行的新创建的数据库:
- 数据库名称: postgres
- 数据库用户: postgres
- 数据库密码: postgres
- 端口: 5432
如果您喜欢在终端中使用数据库，您可以在 docker 容器中输入以下命令来访问数据库(我们的 docker 在本教程中被命名为 my_postgres ):
$ **docker exec -it <DATABASE_NAME> bash**
🎉快乐编码
🐳你会开始使用 docker 数据库镜像来进行本地设置吗？
如何将你的 ML 模型预测速度提高 50 倍？
使用蜂鸟只用了 2 行代码
随着这么多计算和服务框架的出现，开发人员将一个模型投入生产的压力与日俱增。如果哪种模型在我的数据上表现最好的问题还不够，现在的问题是选择什么框架来服务于用 Sklearn 或 LightGBM 或 PyTorch 训练的模型。每天都有新的框架加入进来。
那么，对于一个数据科学家来说，是否有必要学习一个不同的框架，因为一个数据工程师对此很熟悉，或者相反，一个数据工程师是否需要学习一个数据科学家喜欢的新平台？
再加上这些不同框架提供的速度和性能因素，问题突然变得更加复杂。
所以，当我最近在 Github 上偶然看到蜂鸟项目时，我感到惊喜，这个项目旨在回答这个问题，或者至少朝着正确的方向迈出了积极的一步。
那么，蜂鸟是什么？
根据他们的文件:
Hummingbird 是一个用于将训练好的传统 ML 模型编译成张量计算的库。蜂鸟允许用户无缝地利用神经网络框架(如 PyTorch )来加速传统的 ML 模型。
得益于蜂鸟，用户可以受益于:
(1)在神经网络框架中实现的所有当前和未来的优化；
(2)原生硬件加速；
(3)具有支持传统和神经网络模型的独特平台，并且具有所有这些
(4)无需重新设计他们的模型。
更简单地说:现在，您可以将用 Scikit-learn 或 Xgboost 或 LightGBM 编写的模型转换成 PyTorch 模型，并在推理时获得 Pytorch 的性能优势。
到目前为止，这里是蜂鸟支持的 操作者的列表还会有更多。
简单的例子
我们可以从安装蜂鸟开始，简单如:
pip install hummingbird-ml
为了使用 hummingbird，我将从一个小型随机分类数据集的最小示例开始。我们首先创建一个包含 100，000 行的样本数据集，并在此基础上使用 RandomForestClassifier。
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from hummingbird.ml import convert# Create some random data for binary classification
from sklearn import datasetsX, y = datasets.make_classification(n_samples=100000, n_features=28)# Create and train a model (scikit-learn RandomForestClassifier in this case)skl_model = RandomForestClassifier(n_estimators=1000, max_depth=10)
skl_model.fit(X, y)
hummingbird 帮助我们的是通过使用简单的命令将这个 sklearn 模型转换成 PyTorch 模型:
# Using Hummingbird to convert the model to PyTorch
model = convert(skl_model, 'pytorch')
print(type(model))
--------------------------------------------------------
hummingbird.ml._container.PyTorchBackendModel
现在，我们可以使用以下代码将新的 Pytorch 模型加载到 GPU:
model.to('cuda')
这太棒了。因此，我们可以从 sklearn 模型转换为 PyTorch 模型，这应该在 GPU 上运行得更快。但是增加多少呢？
让我们来看一个简单的性能对比。
比较
1.成批处理方式
我们将首先使用 sklearn 模型来预测整个训练数据集，并检查它所花费的时间。
我们的新 PyTorch 型号也可以做到这一点:
那就是 9580/195 ~ 50x 的加速。
2.单实例预测
我们在这里预测一个例子，看看这个模型在实时环境中的表现。sklearn 模型:
vs. Pytorch 模型
这也是 79.6/1.6 ~ 50 倍的加速比。
小警告
我经历的一个小警告是，sklearn 模型和蜂鸟 PyTorch 模型的预测并不完全相同。
例如，下面是我从两个模型中得到的预测:
是的，有时，它们在第 7 位数字上不同，这可能是转换过程的一个函数。我认为它不会改变最终的 1 或 0 预测太多。我们还可以检查:
scikit_1_0 = scikit_preds[:,1]>0.5
hb_1_0 = hb_preds[:,1]>0.5
print(len(scikit_1_0) == sum(scikit_1_0==hb_1_0))
------------------------------------------------------------
True
因此，在这种情况下，两个模型对 100，000 行的整个数据集给出了完全相同的 1 或 0 预测。
所以我想没关系。
结论
微软的开发人员仍在致力于添加更多的操作符，从模型到特性工程，如代码中的MinMaxScaler或LabelEncoder，我希望他们能进一步开发和改进这个项目。如果你感兴趣，这里是发展的路线图。
虽然 Hummingbird 还不完美，但它是第一个能够运行经典 ML 推理 DNN 框架的系统，并证明它们足够成熟，可以用作通用编译器。当涉及到在高吞吐量或延迟时进行预测时，我会尝试将它包含在我的开发工作流中。
你可以在我的 GitHub 库找到这篇文章的代码以及我所有的文章。
继续学习
如果你想了解更多关于构建机器学习模型并将其投入生产的知识，这个关于 AWS 的课程可以满足你的要求。
谢谢你的阅读。将来我也会写更多初学者友好的帖子。在媒体关注我，或者订阅我的博客了解他们。一如既往，我欢迎反馈和建设性的批评，可以通过 Twitter @mlwhiz 联系
此外，一个小小的免责声明——这篇文章中可能会有一些相关资源的附属链接，因为分享知识从来都不是一个坏主意。
使用 OpenDataHub、OCS 和外部 Ceph 集群运行 Spark 数据处理工作负载
Kubernetes 已经成为事实上的标准容器编排平台。通过这种方法，组织试图围绕 Kubernetes 收集所有的应用程序和平台，以利用其稳定性、敏捷性和简单性。在 Kubernetes 中运行您的整个堆栈将允许您拥有一个单一的 API 和一种通用语言，无论是用于需要部署的应用程序、数据库还是存储引擎。
几年前，人们认为，为了获得更高的大数据工作负载性能，您的应用程序需要主要基于闪存介质的高性能本地磁盘。将计算和存储放在一起带来了自身的挑战，主要是在出现故障和升级时，因为组织必须将它们作为一个整体来对待。
今天，我们看到许多数据处理引擎，如 Spark、Presto 等使用 S3 作为存储后端。使用 S3 处理大数据工作负载有多种原因:
- S3 是一个面向吞吐量的存储系统，可以支持来回传输大量数据
- S3 是基于 HTTP 的，当必须开发一个连接器来访问它时，它是非常可移植的
- S3 拥有自己的智能数据管理功能，如存储桶生命周期、存储类别、版本控制等，可以减轻最终用户的数据管理负担
今天，我想和你重点谈谈如何使用 S3 存储后端在 Kubernetes 上运行你的数据处理引擎。为此，让我们简单介绍一下我们将要使用的平台:
- Ceph —将用作 Openshift 集群外部的 S3 网关
- Openshift 集装箱存储—将为我们提供类似 Kubernetes 的功能来处理我们的 S3，将在稍后讨论
- 开放式数据中心——将用作我们的 spark 集群和 Jupyter 笔记本电脑的数据处理供应器，以运行我们的 Spark 工作负载
先决条件
- 正在运行的 Openshift 4.5 集群
- 正在运行的 RHCS 4.1 集群
- 这两者之间的网络连接
我们要部署的第一个组件是 OCS (Openshift Container Storage ),它将成为我们 S3 存储后端的 Kubernetes 管理平台。使用昨天发布的 OCS 4.5，您可以将外部 Ceph 集群连接到 OCS 管理平面，以利用其资源。这种部署方法称为“独立模式”,主要用于正在处理的工作负载和容量超过 OCS 内部模式处理能力的情况。(内部模式将在 Openshift 上运行您的 Ceph 集群，这对于中小型数据工作负载非常有用)。
让我们连接到 Openshift 集群，进入Operator Hub选项卡，并安装 OCS 操作符。该运营商将部署我们的 OCS 管理平台，并将连接到外部 Ceph 集群:
安装好操作员后，让我们创建一个独立的集群，为此我们点击Create Storage Cluster和independent mode。这将要求在我们的 Ceph 集群上运行一个脚本，该脚本将收集将 OCS 连接到我们的外部 Ceph 集群所需的所有信息。该脚本将抛出一个 JSON 文件到 STDOUT，请将它粘贴到代码片段中。
创建集群后，我们应该让它处于Ready状态:
现在我们已经准备好了 S3 后端，让我们创建一个Object Bucket Claim,这样我们的 Spark 应用程序就可以使用它来处理数据。OBC(对象桶声明)是一种将桶视为 Kubernetes 持久卷声明的方式。这个对象对于 OCS 是唯一的，并且减轻了开发人员跟踪其凭证、bucket 名称和端点 URL 的需要。要创建 bucket claim，只需转到 Openshift 控制台中的Object Bucket Claims(存储选项卡下)，创建一个 OBC 并选择 RGW 存储类作为目标。
这种自动化将在我们的外部 Ceph 集群中创建一个用户和一个存储桶，并将所有信息存储在 ConfigMaps 中，并将机密存储在我们的 Openshift 集群中。凭据将存储为机密，而存储桶名称、存储桶端口和端点 URL 将存储为 ConfigMap。
为了验证确实创建了 bucket，让我们使用radosgw-admin命令访问我们的 Ceph 集群并列出我们拥有的 bucket:
$ radosgw-admin bucket list | grep spark
"spark-bucket-1143d1c8-e321-496a-821c-9c1b89297685"
我们看到我们有一个由 OBC 创建的存储桶，现在让我们尝试获取有关我们创建的存储桶的更多信息:
$ radosgw-admin bucket stats --bucket spark-bucket-1143d1c8-e321-496a-821c-9c1b89297685
{
"bucket": "spark-bucket-1143d1c8-e321-496a-821c-9c1b89297685",
"num_shards": 11,
"tenant": "",
"zonegroup": "c6f894d0-256a-425f-92ec-b5c41366c1cb",
"placement_rule": "default-placement",
"explicit_placement": {
"data_pool": "",
"data_extra_pool": "",
"index_pool": ""
},
"id": "9cdf5d28-ceb4-4629-b507-13509f8c99ab.84164.2",
"marker": "9cdf5d28-ceb4-4629-b507-13509f8c99ab.84164.2",
"index_type": "Normal",
"owner": "ceph-user-bbX0Qdrn",
"ver": "0#1,1#1,2#1,3#1,4#1,5#1,6#1,7#1,8#1,9#1,10#1",
"master_ver": "0#0,1#0,2#0,3#0,4#0,5#0,6#0,7#0,8#0,9#0,10#0",
"mtime": "2020-09-17 14:15:12.993277Z",
"max_marker": "0#,1#,2#,3#,4#,5#,6#,7#,8#,9#,10#",
"usage": {},
"bucket_quota": {
"enabled": false,
"check_on_raw": false,
"max_size": -1,
"max_size_kb": 0,
"max_objects": -1
}
}
我们看到还创建了一个新用户(在Owner部分下)。现在，让我们验证我们的信息是否如保证的那样位于我们的 Openshift 集群中。让我们描述一下我们称为spark-bucket的 OBC 对象:
$ oc describe secret spark-bucket
Name: spark-bucket
Namespace: amq-streams
Labels: bucket-provisioner=openshift-storage.ceph.rook.io-bucket
Annotations: <none>
Type: Opaque
Data
====
AWS_ACCESS_KEY_ID: 20 bytes
AWS_SECRET_ACCESS_KEY: 40 bytes
我们看到，我们将访问密钥和秘密密钥作为秘密存储在 Openshift 集群中。现在让我们做同样的事情，描述配置图，看看我们是否有其余的信息:
$ oc describe cm spark-bucketName: spark-bucket
Namespace: amq-streams
Labels: bucket-provisioner=openshift-storage.ceph.rook.io-bucket
Annotations: <none>Data
====
BUCKET_NAME:
----
spark-bucket-1143d1c8-e321-496a-821c-9c1b89297685
BUCKET_PORT:
----
8080
BUCKET_REGION:
----
us-east-1
BUCKET_SUBREGION:
----BUCKET_HOST:
----
10.32.0.3
Events: <none>
太好了！我们已经获得了所需的信息，这样我们的 Spark 应用程序就可以到达我们的 S3 后端。让我们创建一个名为odh的新项目，它将存储Open Data Hub工作负载。
$ oc new-project odh
之后，我们将安装 Open Data Hub operator，这样我们就可以启动和配置我们的 Spark 集群:
在我们成功安装了 ODH 操作符之后，我们将创建一个Open Data Hub定制资源，它将提供所有需要的对象供我们使用。创建 CR 后，将为您的Jupyter Hub笔记本创建一条路线，从s2i-spark-minimal-notebook:3.6映像创建一个新笔记本。
创建这个笔记本将创建一个 spark 集群，其中的每一个 pod 都充当一个 Spark executor。这还将创建一个笔记本数据库，用于存储笔记本中保存的所有信息。这是与您的用户 1:1 的关系，所以下次您登录时，您将看到相同的笔记本。
现在让我们看看豆荚是否真的被创造出来了:
$ oc get podsNAME READY STATUS RESTARTS AGE
jupyterhub-1-2bglz 1/1 Running 0 17m
jupyterhub-1-deploy 0/1 Completed 0 17m
jupyterhub-db-1-72fbr 1/1 Running 0 17m
jupyterhub-db-1-deploy 0/1 Completed 0 17m
jupyterhub-nb-kube-3aadmin 2/2 Running 0 14m
opendatahub-operator-6c96795b8b-kmhhh 1/1 Running 0 19m
spark-cluster-kube-admin-m-9w69r 1/1 Running 0 14m
spark-cluster-kube-admin-w-wb54g 1/1 Running 0 14m
spark-cluster-kube-admin-w-x5zn9 1/1 Running 0 14m
spark-operator-74cfdf544b-mrdzf 1/1 Running 0 17m
太好了！我们有自己的基础设施。现在让我们验证我们的Jupyter Notebook是持久的:
$ oc get pv
NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS CLAIM STORAGECLASS REASON AGE
pvc-6ec75973-a17a-44d6-b308-42cc4c4664fd 1Gi RWO Delete Bound odh/jupyterhub-db ocs-independent-storagecluster-ceph-rbd 43m
pvc-b3064182-ef7c-434f-a3f3-10c8f198a7d8 2Gi RWO Delete Bound odh/jupyterhub-nb-kube-3aadmin-pvc ocs-independent-storagecluster-ceph-rbd 39m
作为奖励，ODH 运营商将为我们的笔记本电脑数据库连接一个 PVC，该 PVC 取自存储在我们外部 Ceph 集群中的 RBD 池，我们在一个系统中获得了两个存储协议，多么令人兴奋！
让我们简单介绍一下我们的 Spark 工作负载。在这个工作负载中，我们将上传一个包含学生成绩的 CSV 文件到我们的 S3 存储桶。这个 CSV 文件包含了学生的名字，以及他们在 4 个年级的分数，也就是最后的成绩。我们的目标是使用火花处理为每个等级收集频率。
让我们来看看我们的 Jupyter 笔记本:
对我们在这里看到的做一点解释:
- 在第一阶段，我们检查 spark 集群中的连通性，输出以 Spark 执行器的名字打印，可以与 pods 运行相关联。
- 稍后，我们使用
wget将 CSV 文件下载到我们的本地笔记本中，并将其保存在我们的 DB 中 - 我们使用
boto库，以便使用从我们的 bucket claim 收集的信息将 CSV 文件上传到我们的 S3 bucket - 然后，我们使用相同的变量来设置 Spark
s3a连接器使用的配置 - 我们从我们的 S3 桶中读取 CSV 文件并打印分数。注意了！我们有一个错误的值，即第 9 个单元格中的“A ”,这会影响我们数据的可靠性
- 我们清理这个值，最后建立一个等级频率图
结论
我们看到了如何利用 Openshift 平台，以一种简单、可访问的方式运行我们的 Spark 处理工作负载。利用 OCS 的优势，我们简化了处理 S3 存储后端的方式，并获得了双存储协议存储引擎解决方案来存储我们的数据集和笔记本电脑的数据库。希望你喜欢这个演示，下次再见:)
使用 Argo 和 Singer.io 在 Kubernetes 上运行数据复制管道
近年来，数百个数据团队已经迁移到 ELT 模式，利用 Stitch 或 FiveTran 等 SaaS 工具将数据可靠地加载到他们的基础设施中。根据我的经验，这些 SaaS 产品非常出色，可以显著加快您的生产时间。然而，许多人没有预算，或者没有需要适应的定制应用程序，或者只是喜欢使用自己的工具。
在这些情况下，一个解决方案是部署singer.iotap 和 targets——可以在任意源和目的地之间执行数据复制的 Python 脚本。Singer 规范是流行的 Stitch SaaS 的基础，它也被许多独立顾问和数据项目所利用。
Singer 管道是高度模块化的。您可以通过管道将任何分支连接到任何目标，以构建符合您需求的数据管道。尽管这使得它们非常适合 Docker 化管道，但我发现很难找到通过 Kubernetes 或 Docker 部署 Singer 管道的例子。最终，我们利用 Argo 工作流和容器化的歌手抽头和目标建立了一个管道。
没有 Argo 和 Kubernetes 的容器编排。图片来自 Unsplash 的 CHUTTERSNAP 。
本文从较高的层面介绍了工作流，并提供了一些示例代码来启动和运行一些共享模板。我假设你对 Docker 、 Kubernetes 和 Singer 规范有些熟悉。即使你是这些技术的新手，我也会试着指出一些有用的资源，为你指明正确的方向。
为什么要自己卷？
ETL 不是任何人进入数据科学或工程的原因。几乎没有创造力，大量的维护，直到出了问题才得到认可。幸运的是，像 Stitch 和 FiveTran 这样的 SaaS 工具已经将数据复制变成了小团队可以利用的商品。
数据复制的“已解决”性质使数据科学家更容易拥有端到端的项目，从而使数据工程师能够考虑“平台”而不是单点解决方案。StitchFix 在这方面有一个很棒的帖子。)这个市场的参与者认识到，真正与众不同的是“围绕”集成脚本的东西:例如，GitLab 的 Meltano 项目已经找到了一个合适的位置，成为集成过程的“跑步者”，而不是数据复制服务的逻辑。
歌手轻拍目标
当不存在受支持的连接器时——比方说，对于内部应用程序——第三方服务不会为您做太多事情。这时候 Singer.io 规范就派上用场了。Singer 管道有两个组成部分:
- tap 连接到服务，提取数据，然后使用 JSON 发出标准化的模式和记录流
- 目标读取 tap 的记录流并将其加载到仓库中
这种 tap 和 target 的分离分离了“提取”步骤和“加载”步骤。因此，一个拥有 10 个数据源和 1 个数据仓库的组织需要管理 10 个从 tap 到 target 的管道。但是，如果他们迁移这个数据库，他们只需要“换出”目标；他们不会对任何水龙头做任何改动。
Kubernetes 和 Argo 工作流程
然而，如果没有编排层，这些管道一文不值。我们致力于在 Kubernetes 上运行管道，这使我们来到了 Argo，一个用于编排并行“工作流”的开源引擎。它是其他编排工具(如 Airflow 或 Prefect)的替代工具，一个关键的区别在于它对容器的固有关注。这个数据委员会的演讲提供了一个与 Airflow 的很好的比较，特别是:Kubernetes——Argo 的本地工作流编排。
我们对我们的解决方案非常满意，但它并不适合所有人。调试 Kubernetes 作业可能比在专用 EC2 实例上调试 Python 脚本更具挑战性。然而，这种方法的回报是三重的:
- 部署的简易性和可移植性
- 容器内脚本/环境的标准化
- 其他数据基础设施也可以很容易地进行容器化和部署
说到这里，让我们试一试吧！
教程
在本教程中，我们将首先使用 Argo 和 MinIO 存储为工件和配置文件设置一个本地 Kubernetes 集群，然后我们将部署一个 Singer tap-to-target 工作流。最后，我们将讨论增强和扩展。
我们可以深入讨论这些领域中的任何一个，但是我会尽量让它变得浅显易懂，把对“生产”考虑的进一步讨论留到最后。本教程有以下先决条件:
- Docker 桌面。安装在本地，并打开 Kubernetes 功能。(如果您有另一个集群，也应该没问题。)
- 掌舵。我们将安装 Argo 和 MinIO 来运行本教程。
首先，我们将使用两个最简单的 singer.io 包——tap-exchangeratesapi 和target-csv——来演示这是如何工作的。下面的图片会让你对我们的发展方向有所了解:
完整的工作流模板。图片作者。
设置 Kubernetes、Argo 和 MinIO
在第一部分中，我们需要设置一个 Kubernetes 集群、Argo 工作流、一个工件存储库和几个存储桶。最简单的方法是使用 Docker for Desktop，它是多平台的，可以在其中部署一个 Kubernetes 集群。这也使本地开发变得更加容易，因为您可以构建容器并部署到本地集群，而无需推到外部容器存储库。
安装 Docker 桌面并启用 Kubernetes
你需要有一个 Kubernetes 集群，你有管理权限，可以用kubectl部署资源。如果你已经有了，那么你可以跳过这一节。如果你没有，最简单的方法就是使用 Docker for Desktop。你会想要遵循 Docker 网站上的文档。
- 为桌面安装 Docker。[ Mac
- 启用 Kubernetes。[ Mac
- 将 Docker 的资源分配提升到至少 12 GB，以确保 MinIO 部署有足够的空间。(见附近图片。)
- 测试
kubectl命令。[ Mac - 安装最新的 Argo CLI。[ Mac
您可能需要增加默认资源来容纳 MinIO。图片作者。
安装 Argo 工作流程
要安装 Argo，您可以遵循他们的[ 快速入门指南 ]，或者简单地使用下面的命令在您的集群中创建一个argo名称空间并部署“快速入门”资源。
kubectl create ns argokubectl apply \
-n argo \
-f https://raw.githubusercontent.com/argoproj/argo/stable/manifests/quick-start-postgres.yaml
您现在应该有一个 Argo 服务器和一些 Argo 使用的新 Kubernetes 资源类型，包括“Workflow”和“CronWorkflow”。要查看 Argo Workflows UI，您可以将 Kubernetes 端口转发到您的本地主机，并在浏览器中查看它。
kubectl -n argo port-forward deployment/argo-server 2746:2746
Argo 工作流为检查作业提供了一个有用的用户界面。图片作者。
设置 MinIO 存储器
Argo 工作流可以通过使用“工件”将文件传入或传出容器。对于本地部署，配置工件传递的一个简单方法是通过 Kubernetes 部署 MinIO 。Argo 有很多关于如何与亚马逊 S3 等其他服务建立这种关系的指南，但是你可以跟随下面的内容快速部署 MinIO。
注意，您需要安装helm(本质上是一个 Kubernetes 包管理器)。在 Mac 上，你可以使用 Homebrew 命令:brew install helm。然后，运行以下命令来添加 MinIO helm 图表:
helm repo add minio [https://helm.min.io/](https://helm.min.io/)helm repo update
接下来，您需要将 MinIO 部署到 Argo 名称空间中。这可能需要一两分钟，请耐心等待。
helm install argo-artifacts minio/minio \
-n argo \
—-set service.type=LoadBalancer \
--set defaultBucket.enabled=true \
--set defaultBucket.name=artifacts \
--set persistence.enabled=false \
--set fullnameOverride=argo-artifacts
您现在应该有一个工件服务器在运行，但是它是空的！我们必须创建一个工件桶，以及一个用于 singer 配置和输出的桶。要使用下面的命令，您需要 MinIO CLI 工具，您可以使用:brew install minio/stable/mc安装该工具。
mc config host add argo-artifacts-local [http://localhost:9000](http://localhost:9000) YOURACCESSKEY YOURSECRETKEYmc mb argo-artifacts-local/artifacts
mc mb argo-artifacts-local/singer
mc mb argo-artifacts-local/outputs
如果您喜欢通过 UI 创建 bucket，那么您可以转到端口 9000 — kubectl -n argo port-forward service/argo-artifacts 9000:9000 —然后创建一个artifacts和singer bucket。(请注意，默认凭据是 YOURACCESSKEY 和 YOURSECRETKEY。)
将 Argo 和 MinIO 一起映射
最后，我们需要告诉 Argo 默认的工件存储库在哪里，这样它就知道工件映射到哪个存储桶，并有适当的秘密进行认证。你可以遵循其他地方的说明但是为了简单起见，我建议将这个“补丁”应用到我整理的资源中。
wget -o patch.yml [https://raw.githubusercontent.com/stkbailey/data-replication-on-kubernetes/master/argo/argo-artifact-patch.yml](https://raw.githubusercontent.com/stkbailey/data-replication-on-kubernetes/master/argo/argo-artifact-patch.yml)kubectl patch configmap workflow-controller-configmap \
-n argo \
--patch “$(cat patch.yml)”
为了确保第一部分中的所有内容都能正常工作，请尝试运行 Argo 示例库中的“工件传递”示例。
argo submit -n argo [https://raw.githubusercontent.com/argoproj/argo/master/examples/artifact-passing.yaml](https://raw.githubusercontent.com/argoproj/argo/master/examples/artifact-passing.yaml) --watch
蓉城工作流程
你已经得到了库贝内特斯，你已经得到了阿尔戈:让我们不要再等了！运行以下命令:
argo submit \
-n argo \
--watch \
[https://raw.githubusercontent.com/stkbailey/data-replication-on-kubernetes/master/argo/tap-exchange-rate-workflow.yml](https://raw.githubusercontent.com/stkbailey/data-replication-on-kubernetes/master/argo/tap-exchange-rate-workflow.yml)
您应该会在终端中看到一个工作流启动。(或者，您可以转到该链接，复制文本并将其粘贴到 Argo Workflows 的“新工作流”UI 中。)如果您收到类似于failed to save outputs: timed out waiting for condition的错误消息，请尝试再次运行该工作流程——可能是 MinIO 设置未完成。
寻找那些漂亮的绿色对勾。图片作者。
您应该看到一个两步工作流创建和完成。现在，检查“输出”存储桶，看看有什么可用。
mc ls argo-artifacts-local/singer/outputs/tap-exchange-rates/
在大多数 Singer 工作流中，管道的输出实际上是加载到数据库中的数据——但是在这里，我们将 tap 输出导出到一个文件中，该文件由目标压缩并输出到 MinIO 中。
剖析工作流程
现在，让我们从头开始，看看 Argo 工作流刚刚发生了什么。
- 它启动了一个
tap-to-target多步骤工作流，由两个子步骤组成:tap和target步骤。 - 它启动了
tap子步骤，并传入一些配置文件，这些文件被映射到/tmp/config.json。当 tap 步骤完成时，/tmp/tap_output.txt处的输出文件存储在默认的 MinIO 工件库中。 - 然后启动
target子步骤，将配置和 tap 输出映射到容器文件系统中。当目标运行时，输出(来自 CSV 目标)被映射到outputsMinIO 桶。
模板逻辑。虽然“target-csv”目标会输出一个表，但大多数目标会将数据加载到数据库中。图片作者。
我不会深入到工作流文件本身，因为 Argo 上有很多很棒的文档。关于数据复制，有趣的是，这个过程是高度标准化的——无论您的 tap 或目标是什么，您基本上都是交换配置文件或容器地址。
码头歌手
在 Argo 级别模板化工作流也需要在容器级别模板化 Singer taps。让我们暂时把 Kubernetes 放在一边，专注于一个典型的歌手管道。这是一个线性过程:
- 点击输入:点击配置文件、目录文件、状态文件
- 点击输出:提取数据的文本输出(Singer 格式)
- 目标输入:目标配置文件，tap 的文本输出
- 目标输出:加载或导出的数据(例如，到数据库或 CSV 文件)和一个“状态”文件，其中包含有关上次提取的元数据
我们可以将容器本身视为黑盒，只要我们知道如何输入适当的输入和输出。为了使本教程简单，我预先创建了tap和target容器供我们使用。要进行测试，请运行以下命令:
docker run -e START_DATE=2020-08-01 stkbailey/tap-exchange-rates
不涉及太多细节，我们将 singer tap-abc或target-xyz命令封装在一个 Runner 对象中，该对象定义了在哪里查找必要的文件。(它可以在 Github 的 singer-container-utils 获得。)剥那只猫皮的方法有很多种，但重要的是要让它在多次轻拍中容易重现。
我们不会深究细节，但是每个 Docker 容器在初始化时都在运行一个 Python entrypoint.py脚本。入口点脚本的要点是:
- 确定适当的输入文件所在的路径。
- 基于文件可用性构建可执行命令。
- 运行命令并将输出写入文件。
它比直接运行 tap 的开销更大，但是当你有多个容器要运行时，这种抽象会让生活变得更容易。
模板化工作流程
总而言之:这种方法有价值的原因是因为您可以轻松地将“工作流”模板化，这样任何可以输出 Singer 格式数据的容器都可以替换为一行模板代码(以及一个配置文件)，这样您就有了一个新的工作流。
希望不难看出，通过一些额外的调整和一些保护良好的 S3 桶，这可以变成一个相当健壮的架构。一旦设置完成，您只需更改图像位置来添加新的 tap 容器。有一个很好的 UI 来检查日志和重新启动作业，并且很容易用 Slack 通知和附加作业来扩展模板。
我在附带的 GitHub repo 中创建了几个例子，包括带有tap-covid-19 Singer tap 的例子、WorkflowTemplate例子和可以每小时或每天运行的CronWorkflow规范。
只需对模板进行最少的编辑，即可同时运行多个拍子和目标。图片作者。
讨论
尽管建立这种架构对我来说很愉快，但它需要对基础设施、容器和 Singer 规范本身非常熟悉。你可能会发现 Pipelinewise 或 Meltano 可以用更少的开销和更多的附加功能为你做同样的工作。或者，您可能会发现您可以利用 Argo 和这些工具来管理数据复制。
作为一名数据科学家，有很多考虑因素。这些问题包括:
- 我是否有足够的预算来支付这笔费用(Stitch / Fivetran)？这些工具能满足我所有的数据复制需求吗？
- 更简单的(单节点)架构是否可行，比如 Meltano？我有其他需要管弦乐队的工作吗？
- Kubernetes 架构是否适合公司基础设施的其他部分？
- 为什么不用气流或者提督？
- 我是否拥有(或可以借用)设置和管理 Kubernetes 集群的基础设施专业知识？
我们的团队选择构建这种架构是因为:
- 我们(还)没有企业服务的预算，但发现我们需要运行定制的 tap。
- 我们已经习惯了容器化的应用程序。
- 我们公司基础设施的其余部分在 Kubernetes 上运行，并利用其他 Argo 产品，使协作更加容易。
- 我们有其他项目，如数据质量工作，我们需要一个平台来运行，我们以前没有与气流或完美的专业知识。
感谢阅读。乐于在 LinkedIn 或歌手 Slack 频道与他人联系。
其他资源
用 Visual Studio 代码运行 Jupyter 笔记本
数据科学家如何运行 Jupyter 笔记本的指南。ipynb 文件与您的。py 文件
Jupyter 笔记本引用中的虚拟数据示例。Visual Studio 中的 py 文件。作者在 Visual Studio 代码 [1]上截图。
目录
- 什么是 Visual Studio 代码？
- 什么是 Jupyter 笔记本？
- 为什么对数据科学家有好处？
- 关于数据集
- 我该如何开始(教程)？
- 导入类
- 结论
- 参考文献
什么是 Visual Studio 代码？
Visual Studio Code(VS Code)[1]是一个免费的、简单的平台，开发者使用它来存放、编辑和执行他们的代码。但是最近，越来越多的数据科学家已经利用这个文件和代码管理平台来处理他们的。py 和。ipynb 文件。
什么是 Jupyter 笔记本？
Jupyter Notebook 是数据科学家测试 Python 代码、模型和结果的研究环境和平台。它以扩展名保存。ipynb”，并且可以被执行，包含在其中执行代码的单独的单元。
为什么对数据科学家有好处？
拿着数据科学的理学硕士学位，以及体验各种数据科学和机器学习课程，我已经在我熟悉的 Jupyter 笔记本里变得太舒服了。以我的经验来看，Visual Studio 代码已经成为我在编程 Python 和实现机器学习模型时提高效率的工具。以下是数据科学家应该使用 Visual Studio 代码的主要原因:
- 更加擅长面向对象编程
- 在一个位置管理您的文件夹、文件和数据
- 查看你的笔记本。py 文件的同时
- 从数据科学家过渡到机器学习工程师
- 转换你的研究。ipynb 文件生产就绪。py 文件
关于数据集
数据集是在谷歌表单中创建的虚拟数据。它是为了模拟 2020 年冠状病毒疫情数据集的类似领域而开发的。这些字段包括日期、区域、记录计数和虚拟类别。遵循本教程时，不同的数据集，如真实的冠状病毒数据集 [2]只能用于教育和学术研究目的。该数据包含可以更好地表示的日期特性，这是本教程中实现的代码的目标。
我该如何开始(教程)？
启动 Visual Studio 代码的第一步是从这里【1】下载必要的包。它将是您计算机上的一个应用程序，是一个可视化和执行代码的平台。从这里开始，如果您选择使用 Python 作为您的主要编程语言，请在市场中搜索该扩展，如下所示。您还可以从这里克隆您的 GitHub 库，并开始发出 pull 请求和终端命令。对于我的例子，我选择创建一个新文件夹，其中包含三个 Python 文件的子文件夹和一个独立的 Jupyter 笔记本文件。我写出来的文件系统是:
visual-studio-code - >示例->(_ _ py cache _ )-> _ init _ _。py、introduction_class.py 和 read_df.py
visual-studio-code->visual _ studio _ code . ipynb
为您的 VS 代码选择 Python 扩展。作者在 Visual Studio 代码【1】上截图。
导入类
在我的例子中，我有帮助描述和显示如何设置你的数据科学算法的类。这些类的目标只是返回一个带有转换日期时间特性的 pandas 数据帧，以及一个可以被算法接收的数据帧。而我的 init。py 文件为空，不出所料，my introduction_class.py 包含一个类’ IntroductionClass ':
来源于GitHub【2】上的作者
下面是我的 read_df.py。如你所见，我使用 pandas 从一个. csv 文件中读取数据帧。我也从pandas【3】执行了一个简单的日期时间转换。“年/月”列被转换为包含月、月、年中某一天的“日期”。然后，我从 head 函数返回数据帧的前 5 行。这个类作为一个简单的例子来说明什么可以被导入到你的 Jupyter 笔记本中。
来源于GitHub【2】上的作者
导入的最后一部分包含在 Jupyter 笔记本本身中，“visual_studio_code.ipynb”。这个文件导入了两个 python 类。py 文件，其中包括“IntroductionClass”和“testClass”。下面，这些类在导入后被调用。它们返回预期的数据帧，第一个新的 Jupyter 笔记本代码由一个 pandas 函数操作，该函数描述了一个带有常用统计信息的数据帧列，在本例中是“确认恢复”字段。
从第一个例子开始，然后练习从。py 文件，您可以为生产创建更好的可伸缩且高效的代码。您可以跨职能工作，用面向对象的代码实现您的算法，然后以 Jupyter 笔记本的形式更好地测试和可视化您的数据框架，两全其美。
从继承的 visual_studio_code.ipynb 文件。py 文件。作者在 VIsual Studio 代码 [1]上截图。
结论
成为你的数据科学游戏的顶端可能是压倒性的和复杂的，但我相信通过新的和熟悉的工具，你可以提高你的技能，也可以变得更加擅长机器学习工程。我相信 Visual Studio 代码就是这些工具之一。
它帮助我导入 Python 类和函数，这些类和函数用于为可能的机器学习模型塑造我的数据框架。它可以作为一个平台，将您的 GitHub 存储库代码与您的 research Jupyter 笔记本并行设计。它是通向数据科学、数据工程和机器学习的优秀桥梁。
参考
我的 Visual Studio 代码设置是使用虚拟数据集创建的。要素/字段/列也是虚拟属性。图片是我自己对 VS 代码主文件管理平台的截图。我的 VS 代码截图中可视化的数据和指标不得用于任何医疗目的。它是静态的、非真实的，并且不依赖于准确性。它纯粹是为了教程的目的而开发的。
[1] M.Przybyla，视觉工作室代码 (2020)
[2] M.Przybyla， GitHub (2020)
[3]熊猫-发展，熊猫 (2020)
在 Azure Databricks 上运行 Apache Beam 数据管道
简要介绍如何在 Databricks 上执行 Apache Beam 管道
Github 资源库链接到本文
介绍
当我们想到数据并行管道时，Apache Spark 立即浮现在脑海中，但也有一些更有前途、更新颖的模型能够实现相同的结果和性能。
这就是 Apache Beam 的情况，它是一个开源的统一模型，用于定义批处理和流数据并行处理管道。它提供了以一种方便的方式定义数据管道的可能性，使用其分布式处理后端之一作为运行时( Apache Apex 、 Apache Flink 、 Apache Spark 、 Google Cloud Dataflow 以及许多其他)。
作者图片
Apache Beam 的强大功能在于更高层次的抽象，这可以防止程序员学习多个框架。
目前，Apache Beam 的使用主要局限于谷歌云平台，尤其是谷歌云数据流。
然而，当转移到其他平台时，可能很难找到一些有用的参考资料和例子来帮助我们运行 Apache Beam 管道。
这就是为什么我想告诉你我如何在 Databricks 上运行 Apache Beam 管道的经验。
让我们建立我们的阿帕奇光束管道
注意:这个演练的代码可以在 this Github repository 获得。
我决定从官方的 Apache Beam 的 Wordcount 例子开始，改变一些细节，以便在 Databricks 上执行我们的管道。
官方代码只是从 Google 云存储中读取一个公共文本文件，对输入文本进行字数统计，并将输出写入给定的路径。为了简化这个过程，我们将通过简单地从代码内模拟的字符串中读取输入文本来代替这些操作，最后将字数统计结果打印到标准输出中。
输入字符串将被定义为列表:
然后我们创建一个简单的光束自定义 DoFn 变换来打印我们的结果:
我们最终的管道将是这样的:
我们现在有了一个可以在本地模式下执行的工作射束管道。
如果您尝试运行它，您应该看到它打印成您的标准输出:
20/06/01 13:14:13 INFO transforms.PrintFN: against: 1
20/06/01 13:14:13 INFO transforms.PrintFN: and: 1
20/06/01 13:14:13 INFO transforms.PrintFN: of: 2
20/06/01 13:14:13 INFO transforms.PrintFN: troubles: 1
20/06/01 13:14:13 INFO transforms.PrintFN: nobler: 1
20/06/01 13:14:13 INFO transforms.PrintFN: arrows: 1
20/06/01 13:14:13 INFO transforms.PrintFN: suffer: 1
20/06/01 13:14:13 INFO transforms.PrintFN: sea: 1
20/06/01 13:14:13 INFO transforms.PrintFN: The: 1
20/06/01 13:14:13 INFO transforms.PrintFN: Or: 1
20/06/01 13:14:13 INFO transforms.PrintFN: not: 1
20/06/01 13:14:13 INFO transforms.PrintFN: slings: 1
20/06/01 13:14:13 INFO transforms.PrintFN: that: 1
20/06/01 13:14:13 INFO transforms.PrintFN: is: 1
20/06/01 13:14:13 INFO transforms.PrintFN: arms: 1
20/06/01 13:14:13 INFO transforms.PrintFN: Whether: 1
20/06/01 13:14:13 INFO transforms.PrintFN: a: 1
20/06/01 13:14:13 INFO transforms.PrintFN: fortune: 1
20/06/01 13:14:13 INFO transforms.PrintFN: take: 1
20/06/01 13:14:13 INFO transforms.PrintFN: question: 1
20/06/01 13:14:13 INFO transforms.PrintFN: To: 1
20/06/01 13:14:13 INFO transforms.PrintFN: mind: 1
20/06/01 13:14:13 INFO transforms.PrintFN: to: 3
20/06/01 13:14:13 INFO transforms.PrintFN: outrageous: 1
20/06/01 13:14:13 INFO transforms.PrintFN: or: 1
20/06/01 13:14:13 INFO transforms.PrintFN: tis: 1
20/06/01 13:14:13 INFO transforms.PrintFN: in: 1
20/06/01 13:14:13 INFO transforms.PrintFN: the: 2
20/06/01 13:14:13 INFO transforms.PrintFN: be: 2
现在，让我们转到数据块
现在，我们想在 Databricks 实例上执行我们的管道。为了实现这一点，我们需要修改代码中的一些东西。首先，我们修改我们的 WordCountOptions，，它必须扩展 SparkContextOptions 类。为了操作光束的 SparkContext ，这些光束选项是必要的。Databricks 集群有自己的 SparkContext，这对检索至关重要，以便扩展应用程序。一旦我们检索到 SparkContext，我们可以直接将其注入到 Beam 的 SparkContextOptions 中，如下所示:
有了这个 Beam 代码的最终版本，我们现在可以在 Azure 中启动我们的 Databricks 工作区，并继续创建一个新的作业。
我们将我们的项目打包到一个 fat jar 中(在本例中，我将使用标准的 maven 生命周期来打包我的应用程序)，并通过单击“Upload Jar”将它上传到我们的作业中。
请注意，如果您的 pom.xml 文件中有任何 Spark 依赖项，请记住将它们标记为" provided " ，，因为我们的 Databricks 集群将通过执行上下文将它们提供给我们的应用程序。
Jar 上传
指定主类后，使用这些将由 SparkContextOptions: 解析的参数是很重要的
--runner=SparkRunner --usesProvidedSparkContext
最后，我们可以通过点击编辑来设置将与我们的作业相关联的集群:
集群配置
这样，我们在 Databricks 运行时版本 6.4 上定义了一个“ 新的自动化集群 ”和 2 个工人。如果您愿意，您还可以创建一个“交互式集群”，这样您可以更好地控制集群的执行。
现在，我们可以走了！
如果您的工作看起来与下图相似，只需点击“立即运行”，然后等待其终止。
运行 Apache Beam 管道的 Databricks 作业示例
终止后的执行状态
请注意，如果您已经用 python 编写了您的 Beam 管道，那么让它在数据块上工作的过程应该看起来或多或少是相同的:
只需记住将数据块’ SparkContext 注入到 Beam 中，并使用正确的参数集执行您的管道。
我希望你喜欢我关于如何在 Azure Databricks 上运行 Apache Beam 管道的演练*,如果你找到了关于这个主题的更多有用的见解，请随时联系我！*
在 Azure Kubernetes 服务上使用 RocksDB 运行 Apache Flink
最近，我在研究如何部署一个使用 RocksDB 作为后端状态的 Apache Flink 集群，发现缺少关于这个主题的详细文档。我能够从 Flink 文档和一些堆栈溢出的帖子中拼凑出如何部署它，但是没有一个清晰的指南。我写这篇文章的目的是展示一个从 Flink 1.11.0 开始如何做到这一点的逐步指南。对于 AWS 部署，只需稍加修改即可遵循本指南。我会注意到这些变化。
先决条件
在开始阅读本指南之前，您应该已经订阅了 Azure，并且拥有一个正在运行 blob store 的存储帐户。如果你需要帮助来设置和运行这些服务，请参见本文底部的链接部分，那里有关于如何设置这些服务的 Azure 指南的链接。
如果你还没有安装 flink、azure-cli 和 docker，也可以下载它们的链接。
步骤 1:构建自定义 Docker 映像
为 Flink 后端状态使用 Azure Blob 存储或 AWS S3 存储需要一个额外的插件 jar，该插件 jar 没有内置到基本 Flink docker 映像中。要添加所需的 jar，首先需要从 GitHub 下载 apache/flink-docker repo。
这个 repo 包含用于为 Apache Flink 构建 Docker 映像的 Docker 文件，并用于构建“官方”映像…
github.com](https://github.com/apache/flink-docker)
下载完 repo 后，导航到包含您要部署的 Flink 版本的文件夹。在我的例子中，我想使用 1.11，然后如果你计划使用 scala 代码，导航到你正在使用的 scala 版本的目录。我使用 scala 2.12，所以对我来说这个文件夹是scala_2.12-debian。如果你使用 java 或者 python，我相信你可以使用任何一个版本。在这个文件夹中，你应该会看到两个文件:Dockerfile和docker-entrypoint.sh。我们将要编辑的文件是 Dockerfile。在文本编辑器中打开它，并在COPY docker-entrypoint.sh行的正上方添加以下几行。
对于 Azure Blob 存储:
# install Flink Azure FS Hadoop plugin
RUN mkdir ./plugins/azure-fs-hadoop
COPY ./flink-azure-fs-hadoop-1.11.0.jar ./plugins/azure-fs-hadoop/
对于 AWS S3，您有两个选项 Presto 和 Hadoop:
转眼间:
# install Flink S3 FS Presto plugin
RUN mkdir ./plugins/s3-fs-presto
COPY ./flink-s3-fs-presto-1.11.0.jar ./plugins/s3-fs-presto/
Hadoop:
# install Flink S3 FS Hadoop plugin
RUN mkdir ./plugins/s3-fs-hadoop
COPY ./flink-s3-fs-hadoop-1.11.0.jar ./plugins/s3-fs-hadoop/
接下来从 Flink 1.11.0 文件夹导航到/opt/目录，将后端所需的 jar 复制到你编辑的 docker 文件所在的目录。对于 Azure，这个 jar 是 flink-Azure-fs-Hadoop-1 . 11 . 0 . jar
现在，使用以下命令构建 Docker 映像并将其推送到 DockerHub，用您的 DockerHub 用户名替换 hunterkempf，并更改标签以反映 flink、scala 和您添加到其中的插件的版本:
docker build --tag hunterkempf/flink:1.11.0_scala_2.12_fs_azure .
docker push hunterkempf/flink
步骤 2: Kubernetes 部署
[## Flink Kubernetes 设置
这个页面描述了如何在 Kubernetes 上部署 Flink 作业和会话集群。信息本页描述部署…
ci.apache.org](https://ci.apache.org/projects/flink/flink-docs-release-1.11/ops/deployment/kubernetes.html#appendix)
首先，转到 Flink Kubernetes 设置页面并创建以下内容。yaml 文件，并从附录中复制/粘贴。
- flink-configuration-config map . YAML
- jobmanager-service.yaml
- 作业管理器-会话-部署. yaml
- 任务管理器-会话-部署. yaml
flink-configuration-config map . YAML
您需要在flink-conf.yaml部分添加以下几行:
此示例针对名为:flinkstorage 的存储帐户中名为:flinkblob 的 blob 存储区。您还需要获取存储帐户的访问密钥，并将其粘贴到 fs . azure . account . Key . flink storage . blob . core . windows . net 之后:
state.backend: rocksdbstate.checkpoints.dir: wasbs://flinkblob@flinkstorage.blob.core.windows.net/flink/fs.azure.account.key.flinkstorage.blob.core.windows.net:
job manager-session-deployment . YAML 和 task manager-session-deployment . YAML
将image: flink:1.11.0-scala_2.11替换为您在第 1 部分中为 jobmanager-session-deployment 和 taskmanager-session-deployment 创建的 docker 映像的名称。
连接到 AKS 集群
运行这两个命令来连接到 AKS 集群
az aks install-cli
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
将 Flink 部署到 AKS
从创建 yaml 文件的目录中，运行以下命令
kubectl create -f flink-configuration-configmap.yaml
kubectl create -f jobmanager-service.yaml
kubectl create -f jobmanager-session-deployment.yaml
kubectl create -f taskmanager-session-deployment.yaml
现在你应该有一个 Flink 集群运行在 AKS 上，使用 Azure Blob 存储作为 RocksDB 后端。
查看 Flink 仪表盘
要访问 Flink 仪表盘，请运行以下命令:
kubectl get pods
这将返回类似下面的内容
NAME READY STATUS RESTARTS AGEflink-jobmanager-5f857bf45d-n4mbt 1/1 Running 0 38sflink-taskmanager-68854b7998-2zkd6 1/1 Running 0 31sflink-taskmanager-68854b7998-vvm5m 1/1 Running 0 31s
复制 flink-jobmanager pod 的名称，并将其用于以下命令，用您的值替换5f857bf45d-n4mbt
kubectl port-forward flink-jobmanager-5f857bf45d-n4mbt 8081:8081
现在打开 http://localhost:8081 ，您应该会看到 Flink 仪表盘
要检查您的配置，请单击左侧的作业管理器选项卡
您应该会看到类似的东西，您的设置在键值标记中列出。
为了测试部署，您可以从位于examples/streaming/文件夹中的 Flink 1.11.0 文件夹上传一个测试 jar
运行流式字数统计作业花了 1 秒钟，没有为我返回任何错误。如果出现内部服务器错误，请检查作业管理器日志，查看错误堆栈跟踪。
链接:
这里有一些有用的链接供进一步阅读
Azure 文档:
Azure CLI 可安装在 Windows、macOS 和 Linux 环境中。它也可以在 Docker 中运行…
docs.microsoft.com](https://docs.microsoft.com/en-us/cli/azure/install-azure-cli?view=azure-cli-latest) [## 在 portal - Azure Kubernetes 服务中创建一个 AKS 集群
Azure Kubernetes Service (AKS)是一个托管的 Kubernetes 服务，可以让您快速部署和管理集群。在…
docs.microsoft.com](https://docs.microsoft.com/en-us/azure/aks/kubernetes-walkthrough-portal) [## 创建存储帐户- Azure Storage
Azure 存储帐户包含所有 Azure 存储数据对象:blobs、文件、队列、表和磁盘。的…
docs.microsoft.com](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-create?tabs=azure-portal) [## 快速入门-使用 Azure 门户创建 blob-Azure 存储
在这个快速入门中，您将学习如何使用 Azure 门户在 Azure 存储中创建容器，以及上传和…
docs.microsoft.com](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal)
Flink 文档:
[## Flink Kubernetes 设置
这个页面描述了如何在 Kubernetes 上部署 Flink 作业和会话集群。信息本页描述部署…
ci.apache.org](https://ci.apache.org/projects/flink/flink-docs-release-1.11/ops/deployment/kubernetes.html#deploy-session-cluster) [## 本地 Flink 安装
按照以下几个步骤下载最新的稳定版本并开始使用。为了能够运行 Flink，唯一的…
ci.apache.org](https://ci.apache.org/projects/flink/flink-docs-release-1.11/try-flink/local_installation.html) [## Azure Blob 存储
Azure Blob Storage 是微软托管的服务，为各种用例提供云存储。
ci.apache.org](https://ci.apache.org/projects/flink/flink-docs-stable/ops/filesystems/azure.html) [## 状态后端
部署&操作状态&容错状态在数据流 API 中编写的后端程序通常保持状态…
ci.apache.org](https://ci.apache.org/projects/flink/flink-docs-release-1.11/ops/state/state_backends.html#the-rocksdbstatebackend) [## 配置
部署和操作配置所有的配置都在 conf/flink-conf.yaml 中完成，这应该是一个平面的…
ci.apache.org](https://ci.apache.org/projects/flink/flink-docs-release-1.11/ops/config.html)
码头工人:
[## 用于 Mac 和 Windows 的 Docker 桌面
5 月 28 日上午 9 点 PDT / GMT -7 了解更多关于 Docker 的…
www.docker.com](https://www.docker.com/products/docker-desktop)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
