创建多标签分类人工智能:创建我们的数据集[第 1 部分]
使用 Pandas 创建我们的数据集，使用 FastAI 库和 Python 进行深度学习以开发 REST API，我们将制作一个能够区分电影剧照中几个元素的 AI，并将其部署到生产中。
Françoise Dorléac and Jean-Paul Belmondo in “L’homme de Rio” (1964).
该项目将分为四个不同的条款:
- 从数据库中创建我们的数据集到熊猫；
3.用 Docker 把我们的 AI 作为 REST API 部署到生产中；
4.每个月做一个脚本重新训练我们的 AI。
介绍 Whatthemovie.com
创建于 2008 年的 Whatthemovie 是一个独特的电影问答游戏，人们上传电影剧照，其他人必须猜猜这张照片是从哪部电影中拍摄的。在十多年的时间里，该网站已经从我们的优秀用户上传的 30 000 部电影中积累了超过 470 000 张图片。
我们重视质量胜于数量。因此，并非所有提交的图像都会被接受。今天，我们可以拥有超过一百万张图片，但这不是我们的首要任务。上传的图像必须对测验有趣，测验本身应该在难度和电影类型方面保持平衡。
主要区域如下所示:
Can you guess what movie is behind this shot?
给你一张取自电影场景的图片，你必须猜电影的名字。旗帜意味着你不必输入原始标题来获得分数，你也可以用德语、法语、西班牙语等来写。我们支持多种语言的替代游戏，让来自世界各地的用户有机会与其他用户一起游戏和竞争。
改善上传阶段
在网站上上传新的电影剧照听起来可能很容易:你从我们的数据库中选择一部电影——或者添加一部新的——你上传你的图像，你就可以开始了。实际上，用户必须首先用任何可用的播放器从电影中自己拍摄快照，裁剪图像中潜在的黑条，并通过上面描述的上传阶段。
在上传阶段的最后一步，我们要求我们的用户添加标签，描述图像包含的内容，图像中有什么——图像是否显示街道、汽车等。这看起来也相对容易，但他们已经做了很多工作，我们的大多数上传者都懒得添加标签，这很不幸，因为相关标签对过滤照片很重要。
Anna Karina in “Le petit soldat” (1963). You can see the tags below the shot. When you click on one of them — like “b/w” for black and white — , you can see all the black and white movie snapshots uploaded on the website.
过滤黑白快照听起来可能没什么意思，但想想其他标签，如“戈尔”、“裸体”或“血液”。这些标签显示了明显的敏感内容，一些用户不希望看到这些图片——至少在没有询问他们的情况下。这就是为什么标记图像很重要。如果一个用户忘记在他的照片上添加“裸体”或“戈尔”标签，一个用户在工作中玩——很多都是这样！—可能会看到这个图像，没有人希望这种情况发生在开放的计划中。
事实上，我们已经在网站上添加了一个设置，让用户选择他们是否希望这种快照自动显示。但显然，如果一张快照没有被标记为敏感的——“血染”或“裸体”，它仍然会显示出来。**这引出了我们今天的项目:**当用户上传他们的快照时，我们能自动向他们建议标签吗？我们能否建立一个能够检测图像中相对常见元素的人工智能，以帮助人们标记他们的照片？我们能否检测图像中的裸体或血块材料，以防止明智的人看到它们？
在这个系列的第一部分，我们将从从我们的数据库创建一个数据集开始，并用 Pandas 清理它。然后，在第二篇文章中，我们将开始使用 FastAI 训练一个 AI，并尝试优化它，以在预测图像中的元素时获得我们可以获得的最佳结果。接下来，我们将找到一种方法，用 Docker 将我们的 AI 部署到生产中。最后，我们将尝试编写一个脚本，每个月用上传的新数据自动重新训练我们的 AI。
从玛丽雅姆到熊猫
我们的网站由 Ruby on Rails 提供支持，这使得数据库结构非常容易创建、理解和维护。在我们为这个项目处理的所有数据中，我们实际上只对两个表感兴趣:“shots”表和“tags”表。这些表格有我们需要的所有数据。前者有图像 ID 及其文件名。后者将所有标签添加到一个特定的“refID”——在我们的例子中，就是我们的图像 ID。
有几种方法可以将这些表格导出为我们关心的格式。熊猫，我们将要用来准备数据来训练我们的 AI 的库，可以读取几种文件类型，如 CSV 文件。这很幸运，因为 PhpMyAdmin 能够将表格直接导出为 CSV 文件。
Don’t forget to check “Put columns names in the first row” before exporting.
PhpMyAdmin 是一种很好的转换方式，但是我们更喜欢通过命令行进行导出，将 CSV 文件直接保存在服务器上。让我们首先使用 mysqldump 将我们的两个表导出到 SQL 文件:
现在我们已经导出了表格，我们可以使用 James Mishra 制作的这个伟大的 Python 脚本将它们转换成 CSV 文件:
我们现在准备好和熊猫一起工作了！
准备和清理我们关于熊猫的数据
我们现在有了格式良好的数据。我们可以开始使用 Pandas 来探索数据，只保留我们感兴趣的表中的列，并将这两个表合并，以获得一个非常好的数据集，为训练我们的 AI 做好准备。
安装熊猫并使用它的最好方法是安装 Anaconda 。这是一个很棒的软件包，默认附带了很多用于深度学习的图书馆，如 Pandas。你可以在本页找到如何安装。
安装 Anaconda 的另一个优势是默认包含的 Jupyter。Jupyter 可以让你直接在浏览器中进行一些 Python、Pandas 和机器/深度学习编码，这非常方便，因为你可以创建和显示数据图表，以检查它显示了什么，更好地决定保留什么等等。启动 Jupyter 很容易，只需在安装后的终端中键入jupyter notebook。
加载数据
开始编码吧！一旦我们启动了 Jupyter，我们就必须导入我们需要的 libairies 在本例中，是 Pandas、Numpy 和 Matplotlib。
我们现在可以打开熊猫的 CSV 文件并开始挖掘。让我们先打开“标签”表。
With .head(), we can see the first rows of our table and its structure directly in Jupyter.
这里我们可以做的第一件事是删除我们不需要的列。“标记”表包含标记的“值”、标记链接到的快照的 ID——“ref _ ID”以及添加它的用户。当您通过 Ruby on Rails 的生成器创建新表时，它们会自动生成列“created_at”和“updated_at”。
让我们只保留“id”、“值”和“ref_id”列:
Only keep the values we care about!
在这个项目中，我们的目标不是找到图像中每一个可能的元素，而是找出最常见的元素，或者更准确地说，是网站上最常用的标签。通过熊猫和.value_counts()函数，我们可以很简单地发现:
Some of the most-used tags on the website.
显示这里使用的前 400 个标签可能有些夸张，但是我们已经可以在第一批结果中找到一些需要清理的数据。我们可以看到，在第 5 个位置，我们有标签“真棒上传”，或者在第 13 个位置，我们有“SotD”标签。这些标签在我们的例子中没有用，因为有些标签没有描述图像上的内容。其实都和网站的系统有关。
带有“精彩上传”标签的照片意味着它是由高级用户上传的，在这种情况下，图像被自动接受，没有投票，没有选择。因此，我们不想保留这个标签，并试图在新上传的图像上建议它—它已经自动完成了。
这同样适用于“SotD”标签，意思是“每日快照”。每天，评分最高的照片都会得到奖励、提升和上传者。它没有描述快照中的任何内容，所以我们不需要它。
另一个有趣的是“情侣”标签。一对夫妇很难被认出来。可能是两个男人，两个女孩，一个男人和一个女孩等等。此外，我们如何以及何时决定应用这个标签？当人与人之间很亲近的时候。接吻？拥抱？很难看出区别。**更重要的是，因为我们的网站是一个问答游戏，所以标签必须只描述图像显示的内容，这一点很重要。标签不应该泄露任何关于我们试图猜测的电影的线索。**如果一个上传者——他显然已经看过这部电影——添加了“情侣”标签，这就泄露了关于这部电影的一些信息，我们不希望这样。如果我们看到两个人接吻，这并不意味着他们是一对，也不意味着他们离得很近。
去掉我们不想建议的标签
在移除标签之前，我们可以合并非常相似的标签。例如，我们有带有“电话”标签或“电话”标签的照片。既然它描述的是同一个东西，我们可以把它们合并成一个单一的“电话”:
我们还对其他标签进行了同样的处理，如“飞机”和“飞机”或“红发人”和“红发人”,之后我们会删除表格中可能出现的重复标签，以确保一切都是干净的:
对于这个项目，我们决定保留那些至少被添加了 500 次以上的标签，并排除一些如上所述的标签。Pandas 提供了一个方便的函数来检查一个列的值是否是不同值列表的一部分，并且只保留这些值。在这里，我们想要相反的。我们希望从数据集中排除一系列标签。我们可以使用.isin()函数，该函数通常只返回值与列表元素之一匹配的行。但是如果我们在函数前面加上~,它会做我们正在寻找的事情，排除一系列标签——就像一个isNOTin()函数。
这次操作之后，我们还剩下 183 个不同的标签。我们现在可以在“tags”表中只保留包含其中一个带有.isin() 函数的行:
Our “tags” table is now ready to be merged!
将“标签”表与“照片”表合并
现在我们已经清理了我们的“标签”表，只保留了最常用和最有趣的标签，我们必须使用 Pandas 来创建一个包含标签和图像数据的独特的表。我们知道“tags”表中的“ref_id”列指的是“shots”表中图像的“id”。Pandas 使得合并两个不同的表变得容易，这两个表有一个与merge函数相同的“键”。
让我们首先加载并检查“shots”表的结构:
A few columns of our “shots” table.
这里我们只关心“id”列，它指的是网站上的镜头 ID，以及存储电影快照文件名的“shot_image_id”列。是时候合并两个表了！正如我们已经知道的，我们在这两个表之间有一个公共的键，所以这很容易。让我们用熊猫来做这项工作:
Both tables have been merged into one.
合并数据后，我们将再次删除最终数据集中我们不感兴趣的所有列。但是我们也要将每个图像的所有标签重新组合到一个单元格中。例如，您可以在上面看到 id 为“2”的图像有三个不同的行，这意味着它有三个不同的标签与之相关联—“值”列中的“床”、“腿”、“文本”。
我们将把给定图像的所有标签重新分组到一个单元格中，用逗号分隔:
Our final table: an image ID and its tags.
为了清楚起见，我们还将包含标记的列重命名为“tags”，将列“ref_id”设置为 index，并将其重命名为“id”。很好，现在我们的数据集已经准备好训练我们的 AI 了！通过使用tags_grouped.shape，我们看到我们的数据集中有 243 558 张图片，至少有一个相关的标签和 183 个不同的标签。
最后要做的是将数据集导出到 CSV 文件:
下一步是什么
在我们系列的第一篇文章中，我们使用熊猫从头开始创建了我们自己的数据集。在清理它并只保留有用的数据之后，现在是时候开始考虑如何使用这个数据集来创建和训练一个能够区分电影快照中不同元素的 AI，并向用户建议这些元素作为标签。这将是我们第二篇文章的主题。敬请期待！
创建多标签分类人工智能:训练我们的人工智能[第 2 部分]
在我们的第一篇文章中，我们从头开始创建和清理了一个关于熊猫的数据集，现在我们要用我们的数据训练一个人工智能来区分电影快照中的几个元素。
Gérard Depardieu and Patrick Dewaere in “Les Valseuses” (1974).
这个项目被分成四个不同的条款:
2.使用 FastAI 创建能够标记电影快照的 AI；
3.用 Docker 把我们的 AI 作为 REST API 部署到生产中；
4.每个月做一个脚本重新训练我们的 AI。
我们在哪里？
通过上一篇文章，我们成功地创建了一个数据集，它将电影快照和描述图像内容的相应标签结合在一起。
提醒一下，该数据集由 243 558 幅图像组成，带有 183 个不同的标签。这是一个简单的 CSV 文件，如下所示:
Our dataset: an image ID and its associated tags.
我们现在将使用这个数据集来创建和训练一个人工智能，它将能够检测和建议用户上传的图像元素。但是怎么做呢？我们可以选择什么库来制作这个 AI？我们去哪里找快速训练我们的 AI 所需的 CPU 和 GPU 资源？
在这个系列的第二部分中，我们首先要找到并创建一个适合这个繁重任务的环境。然后，我们将选择 FastAI ，当今最有前途的深度学习图书馆之一，来制作我们的人工智能，并希望在文章结束时，我们可以导出一个好模型，以便在我们的网站上使用它。
设置环境
为了用 FastAI 训练我们的 AI，我们需要找到可以在短时间内处理超过 25 万张图像的最佳环境。我们的网站运行在两个专用的服务器上，有很好的硬件来服务 Ruby on Rails 应用程序。但是计算机视觉需要很多资源，尤其是一个好的 GPU——而我们的服务器没有。因此，我们需要找到一个平台，能够以便宜的价格甚至免费，按需为我们提供这些资源。
这是幸运的，因为有两个主要的在线平台可以以非常简单的方式提供我们正在寻找的环境。
Kaggle，一个数据科学项目的地方
Kaggle 是一个知名的社区网站，供数据科学家在深度学习挑战中竞争。参加比赛后，你会得到一个数据集，你必须创建一个人工智能，在这个数据集上给出最好的结果。你可以随意使用任何深度学习库。
Kaggle is famous for hosting competitions where you can win thousand of dollars.
但是说 Kaggle 只是关于竞争是不正确的。事实上，Kaggle 还向数据科学家免费提供数百个数据集，学习该领域最常用的工具的课程，更重要的是，免费提供一个拥有丰富资源的现成环境**。**
然后，你可以直接在其他数据科学家的网站上参加比赛，与他们展开较量。他们给你你需要的一切:一个类似 Jupyter 的界面，一些磁盘空间，一个好的 CPU 和一个 GPU。只需点击几下，你就可以开始训练一个人工智能！
FastAI，我们将在这个项目中使用的库，也可以在 Kaggle 上获得。实际上，这个项目很大程度上受到了这个内核的启发，你可以在那里找到 FastAI 的创造者杰瑞米·霍华德——用他的图书馆参加著名的星球:从太空了解亚马逊比赛。他只用了几行代码就获得了极好的结果。
你可以在他们的官网上找到关于如何在 Kaggle 上开始使用 FastAI 的不错的教程。
虽然 Kaggle 似乎是我们项目的完美之地，但它也有一些限制。我认为 Kaggle 是一个不错的网站，在那里你可以玩和尝试不同种类的东西。但对于严肃的深度学习项目，你将不得不转向一个真正的供应商，给你更多的灵活性，更多的资源。
谷歌云平台
由于我们希望能够导出我们的模型，并以自动方式每月重新训练我们的 AI，我们需要为我们的任务找到一个更好的主机，在那里我们可以根据我们的需要深度定制我们的环境。谷歌云平台似乎是解决这一问题的最佳场所。它以合理的价格提供许多服务。注册时你甚至可以免费获得一年 300 美元的积分。
The list of services GCP provides is ridiculously long.
与 GCP 合作肯定需要更多的时间和工作。您基本上必须创建一个虚拟机，并安装项目所需的一切。主要的优点是你可以自由地为你的项目创建任何类型的虚拟机。您可以建立一个拥有大量资源的虚拟机，甚至可以在世界范围内选择虚拟机所在的地区。
幸运的是，网上有很多教程可以帮助你开始学习 GCP。FastAI 有一个关于如何开始在谷歌云平台上使用他们的图书馆的专用教程。按照他们的指示，你应该有一个环境，里面有开始训练人工智能所需的所有工具。
当我们必须每月重新训练我们的模型时，将我们的环境放在云上肯定会使事情变得更容易。GCP 为他们提供的几乎所有服务提供 API，包括创建、启动和停止虚拟机。这是一个非常重要的特性，可以降低重新训练的难度。
用 FastAI 创建一个 AI
我们创建了一个运行在谷歌云平台上的虚拟机，配有一个很棒的 GPU——在我们的例子中是一个 NVIDIA Tesla P100，配有 16gb 的 VRAM。就像我们在以前的文章中用熊猫创建数据集一样，我们将使用 Jupyter 与 FastAI 进行交互。但首先，让我们谈谈这个令人敬畏的图书馆。
FastAI 库提供了一个高级 API，能够为许多不同的应用程序创建深度学习模型，包括文本生成、文本分析、图像分类和图像分割。FastAI 对于 Pytorch 就像 Keras 对于 Tensorflow 一样:一组更直观的抽象，使得用几行代码开发深度学习模型变得很容易。
FastAI 会为您处理许多参数或超参数，默认情况下会产生良好的性能——当然，一切都是可定制的。
但是 FastAI 不仅仅是一个图书馆，它还是一门很棒的进入深度学习的课程。该课程分为两部分，可在的网站上免费获得。它非常适合新手，因为它可以让你在没有大量领域知识的情况下快速玩深度学习模型。这个项目完全基于这个课程和 FastAI，所以感谢他们的出色工作！
现在我们开始编码吧！像往常一样，我们首先必须通过 Jupyter 导入我们需要的所有图书馆:
预处理数据集
我们要做的第一件事是预处理我们的数据集。预处理是非常重要的一步，尤其是在处理图像的时候。为了获得更好的性能，甚至为了让神经网络理解我们在喂它什么，我们必须将图像标准化并调整它们的大小。
在我们的项目中，我们正在处理来自电影的快照。电影可以有许多不同的长宽比。想想老电影:大多数都是用正方形格式制作的——4/3。但如今，它都是关于宽屏幕的——16/9——甚至更宽的宽高比，如 2.35 或 2.39。
The most-used aspect ratios in the cinema industry.
因此，为了使我们的人工智能更有效，预处理步骤是至关重要的:我们需要确保我们所有的数据在训练部分都具有相同的格式。为此，我们首先加载包含数据集的 CSV 文件:
通过这两行代码，FastAI 基本上读取了我们的数据集文件，并理解了我们的图像存储在一个名为“images”的文件夹中，后缀为“”。jpg”。ImageList是一个内置功能，让你轻松做计算机视觉。你可以在他们伟大的文档部分找到更多关于这个函数或者整个库的信息。
变量“data”现在包含了与数据集相关的所有内容。我们可以开始预处理了:
大部分的评论不言自明，但我会详细一点。我们要做的第一件事是使用split_by_rand_pct方法将数据集分成两部分:
- 一个训练集:它将包含用于训练我们的 AI 的图像和标签。我们将原始数据集的 90%用于训练集。
- 验证集:AI 没有用来学习的图像和标签。这些图像仅由模型看到，以验证它是否正确学习以及性能是否变得更好。就此而言，我们使用原始数据集的 10%，因此值为“0.1”。
A visualisation of the splits. Test set is optional.
其次，我们用label_from_df方法告诉 FastAI 在哪里寻找每个图像的标签。在我们的例子中，标签位于 CSV 文件的第二列(不包括索引列)，由逗号分隔。
接下来是有趣的部分，预处理。通过transform 方法——更具体地说是get_transforms()函数——我们要求 FastAI 对我们的图像执行一些工作，以便创建“更多”数据。这被称为数据扩充**。当您的训练集中没有足够的数据时，这尤其有用。默认情况下，FastAI 将对其处理的训练图像应用一些技术，最常见的是仿射变换，如水平或垂直翻转、旋转等。还有非仿射变换，如调整大小，裁剪，亮度变化等。它将在每次迭代中基于单个图像创建新的图像变体。**
Examples of data augmentation techniques: rotation, flip, brightness.
我们正在做的下一个转换是调整图像的大小，正如你所看到的，这对我们来说很重要。我们决定选择 224 像素乘 224 像素的正方形大小，因为它对于计算机视觉来说似乎是一个很好的值，特别是当我们在最后一行使用 ImageNet 标准化图像时。
我们决定选择数字“3”。它相当于“挤压”方法。其他可用的方法有“裁剪”、“填充”或根本不调整大小。
The difference methods available to resize our images.
我们选择了“挤压”方法，因为经过几次测试后，我们发现这是最适合我们的情况的方法，因为我们想在调整大小后保留原始图像的所有信息，而不管它们的原始大小和纵横比。每次都给了我们最好的结果。
最后，我们使用 ImageNet 统计来标准化我们的图像。标准化涉及使用著名的 ImageNet 数据集的平均值和标准差。使用平均值和标准差是一个非常标准的做法。因为它们是用一百万张图像计算出来的，所以统计数据相当稳定。这会使训练更快。
定义我们的神经网络结构
一旦我们完成了预处理，是时候创建我们的神经网络架构并开始训练我们的 AI 了。我们将在这个项目中使用迁移学习**。迁移学习是一种技术，其中在一个任务上训练的模型被重新用于第二个相关的任务——在我们的例子中，检测电影快照中的元素。这种技术可以非常有用，例如，帮助那些没有知识从零开始创建他们的深度神经网络的人，无论是资源还是时间。或者只是为了避免完全重新编码，而我们可以使用一个现成的、适合我们的数据类型的类似模型。**
我们将使用最近为图像分类创建的最有趣的模型之一，名为" Resnet " —其他可用的模型在这里列出。Resnet 是一种残差神经网络，有几种版本，深度可达 152 层——“resnet 152”。它在图像识别方面提供了令人难以置信的结果。
通过迁移学习，我们将获得这个已经训练好的模型的预训练权重，该模型已经在属于 1000 个不同类别的数百万张图像上进行训练，并使用这些已经学习的特征来预测新的类别，即我们的标签。这样做的主要优点是，我们不需要非常大的训练数据集来快速获得好的结果。
让我们以“Resnet152”作为预训练模型来制作我们的架构，创建一个广泛应用于计算机视觉的卷积神经网络。CNN 是一种深度学习算法，它可以将图像作为输入，为图像中的各个方面或对象分配重要性，并能够区分它们。非常适合我们！
Create our neural network structure : CNN, Resnet152 and two metrics: accuracy and FBeta.
我们定义了两个函数作为神经网络的度量，以帮助我们评估它是否表现良好。第一个是精度阈值。为什么是门槛？简单地说，因为在这里，我们不是在制作一个多类分类器，我们希望我们的人工智能只为每张图像预测一个类——概率最高的一个。我们正在制作一个多标签分类器，这意味着每幅图像可以有不同的类别——或者为零。
在我们的例子中，我们有 183 个不同的类。所以我们对每张图片的每一类都有一个概率。但是，我们不仅仅要挑选其中的一个，我们要从这 183 个班级中挑选出 n 。基本上，我们将每个概率与某个阈值进行比较。然后我们会说，任何高于这个阈值的东西，都意味着图像中确实有这个元素。杰瑞米·霍华德使用 0.2 作为他的竞争门槛，因为它似乎普遍工作得很好。我们决定听从他的建议。因此，给定图像的概率高于 0.2 的每个类别将被视为该图像的一部分。
第二个度量被称为“FBeta”。这是一个众所周知的指标，在数据科学家行业或 Kaggle 主办的比赛中广泛使用。当你有一个分类器，你会有一些假阳性和假阴性。你如何权衡这两件事来创造一个单一的数字，并评估性能？有很多不同的方法可以做到这一点，而“FBeta”是一个很好的方法，可以将它们组合成一个单一的数字。它考虑了精确度和召回率。你可以在这里阅读更多关于“T4”的信息。
Both precision and recall are used to compute FBeta.
The FBeta formula.
我们开始训练吧
我们现在已经有了一个现成的带有迁移学习的卷积神经网络，Resnet152 和两个指标。是时候训练我们的数据了！让我们从 10 个时期开始——一个时期意味着我们所有图像的一次迭代。
The results after 10 epochs.
没有那么多的工作，我们已经得到了相当好的结果！精确度看起来不错，FBeta 一直在上升。对你们中的一些人来说，Fbeta 分数可能看起来很低，但请记住，我们正在研究超过 183 个不同的类，我们并不试图创造一个完美的人工智能，它可以绝对预测图像包含的每个元素。我们正在努力使人工智能能够建议网站上最常用的标签，如“黑白”、“动画”、“男人”、“女人”等。
尽管如此，仍有改进的余地。我们可以尝试调整我们神经网络的学习速率，看看它是否能导致更好的结果。学习率是深度学习中一个非常重要的超参数。如果选择得不好，神经网络的表现就不会很好。默认情况下，FastAI 使用单周期策略，这意味着学习率将在每次迭代中先增加，然后降低。
The one-cycle policy in pictures. Source
单周期策略允许非常快速地训练神经网络，这意味着它将快速收敛到低损失值。但要让它发挥作用，我们需要找到最佳学习率，让单周期政策真正发挥作用。FastAI 提供了寻找最佳学习率的函数:
The loss seems to explode with a large learning rate.
我们可以从上面的图表中看到，大的学习率似乎没有帮助。其实学习率越大，损失越大。我们不希望这样。我们可以限制我们的学习速率来避免这种情况，并使用这个更新的参数重新开始训练。此外，我们不仅要重新开始训练，只有我们的神经网络的最后一层被更新。相反，我们这次将更新所有的权重，包括使用上面使用的函数unfreeze()的 Resnet 的 152 层权重。
We define a maximum learning rate to avoid having a loss that goes high.
Our results after 10 another epochs.
列车损失似乎变得更低，而 FBeta 似乎也变得更高。一切看起来棒极了！我们可以尝试另一种学习速率，训练更多一点，希望提高我们模型的性能，但我们已经可以看到我们最有可能处于最佳能力，介于欠拟合和过拟合之间。
The figure shows the optimal capacity that falls between underfitting and overfitting. When reached, we can stop the training. It’s called “early stopping”. Source: https://arxiv.org/pdf/1803.09820.pdf
事实上，在第四个时期之后，我们的验证损失开始高于训练损失。但更重要的是，它似乎没有减少，而在此期间，培训损失不断减少。我们甚至可以看到，验证损失在某个时期开始增加。这无疑是一个信号，表明我们可能已经达到了模型的最佳容量，我们应该停止这里的训练，否则我们可能会开始过度适应。
当您在相同的数据上训练过多的模型时，就会发生过度拟合。当需要在它从未见过的数据上测试你的模型时，在它的舒适区之外，模型开始表现不佳，因为它只习惯于识别训练数据，而不是其他。它不能很好地概括新的、看不见的数据。该模型学习特定于训练数据的模式，这些模式在其他数据中是不相关的。
对测试图像的预测
我们最好在这里停止训练，到此为止。我们可以先用save()函数保存我们的模型，然后导出我们的模型，其中包含所有优化的权重和偏差:
Save the model just in case we want to start again from this point and export the pre-trained model to use on production.
如果我们的人工智能在电影快照的建议标签上正确执行，我们可以快速测试各种数量的图像。我们将一百张人工智能从未见过的电影剧照放在一个文件夹中，并创建了一个快速的 Python 脚本来显示每张图像的预测标签及其各自的概率:
A few examples of the testing set with the predicted tags and their respective probability.
好像很管用！当然，它没有列出所有图像中可能显示的元素，但这从来不是我们的目标。我们想创造一个人工智能，当用户上传电影快照时，它可以向用户建议常用标签，我认为它工作得很好。几乎三分之二的时候，人工智能会提示图像中所有可能的元素。这并不意味着其余的时间它没有暗示任何东西，只是没有所有的元素——可能只有一两个标签。
一如既往，还有改进的空间，但对于第一款车型，我们对结果很满意。重要的是要记住，根据我们的人工智能，只有出现概率超过 20%的标签才会显示在这里。我们希望建议我们确信图像中确实存在的标签。
下一步是什么？
现在我们已经做了一个能够检测电影快照中元素的 AI，并在简单测试后导出了性能良好的模型，我们如何将这个单个文件转化为我们网站上的服务？我们如何在我们的服务器上实现人工智能，并与当前的 Ruby on Rails 后端交互？这将是我们下一篇文章的主题，我们将使用 Docker 在 Python 中创建一个 REST API，以允许我们的网站向 AI 发送请求，AI 将返回给定图像中存在的标签。敬请期待！
创建多页 Dash 应用程序
制作仪表板是向编码人员和非编码人员传达数据科学项目价值的好方法！
对于我们这些从事数据科学工作的人来说，我们的数据技能往往伴随着前端开发技能的缺乏。由 Plotly 构建的 Dash 库提供了简单的 boiler plate 代码，用于开发 Python 中的交互式 web 应用程序。
寻找灵感，查看 仪表盘图库 ！
在本文中，我将介绍构建一个基本的多页面 dash 应用程序的步骤。该项目的代码和数据可以在 this Github repo 中找到。
为什么是多页应用？
学习构建一个多页面应用程序是非常有用的，原因有很多。以下是一些例子:
- 允许为方法或背景信息添加单独的页面。
- 将一个复杂的数据项目分解到多个页面中可以带来流畅的用户体验。
- 可以用来建立一个在线投资组合！
- 理解工作流可以作为进入 web 开发世界的一小步。
应用程序结构:
项目目录:
index.py 最终是运行整个应用程序的文件。可以把它看作是项目的目录。每个页面将在单独的文件中构建，然后导入到 index.py 中。此工作流用于保持文件的简洁和可读性，并保持项目结构的组织性和灵活性。
D.R.Y 代码
该工作流有助于避免重复代码。例如，这个应用程序的每个页面都需要一个导航栏。组件只是被导入，而不是在每个文件中编写相同的代码。
创建目录和环境
首先，我们创建一个文件夹来保存我们所有的项目文件:
注意:我个人更喜欢使用 Visual Studio 代码或 Pycharm，但是为了使本演练易于理解，我们将坚持在终端中构建该应用程序。
在终端中:
mkdir dash_app
cd dash_app
接下来我们要做的是创建一个虚拟环境来构建应用程序。不，这在技术上不是一个要求，但是它消除了产生依赖错误的风险，并且通常是构建 web 应用程序时的最佳实践。
pip install virtualenv
virtualenv venv
source venv/bin/activate
(venv)现在应该出现在终端中的$符号之前。这意味着您现在正在使用您的虚拟环境。
随着虚拟环境的激活，我们需要安装我们将用于这个项目的库。
pip install pandas
pip install dash
pip install dash-bootstrap-components### These are dependences and are likely already installedpip install dash-core-components
pip install dash-html-components
pip install plotly
构建导航栏:
注意:导航栏和主页其余部分的代码直接从 dash bootstrap components 网站复制而来。
Dash bootstrap 组件将网页划分成网格，是组织 web 应用布局的有用工具。有关定位应用程序组件(网页上出现的任何内容)的更多信息，请点击此链接并查看 dbc 的使用。Row 和 dbc.Column
在终端中打开 vim 文本编辑器。
vim navbar.py
s
s 启用了编辑模式，这样我们就可以开始编写代码了！
在 navbar.py 中:
import dash_bootstrap_components as dbcdef Navbar():
navbar = dbc.NavbarSimple(
children=[
dbc.NavItem(dbc.NavLink("Time-Series", href="/time-series")),
dbc.DropdownMenu(
nav=True,
in_navbar=True,
label="Menu",
children=[
dbc.DropdownMenuItem("Entry 1"),
dbc.DropdownMenuItem("Entry 2"),
dbc.DropdownMenuItem(divider=True),
dbc.DropdownMenuItem("Entry 3"),
],
),
],
brand="Home",
brand_href="/home",
sticky="top",
)return navbar
在上面的第六行中，href 参数告诉应用程序将哪个页面返回给用户(如果在开头放置 https://就可以导航到外部网站！)
在这行代码中，我们将 href 设置为“/time-series”。这将是我们的时间序列图的链接名称。
保存并退出文件。
Esc
:wq [ENTER]
主页:
vim homepage.py
## s to enable edit mode
在 homepage.py 中，我们首先需要导入所需的库。
import dash
import dash_bootstrap_components as dbc
import dash_core_components as dcc
import dash_html_components as html
我们还想从 navbar.py 导入 navbar 函数，并创建一个 Navbar 对象。
from navbar import Navbarnav = Navbar()
构建主页主体:
该页面的布局将是 2 个网格空间的网格。1 行，2 列。
第一栏:
- 页眉
- 段落
- 纽扣
第二栏:
- 页眉
- 图表
额外加分:把图形改成图像。
body = dbc.Container(
[
dbc.Row(
[
dbc.Col(
[
html.H2("Heading"),
html.P(
"""\
Donec id elit non mi porta gravida at eget metus.Fusce dapibus, tellus ac cursus commodo, tortor mauris condimentumnibh, ut fermentum massa justo sit amet risus. Etiam porta semmalesuada magna mollis euismod. Donec sed odio dui. Donec id elit nonmi porta gravida at eget metus. Fusce dapibus, tellus ac cursuscommodo, tortor mauris condimentum nibh, ut fermentum massa justo sitamet risus. Etiam porta sem malesuada magna mollis euismod. Donec sedodio dui."""
),
dbc.Button("View details", color="secondary"),
],
md=4,
),
dbc.Col(
[
html.H2("Graph"),
dcc.Graph(
figure={"data": [{"x": [1, 2, 3], "y": [1, 4, 9]}]}
),
]
),
]
)
],
className="mt-4",
)
下一位代码重要。
因为我们正在构建一个多页面应用程序，我们需要能够将布局导入到其他文件中。为此，我们将构建一个主页函数，返回页面的整个布局。
注意:布局必须始终是一个破折号 html 组件。标准是将布局包装在一个 div 中。
def Homepage():
layout = html.Div([
nav,
body
])return layout
在继续之前，让我们确保应用程序正常工作。为此，请将以下代码添加到页面底部。
app = dash.Dash(__name__, external_stylesheets = [dbc.themes.UNITED])app.layout = Homepage()if __name__ == "__main__":
app.run_server()
保存并退出 vim。
Esc
:wq [ENTER]
太好了！现在让我们运行应用程序，以确保代码正常工作！
python homepage.py
如果应用程序失败，将打印出一条错误消息。习惯这个，很大程度上是应用构建的工作流程。对我来说，90%的时间是一个简单的语法错误。阅读错误信息并调试问题。(如果我的代码有问题，请在评论中告诉我！)
如果应用程序运行，将打印出几行。重要的一行应该是这样的:
Running on [http://127.0.0.1:8050/](http://127.0.0.1:8050/)
复制 http url 并将其粘贴到互联网浏览器中。
转眼间。一个应用诞生了！
在你欣赏你的作品一段时间后，关闭网络应用。
[CTR] C
##### It will look like this in terminal: ^C
应用
现在让我们建立我们的交互式图形页面！
首先，我们创建一个 app.py 文件。
vim app.py
## s to enable edit mode
接下来，导入应用程序的库、我们的 Navbar 函数以及伊利诺伊州的人口数据。
### Data
import pandas as pd
import pickle### Graphing
import plotly.graph_objects as go### Dash
import dash
import dash_core_components as dcc
import dash_html_components as html
import dash_bootstrap_components as dbc
from dash.dependencies import Output, Input ## Navbar
from navbar import Navbardf = pd.read_csv('[https://gist.githubusercontent.com/joelsewhere/f75da35d9e0c7ed71e5a93c10c52358d/raw/d8534e2f25495cc1de3cd604f952e8cbc0cc3d96/population_il_cities.csv](https://gist.githubusercontent.com/joelsewhere/f75da35d9e0c7ed71e5a93c10c52358d/raw/d8534e2f25495cc1de3cd604f952e8cbc0cc3d96/population_il_cities.csv)')df.set_index(df.iloc[:,0], drop = True, inplace = True)df = df.iloc[:,1:]
最后两行代码只是将日期列设置为索引，然后从数据集中删除该列的副本。
好，现在让我们建立一些组件！
导航条:
nav = Navbar()
标题:
我们将使用标题向用户提供一些说明。
header = html.H3(
'Select the name of an Illinois city to see its population!'
)
下拉列表:
对于这个应用程序，我们将建立一个下拉菜单。在后台，下拉菜单被格式化为字典列表。这本词典有两个关键词。“标签”和“价值”。label =用户将在下拉菜单中看到的内容，value =返回给应用程序以查询数据的内容。
因为每一列都是伊利诺伊州的一个城市，所以我们将使用这个数据集的列名进行查询。
每一列都被格式化为“伊利诺伊州的城市”。让每个标签都包含“伊利诺伊州”有点大材小用，因为我们只寻找伊利诺伊州的城市。在下面的代码中，我们将删除每个词典标签的这部分额外文本:
options = [{'label':x.replace(', Illinois', ''), 'value': x} for x in df.columns]
现在，我们将字典列表直接插入到一个下拉对象中
重要: 任何交互的组件都必须有一个 id 名。你很快就会明白为什么了。此外，组件不能共享 id 名称。如果一个 id 被多次使用，将会抛出一个错误，应用程序将会中断。
dcc 中的参数。下拉功能有。
- id: 组件的唯一标识符。格式化为字符串。
- **选项:**带有“标签”和“值”键的字典列表
- value: 应用程序加载时下拉菜单设置的默认值。(我从数据集中随机选择了一个城市作为默认城市。)
dropdown = html.Div(dcc.Dropdown(
id = 'pop_dropdown',
options = options,
value = 'Abingdon city, Illinois'
))
下拉完成！
输出空间:
这是我们输出图表的地方。
output = html.Div(id = 'output',
children = [],
)
这是所有的组件！
现在，就像我们制作主页一样，我们将制作一个名为“App”的布局功能。
def App():
layout = html.Div([
nav,
header,
dropdown,
output
])return layout
好的，现在让我们制作图表。我们将创建一个 build_graph 函数，该函数将从下拉菜单中接受一个城市，并返回一个显示该城市人口趋势的图表。
def build_graph(city):data = [go.Scatter(x = df.index,
y = df[city],
marker = {'color': 'orange'})]graph = dcc.Graph(
figure = {
'data': data,'layout': go.Layout(
title = '{} Population Change'.format(city),
yaxis = {'title': 'Population'},
hovermode = 'closest'
)
}
)return graph
好吧！这个文件到此为止。确保保存并退出。
Esc
:wq [ENTER]
索引
现在，让我们用一个 index.py 文件将它们集合起来！
vim index.py
## s to enable edit mode
导入所有的库和函数。
import dash
import dash_core_components as dcc
import dash_html_components as html
from dash.dependencies import Input, Output
import dash_bootstrap_components as dbcfrom app import App, build_graphfrom homepage import Homepage
接下来，我们声明一个 dash app 对象。为了美观，我们将通过传入 dbc.themes 外部样式表来使用主题。主题的名字总是大写的，并且包含在一个列表中。随意阅读可用的主题这里。
app = dash.Dash(__name__, external_stylesheets=[dbc.themes.UNITED])
重要: 为了让我们的时间序列图具有交互性，我们要为下拉菜单和输出空间创建一个回调函数。但是，dash 不允许回调布局中不存在的组件。因为主页布局中没有下拉菜单或输出空间，所以我们必须更改应用程序的配置。
app.config.suppress_callback_exceptions = True
接下来，我们创建一个 dcc。Location 对象，在应用程序中不可见，但监视 url。这将告诉我们的应用程序根据用户点击的链接返回一个页面。
现在，创建一个内容空间，我们可以在这里返回主页或时间序列页面。
app.layout = html.Div([
dcc.Location(id = 'url', refresh = False),
html.Div(id = 'page-content')
])
复试
好吧！现在让我们使我们的应用程序具有交互性，这样当用户点击某些东西时，事情就会发生。
我们需要两次复试。一个用于返回应用程序的不同页面，另一个用于更新图表。
为此，我们声明@app.callback
在 app.callback 中，我们传递在文件顶部导入的输出函数。输出的参数是:
- 正在更新的组件的 id。
- 正在更新的组件的参数。(90%的情况下，您将更新一个 div，并且该参数将被设置为“children”)
注意:一个回调可以更新多个输出空间。只需将所有输出函数包装在一个列表中。
接下来，我们将输入函数传递给 app.callback。
-
- 输入总是包含在列表中。即使只有一个输入*
- 输入参数与输出参数相同
在这种情况下，我们输出到我们的“页面内容”div，并从我们的“url”位置输入。
[@app](http://twitter.com/app).callback(Output('page-content', 'children'),
[Input('url', 'pathname')])
def display_page(pathname):
if pathname == '/time-series':
return App()else:
return Homepage()
现在我们为我们的时序图创建回调。
因为我们做了一个 build_graph 函数，所以这个回调超级简单。
[@app](http://twitter.com/app).callback(
Output('output', 'children'),
[Input('pop_dropdown', 'value')]
)
def update_graph(city):graph = build_graph(city)return graph
最后，让应用程序运行。
if __name__ == '__main__':
app.run_server(debug=True)
注意，我已经设置了 debug=True。在部署应用程序时，您应该将其设置为 false，但我们正处于开发阶段，将 debug 设置为 True 会使应用程序的调试变得更加容易。
保存并退出:
Esc
:wq [ENTER]
并运行应用程序！
python index.py
结论
这是一个简单的例子，但是这些基础可以用来构建更加复杂和强大的应用程序！
发表评论，如果你有任何问题，请告诉我。
附:退出您的虚拟环境。
deactivate
在 OpenCV 和 Flask 中创建一个简单的图片搜索引擎
了解如何使用 OpenCV 提取图像中像素的颜色，然后通过 CSS 十六进制颜色代码搜索图像
我最近开始玩 OpenCV ，一个用于图像处理的开源计算机视觉库。幸运的是有 Python 绑定可用。更幸运的是，像阿德里安这样的人已经做了一个伟大的服务，他们发布了关于类似主题的书和博客。
那么这到底是怎么回事呢？嗯，这很简单，或者我说，是最简单的使用 OpenCV 加载图像并找到与该图像相关的颜色，并在基于 Flask 的 web 应用程序中显示见解的演示。这不是一个国家的艺术应用程序，也不是目前我打算做的方式，但嘿，这只是一个开始，而不是结束。除了把我对像素的基础学习转化成一个 产品 (Google！当心！！)
我不会深入 OpenCV 和 Flask 的细节，我将介绍应用程序实际上在做什么。
该应用程序由两部分组成:一个基于网络的应用程序，用于存储来自网络的图像并显示处理后的图像及其主色；一个命令行脚本，用于运行下载的图像并提取颜色代码。网页图像如下所示:
你通过颜色代码搜索图片，它会返回如下结果:
单个图像的视图看起来像:
让我们讨论系统的核心部分，也就是执行主要工作的命令行脚本。
def process_image(image_name):
color_count = {}
print('Processing the image {}'.format(image_name))
path = 'website/static/uploaded_images/' + image_nameimage = cv2.imread(path)for i in range(image.shape[0]):
for j in range(image.shape[1]):
(b, g, r) = image[i, j]
h_value = rgb2hex(r, g, b)if h_value in color_count:
color_count[h_value] += 1
else:
color_count[h_value] = 1
return color_count
导入计算机视觉后，我们通过调用cv2.imread()从磁盘读取图像。数据以numpy数组的形式提供，因此使用它的shape方法来查找宽度、高度和通道等细节。顺便说一下，OpenCV 以 BGR 格式存储图像数据，而不是 RGB 颜色空间。一旦数据被检索为 BGR 格式，我们就使用一个定制的rgb2hex方法将 RGB 转换为十六进制颜色。该函数然后返回一个字典列表，其中包含十六进制的颜色代码及其频率，我们将使用它来查找图像中颜色的百分比。我还做了一个演示，可以在 youtube 视频中看到。
结论
这是 OpenCV 中的一个基本图像处理教程。它不是一个成熟的产品，因为它不能告诉你图片中独特的颜色。它只是告诉你基于像素颜色的信息，而不是基于 ML 算法执行颜色分割和聚类。
希望在接下来的几周内，我会就更高级的话题进一步讨论 OpenCV。
像往常一样，这些代码可以在 Github 上找到。
本帖原载 此处 。
如何在 R 中生成单词云
如何以及何时使用它们的简单步骤
创建单词云的 4 个主要步骤
在接下来的部分中，我将向你展示如果你想用 r 生成一个单词云，需要遵循的 4 个简单步骤。
步骤 1:检索数据并上传包
要生成文字云，你需要下载 R 版本的文字云 包以及颜色的 RcolorBrewer 包。注意还有一个 wordcloud2 包，设计略有不同，应用也很好玩。我将向您展示如何使用这两个包。
install.packages("wordcloud")
library(wordcloud)install.packages("RColorBrewer")
library(RColorBrewer)install.packages("wordcloud2)
library(wordcloud2)
最常见的是，词云被用来分析 twitter 数据或文本语料库。如果你正在分析 twitter 数据，只需通过使用 rtweet 包上传你的数据(参见这篇文章了解更多信息)。如果你正在处理一篇演讲、一篇文章或任何其他类型的文本，确保将你的文本数据作为一个语料库加载。一个有用的方法是使用 tm 包。
install.packages("tm")
library(tm)#Create a vector containing only the text
text <- data$text# Create a corpus
docs <- Corpus(VectorSource(text))
步骤 2:清理文本数据
在生成你的单词云之前，清理是必不可少的一步。事实上，为了让您的分析带来有用的见解，您可能需要从文本中删除特殊字符、数字或标点符号。此外，您应该删除常见的停用词，以产生有意义的结果，并避免最常见的频繁出现的词，如“I”或“the”出现在词云中。
如果你正在使用 tweets ，使用下面一行代码来清理你的文本。
gsub("https\\S*", "", tweets$text)
gsub("@\\S*", "", tweets$text)
gsub("amp", "", tweets$text)
gsub("[\r\n]", "", tweets$text)
gsub("[[:punct:]]", "", data$text)
如果你正在处理一个文集，有几个软件包可以用来清理你的文本。下面几行代码向您展示了如何使用 tm 包来做到这一点。
docs <- docs %>%
tm_map(removeNumbers) %>%
tm_map(removePunctuation) %>%
tm_map(stripWhitespace)
docs <- tm_map(docs, content_transformer(tolower))
docs <- tm_map(docs, removeWords, stopwords("english"))
步骤 3:创建文档术语矩阵
下一步你要做的是建立一个数据框架，在第一列中包含每个单词，在第二列中包含它们的频率。
这可以通过使用来自 tm 包的 TermDocumentMatrix 函数创建一个文档术语矩阵来完成。
dtm <- TermDocumentMatrix(docs)
matrix <- as.matrix(dtm)
words <- sort(rowSums(matrix),decreasing=TRUE)
df <- data.frame(word = names(words),freq=words)
或者，特别是如果你使用 tweets，你可以使用 tidytext 包。
tweets_words <- tweets %>%
select(text) %>%
unnest_tokens(word, text)words <- tweets_words %>% count(word, sort=TRUE)
第四步:生成单词云
字云 包是生成字云最经典的方式。下面一行代码向您展示了如何正确设置参数。例如，我选择研究美国总统在联合国大会上的演讲。
set.seed(1234) # for reproducibility wordcloud(words = df$word, freq = df$freq, min.freq = 1, max.words=200, random.order=FALSE, rot.per=0.35, colors=brewer.pal(8, "Dark2"))
可能发生的情况是，您的单词云裁剪了某些单词，或者干脆不显示它们。如果发生这种情况，请确保添加参数 scale=c(3.5，0.25) 并摆弄数字，使单词 cloud 合适。
词云的另一个常见错误是显示了太多不常用的词。如果是这种情况，请确保调整最小频率参数 (min.freq=…) ，以便使您的词云更有意义。
这个 wordcloud2 包使用起来更有趣，允许我们做一些更高级的可视化。例如，你可以选择你的文字云以特定的形状甚至字母出现(参见这个小插图获取有用的教程)。作为一个例子，我使用了相同的联合国演讲语料库，并生成了如下所示的两个单词云。很酷，对吧？
wordcloud2(data=df, size=1.6, color='random-dark')
wordcloud2(data=df, size = 0.7, shape = 'pentagon')
你应该使用单词云的 3 个理由
- 文字云是杀手可视化工具。它们以简单明了的格式呈现文本数据，就像云一样，其中单词的大小取决于它们各自的频率。因此，它们在视觉上看起来很好，也很容易理解。
- 字云是很棒的沟通工具。对于任何希望交流基于文本数据的基本见解的人来说，无论是分析演讲、捕捉社交媒体上的对话还是报告客户评论，它们都非常方便。
- 字云见解深刻。视觉上引人入胜，单词云让我们能够快速得出一些见解，允许在解释它们时有一定的灵活性。它们的视觉形式刺激我们思考，并根据我们希望分析的内容得出最佳见解。
那么，什么时候该用词云呢？
是的，单词云是有洞察力的，伟大的交流和可视化工具。尽管如此，它们也有自己的限制，理解这一点是知道什么时候使用它们，什么时候不使用它们的关键。
单词云本质上是一种描述工具。因此，它们应仅用于捕捉基本定性洞察。视觉上吸引人，它们是开始对话、演示或分析的绝佳工具。然而，他们的分析仅限于洞察力，根本不具备更广泛的统计分析的能力。
我经常写关于数据科学和自然语言处理的文章。关注我的Twitter或Medium查看更多类似的文章或简单地更新下一篇文章。 感谢阅读！
使用 Flask 和 Heroku 创建一个 API 来部署机器学习模型
Photo by Ian Simmonds on Unsplash
机器学习模型是基于可用数据进行预测的强大工具。为了使这些模型有用，需要部署它们，以便其他人可以通过 API(应用程序编程接口)轻松访问它们来进行预测。这可以使用 Flask 和 Heroku 来完成——Flask 是一个微型 web 框架，不需要特定的工具或库来创建 web 应用程序，Heroku 是一个可以托管 web 应用程序的云平台。
要使用 Flask 和 Heroku 成功部署机器学习模型，您需要以下文件:model.pkl、app.py、requirements.txt 和一个 Procfile。本文将介绍如何创建这些所需的文件，并最终在 Heroku 上部署应用程序。该员额的主要部分如下:
- 创建 GitHub 存储库(可选)
- 使用大量数据创建和筛选模型
- 创建烧瓶应用程序
- 本地测试烧瓶应用程序(可选)
- 部署到 Heroku
- 测试工作应用程序
根据您在流程中所处的阶段，您可以随意跳过其中任何一项！
创建 Github 存储库(可选)
为了便于以后在 Heroku 上部署，您需要为这个项目创建一个 github 存储库，并克隆它以供本地使用。要创建新的存储库，请单击右上角的个人资料图标，单击“存储库”，然后单击“新建”。为您的存储库命名，使用自述文件初始化存储库，并添加一个许可证，如下例所示:
要克隆存储库，请转到存储库页面，单击“克隆或下载”并复制链接。在终端中，转到要克隆存储库的文件夹，并键入命令:
git clone link_to_repository
运行此命令会将存储库克隆到您的本地计算机上，您可以检查以确保文件夹是在正确的位置创建的。既然回购已经设置好了，我们就可以创建机器学习模型并对其进行处理了。
创建和筛选机器学习模型
首先，让我们使用 Titanic 数据集创建一个简单的逻辑回归模型。根据阶级、年龄、兄弟姐妹数量和票价等信息，该模型将预测是否有人在泰坦尼克号上幸存。如果你想了解我的例子，你可以在这里找到数据集的 csv 文件。在您的工作目录中创建一个 Jupyter 笔记本，并通过运行以下代码创建模型:
import pandas as pd
from sklearn.linear_model import LogisticRegression# create df
train = pd.read_csv('titanic.csv') # change file path# drop null values
train.dropna(inplace=True)# features and target
target = 'Survived'
features = ['Pclass', 'Age', 'SibSp', 'Fare']# X matrix, y vector
X = train[features]
y = train[target]# model
model = LogisticRegression()
model.fit(X, y)
model.score(X, y)
上面的代码从 csv 数据创建了一个 pandas dataframe，删除了空值，定义了模型的特征和目标，将数据拆分为一个只包含特征的矩阵和一个包含目标的向量，并拟合逻辑回归模型，然后对其进行评分。
这就创建了一个模型，它可以以大约 70%的准确率预测泰坦尼克号乘客的存活率，然后可以使用:
import pickle
pickle.dump(model, open(‘model.pkl’, ‘wb’))
pickle 文件可以在 Jupyter 笔记本的同一个目录中找到。
编写烧瓶应用程序
打开您的 IDE(我使用 PyCharm)并创建一个新的。工作目录中的 py 文件名为app.py
flask 应用程序的代码可以在下面找到(python v3.7 版)。
**import** pandas **as** pd
**from** flask **import** Flask, jsonify, request
**import** pickle
*# load model* model = pickle.load(open(**'model.pkl'**,**'rb'**))
*# app* app = Flask(__name__)
*# routes* @app.route(**'/'**, methods=[**'POST'**])
**def** predict():
*# get data* data = request.get_json(force=**True**)
*# convert data into dataframe* data.update((x, [y]) **for** x, y **in** data.items())
data_df = pd.DataFrame.from_dict(data)
*# predictions* result = model.predict(data_df)
*# send back to browser* output = {**'results'**: int(result[0])}
*# return data* **return** jsonify(results=output)
**if** __name__ == **'__main__'**:
app.run(port = 5000, debug=**True**)
代码的结构如下:
- 装载酸洗模型
- 命名烧瓶 app
- 创建一个接收 JSON 输入的路由，使用训练好的模型进行预测，并以 JSON 格式返回预测，可以通过 API 端点访问。
在路由内部，我将 JSON 数据转换为 pandas dataframe 对象，因为我发现这适用于大多数(不是所有！)您希望用来进行预测的模型类型。您可以选择使用您喜欢的方法来转换输入，只要它与您的模型的.predict()方法一起工作。输入的顺序必须与用于训练模型的数据帧中的列顺序相匹配，否则在尝试进行预测时会出现错误。如果您正在接收的输入顺序不正确，您可以在创建数据帧后轻松地对其进行重新排序。
这里的要点是，您需要将从请求中获得的 JSON 数据转换成模型可以用来进行预测的数据结构。如何到达那里取决于你自己。
一旦将它粘贴到 app.py 文件中，您就可以从命令行运行 flask 应用程序(或者如果您使用 PyCharm，只需运行代码)。要从命令行运行应用程序，请使用:
python app.py
如果操作正确，您将看到类似这样的内容:
错误提示:如果这是您第一次创建 flask 应用程序，您可能会得到一个错误提示，提示您需要将 flask 安装到 python 环境中。使用
!pip install flask并重试。
当你的 flask 应用程序启动并运行时，点击蓝色链接，你应该会看到这个——这很正常:
可选的，但是你真的应该:测试应用程序是否工作
将requests和json导入到你的 Jupyter 笔记本中，然后用你的本地服务器创建一个变量，如果它与下面的不同:
# local url
url = '[http://127.0.0.1:5000'](http://127.0.0.1:5000') # change to your url
创建示例数据并转换为 JSON:
# sample data
data = {'Pclass': 3
, 'Age': 2
, 'SibSp': 1
, 'Fare': 50}data = json.dumps(data)
使用requests.post(url, data)发布样本数据并检查响应代码。您希望获得 200 的响应代码，以确保应用程序正常工作:
然后您可以打印请求的 JSON 来查看模型的预测:
模型预测值为 1，这意味着乘客生还🙌
完成测试后，按 ctrl+c 关闭 flask 应用程序。
创建 Procfile
Procfile 指定了 Heroku 应用程序在启动时执行的命令。要创建一个，在工作目录中打开一个名为 Procfile(没有扩展名)的新文件，并粘贴以下内容。
web: gunicorn app:app
仅此而已。保存并关闭。✅
创建需求. txt
requirements.txt 文件将包含 flask 应用程序的所有依赖项。要创建 requirements.txt，请在终端的工作目录下运行以下命令:
pip freeze > requirements.txt
如果您不是在一个新的环境中工作，这个文件将包含您当前环境中的所有需求。如果您稍后在部署应用程序时遇到错误，您可以删除导致错误的需求。
对于这个项目，requirements.txt 至少应该包含:
**Flask**==**1.1.1
gunicorn**==**19.9.0
pandas**==**0.25.0
requests**==**2.22.0
scikit-learn**==**0.21.2
scipy**==**1.3.1**
可选项:将文件提交到 GitHub
运行以下命令将文件提交给 git:
# add all files from the working directory
git add .
然后提交您的信息:
git commit -m 'add flask files'
最后，使用下面的命令将更改推送到 Github。可能会要求您输入您的 github 用户名和密码。如果您设置了 2FA，您将需要您的密钥作为密码。
git push origin master
至少，您的 Github repo 现在应该包含:
- app.py
- model.pkl
- Procfile
- requirements.txt
注意:所有这些文件都应该在工作目录级别，而不是在另一个文件夹中
部署到 Heroku
如果您还没有，请在www.heroku.com创建一个免费账户。
只需选择名称并点击“创建应用”即可创建新应用。这个名称并不重要，但它必须是唯一的。
对于部署应用程序的方式，您有几个选项。我试过 Heroku CLI 和 GitHub，我个人更喜欢 GitHub…但是我会把两个都展示出来，所以挑一个你想看的。
使用 Github 部署
点击下面的 github 图标，连接您的 github 帐户:
搜索正确的存储库，然后单击连接:
然后滚动到页面底部，单击“部署分支”
如果一切正常，您应该会看到这条消息🎉🎉
如果出现问题，请检查您的 requirements.txt，删除给你带来问题的依赖项，然后重试_(ツ)_/
使用 Heroku CLI 部署
在 Heroku CLI 部分，您将看到部署时需要遵循的说明。将每个命令粘贴到您的终端中，并按照任何提示进行操作，如登录。注意任何需要修改的命令，比如cd my-project/——其中my-project/实际上应该是您的项目目录。git remote 应该准确地设置为 Heroku 中的应用程序名称。
如果您成功地遵循了这些说明，您应该在 overview 页面上看到 build successful🎉🎉
如果没有，您可以通过从命令行运行heroku logs --tail来检查出了什么问题。
测试部署的模型并生成预测
如果你已经测试了你的 flask 应用程序，这些说明将会非常相似，除了现在使用 Heroku 应用程序的 url。
在你的 Jupyter 笔记本中导入requests和json，然后创建一个变量来存储 Heroku 应用的 url(你可以在 Heroku 上点击应用页面右上角的“打开应用”来找到这个)。然后创建一些示例数据，并将其转换为 JSON:
# heroku url
heroku_url = '[https://titanic-flask-model.herokuapp.com'](https://titanic-flask-model.herokuapp.com') # change to your app name# sample data
data = { 'Pclass': 3
, 'Age': 2
, 'SibSp': 1
, 'Fare': 50}data = json.dumps(data)
使用以下代码检查响应代码。响应代码 200 表示一切运行正常。
send_request = requests.post(heroku_url, data)
print(send_request)
Output: <Response [200]>
最后，看看这个模型的预测:
print(send_request.json())
Output: {‘results’: {‘results’: 1}}
如果使用不同的样本数据，输出结果会有所不同。在这种情况下，结果为 1 意味着模型预测乘客幸存，更重要的是 API 起作用了！
现在，人们可以通过 Heroku URL 访问您的 API 端点，并使用您的模型在现实世界中进行预测🌐
这里是 github repo ，包含部署这个 API 所需的所有文件和代码。
在 twitter @elizabethets 上找到我或者在 LinkedIn 上联系我！
来源:
[## 欢迎使用 Flask - Flask 文档(1.1.x)
欢迎阅读 Flask 的文档。开始安装，然后了解快速入门概述。有…
flask.palletsprojects.com](https://flask.palletsprojects.com/en/1.1.x/) [## 云应用平台| Heroku
无论您是在构建简单的原型还是关键业务产品，Heroku 的全托管平台都能为您提供…
heroku.com](https://heroku.com/) [## Procfile
Heroku 应用程序包括一个 Procfile，它指定了应用程序在启动时执行的命令。你可以用一个…
devcenter.heroku.com](https://devcenter.heroku.com/articles/procfile)
使用 fastai 创建和部署图像分类器，并在 15 分钟内渲染。
当我刚开始学习机器学习和深度学习时，我花了很长时间来学习如何建立一个图像分类器，我参加了所有的机器学习课程，学习了 pandas，numpy 和 sklearn，然后我意识到，使用这些，我仍然不能创建一个图像分类器，所以我必须学习深度学习，CNN 和 keras 框架，所有这些只是为了创建一个正常的 CNN 图像分类器。
但现在在 2019 年，要创建一个图像分类器，你需要学习的只是 Fastai，用不到 6 行代码，你就可以创建一个随时可以部署的图像分类模型，击败 SOTA 论文的大多数结果。
Fastai 是第一个为视觉、文本、表格数据、时间序列和协同过滤等所有最常用的深度学习应用提供单一一致接口的深度学习库。
直到现在一切都好！我们现在可以使用 fastai 来构建一个图像分类器。
但是等等，模型会留在控制台吗？就像我总是需要用 jupyter 笔记本来预测新图像一样？
我如何将模型部署为可从 web 访问？
呈现有答案。
Render 是一个统一的平台，通过免费 SSL、全球 CDN、专用网络和 Git 自动部署来构建和运行您的所有应用和网站。
你需要做的就是将你的模型训练后保存下来，添加到 Render 提供的模板中，(可以从 github 克隆)，你的模型就部署好了。
例子:https://catdogfastai.onrender.com/
今天我将向你展示如何使用快速人工智能创建和训练一个模型来对猫和狗的图像进行分类，然后如何使用 render 将其部署在一个网站上。
我们开始吧！
首先，你必须准备一个数据集，从谷歌上获取一些猫和狗的图片，并把它们放在不同的文件夹中，给第一个命名为猫，第二个命名为狗。
现在让我们打开我们的 jupyter 笔记本，或者我们的 python 脚本，(随便什么让你的船漂浮)。
在开始编码之前，你首先要安装 PyTorch 和 fastai，
您可以使用以下方式安装它们:
if you are using anaconda:conda install -c pytorch pytorch-cpu torchvision
conda install -c fastai fastaiorpip install orpip install http://download.pytorch.org/whl/cpu/torch-1.0.0-cp36-cp36m-linux_x86_64.whl
pip install fastai
现在，在安装了所需的库之后，让我们开始吧。
首先我们要进口 fastai。
from fastai.vision import *
如果你是一名软件工程师，你可能会注意到我们从 fastai.vision 导入了* (all)，这违背了良好的软件工程实践。
完全正确，但在数据科学领域，当我们构建模型时，最重要的事情是尽可能快地与事物进行交互，当涉及到将模型投入生产时，您可以从母库导入您需要的任何东西。
酷！现在我们必须导入数据。
path="/images/"np.random.seed(42)data = ImageDataBunch.from_folder(path+'.', train=path+'.',valid_pct=0.2,ds_tfms=get_transforms(), size=224,num_workers=4).normalize(imagenet_stats)
我们使用 ImageDataBunch 类来导入图像。
这是 fastai 上最强的特性之一，这个类不需要任何配置就可以自动处理很多事情。
valid_pct 指应用交叉验证时，训练期间验证数据的百分比。
我们为所有图像分配了 244 的大小，以及 4 个 CPU 工作线程。
最后的归一化函数用于归一化所有图像，因为如果所有图像的平均值为 0，标准差为 1，则我们的深度学习模型可以很好地拟合。(不需要在这方面深入探讨)
现在让我们检查一下我们的班级:
data.classes
Out[5]: [‘猫’，‘狗’]
太棒了，现在我们的数据被导入，类被分配(猫和狗)。
让我们检查一下我们的 dataBunch 对象。
data.show_batch(rows=3, figsize=(7, 8))
我们的数据似乎已正确导入。
现在让我们创建我们的模型。在本例中，我们将使用 Resnet34，它是一个残差神经网络。
残余神经网络是一种人工神经网络，其建立在从大脑皮层中的锥体细胞已知的构造上。残余神经网络通过利用跳过连接或跳过某些层的捷径来做到这一点。
ResNet 设法在图像分类中击败了许多论文的 SOTA 结果，所以在我们的问题中使用它已经足够好了。
如果你没有得到 ResNet 的东西，你也不用担心。
from fastai.metrics import error_rate
learn = cnn_learner(data, models.resnet34, metrics=error_rate,model_dir="/tmp/model/")
我们这样创建我们的学习器，cnn_learner，我们指定 error_rate 作为一个度量来计算准确度。
而且我们添加了 models.resnet34 作为架构，是 fastai 提供的。
如果是第一次使用这个架构，那么当你运行这个代码片段时，它就会被下载。
好了，现在我们创建了我们的模型。
让我们训练它！！
defaults.device = torch.device('cuda') *# makes sure the gpu is used*
learn.fit_one_cycle(4)
Training results
最后一个时期的错误率是 0.15，这意味着我们的模型成功地将 85%的图像正确分类，注意到数据集中的一些图像是黑色图像或随机噪声图像。
酷，实际上我对这种准确性很满意，如果你不满意，请添加一些纪元。
现在，让我们保存模型，以便稍后在 web 中部署它。
learn.save("model")
好了，现在我们已经完成了模型的训练和保存。
让我们现在部署它。
首先你要去:https://github.com/render-examples/fastai-v3
并从这个库生成一个新的库。
现在你必须在渲染中创建一个免费账户:【https://render.com/register
上传你保存在某处的模型，例如: DropBox
现在回到 github > server . py 中的存储库
用您的 url 更改文件 url，用文件名更改文件名。
另外，不要忘记把职业改成[‘猫’，‘狗’]，或者你有的任何职业。
在 github 中保存你的代码(你甚至不需要在你的 pc 中克隆它)
现在转到呈现仪表板服务
单击新建 Web 服务
它会要求你授权给 github，授权之后，你所有的库列表就会出现。
点击你之前克隆的那个。
为您的应用程序添加一个名称，忽略付款部分，然后单击创建 Web 服务。
你要等待一段时间的应用程序被建立和部署，然后你可以从链接:yourappname.onrender.com 检查出来
这里有一个小演示:
结论
我们已经使用 fastai 制作了一个图像分类器，并使用 Render 进行了部署。那就像鞭子一样快。
如果您有任何问题、建议或批评，可以通过 Twitter 联系我:@ loulyadam
你可以在这里找到代码源:https://github.com/AdamLouly/CatDogRender
你可以在这个链接找到这里的猫狗数据集。
使用 R 创建趋势动画条形图
最近，动画柱状图开始在社交媒体上疯传，让许多数据爱好者想知道这些动画柱状图是如何制作的。这篇文章的目的是解释如何使用 R-R 和多用途的软件包来构建这样一个动画条形图。
享受 78%的 DataCamp 折扣
包装
在 R 中构建动画情节所需的包有:
- ggplot2
- gganimate
虽然以上两个是基本的软件包，但我们也在这个项目中使用了整个tidyverse、janitor和scales来进行数据操作、清理和格式化。
数据
用于本项目的原始数据集是从世界银行数据下载的。相同的 csv 文件可以在项目文件夹中找到。
关于数据:
这个数据包含了大部分国家几年(尤其是 2000 年到 2017 年)的 GDP 值。
数据预处理:
我们将使用下面的代码以期望的格式准备我们的数据。实际上，我们正在清理列名，将数字转换成数字格式，并使用 tidyr 的gather()函数将数据从宽格式转换成长格式。整理后的数据保存到一个新的 csv 文件gdp_tidy.csv中，以备后用。
library(tidyverse)
library(janitor)gdp <- read_csv("./data/GDP_Data.csv")#select required columnsgdp <- gdp %>% select(3:15) #filter only country rowsgdp <- gdp[1:217,]gdp_tidy <- gdp %>%
mutate_at(vars(contains("YR")),as.numeric) %>%
gather(year,value,3:13) %>%
janitor::clean_names() %>%
mutate(year = as.numeric(stringr::str_sub(year,1,4)))write_csv(gdp_tidy,"./data/gdp_tidy.csv")
动画情节
动画情节构建过程包括两个主要部分:
- 使用 ggplot2 构建整套实际静态图
- 使用 gganimate 以所需参数激活静态图
这两个主要步骤之后的最后一步是以所需的文件格式渲染动画，如 GIF 或 MP4(视频)。
加载所需的库
library(tidyverse)
library(gganimate)
数据处理:
在这一步中，我们将过滤数据集，仅保留给定年份的前 10 个国家。我们还将创建几个列来帮助我们在绘图中显示标签。
gdp_tidy <- read_csv("./data/gdp_tidy.csv") gdp_formatted <- gdp_tidy %>%
group_by(year) %>%
# The * 1 makes it possible to have non-integer ranks while sliding
mutate(rank = rank(-value),
Value_rel = value/value[rank==1],
Value_lbl = paste0(" ",round(value/1e9))) %>%
group_by(country_name) %>%
filter(rank <=10) %>%
ungroup()
构建静态图
现在我们的数据已经准备好绘制了，我们将构建所有需要的静态图。正如你可能已经在这篇文章顶部的动画中看到的，我们将看到在给定的数据集中，GDP 排名前 10 位的国家在过去几年中是如何变化的。为此，我们需要为每一年建造单独的地块。
staticplot = ggplot(gdp_formatted, aes(rank, group = country_name,
fill = as.factor(country_name), color = as.factor(country_name))) +
geom_tile(aes(y = value/2,
height = value,
width = 0.9), alpha = 0.8, color = NA) +
geom_text(aes(y = 0, label = paste(country_name, " ")), vjust = 0.2, hjust = 1) +
geom_text(aes(y=value,label = Value_lbl, hjust=0)) +
coord_flip(clip = "off", expand = FALSE) +
scale_y_continuous(labels = scales::comma) +
scale_x_reverse() +
guides(color = FALSE, fill = FALSE) +
theme(axis.line=element_blank(),
axis.text.x=element_blank(),
axis.text.y=element_blank(),
axis.ticks=element_blank(),
axis.title.x=element_blank(),
axis.title.y=element_blank(),
legend.position="none",
panel.background=element_blank(),
panel.border=element_blank(),
panel.grid.major=element_blank(),
panel.grid.minor=element_blank(),
panel.grid.major.x = element_line( size=.1, color="grey" ),
panel.grid.minor.x = element_line( size=.1, color="grey" ),
plot.title=element_text(size=25, hjust=0.5, face="bold", colour="grey", vjust=-1),
plot.subtitle=element_text(size=18, hjust=0.5, face="italic", color="grey"),
plot.caption =element_text(size=8, hjust=0.5, face="italic", color="grey"),
plot.background=element_blank(),
plot.margin = margin(2,2, 2, 4, "cm"))
我们不会详细讨论如何构建静态图，因为这与使用ggplot2构建普通图非常相似。正如你在上面的代码中看到的,theme()函数有几个关键方面是为了让它与动画配合得更好，比如——只画了垂直的网格线，图例、轴标题和其他一些组件都从图中删除了。
动画
这里的关键功能是transition_states()，它在年前将各个静态图缝合在一起。view_follow()用于提供背景线(网格线)随着动画的进行而移动的视图。
anim = staticplot + transition_states(year, transition_length = 4, state_length = 1) +
view_follow(fixed_x = TRUE) +
labs(title = 'GDP per Year : {closest_state}',
subtitle = "Top 10 Countries",
caption = "GDP in Billions USD | Data Source: World Bank Data")
翻译
随着动画被构建(准备好)并保存在对象anim中，是时候我们使用animate()函数渲染动画了。 animate()中使用的渲染器因所需输出文件的类型而异。
对于 GIF 文件格式:
# For GIFanimate(anim, 200, fps = 20, width = 1200, height = 1000,
renderer = gifski_renderer("gganim.gif"))
对于视频(MP4)文件格式:
# For MP4animate(anim, 200, fps = 20, width = 1200, height = 1000,
renderer = ffmpeg_renderer()) -> for_mp4anim_save("animation.mp4", animation = for_mp4 )
最终输出:
该项目的 GIF 输出:
总结:
因此，我们已经成功地构建了动画条形图，根据 GDP 值来可视化排名靠前的国家在几年内的变化情况。一旦数据预处理和数据操作步骤将输入数据重新整形为所需的格式，就可以很容易地根据您的目的修改这些代码。r 是任何形式的数据可视化的神奇工具，要了解更多请查看这个。这个完整的项目可以在 my github 上获得，你可以随意地使用它。
免费注册接收我的数据科学简讯— AI
免责声明: 此处使用的代码是从本栈溢出问题 动画排序条形图各条互相超越 的答案中长时间借用(可以说是启发、复制)
通过使用深度学习来听音乐，创建自动播放列表
走向组织音乐的连续方式
Robert Dargavel Smith —高级机器学习硕士项目结束( MBIT 学校，西班牙马德里)
动机
周围有许多自动 DJ 工具，它们巧妙地将一首歌曲的速度与另一首歌曲的速度相匹配，并混合节拍。老实说，我一直觉得那种 DJ 很无聊:他们技术越好，听起来就越像一首没完没了的歌。在我看来，重要的不是你怎么玩，而是你玩什么游戏。这些年来，我收集了许多珍贵的唱片，并在电台和俱乐部做过一些 DJ。我几乎可以通过听一首歌几秒钟就判断出我是否会喜欢它。或者，如果正在播放一首歌曲，通常会立即想到一首与之相配的歌曲。我认为人工智能可以应用于这种“音乐直觉”，作为一种音乐推荐系统，只需简单地听一首歌(当然，还需要有广博的音乐知识)。
几年前，iPod 有一个非常酷的功能，叫做 Genius ，它可以根据几首示例歌曲即时创建一个播放列表。苹果决定移除这一功能(尽管它在 iTunes 中仍然可用)，大概是为了说服人们订阅他们的音乐流媒体服务。当然，Spotify 现在提供了这一功能，但就我个人而言，我发现它推荐的最好的是我已经知道的音乐，最差的是相当商业化和缺乏创意。我有一个很大的音乐库，我想念有一种简单的方式来说“继续播放这样的歌曲”(特别是当我开车的时候)，以及一些帮助我发现新音乐的东西，甚至是在我自己的收藏中。我花了一些时间寻找替代解决方案，但什么也没找到。
实施细节
一种常见的方法是使用音乐流派来对音乐进行分类，但我发现这种方法过于简单和局限。罗克珊是雷鬼、流行还是摇滚歌手？那么所有不断发展的电子音乐细分领域呢？我觉得有必要找到一种更高维度、更连续的音乐描述，并且不需要标记每个音轨(即无监督学习方法)。
我做的第一件事是从 Spotify 上收集尽可能多的播放列表。(不幸的是，在一个类似的竞赛已经结束后，我有了这个想法，在这个竞赛中，获得了一百万首歌曲的使用权。)这个想法是，按播放列表分组会给个别歌曲带来一些背景或意义——例如，“80 年代迪斯科音乐”或“我最喜欢的海滩歌曲”。人们倾向于制作相似艺术家的歌曲的播放列表，具有相似的情绪、风格、流派或用于特定的目的(例如，用于健身房的锻炼)。不幸的是，Spotify API 并没有让下载播放列表变得特别容易，所以方法相当粗糙:我搜索了所有名称中包含字母“a”、字母“b”的播放列表，以此类推，直到“Z”。通过这种方式，我设法获得了 240，000 个播放列表，其中包括 400 万首独特的歌曲。我故意排除了所有由 Spotify 策划的播放列表，因为它们特别商业化(我相信艺术家可以付费在其中播放)。
然后，我使用 Word2Vec 算法创建了这些歌曲的嵌入(“ Track2Vec ”)，将每首歌曲视为一个“单词”，将每个播放列表视为一个“句子”。(如果你能相信我，我也有同样的想法，独立于这些家伙。)我发现 100 维是个不错的尺寸。给定一首特定的歌曲，该模型能够令人信服地推荐同一艺术家或类似艺术家，或同一时期和流派的 Spotify 歌曲。由于独特歌曲的数量巨大，我将“词汇”限制在那些出现在至少 10 个播放列表中的歌曲，给我留下了 450，000 首歌曲。
Spotify API 的一个优点是，它为大多数歌曲提供了一个 URL，允许您下载 30 秒的 MP3 样本。我下载了所有这些 MP3，并把它们转换成一个梅尔声谱图(Mel Spectrogram )( T9)——每首歌的一个紧凑表示，它应该反映了人耳对声音的反应。就像一个人可以通过听几秒钟的歌曲想到相关的音乐一样，我认为仅仅 5 秒钟的窗口就足以抓住一首歌的主旨。即使是这样有限的表示，所有光谱图的压缩大小达到了 4.5 千兆字节！
下一步是尝试使用从 Spotify 收集的信息从光谱图中提取特征，以便有意义地将它们相互联系起来。我训练了一个卷积神经网络，以尽可能接近地(在余弦近似下)再现与给定频谱图(输入 x )对应的 Track2Vec 向量(输出 y )。我尝试了一维(在时间轴上)和二维卷积网络，并将结果与基线模型进行了比较。基线模型试图在不实际听音乐的情况下得出最接近的 Track2Vec 向量。这导致了一首歌，理论上，每个人都应该喜欢(或讨厌)一点；-) ( SBTRKT — Sanctuary )，余弦接近度为 0.52。在过度拟合之前，我能够从验证数据中获得的最好分数是 0.70。使用 300 维嵌入，验证分数更好，但基线分数也更好:我觉得基线分数更低、两者之间的差异更大更重要，这反映了更具多样性和辨别能力的潜在代表。当然，分数仍然很低，但期望一个声谱图可以捕捉到人类基于文化和历史因素分组在一起的歌曲之间的相似之处，这确实是不合理的。此外，一些歌曲在 5 秒钟的窗口中表现得相当糟糕(例如，在奎恩的“现在不要阻止我”的情况下，这一部分对应于布莱恩·梅的吉他独奏……)。我摆弄了一个自动编码器和一个可变自动编码器，希望迫使光谱图的内部潜在表现更加连续、清晰，从而更有意义。最初的结果似乎表明，二维卷积网络更好地捕捉光谱图中包含的信息。我也考虑过训练一个暹罗网络来直接比较两个光谱图。我把这些想法留给将来可能的研究。
最后，通过一个 MP3 文件库，我将每个 MP3 映射到每 5 秒时间片的一系列 Track2Vec 向量。大多数歌曲从开始到结束变化很大，所以一首接一首的推荐到处都是。同样，我们可以应用 Doc2Vec 模型来比较类似的文档，我为每个 MP3 计算了一个“MP3ToVec”向量，包括根据其 TF-IDF (术语频率，逆文档频率)权重的每个组成 Track2Vec 向量。这种方案更加重视针对特定歌曲的频繁出现的和的推荐。由于这是一个 O ( n )算法，所以有必要将 MP3 库分成 100 个一批(否则我的 8000 个 MP3 将需要 10 天来处理！).我检查了一下，这对计算出的向量的影响可以忽略不计。
结果
您可以在本练习册的末尾看到一些结果，并自行判断。它特别擅长识别古典音乐、口语词、嘻哈和电子音乐。事实上，我对它工作得如此之好感到惊讶，以至于我开始想知道有多少是由于 TF-IDF 算法，有多少是由于神经网络。所以我创建了另一个基线模型，使用随机初始化权重的神经网络将光谱图映射到向量。我发现这种基线模型擅长识别流派和结构相似的歌曲，但是，当有疑问时，会提出一些完全不合适的东西。在这些情况下，经过训练的神经网络似乎会选择具有类似能量、情绪或仪器的东西。在许多方面，这正是我所寻找的:一种超越僵化的流派界限的创造性方法。为了 TF-IDF 算法的目的，通过摆弄确定两个向量是否相同的ε参数，有可能在流派(全局)和“感觉”(局部)特征之间找到良好的折衷。我还将结果与 Genius 在 iTunes 中生成的播放列表进行了比较，尽管这非常主观，但我觉得 Genius 坚持了流派，即使歌曲不太搭配，也不会做出那么“有灵感”的选择。也许大众来源的“可口可乐”测试需要成为最终的裁判。
当然，考虑到数据、计算能力和时间的限制，我认为结果可以作为概念的证明。
应用程序
除了自动(相对于俱乐部电台)DJ 的最初想法，你还可以做其他一些有趣的事情。例如，由于矢量映射是连续的，您可以轻松地创建一个播放列表，它平滑地“连接一首歌曲和另一首歌曲之间的点，通过您喜欢的任意多个路径点。例如，你可以通过放克和鼓贝斯从灵魂乐转到 techno。或者从摇滚到歌剧:-)。
另一个简单的想法是使用麦克风听音乐，并提出一组下一首歌曲来即时播放。与其与整个 MP3 音乐进行比较，不如只考虑每首歌的开头，这样音乐从一个音轨到另一个音轨会更自然。
你自己试试吧
将 git 库克隆或下载到您的计算机上。安装了所需的 python 包后
并且下载模型权重到你有 python 文件的目录，你可以处理你的 MP3(和 m4a)库。只需运行以下命令并等待…
它将创建一个名为“Pickles”的目录，并在子目录“mp3tovecs”中创建一个名为“mp3tovec.p”的文件。完成后，您可以使用
然后在浏览器中进入 http://localhost:8050 。如果加上参数--demo 5，就不用等到每首歌结束了。只需加载您希望播放列表所基于的 MP3 或 M4A；不一定非得是你音乐库里的一首。最后，有几个控件你可以摆弄(因为它是目前的编程，这些只有在下一首歌曲已经在播放时才生效)。“Keep on”决定了在生成播放列表时要考虑的先前曲目的数量，而“ducked”指定了要在混音中加入多少随机性。或者，您可以使用创建一个您选择的音乐之旅的 MP3 混音
其中“tracks.txt”是包含 MP3 或 M4A 文件列表的文本文件，这里，9 是您想要在每个文件之间生成的附加轨道的数量。
如果你对我用来训练神经网络的数据感兴趣，请随时给我发邮件。
只需听音乐即可创建自动播放列表。
github.com](https://github.com/teticio/Deej-A.I.)
最初发表于T5【http://github.com】。
使用 SeaBorn 创建基本的图形可视化
基本但强大而美丽的图形
Photo by Isaac Smith on Unsplash
说到数据准备和熟悉数据，我们通常跳过的一步是数据可视化。
虽然一部分原因可能是因为缺乏适用于我们使用的平台的良好可视化工具，但我们大多数人有时也会变得懒惰。
对于我们大多数的绘图需求，我会阅读博客，使用 StackOverflow 解决方案，并在每次需要绘制简单图形时与 Matplotlib 文档讨价还价。
这让我想到了一篇用 Python 创建通用图形类型的博文。
但是作为一个拖延者，我总是把它推到我的脑后。
帮助我在 Python 中追求数据可视化需求的一件事是密歇根大学的这门关于数据可视化和应用绘图的课程，它是 Python 本身的一个很好的数据科学专业的一部分。强烈推荐。
所以我最终写这篇博文的基本目的是创建一个代码库，为我提供可以直接用于分析的现成代码。
没错。所以现在开始。
首先导入我们将需要使用的库。
import matplotlib.pyplot as plt #sets up plotting under plt
import seaborn as sns #sets up styles and gives us more plotting options
import pandas as pd #lets us handle data as dataframes
我们将使用包含以下信息的提示数据。
tips = sns.load_dataset("tips")
tips.head()
带回归线的散点图
现在让我们将这些数据可视化。我们将在 seaborn 中使用 regplot 选项。
这需要一点代码，但我觉得它比 Matplotlib 或 ggPlot2 渲染的要好得多。我们在没有太多代码的情况下进行了大量定制。
但这并不是真正让我喜欢 Seaborn 的原因。
真正引起我注意的绘图类型是lmplot，它允许我们在分面模式中使用 regplot 。
:
你可以使用 color_palette() 函数构建自己的调色板。color_palette()将接受任何 seaborn palette 或matplotlib colormap的名称(jet 除外，你千万不要用它)。它还可以接受以任何有效 matplotlib 格式指定的颜色列表(RGB 元组、十六进制颜色代码或 HTML 颜色名称)。返回值总是 RGB 元组的列表。这允许您在图形中使用自己的调色板。
条形图
直方图和分布图
它们构成了我工作流程的另一部分。让我们使用 seaborn 绘制正态直方图。为此，我们将使用函数。这个函数结合了 matplotlib hist 函数(自动计算一个好的默认 bin 大小)和 seaborn kdeplot()函数。它还可以拟合 scipy.stats 分布，并绘制数据的估计 PDF。
****
配对图
你需要看到变量之间是如何变化的。数据集中变量的分布是怎样的？这是与函数一起使用的图表。非常有帮助，使用它是一种乐趣。在这个例子中，我们将使用虹膜数据集**。**
iris = sns.load_dataset("iris")
iris.head()
****
希望这篇文章对你有用，值得你花时间。你可以在 github 找到 iPython 笔记本
我试图让这尽可能简单，但你可能总是问我或查看文档中的疑问。
如果你有更多关于如何使用 Seaborn 的想法，请在评论部分提出建议。
随着我开始使用更多的可视化工具，并遇到其他像 seaborn 一样好的库，我肯定会尝试添加到这篇文章中。
另外，由于这是我的第一个可视化帖子，我想从密歇根大学调用一个关于数据可视化和应用绘图的好课程，这是一个很好的数据科学专业的一部分，Python 本身也不错。一定要去看看。
根据分类数据创建 Python 地图
有很多关于使用 Python 构建地理地图的好帖子，比如这个。然而，所有这些帖子都使用 choropleths 作为连续数据，这意味着使用带有颜色条的渐变来填充地图。由于我找不到很多关于如何使用分类信息构建地图的信息，所以我决定尝试自己构建一些东西，结果是这样的:
Map from categorical data, built with Python.
要求
为了构建此地图，您需要以下库:
- Pandas 和 NumPy(使用数据框)
- Geopandas(使用 shapefiles)
- Matplotlib(绘制图表)
准备数据
获取数据
创建 geopandas 地图时，您总是需要两个文件。
第一个文件是 shapefile，它包含多边形以构建一个带有边界的空地图。你可以在网上找到无数不同地区和边界的 shapefiles。对于这个项目，我使用了一个以行政区为边界的纽约市形状文件。
fp = ‘geo_export_58b25928–032c-45c8-a41f-8345f112f4d4.shp’ map_df = gpd.read_file(fp)
The shapefile data.
数据导入后，您就可以预览地图的外观，而无需用数据填充地图。
map_df.plot()
A plot of the NYC shapefile.
现在让我们用我们的数据对不同的行政区进行颜色编码。
第二个文件是实际数据，即包含用于填充地图的值。在这种情况下，我在纽约市使用了包含 364.558 311 服务请求的文件。
df = pd.read_csv(‘NY_311_requests.csv’)
在这个文件中，每行代表一个请求(或投诉)。然而，我想看看各区最受欢迎的投诉类型。通过使用 groupby 我可以创建这个概览:
df_top_compl = df.groupby(‘Borough’)[‘Complaint Type’].apply(lambda x: x.value_counts().head(1)).reset_index()
Most frequent complaint by borough
合并数据
现在我们有了两个文件，我们可以将它们合并在一起，这样我们就有了地理数据和填充数据(投诉)的组合。由于两个数据框架都包含行政区，我们可以基于该列进行合并。然而，在数据文件中，行政区是用大写的写成的，所以我们也需要将它应用到 shapefile。
map_df[‘Borough’] = map_df[‘boro_name’].apply(lambda x: x.upper())
现在，两个文件都有一列具有相似的值，我们可以在该列上合并它们。(为了防止 shapefile 中的行政区没有匹配的填充数据，我还添加了一个 fillna()值。)
data_df = pd.merge(map_df, df_top_compl, how=’left’, on=’Borough’) data_df[‘level_1’].fillna(value=’No data’, inplace=True)
现在所有的数据都准备好了，我们可以创建地图了！
创建地图
准备颜色
在我们创建实际的地图之前，我们将为图例做一些准备。鉴于代码应该是动态的，以防数据发生变化，我们不能使用固定数量的图例颜色。所以我们要做的是用调色板中相应的颜色创建一个填充值的字典(在这个例子中是 matplotlib tab20b )，除了’ No data '值，按照惯例它应该总是灰色的。
keys = list(data_df[‘level_1’].unique()) color_range = list(np.linspace(0, 1, len(keys), endpoint=False)) colors = [cm.tab20b(x) for x in color_range] color_dict = dict(zip(keys, colors)) color_dict[‘No data’] = ‘lightgray’
准备网格
由于我们需要绘制图例和地图，我们将把图形分成两列；左为图例，右为地图。图例的左列必须再次按行拆分:每个值和相应的颜色一行。但是，由于项目应该是动态的，我们不能使用固定的行数，它应该适应填充值的数量。使用下面的代码，我们可以根据唯一填充值的数量创建一个轴列表**。**
row_count = data_df[‘level_1’].nunique() ax_list = [] for i in range(row_count+1): ax_list.append(‘ax’ + str(i+1)) ax_string = ‘, ‘.join(ax_list)
基于该字符串和轴名称列表，我们可以创建具有 4 列和 N 行的plot grid。
fig, (ax_string) = plt.subplots(row_count, 4)
在这 4 列中，我们将第一列用于图例，另外 3 列用于实际绘图(使用 colspan)。
例如，如果我们有 5 行(要绘制的唯一值)，网格将如下所示:
Subplotgrid mockup.
绘制地图
这就是“传统”的连续数据图谱的不同之处。我们将使用一个循环来堆叠不同的地图，而不是绘制一个地图，以创建最终的结果。每个图层由一个区组成，每个区的颜色对应于它的值，使用我们之前构建的颜色字典。
ax1 = plt.subplot2grid((row_count,4),(0,1), rowspan=row_count, colspan=3) for index, row in data_df.iterrows(): plot = data_df[data_df[‘boro_code’] == row[‘boro_code’]].plot(color=color_dict[row[‘level_1’]], ax=ax1) ax1.axis(‘off’)
Map without legend.
地图看起来很棒，但是没有相应的图例显然是没用的。所以让我们把那部分也加上。
绘制图例
现在让我们在左栏添加一个图例。由于我们使用图层构建了地图，因此我们还需要以一种不太传统的方式构建图例。网格已经完成，包含了我们将要绘制的每个图例值的一行。现在在每一行将放一个彩色圆圈(使用一个小饼图)和一个字符串与相应的值。
row_counter = 0 for i in data_df[‘level_1’].unique(): plt.subplot2grid((row_count,4),(row_counter,0)) plt.pie([1],labels=[i],radius=0.4, colors=[color_dict[i]]) plt.axis(‘off’) row_counter += 1
Final result.
在那里！带有分类数据和相应图例的精美地图。如果数据发生了变化，您可以简单地重新运行脚本，图例中的颜色和值的数量都会很好地适应。
当然，你可以把它应用到你能找到的任何 shapefile 和数据上，只要你能合并这两个文件。
你可以在我的 GitHub 上查看并下载我的 Jupyter 笔记本。如果有不清楚的地方，请随时提问。
最后，我要感谢本杰明·库利，他的帖子给了我创作这个附加内容的灵感。
由于这是我在 Medium 上的第一篇帖子，任何评论或反馈都将受到极大的感谢。
关于我:我叫布鲁诺，是总部位于荷兰的人工智能技术纵向扩展公司dash mote的数据科学家。我们的目标是借助基于人工智能的解决方案，弥合图像和数据之间的鸿沟。
查看我在 上的其他作品 https://www.zhongtron.me 。
使用 Rasa Part-1 创建聊天机器人
现实世界中的数据科学
安装并运行你的第一个 Rasa 机器人。了解 Rasa 框架。
Rasa 是一个开源的机器学习框架，用于构建 AI 助手和聊天机器人。大多数情况下，在 Rasa 中工作不需要任何编程语言经验。虽然有一个叫做“RasaAction Server 的东西，你需要在那里用 Python 写代码，它主要用来触发外部动作，比如调用 Google API 或 REST API 等。
rasa.com
Rasa 有两个主要模块:
- 拉莎·NLU用于理解用户信息
- 用于进行对话和决定下一步行动的 Rasa 核心
注意——现在 Rasa NLU 和 Rasa 核心源代码合并在一起。
Rasa X 是一个帮助你构建、改进和部署由 Rasa 框架支持的人工智能助手的工具。Rasa X 包括一个用户界面和一个 REST API。Rasa X 是 Rasa 的最新版本。
关于我:我是 Rasa 官方贡献者。
Rasa 组件
Rasa X —这是一个基于浏览器的 GUI 工具，它将允许您通过使用基于 GUI 的交互模式来训练机器学习模型。请记住，它是 Rasa 软件堆栈中的可选工具。有时，rasa 会从您的浏览器向 Rasa 发送使用统计信息— ，但它不会向您的系统外部发送训练数据，，它只会发送您使用 Rasa X Train 的次数。
Rasa NLU —这是 Rasa 试图理解用户消息的地方，以检测您消息中的意图和实体。Rasa NLU 有不同的组件来识别意图和实体，其中大多数都有一些额外的依赖关系。
- Spacy(需要单独安装)
- Tensorflow(默认情况下可用于 Rasa)
Rasa Core —这是 Rasa 尝试帮助您处理上下文消息流的地方。基于用户消息，它可以预测对话作为回复，并可以触发 Rasa 动作服务器。
Rasa 内部使用 Tensorflow，无论何时您执行“ pip install rasa ”或“ pip install rasa-x ”操作，默认情况下它都会安装 Tensorflow。
安装 Rasa
Ubuntu 16+，Mac OS 和 Windows 10 (Visual C++构建工具)
**注意:**如果您使用的是 windows，请确保您已经安装了 Visual c++构建工具。这是一些 python 包所必需的。一定要使用 miniconda 来避免系统中其他已安装的 Python 包或冲突的 Python 版本的问题。
在你的操作系统中安装 MiniConda(Anaconda 的一部分)
[## Miniconda - Conda 文档
安装程序有两种变体:Miniconda 是基于 Python 2 的，Miniconda3 是基于 Python 3 的。请注意…
conda.io](https://conda.io/miniconda.html)
安装 miniconda 后，按照下面的命令在 conda 中创建一个虚拟环境。这将允许您无错误地运行 Rasa。
conda install python=3.6
conda create -n rasa python=3.6
source activate rasa
pip install rasa-x --extra-index-url [https://pypi.rasa.com/simple](https://pypi.rasa.com/simple)
按照上面的命令，Rasa 和 Rasa X 都将安装在您的系统中。
在 Rasa 中创建新项目
打开终端，激活康达虚拟环境。现在转到一个目录并执行“ rasa init ”，它将在该位置创建一个 rasa 项目。“rasa x”将启动 Rasa X 应用程序
source activate rasa
rasa init
“ rasa init ”应该显示上面的消息，以防您做得很好，并且您的系统不包含任何错误。跟随交互式会话并继续按回车键到达最后一步。最后，它应该显示这条消息。
如果您在终端中执行“ ls -la ”，您可以看到 Rasa 创建的文件列表。现在做“rasa x”来启动 rasa。
Rasa 配置
让我解释一下文件，它是作为 Rasa 的初始项目结构创建的。
一个空文件，帮助 python 找到你的动作
actions.py自定义操作的代码。如果您希望 Rasa 通过 REST API 或 API 调用来调用外部服务器，您可以在这里定义您的自定义操作。请记住，您可以为 Rasa 自定义操作创建多个 Python 脚本。
config.yml '* '配置你的 NLU 和核心车型。如果你正在处理 Tensorflow 或 Spacy，你需要在这里定义这样的管道。要处理这个文件，你要表现出对机器学习和深度学习的了解。
credentials.yml连接其他服务的详细信息。如果你想在 Facebook Messenger 上构建 Bot，微软 Bot 框架，你可以在这里维护这样的凭证和令牌。所以基本上你只需要添加脸书、slack 和 Bot 框架相关的配置，rasa 会自动为你做 rest。请记住，您需要通过 https 域托管 Rasa。在开发过程中，您可以使用 ngrok 作为测试工具。
data/nlu.md‘*’你的 NLU 训练数据。您可以在这里定义意图。比如订披萨或者预定优步。你需要为此添加相关的句子。请记住，如果您正在使用 Rasa-X，您的培训意图和数据将会自动添加。
data/stories.md '* '你的故事。这是 Rasa 核心所必需的。有一种叫做“Rasa 中的对话流”的东西，其中 Rasa Core 控制着你和 chatbot 之间的对话流，因此对于这种流，你需要使用这些故事来训练 chatbot。因此，如果你想让你的聊天机器人在不同的背景(故事)下非常完美，你可以在这里添加这些故事。
domain.yml '* '您的助手的域。这个文件结合了聊天机器人可以检测到的不同意图和机器人回复列表。请记住，您可以在这里定义您的自定义操作服务器 python 方法名称(下划线格式)，以便 Rasa 为您调用该 Python 方法。
endpoints.yml连接到 FB messenger 等频道的详细信息。这主要用于生产设置。您可以像 Redis 一样配置您的数据库，以便 Rasa 可以存储跟踪信息。
models/<timestamp>.tar.gz您的初始模型
玩示例聊天机器人
Rasa 用默认数据为您创建了一个示例机器人。所以现在您可以从 Shell/Terminal 开始使用它。首先，让我们从终端测试您的聊天机器人(记住要在终端中进行)
rasa shell
你可以输入“hi ”,在机器人的回复中，你会收到一些回应。
如何使用 Rasa-X
这是 Rasa 堆栈的最新成员。您可以使用 Rasa-X 在浏览器上尝试您的聊天机器人。可以下载训练数据。此外，您可以通过指导您的机器人来纠正您的训练数据。
rasa x
它将询问许可协议，您可以说“y”并继续。
在浏览器上打开此链接—http://localhost:5002/talk
在左边，你可以试着和你的机器人聊天，在右边你可以看到哪个意图和回复得到了回应。
关于 Rasa-x 的一些事实
当您在本地运行 Rasa X 时，您的培训数据和故事将从您的项目(例如data/nlu.md)中的文件中读取，并且您在 UI 中所做的任何更改都将保存回这些文件中。对话和其他数据存储在 SQLite 数据库中，该数据库保存在一个名为rasa.db的文件中。
观看此视频，了解有关 Rasa-X 的更多信息
如何使用 Rasa 自定义操作(操作服务器)
这是你的聊天机器人最真实的例子。假设你想在你的聊天机器人上增加一个功能，让你的机器人告诉你一个特定城市的最新天气预报，你会怎么做？答案是“Rasa 自定义操作”
一个动作可以运行你想要的任何代码。自定义操作可以打开灯，在日历中添加事件，检查用户的银行余额，或者任何你能想到的事情。
Rasa 将在预测到自定义操作时调用您可以指定的端点。这个端点应该是一个 web 服务器，它响应这个调用，运行代码，并可选地返回信息来修改对话状态。
在编辑器中打开“actions . py”(Visual Studio 代码可以是一个选项)
步骤 1 — 在“actions.py”中定义一个名为“**ActionCheckWeather”**的方法
**from** **rasa_sdk** **import** Action
**from** **rasa_sdk.events** **import** SlotSet
**class** **ActionCheckWeather**(Action):
**def** name(self) -> Text:
**return** "action_check_weather"
**def** run(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
dispatcher.utter_message("Hello World! from custom action") **return** []
步骤 2-将此自定义操作与您的聊天机器人相链接。打开“domain.yml”。
在动作列表中添加“动作 _ 检查 _ 天气”动作。这应该是这样的
actions:- utter_greet- utter_cheer_up- utter_did_that_help- utter_happy- utter_goodbye- **action_check_weather**
现在，在故事中，将这个自定义操作添加为您的流。打开“ stories.md ”文件和这个新的自定义动作“action_check_weather”作为快乐路径流的一部分。
**## happy path*** greet- utter_greet* mood_great- action_check_weather
步骤 3 告诉 rasa 使用自定义操作服务器
打开“endpoints.yml”并添加以下行以启用自定义操作服务器
action_endpoint: url: "http://localhost:5055/webhook"
现在使用下面的命令重新训练你的 Rasa 聊天机器人。你需要重新训练你的机器学习模型，因为你在“stories.md”和“domain.yml”文件中做了一些修改。所以没有重新训练，你不能通知 Rasa 使用这些。
rasa train
现在使用以下命令再次启动 Rasa
rasa x
此外，使用以下命令启动 Rasa 操作服务器。Rasa X 和 Rasa run 操作应该在两个不同的终端中运行。
rasa run actions
你可以看到，你得到了用 python 写的自定义动作的回复。在同一个 python 脚本中，您可以连接到后端数据库并返回响应。此外，您可以使用额外的 python 包调用外部 API。
另外，你可以用 C#、NodeJS 和 Java 开发定制动作服务器。
如何为聊天机器人构建自定义前端
您可以使用 HTML5 和 CSS3 构建一个聊天机器人 GUI。可以像 ReactJS 和 JQuery 一样使用库。如果你愿意，你可以使用 Angular 作为你的前端 JavaScript 框架来为你的聊天机器人构建前端。
- 在 HTML5 和 CSS3 中构建 GUI
- 从前端调用 Rasa Rest API
- 好了
从 JavaScript 到 Rasa 后端的示例 API 调用
当我们开始构建生产级 Rasa 聊天机器人时，首先我们可以简单地使用下面的命令来启动 Rasa。
rasa run
上述命令将运行 Rasa 核心，并在端口 5005 上公开 REST API。
URL: [http://localhost:5005/webhooks/rest/webhook](http://localhost:5005/webhooks/rest/webhook)
Method: POST
Header: Content-Type: application/json
Body:
{
“sender”: “Rasa1”,
“message”: “hi”
}Response:
[
{
“recipient_id”: “Rasa1”,
“text”: “Hey! How are you?”
}
]
现在，您可以在前端应用程序中解析这个响应，并向用户显示这个响应。请记住，Rasa 将根据我们在请求正文中传递的名为“Rasa1”的唯一 id 来跟踪您的对话。
在本文的下一部分，我们将学习
- Rasa 插槽
- 使用 Docker 的 Rasa
- Rasa-X 进展
- Rasa 生产部署
你可以从我的 Github 获得完整的代码
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/bikashkumars/rasa)
快乐的 Rasa 和快乐的机器学习——读者们。！！！
使用 Luigi & PySpark 和 CI/CD 创建数据科学管道
本文将为您提供关于使用以下 Python 包创建健壮的数据管道的所有细节:
- 路易吉，管道公司的包裹
- PySpark，一个通过 Python API 使用 Spark 的包
- 熊猫，一个处理数据的包
- Unittest，一个实现单元测试的包。
本文使用的所有代码，可以在下面的 GitHub repo 上找到:https://github.com/aalepere/luigi_spark_flask_cicd
什么是数据管道，我们为什么需要它们？
数据管道是一组连续应用于一个或多个数据源的数据处理。
数据处理的例子可以是:加载数据源，转换成定义的格式，应用完整性规则，替换丢失的值…
数据管道在机器学习领域非常重要。传统上，数据科学家倾向于以更“手动”的方式工作，通过文件和笔记本来操作数据。
然而，当需要将模型迁移到生产环境中时，这可能是一项困难的工作。
使用数据管道及其相关原理具有以下优势:
- 再现性
- 可配置的
- 模块性
- 准备生产
路易吉
Luigi 是允许创建数据管道的 python 包。传统上，当创建管道时，我们将事件列表链接起来，以所需的输出结束。Luigi packages 通过开箱即用的功能帮助您构建干净的数据管道，例如:
- 依赖关系解析，换句话说，确保在移动下一个任务之前，所有上游任务都被正确执行。Luigi 允许创建干净的图形
- 工作流程管理
- 图形可视化
- 并行化处理
【https://github.com/spotify/luigi
PySpark
PySpark 是 Spark 的 Python API。PySpark 允许我们通过 Python API 利用 Spark 的所有特性。在本次回购中，我们主要使用 Spark 的机器学习功能，包括:
- 特征模块，一组可用于特征工程的数据转换(替换缺失值、离散化等)
- 分类模块，一组分类模型(逻辑回归，随机森林…)
https://spark . Apache . org/docs/latest/API/python/py spark . html
测试& CI/CD
CI/CD 是一个框架，通过在开发阶段引入自动化来频繁地将代码/特性交付到产品中。CI/CD 的主要概念是持续集成、持续交付和持续部署。CI/CD 是集成新代码给开发和数据科学团队带来的问题的解决方案。通常，数据科学家在 Jupyter notebooks 等原型开发环境中工作，事实证明，很难轻松转移到生产环境中。
具体来说，CI/CD 在数据管道的整个生命周期(从集成和测试阶段到交付和部署)中引入了持续的自动化和连续监控。
创建任务
在 Luigi 中，要创建一个数据管道，我们需要创建一组任务，然后执行这些任务以产生期望的最终输出。
Luigi 任务由以下元素组成:
- 输入，这定义了一个任务需要哪些输入。它通常是一个文件，但稍后我们会看到，通过使用字典，我们可以使用多个文件(即训练和测试)。
- 输出，这定义了任务的输出，然后作为输入用于下游任务。
- 运行，执行任务时需要运行的指令集
- 需要，在执行当前任务之前需要执行的一组上游任务。这允许在任务之间创建依赖关系，有点像数据库设计中的主键和外键。
- Main ，在某些情况下如使用 PySpark 时，将使用 Main 代替 run
数据分析
为了定义将要执行的转换，我们首先需要执行一些数据分析。将用于泰坦尼克号生存数据集的数据集。
- 性，取两个值男性和女性。大多数机器学习算法只接受数值。因此，性别特征必须转换成数值(即男性→ 0，女性→ 1)
- 年龄，有一些缺失的价值需要被取代。由于分布偏向年轻人，我们决定用中位数来代替缺失值。
- 年龄是一个离散值，以决定观察其与存活率(每个年龄的存活数/总乘客数)的关系。正如您在下面看到的，信号非常嘈杂，因此我们希望离散化特征以获得连续的特征。
- 离散化后，我们看到 bin 2 的存活率更高:在 26 到 33 岁之间。看起来他们在疏散泰坦尼克号时优先考虑了老人和孩子。
- 票价，就像年龄也是酌情而定的。
我们可以添加更多的转换和特性，但这里的主要目的是解释数据管道的构建块。
任务
以下是将按顺序执行的任务的描述:
- FileExists :检查初始的 titanic 数据集是否存在。
- 启动:将所有字符串特征(即性别)转换为数字特征，并将数据集拆分为 70/30 的训练/测试。
- 转换:应用数据分析部分描述的转换(替换缺失值和离散化)。这些转换都应用于训练集/测试集。
- 模型:取 2 个转换集，用 train 拟合逻辑回归，并用测试对其进行评估。
运行管道
为了能够运行管道，我们需要告诉 Luigi 模块的名称和要执行的任务。
由于依赖关系的定义，我们只需告诉 Luigi 运行最后一个任务(即模型)，Luigi 就会知道如何重建图并执行所有上游任务:
PYTHONPATH='.' luigi --module pipeline Model --local-scheduler
--input-file "../source_data/titanic.csv" --output-path "data_out"
input_file 和 output_path 是 Luigi 参数，它允许我们选择将哪个数据集推入管道，以及将所有任务输出保存在本地驱动器的什么位置。
测试管道
如上所述，CI/CD 的原则之一是实现和部署的连续流，为了允许这样的模式，我们需要引入测试来确保代码质量，并且任何代码都不会破坏管道的所有组件。
设置
使用单元测试包，设置用于运行一段将被所有单元测试使用的代码。在我们的例子中，我们使用一个我们已经准备好的测试文件来运行数据管道，这个测试文件包含了所有需要测试的不同测试用例。
测试
下面是一个已经实现单元测试的例子:
- 测试初始数据集在训练和测试之间是否正确分离
- 测试性别特征是否正确映射到数值
CI/CD
在 GitHub 中，您可以设置动作，动作是一组指令，当代码被推送到 repo 时将执行这些指令。
GitHub Actions 现在拥有世界一流的 CI/CD，可以轻松实现所有软件工作流程的自动化。构建、测试和…
github.com](https://github.com/features/actions)
GitHub Actions 允许通过 CI/CD 实现软件工作流程的自动化。
直接从 GitHub 构建、测试和部署您的代码。进行代码审查、分支管理和问题分类。
下面是一个设置示例:
将新代码推送到 repo 后，将执行 CI/CD 工作流:
工作流将安装所有需要的 Python 包，用 flake8 检查语法质量，并运行所有测试。这确保了所有推送到 repos 的新代码不会破坏现有的管道。
使用 Flowpoints 创建深度学习模型
构建和分享深度学习模型的直观方式。
我经常发现自己在解释我的模型是如何工作的。有时我试图用通俗的语言来表达，有时我只是把它解释为一个黑盒，有时我画出代表神经网络部分的互连节点。
引入流动点
Flowpoints 是一个开源的在线工具，用户可以在其中以流程图的方式建立深度学习模型。
通过在神经网络(flowpoints)中创建表示操作的节点，将这些节点相互连接，并更改它们的参数，可以快速创建深度学习模型。
相应的 Python 代码可以在浏览器中查看，或者只需点击一下就可以复制到剪贴板。
通过一个菜单，您可以选择代码是使用 TensorFlow 还是 PyTorch。
…您还可以轻松创建模型的共享链接！
一个简单的例子
所以我们来试试吧！在本例中，我们将创建以下模型，该模型将在 CIFAR10 数据集上接受训练。
What the final model looks like
对于那些喜欢先吃甜点的人来说: 这里是 成品模型，这里是 这个例子的 colab。
第一:创建一个新模型
从前往流量点开始。一个相当空的用户界面应该出现在你的屏幕上。
在侧栏中，单击库下拉菜单，然后选择 TensorFlow。现在我们模型的代码将使用 TensorFlow 代替 PyTorch。
接下来，点击主题下拉菜单，选择“橙色”。这没有实际价值，但是我们在这里用风格编码。
第二:给你的模型添加一些流点
向您的模型添加一些操作。单击蓝色+按钮创建一个新的流量点。出现第一个流点应该是“输入”。这个点将被用来告诉模型我们输入的形状。我们会回来的。
不要单击任何其他地方，多单击几次+按钮。一堆流点应该一个接一个地弹出，并自动连接。
如果您缺少连接:单击您想要获取输出的流点，按住 shift，然后单击您想要连接的流点。连接应该会立即显示出来。要移除连接，只需重复此过程。
创建尽可能多的流动点，并按照您喜欢的方式排列它们。或者只是复制图中的模型。
第三:改变图层类型
现在你已经有了一大堆线性运算。那些对我们没多大帮助。是时候告诉每个流点它应该做什么了。
点击第一个流点(“输入”)，并选择侧边栏中的流点选项卡。确保“n_dims”框设置为 3，并且“尺寸”显示为 32，32，3。这些是 CIFAR10 数据集中图片的尺寸。
单击下一个流点(连接到输入的流点)，并单击“层类型”区域。在这里，您将更改该流点的操作。首先删除该字段中的所有文本，然后键入“Conv”。应该会出现一个操作列表，Conv2d 非常接近顶部。选择此操作。
橙色和蓝色的小徽章表示相关图层在哪个库中可用。
流点的参数应改变，以匹配 TensorFlow 中 Conv2D 运算的参数。
将所有参数设置为有意义的东西(可以使用我的型号作为例子)。
对所有流动点重复此步骤，改变它们的层类型和参数，使它们有意义。
第四:看一看代码！
单击侧边栏中的“代码”选项卡，显示您当前型号的代码。它应该是这样的:
Screenshot of the UI with the “Code”-tab open
整个代码如下所示:
The entire code for the model in this walkthrough
大功告成！
要共享或保存您的工作，请执行以下操作:在屏幕左下方的小按钮堆栈中，单击链接共享按钮。将弹出一个对话框，要求您输入密码。这可以用来保护你的模型。如果您想创建一个公共链接(就像我在这个例子中所做的那样)，只需将密码字段留空即可。
要为您的模型复制代码，请单击按钮堆栈中的复制按钮。会弹出一个通知，告诉你代码已经被复制到你的剪贴板上。您可以将其直接粘贴到您的管道中。您可以在我为这个小演练创建的 colab 中找到我的模型的代码:)
感谢阅读！
欢迎分享任何反馈，如果您发现 bug(代码是开源的)可以提出新问题，或者自己添加功能和补丁！
扫一扫
1262
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
