一旦你有了一个帐户，我们就可以在这里访问 Cloud AutoML 自然语言控制台:https://console.cloud.google.com/natural-language/dashboard

在这里，我们将点击“自动情感分析”。虽然我们不是在分析文本的情绪，但本质上，我们将使用股票价格反应作为季度收益报告“情绪”的衡量标准，将此建模为情绪分析问题。

单击“new dataset”，选择情绪分析，并将最大情绪得分设置为 4，因为我们有在上一步中创建的 5%价格变化时段。

我们现在将导入在上一步中创建的 CSV 文件，然后单击 import。导入完成后，您将收到一封电子邮件。然后，您可以返回到仪表板，并单击培训。如果你有任何问题，你可以参考谷歌的文件在这里:https://cloud . Google . com/natural-language/automl/sensation/docs/

该模型将需要几个小时的训练，当它完成时，我们会收到一封电子邮件。然后我们可以分析结果:

这里我们看到了模型的混淆矩阵。如果你不确定如何解释，你可以谷歌一下“困惑矩阵”。我们可以看到，我们实现了近 30%的准确率和召回率，而由于我们有 5 个存储桶，随机机会应该是 20%。那比随机几率好 50%！

如果我们看一下情绪得分为 0 的结果(记住这是价格变化最负的 20 个百分点)，我们会看到我们得到了最好的准确性。当我们使用我们的模型预测季度收益报告将产生最剧烈的价格下跌时，我们将有 35.63%的时间是正确的。这比随机机会好了 75%以上！

我们用这个桶做得最好是有道理的。它告诉我们，当一份季度收益报告包含某些负面指标语言时，它将更可预见地产生戏剧性的股价下跌。这符合一句古老的谚语“卖新闻”。

第七步。下载今天的 10-Q 文件，进行在线预测，并开始交易！

注册羊驼经纪人账户开始交易:【https://alpaca.markets/

他们允许你快速方便地在纸币账户上交易，而不需要输入任何银行信息，这非常好。我们可以用这个纸币账户开始。

注册后，您需要从仪表板中检索您的 API 密钥:

我们还需要从谷歌控制台检索我们的模型名称。在与上一步相同的仪表板上，单击您训练过的机器学习模型。

转到“测试和使用”选项卡。单击“使用您的自定义模型”下的“Python”选项卡。记下上面用黑色圈出的型号名称。

我们现在可以使用以下命令行参数运行我们的命令:

> python MakeTrades.py <羊驼 API 密钥 ID > <羊驼秘钥> <谷歌型号名称>

该命令将:

1.从美国证券交易委员会网站https://www.sec.gov/cgi-bin/current?q1=0&Q2 = 1&Q3 =下载最新的上市日 10-Q 文件

这应该只在交易日晚些时候运行，因为这是当天所有文件都可用的时候。如果你想早点运行它，它会给你昨天的文件。

2.清理每一份 10-Q 文件，并与公司最近的 10-Q 文件进行比较，就像我们在培训准备中所做的那样。如果该公司在过去 3 个月左右没有 10-Q 文件，它将跳过它。

3.提交文本 delta，用我们的 ML 模型做一个在线预测。

4.如果我们的模型返回的预测值为 0(它预测的是最剧烈的价格下跌类别)，那么它将使用羊驼 API 为该股票下一个空头订单，该订单将在第二天的开市时执行。

你应该记得在持有空头头寸一天后平仓。如果你愿意，你可以为此写一个脚本。您还可以将该命令与 cron 作业一起安排在每个交易日结束时运行，以实现完全自动化。

第八步。翻转它来生活，让金钱滚滚而来

希望，这个指南是有价值的，可以被使用，并扩大到现场交易盈利。如果有什么不清楚或者你需要任何帮助，请联系我。

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

原载:【https://www.platorsolutions.com/】T21

我可以为贵公司的任何项目提供软件咨询。点击此处免费预约初诊:https://www.platorsolutions.com/book-online

为快乐和利润建立一个公司 R 包

原文：https://towardsdatascience.com/build-a-corporate-r-package-for-pleasure-and-profit-78b73ce4ff4b?source=collection_archive---------12-----------------------

我们的经济正在进行“大重组”。这是我们所知道的正在发生的事情的官方名称:最好的正在上升到顶端，而平庸的正在沉入底部。这是马太效应在起作用。

在 Brynjolfsson 和 McAfee 2011 年的著作与机器赛跑中，他们详细描述了这种新经济将如何有利于那些拥有技能或资本来对接和投资深度学习和机器人等新技术的人，这些新技术正变得越来越普遍。

Cal Newport 的深度作品概述了在新经济中蓬勃发展的两个核心能力:

1.能够快速掌握难的东西

2.能够在质量和速度方面达到精英水平。这种对速度的需求(抱歉)将是我们关注的重点。

不要重复自己(干)是软件开发中众所周知的格言，大多数 R 程序员都遵循这个规则，构建函数以避免重复代码。但是你多久会:

• 在不同的分析中引用相同的数据集
• 创建到数据库的相同 ODBC 连接
• 在 ggplot 中修补相同的颜色和主题
• 从同一模板生成降价文档

诸如此类？注意到模式了吗？“同”字撒在每一个要点里。我嗅到了干敷的机会！

如果你像我一样在公司或学术机构工作，你可能会经常做这些事情。我将向你展示如何将所有这些任务打包成一个极简的 R 包来节省你的时间，正如我们所知，这是你在新经济中取得成功的关键之一。

工具

首先做一些基础工作。如果你用 R 工作，我假设你用的是 RStudio，这是必须的。我用的是 Windows 10 机器上的 R 版本 3.5.1(啊，美国公司…)。请注意，我们将要开发的包是极简主义的，这是一种说我们要抄近路来制造最小可行产品的方式。我们不会深入讨论文档和依赖项，因为我们在新包中需要的包很可能已经在您的本地机器上了。

创建空的包项目

我们将为咨询公司 Ketchbrook Analytics 创建一个包，这是一家来自康涅狄格州的精品店，他们比任何人都更了解自己的道路。

打开 RStudio 并在新目录中创建一个项目:

选择 R 包并命名。我叫我的凯彻。

RStudio 现在将使用示例“hello”函数启动一个新会话。看来我们准备好进入正题了。

自定义功能

让我们从向我们的包中添加一个函数开始。Ketchbrook 的一项常见任务是将客户数据与市场区域或足迹的轮廓对应起来。我们可以很容易地把它包装成一个简单的函数。

创建一个新的 R 文件，并将其命名为 ketchR.R。我们将把所有的函数放在这里。

所以我们所做的是创建一个函数，利用 tigris 包来获取我们足迹中各州的 shapefiles。然后，该函数将这些状态合并成一个连续的多边形，这样我们就可以很容易地使用传单、ggmap 等来覆盖它。

尝试你的新功能:

你会看到一个漂亮的西部小海岸:

您可以在包中添加的自定义函数的种类没有限制。机器学习算法，客户细分，无论你想要什么，你都可以在你的包中放入一个易于访问的功能。

数据集

让我们继续我们的地理空间爱好。分公司或商店级别的分析在分布于一个大的地理区域的公司中很常见。在我们的例子中，Ketchbrook 的客户从提华纳到西雅图有八家分行。每次我们需要引用这些位置时，不用手动存储和导入 CSV 或 R 数据文件，我们可以简单地将数据集保存到我们的包中。

为了将数据集添加到我们的包中，我们首先需要通过读取 csv 或从其他地方获取数据集，将它放入我们的本地环境中。我只是从本地电脑上读取了一个 csv 文件:

这是数据集的样子:

现在，我们必须将这些数据放在一个非常具体的地方，否则我们的包将无法找到它。就像当我妻子把洗碗机藏起来的时候，我被迫不情愿地把脏盘子放在柜台上。

首先，在当前目录中创建一个名为“data”的文件夹顺便说一句，你的目录现在应该是这样的:

额外好处:使用 RStudio 中的终端功能可以轻松创建目录:

现在我们需要将这个分支数据集作为。RData 文件:

现在，我们建造

让我们测试一下这个包，因为我们很有可能没有搞砸任何事情。当我们构建这个包时，我们正在把它编译成我们所知道的实际的包。在 RStudio 中，这非常简单。导航到“构建”选项卡，然后单击“安装并重启”

如果您已经完成了，您应该不会看到任何错误，但是如果您确实看到了错误，请尝试更新您的本地包。

现在，我们应该能够直接调用我们的包并使用我们的分支数据集:

酷，这很有效。现在让我们用传单快速绘制我们的分支，以确保 footprint_poly()有效:

尼利斯。

数据库连接

数据科学中最常见的任务之一是从数据库中提取数据。假设 Ketchbrook 将数据存储在 SQL 服务器中。与其手动复制和粘贴连接脚本或依赖 RStudio 会话来缓存连接字符串，不如让我们直接创建一个该死的函数。

在这里，我们构建了一个函数，让我们可以输入任何我们想要针对这个 SQL Server 的查询。该函数创建连接，每次都提示我们输入密码(我们不在代码中存储密码……)，并在连接完成时关闭连接。

让我们更进一步。很多时候，您可能会使用一个通用的 SELECT *查询来利用 dplyr 进行真正的数据管理。在这种情况下，更简单的方法就是创建一个这样的函数。

让我们创建另一个从客户那里提取 SELECT *的函数。

啊，当我开始在自己的实践中使用它时，仅这一项就为我每周节省了 15 分钟。仔细想想你可能经常复制和粘贴的任何一段代码——那是你的函数包的候选者。

品牌 ggplot 可视化

好了，现在我们进入了最重要的部分，真正节省时间的部分，我们一揽子计划中给分析师留下深刻印象的部分。我们将使产生一致的数据可视化变得容易，这些数据可视化用定制的颜色和主题来反映公司的形象。

虽然我个人认为绿色调色板是有史以来最好的配色方案，但它并不一定符合凯奇布鲁克公司的调色板。所以让我们自己制作一套函数来使用凯奇布鲁克的调色板是一种‘懒惰’的方式。(非常感谢这篇 Simon Jackson 的伟大文章)。

获取颜色

让我们直接从他们的网站上下载颜色。我们可以使用 Chrome 插件 Colorzilla 来获取我们需要的颜色。

将这些十六进制颜色代码粘贴到这个块中，就像这样:

这将给我们一个很好的调色板，对于分类数据有足够不同的颜色，对于连续数据有足够相似的颜色。为此，我们甚至可以将它分成两个单独的子调色板:

创建函数

我不打算一行一行地介绍这些函数；如果您有任何问题，请发邮件至 bradley . lindblad[at]Gmail[dot]com 联系我，在 Github repo 上创建一个问题。以下是完整的代码片段:

让我们来测试一下:

生产:

很好。在 Ketchbrook 的视觉效果中使用一致的颜色将有助于为他们的品牌建立知名度，并在市场上更快地得到认可。

降价模板

现在我们已经更快地获取数据并绘制数据，最后一步是交流我们的分析结果。同样，我们希望能够快速、一致地做到这一点。定制降价模板已准备就绪。

我发现这一部分是最难做对的，因为所有的东西都需要在文件结构中的正确位置，所以请密切关注。(大部分功劳归于切斯特·伊斯梅的这篇文章。)

1.创建框架目录

这将创建一个嵌套目录来保存我们的模板。Rmd 和。yaml 文件。您的目录中应该有一个名为“ketchbrookTemplate”的新文件夹:

2.创建骨架。中矢状直径之比

接下来，我们创建一个新的 RMarkdown 文件:

这将为我们提供一个基本的 RMarkdown 文件，如下所示:

现在，让我们修改模板来满足我们的需求。首先，我会用一个我觉得很适合我的主题来替换顶部的内容，你可以随意撕掉它:

我喜欢遵循分析模板，因此这是结合我的基本 EDA 模板的首要问题:

将这个文件保存在 skeleton 文件夹中，我们就完成了。

3.创建 yaml 文件

接下来，我们需要创建一个 yaml 文件。只需在 RStudio 中创建一个名为“template.yaml”的新文本文档，并保存它，如下图所示:

重新构建包并打开一个新的 RMarkdown 文档，选择“From Template ”,您应该会看到您的新模板可用:

太好了。您现在可以编织 html pretty，并得到如下甜美的输出:

如果遇到问题，请确保您的文件结构与此匹配:

 ├───inst
│   └───rmarkdown
│       └───templates
│           └───ketchbrookTemplate
│               │   template.yaml
│               │
│               └───skeleton
│                       skeleton.nb.html
│                       skeleton.Rmd

下一步是什么？

因此，我们基本上做了一个炸弹包，让你做任何事情都快一点，好一点:拉数据，引用公共数据，创建数据和交流结果。

从这里，您可以在本地使用这个包，或者将它推送到一个远程 Github 仓库，在您的团队中传播代码。

这个包的完整代码可以在为它设立的 Github repo 获得。随意分叉，让它成为自己的。我不擅长说再见，所以我要走了。

我可以在有限的基础上提供数据科学咨询。通过 gmail[dot]com 联系我

感谢阅读！

在 AWS 上构建一个数据管道来收集 PUBG 数据

原文：https://towardsdatascience.com/build-a-data-pipeline-on-aws-to-collect-pubg-data-5b222ba4e2cc?source=collection_archive---------11-----------------------

Photo by Quinten de Graaf on Unsplash

我在与 PUBG 相关的 Kaggle 竞赛中开始了这个项目，目标是根据一些比赛结束时的统计数据(如比赛中跑的距离等)来预测比赛中的球员排名。我想了解数据源(看看是否有一些故意遗漏的统计数据/信息),并尝试亚马逊的一些服务，如 AWS Glue 和 Athena，以在 AWS 中建立一个数据管道。

在这篇文章中，我将解释:

• 什么是 PUBG，游戏的原理等等
• 项目的方法
• 数据的收集和清理

PUBG 的描述

PUBG 是一款名为 battle royale 的视频游戏类型的旗舰之一(首先也是最受欢迎的之一)，主要是 100 名玩家(或多或少)被丢在一个岛上，没有装备，他们必须通过收集材料，武器，装备和车辆在这个岛上生存。

为了促使人们去战斗，随着游戏的进行，可用的区域变得越来越小，所以这种形式促使人们互相战斗，因为最终只能有一个幸存者。有两个非常受欢迎的游戏支持这一运动，它们是 PUBG 和堡垒之夜，它们可以在所有可能的平台上使用(主机上的 PUBG 不好)，现在你可以看到所有其他受欢迎的游戏(使命召唤，战场)都想在里面添加自己的皇家战役模式，但让我们诚实地说，堡垒之夜正在击败所有人(查看谷歌趋势 PUBG VS Fornite)

我对这类游戏的看法是，原则很酷，你可以在游戏过程中建立一些紧张的令人惊讶的情况，但我认为你不能出售(全价)一个只是皇家战役的游戏。Epic 对堡垒之夜很聪明，因为他们通过提出一个免费的独立应用程序，将一个制作时间长且销售情况不好的项目变成了一个非常有利可图的项目，该应用程序使用的资产与原始游戏相同，但只专注于皇家战役(我希望有想法的人能加薪)。

让我们看看数据收集的项目。

项目方法

这个项目背后的想法是:建立一个系统，从 PUBG 公司提供的 API 收集数据清洁数据，使所有的数据可用，而不是下载我的机器上的一切

为了建立管道，我决定使用 AWS，因为与微软、谷歌等相比，我更喜欢他们的服务，但我确信同样的系统也可以在这些平台上建立。

为了完成任务，我决定使用以下服务:

• EC2 实例运行一台机器来进行收集
• S3 存储收集到的数据并进行处理
• 粘合使数据清晰可用
• Athena 是 S3 数据存储的接口

这是 AWS 上不同步骤的流程部署的高级视图。

我们来详细看看过程。

从 PUBG API 收集数据

PUBG 公司已经建立了一个非常好的开放的 API，有多个端点开放不同的数据源。为了简单起见，您可以访问与以下内容相关的数据:

• 由他们的帐户 id 定义的 PUBG 播放器
• 由其 matchid 定义的匹配

有来自不同地区(美洲、欧洲和亚洲)的多个平台(pc、xbox 和 ps4)的数据。在这篇文章中，我将重点介绍 PC 平台和北美地区。这个 API 有多个端点，但让我们把重点放在:

• 样本端点:提供对每天更新的一些 matchid 的访问
• 匹配端点:给出了匹配的细节，比如最终结果，更重要的是下载事件压缩包的链接。

你可以找到一个仓库，里面有我构建的收集、清理和发送数据的函数。这个笔记本能让你深入了解收集到的数据。有三种类型的数据:

• 结束比赛统计数据，它们存储在 s3 存储桶的“文件夹”中
• 存储在另一个文件夹中的完整事件
• 存储在单独文件夹中的分解事件

关于事件包，API 上有多个可用的事件，有一个模式包含这些事件的详细信息。

我计划每天在 EC2 实例上运行一个脚本，该脚本触发了从样本中获取新数据，并将其存储在正确的文件夹和 day 文件夹中。

为了获得一般信息，比赛的细节被收集到一个 dynamodb 表中(比如人数，地图名称等)。

当你存储数据时，我能给你的一些建议是:

• 妥善保存。gz 文件
• 明确分隔符、空格符和引号符
• 删除索引
• 对于 Dynamodb，将浮点数据转换为十进制数据

这是关于我如何收集数据的简单概述，现在让我们看看云部分。

用胶水抓取 S3 和 Dynamodb 中的数据数据(这么多名字掉线)

AWS glue setup 仪表板分为两个部分，分别是数据目录部分和 ETL 部分(我将重点介绍仪表板的上部)。

让我们首先关注数据目录。

数据目录和爬虫部分

在这一部分中，您可以找到一个 database 选项卡，它包含所有数据库和您用 Glue 创建的相关表。为了这个项目，我创建了我的第一个数据库。有趣的部分是爬虫标签，在那里你可以设置爬虫在 S3 导航，Dynamodb 和 AWS 的一些其他服务(像 RDS)。在上图中，有一个我为这个项目创建的所有爬虫的列表。让我们看看爬虫里面有什么。

因此，当您设置爬虫时，需要:

• 为你的爬虫取一个名字
• 定义数据源，在本例中，我将关注三个事件和我的 Dynamodb 表
• 为您的 crawler 定义一个 AWS 角色，使其能够访问所有要被爬网的数据源
• 定义爬虫的执行频率，我决定让它每周运行一次
• 定义爬虫的输出

我强烈建议激活复选框，用表中的元数据更新所有新的和现有的分区，以避免在读取数据期间出现一些分区问题，如果你不像我一样控制你正在接收的内容。

瞧，你只需要从 AWS Glue 的主页运行爬虫程序，现在你就可以通过 Athena 中的爬虫程序访问你的数据摘录(SQL 方式访问数据)。

但是数据仍然很原始，所以我决定给爬虫添加一个新的层来清理数据和添加一些信息。

ETL 部分

对于 ETL 部分，这是管道的数据处理部分。我本来可以在数据到达 S3 存储桶时对其进行分析，但是我注意到一些记录不太好(比如说损坏了)，所以我想为这些数据应用一个转换状态:

• 删除损坏的记录(带有错误的 matchid 格式)
• 使用 dynamodb 表中收集的匹配细节进行连接(并在之前进行爬网)
• 计算事件和比赛开始之间的时间差(秒和分)
• 在事件函数中进行一些简单的字符串操作(比如清除武器的名称)

这里有代码的插图，你可以在库中找到这段代码。

我尝试了代码方法，但有一个选项 ETL 配置，您可以有更多的图表方法来进行数据操作，因为我想使用 rdd 映射和 spark 的数据帧，我决定不使用此功能，但我做了一些简单的测试，它工作得很好。所以现在只需要构建一个爬虫来用 ETL 部分生成的新数据更新数据目录。

在下面的模式中，有 AWS Glue 中操作的时间表。

现在让我们在 AWS 上做一个快速测试，从 web 界面请求流程数据。

这些数据可以从 Athena 访问，但你可以连接 AWS quicksight，它有更像 Tableau 的体验(我不喜欢的是，我不喜欢所有这些对我来说太黑的 BI 工具)，更重要的是，你可以从笔记本上访问这些数据(在库中有一个 python 环境的副本)。

这是对我从 PUBG API 收集数据的数据管道的描述，系统每天收集大约 1000 个匹配，这不是一个很大的数量，但我想从小的开始。

我是一个好人，你可以在这个 kaggle 数据集 中找到我为这个项目建立的表格的摘录(这是 2019 年 1 月 27 日的数据摘录)。

我希望你喜欢阅读，如果你有任何意见，请不要犹豫。

原载于 2019 年 2 月 1 日 the-odd-dataguy.com。

用你的机器学习模型构建一个 Docker 容器

原文：https://towardsdatascience.com/build-a-docker-container-with-your-machine-learning-model-3cf906f5e07e?source=collection_archive---------3-----------------------

Docker 初学者模板脚本完全指南

Photo by Chris Leipelt on Unsplash

作为一名数据科学家，我没有太多的软件工程经验，但是我肯定听过很多关于容器的很棒的评论。我听说过与传统虚拟机相比，它们是多么的轻量级，它们在确保您的代码有一个安全一致的环境方面有多好，以及我的 devops 工作如何节省，以便您可以专注于您的代码。

然而，当我试图将我自己的模型分类时，我很快意识到它并不那么直观。这一点也不像在 EC2 引导脚本前面加上RUN那么简单。我发现不一致和不可预测的行为经常发生，学习调试一个新工具可能会令人沮丧。

所有这些促使我创建了这篇文章，其中包含了将 Python 中的 ML 模型分解到 Docker 容器所需的所有代码片段。我将指导您安装您需要的所有 pip 包，并构建您的第一个容器映像。在这篇文章的第二部分的中，我们将设置所有必要的 AWS 环境，并在这个系列的第三部分也是最后一部分开始批处理容器。

免责声明 1:我这里说的模型是单个实例上的批处理作业，不是有 API 端点的 web 服务，不是分布式并行作业。如果您遵循本教程，将代码放入容器的整个过程应该不会超过 25 分钟。

免责声明 2:如果这是你第一次阅读关于容器的文章，这篇文章可能不会提供理解容器如何工作的必要信息，我强烈建议你在继续之前查阅一些在线教程。

先决条件

• AWS 账户
• 安装了 AWS CLI
• Docker 已安装，账户设置在 DockerHub
• Python 3 已安装

创建 Dockerfile 文件👷🏻‍♀️

要将您的代码放入容器，您需要创建一个Dockerfile，它告诉 Docker 您在应用程序中需要什么。

一个Dockerfile是一个文本文档，它包含了用户可以在命令行上调用的所有命令来组合一个图像。

(您可以从Dockerfile或docker-compose.yml构建 Docker 映像。如果你的代码可以被重构为一个多容器 Docker 应用程序，你可能想看看docker compose，但是现在一个Dockerfile应该足够了。)

Docker 映像从基础映像开始，由只读层构建而成，每一层都添加了一些依赖关系。最后，您告诉容器如何触发您的模型。

minimal Dockerfile for a Python application

在上面的 other 文件中，我从基本的 Python 3.6 伸展映像开始，apt-get更新了系统库，安装了一些make和build的东西，检查了我的 Python 和pip版本以确保它们是好的，建立了我的工作目录，将requirements.txt复制到容器中，pip 在其中安装了所有的库，最后将所有其他代码文件复制到容器中，列出了所有文件以确保我需要的都在那里，并触发了我的入口点main.py文件。

如果你的代码文件夹结构是这样的，这个Dockerfile应该对你有用。

- app-name
     |-- src
          |-- main.py
          |-- other_module.py
     |-- requirements.txt
     |-- Dockerfile

如果您的代码还没有一个main.py或 shell 脚本来触发模型训练/推理，那么您可能想要首先重构您的代码。还记得用pipreqs path/to/project将库依赖关系冻结到一个requirements.txt文件中。我推荐使用pipreqs而不是pip freeze，因为当你运行pip freeze > requirements.txt时，它会输出该环境中所有已安装的包，而pipreqs只给你这个项目实际导入的包。(如果还没有pip(3) install pipreqs安装pipreqs

如果你的代码已经有了一个入口点，你需要做的就是把<app- name>改成你的应用程序的名字，我们就可以把它构建成一个图像了。

有很多让Dockerfile变得更小更高效的最佳实践，但是大多数都超出了本文的范围。但是，您可能需要注意以下几点:

1.1 使用 Python 拉伸作为基础图像

人们说不要从一个普通的 Ubuntu 镜像开始，而是使用一个官方的基础镜像，比如 Alpine Python。Alpine Python 是一个基于 Alpine Linux 的非常小的 Python Docker 映像，比默认的 docker python 映像小得多，但仍然拥有最常见的 Python 项目所需的一切。但是我发现使用它非常困难，尤其是在安装包的时候。

另一方面，Ubuntu 基础映像将提供更可预测的行为，但是您需要自己安装所有 Python 的东西。

所以我建议你从 Python 3.6 stretch 开始，这是基于 Debian 9(又名 stretch)的官方 Python 镜像。Python stretch 附带了 Python 环境和 pip 安装，并且是最新的，如果你选择 Ubuntu，你需要弄清楚如何安装所有这些。

1.2 仅安装您需要的东西

复制和粘贴一些网上发布的Dockerfile模板也很有诱惑力，尤其是如果这是你的第一个 Docker 项目。但是建议只安装你实际需要的东西来控制图像的大小。如果你看到其他人安装了一大堆make和build的东西，试着先不要包括它们，看看你的容器是否能工作。较小的映像通常意味着构建和部署速度更快。(你应该试试我上面的极简主义模板的另一个原因！)

同样为了保持图像尽可能的简洁，使用.dockerignore，它的工作方式和.gitignore完全一样，忽略那些不会影响模型的文件。

an example .dockerignore file

1.3 在代码前增加requirements.txt

在您的Dockerfile中，总是在复制源代码之前添加您的requirements.txt文件。这样，当您更改代码并重新构建容器时，Docker 将重用缓存层，直到安装了包，而不是在每次构建时执行pip install命令，即使库依赖关系从未更改。没有人愿意仅仅因为你在代码中添加了一个空行就多等几分钟。

如果你有兴趣了解更多关于Dockerfile的信息，在附录 I 中有我们使用的一些基本命令的快速总结。或者你可以在这里查看 Dockerfile 文档。

现在可以随意跳到第 2 步，用刚刚创建的Dockerfile构建一个容器。

第二步——用你的 docker 文件建立一个图像👩🏻‍🍳

准备好Dockerfile之后，就该构建容器映像了。docker build根据Dockerfile中给出的指令创建图像。你所需要做的就是给你的图像一个名字(一个可选的版本标签)。

$ docker build -t IMAGE_NAME:TAG .
$ # or
$ docker build -t USERNAME/IMAGE_NAME:TAG .

这两个命令的唯一区别是图像名称前是否有一个USERNAME/。映像名称由斜杠分隔的名称组成，通常前缀是注册表主机名。USERNAME/IMAGE_NAME一般不是指定图像名称的强制格式。但是亚马逊 ECR 存储库中的图像确实遵循完整的REGISTRY/REPOSITORY:TAG命名约定。比如aws_account_id.dkr.ecr.region.amazonaws.com/my-web-app:latest。

上面的命令中发生了一些事情。

首先，我们告诉 Docker 守护进程获取当前目录中的Dockerfile(这就是末尾的.所做的)。

接下来，我们告诉 Docker 守护进程构建图像并给它指定标签。标记对我来说一直很困惑。通常标记图像就像给它一个别名。这与给现有图像指定另一个名称来引用它是一样的。这有助于区分 Docker 图像的版本。

指定标记名不是强制性的。在没有指定特定标签的情况下运行构建时，:latest标签是默认标签。因此，如果您想维护一个好的版本历史，建议您在每次构建之后都明确地标记您的映像。

$ docker build -t USERNAME/IMAGE_NAME .
$ docker tag USERNAME/IMAGE_NAME USERNAME/IMAGE_NAME:1.0
$ ...
$ docker build -t USERNAME/IMAGE_NAME .
$ docker tag USERNAME/IMAGE_NAME USERNAME/IMAGE_NAME:2.0
$ ...

您可以在使用docker build -t USERNAME/IMAGE_NAME:TAG .构建图像时标记图像，或者在构建后像docker tag SOURCE_IMAGE:TAG TARGET_IMAGE:TAG一样显式标记图像。

现在，如果您运行docker images，您应该看到本地存在一个图像，它的存储库是USERNAME/IMAGE_NAME，标签是TAG。

$ docker images

我还建议您此时在本地机器上测试您的容器，以确保一切正常。

$ docker run USERNAEM/IMAGE_NAME:TAG

请随意查看附录 II，获取一些基本 Docker CLI 命令的快速摘要，或在此处查看官方文档。

恭喜你！您只是将您的模型放入一个可以在任何安装了 Docker 的地方运行的容器中。请加入我这篇文章的第二部分，来配置您的 AWS 环境，以满足调度批处理作业的先决条件。

附录 I — Dockerfile 命令👩🏻‍🏫

• FROM启动Dockerfile。要求Dockerfile必须以FROM命令开始。图像是在层中创建的，这意味着您可以使用另一个图像作为您自己的基础图像。FROM命令定义了你的基础层。作为参数，它采用图像的名称。可选的，你可以添加维护者和镜像版本的 Docker Cloud 用户名，格式 username/imagename:version。
• RUN用于构建您正在创建的图像。对于每个RUN命令，Docker 将运行命令，然后创建一个新的图像层。这样，您可以轻松地将映像回滚到以前的状态。RUN指令的语法是将 shell 命令的全文放在RUN之后(例如RUN mkdir /user/local/foo)。这将在一个/bin/sh外壳中自动运行。您可以像这样定义一个不同的 shell:RUN /bin/bash -c 'mkdir /user/local/foo'。
• COPY将本地文件复制到容器中。
• CMD定义启动时将在图像上运行的命令。与RUN不同，这不会为图像创建一个新层，而只是运行命令。每个 Dockerfile/Image 只能有一个CMD。如果您需要运行多个命令，最好的方法是让CMD运行一个脚本。CMD要求你告诉它在哪里运行命令，不像RUN。
• EXPOSE为镜像用户创建一个提示，提示哪些端口提供服务。它包含在可通过docker inspect <container-id>检索的信息中。
• 注意:EXPOSE命令实际上并没有让主机访问任何端口！相反，这需要在使用docker run时通过-p标志发布端口。
• 将您的映像推送到私有或云注册表。

附录 II — Docker CLI 命令👩🏻‍🏫

一些基本的 Docker CLI 命令包括:

• docker build从 Dockerfile 文件构建图像
• docker images显示机器上的所有 Docker 图像
• 启动一个容器并在其中运行命令
• docker run选项:
• -p指定主机和 Docker 容器中的端口
• -it打开交互式控制台
• -d以守护模式启动容器(在后台运行)
• -e设置环境变量
• docker ps显示所有正在运行的容器
• docker rmi删除一个或多个图像
• docker rm移除一个或多个容器
• docker kill杀死一个或多个运行中的容器
• docker tag用别名标记图像，以便以后参考
• docker login登录您的 Docker 注册表

关于作者

我是一名机器学习工程师，除了技术教程之外，我还撰写关于生产力和自我发展的文章。我在 7 月 4 日参观了黄石公园，这就是封面图片。

让我们建立一个时尚-MNIST 有线电视新闻网，PyTorch 风格

原文：https://towardsdatascience.com/build-a-fashion-mnist-cnn-pytorch-style-efb297e22582?source=collection_archive---------2-----------------------

如何使用 Google Colab 和 TensorBoard 从头开始构建 PyTorch ML 项目的逐行指南

当谈到技术中的框架时，一件有趣的事情是，从一开始，似乎总是有各种各样的选择。但随着时间的推移，竞争将演变为只剩下两个强有力的竞争者。典型的例子有“PC vs Mac”、“iOS vs Android”、“React.js vs Vue.js”等。而现在，我们在机器学习方面有了‘py torch vs tensor flow’。

由谷歌支持的 TensorFlow 无疑是这方面的领跑者。它于 2015 年作为开源机器学习框架发布，迅速获得了大量关注和接受，特别是在生产准备和部署非常关键的行业。 PyTorch 由脸书在 2017 年推出，但由于其动态计算图和'python 式'风格，很快获得了从业者和研究人员的喜爱。

Image from The Gradient

The Gradient 最近的研究表明，PyTorch 在研究人员中表现出色，TensorFlow 在业界占据主导地位:

2019 年，ML 框架的战争还有两个主要竞争者:PyTorch 和 TensorFlow。我的分析表明，研究人员正在放弃 TensorFlow，成群结队地涌向 PyTorch。与此同时，在行业中，Tensorflow 是目前的首选平台，但这种情况可能不会持续太久。— 坡度

最近发布的 PyTorch 1.3 引入了 PyTorch Mobile、quantization 和其他好东西，它们都朝着缩小差距的正确方向前进。如果你对神经网络基础有点熟悉，但想尝试 PyTorch 作为一种不同的风格，那么请继续阅读。我将尝试解释如何使用 PyTorch 为时尚-MNIST 数据集从头构建一个卷积神经网络分类器。如果你没有强大的本地环境，这里的代码可以在 Google Colab 和 Tensor Board 上使用。事不宜迟，我们开始吧。您可以在下面找到 Google Colab 笔记本和 GitHub 链接:

📙谷歌 Colab 笔记本

👽 GitHub

导入

首先，让我们导入必要的模块。

# import standard PyTorch modules
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.tensorboard import SummaryWriter # TensorBoard support

# import torchvision module to handle image manipulation
import torchvision
import torchvision.transforms as transforms

# calculate train time, writing train data to files etc.
import time
import pandas as pd
import json
from IPython.display import clear_output

torch.set_printoptions(linewidth=120)
torch.set_grad_enabled(True)     # On by default, leave it here for clarity

PyTorch 模块非常简单。

火炬

torch是主模块，包含了张量计算所需的所有东西。您可以单独使用张量计算来构建一个全功能的神经网络，但这不是本文要讨论的内容。我们将利用更强大、更方便的torch.nn、torch.optim和torchvision类来快速构建我们的 CNN。对于那些有兴趣知道如何从“从抓到开始做这件事的人，请访问这个奇妙的 PyTorch 官方 tutoria l 作者杰瑞米·霍华德。

torch.nn 和 torch.nn 功能

Photo by Alphacolor on Unsplash

torch.nn模块提供了许多构建神经网络的类和函数。你可以把它想象成神经网络的基本构件:模型、各种层、激活函数、参数类等等。它允许我们像组装乐高玩具一样来建造模型。

火炬. optim

torch.optim提供所有优化器，如 SGD、ADAM 等。，这样就不用从头开始写了。

火炬视觉

torchvision包含大量流行的数据集、模型架构和计算机视觉的常见图像转换。我们从中获取时尚 MNIST 数据集，并使用其变换。

摘要记录器(张量板)

SummaryWriter使 PyTorch 能够为张量板生成报告。我们将使用 Tensor Board 查看我们的训练数据，比较结果并获得直觉。张量板曾经是 TensorFlow 相对于 PyTorch 的最大优势，但是现在从 v1.2 开始 PyTorch 正式支持张量板。

我们还引入了其他一些实用模块，如time、json、pandas等。

资料组

torchvision已经有了时尚 MNIST 数据集。如果你不熟悉时尚 MNIST 数据集:

Fashion-MNIST是一个由 Zalando 的文章图像组成的数据集，由 60，000 个示例的训练集和 10，000 个示例的测试集组成。每个示例都是 28x28 灰度图像，与 10 个类别的标签相关联。我们打算将Fashion-MNIST作为原始 MNIST 数据集的直接替代，用于机器学习算法的基准测试。它共享训练和测试分割的相同图像大小和结构。— 来自 Github

Fashion MNIST Dataset — From GitHub

# Use standard FashionMNIST dataset
train_set = torchvision.datasets.FashionMNIST(
    root = './data/FashionMNIST',
    train = True,
    download = True,
    transform = transforms.Compose([
        transforms.ToTensor()                                 
    ])
)

这个不需要过多解释。我们指定根目录来存储数据集，抓取训练数据，如果本地机器上没有，允许下载它，然后应用transforms.ToTensor将图像转换成张量，这样我们就可以在我们的网络中直接使用它。数据集存储在名为train_set.的dataset类中

网络

在 PyTorch 中构建实际的神经网络既有趣又简单。我假设你对卷积神经网络的工作原理有一些基本的概念。如果没有，可以参考 deeplizard 的这个视频:

时尚 MNIST 只有 28x28 px 大小，所以我们实际上不需要非常复杂的网络。我们可以像这样建立一个简单的 CNN:

我们有两个卷积层，每个卷积层有 5x5 个内核。在每个卷积层之后，我们有一个跨度为 2 的最大池层。这允许我们从图像中提取必要的特征。然后我们展平张量，将它们放入密集层，通过多层感知器(MLP)来执行我们的 10 个类别的分类任务。

现在我们已经清楚了网络的结构，让我们看看如何使用 PyTorch 来构建它:

# Build the neural network, expand on top of nn.Module
class Network(nn.Module):
  def __init__(self):
    super().__init__()

    # define layers
    self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5)
    self.conv2 = nn.Conv2d(in_channels=6, out_channels=12, kernel_size=5)

    self.fc1 = nn.Linear(in_features=12*4*4, out_features=120)
    self.fc2 = nn.Linear(in_features=120, out_features=60)
    self.out = nn.Linear(in_features=60, out_features=10)

  # define forward function
  def forward(self, t):
    # conv 1
    t = self.conv1(t)
    t = F.relu(t)
    t = F.max_pool2d(t, kernel_size=2, stride=2)

    # conv 2
    t = self.conv2(t)
    t = F.relu(t)
    t = F.max_pool2d(t, kernel_size=2, stride=2)

    # fc1
    t = t.reshape(-1, 12*4*4)
    t = self.fc1(t)
    t = F.relu(t)

    # fc2
    t = self.fc2(t)
    t = F.relu(t)

    # output
    t = self.out(t)
    # don't need softmax here since we'll use cross-entropy as activation.

    return t

首先 PyTorch 中所有的网络类都是在基类上扩展的:nn.Module。它包含了所有的基础知识:权重、偏差、正向方法以及一些实用属性和方法，如.parameters()和.zero_grad()，我们也将使用它们。

我们的网络结构在__init__ dunder 函数中定义。

def __init__(self): 
  super().__init__()   # define layers 
  self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5)
  self.conv2 = nn.Conv2d(in_channels=6, out_channels=12, kernel_size=5)
  self.fc1 = nn.Linear(in_features=12*4*4, out_features=120)
  self.fc2 = nn.Linear(in_features=120, out_features=60)
  self.out = nn.Linear(in_features=60, out_features=10)

nn.Conv2d和nn.Linear是在torch.nn模块中定义的两个标准 PyTorch 层。这些都是不言自明的。需要注意的一点是，我们在这里只定义了实际的层。激活和最大池化操作包含在下面解释的转发功能中。

# define forward function  
def forward(self, t):  
  # conv 1  
  t = self.conv1(t)  
  t = F.relu(t)  
  t = F.max_pool2d(t, kernel_size=2, stride=2)     # conv 2  
  t = self.conv2(t)   
  t = F.relu(t)  
  t = F.max_pool2d(t, kernel_size=2, stride=2)     # fc1   
  t = t.reshape(-1, 12*4*4)  
  t = self.fc1(t)  
  t = F.relu(t)     # fc2  
  t = self.fc2(t)  
  t = F.relu(t)    # output  
  t = self.out(t)    # don't need softmax here since we'll use cross-entropy as activation.   
  return t

一旦定义了层，我们就可以使用层本身来计算每一层的转发结果，加上激活函数(ReLu)和最大池操作，我们可以很容易地编写我们的网络的转发函数，如上所述。注意，在fc1(完全连接第 1 层)上，我们使用 PyTorch 的张量运算t.reshape来展平张量，这样它就可以传递给后面的致密层。此外，我们没有在输出层添加 softmax 激活函数，因为 PyTorch 的 CrossEntropy 函数会为我们处理这个问题。

超参数

通常情况下，我们可以只手动选择一组超参数，并用它们做一些实验。在这个例子中，我们想通过引入一些结构化来做更多的事情。我们将构建一个系统来生成不同的超参数组合，并使用它们来执行训练“运行”。每次“运行”使用一组超参数组合。将每次跑步的训练数据/结果导出到 Tensor Board，以便我们可以直接比较并查看哪个超参数集表现最佳。

我们将所有的超参数存储在一个 有序指令 中:

# put all hyper params into a OrderedDict, easily expandable
params = OrderedDict(
    lr = [.01, .001],
    batch_size = [100, 1000],
    shuffle = [True, False]
)
epochs = 3

lr:学习率。我们想为我们的模型尝试 0.01 和 0.001。

batch_size:批量，加速训练过程。我们会用 100 和 1000。

shuffle : Shuffle toggle，我们是否在训练前洗牌。

一旦参数下降。我们使用两个助手类:RunBuilder和RunManager来管理我们的超参数和训练过程。

运行生成器

类RunBuilder的主要目的是提供一个静态方法get_runs。它将 OrderedDict(其中存储了所有超参数)作为一个参数，并生成一个名为元组 Run的，每个run元素代表超参数的一种可能组合。这个命名元组稍后由训练循环使用。代码很容易理解。

# import modules to build RunBuilder and RunManager helper classes
from collections  import OrderedDict
from collections import namedtuple
from itertools import product

# Read in the hyper-parameters and return a Run namedtuple containing all the 
# combinations of hyper-parameters
class RunBuilder():
  @staticmethod
  def get_runs(params):

    Run = namedtuple('Run', params.keys())

    runs = []
    for v in product(*params.values()):
      runs.append(Run(*v))

    return runs

运行管理器

RunManager 类有四个主要目的。

1. 计算并记录每个时期和运行的持续时间。
2. 计算每个历元和运行的训练损失和准确度。
3. 记录训练数据(如损耗、准确度、重量、梯度、计算图等)。)并运行，然后将它们导出到张量板以供进一步分析。
4. 将所有训练结果保存在csv和json中，以备将来参考或提取 API。

如你所见，它帮助我们处理后勤工作，这对我们成功训练模型也很重要。让我们看看代码。这有点长，请原谅:

# Helper class, help track loss, accuracy, epoch time, run time, 
# hyper-parameters etc. Also record to TensorBoard and write into csv, json
class RunManager():
  def __init__(self):

    # tracking every epoch count, loss, accuracy, time
    self.epoch_count = 0
    self.epoch_loss = 0
    self.epoch_num_correct = 0
    self.epoch_start_time = None

    # tracking every run count, run data, hyper-params used, time
    self.run_params = None
    self.run_count = 0
    self.run_data = []
    self.run_start_time = None

    # record model, loader and TensorBoard 
    self.network = None
    self.loader = None
    self.tb = None

  # record the count, hyper-param, model, loader of each run
  # record sample images and network graph to TensorBoard  
  def begin_run(self, run, network, loader):

    self.run_start_time = time.time()

    self.run_params = run
    self.run_count += 1

    self.network = network
    self.loader = loader
    self.tb = SummaryWriter(comment=f'-{run}')

    images, labels = next(iter(self.loader))
    grid = torchvision.utils.make_grid(images)

    self.tb.add_image('images', grid)
    self.tb.add_graph(self.network, images)

  # when run ends, close TensorBoard, zero epoch count
  def end_run(self):
    self.tb.close()
    self.epoch_count = 0

  # zero epoch count, loss, accuracy, 
  def begin_epoch(self):
    self.epoch_start_time = time.time()

    self.epoch_count += 1
    self.epoch_loss = 0
    self.epoch_num_correct = 0

  # 
  def end_epoch(self):
    # calculate epoch duration and run duration(accumulate)
    epoch_duration = time.time() - self.epoch_start_time
    run_duration = time.time() - self.run_start_time

    # record epoch loss and accuracy
    loss = self.epoch_loss / len(self.loader.dataset)
    accuracy = self.epoch_num_correct / len(self.loader.dataset)

    # Record epoch loss and accuracy to TensorBoard 
    self.tb.add_scalar('Loss', loss, self.epoch_count)
    self.tb.add_scalar('Accuracy', accuracy, self.epoch_count)

    # Record params to TensorBoard
    for name, param in self.network.named_parameters():
      self.tb.add_histogram(name, param, self.epoch_count)
      self.tb.add_histogram(f'{name}.grad', param.grad, self.epoch_count)

    # Write into 'results' (OrderedDict) for all run related data
    results = OrderedDict()
    results["run"] = self.run_count
    results["epoch"] = self.epoch_count
    results["loss"] = loss
    results["accuracy"] = accuracy
    results["epoch duration"] = epoch_duration
    results["run duration"] = run_duration

    # Record hyper-params into 'results'
    for k,v in self.run_params._asdict().items(): results[k] = v
    self.run_data.append(results)
    df = pd.DataFrame.from_dict(self.run_data, orient = 'columns')

    # display epoch information and show progress
    clear_output(wait=True)
    display(df)

  # accumulate loss of batch into entire epoch loss
  def track_loss(self, loss):
    # multiply batch size so variety of batch sizes can be compared
    self.epoch_loss += loss.item() * self.loader.batch_size

  # accumulate number of corrects of batch into entire epoch num_correct
  def track_num_correct(self, preds, labels):
    self.epoch_num_correct += self._get_num_correct(preds, labels)

  @torch.no_grad()
  def _get_num_correct(self, preds, labels):
    return preds.argmax(dim=1).eq(labels).sum().item()

  # save end results of all runs into csv, json for further analysis
  def save(self, fileName):

    pd.DataFrame.from_dict(
        self.run_data, 
        orient = 'columns',
    ).to_csv(f'{fileName}.csv')

    with open(f'{fileName}.json', 'w', encoding='utf-8') as f:
      json.dump(self.run_data, f, ensure_ascii=False, indent=4)

**__init__**:初始化必要的属性，如计数、丢失、正确预测数、开始时间等。

**begin_run**:记录运行开始时间，以便当运行结束时，可以计算运行的持续时间。创建一个SummaryWriter对象来存储我们在运行过程中想要导出到张量板的所有内容。将网络图和样本图像写入SummaryWriter对象。

**end_run**:运行完成后，关闭 SummaryWriter 对象，并将历元计数重置为 0(准备下一次运行)。

**begin_epoch**:记录历元开始时间，以便在历元结束时计算历元持续时间。复位epoch_loss和epoch_num_correct。

这个函数是大多数事情发生的地方。当一个时期结束时，我们将计算时期持续时间和运行持续时间(直到这个时期，而不是最后的运行持续时间，除非是运行的最后一个时期)。我们将计算这个时期的总损耗和精确度，然后将损耗、精确度、权重/偏差、梯度导出到张量板中。为了便于在 Jupyter 笔记本中跟踪，我们还创建了一个 OrderedDict 对象results，并将我们所有的运行数据(损失、准确度、运行计数、历元计数、运行持续时间、历元持续时间、所有超参数)放入其中。然后我们将使用熊猫来读取它，并以整洁的表格格式显示出来。

**track_loss** 、 **track_num_correct** 、 **_get_num_correct**:这些是累计损失的效用函数，每批的正确预测数，以便以后计算历元损失和精度。

**save**:将所有运行数据(所有运行的results OrderedDict 对象列表)保存为csv和json格式，以便进一步分析或 API 访问。

这门课有很多东西要学。恭喜你走到这一步！最困难的部分已经过去了。从现在开始，一切都会变得有意义。

培养

终于，我们准备好进行一些训练了！在我们的RunBuilder 和RunManager课程的帮助下，培训过程变得轻而易举:

m = RunManager()

# get all runs from params using RunBuilder class
for run in RunBuilder.get_runs(params):

    # if params changes, following line of code should reflect the changes too
    network = Network()
    loader = torch.utils.data.DataLoader(train_set, batch_size = run.batch_size)
    optimizer = optim.Adam(network.parameters(), lr=run.lr)

    m.begin_run(run, network, loader)
    for epoch in range(epochs):

      m.begin_epoch()
      for batch in loader:

        images = batch[0]
        labels = batch[1]
        preds = network(images)
        loss = F.cross_entropy(preds, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        m.track_loss(loss)
        m.track_num_correct(preds, labels)

      m.end_epoch()
    m.end_run()

# when all runs are done, save results to files
m.save('results')

首先，我们使用RunBuilder创建超参数的迭代器，然后遍历每个超参数组合来执行我们的训练:

for run in RunBuilder.get_runs(params):

然后，我们从上面定义的Network类创建我们的network对象。network = Network()。这个network物体承载了我们需要训练的所有重量/偏差。

我们还需要创建一个DataLoader 对象。它是一个 PyTorch 类，保存我们的训练/验证/测试数据集，它将遍历数据集，并按指定的batch_size批量给我们训练数据。

loader = torch.utils.data.DataLoader(train_set, batch_size = run.batch_size)

之后，我们将使用torch.optim类创建一个优化器。optim类获取网络参数和学习率作为输入，将帮助我们逐步完成训练过程并更新梯度等。我们将使用 Adam 作为优化算法。

optimizer = optim.Adam(network.parameters(), lr=run.lr)

好的。现在我们已经创建了网络，准备好了数据加载器，选择了优化器。让我们开始训练吧！

我们将遍历所有我们想要训练的纪元(这里是 3 个),所以我们将所有东西都放在一个“纪元”循环中。我们还使用我们的RunManager类的begin_run方法来开始跟踪跑步训练数据。

m.begin_run(run, network, loader)    
for epoch in range(epochs):

对于每个时期，我们将遍历每批图像来进行训练。

m.begin_epoch()    
for batch in loader:              
  images = batch[0]      
  labels = batch[1]      
  preds = network(images)      
  loss = F.cross_entropy(preds, labels)

  optimizer.zero_grad()  
  loss.backward()      
  optimizer.step()

  m.track_loss(loss)      
  m.track_num_correct(preds, labels)

上面的代码是真正的训练发生的地方。我们从批处理中读入图像和标签，使用network类进行前向传播(还记得上面的forward方法吗？)并得到预测。通过预测，我们可以使用cross_entropy函数计算该批次的损失。一旦计算出损失，我们用.zero_grad()重置梯度(否则 PyTorch 会累积梯度，这不是我们想要的)，使用loss.backward()方法进行一次反向传播，以计算权重/偏差的所有梯度。然后，我们使用上面定义的优化器来更新权重/偏差。现在网络已经为当前批次更新，我们将计算正确预测的损失和数量，并使用我们的RunManager类的track_loss和track_num_correct方法累积/跟踪它们。

一旦全部完成，我们将使用m.save('results')将结果保存在文件中。

笔记本中运行的输出如下所示:

张量板

Image from Tensorboard.org

传感器板是一个 TensorFlow 可视化工具，现在 PyTorch 也支持它。我们已经努力将所有内容输出到。/runs '文件夹，Tensor Board 将在其中查找要使用的记录。我们现在需要做的只是启动张量板并进行检查。由于我在 Google Colab 上运行这个模型，我们将使用一个名为ngrok的服务来代理和访问我们在 Colab 虚拟机上运行的张量板。先安装ngrok :

!wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip!unzip ngrok-stable-linux-amd64.zip

然后，指定我们要从中运行张量板的文件夹，并启动张量板 web 界面。/runs 是默认值):

LOG_DIR = './runs'get_ipython().system_raw('tensorboard --logdir {} --host 0.0.0.0 --port 6006 &'.format(LOG_DIR))

启动ngrok代理:

get_ipython().system_raw('./ngrok http 6006 &')

生成一个 URL，以便我们可以从 Jupyter 笔记本中访问我们的张量板:

! curl -s http://localhost:4040/api/tunnels | python3 -c \"import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])"

正如我们在下面看到的，TensorBoard 是一个非常方便的可视化工具，让我们可以深入了解我们的训练，并可以极大地帮助超参数调整过程。我们可以很容易地找出哪个超参数组件表现最好，然后用它来做我们真正的训练。

结论

正如你所看到的，PyTorch 作为一个机器学习框架是灵活的、强大的和富有表现力的。你只需要写 Python 代码。由于本文的主要重点是展示如何使用 PyTorch 构建一个卷积神经网络，并以结构化的方式对其进行训练，因此我没有完成整个训练时期，精度也不是最佳的。你可以自己试试，看看模型表现如何。

这篇文章很大程度上受到了 deeplizard 在 YouTube 上的 PyTorch 视频系列的启发。甚至大部分代码片段都是直接抄袭过来的。我想感谢他们的伟大内容，如果你觉得有必要深入研究，随时去看看，并订阅他们的频道。

觉得这篇文章有用？在 Medium 上关注我(李立伟)或者你可以在 Twitter @lymenlee 或者我的博客网站wayofnumbers.com上找到我。你也可以看看我下面最受欢迎的文章！

[## “这是 CS50”:开始数据科学教育的愉快方式

为什么 CS50 特别适合巩固你的软件工程基础

towardsdatascience.com](/this-is-cs50-a-pleasant-way-to-kick-off-your-data-science-education-d6075a6e761a) [## 一枚硬币的两面:杰瑞米·霍华德的 fast.ai vs 吴恩达的 deeplearning.ai

如何不通过同时参加 fast.ai 和 deeplearning.ai 课程来“过度适应”你的人工智能学习

towardsdatascience.com](/two-sides-of-the-same-coin-fast-ai-vs-deeplearning-ai-b67e9ec32133) [## 我完成了吴恩达的机器学习课程，感觉棒极了！

好的，坏的，美丽的

medium.com](https://medium.com/datadriveninvestor/thoughts-on-andrew-ngs-machine-learning-course-7724df76320f)

构建一个机器学习推荐器

原文：https://towardsdatascience.com/build-a-machine-learning-recommender-72be2a8f96ed?source=collection_archive---------8-----------------------

Background vector created by starline — www.freepik.com

用几行 Python 代码构建机器学习推荐器的快速入门指南

在这篇文章中，我将展示如何使用机器学习快速组装推荐器。我将使用 LightFM 推荐库训练一个预测模型，该库可以很好地扩展到 2000 万到 4000 万次交互的中小型数据集，并训练一个关于用户特征和项目特征的模型。然后，我将进一步介绍推荐系统的典型实现，并汇总单个用户的预测，为一个群体提供推荐。

关键定义

在深入研究代码之前，先快速回顾一下用来描述推荐系统机制的一些关键定义。

条目–这是评级或分数的内容(例如，一本书、一部电影等。)

标签 —这些是推荐器的可能的输出。(例如评级或分数)。我们会用带标签的项目来训练推荐器，也就是已经被用户评分过的项目。

交互–这是一个输入和相关输出值的列表，我们希望根据这些值来训练我们的推荐器。(例如，用户和项目参考以及相关评级。)

用户特征–这些值代表每个用户的不同特征、行为和属性(如年龄、位置、性别)。

物品特征–这些值代表物品的不同特征(如产品类别、颜色、尺寸)

我将使用的数据

我将使用 Goodbooks-10k 数据集来演示推荐器，可以从这里下载:http://www2.informatik.uni-freiburg.de/" " ~齐格勒/BX/BX-CSV-Dump.zip

Goodbooks-10K 数据集由三个文件组成:

BX-用户–用户特征，具体为 user_id、年龄和位置。

BX-图书—条目特征包括ISBN、Book_Author 等一堆特征。

BX-图书评级–用户给出的图书评级交互，特别是 user_id、ISBN 和评级。

导入库

首先，我们需要从 LightFM 库中导入一些库和一些库。

import numpy as np
from lightfm.data import Dataset
from lightfm import LightFM
from lightfm.evaluation import precision_at_k
from lightfm.evaluation import auc_score
from lightfm.cross_validation import random_train_test_split
from scipy.sparse import coo_matrix as sp

导入数据

我们将导入 GoodBooks-10K 数据，然后创建以下三个函数，以便在需要时获得数据的新副本。

#fetch the interactions data
def get_ratings():
return get_data()[0]#fetch the item features
def get_book_features():
return get_data()[1]#fetch the user features
def get_user_features():
return get_data()[2]

准备数据

为了使用 LightFM 训练模型，我们将提供以下内容:

[1] 交互作为一个 sparse . COO _ matrix–我们的交互将是 BX-图书-评级. csv 中提供的用户 ID 和 ISBN

[2] user_features 作为包含用户特征的可迭代字符串——我们将简单地包括 BX 用户. csv 中提供的年龄

[3] item_features 作为包含项目特性的可迭代字符串——我们将简单地包括 BX-Books.csv 中提供的图书作者

LightFM 有一个数据集构造器，它有许多方便的方法来准备好数据输入到模型中。由于我们希望在模型中包含用户和项目特征，因此准备数据将是一个两步过程。

步骤 1:创建特性映射

首先，我们在数据集对象上使用 fit()方法来创建 BX-图书-评级. csv 中的映射

dataset = Dataset()dataset.fit((x[‘User-ID’] for x in get_ratings()), (x[‘ISBN’] for x in get_ratings()))num_users, num_items = dataset.interactions_shape()
print(‘Num users: {}, num_items {}.’.format(num_users, num_items))

我们使用 dataset.fit_partial()方法为 user_features 和 model_features 创建特性映射。

dataset.fit_partial(users=(x[‘User-ID’] for x in get_user_features()), items=(x[‘ISBN’] for x in get_book_features()), item_features=(x[‘Book-Author’] for x in get_book_features()), user_features=(x[‘Age’] for x in get_user_features()))

第二步:建立交互、用户特征和物品特征矩阵

其次，可以在 dataset 对象上调用 build_interactions()方法来构建交互矩阵。

(interactions, weights) = dataset.build_interactions(((x[‘User-ID’], x[‘ISBN’]) for x in get_ratings()))

我们在数据集对象上调用 build_item_features()和 build_user_features()方法来构建 item_features 和 user_features。这些函数根据 LightFM 的要求返回 sparse.coo_matrix 类型的对象。

item_features = dataset.build_item_features(((x[‘ISBN’], [x[‘Book-Author’]]) for x in get_book_features()))user_features = dataset.build_user_features(((x[‘User-ID’], [x[‘Age’]]) for x in get_user_features()))

指定型号

为了训练推荐器，我们将使用 LightFM 库中提供的加权近似等级成对(WARP)损失函数。WARP 处理(用户，正项，负项)三元组。

LightFM 对 WARP 算法提供了以下解释:

[1]对于给定的(用户，正项目对)，从所有剩余项目中随机抽取一个负项目。计算两项的预测值；如果负项的预测值超过了正项的预测值加上一个差值，则执行梯度更新，将正项的等级提高，将负项的等级降低。如果没有等级违规，则继续对负项目进行采样，直到发现违规为止。

[2]如果您在第一次尝试时发现了一个违反负面示例，请进行大梯度更新:这表明在给定模型的当前状态下，许多负面项目的排名高于正面项目，并且模型必须进行大量更新。如果需要大量的采样来找到一个违规的例子，执行一个小的更新:模型可能接近最优，应该以较低的速率更新。

下面是我们如何用翘曲损失函数指定模型:

 model = LightFM(loss=’warp’)

该模型可以用许多超参数来指定，但是我将在这里跳过这些。值得一提的是，LightFM 还允许贝叶斯个性化排名损失，尽管这通常表现不太好。

训练模型

此时，您可能希望拆分训练数据，以评估模型训练的性能。LightFM 有一个方法，random_train_test_split()为我们做了这件事。我们可以打电话。fit()将模型拟合到交互、项目和用户特征集。

(train, test) = random_train_test_split(interactions=interactions, test_percentage=0.2)model.fit(train, item_features=item_features, user_features=user_features, epochs=2)

我不打算在这里详细介绍模型训练和评估，尽管下面的代码块显示了如何使用我们使用上面的 random_train_test_split()方法创建的训练集和测试集来测量模型训练精度和以 k 间隔报告的 AUC 分数。

train_precision = precision_at_k(model, train,item_features=item_features, k=10).mean()test_precision = precision_at_k(model, test, item_features=item_features,k=10).mean()train_auc = auc_score(model, train,item_features=item_features).mean()test_auc = auc_score(model, test,item_features=item_features).mean()print(‘Precision: train %.2f, test %.2f.’ % (train_precision, test_precision))print(‘AUC: train %.2f, test %.2f.’ % (train_auc, test_auc))print(“testing testing testing”)print(‘printing labels’, get_ratings()[‘ISBN’])

使用模型为一个组进行预测

为了对小组进行预测，我们需要汇总单个用户的评分，以确定某个项目(书)对小组中所有用户的相对重要性。这里我们可以使用多种聚合策略，比如最小痛苦和混合方法。为了简单起见，我将简单地计算该组中所有用户的每个项目(书籍)的预测得分的平均值。

首先，我们创建一个函数来遍历给定组中的所有用户，并使用 item_features 和 user_features 调用 model.predict()来预测每个项目的得分。该函数将每个用户的分数堆叠到我们称为 all_scores 的数组中，以便我们执行一些聚合。

def sample_recommendation(model, data, user_ids):n_users, n_items = data.shapeall_scores = np.empty(shape=(0,n_items))for user_id in user_ids:scores =. model.predict(user_id,np.arange(n_items),item_features,user_features)all_scores = np.vstack((all_scores, scores))

现在让我们通过对每一项取平均来合计分数。然后，让我们对分数进行排序，并按照我们的模型对标签进行评分的相反顺序获取所有标签(ISBN)。

item_averages = np.mean(all_scores.astype(np.float), axis=0)labels = np.array([x[‘ISBN’] for x in get_ratings()])

top_items_for_group = labels[np.argsort(-item_averages)]

现在，我们可以打印本组的前 5 项。

print(“ Top Recommended ISBN for Group:”)for x in top_items_for_group[:5]:print(“ %s” % x)

取样组建议

最后，我们可以为一个组抽样推荐。值得一提的是，虽然 LightFM 的伸缩性很好，但采样建议不一定需要同步，就像我在这里演示的那样。相反，可以异步计算推荐值，并定期为所有组重新计算推荐值。

group = [3,26,451,23,24,25]sample_recommendation(model, interactions, group)

这就是如何构建一个机器学习推荐器，用不多的 Python 代码就能做出基于组的推荐。

有关完整的代码，请参见:https://github . com/jamesdhope/recommender/blob/master/recommender . py

如果你喜欢这个，请给我一些掌声。

参考

[1] LightFM，https://github.com/lyst/lightfm

[2] LightFM，【https://lyst.github.io/lightfm/docs/examples/dataset.html】T4

[3]Bluedatalab.com，客户项目

用 Keras 和 OpenCV 构建多位数检测器

原文：https://towardsdatascience.com/build-a-multi-digit-detector-with-keras-and-opencv-b97e3cd3b37?source=collection_archive---------2-----------------------

用数据做很酷的事情！

介绍

数字在我们身边无处不在。无论是闹钟、健身追踪器还是条形码，甚至是亚马逊精心包装的快递包裹，数字无处不在。通过 MNIST 数据集，机器学习被用来读取单个手写数字。现在我们可以扩展到读取多个数字，如下所示。底层神经网络既进行手指定位又进行手指检测。这在各种 ML 应用中非常有用，比如读取商店中的标签、车牌、广告等。

Reading multiple digits

但是为什么不仅仅使用 OCR 呢？是的，OCR 可以是自动检测数字的一个很好的起点，但 OCR 并不总是有效，有时我们需要为我们的特定任务训练一个神经网络。

数字检测流水线

数字检测问题可以分为两个部分

1. 数字本地化
2. 数字识别

数字本地化:

图像可以在任何位置包含数字，对于要检测的数字，我们需要首先找到包含这些数字的区域。数字可以有不同的大小和背景。

有多种方法可以检测手指的位置。我们可以利用简单的图像形态学操作，如二值化、腐蚀、膨胀来提取图像中的数字区域。然而，由于阈值、内核大小等调整参数的存在，这些可能变得对图像过于具体。我们还可以使用复杂的无监督特征检测器、深度模型等。

数字识别:

定位的手指区域用作手指识别过程的输入。 MNIST 数据集是手写数字识别的规范数据集。大多数数据科学家都用这个数据集做过实验。它包含大约 60，000 个用于训练的手写数字和 10，000 个用于测试的数字。一些例子看起来像:

MNIST Images

然而，现实生活场景中的数字通常非常不同。它们有不同的颜色，通常像下面的箱子一样印刷。

Day to day digit images

稍加研究，我们就可以看到另一个公共数据集SVHN——街景门牌号数据集 。该数据集由从谷歌街景中收集的门牌号图像组成，并附有注释。下面是来自 SVHN 的示例图像:

SVHN Images

该数据集具有针对许多背景的各种数字组合，并且将更好地用于通用模型。

在 Keras 中建模

我们选择这个 repo 来实现多位数检测器。它写得很好，容易理解。

使用作为稳定特征检测器的最大稳定极值区域(MSER) 方法进行手指定位。MSER 主要用于图像中的斑点检测。斑点是像素的连续集合，其外部边界像素强度比内部边界像素强度高(给定阈值)。如果这些区域在变化的强度范围内没有太大的变化，那么这些区域被认为是最稳定的。MSER 的运行时复杂度较低，为 O(nlog(log(n)))，其中 n 是图像上的像素总数。该算法对模糊和缩放也是鲁棒的。这使得它成为提取文本/数字的良好候选。想了解更多关于 MSER 的信息，请点击链接。

使用具有卷积、最大池和 FC 层的 CNN 来完成数字识别，这些层将每个检测到的区域分类成 10 个不同的数字。该分类器在测试集上达到 95%的准确率。

我们在各种例子上测试了回购，发现它运行得相当好。见上面分享的例子。

有一些差距，要么是定位器没有完美地工作(没有检测到数字 1 的位置)，要么是检测器失败了(检测为 5)。

结论

我们希望这篇博客能成为理解多位数检测管道如何工作的良好起点。我们分享了一个很好的 github 链接，可以用来在 SVHN 数据集上建立模型。如果这种模式效果不好。你可以收集自己的数据，对训练好的模型进行微调。

我有自己的深度学习咨询公司，喜欢研究有趣的问题。我已经帮助许多初创公司部署了基于人工智能的创新解决方案。请到 http://deeplearninganalytics.org/来看看我们。如果你有一个我们可以合作的项目，那么请通过我的网站或在info@deeplearninganalytics.org联系我

你也可以在https://medium.com/@priya.dwivedi看到我的其他作品

参考文献:

• SVHN 数据集
• 了解 MSER
• 多位检测器代码

构建一个收集中顶级作者数据的渠道

原文：https://towardsdatascience.com/build-a-pipeline-for-harvesting-medium-top-author-data-c4d7ed73729f?source=collection_archive---------9-----------------------

如何使用 Luigi 和 Docker 为 Medium 构建简单的数据工程管道

介绍

当我为数据工程管道编写的一些 Python 脚本失去控制时，这个项目的想法开始了:

• 管道需要数千个 API 调用 REST 服务，每个调用下载一个 JSON 文件。
• 管道的某些部分需要很长时间来运行，并且该过程有时会失败。

我的过程是这样的:

这些累积的 API 调用累积起来:

• 获取父对象( 1 请求
• 对于每个父节点获取子节点( 150 个请求
• 为每个孩子获取信息( 5000 个请求)
• 对于每个 info fetch 配置项( 14，000 个请求……这已经很多了！)

这是我使用的 API 的一个怪癖；没有办法进行批量请求。有许多问题:

• 这个序列运行了几个小时
• 如果出现故障，很难确定从哪里重新开始
• 没有办法检查进度；如果脚本已经运行了一个小时，它们是不是就要完成了？

咨询谷歌，我发现我的设计与这个不做事的例子非常相似:

这东西已经长成了一个怪物。

路易吉来救援了

我四处寻找一个轻量级的数据工程框架，它可以支持:

A famous plumber

• 工作流程编排
• 并行处理
• 简单部署
• 快速学习曲线

考虑到这些要求， Spotify Luigi 看起来刚刚好:

Luigi 是一个 Python 模块，帮助您构建批处理作业的复杂管道。它处理依赖性解析、工作流管理、可视化等。

Spotify 使用 Luigi 进行推荐音乐的数据工程批处理工作，例如 Discover Weekly 播放列表(尽管最近流行迪斯科，但我对 Discover Weekly 的选择还是很满意)。

My face when I saw Luigi do all the things

与 Luigi 一起工作令人惊讶地满足，我想知道如何在我的日常工作之外再次使用它。我想到在管道中重用这种方法来收集关于顶级媒体作者的数据，下面的文本描述了一个可以在其他领域重用的数据工程管道的简单框架。

这是面向数据工程和数据科学的，尽管 Luigi 的模块化架构应该可以直接添加分析组件。换句话说，这是一个用于提取数据的系统设计，而不是一种用于分析和从数据中获得洞察力的方法(可能是未来故事的主题)。

Luigi gets to work on the pipes

从媒体中获取有趣的顶级作者数据

我们的管道将收集出版物中顶级作者的数据:

1. 这位顶级故事作者关注的作者列表
2. 他们写的故事总数
3. 每个故事获得了多少掌声
4. 他们故事的平均标题长度
5. 他们故事的平均字数
6. 他们为之写作的出版物

关于 Medium API 的一个简短说明。API 本身相当有限。然而，您可以将?format=json附加到许多标准的中型 URL，这将返回通常显示在页面上的数据的 JSON 表示，以及一些额外的元数据。例如，《走向数据科学》的首页用?format=json参数渲染成这样:

{"success":true,"payload":{"collection":{"id":"7f60cf5620c9","name":"Towards Data Science","slug":"towards-data-science","tags":["DATA SCIENCE","MACHINE LEARNING","ARTIFICIAL INTELLIGENCE","BIG DATA","ANALYTICS"],"creatorId":"895063a310f4","description":"Sharing concepts, ideas, and codes.","shortDescription":"Sharing concepts, ideas, and codes.","image":{"imageId":"1*F0LADxTtsKOgmPa-_7iUEQ.jpeg","filter":"","backgroundSize":"","originalWidth":1275,"originalHeight":1275,"strategy":"resample","height":0,"width":0},"metadata":{"followerCount":171879,"...etc

感谢 Radu Raicea 的精彩文章我如何使用 Python 找到有趣的人来关注 Medium 为我指出了这个特性。

JSON 结果需要一点清理:

Remove invalid characters from the response

具体细节

一个关键需求是使我的 Luigi 工作流的部署非常简单。关于部署环境，我只想假设一件事；Docker 守护进程是可用的。有了 Docker，我就不需要担心 Python 版本不匹配或其他环境差异。

不过，我花了一点时间才弄明白如何在 Docker 中运行 Luigi。

第一步是在它自己的容器中启动中央调度程序。你可以用一张现有的图片来做这件事，比如这张。

您可以向调度程序提交作业，如下所示:

PYTHONPATH='.' luigi --module top_artists Top10Artists  --date-interval 2012-07

这是用 Luigi docs 里的一个例子。

所以对于部署，这是我采取的方法；一个 docker 编写文件，包括:

• Luigi 中央调度程序
• Luigi 任务的独立的基于 Python 的容器
• 公开报告的 nginx 容器

tasks 容器的入口点休眠一段时间，然后启动 Luigi 管道，这个sleep代替了 cron 作业。

使用 Luigi 进行并行处理

我的脚本非常慢，我需要一种方法来并行运行多个 URL 获取过程，这导致了这样的设计:

• 一个WrapperTask包装了管道的所有组件
• 第一次 URL 获取获得需要单独查询的许多项目的列表(这是一个单独的请求)
• 这些块在工人之间划分，他们的工作结果被放入一个以每个工人 id 命名的文件中(例如1.json)
• 从这一点来看，这些文件被下游工人使用

该方法改编自这篇文章。

数据收集任务

对于中型数据采集管道，WrapperTask如下所示:

Pipeline wrapper

requires()方法完成了这里的大部分工作，建立了一个在PipelineTask被认为完成之前需要完成的任务列表。

流水线中的第一个任务是FetchUserList。这将从媒体出版物的首页获取媒体作者的列表。作者列表放在一个文件中，供下游任务使用。

Fetch a list of authors from a publication

在《走向数据科学》出版物上运行它，会给我们一个页面上提到的作者列表:

A list of publication authors

您可能会注意到，此结果中返回的作者列表与页面上显示的不匹配；那是怎么回事？原来，页面在加载时会向 Medium API 提交一系列请求，每个返回的 JSON 结果都包含一个指向该系列中下一组结果的指针。我们需要在获取数据时处理这种分页行为:

Handle Medium API paging

这个实现很大程度上借用了 Radu Raicea 的文章。

注意，在一个给定的管道中，只有一个FetchUserList任务将被执行，因为我们没有包含一个file_number参数。

下一个任务是FetchUserFollowings。这个任务将由许多工作器并发执行，并行化由workers配置参数控制。当任务开始执行时，它决定负责处理 JSON 文件的哪个部分。确定截面的逻辑由get_part_of_list()控制:

Split the whole list, so we can delegate a chunk to each worker

ExtractUserMetrics任务从帖子数据中挑选出一些有趣的数据点，例如每篇文章的总鼓掌次数:

Extract metrics

然后，我们可以从提取的故事数据中得出几个平均值:

Calculate averages

最后，这一行启动了这个过程:

luigi.build([PipelineTask()], workers=worker_count)

公开结果

您可能希望向最终用户公开这些报告，例如向您团队中的数据科学家公开。一个简单的方法是添加一个 nginx web 服务器，并列出输出目录的内容。这将允许任何人点击一个 URL 并下载报告，每天都有一个报告目录。

尝试一下

好吧，让我们踢轮胎这件事…

首先，通过在 luigi.conf 文件中指定一个collection_id来指定 URL 抓取的起点。

配置完成后，有几种方法可以运行代码:

1. 开发时，可以直接运行__main__.py。如果你想这样做，你需要先启动 Luigi。
2. 您还可以使用 docker-compose 运行整个应用程序堆栈:

docker-compose up -d

这将启动 Luigi、nginx 和任务容器，这将触发__main__.py。

检查总结报告，我们可以获得一些关于目前为《走向数据科学》撰写文章的一些顶级作者的信息。例如，我们可以获得当前顶级作者之一 Will Koehrsen 的一些汇总统计数据:

Some example metrics

干得好，威尔！

单元测试

我选择了 pytest 作为测试框架。我喜欢 pytest 有两个主要原因:

• 它需要更少的样板代码
• 您可以使用常规的 assert 语句，而不需要记住特殊的语法

为了使用与生产版本不同的配置进行测试，您可以在测试中使用luigi.configuration.add_config_path()。这将从特定位置加载配置:

Find and load test configuration

我使用了MockTarget类，这样我可以以可重复的方式运行测试。我不希望一个测试依赖于前一个测试创建的数据，或者测试在完成运行后留下结果文件。MockTarget模拟一个 Luigi 目标，它将结果存储在内存中，而不是将它们写到文件系统中。

最后，为了允许在不要求端点可用的情况下测试 URL 请求，我使用了[requests_mock](https://pypi.org/project/requests-mock/)库。

Github 上提供了该示例管道的完整源代码:

[## 吕克拉塞尔/多克尔-路易吉

从 Medium 获取顶级作者数据的数据工程管道— lucrussell/docker-luigi

github.com](https://github.com/lucrussell/docker-luigi)

结论

这个项目是一个 Luigi 管道，用于从 Medium 收集顶级作者数据。该项目一开始只是一个简单的框架，用于编排一个有问题的数据工程过程。管道通过抓取出版物首页的 URL 来提取关于作者及其故事的信息，然后收集关于顶级作者的一些基本指标。它使用 Luigi 来协调 Python 逻辑，使用 Docker 来简化部署。

快速建立投资组合网站

原文：https://towardsdatascience.com/build-a-portfolio-website-in-a-flash-9d5ec30a73a7?source=collection_archive---------16-----------------------

使用 GitHub 页面和 Google 域名创建静态网站的 12 个步骤

如果你是一名开发人员、数据科学家或设计师，你可能会被建议建立一个作品集网站。你的作品集向其他人展示了你能做什么，以及为什么他们应该与你合作发展一项事业、一个副业或一项新的事业。

但是导航选项来创建一个安全、便宜、响应迅速的网站是一个障碍，它经常阻止人们将他们的网站投入使用。我已经做了研究，建立了一个网站，将与您分享如何快速制作作品集网站。好消息是只需要 12 个步骤。😁

这是我网站的截图:

https://jeffhale.net/

我不是说我的设计很壮观。😀我的重点是帮助你通过这个过程，让你可以在瞬间建立一个网站。然后，您可以对其进行样式化，并包含您喜欢的任何内容。

我们开始吧！🚀

12 步

1. 制作 GitHub repo
2. 克隆回购
3. 做一个 gh-pages 分公司
4. 创造 index.html
5. 添加引导启动代码
6. 添加内容
7. 本地查看网站
8. 推送至 GitHub
9. 在网上查看
10. 从谷歌域名购买自定义网址(可选)
11. 将您的自定义域指向 GitHub 页面(可选)
12. 启用 SSL(如果使用自定义 URL)

迭代！🔃

制作 GitHub Repo

如果您没有 GitHub 帐户，请参阅我的 GitHub 工作流文章了解如何获得一个。给你的回购命名。创造。gitignore、README.md 和许可证文件。

克隆回购

在本地机器上克隆您的 repo。如果您的本地机器上没有 git，请参考上面的文章获取它。

切换到您的本地存储库。创建一个名为 gh-pages 的新分支。

默认情况下，GitHub Pages 会根据名为 gh-pages 的分支中的内容自动更新您的站点。默认情况下，GitHub Pages 不会从您的主分支自动更新。

创造 index.html

移动到您的项目目录。用touch index.html做一个名为index.html的文件。如果你想学习 shell 常用命令，比如touch，请点击这里查看我的文章。

在代码编辑器中打开您的index.html文件。

添加引导启动代码

我们将使用超级流行的 Bootstrap 框架，以最小的努力提供响应性 CSS 功能。

从 Bootstrap 复制并粘贴 starter 模板代码。如果你不需要 JavaScript 功能，那就去掉这一部分来加速你的站点。我在下面的代码片段中省略了 JavaScript 代码。

Bootstrap starter code without JavaScript

引导文档非常好。如果你以前没有用过 Bootstrap，我建议你花几分钟时间使用 Bootstrap grid docs ，这样你就知道如何修改页面布局了。如果您需要提神剂(或清新剂😃)在 HTML 和 CSS 方面，建议你去看看 w3schools.com 的。

添加内容

将标题标签和正文标签的内容更改为 Your_name 的作品集— 或您喜欢的任何内容。

添加您的 HTML。我使用了三栏布局，在移动设备上切换到一栏。

如果你想制作其他的 CSS 样式，创建 addedstyles.css 并在你的 index.htmlhead标签中包含<link rel=”stylesheet” href=”addedstyles.css”>。

我的代码可在本回购获得。再说一次，我不是说我的设计很棒。我的重点是帮助你快速建立一个网站。

本地查看网站

您的网站可以在本地查看，而无需提供任何服务，因为这是一个静态网站。只要双击你电脑上的index.html文件，然后砰！你应该会在浏览器中看到你的投资组合。

推送至 GitHub

在 Git 中添加文件并提交您的工作。然后用git push origin HEAD:gh-pages推送到你的 gh-pages 分支。

GitHub Repo

在网上查看

导航到http://your _ git hug _ username . github . io/your _ repo _ name。例如，我的站点在 http://discdiver.github.io/show/(现在它被转发到一个自定义域名)。您应该会看到与您在本地看到的相同的网页。

如果你想要一个每年 12 美元(税前，在美国是美元)的个性化网址，你可以这么做。

从谷歌域名购买自定义网址(可选)

如果你想要一个自定义域名，而不是 GitHub 页面的网址，我建议你从谷歌域名购买一个域名。多年来，我尝试了很多域名注册商，发现谷歌域名是目前最好的。

用你的谷歌账户登录，开始搜索域名。

Probably not what you want for your portfolio URL. 🚗

完成您的交易。您将在一分钟后回来管理 DNS 设置。

将您的自定义 URL 指向 GitHub 页面(可选)

GitHub 最近使得创建一个 CNAME 文件来链接你的自定义域名变得更加容易。👍

转到您的存储库的设置选项卡。向下滚动到 GitHub 页面，在自定义域名字段输入你的域名，按保存。GitHub 现在会自动为你的回购协议中的 DNS 创建一个 CNAME 记录。

Adding a custom url. Note that the Enforce HTTPS checkbox will be unchecked after you save.

现在我们需要修改连接的 Google Domains 端的内容。

在您的 Google Domains 帐户中，选择 DNS 选项卡并向下滚动到自定义资源记录。留着@。在 IPv4 地址字段中键入以下内容:185.199.108.153。

After updating Google Domains DNS tab.

然后添加一个 CNAME 记录，这样就可以解析你的 url 的版本。将 www 放入第一个字段，从下一个下拉字段中选择 CNAME ，并将 @ 放入 IPv4 地址字段。

应该可以了！拿一杯水🚰当您的更改传播时。然后导航到 http://your_custom_url 。你应该看看你的网站。酷！

启用 SSL(如果使用自定义 URL)

启用 SSL 是个好主意，这样你的站点会更安全，你的 https 前缀也会起作用。启用 SSL 只需在您的 repo 的设置选项卡中点击一下。我不知道为什么添加自定义域时设置会关闭。

在 GitHub 页面部分，点击强制 HTTPS 的复选框。请注意，选中复选框后，您不必保存任何内容。

Check the box for HTTPS

现在当你导航到 https://your_url 时，你应该会看到你的站点，而不是一个错误。你有一个功能正常的投资组合网站。酷毙了。😀

不要忘记更新你的 GitHub master 分支中的自述文件，这样人们就知道在哪里可以找到你的 live 站点。GitHub 上的编辑按钮也可以让你包含一个网站链接。👍

Note the Edit button on the right

是时候让你的网站变得更漂亮了。

重复

有许多关于如何建立你的作品集内容的文章。这是一个有很多好建议的人。

有些人推荐大项目，有些人推荐小项目，有些人推荐混合项目。我不打算参加这场辩论，但我将提出一些一般性建议。

• 添加一些链接和图片。如果你不是设计师，你不需要走极端——只要确保你的作品集看起来干净专业。
• 确保你的作品集在手机和桌面上都很好看。Bootstrap 的响应式设计让这变得相当简单。
• 除非你在自述文件、博客帖子或 Jupyter 笔记本中讨论一个项目，否则我建议你在文件夹中谈一谈。
• 如果你把你的投资组合放在一起，发现它有缺口，开始填补这些缺口。如果你正在做你的第一个项目，不要气馁。每个人都从第一个项目开始了他们的旅程。😁
• 将你的作品集交给几个你信任的人，他们会给出诚实的反馈。
• 当你准备好与全世界分享你的作品集时，用你作品集的 URL 更新你的 LinkedIn 个人资料。
• 如果你怀疑自己有冒名顶替综合症，担心你的作品集永远不会准备好，当你认为已经完成 95%的时候，分享你的作品集。您可能会发现设置上线截止日期很有帮助。
• 记住你的作品集是一项正在进行的工作。更新它，因为你有更多的项目要添加。

随意给你的网站添加更多的复杂性:杰基尔、T2、盖茨比。你可能想用 Sass 来管理风格。

我网站的代码可以在 GitHub repo 中找到。随意叉它去镇上。🍴

包装

在这篇文章中，你看到了如何用 12 个步骤建立你的投资组合网站。我希望这个指南对你有用。如果你有，请在你最喜欢的社交媒体上分享，这样其他人也可以找到它。😀

你可以用同样的方法建立任何静态网站，而不仅仅是作品集网站。

我撰写关于数据科学、Python、云计算和其他技术主题的文章。如果你对其中的任何一个感兴趣，请查看它们并在这里跟随我。

为了确保你不会错过精彩的内容，请加入我的邮件列表。👍

如果你用这个指南做一个项目或作品集——我很想看看你会做些什么——在 Twitter @discdiver 上给我加标签。

快乐组合！😁

用 GitHub API 构建一个 Python 爬虫来获取活动流

原文：https://towardsdatascience.com/build-a-python-crawler-to-get-activity-stream-with-github-api-d1e9f5831d88?source=collection_archive---------21-----------------------

从头做起

在我之前的文章用一个简单的 Python 爬虫下载课程资料中，我介绍了一个简单的 Python 爬虫来下载文件。要构建这样一个爬虫，我们必须自己找到文件的模式。但是如果我们想从著名的网站收集数据，比如 Twitter 和 GitHub，事情可能会简单一些。因为通常，这些网站都提供了 API，我们可以直接获取我们想要的数据。在这篇文章中，我将构建一个 Python 爬虫来用 GitHub API 获取活动流。

1 个目标

活动流显示用户最近的活动，例如下面显示的是我在 GitHub 中的活动。

activity stream in GitHub

我想得到如下这些活动

ShusenTang starred lyprince/sdtw_pytorch
chizhu starred markus-eberts/spert
Hexagram-King starred BrambleXu/knowledge-graph-learning
Yevgnen starred BrambleXu/knowledge-graph-learning
......

2 用 GitHub API 获取数据

2.1 GitHub API

首先，我们来看看 GitHub API 文档。如果您没有启用 双因素认证 ，您可以运行下面的命令来测试 API。输入密码后，您应该会看到响应。

$ curl -u '<usename>' [https://api.github.com](https://api.github.com)
Enter host password for user '<usename>': <password>{
  "current_user_url": "[https://api.github.com/user](https://api.github.com/user)",
  "current_user_authorizations_html_url": "[https://github.com/settings/connections/applications{/client_id](https://github.com/settings/connections/applications{/client_id)}",
  "authorizations_url": "[https://api.github.com/authorizations](https://api.github.com/authorizations)",
 ......

但是如果您已经启用了 双因素认证 ，我们需要使用 个人访问令牌 来进行认证。按照帮助页面创建个人令牌。至于访问权限/范围，因为我们只想获得活动流，选择通知就足够了。

如果一切顺利，我们现在应该有一个令牌。按照认证指令使用以下命令测试令牌。

$ curl -H "Authorization: token <TOKEN>" [https://api.github.com](https://api.github.com)

{
  "current_user_url": "[https://api.github.com/user](https://api.github.com/user)",
  "current_user_authorizations_html_url": "[https://github.com/settings/connections/applications{/client_id](https://github.com/settings/connections/applications{/client_id)}",
  "authorizations_url": "[https://api.github.com/authorizations](https://api.github.com/authorizations)",
  .......

2.2 获取激活流

在其他认证方式中，我们可以使用下面的命令直接获取用户数据。

$ curl -u <usename>:<TOKEN> [https://api.github.com/user](https://api.github.com/user){
  "login": "xxxx",
  "id": xxxxx,
  "node_id": "xxxx",
  "avatar_url": "[x](https://avatars1.gi)xxx",
  ......

接下来，我们需要浏览 API 文档来找到与活动相关的 API。在右侧的切换列表中，“活动”下有“事件”、“提要”、“通知”。但是我们需要确定哪个适合我们的需求。

浏览文档后，我们可以知道“事件”下的“列出用户收到的的事件是我们需要的。

我们可以用这个 API 命令测试curl命令。

$ curl -u <usename>:<TOKEN> https://api.github.com/users/<usename>/received_events

这会返回很多消息，所以最好将响应保存为 JSON 文件。

$ curl -u <usename>:<TOKEN> https://api.github.com/users/<usename>/received_events > github_stream.json

3 分析 JSON 文件

我们可以查看 JSON 数据来熟悉格式。

似乎有不同种类的事件类型。我们可以编写一个简单的脚本来获取各种事件类型。

import jsonwith open('github_stream.json', 'r') as f:
  data_string = f.read() # read object as string
  data = json.loads(data_string) # convert JSON (str, bytes or bytearray) to a Python object# Get all event types
events = set()
for event in data:
  events.add(event['type'])
print(events)# output
{'IssueCommentEvent', 'ForkEvent', 'PushEvent', 'PullRequestEvent', 'WatchEvent', 'IssuesEvent'}

通过比较我们在 GitHub 主页上看到的活动流，我们可以看到只存在三种事件类型，WatchEvent(星号)、ForkEvent(分叉)、PushEvent(推送)。

所以我们只需要从这三种事件类型中获取活动。下面是剧本。

# github-api-json-parse.pyimport jsonwith open('github_stream.json', 'r') as f:
  data_string = f.read() # read object as string
  data = json.loads(data_string) event_actions = {'WatchEvent': 'starred', 'PushEvent': 'pushed to'}for event in data:
  if event['type'] in event_actions:
    name = event['actor']['display_login']
    action = event_actions[event['type']] 
    repo = event['repo']['name'] 
    print('{name} {action} {repo}'.format(name=name, action=action, repo=repo))if event['type'] == 'ForkEvent':
    name = event['actor']['display_login']
    repo = event['repo']['name']  
    forked_repo = event['payload']['forkee']['full_name'] 
    print('{name} forked {forked_repo} from {repo}'.format(name=name, forked_repo=forked_repo,repo=repo))

运行脚本，我们可以得到下面的输出。

ShusenTang starred lyprince/sdtw_pytorch
chizhu starred markus-eberts/spert
Hexagram-King starred BrambleXu/knowledge-graph-learning
icoxfog417 pushed to arXivTimes/arXivTimes
icoxfog417 pushed to arXivTimes/arXivTimes
Yevgnen starred BrambleXu/knowledge-graph-learning
......

4 实时获取激活流

直到现在，我们都可以通过 API 获取 JSON 数据文件，解析 JSON 文件得到活动流。接下来，我们将消除 JSON 文件，直接获得活动流。

查看我的其他帖子 中等 同 一分类查看 ！
GitHub:荆棘徐 领英: 徐亮 博客:

参考

• 用一个简单的 Python 爬虫下载课程资料
• https://developer.github.com/v3/
• https://developer . github . com/v3/auth/# via-oauth-and-personal-access-tokens
• https://developer . github . com/v3/activity/events/# list-events-a-user-has-received

构建一个 React + Flask 应用程序，用 Python 图形推荐小说

原文：https://towardsdatascience.com/build-a-react-flask-app-that-suggests-novel-novels-with-a-python-graph-9491e714bbdf?source=collection_archive---------12-----------------------

Photo by Kourosh Qaffari on Unsplash

项目总结:

• 建立一个用户和他们阅读的书籍的图表数据库
• 开发一个 Flask 应用程序，根据用户提交的收藏夹向用户提供稀有、有趣的书籍
• 实现一个与 Flask +我们的 Graph 集成的 React 应用程序，向用户展示他们下一本最喜欢的书

有很多学习数据科学技术的好资源:MOOCS、博客、教程和训练营都是学习的途径。就我个人而言，我通过从事我觉得有趣和吸引人的项目学习得最好。没有什么比解决一个有趣的问题更能激励我把自己的理解水平推向新的高度了。我如何确定我可以探索的新途径？一般靠看别人的作品！

这个项目的想法最初是通过阅读维基·博伊基斯在伟大的博客上发表的关于网飞推荐引擎性质变化的帖子而实现的。简而言之(抱歉，维基)，通过矩阵分解或深度学习来最小化用户评级偏好的 RMSE 的日子已经一去不复返了。推荐在一定程度上仍然是一种艺术形式，上下文、细微差别和设计都在为用户提供良好体验方面发挥着重要作用。此外，推荐的商业价值不仅仅是为用户提供最好的内容。在网飞的情况下，可能是为了给用户提供最好的网飞内容。

我很高兴参加今年在哥本哈根举行的 RecSys 2019 大会。最佳论文的获胜者是而不是最先进的神经网络方法。相反，它是对以前的开源推荐系统、公共数据集以及它们在面对面比赛中的实际表现的仔细检查。结果，你可能会问？简单模型(基于图形、用户/项目最近邻居、热门项目)几乎总是优于最佳深度神经网络。

可以肯定地说，鉴于这些启示，我一直在重新思考推荐系统。作为一个用户，我想从 YouTube 的推荐引擎中得到什么？像 Ecosia /DuckDuckGo 这样的搜索引擎呢？在前一个例子中，我可能想看在那个时刻娱乐/通知我的视频。在后一个例子中，我希望快速找到最相关的信息，而不用担心利益冲突。在这两种情况下，返回的项目可能不是最受欢迎的，最高评级的，或有争议的。广告商有时发现病毒式传播是有利可图的，但我可能不是一个粉丝。

那么我真正想要的是什么？我怎样才能建立一个系统来优化这个难以实现的、无利可图的目标呢？有一天，当我步行去图书馆时，我的脑海中出现了一个具有里程碑意义的清晰时刻:当我找到一个我从未考虑过或听说过的新作者或新书时，我绝对喜欢。当我翻阅书页时，那个时刻的纯粹发现和新奇感可以激发几个星期的快乐。

花在阅读一本书上的时间是一种投资，因此尝试任何新事物(探索与利用)可能是一个困难的命题。一个仅仅推荐随机项目的系统可能会提供意想不到的结果，但它们可能不是好的结果。我想鱼和熊掌兼得。我想找到我以前从未考虑过的好书。

这个想法很简单:

• 和我阅读和喜欢相同书籍的人可能和我有大致相似的品味
• 这些邻居可能读过很多书，其中一些我没有读过
• 这些未读的书中，有些可能是如此晦涩/冷门，以至于我不太可能自己去发现它们

以上陈述都不会让你感到惊讶，尤其是前两点。当然，最后一点对这项工作来说是最基本的。如果我建立一个图书、作者和读者的图形数据库，然后沿着图形的节点寻找这些隐藏的图书瑰宝，会怎么样？

GoodReads 网站已经发布了一个包含 10，000 本书、50，000+用户和近 600 万个书籍评级(1-5 星)的数据集。我肯定能在这个宝藏中找到一些有趣的东西！我从来没有建立过真正的图形，所以我认为这将是一个伟大的尝试。节点和边，能有多难？这个图的节点是Users、Books和Authors:

边缘是与每个(User, Book, Author, rating)元组相关联的评级:

我首先创建了 4 个类来解释我的图形组件。每个节点还会有一个与之关联的列表:Users会有一个Books的书架，Authors会有他们的参考书目，Books会有他们的受众。Graph将把所有这些对象连接成一个可以被遍历的内聚单元。

上面的代码块很大，里面有很多方法，这里就不探讨了。我们将关注一个可以直接与一个简单的、面向消费者的 React 应用程序 API 一起使用的 API: _book2book。所以让我们说，我们现在可以绕着我们的图走，一切都编译好了。我们如何才能找到有意义的Books呈现给User？在我们看来，让我们假设一下:

1. 作为一个User，你喜欢一个Author的Book(例如，五星评级)
2. 这个Author粉丝很多，她也写过类似的Books你可能也会喜欢。这些不是小说，你可能已经知道了。
3. 这个Author有很多粉丝，有些可能和你差不多
4. 这些Users中的一个被随机选中，将会有一个收藏Books的架子
5. 从这个货架上选择最不受欢迎的五星级Book
6. 要么将此提交给User，要么返回步骤 1，继续浏览图表

Simplistic example of our graph

现在我们只需要将这个Book返回给我们的User作为一个可能的伟大发现！不过，我们遗漏了这个项目的关键要素。我们需要应用程序来提供这些有趣的Book。为了熟悉起见，让我们从仍然基于 Python 的部分开始:我们需要构建处理 API 请求的应用程序后端，因此，当然，我们将使用 Flask 。Flask 允许我们用 Python 制作一个小型的 web 服务器，而且非常容易使用。我发现两个教程非常有用，它们很好地链接在一起:一个 Flask 教程和一个调用前面提到的 Flask 应用的 React 应用。

所以我们首先创建一个新目录，我们称之为api/。在这个文件夹中，我们将有两个 python 文件。__init__.py将建立我们的烧瓶应用程序的基础，导入必要的变量等。：

然后是一个app.py(或者随便你怎么称呼):

app.py Example

在app.py里面，我们正在做一些重要的事情。首先，我们调用 python 代码来构建我们的图形数据库，以查找新书。它还设置了我们后端的Blueprint，所以当我们对这个服务进行 API 调用时，我们指向了正确的方向。让我们从最基本的层面解开这些东西:

• 我们的应用程序名称被初始化为@main，但是我们也可以在这里有其他的东西
• 我们在我们的@main应用中托管了两个.routes:/input_book和/novel_novel
• 你可以把它们想象成我们 Web 应用程序上的独立页面，它们都处理不同的行为
• GET和POST的 HTTP 方法，它们从我们的后端获取一些东西或者向它发送一些东西(好术语！)

对于/input_book调用，我们正在做的是从网页上的User接收一个原始文本输入，将其打包成一个看起来像{"book": "book_title"}的 JSON，然后更新后端服务器。在这种情况下，我们使用这本书来寻找User可能喜欢的类似的稀有书籍。我们用这个输入调用 Graph，并将一个global python 变量设置为输出图书的图像 URL。

现在你可以想象 WebApp 会对 Flask App 进行第二次 API 调用，说“那个输入的输出是什么？”。这是我们在/novel_novel中的GET调用，它也返回一个 JSON。对你们大多数人来说，这听起来很合理，对我来说也是如此。你可能以前用过 Flask。但是你以前做过React App 吗？

React 是一个脸书赞助的开源 JavaScript 库，旨在使用户界面更容易编码。我仍然花了一些时间来学习一些 JavaScript 基础知识，理解 React 的语法，并试图让一切看起来体面。我使用的两个重要资源是之前提到的 YouTube 和这篇关于数据科学的文章。视频指南利用了第二个 React 库semantic-ui-react，这使得应用程序的构建更加容易，所以我基本上遵循了他们的建议。老实说，你也应该这样。安装必要的工具、构建样板文件App.js以及解释编写函数的基础工作最好留给 JavaScript 专业人员去做。

不过，我将详细介绍一下实际的 React 组件，这些组件是我为了与我们的图表集成在一起而组装的。这里的主要函数是App.js文件，所以我们将首先解包它。我们导入必要的库，初始化App()，然后返回一些类似 HTML/JavaScript 的实体(部门、容器、图像等)。):

App.js

你会注意到在Container里面我们有两个组件:<BookEntry/>和<GrabBook/>。这些对应于我们 Flask 应用程序中的两个 API 调用，这是我们的图形理解的标题POST，然后执行一个GET调用来为用户抓取我们感兴趣的新小说。让我们先来看看更复杂的组件BookEntry:

我们从这个组件{ Form, Input, Button }中的semantic-ui-react导入了一些额外的包。我们希望用户将文本输入到与他们喜欢的书名对应的Form中，然后点击提交Button。首先，我们初始化几个变量(const [title, setTitle])并设置默认值= useState('');，一个空字符串。

接下来，我们构建<Form.Field>，并添加一个placeholder值，为用户提供做什么的指示。一旦用户输入了一些文本，我们将title的useState设置为输入的文本。轻松点。

接下来，我们添加一个形状为Button的新<Form.Field>，用户可以在文本输入的正下方点击它。单击按钮(<Button onClick= ...)，我们通过await fetch("/input_book"调用对我们的 API 进行第一次调用。回想一下，在我们的 Flask 应用程序中，我们的蓝图有@main.route('/input_book'，所以这个调用在这个接触点上到达我们的后端。这个POST调用的返回值只是一个response,表示当且仅当我们在图中找到标题时一切正常。否则我们返回一个400并要求用户提交一个新的标题。有可能我们的数据库没有标题，或者可能拼写不同，等等。，所以我们不希望我们的应用程序在这些情况下崩溃。

在进入下一个组件之前，我鼓励任何试图构建这些 web 应用程序的人在代码中到处使用console.log()调用。它们不仅有注释的双重作用，在调试代码时也很有帮助。回想一下，你只需右键点击 Chrome 中的任何网页，Inspect，然后打开console标签，你就可以看到正在发生的一切。

所以，让我们假设一切进展顺利，我们已经找到了相关的标题。现在我们实际上必须在我们的GrabBook组件中为用户返回一本新书:

这里我们通过一个fetch("/novel_novel")对POST端点进行另一个 API 调用。请记住，我们正在返回一个类似于{"image_url": "http://image_of_book.png"}的 JSON 对象。然后，我们将它传递给一个<Image>块，该块呈现图像并将其返回给我们的应用程序。酷！

The input was Neuromancer by William Gibson. The output is a great book!

公平地说，这个页面看起来不怎么样。如果你是 React 专家，请告诉我如何才能让布局看起来更好:

• 提交请求后，需要刷新页面以显示正确的图像。
• 我也更喜欢背景图片覆盖整个页面，并且表单域在它的前景中。

这项工作并不打算成为一个商业化、生产就绪的系统。这是一次有趣的学习冒险，并且在它的范围内发人深省。如果你有兴趣查看的话，这里有一个回购的链接。

谢谢你的来访！欢迎在下面评论，求书。我个人已经从图表中找出了 10 多条建议，我几乎总是对结果感到惊讶。我很高兴我研究了这些建议，虽然有些不是我喜欢的，但其他的都是很棒的发现。

在 30 分钟内构建一个实时对象检测 Web 应用程序

原文：https://towardsdatascience.com/build-a-realtime-object-detection-web-app-in-30-minutes-7ad0cb2231fb?source=collection_archive---------7-----------------------

Image Credit: https://github.com/tensorflow/models/tree/master/research/object_detection

张量流。射流研究…

Tensorflow.js 是一个开源库，使我们能够使用 Javascript 在浏览器中定义、训练和运行机器学习模型。我将使用 Angular 中的 Tensorflow.js 框架来构建一个 Web 应用程序，该应用程序可以检测网络摄像头视频馈送上的多个对象。

COCO-SSD 型号

首先，我们必须选择我们将用于对象检测的预训练模型。Tensorflow.js 提供了几个预训练模型，用于分类、姿态估计、语音识别和对象检测目的。查看所有 Tensoflow.js 预训练模型了解更多信息。

COCO-SSD 模型是一种预训练的对象检测模型，旨在定位和识别图像中的多个对象，是我们将用于对象检测的模型。

Photo by Brooke Cagle on Unsplash

原 ssd_mobilenet_v2_coco 模型大小为 187.8 MB，可从 TensorFlow 模型动物园下载。与原始模型相比，Tensorflow.js 版本的模型非常轻量级，并针对浏览器执行进行了优化。

Tensorflow.js COCO-SSD 默认的物体检测模型是‘lite _ mobilenet _ v2’体积非常小，1MB 以下，推理速度最快。如果您想要更好的分类准确性，您可以使用‘mobilenet _ v2’，在这种情况下，模型的大小增加到 75 MB，这不适合 web 浏览器体验。

“model . detect”直接从 HTML 中获取图像或视频输入，因此在使用之前，您无需将输入转换为张量。它返回检测到的对象的类、概率分数以及边界框坐标的数组。

model.detect(
 img: tf.Tensor3D | ImageData | HTMLImageElement |
   HTMLCanvasElement | HTMLVideoElement, maxDetectionSize: number
)
[{
 bbox: [x, y, width, height],
 class: "person",
 score: 0.8380282521247864
}, {
 bbox: [x, y, width, height],
 class: "kite",
 score: 0.74644153267145157
}]

Photo by Marc Kleen on Unsplash

ANGULAR WEB 应用正在初始化

在我们清楚了模型之后，是时候使用 Angular 命令行界面来初始化 Angular web 应用程序了。

npm install -g @angular/cli
ng new TFJS-ObjectDetection
cd TFJS-ObjectDetection

然后我将使用 NMP 包管理器加载 Tensorflow.js 和 COCO-SSD 库。

TFJS-ObjectDetection **npm install @tensorflow/tfjs --save** TFJS-ObjectDetection **npm install @tensorflow-models/coco-ssd --save**

现在都准备好了。所以我们可以开始编码了。我先从‘app . component . ts’导入 COCO-SSD 模型开始。

import { Component, OnInit } from '@angular/core';**//import COCO-SSD model as cocoSSD**
import * as cocoSSD from '@tensorflow-models/coco-ssd';

开始网络摄像机馈送

然后，我将使用以下代码启动网络摄像头。

webcam_init()
{
  this.video = <HTMLVideoElement> document.getElementById("vid");
  navigator.mediaDevices
  .getUserMedia({
  audio: false,
  video: {facingMode: "user",}
  })
  .then(stream => {
  this.video.srcObject = stream;
  this.video.onloadedmetadata = () => {
  this.video.play();};
  });
}

物体检测功能

我们需要另一个函数来加载 COCO-SSD 模型，该模型也调用‘detect frame’函数来使用来自网络摄像头馈送的图像进行预测。

public async predictWithCocoModel()
{
  const model = await cocoSSD.load('lite_mobilenet_v2');
  this.detectFrame(this.video,model);

}

‘detect frame’函数使用 requestAnimationFrame 通过确保视频馈送尽可能平滑来反复循环预测。

detectFrame = (video, model) => {
  model.detect(video).then(predictions => {
  this.renderPredictions(predictions);
  requestAnimationFrame(() => {
  this.detectFrame(video, model);});
  });
}

Photo by Mikhail Vasilyev on Unsplash

渲染预测

同时，‘render predictions’函数将检测到的对象的边界框和类名绘制到屏幕上。

renderPredictions = predictions => {const canvas = <HTMLCanvasElement> document.getElementById     ("canvas");

  const ctx = canvas.getContext("2d");  
  canvas.width  = 300;
  canvas.height = 300;
  ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);  

  **// Fonts**
  const font = "16px sans-serif";
  ctx.font = font;
  ctx.textBaseline = "top";
  ctx.drawImage(this.video,0,0,300,300);

  predictions.forEach(prediction => {  

   **// Bounding boxes's coordinates and sizes**
   const x = prediction.bbox[0];
   const y = prediction.bbox[1];
   const width = prediction.bbox[2];
   const height = prediction.bbox[3];**// Bounding box style**
   ctx.strokeStyle = "#00FFFF";
   ctx.lineWidth = 2;**// Draw the bounding
**   ctx.strokeRect(x, y, width, height);  

   **// Label background**
   ctx.fillStyle = "#00FFFF";
   const textWidth = ctx.measureText(prediction.class).width;
   const textHeight = parseInt(font, 10); // base 10
   ctx.fillRect(x, y, textWidth + 4, textHeight + 4);
   });

   predictions.forEach(prediction => {
    **// Write prediction class names**
    const x = prediction.bbox[0];
    const y = prediction.bbox[1];  
    ctx.fillStyle = "#000000";
    ctx.fillText(prediction.class, x, y);});   
   };

现在，在浏览器上执行对象检测所需的所有功能都已准备就绪。

我们只需要在【ngOnInit】上调用‘web cam _ init’和‘predictwithcocomoodel’就可以在启动时初始化 app。

ngOnInit()
{
  this.webcam_init();
  this.predictWithCocoModel();
}

Photo by Andrew Umansky on Unsplash

用于对象检测的 HTML 元素

剩下的最后一步是修改 'app.component.html' ，以包含上述功能工作所需的 < video > 和 < canvas > HTML 元素。

<div style="text-align:center">
  <h1>Tensorflow.js Real Time Object Detection</h1>
  <video hidden id="vid" width="300" height="300"></video>
  <canvas id="canvas"></canvas>
</div>

完整代码

访问我的 GitHub 资源库获取该项目的完整代码。

演示 WEB 应用程序

访问现场演示应用程序，查看运行中的代码。该应用程序在 Google Chrome 浏览器中运行没有任何问题。如果您使用任何其他浏览器，请确保您使用的浏览器支持' requestAnimationFrame' 。

用 Python 和 Google Search 构建一个简单的聊天机器人

原文：https://towardsdatascience.com/build-a-simple-chatbot-with-python-and-google-search-c000aa3f73f0?source=collection_archive---------1-----------------------

Build a Simple Python ChatBot from Scratch Using Google Search

今天我们要构建一个 Python 3 聊天机器人 API 和 web 界面。聊天机器人很难构建，因为有无限多的输入。正因为如此，一个能够不断给出好答案的聊天机器人需要大量的知识。

开发人员通常会将机器学习算法、NLP 和预定义答案的语料库应用到他们的聊天机器人系统设计中。我们将保持我们的代码基本，所以我们将绕过为我们的聊天机器人创建一个复杂的“大脑”。

我们不会建立一个人工智能大脑，而是使用一个免费的和已经建立的大脑:谷歌搜索。

我们的聊天机器人将对用户的查询执行 Google 搜索，从第一个结果中抓取文本，并用该页面文本的第一句话回复用户。

我们开始吧！顺便说一下，所有提到的代码都在 Python ChatBot GitHub 库中。

用 Python 在 Google 中查询聊天机器人回复

为了用 omniscience(无限知识)编写简单的聊天机器人，我们将在 Python API 中进行 Google 搜索。幸运的是，有一个 Google search Python 库，我们可以用 pip 安装它。

在本地安装了 Google 库之后，您可以像这样编写 Python 代码:

一旦我们从搜索结果中获得了一个 URL 列表，我们就可以使用 Python 请求库对该网页进行 GET 请求。我们也可以通过使用来自 lxml 的html和 BeautifulSoup 来解析 HTML。

这个项目的所有 Python 依赖项都可以在 GitHub 存储库的[requirements.txt](https://github.com/lmzach09/Python_ChatBot_Google/blob/master/requirements.txt) 文件中找到。

这是一个完整的文件，我们的 HTTP 服务器可以将它作为一个依赖项导入。我制作了一个方法，它可以进行 Google 搜索，获取网页上的第一个<p>，并以字符串形式返回其内容。如果搜索以任何方式失败，聊天机器人将回复“对不起，我想不出答案。”

现在我们可以接受用户输入并进行谷歌搜索。我们将对搜索的第一个结果发出一个 HTTP GET 请求。然后我们解析返回的 HTML，分离出该页面上第一个<p>中的第一句话。这是我们聊天机器人的回复算法，不需要机器学习。

一个简单聊天机器人的 Python API

接下来，我们需要建立一个服务器应用程序，这将是我们的聊天机器人查询的 API。它将响应 HTTP 请求。首先，这些请求将来自一个简单的 HTML 页面，我们稍后会制作这个页面。

首先，我们将导入 Python 3 HTTP 服务器和 socket 服务器库，以及我们之前创建的 Google 搜索文件。

我们的 API 将在端口 8080 上提供服务，我们将从项目的父目录中名为public的文件夹中提供网页资产。接下来，我们将为 GET 和 POST 请求创建自己的处理程序。

HTTP GET 请求将尝试从public文件夹中返回相应的文件。这些将是我们 web 浏览器界面的 HTML、CSS 和 JavaScript 文件。帖子请求将用于聊天机器人查询。

最后，我们将启动服务器并使用我们的处理程序。这是整个文件，包括上面的代码片段。

我们可以使用 CURL 来测试带有 POST 请求的聊天机器人 API。

curl -d "how old is samuel l jackson" [http://localhost:8080](http://localhost:8080)

Screenshot of POST request output of the ChatBot API

接下来我们将制作一个可以查询这个 API 的 HTML 页面。最终，我们将拥有一个端到端的聊天机器人，提供复杂的答案。

构建聊天机器人网页

我们的网页将非常简单。它将包含一个机器人的图片，一个文本输入字段和一个提交按钮。每当用户提交一个输入，chatbot API 就会通过 POST 请求到达。从 API 返回的文本答案将被填入网页。

这是 HTML 页面。将此作为index.html保存在我们之前提到的public文件夹中。机器人的图像文件也在完整的 Python ChatBot GitHub 库中。

接下来，我们将为这个网页做一些快速的样式。将这个 CSS 文件也保存在public文件夹中。它已经在 HTML 文件的<head>部分被引用。

现在，您应该有一个简单的聊天机器人网页可供用户输入。以下是截图:

ChatBot Web Page Screenshot

网页还没有完全为用户准备好。它需要 JavaScript。

我们将编写一些 JS 来检测用户按下回车键并点击提交按钮。当这些事件中的任何一个发生时，我们将获得用户输入字段中的文本，并将其作为我们的 Python 服务器的 POST 主体。

我们将使用fetch方法向 Python API 服务器发出 HTTP POST 请求。现代网络浏览器现在默认包含了获取 API 。

这是我们与 3 个 HTML 元素交互的简单 JavaScript。将此作为app.js保存在公共文件夹中。

我们几乎准备好将我们的 Python 聊天机器人投入生产了。

运行我们从头开始制作的简单 Python 聊天机器人

现在我们已经写完了所有的代码，在运行全栈 Python 聊天机器人之前，我们还有一个步骤。如果还没有，在项目的父目录中创建一个requirements.txt 文件，与 2 个 Python 文件放在一起。该文件是一个 Python 范例，用于轻松安装项目的依赖项。

使用命令行转到 ChatBot 项目的父目录。运行 Python 库安装命令。

pip install -r requirements.txt

您的机器现在拥有运行聊天机器人所需的所有库！让我们运行全栈应用程序。

python server.py

接下来打开你的网络浏览器，进入 http://localhost:8080/ 。如果你看到聊天机器人的图像，它正在工作。

尝试一些输入！

谁扮演了钢铁侠

塞缪尔·杰克逊多大了

火星上的天气怎么样

你可以看到，我们的聊天机器人回复并不完美，但对于几分钟的工作来说已经很不错了。

我会继续用 Python 探索 AI 和机器学习，我会分享我的发现。查看我的媒体页面的 JavaScript、 Dart 和 Python 指南。

用 TensorFlow.js 构建一个简单的神经网络

原文：https://towardsdatascience.com/build-a-simple-neural-network-with-tensorflow-js-d434a30fcb8?source=collection_archive---------13-----------------------

创建一个神经网络模型来做出笔记本电脑购买决策

TL；DR 在 TensorFlow.js 中建立一个简单的神经网络模型，做出笔记本电脑购买决策。了解为什么神经网络需要激活函数，以及应该如何初始化它们的权重。

现在是午夜，你正微笑着做着一些令人惊恐的梦。突然，你的电话开始响了，相当国际化。你半睡半醒地拿起电话，听一些奇怪的事情。

你的一个朋友从地球的另一边打电话来，请求帮助挑选一台笔记本电脑。毕竟今天是黑色星期五！

这是你五年来第一次收到朋友的来信，这让你有点惊讶。不过，你是个好人，同意帮忙。也许是时候将你的 TensorFlow.js 技能付诸实践了？

不如你做一个模型来帮助你的朋友，这样你就可以继续睡觉了？你听说过神经网络现在非常热门。现在是凌晨 3 点，你不需要太多的劝说。这一次你将使用神经网络！

在你的浏览器中运行本教程的完整源代码:

GitHub 上的完整源代码

神经网络

什么是神经网络？按照经典的扣人心弦的方式，我们将从远离回答这个问题开始。

神经网络已经存在了一段时间(从 20 世纪 50 年代开始)？为什么它们最近才变得流行起来(最近 5-10 年)？由沃伦·麦卡洛克和沃尔特·皮茨于年首次提出的神经活动固有思想的逻辑演算神经网络直到 20 世纪 80 年代中期才真正流行起来，当时支持向量机和其他方法控制了整个社区。

通用逼近定理指出，神经网络可以逼近任何函数(在一些温和的假设下)，即使只有一个隐藏层(稍后将详细介绍)。第一批证明之一是由乔治·西本科于 1989 年为乙状窦激活函数做的。

最近，深度学习领域越来越多的进展使得神经网络再次成为热门话题。为什么？我们稍后会讨论这个问题。首先，我们从基础开始！

感知器

最初的模型是由弗兰克·罗森布拉特在 20 世纪 50 年代提出的，旨在模拟人类大脑如何处理视觉数据和学习识别物体。感知器接受一个或多个二进制输入 x1，x2，…，xn，并产生一个二进制输出:

要计算输出，您必须:

• 具有表示相应输入的重要性的权重 w1、w2、…、wn
• 二进制输出(0 或 1)取决于加权和∑ wj xj 是大于还是小于某个阈值

让我们看一个例子。假设您需要决定是否需要一台新的笔记本电脑。最重要的特征是它的颜色和大小(她是这么说的)。因此，您有两个输入:

1.它是粉红色的吗？

2.它小吗(明白了)？

你可以用二元变量 x_ pink ，x_ small 来表示这些因素，并给每一个赋予权重/重要性 w_ pink ，w_ small 。根据你对每个因素的重视程度，你可以得到不同的模型。

我们可以进一步简化感知器。我们可以将∑ w_j x_j 重写为两个向量 w . x 的点积，接下来，我们将引入感知机的偏差，b = -threshold。使用它，我们可以将模型重写为:

偏差是衡量感知器输出 1(触发)的难易程度。较大的正偏置使输出 1 变得容易，而较大的负偏置使输出 1 变得困难。

让我们使用 TensorFlow.js 构建感知器模型:

有人出价购买笔记本电脑。它不是粉红色的，但它是小 x = [0，1]。你偏向于不买笔记本电脑，因为你破产了。你可以用负偏压来编码。你是一个比较聪明的用户，你更注重尺寸，而不是颜色 w = [0.5，0.9]:

1

是的，你必须买那台笔记本电脑！

乙状结肠神经元

为了使从数据中学习成为可能，我们希望在给出一个例子时，模型的权重只发生少量的变化。也就是说，每个示例都会导致输出发生微小的变化。

这样，人们可以在呈现新数据的同时不断调整权重，而不必担心单个示例会抹去模型迄今为止已经学习的所有内容。

感知器不是理想的，因为输入的小变化会线性传播到输出。我们可以使用一个s 形神经元来克服这个问题。

乙状结肠神经元具有输入 x1，x2，…，xn，其值可以在 0 和 1 之间。输出由σ(w . x + b)给出，其中σ为 sigmoid 函数，定义如下:

让我们用 TensorFlow.js 和 Plotly 来看看:

使用权重和输入，我们得到:

让我们更深入地了解乙状结肠神经元，并理解它与感知器的相似之处:

• 假设 z 是一个大的正数。那么 e^{-z} ≈ 0，σ(z) ≈ 1
• 假设 z 是一个大的负数。那么 e^{-z} → ∞，σ(z) ≈ 0
• 当 z“有些适度”时，我们观察到与感知器相比的显著差异。

让我们使用 TensorFlow.js 构建 sigmoid 神经元模型:

另一个笔记本电脑的报价出现了。这一次你可以指定颜色接近粉红色的程度，以及它有多小。

颜色有些粉，大小刚好 x = [0.6，0.9]。其余的保持不变:

0.6479407548904419

是的，你还是想买这款笔记本电脑，但是这款也输出了其决策的自信。很酷，对吧？

构建神经网络

扩展上述模型的一个自然方法是以某种方式将它们分组。一种方法是制造多层神经元。这里有一个简单的神经网络，可以用来做出购买笔记本电脑的决定:

神经网络是神经元的集合，连接在一个非循环图中。一些神经元的输出被用作其他神经元的输入。它们被组织成层。我们的示例由全连接层(两个相邻层之间的所有神经元都是连接的)组成，它是一个 2 层神经网络(我们不计算输入层)。由于构建神经网络的神经元做出的简单决定的组合，神经网络可以做出复杂的决定。

当然，输出图层包含您正在寻找的答案。让我们来看看使训练神经网络成为可能的一些因素:

激活功能

感知器模型只是一个线性变换。将多个这样的神经元相互堆叠会导致矢量积和偏差相加。不幸的是，有很多函数不能通过线性变换来估计。

激活函数使模型能够逼近非线性函数(预测更复杂的现象)。好消息是，你已经遇到了一个激活函数 sigmoid:

Sigmoid 函数的一个主要缺点是，它在[-3，+3]范围之外变得非常平坦。这导致权重接近 0——没有学习发生。

ReLU

ReLU，在整流线性单元的神经网络环境中引入，改进受限玻尔兹曼机器，在大于 0 和 0 的值处具有线性输出。

让我们来看看:

ReLU 的一个缺点是负值“消亡”，停留在 0——没有学习。

泄漏的 ReLU

整流器非线性改善神经网络声学模型中引入的泄漏 ReLU 解决了 ReLU 引入的死值:

请注意，负值会被缩放，而不是清零。缩放可通过 tf.leakyRelu() 中的参数进行调整。

重量初始化

训练神经网络做出“合理”预测的过程包括多次调整神经元的权重。这些权重需要有初始值。你应该如何选择那些？

初始化过程必须考虑我们用来训练模型的算法。通常，这个算法是随机梯度下降(SGD) 。它的工作是搜索可能的参数/权重，并选择那些使我们的模型产生的误差最小的参数/权重。此外，该算法严重依赖于随机性和良好的起点(由权重给出)。

相同常数初始化

假设我们使用相同的常数(是的，包括 0)初始化权重。网络中的每个神经元将计算相同的输出，这导致相同的权重/参数更新。我们刚刚挫败了拥有多个神经元的目的。

过小/过大值初始化

让我们用一组小值初始化权重。将这些值传递给激活函数将使它们呈指数级下降，从而使每个权重都变得同等重要。

另一方面，用大值初始化将导致指数增长，使得权重同样不重要。

随机小数字初始化

我们可以使用平均值为 0、标准偏差为 1 的正态分布用小随机数初始化权重。

每个神经元会计算不同的输出，从而导致不同的参数更新。当然，还有其他多种方式。检查 TensorFlow.js 初始化器

你应该买笔记本电脑吗？

现在你已经知道了一些神经网络的功夫，我们可以使用 TensorFlow.js 来建立一个简单的模型，并决定你是否应该购买一台给定的笔记本电脑。

笔记本电脑数据

这么说吧，对于你的朋友来说，大小比粉嫩程度重要多了！你坐下来设计以下数据集:

干得好！你在整合朋友偏好方面做得很好。

建立模型

回想一下我们将要构建的神经网络:

让我们将其转换为 TensorFlow.js 模型:

我们有一个 2 层网络，输入层包含 2 个神经元，隐藏层包含 3 个神经元，输出层包含 2 个神经元。

注意，我们在隐藏层使用 ReLU 激活函数，在输出层使用 softmax。我们在输出层有 2 个神经元，因为我们想知道我们的神经网络在购买/不购买决策中有多确定。

我们使用二元交叉熵通过测量预测的“好”程度来衡量我们模型的当前权重/参数的质量。

我们的训练算法，随机梯度下降，试图找到使损失函数最小化的权重。对于我们的例子，我们将使用 Adam 优化器。

培训

既然我们的模型已经定义，我们可以使用我们的训练数据集来教授它关于我们的朋友偏好的信息:

我们在训练前重组数据，并在每个时期完成后记录进度:

Epoch 1
Loss: 0.703386664390564 accuracy: 0.5
Epoch 2
Loss: 0.6708164215087891 accuracy: 0.5555555820465088
Epoch 3
Loss: 0.6340110898017883 accuracy: 0.6666666865348816
Epoch 4
Loss: 0.6071969270706177 accuracy: 0.7777777910232544
...
Epoch 19
Loss: 0.08228953927755356 accuracy: 1
Epoch 20
Loss: 0.06922533363103867 accuracy: 1

在经历了大约 20 个时期之后，这个模型似乎已经了解了你朋友的偏好。

评价

你保存模型，并将其发送给你的朋友。连接到您朋友的计算机后，您找到一台合适的笔记本电脑，并将信息编码到模型中:

等待几毫秒后，您会收到一个回答:

0: 0.45
1: 0.55

这个模型适合你。它“认为”你的朋友应该购买笔记本电脑，但它对此并不确定。你做得很好！

结论

你的朋友似乎对结果很满意，而你正考虑通过将你的模型作为浏览器扩展来销售，从而赚上百万。不管怎样，你学到了很多:

• 感知器模型
• 为什么需要激活功能，使用哪一个
• 如何初始化神经网络模型的权重
• 建立一个简单的神经网络来解决一个(有点)实际的问题

在浏览器中运行本教程的完整源代码:

GitHub 上的完整源代码

躺在舒适的枕头上，你开始思考。我可以用深度学习来做这个吗？

参考

减少损失:梯度下降

梯度下降和随机梯度下降从零开始

初始化神经网络

重量初始化的类型

如果不使用神经网络中的任何激活函数会怎样？

原载于https://www.curiousily.com。

建立机器学习模型(特别是深度神经网络)，可以轻松地与现有或新的 web 应用程序集成。想想您的 ReactJs、Vue 或 Angular 应用程序通过机器学习模型的强大功能得到了增强:

[## JavaScript 黑客的深度学习

建立机器学习模型(特别是深度神经网络)，您可以轻松地与现有或新的网络集成…

leanpub.com](https://leanpub.com/deep-learning-for-javascript-hackers)

用不到 50 行 Python 代码构建一个文本生成器 Web 应用程序

原文：https://towardsdatascience.com/build-a-text-generator-web-app-in-under-50-lines-of-python-9b63d47edabb?source=collection_archive---------9-----------------------

学习构建一个自动完成任何输入文本的 web 应用程序

我们将使用 OpenAI 的 GPT-2 作为模型，使用面板作为网络仪表板框架。本指南将分为两部分。在第一部分中，我们将加载我们的模型并编写一个预测函数。第二，我们将构建 web 应用程序。

Example text generation application. We will be building a simpler variation of this web app.

你需要什么

本教程假设你已经安装了 Python 3.7+ ，并且对语言模型有所了解。虽然相关步骤可以在 Jupyter 之外完成，但是强烈推荐使用 jupyter 笔记本。

我们将使用 PyTorch 作为我们深度学习库的选择。在 PyTorch 内，我们将使用 变形金刚 库导入预先训练好的 OpenGPT-2 模型。您可以通过在 bash 中单独输入以下命令来安装这些库:

pip install torchpip install transformers

对于我们的 web 应用程序，我们将利用 面板 ，这是一个很好的工具，可以从 jupyter 笔记本或常规 python 脚本轻松创建可服务的仪表板。使用以下命令安装 panel:

pip install panel

第一部分:建立模型

OpenAI 的 GPT 是一种变形金刚模型，它产生类似人类文本的能力引起了很多关注。如果你以前没有尝试过，在读完这篇文章后，你可能会有同样的想法。

加载模型

首先，我们需要导入所需的包。

import numpy as np
import torch
import torch.nn.functional as F
from transformers import GPT2Tokenizer, GPT2LMHeadModel
from random import choice

接下来，我们将加载 OpenGPT2 标记器和语言模型:(如果第一次运行，可能需要几分钟来下载预训练的模型)

tok = GPT2Tokenizer.from_pretrained("gpt2")
model = GPT2LMHeadModel.from_pretrained("gpt2")

预测功能

在这个阶段，大部分工作已经完成。由于我们的模型是预先训练好的，所以我们不需要训练它，也不需要做任何修改。我们只需要编写一个函数，它可以向模型输入文本并生成预测。

def get_pred(text, model, tok, p=0.7):
    input_ids = torch.tensor(tok.encode(text)).unsqueeze(0)
    logits = model(input_ids)[0][:, -1]
    probs = F.softmax(logits, dim=-1).squeeze()
    idxs = torch.argsort(probs, descending=True)
    res, cumsum = [], 0.
    for idx in idxs:
        res.append(idx)
        cumsum += probs[idx]
        if cumsum > p:
            pred_idx = idxs.new_tensor([choice(res)])
            break
    pred = tok.convert_ids_to_tokens(int(pred_idx))
    return tok.convert_tokens_to_string(pred)

这个函数中发生了很多事情。所以，我们来分解一下。首先，我们对来自 input_ids 的输入文本进行标记和编码。然后，我们要求我们的模型为下一个单词/单词生成一个 logits 向量。在应用 softmax 并按降序排列这些概率后，我们有了一个向量， idxs ，它按概率顺序列出了我们的 vocab 中每个令牌的索引。

在这个阶段，我们可以只选择概率最高的令牌。然而，我们希望能够混合我们的结果，以便相同的输入文本可以生成多种文本。为此，我们将添加一个随机元素，从最有可能的下一个令牌列表中选择一个随机令牌。这样，我们就不会每次都选择相同的预测标记。为此，我们利用 核(Top- p )采样 。

我们通过遍历每个概率来执行这个操作，直到我们遍历的所有概率之和大于 p，0 到 1 之间的任意数。在超过 p 之前迭代的所有令牌都存储在列表 res 中。一旦超过了 p ，我们就从这个列表中随机选择一个令牌。请记住，我们正在循环的概率列表包含按概率排序的索引。请注意，如果 p 更高，我们的列表中将包含更多的令牌。反之亦然。因此，如果每次想要相同的结果，可以将 p 设置为 0。

现在，让我们测试几次 pred 函数:

每一次，都有不同的结果，这正是我们所期待的。我们的预测函数现在已经准备好了。让我们构建我们的 web 应用程序吧！

第 2 部分:构建 Web 应用程序

面板概述

如果您不熟悉面板，它可以简化创建 web 仪表盘和应用程序的过程。乍一看，您需要知道它有三个主要组件:

• 面板:可以包含一个或多个窗格(对象)的容器，如文本、图像、图表、小部件等。(它们也可以包含其他面板)
• 窗格:任何单个对象，如文本、图像、数据帧等。
• Widgets :用户可调整的项目，如文本输入、滑块、按钮、复选框，可以改变窗格的行为

为了我们的目的，你需要知道的下一件也是最后一件事是，我们有多种方法来定义不同的窗格和小部件如何相互交互。这些被称为“回调”例如，如果某个按钮被按下，其他窗格应该如何更新？稍后我们将定义一个回调函数来完成这个任务。

高级应用概述

我们的文本生成器应用程序将有一个输入用户输入他们想要的文本。接下来，用户应该能够通过按下按钮来生成新的令牌。此后，将使用我们在第 1 部分中定义的函数中的预测标记生成新文本。最后，用户应该能够在已经预测的标记之上继续生成新的文本。

履行

让我们首先导入面板并创建文本输入小部件:

import panel as pn
pn.extension() # loading panel's extension for jupyter compatibility text_input = pn.widgets.TextInput()

现在，如果我们在 jupyter 中执行 text_input ，我们会得到以下结果:

接下来，我们需要一个面板，它将在我们生成越来越多的令牌时存储整个文本:

generated_text = pn.pane.Markdown(object=text_input.value)

注意，我们将文本对象设置为 text_input 的值。我们希望 generated_text 的值与 text_input 的值相同，因为我们将在 generated_text 的顶部预测新文本。随着更多的令牌被添加到我们的序列中，我们将继续预测 generated_text ，直到用户更改 text_input 。在这种情况下，该过程将重新开始。

然而，我们还没有完全完成。虽然 generated_text 在初始化时会采用 text_input 的值，但如果 text_input 的值发生变化，它不会自行更新。为此，我们需要将这两个对象链接在一起，如下所示:

text_input.link(generated_text, value='object')

这里，我们在 text_input 到 generated_text 之间形成了一个单向链接。因此，每当 text_input 的值改变时， generated_text 的值也会改变为新值。参见:

observing linked behavior between text_input and generated_text in a panel. Note: pn.Row as a component is a panel i.e. container of panes and widgets

现在我们有了两个文本对象，让我们创建按钮小部件:

button = pn.widgets.Button(name="Generate",button_type="primary")

很好，现在我们有了一个按钮，我们只需要把它和我们想要的行为联系起来。为此，我们将编写一个回调函数，它将在每次单击按钮时运行:

def click_cb(event):
    pred = get_pred(generated_text.object, model, tok)
    generated_text.object += pred

这里发生了两件事。首先，我们将 generated_text 作为输入传递给我们之前编写的预测函数，该函数给出了一个新的令牌。其次，将此令牌添加到 generated_text 中。每当有新的按钮点击时，重复这个过程。

说到这里，我们还是要把按钮点击和回调函数捆绑起来。我们可以通过以下方式做到这一点:

button.on_click(click_cb)

我们现在已经创建了所有的小部件、窗格和功能。我们只需要把这些东西放在一个面板上，瞧:

app = pn.Column(text_input, button, generated_text); app

Note: pn.Column, similar to pn.Row is another type of panel i.e. container of widgets, panes and even other panels.

让我们添加一个标题和一个简短的描述，我们通过了！

title = pn.pane.Markdown("# **Text Generator**")
desc = pn.pane.HTML("<marquee scrollamount='10'><b>Welcome to the text generator! In order to get started, simply enter some starting input text below, click generate a few times and watch it go!</b></marquee>")final_app = pn.Column(title, desc ,app)

为应用服务

Panel 使服务应用程序变得非常容易。有两种方法可以用来做这件事。第一个是”。show()"命令。这通常用于调试，用法如下。这将启动一个新窗口，我们的 final_app 面板作为 web 应用程序运行。

final_app.show()

为了将其投入生产环境，您需要使用“.servable()"方法。但是，如果您以类似于 show 方法的方式运行它，那么在您当前的笔记本中不会发生任何不同。相反，您必须像这样通过计算机的 bash 来服务笔记本:

panel serve --show text_generation_app.ipynb

这将在本地端口上启动您的应用程序，只要您在笔记本中有以下代码:

final_app.servable()

完成了。

到目前为止，您已经有能力构建自己的文本生成应用程序了。您可以通过添加更多面板组件来进一步构建它。你甚至可以将这个应用嵌入到你的其他项目中。一如既往，你可以在 github 上找到我的代码库。注:题图中的 app 是我在教程笔记本中找到的高级变体:text _ generation _ app . ipynb。

[## devkosal/gpt-panel-app

此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…

github.com](https://github.com/devkosal/gpt-panel-app)

额外资源

• OpenAI GPT-2:通过可视化理解语言生成
• 开始使用面板
• 轻松可视化任何数据，从笔记本到仪表盘| Scipy 2019 教程| James Bednar(视频:第一个小时是关于面板)
• 在服务器上部署 Panel 应用

在 GCP 建立一个有用的 ML 模型来预测披头士的听众

原文：https://towardsdatascience.com/build-a-useful-ml-model-in-hours-on-gcp-to-predict-the-beatles-listeners-1b2322486bdf?source=collection_archive---------23-----------------------

AutoML“自动化机器学习”最近受到了数据科学界的抨击。我在 Google Cloud ML 上发表了一些批评 Google Cloud 的 AutoML first look(Google AutoML 团队确实回答了我的一些请求，参见本文结尾的*** 新*** 事情)这篇文章将展示一个公民数据科学家在 ML 下处理整个机器学习生命周期是完全合理的。目标是:

• 解决一个真正的商业问题
• 在 GCP 托管数据
• 使用 GCP 的云自动化
• 进行一些 EDA“探索性数据分析”
• EDA 如何影响结果
• GCP AutoML 表上的数据处理
• 利用内置的数据管道
• 使用维持验证模型
• 将模型投入生产
• 随着时间的推移改进模型
• • • Google 刚刚发布的 AutoML 表格中的新内容

启动你的计时器，准备，设置，开始…

解决一个真正的商业问题

目标是基于音乐听众的收听模式来确定他们是否会听披头士；我们将建立一个推荐系统。约翰·列侬难道不会对人工智能的力量印象深刻吗？！

当然，你不会想推荐披头士，所以有人可能不会听披头士。谁会不喜欢披头士呢？不管怎样，这个模型可以适用于任何有足够听力模式数据的艺术家。你只需要关掉目标变量就可以了。

在 GCP 托管数据

数据来源是 ListenBrainz 用户的音乐收听历史。

我们根据听众数量挑选出前 300 名最受欢迎的艺术家。由于 big query 1TB/mo 的自由层处理，这些数据是可用的。

创建数据集的代码可以在我的 github 上找到。如果你不耐烦，只想在这里下载数据(2.19 MB)。

使用 GCP 的云自动化

我已经在 Google Cloud 的 AutoML first look 中发布了更多关于如何开始使用 GCP 云 AutoML 表的细节

进行一些 EDA“探索性数据分析”

Select the Target “Like_The_Beatles”

Cloud AutoML Analyze Tab

通过 Cloud AutoML，我们可以更深入地研究数据。这与你作为一名在人工智能平台上工作的数据科学家所能做到的细节水平相去甚远。尽管如此，这里还是有一些值得观察的地方。例如，听得最多的艺术家是那些空值最少的艺术家。

EDA 如何影响结果

在这种情况下，我们如何处理空值:我们让它们为空。原因是 Null 确实意味着在我们的数据集中没有监听；因此等于零。这里的中间值是错误的。了解你的数据！

GCP AutoML 表上的数据处理

我们需要删除“披头士”栏，因为我们的目标是直接基于这一点。否则，我们总是会得到 100%准确的模型，咄。

利用内置的数据管道

最大的好处是你可以通过管道构建模型，而不需要很多代码。事实上，您可以使用支持多种语言(包括 Python )的客户端库来编写完整的训练代码。

使用维持验证模型

我们使用 AutoML 中的自动数据分割功能。他们说:

数据集在定型、验证和测试子集之间拆分的方式。默认情况下，AutoML 表随机选择 80%的数据行用于定型，10%用于测试，10%用于验证。

模型运行得非常好！我们看到了一个. 937 AUC ROC。

这是 50%分数阈值的混淆矩阵:

现在将模型投入生产

有这么简单吗:

这是有成本的。如果我将主持这个特定的模型，它将花费 0.126 美元每小时，或 91.98 美元/月(乘数 730 小时在一个月内假设)。

下面是我用的等式:0.005 * 2.8 * 9 = 0.126 美元。0.005 美元是机器的数量(他们使用 9 来实现低延迟，我相信这是硬编码的)。2.8 是因为我的型号是 2.8G。

import json
from google.cloud import automl_v1beta1 as automlproject_id = 'mwpmltr'
compute_region = 'us-central1'
model_display_name = 'beatles_machine_l_20191104025339'
input = ['usr', 5.0, None, None, 10, ... ] # list of valuesclient = automl.TablesClient(project=project_id, region=compute_region)response = client.predict(
    model_display_name=model_display_name,
    inputs=inputs)
response###############################################################payload {
  tables {
    score: 0.9896599650382996
    value {
      string_value: "True"
    }
  }
}
payload {
  tables {
    score: 0.010340098291635513
    value {
      string_value: "False"
    }
  }
}

随着时间的推移改进模型

通过使用标签系统在推荐中寻找模式，我们看到整体准确率有了 3.5%的提高。

“诀窍”是纠正不良记录(改进地面真实数据)和引入新数据。

在这种情况下，这个新数据是专家应用于音乐的“标签”。这些标签很有预见性。例如，标签“60 年代”和“英国入侵”是高度预测性的。另一方面，与所有机器学习一样，它也可以预测艺术家不属于哪个标签；例如，那些高水平演奏被标记为“电子乐”的人，他们不太可能听甲壳虫乐队的音乐。

* * Google 刚刚发布的 AutoML 表格中的新内容

以下是谷歌添加到 AutoML 表格中的三个有意义的新功能:

1. 您可以看到最终的模型架构是如何被训练的，以及在每一轮训练中尝试的实验。

详细信息存储在 Stackdriver 中。

我没有仔细看过这些日志。此时，我不知道日志是否包含了重新创建模型所需的所有信息。

2)在线预测可以得到预测级的特征属性。

TypeError: list_models() got an unexpected keyword argument 'feature_importance'

我可能需要更新我的软件包。

3)您可以导出您的模型容器(现在每个人都可以使用)

结论

踏上汽车之旅并不像我曾经想象的那么可怕。这位数据科学家抱怨说，AutoML 的黑箱性质正在慢慢被打开。易用性越来越强。错误和其他问题似乎正在得到解决。

我谨慎地建议人们开始把目光放在 AutoML 上，作为一个跳跃启动器。这并没有减轻对数据科学之外的数据建模的需求。它并没有减轻工具集之外的数据处理和 EDA 的需要(为此，看看 AI 平台笔记本吧！).同样，这并不意味着这些工具所针对的业务分析师类型不需要很好地理解预测建模理论、术语和最佳实践。

构建基于用户的动漫协同过滤推荐引擎

原文：https://towardsdatascience.com/build-a-user-based-collaborative-filtering-recommendation-engine-for-anime-92d35921f304?source=collection_archive---------9-----------------------

基于用户之间的统计相似性进行推荐

今天，我们将为动画建立一个推荐引擎，由基于用户的协同过滤提供动力。这只是推荐系统的几种不同方法中的一种

介绍

在基于用户的协同过滤中:
-如果用户喜欢相似的项目就被认为是相似的
-我们首先发现哪些用户是相似的
-然后推荐其他相似用户喜欢的项目

看看我在上面(煞费苦心)画的图。

桑尼喜欢莫奈、毕加索和达利的画。泰德喜欢莫奈和毕加索的画。

桑尼和泰德很相似，因为他们喜欢一些相同的艺术家。桑妮喜欢达利画，但泰德从未看过达利画。
所以让我们向 Ted 推荐 Dali。

清澈如泥？现在我们已经了解了它是如何工作的，让我们来构建一个推荐器。

构建推荐器

从 Kaggle 下载数据并加载到 2 个数据帧中。

anime . CSV—我们数据库中关于动漫的详细信息
rating . CSV—特定用户对特定动漫的评分

DIR = 'anime-recommendations-database/'import pandas as pdanimes = pd.read_csv(DIR + 'anime.csv')
ratings = pd.read_csv(DIR + 'rating.csv')

通过阅读这些文档，我知道评分值为-1意味着用户已经观看了这部电影，但还没有对它进行评分。我假设这不会给我们任何有用的信息并删除那些记录。

ratings = ratings[ratings.rating != -1]
ratings.head()

animes.head()

数据探索

没有人比我更不喜欢花 75%的时间在数据探索上，所以让我们先了解一下数据的大小和分布。

# number of ratings
len(ratings)
=> 6337241# number of users
len(ratings['user_id'].unique())
=> 69600# number of unique animes (in anime list, not ratings)
len(animes['anime_id'].unique())
#=> 11200# avg number of anime rated per user
import statistics
ratings_per_user = ratings.groupby('user_id')['rating'].count()
statistics.mean(ratings_per_user.tolist())
#=> 91.05231321839081# distribution of ratings per user
# (we may want to exclude users without many data points)
import matplotlib.pyplot as plt
%matplotlib inline
ratings_per_user.hist(bins=20, range=(0,500))

most users have rated fewer than 100 anime

# avg number of ratings given per anime
ratings_per_anime = ratings.groupby('anime_id')['rating'].count()
statistics.mean(ratings_per_anime.tolist())
=> 638.3843054296364# distribution of ratings per anime
import matplotlib.pyplot as plt
%matplotlib inline
ratings_per_anime.hist(bins=20, range=(0,2500))

most anime received less than 500 ratings

回到推荐者

在基于用户的协同过滤中，代表用户的向量实际上是他们给出的评级列表。所以我们宇宙中的动漫越多，每个用户的维度就越多。

让我们通过删除没有被很多用户评价的动画来减少数据量。根据 id 做一个动漫保留清单。

# counts of ratings per anime as a df
ratings_per_anime_df = pd.DataFrame(ratings_per_anime)# remove if < 1000 ratings
filtered_ratings_per_anime_df = ratings_per_anime_df[ratings_per_anime_df.rating >= 1000]# build a list of anime_ids to keep
popular_anime = filtered_ratings_per_anime_df.index.tolist()

以及没怎么评价过动漫的用户。

# counts ratings per user as a df
ratings_per_user_df = pd.DataFrame(ratings_per_user)# remove if < 500
filtered_ratings_per_user_df = ratings_per_user_df[ratings_per_user_df.rating >= 500]# build a list of user_ids to keep
prolific_users = filtered_ratings_per_user_df.index.tolist()

现在过滤掉那些列表之外的动漫和用户。

filtered_ratings = ratings[ratings.anime_id.isin(popular_anime)]
filtered_ratings = ratings[ratings.user_id.isin(prolific_users)]
len(filtered_ratings)
=> 1005314

我们的评级数据点从 600 万降至 100 万。很好。

我们来建立一个用户和动漫之间的评分矩阵。

rating_matrix = filtered_ratings.pivot_table(index='user_id', columns='anime_id', values='rating')# replace NaN values with 0
rating_matrix = rating_matrix.fillna(0)# display the top few rows
rating_matrix.head()

写一个函数，用余弦相似度找出与 current_user 最相似的用户。我们随意决定找出 3 个最相似的用户。

并选择“226”作为我们的当前用户，但我们可以选择任何人。

from sklearn.metrics.pairwise import cosine_similarity
import operatordef similar_users(user_id, matrix, k=3):
    # create a df of just the current user
    user = matrix[matrix.index == user_id]

    # and a df of all other users
    other_users = matrix[matrix.index != user_id]

    # calc cosine similarity between user and each other user
    similarities = cosine_similarity(user,other_users)[0].tolist()

    # create list of indices of these users
    indices = other_users.index.tolist()

    # create key/values pairs of user index and their similarity
    index_similarity = dict(zip(indices, similarities))

    # sort by similarity
    index_similarity_sorted = sorted(index_similarity.items(), key=operator.itemgetter(1))
    index_similarity_sorted.reverse()

    # grab k users off the top
    top_users_similarities = index_similarity_sorted[:k]
    users = [u[0] for u in top_users_similarities]

    return users current_user = 226# try it out
similar_user_indices = similar_users(current_user, rating_matrix)print(similar_user_indices)
#=> [30773, 39021, 45603]

现在写一个函数来做推荐。我们已经设置了返回 5 部热门推荐动漫的功能。

def recommend_item(user_index, similar_user_indices, matrix, items=5):

    # load vectors for similar users
    similar_users = matrix[matrix.index.isin(similar_user_indices)] # calc avg ratings across the 3 similar users
    similar_users = similar_users.mean(axis=0) # convert to dataframe so its easy to sort and filter
    similar_users_df = pd.DataFrame(similar_users, columns=['mean'])

    # load vector for the current user
    user_df = matrix[matrix.index == user_index] # transpose it so its easier to filter
    user_df_transposed = user_df.transpose() # rename the column as 'rating'
    user_df_transposed.columns = ['rating'] # remove any rows without a 0 value. Anime not watched yet
    user_df_transposed = user_df_transposed[user_df_transposed['rating']==0] # generate a list of animes the user has not seen
    animes_unseen = user_df_transposed.index.tolist()

    # filter avg ratings of similar users for only anime the current user has not seen
    similar_users_df_filtered = similar_users_df[similar_users_df.index.isin(animes_unseen)] # order the dataframe
    similar_users_df_ordered = similar_users_df.sort_values(by=['mean'], ascending=False) # grab the top n anime   
    top_n_anime = similar_users_df_ordered.head(items)
    top_n_anime_indices = top_n_anime.index.tolist() # lookup these anime in the other dataframe to find names
    anime_information = animes[animes['anime_id'].isin(top_n_anime_indices)]

    return anime_information #items # try it out
recommend_item(226, similar_user_indices, rating_matrix)

我们做到了！我们的当前用户尚未观看的来自最相似用户的最高评级的 5 部动画。

实际上，我们想要试验不同的相似性算法和不同数量的相似用户。但是我希望你把它当作一个基于用户的协作过滤的粗略框架。

下次见。

在 pySpark 中用 MLlib 搭建一个端到端的机器学习模型。

原文：https://towardsdatascience.com/build-an-end-to-end-machine-learning-model-with-mllib-in-pyspark-4917bdf289c5?source=collection_archive---------3-----------------------

对于具有不平衡类别的二元分类问题

photo credit: pexels

介绍

内存计算和并行处理是 Apache Spark 在大数据行业非常受欢迎的一些主要原因，以处理大规模的数据产品并执行更快的分析。 MLlib 建立在 Spark 之上，是一个可扩展的机器学习库，提供高质量的算法和超快的速度。它拥有优秀的 Java、 Python 和 Scala API，是数据分析师、数据工程师和数据科学家的首选。MLlib 由常见的学习算法和实用程序组成，包括分类、回归、聚类、协同过滤(矩阵分解)、降维等。

履行

在本文中，我们将在 pySpark 中使用 MLlib 构建一个端到端的机器学习模型。我们将使用 kaggle 上的家庭信用违约风险竞赛的真实数据集。这项竞赛的目的是根据从每个申请人那里收集的数据，确定贷款申请人是否有能力偿还贷款。目标变量为 0(有能力偿还贷款的申请人)或 1(没有能力偿还贷款的申请人)。这是一个目标标签高度不平衡的二元分类问题。分配比率接近 0.91 比 0.09，0.91 是能够偿还贷款的申请人的比率，0.09 是不能偿还贷款的申请人的比率。

让我们先来看看数据集的结构:

#we use the findspark library to locate spark on our local machineimport findspark
findspark.init('home Diredtory of Spark')from pyspark.sql import SparkSession# initiate our session and read the main CSV file, then we print the #dataframe schemaspark = SparkSession.builder.appName('imbalanced_binary_classification').getOrCreate()
new_df = spark.read.csv('application_train.csv', header=True, inferSchema=True)
new_df.printSchema()root
 |-- SK_ID_CURR: integer (nullable = true)
 |-- TARGET: integer (nullable = true)
 |-- NAME_CONTRACT_TYPE: string (nullable = true)
 |-- CODE_GENDER: string (nullable = true)
 |-- FLAG_OWN_CAR: string (nullable = true)
 |-- FLAG_OWN_REALTY: string (nullable = true)
 |-- CNT_CHILDREN: integer (nullable = true)
 |-- AMT_INCOME_TOTAL: double (nullable = true)
 |-- AMT_CREDIT: double (nullable = true)
 |-- AMT_ANNUITY: double (nullable = true)
 |-- AMT_GOODS_PRICE: double (nullable = true)
 |-- NAME_TYPE_SUITE: string (nullable = true)
 |-- NAME_INCOME_TYPE: string (nullable = true)
 |-- NAME_EDUCATION_TYPE: string (nullable = true)
 |-- NAME_FAMILY_STATUS: string (nullable = true)
 |-- NAME_HOUSING_TYPE: string (nullable = true)
 |-- REGION_POPULATION_RELATIVE: double (nullable = true)
...

printSchema()只显示了列名及其数据类型。我们将删除 SK_ID_CURR 列，将“TARGET”列重命名为“label ”,并查看我们的目标变量的分布:

# Sk_ID_Curr is the id column which we dont need it in the process #so we get rid of it. and we rename the name of our 
# target variable to "label"
drop_col = ['SK_ID_CURR']
new_df = new_df.select([column for column in new_df.columns if column not in drop_col])
new_df = new_df.withColumnRenamed('TARGET', 'label')
new_df.groupby('label').count().toPandas()

我们可以用 matplotlib 可视化标签的分布:

# let's have a look at the distribution of our target variable:
# to make it look better, we first convert our spark df to a Pandasimport matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
df_pd = new_df.toPandas()
print(len(df_pd))
plt.figure(figsize=(12,10))
sns.countplot(x='label', data=df_pd, order=df_pd['label'].value_counts().index)

以下是熊猫数据帧格式的数据:

# let's see how everything look in Pandasimport pandas as pd
pd.DataFrame(new_df.take(10), columns= new_df.columns)

数据争论

现在我们对数据集的一般结构有了一些想法，让我们继续一些数据争论。首先我们检查我们有多少分类和数字特征。接下来，我们构建一个函数，输出数据集中缺失值的基本信息:

# now let's see how many categorical and numerical features we have:cat_cols = [item[0] for item in new_df.dtypes if item[1].startswith('string')] 
print(str(len(cat_cols)) + '  categorical features')num_cols = [item[0] for item in new_df.dtypes if item[1].startswith('int') | item[1].startswith('double')][1:]print(str(len(num_cols)) + '  numerical features')**16  categorical features
104  numerical features**

下面是我们如何得到缺失信息的表格:

# we use the below function to find more information about the #missing valuesdef info_missing_table(df_pd):
    """Input pandas dataframe and Return columns with missing value and percentage"""
    mis_val = df_pd.isnull().sum() #count total of null in each columns in dataframe#count percentage of null in each columns
    mis_val_percent = 100 * df_pd.isnull().sum() / len(df_pd) 
    mis_val_table = pd.concat([mis_val, mis_val_percent], axis=1) #join to left (as column) between mis_val and mis_val_percent
    mis_val_table_ren_columns = mis_val_table.rename(
    columns = {0 : 'Missing Values', 1 : '% of Total Values'}) #rename columns in table
    mis_val_table_ren_columns = mis_val_table_ren_columns[
    mis_val_table_ren_columns.iloc[:,1] != 0].sort_values('% of Total Values', ascending=False).round(1) 

    print ("Your selected dataframe has " + str(df_pd.shape[1]) + " columns.\n"    #.shape[1] : just view total columns in dataframe  
    "There are " + str(mis_val_table_ren_columns.shape[0]) +              
    " columns that have missing values.") #.shape[0] : just view total rows in dataframe return mis_val_table_ren_columns missings = info_missing_table(df_pd)
missings

121 列中有 67 列缺少值。它没有在图像中显示所有这些列，但总体而言，这 67 列中的大多数都有超过 50%的缺失值。所以我们正在处理大量缺失的值。我们将用每列的平均值填充数值缺失值，用每列最常见的类别填充分类缺失值。但首先，让我们统计每一列中缺失的值:

miss_counts = count_missings(new_df)
miss_counts[('AMT_ANNUITY', 12),
 ('AMT_GOODS_PRICE', 278),
 ('NAME_TYPE_SUITE', 1292),
 ('OWN_CAR_AGE', 202929),
 ('OCCUPATION_TYPE', 96391),
 ('CNT_FAM_MEMBERS', 2),
 ('EXT_SOURCE_1', 173378),
 ('EXT_SOURCE_2', 660),
 ('EXT_SOURCE_3', 60965),
 ('APARTMENTS_AVG', 156061),
 ('BASEMENTAREA_AVG', 179943),
 ('YEARS_BEGINEXPLUATATION_AVG', 150007),
 ('YEARS_BUILD_AVG', 204488),
...

我们将缺失值的分类列和数字列分开:

# here we seperate missing columns in our new_df based on #categorical and numerical typeslist_cols_miss=[x[0] for x in miss_counts]
df_miss= new_df.select(*list_cols_miss)
#categorical columns
catcolums_miss=[item[0] for item in df_miss.dtypes if item[1].startswith('string')]  #will select name of column with string data type
print("cateogrical columns_miss:", catcolums_miss)### numerical columns
numcolumns_miss = [item[0] for item in df_miss.dtypes if item[1].startswith('int') | item[1].startswith('double')] #will select name of column with integer or double data type
print("numerical columns_miss:", numcolumns_miss)

接下来，我们填充缺失的值:

# now that we have seperated the columns based on categorical and #numerical types, we will fill the missing categiracl 
# values with the most frequent categoryfrom pyspark.sql.functions import rank,sum,col
df_Nomiss=new_df.na.drop()
for x in catcolums_miss:                  mode=df_Nomiss.groupBy(x).count().sort(col("count").desc()).collect()[0][0] 
    print(x, mode) #print name of columns and it's most categories 
    new_df = new_df.na.fill({x:mode})# and we fill the missing numerical values with the average of each #columnfrom pyspark.sql.functions import mean, roundfor i in numcolumns_miss:
    meanvalue = new_df.select(round(mean(i))).collect()[0][0] 
    print(i, meanvalue) 
    new_df=new_df.na.fill({i:meanvalue})

既然我们的数据集中不再有缺失值，让我们来研究如何处理不平衡类。有不同的方法来缓解这个问题。一种方法是下采样多数阶级或者上采样少数阶级以取得更平衡的结果。另一种方法是为每个类分配权重，通过分配较小的权重来惩罚多数类，通过分配较大的权重来促进少数类。我们将在数据集中创建一个名为“weights”的新列，并将每个类的倒数 比率指定为权重。这是如何做到的:

# adding the new column weights and fill it with ratiosfrom pyspark.sql.functions import whenratio = 0.91
def weight_balance(labels):
    return when(labels == 1, ratio).otherwise(1*(1-ratio))new_df = new_df.withColumn('weights', weight_balance(col('label')))

下面是添加重量列后的样子:

特征工程

下一步是特征工程。pySpark 使得提取特征变得如此简单，我们不需要做太多工作。以下是步骤:

1. 我们应用 StringIndexer()为分类列中的每个类别分配索引。
2. 我们应用 OneHotEncoderEstimator()将分类列转换为 onehot 编码的向量。
3. 我们应用 VectorAssembler()从所有分类和数字特征中创建一个特征向量，我们将最终向量称为“特征”。

# we use the OneHotEncoderEstimator from MLlib in spark to convert #aech v=categorical feature into one-hot vectors
# next, we use VectorAssembler to combine the resulted one-hot ector #and the rest of numerical features into a 
# single vector column. we append every step of the process in a #stages arrayfrom pyspark.ml.feature import OneHotEncoderEstimator, StringIndexer, VectorAssemblerstages = []
for categoricalCol in cat_cols:
    stringIndexer = StringIndexer(inputCol = categoricalCol, outputCol = categoricalCol + 'Index')
    encoder = OneHotEncoderEstimator(inputCols=[stringIndexer.getOutputCol()], outputCols=[categoricalCol + "classVec"])stages += [stringIndexer, encoder]assemblerInputs = [c + "classVec" for c in cat_cols] + num_cols
assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="features")
stages += [assembler]

现在让我们把所有东西都放到一个管道里。这里我们执行一系列转换，因此我们使用管道一次完成所有转换:

# we use a pipeline to apply all the stages of transformationfrom pyspark.ml import Pipelinecols = new_df.columns
pipeline = Pipeline(stages = stages)
pipelineModel = pipeline.fit(new_df)
new_df = pipelineModel.transform(new_df)selectedCols = ['features']+cols
new_df = new_df.select(selectedCols)
pd.DataFrame(new_df.take(5), columns=new_df.columns)

以下是我们的新数据集在特征工程后的样子:

训练和超参数调整

对于训练，我们首先将数据集分成训练集和测试集。然后，我们开始使用逻辑回归进行训练，因为它对二元分类问题表现良好。

# split the data into trainign and testin setstrain, test = new_df.randomSplit([0.80, 0.20], seed = 42)
print(train.count())
print(test.count())# first we check how LogisticRegression perform 
from pyspark.ml.classification import LogisticRegressionLR = LogisticRegression(featuresCol = 'features', labelCol = 'label', maxIter=15)
LR_model = LR.fit(train)

我们将为训练数据绘制 ROC 曲线，以了解如何执行逻辑回归，然后我们将使用 ROC 曲线下面积(一种用于评估二元分类的标准度量)作为评估模型的度量:

#plotting the ROC CurvetrainingSummary = LR_model.summaryroc = trainingSummary.roc.toPandas()
plt.plot(roc['FPR'],roc['TPR'])
plt.ylabel('False Positive Rate')
plt.xlabel('True Positive Rate')
plt.title('ROC Curve')
plt.show()print('Training set ROC: ' + str(trainingSummary.areaUnderROC))

在测试集上检查模型的性能:

from pyspark.ml.evaluation import BinaryClassificationEvaluatorpredictions_LR = LR_model.transform(test)
evaluator = BinaryClassificationEvaluator()
print("Test_SET (Area Under ROC): " + str(evaluator.evaluate(predictions_LR, {evaluator.metricName: "areaUnderROC"})))**Test_SET (Area Under ROC): 0.7111434396856681**

0.711 对于逻辑回归来说并不是一个很差的结果。接下来，我们尝试另一个模型，梯度推进树(GBT)。这是一种非常流行的分类和回归方法，使用决策树的集合。

# next we checkout gradient boosting treesfrom pyspark.ml.classification import GBTClassifiergbt = GBTClassifier(maxIter=15)
GBT_Model = gbt.fit(train)
gbt_predictions = GBT_Model.transform(test)evaluator = BinaryClassificationEvaluator()
print("Test_SET (Area Under ROC): " + str(evaluator.evaluate(gbt_predictions, {evaluator.metricName: "areaUnderROC"})))**Test_SET (Area Under ROC): 0.7322019340889893**

我们使用 GBT 获得了更好的结果，0.732。作为这里的最后一个策略，我们将使用网格搜索实现超参数调整，然后我们运行交叉验证来更好地提高 GBT 的性能。

from pyspark.ml.tuning import ParamGridBuilder, CrossValidatorparamGrid = (ParamGridBuilder()
             .addGrid(gbt.maxDepth, [2, 4, 6])
             .addGrid(gbt.maxBins, [20, 30])
             .addGrid(gbt.maxIter, [10, 15])
             .build())cv = CrossValidator(estimator=gbt, estimatorParamMaps=paramGrid, evaluator=evaluator, numFolds=5)# Run cross validations.cvModel = cv.fit(train)
gbt_cv_predictions = cvModel.transform(test)
evaluator.evaluate(gbt_cv_predictions)**CV_GBT (Area Under ROC) = 0.7368288195372332**

结果有了一点改善，这意味着我们仍然可以通过超参数调整来看看我们是否可以进一步改善结果。

在这个项目中，我们建立了一个端到端的机器学习模型(具有不平衡类的二元分类)。我们展示了 Apache Spark 的 MLlib 的强大功能，以及它如何应用于端到端 ML 项目。

像往常一样，代码和 jupyter 笔记本在我的 Github 上可用。

非常感谢您的提问和评论。

参考资料:

1. https://github.com/elsyifa/Classification-Pyspark
2. https://spark . Apache . org/docs/2 . 3 . 0/ml-classification-regression . html

用 Plotly 和 Dash 创建交互式 Choropleth 地图

原文：https://towardsdatascience.com/build-an-interactive-choropleth-map-with-plotly-and-dash-1de0de00dce0?source=collection_archive---------8-----------------------

悉尼郊区房价中位数的可视化

L 上周，我完成了 IBM 数据科学课程的期末作业，就是根据位置数据，寻找一个理想的郊区，开一家意大利餐厅。在这个过程中，我在网上收集了悉尼每个郊区的房产中值价格(即房屋购买/租赁和单位购买/租赁),并分别绘制在 Choropleth 地图上。

Choropleth maps for different parameters

然而，我想知道是否有可能将所有这些地图组合在一起，并通过点击下拉菜单中的名称来选择其中之一。此外，我想在地图旁边再添加一个地块，以相应地显示中位数价格最高的前 10 个郊区。这些附件将使地图更加丰富和用户友好。在这篇文章中，我将分享我关于如何使用 Plotly 和 Dash 创建一个带有 choropleth 地图和条形图的交互式仪表板的笔记。此外，我假设你以前有与 Plotly 的经验。

先决条件

在系统上安装plotly, dash和pandas。我使用conda创建了一个虚拟环境，以保持系统有序，避免与系统中的其他包混淆。如果你想了解更多关于conda env的信息，我已经在上一篇文章中介绍了康达虚拟环境。以下代码将创建一个虚拟环境，其中包含plotly和dash所需的所有包。

conda create -n <whatever name you want for this env> -c plotly plotly=4.4.1 -c conda-forge dash pandas

为了能够在plotly中绘制地图，我们还需要一个来自 Mapbox 的令牌，它提供了各种漂亮的地图样式，最重要的是免费的。此外，在这个仪表板中使用了两个数据集，它们可以从我的 github 下载(你也可以在这里找到 dash 应用程序代码)。

子弹头列车路线

如果您现在想探索 dash 应用程序，在完成上述步骤后，您需要在这个脚本中将您的 Mapbox 令牌分配给mapbox_accesstoken，并在两个数据集所在的同一目录下运行它。一旦弹出以下消息，只需在您首选的浏览器中打开这个地址[http://127.0.0.1:8050/](http://127.0.0.1:8050/)，dash 就会加载到那里。

$ python dash_project_medium.py
  Running on [http://127.0.0.1:8050/](http://127.0.0.1:8050/)
  Debugger PIN: 880-084-162
  * Serving Flask app "dash_project" (lazy loading)
  * Environment: production
    WARNING: This is a development server. Do not use it in a    production deployment.
  Use a production WSGI server instead.
  * Debug mode: on

蒸汽火车道

如下图所示，我已经标记了脚本中用于在仪表板中创建相应元素的关键函数。

Dissecting the dashboard

通过plotly和dash构建这个仪表板的一般原则是 1)在一个定义好的画布上安排和组合不同的元素；2)将所有元素编译到一个容器中:fig=go.Figure(data=trace2 + trace1, layout=layout)；3)将这个容器传递给dcc.Graph，其中dcc是 dash 核心组件，dash将为仪表盘创建一个基于 html 的 web 应用。

该仪表板的一个关键功能是通过下拉菜单在两个轨迹(choropleth 图和条形图)中显示特定参数(即House_buy、House_rent、Unit_buy和Unit_rent)。我的方法是创建四个层，每个层有一个参数visible=False。然后使用updatemenus的buttons功能转动visible=True至给定参数。

Bar plot code

因此，每个轨迹中有四个图形层，只有一个是可见的，这取决于在给定的时间点点击了哪个按钮。

Drop down menu bar code

由于地图不是在笛卡尔坐标系(x/y)上绘制的，而笛卡尔坐标系是条形图中使用的坐标系，因此我在仪表板中为地图和条形图分别设置了两个坐标系。对于条形图(trace2)，其坐标轴被分配到**xaxis='x2'**、**yaxis='y2'**。相反，地图(trace1)在Layout中有自己的特征，它被赋给变量mapbox1，mapbox和x/y后面的数字是任意的。话虽如此，你可以指定任意多的坐标系，只要确保你在Layout中将正确的系统锚定到它的轨迹上。

Choropleth map code

然后在Layout设置中，我们分别对这两个坐标系进行调整。如通过domain显示轨迹在仪表盘中的位置，通过showticklabels显示每个轴上的刻度，通过autorange显示条的升序。

Layout code

在连接了fig=go.Figure中的所有元素之后，我将fig分配给dcc.Graph，将所有代码打包成一个py文件，并运行它。嘣，我的第一个交互式仪表盘来了。

Dash app implementation

我应该指出，我在这里只使用了非常基本的破折号结构，大部分代码仍然是用 Plotly 编写的。我的方法的一个缺点是，将所有四层堆叠到同一轨迹上可能会降低应用程序的速度，这是因为所有数据都需要在 dash 应用程序初始化时加载。当点击下拉菜单事件发生时，进行实时更新会更有效。希望通过进一步学习高级 Dash 代码，我能找到一个解决方案。

以下是一些学习 Dash 的资源:

• Dash 用户指南
• 来自数据营的初学者 Dash
• Dash 社区论坛
• Github 上的牛逼 Dash 资源指南
• 一张详细的仪表盘构建贴

和往常一样，我欢迎反馈、建设性的批评和倾听您的数据科学项目。你可以在 Linkedin 上找到我。

构建并比较 3 个模型— NLP 预测

原文：https://towardsdatascience.com/build-and-compare-3-models-nlp-sentiment-prediction-67320979de61?source=collection_archive---------8-----------------------

从零开始用 3 种算法预测情绪-初学者友好。

Python 上的自然语言处理(Jupyter)！

创建这个项目是为了学习和理解各种分类算法在自然语言处理模型中是如何工作的。自然语言处理，我现在称之为 NLP，是机器学习的一个分支，专注于使计算机能够解释和处理语音和文本形式的人类语言。

Photo by Patrick Tomasso on Unsplash

在这条流水线上，我经历了以下几个步骤:

1. 导入所需的包和库
2. 导入数据集
3. 在数据集中的文本可以被计算机分析之前对其进行处理
4. 创建一个单词袋模型
5. 将数据集分成训练集和测试集
6. 朴素贝叶斯算法
7. 决策树算法
8. 随机森林算法
9. 比较准确度、精确度、召回率和 F1 分数

||二||问题

Photo by Zulmaury Saavedra on Unsplash

对于这个项目，我将使用来自 Kaggle 的数据集，其中包含不同用户对一家披萨店的 1000 条评论。|链接到数据集|

人类可以阅读评论，并判断它是积极的还是消极的。如果我们可以创建一个模型来将他们分为积极的或消极的呢？做这件事的最好方法是什么？

首先说一下流程。我们首先对数据进行预处理，删除对我们的预测没有帮助的不必要的词。然后，我们采用词干形式的重要单词(例如 lov 是 loved、loving 或 lovely 的词干)。然后，我们训练机器根据词干来学习哪些评论是正面的。之后，我们使用类似的信息测试数据，看看我们的机器能够多准确地预测评论是正面还是负面(1 或 0)。

|| III || 导入基本库

在这里，我们导入这个模型工作所需的所有库。在开始之前，请确保安装了所有的依赖项。我们将主要与pandas, numpy, re, nltk, matplotlib, and sci-kit learn.合作

确保在命令行上运行上面提到的所有库。

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import re
import nltk
from nltk.corpus import stopwords
from nltk.stem.porter import PorterStemmer
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import confusion_matrix
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier

|| IV ||导入数据集

dataset = pd.read_csv(‘Restaurant_Reviews.tsv’, delimiter = ‘\t’, quoting = 3)

在上面的代码中，我使用的是. tsv 文件，而不是. csv 文件。当我们分解缩略词时，区别就更容易分辨了。. tsv(制表符分隔的值)在文本文件中由空格分隔，而. csv(逗号分隔的值)使用逗号分隔不同的值。

pd.read_csv可用于两者，但为了指定 tsv 文件，我在分隔符中添加了' \t ',以告诉机器值由制表符而不是逗号分隔。引用被设置为 3，因为我们的评论包含一些双引号，如果我们不添加这一行，机器将无法将它们解释为常规文本。
下面我们可以看到我们数据集的前 10 个评论和结果:正面(1)或负面(0)

dataset.head(10)

|| V || 文本预处理

nltk.download(‘stopwords’)
corpus = []for i in range(0, 1000):
review = re.sub(‘[^a-zA-Z]’, ‘ ‘, dataset[‘Review’][i])
review = review.lower()
review = review.split()
ps = PorterStemmer()
review = [ps.stem(word) for word in review if not word in set(stopwords.words(‘english’))]
review = ‘ ‘.join(review)
corpus.append(review)

上面的代码显示了这个模型中最重要的一步。我从导入 Regex 作为re开始。这个类允许我们匹配和搜索字符串对象。我使用 re 的子功能来允许机器包含我们需要的数据元素，即大写和小写的字母 A-Z。

我还导入了代表自然语言工具包的nltk。从nltk中，我导入了两个类:stopwords类和PorterStemmer类。

stopwords允许我们删除对我们的模型没有帮助的单词(如“the”、“an”、“this”等)。stopwords 类已经包含了这些单词，所以我不必手动输入它们。我使用了一个 for 循环来告诉机器，如果这个单词不在 stopwords 类中，我们需要把它取出来。

PorterStemmer允许我们提取一个单词的词干，并将其归类为相似单词的常见预测值。例如，在第一个评论中，“Lov”是单词“loving”或“loved”的词干，这两个单词本质上都转化为积极的评论，因此允许我们的模型有更少的单词。

最后，为了将预处理步骤应用于我们数据集中的所有 1000 条评论，我在文本处理步骤之前添加了另一个 for 循环。

|| VI || 创建单词袋模型

cv = CountVectorizer(max_features = 1500)X = cv.fit_transform(corpus).toarray()
y = dataset.iloc[:, 1].values

单词袋模型允许我们从文本数据中提取特征，在本例中，我们从每个观察结果中提取所有单词，并将它们集中在一个“袋”中，通过不计算重复项来减少冗余。我是通过从sklearn导入CountVectorizer类来做到这一点的。

每个单词以某种方式形成自己的列，因为有这么多单词，我们可以有大量的列。然而，我使用CountVectorizer类的max_features参数指定了最大列数。

然后，我所要做的就是将单词列与 X(输入)变量相匹配，并将 y(输出)变量指定为数据集中的第二列，这将根据评论是正面还是负面分别给出 1 或 0。

|| VII || 分成训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)

然后，我必须将数据集分为训练集和测试集，并使用 0.2 的测试大小，这样我们就有 800 个值来训练数据集，200 个值来测试数据集。

下面的代码向我们展示了训练和测试集的样子

X_train[0, 0:10] *#First 10 rows of the first column of X_train.***Output**: array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int64)X_test[0, 0:10] *#First 10 rows of the first column of X_test.***Output**: array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int64)y_train[:10] *#First 10 values of the first column of y_train.***Output**: array([1, 1, 1, 0, 1, 0, 1, 0, 0, 0])y_test[:10] *#First 10 values of the first column of y_test.***Output**: array([0, 0, 0, 0, 0, 0, 1, 0, 0, 1])

现在我已经完成了所有的预处理步骤，我将开始对 model 应用一些分类算法，以帮助它预测评论。

|| VIII || 朴素贝叶斯模型

我使用的第一个模型是朴素贝叶斯模型。在机器学习中，朴素贝叶斯分类器是一系列简单的“概率分类器”，基于应用贝叶斯定理，在特征之间具有强(朴素)独立性假设。

给定类变量，所有朴素贝叶斯分类器都假设特定特征的值独立于任何其他特征的值。在我们的模型中，朴素贝叶斯算法根据输出集，查看评论的特定关键字来描述它是正面还是负面的。

在下面的代码中，我导入了 GaussianNB 类，它假设我们的数据是正态分布的(具有高斯钟形曲线)。

VIII~i ||将朴素贝叶斯拟合到训练集

classifier = GaussianNB()
classifier.fit(X_train, y_train)**Output**: GaussianNB(priors=None, var_smoothing=1e-09)

VIII~ii ||预测测试集结果

我创建了y_pred_NB，这是我们的模型的预测将被存储的地方。下面的输出向我们展示了预测矩阵的样子。它是一堆 1 和 0，就像我们的y_train数据集。这些是我们的模型做出的预测。y_pred_NB可以与y_test进行比较，并确定我们的模型有多精确。

y_pred_NB = classifier.predict(X_test)
y_pred_NB**Output**: array([1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1])

VIII~iii ||制作混淆矩阵

朴素贝叶斯的混淆矩阵在左上角显示我们的真阴性，在右上角显示假阴性，在右下角显示真阳性，在左下角显示假阳性。

下面，我用缩写对每个数字进行了编码，T 代表真，F 代表假，N 代表负，P 代表正。

cm_NB = confusion_matrix(y_test, y_pred_NB) 
cm_NB**Output**: array([[55, 42],[12, 91]])TP_NB = 91 *#True Positives (Naive Bayes)*TN_NB = 55 *#True Negatives (Naive Bayes)*FP_NB = 12 *#False Positives (Naive Bayes)*FN_NB = 42 *#False Negatives (Naive Bayes)*

下面，我将使用真/假阳性和阴性来计算准确度、精确度、召回率和 F1 分数。

VIII~iv ||朴素贝叶斯算法的精度

准确性顾名思义。它通过将真实预测相加并除以预测总数来衡量准确性。

Accuracy_NB = (TP_NB + TN_NB) / (TP_NB + TN_NB + FP_NB + FN_NB) Accuracy_NB **Output**: 0.73

VIII~v || 朴素贝叶斯算法的精度

精度是指两个或多个测量值之间的接近程度。它是通过将真阳性除以总阳性来计算的

Precision_NB = TP_NB / (TP_NB + FP_NB)Precision_NB**Output**: 0.883495145631068

VIII~vi ||回忆朴素贝叶斯算法

回忆是正确预测的正面观察与实际类中所有观察的比率。将真阳性除以真阳性和假阴性之和。

Recall_NB = TP_NB / (TP_NB + FN_NB)Recall_NB**Output**: 0.6842105263157895

VIII~vii ||朴素贝叶斯算法的 F1 得分

F1 分数是精确度和召回率的加权平均值。如果我们需要在精确度和召回率之间寻求平衡，并且存在不均匀的类别分布，F1 分数可能是一个更好的衡量标准。它的计算方法是将精度和召回率相乘，将结果除以精度和召回率之和，然后将最终结果乘以 2。

F1_Score_NB = 2 * Precision_NB * Recall_NB / (Precision_NB + Recall_NB) F1_Score_NB**Output**: 0.7711864406779663

|| IX || 决策树

我使用的下一个算法是决策树。决策树允许您开发分类系统，该系统基于一组决策规则对未来的观察结果进行预测或分类。

IX~i || 将决策树分类拟合到训练集

classifier = DecisionTreeClassifier(criterion = ‘entropy’, random_state = 0)classifier.fit(X_train, y_train)**Output:** DecisionTreeClassifier(class_weight=None, criterion=’entropy’,max_depth=None,max_features=None,max_leaf_nodes=None,min_impurity_decrease=0.0,min_impurity_split=None,min_samples_leaf=1,min_samples_split=2,min_weight_fraction_leaf=0.0, presort=False, random_state=0,splitter=’best’)

IX~ii ||预测测试集结果

In [59]: y_pred_DT = classifier.predict(X_test)y_pred_DT**Output**: array([0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0,1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0,0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1,0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1,0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1,0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1,0, 0])

IX~iii ||制作混淆矩阵

cm_DT = confusion_matrix(y_test, y_pred_DT) cm_DT**Output**: array([[74, 23],[35, 68]])TP_DT = 68 *#True Positives (Decision Tree)*TN_DT = 74 *#True Negatives (Decision Tree)*FP_DT = 35 *#False Positives (Decision Tree)*FN_DT = 23 *#False Negatives (Decision Tree)*

IX~iv ||决策树算法的准确性

Accuracy_DT = (TP_DT + TN_DT) / (TP_DT + TN_DT + FP_DT + FN_DT)Accuracy_DT**Output**: 0.71

IX~v ||决策树算法的精度

Precision_DT = TP_DT / (TP_DT + FP_DT)Precision_DT**Output**: 0.6601941747572816

IX~vi ||召回决策树算法

Recall_DT = TP_DT / (TP_DT + FN_DT)Recall_DT**Output**: 0.7472527472527473

IX~vii ||决策树算法的 F1 得分

F1_Score_DT = 2 * Precision_DT * Recall_DT / (Precision_DT + Recall_DT)F1_Score_DT**Output**: 0.7010309278350515

|| X ||随机森林

最后，我使用了随机森林算法，这只是一些决策树的组合。在我的例子中，我选择使用 300 棵树，但是我可以根据我想要的模型精度来改变这个数字。

X～I | |将随机森林分类拟合到训练集

classifier = RandomForestClassifier(n_estimators = 300, criterion = ‘entropy’, random_state = 0)classifier.fit(X_train, y_train)**Output**: RandomForestClassifier(bootstrap=True, class_weight=None, criterion=’entropy’,max_depth=None,max_features=’auto’,max_leaf_nodes=None,min_impurity_decrease=0.0,min_impurity_split=None,min_samples_leaf=1, min_samples_split=2,min_weight_fraction_leaf=0.0, n_estimators=300, n_jobs=None,oob_score=False, random_state=0, verbose=0, warm_start=False)

X~ii ||预测测试集结果

y_pred_RF = classifier.predict(X_test)y_pred_RF**Output**: array([0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0])

X~iii ||制作混淆矩阵

cm_RF = confusion_matrix(y_test, y_pred_RF) cm_RF**Output**: array([[87, 10],[47, 56]])*# Calculating True/False Positives/Negatives* TP_RF = 56 *#True Positives (Random Forest)* TN_RF = 87 *#True Negatives (Random Forest)* FP_RF = 47 *#False Positives (Random Forest)* FN_RF = 10 *#False Negatives (Random Forest)*

X~iv ||随机森林的精度

Accuracy_RF = (TP_RF + TN_RF) / (TP_RF + TN_RF + FP_RF + FN_RF)Accuracy_RF**Output**: 0.715

x～v | |随机森林的精度

Precision_RF = TP_RF / (TP_RF + FP_RF)Precision_RF**Output**: 0.5436893203883495

X~vi ||随机森林的回忆

Recall_RF = TP_RF / (TP_RF + FN_RF)Recall_RF**Output**: 0.8484848484848485

X~vii ||随机森林 F1 得分

F1_Score_RF = 2 * Precision_RF * Recall_RF / (Precision_RF + Recall_RF)F1_Score_RF**Output**: 0.6627218934911243

XI ||对比模型

在最后一部分，我将比较我使用的每种算法的准确度、精确度、召回率和 F1 值。我将把它们绘制在条形图上，以图形方式展示不同型号之间的比较。

Xi～I | |比较模型精度

Accuracy = [Accuracy_RF, Accuracy_DT, Accuracy_NB]
Methods = [‘Random_Forest’, ‘Decision_Trees’, ‘Naive_Bayes’]
Accuracy_pos = np.arange(len(Methods))plt.bar(Accuracy_pos, Accuracy)
plt.xticks(Accuracy_pos, Methods)
plt.title(‘comparing the accuracy of each model’)plt.show()

正如我们在上面的柱状图中看到的，朴素贝叶斯在所有算法中具有最高的准确性，有 73%的正确预测。决策树和随机森林算法也很接近，准确率分别为 71%和 71.5%。

XI~ii ||比较模型精度

Precision = [Precision_RF, Precision_DT, Precision_NB]
Precision_pos = np.arange(len(Methods))plt.bar(Precision_pos, Precision)
plt.xticks(Precision_pos, Methods)
plt.title(‘comparing the precision of each model’)plt.show()

朴素贝叶斯是最精确的模型，精度为 88.35%，而决策树的精度为 66%。随机森林的准确率最低，约为 54.4%。

XI~iii ||对比车型召回

Recall = [Recall_RF, Recall_DT, Recall_NB]
Recall_pos = np.arange(len(Methods))plt.bar(Recall_pos, Recall)
plt.xticks(Recall_pos, Methods)
plt.title(‘comparing the recall of each model’)plt.show()

随机森林的召回率最高，约为 84.8%，而决策树的召回率为 74.7%。朴素贝叶斯的召回率最低，为 68.4%

XI~iv ||对比 F1 车型分数

F1_Score = [F1_Score_RF, F1_Score_DT, F1_Score_NB]F1_Score_pos = np.arange(len(Methods))plt.bar(F1_Score_pos, F1_Score)plt.xticks(F1_Score_pos, Methods)plt.title(‘comparing the F1 Score of each model’)plt.show()

• 朴素贝叶斯的 F1 值最高，为 77.1%
• 决策树的 F1 值为 70.1%。
• 随机森林的 F1 得分最低，为 66.2%

十二||结论

平均而言，我们的模型大约有 71.8%的准确率。虽然这可能意味着机器无法准确预测每一篇评论，但它也向我们展示了我们的模型没有过度拟合数据的证据。过度拟合是一种建模错误，发生在函数与有限的一组数据点过于接近的时候。过度拟合模型通常发生在使用过于复杂的模型来解释数据中的特质时。然而，由于我们的模型正在被训练成像人脑一样思考，因此可以公平地假设，即使是人类也无法 100%地预测评论是正面还是负面的。这实际上取决于数据及其处理方式。

那么这个模型的最佳算法是什么呢？在本项目使用的 3 种算法中，最准确和精确的是朴素贝叶斯算法。

然而，我们的随机森林算法的召回率是最高的。这意味着随机森林算法实际上通过将它标记为阳性(真阳性)来计算我们的模型捕获了多少实际阳性。当存在与假阴性相关联的高成本时，这将是我们用来选择最佳模型的良好指标。

事实存在于我们的 F1 分数中，这实际上可能是在所选的三个模型中哪个模型最好的最佳预测器。朴素贝叶斯算法具有最高的 F1 分数，这意味着它定义了特定模型的召回率和精确度之间的关系。如果我们需要在精确度和召回率之间寻求平衡，并且如果存在不均匀的类别分布(大量实际否定)，F1 分数可能是更好的衡量标准。

感谢阅读！希望你学到了有用的东西。

关注 Rohan Gupta，了解更多与数据科学和机器学习相关的内容

将人脸识别构建为 REST API

原文：https://towardsdatascience.com/build-face-recognition-as-a-rest-api-4c893a16446e?source=collection_archive---------4-----------------------

有很多开源的人脸识别包，比如 face_recognition ，你可以很容易地将它们安装在 Linux 服务器上。但是在移动和物联网设备上部署它们是非常困难或者不可能的。一种选择是使用机器学习移动框架，如 TensorFlow Lite 来调用预先训练好的模型。

但是有更简单的选择吗？是啊！随着 5G 的到来，上传 100KB 的图像只需 0.01 秒，速度约为 100Mbps ，因此我们可以部署几乎所有东西，包括服务器端的人脸识别服务和客户端的轻量级应用。这篇文章将展示如何使用 Python Flask 在 Linux 服务器上为 face_recognition 构建一个 RESTful API。

人脸识别项目

face_recognition 是一个基于 dlib 的非常棒的人脸识别开源项目，正如它自己所描述的:

世界上最简单的 Python 面部识别 api 和命令行

只需几行 Python 代码，就可以进行人脸比对、人脸检测、面部特征查找。

例如，运行示例find _ face _ features _ in _ picture . py(只有 40 行代码)获取一幅奥巴马的图像，您可以得到如下绘制的所有面部特征。

要在 Linux 服务器上安装它，你可以遵循 Github 上 face_recognition 项目中的步骤，或者只需下载预配置的虚拟机。对于 Windows 用户，Sasiwut Chaiyadecha 提供的步骤对我很管用。

构建 REST API

让我们使用 face_recognition 包定义两个 API。

• 对比两张脸:上传两张图片，返回真/假进行匹配
• 从已知的数据集中识别一张脸:上传一张图片并返回这个人的名字。

面部识别功能

在文件 face_util.py 中为这两个 API 定义了两个人脸识别函数作为 util。

第一个函数 compare_faces 比较两个图像文件，如果两个图像中的人脸是同一个人，则返回 True。

face_util_part1.py

第二个函数 face_rec 检查图像文件中的人脸是否是数据集中的已知人脸，并返回人名。在这个例子中有两个已知的面。

face_util_part2.py

带烧瓶的 REST API

有了上面的函数，我们可以很容易地用 Flask 定义 REST API，如下。

第一个 API 是 face_match 。它从 POST 请求的表单数据中获取两个图像文件，并调用 compare_faces 来检查它们是否匹配，然后返回一个 JSON 格式的结果。

flask_server_v1_part1.py

第二个 API 是 face_rec，它取一个图像文件作为输入，调用 face_rec 检查是否是已知人脸，然后以 JSON 格式返回人名。

flask_server_v1_part2.py

你可以在这里下载完整的 flask_server_v1.py 文件。

通过pip install -U flask安装烧瓶模块，然后运行python flask_server_v1.py启动服务器 API。启动输出如下所示。

* Serving Flask app "flask_server_v1" (lazy loading)
...
 * Debug mode: on
 * Running on [http://0.0.0.0:5001/](http://0.0.0.0:5001/) (Press CTRL+C to quit)

您可以使用以下 URL 以 POST 表单数据格式访问这两个 API:

• 比较两张脸 : http:// <服务器 IP 地址> : 5001/face_match
• 认个脸: http:// <服务器 IP 地址> : 5001/face_rec

REST API 客户端示例

您可以使用任何编程语言调用 API。我只是以 Python 为例。它需要请求模块，你可以通过pip install -U requests安装。

在第一个例子中，我们用同一个人的两幅图像调用 face_match API。

demo_client_part1.py

通过python demo_client_part1.py运行示例，您将得到如下响应:

{"match": true}

在第二个例子中，我们调用 face_rec API 来查找一个人的名字。

demo_client_part2_v1.py

运行脚本，您将得到如下响应:

{"name": "Obama"}

了解发布表单数据

如果你已经知道 HTML 表单数据，跳过这一节。

表单数据只不过是用户提交给服务器端的 HTML 表单。检查不同的 HTML 表单。例如，一个简单的输入表单如下所示。

当您单击 Submit 时，它实际上向 web 服务器发送一个 HTTP POST 请求，其中包含如下数据:

在我们的例子中，我们使用文件形式。为了更好地理解它，让我们修改 face_rec API，以便当用户通过 GET 访问 API 时返回一个 HTML 表单页面，即在 web 浏览器中键入 URL，当请求内容是 POST 时打印它。

首先，我们定义了一个新函数 print_request() 来打印 POST 请求的 URL、键头和正文内容。应用了一个技巧，用字符串'< raw image data >'替换 raw image data，这样我们就可以打印完整的 POST 请求。

flask_server_v2_part1.py

然后我们修改 face_rec API 如下:

• 在方法中添加 GET 支持。(第一行)
• 如果是 POST，打印请求。(第 3 行)
• 如果是 GET，返回一个 HTML 文件表单页面。(第 12–20 行)

flask_server_v2_part2.py

你可以在这里下载完整的 flask_server_v2.py 。

运行新的服务器 API python flask_server_v2.py，然后打开 web 浏览器，输入 face_rec URL，例如 http://127.0.0.1: 5001/face_rec。

你会看到上面的网页，点击浏览选择一个图像文件，然后点击上传按钮。它将向服务器端发送一个包含所选文件的 POST 请求，即调用 face_rec API。因此您将在浏览器上获得 API 响应。

同时，POST 请求内容将在服务器端打印出来，如下所示。

Base64 图像编码

表单数据传输图像数据是有效的，因为数据是直接以原始二进制传输的。但是如果你想以 JSON body 格式传输图像， base64 编码是一种流行的解决方案，它将二进制数据转换成可打印的 ASCII 文本字符串，但是有 33%的开销，即(8–6)/6。

有了 Python base64 库，简直易如反掌。只需调用 b64encode 和 b64decode 函数。但是有一个技巧，你需要将 b64encode 的字节字符串输出转换为普通字符串，例如 b'abc '转换为' abc '，然后再将其传递给 JSON 对象，因为 JSON 不支持 Python 字节字符串。

我们可以如下使用 JSON 格式重新编写 face_rec API 客户端。

base64 encode client

你可以在这里下载完整的客户端脚本 v3 。

并相应地修改服务器端以支持 JSON 格式，如下所示。

base64 encode REST API server

我们将 base64 字符串解码回二进制数据，并将其保存为图像文件，然后调用我们在基于表单数据的 API 中使用的相同的 face_rec 函数。比较帖子内容长度，你会看到 33%的开销如下。

Peter2.jpg file size: 89KBPost form data content length: 91162Post base64 data content length: 121396(121396 - 91162) / 91162 = 33%

你可以在这里找到完整的服务器端脚本 v3。

进一步的工作

您可以向 API 添加更多功能，例如，返回面部位置和面部特征，这样您就可以在移动设备上实现与在 Linux 服务器上相同的功能。

我已经实现了一个使用 REST API 绘制面部位置和面部特征的版本，并带有额外的参数，如果感兴趣，你可以在这里下载完整的库。

感谢阅读到此结束。

领英

自己构建—使用 Keras/TensorFlow 模型的聊天机器人 API

原文：https://towardsdatascience.com/build-it-yourself-chatbot-api-with-keras-tensorflow-model-f6d75ce957a5?source=collection_archive---------0-----------------------

在 Keras/TensorFlow 模型上构建简单聊天机器人的分步解决方案及源代码

Source: Pixabay

构建自己的聊天机器人(或助手，这个词是聊天机器人的一个新的流行术语)并不像你想象的那么复杂。各种聊天机器人平台正在使用分类模型来识别用户意图。虽然很明显，在现有平台的基础上构建聊天机器人时，你会得到一个很好的提示，但研究背景概念并尝试自己构建它不会有什么坏处。为什么不自己用一个类似的模型。聊天机器人实施的主要挑战是:

1. 对用户输入进行分类以识别意图(这可以通过机器学习来解决，我正在使用带有 TensorFlow 后端的 Keras)
2. 保持上下文。这部分是编程，这里没有什么 ML 相关的。我使用 Node.js 后端逻辑来跟踪对话上下文(在上下文中，通常我们不需要对用户意图进行分类——用户输入被视为聊天机器人问题的答案)

我的 GitHub repo(开源)上提供了本文的完整源代码和自述说明。

这是实现中使用的 Python 库的列表。 Keras 深度学习库用于建立分类模型。Keras 在 TensorFlow 后端上运行培训。兰开斯特词干库用于折叠不同的单词形式:

import nltk
from nltk.stem.lancaster import LancasterStemmer
stemmer = LancasterStemmer()# things we need for Tensorflow
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation, Dropout
from keras.optimizers import SGD
import pandas as pd
import pickle
import random

聊天机器人的意图和学习模式在普通的 JSON 文件中定义。不需要有庞大的词汇量。我们的目标是建立一个特定领域的聊天机器人。也可以为小词汇量创建分类模型，它将能够识别为训练提供的一组模式:

chatbot training data

在我们开始分类模型训练之前，我们需要首先建立词汇。模式被处理以构建词汇表。每个单词被词干化以产生通用词根，这将有助于覆盖用户输入的更多组合:

words = []
classes = []
documents = []
ignore_words = ['?']
# loop through each sentence in our intents patterns
for intent in intents['intents']:
    for pattern in intent['patterns']:
        # tokenize each word in the sentence
        w = nltk.word_tokenize(pattern)
        # add to our words list
        words.extend(w)
        # add to documents in our corpus
        documents.append((w, intent['tag']))
        # add to our classes list
        if intent['tag'] not in classes:
            classes.append(intent['tag'])# stem and lower each word and remove duplicates
words = [stemmer.stem(w.lower()) for w in words if w not in ignore_words]
words = sorted(list(set(words)))# sort classes
classes = sorted(list(set(classes)))# documents = combination between patterns and intents
print (len(documents), "documents")
# classes = intents
print (len(classes), "classes", classes)
# words = all words, vocabulary
print (len(words), "unique stemmed words", words)

这是词汇创造的输出。共有 9 个意图(类别)和 82 个词汇:

45 documents
9 classes ['adverse_drug', 'blood_pressure', 'blood_pressure_search', 'goodbye', 'greeting', 'hospital_search', 'options', 'pharmacy_search', 'thanks']
82 unique stemmed words ["'s", ',', 'a', 'advers', 'al', 'anyon', 'ar', 'awesom', 'be', 'behavy', 'blood', 'by', 'bye', 'can', 'caus', 'chat', 'check', 'could', 'dat', 'day', 'detail', 'do', 'dont', 'drug', 'entry', 'find', 'for', 'giv', 'good', 'goodby', 'hav', 'hello', 'help', 'hi', 'hist', 'hospit', 'how', 'i', 'id', 'is', 'lat', 'list', 'load', 'loc', 'log', 'look', 'lookup', 'man', 'me', 'mod', 'nearby', 'next', 'nic', 'of', 'off', 'op', 'paty', 'pharm', 'press', 'provid', 'react', 'rel', 'result', 'search', 'see', 'show', 'suit', 'support', 'task', 'thank', 'that', 'ther', 'til', 'tim', 'to', 'transf', 'up', 'want', 'what', 'which', 'with', 'you']

训练不会基于单词的词汇来运行，单词对于机器来说是没有意义的。我们需要将单词翻译成包含 0/1 数组的单词包。数组长度将等于词汇大小，当当前模式中的一个单词位于给定位置时，将设置 1:

# create our training data
training = []
# create an empty array for our output
output_empty = [0] * len(classes)# training set, bag of words for each sentence
for doc in documents:
    # initialize our bag of words
    bag = []
    # list of tokenized words for the pattern
    pattern_words = doc[0]
    # stem each word - create base word, in attempt to represent related words
    pattern_words = [stemmer.stem(word.lower()) for word in pattern_words]
    # create our bag of words array with 1, if word match found in current pattern
    for w in words:
        bag.append(1) if w in pattern_words else bag.append(0)

    # output is a '0' for each tag and '1' for current tag (for each pattern)
    output_row = list(output_empty)
    output_row[classes.index(doc[1])] = 1

    training.append([bag, output_row])# shuffle our features and turn into np.array
random.shuffle(training)
training = np.array(training)# create train and test lists. X - patterns, Y - intents
train_x = list(training[:,0])
train_y = list(training[:,1])

训练数据— X(转换为数组[0，1，0，1…，0]的模式)，Y(转换为数组[1，0，0，0，…，0]的 intents，intents 数组将只有一个 1)。模型是用 Keras 构建的，基于三层。根据我的实验，三层提供了良好的结果(但这都取决于训练数据)。分类输出将是多类数组，这将有助于识别编码意图。使用 softmax 激活生成多类分类输出(结果返回 0/1 的数组:[1，0，0，…，0] —该集合标识编码意图):

# Create model - 3 layers. First layer 128 neurons, second layer 64 neurons and 3rd output layer contains number of neurons
# equal to number of intents to predict output intent with softmaxmodel = Sequential()
model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(len(train_y[0]), activation='softmax'))

使用 SGD 优化器编译 Keras 模型:

# Compile model. Stochastic gradient descent with Nesterov accelerated gradient gives good results for this modelsgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])

拟合模型—执行训练并构建分类模型。我在 200 次迭代中执行训练，批量大小= 5:

# Fit the modelmodel.fit(np.array(train_x), np.array(train_y), epochs=200, batch_size=5, verbose=1)

模型已建立。现在我们可以定义两个辅助函数。函数 bow 帮助将用户句子翻译成数组为 0/1 的单词包:

def clean_up_sentence(sentence):
    # tokenize the pattern - split words into array
    sentence_words = nltk.word_tokenize(sentence)
    # stem each word - create short form for word
    sentence_words = [stemmer.stem(word.lower()) for word in sentence_words]
    return sentence_words# return bag of words array: 0 or 1 for each word in the bag that exists in the sentence
def bow(sentence, words, show_details=True):
    # tokenize the pattern
    sentence_words = clean_up_sentence(sentence)
    # bag of words - matrix of N words, vocabulary matrix
    bag = [0]*len(words)  
    for s in sentence_words:
        for i,w in enumerate(words):
            if w == s: 
                # assign 1 if current word is in the vocabulary position
                bag[i] = 1
                if show_details:
                    print ("found in bag: %s" % w)return(np.array(bag))

看看这个例子——把这个句子翻译成一个单词包:

p = bow("Load blood pessure for patient", words)
print (p)
print (classes)

当该函数在 chatbot 词汇表的句子中找到一个单词时，它会在数组中的相应位置设置 1。该数组将被发送到模型进行分类，以识别其所属的意图:

found in bag: load
found in bag: blood
found in bag: for
found in bag: paty
[0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]

将训练好的模型保存到 pickle 文件中是一个很好的做法，以便能够重用它来通过 Flask REST API 发布:

# Use pickle to load in the pre-trained model
global graph
graph = tf.get_default_graph()with open(f'katana-assistant-model.pkl', 'rb') as f:
    model = pickle.load(f)

在通过 Flask REST API 发布模型之前，运行一个额外的测试总是好的。使用 model.predict 函数对用户输入进行分类，并根据计算出的概率返回意图(可以返回多个意图):

def classify_local(sentence):
    ERROR_THRESHOLD = 0.25

    # generate probabilities from the model
    input_data = pd.DataFrame([bow(sentence, words)], dtype=float, index=['input'])
    results = model.predict([input_data])[0]
    # filter out predictions below a threshold, and provide intent index
    results = [[i,r] for i,r in enumerate(results) if r>ERROR_THRESHOLD]
    # sort by strength of probability
    results.sort(key=lambda x: x[1], reverse=True)
    return_list = []
    for r in results:
        return_list.append((classes[r[0]], str(r[1])))
    # return tuple of intent and probability

    return return_list

句子分类示例:

classify_local('Fetch blood result for patient')

意图计算正确:

found in bag: blood
found in bag: result
found in bag: for
found in bag: paty[('blood_pressure_search', '1.0')]

为了通过 REST 端点发布相同的函数，我们可以将包装到 Flask API 中:

app = Flask(__name__)
CORS(app)[@app](http://twitter.com/app).route("/katana-ml/api/v1.0/assistant", methods=['POST'])
def classify():
    ERROR_THRESHOLD = 0.25

    sentence = request.json['sentence']

    # generate probabilities from the model
    input_data = pd.DataFrame([bow(sentence, words)], dtype=float, index=['input'])
    results = model.predict([input_data])[0]
    # filter out predictions below a threshold
    results = [[i,r] for i,r in enumerate(results) if r>ERROR_THRESHOLD]
    # sort by strength of probability
    results.sort(key=lambda x: x[1], reverse=True)
    return_list = []
    for r in results:
        return_list.append({"intent": classes[r[0]], "probability": str(r[1])})
    # return tuple of intent and probability

    response = jsonify(return_list)
    return response# running REST interface, port=5000 for direct test, port=5001 for deployment from PM2
if __name__ == "__main__":
    app.run(debug=False, host='0.0.0.0', port=5001)

我已经解释了如何实现分类部分。在帖子开头引用的 GitHub repo 中，你会找到如何维护上下文的完整例子。上下文由用 JavaScript 编写并运行在 Node.js 后端的逻辑维护。一旦意图被分类并且后端逻辑找到了上下文的起点，就必须在意图列表中定义上下文流——我们进入循环并询问相关的问题。上下文处理有多高级完全取决于后端实现(这超出了现阶段机器学习的范围)。

聊天机器人用户界面:

Chatbot UI implemented with Oracle JET

使用概率模型和 AWS Lambda 函数构建智能(er)应用程序

原文：https://towardsdatascience.com/build-smart-er-applications-with-probabilistic-models-and-aws-lambda-functions-da982d69cab1?source=collection_archive---------22-----------------------

用 WebPPL 概率程序为端点供电的快速、廉价和无服务器的方法。

哎呀！…我需要再次部署一个模型

"概率是生活的向导."―西塞罗

当今天的酷孩子忙着画张量和画 PyTorch 时，更酷的孩子越来越喜欢概率编程(PP)——例如参见 Pyro ， Figaro ， Stan ，Infer.NET(想了解更多关于 PP 的哲学倾向的读者可以从我们自己关于概念学习的观点文章开始

如果你是一名数据科学家/数据工程师/人工智能什么的，并且你正在考虑给你现有的数据管道添加一些概率魔法——而不打扰你的 devOps 团队和花费云资金——你可能会喜欢让微服务以一种快速、廉价和直接的方式公开模型的想法。

在这篇文章中，我们利用无服务器和 AWS lambda 功能在几分钟内部署一个 WebPPL 驱动的端点。正如我们将看到的，新部署的端点，加上其他无服务器代码(例如，一个单页 web 应用程序)，成为一个可以在组织内共享的原型，用于快速反馈和快速迭代。

这是“懒惰开发”系列中之前帖子的续篇，该系列以带有 Tensorflow 模型和 Spark 决策树的 AWS Lambda 函数为特色。

先决条件

在深入研究代码之前，请确保:

1. 拥有一个安装了 npm 的工作节点环境；
2. 拥有一个 AWS 帐户来将代码部署到AWS Lambda；
3. 设置无服务器(遵循此处的说明；记得设置你的 AWS 凭证)；
4. 如果你有一个 WebPPL 模型准备好了，太好了(100 奖励点！);如果没有，不用担心:我们将一起发货！

像往常一样，你可以在我们的 GitHub 页面中找到所有代码:让我们开始工作吧。

(玩具)概率应用程序

“所有的模型都是错的，但有些是有用的。”―G .盒子

如果说 Javascript 中程序的语义是从程序到执行的函数，那么它的 PP 表亲 WebPPL 的语义是从程序到执行的分发的函数。换句话说，当你运行这个程序时:

结果是结果的分布，通过 I)列举随机变量(die1和die2)的可能值，ii)以die1 + die2之和的值(8)为条件，即拒绝条件为不满足的所有运行:

Frequency distribution for the value of the first die, conditional on the sum of the two being 8.

由于这不是对概率规划的介绍，因此我们仅简单提及 PP 原则已经成功应用于各种各样的现象，例如技能评级、计算机视觉和基于图像的推理(参见此处和此处)、程序合成、不确定性下的决策， 自然语言语义学和语用学，以及显然在认知科学中模拟人类推理的棘手任务——非懒惰读者被强烈鼓励进一步探索理论景观并了解这一工具家族的许多优点(例如，在服务预测时量化模型不确定性)。

正如所料，我们将使用的语言是 WebPPL ，一个纯粹的函数 Javascript 子集，增加了概率原语，如sample(一个函数，不出所料，从分布中采样值)。为了展示 WebPPL 的概率性质，我们将从高斯过程中采样并提取数据点 ( GP ): GPs 非常酷，非常通用并在数据科学社区中得到越来越多的关注(显然，我们讨论的内容并不特定于 GPs ，因此可以应用于其他类型的 WebPPL 程序，例如，对计算机视觉的推理

Charting priors from GPs with the RBF kernel (mean=0, sigma=1).

预期的工作流程如下:

A lambda-powered web app for prototyping and data viz. with WebPPL and standard JS libraries.

• 用户从公共 URL 请求 web 应用程序；
• 一个λ函数被 API 网关调用；响应是简单的 HTML 代码，包含一个基本表单，要求用户输入一些变量；
• 用户通过一个 HTML 按钮提交她的选择，这个按钮使用 JQuery 向模型端点发送一个 AJAX 请求；
• API 网关调用 Lambda 函数；响应是在用户输入上运行所选择的 WebPPL 程序(下面将详细介绍)的输出；
• 最后，一些 Chart.js 代码将端点响应映射到一个漂亮的数据可视化。

在下一节中，我们将看到如何在几秒钟内从一个存在于 powerpoint 中的想法变成一个有效的 web 应用程序。

空谈不值钱，给我看看代码！

“给一个人一个程序，让他沮丧一天。
教一个人编程，挫他一辈子。”―米·瓦西姆

我们的项目功能仅依赖于项目中的两个文件:

• handler.js包含上述两个功能的代码；
• serverless.yml是一个标准的 yml 文件，描述了运行这两个功能的 AWS 基础设施。

serverless.yml是一个普通的无服务器文件，它通过 API Gateway 将 lambda 函数公开为端点:这里没有什么特别的(例如，万维网上已经充满了关于这个设置的教程，包括我们自己的)。

所有神奇的事情都发生在这里。该结构确实相当简单，因此我们将重点介绍一些关键特性:

• WebPPL 是用顶部的webppl = require('webppl')语法导入的；
• app是一个简单的函数，返回一个完整的 HTML 页面，包括在末尾添加所需输入字段和基本交互的 JQuery 函数——HTML 代码简单地存储为一个字符串，并在响应中返回特定的headers；
• model函数是实际运行 WebPPL 代码的函数:它从一些简单的参数检查/验证/类型转换开始，然后使用webppl.run(CODE)执行在const code变量中指定的代码。请注意，为了向模型传递查询参数，我们使用了书中最简单的技巧，即构建一个包含脚本变量的代码片段(作为字符串),并确保code使用输入变量的正确名称。一个显而易见的选择是全球商店，但是如果没有特别的顾虑(就像在这个例子中)，我们的简单策略就足够了。

要查看项目的运行情况，只需克隆 repo ，打开终端，cd进入文件夹，下载 WebPPL 依赖关系:

npm install webppl

然后最后键入:

serverless deploy

如果无服务器安装正确，第一个deploy触发 AWS 上所需资源的创建(未来的deploy命令会更快)。等待一段时间后，您应该会在终端中看到一条成功消息:

Congratulations, your lambdas are up and running!

如果你将浏览器指向在终端中找到的/app URL(见上图中的“端点”)，一切都应该如预期的那样工作:

Our fantastic web app is up and running (original video here)!

当您对原型满意并准备好清理资源时，只需使用remove 命令来安全地移除堆栈:

serverless remove

后续步骤

“一千个模特的旅程从一个(几乎)老子开始”

在这篇的简短帖子中，我们展示了如何将概率模型部署到 AWS，并通过标准 GET 请求用几行代码按需提供预测:

这种设置快速、可靠且廉价(如果不是免费的，因为前 100 万个请求/mo 完全在杰夫·贝索斯上)。

要使提供的模板适应您自己的原型，只需更改model函数中的 WebPPL 代码，然后相应地调整 HTML 输入字段、参数解析和数据可视化:在几分钟内，您将能够与任何人分享您非凡的贝叶斯建模的结果，或者生成有洞察力的可视化来帮助您的科学探索。

在可视化方面， WebPPL viz 模块可能会有一些启发来概括现在简单而杂乱的图表:使用 chart.js / d3 围绕 WebPPL 模型的主要用例构建一个可重用的包装器应该不会花费太长时间对于非懒惰读者的练习:对于线性回归案例，例如单一回归来说，什么可能是有趣且引人入胜的可视化].

在建模方面，我们选择了 GP s 来提供一个在浏览器窗口中看起来不错的端到端概率程序，但显然概率人工智能的世界是伟大的，并且——像宇宙一样——在不断扩展:如果你想要一些 PP 建模的想法，这里有一吨很酷的东西。

最后，如果你真的喜欢这个设置，你认为它已经准备好了，一定要添加测试，错误处理和所有其他重要的东西，这个教程太短了，无法包含。

快乐(概率)编码！

再见，太空牛仔

如果您有问题、反馈或评论，请与jacopo . taglia bue @ tooso . ai分享您的故事。

别忘了从 Linkedin 、 Twitter 和 Instagram 上的 Tooso 获取最新消息。

感谢

如果没有 Tooso 的高级工程师和节点向导 Luca，这一切都是不可能的:Luca 建立了我们的第一个 WebPPL-to-lambda 游乐场，并耐心地回答了我所有(愚蠢的)节点问题。

这篇文章中大多数好的想法都是卢卡的，剩下的错误都是我的。

构建正确的自动编码器——使用 PCA 原理进行调整和优化。第一部分

原文：https://towardsdatascience.com/build-the-right-autoencoder-tune-and-optimize-using-pca-principles-part-i-1f01f821999b?source=collection_archive---------2-----------------------

在这里，我们将学习自动编码器的期望属性，这些属性源自它与 PCA 的相似性。由此，我们将在第二部分中为自动编码器构建定制约束，以进行调整和优化。

<了解深度学习，了解更多> >

深度学习 API 的可用性，如 Keras 和 TensorFlow，使模型建立和实验变得极其容易。然而，对基本面缺乏清晰的理解可能会让我们在最佳模式的竞赛中迷失方向。在这样的比赛中达到最佳模式是靠运气的。

在这里，我们将了解自动编码器所需的基本属性。这将为自动编码器调整和优化提供一个很好的指导方法。在第一部分中，我们将重点学习这些属性及其优点。在第二部分，我们将开发自定义层和约束来合并属性。

我们将在这里学习的主要概念是，自动编码器与主成分分析(PCA) 直接相关，这将使我们能够构建一个正确的自动编码器。一个“正确的”自动编码器在数学上意味着一个适定的自动编码器。一个适定的模型更容易调整和优化。

自动编码器相对于PCA 、

• 线性激活的自动编码器近似于 PCA。数学上，最小化 PCA 建模中的重建误差与单层线性自动编码器相同。
• 自动编码器将 PCA 扩展到非线性空间。换句话说，自动编码器是 PCA 的非线性扩展。

因此，自动编码器应该理想地具有 PCA 的特性。这些属性是，

• 绑定权重:编码器和相应解码器层上的权重相等(在下一节的图 1 中阐明)。
• 正交权重:每个权重向量都是相互独立的。
• 不相关特征:编码层的输出不相关。
• 单位定额:一层上的权重有单位定额。

然而，大多数教程中解释的自动编码器，例如在 Keras【1】中构建自动编码器，没有这些属性。缺少这一点使它们不是最佳的。

因此，对于一个适定的自动编码器来说，结合这些属性是很重要的。通过合并它们，我们还将

• 有正规化。正交性和单位范数约束作为正则化。此外，正如我们将在后面看到的，绑定权重将网络参数的数量减少了近一半，这是另一种正则化类型。
• 解决爆炸和消失的渐变。单位范数约束防止权重变大，因此解决了爆炸梯度问题。此外，由于正交性约束，只有重要的/信息性的权重是非零的。因此，在反向传播期间，足够的信息流过这些非零权重，从而避免消失梯度。
• 有更小的网络:没有正交性，编码器有冗余的权重和特征。为了补偿冗余，增加了编码器的尺寸。相反，正交性确保每个编码特征都有一条唯一的信息——独立于其他特征。这消除了冗余，并且我们可以用较小的编码器(层)编码相同数量的信息。

通过一个更小的网络，我们让 Autoencoder 更接近边缘计算。

本文将通过展示

1. PCA 和 Autoencoder 之间的架构相似性，以及
2. 传统自动编码器的次优性。

本文将在第二部分中继续，详细介绍优化自动编码器的步骤。在第二部分的中，我们发现优化将自动编码器重构误差提高了 50%以上。

本文假设读者对 PCA 有基本的了解。如果不熟悉，请参考了解 PCA【2】。

PCA 和自动编码器之间的架构相似性

Figure 1. Single layer Autoencoder vis-à-vis PCA.

为简单起见，我们将线性单层自动编码器与 PCA 进行比较。PCA 建模有多种算法。其中之一是通过最小化重建误差进行估计(参见[ 3 ])。遵循该算法可以更清楚地理解 PCA 和自动编码器之间的相似之处。

图 1 显示了单层线性自动编码器。如图底部所示，编码过程类似于 PC 变换。PC 变换将原始数据投影到主成分上，以产生正交特征，称为主得分。类似地，解码过程类似于从主要分数重构数据。在自动编码器和 PCA 中，可以通过最小化重建误差来估计模型权重。

在下文中，我们将通过展示关键的自动编码器组件及其在 PCA 中的等效组件来进一步阐述图 1。

假设我们有带有 p 特征的数据。

输入层—数据样本。

• 在自动编码器中，使用尺寸为 p. 的输入层输入数据
• 在 PCA 中，数据作为样本输入。

编码——数据在主成分上的投影。

• 编码层的大小为 k 。在 PCA 中， k 表示选择的主成分(PCs)的数量。
• 在两者中，我们都有 k < p 进行降维。 k ≥ p 导致过代表模型，因此(接近)零重建误差。
• 图 1 中编码层中的彩色单元是计算节点，其具有表示为p的权重，

也就是说，对于 1，…， k 中的每个编码节点，我们都有一个 p 维的权重向量。这相当于 PCA 中的一个特征向量。

• 自动编码器中的编码层输出是，

x 是输入， W 是权重矩阵。功能 g 是一个激活功能。 g ( Wx )是编码层的输出。如果激活是线性的，这相当于 PCA 中的主要分数。

解码——从主要分数中重建数据。

• 自动编码器和 PCA 重建中解码层的大小必须是输入数据的大小
• 在解码器中，数据从编码中被重构为，

类似地，在 PCA 中，它被重构为，

注意，我们在等式中有W’。4 和等式中的 W 。5.这是因为，默认情况下，编码器和解码器的权重不同。如果编码器和解码器权重与绑定，解码器和 PCA 重建将是相同的，即

解码器单元中的多种颜色表示编码器中不同单元中的权重出现在解码器中的相同单元中。

这就把我们带到了自动编码器和 PCA 之间的数学比较。

数学上，线性自动编码器将类似于 PCA if，

• 捆绑权重:在任何通用多层自动编码器中，编码器模块中的层 l 的权重等于解码器中从末端开始的层 l 的权重的转置。

• 正交权重:编码层上的权重是正交的(参见等式。7b)。可以在中间编码器层上实施相同的正交性约束以进行规则化。

• 不相关特征:PCA 的输出，即主分数，是不相关的。因此，编码器的输出应该具有，

• 单位范数:PCA 中的特征向量被约束为具有单位范数。如果没有这个约束，我们将得不到一个合适的解，因为只要向量的范数增加，投影的方差就可能变得任意大。出于同样的原因，编码层上的权重应该是单位范数(参见等式 1)。7d)。这个约束也应该应用于其他中间层以进行正则化。

正则无约束自动编码器的次优性

这里我们将在随机数据集上实现 PCA 和一个典型的无约束自动编码器。我们将展示它们的输出在上述各个方面的不同。这导致了次优的自动编码器。在这个讨论之后，我们将展示如何为正确的估计(第二部分)约束自动编码器。

完整的代码可在这里获得。

加载库

**from** **numpy.random** **import** seed
seed(123)
**from** **tensorflow** **import** set_random_seed
set_random_seed(234)

**import** **sklearn**
**from** **sklearn** **import** datasets
**import** **numpy** **as** **np**
**from** **sklearn.model_selection** **import** train_test_split
**from** **sklearn.preprocessing** **import** StandardScaler, MinMaxScaler
**from** **sklearn** **import** decomposition
**import** **scipy**

**import** **tensorflow** **as** **tf**
**from** **keras.models** **import** Model, load_model
**from** **keras.layers** **import** Input, Dense, Layer, InputSpec
**from** **keras.callbacks** **import** ModelCheckpoint, TensorBoard
**from** **keras** **import** regularizers, activations, initializers, constraints, Sequential
**from** **keras** **import** backend **as** K
**from** **keras.constraints** **import** UnitNorm, Constraint

生成随机数据

我们生成多元相关正态数据。数据生成的步骤在 GitHub 库中有详细说明。

n_dim = 5
cov = sklearn.datasets.make_spd_matrix(n_dim, random_state=None)
mu = np.random.normal(0, 0.1, n_dim)n = 1000X = np.random.multivariate_normal(mu, cov, n)X_train, X_test = train_test_split(X, test_size=0.5, random_state=123)# *Data Preprocessing* scaler = MinMaxScaler()
scaler.fit(X_train)X_train_scaled = scaler.transform(X_train)X_test_scaled = scaler.transform(X_test)

测试数据集将在第二部分中用于比较自动编码器重建精度。

自动编码器和 PCA 型号

我们安装了一个单层线性自动编码器，编码维数为两个。我们还为 PCA 安装了两个组件。

# *Fit Autoencoder*
nb_epoch = 100
batch_size = 16
input_dim = X_train_scaled.shape[1] *#num of predictor variables,* 
encoding_dim = 2
learning_rate = 1e-3

encoder = Dense(encoding_dim, activation="linear", input_shape=(input_dim,), use_bias = **True**) 
decoder = Dense(input_dim, activation="linear", use_bias = **True**)

autoencoder = Sequential()
autoencoder.add(encoder)
autoencoder.add(decoder)

autoencoder.compile(metrics=['accuracy'],
                    loss='mean_squared_error',
                    optimizer='sgd')
autoencoder.summary()

autoencoder.fit(X_train_scaled, X_train_scaled,
                epochs=nb_epoch,
                batch_size=batch_size,
                shuffle=**True**,
                verbose=0)# *Fit PCA*
pca = decomposition.PCA(n_components=2)pca.fit(X_train_scaled)

Figure 2. Structure of the single-layer Autoencoder.

从视觉上看，这里开发的编码器-解码器结构如下面的图 3 所示。该图有助于理解权重矩阵是如何排列的。

Figure 3. A simple linear Autoencoder to encode a 5-dimensional data into 2-dimensional features.

为了遵循 PCA 属性，图 3 中的自动编码器应该遵循等式中的条件。下面，我们将示出这种传统的自动编码器不满足它们中的任何一个。

1.捆绑重物

正如我们在下面看到的，编码器和解码器的权重是不同的。

w_encoder = np.round(autoencoder.layers[0].get_weights()[0], 2).T  *# W in Figure 3.*
w_decoder = np.round(autoencoder.layers[1].get_weights()[0], 2)  *# W' in Figure 3.*
print('Encoder weights **\n**', w_encoder)
print('Decoder weights **\n**', w_decoder)

2。权重正交性

如下所示，与 PCA 权重(即特征向量)不同，编码器和解码器上的权重不是正交的。

w_pca = pca.components_
np.round(np.dot(w_pca, w_pca.T), 3)

np.round(np.dot(w_encoder, w_encoder.T), 3)

np.round(np.dot(w_decoder, w_decoder.T), 3)

3。特征关联

在 PCA 中，特征是不相关的。

pca_features = pca.fit_transform(X_train_scaled)
np.round(np.cov(pca_features.T), 5)

但是编码特征是相关的。

encoder_layer = Model(inputs=autoencoder.inputs, outputs=autoencoder.layers[0].output)
encoded_features = np.array(encoder_layer.predict(X_train_scaled))
print('Encoded feature covariance\n', np.cov(encoded_features.T))

权重非正交性和特征相关性是不期望的，因为它带来了包含在编码特征中的信息的冗余。

4。单位定额

五氯苯甲醚重量的单位标准是 1。这是在 PCA 估计中应用的约束，以产生正确的估计。

print('PCA weights norm, \n', np.sum(w_pca ** 2, axis = 1))
print('Encoder weights norm, \n', np.sum(w_encoder ** 2, axis = 1))
print('Decoder weights norm, \n', np.sum(w_decoder ** 2, axis = 1))

Github 库

完整的代码可在这里获得。

[## cran 2367/PCA-自动编码器-关系

了解 PCA 和自动编码器之间的关系-cran 2367/PCA-自动编码器-关系

github.com](https://github.com/cran2367/pca-autoencoder-relationship/blob/master/pca-autoencoder-relationship.ipynb)

结论

因此，自动编码器模型是不适定的。不适定模型没有稳健的估计。这不利地影响了它的测试精度，即新数据的重建误差。

最近的几项研究进展是建立和利用正交条件来提高深度学习模型的性能。一些研究方向参考[ 4 ]和[ 5 ]。

在续集第二部分中，我们将实现自定义约束，将上述从 PCA 得到的属性合并到自动编码器中。我们将会看到，添加约束改善了测试重构误差。

去看续集，下集。

参考

1. 在 Keras 中构建自动编码器
2. 理解主成分分析
3. 主成分分析:利用重构误差的算法(第 15 页)。
4. 黄，雷等.正交权重归一化:深度神经网络中多重相关 stiefel 流形上的优化解。第三十二届 AAAI 人工智能大会。2018.
5. 使用内省对抗网络的神经照片编辑。arXiv 预印本 arXiv:1609.07093 (2016)。

构建正确的自动编码器——使用 PCA 原理进行调整和优化。第二部分

原文：https://towardsdatascience.com/build-the-right-autoencoder-tune-and-optimize-using-pca-principles-part-ii-24b9cca69bd6?source=collection_archive---------3-----------------------

在第一部分的延续中，我们将在这里定义并实现自定义约束，以构建一个适定的自动编码器。一个适定的自动编码器是一个正则化的模型，它改善了测试重建误差。

<了解深度学习，了解更多> >

去看前传第一部

在第一部分中，我们了解到 PCA 和自动编码器在架构上有相似之处。但是尽管如此，自动编码器本身并不具有 PCA 属性，例如正交性。我们知道，结合 PCA 属性将为自动编码器带来显著的好处，例如解决消失和爆炸梯度，以及通过正则化进行过拟合。

基于此，我们希望自动编码器继承的属性是:

1. 捆绑重物，
2. 正交权重，
3. 不相关的特征，以及
4. 单位定额。

在本文中，我们将

• 实现自定义层和约束来合并它们。
• 演示它们是如何工作的，以及它们带来的重构误差的改善。

这些实现将能够构造一个适定的自动编码器并对其进行优化。在我们的示例中，优化将重建误差提高了 50%以上。

注意:正则化技术，如辍学，是普遍使用的。但是没有一个适定的模型，这些方法需要更长的时间来优化。

下一节详细展示了该实现。读者可以跳至关键要点部分进行简要总结。

一个适配的自动编码器

Figure 1. Apply constraints for a well-posed Autoencoder.

我们将为随机生成的数据集开发一个具有五个特征的自动编码器。我们将数据集分为训练集和测试集。当我们添加约束时，我们将使用测试数据重构误差来评估性能。

本文包含实现细节，以帮助从业者尝试各种选择。完整的代码显示在这里。

导入库

from numpy.random import seed
seed(123)
from tensorflow import set_random_seed
set_random_seed(234)import sklearn
from sklearn import datasets
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn import decomposition
import scipyimport tensorflow as tf
from keras.models import Model, load_model
from keras.layers import Input, Dense, Layer, InputSpec
from keras.callbacks import ModelCheckpoint, TensorBoard
from keras import regularizers, activations, initializers, constraints, Sequential
from keras import backend as K
from keras.constraints import UnitNorm, Constraint

生成和准备数据

n_dim = 5
cov = sklearn.datasets.make_spd_matrix(n_dim, random_state=None)mu = np.random.normal(0, 0.1, n_dim)n = 1000X = np.random.multivariate_normal(mu, cov, n)X_train, X_test = train_test_split(X, test_size=0.5, random_state=123)# *Scale the data between 0 and 1.*
scaler = MinMaxScaler()
scaler.fit(X_train)X_train_scaled = scaler.transform(X_train)X_test_scaled = scaler.transform(X_test)X_train_scaled

估算参数

nb_epoch = 100
batch_size = 16
input_dim = X_train_scaled.shape[1] *#num of predictor variables,* 
encoding_dim = 2
learning_rate = 1e-3

基线模型

encoder = Dense(encoding_dim, activation="linear", input_shape=(input_dim,), use_bias = **True**) 
decoder = Dense(input_dim, activation="linear", use_bias = **True**)

autoencoder = Sequential()
autoencoder.add(encoder)
autoencoder.add(decoder)

autoencoder.compile(metrics=['accuracy'],
                    loss='mean_squared_error',
                    optimizer='sgd')
autoencoder.summary()

autoencoder.fit(X_train_scaled, X_train_scaled,
                epochs=nb_epoch,
                batch_size=batch_size,
                shuffle=**True**,
                verbose=0)

Figure 2.1. Baseline Model Parameters.

基线重建误差

train_predictions = autoencoder.predict(X_train_scaled)
print('Train reconstrunction error**\n**', sklearn.metrics.mean_squared_error(X_train_scaled, train_predictions))
test_predictions = autoencoder.predict(X_test_scaled)
print('Test reconstrunction error**\n**', sklearn.metrics.mean_squared_error(X_test_scaled, test_predictions))

Figure 2.2. Baseline Autoencoder Reconstruction Error.

自动编码器优化

Keras 提供了各种层和约束。对于单位定额，我们有一个可用的约束。对于其他人，我们将构建自定义层和约束。

1. 自定义图层:捆绑砝码。

有了这个自定义层，我们可以使编码器和解码器的权重相等。数学上，解码器权重的转置等于编码器权重(等式)。第一部分 7a)。

**class** **DenseTied**(Layer):
    **def** __init__(self, units,
                 activation=**None**,
                 use_bias=**True**,
                 kernel_initializer='glorot_uniform',
                 bias_initializer='zeros',
                 kernel_regularizer=**None**,
                 bias_regularizer=**None**,
                 activity_regularizer=**None**,
                 kernel_constraint=**None**,
                 bias_constraint=**None**,
                 tied_to=**None**,
                 **kwargs):
        self.tied_to = tied_to
        **if** 'input_shape' **not** **in** kwargs **and** 'input_dim' **in** kwargs:
            kwargs['input_shape'] = (kwargs.pop('input_dim'),)
        super().__init__(**kwargs)
        self.units = units
        self.activation = activations.get(activation)
        self.use_bias = use_bias
        self.kernel_initializer = initializers.get(kernel_initializer)
        self.bias_initializer = initializers.get(bias_initializer)
        self.kernel_regularizer = regularizers.get(kernel_regularizer)
        self.bias_regularizer = regularizers.get(bias_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)
        self.kernel_constraint = constraints.get(kernel_constraint)
        self.bias_constraint = constraints.get(bias_constraint)
        self.input_spec = InputSpec(min_ndim=2)
        self.supports_masking = **True**

    **def** build(self, input_shape):
        **assert** len(input_shape) >= 2
        input_dim = input_shape[-1]

        **if** self.tied_to **is** **not** **None**:
            self.kernel = K.transpose(self.tied_to.kernel)
            self._non_trainable_weights.append(self.kernel)
        **else**:
            self.kernel = self.add_weight(shape=(input_dim, self.units),
                                          initializer=self.kernel_initializer,
                                          name='kernel',
                                          regularizer=self.kernel_regularizer,
                                          constraint=self.kernel_constraint)
        **if** self.use_bias:
            self.bias = self.add_weight(shape=(self.units,),
                                        initializer=self.bias_initializer,
                                        name='bias',
                                        regularizer=self.bias_regularizer,
                                        constraint=self.bias_constraint)
        **else**:
            self.bias = **None**
        self.input_spec = InputSpec(min_ndim=2, axes={-1: input_dim})
        self.built = **True**

    **def** compute_output_shape(self, input_shape):
        **assert** input_shape **and** len(input_shape) >= 2
        output_shape = list(input_shape)
        output_shape[-1] = self.units
        **return** tuple(output_shape)

    **def** call(self, inputs):
        output = K.dot(inputs, self.kernel)
        **if** self.use_bias:
            output = K.bias_add(output, self.bias, data_format='channels_last')
        **if** self.activation **is** **not** **None**:
            output = self.activation(output)
        **return** output

带绑定解码器的自动编码器。

encoder = Dense(encoding_dim, activation="linear", input_shape=(input_dim,), use_bias = True) 
decoder = DenseTied(input_dim, activation="linear", tied_to=encoder, use_bias = True)autoencoder = Sequential()
autoencoder.add(encoder)
autoencoder.add(decoder)autoencoder.compile(metrics=['accuracy'],
                    loss='mean_squared_error',
                    optimizer='sgd')
autoencoder.summary()autoencoder.fit(X_train_scaled, X_train_scaled,
                epochs=nb_epoch,
                batch_size=batch_size,
                shuffle=True,
                verbose=0)

观察结果

1a。同等重量。

w_encoder = np.round(np.transpose(autoencoder.layers[0].get_weights()[0]), 3)
w_decoder = np.round(autoencoder.layers[1].get_weights()[0], 3)
print('Encoder weights**\n**', w_encoder)
print('Decoder weights**\n**', w_decoder)

1b。偏见是不同的。

b_encoder = np.round(np.transpose(autoencoder.layers[0].get_weights()[1]), 3)
b_decoder = np.round(np.transpose(autoencoder.layers[1].get_weights()[0]), 3)
print('Encoder bias\n', b_encoder)
print('Decoder bias\n', b_decoder)

2。自定义约束:权重正交性。

**class** **WeightsOrthogonalityConstraint** (Constraint):
    **def** __init__(self, encoding_dim, weightage = 1.0, axis = 0):
        self.encoding_dim = encoding_dim
        self.weightage = weightage
        self.axis = axis

    **def** weights_orthogonality(self, w):
        **if**(self.axis==1):
            w = K.transpose(w)
        **if**(self.encoding_dim > 1):
            m = K.dot(K.transpose(w), w) - K.eye(self.encoding_dim)
            **return** self.weightage * K.sqrt(K.sum(K.square(m)))
        **else**:
            m = K.sum(w ** 2) - 1.
            **return** m

    **def** __call__(self, w):
        **return** self.weights_orthogonality(w)

对编码器和解码器权重应用正交性。

encoder = Dense(encoding_dim, activation="linear", input_shape=(input_dim,), use_bias=**True**, kernel_regularizer=WeightsOrthogonalityConstraint(encoding_dim, weightage=1., axis=0)) 
decoder = Dense(input_dim, activation="linear", use_bias = **True**, kernel_regularizer=WeightsOrthogonalityConstraint(encoding_dim, weightage=1., axis=1))

autoencoder = Sequential()
autoencoder.add(encoder)
autoencoder.add(decoder)

autoencoder.compile(metrics=['accuracy'],
                    loss='mean_squared_error',
                    optimizer='sgd')
autoencoder.summary()

autoencoder.fit(X_train_scaled, X_train_scaled,
                epochs=nb_epoch,
                batch_size=batch_size,
                shuffle=**True**,
                verbose=0)

观察。

2a。编码器和解码器的权重接近正交。

w_encoder = autoencoder.layers[0].get_weights()[0]
print('Encoder weights dot product**\n**', np.round(np.dot(w_encoder.T, w_encoder), 2))

w_decoder = autoencoder.layers[1].get_weights()[0]
print('Decoder weights dot product**\n**', np.round(np.dot(w_decoder, w_decoder.T), 2))

3。自定义约束:不相关的编码特征。

对于不相关的特征，我们将对编码特征协方差的非对角元素的和施加惩罚。

**class** **UncorrelatedFeaturesConstraint** (Constraint):

    **def** __init__(self, encoding_dim, weightage = 1.0):
        self.encoding_dim = encoding_dim
        self.weightage = weightage

    **def** get_covariance(self, x):
        x_centered_list = []

        **for** i **in** range(self.encoding_dim):
            x_centered_list.append(x[:, i] - K.mean(x[:, i]))

        x_centered = tf.stack(x_centered_list)
        covariance = K.dot(x_centered, K.transpose(x_centered)) / tf.cast(x_centered.get_shape()[0], tf.float32)

        **return** covariance

    *# Constraint penalty*
    **def** uncorrelated_feature(self, x):
        **if**(self.encoding_dim <= 1):
            **return** 0.0
        **else**:
            output = K.sum(K.square(
                self.covariance - tf.math.multiply(self.covariance, K.eye(self.encoding_dim))))
            **return** output

    **def** __call__(self, x):
        self.covariance = self.get_covariance(x)
        **return** self.weightage * self.uncorrelated_feature(x)

在自动编码器中应用约束。

encoder = Dense(encoding_dim, activation="linear", input_shape=(input_dim,), use_bias = **True**, activity_regularizer=UncorrelatedFeaturesConstraint(encoding_dim, weightage = 1.)) 
decoder = Dense(input_dim, activation="linear", use_bias = **True**)

autoencoder = Sequential()
autoencoder.add(encoder)
autoencoder.add(decoder)

autoencoder.compile(metrics=['accuracy'],
                    loss='mean_squared_error',
                    optimizer='sgd')
autoencoder.summary()

autoencoder.fit(X_train_scaled, X_train_scaled,
                epochs=nb_epoch,
                batch_size=batch_size,
                shuffle=**True**,
                verbose=0)

观察。

3a。我们有较少相关的编码特征。施加这种惩罚更加困难。可以探索更强的约束函数。

encoder_layer = Model(inputs=autoencoder.inputs, outputs=autoencoder.layers[0].output)
encoded_features = np.array(encoder_layer.predict(X_train_scaled))
print('Encoded feature covariance\n', np.round(np.cov(encoded_features.T), 3))

4。约束:单位定额。

UnitNorm约束是在 Keras 中预先构建的。我们将在编码器和解码器层应用这种约束。值得注意的是，我们为编码器层保留了axis=0，为解码器层保留了axis=1。

encoder = Dense(encoding_dim, activation="linear", input_shape=(input_dim,), use_bias = True, kernel_constraint=UnitNorm(**axis=0**)) 
decoder = Dense(input_dim, activation="linear", use_bias = True, kernel_constraint=UnitNorm(**axis=1**))autoencoder = Sequential()
autoencoder.add(encoder)
autoencoder.add(decoder)autoencoder.compile(metrics=['accuracy'],
                    loss='mean_squared_error',
                    optimizer='sgd')
autoencoder.summary()autoencoder.fit(X_train_scaled, X_train_scaled,
                epochs=nb_epoch,
                batch_size=batch_size,
                shuffle=True,
                verbose=0)

观察。

4.a .编码器和解码器沿编码轴的权重范数为，

w_encoder = np.round(autoencoder.layers[0].get_weights()[0], 2).T  # W in Figure 3.
w_decoder = np.round(autoencoder.layers[1].get_weights()[0], 2)  # W' in Figure 3.print('Encoder weights norm, \n', np.round(np.sum(w_encoder ** 2, axis = 1),3))
print('Decoder weights norm, \n', np.round(np.sum(w_decoder ** 2, axis = 1),3))

如前所述，规范并不完全是 1.0，因为这不是一个硬约束。

把所有东西放在一起

这里我们将把上述属性放在一起。根据问题的不同，这些属性的某种组合会比其他组合更好。

同时应用几个约束有时会损害评估。例如，在此处使用的数据集中，结合联系层、权重正交性和单位范数效果最佳。

encoder = Dense(encoding_dim, activation="linear", input_shape=(input_dim,), use_bias = True, kernel_regularizer=WeightsOrthogonalityConstraint(encoding_dim, weightage=1., axis=0), kernel_constraint=UnitNorm(axis=0)) 
decoder = DenseTied(input_dim, activation="linear", tied_to=encoder, use_bias = False)autoencoder = Sequential()
autoencoder.add(encoder)
autoencoder.add(decoder)autoencoder.compile(metrics=['accuracy'],
                    loss='mean_squared_error',
                    optimizer='sgd')
autoencoder.summary()autoencoder.fit(X_train_scaled, X_train_scaled,
                epochs=nb_epoch,
                batch_size=batch_size,
                shuffle=True,
                verbose=0)train_predictions = autoencoder.predict(X_train_scaled)
print('Train reconstrunction error\n', sklearn.metrics.mean_squared_error(X_train_scaled, train_predictions))
test_predictions = autoencoder.predict(X_test_scaled)
print('Test reconstrunction error\n', sklearn.metrics.mean_squared_error(X_test_scaled, test_predictions))

GitHub 库

这里的完整地提到了模型调整的步骤和更多细节。

[## cran 2367/PCA-自动编码器-关系

了解 PCA 和自动编码器之间的关系-cran 2367/PCA-自动编码器-关系

github.com](https://github.com/cran2367/pca-autoencoder-relationship/blob/master/pca-autoencoder-relationship.ipynb)

关键要点

重建误差的改善

Table 1. Summary of reconstruction errors.

• 基线模型测试数据的重建误差为 0.027。
• 将每个属性添加到 Autoencoder 减少了测试错误。改进范围从 19%的重量正交性到 67%的束缚重量。
• 不同的数据有不同的改进。
• 在我们的问题中，结合束缚权重、权重正交性和单位范数产生了具有最佳重构误差的最优模型。
• 尽管最佳模型中的误差大于仅具有束缚权重的模型，但这更稳定，因此更可取。

关键实施说明

绑重物

• 在绑定权重层DenseTied中，编码器和解码器中的偏差会有所不同。
• 要使所有重量完全相等，设置use_bias=False。

权重正交

• kernel_regularizer用于在层的权重上添加约束或正则化。
• 正交轴对于编码器应该是按行的，axis=0，对于解码器应该是按列的，axis=1。

不相关的编码特征

• activity_regularizer用于对层的输出特征应用约束。因此，这里使用它来将编码特征的非对角协方差约束为零。
• 这个约束不强。也就是说，它不会将非对角协方差元素推到非常接近零的程度。
• 可以探索该约束的另一种定制。

单位定额

• UnitNorm编码器和解码器应该在不同的轴上。
• 类似于权重正交性，这适用于编码器的行axis=0和解码器的列axis=1。

通用

• 有两个类，Regularizer和Constraints用于构建定制函数。实际上，对于我们的应用程序来说，两者是一样的。对于权重正交性和不相关特征，我们使用了Constraints类。
• 所有三个约束——单位范数、不相关编码特征和权重正交性——都是软约束。也就是说，它们可以使模型权重和特征接近所需属性，但并不精确。例如，权重几乎是单位范数，而不是精确的。

在实践中，

• 合并这些属性的性能将因问题而异。
• 在不同的设置下，例如有和没有偏差，以及不同层上正交性和不相关特征约束的不同权重下，分别探索每个属性。
• 除此之外，在自动编码器中包括流行的正则化技术，例如丢弃层。

摘要

• 在前传第一部分中，我们学习了自动编码器应该从 PCA 继承的重要属性。
• 这里，我们实现了自定义层和约束来合并这些属性。
• 在表 1 中，我们展示了这些特性显著改善了测试重构误差。
• 正如在关键要点中提到的，我们需要反复试验来找到最佳设置。然而，这些试验是在一个具有解释意义的方向上进行的。

转到前传第一部

参考

1. https://stack overflow . com/questions/53751024/tieng-auto encoder-weights-in-a-dense-keras-layer

用 Python 构建神经网络

原文：https://towardsdatascience.com/build-up-a-neural-network-with-python-7faea4561b31?source=collection_archive---------15-----------------------

机器学习和深度学习之旅

使用 NumPy 实现正向传播、反向传播

Figure 1: Neural Network

这个博客的目的是使用 python 中的包 NumPy 来建立一个神经网络。虽然像 Keras 和 Tensorflow 这样的成熟包使建立模型变得容易，但是值得自己编写向前传播、向后传播和梯度下降的代码，这有助于更好地理解该算法。

概述

Figure 2: Overview of forward propagation and backward propagation

上图显示了训练神经网络模型时，信息是如何流动的。输入 Xn 后，权重 W1 和偏差 B1 的线性组合被应用于 Xn 。接下来，应用激活函数进行非线性变换以得到 A1 。然后进入 A1 作为下一个隐藏层的输入。相同的逻辑应用于生成 A2 和 A3 。产生 A1 、 A2 和 A3 的过程称为正向传播。 A3 也作为神经网络的输出，与自变量 y 比较计算成本。然后计算成本函数的导数，得到 dA3 。对 W3 和 B3 求 dA3 的偏导数，得到 dW3 和 dB3 。同样的逻辑适用于得到 dA2 、 dW2 、 dB2 、 dA1 、 dW1 和 dB1 。生成导数列表的过程称为反向传播。最后应用梯度下降并更新参数。然后，新一轮迭代从更新的参数开始。该算法不会停止，直到它收敛。

创建测试数据

创建一小组测试数据来验证所创建的功能。

初始化参数

在参数初始化阶段，权重被初始化为接近零的随机值。如果权重接近于零，则 sigmoid 的操作部分大致是线性的，因此神经网络崩溃为近似线性的模型[1]sigmoid 函数在零点附近的梯度较陡，利用梯度下降可以快速更新参数。不要使用零和大的权重，这会导致糟糕的解决方案。

我在 Excel 中手动计算了一次神经网络的迭代训练，这有助于您验证每一步创建的函数的准确性。下面是参数初始化的输出。

Table 1: Parameters Initialization Testing Result

正向传播

在神经网络中，输入 Xn 被输入，信息通过整个网络向前流动。输入 Xn 提供初始信息，该信息向上传播到每层的隐藏单元，并最终产生预测。这个过程称为正向传播。正向传播包括两个步骤。第一步是权重和来自最后一层的输出(或输入 Xn )的线性组合，以生成 Z 。第二步是应用激活函数进行非线性变换。

Table 2: Matrix Calculation in forward propagation

第一步，你需要注意投入和产出的维度。假设您有一个维度为[2，3]的输入矩阵 X ，矩阵中的一列代表一条记录。隐含层有 5 个隐含单元，所以权重矩阵 W 的维数为[5，2]。偏置 B 的尺寸为【5，1】。通过应用矩阵乘法，我们可以得到维数为[5，3]的输出矩阵 Z。计算的细节可以在上表中看到。

Table 3: How activation is applied in forward propagation

上表显示了激活函数是如何应用于 Z 的每个分量的。使用激活函数的原因是为了进行非线性变换。没有激活函数，无论模型有多少隐层，它仍然是一个线性模型。有几种流行且常用的激活函数，包括 ReLU、Leaky ReLU、sigmoid 和 tanh 函数。这些激活函数的公式和图形如下所示。

Figure 3: Activation Function

首先，你需要定义 sigmoid 和 ReLU 函数。然后为单层正向传播创建函数。最后，上一步中创建的函数被嵌套到名为完全正向传播的函数中。为简单起见，ReLU 函数用于前 N-1 个隐藏层，sigmoid 函数用于最后一个隐藏层(或输出层)。注意，在二分类问题的情况下，使用 sigmoid 函数；在多类分类问题的情况下，使用 softmax 函数。将每个隐藏层中计算的 Z 和 A 保存到缓存中，用于反向传播。

这是测试数据的函数输出。

Table 4: Forward Propagation Testing Result

价值函数

正向传播的输出是二元事件的概率。然后将概率与响应变量进行比较，计算成本。在分类问题中使用交叉熵作为代价函数。在回归问题中，均方误差被用作成本函数。交叉熵的公式如下所示。

这是测试数据的函数输出。

Table 5: Cost Function Testing Result

反向传播

在训练期间，前向传播可以继续向前，直到它产生成本。反向传播是计算成本函数的导数，并使用微积分中的链式法则将所有信息返回到每一层。

假设

和

然后

链式法则指出

激活函数的导数如下所示。

类似于正向传播。首先，你需要为 sigmoid 和 ReLU 的导数创建一个函数。然后定义一个单层反向传播的函数，计算 dW 、 dB 、 dA_prev 。 dA_prev 将被用作前一隐藏层反向传播的输入。最后，上一步中创建的函数被嵌套到名为完全反向传播的函数中。为了与正向传播对齐，前 N-1 个隐藏层使用 ReLU 函数，最后一个隐藏层或输出层使用 sigmoid 函数。你可以修改代码并添加更多的激活功能。将 dW 和 dB 保存到另一个缓存中，用于更新参数。

这是测试数据的函数输出。

Table 6: Backward Propagation Testing Result

更新参数

一旦从反向传播计算出梯度，就通过学习速率*梯度来更新当前参数。然后，更新的参数被用于新一轮的正向传播。

这是测试数据的函数输出。

Table 7: Parameter Update Testing Result

梯度下降的解释可以在我的博客里看到。

[## 梯度下降导论

本博客将涵盖以下问题和主题:

towardsdatascience.com](/an-introduction-to-gradient-descent-c9cca5739307)

将功能堆叠在一起

为了训练神经网络模型，将前面步骤中创建的函数堆叠在一起。下表提供了功能摘要。

Table 8: Functions Summary

运行模式

首先使用 make_moons 函数创建两个交错的半圆数据。下面提供了数据的可视化。

Figure 4: Training Data

然后运行该函数来训练神经网络模型。下图显示了培训过程。成本在 8000 个时期后收敛，并且模型准确率收敛到 0.9。

Figure 5: Cost over Time

Figure 6: Accuracy over Time

下一步

图 5 和图 6 表明存在潜在的过拟合问题。您可以使用包括提前停止、退出和调整在内的方法来解决这个问题。除了 ReLU 和 sigmoid 函数之外，还可以通过添加其他激活函数来玩 model。本博客使用的是批量梯度下降，但也有很多改进的梯度下降算法如 Momentum、RMSprop、Adam 等。

摘要

虽然之前上过网上课程，读过书中的相关章节，但直到我亲自动手写博客，我才完全理解了这种奇特的方法。俗话说，教是最好的学习方法。希望你能从阅读这篇博客中受益。如果你有兴趣，请阅读我的其他博客。

[## 目录

这一系列博客将从理论和实现两个方面对深度学习进行介绍。

medium.com](https://medium.com/@songyangdetang_41589/table-of-contents-689c8af0c731)

参考

[1]特雷弗·哈斯蒂，罗伯特·蒂布拉尼，杰罗姆·弗里德曼，(2008)，统计学习的要素

[2]伊恩·古德费勒，约舒阿·本吉奥，亚伦·库维尔，(2017) 深度学习

[3]https://www.coursera.org/specializations/deep-learning?

[4]https://en.wikipedia.org/wiki/Activation_function

[5]https://explained.ai/matrix-calculus/index.html

构建与购买——可扩展的机器学习基础设施

原文：https://towardsdatascience.com/build-vs-buy-a-scalable-machine-learning-infrastructure-88146cfcadb7?source=collection_archive---------10-----------------------

开源 ML 基础设施的路线图。

在这篇博客文章中，我们将看看机器学习平台由哪些部分组成，并将从头构建自己的基础设施与购买一个为您做所有事情的现成服务进行比较。

购买和构建基础架构的最终目标都是让您的数据科学团队尽可能多地花时间了解数据、构建模型并将其投入生产，从而提高他们的效率。相反，这意味着他们将在基础设施和样板代码上花费尽可能少的时间。为了实现这一点，大多数 ML 基础设施公司(如优步的米开朗基罗)都建立在以下原则之上:

• 集成您的数据科学家已经喜欢使用的工具
• 构建快速迭代实验的平台
• 尽可能自动管理输入数据和输出数据
• 通过提供自动审计跟踪，提供回滚实验的方法
• 支持贵公司使用的环境，从不同的云提供商到内部硬件
• 建立在抽象之上，这样你就可以在新技术出现时支持它们
• 从团队的角度和资源的角度来设计可伸缩性，这样你就可以支持数百个项目、人员、数据源和计算单元。
• 与任何地方的任何东西集成，因此平凡的任务都可以自动化。

记住这些原则，让我们看看如何通过从头开始构建来实现这一点。

构建可扩展的机器学习基础设施

有效的机器学习基础设施需要构建它的团队具备各种各样的能力。您将为您的数据科学团队解决特定需求，因此让我们来看看典型的机器学习基础架构由什么组成。

机器编排

机器编排是你的机器学习基础设施的主干。编排引擎在你的机器编排部分的 UI 中实现自己，无论是通过集成在 ide、笔记本、CLI、API 或 UI 中。最先进的引擎优化资源使用，预测需求，处理排队等。您可以将您的引擎基于虚拟机、Kubernetes 之类的平台，或者直接编排您自己的硬件。

记录保存、记录和版本控制

严格来说，版本控制并不是传统 ML 平台的一部分，但是由于 GDPR 等法规，版本控制变得越来越重要。为了让您的数据科学家只需点击一下鼠标就能重现实验，您需要对数据、参数、硬件和软件环境、日志等进行版本控制和记录。一个很好的起点是使用 Git 进行代码版本控制，使用 Docker 进行环境控制。在下面的图片中可以找到版本的起点。

项目和用户管理

您需要将实验纳入项目中，并管理用户和团队的权限。使用 Azure Active Directory 或 Hadoop Ranger 提供的访问控制，或者自己构建一些东西。访问控制还应该定义用户可以使用哪些资源、不同用户如何对作业进行排队、哪些数据对谁可用等等。您将希望消除孤岛并实现透明，以便您的数据科学家可以相互学习。

自动化 ML 管道

机器学习管道是一个概念，其中工作被分成不同的阶段，从探索开始，继续进行批处理、规范化、培训、部署和中间的许多其他步骤。您需要构建对将结果从一个步骤传递到下一个步骤的支持。当数据湖中的数据发生重大变化时，一些高级触发器可能会自动重新运行部分管道。从基于 Git 的低级方法到 Apache 气流和 ML 气流管道，有几种解决方案，您可能想要探索并组合在一起。

整合，整合，整合！

数据科学家应该能够继续使用他们喜欢的工具和框架，无论是他们最喜欢的 IDE、笔记本还是其他任何东西。根据具体情况，还应该有不同的与基础设施交互的方式。最佳实践是在开放 API 的基础上构建一切，然后可以从 CLI 和 web UI 访问，甚至直接从 Jupyter notebook 访问。对于超参数调优，您可能需要考虑外部优化器，比如 SigOpt 。

可视化正在进行的执行

当数据科学家使用模型时，他们需要了解各个步骤是如何进行的，无论是训练精度还是数据准备。为此，您需要构建一种以有意义的方式显示实时训练数据的方法。解决方案可以是定制的可视化库或例如 TensorBoard 或权重&偏差。

推理部署

ML 管道的最后一部分是部署。您可能不想在实际生产环境中进行部署，但要确保您的数据科学团队在为将预测模型集成到您的业务应用程序中的软件团队部署新模型时能够自给自足。由于开销和缓慢的模型开发周期，将模型交付给 IT 部门的旧方法从长远来看是行不通的。Kubernetes clusters 是业内事实上的云推理部署标准。也可以看看 AWS 的弹性推理，谢顿核心或 Azure 推理引擎与 ONNX 的支持。

购买可扩展的机器学习基础设施

不仅自己构建基础设施需要几年的时间(相信我，我们有历史可以证明这一点)，而且随着技术的发展和新技术的支持，您还需要不断开发平台。

Valohai 是一个完整的可扩展的机器学习基础设施服务，可以为您的团队扩展，从 1 到 1000 名数据科学家。Valohai 的一切都是围绕项目和团队构建的，它可以从内部安装扩展到混合云和 Microsoft Azure、AWS 和 Google Cloud 中的全云解决方案。Valohai 为您处理机器编排，并自动跟踪您或您公司中的任何人曾经进行过的每个实验——从数据、代码、超参数、日志、软件环境和库、硬件等等。

Valohai 基于开放 API 构建，通过现成的 CLI、直观的 Web UI 和 Jupyter 笔记本集成，集成到您当前的工作流程中。借助自动化管道，您无需手动操作即可开始批量作业并运行培训流程的每一步。元数据的交互式可视化有助于您的团队了解其他人在做什么，并跟踪他们的模型，直到他们准备好将这些模型投入生产。

然而，有一点是肯定的，ML 基础设施是你的团队生产力中最重要的部分。在最好的情况下，它将减少多达 90%的模型开发时间。

最初发表于【blog.valohai.com】。

在大型数据集上构建 XGBoost / LightGBM 模型——可能的解决方案是什么？

原文：https://towardsdatascience.com/build-xgboost-lightgbm-models-on-large-datasets-what-are-the-possible-solutions-bf882da2c27d?source=collection_archive---------4-----------------------

XGBoost 和 LightGBM 已经在许多表格数据集上被证明是性能最好的 ML 算法。但是当数据庞大时，我们如何使用它们呢？

Photo by Sean O. on Unsplash

XGBoost 和 LightGBM 在最近所有的 kaggle 表格数据竞争中占据了主导地位。只需进入任何竞赛页面(表格数据)并检查内核，你就会看到。在这些比赛中，数据并不“庞大”——好吧，不要告诉我你正在处理的数据是巨大的，如果它可以在你的笔记本电脑上训练的话。对于这些情况，Jupyter notebook 足够用于 XGBoost 和 LightGBM 模型构造。

当数据变得更大，但不是超级大，而你仍然想坚持使用 Jupyter 笔记本，比方说，来构建模型——一种方法是使用一些内存减少技巧(例如，ArjanGroen 的代码:https://www . ka ggle . com/arjanso/reducing-data frame-memory-size-by-65)；或者使用云服务，比如在 AWS 上租一台 EC2。例如，r5.24xlarge 实例拥有 768 GiB 内存，成本为 6 美元/小时，我认为它已经可以处理大量数据，您的老板认为它们真的很“大”。

但是如果数据更大呢？

我们需要分布式机器学习工具。据我所知，如果我们想使用可伸缩的 XGBoost 或 LightGBM，我们有以下几种选择:

1 XGBoost 4j on Scala-Spark
2 light GBM on Spark(py Spark/Scala/R)
3 XGBoost with H2O . ai
4 XGBoost on Amazon SageMaker

我想根据我的个人经验指出每种工具的一些问题，如果您想使用它们，我会提供一些资源。如果你也有类似的问题/你是如何解决的，我也很高兴向你学习！请在下面评论。

在我开始使用这些工具之前，有一些事情需要事先了解。

XGBoost 与 LightGBM

XGBoost 是一种非常快速和准确的 ML 算法，但它现在受到了 LightGBM 的挑战，light GBM 运行得更快(对于某些数据集，根据其基准测试，它快了 10 倍)，具有相当的模型准确性，并且有更多的超参数供用户调整。速度上的关键差异是因为 XGBoost 一次将树节点拆分一层，而 LightGBM 一次只拆分一个节点。

因此，XGBoost 开发人员后来改进了他们的算法，以赶上 LightGBM，允许用户也在逐叶分割模式下运行 XGBoost(grow _ policy = ' loss guide ')。现在，XGBoost 在这一改进下速度快了很多，但根据我在几个数据集上的测试，LightGBM 的速度仍然是 XGB 的 1.3-1.5 倍。(欢迎分享你的测试结果！)

读者可以根据自己的喜好选择任何一个选项。这里再补充一点:XGBoost 有一个 LightGBM 没有的特性——“单调约束”。这将牺牲一些模型精度并增加训练时间，但可以提高模型的可解释性。(参考:https://xgboost . readthe docs . io/en/latest/tutorials/monotonic . html和【https://github.com/dotnet/machinelearning/issues/1651】T2)

在渐变提升树中找到“甜蜜点”

对于随机森林算法，建立的树越多，模型的方差越小。但是在某种程度上，你不能通过添加更多的树来进一步改进这个模型。

XGBoost 和 LightGBM 不是这样工作的。当树的数量增加时，模型精度不断提高，但是在某个点之后，性能开始下降——过度拟合的标志；随着树越建越多，性能越差。

为了找到‘甜蜜点’，你可以做交叉验证或者简单的做训练-验证集分裂，然后利用提前停止时间找到它应该停止训练的地方；或者，你可以用不同数量的树(比如 50、100、200)建立几个模型，然后从中选出最好的一个。

如果你不在乎极端的性能，你可以设置一个更高的学习率，只构建 10-50 棵树(比如说)。它可能有点不合适，但你仍然有一个非常准确的模型，这样你可以节省时间找到最佳的树的数量。这种方法的另一个好处是模型更简单(构建的树更少)。

1.Scala-Spark 上的 XGBoost4j

如果读者打算选择这个选项，https://xgboost . readthedocs . io/en/latest/JVM/xgboost 4j _ spark _ tutorial . html是一个很好的起点。我想在这里指出几个问题(在本文发布时):

1. XGBoost4j 不支持 Pyspark。
2. XGBoost4j 不支持逐叶分割模式，因此速度较慢。https://github.com/dmlc/xgboost/issues/3724
3. 因为是在 Spark 上，所以所有缺失值都要进行插补(vector assembler 不允许缺失值)。这可能会降低模型精度。http://docs . H2O . ai/H2O/latest-stable/H2O-docs/data-science/GBM-FAQ/missing _ values . html
4. 早期停止可能仍然包含 bug。如果你关注他们在 https://github.com/dmlc/xgboost/releases的最新发布，你会发现他们最近仍在修复这些漏洞。

2.Spark 上的 light GBM(Scala/Python/R)

基于我个人经验的主要问题:

1. 缺少文档和好的例子。https://github . com/Azure/mmspark/blob/master/docs/light GBM . MD
2. 所有缺失的值都必须进行估算(类似于 XGBoost4j)
3. 我在 spark cross validator 的“提前停止”参数上也有问题。(为了测试它是否正常工作，选择一个较小的数据集，选择一个非常大的回合数，提前停止= 10，并查看训练模型需要多长时间。训练完成后，将模型精度与使用 Python 构建的模型进行比较。如果过拟合得很差，很可能早期停止根本不起作用。)

一些示例代码(不包括矢量汇编程序):

from mmlspark import LightGBMClassifier
from pyspark.ml.evaluation import BinaryClassificationEvaluator
from pyspark.ml.tuning import CrossValidator, ParamGridBuilderlgb_estimator = LightGBMClassifier(learningRate=0.1, 
                                   numIterations=1000,
                                   earlyStoppingRound=10,
                                   labelCol="label")paramGrid = ParamGridBuilder().addGrid(lgb_estimator.numLeaves, [30, 50]).build()eval = BinaryClassificationEvaluator(labelCol="label",metricName="areaUnderROC")crossval = CrossValidator(estimator=lgb_estimator,
                          estimatorParamMaps=paramGrid, 
                          evaluator=eval, 
                          numFolds=3) cvModel  = crossval.fit(train_df[["features", "label"]])

3.H2O.ai 上的 XGBoost

这是我个人最喜欢的解决方案。该模型可以使用 H2O.ai 构建，集成在 py sparking Water(H2O . ai+py spark)管道中:
https://www . slide share . net/0x data/productionizing-H2O-models-using-sparking-Water-by-jakub-hava

很容易建立一个带有交叉验证的优化轮数的模型

# binary classificationfeatures = ['A', 'B', 'C']
train['label'] = train['label'].asfactor() # train is an H2O framecv_xgb = H2OXGBoostEstimator(
    ntrees = 1000,
    learn_rate = 0.1,
    max_leaves = 50,
    stopping_rounds = 10,
    stopping_metric = "AUC",
    score_tree_interval = 1,
    tree_method="hist",
    grow_policy="lossguide",
    nfolds=5, 
    seed=0)cv_xgb.train(x = features, y = 'label', training_frame = train)

并且 XGBoost 模型可以用cv_xgb.save_mojo()保存在 Python 中使用。如果您想以 h2o 格式保存模型，请使用h2o.save_model()。

我唯一的抱怨是保存的模型(用save.mojo保存的那个)不能和 SHAP 包一起使用来生成 SHAP 特性重要性(但是 XGBoost 特性重要性，.get_fscore()，工作正常)。似乎最初的 XGBoost 包有一些问题。
https://github.com/slundberg/shap/issues/464
https://github.com/dmlc/xgboost/issues/4276

(更新:似乎他们刚刚在其最新版本中实现了 SHAP-https://github . com/h2oai/H2O-3/blob/373 ca 6 B1 BC 7d 194 C6 c 70 e 1070 F2 F6 f 416 f 56 B3 d 0/changes . MD)

4.SageMaker 上的 XGBoost

这是 AWS 的一个非常新的解决方案。两个主要特性是使用贝叶斯优化的自动超参数调整，并且该模型可以作为端点部署。在他们的 Github 上可以找到几个例子:https://Github . com/aw slabs/Amazon-sage maker-examples/tree/master/introduction _ to _ applying _ machine _ learning。以下是我对此的一些担忧:

1. 与其他解决方案相比，参数调整工具对用户(数据科学家)不太友好:
   https://github . com/aw slats/Amazon-sagemaker-examples/blob/master/hyperparameter _ tuning/xgboost _ direct _ marketing/hpo _ xgboost _ direct _ marketing _ sagemaker _ APIs . ipynb和
   https://github . com/aw slats/Amazon-sagemaker-examples/blob/master/hyperparameter _ tuning/Analyze _ results/HPO
2. 贝叶斯优化是否是调优 XGB 参数的最佳选择还是未知数。如果你检查了文件，梯度推进树没有被提及/测试。https://docs . AWS . Amazon . com/sage maker/latest/DG/automatic-model-tuning-how-it-works . html
3. 该参数通过单个验证集进行调整，而不是交叉验证。
4. 我还没想好如何在 Python XGBoost 中使用其内置的 XGBoost 算法训练出来的模型神器。

但是除了这些问题，我们仍然可以利用它的端点特性。你可以在任何地方训练你的 XGB 模型，从 Amazon ECR(Elastic Container Registry)把它放在 XGBoost 映像中，然后把它部署成一个端点。

XGBoost / LightGBM 是相当新的 ML 工具，它们都有潜力变得更强。开发人员已经做了出色的工作，创造了这些工具，使人们的生活变得更容易。我在这里指出我的一些观察和分享我的经验，希望它们能成为更好、更易用的工具。

建立你的第一个计算机视觉项目——狗的品种分类

原文：https://towardsdatascience.com/build-your-first-computer-vision-project-dog-breed-classification-a622d8fc691e?source=collection_archive---------10-----------------------

在不到 30 分钟的时间内开始构建您的第一个计算机视觉项目。

Photo by Joe Caione on Unsplash

对我们人类来说，区分不同品种的狗是很容易的。如果你说的是 10-20 种受欢迎的狗品种。当我们谈论 100 多种狗时，情况就完全不同了。对于一个人来说，要正确并一致地对大量品种进行分类，我们需要一种不同于单纯记忆的方法。我们需要开始提取与不同品种相对应的“特征”，如皮毛颜色、耳朵形状、面部形状、尾巴长度等。即使这样，我们也需要记住什么品种有什么特征，这不是一件容易或有趣的任务。

Image credit: It is hard to classify a large number of dog breeds

人类难以识别大量物种是计算机比我们更好的一个完美例子。这并不是说天网要来杀我们所有人；我认为我们现在还不应该为此担心。许多人认为，两个种族一起工作的混合方式比任何一个种族单独工作都要好，而不是用机器来代替人类。你可以在 Andrew McAfee 所著的《机器、平台、人群》一书中了解更多相关信息。

在这个项目中，我将带你经历建立和训练卷积神经网络(CNN)的步骤，该网络将对 133 种不同的狗进行分类。这个项目是我的数据科学家 Nanodegree 的一部分，你可以在这里找到更多关于它的信息。这个项目的代码可在我的 GitHub repo 上获得，如果你想跟着做，请确保你安装了所需的包。

你需要知道的是

计算机如何理解图像

由于数百万年的进化完善了我们的眼睛和大脑的视觉能力，我们非常擅长识别事物。计算机将图像“视为”一系列数字。屏幕上的一个像素由从 0 到 255 的三个数字表示。每个数字都表示为红色、绿色和蓝色的强度。一张 1024768 的图片可以表示为一个 1024768*3 的矩阵，相当于一系列 239，616 个数字。

Image credit: Image represented as numbers

传统上，计算机很难识别或分类图像中的对象。随着计算能力和神经网络研究的最新进展，计算机现在可以在许多特定任务上具有人类级别的视觉能力。

什么是神经网络

有许多很好的资源可以解释什么是神经网络。下面是我最喜欢的解释，借用这个帖子:

神经网络由以下组件组成

• 一个输入层、T3、x
• 任意数量的隐藏层
• 一个输出层，， ŷ ，
• 一组权重和在各层之间偏向， W 和 b
• 一个选择激活功能用于每个隐藏层，。在本教程中，我们将使用一个 Sigmoid 激活函数。

下图显示了 2 层神经网络的架构(注意，在计算神经网络的层数时，输入层通常被排除在外**

Image credit: A simplified neural network architecture

详细解释神经网络如何工作超出了这篇文章的范围。你可以在 Medium 上找到许多解释神经网络如何工作的优秀文章。对于我们的狗分类项目，我们的输入层将是用数字表示的狗图像。隐藏层将是许多具有权重和偏差的层，这些权重和偏差将在我们训练模型时更新。输出将是我们 133 个犬种的一系列概率。

虽然对于各种机器学习问题有不同的神经网络架构，但是卷积神经网络(CNN)是用于图像分类问题的最流行的一种。

什么是卷积神经网络

CNN 是通常用于图像分类问题的神经网络的架构。典型的架构包括一个输入层、几个卷积层、一个池层、一个全连接层(FC)和一个输出层。你可以在这里和这里阅读 CNN 更全面的解释。

Image credit: Architecture of a CNN

Image credit: Visualization of a convolutional layer

什么是迁移学习

迁移学习利用解决一个问题时获得的知识，并将其应用于另一个不同但相关的问题。

现代卷积网络是在 ImageNet 这样的大型数据集上训练的，需要数周才能完成。所以很多时候，你并不想自己去训练一个全新的 ConvNet。

有很多著名的预训练模型，比如 VGG-16，雷斯网-50，Inception，Xception 等。这些模型已经在大型数据集上进行了训练，您可以利用特征提取步骤，并将它们作为特征提取器应用于您的特定问题。你可以在这里阅读更多关于迁移学习的内容。

Image credit: Visualization of transfer learning architecture

准备数据

获取数据

你可以在这里下载数据集。该数据集包含 8，351 张狗图像，133 个狗品种，分为 6，680 张用于训练的图像，836 张用于测试的图像，以及 835 张用于验证的图像。

注意，如果你有一个 NVIDIA GPU，你应该遵循这个教程。关于 CPU 的培训需要很多时间。或者，你可以在这里免费使用谷歌实验室。

可以按如下方式加载标签和文件路径的键值对字典:

***from** **sklearn.datasets** **import** load_files       
**from** **keras.utils** **import** np_utils
**import** **numpy** **as** **np**
**from** **glob** **import** glob*# define function to load train, test, and validation datasets*
**def** load_dataset(path):
    data = load_files(path)
    dog_files = np.array(data['filenames'])
    dog_targets = np_utils.to_categorical(np.array(data['target']), 133)
    **return** dog_files, dog_targets*# load train, test, and validation datasets*
train_files, train_targets = load_dataset('dogImages/train')
valid_files, valid_targets = load_dataset('dogImages/valid')
test_files, test_targets = load_dataset('dogImages/test')*

不同的图像可能有不同的大小。以下代码将输入调整为 224224 像素的图像，并将其作为 numpy 系列加载到内存中:*

***from** **keras.preprocessing** **import** image                  
**from** **tqdm** **import** tqdm**def** path_to_tensor(img_path):
    *# loads RGB image as PIL.Image.Image type*
    img = image.load_img(img_path, target_size=(224, 224))
    *# convert PIL.Image.Image type to 3D tensor with shape (224, 224, 3)*
    x = image.img_to_array(img)
    *# convert 3D tensor to 4D tensor with shape (1, 224, 224, 3) and return 4D tensor*
    **return** np.expand_dims(x, axis=0)**def** paths_to_tensor(img_paths):
    list_of_tensors = [path_to_tensor(img_path) **for** img_path **in** tqdm(img_paths)]
    **return** np.vstack(list_of_tensors)*

预处理数据

我们需要标准化我们的数据，以消除测量单位。归一化可以帮助我们的模型更好地比较不同尺度的数据。

***from** **PIL** **import** ImageFile                            
ImageFile.LOAD_TRUNCATED_IMAGES = **True***# pre-process the data for Keras*
train_tensors = paths_to_tensor(train_files).astype('float32')/255
valid_tensors = paths_to_tensor(valid_files).astype('float32')/255
test_tensors = paths_to_tensor(test_files).astype('float32')/255*

培训用数据

**

It’s challenging even for humans to identify a dog breed

让我们来看看我们的一些数据。我们的例子表明，准确识别狗的品种是具有挑战性的，即使对人类来说也是如此。还有许多其他现实世界的因素会影响我们的模型:

• 灯光条件:不同的灯光改变颜色的显示方式
• 目标定位:我们的狗可以帮助很多不同的姿势
• 相框:特写人像相框和全身照片非常不同
• 缺失特征:照片中并没有显示狗狗的所有特征

因此，传统方法不可能在计算机视觉任务中取得进展。让我们看看 CNN 和转移学习能做些什么。

创建一个你自己的模型

模型架构

用 Keras 创建 CNN 很简单。您可以用下面的代码定义您的模型架构。

***from** **keras.layers** **import** Conv2D, MaxPooling2D, GlobalAveragePooling2D
**from** **keras.layers** **import** Dropout, Flatten, Dense
**from** **keras.models** **import** Sequentialmodel = Sequential()
model.add(Conv2D(filters=16, kernel_size=2, padding='same',activation='relu',input_shape=(224,224,3)))
model.add(MaxPooling2D())
model.add(Conv2D(filters=32, kernel_size=2, padding='same',activation='relu'))
model.add(MaxPooling2D())
model.add(Conv2D(filters=64, kernel_size=2, padding='same',activation='relu'))
model.add(MaxPooling2D())
model.add(GlobalAveragePooling2D())
model.add(Dense(133,activation='softmax'))model.summary()*

我们的原始模型架构有一个形状为 2242243 的输入层。然后，输入馈入两个卷积层，接着是最大池层(用于下采样)。然后，输出被馈送到全局平均池层，以通过减少参数的数量来最小化过拟合。输出层为我们的品种返回 133 个概率。

Image credit: Visualization of pooling layers such as MaxPooling and AveragePooling

Our primitive model summary

韵律学

在这个项目中，我们的目标是正确预测狗的品种。因此，在每次迭代之后，我们使用准确性作为选择的度量来改进我们的模型。准确性就是我们的模型正确预测犬种的次数。

编译和训练模型

然后需要编译我们的模型。我们使用 rmsprop 作为我们的优化器，category _ cross entropy，作为我们的损失函数，准确性作为我们的度量。

*model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])*

然后，我们可以使用以下代码训练模型:

***from** **keras.callbacks** **import** ModelCheckpointepochs = 5checkpointer = ModelCheckpoint(filepath='saved_models/weights.best.from_scratch.hdf5', 
                               verbose=1, save_best_only=**True**)model.fit(train_tensors, train_targets, 
          validation_data=(valid_tensors, valid_targets),
          epochs=epochs, batch_size=20, callbacks=[checkpointer], verbose=1)*

用五个纪元和大约八分钟，我们取得了 3.2297% 的准确率，比随机猜测(1/133 = 0.75%)要好。

虽然我们的模型比随机猜测的表现好得多，但 3.2297%的模型在现实中没有用。训练和调整我们的模型以达到有意义的准确性需要大量的时间、大量的数据集和大量的计算资源。幸运的是，我们可以使用迁移学习来减少训练时间，而不牺牲准确性。

使用迁移学习创建模型

获取瓶颈特征

Keras 提供了以下经过预先培训的最新架构，您可以在几分钟内使用它们:VGG-19、ResNet-50、Inception 和 Xception。在这个项目中，我们将使用 ResNet-50，但是您可以自己尝试其他体系结构。下面的代码下载预先训练好的模型并加载瓶颈特性。

***import** **requests**
url = 'https://s3-us-west-1.amazonaws.com/udacity-aind/dog-project/DogResnet50Data.npz'
r = requests.get(url)**with** open('bottleneck_features/DogResnet50Data.npz', 'wb') **as** f:
    f.write(r.content)bottleneck_features = np.load('bottleneck_features/DogResnet50Data.npz')
train_Resnet50 = bottleneck_features['train']
valid_Resnet50 = bottleneck_features['valid']
test_Resnet50 = bottleneck_features['test']*

模型架构

借助预训练的 ResNet-50 模型，我们使用以下代码创建全连接(FC)层。我们还增加了两个下降层，以防止过度拟合。

*Resnet50_model = Sequential()
Resnet50_model.add(GlobalAveragePooling2D(input_shape=train_Resnet50.shape[1:]))
Resnet50_model.add(Dropout(0.3))
Resnet50_model.add(Dense(1024,activation='relu'))
Resnet50_model.add(Dropout(0.4))
Resnet50_model.add(Dense(133, activation='softmax'))
Resnet50_model.summary()*

Our model architecture using transfer learning looks like this

模型性能

使用迁移学习(ResNet-50)，在二十个历元和不到两分钟的情况下，我们取得了 80.8612% 的测试准确率。这是对我们原始模型的巨大改进。

使用上面描述的模型，我创建了一个小的命令行应用程序。如果你输入一只狗的照片，这个应用程序会预测它的品种。如果你输入一个人的图像，比如你的一个朋友说，这个应用程序会预测最接近的匹配犬种。如果没有狗或人出现，应用程序将输出一个错误。你可以按照我的 GitHub repo 上的 README.md 文件中的说明进行操作。

结论

在这个项目中，我将带你了解一些构建你的第一个计算机视觉项目所需的核心概念。我解释了计算机如何理解图像，简要回顾了什么是神经网络、卷积神经网络、、和迁移学习。

我们还从零开始构建并训练了一个 CNN 架构以及应用迁移学习来大幅提高我们模型的准确率从 3.2%到 81%。在做这个项目时，我对你如何利用迁移学习来提高准确性，同时显著减少培训时间印象深刻。以下是我们模型的一些预测:

Some predictions of our model

未来的改进

如果我有更多的时间，这里是这个项目的几个未来发展:

• 扩充数据:当前的实现只接受标准图像作为输入。因此，该模型在现实环境中可能不够健壮。我可以增加训练数据，使我们的模型不容易过度拟合。我可以通过随机裁剪、翻转、旋转训练数据来创建更多的训练样本。
• 调优模型:我还可以调优模型超参数，以达到更好的精度。一些用于调优的潜在超参数包括优化器、损失函数、激活函数、模型架构等。我也可以用 Keras 使用 Sklearn 的 GridSearch。
• 尝试其他模型:在这个项目中，我尝试在 VGG-16 和 ResNet-50 上训练模型。下一步可能是尝试使用不同的架构来训练模型，以及改变我们完全连接的层的架构。
• 创建一个 web/移动应用程序:我也可以用这个模型创建一个 web 应用程序或移动应用程序来取乐。

感谢你的阅读，希望你能学到东西:)

建立您的第一个时差数据警报

原文：https://towardsdatascience.com/build-your-first-data-alert-on-slack-e0768621e0fa?source=collection_archive---------30-----------------------

动手黑客

不仅要注重实践，还要更深入地融入你的工作流程

序

这个提醒极大地提高了我的工作效率，让我远离了多余的询问和工作，所以这篇文章不仅关注实践，也解释了我是如何将它融入到工作中的。

为了更容易使用，本文中的所有内容都已经打包到这个 Github 库中。

data alert 如何提高我的工作效率？

🔕对多余的询问保持沉默

你对利益相关者的提问感到很烦，他们也是。如果数据能够自己出现并解释这种情况，每个人都会很感激。

🏋️‍♂️立即追踪异常信号

异常信号出现时跟踪它比一个月后复查要容易得多。不要害怕转发信息并给你的同事/老板贴标签！

👨‍👧‍👧让您的团队充分参与进来！

一旦您注意到后端工程师和首席执行官正在讨论是什么原因导致警报发出异常信号，并为您标记营销经理…

你离成功很近了。

什么让数据预警清晰？

色彩管理

颜色是表明当前状态的最佳方式。红色代表警戒，黄色代表警告，蓝色代表沮丧…

Which style draws more attention with clarity?

情节很重要

一张图胜过千言万语，尤其对于没有统计学背景的同事来说，还是能体会到形势有多严峻的。

Don’t mess it up!

易接近

人类是最懒的动物，所以你的警报应该整合到原来的工作场所，比如 slack，而不是外部的网站或者仪表盘。

编码前:松弛应用设置

1. 登录您的 slack 帐户。
2. 在这里创建一个 Slack App 。
3. 允许应用程序通过备用渠道上传文件(例如#图片存储)
4. 允许在通道通知中发送传入的 webhook(例如#data-notify)
5. 上传一个有趣的图标到你的 Slack 应用程序🤪

Make sure you have the same setting.

让我们编码

1。确保您的数据和绘图准备就绪

2.将绘图上传到时差

这是最有趣的(hack)部分。这个想法是:

1. 将您的绘图保存为临时文件
2. 将你的剧情发布到另一个 slack 频道，获得只能在 slack 上分享的私人网址！
3. 重新分享到#general 或您喜欢的任何频道

3.🚥颜色+📊Plot +📝描述=📩完成的

你做到了，检查你的松弛频道！

如果没有，在这里处理您的错误代码。

替代方案:使用我开发的库

您可以通过克隆slacleoneir来完成数据预警，无需额外编码。

另外:用气流来安排你的剧本

Cronjob 简单而有用，但我个人建议用气流作为更好的替代品。

构建您的第一个开源 Python 项目

原文：https://towardsdatascience.com/build-your-first-open-source-python-project-53471c9942a7?source=collection_archive---------1-----------------------

工作包的逐步指南

每个软件开发人员和数据科学家都应该经历制作软件包的练习。一路上你会学到很多东西。确保你有时间。🕰

制作一个开源 Python 包可能听起来令人生畏，但是你不需要成为一个头发斑白的老手。你也不需要一个精心制作的产品创意。你确实需要坚持和时间。希望这个指南能帮助你减少这两者的需求。😃

Build something beautiful 😃

在本文中，我们将通过每个步骤来制作一个基本的 Python 包。在以后的文章中，我们将建立自动化测试和文档构建。我们还将集成其他有用的应用程序来改进您的包开发。然后，您可以扩展您构建的内容以满足您的需求。

如果你想学习 Python，看看我的令人难忘的 Python 书籍。

本指南适用于使用 Python 3.7 的 macOS。现在一切正常，但事情变化很快，所以不能保证你在 2030 年读到这篇文章。在下面的代码中替换我的 _ 包、我的 _ 文件、等。用你们自己的名字。

我们开始吧！🚀

第一步:制定计划

我们最终计划在 Python 程序中使用一个非常简单的库。该软件包将允许用户轻松地将 Jupyter 笔记本转换成 HTML 文件或 Python 脚本。

我们的包的第一次迭代将允许用户调用打印语句的函数。

现在我们知道了我们想要做什么，我们需要决定如何命名这个包。

第二步:命名

给事物命名是很棘手的。名字应该是独一无二的，简短的，易记的。它们也应该全部小写，并且绝对不能有任何破折号或其他标点符号。不鼓励使用下划线。当你在构建你的包时，检查这个名字在 GitHub、Google 和 PyPI 上是否存在。

如果你非常希望你的包裹有一天会有 10，000 颗 GitHub 星，那么你可能需要检查这个名字在社交网络上是否可用。在这个例子中，我将把我的包命名为 notebookc ，因为它是可用的、简短的、半描述性的。😄

步骤 3:配置环境

确保安装并配置了 Python 3.7、GitHub 和 Homebrew。如果你需要这些，这里有详细信息:

计算机编程语言

在这里下载 Python 3.7 并安装。

开源代码库

如果你没有 GitHub 账户，请点击这里注册一个免费账户。点击查看如何安装和配置 Git 。你需要命令行工具。按照链接下载、安装它，设置您的用户名，并设置您的提交电子邮件地址。

公司自产自用

家酿是一个 Mac 专用的软件包管理器。这里的安装说明是。

Venv

从 Python 3.6 开始，推荐使用 venv 来创建你的虚拟环境进行包开发。使用 Python 管理虚拟环境有多种方法，并且这些建议也在不断发展。见此处的讨论，但小心掉进这个兔子洞。🕳

venv 从 Python 3.3 开始随 Python 一起安装。请注意，从 Python 3.4 开始， venv 将 pip 和 setuptools 安装到虚拟环境中。

使用以下命令创建 Python 3.7 虚拟环境:

python3.7 -m venv my_env

用你喜欢的任何名字替换 my_env 。像这样激活您的虚拟环境:

source my_env/bin/activate

现在，您应该会在终端提示符的最左边看到(my_env)——或者您给虚拟环境起的名字。

当您完成开发后，使用deactivate停用您的虚拟环境。

现在让我们在 GitHub 上设置一些东西。

步骤 4:在 GitHub 上创建组织

GitHub 是版本控制注册中心的市场领导者。GitLab 和 Bitbucket 是其他流行的选项。我们将在本指南中使用 GitHub。

• 你会经常用到 Git 和 GitHub，所以如果你不熟悉，可以看看我的文章这里。
• 在 Github 上创建一个新组织。按照提示操作。我将我的组织命名为 notebooktoall。你可以在自己的个人账户下创建回购，但部分目标是学习如何为更大的社区建立一个开源项目。

步骤 5:设置 GitHub Repo

创建新的存储库。我把我的回购记录命名为 c。

从下拉列表中添加一个. gitignore 。为您的存储库选择 Python 。你的的内容。gitignore 文件将匹配要从 Git repo 中排除的文件夹和文件类型。你可以改变你的。gitignore 稍后排除其他不必要的或敏感的文件。

我建议你从添加许可证下拉框中选择一个许可证。许可证定义了存储库内容的用户可以做什么。有些许可证比其他的更宽松。如果没有选择许可证，则默认版权法适用。点击了解更多关于许可证的信息。

对于这个项目，我选择了 GNU 通用公共许可证 v3.0，因为它是流行的、合法的，并且“保证最终用户自由运行、学习、共享和修改软件”——来源。

步骤 6:克隆和添加目录

选择要在本地克隆存储库的位置，并运行以下命令:

git clone [https://github.com/notebooktoall/notebookc.git](https://github.com/notebooktoall/notebook_convert.git)

替代您的组织和回购。

使用桌面 GUI 或代码编辑器进入项目文件夹。或者使用带有cd my-project的命令行，然后用ls —a查看你的文件。您的初始文件夹和文件应该如下所示:

.git
.gitignore 
LICENSE
README.rst

为您的主项目文件创建一个子文件夹。我建议您将这个主子文件夹命名为与您的包相同的名称。确保名称中没有任何空格。🙂

创建一个名为 init 的文件。py 在您的主子文件夹中。该文件暂时将保持为空。要导入此文件夹中的文件，此文件是必需的。

用创建另一个与主子文件夹同名的文件。py 追加到它后面。我的文件命名为 notebookc.py 。您可以随意命名这个 Python 文件。您的软件包用户在导入您的模块时将引用该文件的名称。

我的 notebookc 目录内容现在看起来是这样的:

.git
.gitignore 
LICENSE
README.rstnotebookc/__init__.py
notebookc/notebookc.py

步骤 7:创建并安装 requirements_dev.txt

在项目目录的顶层，创建一个 requirements_dev.txt 文件。通常这个文件被命名为 requirements.txt 。称之为 requirements_dev.txt 突出了这些包只由项目开发人员安装。

在 requirements_dev.txt 中，指定需要安装 pip 和轮。

pip==19.0.3
wheel==0.33.1

请注意，我们用双等号和完整的 major.minor.micro 版本号来指定这些包的确切版本。如果你将来读到这篇文章，你会希望使用更新的版本。检查https://pypi.org/以查看更新的软件包版本。

Pin your package versions in requirements_dev.txt

派生项目 repo 并使用 pip 安装钉住的 requirements_dev.txt 包的合作者将拥有与您相同的包版本。你知道他们会为他们工作。此外，阅读文档将使用这个文件来安装软件包时，它建立您的文档。

在您激活的虚拟环境中，使用以下命令安装 requirements_dev.txt 中的包:

pip install -r requirements_dev.txt

随着新版本的发布，您将希望保持这些包的更新。现在，你可以通过搜索 PyPI 来安装最新的版本。

我们将在以后的文章中安装一个工具来帮助完成这个过程。跟着我确保你不会错过它。

步骤 8:编码并提交

出于演示目的，让我们创建一个基本函数。您可以稍后创建自己的牛逼函数。👍

在主文件中输入以下内容(对我来说就是notebook c/notebook c/notebook c . py):

这是我们最重要的职能。😃

文档字符串以三个连续的双引号开始和结束。它们将在后面的文章中用于自动创建文档。

让我们提交我们的更改。如果你想复习 Git 工作流，请参阅本文。

第 9 步:创建 setup.py

setup.py 文件是您的包的构建脚本。Setuptools 的 setup 函数将构建您的包，并上传到 PyPI。Setuptools 包括关于您的软件包、您的版本号以及用户需要哪些其他软件包的信息。

以下是我的示例 setup.py 文件:

注意 long_description 被设置为 README.md 文件的内容。

在setup tools . setup . install _ requires中指定的需求列表包含了您的软件包工作所需的所有软件包依赖项。

与 requirements_dev.txt 中开发所需的包列表不同，这个包列表应该尽可能宽松。点击阅读更多关于为什么的信息。

将这个 install_requires 包列表限制为只需要的——你不想让用户安装不必要的包。注意，您只需要列出不属于 Python 标准库的包。如果您的用户将使用您的包，他们将安装 Python。😄

我们的包不需要任何外部依赖，所以您可以排除上面例子中列出的四个包。

派生项目 repo 并使用 pip 安装固定包的合作者将拥有与您所使用的相同的包版本。这意味着事情应该工作。🤞

更改其他 setuptools 信息以匹配您的软件包信息。还有许多其他可选的关键字参数和分类器——参见这里的列表。更深入的 setup.py 指南可以在这里和这里找到。

将代码提交给本地 Git repo。让我们准备构建一个包吧！

步骤 10:构建第一个版本

Twine 是一个实用程序集合，用于在 PyPI 上安全地发布 Python 包。将捆绳包添加到 requirements_dev.txt 的下一个空行，如下所示:

twine==1.13.0

然后通过重新安装 requirements_dev.txt 包将 Twine 安装到您的虚拟环境中。

pip install -r requirements_dev.txt

然后运行以下命令创建您的包文件:

python setup.py sdist bdist_wheel

应该创建多个隐藏文件夹: dist 、 build 和——在我的例子中——notebookc . egg-info。让我们看看区文件夹中的文件。的。whl 文件是车轮文件，即构建的分布。. tar.gz 文件是一个源归档文件。

Wheel

在用户的机器上，只要有可能，pip 就会把包安装成轮子。车轮安装更快。当 pip 不能安装一个轮子时，它就依靠源档案。

让我们准备上传我们的车轮和源档案。

步骤 11:创建 TestPyPI 帐户

PyPI 代表 Python 包索引。它是官方的 Python 包管理器。当库还没有安装在本地时，pip 从 PyPI 中获取库。

PyPI

TestPyPI 是 PyPI 的功能测试版本。在这里创建一个 TestPyPI 账户并确认你的电子邮件地址。请注意，上传到测试网站和官方网站时，您将有单独的密码。

步骤 12:发布到 TestPyPI

Twine

使用 Twine 将您的包安全地发布到 TestPyPI。输入以下命令—无需修改。

twine upload --repository-url [https://test.pypi.org/legacy/](https://test.pypi.org/legacy/) dist/*

系统会提示您输入用户名和密码。记住，TestPyPI 和 PyPI 有不同的密码！

如果需要，修复任何错误，在 setup.py 中创建一个新的版本号，并删除旧的构建工件: build 、 dist 和 egg 文件夹。用python setup.py sdist bdist_wheel重建并用 Twine 重新上传。TestPyPI 上的版本号没有任何意义，这没什么大不了的——您是唯一会使用这些包版本的人。😄

成功上传软件包后，让我们确保您可以安装和使用它。

步骤 13:验证安装并使用它

在您的终端 shell 中创建另一个选项卡，并创建另一个虚拟环境。

python3.7 -m venv my_env

激活它。

source my_env/bin/activate

如果你已经把你的包上传到官方的 PyPI 网站，你就会pip install your-package。我们可以从 TestPypPI 中检索这个包，并用修改后的命令安装它。

下面是从 TestPyPI 安装软件包的官方说明:

您可以通过指定— index-url 标志来告诉 pip 从 TestPyPI 而不是 PyPI 下载包

pip install --index-url [https://test.pypi.org/simple/](https://test.pypi.org/simple/) my_package

如果您想让 pip 也从 PyPI 获取其他包，您可以指定——extra-index-URL 来指向 PyPI。当您测试的包有依赖项时，这很有用:

pip install --index-url [https://test.pypi.org/simple/](https://test.pypi.org/simple/) --extra-index-url [https://pypi.org/simple](https://pypi.org/simple) my_package

如果您的包有依赖项，使用第二个命令并替换您的包名。

您应该会看到虚拟环境中安装了最新版本的软件包。

要验证您可以使用您的软件包，请在您的终端中使用以下命令启动 IPython 会话:

python

导入函数并用字符串参数调用函数。我的代码如下所示:

from notebookc.notebookc import convert

convert(“Jeff”)

然后我会看到以下输出:

I’ll convert a notebook for you some day, Jeff.

你当然会。😉

步骤 14:推送至 PyPI

将你的代码推送到真正的 PyPI 站点，这样人们可以在他们pip install my_package的时候下载它。

这是你上传的代码。

twine upload dist/*

请注意，如果您想将新版本推送到 PyPI，需要在 setup.py 中更新您的版本号。

好吧，让我们把我们的作品上传到 GitHub。

第 15 步:推送至 GitHub

确保您提交了代码。

我的记事本 c 项目文件夹看起来是这样的:

.git
.gitignore
LICENSE
README.md
requirements_dev.txt
setup.pynotebookc/__init__.py
notebookc/notebookc.py

排除任何不想上传的虚拟环境。巨蟒。我们在进行回购时选择的 gitignore 文件应该防止构建工件被索引。您可能需要删除虚拟环境文件夹。

用git push origin my_branch推你当地的分支到 GitHub。

步骤 16:创建并合并采购申请

从浏览器中，导航到 GitHub。您应该会看到一个发出拉取请求的选项。继续按绿色按钮创建和合并您的 PR，并删除您的远程功能分支。

回到你的终端，用git branch -d my_feature_branch删除你的本地特征分支。

步骤 17:在 GitHub 上更新发布版本

通过点击资源库主页上的发布，在 GitHub 上创建一个新的发布版本。输入发布信息并保存。

那就暂时好了！🎉

我们将在以后的文章中添加更多的文件和文件夹。

让我们回顾一下我们的步骤。

总结:工作包的 17 个步骤

1. 想办法
2. 将其命名
3. 配置环境
4. 在 Github 上创建组织
5. 设置 GitHub Repo
6. 克隆和添加目录
7. 创建并安装 requirements_dev.txt
8. 编码并提交
9. 创建 setup.py
10. 构建第一个版本
11. 创建 TestPyPI 帐户
12. 推送至 TestPyPI
13. 验证安装和使用
14. 推送至 PyPI
15. 推送至 GitHub
16. 创建并合并请购单
17. 在 GitHub 上更新发布版本

包装

我希望这篇关于制作和发布你的第一个 Python 包的指南对你有用。如果你有，请分享到你最喜欢的社交媒体渠道，这样其他人也可以找到它。👏

在本系列的下一部分，我们将添加测试、持续集成、代码覆盖等等。请点击这里查看:

[## 成功设置 Python 项目的 10 个步骤

如何添加测试、CI、代码覆盖率等等

towardsdatascience.com](/10-steps-to-set-up-your-python-project-for-success-14ff88b5d13)

我撰写关于 Python、Docker、数据科学和其他技术主题的文章。如果你对此感兴趣，请在这里阅读更多和关注我。😄

快乐大厦！

在创建一个好的回归模型时建立你的直觉

原文：https://towardsdatascience.com/build-your-intuition-in-creating-a-good-regression-model-90fd5aa97058?source=collection_archive---------29-----------------------

你可以通过分类来辨别那是猫还是不是猫。但是，要回答那只猫有多“猫”，回归是唯一的方法。

Photo by Erik-Jan Leusink on Unsplash

分类与回归

两个大问题，两种不同的原因。

热狗还是不是热狗，猫还是不是猫，诈骗还是不是诈骗。这些问题是分类的常见用例。

通过查看示例，您可以很容易地得出结论:分类问题就是将一些数据集划分为几个类或组。从某种意义上说，组的数量是有限的。

正如您所猜测的，另一方面，回归是将这些数据分成无限组。

例如，拥有一组关于房屋面积的数据。通过查看数据，你可以预测每套房子的价格。因为价格几乎是无限的，所以你可以根据这些数据建立一个回归模型。

那么，如何开始创建回归模型呢？

定义问题

用例子做任何事情总是更好，因为理论不会让你走那么远。

我们来发现一些问题。

我发现了这个:

纽约市出租车费用预测

这是一个很好的开始问题，可以训练你建立良好回归模型的直觉。

基本上，你会得到一堆关于在纽约从一个地方到另一个地方需要付多少钱的数据。根据这些数据，你需要预测你需要支付多少打车费用。

他们在问题中陈述的指标是，在不做所有必要的机器学习事情的情况下，你可以得到 5 到 8 美元的 RMSE(均方根误差)。所以，让我们建立一个能给你更少误差的东西。

开始吧！

数据

下载数据并打开 train.csv(是的，它很大)，您将看到大约 5500 万行包含实际出租车费用的数据。

每行将由 7 列组成。

1. 接送日期，当出租车开始行驶时
2. 皮卡 _ 经度，出租车乘坐皮卡的经度
3. 皮卡 _ 纬度，乘坐皮卡的纬度
4. 落客 _ 经度，落客的经度
5. 落客 _ 纬度，落客的纬度
6. 乘客计数，船上乘客的数量
7. fare_amount ，我们要预测的那个。

我们走吧！

逻辑

对于本教程，我将使用 Python 和几个标准库，如 Numpy、Pandas 和 LGBM

import numpy as np 
import pandas as pd
import scipy as scipy
import datetime as dt
from sklearn.model_selection import train_test_split
import lightgbm as lgbm
import os
import gc

我导入了 GC。那是一个用 python 收集垃圾的库。垃圾收集器的 GC。

为什么要导入？

看看数据，对于本教程，我的计算机无法加载文件中的所有行，我最多只能加载 2200 万行。甚至，手动使用垃圾收集器也有所帮助，这样我就可以释放内存来加载和处理所有这 2200 万行。

# Reading Data
train_df =  pd.read_csv('train.csv', nrows = 22000000)# Drop rows with null values
train_df = train_df.dropna(how = 'any', axis = 'rows')# Drop invalid rows
train_df = train_df[(train_df.fare_amount > 0)  & (train_df.fare_amount <= 500) & ((train_df.pickup_longitude != 0) & (train_df.pickup_latitude != 0) & (train_df.dropoff_longitude != 0) & (train_df.dropoff_latitude != 0))]

读取并删除所有缺少值或值无效的行。

直觉

现在你已经准备好了数据。下一步是什么？

像这样的问题，你需要几个新的特性(数据中只有 6 个可用)。你可以试着用这些数据来训练模型，但是你给的信息对模型来说太少了。

特征工程是解决方案。

它基本上是使用现有的功能创建或修改数据。这样做将增加您对数据的理解，最终在训练阶段帮助您的模型。

比如经纬度，直接看的话可能没有任何意义。但是，什么对你有意义呢？距离！正确。

让我们准备一个函数来计算拾取点和衰减点之间的距离。

# To Compute Haversine distance
def sphere_dist(pickup_lat, pickup_lon, dropoff_lat, dropoff_lon):
    """
    Return distance along great radius between pickup 
    and dropoff coordinates.
    """
    #Define earth radius (km)
    R_earth = 6371 #Convert degrees to radians
    pickup_lat, pickup_lon, dropoff_lat, dropoff_lon =
            map(np.radians, [pickup_lat, pickup_lon,dropoff_lat,        
                dropoff_lon]) #Compute distances along lat, lon dimensions
    dlat = dropoff_lat - pickup_lat
    dlon = dropoff_lon - pickup_lon

    #Compute haversine distance
    a = np.sin(dlat/2.0)**2 + np.cos(pickup_lat) * 
        np.cos(dropoff_lat) * np.sin(dlon/2.0)**2
    return 2 * R_earth * np.arcsin(np.sqrt(a))

这就是哈弗辛公式，一个计算两个纬度和经度之间距离的函数。

然而，在导航中，除了距离之外，你经常需要计算方位，也称为方位角或在北方和游乐设备之间移动的角度。

def sphere_dist_bear(pickup_lat, pickup_lon, dropoff_lat, dropoff_lon):
    """
    Return distance along great radius between pickup and dropoff 
    coordinates.
    """

    #Convert degrees to radians
    pickup_lat, pickup_lon, dropoff_lat, dropoff_lon = 
    map(np.radians, [pickup_lat, pickup_lon, dropoff_lat, 
        dropoff_lon]) #Compute distances along lat, lon dimensions
    dlat = dropoff_lat - pickup_lat
    dlon = pickup_lon - dropoff_lon

    #Compute the bearing
    a = np.arctan2(np.sin(dlon * 
        np.cos(dropoff_lat)),np.cos(pickup_lat) * 
        np.sin(dropoff_lat) - np.sin(pickup_lat) * 
        np.cos(dropoff_lat) * np.cos(dlon))
    return a

你可以在这里阅读哈弗森距离，在这里阅读方位。

让我们添加数据

train_df['distance'] = sphere_dist(train_df['pickup_latitude'], 
                                   train_df['pickup_longitude'], 
                                   train_df['dropoff_latitude'], 
                                   train_df['dropoff_longitude']) 

train_df['bearing'] = sphere_dist_bear(train_df['pickup_latitude'], 
                                       train_df['pickup_longitude'], 
                                       train_df['dropoff_latitude'], 
                                      train_df['dropoff_longitude'])

接下来，您可能想要将纬度和经度转换为弧度。因为用弧度计算会给你已经标准化的输入。弧度参数的最大值是 2π弧度。

def radian_conv(degree):
    """
    Return radian.
    """
    return  np.radians(degree)train_df['pickup_latitude'] =  
                       radian_conv(train_df['pickup_latitude'])
train_df['pickup_longitude'] = 
                       radian_conv(train_df['pickup_longitude'])
train_df['dropoff_latitude'] = 
                       radian_conv(train_df['dropoff_latitude'])
train_df['dropoff_longitude'] = 
                       radian_conv(train_df['dropoff_longitude'])

现在，还有什么？

您可能希望从 datetime 特性中提取详细的日期和时间数据。

def add_datetime_info(dataset):
    #Convert to datetime format
    dataset['pickup_datetime'] = pd.to_datetime(dataset['pickup_datetime'],format="%Y-%m-%d %H:%M:%S UTC")

    dataset['hour'] = dataset.pickup_datetime.dt.hour
    dataset['day'] = dataset.pickup_datetime.dt.day
    dataset['month'] = dataset.pickup_datetime.dt.month
    dataset['weekday'] = dataset.pickup_datetime.dt.weekday
    dataset['year'] = dataset.pickup_datetime.dt.year

    return datasettrain_df = add_datetime_info(train_df)

这些是您可能希望看到的常见功能，因为出租车费用可能是季节性的。让我们将所有这些要素放入数据集中。

开始变得有创造力

从这一点来说，您已经准备好了，因为您可能已经从初始特征中提取了所有可能的特征。

这一次，你可能想在餐桌上增加一些创意。

给自己一个问题。

为什么人们在纽约打车？

1. 可能他们刚到机场就去市区了。在这种情况下，如果乘坐距离机场较近，而乘坐距离机场较远，情况可能会有所不同。
2. 人们到处都乘出租车。市内，市外，靠近市中心，远离市中心。但是大概票价会因为你离纽约市中心有多远而有所不同。
3. 自由女神像？

Photo by AussieActive on Unsplash

让我们计算一下乘车点和这些点之间的距离。

def add_airport_dist(dataset):
    """
    Return minumum distance from pickup or dropoff coordinates to 
    each airport.
    JFK: John F. Kennedy International Airport
    EWR: Newark Liberty International Airport
    LGA: LaGuardia Airport
    SOL: Statue of Liberty 
    NYC: Newyork Central
    """
    jfk_coord = (40.639722, -73.778889)
    ewr_coord = (40.6925, -74.168611)
    lga_coord = (40.77725, -73.872611)
    sol_coord = (40.6892,-74.0445) # Statue of Liberty
    nyc_coord = (40.7141667,-74.0063889) 

    pickup_lat = dataset['pickup_latitude']
    dropoff_lat = dataset['dropoff_latitude']
    pickup_lon = dataset['pickup_longitude']
    dropoff_lon = dataset['dropoff_longitude']

    pickup_jfk = sphere_dist(pickup_lat, pickup_lon, 
                       jfk_coord[0], jfk_coord[1]) 
    dropoff_jfk = sphere_dist(jfk_coord[0], jfk_coord[1], 
                       dropoff_lat, dropoff_lon) 
    pickup_ewr = sphere_dist(pickup_lat, pickup_lon, 
                       ewr_coord[0], ewr_coord[1])
    dropoff_ewr = sphere_dist(ewr_coord[0], ewr_coord[1], 
                       dropoff_lat, dropoff_lon) 
    pickup_lga = sphere_dist(pickup_lat, pickup_lon, 
                       lga_coord[0], lga_coord[1]) 
    dropoff_lga = sphere_dist(lga_coord[0], lga_coord[1], 
                       dropoff_lat, dropoff_lon)
    pickup_sol = sphere_dist(pickup_lat, pickup_lon, 
                       sol_coord[0], sol_coord[1]) 
    dropoff_sol = sphere_dist(sol_coord[0], sol_coord[1], 
                       dropoff_lat, dropoff_lon)
    pickup_nyc = sphere_dist(pickup_lat, pickup_lon, 
                       nyc_coord[0], nyc_coord[1]) 
    dropoff_nyc = sphere_dist(nyc_coord[0], nyc_coord[1], 
                       dropoff_lat, dropoff_lon)

    dataset['jfk_dist'] = pickup_jfk + dropoff_jfk
    dataset['ewr_dist'] = pickup_ewr + dropoff_ewr
    dataset['lga_dist'] = pickup_lga + dropoff_lga
    dataset['sol_dist'] = pickup_sol + dropoff_sol
    dataset['nyc_dist'] = pickup_nyc + dropoff_nyc

    return datasettrain_df = add_airport_dist(train_df) 

这取决于你的想象力，你的特征可能不像我创造的。你可能对影响出租车费用的因素有另一种直觉，比如离商业区或住宅区的距离。或者你想象的任何东西。

该训练了

现在，在您准备好数据之后，让我们来训练模型。

train_df.drop(columns=['key', 'pickup_datetime'], inplace=True)

y = train_df['fare_amount']
train_df = train_df.drop(columns=['fare_amount'])x_train,x_test,y_train,y_test = train_test_split(train_df, y, test_size=0.10)del train_df
del y
gc.collect()

将数据以 90:10 的比例分割成训练验证分割。获得训练数组后，不要忘记删除数据帧。它占用了大量资源。

params = {
        'boosting_type':'gbdt',
        'objective': 'regression',
        'nthread': 4,
        'num_leaves': 31,
        'learning_rate': 0.05,
        'max_depth': -1,
        'subsample': 0.8,
        'bagging_fraction' : 1,
        'max_bin' : 5000 ,
        'bagging_freq': 20,
        'colsample_bytree': 0.6,
        'metric': 'rmse',
        'min_split_gain': 0.5,
        'min_child_weight': 1,
        'min_child_samples': 10,
        'scale_pos_weight':1,
        'zero_as_missing': True,
        'seed':0,
        'num_rounds':50000
    }train_set = lgbm.Dataset(x_train, y_train, silent=False,categorical_feature=['year','month','day','weekday'])valid_set = lgbm.Dataset(x_test, y_test, silent=False,categorical_feature=['year','month','day','weekday'])model = lgbm.train(params, train_set = train_set, num_boost_round=10000,early_stopping_rounds=500,verbose_eval=500, valid_sets=valid_set)

它将永远训练，直到你的模型不能再优化结果。这将使你达到大约 25，000 次迭代，并给你 $3.47966 均方根误差。

这是一个巨大的提升，可以为你节省 1.5 美元到 4.5 美元的出租车费。你可以用它买一份简单的快餐。Lol。

Photo by Jen Theodore on Unsplash

结论

一开始直觉可能很难。但是你知道，通常是常识帮助你度过所有这些。通过了解基层的数据情况，可以让你比以前更直观一点。

别忘了，继续努力！

干杯

为分布式分类帐建立区块链协议

原文：https://towardsdatascience.com/build-your-own-blockchain-protocol-for-a-distributed-ledger-54e0a92e1f10?source=collection_archive---------10-----------------------

通过一个简单的编码例子揭开区块链的神秘面纱

Background vector created by freepik — www.freepik.com

在这篇文章中，我将使用区块链构建一个简单的分布式分类帐，扩展 CodeAcademy 和其他人的教程，解释区块链的一些关键机制以及它们如何在 Python 中实现。

区块链概览

区块链协议的基本思想是在一个由机器或节点组成的分布式网络中保存一个名为分类账的数据库。分类账可以用于任何东西，可以保存交易或数字货币，如比特币或以太坊。为了维护保存在网络不同地方的账本的完整性，区块链协议在网络参与者解决计算密集型问题时对他们进行奖励——这个过程被称为挖掘。正是网络上的参与者进入的这个过程，确保了公共网络上分布式账本的完整性。区块链本质上是网络上的参与者解决的问题的解决方案的证明，这些解决方案在一个链中链接在一起，并且随着每个新的解决方案的发现，一个新的块被创建，并且下一组记录被复制到该块中。

构建区块链类

首先，我们将构建 Blockchain 类构造函数方法，该方法创建一个初始空列表(存储我们的区块链)和另一个存储分类账(交易记录)的列表。区块链类对象将负责管理整个区块链。我们将创建以下方法来帮助我们管理区块链:

[1] register_node() — 该方法将在网络上注册一个新节点

[2] new_block() —此方法将在区块链中创建一个新块，将最近的事务复制到这个新块中，并清除事务集。

[3] valid_proof() —此方法将检查提交以添加到区块链的块是否解决了问题。

[4]proof _ of _ work()-此方法将检查采矿是否产生了在区块链创建下一个区块的正确证据。如果证明是正确的，我们返回证明，否则它会一直调用 valid_proof() 直到我们找到有效的证明。

[5] valid_chain() — 该方法将遍历整个区块链，调用 valid_proof()来检查后续块是否有效。

[6]new _ transaction()—此方法将向事务列表中添加一个新事务。

[7] last_block() —此方法将返回链中的最后一个块。

区块链类看起来是这样的:

解决网络上的冲突

由于区块链协议是在分布式网络上运行的，我们需要一个关于区块链类对象的方法来解决网络上的冲突。我们将简单地检查网络上是否有任何其他比我们更长的区块链，如果有，使其成为我们自己的链，否则我们可以继续挖掘我们正在为下一个块挖掘的知识，我们的努力是值得的。

与区块链互动

最后，为了让我们的区块链变得生动并与之交互，我们可以使用 flask 通过 web 应用程序接口公开许多方法。

在网络上注册节点

我们将允许用户在网络上注册一个节点，这样他们就可以参与到工作证明过程中，并为他们的努力获得回报。我们在区块链类对象上调用 register_node()方法注册一个节点。

我们还想让这些参与者检查他们的区块链是否有效，如果无效，就从网络上获取区块链。

向区块链添加交易

我们希望允许参与者向分类帐添加交易。为此，我们只需在区块链类对象上调用 new_transaction()，并添加交易细节。

采矿

最后一件重要的事情！我们需要创造互动，让网络上的参与者挖掘他们的区块链。

现在，我们可以实例化 flask 应用程序，创建区块链类对象，运行 flask 应用程序，并与我们的区块链进行交互。

要下载完整的代码文件，请参见:【https://github.com/jamesdhope/blockchain】

参考

[1]https://www.wikihow.com/Build-a-Blockchain-App

[2]https://www . codecademy . com/learn/introduction-to-区块链/modules/区块链-in-python

[3]丹尼尔·范·弗莱明，https://hacker noon . com/learn-区块链-by-building-one-117428612 f46。

[4]https://towards data science . com/building-a-minimal-区块链-in-python-4f2e9934101d

[5]奥默·戈德堡，https://hacker noon . com/building-a-区块链-the-grey-paper-5be 456018040

在 15 分钟内构建您自己的基于聚类的推荐引擎！！

原文：https://towardsdatascience.com/build-your-own-clustering-based-recommendation-engine-in-15-minutes-bdddd591d394?source=collection_archive---------1-----------------------

推荐引擎是机器学习技术在当前互联网时代最流行的应用之一。这些广泛用于电子商务网站推荐类似产品和电影推荐网站。他们负责为我们生成各种定制的新闻建议。这将推动用户参与更多内容，从而为组织带来更好的用户体验和更多收入。因此，它们在今天的工业中极其重要。

推荐引擎基本上过滤数据并向用户推荐最相关的结果。这些结果是以最大可能感兴趣的方式推荐的。现在，所有的推荐引擎都有用户数据和他们的历史记录，可以用来创建他们的过滤算法。这最终帮助他们为每个独特的用户生成非常准确的推荐。

User-based filtering is based on history of users and similarity b/w them from their purchase histories for example. But, Item-based recommendations are based on content based similarity. Like, “how many times few items are bought together”. Next time, most frequent of these purchases will be recommended together.

在协同过滤的情况下,“用户行为”被用于推荐项目。这些推荐可以利用用户-用户相似性或者基于项目-项目相似性来生成。并且基于该相似性度量，向用户提供建议。但是，让我们考虑一个场景，在这个场景中，我们没有可用的用户数据，但是我们仍然必须向用户推荐商品。

没有用户数据怎么办？我们的推荐引擎现在将如何工作？

生成推荐的问题现在被简单地转化为类似聚类的问题。其中相似性度量基于“在生成推荐时，两个项目有多接近？”。用于生成推荐的度量将基于两个项目的相似性，如这些项目之间的向量距离。我们将针对 Pluralsight 的在线课程文本数据进行讨论。让我们来做一个仅基于我们可用的项目数据的推荐引擎。

在线课程推荐系统

在本文中，我们将从 Pluralsight 的课程数据中构建一个推荐系统，并查看可以对我们基于聚类的解决方案进行的进一步改进。我们将按下述顺序讨论该项目的整个数据分析流程。为了节省时间，你可以直接参考项目库并遵循精心制作的 README.md 文件。此外，可以为提到的每个模块直接运行实用程序脚本。

1.简介:了解你的数据

2.架构设计:构建实用工具

3.预处理步骤

4.问题讨论、模型训练和优化

5.工作推荐系统

6.结论&主题建模的未来改进(特别是 LDA)

超级省时提示 :打开项目的 github 库，按照 README.md 文件运行代码即可😉

简介:了解你的数据

该项目使用的数据是 Pluralsight 网站上的课程列表和描述。要获取课程数据，只需运行下面提到的 ReST API 查询。但是，为了获得用户注册数据，让我们说一个基于协作过滤器的引擎。

首先，获取在文档中提到的 ReST api-token，然后进行 ReST 查询，以获取关于该网站上所有课程和注册该网站的各个用户的数据。如果您想要获取用户相关数据，则需要此键。否则，为了获得简单的课程相关数据，我们可以编写如下 ReST 查询。

# Input
http://api.pluralsight.com/api-v0.9/courses# Output: A *Courses.csv* file for download. It will be having below mentioned structure.CourseId,CourseTitle,DurationInSeconds,ReleaseDate,Description,AssessmentStatus,IsCourseRetiredabts-advanced-topics,BizTalk 2006 Business Process Management,22198,2008-10-25,"This course covers Business Process Management features in BizTalk Server 2006, including web services, BAM, hosting, and BTS 2009 features",Live,no
abts-fundamentals,BizTalk 2006
...

在本文中，我们仅限于发动机制造的课程数据。否则，这种方法将与其他推荐引擎文章非常相似。通过查看这些数据，我们发现以下几点在训练模型时非常重要。您也可以打开 Courses.csv 文件，自己进行如下观察。

1. 课程数据文本描述针对课程 Id、课程标题和课程描述列呈现。因此，在构建我们的推荐引擎时，这些列是我们感兴趣的。利用这些列中的文本数据，我们将能够构建词向量，我们的模型将在预测结果时使用这些词向量。此外，大部分信息仅出现在【描述】栏中。因此，没有描述的课程将从培训中删除。
2. “已退休”栏描述了网站上课程的当前状态，即网站上目前是否有该课程。因此，我们不想推荐我们训练有素的模型的退役课程。但是，我们绝对可以在我们的训练数据中使用它们。
3. 并对该数据的预处理进行了讨论。数据中显然存在一些额外的'-'标记、不同的大小写和停用词。我们将相应地预处理我们的文本，只关注名词/名词短语。

在下一节中，我们将讨论正在开发的这个推荐实用程序的基本架构。有了这个架构，最终我们将拥有一个完整的机器学习工具，它将课程数据作为输入，并基于用户查询生成建议。

架构设计:构建实用工具

下图清楚地说明了我们在这个数据科学项目中的渠道。请在以从左到右的方式进一步阅读之前先看一下。

Three main components: 1. Pre-process & Train; 2. Optimizations; 3. Recommendation Utility Tool

这个实用工具主要分为三个组件，我们将在接下来的章节中详细讨论这些组件。主要是对模型进行训练和优化，减少误差。之后，我们将编写实用工具，该工具将基于唯一课程 id 的输入查询生成推荐。

记住上面的工具架构，让我们转到预处理步骤，并开始为我们的模型进行数据摄取步骤。

预处理步骤

按照下面的代码片段，我们将做一些小的文本预处理，如删除所有标点符号。此外，在大量的术语中,“ll”被用在诸如“we’ll”、“you’ll”等情况中。这些也从‘描述’文本中删除。我们还将消除停用词，并以适当的方式合并包含描述、课程 id、标题的列。请参考下面的代码片段，以遵循上述步骤。

import pandas as pd# 1\. read data, from source
# "Courses.csv" file has been renamed
course_df = pd.read_csv("data/courses.csv")# 2\. drop rows with NaN values for any column, specifically 'Description'
# Course with no description won't be of much use
course_df = course_df.dropna(how='any')# 3\. Pre-processing step: remove words like we'll, you'll, they'll etc.
course_df['Description'] = course_df['Description'].replace({"'ll": " "}, regex=True)# 4\. Another Pre-preprocessing step: Removal of '-' from the CourseId field
course_df['CourseId'] = course_df['CourseId'].replace({"-": " "}, regex=True)# 5\. Combine three columns namely: CourseId, CourseTitle, Description
comb_frame = course_df.CourseId.str.cat(" "+course_df.CourseTitle.str.cat(" "+course_df.Description))# 6\. Remove all characters except numbers & alphabets
# Numbers are retained as they are related to specific course series also
comb_frame = comb_frame.replace({"[^A-Za-z0-9 ]+": ""}, regex=True)

在对上述数据进行基本的清理步骤后，‘comb _ frame’包含了与课程相关的所有必要的文字描述。之后，让我们移动到这个文本的矢量化，并训练我们的模型。

问题讨论、模型训练和优化

现在，我们将所有需要的文本数据呈现在一个数据框中。但是，我们需要将其转换成有意义的表示。因此，它可以正确地输入到我们的机器学习模型中。

为此，我们使用 tf-idf 权重来表示术语在文档中的重要性。它是对文档中单词重要性的统计度量。该权重与单词在语料库中出现的次数相关，但是被语料库中单词的频率所抵消。

Tf 中的 tf-idf 权重衡量文档中的词频。以及 idf 测量给定语料库中给定术语重要性。这可以从下面提到的公式中推断出来。

**TF(**t**)** = (Number of times term *'t'* appears in a document) **/** (Total number of terms in the document)**IDF(**t**)** = **log_e(**Total number of documents **/** Number of documents with term *'t'* in it**)**

我们将使用 scikit learn 将我们的文本数据转换为上面公式中指定的向量矩阵乘积。按照下面的代码片段进行转换。

# Create word vectors from combined frames
# Make sure to make necessary importsfrom sklearn.cluster import KMeans
from sklearn import metrics
from sklearn.feature_extraction.text import TfidfVectorizervectorizer = TfidfVectorizer(stop_words='english')
X = vectorizer.fit_transform(comb_frame)

在此之后，我们可以将这些数据直接输入到我们的 k 均值学习算法中。但是，对于我们的 k-means 算法，我们将需要【k】的理想值，对此我们还没有讨论过。首先，我们可以使用 k=8 的值，因为 Pluralsight 有八种不同类型的课程类别，并检查我们的模型相应训练的预测能力。跟随下面提到的代码片段。

# true_k, derived from elbow method and confirmed from pluralsight's website
true_k = 8# Running model with 15 different centroid initializations & maximum iterations are 500
model = KMeans(n_clusters=true_k, init='k-means++', max_iter=500, n_init=15)
model.fit(X)

我们可以观察来自每个聚类的顶词，以查看所形成的聚类在质量上是否良好，或者它们在某种意义上是否需要改进。运行下面提到的片段，观察每个聚类中的热门词。

# Top terms in each clusters.print("Top terms per cluster:")
order_centroids = model.cluster_centers_.argsort()[:, ::-1]
terms = vectorizer.get_feature_names()
for i in range(true_k):
    print("Cluster %d:" % i),
    for ind in order_centroids[i, :15]:
        print(' %s' % terms[ind]),
    print

观察这些单词后，您可能会注意到所有形成的集群都不合适，一些课程类别在多个集群中重复出现(请参考 README.md 文件)。那现在还是好的(😉)，我们的模型将数量巨大的课程类别细分为其他子类别。因此，给定类别的课程数量的基数问题暴露出来，我们的模型无法解决。

我们可以看到，细分类别平面艺术，电影设计，动画形成了母'创意-专业'类别。由于课程类别之间的数据分布不均，即数据基数的问题，因此形成了这个子类。因此，像“商务-专业”这样课程数量少的课程类别在我们的理想假设中迷失了，因为 k 等于 8。这很容易发生，因为在我们简单的机器学习模型训练中，不经常出现的业务相关术语很容易失去其 tf-idf 权重。

因此，从这种方法得到的聚类仍然可以通过进一步划分成其他聚类来改进，以用更少数量的课程得到这些更小的课程类别。因为，这些进一步的划分可以公式化为误差最小化的优化问题。我们不想因此过度拟合我们的模型，我们将使用 【肘测试】 方法来寻找 k 的理想值。这个想法是，每当给定的【k’的值的误差急剧下降时，该值对于形成聚类来说足够好。这些形成的集群将具有尖锐的误差极小值，并将为我们的模型给出令人满意的解决方案。按照下面提到的代码对我们的数据进行弯头测试。

**# Continuing after vectorization step# data-structure to store Sum-Of-Square-Errors
sse = {}# Looping over multiple values of k from 1 to 30
for k in range(1, 40):
    kmeans = KMeans(n_clusters=k, init='k-means++', max_iter=100).fit(X)
    comb_frame["clusters"] = kmeans.labels_
    sse[k] = kmeans.inertia_# Plotting the curve with 'k'-value vs SSE
plt.plot(list(sse.keys()), list(sse.values()))
plt.xlabel("Number of cluster")
plt.ylabel("SSE")
# Save the Plot in current directory
plt.savefig('elbow_method.png')**

运行上述代码后，我们得到了下图，在此基础上，我们为 k=30 训练了我们的模型。并为我们的推荐引擎工具实现了相对更好的聚类。

Slope is drastically diminishing after the value of k=30. Hence, we’ll opt for this value for our model.

最后，让我们保存我们的模型，继续我们的推荐实用程序脚本设计，并讨论未来的改进方法。所有这些提到的片段都以 model_train.py 脚本的形式提供，您可以参考它来直接执行。但是，在此之前，请提取 courses.csv 数据文件，并仔细阅读 README.md 。

**# Save machine learning model
filename = 'finalized_model.sav'
pickle.dump(model, open(filename, 'wb'))**

工作推荐系统

我们将为这个推荐模块创建几个实用函数。一个 cluster_predict 函数，它将预测输入其中的任何描述的分类。首选输入是我们之前在 model_train.py 文件的 comb_frame 中设计的类似“描述”的输入。

**def cluster_predict(str_input):
    Y = vectorizer.transform(list(str_input))
    prediction = model.predict(Y)
    return prediction**

之后，我们将根据新的 dataframe 列中的描述向量为每个课程分配类别，即‘cluster prediction’。见下文。

**# Create new column for storing predicted categories from our trained model.
course_df['ClusterPrediction'] = ""**

我们将为只有实时课程的数据框存储该聚类类别分数，即删除“无”实时条目的课程。之后，我们将在数据框中为每门课程运行预测函数实用程序，并存储聚类类别。这些存储的类别将在将来与输入查询及其预测类别进行匹配，以生成推荐。

**# load the complete data in a dataframe
course_df = pd.read_csv("data/courses.csv")# drop retired course from analysis. But, courses with no descriptions are kept.
course_df = course_df[course_df.IsCourseRetired == 'no']

# create new column in dataframe which is combination of (CourseId, CourseTitle, Description) in existing data-frame
course_df['InputString'] = course_df.CourseId.str.cat(" "+course_df.CourseTitle.str.cat(" "+course_df.Description))# Create new column for storing predicted categories from our trained model.
course_df['ClusterPrediction'] = ""# Cluster category for each live course
course_df['ClusterPrediction']=course_df.apply(lambda x: cluster_predict(course_df['InputString']), axis=0)**

最后，推荐实用函数将预测具有课程 id 的输入查询的课程类别，并且将从上面转换的数据帧‘course _ df’中推荐几个随机课程，该数据帧具有每个课程的预测值。

**def recommend_util(str_input):

    # match on the basis course-id and form whole 'Description' entry out of it.
    temp_df = course_df.loc[course_df['CourseId'] == str_input]
    temp_df['InputString'] = temp_df.CourseId.str.cat(" "+temp_df.CourseTitle.str.cat(" "+temp_df['Description']))
    str_input = list(temp_df['InputString'])
        # Predict category of input string category
    prediction_inp = cluster_predict(str_input)
    prediction_inp = int(prediction_inp) # Based on the above prediction 10 random courses are recommended from the whole data-frame
    # Recommendation Logic is kept super-simple for current implementation. temp_df = course_df.loc[course_df['ClusterPrediction'] == prediction_inp]
    temp_df = temp_df.sample(10)

    return list(temp_df['CourseId'])**

用下面给出的查询测试你训练过的推荐引擎。您也可以通过从 courses.csv 获取课程 id 来添加您的查询。

**queries = ['play-by-play-machine-learning-exposed', 'microsoft-cognitive-services-machine-learning', 'python-scikit-learn-building-machine-learning-models', 'pandas-data-wrangling-machine-learning-engineers', 'xgboost-python-scikit-learn-machine-learning']for query in queries:
    res = recommend_util(query)
    print(res)**

结论和未来改进

当前推荐引擎的实现本质上是非常原始的。用精确的硬步骤阈值来形成集群的方法是粗糙的，但是给出了用集群化算法实现这些引擎的想法。此外，生成的推荐本质上是随机的。可以采用更具体的方法(如基于最高得分的推荐方法)作为改进。目前，course-id 作为唯一的输入，而不是更好的自然语言输入。但是，这些只是基于实施的改进。

基本上，为了将来的改进，用于训练的类别分配机制和模型可以被改变。此外，可以采用来自主题建模的高级和复杂的机制，如潜在狄利克雷分配(LDA)。主题建模是自然语言处理的一个统计分支，它从文档集中提取摘要。我们将使用 LDA，它将一个特定的文档分配给一个特定的主题和一个实数权重分数，该分数将与相应主题的单词相关联。

只需运行 lda_train.py 来详细了解 lda 的实现，注释/控制台输出将解释关于正在执行的步骤的一切。

这些指定的主题及其与单词的关联分数可以作为上述 cluster_prediction 函数的预测逻辑基础。但是，这些预测将比当前由 k-means 聚类算法生成的任何推荐更精确。一个基于 gensim 的 LDA 实现在这里的同一个 github 仓库中可用。它的推荐实用程序脚本目前还没有添加，你可以作为家庭作业来尝试。

霍普，你喜欢读它，并得到了一个数据科学项目的小手。如果有任何改进，请在 github 上做一个公关或公开一个问题。

建立您自己的自定义热门词探测器零训练数据和$0！

原文：https://towardsdatascience.com/build-your-own-custom-hotword-detector-with-zero-training-data-and-0-35adfa6b25ea?source=collection_archive---------14-----------------------

TLDR : 谷歌 TTS - >噪音增强- > {wav 文件} - > SnowBoy - > {。pmdl 型号} - >树莓 Pi

好了，又到了一年中的这个时候了。你知道沙漠里有个东西。上一次，我装配了一个谷歌 AIY 视觉套件，并在芯片上添加了 espeak 和 Terra ，这是一群杂牌军的艺术装置，即ÿntelligent 技术解放的 bÿte:燃烧器。

结果是这样的:

这一次，我决定增加一种额外的感官能力:倾听和回应的能力，在机器学习中，通俗地说就是装配一个可以在设备上和离线工作的热词检测引擎。放松点，皮兹，不？把啤酒递给我好吗？在学徒上阅读…

因此，我开始四处寻找简单的现成解决方案，并偶然发现了令人敬畏的snow boy*离线热门词汇检测器。这当然是有限制的！你可以下载预先训练好的机器学习模型来检测特定的热门词汇，如 Alexa 和 Jarvis(见下图)…*

The off-the-shelf available hotword models

..但是，为了真正为精确的自定义热门词汇建立您自己的健壮模型，您需要大约 500 名志愿者每人贡献 3 个样本。尽管我在社交媒体上的影响力极其有限，但我还是召集了大约 5 名捐款人

5 donors from my social media campaign!

看到这毫无进展，我想到了生成自己的数据集。我最近从事了几个合成到真实单词转移学习项目，其中一个我在 https://arxiv.org/abs/1905.08633 ICLR 的深度生成模型研讨会上发表了论文(见和)，我认为如果 WaveNet 在生成真实声音的文本到语音转换方面真的如此令人印象深刻，我可以使用 Goggle doles 提供的 300 美元免费 Google cloud credits 来为我收集数据，并通过一些漂亮的噪声增强将学习转移到现实世界中，是的，深度神经网络的泛化能力是不合理的！

第一阶段:使用 Google TTS 生成不同声音的合成热门词音频文件

于是，我创建了一个临时的 GC 账号，虔诚地按照文档写了一些 Python 代码(分享到这里:https://github . com/vinay prabhu/burning man 2019/blob/master/generate _ SYNTHETIC _ audio files . py)。在大约 5 分钟内，我有 189 个。wav 文件的热词我是针对的(这是 嘿芯片！ BTW)不同的口音，或者更正式地称为的声音。你可以从这里下载整个宝藏。**

Using Google TTS to generate synthetic training data

我最喜欢的一些声音例子是:

Example sound files from the Google TTS engine!

现在我们有了 189 个。不同声音的 wav 文件，对于这些声音中的每一个，我执行了普通的加性白高斯噪声增强来获得(189 x 3) wav 文件。这里是与这个任务相关的 colab 笔记本。

阶段 2:使用合成的噪声增强 wav 文件训练热词检测模型

尽管这项技术很有前途，但它仍处于危险之中。用于以编程方式训练您自己的模型的 api 看起来相当严格:

*python training_service**.**py 1.wav 2.wav 3.wav saved_model**.**pmdl*

正如所见，您需要准确地输入 3 个 wav 文件来生成一个模型。所以，是的。我确实为每个声音生成了 189 个模型(我非常非常高兴在这方面被证明是错误的)，并将它们逻辑“或”在一起。摄取 wav 文件训练 ML 模型的 colab 笔记本分享到这里:https://github . com/vinay prabhu/burning man 2019/blob/master/Colab _ Notebooks/model _ gen . ipynb

阶段 3:将所有的模型组合在一起，并在 Raspberry Pi 上运行它们

好的。所以，这个阶段有点棘手。请确保您耐心且虔诚地遵循本回购文件:

* [## wanleg/snowboyPi

从全新安装 Raspbian 开始(Lite 或 Regular，本指南假设是 Lite) sudo apt update && sudo apt -y…

github.com](https://github.com/wanleg/snowboyPi)

树莓 Pi 上音频项目的一个主要来源是 ALSA 的恶作剧，以及随之而来的 HDMI、USB 音频和本地音频输出端口之间的音频统治之争。为了避免这一点，我使用了良好的 ol' SAMSON mike in + audio-out 钻机(显然亚马逊兜售这些现在 29.99 美元！班加罗尔 SP 路的便宜多了。)

整个设置如下所示:

The raspberry pi-3 set-up with the Samson mike

在开始人体试验之前，我试图通过一个简单的测试案例来隔离使用麦克风的影响，我在笔记本电脑上播放谷歌 TTS 输出音频文件，并检查音频文件是否相关。运行在 Raspberry Pi 上的 pmdl 确实会被合成话语触发。结果非常好！

Synthetic data input trials

现在有了一些希望，我开始调整 snowboy.py 脚本(从这里:【https://github.com/wanleg/snowboyPi/blob/master/snowboy.py】T2)来包含所有的。我刚刚生成的 pmdl 模型文件，以便当现实世界中的智人说出关键字‘嘿，芯片！’时，至少有一个会被触发。原来，你需要做的只是在这里添加第 29 行的模特列表:https://github . com/wan leg/snowboyPi/blob/master/snowboy . py # L29

大结局:

现在所有的文件都打包好了(顺便说一下，你再也不用担心这些单个 DNN 模型的大小了。各有~ 10KB。令人印象深刻的作品 雪衣人 ！)，我最终决定用真实的人类语音输入进行最后的真实世界测试，结果是..鼓声。

钽..大！有用！它与我正常的(印度口音)声音和我的亚当·莱文声音配合得天衣无缝。

第 4 阶段:片上部署和 Terra +套管+ playa 部署

我正屏息等待这一阶段。我一回到默认世界就更新这篇博文！*

构建您自己的数据仪表板

原文：https://towardsdatascience.com/build-your-own-data-dashboard-93e4848a0dcf?source=collection_archive---------0-----------------------

数据专业人员权威指南(商业智能)

使用 Python Dash 快速构建 dashboard web 应用程序

Source: Unsplash

问题是

The emergence of BI Dashboarding Tools. source: ezDataMunch

对于数据科学家来说，将我们的数据和结果传达给非技术用户是非常重要的。特别是以能够被理解和迅速反应的形式。这就是数据可视化非常重要的原因，尤其是在 Power BI、Tableau 和 Qlikview 等 BI 产品中。

虽然他们有一个易于使用的界面来产生惊人的可视化，这些技术许可证可能非常昂贵。对于 Tableau 来说，每月最高可达 50 美元。此外，对于像我这样的数据专业人员来说，我认为大多数 BI 工具不够通用，无法跟上 Python 用例的动态增长。嵌入它仍然非常笨拙，而不是与我们的 web 应用程序无缝集成。

因此，我们需要一个更好的方法来解决这个问题。

我们可以免费用 Python 构建仪表板 Web 应用吗？

令人惊讶的答案是肯定的！我将通过开源库——Dash Python 向您展示这一点。

见见达什。

简而言之，Dash 是一个开源 Python 库，用于构建针对数据可视化而优化的 web 应用程序。Dash 最棒的地方在于，它建立在 Plotly 和 Matplotlib 等数据可视化库、Web 应用程序库(Flask)以及最终通过 Pandas 实现的数据可移植性之上！由于 Javascript 层是通过 Plotly 和 Flask 处理的，因此您甚至不需要接触其他编程语言就可以创建一个令人惊叹的 web 应用程序。

最终结果是熟悉、惯例和实用性的完美结合。您可以快速地选择、开发和部署应用程序。严格来说，所有这些都是用 Python 编写的，不需要其他语言(尽管选项仍然可用)。

冲刺的力量

“Dash 应用程序代码是声明性和反应性的，这使得构建包含许多交互元素的复杂应用程序变得容易。” —阴谋破折号

最好的特性之一是 Dash 支持声明式编程。这允许您基于输入数据和输出属性构建 Dash 应用程序。你将只陈述你需要什么，而不是如何实现目标的细节。

Source: Unsplash

假设你想买鸡蛋。

声明式编程会说“给我找鸡蛋买鸡蛋。这是现金”

然而传统编程会说“去法院超市，去 6 号过道找到你右手角的鸡蛋，去收银台用 5 美元现金支付”。

显然，从这个例子中，声明式编程将卸载“如何”。与金钱和鸡蛋类似，您只需要提交输入数据和输出属性，可视化结果就会自动呈现。

你甚至不需要理解 Dash 是如何处理你的视觉化的。你只需要发出指令并接受结果。这就是 Dash 支持声明式编程的美妙之处。

其实这一点都不外国。许多语言也是用相同的概念构建的。声明性语言的一个例子是 SQL(结构化查询语言)和 Kubernetes yaml 。两者都是数据科学家优化数据检索和开发流程的重要工具。

希望我让你兴奋！！让我们开始吧

战斗中的冲刺

Our Application in Big Picture, today we are going to learn how to build Dashboard with Dash

在本教程中，您将学习如何使用 Dash Python 构建仪表板应用程序。

我们将访问我们以前在任务调度器到上的项目，从 Lazada (电子商务)网站抓取数据，并将其转储到 SQLite RDBMS 数据库中。然后，我们将生成数据可视化，以了解 Lazada 产品随时间和日期的价格变化。

请随意欣赏这篇文章或访问我的 Github Repo 获取完整代码。

在这种情况下，让我们想象 3 天内的价格变化。

Price Optimization Dashboard Scraped from Lazada over 3 days

让我们完成这 5 个重要步骤，生成您的第一个仪表板！

1. 导入和激活仪表板
2. 准备数据
3. 可视化图表
4. 下拉菜单和输入过滤器选择
5. 造型和装饰

导入和激活仪表板

像往常一样，让我们在 Python 上导入 Dash 库。

import dash
from dash.dependencies import Input, Output
import dash_core_components as dcc
import dash_html_components as html

您可以用一个简单的 pip install 命令下载这些库。

pip install <library name e.g: dash>

我们还将用这段代码激活 Dash 服务器。

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

一旦您运行这个 Python 脚本，它将运行一个服务器，您可以使用 http://127.0.0.1:8050/ 打开该服务器。这将打开一个 flask web 应用程序，您可以将它部署在任何地方，比如 Heroku。请注意，我们放置了 run_server 参数debug =True. ,这将允许您在脚本中保存任何更改后自动更新本地部署。非常整洁的时间节省技巧重新启动您的应用程序。

Info logs to run dash app on Command Prompt

准备数据

在这个领域，我们将从数据库中读取产品信息，并将它们转储到熊猫数据框架中。dbm 是我们之前在 SQLite RDBMS 项目中创建的一个模块。这将把一个 SQLite 表转储到名为product_df的 Pandas Dataframe 中。请随意从我的 Github 中提取模块。

global product_df
product_df = dbm.read()

关键字global 将全球化 product_df，以便所有回调函数都可以访问它来生成数据可视化。

可视化图表

Dash Graph with Component Details

我们将创建一个应用程序布局，它将在html 模块中封装 html 对象。这将是我们布局图形和调整相对尺寸到你的屏幕尺寸的主要途径。

app.layout = html.Div([
    html.Div([
        html.H1('Price Optimization Dashboard'),
        html.H2('Choose a product name'),
        dcc.Dropdown(
            id='product-dropdown',
            options=dict_products,
            multi=True,
            value = ["Ben & Jerry's Wake and No Bake Cookie Dough Core Ice Cream","Brewdog Punk IPA"]
        ),
        dcc.Graph(
            id='product-like-bar'
        )
    ], style={'width': '40%', 'display': 'inline-block'}),
    html.Div([
        html.H2('All product info'),
        html.Table(id='my-table'),
        html.P(''),
    ], style={'width': '55%', 'float': 'right', 'display': 'inline-block'}),
    html.Div([
        html.H2('price graph'),
        dcc.Graph(id='product-trend-graph'),
        html.P('')
    ], style={'width': '100%',  'display': 'inline-block'})

])

注意dcc 模块。这是 dash 核心组件，将存储 web 应用程序的基本可视化，如条形图、下拉列表和折线图。

剩下的简单明了，具体到html 模块。您可以创建 H1 或 H2 标题、div(包含 web 组件的框)，甚至表格。把它想象成抽象的 html 代码，这样你甚至不需要看它。

现在我们来说说id。dcc.Graph(id=’my-table’) 中的 id my-table 到底是什么意思？这显示了为某个图形输出调用哪个函数。通过插入代码，我们将调用下面的函数。

@app.callback(Output('my-table', 'children'), [Input('product-dropdown', 'value')])
def generate_table(selected_dropdown_value, max_rows=20):

product_df_filter = product_df[(product_df['product_title'].isin(selected_dropdown_value))]product_df_filter = product_df_filter.sort_values(['index','datetime'], ascending=True)

return [html.Tr([html.Th(col) for col in product_df_filter  .columns])] + [html.Tr([
        html.Td(product_df_filter.iloc[i][col]) for col in product_df_filter  .columns
    ]) for i in range(min(len(product_df_filter  ), max_rows))]

在功能代码的顶部，你会看到@app.callback ，它将运行魔法。这意味着您将返回函数准确地导出到 my-table 组件中。您也可以从下拉列表中指定输入选项。这将用于过滤 product_df。

注意，过滤后的 product_df 将用于填充 return 语句，在这里我们使用 html 模块设计表格。

它的美妙之处在于，如果您更改仪表板中的下拉输入，该函数将呈现过滤后的 product_df。

确切地说，你如何使用 Tableau，但免费和更通用(即插即用)！！

Source: Meme Crunch

下拉菜单和输入过滤器选择

注意到@app.callback 输入了吗？此时，您可以指定自己的过滤器来呈现可视化组件。

dcc.Dropdown(
    id='product-dropdown',
    options=dict_products,
    multi=True,
    value = ["Ben & Jerry's Wake and No Bake Cookie Dough Core Ice Cream","Brewdog Punk IPA"]
),

id 与回调函数中的输入注释相同。这指定了要调用的函数。

options 将插入所有可用选项的键值对。这可能是股票代号，如{'GOOG ':谷歌，' MSFT ':微软}或任何东西。对于我们的例子，我们将插入相同的键值对，它们是产品名称。

multi 属性将允许您选择一个以上的选项，这对于在一个图表中进行并排价格比较来说是完美的。

最后，value 属性将在服务器运行开始时存储你的下拉列表值。

Dropdown values to affect Python Dash Elements

造型和装饰

Dash 的造型很简单。默认情况下，Dash 已经预先配置了访问资产文件夹的设置。这是您可以覆盖样式的 css 和 web 行为的 js 的地方。你可以插入 stylesheet.css 来美化你的 Dash Web 应用。具体的改进空间是组件和表格边框之间的边距。

Inserting assets folder with stylesheet.css for styling

最终结果

恭喜你！！您已经创建了第一个交互式仪表板。如果你做得好，你会得到这个结果。如果没有，请随意查阅我的 Github 代码或者在这里提出你的问题。

Your First Python Price Optimization Dashboard!!!

现在，释放和创建自己的仪表板！

更多参考

如果你需要更多的例子和 Dash 能做什么的更好的见解。请随意访问以下链接。我向你保证，这些将提高你的仪表板设计技能，以解决现实生活中的业务问题。

1. 价值投资仪表盘配 Python 美汤和 Dash Python
2. 使用 Python Dash、主题分析和 Reddit Praw API 自动生成 FAQ
3. 仪表盘图库

最后…

Source: Unsplash

我真的希望这是一本很棒的读物，是你发展和创新的灵感来源。

请在下面评论出来建议和反馈。就像你一样，我也在学习如何成为一名更好的数据科学家和工程师。请帮助我改进，以便我可以在后续的文章发布中更好地帮助您。

谢谢大家，编码快乐:)

关于作者

Vincent Tatan 是一名数据和技术爱好者，拥有在 Visa Inc .和 Lazada 实施微服务架构、商业智能和分析管道项目的相关工作经验。

Vincent 是土生土长的印度尼西亚人，在解决问题方面成绩斐然，擅长全栈开发、数据分析和战略规划。

他一直积极咨询 SMU BI & Analytics Club，指导来自不同背景的有抱负的数据科学家和工程师，并为企业开发他们的产品开放他的专业知识。

请通过 LinkedIn ，Medium或 Youtube 频道 联系文森特

用 R 构建你自己的神经网络分类器

原文：https://towardsdatascience.com/build-your-own-neural-network-classifier-in-r-b7f1f183261d?source=collection_archive---------4-----------------------

导言

图像分类是计算机视觉中的一个重要领域，不仅因为许多应用都与它相关，而且许多计算机视觉问题都可以有效地归结为图像分类。图像分类中最先进的工具是卷积神经网络(CNN)。在这篇文章中，我将写一个简单的神经网络有 2 层(完全连接)。我将首先训练它对一组 4 类 2D 数据进行分类，并可视化决策边界。第二，我准备用著名的 MNIST 数据(可以在这里下载:https://www . ka ggle . com/c/digit-recognizer/download/train . CSV)来训练我的 NN，看看它的表现。第一部分受斯坦福提供的 CS 231n 课程启发:http://cs231n.github.io/，用 Python 授课。

数据集生成

首先，让我们创建一个螺旋数据集，每个数据集有 4 个类和 200 个示例。

X、y分别是 800×2 和 800×1 的数据帧，并且它们是以线性分类器不能将它们分开的方式创建的。由于数据是 2D，我们可以很容易地在图上看到它。它们的间距大致相等，实际上一条线并不是一个好的决策边界。

神经网络构建

现在，让我们构造一个两层的神经网络。但在此之前，我们需要将 X 转换成一个矩阵(用于后面的矩阵运算)。对于 Y 中的标签，创建新的矩阵 Y (800 乘 4)，使得对于每个示例(Y 中的每一行)，index==label 的条目为 1(否则为 0)。

接下来，让我们构建一个函数nnet，它采用两个矩阵X和Y，并返回一个包含 4 个矩阵的列表，其中有W、b和W2、b2(每层的权重和偏差)。我可以指定step_size(学习率)和正则化强度(reg，有时符号化为λ)。

激活和损失(代价)函数的选择，分别选择 ReLU 和 softmax。如果你选修了吴恩达的 ML 课程(强烈推荐)，在课程笔记和作业中会选择 sigmoid 和物流成本函数。它们看起来略有不同，但是只需修改下面的代码就可以很容易地实现。还要注意，下面的实现使用了看起来难以理解的矢量化运算。如果是这样，你可以写下每个矩阵的维数并检查乘法运算等等。通过这样做，你也知道神经网络的内部是什么。

预测函数和模型训练

接下来，创建一个预测函数，它将X(与训练X相同的列，但可能有不同的行)和层参数作为输入。输出是每行中最大得分的列索引。在这个例子中，输出只是每个类的标签。现在我们可以打印出训练精度。

判别边界

接下来，让我们绘制决策边界。我们还可以使用 caret 包，用数据训练不同的分类器，并可视化决策边界。看到不同的算法如何做决定是非常有趣的。这将是另一篇文章。

MNIST 数据和预处理

著名的 MNIST(“修正的国家标准与技术研究所”)数据集是机器学习社区中的经典，已经被广泛研究。它是分解成 csv 文件的手写数字的集合，每行代表一个示例，列值是每个像素从 0 到 255 的灰度。首先，让我们显示一个图像。

现在，让我们通过删除接近零方差的列并按max(X)缩放来预处理数据。为了交叉验证，数据也被一分为二。同样，我们需要通过K创建一个维度为N的Y矩阵。这一次，每行中的非零索引偏移 1:标签 0 将在索引 1 处具有条目 1，标签 1 将在索引 2 处具有条目 1，依此类推。最终，我们需要将其转换回来。(另一种方法是将 0 放在索引 10 处，其余标签没有偏移量。)

模型训练和 CV 准确性

现在我们可以用训练集训练模型了。注意即使删除了 nzv 列，数据仍然很大，所以结果可能需要一段时间才能收敛。在这里，我只为 3500 次迭代训练模型。您可以改变迭代次数、学习率和正则化强度，并绘制最佳拟合的学习曲线。​

随机图像的预测

最后，我们随机选择一张图片，预测标签。​

结论

如今，我们很少从头开始编写自己的机器学习算法。有成吨的软件包可用，他们最有可能胜过这个。但是，通过这样做，我真的对神经网络的工作原理有了深刻的理解。在一天结束时，看到你自己的模型产生一个相当好的准确性是一个巨大的满足。

建立你自己的熊猫(喜欢)图书馆

原文：https://towardsdatascience.com/build-your-own-pandas-like-library-7aac66c1f3d7?source=collection_archive---------25-----------------------

我主要通过泰德·彼得鲁的烹饪书了解熊猫。而现在，Ted 又想出了另一个有趣的项目: 建造我们自己的熊猫像库 。它包含一系列需要完成的步骤，以便构建一个类似于熊猫的全功能库，称为 pandas_cub 。图书馆将拥有熊猫最有用的特征。

我喜欢这个项目的地方

1. 项目规模:该项目为熟悉 Python 的人提供了一个编写大代码的绝佳机会。
2. 设置环境:这个项目帮助你学习如何为你的项目创建一个独立的环境。这是使用conda包管理器完成的。
3. 测试驱动开发:你也学习测试驱动开发，这意味着你首先写测试，然后你写代码通过测试。在这个过程中你会学到 python 库pytest。

先决条件和设置可以在项目的 Github 页面上找到，但我仍然会提供一个快速浏览。

步骤 1: 派生存储库

Git 和 GitHub 入门课程，以防你不熟悉。

第二步:克隆你的本地拷贝

没错。现在，我们可以填写我们的代码，并将其推送到我们的项目副本中。但是，如果项目的创建者修改了原来的项目呢？我们希望我们的分叉版本中也有这些修改。为此，我们可以将一个名为upstream的遥控器添加到原始存储库中，并在我们想要同步二者时从那里添加pull。然而，这并不是这个项目所必需的。

第三步:环境设置

这意味着下载构建这个项目所需的特定库和工具集。该项目有一个名为environment.yml的文件，其中列出了所有这些库。一个简单的conda env create -f environment.yml将为我们安装它们。我已经安装好了。

我们现在可以使用conda activate pandas_cub和conda deactivate来激活和停用我们的环境。

步骤 4: 检查测试

所有的测试都包含在位于tests目录下的一个名为test_dataframe.py的文件中。

运行所有测试:

$ pytest tests/test_dataframe.py

运行特定类别的测试:

$ pytest tests/test_dataframe.py::ClassName

运行该类的特定函数:

$ pytest tests/test_dataframe.py::ClassName::FuncName

最后，您需要确保 Jupyter 运行在正确的环境中。

第五步:__init.py__

一旦一切都设置好了，让我们从检查__init.py__开始，这是我们将在整个项目中编辑的文件。第一个任务要求我们检查用户提供的输入是否是正确的格式。

先来举个TypeError如果data不是字典的话。我们的做法如下:

为了测试这个案例，我们将打开一个新的 Jupyter 笔记本(您也可以使用现有的测试笔记本)并执行以下操作:

注意:确保你的笔记本上有这些神奇的代码行。它们将确保无论何时您编辑库代码，它都将反映在您的笔记本中，而无需重新启动。

现在我们传一本字典，看看有没有用。

的确如此。一旦我们编写了所有的案例，我们就可以从test_dataframe.py开始运行测试，看看它们是否都通过了。总的来说，这似乎是一个非常有趣的项目，并且提供了很多可以学习的东西。浏览一遍，告诉我你喜不喜欢。也告诉我你做过的其他有趣的项目。

~快乐学习。

5 分钟内建立自己的推荐系统！

原文：https://towardsdatascience.com/build-your-own-recommender-system-within-5-minutes-30dd40388fbf?source=collection_archive---------12-----------------------

机器学习技术在商业中最成功和最广泛的应用是推荐系统。

Photo by Fixelgraphy on Unsplash

您正在浏览 Spotify 以收听歌曲，但无法决定是哪一首。你正在 YouTube 上浏览观看一些视频，但无法决定观看哪个视频。还有很多这样的例子，我们有丰富的数据，但我们不能决定我们想要什么。这就是推荐系统帮助我们的地方。

推荐系统在今天的市场中无处不在，并且具有巨大的商业重要性，正如大量公司销售推荐系统解决方案所证明的那样。推荐系统改变了无生命网站与用户交流的方式。推荐系统不是提供用户搜索和潜在购买产品的静态体验，而是增加交互以提供更丰富的体验。推荐系统基于过去的购买和搜索以及其他用户的行为，自主地为单个用户识别推荐。

今天，我们将通过推荐与特定项目(在本例中为电影)最相似的项目来重点介绍一个基本的推荐系统。请记住，这不是一个真正健壮的推荐系统，更准确地说，它只是告诉你哪些电影/项目与你的电影选择最相似。

我们开始吧！

导入库

**import** **numpy** **as** **np**
**import** **pandas** **as** **pd**

获取数据

您可以通过点击这里的获取数据集。名为“u.data”的数据集中的列表示用户 ID、项目 ID、评级和时间戳，如我们在下面的代码中所定义的。

column_names = ['user_id', 'item_id', 'rating', 'timestamp']
df = pd.read_csv('u.data', sep='**\t**', names=column_names)
df.head()

Our data should look something like this.

现在让我们来看看电影名称:

movie_titles = pd.read_csv("Movie_Id_Titles")
movie_titles.head()

我们可以将它们合并在一起:

df = pd.merge(df,movie_titles,on='item_id')
df.head()

电子设计自动化(Electronic Design Automation)

让我们稍微研究一下这些数据，看看一些评分最高的电影。

可视化导入

**import** **matplotlib.pyplot** **as** **plt**
**import** **seaborn** **as** **sns**
sns.set_style('white')
%matplotlib inline

让我们用平均评分和评分数创建一个评分数据框架:

df.groupby('title')['rating'].mean().sort_values(ascending=**False**).head()title
Marlene Dietrich: Shadow and Light (1996)     5.0
Prefontaine (1997)                            5.0
Santa with Muscles (1996)                     5.0
Star Kid (1997)                               5.0
Someone Else's America (1995)                 5.0
Name: rating, dtype: float64 df.groupby('title')['rating'].count().sort_values(ascending=**False**).head()title
Star Wars (1977)             584
Contact (1997)               509
Fargo (1996)                 508
Return of the Jedi (1983)    507
Liar Liar (1997)             485
Name: rating, dtype: int64 ratings = pd.DataFrame(df.groupby('title')['rating'].mean())
ratings.head()

现在设置评级列的数量:

ratings['num of ratings'] = pd.DataFrame(df.groupby('title')['rating'].count())
ratings.head()

sns.jointplot(x='rating',y='num of ratings',data=ratings,alpha=0.5)

好吧！现在我们已经对数据有了一个大致的概念，让我们继续创建一个简单的推荐系统:

推荐类似电影

现在让我们创建一个矩阵，在一个访问上有用户 id，在另一个轴上有电影标题。每个单元格将包含用户对该电影的评价。注意会有很多南值，因为大部分人没看过大部分电影。

moviemat = df.pivot_table(index='user_id',columns='title',values='rating')
moviemat.head()

最受欢迎电影:

ratings.sort_values('num of ratings',ascending=**False**).head(10)

我们选两部电影:《星球大战》，科幻电影。和骗子骗子，一部喜剧。现在让我们来看看这两部电影的用户评分:

starwars_user_ratings = moviemat['Star Wars (1977)']
liarliar_user_ratings = moviemat['Liar Liar (1997)']
starwars_user_ratings.head()user_id
0    5.0
1    5.0
2    5.0
3    NaN
4    5.0
Name: Star Wars (1977), dtype: float64

然后，我们可以使用 corrwith()方法来获得两个熊猫系列之间的相关性:

similar_to_starwars = moviemat.corrwith(starwars_user_ratings)
similar_to_liarliar = moviemat.corrwith(liarliar_user_ratings)

在执行这个命令时，将会发出一个类似这样的警告。

/Users/marci/anaconda/lib/python3.5/site-packages/numpy/lib/function_base.py:2487: RuntimeWarning: Degrees of freedom <= 0 for slice
  warnings.warn("Degrees of freedom <= 0 for slice", RuntimeWarning)

让我们通过删除 NaN 值并使用数据帧而不是序列来清理这个问题:

corr_starwars = pd.DataFrame(similar_to_starwars,columns=['Correlation'])
corr_starwars.dropna(inplace=**True**)
corr_starwars.head()

现在，如果我们通过相关性对数据帧进行排序，我们应该会得到最相似的电影，但是请注意，我们会得到一些没有实际意义的结果。这是因为有很多电影只有看过一次的用户也看过《星球大战》(那是最受欢迎的电影)。

corr_starwars.sort_values('Correlation',ascending=**False**).head(10)

让我们通过过滤掉少于 100 条评论的电影来解决这个问题(这个值是根据前面的直方图选择的)。

corr_starwars = corr_starwars.join(ratings['num of ratings'])
corr_starwars.head()

现在对值进行排序，注意标题变得更有意义:

corr_starwars[corr_starwars['num of ratings']>100].sort_values('Correlation',ascending=**False**).head()

喜剧骗子骗子也一样:

corr_liarliar = pd.DataFrame(similar_to_liarliar,columns=['Correlation'])
corr_liarliar.dropna(inplace=**True**)
corr_liarliar = corr_liarliar.join(ratings['num of ratings'])
corr_liarliar[corr_liarliar['num of ratings']>100].sort_values('Correlation',ascending=**False**).head()

干得好！

你不需要通过市场调查来确定一个顾客是否愿意在一个能最大限度帮助他们找到合适产品的商店购买。他们将来也更有可能回到这样的商店。为了了解推荐系统的商业价值:几个月前，网飞估计其推荐引擎每年价值 10 亿美元。

有更先进和非传统的方法来驱动你的推荐过程。这些技术即深度学习、社会学习和张量分解是基于机器学习和神经网络的。这样的认知计算方法可以让你的推荐者的质量更上一层楼。可以肯定地说，产品推荐引擎将随着机器学习的使用而改进。并创建一个更好的客户满意度和保留流程。

最后，我要感谢我的教授——何塞·马西亚尔·波尔蒂利亚，他在 Udemy 上的课程“Python 用于数据科学和机器学习训练营”让我很容易理解所有这些概念。

在几分钟内构建您自己的强大深度学习环境

原文：https://towardsdatascience.com/build-your-own-robust-deep-learning-environment-in-minutes-354cf140a5a6?source=collection_archive---------8-----------------------

深度学习环境配置的不太理想方面指南

Photo by Kyle Hanson on Unsplash

介绍

多亏了更便宜、更大的存储，我们拥有了比几年前更多的数据。无论大数据制造了多少宣传，我们都应该感谢它。然而，这里真正的 MVP 是更快更好的计算，这使得 20 世纪 80 年代和 90 年代的论文更加相关(lstm 实际上是在 1997 年 )发明的！由于更好更快的 CPU 和 GPU，我们终于能够利用神经网络和深度学习的真正力量。不管我们喜欢与否，传统的统计和机器学习模型在处理高维、非结构化数据、更复杂和大量数据的问题时有严重的局限性。

Source: https://twitter.com/andrewyng/status/700086119333892096

深度学习已经开始在这些领域大放异彩，我们已经慢慢地看到它在整个行业中被大规模应用于几个现实世界的问题。著名的人工智能传奇人物吴恩达几年前也提到过同样的问题！

深度学习 的好处是，在构建解决方案时，我们有更好的计算、更多的数据和各种易于使用的开源框架，如**keras**、**tensorflow**和**pytorch**可供选择。

关于深度学习不好的部分？ 从零开始建立自己的深度学习环境可能是一个巨大的痛苦，尤其是如果你迫不及待地开始编码和实现自己的深度学习模型。

经历了几次这个痛苦的过程，也在我的旅程中发现了易于使用的服务，本指南旨在让你轻松地完成建立自己的深度学习环境的不太理想的方面，以便你可以更快地建立你的深度学习模型和解决问题。我们将在本指南中涵盖以下方面。

• 最小配置的基于云的深度学习环境
• 设置你自己的基于云的深度学习环境
• 内部设置提示

事不宜迟，让我们开始吧！

最小配置的基于云的深度学习环境

如果你真的想在不投资专用硬件的情况下开始建立深度学习模型，或者你想跳过所有那些讨厌的配置和设置命令，有几个选项只适合你！使用预先配置的基于云的深度学习环境是最好的。通常，有几个基于云的深度学习服务提供商。以下选项使您能够立即开始工作，只需最少的设置和配置。请注意，这不是我的全面列表，而是我已经试验过或从深度学习实践者那里听到的选项。

• 谷歌合作实验室
• 纸空间渐变
• FloydHub 工作区
• Lambda GPU 云
• AWS 深度学习 AMIs
• GCP 深度学习 VM 图片

我们将介绍这些提供商的基本知识，以便您有足够的知识开始使用它们。除此之外，我们鼓励你走出去，进一步探索它们的细节，并根据你的喜好选择一个！

谷歌联合实验室

也许是谷歌最好的(仍然)免费的选项之一，它让你能够在 GPU 甚至 TPU 支持的深度学习环境中运行交互式 Jupyter 笔记本。谷歌一直在各个领域积极使用和推广其应用，包括其广受欢迎的机器学习速成班。简而言之，Colaboratory 是一个免费的 Jupyter 笔记本环境，不需要任何设置，甚至可以免费使用 GPU 来运行深度学习模型。更多细节可以在这篇文章中找到。

默认情况下，您会获得一个 CPU 支持的深度学习环境，其中预安装了所有库，您可以使用以下代码验证这一点。

现在，对于工作负载和数据较小的相对简单的模型，使用 CPU 是很好的，但对于更复杂的问题，您肯定需要利用 GPU。将 Google Colab 中的运行时改为使用 GPU 只需要几秒钟，如下图所示。

Google Colab 然后为您分配一个新的支持 GPU 的深度学习后端，您可以使用以下代码查看 GPU 类型。

看起来你免费得到了一个 12 GB 内存的 Tesla K80 GPU！这就是 AWS **p2.xlarge**实例给你的惊人的 0.9 美元一小时。相当整洁！最后，您可以使用以下代码来确认您的深度学习库正在使用 GPU。

这应该可以让你在 Google Colab 上尝试自己的深度学习模型。当您使用 colab 时，请随意利用my Colab notebook来测试支持 CPU 和 GPU 的深度学习环境！

[## 谷歌联合实验室

测试 CPU 和 GPU 支持的环境

colab.research.google.com](https://colab.research.google.com/drive/1zSI8QrODgmbgwDflHr1pr4aMzeGMXsjF)

纸张空间渐变

Gradient 是 Paperspace 提供的产品，paper space 是一家专注于机器学习和数据科学的轻松基础设施的公司。它为开发人员提供了一整套工具，用于探索数据、训练深度学习模型和在 GPU 上运行计算作业。Gradient 包括一键式 jupyter 笔记本电脑，由 Paperspace GPU 云的全部功能提供支持。这个介绍视频更详细地谈到了它。以下是他们的一些基本计划(进一步的细节可以在这里找到)。

你确实需要按小时支付 GPU 的使用费用，但价格与其他服务提供商相比非常有竞争力，Quadro P4000 每小时 0.5 美元，Tesla K80 每小时约 0.59 美元，仍然比 AWS 上的类似选项相对便宜。

FloydHub 工作空间

FloydHub 提供的一个有趣的产品是 FloydHub Workspace，它旨在通过在云上为深度学习提供一个完全配置的开发环境，来减少设置自己的深度学习环境的麻烦。最精彩的部分？虽然它不是免费的，但你可以无缝地从 CPU 切换到 GPU 后端，只需按每秒使用量付费！

考虑到你可以以 12 美元的最便宜价格获得一个拥有 12 GB 内存、61 GB 内存和 200 GB 固态硬盘的特斯拉 K80 专用实例，它们的价格也很不错。

Lambda GPU 云

Lambda Labs 或 Lambda 是一家人工智能基础设施公司，提供计算来加速人类的进步。他们专注于深度学习工作站，最近推出了 Lambda GPU Cloud，目前仍处于封闭测试阶段。每个 Lambda GPU 云实例有 4 个 GPU，比 AWS 的 p2.8xlarge 实例快 2 倍。他们声称您可以简单地按下按钮，立即获得对 4-GPU 实例的 SSH 远程访问。然而，定价是每小时每 GPU 0.9 美元。可以在这里 报名私测 。

AWS 深度学习 AMIs

亚马逊网络服务(AWS)是亚马逊的子公司，提供基于付费订阅的按需云计算平台。最近，他们推出了深度学习 ami，这是亚马逊机器映像(AMIs)，专用于 GPU 密集型工作负载，用于建立深度学习模型。AWS 深度学习 ami 为我们提供了必要的基础设施和预配置的工具和框架，以大规模加速云中的深度学习。它预先配置了所有最新和最好的深度学习框架。

你可以得到 Conda AMI，它为每个深度学习框架提供了单独的虚拟环境，或者是用于配置和使用定制构建的基本 AMI。

Virtual Environments in the Conda AMIs

随意查看深度学习 AMI 指南 这里 还有如何开始使用 Conda 和 Base AMI这里 。当您选择自己的 AWS 实例时要小心，因为您是按小时收费的。最便宜的选择是给你 12 GB 的 GPU，每小时 0.9 美元(T21)。

GCP 深度学习虚拟机图片

GCP 也称为谷歌云平台，为我们提供了一套云计算服务，包括运行深度学习模型和工作负载的基础设施。最棒的是，它运行在谷歌内部用于终端用户产品的同一基础设施上。如果你注册的话，GCP 还会在第一年提供价值 300 美元的免费积分，这很酷！

谷歌云深度学习虚拟机映像使开发人员能够在谷歌计算引擎实例上实例化包含流行的深度学习和机器学习框架的虚拟机映像。您可以启动预先安装了流行的 ML 框架(如 TensorFlow、PyTorch 或 scikit-learn)的计算引擎实例。你可以在这里 查看进一步详情 。最棒的是，您还可以通过单击添加云 TPU 和 GPU 支持。价格非常有竞争力，比 AWS 便宜得多。GCP 虚拟机让你以每小时仅 0.45 美元的价格访问 12 GB Tesla K80 GPU！查看定价板 点击 了解更多信息。

这些选项应该让您对潜在选项有一个好的想法，以最少的配置和设置启动您的深度学习之旅。

设置您自己的基于云的深度学习环境

虽然云上的预配置设置非常好用，但有时您希望构建自己定制的基于云或内部的深度学习环境。在这一部分，我们将看看如何利用任何流行的云平台服务提供商，在云中构建一个健壮的深度学习环境。涉及的主要步骤如下:

• 选择云提供商
• 创建您的虚拟服务器
• 配置您的虚拟服务器
• 设置你的深度学习环境
• 访问您的深度学习环境
• 验证 GPU 启用

现在，让我们详细了解一下如何设置基于云的深度学习环境。

选择云提供商

如今，有多家价格合理且具有竞争力的云提供商。在前一节中，我们已经看到了其中的一些。我们希望利用平台即服务(PaaS)功能，我们只需管理我们的数据、应用和基本配置，但使用 GPU 计算进行深度学习。下图显示了深度学习实践者利用的一些流行的云提供商。

Cloud Providers having Deep Learning Instances

受欢迎的供应商包括亚马逊的 AWS、微软的 Azure 和谷歌的谷歌云平台(GCP)。

创建虚拟服务器

选择云服务提供商后的下一步是创建虚拟机实例，这基本上是一个托管代码、数据和配置设置的服务器。创建虚拟机的步骤取决于您的云提供商的选择。以下分步教程深入指导您在 AWS 和 GCP 中创建和设置自己的实例。

• 用 AWS 深度学习 AMI 创建并设置云实例
• 使用 GCP 市场 创建并设置云实例

我在我的书《第二章中的 【用 Python 进行实际迁移学习】 中确实涵盖了在 AWS 上创建和实例化你自己的 VM 的逐步指南。整个代码库都是开源的，如果你感兴趣的话，进一步的细节在本书的 GitHub 资源库 中。

配置您的虚拟服务器

一旦创建了实例，就可以从云提供商的平台上启动实例。通常是 AWS 中的 EC2 用户界面或 GCP 中的 VM 实例页面。现在，通常您需要一个私钥来从本地终端使用 SSH 登录到您的服务器。通常 AWS 允许你在创建 VM 的最后一步设置你自己的密钥，并给你一个可下载的私有密钥。GCP 允许您通过 SSH 使用 GCP 实例页面直接登录到您的系统。然后，如果需要的话，你可以按照这个指南来创建你自己的 SSH 密钥，如果你没有的话。

请记住将您的私有 SSH 密钥保存在一个安全的地方，并从终端使用以下命令登录到您的服务器。

恭喜你！您现在已成功登录到深度学习服务器。我们深度学习设置的其余方面将在假设您在 Linux 服务器上的情况下进行。我们的 Linux 发行版是 Ubuntu 18.10 。您可以根据自己的喜好自由选择自己的操作系统！

由于我们将广泛使用 Jupyter 笔记本电脑进行原型制作和开发，因此为笔记本电脑服务器设置密码通常会有所帮助，这样即使陌生人以某种方式获得了您的公共 IP 地址，也无法使用它。如果您不想设置密码，可以跳过本节中的密码设置步骤。这里的第一件事是使用 Open SSL 创建一个新的 SSL 证书。

如果系统中没有安装 python，我们建议使用 Anaconda 发行版，它有一个很好的包管理系统，并附带了一套预安装的库。我们推荐下面的 官方指南 来安装 Anaconda python 发行版。

下一步是为我们的 Jupyter 笔记本服务器生成一个配置文件，以防它不存在。通常该文件位于您的主目录中的**~/.jupyter/jupyter_notebook_config.py** 处，如果它不存在，您可以使用以下命令创建它。

要为笔记本电脑启用基于密码的安全性，我们需要首先生成一个密码及其哈希。我们可以如下利用**Ipython.lib**中的**passwd()**函数:

一旦您输入了密码并验证了密码，该函数将返回一个哈希，这是您的密码的哈希(在这种情况下，我键入的密码键实际上是单词 password ，这是您绝对不应该使用的！).复制并保存哈希值，因为我们很快就会用到它。接下来，启动您最喜欢的文本编辑器来编辑 Jupyter 配置文件，如下所示:

我们现在准备设置我们的深度学习环境。

设置您的深度学习环境

我们现在将开始设置我们的深度学习环境所需的必要配置，以开始使用 GPU。如果已经为您的实例配置了 CUDA 和 cuDNN，您可以根据需要跳过下面的一些步骤。

1。安装图形驱动程序

这里的第一步是确保为您的 GPU 安装了图形驱动程序。接下来，我们假设您使用的是 NVIDIA GPU。测试是否安装了驱动程序的最佳方法是从终端运行**nvidia-smi** 命令。现在，如果这个命令不起作用，我们需要安装 GPU 驱动程序。

2。安装 CUDA

NVIDIA CUDA Toolkit 基本上是一个开发环境，用于创建可以最大限度地利用 NVIDIA GPUs 的应用程序和程序。GPU 加速的 CUDA 库支持跨多个领域的嵌入式加速，包括线性代数、图像和视频处理、深度学习和图形分析。假设我们使用的是基于 Ubuntu 的系统，你可以去NVIDIA CUDA 官方页面 下载必要的安装文件。在撰写本文时，CUDA 10 已经发布，但仍然相当新。因此我们将使用传统的 CUDA 9.0 版本，你可以从 传统发布页面 获得。如果您在服务器上，最好使用终端直接下载安装文件，并使用以下命令配置 CUDA。

3。安装 cuDNN

NVIDIA CUDA 深度神经网络库(cuDNN)是用于深度神经网络的 GPU 加速原语库。cuDNN 库为神经网络中的标准例程提供了高度优化的实现，包括前向和后向卷积、池化、规范化和激活层。深度学习实践者可以依赖 cuDNN，它可以在 GPU 上加速广泛使用的深度学习框架。你可以从 官方页面 下载 cuDNN，但是你需要为此注册一个 NVIDIA 账户！您将获得 cuDNN 的下载链接，然后您可以在终端中使用该链接直接下载到服务器中。

通常，这照顾到我们的 GPU 设置的大多数必要的依赖关系。

4。安装深度学习框架

现在，我们需要安装和设置我们的 Python 深度学习框架，以防它们没有安装。我们通常使用大量的 keras 和 tensorflow，下面的命令可以帮助我们在我们的环境中安装它们。

访问您的深度学习云环境

我们真的不想一直坐在服务器上的终端中编码。由于我们希望利用 Jupyter 笔记本进行交互式开发，我们将从本地系统访问云服务器上的笔记本。为此，我们首先需要在远程实例上启动 Jupyter 笔记本服务器。

现在，如果您有一个分配给实例的公共 IP，并且端口**8888**是公开的，那么您可以直接键入**http://<IP_Address>:8888**并开始从您的本地浏览器访问您的云 VM 中的 Jupyter 服务器！

另一个选项，特别是对于 AWS 实例，是在本地实例上启用端口转发，以便从本地机器的浏览器访问我们的云服务器笔记本。这也称为 SSH 隧道。

在端口转发的情况下，转到您的本地浏览器并导航到本地主机地址，例如 https://localhost:8890，，我们将它转发到我们虚拟服务器中的远程笔记本服务器。确保你在地址中使用了**https**，否则你会得到一个 SSL 错误。

验证 GPU 启用

最后一步是确保一切都在工作，并且我们的深度学习框架正在利用我们的 GPU(我们通常按小时付费！).下面的代码应该可以帮助我们验证这一点。

看起来我们的深度学习设置被配置为使用 GPU 进行深度学习，我们已经准备好了！

内部设置提示

通常，用户或组织可能不想利用云服务，尤其是如果他们的数据是敏感的，因此他们专注于构建内部深度学习环境。这里的主要重点应该是投资正确类型的硬件和软件，以实现最高性能，并利用正确的 GPU 来构建深度学习模型。关于硬件，特别强调以下几点:

• 处理器:你可以购买 i5 或 i7 英特尔 CPU，或者如果你想宠坏自己，也可以购买英特尔至强处理器！
• RAM: 为你的内存投资至少 32 GB 的 DDR4\DDR5 或者更好的 RAM。
• 磁盘:1tb 的硬盘很不错，而且你还可以投资最少 128 GB 或 256 GB 的固态硬盘来实现快速数据访问！
• GPU: 可能是深度学习最重要的组件。购买一个 NVIDIA GPU，任何高于 GTX 1070 的最低 8 GB。

你不应该忽视的其他东西包括主板、电源、坚固的外壳和冷却器。一旦你设置好你的装备，对于软件配置，你可以重复上一节的所有步骤，不包括云设置，你应该准备好了！

结论

这份详细的实践指南旨在让开发者、工程师和深度学习实践者在几分钟内从零到深度学习。我希望这个指南能帮助你建立自己的深度学习，而不是最终花几个小时打破你的脑袋阅读论坛上的无数帖子和栈溢出来建立自己的深度学习环境。现在出去开始‘深度学习’！

我利用数据科学、人工智能、机器学习和深度学习来解决现实世界的问题。我也在业余时间做一些咨询、研究和指导。如果您需要集中咨询、培训课程，希望我在活动中发言，或者如果您想发表一篇关于【TDS】的文章，请随时通过LinkedIn联系我。

* [## Dipanjan Sarkar -数据科学家-红帽| LinkedIn

查看 Dipanjan Sarkar 在世界最大的职业社区 LinkedIn 上的个人资料。Dipanjan 有 9 份工作列在…

www.linkedin.com](https://www.linkedin.com/in/dipanzan/)*

构建自己的 Whatsapp 聊天分析器

原文：https://towardsdatascience.com/build-your-own-whatsapp-chat-analyzer-9590acca9014?source=collection_archive---------1-----------------------

最近，在完成了 Udacity 课程中的一些项目后，我开始寻找新的、熟悉的数据进行分析，还有什么地方比自己的手机更好呢？

Whatsapp 声称每天发送近 550 亿条信息。普通用户每周在 Whatsapp 上花费 195 分钟，并且是许多团体的成员。

有了这个就在我们眼皮底下的数据宝库，我们就必须着手一项任务，深入了解我们的手机被迫见证的信息。本文旨在逐步指导您构建自己的 whatsapp 对话分析器，分为以下 3 个主题:

• 数据收集
• 数据准备
• 数据探索

先决条件

在您开始之前，确保您的 Python 环境中安装了以下包(我推荐使用 Jupyter，因为您可以在遵循本教程中的步骤时很容易地看到中间输出):

• 熊猫
• 海生的
• Matplotlib
• Jupyter(可选但有用，因为你可以在遵循本教程中的步骤时很容易地看到中间输出)或者如果你像我一样懒，不想安装这些包中的任何一个，只需前往谷歌协作实验室(【https://colab.research.google.com】T2)，这是一个免费的 Jupyter 笔记本环境，预装了所有东西，并立即开始！

数据收集

首先，我们需要一个 whatsapp 对话来分析。打开您希望分析的 whatsapp 对话(最好是群聊，因为它们往往比较大)，使用“导出聊天”功能将整个对话以文本格式发送到您的电子邮件 ID。

重要提示:当 whatsapp 提示时，确保不要导出任何媒体，否则可能需要很长时间才能导出。

从您的电子邮件收件箱下载导出的聊天内容。它应该如下所示:

18/06/17, 22:45 - Messages to this group are now secured with end-to-end encryption. Tap for more info.
25/09/16, 21:50 - Nick Fury created group "Avengers"
18/06/17, 22:45 - Nick Fury added you
18/06/17, 22:45 - Nick Fury added Hulk
18/06/17, 22:45 - Nick Fury added Thor
18/06/17, 22:45 - Nick Fury added Tony Stark
18/06/17, 22:29 - Tony Stark: Here are the details for tomorrow's picnic:The park is located at 123 Main Street. Bring your own snacks, we will also be grilling. It is going to be very warm so dress appropriately. We should be getting there at noon. See you then and don't forget the sunscreen.
18/06/17, 22:46 - Hulk: HULK NO CARE
18/06/17, 22:46 - Hulk: HULK NO FRIEND HERE
18/06/17, 22:46 - Hulk: HULK HATE LOKI
18/06/17, 22:46 - Hulk: GFCHGK
18/06/17, 22:47 - Thor: Stop pressing every button in there
18/06/17, 22:47 - Loki: Why do you have 2 numbers, Banner?
18/06/17, 22:48 - Hulk: HULK FIRST SMASH YOU THEN TELL YOU

数据准备

Background photo created by freepik — www.freepik.com

就像生蔬菜必须用各种香料烹饪和点缀才能使它们对人类可口一样，这个纯文本文件也必须以有意义的方式进行解析和标记，以便在熊猫数据帧中提供(存储):

让我们只考虑文本中的一行(我们称之为“raw text”)，看看我们如何从中提取相关的列:

18/06/17, 22:47 - Loki: Why do you have 2 numbers, Banner?

此后，每当我希望把你的注意力吸引到字符串 s 中的不同记号时，我会向你展示两行。

• 第一行将显示{花括号}中的标记名以及它们在 s 中的相对位置。
• 第二行将是字符串 s ,它被修改以指示对应于每个标记的实际值，用花括号括起来。

例如，如果字符串 s 是“单词 1，随机单词单词 2:”，那么我将提供以下定义:

{Token 1}, random word {Token 2} {Token 3}
{Word 1}, random word {Word 2} {:)}

由此，您将能够推断出令牌 1 的值是“单词 1”，令牌 2 的值是“单词 2”，令牌 3 的值是“😃”。

在我们的示例文本行中，我们的主要目标是将原始消息自动分解成 4 个令牌，我们将在下一节中了解如何完成这项任务:

{Date}, {Time} - {Author}: {Message}
{18/06/17}, {22:47} - {Loki}: {Why do you have 2 numbers, Banner?}

步骤 1:检测{Date}和{Time}令牌

首先，为了检测一行文本是新消息还是属于多行消息，我们必须检查该行是否以日期和时间开始，为此我们需要一点正则表达式 (regex) 匹配(不要担心——一旦你把它分解，就没那么令人困惑了，特别是用一些我马上会展示给你的漂亮工具)。让我们定义一个名为 startsWithDateTime 的新方法:

下图显示了正则表达式匹配如何检测邮件中的日期和时间:

下图简要概述了在示例文本文件中检测到的所有消息:

我不会深究正则表达式实际上是如何工作的细节，但如果你感兴趣，你可以通过访问https://regex101.com/和https://medium . com/tech-taja wal/regular-expressions-the-last-guide-6800283 AC 034找到关于这种匹配是如何完成的更多解释。

回到我们的示例行，在我们运行 startsWithDateTime 方法之前，在我们的原始示例消息中没有检测到令牌:

{Raw Message}
{18/06/17, 22:47 - Loki: Why do you have 2 numbers, Banner?}

在我们运行了 startsWithDateTime 方法之后，在我们处理的示例消息中检测到了2令牌:

{Date}, {Time} -Message
{18/06/17}, {22:47} - Loki: Why do you have 2 numbers, Banner?

步骤 2:检测{Author}令牌

现在我们已经确定了包含带有日期和时间组件的新消息的行，让我们移动到消息的下一部分(hypen 之后的所有内容):

Loki: Why do you have 2 numbers, Banner?

同样，我们将需要更多的正则表达式匹配。我们的目标是找出这条信息的作者。虽然根据您在手机联系人应用程序中保存朋友姓名的方式，可能有多种模式，但我确定的最常用模式如下(您可以随意添加或删除您认为合适的任何规则):

记住这些规则，现在让我们定义一个名为 startsWithAuthor 的方法，该方法查找至少与上述规则之一匹配的字符串:

下图显示了正则表达式匹配如何检测邮件中的作者:

下图简要概述了示例文本文件中检测到的所有作者:

你可以通过访问https://regex101.com/找到更多关于如何匹配的解释

在我们运行 startsWithAuthor 方法之前，已经在我们处理的示例消息中检测到了2令牌 s:

{Date}, {Time} -Message
{18/06/17}, {22:47} - {Loki: Why do you have 2 numbers, Banner?}

在我们运行了 startsWithAuthor 方法之后，在我们处理过的示例消息中检测到了 4 个令牌。

{Date}, {Time} - {Author}: {Message}
{18/06/17}, {22:47} - {Loki}: {Why do you have 2 numbers, Banner?}

注意:您可能想知道消息令牌是如何凭空出现的。好了，一旦我们检测到了日期、时间和作者标记，我们剩下的就是字符串的剩余部分，也就是事实上的消息标记

步骤 3:提取和组合令牌

既然我们已经能够识别单个消息中的日期、时间、作者和消息标记，那么是时候根据分隔符标记(如逗号(，)、连字符 (-)、冒号(:)和空格())来拆分每一行了，以便可以这一次，让我颠倒一下，突出显示分隔符标记，而不是日期、时间、作者和消息标记:

Date{Comma }Time{ Hyphen }Author{Colon }Message
18/06/17{, }22:47{ - }Loki{: }Why do you have 2 numbers, Banner?

让我们定义一个名为 getDataPoint 的新方法，用于根据分隔符标记分割字符串以提取感兴趣的标记:

示例输出值显示在每行旁边的注释(#)中。

注:计算作者令牌的值何时可以为 None 留给读者作为练习。

步骤 4:解析整个文件并处理多行消息

我们已经到了数据解析的最后阶段，为此我们必须读取整个 whatsapp 文本文件，从每一行中识别和提取标记，并在一个列表中以表格格式捕获所有数据:

使用以下代码初始化 pandas 数据帧:

你会发现你所有的数据列表如下(看起来很整洁，不是吗？):

数据探索

Image obtained from https://www.flocabulary.com/lesson/age-of-exploration/

最后，我们到达了旅程中最激动人心的部分之一——数据探索。是时候让我们挖掘这些数据试图告诉我们的有趣故事了。

描述数据框

首先，让我们看看熊猫对我们的数据帧 (df) 有什么看法:

该命令显示数据帧中每一列的条目数量(计数)、唯一条目、最频繁出现的条目(顶部)和最频繁出现的条目(频率)。

输出可能如下所示:

非常健谈

谁是最饶舌的成员？我们来看看群里前 10 位作者的发消息量。

没有作者的神秘消息！

还记得几节之前，我给你做了一个练习，让你知道某些消息的作者可能是 None 吗？好吧，如果你还没有弄明白，你不必担心，因为这一部分的结果可能会给你一个线索。

让我们使用下面的代码找到所有没有作者的消息:

你在这些信息中看到了什么规律吗？

媒体超载

浏览原始文本文件或整个数据框时，您可能会注意到包含以下字符串的消息: " <媒体省略> " 。这些消息代表任何图片、视频或音频消息。

让我们使用以下代码找到所有媒体消息，并分析组中发送媒体消息的前 10 名作者发送的媒体消息的数量:

你能看出发送信息最多的作者和发送媒体信息最多的作者之间有什么不同吗？

我们不需要媒体也不需要鬼魂

由于我们仅限于分析组中朋友发送的纯文本消息，因此让我们创建一个新的数据帧 (messages_df) ，通过丢弃所有媒体消息或没有作者的消息，使用前两部分获得的数据帧:

这一步可以归类为数据清理。如果您还想深入了解整个非文本数据，可以跳过这一步。

如果你不收集任何指标，你就是盲目飞行。

计算每个作者在每条消息中使用的字母和单词的数量可能会很有趣。因此，让我们使用下面的代码，向名为“Letter _ Count”和“Word _ Count”的数据帧添加 2 个新列:

这一步可以归类为数据扩充。

现在，让我们描述清理和扩充的数据帧。这里需要注意的一个要点是包含连续值的列与包含离散值的列之间的区别:

尝试在不指定任何列的情况下对整个数据框运行 describe 命令。你观察到了什么？

“艺术的殿堂是用语言建造的”和“l”，“e”，“t”，“t”，“e”，“r”，“s”

让我们后退一步，看看整体情况。自从有时间以来(在这种情况下，恰好是从这个团体诞生的那一刻起)，已经发送了多少单词和字母？

运行这段代码发现，复仇者联盟使用了多达 1，029，606 个字母和 183，485 个单词。

"当然，语言是人类使用的最有效的药物."

有史以来，每个作者总共发了多少字？

一条信息中最常见的字数是多少？

看起来大多数消息只包含一个单词。我想知道那个词是什么！

能够给别人写一封信是多么美好的事情啊！

同样计算自时间开始以来每位作者发出的信件总数有意义吗？好吧，既然我们已经有了一个“信件数量”专栏，我看不出这样做有什么坏处。所以，现在开始:

信息中最常见的字母数是多少？

看起来大多数邮件只包含 1 或 2 个字母。嗯！很有意思！这些字母是来自英语还是其他符号？

记得，记得，十一月五日火药叛国和阴谋

你知道你们组历史上发送消息最多的日期吗？好了，不要再害怕了，因为你马上就会发现:

2017 年 9 月 22 日是最活跃的日期。这是灭霸袭击的日子吗，让每个人都惊慌失措，充满疑问？你得到了几号？你记得这一天有什么重要的事情发生吗？

时间是一种幻觉

你晚上睡不着觉，想知道一天中什么时候你的团队最活跃吗？真相将被揭露:

看起来这个组织大多在晚上 8:15 左右活动。请务必在此时发送消息，以便获得更快的回复。

当前的需要

一天中什么时候最适合发信息来增加你得到某人回复的机会？

为了回答这个问题，我们必须扩充数据框，以包含一个小时的新列(从“时间”列中提取)，如下所示:

现在，您只需运行类似于获取热门日期和时间的代码:

看起来下午 6 点到 7 点之间发信息最有可能引起团队成员的回应。

结论

恭喜你！您现在对 whatsapp 对话更加了解了！那些是相当多的见解，不是吗？你从谈话中获得了什么样的见解？你觉得它们有用吗？你有没有发现这里没有提到的其他有用的见解？请随意在评论区添加您的想法，以便我改进本指南。

这种分析并不是探索和分析的全部。我还没有考虑到像表情符号这样的东西，它们在对话中使用得相当多。或者他们是？我应该抛弃标点符号吗？为什么大多数消息只包含一个单词？

似乎我们的分析在回答了很多问题的同时，也打开了新问题的潘多拉魔盒。嗯，这不是结束。请继续关注不久的将来的一篇文章，在那里我将尝试更深入地挖掘这些问题。

在那之前，再见了，朋友们，祝探索愉快！
来自我的问候……耶我！

打造您的个人语音助手

原文：https://towardsdatascience.com/build-your-personal-voice-assistant-cec7785508da?source=collection_archive---------10-----------------------

通过语音命令在计算机上执行任务

我一直对 Siri、Alexa、谷歌助手或任何其他语音助手的工作方式很着迷。它通过自动化任务使用户的生活变得更加容易。因此，我决定构建自己的语音助手，它将从我的笔记本电脑上的麦克风收集命令，并使用它来执行任务。

资料组

我选择了 5 个我觉得任何人都可能经常使用的简单命令，并决定录下自己说这些命令的过程。我假设当用户说出命令时不会有任何背景噪音。这使得事情变得容易得多，因为我不必担心从噪音中分离出实际的命令，这需要对音频进行一些预处理。

这五个命令是:

• ‘降低音量’—降低系统音量
• ‘增加音量’—增加系统音量
• ‘打开谷歌’—在浏览器中打开谷歌网页
• “显示 CPU 利用率”—显示正在运行的进程的性能详细信息
• “拍照”—使用笔记本电脑摄像头点击照片

因为我将使用深度学习模型来预测命令，所以我将需要每个类的大量数据。我使用下面的脚本，通过我的笔记本电脑麦克风为每个命令录制了 20 个样本，其中节奏和音调略有不同。每个样本的长度为 2 秒，刚好大于任何人说出任何命令所需的平均时间。

https://gist.github.com/grohith327/deedd75d73070e7667eef1977162a390

我们可以从记录的 20 个样本中随机抽取 1 秒的作物，并附加 1 秒的静默。这将为我们提供每门课的大量数据。我们使用下面的脚本获取 200 个这样的作物。

https://gist.github.com/grohith327/2f9121157039840a77b5d527e2313f06

现在我们已经为每个类准备了大约 220 个样本(200 个裁剪样本和 20 个原始样本),我们可以考虑对音频样本进行一些预处理。

音频预处理

录制的语音命令存储为。wav 文件，如果我们能得到音频文件的声谱图，我们可以把它当作一个图像，并把它输入 CNN，对音频进行分类。幸运的是，python 库 librosa 让事情变得简单多了，我们可以很容易地用这个库生成音频的频谱图。以下脚本用于生成声谱图。

https://gist.github.com/grohith327/0e6b2071b8e3f57961a24d06c495fe33

为了生成声谱图，我们对音频数据进行短时傅立叶变换。傅立叶变换用于将信号从时域转换到频域，我们这样做是为了了解信号变化的程度。短时傅立叶变换是一种扩展，它采用小窗口，将其与信号进行卷积，并在卷积窗口内应用 DFT，现在我们在信号上移动窗口，迭代执行 DFT。

我们可以使用上面的脚本可视化所有五个命令的频谱图。

我们可以观察到命令“增大音量”和“减小音量”似乎具有相似的频谱图，因为单词“增大”和“减小”之间只有很小的差别。

我们现在可以为每个音频样本生成声谱图，并使用以下脚本将其转储到 numpy 数组中。(注意:我们填充光谱图，以便所有维度匹配)

https://gist.github.com/grohith327/ce30475cd508e0f196fb4face38f47ca

既然我们已经将音频样本及其相应的标签保存到了一个. npy 文件中，我们可以随时加载它们，而不是每次都生成频谱图。

构建模型

我们可以将频谱图视为图像，并尝试从这些图像中识别有助于我们识别音频样本类别的特征。我们可以使用卷积神经网络，它将图像作为输入，学习图像的空间特征并预测类别。

在构建模型之前，我们将数据分为训练集和测试集。我们还使用下面的脚本将标签转换成一个热编码。

https://gist.github.com/grohith327/3d3ab1759f6a7a41654cbedbcd5dd7e8

我们现在可以开始构建卷积神经网络，为此我们将使用 TF 2.0 作为我们的框架。要了解如何在 Tensorflow 2.0 中构建 CNN，请点击此处。

https://gist.github.com/grohith327/3ff5da311fe03e0a8cc615bf7435ae83

我们现在可以为 15 个时期训练我们的模型，我们评估我们的交叉熵损失模型，并使用 RMSProp 作为我们的优化器。

https://gist.github.com/grohith327/3ff5da311fe03e0a8cc615bf7435ae83

我们的模型学习频谱图的内在特征，并根据语音命令的类型区分它。经过 15 个时期的训练，我在测试数据上观察到了 96%的准确率。我们现在可以保存我们的模型，并使用它来预测我们的语音命令的类别并执行任务。

自动化任务

我们使用笔记本电脑的麦克风连续记录音频，并将其分成 2 秒钟的样本，然后输入到我们的模型中进行预测。如果我们的模型能够以高置信度对命令进行分类，我们就执行该任务。以下是通过 python 执行每个命令的脚本。(注意:根据操作系统，某些命令可能需要不同的库来执行，以下脚本适用于 macOS)

降低音量

https://gist.github.com/grohith327/9192644cc40d2d1a2c0cc963dc5520ca

增加量

https://gist.github.com/grohith327/5a7140d573b9416175d0b334da516260

打开谷歌

https://gist.github.com/grohith327/102a2ec2e16a81956a7bc2a7a0a248a5

显示 CPU 利用率

https://gist.github.com/grohith327/41c810a36097905747f0d5aad57c3500

照相

https://gist.github.com/grohith327/becb9a96274d04a8e97cac5a6e23abdf

我们现在可以编写一个脚本，它可以无限期地通过笔记本电脑麦克风监听语音命令，并将其分成 2 秒的间隔，然后使用该样本从 CNN 模型中获得预测。如果我们的 CNN 模型能够以高置信度对样本进行分类(这是因为我们不想在没有命令或静默的情况下执行任务)，我们就执行该任务。代码如下。

https://gist.github.com/grohith327/27b51531eb7f27f3de26be4af53a45cb

https://gist.github.com/grohith327/27b51531eb7f27f3de26be4af53a45cb

演示

结论

这种方法有点天真，因此它并不完美，正如你在上面的视频中看到的，它两次都没有识别出命令，但是，这是我们可以在短时间内构建和测试的东西(也很有趣！).

这只是你能做的一个例子。如果你愿意，你可以选择通过不同的命令来自动完成不同的任务，甚至可以扩展命令的数量，并且仍然可以获得很好的准确性。

参考

[## 利布罗萨/利布罗萨

一个用于音乐和音频分析的 python 包。参见 http://librosa.github.io/librosa/的完整参考手册…

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

用这些数据为好的项目想法建立你的投资组合

原文：https://towardsdatascience.com/build-your-portfolio-with-these-data-for-good-project-ideas-919254357a66?source=collection_archive---------8-----------------------

Credit: Unsplash

从数据可视化到数据科学，获得创造的灵感。

这篇文章的灵感来自于我在 数据中的女性*打造你的数据科学工具箱 研讨会上的一次演讲，题目是“数据(科学)为善”*

在我成为数据科学家的过程中，我建立了自己的项目组合，这些项目展示了我的硬技能，同时也为社会事业做出了贡献。例如，当我注意到 sports analytics 没有太多关于女子运动队的分析时，我使用了一种无监督的机器学习算法来建立 WNBA 球员的梦之队。或者当我不断听到人工智能中的偏见时，我决定建立一个机器学习模型来减轻 AI 中的偏见。在这两个项目中，我展示了作为一名数据科学家的艰苦技能，同时也为更大的利益做出了贡献并坚持了我的价值观。为了回馈数据专业人士社区，我想分享一些资源和技巧，以帮助您为优秀项目增加数据。

放下恐惧，开始吧

Credit: WOCinTech Chat.

我想与你分享的第一个技巧是，放下恐惧，开始使用你已经掌握的数据项目工作技能。在我成为数据科学家的早期，我最喜欢使用 Excel 来解释数据。当时，我不知道如何用 python 开发机器学习模型。利用我当时拥有的技能，我本可以开始从事数据驱动的项目——但唯一阻止我的是恐惧。如果您正处于学习成为数据专家的专业技能的初级阶段，您仍然可以使用现有的技能从事项目工作。我希望我能回到过去，告诉自己这些，但是因为我不能，所以我写这篇文章来告诉你——开始吧！我试着在这里包含一些资源，每个人都可以从中受到启发，不管你是新手还是专家。

创建项目工作流

Download the Data Science Workflow Canvas.

不管你是否知道你想从事哪种数据驱动的项目，或者你还不确定，开始集思广益吧。头脑风暴、制定战略、构思——这些词的一个共同点是租户认为没有所谓的“错误”想法。对于任何想要一种结构化方式来头脑风暴数据科学项目工作流的人，我设计了这幅画布(如上图)来帮助你开始。如果你需要其他工具来帮助你制定项目工作流程，你也可以尝试手绘或数字化思维导图，使用设计思维工具，或者简单地打开一个空白的 word 文档(或者如果你是模拟型的人，翻到笔记本的空白页)并开始写下你的想法。

良好数据集的数据

Credit: Unsplash

既然您已经有了如何制定项目工作流程战略的想法，您就可以开始使用这些数据换好的数据集了。或者你也可以收集你的数据，或者出去收集你自己的数据。我在下面列表中分享的大多数门户网站都提供易于下载的数据集。这些资源中的一些并不纯粹关注“数据的好处”，但仍然有相关的数据集可以下载。最后，这些只是众多数据集的一小部分！

• 人道主义数据交换
• 美国主要博物馆中艺术家的多样性
• 民权数据收集
• 政府开放数据库:美国开放数据，美国城市开放数据
• 气候数据
• 性别数据门户
• 健康数据
• Kaggle 的数据科学为好:洛杉矶市
• 穿越时间线
• 多样性数据
• FiveThirtyEight:我们的数据
• 或者你可以使用谷歌的数据集搜索来找到其他东西

数据可视化

Credit: Amazon

数据可视化是一个强大的工具，可以传达您从数据分析中收集到的见解，尤其是如果您正在进行一个有益于数据的项目。这些是我最喜欢的展示数据可视化的资源。

• 杜波依斯的数据画像:可视化美国黑人
• 莫娜·沙拉比
• 乔尔吉亚·卢皮

出版物/博客

Source: Gayta Science

这些只是一些以数据驱动的文章集合为特色的博客和/或出版物。

• 布丁
• 盖塔科学
• 她的篮圈统计数据
• 空间研究中心
• 数据女权主义 ( 帽尖米切尔·博曼与我分享这个！)
• 数据&社会

介入

Credit: Unsplash

有很多方法可以参与进来，围绕“数据为善”的理念建立社区这里有一些你可以参与的方法，无论是通过为一个组织做志愿者还是参加一个会议。

• 黑人生活数据
• AI4All
• LatinX in AI
• 数据种类
• 数据中的女性
• AI 中的黑色
• 机器学习和数据科学领域的女性
• 数据为好:加拿大
• R-女装
• 皮拉迪斯
• 酷儿在艾

结论

Credit: Unsplash

我希望这些资源能激励您创建数据为善的项目！请记住，这些资源只是可用资源的一个快照。如果你想分享更多你参与过的资源或项目，请在下面评论！

—

感谢 Anuva Kalawar 总是与我分享数据换好处的资源。

Jasmine Vasandani 是一名数据科学家和战略家。你可以在这里了解她的更多:【https://github.com/jasminevasandani/about_jasmine】。

为人工智能构建后端系统

原文：https://towardsdatascience.com/building-a-backend-system-for-artificial-intelligence-c404efade360?source=collection_archive---------23-----------------------

构建可扩展“人工智能”系统的挑战

让我们探讨一下构建一个后端系统来存储和检索高维数据向量所面临的挑战，这是使用“人工智能”的现代系统的典型特征，包括图像识别、文本理解、文档搜索、音乐推荐等

在我的上一篇文章中，我提到了一个我写的用来替代第三方 API 的系统。新系统由三部分组成:
1。领域逻辑服务—“人工智能”
2。存储检索服务
3。后备数据存储(Redis)

域逻辑服务处理输入数据，并生成代表数据的 1024 维规范化向量。然后传递给存储和检索服务进行持久化。
在检索时，域逻辑服务从输入中产生另一个向量，该向量使用相同的处理逻辑和存储进行转换&检索服务的任务是产生一组已经保存在系统中的与给定输入最相似的向量。

以这种方式分解系统的原因是因为存储和检索本身就是一个具有挑战性的问题。为了隔离问题，我将它放在一个自包含的服务中。下文旨在解释原因。

向量相似度

因为我们使用向量，所以让我们将两个向量的“相似性”定义如下:
如果
a) a 与 b 相同或者
b)向量 a 与 b 之间的距离小于向量 b 与数据集中任何其他向量之间的距离
并且该距离低于给定阈值，则向量 a 与输入向量 b 相似。

向量之间的距离有不同的计算方法:
1。欧几里德距离
2。余弦距离
3。笛卡儿及其思想的

Visual representation of euclidean distance (d) and cosine similarity (θ)

这是欧几里德距离(d)和余弦相似度(θ)的直观表示。余弦着眼于向量之间的角度(因此不考虑它们的重量或大小)，欧几里得距离类似于使用尺子来实际测量距离。

当向量的大小无关紧要时，余弦相似性通常用作测量距离的度量。这正是我们在这里要用的。我们的向量标准化地进入存储和检索服务(所有向量都是长度为 1 的单位向量)。

既然我们已经确定了寻找“相似”向量意味着什么，那么让我们看看真正的挑战——检索相似向量集。

挑战

寻找相似向量的强力方法是获取输入并计算与数据集中每个其他向量的余弦相似性。将 vector 与“所有其他向量”进行比较并不能很好地扩展(它是线性的— O(n))，考虑到向量的维数，您可以看到当数据集增长时，这变得非常无效。如果你需要一个每秒处理大量查询的实时系统，那就不太现实了…

局部敏感散列法

相反，我们将使用本地敏感散列法(LSH)。在计算机科学中，LSH 是一种算法技术，它以很高的概率将相似的输入项散列到相同的“桶”中(桶的数量远小于可能的输入项的总数)。

LSH 主要不同于传统的散列法(又名加密)，因为加密散列法试图避免冲突，而 LSH 的目标是最大化相似输入的冲突。

对于 LSH，彼此靠近的向量(“相似”)具有相同的散列值，而远离的向量具有不同的散列值(“不相似”)。
这为我们提供了一个潜在的解决方案——如果我们使用 LSH 散列我们的向量，我们可以减少匹配检索所需的向量比较次数。
我们可以将搜索限制在一个桶(或一组桶)中，以显著减少计算余弦距离的向量数量。
但是，如果我们考虑具有数百万个向量的数据集，那么即使在一个桶中，要搜索的向量的数量仍然很大。稍后会详细介绍。

然而，这是有代价的。在之前的 LSH 定义中，你应该关注的关键词是“概率”。LSH 不是一个精确的算法，它使用近似值。不能保证数据集中的相似向量最终会出现在同一个桶中。这取决于我们提供给算法的参数，即相似的向量具有相同散列的“可能性”有多大。

这里需要注意的一件重要事情是，对于我的用例，相似性截止(阈值)是余弦距离 0.36，这非常宽，这使得 LSH 的使用更加困难，因为你需要考虑更广泛的向量集。LSH 最擅长处理非常接近的向量。

幸运的是，我们有一个优势。我们不需要一个最相似的向量。我们可以近似。一旦找到第一个距离小于阈值的向量，我们就可以在桶内终止搜索。我们举个面部识别的例子。这里，系统中的每个向量代表一张脸。但是每个人都有多张相关的脸(他或她的多张照片)。假设我们正在使用另一张脸作为输入来搜索一个人。我们不需要检索单个最近的向量——最相似的脸。我们只需要一张足够“接近”的脸(低于指定的阈值)。根据定义，该阈值应该保证低于该阈值的每个这样的向量代表同一个人。

在为本文收集笔记时，我决定对我当前的实现进行测试，以了解我的系统的性能，并看看我是否可以对它进行改进。好家伙，我学到了很多东西！

基线

因为我的目标是观察(并希望改进)我当前的实现，所以我首先必须建立一种方法来测量被观察的系统，然后建立一个我们试图改进的基线。

我很幸运，因为我已经开发和测试我的系统有一段时间了，我有来自测试用户的“真实世界”数据可以使用。
为了设置我的实验，我手工挑选了大约 250 个向量的数据集作为我的系统的种子，并挑选了近 3000 个向量用于相似性检索
(即“250 个种子向量中有任何一个与 3000 个测试向量中的每一个相似吗？”).如果你要谈论生产规模，这不是一个巨大的数据集，但请记住，我们希望用它来观察我们算法的准确性，而不是硬件性能。为此目的，它应该是足够的。同样值得注意的是，这个数据集不能与用于训练人工智能子系统的数据集混淆。这已经在数百万个数据点上进行了预先训练，超出了我们今天讨论的范围。

为了建立准确性基线，我使用了简单的“蛮力”方法。这样，我总是保证得到最准确的结果，代价是将我的输入与“数据库”中的每一个向量进行比较。这就是可怕的 O(n)线性性能。

“匹配”总数为 673，相似性分布如下:

Similarity distribution histogram for baseline scenario (no approximation)

显而易见，在这种情况下找到“正确”匹配的概率总是 1。也就是说，如果一个相似的向量存在，它将被检索。查看不同算法的概率图将是理解其准确性的关键。

Probability of retrieving correct match in brute-force approach

接近

接下来，我决定测量我当前实现的算法。与 LSH 一起进入问题近似的世界。理想情况下，我们希望 LSH 降低搜索的复杂性(比线性更好),但保持准确率在——或接近——100%。为了实现这个圣杯，我们需要提出一个阶跃函数，将所有低于阈值的向量散列到同一个桶中，将所有其他向量散列到不同的桶中。如果我们在特定的桶中搜索向量，我们会大大减少搜索空间，但我们保证会找到相似的向量(假设它们存在于我们的数据集中)。

Ideal case — step function

首先，我们需要从输入向量中计算二进制散列。为此，我们将空间划分为 n 个随机平面。对于每一个平面，矢量都位于该平面分隔的两个区域之一。如果向量在正侧，我们赋值 1，如果向量在负侧，我们赋值 0。直觉上，两个文档越接近，它们越有可能在随机平面的同一区域。例如，如果两个文档几乎在彼此之上，那么对于你能想到的大多数平面来说，它们将在相同的区域结束。

对于随机绘制的平面，可以从数学上证明两个文档 x 和 y 以概率散列到相同的值:

这个表达式概括了我们的直觉:两个文档越接近(小θ)，它们出现在同一区域的可能性就越大。

如果我们仅使用一个平面将我们的空间分成两半，则两个向量具有相同散列的概率将是:

Probability of two vectors having same single-bit binary hash

您可以将这解释为余弦相似度为 0.36(阈值)的两个向量被散列到同一个桶中的概率大约为 0.72 (72%)。这起初听起来不错，但这也意味着在 0.38 (38%)的情况下，相似的向量将散列到不同的桶(因此我们不会找到我们的匹配)。我们只减少了 50%的搜索空间。考虑到我们损失了相当多的准确性，这不是一个好的优化。

让我们添加更多的随机平面，最终得到一个如下所示的散列:

01110011

(通过将空间除以 8 个随机超平面构建的 8 位散列)

现在我们的概率降低了。向量不太可能散列到同一个桶中，除非它们几乎相同。如果你还记得的话，这正是我们早期关于 LSH 建立的——该算法最适合非常接近的匹配(向量之间非常小的余弦距离)。

Probability of two vectors having same 8bit binary hash

但是我们可以采用不同的技术来改善我们的处境。

• 探索附近的桶
• 考虑部分哈希匹配

附近的桶

为了探索附近的桶，我添加了汉明距离散列变量。这个想法很简单:一旦我们获得了 LSH 散列，我们就计算该散列在 n 个距离内的变化。这允许对根据我们的标准相似但最终在不同桶中的向量进行纠错。

如果我们取前面例子中的散列，汉明距离 1 的变化将是:

11110011
00110011
01010011
01100011
01111011
01110111
0111000【T19

对于汉明距离 2，我们得到:

10110011
11010011
11100011
11111011
11110111

00010011
0010011
0111011
00110111
00【T77

01000011
01011011010111
0101000
101

等等。

在我的例子中，我选择的汉明距离为 3，这总共产生 1+8+7 * 8/2+6 * 7/2+5 * 6/2+4 * 5/2+3 * 4/2+2 * 3/2+1 * 2/2 = 93 个变量。这给了我们找到正确匹配的概率:

8bit hash with Hamming distance 3

这比前一种情况好得多，曲线的形状开始类似于理想的阶跃函数。但是在准确性(近似值)和性能(获得结果所需的时间/资源)之间有一个明显的折衷。

与基线相比，这种配置给出了令人满意的 93%的准确度，并且子线性复杂度在搜索空间中提供了平均 63.7%的减少。让我解释一下:在一个假设的场景中，我们的数据库中有 100 万个均匀分布的向量，我们在 256 个桶的每个桶中保存了大约 3906 个
向量(8 位哈希= 256 个不同的桶)。我们每个查询需要搜索 93 个桶，这给了我们大约 363281 个向量要搜索(100 万个存储向量的 36.3%)。但是我必须强调的是，这些计算是理想化场景中的平均结果(均匀分布的向量)，实际上，向量会更集中在一些桶中，从而为不同的查询产生非常不同的结果。

这是一个适度的改进，但也让我们损失了 7%的准确性。换句话说，在 7%的情况下，数据库中有一个相似的向量，但我们没有找到它。

为了完整起见，让我解释一下实际的数据持久性是如何实现的。我使用 Redis，每个散列都简单地转换成数据存储中的一个键。Value 是一个 Redis 向量列表，它将与查询响应中返回的元数据一起被搜索(例如，在音乐推荐服务中，元数据可以是一首歌曲的名称、一个艺术家等等)。

部分哈希匹配

作为最后一个实验，我尝试了一个略有不同的算法，这是我在研究 LSH 时发现的。

对于这个实验，我们生成更长的散列，但是将它分成多个组，并搜索每个桶，其中至少有一个散列组与查询中的一个组相匹配。

输入:011100111100100111001100

(24 位哈希分为 3 组)

如果我们有两个不同的向量存储在系统中，哈希为

答:00110010 11001001 10001100

b:110000111100100111001000

我们的输入向量将被认为类似于向量 b，因为第二组(11001001)匹配输入的第二组。

直到后来，当我开始分析我的结果时，
我才意识到我犯了一个错误，我只使用了 24 位散列分成 3 组。这第三个实验不可能超过我当前的实现。原因就摆在我面前:

24bit hash split in 3 groups

一旦我计算了概率图，我就明白了为什么与基线相比，我只看到了 71%的准确性。散列余弦距离为 0.36 的两个向量的概率下降到大约 22%。
虽然性能更好，但在我们拥有 100 万个向量的理想场景中，使用该算法我们只需比较(平均)约 12k 个向量，也就是说我们将搜索空间减少了 98.8%。

因为我们将散列分组，并且需要单独考虑每个组，所以我们需要不同的机制来查询 Redis 后端。

对于样本散列 01110011 11001001 11001100，我们将其分解为 3 个 Redis 键:

01110011 xx
x 11001001 x
xx 11001100

我们将向量存储在三个键的每个键下。这造成了数据的重复，但是当只有组成散列的一些组匹配时，允许我们找到向量。
在返回结果之前，我们还需要引入一个额外的步骤来过滤掉重复的结果。

我们能做得更好吗？

这是我一直在思考的事情。不仅仅是我——这是相当前沿的东西，许多比我聪明得多的人都在花大量时间开发新算法来查询大量高维数据。

我尝试了不同的配置来微调系统的精度和性能。但是到了最后，这仅仅是边际改善，虽然很重要，但并没有显著改变观察到的行为和(最好的)亚线性性能。

我也试着从不同的角度看待这个问题。我的系统存储了大量的向量，这些向量可能在存储后不久就会被使用，但更多的时候根本不会被使用。在大多数情况下，只有很小一部分向量最终会被返回为最相似的向量。

如果我们更积极地减少数据集的整体大小会怎么样？

我的计划是实现生存时间(TTL)，这是缓存中众所周知的概念，只在特定的时间窗口内保持向量“已使用”(已检索)(并且在每次使用向量时重新创建 TTL，甚至可能使用滑动窗口—第一个 TTL 为 1 小时，向量“已使用”后，下一个 TTL 将为 1 天，然后是 1 周，依此类推)。结合禁用某些向量的 TTL 的能力，我应该可以从数据集中清除大量向量，而不必太担心算法的性能。

未来要考虑的另一件事是并行处理。我们可以将数据集划分到不同的节点上进行存储和查询，然后将部分结果组合成最终结果(map-reduce)。或许，这将是另一个有趣的话题？

用 Python 和 PyMC3 构建贝叶斯逻辑回归

原文：https://towardsdatascience.com/building-a-bayesian-logistic-regression-with-python-and-pymc3-4dd463bbb16?source=collection_archive---------6-----------------------

我认购定期存款的可能性有多大？后验概率，可信区间，优势比，WAIC

在本帖中，我们将探讨如何使用贝叶斯逻辑回归来预测客户在银行开展营销活动后是否会认购定期存款。

我们希望能够实现:

• 客户认购定期存款的可能性有多大？
• 变量选择技术实验。
• 对变量 so 的探索是探索性数据分析的一个很好的例子，它可以指导模型的创建和选择过程。

我相信你熟悉数据集。不久前，我们使用标准的机器学习方法对这个数据集建立了一个逻辑回归模型。今天我们将应用贝叶斯方法来拟合逻辑回归模型，然后解释由此产生的模型参数。我们开始吧！

数据

此数据集的目标是创建一个二元分类模型，该模型根据许多指标预测客户在银行开展营销活动后是否会认购定期存款。目标变量被给定为y，如果客户已经订阅，则取值 1，否则取值 0。

这是一个类别不平衡的问题，因为没有认购定期存款的客户明显多于认购定期存款的客户。

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import pymc3 as pm
import arviz as az
import matplotlib.lines as mlines
import warnings
warnings.filterwarnings('ignore')
from collections import OrderedDict
import theano
import theano.tensor as tt
import itertools
from IPython.core.pylabtools import figsize
pd.set_option('display.max_columns', 30)
from sklearn.metrics import accuracy_score, f1_score, confusion_matrixdf = pd.read_csv('banking.csv')

作为 EDA 的一部分，我们将绘制一些可视化图形。

• 使用 seaborn 的stripplot函数探索目标变量与客户年龄的关系:

sns.stripplot(x="y", y="age", data=df, jitter=True)
plt.show();

Figure 1

• 使用 seaborn 的stripplot函数探索目标变量与 euribor3m 的对比:

sns.stripplot(x="y", y="euribor3m", data=df, jitter=True)
plt.show();

Figure 2

这里没什么特别有趣的。

下面是我使所有变量数值化的方法。你可能有更好的方法做这件事。

cat_to_num.py

单自变量逻辑回归

我们将从最简单的逻辑模型开始，仅使用一个独立变量或特征，即持续时间。

outcome = df['y']
data = df[['age', 'job', 'marital', 'education', 'default', 'housing', 'loan', 'contact', 'month', 'day_of_week', 'duration', 'campaign', 'pdays', 'previous', 'poutcome', 'euribor3m']]
data['outcome'] = outcome
data.corr()['outcome'].sort_values(ascending=False)

Figure 3

有了正确格式的数据，我们可以开始用 PyMC3 构建第一个也是最简单的逻辑模型:

• 将数据居中有助于采样。
• 确定性变量之一θ是应用于μ变量的逻辑函数的输出。
• 另一个确定性变量 bd 是边界函数。
• pm.math.sigmoid是同名的 Theano 函数。

logReg_model.simple.py

我们将绘制拟合的 sigmoid 曲线和决策边界:

logReg_viz.py

Figure 4

• 上图显示了非订阅与订阅的对比(y = 0，y = 1)。
• S 形(绿色)线是θ的平均值。这条线可以解释为订阅的概率，假设我们知道最后一次联系持续时间(持续时间的值)。
• 边界决策表示为一条(黑色)垂直线。根据边界决策，左边的持续时间值对应于 y = 0(非订阅)，右边的值对应于 y = 1(订阅)。

我们总结了推断的参数值，以便更容易地分析结果，并检查模型的表现如何:

az.summary(trace_simple, var_names=['α', 'β'])

Table 1

如您所见，α和β的值非常狭窄。这是完全合理的，因为我们正在将一条二元拟合线拟合到一组完全对齐的点上。

让我们运行一个后验预测检查来探索我们的模型捕捉数据的能力。我们可以让 PyMC3 为我们做从后面取样的艰苦工作:

ppc = pm.sample_ppc(trace_simple, model=model_simple, samples=500)
preds = np.rint(ppc['y_1'].mean(axis=0)).astype('int')print('Accuracy of the simplest model:', accuracy_score(preds, data['outcome']))
print('f1 score of the simplest model:', f1_score(preds, data['outcome']))

数据的相关性

我们绘制了一张热图来显示每个变量之间的相关性。

plt.figure(figsize=(15, 15))
corr = data.corr() 
mask = np.tri(*corr.shape).T 
sns.heatmap(corr.abs(), mask=mask, annot=True, cmap='viridis');

Figure 5

• poutcome & previous 有很高的相关性，我们可以简单的去掉其中一个，我决定去掉 poutcome。
• 与结果变量没有太多强相关性。最高正相关为 0.41。

使用具有多个独立变量的 PyMC3 GLM 方法定义逻辑回归模型

• 我们假设订阅结果的概率是年龄、工作、婚姻、教育、违约、住房、贷款、联系人、月份、星期几、持续时间、活动、pdays、先前和 euribor3m 的函数。为了从后验样本中抽取样本，我们需要指定一个先验和一个似然。
• 解释公式如下:

logit = β0 + β1(年龄)+ β2(年龄)2 + β3(工作)+ β4(婚姻)+ β5(教育)+ β6(默认)+ β7(住房)+ β8(贷款)+ β9(联系)+ β10(月)+ β11(星期几)+ β12(持续时间)+ β13(活动)+ β14(活动)+ β15(pdays) + β16(以前)+ β17(poutcome) + β18

• 然后，对数赔率可以转换为输出的概率:

• 对于我们的问题，我们感兴趣的是在给定所有活动的情况下，找出客户认购定期存款的概率:

• 数学问题解决后，我们可以回到数据上来。PyMC3 有一个模块 glm，用于使用 patsy 风格的公式语法定义模型。这看起来真的很有用，特别是对于用更少的代码行定义模型。
• 我们使用 PyMC3 从后部提取样本。使用的采样算法是 NUTS，其中的参数是自动调整的。
• 我们将使用所有这 18 个变量，并使用上面定义的公式创建模型。添加年龄 2 的想法是从本教程中借用的，比较最近的模型也是很有趣的。
• 我们也将年龄缩放 10，这有助于模型收敛。

logistic_model.py

Figure 6

以上我只展示了部分的痕迹图。

• 该轨迹显示了为所有变量抽取的所有样本。在左侧，我们可以看到模型参数的最终近似后验分布。右边是采样过程中每一步的单个采样值。
• 这个glm定义的模型表现得非常相似，并且找到了与我们之前创建的传统定义模型相同的参数值。

我希望能够回答这样的问题:

年龄和教育程度如何影响认购定期存款的概率？假设客户已婚

• 为了回答这个问题，我们将展示几个不同教育水平的人订阅定期存款的概率如何随年龄变化，我们想研究已婚客户。
• 我们将传入三个不同的线性模型:一个教育程度== 1(文盲)，一个教育程度== 5(基础. 9y)，一个教育程度== 8(大学.学位)。

age_education_marital.py

Figure 7

• 对于所有三种教育水平，随着年龄的增长，定期存款的概率会降低，直到大约 40 岁时，这一概率才开始增加。
• 每条曲线都是模糊的，这是因为我们为每个教育水平绘制了 100 条不同的曲线。每条曲线都是从我们的后验分布中抽取的。

让步比

• 一个人的教育程度会影响他或她定期存款吗？为了做到这一点，我们将使用比值的概念，我们可以这样估计教育的比值比:

b = trace['education']
plt.hist(np.exp(b), bins=20, normed=True)
plt.xlabel("Odds Ratio")
plt.show();

Figure 8

• 我们有 95%的信心，教育的优势比在以下区间内。

lb, ub = np.percentile(b, 2.5), np.percentile(b, 97.5)
print("P(%.3f < Odds Ratio < %.3f) = 0.95" % (np.exp(lb), np.exp(ub)))

• 我们可以这样解释:“在概率为 0.95 的情况下，优势比大于 1.055，小于 1.108，所以教育效应发生了，因为在保持所有其他独立变量不变的情况下，教育程度较高的人比教育程度较低的人至少有 1.055 的概率订阅定期存款。”
• 我们可以估计所有变量的优势比和百分比效应。

stat_df = pm.summary(trace)
stat_df['odds_ratio'] = np.exp(stat_df['mean'])
stat_df['percentage_effect'] = 100 * (stat_df['odds_ratio'] - 1)
stat_df

Table 2

• 我们可以这样来解释 percentage_effect:“教育水平每提高一个单位，定期存款的可能性就会增加 8%。同样，在保持所有其他独立变量不变的情况下，euribor3m 每增加一个单位，认购定期存款的可能性就会降低 43%。

可信区间

Figure 9

很难展示整个森林地块，我只展示了其中的一部分，但这足以让我们说，存在订阅定期存款的基线概率。除此之外，年龄对订阅的影响最大，其次是联系方式。

使用广泛适用的信息标准比较模型(WAIC)

• 如果你记得的话，我们增加了一个年龄 2 变量，它是年龄的平方。现在是时候问它对我们的模型有什么影响了。
• WAIC 是模型拟合的一种度量，可应用于贝叶斯模型，并且在使用数字技术进行参数估计时有效。阅读这篇论文了解更多信息。
• 我们将比较三个多项式复杂度递增的模型。在我们的例子中，我们对 WAIC 分数感兴趣。
• 现在循环所有的模型，计算 WAIC。

compare_models.py

• PyMC3 包括两个方便的函数，有助于比较不同型号的 WAIC。第一个函数是compare，它从一组轨迹和模型中计算 WAIC，并返回一个数据帧，该数据帧从最低到最高 WAIC 排序。

model_trace_dict = dict()
for nm in ['k1', 'k2', 'k3']:
    models_lin[nm].name = nm
    model_trace_dict.update({models_lin[nm]: traces_lin[nm]})dfwaic = pm.compare(model_trace_dict, ic='WAIC')
dfwaic

Table 3

• 我们更喜欢 WAIC 较低的型号。
• 第二个便利函数获取compare的输出并生成一个汇总图。

pm.compareplot(dfwaic);

Figure 10

• 空心圆圈代表 WAIC 的值，与之相关的黑色误差线是 WAIC 的标准偏差值。
• 最低 WAIC 值也用垂直灰色虚线表示，以便与其他 WAIC 值进行比较。
• 实心黑点是每个模型的样本内偏差，对于 WAIC 来说，与相应的 WAIC 值相差 2 pWAIC。
• 对于除排名第一的模型之外的所有模型，我们还得到一个三角形，指示该模型和排名第一的模型之间的 WAIC 差值，以及一个灰色误差条，指示每个模型的排名第一的 WAIC 和 WAIC 之间的差值的标准误差。

这证实了包含年龄平方的模型比不包含年龄平方的模型更好。

后验预测检查

与标准的机器学习不同，贝叶斯专注于预测的模型可解释性。但我很好奇，如果我们计算标准的机器学习指标，我们会得到什么。

我们将使用参数的平均值作为“最有可能”的估计值来计算指标。

bayesian_metrics.py

Figure 11

print('Accuracy of the full model: ', accuracy_score(preds, data['outcome']))
print('f1 score of the full model: ', f1_score(preds, data['outcome']))

Jupyter 笔记本可以在 Github 上找到。祝你一周愉快！

参考资料:

[## GLM:逻辑回归- PyMC3 3.6 文档

编辑描述

docs.pymc.io](https://docs.pymc.io/notebooks/GLM-logistic.html) [## 型号比较-pymc 3.6 文档

为了演示模型比较标准在 PyMC3 中的使用，我们实现了来自第 5.5 节的 8 所学校的示例…

docs.pymc.io](https://docs.pymc.io/notebooks/model_comparison.html)

这本书:用 Python 进行贝叶斯分析，第二版

用 scikit-learn 构建一个更好的亵渎检测库

原文：https://towardsdatascience.com/building-a-better-profanity-detection-library-with-scikit-learn-3638b2f2c4c2?source=collection_archive---------9-----------------------

为什么现有的库没有启发性，以及我如何建立一个更好的库。

几个月前，我需要一种方法来检测用户提交的文本字符串中的亵渎内容:

This shouldn’t be that hard, right?

为此，我最终构建并发布了自己的库，名为亵渎检查:

[## vzhou 842/亵渎性检查

一个快速、健壮的 Python 库，用于检查字符串中的攻击性语言。-vzhou 842/亵渎-检查

github.com](https://github.com/vzhou842/profanity-check)

当然，在我这么做之前，我在 Python 包索引 (PyPI)中寻找任何可以为我做这件事的现有库。搜索查询“亵渎”得到的结果只有一半还不错:

• 脏话(理想的包名)
• 更好——亵渎 : “灵感来自包 亵渎 本·弗里德兰 的 ，这个库比原来的快多了。”
• 亵渎过滤器(有 31 颗 Github 星，比大多数其他结果多 30 颗)
• 脏话过滤(采用机器学习，说够了吧？！)

然而，第三方库有时可能是粗略的，所以我对这 4 个结果做了尽职调查。

亵渎，更好的亵渎，亵渎过滤器

在快速浏览了一下profanity存储库之后，我找到了一个名为 wordlist.txt 的文件:

Sorry this image of profanities is so big…

整个profanity库只是这个 32 个单词列表的包装器！profanity只需查找其中一个单词就能检测出亵渎。

令我沮丧的是，better-profanity和profanityfilter都采取了同样的方法:

• better-profanity使用一个 140 字的单词表
• profanityfilter使用一个 418 字的单词表

这很糟糕，因为基于单词表的亵渎检测库非常主观。例如，better-profanity的单词列表中就包含了单词“suck”你愿意说任何包含“吸”字的句子都是亵渎吗？此外，任何硬编码的不良词汇列表将不可避免地是不完整的——你认为只有profanity的 32 个不良词汇吗？

Fucking Blue Shells. source: xkcd

已经排除了 3 个库，我把希望放在了第 4 个也是最后一个:profanity-filter。

脏话过滤器

profanity-filter使用机器学习！太棒了。

原来，是 真的 慢。下面是我在 2018 年 12 月运行的一个基准测试，比较了(1) profanity-filter、(2)我的库profanity-check、(3) profanity(有 32 个单词列表的那个):

A human could probably do this faster than profanity-filter can

我需要能够实时执行许多预测，而profanity-filter甚至还不够快。但是，嘿，也许这是一个经典的速度与准确性的权衡，对不对？

没有。

At least profanity-filter is not dead last this time

我在 PyPI 上找到的库都不能满足我的需求，所以我自己建了一个。

建筑物亵渎检查第 1 部分:数据

我知道我希望profanity-check基于数据进行分类，以避免主观(理解为:可以说我使用了机器学习)。我从两个公开来源收集了一个综合数据集:

• 来自t-Davidson/仇恨言论和攻击性语言的“推特”数据集，包含从推特上抓取的推文。
• Alphabet 的 Conversation AI 团队发布的来自 this Kaggle competition 的“维基百科”数据集，其中包含来自维基百科 talk page edits 的评论。

这些数据集中的每一个都包含了文本样本，这些样本是由人们通过众包网站手工标注的，比如Figure 8。

我的数据集最终看起来是这样的:

Combined = Tweets + Wikipedia

Twitter 数据集有一个名为class的列，如果推文包含仇恨言论，则为 0，如果包含攻击性语言，则为 1，如果两者都不包含，则为 2。我将任何一条class为 2 的推文归类为“不冒犯”，而将所有其他推文归类为“冒犯”。

维基百科数据集有几个二进制列(如toxic或threat)，表示该文本是否包含该类型的毒性。我将任何包含毒性类型的文本归类为“攻击性的”，而将所有其他文本归类为“非攻击性的”

建筑亵渎检查，第 2 部分:培训

现在有了一个干净的组合数据集(你可以在这里下载)，我已经准备好训练这个模型了！

我跳过了我是如何清理数据集的，因为老实说，这很无聊——如果你有兴趣了解更多关于预处理文本数据集的信息，请查看这个或这个。

Are you also surprised the code is so short? Apparently scikit-learn does everything.

这里有两个主要步骤:(1)矢量化和(2)训练。

矢量化:单词包

我使用了scikit-learn的 CountVectorizer 类，它基本上通过计算每个给定单词出现的次数，将任何文本字符串转换成一个向量。这就是所谓的袋字(鞠躬)表示法。例如，如果英语中仅有的单词是the、cat、sat和hat，则句子the cat sat in the hat的可能矢量化结果可能是:

“the cat sat in the hat” -> [2, 1, 1, 1, 1]

???代表任何未知单词，对于这个句子来说就是in。任何句子都可以这样表示为the、cat、sat、hat和???的计数！

A handy reference table for the next time you need to vectorize “cat cat cat cat cat”

当然，英语中有更多的单词，所以在上面的代码中我使用了fit_transform()方法，它做了两件事:

• Fit: 通过查看数据集中出现的所有单词来学习词汇。
• Transform :将数据集中的每个文本字符串转换成它的向量形式。

训练:线性 SVM

我决定使用的模型是线性支持向量机(SVM)，它是由scikit-learn的 LinearSVC 类实现的。这个和这个如果你不知道什么是支持向量机，是很好的介绍。

上面代码中的 CalibratedClassifierCV 是一个包装器，为我提供了predict_proba()方法，它返回每个类的概率，而不仅仅是一个分类。不过，如果最后一句对你来说毫无意义，你几乎可以忽略它。

你可以用一种(简化的)方式来思考线性 SVM 的工作原理:在训练过程中，该模型学习哪些单词是“坏的”，以及它们有多“坏”，因为这些单词在攻击性文本中出现得更频繁。就好像训练过程是在为我挑出“不好的”单词，这比用我自己写的单词表好多了！

线性 SVM 结合了我发现的其他亵渎检测库的最佳方面:它足够快，可以实时运行，但又足够健壮，可以处理许多不同类型的亵渎。

警告

话虽如此，profanity-check远非完美。让我明确一点:对profanity-check的预测持保留态度，因为也会犯错。例如，它不擅长挑选不太常见的脏话变体，如“f4ck you”或“you b1tch ”,因为它们在训练数据中出现的频率不够高。你永远无法检测出所有的脏话(人们会想出新的方法来逃避过滤器)，但是profanity-check在发现大多数方面做得很好。

亵渎-检查

profanity-check是开源的，可以在 PyPI 上获得！简单地说，使用它

$ pip install profanity-check

怎样才能更好？如有任何想法或建议，请随时联系我们或发表评论！

[## vzhou 842/亵渎性检查

一个快速、健壮的 Python 库，用于检查字符串中的攻击性语言。-vzhou 842/亵渎-检查

github.com](https://github.com/vzhou842/profanity-check)

也贴在【victorzhou.com】上。

构建更好的查询引擎

原文：https://towardsdatascience.com/building-a-better-query-engine-ff52cb6364cd?source=collection_archive---------33-----------------------

TL；博士 这篇文章讲述了我们如何引入一个自由文本查询引擎来取代传统的基于过滤器的方法，使用命名实体识别和一些其他技巧来查询数据。

所有企业都在以巨大的速度生成数据。当数据量很大时，我们会希望查看我们可能感兴趣的数据子集(应用过滤器)。所以传统上这些过滤器转化为数据库查询。对 IBM 中所有概要文件的简单查询如下所示

SELECT * from profiles where company = " IBM "

当以有意义的方式向用户呈现数据时，Draup 面临着非常类似的挑战。它有一个庞大的配置文件生态系统，用户可以根据几个过滤器参数缩小范围。您可以根据公司、位置、技能、业务职能等选择个人资料。

这是基于过滤器的方法的样子。

Filter-Based Approach

当每个类别只有几个选项时，过滤很容易，但随着每个类别的选项增加，复杂性就会不成比例。

另一种查询方法

在 Draup，我们希望摒弃这种过滤搜索结果的方式，改善我们的用户体验。所以我们研究了另一种查询平台的方法。用户现在可以输入自由文本查询，告别所有由过滤器造成的混乱。这里有几个例子

- Show me data engineers skilled in python
- Someone who is located at san francisco with the qualification of a data scientist.
- Show me top executives in Amazon
- Adam from Microsoft, Redmond

所以第一个查询应该转换成下面的 SQL 查询。

从档案中选择 *，其中JOB _ TITLE = " data engineer "和 SKILL = "python"

我们从机器学习的角度来处理这个问题。这个问题在 ML 世界中被称为命名实体识别(NER)。

构建命名实体识别系统

命名实体识别是信息提取的一个子任务，旨在定位非结构化文本中的命名实体提及并将其分类为预定义的类别，例如个人和组织名称、位置、日期、等。

NER 有出色的开源模型 ( 1 、 2 、 3 、 4 )，但它们本质上非常普通。这些模型适用于一般的实体类型，如人名、位置、组织、日期等，但是在 Draup 中，我们关心的要多得多。我们还有其他几个实体，如技能、子垂直行业、业务职能、组织级别等，这些都是这些预训练模型无法涵盖的。所以我们得出结论，我们必须建立自己的 NER 系统。

构建数据集

这通常是任何机器学习(ML)过程中最关键的部分。ML 遵循一个简单的规则，“垃圾入，垃圾出”。这意味着一个 ML 模型的好坏取决于它所训练的数据。牢记这一点，我们努力产生尽可能多的例子。我们可以达到大约 200 个可能的查询。这是用于训练模型的相对较小的数据集。对用户查询模式的仔细研究给了我们关于如何通过数据扩充生成更多数据的想法。人们似乎并不关心自由文本查询中重要单词的大写。许多用户没有注意到使用正确的标点符号，但是仍然期望模型能够工作。这些见解有助于我们建立一个快速的数据增强管道，为我们创建更多的训练示例。所有这些努力总共产生了 1000 个培训示例。

建模技术的选择

构建 NER 系统有两大主题:

1. 传统算法如条件随机场 (CRF)
2. 基于深度学习的方法

如果你有一个大的数据集，基于深度学习的方法在文本数据领域非常有效。大约 1000 个例子还不够。最近，通用语言模型，如谷歌的伯特 T21 或 OpenAI 的 GPT-2 已经在较小的数据集上显示出有希望的结果。然而，这些模型体积庞大，我们觉得它们对我们的任务来说有点大材小用。与传统方法相比，深度学习的另一个重要缺点是很难解释和说明模型行为。

另一方面，条件随机场即使在数据有限的情况下也能很好地完成 NER 任务。

条件随机场模型

本节以一些直观的细节讨论了 CRF，但涉及一些数学问题。您可以选择跳过它。

当我们处理序列时，使用 条件随机场 模型。在我们的例子中，输入是一个单词序列，输出是一个实体标签序列。

Words and Tags sequence

让我们把单词序列叫做 x̄，把标签序列叫做 y̅.
同样，让我们定义所谓的特征函数:f(yᵢ₋₁、yᵢ、x̅，i)
这里，特征函数采用 4 个参数:-

1: i，当前索引在序列
2: x̄，整个输入序列
3: yᵢ₋₁，先前的输出标签索引在 i
4: yᵢ，当前输出标签索引在 I

为了让事情更清楚，让我们定义一个示例特征函数。

f(yᵢ₋₁、yᵢ、x̅、i) = { 1 如果 yᵢ₋₁和 yᵢ都是头衔并且现在的单词是‘工程师’,否则为 0}

正如您所看到的，这是一个非常具有描述性的特征函数，如果我们定义了很多这样的特征函数，我们就可以提取出很多关于文本数据的信息。这是另一个功能。

f(yᵢ₋₁、yᵢ、x̅、i) = { 1 如果 yᵢ₋₁是其他人，yᵢ是标题，当前单词是大写的，否则 0}

在收集了一系列特征函数之后，我们想要找到一个概率分布函数。这个函数应该告诉给定 x̅.，每个可能的 y̅的概率是多少下面的等式定义了这个概率。

Image Credit: Sameer Maskey slides

这里 exp 是指数函数。上述函数使用指数平滑地将概率分布在所有可能的标签序列上，并确保概率之和为 1。

如果你仔细观察，你会发现每个特征函数都被赋予了一个权重，这在直觉上是有意义的，因为不是所有的特征函数都具有同等的重要性。现在，给定数据，我们希望最大化我们的数据的条件似然并找到最佳的权重集。

Conditional Likelihood function

这里 L 是条件似然函数，k 迭代所有的训练例子。使用梯度下降，我们可以学习最适合我们数据集的参数(权重)。

嗯，这看起来需要做很多工作，但是我们使用了sklearn-CRF suite库，在大约 1000 个例子的数据集上训练 CRF 模型。

准确率、召回率和 F1 评分

下面用一个简单的例子来解释一下 精度和回忆一下 。假设我们建立了一个模型，可以预测/提取文本中提到的所有技能，我们的输入文本有 9 项技能。假设模型预测了 10 项技能，其中 6 项实际上是技能，另外 4 项不是技能。

A =相关记录数= 9
B =检索到的相关记录数= 6
C =检索到的记录数= 10
D =检索到的不相关记录数= 10–6 = 4

精度= B/C = 0.6
召回=B/A = 0.667

一个好的模型在精确度和召回率上都有很高的值。然而，有时用一个值来评估模型的好坏是有好处的。f1 分数由此而来。它将精确度和召回率和谐地结合在一起。

f1-score

所以在我们的例子中，f1 分数是 0.632

模型验证和改进

如果模型不能识别查询中的所有实体，这是可以接受的。但是如果模型错误地识别了实体，那么结果就会受到负面影响。例如，如果模型将一个人的名字识别为一家公司，那么很可能不会有搜索结果，甚至更糟的是，系统会产生错误的结果。因此，我们需要非常好的精确度和尽可能多的召回率。

Initial Model

我们最初的努力导致了以下结果。

精确度:0.790
召回率:0.635
F1-得分:0.702

这些结果是基于完全看不见的数据。

如果看召回，好像挺低的。这通常是 CRF 技术的一个问题。CRF 通常可以达到很好的精度，但是在召回率上有所欠缺。

为了解决低召回率的问题，我们引入了几个特征函数，它们使用我们的几个实体的管理列表。

f(yᵢ₋₁，yᵢ，x̅，我)=

假设我们的列表中有这样的技能:
('AutoCAD '，' python '，' java '，' MongoDB '，' nodejs '，……)

Value of skill lookup function for each index in the original sequence

在为其他一些实体定义了这样的特性之后，我们取得了巨大的进步。在引入这些特性后构建的模型给出了以下结果。

Improved Model

精确度:0.862
召回率:0.754
F1-得分:0.803

帮助我们的引擎在生产中表现良好的另一个技巧是使用 拼写纠正 。用户在向系统查询时似乎很匆忙。我们经常会遇到这样的查询:

向我展示amzon Java伦敦 的开发人员

拼写纠正过程帮助我们在很大程度上纠正这种情况，并使我们的系统更可用。

它看起来像什么

系统现在允许用户输入自由文本查询，然后提取实体并显示给用户，以及显示基于这些实体/过滤器的结果。

New Search Interface

上面的例子显示了微软中的查询“ Director”。系统正确地识别出实体董事和微软，并为您应用这些过滤器。

这只是自由文本查询引擎的开始。我们的系统将随着我们获得更多数据的训练而改进。

参考文献:-

• 条件随机场:用于分割和标记序列数据的概率模型
• Web 对数线性模型的统计 NLP，MEMM，条件随机字段:same er Maskey
• 自然语言工具包
• Spacy:工业级自然语言处理
• sk learn-CRF suite
• 最大似然估计

利用矩阵分解和 SV 分解构建图书推荐系统

原文：https://towardsdatascience.com/building-a-book-recommendation-system-using-matrix-factorization-and-sv-decomposition-d3541112d53e?source=collection_archive---------21-----------------------

每周一，我都会点击“发现周刊”的列表，看看 Spotify 提供了哪些个性化服务，特别是针对我前一周上传的音乐定制的服务。有时我会遇到一个隐藏的宝石(有一些音乐跳过)，有时我会完全失望。但事实是，我通常也有错，因为我根据情绪听完全不同的音乐风格，所以所发生的是推荐引擎没有区分情绪，我最终不得不做一些手动工作，以在给定的时间达到期望的精神状态。

然而，撇开情绪不谈(我强烈推荐 Spotify 团队考虑/测试的产品功能)，我一直想知道 Spotify 是如何找出这些标题的，即使在其系统中除了“另存为收藏夹”按钮之外没有评级，该按钮发送的是分类信号而不是数量信号……直到我最近意识到他们的推荐引擎使用了不同架构的组合:

1。基于记忆的协同过滤推荐器:，它关注用户和所讨论的项目之间的关系(当数据包含对所提供的各种项目的评级时是理想的)。矩阵分解在这里是一个强大的数学工具，用来发现用户和物品之间潜在的交互。比方说，A 和 B 听歌曲 X，B 经常听歌曲 Y，那么 A 也很可能听宋立科 Y。

2。基于内容的推荐:关注项目本身的特征。因此，不是分析用户/客户与项目的主动交互，而是主要在后者的水平上进行分析，因此检查和测量项目特征的相似性。为了保持在音乐环境中，让我们举例说，你经常听歌曲 X 和 Y，而这两首歌恰好来自一位意大利音乐家，他使用独特的钢琴曲调，并且恰好属于歌曲标签中指定的音乐流派和时代。
这种推荐方法将使用不同的机器学习技术(例如，自然语言处理、音频建模等。)来确定具有相似属性的歌曲 Z。

我想尝试一下第一种推荐方式，因为它似乎比第二种更简单。最重要的是，我想了解算法背后的数学原理，并提供简单的直觉，或许还想在转向更复杂的模型之前，为推荐系统在实践中的工作方式打下基础。

10k Books 数据集 在本教程中，我选择了在 Kaggle 上找到的 Goodbooks-10k 数据集作为开始。我一直担心读完一本精彩的书后会感到失望，所以我认为这将解决个人的矛盾，总的来说，这可能只是一件有趣的事情，因为朋友们会问我接下来该读什么。
zip 文件包含多个数据集(book_tags、books、ratings、tags)。我们将只使用包含与我们的分析相关的列的书籍和评级数据集。

首先，让我们导入必要的库。

import pandas as pd
import numpy as np
import sklearn
from sklearn.decomposition import TruncatedSVD
import warnings

让我们上传数据集。“图书”数据集包含 23 列。我们将分割数据并删除变量，只保留感兴趣的列。我们将保持评级数据集不变。
接下来，我们将合并“book_id”上的两个数据集。Book_id 比 original_title 更可靠，因为某些标题的格式可能会有一些变化。在继续创建矩阵之前，我们将删除 user_id 和 book_id 以及 user_id 和 original_title 的成对组合中的重复项。

books = pd.read_csv('books.csv', sep=',')
books = books.iloc[:, :16]
books = books.drop(columns=['title', 'best_book_id', 'work_id', 'books_count', 'isbn', 'isbn13', 'original_publication_year','language_code','work_ratings_count','work_text_reviews_count'])
books.head(5)
ratings = pd.read_csv('ratings.csv', sep=',')
ratings.head(5)df = pd.merge(ratings, books, on="book_id")
df.head(5)df1= df.drop_duplicates(['user_id','original_title'])
df1= df.drop_duplicates(['user_id','book_id'])
df1.head(10) #went down from 79701 to 79531 
df1.shape #(79531, 8)

矩阵分解法& SVD —直觉

我们现在将使用矩阵分解方法和单值分解模型(SVD)来创建一个矩阵模型。您可以在网上找到许多优秀的技术资源，以更深入的方式描述这些模型，但是我将在这里用简单的术语把它分解给你。

我们接下来要做的是调用 pivot 函数来创建一个数据透视表，用户在这个数据透视表中采用不同的行，预订不同的列，并在这个表中用一个形状(m*n)来表示各自的评分值。

######################################
####MATRIX FACTORIZATION
######################################books_matrix = df1.pivot_table(index = 'user_id', columns = 'original_title', values = 'rating').fillna(0)
books_matrix.shape #(28554, 794)
books_matrix.head()

如果你看看下面的图形表示，你就会知道幕后发生了什么。首先，我们创建了形状为(md)=(booksuser_id)的 A 矩阵和形状为(dn)=(ratingsuser_id)的 B 矩阵。

Matrix graphical representation by Albertauyeung

结果是两个矩阵之间的乘积(矩阵因式分解),其数学计算值如下:

我们需要创建一组训练数据——我们的训练数据基本上由更小的矩阵组成，这些矩阵是我们想要预测的评级因素。为此，我们将设置另一个矩阵 X，它是上面创建的结果矩阵(“books_matrix”)的转置，也称为可逆矩阵。

X = books_matrix.values.T
X.shape#Fitting the Model
SVD = TruncatedSVD(n_components=12, random_state=0)
matrix = SVD.fit_transform(X)
matrix.shape #(812, 12)

你会注意到我们新创建的矩阵非常稀疏。根据您指定的随机状态，列数是 5 位数，这意味着一个 5 位数的维度空间。这就是 SVD 方法介入的地方。

就像我们在其他数据集上使用 PCA/核 PCA 特征提取方法一样，SVD 是我们在推荐应用中应用于矩阵的另一种方法。奇异值分解可以将我们的维数压缩成更小的数来描述数据中的方差。这里发生的事情是，SVD 将寻找潜在的特征，并从数据中提取它们，从 10.000 个特征减少到只有 10 个，并且将为我们节省大量的计算能力，此外还可以避免数据过度拟合。在这个练习中，我将 SVD 的组件数量设置为 12。为了应用该模型，现在剩下的是拟合和转换训练数据 x。

注: 一般来说，在应用 SVD 后，一个常见的做法是引入一个正则化项(下面右边的项)，以避免对数据的过拟合:

左边的最小化术语是我们没有信息的评级误差的最小化(例如，未知的当前或未来评级)。我们可以在数学上用上述目标函数得出这些值，在实践中用随机梯度下降(SGD)等方法。
在本教程中，为了简单起见，我没有在实践中引入这两个术语，只是用空值(.菲尔娜(0))。

创建相关系数 接下来我们用 numpy 函数 np_corrcoef 为矩阵中的所有元素创建相关系数函数。我们称之为“corr”。
一旦我们将“corr”应用于我们非常喜欢的一本书，该函数将计算与其余书的所有相关系数，并将返回我们最有可能喜欢的所有书。

import warnings
warnings.filterwarnings("ignore",category =RuntimeWarning)#to avoid RuntimeWarning #Base class for warnings about dubious runtime behavior.corr = np.corrcoef(matrix)
corr.shape

相关系数的范围从 0 到 1，0 表示两个项目之间不存在相关性，1 表示相反。在我们的例子中，我们越接近 1，其他推荐的书籍就越有可能具有与您输入的书籍高度相关的特征，因此您更有可能喜欢这些书籍。

检查结果 现在我们来检查结果。我将创建一个名为“titles”的向量并列出条目。我会挑一本我喜欢的书作为索引。《艺妓回忆录》是我最喜欢的小说之一，所以我们就看这本吧。

title = books_matrix.columns
title_list = list(title)
samia = title_list.index('Memoirs of a Geisha')
corr_samia  = corr[samia]
list(title[(corr_samia >= 0.9)])

在我运行完全部代码后，这里是算法推荐的书籍列表:

Suggested Book list for Samia

这个看起来不错！我已经读了很多以上的书，可以证明他们中的一些曾经在我的清单上(例如《波斯波利斯》、《荒野》、《了不起的盖茨比》、《百年孤独》、《问题的核心》等)。).我仍然很好奇这个算法在这里使用了哪些潜在的特征来选择“思考和致富”，因为我会把它归类到另一个类别中(非小说+其他考虑)，但这再次揭示了这个算法的一个限制，这可能与我们提供给它的独立变量的权重有关。

评估结果 我评估了这个模型，只是看了一下算法给出的书单，因为我已经阅读了(并且非常喜欢)一些推荐的书名，并且为了好玩，和其他人一起运行这个模型，看看他们是否会同意大部分内容——我想我今天就到此为止了。当然，如果您必须提供清晰的性能指标，这不是正确的方法。

为了更加准确，有许多方法来评估推荐系统，并且该方法将根据推荐器的类型而不同(例如，基于内容的与协同过滤的)。一种方法是应用交叉验证模型——将您的用户分成 k 个折叠组并循环进行:将(k-1)个折叠作为训练集，并对剩余的折叠进行测试，对所有结果进行平均。也许这将是后续文章的主题:)

免责声明&离开的想法:) 最后，这是我的第一个数据科学/机器学习实践帖子，所以我希望这是一个有用的教程，直观地解释了模型背后的数学原理。
祝您构建自己的推荐引擎愉快，不要忘记订阅我的频道或在下面提问以获得澄清！😃

关注我在 Linkedin
连接在 Twitter

为 Slack 构建一个王座聊天机器人游戏:第 1 部分理解语言

原文：https://towardsdatascience.com/building-a-chatbot-for-slack-from-scratch-part-1-understanding-language-1f085b2eda6c?source=collection_archive---------30-----------------------

经验教训将深度学习应用于自然语言理解并结合问答

去年夏天，我决定测试一下我的 NLP 技能，着手开发一个聊天机器人。作为《权力的游戏》的忠实粉丝，我决定为《权力的游戏》开发一个聊天机器人。最初，我的目标只是提供一种从 Reddit、Watchers on the Wall、Los Siete Reinos 和 Twitter 等网站轻松获取各种新闻的方式。然而，我很快决定扩展到其他任务，我对如何整合现代 NLP 方法来丰富我的聊天机器人特别感兴趣。这第一篇文章将涵盖自然语言理解和问答组件；第二篇文章将更多地讨论平台和架构。

如果你想使用聊天机器人，那么你可以加入 Slack 上的 Citadel 社区(虽然，正如我将要描述的，我还没有将所有描述的功能添加到实际的产品版本中)。在未来，我计划增加支持，将它安装在您的工作区。还要注意的是，本文中的一些例子和机器人本身的内容包含了第七季的信息。

自然语言理解(NLU)

NLU 深度学习简介

在哪里以及如何将深度学习集成到聊天机器人中，实际上是一个有点棘手的问题。在聊天机器人的基础上，你可以使用基于规则的方法，机器学习，或者两者的结合。使用基于规则的方法，你通常可以保证只要用户以公式化和受限的方式书写，聊天机器人就会正确地响应用户的查询。通过机器学习(甚至是统计 NLP 方法)，你可以打破刻板的公式，让用户更自然地打字。然而，这样做也引入了不确定性(即使是最好的模型)。此外，即使是 SOTA 模型通常也只适用于有限类型的对话。例如，如果用户开始参与聊天，为面向目标的对话训练的模型通常会崩溃。深度学习当然也需要数据，在这种情况下，我们经常会遇到冷启动问题。因此，你经常需要写你认为用户会问的样本数据。这个过程既费时又不准确。

形式化的方式

在看为什么我们可能需要基于机器学习的模型之前，让我们看看使用基于规则的方法的一些限制。使用聊天机器人的公式化方式，我们可以编写类似这样的代码:

Note this is purposefully simplfied. In my actual bot for my rule based methods I usually use a dict to map words to actions to avoid long if statement like these. Also you would obviously have to handle the DB operations etc

Example users requests and responses using the formulaic approach

现在，用户必须用非常公式化的方式来使用聊天机器人。他们必须准确地写出Quote Jon Snow或News Reddit如果你只想包含简单的查询，这没问题。但是如果想要支持像Quote about Jon Snow甚至Quote from Jon Snow when he is talking about Stannis?这样的短语的功能，我们可以强迫用户以一种公式化的方式做事情，但是这对用户来说很快就变得复杂和累赘。对于新闻来说也是如此，支持像Get news from the past 24 Hours on Reddit甚至News about Jon Snow in Season 8这样的复杂查询在最好的情况下会变得很困难，在最坏的情况下也是不可能的。

槽填充和意图检测

这就把我们带到了机器学习的缝隙填充和意图检测。在聊天机器人中使用深度学习的一个关键领域是自动获取用户输入的字符串，并将相关的令牌映射到 API 的插槽(这被称为插槽填充或 SLU)。一个相关的领域是意图检测，其集中于将话语映射到意图。这是一个 SLU 注释的例子

Quote about Jon                 Snow
0       0   B-focus-character   I-focus-character
Intent: Quote 0 Quote from   Jon       Snow      when he is talking about Stannis
0       0   B-speaker  I-speaker  0   0   0   0       0   I-focus
Intent: Quote 0

在某种意义上，槽填充是命名实体识别(NER)的更细粒度版本。例如，在纯 NER 设置中Jon Snow可能总是有标签character，而对于槽填充，标签将基于他应该占据的槽而改变。注释的格式称为 IOB ，代表内-外开始。这意味着一起显示令牌的“块”。

由于机器人的响应将取决于插槽和用户的目标，许多论文集中在联合插槽填充和意图检测。此外，许多 NLU 库如 Rasa-NLU 框架提供了联合 SLU 意图检测。

一旦填充了插槽，我们仍然需要构建实际的查询。查询构造将取决于数据库的设置方式。因此，在大多数情况下，这些代码是您自己手工编写的。然而，有一些模型学习话语到 SQL 查询的直接映射。但是大多数时候，您会有一个现有的 API 或者想要构建一个。因此，让我们看看如何将它变成一个简单的 API 请求:

def process_user_text(user_text, model):
    # Let's assume model.predict() returns 
    # intent:str ents:dict (e.g. {"focus_character":"Jon Snow"})
    intent, ents = model.predict(user_text)
    # Assume this function combines multi-token ents an
    # normalizes them to how they appear in the database
    ents = combine_normalize_ents(ents) 
    url = "https://random_site.com/" + intent
    requests.post(url, data=ents)

Note although this code resembles the code in the GOT-Bot APIs I have not personally tested this code. I plan on doing so in the next few days. But if you run into errors in the interim let me know.

现在我们可以使用这个简单的 Flask API 来处理这些请求。

回到我们之前的新闻示例，我们将使用以下格式标记数据，以便与 API 一起工作:

News about Jon          Snow          in    Season       8
0     0    B-character  I-character    0    B-season  I-season
Intent: News 1

正如您所看到的，这种格式允许我们更容易地构造 API 调用和 SQL 查询。现在我们可以定义一个函数(假设我们已经运行了一个 NER 并标记了新闻故事)。

有限数据场景

这种方法的问题，当然还有一般深度学习的问题，是需要大量带标签的训练数据。我目前正在研究的一种方法是在许多带注释的对话数据集上使用元学习，以便使模型能够快速适应少数几个例子。

插槽对齐是另一种有趣的(尽管有些局限)方法。面向域缩放的零镜头帧语义解析，谷歌研究人员 2017 年的一篇文章描述了在 API 中使用槽的名称和/或槽的文档来有效地执行零镜头填充。其想法是，如果模型已经接受了预订航空公司的培训，那么它也应该能够预订公共汽车，因为插槽通常应该重叠(即，两者都有一个start_city、destination_city)。更进一步，基于餐馆的对话系统可能具有restaurant_city (即，在芝加哥为我预订一家餐馆)，而酒店可能具有hotel_city。通过利用短语之间的相似语义，一个模型可以学习有效地填充restaurant_city，即使它只在机票预订数据上受过训练。当然，这种方法也有局限性:(1)它不能在几乎没有重叠的完全不同的领域上工作；(2)在某些情况下，实际上可能存在负迁移(例如，在出租车预订上表现更差；它混淆了drop_off 和pickup_spot，因为它们是依赖于上下文的；即使这些可以与start_city和destination_city对齐，它们的表示也不相似)。对于我的用例，这种方法可能不会工作，因为在大型公共槽填充数据集和我的聊天机器人之间很少有重叠的语义槽。

超越关节槽填充和意图检测模型

但是，即使是联合 NLU 模型也有其局限性，因为它们不使用上下文。例如，假设用户说Quote from Robert Baratheon，然后说Get me another quote from him.，在这种情况下，之前描述的 NLU 模型之一不知道该做什么，因为它不使用对话历史。类似地，用户可能会问这个问题Who is Jon Snow's mother?，机器人将(希望)返回Lyanna Stark，那么如果用户问When did she run off with Rhaegar?，它甚至可能不会将her投给一个槽。有时，我们可能需要更新或请求关于某些插槽的附加信息。例如，如果用户要求News from the past 24 hours about Season 8?，但 API 要求指定新闻来源，机器人可能会回复From what source?，或者如果用户声明Get the scene from episode 2?,，机器人可能会回复from what season?

端到端对话模型应该能够处理这些任务。为测量该任务的进度而创建的一个挑战是对话状态跟踪。特别是挑战的第二个版本 DSTC2 ，测量了模型在需要时发布和更新 API 调用以及向用户请求额外信息的能力。在这个挑战中做得很好的第一个模型是用于目标导向对话的记忆网络。这是由脸书的研究人员在论文《学习端到端的面向目标的对话》中完成的。他们表明，记忆网络远远胜过其他机器学习方法。

最近出现了像 Mem2Seq 这样的论文，它们积极地将对话历史与知识库结合起来，并在响应生成中使用它们。具体来说，Mem2Seq 有两个部分，一个是对对话历史进行编码的内存编码器，另一个是使用编码的 dialogue/KB 生成用户响应的解码器。Mem2Seq 在 DSTC2 challenge、BABI 和车载 stanford 数据集上获得了 SOTA 结果。

The architecture of Mem2Seq notice how both dialog history and the knowledge base are encoded that is utilized at each turn.

为 GOT-Bot 训练 Mem2Seq 需要三样东西:知识库、带注释的意图和带注释的对话历史。这使得更难适应 GOT-Bot，因为知识库需要转换成三元组，如(person，person2，relation)。

问题解答

从回答问题开始到填充位置结束之间的界限通常很模糊。在研究术语中，我们通常将 QA 视为基于非结构化文本数据的问题回答。(它也可以基于一个结构化的知识库，但是在这种情况下，填隙结束和 QA 开始的确切位置特别混乱)。在前一种情况下，这通常意味着从文本数据中搜索和提取答案，而不是计算查询数据库时要填充哪些槽。在《权力的游戏》机器人的上下文中，这意味着接受一个用户问题，在 ElasticSearch 上搜索适当的索引，然后从返回的结果中提取正确的答案。在讨论具体如何之前，我们先来看看用户可能会问的不同类型的问题:

基本上有三类问题:

(1)通过查询知识图可以回答的问题。

Who has the Hound killed?

Who is Jon Snow's father?

What is the motto of house Glover?

Who was Margeary married to?

What region is Harrenhall in?

这些问题都有已知的答案，可以在结构化知识图中找到。问题是我们需要将用户查询转换成 SQL 或 API 请求。这类似于我们需要做的槽填充。在许多情况下，我们实际上可以通过将问题作为另一个意图来表达，从而将这个问题作为一个填充问题。举个例子，

Who has the Hound               killed 
0   0    0  I-focus_character   I-attribute 
Intent kb_question`

或者在以下问题的情况下:

What region             is   Harrenhall       in?
0    I-location-region   0  I-focus_castle     0 
Intent 

然后，我们可以用类似的方式构造一个 API 请求。然而，有大量的数据集对 SQL 有疑问，所以在这种情况下，使用其中一个数据集可能是有意义的。

(2)不在知识图中但是仍然有已知答案并且可以从 MediaWiki 页面或其他 GOT 站点提取的问题。

How did the war of the five king's start?

What happened during Harrenhal tourney?

What was the war of the five kings?

How did Robert's rebellion end?

Who got the Tyrell's to support the Lannisters?

与此任务最相关的数据集/模型是像 MARCO 女士和 TriviaQA 这样的数据集。尽管许多研究人员对 SQUAD 进行评估，但在现实中，你几乎永远不会得到给你的准确的上下文段落。这使得在 MARCO 女士身上表现良好的模型非常理想，因为它们被给予一个完整的排名结果列表，并且必须从中提取正确的答案。

QuAC 数据集或上下文中的问答类似于前面提到的问答的“端到端”对话模型。它包含涉及多次对话的问题和跟进问题。像 FlowQA 这样的模型可以很好地完成对话式 QA 任务，因为它们将对话历史添加到基础模型中。

(3)问题，其中答案是主观的或推测性的，并且需要找到相似的问题或可替换地执行多跳推理。

Why did Sansa trust Joffery?

Who will survive season 8 and why?

If Robb Stark hadn't broken his marriage pack would've the Freys betrayed him?

Who will kill Cersei?

Is Jon the prince that was promised?

这些问题没有明确的答案，需要分析或推测。因此，最好的解决方案是找到已经回答过的类似问题。这可以通过刮掉的 Quora 索引来实现。但是，这里我们不会使用 QA 模型，而是使用问题相似度模型。可以使用多种方法来完成问题相似性。我目前生产的模型使用一个基本的弹性搜索，然后使用通用句子编码器 +余弦相似度对结果进行重新排序。为了收集更多的数据来提高排名，机器人目前向用户显示所有前十名的结果。然后，我们可以根据用户的选择重新训练模型。然而，这种方法有几个问题。首先，在许多情况下，最初的弹性搜索通常不会返回好的问题。第二，用户可能会返回另一个有趣的答案，而不是直接回答他们的问题。然而，这种“弱监督”意味着人们可以在以后更快地手工注释例子。

Example questions and bot returned answers. In the first panel (from the left) the correct answered is returned as (1) when it should be returned as 0 (it is likely some type of bug as that question seems very out of place). In 2/3 the correct answers are not even found by ElasticSearch but the related results

创建良好的入职流程

创建良好的入职流程对于获得用户也至关重要。你的机器人需要立即给人留下积极的印象，否则人们会离开。出于这个原因，为了建立一个良好的入职流程，我决定编写一个基于规则的对话。机器人首先用欢迎他们来到城堡的直接信息来介绍自己。在整个入职过程中，Redis 会跟踪用户的状态。在每个响应的结尾，用户的状态在 Redis 中被更新。这里我决定使用简单的字典将用户的状态映射到动作，以避免冗长的 if 语句。

入门过程旨在以有趣和友好的方式让用户熟悉机器人的基本功能。

Maester bot message to new users

手动定义规则的一个问题是，如果用户说了一些意想不到的话，甚至与您硬编码的略有不同，机器人就会失败。当我不小心让一个 bug 从我的单元测试和手动测试中溜走时，我发现了这一点。我期望用户对问题Would you like me to show you around the Citadel做出yes的回应，但是用户经常用yes thanks或yes please 这样的话来回应，这是一个我没有发现的非常简单的错误。这就是为什么我建议让不同的人测试你的聊天机器人，因为你可能会不可避免地错过一些东西。

响应生成

在本文中，我没有过多讨论实际的响应生成。在很大程度上，这是通过用基本短语重新组合先前描述的元素的响应来完成的。当然，还有许多更复杂的方法来生成独特的、随时间变化的响应。然而，现在我仍然使用简单的短语来组合 API 中 NLU 调用的结果。

闲聊和无目标的互动呢？

这是一个我没有研究太多的领域，但我希望能够深入到后续的补充。本质上，这是当用户不想完成一个特定的任务，而只是想从总体上谈论《权力的游戏》的元素，并听到机器人机智/有趣的回应。

机器人的当前状态和未来改进

目前，聊天机器人仍处于公式化状态。我还没有能够对足够的训练数据进行注释，或者有效地结合元/无监督学习，以使槽填充始终如一地执行。然而，我训练的模型正在变得更好，我希望很快推出一个包含它们的更新。我也在考虑通过元学习训练 Mem2Seq 来处理整个对话过程，不过这是在更遥远的将来。

在问答方面，Quora 索引的搜索仍然很差，并且不支持查询知识库。我希望通过使用在 MARCO 女士身上预先训练的 BERT Reranker 来提高 Quora 索引的问答问题排名。我希望重写新闻系统，这样你就可以询问“关于第八季的最新消息”或“来自 Reddit 的新琼恩·雪诺迷因”最后，我添加了一些基于规则的对话流，用于更真实的聊天序列。在本系列的第二部分中，我将深入到聊天机器人更实际的方面，比如使用的平台和工具。

利用点击流数据构建协同过滤推荐系统

原文：https://towardsdatascience.com/building-a-collaborative-filtering-recommender-system-with-clickstream-data-dffc86c8c65?source=collection_archive---------3-----------------------

Photo credit: Paxabay

如何实现一个基于先验隐式反馈的推荐算法？

推荐系统无处不在，帮助你找到一切，从书籍到浪漫约会，从酒店到餐馆。

针对各种情况有各种推荐系统，这取决于你的需求和可用的数据。

显性 vs 隐性

让我们面对现实吧，明确的反馈很难收集，因为它们需要用户的额外输入。只有当用户选择这样做时，他们才会给出明确的反馈。结果，大多数时候，人们根本不提供评分(我自己在亚马逊上对此完全有罪！).因此，收集到的显性数据量极其稀少。

另一方面，隐式数据易于大量收集，无需用户付出任何努力。目标是通过观察用户行为，将用户行为转化为间接反映意见的用户偏好。例如，一个为同一作者的许多文章添加书签的用户可能喜欢那个作者。

数据

我们今天的目标是开发一个具有隐式数据收集的推荐系统，在我们的例子中，隐式数据收集是点击流数据。

很难找到这个项目的公开可用数据。我使用的数据来自文章分享和 CI & T DeskDrop 阅读。 Deskdrop 是一个内部交流平台，允许公司员工与同事分享相关文章，并围绕他们进行协作。

该数据包含了约 73k 个用户在平台上分享的超过 3k 篇公共文章上的互动，更重要的是，它包含了丰富的隐性反馈，记录了不同的互动类型，使得推断用户对文章的兴趣程度成为可能。

我们将使用隐式库，一个隐式数据集的快速 Python 协作过滤，用于我们的矩阵分解。

数据预处理

• 删除我们不需要的列。
• 从articles_df上移除eventType == 'CONTENT REMOVED'。
• 将interactions_df与articles_df合并。

implicit_rec_preprocess.py

这是让我们开始的数据集:

Table 1

这告诉我们每个人对每个内容有什么事件类型。有许多重复的记录，我们将很快删除它们。

df['eventType'].value_counts()

Figure 1

eventType 值为:

• 查看:用户已经打开文章。内容站点中的页面视图可能意味着许多事情。这可能意味着用户感兴趣，或者用户只是迷路或随机点击。
• 喜欢:用户喜欢这篇文章。
• 书签:用户已经将文章做了书签，方便日后归还。这强烈表明用户找到了感兴趣的东西。
• 评论已创建:用户对文章发表了评论。
• 跟在后面:用户选择在关于文章的任何新评论上得到通知。

我们将把每个事件类型与权重或强度相关联。合理的假设是，例如，文章上的书签指示用户对该文章的兴趣比类似的更高。

event_type_strength = {
   'VIEW': 1.0,
   'LIKE': 2.0, 
   'BOOKMARK': 3.0, 
   'FOLLOW': 4.0,
   'COMMENT CREATED': 5.0,  
}df['eventStrength'] = df['eventType'].apply(lambda x: event_type_strength[x])

Table 2

• 删除重复的记录。
• 将 eventStrength 与人员和内容组合在一起。

df = df.drop_duplicates()
grouped_df = df.groupby(['personId', 'contentId', 'title']).sum().reset_index()
grouped_df.sample(10)

• 我们得到分组事件强度的最终结果。

Table 3

交替最小二乘推荐模型拟合

eventStrength 可以代表交互有多强的“置信度”,而不是表示明确的评级。一个人的事件强度越大，文章在我们的事件强度评级矩阵中的权重就越大。

• 为了避开“负整数”警告，我必须创建数字列person_id和content_id。
• 创建两个矩阵，一个用于拟合模型(内容-人)，另一个用于推荐(人-内容)。
• 初始化交替最小二乘(ALS)推荐模型。
• 使用稀疏内容-人矩阵来拟合模型。
• 我们将矩阵的类型设置为 double，以便 ALS 函数正常运行。

implicit_als_model.py

寻找相似的文章

我们要为 content_id = 450 找出前 10 篇最相似的文章，标题为“ Google 的合理使用胜利对开源有好处 ”，这篇文章似乎在谈论 Google 和开源。

• 从我们训练好的模型中获取人物和内容向量。
• 计算向量范数。
• 计算相似性得分。
• 获取前 10 个内容。
• 创建与本文最相似的文章的内容分数元组列表。

similar_content.py

Figure 2

第一条就是它自己。另外 9 篇文章是关于谷歌、开源软件、云、人工智能或其他科技公司的。我相信你会同意我的看法，它们都与第一部有些相似之处！

向人们推荐文章

下面的函数将返回根据人/内容向量选择的前 10 个推荐，这些内容是从未与任何给定的人交互的内容。

• 从稀疏人员内容矩阵中获取互动得分。
• 每样东西都加 1，这样没有交互作用的文章就等于 1。
• 让文章已经互动为零。
• 得到人物向量和所有内容向量的点积。
• 在 0 和 1 之间调整这个推荐向量。
• 已经互动的内容的推荐乘以零。
• 按照最佳推荐的顺序对内容的索引进行排序。
• 开始空列表来存储标题和分数。
• 将标题和分数添加到列表中。
• 获取经过培训的人员和内容向量。我们将它们转换成 csr 矩阵。
• 为 id 为 50 的人员创建推荐。

implicit_rec_als_id_50.py

Figure 3

这里我们有 person_id = 50 的前 10 个建议。它们有意义吗？让我们看看此人互动过的前 10 篇文章。

grouped_df.loc[grouped_df['person_id'] == 50].sort_values(by=['eventStrength'], ascending=False)[['title', 'person_id', 'eventStrength']].head(10)

Table 4

显然，此人对 Drupal 等开源 CMS 上的文章感兴趣，她也阅读软件开发和业务相关的文章，即“Google”、“Slack”或“Johnson Johnson”。

我们向她推荐的文章包括 Drupal for digital experience、信息技术与人类、软件开发以及关于 Google 的商业文章。

相当令人印象深刻！让我们再试一次。

我们向 person_id = 1 推荐了以下文章:

person_id = 1recommendations = recommend(person_id, sparse_person_content, person_vecs, content_vecs)print(recommendations)

Figure 4

以下是 person_id = 1 互动过的文章:

grouped_df.loc[grouped_df['person_id'] == 1].sort_values(by=['eventStrength'], ascending=False)[['title', 'eventStrength', 'person_id']]

Table 5

显然，这个人只和 5 篇文章有过互动，她似乎对此兴趣不大。她互动的文章是关于学习日语和/或 android 开发的。

我们向她推荐的文章包括学习日语、android 开发和用户界面设计。酷！

评估推荐系统

以上抽查看起来都不错。但是对推荐系统最好的评价标准是该系统给最终用户和/或企业增加了多少价值，该系统是否增加了页面浏览量、点赞数、书签数、关注数和评论数。我们希望进行一些在线 A/B 测试来评估这些指标。

然而，在我们将推荐系统推向在线之前，还有其他一些单独评估推荐系统性能的通用指标。通过遵循这个教程，我们能够计算出我们的训练集中至少有一篇文章被屏蔽的每个人的 AUC 。和 AUC 最受欢迎的文章，供人们比较。

Jupyter 笔记本可以在 Github 上找到。复活节快乐！

参考资料:

[## alternatinglestsquares-隐式 0.3.8 文档

基于论文“隐式反馈的协同过滤”中描述的算法的推荐模型…

implicit.readthedocs.io](https://implicit.readthedocs.io/en/latest/als.html) [## ALS 隐式协同过滤

继续我的二进制数据协同过滤示例中的协同过滤主题，我将…

medium.com](https://medium.com/radon-dev/als-implicit-collaborative-filtering-5ed653ba39fe) [## Python 101 中的推荐系统

使用文章中的数据共享和从 CI&T 桌面阅读 Drop

www.kaggle.com](https://www.kaggle.com/gspmoreira/recommender-systems-in-python-101)

用 TensorFlow 构建协同过滤推荐系统

原文：https://towardsdatascience.com/building-a-collaborative-filtering-recommender-system-with-tensorflow-82e63d27b420?source=collection_archive---------2-----------------------

Source: Pixabay

推荐是建立在其他用户的现有评级基础上的，这些用户与我们想要推荐的用户具有相似的评级。矩阵分解

协同过滤是一种被推荐系统广泛使用的技术，当你有足够大的用户项目数据时。它会根据相似用户的内容偏好进行推荐。

因此，协同过滤不是处理冷启动问题的合适模型，在这种情况下，协同过滤不能对尚未收集到足够信息的用户或项目做出任何推断。

但是一旦你有了相对大的用户-项目交互数据，那么协同过滤就是最广泛使用的推荐方法。我们将学习如何使用 TensorFlow 构建一个协同过滤推荐系统。

数据

我们再次使用预订交叉数据集，可以在这里找到。数据预处理步骤执行以下操作:

• 合并用户、评级和图书数据。
• 移除未使用的列。
• 过滤至少有 25 个评分的书籍。
• 过滤至少给出 20 个评级的用户。记住，协同过滤算法通常需要用户的积极参与。

recSys_preprocessing.py

因此，我们的最终数据集包含 5，850 本书的 3，192 个用户。并且每个用户给出了至少 20 个评级，每本书获得了至少 25 个评级。如果你没有图形处理器，这将是一个很好的大小。

协同过滤方法专注于寻找对同一本书给出相似评价的用户，从而在用户之间建立一个链接，向他们推荐被正面评价的书籍。这样，我们寻找的是用户之间的关联，而不是书籍之间的关联。因此，协同过滤仅依靠观察到的用户行为来做出推荐，不需要简档数据或内容数据。

我们的技术将基于以下观察:

• 以类似方式对书籍进行评级的用户共享一个或多个隐藏的偏好。
• 具有共享偏好的用户可能会以相同的方式对相同的书籍进行评级。

张量流中的过程

首先，我们将标准化评级功能。

scaler = MinMaxScaler()
combined['Book-Rating'] = combined['Book-Rating'].values.astype(float)
rating_scaled = pd.DataFrame(scaler.fit_transform(combined['Book-Rating'].values.reshape(-1,1)))
combined['Book-Rating'] = rating_scaled

然后，构建具有三个特征的用户、预订矩阵:

combined = combined.drop_duplicates(['User-ID', 'Book-Title'])
user_book_matrix = combined.pivot(index='User-ID', columns='Book-Title', values='Book-Rating')
user_book_matrix.fillna(0, inplace=True)users = user_book_matrix.index.tolist()
books = user_book_matrix.columns.tolist()user_book_matrix = user_book_matrix.as_matrix()

tf.placeholder仅在 v1 中可用，所以我必须这样做:

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

在下面的代码脚本中

• 我们设置了一些网络参数，比如每个隐层的维数。
• 我们将初始化 TensorFlow 占位符。
• 权重和偏差是随机初始化的。
• 以下代码摘自《Python 机器学习烹饪书——第二版》

placeholder.py

现在，我们可以建立编码器和解码器模型。

encoder_decoder.py

现在，我们构建模型和预测

encoder_op = encoder(X)
decoder_op = decoder(encoder_op)y_pred = decoder_opy_true = X

在下面的代码中，我们定义损失函数和优化器，最小化平方误差，并定义评估指标。

loss = tf.losses.mean_squared_error(y_true, y_pred)
optimizer = tf.train.RMSPropOptimizer(0.03).minimize(loss)
eval_x = tf.placeholder(tf.int32, )
eval_y = tf.placeholder(tf.int32, )
pre, pre_op = tf.metrics.precision(labels=eval_x, predictions=eval_y)

因为 TensorFlow 使用计算图形进行运算，所以占位符和变量必须在拥有值之前进行初始化。因此，在下面的代码中，我们初始化变量，然后创建一个空数据框来存储结果表，这将是对每个用户的前 10 项建议。

init = tf.global_variables_initializer()
local_init = tf.local_variables_initializer()
pred_data = pd.DataFrame()

我们终于可以开始训练我们的模型了。

• 我们把训练数据分成几批，然后把它们输入网络。
• 我们用用户评级的向量来训练我们的模型，每个向量代表一个用户，每个列代表一本书，条目是用户给书的评级。
• 经过几次尝试，我发现批量大小为 35 的 100 个时期的训练模型将消耗足够的内存。这意味着整个训练集将馈给我们的神经网络 100 次，每次使用 35 个用户。
• 最后，我们必须确保删除训练集中的用户评级。也就是说，我们不能向一个用户推荐他(或她)已经评价过的书籍。

recSys_train.py

最后，让我们看看我们的模型是如何工作的。我随机选择了一个用户，看看我们应该向他(或她)推荐什么书。

top_ten_ranked.loc[top_ten_ranked['User-ID'] == 278582]

Table 2

以上是该用户的前 10 个结果，按标准化预测评分排序。

我们来看看他(或她)评价过哪些书，按评价排序。

book_rating.loc[book_rating['User-ID'] == 278582].sort_values(by=['Book-Rating'], ascending=False)

Table 2

这位用户喜欢的书籍类型有:历史推理小说、惊悚悬疑小说、科幻小说、奇幻小说等。

这个用户的前 10 个结果是:谋杀幻想小说，神秘惊悚小说等等。

结果并不令人失望。

Jupyter 笔记本可以在 Github 上找到。星期五快乐！

参考资料:

Python 机器学习烹饪书—第二版

https://cloud . Google . com/solutions/machine-learning/recommendation-system-tensor flow-overview

为数据科学文章构建基于内容的推荐器

原文：https://towardsdatascience.com/building-a-content-based-recommender-for-data-science-articles-728e5ec7d63d?source=collection_archive---------15-----------------------

一步一步的教程

介绍

博客在数据科学社区中很流行，这已经不是什么秘密了。通过这种方式，这个领域反映了它在开源运动中的根源。在找到一个问题的创新解决方案后，似乎没有什么比写关于它的文章更让数据科学家喜欢的了。数据科学社区内的博客是一个双赢的局面，作者从曝光中受益，读者从获得的知识中受益。

在本教程中，我将使用主题建模来描述与数据科学相关的媒体文章的内容，然后使用主题模型输出来构建一个基于内容的推荐器。作为我的语料库，我将使用 Kaggle 数据集 Medium Articles(带内容)，它包含大约 70，000 篇中型文章，这些文章被标记为数据科学、机器学习、AI 或人工智能。这是一个很好的数据集，因为除了文章的全文之外，它还包含了大量的信息:点击次数、作者、url 等。该数据集包含最近在 2018 年 10 月发布的文章。这意味着我们的推荐者不会推荐最近的帖子，但这没关系。

加载数据

首先，让我们导入我们的库，将数据集加载到 pandas 数据框中，然后查看前几行。

import numpy as np
import pandas as pd
import re
import stringfrom sklearn.decomposition import NMF
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVDimport gensim
from gensim.parsing.preprocessing import STOPWORDS
from gensim import corpora, models
from gensim.utils import simple_preprocessfrom nltk.stem.porter import PorterStemmermedium = pd.read_csv(‘Medium_AggregatedData.csv’)
medium.head()

看起来未经处理的数据集包含大量冗余信息。事实上，分配给一篇文章的每个标签都有一行，所以每篇文章最多有 5 行。让我们通过压缩标记信息然后消除重复行来解决这个问题。为了进一步减少我们数据集的大小，并确保我们产生高质量的推荐，让我们也删除不是用英语写的文章和少于 25 次鼓掌的文章。最后，我们将删除所有不会继续使用的列。

# Filter articles
medium = medium[medium['language'] == 'en']
medium = medium[medium['totalClapCount'] >= 25]def findTags(title):
    '''
    Function extracts tags for an input title
    '''
    rows = medium[medium['title'] == title]
    tags = list(rows['tag_name'].values)
    return tags# Get all the titles
titles = medium['title'].unique()tag_dict = {'title': [], 'tags': []} # Dictionary to store tagsfor title in titles:
    tag_dict['title'].append(title)
    tag_dict['tags'].append(findTags(title))tag_df = pd.DataFrame(tag_dict)  # Dictionary to data frame# Now that tag data is extracted the duplicate rows can be dropped
medium = medium.drop_duplicates(subset = 'title', keep = 'first')def addTags(title):
    '''
    Adds tags back into medium data frame as a list
    '''
    try:
        tags = list(tag_df[tag_df['title'] == title]['tags'])[0]
    except:
        # If there's an error assume no tags
        tags = np.NaN
    return tags# Apply addTags
medium['allTags'] = medium['title'].apply(addTags)# Keep only the columns we're interested in for this project
keep_cols = ['title', 'url', 'allTags', 'readingTime',
             'author', 'text']
medium = medium[keep_cols]# Drop row with null title
null_title = medium[medium['title'].isna()].index
medium.drop(index = null_title, inplace = True)medium.reset_index(drop = True, inplace = True)print(medium.shape)
medium.head()

太好了！数据集现在已经缩减到只有 24，576 行，标记信息保留在“allTags”列中。这将更容易向前推进。

文本清理

现在让我们把注意力转移到预处理文章文本，为主题建模做准备。首先，我们将删除链接、非字母数字字符和标点符号。我们还会将所有字符转换成小写字母。

def clean_text(text):
    '''
    Eliminates links, non alphanumerics, and punctuation.
    Returns lower case text.
    '''

    # Remove links
    text = re.sub('(?:(?:https?|ftp):\/\/)?[\w/\-?=%.]+
                  \.[\w/\-?=%.]+','', text)
    # Remove non-alphanumerics
    text = re.sub('\w*\d\w*', ' ', text)
    # Remove punctuation and lowercase
    text = re.sub('[%s]' % re.escape(string.punctuation),
                  ' ', text.lower())
    # Remove newline characters
    text = text.replace('\n', ' ')

    return textmedium['text'] = medium['text'].apply(clean_text)

预处理管道中的下一步是消除停用词，这些词非常常见并且没有信息。对于许多 NLP 任务来说，这些单词是混淆我们试图寻找的任何信号的噪音。标准英语停用词的几个例子是“the”、“is”和“you”。此外，考虑特定领域的停用词通常也很重要。对于这个项目，我们将从 Gensim 的预定义停用词集开始，然后添加数据科学专用停用词和一些由我们的预处理步骤生成的词片段。

stop_list = STOPWORDS.union(set(['data', 'ai', 'learning', 'time', 'machine', 'like', 'use', 'new', 'intelligence', 'need', "it's", 'way', 'artificial', 'based', 'want', 'know', 'learn', "don't", 'things', 'lot', "let's", 'model', 'input', 'output', 'train', 'training', 'trained', 'it', 'we', 'don', 'you', 'ce', 'hasn', 'sa', 'do', 'som', 'can']))# Remove stopwords
def remove_stopwords(text):
    clean_text = []
    for word in text.split(' '):
        if word not in stop_list and (len(word) > 2):
            clean_text.append(word)
    return ' '.join(clean_text)medium['text'] = medium['text'].apply(remove_stopwords)

在你的语料库上运行单词计数(在移除标准停用词之后)可以快速识别一些更明显的领域特定停用词，但是通常这些停用词列表需要通过反复试验来精炼。

作为最后的预处理步骤，我们将对文档应用词干分析器，将各种单词时态和词尾变化转换成标准化的词干。这将产生一些词干，看起来像是被屠宰了的(例如，image → imag 和 busy→busi)，但是人们通常很容易识别出真正的词根。

# Apply stemmer to processedText
stemmer = PorterStemmer()def stem_text(text):
    word_list = []
    for word in text.split(' '):
        word_list.append(stemmer.stem(word))
    return ' '.join(word_list)medium['text'] = medium['text'].apply(stem_text)

我们几乎准备好继续主题建模了，但是让我们首先将当前的数据框保存到一个 csv 文件中。

medium.to_csv('pre-processed.csv')

主题建模

预处理完成后，我们终于可以享受主题建模的乐趣了。主题建模的想法是将我们的文档转换成稀疏的词向量，然后应用降维技术来找到有意义的词分组。为此，我们将使用不同的方法构建多个模型，并比较结果。我们将寻找能产生最清晰、最有凝聚力、最具差异化主题的模型。这是无监督学习的领域，对结果的评估是主观的，需要良好的人工判断。

构建主题模型的第一步是将我们的文档转换成单词向量。有两种常用的方法，BOW(单词袋)和 TFIDF(术语频率，逆文档频率)。BOW 只是统计一个单词在文档中出现的次数。如果单词“president”在一个文档中出现 5 次，那么它将被翻译成该文档的稀疏单词向量的适当位置中的数字 5。

另一方面，TFIDF 基于这样的假设运行，即出现在每个文档中的单词对于任何一个单独的文档都不太重要。例如，考虑与 2020 年总统选举相关的文档集。显然,“president”这个词会出现在几乎每一篇关于这个主题的文章中，并且“president”不是一个特别有用的词来分析这个上下文中的任何单个文档。更多关于 TFIDF 的信息可以在这里找到。

为了简洁起见，我将只关注 TFIDF 主题模型的实现，除了 LDA 算法只适用于 BOW 的情况。根据我的经验，TFIDF 通常在提取清晰、有凝聚力和有区别的主题方面做得更好。首先，让我们将文档集转换为 TFIDF 稀疏向量表示，并将 SVD(单值分解)应用于稀疏集矩阵。

vectorizer = TfidfVectorizer(stop_words = stop_list,
                             ngram_range = (1,1))
doc_word = vectorizer.fit_transform(medium['text'])svd = TruncatedSVD(8)
docs_svd = svd.fit_transform(doc_word)

这将从我们的语料库中提取 8 个主题(根据我的判断，8 是这个语料库的最佳主题数，但可以尝试使用不同的数量)，并将我们的文档转换为 8 维向量，这些向量表示该文档中每个主题的存在。现在让我们编写一个函数来打印出每个主题中最突出的单词，这样我们就可以评估 SVD 算法的执行情况。

def display_topics(model, feature_names, no_top_words, no_top_topics, topic_names=None):
    count = 0
    for ix, topic in enumerate(model.components_):
        if count == no_top_topics:
            break
        if not topic_names or not topic_names[ix]:
            print("\nTopic ", (ix + 1))
        else:
            print("\nTopic: '",topic_names[ix],"'")
        print(", ".join([feature_names[i]
                        for i in topic.argsort()[:-no_top_words - 
                                                 1:-1]]))
        count += 1display_topics(svd, vectorizer.get_feature_names(), 15, 8)