建立您自己的自定义热门词探测器零训练数据和$0！
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 上运行它们
好的。所以，这个阶段有点棘手。请确保您耐心且虔诚地遵循本回购文件:
从全新安装 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 部署
我正屏息等待这一阶段。我一回到默认世界就更新这篇博文！*
构建您自己的数据仪表板
数据专业人员权威指南(商业智能)
使用 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 应用程序。你将只陈述你需要什么，而不是如何实现目标的细节。
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 个重要步骤，生成您的第一个仪表板！
- 导入和激活仪表板
- 准备数据
- 可视化图表
- 下拉菜单和输入过滤器选择
- 造型和装饰
导入和激活仪表板
像往常一样，让我们在 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 能做什么的更好的见解。请随意访问以下链接。我向你保证，这些将提高你的仪表板设计技能，以解决现实生活中的业务问题。
最后…
Source: Unsplash
我真的希望这是一本很棒的读物，是你发展和创新的灵感来源。
请在下面评论出来建议和反馈。就像你一样，我也在学习如何成为一名更好的数据科学家和工程师。请帮助我改进，以便我可以在后续的文章发布中更好地帮助您。
谢谢大家，编码快乐:)
关于作者
Vincent Tatan 是一名数据和技术爱好者，拥有在 Visa Inc .和 Lazada 实施微服务架构、商业智能和分析管道项目的相关工作经验。
Vincent 是土生土长的印度尼西亚人，在解决问题方面成绩斐然，擅长全栈开发、数据分析和战略规划。
他一直积极咨询 SMU BI & Analytics Club，指导来自不同背景的有抱负的数据科学家和工程师，并为企业开发他们的产品开放他的专业知识。
请通过 LinkedIn ，Medium或 Youtube 频道 联系文森特
用 R 构建你自己的神经网络分类器
导言
图像分类是计算机视觉中的一个重要领域，不仅因为许多应用都与它相关，而且许多计算机视觉问题都可以有效地归结为图像分类。图像分类中最先进的工具是卷积神经网络(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 次迭代训练模型。您可以改变迭代次数、学习率和正则化强度，并绘制最佳拟合的学习曲线。
随机图像的预测
最后，我们随机选择一张图片，预测标签。
结论
如今，我们很少从头开始编写自己的机器学习算法。有成吨的软件包可用，他们最有可能胜过这个。但是，通过这样做，我真的对神经网络的工作原理有了深刻的理解。在一天结束时，看到你自己的模型产生一个相当好的准确性是一个巨大的满足。
建立你自己的熊猫(喜欢)图书馆
我主要通过泰德·彼得鲁的烹饪书了解熊猫。而现在，Ted 又想出了另一个有趣的项目: 建造我们自己的熊猫像库 。它包含一系列需要完成的步骤，以便构建一个类似于熊猫的全功能库，称为 pandas_cub 。图书馆将拥有熊猫最有用的特征。
我喜欢这个项目的地方
- 项目规模:该项目为熟悉 Python 的人提供了一个编写大代码的绝佳机会。
- 设置环境:这个项目帮助你学习如何为你的项目创建一个独立的环境。这是使用
conda包管理器完成的。 - 测试驱动开发:你也学习测试驱动开发，这意味着你首先写测试，然后你写代码通过测试。在这个过程中你会学到 python 库
pytest。
先决条件和设置可以在项目的 Github 页面上找到，但我仍然会提供一个快速浏览。
步骤 1: 派生存储库
第二步:克隆你的本地拷贝
没错。现在，我们可以填写我们的代码，并将其推送到我们的项目副本中。但是，如果项目的创建者修改了原来的项目呢？我们希望我们的分叉版本中也有这些修改。为此，我们可以将一个名为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 分钟内建立自己的推荐系统！
机器学习技术在商业中最成功和最广泛的应用是推荐系统。
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 用于数据科学和机器学习训练营”让我很容易理解所有这些概念。
在几分钟内构建您自己的强大深度学习环境
深度学习环境配置的不太理想方面指南
Photo by Kyle Hanson on Unsplash
介绍
多亏了更便宜、更大的存储，我们拥有了比几年前更多的数据。无论大数据制造了多少宣传，我们都应该感谢它。然而，这里真正的 MVP 是更快更好的计算，这使得 20 世纪 80 年代和 90 年代的论文更加相关(lstm 实际上是在 1997 年 )发明的！由于更好更快的 CPU 和 GPU，我们终于能够利用神经网络和深度学习的真正力量。不管我们喜欢与否，传统的统计和机器学习模型在处理高维、非结构化数据、更复杂和大量数据的问题时有严重的局限性。
Source: https://twitter.com/andrewyng/status/700086119333892096
深度学习已经开始在这些领域大放异彩，我们已经慢慢地看到它在整个行业中被大规模应用于几个现实世界的问题。著名的人工智能传奇人物吴恩达几年前也提到过同样的问题！
深度学习 的好处是，在构建解决方案时，我们有更好的计算、更多的数据和各种易于使用的开源框架，如**keras**、**tensorflow**和**pytorch**可供选择。
关于深度学习不好的部分？ 从零开始建立自己的深度学习环境可能是一个巨大的痛苦，尤其是如果你迫不及待地开始编码和实现自己的深度学习模型。
经历了几次这个痛苦的过程，也在我的旅程中发现了易于使用的服务，本指南旨在让你轻松地完成建立自己的深度学习环境的不太理想的方面，以便你可以更快地建立你的深度学习模型和解决问题。我们将在本指南中涵盖以下方面。
- 最小配置的基于云的深度学习环境
- 设置你自己的基于云的深度学习环境
- 内部设置提示
事不宜迟，让我们开始吧！
最小配置的基于云的深度学习环境
如果你真的想在不投资专用硬件的情况下开始建立深度学习模型，或者你想跳过所有那些讨厌的配置和设置命令，有几个选项只适合你！使用预先配置的基于云的深度学习环境是最好的。通常，有几个基于云的深度学习服务提供商。以下选项使您能够立即开始工作，只需最少的设置和配置。请注意，这不是我的全面列表，而是我已经试验过或从深度学习实践者那里听到的选项。
我们将介绍这些提供商的基本知识，以便您有足够的知识开始使用它们。除此之外，我们鼓励你走出去，进一步探索它们的细节，并根据你的喜好选择一个！
谷歌联合实验室
也许是谷歌最好的(仍然)免费的选项之一，它让你能够在 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 聊天分析器
最近，在完成了 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 对话更加了解了！那些是相当多的见解，不是吗？你从谈话中获得了什么样的见解？你觉得它们有用吗？你有没有发现这里没有提到的其他有用的见解？请随意在评论区添加您的想法，以便我改进本指南。
这种分析并不是探索和分析的全部。我还没有考虑到像表情符号这样的东西，它们在对话中使用得相当多。或者他们是？我应该抛弃标点符号吗？为什么大多数消息只包含一个单词？
似乎我们的分析在回答了很多问题的同时，也打开了新问题的潘多拉魔盒。嗯，这不是结束。请继续关注不久的将来的一篇文章，在那里我将尝试更深入地挖掘这些问题。
在那之前，再见了，朋友们，祝探索愉快！
来自我的问候……耶我！
打造您的个人语音助手
通过语音命令在计算机上执行任务
我一直对 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)
用这些数据为好的项目想法建立你的投资组合
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
有很多方法可以参与进来，围绕“数据为善”的理念建立社区这里有一些你可以参与的方法，无论是通过为一个组织做志愿者还是参加一个会议。
结论
Credit: Unsplash
我希望这些资源能激励您创建数据为善的项目！请记住，这些资源只是可用资源的一个快照。如果你想分享更多你参与过的资源或项目，请在下面评论！
—
感谢 Anuva Kalawar 总是与我分享数据换好处的资源。
Jasmine Vasandani 是一名数据科学家和战略家。你可以在这里了解她的更多:【https://github.com/jasminevasandani/about_jasmine】。
为人工智能构建后端系统
构建可扩展“人工智能”系统的挑战
让我们探讨一下构建一个后端系统来存储和检索高维数据向量所面临的挑战，这是使用“人工智能”的现代系统的典型特征，包括图像识别、文本理解、文档搜索、音乐推荐等
在我的上一篇文章中，我提到了一个我写的用来替代第三方 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 构建贝叶斯逻辑回归
我认购定期存款的可能性有多大？后验概率，可信区间，优势比，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 构建一个更好的亵渎检测库
为什么现有的库没有启发性，以及我如何建立一个更好的库。
几个月前，我需要一种方法来检测用户提交的文本字符串中的亵渎内容:
This shouldn’t be that hard, right?
为此，我最终构建并发布了自己的库，名为亵渎检查:
一个快速、健壮的 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
怎样才能更好？如有任何想法或建议，请随时联系我们或发表评论！
一个快速、健壮的 Python 库，用于检查字符串中的攻击性语言。-vzhou 842/亵渎-检查
github.com](https://github.com/vzhou842/profanity-check)
也贴在【victorzhou.com】上。
构建更好的查询引擎
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 系统有两大主题:
- 传统算法如条件随机场 (CRF)
- 基于深度学习的方法
如果你有一个大的数据集，基于深度学习的方法在文本数据领域非常有效。大约 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̅，我)= {1 如果 yᵢ₋₁是其他，yᵢ是技能，并且当前单词存在于我们的已知技能列表中，否则 0}
假设我们的列表中有这样的技能:
('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 分解构建图书推荐系统
每周一，我都会点击“发现周刊”的列表，看看 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)个折叠作为训练集，并对剩余的折叠进行测试，对所有结果进行平均。也许这将是后续文章的主题:)
免责声明&离开的想法:) 最后，这是我的第一个数据科学/机器学习实践帖子，所以我希望这是一个有用的教程，直观地解释了模型背后的数学原理。
祝您构建自己的推荐引擎愉快，不要忘记订阅我的频道或在下面提问以获得澄清！😃
扫一扫
724
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
