TowardsDataScience-博客中文翻译-2021-九十五-
TowardsDataScience 博客中文翻译 2021（九十五）
Python 和数据科学的 Visual Studio 代码？你必须拥有的前 3 个插件
是 Python 和数据科学最好的代码编辑器吗？
您是否正在努力寻找一个适合 Python 编程和数据科学的最佳代码编辑器？你并不孤单。有大量的选项可供选择——既有免费的也有付费的——今天我将向你展示我最喜欢的免费选项。
这是 Visual Studio 代码——微软的一个完全免费的代码编辑器。这是迄今为止我发现的最灵活、功能最丰富的代码编辑器。它甚至比 PyCharm 社区有更多的功能，py charm 社区应该是一个专业的 IDE。甚至不要让我开始使用 Jupyter——这可能是写笔记本的最好方法，但是对于数据专业人员来说，光有笔记本是不够的。
今天，您将看到我为 Python 编程和数据科学设置 VSCode 的常用方法。我们将从安装开始，从那里开始浏览插件。
不想看书？请观看我的视频:
下载并安装 Visual Studio 代码
前往 code.visualstudio.com下载 VSCode。网页会自动检测你的操作系统，所以你只需要点击蓝色的下载按钮:
图片 1 — Visual Studio 代码主页(图片由作者提供)
在 Mac 上，它会下载一个 ZIP 文件，你可以提取并拖动应用程序到应用程序文件夹。在 Windows 上，我假设您需要打开。EXE 文件，然后点击几次 Next，对于 Linux，它可能是一个终端命令或 DEB 文件。
一旦启动它，您应该会看到以下内容:
图片 2 — Visual Studio 代码(图片由作者提供)
您可以通过打开机器上的任何文件夹，右键单击左侧边栏并选择新文件来创建 Python 文件。我在桌面上创建了一个文件夹，里面有一个main.py文件:
图 3-在 VSCode 中创建 Python 脚本(图片由作者提供)
默认情况下，您不会有最好的调试选项，也不会有智能感知。您也无法选择虚拟环境。解决这个问题又快又简单。你只需要安装一个插件。但是让我们先解决一些更紧急的事情。
下载主题(可选)
在 VSCode 中，我喜欢做的第一件事是更改主题。与 Python 和数据科学无关，所以你要么跳过这一节，要么把它当作加分项。
默认的主题对我来说太微软化了。要更改它，你可以点击扩展标签并搜索主题。我特别喜欢 One Dark Pro 主题，它是免费的，尽管上面写着 Pro :
图 4 —一个深色专业主题(图片由作者提供)
点击主题并点击安装按钮。默认皮肤对我来说有点太浅了。在 Mac 上，你可以按 CMD+K CMD+T 打开主题下拉菜单。我最喜欢的是 One Dark Pro Darker :
图 5 —使用自定义主题(作者图片)
好多了，不是吗？接下来让我们处理扩展。
官方 Python 扩展
如果你想使用 Python，这是必须的。再次进入扩展选项卡，搜索 Python 。您应该安装微软的官方扩展:
图片 6-官方 Python 扩展(图片由作者提供)
现在，编写 Python 文件将变得更加容易。您现在还可以选择一个虚拟环境，这是您每天都要做的事情。点击左下角的文本 Python 3.9.7 64 bit (至少在我的机器上)并选择你想要的任何环境:
图 7 —选择虚拟环境(图片由作者提供)
你知道最棒的是什么吗？您可以立即开始使用 Jupyter 笔记本电脑工作！创建一个.ipynb文件来验证——它可能会提示您安装一些额外的依赖项，所以只要同意所有的东西就行了。
安装后，您可以在单元格中输入 Python 代码来验证一切正常:
图 8 —测试 Jupyter 笔记本电脑(图片由作者提供)
就这样——您现在已经安装了基础，因此您可以通过脚本或笔记本使用 Python。接下来让我们添加一些额外的功能。
Python 文档字符串生成器
编写好的 Python 代码的一个基本技巧是文档。VSCode 可以帮你做到这一点。你需要做的就是安装Python Docstring Generator扩展。
图片 9 — Python 文档字符串生成器扩展(图片由作者提供)
让我们看看它是如何工作的。您将编写一个对两个整数求和的虚拟 Python 函数:
def add(a: int, b: int) -> int:
return a + b
在main.py里面写函数:
图 10-虚拟 Python 函数(图片由作者提供)
现在，您可以通过在函数声明下面写三个双引号并选择生成文档字符串选项来添加文档字符串:
图 11 —文档字符串生成器(图片由作者提供)
它会立即为您编写样板文件:
图 12 — Docstring 样板文件(作者图片)
您现在所要做的就是编辑描述和每个参数的作用:
图 13 —编辑文档字符串(作者图片)
这比从头开始编写所有内容要容易得多。也许你看不到好处，因为我们只有一个函数，但是想象一下你有多个 Python 模块，每个模块有几十个函数——那么这个扩展是一个巨大的时间节省。
蟒蛇绒
最后，我想讨论一下林挺。您可以在 VSCode 中启用林挺来自动告诉您是否没有遵循 Python 约定。它会告诉您是否有未使用的导入、变量，或者您的代码中是否有需要改进的地方。
首先，打开命令调色板(设置—命令调色板…或按 SHIFT + CMD + P)并输入 Linter 。选择选择棉绒选项:
图 14-选择 Python linter(图片由作者提供)
PyLint 是最受欢迎的一个，点开就行了:
图 15 —棉绒选项(图片由作者提供)
如果还没有安装 PyLint，它会要求您安装它。您必须对每个虚拟环境重复这一过程，因此请记住:
图 16 —安装 PyLint(图片由作者提供)
现在让我们删除add()函数，探索一下 PyLint 提供了什么。您将导入json和random模块，并打印一个 1 到 100 之间的随机整数:
import json
import random
print(random.randint(1, 100))
它应该是这样的:
图 17-警告信息(1)(图片由作者提供)
一旦保存文件，您就会看到警告消息。print语句报错是因为它后面没有新的一行，但这是一个快速解决方法——只需在行尾按 Enter 键。
顶部的 import 语句带有下划线，因为我们在顶部没有文件级的 docstring，所以让我们快速编写一个:
图 18-警告信息(2)(图片由作者提供)
如果保存文件，警告不会消失。它现在抱怨你已经导入了json，但是没有在文件中使用它:
图 19-警告信息(3)(图片由作者提供)
删除未使用的导入后，该消息将消失。
总而言之，linters 可以帮助您编写更好的 Python 代码，并确保您遵循所有的约定。如果 linter 向您发出警告消息，您的代码仍然会运行，但是查看这些消息很烦人，所以当它们出现时，您可能会处理它们。
今天就到这里。我在 VSCode 中的 Python 和数据科学设置有些简单，但它完成了工作。
你最喜欢的 Python 和数据科学的 VSCode 扩展有哪些？请在下面的评论区告诉我。
喜欢这篇文章吗？成为 中等会员 继续无限制的学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
https://medium.com/@radecicdario/membership
保持联系
Visual Studio 代码现在可以作为 Web 应用程序使用。你应该关心吗？
意见
这让 Python 程序员和数据科学家非常失望——原因如下
Visual Studio 代码是我最喜欢的 Python 编程和数据科学的代码编辑器。对于任何数据科学工作流来说，它都是一把瑞士军刀，因为它支持 Python 文件、笔记本、远程连接和几乎任何你能想象到的东西。此外，它是完全免费的。
微软最*决定把它带到网络上——这是一个大胆的举动，但我能看到开发者如何从中受益。对于数据科学家来说，这是一个完全不同的故事，因为它在当前的迭代中已经毫无用处。继续阅读，找出原因。
不想看书？请观看我的视频:
如何开始使用 VSCode Web
只需前往 vscode.dev 。一个熟悉的界面会立即出现:
图 1 — Visual Studio 代码 Web 界面(图片由作者提供)
在这里，您可以从您的机器上打开一个文件夹，也可以打开一个远程存储库。我在桌面上为这篇文章创建了一个专用的vscode_web文件夹，所以我选择第一个选项。
请记住 —你不能在 Safari 中打开本地文件夹，因为它还不被支持。一定要安装一个更消耗资源的网络浏览器。如果您发现另一个不受支持的浏览器，请告诉我。
假设您在受支持的浏览器中，您可以毫无问题地打开本地目录:
图 2 —在 VSCode Web 中打开本地目录(图片由作者提供)
好了，我们可以走了！在开始扩展之前，让我们创建一个 Python 文件。我给我的取名main.py:
图 3-在 VSCode Web 中创建 Python 文件(图片由作者提供)
这基本上涵盖了好的部分。对于 Python 程序员和数据科学家来说，事情从此开始走下坡路。
面向 Python 和数据科学的 VSCode Web 扩展
VSCode 就像没有扩展的记事本一样有用。目前，VSCode Web 的可用扩展数量令人失望。作为一名数据科学家，你可能找不到你想要的东西。
先说微软官方的 Python 扩展。您可以安装它，但它会立即警告您该扩展在 VSCode Web:
图片 VSCode 的 Python 扩展(图片由作者提供)
然而，你可以安装它没有任何问题。它增加了智能感知、林挺、代码格式化和任何你能想到的 web 应用。
如果你不会运行 Python 代码，那么写 Python 代码就毫无意义。 Visual Studio 代码 Web 不包终端支持。不容易消化但是可以理解。出于显而易见的原因，向 web 应用程序添加终端并不容易。
一个可能的解决方案是安装代码运行器扩展。它向 Python(和其他)文件添加了一个按钮，允许您运行代码。问题是——不支持扩展:
图 5 —不支持的扩展(图片由作者提供)
这意味着您被困在一个无法运行的 Python 文件中。您可以创建 Python 文件，并随意编辑它们，但仅此而已。
我现在看到的唯一选择是创建一个 Jupyter Notebook 并交互执行代码。我给我的取名为nb.ipynb。这又是一件令人失望的事情，因为你不能创建一个新的代码单元或者改变 Python 内核。猜猜为什么不支持 Jupyter 扩展:
图 6 —没有 Jupyter 支持(图片由作者提供)
总结一下，你能做的不多。在这一点上，我找不到任何值得谈论的好处。也许将来事情会有所改变，但不能保证。
我们可以花更多的时间来测试与远程机器的连接等等，但是如果连最基本的东西都不能用，那还有什么意义呢？
结论
如果您希望作为 Python 程序员或数据科学家使用 Visual Studio Code Web，您没有太多选择。您可以创建 Python 文件，并在适当的智能感知和林挺中享受，但这几乎概括了您的选择。您不能管理虚拟环境、调试代码、通过扩展或终端运行 Python 文件，甚至不能在 Jupyter 笔记本上运行代码。
简而言之，只需在本地安装 VSCode，目前使用 web 版本没有意义。也许未来的版本会扩展功能并增加对额外扩展的支持，但是谁知道呢。这肯定会是一个可喜的变化。
你作为 Python 程序员或者数据科学家尝试过 VSCode Web 吗？你有什么想法？请务必在下方评论区分享。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
https://medium.com/@radecicdario/membership
保持联系
可视化与熊猫和 Plotly 意甲(足球联赛)数据
上次我用意甲数据比赛，试图了解更多关于米兰德比的信息。然后我想对数据做更多的探索，这样我可以更好地了解球队在意甲的表现。作为数据可视化的忠实粉丝，饼状图、树状图、线图和条形图都被采用。
托马斯·塞勒在 Unsplash 上的照片
先决条件—软件包
本次分析使用的包有:熊猫用于数据清洗； glob 用于数据合并； numpy 用于数据过滤和分组； plotly.express 用于数据可视化
import pandas as pd
import glob
import numpy as np
import plotly.express as px
步骤 1 获取数据、导入数据和合并数据
当前分析中使用的数据来自 ka ggle(https://www.kaggle.com/massibelloni/serie-a-19932017)。我下载了 1993 年到 2017 年的所有意甲数据，保存到本地文件夹。
path = r'....(your local folder)\SerieA'
all_files = glob.glob(path + "/*.csv")table = []for filename in all_files:
data = pd.read_csv(filename, index_col=None, header=0)
table.append(df)frame = pd.concat(table, axis=0, ignore_index=True)
由于分析仅使用了前七列的数据，因此选择了这些列:
df = frame.iloc[:,0:7]
现在数据帧看起来像这样:
图 1 :测向头(10)
步骤 2:根据可视化需要添加列
为了更好地显示，基于当前数据框添加了一些列:
### To identify the winner of each match: if "H"- the home team was the winner, if "A" the away team was the winner, else draw:df['Winner'] = np.where(df['FTR'] == 'H',df['HomeTeam'],
np.where(df['FTR'] == 'A', df['AwayTeam'], "Draw"))### To identify the result of each match: whether the home team won, the away team won, or drew:df['Result'] = np.where(df['FTR'] == 'H','HomeTeamWin',
np.where(df['FTR'] == 'A', 'AwayTeamWin', "Draw"))### To identify how many goals did the winner had:
df['Result'] = np.where(df['FTR'] == 'H','HomeTeamWin',
np.where(df['FTR'] == 'A', 'AwayTeamWin', "Draw"))### To get the "Year" of each match:
df['Year']=pd.DatetimeIndex(df['Date']).year### To get the total number of goals in each match and the goal differences:
df['TotalGoal'] = df['FTHG'] + df['FTAG']
df['GoalDif']= df['FTHG']- df['FTAG']
包含更多列的数据框如下所示:
图二:测向头(10)
视觉化
饼图 I
首先，我想知道的基本信息是，在意甲联赛中，赢一场比赛和*局的比例是多少；谁更有机会赢得这场比赛——主队还是客队:
为了获得这种可视化，在应用 plotly.express 之前，我首先对“结果”进行分组:
### Group the data by Result:
general = df.groupby('Result')['Result'].count().reset_index(name = "count")### Apply px.pie:
fig1 = px.pie(general, values ='count', names ='Result', title='Serie A - results from 1993 - 2017', color = 'Result',
color_discrete_map={'HomeTeamWin':'royalblue',
'AwayTeamWin':'orangered',
'Draw':'lightgreen'})### Add text and define text information:
fig1.update_traces(textposition='inside', textinfo='percent+value')
fig1.show()
图 3 :饼状图一——赢/*比例
这张图表清楚地表明，* 70%的比赛都有赢家，而且主队比客场更有可能获胜——我认为这就是所谓的——主队优势！
饼图 II
我真正感兴趣的另一件事是哪支球队赢得了最多的比赛，排名是怎样的:
### Group by Winner
teamresult = df.groupby('Winner')['Winner'].count().reset_index(name = "Count")### Drop the results which were "Draw" as this data was not required for the visualisation
teamresult = teamresult[teamresult.Winner != 'Draw']### Visualisation
fig2 = px.pie(teamresult, values = 'Count', names = 'Winner', title = "Serie A Result from 1993 - 2017 - Most Win Team", color = 'Winner', color_discrete_sequence=px.colors.qualitative.Light24)
fig2.update_traces(textposition='inside', textinfo='percent+label')
fig2.show()
图 4 :饼状图一 I——最多胜队比例
有趣的是，尤文图斯比其他球队赢得了更多的比赛，紧随其后的是国际米兰。
旭日图
我在 PowerBI 可视化中经常使用的一种奇特的图表是旭日图。在这个想象中，我想知道从 2012 年到 2016 年，哪支球队每年赢得更多的比赛。
### To remove "draw" results and filter the year between 2012-16
sun = df[(df.Winner != 'Draw') & (df.Year.between(2012,2016))]### Group results by Year & Winner
sun1 = sun.groupby(['Year','Winner'])['Winner'].count().reset_index(name = "Count")### Sunburst chart visualisation
fig3 = px.sunburst(sun1, path=[ 'Year','Winner'], values='Count')
fig3.update_traces(textinfo = 'label + value')
fig3.show()
图 5 :旭日图——团队年度冠军
树形图
另一种形象化比例的方法是树形图，我发现这种方法非常方便且易于理解。下面是一个使用树形图直观显示团队获胜总数的示例:
### Remove the results which were "draw"
treemap = df[(df.Winner != 'Draw')]### Group data by Team
treemap1 = treemap.groupby('Winner')['Winner'].count().reset_index(name = "Count")### Visualise the data with treemap
fig4 = px.treemap(treemap1, path=['Winner'], values='Count'
)
fig4.update_traces(textinfo = 'label + value')
fig4.show()
图六:树状图——最多获胜的队伍
如您所见，treemap 是一个非常好的图表，可以显示不同项目之间的比例和比较。尤其是当你比较许多项目时，饼图可能会受到文本/注释空间的限制，treemap 提供了一种更好的方式来呈现这些信息。
折线图
为了进一步探索这些数据，我想创建一个折线图，显示每年的总目标:
### Group total goals by year
total_goal =df.groupby('Year')['TotalGoal'].agg('sum').reset_index(name = 'Sum')### Remove the data for 1993 and 2017 as it seemed that the data for those years were not complate
total_goal = total_goal[(total_goal.Year != 2017) & (total_goal.Year != 1993)]### Visualise by line chart
fig5 = px.line(total_goal, x = 'Year', y = 'Sum', title = 'Total Goals by Year',
line_shape = 'spline')
fig5.show()
图 7 :折线图——总目标
条形图
我想知道的另一件事是，作为主客场球队，球队的表现有什么不同。当他们是主队时，他们进了更多的球吗？
### Number of goals for hometeam
test1 = df.groupby('HomeTeam')['FTHG'].agg('sum').reset_index(name = 'HomeSum')
test1 = test1.rename(columns={"HomeTeam": "Team1"})### Number of goals for awayteam
test2 = df.groupby('AwayTeam')['FTAG'].agg('sum').reset_index(name = 'AwaySum')
test2 = test2.rename(columns = {'AwayTeam':'Team2'})### Merge two dataframe
result = pd.concat([test1, test2], axis=1)
dt = result.drop(['Team2'], axis=1)### Visualise the chart
fig6 = px.bar(dt, x = "Team1", y =['HomeSum','AwaySum'], title = 'Goals by Home & Away')
fig6.show()
图 8 :条形图——主场/客场进球
看起来球队在主场比赛时更有可能进球。
每个队的总目标是什么？
### Total goals by each team
dt['Total'] = dt['HomeSum']+dt['AwaySum']### Rename column
dt= dt.rename(columns={'Team1':'Team'})### Bar chart visualisation
fig6 = px.bar(dt, x='Team', y='Total', text = 'Total', color = 'Total',
color_continuous_scale=px.colors.sequential.Viridis)
fig6.update_traces(textposition='inside')
fig6.show()
图 9 :团队总目标
令人惊讶的是，罗马在那些年里有超过 1500 个进球，尽管这支球队赢得了一次联赛冠军。
总而言之
我喜欢图表讲述意甲历史的方式！
用 Python 可视化全球人口数据集
Python 实践教程
由面 shapefiles 限定的地理空间栅格和矢量数据集的汇总统计数据
这项工作完全使用公开可用的数据完成，并与Kai Kaiser合作完成。所有错误和遗漏都是作者的。
美国宇航局在 Unsplash 拍摄的照片
关于人口分布的地图信息对于地球上不同国家背景下的一系列公共政策问题至关重要。掌握人口的地理分布及其主要特征的能力是衡量遭受灾害和气候变化影响的程度以及获得健康、环境和土地使用压力等关键服务的机会差异的一个组成部分。无论是出于规划、预算还是监管目的，足够精细和及时的人口数据对于更加循证的决策都是必要的。
新一代高分辨率人口估计计数图层将对公共部门决策做出越来越大的贡献，特别是在发展中国家。制图层依靠非传统的数据收集方法，包括使用卫星图像。因此，他们可以提供分辨率低至 30 米的地球上任何网格单元的人口估计。他们的最新更新可以通过应用程序编程接口(API)在线访问，这使他们成为数据驱动型决策者潜在的非常有价值的资产。
这些高分辨率人口地图解决了传统行政或统计人口普查数据的一些关键局限性。人口普查数据通常缺乏频繁更新，大多数国家大约每十年才更新一次。它们通常以表格管理分类的形式呈现，与更细粒度的基于网格的层相比，这限制了分析和可视化选项。家庭一级的人口普查数据很少在地理参照的基础上收集，或在这一级披露。国家和国家以下各级政府维持的出生和死亡行政登记册也不总是可靠或更新的，特别是在低收入和中等收入国家。
脸书研究高分辨率定居层(HRSL)和 World Pop 等数据集采用新一代高分辨率人口估计技术，可随时用于一系列描述性和规范性分析。
WorldPop 项目于 2013 年启动，目标是提供人口和人口统计数据集的开放访问，以支持发展、灾难和健康应用。它整合了在小区域进行的邻里级微观人口普查调查以及国家级卫星图像和数字制图。简而言之，WorldPop 利用机器学习建模(随机森林)从相对稀疏的微观人口普查数据中推断出高分辨率的国家人口估计值(包括预测未调查地区的人口)，并从 2000 年到 2020 年(截至 2020 年 11 月)每年提供。网格化人口数据或光栅图像的空间分辨率详细到 3 弧秒(赤道约为100 米)。这种高分辨率人口统计估计数的时间可用性使得确定国家和区域两级的人口增长和动态更加容易。
另一个这样的合作是脸书与国际地球科学信息网络中心(CIESIN)的合作，使用人工智能从卫星图像中识别建筑物，并以 30 米的分辨率估计人口。在国家一级也进行了调整，以使普查人口与联合国估计数相匹配。这些调整是为了配合联合国对 2015 年和 2020 年国家人口的估计。
在实践中，决策者可能还不太熟悉如何获取、分析、应用并最终采用这些数据来进行决策。更加熟悉也将有助于他们了解这些新数据资源的可能优势和应用，以及它们在决策方面的局限性。
为了支持基于数据和数据驱动的决策，在线 Jupyter 笔记本 Python 环境( JPNEs )允许以可访问和可复制的方式实现数据分析和可视化。
JNPEs 集成了编程代码、直观描述以及数字和视觉输出(cite)。当在线实施时，它们不需要用户安装或下载任何本地软件。JPNE 不仅在交付工作方面非常强大，而且最重要的是促进了领域和公共部门专家与数据科学家之间的密切合作。
在这篇博客中，我们用 Python 在一个 JPNE 中探索了 WorldPop 人口统计(以 tif 文件下载的 100m 分辨率的栅格格式)和来自脸书的高分辨率人口密度地图(矢量格式，以 30m 分辨率下载的 csv )并可视化了越南不同行政单位的人口统计。
为了提取不同行政单位的估计人口数量，我们还需要将越南的数字边界表示为 shapefiles(一种简单的非拓扑格式，用于存储表示为面或区域的要素的几何位置和属性信息)。
因此，这项分析需要三个数据集——来自 WorldPop 和脸书的人口数据，以及来自 GADM 的行政边界数据。分析包括 4 个步骤-
- 从 GADM 加载并浏览行政边界数据
- 从 WorldPop 加载、浏览和可视化人口数据
- 从脸书加载、探索和可视化人口数据
- 比较和总结结果
从 GADM 加载并浏览行政边界数据
全球行政区域数据库 GADM是一个高分辨率的国家行政区域数据库，最新版本划定了 386735 个行政区域。越南的国家级数据已下载，并生成了一个具有以下结构的文件夹。
GADM 的文件夹结构(来源——作者)
文件的索引(0，1，2，3)表示边界可用的管理级别。
越南被划分为 58 个省和 5 个直辖市，由中央政府管理，总共有 63 个一级行政区。越南各省再细分为二级行政单位，即区、省辖市和区级城镇。城市又分为农村地区、区级城镇和城市地区，城市地区又分为选区。因此，GADM 的数据包括 686 个二级单位和 7658 个三级行政单位。
gadm 造型文件用 geopandas 读取。
vietnam_administrative_boundaries = geopandas.read_file('Data/gadm36_VNM_shp/gadm36_VNM_3.shp')vietnam_administrative_boundaries['NAME_0'].unique()
**> Vietnam**vietnam_administrative_boundaries['NAME_1'].nunique()
**> 63**vietnam_administrative_boundaries['NAME_2'].nunique()
**> 686**vietnam_administrative_boundaries['NAME_3'].nunique()
**> 7658**
越南一级、二级和三级行政单位(资料来源——作者)
从 WorldPop 加载和浏览人口数据
我们从 WorldPop 下载了光栅格式的越南人口每像素(PPP)数据，分辨率为 100 米，调整后与联合国国家估计值相匹配。我们使用 rasterio ，一个 GDAL 和基于 numpy 的 python 库来读取作为 tif 文件下载的栅格数据。
vietnam_worldpop_raster = rasterio.open('vnm_ppp_2020_UNadj.tif')
栅格数据是任何像素化(或网格化)的数据，其中每个像素都与特定的地理位置相关联。像素值可以是连续的(例如高程)或分类的(例如土地利用)。地理空间栅格与数字照片的唯一不同之处在于，它伴随着将数据与特定位置联系起来的空间信息。这包括栅格的范围和像元大小、行数和列数及其坐标参考系统(CRS)。栅格数据集包含一个或多个称为波段的图层。例如，彩色影像有三个波段(红色、绿色和蓝色)，而数字高程模型(DEM)有一个波段(保存高程值)，多光谱影像可能有多个波段。
print('No. of bands:',(vietnam_worldpop_raster.count))
**> No. of bands: 1**
WorldPop 栅格图层-越南(来源-作者)
**# Calculating total population of Vietnam**worldpop_raster_nonzero = vietnam_worldpop_raster_tot[vietnam_worldpop_raster_tot>0]population_worldpop = worldpop_raster_nonzero[worldpop_raster_nonzero > 0].sum()print(round(population_worldpop/1000000,2),'million')
**> 97.34 million**
栅格图层给出了越南总人口9734 万。然后，我们使用从 GADM 文件中提取的多边形来遮罩此栅格图层，以识别越南 63 个省和直辖市(一级行政单位)中每个省和直辖市的人口数量。以下函数返回 vector_polygon 中栅格图层的人口数。
来源—作者
该代码通过添加一个名为 population_count_wp 的列来创建以下结果，该列包含基于 WorldPop 栅格数据的 ADM 级别 1 的人口估计值。然后，我们使用下面的代码片段，使用 Plotly Choropleth map 来可视化种群数量。
来源—作者
越南各城市的百万人口(资料来源-作者)
加载并浏览脸书的人口数据
脸书人口地图估计了居住在越南 30 米范围内的人口数量，该地图可以以 tif 文件或 CSV 文件的形式在 HDX 下载。由于我们对 tif 格式的 WorldPop 数据进行了预处理，我们在这里演示了以下列格式下载的 CSV 文件。
2021 年 11 月 11 日从 HDX 下载的数据(来源——作者)
CSV 文件包含截至 2015 年和 2020 年的纬度、经度和人口估计值。脸书的数据估计越南总人口为 9816 万。
为了使用 WorldPop 数据演示的地理空间工具和技术，我们需要将此数据框架转换为包含几何字段的地理数据框架。
然后，我们使用带有面的矢量图层的掩膜函数获得每个行政边界的人口数。
然后我们使用下面的代码绘制 choropleth 地图
越南各城市的脸书人口以百万计(资料来源-作者)
结论
现在在 JPNE 中预览了两个地图图层，我们现在转向通过大多数决策者熟悉的更熟悉的管理定义镜头来比较结果。为了做到这一点，我们可以用下面的散点图来显示世界流行与脸书结果的比较比率。一条 45 度线意味着任何给定地点的结果都是相同的。
在省/市一级，世界人口普查和脸书的人口统计显示出高度的相关性。
在第二个行政级别，特别是在*阳和胡志明市，与世界人口普查相比，脸书的人口数量相对较少。这是否是一个问题最终取决于所提的问题。JPNEs 允许快速查看使用一个数据源而不是另一个数据源对当前问题产生实质性影响的程度。
脸书和越南 ADM 二级世界流行人口计数之间的相关性(来源-作者)
*台(如 JPNEs)和数据(脸书研究 HRSL 和 World Pop)方面的数字技术发展为解决一系列政策问题提供了强大的组合。但这些需要领域专家(例如，规划、金融或卫生领域的政府官员)以及数据科学家(工程师/程序员)之间的实际协作。
这位从业者的博客是作为针对越南的 颠覆性公共资产治理技术(DT4PAG) 项目的一部分而产生的，该项目由世界银行在越南发起，得到了 瑞士国家经济事务秘书处(SECO) 的支持。
DT4PAG 提倡使用基于云的开源*台和数据，以及从业者通过技能建设进行学习。更好地为绿色、可持续发展提供信息。本说明中表达的观点是作者的观点，所有剩余的错误和遗漏都是我们自己的。
本教程的完整代码可以在GitHub repo中找到。即使您不是 Python 程序员，我们也希望这篇文章能让您直观地感受到利用这类数据进行新一代决策支持的可能性和过程。
时间序列数据中的可视化模式:2D 叠加图
如何为具有周期性的时间序列数据集创建漂亮的绘图
艾萨克·史密斯在 Unsplash 上拍摄的照片
什么是 2D 叠加图？
存在许多不同种类的时间序列数据，选择正确的方式来可视化它们并不总是简单的。具有周期性的数据尤其难以可视化，因为在许多情况下，由于单个图上的数据量巨大，周期性会丢失。
考虑到大多数人会发现很难识别一维照片上的任何东西，像素显示在一行中，这并不奇怪。然而，一旦像素以正确的二维格式重新排列，这个问题就神奇地消失了！
类似地，对具有周期性的数据应用简单的变换以使其二维化，通过以有助于人类理解的方式呈现数据，可以在可视化数据中固有的复杂模式方面创造奇迹。
有意地，我不会给你一个什么是 2D 叠加图的定义，也不会在这一点上给你看。我要做的是通过下面的一个例子一步一步地让你理解。
示例中的数据可能具有日、周和年模式。我希望你在每个情节前停下来，问自己以下问题:
- 这个情节传达的最重要的东西是什么？
- 该图显示的日、周和年模式有多清晰？
数据集示例
我们获得了一个数据集，其中包含 2018 年 1 月 10 日至 2019 年 4 月 31 日之间的 10，080 条记录。根据元数据，我们可以推断出，这些是整个供暖季期间建筑物内每半小时的内部温度读数。
对数据的初步观察
我们的第一直觉很可能是绘制随时间变化的值的传统方式，这产生了下面的图:
第一直觉:内部温度时间序列图(图片由作者提供)
通过观察该图，我们可以看到一些周期性:存在具有相对低δT 的日周期和在某些天具有较大δT 的周周期。年度模式(例如，周低点的最小值)不是很清楚。
请注意，在这一点上，这是对数据固有模式的一种相当模糊且不太有用的描述。我们认为有日模式和周模式，但我们不知道它们是什么。然而，这给了我们足够的时间继续下去，并指导我们的第二个直觉:由于数据集的值是建筑物的内部温度测量值，并且似乎存在日/周模式，因此建筑物可能有一个适当的供暖计划。
假设:如果这个数据集背后有一个驱动建筑热行为的供暖时间表，我们应该致力于展示供暖时间表，因为这是一个非常简单的概念。
可视化昼夜模式
我们决定下一步把重点放在观察昼夜模式上。一种方法是绘制数据，x 轴是一天中的时间，而不是完整的时间戳，包括日期(这是我们在第一次直觉中所做的)。我们的绘图仍将是二维的(x:一天中的时间；y: value ),各个日期相互重叠。要做到这一点，我们需要两个简单的转换来预处理数据。
首先，我们需要透视数据，以便时间戳的日期部分保存在索引中(即一条记录保存一天的信息)，时间戳的时间部分保存在标题中(即列名)。
第二，我们需要转置数据，因为默认情况下，单个字段会覆盖在图上，我们希望单个记录(即天数)被覆盖。
(您可能想知道，如果我们在接下来的步骤中需要转置数据，为什么要首先转置“错误的方式”。这样做的原因是为了遵守数据集结构的最佳实践:这样，如果我们向透视数据帧添加额外一天的测量值，我们将添加一条新记录，而不是一个新字段。)
支持 Matplotlib 的 Pandas 非常擅长制作简单的数据帧图，因此我们可以依靠它来制作我们的第一个尝试 2D 叠加图。
首次尝试显示日变化模式的 2D 叠加图(图片由作者提供)
让阿尔法正确
这看起来不太好，因为在图中有实心块，在那里不能跟随单独的线。这里的关键是向绘图传递一个自定义的透明度值，使单独的线条可见，并且在绘图变得非常繁忙时不会饱和。Matplotlib 使用 alpha 透明度，0.0 表示完全透明，1.0 表示完全不透明。在这种情况下，10%的 alpha 就很好了。
2D 叠加图显示自定义 alpha 的日变化模式(图片由作者提供)
整合领域知识
我们可以看到，从供暖系统的角度来看，18:00 对应于大多数日子的“供暖日”的开始。在这个时间之后的任何点，供暖系统可以决定开始预热建筑物，以在供暖计划的下一点达到所需的状态。
依靠我们的领域知识，我们正在将生成数据的系统的视角整合到我们希望查看者拥有的视角中。
2D 叠加图显示了以 18:00 作为“供暖日”开始的日变化模式(图片由作者提供)
添加更多模式与保持清晰
改变一天的开始时间对剧情的清晰度有很大的改善。然而，在这个情节上仍然有许多事情在进行，我们将努力使它变得更清楚。
这里我们要做一个重要的决定:我们要强调数据中的周和/或年模式吗？我们应该只选择周模式，原因如下:
- 供暖时间表每周确定一次
- 第一步的数据没有明确的年度模式
- 我们需要保持清晰:试图想象年度模式和周模式，我们会牺牲理解的容易性
抛弃这个维度伴随着责任:我们需要意识到这个决定，如果必要的话，我们必须能够在以后调查它。
可视化每日和每周模式
在对一周中的几天进行了几次颜色编码试验后，我们得出了下面的颜色方案。请注意，虽然我们保留了关于周模式的信息，但我们丢失了关于年模式的信息:例如，我们知道蓝线代表星期一，但我们不知道哪条蓝线对应于一年中的哪一个星期一。
每日和每周的模式清楚地描述了供暖时间表(图片由作者提供)
如果你认为这不再是 2D 的情节，因为我们使用颜色作为第三维度，你是非常正确的。这种绘图风格与我们通常认为的 3D 绘图是如此不同，以至于我可以称之为 2D 叠加图(有点欺骗)。
我认为我们已经成功实现了我们的目标:这张图片清楚地传达了以下供暖时间表:
- 周日:未设定供暖时间表
- 周一:与周二-周五相同，但预热时间更长
- 周二至周五:09:00 至 18:00，21 摄氏度
- 周六:14:00–16:00，21 摄氏度
此外，生成情节的代码非常简单:
摘要
- 我们得到了一个数据集，乍一看，它显示了一些日周期和周周期。
- 通过在预处理步骤中应用两个简单的变换，我们能够创建一个 2d 叠加图来呈现日变化模式。
- 调整图的 alpha 值，并结合我们的领域知识来调整开始时间，使得图更加清晰。
- 使用颜色，我们能够将每周的图案添加到可视化中。
- 我们有意丢弃了关于年度模式的信息，但这是一个保持清晰的有意识的决定。
Github 示例
您可以在 github 上获得示例数据和示例笔记本:
https://github.com/czagoni/medium-visualising-patterns
感谢阅读！如果你喜欢这篇文章，你也应该看看:
https://medium.com/analytics-vidhya/data-driven-thermal-models-for-buildings-15385f744fc5
用交互式图形可视化相似性聚类
利用 Python、Plotly 和 NetworkX 创建交互式图形来查找相似性聚类
让我们假设，作为一个运行的例子，我的数据由英语的单词嵌入组成。我想获得关于嵌入空间中的单词分布的见解，具体来说，是否存在非常相似的单词的任何簇，是否存在与其余单词完全不同的单词，是否存在与每一个其他单词都非常相似的单词，等等。我想直观地获得这些见解，以便更容易理解并与同事分享。
互动工具，我们将创造这个职位。连接的节点表示样本相似度高于滑块值阈值。图片作者。
在这篇文章中，我将向你展示如何构建一个交互式可视化工具来获得关于你的数据相似性聚类的见解。有各种各样的问题需要对数据分布有直观的理解。以一种互动的方式(在这个例子中，关于样本相似性)可视化这种分布可以给你这种直觉。此外，它还是向他人展示结果的一个很好的工具。
这是一篇非常实用的文章，因此，我将会更加精确地讨论构建细节。我提出的实现完全依赖于 Plotly 和 NetworkX 。
这篇文章分为四个部分:
- 样本相似性
- 图形构建
- 用 Plotly 绘制图形
- 交互实现
1)样本相似性
重要的事情先来。我们希望深入了解样本相似性聚类，因此，我们需要首先计算每个样本与其他每个样本的相似性。
您可以使用任何最适合您的数据的相似性度量。ideia 总是相同的:具有非常相似的特征向量(在我的例子中是嵌入)的两个样本将具有接* 1 的相似性得分。这些向量越不同，相似性得分就越接*于零。对于我的运行示例，我将使用余弦相似度。
从一个任意长度的 N 单词嵌入数组开始，我创建了一个维度为 N x N 的相似性矩阵，它指定了每对数据样本之间的相似性。在我运行的例子中，我有 78 个单词嵌入，每个对应一个不同的单词。
相似度得分热图:越亮得分越高(词对越相似)。图片作者。
2)图形构建
给定一个相似矩阵，使用 NetworkX 用图表示它是非常容易的。我们只需要将矩阵输入到构造函数中。
我们的图将有 N 个节点(每个节点对应于我们数据中的一个样本，在我的例子中是单词)，以及 N * N 条边，代表每对单词之间的相似度。有 N^2 是因为每对节点都有相似性得分，即使它非常接*于零。边权重表示相似度得分。
图 G 的可视化，包含相似性分数大于 0 的每对单词之间的链接。图片作者。
以静态方式形象化这个图表不是很有见地，主要是因为每一对单词都是相互关联的。我们可以做的第一件事是删除所有权重非常接*于零的边，并再次可视化图形。这显然不足以洞察相似性聚类。接下来我们可以做的是在区间[0，1]中迭代定义一个递增的阈值，移除所有权重低于阈值的边，并可视化该图。然而，以静态方式反复绘制这些图表在视觉上一点也不吸引人，而且会使事情更难理解。
接下来的部分将向您展示如何在一个单独的交互式图表中绘制所有这些增加阈值的图表，在底部有一个相似性得分滑块。能够自由操作该滑块非常有助于提供关于样本相似性和可能聚类的新见解。
3)用 Plotly 绘制图形
Plotly 是我们将用来创建我们的互动情节的框架。然而，到目前为止，它还不支持即插即用风格的图形绘制。为了避免这一点，我们将使用两种散点图来绘制我们的图形:一种用于节点，另一种用于边。
节点的散点图
这是一个简单的程序。给定一个 NetworkX 图，我们遍历所有节点并收集它们的 x，y 位置、颜色和文本(用于鼠标悬停信息)，这些都将在后面的部分中定义。然后，我们简单地使用这些信息，通过 Plotly 的接口创建一个散点图。在 Plotly 的语言中，散点图被称为轨迹，我们将其返回以备后用。
边缘散点图
事情在这里变得有点棘手。我们需要为图中的每一条边创建一个轨迹。将一条边想象成一个散点图，其中两个点由一条直线连接。
因此，对于 NetworkX 图中的每条边，我们获得其两点的位置，并创建一个连接这两点的线图。我们将这条边的轨迹添加到边轨迹列表中，并返回整个列表供以后使用。
4)交互实现
我们就要结束了。现在我们知道了如何使用 Plotly 绘制图表，我们可以创建一个交互式滑块来指定最小相似性阈值，这样权重低于阈值的边就不会显示。
虽然实现起来很长，但是概念上非常简单。基本上，对于每个滑块值(也称为步长)，我们用上一节中定义的例程创建一个完整的图形。我们在这里所做的是“预加载”每个滑块步长的每一个单独的图。因此，在图形的交互部分没有任何魔法:我们只是让一个特定的图形图形可见，而所有其他的图形对于每个滑块都是不可见的，创造出我们想要的幻觉。也是在这里，我们指定节点位置、颜色和文本。
最后，以交互方式绘制相似性聚类！
上面代码片段的输出(重复上面的 gif)。图片作者。
此外，当悬停在节点上时，您可以很容易地看到哪些单词属于哪个簇。在底部图像上显示的阈值中，人们可以立即看到“sharp”(左上)与任何其他单词都不够相似，而“arriable”(左下的 cluster)与许多单词相似，因此与许多节点有联系。
每个节点都标有单词名称的图表。将鼠标悬停在您的地块上以查看相同的文本。图片作者。
这就是如何创建一个交互式可视化工具来深入了解数据样本的相似性聚类。在结论性说明中，需要注意的是，这并不是为了相似性而严格定义的。您可以使用这个工具来可视化实体之间的任何类型的关系，只要用图形来表示它是有意义的。一个简单的例子是文档语料库中的单词共现。最后，通用方法并不严格适用于绘制图表:您可以使用散点图、条形图、饼图以及您可以想象的任何其他图表来创建交互图。重要的是它提供的交互性和解释的简易性。
可视化星际迷航人物互动
使用 Networkx 、 Pyvis 、&、 Streamlit 创建网络仪表板
每部《星际迷航》系列的主要角色互动的频率(图片由作者提供)
你可能遇到过交互式网络图(如果没有，我会推荐 José Manuel Nápoles Duarte 使用这个应用程序)。你可能也遇到过总结电视/电影角色之间互动的网络图(一个例子是最*在 r/dataisbeautiful 上发布的)。但是你见过互动人物互动图形(ICIG)吗？嗯，我制作了这个仪表板，其中包含《星际迷航》系列中每一部的 ICIGs，本文的其余部分将解释关键步骤。
1.找到数据
经常检查别人是否已经为你做了工作
所有数据科学项目都是从数据采集开始的。经过一番搜索，我找到了一个网站，上面有我需要的东西，每一集《星际迷航》的脚本(不包括最*的系列)，格式一致:
更重要的是，我甚至不用写脚本就可以从这个网站下载所有这些脚本。原来有人已经这样做了，并把它们都放在 Kaggle 上的 JSON 中:
https://www.kaggle.com/gjbroughton/start-trek-scripts
2.处理数据
总是检查你的输出是否通过常识测试
虽然《星际迷航》的每一个剧本都是伟大的文学作品，但我来这里只是为了冰冷的硬数据。我所关心的是两个字符有连续行的频率(这就是我如何定义这两个字符之间的一个“交互”)。
计算这个需要使用一些选择正则表达式来解析所有的抄本。这里有相当多的普通步骤，所以我只挑选几个处理步骤的几个例子:
从原始脚本到场景列表
又走了几步，我找到了一个包含每一行对话的数据框架，然后它可以被转换成一个包含每集角色之间互动次数的表格:
《星际迷航:原始系列》第一集的台词和互动
但是在我得到这个最终输出之前，我的解析代码经历了几次迭代。每次迭代之后，我都会看着输出，问自己一些问题，比如:
q)为什么有些剧集只有 30 行对白？(答:解析代码中有一个错误，需要更新)。
q)为什么有那么多场景只有 1 行对白？(答:解析代码中有一个错误，需要更新)。
问:为什么有少数几集的对话行数是*均水*的两倍？(答:部分笔录为两集)。
当输出看起来很奇怪时，大多数时候是代码有问题。
3.创建交互图
Networkx:自 2005 年以来创建 Python 网络图
现在我们有了数据，是时候开始制作交互图了。据我所见， Networkx 提供了用 python 定义图形的最直接的方法。
在下面的代码片段中，我们遍历每个字符，设置节点的属性以匹配我们希望该字符的节点如何显示。然后我们遍历交互表中的每个条目:
制作网络图
4.让它互动
Pyvis:用几行代码制作互动网络
没有理由不尝试 Pyvis(即使您和我一样，更熟悉 Networkx ),因为 Pyvis 可以直接从 Networkx graph 对象中读取。无论您向 Networkx 节点添加什么属性，都将被转移到这个 Pyvis 图中。值得一读的是 Pyvis 文档，看看所有可以设置的属性，尤其是关于物理引擎的。
一旦有了 Pyvis 对象，就可以直接生成一个在应用程序中使用的 HTML 文件(我已经使用过 Streamlit，下面会详细介绍):
Networkx -> Pyvis -> HTML
5.部署应用程序
Streamlit:将数据科学家转变为应用开发者
应用程序部署的*台即服务已经存在一段时间了(如 Heroku 或 Firebase )，但是 Streamlit 使得构建和部署一个简单的单页应用程序变得非常快。对于想要成为应用程序开发人员但无法理解 Flask 的数据科学家来说，这是一个完美的解决方案！
Streamlit 提供了几个小部件，如选择框、复选框和滑块，可用于让用户轻松定制选项:
Streamlit 小部件:选择框(左)，复选框和滑块(右)(作者图片)
这些小部件中的每一个都可以用一行代码添加(在下面的代码片段中，每个部件都被添加到侧边栏，因此使用了 st.sidebar ):
真的就这么简单！
最重要的是，Streamlit 将免费托管您的应用程序(前提是您乐于公开您的代码)，这就是所需的全部内容:
Streamlit 应用部署流程(图片由作者提供)
最终的应用程序看起来像这样(并且包含一个额外的牛郎星)时间序列):
最终的应用仪表板是什么样子的(图片由作者提供)
看一下源代码
星际迷航互动角色互动图应用的完整代码可以在这个库中找到(其中包括一些额外的 HMTL 版本的互动图，每个图节点都是那个角色的图像):
用 Python 可视化 Dash 中的生命体征
从表格到交互式图表
我清楚地记得我在 IC 部门担任 MD 期间，病人生命体征的图表。生命体征的图形表示有助于更好地了解幕后发生的事情。与其他工作环境中的生命体征快照相比，这些图表通常能更深入地了解患者的健康状况。
Dash 是一个 python 模块，正受到越来越多的关注。用<100 lines of code you can make remarkable beautiful and interactive charts. Dash creates a local server on your computer and the application you build can be accessed via your browser. By doing so you have a graphical user interface (GUI) that you can interact with within your browser. This saves you time in writing a whole user interface to control the functionality of a script or software package. Dash also has a steep learning curve, understanding how to get things done doesn’t take much time. Dash seems to be the perfect python package for data visualisations.
Let’s see if we can create a graphical user interface of the vital signs of a 模拟病人。实现这一目标的工作流程包括三个步骤。你得到数据，清理数据，然后展示金光闪闪的东西。由于 Dash，最后一个是最容易的，中间一个是最难的。完整代码在我的 Github 上。
我们使用 selenium 模块从虚拟患者那里获取数据，并创建了一个熊猫数据框架:
结果应该是这样的:
清洁
垃圾进，垃圾出。所以这里有几件重要的事情:
- 我们不能在图表中使用血压测量值中的不适用值(例如— / -)。
- 血压测量值中有文本(如 r.a. =右臂)。
- 存在与正常值的偏差(饱和度 20 和呼吸频率 95 在第 5 行(索引 4)中切换)。`
- 有错别字:372.0 应该是 37.2，问题是在患者档案中输入时使用了逗号而不是圆点。此外，第 6 行(索引 5)中的 7.4 可能代表 37.4。
我们用下面一行使用正则表达式的代码来解决(1)和(2)。关于正则表达式的更多信息，请参见科里·斯查费的教程:
对于血压列，唯一要做的是制作两个单独的列，一个用于舒张压，一个用于收缩压，这样我们就可以在图表中处理它们:
如果你打印出来，这个表看起来会像这样。您可以看到末尾有两个新列，仅显示数值:
第三点第四点，去除异常值，可以通过屏蔽和使用一些合理的值作为过滤器来实现。
你也可以考虑使用数学上更复杂的滤波器，例如 Savitzky-Golay 滤波器，来*滑数据，但在我们的例子中，这不是我们想要的:数据中的异常通常是警报信号，而不是噪音。
(英)可视化(= visualization)
我们用可视化软件包 plotly 创建一个图形对象:
为了在 Dash 中以图形显示我们的生命体征，我们需要安装一些软件包:
- pip 安装仪表板
- pip 安装仪表板-核心-组件
- pip 安装仪表板-html-组件
我们通过使用 dash 核心组件“graph”来绘制图形。为此，我们提供上一节中的 graph 对象作为图形的变量:
结果如下图所示。现在，让我们想象患者在 2 月 7 日接受了美托洛尔(降压药)，我们现在可以在图中看到，在 2 月 8 日收缩压有所下降，脉搏也从大约 90 次/分钟下降到 70 次/分钟，因此看起来干预起作用了:
在随叫随到的轮班期间，许多电话都集中在根据特定的温度是否隔离病人的问题上。如果您取消选择右侧的所有生命体征，只保留列表中的温度，您将更深入地了解温度随时间的变化。在 2 月 4 日，确定零下温度(= 37.5-38.4)变得很容易。这似乎可能是正常生理节律(生物可变性)或错误测量(测量可变性)的结果，因为在后续测量中，温度在正常范围内。像这样的可视化可以使围绕 covid 相关咨询的决策变得更容易。
这是一个快速简单的生命体征数据可视化。这当然只是一个例子。在像这样的东西在日常工作环境中可用之前，还有很多工作要做，但是我希望我已经向您展示了 Python 和 Dash 这两个兄弟是未来工作的两个很好的候选人…
Python 中的可视化和交互式仪表盘
我最喜欢的 Python Viz 工具——holo Viz
图片经许可来自 datashader.org
令我惊讶的是，许多数据科学家不知道 HoloViz 。HoloViz 是我最喜欢的 Python viz 生态系统，它由七个 Python 库组成——Panel、hvPlot、HoloViews、GeoViews、Datashader、Param 和 Colorcet。
我为什么爱 Holoviz？
HoloViz 允许用户用超级简单灵活的 Python 代码构建 Python 可视化和交互式仪表盘。它提供了在几个 API 后端中进行选择的灵活性，包括 bokeh、matplotlib 和 plotly，因此您可以根据自己的喜好选择不同的后端。另外，它是 100%开源的！
与其他 python viz 和 dashboarding 选项不同，HoloViz 非常认真地支持您可能想要使用 Python viz 或 app 工具的每一个合理的上下文:
- 一本 Jupyter 笔记本，
- 一个 Python 文件，
- 生成 pdf 或 SVG 或 png 或 gif 的批处理作业，
- 作为自动报告的一部分，
- 作为独立的服务器，
- 作为独立的。网站上的 html 文件。
每一种替代技术都很好地支持了其中的一些情况，但却忽略了其他情况。HoloViz 最大限度地减少了在所有这些环境之间切换的摩擦和成本，因为这是任何科学家或分析师的现实——只要你发布它，人们就希望改变！一旦你有了 Dash 应用程序；这就是你所拥有的一切，但是一旦你有了一个面板应用，你可以在第二天回到 Jupyter，从你离开的地方开始。
七个套餐是什么？
- 面板 构建交互式仪表盘和应用。就像 R 闪亮，但更强大。我无法表达我有多爱 Panel。
- 根据我的经验，hvPlot 比其他任何绘图库都容易，尤其是如果你喜欢绘制熊猫数据帧的话。只需一行代码，hvPlot 将为您提供一个包含所有您想要的内置功能的交互式绘图。
- HoloViews 是通过可视化进行数据探索和数据挖掘的伟大工具。
- GeoViews 绘制地理数据。
- Datashader 处理大数据可视化。使用 Numba (Python 编译器)和 Dask(分布式计算)，Datashader 可以非常快速地创建大型数据集的有意义的可视化。我绝对喜欢 Datashader，喜欢它所产生的美丽的情节。
- Param 创建声明性用户可配置对象。
- 颜色创建颜色图。
我的 HoloViz 工作流程是什么？
我通常从熊猫数据帧或 Dask 数据帧开始。对于地理数据，我使用 GeoViews。大多数时候，我只用 hvPlot。然后，如果我需要绘制大数据(数百万/数十亿个数据点)，我就用 Datashader 如果我需要不同的定制，我使用 Holoviews。然后，我可以在 Panel 中构建我的仪表板/应用程序。
HoloViz 工作流程(图片由作者提供)
一个非常简单的例子
正如您在下面看到的，通过几行代码，您可以获得一个交互式仪表板，它带有一个下拉菜单和一个用于绘图的滑块。
对于部署，我要么将仪表板直接输出为嵌入的 HTML 文件jupyter nbconvert YOUR_NOTEBOOK.ipynb --to html --no-input --no-prompt --stdout > output.html
或者我运行panel serve YOUR_NOTEBOOK.ipynb或panel serve YOUR_PYTHON_FILE.py将应用程序部署到服务器上的某个地方。
我希望 HoloViz 可以做得更好的事情有哪些？
我唯一希望 HoloViz 能做得更好的是图形设计。说实话，开箱即用的设计没有 Plotly 和 R 闪亮那么好看。然而，有一些模板和主题有助于设计，你可以随时创建自己的主题。awesome-panel.org 展示了许多令人惊叹的使用面板的仪表板设计。
我在哪里可以找到支持？
HoloViz 团队非常积极地回应他们的 Github 页面(https://github.com/holoviz)上的问题和功能请求。我在他们的 Github 上提交了许多问题和功能请求。他们还提供 T21 咨询服务。事实上，HoloViz 的大部分工作都是由一些关键的公司和机构资助的，他们已经与这些公司和机构建立了长期的合作关系。
推荐的学习资源
Pyviz.org很好地总结了所有的 Python 可视化工具和前景。
如果你有兴趣了解更多关于 HoloViz 的知识，这里有一些我喜欢的教程和讲座:
- https://holoviz.org/tutorial/index.html
- 【https://www.youtube.com/watch?v=v0QiTptWt3w
- https://www.youtube.com/watch?v=t5oFw9NUhlQ
希望你喜欢使用 HoloViz！
作者索菲亚·杨 2021 年 8 月 11 日
Python 中的可视化-可视化地理空间数据
了解如何使用 Learn 轻松显示地图和标记
可视化地理空间数据是您可以对数据做的最有趣的事情之一，尤其是当您的数据已经包含可以直接映射到地图上的位置的列时。对于 Python 开发人员来说，并不缺少可以完成这项工作的库。在本文中，我将向您展示一种在地图上快速显示地理空间数据的简单方法。具体来说，我们将使用叶子库。
什么是叶？
leave是 leaflet.js 库的 Python 包装器——一个用于绘制交互式地图的 JavaScript 库。使用 lyum，您现在可以直接在 Jupyter Notebook 中轻松地将地理空间可视化添加到您的 Python 项目中。
要安装 lyum，您可以在 Jupyter Notebook 中使用以下命令:
!pip install folium
显示地图
使用 leav 首先要做的是显示地图。所以让我们使用下面的代码片段:
import foliummymap = folium.Map(location = [1.366623, 103.821285],
width = 950,
height = 550,
zoom_start = 12,
tiles = 'openstreetmap')
mymap
当您运行上面的代码片段时，您将看到下面的交互式地图:
从上面可以看到，位置是新加坡的经纬度(1.366623，103.821285)，我还设置了地图的宽度和高度。zoom_start参数设置地图的初始缩放级别——数字越大，地图的缩放程度越大。下图显示了缩放级别为 15 的地图:
下图显示了缩放级别为 5 的地图:
地图显示后，您可以使用鼠标上的滚轮来放大或缩小地图。您也可以使用地图上的+或-按钮来执行相同的操作。
tiles参数指定要使用的 tileset 。要使用的默认 tileset 是openstreetmap。下一节将更详细地讨论 tilesets。
一个 tileset 是一个由栅格或矢量数据组成的集合，这些数据被分割成一个统一的方格网格。
在 Tilesets 之间切换
不同的图块集提供了不同的地图显示方式。您可以在 leav 中使用以下 tilesets:
- 雄蕊地形
- 雄蕊调色剂
- 雄蕊水色
- 卡通正电子
- 黑暗物质
您可以使用TileLayer类向地图添加不同的 tileset，而不是通过tiles参数来固定地图以使用特定的 tileset。以下粗体语句将五个切片集添加到当前地图中:
import folium
mymap = folium.Map(location = [1.366623, 103.821285],
width = 950,
height = 550,
zoom_start = 12,
tiles = 'openstreetmap')**folium.TileLayer('Stamen Terrain').add_to(mymap)
folium.TileLayer('Stamen Toner').add_to(mymap)
folium.TileLayer('Stamen Water Color').add_to(mymap)
folium.TileLayer('cartodbpositron').add_to(mymap)
folium.TileLayer('cartodbdark_matter').add_to(mymap)****folium.LayerControl().add_to(mymap)**mymap
LayerControl类在地图上显示图块图标:
作者图片
单击图块图标会显示可用于地图的各种图块集:
作者图片
以下部分显示了每个 tileset 的外观。
雄蕊地形
雄蕊地形地图显示了地形、山丘阴影和天然植物的颜色。
作者图片
雄蕊调色剂
雄蕊调色剂地图对于可视化河流蜿蜒和沿海地带等特征非常有用。
作者图片
雄蕊水色
雄蕊水彩贴图，顾名思义，使用水彩效果渲染贴图。
作者图片
如果你对《雄蕊水彩》的创作感兴趣，可以去 https://hi.stamen.com/watercolor-process-3dd5135861fe看看。
Stamen 是一个位于加州旧金山的数据可视化设计工作室。它的客户包括国家地理、脸书和达丨赖喇嘛。来源:https://en.wikipedia.org 维基雄蕊 _ 设计
卡通正电子
CartoDB 正地图是 CARTO 的底图(以前称为 CartoDB )。CARTO 是一个软件即服务云计算*台，提供 GIS、web 制图和空间数据科学工具。
作者图片
黑暗物质
在黑暗模式下， cartodbdark_matter 贴图相当于cartodbposient贴图。
作者图片
注释地图
地图之所以有用，是因为它能够让我们给地图添加注释。例如，我想显示代表新加坡各种捷运站位置的标记。因此，在这一节中，你将学习如何添加标记到叶子地图。
首先，你需要得到新加坡各个捷运站的位置。为此，我将使用来自 https://data.world/hxchua/train-stations-in-singapore 的数据。
该数据集对公众开放。但是，您需要作为成员加入 data.world 才能下载此数据集。
以下粗体语句将 CSV 文件作为 Pandas 数据帧加载:
import folium
mymap = folium.Map(location = [1.366623, 103.821285],
width = 950,
height = 550,
zoom_start = 12,
tiles = 'openstreetmap')folium.TileLayer('Stamen Terrain').add_to(mymap)
folium.TileLayer('Stamen Toner').add_to(mymap)
folium.TileLayer('Stamen Water Color').add_to(mymap)
folium.TileLayer('cartodbpositron').add_to(mymap)
folium.TileLayer('cartodbdark_matter').add_to(mymap)folium.LayerControl().add_to(mymap)**import pandas as pd
df = pd.read_csv('mrtsg.csv')
display(df)**mymap
数据帧看起来像这样:
我们将在本文中使用三个专栏:
- 工位名称(工位名称)
- 纬度
- 经度
显示标记
我们要添加到地图上的第一个标记是一个圆形标记。这可以通过使用CircleMarker类来完成。以下粗体语句基本上使用zip()函数组合了Latitude和Longitude列，然后遍历位置集合并添加代表每个 MRT 站的圆形标记:
import folium
mymap = folium.Map(location = [1.366623, 103.821285],
width = 950,
height = 550,
zoom_start = 12,
tiles = 'openstreetmap')folium.TileLayer('Stamen Terrain').add_to(mymap)
folium.TileLayer('Stamen Toner').add_to(mymap)
folium.TileLayer('Stamen Water Color').add_to(mymap)
folium.TileLayer('cartodbpositron').add_to(mymap)
folium.TileLayer('cartodbdark_matter').add_to(mymap)folium.LayerControl().add_to(mymap)import pandas as pd
df = pd.read_csv('mrtsg.csv')
display(df)**for lat, lng in zip(df['Latitude'], df['Longitude']):
station = folium.CircleMarker(
location=[lat, lng],
radius=8,
color='red',
fill=True,
fill_color='yellow',
fill_opacity=0.5)** **# add the circle marker to the map
station.add_to(mymap)**mymap
这是地图上的所有标记，每个标记代表一个捷运站:
您可以放大以定位每个电台:
用弹出窗口显示标记
有时候，显示一个当用户点击时显示更多信息的标记更有意义。在这种情况下，您只需要添加popup属性。让我用另一种标记类型Marker来展示一下。Marker类在地图上显示一个简单的股票传单标记。
以下粗体语句将Marker对象添加到贴图中:
for lat, lng, name in \
zip(df['Latitude'], df['Longitude'], df['STN_NAME']): **#** station = folium.CircleMarker(
**#** location=[lat, lng],
**#** radius=8,
**#** color='red',
**#** fill=True,
**#** fill_color='yellow',
**#** fill_opacity=0.5)
**#** station.add_to(mymap)
**station_name = folium.Marker(
location=[lat, lng],
popup = name,
)
station_name.add_to(mymap)**mymap
请注意，
popup参数也适用于CircleMarker类。
您可以在这里看到标记，而不是我们之前使用的圆形标记:
当您点击制造商时，您将看到一个弹出窗口，显示 MRT 站的名称:
摘要
我希望这篇文章能为您更详细地探索 leav 库提供素材。我几乎没有触及到叶子能做什么的皮毛。如果您在现实世界的项目中使用了 real，请务必通过评论窗口与我们的读者分享。玩得开心！
https://weimenglee.medium.com/membership
赫尔辛基的自行车共享系统运动:用交互式流程图进行聚合和可视化
基于赫尔辛基自行车出行 OD 矩阵汇总出行量的 KeplerGL 流程图
图片由作者提供。赫尔辛基自行车站之间的合计自行车出行地图
赫尔辛基是一个由巨大的自行车道网络提供的城市，这使得替代交通(即自行车、踏板车、步行)变得高效。在某些情况下，骑自行车去目的地比乘坐公共交通工具更舒服。就我个人而言，它发生在我身上是由于三个主要方面:1)我省钱，2)我节省时间，3)精神健康。如果你想了解更多关于赫尔辛基不同交通方式的可达性，你可以查看文章:在赫尔辛基使用 accessviz-mapper 工具绘制旅行时间(可达性)地图
芬兰城市自行车致力于为赫尔辛基市民提供服务，是全球最先进的自行车共享系统之一。该服务包括 1.500 辆自行车和大都市地区(赫尔辛基和埃斯波，万塔)周围的 457 个车站，它是在当地城市规划部门的支持下开发的。BSS 在 2017 年春天完全运行，当时所有的自行车和车站都开始可用。自那以后，城市自行车作为交通工具的选择大大增加，它被认为是一种可持续(绿色)的交通工具选择。用户数量已超过 34.100 人，每周骑行约 68.000 次，*均每天骑行 7 次，16.4 分钟，3.2 公里。这些统计数据是在上面提到的芬兰城市自行车网页上找到的。此外，还可以在 赫尔辛基 自行车共享地图中实时查看自行车的供应情况。
自行车共享系统(BSS)的局限性始于这样的讨论，即该系统可能只对特定的市民群体有利。得益于赫尔辛基市的开放数据,可以分析车站之间的运动数据集，以提供与社会群体和最常用/最少使用的自行车站相关的见解。来自赫尔辛基大学地理系的数字地理实验室 (DGL)一直在从不同的角度研究自行车共享系统(BSS)。2021 年 2 月，Elias Willberg可持续发展的专用研究员&活跃的城市流动性和可达性在DGL发表*关于自行车共享系统用户的出行数据揭示了什么？ ”展示了 BSS 行程数据对于了解 BSS 服务的用户特征和使用概况的重要性。BSS 的总体目标是为大多数公民创建一个包容和高效的结构。[1]***
自行车共享系统数据
BSS 发布的数据对应于服务的可用季节:从 4 月到 10 月。对于本练习，我们将使用 2019 年 7 月的月度数据集。出行数据[2]是开放访问以及城市周围 自行车站的位置由知识共享署名 4.0 许可。它被认为是一种出行数据，OD 矩阵是根据自行车站点的位置生成的。这意味着每次行程都是从起始自行车站点(起点)到终点自行车站点(终点)生成的。
本练习的目的是使用交互式流程图来可视化自行车共享系统出行数据的聚合移动，以了解赫尔辛基的自行车使用动态
这个可视化实践分为两个部分:1)数据生成，和 2)数据可视化。第一部分创建一个具有适当结构的数据集，可以在 KeplerGL 中使用，这个过程是在 Python 中完成的。第二部分使用 KeplerGL 实现流图的可视化。
1)数据生成
首先，我们读取存储库中名为geodata 的地理数据框架中的bike-stations.shp图层。我们会注意到总共有 457 个自行车站，它们看起来像这样:
******import pandas as pd
import geopandas as gpd
from shapely.geometry import Point
from keplergl import KeplerGl
from pyproj import CRSfp = r'data/bike-stations.shp'
geodata = gpd.read_file(fp)geodata.plot(markersize=1);******
图片由作者提供。赫尔辛基地区的自行车站
然后，我们阅读自行车出行的 OD 矩阵，它可以在名为data的数据框架中的存储库中找到。
******bikefp = r'data/2019-07.csv'
data = pd.read_csv(bikefp)******
图片由作者提供。自行车站点之间的移动(无汇总数据)
您可能会注意到，我们在一个数据集中有起点和终点，在另一个数据集中有位置(坐标)。因此，我们在这一步将数据合并到行程中，这样我们就可以获得 OD 矩阵和坐标。接下来是:
******# some details for origins
geodata['ID'] = geodata[‘ID’].astype(int)
geodata_origin = geodata.add_suffix(‘_origin’)# merging data with no aggregation
coor_data = data.merge(geodata_origin, left_on='Departure station id', right_on='ID_origin', how='outer')# some details for destinations
geodata_destin = geodata.add_suffix('_destin')# creating a data with no aggregation
coor_data = coor_data.merge(geodata_destin, left_on='Return station id', right_on='ID_destin', how='outer')# obtaining the needed columns
coor_data = coor_data[['Departure','Return', 'Departure station id', 'Departure station name' , 'Return station id',
'Return station name', 'x_origin', 'y_origin', 'x_destin', 'y_destin', 'geometry_origin']]coor_data.head()******
现在我们已经获得了一个包含个人出行的数据集。可视化很难理解，因为它包含大量信息。但是 KeplerGL 可以做出很好的东西，这里你可以看到粉红色是整个数据集的起点，蓝色是终点。总共 666.586 行(行程):
图片由作者提供。自行车站点之间的个性化出行。
现在，我们将汇总自行车站点之间的行程。我们要做的是为车站之间的旅行创建唯一的 id，并将它们算作搬运工。代码如下所示:
******agg_data = coor_data.copy()# aggregating data
# creating pairs
# if 457 station, then we make a lot of pairs.
origins = geodata['ID'].to_list()
destins = geodata['ID'].to_list()# creating pairs of trips
pairs_list=[]for origin in origins:
for destin in destins:
stat_pair = (int(origin), int(destin))
pairs_list.append(stat_pair)routes_list = list(range(len(pairs_list)))# dictionary with pairs and ID
routes_dict = dict(zip(pairs_list, routes_list))agg_data = agg_data.dropna()# adding a columns with station pairs
agg_data['pairs'] = [(int(orID), int(deID)) for orID, deID in zip(agg_data['Departure station id'].to_list(),
agg_data['Return station id'].to_list())]agg_data = agg_data.reset_index(drop=True)# add route id through dictionary
agg_data['route_id'] = Nonefor i in list(range(len(agg_data))):
pair_route = agg_data.at[i, 'pairs']
route_id = routes_dict[pair_route]
agg_data.at[i, 'route_id'] = route_idagg_data.head()******
我们得到一个包含route_id的新表，它看起来必须像这样:
图片由作者提供。具有路线 ID 的单个行程
下一步是通过将 ID 计数为移动者来进行聚合。在分组数据帧中是这样的:
******# aggregating movers
movers = gpd.GeoDataFrame(index = agg_data[‘route_id’].unique())for key, group in agg_data.groupby(‘route_id’):
movers.at[key, ‘route_id’] = key
movers.at[key, ‘movers’] = int(len(group))
movers.at[key, ‘origin_id’] = group[‘Departure station id’].unique()
movers.at[key, ‘origin_name’] = group[‘Departure station name’].unique()[0]
movers.at[key, ‘destin_id’] = group[‘Return station id’].unique()
movers.at[key, ‘destin_name’] = group[‘Return station name’].unique()[0]
movers.at[key, ‘x_origin’] = group[‘x_origin’].unique()[0]
movers.at[key, ‘y_origin’] = group[‘y_origin’].unique()[0]
movers.at[key, ‘x_destin’] = group[‘x_destin’].unique()[0]
movers.at[key, ‘y_destin’] = group[‘y_destin’].unique()[0]movers['geometry'] = [Point(originx, originy) for originx, originy in zip(movers['x_origin'].to_list(),
movers['y_origin'].to_list())]
movers.head()******
图片由作者提供。自行车站点间自行车运动汇总表
现在我们对桌子做一些安排，使它形象化。
******# defining CRS
movers.crs = CRS.from_epsg(4326)# columns
movers = movers[['route_id', 'movers', 'x_origin', 'y_origin', 'x_destin', 'y_destin', 'geometry' ]]******
如果要将各个运动可视化为上面的地图，可能需要在地理数据框架中定义几何。本练习的目标是关注汇总的信息，所以我在这里只解释这个过程。新的聚合数据集包含 37.403 行(聚合移动)。
2)数据可视化
在这里，我们为 KeplerGL 创建一个实例，配置可视化，并保存地图。您可以在其他文章中找到更多可视化示例，例如: 蓝鲸 GPS 跟踪中的停止检测—移动熊猫 0.6
******# Create KeplerGl instance
m = KeplerGl(height=600)# Add stop duration
m.add_data(movers, 'agg movements')******
然后你调用m，按照你的喜好正确配置地图。我是这样做的:
图片由作者提供。赫尔辛基自行车站的汇总自行车运动地图
然后你保存它:
******# Save map as html
m.save_to_html(file_name='index.html')******
结论
自行车共享数据可以通过唯一的路线 ID 进行聚合。通过计算重复路线 id 的数量来定义站之间的移动者。在可视化中，移动器的值可以用作颜色强度(黄色)和内联大小。所以理解自行车运动很容易。
这就是本练习的全部内容，以防您需要帮助或想要使用自己的数据。你可以在我的职业简介LinkedIn上联系我。********
参考文献
[1]威尔伯格，e .，萨洛宁，m .，托伊沃宁，T. (2021)。 “出行数据揭示了自行车共享系统用户的哪些信息？”。 土井:【https://doi.org/10.1016/j.jtrangeo.2021.102971】T21
[2] 城市自行车站点的起止点(OD)数据。数据集的维护者是 Helsingin seudun liikenne HSL，原作者是 City Bike Finland。该数据集已于 2021 年 7 月 18 日使用许可知识共享署名 4.0 从赫尔辛基地区信息共享服务下载。******
[3] 赫尔辛基地区交通局(HSL)的城市自行车站。 数据集的维护者是 Helsingin seudun liikenne HSL。该数据集已于 2021 年 7 月 18 日使用许可知识共享署名 4.0 从赫尔辛基地区信息共享服务下载。
用开放数据和开普勒可视化荷兰火车的拥挤
荷兰公共交通提供的公开数据使人们有可能看到一天中的拥挤情况。
列车占用的开普勒可视化
荷兰公共交通的最大发展之一是公共可用数据的持续增长。时间表已经推出好几年了，包括实时更新和几个月前增加的拥挤信息。所有这些开放数据使得开发者为大众和利基市场开发应用成为可能。在这篇文章中，我将向你展示如何在荷兰创造一个拥挤的火车美景。
本产品使用的数据来源为 OVInfo 时间表信息和 N DOV 拥挤信息。时间表有 GTFS 格式和专用格式(CSV)的拥挤度。可视化是用开普勒制作的，基于 GeoJSON 文件。
创建这个可视化的原因是我在阅读了由奥赞·卡拉和阿卜杜拉·库尔库撰写的关于可视化伊斯坦布尔公交和丹弗公交的文章后感受到的灵感。他们在数据工程和可视化方面做了一些出色的工作。
这篇文章的完整代码可以在 github 上找到。
我们将从 GTFS 规范中指定的时间表开始。也可以使用来自 GTFS 馈送的已实现时刻表信息，但是现在我们将使用计划时刻表，因为可用的拥挤信息是预测。
可视化拥挤时间表所需的数据结构如下所示:
这包含以下列:
- 时间戳— Unix 时间戳，记录旅程中的每一分钟(到达第一站和离开最后一站之间的时间)
- rit number-trip number，指定从 GTFS 出发的行程
- 序列—行程由几个部分组成。路段是行程中两个连续停靠站之间的部分，或者是在一个停靠站停留的时间。
- lat，lon —在时间时间戳时，列车完成行程 ritnumber 的位置
- 分类——列车在最后一站发车时的拥挤分类。是一个介于 1 和 5 之间的值。
- 乘客——列车乘客数量的粗略估计
有了这个数据集，我们能够创建一天中所有火车的动画，其中两个车站之间的拥挤程度可以用来给火车位置着色。
获取数据
第一步是导入所需的库(熊猫、 numpy 和 geojson 是最重要的非标准库)并设置一些参数。
然后我们从 NDOV 导入拥挤度信息。这些数据以压缩的 CSV 文件的形式提供。
如果文件还没有下载，我们下载压缩的 CSV 文件。使用 Panda 数据帧的 CSV 阅读器导入文件。在重命名一些列后，对列车座位数进行了估计。维基百科是寻找火车车厢座位容量的一个很好的来源。由于有不同的亚型，我们可以粗略估计每辆客车的*均座位数。NDOV 数据指定了车厢类型和车厢数量，因此我们可以估计列车中的座位总数。
导入 GTFS 数据需要更多的工作。首先，如果 GTFS 文件不存在，我们就下载它(它的大小超过 200MB，所以防止不必要的下载可以节省时间和带宽)。
然后，我们从下载的 zip 文件中一个接一个地导入 GTFS 文件，并在 operator 上过滤它们。GTFS 文件包含荷兰公共交通所有模式和运营商的时间表。在列车运行人员身上进行过滤大大减少了数据量。在本例中，我们仅使用来自 NS 的数据，该数据运营该国的大部分列车，但也可以通过更换机构来过滤所有列车运营商或一个地区或城市的运输提供商。
从代理处开始，一步一步地，所有东西都是为指定的操作者过滤的数据。首先是代理机构，然后是指定代理机构的路线、这些路线的行程以及这些行程的停留时间。请注意，GTFS 的车站是现实生活中的站台，停车区代表车站。到达和离开时间从 hh:mm 转换为自午夜起的分钟数，因此在路上使用更容易。
数据处理
真正重要的下一步是确定一天中所有行程的火车位置，从到达第一站到离开最后一站。行程的路线被指定为一个 GTFS 形状，该形状由一系列纬度坐标和从第一站开始的行驶距离组成。以下函数根据行驶距离在两个 LatLon 位置之间插入位置。在找到前一/最后一站( ps 和下一站( ns )后，我们可以使用简单的直线插值，因为不需要高精度并且距离相对较短。
参数 tripshape 是 GTFS 形状文件中指定旅行路线的点集，而距离是沿着 tripshape 行进的距离。找到指定距离的周围两个纬度位置后，根据距离在这两个纬度位置之间进行插值(见下图)。两个台阶之间的行进速度在这里是恒定的。
以下函数对一天中一次行程的每一分钟的位置进行插值:
在确定这个行程的停靠点之后( tripstops )，我们迭代所有这些停靠点并执行两个动作。首先，对从最后一个停车点出发到到达该停车点之间的所有分钟进行插值。然后创建列车位于停车位置的所有分钟。这些由停止位置的到达和离开时间决定。每组插值点被分配给一个序列供以后使用。
该函数返回一个数据帧，其中包含该行程每分钟的停靠位置，包括列车最后一次停靠位置的信息。然后，通过迭代我们可视化的当天的所有行程，可以直接获得包含所有行程信息的数据帧:
当我们通过将该数据帧与 NDOV 数据合并来添加所有拥挤信息时，我们就有了一天中所有列车位置的数据集以及拥挤信息:
乘客数量是根据座位数量和分类来估算的。这也是对乘客数量的一个非常粗略的估计，但是根据现有的数据，不可能得到更好的指示。geoJSON 文件需要一个 UNIX 时间戳，因此需要对其进行计算并添加高程列，因为 geoJSON 文件需要该列。
数据导出和可视化
创建的数据集包含简介中描述的所有信息(以及更多)。有了这个数据集，我们就可以创建 GeoJSON 文件供开普勒使用。为了显示点跟随路径的动画，开普勒需要以下 GeoJSON 结构:
线串的坐标包含 4 个元素【经度、纬度、海拔、时间戳】。特征的数字属性可用于给形状着色。由于拥挤仅在停止位置发生变化，因此会为两个站点之间的每条路径创建一个要素。这些路径由上一步中添加的序列号指定。
通过迭代所有行程和行程中的所有序列，构建要素的总位置，这些要素作为要素集合存储在 GEOJSON 文件中。
为了提高地图的可用性，还在网络布局中创建了 GeoJSON。只需将每条路线的一个行程添加到 GeoJSON 文件中，即可创建此布局。
最后，是开普勒进行可视化的时候了。导航到开普勒网站，并按下开始。在下一页拖放两个创建的文件，开普勒将准备适当的层。一个静态层是网络布局，另一个是火车动画。
通过调整线宽和颜色，可以很好地展示一天中的列车运行情况。我们在白天看到所有的火车，包括早高峰的爆发。列车根据预计乘客数量进行着色:
链接到 Github 上制作的视频，展示了 NS 火车旅行的一天。
最终想法
给出的代码没有针对速度进行优化。在普通机器上运行它需要 30 分钟，因此改进是受欢迎的，但对于本演示来说，这不是必需的。
开普勒是一个非常强大的可视化地理空间数据的工具，包括随时间推移的动画。添加越来越多的公开可用数据，通过令人惊叹的图表和动画打开了公共交通领域奇妙见解的大门。我希望这个例子能激发你对公共交通产生新的视觉化和洞察力。
免责声明:本文包含的观点和看法仅归作者所有。
基于 OTP 和 QGis 的旅行时间可视化
使用开源产品和开放数据创建荷兰公共交通出行时间的惊人可视化
作者图片(由 QGIS 创建)
荷兰公共交通的最大发展之一是公共可用数据的持续增长。结合 OpenStreetMap，这为多模式出行规划者提供了充足的信息。 OpenTripPlanner 是一个非常完整的 TripPlanner 实现的例子。本文将向您展示如何使用 OTP 和 QGis 来可视化从一个起点到荷兰所有地区的旅行时间。
时代在变，在家工作正成为新的标准，而且很可能会持续下去。2 或 3 天到办公室将成为标准，减少从家到工作的旅行天数。在过去的几十年里，通勤时间保持不变，对于大多数人来说，每天大约一个小时的单程旅行是最长的。未来几十年，我预计每周通勤时间将保持稳定，增加每天可接受的旅行时间，这将允许人们离开城市，进入内陆地区(“乌得勒支以外”)。
这将提出一个问题:在一定的旅行时间内可以到达该国的哪些地区？本文将向您展示从一个位于乌得勒支市中心的虚构工作地点到荷兰所有邮政编码的旅行时间。所有的旅行都使用公共交通工具。
该项目的数据来源是 GeoFabrik 的 OpenStreetMap 和 GTFS 格式的 OVapi 用于时间表。基于 GeoJSON 文件，用 OpenTripPlanner 2.0 进行行程时间计算，用 QGis 3 进行可视化。
这篇文章的完整代码可以在 G ithub 上找到。
计算行程时间
第一步是计算旅行时间。从我们的出发点到这个国家的一系列地点。如前所述，计算是用 OTP 执行的。OTP 需要一个 OpenStreetMap PBF 文件，其中包含您感兴趣区域的街道和步行时间，以及 GTFS 的公共交通时刻表。OTP jar 是从 Maven 下载的。阴影部分是为了简单起见，因为它包括了所有的依赖项。OSM PBF 从 GeoFabrik 获得，命名为‘荷兰-最新-osm . pbf’。GTFS 从 OVapi 下载，并以 zip ('gtfs-nl.zip ')格式下载。这三个文件都存储在同一个位置。
OTP 从命令行启动:
它将在当前目录中找到 OSM 和 GTFS 文件，并开始构建网络图。由于规模(我们正在创建一个整个国家的地图，而不是一个单一的城市)这将需要一些时间，但最终 OTP 服务器启动。需要 12G 的堆大小才能在内存中加载网络图。要测试服务器，请尝试 URLhttp://localhost:8080。
除了 web 接口，还有一个 REST API 用于使用 OTP 服务器。旧版本的 OTP 提供了一个 REST-API，用于从单个位置请求带有旅行时间的等时线地图，但不幸的是，这个 API 在最新版本中不再可用。
GTFS 停靠点规范是为行程时间计算定义一组目的地的一个很好的切入点。对于所有已定义的公共交通站点，我们采用 LatLon 坐标，并将其四舍五入到圆点后面的三个数字。1 度大约是。111 千米，所以 xx.xxx 给出 100 米的分辨率。在移除重复的位置之后，获得将被使用的集合。通过对 LatLon 位置进行舍入，可以防止重复计算，例如，在同一条道路的相对侧有两个公共汽车站。
此示例显示了输入集的创建，其中使用了乌得勒支市中心的一个位置，旅行将发生在 2021 年 3 月 17 日 16:00。相同的文件格式可用于计算在不同时间和日期具有不同起点的一组起点-目的地，但目前，旅行的起始位置和日期时间是恒定的。
OTP 通过其 REST API 支持计划者请求。请求具有以下形式:
http://localhost:8080/OTP/routers/2015/plan？<参数
除其他外，这些参数规定了日期、时间、起点、终点和使用的方式。通过为创建的文件中的每个起点/目的地线路调用该端点，创建了到该国公共交通可到达的所有位置的旅行时间的概览:
生成的数据集:
作者图片
可视化行程时间
将这些点添加到 QGis 中的地图可以合理地概述行驶时间。首先安装来自 https://qgis.org的 QGis 3，并按照本页的说明添加来自 https://www.openbasiskaart.nl/qgis.html的国家底图。我们为可视化添加了 ESP-28992 地图 als 底图。
通过添加“文本交付图层”并将 are script 的输出文件指定为源，在底图的顶部添加了包含行驶时间的图层。确保使用 EndLon、EndLat 作为位置列(否则仅绘制起点)。现在，它将所有计算出的旅行时间显示为地图上的点:
作者图片(由 QGIS 创建)
由于公共交通点是目的地位置的基础，点的分布很好地概括了公共交通密度。我们可以给点添加一种颜色，通过将它指定为“分级”来指示旅行时间:
QGIS 图层属性屏幕(来源:QGis)
深绿色圆点在 30 分钟内，浅绿色圆点在 60 分钟内，黄色圆点在 2 小时内，橙色圆点在 4 小时内，红色圆点超过 4 小时:
作者图片(由 QGIS 创建)
虽然这是一个好的开始，但地图并没有给出完整的、易于理解的旅行时间概览。这是一大堆点。为了改进地图，我们想制作一个类似等时线的总览图。我们需要将地图划分为覆盖整个国家的区域，并根据旅行时间对这些区域进行着色。这些区域的来源将是邮政编码地图。所有邮区的形状都可以从 ArcGIS Hub 中获得。到达一个邮政编码的行驶时间计算为到达上图中所有可用点的*均行驶时间:
GeoPandas 包对地理计算有很好的支持，包括在给定区域内选择点(gdf.within(…))。对于所有的邮政编码，添加一列行程时间(“travel time”)。
看上面的地图，你会怀疑不是所有的邮政编码都包括在内。执行上述代码后，超过 10%的邮政编码没有旅行时间。这些邮政编码被赋予到周围(接触)邮政编码的*均行程时间，加上所需时间的 15 分钟(用于从邮政编码到邮政编码的通勤)。如果这仍然不能产生时间，则使用完整组中的最大时间(以在以后保持带内着色)。
最后将 GeoPanda 数据帧保存为 GeoJSON 文件:
导出此数据框后，可将其作为图层添加到 QGis(例如，将 geojson 文件拖放到 QGis 的图层窗口):
作者图片(由 QGIS 创建)
邮政编码区域覆盖整个国家，对于我们的目的有足够的细节。如果需要更多细节，可以使用 PC6 数据集。
最后一步是给形状添加颜色:
QGIS 图层属性屏幕(来源:QGis)
颜色随着 15 分钟而增加，并逐渐从绿色变为红色，从而显示出全国范围内到达乌得勒支市中心的旅行时间概况:
作者图片(由 QGIS 创建)
如果给出了可接受的行驶时间，例如 90 分钟，颜色方案可以被调整为:
绿色:0 至 60 分钟
浅绿色:60 至 90 分钟
黄色:90 至 120 分钟
红色:120 分钟及更长时间
作者图片(由 QGIS 创建)
结束语
Open Trip Planner 2 是一款成熟的开源多模型旅行规划工具。通过它的 API，很容易集成到任何脚本或应用程序中。由于 GeoPandas 支持地理计算，因此创建地理编码数据集相对容易。QGis 是一个开源地理信息系统，可以从界面使用，如本例所示，但也配备了 Python 接口，使其更容易集成到脚本和应用程序中。创建视觉效果既简单又有帮助，因为图形概览使数据解释更容易。
免责声明:本文包含的观点和意见仅归作者所有。
可视化 BERT 序列嵌入:一种看不见的方式
实践教程
探索一种看不见的方式来可视化通过 BERT 的编码器层生成的序列嵌入。Python 笔记本包括完整的代码。
菲利贝托·桑蒂兰在 Unsplash 上拍摄的照片
关于
像 BERT [1]这样的基于转换器-编码器的语言模型已经席卷了 NLP 社区，研究和开发阶层都大量使用这些架构来解决他们的任务。它们通过显示文本分类、下一句预测等各种语言任务的最新成果而变得无处不在。
BERT- base 架构堆叠了 12 个编码器层，这使得它拥有高达 1 亿个可调参数！BERT- large 架构更上一层楼，拥有 24 个编码器层和大约 3.5 亿个参数！🤯
插图选自http://jalammar.github.io/illustrated-bert/
为什么这么多层？
在输入文本序列的前向传递中，来自这些编码器块中的每一个的输出可以被视为上下文化嵌入的序列。然后，将每个上下文化嵌入序列作为输入提供给下一层。
编码器层的这种重复应用实现了:
- 当输入通过它们时，提取输入的不同特征
- 每个连续的层建立在前一层突出显示的图案上
插图选自http://jalammar.github.io/illustrated-bert/
众所周知，在使用这些深度架构时，非常容易陷入过度拟合的陷阱。
查看每个编码器层如何为输入提供自己的嵌入，一个有趣的问题可能会出现在人们的脑海中:
“当我训练我的模型时，每个层的嵌入对看不见的数据进行概括的效率如何？”
简而言之，我们感兴趣的是看看 BERT 的每一层能够在多大程度上发现数据中的模式，这些模式保存着看不见的数据。
在本教程中，我们将讨论一种非常酷的方式来可视化每一层在为分类任务寻找模式时的效率。
把手放在某物或者某人身上💪
有了动机，让我们看看我们将要做什么。
目标
为多个时期训练一个 BERT 模型，并可视化每一层在这些时期分离数据的效果。我们将为序列分类任务训练 BERT(使用BertForSequenceClassification类)。通过对实现细节进行一些调整，同样的练习可以扩展到其他任务。比如语言建模(使用 BertForMaskedLM 类)。在您自己的数据集上重新训练语言模型，并检查每个集群的特征或嵌入的分布！
使用的资源/库
训练:
- 🤗变压器:BertForSequenceClassification模型，但是你也可以插入其他的变压器-编码器分类器架构，比如RobertaForSequenceClassification、DistilBertForSequenceClassification等等。
- PyTorch
可视化:
- 海生的
- Matplotlib
数据集:
HatEval [2]，一个将推文标记为仇恨/中性的数据集。
然而，你可以随意在配套的 Jupyter 笔记本中加载你自己的数据集。
同伴 Jupyter 笔记本
我把数据加载、模型训练和嵌入可视化的完整代码放在这个笔记本里。本教程中的代码仅用于解释目的。完整的工作代码请参考笔记本。
⚠️我们不会报道的
由于本文只关注层嵌入的可视化，我们将只遍历代码的相关部分。其余的代码超出了本教程的范围。我假设你事先知道🤗变压器 BERT 基本工作流程(数据准备、培训/评估循环等)。
我们开始吧
提取每个 BERT 编码器层的隐藏状态:
- 这🤗变形金刚为我们提供了一个BertForSequenceClassification模型，它由:
(1 xbertendedgings层)→ (12 x BertLayer 层)→ (1 x BertPooler 层在嵌入 for'【CLS】'token)→(tanh激活)→(脱落层)
注意分类头(从池层开始)是我们将可视化直接来自 12 x BertLayer 层的嵌入。 - sent _ id和掩码在 a 中准备🤗变压器 BERT 兼容格式
- 数据集的标签需要对可视化进行颜色编码
- 当将output _ hidden _ States = True参数提供给模型的前向传递时，这 1 个Bert embeddeds层和 12 个 BertLayer 层中的每一个都可以返回它们的输出(也称为 hidden_states )。因此，模型输出隐藏状态的维数是(13，数据点数，最大序列长度，嵌入维数)
- 由于我们只对来自 12 个 BertLayer 层的嵌入感兴趣，我们切掉不需要的bertlembedding层嵌入，留给我们维度的隐藏状态(12，数据点数，最大序列长度，嵌入维度)
接下来，我们定义一个函数，该函数可以在一个时期后为我们的数据集(例如- train/val/test)的分割绘制层的嵌入:
- dim _ reducer:scikit-learn 的 t-SNE 降维实现，将我们的嵌入从 BERT 默认的 768 维减少到 2 维。您也可以使用 PCA ，这取决于哪个更适合您的数据集。
- visualize _ layer wise _ embeddings:定义一个函数，该函数可以在每个时期后为我们的数据集(train/val/test)的分割绘制层的嵌入
- 在每个层上循环计算:
- layer_embeds :由层输出的嵌入，一个形状张量(number_of_data_points，max_sequence_length，embedding _ dimension)
-layer _ averaged _ hidden _ States:通过对序列的所有非屏蔽记号上的嵌入取*均值，为每个数据点创建单个嵌入，产生一个形状张量(number_of_data_points，embedding _ dimension)
- layer_embeds :由层输出的嵌入，一个形状张量(number_of_data_points，max_sequence_length，embedding _ dimension)
这些计算值最终使用 Seaborn 库绘制在新图上。
最后，将我们到目前为止在训练循环中看到的内容整合在一起:
在这里，我们在每个历元调用一次visualize _ layer wise _ embeddings函数，用于我们想要单独可视化的数据集的每个分割。
我选择可视化前 4 层和后 4 层的嵌入。
可视化🔬👨⚕️
我们已经准备好了我们的可视化！
我更进一步，把不同的图片拼接成 gif，让事情变得更方便！代码再次出现在笔记本中。
挺审美的吧？🤩
跨 BERT 模型层的训练数据的可视化
花点时间了解一下每一层的输出。试着从中得出一些有趣的推论！
我将给出一些例子:
-你能评论一下每一层在每个连续时期的表现吗？
-分类器的训练精度从时段 4 下降到时段 5！你能从上面的 gif 中验证这个事实吗？**
BERT 模型各层验证数据的可视化
最后，我们更感兴趣的是知道我们的嵌入是否有助于我们概括。我们可以通过上面的验证分割可视化来判断。
我想到的一些有趣的问题是:
-哪一层比其他层概括得更好？
-最后一层能在多大程度上区分职业？
-您认为训练和验证分割的嵌入之间的可分性有什么不同吗？
-对序列中所有非屏蔽标记的嵌入取*均值是否比仅对“【CLS】”标记进行嵌入产生更好的结果？(要回答这个问题，你可能需要稍微调整一下笔记本😉)
更进一步🙇♂️
不要仅仅停留在这里！
在所提供的笔记本中进行试验，尝试混合搭配不同层的输出嵌入，看看哪种组合有助于产生最佳的下游性能！
**回答:与时段 5 相比，时段 4 的第 12 层的嵌入更整齐地聚集在一起！这清楚地表明分类器在损失函数空间中击中然后超过了最小值。
参考
[1]: BERT:用于语言理解的深度双向变压器的预训练，Delvin 等人，2019
[2]: SemEval-2019 任务 Twitter 中针对移民和女性的仇恨言论的多语言检测，Basile 等人，2019
使用 PandasTutor 可视化您的熊猫数据转换
工具
在浏览器中可视化您的 Python 熊猫代码，并查看您的数据如何逐步转换
Pandas 是一个强大的 Python 库，可用于任何探索性数据分析。有时，您可能难以可视化数据转换。PandasTutor 来了，这是一个网络应用程序，可以让你看到你的 pandas 代码如何一步一步地转换数据。
如果您有复杂的转换，并且想要可视化您的步骤或者向其他人解释它，这可能会很方便。
PandasTutor 可以让你可视化不同的熊猫变换，从排序到按多列分组，甚至按列分组和执行多重聚合 [1]。
PandasTutor 创建者
熊猫导师是由加州大学圣地亚哥分校的 Sam Lau 和 Philip Guo 创建的。该工具主要用于教学目的，正如其创建者在此处所述。这解释了这个工具的一些局限性(我将在后面的文章中讨论这些局限性)。
Sean Kross 和 Philip Guo 为 R 用户开发了一个类似的工具，叫做 Tidy Data Tutor。
个案研究
在本文中，我们将研究一个示例，其中我们对一些值进行排序，然后按多个列进行分组，最后我们将对多个列执行不同的聚合！
资料组
让我们使用来自 Kaggle 数据集【2】的心力衰竭预测数据集。你可以在下面找到数据。数据在开放数据库(ODbl)许可下可用，允许用户自由共享、修改和使用该数据库，同时为其他人保持同样的自由。【3】
https://www.kaggle.com/fedesoriano/heart-failure-prediction
由于熊猫导师只对小数据起作用，我就取前 50 行红心数据)。
密码
下面是这篇文章中用于可视化的代码。您可能会注意到，CSV 数据在这里被编码，这是该工具的当前限制。
所以我们的转换只是最后几行(第 63–69 行)。
结果
步骤 1:对数据帧进行排序
sort_values()结果的可视化(步骤 1)(使用 PandasTutor 生成)
第二步:可视化熊猫分组操作
对步骤 1 中的结果进行排序并可视化后，我们可以可视化 groupby()操作。
groupby()结果的可视化(步骤 1 和 2)(使用 PandasTutor 生成)
步骤 3:计算多个列的不同聚合
在这里，我将计算“RestingBP”和“胆固醇”两列的*均值和标准差，并提供每个组的计数(这里我使用“性别”列来获得该信息。)
最终结果的可视化，即聚合(步骤 1-3)(使用 PandasTutor 生成)
有趣的分享功能
Pandas Tutor 还为您提供了一个可共享的 URL，其中甚至包括转换中使用的 CSV 数据。例如，你可以在这里或者通过下面的链接查看我的转换代码和结果！
优点:
- 逐步可视化
- 交互式绘图(您可以跟踪转换前后的数据行)
- 可共享的 URL
缺点(当前限制):
- 仅适用于小代码(代码应为 5000 字节)。由于数据也是编码的，而不是从文件中读取的，因此，您只能可视化小型数据集。
- 如前一步所述，您必须将数据和代码一起编码，因为不支持从外部资源(文件或链接)读取。
- 有限的熊猫方法支持。
- 你只能在最后一行想象熊猫的表情。您可能需要将多个步骤放在一起，或者单独运行可视化。
关于不支持的功能或其他常见问题的完整列表，您可以在这里 查看 。
结论
在本文中，我们检查了一个很好的工具，它可以一步一步地可视化 Pandas 数据转换，生成交互式图表来比较每次转换前后的数据。这对于那些想要巩固自己对熊猫转型的理解，或者想要与他人分享那些转型的人(熊猫导师甚至提供了一个可分享的网址)来说，非常有用。
感谢阅读🙏
加入我的邮件列表，接收类似的帖子。也可以在中、 LinkedIn 、 Twitter 关注我。
👉如果你喜欢阅读这样的故事(以及媒体上的其他故事)，并且也想支持我成为一名作家，可以考虑注册【https://medium.ealizadeh.com/membership】来获得所有故事的全部信息(免责声明:如果你使用我的链接注册，我将免费为你赚取一小笔佣金。)
https://medium.ealizadeh.com/membership
参考
https://www.kaggle.com/fedesoriano/heart-failure-prediction
[3]https://opendatacommons.org/licenses/odbl/1-0/
可视化新冠肺炎期间各国的超额死亡率
对我的孩子们来说，最令人兴奋的事情，尤其是在新冠肺炎时间，就是打开几乎每天都送到我们家门口的投递箱。尽管大多数送货都是食品杂货，但孩子们总是对这次他们将在盒子里找到什么宝贝充满热情和兴奋。
这也是我在发现一个新的新冠肺炎数据集时的感受。它采用了一种有趣但简单的方法:该数据集只是统计了每个国家的所有死亡人数，并与前几年进行比较，而不是关注死亡原因和对每个记录的潜在偏差进行无休止的辩论。主要假设是，新冠肺炎相关的死亡率效应只是今年独特的死亡病例与前几年之间的差异。
这个数据集的作者查阅了世界各地可靠的死亡率记录，并让数据集可供我们所有人探索。
这篇博客文章将重点复制存档论文中的一些分析，使用简单的可视化工具，没有花哨的数学符号，或其他流行病学标度/转换/相对比率等。
我们先来看看今年的死亡病例和往年有什么不同。虽然数据集包括全球 79 个国家的数据，但我将只关注其中几个国家，每个国家都有独特的模式。
图一。来源:作者
查看该图可以看到 2020 年(蓝线)与前几年相比的独特分布:2015–2018(灰线)，以及 2019 ( 红线)。Lichtenstein 是一个特殊的案例研究，前几年每周的案例相对很少，很难从视觉上发现多年来的任何差异。
接下来，让我们决定什么是最好的(或至少足够好的)参考非 covid 年份。一种方法是取所有/最*/前几年子集的*均值。为了简单起见，也为了避免多年来无关的年度趋势影响，让我们只使用 2019 年作为参考年。
图二。来源:作者
接下来，让我们用带状图来可视化 2020 年至 2019 年间的超额死亡率案例。当 2020 年的病例数高于 2019 年时，两条线之间的红色区域是每周增加的病例数。但是，如果 2019 年的病例数多于 2020 年，则会用蓝色区域表示。
图 3。来源:作者
红色和蓝色之间的每周波动表明没有恒定的趋势，因此， covid-year 的影响较小。请注意，每个图都有自己的 Y 轴刻度。查看论文，了解评估这种影响的更多量化方法。**
另一个让上述形象化的尝试是用烛台情节:
图 4。来源:作者
这里是另一个烛台图，带有一个嵌入了 HTML 滑动条的 Java 脚本，用于 x 轴周，通过 plotly 包允许更多用户友好的交互。(尽管我不知道如何用区域命名轨迹，以及如何将 HTML 文件作为动态图像/动画加载到 Medium 中)。
图 5。来源:作者
****后记:
希望您受到了启发，可以自己处理这些数据，并尝试一下。
在这个博客上，我学到了一些新的实践，比如在每个面(国家)上添加旗帜图标作为网格对象，绑定/分面情节支线剧情，以及其他技巧。
我也希望在世界地图上把这些地方作为贫民窟添加进去，但是可能在另一个帖子上。
我用过的 R 包有:ggplot2，patchwork，ggflags，plotly，tidyverse，
lubridate，magrittr，gghighlight，ggtext，tidyquant，ISOweek。
将很高兴应要求分享 R 代码。
我差点忘了交叉引用我之前关于新冠肺炎可视化的博文:
查看我的其他博客文章和我的 GitHub 页面获得更多有趣的阅读。领英。
用 PyGraphistry 可视化 GitHub 社交网络
实践教程
分析机器学习开发者和 Web 开发者之间的联系
动机
你有没有想过不同角色的 GitHub 开发者是如何连接的？例如，如果一个人是机器学习开发人员，他/她关注的人中有百分之多少是 web 开发人员？如果一个人是 web 开发人员，他/她关注的人中有百分之多少是机器学习开发人员？
作者图片
在本文中，我们将使用由 GitHub 开发人员的大型社交网络组成的数据来回答这个问题。我们还将使用 PyGraphistry 来可视化不同类型的开发人员是如何相互联系的。
GIF by Author——在这里与剧情互动。
加载数据集
我们将使用 Kaggle 中的 GitHub 社交网络来分析 GitHub 开发者的大型社交网络。节点是至少有 10 个存储库的开发人员。如果一个人是机器学习开发者，ml_target=1，否则ml_target=0。
作者图片
边缘是这些开发者之间的相互追随关系。
作者图片
分析每种开发人员类型的联系
ML 开发人员和 Web 开发人员的百分比
让我们从找出网络中 web 开发者(𝑃(Web 开发者)和机器学习开发者(𝑃(ML 开发者)的百分比开始。
这个网络中 74%的开发者是 web 开发者。
混合连接的百分比
网络中混合连接(一个 web 开发者和一个机器学习开发者之间的连接)的百分比是多少？
作者图片
从连接edges工作台和nodes工作台开始:
作者图片
接下来，计算网络中混合连接的百分比— 𝑃(ML 开发人员与 web 开发人员连接)。
0.1546558340224842
相同连接的百分比几乎比混合连接的百分比高 5.5 倍。
网络开发者的联系
另一个需要分析的有趣问题是:如果一个人是 web 开发人员，他/她的人脉中有百分之几是 web 开发人员，他/她的人脉中有百分之几是机器学习开发人员？
作者图片
让我们用贝叶斯定理来回答这个问题。
根据贝叶斯定理，我们知道:
从前面的计算中我们已经知道𝑃(ML 开发者与网络开发者)和𝑃(Web 开发者)连接。让我们用这些百分比来找出 ML 开发者|Web 开发者的𝑃(Connect):
0.20852347708049263
现在，找到𝑃(Connect 对一个网页开发者来说是很容易的:
这意味着如果一个人是 web 开发人员:
- 他的人脉是网络开发者的比例是 71.95%
- 他的关系是 ML 开发者的百分比是 28.05%。
作者图片
这些百分比与网络中 ML 开发者和 web 开发者的百分比非常相似(0.258 和 0.741)。
ML 开发人员的联系
同样，我们可以找到𝑃(Connect 对一个 Web 开发者|ML 开发者):
0.5986779897985065
和𝑃(Connect 对一个 ML 开发者|ML 开发者):
0.4103
现在，我们知道如果一个人是 ML 开发者:
- 他/她的联系人是 web 开发人员的比例为 59.87%
- 他/她的关系是 ML 开发者的百分比是 41.03%。
作者图片
由于 ML 开发者在网络中的百分比只有 25.8%，所以看到一个 ML 开发者的人脉中有 41.03%是 ML 开发者就很惊讶了。这意味着 ML 开发者更有可能跟随其他人而不是 web 开发者。
使用 PyGraphistry 可视化网络
让我们通过使用 PyGraphistry 可视化 GitHub 网络来尝试确认上一节的结论。
什么是 PyGraphistry？
PyGraphistry 是一个可视化大型图形的 Python 库。由于我们将在本文中使用大型图表，PyGraphistry 是一个完美的工具。
要安装 PyGraphistry，请键入:
pip install pygraphistry
开始
要使用 PyGraphistry，首先在graphistry.com创建一个免费账户，然后注册新账户:
接下来，指定图形的节点和边。我们还使用encode_point_icon来显示不同角色的不同图标:
绘制图表:
现在你应该在你的笔记本上看到类似下面的东西！
GIF by Author —在这里与剧情互动。
这里可以和上面的剧情互动。节点越大，它连接的节点就越多。
将鼠标悬停在特定节点上会显示它所连接的节点。
GIF by Author —在这里与剧情互动。
单击一个节点将为您提供关于该节点的信息。
作者图片
编码点颜色
目前的情节很美，但信息量不大。因为我们想知道不同角色的开发人员是如何相互联系的，所以让我们根据每个开发人员的角色给节点涂上颜色。
机器学习开发者是银色的，web 开发者是栗色的。
作者图片—与剧情互动此处
你可以在这里和上面的剧情互动。如果颜色没有按预期显示，您可能需要刷新。
我们可以看到相同角色的开发人员倾向于聚集在一起。
确定影响者
谁是获得最多连接节点数的开发人员？我们可以通过点击屏幕顶部的数据表图标找到答案。
表格打开后，按度数(一个节点连接了多少个节点)对表格进行排序，然后单击您感兴趣的点，该点将在下图中突出显示:
GIF by Author —在这里与情节互动
从表中我们可以看出，大部分热门的开发者都是 web 开发者。这并不奇怪，因为 web 开发人员比 ML 开发人员多得多。
检测社区
社区是彼此紧密连接的节点的子集，并且松散地连接到同一图中的其他社区中的节点。
让我们尝试使用 Louvain 方法来检测图中的社区。由于我们正在处理一个大图，我们将使用 cuGraph 来加速代码。
作者图片
在上表中，partition是节点(或vertex)所属的社区。
让我们看看有多少个社区:
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21], dtype=int32)
总共有 22 个社区。让我们想象一下这些社区是什么样子的。从连接nodes表和parts表开始，获取节点及其分区的名称。
作者图片
然后我们用 faker 自动为不同的分区创建不同的颜色。
您应该会看到类似下面的内容！
Gif by Author —在这里与情节互动
你可以在这里与上图互动。我们可以看到，同一个社区中的节点(具有相同的颜色)倾向于聚集在一起。
每种类型开发人员的社区
大多数 web 开发人员属于什么社区？我们可以通过只选择 web 开发人员的节点来解决这个问题。要过滤节点，请单击屏幕顶部的过滤器按钮。
作者图片
您应该只看到 web 开发人员的节点:
作者图片
似乎 web 开发人员属于不同的社区。让我们看看 ML 开发者属于哪些社区:
作者图片
该图仅包含 ML 开发人员:
作者图片
有意思！大部分 ML 开发者属于粉色社区。这意味着，与 web 开发人员不同，ML 开发人员倾向于在同一个社区中。换句话说，ML 开发者之间的联系更加紧密。
每个社区中 ML 开发者的百分比
每个社区中 ML 开发者的比例是多少？让我们用一个分组条形图来说明这一点:
看起来在大多数社区中有一小部分 ML 开发者。这意味着大多数社区都相当多样化。
结论
恭喜你！你刚刚学习了如何使用贝叶斯统计和 PyGraphistry 分析社交网络。希望这篇文章能给你分析身边网络所需的动力和知识。你可能会对你从图表中发现的东西感到惊讶。
在这个 GitHub repo 中随意发挥和分叉本文的源代码:
我喜欢写一些基本的数据科学概念，并尝试不同的数据科学工具。你可以在 LinkedIn 和 Twitter 上与我联系。
如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:
https://pub.towardsai.net/visualize-gender-specific-tweets-with-scattertext-5167e4600025 https://khuyentran1476.medium.com/visualize-similarities-between-companies-with-graph-database-212af872fbf6
引用
FEMI·K·j .(2021 年 7 月 25 日)。GitHub 社交网络，
第 1 版。从https://www.kaggle.com/femikj/github-social-network取回 2021–11–22。公共许可证。
使用 Plotly 和 Datapane 可视化分层数据
实践教程
使用交互式图表探索嵌套很深的通货膨胀数据集
按类别显示数据很容易——只要用一个不起眼的条形图或饼图就行了(尽管 T2 有一个关于哪个最好的 100 年历史的争论)。
但是如果每个类别都有子类别呢？而那些子类别又有子子类别？这是许多领域中常见的数据模式，包括文件系统、生物学和经济学。
照片由 niko photos 在 Unsplash 上拍摄
在本文中，我们将介绍几种交互式显示嵌套数据的方法，并讨论每种方法的优缺点。
数据:美国消费者价格指数(CPI)权重
想知道通货膨胀是如何计算的吗？从本质上讲，政府将每月收集数千种普通商品的价格数据，根据重要性进行加权，并将它们组合成一个“篮子”，广泛代表普通家庭的支出。然后，他们跟踪这些项目的价格变化，以计算出经济的整体通胀水*。
这个篮子可以用来粗略衡量每个人是如何花钱的。这是一个有趣的数据集，因为数据自然是分层的:从最高层的类别如“食品”一直到单个产品如“多力多滋”。
[警告:通货膨胀方法论是一门深奥的学问——要小心，否则你可能会在晦涩的政府统计网站上浪费掉几天的时间！]
为了进行这种探索，我们将根据美国劳工统计局的公开数据来研究美国消费者价格指数的不同类别和权重。数据来自 Excel 文件，具有以下特征:
该数据包含 295 个不同的类别，分布在 8 个不同的“缩进级别”，从 1—“食品和饮料”( 15.16%重量)，到 8 —“生牛肉末”(0.17%重量)。请注意，它并没有深入到单个产品。这些项目按层次排列，因此每个项目的权重将等于其子项权重的总和。
我们首先将数据加载到 Pandas 中，并做一些预处理。特别是，我们需要使用行索引和缩进级别来获取每一行的“父级”,因为许多图形库都需要这些信息。我们最终得到以下数据框架:
让我们开始一些可视化！我们将使用 Plotly 创建交互式图表，并使用 Datapane 使我们的图表具有交互性，因此用户可以自己探索数据。当您有复杂的数据，而这些数据又不容易用静态图表示时，这一点尤其重要。
1。旭日图
我们将从 Sunburst 图表开始:一种高级类型的饼图，其中不同级别的数据表示为同心圆。
使用 Plotly 制作旭日图非常简单:
它在我的浏览器上交互显示，但当我试图将其复制到 Medium 时，它显示为静态图。不过不用担心，我们可以使用 Datapane 将图表上传到 Datapane.com，然后共享或嵌入交互式报告:
运行这段代码后，Datapane 生成一个报告，我们可以通过 URL 查看我们的绘图:https://data pane . com/u/johnmicahreid/reports/visualizing-deep-nested-data/
此时，我们可以共享报告，或者直接嵌入报告，如下所示:
回到分析，这个图表看起来很有趣，但很混乱，很难阅读深度嵌套的小权重类别。将它限制在两个级别看起来更好:
通过简化图表，你遗漏了信息，但这可能是一件好事。有效的数据可视化是向你的受众传达一个清晰的信息，你的图表越明显+简单，他们就越有可能理解。
对于这张图表，我希望有人理解的故事如下:“哇，看起来住房成本是通货膨胀的最大因素！”
2.树形图
树状图类似于旭日图，只是它们以矩形形式表示数据。它们比旭日图有优势，因为图上每个矩形的面积与你要展示的数量成正比。
构建树状图使用的 Plotly 语法与 sunburst 完全相同:
这要清楚得多，但是区域并不完全准确，因为一些空间被边界框和文本占据了。此外，一些嵌套很深的层次被切断，难以阅读。如果我们把情节限制在前两层，我们会得到一个更整洁的画面:
3.桑基图
另一种选择是桑基图，它最初被发明用来显示能量在系统中的传递。如果您想要显示经过几个不同阶段的数据，请使用它—唯一的建议是进入系统的“流量”应该等于流出系统的“流量”。
Plotly 中的代码要复杂得多，因为我们需要将数据转换成不同的格式:
与前两种情况相比，我们在这里看到了一个类似的信息密度问题——有太多的信息需要一目了然，较小的类别被极度压缩。Sankey 图和 sunburst/treemap 之间的一个有趣的区别是在图的最右端显示所有没有子节点的节点的方式，即使它们有不同的缩进级别。
让我们再来看看前两个级别:
这更清楚，但我个人建议不要使用桑基图，除非你有真正令人信服的理由这样做，因为它们相当不直观，数据通常可以用更好的方式表示。
4.图表
从第一原理思考问题，我们的数据本质上是一个树形结构，树是一种图形。所以让我们试着把数据形象化为图表。
这里的代码要复杂得多，因为我们需要将数据帧转换成一系列的边和节点。我们将使用 networkx 来转换和存储数据，并 Plotly 将其可视化。不再有高级 API，所以我们将手动绘制每个节点和边。
正如你从这个 viz 中看到的，图很好地表现了不同量之间的关系，并且可以轻松地适应许多不同的节点。唯一的缺点是，您需要将鼠标悬停在每个节点上才能读取该点的值。我们还可以尝试各种技巧，如使节点的大小与权重成比例，以及不同的节点定位算法，但结果开始看起来很奇怪。
5.其他选择
冰柱图是另一种可视化嵌套数据的好方法，基本上是一组堆叠的垂直条形图。我们可以在 D3.js 可视化库中看到一个很好的例子:
Mike Bostock 的 D3.js 文档中的 Icicle embed
火焰图是一个类似的概念，但是旋转了。它们是由 Brandon Gregg 发明的，作为一种分析软件性能的方法。这里 X 轴是时间，Y 轴代表函数调用深度，每个矩形代表一个不同的函数调用。
来自维基共享资源的火焰图示例
这两种方法似乎都比以前的方法在显示多层次嵌套方面做得更好，但不幸的是，我还没有找到任何优秀的 Python 库来制作它们！如果你有任何想法，请在评论中告诉我。
最后
- 嵌套数据很难很好地可视化，如果可能的话，您应该尝试一次只显示两个级别。
- 除非您的数据非常符合目的和/或您的点数相对较少，否则不要使用桑基图。
- 决定是显示每个类别的比例更重要，还是显示类别之间的关系更重要。如果是后者，那么图表可能是一个不错的选择。
- 如果你有 JS 技能，冰柱图是一个很好的选择
如果你有兴趣自己试验一下，这里有一些数据:
使用 3D 360 度动画散点图可视化高维网络数据
作者图片
介绍
在网络分析的环境中，我们经常会遇到极其复杂的数据，这些数据是不可读或无法解释的。虽然一些算法框架(例如 node2vec)可以将网络数据合并到统计机器学习中，但产生的数据仍然是高维的，并且在可视化方面难以管理。在这篇博客中，我将与你分享我用来降低复杂性和解决这个问题的方法之一。
数据
出于演示目的，使用了来自斯坦福大学 SNAP 的数据集“电子邮件-欧盟-核心网络”。你可以在这里找到原始数据集:https://snap.stanford.edu/data/email-Eu-core.html。我认为，如果我用真实世界的复杂数据集向您展示代码，会更有意义。因此，我使用这个数据集，而不是模拟数据。在 SNAP 上可用的网络数据中，这个网络可能具有最简单的结构。
图的阶(节点数)是 1005，图的大小(边数)是 25571。该数据集还带有每个顶点/节点的地面实况标签。当我们生成可视化时，我们将使用地面真实标签来注释顶点。解决这个问题的方法之一(如果没有标签)是使用 k-means 聚类来获得标签。
注意:我在 Google Colab 中完成了这个代码演示。如果您在本地 ide 中工作，可能需要以不同的方式配置路径。但是作品的逻辑应该是一样的。
密码
第一步:加载所有必需的包
生成图嵌入所需的核心包是 networkx 和 node2vec。应用详情可以参考本文:利用 NetworkX、Gephi、Node2Vec 分析疾病共现。其余的包用于为我们的网络数据生成 3D-360 度散点图。
第二步:读取数据
因为这是一个未加权的图，所以我将图中所有边的权重设置为 1。我将标签的顶点列的数据类型转换为“string ”,因为稍后将对其进行索引以进行注释。
第三步:将数据导入图表并绘图
如果我们不执行降维，并找到一种方法使图形更稀疏，那么您将得到图 1 中的图形，它根本不可读。此外，node2vec 算法需要一个 networkx 图作为输入。
图一。原始图表
第四步:使用 node2vec 获取嵌入
您可以注意到，在代码中，我手动计算了 vector_size (dimensions)的起点和图的顺序。这种做法受到了谷歌机器学习速成班的启发。而经验法则是， 维数的大小等于可能值的四次方根(维数=可能值的个数 0.25)** 。
第五步:用 3D 360 度动画散点图可视化
执行three dplot(model)命令后，我们得到的就是图 2。来自同一个部门的人，比如第 21 部门(黄色点)和第 14 部门(绿色点)，更喜欢呆在一起(更频繁地联系)。部门 4、5 和 7-分别是紫色、深蓝和淡蓝色点-也可以被识别为彼此保持接*的部门。
图二。三维 360 度散点图
对于高分辨率的图形，请访问此链接获取原始 gif。
要复制结果，请访问笔记本的链接。
结论
在这篇博客中，我们使用了【node 2 vec】，networkx，tsne(PCA)，seaborn，matlibplot等。制作 3D 360 度动画散点图，以可视化高维复杂的网络数据。
欢迎随时联系我上LinkedIn。
相关阅读
使用 NetworkX、Gephi 和 Node2Vec 分析疾病共现
如何像专业人士一样可视化机器学习结果
只用一行代码
动机
评估机器学习模型是机器学习工作流程中的一个重要步骤。在本文中，我们研究了如何使用 Scikit-plot 轻松可视化各种常见的机器学习指标。虽然它的名字可能表明它只与 Scikit-learn 模型兼容，但 Scikit-plot 可用于任何机器学习框架。在幕后，Scikit-plot 使用 matplotlib 作为它的图形库。
Scikit-plot 最好的部分是它只需要一行代码来可视化每个指标。
设置
安装软件包
pip install scikit-plot==0.3.7
导入必要的包
import pandas as pd
import numpy as np
from sklearn import datasets
from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
from sklearn.model_selection import cross_val_predict, train_test_splitimport scikitplot as skplt
为了演示 Scikit-plot，我们将使用乳腺癌数据集训练一个简单的随机森林和梯度增强分类器。
X,y = datasets.load_breast_cancer(return_X_y = True)
X_train, X_test, y_train, y_test = train_test_split(X,y, test_size = 0.3, stratify = y)gbc = GradientBoostingClassifier()
gbc_model = gbc.fit(X_train, y_train)
y_gbc_proba = gbc_model.predict_proba(X_test)
y_gbc_pred = np.where(y_gbc_proba[:,1] > 0.5, 1, 0)rfc = RandomForestClassifier()
rfc_model = rfc.fit(X_train, y_train)
y_rfc_proba = rfc_model.predict_proba(X_test)
y_rfc_pred = np.where(y_rfc_proba[:,1] > 0.5, 1, 0)
让我们看看如何使用 Scikit-plot 来可视化各种指标。
混淆矩阵
混淆矩阵将基础事实与预测标签进行比较，并将结果分为真阳性、真阴性、假阳性和假阴性。为了绘制混淆矩阵，我们简单地调用plot_confusion_matrix方法。
skplt.metrics.plot_confusion_matrix(y_test, y_gbc_pred, normalize=False, title = 'Confusion Matrix for GBC')
作者图片
要显示 0 到 1 之间的标准化值，只需将normalize参数设置为True
skplt.metrics.plot_confusion_matrix(y_test, y_gbc_pred, normalize=True, title = 'Confusion Matrix for GBC')
作者图片
受试者工作特性曲线
ROC 曲线显示了分类器在所有分类阈值下相对于随机基线分类器的性能(真阳性率，也称为召回率和假阳性率)。
skplt.metrics.plot_roc(y_test, y_gbc_proba, title = 'ROC Plot for GBC')
默认情况下，ROC 图带有宏观和微观*均值。我们可以通过将plot_micro或plot_macro参数设置为False来隐藏这些情节线。plot_roc方法显示所有类别的所有 roc 曲线，并且图表在多类别绘图中可能会变得混乱，因此我们可以通过传递classes_to_plot参数来选择绘制特定类别的 roc 曲线。
作者图片
精确召回曲线(PR 曲线)
精确度和召回率曲线显示所有分类阈值的精确度和召回率值。它总结了精确度和召回率之间的权衡。
skplt.metrics.plot_precision_recall(y_test, y_gbc_proba, title = 'PR Curve for GBC')
默认情况下，精确召回曲线带有宏观和微观*均值。我们可以通过将plot_micro或plot_macro参数设置为False来隐藏这些情节线。plot_precision_recall显示所有类别的 PR 曲线，在多类别图中图表可能会变得混乱，因此我们可以通过传递classes_to_plot参数来选择绘制特定类别的 PR 曲线。
作者图片
校准图
校准图也称为概率校准曲线，是一种检查预测值是否可以直接解释为置信水*的诊断方法。例如，校准良好的二进制分类器应该对样本进行分类，使得对于概率约为 0.8 的样本，大约 80%的样本来自正类。该函数仅适用于二元分类任务。
probas_list = [y_gbc_proba, y_rfc_proba]
clf_names = ['GBC', 'RF']
skplt.metrics.plot_calibration_curve(y_test, probas_list = probas_list, clf_names = clf_names)
作者图片
累积增益曲线
累积增益曲线显示模型的性能，并与随机基线分类器进行比较。它显示了在考虑概率最高的一部分人口时实现目标的百分比。该功能仅适用于二元分类。
skplt.metrics.plot_cumulative_gain(y_test, y_gbc_proba, title = 'Cumulative Gains Chart for GBC')
作者图片
升力曲线
提升曲线显示了当考虑具有最高概率的人群的一部分时，与随机基线分类器相比，每个类别的响应率。
skplt.metrics.plot_lift_curve(y_test, y_gbc_proba, title = 'Lift Curve for GBC')
作者图片
调整图表属性
Scikit-plot 允许用户分别使用figsize、title_fontsize和text_fontsize参数调整基本属性，如图形大小、标题字体大小和文本字体大小。
skplt.metrics.plot_lift_curve(y_test, y_gbc_proba, title = 'Lift Curve for GBC', figsize = (10,10), title_fontsize = 20, text_fontsize = 20)
此外，这些方法还通过ax参数接受matplotlib.axes.Axes对象。这很有用，因为我们可以定义要绘制的轴。例如，我们希望在同一个子图上并排绘制累积收益图和提升曲线。我们可以首先创建一个 1x2 子图网格，并使用ax参数在子图的不同网格中绘制每个图表。
fig, ax = plt.subplots(1,2)
skplt.metrics.plot_cumulative_gain(y_test, y_gbc_proba, ax = ax[0], title = 'Cumulative Gains Chart for GBC')
skplt.metrics.plot_lift_curve(y_test, y_gbc_proba, ax = ax[1], title = 'Lift Curve for GBC')
plt.show()
作者图片
这些方法的输出是matplotlib.axes._subplots.AxesSubplot对象，我们可以使用 matplotlib 方法进一步操作这些对象。例如，我们可以执行以下操作来调整垂直轴的范围。
import matplotlib.pyplot as plt
ax = skplt.metrics.plot_lift_curve(y_test, y_gbc_proba, title = 'Lift Curve for GBC')
ax.set_ylim(0,3)
结论
我们研究了如何使用一行代码绘制各种常见的机器学习指标，以及如何使用 matplotlib 调整图表属性以满足我们的需求。Scikit-plot 中还有很多我们在本文中没有涉及到的功能，比如为聚类问题绘制肘图和剪影图。查看 Scikit-plot 文档了解更多详情。
借助 Power BI 可视化 SQLite 数据
使用 SQL 和 Power BI 进行实际数据分析
将 SQLite 数据库与 Power BI 相连接并将数据快速转化为洞察力的分步指南
power bi⚡️
power bi desktop 支持多种数据源，包括 Excel、SQL Server、IBM Db2 数据库等等。虽然 Power BI 提供了 Azure SQL 数据库和 SQL 数据仓库的连接器，但是你不会找到任何 SQLite 数据库的连接器。但好消息是，您仍然可以在 Power BI 中可视化这些数据。⚡️
💡这篇文章末尾的指导项目将是展示您的数据科学作品集的绝佳素材。
几天前，我创建了一个 SQLite 数据库来练习 SQL 查询。但是，我更好奇的是，如何在 Power BI 中可视化这些数据。然后，我按照下面的过程来达到我的目标。
关于 SQLite 数据库及其创建方式的更深入的见解可以在我之前的文章中找到。
https://medium.com/analytics-vidhya/sql-database-with-python-5dda6c9a0c8d
在开始这个过程之前，让我告诉你更多关于这个英雄的事情😎我们的故事— SQLite ODBC 驱动
驱动程序是促进两个应用程序之间通信的接口
SQLite ODBC 驱动程序
ODBC 代表开放式数据库连接。
它是微软开发和维护的界面。我们将使用 ODBC 驱动程序来访问 SQLite 数据库中的数据。
ODBC 驱动程序允许我们将 SQLite 数据库添加到它的数据源列表中，然后这个数据源可以连接到任何应用程序进行进一步的分析和可视化。当然，这些数据库可以通过 Python 或任何其他编程来访问。但是，通过 ODBC 驱动程序访问它要方便得多。
我们开始吧！
让我们来看看继续这个故事所需要的所有东西。
- 一个 SQLite 数据库 :我正在赠送我自己创建的 SQLite 数据库📚作为一个很好的外卖。你可以在这里找到https://github.com/17rsuraj/data-curious/tree/master/TowardsDataScience。数据库文件的名称是
tds.sqlite - SQLite ODBC 驱动 :我发现我一些同事的电脑上已经安装了。不过你可以随时从这里 下载。根据您的操作系统，选择 32 位或 64 位版本。
- Power BI Desktop 版 :如果你是在职专业人士，可以使用你的工作邮箱访问 Power BI Desktop。如果您是学生，将需要您的学校电子邮件地址才能访问。威力 BI 桌面可以从 这里 下载。
检查 SQLite ODBC 驱动程序
这简单明了。只需在开始菜单中查找 ODBC 数据源并打开它。
你需要这三个驱动中的任何一个-
1。SQLite ODBC 驱动程序
2。SQLite3 ODBC 驱动程序
3。SQLite ODBC (UTF-8)驱动程序
如下图所示，您可以在“驱动程序”选项卡下检查这一点。
检查 ODBC 驱动程序(作者图片)
如果您看到上面列出的任何驱动程序，您可以跳过 SQLite ODBC 驱动程序的安装。
安装 SQLite ODBC 驱动程序
SQLite ODBC 驱动可以在 这里 下载。
下载并安装 SQLite ODBC 驱动程序(图片由作者提供)
一旦安装了这个驱动程序，然后再次检查它现在是否在 ODBC 数据源管理器中可见，如上图所示。
分配数据源名称(DSN)
至此，您将拥有 SQLite ODBC 驱动程序和 Power BI Desktop。让我们开始通过 ODBC 驱动程序将 SQLite 数据库与 Power BI 连接起来。
下一步是为所需的数据源创建一个名称。使用这个名称，我们可以在使用 Power BI 时识别所需的数据源。
在 ODBC 数据源管理器中设置数据源名称(图片由作者提供)
上图中的 DSN 代表数据源名称。在“开始”菜单中搜索 ODBC 数据源管理器，然后按照此图片快速设置 DSN。要完成该过程，请在步骤 8 之后，在 ODBC 数据源管理器窗口中单击 OK。
📌上图中需要记住的要点是:
*1\. Select the correct ODBC driver as shown in step 3
2\. Type in a meaningful Data Source Name as shown in step 5
3\. Browse for the sqlite3 database file which you want to visualize in step 6\. For this particular example, you can download my self-created database [file](https://github.com/17rsuraj/data-curious/blob/master/TowardsDataScience/tds.sqlite).
4\. After step 7, you must see your DSN in the ODBC Data Source Administrator window as shown in step 8.*
将数据导入 Power BI
离目标又*了一步🎯现在，让我们用 Power BI 连接数据源。只需打开 Power BI 桌面，按照下面的一系列图片进行操作。
从 ODBC 获取数据(图片由作者提供)
如上图所示，您必须为在上一步中创建的数据源选择 DSN。一旦您在步骤 7 中单击 OK，您将被提示输入连接凭证。
数据库连接凭据(作者图片)
只需选择默认或自定义选项，然后点击连接。接下来，您将在数据源导航器窗口中看到所有可用的表。在这里，您还会在顶部看到 DSN(如下面蓝色虚线矩形所示)
数据源导航器(图片由作者提供)
如上图所示，选择要可视化的表并加载数据。如果您对任何数据操作感兴趣，也可以选择转换数据选项。
如果数据库有多个表，并且您希望可视化多个表中的数据，请选择所有表并加载数据。必须在 Power BI 的 模型 视图中手动创建表之间的关系。
行动的时间到了！！！🎭
电力商业智能中的数据可视化
由于来自 SQL 数据库的数据现在被导入到 Power BI 中，因此可以根据可用的数据创建各种可视化。这是我创造的视觉效果。
电力 BI 中的数据可视化(图片由作者提供)
您肯定可以利用 Power BI 可视化的强大功能进行创造性的可视化。我已经开始把我的工作从 Excel 转移到这个磁盘数据库，你也可以跟着做。
💡项目创意！！
使用Web Scraping创建您自己的数据集，通过练习 数据争论 技术对其进行评估和清理，并将其存储在 SQL 数据库 中，以最终在 Power BI 中将其可视化，这不失为一个好主意。
长话短说，
我向您展示了使用 Power BI 可视化 SQLite 数据的过程。有适当图片支持的一步一步的方法一定会帮助你更好地理解。
如果你想直接开始而不创建任何数据库，没问题！现成的 SQLite 数据库文件📚正在我的 Github repo 上等你。
此外，项目构想可以用其中给出的资源来实现。正如我常说的，我乐于接受建设性的反馈和通过 LinkedIn 分享知识。
感谢您的阅读和宝贵时间！
希望对你在任何数据集上练习 DataViz 有所帮助。
可视化不可见的量子位相位
并学习如何区分相对相位和全局相位
本帖是本书的一部分: 用 Python 动手做量子机器学习 。
当我们处理振幅时，量子位的相位是决定性因素。即使我们不能直接测量相位，它也不是不可见的。一旦，我们可以使用我们的模拟器来可视化它。第二，我们可以用数学来精确描述。
当我们观察布洛赫球时，具有正振幅的态位于 X 轴和 Z 轴的前侧。
作者弗兰克·齐克特的图片
相比之下，具有负振幅的态位于布洛赫球的背面。
作者弗兰克·齐克特的图片
首先，让我们考虑一些简单的状态。如果我们将量子位状态向量绕 Y 轴旋转角度θ，我们得到以下状态。对于 0
作者弗兰克·齐克特的图片
该图示出了这些状态位于 X 轴和 Z 轴跨越的*面上。向量θ指定绕 Y 轴的旋转。因此，我们把相应的门称为 RY-gate。
在 Z 轴上相互镜像的两个向量具有相同的测量概率，例如图中所示的两个向量。它们共享相同的测量概率，但是它们的相位不同。
Z 门
Z 门反映了 Z 轴上量子位的状态。它具有类似于 X 门的效果，反映 X 轴上的状态。x 轴上的反射会影响最终的测量概率，因为它会改变到 z 轴端点(|0⟩和|1⟩).)的邻*度但是它没有触及这个阶段。相反，Z 轴上的反射会翻转相位，但不会影响测量概率。
以下等式表示 Z 门的变换矩阵。
Z-gate 将|+⟩态的量子位转变为|−⟩.态|+⟩和|−⟩位于 x 轴上。数学上，下面的等式描述了这种转换。
让我们通过编程来看看 Z 门的效果。
作者弗兰克·齐克特的图片
Qiskit 让我们很容易地展示量子位状态向量。我们照常定义和准备量子电路(第 4-11 行)。在这种情况下，我们在量子位 0(第 7 行)上应用一个单一的 Hadamard 门，在量子位 1(第 10-11 行)上应用一个附加的 Z 门。
我们使用'statevector_simulator'-后端执行电路。但是我们没有从执行结果中获取计数，而是调用了get_statevector()-函数(第 13 行)。输出是状态向量的数组，就像array([ 0.5+0.j, 0.5+0.j, -0.5+0.j, -0.5+0.j])。
我们可以将这个数组输入从qiskit.visualization(第 2 行)导入的函数plot_bloch_multivector(第 14 行)。结果，我们得到了每个量子位的布洛赫球表示。
我们可以看到两个向量都在 Y 轴上。它们的振幅产生相同的测量概率，每个概率为 0.5。|+⟩状态向量指向 x 轴的正方向(正面),而|−⟩状态向量指向负方向(背面)。
让我们看另一个例子。在应用 Z 门之前，让我们围绕 Y 轴将状态旋转一个小θ。
作者弗兰克·齐克特的图片
第二个例子强调了轴上的反射。它不是坐标系中心的反射。
Z 门有一个显著的特性。它对|0⟩和|1⟩.的量子位没有影响显然不是，因为这两个状态位于 Z 轴上。
作者弗兰克·齐克特的图片
从数学角度来看，|0⟩.的情况很简单
我们得到了可视化的确认。但是|1⟩.怎么样
这个等式的结果是不明确的。得到的状态向量不同于原始向量|1⟩.
相移似乎有所不同。但是可视化显示这两个向量是相同的。
作者弗兰克·齐克特的图片
负号似乎无关紧要。但是如果我们把这个状态叠加会怎么样呢？
作者弗兰克·齐克特的图片
同样，可视化告诉我们，这些状态之间没有区别。那么，让我们再来看看数学。如果我们将哈达玛门应用于|1⟩，就会得到|−⟩.
如果我们首先应用 z 门，符号从|0⟩的幅度跳到|1⟩.的幅度
你还记得帖子中的量子数学——你准备好接受红色药丸了吗，在那里阐述了无法区分
正如我们刚刚看到的，当我们在任一态上应用其他量子门时，结果态没有区别。α|0⟩态和β|1⟩态构成了一个共享的量子态。对于得到的量子位状态向量，α或β是否包含相位并不重要。
不过还是再细致一点吧。Qiskit 提供了另一种可视化，量子状态的“qsphere”表示。在这种表示中，点的大小与状态中相应项的概率成比例，颜色表示相位。
作者弗兰克·齐克特的图片
上图显示了|0⟩−|1⟩/sqrt(2).状态下的量子位在应用 Z 门(第 6 行)之前，我们首先应用 Hadamard 门(第 5 行)。相位适用于状态|1⟩.的振幅因此，我们只能看到绿松石色的|1⟩。|0⟩仍然是红色的。两个圆具有相同的大小，因为两个状态具有相同的测量概率。
现在，让我们像以前一样在|1⟩态的量子位上应用 z 门和哈达玛门。
作者弗兰克·齐克特的图片
这个电路导致−|0⟩+|1⟩/sqrt(2).状态这些颜色表明我们对|0⟩.进行了相移
因此，我们可以将相位应用于两个幅度之一，α或β。重要的是，我们不能将它应用于两个幅度，因为这将有效地再次恢复整体相位。
多量子位相位
如果我们有多个量子比特呢？下面的等式表示两个量子位系统的状态。
两量子位系统可以处于四种不同的状态。每个状态也有一个振幅。
事实上，我们已经在上面指定了一个两量子位系统来并排显示两个布洛赫球。量子位 0 处于|0⟩−|1⟩/sqrt(2 状态)而量子位 1 处于−|0⟩+|1⟩/sqrt(2).状态
让我们看看这个系统的四个状态的总体阶段。
作者弗兰克·齐克特的图片
我们看到|00⟩和|11⟩.这两个国家的相位发生了变化在这种记法中，我们从右边(位置 0 的量子位)到左边(位置 1 的量子位)读取量子位。|11⟩获得量子位 0 相移的状态具有|1⟩振幅中的相位(如在|0⟩−|1⟩/sqrt(2)).因此，状态|00⟩得到量子位 1 的相移，它的相位在|0⟩ (−|0⟩+|1⟩/sqrt(2)).)的振幅中
尽管这很有道理，但这并不是全部事实。让我们看看如果两个量子位都处于|0⟩−|1⟩/sqrt(2).态会发生什么我们期望看到|01⟩和|10⟩.阶段的转变
作者弗兰克·齐克特的图片
与我们的预期不同，我们在|00⟩和|11⟩.看到了相位的变化原因很简单，相位是相对的。我们有两个相似但偏移的波。但是你怎么知道这两个波中哪一个是原始的呢？
作者弗兰克·齐克特的图片
因此，我们需要接受这样一个事实:我们无法区分
当我们使用单个量子位时，区分这两种状态的能力是虚假的。当我们加入第二个量子位元时，它已经消失了。
下面的电路在单个量子位上产生|0⟩−|1⟩/sqrt(2 状态。
作者弗兰克·齐克特的图片
我们在|1⟩.看到了这个阶段看看当我们将电路定义为两个量子位的电路时会发生什么。
作者弗兰克·齐克特的图片
在两个量子位的电路中，我们看到了|00⟩.态的相位因此，当我们对两个量子位中的一个施加相移时，我们看到它处于|1⟩.态
作者弗兰克·齐克特的图片
在这种情况下，我们通过应用哈达玛门(第 4-5 行)将两个量子位置于叠加态。我们在位置 0 移动量子位的相位。因此，我们看到这个量子位(右手边)的不同状态具有不同的相位。|1⟩状态中量子位为 0 的状态与|0⟩.状态中量子位为 0 的状态具有不同的相位同样，Qiskit 仅对相对相位有意义，并指示量子位 0 处于|0⟩.状态时的状态偏移全局相位不可观测。
结论
全局相位是我们使用的数学框架的人工制品。它们没有物理意义。如果两个状态只有一个全局相位不同，那么它们实际上代表的是同一个物理系统。
相比之下，相对相位是量子力学的核心，因此是量子计算中最令人感兴趣的部分。如果两个状态相差一个相对相位，它们就是以不同方式演化的不同系统。即使分开测量它们看起来是一样的，但当它们干扰其他量子系统时，会有不同的效果。
本帖是本书的一部分: 用 Python 动手做量子机器学习 。
在这里免费获得前三章。
使用 Google Colab 用旭日图可视化你的投资组合
旭日图是形象化你的投资组合的一种有见地的方式。Google Colab 使在浏览器中创建动态图变得很容易。
图一。展示投资组合的旭日图示例。图片由作者提供。
旭日图是可视化分层数据的一种有见地的方式。投资组合是此类数据的一个很好的例子，因为它可以细分为几个资产类别，每个资产类别可以进一步细分为单个资产，如上例所示。在这个小故事中，我分享了使用 google colab 创建如上图所示的情节的简单步骤。
运行代码以获得您自己的绘图
如果您只想运行代码并获得投资组合的绘图，您可以简单地替换以下 google colab 笔记本中的值:
https://colab.research.google.com/drive/1r2j8NzPL8HaC3O2f74XMabOiYVJ1nIxc?usp=sharing
该图是基于一个简单的表生成的，该表有 3 列:资产、名称和值。下图显示了如何逐行构建表格(左图)以及生成的格式化数据帧(右图)。
图二。用于在笔记本中创建数据帧(左图)和数据帧渲染(右图)的代码示例。图片由作者提供。
绘图功能如何工作
对于情节，我使用的是 Plotly 库。从数据帧生成绘图的代码如下:
图 3。用于生成图 1 中的绘图的代码。图片由作者提供。
代码非常简洁，所以让我一步一步地解释它。
- 每个标签必须有一个父标签和值。例如，您可以看到第一个标签是“Portfolio ”,有一个父项" "(空-无父项),其值是表中所有资产的总和。这将创建中心圆(图 1 中的白色区域)。
- 下一步是图的第一个环，对应于资产类别。在第 6 行和第 14 行，数据帧按资产分组，并对值求和。然后在第 6 行，选择
index，对应于唯一资产的列表。在第 14 行选择了Value，对应于每项资产的总价值。资产类别的父项总是“投资组合”标签，因此在第 10 行“投资组合”被添加了 n 次，其中 n 是可以通过df.Asset.nunique()获得的独特资产的数量。另外，注意列表前的*被用来使值“离开列表”，否则结果将是列表中的列表，这不是我们在这里想要的。 - 最后，对于图的第二个环，所有单独的名称(第 7 行)和相应的值(第 15 行)被添加到标签和值列表中。在这种情况下，父资产是表中每一行对应的资产(第 11 行)。
- 在第 17 行中，设置
branchvalues='total'确保分支跨越父节点上方的所有空间，因为分支中值的总和等于父节点值。 - 在第 19 行中，
update_layout可以用来添加或删除图形周围的边距。 - 在第 20 行，
update_traces可以用来设置在绘图中显示哪些信息。在这种情况下，选项labels+percent parent确保绘图显示标签名称和相对于父标签的百分比。根据功能描述，text_info的选项可以是用“+”字符连接的['标签'，'文本'，'值'，'当前路径'，'根百分比'，'条目百分比'，'父百分比']的任意组合。
仅此而已！我希望你觉得这个故事有用，并享受创造情节的乐趣！
免责声明:本故事的内容仅供参考。图、表或文本中提及的资产仅用于说明目的，并不代表任何类型的投资建议或认可。
用基本的 Viz 包可视化你的地图数据
仅使用基本工具创建信息丰富的地图可视化
美国宇航局在 Unsplash 拍摄的照片
当我处理房地产数据时，我经常在打开数据集时做一件事情，就是制作数据的地理可视化。我这样做没有使用任何复杂的包或形状文件。这不仅是一个很好的方式来形象化我的住房所在的物理空间，而且我可以用这个形象化来看到可能通知我的目标的其他元素。我所需要的是 Seaborn 和一个带有一些经度/纬度信息的数据集。
我首先加载我的相关包并加载我的数据集。在本例中，我使用的是国王郡住宅数据集。
# data processing tools
import pandas as pd
import numpy as np# Visualization tools
import seaborn as sns
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline# load and look at our king county housing data
df = pd.read_csv(‘kc_house_data.csv’)
df
这只适用于具有 lat/long 的数据集，但效果惊人。请看我获取数据集并生成国王县区域的地图:
# plotting latitude and longitude as a visual scatter plot to look for location outliersplt.figure(figsize=(25,25))ax = sns.scatterplot(data=df, x=”long”, y=”lat”, palette=”magma_r”)plt.show();
只用了几行代码，我就制作出了所有数据点的地图。我能做的第一件事是轻松识别基于位置的异常值。例如，对于 King County 数据集，在经度-121.65 以东只有几个属性不在我们想要建模的大都市区附*。我可以删除这些属性，而不用担心删除了有用的数据。
# drop the properties east of the metropolitan area
df.drop(df[df[‘long’] > -121.65].index, inplace=True)
不过，我可以用这张地图展示更多。我们都知道位置是房地产的一切，所以让我们在地图上展示一下，只需多几行代码。
我们将使用每个邮政编码的房屋价值中值对 70 个邮政编码从低到高进行价格排序。为此，我们将为我们的邮政编码制作一个等级查找表，然后将其应用于数据帧。
# we’re using the median house value for a zip code to determine the zip code’s sort, so we can visualize the zip code importance# group our dataframe by zipcode on median home price, sorted ascending.
zipsorted = pd.DataFrame(df.groupby(‘zipcode’)[‘price’].median().sort_values(ascending=True))# rank each zip code and assign rank to new column
zipsorted[‘rank’] = np.divmod(np.arange(len(zipsorted)), 1)[0]+1# function that looks up a segment that a data entry belongs to
def make_group(x, frame, column):
‘’’Takes in a line, a lookup table, and a lookup column
returns value of target column
PARAMETERS:
line from dataframe x
lookup table frame
column to return rank’’’
y = frame.loc[(frame.index == x)][column]
z = np.array(y)
z[0]
return z[0]# make a new column on our dataframe. Look up each zip entry’s group, and append to the column.
df[‘zip_rank’] = df[‘zipcode’].apply(lambda x: make_group(x, zipsorted, ‘rank’))
顺便说一下，不要在你的模型中使用这些等级，至少在你分割和使用正确的目标编码之前不要使用。这会将您的拒绝数据泄露到您的模型中。我们现在只是把它作为一个可视化工具。
现在我们将制作和以前一样的地图，但是这一次我们将使用我们的 zip 等级给地图着色。
plt.figure(figsize=(25,25))ax = sns.scatterplot(data=df, x="long", y="lat", hue='zip_rank', palette="magma_r")# Add title to legend
ax.legend(title='Zip Rank', title_fontsize=30, fontsize=24)plt.show();
现在，我们不仅制作了我们所在地区的地图，还展示了一些重要信息——即位置对价格的重要性。
如果我们尝试，我们可以在地图上显示更多信息，尽管在这个比例下，可能很难看到太多。但这是同样的地图，又是另一个维度，使用我们的“等级”属性来确定我们的散点大小。
plt.figure(figsize=(25,25))ax = sns.scatterplot(data=df, x=”long”, y=”lat”, hue=’zip_rank’, size=’grade’, palette=”magma_r”)
# Add title to legend
ax.legend(title=’Zip Rank’, title_fontsize=24, fontsize=20)plt.show();
就像那样，我们已经为一个住宅集制作了一个有用的和信息丰富的可视化，所有这些都没有使用任何额外的包或 shapefiles！我们需要的只是熊猫、numpy、matplotlib 和 seaborn 的基本套装。
使用 GA4、BigQuery 和 Tableau 可视化您的产品健康状态指标
了解热图表的强大功能！
在这篇文章中，我将分享一个我最喜欢的监控数码产品健康状态的可视化工具。我将关注这三个指标:1 .用法，2。成功率& 3。完成率。我还将分享如何从 BigQuery 查询提到的度量数据。
GA4 允许所有用户将原始数据导出到 Google cloud & BigQuery。这个特性非常棒，因为对于数据专业人员来说，原始数据就像是好厨师的新鲜有机食材。两者都是伟大食谱的必备！此外，Google Cloud 拥有广泛的分析工具来转换数据、分析数据、在其上应用 ML &构建数据产品，等等。
对于数据专业人员来说，原始数据就像是好厨师的新鲜有机食材。两者都是伟大食谱的必备！
让我们首先通过在 BigQuery 中查询来获取这些指标的数据。下面的查询应该可以帮助我们实现这一点。
-- Standard SQL, BigQuery
select parse_date('%Y%m%d',t.event_date) as date, platform, event_name, p.value.int_value as success, p2.value.string_value as flow_name,count(event_name) as events_count,if(p.value.int_value=1,count(event_name),0) as success_count,if(p.value.int_value=0,count(event_name),0) as fail_countfrom `[gcp_ptoject_name].[dataset_name].events_*` t, t.event_params p, t.event_params p2where p.key = 'success' and _table_suffix between '20210101' and '20211231' and p2.key = 'flow_name'group by 1,2,3,4,5order by date desc
我们得到了按日期、*台、流名称、事件名称和成功状态计数的事件&然后我们做一些计算来计数成功和失败事件的数量。
上述查询的结果应该类似于下表:
现在，在获得我们需要的数据之后，是时候将它可视化了。我将使用热图表来可视化这三个指标。
热图表是我最喜欢的可视化数据的图表之一。这是一个任何人都能理解的简单图表(只是一个表格)。它可以在一个图像中封装多个维度，并使您能够轻松地发现趋势，如果您愿意，还可以检查绝对数字。
现在，让我们来看看每个指标的热图。
1-用法:
使用是指人们尝试进行某项活动的总次数。您也可以通过尝试参加活动的用户数量来计算。
这个指标不需要预先计算，我们从 BigQuery 获得的数据中明确显示了这一点。
下面的热图表是一个可视化所有事件和流的每个*台的使用趋势的示例。每个单元格包括两个值(事件数和与上一个值的差异%)。天)。颜色代码用于表示与前一天的百分比差异，以显示每个事件的使用趋势如何变化。例如，在 8 月 8 日，所有*台的 song_end 事件都有一个使用高峰。
热图表—所有*台的每个事件和流量的使用趋势。
— — — —
2-成功率:
成功率是指成功完成一项活动的人占所有尝试完成这项活动的人的百分比。
要计算成功率，需要将成功的事件除以所有事件。以下是如何在 Tableau 中对上述数据进行操作。
sum([Success Count])/SUM([Events Count])
下面的热图是一个示例，直观显示了每个*台所有事件和流的成功率随时间的变化情况。颜色代码用于显示某些功能的成功率是否下降。例如，在下图中，8 月 9 日 iOS 应用程序的 song_play_start 事件的成功率显著下降。
热图表—所有*台的每个事件和流程的成功率。
— — — —
3-完成率:
完成率是完成流程的用户与开始流程的用户之间的差异。即，完成收听音轨的人/开始音轨的所有人。
为了计算完成率，您可以使用 Tableau LOD 特性来创建指标。例如，下面是为上面的数据创建的代码。
{include [Flow Name],DAY([Date]),[Platform]: sum(if(CONTAINS([Event Name],"end")) then [Events Count] else 0 END)/
sum(if(CONTAINS([Event Name],"start")) then [Events Count] else 0 END)}
下面的热图是一个示例，显示了一个流程在每个*台上的完成率。颜色代码用于完成率，以显示它是否在某些日期或*台下降。例如，在下面的图表中，play_track 流增加了所有*台在 8 月 8 日和 9 日之间的完成率。
结论:
在这篇文章中，我试图分享我最喜欢的图表之一，热图表，以及如何可视化健康状态指标。我还讨论了如何在 BigQuery 中查询数据。
你有其他可视化健康状态指标的想法吗？如果有，请在评论区与我们分享！😃
— — — -
你可以在下面查看我以前的帖子:
用这个框架简化你的 GA4 追踪&分析——以 Spotify App 为例。
— — —
注:本帖所有数据均为虚拟数据，并非真实数据。
使用 Python 在交互式地图上可视化您的 Strava 数据
使用 Strava API 和 Python 下载您的活动数据、创建高程剖面并在交互式地图上绘制您的活动详细信息，只需几个简单的步骤。
作者图片
D 下载你的 Strava 数据并不复杂。但首先，您必须通过一个一次性的手动过程，授权您的应用程序访问您的所有活动数据。首先，我建议你按照 Matt Ambrogi 在他精彩的故事中解释的步骤。之后，你就可以走了。
首先:导入一些重要的 Python 包。还建议禁用特定的urllib3警告。
# import modules
import os
import requests
import urllib3
import pandas as pd
import numpy as np
import time
import matplotlib.pyplot as plt
import folium
import polyline
import base64
from tqdm import tqdm# disable warnings
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
要下载您的 Strava 数据，需要设置一些变量。当您在线登录到您的 Strava count 时，您可以查找所需的值。进入“设置”，然后进入“我的 API 应用程序”。
作者图片
您将需要您的客户端 ID 、客户端密码和刷新令牌。在下面的代码块中，将文本在此插入您的值替换为您的个人值。
# set strava variables
client_id = ‘insert your value here‘
client_secret = ‘insert your value here’
refresh_token = ‘insert your value here'
基于您刚刚声明的变量，您可以获得一个新的访问令牌。
# define function to get a new access token
def get_access_token(client_id, client_secret, refresh_token):
oauth_url = ‘[https://www.strava.com/oauth/token'](https://www.strava.com/oauth/token')
payload = {
‘client_id’: client_id,
‘client_secret’: client_secret,
‘refresh_token’: refresh_token,
‘grant_type’: ‘refresh_token’,
‘f’: ‘json’,
}
r = requests.post(oauth_url, data=payload, verify=False)
access_token = r.json()[‘access_token’] return access_token# get new access token
access_token = get_access_token(client_id, client_secret, refresh_token)
现在您有了一个新的访问令牌，您可以下载您的 Strava 数据。一页数据包含 200 个活动(默认值)。因此，*均每周 4 次活动大约是每年 1 页 Strava 数据(4 次活动×50 周)。我们将设置一个初始值，最大获取 10 页。然而，当发现一个空页面时，控制循环将停止。
# define function to get your strava data
def get_data(access_token, per_page=200, page=1):
activities_url = ‘[https://www.strava.com/api/v3/athlete/activities'](https://www.strava.com/api/v3/athlete/activities')
headers = {‘Authorization’: ‘Bearer ‘ + access_token}
params = {‘per_page’: per_page, ‘page’: page}
data = requests.get(
activities_url,
headers=headers,
params=params
).json()
return data# get you strava data
max_number_of_pages = 10
data = list()
for page_number in tqdm(range(1, max_number_of_pages + 1)):
page_data = get_data(access_token, page=page_number)
if page_data == []:
break
data.append(page_data)
现在我们有了一个带有页面结果的列表中的数据，我们将把它们放在一个字典中，并打印下载的活动数量。
# data dictionaries
data_dictionaries = []
for page in data:
data_dictionaries.extend(page)# print number of activities
print(‘Number of activities downloaded: {}’.format(len(data_dictionaries)))
最后一步是将数据标准化为熊猫数据框架，并对一些数据进行采样以获得第一印象。
# normalize data
activities = pd.json_normalize(data_dictionaries)# sample activities
activities[['name', 'distance', 'average_speed', 'moving_time']]\
.sample(5)
作者图片
列map.summary_polyline是 Google 格式的，我们需要先解码，然后才能在地图上绘制路线(折线)。
# add decoded summary polylines
activities[‘map.polyline’] = activities[‘map.summary_polyline’].apply(polyline.decode)
新创建的列map.polyline将用于使用开放高程 API 向数据帧添加高程数据。注意:根据活动的数量和距离(折线中的坐标数)，下载高程数据可能需要相当长的时间。
# define function to get elevation data using the open-elevation API
def get_elevation(latitude, longitude):
base_url = ‘[https://api.open-elevation.com/api/v1/lookup'](https://api.open-elevation.com/api/v1/lookup')
payload = {‘locations’: f’{latitude},{longitude}’}
r = requests.get(base_url, params=payload).json()[‘results’][0]
return r[‘elevation’]# get elevation data
elevation_data = list()
for idx in tqdm(activities.index):
activity = activities.loc[idx, :]
elevation = [get_elevation(coord[0], coord[1]) for coord in activity['map.polyline']]
elevation_data.append(elevation)# add elevation data to dataframe
activities['map.elevation'] = elevation_data
在我们的数据框架中还有一些工作要做。日期没有日期时间格式，距离以米为单位，速度以米每秒为单位。设置一个索引列并删除我们不使用的列也是一个很好的做法。
# convert data types
activities.loc[:, ‘start_date’] = pd.to_datetime(activities[‘start_date’]).dt.tz_localize(None)
activities.loc[:, ‘start_date_local’] = pd.to_datetime(activities[‘start_date_local’]).dt.tz_localize(None)# convert values
activities.loc[:, ‘distance’] /= 1000 # convert from m to km
activities.loc[:, ‘average_speed’] *= 3.6 # convert from m/s to km/h
activities.loc[:, ‘max_speed’] *= 3.6 # convert from m/s to km/h# set index
activities.set_index(‘start_date_local’, inplace=True)# drop columns
activities.drop(
[
‘map.summary_polyline’,
‘resource_state’,
‘external_id’,
‘upload_id’,
‘location_city’,
‘location_state’,
‘has_kudoed’,
‘start_date’,
‘athlete.resource_state’,
‘utc_offset’,
‘map.resource_state’,
‘athlete.id’,
‘visibility’,
‘heartrate_opt_out’,
‘upload_id_str’,
‘from_accepted_tag’,
‘map.id’,
‘manual’,
‘private’,
‘flagged’,
],
axis=1,
inplace=True
)
我们的第一个情节开始了！我们将从在地图上绘制一条活动路线开始。为了正确地使地图居中，我们计算质心或“折线中心”。
# select one activity
my_ride = activities.iloc[0, :] # first activity (most recent)# plot ride on map
centroid = [
np.mean([coord[0] for coord in my_ride['map.polyline'][0]]),
np.mean([coord[1] for coord in my_ride['map.polyline'][0]])
]
m = folium.Map(location=centroid, zoom_start=10)
folium.PolyLine(my_ride['map.polyline'], color='red').add_to(m)
display(m)
作者图片
让我们画出这次乘坐的高度剖面图。
# plot elevation profilefig, ax = plt.subplots(figsize=(10, 4))
ax = pd.Series(my_ride[‘map.elevation’][0]).rolling(3).mean().plot(
ax=ax,
color=’steelblue’,
legend=False
)
ax.set_ylabel(‘Elevation’)
ax.axes.xaxis.set_visible(False)
ax.spines[‘top’].set_visible(False)
ax.spines[‘right’].set_visible(False)
plt.show()
作者图片
现在，我们准备在一张地图上绘制所有活动，每条路线(中途)都有一个标记，还有一个包含所有活动详细信息的交互式弹出窗口。对于每种类型的活动(骑行、跑步、步行)，我们将使用不同的颜色。我们将分两步进行。在步骤 1 中，我们创建弹出窗口所需的所有高程剖面。在步骤 2 中，创建并保存了实际的地图。
步骤 1:立面图
# color scheme
color = {'Ride':'red', 'Run':'blue', 'Walk':'purple'}# create dictionary with elevation profiles
elevation_profile = dict()for row in activities.iterrows():
row_values = row[1]
# figure
fig, ax = plt.subplots(figsize=(6, 2))
ax = pd.Series(row_values[‘map.elevation’]).rolling(3).mean().plot(
ax=ax,
color=color[row_values[‘type’]],
legend=False,
)
ax.set_ylabel(‘Elevation’)
ax.axes.xaxis.set_visible(False)
ax.spines[‘top’].set_visible(False)
ax.spines[‘right’].set_visible(False)
png = ‘elevation_profile_{}.png’.format(row_values[‘id’])
fig.savefig(png, dpi=75)
plt.close()
# read png file
elevation_profile[row_values[‘id’]] = base64.b64encode(open(png, ‘rb’).read()).decode()
# delete file
os.remove(png)
第二步:绘制交互式地图
# plot all activities on map
resolution, width, height = 75, 6, 6.5def centroid(polylines):
x, y = [], []
for polyline in polylines:
for coord in polyline:
x.append(coord[0])
y.append(coord[1])
return [(min(x)+max(x))/2, (min(y)+max(y))/2]m = folium.Map(location=centroid(activities['map.polyline']), zoom_start=4)for row in activities.iterrows():
row_index = row[0]
row_values = row[1]
folium.PolyLine(row_values['map.polyline'], color=color[row_values['type']]).add_to(m)
halfway_coord = row_values['map.polyline'][int(len(row_values['map.polyline'])/2)]# popup text
html = """
<h3>{}</h3>
<p>
<code>
Date : {} <br>
Time : {}
</code>
</p>
<h4>{}</h4>
<p>
<code>
Distance  : {:.2f} km <br>
Elevation Gain  : {:.0f} m <br>
Moving Time  : {} <br>
Average Speed  : {:.2f} km/h (maximum: {:.2f} km/h) <br>
Average Cadence  : {:.1f} rpm <br>
Average Heart Rate  : {:.0f} bpm (maximum: {:.0f} bpm) <br>
Average Watts  : {:.1f} W <br>
Average Temperature : {:.1f} <br>
Kilojoules  : {:.1f} <br>
Relative Effort  : {:.0f} <br>
Athletes  : {:.0f} <br>
Kudos  : {:.0f} <br>
</code>
</p>
<img src="data:image/png;base64,{}">
""".format(
row_values['name'],
row_index.date(),
row_index.time(),
row_values['type'],
row_values['distance'],
row_values['total_elevation_gain'],
time.strftime('%H:%M:%S', time.gmtime(row_values['moving_time'])),
row_values['average_speed'], row_values['max_speed'],
row_values['average_cadence'],
row_values['average_heartrate'], row_values['max_heartrate'],
row_values['average_watts'],
row_values['average_temp'],
row_values['kilojoules'],
row_values['suffer_score'],
row_values['athlete_count'],
row_values['kudos_count'],
elevation_profile[row_values['id']],
)
# add marker to map
iframe = folium.IFrame(html, width=(width*resolution)+20, height=(height*resolution)+20)
popup = folium.Popup(iframe, max_width=2650)
icon = folium.Icon(color=color[row_values['type']], icon='info-sign')
marker = folium.Marker(location=halfway_coord, popup=popup, icon=icon)
marker.add_to(m)m.save('mymap.html')
display(m)
作者图片
作者图片
您的互动地图另存为mymap.html，可以分享！你只需要一个网络浏览器来查看你的(本地)文件。
最后的想法
Python 是一种功能强大的语言，拥有惊人的库来可视化您的数据。你最喜欢的可视化地理数据的语言和包是什么？让我知道你的想法。
https://medium.datadriveninvestor.com/create-thematic-maps-using-shapefiles-in-julia-135ea67e9628 </5-amazing-pandas-features-you-probably-dont-know-about-5533498aac88>
使用 Python 甘特图可视化您团队的项目
利用您的 Python 技能来帮助您的团队管理他们的任务
动机
如果您在团队中工作，团队中可能会有多个项目。每个项目还有一些有截止日期的子任务。每个子任务被分配给不同的团队成员。
如果每个成员都有不同的休假日期，日程安排就更复杂了。有没有一种方法可以让你用 Python 可视化所有这些细节，如下图？
作者图片
是的，你可以用 python-gantt。
什么是甘特图？
甘特图是一种条形图，它提供了一段时间内任务计划的可视化视图。x 轴代表时间线，y 轴代表任务。
Python 中有多个库可以让你创建甘特图，但我发现的图形最漂亮的是 python-gantt。
要安装 python-gantt ，请使用
pip install python-gantt
入门指南
我们将从一个简单的例子中学习如何使用 python-gantt。假设你的公司只有两名员工:Ben 和 Alex。您希望在一个项目中为不同的员工分配不同的任务。
创建员工
从使用gantt.Resource()方法创建雇员开始。
创建一些任务
接下来，我们使用gantt.Tasks方法为您的员工创建一些任务
gantt.Tasks方法内部参数说明:
start:开始日期duration:任务的持续时间resources(可选):任务会分配给谁color(可选):任务栏的颜色
创建项目
一个项目可能有不同的任务。例如，“清理数据”项目可以包括较小的任务，如“研究数据”、“选择最佳特征”等。
可能有多个项目，例如“清理数据”、“构建模型”和“测试模型性能”。在这个例子中，我们将只创建一个包含上面创建的所有任务的项目。
创建假期(可选)
您也可以使用add_vacation方法将自定义假期添加到甘特图中
现在我们已经准备好可视化我们的甘特图了！
用甘特图可视化
要可视化甘特图，请使用make_svg_for_tasks方法
这将创建一个 SVG 图像，如下所示
作者图片
点击此处查看图表。在上图中，灰色单元格表示休息日(周末和假期)，蓝色竖线表示今天。我们还可以看到每个任务的持续时间以及每个任务分配给了谁。
多个项目和里程碑
在现实生活中，甘特图可能看起来比上面更复杂，因为可能有多个项目。在一个项目中，可能有多个里程碑。
里程碑标志着工作主要阶段的完成。每个里程碑可以有不同的任务。
这些细节听起来很复杂。好消息是，使用 python-gantt 可以很容易地将所有这些细节包含在甘特图中。
创建项目 2、里程碑和任务
要创建一个里程碑，使用gantt.Milestone方法。参数depends_of指定每个里程碑依赖于哪些任务。
酷！现在我们向项目 2 添加任务和里程碑
可视化所有项目
为了合并我们创建的所有项目，我们将创建一个包含项目 1 和项目 2 的父项目
然后可视化所有项目
作者图片
点击这里查看上面的甘特图。
结论
恭喜你！您刚刚学习了如何用 Python 创建甘特图。创建一个，并展示给你的队友和经理。他们会很高兴能够在一个地方可视化所有项目和任务。
在Github repo中，您可以随意使用本文的代码。
我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上与我联系。
在 Python 中可视化和分析蛋白质
数据科学
生物蛋白组学
人类生物学极其复杂。即使我们的理解越来越多，我们的答案只会发现越来越多的问题。人类基因组计划的完成给了许多科学家信心，我们可以通过基因组学解决生物学中的紧迫问题。然而，随着我们对生物学理解的加深，我们已经认识到其他因素会影响生物体基因组的利用。因此，新的研究领域诞生了，以解决这些相互联系和灵活的领域，包括转录组学(mRNA 的研究)和蛋白质组学(蛋白质的研究)。
作者 GIF
正如我在之前的博客中提到的，Biopython 软件包非常强大，可以简单地可视化和分析 DNA 和 RNA 序列。它还具有蛋白质分析能力！所以让我们开始吧。
蛋白质数据库是探索和下载蛋白质序列的一站式商店。PDB 为此开发了自己的文件格式——恰当地命名为. pdb。但随着更大、更复杂的蛋白质被分析，另一种格式被开发出来——CIF 和 mmCIF。CIF(晶体学信息文件)被开发用来存档研究晶体中原子排列的小分子晶体学实验。用 mmCIF 将 CIF 扩展到更大的分子(大分子，因此 mm ),并取代了 PDB 格式。[ 1
用 PDB 格式可视化
虽然 mmCIF 现在是标准，但仍有对 PDB 文件的传统支持。
让我们看看植物血凝素-L ，一种在某些豆类中发现的凝集素，如菜豆。
导入必要的包:
from Bio.PDB import *
import nglview as nv
import ipywidgets
现在我们将创建 Biopython 的 PDBParser 的一个实例，并使用 nglview 库来创建我们的交互式可视化。我们可以*移、缩放和旋转分子，甚至悬停以获取特定的原子信息。
pdb_parser = PDBParser()
structure = pdb_parser.get_structure("PHA-L", "Data/1FAT.pdb")
view = nv.show_biopython(structure)
作者图片
用 CIF 格式可视化
我们处理 CIF 文件的过程将非常相似，只是使用 MMCIF 解析器来代替！在这里，我们正在想象一个更大的蛋白质 6EBK ，或者脂质纳米盘中的电压激活 kv 1.2–2.1 桨嵌合体通道(一口…)
cif_parser = MMCIFParser()
structure = cif_parser.get_structure("6EBK", "fa/6ebk.cif")
view = nv.show_biopython(structure)
作者图片
访问蛋白质信息
页眉
获取蛋白质信息的最直接方式是通过标题，这是一个元数据字典，有 PDB 和 CIF 两种文件格式。
mmcif_dict = MMCIFDict.MMCIFDict("fa/1fat.cif")
len(mmcif_dict) # 689
这产生了一个关于蛋白质信息的大字典，包括对蛋白质排序的引用、结构信息、原子与原子的位置和角度以及化学成分。如你所见，这本词典有 689 个词条。
剩余序列
你想要分析的最重要的信息之一是蛋白质或多肽的残基——想想氨基酸——序列。因为蛋白质可以由几个多肽组成，我们使用一个框架来了解我们正在检查的组织水*。从整体结构，到单个原子。
我们文件中的结构对象遵循父子关系中的 SMCRA 体系结构:
- 一个 S 结构由模型组成
- 一个 M 模型由链条组成
- 链由残基(氨基酸)组成
- 一个Re 由ATom 组成
有许多方法可以解析结构元数据以返回蛋白质的残基序列。以下是三种方式:
# .get_residues() method in a loop
for model in structure:
for residue in model.get_residues():
print(residue)# .get_residues() method as generator object
residues = structure.get_residues() # returns a generator object
[item for item in residues]# .unfold_entities - keyword for each level of the SMCRA structure
Selection.unfold_entities(structure, "R") # R is for residues
构建多肽
得到上面的残基序列会返回整个蛋白质结构的序列，但是蛋白质通常由几个较小的多肽组成，我们可能想要单独分析它们。Biopython 通过可以产生这些单独多肽的多肽构建体来实现这一点。
polypeptide_builder = CaPPBuilder()
counter = 1for polypeptide in polypeptide_builder.build_peptides(structure):
seq = polypeptide.get_sequence()
print(f"Sequence: {counter}, Length: {len(seq)}")
print(seq)
counter += 1# Sequence: 1, Length: 36
# SNDIYFNFQRFNETNLILQRDASVSSSGQLRLTNLN
# Sequence: 2, Length: 196
# NGEPRVGSLGRAFYSAPIQIWDNTTGTVASFATSFT...ASKLS
# Sequence: 3, Length: 233
# SNDIYFNFQRFNETNLILQRDASVSSSGQLRLTNLN...ASKLS
# Sequence: 4, Length: 36
# SNDIYFNFQRFNETNLILQRDASVSSSGQLRLTNLN
# Sequence: 5, Length: 196
# NGEPRVGSLGRAFYSAPIQIWDNTTGTVASFATSFT...ASKLS
# Sequence: 6, Length: 35
# SNDIYFNFQRFNETNLILQRDASVSSSGQLRLTNL
# Sequence: 7, Length: 196
# NGEPRVGSLGRAFYSAPIQIWDNTTGTVASFATSFT...ASKLS
分析残基序列
所以现在我们有了这 7 条链的残基序列，但是我们也有了很多分析这些序列的方法。
from Bio.SeqUtils.ProtParam import ProteinAnalysis
唯一需要注意的是。上面的 get_sequences()返回一个 Biopython Seq()对象——查看我之前的博客以深入了解 Seq()对象及其功能——而 ProteinAnalysis 需要一个字符串。
analyzed_seq = ProteinAnalysis(str(seq))
我们现在准备运行以下方法来建立对我们序列的理解！
分子量
我们可以计算多肽的分子量。
analyzed_seq.molecular_weight()
# 4176.51669
肉汁
蛋白质肉汁返回您输入的蛋白质序列的肉汁(亲水性的大*均值)值。通过将每个残基的亲水性值相加并除以序列长度来计算肉汁值(Kyte 和 Doolittle1982).2
值越高，疏水性越强。值越低，亲水性越强。我们后面会讨论如何通过残基疏水性生成残基。
**analyzed_seq.gravy()
# -0.5611**
氨基酸计数
我们可以很容易地计算出每种氨基酸的数量。
**analyzed_seq.count_amino_acids()
# {'A': 1,
'C': 0,
'D': 2,
'E': 1,
'F': 3,
'G': 1,
'H': 0,
'I': 2,
'K': 0,
'L': 5,
'M': 0,
'N': 6,
'P': 0,
'Q': 3,
'R': 3,
'S': 5,
'T': 2,
'V': 1,
'W': 0,
'Y': 1}**
氨基酸百分比
以及序列中每个氨基酸的百分比！
**analyzed_seq.get_amino_acids_percent()
# {'A': 0.027777777777777776,
'C': 0.0,
'D': 0.05555555555555555,
'E': 0.027777777777777776,
'F': 0.08333333333333333,
'G': 0.027777777777777776,
'H': 0.0,
'I': 0.05555555555555555,
'K': 0.0,
'L': 0.1388888888888889,
'M': 0.0,
'N': 0.16666666666666666,
'P': 0.0,
'Q': 0.08333333333333333,
'R': 0.08333333333333333,
'S': 0.1388888888888889,
'T': 0.05555555555555555,
'V': 0.027777777777777776,
'W': 0.0,
'Y': 0.027777777777777776}**
二级结构
一个非常有用的方法。secondary _ structure _ fraction()-返回三种经典二级结构中的氨基酸比例。这些是β折叠、α螺旋和转角(残基改变方向的地方)。
图片由托马斯·沙菲在维基媒体的 CC BY-SA 4.0 许可下提供。
**analyzed_seq.secondary_structure_fraction() # helix, turn, sheet
# (0.3333333333333333, 0.3333333333333333, 0.19444444444444445)**
蛋白质秤
蛋白质尺度是一种使用滑动窗口测量肽序列长度上残基的某些属性的方法。标度由基于不同物理和化学性质的每种氨基酸的值组成，例如疏水性、二级结构趋势和表面可及性。与一些链级测量(如整体分子行为)相反，尺度允许对序列的较小部分将如何表现有更细粒度的理解。
**from Bio.SeqUtils.ProtParam import ProtParamData**
一些常见的秤包括:
- kd → Kyte & Doolittle 疏水性指数[ 原文
- 弹性→标准化*均弹性参数(B 值)[ 原文
- hw → Hopp & Wood 亲水性指数[ 原文
- em → Emini 表面分数概率(表面可达性)[ 原著
可在这里找到一些常见秤的文档。
让我们以疏水性指数(kd)为例。这是一个等级，每个残基都有一个代表其疏水性水*的相关值。
**kd = {"A": 1.8, "R": -4.5, "N": -3.5, "D": -3.5, "C": 2.5,
"Q": -3.5, "E": -3.5, "G": -0.4, "H": -3.2, "I": 4.5,
"L": 3.8, "K": -3.9, "M": 1.9, "F": 2.8, "P": -1.6,
"S": -0.8, "T": -0.7, "W": -0.9, "Y": -1.3, "V": 4.2}**
正值是疏水的。异亮氨酸(I)和缬氨酸(V)最疏水，精氨酸(R)和赖氨酸(K)最亲水。疏水性残基通常位于多肽的内部，而亲水性残基位于外部，因此这一尺度也给出了该多肽可能如何折叠的意义。
蛋白质规模分析需要设置一个窗口大小，在此范围内计算*均值。您还可以使用“edge”关键字来指定相邻残基的重要性，基本上是将它们的重要性加权到窗口的*均值。
**analysed_seq.protein_scale(window=7, param_dict=ProtParamData.kd)# [-0.7571428571428572,
-0.2428571428571429,
-0.24285714285714288,
-0.38571428571428573,
-0.6285714285714287,
-0.942857142857143,
-1.842857142857143,
-1.442857142857143,
-2.3428571428571425,
-1.3000000000000003,
-0.01428571428571433,
0.1285714285714285,
0.1285714285714285,
-0.014285714285714235,
-0.4142857142857143,
0.3428571428571428,
-0.31428571428571417,
-0.35714285714285715,
-1.014285714285714,
-0.6285714285714284,
-0.10000000000000002,
0.3428571428571429,
-0.4142857142857142,
0.24285714285714285,
-1.0,
-0.34285714285714286,
-0.32857142857142857,
-0.7142857142857143,
-0.1142857142857144,
-0.11428571428571435]**
把它绑在一起
让我们把所有的方法放在一起，创建一个脚本，它可以遍历我们结构中的每个链，并运行一些常规分析。我们将创建一个空容器，然后用每个序列的关键信息的字典填充它。在这个嵌套结构中，我们可以像对 Python 中的任何容器一样进行切片，以选择单个条目。
**# Create empty list for chains
all_seqs = []
counter = 1# For each polypeptide in the structure, run protein analysis methods and store in dictfor pp in ppb.build_peptides(structure):
seq_info = {} # create an empty dict
seq = pp.get_sequence() # get the sequence like above
analyzed_seq = ProteinAnalysis(str(seq)) # needs to be a str # Specify dict keys and values
seq_info['Sequence Number'] = counter # set sequence id
seq_info['Sequence'] = seq # store BioPython Seq() object
seq_info['Sequence Length'] = len(seq) # length of seq
seq_info['Molecular Weight'] = analyzed_seq.molecular_weight()
seq_info['GRAVY'] = analyzed_seq.gravy() # hydrophobicity
seq_info['AA Count'] = analyzed_seq.count_amino_acids()
seq_info['AA Percent'] = analyzed_seq.get_amino_acids_percent() # tuple of (helix, turn, sheet)
seq_info['Secondary Structure'] = \
analyzed_seq.secondary_structure_fraction()
# Update all_seqs list and increase counter
all_seqs.append(seq_info)
counter += 1**
选择第一个序列将返回包含我们的分析和值的字典！
**all_seqs[0] # select the first sequence# {'Sequence Number': 1,
'Sequence': Seq('SNDIYFNFQRFNETNLILQRDASVSSSGQLRLTNLN'),
'Sequence Length': 36,
'Molecular Weight': 4176.52,
'GRAVY': -0.5611,
'Amino Acid Count': {'A': 1,
'C': 0,
'D': 2,
'E': 1,
'F': 3,
'G': 1,
'H': 0,
'I': 2,
'K': 0,
'L': 5,
'M': 0,
'N': 6,
'P': 0,
'Q': 3,
'R': 3,
'S': 5,
'T': 2,
'V': 1,
'W': 0,
'Y': 1},
'Amino Acid Percent': {'A': 0.027777777777777776,
'C': 0.0,
'D': 0.05555555555555555,
'E': 0.027777777777777776,
'F': 0.08333333333333333,
'G': 0.027777777777777776,
'H': 0.0,
'I': 0.05555555555555555,
'K': 0.0,
'L': 0.1388888888888889,
'M': 0.0,
'N': 0.16666666666666666,
'P': 0.0,
'Q': 0.08333333333333333,
'R': 0.08333333333333333,
'S': 0.1388888888888889,
'T': 0.05555555555555555,
'V': 0.027777777777777776,
'W': 0.0,
'Y': 0.027777777777777776},
'Secondary Structure': (0.3333333333333333,
0.3333333333333333,
0.19444444444444445)}**
我们也可以很容易地选择特定的值。
**all_seqs[0]['Sequence']# Seq('SNDIYFNFQRFNETNLILQRDASVSSSGQLRLTNLN')all_seqs[0]['Molecular Weight']# 4176.52**
结论
Biopython 不仅使处理 DNA 序列变得容易，它还可以用于蛋白质组学来可视化和分析蛋白质。它为常规蛋白质分析提供了强大而灵活的方法，可用于根据您的特定需求开发定制管道。我知道，随着我继续深入研究 Biopython 所提供的功能，我将会继续留下深刻的印象，因此您可以期待将来有更多的文章介绍它的功能。
和往常一样，本文中描述的所有代码和依赖项都可以在这个 repo 中找到，随着我对 Biopython 的探索，我将继续更新这个 repo。我希望本指南向您展示用 Biopython 开始自己的生物信息学项目是多么简单，我期待看到您能创造出什么！
连接
我一直在寻找连接和探索其他项目！你可以在 GitHub 或 LinkedIn 上关注我，并在媒体上查看我的其他故事。我也有一个推特！
来源
[1] R. K. Green，PDB 结构和 PDBx/mmCIF 格式的初学者指南。
[2] J. Kyte 和 R.F. Doolittle，一种显示蛋白质亲水特性的简单方法 (1983)，J. Mol .生物。157 (1): 105–32.
可视化和预处理图像数据集
使用 Tensorbay 和 SkImage 对大型数据集进行可视化和预处理
来源:作者
当创建计算机视觉项目或模型时，我们通常使用大型数据集。不仅图像数据集的大小比文本数据集大，而且使用了更多的图像，因此我们的模型不会过拟合，并且具有高性能。
我们在哪里可以找到新的、新鲜的数据集？鉴于它们的大小，下载可能吗？我们都曾在 MNIST、FashionMNIST、CIFAR-10 等数据集上工作过。，但是这些都是旧的，用过很多次了。一旦我们访问了新的数据集，我们如何在不下载到本地的情况下轻松使用它们？
答案是使用来自 Graviti 的 TensorBay。TensorBay 是一个数据集管理*台，可自动化和简化整个流程，包括数据托管、版本控制和数据可视化。为了便于集成，Graviti 为 TensorBay 开发了一个基于 Python 的 SDK 来执行这些服务。
对于本地数据集的可视化，我们可以使用 Pharos ，它是 TensorBay SDK 的一个插件。Pharos 发布了一个 Flask 应用程序，允许我们可视化数据并检查其注释。这些可视化有助于识别我们的数据是如何组织的，以及数据中是否存在异常。
对于图像处理，使用了一个 Python 库 Skimage。Skimage 包含不同的算法，可以用来编辑图像。
在本文中，我们将使用 TensorBay、Pharos 和 Skimage 探索图像数据可视化。让我们开始吧…
为访问密钥创建 Graviti 帐户
在可视化数据之前，您需要有一个访问键来访问数据和分叉数据集。除了可视化，这个键还可以让您访问其他功能，如版本控制、数据集创建等。
上面给出的链接可以用来在 Graviti 上创建一个帐户。注册后，您可以从开发人员工具部分生成并使用您的访问密钥。
分叉数据集
下一步是派生数据集。 Graviti 提供了 1000 多个数据集，可以很容易地进行相应的分叉和使用。您可以在此选择任何数据集。对于本文，我们使用的是 17 类别花数据集。
来源:作者
使用 Pharos 可视化数据集
要可视化一个数据集，请登陆它在 TensorBay 的主页，使用 Pharos 启动 Flask 应用程序。
来源:作者
创建 Jupyter 笔记本
最后一步是创建一个 Jupyter 笔记本，用于加载分叉数据集。但是首先，我们需要使用下面给出的命令安装所需的 TensorBay 及其插件 Pharos Python 库。
在下面显示的代码中，数据集在我们的本地机器上被读取，图像从 URL 中获取并保存在一个列表中，该列表将用于预处理。请记住，您需要提供自己的访问键，并派生出您想要使用的数据。
from tensorbay import GAS
from tensorbay.dataset import Segment
from tensorbay.dataset import Data, Dataset
import requests
from PIL import ImageACCESS_KEY = “Your Access Key”
gas = GAS(ACCESS_KEY)dataset_client = gas.get_dataset(“Flower17–1”)img_list=[]segments = dataset_client.list_segment_names()segment = Segment(“default”, dataset_client)for data in segment:
fp = data.open()
img_list.append(Image.open(requests.get(fp.url,
stream=True).raw))
img_list
来源:作者
在上面的图片中，你可以看到我们如何从 URL 加载不同的图片。现在我们将对将要处理的图像进行可视化，然后对这些图像进行预处理，这些图像存储在一个列表中。
plt.figure(figsize=(11,11))for i in range(1,10):plt.subplot(3,3,i)plt.tight_layout()plt.imshow(img_list[i-1])plt.title(‘Flower’)plt.xlabel(img_list[i-1].shape[1], fontsize=10)plt.ylabel(img_list[i-1].shape[0], fontsize=10)
来源:作者
#converting image to numpy arrayimport numpy as npimage1 = np.array(img_list[0])image1
来源:作者
image1.shape
来源:作者
image1.size
来源:作者
#Converting Grayscale
from skimage.color import rgb2gray
grayscale = rgb2gray(img_list[0])#Edge Detection
from skimage import filters
ed_sobel = filters.sobel(grayscale)
imshow(ed_sobel, cmap=’gray’);
边缘(来源:作者)
from skimage.exposure import histogram
hist, hist_centers = histogram(grayscale)#Plotting the Image and the Histogram of gray valuesfig, axes = plt.subplots(1, 2, figsize=(8, 3))axes[0].imshow(grayscale, cmap=plt.cm.gray)axes[0].axis(‘off’)axes[1].plot(hist_centers, hist, lw=2)axes[1].set_title(‘histogram of gray values’)
来源:作者
在 Graviti 使用不同的数据集尝试这个过程，并使用 Pharos 创建可视化。请在回复部分留下你的评论，让我知道结果如何。
使用 Streamlit 可视化音频管道
检查浏览器中增强功能的效果
当处理图像数据时，从业者经常使用增强。扩充是人为随机改变数据以增加多样性的技术。将这种变换应用于训练数据使得模型更加健壮。对于图像数据，常用的方法是旋转、调整大小或模糊。转换的效果很容易看到和理解。甚至可以快速掌握多个增强，如下例所示:
示例性增强。一个 TensorFlow 教程后作者创建的图片。
这种增强并不局限于图像(尽管它们在那里很受欢迎)。对于音频数据，有类似的方法来修改训练数据。不利的一面是，人们不能同时观察增强的效果，而必须手动聆听个别的转换。但是，您可以将音频数据可视化，而不是按顺序聆听所有样本。通过视觉化改变，你将检查转移到图像世界。现在，看一眼比同时听十个样本能告诉你更多。当您为新任务构建原型并希望快速检查数据集的变化时，这很有帮助。
这篇文章并没有展示如何在使用 TensorFlow 的时候增加音频数据。我在最*的帖子中对此进行了弥补。
要创建一个简单的应用程序来完成您正在寻找的功能，谢天谢地，您不必再深入 GUI 编程了。相反，你可以利用像 streamlit 这样的工具来可视化数据脚本。将这个与 audiomentations 包结合起来，你可以在两三个下午内构建一个可视化工具。
让我们看看这样的应用程序是什么样子的:
示例性应用的概述。图片由作者提供。你可以在这里复制代码，在这里现场试用。
在左侧边栏，您构建了您的增强管道。选择一些转换；可能包括添加噪声(AddGaussianNoise)和掩蔽频率(FrequencyMask)。然后，上传一个音频文件或选择一个提供的样本。点击“应用”后，您可以在中心检查效果。
最左边的列包含文件的谱图表示。这种可视化显示了给定时间步长下频率的功率。中间一栏包括波形，最右边一栏显示音频播放器。
侧栏是通过调用以下代码创建的:
我们首先为所有可能的扩展创建复选框，并通过在下面放置一个水*栏来直观地划分这一部分。下一部分添加文件选择功能，最后一个按钮启动可视化过程。
主布局通过以下方法创建:
我们首先绘制未更改的音频文件，然后应用管道的单独转换。增强 A 的输出是增强 b 的输入。为了区分各个变化，我们添加一个小标题，就这样。
更多的代码在后台工作，但是没有太多令人兴奋的事情发生。如果你无论如何都想深入了解它，那么就在这里浏览这些行。要查看运行中的完整应用程序，您有两种选择:
首先，你可以在你的浏览器这里现场试用。
其次，你可以克隆库，安装需要的包，然后在命令行运行streamlit run visualize _ transformation . py。然后，Streamlit 在本地的http://localhost:8501/上呈现并提供您的 python 脚本。
最*，这个帖子得到了一个兄弟，它展示了如何将增强应用于(TensorFlow)音频数据集。你可以在这里找到说明。
可视化丹佛的公共汽车轨迹
实践教程
使用 Python 和 Unfolded 可视化 RTD 的实时总线数据馈送
区域交通区，通常被称为 RTD，是丹佛运营公共交通服务的区域机构。RTD 有一个开放的数据*台，发布:
- 时刻表数据，包括完整的时刻表和路线配置
- RTD 公交服务的实时数据，包括作为 GTFS 实时反馈的到达/离开预测和车辆位置信息
使用展开的最终可视化(Abdullah Kurkcu 图像)
我们将使用实时数据馈送来首先存储一些数据，然后使用新发布的 explode studio 来可视化公共汽车运动。利用优步的开普勒定律可以达到同样的结果。
在寻找如何下载 GTFS 实时数据的例子时，我看到了这篇精美的文章和代码，展示了如何下载这样的地理空间数据。
https://medium.com/swlh/visualizing-istanbul-bus-traffic-with-python-and-keplergl-a84895788825
我按照奥赞·卡拉的方法下载了丹佛地区的 GTFS 数据，并对代码做了一些修改，还增加了一些额外的后处理步骤来计算总线速度。
我试图下载数据时遇到的问题是，GTFS 提要中有一些空闲的总线，这改变了提要的格式。例如，如果车辆空闲，则 tripID/stopID 等标签不存在。
让我们看看计划车辆的常规饲料:
如果公共汽车还没有时间表，那么 JSON 就是这样的:
如您所见，没有时间表的公共汽车没有 stopId、tripId、routeId 等。这就是为什么我们必须在尝试读取它们之前检查这些标签是否存在。让我们在整个数据下载过程中导入我们需要的库。
下面的虚拟函数将检查可能存在的标签，并使用数据或 NA 填充它们。
下面的函数将下载我们需要的数据。为了能够从 RTD 的 GTFS 实时数据馈送下载数据，您将需要 HTTP 基本身份验证凭据。
我们需要每分钟调用这个函数，因为公共汽车每分钟都会发送位置更新。
好了，我们现在有了我们需要的一切。您可以想运行这个函数多长时间就运行多长时间，但是我认为一个小时的数据足以构建一个很好的可视化。我让它运行了一天，并存储了数据。以下函数将 busdata 保存为 geoJSON 文件。它以 Kepler.gl 或 Unfolded 可以动画的方式格式化。
另外，如果你想计算公共汽车的速度，我写了下面这段混乱的代码。我想计算给定路线的*均公交车速度。这就是为什么该函数会计算每次 ping 之间的速度，并取该路线所有这些值的*均值。
不要忘记将其保存为新的 geoJSON 文件。
我们需要的一切都准备好了。你可以去 kepler.gl 或者 unfolded.ai 来可视化这个 geoJSON。我将使用展开，因为我有一个老朋友在那家非常成功的公司工作。
登录 studio.unfolded.ai ，点击右上方“新地图”。这将把你带到要求你上传数据的屏幕。
只需找到您保存的 geojson 文件，并将其放在此屏幕上。展开将自动识别格式，并为您创建一个动画时间线。我们唯一需要改变的是颜色。我想根据公交车的*均速度给这些轨迹上色。
好吧，我撒谎了，这不是我唯一要改变的。我也会增加步道的长度。更长的步道看起来更酷:)谢谢展开！(图片由阿卜杜拉·库尔库提供)
仅此而已！这是最终产品的视频。你可能会看到一些飞行器。我认为原因是他们打开/关闭追踪器或者失去了与服务器的连接。
(阿卜杜拉·库尔库的视频)
用 Python 可视化气候变化数据
使用 xarray 和 cartopy Python 库创建气候变化图表
2020 年全球气温异常(图片由作者提供)-数据由美国宇航局/GISS 提供
不可否认的事实是，气候变化是当今时代人类面临的最大挑战。全球*均气温持续上升，IPCC 指出的上升幅度应限制在比工业化前水*高 1.5 摄氏度，才有希望减轻气候变化的有害影响。这个目标是在巴黎协定中设定的，该协定于 2015 年被世界上几乎所有国家采纳。然而不幸的是，几乎没有采取什么行动来解决这个问题，不断发表的令人担忧的科学研究突出了这一点。
新冠肺炎疫情导致了人类活动的大多数方面的下降，以及随之而来的化石燃料燃烧和二氧化碳排放的减少。尽管如此， 2020 年是历史上最热的年份之一，全球各地都有极端天气事件的记录。此外，根据发表在《冰冻圈杂志》上的研究，全球冰盖正在以创纪录的速度融化，这符合 IPCC 的最坏情况。其他科学家声称，气候变化和生物多样性的丧失对人类的生存构成了前所未有的威胁，其程度甚至连专家都难以理解。
根据皮尤研究中心进行的调查，全球大约 70%的人认为气候变化是他们国家的主要威胁。与 2013 年相比，这一比例显著增加，但仍然很低，因为每个人都必须了解这一问题的严重性。让公众了解气候变化的一个方法是创建相关数据的信息性和美观的可视化。在这篇文章中，我将教你如何使用 Python 制作温度变化的地图和动画。
GIS temp 数据集
我们的可视化基于美国宇航局 GISTEMP v4 数据集，该数据集结合了 NOAA GHCN v4(气象站)和 ERSST v5(海洋区域)，从而产生了我们星球整个表面气候可变性的全面记录。该数据集包括 1880 年以来的温度，每月一次，由美国国家航空航天局用于监测全球和区域气候变化。没有提供绝对温度，而是给出了与基准期(1951-1980 年)相比的异常。该数据集以 netCDF 格式在GIS temp 网站免费提供。如果你想了解关于数据集的更多细节，以及美国宇航局分析数据集以生成气候变化图表的方式，你可以查看相关论文。
Xarray 和 Cartopy 图书馆
NetCDF 是一种支持面向数组的科学数据的文件格式，通常用于气候学和气象学等领域。有各种各样的 Python 库支持它，但是我们将使用 xarray，因为它是最强大的。Xarray 受流行的 pandas 库的启发，将其大部分功能扩展到多维数组。该库构建在 NumPy 之上，易于集成到 Python 机器学习工作流中。最后，它还具有强大的科学数据集可视化绘图功能。Cartopy 是一个用于地理空间数据可视化的 Python 库，使科学家能够创建出版物质量的地图。它与 xarray 集成得很好，所以我们要用它来生成我们的地图。
可视化 GISTEMP 数据
下面的代码可以在使用 Python 3 的 Jupyter 笔记本上执行，如果您愿意，甚至可以使用 Google Colab。首先，我们将通过使用open_dataset() xarray 函数导入必要的库并加载 GISTEMP 数据集。
(图片由作者提供)
打印 xarray 数据集输出一些关于其属性和变量的基本信息。正如我们所看到的，数据集是一个 2 ×2 的温度异常网格，每月一次。我们现在要绘制 2020 年全球气温异常图。
2020 年全球气温异常(图片由作者提供)
首先，我们将 xarray 数据集重新采样为一年一次的频率，因为这样更便于操作。之后，我们创建一个卡通地图，并添加世界上每个国家的边界。然后，我们使用imshow()方法绘制 xarray 数据。我们还启用了双三次插值，因此图形看起来更具视觉吸引力。我们现在要把我们的重点转移到欧洲国家，通过绘制该地区的地图。
2020 年欧洲气温异常(图片由作者提供)
我们更改了制图地理轴的范围，以仅绘制我们偏好的区域，而不是整个地图。在这种情况下，我们绘制了欧洲大陆，但您可以选择任何您喜欢的地区，这取决于您希望与哪些受众共享图表。我们现在要制作同一地区过去几十年温度变化的动画。
我们现在使用FuncAnimation() Matplotlib 函数来生成 1950-2020 年期间的动画，而不是生成静态图表。使用了一个名为animate()的附加方法，指定动画的每一帧将如何生成。这个函数作为一个参数传递给FuncAnimation()，同时传递的还有我们想要制作动画的时间段。之后，我们使用 FFmpeg 将动画保存为 MP4 视频。在所有主流操作系统上安装 FFmpeg 的下载链接和说明可从这里获得。
结论
为气候变化创建信息丰富且吸引人的图表是一个相对简单的过程，我希望这篇教程能帮助你完成这个任务。由 NASA 等知名组织免费提供的科学数据集，以及众多开源工具，使得每个人都可以进行气候数据分析。我鼓励你们使用 GISTEMP 或其他类似的数据集，并告知你们地区的公民有关气候变化的信息。我们都可以为应对这一巨大挑战做出贡献，而利用数据是实现这一目标的一个很好的方式。如果你想克隆这个项目的 Github 库，可以在这里找到。欢迎在评论中分享你的想法，或者在 LinkedIn 上关注我，我经常在那里发布关于数据科学、气候变化和其他主题的内容。你也可以访问我的个人网站或者查看我的新书，名为用 PyCaret 简化机器学习。
参考
[1]斯莱特，托马斯等，“地球的冰不*衡。”冰冻圈 15.1(2021):233–246。
[2]布拉德肖，科里·贾等人，“低估避免可怕未来的挑战。”保护科学前沿 1 (2021): 9。
[3]汉森，詹姆斯，等，“全球地表温度变化。”地球物理学评论 48.4 (2010)。
用 Python 的 Matplotlib 可视化集群
如何提高聚类分析的可视化
集群肯定不是什么新鲜事物。MacQueen 在 1967 年开发了 k-means 算法，从那以后，人们开发了许多其他实现和算法来执行对数据进行分组的任务。
散点图—作者提供的图片
本文将探讨如何用散点图来改进我们的集群的可视化。
散点图
让我们从加载和准备数据开始。我将使用口袋妖怪统计数据的数据集。
import pandas as pddf = pd.read_csv('data/Pokemon.csv')# prepare data
types = df['Type 1'].isin(['Grass', 'Fire', 'Water'])
drop_cols = ['Type 1', 'Type 2', 'Generation', 'Legendary', '#']
df = df[types].drop(columns = drop_cols)
df.head()
数据框-作者提供的图片
由于这篇文章与其说是关于集群，不如说是关于可视化，我将在下面的例子中使用一个简单的 k-means。
我们将计算三个集群，获得它们的质心，并设置一些颜色。
from sklearn.cluster import KMeans
import numpy as np# k means
kmeans = KMeans(n_clusters=3, random_state=0)
df['cluster'] = kmeans.fit_predict(df[['Attack', 'Defense']])# get centroids
centroids = kmeans.cluster_centers_
cen_x = [i[0] for i in centroids]
cen_y = [i[1] for i in centroids]
## add to df
df['cen_x'] = df.cluster.map({0:cen_x[0], 1:cen_x[1], 2:cen_x[2]})
df['cen_y'] = df.cluster.map({0:cen_y[0], 1:cen_y[1], 2:cen_y[2]})# define and map colors
colors = ['#DF2020', '#81DF20', '#2095DF']
df['c'] = df.cluster.map({0:colors[0], 1:colors[1], 2:colors[2]})
然后，我们可以将用于创建聚类的字段传递给 Matplotlib 的散点图，并使用我们创建的“c”列根据聚类在图表中绘制点。
import matplotlib.pyplot as pltplt.scatter(df.Attack, df.Defense, c=df.c, alpha = 0.6, s=10)
散点图—作者提供的图片
酷毙了。这是聚类数据集的基本可视化，即使没有太多信息，我们也可以开始了解我们的聚类以及它们是如何划分的。
多维度
我们经常使用多个变量对数据进行聚类，而散点图只能显示两个变量。可视化三个以上变量有几种选择，但都有应该考虑的缺点。
我们可以使用标记的大小，并使其成为一个气泡图，但这不是一个最佳的解决方案。我们无法将第三个变量与其他变量进行比较，因为它们的编码不同。
例如，我们可以通过查看我们之前制作的图表来判断某个记录的攻击或防御是否较高。但是如果我们把速度作为大小加入，我们就无法和其他两个变量进行比较。
plt.scatter(df.Attack, df.Defense, c=df.c, s=df.Speed, alpha = 0.6)
气泡图—作者图片
3D 图也可以对第三个变量进行编码，但它也可能会令人困惑，有时甚至会产生误导——这是因为取决于我们如何看待图表，它可能会给我们错误的印象。
3D 散点图—图片由作者提供
不过，3D 散点图还是很有帮助的，尤其是在它们不是静态的情况下。
根据您的环境，很容易添加一些与 Matplotlib 的交互性。
一些 ide 默认会有这个；其他环境将需要扩展和一个神奇的命令，如 Jupyter Lab 上的“Matplotlib Widget”或 Jupyter notebooks 上的“Matplotlib Notebook”。
通过改变我们看图表的角度，我们可以更仔细地检查它，避免误解数据。
from mpl_toolkits.mplot3d import Axes3D
%matplotlib widgetcolors = ['#DF2020', '#81DF20', '#2095DF']kmeans = KMeans(n_clusters=3, random_state=0)df['cluster'] = kmeans.fit_predict(df[['Attack', 'Defense', 'HP']])
df['c'] = df.cluster.map({0:colors[0], 1:colors[1], 2:colors[2]})fig = plt.figure(figsize=(26,6))ax = fig.add_subplot(131, projection='3d')
ax.scatter(df.Attack, df.Defense, df.HP, c=df.c, s=15)ax.set_xlabel('Attack')
ax.set_ylabel('Defense')
ax.set_zlabel('HP')plt.show()
3D 散点图—图片由作者提供
总的来说，它们仍然是一个非常有限的解决方案。
我认为最好的方法是使用多个散点图，要么以矩阵格式，要么通过变量之间的变化。你也可以考虑使用一些数据简化方法，如主成分分析法，将你的变量合并成更少的因素。
释文
现在，让我们开始改善我们的视觉化。
如果数据可视化是讲故事，那么注释就相当于我们故事中的叙述者。他们应该帮助观众理解和关注什么是重要的，而不是占用太多的情节空间。
我们将添加基础知识、标题、标签和图例。
### BUILD A TWO DIMENSIONS CLUSTER AGAIN ###
# k means
kmeans = KMeans(n_clusters=3, random_state=0)
df['cluster'] = kmeans.fit_predict(df[['Attack', 'Defense']])# get centroids
centroids = kmeans.cluster_centers_
cen_x = [i[0] for i in centroids]
cen_y = [i[1] for i in centroids]
## add to df
df['cen_x'] = df.cluster.map({0:cen_x[0], 1:cen_x[1], 2:cen_x[2]})
df['cen_y'] = df.cluster.map({0:cen_y[0], 1:cen_y[1], 2:cen_y[2]})# define and map colors
colors = ['#DF2020', '#81DF20', '#2095DF']
df['c'] = df.cluster.map({0:colors[0], 1:colors[1], 2:colors[2]})#####PLOT#####
from matplotlib.lines import Line2Dfig, ax = plt.subplots(1, figsize=(8,8))
# plot data
plt.scatter(df.Attack, df.Defense, c=df.c, alpha = 0.6, s=10)# create a list of legend elemntes
## markers / records
legend_elements = [Line2D([0], [0], marker='o', color='w', label='Cluster {}'.format(i+1),
markerfacecolor=mcolor, markersize=5) for i, mcolor in enumerate(colors)]# plot legend
plt.legend(handles=legend_elements, loc='upper right')# title and labels
plt.title('Pokemon Stats\n', loc='left', fontsize=22)
plt.xlabel('Attack')
plt.ylabel('Defense')
散点图—作者提供的图片
酷，现在我们可以清楚地了解这个图表是关于什么的了。
我们也可以给观众一些参考点。显示质心并画出*均值或百分位数的参考线有助于解释我们的聚类。
from matplotlib.lines import Line2Dfig, ax = plt.subplots(1, figsize=(8,8))
# plot data
plt.scatter(df.Attack, df.Defense, c=df.c, alpha = 0.6, s=10)
# plot centroids
plt.scatter(cen_x, cen_y, marker='^', c=colors, s=70)# plot Attack mean
plt.plot([df.Attack.mean()]*2, [0,200], color='black', lw=0.5, linestyle='--')
plt.xlim(0,200)# plot Defense mean
plt.plot([0,200], [df.Defense.mean()]*2, color='black', lw=0.5, linestyle='--')
plt.ylim(0,200)# create a list of legend elemntes
## average line
legend_elements = [Line2D([0], [0], color='black', lw=0.5, linestyle='--', label='Average')]
## markers / records
cluster_leg = [Line2D([0], [0], marker='o', color='w', label='Cluster {}'.format(i+1),
markerfacecolor=mcolor, markersize=5) for i, mcolor in enumerate(colors)]
## centroids
cent_leg = [Line2D([0], [0], marker='^', color='w', label='Centroid - C{}'.format(i+1),
markerfacecolor=mcolor, markersize=10) for i, mcolor in enumerate(colors)]
# add all elements to the same list
legend_elements.extend(cluster_leg)
legend_elements.extend(cent_leg)
# plot legend
plt.legend(handles=legend_elements, loc='upper right', ncol=2)# title and labels
plt.title('Pokemon Stats\n', loc='left', fontsize=22)
plt.xlabel('Attack')
plt.ylabel('Defense')
散点图—作者提供的图片
现在很容易分辨出集群是如何划分的。
红色组的攻击和防御值最高，而蓝色组最低，绿色组通常更接**均值。
线
说明我们的集群工作与其结果一样重要。在 k-means 中，由于我们正在处理距离，将点连接到它们各自的质心可以帮助我们可视化算法实际在做什么。
fig, ax = plt.subplots(1, figsize=(8,8))
# plot data
plt.scatter(df.Attack, df.Defense, c=df.c, alpha = 0.6, s=10)
# plot centroids
plt.scatter(cen_x, cen_y, marker='^', c=colors, s=70)
# plot lines
for idx, val in df.iterrows():
x = [val.Attack, val.cen_x,]
y = [val.Defense, val.cen_y]
plt.plot(x, y, c=val.c, alpha=0.2)# legend
legend_elements = [Line2D([0], [0], marker='o', color='w', label='Cluster {}'.format(i+1),
markerfacecolor=mcolor, markersize=5) for i, mcolor in enumerate(colors)]
legend_elements.extend([Line2D([0], [0], marker='^', color='w', label='Centroid - C{}'.format(i+1),
markerfacecolor=mcolor, markersize=10) for i, mcolor in enumerate(colors)])legend_elements.extend(cent_leg)
plt.legend(handles=legend_elements, loc='upper right', ncol=2)# x and y limits
plt.xlim(0,200)
plt.ylim(0,200)# title and labels
plt.title('Pokemon Stats\n', loc='left', fontsize=22)
plt.xlabel('Attack')
plt.ylabel('Defense')
连通散点图—图片由作者提供
现在，聚类和质心之间的关系已经完全清楚了，也更容易解释算法是如何工作的。
我们还可以看到每个分类中的值是如何分布的。
例如，红色值看起来比蓝色值离其质心更远。如果组的方差对我们的分析很重要，这样的图表可能是有效的。
我们还应该注意到，绿色和蓝色之间的区别在之前的可视化中并不明显。
散点图—作者提供的图片
即使它们具有不同的颜色，并且连接到不同的位置，那些用黑色圈出的记录在它们之间仍然比它们自己的分类中的大多数值更相似。
这种可视化使人更难察觉到这一点，并可能给人以不同分类的值完全不同的印象。
凸包
另一个帮助我们可视化星团大小或分布的方法是在它周围画一个形状或一个阴影。手动这样做将花费很长时间，而且肯定不值得。
幸运的是，有一些方法可以实现自动化。
凸包是我们的数据点之间形成包围所有点的多边形的最小连接集，并且有系统地找到凸包的方法——也就是说，我们可以使用 Sklearn 来获得我们数据集的轮廓。
from scipy.spatial import ConvexHull
import numpy as npfig, ax = plt.subplots(1, figsize=(8,8))
# plot data
plt.scatter(df.Attack, df.Defense, c=df.c, alpha = 0.6, s=10)
# plot centers
plt.scatter(cen_x, cen_y, marker='^', c=colors, s=70)# draw enclosure
for i in df.cluster.unique():
points = df[df.cluster == i][['Attack', 'Defense']].values
# get convex hull
hull = ConvexHull(points)
# get x and y coordinates
# repeat last point to close the polygon
x_hull = np.append(points[hull.vertices,0],
points[hull.vertices,0][0])
y_hull = np.append(points[hull.vertices,1],
points[hull.vertices,1][0])
# plot shape
plt.fill(x_hull, y_hull, alpha=0.3, c=colors[i])
plt.xlim(0,200)
plt.ylim(0,200)
突出显示的散点图-图片由作者提供
太好了。我们甚至可以插入多边形的线条，使数据周围的形状更加*滑。
from scipy import interpolatefig, ax = plt.subplots(1, figsize=(8,8))
plt.scatter(df.Attack, df.Defense, c=df.c, alpha = 0.6, s=10)
plt.scatter(cen_x, cen_y, marker='^', c=colors, s=70)
for i in df.cluster.unique():
# get the convex hull
points = df[df.cluster == i][['Attack', 'Defense']].values
hull = ConvexHull(points)
x_hull = np.append(points[hull.vertices,0],
points[hull.vertices,0][0])
y_hull = np.append(points[hull.vertices,1],
points[hull.vertices,1][0])
# interpolate
dist = np.sqrt((x_hull[:-1] - x_hull[1:])**2 + (y_hull[:-1] - y_hull[1:])**2)
dist_along = np.concatenate(([0], dist.cumsum()))
spline, u = interpolate.splprep([x_hull, y_hull],
u=dist_along, s=0, per=1)
interp_d = np.linspace(dist_along[0], dist_along[-1], 50)
interp_x, interp_y = interpolate.splev(interp_d, spline)
# plot shape
plt.fill(interp_x, interp_y, '--', c=colors[i], alpha=0.2)
plt.xlim(0,200)
plt.ylim(0,200)
*插值方法基于来自此线程的回复。
- *正如 Dragan Vidovic 在评论中指出的，我已经将参数 per=1 添加到了
splprep函数中。
突出显示的散点图-图片由作者提供
我们不应该把这些轮廓看得太重，因为它们不是实际的测量值。但是它们仍然很好地突出了星团，所以没有观众会错过它们。
总的来说，没有简单的方法来可视化集群。每个案例都是独特的，在决定向公众展示什么之前，我们应该做大量的实验。
提到我使用的例子是干净的也很重要。我使用一个简单的数据集和两个变量进行聚类。真实情况下，不会一直是这个样子。通常，画出质心的连线会使我们的图表污染太严重，几乎无法阅读。
最好从简单的事情开始:想象变量的每一个组合，找出更有意义的或者你可以自然展示你的洞察力的变量。然后你可以尝试其他的可视化和技术来突出你的发现。
我希望你学到了一些东西，喜欢我的文章。谢谢！
更多教程 | 酷炫玩意儿 | 推特
使用 pycohort 软件包可视化群组保持率
罗伯特·卡茨基在 Unsplash 上的照片
关于如何在 PyPi 上创建 Python 包的教程
订阅业务的主要收入来源是定期支付。可能会有额外的一次性服务，但选择额外收费的用户数量有限，这个数字将更难预测。这就是为什么订阅业务的财务健康状况最好用留存率来衡量。如果用户对产品或服务满意，他们可能会一直呆到他们的需求改变。这就是为什么应用程序中有什么样的保留功能以及如何呈现给用户非常重要，特别是那些正在进入取消漏斗以结束重复支付周期的用户。
为了以更详细的格式快速可视化保留率，企业利用基于时间的群组分析。群组由在特定时间范围内注册的用户组成，该时间范围可能具有从每周到每季度的粒度。对于每个群组，在每个时间段计算保留客户的百分比，直到最*一次。
如何阅读基于时间的队列分析图表？
以下是基于时间的群组分析图表示例。用户根据他们的订阅开始月份被分组。每一行代表一群用户。对于每个群体，第一栏中有一个初始保留率。这是在订阅开始日期后一个月仍未离开的用户的百分比。每行的比率代表订阅旅程中给定月份的保留率。这些比率是基于某个月之后剩余的用户数量除以开始时给定群组中的所有用户数量来计算的。让我们以 2020 年 1 月注册的用户群体为例。订阅开始两个月后，75%的订阅者仍然在那里。也就是说，前两个月的流失率是 25%。由于数据拉动将于 2021 年 4 月结束，这一群体还有 16 个月的时间。16 个月后，仍有 44%的用户订阅。(由于这是一个人工数据集，数字可能会高于真实案例的预期。)
基于时间的队列分析
这个观点能概括关于保留的一切吗？
不要！该图表总结了每个群组在订阅过程中特定时期的保留率。但重要的是要记住，这些只是利率。在没有看到分子和分母的情况下，我们不应该对一家公司的未来是否处于危险之中妄下结论。可能会有新的服务增加门户网站的流量，从而增加订阅数量并增加收入，因此这是非常可取的，但费率可能会显示不同的趋势。尽管数量有所增加，但用户流失的速度可能会更快。这就是为什么这种可视化只能呈现业务的局部视图，如果单独使用可能会产生误导！
如何为我的公司创建类似的图表？
为了回答这个问题，我构建了一个名为 pycohort 的 python 包。要使用这个包，数据需要有特定的格式。否则，无法使用这些功能。首先，由用户创建的每个订阅需要有一个惟一的标识符，这个标识符需要被称为id。然后需要在creation_date字段中输入每个订阅的开始日期。metric_month为订阅活动的每个月添加一列。这就是为什么每活跃一个月，就会有一个新的数据点。订阅最后激活的日期需要在last_active_month字段中。这不一定等于取消月。如果订阅仍然有效，那么last_active_month将等于最*的月份。所需的最后一列是active_duration，它是在creation_date和last_active_month之间花费的时间。
数据帧的格式需要加载到 pycohort 函数中
在这样的数据格式中，可能会有重复。例如，对于在 2020 年 3 月创建并在 2020 年 5 月取消的订阅，将有三行:第一行的metric_month等于 2020 年 3 月，第二行的metric_month等于 2020 年 4 月，第三行的metric_month等于 2020 年 5 月。
在确保数据格式正确后，有 5 个函数可用来了解保留情况。前三个是计算*均值，中位数和标准差。这三个主要用于active_duration字段。下一个函数叫做cohort_preprocess。在这个函数中，上面解释的数据帧格式被转换成一个矩阵，在这个矩阵中计算每个周期中不同群组的保持率。最后一个函数cohort_viz将cohort_preprocess的输出作为输入，并打印群组分析可视化。
# to download the package:
!pip install pycohort# importing necessary functions from the package
from pycohort import calculate_stdev
from pycohort import calculate_mean
from pycohort import calculate_median
from pycohort import calculate_stdev
from pycohort import calculate_stdev# calculating mean
calculate_mean(df.active_duration)
>>> 13.315# calculating median
calculate_median(df.active_duration)
>>> 12# calculating standard deviation
calculate_stddev(df.active_duration)
>>> 7.256# printing the visualization
cohort_viz(cohort_preprocess(df))
群组预处理函数的输出
如何将所有功能捆绑在一个 python 包中？
在发布这段代码之前，我创建了一个名为 pycohort 的工作目录。在那个文件夹下，有一个 readme.md，setup.py，license.txt，还有一个叫 pycohort 的文件夹。在 setup.py 下，作者需要输入与包相关的具体信息，如下所示。请注意这个包的名字不能被其他开发者使用。同样，如果你想上传一个新的版本，你需要迭代这个版本。正如你所看到的，我花了几个版本来调整代码，添加注释和提高包的效率。
# content of setup.py for pycohort
from setuptools import setupsetup(name='pycohort',
version='2.6',
description='pycohort package',
url='[https://github.com/demirkeseny'](https://github.com/demirkeseny'),
author='Yalim Demirkesen',
[author_email='yalimdemirkesen@gmail.com](mailto:author_email='yalimdemirkesen@gmail.com)',
license='MIT',
packages=['pycohort'],
zip_safe=False)
在工作目录的 pycohort 文件夹下有两个文件。init。py，它通知用户如何导入包，还有 pycohort.py，上面提到的所有函数都存储在这里。
# content of __init__.py for pycohort
from .pycohort import calculate_mean
from .pycohort import calculate_stdev
from .pycohort import calculate_median
from .pycohort import cohort_preprocess
from .pycohort import cohort_viz
最终的文件布局如下所示:
这些文件需要上传到哪里以及如何上传？
下一步是上传我们的文件，以便其他人可以安装它们。我们将上传我们的包的站点叫做 PyPi 。当你通常使用pip install下载任何 python 包时，你从 PyPi 中拉出文件夹。最佳实践是首先尝试将您的包上传到 test PyPi 中，这是 PyPi 的一个测试库。如果顺利的话，我们可以把所有东西上传到 PyPi。为了上传我们的文件，我们需要在 test PyPi 和 PyPi 上创建一个帐户。
一旦每个文件都准备好了，帐户也创建好了，我们需要使用cd命令导航到 pycohort 所在的工作目录。然后我们需要运行python setup.py sdist。这个命令将向我们的存储库添加两个额外的文件，这样我们的包就可以上传到 PyPi，也可以从 PyPi 下载。接下来，我们需要下载twine包，将我们的文件推送到 PyPi 存储库。然后我们可以上传我们的包来测试 PyPi，并尝试从测试存储库中下载它。如果上传到测试 PyPi 时没有问题，我们可以转移到常规的 PyPi。您可以在下面找到所有必要的代码:
# navigate to pycohort working directory:
cd pycohort# download the necessary files to upload your package:
python setup.py sdist# install twine package:
pip install twine# upload package to test PyPi:
twine upload --repository-url https://test.pypi.org/legacy/ dist/*# install from test PyPi:
pip install --index-url https://test.pypi.org/simple/ pycohort# upload package to PyPi:
twine upload dist/*# install from test PyPi:
pip install pycohort
结论
如果您想要直观显示不同群组的保留趋势，这种基于时间的群组分析是一个完美的选择。一旦你的数据是上面解释的格式，那么使用 pycohort 包就更容易了。
在对这张图表做出任何决定之前，请记住，这种可视化是基于没有反映分子或分母突然变化的比率。
请点击这里找到 Github repo ，点击这里找到 PyPi 链接，获得关于软件包和功能的更详细的视图。
特别感谢 Gunsu 阿尔丁达格所有的灵感！
用 Python 可视化新冠肺炎疫苗数据(5 个简单步骤)
让您的 MatPlotlib 图形脱颖而出
让你的 Matplotlib 可视化更加漂亮！资料来源:Nik Piepenbreier
Matplotlib 是 Python 中最常用的数据可视化库之一。然而，它的默认设置会导致单调乏味的图形。本快速教程将指导您使用一些技巧和窍门来设计更漂亮的 Matplotlib 图。
你会做什么！
我们将从我们的数据世界中获取一些新冠肺炎疫苗数据，并用它将我们最初的、枯燥的 Matplotlib 可视化变成更漂亮的东西。
你的开始和结束。资料来源:Nik Piepenbreier
我们开始吧！
我们将从加载所需的库开始。不要被长长的导入列表吓倒——在整个教程中，我将逐一介绍每个导入的细节:
如果你在 Jupyter 笔记本上跟随，确保包含%matplotlib inline Jupyter magic，让你的图表在线显示。
加载我们的数据帧
我们将使用 Pandas 的.read_csv()方法加载我们的数据帧。好的一面是，随着数据的更新，您的绘图将通过简单的重新运行进行更新。
让我们看看我们在这里做了什么:
在步骤 1 中，我们加载数据，让 Pandas 知道只加载列的子集(date、location、total_vaccinations_per_hundred)，并将date作为日期时间值读取。
- 我们还创建了一个包含不同国家的列表。如果您希望您的可视化显示其他国家，只需确保它们与数据框中的可用内容相匹配。
提示:您可以通过使用 print(df['location']找到 location 中使用的国家名称。唯一())
然后，我们过滤数据框架，只包括这些国家，这样我们的可视化就不会被太多的国家弄乱。
汇总数据
在步骤 2 中，我们使用一个简单的数据透视表汇总数据。如果你想了解熊猫的数据透视表，点击这里查看我的 YouTube 视频。
- 最后，我们填充缺失的值。不幸的是，数据中分散着一些缺失值。我们使用
method='ffill'参数向前填充任何丢失的值以获得最佳估计。
创造我们的视觉化
让我们开始创建我们的可视化！这有点复杂，但我会一步一步地教你:
在步骤 3 中，我们设置了一些辅助变量。我们想突出我们的main_country，在这个例子中是美国。如果您想突出显示另一个国家，只需用另一个国家(您已经在步骤 1 中过滤到数据框中)替换掉该字符串。
然后，我们使用两种字典理解将所有国家指定为灰色，透明度为 0.75，除了main_country，它被指定为深青色，没有透明度。要了解更多关于字典理解和它们是如何工作的，请查看这个教程。
在步骤 4 中，我们做了很多，所以让我们来分解一下！
- 我们举例说明一个图形和一个大小为 12x8 的轴
- 然后，我们循环遍历 countries 变量中的每个国家，分别绘制每条线。我们使用指数(我们的日期)作为 x 值，使用接种疫苗的人口比例作为 y 值。我们从步骤 3 中创建的字典中提取颜色和透明度。
- 然后，我们将文本添加到我们的绘图中，以直接在线上显示国家的标签。我们使用
timedelta函数将索引的最后一个值增加 2 天，以在行尾和文本开始处之间创建一点缓冲。 - 我们可以使用
.max()值来表示每个国家的值，因为这个比例只会越来越大。 - 最后，我们传入国家的名称作为要使用的字符串，并使用字典传入颜色和透明度，就像我们传入行本身一样。
第 5 步也有点复杂，所以我把它分成了几个子步骤。
- 对我来说，A 部分是最复杂的。我们使用
DateFormatter将日期格式化为 YYYY-MM-DD 格式。然后我们使用.set_major_locator()告诉 Matplotlib 使用什么作为刻度标记，传入WeekdayLocator作为参数，表示我们希望使用第一个工作日作为刻度。然后，我们将标签旋转 45 度，并将 y 轴限制在 0 到 100 之间。 - 在B 部分中，我们移除了顶部和右侧的脊线，并降低了左侧和底部脊线的对比度。我们还添加了一个微妙的网格。
- 在C 部分中，我们添加了描述性轴标签和标题。
- 最后，我们在d 部分展示剧情
运行此代码会返回以下视觉效果:
我们最后的视觉化。图片作者:Nik Piepenbreier
结论
在这篇文章中，我们学习了如何使用新冠肺炎数据集生成漂亮的数据可视化。我们可以利用 Python 的强大功能，根据今天的数据自动更新我们的图表。
如果你想了解更多关于 Matplotlib 的内容，可以查看我在 YouTube 上不断增加的播放列表:
如果你想订阅我的频道，请点击下面的按钮！
点击此处订阅(图片由 stickpng.com 提供)
想象洛杉矶的犯罪
影响犯罪的因素有哪些？一天中的什么时候？星期几？
洛杉矶是全球特大城市之一。这个大都市每年都吸引成千上万像我一样的学生。2021 年 8 月，我将搬到洛杉矶，在南加州大学(USC)学习数据科学。自从我做出决定后，朋友、家人和其他洛杉矶人一再提醒我，这个地区可能不是最安全的。因此，我决定在 2021 年期间对洛杉矶的犯罪本质进行一次知情的调查，以确保我在这座城市的这段时间里做出明智的、由数据驱动的决定。
让我印象深刻的一件事是，LAPD 提供的犯罪数据在埃里克·加希提市长的网站上随时可供公众使用。即使在当今开放的数据世界中，这也是相对罕见的。无论如何，让我们深入这个庞大的数据集，收集一些重要的见解。
在探索和清理数据以进行适当的分析后，我想看看这个城市中最常见的犯罪类型。
2021 年，截至 6 月，洛杉矶市记录了超过 79，000 起犯罪案件。“偷车”占所有犯罪的 11%以上，高居榜首。“自行车失窃”占所有犯罪的 1%。作为一名学生，我很可能每天骑自行车去大学，因此看到如此高的自行车被盗数量令人震惊。
好了，我们现在知道了什么类型的犯罪比其他类型的犯罪发生得更频繁，但是这些犯罪是什么时候发生的呢？他们是遵循特定的时间模式，还是一周中的某一天比其他时间承担更多的案件？
上面的树形图给了我们一些相当有用的见解:周末很麻烦！周五累积了全年最多的犯罪案件，随着新一周的开始，案件数量减少了* 1500 起。周五的高峰很可能是由于周末的到来，更多的人外出社交和聚会，导致深夜外出，这是犯罪发生的最大可能。就洛杉矶的犯罪而言，周二和周三是最*静的。
一天中的时间在犯罪中也起着重要的作用。我在下面绘制了一张图表，其中我们以 24H 格式显示了一天中的时间与犯罪数量的关系。
凌晨 5 点左右，当城市的大部分人都在睡觉时，犯罪率就下降了。这是非常期待的。我还预计在傍晚 6 点左右会出现一个高峰，这时人们下班回家或者出去享受夜晚。令我惊讶的是，中午的时候几乎达到了峰值。看看在这几个小时里会发生什么类型的犯罪会很有趣。我预测这些犯罪属于“软性”类型，包括毒品违法、盗窃和财产犯罪。
正如我所预测的，左上方的表格清楚地告诉我们，财产犯罪和入室盗窃是最常见的犯罪类型，在中午我们会看到每天的高峰。
尽管这些犯罪是频繁和令人不安的，但由于犯罪的性质，这仍然是一个相对安全的外出时间。然而，如果与一天中晚些时候(大约晚上 7 点)的类似高峰相比，情况就不同了。
随着太阳落山，攻击性犯罪的数量显著上升。致命袭击上升到令人震惊的 294 起，而对伴侣的袭击也在增加。“软”犯罪也有所上升，被盗车辆数量几乎是中午的两倍。
虽然这提供了关于一天中什么时间更安全的有价值的见解，但我仍然不完全满意。这里还需要考虑其他因素，比如犯罪率高的地区。更重要的是，我想知道犯罪在南加州大学大学公园校区的分布情况，在接下来的两年里，我将在这里度过大部分时间。首先，我绘制了周边地区的犯罪分布图。该数据集通过地理坐标提供犯罪现场位置，这使得在 Tableau 中绘图变得简单。
标记的不透明度描绘了彼此靠*的单个犯罪地点，因此形成了该区域中犯罪数据点的聚类。哪里的标记暗，哪里就有频繁的犯罪麻烦。校园东侧的 Figueroa 街有多个集群，表明那里的犯罪率较高。我是一个狂热的跑步者，我们获得的时间和地点信息帮助我计算出合适的跑步时间和潜在的安全跑步路线！让我们继续探索。南加州大学地区的犯罪类型呢？
“车辆被盗”仍然是最常见的犯罪类型，该地区似乎有很多破坏和盗窃行为。《致命武器袭击》进入了前 7 名，不过我想看看它在“高峰”犯罪时段，即正午和黄昏的表现。
当“一天中的某个小时”过滤器应用于上表时，“致命武器袭击”在中午和晚上 7 点没有进入前 7 名。这让人放心，那么什么时候十恶不赦的犯罪最常见呢？
袭击犯罪在下午 4 点左右上升，在晚上 8 点和 11 点再次上升。在《安全》杂志的一篇报道中，攻击性犯罪在美国最有可能发生在晚上，我的情节也证实了这一点。同样，这个情节令人放心，并且帮助本文的读者在计划他们的一天时做出数据驱动的决定，如果他们碰巧住在洛杉矶地区的话。
继续前进，随着洛杉矶成为不同文化和种族的大熔炉，我想看看某些人群是否比其他人更容易成为犯罪的受害者。
上述种族和受害者血统类别由 LAPD 在数据集中定义，并按原样转载。西班牙裔/拉丁裔/墨西哥裔人在这个城市的犯罪率最高，其次是白人和黑人。其他亚洲人排名第四。看了看洛杉矶的人口多样性数据，这些数字提供了一个可能的原因。49%的洛杉矶人口被归类为“西班牙裔/拉丁裔/墨西哥裔”。利用概率，人们可以确定人口分布是这两个种族在城市犯罪受害者排行榜上名列前茅的原因。(免责声明:由于缺乏可量化的数据，我在本文中没有考虑种族偏见等影响犯罪的因素。)
该市受害者的*均年龄为 29.82 岁，这表明相对年轻的人容易犯罪。为什么不看看按性别划分的犯罪数量呢？
该数据集按男性/女性/未知进行性别分类，因此不可能进行其他性别鉴定。尽管洛杉矶县的男女比例较高，但我们仍然看到更多的男性成为犯罪的受害者。根据 M E Lewyn 在《圣地亚哥司法杂志》上发表的一篇文章，男性更有可能成为暴力犯罪的受害者。在我们的例子中，我们已经通过上面的饼状图证明了这一点。
尽管南加州大学附*地区因“不安全”而闻名，尽管有数据支持这一说法，但对 LAPD 提供的数据集的进一步分析和研究得出的结论是，在一天中的特定时间，发生的犯罪比其他时间更严重。此外，随着周末的临*，与*日相比，更有可能发生犯罪。我们还知道南加州大学周围的哪些街道相对来说比其他街道更安全，以及哪些街道可以在“高峰”犯罪时段避开。虽然我周围的人对这个地方的担忧在一定程度上是合理的，但任何读过这篇文章的人都可以获得一些重要的见解，这些见解将使他们能够在日常生活中做出数据驱动的决策。只要负责任地去做，洛杉矶有很多值得享受和体验的东西。我期待着今年秋天和以后去体验加州的美丽！
免责声明:
- 上述文章中表达的所有观点都基于 LAPD 提供的数据集。
- 在发布时，Medium 不支持 Tableau 可视化的嵌入，因此我在标题中提供了原始可视化的 URL，读者可以应用更多的过滤器来查看他们喜欢的数据。
骚乱后宵禁期间 DC 实时交通可视化
流动性是城市的生命线。让我们用这里的交通流量/事故 API 来想象一下今天发生不幸的混乱之后，宵禁期间的 DC。
DC 的交通流量和事故。在 Kepler.gl |塞犍陀·维韦克创建的图表
不幸的是，今天的骚乱导致了混乱和生命损失。许多数据提供商免费提供实时详细信息，这对于应急人员和市民应对我们今天看到的突发事件非常有用。让我们深入研究一下使用这样一个 API 量化实时事件和流量数据的潜力。
谷歌地图在计算走哪条路线可以最大限度地减少旅行时间方面非常有用。然而，对于数据爱好者来说，它并不提供这些交通信息。TomTom，Waze，这里都是实时交通信息的提供者。就个人而言，我觉得这里最容易使用，它的免费 API 对于获取详细的交通信息非常有用，比如速度和事故。在之前的博客中，我讲述了如何使用 HERE traffic flow API 提取单个路段的交通速度:
在这里，我将说明如何提取交通事故数据，并将这里的速度/事故与谷歌地图的图像进行比较。
%matplotlib inline
import numpy as np
import requests
from bs4 import BeautifulSoup
import xml.etree.ElementTree as ET
from xml.etree.ElementTree import XML, fromstring, tostringpage = requests.get('[https://traffic.api.here.com/traffic/6.2/incidents.xml?app_id=BLAH&app_code=BLAH2&bbox=38.92,-77.06;38.88,-77.00&responseattributes=sh,fc'](https://traffic.api.here.com/traffic/6.2/incidents.xml?app_id=EuBWKTOquw60Mdj8U9Tu&app_code=aEJDOiovLnfYhC6jcT_pkA&bbox=38.92,-77.06;38.88,-77.00&responseattributes=sh,fc'))
soup = BeautifulSoup(page.text, "lxml")incidents = soup.find_all('traffic_item')
您可以在这里注册以获得一个应用程序 id 以及证书的应用程序代码(以上示例中的 BLAH、BLAH2)。接下来，您需要一个边界框来获取流量/事件。为此，在谷歌地图上，你会看到纬度-经度对。您需要左上角和右下角的按钮来获取边界框的坐标。响应属性 fc 和 sh 非常重要，稍后可用于过滤高速公路、街道等。，但我不会在这篇文章中使用这些信息。最后一行给出了当时所有独特的事件。
myxml = fromstring(str(incidents[0]))
for child in myxml:
print(child.tag)traffic_item_id
original_traffic_item_id
traffic_item_status_short_desc
traffic_item_type_desc
start_time
end_time
entry_time
criticality
verified
abbreviation
rds-tmc_locations
location
traffic_item_detail
traffic_item_description
traffic_item_description
traffic_item_description
查看第一个事件，有 16 个标签包含有用的事件信息，如事件开始和结束的时间、描述和位置。目前，我只对事件发生的地点感兴趣。事实证明，这并不像交通速度那样简单。但是稍微调查了一下，我发现它隐藏在位置标签中。
myxml = fromstring(str(incidents[0]))
for child in myxml:
if (child.tag==’location’):
for chelds in child:
print(chelds.tag,chelds.attrib)intersection
geoloc
political_boundary
navtech
length
最后，我发现了隐藏在地理标签中的事件的来龙去脉:
incidents[0].location.geoloc<geoloc><origin><latitude>38.88507</latitude><longitude>-77.01081</longitude></origin><to><latitude>38.88602</latitude><longitude>-77.01051</longitude></to><geometry><shapes><shp fc="5" fw="SD" le="0.042374034341961575" lid="1186813844F">38.88507,-77.01081 38.88544,-77.01069</shp><shp fc="5" fw="SD" le="0.06625476521319096" lid="1254739814F">38.88544,-77.01069 38.88602,-77.01051</shp></shapes></geometry></geoloc>
您还可以查看存在哪些类型的事件。在 2021 年 6 月 1 日晚上 9 点左右，DC 总共发生了 173 起事故。所有这些都被描述为道路封闭或有计划的活动。以下是前 10 个。注意:这里的时间显然不是美国东部时间。可能是格林威治时间，虽然我现在还不确定。
for inc in incidents:
print(inc.start_time.text, inc.end_time.text,inc.traffic_item_type_desc.text)12/15/2020 15:46:16 02/15/2023 17:00:00 ROAD_CLOSURE
01/06/2021 21:46:56 01/07/2021 21:45:44 ROAD_CLOSURE
01/06/2021 22:52:32 01/07/2021 22:52:07 ROAD_CLOSURE
12/15/2020 15:46:16 02/15/2023 17:00:00 ROAD_CLOSURE
01/06/2021 21:46:56 01/07/2021 21:45:44 ROAD_CLOSURE
12/15/2020 15:46:16 02/15/2023 17:00:00 ROAD_CLOSURE
01/06/2021 23:04:11 01/07/2021 23:01:47 ROAD_CLOSURE
12/15/2020 15:46:16 02/15/2023 17:00:00 ROAD_CLOSURE
12/15/2020 15:46:16 02/15/2023 17:00:00 ROAD_CLOSURE
01/06/2021 23:04:11 01/07/2021 23:01:47 ROAD_CLOSURE
最后，这里是 here 交通速度/事件与谷歌地图承诺的视觉对比:
左边是谷歌地图，右边是华盛顿 DC |塞犍陀·维韦克的数据
有一些有趣的区别。这里有更多的事件和更多的速度数据在一些较小的路段。否则，在没有谷歌地图数据的情况下，很难直观地识别速度有多相似/不同。还有，我不确定谷歌地图是如何通过颜色来识别自己的速度的。谷歌地图有 4 种颜色，从慢到快(暗红色、红色、黄色、绿色)。我在这里制作了一个类似的彩色地图，其中道路颜色根据相对于速度限制的速度进行分段:0-0.25，0.25-0.5，0.5-0.75，0.75-1(0 对应于*均速度为 0 英里/小时，1 代表速度限制)。
这里有一个获取实时信息的绝佳资源，你无法从谷歌地图上获得。此外，这里似乎有更详细的小路段交通信息，他们声称是世界第一的定位*台，相当大胆的说法。唯一的缺点是他们没有可用的历史交通数据——但希望这是未来的选择。
正如我们今天所看到的，有时一群人会以以前不可想象的方式集体行动，并造成巨大的伤害。当这种情况发生时，我们需要对不断演变的地貌有一个准确的了解。今天的事件表明，DC 政府对抗议的规模和国会大厦被渗透的突然性毫无准备。
与其他实时数据源集成的实时交通数据，包括社交媒体消息，如推文；作为社会的脉搏。这些数据提供了强大的、可操作的信息，执法部门、应急响应人员甚至市民等城市利益相关者可以利用这些信息来正确评估情况的严重性，并在时间至关重要的情况下做出关键决策。
如果你喜欢这篇文章，请关注我——我经常在复杂系统、物理学、数据科学和社会的界面上写作
用 Pybaobabdt 可视化决策树
实践教程
一个用于决策树可视化和模型解释的开源包
数据可视化是决策的语言。好的图表有效地传达信息。伟大的图表使决策成为可能，提供信息，并改善决策: 但丁·维塔利亚诺
决策树可以以多种方式可视化。以缩进节点为例，其中每个内部节点和叶节点都被描述为文本，而父子关系是通过相对于父节点缩进子节点来显示的。
缩进图|作者图片
然后是节点-链路图。这是可视化决策树最常用的方法之一，决策树中的节点通过字形表示，父节点和子节点通过链接连接。
节点链接图|作者图片
冰柱图图是同样的另一个选项。除了显示关系，这些图还有助于描述节点大小。他们的名字来源于这样一个事实，即最终的可视化看起来像冰柱。
由 https://www . cs . middlebury . edu/~ can drews/showcase/infovis _ techniques _ s16/icicle _ plots/icicle plots . html| CC-经许可
虽然这些技术很有帮助，但是它们不能很好地扩展，尤其是当数据量增加时。在这种情况下，不仅可视化数据变得困难，而且解释和理解树也是一个挑战。 BaobabView 是一个为解决这类问题而创建的库，在本文中，我们将通过例子详细介绍它的 python 实现 pybaobabdt 。
绘制决策树的几个软件包
我们通过讨论可视化决策树的多种方式开始了这篇文章。查看各种帮助绘制决策树的库也是值得的。
资料组
这里我们将使用帕尔默企鹅数据集作为公共数据集。这是一个众所周知的数据集，通常是 iris 数据集的替代物，目标是根据给定的特征预测企鹅种类。
数据集|图像的前五行(按作者)
1\. Visualization using [sklearn.tree](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.tree)。绘图树
这是默认的方式，也是最常用的方法。它是 scikit-learn 的默认选项。
Visualization using [sklearn.tree](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.tree)。plot_tree |作者图片
在这个例子中，树的max_depth被限制为 3。
Visualization using [sklearn.tree](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.tree)。plot_tree |作者图片
2.Visualization using 达特里维兹
dtreeviz 库提供了更好的外观和直观的可视化，同时提供了更好的可解释性选项。图书馆的灵感来源于r2d 3的教育动画；* 机器学习视觉入门 。*
链接到文章 : 用 dtreeviz 库可视化决策树的更好方法
Visualization using dtreeviz |作者图片
Visualization using 作者图片
3.张量流决策森林
TensorFlow 决策森林是为训练、服务、推理和解释这些决策森林模型而创建的库。它为基于树的模型和神经网络提供了统一的 API。TensorFlow 决策森林具有内置的交互式绘图方法来绘制和帮助理解树结构。
链接到文章 : 回顾 TensorFlow 决策森林库
Visualization using 张量流决策森林(TF-DF) |图片由作者提供
张量流决策森林(TF-DF) |图片由作者提供
镇上的新成员
一篇名为 猴面包树视图:决策树的交互式构建和分析 的论文展示了一种可视化决策树的独特技术。这种技术不仅可扩展，而且使专家能够将他们的领域知识注入到决策树的构造中。该方法被称为 BaobabView 和依赖于可视化、交互和算法支持这三个关键方面。
BaobabView 的三个关键方面:可视化、交互和算法支持|作者图片
以下是这篇论文的摘录，具体强调了这一点:
我们认为我们的工具提供了一个可视化分析方法的双重例子。我们展示了如何使用交互和可视化来增强机器学习方法；我们还展示了人工构建和分析是如何得到算法和自动化支持的。
名字里有什么？
你想知道这个奇怪的名字吗？这个词源于 非洲猴面包树 或 非洲猴面包树 ，因为它与树的结构惊人地相似。
荷兰阿纳姆的费迪南·勒乌斯， CC BY-SA 2.0 ，通过维基共享
pybaobabdt 包是 BaobabView 的 python 实现。现在让我们从这个库的安装开始，稍微深入一点这个库的细节。
装置
该软件包可以按如下方式安装:
pip install pybaobabdt
但是，需要满足一些要求:
- Python 版本≥ 3.6
- PyGraphviz
- 还应该安装像 sklearn、numpy、pygraphviz、matplotlib、scipy、pandas 这样的流行 python 包。
我在安装pygraphviz的时候经历了几次打嗝。如果您面临同样的问题，请参考随附的代码笔记本。
Pybaobabdt 在行动
我们将继续我们的企鹅数据集，并建立一个决策树，根据给定的特征预测企鹅物种。
from sklearn.tree import DecisionTreeClassifier
y = list(df['Species'])
features = list(df.columns)
target = df['Species']
features.remove('Species')
X = df.loc[:, features]clf = DecisionTreeClassifier().fit(X,y)
上面的代码初始化并训练一个分类树。一旦完成，下一个任务就是使用pybaobabdt包来可视化树，这只需要一行代码就可以完成。
ax = pybaobabdt.drawTree(clf, size=10, dpi=300, features=features, ratio=0.8,colormap='Set1')
使用 Pybaobabdt 软件包可视化决策树分类器|图片由作者提供
这就对了。你有一个决策树分类器，每一类物种用不同的颜色表示。在随机森林的情况下，也可以可视化单个的树。然后，这些树可以保存为更高分辨率的图像，以便进行深入检查。
自定义
pybaobabdt 库也提供了许多定制。我将在这里展示其中的一些:
彩色地图
pybaobabdt 支持所有 matplotlib 颜色映射。我们已经看到了Set1色图的样子，但是你可以从许多不同的选项中选择。以下是它们在使用时出现的次数:
使用 Pybaoabdt 和不同的颜色图进行决策树可视化|图片由作者提供
但是您并不局限于可用的色彩映射表。你甚至可以自己定义一个。假设我们只想突出显示数据集中的一个特定类，而将所有其他类置于背景中。我们可以这样做:
from matplotlib.colors import ListedColormapcolors = ["green", "gray", "gray"]
colorMap = ListedColormap(colors)ax = pybaobabdt.drawTree(clf, size=10, features=features, ratio=0.8,colormap=colorMap)
仅突出显示决策树中的特定类别|作者图片
比例
比率选项用于设置树的比率，默认值为 1。下面是这两个比率的比较，以及它们在屏幕上的显示方式。
ax = pybaobabdt.drawTree(clf, size=10, dpi=300, features=features, ratio=0.5,colormap='viridis')
不同的比例如何影响体型|作者图片
最大深度=3
参数maxdepth控制树的深度。较低的数字限制了树的分裂，也显示了顶部分裂。如果上述树的max_depth设置为 3，我们将得到一个发育不良的树:
ax = pybaobabdt.drawTree(clf, size=10, maxdepth = 3,features=features, ratio=1,colormap='plasma')
调整树的最大深度以控制树的大小|图片由作者提供
保存图像
输出图形可以保存如下:
ax.get_figure().savefig('claasifier_tree.png', format='png', dpi=300, transparent=True)
结论
pybaobabdt 包为可视化提供了一个新的视角。它包括了在它的对应物中没有见过的特征。主要思想是通过有意义的可视化来帮助用户理解和解释树。本文使用了一个简单的例子来演示这个库。然而，将它用于更广泛和更复杂的数据集，以了解它在实际意义上的优势，这将是一个很好的练习。我将把它留给读者做练习。
参考资料和进一步阅读:
可视化降维
使用 UMAP 进行降维
来源:作者
在处理大型数据集时，降维是最重要的方面之一，因为它有助于将数据转换到较低的维度，以便我们可以识别一些重要的特征及其属性。它通常用于避免在分析大型数据集时出现的维数灾难。
当我们进行数值分析或创建机器学习模型时，处理高维数据可能会很困难。使用高维数据集会导致高方差，并且模型不会被一般化。如果我们降低维度，我们可以使机器学习模型更加一般化，并避免过度拟合。
UMAP 是一个开源的 Python 库，有助于可视化降维。
在本文中，我们将探索 UMAP 提供的一些功能。
让我们开始吧…
安装所需的库
我们将从使用 pip 安装 UMAP 库开始。下面给出的命令可以做到这一点。
!pip install umap-learn
导入所需的库
在这一步中，我们将导入加载数据集和可视化降维所需的库。
import umap
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
import pandas as pd
%matplotlib inline
正在加载数据集
在本文中，我们将使用从 Github 获取的著名的 Palmer Penguins 数据集。
penguins = pd.read_csv("https://github.com/allisonhorst/palmerpenguins/raw/5b5891f01b52ae26ad8cb9755ec93672f49328a8/data/penguins_size.csv")
penguins.head()
加载数据集后，我们将从删除空值开始，并使用 UMAP 创建一个 reducer 对象。该缩减器将用于维度缩减，并进一步用于可视化。
penguins = penguins.dropna()
penguins.species_short.value_counts()
reducer = umap.UMAP()
penguin_data = penguins[
[
"culmen_length_mm",
"culmen_depth_mm",
"flipper_length_mm",
"body_mass_g",
]
].values
scaled_penguin_data = StandardScaler().fit_transform(penguin_data)
embedding = reducer.fit_transform(scaled_penguin_data)
绘制降维图
在这一步，我们将绘制降维图。
plt.scatter(embedding[:, 0], embedding[:, 1], c=[sns.color_palette()[x] for x in penguins.species_short.map({"Adelie":0, "Chinstrap":1, "Gentoo":2})])
plt.gca().set_aspect('equal', 'datalim')
plt.title('UMAP projection of the Penguin dataset', fontsize=24)
降维(来源:作者)
在这里，您可以清楚地看到企鹅数据集的维数减少。
继续尝试不同的数据集，执行降维，并使用 UMAP 绘制。如果您发现任何困难，请在回复部分告诉我。
本文是与 Piyush Ingale 合作完成的。
在你走之前
感谢 的阅读！如果你想与我取得联系，请随时通过 hmix13@gmail.com 联系我或我的 LinkedIn 个人资料 。可以查看我的Github*简介针对不同的数据科学项目和包教程。还有，随意探索* 我的简介 ，阅读我写过的与数据科学相关的不同文章。
使用 t-SNE 和 PCA 可视化特征向量/嵌入
丹尼斯·库默在 Unsplash 上拍摄的照片
在学习机器学习或深度学习的基础知识的同时训练一个模型是一个非常受引导的过程。数据集已被很好地理解，并被充分格式化以供您使用。然而，当你步入现实世界，试图解决行业或现实生活中的挑战时，数据集通常是混乱的，如果一开始不存在的话。理解为什么你的模型不简单。没有具体的步骤引导你找到答案。然而，某些工具允许您调查并获得关于模型输出的更深入的见解。可视化是一个非常强大的工具，可以提供非常宝贵的信息。在这篇文章中，我将讨论两种非常强大的技术，可以帮助你在低维空间中可视化高维数据，以找到趋势和模式，即主成分分析和 t-SNE。我们将采用一个基于 CNN 的示例，并在测试数据集中注入噪声来进行可视化研究。
介绍
在深入研究如何使用这两种技术之前，我将简要介绍一下它们。
主成分分析[1]
PCA 是一种探索性工具，通常用于将大型复杂数据集简化为更小、更容易理解的数据集。它通过进行正交线性变换来实现这一点，该变换将数据转换到一个新的坐标系中，该坐标系以主成分的形式根据其方差内容进行排列，即您的高维相关数据被投影到一个具有线性独立基的较小空间中。第一个分量的方差最大，最后一个分量的方差最小。在原始空间中相关的特征在这个新的子空间中用线性独立或正交的基向量来表示。[注意:给定向量空间 V 的基集 B 包含的向量允许 V 中的每个向量唯一地表示为这些向量的线性组合[2]。PCA 的数学超出了本文的范围。]您可以将这些组件用于许多事情，但在本文中，我将使用这些组件来可视化特征向量或嵌入中的模式，我们通常从 2D/3D 空间中的神经网络的倒数第二层获得这些模式。
t-分布随机邻居嵌入(t-SNE) [2]
t-SNE 是一种强大的可视化技术，可以帮助发现低维空间中的数据模式。这是一种非线性降维技术。然而，与 PCA 不同，它涉及迭代优化，这需要时间来收敛，并且有一些参数可以调整。这涉及到两个主要步骤。首先，t-SNE 在高维对象对上构建概率分布，使得相似的对象被分配较高的概率，而不相似的对象被分配较低的概率。相似性是基于某个距离(例如欧几里德距离)来计算的。接下来，t-SNE 在低维空间中定义了类似的概率分布，并最小化了两个分布之间关于空间中点的位置的 Kullback-Leibler 散度(KL 散度)。KL 散度是一个统计工具，它允许你测量两个分布之间的相似性。当你用一个分布来*似另一个分布时，它会给你丢失的信息。因此，如果 KL 散度被最小化，我们会发现一个分布，它是相似和不相似物体的高维分布的一个很好的低维*似。这也意味着结果不会是唯一的，每次运行都会得到不同的结果。因此，在做出结论之前，多次运行 t-SNE 算法是一个好主意。
接下来，我将讨论我们将在本文中使用的分类数据集和体系结构。
使用 CNN 的 MNIST 分类
我想使用真实世界的数据集，因为我最*在工作中的一个项目中使用了这种技术，但由于 IP 原因，我不能使用该数据集。所以我们将使用著名的 MNIST 数据集[4]。(尽管它现在已经成为一个玩具数据集，但它已经足够多样化，可以展示这种方法。)
它总共由 70，000 幅手写数字图像组成。这些样本分为 60，000 个训练样本和 10，000 个测试样本。这些是 28x28 灰度图像。一些带有相应标签的随机样本如下所示。
来源:作者
我将使用一个小的 CNN 架构来执行分类并在 PyTorch 中构建它。该架构如下所示:
来源:作者
它由一个带有 16 个滤波器的 conv2d 层和两个完全连接的线性层组成。网络为每个图像输出 10 个值。我已经应用了最大池来减少特征尺寸。网络参数摘要如下所示。
来源:作者
我们看到，即使这个微小的网络也有 175k 个参数。这里需要注意的是，与全连接层相比，CNN 层的网络参数非常少。这些线性图层还会对网络的输入大小产生限制，因为它是针对 28x28 输入计算的，并且会针对其他输入大小更改其尺寸。这就是为什么我们不能将具有全连接层的预训练 CNN 模型用于与训练期间使用的维度大小不同的输入。除了最后一层，我在每一层之后都应用了 relu 激活。因为 PyTorch 中的交叉熵损失需要原始逻辑。它在内部应用 softmax。因此，在使用该特定功能时，请记住这一点。
对于训练，我使用具有默认设置的 Adam 优化器，并且模型被训练 20 个时期，并且基于最低验证损失保留最佳模型。通过查看 train 和 val 指标，我观察到了随着训练的进行过度拟合的趋势。我觉得给你看看可能是个好主意。
来源:作者
在整个训练过程中，我们看到训练损失呈下降趋势，训练准确率呈上升趋势。这意味着我们的模型复杂度对于我们的训练数据集来说是足够的。对于验证损失，我们看到直到第七个时期(步骤 14k)损失减少，然后损失开始增加。验证准确度经历了增加，然后也在接*结束时开始降低。想了解更多关于偏差-方差权衡、过拟合和欠拟合的内容，可以阅读本文:https://towardsdatascience . com/bias-variance-trade-off-7b 4987 DD 9795？sk = 38729126412 b 0 DC 94 ca 5 D2 a 9494067 b 7
现在我们将转移到今天文章的核心，特征向量或嵌入的可视化。
特征向量的可视化
我不会解释训练代码。所以让我们从视觉化开始。我们将需要导入一些库。我在我的脚本中使用了 PyTorch Lightning ，但是代码将适用于任何 PyTorch 模型。
我们加载训练好的模型，将其发送到 GPU，并将其置于评估模式。将你的模型放入 eval 是非常重要的，因为它将设置 BatchNorm、Dropout 等层。在推理过程中恰当地表现。
接下来，我们加载我们的 MNIST 数据集，并在数据集中注入一些噪声样本。
注入的噪声看起来像这样。
来源:作者
所以我们知道，模型必须要抛出一些类，但是对于这些样本来说，这是无用的。这是使用 DL 模型的问题之一，如果您遇到非分布数据，那么很难预测模型会预测什么。对看不见的数据进行归纳总是一个挑战。我已经定义了模型，它返回嵌入张量和最终预测张量。这使得无需改变 PyTorch 中的前钩就可以容易地接*。
但是，如果您发现自己想要访问预训练模型的中间层的输出，您可以使用下面的代码来注册前向挂钩。
MNIST 数据集的预测代码如下。我们只需在数据集上循环，向前遍历网络，提取嵌入，并将其存储在嵌入张量中。
为了进行健全性检查，我绘制了几个样本输入测试点的输出预测。
来源:作者
该模型似乎按预期工作，预测标签显示在每个子情节的顶部。最后，我们可以做 t-SNE 和主成分分析投影，看看一些漂亮的视觉效果。我用 scikit-learn 来学习这些算法。
经过训练的模型嵌入的结果图如下所示。正如我们所料，我们看到了 11 个漂亮的星团。该模型预测所有的噪声样本为八个。我们看到这些噪声图像中最右边的紫色集群。这是一种异常，这种异常或异常值应该在您的真实数据集调查中进一步调查。您可以使用 x，y 位置来获取嵌入的索引，并将它们映射到图像索引。那会告诉你那些样品有什么问题。
来源:作者
我还计算了 3D t-SNE 投影，只是为了说明做这件事同样容易。
我们在 3D 投影中也观察到了同样的现象。
来源:作者
对于 PCA，代码非常相似，但是我们使用 PCA 类而不是 TSNE。我做了类似 t-SNE 的二维和三维投影。但是，对于 PCA，您需要记住一个额外的参数。这就是被解释的方差比率。这将告诉您主成分捕获的数据的差异量。这些值越高，主成分就越能更好地显示低维空间中数据的变化。但是较低的值表明只有 2 或 3 个组件不太擅长显示模式。
对于前两个主成分，仅捕获嵌入中 25%的变化。我们确实看到了一些模式，但是这些集群并不像 t-SNE 嵌入那样清晰。主成分分析图中的异常值并不明显。不过，3D 图显示的聚类更好一些。这是因为 3 个分量捕获了更多的方差。因此，PCA 可视化的有效性将取决于您的数据。
来源:作者
来源:作者
在我结束之前，我想再给你们看一个图，让 t-SNE 视觉化的力量更加清晰。作为一个实验，我用一个随机权重的模型计算了嵌入量，并绘制了 t-SNE 投影。为了正确地向您展示聚类，我根据我们可用的实际标签对这些重量进行了颜色编码。我们看到 t-SNE 从一个未训练的模型中提取的嵌入中给了我们 11 个聚类。
来源:作者
但是你必须小心，SNE 霸王龙会产生一些毫无意义的集群。我还要重申我在导言中所说的，这些预测并不是唯一的。因此，投射几次，并验证你在所有情况下都得到了相似的结果。
结论
我们研究了 t-SNE 和 PCA 来可视化从神经网络获得的嵌入/特征向量。这些图可以向您显示数据中的异常值或异常，可以进一步调查以了解这种行为发生的确切原因。这些方法的计算时间随着样本的增加而增加，所以要认识到这一点。感谢您的阅读，我希望您喜欢阅读这篇文章。代码可从这里获得:https://github . com/msminhas 93/embeddings-visualization/blob/main/readme . MD
参考
[1]https://en.wikipedia.org/wiki/Principal_component_analysis
[2]https://en . Wikipedia . org/wiki/Basis _(线性代数)
[3]https://jakevdp . github . io/python datascience handbook/05.09-principal-component-analysis . html
http://yann.lecun.com/exdb/mnist/
可视化足球比赛数据
使用 Python、JSON、Matplotlib 和 Streamlit
由法布里西奥·特鲁希略拍摄于像素
- 在 Streamlit 上查看申请:https://share . Streamlit . io/andriigoz/football _ game _ stats/main . py
- GitHub 库:https://github.com/AndriiGoz/football_game_stats
浏览数据
我总是对显示足球运动员在球场上表现的热图感到兴奋。让我们尝试构建我们的应用程序，在其中我们可以选择一个玩家和他的动作，并将其可视化。用于分析的数据在 StatsBomb 开放数据存储库中的处找到。StatsBomb 是一家收集和存储足球比赛数据的英国公司。对于我的应用程序，我取了 15 个 JSON 文件，代表 2020 年欧锦赛淘汰赛阶段的 15 场比赛，比赛发生在 2021 年 6 月 26 日至 2021 年 7 月 11 日之间。
让我们打开并发现意大利和英格兰之间的决赛。
# Read JSON file
with open('3795506.json', 'r', errors="ignore") as f:
game = json.load(f)
df = pd.json_normalize(game, sep='_')
4796 行× 122 列
让我们先来看看数据框架。共 4796 行，122 列，有时间戳、玩家名、类型名位置、等列。它告诉我们整个游戏的故事，从开始到结束:发生了什么，谁做的，什么样的行动，在哪里等。有一个大约 120 分钟长的游戏和一个 4796 行的数据帧，我们得到每 1.5 秒捕获的动作列表。
那场比赛玩家做了几个动作？那是什么样的行动？使用 pd.value_counts 我们可以看到 player_name 和 type_name 列的唯一值的计数，并了解那里发生了什么。
玩家名称和类型名称的动作数量
马尔科·维拉蒂以他的 382 次行动成为游戏中最活跃的玩家。最常见的动作是传球、接球和持球。对于我的应用程序，我决定采取四个最频繁的动作加上 Shot 动作。app 的思路是做一些下拉菜单，我们可以在里面选择一场比赛、一名球员、其中一个动作，然后在球场上画出这个具体动作的可视化。
创建音高
在之友的追踪库中的这里找到了 Pitch Plot 函数。他们用长度、宽度、单位和线条颜色参数创建了一个很好的函数，返回给我们一个现成的足球场作为次要情节。所以我们只是拿着它，并不太坚持这一部分。
*from FCPython import createPitch
# Create pitch plot
pitch_width = 120
pitch_height = 80
fig, ax = createPitch(pitch_width, pitch_height, 'yards', 'gray')*
通过绘图功能
我们通过选择包含某些类型名称和玩家名称的行来启动通道绘图功能。 type_name 在这里等于“Pass”， player_name 将由用户从下拉菜单中选择分配(这将在 Streamlit 应用程序部分完成)。接下来，我们得到位置和 pass_end_location 系列并将它们转换成两个列表:(x1，y1)坐标，这里给出了一个 pass；和(x2，y2)坐标，其中接收到传球。使用py plot . fibble(x1，y1，u，v)* 方法，我们现在可以绘制代表通道的箭头。此外，我们为主队分配蓝色，为客场队分配红色。*
马尔科·维拉蒂通行证地图(意大利)。作者图片
这样，我们就有了一个函数，它返回游戏中所选玩家的所有传球的可视化效果。进位图和 Shot 图功能具有相同的结构，因此不必在本文中描述。
接球图
对于球收据绘图功能，我们选择type _ name = =‘球收据’的行。这里我们只得到一个(x，y)坐标列表，并用 plt 将它们可视化为点。圆(x，y)法。压力绘图功能具有相同的逻辑。
哈里·马奎尔(英国)的球收据地图。作者图片
简化应用程序
Streamlit 是每个数据科学家都应该知道的强大工具。它非常简单，同时，它让您有可能通过 web 应用程序可视化和共享您的数据见解。首先，我们创建了一个侧边栏，它有四个下拉菜单和一些只有几行代码的文本:
*# Drop-down menu 'Select Football Game'
st.sidebar.markdown('## Select Football Game')
menu_game = st.sidebar.selectbox('Select Game', games_list, index=14)
# Drop-down menus 'Select Team, Player and Activity'
st.sidebar.markdown('## Select Player and Activity')
menu_team = st.sidebar.selectbox('Select Team', (team_1, team_2))
if menu_team == team_1:
menu_player = st.sidebar.selectbox('Select Player', player_names_1)
else:
menu_player = st.sidebar.selectbox('Select Player', player_names_2)
menu_activity = st.sidebar.selectbox('Select Activity', activities)
st.sidebar.markdown('Select a player and activity. Statistics plot will appear on the pitch.')*
这里我们让用户通过从相应的‘选择玩家’和‘选择活动’下拉菜单中选择来指定玩家名称和类型名称。这些参数将定义必须显示哪个特定的玩家和活动。然后 activity 的 plot 会被 st.pyplot 函数调用。使用 st.head 、 st.write 和 st.markdown 方法，我们用一些文本填充我们的主区域。
Streamlit 上的应用程序
要创建 Streamlit 应用程序，您需要为您的 Python 安装 Streamlit 库。为了分享它，你必须在 streamlit.io 注册，制作一个新的应用程序，并将其连接到 GitHub 存储库中的项目文件夹。将自动创建一个随时可用的 web 应用程序。
参考
*[1] StatsBomb 公开数据:【https://github.com/statsbomb/open-data *
[2]创建 Pitch 资源库:https://github . com/Friends-of-Tracking-Data-FoTD/SoccermaticsForPython/blob/master/fc python . py
[3] Irfan Alghani Khalid ，如何使用 Python 分析足球赛事数据:https://towards Data science . com/How-to-Analyze-Football-Event-Data-Using-Python-2f 4070d 551 ff
[4]2020 年欧锦赛淘汰赛阶段:https://en.wikipedia.org/wiki/UEFA_Euro_2020_knockout_phase
在 Kepler.gl 中可视化地理空间交通数据
使用 Kepler.gl 和 HERE traffic data，对数十万个交通数据点进行快速、优雅的地理空间可视化
使用 Kepler.gl |塞犍陀·维维克可视化波士顿交通
Kepler.gl 是优步的开源地理空间工具箱。通常，可视化大规模地理空间数据集可能相当具有挑战性。有很多 Python 包包括 leav、GeoPandas 和 Plotly 都做得很好；但是找到合适的情节背景可能是一个挑战。在本地机器上绘制数千或数十万个数据点在计算上也具有挑战性。
这就是 Kepler.gl 有巨大优势的地方。Kepler.gl 是一个基于浏览器的框架，可以轻松加载 CSV、JSON 或 GeoJSON 数据，并以最少的格式生成优雅的可视化效果。在这个例子中，我在几秒钟内可视化了从 HERE Traffic API 获得的成千上万的流量数据点。
我们开始吧！
获取交通数据:
我已经从HERE Technologies traffic flow API获得了交通数据。我写过几篇文章，重点介绍如何提取交通流量数据:
保存文件
Kepler.gl 喜欢将文件保存为 CSV 格式，有不同的列。如果您想要一个即时的地理空间图，您需要将这两列标记为“纬度”和“经度”，用于空间位置，第三列用于颜色偏好(在交通信息的情况下是速度)。
在 Kepler.gl 中可视化
既然我们已经以正确的格式保存了数据，我们就可以拖放了——就这么简单！
在 Kepler.gl 中加载文件
你会自动得到一个可以保存的漂亮图像。
从 Kepler.gl 导出图像
然而，当你仔细观察时——色阶是根据分位数显示的——这取决于数据以及数据的比例和速度。例如，如果大部分交通是快速移动的(通常是在深夜或清晨)，颜色味觉将偏向这些更高的速度。然而，这不是我们想要的。我们希望颜色能清楚地表明绝对速度:就像谷歌地图中的交通一样。在这种情况下，我们根据量化值而不是分位数来选择颜色，如下所示。
选择是基于 Kepler.gl 中的量化值还是分位数来着色
还有一些选项可以改变符号的外观和颜色。这样做，我们可以生成一些非常优雅的可视化效果——如本文的标题图片所示！
在 Kepler.gl 中修改颜色和符号
结论
Kepler.gl 非常适合以最小的努力相对快速地生成优雅的可视化效果。相比之下，使用 OSMnx 和其他 Python 库在我的本地机器上绘制成千上万个点需要更长的时间。
然而，在 Kepler.gl 以最少的输入在可视化方面做得很好的地方，人们也遇到了最小可定制性的问题。例如，基本上只有 3 种背景——黑暗、明亮和卫星。可能存在需要其他类型背景的情况。
但是 Kepler.gl 在地理空间可视化方面做得很好。
关注我 如果你喜欢这篇文章——我经常写复杂系统、物理学、数据科学和社会的界面。
如果你还不是中会员，想支持我这样的作家，可以通过我的推荐链接随意报名:https://skanda-vivek.medium.com/membership
用 Python 中的 t-SNE 可视化图形嵌入
实践教程
如何定性评估 Neo4j 图嵌入
图片由 Martin Grandjean 提供，根据知识共享 署名-分享相似 4.0 国际许可授权。未对原始图像进行任何更改。
介绍
在我的上一篇文章中，我们讨论了图嵌入的目的和本质。主要思想是，为了在图上进行机器学习，我们需要将图转换成一系列向量(嵌入)，然后我们可以使用这些向量来训练我们的机器学习(ML)模型。
问题是图嵌入可能很难调优。与创建嵌入和它们所用于的模型的其他方法类似，我们需要考虑很多超参数，并且针对特定的应用对它们进行优化需要时间。关于调整嵌入的主题，我将留到以后的文章中讨论。
这篇文章是关于开发关于嵌入的超参数的直觉。更具体地说，我将向您展示如何在 Neo4j 中注入由图形数据科学 (GDS)库创建的图形嵌入，然后用 Streamlit 仪表板可视化它们。Tomaz Bratanic 开发了功能来可视化 NEuler Neo4j 工具中的嵌入，但是我将演示如何以一种纯粹的 pythonic 方式来实现这一点。
你可以在 GitHub repo 中找到本教程的所有代码。
入门指南
我们需要做的第一件事是使用免费的 Neo4j 沙箱实例创建一个用于嵌入创建的图。在本次演示中，我们将使用一个预先构建在沙盒中的图表，即《权力的游戏》图表，它是许多图表示例的来源。(这张图贯穿了前 5 本书，我要警告你，《权力的游戏》剧透就要来了！)
当您到达主沙盒页面时，您将希望选择带有预构建数据的图表数据科学类型，并启动项目:
选择带有预建数据的图形数据科学图像。(图片由作者提供。)
您将看到实例被创建。然后，您需要使用右边的下拉菜单获取连接详细信息:
实例的连接详细信息。(图片由作者提供。)
酷毙了。请务必获取 Bolt URL 和密码，因为这些将用于建立我们的连接。如果您单击 Open: Open with Browser，然后单击左上角的数据库图标，您应该会看到一个预先填充的 2642 个节点的图表，这些节点代表人员、地点等。以及各种类型的 16，474 个关系。
《权力的游戏》图表的节点和关系。(图片由作者提供。)
在这一点上，你会想进入回购(你克隆了它，对不对？)并且我们将用这些信息调整 Dockerfile 文件。我喜欢使用 Docker，这样结果是可重复的。因此，根据上面的图像，您将编辑 Dockerfile 文件的最后一行，以读取
(在本文发布时，这个沙盒实例将被关闭。)
太棒了。现在我们可以构建用于建立连接的 Streamlit 容器。我非常喜欢 Streamlit，因为它允许您以最少的编码开销快速创建非常复杂的仪表板。我们现在将通过命令行使用标准命令来构建容器:
docker build -t neo_stream .
然后我们会用
docker run -p 8501:8501 -v $PWD/src:/examples neo_stream
(请注意，如果您在 Windows 上，您将需要调整这些命令。)
在仪表板中可视化嵌入
现在，我们已经启动并运行了 Streamlit 容器，并将其连接到 Neo4j 沙盒实例。现在容器正在运行，它将为您提供您应该使用浏览器导航到的 URL。它看起来会像 http://172.17.0.2:8501。当您这样做时，您应该会看到类似这样的内容:
Streamlit 仪表板的屏幕截图。(图片由作者提供。)
很好。现在让我们看看这里有什么。我们可以做的第一件事是点击“获取图表列表”这将做两件事。首先，如果您得到一些文本，您知道您已经正确地连接到沙箱。其次，如果有任何由 GDS 创建的内存图形(参见 API 文档和本帖了解这些)，那么它们将在此列出。既然我们才刚刚开始，应该不会有。
但是我们现在要创建一个，因为他们是整个 GDS 的支柱。给图形命名并点击“创建内存图形”(没有空格！).这将创建一个单边无向图，查看《权力的游戏》中的哪些人与其他人互动，或(person1:Person)-[:INTERACTS]-(person2:Person)。当我们这样做时，我们将得到一个有 2166 个节点和 7814 个关系的图。注意，无向图将使关系的数量加倍，因为它考虑了从人员 1 到人员 2 和人员 2 到人员 1 的两个方向。剧透:如果你沿着图的自然方向走，你的嵌入看起来会不同:(person1:Person)-[:INTERACTS]->(person2:Person)。
好了，现在是开始工作并创建一些嵌入的时候了。在撰写本文时，我已经实现了 GDS 内置的两个更简单的嵌入，即 FastRP 和 node2vec 。如果你阅读了 API 文档，你可以并且应该使用很多超参数，因为正如我们所知，缺省值往往不会给出最好的结果。我只包含了每种方法的一个子集，但将来会添加更多。对于 FastRP，我有以下内容:
仪表板中包含的 FastRP 超参数。(图片由作者提供。)
您还可以单击 node2vec 的下拉菜单，查看其中有哪些可调参数。我强烈建议您查阅每种嵌入方法的 API 文档，以获得更多关于每种方法的含义的信息，因为详细描述每种方法超出了本文的范围(尽管在以后关于嵌入调优的文章中，我们将深入讨论这一点！).
因此您可以创建 FastRP 和 node2vec 嵌入。现在我们想把它们形象化。但是为了什么目标呢？我们来看看，在这一点上，我们是否无法预测哪些角色是活着的，哪些是死了的。这是一个非常基本的节点分类问题，也是一个很好的起点，因为这是一个监督学习问题。对于这个数据，我将每个人节点标记为 1(如果他们活着), 0(如果他们死了)。
我们将使用[scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.manifold.TSNE.html)中可用的t-分布式随机邻居嵌入 (t-SNE)来执行维度缩减，以便在 2 维空间中可视化。(您可以使用任何降维方法，如 PCA。我对 SNE 霸王龙的选择是任意的。)
我将选取一些随机值并生成一些 node2vec 嵌入，如下所示:
my node2vec 嵌入的演示超参数。(图片由作者提供。)
接下来，我将使用 t-SNE 选项卡来可视化这些嵌入。当我这么做的时候，我得到了这个:
基于以上 node2vec 嵌入的 2D t-SNE 向量。(图片由作者提供。)
哦不！这太可怕了！红色的数据点是死去的人，蓝色的是活着的人。我们希望我们的红色和蓝色点会比这更好地聚集！我把它作为一个练习留给读者，让他们来修补这些值，看看他们是否能做得更好。(相信我，你可以！)
后续步骤
这里需要考虑一些事情。首先，这是一个非常小的图表。所以真正的优化通常会很难。第二，如果我们真的想优化它们，我们需要做的不仅仅是在 2D 看一张更高维度的嵌入的漂亮图片。我们可以使用这样的工具来获得对我们的图最重要的超参数的直觉，然后在 ML 模型中使用这些参数进行网格搜索，以优化我们的相关指标。因此，我鼓励您修改这些超参数，看看会发生什么。
在未来的帖子中，我计划使用更大的图，我们希望可以得到更好的嵌入结果，并在 ML 模型中测试它们。
可视化高维数据
使用 Hypertools——Python 工具箱
来源:https://hypertools.readthedocs.io/en/latest/
数据可视化有助于识别不同数据列之间的隐藏模式、关联和趋势。我们制作不同类型的图表、绘图、图形等。为了理解数据是什么以及不同的列是如何相互关联的。
很容易可视化具有较低维度的数据，但是当涉及具有较高维度的数据时，很难分析或可视化它们，因为在可视化中不可能显示大量维度。
但是，如果我告诉你，有一个 python 工具箱，它不仅创建了视觉上吸引人的可视化效果，而且在单个函数调用中简化了维数约减。
Hypertools 是一个开源的 python 工具箱，它通过自身降维来创建高维数据集的可视化。它主要构建在 matplotlib、sklearn 和 seaborn 之上。在本文中，我们将探索一些可以使用 hypertools 创建的可视化。
让我们开始吧…
安装所需的库
我们将从使用 pip 安装 hypertools 开始。下面给出的命令可以做到这一点。
pip install hypertools
导入所需的库
在这一步中，我们将导入用于创建可视化的所需库。
import hypertools as hyp
创建可视化
现在我们将开始创建不同的可视化效果，看看 hypertools 是如何工作的。
- 基本剧情
# data loading
basic = hyp.load('weights_sample')
# Creating plot
basic.plot(fmt='.')
来源:作者
2.集群剧情
clust = hyp.load('mushrooms')
# Creating plot
clust.plot(n_clusters=10)
来源:作者
3.文集情节
此图用于文本数据集。
text = ['i am from India', 'India is in asia', 'Asia is the largest continent',
'There are 7 continents', 'Continents means earth surfaces ', 'Surfaces covers land area',
'land area is largest in asia']# creating plot
hyp.plot(text, '*', corpus=text)
来源:作者
4。UMAP
from sklearn import datasets data = datasets.load_digits(n_class=6)
df = digits.data
hue = data.target.astype('str')hyp.plot(df, '.', reduce='UMAP', hue=hue, ndims=2)
来源:作者
5.动画剧情
ani = hyp.load('weights_avg')# plot
ani.plot(animate=True, chemtrails=True)
来源:作者
继续尝试不同的数据集，并创建美丽的可视化来解释数据。如果您发现任何困难，请在回复部分告诉我。
本文是与 Piyush Ingale 合作完成的。
参考:https://hypertools.readthedocs.io/en/latest/
在你走之前
感谢 的阅读！如果你想与我取得联系，请随时通过 hmix13@gmail.com 联系我或我的 LinkedIn 个人资料 。可以查看我的Github*简介针对不同的数据科学项目和包教程。还有，随意探索* 我的简介 ，阅读我写过的与数据科学相关的不同文章。
可视化滤波器如何在卷积神经网络(CNN)中工作
使用 Excel 了解边缘检测的工作原理
约翰·巴克利在 Unsplash 上拍摄的照片
在深度学习中，卷积神经网络 (CNN)是一种特殊类型的神经网络，旨在通过多层阵列处理数据。CNN 非常适合像图像识别这样的应用，特别是经常用于人脸识别软件。
在 CNN 中，卷积层是创造奇迹的基本构件。在典型的图像识别应用中，卷积层由几个滤波器组成，用于检测图像的各种特征。理解这项工作如何最好地用类比来说明。
假设你看到有人从远处朝你走来。从远处看，你的眼睛会试图检测图形的边缘，你会试图将该图形与其他物体区分开来，如建筑物或汽车等。当这个人向你走*时，你试着关注这个人的形状，试着推断这个人是男是女，瘦还是胖，等等。随着这个人越来越*，你的注意力转移到这个人的其他特征上，比如他的面部特征，他是否戴眼镜，等等。总的来说，你的关注点从宽泛的特性转移到了具体的特性。
同样，在 CNN 中，有几层包含各种过滤器(通常称为内核)的层，负责检测您试图检测的目标的特定特征。早期层试图集中于广泛的特征，而后面的层试图检测非常具体的特征。
在 CNN 中，每个卷积层中各种滤波器的值是通过对特定训练集进行训练而获得的。在训练结束时，您将拥有一组唯一的过滤器值，用于检测数据集中的特定要素。使用这组滤镜值，您可以将它们应用到新图像上，以便预测图像中包含的内容。
向 CNN 初学者教授的挑战之一是解释过滤器是如何工作的。学生们常常难以想象(并非有意双关)过滤器的用法。正是带着这个目标，我开始写这篇文章。我希望在这篇文章结束时，你会对 CNN 中的过滤器如何工作有一个更好的理解。
获取我们的数据
深度学习的一个经典例子是 MNIST 数据集。我将在我们的例子中使用它。
何 MNIST 数据库(修改后的国家标准与技术研究所数据库)是一个手写数字的大型数据库，通常用于训练各种图像处理系统。
来源:https://en . Wikipedia . org/wiki/MNIST _ 数据库#/media/File:mnistexamples . png
使用 TensorFlow，您可以按如下方式加载 MNIST 数据:
from tensorflow.keras.datasets import mnist
(X_train, y_train), (X_test, y_test) = mnist.load_data()
我现在要做的是使用该数据集中的特定项目，提取其数据，然后将其保存到 CSV 文件中。下面的代码片段可以做到这一点。
item = 66 # index of the digit to load
data = X_train[item] # data is a 2D array# get the rows and columns of the data
rows = data.shape[0]
columns = data.shape[1]# used to store all the numbers of the digits
lines = ''# convert all the cells into lines of values separated by commas
for r in range(rows):
print(data[r])
lines += ','.join([f'{i}' for i in data[r]]) + "\n"# write the lines to a csv file
with open('mnist.csv','w') as file:
file.write(lines)
如果您打开保存的 mnist.csv 文件，您将看到以下内容:
更好的可视化方法是使用 Excel 打开它:
您现在可以非常清晰地看到，这个数据集表示数字“2”。
将滤镜应用于图像
为了直观显示筛选器的工作方式，让我们使用 Excel 并创建一个新的工作表。
我已经把最终的电子表格放在https://bit.ly/2QVLnSS供下载。
首先，用以下值创建一个 28x28 的网格(我们稍后将使用 MNIST 数字的数据；现在我要给你看一些更容易理解的东西):
假设 28x28 网格中的每个值代表一种颜色(255 代表白色，0 代表黑色)。
接下来，创建另一个 28x28 网格，其值是通过将第一个网格中的每个值除以 255 获得的:
接下来，我们创建一个代表过滤器(内核)的 3x3 网格:
过滤器代表我们在图像中寻找的模式类型，其中 1 代表白色，-1 代表黑色。在上面的过滤器中，我在图像中寻找一个垂直边缘，颜色从白色变为黑色，就像这样:
将过滤器应用于网格只是将过滤器中的每个值与网格中的相应值相乘:
过滤器中的每个值都与网格中的相应值相乘，然后求和
应用于图像的滤镜的值；然后，结果的小数部分被截断
生成的网格就是我们试图寻找的特征图。看数值，我们不容易知道特征图的意义。因此，让我们添加一些颜色编码到我们的原始图像和特征地图，以便我们可以清楚地看到我们在寻找什么。
对于这个图像网格，我们希望通过选择整个网格，然后选择格式|条件格式… 来应用颜色:
在管理规则窗口中，点击对话框左下角的+按钮:
如下设置颜色，然后点击确定两次:
网格现在看起来像这样:
我们的图像只是一个中间有一个黑色矩形的白色图像
从图像中可以看到，图像中有两条边，一条从白到黑，另一条从黑到白:
现在让我们也对我们的特征图进行颜色编码(应用了过滤器的图像):
您现在应该看到以下内容:
基于我们的过滤器，白色的列是我们正在寻找的(记住我们正在寻找颜色从白色变为黑色的边缘)。如果我们现在更改过滤器，寻找从黑色变为白色的垂直边缘，那么输出将如下所示:
水*边缘怎么样？嗯，如果您更改过滤器以寻找水*边缘，您将一无所获(这并不奇怪):
现在，您可以看到过滤器如何处理 MNIST 数据集了。将您在上一节中提取的数据(数字“2”)粘贴到工作表中:
标准化和颜色编码的图像现在看起来如下:
如果您想检测水*边缘，请使用以下过滤器:
现在，图像中的所有水*边缘都高亮显示:
使用另一个例子(对于数字“6”):
您可以像这样检测所有垂直边缘:
您也可以检测水*边缘:
每个卷积层中各种滤波器的组合使得 CNN 中的预测成为可能。
自己试试吧
了解过滤器工作原理的最佳方式是亲自尝试。在https://bit.ly/2QVLnSS下载电子表格，使用不同的过滤值，例如:
此外，在 MNIST 数据集中尝试不同的数字。当你这样做的时候，试着使用一些除了数字以外的其他图像！
可视化全球贸易如何塑造气候危机
全球贸易和气候危机有什么关系？很复杂，但是一张图胜过千言万语。
如果决策者想要履行《巴黎协定》中的义务，他们的时间很紧。幸运的是，有很多关于从金融角度理解气候危机的研究可以帮助他们。作为一名数据科学家，我认为查看一些数据并看看是否能找出一些模式会很有趣。
图一。从我以前的博客帖子的中间需求。图片作者。
在我之前的博文中，我使用数据科学工具挖掘全球经济。我使用 Pymrio 和其他几个库以及 Gephi 来可视化基于 Eora26 数据集的全球经济。我发现有一个紧密相连的核心经济体相互进行贸易。世界上大约一半的国家属于这一核心，而其余的国家起着次要的作用。我还发现，在整个 90 年代，美国是全球经济的动力，但中国正在快速赶上。在图 1 中，您可以看到 2014 年几个核心经济体之间的贸易情况。
在这篇博文中，我将尝试使用 PRIMAP-hist 数据集[3]将国际贸易与全球排放数据联系起来，该数据集包括《京都议定书》中包含的所有温室气体，但不包括土地使用变化和林业。该数据包含在 Eora26 中。我将首先解释投入产出理论背后的经济建模思想，以及如何将其与排放数据相结合。之后，我们将深入研究数据。
投入产出表速成班
在投入产出理论中，通过考虑资本流入、流出和在经济中的流动来模拟经济。这种观点认为，最终用户推动经济发展，因为他们提供了对产品的最终需求，而最终需求又产生了供应产品的中间需求。考虑下面的例子。你花 1 美元从木匠那里买了一把钉子。然后你是钉子的最终用户，所以你的购买构成了最终需求。这个木匠没有做钉子，他是从一个批发商那里买的，这个批发商是从一个工厂买的。工厂需要钢材、机器和一堆其他材料来制造钉子。钢铁制造商需要天然气、电力和计算机，并从其他供应商那里购买。这样，所有部门都联系起来，产生中间需求，以满足最终需求。经济中的资本数量不是恒定的，所以为了*衡经济，你还需要关于经济增加值的信息。投入产出表反映了资本如何流入和流出经济，以及经济各部门之间的流动。所有这些信息都被收集到巨大的表格中，例如 Eora26。
不过，首先让我们试着了解一下中间需求和最终需求的规模。
最终和中间需求
在下面的柱状图(图 2)中，我以基本价格(税前)绘制了 2015 年全球最终和中间需求的规模。
图二。2015 年最终和中间需求总量。图片作者。
我们可以看到，*均而言，对全球经济而言，价值 1 美元的最终需求(比如一把钉子)会产生大约 1 美元的中间需求。如果你假设最终需求和经济总产出(中间+最终)之间呈线性关系，你就可以计算出满足最终需求的部门间的资本流动。如果你对这个模型的细节感兴趣，我推荐你阅读这个介绍[4]或者看一看包含我的代码的笔记本。但是我们来看一个例子。
可视化供应链
在下面的图 3 中，我展示了满足建筑部门 1 美元最终需求所需的计算中间需求的可视化(你从那里买了钉子，记得吗？).用于建立模型的数据来自 2015 年。我用 NetworkX 搭建了网络，写了一些代码在 Gephi 中可视化。
图 3。“建筑”部门 1 美元最终需求产生的中间需求。图片作者。
经济中的每个部门都用一个点(节点)来表示，每个部门都用一个箭头(有向边)与所有其他部门相连，箭头通过其大小和黑色来指示资本流动的方向和流动的大小。你会看到也有箭头会自己绕成圈。这表明一个部门内的资本流动。我使用了一个弹簧算法来放置这些点，它们之间的距离对应于中间需求(Force Atlas 2 算法)。节点的颜色对应于建筑部门 1 美元最终需求对总产出的贡献。您可以通过将进入每个节点的所有箭头相加来找到该值(入度)。
我们看到，对“建筑”部门的最终需求*均而言会导致“石油、化工……”、“金属产品”和“金融中介”产生大量产出。相反，在“旅馆和餐馆”以及“电力、煤气和水”部门，该部门似乎没有产生大量产出。但你可以看到供应链中的其他部门在“电、气和水”部门产生产出。尤其是“石油、化工……”和“金属制品”部门。这种类型的可视化使得可视化资本流动和识别供应链中的潜在热点变得非常容易。但你会问，这与气候危机有什么关系？坚持住，因为我们快到了！
排放核算
我们已经学会了一种将最终需求归因于不同部门产出的方法。如果我们知道每个部门的排放量，那么我们可以认为，与该部门产品的最终需求相关的足迹应该与该部门的产出和排放量成比例。这样我们就可以计算出经济的总产出和与经济相关的总排放量。对于给定的最终需求，我们可以计算总足迹，并将其理解为不同部门的贡献。这当然只是一个模型——但是一个直观且可解释的模型。所以让我们开始研究排放数据。
排放与产出的关系 我想知道全球范围内不同行业的产出与排放之间关系的本质。在下面的图 4 中，我展示了一个散点图，其中每个部门的排放量与该部门的总产出一起绘制。
图 4。总排放量散点图，不包括 PRIMAP-hist 数据集中的 LULUCF 和 Eora26 数据集中的输出。
正如你所看到的，每个部门的排放量和其产出之间似乎有一个几乎线性的关系。不过有一个例外。“电力、燃气和水”部门产出一般，但排放量巨大。因此，在包括“电、气和水”的所有供应链中(都是供应链)，该部门对碳足迹的贡献远远大于对总产出的贡献(*均而言)。让我们暂时回到我们的例子。
在图 3 中，您将看到每个节点都有不同的大小。大小表示该部门对总足迹的贡献。你可以看到，虽然“电、气、水”并没有真正贡献间接产出(进入其中的箭头很小，节点离“建设”节点很远)，但它对间接足迹的贡献很大。
像这样的可视化使得识别全球供应链中的排放热点变得容易。例如，即使建筑部门减少了对"电、气和水"的需求，也不会使总足迹发生很大变化，因为所有其他部门也需要"电、气和水"，其中一些部门甚至比"建筑"部门更需要。因此，一个更好的解决方案是改造“天然气、水和电力”部门，以减少单位产出的排放量。
做预测
该模型的强大之处在于，我们还可以预测需求的“微小”变化对整个供应链的影响(微小，因为该模型假设线性，还记得吗？).例如，如果我们将“天然气、水和电力”部门的排放效率提高 10%，我们可以减少多少建筑部门的全球足迹？像这样的信息可能对决策者很重要，但对消费者也很重要，因为是他们的最终需求推动了中间需求。例如，一种类似于本文中概述的方法最*被用来计算丹麦 500 种最受欢迎的食品杂货的足迹。这使得消费者能够就他们的消费习惯如何影响他们的个人足迹做出明智的决定。在丹麦，许多食品杂货都是进口的。因此，与最终需求相关的大量排放发生在国外。我有兴趣了解这在全球范围内的真实程度。接下来让我们来看看。
可视化排放的输出/输入
我解决这个问题的方法是，首先计算所有地区对当地足迹的贡献大小。然后，我将全球总排放量与这些地方排放量的总和进行了比较。我在下面的图 5 中绘制了 1993 年至 2015 年的图表。
图 5。区域总排放量和满足区域需求的排放量。图片作者。
您可以看到，全球排放量在此期间有所增加，总排放量的 85–90%可归因于本地需求的本地贡献。但是，10-15%是进口/出口排放，这仍然是一个很大的贡献，尽管不一定是一件坏事。为了了解一段时间内的发展情况，我在图 6 中绘制了每个地区的足迹与该地区领土排放量的比率。
图 6。Eora26 数据集中各区域的碳足迹与地域排放的比率。
一些较小的国家有非常高和非常低的比率，所以我不得不限制颜色范围从-0.5 到 0.5。你可以看到随着时间的推移，地图变得更加丰富多彩。这一趋势表明排放量的进出口增加。我们还可以从蓝色和红色看出，西方的最终需求似乎倾向于导致向国外排放。对亚洲和非洲部分地区来说，国外的最终需求往往会导致当地的排放。但是该图没有告诉我们在哪些区域之间发生了导出/导入。所以我做了另一个图表…
绘制排放流图
我想了解哪些国家推动了与国际贸易相关的排放。为了做到这一点，我可以绘制每个地区的供应链，并像我们对每个部门一样寻找模式。相反，我计算了 A 地区的最终需求在多大程度上可以归因于所有其他地区的排放。然后，我在区域 A 和所有其他区域之间画了一个箭头，每个箭头的大小和红色反映了该国排放的方向和幅度，这是区域 A 最终需求的结果。我对所有区域都画了一个箭头，并再次使用 Gephi 和 Force Atlas 2 spring 算法显示了图表。您可以在下面的图 7 中看到结果。
图 7。不同国家最终需求导致的当地排放可视化。仅显示高于特定阈值的箭头。图片作者。
记住，箭头指向发射的方向，大小和红色表示发射的大小。我为何时绘制箭头设置了一个阈值，以使可视化效果更漂亮。点(节点)的大小反映了总输入或输出排放量的大小。如果一个区域是排放的净输出者，那么节点的色调是蓝色，如果该区域是排放的净输入者，那么节点的色调是红色。颜色的饱和度和节点的大小表示向/从该区域排放的总输入/输出的量级。例如，美国是最大的排放出口国，因此美国节点是最大的蓝色节点，具有最清晰的蓝色。相反，中国是最大的排放进口国，所以它的红色最明显。中国节点的大小大于美国节点，这表明中国的净排放量进口大于美国的净排放量出口。
我们看到，西方和一些亚洲国家的最终需求推动了中国的排放。有趣的是，中国的最终需求似乎推动了俄罗斯的排放，而俄罗斯的最终需求似乎推动了白俄罗斯的排放。香港的最终需求似乎也推动了中国的排放。但是一张图胜过千言万语，所以我鼓励你自己去探索可视化，看看你是否能发现一些有趣的模式。让我知道你有什么意见。
所有这些排放的进口和出口并不一定是坏事。如果中国和印尼的单位产出排放效率高于它们出口产品的国家，那么这实际上是一件好事。不幸的是，他们不是。因此，虽然一些西方国家的本土排放正在减少，但这是以更大的海外足迹为代价的。决策者应该记住这一点。
我是博客新手。所以，如果你有任何意见或建议，请告诉我。你可以在这里找到 代号 。也可以在LinkedIn上找我。
[1] Lenzen M，Kane moto K；Moran D 和 Geschke A (2012 年)绘制世界经济结构图。环境科学&技术46(15)PP 8374–8381。 DOI: 10.1021/es300171x
[2] Lenzen，m .，Moran，d .，Kanemoto，k .，Geschke，A. (2013) 建立 Eora:高国家和部门分辨率的全球多区域投入产出数据库。经济系统研究，25:1，20–49，DOI:10.1080/09535314 . 2013 . 769938
[3] Gütschow，j .，Jeffery，M. L .，Gieseke，r .，Gebel，r .，Stevens，d .，Krapp，m .，& Rocha，M. (2016 年)。PRIMAP-hist 国家历史排放量时间序列。 地球系统科学数据， 8 (2)，571–603。https://doi.org/10.5194/essd-8-571-2016
[4]莱昂蒂夫，W. (1970 年)。环境影响和经济结构:投入产出方法，《经济学和统计学评论》，第 52 卷，第 3 期(1970 年 8 月)，第 262-271 页，麻省理工学院出版社。经济与统计评论， 52 (3)，262–271。
使用 CNN 以有趣的新方式提取特征
Everingham 等人的图片来自 PASCAL VOC2012 数据集
使用分类模型分割图像。
解开由深度卷积神经网络(CNN)学习的特征是一项涂抹任务。通过每一层来可视化过滤器或功能与网络深度的比例很低，尽管通过这一过程可以创建一些很酷的图形，但结果可能非常抽象，甚至是迷幻。诸如 gradCAM 或制导反向投影之类的技术，通过计算哪些输入像素在受到干扰时会导致网络输出的最大变化，从而避开了检查单个激活的需要。如 Adebayo et al. 早在 2018 年所示，一些基于显著性的模型可解释性技术给出的结果与基本边缘检测算法过于相似。例如，引导反向投影被发现产生看起来独立于模型参数和数据标签的可视化。
今天，我们探索了一种理解 CNN 内部工作的替代方法，通过创建一个交互式可视化来显示网络中任何给定层的两个图像的特征之间的相似性。程序很简单:
- 对每个图像执行正向传递，以提取所需网络层的特征
- 在每幅图像上创建一个不可见的格网覆盖，其中像元的数量等于所提取特征的尺寸
- 从 img1 中选择一个方格，并计算该特征与 img2 中所有可能特征位置的相似性
我们使用 ResNet-18 模型在来自 PASCAL VOC2021 数据集的一些随机选择的图像对上可视化该过程。使用双线性插值将图像调整为 512x512 像素。请注意，由于我们使用的是 ResNet 模型中的第 4 个块，网络的这一部分会以 32 倍的因子对原始分辨率进行下采样，因此我们最终会得到 16x16 维的要素地图。在左边的图片( img1 )中，用户可以点击任意一个高亮显示为黄色的方块。这个正方形的 x 和 y 索引随后被用于索引该图像的特征图，该图像仅仅是 512 通道向量。余弦相似性被用作相似性度量，以将该特征向量与 img2 的特征图中的所有 16×16 特征向量进行比较。
特征相似性热图块 Everingham 等人从 PASCAL VOC2012 数据集获得的图像
结果有些令人惊讶，因为这些特征图中每个神经元的感受野几乎是整个图像，然而可视化的相似性仍然严重依赖于位置。这表明学习的过滤器和汇集的组合减弱了激活，以防止蓝天特征泄漏到飞机机翼特征中。
那么，我们能从这样的可视化中得出什么结论呢？如果我们观察像下面这样网格分辨率较大的较浅的层，很明显这些特征的相似性可用于分段目的:
特征相似性热图块 Everingham 等人从 PASCAL VOC2012 数据集获得的图像
这是一个有趣的结果，因为我们正在寻找的 ResNet-18 是为图像分类而不是分割而训练的。假设你有一个训练图像和一个分割蒙版。可以通过从训练图像和测试图像的所有可能区域计算前景区域的特征相似性来分割测试图像。那么可以通过视觉检查来设置阈值，以控制所生成的分割掩模的 IoU。这项任务听起来很像少数镜头语义分割，模型应该在测试时通过将我们有遮罩的图像的特征相似性传播到我们没有遮罩的图像来概括新的对象。让我们看看使用第 4 块中的特性效果如何，这次使用的是 ResNet-50 模型:
使用 ResNet-50 block 4 特征的特别分割 Everingham 等人从 PASCAL VOC2012 数据集中获得的图像
考虑到这种无需任何培训的开箱即用的工作方式，结果令人惊讶地好。在如此低分辨率的网格(仅 16x16)下，生成的蒙版捕捉了太多*面周围的区域，因此让我们看看是否可以通过使用 block 3 功能来解决这个问题:
使用 ResNet-50 block 3 特征的特别分割 Everingham 等人的图像来自 PASCAL VOC2012 数据集
遗憾的是，这个区块中的特征并没有表现出足够高的水*，并且过于关注纹理，正如飞机的白色机身与灰色天空过于相似所证明的那样。这是可以通过任务特定的调优来解决的问题，尽管这不是本文所关注的。
在试图理解 CNN 的内部工作方式时，我们偶然发现了一种特别的方法，它可以用作少量镜头分割的基线。我们还可以使用这种技术来可视化自相似性，即在左右面板中使用相同的图像来查看模型在训练过程中是否正在学习语义上有意义的特征。例如，我们期望图像中的前景对象区域与其他前景区域比与背景更相似。对于分割，这种技术的性能并不接*实际训练用于分割任务的方法。然而，它确实证明了为分类而学习的特征可以重新用于分割。这些可视化的代码将很快发布到我的博客上，所以请继续关注这个系列的下一篇文章。
可视化印度的地震活动
在 Jupyter 笔记本中无缝分析和可视化地震数据
上周，我住的地方附*发生了一次轻微的地震。它发生在清晨，几乎感觉不到(感谢上帝)。事实上，我们只是从每日新闻中知道这件事的。
这让我开始寻找印度地震的模式和历史。在网上搜索资源的时候，我偶然发现了一篇来自 Giuseppe Macrì 的精彩文章，标题为 制作了 40 年来加州地震的动画 ，他分析了 40 年来加州的地震数据。事实上，朱塞佩之所以决定可视化地震数据集，是因为当时加州发生了一场小地震。我想这太巧合了😃。他写道:
一天，在看新闻时，我注意到加利福尼亚发生了一次小地震。我认为地震数据将会是一个有趣的可视化。
在阅读这篇文章时，我对用于分析的工具 Kepler.gl 印象深刻。所以我决定复制印度地震数据集的结果，结果如下所示:
分析印度自 2019 年以来的地震数据|作者图片
相当酷！没错。因此，在本文中，我将帮助您了解 Kepler.gl 是什么，以及它如何使可视化和分析地理空间数据成为一项无缝任务。我希望读完这篇文章后，您能够将它用于您的数据集。
使用 Kepler.gl 实现地理空间数据可视化
地理空间数据是指与地球表面特定位置相关的基于时间的数据。这是有用的，因为它可以揭示景观中的重要模式和趋势。有许多库可以用来分析这样的数据，但是通常需要大量的手工操作。地理空间数据的内存管理是另一个问题。这意味着此类数据的数量级使得轻松处理和分析数据变得有些困难。
Kepler.gl 是一款强大的开源地理空间分析工具，适用于大规模数据集。Kepler.gl 由优步开发，是一个数据无关的高性能网络应用程序，适用于大规模地理定位数据集。您可以非常容易地在数据集中找到模式，组合不同的数据集，实时执行聚合和操作。如果数据集有时间戳、地理点和一些元信息，Kepler.gl 可以自动提取信息并将其可视化。文档非常强大，我强烈建议您阅读它以获得更多信息。
装置
开普勒有多种使用方式。gl。用户可以直接在网络浏览器中使用，也可以在本地安装。还为常见的数据分析工具构建了一系列插件，如 Jupyter 、 Tableau 和 Visual Studio Code 。然而，在本文中，我将只关注 Jupyter，但是它也可以与其他两个无缝地协作。
虚拟环境
为了轻松安装，建议创建一个虚拟环境。让我们使用venv来创建这个新的虚拟环境，并将其命名为**geoviz.**
# Creating virtual environment in Mac/Linux
python3 -m venv geoviz #Creating virtual environment in Windows
py -m venv geoviz# Activating the environment
source geoviz/bin/activate
一旦环境被激活，用 pip 安装 Kepler.gl。
#Run the following cell in your command line
pip install keplergl
推出 Jupyter 笔记本
jupyter notebook
与 Jupyter 笔记本不同，Jupyter 实验室需要一些额外的安装，如[node](https://nodejs.org/en/download/package-manager/#macos) > 10.15.0 和 jupyter labextension。详细说明参见详细用户指南。
资料组
有一个名为国家地震学中心的门户网站，它是印度政府监测该国地震活动的节点机构。它监测、操作和维护由 115 个台站组成的国家地震网络。你可以从这里下载公开可用的数据集。我正在寻找一个更广泛的数据库，但根据门户网站，我们无法在 2019 年 8 月 1 日之前访问数据。
探索数据
让我们导入数据并查看各种属性。
df = pd.read_csv('Indian_earthquake_data.csv')
df.head(10)
2021 年 7 月 31 日，当我写这篇文章的时候，印度北部发生了地震
该数据集包括自 2019 年 8 月 1 日以来每一次地震的date、time、location、depth和magnitude的记录。震级是指震源产生的地震波的振幅或大小。《大英百科全书》对此有一个极好的、直观的解释。它指出:
地震震级是由地震源产生并由地震仪记录的地震波“大小”或振幅的量度。(这些波的类型和性质在地震波一节中描述。)因为地震的大小变化很大，为了进行比较，有必要用数学方法压缩地震图上测得的波幅范围。1935 年，美国地震学家查尔斯·f·里克特(Charles F. Richter)建立了一个地震震级表，以标准地震仪(Wood-Anderson 扭摆地震仪)记录的最大地震波振幅(以千分之一毫米为单位)的以 10 为底的对数作为地震震级表。
预处理数据
数据是干净的，格式是正确的，但是我们将通过从Location列中提取Place来做一些小的预处理。这就是要有短标签而不是长句，这样会把地图挤得水泄不通。如果我们手动分析数据，我们也可以提取其他基于时间的特征，但是我们将在这里跳过这一部分。
预处理数据集|按作者分类的图像
用 Kepler.gl 可视化
现在我们已经有了想要的格式的数据集，是时候开始了。
步骤 1:加载底图
第一步是使用 KeplerGl() 类创建一个地图对象，它可以接受三个可选的参数:
- 高度 Kepler.gl 微件的高度
- 数据—要添加到地图中的数据，
- 配置 Kepler.gl 映射的配置文件
from keplergl import KeplerGl
map_1=KeplerGl(height=600)
map_1
加载底图|图片 b 作者
步骤 2:向地图添加数据
接下来，我们将把我们的数据帧添加到 Kepler.gl 中，并为其指定一个名称。
map_1.add_data(data=df, name='Indian Earthquake Visualization')
将数据添加到地图|图像 b 作者
Kepler.gl 自动检测纬度和经度列，并为它们创建绘图。
自定义
Kepler.gl 提供了一些重要的定制，可以真正增强可视化。如果您单击地图左侧的箭头，将会看到几个选项。这些使您能够对您的地图进行一些更改，如添加更多的层，应用过滤器，互动，以及更改底图。让我们一个一个地看。
自定义|作者图片
层层
图层是可以在彼此之上构建的特定数据可视化。例如，上面的可视化显示了一个点图层，其中每个事件都根据其位置呈现为一个点。同样，也可能有弧图层、线图层、热点图等等。每一层都有特定的属性，可以根据用户的需求进行调整。在下图中，我们实验了不同的图层选项，然后改变了点的半径和颜色。
自定义图层|作者图像
此外，我们还可以根据选定的字段给点着色。假设我们希望看到数据点的颜色和大小与它们的大小有关。
数据点的颜色和大小取决于它们的大小|图片由作者提供
互动
交互意味着用户如何与地图交互。这包括定制工具提示显示，用光标高亮显示区域，显示坐标。
自定义互动|作者图片
地图样式
还有一个修改底图样式的选项。您也可以使用地图框样式链接添加自己的自定义地图样式。
按作者修改底图样式|图像
时间回放
这是 Kepler.gl 最显著的特性之一。您可以通过添加一个基于时间相关字段的过滤器来创建一个事件的回放视频，在我们的例子中是Origin Time.
时间回放功能|作者图片
保存和导出地图
对可视化效果感到满意后，您可以将地图导出为交互式 HTML 文件，也可以保存 Jupyter 笔记本的微件状态，以便每次打开笔记本时加载当前地图。
按作者保存和导出地图|图像
Visual Studio 中的 Kepler.gl
对于那些喜欢使用 VS 代码的人来说，你不需要失望。检查此链接以安装扩展。
Visual Studio 中的 Kepler.gl 作者图片
结论和进一步阅读
地理空间数据分析是一个重要的研究领域。它提供关于实时发生的事件的非常有用的信息，如人口普查数据、卫星图像、天气数据等。可视化这样的数据具有巨大的价值，因为不可能通过电子表格和表格来衡量这样的数据。像 Kepler.gl 这样的工具可以广泛地帮助解决这个问题，从而使分析变得更快、更容易、更准确。
可视化 Keras 模型
创建模型摘要的图像
Keras 模型可视化(来源:作者)
你有没有想过你的神经网络实际上是如何连接不同的神经元的？如果你能把你设计的模型架构可视化，那不是很好吗？如果您可以下载您的模型架构作为图像，以便在演示时使用，这不是很好吗？如果你对所有这些都有肯定的回答，那么你就来对地方了。
在本文中，我将向您展示一个令人兴奋的 python 包/模块/库，它可以用来可视化您的 Keras 模型。无论是卷积神经网络还是人工神经网络，这个库都将帮助您可视化您所创建的模型的结构。
Keras Visualizer 是一个开源 python 库，在可视化模型如何逐层连接方面非常有用。所以让我们开始吧。
安装 Keras 可视化
我们将使用 pip install 像安装任何其他 python 库一样安装 Keras Visualization。我们将在本文中使用 google collab，所以您需要复制给定的命令，并在 Google Collab 中运行它来安装库。
!pip3 install keras-visualizer
创建神经网络模型
为了理解这篇文章，你应该对如何创建一个神经网络有一个基本的了解。
现在让我们使用 Keras 及其函数创建一个基本的人工神经网络。在这个神经网络中，我将输入形状作为(784，)并相应地设计它，您可以创建自己的网络，因为在这里我们不是学习如何创建 NN，我们只是将我们创建的最终模型可视化。
from keras import models
from keras.layers import Dense, Conv2D, MaxPooling2D, Flatten, Activation
from keras_visualizer import visualizer
from keras import layers
model1 = models.Sequential()
model1.add(Dense(16, input_shape=(784,)))
model1.add(Dense(8))
model1.add(Dense(4))
人工神经网络(来源:作者)
在图中，您可以清楚地看到我们的模型是如何构建的，不同的层是如何通过大量的神经元和每层的激活功能相互连接的。
让我们想象一个卷积神经网络，它将使我们更好地了解这个库如何帮助我们可视化 CNN。
# Building model architecture
model = models.Sequential()
model.add(Conv2D(8, (3, 3), padding="same",input_shape=(224,224,3), activation="relu"))
model.add(MaxPooling2D(pool_size=(3, 3)))
model.add(Conv2D(16, (3, 3), padding="same", activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(32, (3, 3), padding="same", activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(32, activation="relu"))
model.add(Dense(10))
model.summary()
visualizer(model, format='png', view=True)
卷积神经网络(来源:作者)
在这里，您可以清楚地看到在不同层上执行的所有操作，包括过滤器数量、过滤器大小、神经元数量等。
这就是如何使用 Keras Visualizer 可视化您的深度学习模型。试试这个，让我知道你在回复部分的经历。
本文与 皮尤什·英格尔 合作。
在你走之前
感谢 的阅读！如果你想与我取得联系，请随时通过 hmix13@gmail.com 联系我或我的 LinkedIn 个人资料 。可以查看我的Github*简介针对不同的数据科学项目和包教程。还有，随意探索* 我的简介 ，阅读我写过的与数据科学相关的不同文章。
深度神经网络的可视化学习
使用深度重放来可视化神经网络学习
Keras 模型学习(来源:作者)
深度学习通常被认为是一种黑箱技术，因为你通常无法分析它在后端是如何工作的。你创建一个深度神经网络，编译它，然后将其应用于你的数据，我们知道它将使用神经元来传输信息，使用不同的层和所有的激活和其他重要的超参数。但是我们无法想象信息是如何传递的，或者模型是如何学习的。
如果我告诉你，有一个 python 包可以创建模型在每个迭代/时期如何工作或学习的可视化。您可以将这种可视化用于教育目的，或者向其他人展示您的模型是如何学习的。如果这让你兴奋，那么你来对地方了。
Deep Replay 是一个开源的 python 包，旨在让您可视化地回放您的模型训练过程是如何在 Keras 中进行的。
让我们开始吧……
设置 Colab 笔记本
对于本文，我们将使用 google colab，为了使用它，我们首先需要设置一个笔记本。复制并运行下面给出的代码，以准备好您的笔记本。
# To run this notebook on Google Colab, you need to run these two commands first
# to install FFMPEG (to generate animations - it may take a while to install!)
# and the actual DeepReplay package!apt-get install ffmpeg
!pip install deepreplay
该命令还将安装我们需要的库，即深度重放。
导入所需的库
因为我们正在创建一个深度神经网络，所以我们需要导入所需的库。
from keras.layers import Dense
from keras.models import Sequential
from keras.optimizers import SGD
from keras.initializers import glorot_normal, normalfrom deepreplay.callbacks import ReplayData
from deepreplay.replay import Replay
from deepreplay.plot import compose_animations, compose_plotsimport matplotlib.pyplot as plt
from IPython.display import HTML
from sklearn.datasets import make_moons%matplotlib inline
加载数据并创建重放回调
在这一步中，我们将加载我们将要处理的数据，并且我们将为可视化的重放创建一个回调。
group_name = 'moons'X, y = make_moons(n_samples=2000, random_state=27, noise=0.03)replaydata = ReplayData(X, y, filename='moons_dataset.h5', group_name=group_name)fig, ax = plt.subplots(1, 1, figsize=(5, 5))
ax.scatter(*X.transpose(), c=y, cmap=plt.cm.brg, s=5)
数据(来源:作者)
创建 Keras 模型
现在，我们将使用不同的层、激活和所有其他超参数来创建 Keras 模型。此外，我们将打印模型的摘要。
sgd = SGD(lr=0.01)glorot_initializer = glorot_normal(seed=42)
normal_initializer = normal(seed=42)model = Sequential()
model.add(Dense(input_dim=2,
units=4,
kernel_initializer=glorot_initializer,
activation='tanh')) model.add(Dense(units=2,
kernel_initializer=glorot_initializer,
activation='tanh',
name='hidden'))model.add(Dense(units=1,
kernel_initializer=normal_initializer,
activation='sigmoid',
name='output'))model.compile(loss='binary_crossentropy',
optimizer=sgd,
metrics=['acc'])model.summary()
摘要(来源:作者)
现在让我们训练模型
在训练模型时，我们将把回调传递给 fit 命令。
model.fit(X, y, epochs=200, batch_size=16, callbacks=[replaydata])
构建空图形
现在，我们将创建一些空白图，在这些图上我们将绘制与模型学习相关的数据。
fig = plt.figure(figsize=(12, 6))
ax_fs = plt.subplot2grid((2, 4), (0, 0), colspan=2, rowspan=2)
ax_ph_neg = plt.subplot2grid((2, 4), (0, 2))
ax_ph_pos = plt.subplot2grid((2, 4), (1, 2))
ax_lm = plt.subplot2grid((2, 4), (0, 3))
ax_lh = plt.subplot2grid((2, 4), (1, 3))
下一步，我们只需要将数据传递到这些空的可视化中，并创建所有迭代/时期的视频。视频将包含每个时期的学习过程。
replay = Replay(replay_filename='moons_dataset.h5', group_name=group_name)fs = replay.build_feature_space(ax_fs, layer_name='hidden',
xlim=(-1, 2), ylim=(-.5, 1),
display_grid=False)
ph = replay.build_probability_histogram(ax_ph_neg, ax_ph_pos)
lh = replay.build_loss_histogram(ax_lh)
lm = replay.build_loss_and_metric(ax_lm, 'acc')
创建样本图
sample_figure = compose_plots([fs, ph, lm, lh], 160)
sample_figure
制作视频
sample_anim = compose_animations([fs, ph, lm, lh])
HTML(sample_anim.to_html5_video())
可视化视频(来源:作者)
这就是我们如何将深度重放用于深度神经网络训练过程。试试这个，让我知道你在回复部分的经历。
本文与 皮尤什 合作。
在你走之前
感谢 的阅读！如果你想与我取得联系，请随时通过 hmix13@gmail.com 联系我或我的 LinkedIn 个人资料 。可以查看我的Github*简介针对不同的数据科学项目和包教程。还有，随意探索* 我的简介 ，阅读我写过的与数据科学相关的不同文章。
用 7 美元的智能灯泡观察当地电网污染。
气候爱好者的物理数据可视化。
作者图片
结合来自 WattTime API 的电网清洁度评分和的廉价智能灯泡，我将演示“电网灯泡”的创建过程，它可以可视化当地电网在任何时刻有多脏。知识就是力量，知道我们当地的能源生产何时更清洁，使我们能够通过决定何时消耗一些电力来选择减少污染和碳排放。在 WattTime 与 Geoff Hancock 的一次谈话激发了这个项目。
在我们开始之前，你应该知道，我通过本帖中的代销商链接购买任何物品都会获得佣金。该委员会有助于支持今后设立像这样的职位。
每当你打开插在墙上的电气设备，你就增加了对电网的少量需求。发电厂通过增加产量向电网提供必要的能量来满足这一需求。如果发电厂燃烧煤炭，插入你的设备会比发电厂甚至天然气发电厂产生更多的碳排放。你的设备消耗的能量越多，差别就越大。因此，通过了解什么时候你的电网是最干净的，你可以通过选择什么时候给你的电动汽车充电来减少你的排放量。
但是我们怎么知道什么时候我们的网格是最干净的呢？我使用了由 WattTime 提供的创新 API。WattTime 是一个非盈利组织，旨在回答“我现在用的电有多干净？”他们已经为美国、加拿大和其他强制要求发电厂报告排放的国家回答了这个问题。他们目前正致力于通过与 ClimateTrace 的合作将这种能力扩展到世界其他地方。
WattTime API 对每个网格进行评分，分值范围为 0-100，其中 0 表示最干净，100 表示最脏。这是为我们的“电网灯泡”供电的实时数据
我正在使用这个 $7 灯泡，它像大多数廉价智能设备一样，连接到图雅*台。这些灯泡暴露了一个本地 API，可以从我们局域网上的任何计算机直接与它们通信，这意味着我们不需要智能集线器或任何其他智能设备来工作。如果您通过本文中的链接购买灯泡，我可能会收到
结合这两个 API 和一点 Python，我们将创建一个显示当前网格清洁度的灯，绿色表示最干净，红色表示最脏。
WattTime API
WattTime API 使用起来很简单，文档提供了很好的例子。虽然数据计划页面有点混乱，但我发现免费计划允许访问当前的本地电网条件。
我们将通过以下方式获得排放分数:
- 注册 WattTime API。
- 认证。
- 用谷歌地图确定我们的纬度和经度。
- 获得实时排放量。
注册 WattTime API
你通过 API 本身注册 API，效率非常高。记得用你的信息替换USER_NAME、PASSWORD、EMAIL和ORG。
import requestsparams = {'username': 'THE USER_NAME YOU WANT',
'password': 'THE PASSWORD YOU WANT',
'email': 'YOU EMAIL',
'org': 'ORG NAME'}register_url = '[https://api2.watttime.org/v2/register'](https://api2.watttime.org/v2/register')
rsp = requests.post(register_url, json=params)
print(rsp.text)
如果一切顺利，您将获得一条成功消息，显示您已经成功注册了该 API。
{"user":"benbogart","ok":"User created"}
如果出现错误，请相应地调整参数。在下面的情况下，我们将不得不选择一个不同的用户名，然后再试一次。
{"error":"That username is taken. Please choose another."}
鉴定
WattTime API 使用 HTTP 基本认证将您的用户名和密码交换为访问令牌。这也很简单，使用requests.auth中的HTTPBasicAuth。
from requests.auth import HTTPBasicAuthlogin_url = 'https://api2.watttime.org/v2/login'
auth = HTTPBasicAuth(params['username'], params['password']))rsp = requests.get(login_url, auth=auth)
token = rsp.json()['token']print(rsp.json())
检查响应以确保您收到了令牌。如果是这样，我们可以继续前进。
用谷歌地图确定我们的纬度和经度
在这个例子中，我将使用位于市政厅的布鲁明顿。你应该用你的地址。
搜索您的地址，然后右键单击、双指单击或 ctrl+单击地图上的红色大头针。这将弹出一个对话框，显示大头针的纬度和经度。单击纬度和经度，这会将它们复制到您的剪贴板。
作者图片
我们现在将这些值分配给latitude和longitude。
lat = 39.17100708872063
long = -86.53651334662412
获取实时排放
现在，我们拥有了获取本地区实时排放量所需的一切。
index_url = '[https://api2.watttime.org/index'](https://api2.watttime.org/index')params = {'latitude': lat, 'longitude': long}rsp=requests.get(index_url, headers=headers, params=params)print(rsp.text)
它会返回类似这样的内容:
{
"freq": "300",
"ba": "MISO_INDIANAPOLIS",
"percent": "57",
"point_time": "2021-07-31T17:00:00Z"
}
freq显示数据更新的频率。ba是地区。percent是我们地区当前的污染值。point_time是最后一次更新分数的时间。
我们将使用percent来更新智能灯泡的颜色。
连接到智能灯泡
这里的指示是连接到专为图雅*台设计的 wifi 智能灯泡。绝大多数低成本智能设备都使用这个*台，包括任何使用智能生活 app 的灯泡。
这些灯泡暴露了一个 API，允许我们通过本地网络直接控制它们。不幸的是，我们需要经历一些困难才能获得灯泡的 API 密钥。此外，这些灯泡通常只能在 2.4Ghz 网络上工作。
图雅使用智能手机应用程序将智能设备连接到当地的 wifi 网络，并在图雅网络上注册。在图雅*台上注册设备可以让我们检索灯泡的 API 密钥，因此虽然我们不会使用图雅*台或智能生活应用程序来控制灯泡，但我们仍然必须注册灯泡以获得 API 密钥来访问灯泡的 API。
以下是我们连接灯泡的步骤。
- 下载并设置智能生活应用程序。
- 将灯泡连接到我们的 wifi，并在智能生活应用程序中注册。
- 通过图雅开发者*台获取灯泡的 API 密钥。
- 连接灯泡。
下载并设置智能生活应用程序
将灯泡连接到我们的 wifi，并在智能生活应用程序中注册
大多数现代 wifi 网络在一个网络 id 上同时使用 2.4Ghz 和 5Ghz 频道。我们的廉价灯泡只能使用 2.4Ghz 网络，当使用智能生活应用程序的默认 EZ 配对方法时，它会变得混乱。我们将它与“AP 模式”配对，这似乎可以解决这个问题。这个方法比“EZ”方法长一点，但这是我们为便宜付出的代价。
- 在智能生活应用程序中，点击“添加设备”或屏幕左上角的+图标。
- 在“手动添加”标签中，选择照明和您购买的灯泡种类。我选了“光源(Wi-Fi)。”
作者图片
- 更改配对模式。以下屏幕将要求我们重置设备。在此之前，请点击右上角的“EZ 模式”然后，从出现的菜单中选择“AP 模式”
作者图片
- 接下来，连续两次复位灯泡:先关再开 3 次，等灯泡开始快速闪烁，再关再开，等开始缓慢闪烁。
- 当缓慢闪烁时，灯泡会创建一个 wifi 热点。智能生活应用程序会引导你进入 wifi 设置并连接灯泡。
作者图片
- 返回应用程序并完成配对。现在你应该可以在智能生活应用中看到你的灯泡了。这是一个玩应用程序的好时机，看看你的灯泡能做什么。
作者图片
通过图雅开发者*台获取灯泡的 API 密钥
现在灯泡连接到我们的本地网络，我们可以从我们的手机控制它，下一步是获得设备 id，并从图雅开发者*台提取 API 密钥。
第一部分:图雅设置
- 在 iot.tuya.com创建一个免费的图雅开发者账户。(选择登录框下方的“注册”)。
- 您可以跳过“组织类型”对话框。
- 登录后，选择左侧导航栏中的“云”。第一次这样做时，图雅会让你选择一个计划。选择免费的“试用版”并查看。您必须像购买该计划一样结账，但您不会被收取任何费用，也不必提供任何付款信息。
作者图片
- 回到物联网*台，再次选择云。这次选择“创建云项目”
- 填写“创建云项目”对话框，确保选择“智能家居”作为开发方法。
作者图片
- 在下一个屏幕上，验证“智能家居设备管理”、“授权”和“智能家居家庭管理”是否列在选定的 API 产品下，然后单击授权。
作者图片
- 在这一步之后，图雅将带你去你的新项目。前往“设备”选项卡，选择“链接图雅应用程序帐户”
作者图片
图雅将展示一个二维码，我们需要用我们的智能生活应用程序扫描。在手机的智能生活应用程序中，进入“我”和屏幕右上角的扫描图标。这将调出一个二维码阅读器。
作者图片
- 扫描二维码后，点击“确认登录”，您的设备将出现在物联网*台的图雅物联网*台设备选项卡中。
作者图片
先不要关闭这一页。我们还需要两条信息，但是我们已经完成了帐户设置。
第 2 部分:获取 API 密钥
现在一切就绪，我们可以提取灯泡的 API 密钥了。我发现tinytuya包既有提取 API 密钥的最简单的方法，也有连接灯泡的最简单的方法。
- 安装
tinytuya
*pip install tinytuya*
- 获取设备 id:要登录 API，我们需要与帐户相关联的任何智能设备的 Id。因为我们只有一个灯泡，所以我们需要获取它的设备 id。我们可以从命令行使用
tinytuya来完成这项工作。
*$ python -m tinytuya scan*
作者图片
这将轮询本地网络上设备的端口 6666 和 6667，并返回任何图雅设备。我们可以从上面的扫描中看到，设备 ID 以蓝色列出。
- 导航至将在其中创建 python 脚本的目录。下面的向导生成一个 JSON 文件，该文件必须保存在与脚本相同的目录中。
- 在命令行上运行以下命令，然后继续阅读在哪里检索每个请求的项目。
*python -m tinytuya wizard*
- 从图雅项目页面输入您的 API 密钥(又名客户端 ID)和 API 秘密(又名客户端秘密)。
作者图片
- 输入您在上一步中通过微型 tuya 扫描获得的设备 ID
- 从列表选项中输入最*的区域。
结果看起来会像这样。
作者图片
好了，所有的难题都解决了！我们不需要图雅 API 来做任何其他事情，但如果你从你的智能生活应用程序中移除灯泡，你将需要重复上述步骤。
现在来看看魔术。
连接灯泡
我们有直接连接灯泡所需的一切。在一个地方看到这一切的最简单的方法是重复设备扫描，现在我们已经连接到图雅 API。
- 在命令提示符下重复设备扫描…
*$ python -m tinytuya scan*
…或者在 Jypyter 笔记本中。
*import tinytuya
intytuya.scan()*
这次扫描给了我们连接灯泡所需的一切，包括本地 API 密钥。
注意:这需要访问由
tinytuya wizard生成的 devices.json 文件。确保从同一目录运行该命令，或者将 devices.json 复制到您的工作目录。
作者图片
- 在您的笔记本或代码编辑器中，通过替换下面代码中灯泡的详细信息来连接灯泡。
*bulb = tinytuya.BulbDevice(dev_id='DEVICE ID',
address='ADDRESS',
local_ley='LOCAL KEY')
bulb.set_version(VERSION)
print(f'set status result {bulb.status()}')*
如果连接成功，您将得到类似如下的响应:
*set status result {'devId': '42313382e09806b2e707', 'dps': {'20': True, '21': 'white', '22': 1000, '23': 1000, '24': '000003e803e8', '25': '000e0d0000000000000000c80000', '26': 0}}*
- 摆弄一下灯泡。当这个成功的时候，你可以尽情地大笑。
试着打开灯泡:
*bulb.turn_on()*
关闭灯泡:
*bulb.turn_off()*
在 0-100 的范围内设置亮度:
*bulb.set_brightness_percentage(25)*
设置灯泡的颜色:
*bulb.set_colour(0,255,255)*
你可以在[tinytuya](https://pypi.org/project/tinytuya/) 文档中找到tinytuya支持命令的完整列表。
可视化智能灯泡上的瓦特时间分数
剩下的就是使用智能灯泡来显示灯泡上的 watt time grid dirty 得分。我选择红色代表最脏的，绿色代表最干净的，因为我觉得这很直观，也因为数学很简单。
你可以在下面或者在 Github 库中找到代码。将文件另存为gridbulb.py并用python gridbulb.py运行。脚本会一直运行，直到你用ctrl + c停止它。不要忘记用您的信息替换方括号中的字段。
注意:你可以通过添加
&在后台运行脚本。这将派生脚本，给它自己的进程 id。如果你以前没有这样做过，我在这里推荐一些关于这个主题的轻松读物。
结论
虽然这篇文章是关于在一个智能灯泡上可视化您的本地能源网格有多干净，但是每个组件都可以应用于其他任务。你可以将一个智能开关连接到你的电动汽车充电器上，这样你的汽车只能用最清洁的能源充电。你可以在你的智能灯泡上想象比特币的波动分数。可能性只受到你想象力的限制。
连接一个便宜的智能灯泡需要大量的努力，但我们只需经历一次磨难。不过，如果我不得不再次这样做，我可能会考虑多花几美元买一个可以直接连接到我的三星智能集线器的灯泡。不过，希望使用 7 美元的灯泡能让更多人接触到它。
现在去用你的智能灯泡做点好事吧。
资源
- GitHub 库为本帖
- WattTime API 文档
[tinytuya](https://pypi.org/project/tinytuya/)文档- 亚马逊上售价 7 美元的智能灯泡
用树叶可视化 2017 年墨西哥野火
数据新闻
一个难以置信的，强大的和友好的工具来显示地理空间数据
最后用叶可视化。由 E. Camacho 制作
作者:
阿罗约-贝拉斯克斯·艾萨克；卡马乔-佩雷斯·恩里克
介绍
在世界范围内，火灾发生的规模、频率和强度都显著增加。墨西哥是一个非常多样化的国家，经常发生森林火灾，尤其是在厄尔尼诺年。然而，在墨西哥，火灾主要是由人类引起的，道路可达性和到城镇的距离等因素通常与火灾的频率和分布有关。
本教程的总体目标是展示如何使用数据科学可视化工具，但以一种特殊的方式，即**folium**模块，来了解 2017 年墨西哥的火灾。
CONAFOR 数据库
在墨西哥，森林火灾的预防和控制由国家森林防火计划(CONAFOR，其西班牙语缩写)执行，我们将通过以下链接使用其 2017 年的数据库:【2】【3】
https://www.datos.gob.mx/busca/organization/conafor
数据探索
首先，将对国家森林委员会的数据进行基本探索。
- 行数:8896
- 列数:53
- 数据集的统计摘要:
单位转换
可疑数据
在进行任何转换之前，我们必须确保数据是数值类型:
我们必须将 19 改为数字数据
转换功能
使用“度”、“分”和“秒”列，我们通过以下函数找到纬度和经度的十进制度:
有了经度和纬度数据，我们就去掉了“度”、“分”和“秒”这几列
用**Folium**可视化野火
当我们有涉及位置、区域或地理区域的数据时，将它们清晰且用户友好地可视化是至关重要的。
Python 的库，**Folium**【4】，是这种情况下最可靠、最理想的工具。在这本笔记本中，我们将解释如何可视化 2017 年在墨西哥记录的野火。显示的每张地图都有其详细的程序，可与其他数据一起重新创建。
**import folium**
首先，我们将使用数据的经度和纬度信息创建一个数组。
每一张用树叶制成的地图都应该装在底图的上面。这个基地是由**Map()**函数创建的:
**location**(tuple) :中心的地图位置为元组(纬度，经度)**zoom_start**【int】:显示地图时你想要的缩放量
野火接*度
当我们谈到一些自然灾害时(虽然野火很大程度上是人为造成的)，每个人都想知道它离你住的地方有多*，如果很*，有多少或者已经发生了多少？这种情况就是 热图 有助于显示各点(数据)的接*程度的地方。幸运的是，叶有这个工具:
**from folium.plugins import HeatMap**
相关参数(以及我们将要使用的参数)是:
**data**(列表或数组):地图上要绘制的数据的地理位置。**name**(字符串):图层的名称。这个会出现在LayerControls里。[默认:None]**radius**(int) :地图上每个数据点的半径。[默认:15]**max_val**(浮点):一个点的最大强度值。[默认:1]**min_opacity**(float) :最小不透明度值，在该值处热图将开始“加热”。[默认:1]**blur**(int) :点中模糊的量。数字越大，重点就越模糊。[默认:15]
重要提示:如果我们想修改任何地图参数，重新运行创建地图的代码(**Map()**)是很重要的，因为如果我们只运行**HeatMap()**函数，它会在地图上叠加一个新的图层。处理这个问题的最好方法是，一旦代码准备好了，就将所有内容放在同一个单元格中，以便在需要更改某些参数时可以重新运行所有内容:
野火持续时间(天)
我们可以看到我们的数据集包含有价值的信息，其中之一是火灾的持续时间。此外，尽管我们有开始和结束日期，但我们有一个名为**Duration time (days)**的变量，它已经对时间进行了分类。
为了更好地形象化，我们可以用颜色对各个时期进行分类。
野火持续时间的颜色表示。图片作者:艾萨克·阿罗约
下一步，我们将把颜色代码添加到我们的数据集中，并将数据从西班牙语翻译成英语
我们将如何处理这些信息？我们将画一些小圆，它们的中心在纬度和经度，它们的颜色由持续时间(颜色)给出。该选项将通过功能**Circle():**实现
**location**(元组或列表):经纬度(对)。**popup**(字符串 o*folium.Popup*) :为点击时显示的对象输入文本或可视化。**radius**(浮点):圆的半径，单位为米。**color**【字符串】:圆轮廓的颜色，十六进制代码。**fill**(字符串):如果fill = True则该函数要求一个**fill_color****fill_color**(bool) :圆的填充颜色。
为了显示该国的所有火灾，我们将在**for**循环中使用**Circle()**:
组合:持续时间+受影响区域
继续圆图，我们可以给**radius**参数一个更好的理解火的尺寸。
受灾面积(ha) 的单位是公顷，因此我们可以用它来确定我们的圆的半径，以便对这些自然灾害的程度有一个初步的直观了解(和*似)。
其中𝑅以百米 (1 hm = 100 m)为单位，翻译成 Python 为:
**radius = np.sqrt( df[‘Affected area (ha)’].values[i]/np.pi )*1000**
末端的***1000**用于将圆缩放 10 倍(真实数据中的 1 米=可视化数据中的 10 米)
受影响的总面积(公顷)
仅用圆圈还不足以全面了解情况，我们还有关于受影响面积(公顷)的信息，可变名称为受影响面积(公顷):。
我们可以按州对它们进行分组，并在数据帧中获得受影响区域的总和
为了获得因野火造成的绿色区域损失的清晰而醒目的地图，我们将使用额外的资源:
- 墨西哥各州的 ID 代码
- 用于可视化的 JSON 文件
墨西哥各州 ID 代码
affected_area_states 的 El 数据框对于我们想要绘制的地图来说有些不完整，因此我们需要使用以下 csv 文件中的信息来完成:
我们可以注意到两个州在名称上不匹配，因此执行merge对我们不利，因此我们将更改名称:
affected_area_states.iloc[6,0] = ‘CDMX’ affected_area_states.iloc[16,0] = ‘Estado de México
JSON 文件
有了**IDNAMES**，我们只需在墨西哥各州上“绘制和绘画”，这些州的几何图形将由下面的 JSON 文件给出: states_mx.json
让我们看看我们的数据分布，以便按受影响的区域进行分类:
彩色地图
我们将要使用的函数是**GeoJson()**，它的参数是:
**data**(file，dict 或 str) :您想要绘制的 GeoJSON 数据。**style_function**(函数):将 GeoJSON 特征映射到样式字典的函数。在我们的例子中，风格字典如下:
而**COLOR_FUNCTION** 则如下:
最后我们得到了这个结果:
要在地图中添加图例，您可以使用本文末尾我的 GitHub 库中的 Jupyter 笔记本中显示的步骤。
环境和自然资源部长(SEMARNAT)有一个向公众开放的每年各州野火数量的登记册，所以我们可以很容易地检查他们提供的数据是否是向公众开放的。进行这种练习，即使听起来很愚蠢，也是很重要的。
在审查结束时，我们可以看到，他们在网站上与我们分享的信息确实与我们从国家森林委员会的公开数据中收集的信息相同。
结论
多亏了叶，我们可以呈现 2017 年墨西哥野火的行为，比如:
- 野火接*度
- 野火持续时间
- 每场野火和每个州的总受灾面积，这一切都要归功于以下 leav 功能:
**Map()****HeatMap()****Circle()****GeoJson()**
因此，下次当您遇到带有地理信息的数据时，请立即使用**folium**。
我们知道还有其他工具；我们不想把它们最小化。我们只是展示了另一个工具。
要查看完整教程，请访问:
参考
【1】华雷斯·奥罗兹科，S. 墨西哥米却肯州森林火灾风险模型【国际地理信息科学与地球观测研究所硕士论文】
https://library . ITC . ut wente . nl/papers _ 2008/MSC/NRM/orozco . pdf
【2】墨西哥开放数据-confor-institutions
https://www . data . gob . MX/search/organization/confor
【3】【指数】
【http://187 . 218 . 230 . 4/openata/fire/
【4】【文件】
【https://python-visualization . github . io/folum/
在 Python 中可视化缺失值非常容易
如何使用 Missingno 库查看所有缺失的值
您的旅程概述
1 —搭建舞台
缺少价值观是生活的现实。如果你是数据科学家或者数据工程师，接收数据，那么缺失值比比皆是。您应该如何处理缺失值是高度依赖于上下文的:
- 也许删除所有缺少值的行？
- 可能会删除包含太多缺失值的整个要素？
- 也许用一种巧妙的方式来填充缺失的值？
第一步应该始终是了解缺少什么以及为什么缺少。要开始这一发现，没有什么比获得丢失值的良好可视化更好的了！下面两个选项中哪个更容易理解？
0 survived 891 non-null int64
1 pclass 891 non-null int64
2 sex 891 non-null object
3 age 714 non-null float64
4 sibsp 891 non-null int64
5 parch 891 non-null int64
6 fare 891 non-null float64
7 embarked 889 non-null object
8 class 891 non-null category
9 who 891 non-null object
10 adult_male 891 non-null bool
11 deck 203 non-null category
12 embark_town 889 non-null object
13 alive 891 non-null object
14 alone 891 non-null bool
条形图
绝对是条形图，对吧？😋
这两个选项都提供了著名的 Titanic 数据集中缺失值的信息。只需看一眼条形图，您就可以发现有两个特性(age和deck)丢失了大量数据。
在这篇博文中，我将向您展示如何使用 Python 库 missingno 。这个库为你提供了几个实用函数，用来绘制熊猫数据帧的缺失值。如果你更喜欢视觉学习，那么我也制作了一个关于这个主题的视频😃
2 —缺少什么？
是一个 Python 库，可以帮助你可视化熊猫数据帧中缺失的值。该库的作者以如下方式描述了 missingno:
杂乱的数据集？缺少值？
missingno提供了一个灵活易用的缺失数据可视化工具和实用程序的小型工具集，可让您快速直观地总结数据集的完整性(或缺失)。—没有遗漏任何文件
在这篇博文中，您将使用 missingno 来理解著名的 Titanic 数据集中缺失的值。数据集预装了库 seaborn，所以不需要单独下载。
首先，我们来安装 missingno。我将使用 Anaconda，因此用简单的命令安装了 missingno:
conda install -c conda-forge missingno
如果您正在使用 PIP，那么您可以使用以下命令:
pip install missingno
因为我通过 Anaconda 使用 Jupyter 笔记本，所以我已经安装了 pandas 和 seaborn。如果你想遵循这篇博文中的代码，确保你已经安装了这些😉
3-加载数据
您应该从导入包开始:
# Package imports
import seaborn as sns
import pandas as pd
import missingno as msno
%matplotlib inline
推荐使用别名msno导入 missingno。
现在，您可以使用 seaborn 导入泰坦尼克号数据集。seaborn 预装了这个数据集，您可以简单地运行命令:
# Load the Titanic data set
titanic = sns.load_dataset("titanic")
现在，泰坦尼克号的数据集被储存在熊猫数据库titanic中。
很难想象熊猫身上缺失的价值观。您唯一能做的就是使用 pandas 方法.info()来获得缺失值的汇总:
titanic.info()**Output:** <class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 15 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 survived 891 non-null int64
1 pclass 891 non-null int64
2 sex 891 non-null object
3 age 714 non-null float64
4 sibsp 891 non-null int64
5 parch 891 non-null int64
6 fare 891 non-null float64
7 embarked 889 non-null object
8 class 891 non-null category
9 who 891 non-null object
10 adult_male 891 non-null bool
11 deck 203 non-null category
12 embark_town 889 non-null object
13 alive 891 non-null object
14 alone 891 non-null bool
dtypes: bool(2), category(2), float64(2), int64(4), object(5)
memory usage: 80.7+ KB
方法.info()对于检查不同特性的数据类型非常有用。然而，这对于了解不同特性所缺少的东西并不是很好。您将为此使用 missingno😍
4 —条形图
可视化缺失值的最基本绘图是条形图。为此，您可以简单地使用 missingno 库中的函数bar:
# Gives a bar chart of the missing values
msno.bar(titanic)
这将显示图像:
条形图
这里您可以立即看到age和deck特性严重缺失值。仔细观察还会发现特性embarked和embark_town各缺少两个值。
您应该如何处理缺失值取决于上下文。在该设置中，应该可以用适当的值填充特征age、embarked和embark_town。然而，对于deck功能，有太多的缺失，我会考虑完全放弃这个功能。
虽然条形图很简单，但是没有办法看出缺少了特性的哪一部分。在下一节中，我将向您展示如何使用 missingno 的matrix函数看到这一点。
5 —矩阵图
missingno 提供的另一个实用可视化是矩阵图。简单地使用matrix()功能如下:
# Gives positional information of the missing values
msno.matrix(titanic)
这将显示图像:
矩阵图
从矩阵图中，您可以看到缺失值的位置。对于 Titanic 数据集，丢失的值到处都是。然而，对于其他数据集(如时间序列)，缺失的数据通常被捆绑在一起(例如由于服务器崩溃)。
矩阵图重申了我们最初的假设，即很难保存任何关于deck特性的东西😟
6 —热图
您可以使用的最后一个可视化工具是热图。这比条形图和矩阵图稍微复杂一些。然而，它有时可以揭示不同特征的缺失值之间的有趣联系。
要获得热图，只需使用 missingno 库中的函数heatmap():
# Gives a heatmap of how missing values are related
msno.heatmap(titanic)
这将显示图像:
热图
首先，请注意热图中只有四个功能。这是因为只有四个要素缺少值。所有其他特征都将从图中删除。
要理解热图，查看对应于embarked和embark_town的值。该值为 1。这意味着embarked中的缺失值和embark_town中的缺失值完全对应。从你之前做的矩阵图也可以看出这一点。
热图中的值介于-1 和 1 之间。值-1 表示负对应关系:特征 A 中的一个缺失值意味着特征 B 中没有缺失值。
最后，值 0 表示在特征 A 中的缺失值和特征 B 中的缺失值之间没有明显的对应关系。其余所有特性(或多或少)都是如此。
对于 Titanic 数据集，热图显示在age要素中的缺失值和deck要素中的缺失值之间没有明显的对应关系。
7—你学到了什么？
从你所做的想象中，可以得出以下结论。
- 条形图—Titanic 数据集大多缺少特征
age和deck的值。 - 矩阵图—
age和deck中缺失的值分布在所有行上。 - 热图—
age和deck特征中的缺失值之间没有很强的相关性。
这给了你比开始时更多的直觉。可视化丢失的数据只是漫长过程的第一步。你还有很长的路要走，但至少现在你已经开始了旅程🔥
8 —总结
如果您需要了解更多关于思念号的信息，请查看思念号 Github 或我的思念号视频。
喜欢我写的？查看我的博客帖子
- 用漂亮的类型提示使你罪恶的 Python 代码现代化
- SymPy 符号数学快速指南
- 5 个牛逼的数字功能，能在紧要关头救你一命
- 5 个专家提示，让你的 Python 字典技能一飞冲天🚀
获取更多 Python 内容。如果你对数据科学、编程或任何介于两者之间的东西感兴趣，那么请随意在 LinkedIn 上加我，并向✋问好
可视化美国宇航局的陨石数据集
Python 中用于数据科学和机器学习的探索性数据分析(EDA)
在 Unsplash 上 Austin Human 的照片
当你进入数据科学领域时，你很快就会意识到有两个主要的分支可以发展。一个是更多的业务面对。另一部分用于研发。
我自己更像一个科学家。总是问问题并寻找答案。此外，我是一个超级太空迷。我总是仰望星空，想知道:“我们在哪里”，“上面有什么”，“我们如何到达那里”，“我们如何保护自己”。
这最后一个问题从童年起就一直萦绕在我心头。当你看科幻和奇幻电影时，你会有很多这样的想法。尤其是在看过《世界之战》和《银河系漫游指南》这样的电影之后。哪怕只是知道一颗流星对恐龙做了什么都会让你有点紧张。
年轻时，我希望长大后能够在地球周围建立一个保护我们免受外星人、流星、太阳耀斑等伤害的屏障。我会怎么做？还是未知。但这确实让我开始思考…
毁灭行星的流星撞击地球的可能性有多大？
当然，作为一名数据科学家，我必须找到答案。
预处理
数据收集
找到好的数据来源。你的结论和你使用的数据一样好。数据越多，标签越多样化越好。
直到我有了一些研究工作，我才能开始寻找答案。就这样，我开始了对数据的搜寻！
我首先关注的是 Kaggle.com，因为它以数据收集、挑战和其他令人惊叹的数据科学功能而闻名。
Kaggle Gif — Kaggle
我做这个已经有一段时间了。在互联网的巨大数据森林中搜寻有用的数据集。最终，我选定了美国宇航局的【陨石降落】 数据集。它包含大约 46，000 行和 10 列信息，如名称、位置、类别、质量等。
似乎是个不错的起点。
从那里，我将数据下载为 CSV 文件(我处理数据的首选文件时间),并将其上传到我的编码环境中。我使用 VSCode 的 Jupyter 笔记本扩展。
Github 上的 @robotgyal 预处理. ipynb
Github 上的 @robotgyal 预处理. ipynb
我打印出了列名和形状，只是为了验证加载的所有内容是否符合我的预期。此外，查看列名可以告诉您任何奇怪的命名约定或重复的数据。例如，此数据集的“reclat”和“reclong”(纬度和经度)包含与“GeoLocation”相同的信息，但格式不同。
意识到这些事情是很重要的，因为它们可能导致误解、歪曲或重复的结果。更不用说在将来训练和测试模型时节省时间了。
我快速浏览了一些数据(我最终添加了另一个来自IMO——国际流星组织的数据集，并将其与 NASA 的数据集合并)。
Github 上的 @robotgyal 预处理. ipynb
在这里，我不仅可以看到位置数据的相似性，还可以看到许多“NaN”值。这是因为有些标注存在于一个数据集中，而不存在于另一个数据集中，例如，NASA 有地理定位，但 IMO 有高程。当它们结合在一起时，该功能使所有丢失的数据都变得“难”。
结合不必要的列，这意味着是时候清理它了！
数据清理
清洁会影响你今后所做的一切。确保数据的格式正确，可以被你的模型读取，不重复，和/或处理丢失的数据。
我先做了最简单的事情，去掉不需要的标签。
Github 上的 @robotgyal 预处理. ipynb
这些要么根本无助于找到我想要的答案，要么在数据集中重复出现。
然后，我需要处理‘Nan’值，因为我知道它稍后会出现问题。
Github 上的 @robotgyal 预处理. ipynb
其步骤如下:
- 找出每列中“南”的总数
- 用另一个数据集中的相应数据替换每个列中缺少的数据。另一种选择是用 0 填充，但这会扭曲以后的一些统计数据。
- 根据需要重命名和删除列。
- 再次检查以确保没有“NaN”值
我通常在预处理中采取的最后一步是采样。然而，对于这个项目，我决定将采样留给特定的机器学习脚本，而不是在预处理中。
部分原因是，在清理结束时，我将数据导出到一个新的 CSV 文件中。
永远不要覆盖您的原始数据
当我开始做视觉和机器学习时，这个文件被用作我的数据源。
最后，看到数据是一回事，到 看到 数据又是另一回事。
画面
当我第一次学习数据科学时，我学会了使用硬编码来绘制数据。随着时间的推移，我意识到这不是最好的解决方案。
归根结底，直观地查看数据的目的是让任何人都容易理解数据，从而得出结论。通过硬编码，我花费了大量不必要的时间和精力来制作不容易理解或视觉上不吸引人的情节。
经过一些研究和反复试验，我发现了 Tableau。我可以简单地上传我的 CSV 文件，并使用它的图形用户界面工具非常快速和容易地创建视觉效果。
从左到右:美国宇航局数据集-按位置绘制-按坠落和发现状态和质量过滤，美国宇航局数据集:通过地理位置绘制的陨石-按质量过滤，美国宇航局数据集-坠落与坠落-按质量和年份过滤— — — 项目撞击视觉效果
从左至右:IMO 数据集:报告数量-按国家和*均海拔过滤，IMO 数据集-报告数量-按年份和国家过滤— — 项目影响视觉效果
从左至右:IMO 数据集:
报告数量-按月份过滤，IMO 数据集:
报告数量-按年份和海拔过滤— — 项目影响视觉效果
好多了！
以这种方式查看数据会使理解变得容易得多。例如，在“IMO Dataset:Report Count-Filtered by Month”条形图中，很容易看到 8 月份出现峰值。通过一点研究，我发现这是因为每年发生的英仙座流星雨。这是非常明显的肉眼可见的，因此有理由相信这个月会有更多的人报告观测到流星。
https://solarsystem.nasa.gov/asteroids-comets-and-meteors/meteors-and-meteorites/perseids/in-depth/
如果你从事商业或营销数据科学，视觉可能是你的终点。您应该投入大量的工作来掌握创建它们，将它们转换成仪表板，和/或将它们合并到报告中。
如果你是做机器学习的数据科学，那么这只是一个开始。经过清理和预处理的数据只是缩放、特征选择、编码、构建、测试和训练模型以及执行度量的链中的第一步。
敬请关注！因为将会有第二部分！在这个过程中，我们更深入地将这些数据转化为我们最初问题的解决方案。
行星毁灭流星撞击地球的可能性有多大？
只有数据知道…
在此签出当前状态的完整项目: 项目影响
用 Python 可视化网络
帮助您“看到”网络的实用工具指南
斯科特·韦伯在 Unsplash 上拍摄的照片
本文中的每一段代码都发布在这个 资源库 中。
2021 年 2 月 2 日更新:我最*发布了 Jaal ，一个用于网络可视化的 python 包。它可以被认为是下面讨论的列表中的第四个选项。一定要试一下。更多细节，请看这篇独立的博客。Thnx！
介绍
网络或图是相互之间有关系的实体的特殊表示。它由两个通用对象的集合组成— (1) node:代表一个实体，以及(2) edge:代表任意两个节点之间的连接。在复杂的网络中，我们也有与每个节点和边相关联的属性或特征。例如，表示为节点的人可能具有年龄、性别、工资等属性。类似地，代表“朋友”联系的两个人之间的边可以具有诸如“自从朋友”、“上次见面”等属性。由于这种复杂的性质，我们有必要直观地展示一个网络，这样它就能展示尽可能多的信息。为此，我们首先需要熟悉不同的可用工具，这就是本文的主题，即浏览帮助我们可视化网络的不同选项。我们开始吧！
使用 NetworkX 进行网络分析
在开始可视化之前，让我们先了解一下图形数据是什么样子，以及如何使用 Python 中的 NetworkX 将它加载到内存中。下面我们可以看到《权力的游戏》社交网络的表格公式。这里，节点表示 GoT 的字符，两个字符之间的边意味着它们的名称在书中彼此相距 15 个单词的范围内同时出现。
前两列包含节点(这里是 get 字符)，一对源和目标表示两个字符之间的一条边。只看第一本书的数据集，我们有 187 个独特的字符和 684 个连接(行)。此外，权重栏给出了这种联系的重要性，这里是我们在第一本书中看到两个角色的名字在附*的次数(如上所述)。为了使网络易于管理，我们只考虑与weights>10保持边的强连接。这会将图形削减到 80 个节点(字符)和 175 条边(连接)。
将熊猫数据帧格式的数据作为一个网络来加载是非常容易的。这可以使用 NetworkX 来完成，如下所示:
就是这样！变量G现在是一个 networkx 图，我们可以在其上执行与图相关的操作。现在，完成了先决条件，让我们逐一探索不同的可视化选项。
选项 1:网络 x
NetworkX 有自己的绘图模块，提供多种绘图选项。下面我们可以在包中找到一些绘制模块的可视化。使用它们中的任何一个都相当容易，因为你需要做的就是调用模块并传递G图形变量，剩下的工作由包来完成。
虽然可视化选项内置在默认的 python graph 包中，并且很容易调用，但它非常不直观，仅适用于小型网络。大多数时候，对于大型网络，任何内置的模块调用都没有多大意义。如果您使用较大的网络数据，这使得默认选项不是显而易见的选择。另一个缺点是，它不是交互式的，所以图形是固定的。这是一个主要的缺点，因为还有其他选项可以让你手动交互和处理图表。有了这个提示，让我们进入下一个选项。
选项 2: PyVis
PyVis 是一个交互式网络可视化 python 包，以 NetworkX 图作为输入。它还提供了多种样式选项来定制节点、边缘甚至整个布局。最棒的是，它可以在移动中使用设置面板来完成，您可以在其中使用各种选项，并以 python 字典的形式导出最终设置。这个字典可以在调用函数时作为 config 传递，从而得到网络的原样图。除此之外，在可视化方面，你有缩放、选择、悬停等基本选项。很酷不是吗！😉
默认情况下，绘制我们的 GoT 网络可以很容易地通过，
这将网络绘制为，
选项 3:仪表板中的 Visdcc
以前的选项的一个主要缺点是它们很难与交互式仪表板一起使用，如 Dash 。这是因为除了支持手动交互，如选择、缩放等，一个包应该自动调整程序交互，如数据变化、属性变化等。这个特性由 Python 中的 visjs 的一个端口 visdcc 支持。这使得通过回调来修改图形甚至图形的某些选择属性变得相当容易，在 Dash 中，回调可以连接到按钮或单选选项之类的小部件。我们的 GoT 数据集的 Dash 应用程序示例如下所示，
这里，代码像我们以前做的那样绘制了 GoT 网络。除此之外，我们还在图形上添加了一个回调函数，这样在选择一个选项时，我们可以改变整个图形的颜色。请注意，这是一个虚拟示例，所以完整的范围非常大，比如添加搜索选项(查找任意一个字符)、根据权重调整过滤器(从我们的固定值 10 移动)等。带有虚拟示例的 Dash 应用程序如下所示，
结论
本文的目的是向读者介绍网络数据以及 Python 中可视化的不同选项。我们的选项列表从内置的 NetworkX 绘图模块开始，该模块可用于可视化小型和不复杂(较少连接)的图形。对于较大的图形，我们可以使用 PyVis，因为它支持自动布局(迫使节点尽可能分开)并提供手动交互(缩放、拖动、选择等)。最后，在极端情况下，我们希望通过分析网络 w.r.t .节点和边属性的变化来进一步处理网络，我们可以使用 visdcc 在 Dash 中绘制网络，并通过回调将功能连接到图形。希望这有所帮助🙂
干杯。
在 LinkedIn 上与我联系，在我的网站上阅读类似文章。
可视化神经网络的决策过程第一部分——类激活图(CAMs)
卷积神经网络(CNN)构成了一类极其强大的机器学习算法。它们在大多数计算机视觉任务中实现了最先进的性能，例如图像分类、物体检测或图像生成。
然而，通常我们对 CNN 是如何学习的以及他们使用什么样的特征来进行预测知之甚少，这是由于他们的黑盒性质。而洞察神经网络的决策过程不仅对于创建性能更好的模型至关重要，对于确保模型在应用于现实问题时的公*性和可问责性也至关重要。
有点老生常谈，但很能说明问题的例子是一辆无人驾驶汽车出了问题，撞到了一名行人。一方面，不理解决策背后的原因，我们就无法识别和解决问题。另一方面，如果不解释算法最初是如何工作的，以及什么使下一个版本更安全，你很难找到愿意使用这样一辆车的人。
将 CNN 的决策过程可视化正处于研究阶段。目前，有几种技术被提出来增加可解释性和理解神经网络如何做出决定。其中之一是类激活映射(CAMs) [1]，我想在这篇博文中更详细地讨论它。
类激活图(CAMs):它们是如何工作的？
摄像头有助于可视化输入图像的哪些区域有助于 CNN 的最终预测。这可以通过生成热图来实现，该热图突出显示输入图像中影响将该图像分配到某个类别的像素。
为了使 CAMs 工作，我们需要使用在最后一个卷积层和最终全连接层之间注入的全局*均池(GAP)层来训练分类网络。间隙图层通过取所有值的*均值将每个要素地图缩减为一个数字。
因此，GAP 图层中的每个结点都对应于一个要素地图。此外，连接间隙图层和最终图层的权重编码了每个地图对预测的贡献(某个特征地图有多重要)。
为了获得某个类别的热图，我们将特征图与相应的权重相乘，并将它们相加。您可以在下图中看到生成凸轮的过程。
生成凸轮的过程。改编自参考文献。[1].
cam 是可视化神经网络决策过程的一个非常强大的工具。但是，它们有一定的局限性:
1)只有当 CNN 包含间隙层时，我们才能应用 CAMs，2)只能为最后一个卷积层生成热图。
为了解决这些问题，提出了梯度加权类激活映射(Grad-CAM) [2]。
梯度加权类激活映射(Grad-CAM)
Grad-CAM 是 CAM 的推广，可以应用于任何类型的 CNN。此外，可以生成每一层的热图(不仅仅是最后一层)。
cam 和 Grad-cam 之间的区别在于计算每个特征图的权重的方式。准确地说，对于 Grad-CAM，计算某个类别相对于卷积层的特征图的分数梯度。
接下来，对这些梯度进行全局*均，以获得神经元权重。因此，与 cam 类似，计算的权重对目标类的特征映射的重要性进行编码。
通过将特征图与它们的权重相乘，对它们求和，并将 ReLU 函数应用于结果，我们获得定位图，其中输入图像的重要区域被突出显示。
下面给出了两个类的激活图，即瞪羚和大象。
两个不同类别的激活图(照片由 Unsplash 上的 Hidde Rensink 提供)
摄像头是解释 CNN 决策的绝佳工具。从上面可以看出，它们突出显示了输入图像中与预测相关的像素。这有助于我们了解 CNN 在决策过程中考虑的因素，并创建更强大的模型。
这是这个系列的第一部分。在下一篇文章中，我将重点介绍一种解释神经网络决策的不同技术:分层相关性传播(LRP)。
更多类似的文章请看神经系统博客。
参考
[1]周，，等.“学习深层特征用于鉴别性定位”IEEE 计算机视觉和模式识别会议论文集。2016.
[2] Selvaraju，Ramprasaath R .等人，“Grad-cam:通过基于梯度的定位从深度网络中进行可视化解释”IEEE 计算机视觉国际会议论文集。2017.
可视化神经网络的决策过程第二部分
逐层相关性传播
解释神经网络(NNs)预测是一个正在进行的研究领域。由于他们的黑箱性质，我们通常对他们如何决策知之甚少。然而，理解神经网络非常重要，特别是在现实世界的应用中，如自动驾驶汽车，其中确保模型的可靠性和鲁棒性至关重要。
在我的上一篇文章中，我描述了一种叫做类激活映射(CAM)的方法，这种方法用于突出显示输入图像中影响该图像分配到某个类的像素。在今天的帖子中，我将介绍另一种方法来找出哪些像素与预测相关，即逐层相关性传播(LRP) [1]。
LRP 算法
LRP 算法背后的主要思想在于追溯输入节点对最终预测的贡献。
首先，将最后一层中指定节点的相关性分数设置为其输出。接下来，使用重新分布规则将相关性值传播回输入层。基本的再分配规则(所谓的 LPR-Z)如下所示:
其中 j 和 k 表示连续层中的神经元，zjk=ajwjk 是神经元 j 的激活度乘以神经元 j 和神经元 k 之间的权重。
传播回相关性值的过程示意性地呈现如下:
LRP 程序的说明。改编自参考文献。[2]
作为 LRP 算法的结果，预测被分解成指示节点对最终决策贡献多少的像素相关。
除此之外，还提出了许多其他更稳健的再分配规则，例如 LRP-ε规则，它在分母中增加了小的正项ε，或者 LRP-γ规则，它有利于正贡献超过负贡献(参见参考文献 1)。[2]了解更多信息)。虽然存在多个版本的重新分布规则，但它们都共享守恒原理，即输出的激活强度在每层都是守恒的，或者换句话说，神经元相关性分数的总和在所有层中都是相同的。
结果
下面你可以看到使用[3]中的 5 种不同的重新分配规则为识别为西伯利亚哈士奇的图像生成的关联图，以及在 CAM 技术的帮助下生成的热图，我在我的上一篇文章中更详细地谈到了这一点。
使用 LRP 算法产生的热图，使用 5 种不同的关联规则(图片由 路易莎·萨伊芙莉娜 在Unsplash 上拍摄)。
使用类激活映射算法生成的热图。
正如您在上面的图片中所看到的，热图互不相同，这取决于计算相关性分数时使用的原则和应用的方法(LRP 或 CAM)。然而，在所有的图片中，狗的头部被清楚地突出显示，这表明图像的这一部分与分类结果相关。
LRP 方法成功地应用于解释面部表情识别中的神经网络决策[4]和寻找与文档分类相关的单词[5]。
想要更多类似的文章，请看一下 NeuroSYS 的博客。
文学
[1] Bach，Sebastian 等人，“通过逐层相关性传播对非线性分类器决策的逐像素解释”《公共科学图书馆综合杂志》 10.7 (2015)
[2] Montavon，Grégoire 等人，“分层相关性传播:概述”可解释的 AI:解释、说明和可视化深度学习。施普林格，查姆，2019。193–209
[3] Alber，Maximilian，等,“研究神经网络”机器学习研究杂志20.93(2019):1–8。
[4]阿尔巴布扎达、法尔哈德等人，“通过解构神经网络识别个人面部表情”德国模式识别会议。施普林格，查姆，2016
[5] Arras，Leila，等.“在文本文档中什么是相关的？":一种可解释的机器学习方法." PloS one 12.8 (2017)。
用和弦图可视化纽约自行车共享旅行
将 Holoviews 弦图与 Citi 自行车旅行数据结合使用
纽约市自行车共享系统 Citi Bike 提供出行数据文件，允许任何人分析该系统的使用情况。弦图提供了一种可视化实体间流动的方式。在这篇文章中，我将展示一旦你有了所需格式的数据，就很容易创建一个交互式的和弦图来帮助理解这些共享自行车是如何使用的。
曼哈顿街区自行车旅行——作者图片
上图是使用全息视图和弦元素创建的。如果您使用的是 Anaconda，您可以使用以下命令安装 Holoviews 库:
conda install holoviews
对于这篇文章，我还使用了 Jupyter 笔记本，熊猫，Seaborn 和 Pyarrow。参见我之前的文章探索纽约市自行车共享数据，了解如何安装这些库。
本文中使用的所有 Python 代码及其生成的输出可以在 Jupyter 笔记本 chords.ipynb 中的 GitHub 上找到。
下载花旗自行车旅行数据
花旗自行车系统数据页面描述了所提供的信息，并提供了一个可下载数据的页面链接。在这篇文章中，我使用了 2020 年 9 月的数据。从 Windows 中找到 202009 年的 NYC 文件，下载并解压到一个bikeshare目录。在 Linux 上发出以下命令:
mkdir bikeshare && cd bikeshare
wget [https://s3.amazonaws.com/tripdata/202009-citibike-tripdata.csv.zip](https://s3.amazonaws.com/tripdata/202003-citibike-tripdata.csv.zip)
unzip 202009-citibike-tripdata.csv.zip
rm 2020009-citibike-tripdata.csv.zip
Citi Bike 是一个传统系统，有固定的站点，用户可以在那里取放共享自行车。行程数据文件中的每条记录都是一个单独的行程，有一个起点和终点站名和 ID。然而，唯一的地理数据包括纬度和经度。
为了理解旅行数据，我创建了一个文件，其中包含了每个车站的区、社区和邮政编码。(在纽约市，区是一个行政单位。虽然有五个，但有花旗自行车站的四个是曼哈顿、布鲁克林、皇后区和布朗克斯区。
你可以从 202009-stations.parquet 下载这个文件。在 Linux 上，发出以下命令:
wget [https://github.com/ckran/bikeshare/raw/main/202009-stations.parquet](https://github.com/ckran/bikeshare/raw/main/202009-stations.parquet')
要从 Python 中读取拼花文件，请安装 pyarrow。如果您使用的是 conda，您可以安装:
conda install -c conda-forge pyarrow
该文件是使用 OpenStreetMaps 中的数据创建的。如果你想知道怎么做，请阅读我的文章用纽约自行车共享数据进行反向地理编码。
导入库和数据
启动 Jupyter 并在您的bikeshare目录中创建一个新笔记本。将每个代码块输入到一个单元格中并运行它。
导入这些库并设置选项，如下所示:
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from holoviews import opts, dim
import holoviews as hvhv.extension('bokeh')
hv.output(size=200)
然后读取花旗自行车旅行数据文件。这些文件对每次旅行都有一个记录，并且包括关于乘坐的信息(旅行持续时间、车站名称和地理坐标)和乘坐者的信息(出生年份、性别、用户类型)。如果我想按时间、日期或骑手类型分析行程，我会读取整个文件。然而，对于这个分析，我只需要通过开始和结束位置来计算乘坐次数，所以我需要的只是start station id和end station id。
dfa = pd.read_csv('202009-citibike-tripdata.csv',\
usecols=['start station id','end station id'])dfa.shape
输出显示行数和列数。这个月几乎有 200 万次乘坐！
(2488225, 2)
然后将电台文件读入数据帧，查看前十行。
dfstations=pd.read_parquet('202009-stations.parquet')
dfstations.head(10)
前十个花旗自行车站
然后，我们可以使用 Pandas merge函数将 tripdata 表(带有起点和终点站点 ID)连接到 stations 表(在站点 ID 上)。我们将对执行两次，一次用于起点站，一次用于终点站。
dfa = pd.merge(dfa, dfstations[['boro','neighborhood','zipcode']],\ how = 'left', left_on='start station id', right_on='stationid')
dfa = pd.merge(dfa, dfstations[['boro','neighborhood','zipcode']],\ how = 'left', left_on='end station id', right_on='stationid')dfa.head(10)
注意在下面的输出中，为每个属性创建了两列。例如boro_x代表起始位置，而boro_y代表结束位置。
按行程开始和结束行政区和社区
格式化数据
现在，我需要将数据转换成 Holoviews 弦图所要求的格式，同时将数据限制为仅在曼哈顿开始和结束的行程。对于这个分析，我使用起始和结束邻域，但是如果我进一步限制数据，我也可以使用邮政编码进行更详细的分析。使用value_counts()返回邻域间乘坐次数的排序列表。
trips=dfa[['neighborhood_x','neighborhood_y']]\
.loc[((dfa['boro_x']=='Manhattan')&(dfa['boro_y']=='Manhattan'))]\
.value_counts()trips.head()
按邻域统计乘车次数
现在我需要格式化一个三列熊猫数据框架中的数据。我将列称为start、end和trips。
links=pd.DataFrame.from_records(list(trips.index),\
columns=['start','end'])
links['trips']=trips.valueslinks.head(10)
显示游乐设备计数的数据框
在酒吧聊天中可以很容易地看到这些数据。首先，我将创建一个包含start和end邻居名称的列表names，然后绘制trips。
names = links.start + '/' + links.end
plt.figure(figsize=(12,10))
sns.barplot( x=links.trips[:60], y=names[:60], orient="h") ; ;
按起始和结束邻域显示乘车次数的条形图-按作者显示图像
我们在这里看到一个经典的“长尾”；我将图表限制在开始/结束对的前 60 个。
我很容易看出，第二受欢迎的旅行是那些以切尔西为起点和终点的旅行。但是以切尔西为起点或终点的旅行呢？我必须阅读图表上的标签才能找到它们。如果我只想查看旅行次数，我可以通过旋转数据来查看。
pd.pivot_table(links,index='start',values='trips',columns='end')
透视数据-按作者分类的图像
但是如果我想看到这些数据的图形化表示呢？
查看弦图
这就是和弦图出现的地方。它可以让我轻松地创建一个显示始发站和终点站的图表。
但是如果我尝试使用整张表，我会得到一个无法理解的猫的和弦摇篮，这实在是太多的信息了。
曼哈顿所有街区的弦图-图片由作者提供
所以我要把这张图限制在乘坐次数最多的 60 对。这里的选项设置边和节点的颜色。
chord=hv.Chord(links[:60])
chord.opts(node_color='index', edge_color='start',\
label_index='index',cmap='Category10', edge_cmap='Category10' )
在这里，我可以清楚地看到最受欢迎的社区之间的花旗自行车使用量。
显示邻里之间乘坐情况的弦图-图片由作者提供
在 Jupyter 中，该图会自动启用以供浏览。因此，当我将悬停在前往切尔西的节点上时，从那里开始的行程以绿色突出显示，我可以看到它们在圆圈周围的目的地。
悬停在显示切尔西-作者的图像
如果我在一个节点上点击按钮，图表的其余部分会变暗，这样我就可以看到在所选位置开始和结束的旅行数量。在这里，我看到大多数从切尔西开始的旅行也在那里结束，而那些不是主要去邻*社区的旅行。
选择切尔西—作者图片
而如果我不想去切尔西呢？我只需点击不同的节点。
结论
当您在探索包括实体(如自行车共享系统中的停靠站)之间的流的数据时，和弦图是可视化数据的一种很好的方式，并且可以引导您进行进一步的探索。
可视化 NYS 新冠肺炎数据
使用 Python Matplotlib 和 Plotly
在 Unsplash 上由 Carlos Muza 拍摄的照片
作为一名全职数据分析师，我每天花大量时间使用 SQL 来提取工作项目的相关数据。然而，另一方面，我也喜欢通过探索性研究和图形来磨练我的 python 技能。下面这个(简单的)项目着重于使用 plotly 绘制来自 Health.Data.NY.Gov的纽约州新冠肺炎数据。
目标
这个项目的目标是从 matplot 库创建一个简单的可视化开始，然后使用 plotly 增强它并在它的基础上构建。
数据
我使用两个数据集进行描述性分析和可视化:
这两个数据集都包含 NYS 各县的最新统计数据。
在我导入数据后，我做了一个快速总结来理解结构。首先，我查看了 COVID 测试数据:
测试数据.描述
一个快速描述功能向我展示了基本知识。我的数据框有 37882 行和 6 列。我将关注的列是 County、Test Date 和已执行测试的累积数量。
疫苗数据.描述
对于疫苗数据，快速描述功能也向我展示了基础知识。有 1980 行和 5 列。我将关注的栏目是地区、县、报告日期和首剂。
Matplotlib 可视化
我的第一个可视化是使用测试数据集的全部数据从 matplotlib 创建的。我使用了下面的代码块(如果您想要一个有意义的可视化，我不推荐使用它)。
plt.plot(df['Test Date'],df['Cumulative Number of Tests Performed'])
plt.title('COVID Testing NYS')
plt.xlabel('Test Date')
plt.ylabel('Cumulative Count of Tests')
plt.show()
正如你所看到的，这个图表并没有很好地讲述一个故事，主要是因为所有的县数据都是一起绘制的。另外，你看不到考试日期，因为分数太多了。因此，我采取的第一步是清理数据。我将分析重点放在长岛，因此我选择了萨福克县和拿骚县。
首先，我设置日期时间索引，按计数分组，并重新采样:
dftest=dfdftest['date']=pd.to_datetime(df['Test Date'])dftest=df.set_index('date')dfcounty1=dftest.groupby(['County']).resample('D').mean().reset_index()
接下来，我将萨福克郡的数据与拿骚郡的数据分开:
Suffolk=dfcounty1[dfcounty1['County']=='Suffolk']
Nassau=dfcounty1[dfcounty1['County']=='Nassau']
这个稍微好一点，但是还是很乱，没有给我想要的所有信息。至此，我认为我的目标无法用 matplotlib 实现，所以我转向了 plotly。
基本情节视觉
这个简单的代码块允许我绘制出萨福克郡的数据:
fig = px.line(dfcounty2, x = 'date',
y='Cumulative Number of Tests Performed', color='County',
title = 'COVID Tests by County')
fig.show()
现在，这更多的是我在寻找的格式，但现在是时候结合我的数据了。下面的代码允许我将拿骚县和萨福克县的测试数据和疫苗数据绘制在一起。
为了分解它，首先我创建了支线剧情来考虑双 y 轴。然后我绘制了萨福克和拿骚的疫苗数据。我为我想要添加的每一行添加了跟踪。然后我格式化了标题并添加了注释。我想强调李身上的第一次 COVID 测试和李身上的第一次 COVID 疫苗的日期，所以我用文本注释添加了这一点。
最后，我用 updatemenus 参数创建了下拉过滤器。
fig2 = make_subplots(specs=[[{"secondary_y": True}]])
fig2.add_trace(go.Scatter(x=S['date'], y=S['First Dose'], name = 'Suffolk First Dose of Vaccine',
line=dict(color='red', width=1, dash='dash')), secondary_y=True)
fig2.add_trace(go.Scatter(x=N['date'], y=N['First Dose'], name = 'Nassau First Dose of Vaccine',
line=dict(color='blue', width=1, dash='dash')), secondary_y=True)fig2.add_trace(go.Scatter(x=Suffolk['date'], y=Suffolk['Cumulative Number of Tests Performed'], name = 'Suffolk Tests',
line=dict(color='red', width=1, dash='solid')), secondary_y=False)
fig2.add_trace(go.Scatter(x=Nassau['date'], y=Nassau['Cumulative Number of Tests Performed'], name = 'Nassau Tests',
line=dict(color='blue', width=1, dash='solid')),secondary_y=False)
fig2.update_layout(title_text='COVID Test and Vaccines LI', title_x=0.4,
xaxis_title='Date')
fig2.update_yaxes(title_text="COVID Tests", secondary_y=False)
fig2.update_yaxes(title_text="First Dose of Vaccine (Count)", secondary_y=True)fig2.add_annotation(x='2020-03-05', y=100,
xref="x",
yref="y",
text="First Test: 3/5/20",
showarrow=True,
font=dict(
family="Courier New, monospace",
size=10,
color="black"
),
align="center",
ax=20,
ay=-30,
bordercolor="black",
borderwidth=1,
borderpad=2,
bgcolor="#ffffff",
opacity=1
)
fig2.add_annotation(x='2020-12-14', y=20,
xref="x",
yref="y",
text="First Vaccine: 12/14/20",
showarrow=True,
font=dict(
family="Courier New, monospace",
size=10,
color="black"
),
align="center",
ax=20,
ay=-30,
bordercolor="black",
borderwidth=1,
borderpad=2,
bgcolor="#ffffff",
opacity=1
)fig2.update_layout(
updatemenus=[
dict(active=0,
buttons=list([
dict(label="All",
method="update",
args=[{"visible":[True,True,True, True]},
{"title":"ALL"}]),
dict(label="Suffolk",
method="update",
args=[{"visible":[True, False, True, False]},
{"title":"Suffolk"}]),
dict(label="Nassau",
method="update",
args=[{"visible":[False,True,False, True]},
{"title":"Nassau"}]),
dict(label="First Dose",
method="update",
args=[{"visible":[True, True, False,False]},
{"title":"First Dose"}]),
dict(label="Total Tests",
method="update",
args=[{"visible":[False,False, True, True]},
{"title":"Total Tests"}])
]),
)
]
)fig2.show()
调查的结果
总的来说，我发现拿骚县和萨福克县在 COVID 测试和疫苗方面遵循非常相似的趋势。然而，还是有一些不同之处:
- 第一次检测是在拿骚县，结果呈阳性。因此，我不能准确地绘制疫情开始时的阳性率，因为纳索在测试的第一天显示为 100%阳性，这是有道理的，因为人们没有被测试，除非他们相当确定他们是阳性的。
- 尽管在萨福克县进行了更多的测试，拿骚县还是更快地获得了第一剂疫苗。这也是有道理的，因为萨福克县(一般来说)更保守/共和党，拿骚县(一般来说)更自由，因为它更接*纽约市。
感谢您花时间阅读这篇文章。我知道这是相当基本的，但我希望这是对那些想使用 plotly 来可视化数据的人的一个很好的介绍。
请随时留下与调查结果或视觉效果相关的评论，我一定会用新数据更新它们。
互动公开图此处:https://chart-studio.plotly.com/~meagvo/2/#/
github 上有完整的笔记本:https://github . com/meag VO/towards data science/blob/main/health project . ipynb
机器学习模型的可视化输出
使用 Shap 进行机器学习可视化
由 Unsplash 上的 Pietro Jeng 拍摄
解释一个机器学习模型是一项艰巨的任务，因为我们并不真正知道这个模型在那个黑匣子里是如何工作的。需要进行解释，以便我们能够为我们的数据选择最佳模型，并使其稳健。
Shap 是一个用于解释模型的开源 python 库。它可以创建多种类型的可视化，帮助解释模型和解释模型是如何工作的。
在本文中，我们将看到不同类型的机器学习模型可视化，可以使用 Shap 创建。
让我们开始吧…
安装所需的库
我们将从使用 pip 安装 Shap 开始。下面给出的命令可以做到这一点。
pip install shap
导入所需的库
在这一步中，我们将导入加载数据、创建模型以及创建该模型的可视化所需的库。
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import shap
from sklearn.model_selection import train_test_split
import xgboost as xgb
创建模型
在这一步，我们将创建机器学习模型。对于本文，我将创建一个 XGBoost 模型，但是您可以选择自己喜欢的任何模型。我们将在这个模型中使用的数据集是著名的糖尿病数据集，可以从 Kaggle 下载。
df = pd.read_csv('/content/Diabetes.csv')
features = ['Pregnancies', 'Glucose','BloodPressure','SkinThickness','Insulin','BMI','DiabetesPedigreeFunction','Age']
Y = df['Outcome']
X = df[features]
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.2, random_state = 1234)
xgb_model = xgb.XGBRegressor(random_state=42)
xgb_model.fit(X_train, Y_train)
模型(来源:作者)
创建可视化
现在，我们将为 shap 创建解释器，找出模型的形状值，并使用它们创建可视化效果。
explainer = shap.Explainer(xgb_model)
shap_values = explainer(X_test)
- 酒吧剧情
shap.plots.bar(shap_values, max_display=10)
条形图形状值(来源:作者)
2.组群图
shap.plots.bar(shap_values.cohorts(2).abs.mean(0))
群组图(来源:作者)
3.热图
shap.plots.heatmap(shap_values[1:100])
热图(来源:作者)
4.瀑布图
shap.plots.waterfall(shap_values[0]) # For the first observation
瀑布 P{lot(来源:作者)
5.力图
对于这个情节，我们还需要初始化“js”。
shap.initjs()
explainer = shap.TreeExplainer(xgb_model)
shap_values = explainer.shap_values(X_test)
def p(j):
return(shap.force_plot(explainer.expected_value, shap_values[j,:], X_test.iloc[j,:]))
p(0)
力情节(来源:作者)
6.决定情节
shap_values = explainer.shap_values(X_test)[1]
print("The expected value is ", expected_value)
print("The final prediction is ", xgb_model.predict(X_test)[1])
shap.decision_plot(expected_value, shap_values, X_test)
决定情节(来源:作者)
这就是如何使用 Shap 来创建与机器学习模型相关的可视化并分析它们。继续尝试不同的数据集和机器学习模型，并让我知道你在回复部分的评论。
本文是与皮尤什·英格尔合作完成的。
在你走之前
感谢 的阅读！如果你想与我取得联系，请随时通过 hmix13@gmail.com 联系我或我的 LinkedIn 个人资料 。可以查看我的Github*简介针对不同的数据科学项目和包教程。还有，随意探索* 我的简介 ，阅读我写过的与数据科学相关的不同文章。
可视化量子计算
从零开始了解黑客是怎么回事！
你好。我是比萨大学的博士生，研究课题是量子计算！
我第一次尝试量子计算
我必须诚实地说，量子计算的第一步非常艰难，特别是对于那些拥有计算机科学学位的人来说(就像我一样:)。基于你经典的计算机科学家经验，有一点你可以坚持。
量子计算中的一个问题肯定是一个 可视化问题 。
你能理解下面的量子电路是做什么的吗？
图一。这个量子电路是什么？[图片由作者提供]
如果你是初学者，可能没有。我也有同样的问题！
我确实相信，这种在量子电路中表示量子算法代码的方式，遗漏了“一个维度”。这种表现欺骗了我。它隐含地强迫我在 2D 维度中推理，而现实是在 3D 中，所以我不能正确地可视化它。
缺少 尺寸:叠加的尺寸 。
量子计算的强大之处在于，一个物体同时是“蓝色和红色”、“真与假”、“ 0 和 1”……不幸的是，量子电路并不适合代表这个 “缺失维度 ，让人很难理解到底发生了什么。
不过不用担心！在这篇文章中，我将向你展示我的量子计算方法。我会尽我所能让你看到引擎盖下的量子现象！
为此，我将借用由 Schuld、Fingerhuth 和 Petruccione 在【1】中提出的“基于量子距离的分类器”。
在本文的最后，你会发现我的 Github 库实现了这个基于量子距离的分类器。
⚠️免责声明⚠️
为了避免这篇文章没有重点且太长，我假设你已经熟悉了以下概念:
- 什么是量子位，以及它在数学上是如何描述的。
- 哈达玛、受控非、托弗利和受控旋转门是如何工作的。
- 什么是量子电路。
- 什么是测量。
你准备好了吗？
量子电路计算什么？
下面的电路已经在图 1 中示出，是基于量子距离的分类器。
为了防止不一致，我必须注意到在[1]中，电路是通过叠加|a >和|m >开始的。在图 2 中，为了便于说明，我决定推迟在|m >上应用 H。然而，这种差异不会以任何方式影响计算。
图二。基于量子距离的分类器[图片来自作者]
电路计算什么？
我们来超简单的说一下，给定:
- 属于 2 个不同类别的 2 个训练向量
- 1 个测试向量(未知类别)
- 电路将最接*的训练向量(即，使与测试向量的欧几里德距离最小的训练向量)的类别分配给测试向量
只是为了固定点 :让我们给每个训练向量分配一个颜色( =class ):
- training_0 =蓝色
- 培训 _1 =红色
A 根据 基于距离的分类器 和图 3 中的例子，测试向量的颜色(= 类)会是什么？
S 由于 training_1 向量是最接*测试向量的向量，所以测试向量颜色为红色！
图 3。基于距离的分类[图片由作者提供]
希望问题陈述清楚:)
走向量子:让我们打破量子电路！
电路通常分为三个宏阶段(图 4 ):
- 量子编码:将经典数据编码成量子数据。
- 计算:计算解。
- 测量:将量子表示解解码成经典数据。
图 4。这三个阶段[图片由作者提供]
因为我们在寻找叠加态的维度，而且从这个角度来看，量子编码阶段是最有趣的，所以我将把重点放在这一个上。
量子编码阶段
我们处于非常低的抽象层次，没有内置的数据结构。我们的责任是将数据映射到“存储器中，这是电路在此阶段的工作。
⚠️ ACHTUNG :量子计算机中没有内存。他们只是处理器。然而，“记忆”这个词唤起了我们在电路中做什么的良好直觉(即，给量子位的特定组合分配特定的编码值)。
特别是在这个阶段，我们需要:
- 选择一个编码器。
- 将编码数据映射到“内存”中。
在我们观察的基于量子距离的分类器中，选择的编码器是振幅编码。来了解一下吧！
振幅编码
这是一种有趣的编码类型，可以对振幅中的连续值进行编码。
嗷？
我记得你是如何定义量子位的:
量子位定义[图片由作者提供]
因为幅度的绝对*方等于概率，所以可以得出:
[图片由作者提供]
你注意到了吗？这个条件看起来像…圆周方程！
[图片由作者提供]
[图片由作者提供]
那又怎样？
你也可以如下定义一个量子位:
[图片由作者提供]
给定某个 角度 α ，可以在一个圆周内映射一个量子位！
让我们把它们放在一起。
给定标准化和规范化数据集的条目 [0.789，0.615】，我们必须找到一个 角度 α 使得:
[图片由作者提供]
[图片由作者提供]
如何才能算出这个角度** α 进行正确的旋转？**
现在我们必须将这个 角度 α 插入我们的受控旋转门，它将如前所述旋转量子位！
敏锐的读者会注意到，arctan(sinα/cosα)被乘以了一个因子 2 。“为什么”已经超出了本文的范围，但是，它涉及了一个事实，即一个量子位自然地绘制在一个球面上( 布洛赫球面 )，而不是圆周上。无论如何，在我看来，通过圆周比通过布洛赫球更容易理解振幅编码的思想:**
那就是幅度编码:)
回到赛道上
回到图 5 中的电路，我们将对以下向量进行振幅编码:**
- 2 个训练向量(训练 _0，训练 _1 )**
- 1 个测试向量。
图 5。量子编码阶段[图片由作者提供]
为简单起见，我们将使用[1]中使用的相同条目。
这些值属于虹膜数据集；它们已经标准化和规范化了。如果你想重现这个实验，每一个条目都标注了样本号(希望有所帮助:))。**
- 测试: [-0.549，0.836】→α=反正切 2(0.836，-0.549)2 = 4.304 (虹膜样本 28)*
- Training _ 0:【0，1】→通过一个托夫里门旋转到|1 >即可。(虹膜样本 33)**
- Training _ 1:【0.789，0.615】→α=arctan 2(0.615，0.789)2 = 1.325 (虹膜样本 85)*
给定前面的 alphas，我们可以绘制圆周上的 3 个向量(数据)(图 6 )。
图 6。圆周上绘制的数据[图片由作者提供]
缺失的维度:叠加
这是我想强调更多的部分，因为你将能够理解绿色突出显示的门做什么(图 7 )，从而 可视化缺失的维度 。**
图 7。量子编码阶段[图片由作者提供]
你可能想知道的一个问题是:
如何将 3 个不同的向量加载到电路的同一个量子位上？
为了回答这个问题，从而找到我们的“缺失维度”，我们来逐门分析一下量子编码相位。
逐门量子电路
HADAMARD on |a >
图 8。电路步骤 1[图片由作者提供]
第一个哈达玛门 将 的运算 分成两个分支 ，可以用一棵树来表示(图 9 )。**
图 9。树步骤 1[图片由作者提供]
H 如何解读这棵树？很简单！
在树的中间我们标明:
- 应用门(此处为哈达玛门)**
- 受门影响的量子位****
这两个分支表明量子位(|a >)如何受到门(H) 的影响。在这里，量子位已经被置于相等的叠加态。
我知道…我知道…在树上没有振幅，但这对我们的视觉实验并不重要。重要的是不要让画面“超载”。
第一个带走的信息是，到目前为止，两个分支同时存在并从一个独立发展到另一个！****
在|i >上传测试向量 [-0.549，0.836】
图 10。电路步骤 2[图片由作者提供]
正如我们已经指出的，这种旋转通过振幅编码将经典数据映射成量子表示。
映射的条目是测试向量:[-0.549，0.836] → alpha = 4.304
我们可以观察到，由于它是一个控制量子位为|a >的受控旋转(图 11 )，算符只影响|a >为|1 >的右分支。
图 11。树步骤 2[图片由作者提供]
****注意:语法“R(4.304)|0 >”是一种简洁的方式来表达|0 >已经被受控旋转所旋转。
****泡利 X 门开|a >
图 12。电路步骤 3[图片由作者提供]
|a >上这个 X-gate 的用途是什么？
这里的重点是，你不要“ 覆盖 ”刚刚上传到右边分支的测试向量()R(4.303)| 0>)。因此，我们必须将下一个计算移到左分支，而不改变右分支。****
为了保持右分支不变，由于 Training_0 和 Training_1 是的双重控制，并且由于 的第一个控制量子位是|a > 和 ，X 门刚刚翻转|a >到|0 > ，那么，到现在，的任何双重控制旋转**
图 13。树步骤 3[图片由作者提供]
这种模式避免了测试向量的覆盖！
HADAMARD on |m >
图 14。电路步骤 4[图片由作者提供]
同样，我们通过应用 Hadamard 来分割计算。这次受哈达玛影响的量子位是|m >。
图 15。树步骤 4[图片由作者提供]
到目前为止，我们有四个分支同时存在和并且从一个到另一个独立发展！(图 15 )********
正在上传|i >上的 TRAINING_0 [0，1]
图 16。电路步骤 5[图片由作者提供]
Toffoli 门只影响左边第二个分支。此外，正如我们在图 17 中看到的，右分支中|i >的值没有受到影响，事实上，它仍然包含正确编码的测试向量(R(4.304)|0 >)。
图 17。树步骤 5[图片由作者提供]
问题:为什么？
答:因为 Toffoli 是双控的，而且由于右边分支的|a >是|0 >，那么 Toffoli 不适用。此外，Toffoli 也不影响第一个分支，因为即使|a >是|1 >，第二个控制量子位|m >也是|0 >
泡利 X 门开启|m >
图 18。电路步骤 6[图片由作者提供]
在|m >上应用 X-gate 遵循我们在第三步中在|a >上应用的相同模式逻辑。 由于我们不想覆盖上一步上传的[0，1] 条目 ，我们翻转|m >，这样在第二个分支中它变成了|0 >，在第一个分支中它是|1 >。这样，只有第一个分支会受到下一个双控操作器的影响(图 19 )。**
图 19。第六步[作者图片]
在|i >上传训练向量[ 0.789，0.615
图 20。电路步骤 7[图片由作者提供]
由于之前讨论的原因，第二、第三、第四分支不受双控旋转的影响，而唯一受影响的分支是第一分支，因为它的控制量子位都|1 >在这个特定的子分支中(图 21 )。**
图 21。树步骤 7[图片由作者提供]
将类别映射到每个训练向量
图 22。电路步骤 8[图片由作者提供]
到目前为止，我们没有明确地将类别映射到每个训练向量。我们开始吧！
具体来说，我们按如下方式分配类别:
- Training_0 属于类 0
- Training _1 属于类别 1
对训练向量的类别进行编码的量子位是|c >
在 Training_0 的情况下，我们不需要对|c >应用任何门，因为在那个分支(第二个)中，|c >已经被设置为|0 >。****
图 23。第八步树[作者图片]
关于 Training_1 的情况是不同的。加载 Training_1 的分支是第一个。由于我们只想翻转到这个分支的|1 >类量子位|c >，我们应该应用一个 Toffoli 门，它的控制量子位是|a >和|m >，它的目标量子位是|c >。那是可行的，因为在这个分支中，|a > = |1 >和|m > = |1 >。****
但是你可能注意到了，在量子编码阶段的最后一步，有一个 CNOT 门(图 23 )而不是一个托夫里门！ 那么为什么呢？****
由于 CNOT 具有作为控制量子位|m >和作为目标量子位|c >，这意味着 CNOT 将影响所有分支，其中|m> = |1 >(即 CNOT 将影响第一分支和第三分支)。最终的量子位设置如图 24 所示。
图 24。最终量子位设置[图片由作者提供]
为了直观地了解为什么电路采用 CNOT 而不是托夫里，请注意我们有相同测试向量的两个副本(分支 3 和分支 4)。不同之处在于，一个副本被分配给类|1 >(分支 3)，而另一个被分配给类|0 >(分支 4)。
“记忆”
但是等等！你还记得之前我用了一个不恰当的术语“记忆”吗？
查看图 24 每一列中量子位|a >和|m >的组合。
从某种意义上来说，|a >和|m >充当索引，在那里你存储一个特定的向量，它的值用量子位|i >编码，它的类用量子位|c >编码
特指:特指
- |00 >:分支 4 →分配给类|0 > 的测试向量
- |01 >:分支 3 →分配给类|1 > 的测试向量
- |10 >:分支 2 →训练 _1 向量分配给类|0 >
- |11 >:分支 1→训练 _0 向量分配给类|1 >
现在我们可以回到为什么有两个测试向量副本的原因:)
量子计算——H 门
根据这种设置，您可以“碰撞”(=interfere) 分支 3 上的分支 1 和分支 4 上的分支 2 。换句话说，我们能够一次比较相同的测试向量(用不同的类别标记)和两个不同的训练向量。******
为了使它们“冲突”，电路在|a > ( 图 25 )上应用计算阶段的哈达玛。****
图 25。电路步骤 9[图片由作者提供]
通过应用 Hadamard 门，直观地了解在计算阶段发生了什么，如下所示(图 26 )。******
图 26。计算阶段的哈达玛效应[作者 Gif
本质上，由于 Hadamard 门，电路计算两个训练向量和测试向量之间的距离，这是本电路的目的。在“冲突”之后，电路测量结果并输出测试向量所属的类。
测量阶段超出了本视觉实验的范围，但是，您可以在我的 Github 上找到基于量子距离的分类器的实现，以及一些手写的 PDF 笔记，其中量子编码阶段在数学上有所发展。
******https://github.com/Brotherhood94/quantum_distance_based_classifier
我们终于找到了缺失的维度！
从 CS 的角度来看，我们正处于量子世界的旅程的终点！
对比电路可视化 ( 图 27 )和树形可视化 ( 图 28 )，就能明白我对“ 缺维 ”的意图了。事实上，电路可视化并没有明确显示一个量子位是如何受到一个门在“分支”方面的影响。这就是树可视化来拯救的地方！树形可视化的分支以图形化的方式代表了叠加和电路“存储”的内容。
图 27。电路可视化[图片由作者提供]
图 28。树可视化[图片由作者提供]
这种树形可视化对于所展示的电路来说效果很好，而对于其他电路来说就不那么有效了。然而，我希望这个可视化帮助你更好地理解“叠加”的概念，至少和它帮助我一样多！
为了清楚起见，我在本文中省略了一些对于寻找“缺失的维度”不重要的细节。但是，如果你需要澄清，只需留下评论:)******
🚀你觉得这种视觉表现有用吗？
如果有，请随意留下拍拍让我们继续在碰上LinkedIn和 Twitter ！********
我会超级感激它！😃
见 yaaaaa！ ✌🏼
拜拜！[ Gif by Giphy ]
参考
[1]舒尔德，米，芬格胡斯，米，&彼得鲁乔内，F. (2017)。用量子干涉电路实现基于距离的分类器。 EPL(欧洲物理快报)， 119 (6)，60002。
使用 Matplotlib 和 Cartopy 可视化卫星数据
实践教程
使用 Python 和被动微波数据探索我们不断变化的气候
北半球亮温图像(作者创建)
我最*给写了一篇帖子，讲述我们如何利用从卫星上获得的被动微波图像来研究积雪。利用卫星来研究积雪，可以解开一些区域的信息，否则这些信息是不可能研究的，尤其是在大范围内。除了覆盖范围大之外，携带被动微波传感器的太阳同步卫星每天在相似的时间拍摄两极的图像。这些一致的测量产生了令人难以置信的每日时间序列，可以追溯到 1978 年 Nimbus 7 卫星的发射。Nimbus 计划是 NASA 和 NOAA 首次合作发射专门用于气象研究的卫星，40 多年后，我们仍然受益于研究气候的早期投资。
在本帖中，我们将通过各种方法来使用 Matplotlib 和 Cartopy 可视化卫星图像。在制作演示地图时，这两个库是我最喜欢的工具；虽然网络地图风靡一时，但我们经常需要一种非在线托管的高质量可视化。
我们将从使用 Matplotlib 快速绘制信息丰富的图像开始，然后深入到使用 Cartopy 使用 Matplotlib 绘制地理坐标。最后，我们将讨论如何用 Matplotlib 制作动画图像和地图，以显示随时间的变化。所以，请坐好，放松，让我们学习如何使用 Matplotlib 来可视化阿拉斯加的积雪。
数据
背景
我们将使用 MEaSUREs 校准的高分辨率被动微波数据集，该数据集是 NASA 制作地球系统数据记录用于研究环境(MEaSUREs)计划的一部分。这个数据集是特殊的，因为它被重采样到比传感器最初捕获的分辨率高得多的分辨率；原始像素为 25 公里宽，但新数据的像素为 6.25 公里宽。这意味着我们现在有 16 个像素，而原来只有一个。
这些无源微波传感器测量的辐射能量非常低，这迫使我们在大范围内进行测量，以获得良好的读数。虽然与其他类型的卫星图像相比，6.25 公里仍然是一个宽像素，但它使我们能够比以前更详细地研究积雪。
被动微波辐射计测量的主要参数之一是亮温(TB)，它是对朝向卫星上的传感器移动的辐射的辐射率的测量。我们在不同的频率下测量结核，用千兆赫(GHz)表示。对于积雪分析，我们主要关注 37GHz 和 19GHz 频率。当地面上没有雪时，两种频率相似，但随着雪在地面上积累，37GHz 频率的散射要多得多。这种差异使我们能够找到雪水当量(SWE)的替代变量，即储存在雪堆中的水量。
由作者创建
在该图中，您可以看到 19GHz 和 37GHz 频段在冬季如何发散，这是由于 37GHz 频段更多地从雪中散射。
在这篇文章的中，我深入研究了这个数据集，以及我们如何使用被动微波传感器测量的亮度温度来估计积雪中储存的水量。如果你对使用被动微波成像研究雪背后的科学感兴趣，请阅读那篇文章的前半部分。
选择研究区域
可通过 FTP 获得的完整数据集将* 70TB。幸运的是，为了研究 SWE，我们只需要在我们的时间序列期间每天下载两个文件。我已经写了一个 Python 库来为我们做这项工作，确保我们每年都能得到最佳的文件；有多种传感器可用，某些传感器的错误率低于其他传感器。
为了处理合理数量的数据，我们需要选择一个研究区域，因为使用完整北半球影像的时间序列(如帖子顶部所示)需要存储大量数据！下面你会看到我们将要绘制的阿拉斯加地区。
由作者使用谷歌地球创建
由于该数据使用 EASE-Grid 2.0 投影，我们必须通过选择左上角和右下角的一组坐标来选择边界框。等面积可缩放地球(EASE)格网是全球范围的网格数据的通用格式，可以很好地保留映射对象的面积。虽然缓和网格不使用纬度和经度；相反，他们选择以米为单位的行/列系统。稍后我将展示如何在纬度/经度和行/列坐标之间进行转换，这被称为重新投影。
用 Matplotlib 绘制 SWE
Matplotlib 是 Python 程序员可以使用的绘图库。虽然它在图形上比交互式绘图库更简单，但它仍然是一个强大的工具。Matplotlib 是我的首选库，用于快速绘制和演示我想要传达的特定观点。交互式地图根本难以清晰呈现；除非你正在做一个现场编码演示，否则你永远不会真的想在和观众说话的时候和你的电脑互动。
用 imshow 绘制简单图像
绘图是探索性数据分析的一个重要组成部分，Matplotlib 非常适合我们 EDA 所需的快速绘图。利用我们的 SWE 数据，简单地绘制时间序列中的一天就可以有力地证实我们对图像进行了正确的子集划分。
fig = plt.figure(figsize=(12,6))
im = plt.imshow(swe[0,:,:])
由作者创建
使用 Matplotlib 的 imshow 函数，我们可以像绘制任何图像一样绘制光栅数据。我们可以看到这个图中的海岸线和我用来创建上面的边界框的谷歌地球轮廓之间的大致相似之处，这意味着我们确实正确地选择了数据！
然而，这个情节缺少一些关键的组成部分。让我们用一些基本的 Matplotlib 格式使它更丰富一些:
fig = plt.figure(figsize=(12,6))
im = plt.imshow(swe[0,:,:],cmap='gist_rainbow')
plt.colorbar(im)
plt.title("SWE (mm) on Jan 23, 1993 | North Slope, Alaska");
由作者创建
这是我喜欢在演讲中使用的情节；这很简单，有助于避免分心，并且可以很快被消化，以便听众可以专注于我所说的内容。当在投影仪上呈现色彩不总是最饱和的地块时，使用对比度更高的色彩映射表会有所帮助。强烈对比的颜色使人们能够很快看出细微的差异，而这些差异在更微妙的颜色图上很难分辨出来。
利用支线剧情
支线剧情通过允许我们在一张画布上组合多个情节，为我们提供了许多扩展的功能。我们可以使用支线剧情来查看我们的研究区域在第一年不同季节的快照。
由作者创建
由作者创建
这是个很酷的情节。有趣的是，看到雪在秋天积累，在冬天达到高峰，并通过春天的图像几乎完成融化。在夏季/秋季图像和冬季/春季图像之间，海洋也在明显地改变温度；我们可以看到海洋重新变暖的时间可能比陆地上的雪融化的时间要长。
虽然这些图提供了丰富的信息，但由于我们将数据视为普通图像，因此我们失去了坐标参考系统，该系统实际上将网格与地球相一致。当我们像这样绘制空间数据时，我们失去了许多适当的形状和空间背景；接下来让我们尝试使用 Cartopy 在地图上绘制它。
添加投影
默认情况下，Matplotlib 设计用于在传统网格空间中绘图。为了在地图上显示数据，我们必须有一个带有匹配投影的底图。幸运的是，有一个名为 Cartopy 的库，它被设计用来处理地理空间数据，以便使用 Matplotlib 进行制图。我最喜欢 Matplotlib 的一点是，开发人员在它的基础上进行构建是多么容易；Cartopy 在某种程度上类似于 Seaborn，它建立在 Matplotlib API 之上，为用户带来了一个更加定制化的工具。
我们从定义制图坐标参考系统(CCRS)对象开始。这些告诉 Cartopy 我们的数据正在使用什么坐标参考系统(CRS)。
geod = ccrs.Geodetic()
proj = ccrs.LambertAzimuthalEqualArea(central_latitude=90.0)
我们数据的投影是以北极为中心的 Lambert 方位角等面积。让我们通过定义我们的投影和范围，使用我们的新坐标系来绘制地球的北半球。
由作者创建
由作者创建
在这张地图中，我们俯视北极，北美在左边，非洲在底部作为参考。您会注意到，我们没有绘制任何数据，这是因为这本质上是我们的新“画布”。Matplotlib 现在将 EASE-Grid 2.0 坐标视为绘图空间。
如果我们想在这个底图上分层数据，那么我们也需要找到数据的范围。您会注意到，当我们绘制底图时，我们用四个数字定义了范围。这些是边界框左上角和右下角的 x/y 坐标。在这种情况下，-9，000，000–9，000，000 米是 EASE-Grid 2.0 格网中两个 x/y 坐标的最大范围，北极位于点(0，0)。
我知道我学习区域的左上坐标是[-145，66]，右下坐标是[-165，72]。这些是以度为单位的大地坐标，可以使用前面定义的 Cartopy 对象转换为米(由 EASE-Grid 2.0 使用)。
找到我们的边界坐标(由作者创建)
您会注意到我们将源坐标参考系统设置为geod，这是另一个 CCRS 对象，表示使用度数、纬度和经度的大地坐标参考系统。我们使用兰伯特方位角等面积 CCRS 物体来转换坐标，因为那是我们的目标投影。
现在，我们在正确的 CRS 中有了新的边界坐标，我们可以继续绘制我们的研究区域:
由作者创建
覆盖数据(由作者创建)
不错！现在，我们已经将数据叠加到地图上，我们可以使用海岸线来验证我们是否使用了正确的投影和方向。我最初将 SWE 数据上下颠倒绘制，因为它的“原点”与基础地图不同，所以如果有些东西偏离了，不要害怕调整方向。
这张地图有点缩小了。很难非常清楚地看到 SWE 数据。我们可以通过调整底图的范围来放大:
ease_extent = [-3000000., 1000000., -1000000., 3000000.]
由作者创建
Cartopy 为 Matplotlib 带来了强大的功能，支持许多投影。
动画 Matplotlib 图
我总是发现用 Matplotlib 显示连续的变化非常困难。我们可以制作支线图来显示离散的变化，但是如果不使用动态绘图工具，显示变化是有挑战性的。解决这个问题的一个方法是使用动画。创建随时间变化的图形的电影或 gif 并不困难，这对于可视化地理空间数据的变化非常有用！
让我们试着用动画演示我们的原始绘图，它使用plt.imshow() 来绘制我们的 SWE 数据。
由作者创建
动画 SWE(由作者创作)
制作动画剧情真的那么容易！关键是我们有一些迭代绘图的方法。在这种情况下，我简单地遍历 1000 天的时间序列，并保存每个图的快照，然后将其转换为 gif。因此，我们首先创建一个 Matplotlib 图形fig，并将其传递给Camera()实例化器。现在，每次我们迭代创建一个新的图形时，我们只需用camera.snap()对当前的 Matplotlib 图形进行快照。
有多种方法可以创建动画 Matplotlib 图。大多数例子可能会使用内置的Matplotlib.animation模块。总的来说，这个模块工作得很好，但是，我遇到了依赖问题，阻止了在 Windows 10 上导出动画。Matplotlib 的动画模块也不能导出为 GIF 格式，而 GIF 是我用来分享演示和文章的首选格式。
为了避免依赖性问题并直接导出为 GIF 文件，我们可以使用一个叫做赛璐珞的库。赛璐珞是一个轻量级的库，用于从现有的情节中创建动画。它的开发并不活跃，但是如果您对内置的 Matplotlib 功能有问题，我建议您尝试一下。我喜欢它可以很容易地添加到现有的情节与任何功能的最低限度的返工。
实际上，在 Matplotlib 图形上绘制的任何东西都可以被动画化。所以我们也可以在地图上制作 SWE 图像的动画！
由作者创建
动画漫画/Matplotlib 图(由作者创建)
我觉得这些动画情节挺好玩的。能够看到陆地和海洋上的数值如何随着相应的日期变化，确实有助于显示每年的积累和融化周期。我们还可以以各种方式聚合数据，然后将这些聚合动画化。
包扎
虽然有时可能会觉得在 Python 中有比 Matplotlib 更好的绘图选项，但它仍然是最可靠和有效的绘图工具之一。Matplotlib 做得很好，为我们提供了一个可以根据我们的每一个愿望进行定制的画布。如果您需要为演示文稿、论文或文章绘制图表，Matplotlib 的可定制性是无可争议的。
除非您需要交互式地图，否则您可能会在某个时候使用 Matplotlib 来可视化 Python 中的地理空间数据。幸运的是，Cartopy 这样的库为 Matplotlib 提供了处理各种地理空间数据的能力。
资源
可视化技能评估指标
评估你的模型有多“好”
无论是评估回归模型还是地球系统模型，我们都需要能够量化它的“好”，这可能是主观的。这篇文章讨论了一套常用的技能评估指标，它们的优点，以及如何可视化或解释它们。每个指标将模型的 预测值(P) 与一组 实际观察值(A) 进行比较。
我不主张选择一个度量标准来量化好，而是提倡综合并呈现一套标准。在这篇文章中，我将讨论:bias、MAE、RMSE、NSE和RI。我将描述每个指标，展示它的可视化，并展示如何用 Python 对它进行编码。前三个(bias、MAE和RMSE)是一个数字，用来量化预测的偏差程度。每一种都提供不同的信息，应该在分析中提出。
其他两个指标NSE和RI应谨慎解读，因为它们涉及比率。NSE量化模型的预测能力，而RI量化预测在乘法意义上的偏离程度。
0.交叉绘图
虽然不是一个技能指标，但这个情节非常重要，值得讨论。每当将预测值与实际数据进行比较时，总是从交会图开始，y 轴上的 预测值 ，x 轴上的 实际值 ，以及一条一对一的对角线。
将预测值放在 y 轴上，将实际值放在 x 轴上是很重要的。有了这个约定，一对一线以上的点被高估，线以下的点被低估。因此，坚持这一惯例可以对预测进行快速的视觉评估，并可以告诉你是否存在系统性偏差。
残差
下图显示了交叉图上的数据点，并说明了如何可视化单个数据点的【R】。
单个数据点的残差示意图。
为了得到正确的符号，残差必须计算为预测值减去实际值。在 Python 中，残差可以通过按元素减去两个数据集来计算，这通常适用于大多数数据类型:
*residual = prediction - actual*
残差是预测值和实际值之间的差值，它告诉您两条信息:
- 量级:预测与实际观测的差距有多远
- 符号:正表示高估，负表示低估
总是从一个交会图开始，y 轴上的 预测值 ，x 轴上的 实际值 ，以及一条一对一的对角线。
1.*均误差(偏差)
*均误差或偏差是所有残差的*均值，与符号无关。
偏差方程(图片由作者提供)
一个等价的表达偏差的方式是这样的:bias = mean(P) — mean(A)，因为你可以分配总和。这清楚地表明，偏见仅仅是手段的不同。对偏差的解释是量化预测是否过度或低估的一种快速而肮脏的方法。
计算
无论你计算的*均误差是所有残差的*均值，
*import numpy as npresidual = prediction - actual
mean_error = np.mean( residual )*
或者作为两个*均值之间的差异，
*import numpy as npbias = np.mean(prediction) - np.mean(actual)*
答案完全一样。
*均误差是*均残差，与符号无关。
无偏见是什么意思？
解释偏差时一定要小心，因为接*零的值可能会引起误解。例如，如果较低的实际值被高估，而较大的值被低估，那么bias也将出现在零附*。这在下面右边的图中有所说明。
两个交叉图，每个都有接*零的偏差。
这是因为大小相似的正负残差相互抵消，从而导致接*零的bias。因此，要小心不要过于强调偏见，总是要参考交叉图来为bias添加上下文。
也可以计算交会图的线性回归斜率，为bias添加上下文。如果预测与实际观测完全一致，则斜率为 1。
谨慎解释偏见是很重要的
2.*均绝对误差
*均绝对误差MAE与*均误差相似，只是我们忽略了符号。数学上，这是通过取绝对值来完成的。换句话说，MAE是残差的*均幅度。值得注意的是没有告诉你错误的方向。
*均绝对误差方程。这与偏置方程非常相似，只是我们取绝对值。(图片由作者提供)
MAE 是残差的*均幅度
计算
使用numpy，MAE是这样计算的:
*import numpy as npmae = np.mean(np.abs(prediction - actual))*
sklearn的实现如下所示。
*from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(actual, prediction)*
实际值通常是sklearn.metrics中的第一个参数，但顺序与 MAE 无关。
MAE 告诉你，*均来说，一个数据点距离一对一的直线有多远
3.均方根误差(RMSE)
了解 RMSE 的最好方法是把它分成以下几个部分:
- *方误差 : SE
- 均方误差 : MSE
- 均方根误差: RMSE
*方误差:标准误差
这是通过对每个数据点的残差求*方来计算的，并显示在一个十字图上，就像正方形一样。见下图:
交会图上的*方误差示意图。
更准确地说，它被想象成一个区域。如果我们预测的是开尔文温度，那么误差*方的单位是开尔文*方。
均方差:MSE
均方误差 MSE 就是*均“误差面积”。然而，MSE 不是一个好的技能指标，因为单位仍然是*方的。MSE 随残差呈指数增长，因为它代表一个面积，并且通过对残差求*方来计算。
均方根误差:RMSE
求 MSE 的*方根解决了单位问题，并得到均方根误差(RMSE)。这可以解释为 MSE 正方形的边长。
RMSE 方程(图片由作者提供)
计算
下面是一个numpy实现。
*import numpy as np# squared error
se = (actual - prediction)**2# mean squared error
mse = np.mean(se)# root mean squared error
rmse = np.sqrt(mse)*
下面是一个sklearn实现:
*from sklearn.metrics import mean_squared_error# mean squared error
mse = mean_squared_error(actual, prediction)# take square root of mse
rmse = np.sqrt(mean_squared_error)*
RMSE 边界
看起来似乎RMSE和MAE是同一个数字。然而，RMSE被限制在MAE和MAE*sqrt(N)之间。下限是当所有的误差具有相同的幅度时，而上限是当所有的N点除了一个以外都为零时的情况。
RMSE 误差界限(图片由作者提供)
见这篇文章关于 RMSE 及其误差范围的详细讨论。
MSE 告诉你*均面积，RMSE 告诉你面积的*方长度。
RMSE 对重大失误的处罚力度更大
RMSE 对大错误的惩罚比 MAE 多，这可能是一个可取的特征。例如，考虑以下两个残差，5 和 10
- 梅说，10 点下班比 5 点下班“糟糕”两倍。
- RMSE 说，10 点前的失误是 5 点前的两倍多。这是因为残差首先被*方。
RMSE 对重大失误的处罚力度超过了 MAE
其他指标
以下两个指标与后三个不同。它们是作为比率计算的，因此需要小心解读。每当涉及一个比率时，总有被零或一个非常小的值除的风险。解释 NSE 和 RI 时要小心
4.纳什-萨特克利夫效率
Nash-Sutcliffe 效率衡量的是预测值相对于观测*均值的准确程度。这与 RMSE 的根据有关:
纳什-苏特克利夫效率方程(图片由作者提供)
其中var(A)是实际观测值的方差。
计算
这里是NSE的一个numpy实现。
*import numpy as np# squared error
se = (actual - prediction)**2# mean squared error
mse = np.mean(se)# nse
nse = 1 - (mse/np.var(actual))*
解释
- NSE = 1 :满分
- NSE = 0 :表示预测并不比观测*均值好。
- NSE < 0 :表示观察*均值是比您的模型更好的预测器
5.可靠性指数
可靠性指数被解释为预测值与实际观测值不同的*均因子。例如，RI 为 2 表示，*均而言，预测值与观测值在乘法因子 2 的范围内一致。理想情况下，RI 应该接* 1。
可靠性指数方程(图片由作者提供)
计算
在数学上，RI 从对预测和观测值进行对数转换开始。然后计算 RMSE，最后对结果求幂。因此，RI 是对数变换预测和观测值的指数 RMSE。
下面是一个numpy实现。
*import numpy as np# logged squared error
log_se = np.log(prediction/actual)**2# log rmse
log_rmse = np.sqrt(np.mean(se))# reliability inded
ri = np.exp(log_rmse)*
最后的想法
这篇文章描述了评估模型预测的五个标准，无论是回归模型还是海洋模型。对于bias、MAE和RMSE，越接*零预测越好。对于NSE和RI，1 分被认为是完美的。我主张显示所有这些指标的完整性。关于海洋科学背景下这些指标的详细讨论，我鼓励你阅读 Stow et al. 2009 。
我没有讨论的一个常见指标是相关性，它也与决定系数(R2)相关。这个在别处已经讨论过了(见相关帖子)。
讨论的每个度量都是空间和时间上的敏感相移。因此，每个指标都可以用“滞后”来计算例如，通常通过计算滞后相关性来确定任何滞后-超前效应。
相关职位
*https://medium.com/human-in-a-machine-world/mae-and-rmse-which-metric-is-better-e60ac3bde13d https://medium.com/@SilentFlame/pearson-correlation-a-mathematical-understanding-c9aa686113cb
感谢阅读和支持媒体作者
https://lukegloege.medium.com/membership *
用 Python 和 Tableau 可视化 Spotify 数据
使用您的流数据和 Spotify 的 API 创建一个动态仪表板
我不需要做这个项目来发现我仍然沉迷于 Lorde 的'https://open.spotify.com/track/0TEekvXTomKt3hdXDZxxeW****''排骨，但尽管如此，工作还是很有趣。参见下文，了解如何使用您自己的 Spotify 数据轻松复制它！
https://public . tableau . com/app/profile/Anne . bode/viz/spotifypremiumdash/PremiumDashboard
步骤 1:请求数据
在此 向 Spotify 索取您的数据副本。耐心等几天。可能有一种方法可以直接使用 Spotify 的 API 请求这些数据，但那是另外一个项目了！
步骤 2:准备流/库数据
使用 Spotify 给我们的文件，我们现在将创建一个数据帧，其中包括我们所有的流媒体数据，以及每首歌曲是否在我们的资料库中，以及每首歌曲的 Spotify“URI”(唯一标识符，以后会派上用场)
创建 df_stream :
接下来，我从 Spotify 清理了我的“YourLibrary”文件，这样它就只包含了“tracks”字典，用方括号[ ]括起来，并保存为一个新文件“YourLibrary1”。更擅长清理 json 文件的人可能会自动执行这个步骤，并使用原始文件。
创建 df_library :
创建我们的最终数据帧， df_tableau:
步骤 3:创建新的 Spotify 项目
在这里 登录你的开发者账号 。在仪表板中，创建一个新项目。创建后，您可以检索您的“客户 ID”和“客户机密”我们将在步骤 4 中使用这些。
步骤 4:使用 Spotify 的 API 创建流派数据框架
首先，我们将使用我们的客户端 ID 和客户端密码来生成一个访问令牌，这样我们就可以从 Spotify 的 API 中提取数据。注意:此令牌必须在一小时后重新生成。我在 这篇文章 的帮助下想出了如何做到这一点。
现在，我们将从库中提取与每个 track_uri 相关联的艺术家和流派，并添加到字典(查看 Spotify 的 控制台以了解如何提取您感兴趣的数据点)。****
我们将把这个字典转换成一个 dataframe ( df_genre )并扩展它，以便每个曲目/艺术家的每个流派都在它自己的行中(我使用了这个解决方案)。这将创建 df_genre_expanded 。
然后，我们将把 df_tableau 和 df_genre_expanded 保存为 csv 文件，以便加载到 tableau 中。
步骤 5:将数据加载到 Tableau 中
连接到 Excel 文件(MySpotifyDataTable.csv)作为数据源。这应该也会在左侧弹出您的 GenresExpandedTable.csv 文件。将后一个文件拖到右边，并在两个表之间添加一个关系。确保基于 track_uri 创建关系(注意:您可能需要单击 GenresExpandedTable.csv 旁边的向下箭头，然后单击“字段名在第一行”)。
步骤 6:编辑 Tableau 中的字段
我们将在数据表中添加两个计算字段。我们可以用 Python 来完成这个，但是我想用 Tableau 来做实验。
- 将 Ms 播放转换为分钟收听*:
【Ms 播放】/60000*** - 将结束时间* (UTC)转换为结束时间(Adj) (您的时区，已考虑夏令时):
IF【结束时间】<DATE(2020–03–08)THEN DATEADD('小时'，-5，[结束时间])
ELSEIF【结束时间】<DATE(2020–11–01)THEN DATEADD('小时'，-4，[结束时间***
步骤 7:创建可视化效果
下载仪表板 来看看我是如何创建下面的可视化效果的。请注意，它们在仪表板中都是链接在一起的，因此可以互相过滤，这很不正常！
仪表板过滤了风格为“alt z”的歌曲/艺术家——我是一个酷 Z 一代的孩子吗？
- 顶级艺人:收听分钟数最多的流行艺人，个人歌曲构成了丰富多彩的片段
- 艺人广度 : 我听了> 1 分钟和> 1 流的每位艺人的歌曲数量
- 热门歌曲:收听分钟数最多的流行歌曲
- 流派:我听过的所有流派，用大小和颜色表示流的数量
- 按月统计的听众人数:不言而喻的(编辑 9/29:我将“在图书馆中”字段从一个度量转换为一个维度，这样我就可以将它包含在一个堆叠条形图中，以查看我每个月总共听了多少分钟，其中有多少分钟在我的图书馆中)
- 每小时听众人数:不言自明
最后
通过分析您的 Spotify 流媒体和图书馆数据，您可以收集到大量有趣的见解，尤其是结合通过 Spotify API 获得的其他数据字段(即流派)时。我知道今年我真的很喜欢朱利安·贝克，我对洛德的爱没有时间限制。8 月份，我听了太多阿德里安娜·伦克的'https://open.spotify.com/track/1abuE8PRWIA2GAH1DqzfNl*'(# sadgirlvibes)，但 12 月份，我最喜欢的歌当然是玛丽亚·凯莉的' 我想要的圣诞礼物就是你 '。现在我知道如何连接到 Spotify 的 API，在未来的项目中，我想检查我听的歌曲/艺术家的音乐质量(不仅仅是流派)。我特别感兴趣的一个领域是“可跳舞性”，因为每当我被指派为家庭公路旅行的 DJ 时，我母亲的唯一标准就是“我能跟着跳舞的东西。”不管那是什么意思。***
祝你好运分析你自己的收听历史，继续收听 2013 年以来你最喜欢的歌曲！
用 Python 可视化 Spotify 歌曲:探索性数据分析
实践教程
需要回答的一些问题:是什么让流行音乐流行？今天的音乐与 30 多年前有什么不同？
sgcdesignco 在 Unsplash 上的照片
在过去的一年里，我一直在使用 Spotify 应用程序收听我最喜欢的艺术家，并获得新歌推荐。最*，我了解到该应用程序根据音频特征系统对曲目进行分类，并将它们存储在一个数据库中，通过其 API 可以轻松访问。所以，我想:我们能不能利用这个数据库更好地了解其中的轨迹？也就是说，我们可以根据音乐的流行程度或发行年份等因素来划分音乐分组，从而发现任何趋势吗？让我们开始吧:
音频特性:
根据 Spotify 网站的说法，他们所有的歌曲都在以下每个类别中得到了分数(摘自 Spotify API 文档，https://developer . Spotify . com/documentation/we b-API/reference/):
- 情绪:可跳性、效价、能量、节奏
- 特性:响度、语音、乐器性
- 语境:活跃度，声音
我将要使用的数据来自这个 Kaggle 数据集:https://www . ka ggle . com/yamerenay/Spotify-dataset-19212020-160k-tracks？select=tracks.csv 。
1。前 100 首最受欢迎的歌曲对比所有数据集
首先，让我们将前 100 首歌曲与数据集的其余部分进行比较。这是通过对“受欢迎程度”列进行排序来完成的:
现在我们有了数据，让我们来看看每首歌的特点。具体到这一部分，我们将查看前 100 首最流行歌曲以及所有数据集的*均值。为了形象化这一点，我们可以使用如下雷达图。下面的代码是:
- 获取数据的所有标签，在我们的例子中是音频特征，并获取它们的含义。有两个变量:“特征”，具有前 100 首歌曲的音频特征的*均值，以及“特征 _ 全部”，具有所有数据集的*均值。
- 用不同的颜色在同一雷达图上绘制“特征”和“特征 _ 全部”。
前 100 首歌曲和其余数据集的特征*均值雷达图
从剧情来看，这两个歌曲分组在几乎所有的音频特征上似乎都有一些不同。也就是说，最流行的歌曲更“有活力”，“可跳舞”，并且具有更高的“明确性”值。根据 Spotify 对这些特征的定义，其余歌曲在“声音”和“效价”类别中得分较高，这可以被解释为传达了更多的积极信息。
比较盒式图中的歌曲
既然我们看到两组人的特征有一些不同，我们来更好地看看他们怎么样？下面，您可以找到这些功能的方框图，0 表示数据取自前 100 首歌曲，1 表示数据取自数据集的其余部分。
前 100 首歌曲和其余数据集的特征的方框图
箱形图还显示了两组特征的一些差异:在“活泼”子图中，流行歌曲部分比数据集的其余部分短。然而，在很大程度上，这些图证实了我们对这些群体的观察。
精力与舞蹈能力
现在让我们画一个散点图，看看“活力”和“可跳舞性”特征之间是否有关联。除了前 100 首最受欢迎的歌曲，我还从数据集中随机选择了 100 首歌曲。在下图中，有两种不同的颜色，黄色表示 100 首随机歌曲，紫色表示前 100 首歌曲。
能量与舞蹈性散点图
计算的皮尔逊相关系数是:0.35156523(对于黄色/所有数据集点)和 0.20520467(对于前 100 首歌曲)。
价和活泼
我们可以画的另一个散点图是化合价与活跃性的关系。“生动性”代表一首歌曲是否在观众面前现场表演的概率。该图的图例同上:
化合价和活度散点图
有趣的是，这两个变量之间似乎没有很强的线性关系。在这里，我还计算了皮尔逊系数，就像上面的散点图一样:-0.09403765(黄色点)和 0.02555036(紫色点)。
3.比较时代:90 前与 90 后
除了比较流行歌曲和数据集的其他部分，我们还可以看看不同时代之间歌曲的差异。出于本教程的目的，我将把年代定义为 1990 年之前和 1990 年之后。现在让我们看一个与上面类似的雷达图，但是有这两个类别(图的代码基本相同，所以我不会在这里再次展示)。
对比 20 世纪 90 年代前后音乐的雷达图
根据盒子情节，两个时代的音乐有几个不同之处:首先，90 年代后的音乐更“有活力”、“适合跳舞”和“明确”。而其他特征如“效价”和“活泼性”在两者中非常相似。20 世纪 90 年代以前的音乐在“声音性”和“乐器性”方面也往往得分较高。
4.可视化最受欢迎的艺术家
该数据集还包括每首歌曲的艺术家姓名，但采用列表格式。为了解析单个的名字，我们可以使用“re”，这是一个非常有用的文本操作包。首先，我们从列表中删除“[”和“]”，并构建一个文本模式来搜索数据。由于艺术家通常使用他们的全名或一个艺术名称，该模式查找一个或两个单词，由一个字符分隔，如下所示:
然后，我们在数据集的列中执行搜索，并使用另一个名为“collections”的 Python 包来计算每个艺术家的出现次数:
以下是统计前 100 名艺术家的结果:
按歌曲数量排名前 100 位的艺术家
顶级艺术家是贾斯汀比伯(5 首歌曲)和坏兔子(4 首歌曲)，反映了 2021 年 4 月收集该数据集时公众的偏好。
5.图形音频功能相似
对于这一部分，我们将使用 networkx 包来绘制图表，以可视化歌曲之间的相似性。要使用的功能将是 Spotify 音频功能，我们将使用余弦相似度、来计算歌曲相似度，这是一种常用的测量对象(如歌曲、电影或书籍)之间相似度的方法。我们可能试图回答的一个问题是，哪些歌曲与许多其他歌曲相似。也就是说，有没有“听起来”和别人差不多的歌？让我们将一首歌曲与另一首歌曲的相似度的下限设定为余弦相似度 0.95。下面是计算余弦相似度和绘制图形的代码:
余弦相似度高于 0.95 的前 100 首歌曲的图表
正如你在下图中看到的，没有多少歌曲是彼此非常相似的，因为图中包含的节点少于 100，这是我们最初的数字。但是，哪些歌曲的“度”最高，这意味着它们与图中的许多其他歌曲相似？
代码返回数据库中的第 55 个条目，对应于 23 度，这意味着这首歌与其他 23 首歌相似。这首歌是这样的:
与前 100 名中的其他人相比度数最高(边缘最多)的歌曲
让我们也获得一些关于该图的其他信息，例如*均程度，它告诉我们一个音轨有多少首歌曲的*均值是相似的:
- *均度: 12.494845360824742(歌曲*均类似其他 12 首左右)
- 节点数: 97
6.获取歌词数据
对于这一部分，我们还将分析数据集中歌曲的歌词数据。为此，我们可以使用 LyricsGenius API。由于数据集非常大，我将再次随机选择大约 400 首歌曲来可视化。为了用 LyricsGenius 搜索歌词，您需要知道歌曲和艺术家的名字，所以下面的代码提取了这两条信息并搜索了歌词:
从所有数据集中选择和抓取 400 首随机歌曲
7.歌词分析
既然我们已经研究了最流行歌曲的音频特征，我们也可以尝试分析数据子集的歌词。对于这一部分，我们将使用 Python 的 TextBlob 包对我们在上面的步骤 6 中选择的歌曲进行文本分析。
- 文本情感分析:极性
歌词的一个方面是它的极性，或者文本被认为是积极的(值更接* 1)还是消极的(值更接*-1)。这是歌曲子集极性的方框图:
400 首随机歌曲文本极性的箱线图
虽然该指标的中值约为 0，这意味着歌曲大多是中性的，但在图的两个方向上仍有许多异常值。这表明有许多积极乐观的歌词，也有消极的。
- 词性分析
在进行文本分析时，查看词性标注对于理解文档也很重要。你可以在这里阅读更多关于所有部分的内容:https://www . geeksforgeeks . org/python-part-of-speech-tagging-using-text blob/。在这个故事中，我们将学习 NN(单数名词)、NNS(复数名词)、RB(副词，如“非常”)、rbs(最高级副词)、RBR(比较副词)和 VB(基本动词)。让我们看看我们挑选的 400 首歌曲是如何根据上述部分的百分比使用以下代码创作的:
现在我们已经有了每首歌的这些指标，我们可以使用一个方框图来可视化它们:
词类构成
词类构成第二部分
正如你所看到的，单数名词占了歌词的很大一部分，其次是动词和规则副词。另一方面，比较级和最高级副词在歌词中不常出现。
结论
总结我们的发现，我们发现与其他歌曲相比，最受欢迎的歌曲之间以及不同时代之间存在相当大的差异。我们还构建了图表来查看哪些歌曲与其他歌曲更相似，并查看了用于查看歌词的文本分析技术。下面是您可以仔细查看的代码:https://github . com/DeaBardhoshi/Data-Science-Projects/blob/main/Music % 20 system . ipynb
我希望你喜欢这篇文章，并感谢阅读！
使用 Python 可视化统计数据-使用 Matplot 讲述故事
用 Python 讲述数据故事
为泰坦尼克号数据集精心制作一个故事
数据科学家可以学习的最重要的技能之一是如何使用给定的数据编写令人信服的故事。虽然我们倾向于认为我们的工作是客观的和技术性的，概括在格言“数字不会说谎”中，但我们也应该意识到它更主观的方面。我们不应该陷入这样一个陷阱，即认为我们的工作完全脱离了我们自己对世界的印象和先入为主的观念。
在这篇文章中，我将回顾相同的数据集可以被用来制作不同的(有时是相互矛盾的)关于主题的叙述的许多方法。
我们开始吧！
像往常一样，让我们导入将要使用的 Python 库。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import scipy.stats as stats
太好了，现在让我们导入将要使用的数据。
df = pd.read_csv('titanic_data.csv')
df.head()
数据帧的前 5 行
你可能已经注意到了，我们使用的是经典的泰坦尼克号数据，可以在 Kaggle 这里的找到。我鼓励新的数据科学家看一看它，因为它是开始学习基本统计学的一个极好的方法。
让我们先来看看最明显的特征，幸存者人数。
fig, ax = plt.subplots(1, figsize=(5,5))
plt.suptitle('Frequency of Survival', fontsize=15)
ax.bar(dataset['Survived'].value_counts().index,
dataset['Survived'].value_counts().values,
color = ['darkblue', 'darkorange'])
ax.set_xticks(range(0, 2))
ax.set_xticklabels(['Died','Survived'], fontsize = 14);
死亡与存活的计数图(由代码生成的图像)
正如我们所看到的，记录显示死亡人数多于存活人数。尽管这是一个有趣的统计数据，但我们并不能从中挖掘出多少故事。现在让我们加入一些其他的描述性特征，比如性别。
fig, ax = plt.subplots(2,2, figsize=(15,10))
plt.suptitle('Survival by Gender', fontsize=25)
ind = np.arange(2)
width = 0.45x_axis_status = dataset['Survived'].value_counts().index
x_axis_sex= dataset['Sex'].value_counts().index
male_stats = dataset[dataset['Sex'] == 'male']['Survived'].value_counts().values
female_stats = dataset[dataset['Sex'] == 'female']['Survived'].value_counts().valuesax[0][0].set_title('Stacked Graphs', fontsize = 18)
ax[0][0].bar(x_axis, male_stats, label = 'Male', color = 'darkblue')
ax[0][0].bar(x_axis, female_stats, label = 'Female',
color = 'darkorange', bottom = male_stats)
ax[0][0].set_xticks(range(0, 2))
ax[0][0].set_xticklabels(['Died','Survived'], fontsize = 14)ax[0][1].set_title('Side-by-Side Graphs', fontsize = 18)
ax[0][1].bar(ind, male_stats , width, label='Male',
color = 'darkblue')
ax[0][1].bar(ind + width, female_stats, width, label='Female',
color = 'darkorange')
plt.sca(ax[0][1])
plt.xticks(ind + width / 2, ('Died', 'Survived'), fontsize = 14)ax[1][0].set_title('Stacked Graphs', fontsize = 18)
ax[1][0].bar('Male', male_stats[0], label = 'Died',
color = 'darkblue')
ax[1][0].bar('Male', male_stats[1], label = 'Survived',
color = 'darkorange', bottom = male_stats[0])
ax[1][0].bar('Female', female_stats[0], color = 'darkblue')
ax[1][0].bar('Female', female_stats[1], color = 'darkorange',
bottom = female_stats[0])
ax[1][0].set_xticklabels(['Male','Female'], fontsize = 14)ax[1][1].set_title('Side-by-Side Graphs', fontsize = 18)
ax[1][1].bar(0, male_stats[0] , width, label='Died',
color = 'darkblue')
ax[1][1].bar(0 + width, male_stats[1] , width,
label='Survived', color = 'darkorange')
ax[1][1].bar(1, female_stats[0] , width, color = 'darkblue')
ax[1][1].bar(1 + width, female_stats[1] , width,
color = 'darkorange')
plt.sca(ax[1][1])
plt.xticks(ind + width / 2, ('Male', 'Female'), fontsize = 14)[axi.legend(fontsize = 14) for axi in ax.ravel()]
[axi.set_ylim(0, 800) for axi in ax.ravel()]fig.tight_layout()
plt.show();
图表比较(代码生成的图像)
既然我们已经纳入了性别因素，我们的分析可能会更有趣。通过设计，我们制作了四个不同版本的基本相同的图表。注意每一个微小的变化是如何突出数据的不同方面的(因此需要不同的叙述)。
上面的两张图给人的印象是，我们应该关注乘客死亡中的性别差异。如果我们看上面的图表，我们会注意到更多的人死于泰坦尼克号的沉没。然后，我们可能会忍不住得出结论，这是如何通过“妇女和儿童”优先政策实现的。然而，看下面的一组图表揭示了一些更微妙的东西。
与上面的图表不同，死亡人数中的性别差异并不是重点。实际上强调的是，男性和女性的死亡率明显相似。
“但这怎么可能呢？”你可能会问。男性显然代表了更多的死亡。那么，两性的死亡率怎么会相似呢？
答案在另一张图中。
fig, ax = plt.subplots(1, figsize=(5,5))
plt.suptitle('Gender Split', fontsize=15)
ax.bar(dataset['Sex'].value_counts().index,
dataset['Sex'].value_counts().values,
color = ['darkblue', 'darkorange'])
ax.set_xticks(range(0, 2))
ax.set_xticklabels(['Male','Female'], fontsize = 14);
按性别划分的乘客计数图(由代码生成的图像)
我们可以看到，男性实际上大大超过了女性，两者相差大约 82%。这样一来，男性在死者中所占的比例就更大了，这也就说得通了，因为他们的数量本来就更多(请注意，男性也构成了幸存者的大部分)。
当然，这并不是说不存在强调保护妇女和儿童而不是成年男子的偏见。然而，当试图寻找这种特殊偏见的证据时，我们必须认识到要使用的“正确的数据。我们还必须认识到，完全相同的数据在被选为主要分类器时可能看起来非常不同(在我们的案例中，幸存者身份与性别)。如果我们依赖第一组图表，我们可能会夸大死亡统计中的性别差异水*。
但是现在让我们不要从性别的角度来看这些数据，而是从年龄的角度来看。
fig, ax = plt.subplots(figsize=(10,7))
age_died = df[df['Survived']==0]['Age']
age_survive = df[df['Survived']==1]['Age']
n, bins, patches = plt.hist(x = [age_died, age_survive],
stacked = True, bins='auto',
color=['darkblue', 'darkorange'],
alpha=0.65, rwidth=0.95)
plt.grid(axis='y', alpha=0.55)
plt.xlabel('Passenger Age', fontsize = 15)
plt.ylabel('Frequency', fontsize = 15)
plt.title('Age Distribution of Passengers', fontsize = 22)
plt.legend(['Died','Survived'], fontsize = 15);
按乘客年龄划分的存活率(由代码生成的图像)
从上面的图表中我们可以看出，年轻肯定有优势，因为我们注意到，存活数大于死亡数的唯一时间是在 10 岁以下。此外，我们看到一个八十多岁的老人能够在灾难中幸存下来，也许一些乘客同情他们，让他们上了救生艇。
总之
我们已经看到了图表中的细微变化如何对数据的整体叙述产生巨大影响。在实际的数据科学项目中，我发现简单地制作一个条形图并接受 Matplotlib 或 Seaborn 的第一个输出是一种诱惑。虽然这有助于加快进程，但我们在最初查看数据时必须小心。我们必须尽力以多种方式将其可视化，以确保我们不会对数据产生错误的印象。在以后的文章中，我们将讨论更高级的统计概念以及可视化它们的最佳方式。现在，我希望这篇文章已经帮助你认识到我们的工作有时会相当主观。
可视化幸存者电视节目数据集:幸存者个性和投票团队模式
十几岁的时候，我记得电视真人秀《幸存者》每一集的精彩场面。虽然观众对角色的阴谋和策略有了接*真实的一瞥，但我们都知道真正的洞察力隐藏在原始数据中。
最*发布了一个新的公共数据集，记录了数据科学家希望在电视节目中看到的一切:从评级，到漂流者的个性，以及投票结果。
在这篇博文中，我将尝试一些我觉得有趣的可视化。
获奖者的性格特征是什么？
Myers-Briggs Type Indicator是一种流行的个性特征方法，尽管它作为一种心理测量工具的有效性一直是许多批评的主题！但是有人(！？)正在努力对 40 季中的每一季进行分类，每集 20 名漂流者，参与者，以及…数据已经在那里了，所以为什么不看看呢。只是为了好玩。
bind_rows(
castaways %>% ungroup %>%
mutate(place = case_when(
result == ‘Sole Survivor’ ~ ‘Sole Survivor’,
result == ‘Runner-up’ ~ ‘Runner-up’,
TRUE ~ ‘voted-out / other’)) %>%
count(place, personality_type) %>%
group_by(place) %>%
mutate(perc = n / sum(n)) %>%
ungroup,
castaways %>% ungroup %>%
count(personality_type) %>%
mutate(perc = n / sum(n)) %>%
mutate(place = ‘all’)
) %>%
filter(!is.na(personality_type)) %>%
mutate(personality_type = as.factor(personality_type)) %>%
ggplot(aes(x = personality_type, y = perc)) +
geom_bar(position=”dodge”, stat=”identity”) +
facet_grid(~place) +
coord_flip() +
labs(title = ‘Survivors castaway personality type across all seasons, overall, and by winning place subgroups’,
subtitle = ‘% are relative to the place-group only, e.g. Runner-up only, etc’,
caption = ‘created by Dror Berel’) +
theme(axis.text.x = element_text(angle = 90))`
图来源:作者
首先，让我们来看看制片人是否有偏见选择，只选择特定的性格类型来表演。左侧的“所有”柱状图直观地表明，在所有 731 名遇难者中，总体上有一些*衡。接下来，我们看到赢家(“唯一幸存者”)拥有各种各样的人格类型，但可能倾向于 es 人格类型，特别是 ESTP 。“亚军”往往也有 ES 的部分，尽管有些人拥有 IS 的特征，特别是 ISFP。
联盟/投票团队模式
第一次尝试用一个简单的条形图来显示被淘汰的漂流者。
## Barplot ----
vote_history %>%
filter(season == 40) %>%
mutate(vote = vote %>% fct_reorder(order)) %>%
ggplot(aes(vote, fill = castaway)) +
geom_bar() +
facet_grid(.~episode) +
coord_flip() +
labs(title = 'Season 40 Voted out castaway',
#subtitle = '% are relative to the place-group only, e.g. Runner-up only, etc',
caption = 'created by Dror Berel') +
theme(axis.text.x = element_text(angle = 90))
图来源:作者
第一集展示了琥珀和娜塔莉，以及其他一些稀疏的漂流者之间的密切匹配。然后，接下来的几集没有那么多样的投票模式，也许在第六集丹尼斯和帕尔瓦蒂之间有一些额外的戏剧性时刻。
虽然上面的柱状图已经给出了一些关于哪些联盟一起投票的指示，但是下面的流程图显示了成对投票的模式。第一个仅针对第 1 集，随后是跨所有集的聚合。
图来源:作者
图来源:作者
拱门狭窄的漂流者在比赛初期就被淘汰了。在游戏中走得更远的幸存者有更长的拱门和更多的联盟。
你对特定的季节感兴趣吗？请继续关注另一篇全季全集可视化的博文。
用于可视化的 r 包: ggplot2 、circle circle、 tidyverse 。
查看我的其他博客文章和我的 GitHub 页面获得更多有趣的阅读。领英。
想象圆周率的美丽
柴坦尼亚电视台在 Unsplash 拍摄的照片
由圆周率的数字制成的各种静态和动态图像
注 1: 图形以高分辨率渲染，清晰可见。请给图形加载一些时间。
注 2: 这些图片的高分辨率 pdf 版本可以从www.pi.aqeel-anwar.com下载
注 3: 随着时间的推移，更多的可视化将被添加到本文中。
圆周率是圆的周长与直径的比率，是宇宙中最重要的数字之一。这是一个非-终止，非 - 重复小数，这意味着没有一组数字无休止地重复。利用谷歌云，Emma Haraku 将圆周率大部分位数的计算记录设定为 31.4 万亿。给你一个视角，一个人要花将* 100 年才能说出圆周率的这些数字。
在本文中，我们将尝试通过不同的动画和情节来可视化圆周率。
1.网格上的 Pi
网格上的圆周率从左到右、从上到下绘制大小相等的圆。圆圈的颜色表示从 0 到 9 的数字，如果数字是奇数，则表面颜色为空。下面的网格图描绘了圆周率的 100、400、2500 和 10，000 位数。
作者图片
作者图片
2.圆周率数字的随机游走
每个数字被分配一个等间距的角度(0-360 度)。对于每一个手指，行走以相等的步长在各自的方向上前进。
下图描绘了 100、500、1000 和 10，000 位数圆周率的变化。
作者图片
作者图片
作者图片
3.码头的环形人行道；
受 Martin Krzywinski 的启发，环形网络行走以环形模式绘制圆周率数字的行走。下图描绘了 100、1000、5000 和 10000 位数圆周率的变化。
作者图片
作者提供的视频
4.圆周率的概率直方图:
这个可视化显示了圆周率的前 n 位数字的分布。可以看出，数字 0 是最后出现的，而数字 3 是圆周率前 100 位中最占优势的。
作者图片
作者图片
总结:
一张图胜过千言万语，或者在这种情况下，一张图胜过数万位数。从上面看到的各种形象化，可以看出圆周率的数字中并没有隐藏着可观察的模式。随着位数的增加，不仅从 0 到 9 的所有数字的出现频率变得相等(概率直方图)，而且所有可能的 2 位数模式(11、12、…、19、21、22、…)的出现频率也变得相等(循环网络遍历)。
如果这篇文章对你有帮助，欢迎鼓掌、分享和回复。如果你想了解更多关于机器学习和数据科学的知识，请关注我@Aqeel an war或者在LinkedIn上与我联系。
可视化超参数对支持向量机的影响
直观地了解在支持向量机中使用不同的核函数和超参数时会发生什么
本文的目标是直观地查看 SVM 的每个超参数和核函数的效果，以了解它们对模型的影响。
首先简单介绍支持向量机，然后是数据集。就本项目而言，数据集是一个简单的数据集，只有两个特征，可以很容易地以二维方式可视化。数据集将分为训练数据集和验证数据集。并且，对于每个核函数，呈现了显示不同超参数的效果的可视化。
你可以在这个笔记本里找到的源代码。
目录
- 支持向量机简介
- 资料组
- 流行的内核函数
- 结论
- 感谢
支持向量机简介
支持向量机是用于分类(或回归)任务的监督机器学习模型。在二元分类的情况下，有一个由𝑛观测值组成的数据集，每个观测值由𝑑维数的向量𝑥𝑖和目标变量𝑦𝑖组成，目标变量可以是 1 或 1，这取决于观测值是属于一个类还是属于另一个类。
使用这些数据，SVM 学习超*面的参数，𝑤⋅𝑥−𝑏=0 将空间分成两部分:一部分用于一个类的观察值，另一部分用于另一个类。此外，在分隔两个类的所有可能的超参数中，SVM 学习分隔它们最大的超参数，即，在每个类和超*面之间留下尽可能多的距离/余量
两类训练的 SVM 的最大边缘超*面和边缘。边缘上的样本被称为支持向量，因为它们是定义超*面所需的唯一样本。
图片由拉赫玛姆提供，CC BY-SA 4.0<https://creativecommons.org/licenses/by-sa/4.0>，转自维基共享
为了学习超*面的参数，SVM 试图最大化观测值之间的间隔，并且附加约束是不同类别的观测值必须在超*面的不同侧。
本文不会详细讨论支持向量机如何获得这些参数背后的数学原理。然而，为了提供一些可能有用的直觉，有趣的是注意到当计算超*面的参数时，训练数据、 𝑥 将仅作为标量积的一部分出现。
由于这种观察，支持向量机可以利用所谓的核函数。这是一个函数，它返回两个向量之间的标量积，但不需要计算这些向量的坐标。这非常有用，因为我们可以模拟应用增加𝑥维度的操作，而不需要去更高维度，这在计算上更便宜(这被称为内核技巧)。
因此，支持向量机可以处理不可线性分离的数据。SVM 不再试图为数据拟合复杂的函数，而是进入数据可以线性分离的更高维度，并在那里找到分离数据的超*面(回到原始维度，它看起来不会像线性分离)。
因此，现在是时候说，支持向量机不计算超*面的参数，而是记住计算超*面所需的𝑥's，当新的输入数据到来时，支持向量机执行这些𝑥's(称为支持向量)和输入数据之间的标量积。同样，这是为了继续使用标量积并利用内核函数。
另一个要注意的有趣的事情是，在两个类之间找不到完美的分离是很常见的。这对于支持向量机是不利的，因为在训练(计算超*面参数)期间，它们试图最大化类别之间的间隔，并限制一个类别的观测值必须在超*面的一侧，而另一个类别的观测值必须在另一侧。为了有助于这一点，支持向量机有“软余量”，这是一个通过调节允许多少观察值通过余量来放松这一点的参数。
资料组
该数据集是对虹膜数据集的修改，只有两个维度，因此可以很容易地可视化。特别是，它由刚毛鸢尾和杂色鸢尾花的萼片长度和宽度组成。
下图显示了该数据集是如何划分为训练集和验证集的。此外，数据已经过预处理，具有*均值 0 和单位方差。这是一个很好的实践，因为支持向量机使用标量积，所以如果一个变量的值范围比其他变量大，它将支配标量积的结果。
作者图片
流行的内核函数
本节介绍四种最常见的核函数以及每个超参数对 SVM 结果的影响。
线性核函数
作者图片
这是最简单的核函数，因为它相当于不使用任何核函数。换句话说，它直接计算输入之间的标量积。它没有向 SVM 添加任何额外的超参数，并且可以很好地看到调节余量的超参数𝐶的效果。
接下来的图显示了在训练数据集上使用线性核训练 SVM 的结果
作者图片
背景色代表 SVM 的决定。训练数据集被表示为*面中的点，并且它们的类也用颜色表示。突出显示的点代表支持向量，即定义超*面的数据点。虚线代表 SVM 的边缘。在每个图的上方，您可以找到该 SVM 在验证数据集上的 R2 分数以及所用超参数的值。
如图所示，增加超参数 𝐶 的效果是使边缘更紧，因此，需要更少的支持向量来定义超*面。
RBF 核函数(径向基函数)
作者图片
该函数为调谐𝛾.增加了一个额外的超参数但是，与线性核函数的情况不同，该函数将数据映射到更高维度。从下图中可以看出，现在 SVM 可以表示非线性分离。
作者图片
从上到下，我们可以看到增加超参数𝐶的效果，如前所述，这会影响 SVM 的余量。
另一方面，从左到右，我们可以看到增加𝛾 的效果:较低的值导致分色看起来更线性，随着 𝛾 的增加，它导致更复杂的分色。
在𝛾足够高的情况下，训练集的每个观测值都是支持向量。换句话说，每个训练点都用于定义超*面，这表明明显的过拟合。此外，使用的支持向量越多，SVM 的计算开销就越大，并且它需要更多的时间来进行预测。
最后，有趣的是注意到，在数据的原始维度中观察分离，它看起来像高斯，就像核函数公式看起来像高斯一样。
Sigmoid 核函数
作者图片
在这个函数中有两个额外的超参数:𝑟和另一个也称为𝛾的超参数，正如下面可以看到的，它也影响分离的复杂性。
作者图片
现在，𝐶超参数已被修复，因为如上所示，它会影响边距。从上到下可以看到改变 𝛾 的效果，这有助于使分离变得更加复杂，因为它增加了，就像 RBF 核函数一样。
𝑟超参数变化不大，视觉效果不太清晰。但是看函数定义，tanh(γxi⋅xj + r)，这个常数 𝑟 的作用是移动双曲正切:
作者图片
𝑟常数的较大正值和负值支配着结果，这使得标量积更难对函数的结果产生影响。****
如果我们将标量积解释为两个向量之间相似性的度量，那么核函数也表示相似性。因此，我们可以把𝑟的这种效应解释为使结果有偏差，如果我们知道某个类比另一个类更受偏爱，这是很有用的？
多项式核函数
作者图片
这最后一个核函数有三个超参数:影响标量积的因子𝛾、常数𝑟和多项式的次数𝑑.
作者图片
从上到下可以看出，增加多项式次数和** 𝛾 的效果是进行更复杂的分离。**
从左到右可以看出，改变 𝑟 的效果看起来类似于 sigmoid 函数中的 𝑟 所发生的情况，至少对于多项式的较低次而言是如此。
结论
本文首先简要介绍了支持向量机，然后介绍了使用的数据集。然后，它显示了在原始数据的维度上，改变最常见的核函数的超参数的视觉效果。这些影响可以根据视觉直觉分为两类:它们影响 SVM 的边缘和/或它们影响分离的非线性。
通常建议使用 RBF 核作为“go-to”核函数，因为它只有两个超参数需要调整，并且可以模拟非线性分离。但是，正如许多事情一样，这可能不是任何任务的完美核函数，根据数据，可能有一个核函数可以更好地模拟类之间的分离。希望这篇文章给读者一种直觉，帮助他们选择要使用的核函数和/或更好地理解支持向量机🙂
感谢
特别感谢安吉尔·伊加丽塔在本文发表前审阅了本文😊
感谢您阅读本文！😄有反馈吗？非常感谢🙂请在这里的评论中，或者在笔记本上，甚至在 LinkedIn 上自由分享你的想法！
祝您愉快！🙂
可视化 MLP:变换的组合
如何绘制非线性决策边界
介绍
神经网络通常被视为从数据中“学习”的黑盒。但是他们的重量实际上在学习什么呢？简而言之，他们正在学习以特定的方式操作向量空间。虽然这不是一个新的想法，但它是一个核心概念，在我打算阐述的课程中经常被忽略。在本文中，我将关注多层感知器，并理解一个复杂的决策边界是如何从一系列转换中形成的。
基本向量
在深入研究神经网络操作之前，我们需要一本线性代数入门书。
作者图片
什么是基矢？
基向量是坐标空间中独立的单位向量。在上图中，有两个基本向量定义了我们的 2D *面:I 和 j。向量 I 的值为[1 0]，向量 j 的值为[0 1]。如上所述，*面上的所有其他矢量都可以表示为基本矢量的线性组合。这样，它们定义了坐标空间。
作者图片
让我们将两个基向量重新组织成一个矩阵，以加强这一想法，其中顶行包含向量 I，底行包含向量 j。如果我们取向量[3 ^ 2]和基向量矩阵的乘积，那么我们得到该向量在矩阵中的基向量所定义的坐标空间中的嵌入。虽然这听起来很抽象，但是通过下面的方式，这个想法是非常清晰的。
变换
为了更好地理解基向量如何定义坐标空间，让我们看看当我们改变基向量时会发生什么。
作者图片
向量 I 现在在[1 ^ 2]，向量 j 现在在[2 ^ 1]。在视频中，我们可以看到改变基向量如何通过线性变换来操纵坐标空间，这正是神经网络所做的。有关更深入的描述，请参见 3blue1brown 关于线性变换的视频。
线性图层
作者图片
现在我们已经掌握了一些线性代数的基础知识，让我们来看看一个基本的线性层。在这种情况下，所有输入神经元通过明显学习的权重连接到所有输出神经元。所以每个输出神经元就是输入向量和权重向量的点积。我们可以将权重向量组织成矩阵 W，然后与输入向量 x 相乘，而不是单独编写所有这些内容。在这里，我们可以将 W 视为基本向量的矩阵，我们已经看到了更改这些值会对坐标空间产生什么影响。
但是偏见有什么作用呢？
类似于直线的方程，这里的偏差移动原点。在上面的示例中，对上述变换应用了[1，1]偏差。
激活功能
作者图片
激活函数通常紧接在上述线性变换之后。在这里，我们将研究双曲正切函数，它独立作用于每个输出神经元。该函数将线性运算的输出从-1 限制到 1。
众所周知，非线性在神经网络中起着重要作用，尤其是在绘制决策边界方面。但是他们实际上是如何划分这些界限的呢？他们通过变换坐标空间来实现。在上面的视频中，我们可以看到双曲正切函数是如何扭曲坐标空间的。当需要收缩或扩展不同的区域时，这种类型的行为非常有益。稍后对整个网络的可视化将阐明这一点。
MLP 背后的直觉
既然我们已经介绍了线性图层的每个组件，那么多个图层如何一起工作呢？直观上，在 N 层的 MLP 中，前 N-1 层用于变换坐标空间，以使第 N 层更容易线性分离数据。我选择 MLP 作为基本案例来表达这个想法，因为它是最清晰的，但它可以很容易地显示其他运营商如何以不同的方式操纵坐标空间。
线性回归决策边界
我们已经了解了线性图层如何转换坐标空间，但现在让我们关注它如何绘制决策边界。Thomas Countz 在这里对单层感知器进行了详细的分析:
总而言之，最终线性层中的权重向量(对于给定的输出神经元)定义了与决策边界正交的超*面，并且从该超*面，我们可以得到决策边界的方程如下:
- b + w1x + w2y = 0
- x 截距= (0，-b / w2)
- y 轴截距= (-b / w1，0)
- m = -(b / w2) / (b / w1)
- y = (-(b / w2) / (b / w1))x + (-b / w2)
将它整合在一起
最后，我们可以充分了解 MLP 的运作。在上面的例子中，我们设想了一个四层的 MLP，每层分别有(2，2，2，1)个神经元。该网络在一个 2 类非线性可分螺旋数据集上进行训练，以突出显示该网络如何操纵原始坐标空间来使这两个类线性可分。
画好线后，通过反向操作将网络向后滚动到原始坐标空间。通过这个过程，我们可以看到潜在空间中的线是如何变成原始空间中的非线性决策边界的。
摘要
在这篇文章中，我简要介绍了从拓扑学的角度思考神经网络。我希望本教程对初学者有所启发，并且在设计新的架构时会更多地考虑组件的拓扑影响。
评论
本文旨在提供对神经网络如何运行的简化见解，因此我将这里省略的其他考虑留到以后的文章中。
所有的可视化都是通过开源软件 manim 的定制版本以编程方式产生的。
可视化美国石油管道网络
让我们用数据来理解殖民地管道在更大的美国石油产品管道网络中的作用。
美国主要的石油产品管道。来源:环评。图片来源:塞犍陀·维维克
最*殖民管道勒索软件网络攻击的影响遍及整个美国东南部。肇事者是一个著名的勒索软件组织，名为黑暗面，他们声称他们的目标从来不是扰乱社会:
“我们的目标是赚钱，而不是给社会制造问题。从今天起，我们引入了审核机制，并检查我们的合作伙伴想要加密的每家公司，以避免未来的社会后果。”
但是人们怀疑这是否完全正确。毕竟，黑暗面的总部设在俄罗斯，最*源于俄罗斯的网络安全管理软件产品网络攻击导致多个美国政府服务器被攻破。这一事件以及最*发生的其他事件表明，俄罗斯确实有兴趣破坏美国的网络，甚至是关键的基础设施网络，例如那些穿越美国大部分地区的燃料网络。
让我们更深入地了解一下美国石油产品管道网络。这将有助于理解殖民地管道的作用。此外，来自俄罗斯、朝鲜、伊朗和中国的民族国家网络攻击的增加意味着，未来美国可能面临有针对性的攻击的风险，其目的是最大限度地破坏社会秩序。在这种情况下，最好考虑关键基础设施中的漏洞，以便在网络攻击成功的情况下建立弹性。
可视化管道形状文件
import networkx as nx
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import re
import matplotlib.colors as mcolors
import geopandas as gpd
import contextily as ctxshapefile = gpd.read_file('./PetroleumProduct_Pipelines_US_EIA/PetroleumProduct_Pipelines_US_202001.shp')
shapefile2=shapefile[shapefile['geometry'].notnull()]shapefile3=shapefile2.to_crs(epsg=3857).sample(frac=1) #projecting to Spherical Mercator projection coordinate system for subsequent plotting on mapfig=plt.figure()
ax=shapefile3.plot(column='Shape_Leng', cmap='jet',linewidth=3,figsize=(32,16))
plt.axis('off')
ctx.add_basemap(ax)
美国主要的石油产品管道。来源: EIA 。图片来源:塞犍陀·维维克
我从 EIA 网站获取了美国主要石油产品管道的数据，并使用 Python GeoPandas 包加载了 shapefile。你可以看到暗红色的最大管道，这是殖民地管道。对 5 个最大管道的进一步观察证实了这一点。第二长的是从美国中西部到加拿大阿尔伯塔省的 Southern Lights 管道，第三长的是从路易斯安那到华盛顿特区的种植园管道，除了稍微短一点之外，几乎与殖民地管道相同。
5 条最大的石油产品管道|塞犍陀维维克
将 Shapefiles 转换为网络
#using shapely to convert geometry into string format
from shapely import wkt
shapefile2['str_geom'] = shapefile2.geometry.apply(lambda x: wkt.dumps(x))
net = nx.Graph()
nt=0for i in range(0,len(shapefile2)):
a=np.zeros(len(shapefile2['str_geom'][i].split())-1) #e.g. 4 points with 8 coordinates means a has 8 values
nt+=len(a)/2
for j in range (0,len(a)):
a[j]=float(re.findall(r"[-+]?\d*\.\d+|\d+", shapefile2['str_geom'][i].split()[j+1])[0])
for k in range(0, int(len(a)/2)-1):
net.add_edge((a[2*k],a[2*k+1]),(a[2*k+2],a[2*k+3]))positions = {n: (n[0], n[1]) for n in list(net.nodes)}fig, ax = plt.subplots(figsize=(16,8))
ax.tick_params(left=True, bottom=True, labelleft=True, labelbottom=True)
nx.draw(net, positions, ax=ax, node_size=20)
plt.tight_layout()
节点和边的石油产品管道网络|塞犍陀·维韦克
每个 shapefile 行包含管道中点的坐标。我将每个点表示为一个节点，并通过边连接这些点，通过边使用 NetworkX Python 包构建网络。现在我们有了网络，我们可以运行一些经典的网络算法来发现哪些节点或管道段对于整个管道网络是至关重要的。
中心性度量
在图论和网络分析中，中心性度量确定节点在整个网络中的相对重要性。我将使用介数中心性，它是网络中一个节点对信息流(T3)(或者在这种情况下，石油流)的影响的量。中间中心性度量如下所示:
中间中心性|维基百科
在等式中，分子是节点 s 和 t 之间通过节点 v 的最短路径的数量，分母是 s 和t之间所有最短路径的数量，求和是对所有节点对进行的。在我们的例子中，中间中心性应该给出在更大的网络中哪个管道段对石油运输最重要的感觉。
fig, ax = plt.subplots(figsize=(16,8))ax.tick_params(left=True, bottom=True, labelleft=True, labelbottom=True)
nodes = nx.draw_networkx_nodes(net, positions,ax=ax, node_size=20, cmap=plt.cm.jet,node_color=list(nx.betweenness_centrality(net).values()),nodelist=nx.betweenness_centrality(net).keys())edges = nx.draw_networkx_edges(net, positions,ax=ax)
plt.axis('off')
plt.title('Betweenness Centrality')
plt.colorbar(nodes)
plt.tight_layout()
石油产品管道网络，由中间中心值着色的节点|塞犍陀·维韦克
具有最高介数中心性的节点位于南卡罗来纳州的殖民地管道的中心。这让我感到惊讶，因为我原以为最重要的节点可能位于更靠*美国地理中心的地方
结论
Colonial 管道的绝对长度以及中间中心性指标都将 Colonial 管道视为美国石油产品管道网络中最重要的资产。一个更大的问题是攻击者如何最大限度地破坏社会秩序，比如一个民族国家的行为。那些后果会是什么？我们已经看到了殖民地管道勒索软件攻击后几周的天然气供应中断和价格上涨。如果多条这样的管道被关闭，情况会是怎样？我们如何建立社会对成功攻击的弹性？
我们可以通过多维数据源和灾难期间的点点滴滴来学习很多东西，以便在未来，我们作为一个社会有更好的准备。在殖民地管道网络攻击的案例中:管道网络、炼油厂和存储位置、运输供应链以及短缺加油站的位置可以帮助理解事件链。这一认识将使我们为未来的网络攻击做好更充分的准备。
总之——要让社会抵御网络攻击，还有很多事情要做。但我认为第一步在于量化复杂的社会对这种攻击的脆弱性。不幸的是(或者是故意的)——在 Colonial pipeline 事件中，数据明确显示，攻击关闭了整个美国石油产品管道网络中最重要的管道，导致几周的天然气短缺。
有兴趣的话，下面详细介绍一下带代码的 Google Colab 笔记本。
https://colab.research.google.com/drive/1FaK2wiUV_3MqJViGS1m-xQYPUXGG5EaT?usp=sharing 如果你喜欢这篇文章——我经常写复杂系统、物理学、数据科学和社会的界面
使用 Welly Python 库可视化井眼轨迹
使用 Matplotlib 创建 3D 线图以可视化井眼轨迹
显示从 Welly Python 库生成的井眼轨迹位置的 3D 线图。图片由作者提供。
测井中使用多个深度参考来表示沿井筒的位置。这些包括测量深度(MD)、真实垂直深度(TVD)、真实水下垂直深度(TVDSS)等。所有这些都是油井成功开发和完井的关键衡量标准。
显示 MD、TVD 和 TVDSS 之间差异的图示。图片来源:http://petroleum-companies . blogspot . com/2013/12/diffused-well-directional . html
上图展示了本文中提到的关键深度参考。
- 测量深度(MD)是沿井眼长度测量的井眼长度。
- 真实垂直深度(TVD)，是基准面(如转盘)和井筒中一点之间的绝对垂直距离。
- 海底真实垂直深度(TVDSS)，是*均海*面和井筒中某点之间的绝对垂直距离。
当井是垂直的时，MD 等于从同一基准面测量的 TVD。在井斜的情况下，TVD 值变得小于 MD 值。
大多数 LAS 文件都参考测量深度，通常不包含 TVD 曲线。因此，我们必须用一些数学来计算 TVD。为此，我们需要井的倾斜度，即井眼与垂直方向的偏差，我们还需要方位角，测量井眼轨迹相对于北方的方向。
在本文中，我们不会关注 TVD 背后的计算，相反，我们将了解如何使用 Welly 的位置模块来计算它。如果你想知道更多关于计算背后的数学知识，我在下面的描述中提供了一些文章的链接。
https://www.drillingformulas.com/minimum-curvature-method/
视频版教程
如果你喜欢跟随视频，你可以在我的 YouTube 频道找到它。
Python 教程
导入库和加载数据
让我们从导入将要使用的库开始。这些是来自 welly 图书馆和熊猫图书馆的位置和井模块。
from welly import Location
from welly import Well
import pandas as pd
一旦我们导入了这些，我们就可以加载数据了。本例中使用的数据来自北海的荷兰部分，可以在 NLOG 网站或我的 Github Repo 上找到。
data = Well.from_las('Netherlands Data/L05-15-Spliced.las')
检查数据
如果我们调用刚刚创建的data变量，我们可以得到油井的摘要。我们可以看到井的名称、位置以及文件中包含的数据信息。
使用 Python Welly 库生成的井的摘要(图片由作者提供)
如果我们想更仔细地查看数据，我们可以调用我们的 well 对象，后跟.data。这提供了一个包含曲线助记符以及前 3 行和后 3 行中包含的值的 dictionary 对象。不出所料，大部分数据都丢失了。
data.data{'BHT': Curve([nan, nan, nan, ..., nan, nan, nan]),
'CAL': Curve([nan, nan, nan, ..., nan, nan, nan]),
'CHT': Curve([nan, nan, nan, ..., nan, nan, nan]),
'CN': Curve([nan, nan, nan, ..., nan, nan, nan]),
'CNC': Curve([nan, nan, nan, ..., nan, nan, nan]),
'CNCQH': Curve([nan, nan, nan, ..., nan, nan, nan]),
'CNQH': Curve([nan, nan, nan, ..., nan, nan, nan]),
'GR': Curve([nan, nan, nan, ..., nan, nan, nan]),
'MBVI': Curve([nan, nan, nan, ..., nan, nan, nan]),
'MBVM': Curve([nan, nan, nan, ..., nan, nan, nan]),
'MCBW': Curve([nan, nan, nan, ..., nan, nan, nan]),
'MPHE': Curve([nan, nan, nan, ..., nan, nan, nan]),
'MPHS': Curve([nan, nan, nan, ..., nan, nan, nan]),
'MPRM': Curve([nan, nan, nan, ..., nan, nan, nan]),
'PEQH': Curve([nan, nan, nan, ..., nan, nan, nan]),
'PORZ': Curve([nan, nan, nan, ..., nan, nan, nan]),
'PORZC': Curve([nan, nan, nan, ..., nan, nan, nan]),
'TEN': Curve([nan, nan, nan, ..., nan, nan, nan]),
'TTEN': Curve([nan, nan, nan, ..., nan, nan, nan]),
'WTBH': Curve([ nan, nan, 87.943, ..., nan, nan, nan]),
'ZCORQH': Curve([nan, nan, nan, ..., nan, nan, nan]),
'ZDEN': Curve([nan, nan, nan, ..., nan, nan, nan]),
'ZDENQH': Curve([nan, nan, nan, ..., nan, nan, nan]),
'ZDNC': Curve([nan, nan, nan, ..., nan, nan, nan]),
'ZDNCQH': Curve([nan, nan, nan, ..., nan, nan, nan])}
理解数据内容的更好方法是查看测井曲线。我们可以通过调用data.plot并设置曲线范围的关键字参数来实现。我们可以生成一个从第一个测量值开始到最后一个测量值的图。
data.plot(extents='curves')
这将返回以下图。该图允许我们快速查看每个测井测量的内容及其特征，如果数据中存在大量曲线，则很难查看。
在本文中，我们不会对测井数据进行绘图，但是如果您感兴趣，请务必查看我在 welly 系列中的 YouTube 视频，在该视频中，我重点介绍了单井和多井的工作。
Welly 生成的显示井内容的测井图。图片由作者提供。
使用测量数据和 Welly
导入调查数据
现在我们已经加载了日志数据，我们可以开始加载调查数据了。
在钻井过程中，通常以不规则的间隔测量勘测数据。它给出了测量时测量深度(MD)、倾角(INC)和方位角(AZI)的快照。由此，我们可以计算出油井原点的真实垂直深度(TVD)、x 偏移和 y 偏移。
通常，数据以表格或 CSV 格式提供。要加载 CSV 数据，我们可以使用pd.read_csv()并传入文件的位置及其名称。
survey = pd.read_csv('Netherlands Data/L05-15-Survey.csv')
当我们调用调查对象时，我们看到返回了一个包含关键井位置信息的数据帧。
熊猫数据框中的井调查数据。图片由作者提供。
Welly 要求勘测数据包含测量的深度、倾斜度和方位角。这允许库计算 TVD、X 偏移和 Y 偏移。
我们可以通过调用调查数据框架并使用方括号传入所需列名的列表来对数据进行子集化。
survey_subset = survey[['MD', 'INC', 'AZI']]
当我们调用survey_subset时，我们得到下面的数据帧。
准备好要导入 Welly Python 库的测量数据。图片由作者提供。
向油井添加测量数据
从 CSV 文件中加载调查数据后，我们需要计算我们的位置参数。默认情况下， Welly 被设置为使用最小曲率法计算这些，这是最常见和最精确的方法。
有关此方法的更多信息，请访问https://petro wiki . SPE . org/Calculation _ methods _ for _ directional _ survey
要将测量数据添加到井中，我们可以调用以下内容
#Add deviation data to a well
data.location.add_deviation(survey_subset.values)
既然勘测数据已经加载到我们的 Welly well 对象中，我们可以调用data.location.position来查看数据。对于这个例子，我使用切片符号只返回数据的前 5 行。
#View first five rows of the data
data.location.position[:5]
返回的数组格式为:X 轴偏移量、Y 轴偏移量和 TVD。
array([[ 0\. , 0\. , 0\. ],
[ 0\. , 0\. , 89.3 ],
[ -0.6333253 , 0.8552655 , 142.08569704],
[ -1.59422229, 2.03112298, 170.14372544],
[ -3.19869524, 3.75201703, 197.74222054]])
我们可以通过分割数组将每个位置参数提取到变量中。这是通过使用方括号并使用冒号(:)后跟数组中的列来选择所有行来完成的。
x_loc = data.location.position[:,0]
y_loc = data.location.position[:,1]
z_loc = data.location.position[:,2]
如果我们调用 z_loc，它是我们的 TVD，我们得到下面的数组:
array([ 0\. , 89.3 , 142.08569704, 170.14372544,
197.74222054, 225.68858529, 254.17872844, 282.83986178,
311.3294853 , 339.82739229, 368.42706739, 396.92691062,
425.62638313, 454.22551155, 482.42473573, 511.12342097,
539.72042719, 568.21483874, 597.00539705, 625.8900492 ,
654.36614119, 683.22656973, 711.6691264 , 740.00649462,
767.54748074, 797.06893638, 825.36408467, 853.83548556,
882.30553194, 910.5784206 , 939.03148052, 967.35658945,
995.56380403, 1023.95695144, 1052.22740711, 1080.54668678,
1108.68959153, 1136.6589388 , 1164.87003188, 1192.91335907,
1220.78632672, 1248.71483434, 1276.69724251, 1304.38501765,
1332.02759325, 1359.48829109, 1386.59399864, 1413.47807554,
1440.51055639, 1467.37758752, 1494.27990524, 1521.15255355,
1547.94826077, 1574.81148851, 1601.67556214, 1628.46190115,
1655.38744119, 1682.77094459, 1709.94467279, 1737.02953371,
1764.09191195, 1791.3868565 , 1818.75450935, 1845.99897829,
1873.48895669, 1900.86728951, 1928.20315443, 1955.1719983 ,
1982.16522007, 2009.02433087, 2035.75920778, 2062.44460278,
2088.89113734, 2115.18715337, 2141.53399746, 2167.86835015,
2194.17601217, 2220.34087524, 2246.65950847, 2273.26101123,
2300.13882036, 2326.97261339, 2353.95042418, 2380.81977995,
2407.70173751, 2434.4676547 , 2460.90920154, 2472.20902514,
2498.66491934, 2525.74629926, 2553.35452297, 2579.86481719,
2606.67927736, 2634.67341768, 2663.73057678, 2690.48389425,
2716.3110963 , 2743.39559139, 2770.53319932, 2798.10117685,
2824.99473242, 2851.85337513, 2879.55133503, 2906.56976579,
2933.96384651, 2960.25680057, 2986.50202763, 3013.35506117,
3039.2427437 , 3065.81112303, 3078.05551274, 3096.92997476])
我们也可以通过调用data.location.tvd.来访问相同的数据
array([ 0\. , 89.3 , 142.08569704, 170.14372544,
197.74222054, 225.68858529, 254.17872844, 282.83986178,
311.3294853 , 339.82739229, 368.42706739, 396.92691062,
425.62638313, 454.22551155, 482.42473573, 511.12342097,
539.72042719, 568.21483874, 597.00539705, 625.8900492 ,
654.36614119, 683.22656973, 711.6691264 , 740.00649462,
767.54748074, 797.06893638, 825.36408467, 853.83548556,
882.30553194, 910.5784206 , 939.03148052, 967.35658945,
995.56380403, 1023.95695144, 1052.22740711, 1080.54668678,
1108.68959153, 1136.6589388 , 1164.87003188, 1192.91335907,
1220.78632672, 1248.71483434, 1276.69724251, 1304.38501765,
1332.02759325, 1359.48829109, 1386.59399864, 1413.47807554,
1440.51055639, 1467.37758752, 1494.27990524, 1521.15255355,
1547.94826077, 1574.81148851, 1601.67556214, 1628.46190115,
1655.38744119, 1682.77094459, 1709.94467279, 1737.02953371,
1764.09191195, 1791.3868565 , 1818.75450935, 1845.99897829,
1873.48895669, 1900.86728951, 1928.20315443, 1955.1719983 ,
1982.16522007, 2009.02433087, 2035.75920778, 2062.44460278,
2088.89113734, 2115.18715337, 2141.53399746, 2167.86835015,
2194.17601217, 2220.34087524, 2246.65950847, 2273.26101123,
2300.13882036, 2326.97261339, 2353.95042418, 2380.81977995,
2407.70173751, 2434.4676547 , 2460.90920154, 2472.20902514,
2498.66491934, 2525.74629926, 2553.35452297, 2579.86481719,
2606.67927736, 2634.67341768, 2663.73057678, 2690.48389425,
2716.3110963 , 2743.39559139, 2770.53319932, 2798.10117685,
2824.99473242, 2851.85337513, 2879.55133503, 2906.56976579,
2933.96384651, 2960.25680057, 2986.50202763, 3013.35506117,
3039.2427437 , 3065.81112303, 3078.05551274, 3096.92997476])
创建位置图
为了了解井的位置，我们可以看三幅图。
- x 偏移与 Y 偏移(地形图)
- x 偏移与 TVD
- y 偏移与 TVD
为了创建这些图，我们可以使用 matplotlib 并使用 subplot2grid 创建多个图。
import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(15,5))
ax1 = plt.subplot2grid(shape=(1,3), loc=(0,0))
ax2 = plt.subplot2grid(shape=(1,3), loc=(0,1))
ax3 = plt.subplot2grid(shape=(1,3), loc=(0,2))
ax1.plot(x_loc, y_loc, lw=3)
ax1.set_title('X Location vs Y Location')
ax2.plot(x_loc, z_loc, lw=3)
ax2.set_title('X Location vs TVD')
ax3.plot(y_loc, z_loc, lw=3)
ax3.set_title('Y Location vs TVD')Text(0.5, 1.0, 'Y Location vs TVD')
这将返回我们的三个井剖面图。
使用 matplotlib 和 Welly 生成的油井剖面。图片由作者提供。
请注意，这两个 TVD 图是颠倒的，我们将使用ax.invert_yaxis()进行排序。
为井的起点和终点添加标记
我们可以在图中添加标记，以显示井的起始位置(黑色方块)和结束位置(红星)。此外，我们将反转两个 TVD 图的 y 轴。
fig, ax = plt.subplots(figsize=(15,5))
ax1 = plt.subplot2grid(shape=(1,3), loc=(0,0))
ax2 = plt.subplot2grid(shape=(1,3), loc=(0,1))
ax3 = plt.subplot2grid(shape=(1,3), loc=(0,2))
ax1.plot(x_loc, y_loc, lw=3)
ax1.plot(x_loc[0], y_loc[0], marker='s', color='black', ms=8)
ax1.plot(x_loc[-1], y_loc[-1], marker='*', color='red', ms=8)
ax1.set_title('X Location vs Y Location')
ax2.plot(x_loc, z_loc, lw=3)
ax2.plot(x_loc[0], z_loc[0], marker='s', color='black', ms=8)
ax2.plot(x_loc[-1], z_loc[-1], marker='*', color='red', ms=8)
ax2.invert_yaxis()
ax2.set_title('X Location vs TVD')
ax3.plot(y_loc, z_loc, lw=3)
ax3.plot(y_loc[0], z_loc[0], marker='s', color='black', ms=8)
ax3.plot(y_loc[-1], z_loc[-1], marker='*', color='red', ms=8)
ax3.invert_yaxis()
ax3.set_title('Y Location vs TVD')Text(0.5, 1.0, 'Y Location vs TVD')
使用 matplotlib 和 Welly 生成的油井剖面。还标记了孔的开始(黑色方块)和结束(红星)位置。图片由作者提供。
与原始调查进行比较
幸运的是，我们有一个包含位置参数和 TVD 的测量文件，但情况可能并不总是如此。通过将数据添加到我们的图中，我们可以快速检查 Welly 计算的数据和 CSV 文件中包含的数据。
fig, ax = plt.subplots(figsize=(15,5))
ax1 = plt.subplot2grid(shape=(1,3), loc=(0,0))
ax2 = plt.subplot2grid(shape=(1,3), loc=(0,1))
ax3 = plt.subplot2grid(shape=(1,3), loc=(0,2))
ax1.plot(x_loc, y_loc, lw=7)
ax1.plot(x_loc[0], y_loc[0], marker='s', color='black', ms=8)
ax1.plot(survey['X-offset'], survey['Y-offset'])
ax1.plot(x_loc[-1], y_loc[-1], marker='*', color='red', ms=8)
ax1.set_title('X Location vs Y Location')
ax2.plot(x_loc, z_loc, lw=7)
ax2.plot(x_loc[0], z_loc[0], marker='s', color='black', ms=8)
ax2.plot(survey['X-offset'], survey['TVD'])
ax2.plot(x_loc[-1], z_loc[-1], marker='*', color='red', ms=8)
ax2.invert_yaxis()
ax2.set_title('X Location vs TVD')
ax3.plot(y_loc, z_loc, lw=7)
ax3.plot(y_loc[0], z_loc[0], marker='s', color='black', ms=8)
ax3.plot(survey['Y-offset'], survey['TVD'])
ax3.plot(y_loc[-1], z_loc[-1], marker='*', color='red', ms=8)
ax3.invert_yaxis()
ax3.set_title('X Location vs TVD')Text(0.5, 1.0, 'X Location vs TVD')
创建井眼轨迹的 3D 图
我们可以使用 matplotlib 以三维方式查看数据，而不是以二维方式查看数据。但首先，我们要计算连续的数据。这是通过使用location.trajectory()来完成的。这里我们可以提供一个数据，即地面井位的 UTM 坐标和一个垂直偏移。
如果我们看看 NLOG 网站上的下图，我们就有了油井的精确表面坐标
我们将在location.trajectory() 功能中使用交付的位置坐标。
# Create a trajectory of regularly sampled points
location_data = data.location.trajectory(datum=[589075.56, 5963534.91, 0], elev=False)xs = location_data[:,0]
ys = location_data[:,1]
zs = location_data[:,2]plt.plot(xs, ys)
plt.xlabel('X Location')
plt.ylabel('Y Location')
plt.ticklabel_format(style='plain')
plt.grid()
当我们运行此代码时，我们现在有了油井的地形图，这些值反映了油井的真实坐标。
使用参考基准面的 Welly Python 库创建的井眼轨迹计划。图片由作者提供。
创建 3D 绘图
现在，井位已经参考了基准面，我们可以继续绘制井眼轨迹了。不需要应用前面的步骤，您可以使用 x、y 和 z 位置进行查看
为了创建 3D 绘图，我们需要从mpl_toolkits.mplot3d导入 Axes3D，然后当我们需要启用 3D 绘图时，使用一个神奇的 Jupyter 命令:%matplotlib widget。
然后，我们创建图形并将投影设置为 3d，如下面的代码所示。
from mpl_toolkits.mplot3d import Axes3D# Enable 3D Ploting
%matplotlib widgetfig = plt.figure(figsize=(8, 8))
ax = plt.axes(projection='3d')
ax.plot3D(xs, ys, zs, lw=10)
ax.set_zlim(3000, 0)
ax.set_xlabel('X Location')
ax.set_ylabel('Y Location')
ax.set_zlabel('TVD')
plt.ticklabel_format(style='plain')
plt.show()
用 Welly 和 Matplotlib 创建的交互式 3D 井眼轨迹。图片由作者提供。
摘要
在这个简短的教程中，我们已经了解了如何将原始井测量数据与井井对象相结合，以及如何在*面图和侧视图中显示井井轨迹。我们还看到了如何使用 matplotlib 在 3D 中可视化井眼轨迹。这样，我们可以更好地了解井眼轨迹。
感谢阅读！
如果您觉得这篇文章有用，请随时查看我的其他文章，这些文章介绍了 Python 和测井数据的各个方面。你也可以在GitHub找到我在这篇文章和其他文章中使用的代码。
如果你想联系我，你可以在LinkedIn或者我的 网站 找到我。
有兴趣了解更多关于 python 和测井数据或岩石物理学的知识吗？跟我上 中 。
如果你喜欢阅读这些教程，并想支持我作为一名作家和创作者，那么请考虑报名成为一名媒体成员。一个月 5 美元，你就可以无限制地阅读数千篇各种主题的文章。如果您使用 我的链接 ，注册，我将为您赚取一小笔佣金，无需额外费用！
https://andymcdonaldgeo.medium.com/membership
使用 expert.ai 可视化文档的真实内容
关于如何使用 expert.ai NL API 检索和可视化文本文档中隐藏的相关数据的简短教程。
如果您曾经处理过文本数据集，您就会知道在数据集中检索中心信息、避免干扰或冗余是多么困难。如果你想训练你自己的模型，很多方法都可以得到很好的结果，但是这需要时间和资源。在下面的教程中，我们将探索如何使用 expert.ai NL API Python SDK 检索文本中的隐藏信息，这不需要模型训练，然后将结果可视化为可以添加到报告中的图表。
什么是 expert.ai NL API？
expert.ai 自然语言 API 是由 expert.ai 开发的服务，可用于轻松构建 NLP 应用程序。该库包括多种功能，如 NLP 管道(标记化、词汇化、词性标注、依存解析、句法解析、词义消歧)和即用型 IPTC 媒体主题分类器、地理分类和情感分析。命名实体识别(NER)也被执行，其中实体被链接到它们在公共知识库(例如，Wikidata、GeoNames、DBpedia)中的唯一标识。对于任何对自然语言处理感兴趣的人来说，expert.ai NL API 都是一个有用的工具，因为它易于使用并且提供了广泛的功能。该技术由 expert.ai 开发，该公司在提供语言解决方案方面拥有 20 多年的经验，这使得该 API 非常适合任何有兴趣构建业务就绪型解决方案的人。
第一步:安装 expert.ai NL API python SDK
在本教程中，我们将使用用于 expert.ai 自然语言 API 的 Python 客户端来为 Python 应用程序添加自然语言理解功能。
您可以使用pip来安装库:
$ pip install expertai-nlapi
建立
要使用 expert.ai NL API，您需要在 expert.ai 开发者门户上创建您的凭证。Python 客户端代码期望 expert.ai 开发人员帐户凭据作为环境变量可用:
- Linux:
**export** EAI_USERNAME**=**YOUR_USER
**export** EAI_PASSWORD**=**YOUR_PASSWORD
- Windows 操作系统
SET EAI_USERNAME**=**YOUR_USER
SET EAI_PASSWORD**=**YOUR_PASSWORD
您也可以在代码中定义它们:
**import** os
os.environ["EAI_USERNAME"] **=** YOUR_USER
os.environ["EAI_PASSWORD"] **=** YOUR_PASSWORD
第二步:关键要素
现在，我们可以在一组文档上使用开箱即用特性来检索它们的关键元素。
首先:导入库并初始化对象。
然后，设置文本和语言:
我们可以执行第一次分析，简单地看一下文档的内容。关键元素通过relevants分析获得，并在文档中被识别为主句、主要概念(称为“同步子”)、主要引理和相关主题:
expert.ai 引擎执行词义消歧，这要归功于一个专有的知识图，它存储了每种语言的所有概念。这有助于引擎理解文档中出现的概念。
注意概念和引理的不同。一个概念可以用一个或多个同义词来表示。例如，如果我们在文本中找到 home 和 house ，expert.ai 技术理解这两个词条具有相同的含义，并为它们分配概念的首选标签——在这种情况下将是 house 。
让我们看看在之前的文本中找到的最相关的概念，以及它们的相关性分数:
CONCEPT SCORE
startup company 42.59
Facebook Inc. 41.09
Springfield 14.89
American 1.1
我们可以对一组文档做同样的事情，为每个文档检索相关的概念，并将它们聚合起来:
然后，我们可以在条形图中显示结果，选择在我们的数据集中更常见的 20 个最常见的概念:
文档中 20 个最常见概念的条形图
第三步:文件分类
现在，我们将学习如何根据自然语言 API 提供的 IPTC 媒体主题分类法对文档进行分类。我们首先从一个示例文本开始，看看如何设置一切，然后在数据集上执行相同的操作。
我们现在可以请求根据 IPTC 媒体主题类别对之前的文本进行分类:
对于每个类别，我们可以在文本中看到其标签、唯一 ID 和频率 whitin:
CATEGORY IPTC ID FREQUENCY
Earnings 20000178 29.63
Social networking 20000769 21.95
通过数据集上的这一新功能，我们可以检索和收集文档中触发的所有 IPTC 媒体主题类别:
现在，在collection_of_categories中，我们找到了每一个 IPTC 媒体主题类别以及找到它的文档数量。我们现在可以看到数据集主题的标签云:
IPTC 媒体话题类词云
全部代码可在这里获得。
结论
借助 expert.ai 技术，可以轻松访问文本中隐藏的信息，如最重要的概念或它们描述的主题。正如我们所见，从安装到有意义数据的可视化只需要几分钟！
我们希望您喜欢本教程，并期待了解您使用 expert.ai NL API 执行的文本探索。
视觉上吸引人的进度条
使用 tqdm 在 python 中创建进度条
沃洛季米尔·赫里先科在 Unsplash 上的照片
当我们想要测量特定函数或代码块的进度时，进度条非常重要。它允许我们可视化我们的代码已经运行了多少，或者告诉我们在运行时代码中是否有错误。它还允许我们查看代码块的剩余执行时间。
我们可以在 python 中使用不同的 or 库创建进度条，其中之一就是 tqdm。这是一个开源的 python 库，用于创建视觉上吸引人的进度条。Tqdm 来源于一个阿拉伯语单词，意思是进步。它很容易创建进度条，并且可以将任何代码块包装在里面。
在本文中，我们将看到一些可以使用 tqdm 创建的基本进度条。
让我们开始吧…
安装所需的库
我们将从使用 pip 安装 tqdm 开始。下面给出的命令可以做到这一点。
pip install tqdm
导入所需的库
在这一步中，我们将导入创建进度条所需的库。在这篇文章中，我将向你展示如何使用 tqdm 和 tqdm_notebook 创建一个进度条。
创建进度条
在这一步中，我们将看到使用 tqdm 创建进度条是多么容易。
for i in tqdm(range(10)): time.sleep(0.5)
进度条(来源:作者)
同样，我们也可以使用 tqdm_notebook 创建一个进度条。
for i in tqdm_notebook(range(10)): time.sleep(0.5)
进度条(来源:作者)
当代码执行过程中出现错误或者我们不小心停止了它时，它看起来就像下面给出的图像。
错误(来源:作者)
类似地，您可以在任何函数、循环或代码块中添加进度条，并分析特定代码块的时间和进度。您也可以在创建 python 应用程序时使用它。
继续尝试不同的代码块，创建漂亮的进度条。如果您发现任何困难，请在回复部分告诉我。
本文是与皮尤什·英格尔合作完成的。
在你走之前
感谢 的阅读！如果你想与我取得联系，请随时通过 hmix13@gmail.com 联系我或我的 LinkedIn 个人资料 。可以查看我的Github*简介针对不同的数据科学项目和包教程。还有，随意探索* 我的简介 ，阅读我写过的与数据科学相关的不同文章。
增强 Git 工作流的重要命令
一些 git 提示和技巧来提高您的贡献和协作能力
作为一名软件工程师、设计师、开发人员，或者你选择的其他身份，你的工具包中最重要的一项是版本控制系统，特别是 git。
作为开发人员，git 是我们的保险单，也是协作的强大工具。但是，重要的是，除了简单的提交或推送之外，我们很多人都不知道自己到底在做什么。
但是请不要担心，我将带您快速浏览一些您在现实世界中会遇到的常见场景，以及一些帮助您应对这些场景的简单解决方案。
观众
对于那些已经理解 git 作为工作流的一部分的重要性并对提高他们的生产力感兴趣的用户来说，这篇文章将是最有帮助的。如果你对使用 Git 的好处感兴趣，我强烈建议为什么使用 Git 以及如何作为数据科学家使用 Git。
背景
我在这里分享的方法是在以下假设下运行的，但也可能适用于其他情况。
- 你和其他人一起工作。
- 您在一个从“主”存储库中派生出来的存储库上工作，而其他人从他们的派生中贡献出来。
- 你是唯一一个使用叉子的人。(极其重要:其中一些方法将改写历史。如果你在共享回购中搞乱了历史，这对你的合作伙伴来说可能是一件痛苦的事情。)
如何下载私人回购？(Github)
方案
你刚刚开始与一个新的组织合作，并且你很兴奋开始建立一些令人惊奇的东西。您尝试克隆存储库，但是哦，不——您遇到了一个小问题
fatal: repository 'https://github.com/user/project.git/' not found
那么，我们该如何度过这一关呢？
首先，您需要为 Github 设置一个个人访问令牌。您可以使用下面的链接找到相关说明。
现在您已经有了令牌，您可以运行以下命令来克隆 repo。
git clone https://<TOKEN>@github.com/<USERNAME>/<REPO>.git
准备好开始贡献吧！
如何使分叉回购中的分支与原始回购中的分支完全匹配？
方案
假设我们有一个名为 dev 的分支。在这个场景中， dev 是主要的分支，贡献者在这里合并来自原始 repo 的变更。因此，您希望将分叉回购中的本地 dev 分支与原始回购中的 dev 分支上的最新变更同步。
好的，这是一个相当简单的方法，如果你在一个快速发展的团队中，你会发现自己每天都在使用它。
首先，您需要确保获取最新的更改。
git fetch upstream/dev
此后，您可以硬重置本地分支，以匹配上游分支的状态。
git reset --hard upstream/dev
完全匹配。
怎么取别人的 PR(拉取请求)？
方案
您的开发伙伴对代码做了一个小而重要的更改，从他们的 repo 向主 repo 提交了一个 PR，并希望您帮助测试这些更改。所以你需要在你的机器上获得他们的代码，这样你就可以在本地测试它。
这是你怎么做的！
git fetch upstream pull/ID/head:#username
这里的 ID 是拉请求的 ID，而#username 是您试图获取其代码的开发人员的用户名。例如，假设您的好友 JaneSmith 希望您查看他们的 PR，该命令如下所示:
git fetch upstream pull/1234/head:#JaneSmith
附加信息:在 上面的命令中，“上游”.) 是指分叉回购发起的回购。
这将使分支机构，他们的公关是提供给你本地，所有你要做的下一步是检查他们的分支机构。
git checkout #JaneSmith
瞧啊。现在，您可以在本地测试它们的更改。
更新(2022 年 10 月): 不必在分支机构名称前加标签，实际上名称是任意的，你可以随意命名。
如何从分支的历史记录中删除特定的提交？
方案
您刚刚修复了一个 bug，发布了代码，创建了 PR。您去检查您的变更，但是，您注意到其中有一些来自您以前工作的分支的代码没有被批准，您需要将它从这个分支中取出来。
这是你需要做的。
首先，您需要包含不需要的更改的提交散列。您可以使用下面的命令找到它。
git log
找到散列后，可以运行下面的命令将其从分支的历史记录中删除。
git rebase --onto <commit-id>^ <commit-id>
太好了，现在你已经摆脱了那些讨厌的不想要的变化！
接下来，由于您删除了提交，本地分支的历史记录将不再与远程分支的历史记录相匹配。要解决此问题，您必须强制推送以覆盖遥控器的历史记录。
git push -f
太好了，现在你的公关准备好了！
如果你做到了这一步，首先，感谢你的阅读。
作为开发人员，git 是一个至关重要的工具，它使我们能够以很小的摩擦进行协作，并轻松地修复我们破坏的东西。我分享了这些具体的情况，因为它们是我经常遇到的问题，我发现自己在谷歌上搜索。我发现这些简单的命令对我的工作效率是不可或缺的，我希望你也能把它们添加到你的工具箱中！
生命体征:评估数据健康状况和处理异常值
你的数据准备好机器学习了吗？检查它的健康状况，并学习如何处理您可能发现的异常值
杰西·奥里科在 Unsplash 上的照片
在医生的办公室，在医生到达之前，你和医疗助理要经历一个熟悉的例行程序。他们会检查你的生命体征——脉搏、血压、呼吸率等——并收集一些一般信息。这些步骤总结了你健康的一些重要方面，让医生直接进入更复杂的分析。
现在包含在 Alteryx 智能套件中的数据健康工具，为您的数据做类似的事情。它为您提供了对数据集进一步分析准备情况的快速而全面的评估，尤其是在预测分析和机器学习之前。该工具还会查找异常值，并方便地将它们放在单独的输出中，以便您可以处理它们。
让我们看看使用这些新诊断能力的最佳方式，以及如何对结果采取行动，尤其是那些异常值。
关于数据健康工具
数据健康工具收集数据集的“生命体征”,揭示数据集是否已准备好产生可靠、准确的见解，或者它是否会受益于一些特殊处理。具体来说，该工具可以查看数据集的缺失值、是否有异常值及其稀疏度。(如果数据集包含许多零值，则它是“稀疏的”；例如，许多购物推荐系统使用的数据集是稀疏的，因为每个购物者都没有购买过甚至没有看过许多提供的产品。)Data Health 还检查每个变量的唯一值的数量对于其数据类型和数据集的大小是否有意义。
图像通过 GIPHY
如果您是数据调查工具面板的粉丝，您可能想知道数据健康与字段汇总工具有何不同。您从这两种工具中确实获得了一些相同的信息；然而，值得注意的是，正如 Alteryx 数据科学产品经理 Sonia Prakasam 最*告诉我的那样，数据健康提供了“对数据集质量的整体衡量”。“数据健康产生更具可操作性的结果。在任何机器学习过程之前使用它来帮助为机器学习管道准备数据非常好。”
Data Health 还会为您检测和识别异常值，而 Field Summary 不会这样做。我们一会儿将讨论这个问题——包括一旦你将这些离群值收集起来，该如何处理它们。
在使用数据健康之前，最好使用要素类型工具来确保您的数据类型设置正确，否则您可能会得到不同的结果。数据健康可以处理字符串、布尔和数字数据；特征类型允许您为每一列设置更详细的类型(例如，邮政编码、文本、分类等)。).Data Health 了解如何处理每一种类型，如果提供额外的信息，它将提供更好的运行状况评估。
诊断异常值
除了所有其他可操作的信息之外，拥有一个工具来快速发现可能给分析和建模带来挑战的异常值是非常棒的。数据健康工具使用 2008 年同行评审研究中建立的方法(在此阅读)。它基于一种你可能听说过的数据可视化方法:盒状图或盒须图。
图片由Schlurcher，维基共享
下面是对阅读这些情节的复习.)。我们主要对代表异常值的点感兴趣。我们如何知道哪些数据点应该被定义为异常值，并显示为那些孤独的小点？当数据失真时，这种识别也变得更加棘手。一些识别异常值的方法假设您将拥有一个良好的、正态分布的数据集，但事实可能并非如此。
图片 via GIPHY
不管您的数据分布看起来如何，Data Health 识别异常值的方法已经涵盖了您。它基于一种叫做“ medcouple 的偏斜度测量方法该度量用于调整箱线图的结构。这种方法避免了不必要地将数据点标记为异常值，因为它们实际上相当接*数据分布的中心。正如研究人员解释的那样，“这使得调整后的箱线图成为自动异常值检测的有趣而快速的工具，而无需对数据的分布做出任何假设。”
在没有自动化工具的情况下寻找异常值有点复杂。Designer 中的一些选项在本线程中讨论。您可以尝试使用 Python 和 pandas，如这里的所解释的那样，计算每一列中的值的 z 值，然后潜在地消除在一列或多列中包含异常值的行。另一个 Python 选项是使用本地离群因子，sklearn 中提供的。这种方法在此处演示并在下图中显示，它基于k-最*邻点，并根据一个数据点相对于其周围邻域的孤立度来确定该数据点是否为异常值。可怜的孤独的局外人！
每个带有局部异常值因子的数据点用红色圆圈的直径显示。图来自 scikit-learn 示例。
所以我有离群值…有什么治疗方法？
首先，仔细看看你的异常值:
- 它们真的很稀有吗？不应该有很多古怪的价值观。如果有，你可能有其他问题要解决。
- 会不会是错别字？也许那些值可以被修正。
- 会不会有测量误差？例如，在某些情况下，传感器可能会错误地记录数据。
- 异常值是如何出现的，有什么模式吗？也许它们与另一个变量的特定值同时出现。这可能是一个重要的观察模式。
- 你的样本中是否有值得进一步研究的不寻常的人或事？异常值可能是一个线索，表明有一个全新的领域需要研究。
- 如果你的样本量很小:你的异常值可能只是出现在分布末端的前几个数据点吗？如果你收集了更多的数据，你会有更多的数据点吗？这种可能性可能很难确定，但这些异常值可能只是随着进一步的数据收集而出现的额外数据的暗示。
这次考试将决定你下一步的行动。表面上，处理异常值的方法很简单:忽略它们，删除它们，或者修改它们。您的选择可能部分取决于您对数据的计划。如果您正在进行探索性的数据分析和生成可视化，离群值可能是新奇的和/或讨论的开始，所以让它们留在原处可能不是问题。您可能希望在有异常值和无异常值的情况下运行分析，以查看您的结果有何不同。
如果您有大量数据，简单地删除异常值可能没问题。这种删除有时被称为“修剪”您的数据。通常，您会从数据中删除相同百分比的最高值和最低值。请将此视为修剪数据钟形曲线的尾部。但是，您正在非常显著地修改您的数据，这可能会引发所有的问题，并且您希望对这种方法有一个很好的理由。
修整异常值
修改你的异常值是另一个策略。离群值肯定会影响机器学习模型，有些影响更大。然而，您可能希望保留在训练模型时必须使用的每一点数据。您可以考虑以下几种修改方法:
- 转换:对数、*方根或逆转换有时会在预处理中使用，以减少数据的偏斜度(即，使其看起来更像正态分布)并减少异常值的潜在影响。Designer 公式工具中的 LOG(x)函数可以帮助进行对数转换。
- 裁剪，又名 winsorization :这个方法对变量可以拥有的值进行限制。例如，数据的 90% winsorization 将取前 10%和后 10%的值，并分别用第 90 百分位和第 10 百分位的值替换它们。与修剪相反，你没有删除数据点；您正在用更接*数据其余部分的值替换曲线两端最远的值(以前的异常值)。
裁剪或 winsorization 用更多的中心值替换离群值
均值或中值替换:一些参考文献建议用变量的均值或中值替换异常值，假设仅用非异常值计算。这可能不是一个好主意，因为在这个讨论中阐述了的许多原因。
有了数据健康工具，一旦您的异常值被识别出来，如何处理它们就取决于您了。您可以在工具的第三个输出锚点中找到它们，并进一步查看它们。您可以添加一个字段，将它们标记为异常值，并将它们连接回您的主数据集。您可以绘制数据并使用该标志标记异常值，方法是使用不同的颜色来标识异常值(例如，在散点图上)，或者使用数据调查工具来进一步探究这些异常值及其与其他变量的关系。您还可以将异常值输出连接到主数据源，然后从您的分析中排除异常值。无论你选择做什么，记住上面的警告。
总的来说，数据健康工具为分析和机器学习提供了对数据质量和就绪性的快速和极其有用的洞察。在它的帮助下，您可以自信地快速进入下一步，因为您已经查看了数据集的关键生命体征。
附加阅读
- 为什么离群值对科学有好处(还有其他领域！)
- 40 年的箱型电影，作者:哈德利·威克姆和丽莎·斯特莱杰斯基
- 关于 Winsorization 和 Trimming 的一些观察
原载于 Alteryx 社区 数据科学门户 。
用 Python 通过三个简单的步骤实现 VLOOKUP
通常，在数据分析领域，数据清理和处理需要花费最多的时间和精力。虽然与模型开发等更有趣的部分相比，数据清理、过滤和预处理等步骤通常被低估或忽略，但决定输出质量的是数据质量。正如正确的说法，垃圾输入=垃圾输出，反之亦然。
在 Excel 中，VLOOKUP、HLOOKUP、xlookup 和 INDEX MATCH 等函数对于从数据表或区域中查找满足给定条件的所需数据非常有用。在本文中，我将描述一种简单的方法，用 Python 通过三个简单的步骤复制 Excel 的 VLOOKUP 函数。本文使用的脚本可以在这个 GitHub 资源库中获得。让我们开始吧。
图片来自 Unsplash 作者 Jonnelle Yancovic
数据
首先，我将描述我们在这篇文章中使用的数据。
世界银行开放数据是一个关于全球发展的免费和开放的数据来源。人们可以从世界银行的数据库中找到数百个与全球发展相关主题的数据集，包括经济、人口、气候变化、卫生、基础设施、能源等。分析这些指标的时间序列数据对于制定适合一个国家或地区的政策、制度和监管框架至关重要。
世界银行的数据可以以 Excel 或 CSV 格式直接从数据库中下载，也可以使用pandas_datareader从 Python 中直接访问，如下面的脚本所示:
在这篇文章中，我将使用特定国家特定年份的选择性指标。我从世界银行数据库中选择了国内生产总值、人均国内生产总值、电力供应、人口和二氧化碳排放数据，并提供了这些指标的代码，这些数据也可以从网站上获得。接下来，我通过提供 ISO 代码随机选择了 12 个国家，并下载了 2018 年的数据。我用指标名称而不是代码来重命名列，并且只选择索引中的国家。数据帧df如下所示:
2018 年选自世界银行数据库的发展指标
Excel 中的 VLOOKUP 实现
在这一节中，我将描述 VLOOKUP 函数如何在 Excel 中从数据表或数据区域中获取所需的数据子集。如下面的 Excel 截图所示，A 到 F 列表示与df中相同的数据。在 I 到 L 列中，我想从第一个表中获得二氧化碳排放量和人口数据。
在 Excel 中实现的 VLOOKUP 函数在右边的表(I1:L6)中从左边的表(A1:F13)中获取值
在 Excel 屏幕截图中用红色矩形表示的公式栏中，我们可以看到用于单元格 J2 的公式。
=VLOOKUP($I2, $A$1:$F$13,6,FALSE) * 1000
其中，
$I2代表我们要在第一个表中查找的国家不丹；
$A$1:$F$13表示整个第一个表，在该表中可以找到查找值和要返回的数据
6代表栏号(此处代表 kt CO2 栏),将从该栏返回相应的数值(不丹),以及
FALSE表示完全匹配。
用 Python 实现它的三个简单步骤
在这里，我描述了上面在 Excel 中使用的相同函数的实现，但是用 Python 分三个简单的步骤:
首先，我们创建一个名为df_target的数据帧，我们希望在其中包含所需的子集数据。最初，数据框架包括五个所需国家的名称。然后我们为想要从df返回的指标CO2 emissions (tonnes)和Population创建空列。
第一步
df_target中的countries列与df中的country列共用。因此，其次，我们将df_target中的countries列设置为索引。
第二步
第三步，这是我们将df_target中的索引映射到df以获取所需列的数据作为输出的主要步骤。例如，df的kt CO2列的值乘以 1000 后返回给df_target的CO2 emissions (tonnes)列。 map()函数根据输入对应关系映射系列的值，并用于将系列中的每个值替换为另一个值，该值可从函数、字典或系列中提取。
第三步
在本文中，我们学习了一种简单的技术，用 Python 通过三个简单的步骤实现 Excel 的 VLOOKUP 函数。Python 中不同包的功能和模块使得几个步骤自动化，否则将花费大量的时间和精力，从这个意义上说，这是优化成本和资源的真正福音。
语音分类使用深度学习，用 Python
Jukka Aalho 在 Unsplash 上拍摄的照片
以下是如何使用深度学习对音轨的声音进行分类
有时人类能够非常容易地做某些事情，但是他们不能恰当地描述他们是如何做的。例如，当两个不同的声音说话时，我们能够清楚地区分它们，但很难描述我们用来区分它们的确切特征。由于任务很难描述，教计算机如何做就更难了。幸运的是，我们有数据，我们可以用这些例子来训练我们的机器。
我们开始吧！
1.设置
如题，我用过 Python 。特别是，我使用了这些库:
我们将在此过程中使用它们。
2.数据集
我用了第一场美国 2020 年总统辩论的前 30 分钟。具体来说，任务是区分三种声音:
- 克里斯·华莱士(主持人)
- (前任)总统唐纳德·特朗普
- (前任)副总统乔拜登
音频可以在这里找到。特别是，你有一个. csv 文件，一步一步地描述所有的争论。然后，你有一个. mp3 文件，这是辩论的音频。我对它进行了裁剪，得到了一个 30 分钟的音频(为了让过程更快)，并将其命名为“ trimmed.mp3 ”。然后我做了音频的梅尔频谱图。很多人比我解释得更好(例如)，但是你可以认为 MEL 频谱图是音频信号的频率表示，它被转换以更接*我们对声音的感知。最终结果如下:
因此，信号基本上有 20 个频率。采样率为 22010 Hz，因此，可以使用代码提取时间向量
现在，由于已经使用了监督学习方法，是时候使用。csv 文件。特别是，它由三列组成:
- 演讲者(华莱士、拜登或特朗普)
- 结束分钟(分:秒或小时:分:秒)
- 演讲
因为我们有以秒为单位的时间，所以我们将结束分钟转换为秒:
现在我们完成了。
尽管如此，它是关于整个演讲，而正如已经说过的，音频较短。由于这个原因，数据集的一部分也被取走了。
让我们来看看:
现在可以轻松地将音频数据转换成熊猫数据帧:
开始了。所以现在我们有 20 列 X 74200+行…非常大。为此，已执行****主成分分析(PCA)缩减:
****现在，我们要合并。带有 pca_data 数据帧的 csv 文件。为了做到这一点，我们定义了另一个列，告诉你，对于那个特定的点，说话者:
现在，我们来看看。****
因为这是可以预测的，所以有必要查看时间序列以了解正在发生的事情。为了简单起见，让我们使用互信息来选择最具信息性的特征，并从中提取出一个时间序列。
信息量最大的是 2 组分。
事情是这样的:
使用 LabelEncoder():
定义字典:
3。深度学习
现在我们已经有了我们需要的一切，我们来谈谈深度学习。虽然众所周知，卷积神经网络对图像非常有效，但很少有人知道它们对时间序列也很有效。其实我们会用一个 CNN 来区分三种声音。****
让我们使用一个训练测试分割并混合数据:
定义模型:
训练模型:
评估模型:
该模型以 softmax 结尾。这意味着我们基本上获得了特朗普、拜登或华莱士发言的概率。这里有一个例子:
让我们来探索一下测试集:
结果如下:
****正如可能看到的，当他们实际说话时，概率很高，这是一个好迹象！此外，如果我们直接评估准确性，我们是严格的，因为该算法在几分之一秒内工作，而人类语音不能变化如此之快(例如，强制预测不变，直到某个时间增量被验证，这可能是一个好主意)。
尽管如此，让我们严肃一会儿，让我们画出困惑矩阵:
和分类报告:
所以我们有 68%的准确率。
摘要
简而言之，已经开展的进程如下:
- 获取音频数据，修整并应用 MEL 频谱图
- 使用主成分分析降低维数
- 使用。标记音频数据的 csv 数据
- 定义深度学习 CNN 模型
- 得到结果
如果你喜欢这篇文章，你想知道更多关于机器学习的知识，或者你只是想问我一些你可以问的问题:
A.在 Linkedin 上关注我，我在那里发布我所有的故事
B .订阅我的 简讯 。这会让你了解新的故事，并给你机会发短信给我，让我收到你所有的更正或疑问。
C .成为 推荐会员 ，这样你就不会有任何“本月最大故事数”，你可以阅读我(以及数千名其他机器学习和数据科学顶级作家)写的任何关于最新可用技术的文章。
VoxMorphia:使用人工智能进行歌词风格转换
我如何使用 GPT-3 重新想象鲍勃·马利、电台司令和梅根·赛恩风格的经典歌曲
鲍勃·马利作者埃迪·马林，电台司令汤姆·约克作者克里斯、和梅根·赛恩作者阿尔弗雷德·马罗奎因，作者图片说明，来源图片来自commons.wikimedia.org经 2.0 许可在 CC 下使用
OpenAI 的第三代转换器 GPT-3 是目前最先进的文本生成模型[1]。只要给出几个例子，它就可以创建高质量的文本。我想看看能否提示系统采用一位作家的写作风格，并将其转移到另一位作家的作品中。
在这个我称之为 VoxMorphia 的实验中，我选择了转换公共领域的歌曲，包括像“是的，先生，那是我的宝贝”这样的经典歌曲。使用 GPT-3 和一些额外的开源项目，我将经典歌曲的歌词改编成鲍勃·马利、来自电台司令的汤姆·约克、梅根·赛恩和其他 43 位歌曲作者的抒情风格。
我选择突出这三位录音艺术家，以展示一系列风格:鲍勃·马利在复古雷鬼节奏中流畅的旋律线条，汤姆·约克在复杂的另类摇滚模式中充满焦虑的漫谈，以及梅根·赛恩在甜美的嘻哈节拍中巧妙而露骨的说唱。
概观
我将首先展示主要系统组件是如何连接在一起的，然后介绍 GPT-3 是什么以及它是如何工作的。接下来，我将介绍我用来转换歌词风格的过程，并展示一首具有三种不同歌词风格的歌曲的样本输出。
在附录中，我将展示三首不同风格的不同歌曲的较长示例。
这个项目的源代码可以在 GitHub 上获得，你可以使用这个 Google Colab 来试验代码。请注意，您需要一个来自 OpenAI 的帐户来运行代码。你可以加入等候名单，进入他们的测试程序这里。
系统组件
这个项目的主要工作是由 GPT-3 生成歌词，谷歌的通用句子编码器[2]帮助对文本进行预处理和后处理。
以下是该系统的组成部分及其工作原理的示例。
VoxMorphia 组件图，图片作者
该系统首先对 Kaggle 数据库中的歌词和一首老歌进行预处理，例如，Gus Kahn 1925 年的“是的，先生，那是我的宝贝”。Google 的通用句子编码器用于从目标歌曲作者(例如 Bob Marley)中查找紧密匹配的旧歌词和新歌词对。这些配对被添加到一个提示中，作为商业服务运行的 GPT-3 的输入。该提示包含三个用简单英语编写的部分:说明、前/后示例和输入文本。您可以在上面生成的提示块中看到一个例子。
在被提示后，GPT-3 以鲍勃·马利的风格返回“是的，先生”的五个候选歌词行。再次使用通用句子编码器来选择最佳候选。理想情况下，新歌词将(A)抓住原始歌词的精髓，但(B)不完全相同，(C)不会相差太远。
在我进入 VoxMorphia 的细节之前，我将介绍 GPT-3 的简短历史和概述，并展示它是如何工作的。
GPT 模型的大小(对数标度)随着时间的推移，大约每六个月就会增加 10 倍，图表由作者绘制
GPT 三号背景
在使用更大的变压器模型进行自然语言处理(NLP)之前，人工智能模型被训练来执行特定的任务，如文本分类、回答问题、创建摘要等。
GPT 一号
2018 年 6 月，OpenAI 发布了其初始生成式预训练变压器(GPT)，其神经网络规模为 1.17 亿个参数。它接受了 7000 本未出版书籍的训练[3]。该系统可以执行一般的 NLP 任务，而不需要太多的预先训练。
GPT-2
2019 年 2 月，OpenAI 发布了拥有 15 亿个参数的 GPT-2。它在 800 万个网页上进行了训练，并成为许多自然语言任务的最先进的系统[4]。我在我的 PlotJam 和 InventorBot 项目中使用了 GPT-2。
GPT-3
2020 年 6 月，OpenAI 发布了 GPT-3 的测试版。它使用 29 亿个网页进行训练，拥有 1750 亿个参数[1]。作为参考，一个典型的人脑大约有 1000 亿个神经元[5]。正如我们在波斯顿所说，GPT 三号是“邪恶的史迈特”
缺德斯迈特到底有多聪明？当我被邀请参加 OpenAI 的测试程序时，我做的第一件事是对我为我的 AI-8 Ball 项目所做的事情进行一个快速测试，以神奇 8 球的方式回答是/否问题。
我登录 OpenAI 的 playground 运行测试，用粗体键入以下提示，GPT-3 回答了。
GPT 3 号游乐场由 OpenAI 拍摄，图片由作者提供
文本提示
与其他生成文本的人工智能模型不同，OpenAI 目前不允许微调 GPT-3。但是，它允许您用英语告诉转换器做什么，并在提供输入文本之前提供几个例子。这称为“少量”学习，通过提供文本提示来完成。
从示例中，您可以看到提示的三个部分:说明、前/后示例和文本输入。这是上例中的提示，部分用括号标注。
The following are questions with yes/no answers in the style of the Magic 8-Ball. **(Instructions)**Is the sky blue?
Yes. It is certain. **(Example 1)**
###
Will I win the lottery?
No. Don’t count on it **(Example 2)**
###
Can a computer beat a grandmaster chess player? **(Text Input)**
然后，系统将为文本输入中的问题写下答案。
Yes. Ask Garry. **(Response Created by GPT-3)**
爆笑！它没有完全做到我想要的，因为它没有使用魔术 8 球的标准答案之一。但是它很好地提到了加里·卡斯帕罗夫，他在 1997 年输给了 IBM 的深蓝电脑。
控制参数
上面操场的截图显示了控制生成文本的参数集。这里是我使用的设置的每个参数的简要描述。
- 引擎 -要使用的 AI 模型。达芬奇型号 175B 参数能力最强， Ada 最快 2.7B 参数。居里和巴氏合金型号介于两者之间分别为 13B 和 6.7B 参数。我为这个项目使用了 达芬奇 模型。
- 响应长度 -要生成的最大文本量，用令牌指定。令牌大致相当于单词中的一个音节。对于上面的示例，提示中有 62 个标记，结果中有 8 个标记。对于 8 球问题，我将响应长度设置为 64，对于生成歌词，我将设置为 128 。
- 温度 -控制响应的变化，范围从 0.0 到 1.0。默认是 0.7，但是我用了 0.8 。
- 顶部 P -控制输出的多样性。我一直盯住 1.0 。
- 频率惩罚 -在响应中避免重复的程度。我将此设置为 0.25 。
- 存在惩罚 -控制在生成的文本中改变主题的能力。我将此设置为 0.75 。
- 之最——在服务器端生成多少响应。如果设置为大于 1，那么 GPT-3 将只发送最好的一个。我把这个设置保持为 1 。
请注意，温度和 Top P 参数是相似的。将它们移向 0，结果会变得乏味且可预测，将它们移向 1，结果会变得更加随机。你可以在 Ben Mann 的文章这里中了解这些参数是如何工作的。
频率和出席惩罚也是相似的。弗拉德·亚历克斯在他的帖子中实验了这些参数。他发现增加频率惩罚会导致与先前生成的文本产生新的偏差。并且增加存在惩罚允许 GPT-3 将新主题插入文本。
定价
正如我上面提到的，OpenAI 提供 GPT 3 作为商业服务。当我注册测试版时，他们给了我 30 万个免费代币，4 个月后到期。我在两个月内用完了免费代币，现在为使用达芬奇模型支付每 1000 个代币 0.06 美元。上述 8 球的例子总共使用了 70 个代币，总成本为 0.004 美元，约为 0.5 美分。其他车型的费率计划在这里，beta.openai.com/pricing。运行模型的成本基于它们的大小。参数越多=成本越高。
体视吗啡系统详情
在这一节中，我将介绍 VoxMorphia 使用的过程，并解释系统组件是如何工作的。
创建提示
我不想自己为转换歌词风格创建自定义提示，所以我设计了一个自动完成这项工作的方法。下面是一个样式转换提示示例，包含三个部分:指令、前/后示例和要转换的输入行。
说明
这是我给 GPT 3 号的指令。
Rewrite the song "Yes Sir, That's My Baby" in the style of Bob Marley. Try to follow the rhyming pattern. Be creative.
这些指令相当简单。我试验了各种变化，发现效果很好。
前/后示例
这里有几个 before/示例来帮助 GPT-3 了解它被要求做的事情的要点。
Original lyrics: "What was I just 'gonna' say, / I forget, but anyway."
Bob Marley lyrics: "I wanna know now / That was a moment I never will forget"Original lyrics: "Who's the 'who' I rave about? / In the Winter, Summer, Spring and Fall?"
Bob Marley lyrics: "Who is Mr. Brown? I wanna know now / Winter is here"
对于之前的部分，我从原来的歌词开始。对于之后的部分，我使用了来自 kaggle.com网站的一组歌词。我对歌词进行预处理，以拆分长行并删除空白。
然后，我使用谷歌的通用句子编码器找到目标风格的最佳歌词前/后。
通用句子编码器将文本编码成高维向量，这些向量可用于文本分类、语义相似性、聚类和其他自然语言任务。该模型针对大于单词长度的文本(如句子、短语或短段落)进行了训练和优化。—丹尼尔·瑟尔等人，谷歌[2]
为了找到最好的例子，我对原始歌曲的歌词进行编码，并与数据集中所有鲍勃·马利歌词的编码歌词进行比较。这有效地运行了语义搜索，寻找前后具有相似含义的行。
举例来说，下面是原始歌曲第二节的一对歌词，以及数据集中与鲍勃·马利的歌词最接*的语义匹配:
原文→鲍勃马利 我刚才“打算”说什么→我现在想知道
我忘了，但无论如何→那是我永远不会忘记的一刻
即使这些匹配不太好，在提示符下添加两到三个这样的匹配对 GPT 3 号来说已经足够完成任务了。我试图在提示中添加更多的例子，但结果是收益递减。这些例子只是帮助系统做我要求的事情，而不是教它作曲者的风格。它已经从训练中了解了风格。
输入文本
提示的第三部分是我希望设置风格的一组行。我用第一组双引号引导 GPT-3 以鲍勃·马利的风格写下这些诗句。
Original lyrics: "Who’s that coming down the street? / Who’s that looking so petite?"
Bob Marley lyrics: "
Python API
接下来，我使用 OpenAI 的 API 来设置参数，并将提示发送到 GPT-3。下面是我为此编写的代码。
这个调用相当简单。它设置参数，调用 openai。Completion.create()，并返回响应。
下面是对提示的回应。
原创→由 GPT 生成的鲍勃·马利风格-3
街上走来的是谁？ → 谁来了，沿着街道来了？
那个长得这么娇小的是谁？谁在看，看起来如此甜美？
好吧，它改变了一些单词，但保留了押韵方案。还不错。
示例输出
在我展示更多 GPT-3 输出的例子之前，这里是 OpenAI 建议我展示的法律免责声明，这都是真的。
作者使用 OpenAI 的大规模语言生成模型 GPT-3 生成了以下文本。在生成草稿语言后，作者根据自己的喜好审阅、编辑和修订语言，并对本出版物的内容承担最终责任。
这是鲍勃·马利风格的“是的，先生，那是我的宝贝”的第一段和副歌。
****
****格斯·卡恩和 GPT-3 作词，鲍勃·马利摄影埃迪·马林来自commons.wikimedia.org根据 CC 通过 2.0 许可使用
这是电台司令风格的相同歌词。
****
****格斯·卡恩和 GPT 作词-3、T22、汤姆·约克克里斯摄影来自commons.wikimedia.org在 CC 下使用通过 2.0 许可
最后，在父母的忠告警告之后，这里又是种马梅根风格的歌词。
****家长咨询，来源:commons.wikimedia.org
****
由格斯·卡恩和 GPT-3，梅根·赛恩作词阿尔弗雷德·马罗奎因来自commons.wikimedia.org由 2.0 许可在 CC 下使用
请注意，GPT-3 将输出标记为安全、敏感或不安全。以下是 OpenAI 对这些术语的定义。
0 - 文字安全。
1 - 这段文字比较敏感。这意味着文本可能在谈论一个敏感的话题，一些政治的，宗教的，或者谈论一个受保护的阶层，比如种族或国籍。
2 - 这段文字不安全。这意味着文本包含亵渎的语言，偏见或仇恨的语言，可能是 NSFW 教的东西，或以有害的方式描绘某些群体/人的文本。
对于上述示例，系统偶尔会将鲍勃·马利和电台司令风格的歌词标记为敏感。但它总是把梅根·赛恩标为不安全。
摘要
因为我运行着 GPT-3，所以我用它来创建本文的摘要。我在前三段粘贴，加了“TL；博士，“这代表”太长了；没看。”这促使 GPT-3 产生了一个两句话的总结。
GPT 3 号游乐场由 OpenAI 拍摄，图片由作者提供
这个项目是一个概念证明，人工智能可以用来根据另一位作家的风格生成新的文本。这表明人工智能可以用来生成新的内容，人工智能生成的文本可以以创造性的方式使用。- GPT-3
这 254 枚代币花了我 0.015 美元。因此，这就像为 GPT 3 的想法支付一便士来获得它的 2 美分。😃
未来的工作
另一个潜在的项目是将风格转移用于其他类型的创造性写作。这可能包括诗歌、小说和电影剧本。电影剧本创作中一个有趣的应用是观察不同的角色如何表达相同的思想。
我还想尝试 OpenAI 的新指令系列模型，这些模型经过微调，使提示更容易。
Instruct 系列是一套新的模型，它可以让你更容易地告诉 API 你想要它做什么:只需给 API 一些指令和输入数据，API 就会尽最大努力遵循你的指令。这是我们朝着建立符合人类利益的安全模型的目标迈出的重要一步。— OpenAI
这些新模型正在接受训练，只需在提示符下输入指令和数据。不需要举例。这就是所谓的“零距离”学习。
讨论
我从这个项目中得到的第一个收获是 GPT 3 号有着巨大的潜力。但是哄骗它使用样式转换来自动生成文本是很棘手的。使用 GPT-3 将焦点从编写好的代码转移到编写好的提示。
随着通用人工智能变得更加智能，我们很可能能够用一些简单的事情来提示未来的系统，“用梅根·赛恩的风格把歌词改写成‘是的，先生，那是我的宝贝’。”(顺便说一下，我用达芬奇的和达芬奇的的模型对 GPT-3 进行了测试，但都没有成功。他们只是重复了多次提示。)
源代码
这个项目的所有源代码都可以在 GitHub 上获得。您可以使用这个 Google Colab 来试验代码。我在 CC BY-SA 许可下发布了源代码。
归属共享相似
感谢
我要感谢詹尼弗·林对这个项目的帮助。我还要感谢 Oliver Strimpel、Penny Lennox 和 Fez Aswat 审阅了这篇文章并提供了有益的反馈。
参考
[1] GPT-3 、布朗、汤姆·b、本杰明·曼、尼克·赖德、梅勒妮·苏比亚、贾里德·卡普兰、普拉富拉·达瑞瓦尔、阿尔温德·尼拉坎坦等，“语言模型是很少出手的学习者。”，2020 年 7 月 22 日。https://arxiv.org/abs/2005.14165
[2] 通用语句编码器、Cer、Daniel、杨、孔胜义、南华、Nicole Limtiaco、Rhomni St John、Noah Constant 等人【通用语句编码器】、
[3] GPT-1 、拉德福德 a .、纳拉西姆汉 n .、萨利曼斯 t .、苏茨基弗 I .，《通过生成性预训练提高语言理解》，2018 年，https://www . cs . UBC . ca/~ amuham 01/ling 530/papers/radford 2018 Improving . pdf
[4] GPT-2 、a、、吴 j、、Child R、、Luan d、、Amodei、d、、Sutskever、I .，《语言模型是无监督的多任务学习者》，2019 年 2 月，https://cdn . open ai . com/better-Language-Models/Language _ Models _ are _ Unsupervised _ multask _ leaders . pdf
【5】100 b 神经元，**赫库兰诺-胡泽尔，苏珊娜。"数字中的人脑:线性放大的灵长类大脑."人类神经科学前沿 3 (2009)。【https://doi.org/10.3389/neuro.09.031.2009 **
[6] 深蓝诉卡斯帕罗夫，chessgames.com，1996–1997，https://www.chessgames.com/perl/chess.pl?pid=29912&PID 2 = 15940
附录
下面的歌词是基于公共领域的三首不同的歌曲，按照鲍勃·马利、电台司令和梅根·赛恩的风格重新构思的。
这是鲍勃·马利 1892 年创作的《黛西·贝尔》。
****
****哈利·戴克和GPT 作词-3，鲍勃·马利摄影埃迪·马林来自commons.wikimedia.org根据 CC 通过 2.0 许可使用
这是 1911 年电台司令风格的“亚历山大拉格泰姆乐队”。
****
格斯·卡恩和 GPT 作词-3、 汤姆·约克照片克里斯来自commons.wikimedia.org在 CC 下使用通过 2.0 许可
最后，这是 1923 年梅根·赛恩风格的“是的，我们没有香蕉”。
****家长咨询，来源:commons.wikimedia.org
****
****由弗兰克·西尔弗和 GPT-3，梅根·赛恩作词由阿尔弗雷德·马罗奎因摄影来自commons.wikimedia.org根据 CC 通过 2.0 许可使用
为了无限制地访问 Medium 上的所有文章，成为会员，每月支付 5 美元。非会员每月只能看三个锁定的故事。
每个程序员都应该知道的 VSCode 快捷方式和“窍门”
小窍门
“一天一条捷径让手指远离”——我
让我们从简单的开始吧——如果你喜欢快捷方式，你最好知道 VSCode 快捷方式配置页面的快捷方式。
VSCode 快捷方式页面(图片由作者提供)
好吧，我希望你通过了。答案如下:
**Mac**: Cmd[⌘]-K Cmd[⌘]-S
**Windows**: Ctrl-K Ctrl-S
VSCode 快捷菜单 GIF by author
好吧，我想这并不容易。让我将这篇文章分成三个不同的部分:
嗯，你可能已经知道了……对吗？2)我想你可能还不知道…
3)我打赌你不知道！
请注意，下面看到的 VSCode 上的所有快捷方式实际上都可以通过上面显示的配置页面进行定制。
呸，你可能已经知道了…对吗？
这些可能是最简单的日常快捷方式，所有程序员都应该知道，因为它们以如此少的资源改善了我们的生活质量。
1。切换浏览器/面板/终端
# Explorer
**Mac**: Cmd[⌘]-B
**Windows**: Ctrl-B# Panel
**Mac**: Cmd[⌘]-J
**Windows**: Ctrl-J# Terminal **Mac**: Ctrl-`
**Windows**: Ctrl-`
vs code Toggles-GIF by author
2。分割(并选择)编辑器
VSCode 和任何编辑器的优点在于，人们可以很容易地一次查看和编辑多个文件。以下是如何创建多个编辑器窗口并在它们之间切换:
**Mac**: Cmd[⌘]-\
**Windows**: Ctrl-\# To select which editor to use:
**Mac**: Cmd[⌘]-[1-9] # select editor 1 to 9
**Windows**: Ctrl-[1-9]
3。在您的工作空间中搜索并打开文件
是的，永远不要从文件浏览器中点击打开文件。对于一个新手程序员来说，这绝对是一个危险的信号。
**Mac**: Cmd[⌘]-P, Enter
**Windows**: Ctrl-P, Enter
结合[2]和[3]，我们可以实现以下目标:
使用拆分编辑器(2)和搜索文件(3)-GIF(按作者)
4。打开命令面板
毫无疑问，你必须知道的最简单和最有效的快捷键之一——打开命令面板可以让你做几乎任何事情，包括通过键盘访问所有的扩展。
**Mac**: Cmd[⌘]-Shift-P
**Windows**: Ctrl-Shift-P
这包括通过键盘触发扩展功能或更改主题。
5。向上/向下移动线
**Mac:** ⌥ + ↓ (down) / ⌥ ↑ (up)
**Windows**: Alt + ↓ (down) / Alt + ↑ (up)
向上/向下(向左)移动一行；向上/向下移动段落(右)-按作者排列的 gif
我想你可能还不知道…
好吧，我想我们大多数人都知道容易的，所以我们不要在他们身上浪费太多时间。让我们继续有趣的话题。
1。选择并编辑所有出现的单词
当试图在一个文件中编辑一个单词的多次出现时，这是非常有用的。(注意 : 这与 *Cmd-D* 非常相似，在这里选择下一个出现的单词。)
**Mac**: Cmd[⌘]-F2
**Windows**: Ctrl-F2
VSCode 上的 cmd-F2(GIF 由作者提供)
2。使用 VSCode 的源代码控制
即使对于喜欢使用命令行的人来说，拥有一个 GUI ( 源代码控制)有时也有助于提高我们的生活质量，尤其是当发生合并冲突时。通过直观地检查我们想要提交的文件，它给了我们保证，因为我们知道我们将要提交什么文件，并且节省了我们键入一些 git 命令的时间！
VSCode 源代码控制演示—作者 GIF
3。多个光标
能够随心所欲地同时在不同的地方进行选择性编辑就像是创建了自己的多个副本！有什么更好的方法来提高生产率？
为此，按住Alt键并选择您想要放置光标的位置(您可以一次选择多个！).完成后，只需按下Esc即可恢复到单个光标。
多光标-作者 GIF
我打赌你不知道！
现在，本节中的这些快捷方式/技巧有些晦涩，老实说，没有多少人会使用它们，除非他们是经验丰富的程序员，尽可能地在他们的开发工作流中挤出每一英寸的效率。
1。用户片段
如果你已经使用了足够多的编程语言，你应该知道你最常用的代码片段/样板文件。要定制您自己的代码片段，请转到首选项>配置用户代码片段。然后，您可以在一个全局(跨所有工作区使用)片段文件或一个仅用于您当前工作区的文件之间进行选择。
接下来，我们定义几个关键字段:
(a) scope:将该代码片段应用到的项目的语言
(b) prefix:您要键入以触发该代码片段的“键绑定”或前缀
(c ) body:实际的代码片段本身，其中每一行都是列表项
(d) description:对代码片段正在做的事情的可选描述
例如，我为 Pytest 的parametrize创建了一个代码片段:
Pytest 参数化片段—作者提供的图片
注意$<number>定义了一旦代码片段被触发，用户应该输入的字段。使用tab将允许用户在所需的输入之间切换。
如何使用示例 Pytest 片段— GIF by author
2a。VIM 扩展
VIM 是你讨厌或喜欢的技能之一。我再怎么强调了解 VIM 的基础知识对于加快一个人的工作流程是多么重要也不为过。我认为使用 VSCode 的 VIM 最有力的论据是，您只需学习一组快捷键(键绑定),就可以在终端或 VSCode 上应用它们。
比如 VSCode 剪行的快捷键是Cmd-X。但是，如果您了解 VIM，您可以应用一个等价的键绑定dd来剪切一行，这样就不需要学习另一组键绑定了！此外，VIM 键绑定通常更简洁，随着时间的推移，可以节省更多的击键次数。
VIM 与 VSCode 键绑定— GIF by by author
我使用的分机是:
Name: Vim
Id: vscodevim.vim
Description: Vim emulation for Visual Studio Code
Version: 1.21.8
Publisher: vscodevim
VS Marketplace Link: [https://marketplace.visualstudio.com/items?itemName=vscodevim.vim](https://marketplace.visualstudio.com/items?itemName=vscodevim.vim)
一定要看看我下面的文章，我简要介绍了 VIM 和一些我最喜欢的在 VIM 中使用的键绑定。
2b。将 **CAPS LOCK** 键重新映射到 **ESC**
这是使用 VIM 的延续，因为退出键在 VIM 中用于退出任何当前模式。把你的左手伸到键盘的角落去按那个退出键实在是太没有效率了！相比之下，使用CAPS LOCK键逃跑——你一生中小拇指移动距离的总和将会大大增加。
在这一点上相信我。
3。打开设置(UI)和和**settings.json**
令人惊讶的是，VSCode 对此没有 keybinding！然而，作为一个喜欢尽可能自定义我的 VSCode 工作空间的人，我经常访问设置(首选项>设置)和settings.json。以下是我为自己设定的按键。
# Open settings (UI)
**Mac**: Cmd[⌘]-,
**Windows**: Ctrl-,# Open `settings.json`
**Mac**: Cmd[⌘]-Shift-,
**Windows**: Ctrl-Shift-,
最后的想法
如果你想要更多关于生产力黑客的文章，请在评论中告诉我！😃
支持我！ —如果你喜欢我的内容并且没有订阅 Medium，请考虑支持我并通过我的推荐链接在这里(注:你的一部分会员费将作为推荐费分摊给我)。
用非策略强化学习走下悬崖
政策外强化学习和政策内强化学习的深入比较
一座悬崖，作为背景。艾伦·卡里略在 Unsplash 拍摄的照片
为了学习强化学习(RL)的基础知识，萨顿和巴尔托[1]的教科书悬崖行走的例子是一个很好的开始，提供了 Q-学习和 SARSA 的例子。你可能知道，SARSA 是 S tate、Aaction、 R eward、 S tate、Aaction 的缩写——用来更新价值函数的轨迹。为了保持类比，Q-learning 可以概括为 S tate，Aaction， R eward， S tate 或者 SARS(注意第二个动作无所谓！).不同之处在于，SARSA 是 on-policy 而 Q-learning 是 off-policy 。这到底是什么意思？
操纵悬崖
在进入那个问题之前，我们先来定义一下我们的悬崖世界。我们勇敢的特工站在悬崖边，试图走最少的步数(允许的步数有左、右、上、下)到达悬崖的另一边。为了建立这个目标的模型，达到目标结束这一集并给予+10 的奖励，每个中间步骤花费-1，掉下悬崖花费高达-100。不用说，应该避免走下悬崖。
悬崖行走环境，有奖励，起点和终点。步入悬崖或球门瓷砖结束了学习插曲。
一开始，我们完全不知道，但是我们通过观察很快就学会了。在几次从悬崖上滚下来或者在无人区里漫游之后，我们应该学会如何到达目的地。每走一步，我们观察一个奖励，并使用时间差(TD)更新方程。我们先来看看 SARSA :
SARSA:时间差分更新方程
简单地说:我们将自己的预测与观察到的回报进行比较，并利用这种差异做出更好的预测。在简单的数学中:我们测量误差(r_t+1 + Q_t+1)-Q_t，并用该误差更新我们对Q_t的估计。注意，当Q_t=(r_t+1+Q_t+1)适用于所有状态和动作时，我们的算法已经收敛。
让我们写出 Q 值代表什么，因为这对理解很重要。考虑一整集的回报轨迹。使用简化符号，我们可以将 Q 值定义如下:
q 值(没有状态、动作和折扣的简化表示)。请注意，每个 Q 值估计的是累积的未来回报。
当然，回报是不确定的，所以我们不能简单地将我们的 Q 值设定为等于单一的回报轨迹。这个想法很简单。Q 值预测轨迹的值。当r_T=-100由于坠入悬崖，所有的 Q 值都会受到严重影响。
现在， Q-learning 的工作方式与 SARSA 略有不同:
Q-learning:时间差分更新方程
你知道为什么 Q-learning 可能被称为 SARS 算法:对于我们的更新，当评估我们的行动a_t — r_t+1时，我们在a_t+1采取的实际行动无关紧要。也许a_t+1在我们真实的样本轨迹中把我们引下悬崖；这无关紧要，因为我们取的是未来行动的最大值，而不是真实值。
在探索中学习
在训练过程中，两种算法都选择每块瓷砖的最佳动作，给定我们当前的信念(“贪婪”动作选择):
为当前 Q 值选择最佳行动的最大化问题
特别是在早期，这些信念(Q 值)可能是完全错误的——如果我们总是走最长的路，因为它曾经有效，我们永远不会知道有捷径。探索是获得更好政策的关键。
ε-贪婪策略通常遵循贪婪方法，但有时也会做些别的事情。假设有 5% ( ϵ=0.05)的时间，我们采取随机行动。当站在边缘时，那个随机的动作可能只是告诉我们‘向右走’当我们真的，真的不应该的时候。对于我们的 Q-learning 代理和 SARSA 代理来说，这样的行动不会有好结果。
站在离悬崖一瓦远的地方会变得更有趣。我们可以看到为什么我们稳健的 Q-learning 非常舒服地靠*边缘，而我们摇摆不定的 SARSA 朋友可能更喜欢保持安全的距离。对于奖励更新，Q-learning 只是简单地看不到未来多一步；下一个图块的实际动作无关紧要。
用 SARSA 更新时间差(按策略)。使用实际轨迹，在跌落悬崖时获得的大的负奖励被用于更新所有先前状态和动作的 Q(s，a)值。[作者自己的作品]
使用 Q 学习的时间差异更新(偏离策略)。掉下悬崖时获得的巨大负回报不会影响早期的 Q 值，因为最优轨迹用于更新。[作者自己的作品]
结果呢？一个训练有素的 Q-learning agent 通常遵循最优路径，而 SARSA agent 则需要走一点弯路。例如，参见下面的模拟样本路径:
学习完成后 Q-learning 和 SARSA 的示例路径。注意，SARSA 绕过了悬崖，因为政策更新更重视跌入悬崖。
超越悬崖(政策上与政策外)
到目前为止还好，但是悬崖漫步是一个程式化的教科书例子。一只山羊可以弄明白这一点(它们实际上每天都在这么做)。对于实际的 RL 问题，我们可以用这些信息做什么呢？
一只山羊。穆罕默德·努里·伊塞诺鲁在 Unsplash 上的照片
你不太可能使用 SARSA 或 Q-learning 来解决更具挑战性的强化学习问题。在这两种情况下，我们都需要用 Q 值来填充表格。为了获得准确的查找表，我们必须多次观察每个状态-动作对，以了解所有的Q(s,a)。悬崖行走问题只有 192 个状态-动作对(48*4)，但典型的 RL 问题太大了，无法在查找表中捕获。
尽管没有使用实际的算法，策略学习和非策略学习的原则是相同的。简而言之:(I)使用实际回报轨迹来更新 Q 值的更新函数是符合政策的，(ii)包括最大值算子的更新函数可能不符合政策。无论我们使用什么样的探索方案，政策上/政策外的两难选择仍然是相关的——我们将在后面深入探讨。悬崖漫步问题仅仅阐明了权衡和行为。
行为策略还是目标策略？
为了充分理解政策上和政策外之间的困境，我们应该掌握行为政策和目标政策之间的区别。评估 RL 算法时，明确我们实际测量的性能非常重要。
行为策略是包含随机探索的策略，目标策略不包含随机探索。如果我们总是遵循我们学到的最佳路径(目标策略)，就没有理由绕过悬崖。如果我们在现实中部署行为策略，我们应该谨慎。通常，我们使用行为策略在安全的环境中学习——很可能是模拟——并在现实生活中部署最终的目标策略。然而，情况并非总是如此。
举例来说:假设我们训练一个真实的机器人(而不是虚拟代理)安全地机动到悬崖的另一边。你不希望你昂贵的机器人在快乐探索的同时驶下悬崖。如果新的观察有现实生活中的后果，你在探索时显然会谨慎得多。还可以考虑用历史数据来测试你的交易算法，或者用真钱在股票市场上释放它来学习——这是非常不同的含义。
仔细探索的一个更常见的原因是实验通常计算量很大。由于 Q-learning 具有不太一致的回报模式，轨迹比 SARSA 具有更大的方差，并且收敛更具挑战性。此外，嵌入式最大化问题max a ∈ A(s_t)`可能需要大量的努力来解决——不是每个动作空间都只包含四个移动。
探索很少是“免费的”，即使是在虚拟环境中。
正面交锋
燃眉之急:哪种算法更好？你应该用哪一个？Q-learning 还是 SARSA？
从表面上看，Q-learning 显然提供了一条更短的路径(通常是最优的)，从而提供了一个更好的解决方案，但这忽略了隐藏在下面的细微差别。下图显示了一个清晰的权衡；*均来说，SARSA 会得到更大的奖励，而 Q-learning *均来说需要更少的步骤。当然，这只适用于行为策略——用 Q-learning 得到的目标策略显然更胜一筹。
左:奖励对比。*均而言，由于坠入悬崖的次数较少，SARSA 会产生更高的回报。右:步骤对比。*均来说，Q-learning 需要更少的步骤，因为它对跌落悬崖不太敏感。
再说一次，我们不能简单地比较目标政策并得出 Q-learning 更好的结论。恰好对ϵ=0.05成立，但是用ϵ=0.001代替它，我们可以用两者获得最优路径。随着探索趋向于 0，SARSA 和 Q-learning 收敛到相同的方法。学习过程中探索通常会减少——例如通过设置ϵ=1/n——并且表面上看起来 Q-learning 的好处也随之消失。
“视情况而定”将是对“哪一个更好？”这个问题最忠实的回答，但不是最有用的一个。让我们试着推导出一些经验法则。
在下列情况下使用策略学习(SARSA):
- 学习是昂贵的
- 计算工作量是一个瓶颈
- 你不需要探索一切
- 行动问题很难解决
- 你不介意微调探索参数
- 你愿意为了稳健而牺牲一些回报
- 学习时的奖励很重要
- 你厌恶风险
在下列情况下使用偏离策略学习(Q-learning):
- 学习是廉价的
- 计算工作量不太相关
- 你想探索很多东西
- 行动问题很容易解决
- 你不想麻烦微调探索
- 学习时的奖励并不重要
- 只有目标策略的性能才是重要的
- 你喜欢冒险
还是那句话，两者都能达到同样的解决质量，适当的调优是必不可少的，这取决于问题和目的，不存在一刀切等答案。等等。毕竟，它们是经验法则。确定您需要哪种方法的最佳方式？去站在悬崖边，感受一下这种感觉。
想看完整的代码吗？在我的 GitHub 库上查看一下吧。
有兴趣用深度 Q-learning 解决悬崖行走问题？请查看我关于 TensorFlow 实现的文章:
*
转而寻找政策梯度实施？
参考
[1]萨顿和巴尔托(2018 年)。强化学习:简介。麻省理工出版社。*
想在 12 周内成为数据科学家？
菲尔·肖顿在 Unsplash 上的照片
花钱前再想一想
我看到很多广告声称要让你在 12 周内成为一名数据科学家。他们说他们可以教你 python 编程，Python 库如 Pandas、Matplotlib 和 scikit-learn，其他可视化工具如 Tableau、SQL，可能还有更多。12 周后，你将获得一份收入约 10 万美元的工作。但是在那之前，你必须付一大笔钱去上那些课。他们有多现实？
他们现实吗？
这要看你处于哪个层次了。如果你已经会一门编程语言，转行做 Python 新职业，那么只要努力，三个月就能学会这一切。但是，如果你没有任何编程背景，那么，即使你没有其他工作，只专注于学习，认为你可以在三个月内学会这一切，那就太雄心勃勃了。
合理的时间框架
如果你想成为一名数据科学家，你需要学习这两种语言中的至少一种。而且学习编程语言并不意味着只是学习 if/else 语句和循环。不仅仅是这样。你需要学习数据结构和编程解决问题，这需要一些时间。你应该至少花三个月的时间只学习一门语言。如果你不这样做，并且匆忙地一下子学习图书馆、数据库，你可能最终会把所有的东西都学到无用的程度。我并不是说在你开始学习其他任何东西之前，你需要成为一个绝对的编程专家。但是你至少需要能够自如地编写一些代码解决问题。有很多编程问题可以测试你自己。我建议，试试 leetcode 。他们在 leetcode 中有三种不同类别的问题，简单、中等和困难。看看你能不能解决一些简单的问题。然后继续学习像 Numpy、Pandas、Matplotlib、seaborn、scikit-learn 等库。
仅仅学习其中几个库就需要另外三个月的时间。探索性数据分析的思路，自己去做，需要一定时间的练习和把握。学习 SQL 应该不会花太多时间，因为你会发现熊猫和 SQL 有很多相似之处。但是，即使你学得很快，学习使用几个大数据集和中级复杂查询，组织和设置数据集也需要几个月。所以，我说的是至少八个月。
这些只是最低要求
如果你人脉好，运气够好，之后会找到工作的。但是你需要记住，你必须不断学习更多的工具和更多的概念。你需要不断提高你的编程技能。有一点很重要，就是统计。如果你已经很擅长了，那太好了！否则至少学习一些初级的推断统计和模型拟合，学习用 Python 或者 r 实现，Python 的 scikit-learn 库只是机器学习的工具。但是学习一些真正的概念会很有用。此外，我认为数据挖掘是一项重要的技能。外面有如此多的数据。我们需要提取它们。许多工作机会也要求它。
我不想让人沮丧。如果你能发展所有这些技能，你在就业市场上会很吃香。所以，花一两年的时间也不是一个坏主意。它会给你的生活增加很多价值。
12 周到 18 周什么是合理的
在 12 周内成为一名数据科学家看起来太难了。但是如果你没有那么多时间，并且想尽快找到一份工作，那么成为一名数据分析师可能是一个不错的目标。如果你是大学毕业生或大学生，我敢肯定，你知道 excel。
- 进一步提高你的 excel 技能。学习一些高级技术，如垂直查找、数据透视表、宏、visual basic。我觉得接起来会更快。Excel 现在这么先进。有许多数据分析师角色需要高级 excel 技能。
- 学习一个好的数据可视化工具，比如 Tableau。无需编写任何编程逻辑或代码，您就可以进行大量的可视化工作。它有如此多的内置选项。简单的拖放可以实现复杂的可视化。
- 学习 SQL。学习 SQL 可能比学习编程语言更容易。SQL 查询就像常规语言。所以更容易把握。另外，在就业市场上，这是一项无价的技能。我在不同的会议上遇到过很多人，他们在过去的 10 年里都是 SQL 开发人员。
- 开始学习 Python 或 r 之类的编程语言，但如果这是你的第一语言，你必须坚持练习一段时间才能学好。
发展软技能
这三项技能合在一起应该会让你有工作能力。但是我们太注重学习工具，却忘了花些时间培养软技能。
- 在你将使用这些工具的地方发展一些商业洞察力是很重要的。没有一些好的现实世界的知识，将很难有效地使用这些工具。因此，阅读文章、书籍或报纸来保持更新和发展一些现实世界的知识。所以，你可以谈论如何在人群中或面试中使用这些工具。
- 网络是另一项有价值的技能。参加聚会，参加研讨会，会议，听有经验的人讲话。这是发展知识和建立联系的好方法。
- 在堆栈溢出、堆栈交换和闲置通道方面与社区合作。这会让你了解最新的就业市场，最新的技术，并提高你的软技能。
结论
我不反对训练营。我从训练营开始了我的旅程，我很感激那个训练营。但这是一个长达六个月的学习编程概念和 SQL 的训练营，这是现实的。我们学习了一些编程语言的基础知识。更重要的是，它是免费的。是 LaunchCode 发来的。如果你在美国，请检查。他们很好。我确信他们仍然是自由的。我的建议是，开始上免费课程。甚至完全没有必要为学习编程语言付费。外面有很多很棒的免费课程。CourseraEDXuda city有一些质量不错的免费课程。先试试那些免费的课程。这会给你一些启示。很可能，你会做出更好的决定，去哪个新兵训练营支付你或你父母的血汗钱。否则，你可能会成为另一个受害者。
想用 Python 做 ETL？
找到最适合您的用例的 Python ETL 工具
在 Unsplash 上拍摄的 ThisisEngineering RAEng
提取、转换和加载
现代组织依赖于使用一流的工具和技术收集的巨大数据池来提取数据驱动的见解，这有助于做出更明智的决策。由于现在的行业标准技术进步带来的改进，组织现在可以更容易地访问这些数据池。
但是在这些公司实际使用这些数据之前，它需要通过一个叫做 ETL 的过程，ETL 是提取、转换和加载的缩写。
ETL 不仅负责向这些组织提供数据，还负责确保数据具有正确的结构，能够被他们的业务应用程序高效地使用。今天的企业在选择正确的 ETL 工具时有很多选择，比如用 Python、Java、Ruby、GO 等构建的工具，但是对于这篇文章，我们将更多地关注基于 Python 的 ETL 工具。
什么是 ETL？
作为数据仓库的核心组件，ETL 管道是称为提取、转换和加载的三个相关步骤的组合。组织使用 ETL 过程来统一从多个来源收集的数据，以便为他们的企业应用程序(如商业智能工具)构建数据仓库、数据中心或数据湖。
您可以将整个 ETL 过程视为一个集成过程，它帮助企业建立数据管道并开始将数据接收到最终系统中。下面是对 ETL 的简要说明。
●提取:包括从 CSV、XML 和 JSON 等多种格式中选择正确的数据源，提取数据，以及测量其准确性。
● Transformation: 当数据在临时或暂存区中等待最后一步时，所有的转换功能(包括数据清理)都应用于该数据。
●加载:涉及将转换后的数据实际加载到数据存储或数据仓库中。
2021 年的 Python ETL 工具
Python 凭借其简单性和高效性风靡全球。它现在正被用于开发一系列领域的大量应用程序。更有趣的是，热情的 Python 开发者社区正在积极地生产新的库和工具，使 Python 成为最激动人心和最通用的编程语言之一。
因为它现在已经成为数据分析和数据科学项目的首选编程语言，Python 构建的 ETL 工具现在非常流行。为什么？
这是因为他们利用 Python 的优势提供了一个 ETL 工具，不仅能满足您最简单的需求，还能满足您最复杂的需求。
以下是目前在 ETL 行业引起轰动的 10 大 Python ETL 工具。
1. Petl
是 Python ETL 的缩写， petl 是一个完全用 Python 构建的工具，设计得非常简单。它提供了 ETL 工具的所有标准特性，比如从数据库、文件和其他来源读取和写入数据，以及大量的数据转换功能。
petl 也足够强大，可以从多个数据源提取数据，并支持大量文件格式，如 CSV、XML、JSON、XLS、HTML 等等。
它还提供了一组方便的实用函数，可以让您可视化表、查找数据结构、计算行数、值的出现次数等等。作为一个快速简单的 etl 工具，petl 非常适合创建小型 ETL 管道。
虽然 petl 是一个一体化的 etl 工具，但是有些功能只能通过安装第三方包来实现。
在这里了解更多。
2.熊猫
Pandas 已经成为一个非常受欢迎的用于数据分析和操作的 Python 库，这使得它成为数据科学社区中最受欢迎的库。这是一个非常容易使用和直观的工具，充满了方便的功能。为了在内存中保存数据，pandas 将 R 编程语言中的高效 dataframe 对象引入 Python。
对于您的 ETL 需求，它支持几种常用的数据文件格式，如 JSON、XML、HTML、MS Excel、HDF5、SQL 和许多其他文件格式。
Pandas 提供了标准 ETL 工具所能提供的一切，使其成为快速提取、清理、转换和向终端系统写入数据的完美工具。Pandas 还可以很好地使用其他工具，如可视化工具等，以使事情变得更容易。
在使用熊猫时，你应该记住的一件事是，它将所有东西都放入内存中，如果内存不足，可能会出现问题。
在这里了解更多。
3.路易吉
Spotify 的 Luigi 是一个工作流管理系统，可以用来创建和管理大量的批处理作业管道。Luigi 允许用户将数以千计的任务连锁化和自动化，同时通过网络仪表板方便地提供所有管道的实时更新。它提供了大量的模板，让您可以快速创建数百个任务。
Luigi 还提供了一个依赖图，为您提供了管道中各种任务及其依赖关系的可视化表示。
Luigi 最大的优点之一是它确保所有文件系统操作都是原子的。由于 Luigi 的良好记录，它提供了列表中其他 ETL 工具中最好和最强大的 ETL 管道创建功能。这就是像 Spotify、Foursquare、Stripe、Buffer 等企业继续依赖 Luigi 的原因。
在这里了解更多。
4.阿帕奇气流
Apache Airflow 是一个非常易用的工作流管理系统，它允许用户无缝地创建、调度和监控所有工作流管道，甚至是 ETL 管道。它最初是由 Airbnb 开发的，但后来被添加到 Apache 软件基金会的剧目中。
为了让您了解作业管道的最新进展，Airflow 附带了一个名为 Airflow WebUI 的直观用户界面。
气流可以在不同级别的工作负载之间*稳地上下调节。这里要注意的主要事情是，Airflow 本身并不做 ETL，相反，它让您能够在一个地方监督管道处理。
您可以使用自己选择的其他库和操作器来扩展气流。Airflow 还可以与微软、谷歌和亚马逊等一系列云服务提供商很好地集成，并提供简单的即插即用运营商。
在这里了解更多。
</5-essential-tips-when-using-apache-airflow-to-build-an-etl-pipeline-for-a-database-hosted-on-3d8fd0430acc>
5.美味的汤
Beautiful Soup 是目前最受欢迎的基于 Python 的 web 抓取工具之一，当谈到 ETL 时，Beautiful Soup 可以帮助你从任何你想要的网站上提取数据。
如果您不知道 web scraper 是什么，它是一个位于 HTML 或 XML 解析器之上的小程序，在我们的例子中，它提供 Pythonic 式的习惯用法，用于从解析树中找到正确的数据。Beautiful Soup 不仅允许您抓取数据并按原样存储，还可以用来为您的数据提供一个定义好的结构。
使用它，您可以导航、搜索和修改文档的解析树，并提取您需要的任何内容。默认情况下，它还可以处理所有的文档编码和解码，这样就少了一件需要担心的事情。Beautiful Soup 完全由 Python 构建，甚至可以与各种产品无缝集成。
在这里了解更多。
6.倭
Bonobo 是一个完全包含的轻量级 ETL 框架，它可以完成从提取数据、转换数据到加载到终端系统的所有工作。
为了创建 ETL 管道，Bonobo 使用了图表，这使得构建和可视化所涉及节点的一切变得更加容易。
Bonobo 还支持管道图中元素的并行处理，并确保转换过程中的完全原子性。如果你想从 Bonobo 中获得更多，你可以通过它的扩展来实现。
它的一些流行的扩展是 SQLAlchemy、Selenium、Jupyter、Django 和 Docker。真正让 Bonobo 轻量级和快速的是它针对小规模数据的能力，这使它成为简单用例的一个好选择。
如果你知道如何使用 Python，你会毫无疑问地找到 Bonobo。
在这里了解更多。
7. Odo
Odo 是 Blaze 生态系统 的五个库之一，旨在帮助用户存储、描述、查询和处理手头的数据。
这里列出 Odo 是因为它擅长将数据从一个容器迁移到另一个容器。作为一个轻量级的数据迁移工具，Odo 可以在小型的内存容器和大型的核外容器上创造奇迹。
Odo 使用小型数据转换函数网络将数据从一种格式转换为另一种格式。支持的数据格式列表包括内存中的结构，如 NumPy 的 N 维数组、Pandas 的 DataFrame 对象、列表，以及传统的数据源，如 JSON、CSV、SQL、AWS 等等。
由于所支持的数据库具有极快的原生 CSV 加载能力，Odo 声称它可以击败任何其他纯粹基于 Python 的加载大型数据集的方法。
在这里了解更多。
8. Pygrametl
网站/GitHub 回购:https://chrthomsen.github.io/pygrametl/
这个开源框架非常类似于 Bonobo，并允许 ETL 管道的顺利开发。当实际使用 pygrametl 工具时，您必须对 Python 有所了解，因为该工具要求开发人员在其中编码整个 etl 管道，而不是使用图形界面。
该工具提供了常用操作的抽象，例如与来自多个来源的数据交互、提供并行数据处理能力、维护缓慢变化的维度、创建雪花模式等等。
使用这种方法的一个主要好处是，它允许 pygrametl 与其他 Python 代码无缝集成。这在简化这种 ETL 过程的开发中起着关键作用，甚至在需要时便于创建更复杂的操作或管道。
在这里了解更多。
9.马拉
如果您不喜欢自己编写所有代码，并且认为 Apache Airflow 对您的需求来说太复杂，那么您可能会发现 Mara 是您 ETL 需求的最佳选择。您可以将 Mara 视为编写纯基于 Python 的脚本和 Apache Airflow 之间的轻量级中间地带。为什么？
这是因为 Mara 基于一套预定义的原则，可以帮助您创建 ETL 管道。这些假设解释如下:
● 使用 Python 代码创建数据集成管道。
● PostgreSQL 将作为数据处理引擎。
● 一个 web UI 将用于检查、运行和调试 ETL 管道。
● 节点依赖上游节点完成，无数据依赖或数据流。
● 命令行工具将被用作与数据和数据库交互的主要来源。
● 将使用基于 Python 多处理能力的单机流水线执行。
● 成本较高的节点先运行。
这些假设负责降低管道的复杂性，但由于一些技术问题，Mara 仅在 Linux 和 Docker 上可用。Mara 还提供了一系列工具和实用程序，用于在其 GitHub repo 上创建数据集成管道。
在这里了解更多。
10.气泡
Bubbles 是另一个基于 Python 的框架，可以用来做 ETL。但是 Bubbles 不仅仅是一个 ETL 框架，它还有更多。Bubbles 为用户提供了一组工具，可以对数据进行多种操作，比如监控、审计、清理和集成。
大多数 ETL 工具使用脚本或图形来描述它们的 ETL 管道，而不是气泡。在其核心，Bubbles 使用元数据来描述其管道，使管道设计者的任务变得容易得多。
使用 Bubbles 的最好理由之一是它是技术不可知的，这意味着您不必担心如何使用数据存储，您可以简单地专注于以您选择的格式获取数据。由于其技术无关性，Bubbles 提供了一个抽象的 ETL 框架，可以在各种系统上快速使用，以执行所有必要的 ETL 操作。
在这里了解更多。
结束…
如今，现代企业更加依赖数据来做出明智的决策，ETL 工具在这一过程中发挥着至关重要的作用。它们不仅能帮你节省时间，而且非常经济实惠。鉴于 ETL 工具日益增长的重要性，它已经成为当今企业的必需品。
现在市场上有很多 Python ETL 工具，它们是用一系列编程语言构建的，可以满足您所有的 ETL 需求。请记住，并不是所有的 ETL 工具都是一样的，虽然其中一些工具可能提供了丰富的特性集，但其中一些工具可能非常简单。
认识你的作者
克莱尔 D 。是 Digitalogy 的内容制作师和战略家，他可以将你的内容想法转化为清晰、引人注目、简洁的文字，与读者建立强有力的联系。
想要擅长时间序列预测吗？预测天气。
了解时间序列的组成部分
对于一个最初来自经济学背景的人来说，我会花一些时间来建立可以预测天气模式的模型，这可能看起来很奇怪。
我自己也经常质疑这一点——但这是有原因的。温度模式是最容易预测的时间序列之一。
时间序列组件
当时间序列被分解或分解成单个元素时，序列由以下部分组成:
- 趋势:时间序列在一段重要时间内的大致方向
- 季节性:在时间序列中频繁重复的模式
- 随机:时间序列中的随机波动
仔细想想，温度数据的组成非常明显。
至少在北半球的大部分地区，总的趋势是气温随着夏季月份的到来而上升，随着冬季月份的到来而下降。
例如，这是爱尔兰都柏林机场 2015-2018 年的*均温度波动，来源于气象局:
资料来源:RStudio
分解这个时间序列直观地揭示了以下内容:
趋势
资料来源:RStudio
季节性
资料来源:RStudio
随机
资料来源:RStudio
正如我们在上面的图表中看到的，季节模式清楚地显示了一个年度周期。例如，自相关函数揭示了每 12 个月温度数据的强相关性。这是有道理的，因为显而易见的是，一月份的气温将与其他年份记录的一月份气温表现出最大的相关性。在比较七月的温度时也是如此，以此类推。
资料来源:RStudio
对这些组成部分的直观理解有助于更好地理解它们在其他时间序列中的应用。
例如，航空乘客数量的季节性模式(至少在新冠肺炎之前)是，夏季几个月航空乘客较多，冬季乘客总体较少。下面是一个乘客数量波动的例子，它是使用来自旧金山开放数据的数据生成的:
来源:Jupyter 笔记本输出
领域知识对于识别时间序列的组成部分也很重要。例如，专门从事能源市场分析的数据科学家会直觉地知道，商业用电量往往遵循每周一次的模式，而不是每年一次的季节性模式。也就是说，消费倾向于在高使用率的日子(如星期一)达到峰值，而在周末显著下降。
首先可以预测一个时间序列吗？
很多时候，那些时间序列分析的新手会试图预测数据中存在大量内在随机性的序列。
例如，股票价格往往遵循非常随机的模式。这些时间序列通常是由周期性而不是季节性驱动的，因此时间序列中的波峰和波谷不会以特定的间隔出现。
因此，尽管整体趋势可能会给出股票方向的长期观点，但直接预测时间序列仍然非常困难，因为时间序列中的模式通常不会重复。
也就是说，很多时候，人们可能试图使用 ARIMA 模型来预测股票价格，而没有花足够的时间来理解时间序列的组成部分。我也为过去犯的这个错误感到内疚。
此外，值得注意的是，温度数据不会受到人为干预的影响。然而，许多时间序列可以(包括股票价格)，因此，过去的数据无法解释这些干预。
使用一个单独的例子，假设我试图使用谷歌的社区移动数据来尝试预测一个主要城市在六个月内的移动趋势。
这种预测毫无意义，因为它完全依赖于时间序列本身以外的因素，如政府封锁、新冠肺炎流通等。
结论
严格来说，在预测时间序列时，不必从天气模式开始。但是，您应该从一组易于预测且具有可预测趋势和季节性模式的数据开始。
人们犯的一个大错误是试图预测一个具有许多内在随机性的时间序列。你不仅无法对这些数据做出可信的预测，而且像自相关函数这样的术语对你来说也没有直观的意义。
预测一个不受外部因素影响的时间序列(温度模式是极少数因素之一)将让你更好地理解为什么诸如自相关、*稳和其他因素具有理论相关性。事实上，当需要预测更复杂的数据(如销售数据)时，您将能够更好地理解 1)模型的理论工作方式，以及 2)使用不同时间序列模型对数据的优缺点。
免责声明:本文是在“原样”的基础上编写的，没有担保。它旨在提供数据科学概念的概述，不应被解释为专业建议。本文中的发现和解释是作者的发现和解释，不被本文中提到的任何第三方认可或隶属于任何第三方。
搞定你的面试，获得一份数据科学家的工作:成为异类
达里娅·皮姆金娜在 Unsplash 上拍摄的照片
这不是一篇关于改善你求职过程的博客文章(读这篇文章，而不是)。
这是一篇关于我们(我和我的同事 Joshua Loong 和 Lewis Davies 作为百思买高级分析部门的招聘经理)在寻找应用数据科学家的博文。如果这能帮你找到工作，那太好了。更充实的职业，令人惊叹。但是完全透明:我写这篇文章是希望提高我们招聘渠道中候选人的质量。
“寻找数据科学家，这是一个坚实的*均水*。”
你听过有人这么说吗？号码
我们都希望找到顶级异常。我在 RJMetrics(一家被 Magento/Adobe 收购的商业智能软件初创公司)和 Best Buy Canada(一家 F500 全渠道零售商)招聘数据科学家和分析师的经历都是如此。我们在大海捞针。在同龄人中排在前 95%的人。
但是 KPI 是什么呢？什么是“好？”在众多编写 python、能够清理数据、运行回归和开发应用程序的人中，是什么定义了最佳候选人？
在招聘能够使用数据解决实际业务问题的应用数据科学家的背景下(比如自动化、优化)，我和我的同事们对以下三种能力印象深刻:
“我是唯一一个能够…”
#1 生成我自己的公关
一个独角兽数据科学家应该能够清楚地说明业务问题，它如何与组织或战略目标保持一致，为什么建议的解决方案是最好的，以及预期的影响。都是外行人说的。不要依赖产品经理来管理利益相关者和客户，
我们采访了许多分析专家，他们能够将技术需求转化为分析和模型，但从来没有问过自己为什么他们要这么做。为什么今年建立财务预算预测模型比预测销售人员绩效更重要？
我们认为数据科学家应该对他们的工作有发言权:优先考虑为组织带来最大价值的项目和任务。这从理解为什么我们被要求处理一个给定的计划开始。它确保我们致力于最有价值的项目(收入或成本节约潜力)。成功是什么样子的？首席执行官不断向您询问插入数据科学以提高利润的新方法。
我们也遇到过数据科学家不能用外行的术语说话，导致利益相关者不理解我们是如何工作的。当我们的老板错过最后期限时，这尤其令人沮丧，因为新的发现需要重要的模型改变，但他们不知道为什么。
如果你能直接与高管沟通，就更容易推后不可行的需求和时间表。解释为什么 X 问题太难建模，错误的做法，或者为什么 Y 方法可能需要更多时间。
因此，当企业要求创建一个应用程序来个性化 web 体验时，我们首先要问为什么:
换句话说，创建一个类似 mad lib 的执行摘要:
“我们的业务面临着 _________________ 的挑战，因此我们正在开发一个 _______ 的解决方案，我们预计它将产生 _____ 的影响。我们使用了以下高级分析方法和现代分析工具 ____，包括现在可重复用于 ______ 的组件和基础架构。老办法是 __。新的方式更好，因为 ____”
如果你被挖掘来领导越来越多的数据科学项目，并获得更多的资源和自由，不要感到惊讶。如果领导理解你，他们会相信你的判断。
#2 做你自己的魔鬼代言人
表明你已经检查了你的盲点。
数据科学面试流程通常涉及一个项目组件，候选人在其中解决一个分析问题。可能会涉及到数据清理、ETL 和建模组件。大多数候选人在所有这些方面都做得不错，但在两个关键领域有所失误:
- 他们未能概述其模型的限制和警告(即，为什么他们的模型在众多其他选项中是“最好的”)，以及
- 忘记提出对未来迭代的改进(如果您可以访问其他数据集或有更多时间，您会尝试什么？).
从来没有“完美”的模型，我们在构建它的时候都会想到局限性和替代方案。然而，许多候选人未能传达这些信息。
是的，强调为什么我们刚刚提出的模型可能不是最好的是很可怕的，因为它可能会使它完全无效。但另一种选择要糟糕得多:在不清楚如何改进的情况下使用次优模型。
在百思买，持续改进和建设性反馈是推动我们发展的核心价值观。整个技术组织使用敏捷和精益原则。不怕提出半生不熟的想法并与同行辩论的候选人最受欢迎。所以，继续前进，展示你可以扮演我们自己的魔鬼代言人；展示批判性思维。展示你是一个很好的资源来激发想法。
这里有一篇概述批判性思维策略的博客文章。我强烈建议将列出的一些问题作为日常产品开发的一部分。我还想暂停一下，推荐数据科学家们读读《思考的快与慢》，这本书是关于两位获得诺贝尔奖的心理学家对人类非理性和偏见的研究。这本书真的帮助我在解释数据时更加意识到偏见。
#3 在此想象和塑造数据科学的未来
我认为团队中的每个人都在塑造公司未来的过程中扮演着关键角色。不仅仅是首席执行官或副总裁。这意味着认可公司的愿景(例如，在百思买，我们致力于 通过技术 )和来丰富人们的生活，并思考我们如何才能朝着这个目标前进。给我们自己发挥创造力的空间。
在数据科学的背景下，这可能是寻找新的工具或开发流程，甚至是能够更容易地将机器学习部署到生产中的团队结构，或者更快地实现 MVP，等等。什么可以改善我们作为数据科学家的生活，以及受益于优化体验的客户的生活？
无论你如何展望数据科学的未来，请发挥领导作用并塑造它。与未来的雇主分享你的愿景，为什么它让你兴奋/吸引你，以及我们可以实现的一种方式。不一定是对的。目标是证明你在考虑明天。因为普通和中等数据科学家太忙于对现在做出反应，用没有价值的有趣事实创建报告。
不要埋没你的成就
关于简历的最后一点。如果你避开只描述做了什么的要点，通过屏幕的几率会高得多:例如“使用 DBT 设置 ETL 管道……”
相反，强调你取得的成果/影响:例如“通过使用 DBT 建立 ETL 管道，生产力提高了 30%……”所以从星形中的 R 开始。
没有人想要一份完美的简历，但是让我们向雇主展示你不仅仅是为了工作而工作。你是一个有目标的数据科学家:你的存在是为了最大化业务价值。因此，庆祝你所带来的影响。为你庆祝。
想学数据科学？先学编码
在过去几年与有抱负的数据科学家共事后，我的建议是
由 Unsplash 上的 Karsten Winegeart 拍摄
几年来，我一直在教授硕士级别的数据科学，并在训练营指导有抱负的数据科学家。与那些试图进入该领域的人一起工作很棒——我可以和他们一起学习，这有助于我发展解释我每天使用的工具的能力。看着人们成长为初出茅庐的数据科学家也很有意义。
这些年来，我看到了足够多的学生，对谁会成功有了很好的认识。我这里的“成功”指的是相当广泛的——那些能从课程中学到很多东西，并在工业界找到一份好工作的人。
这种感觉与虔诚或某种原始智力没有什么关系。这都与他们开始训练的技能有关。
让我们快速浏览一下数据科学家可能需要的一些技能:
- 编码
- 统计数字
- 机器学习
- 各种专业化(例如，大数据工具、数据可视化等。)
对于任何数据科学家来说，至少掌握其中一些技能是必不可少的。但是有一点在刚开始时尤为重要。
有抱负的数据科学家表现出色和努力奋斗的区别主要在于编码技能。
大多数好的数据科学课程都涉及学习抽象的东西，即方法背后的理论和数学，然后有机会将其付诸实践。将其付诸实践意味着编写代码，要么实现您所学的内容，要么使用已经实现它的工具。将事情付诸实践有助于巩固对概念的理解。
如果你纠结于代码，将一个概念付诸实践是不会有启发性的。相反，这将是令人沮丧的，学习将是如何让你的代码做你想要的。很难同时学习两件相互依赖的事情——如果你不理解代码，也不完全理解它在实现什么，你就不会从编码练习中获得太多。
拥有统计学的基础也很重要，因为它提供了上下文和对许多机器学习概念的理解，但在我看来，它远不如编码那么基础。虽然数学和统计有助于提供更深层次的复杂性，但大多数机器学习算法本质上是非常直观的。描述它们并不难，因为它们的工作原理显而易见。如果你能让学生理解算法背后的直觉，具体的数学可以等等——但是能够编写使用该算法的代码对于他们真正理解它是必要的。
如果你不明白你正在使用的任何工具是怎么回事，你就不会提高你对理论的理解。
我不想听起来像是在宣称其他技能不重要。但是，如果我有一个对数据科学完全无知的人想要闯入，我的建议将是先获得非常舒适的编码。通过理论和实践相结合的方法，其他的东西也可以随之而来。但是如果一个学生在代码上挣扎，那么其他的事情也会是一场挣扎。
你可能感兴趣的其他故事
[## 为什么大多数数据科学组合项目没有得到招聘经理的认可
towardsdatascience.com](/why-your-data-science-portfolio-project-sucks-208ee830ad1b) [## 让你的数据科学简历脱颖而出
towardsdatascience.com](/making-your-data-science-resume-stand-out-119d2eb37d8c)
想转行做数据科学？咬紧牙关
将职业生涯转向数据科学具有挑战性，但肯定是可能的。
斯文·米克在 Unsplash 上的照片
你已经研究数据科学有一段时间了，并决定这是适合你的职业。这很好，大多数人都在决策过程中挣扎，从来没有走那么远。然而，显而易见的问题是:“我如何转行到数据科学？”你也会意识到我们每个人都有不同的背景；可能是学术上的，经济上的，或者个人的。因此，当谈到你的职业改变时，没有什么灵丹妙药。
你可以从当前的数据科学家和志同道合的人那里获得很多信息。但是请记住，转行从事数据科学绝对不同于已经发展成为数据科学家的角色。因此，在你的职业转变过程中，学习并与经历相似的人分享经验可能是你能做的最好的事情之一。为此，我决定写这篇文章来分享我迄今为止的经验。
1。管理你的期望
我知道这不是你想先读的，但你会一直得到我诚实的意见。所以给你:
“如果人们知道我是如何努力获得成功的，这看起来一点也不美妙”——米开朗基罗。
转行很简单，但可能非常困难。例如，一些顶级的研究生课程只在每年的九月和十月开始。假设你的新年决心是注册一个硕士学位。在这种情况下，你可能要等到 12 月份才能申请，并且只能在下一年开始招生。也就是等了将*两年才开始读硕士。
此外，学习本身是一个缓慢的过程。我写过关于如何利用神经科学研究的见解来提高你的编码技能的文章。尽管如此，掌握大多数技能仍需要数年时间，尤其是对那些来自完全不相关背景的人来说。这就引出了我的第二点…
2。练习，练习，练习
你必须投入工作。在接下来的几年里，纪律应该是你最好的朋友。否则，你会花更长的时间来达到你的目标，并要求你再次管理你的期望。改变你的思维模式:你不是在学习如何编码；你将成为一名程序员/数据科学家。所以，像一个人一样思考和行动。
以我的小经验，编码需要几个小时(很多小时)的练习，就像弹钢琴一样。首先，你必须熟悉语法(在我的例子中是 Python ),这在一开始是不自然的。大多数时候不会。所以，你应该每天练习。程序员会怎么做？答案很简单，开始编码就行了。
第二，尝试不同的学习方法:看视频应该是你最后的手段。所以，通过阅读、理解和尝试复制别人的代码来练习。你可以使用 Kaggle 和 GitHub 来找到写得好且简洁的代码，不管你的水*如何。还有，业余时间看数据科学方面的书。你可以完全避开技术书籍或教科书，寻找不同的类型。世界排名第一的棋手芒努斯·卡尔森，不下棋的时候，他就在读关于象棋和历史上著名棋手的书【2】。也就是说，这里有一些开始的想法:
https://www.goodreads.com/book/show/39813845-the-art-of-statistics https://www.goodreads.com/book/show/28186015-weapons-of-math-destruction?ac=1&from_search=true&qid=yedjexfopY&rank=1
3。该系统不是为职业变化而设计的
如果你也过了 30 岁，那么你将面临一些艰难的挑战。对于已经有工作的人来说，很少有资金或奖学金。显然，企业、机构和政府会优先资助更年轻的候选人(至少在英国是这样)。因此，开始攒钱支付学费、课程和书籍。
如果你想转行去脸书、亚马逊、网飞或谷歌(简称方)等公司工作，有很多先决条件。其中一些先决条件甚至可能包括博士学位。因此，你将不得不再次管理你的期望，存更多的钱。当转到一个不同的领域时，公司不会在意你过去的经历。跨国公司有严格的招聘流程，不会因为你比一般应聘者年龄大而破例。所以，提前计划，确保你尽可能多地了解实现目标需要什么。
关于“系统”的最后一点招聘经理通常不喜欢雇佣比他们年长的人。即使你的简历上可能没有你的出生日期，也很容易猜出你的年龄，只是不会邀请你参加面试。所以，一定要建立良好的关系网，结交新的朋友，并与和你志同道合的人取得联系。每个人都有大量的工作机会。
4。走人迹罕至的路
你必须做些不同的事情。为什么？让我们假设:
- 您比数据科学学生/候选人的*均年龄要大。
- 你没有足够的积蓄在短期内资助自己读完硕士学位。
- 你没有很强的定量背景(例如工程或物理)，因为你来自一个完全不同的背景。
- 你全职工作，甚至可能有自己的家庭。
- 你真的想去美国或英国学习。
如果你决定走和别人一样的路，那你就陷入了困境。如果你选择等待一个完美的时刻，当我上面列出的所有事情——不知何故——都被整理好的时候，那么你将永远不会成功。你必须忍受并尝试完全不同的东西:
- 试着自愿加入研究小组，这样你就可以处理一些数据了。
- 从Y Combinator【4】学习如何像企业家一样思考。
- 找到你可以通过自动化解决的问题。思考与你当前行业或职业相关的问题。
- 邀请一些同事创业(如果失败了，再尝试，再尝试)。
- 写一篇关于数据科学或者人工智能的博客。
- 尝试搬到不同的城市。蒙特利尔和巴黎正在成为人工智能的全球中心。
最后，你可能听说过，不是每个人都同意进行训练营，因为这可能是浪费金钱。我恭敬地表示不同意，认为“视情况而定。”为什么如果你意识到走预先设定好的路(即硕士学位、攻读 GRE/GMAT、竞争性博士课程、实习、第一份工作等等)，并不适合你。然后，一个为期九周的训练营，挤满了志同道合的人，带着合作的态度和企业家精神，听起来是个好主意。也许，因为你的生活与大多数数据科学学生不同，少走的路可能是最好的一条。
结论
感谢阅读。这里有一些你会喜欢的文章:
参考文献:
【1】https://www . goodreads . com/quotes/115896-if-people-know-how-how-hard-I-had-to
【2】https://en . Wikipedia . org/wiki/Magnus _(2016 _ film)
【4】https://www.ycombinator.com/
想在数据科学领域赚更多的钱？不要成为管理者，要成为领导者
行业笔记
领导数据科学团队的 4 项基本技能
图片来自 PublicDomainPictures 来自 Pixabay
对许多人来说，在数据科学领域赚更多的钱意味着进入管理层。
事实上，一项研究显示经理“价值 1.75 名员工”
这一统计表明，经理的收入几乎是非管理人员的两倍。尽管工资差异因行业和职位类型而异，但有一点是明确的:经理通常会得到更多的报酬。
但获得晋升不一定与管理有关。更关键的是，钱不在管理上。钱在领导身上。
管理是一种领导角色吗？绝对的。你应该学习如何成为一名优秀的经理来获得晋升吗？不一定。
在本文中，我想介绍我从开发人员到经理再到数据科学团队主管这些年来学到的一些顶级技能。
TLDR；学会成为数据科学领导者，而不是数据科学管理者。
有没有见过这样一个迷因，它展示了一个象形文字般的角色坐在一个“任务”盒子上，被其他象形文字般的角色拉着，看起来绑在一起？在图像中，有一个箭头指向标签为“boss”的盒子顶部的字符
该图像的正下方是一个类似的图像，但是没有人坐在盒子上面。相反，有一个箭头指向前面的字符，标签为“leader ”,因为该字符指向前方。
我喜欢这个形象，因为它说明了领导的价值高于管理。换句话说，领导者不仅要管理，还要努力指明方向。由于其复杂性，这种品质对于数据科学领导者来说更加重要。
但是形象并没有告诉我们如何成为领导者。它没有告诉我们需要什么技能。它没有为我们提供图像传达给我们的成千上万个词中最关键的 4 个词。所以我会努力的。
数据科学家的 4 项领导技能
1.思考概念，而不是工具和技术
为了有效地领导数据科学团队，理解您作为开发人员所处理的工具和技术与高阶概念的关系是至关重要的。例如，像 Google BigQuery 这样的数据库只是存储某些类型信息的简单方式。概念是存储，技术是 BigQuery，工具是 SQL。
领导团队需要我们调整我们的思维来设定概念方向，并理解可以支持概念方向的工具和技术正在讨论中。这有点像学者如何使用理论来发展假设，以帮助测试他们的理论。
在商业中，理论是如何为商业问题带来更多商业价值的概念模型。领导者帮助建立这些概念模型，而开发人员致力于各种假设，将这些模型变为现实。假设的测试要求我们使用可用的特定工具和技术，因此优秀的开发人员擅长应用这些工具/技术并将它们联系在一起，而领导者则确保他们符合最终带来价值的概念方向。
我把它看作一种漏斗，概念模型在顶部，假设在中间，所有这些最终导致生产。
漏斗底部是操作人员。那些知道一套独立的工具和技术，可以帮助把工作的假设变成商业规模的实际产品的人。
数据科学领导者了解这些部分，同时不断确保它们的开发方式与她/他/他们设定的概念方向一致。
作者图片
2.沟通
当领导者看到他们的概念模型变得栩栩如生并带来商业价值时，他们会感到兴奋；当数据科学家修复错误、实现新的模型代码并训练精确的模型时，他们会感到兴奋。重点是？兴奋很重要，情绪很重要，即使在数据科学中也是如此。
但是没有解释的结果没有什么商业价值。领导者不仅帮助创造商业价值，而且他们还通过团队的激励传达这种价值。换句话说，领导者帮助翻译数据科学成果，帮助非数据科学家理解他们的产品带来的商业价值。
不幸的是，对于数据科学来说，能够有效地传达让数据科学开发人员兴奋的商业价值是令人沮丧的困难。这种困难的部分原因是，大量的开发工作都是在实验中度过的(参见上面漏斗中的假设阶段)。此外，解释我们能够创建数据的图形表示以提取图形属性作为特征来提高模型准确性是多么酷，就像对业务利益相关者说克林贡语一样。
因此，与其他团队相比，有效沟通对于数据科学领导的重要性对于数据科学团队的成功更为重要。这意味着数据科学的领导者甚至不想解释他们的开发人员对什么感兴趣。相反，领导人会等待集体兴奋降温。他们反思围绕概念模型的执行而建立的情感，然后他们交付该价值的有效商业翻译。
作者图片
3.连接到 KPI
商业利益相关者看重的到底是什么？他们重视关键绩效指标或 KPI。
你问什么是 KPI？KPI 到底是什么取决于具体的业务。也就是说，每个企业都有一些用美元定义的 KPI。但是知道 KPI 是什么只是成功的一半。
有效传达数据科学的价值意味着知道如何将数据科学成果与企业重视的 KPI 联系起来。理想情况下，在设定概念方向时，这些都被确定或至少被广泛定义(见第 1 点)。
因为数据科学很少产生最终用户直接交互的解决方案，所以领导者还必须了解在数据科学团队之外需要采取哪些步骤来与业务部门进行适当的沟通，还必须有谁参与将数据科学输出与将确定业务价值的特定 KPI 联系起来。
4.支持计划
随着概念模型的确定、沟通技巧的增强以及可转化为 KPI，领导者还必须知道需要什么资源来支持他们的产品。在早期，从数据科学实验中获得的见解可能足以证明其对企业的价值，因为企业仍在试图理解他们最初是如何获得这种见解的。随着领域的发展、团队的壮大和薪水的上涨，数据科学领导者在实施团队工作方面面临越来越大的压力。
因此，数据科学的成果必须嵌入业务直接受益的业务产品中。这些嵌入可以是改善用户体验的应用程序，也可以是帮助员工提高效率的工作流。不管应用程序如何，这些数据科学成果现在都在与生产环境交互。
这意味着数据科学产品必须遵守为生产环境设置的业务策略、服务级别协议和安全协议。因此，对于数据科学领导者来说，了解 DevOps 以及在真实生产环境中支持其产品所需的资源变得越来越重要。这一新要求的重要性可以从企业对 MLOps 专家不断增长的需求中看出。MLOps 专家了解如何将数据科学家的工作与生产软件系统的需求联系起来。数据科学领导者必须知道如何根据运营团队的要求管理他们的开发团队，并为开发人员提供充分的计划，以支持他们已经投入生产的产品。
说到底，当经理远不如当领导有价值。在这里，我提供了一些关于我在数据科学领导生涯中已经学到(并且还在学习)的关键技能的想法。一如既往，我期待您的想法、反馈和想法。
比如参与学习更多关于数据科学、职业发展或糟糕的商业决策的知识？加入我。
对于性能更好的模型，不要未经检查就假设数据是独立的
关注数据中的自相关可以帮助您构建更好的预测模型
Ehimetalor Akhere Unuabona 在 Unsplash 拍摄的照片
首先，一个小测验。
在下面的两个例子中，报告的准确性可信吗？
- Shivram 想到了一个绝妙的主意，仅仅通过 iPhone 的移动来预测心率。他从数千名同意的用户那里收集 iPhone 动作的时间同步数据和 Apple watch 的心率数据。然后，他将数据随机一秒一秒地分成训练集、验证集和测试集。在他对自己的模型感到满意之后，他报告说，他能够从 iPhone 的运动中预测心率，在测试集上的准确率高达 98%!
- Abhilash 希望利用卫星图像来寻找森林的位置。他获得了一些卫星图像和人类绘制的森林地理位置图的训练数据。然后，他将像素随机分成训练集、验证集和测试集。在他对他的模型满意之后，他报告他的测试准确率为 99%！
在上述两种情况下，报告的准确性可信吗？
不要！
在这篇文章中，我们将了解为什么他们不是。我们还将学习一些基本的预处理原则，人们可以遵循这些原则来避免将来出现这样的陷阱。
为什么要关心数据是否是 id？
独立同分布数据(i.i.d .)在预测设置中有许多好的特性在预测设置中，知道一个数据点并不能告诉你关于另一个数据点的任何事情。当我们为模型训练拆分数据时，必须知道数据是否是独立的。
将数据分为训练集、验证集和测试集是在监督学习设置中测试模型性能的最标准方法之一。即使在我们进入建模之前(这在机器学习中几乎受到了所有的关注)，不关心上游过程，如数据来自哪里，它们是否真的相同，以及我们如何分割它们，都会对预测的质量产生影响。
当数据具有高自相关性时，这尤其重要。点之间的自相关仅仅意味着一个点上的值与其周围的值相似。以温度为例。预计任何时刻的温度都与前一分钟的温度相似。因此，如果我们希望预测温度，我们需要特别注意分割数据。具体来说，我们需要确保在训练、验证和测试集之间没有可能夸大模型性能的数据泄漏。
模型性能会因信息泄露而被夸大到什么程度？
看完以上，很自然的会问，这是一个足够重要的问题，值得我去关心吗？通过一个高度自相关数据的例子，我们会看到答案当然是肯定的！我们将把这个例子分成两部分。首先，我们将数据随机分为训练集和验证集，并在验证集上实现非常高的准确性。然后，我们将使用分层随机抽样来分割数据，从而减少信息泄漏。然后，我们将看到同样的模型如何具有几乎为零的精度。
交互式示例
如果您希望以交互方式了解这个示例，您可以使用这个 colab 笔记本。
我们先导入相关的包。
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import sklearn.model_selection
import sklearn.linear_model
import sklearn.ensemble
我们来做一些响应变量自相关性高的合成数据。
# number of examples in our data
n = int(100*2*np.pi)
# Seed for reproducebility
np.random.seed(4)
# make one feature (predictor)
x = np.arange(n)
# make one response (variable to predict) which has high autocorrelation. Use a
# sine wave.
y = np.sin(x/n*7.1*np.pi)+np.random.normal(scale = 0.1, size = n)
# merge them into a dataframe to allow easy manipulation later
df = pd.DataFrame({"x":np.array(x), "y":np.array(y), "y_pred":np.nan})
# visualize the response versus feature
sns.set(style = "ticks", font_scale = 1.5)
sns.regplot(x="x",y="y",data=df)
数据的随机分割
让我们将数据随机分为训练集和验证集，看看模型的表现如何。
# Use a helper to split data randomly into 5 folds. i.e., 4/5ths of the data is chosen *randomly* and put into the train set, while the rest is put into# is chosen *randomly* and put into the train set, while the rest is put into# the validation set.kf = sklearn.model_selection.KFold(n_splits=5, shuffle=True, random_state=42)# Use a random forest model with default parameters.# The hyperaparameter of the model are not important for this example because we# will use the same model twice- once with data split randomly and (later) with# data split with stratificationreg = sklearn.ensemble.RandomForestRegressor()# use k-1 folds to train. Predict on the kth fold and store in the dataframefor fold, (train_index, test_index) in enumerate(kf.split(df)):reg.fit(df.loc[train_index, "x"].values.reshape(-1, 1), df.loc[train_index, "y"])df.loc[test_index, "y_pred"] = reg.predict(df.loc[test_index, "x"].values.reshape(-1, 1))# visualize true y versus predicted yfig, ax = plt.subplots(figsize = (5,5))sns.kdeplot(data=df, x="y_pred", y="y",fill=True, thresh=0.3, levels=100, cmap="mako_r",ax=ax)ax.set_xlim(-2,2)ax.set_ylim(-2,2)ax.set_xlabel(r"y$_{\rm predicted}$")ax.set_title("Exaggerated predictive ability\nassuming data is i.i.d.")r2 = sklearn.metrics.r2_score(df.y, df.y_pred)ax.annotate(f"R$^2$ = {r2:0.2f}", xy =(0.95,0.95), ha = "right", va = "top", xycoords = "axes fraction")print(f"[INFO] Coefficient of determination of the model is {r2:0.2f}.")
假设数据是独立的，夸大了预测能力(但实际上不是)。
哇哦。！我们实现了 97%的 R2！似乎我们的模型在模拟正弦响应函数方面做得非常出色。
但是……模型真的能够理解 x 和 y 之间的响应函数吗？或者它只是作为一个最*邻插值？换句话说，模型只是通过记忆训练数据，输出最接*训练样本的 y 值来作弊吗？让我们通过使模型难以作弊来找出答案。
数据的分层分割
现在，我们将沿着 x(特征)轴将数据分成 5 个块，而不是随机分割数据。然后，我们将把 4 个数据块放入训练数据，1 个数据块放入验证集。
通过沿着自相关特征对数据进行分层，我们尊重了数据的非独立身份性质。
让我们看看模型是否有同样的精度。
# How many chunks to split data in?
nbins = 5
df["fold"] = pd.cut(df.x, bins = nbins, labels = range(nbins))# Split the data into training and validation data based on the chunks.
# Train on 4 chunks, predict on the remaining chunk.
for fold in sorted(df.fold.unique()):
train_index = df.loc[df.fold!=fold].index
test_index = df.loc[df.fold==fold].index
reg.fit(df.loc[train_index, "x"].values.reshape(-1, 1), df.loc[train_index, "y"])
df.loc[test_index, "y_pred"] = reg.predict(df.loc[test_index, "x"].values.reshape(-1, 1))
# Visualize true y versus precited y.
fig, ax = plt.subplots(figsize = (5,5))
sns.kdeplot(
data=df, x="y_pred", y="y",
fill=True, thresh=0.3, levels=100, cmap="mako_r",ax=ax
)
ax.set_xlim(-2,2)
ax.set_ylim(-2,2)
ax.set_xlabel(r"y$_{\rm predicted}$")
ax.set_title("True predictive ability")
r2 = sklearn.metrics.r2_score(df.y, df.y_pred)
ax.annotate(f"R$^2$ = {r2:0.2f}", xy =(0.95,0.95), ha = "right", va = "top", xycoords = "axes fraction")
print(f"[INFO] Coefficient of determination of the model is {r2:0.2f}.")
同一模型的真实预测能力
现在，我们看到我们的模型具有低于随机的性能(旁注:不知道决定系数怎么会是负的？在这里阅读更多)！这表明，我们的初始模型并没有真正使用 x 作为 y 的信息预测器，而只是从训练集中找到最接*的 x，并吐出相应的 y。因此，如果我们不小心数据中的自相关，我们可能会夸大模型性能。
更糟糕的是，我们可能错误地推断出 x 的重要性，并进而得出几个科学结论。然而，我们的模型仅使用 x 来插入/记忆响应。不幸的是，这不是一个虚构的例子。这篇论文表明，地球科学中试图预测植被生物量的几篇论文(类似于本文开头 Abhilash 的例子)都被这个问题弄得千疮百孔。
结论
拆分数据可能会产生巨大的后果。如果有任何证据表明数据是自相关的，或者更一般地说是非同分布的，则分层分裂或使用信号分解来解相关数据的其他技术可能是有用的。至少，在开始建模之前将数据可视化是非常有益的。因此，下次你遇到 Shivram、Abhilash 或其他任何声称在随机拆分他们的数据后实现了非常高的建模性能的人时，你已经准备好帮助他们提出更好的预测模型，而不会夸大模型性能。
想成为一名杰出的数据科学家吗？开始练习这些非技术性技能
仅仅擅长编码是不够的
成为数据科学家的很大一部分是量化的。一个人需要擅长数字，相当精通编码，并且能够分析图表和模式。这就是为什么大多数数据科学家通常来自数学和统计、工程和计算机科学等技术背景。
尽管如此，在作为一名数据科学家工作了几个月后，我意识到不仅仅是擅长数字，真正让一个人脱颖而出的是非技术技能。
当然，拥有强大的技术基础是至关重要的，但拥有更软的技能不仅会让你成为一个更全面的人，更重要的是提供额外的优势，帮助你最终获得下一份数据科学工作或获得晋升。
虽然发展这些技能可能不像报名参加在线编程课程那么简单，但你仍然可以采取一些可行的步骤和思维模式来提高这一特定领域的水*。
在这篇博文中，我想强调你应该注意的 5 个非技术性技能，并概述你可以采取的发展这些技能的实际步骤。
1.注意细节
有趣的是，关注细节是我曾经放在简历上的短语之一，只是因为它听起来很酷，但实际上，我并不完全知道它的意思——直到今天。
嗯，对细节的关注可以采取各种不同的形式，但其核心是，确保你正在进行的一项分析或交付物是专业的、准确的，并以正确的方式传达信息。
具体来说，在数据科学中，这可能是检查数据错误和执行健全性检查的尽职调查。例如，检查缺失的字段、不合理的数据(如年龄为 500 岁的客户)以及确保详尽类别的百分比总和为 100%。
除了数据检查之外，在创建幻灯片或设计仪表板时，关注对齐、颜色一致性、拼写错误、可视化选择、用户体验等也很重要。
虽然对你来说这可能听起来很无聊，但对细节的高度关注不仅通过你交付的工作质量建立了你作为分析师的信誉，更重要的是，它防止了与客户陷入尴尬的境地。你最不希望的就是客户在你之前发现一个巨大的错误。
至此，我将以最*收到的一条关于关注细节的重要性的建议来结束这一部分。
幻灯片的 80%可以在 20%的时间内完成，但剩下的 20%将占用 80%的时间。
这当然就是臭名昭著的帕累托原理，你可以在这里阅读更多关于的内容。
2.沟通
几个月前，我在博客中写了一篇关于沟通技巧的文章。在这里，我想进一步阐述这个观点，并重申那篇文章中提到的一些观点。
拥有良好的沟通技巧不仅仅是数据科学的专利，坦率地说，任何其他专业工作环境都是如此。工作场所的交流可以分为两种:口头交流和书面交流。
无需深入研究太多细节，两者之间的主要区别在于传输速度和记录证明。
口头交流传播速度很快，但没有记录证明。因此，它更常用于内部会议或客户会议，在这些会议中，你只是简单地向团队提供最新情况，或者需要对某个特定想法的即时反馈。
另一方面，书面交流的传输速度很慢，但可以提供记录证明。这可以是电子邮件、松散消息，甚至是代码中的注释。
在协作环境中工作时，拥有良好的沟通技巧会大有帮助。它不仅能提高或降低团队的效率，还能帮助说服其他人在项目过程中追求一个想法。
就我个人而言，在我职业生涯的早期，我一直在努力解决这个问题，因为我太习惯于从事自己的数据科学项目，而不必与其他人合作。但是就我现在所知道的，我会强烈鼓励任何认真从事数据科学家工作的人尽早开始练习这些技能。
这实际上看起来像什么？嗯，这可能是在编码时养成写评论的习惯，在执行探索性分析以总结您的发现后写一份总结报告或模拟电子邮件，开始一个简化复杂数据科学主题的博客，参加公共演讲课程等等。
正是这些小细节，随着时间的推移，会让你成为一个更有效的沟通者和数据科学家。
3.对客户感同身受
我在大学期间做学生顾问时学到的一件重要事情就是从客户的角度思考问题。
虽然你们中的一些人可能不渴望在未来从事咨询工作，但我个人认为这种心态适用于无论你是咨询领域的数据科学家还是纯产品分析人员。
能够站在客户的立场上，让您深入思考他们正在经历的痛点，以及如何利用数据来解决他们的问题。反过来，这可以用来制定解决某个问题的方法，也可以推动你的分析，并以增加最大价值的方式呈现它们。
例如，现在与政府客户的合作挑战着我，让我了解更多以前从未有过的政策决策，以及政府关心的问题，如医疗保健、教育、经济增长等。
因此，在获取数据和进行分析时，我在跟踪和传达会给我的客户带来最大影响的关键指标时变得更加谨慎。
总之，在做任何工作之前，想想客户会从中得到什么，然后专注于此，避免做无脑的、低影响的任务。
4.优先顺序和授权
就像你在大学期间在多项任务和考试之间周旋一样，作为一名数据科学家，你经常需要将时间分成不同的项目，当然还有项目中不同的任务。
那么，如何做到这一点呢？答案是优先化和授权。
优先化是对给定的一组任务分配相对重要性或紧迫性的过程。它意识到任务何时到期，以及完成它们各自的时间要求。
实际上，这可以包括拥有一份最新的日历，在开始一天的工作之前写下一份每日目标清单，甚至可以和你的经理谈谈，听听他或她对你应该把时间集中在什么事情上的看法。
另一方面，知道何时说不也很重要。作为一名研究生数据科学家，我认为为了向公司的其他人证明自己的价值，很容易陷入承担过多的陷阱。然而，这样做可能会导致巨大的压力，而且如果您最终没有实现最初的承诺，还会危及团队的整体进展。
因此，在承担一项任务之前，根据你目前的能力和优先顺序来评估你能承担什么。
接下来，我们有代表团。虽然作为一名刚从大学毕业的分析师，这可能不是最需要担心的事情，但仍然值得讨论一下。
随着你职业生涯的进展和你在公司的晋升，你的时间会慢慢地转移到人员和项目管理上，而不是实际上做技术工作本身。
对于负责特定项目的健康和进展的经验丰富的数据科学家或项目经理来说，委派更为重要。这是成为一名优秀领导者的关键之一。
委托可能是一个复杂的话题，我个人对此没有太多的经验，所以我在这里将轻描淡写。但本质上，有效的授权包括了解你的团队的优势和劣势，提供健康水*的支持和反馈，以及建立一个清晰的预期结果。
正确的委托可以产生令人难以置信的结果，并使项目团队像一台润滑良好的机器一样运转。
5.思想开放，不断追求知识
随着数据科学的不断变化，新的工具和技术像爆米花一样不断涌现。软件、编程语言、建模技术都在不断发展，以服务于不同的目的——要跟上这种发展是相当具有挑战性的。
然而，要成为一名优秀的数据科学家，就要有一颗好奇的心和积极的学习热情。为了在这个领域保持相关性，与最新的行业趋势保持联系以及不断扩展你的技能组合是很重要的。
幸运的是，互联网上并不缺乏资源。YouTube，DataCamp，Coursera 之类的 MOOCs，你能想到的都有。这完全取决于你是否愿意投入时间和精力去做这件事。
我喜欢把思想开放看作是拥抱一个学生的心态，不管你在职业生涯的哪个阶段，他总是在追求知识。这不仅会让你在工作场所不可替代，从而确保职业生涯的长久，更重要的是，它提升了你的价值和能力。
我个人的趣闻是，当我被指派构建一个 PowerBI 仪表板时，当时我对此毫无经验，也毫无兴趣。然而，尽管如此，我还是意识到了我可以给项目团队带来的价值，以及通过提高特定领域的技能带来的长期职业利益。
因此，除了周末跟随教程视频学习我需要知道的东西之外，我还主动向更有经验的同事寻求指导。
现在回想起来，这是一次收获颇丰的旅程，学习一些全新的东西，这一切之所以成为可能，是因为我一开始就有开放的心态和学习的欲望。
最后，现实是，我们并不总是什么都知道，这没关系，但相反，最终重要的是要有努力改进的心态。
外卖食品
- 注意细节
- 沟通
- 对客户感同身受
- 优先顺序和授权
- 思想开放，不断追求知识
不知道接下来要读什么？这里有一些建议。
https://medium.com/geekculture/70-data-science-interview-questions-you-need-to-know-before-your-next-technical-interview-ccfbd37a37b3 </10-most-important-sql-commands-every-data-analyst-needs-to-know-f0f568914b98>
如果你还不是一个媒体会员，如果你使用下面的链接注册会员，这对我和这个*台上的其他作者来说意义重大。它鼓励我们继续推出高质量和信息丰富的内容——谢谢！
https://chongjason.medium.com/membership
数据仓库中的预警系统
关于我如何以及为什么建造了 beoneer 的故事，这是一个允许我们在环境中的任何桌子上设置警告的系统。
在过去的几年里，我和 Shopify 的其他一些人一直在寻找一种在特定的桌子上设置警告的聪明方法。为什么是警告？原因很简单，正如我在这个以前的博客中解释的那样，我们花了很多时间来构建高质量的前厅数据集。也就是说，由于许多原因，这些数据集可能会随着时间的推移而开始退化。让我向你介绍一下这个问题，我们以前尝试过什么，以及我们是如何解决的。
问题是
是的，在 Shopify，我们非常关心数据集的质量，我们对所有数据集进行同行评审，尽可能地记录它们。当我们发布数据集时，它们是完美的。也就是说，我们工作在一个不断变化的环境中。然后，在某个时候，数据集质量会下降。这里有几个例子:
- 有些数据不再可用:单看起来很容易，但当它是更大数据集的一部分，隐藏在 6 个连接之下时，识别和修复就不是那么简单了。
- 原始数据的变化:你建立数据集时的假设可能会改变。有可能数据点开始返回一个新类型的值，或者在预先设定的范围之外(例如从 0 到 1)，可能以前不能为 null 的东西，现在可以为 null。
- 业务规则的变化:我们的一些数据集确实建模或复制了业务逻辑、商业合同、SLA 等。当这些契约发生变化时，我们需要修改数据集以包含新的现实。
当这三件事发生时，有两个主要步骤。首先，我们需要意识到并确定变化，其次，我们必须修复或废弃数据集。由于第一个值得关注，并且 Shopify 是很好的工具，所以我不想谈论太多。在这里我真的想重点讲第二个，因为虽然听起来很简单，但这是现实生活中的另一个故事。
每次我们遇到这种情况，我们都不得不问自己，“好吧，我们需要修理 XYZ，但是我们没有时间了。选项 A)我们删除数据集，选项 B)我们修复它”。在一个快速的头脑风暴会议后，我们不能用 A，因为它为其他资产提供动力，我们也不能用 B，因为我们没有时间去做。因此，我们最终会让数据集保持原样，即使我们知道它已经损坏。我们不能优先考虑其他工作，错误的影响不是很大(目前)。
结论:让我们警告数据集的用户，让他们意识到错误，然后我们将问题添加到 backlog 中
真正的问题是
真正的问题是，有一天，有人会查询你的数据集。这个人不会意识到这个问题，并且会得出错误的结论。当他们联系你，因为他们和他们一半的老板都被这个结果吓坏了，你告诉他们最糟糕的答案，哦，是的，对不起，我们知道这是一个错误。
我们到目前为止所做的努力
正如我们所说，我们多次面临这些问题，以下是我们已经尝试过的一些方法:
- 传播 bug :在 Slack 上发一封令人讨厌的
@here或者广泛传播的电子邮件，让每个人都知道你的数据集有 bug。如果有人要使用它，那就太好了。因为除此之外，从现在起的 6 个星期内，很少有机会有人会记得你，而且你刚刚用你的广播惹恼了很多人。 - 文档:像大多数其他地方一样，我们有自己的文档库。你可以去那里并在这个特定的数据集上添加注释，但是除非有人去读它，否则没有人会看到。此外，所有经常使用您的数据集的现有仪表板或数据科学家不会在每次运行查询/报告时都去读取文档。
- 找出谁在使用它:这是了解这个 bug 有多糟糕的关键。它将帮助您了解您需要给予修复多少优先级，但是首先，在此期间，它不能修复任何东西，其次，即使没有很多依赖项，也不意味着将来会有人使用它。
解决办法
所以我在寻找一种方法来解决这个问题，尤其是在像上面解释的那样糟糕的情况下，有些人真的对完全有效的查询结果感到压力。我们需要一种方式来警告用户这个数据集有特定的问题。
经过一番挖掘，我意识到一些聪明的数据工程师已经将Prestoevent listener设置为针对特定的 kafka 主题发送。换句话说，我们的 Presto 集群上的每个查询都生成一个 Kafka 事件。
注意:Presto 是在 Shopify 查询数据集的默认引擎。
“我意识到我可以构建一个软件来监控这个 Kafka 主题，执行一些正则表达式来识别查询是否是关于表的错误，我可以向用户发送一条 Slack 消息。”
为什么 Slack，Slack 是 Shopify 的主要沟通工具，人们通过这种方式监控他们的电子邮箱。所以一条松弛的消息是警告他们的最好方式。我有个计划
履行
在 Shopify，我们有一个叫 Hackday 的东西。连续三天，我们停止“正常”的工作，开始特殊的项目。每个人都选择了自己的项目。我决定试一试。我从事专业软件开发已经有几年了，但我确信我能做点什么。
我的申请基本上就是这四个步骤:
- 听听卡夫卡的话题
- 做一些聪明的正则表达式，以确定它是否是我的表
- 找到 Slack 句柄并向用户发送 Slack 消息。
- 让所有这些在某个地方运行。
所以我被这个快速卡夫卡式的话题解决了，我可以简单地听它。2 可以通过一个基本的网页来解决，数据科学家可以在特定的表格上添加警告并使用正则表达式。对于#3 和#4，我对 Shopify 的开发文化和环境印象深刻。已经有一个网络服务可以将用户的电子邮件(我从 Kafka 的消息中得到的)转换成一个松散的句柄。我也可以通过他们的 API 轻松连接到 Slack。对于最*的部分，它比我能想到的还要简单。基本上，如果我能在 Ruby on Rails 中找到这样做的方法，我只需点击一下鼠标就能部署我的应用程序。
结果
直到今天，我仍然对这个结果印象深刻。如果您在查询完成后的 3 秒内查询任何带有警告的数据集，您会收到如下所示的 Slack 消息。
数据科学家现在可以轻松地在任何表上添加警告消息:
特征
我一直在开发这个工具的特性。我补充道:
- 小睡选项:这样用户就不会在每次查询表时疲惫不堪。
- 特定列过滤:如果除了一列之外，您的所有数据集都正常，那么您只能警告使用该列的用户。
- 表名中的正则表达式，可能有多个表受到影响。您可以设置一个正则表达式样式的表名。
统计数据
大约 3 个月后，举报人
- 向 148 个不同的用户发送了 1300 多个警告。
- 每天扫描大约 43 000 个 Presto 查询。
- 在小时后发送了 300 个警告。
我对此非常高兴，尤其是下班后的 300 个警告。这意味着 300 次，有人收到一个警告，指示他很可能因为其他团队成员不在那里提供帮助而无法获得支持。
这个工具太棒了，我现在晚上可以睡得更好了，因为我知道如果有人查询这些表，他们会得到警告，并且不会对结果做出任何错误的决定。
旁注:当你给内部项目告密者打电话时，有多少人联系你，这真的令人印象深刻
原载于 2021 年 1 月 29 日https://coffeeanddata . ca。
《权力的游戏》第八季真的有那么糟糕吗？
探索性数据分析故事。
我最*开始重新观看《权力的游戏》，从第一季开始。因为我从一开始就是这个系列的忠实粉丝，所以我认为第八季很大程度上是令人失望的。更具体地说，剧情线要么被抛弃，要么被仓促处理，故事里发生的事情我几乎都不认同。当时其他人似乎也有同样的想法。
所以，我想:我们能从数据科学的角度来看第八季吗？也就是说，除了观众自己对这一季的看法之外，我们能客观地证明写作确实糟糕吗？让我想想。首先，这里是我们将使用的工具:
工具:
- Jupyter 笔记本，所有的代码都将存在其中
- Pandas 和 numpy，用于操作数据框和数学函数的 Python 包
- Textstat，另一个用于分析文本的 Python 包
- Datawrapper，一个生成可视化的网站
- 数据集:这个故事使用了以下数据:https://www . ka ggle . com/alben ft/game-of-thrones-script-all-seasons
以下是一些指导我们分析的基本问题:
问题:
- 《GoT》第八季的剧本是不是独字比例比较小？独特词用来衡量文本的复杂程度:它们的比例越高，文本就越复杂。
- GoT 第八季有没有不那么复杂的词？复杂 单词在我们的定义中会是长度超过 7 个字符的单词。
- 《GoT》第八季有没有更多「容易」的词？在此上下文中，易字少于 5 个字符。
- GoT 第八季有没有不那么复杂的句子？让我们把复合句定义为至少 15 个单词的句子。
- GoT 第八季剧本的等级水*是多少？这个被称为弗莱施-金凯等级的标准指的是特定年级的学生是否能够阅读一篇文章，它的范围从 1 到 12。
- 可读性评分呢？对于这个故事，我们将使用 Flesch 阅读难易程度评分，它指的是理解一篇英语文章的难度。
唯一单词得分
那么，我们开始吧。我决定比较两季第一季和第八季每集的独特词百分比。这是因为第一季的收视率相对较高，两者之间的任何差异都会让我们倾向于认为第八季的写作实际上更差。在分析了每集的文本后，我清理并标记了数据，以生成每一集的独特单词的比例。下面您可以看到一个 Datawrapper 可视化，横轴显示季节编号和相应的剧集。
令人惊讶的是，至少对我来说，第八季第四集在这一类别中得分非常高。书名是《最后的史塔克》，故事发生在对抗活死人军团的战役之后。其独特的字数比例的一个原因可能是该集讨论了多条情节主线。
另一方面，最低的是第八季的第二集，名为“七国骑士”，发生在与死者战斗之前。独特词汇得分低的一个原因可能是场景完全设置在一个地方，人物只为一个事件做准备，导致他们使用大致相似的词汇。然而，稍微出乎意料的是，跨两个赛季的独特性得分似乎没有巨大差异。尽管事实上许多人觉得这个系列的质量下降了，但这似乎并没有反映在这个指标上。
复杂的单词
继续研究复杂单词的百分比，我遵循了与上面相同的步骤，只是增加了一个“如果条件”来扫描更长的单词。下面是结果。我注意到的一件事是，在第八季第三集里，复合词的比例明显较低。这一集的标题是“漫漫长夜”，它跟随生者的军队与死者作战。因此，没有那么多复杂的词是有道理的，因为这一集主要是打斗场面。第一季和第八季的其他剧集中，复杂词的比例大致相当，徘徊在 3.02 到 4.41 之间。
“简单”的词
现在，让我们看看简单的(少于 5 个字符)单词。同样，对于复杂的单词，我只需要添加一个“如果条件”来扫描它们，结果如下。如你所见，每一集都有相似的单词，没有一集有明显多或少的简单单词。
复合句
复合句的百分比呢？好吧，看看下面。首先，不出所料，第八季第三集在这一项上得分很低。然后倒数第二，还有同季第五集，标题是《钟声》。这也是一个战斗集中的插曲，这有助于我们理解为什么它在这个指标上排名很低。第一季第一集和第二集的复合句得分也很低，这有点令人惊讶(至少对我来说，我认为第一季比第八季好得多)。还有趣的是，这一类别中得分最高的一集，第一季第八集是由乔治·r·r·马丁自己写的，这可能有助于复杂的句子。至于两个赛季的总体差异，我不认为这个指标有任何差异。你怎么想呢?
易读性指数
哪些剧集的文本更容易或更难阅读？第一季的第二集得分高于 90，相当于“非常容易”，而根据 Flesch 标准，介于 80-89 之间的剧集“容易”阅读。正如你所看到的，只有两集比较难读:S1.7。这是“相当容易”和 S1.8。这是“标准”。再一次，乔治·r·r·马丁写了 S1.8 这个事实可能导致它更难阅读。这一部分的一些后续步骤可能是为电视节目编制这一指标的*均值，特别是因为易读性指数通常指的是书面文本，比口头文本更复杂。
年级水*
现在让我们看看第一季和第八季所有剧集的分数。正如你所看到的，第一季的第 7 和第 8 集更难阅读(如上),也对应着更高的阅读水*。此外，小数点向下舍入到较低的级别(例如 6.2 舍入到 6)。其他集从 4.5 到 6.5 不等，唯一的例外是 S.1 E.2，其阅读水*得分为 3(或三年级)。如上所述，看看是否可以对电视节目进行某种类型的*均，以了解《权力的游戏》的排名，这将是一件有趣的事情。
适用于所有季节
既然我们已经查看了所有的指标，不如我们来看看每一季的表现如何？下面你可以找到一个线图，横轴是季节数字。有趣的是，在第六季中，句子的复杂程度有了一个飞跃，但这一指标在各季中基本保持相对相似。
结束的
总结我们的发现，我当然很惊讶地看到，按照我们使用的指标，第八季的得分并不比第一季差。相反，这一季剧集的剧本在独特的单词、复杂和简单的单词、复杂的句子和易读性方面得到了类似的结果。这可能表明，人们对该系列的不满主要在于情节主线及其处理方式，而不是文本组件本身。
感谢您的阅读！
观看语言模型学习下棋
根据象棋符号训练 GPT2 模型的结果
图片:www.pexels.com
在之前的一篇文章 (Chess2Vec)中，我分析了国际象棋比赛中的哪些走法是接*的，也就是说，它们经常出现在游戏中类似的情况下。如果两个或两个以上的移动在另一个之后或之前，它们被认为是以某种方式相关的。我分析的来源是国际象棋服务器 Lichess 上的游戏文件。
在这篇文章中，我想更进一步，调查是否可能只从文本文件形式的记录游戏中学习国际象棋的规则？为此，我使用机器学习模型，这些模型实际上是为分析自然语言而设计的——语言模型。
语言模型适合象棋吗？
自然语言处理被应用于与 NLP 任务没有或没有直接联系的各种目的，并且数据以除文本之外的形式被处理。例如，计算机视觉和蛋白质折叠预测是利用自然语言处理原理的过程的例子。
我们调查了一个领域中最先进的语言建模技术，这个领域起初似乎超出了他们的范围，即计算机象棋。因为规则是明确的，而不是模糊或模棱两可的，这是因为明确的规则控制着这里发生的事情，而不是因为人们有许多不同的方式来解释语言。
例如，的 GPT3 论文表明，通过用抓取的网站数据训练语言模型，人们可以在某种程度上发展算术能力。在这个过程中，简单的运算只能在给定的数字空间内学习，而不能超出这个空间。这是模型能力不足、训练时间不足，还是仅仅是数据不足的结果？
我们以广受关注的“计算机象棋”领域为例，评估语言模型的学习能力以及模型大小、训练时间和可获得的训练数据的影响。
因为国际象棋比赛是在不断增长的互联网国际象棋服务器上记录的，所以测试区是研究语言模型训练的理想场所。另一个优点是，语言模型的质量不仅可以使用语言模型的典型评估度量来测试，例如困惑，还可以通过测试好的游戏是否是根据国际象棋规则产生的来测试。
几十年来，国际象棋一直是一个受欢迎的人工智能试验场，由于 Deepmind 的努力，它在过去几年里变得特别热门。在那里，一个国际象棋引擎被创造出来，它通过仅利用规则和新的强化学习方法(“AlphaZero”)在游戏强度方面超越了以前存在的一切。
作为之前学习的后续，不再需要规则知识。新算法穆泽罗在不知道游戏规则的情况下，超过了 AlphaZero 在之前研究中的超人表现。
为了构建一个可以从头开始发现国际象棋规则的系统，我从一种完全不同的方法开始。只有游戏抄本被用来训练语言模型。然后我们将检查这些模型，看看这个系统是如何学习国际象棋的规则的。
数据和预处理
我们需要大量的游戏数据来教授语言模型。例如，我们可能从国际象棋服务器 Lichess 获得这些信息。自 2013 年以来，服务器上托管的所有游戏都按月份排列在一个列表中。每个月的压缩 PGN 文件是可用的。总的来说，有超过 400 GB 的压缩数据，玩了超过 17 亿个游戏。
虽然预处理(例如删除元数据)后数据量会显著减少，但此时数据量仍然很大。鉴于最初的 GPT2 语言模型是在 40GB 的互联网文本上训练的，我们在训练期间有足够的空间来试验不同数量的数据。
游戏的质量在这项研究中起着次要的作用，因为它只涉及简单地学习规则。然而，玩家的 ELO 评级对他们的游戏实力的影响可以通过基于他们的元数据过滤游戏来评估。然而，为了避免由于服务器上缺乏游戏活动而在早期被放弃的游戏，我们将使用最小长度进行过滤。一个名为“ pgnextract ”的命令行程序将 PGN 文件转换成个人电脑可以读取的格式，然后用象棋引擎软件对其进行处理。该程序通过使用用于操作 PGN 文件的命令行应用程序预处理批量数据来处理几乎所有需要的操作。pgnextract 可以在合理的时间内执行所需的转换，即使数据量很大。
游戏中的所有移动数字、结果、注释、变化和其他信息都在这些清理中被删除，只显示带有 SAN 符号的纯字符串。每场比赛被记录到一个文件中的一行。所有少于 20 步的游戏都被排除。
模型的训练
培训是在 Kubernetes 集群上进行的，该集群配备了英伟达 RTX 3090 GPU，每个 GPU 都有 24 GB 的视频 RAM 和 256 GB 的主内存。为了实现，使用了基于 Pytorch 的来自 HuggingFace 的变形金刚包。
在相同的条件下，如果一个单词序列是由语言模型生成的，那么它将会重复自己，除非下次选择最可能的单词。此外，模型经常重复短语。这也影响了这里棋牌游戏的制作。因此，利用诸如 top-k 抽样和 top-p 抽样的随机过程来生成游戏。这些方法有助于最大限度地减少重复，尽管重复仍然会发生。
模型评估
为了检验模型，使用了各种方法来制作游戏:
- 两次移动后的典型开仓位置列表。
- 在给定数量的移动之后从游戏数据集中的游戏位置。
- 在给定次数的移动后从随机产生的位置
对于这些游戏中的每一个，跟踪产生的正确移动的总数。语言模型将不得不处理三个特定于国际象棋的度量来评估生成的移动。为第一个评估标准开发合法移动是最容易的，因为所有的测试情况都出现在大量的训练数据游戏中，因此模型记住数据就足够了。一种形式上的概括，即象棋规则实际上是被学习的，只需要用于非常长的生成的移动序列。
随着给定数量的移动的长度增加，第二种方法更加困难。因为研究中使用的游戏数据集不包括在训练数据中，所以随着所提供的序列长度的增长，将会出现越来越多的模型从未见过的位置。因此，模型必须学习规则，以生成合法的移动。
第三项措施需要由随机的棋步序列产生起始位置。由于这种高度的不可预测性，这些步骤中的大部分以前从未出现在人类游戏或测试数据集中。因此，模型很难为这些序列生成规则的移动。即使对人类来说，处理这样的随机位置也是非常困难的。在对国际象棋大师和业余爱好者的实验中发现，虽然优秀的国际象棋选手可以很容易地记住典型的位置，但他们对随机位置有问题。
结果
为了了解这两个变量如何影响学习过程，我们用不同数量的游戏(99，604；577,202;2163417 场)。几个时期后，使用上一节中描述的评估指标对每个模型进行评估，以评估结果。
通过这些统计数据，我们可以看到，当研究范围内的更多游戏用于训练时，在相同的时间内可以获得更好的结果。然而，模型的复杂性并没有这么大的影响。还值得注意的是，语言模型的典型评估指标，预测准确性和困惑度，在这里没有提供这方面的信息。
作者从移动 10 次/图像后的位置的*均正确移动次数
象棋知识是如何存储在模型中的？
我们已经看到模型中有更多的参数和更多的训练数据如何帮助语言模型更好地学习国际象棋规则。现在，我们将寻找在模型参数中如何表示国际象棋规则信息的任何模式。为此，我们将使用不同的可视化。
当适当地可视化和研究时，神经元激活可以揭示单个神经元和神经元群所扮演的角色。我们使用 Ecco 库进行分析。
让我们来看看一个经过训练的模型在不同情况下的内部运作。第一个位置来自开放阶段，当只有一个合法选项存在时，它是一次性发生的。
位置 1 /作者图片
如果我们观察序列的单个部分对新移动的影响，我们会发现最后部分的影响最大，但除此之外，整个序列也会影响输出。
颜色代码显示影响的强度，或者，我们也可以用百分比显示各个部分的影响。
模型有多确定生成的移动是正确的？
在生成器组件的最后一层的末尾，我们评估模型对于每个可能的令牌的机会。移动分两个阶段产生，两个部分都有很高的可能性被创造出来，但是，只有一个部分有 100%的可能性。
让我们来看看神经元的激活，看看模型如何根据移动序列跟踪棋盘。为了生成可接受的走法，语言模型需要棋盘及其棋子的表示。
通过检查神经元组的激活，我们看到一组(红色)活跃在棋盘的行信息上，另一组(蓝色)活跃在棋盘的列和块信息上。另外两个在绳子的两端被激活。
作者图片
现在让我们看看另一个位置，它来自所谓的“世纪游戏”。在具有大量选项的复杂中间位置，该模型达到了其极限。
位置 2 /作者图片
它识别出 d 文件上的一个片段是最后捕获的，并希望用 Rxd 或 Qxd 将其捕获回来。但是，在此位置没有有效的移动。棋盘在神经元中的表现是不正确的，所以没有可行的移动被创造出来。
许多潜在的 next 令牌分布在网络最后一层的多个候选中。
在第二个位置，可以看出，实际上先前移动的整个序列对将要产生的新移动有影响。
在这个例子中，神经元组在行信息以及图形和列信息上的专门化是明显的。另一方面，激活在序列开始时较少。
作者图片
在两个示例位置中，可以看到整个序列对生成的移动有影响，这对于生成正确的移动是必要的。通过观察神经元的活动，我们可以看到关于行、列和图形类型的信息存储在不同的神经元组中。因此，该模型似乎组织了表示棋盘状态所必需的信息的存储。
论文发表在自然语言处理最新进展国际会议(RANLP 2021)的会议录上。所有的细节都可以在那里找到。
水冷却器谈话:你真正工作了多少？
850 天工作、学习和睡眠数据的分析和可视化。哪个位置让我更有效率？
Priscilla Du Preez 在 Unsplash 上拍摄的照片。
你每天工作多长时间？我说的工作，不是指在饮水机旁聊天，花 15 分钟泡一杯咖啡，或者在厕所里回复你所有的 Whatsapp 信息。还有 而不是 偶尔上推特，或者写“就一封”个人电子邮件，里面有 100 个关于你最*一次尝试制作康普茶的细节。
我是说真正的工作时间。
衡量它的一种方法是跟踪和分类你在笔记本电脑上花费的时间。如果有任何有趣的趋势，或者工作时间与情绪或睡眠之间的相关性，它会让你清楚地看到你实际上在做什么。
猜猜是什么。一位痴迷于自我追踪、有抱负的数据分析师做到了！🎉你马上就会知道她发现了什么。
这篇文章中的数据来自我的每日和每周自我跟踪表，我已经填写了两年多了——你猜对了——每日和每周。这些表格记录了我的心情、地点、正在服用的药物、习惯，我用它们来记录各种提示下的一些日志式的想法。睡眠数据来自 Oura 戒指，我也戴了两年多了。
这篇文章的一个简短版本也以一个场景故事的形式存在。
最努力工作的城市
我过去经常旅行，所以在这个数据集中首先要调查的是我工作最多的城市。
排名如下:
1.葡萄牙里斯本🇵🇹 (31.25 小时)
2.法国🇫🇷卡昂(19.44 小时)
3.印度尼西亚巴厘岛🇮🇩 (17.86 小时)
但是，看数值。里斯本以的优势赢了卡昂。
那里发生了什么事？你可能会想知道。
这很简单。我没有我的伴侣，作为一个相当不合群的人，没有太多事情可做。
你可能想知道的第二件事是，“哎呀，其他人*均每周只工作 17-9 小时？，你好像工作不多啊！”
但是，还记得这篇课文的第一段吗？⬆️:嗯，我相信许多所谓的每周工作 40 小时的办公室工作最多是 25 小时的工作。所以，我的工作时间可能与你的没有太大的不同……我向你挑战，开始跟踪它——准备好大吃一惊吧。
不要误解我，这不是对任何人懒惰的评论，而是对我们感知的不准确的评论。如果你花那么多时间在办公室，看起来你好像“工作”了 40 个小时。
我认为这也是对不完善的工作标准的评论。
如果你能在 10 小时内完成和其他人 30 小时内完成的一样多的事情，你应该被要求在剩下的 20 小时里坐在办公室里吗？
我不这么认为。而且，你们可能应该根据结果而不是花费的时间获得相同的报酬。
工作时间短？故事的第二部分。
注意到我经常发布关于数据的帖子了吗？嗯，我正在重新培训成为一名数据分析师。这需要大量的学习，这也是我花费大量时间的地方。
下图显示了各个城市工作和学习时间的综合价值。
“赢家”和上一个案例中的一样:里斯本、卡昂和巴厘岛。但是，现在的数字要高得多。(仍然没有包括饮水机谈话，当我给我妈妈写任何康普茶尝试的时候，计时器被切换到跟踪“家庭时间”。)
☝️:这些数字应该是数字流浪者光辉形象的更新，他们每周在巴厘岛的游泳池边工作几个小时。没有。
真实的形象看起来很像这样:利用生活的低成本作为一个机会，尽可能多地投入时间到学习中，同时试图找到一个有空调的房间和一把像样的椅子来坐，但不是为此支付一大笔钱。你没有财产，你一周只工作 15 小时，记得吗？
我找到了一把好椅子，但有人比我快。好色客别墅，巴厘岛乌布(印度尼西亚)。
有工作城市和学习城市吗？
将工作时间和学习时间分开来看，我们可以算出在哪个城市的哪项活动上花费了更多的时间。
看起来里斯本在工作时间方面彻底击败了竞争对手，在工作时间和学习时间的差异方面也是如此。
图表的另一边是华沙，在那里我花在学习上的时间比工作上的时间多得多。我还记得那段时间，那是一些繁重的 SQL 查询的时期，我试图申请两份工作，并且有非常苛刻的选择过程。
不用说，他们的 SQL SELECT 没有返回我。这就是为什么你仍然可以享受我的职位。否则，我现在会在别的地方赚钱并产生巨大的积极影响。😛
时间趋势？
看一下趋势线，总体来说，我花在工作上的时间更少了，而花在学习上的时间更多了。
这怎么可能？现在是我想知道了。
一种解释可能是，随着时间的推移，我的经验增加了，作为一名自由职业者，我收取更多费用的能力也增强了。换句话说，我每小时挣得更多，因此在同样的经济效益下，我可以干更少的活。(如果我可以花一点时间自怜的话，这是一个更低、更悲惨的选择。)
把这些数字按季度分组怎么样？
当按季度分组时，过去两年讲述了一个早年赚钱动机的故事，随着时间的推移，这变成了对自我改善的长期收益的关注。💰🥳🌹
好吧，这是一个严重的过度解读。
它唯一显示的是，在过去的两年里，我花在工作上的时间比上半年花在学习上的时间还多。我敢肯定，你——读到这篇文章的两个人之一——对于 2021 年 Q1 和 Q2 的选举结果，正坐立不安。
更高的睡眠分数，而不是更多的工作🤷♀️
最后，我很好奇睡眠是否会影响我的工作时间。我的睡眠数据被一个 Oura 环跟踪，每天晚上，它都会根据我的睡眠质量计算出一个睡眠分数。分数越高，我的睡眠越好。
这是一个散点图，有一条趋势线来衡量相关性。
在绘制这张图表之前，我会假设高质量的睡眠会增加我的动力和注意力，从而让我花更多的时间在工作上。
但是，令人惊讶的是，事情似乎正好相反！
睡眠得分越高，我花在工作上的时间就越少。
为什么？也许更好的睡眠让我有时间反思我的优先事项，意识到工作是对生命的浪费，我应该去欣赏我凝视的每一根倒下的树枝。或者，有了更好的睡眠质量，我会更加专注，在更短的时间内完成所有工作。或者，一千个其他的解释。
重要的是，其他图表显示减少了花在工作上的时间，并不与花在学习上的时间显著增加相一致。有少量增加，但没有统计学意义。
后续步骤
不仅要衡量长度，还要衡量工作和学习的质量，这是很有价值的。这将有助于量化工作时间的减少意味着生产率的降低还是提高，并更精确地了解睡眠对这些指标的影响。
如果您对数据故事感兴趣，请查看以下内容:
- 🙋♀️Does 表情符号的使用与推特互动相关吗？
- 在疫情茁壮成长？😳数据揭示了我的睡眠模式
- 所有俄罗斯人都热爱他们的工作吗？🧐工作的乐趣如何改变你对时间的重视程度。
水变成咖啡:浓缩咖啡
咖啡数据科学
压榨前将水和咖啡渣混合
几个月前，我尝试了一杯浓缩咖啡，将冰球放在盛有水的篮子里一整夜。其中一条评论问，如果我在咖啡中混合少量的水，然后用勺子把它放进压榨机里挤出咖啡，会发生什么？这是一个足够小的实验，所以我试了一下。
我从 9 克咖啡和 18 克水开始。我把它们放在碗里搅拌，直到所有的咖啡渣都变湿。我算了一下，我可以拿出大约 9 克咖啡液。这是终极预湿。
所有图片由作者提供
我确定稠度像泥浆，我给它几分钟。一些克莉玛已经显露出来了。
然后我把这些泥放进一个 Kompresso，但是我用了 Kompresso 的上半部分，这样我可以更好地观察发生了什么。
第一轮没进多少液体，就多加了 19 克水。
第一位果然是暗的。对于这种类型的测试，一切似乎都很正常。
事后我看了看咖啡冰球，没有看到任何奇怪的通灵现象。
我查看了几个输出样本的提取率(EY)。他们都遵循一条直线前进的趋势线。10%在 1:1 中被提取，这看起来很低，可能是水温较低的结果。最终的 EY 在输出比的良好范围内。
我看了数据，还估算了冰球中剩余的水。如果我假设它测量的 TDS 和最后一点流出的咖啡液体是一样的，我就能看到我错过了什么。
基于这一预测，最终的镜头将有超过 22%的 EY，但最终的比例是 3.6:1，这是我的典型比例的两倍多。
这是一个奇怪的测试。我有点想用热水再做一次。我的主要问题是，在整个实验过程中，水温会下降。主要的问题是，如果没有更长的浸泡时间、更高的压力或更高的温度，就不可能获得更高的提取率。
如果你愿意，可以在 Twitter 和 YouTube 上关注我，我会在那里发布不同机器上的浓缩咖啡视频和浓缩咖啡相关的东西。你也可以在 LinkedIn 上找到我。也可以关注我中。
我的进一步阅读:
在水中跌跌撞撞:浓缩咖啡水实验
克莉玛，嗯，它有什么用？
浓缩咖啡的水温
咖啡数据科学
提高提取温度
多年来，水温一直是浓缩咖啡和普通咖啡的有趣话题。取决于冲泡方法和咖啡烘焙，水温对味道有很大的影响。
然而，我们经常混淆水温和机器温度，因为使用加压机器，水可以达到比炉子上高得多的温度。结果，水一接触到咖啡，温度就下降了。即使把水加热到接* 100 摄氏度也会很棘手，因为它正在蒸发。
温度是需要跟踪的变量，尤其是对于杠杆式机器。
我收集了几个温度下的一些照片，以展示温度对味道和提取的影响有多大。我用了金特快和韩国磨床。我对每一次注射都遵循相同的协议，这意味着每一次注射都是不连续的，有 60 秒的预输注和输注期间的压力脉冲。
咖啡豆是中度烘焙的，所以如果你用的是较深的烘焙，你可能要用较低的温度。
所有图片由作者提供
机器温度
我通常用测温枪测量机器温度。我见过测试条，但温度枪对我有用，因为我的机器是喷漆的。在收集这些数据时，我意识到机器的温度与输出水温并不相同。所以我收集了一些数据，发现机器温度和输出水温之间存在线性相关性。
我以此为指导，推动高于正常水*。在过去的一年里，我的目标是将机器温度控制在 114 摄氏度，但这导致水温在 91 摄氏度左右。当我开始尝试更高的高度时，我发现我可能错过了一些更好的镜头。
绩效指标
我使用两个指标来评估技术之间的差异:最终得分和咖啡萃取。
最终得分 是评分卡上 7 个指标(辛辣、浓郁、糖浆、甜味、酸味、苦味和回味)的*均值。当然，这些分数是主观的，但它们符合我的口味，帮助我提高了我的拍摄水*。分数有一些变化。我的目标是保持每个指标的一致性，但有时粒度很难确定。
使用折射仪测量总溶解固体量(TDS)，这个数字结合咖啡的输出重量和输入重量用于确定提取到杯中的咖啡的百分比，称为提取率(EY)** 。**
多个温度下的数据
我在这里显示的温度是使用上面的曲线从机器温度计算得到的水温。
温差的第一个视觉信号是水流得更快。对于 97C，我不得不将预输注减少到 30s，因为它流动得太快了。
从圆盘的底部看，较低温度下有暗点，表示流动缓慢，但是当温度达到 97℃时，圆盘的整体颜色变浅，暗点变少，表示流动均匀，提取率更高。
****
顺序:顶配:85C、87C、90C 底部:92C、95C 和 97C
证据就在味道和 EY。味道真的在上升到 97C 的路上提升了。
****
总时间随着温度的升高而下降，因为水流得更快了。
我真的很喜欢这个实验，因为它揭示了我没有充分加热我的机器。热水还会增加机器中的压力，进而影响预浸压力。也许实验的另一个设计是使用压力计来了解压力，然后释放压力以使比较更加公*，或者使用 DE1。
关键是要实验，因为水温会有不同的影响，取决于机器和烘烤。
如果你愿意，可以在 Twitter 和 YouTube 上关注我，我会在那里发布不同机器上的浓缩咖啡视频和浓缩咖啡相关的东西。你也可以在 LinkedIn 上找到我。也可以关注我中和订阅。
我的进一步阅读:
用 Plotly 制作瀑布图
为什么&如何
图片由 Muhamad Rizal Firmansyah 从 Unsplash 拍摄
瀑布图
又名:飞砖图、浮砖图、马里奥图
原因:是一个 2D 图，用于表示在一段时间内或在多个分类步骤内连续添加正值或负值的累积效果。随着时间或基于时间的瀑布图表示一段时间内的增加和减少。分类步骤或基于类别的瀑布图表示收入和费用或任何其他变量的加减，依次为正值和负值。
如何:瀑布图(WCs)由一系列竖条(柱)组成。初始值和最终值由全列表示(通常从零基线开始)，而中间值显示为代表加法和减法的浮动列。最后一个竖线表示这种加法和减法的结果。加法通常用绿色表示，而减法通常用红色表示。另外，习惯上用另一种颜色表示起始列和结束列。建议通过用连接横线连接各列来展示累积效果的理念。
图 1:瀑布图的示意图。作者用 Plotly 做的。
现在应该清楚为什么它们被称为飞砖或浮砖图了。有人将它们命名为马里奥图表，因为它与流行的视频游戏有一定的相似性。
讲故事 : WCs 通常用于金融和商业中的在正值和负值之间波动的数据。基于时间的 WCs 显示每月或每年的总变化，同时显示整月或整年的利润或亏损。基于类别的 WCs 显示给定变量的连续增加的正值或负值的累积效应。正值可能是收入、收益、仓库库存增加、积极变化或收入流。负值可能是费用、损失、仓库存货、负变化或流出量。请记住，阅读是从左到右依次进行的。
WC 是一种有价值的数据可视化技术，因为它允许分析师清楚地确定哪些时段或项目显示最大收益，何时观察到最大损失，以及在评估的时间段内净变化是什么。它提供了比其他类似图表更多的上下文信息。
瀑布图与 Plotly
我们使用了开源的图形库 Plotly ，它提供了一组名为 graph objects 的类来构造图形。图是具有数据属性和布局属性的主类。数据属性指的是一个轨迹，一个带有相应参数的特殊类型的图表。布局属性指定图形的标题、轴、图例和其他属性。
对于本文中的瀑布图，Plotly trace 为*go.Waterfall()*对应的参数为:*x=*设置 x 坐标(一般为字符串或日期时间对象)；*y=*设置 y 坐标(通常是一列 con 数值，包括无)； *base=*设置数值基线。
最重要的参数是*measure=* ，一个具有下列值之一的数组:相对；绝对；总计。相对值，默认值，表示增加或减少。绝对值设置初始值，而总和计算代数和。
这是图 1 中瀑布图的代码:
import plotly.graph_objects as gofig1 = go.Figure()hrz = ["Initial", "Addition 1","Addition 2",
"Subtraction 1","Subtraction 2","Final"]vrt = [100, 600, 700, -400, -300, None]fig1.add_trace(go.Waterfall(
x = hrz, y = vrt,
base = 0,
measure = [ "absolute","relative",
"relative","relative",
"relative","total" ]
)) fig1.show()
我们更新了图表以改进讲故事:text为每个条形设置注释；textposition将文字列表定位在内或将定位在外；update.layout 设置标题文本和标题字体。
这是图 2 中瀑布图的代码:
import plotly.graph_objects as gofig2 = go.Figure()hrz = [ "Initial", "Addition 1", "Addition 2",
"Subtraction 1","Subtraction 2","Final"]vrt = [100, 600, 700, -400, -300, None]text = ['100', '+600', '+700', '-400', '-300', '700']fig2.add_trace(go.Waterfall(
x = hrz, y = vrt,
base = 0,
text = text, textposition = 'inside', measure = ["absolute", "relative", "relative",
"relative","relative","total"]
)) fig2.update_layout(
title_text = "Category-Based Waterfall Chart",
title_font=dict(size=25,family='Verdana',
color='darkred')
)fig2.show()
图 2:瀑布图的示意图。作者用 Plotly 做的。
在我们的第二个例子中，我们将使用一个基于时间的瀑布图来表示一个虚构的地方每月访客数量依次增加和减少的累积效应。
首先，我们将创建一个数据框架，其中包含我们应该收集的关于访问者数量增减的数据。我们需要将库Numpy&Pandas分别导入为 np 和 pd 。
import numpy as np
import pandas as pdmonths = ['Initial', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Final']visitors = [15000, +18000, +12000, -4000, +8000,
-10000, -5000, +20000, +15000, +18000,
-16000, -18000, +10000, 63000]df = pd.DataFrame({'months' : months, 'visitors' : visitors,
'text' : visitors})
我们需要在 dataframe 中创建一个列，指示与*measure*相关的值。记住这个参数可以取以下三个值中的任意一个:absolute；相对的；总计。为了填充名为*measure* 的列，我们使用了 Numpy 方法np.select()，该方法根据条件列表返回一个从 choicelist 中的元素提取的数组。
conditionlist = [(df['months'] == 'Initial'),
(df['months'] == 'Final'),
(df['months'] != 'Initial') & (df['months'] != 'Final')]choicelist = ['absolute', 'total', 'relative']df['measure'] = np.select(conditionlist, choicelist,
default='absolute')
下面的屏幕截图显示了数据集的 14 条记录:
现在我们准备画 WC 了。
Plotly 允许通过 *increasing*、*decreasing*和*totals*.自定义浮动条的颜色
fig3 = go.Figure()fig3.add_trace(go.Waterfall(
x = df['months'], y = df['visitors'],
measure = df['measure'],
base = 0,
text = df['visitors'],
textposition = 'outside',
decreasing = {"marker":{"color":"crimson",
"line":{"color":"lightsalmon","width":2}}},
increasing = {"marker":{"color":"forestgreen",
"line":{"color":"lightgreen", "width":2}}},
totals = {"marker":{"color":"mediumblue"}}
))
我们决定将注释放在条的外面，以避免混乱。最后，我们设置了标题并更新了坐标轴:
fig3.update_layout(
title_text = "Time-Based Waterfall Chart",
title_font = dict(size=25,family='Verdana',
color='darkred'))fig3.update_yaxes(title = 'Visitors' , range = [0, 100000])
fig3.update_xaxes(title = 'Year 2020')fig3.show()
图 3:基于时间的瀑布图。作者用 Plotly 做的。
总而言之:瀑布图的关键概念是传达一段时间内或一系列相关项目中正值和负值的变化。它们很容易实现，尤其是用 Plotly。它们广泛用于金融分析和商业环境。
如果你发现了这篇感兴趣的文章，请阅读我之前的(https://medium.com/@dar.wtz):
分歧棒线，为什么&如何，用分歧讲故事
斜率图表，为什么和如何，用斜率讲故事
Wav2Vec 2.0:语音表示的自我监督学习框架
思想和理论
解释语音识别模型
图片由下雪发自Freepik.com
Wav2Vec 2.0 是自动语音识别的当前最新模型之一，这是由于在该领域中自我监督训练是一个相当新的概念。这种训练方式允许我们在未标记的数据上预先训练模型，这总是更容易获得。然后，可以针对特定目的在特定数据集上对模型进行微调。正如以前的作品所显示的，这种训练方式是非常有力的[4]。
主要思想
如下图所示，模型分两个阶段进行训练。第一阶段是在自我监督模式下，这是使用未标记的数据完成的，其目的是尽可能实现最佳的语音表示。你可以用类似于思考单词嵌入的方式来思考这个问题。单词嵌入还旨在实现自然语言的最佳表示。主要区别在于 Wav2Vec 2.0 处理的是音频而不是文本。训练的第二阶段是监督微调，在此期间，标记的数据被用来教导模型预测特定的单词或音素。如果你不熟悉“音素”这个词，你可以把它想成特定语言中最小的声音单位，通常用一两个字母来表示。
图一。Wav2Vec 2.0 的训练阶段(图片由作者提供)
第一阶段的培训是这种模式的主要优势。学习一个非常好的语音表示能够在少量的标记数据上实现最先进的结果。例如，该论文的作者已经在一个巨大的 LibriVox 数据集上对模型进行了预训练。然后，他们使用整个 Libri 语音数据集进行微调，在测试清理子集上产生了 1.8% 的单词错误率(WER) ，在测试其他子集上产生了 3.3%的 WER。使用少了* 10 倍的数据，允许在测试-清理上获得 2.0%的 WER，在测试-其他上获得 4.0%。仅使用 10 分钟的标记训练数据(几乎没有数据)，在 Libri 语音的 test-clean / test-other 子集上产生 4.8% / 8.2%的 WER。根据代码为的论文，它在 2018 年 1 月将会达到最先进的水*[5]。
图二。Wav2Vec 2.0 的结果(图片由作者提供)
Wav2Vec 2.0 模型架构
用于预测的最终模型的架构包括三个主要部分:
- 处理原始波形输入以获得潜在表示的卷积层-，
- 变形金刚图层，创造情境化的表现- C ，
- 线性投影到输出-。**
图 3。微调的 Wav2Vec 2.0 模型架构(图片由作者提供，基于 wav2vec 2.0:语音表示的自我监督学习框架)
这就是模型经过最终微调后的样子，可以在生产环境中开发了。整个魔术发生在训练的第一阶段，在自我监督模式下，当模型看起来有点不一样。该模型在没有线性投影生成输出预测的情况下被训练。
基本上，本文主旨部分提到的语音表征对应于图 4 中的‘语境表征C’。预训练的主要思想类似于 BERT:变换器的部分输入被屏蔽，目的是猜测屏蔽的潜在特征向量表示。然而，作者用对比学习改进了这个简单的想法。**
对比学习
对比学习是一个输入以两种不同方式转化的概念。之后，模型被训练以识别输入的两个变换是否仍然是相同的对象。在 Wav2Vec 2.0 中，变换层是第一种变换方式，第二种方式是通过量化，这将在本文的后续部分进行解释。更正式地说，对于一个被掩蔽的潜在表征【zₜ】，我们希望得到这样一个上下文表征【cₜ】以便能够在其他量化表征中猜出正确的量化表征【qₜ】。很好地理解前面的句子是很重要的，所以如果你需要的话，不要犹豫就此打住:-)用于自我监督训练的 Wav2Vec 2.0 版本如图 4 所示。
图 4。用于自我监督训练的 Wav2Vec 2.0 模型架构(图片由作者提供，基于 wav2vec 2.0:语音表示的自我监督学习框架)
为了总结我们到目前为止所学的内容，请看看表 1。
表 1。Wav2Vec 2.0 自我监督学习和监督学习的比较
量化
量化是将连续空间中的值转换为离散空间中有限的一组值的过程。
但是我们如何在自动语音识别中实现这一点呢？让我们假设一个潜在语音表示向量 、zₜ 覆盖两个音素。一种语言中音位的数量是有限的。此外，所有可能的音素对的数量是有限的。这意味着它们可以被相同的潜在语音表征完美地表征。此外，它们的数量是有限的，所以我们可以创建一个包含所有可能的音素对的码本。然后，量化归结为从码本中选择正确的码字。然而，你可以想象所有可能的声音的数量是巨大的。为了更容易训练和使用，Wav2Vec 2.0 的作者创建了 G 码书，每个码书都由 V 码字组成。为了创建量化表示，应该从每个码本中选择最佳字。然后，将选择的向量连接起来，用线性变换进行处理，以获得量化的表示。该过程如图 5 所示。
图 5。量化(作者图片)
我们如何从每个码本中选择最佳码字？答案是 Gumbel softmax :
其中:
- sim——余弦相似度，
- ***lϵℝᴳˣ***ⱽ—logits 由 z 计算得出，
- =-log(-log(uₖ)、
- uₖ 从均匀分布 U(0，1) 中取样，
- 𝜏——温度。
由于这是一项分类任务，softmax 函数似乎是在每个码本中选择最佳码字的自然选择。为什么在我们的例子中， Gumbel softmax 比普通的 softmax 好？它有两个改进:随机化和温度 𝜏 。由于随机化，模型更愿意在训练期间选择不同的码字，然后更新它们的权重。重要的是，特别是在训练的开始，防止只使用代码簿的子集。温度随着时间从 2 降低到 0.5，因此随机化的影响随着时间变小。
掩饰
让我们深入到掩蔽的细节。它由两个超参数定义:p= 0.065和 M = 10，并按以下步骤进行:**
- 从潜在言语表征的空间中取出所有时间步骤 Z 。
- 样品没有替换比例 p 来自上一步的向量。
- 选择的时间步长是起始索引。
- 对于每个索引 i ，连续的 M 时间步长被屏蔽。
如下图所示，我们采样了两个标有橙色的向量作为起始索引。
图 6。选择蒙版的起始索引(图片由作者提供)
然后，从每个选择的向量开始， M = 10 个连续的时间步长被屏蔽。跨度可能重叠，由于它们之间的间隙等于 3 个时间步长，我们屏蔽了 14 个连续的时间步长。
图 7。屏蔽 M 个连续的时间步长(图片由作者提供)
最后，对比损失仅针对掩模的中心时间步长进行计算。
培训目标
训练目标是两个损失函数之和:对比损失和多样性损失。目前，只提到了对比损失。它负责训练模型来预测 K + 1 量化候选表示q’∈qₜ.中正确的量化表示 qₜ** 集合 Qₜ 由目标 qₜ 和 K 干扰子组成，这些干扰子是从其他掩码时间步中均匀采样的。**
字母 κ 是训练过程中恒定的温度。 Sim 代表余弦相似度。函数的主要部分类似于 softmax，但是我们取上下文表示【cₜ和量化表示 q 之间的余弦相似度。为了更容易优化，我们还将 -log 放在那个分数上。**
*多样性损失**是一种正则化技术。作者设置了 G =2 个码本，每个码本中有 V =320 个码字。理论上它给出了 320320=102400 个可能的量化表示。然而，我们不知道该模型是否真的会使用所有这些可能性。否则，它将仅学习使用例如来自每个码本的 100 个码字，并且它将浪费码本的全部潜力。这就是多样性损失有用的原因。它基于熵，熵可通过以下公式计算:
其中:
- x —离散随机变量𝒳的一种可能结果，
- P(x) —事件发生的概率 x 。
当数据分布均匀时，熵取最大值。在我们的例子中，这意味着所有的码字都以相同的频率使用。这样，我们可以在整批训练样本上计算每个码本的熵，以检查码字是否以相同的频率使用。这个熵的最大化将鼓励模型利用所有码字。最大化等于负熵最小化，负熵是多样性损失。
微调
由于 Wav2Vec 2.0 的微调阶段并不包含任何突破性的发现，所以作者并没有太关注他们论文的这一部分。在训练的这个阶段，不使用量化。取而代之的是，在上下文表示 C 的顶部添加一个随机初始化的线性投影层。然后用标准的连接主义者时态分类(CTC) loss 和一个修改版本的 SpecAugment 对模型进行微调，这超出了本文的范围。有趣的是，作者并没有放弃掩蔽，因为它仍然可以作为一种正则化技术。
结论
Wav2Vec 2.0 使用自我监督的训练方法进行自动语音识别，该方法基于对比学习的思想。在巨大的原始(未标记)数据集上学习语音表示减少了获得满意结果所需的标记数据量。
这篇文章的要点是:
- Wav2Vec 2.0 利用了自我监督的训练，
- 它使用卷积层来预处理原始波形，然后应用变换器来增强具有上下文的语音表示，
- 其目标是两个损失函数的加权和:
- 对比损失，
- 多样性丧失，
- 量化用于在自我监督学习中创建目标。
我希望你喜欢我的文章，它能帮助你理解 Wav2Vec 2.0 的思想。要了解更多细节，我鼓励你阅读原文[1]。
参考
[1] A. Baevski，H. Zhou，A. Mohamed 和 M. Auli， wav2vec 2.0:语音表征的自我监督学习框架 (2020)，CoRR
[2] A. Kim，香农熵背后的直觉 (2018)，走向数据科学
[3] 熵(信息论)，维基百科。
[4] J. Devlin，M. Chang，K. Lee，K. Toutanova， BERT:用于语言理解的深度双向变压器的预训练 (2019) 。
[5]LibriSpeech 上的语音识别测试-clean ，试卷用代码。
Python 中 ENSO 和季风数据的小波&傅立叶分析
小波级数通过由小波生成的某个标准正交级数来表示实值或复值函数。我们不能简单地用傅立叶变换的基本知识来解释小波变换。
傅里叶变换
傅立叶变换是将信号从时域变换到频域的有用工具。频谱中的峰值对应于信号中出现最多的频率。当频谱稳定时(信号中存在的频率不依赖于时间)，傅立叶变换是可靠的。然而，整个时间序列的傅立叶变换不能告诉特定频率上升的瞬间。
一个快速的解决方法是使用滑动窗口找到一个给出时间和频率信息的频谱图(著名的短时傅立叶变换)。然而，这使用了窗口的刚性长度，因此限制了频率分辨率。这是由于信号分析中的不确定性原理(持续时间-带宽定理)在频率和时间分辨率之间进行了权衡(帕普利斯 1977；Franks 1969)，类似于量子力学中关于粒子位置和动量的海森堡测不准原理。
小波变换
因为在地球科学中，我们主要处理动态系统，所以大多数信号在本质上都是非*稳的。在这种情况下，小波变换是一种更好的方法。
小波变换在时域和频域中都保持高分辨率(Torrence & Compo 1998Chao 等 2014)。它告诉我们信号中存在的频率细节及其在时间上的位置。这是通过分析不同尺度的信号来实现的。与使用一系列不同频率的正弦波的傅立叶变换不同，小波变换使用一系列称为小波的函数，每个函数具有不同的尺度来分析信号。使用小波的优点是小波在时间上是局部的，不像它们在傅立叶变换中的对应物。可以通过将信号与时间上不同位置的小波相乘来利用小波的这种时间局部化特性，从信号的开头开始，慢慢地向信号的结尾移动。这个过程被称为卷积。我们可以通过在每次迭代中增加小波的尺度来迭代整个过程。这将给出小波频谱图(或标度图)。标度类似于傅立叶变换中的频率。标度可以通过以下关系式转换为伪频率:
这种关系表明，较高的比例因子(较长的小波)对应于较小的频率。因此，在时域中缩放小波可以用于分析频域中的较小频率。
小波分析在厄尔尼诺-南方涛动海表温度和印度季风降水资料中的应用
我将小波分析概念应用于以摄氏度为单位的厄尔尼诺-南方涛动(ENSO)海洋表面温度(1871-1997)和以毫米为单位的印度季风降雨量(1871-1995)(Torrence & Webster 1999)的季度数据集。小波频谱图中的颜色模式取为 log2(幂)。用于此分析的小波是复数 Morlet 小波，带宽为 1.5，归一化中心频率为 1.0。如果比例过低，则可能会因违反奈奎斯特频率而发生混叠。如果尺度太大，小波计算可能是计算密集型的。
import pywt
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
plt.style.use('seaborn')
dataset = "monsoon.txt"
df_nino = pd.read_table(dataset, skiprows=19, header=None)
N = df_nino.shape[0]
t0 = 1871
dt = 0.25
time = np.arange(0, N) * dt + t0
signal = df_nino.values.squeeze() #to get the scalar values
signal = signal - np.mean(signal)
scales = np.arange(1, 128) #set the wavelet scales
def plot_signal(time, signal, average_over=5, figname=None):
fig, ax = plt.subplots(figsize=(15, 3))
ax.plot(time, signal, label='signal')
ax.set_xlim([time[0], time[-1]])
ax.set_ylabel('Signal Amplitude', fontsize=18)
# ax.set_title('Signal + Time Average', fontsize=18)
ax.set_xlabel('Time', fontsize=18)
ax.legend()
if not figname:
plt.savefig('signal_plot.png', dpi=300, bbox_inches='tight')
else:
plt.savefig(figname, dpi=300, bbox_inches='tight')
plt.close('all')
plot_signal(time, signal) #plot and label the axis
在上面的代码中，我使用了 pandas read_table方法来读取monsoon.txt中的数据。我不确定我最初是从哪里获得季风数据集的，所以我不能引用来源。如果有人知道，请在下面评论。上面的脚本使用模块wavelet_visualize来计算和绘制下图。
信号图(图片由作者提供)
def get_fft_values(y_values, T, N, f_s):
f_values = np.linspace(0.0, 1.0/(2.0*T), N//2)
fft_values_ = np.fft.fft(y_values)
fft_values = 2.0/N * np.abs(fft_values_[0:N//2])
return f_values, fft_values
def plot_fft_plus_power(time, signal, figname=None):
dt = time[1] - time[0]
N = len(signal)
fs = 1/dt
fig, ax = plt.subplots(2, 1, figsize=(15, 3), sharex=True)
variance = np.std(signal)**2
f_values, fft_values = get_fft_values(signal, dt, N, fs)
fft_power = variance * abs(fft_values) ** 2 # FFT power spectrum
ax[0].plot(f_values, fft_values, 'r-', label='Fourier Transform')
ax[1].plot(f_values, fft_power, 'k--',
linewidth=1, label='FFT Power Spectrum')
ax[1].set_xlabel('Frequency [Hz / year]', fontsize=18)
ax[1].set_ylabel('Amplitude', fontsize=12)
ax[0].set_ylabel('Amplitude', fontsize=12)
ax[0].legend()
ax[1].legend()
# plt.subplots_adjust(hspace=0.5)
if not figname:
plt.savefig('fft_plus_power.png', dpi=300, bbox_inches='tight')
else:
plt.savefig(figname, dpi=300, bbox_inches='tight')
plt.close('all')
plot_fft_plus_power(time, signal)
傅立叶变换图(图片由作者提供)
def plot_wavelet(time, signal, scales, waveletname='cmor1.5-1.0', cmap=plt.cm.seismic, title='Wavelet Transform (Power Spectrum) of signal', ylabel='Period (years)', xlabel='Time', figname=None):
dt = time[1] - time[0]
[coefficients, frequencies] = pywt.cwt(signal, scales, waveletname, dt)
power = (abs(coefficients)) ** 2
period = 1\. / frequencies
scale0 = 8
numlevels = 10
levels = [scale0]
for ll in range(1, numlevels):
scale0 *= 2
levels.append(scale0)
contourlevels = np.log2(levels)
fig, ax = plt.subplots(figsize=(15, 10))
im = ax.contourf(time, np.log2(period), np.log2(power),
contourlevels, extend='both', cmap=cmap)
ax.set_title(title, fontsize=20)
ax.set_ylabel(ylabel, fontsize=18)
ax.set_xlabel(xlabel, fontsize=18)
yticks = 2**np.arange(np.ceil(np.log2(period.min())),
np.ceil(np.log2(period.max())))
ax.set_yticks(np.log2(yticks))
ax.set_yticklabels(yticks)
ax.invert_yaxis()
ylim = ax.get_ylim()
ax.set_ylim(ylim[0], -1)
cbar_ax = fig.add_axes([0.95, 0.15, 0.03, 0.7])
fig.colorbar(im, cax=cbar_ax, orientation="vertical")
if not figname:
plt.savefig('wavelet_{}.png'.format(waveletname),
dpi=300, bbox_inches='tight')
else:
plt.savefig(figname, dpi=300, bbox_inches='tight')
plt.close('all')
plot_wavelet(time, signal, scales)
小波变换图(图片作者提供)
决赛成绩
对于 ENSO 数据集的分析[下图(a-d)]，我们看到大部分功率集中在 2 到 8 年的周期内(或 0.125–0.5Hz)。我们可以看到，直到 1920 年，电力波动很大，而在那之后就没有那么多了。我们还可以看到，随着时间的推移，有一种从长到短的转变。对于印度季风数据集[下图(e-h)]，虽然能量在不同时期均匀分布，但随着时间的推移，能量也从较长时期向较短时期略有转移。因此，小波变换有助于可视化信号的这种动态行为。
ENSO(a-d)和印度季风降雨(e-h)时间序列的小波分析
(a)和(e)分别显示了 ENSO 和印度季风的时间序列，单位为 C 和 mm。(b)和(f)显示傅立叶变换，(c)和(g)分别显示 ENSO 和印度季风的功率谱。(图片由作者提供)
参考
- 赵本峰、钟文伟、施志忠、谢永元(2014)。地球自转变化:小波分析。史前新纪元，第 26 卷第 4 期，第 260-264 页。https://doi.org/10.1111/ter.12094
- 弗兰克斯，L. E. (1969 年)。信号理论。
- 帕普利斯(1977 年)。信号分析(第 191 卷)。纽约麦格劳希尔公司。
- c .托伦斯和 G. P .康普公司(1998 年)。小波分析实用指南。美国气象学会通报，79(1)，61–78。
- 小波变换(维基百科)
原载于 2021 年 4 月 5 日【https://www.earthinversion.com】。
用谷歌 JAX 在 Python 中实现小波变换
一个简单的数据压缩例子
来自 scikit-image 的草样本图像(左)，作者进行的小波系数计算、压缩和重建
小波变换是信号分析的关键工具之一。它们广泛应用于科学和工程领域。一些特定的应用包括数据压缩、步态分析、信号/图像去噪、数字通信等。本文通过使用 CR-Sparse 库中提供的 DWT(离散小波变换)支持，关注一个简单的有损数据压缩应用程序。
有关小波变换的详细介绍，请参见:
- 维基百科，小波变换
- 小波教程，第一部分
- C. Valens，一本真正友好的小波指南
- 韦达科维奇和穆勒，儿童小波，教程介绍
Python 中的小波
Python 中有几个包支持小波变换。让我列举几个:
- py wavelet是 python 中对离散和连续小波支持最全面的实现之一。
- py torch-wavelet支持 2D 离散小波和 2d 双树复小波变换。
- scipy 为连续小波变换提供了一些基本的支持。
PyWavelet 可能是可用的最成熟的库。它的覆盖面和性能都很棒。然而，该库的主要部分是用 c 编写的，因此，为 GPU 硬件实现重定向是不可能的。这也是人们想出更新的实现的原因之一，例如在 PyTorch 之上，py torch 提供了必要的 GPU 支持。
谷歌 JAX
CR-Sparse 库现在支持使用谷歌 JAX 库计算离散和连续小波变换。
JAX 通过利用 XLA 提供高性能数值计算。XLA 是一个特定领域的线性代数编译器。JAX 提供了一个类似 NumPy 的 API 和一个 JIT 编译器，这样使用 JAX 编写的代码可以很容易地被及时编译(使用 XLA)成特定硬件架构的机器代码。
因此，您可以在 JAX API 的基础上编写纯 Python 代码，并构建复杂的数值算法，这些算法可以高效地交叉编译到不同的 GPU 架构。
JAX 有像 pmap 这样的工具，它使得代码的并行评估变得简单明了。对于大型数据集，JAX 甚至在 CPU 上轻松胜过 NumPy。
然而，利用 JAX 确实需要一些工作。我们必须以某种方式编写我们的数值算法，以便它们可以被 JIT 编译。一个特定的需求是所有的代码都是使用函数式编程原则编写的。例如，JAX 数组是不可变的(而 NumPy 数组不是),所以对数组的任何更改实际上都在 Python 代码级别创建了一个新数组。XLA 编译器很聪明，可以重用内存。在某种程度上，以函数方式重写数值算法是一种非常有益的体验。它让您专注于基本的数学，避免不必要的全局状态操作，保持实现相当干净和简单。
CR-稀疏中的小波支持
CR-Sparse 专注于稀疏信号处理的功能模型和算法，即在信号处理问题中利用信号表示的稀疏性。小波变换是构造常见信号稀疏表示的关键工具。因此，它们构成了 CR-Sparse 库的重要部分。该实现是纯 Python，使用 JAX 遵循的函数式编程原则编写，并及时编译为 CPU/GPU/TPU 架构，无缝提供出色的性能。小波模块 API 受到py wavelet的启发并与之相似。此外，小波功能已经被包装成类似于 PyLops 的 1D 和 2D 线性算子。
请参考我以前的文章用谷歌 JAX 在 Python 中实现线性操作符以获得更多关于线性操作符设计的信息。
简单的小波数据压缩
分解和重构
小波变换是可逆的。
- 我们可以使用小波分解信号，通过称为离散小波变换(DWT)的算法获得小波系数。信号被分解成两组系数:*似系数(信号的低通分量)和细节系数(高频。
- 我们可以使用一种称为离散小波逆变换(IDWT)的算法从小波系数中重建信号。
多级分解
- 通常，小波分解要进行多次。
- 我们从信号开始，计算*似和细节系数，然后对*似系数再次应用 DWT。
- 我们多次重复这一过程，以实现信号的多级分解。
以下示例显示了一个 4 级分解
X => [A1 D1] => [A2 D2 D1] => [A3 D3 D2 D1] => [A4 D4 D3 D2 D1]A1, D1 = DWT(X)
A2, D2 = DWT(A1)
A3, D3 = DWT(A2)
A4, D4 = DWT(A3)
- 通过应用 DWT，信号 X 被分成*似和细节系数 A1 和 D1。如果信号有 N 个系数，那么分解将有 N/2 个*似系数和 N/2 个细节系数(从技术上讲，如果我们在计算 DWT 时使用周期化扩展，其他扩展会导致更多的系数)。
- 通过应用 DWT，*似系数 A1 已经再次分裂成*似和细节系数 A2 和 D2。
- 我们重复这个过程 2 次以上。
- 通过连接 A4、D4、D3、D2、D1 中的系数来获得 X 的 4 级分解。
- 如果信号 X 有 N 个样本，那么小波分解也将由 N 个系数组成。
信号的重建过程如下:
A3 = IDWT(A4, D4)
A2 = IDWT(A3, D3)
A1 = IDWT (A2, D2)
X = IDWT(A1, D1)
简单数据压缩
- 结果表明，如果我们丢弃一些细节系数，信号仍然可以在相当高的信噪比下如实重建。
- 如果我们去掉 D1 系数，我们可以实现 50%的压缩。如果我们降低 D1 和 D2 系数，我们可以实现 75%的压缩。
一个重要的考虑是在从剩余系数重构信号之后测量信噪比。如果压缩技术好，信噪比就会高。
这是对压缩问题的一种非常简单的处理方式，但它足以满足本文的目的。
我们现在展示使用 1D 和 2D 小波变换进行信号和图像压缩和重建的示例代码。详细的示例代码可以在示例库(在 CR-Sparse 文档中)这里找到。
此示例针对存储库中的最新版本运行，该版本可通过以下软件安装:
python -m pip install git+https://github.com/carnotresearch/cr-sparse.git
1D 信号分解、压缩、重建
第一，必要的进口。我们还需要 JAX，matplotlib 和 scikit-image 库。
**import** **jax.numpy** **as** **jnp**
**import** **matplotlib.pyplot** **as** **plt**
**import** **cr.sparse** **as** **crs**
**from** **cr.sparse** **import** lop
**from** **cr.sparse** **import** metrics
**import** **skimage.data**
**from** **cr.sparse.dsp** **import** time_values
在本例中，我们将构建一个由不同频率和幅度的多个正弦波组成的信号。
fs = 1000.
[T](https://docs.python.org/3/library/functions.html#int) = 2
t = time_values(fs, [T](https://docs.python.org/3/library/functions.html#int))
[n](https://docs.python.org/3/library/functions.html#int) = t.size
x = jnp.zeros([n](https://docs.python.org/3/library/functions.html#int))
freqs = [25, 7, 9]
amps = [1, -3, .8]
**for** (f, amp) **in** zip(freqs, amps):
sinusoid = amp * jnp.sin(2 * jnp.pi * f * t)
x = x + sinusoid
正弦波混合样本(作者提供)
CR 稀疏线性算子模块(lop)包括 1D 小波变换算子。我们将构造操作符。我们将提供信号的大小、小波类型和分解的级数作为这个操作符的参数。
DWT_op = lop.dwt(n, wavelet='dmey', level=5)
通过对数据应用线性算子来计算小波系数。阅读这里的了解线性操作符如何在 CR-Sparse 中工作。
alpha = DWT_op.times(x)
信号的小波系数(由作者计算)
有趣的是，大部分细节系数可以忽略不计。小波系数的大小表示该系数携带的信号能量部分。丢弃这些系数不会导致很高的重建误差。
让我们去掉 10%的系数(压缩):
cutoff = [n](https://docs.python.org/3/library/functions.html#int) // 10
alpha2 = alpha.at[cutoff:].set(0)
出于我们的目的，我们只是将这些系数设置为 0。在数字通信设置中，这些系数不会被传输，并且会被接收器假定为零。我们还看到数组更新的语法有点困难。由于数组在 JAX 中是不可变的，因此 JAX 提供了通过更新旧数组的一部分来构造新数组的函数变体。详见此处。
我们现在通过应用 DWT 线性算子的伴随算子(恰好是它的逆算子)从剩余的系数中重构原始信号。
x_rec = DWT_op.trans(alpha2)
snr = metrics.signal_noise_ratio(x, x_rec)
print(snr)
信噪比为 36.56 dB。
使用逆 DWT 完成重建(作者)
从这个图中我们可以看出，重建误差可以忽略不计。
2D 图像分解、压缩、重建
现在让我们在 2D 图像上试试运气。在这个演示中，我们将从 scikit-image 库中获取一个草地图像样本。
image = skimage.data.grass()
2D DWT 是 1D DWT 的直接扩展。
- 给定大小为 NxN 的图像 X，计算每一列的 DWT。我们得到两个新图像 CA 和 CD，每个图像的大小为 N/2×N(即行数的一半)。
- 对 CA 的每一行应用 DWT，以获得 CAA 和 CAD 图像(每个图像的大小为 N/2 x N/2)。
- 对 CD 的每一行应用 DWT 以获得 CDA 和 CDD 图像。
- 这样我们把 X 分割成[CAA，CAD，CDA，CDD] 4 个子图。
- 我们可以组合这些子图像以形成单个系数图像。
- 我们递归地在 CAA 部分上重复 2D DWT 分解，以计算多级分解。
2D IDWT 将[CAA，CAD，CDA，CDD]作为输入，并将 X 作为输出返回(首先对行应用 IDWT，然后对列应用 IDWT)。
我们将使用具有 5 级分解的 2D·哈尔小波变换算子。
DWT2_op = lop.dwt2D(image.shape, wavelet='haar', level=5)
DWT2_op = lop.jit(DWT2_op)
计算小波系数就是对图像应用线性算子:
coefs = DWT2_op.times(image)
让我们只保留 1/16 的系数(即只有 6.25%的系数)。我们将删除第一级和第二级细节系数。
h, w = coefs.shape
coefs2 = jnp.zeros_like(coefs)
coefs2 = coefs2.at[:h//4, :w//4].set(coefs[:h//4, :w//4])
重构包括应用恰好是其逆算子的伴随算子。重建后，我们将计算峰值信噪比来衡量重建的质量。
image_rec = DWT2_op.trans(coefs2)
# PSNR
psnr = metrics.peak_signal_noise_ratio(image, image_rec)
print(psnr)
PSNR 是 19.38 分贝。
作者仅使用 6.25%的小波系数进行图像重建(来自 scikit-image 的草地样本图像)
小波系数只有 6%的 19 dB PSNR 并不坏。此外，图像的细节得到很好的保留，没有块状伪像。
我希望这篇文章很好地介绍了 CR-Sparse 中可用的小波变换功能。
对于更高级的用法，请查看使用 LSQR 和 FISTA 算法的图像去模糊示例。
WBF:优化目标检测——融合和过滤预测框
思想和理论
加权盒融合已经成为优化目标检测模型的新 SOTA
目标检测是最常见和最有趣的计算机视觉任务之一。最*的 SOTA 模型，如 YOLOv5 和 EfficientDet，令人印象深刻。这篇文章是关于一种新的 SOTA 新技术，称为加权盒融合，优化了一个巨大的目标检测问题。这是一种先进的对象检测技术，我是在目前正在进行的 VinBigData Kaggle 比赛中遇到它的。
如果你熟悉物体检测的工作原理，你可能知道总有一个中枢 CNN 提取特征。还有另一个阶段，要么生成区域提议(可能的边界框)，要么过滤已经提出的提议。这里的主要问题是，这根本不是一项简单的任务，实际上相当困难。这就是为什么对象检测模型要么最终生成大量的边界框，要么没有足够的边界框，最终导致低*均精度。已经提出了几种算法来处理这个问题，我将首先介绍一下。
如果你对理论上的解释不感兴趣，你可以直接跳到最后的编码教程，在那里我将展示如何将这种技术应用到一个非常具有挑战性的数据集上，这个数据集是我一直在做的( VinBigData )。
给你一点背景，这个比赛是关于用 x 光检测肺部疾病的。你的模型必须能够区分 14 种不同的疾病，并为每种疾病预测疾病所在的边界框。这变得更加困难，因为每幅图像可能有一种以上的疾病(因此，您必须预测多个不同的边界框)。
第一个问题是疾病由多个不同的放射科医生标记，并且对于相同的异常可能有多个不同的边界框。所以我们必须过滤这些(或者在这种情况下“融合”它们)以避免混淆我们的模型。
第二个问题是，一些密集的疾病区域包含多个标签，这意味着一个小的边界框可以有多个疾病标签。这使得我们的生活有点困难，如果我们使用类似 NMS 的东西，因为我们是基于 IoU 过滤盒子(这在这里经常发生)。所以像 NMS 这样的方法很可能会去掉有用的盒子。
请注意，所有这些技术都可以以两种方式使用。要么预处理您的数据以过滤掉不精确的带标签的边界框(这是我将在这里做的)，要么过滤掉由您训练以提高准确性的模型预测的边界框(或两者都进行)。
我将讨论每一种技术，包括使用该技术前后边界框的可视化。
- 非最大抑制(NMS)
如果你熟悉物体检测，你可能听说过 NMS。给定对象检测模型的每个预测由边界框坐标、类别标签和置信度得分组成，NMS 工作如下:
- 如果这些框在并集 IoU 上的交集高于指定的阈值保持超参数，则这些框被过滤成 1 个框。IoU 本质上是两个框之间的重叠量。
这里的主要挑战是，如果对象是并排的，其中一个将被消除(因为 IoU 将相当高)。
来源: arxiv
图片由作者转载。我们可以清楚地看到右边的方框变少了。
2.软 NMS
第二种方法试图用一种更“软”的方法来解决 NMS 的主要问题。它不是完全移除 IoU 高于阈值的盒子，而是根据 IoU 值降低它们的置信度得分。
图片由作者转载。“软”方法导致过滤掉更少的框(这就是为什么与 NMS 相比，右边有更多的框)
3.加权盒子融合(WBF)
WBF 算法的工作方式与 NMS 算法不同。这本书有点长，而且确实涉及到很多数学方程式，但我会尽我所能给你一个简单的概述，不会让你对细节感到厌烦。
首先，它按照置信度得分的降序对所有边界框进行排序。然后，它生成另一个可能的框“融合”(组合)列表，并尝试检查这些融合是否与原始边界框匹配。它通过检查 IoU 是否大于指定阈值(超参数)来实现。
然后，它使用一个公式来调整融合框列表中所有框的坐标和置信度得分。新的置信度得分仅仅是融合它的所有盒子的*均置信度得分。新的坐标以类似的方式融合(*均)，除了坐标被加权(意味着不是每个框在结果融合框中具有相同的贡献)。权重的值由置信度得分确定，这是有意义的，因为低置信度得分可能指示不正确的预测。
就是这样，当然，这是高层次的，如果你想深入研究数学和低层次的细节，我建议在这里查看论文。然而，*心而论，当我在高层次上理解一些东西是如何工作的，实现它，测试它，然后只在需要时回到低层次的细节时，我通常会获得大部分的价值。如果你总是钻研底层的细节，你最终会学到理论是如何工作的，但实际上并没有实现它的大部分。
图片由作者转载。
还值得一提的是，还有第四种方法叫做非最大加权 融合，其工作方式类似，但性能不如 WBF。这是因为它不会改变盒子的置信度得分，而是使用 IoU 值来衡量盒子，而不是使用置信度得分这一更准确的衡量标准。不过他们的表现非常接*:
来源: arxiv
图片由作者转载。
编码部分
好了，理论部分到此为止，让我们开始编码吧！衡量这篇论文是否真的好的最好方法之一是看他们是否发布了高质量的代码，在这种情况下，他们确实发布了。你可以在 Github 上查看
他们提供了一个易于使用的库。这里有一个例子
boxes, scores, labels = weighted_boxes_fusion(boxes_list, scores_list, labels_list, weights=weights, iou_thr=iou_thr, skip_box_thr=skip_box_thr)
如果您想尝试其他方法，可以用“nms”或“soft_nms”或“non_maxmimum_weighted”替换“weighted_boxes_fusion ”,这样就可以很好地工作。
我遇到这个库/技术的最初原因是，在 Kaggle 的 VinBigData 竞赛中，数据集有两个主要问题导致对象检测模型表现不佳。
竞赛给出的原始数据帧已经包括了每个图像的边界框、标签。所以这些将是上面 WBF 函数输入的一部分
作者图片
因为我们将在这里使用它进行预处理，所以我们可以将“权重”和“分数”设置为 1，这样每个盒子将被同等对待(因为我们还没有预测)。就是这样！这个库非常简单，只有一行代码，你传入一个边界框和分数的列表，然后你得到一个更整洁的列表。
最终想法
我将很快发布几篇关于我从这场比赛中学到的经验的文章，大部分是先进的物体探测技术，所以如果你感兴趣，请跟我来。
我们不是数据科学家，我们是商业科学家
意见
数据科学是时候进行品牌更新了
照片由 Unsplash 上的 this engineering RAEng 拍摄
我一直不喜欢数据科学家这个头衔。这违反了标签艺术的黄金法则。描述一下。当然，当你向朋友和家人谈论你的工作时，这种神秘感是有一定诱惑力的。
但是“哦和啊”很难用一个连贯的解释来解释你到底在做什么。我认为称自己为数据科学家是这个职业的净损失，不仅仅是因为这个微不足道的原因。但是在我深入到更具体的问题之前，让我把我的解决方案放在前面和中心。
数据科学家应该将自己重新定义为商业科学家。
让我试着说服你。
对外来者和就业市场的购物者来说，数据科学家是模糊的
科技行业已经开始看到在招聘中使用这个总括术语的痛苦，这就是为什么我们看到公司开始招聘更专业的角色，如机器学习工程师、深度学习工程师、数据工程师等。
即使出现了这些子专业，行业仍然坚持数据科学家的想法。当我今天被问及这意味着什么时，我倾向于给与凯西·科泽尔科夫相同的答案
"数据科学是让数据变得有用的学科."
我认为这个定义是人们所能得到的最准确的描述，但我仍然认为它没有以激励数据科学家尽最大努力的方式来描述这个角色。
数据科学家过于强调方法，而对知识和影响不够重视
在我职业生涯的早期，如果有人问我“我们如何让数据变得有用”这个问题，我会回答“机器学习模型！”或者“计量经济学！”数据科学的这一定义导致我们过于关注使数据在总体上有用的方法，而较少关注使数据在您的工作环境中有用的实践。
这并不是说方法不重要，我只是认为我们对方法的关注过度了，而对在我们工作的业务中构建上下文和有影响力的知识的关注不足。我们用科学来建造像火箭飞船这样的酷东西，这通常是有效的！我认为这部分是因为我们有火箭科学家在从事这项工作。人们把目光聚焦在了火箭的科学 。
由 SpaceX 在 Unsplash 上拍摄的照片
是时候介绍商业科学家了。这里要关注的是……你猜它的科学业务(更确切地说是你的业务！)
为了理解为什么“商业科学家”是一个比数据科学家更合适的头衔，我们需要首先理解我们称之为科学的东西是什么。我从两个可靠的来源拼凑了一个连贯的定义维基百科，(当然)和斯坦福哲学百科全书
在通常被认为是科学特征的活动中，有系统的观察和实验，归纳和演绎推理，以及假说和理论的形成和检验。
因此，科学家是一个通过实验、观察和推理进行理论和假设生成以及后续测试的个体。那么，数据科学家这个名字意味着我们正在产生一些关于数据的理论…并测试关于…数据的理论？
数据是科学的手段
这里的问题是，在现实中，数据不是目的，而是达到目的的手段。数据是我们通过观察、实验和逻辑处理收集的。
作为数据科学家，我们应该成为我们所在业务或业务部门的专家，并努力 1。)理解组成业务的动态系统；2.)根据我们的理解，构建工具来改进该系统。
数据科学家应该考虑更名为商业科学家。
你被雇佣来成为你所在行业的专家，并运用科学的方法来理解和改进管理你工作的商业环境的随机的和极其复杂的过程。
如果数据科学家认为自己更类似于植物学家或发展心理学家，即开发全面领域专业知识，然后应用科学方法来理解和改善其领域成果的人，我认为我们可以对我们的业务产生更积极的影响，并允许麦肯锡的合作伙伴停止撰写关于如何没有人听数据科学家的文章，并回到计费客户那里制作漂亮的幻灯片(抱歉，我不得不开玩笑)。
通过将数据科学家的角色重新定义为商业科学家，我们可以改变一些(但不是全部！)职业的重点从方法和工具转向知识生成和业务影响驱动的科学。嘿，我们仍然可以保留“科学家”这个词我们都知道这是最精彩的部分。
我们进行了一轮数据科学竞赛，结果发生了这种情况！
预测鱼量的简单与复杂模型
本文将讨论我们与一个班级举办的数据科学竞赛。我们将讨论五个得分最高的模型及其复杂性。
介绍
挑战在于创建一个预测鱼体重的机器学习模型。其模型具有最低均方误差(MSE)的学生将被宣布为获胜者！
挑战
你好！欢迎来到日本东京著名的筑地鱼市场！我们来这里收集他们的鱼的数据，但我们没有在早上 5 点醒来参加金枪鱼拍卖。当我们出现的时候，只剩下一些种类的鱼了。我们收集了剩余鱼的测量值，并希望您使用这些特征训练一个回归模型来预测鱼的重量。
我们将拿出 30%的数据，并使用该 csv 进行评分。我们将根据他们的模型在这些原始数据上预测体重的表现对学生进行排名。分数将根据均方差排名决定。
这是一场一次性比赛。不允许调整模型。也就是说，有一次提交模型的机会，我们将使用它尚未看到的维持数据来度量它。
这是我们的鱼类数据。在训练数据集中的 112 行中有 7 个特征。
鱼类数据
下图显示了鱼的长度。这样，我们可以理解长度 1-3。
测量一条鱼
高度是从鱼的腹部到最厚处的脊骨。宽度是周长的度量。重量以克为单位，长度以厘米为单位。如果你感兴趣，这里有一个数据集的链接！
https://www.kaggle.com/aungpyaeap/fish-market
让我们看看前 5 名学生模型(按 MSE 排名)及其方法论。
前 5 名模特
即使只上了一周的机器学习课程，我们的学生也想出了一些创造性的解决方案！值得注意的是，排名前五的模型要么都是决策树，要么都是随机森林和线性回归模型。这些模型相对简单，有很强的偏向性。线性回归假设一个线性问题。决策树更加灵活，并假设一个逐步的功能。决策树经常过度拟合它们的训练数据，但是随机森林可以在建立模型时减轻这种风险。
现在让我们看看我们的前五名学生模特！
第五名——2659 毫秒
我们的第五名选手使用了一个带有一些附加功能的决策树。这些增加的特征之一是椭球的体积。这个几何特征试图捕捉鱼的形状。
约翰·卡梅隆在 Unsplash 上拍摄的照片
这名学生还选择使用梯度助推器。梯度推进是一种在决策树集合中产生预测模型的技术。这被称为梯度增强树，通常优于随机森林。它像其他 boosting 方法一样以分阶段的方式构建模型，并通过允许优化任意可微分损失函数来推广它们。
这位学生的增加了几何特征的梯度提升树获得了 2659 的 MSE，为他们赢得了前 5 名的成绩。
第四名——2332 毫秒
我们的第四名学生编写了可能是最优雅的解决方案。这名学生将原始特征输入线性回归模型，得出 MSE 为 2332。这种易于实施且简单明了的模型胜过了 90%的学生模型，获得了第 4 名！
线性回归，通常被认为是一个简单的机器学习模型，永远不应该被低估。
第三名——2163 毫秒
排名第三的完成者建立了一个线性回归模型，增加了一些功能，并使用了 LassoCV。额外的特征是长度和长度的二次项之间的差异。
套索回归是一种使用收缩的线性回归。收缩是指数值向一个中心点收缩。套索程序鼓励使用较少参数的模型。
engin akyurt 在 Unsplash 上拍摄的照片
这种特殊类型的回归非常适合显示高度多重共线性的模型(如我们的鱼类数据！).Lasso 回归具有自动内生最佳子集选择的额外好处。当向您的训练数据中添加许多附加功能时，这个自动化功能非常有用！
这个学生用 LassoCV 建立的线性回归模型产生了 2163 的 MSE，获得了第三名。
第二名——2034 毫秒
我们的第二名学生也使用了线性回归模型，并添加了几个几何特征来捕捉鱼的形状。三个增加的变量是 hw 和 l32 和(l32)h*w。这些变量代表从头到尾穿过鱼的矩形*面、穿过 l3 的正方形*面和围绕整条鱼的盒子。
这个简单的模型加上一些几何推理产生了 2034 的 MSE 和第二名的成绩！
戏剧性的鼓声
第一名——802 毫秒
干杯！乔治·特罗瓦托在 Unsplash 上的照片
我们的第一名选手使用了隔离森林。隔离森林是一种异常检测算法，其工作原理是隔离异常值。剔除异常值可能是将该模型提升到首位的关键特性！通过从训练集中分离出异常值，这名学生建立了一个比同龄人更准确的模型。
这个学生还使用了一个额外的树回归变量。该回归器随机生成决策树，然后使用*均来提高预测精度和控制过拟合。
这款车型的 MSE 得分为 802，远低于其他前 5 名选手！
结论
注意，这里使用的所有模型都相对简单。所有五个顶级模型都没有很大的灵活性。这对这个问题很好，因为我们可以假设鱼的大小和质量之间的线性关系。超过一定程度的灵活性，您将得到在新数据上表现不佳的模型。
在竞赛环境中，学生通常会过度设计(和过度拟合)模型，特别是当给定 100%的数据来训练模型和多次提交尝试时。通过保留 30%的数据并只允许一次提交，我们试图减少这种行为。
复杂的模型并不是天生更好的模型。当用新数据进行测试时，复杂模型的表现往往不如简单模型。以我们的第四名模型为例。它需要最少的工程。简单的线性回归与原来的功能！没有花费额外的时间来设计额外的功能或使用各种回归优化模型，该模型的表现超过了班上 90%的学生。
我们不需要数据工程师，我们需要为数据科学家提供更好的工具
(来源)
正如我们所知，数据工程师的角色之所以存在，是因为缺乏足够的工具来支持数据科学家
在大多数公司，数据工程师以各种方式支持数据科学家。这通常意味着翻译或生产数据科学家写的笔记本和脚本。对于数据科学家来说，数据工程师的大部分角色可以被更好的工具所取代，从而解放数据工程师来做更有影响力(和可伸缩性)的工作。
为什么这很重要？
互联网上流传着一种观点:我们不需要数据科学家，我们需要数据工程师。
这些文章关注的是“数据工程师”和“数据科学家”的职位空缺数量。我们姑且不论发布这些职位的招聘经理往往不知道这两个职位的区别，而是互换使用(或者使用目前流行的任何东西)。就本文而言，我们可以从表面价值来看待头寸的存在。那么问题就变成了:数据工程师职位的过剩仅仅是一个人员问题吗？
数据科学是混乱的，因为它反映了现实世界
数据科学家是领域专家(除了了解统计学之外)，他们通常没有很强的编程背景。我已经在多个 Twitter 和论坛帖子中看到了这种专业知识的折扣，软件工程师和其他“技术人员”会问类似“他们为什么不学习 Spark？”。这种心态完全忽略了一个事实，即数据科学家已经可以用他们现有的工具在更小的范围内做他们想做的事情。数据科学家希望获得洞察力，而不是担心构建优雅的管道。公司想要可操作的东西，而不是漂亮的东西。
洞察力比优雅的管道更重要。
流行的数据科学工具也受到更多技术人士和学者的批评:“为什么会有人用熊猫？”。熊猫一定是最受那些对它毫无用处的人憎恨的工具。然而，它受到每天使用它的数据科学家的喜爱(或者至少是欣赏)。
如果熊猫真的如此糟糕，为什么没有什么能让它下台？
熊猫和其他工具一样，是用来处理现实世界的混乱的。看看read_csv有多少个参数就知道了:
https://pandas . pydata . org/docs/reference/API/pandas . read _ CSV . html
如果 pandas 如此糟糕，为什么没有任何东西取代它成为 Python 数据科学的标准数据框架？为什么会在领养上连年持续增长？它不是最快的，也不是最健壮的，为什么呢？
数据工程师必须处理可扩展工具无法处理的混乱
对于生产使用来说足够健壮的可伸缩系统(例如 Apache Spark)不能处理现实世界的混乱。没有清晰简单的假设，就很难扩展，问题越乱，就越难扩展。数据工程师处理混乱，因为可扩展的工具不能。
杂乱无章的缩放极其困难。数据工程师处理混乱，因为工具不能。
在这种情况下，脏乱意味着:
- 组/连接键倾斜
- 分割
- 调试分布式系统
- 集群配置和资源供应
对于较小规模的系统，这些都不是你需要担心的事情。在湾区之外，大多数数据工程师花时间调试和翻译一个分布式系统，通常是 Spark。
需要多次重写才能将一次性见解转化为生产作业。
在这里，我们真的不能指责任何人，构建今天使用的可伸缩工具的人是在为像他们一样的高技术用户构建。高技术人员不需要他们的工具来为他们处理混乱，通常他们想要调整旋钮。在系统工程中，狗食是一个流行的概念:“建造它的人也使用它”。我认为，对狗食化的担忧在一定程度上导致了我们今天在数据科学中看到的景象:“只有像构建系统这样的技术人员才能使用它”。
那么，数据工程师应该做什么呢？
数据科学生态系统需要不仅仅关注构建它的人的问题的系统。在过去的 10 多年里，数据科学家大多都在使用相同或相似的工具。对此的解释有两个:(1)数据科学家喜欢使用他们现有的工具，因为他们了解这些工具；(2)那些有能力构建大规模系统的人在很大程度上(无意中)忽略了那些技术不如他们的人的问题。
我们需要数据工程师来帮助构建工具，以增强数据科学家的能力，而不是将熊猫转化为火花。
我们需要数据工程师来帮助构建可扩展的工具，为数据科学家提供支持，而不是将熊猫转化为火花。有谁比当今的数据工程师更适合帮助构建下一代数据科学工具呢？
相比原生 Spark 3.0，我们在 AI 应用领域取得了显著的优化效果
介绍 OpenMLDB 及其相对于原生 Spark 的优势
SpaceX 在 Unsplash 上拍摄的
背景
Spark 已经迅速成为大数据处理事实上的标准，无需介绍，但 Spark 在 AI 场景下仍有很多不足。
- 好:原生 Spark 擅长 Hadoop 集群中的大数据处理
- 不足:SparkSQL 的缺点在特征提取领域逐渐暴露出来
- 不足:考拉，阿帕奇 Spark 上的熊猫 API
即使 SparkSQL 和 Koalas 项目可以提供一些重要的数据处理功能，但特征提取所需的功能支持仍然非常有限。所支持的时序特征计算的性能不令人满意。只能支持离线分析，但对于 AI 制作，还需要在线计算。而且因为这个过程要反复使用 UDF/UDAF，所以开源的 Spark 和 AI 的融合还有很大的提升空间。
目前，业界已经涌现出越来越多的原生执行引擎解决方案，如 Databricks 的光子模块、Intel 的 OAP 项目、Nvidia 的 Spark-rapids 项目、阿里巴巴的 EMR 服务等。这些项目都有其亮点。它们可以通过底层原生代码生成，充分利用 CPU 矢量化和 GPU 并行计算特性，显著提升 Spark 在特定场景下的性能。但还是有一些不足。首先，它只能支持离线计算和在线特征计算，以及 AI 场景落地所需的在线模型估计服务。其次，对于常用的时间序列计算功能(SQL Over Window)没有进一步优化，最后，对于 AI 场景，特征提取功能也缺乏支持。
几种火花发动机的比较
作者图片
所以我们发布了我们的项目 OpenMLDB (SparkFE 是 OpenMLDB 的引擎)。它可以弥补上述项目的不足，在人工智能应用中取得更好的性能。基于 LLVM 优化，性能比原来的 Spark 提高了 6 倍以上。
优势
- 基于 LLVM 优化，高性能性能比原来的 Spark 提升 6 倍以上。
- 对于 AI，扩展 SQL 语法，支持更多的 FE 函数和时序特征计算。
- 线上线下一致，通过时间序列数据库的窗口特征聚合计算，实现 SQL 一键上线。
- 无迁移成本，兼容 SparkSQL 应用，Scala、Java、Python、R 应用无需修改代码即可享受性能提升。
- 所以，最后，无论是时间序列特征计算场景，还是机器学习的特定表组成场景，最终的性能测试结果都表明 OpenMLDB 在不增加硬件成本的情况下，可以实现 6 倍到上百倍的性能提升。
时间序列特征提取。作者图片
用于机器学习的自定义表连接。作者图片
与原生 Spark3.0 相比的性能优化
这里我们介绍一下 OpenMLDB 的一些应用场景，重点是性能优化的方法。
第一个优化是原生窗口计算。
底层基于 C++双向队列数据接口，高效实现标准窗口和子窗口功能。扩展 SQL 实现的 ROWS_RANGE 边界也可以更好的解决相同毫秒数据的计算顺序问题。本机窗口计算
- 本机窗口计算
- ➡Performance 改进
- ➡行 _ 范围界限
- 带有联合表的➡窗口
- ➡处理微秒级冲突
select trip_duration, passenger_count,
sum(pickup_latitude) over w as vendor_sum_pl,
max(pickup_latitude) over w as vendor_max_pl,
min(pickup_latitude) over w as vendor_min_pl,
avg(pickup_latitude) over w as vendor_avg_pl,
sum(pickup_latitude) over w2 as pc_sum_pl,
max(pickup_latitude) over w2 as pc_max_pl,
min(pickup_latitude) over w2 as pc_min_pl,
avg(pickup_latitude) over w2 as pc_avg_pl ,
count(vendor_id) over w2 as pc_cnt,
count(vendor_id) over w as vendor_cnt
from t1
window w as (partition by vendor_id order by pickup_datetime ROWS_RANGE BETWEEN 1d PRECEDING AND CURRENT ROW),
w2 as (partition by passenger_count order by pickup_datetime ROWS_RANGE BETWEEN 1d PRECEDING AND CURRENT ROW);
优化的第二点是本机 LastJoin 实现。
这种扩展连接类型可以确保表组装后的结果与拼接前的结果相同。Spark 源代码级别的原生实现比基于 Spark 3.0 的实现快 100 多倍，并且节省更多内存。
SELECT t1.name FROM t1 LAST JOIN t2 WHERE t1.id == t1.id
LastJoin 性能。作者图片
优化的第三点是多窗口并行计算的优化。
Spark 默认的串行执行被优化为并行计算，充分利用了集群计算资源，SparkSQL 整体任务时间也可以大大减少。
SELECT
min(age) OVER w1 as w1-min-age,
min(age) OVER w2 as w2-min-age
FROM t1
WINDOW
w1 as (PARTITION BY name ORDER by age ROWS BETWEEN 10 PERCEDING AND CURRENT ROW),
W2 as (PARTITION BY age ORDER by age ROWS BETWEEN 10 PERCEDING AND CURRENT ROW)
作者图片
优化的第四点是时间窗口数据偏差计算
与表格不对称优化类似，该窗口对不对称数据进行了两次分区，从而显著提高了任务的计算并行性，并充分利用集群资源来降低总体 TCO(总拥有成本)。
opt 之前，并行度:2。作者图片
opt 之后，并行度:4。作者图片
SparkFE(现在合并到 OpenMLDB )有很多不能重复的优化。由于兼容 SparkSQL API，应用场景与 Spark 类似，尤其是在 AI 相关的时序特征计算、数据表拼接方面。
- 时间序列特征提取
- 多窗口并发
- 自定义表连接
- 自定义特征提取功能
- 偏斜优化
- 本机聚合函数
这里是 OpenMLDB 的架构，欢迎来到社区。
作者图片
我们必须停止人工智能情感识别
人工智能
对这个价值数十亿美元的行业意味着什么？
情感识别是人工智能的一个分支，旨在识别人脸的情感。在过去的十年里，学术界和工业界对它的兴趣越来越大，预计到 2025 年，这个市场将增长到850 亿美元。它有几种应用，其中大多数至少在伦理上是有问题的。它允许雇主通过对潜在雇员的同情心、情商和其他特质进行评分来评估他们。它可以帮助教师远程监控学生在学校的参与度，或者当他们在家做作业的时候。它用于识别“危险人物”它已经被用来控制美国与墨西哥的边境。
科技巨头通常是潜在有利可图技术的早期采用者，他们很快理解了这种系统的价值，并已经部署；情感识别软件，他们提供了大量的数据。2016 年推出的亚马逊 Rekognition ，可以从图像或视频中的人脸识别基本情绪。同年，微软宣布了人脸 API ，这是一种可以检测“愤怒、轻蔑、厌恶、恐惧、快乐、中性、悲伤和惊讶”的算法他们进一步声称，“这些情绪被认为是跨文化的，普遍通过特定的面部表情进行交流。”
除了成熟的公司之外，建立情绪识别系统的动力如此强大，以至于催生了一大批创业公司。总部位于南约旦的 HireVue “将应聘者的语调[…]和细微的面部表情与之前被认为表现出色的人进行比较。Eyeris 的目标是利用面部和情感识别让汽车“比现在安全得多”。苹果于 2016 年收购的emotient，实时扫描消费者的面部，以评估他们对广告和产品的情绪反应。
处于初创行业前沿的是 Affectiva ，一家 2009 年从麻省理工学院媒体实验室崛起的初创公司。然而，与其他人相比，他们一直致力于解决一些与从面部信息中提取情绪状态的困难相关的问题。Affectiva 的首席执行官 Rana el Kaliouby 说,他们正试图结合“文化特定基准”来解决情境和社会因素影响情感表达普遍性的情况。
Affectiva 的做法背后的原因是情感识别技术不起作用。至少不是所有这些公司声称的那样。这项技术是基于保罗·艾克曼的基本情绪理论，用泰勒特尔福德的话说，“六种情绪——快乐、悲伤、厌恶、恐惧、愤怒和惊讶——在所有文化中都由通用的面部表情所代表。”埃克曼辩护说，我们可以从面部表情中可靠地推断出情绪状态，对每个人都一视同仁。然而，这种观念一次又一次地受到挑战，现在人们普遍认为证据是不确定的。情感识别技术建立在不可靠的科学基础上。
但让我们回过头来看看*几十年来这场争论是如何展开的，科学界的最新结论是什么，这对这个数十亿美元的行业意味着什么。
加州大学旧金山分校的心理学家保罗·艾克曼将他的情绪研究方法建立在普林斯顿心理学家西尔万·汤姆金斯的工作基础上。汤姆金斯认为，正如凯特·克劳福德所说，“情感是一套天生的进化反应。”但即使是“情感研究之父”何也认识到，情感的具体表现取决于“个人、社会和文化因素”他承认“面部语言”并不是在所有地方都以同样的方式说的。
埃克曼想要建立一个可以克服这些问题的普适理论。他认为，如果情感表达是一种进化优势，那么它应该在所有社会和文化中都是普遍的。在过去的 50 年里，借助计算能力的进步和可用人脸数据集的急剧增长，他一直在改进他的方法。在 21 世纪的第一个十年里，他的理论被广泛接受，他的影响在学者和业界都有所扩大。
然而，他的方法论在有效性问题上受到了批评。科学历史学家 Ruth Leys 认为【Ekman 的方法存在固有的缺陷，因为他使用了在受控环境中提取的数据，在这些环境中，情绪被人为地展示出来，忽略了个体和背景的差异。莱斯声称，他使用的面部图像“已经摆脱了文化的影响。”
对埃克曼工作最重要的批评来自心理学家丽莎·费尔德曼·巴雷特及其同事在 2019 年发表的一篇综述。这篇论文的主要目的是评估科学证据是否“足够强和足够清楚”来证明我们可以从面部运动推断情绪状态的想法。他们分析了有关埃克曼观点的文献——也称为普遍观点——，即情绪状态与面部运动明确相关。
他们根据三个标准评估了情绪产生(当感受到特定情绪时做出面部运动)和情绪感知(从面部运动推断出情绪)的共同观点:可靠性(例如，愤怒是否在大多数时间产生皱眉)、特异性(皱眉是否仅由愤怒产生)和概括能力(愤怒-皱眉关系是否也发生在现实世界场景中以及在非常不同的社区中)。他们考虑了广泛的人群:美国的成年人、偏远农村社区的成年人、儿童和先天失明的人。
巴雷特的总体结论是明确的:“我们不可能自信地从微笑中推断出快乐，从皱眉中推断出愤怒，或者从皱眉中推断出悲伤，而当前的许多技术试图在应用被错误地认为是科学事实的东西时做到这一点。”他们发现了有限的可靠性(情绪并不总是产生相同的面部动作)，缺乏特异性(情绪-面部动作对并不呈现唯一的映射)，以及有限的普遍性(文化和背景因素尚未得到充分的记录)。
巴雷特认为，科学家进行研究的方式“可能无意中”误导了情感研究的消费者——科技公司和其他研究人员——认为情绪和面部运动之间存在完美的映射。根据这些结论，我们可以说两件事:埃克曼的理论充其量是部分错误的，学术界和工业界可能都没有很好地意识到它的错误程度。
巴雷特的发现引发了一个新的问题:有了这个证据，数百万的情绪识别行业还会将那些并不像他们宣称的那样有效的产品商业化吗？从某种程度上来说，情感研究的最新进展已经让这个行业的主要参与者重新思考他们的情感识别方法。HireVue 在今年一月宣布他们将停止在他们的算法中使用视觉分析，并表示希望“这一决定成为行业标准。”微软 Face API web 现在显示了一个不同的描述:“需要注意的是，面部表情本身并不能代表人的内部状态。”他们已经取消了跨文化情感表达普遍性的说法。许多公司似乎已经改变了他们的道路，走上了 Affectiva 几年前就已经在铺设的道路。
然而，尽管最新的研究揭示了情绪识别技术的一些关键问题，但我们应该问自己最后一个问题:即使有一天这些技术完全没有偏见，我们是否希望政府和公司有能力随时随地了解我们内心的情绪状态？黛博拉·拉吉(Deborah Raji)是揭示亚马逊面部识别系统中性别和种族偏见的一项重要研究的合著者，说即使这项技术工作完美，它也可能“很容易被用来对社区进行武器化的骚扰。”
面部和情感识别技术中偏见的暴露让位于一场更重要的辩论。目前，科技巨头已经停止向政府出售他们的产品，但是监管还没有在美国实施。即使偏见消失了，这些系统仍然可能以我们只能想象的方式危及我们的隐私。亚历克莎·哈格蒂和亚历山德拉·艾伯特说得好:“当技术没有正常工作时，它们可能是危险的。当它们在一个不完美的世界中完美地工作时，它们也可能是危险的。”
我们必须对人工智能更加现实。
社区笔记
让我们防止过度简化、过度复杂和过度夸张。
我不能阻止自己写这篇文章，并与你分享我的观点。我在看吴恩达接受《财富》杂志采访，他在采访中强调不要相信大数据的宣传。他提到不买大数据的炒作，而他是过去几年推动大数据炒作的主要人物之一。例如，在 2017 年斯坦福商学院的一次采访中，安德鲁说“为了让人工智能有意义，公司需要给它们的算法输入大量数据，而这些数据并不总是容易获得的。”所以，有趣的是，我发现他在这件事上改变了主意。
https://fortune.com/2021/07/30/ai-adoption-big-data-andrew-ng-consumer-internet/ https://www.gsb.stanford.edu/insights/andrew-ng-why-ai-new-electricity
我认为人工智能面临两大挑战。
- 第一个挑战是当专家们在定义人工智能背后的技术时不接受*庸。有时他们将人工智能的概念简化为一系列的“如果……那么”而有时他们谈论邪恶的人工智能将控制人类。我们必须更加现实地定义人工智能及其力量背后的复杂性。
- 第二个挑战是当专家夸大人工智能产品开发中某个步骤的重要性。有时他们强调数据的数量，有时他们将数据总结成复杂的模型。简而言之，要开发一个人工智能产品，你必须采取几个步骤，并且你必须正确地执行所有这些步骤。开发高性能的 AI 产品没有捷径可走。如果你只关注数据的数量，而不关心如何评估模型，你就不会有案例。诸如此类。
下面，我描述了我应对上述两个挑战的两个经历。
—过度简化
我和安德鲁的故事可以追溯到 10 年前，当时我是 Thalmic 实验室的人工智能负责人，是 Myo 控制臂带 的发明者。那些年，他在 Coursera 上的机器学习课程火了。那门课是关于机器学习的非常棒的 101 课程。然而，它有一个让我深受打击的缺陷。
安德鲁的课程教授的概念使得任何学过这门课的人都认为自己成为了该领域的专家。那些年我面试过我们团队的许多候选人，几乎所有人都声称他们是该领域的专家，因为他们上过那门课。一切都要尽可能的简单，但不能更简单！虽然保持课程的吸引力和复杂性对 Andrew 来说是一把双刃剑，但我认为他过度简化了概念和方法。
—过度夸张
认识我的人可以作证，我总是以设定 AI 的现实预期为目标。对于大数据和深度学习的炒作，我一直持谨慎态度。例如，我知道大数据和深度学习为人工智能社区打开了大门，但从不认为它们是万能的解决方案。我很高兴安德鲁也意识到了这一点。
在 2017 年接受斯坦福商业采访时，安德鲁表示，为了让人工智能有意义，公司需要向其算法提供大量数据。例如，来自有影响力的专家的这种说法导致行业高管不合理地收集大量数据，而不注意其他细节。这就是为什么我认为人工智能专家必须更加现实。
在采访的另一部分，他提到人工智能是新的电力，因为它可以在每个行业创造价值。当像安德鲁这样的人工智能人物夸大人工智能的重要性时，方舟投资公司的首席执行官凯西·伍德声称深度学习可以创造比互联网更多的经济价值！问题是我们如何展示这些大胆的言论。依我看，像安德鲁这样有影响力的人应该对自己的言论更加谨慎。
—遗言
总之，我想强调两点。
- 首先，我们既不能过度简化也不能过度复杂 AI 概念和方法。这两种情况都有误导性。例如，过度简化可能会提高人工智能高管的期望，并为人工智能爱好者创造错觉，让他们过快地成为专家。此外，过度复杂化可能会导致我们陷入恶性循环而得不到任何结果。
- 其次，我们不要过分夸大****在 AI 发展中一步的重要性。尽管拥有大量高质量的数据、高性能的模型和自动化测试管道，但要为市场打造一款人工智能产品，仍需要关注许多细节。我相信开发人工智能解决方案的所有步骤都同样重要，给予和接受。忽视每一个都可能导致低性能的人工智能产品。
所以，我们必须对 AI 更加现实。我们必须远离过度简化、过度复杂和过度夸张。你可能同意或不同意我的观点，但这是我过去十年在这个领域工作的经验。相信我，我和任何人工智能专业人员一样，希望人工智能能够解决所有问题，但是如果我们想在这个领域前进，我们必须首先接受它的缺点！你怎么看？
感谢阅读！
如果你喜欢这个帖子，想支持我…
**https://pedram-ataee.medium.com/membership **
我们需要一个更好的人工智能定义，而且我们现在就需要
为了使这个术语在工业中有用，我们需要排除一些历史包袱。
我试图找到一个人工智能的好定义的重演。照片归功于 Snapwire 。
你最*尝试过定义人工智能吗？继续前进，找到一个共同的线索连接成千上万的营销网站，从屋顶尖叫它。我会等的。
如今人们给人工智能贴上任何东西的标签。你有搜索系统，你有流程自动化，你有垃圾邮件过滤器。如果今天发明了运动激活的超市门，我保证它们也会被打上人工智能的烙印。
学术界当然不会帮助提供一个明确的定义。人工智能包含了广泛的研究领域。它涵盖了搜索系统、计算机视觉、聊天机器人、自然语言处理、机器人和游戏。在大多数大学里，它通常是一个系或子系，就像你会发现的系统设计或信息论。你上一次听到你的经理要求应用“系统设计”来解决问题，然后他们就不管了，是什么时候？
话又说回来，学术界从来没有对领域清晰度特别感兴趣。但随着人工智能和机器学习从大学爆发出来，进入品牌战略白板，这种模糊性成为行业中的一个关键问题。这样做混淆了目标的定义，放错了利益相关者的期望，并导致对工程拥有什么和研究小组拥有什么的错误假设。
是时候给 AI 一个更清晰的定义了。
工业中的人工智能与学术界截然不同
我要告诉你一个人工智能模型是如何在工业中建立的秘密。
你可能会想象一名研究人员分析数据集，微调完美的模型，然后将其发送给客户。毕竟，这是我们在学术界或者像 Kaggle 这样的网站上通常会做的事情。这些问题有明确的范围，适合直接的机器学习。您有输入数据和预期的输出，通常是一些标签，有时是连续的值。如果你的模型在指标上做得很好，你就完成了。
真正的问题远没有这么简单。
考虑自动驾驶汽车。你可以训练一个直接从摄像机输入到转向预测的模型。有些人有。但是真正销售自动驾驶汽车的汽车制造商将这个复杂的挑战分成了几十个子任务:车道检测、障碍物检测、限速检测等。它们分别进行了基准测试和优化。控制系统在一系列规则中使用这些输入，这些规则指定汽车的物理控制应该如何响应。这是战略性的。
所有的机器学习都有失败的可能性。当生命和生计受到威胁时，您希望您的系统:
可解释:系统应该允许一些内省来揭示它失败的原因。是否存在偏见？是不是车道检测很好，限速检测很差？如果一个端到端的系统太难理解，工业界的研究人员会将问题分解成更清晰的模型定义。
确定性:给定相似的输入，系统应该以相似的方式运行。你不希望你的自动驾驶汽车在人行横道上撞到人。如果传感器检测到有人在你的视野中，你想停下来。百分之百的时间。这是常规编程的领域，给定一些明确的输入，您可以设计系统的行为并设置固定的行为。
让我们从范围明确的东西开始
ML 有明确的定义。你有一些输入，也有一些输出。内部可能很复杂，但最终它仍然只是f(x)=y。系统学习如何构建尽可能精确的函数，给定它可以访问的数据。这些是关键部分:
- 该模型接受数据以将输入与输出相关联。在监督学习中，这些数据是显式提供的。在无监督或强化学习中，数据是在系统为自己生成时隐式提供的。但仍然——它实现了相同的模型契约。
- 模型使用这些数据来构建函数。在未来，你期望提供一种新的输入，并得到一种合理的输入，就像人类处理同样的新输入一样。
ML 这个术语并没有遭受和 AI 一样的诅咒。如果一个系统满足这些条件，它就是 ML。否则就不是了。
ML 填补了确定性系统中的空白
归根结底，你希望你的产品能为你的用户解决一个问题。有了足够多的需求发现，你就会对这个解决方案有一个观点。产品领导者和工程师对如何编程实现这种观点的自动化有一种直觉。在过去的四十年里，软件一直在这样做。
缺失的拼图是当你不能编程解决方案的时候。你可以清楚地定义一个系统的输入/输出契约，但是不知道如何通过编程从 A 点到 B 点。你可以像人一样做这件事，但你不希望阐明一台机器如何做同样的事情。这才是机器学习真正闪光的地方。
在其他条件相同的情况下，编程比机器学习更好。通过编程，你可以检查代码路径。您可以找到边缘案例并对其进行测试。性能不会随着时间而改变。如果你能为一个问题编写一个确定性的解决方案，那就去做吧。不要把它留给模式识别系统。
更清晰的工业人工智能定义方案
好的，让我们考虑这两个条件。我们希望我们的系统尽可能可解释，这是编程最实用的地方。我们的系统可能有需要从数据中学习的方面，因此需要机器学习。一个将这两者结合成用户解决方案的系统——这应该是工业中使用的人工智能的工作定义。
人工智能是一个集成的系统，它将规则和 ML 结合起来，为最终用户提供价值。
这个定义适合我在工业中见过的所有真正智能的系统。这两种工具之间存在相互作用，机器学习填补了编程的弱点，反之亦然。这些系统的“秘方”通常是机器学习模型，但不要低估周围规则的重要性。
人工智能是将一切结合在一起的粘合剂。不多也不少。如果你的系统没有 ML 部分，就不要称之为 AI。
关闭
一些部署在工业领域的智能系统，以及学术界的一些研究领域，可能会被排除在人工智能的范围之外。这才是重点。为了让一个定义有用，它必须划出一条规定的界线，定义什么是“T1”，什么是“T2”，什么不是“T3”。
当实际使用这些系统时，这个定义牺牲了一些呼吸来获得大量的清晰度。当你在下一次会议上要求产品中有更多的人工智能时，解开 ML 在这个系统中的位置以及规则的意图。如果它只有 ML，那就叫它 ML 吧。如果它只有规则，那就叫编程吧。只为路口预留 AI。
记住:如果一切都是 AI，那就什么都不是。
大合成
思想和理论
我们需要一个商业和管理的研究-实践知识综合系统
背景
在我在 2017 管理学院(AOM)年会上组织的一次研讨会上，五位前 AOM 大学校长带领观众设想了一个理想的科学实践知识体系。我们共同设想了一个未来，在这个未来，管理研究人员和从业者可以在一个共享的数字*台上直接交流——双方都能及时受益于彼此独特的经验、数据和知识(见摘要)。这个知识*台将不断积累和整合零散的见解，形成集体智慧。
2017 年 AOM 知识综合研讨会，五位 AOM 总统 Drs. R. Duane Ireland、Jim Walsh、Denise Rousseau、Mike Hitt 和 Susan Jackson(图片来源:作者)。
然而，当前的知识基础设施一直在激励学者们专注于正常的科学和还原论研究。这种研究因学科界限、同行对精细专业化的压力、期刊网点的技术限制(空间、范围和频率)以及学术激励缺乏多样性(出版或消亡)而得以延续。
“正常的科学和还原论研究因学科界限、同行对精细专业化的压力、期刊网点的技术限制(空间、范围和频率)以及学术激励缺乏多样性(出版或灭亡)而得以延续。”
现有基础设施的局限性
当涉及到解决复杂的社会问题时，如多重利益相关者的价值、可持续性和社会福利，我们目前的基础设施变得不足(陈& Hitt，2021 )。文献、数据和社区越来越分散。开发连接不同知识片段的完整且可操作的框架变得极其困难，并且对这些片段的影响知之甚少。
“文献、数据和社区越来越分散。开发连接不同知识片段的完整且可操作的框架变得极其困难，而且对这些片段的影响知之甚少。”
经过 60 多年的商业管理科学研究，我们的知识量使得知识合成成为可能，而我们的知识碎片化程度使得知识合成成为必要。发明一种知识综合*台的时机已经成熟，这种*台具有能够促进知识积累的相互支持的组件。该*台应持续整合学术和专业社区中分散的知识资源，并生成及时、可行且易于访问的循证框架，用于管理与各利益相关方相关的组织。
“发明一个知识综合*台的时机已经成熟，这个*台由相互支持的组件组成，能够促进知识积累。”
要做到这一点，我们需要克服当前基础设施(如学术期刊)无法克服的三个持续障碍。
第一个障碍是零散的科学
对于一个组织来说，向各种利益相关者交付价值是一项复杂的任务，涉及跨许多级别、学科和异构效用函数的交互( Bridoux & Stoelhorst，2014 )。传统的科学方法是使用基于学科的、连贯的理论驱动的和简化的模型，以分段的方式研究这些不同的组成部分。提议的*台应该将来自不同领域的管理概念、模型、理论和发现汇集到一个统一的知识表示中。为了迎合来自不同领域的观众，它还应该阐明通常是特定领域的难以表达的假设和信念。
潜在的系统解决方案包括:
- 开发和统一业务和管理概念的本体
- 构建嵌入理论相关属性的机器可读知识图
- 建立多层次、复杂的概念框架，模拟社会生态系统的动态，以创造和分配利益相关者的价值
- 开发一个元框架，该框架可以捕捉处于不同利益相关者身份的个人的共享和异质动机
我们可以利用的一些现有成果包括:
- 关于人类行为结构和模型之间语义匹配的理论，由 NSF 资助，PI Kai Larsen 领导(科罗拉多大学，博尔德)
- 由美国国家科学基金会资助，PI Jay Pujara (南加州大学)领导的创业关系商业开放知识网络(BOKN)项目
- 商业和管理的因果知识图(CausalKG)项目，该项目发展了对组织绩效的因果关系的全面分类，由美国国家科学基金会资助，PIVictor Chen领导(北卡罗来纳大学夏洛特分校)
- 商业学术文献的机器阅读和非编码知识的视觉表示，由 PIVictor Chen领导(北卡罗来纳大学夏洛特分校)
图片来源:https://wiki.edmcouncil.org/
- 金融行业业务本体(FIBO) ，由企业数据管理(EDM)委员会私人资助，由富国银行戴维·纽曼领导
第二个障碍是分布式数据
结构化和非结构化数据(例如，自然语言处理[NLP]数据等)的数量、频率和速度都在不断增长。)关于不同利益相关者的问题。然而，许多数据保存在分散的、不协调的、通常是私人的来源中。因此，我们可以从学术文献中获得的经验证据很可能是基于世界上不完整或有偏见的部分，而不是一个连贯、紧密整合的全球样本。需要新的技术来理解支离破碎的经验证据，并及时将这些碎片合成为一组更完整、更公正的证据。
潜在的系统解决方案包括:
- 开发数据共享和查询*台，可以自动比较、合并和重用公开访问的数据，并可以一起索引和打包请求私有访问的数据。
- 重新发明元分析技术的数学，以纳入非线性，缺失的交互项，以及证据合成的隐藏调节因子
- 开发元机器学习(ML)算法来聚集来自不能完美合并的多个数据源的统计和 ML 结果
- 开发 NLP 算法，该算法可以检测和比较基于分类法/本体论的非结构化数据源，以帮助综合管理研究领域的大量文献
我们可以利用的一些现有成果包括:
- metaBUS *台管理超过 14，000 份 OBHR 和管理出版物，由 NSF 资助，PI Frank Bosco 领导(弗吉尼亚联邦大学)
- HubMeta *台允许研究人员上传正在进行的元分析工作，由 PI 领导(卡尔加里大学)
- 大机制项目，由 DARPA 资助 4500 万美元，由当时的项目官员保罗·寇恩(现在的匹兹堡大学)领导
- CausalityLink ，专注于将文本文档中的因果关系与财务指标联系起来的人工智能公司，由联合创始人兼首席执行官 Pierre Haren 领导
第三个障碍是证据和实践的脱节
关于实际问题的知识通过循证实践和实践证据之间的持续交叉验证而进步，然而这两者越来越孤立。对员工、客户、供应商和社区关系等各种利益相关者的直接观察、非结构化数据资源和背景细节通常是研究人员无法获得的( George，Haas，& Pentland，2014 )。目前还没有一个可扩展的*台，让双方的真相能够以一种及时可信的方式共享。因此，我们对世界的理解可能基于过时、不准确、不完整和间接的证据，而实践可能基于未经充分检验或不可复制的原则。
潜在的系统解决方案包括:
- 设计和实现一个图形用户界面，允许工作场所和外部研究团体之间的即时信息交换
- 设计和实施隐私保护协议，允许报告经验发现，同时保护敏感身份和信息
- 设计和实施一个激励系统，工作场所分析办公室可以从使用科学文献开发的模型和框架中受益
- 设计和实施一个*台，利益相关者可以从他们的角度直接评估组织的绩效，而无需代理人，最高领导层可以收到基于证据的干预建议，以回应利益相关者的评估
我们可以利用的一些现有成果包括:
图片来源:www。GoPeaks.org
面向企业绩效管理的可解释人工智能(XAI)项目，该项目采访了 100 家企业分析供应商、顾问和最终用户，由 NSF 资助，PIVictor Chen(北卡罗来纳大学夏洛特分校)领导
规划活动
改变需要时间，即使是在最乐观的时候。我们需要形成一个跨学科的致力于合作的社区(例如 AOM 和 INFORMS ),以支持一系列逐渐产生新的知识合成系统的活动。以下是一些提议的活动和时间表。
“改变需要时间，即使是在最乐观的时候。我们需要形成一个跨领域的、忠诚的、协作的社区。”
2021–2022:组织管理信息系统和管理层之间的联合专题和研讨会
我和几位顶尖的管理学者一起，正在探索在一个或多个管理精英评论期刊和一个或多个管理信息系统精英期刊之间联合发行特刊的可能性。社会主义国际将呼吁两个轨道的贡献。第一个轨道将呼吁管理信息系统学者审查学术界和实践中知识治理的现有工作实例，并提出商业和管理科学实践知识综合*台的设计原则。第二条路线将要求管理学者回顾组织和管理中的现有理论、模型和经验发现，并提出一个整体框架，在这个框架中，简化论者可以进行比较、综合和不断更新。
然后，编辑团队将把这两种贡献结合成一个科学实践知识综合系统的具体蓝图，首先作为一篇期刊文章发表，然后改编为多个主要资助机构(例如，国家科学基金会、国防部、斯隆基金会)的资助提案，以将设计付诸实施。
将组织几次研讨会，召集利益攸关方，宣传这项举措。精英评论期刊的编辑和有重要评论贡献的杰出学者将被邀请作为小组成员或演讲者。
2022–2023:在领先的学术协会建立新的兴趣小组
目前，主要学术协会(如 AOM 和 INFORMS)的大多数兴趣小组都是基于专业的。这种划分利益的方式本身延续了知识的碎片化。很多学者提出，知识综合本身就是一个兴趣小组。具有综合思维的学者将被邀请在 AOM 和 INFORMS 等主要协会组建新的兴趣小组。
LinkedIn Group和 Connect@AOM 社区 on 知识整合、综合和工程(KnISE) 是最*创建的，作为商业和管理领域的研究科学家和实践者之间的门户(图片来源:作者)。
在我组织的以下活动中已经建立了一些社区:
- 与《AoM 年鉴》、《AoM 文集》、《年度评论》、JOM、JIBS 和 IJMR 的编辑一起，提议在 2021 年 AOM 会议上召开关于“管理集体智慧:探索知识综合的新基础设施”的研讨会
- 在 2015 年 AOM 会议上，与亨利·明茨伯格、彼得·罗兰格、比尔·克里克和 JC·斯潘塞一起参加了“设计未来商学院”的研讨会
- 与 MISQ、AMR、JAP、JIBS 和 ASQ 的 EIC 和 AE 一起，在 2016 年 AOM 会议上举办了一个关于“创建更可靠和累积的知识生态系统的研讨会
- 五位 AOM 总统将在 2017 年 AOM 会议上召开关于“知识综合的时机已经成熟”的研讨会
- 与商业&管理(RRBM) 责任研究合作，在 2019 年 AOM 会议上举办关于“打造管理知识导航者的研讨会
2023–2024 年:向多个机构提交大额赠款提案
如前所述，新知识合成社区的领先研究人员将共同努力，向主要资助机构提交多项资助。主要的资助机构最*提出了知识分散的问题，它们试图鼓励整合目前孤立的知识进步。例如，在其卓越研究框架的 2017 年咨询中，高等教育机构最大的资助机构英国研究与创新(UK Research and Innovation)对其倾向于不利于跨学科研究的旧审查政策提出了一系列修订。在美国，美国国家科学基金会(National Science Foundation)将不断增长的融合研究(Growing Convergence Research)定义为其当前 10 大投资优先事项之一，这是一种寻求整合跨学科进展以解决复杂社会需求问题的研究。更具体地说，美国国防高级研究计划局(DARPA)在 2014 年至 2017 年期间实施了一项 4500 万美元的大机制计划，以资助将碎片化的癌症模型整合到整体因果框架中的创新(You，2015)。
与该科学-实践知识综合系统相关的一些程序包括:
- 维基媒体基金会项目和活动资助(目标:3 万美元)
- 美国陆军行为和社会科学研究所
- NSF 组织科学计划(目标:20 万美元)
- NSF 科学学计划(目标:20 万美元)
- 创新英国 STFC 创新伙伴计划(目标:36 万)
- NSF 创新伙伴计划(目标:50 万美元)
- NSF 研究协调网络计划(目标:50 万美元)
- ESRC 研究资助(目标:100 万)
- 斯隆基金会学术交流和知识普及(目标:200 万美元)
- 创新英国 Smart 赠款(目标:200 万英镑)
- NSF 增长融合研究项目(目标:360 万美元)
- 人类科技前沿项目的工作前景(目标:665 万美元)
- NSF 融合加速器计划(目标:800 万美元)
*有些资助正在进行中，但有些可能会在申请时终止或被新项目取代。
我们需要一个 Ruby on Rails 来进行机器学习
一个为用户快乐而优化的 ML 框架应该是什么样的？
图片作者。
Rails 允许任何人在 15 分钟内 搭建博客引擎；这将如何转化为机器学习开发世界？这篇文章代表了我对用于机器学习的 Ruby on Rails 应该是什么样子的看法。
在过去的几个月里，我和许多数据从业者交谈过，从 Ploomber 用户到其他数据工具的维护者。一个反复出现的话题是机器学习工具的状态；讨论经常围绕机器学习框架的适当 API。
我想知道，当 web 开发框架出现时，在互联网的早期是否也发生过同样类型的讨论。我第一次接触 web 开发是在我了解到 LAMP stack 的时候。出于好奇，我学习了 PHP、JavaScript、HTML 和 CSS 的基础知识，但我发现将它们缝合在一起构建一个网站太难了。做同一件事有太多的方法，其中大多数似乎都不正确。那时，我想:即使是建立一个简单的网站，一个人也必须学习很多东西。然后，我在参加一个关于软件工程的在线课程时学习了 web 框架:这真是一次令人愉快的经历！
该课程展示了如何使用 Ruby on Rails 开发软件应用程序。我对 web 技术了解不多，但是这个框架让我变得更容易:它减少了我必须做出的决定的数量，并提供了一个一致的途径来完成事情。我尝试了一些其他的框架，比如 Django，但是没有一个符合 Rails 的开发经验；毫不奇怪,Rails 信条的第一个支柱是为程序员的快乐而优化。
很快，我开始从事机器学习项目，感觉自己又走上了低效路线。有很多方法可以达到同样的目的，但大多数方法都不正确。
我们将 scikit-learn、PyTorch 或 Tensorflow 等项目称为机器学习框架。尽管如此，他们是机器学习培训框架，因为做机器学习不仅仅是培训一个模型；这相当于调用 ORM 框架，web 框架。
Web 框架允许个人快速开发 web 应用程序，但我们目前需要整个团队来构建和部署机器学习模型。我敢肯定，在这一点上，你已经听过 87%机器学习项目失败的统计不下十几次了。
简化机器学习模型的开发是新工具的承诺，但许多人正在走向错误的方向。例如，一些工具声称通过版本化数据、缩放实验或自动化模型部署来降低 87%的统计量。然而，根据我的经验，大多数项目失败的原因还有其他。我们投入了太多的资源来解决外围问题，而不是解决根本原因。
将业务问题放在一边(这是 ML 项目从未投入生产的首要原因)，确实有一些技术问题，在这些问题上，更好的工具可以产生巨大的差异。根据我的经验，破坏项目的是缺乏开发过程:缺乏代码组织和打包标准，未记录的依赖关系，破碎的计算环境，培训和服务数据预处理之间的不匹配，以及集成较差的管道；这些问题导致项目建立在脆弱的基础上，使得将模型原型(通常在笔记本中开发)转换成生产就绪的工件变得很困难。
下面几节描述了我认为 Ruby on Rails 对于机器学习的体验应该是怎样的。
项目脚手架
没有人会从零开始开发 web 应用程序，然而，每当我们开始一个机器学习项目时，我们通常会从几个文件(或笔记本)开始，然后从那里开始构建。此外，从零开始导致每个项目都有一个特定的布局，这很难实现，因为人们必须了解每个项目的结构。相比之下，当使用 web 框架时，如果我们过去使用过该框架，我们会立即知道在哪里可以找到东西。
像cookiecutter-data-science这样的项目是引导项目的好方法。然而，我相信如果项目布局与框架集成，它可以做得更多。例如，Rails 用户可以通过遵循关于项目结构和文件命名的某些约定来显著减少配置参数。
创建软件工件
部署工件由代码、配置和模型文件组成。图片作者。
项目布局的标准化是重要的第一步。自然的第二步是采用标准形式的项目，并轻松地将其转换为部署工件。一旦你用一个特定的框架开发了一个 web 应用程序，你就可以使用一系列的 PaaS 服务来快速部署它。相比之下，数据科学世界充斥着 Docker for Data Science 教程，不幸的是，这些教程对于展示如何打包 ML 工作以在生产中运行它是必要的。数据科学家不应该学习 Docker。相反，框架应该创建一个 Docker 映像(或 Python 包)用于部署，而数据科学家不必处理这些细节。
自动化差的另一个例子是当数据科学家为在线服务编写 Flask 应用程序时。一旦定义了服务逻辑，框架就应该生成所有的支持代码，以便将服务管道集成到一个更广泛的系统中；这可以是 REST API，但也可以采用其他形式。
部署自动化是许多新工具的目标。尽管如此，我认为它们提供了一个不完整且容易出错的工作流程。例如， Mlflow 的文档显示，要部署 scikit-learn 模型；我们必须提供以下文件:
一个模型文件(model.pkl)并不是一个完整的推理工件。在大多数情况下，服务管线涉及自定义预处理(即生成特征)。虽然 MLflow 支持任意函数作为模型，但是这种功能隐藏在一个小的部分中。因此，框架不应该将模型文件视为部署工件，而应该将项目视为一个整体:配置、模型文件和依赖项。
为了部署一个模型，我有一个小的 bash 脚本，它用所有必需的文件创建了一个.zip工件；第二个脚本使用这样的压缩文件部署模型:
然后，将我的模型导入应用程序:
在这里，我的部署工件包含设置项目所需的一切，公开的 API 抽象了所有细节(加载哪个模型、预处理数据并最终调用模型)。
结构管理
配置和代码的严格分离被认为是软件开发的最佳实践。然而，这在许多 ML 项目中不会发生，在这些项目中，云配置设置(例如，连接到 S3 桶)与数据处理代码(例如，NumPy 或 pandas 操作)交织在一起是很常见的。配置和代码分离允许我们在不同的设置下运行代码，简化了测试和执行。
例如，为了实现持续集成，我们可能希望使用原始数据的样本运行管道，并将结果存储在特定的 S3 存储桶中，以便进行测试。然而，我们希望在训练模型时使用整个数据集并将工件存储在不同的存储桶中。 Rails 默认定义了一个开发、测试、生产环境；我们可以将同样的想法应用于 ML 项目，以帮助用户根据他们的目标在不同的配置下运行他们的工作流:测试管道、训练模型或服务模型。
在本地和云中运行，无需更改代码
配置和代码之间的严格分离为另一个基本特性打开了大门:从本地环境到云的无缝过渡。虽然并非所有项目都需要，但有时我们可能希望扩大分析规模(例如，在多个进程或集群中运行)以加快计算速度。因此，框架应该允许用户在不修改代码的情况下，通过改变项目的配置，从本地环境转移到分布式环境。
状态复制
在云端运行的缺点是我们失去了交互调试错误的能力。例如，在过去调试管道的经验中，日志不能提供足够的信息，所以我必须从远程存储下载工件，在本地复制错误，并使用 Python 调试器。因此，框架必须确保依赖项安装是确定的(即，相同的版本)，提供下载远程工件的方法，并从故障点本地恢复执行。
管道组成
训练-服务偏斜是部署机器学习模型时最常见的问题之一。当在服务时间和培训时间处理原始数据不同时，问题出现了。防止它的有效方法是在培训和服务期间尽可能多地共享代码。
培训和服务管道之间的唯一区别是前者获取历史数据，对其进行处理，然后培训一个模型。相比之下，后者获得新数据，对其进行处理，并做出预测。
管道必须匹配，以防止培训服务偏差。图片作者。
如您所见，中间发生的所有事情都是(并且必须是)相同的，以防止培训服务偏差。一个用于 ML 的 Rails 应该允许用户将他们的训练管道转化为批处理或在线处理的服务管道。
更好的 SQL <> Python 互操作性
表格数据是应用机器学习最常见的用例。但是，在训练模型之前，表格数据通常需要大量的预处理。大量的预处理意味着项目的大部分代码是数据准备，然而，许多框架侧重于模型训练，但是创建训练集是在表格数据上训练模型的最具挑战性和最耗时的部分！
pandas 等库允许用户查询和转储数据仓库中的数据，但不能自动化整个工作流程，导致数据科学家编写自定义 Python 代码来管理下载数据的连接，或参数化 SQL 查询。一个简化 SQL 和 Python 之间集成的框架通过去除大多数项目都有的所有额外的(通常是低效的)代码，有助于产生更干净的管道。
依赖性管理
Ruby 有一个奇妙的工具叫做 Bundler ，它在设置环境时记录依赖版本。开发人员在一个Gemfile(类似于 pip 的requirements.txt)中列出他们的依赖项，然后运行bundle install。在 Python 中，这需要两步，首先安装依赖项pip install -r requirements.txt，然后用pip freeze > requirements.lock.txt记录已安装的版本。然而，这不是标准的实践，是一个两步的过程，并且不健壮。Bundler 提供了更强的保证来防止我们破坏我们的依赖安装，因为它存储了一个requirements.txt文件不包含的额外信息。Pipfile 项目旨在解决 Python 生态系统中的这些限制，但它还没有准备好；在康达世界，还有另一个类似的项目。依赖管理是一个适用于任何 Python 项目的更广泛的问题，所以我认为一个通用的解决方案(不依赖于任何特定的框架)是前进的最佳方式。
第二个重要的考虑是开发和生产依赖性的管理。例如，我们可以使用在服务预测时不需要的开发库(例如，实验跟踪器)。因此，ML 框架应该确保生产中最小的依赖性，以便更快地构建，并减少不可解决的环境的机会。
优化开发速度
大多数工具以可伸缩性而不是用户体验来推销自己。性能和可伸缩性是必不可少的，但是我们在这个过程中过早地抛弃了它们。大多数 ML 项目甚至没有达到可伸缩性成为问题的程度,因为它们从未投入生产。
就像Rails 主义一样，我们应该把数据科学家的幸福放在第一位。在数据世界中，这转化为一种工具，允许我们快速运行更多的实验。但是请记住，我所说的实验并不是指训练更多的模型，而是一个实验的更广泛的定义:处理更多的训练数据、改进数据清理代码、添加新功能等等。
用户快乐的另一个方面是让他们使用他们觉得最舒服的工具。他们喜欢朱庇特吗？让他们使用它，但是要解决那些阻止在笔记本上写的代码对生产友好的问题。我喜欢笔记本。其他的感觉都像是退步；强迫我在一个类中编写我的数据处理代码让我不高兴，因为我失去了取得增量进步的能力。
交互式控制台
Rails 有一个控制台，允许用户在不接触网站的情况下快速测试想法。在初始化控制台时，用户可以访问一个app对象，他们可以使用这个对象与他们的应用程序进行交互，以进行实验或调试。其他项目也有类似的控制台( Django 、 Flask )。
控制台是我为 Ploomber 开发的最省时的功能之一。管道可以表示为有向无环图，与它交互以提取信息使得开发更加透明。
几周前，我让一位同事参与我正在做的一个项目。管道有大约 50 个任务，包括数据转储、清理、特征工程和模型训练。我没有给她看源代码文件，而是开始了一个交互式会话，我们浏览了整个管道。几分钟后，她对管道有了一个高层次的想法；但更重要的是，她可以启动一个交互式控制台，探索管道以了解其结构，并在需要时深入研究源代码。
增量构建
增量构建加速开发。图片作者。
机器学习管道以微小的步伐前进。因此，对每个微小的变化重复所有的计算是浪费时间。这就是为什么有些人使用像 Make 这样的工具来跟踪源代码的变化，并跳过执行源代码没有变化的脚本。削减未变更任务的执行是快速迭代的一个基本特性，然而，大多数管道框架并没有实现它，或者只有一个基本的基于散列的实现。
自动化测试
发布突然变化的警报有助于在部署前发现错误。图片作者。
模型会随着时间的推移而退化，经常对它们进行重新训练至关重要。最*，出现了大量的 ML 模型监控工具来解决这个问题，并提醒我们重新训练一个模型。最容易被忽视的是在我们部署一个模型之前持续评估它的质量。传统的单元测试不起作用，因为即使使用相同的输入数据，训练过程也会生成具有不同学习参数的模型，从而导致对相同输入数据的预测略有不同。
另一方面，设置种子是无用的，因为一旦我们在训练过程中改变任何东西(例如，添加更多数据)，参考值就会过时。此外，我们不想测试我们的训练代码每次都生成相同的模型，而是输出高质量的模型。因此，我的方法是使用生产中的当前模型的预测作为参考值，然后测试这些预测与候选模型的不同程度。这种方法让我能够快速丢弃低质量的模型并发现错误，比如对损坏的数据进行训练；然而，这个过程仍然部分是手动的。
ML 框架可以通过与参考模型进行比较来评估模型质量，从而实现模型评估的自动化。然而，自动化测试可以超越模型评估。例如，当代码更改导致模型特征的分布发生重大变化时，向用户发出警告。自动化测试甚至可以检查内存消耗或运行时间的增加，并提醒我们任何降级。
自动化测试有很大的潜力来提高数据管道的质量，而不需要数据科学家编写测试代码。
加入运动
我们正在努力使 Ploomber 成为构建机器学习项目的愉快体验，请在 GitHub 上用星星表示您的支持。
如果你想成为旅程的一部分，请加入我们的社区或订阅我们的时事通讯。
最初发布于 ploomber.io 。
“我们需要了解我们的数据”
参考书目
《2021 骄傲》精选了一系列关于数据、偏见和 LGBTQIA+社区交集的故事
乔治·科登伯格三世在 Unsplash 上的照片
对于试图衡量或量化人们历史上与边缘化群体联系在一起的特征，人们普遍感到不安，这是可以理解的。这种不确定(甚至令人作呕)的感觉可以追溯到现代数据科学的起源，19 世纪的伪科学如颅相学和相面学试图检测和分类偏离社会规范的行为；当时，这些不仅包括犯罪行为，还包括精神疾病和非异性恋的性取向(应该注意，这三个类别在 20 世纪一直被混为一谈)。就在最*，正如米歇尔·简·塔特几年前在 TDS 的一篇文章中指出的那样，“数据收集在边缘化群体中并不真正享有盛名。”比方说，试图将人工智能转化为某种涡轮增压的 gaydar 并不能激发人们对我们集体防范入侵性数据驱动技术的信心。
然而，数据延续偏见和强化边缘化的能力也有另一面:它赋予个人和机构权力、启发和信息的潜力。在社会层面上，如果看不到它在现实世界中的具体影响，解决社会不公正和歧视几乎是不可能的；在更细的层面上——这也是我的个人经历——看到自己的生活经历在更广泛的群体中得到反映是有实际好处的；在某些方面，这是社区意识的先决条件。
为了纪念和庆祝 Pride 2021，我想分享 TDS 多年来在数据科学和 LGBTQIA+社区的交叉领域发表的一些有见地的重要作品。它们的范围从扩展的数据探索到个人反思，它们解决了关于偏见和我们带来积极变化的能力的正面问题。它们都非常值得你花时间——这个月以及以后。
走向跨包容的人工智能
使用性别作为人工智能算法的输出是不科学的，因为性别身份是在个人的权威之下。这不是看身体或外在表情就能决定的。
从那里，扎卡里列举了公司和组织目前使用人工智能的多种方式，以及这些做法如何对他们坚持稳定、容易察觉的性别二元制有害。不过，我欣赏扎卡里的帖子的地方在于，它还旨在追踪潜在解决方案的轮廓——从坚持在人工智能使用方面(特别是在公共机构的自动决策系统中)增加透明度，到在人工智能工具的设计中积极纳入跨性别知识和经验。
保持数据的包容性，同时不稀释您的结果
即使当数据科学家希望解决项目中的偏差并以公*的方式设计项目时，在保持结果具有统计意义的需要和对包容性数据集的渴望之间也经常出现矛盾。希瑟·克劳斯通过案例研究思考这个问题:一项涉及性取向的调查，但只收到来自特定子群体的少量回复。
谷歌在我之前就知道我不是二进制的
有趣的是，固有的性别歧视算法可以揭示像我这样不合群的人的真相。以及这如何成为我们解脱和自由的源泉。
Rhea mout afis对谷歌广告设置的沉思，以及他们作为一个非二进制人如何反映他们的个人旅程，融合了散文、分析和回忆录。这是一个强大的阅读，不仅推动了公开故事的界限，也推动了数据科学故事的界限。
苏格兰的数据行动主义和争取社会公正
凯文·古言博士把他的文章框定在一个非常具体的地方——从爱丁堡的一个警察审讯室开始，接着倡导苏格兰的社会公正和公*。但是他的帖子的潜在信息适用范围更广，并且是这次评选的和结束语:
为了证明一个专门与边缘化群体合作的社会或文化团体的存在，我们需要知道我们的数据。数据就是弹药。数据就是力量。
感谢您的阅读——如果您想分享您(或其他人)在数据科学、人工智能和 LGBTQIA+主题方面的工作，请在评论中留下链接。
我们使用机器学习来研究青少年心理健康的语言
变更数据
危机短信线路数据科学家使用机器学习模型，根据青少年短信用户使用的独特词汇来预测短信用户的年龄。了解我们如何在 1.18 亿条短信的数据集上使用 NLP 进行数据扩充。
内容警告//此帖子可能包含令人不安或引发精神健康问题的内容，包括焦虑和压力。
照片由普里西拉·杜·普里兹在 Unsplash 拍摄
本文作者为 蒂芙尼·梅什卡特 ，编辑为 莉莉·托罗克 ，合著者为 齐藤圭 。供稿来自 杜瓦·沙姆西香绿朱慧珊 。本研究在 危机文本行 与Hopelab和Well Being Trust合作进行。**
一眼
- 在着手了解新冠肺炎时期青少年面临的独特心理健康挑战时，危机短信热线遇到了一个障碍:在一项谈话后调查中，只有 21%的发短信者直接透露了他们的年龄。为了绕过这个障碍，我们应用机器学习来尝试准确区分青少年短信者和成人短信者，以增加我们可以分析的青少年对话的范围。
- 我们使用自然语言处理来预测发短信者的年龄，以便了解我们的年轻短信者在新冠肺炎期间面临的心理健康挑战。
- 青少年发短信的声音是独特的，与成年人明显不同。我们的机器学习模型可以根据他们在与我们交谈时使用的词汇识别出他们更年轻，准确率为 85%。
- 虽然我们的大多数青少年发短信者是白人和女性(根据调查)，但该模型在非白人、非女性发短信者中表现类似，准确率为 83%
- 青少年发短信更有可能使用缩写、表示同意的词语，他们也更有可能提及自己的年龄。
- 成年人发短信更有可能讨论经济困难、酗酒、无家可归和精神健康诊断。
由于新冠肺炎疫情，2020 年对世界各地的人们来说是极具挑战性的一年。因为填写我们对话后调查的危机短信热线短信人中有 50%是 17 岁或更小的，我们处于一个独特的位置来讨论这个时间对于年轻人的心理健康意味着什么，所以我们在 2020 年启动了一系列关于青少年绝望和韧性的研究。在我们的第一篇帖子中，我们发现 2020 年发危机短信的青少年比 2019 年处理了更多的悲伤、饮食失调、焦虑和压力。2020 年，青少年在深夜联系我们的可能性也比以前增加了 45%。(在整篇文章中，我们交替使用年轻人和青少年这两个术语来描述 17 岁或更小的短信者。)
到目前为止，我们的分析受到了限制，因为我们不得不依赖于一部分对话，在这些对话中，我们的短信发送者在可选的对话后调查中与我们分享了他们的年龄。
然而，我们的危机辅导员向我们解释说，他们通常可以分辨出他们在和青少年发短信，因为青少年发短信的方式和他们使用的语言与年长的短信者不同。
例如，下面的消息表明一个年轻人正在发短信:
“我真的很紧张，因为我不了解远程学校里发生的任何事情。我不能完成分配给我的所有工作，我的成绩在下降。无处可去，起床穿衣真的很难。我妈妈试图让我起床，但我就是不想。我等不及新冠肺炎的事情结束了”。 为了保护发件人的身份，我们转述了这句话****
危机顾问可以立刻分辨出这是一个年轻的短信者——电脑也可以，如果不那么精确的话。这提供了一个使用机器学习和数据增强来估计我们短信者年龄的绝佳机会，以便从更大的数据集——危机短信*台上的几乎所有对话，而不是其中的 21%——中了解青少年心理健康。我们认为这是我们的数据科学家面临的令人兴奋的挑战，也是了解 2020 年年轻人独特的心理健康挑战的机会。
构建模型
****第一步:我们从清理和争论我们的数据开始。
我们访问了 2018 年至 2020 年危机中发短信者的匿名化和擦洗的短信数据。我们使用术语频率-逆文档频率 (TF-IDF)将文本消息的内容转换为我们的模型可以处理的数字。我们删除了双倍空格；我们还将数字替换为单词“numeric_value ”,以搜索数字使用的大规模趋势，而不是单个数字。我们选择不删除停用词(几乎没有可解释内容的词，如“the”)，因为删除它们会降低我们模型的预测能力(有关此选择的更多详细信息，请参见最后的方法部分)。然而，我们确实选择包括标点符号，以包括青少年和成人标点符号之间的任何差异。我们预测年轻人会以不同的方式使用标点符号，我们相信这可能是青少年的一个额外的独特标识。
****第二步:我们对 2018 年和 2019 年的对话数据进行了训练，然后对 2020 年的对话进行了测试。
在 2018 年至 2020 年期间，我们的危机辅导员与 380 万处于危机中的人发短信，但大多数短信者不会分享他们的年龄和其他人口统计信息。为了训练这个模型，我们必须将我们的样本限制在通过我们的自愿谈话后调查确实有年龄可用的谈话中，前面提到的 21%的发短信者在与我们交谈后填写了该调查。这意味着我们的训练和测试数据仅限于这 21%的数据。所以，我们的样本大小看起来像这样:
- 训练集样本量:2018 年和 2019 年的 45 万次危机对话，
- 测试集样本量:2020 年的 24 万次危机对话。
拆分:从 2018 年至 2020 年的数据来看，45%的标记对话是青少年，55%是成年人。这两个阶级几乎是*衡的；有相似数量的年轻人和成年人输入到我们的模型中。
步骤 3: 我们使用了逻辑回归，因为它在具有大量特征集的文本数据上表现良好，并且易于解释。
我们使用逻辑回归模型创建了一个二元分类器，根据我们通过人口统计调查分配的标签，识别短信发送者是青少年还是成年人。我们首先用短信作为输入来测试这个模型。
然后，我们测试添加了一些其他数据输入，包括主动救援号码(呼叫紧急服务以支持短信发送者的次数)、对话次数(个人联系我们的总次数)、对话开始时间以及与青少年更相关的某些问题标签。最后，使用对话数量和主动救援数量，该模型最具预测性。
****第四步:我们评估了几个人口统计数据的表现。
****我们的模型准确率为 85%，曲线下面积(AUC)为 84%。AUC 分数是蓝色受试者操作特征(ROC)曲线下的面积，其绘制了真阳性率对假阳性率。简而言之，AUC 分数是一个很好的指标，它可以很好地预测发短信的人是青少年还是成年人。
图 1: 显示真阳性率对假阳性率的 AUC 曲线。84%的 AUC 分数表明，该模型非常善于预测发短信者是青少年还是成年人。
大多数填写了谈话后调查并列出性别的危机短信发送者是女性(约 70%)。列出比赛的短信中有 50%是白人。考虑到这一多数群体，我们还在自我认定的非女性、非白人短信发送者群体上测试了我们的模型。我们在文章底部提供了两张表格，分别列出了发短信者的性别和种族。发短信的人也可以选择写性别回复，也可以选择“不回答”。
该模型在非女性、非白人 texter 群体中表现非常好，准确率为 83%，AUC 得分为 83%。该测试表明，我们的模型对这一人群表现相当好，即使他们是我们短信的少数。在学术研究中并不总是这样，你可以在加州大学伯克利分校、T2 大学弗吉尼亚大学和 T4 乔治梅森大学的文章中读到更多关于这个问题的内容。2020 年，非女性、非白人的短信用户数量约为 19，000 人，相比之下，我们 2020 年的完整模型中的短信用户数量约为 237，000 人(包括那些认为自己是女性和白人的短信用户)。
我们还测试了我们的模型对青少年对话的预测能力，特别是那些识别为“西班牙裔、拉美裔或西班牙裔”或“黑人或非裔美国人”的短信。我们的模型对西班牙裔短信者的准确率为 84%，AUC 得分为 83%。它在黑人和非洲裔美国人短信人群中的表现也很好，准确率为 83%，AUC 得分为 83%。
根据我们的模型，青少年如何发不同的短信
我们的逻辑回归模型通过识别青少年或成人短信者的最强指标来工作。我们可以访问这些属性来深入了解这些群体之间的语言差异。下图列出了青少年和成人之间最明显的特征(1 到 3 个单词)。
青少年短信的 50 大特征
图 2 :逻辑回归模型用来在训练数据中识别青少年发短信者的主要特征。
成人短信的 50 大属性
图 3 :逻辑回归模型用来识别训练数据中的成人短信者的顶级特征。
用来确定发短信者是否是青少年的最有区别的词语包括描述与学校相关的话题、他们的年龄或他们的父母。对于成年人来说，这些词主要包括与他们的伴侣和孩子以及工作和大学有关的词。关于青少年和成年人使用的独特语言，有几件事引起了我们的注意。
青少年:
- 令人惊讶的是，青少年的一些主要特征包括表示同意的表情，如“你也是”、“好吧”和“mhm”。根据我们的临床团队，青少年比成年人更频繁地向危机辅导员求助，似乎觉得更有义务做出回应。这经常导致给危机顾问的确认信息比成人多，比如“好的”、“mhm”、“哦”等。
- ****青少年最大的特点之一就是“我只有[数值]”。这包括我们用来替换所有数字的术语“数值”。我们的临床团队把这解释为一个青少年发短信谈论他们的年龄，提到一些困难的事情。这是他们理解自己处境的一种常见方式，他们认为自己的生活不应该如此艰难，因为他们只是一个孩子。
- ****青少年比成年人使用更多的缩写、首字母和缩写词。图 4 列出了青少年最常用的缩写。
成人:
- 在与成年人相关的前 150 个特征中，我们发现与金钱相关的担忧比在青少年对话中更为突出。与金钱相关的主要特征包括“工作”、“保险”、“工作”、“负担得起”、“账单”、“财务”、“金钱”和“事业”。
- 与成年人相关的其他主要特征包括酗酒和无家可归。与酒精相关的单词没有出现在青少年的前 150 个特征中，这很有趣，因为人口水*调查表明，一些青少年确实饮酒，而且当他们饮酒时，往往会酗酒。这一发现可能表明成年人对酒精有更多的挣扎，或者将其视为一种应对机制。
- ****成年人使用较多的心理健康诊断相关词汇，如“残疾”、“疾病”、“抑郁”、“双相”。此外，成人对话使用更多的专业服务词汇，如“咨询”、“药物”、“医疗”和“心理医生”。
- ****与汽车相关的词语只出现在成人的前 150 个特征中，不在青少年列表中(即“我的车”、“汽车”、“驾驶”、“驾驶”)。
在这前 150 个特征中，我们看到青少年使用了许多成年人通常不使用的首字母缩写词、首字母缩写词和缩写词。我们注意到，使用缩写并没有贬低对话的严肃性，只是表明了青少年在发短信时选择的语言差异。这些包括在下图中:
十大 表示青少年短信的缩写
图 4: 这是一个年轻人使用的顶级缩写、首字母缩略词或首字母缩写的列表，模型将其用作区分青少年和成年人的特征。
表 4 中列出的大多数单词都是常见单词的缩写，如“Instagram”或“really”，但 CPS 是一个明显的例外，它代表儿童保护服务，是青少年短信生活中的一个潜在压力源。我们对这些信息进行了定性分析，发现关于 CPS 的对话从青少年谈论他们的父母，到青少年父母关心他们的孩子。
我们将使用这个扩大的数据集来研究 2020 年年轻短信用户的绝望和恢复能力。
这是分析 2020 年青少年心理健康系列的第二篇文章。我们的第三篇也是最后一篇文章将分析是什么让青少年发短信感觉更好。我们将使用本文中描述的机器学习模型来扩大我们可以分析的青少年对话的范围。我们将在这个大型数据集中寻找趋势，以发现青少年使用了哪些应对策略来帮助他们摆脱困境。在接下来的几周里，我们将继续在这个博客上分享我们所学到的东西。
关于数据限制的一个注记
数据从来都不是完美的；它提供了一个基于不完整信息的故事。危机文本行的数据也不例外。我们认为危机文本行为全国对话增添了一个重要的视角，但重要的是要注意，我们的数据并不代表所有美国人，也不代表所有处于危机中的人正在经历的事情。大约 95%的对话都是由志愿危机顾问根据他们对对话问题的解释来报告问题数据的。在一项网络调查中，人口统计数据是由发短信者在交谈后自我报告的。我们一直使用数据来帮助我们改善对危机中的短信发送者的服务，并定期让第三方建议和验证我们的流程是否参考了最佳实践。我们正在聘请更多的第三方来进一步审查我们的数据做法，以确保它们是适当的、隐私的、安全的和尽可能严格的。
危机短信对话中的人口统计分析:
发短信者自报性别人口
表 1: 在关于性别的谈话后调查中，发短信者最常见的回答。报告的性别比我们在这个表中列出的要多，但是我们已经剔除了至少有 0.4%的人发短信的性别。
下表列出了最常见的短信回复。和上表一样，我们只列出了最常见的比赛，其中有超过 0.4%的人发短信。
发短信者自报种族人口
表 2: 在关于种族的谈话后调查中，发短信者最常见的回答。报道的种族比我们在这个表中列出的要多，但是我们已经在至少有 0.4%的人发短信的种族群体中删除了这个表。
这些是我们在模型中使用的参数:
- 我们允许模型一次根据 1、2 或 3 个词(1-3 个词)进行分类。
- 我们将最大文档频率设置为 0.7，以便忽略出现在 70%以上文本中的单词。我们将这个参数从 0.5 增加到 0.7，因为与青少年的对话占了我们数据的*一半；在大约 50%的对话中出现的一个词，从技术上来说，可能是一个帮助识别青少年声音的词。
- 我们将最小文档频率设置为 50，忽略在少于 50 个对话中出现的单词，以便丢弃非常常见或不常见的单词。
- 我们将最大迭代次数增加到 2000 次，以便让解算器有更多的时间收敛。
****为什么我们没有删除停用词:我们选择在将消息输入模型之前不删除停用词。相反，我们为 min_df(最小文档频率)和 max_df(最大文档频率)选择特定的值，以缩减单词集并删除罕见的单词。这是继开放大学的一项研究的结果之后，该研究发现，删除预先编译的停用词表会对他们的情感分析分类器在样本 Twitter 数据上的性能产生负面影响。他们发现最好的方法是一种动态的方法来删除语料库中最不常出现的单词。
天气预报与机器学习，使用 Python
简单而强大的天气预报机器学习应用
物理学家将气候定义为一个【复杂系统】。虽然有很多关于它的解释，但在这个具体的例子中，我们可以认为【复杂】是【无法以分析的方式解决】。
这可能看起来令人沮丧，但它实际上为旨在解决气候挑战的广泛的数字算法铺*了道路。随着过去几年的计算发展，机器学习算法肯定是其中的一部分。
我想讨论的挑战是基于使用传统机器学习算法预测*均温度:自回归综合移动*均模型(ARIMA) 。
虽然这篇文章不想详细介绍理论背景，但它确实想一步一步地指导如何在 Python 中使用这些模型，并将其应用于现实世界的数据。
所以让我们从描述 Python 框架开始。
0.图书馆
用过的库都是最著名的数据分析，绘图，数学运算 (pandas，matplotlib，numpy) 。还有一些是用于高级数据可视化的(比如叶子，还有一些是用于 ARIMA 模型的特定库(比如 statsmodels )。以下是导入的代码:
1.数据集/数据集探索
数据集是开源的，可以在这里找到。
如果您想知道数据集中的城市，请使用这条熊猫线选择它们:
如果我们想在世界地图上标出这些城市，我们需要稍微改变一下纬度和经度。为了做到这一点，让我们使用这几行代码:
并显示城市:
2.预处理、高级可视化、稳定性
我选择隔离芝加哥，并将该城市的数据视为我的数据集。没有什么特别的原因要那么做…我就是喜欢芝加哥:)。当然，您可以使用自己的城市，并使用自己的数据集执行后续步骤。
目标是 AverageTemperature 列，即该特定月份的*均温度。我们有 1743 年到 2013 年的数据。
通过这条线，我们确定了 NaN 值，并用饼图显示它们:
由于它们不是数据集的一致部分，我决定用以前的值来填充缺失的值。我对*均温度的不确定性做了同样的处理。
“dt”列是标识年和月的列。对于接下来的操作，更方便的方法是将该列转换成 datetime 对象，并在两个不同的列中显式标识年份和月份。我们可以通过使用以下代码行来实现这一点:
使用该数据集，可以获得如下散点图:
但是读起来并不容易，所以我们应该做得更好。
现在让我们来描述我创建的三个超级基本函数:
- get_timeseries(start_year，end_year) 提取两年之间的数据集部分
- plot_timeseries(start_year，end_year) 以可读的方式绘制 get_timeseries 中提取的时间序列
- plot _ from _ data(data，time，display_options) 以可读的方式绘制时间(dt)的数据(AverageTemperature)。显示选项允许显示记号，改变颜色，设置标签…
完成后，我们可以画出这样的图:
当我们使用 ARIMA 模型时，我们应该考虑*稳的时间序列。为了检查我们考虑的时间序列是否是*稳的，我们可以检查相关和自相关图:
这表明时间序列不是静止的。尽管如此，如果我们对整个数据集执行 AD Fuller 测试，它会告诉我们数据集是稳定的。
但这是真的，因为我们在看整个数据集。事实上，如果我们分析一个单一的十年，很明显数据集在十年时间内绝对不是静止的。
为了考虑这种非*稳性，将在 ARIMA 模型中考虑微分项。
3.机器学习算法
让我们考虑 1992 年至 2013 年这十年，并绘制图表:
执行训练/测试分割:
绘制拆分:
机器学习算法是 ARIMA 模型。 这些都是基于采用最大似然函数的优化程序。
使用 AIC 来考虑和评估零微分 ARIMA 模型。
而一阶微分模型用这些线考虑:
使用此功能突出显示总摘要，并显示(2，1，5)模型和(2，1，6)模型是最好的模型。
可以看到的统计汇总值几乎相同
同样的事情也发生在统计图表之间:
-
模型(2，1，5)
-
模型(2，1，6)
尽管如此，最好使用低指数模型，以避免过度拟合并减少计算机的计算压力。为此，考虑了(2，1，5)模型。
4.预测
让我们绘制预测操作的结果:
现在让我们考虑具有相应不确定性(由数据集给出)和置信区间(由算法给出)的特定预测区域:
最后，让我们考虑一个可读性更强的版本的剧情:
5.结论
这些方法非常容易采用，因为它们不需要像深度学习方法(RNN，CNN……)那样的任何特定计算能力。
尽管如此，预测完全符合数据集本身设计的误差范围。考虑到我们只检查了月*均值，这一点很重要，同时考虑日值并进行日预测可能也很有趣。
如果你喜欢这篇文章，你想知道更多关于机器学习的知识，或者你只是想问我一些你可以问的问题:
A.在 Linkedin 上关注我，在那里我发布我所有的故事
B .订阅我的 简讯 。这会让你了解新的故事，并给你机会发短信给我，让我收到你所有的更正或疑问。
C .成为 推荐会员 ，这样你就不会有任何“本月最大故事数”，你可以阅读我(以及数千名其他机器学习和数据科学顶级作家)写的任何关于最新可用技术的文章。
再见。😃
用 Python 进行 Web 开发:Dash(完整教程)
用 Plotly 绘图，嵌入引导 CSS，上传和下载文件，选择后改变输入，导航条，微调器，等等…
摘要
欢迎来到这个硬核 Dash 教程，通过这篇文章，你将能够为任何类型的 web 应用程序制作和部署一个基本原型(最小可行产品)。
作者图片
在我最好的朋友的婚礼上，我试图用一个仪表板来安排座位，让他的生活更轻松。在编写代码时，我意识到这个简单的项目包含了开发一个基本但良好的原型所需的所有关键特性。所以我觉得值得分享一下。
通过本教程，我将以我的婚礼策划师应用为例(下面的链接)，来解释如何构建一个完整的 Dash web 应用，。
我将展示一些有用的 Python 代码，这些代码可以很容易地应用于其他类似的情况(只需复制、粘贴、运行)，并通过注释遍历每一行代码，以便您可以复制这个示例(下面是完整代码的链接)。
https://github.com/mdipietro09/App_Wedding
特别是，我将经历:
- 环境的设置
- 数据和模型
- 准备 dash 应用程序的基本结构(导航条、正文、布局)
- 输入(表单、滑块、手动、文件上传、事件后更改输入)
- 输出( Plotly ，文件下载，载入时微调)
- 在 Heroku 部署 app
设置
首先，我将通过终端安装以下库:
## for application
**dash**==1.20.0 **dash-bootstrap-components**==0.12.2## to produce random data
**names**==0.3.0## for data processing
**numpy**==1.19.5
**pandas**==1.1.5## for plotting
**plotly**==4.14.3## for read and write excel files
**openpyxl**==3.0.7
**xlrd**==1.2.0
为了让仪表板看起来漂亮，我们将使用 Bootstrap ，这是一个 CSS/JS 框架，包含表单、按钮、导航和其他界面组件的设计模板。软件包Dash-Bootstrap-Components可以轻松将 Bootstrap 集成到我们的 dash 应用程序中。
names包生成随机名称，我将使用它来创建随机来宾的数据集。
请注意，最新版本的xlrd(2 . 0 . 0)不接受。xlsx 文件，因此如果您想上传 Excel 文件，请使用 1.2.0 。
数据和模型
简而言之，这个想法是创建一个随机的客人名单，并运行一个优化算法来安排座位。或者，我们会给用户上传他们的 Excel 文件的可能性，算法将使用该文件而不是随机数据集。
*import **names**
import **pandas** as pd
import **numpy** as np **'''
Generate random guests list
:parameter
:param n: num - number of guests and length of dtf
:param lst_categories: list - ["family", "friends", ...]
:param n_rules: num - number of restrictions to apply (ex. if 1
then 2 guests can't be sit together)
:return
dtf with guests
'''**
def **random_data**(n=100, lst_categories=["family","friends",
"work","university","tennis"], n_rules=0):
**## basic list**
lst_dics = []
for i in range(n):
name = names.get_full_name()
category = np.random.choice(lst_categories) if
len(lst_categories) > 0 else np.nan
lst_dics.append({"id":i, "name":name, "category":category,
"avoid":np.nan})
dtf = pd.DataFrame(lst_dics) **## add rules**
if n_rules > 0:
for i in range(n_rules):
choices = dtf[dtf["avoid"].isna()]["id"]
ids = np.random.choice(choices, size=2)
dtf["avoid"].iloc[ids[0]] = int(ids[1]) if
int(ids[1]) != ids[0] else int(ids[1])+1 return dtf*
这个函数创建一个包含客人信息的表。
作者图片
我将使用“类别”列用不同的颜色显示客人:
作者图片
“避免”栏将用于确保两个互相讨厌的客人不会被安排在同一张桌子上。
作者图片
该应用程序将根据以下内容安排座位:
- 当两个属于同一类别的人坐在一起时，奖励+1
- 当两个想避开对方的人被安排在同一张桌子上时，罚分为-1。
此函数返回相同的数据帧，并为表分配一个新列:
作者图片
应用程序结构
现在我们可以从最酷的部分开始:构建应用程序。我要把它分成三个部分:导航条，正文，布局。此外，每个部分将包含 3 个部分:
- Input —应用程序的一部分，用户可以在其中插入和选择参数和数据，后端将使用这些参数和数据来返回所需的输出(Navbar 不需要输入)。
- 输出-应用程序的一部分，用户可以在其中查看结果。
- 回调 —包装一个函数的装饰器，其中需要指定输出、输入和状态；后者允许你传递额外的值而不触发回调(回调可能看起来可怕，但实际上它们是你最好的朋友)。
***# setup**
import **dash**
from dash.dependencies import Input, Output, State
import **dash_core_components** as dcc
import **dash_html_components** as html
import **dash_bootstrap_components** as dbc**# App Instance**
app = dash.Dash(name="name")
app.title = "name"**########################## Navbar ##########################**
**# Input****# Output**
navbar = dbc.Nav()**# Callbacks**
**@app.callback()**
def function():
return 0**########################## Body ##########################
# Input**
inputs = dbc.FormGroup()**# Output** body = dbc.Row([
**## input**
dbc.Col(md=3),
**## output**
dbc.Col(md=9)
])**# Callbacks**
**@app.callback**()
def function():
return 0**########################## App Layout ##########################** app.layout = dbc.Container(fluid=True, children=[
html.H1("name", id="nav-pills"),
navbar,
html.Br(),html.Br(),html.Br(),
body
])**########################## Run ##########################**
if __name__ == "__main__":
app.run_server(debug=True)*
先说风格。奇妙的Dash-Bootstrap-Components提供了大量不同的预定义样式。你可以在这里查看它们。一旦选择了一个样式表，就可以将其作为外部样式表插入到应用程序实例中。您甚至可以使用多个:
*theme = dbc.themes.LUXcss = 'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css'**# App Instance**
app = dash.Dash(name="name",
external_stylesheets=[theme, css])*
让我们继续到顶部的 导航栏 ，我将包括一个链接、一个弹出窗口和一个下拉菜单。
作者图片
正如你所看到的，导航条很酷，点击后会有弹出菜单和下拉菜单。“链接”下拉菜单很简单，因为你不需要回调来使它工作，而“关于”弹出菜单有点棘手。
导航栏包含 3 个导航项目:徽标,“关于”按钮，下拉菜单。“About”按钮包含两个元素:一个导航链接(通常用于导航一个多页应用程序，但在这里是 href="/" )和一个弹出窗口(绿色和红色标记)。这两个元素在回调中作为输出、输入和状态被调用，就像这样，如果“About”导航链接被单击，那么 popover 就变成活动的并显示出来。python 函数 about_popover() 期望 3 个参数，因为回调有一个输入和两个状态，返回 2 个变量，因为回调有两个输出。当应用程序启动，按钮没有被点击 n=0。
请注意，下拉菜单(蓝色部分)包括使用外部样式表导入的字体(即class name = " fa fa-LinkedIn ")。
我们刚刚看到的导航栏是最终布局的元素之一，连同标题和主体:
**
作者图片
现在，我们来谈谈房间里的大象…主体。它由输入(左侧)和输出(右侧)组成，它们通过回调相互作用。
作者图片
输入
正常情况下，输入被包装在一个表单组中，并在点击表单按钮时发送。滑块和手动输入是最常见的表单元素。
作者图片
这是创建普通滑块的方法:
*dcc.Slider(id="n-guests", min=10, max=100, step=1, value=50,
tooltip={'always_visible':False})*
下面是如何在滑块中只强制特定的值:
*dcc.Slider(id="n-iter", min=10, max=1000, step=None,
marks={10:"10", 100:"100", 500:"500", 1000:"1000"},
value=0),*
这是一个简单的手动输入:
*dbc.Input(id="max-capacity", placeholder="table capacity",
type="number", value="10"),*
让我们增加难度，解决“文件上传的情况。我将为用户提供上传 Excel 文件的可能性，该文件包含我们随机生成的类似数据集:
作者图片
上传文件时，我希望发生两件事:
- 显示文件名只是为了确保选择了正确的文件名并正确加载
- 隐藏前两个滑块，因为它们是用于随机模拟的，并且在上传自定义文件时变得无用
作者图片
我们如何实现这一目标？简单，用一个神奇的回调函数改变 HTML 组件的 CSS 样式:
为了使用上传的文件，我们需要解析它并将其转换为 pandas 数据帧，我们将使用以下函数:
*import pandas as pd
import base64
import io**'''
When a file is uploaded it contains "contents", "filename", "date"
:parameter
:param contents: file
:param filename: str
:return
pandas table
'''**
def **upload_file**(contents, filename):
content_type, content_string = contents.split(',')
decoded = base64.b64decode(content_string)
try:
if 'csv' in filename:
return pd.read_csv(io.StringIO(decoded.decode('utf-8')))
elif 'xls' in filename:
return pd.read_excel(io.BytesIO(decoded))
except Exception as e:
print("ERROR:", e)
return 'There was an error processing this file.'*
在继续讨论输出之前，让我们回顾一下到目前为止我们所看到的内容。下面是主体中输入的完整代码:
***########################## Body ##########################
# Input**
inputs = dbc.FormGroup([
**## hide these 2 inputs if file is uploaded**
html.Div(id='hide-seek', children=[ dbc.Label("Number of Guests", html_for="n-guests"),
dcc.Slider(id="n-guests", min=10, max=100, step=1, value=50,
tooltip={'always_visible':False}), dbc.Label("Number of Rules", html_for="n-rules"),
dcc.Slider(id="n-rules", min=0, max=10, step=1, value=3,
tooltip={'always_visible':False}) ], style={'display':'block'}), **## always visible**
dbc.Label("Number of Trials", html_for="n-iter"),
dcc.Slider(id="n-iter", min=10, max=1000, step=None,
marks={10:"10", 100:"100", 500:"500", 1000:"1000"},
value=0), html.Br(),
dbc.Label("Max Guests per Table", html_for="max-capacity"),
dbc.Input(id="max-capacity", placeholder="table capacity",
type="number", value="10"), **## upload a file**
html.Br(),
dbc.Label("Or Upload your Excel", html_for="upload-excel"),
dcc.Upload(id='upload-excel', children=html.Div([
'Drag and Drop or ', html.A('Select Files')]),
style={'width':'100%', 'height':'60px',
'lineHeight':'60px', 'borderWidth':'1px',
'borderStyle':'dashed',
'borderRadius':'5px', 'textAlign':'center',
'margin':'10px'} ),
html.Div(id='excel-name', style={"marginLeft":"20px"}), **## run button**
html.Br(),html.Br(),
dbc.Col(dbc.Button("run", id="run", color="primary"))
]) **# Callbacks**
**@app.callback(**
output=[
Output(component_id="hide-seek", component_property="style"),
Output(component_id="excel-name", component_property="children")],
inputs=[
Input(component_id="upload-excel",component_property="filename")])
def **upload_event**(filename):
div = "" if filename is None else "Use file "+filename
return {'display':'block'} if filename is None else
{'display':'none'}, div*
输出
后端将产生 3 个输出:标题，一个链接，以下载 Excel 文件的结果，显然是情节。
作者图片
先从 Plotly 制作的剧情开始吧。本质上，这个令人惊叹的图形库有两大模块: plotly express 和graph _ objects。前者是一个高级图形工具，包含可以一次创建整个图形的功能(我发现它类似于 seaborn )，而后者允许你一砖一瓦地构建一个图形(这实际上是 plotly express 在引擎盖下运行的)。
Plotly express 在您想要根据特定列的值来设计数据样式时是完美的，所以在这里我将使用它，但是如果您想要查看用 graph_objects 制作的绘图示例，请查看这篇文章。
那么…这是什么？
作者图片
它可能看起来像一幅画，但它是一个恰当的几何图形:这是一个散点图，其中的颜色基于客人所属的类别(家人、朋友……)，大小取决于客人是否想避开某人(基本上我会突出显示有问题的人)，而面组件与分配给每个客人的桌子相关联。分面图是由多个具有相同坐标轴组的子图组成的图形，其中每个子图显示数据的一个子集。
首先，我需要使用圆方程为地块添加 x 和 y 坐标: (x，y) = (rcosθ，rsinθ)* 。然后，我在“避免”列的基础上添加了“大小”列:*
*def **prepare_data**(dtf):
**## mark the rules**
dtf["avoid"] = dtf["avoid"].apply(lambda x:
dtf[dtf["id"]==x]["name"].iloc[0] if
pd.notnull(x) else "none")
dtf["size"] = dtf["avoid"].apply(lambda x: 1 if x == "none"
else 3) **## create axis**
dtf_out = pd.DataFrame()
lst_tables = []
for t in dtf["table"].unique():
dtf_t = dtf[dtf["table"]==t]
n = len(dtf_t)
theta = np.linspace(0, 2*np.pi, n)
dtf_t["x"] = 1*np.cos(theta)
dtf_t["y"] = 1*np.sin(theta)
dtf_out = dtf_out.append(dtf_t) return dtf_out.reset_index(drop=True).sort_values("table")*
作者图片
然后，我可以简单地使用 plotly 命令来生成图形，并指定当鼠标悬停在这些点上时会显示哪些信息:
*import plotly.express as pxfig = px.scatter(dtf, x=**"x"**, y=**"y"**, color=**"category"**,
hover_name=**"name"**, facet_col=**"table"**,
facet_col_wrap=3, size=**"size"**,
hover_data={"x":False, "y":False, "category":True,
"avoid":True, "size":False,
"table":False}
) fig.add_shape(type="circle", opacity=0.1, fillcolor="black",
col="all", row="all", exclude_empty_subplots=True,
x0=dtf["x"].min(), y0=dtf["y"].min(),
x1=dtf["x"].max(), y1=dtf["y"].max()
) fig.update_layout(plot_bgcolor='white',
legend={"bordercolor":"black",
"borderwidth":1,
"orientation":"h"}
)*
作者图片
plotly 的完整代码(以及标题):
现在出图了，如何把结果下载成 Excel 文件？我们只需要一个函数，将熊猫数据帧转换成一个文件，并通过链接将其下载到用户界面:
*import pandas as pd
import io
import base64**'''
Write excel
:parameter
:param dtf: pandas table
:return
link
'''**
def **download_file**(dtf):
xlsx_io = io.BytesIO()
writer = pd.ExcelWriter(xlsx_io)
dtf.to_excel(writer, index=False)
writer.save()
xlsx_io.seek(0)
media_type = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
data = base64.b64encode(xlsx_io.read()).decode("utf-8")
link = f'data:{media_type};base64,{data}'
return link*
在前端，我们必须添加用于下载的 HTML 链接，并使用回调来完成通常的操作:
正如您可能已经注意到的，输出(标题、下载、绘图)被包装在一个 微调器 中，它呈现了加载状态的良好效果，同时详细说明了输入:
作者图片
部署
最后，我们准备部署这个应用程序。以下是 dash 应用程序的完整代码(你可以在 GitHub 上查看其余部分):
个人喜欢 Heroku 用于部署原型。你需要添加一个 requirements.txt 和一个 Procfile 。如果你需要帮助，你可以在这里找到详细的教程和这里。
结论
这篇文章是一个关于如何用 Python Dash 构建一个好的 web 应用程序的(几乎)完整的教程。这个应用非常简单，因为它没有任何数据库和用户登录功能(也许是下一个教程的素材？).在这里，我只是想展示你如何轻松地将你的想法转化为原型向世界展示。现在你知道它是如何工作的，你可以开发你自己的应用程序。
我希望你喜欢它！如有问题和反馈，或者只是分享您感兴趣的项目，请随时联系我。
👉我们来连线👈
本文是用 Python 开发应用程序系列的一部分，参见:
用 Plotly 和 Flask 实现 Web 可视化。
数据可视化
当 Plotly plus Flask 更容易和更灵活时，为什么要使用 Dash
使用 Plotly 和 Flask 的多页 web 应用程序—图片由作者提供
你为什么想用 Python 写 HTML？这让我困惑。但如果你想写一个 Dash 应用程序，这就是你需要做的。
虽然我知道将所有代码放在一个文件中有一定的满足感，但在我看来，如果你对 HTML 有足够的了解，可以用另一种语言编写代码，那么你肯定也有足够的知识用 HTML 编写代码！
我很想让 Dash 成为编写 web 可视化应用程序的解决方案，但我不相信。
请考虑以下情况:
- Dash 应用程序基本上是一个 Flask 应用程序，它整合了 Plotly。
- 编写一个使用 Ploty 的实际 Flask 应用程序并不困难。
- 编写 Flask 应用程序可以让您更好地控制您所编写的内容，并且更加灵活。
因此，虽然我承认 Dash 是一个构造良好、用心良苦的工具，可以用来创建复杂而令人印象深刻的 web 应用程序，但我想提出一个我认为更简单的解决方案——至少对于简单的 web 应用程序来说是这样。
我们将看到使用 Flask 构建包含 Plotly 图表的多页面 web 应用程序是多么简单(对于 Dash 的开源版本来说，这不是一项简单的任务)。
但是首先让我们快速比较一下一个简单的 Dash 应用程序和它的 Flask 等价物。
简单的 Dash 应用程序
下面列出了 Dash 教程的一个稍微修改的版本——原来的教程是这里是，你可以从 github 下载源代码。
它有几个部分。首先，我们导入适当的库，然后在下一行，我们启动一个 Dash 应用程序。接下来，我们定义一个熊猫数据帧，然后画一个条形图，把它放入变量图。
最后一部分为应用程序创建布局。创建布局基本上就是在 Python 中将网页定义为文档对象模型。定义的页面由一个标题“Hello Dash”和一些文本“Dash:Python 的 web 应用程序框架”组成。最后是图表。
import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.express as px
import pandas as pdapp = dash.Dash(__name__)df = pd.DataFrame({
'Fruit': ['Apples', 'Oranges', 'Bananas', 'Apples', 'Oranges', 'Bananas'],
'Amount': [4, 1, 2, 2, 4, 5],
'City': ['SF', 'SF', 'SF', 'Montreal', 'Montreal', 'Montreal']
})fig = px.bar(df, x='Fruit', y='Amount', color='City',
barmode='group')app.layout = html.Div(children=[
html.H1(children='Hello Dash'),
html.Div(children='''
Dash: A web application framework for Python.
'''),
dcc.Graph(
id='example-graph',
figure=fig
)
]) if __name__ == '__main__':
app.run_server(debug=True)
代码转载由 Plotly 提供—版权所有 2019 Plotly， 麻省理工学院许可
这并不难理解，它会生成一个如下所示的网页:
使用 Dash 的单页 web 应用程序—图片由作者提供
现在让我们看看烧瓶当量。
一个简单的烧瓶+ Plotly 应用程序
一个使用 Plotly 的 Flask app 就有点不一样了。首先，有两个部分:Flask 应用程序本身和一个或多个 HTML 模板。Flask 应用程序的工作类似于 Dash 应用程序，但不构建实际的网页。网页是一个 HTML 模板，我们将 Plotly 数据从 Flask 应用程序传递给它，这样它就可以显示图表。
Flask 部分的结构与 Dash 类似:首先是(略有不同的)imports，然后是 Flask app，但现在有所不同。代码的下一部分在一个名为 notdash() 的函数定义中，它有一个 app.route 装饰器。
from flask import Flask, render_template
import pandas as pd
import json
import plotly
import plotly.express as pxapp = Flask(__name__)**@**app.route('/')
def notdash():
df = pd.DataFrame({
'Fruit': ['Apples', 'Oranges', 'Bananas', 'Apples', 'Oranges',
'Bananas'],
'Amount': [4, 1, 2, 2, 4, 5],
'City': ['SF', 'SF', 'SF', 'Montreal', 'Montreal', 'Montreal']
}) fig = px.bar(df, x='Fruit', y='Amount', color='City',
barmode='group') graphJSON = json.dumps(fig, cls=plotly.utils.PlotlyJSONEncoder) return render_template('notdash.html', graphJSON=graphJSON)
在 Flask 中，url 被映射到函数上，装饰器告诉我们哪个函数对应于一个特定的 URL，或者路由。在我们的例子中，我们有一个名为 notdash() 的函数，这个函数用于 url“/”(即网站的根 URL)。我们很快就会看到，使用 Flask，我们可以用不同的 URL 指定其他页面。
(如果您需要快速建立和运行 Flask 应用程序，请参见如何创建和运行 Flask 应用程序5 分钟简介)
在 notdash() 中，我们创建了 dataframe，并且像在以前的版本中一样，在变量 fig 中创建了一个绘图。现在我们稍微改变一下。我们的下一步是使用 json.dumps() 和 Plotly 附带的 json 编码器将 plot 转换成 JSON。这样做的原因是，网页将使用 Plotly Javascript 库来呈现绘图，这需要将 Plotly 图表编码为 JSON。
下一行代码告诉 Flask 使用一个名为notdash.html的 HTML 模板，并将 JSON 代码传递给它。
模板是将要显示的网页。它相当于 Dash 应用程序的布局，但我们在 HTML 文件中编写实际的 HTML:HTML 的主体包含一个标题(显示一条消息)和一个 < div > 元素，该元素将包含 Plotly 图表(为了让 Plotly 工作，我们需要给这个 < div > 一个 id，并将其 class 属性设置为 chart )。
文件的其余部分是几行 Javascript 样板代码，这些代码在任何 Flask/Plotly 应用程序中都很常见。首先，我们导入 Plotly Javascript 库。然后我们创建自己的脚本，为导入的 JSON 代码设置一个变量，然后从 Plotly 库中调用 plot 方法来显示图表。
注意，我们告诉 Python 将 JSON 数据放入 HTML 的方式是使用符号 {{name}} ，其中 name 是从 Python 传递给模板的参数，花括号表示它是参数的占位符。
<!doctype *html*>
<html>
<body>
<h1>Hello Plotly (but not Dash)</h1>
<div *id*='chart' *class*='chart'”></div>
</body><script *src*='https://cdn.plot.ly/plotly-latest.min.js'></script>
<script *type*='text/javascript'>
var graphs = {{graphJSON | safe}};
Plotly.plot('chart',graphs,{});
</script></html>
它看起来是这样的:
使用 Plotly 和 Flask 的单页 web 应用程序—图片由作者提供
非常类似于 Dash 版本，对吗？。
我不得不承认，我的非破折号版本稍微长一些，但从我的角度来看，将你的网页写成 HTML 文件并用 Python 编写你的 web 应用程序更符合逻辑。
更重要的是，它允许你灵活地编写多页应用程序。
多页应用程序
在本节中，我们将制作一个由三个页面组成的应用程序:两个包含不同图表的页面和一个包含其他两个页面链接的索引页面。当您有许多不同的图表或仪表板要包含在一个网站上时，这可能是您经常想要做的事情，但是当使用 Dash 时，这并不简单。
下图显示了该应用程序的三个页面。
使用 Plotly 和 Flask 的多页 web 应用程序—图片由作者提供
它比前一个稍微复杂一些，因为图表页面(notdash2.html)现在有三个参数，图表(和以前一样)加上一个标题和一个描述 HTML 代码中的占位符是 {{graphJSON}} 、 {{header}} 和 {{description}}。
Flask 代码现在有三个路径用于三个页面。第一个是 web 应用程序的根，另外两个是两个图表页面。请注意，这些图表具有相同的模板，因为它们使用相同的布局，但是不同的标题、描述和图表被传递给这些模板。
所以我认为，这并不太难，一个多页面的 web 应用程序使用 Plotly 来显示 Flask 应用程序中熊猫数据帧的图表。
复试
但是，我听说你死于羊毛短跑爱好者说，什么样的回调？回调是一种破折号机制，它允许网页更新以响应输入的变化。嗯，我们也可以用 HTML 和 Flask 来做。但不是在这里。如果有足够的兴趣，我将在这篇文章之后再写一篇关于这方面的文章。如果你想在这篇文章和其他文章发表时得到通知，请考虑订阅我的免费、不定期的时事通讯。
更新:后续文章在此: 一个带 Plotly 和 Flask 的交互式 Web 仪表盘
密码
如果您从上面的要点中复制代码，不要忘记 HTML 模板需要放在一个文件夹中， templates，或者，您可以在我的 Github 存储库中找到所有的源代码— 参见 Github 页面。
那么，Dash 还是 Flask？
我确信使用 Dash 进行 web 可视化可能有很好的理由，我并不完全反对。我在这里的目的是展示，在我看来，至少对于简单的应用程序来说，有一种替代方案至少和 Dash 一样好。希望一直有用。
一如既往，感谢阅读。如果你想知道我什么时候发表新文章，请考虑注册下面的电子邮件提醒，或者订阅我偶尔发布的简讯 Technofile 。
如果你不是一个媒体订阅者，那就注册吧，这样你就可以每月花 5 美元阅读尽可能多的文章。在这里注册，我将赚取一小笔佣金。
Webhook 和 API——你需要哪一个？
基于事件和基于请求的数据传输的快速非技术性介绍
即使你对技术完全不熟悉，你也可能每天都在使用 API。无论是从网上商店订购，确定您的火车时刻表，还是查看天气应用程序，我们都会不断地请求信息，这些信息是从我们不一定了解的系统或数据库中检索出来的。我们的信息请求和底层系统之间的层是应用编程接口或 API 。Webhooks 也许不太为人所知，但却越来越受欢迎。本文将对这两者进行简短的非技术性介绍。
什么是 API？
一个 API 是一个软件连接其他软件的接口。它以预先指定的格式接收请求，在内部处理它们，并返回所请求的信息(例如，以 JSON 或 XML 格式)。处理步骤可能是简单的数据检索，但也可能涉及更复杂的子程序。API 是请求驱动的，当进行调用时被触发。
利用 API 可以隐藏软件的内部机制，只输出相关的结果。此外，它允许不同的应用程序用一种通用语言进行通信。API 通常相当稳定；即使底层系统频繁改变，依赖软件也可能继续使用相同的 API。
最后，API 是双向的。本质上，你必须发送一个请求来接收某样东西。你也可以给系统添加一些东西。例如，如果你在社交媒体上发布了一些东西，你的帖子会通过一个 API 被路由到底层数据库。简而言之:API 可以用于发送数据和请求数据。
日常生活中使用的 API 的一些常见示例:
- 在线支付:有没有想过如何让 PayPal 的支付*乎即时？零售商的网站连接到 PayPal API。这是一个明显的例子，你不想分享完整的源代码；由于通过 API 进行通信，最终用户只有有限的权限。
- 旅游预订:每当查询booking.com或skyscanner.com时，这些*台都会向许多酒店和航空公司的 API 提出请求，以便为你找到最优惠的价格。
- 社交媒体登录:许多网站提供通过、 LinkedIn 等的登录，而不是为你访问的每个网站创建唯一的用户账户。它是如何工作的？你猜对了，登录 API。
- 天气预报:谷歌天气预报中灰色的雨云和寒冷的气温？它从weather.comAPI 提取数据。
什么是 webhook？
与 API 相反，web hook 是事件驱动的。每当系统发生变化时，webhook 就会广播新的信息。因此，它也被称为反向 API 。另一种看待它的方式是，将 API 视为拉系统，将 webhook 视为推系统。
自然地，你可能会订阅你想要得到通知的特定事件。您不必经常检查数据是否已经更新或事件是否已经发生，而只需在事件发生时得到通知。因此，webhook 比 API 更加轻量级和资源高效。但是它们的设计有点困难，因为它们必须被定制来推动特定的事件。
webhooks 的几个例子:
- 交易系统:这是一个作家都会熟悉的媒介。支付通知是网络陷阱的一个简单例子。
- Twitter 机器人: Twitter 机器人通知你，例如，被喜欢的推文或新的关注者。
- 电子邮件服务:像 MailChimp 这样的服务提供了许多网页挂钩。例如，当有人订阅你的时事通讯时，一个 webhook 可能会自动转发这个事件来更新你的 CRM 系统。
- 购物*台:类似 Shopify 的*台利用 webhooks，例如，发送订单或通知会计系统收到付款。推送的事件会自动触发动作。
哪个更好？
正如你可能猜到的，两者之间没有“更好”的。是使用 webhook 还是 API 确实取决于问题的背景。请考虑以下注意事项:
答:鞋店
假设你订购了一双鞋，急切地等待着从商店里拿起它的那一刻。你不耐烦地给商店打电话。销售人员尽职尽责地走进杂志查看——还没有。五分钟后，你再次打电话——还是没有。又过了五分钟——什么也没有。这将是一个非常无效的 API:员工总是忙于处理你烦人的请求，而你实际上只对事件感兴趣:你想知道你的鞋子什么时候在那里。在 webhook 实现中，员工只需在鞋子到达时给你打电话。
这可能意味着 webhook 比 API 更有效，这也是可能的。然而，现在考虑你每年买两双鞋；您还没有决定选择哪一对，将根据可用的选择来决定。所以，每次鞋店接到新订单或者卖出一双鞋，销售员工都会热情地给你打电话，沟通目前的库存。由于每年只有两个决策时刻，webhook 方法现在提供了过载的数据；API 在这里会更合适。
什么时候用哪个？
好吧，也许没有一个天生比另一个更好，但是对于特定的用例来说，它们肯定更好。以下指南可能有用:
API
想用 API 就用吧……
- …与底层应用程序的双向通信，例如向 API 背后的数据库发送更新。
- …只是为了了解当前或请求时的系统状态，而不是每个中间数据突变。
- …比事件提供的信息更多，无法在自定义 webhook 中捕获所有信息。
API 和 Webhook 的比较。如果您只需要调用时的系统状态(例如，做决定时)，API 通常更有用。[图片由作者提供]
Webhook
如果你愿意，可以使用 web hooks……
- …在(特定)事件发生时获得通知。
- …自定义缓存中最新的数据就绪。
- …构建自定义内容工作流。
- …与第三方系统同步数据。
API 和 Webhook 的比较。如果你想在事件发生的那一刻得到通知，Webhook 通常更合适。[图片由作者提供]
当然，单个应用程序通常同时支持 webhooks 和 API。如果两者都有有效的用例，就没有理由局限于一个。
最后的话
本文关注的是对最终用户来说相当明显的 API 和 webhooks，但这只是冰山一角。还有更多这两种情况的例子，大多数都涉及到表面下的信息交换。提醒他们促进个软件之间的联系，而不是个人之间的联系；除非你是程序员，否则你可能永远不会直接观察 API 或 webhook。
本文的底线是:批判性地评估你的用例是基于请求的还是基于事件的，并基于此使用 API 或 webhook。API 可能更广为人知，但是 webhooks 通常提供了一种轻量级的高效替代方案。
参考
*https://agilitycms.com/resources/posts/-api-vs-webhooks-what-s-the-difference https://www.mparticle.com/blog/apis-vs-webhooks https://sendgrid.com/blog/webhook-vs-api-whats-difference/ https://nordicapis.com/5-examples-of-apis-we-use-in-our-everyday-lives/ https://sendgrid.com/blog/whats-webhook/ *
在每台设备上进行统计和数据分析的网站
统计、回归、神经网络、PCA、绘图等等
我对网络浏览器中数据分析在线工具的选择。
快速链接: 在线统计 | 在线回归&拟合 | 在线 PCA|在线数学环境 | 关于客户端 web 编程
曾经想要做一个快速的统计测试，回归，主成分分析，或者一些简单的描述性统计，但是你手边只有你的智能手机？这里有一些基于网络的工具，可以在任何浏览器上运行这些分析。其中一些工具运行在客户端，这让我有机会关注客户端 web 编程的强大功能。
一个伟大的资源，免费的在线统计工具:SocialScienceStatistics.com
我不得不推荐这个网站，它提供在线工具来计算描述性统计数据，进行假设检验，计算 p 值，甚至绘制一些简单的图，包括直方图:
https://www.socscistatistics.com/
这不是我的，我没有因为推广它而获得任何收益！我只是展示它，因为它超级有用和方便。
虽然该网站宣传自己是为社会科学中从事统计工作的学生和研究人员量身定制的，但这些工具实际上足够广泛，可以应用于处理数据分析的所有学科。我的意思是，该网站没有使用任何专门针对社会科学的行话。
本网站中的所有工具都是按照易用性和清晰表达的原则设计的。在我看来，这一点很好地实现了。当然，你会发现它比任何特别的统计或数学程序更容易使用——当然是以一些限制为代价的。重要的是，本网站中工具的输出已经过审核，其准确性与常规“已建立”程序的输出一致。
SocialScienceStatistics.com 提供的工具
该网站有三个主要部分:统计计算器，主要处理假设检验； p 值计算器，允许你从 Z 、 t 、卡方和皮尔逊( r )中导出 p 值；以及描述性统计 —*均值、方差、标准差计算器，以及简易直方图和条形图制作工具。下面让我给你一些细节，并展示一些例子:
描述性统计 : 给定一个输入数据集，该模块中的工具返回简单的*均值、中位数、众数、标准差等。到四分位数范围、偏斜度和峰度计算器，以及一些快速数据绘图仪:一个快速直方图生成器，您只需输入一系列值，然后单击一下就可以获得直方图；一个快速条形图生成器，您可以输入带有相关计数的标签，甚至可以输入应用程序将自动计算频率并显示图表的源数据。
看这些例子:
为了说明一个不是简单计算*均值、中位数或众数的例子，许多描述性统计工具中的一个从一系列数字中计算变异系数。列出这个网站中的所有其他工具，你在文本框中输入数据(你可以从任何常规的电子表格程序中复制粘贴)，然后进行一些选择并点击计算。
计算动作变异系数的工具。作者 Luciano Abriata 图。
另一个可以在本网站上进行的典型分析示例是计算峰度和偏斜度的简单工具:
根据一组输入数字计算偏度和峰度的工具。作者 Luciano Abriata 图。
如果你更喜欢检查你的数据是如何分布的，最好画一个直方图。网站上的这个伟大的工具使直方图对你来说非常容易；只需输入观察值并点击生成。
SocialScienceStatistics.com 的简单直方图生成器。作者 Luciano Abriata 图。
使用另一个工具，您可以轻松制作和比较三组独立数据的直方图:
用于计算和比较最多三个数据集中的分布的工具。作者 Luciano Abriata 图。
这两个直方图工具不仅提供了图，还提供了计算的仓和频率，您可以将其复制到一个单独的程序中，根据您的喜好重新绘制图。此外，web 工具允许您微调 x 轴的范围，向数据添加标签，并在那里重新绘制图表。
统计检验 :从两个或两个以上的数据集，使用网站的各种工具，您可以计算独立或重复测量的方差分析，最多 5 个处理；还有 Fisher 检验、Mann-Whitney 检验、Wilcoxon 检验、各种 t 检验和卡方检验；线性回归和 2 输入多元线性回归；相关性检验，包括常规皮尔逊相关性和 Spearman 相关性；p 值和置信区间的计算，以及用于数据转换和变换的各种实用程序。
作为一个例子，我向你展示了一个我经常使用的工具，用来用 t 检验比较观察结果。与网站的所有其他工具一样，您输入数据(这里是两组数字)，进行一些选择(这里是截止 p 值和问题是否暗示单尾或双尾假设)，然后单击计算。你会立即得到所有中间计算的结果，以及在所选 p 下你是接受还是拒绝假设的结论。
t 检验计算器。作者 Luciano Abriata 图。
帮助您决定给定问题需要哪些统计数据的向导: 该向导指导您逐步完成问题，并根据您的答案推荐最适合您想要解决的问题的统计测试。
事实上，整个网站上的大多数工具都非常关注你输入的数据类型以及你脑子里想的问题。因此，当您正在运行的计算可能不合适时，它会在旅途中向您发出警告。
此外，该网站还包括关于统计的教程 关于通过 SPSS 软件进行统计的各种主题，包括如何报告结果。
回归和数据拟合
上述网站的不足之处在于回归。然而，有一些其他的在线工具涵盖了这一点。
第一个计算线性回归、15 阶多项式回归，以及指数、对数和幂回归。使用非常简单，它接受从常规电子表格程序复制粘贴的 x，y 表格:
第二种方法仅限于多项式回归，但我喜欢它，因为它更具交互性；特别是，您可以上下改变多项式的阶数并实时获得结果(包括图形)，因此进行探索性拟合更有用:
为了更普遍地适应，同时保持简单，我知道的最好的在线工具是这样的:
该网站提供了几个内置函数来将(x，y)数据(可以手动输入，也可以按照说明复制粘贴)拟合到常规函数中，包括线性函数、5 阶多项式以及各种 sigmoidal、指数、幂、双曲线和高斯形状。x 和 y 值可以在拟合之前进行变换，这扩展了可用的快速拟合集。但最重要的是，用户可以编辑自己的功能，这在我做的测试中似乎效果不错。此外，这个拟合网站允许根据不同的方案对 x 和 y 值进行加权。
需要 2 分钟来适应 GUI。但是它非常完整，使所有功能都可用，并显示拟合结果的实时更新(回归系数、皮尔逊相关、p 值、误差*方和等)。)以及显示输入数据(红点)和基于拟合的输入域模拟(黑线)的清晰图。例如，请参见我如何将一些(x，y)数据拟合到方程 y = acos(bx-1)+3:
mycurvefit.com 的例子。作者 Luciano Abriata 图。
主成分分析
上面的网站没有包括的，我在网上也没找到多少，是轻松探索多维数据的工具。可能经常会发生这样的情况，你手头有多维数据，光看数字很难分组，也很难在网上绘图。
我制作了这个在线工具，用户可以在他们的网络浏览器上运行主成分分析:
http://lucianoabriata.altervista.org/jsinscience/pca/pca3.html
有了它，人们可以轻松地加载一个由多个变量描述的带标签的对象表，然后点击几下就可以获得通过 PC1 和 PC2 上的投影分布对象的图，以及解释观察到的投影的负载图和特征值图。此外，该工具返回由奇异值分解过程产生的矩阵，以便用户可以重新制作他们自己的图。
这是内置的例子，你可以在http://lucianabriata . alter vista . org/jsin science/PCA/PC a3 . html试试
本文作者开发的在线 PCA web 应用程序。作者 Luciano Abriata 图。
LALOLab，网络浏览器的数学环境
您可能已经注意到，我上面的 PCA web 应用程序使用了一个名为 LALOLib 的库中的奇异值分解。这是 LALOLab 的 JavaScript 库对应物，lalo lab 是一个用于 web 浏览器中数值计算的包。LALOLab 就像一种在线 MatLab(或 Octave，或 Mathcad，或任何你喜欢的数学编程工具)，而 LALOLib 是一个库，你可以插入到你的 web 应用程序中运行复杂的计算。
LALOLab 和 LALOLib 是 MLWeb(【https://mlWeb.loria.fr/lalolab/】)的一部分，ml web 是一系列用于 web 中的数值过程和机器学习的工具，其中也包括 ML.js，这是一个专用于 web 浏览器中的机器学习的库。接下来，我简要概述了 LALOLab maths 接口和 LALOLib + ML.js 库。
数学在线界面
LALOLab 感觉完全像一个数字计算和编程环境，非常像 MatLab 和其他软件，不同之处在于它只在你的 web 浏览器中运行，甚至不将数据发送到服务器，因为它完全基于客户端 web 编程。事实上，它使用 LALOLib JavaScript 库进行数值计算——您也可以将它集成到您的 web 应用程序中，见下一节。
LALOLab 包括用于线性代数、统计、编程中的流程控制、基本图、统计、优化的函数，以及用于回归、神经网络等的各种机器学习工具。当然，它不如独立程序强大，但它确实提供了广泛的计算和数字编程环境，您可以在任何地方使用，无需安装任何软件。无论你在哪里有浏览器，无论是你的手机、*板电脑、linux 桌面还是 windows 笔记本电脑，你都会有这个工具(就像这个故事中的所有其他工具一样——网络之美！).
下面是我用 LALOLab 的截图。您可以在左下方逐个输入命令，或者在右下方编写脚本。浅蓝色的大框将处理命令并显示输出。您可以看到语法和格式与 MatLab 非常相似(但不完全相同)。
您可以在此访问 LALOLab:
在 web 应用程序中运行计算的 JavaScript 库
如果您对客户端 web 编程感兴趣，您可以在 web 应用程序的 JavaScript 代码中使用 LALOLab 的函数。您只需要用 HTML 中的这行代码加载 LALOLib 库:
<script src="http://mlweb.loria.fr/lalolib.js"></script>
LALOLib 库提供了与 LALOLab 相同的功能，但是是在 web 页面中常规 JavaScript 的上下文中。它有一个特殊的函数，可以将 JavaScript 数组转换成自己的矩阵表示。用该函数创建的矩阵继承了可以应用于矩阵的所有函数和运算。
例如，从 JavaScript 数组 P 中创建一个 LALOLib 矩阵对象，如下所示:
var pMatrix = array2mat(P);
然后，您可以对矩阵保持对象进行操作，使用如下所示的函数进行转置:
var pMatrixT = transposeMatrix(pMatrix);
…或者这个将两个矩阵相乘的例子:
var H = mul(pMatrixT, qMatrix);
…或者说运行奇异值分解:
var svdH = svd(H, “full”);
在这种情况下，svdH 包含三个矩阵。v，svdH。s 和 svdH。U
你也可以嵌套操作，比如说得到一个矩阵的乘积的行列式和另一个矩阵的转置:
var d = det(mul(pMatrix, transposeMatrix(qMatrix)));
…等等。
对客户端 web 编程的进一步评论
我不想让这篇文章过多地讨论编程，我将在一篇专门的文章中讨论编程，但是我确实想强调我写的关于客户端编程对科学的力量的两篇同行评议文章:
第一篇文章回顾了浏览器内编程的最佳工具，包括 HTML5 中使用的 JavaScript 以及相关的 web 技术。通过脚本、库、web 应用程序甚至完整 web 应用程序的具体示例，强调了这些技术在执行数值计算、文本处理和挖掘、通过查询在线数据库和 web 服务检索和分析数据、有效的数据可视化(包括 3D 可视化，甚至虚拟和增强现实)方面的潜力；所有这些都在浏览器中以相对较低的编程工作量完成，应用于化学信息学、结构生物学、生物物理学和基因组学以及其他分子科学。
https://www.mdpi.com/2227-9709/4/3/28
这篇文章讨论了客户端 web 编程在科学教育和推广中的应用:
https://pubmed.ncbi.nlm.nih.gov/29254737/
我最后评论一下这些作品的一些副产品。第一个是完全为在网络浏览器中运行而构建的生物信息学工具，很像上面介绍的 LALOLab 环境，但这里致力于探索蛋白质中氨基酸变异背后的物理化学原因:
https://pubmed.ncbi.nlm.nih.gov/27315797/
这另一个副产品是关于使用 web 编程为分子可视化和建模产生增强和虚拟现实体验:
https://peerj.com/articles/cs-260/
这项工作进一步发展成为一个完整的化学教育网站，moleculARweb:
https://pubs.acs.org/doi/10.1021/acs.jchemed.1c00179
在本文中，我将在这个*台上与其他技术一起讨论:
在这份同行评审意见中:
我是一个自然、科学、技术、编程和 DIY 爱好者。生物技术专家和化学家，在潮湿的实验室和计算机里。我写我广泛兴趣范围内的一切。查看我的 列表 了解更多故事。 成为媒介会员 访问我和其他作家的所有故事， 订阅通过邮件获取我的新故事 (*台原创附属链接)。
数据科学家和机器学习从业者每周推荐文章(1 月 11 日)
人工智能和数据科学
每周数据科学、机器学习和 AI 推荐文章
作者图片
2021 年似乎将会走上一条与备受厌恶的 2020 年相同的道路。
一些技术媒体作者已经开始从 ML 从业者的角度捕捉全球正在发生的事件。
这篇文章介绍了六篇写得很好的与时间相关的文章，不同水*的 ML 从业者都会喜欢。
以下是本周推荐文章的内容:
- 一篇涵盖人工智能方法的文章将继续支持疫情后的医疗保健行业。
- 两篇文章侧重于面部识别，一篇传达面部识别对少数群体的灌输，另一篇提出面部识别可以支持司法工作的方法。
- 一篇解释 OpenAI 最新项目 DALL-E 的短文和一篇关于过渡到机器学习相关角色的旅程的详细文章。
- 一篇介绍销售预测数据合成的文章。
快乐阅读
1.新冠肺炎之后的医疗保健中的人工智能
Raj 的文章提供了关于制药公司、政府和医疗保健机构在新冠肺炎疫情期间利用人工智能的各种方式的深刻信息。
但更重要的是，在本文的后半部分，Raj 提供了一系列方法，在新冠肺炎疫情之后，人工智能仍然在提供价值。
关键的一点是，人工智能应用作为医疗保健中的支持工具将继续存在。
2.艾被娜塔莎·玛塔用来监视和压迫中国的维吾尔穆斯林
Natasha Matta 的文章包含了利用面部识别和监控系统来压迫和歧视中国维吾尔穆斯林的信息。
这篇文章聚焦于大型科技公司参与向中国当局提供硬件、软件和工具，从而对少数民族进行不间断的监控和监视，主要是为了灌输思想。
这篇文章展示了一个人工智能被用作剥夺个人隐私和基本人权的工具的例子。
虽然我们可能没有直接参与到这个特定的场景中，但是作为 ML 从业者，我们需要考虑更大的图景，思考我们开发的工具如何被用于伤害。
https://natashamatta.medium.com/use-of-ai-to-surveil-oppress-uyghur-muslims-in-china-18fd5773972b
3.对国会大厦的袭击应该会引发一场关于面部识别的新辩论
面部识别软件的使用一直是一个有争议的话题，并引起了社会的高度关注。
但在这篇文章中，托马斯·史密斯探索了面部识别软件的应用场景，更具体地说，ClearviewAI 提供的软件可以用来追踪袭击美国国会大厦的暴徒。
https://tomsmith585.medium.com/this-is-a-rare-moment-when-we-actually-need-clearview-ai-a8e036a33442
4.基于深度学习的数据合成方法及其在金融交易中的应用张睿
在这篇文章中，张睿详细介绍了基于从历史销售数据中获得的信息创建销售预测工具的技术工作。Rui 的文章涵盖了典型数据科学项目中涉及的主要过程，如数据收集、清理、增强模型开发等。
本文的主要内容集中在通过表格变分自动编码器(TVAE)支持的数据合成来扩充最初有限的数据集的过程。
5.戴尔·E 由戴尔·马科维茨在不到 5 分钟的时间里解释
Dale 的文章对 OpenAI 的最新公开项目 DALL-E 进行了高水*的技术介绍。
Dale 提供 DALL-E 的功能，尽管图像是通过人工输入的文本提示生成的。避免过多的技术术语，Dale 友好地解释了 DALL-E 的功能、技术细节、应用和性能。
6。我是如何从一名销售工程师变成深度学习/计算机视觉研究工程师 曼普里特·辛格·米哈斯
Manpreet 与 Medium 读者分享了他从客户经理到计算机视觉工程师的详细经历。
Manpreet 的文章包含学习、求职、技能提升等外部资源的链接。除了提供的资源之外，这篇文章还有一个额外的好处，那就是提供第一人称的叙述和关于导航机器学习研究、求职和获得经验的建议。
结论
我很想知道媒体作家在接下来的几周里会报道些什么。看到 2020 年即将到来的快速发展和进步，我更加兴奋。
要联系我或找到更多类似本文的内容，请执行以下操作:
数据科学家和机器学习从业者每周推荐文章(2 月 2 日)
每周数据科学、机器学习和 AI 推荐文章
作者图片
由 罗曼·格雷特 给你的食材拍照后推荐食谱的推荐引擎
Roman Gratier 的文章指出了创建一个食物食谱生成器的技术步骤，该生成器是一个通过电报消息接口访问的迷你应用程序。
易于遵循的代码说明、直观的解释和时髦的 gif 都使这篇文章成为对开发实际应用程序感兴趣的数据科学家的必读内容。
Roman 在本文中涉及的主题是健壮的，从 NLP 到深度学习主题和技术。这是一个端到端的项目，以初学者友好的方式介绍了 NLP，深度学习和 API 的世界。
人工智能驱动的在线试衣间:时尚
人工智能技术似乎已经成熟，可以应用于时尚行业，Louis(什么是人工智能)Bouchard(T9)详细介绍了 StyleGAN 应用程序的开发，以生成虚拟服装试衣应用程序。
VOUGE 是来自谷歌、麻省理工学院和华盛顿大学的研究人员的努力成果。路易斯在他最新的解释性文章中介绍了《时尚》的基本技术细节。
这篇文章是 ML 从业者寻找关于人工智能如何颠覆时尚和服装行业的灵感的推荐读物。
艾揭露性别收入不*等 盖德本拉姆
Gad 的对话式文章揭示了一个研究团队的努力，该团队揭示了数据科学角色在薪酬考虑方面的性别不*等。
众所周知，从教育到职业生涯，科技行业都存在某种形式的性别偏见。Gad 对这篇文章的简短报道为 ds 领域内对女性的不公*待遇，尤其是在工资方面的不公*待遇增加了无可辩驳的证据。
Gad 的文章包括了最初进行的调查的可视化，并补充了背景信息和支持叙述。
https://medium.com/swlh/ai-exposes-gender-income-inequality-2d46d9c0d372
由奥利佛·西奥博尔德所著的《武士大师的 9 条永恒的数据科学规则》
机器学习从业者能从一个 17 世纪的武士大师身上学到什么？
我有点担心会陷入奥利弗的文章。尽管如此，读了几秒钟后，我确信我们作为 ML 从业者可以从其他学科，尤其是物理学科中涌现的哲学智慧中学到很多东西。
Oliver 的文章探讨了从“五环之书”一书中提取的九条指导原则，以及如何在数据科学学科中应用每条原则。
当你在机器学习领域前进时，阅读这篇文章将会提高你的技能。
人工智能将改变我们生活的 5 种方式Venkatesh chand gothia
人工智能的采用在过去十年中加快了步伐，随着势头越来越大，人工智能技术可能会在日常生活中变得司空见惯。
Venkatesh 的文章探讨了人工智能目前作为一种常规操作方法出现的五个领域。Venkatesh 在医疗保健、交通、购物等领域探索人工智能技术。每个领域都补充了这些人工智能技术在哪里以及如何融入日常生活的证据。
https://medium.com/codex/5-ways-artificial-intelligence-will-transform-our-lives-99d8c5a1a445
要联系我或找到更多类似本文的内容，请执行以下操作:
强化学习试卷#10 的每周回顾
每周一，我都会发表我研究领域的 4 篇论文。大家来讨论一下吧！
作者图片
论文 1:通用策略的分布条件强化学习
Nasiriany，s .，Pong，V. H .，Nair，a .，Khazatsky，a .，Berseth，g .，和 Levine，S. (2021 年)。 Disco rl:通用政策的分布条件强化学习。 arXiv 预印本 arXiv:2104.11707 。
以目标为条件的强化学习包括将一个目标整合到政策论证中。例如，考虑一个机器人手臂和一个放在桌子上的立方体；任务是控制机械臂将立方体移动到期望的位置。如果目标位置不变，你知道的 RL 方法可以解决这个问题。但是如果我现在想把立方体移动到一个新的位置呢？我是否必须为多维数据集的每个目标位置学习一个策略？通过使用以目标为条件的策略，可以学习任何目标位置的移动任务。该策略将州和目标州作为参数。
以目标为条件的策略可以允许一些一般化，但是不能捕获所有可能需要的任务。举个例子，同样的例子，如果你在桌子上加了一个盒子，你想让手臂把立方体移动到盒子里，完成这个任务有很多状态:立方体可以在盒子的中心，在盒子的边缘，或者其他任何地方，只要它在盒子里，任务就完成了。
在本文中，作者建议用状态分布来代替目标。首先，模型必须使用对应于成功任务的状态的例子来学习奖励分配。一旦模型能够识别对应于任务成功的状态，就可以学习策略。他们在这篇论文中提出了他们的算法，适用于对奖励分布的学习，他们称之为分布条件强化学习(DisCoRL)。
首先，一个模型被训练来推断一个目标分布，一个策略被训练来完成期望的任务。
这种方法的巨大优势在于，它将以目标为条件的 RL 方法扩展到了以前被忽略的各种各样的任务。
论文 2:拼车强化学习:综述
秦，朱海红，叶，等(2021)。拼车强化学习:综述。 arXiv 预印本 arXiv:2105.01099 。
本文是一篇关于拼车强化学习方法的文献综述。我们这里处理的是专业拼车，比如优步提供的服务。从某种意义上来说，司机提供了一次他本应该去的旅行(去度假或去工作场所)，这不是拼车。
拼车其实集合了几个话题。(1)匹配，包括根据顾客的要求和驾驶员的位置将顾客和驾驶员联系起来；(2)重新定位，包括将空闲的驾驶员(不在驾驶中)移向一个位置，使其与未来顾客的距离最大化，或使顾客的*均等待时间最小化；(3)驱动器的动态定价。
对于这些主题中的每一个，作者探索了几个作品，讨论了每个获得的假设和结果。有趣的是，所有的工作都是首先(如果不是唯一)在模拟中完成的。因此，有必要解决所使用的模拟工具的真实性问题，以及允许从模拟到真实世界的方法。
另一方面，这是他们的结论性评论，大多数作品都是最*写的。这是一个非常新的领域，还有许多方向有待探索。
论文 3:通过乐观自举和逆向归纳进行原则性探索
(2021)白超群，王，李，王，郑，韩，郝建杰，刘。乐观自举和逆向归纳的原则性探索。 arXiv 预印本 arXiv:2105.06022 。
U pper 置信界限( UCB )是一种强化学习方法，其特殊性在于为很少访问的州提供探索奖励。从另一个角度来看:一个代理人对一个它从未尝试过的行动的结果持乐观态度。
这种算法在表格情况下非常容易实现(每个状态-动作对都与一个值相关联，该值可以存储为一个表)。然而，当我们想要使用神经网络来估计该值时，该算法很难实现:不可能单独选择与状态-动作对相关联的输出。网络的输出值取决于网络的权重集，因此权重的每次更新都会对输出集产生影响。
乐观值函数是通过对估计的 Q 函数和奖金 B 求和而获得的
在本文中，作者提出了乐观自举和逆向归纳(OB2I)，一种适应 UCB 探索奖金思想的深度 RL 算法。以前的工作允许 UCB 的这种适应，但仅限于线性情况。在这个版本的算法中，状态-动作对的不确定性被估计。如果这种不确定性高，奖金就高，如果不确定性低，奖金就低。然后，这个额外奖励被添加到状态-动作的值中。因此，可以将这种方法与所有基于值的算法相结合。他们通过超越其他最先进的勘探策略来验证其方法的效率。
论文 4:具有通用策略更新的快速强化学习
Barreto，a .，Hou，s .，Borsa，d .，Silver，d .，& pre COPD，D. (2020 年)。具有通用策略更新的快速强化学习。美国国家科学院院刊， 117 (48)，30079–30087。
了解一个令人满意的政策所需的交互次数通常非常多。这是强化学习与深度学习共有的限制。本文作者采用了分而治之的方法。这到底是什么意思？
一个复杂的任务通常由几个任务的连续或并行实现组成。通过将一项任务分成更简单的子任务，可以更有效地学习。但这就引出了一个问题:如何评价一个政策必须在几个子任务上表现良好？为了理解这一点，让我们再次从策略迭代算法开始。我们从任何政策开始，然后我们评估这个政策以获得它的状态-动作值函数(政策评估)。一旦我们有了这个价值函数，我们就创建了一个新的政策，为每个州选择产生最大回报的行动(政策改进)。然后我们重新开始。
政策迭代的保证之一是，在每一步，政策必然会变得更好。在本文中，作者将策略迭代扩展到几个奖励信号必须最大化的情况。它们引入了一般政策评估(GPE)和一般政策改进(GPI)。
让我们用几句话来解释 GPI，即如何从它的价值函数出发，建立一个新的政策，比以前的政策更好。这个想法是评估几个政策。一旦我们有了每个政策的价值函数，我们就可以检查各个状态:对于每个状态，我们选择在所有政策中给出最高回报的行动。
结果是好的，从某种意义上说，该算法收敛非常快，比 Q 学习快几个数量级。当然我简化了很多。我邀请你阅读这篇文章来理解这种概括的所有微妙之处，以及结果是如何得到的。
我很高兴向你们展示我本周的阅读材料。请随时向我发送您的反馈。
强化学习试卷#11 的每周回顾
每周一，我都会发表我研究领域的 4 篇论文。大家来讨论一下吧！
作者图片
论文 1:奖励就够了
西尔弗博士、辛格博士、普雷科普博士和萨顿博士(2021 年)。奖励充足。人工智能，103535。
本文提出的假设是，在足够复杂的环境中，报酬最大化是智能出现的充分条件。他们在这篇论文中举了一只松鼠的例子，这只松鼠想要得到尽可能多的坚果。为了实现他的目标，他必须执行许多后续任务:感知他的环境，四处移动，爬树，与其他松鼠交流，理解季节的循环……在他们的假设中，所有这些后续任务都将被隐含地学习由于单个奖励的最大化，即获得坚果数量的最大化。
图片来自文章:松鼠学会了复杂的行为，这些行为是最大限度地消耗食物所必需的。这也与厨房机器人的例子相关。
他们以他们之前关于国际象棋和围棋的工作为例。代理人只受报酬最大化的训练。经纪人没有被教授年轻球员通常被教授的开局和战术。所以他创造了自己的开口和战术。他们被证明是非常创新的，有时与专家们所习惯的非常不同。阿尔法围棋著名的“37 步棋”就是一次完美的演示，彻底动摇了这一局的所有高手。
这个假设正确吗？单一价值的最大化能产生复杂的智能吗？每个人都有自己的看法。一些人认为这是对科学结果的必要简单性的新证明，而另一些人则认为他们的解释往往是同义反复。而你，你怎么看？
一切都应该尽可能简单，但不能再简单了。——爱因斯坦
论文 2:Android enforcement 学习*台
Toyama，d .，Hamel，p .，Gergely，a .，Comanici，g .，Glaese，a .，Ahmed，z .，…& pre COPD，D. (2021 年)。andro idenv:Android 的强化学习*台。 arXiv 预印本 arXiv:2105.13231 。
你知道 gridworld，你知道 Atari，你知道 Mujoco 控制环境。今天，你发现了 androidEnv，一个与 Android 环境交互的 RL 环境。该操作系统完全模拟并封装在 OpenAI gym 环境中，您可以像与该框架的所有其他环境一样与它交互。观察对应于像素矩阵，动作对应于您在触摸屏上的移动。
来自博客的动画:无名氏是我们的新联系人。
这为大量可行的任务开辟了道路。这个环境更加有趣，因为集成了两个主要元素:
(1) 实时。如你所知，一个代理可以花一些时间来选择它的行动。通常，环境被阻塞，并且正在等待代理的动作。这里的情况不是这样。环境在代理的考虑时间内继续进行。此外，Android 渲染可能需要一些时间:例如，当你滚动网页时，会有一个小的滑动效果，使其变得自然。这已经包括在内，所以代理人将不得不学习适应这种影响和自己的审议时间，使其更难学习。
(2) 原始动作。动作规范是低级的:一个位置和触/举。就是这样。因此，代理必须学习复杂的手势，比如拖放、敲击或滑动。
现在，让我们把焦点放在你从一开始就在疑惑的问题上:要完成的任务是什么？奖励函数是什么？实际上，这是由用户通过操作系统日志来指定的。让我们举一个例子:我希望我的代理将 John Doe 添加到我的联系人中。如果完成此任务，则可能会添加一个“【信息】【2021/06/07】John Doe”形式的系统日志作为新联系人。“通过检测这种日志的出现，我可以决定何时给我的代理人报酬。是的，这有点复杂，但我想这是他们找到的指定奖励的最干净的方法。
论文 3:走向更深层次的强化学习
Bjorck，j .、Gomes，C. P .和 Weinberger，K. Q .，走向更深的深度强化学习， arXiv 预印本 arXiv:2106.01151 。
正如你可能已经注意到，在深度强化学习中，最佳神经网络结构的问题很少被问到。基本上，如果观察是一个图像，我们用 CNN，如果不是，用 MLP。在 RL 中，主要致力于算法:基于值还是基于策略？探索还是剥削？正规化与否？基于模型与否？很明显，从来没有人问过神经网络的类型问题。
在这篇文章中，作者讨论了使用最新神经网络的影响，使用现代技巧，如跳过连接。目标是提高学习性能，同时保持相同的算法，这里是软演员评论家(SAC)。那么在你看来，神经网络的选择有多重要？
作者研究了增加标准化和剩余连接对 SAC 的影响。如果天真地实现，很可能造成模型的不稳定。因此，他们建议使用一种通过频谱归一化进行*滑的(图中的“*滑”)。
摘自文章中的一幅图:使用现代架构的 SAC 的学习曲线(归一化和剩余连接)，*滑和不*滑。1 水*增量= 10 万时间步长。
这种*滑允许稳定学习。在连续控制任务上获得的结果通常比在网络架构上不工作时获得的结果好得多。
结论是显而易见的:我们必须花时间研究 RL 中的网络架构。这会对学习成绩产生重要影响。这是每个人或多或少都有的直觉，感谢他们一劳永逸地证明了这一点。
论文 4:决策转换器:通过序列建模的强化学习
Chen，l .，Lu，k .，Rajeswaran，a .，Lee，k .，Grover，a .，Laskin，m .，Abbeel，p .，Srinivas，a .，Mordatch，I. (2021)。决策转换器:通过序列建模进行强化学习。 arXiv 预印本 arXiv:2106.01345 。
增强学习可以利用语言建模学习的巨大进步。特别是，它可以利用变压器的力量，这是一种最*的神经网络架构，它大大提高了学习性能，包括一种注意力机制。
作者提出了决策转换器，一种将 RL 问题表示为条件序列建模的架构。忘记你所知道的政策梯度或基于价值的学习方法。方法不同。在这里，它不再是一个最大化回报函数的问题，而是决定允许达到预期回报的行动。
来自论文的图:决策转换器架构
基本上，给定一个交互数据集，transformer agent 将学习哪个动作导致了哪个奖励。将状态和期望回报作为输入，代理将预测获得期望回报的概率最大化的行动。因此，如果我们想获得最大的奖励，我们只需要在输入中指定最大可能的奖励。
****为什么这种方法比传统的 RL 方法更有效？主要原因是 transform 能够将奖励与其产生的行为联系起来。如你所知，奖励是之前所有行为的产物。但是每个行动都或多或少地促成了这种回报。他们中的一些人甚至强烈限制了奖励。当环境具有这种特征(行为远离其结果)时，经典的 LR 方法就有麻烦了。Transformer 在这方面处理的非常好。
然而，在现阶段，有些事情我还不清楚。为什么我们会希望一个代理人能够准确地获得不是最大的回报？在一个状态下，代理人如何知道它可以要求的最大报酬？(不行，每次要求十亿的奖励是不行的。)希望能尽快发布更多解释。
谢谢你把我的文章看完。我很乐意阅读你的评论。
强化学习试卷#12 的每周回顾
我在我的研究领域发表了 4 篇论文。大家来讨论一下吧！
作者图片
论文 1:通过新颖性搜索和发射体的稀疏回报探索
Paolo，g .，Coninx，a .，Doncieux，s .，和 Laflaquière，A. (2021 年)。通过查新和发射体进行稀疏回报探索。arXiv 预印本 arXiv:2102.03140 。
强化学习的主要权衡是探索与利用的权衡。探索对于发现新的回报是必要的，开发对于利用已经吸收的知识也是必要的。有些环境，比如机器人环境，有非常稀有的奖励的特殊性(称为稀疏)。这项工作的目的是提出一种算法，允许在稀疏奖励的框架内进行有效的探索。他们称他们的方法为 SERENE(通过新奇事物和发射器进行稀疏回报探索)。这是什么？
图来自文章:宁静的建筑
这种算法的主要区别在于，它将清楚地区分探索过程和开发过程。换句话说，代理从探索过程开始，然后切换到利用过程，依此类推。代理如何决定是探索还是剥削？这是元调度器的角色，它必须为每个模式分配正确的时间。
探索阶段实际上是奖励不可知论者，并且只寻求最大化所遇到的状态的新颖性。这允许有效地发现新的领域，而仅仅通过寻找奖励是永远不会被发现的。然后在开发过程中，代理将创建算法的本地实例，他们称之为发射器。这些发射器是基于奖励的进化算法的实例。它们适合于在空间的小区域上优化奖励。
所获得的结果并不具有启发性，但是在我看来，区分探索阶段和开发阶段的想法使得算法具有更好的可读性，从而允许以更好的方式管理折衷。
论文 2:针对深度强化学习策略的实时攻击
泰克古尔，B. G .，王，s .，&阿索坎，N. (2021)。针对深度强化学习策略的实时攻击。 arXiv 预印本 arXiv:2106.08746 。
D eep 强化学习代理和我们一样，容易受到攻击。什么是攻击？想象一个交易代理，被训练买卖股票。通过训练一个攻击智能体，可以愚弄第一个智能体，并通过仔细扰乱观察使他做出错误的决定。因此，代理人可能买入大量下跌的股票，或者相反，在错误的时机卖出非常有利可图的股票。
图来自篇。
到目前为止，主要的限制是这些策略速度缓慢，无法实时部署。在这篇论文中，作者提出了一种方法，他们称之为普遍对抗性扰动(UAP)。他们在 ATARI2600 游戏中表明，通过正确训练扰动者，通过应用低振幅(0.5%)的扰动，有可能使主代理的性能灾难性地下降。此外，他们表明，与以前的方法不同，他们的算法的轻便性允许其实时使用。
这是好消息吗？不确定。
论文 3: DouZero:通过自我游戏深度强化学习掌握斗地主
查大丁，谢军，马，张，连，胡，刘军(2021)。 DouZero:用自玩深度强化学习掌握斗地主。 arXiv 预印本 arXiv:2106.06135 。
斗朱迪在中国是一种非常受欢迎的纸牌游戏。它是由三个玩家玩的。每个玩家从一手牌开始，目标是在其他玩家之前除掉他们。规则很简单，这使得它非常容易学习。然而，它有着极难掌握的特殊性。为了正确地玩游戏，你需要从数学、概率和战略的角度去思考。
照片由Ulrich&Mareli Aspeling在 Unsplash 上拍摄
你可以想象一些人想知道这个游戏是否能抵抗强化学习。这篇文章的作者介绍了 DouZero，一个通过掌握这种游戏来训练自我游戏的 DRL 特工。有趣的是实现。在这种游戏中，每一轮都可以放一张或多张牌。但是要小心，不是随便什么卡。合法的诉讼数量有限。这使得实现有点复杂。在这项工作中，作者提出了两个主要成分:动作编码和并行演员。训练有素的代理实现的性能超过了任何现有的机器人。似乎没有一款游戏能抵抗这种诱惑
论文 4:通过潜在空间配置的基于模型的强化学习
朱，c .，纳加班迪，a .，达尼利迪斯，k .，莫尔达奇，I .，，莱文，S. (2020)。基于模型的潜在空间配置强化学习。
基于视觉感知的强化学习的问题在于观察空间非常大(每个像素的所有可能值的乘积)。当然，空间中的大部分观察点是不可到达的，对于所考虑的环境，只有少数会被访问。然而，这足以使强化学习算法，尤其是那些基于规划的算法变得困难。一个非常有效的解决方案是创建一个空间的潜在表示，一个更精简的观察版本，但它在理论上包含了输入中存在的所有数据。但让我们面对现实吧，长期规划仍远未明朗。事实上，使用潜在观察空间的算法通常可以预测一些未来的观察，但仍然无法进行长期规划。
图来自论文 : LatCo 架构
他们的假设如下:与其计划一系列的行动(通常在文献中是这样做的)，不如通过计划一系列的状态来更容易地解决一个任务。这背后的直觉是，每个动作对轨迹的其余部分都有重要的影响。因此，最小的误差很快就会产生相当大的预测误差。
相反，作者使用了配置法，这种方法优化了一个状态序列，使报酬最大化。这种方法还保证了轨迹的可行性。
有趣的是，他们称之为 LatCo(潜在搭配)的这种方法，在某些环境中可以极大地改善结果，但在其他环境中却不行。这将是有趣的调查，以了解这种结果差异的原因。
谢谢你把我的文章看完。我很乐意阅读你的评论。
强化学习论文#4 的每周回顾
每周一，我都会发表我研究领域的 4 篇论文。大家来讨论一下吧！
作者图片
纪念安德烈亚斯。
论文 1:规划在基于模型的深度强化学习中的作用
汉姆里克、J. B .、弗里森、A. L .、贝巴哈尼、f .、格斯、a .、维奥拉、f .、威瑟斯彭、s .…&韦伯、T. (2020)。论规划在基于模型的深度强化学习中的作用。 arXiv 预印本 arXiv:2011.04021 。
W 规划在强化学习中的贡献是什么？这很难知道:它是许多非常强大的算法(如 MuZero)的一部分。但是这个计划阶段对好的学习结果有多大的必要呢？这是本出版物的作者试图回答的问题。为了做到这一点，他们修改了 MuZero，用不同的环境，不同的消融来面对它。
以下是他们回应的摘要。计划是有用的，但是并不总是非常有效。在某些情况下，人们会直观地定义为需要大量的推理，如推箱子，没有必要做大量的规划。在像 9x9 Go 这样的其他游戏中，学习表现受到计划深度的强烈影响。另一方面，规划对于良好的概括是不够的。这表明，识别良好的政策偏差可能比学习更好的模型来推动泛化更重要。
直觉上，预测未来的能力对于学习好的政策很重要。我发现通过测试基于基准模型的学习算法来质疑这种直觉是很有趣的。
论文 2:双足机器人鲁棒参数化运动控制的强化学习
(2021 年)李，郑，陈，彭，张宝兵，李宝兵，李宝兵，李宝兵。双足机器人鲁棒参数化运动控制的强化学习。 arXiv 预印本 arXiv:2103.14295 。
ipedal 移动是机器学习力量的一个很好的展示。大多数机器人的控制不是基于学习。我们使用几十年前就知道的线性自动方法，结果非常令人满意。但是这些方法从来没有强大到足以让双足机器人行走。正是在这个前沿领域，机器学习引起了人们极大的兴趣。
在本文中，作者提出了一个适用于双足机器人控制的强化学习框架。在这个框架中，第一个学习阶段是在模拟中完成的。然而，模拟系统地不同于真实世界。这被称为模拟真实差距。这就是他们使用域随机化的原因:模拟常数不再是常数:它们从一个模拟时期变化到下一个。这使得该策略在部署到真实机器人上时，对于它将经历的域改变更加健壮。
图来自文章:从脚滑中恢复
学习到的策略允许双足机器人执行一系列有趣的行为:例如，在图形上，它们通过使机器人滑动来破坏其稳定性。我们看到它是如何对这种扰动做出正确反应的！它还执行其他任务:快速行走，转弯，支撑额外的重量…
deep-RL 应用于机器人控制的另一个很好的演示。去看他们的视频。我发现这种认识很能说明问题，因为我们每个人都是在最初几个月学会走路的。
论文 3:使用行动者-学习者提炼的强化学习中的有效转换器
Parisotto，e .，& Salakhutdinov，R. (2021)。使用行动者-学习者提取的强化学习中的高效转换器。 arXiv 预印本 arXiv:2104.01655 。
F 或者某些应用，特别是对机器人的实时控制，需要学习的模型响应时间低。机器人必须对环境的变化做出快速反应。因此，学习模型必须足够简单，以允许推理与实时控制的约束兼容。很多时候，学习到的强化学习模型很简单。正如安德烈·卡帕西所说
“我所知道的关于 ConvNets 设计的一切(resnets，bigger=better batchnorms 等。)在 RL 是没用的。Superbasic 4 层 ConvNets 效果最佳。”[ 来源
但是，如何利用那些让监督学习如此成功的复杂模型呢？为了回答这个问题，这篇文章的作者提出了一个“行动者-学习者升华”(ALD)的过程。它允许将学习进度从在大型网络上学习的模型转移到较小的网络。这使得他们可以在非马尔可夫环境(即部分可观测环境)中使用非常高效但非常笨重的变压器架构。这个超级模型然后被提炼为一个更轻的 LSTM 模型。
图来自篇:ALD 概况。
他们在相当简单的环境(I-Maze 9x9 和 Meta-Fetch)中对其进行了测试，学习到的模型成功地将 LSTM 的轻便性和变压器的效率结合起来。它可以很好地帮助协调强化学习和监督学习，有利于强化学习！
论文 4: pH-RL:将强化学习引入健康实践的个性化架构
Hassouni，A. E .、Hoogendoorn，m .、Ciharova，m .、Kleiboer，a .、Amarti，k .、Muhonen，v .、… & Eiben，A. E. (2021)。 pH-RL:将强化学习引入健康实践的个性化架构。 arXiv 预印本 arXiv:2103.15908 。
总是同一个问题:在模拟或游戏中，强化学习已经证明了自己。但是现实世界呢？在这篇论文中，作者提出了一个健康问题的通用强化学习架构:个性化，更具体地说是移动应用的个性化。他们称之为 pH-RL(带 RL 的电子健康个性化)。这种架构允许通过学习来个性化健康应用，并且个性化的级别是可调的。
事实上，他们提出了在移动医疗应用程序中引入强化学习模型的指南。他们用 MoodBuster 应用程序(一个在线治疗心理疾病的*台)证明了他们方法的有效性。从经验上来说，他们表明，学习模型正确地选择了最大限度地每日坚持治疗模块所需的行动和信息。
我喜欢这种将医疗保健联系起来的文章。结果很有趣，但我忍不住评论道:当心技术解决主义，尤其是在医疗保健领域。
奖励论文:在世纪营 1.4 千米冰层下的沉积物中保存了数百万年的格陵兰植被和冰川历史记录
Christ，A. J .，Bierman，P. R .，Schaefer，J. M .，Dahl-Jensen，d .，Steffensen，J. P .，Corbett，L. B .，… & Southon，J. (2021)。世纪营地 1.4 千米冰层下的沉积物中保存了数百万年前的格陵兰植被和冰川历史记录。美国国家科学院院刊，第 118 期 (13)。
来自 Pexels 的 CHRISTIAN PFEIFER 的图片
多年后，一个被遗忘的样本揭示了格陵兰岛令人震惊的历史。由于冷战期间意外收集的岩石和土壤碎片，几十年来没有人注意到这些碎片，研究人员已经证明格陵兰冰盖在大约一百万年前已经完全融化。
1966 年，美国研究人员被派往格陵兰的世纪营，进行 1400 米深的钻探。客观？官方说法:这是为了刺破北极生存的秘密。非正式地说:是为了藏在冰层下苏联俄罗斯能触及的 600 核导弹。在切斯特·朗威的指导下，1.4 千米厚的冰芯和 3 米厚的冰下沉积物被提取、冷冻并转移到布法罗大学的一个仓库里。一份独一无二的档案，最终会被遗忘几十年。切斯特·朗威在 20 世纪 90 年代犹豫要不要销毁这些样本，以便在大学的冰柜里腾出空间。但是最终接受他们的是考纳格大学。
2017 年，在一次大清理期间，这些著名的样本将被分发给世界各地的几个团队，包括佛蒙特大学的一个团队。2021 年，这些来自佛蒙特大学的研究人员研究了这些样本，并发现了可追溯到一百万年前的植物化石。这意味着一百万年前，在世纪营地，可能有北方森林，而不是冰川。
然而，这个惊人的发现相当令人恐惧:一百万年前，*均气温只比今天高 2 到 3 度。具有讽刺意味的是，这正是对未来 50 年的预测。格陵兰岛的融化将导致海*面上升 6 到 7 米。那么我们还在等什么呢？我们是继续做出调整，还是真的全力以赴来防止这种情况发生？
我很高兴向你们展示我本周的阅读材料。请随时向我发送您的反馈。
强化学习论文#5 的每周回顾
每周一，我都会发表我研究领域的 4 篇论文。大家来讨论一下吧！
作者图片
论文 1:超越波束搜索的机器翻译解码
r .勒布隆，Alayrac，j .，Sifre，l .，Pislar，m .，Lespiau，j .，Antonoglou，I .，Simonyan，k .，& Vinyals，O. (2021)。机器翻译解码超越光束搜索。arXiv 预印本 arXiv:2104.05336。
L et 来说说机器翻译。BLEU(双语评估替读)是一种算法，用于评估由机器从一种语言翻译成另一种语言的文本的质量。机器翻译越接*专业的人工翻译，评价越好。使用波束搜索可以获得最佳结果。这是一种启发式搜索算法，通过只考虑每个节点的有限的子节点集来探索图形，从而减少运行图形所需的内存。但是作者对这种波束搜索并不满意，因为它没有考虑从业者感兴趣的度量。这些指标是什么？这篇文章的简短使我无法解释，所以我建议您参考这篇文章。为了取代波束搜索，他们提出使用 RL，更具体地说是基于 MCTS 的算法。
他们展示了一个令人惊讶的结果:没有最好的算法，所有的指标都考虑在内。所考虑的度量极大地决定了要使用的最佳算法。但是在某些情况下，基于 MCTS 的算法比波束搜索算法获得更好的结果。在 23 页中，作者探讨了这种新的翻译方法的优缺点。他们还提出了几个附录，可以很容易地重现他们的结果。这为机器翻译的新方法奠定了基础。
论文 2:和朋友一起学习:敌对动机的内在目标
Campero，a .，Raileanu，r .，Küttler，h .，Tenenbaum，J. B .，rocktschel，t .，& Grefenstette，E. (2020)。和朋友一起学习:敌对动机的内在目标。arXiv 预印本 arXiv:2006.12122 。
在一个回报很少的环境中学习是很复杂的。没有什么能引导代理人去高回报的领域。一个解决办法是引入所谓的内在奖励。具体来说，它是一种奖励，这种奖励不是来自环境，而是来自行为者本身。但是这个奖励的目的是什么呢？以及如何决定何时给予这种奖励？这里有一个简单的例子:当代理访问一个新的状态时，它可以给自己一个奖励。这鼓励它去好奇，去发现新的状态。但这不是这里使用的奖励类型。我简单解释一下。
作者提出了一个框架，其中代理生成一个“教师”和一个“学生”。老师学会提出越来越高的目标，学生学会实现这些目标。代理人因此可以改进、获得一般技能，甚至不需要从环境中获得奖励。事实上，就好像代理人在一个不使用奖励的世界里学习进化。
来自论文的图:AMIGO 的两个模块:产生目标的教师和以目标为条件的学生政策
退一步说，我觉得这个想法从哲学的角度来看非常有趣。我们每天都在学习新的东西，但我们生活的世界却没有目的(或者说隐藏得很好)。我们创造自己的进步目标。
获得的结果看起来非常好。训练是在一个更难的 gridworld 上进行的，在一些配置中，代理人能够获得任何最先进的算法都无法获得的奖励。太棒了。
论文 3: AMP:程式化的基于物理的角色控制的对抗性运动先验
彭新波，马，郑，阿比尔，p，莱文，s，金泽，a(2021)。 AMP:基于物理的风格化角色控制的对抗性动作优先。arXiv 预印本 arXiv:2104.02180 。
如果动画角色的动作看起来如此逼真，这主要归功于动作捕捉。你知道，那些演员穿着朴素的衣服，所有关节上都有小跟踪球。效果真的很好。但如果结果这么好，那是因为活动范围有限。对于更复杂的运动，需要复杂的机械来获得满意的结果。
你可能会说，与 Deep-RL 有什么联系。在这项工作中，作者提出了一种基于对抗性学习的方法，以免除模仿目标的设计。
对于代理来说，目标是双重的:完成一个高级任务，并采用角色的风格。对于高层次的任务，通常很容易定义一个相关的奖励函数:例如，对于一个向前的进程，奖励将值得所走的距离。关于风格的模仿，代理必须尽可能接*包含角色自然动作的数据集来呈现动作。优点是该数据集的运动序列非常相似，并且不一定对应于所讨论的任务。
得到的结果是非常现实的:字符做侧手翻，翻筋斗，踢足球，你应该检查出来！
论文 4:机器人操作中自动目标发现的不对称自我游戏
OpenAI，o .、Plappert，m .、Sampedro，r .、Xu，t .、Akkaya，I .、Kosaraju，v .…& za remba，W. (2021)。机器人操作中自动发现目标的不对称自我游戏。 arXiv 预印本 arXiv:2101.04882 。
一只虱子和鲍勃。这是竞争中的两个机器人代理的名字。爱丽丝的目标？去做鲍勃做不到的事情。鲍勃的目标？去实现爱丽丝的成就。学习过程是这样的:
(1)爱丽丝开始与环境互动。她可以移动物体，推动它们…几步之后，我们将场景定格。这是“目标”状态
(2) Bob 开始于和 Alice 相同的初始状态。通过与环境的互动，Bob 必须找到一种方法来重现目标状态。
来自文章的图:初始状态从预定义的分布中取样，Alice 生成目标状态，Bob 试图达到目标状态
一旦鲍勃成功再现了爱丽丝提出的场景，爱丽丝就会提出更复杂的状态来再现。我们将简单地让爱丽丝与环境互动更长的时间。她互动的时间越长，就越会修改场景，Bob 就越难重现。
这个想法非常聪明，因为我们确保每次都有可能达到目标状态(Alice 已经达到了，所以我们至少有一个解决方案)。另一方面，Bob 被训练来再现目标状态。如果学习成功， Bob 不是被训练去做单一任务(就像我们在机器人学里经常看到的那样)，而是可以做任何任务。我邀请您参加查看受过培训的代理能够执行的任务的复杂性和多样性，这里有一个小的概述。
来自文章的图:Bob 成功到达的最终状态。
我和你打赌，这篇论文将成为机器人学习的里程碑。
奖励论文:利用深度学习的潜力改进蛋白质结构预测
Senior，A. W .、Evans，r .、Jumper，j .、Kirkpatrick，j .、Sifre，l .、Green，t .、……和 Hassabis，D. (2020)。利用深度学习的潜力改进蛋白质结构预测。性质， 577 (7792)，706–710。
本周的一个收获，与这篇奖金文章的强化学习无关。我们会谈到 AlphaFold。这是你去年肯定看过的一条新闻:DeepMind 科学家解决了蛋白质折叠问题。但是它到底是什么意思呢？
蛋白质是生命中生物化学的基础。理解它们是如何工作的将会使对生命机制的理解有巨大的进步。这个想法很简单:蛋白质是由一系列氨基酸组成的。氨基酸在某种程度上是蛋白质的组成部分。大约有 20 个这样的基本构件。通过以特定的顺序组装这些氨基酸，我们得到了一种蛋白质。但是蛋白质并不是无定形的链。它会折叠并形成最终形状。正是这种形式是其化学性质的来源。因此问题来了:蛋白质是如何折叠的？
我们知道对于一个氨基酸序列，有一种独特的折叠方式。因此，我们面临的挑战是根据氨基酸序列预测蛋白质的形状。这个问题研究了 50 年，每年都会组织一次比赛，确定最佳折叠预测算法。以下是上一期的结果:
casp 14 中参与者的排名，根据他们预测的 Z 分数总和。图来自官方 CASP14 网页 。
最左边的条形比第二个大得多，是 AlphaFold，DeepMind 提出的模型。(纵坐标，简称 z 分数:其值越高，预测越好。)他们是怎么取得这么好的成绩的？简单来说，他们用的是深度学习。训练网络来预测残基对之间的距离。从这些数据中，他们可以准确地预测蛋白质的形状。
这份出版物很好地展示了人工智能对人类的积极应用。恭喜你。
我很高兴向你们展示我本周的阅读材料。请随时向我发送您的反馈。
强化学习论文#6 的每周回顾
每周一，我都会发表我研究领域的 4 篇论文。大家来讨论一下吧！
作者图片
论文 1: MT-Opt:大规模连续多任务机器人强化学习
卡拉什尼科夫，d .、瓦利，j .、切博塔尔，y .、斯旺森，b .、琼施科夫斯基，r .、芬恩，c .、… &豪斯曼，K. (2021)。 MT-Opt:大规模连续多任务机器人强化学习。 arXiv 预印本 arXiv:2104.08212 。
智能机器人:科幻小说取之不尽的灵感源泉，强化学习的丰富研究领域。要真正“智能”，机器人必须掌握大量技能(我们称之为多面手机器人)。有许多机器人使用强化学习成功地学习了一项任务。然而，这些机器人有一个共同的问题:学习需要大量的训练。因此，通用机器人仍然是科幻小说。
在这篇文章中，作者提出了一些接*这种多面手机器人的基础。例如，他们认为学习的某些方面是可以共享的:探索、经验和任务间的表现。在这个框架中，学习是连续的，新的任务可以在飞行中学习，通过重用过去的经验，收集用于学习其他任务。这种方法称为 MT-Opt。作者展示了一些用这种方法学习的任务的例子，(排列，重排，…)。
哦对了，还有一点:学习也可以分布在几个代理(这里是几个机器人)之间。由于这种学习合作，MT-Opt 通过在 7 个机器人上的分布式学习，在现实生活中学习了 12 项任务。
论文 2:发现不同的运动跳跃策略
图片比文字更有说服力:
杨，杨，范德*，尹，。(2021).发现多样的竞技跳跃策略。美国计算机学会信号图 2021。
本文的作者提出了一个运动技能的学习框架，特别是跳高。
一点历史题外话:今天所有运动员使用的跳跃被称为背越式跳高(背对障碍物)。它在 1968 年奥运会的决赛中首次被执行。之前，运动员面对障碍物跳跃，效率低很多。在迪克·福斯贝里之前，没有人想到这种跳跃。他将加冕奥运冠军，但不会提高世界纪录。
基于一个模拟的角色模型，他们应用强化学习来学习跳高。(注意跳跃前的跑步阶段不一定要学)。没有使用演示，代理必须发现跳过栏的最佳策略。为了让代理学习人类可行的策略，动作被限制在自然姿态。通过鼓励新政策，可以出现各种重要的战略。其中:背越式跳高在模拟中达到 2.00 米仍是最佳策略。我觉得这个主意非常有趣。
论文 3:通过多任务学习的免重置强化学习:在没有人工干预的情况下学习灵巧的操作行为
Gupta A .、Yu J. Zhao T.Z .、Kumar V .、Rovinsky A .、Xu K .、Devlin T .和 Levine S. (2021)。通过多任务学习的免重置强化学习:在没有人工干预的情况下学习灵巧的操作行为。 arXiv 预印本 arXiv:2104.11203。
R 应用于机器人的强化学习有一个特点。它将被部署在一个真实的机器人上。有两种方法。要么(1)在模拟机器人上进行学习，并将学习到的策略部署在真实机器人上，要么(2)直接在真实生活中进行学习。每种方法都有其优点和缺陷。如果在模拟中学习，一个人可以自由地同时模拟数百个机器人，这可以比在现实生活中模拟得更快。然而，由于模拟被系统地非常简化，所以在模拟中学习的策略很难部署在真实的机器人上。第二种选择是直接在真实的机器人上学习。模拟和现实差距的问题已经不存在了。但与环境互动的成本要高得多:时间无法加速，可用的机器人往往只有一个。现实世界的学习还有最后一个限制，这也是本文的主题。环境需要人工干预或复杂的工程来重置(例如，如果任务是打开抽屉，则关闭抽屉)。
在本文中，作者通过提出一种方法来解决这种限制，该方法利用了这样一个事实，即一些任务本质上是另一个任务的重置。例如(这不是在论文中所做的，但是这个例子很好地说明了原理)，打开抽屉是在于关闭抽屉的任务的复位。相反地，关闭抽屉是在于打开抽屉的任务的复位。这个想法是同时学习这些任务。机器人将首先学习关闭抽屉的模式，并且一旦抽屉被关闭，新的学习情节开始学习如何打开抽屉，等等。
来自文章的图:模拟中灯泡插入的任务和转换。目标是将灯泡重新放在中心，提起它，翻转它，然后将其插入灯中
这种方法在一个真实的机器人上进行了测试，机器人能够在短短 2 天多的时间内学习几项任务，无需任何人工干预。也不需要任何复杂的修补来重置环境。这种学习技巧将可能成为在真实机器人上学习复杂行为的标准。
论文 4:通过学习模型进行规划的在线和离线强化学习
Schrittwieser，j .，Hubert，t .，Mandhane，a .，Barekatain，m .，Antonoglou，I .，和 Silver，D. (2021)。利用学习模型进行规划的在线和离线强化学习。 arXiv 预印本 arXiv:2104.06294 。
基于模型的强化学习是最广泛使用的数据高效学习解决方案。它通常离线(从固定数据)或在线(通过与环境交互)执行。当前的方法首先学习环境的模型，然后在该模型上训练策略。他们不直接使用学习到的模型来计划动作序列。这正是作者称之为 Reanalise 的方法所提出的。这种方法侧重于直接使用学习到的模型来改进策略和价值。这种改进可以离线(从数据)和在线(通过与环境交互)完成。Reanalize 最终成为半在线半离线学习的解决方案。他们的方法与基于模型的算法兼容，特别是与 MuZero 兼容。结合这两者，我们得到了作者所说的 MuZero 不插电。
图来自文章:不同再分析分数在《吃豆人》中的最终得分。MuZero 不插电可以学习任何数据预算。
MuZero 不插电在线和离线强化学习达到了一个新的艺术境界。对于所有数量级的数据预算，它都优于 Atari 学习环境中以前的基线。我喜欢这个统一算法的自然想法，它可以学习所有数量级的数据预算，并处理离线和在线数据，而无需特殊适应。
奖励论文:应用于手写邮政编码识别的反向传播
LeCun，y .，Boser，b .，Denker，J. S .，Henderson，d .，Howard，R. E .，Hubbard，w .，& Jackel，L. D. (1989)。应用于手写邮政编码识别的反向传播。神经计算， 1 (4)，541–551。
本周再次出现了一篇应该知道的文章。这篇发表于 1989 年的论文首次提出了利用反向传播直接从图像中学习卷积核系数的方法。在这个出版物中，目标是识别手写的邮政编码。(这些相同的代码稍后将产生 MNIST 数据集)。这种方法用于所有计算机视觉算法，包括当观察空间是图像时的强化学习。
图来自文章:卷积神经网络架构
值得注意的是，这种方法并没有立即引起人们的兴趣。这些算法是计算密集型的，并且在实践中学习过程非常长。直到 2000 年，GPU 带来的计算并行化才允许通过并行化矩阵计算来显著提高这种方法的效率。
我很高兴向你们展示我本周的阅读材料。请随时向我发送您的反馈。
强化学习论文#7 的每周回顾
每周一，我都会发表我研究领域的 4 篇论文。大家来讨论一下吧！
作者图片
论文 1:神经科学和强化学习之间的学习差距
Wauthier，S. T .，Mazzaglia，p .，atal，o .，De Boom，c .，Verbelen，t .，和 Dhoedt，B. (2021 年)。神经科学和强化学习之间的学习鸿沟。arXiv 预印本 arXiv:2104.10995 。
有两种可能的配置。奖励用红圈表示。在第一种配置中，奖励在左边，在第二种配置中，奖励在右边。
来自报纸的数字
在其初始位置，代理无法区分这两种配置。所以增加了一条线索:一个窗户后面的圆圈，如果奖励在左边，它是蓝色的，如果奖励在右边，它是绿色的。最后一个细节，特工不允许探索 T 的两个分支，一旦他进去了一个，他就不能回来了。很简单，不是吗？你认为 DQN 或 PPO 会在多少次迭代中解决这个问题？打个赌。
下面是令人惊讶的坏结果:在最好的情况下，DQN/彩虹、PPO 和 DreamerV2 的成功率是 50% 。代理人不可能做得比这更好。50%意味着代理似乎知道奖励出现的两个位置，但似乎无法预测奖励是在左边还是在右边(即使底部的彩色圆圈给了它这个信息)。代理人似乎没有把线索圈的颜色和悬赏的位置联系起来。有人可能会说这种观察是不全面的，解决这个问题需要记忆机制。DreamerV2 有记忆机制，成功率还是 50%。
我必须承认我对这些结果感到惊讶，但我认为这揭示了许多 RL 作品的偏见。当前的基准测试限制太多，并且使用许多技巧来使学习过程有效。这些技巧虽然重要，但往往在报纸上甚至没有提及。作者提出的一种方法是再次接*神经科学。我喜欢他们的结论。
论文 2:复杂行动空间中的学习和计划
休伯特，t .，施利特维泽，j .，安东诺格鲁，I .，巴雷卡廷，m .，施密特，s .，和西尔弗，D. (2021)。复杂动作空间的学习与规划。 arXiv 预印本 arXiv:2104.06303 。
作用空间可以是有限离散的，无限离散的，连续的，甚至多维连续的。行动空间越复杂，正确评估政策就越困难。仅仅列举所有可能的行动可能是不可能的。在本文中，作者提出了一个相当自然的想法:关注发生概率最高的动作。如何评价这种发生概率？你不用，你只要样就可以了。这种抽样是问题的核心，因此他们给他们的框架起了个名字:抽样 MuZero(他们使用 MuZero，但是他们的方法应该在所有基于策略迭代的方法上工作)。
所以我们不再对整个动作空间进行推理，而只对动作的缩减子集进行推理。于是问题出现了:为了让学习正确进行，必须对多少个动作进行采样？显然，采样的动作越多，学习就越好，但是计算时间越长也越重要:这是一种折衷。为了说明这种折衷，作者将他们的方法应用于围棋游戏:362 种可能的动作。是的，行动空间的大小是非常合理的，但它允许他们与理论上的最大值进行比较，理论上的最大值在于可以访问整个行动空间。所以他们通过取样 15、25、50 和 100 个动作来比较学习曲线。结果如下:
图来自文章:经典围棋棋局结果。Elo 衡量玩家的水*。
我们看到，通过对 50 个动作(不到 15%的可能动作)进行采样，学习曲线非常接*对应于访问所有动作的曲线。
连续动作空间也获得了类似的结果(DeepMind 控制套件，Real-WorldRL 套件)。这是一个有趣的技巧，可以大大减少计算时间。
论文 3:基于模型的强化学习的模块库
Pineda，l .，Amos，b .，Zhang，a .，Lambert，N. O .，& Calandra，R. (2021)。MBRL 库:基于模型的强化学习的模块化库。 arXiv 预印本 arXiv:2104.10159 。
基于模型的强化学习框架不再需要被证明。当与环境交互的成本很高时，基于模型的 RL 仍然是给出最佳结果的方法。然而，实现没有无模型方法那么直接。作者提议建立一个图书馆，他们称之为 MBRL 图书馆。它是一个机器学习库，用于基于连续状态-动作空间中的模型进行强化学习(我们可以很遗憾不能使用离散空间)。图书馆使用 PyTorch。
说实话，我还没用过，不过一直在浏览代码。基于模型学习的示例代码仍然不多。目前，只有 MBPO 和宠物，仅此而已。我猜目标是贡献者丰富他们的图书馆。我很期待看到这一举措是否会在基于模型的 RL 社区中产生诱惑。0.1.0 版本发布不到两周，敬请关注。这里是回购。
论文 4:进化强化学习算法
共同雷耶斯，法学博士，苗，y，彭，d，雷亚尔，e，莱文，s，乐，Q. V，…和浮士德，A. (2021)。进化强化学习算法。arXiv 预印本 arXiv:2101.03958 。
学习就是学会学习。它是机器学习的一个完整分支，与强化学习有一些交叉。这是其中之一。
出发点是所有的强化学习算法都可以用图来表示。这里有一个 DQN 的例子:
图来自文章:DQN 的可视化，作为一个计算图。输出就是损失。
先说一组算法，随机的或者文献上的。这些算法必须首先在所谓的“障碍”环境中表现良好，然后才能被允许在一组更困难的环境中进行训练。如果一个算法过不了这一关，它就会被淘汰。其他的用来更新不时变异的算法群体。在训练结束时，在测试环境中评估性能最佳的算法，该测试环境不同于它已经训练过的所有环境。
图来自文章:方法概述。
令人惊讶的结果:通过在简单的经典控制和 gridworld 任务上从头开始学习(没有任何最先进的算法)，这种方法重新发现了时差(TD)算法！
我很高兴向你们展示我本周的阅读材料。请随时向我发送您的反馈。
强化学习论文#8 的每周回顾
每周一，我都会发表我研究领域的 4 篇论文。大家来讨论一下吧！
作者图片
论文 1:随机延迟的强化学习
拉姆斯泰特、布泰勒、贝尔特拉姆、帕尔和比纳斯(2020)。具有随机延迟的强化学习。 arXiv 预印本 arXiv:2010.02966 。
行动和回报之间的延迟是常见的，也是 RL 中的一个核心问题。即使在现实世界中:一个行为可以立即产生回报(例如，跌倒后立即出现的疼痛的负面回报)，也可以有很长的延迟(在学校表现良好可以让你获得一份远离财务问题的工作)。显然，整个中间范围都包括在内:一个动作可以产生任意远的时间上的回报)。相反，某一时刻的奖励不能系统地归因于单一的过去行为。事实上，这可能是所有先前行为的回报，每个行为都有或多或少的重要贡献。
在本文中，作者介绍了以下范式:延迟环境是在延迟通信动态中封装未延迟环境(一个动作立即产生相关的回报)的结果。
文章图:延迟环境是延迟通信动态中未延迟环境封装的结果。
动作延迟到达这个无延迟环境，而观察延迟到达代理。他们称之为随机延迟马尔可夫决策过程(RDMDP)。
接下来，作者介绍了一种来自软演员评论家(SAC)的算法，他们称之为延迟校正演员评论家(DCAC)，其中他们添加了来自重放缓冲区的轨迹的部分重采样。这允许他们估计多步偏离策略状态值。获得的结果似乎比用 SAC 获得的结果更好。优点主要是对延迟的鲁棒性，延迟可以同样大或为零。
论文 2:加强对少量学习的关注
洪军，方，李，张，陈，陈，李，李(2021)。强化对少量学习及以后的注意。 arXiv 预印本 arXiv:2104.04192 。
机器学习的主要限制之一是它是{一切}-密集型的:它是数据密集型、计算密集型、时间密集型和能量密集型的。因此，一个主要的挑战是改进学习算法，使它们不那么贪婪。这是少投学习的目标。它包括从非常少量的支持物中正确地识别未知类别的样本。
在这篇文章中，作者通过用强化学习算法训练注意机制，将 RL 和少数镜头学习联系起来。因此，代理被训练来适应性地定位特征空间中感兴趣的区域。奖励函数被构造成使得如果代理对所选数据有良好的预测，则代理被奖励。
结果表明，保留的表征越来越歧视少数镜头的学习场景。同样，分类似乎给出了令人满意的结果。因此，强化学习在这个领域很有帮助。
论文 3:通过多智能体强化学习自动化湍流模拟
Novati，g .，de Laroussilhe，H. L .，& Koumoutsakos，P. (2021 年)。通过多智能体强化学习实现湍流建模自动化。自然机器智能， 3 (1)，87–96。
所有学过流体力学的人都知道，描述流体流动的唯一方法是模拟。随后的方程只能找到非常特殊情况下的解，对于航空或气象应用来说太简单了。最*，机器学习使得大大增加模拟的真实性成为可能。作者在这里提出了多智能体强化学习作为自动湍流模型发现的工具。进入更多的技术细节:作者使用大电流各向同性湍流模拟，并从直接数值模拟中以统计特性恢复的措施奖励代理。代理必须识别流程中的关键时空模式。目标是在亚网格尺度上估计未解决的物理问题。
来自文章的图:代理(红色块)执行本地化操作。观测值包括由一小组局部和全局变量编码的流场状态
结果表明，这种方法是真正令人感兴趣的，并且似乎可以很好地推广到学习过程中从未遇到过的流动。学习模型给出了良好的结果，但是避免了对复杂的流体动力学方程进行积分。
论文 4: Parrot:强化学习的数据驱动行为先验
辛格，刘，周，于，莱茵哈特，n .，，莱文，S. (2020)。 Parrot:用于强化学习的数据驱动行为先验。 arXiv 预印本 arXiv:2011.10024 。
考虑一个机器人必须学会抓住物体的环境。它将首先探索环境，大部分时间甚至无法触及物体。这可能是学习的一个相当大的障碍，尤其是在回报很少的情况下。另外，这不是我们人类学习的方式。我们重复使用我们在其他领域学到的技能，并试图将它们用于新的任务:学习打网球可能很难，但我们可以重复使用我们已经学到的技能，如跑步，或握球拍；我们从来没有真正从零开始。
本文提出的问题是:我们如何为 RL 代理人提供这种有用的预培训？作者提出了所谓的行为先验，即从其他任务的先前学习中学习到的。这些先验可以被重用来快速学习新任务，同时保留代理尝试新行为的能力。
来自文章的图:训练数据集由来自广泛任务的接*最优的状态-动作轨迹组成。每项任务都可能涉及到与一组不同的对象进行交互。
结果令人信服。学习成绩比基线好得多。我不认为这是一个很大的惊喜，也相当令人放心。重用经验应该增加学习能力。本文的真正成果是找到了一种机制，允许在重用已学技能和探索新行为之间进行灵活的折衷。
我很高兴向你们展示我本周的阅读材料。请随时向我发送您的反馈。
强化学习论文#9 的每周回顾
每周一，我都会发表我研究领域的 4 篇论文。大家来讨论一下吧！
作者图片
论文 1:连续动作、状态和时间中的价值迭代
Lutter M .，Mannor S .，Peters J .，Fox D .，Garg A. (2021)。连续动作、状态和时间的价值迭代。 arXiv 预印本 arXiv:2105.04682 。
强化学习方法首先是表格化的:人们必须从有限数量的动作中选择一个动作，这是从有限数量的可能观察值中得出的观察值。这些学习方法被连续扩展到连续观察空间，然后扩展到连续动作空间。这里作者感兴趣的是连续时间。这不是每 t 秒采取一次行动的问题，而是在连续的时间内进行一次真正的控制。
最明显的框架是机器人技术，这是他们选择的。他们提出了连续拟合值迭代(cFVI)，这是一种基于已知动态模型的允许连续控制的算法。
作者在仿真和真实世界中展示了该方法在几种控制环境中的有效性。一个经典的问题在于学习一个策略，并使用转移方法(例如，领域随机化)将其部署到现实世界中。非常有趣的是，尽管没有使用模拟真实迁移学习方法，但是用 cFVI 学习的策略在真实世界中比用离散时间控制学习的策略更健壮。看一看:
论文 2:人工智能经济学家:用人工智能驱动的税收政策改善*等和生产率
郑，s .，Trott，a .，斯里尼瓦萨，s .，n .，Gruesbeck，m .，，D. C .，& Socher，R. (2020)。人工智能经济学家:用人工智能驱动的税收政策改善*等和生产率。arXiv 预印本 arXiv:2004.13332 。
人工智能经济学家 T21 是一个强化学习框架，旨在模拟一个简化的世界，由几个经济主体组成。在这种环境下，每个代理人都可以与其他代理人互动，交换商品，聚集资源，建设以获得收入…他们也被征税，税收的钱被用于建设道路，学校…
目标是最大限度地提高生产率和代理之间的*等。选择税收政策是为了最大限度地实现这一双重目标。要在高收入和低收入的税收水*之间找到恰当的*衡，选择如何重新分配税收，将税收投资到哪里，等等，都需要谨慎的政策。
就目前而言，环境过于简单，无法得出政策建议。然而，人们可以想象一个更完整的模拟，其中代理人的个人行为，以及公司和社区的行为，更忠实于现实。还有必要引入一个与经济完全相关的不可或缺的目标:生态。
论文 3:强化学习中信心偏差的计算来源
勒布雷顿，m .，帕尔明特里，s .，加西亚，N. A. S. (2021 年 5 月 5 日)。强化学习中置信度偏差的计算来源。从 osf.io/cy9e6 取回
无知比知识更容易带来自信
牛顿说。他描述了一种后来被称为邓宁-克鲁格效应的偏见。简单地解释一下:当一个不称职的人倾向于高估他或她的能力水*。在这一点上你认为这是典型的人类偏见。然而，这种偏见也存在于强化学习中。很少有文章试图解释这些偏见是如何以及为什么在强化学习环境中出现并持续存在的。作者将这种行为描述为反直觉的，我同意他们的观点。
那么，我们该如何解释呢？作者认为，这些信心偏差出现并保持在学习偏差的强化学习环境中。因此，他们在学习阶段和迁移阶段检查了不同的工具和信心判断。研究结果表明，强化学习包括依赖于上下文的学习和确认更新，是解释参与者对论文中使用的任务的选择的一个非常好的候选。第二，他们表明模型的过度自信偏差可以通过学习的信心值的过度加权来解释。因此，他们得出结论，基于所提出的强化学习模型，可以预测个体的认知偏差。
论文 4:通过神经网络构建组合学
瓦格纳(2021)。通过神经网络构建组合学。 arXiv 预印本 arXiv:2104.14516 。
对数学家来说，伟大的新工具是计算机。不仅进行大型计算，而且从几十年前开始，帮助他们进行论证。这叫计算机辅助校样。这些计算机辅助校样开始有了良好的记录。除了其他方面，它们让我们获得了一些革命性的结果，如四色定理的证明或开普勒猜想的证明。毫无疑问:机器学习算法是最强大的工具之一，不仅对数据科学家，对所有科学家，包括数学家都是如此。这里有一个证明。
在这篇文章中，作者再次展示了强化学习应用于计算机辅助证明的兴趣。他们的主题是图表。图形是一个活跃的研究课题，数学家们经常提出问题或猜想。一个猜想只有被证明才能成为定理。事实证明，有些猜想是错误的。要说明一个猜想是假的，需要提供一个反例。因此，作者有了使用强化学习来寻找使一些猜想无效的图的反例的想法。被驳倒的猜想有:奥奇切-汉森猜想、柯林斯猜想和阿伦森-格罗兰-格泽西克-基拉克-约翰斯顿猜想。我不会解释这些猜想，因为它们往往是非常数学化的，并没有带来太多的意义。重要的是要记住，这些反例是通过一种强化学习算法获得的:深度交叉熵方法。
对于每一个猜想，都会生成一个图，然后提交给环境。环境，根据猜想，会有回报。然后，代理将最大化这个奖励，并在某些情况下，找到一个图的反例来使猜想无效。
图自文章:关于图的邻*和距离特征值猜想的最佳构建图的演化。看来网络很快意识到稀疏图是最好的，最终出现了“*衡双星”结构。最后，给出了一个反例。
这篇文章不仅反驳了猜想，它还解决了关于图的其他问题，要了解更多，去探索这篇非常有趣的文章。
我很高兴向你们展示我本周的阅读材料。请随时向我发送您的反馈。
重量衰减及其特殊效应
它是如何工作的，为什么工作，以及一些实用的技巧。
由在 Unsplash 上拍摄的好的免费照片。我们都喜欢光滑的东西，不是吗？
什么是体重衰减？
权重衰减，有时被称为 L2 归一化(尽管它们并不完全相同，这里是解释差异的好博客文章)，是正则化神经网络的一种常见方法。它有助于神经网络学习更*滑/更简单的函数，与尖锐、嘈杂的函数相比，这些函数在大多数情况下更容易概括。
有许多正则化，权重衰减是其中之一，它通过在每一步用一些小因子将权重推向零来完成工作。
在代码中，这实现为
重量衰减的基本实现
其中weight_decay是一个超参数，典型值范围从 1e-5 到 1。
实际上，您不必亲自执行此更新。例如，PyTorch 中的优化器有一个为您处理所有更新的weight_decay参数。
在 PyTorch 中使用权重衰减
体重衰减的直觉
但是体重衰减实际上对模型有什么帮助呢？什么情况下应该用？
首先，我们必须理解为什么有时模型不能一般化。
古典政体
在经典的机器学习理论中，我们认为存在“欠拟合”和“过拟合”区域。
传统体制中模型容量的训练和测试损失摘自“协调现代机器学习实践和偏差-方差权衡”
在欠拟合区域，模型“太简单”而不能捕捉数据的结构，因此既有高训练误差又有高测试误差。
在过拟合区域，模型具有足够的容量，它可以仅记忆训练数据集而不学习数据的底层结构，导致低训练误差但高测试误差。
无论是哪种情况，这个模型都不能一概而论。传统观点认为，最好的模型位于这两个区域之间。
权重衰减在这里作为一种方法降低模型的容量，使得过度拟合的模型不会过度拟合，并被推向最佳点。这也表明，如果模型最初在欠拟合区域中运行，重量衰减将具有负面影响。
现代政体
然而，最*的研究揭示了一种称为“深度双重下降”的现象，表明实际上存在第三个区域。虽然经典理论认为进一步增加模型复杂性会导致更高的测试误差，但经验证据表明，随着我们从“过拟合”区域进入“过参数化”区域，测试误差将会下降。
从“现代机器学习实践与偏差-方差权衡的调和”中截取的训练和测试损失与模型能力的全貌
经验证据表明，过拟合和过参数化区域之间的这种边界(称为“插值阈值”)发生在模型刚好具有足够的能力来实现(接*)零训练损失的时候。
在插值阈值处，只有一组参数可以对整个训练集进行插值。最有可能出现的情况是，这种特定的插值将会非常颠簸和尖锐，因为大多数数据集都包含一定程度的噪声。当模型被迫以勉强足够的能力适应所有噪声时，它没有额外的空间来使噪声训练点之外的函数*滑，因此泛化能力很差。
随着我们进一步增加模型容量，它不仅可以完美地命中训练数据点，还可以获得额外的容量来选择在空间之间*滑插值的函数，从而更好地进行概括。
这就是体重下降的原因。
在模型可以学习的所有可能的插值中，我们希望使我们的模型偏向更*滑、更简单的插值，这样它就能够进行推广。重量衰减正是这样做的。这就是体重下降如此强大的原因。
虽然不完全准确，但我认为下面的迷因很好地总结了我们目前的理解。
完全由我原创的迷因
玩具实验
为了测试上述特性，我训练了一个带有跳跃连接的简单前馈网络，以学习对二进制编码的数字执行加法。您可以在这里找到完整的源代码:
https://github.com/andylolu2/ml-weight-decay
它在 2 位和 4 位加法上被训练，并且在 3 位加法上被测试以测量它的概括能力。以下是一个示例培训点:
示例培训输入和标签
我的模型由两个剩余块组成，每个块的宽度为 256，总共有 300K 个参数，这些参数几乎肯定会在“过参数化”区域内运行。我针对重量衰减因子的不同值对其进行了训练，下面是它与训练和测试精度的关系图:
在我的玩具实验中，精确度与重量衰减系数λ的关系图
我们可以看到，对于这个模型，λ的合适值是 0.1 左右。
在左手侧，当λ太低时，模型完全具有足够的能力来拟合训练数据集，但是不偏向于寻找更简单的插值，因此测试精度非常低。
在右侧，当λ太高时，该模型由于被迫使用非常小的权重而受到太多限制，以至于它的表达能力不足以适应训练数据。因此，训练和测试精度都很低。
根据我们上面的直觉，我们期望在插值阈值处看到测试精度的下降——但是我们没有。为什么？
我的最佳猜测是因为我们的数据集是完全无噪声的，所以插值阈值处的特定权重集不会出错，最终会很好地进行概化。
为了进一步说明权重衰减在帮助模型概化方面的重要性，下面是λ = 0.1 的模型的训练曲线:
在我的玩具实验中，λ = 0.1 的训练曲线
在前 3665 个步骤中，该模型能够达到 100%的准确率，并且几乎没有训练损失。但是测试精度还是很低。
在接下来的 25K 步中，它继续最小化权重范数(模型权重的*方和),同时保持完美的训练精度。这对应于为训练数据找到更简单的插值，并且我们可以清楚地看到这与测试准确度的增加之间的相关性。
更简单的插值=利润！
选择正确的价值
好的，所以体重下降是非常有用的。现在，我如何选择正确的λ值呢？
一般来说，挑选体重衰减值没有金科玉律。一些尝试和错误是不可避免的。然而，有一些规则你可以遵循。提出 AdamW 优化器的研究人员提出了以下规则:
“解耦权重衰减正则化”中提出的归一化权重衰减因子公式
其中 b 批量， B 为训练点总数， T 为总历元数。现在要调整的新超参数是 λ_norm 。
所以他们只是把一个超参数换成了另一个超参数…嗯…这个怎么有用？？
这很有帮助，因为将 b 、 B 和 T 的选择从合适的权重衰减值中分离出来，因此更容易调整超参数。
但是，您仍然需要搜索 λ_norm 的好值。作者发现 0.025 到 0.05 范围内的 λ_norm 对于他们训练的图像分类网络来说是最佳的。也许这可以作为一个有用的起点。
批处理规范化的问题
如今，我们几乎总是将批量范数层放入我们的神经网络，因为它大大加快了训练速度。然而，当我运行我的实验时，当我使用具有权重衰减的批范数层时，我经常看到这种周期性波动的奇怪行为。
在我的玩具实验中，使用批量标准训练时出现了奇怪的周期波动，重量随默认值衰减
这肯定不是我第一次看到这种行为。似乎当模型即将收敛时，这些波动就开始出现了。那么是什么造成的呢？
我在谷歌上寻找答案，看到了这篇文章:
https://arxiv.org/abs/2106.15739
总之，这与批处理规范层的工作方式有关。
受 PyTorch Doc 启发的批量定额层方程
上面显示了 batch norm 如何计算其输出的公式。这里， x 是一个尺寸为 (batch_size，1) 的特征。重要的是，它将这些值除以 x 的方差与某个小值εϵ.之和的*方根
当我们使用权重衰减时，一些权重逐渐变为零。随着权重趋*于零，无论从上一层得到什么输入， x 的值也将趋*于零(或恒定值)。
结果，批中的 Var[ x ]变得很小，以至于当我们将它传递给批范数层时，它将其除以一个接*于零的值，导致最终输出放大。这导致了巨大的波动，如下图所示。
爆炸后，由于该步骤的巨大梯度，权重更新为某个大值，因此方差再次变高。重量会再次开始衰减，这个过程会不断重复，形成周期性的模式。
从实用的角度来看，为了避免这种不稳定性，我发现简单地将 epsilon 的值增加到更大的值(比如1e-2而不是 PyTorch 默认的1e-5)效果惊人地好。
又一个有用的东西放在你的脑后。
摘要
权重衰减是一种正则化方法，通过学习更*滑的函数使模型更好地泛化。在经典(欠参数化)状态下，它有助于限制模型过拟合，而在过参数化状态下，它有助于引导模型朝向更简单的插值。实际上，有一个最佳的重量衰减值范围。
希望你觉得这个博客有用！
密码
https://github.com/andylolu2/ml-weight-decay
参考
- 普里图姆·纳基兰、加尔·卡普伦、亚米尼·班萨尔、特里斯坦·杨、波阿斯·巴拉克、伊利亚·苏茨基弗。 深度双下降:更大的模型和更多的数据伤害 。2019.arXiv:1912.02292
- 米哈伊尔·贝尔金，丹尼尔·许，，苏米克·曼达尔。 调和现代机器学习实践和偏差-方差权衡 。2019.arVix:1812.11118
- 叶卡捷琳娜·洛巴切娃、马克西姆·科德良、娜杰日达·奇尔科娃、安德烈·马林宁、德米特里·维特罗夫。 对神经网络的周期性行为进行批量归一化和权值衰减训练 。2021.arVix:2106.15739
- 伊利亚·洛希洛夫，弗兰克·哈特。 解耦权重衰减正则化 。2019.arVix:1711.05101
深度学习中的权重初始化和激活函数
显著影响模型性能的微小变化
莱纳斯·尼隆德在 Unsplash 上拍摄的照片
D 开发深度学习模型需要大量的微调。本文讨论并比较了不同的激活函数和权重初始化器对模型性能的影响。
本文将涵盖三个激活函数: sigmoid ，双曲线正切( tanh ，整流线性单元( ReLU )。
然后用三个初始化器测试这些激活函数:Glorot(Xavier)He， LeCun 。
这篇文章分成几个部分:
- 激活功能和重量初始化
- 激活功能
- 重量初始化功能
- 砝码初始化和激活实验
这是关于调整深度学习模型系列的第二篇文章。随着新文章的产生，我会添加下面的链接。
激活功能和初始化
有效的深度学习模型需要大量微妙的调整。然而，小的变化可能会波及到您的模型，并显著改变性能，因为它们是健壮和灵活的。
激活功能是深度学习课程介绍中介绍的那些方面之一。有许多选择，但是没有给出每种方法的太多细节。
尽管提供的细节有限，但它们似乎比本文的另一个主题初始化更容易理解。
你可能会想，“我将随机初始化我的权重，使之变小”，这样你就能产生好的模型。但是这篇文章和围绕它的一系列文章都不是关于好的。我们想要优秀的模特。
相反，我们可以通过仔细选择激活函数和初始化器来为我们的模型挤出更多的性能。
激活功能
激活函数在深度学习模型中起着重要的作用。但很多人可能体会不到其中的微妙。
激活功能(作者图片)
在核心处，激活函数允许非线性关系的建模。
很简单，但极其重要。没有这些激活函数在本质上更复杂的线性回归中将每一层的输出传递给下一层。停下来想一想这一点。
如果你以前使用过逻辑回归模型，你可能已经知道这种情况。逻辑函数或 sigmoid 函数将线性回归模型的线性输出转换为分类所需的非线性输出。
没有 sigmoid 函数，逻辑回归只是线性回归。
因此，虽然激活函数可以将非线性关系引入到模型中，但是应该使用什么函数呢？在谷歌上快速搜索可用的功能，会给你提供一长串的功能。例如，swish 或指数线性单位函数对许多人来说没有多大意义。但是这些功能中的每一个在深度学习中都有它的位置。
尽管可用的功能多种多样，但它们有一些共同点。也就是说，它们根据基于导数的优化方法更新模型权重。
注意:不是所有的优化方法都需要梯度，但这是另一篇文章的主题。
在这篇文章中，我将介绍三个更常见的激活函数。
- 乙状结肠
- 双曲正切 (Tanh)
- 整流线性单元 (ReLU)
乙状结肠的
对许多人来说，sigmoid 函数是他们遇到的第一个激活函数。此函数将连续输出转换为 0 到 1 范围内的输出，用于逻辑回归。
sigmoid 还具有简单易用的梯度，非常适合梯度下降优化。
Sigmoid 函数
双曲正切值
类似于 sigmoid 函数，但有明显的区别。输出的范围是-1 到 1。这种看似很小的差异允许深度学习模型的有趣的新架构。
长期短记忆(LSTM)模型在每个单元中大量使用双曲正切函数。这些 LSTM 单元是理解不同输出如何开发鲁棒架构的绝佳方式。
关于这些激活函数的输出范围如何影响的更多细节可以在我下面的文章中找到。
Tanh 函数
整流线性单元
构建越来越大的模型时出现的一个问题是渐变消失的问题。误差必须传播通过的层越多，来自反向传播的更新就受到抑制。
这种行为的结果是，在每次训练迭代期间，许多权重仅少量更新。ReLu 激活用于缓解这个问题。
与之前的激活功能相比，ReLu 激活的输出范围为[0，inf。从受限范围的输出到不受限制的正输出的这种变化允许误差更有效地通过模型传播回来，从而改进了更新权重的过程。
ReLU 函数
重量初始化功能
权重初始化是深度学习中经常被忽视的一个方面。一般来说，你可以摆脱随机初始化。或者，您的 TensorFlow 模型的默认初始化方法工作正常(不是说您知道默认值是什么)。
然而，正如您将在实验中看到的，权重初始化的选择可以与激活函数配对，以产生显著的性能增益。
下面是本文中涉及的三种初始化方法(不包括随机方法)。
- 格洛特(泽维尔)
- 何
- 乐村
虽然还有很多初始化器，但这三个是很好的起点，尤其是如果您以前从未尝试过初始化的话。
这些方法应该补充激活功能以观察最大益处。
均匀分布与正态分布
对于那些使用 TensorFlow(本文中的深度学习包)的人，您会注意到初始化器有两个选项，uniform 和 normal。
这些分布之间的差异通常很小。不幸的是，对于哪种发行版表现最好，还没有达成共识。
这些差异也可能是由于您使用的数据造成的。
无论如何，对于本文中的实验，使用了均匀分布。
初始化方法
这些初始化方法试图将深度学习模型的初始条件置于用于训练的理想状态。
显示了以下方法的分布函数。但是，请记住，正态分布有一个稍微不同的公式。
格洛罗特
Glorot(或 Xavier)初始化试图缓解渐变消失的问题。这个解决方案是通过将初始权重设置为一个分布来产生的，其中该分布的方差取决于输入和输出层的数量。
Glorot 函数是为 sigmoid 函数设计的。输入单元的数量被定义为“扇入”，而输出单元的数量被定义为“扇出”下面的完整公式代表了均匀分布的极限，其中值是从范围 [-limit，limit] 中均匀提取的
格洛特均匀分布的极限公式(图片由作者提供)
男性
Glorot 对于 ReLu 来说不是最佳的。因此引入了 he 初始化。
这种方法只考虑输入层的变化。其中下面的公式也是均匀分布的极限。从范围[-极限，极限】中选择重量
均匀分布的极限公式(图片由作者提供)
乐村
类似于 he 初始化，但是该方法的规模减小了。
虽然此函数与其他权重初始化方法非常相似，但细微的变化会在模型的完整训练中产生不同的结果。下面再次给出均匀分布极限的公式，以形成范围 [-limit，limit]
勒村均匀分布的极限公式(图片由作者提供)
请注意，这些方法彼此非常相似。因此，即使是对深度学习模型的微小改变，如随机种子，也可能改变每个初始化器的性能。
这些权重初始化方法旨在根据它们各自的输入和输出来表示权重的方差。
砝码初始化和激活实验
本文的剩余部分给出了一个简单的实验，您可以从提供的代码中重新创建这个实验。目的是比较具有不同激活函数的不同权重初始化方法。
这些实验决不是结论性的。相反，它们说明了不同权重初始值设定项之间的显著差异。
观察这些结果时，请关注模型的中间性能。虽然最好的结果需要更多的训练，但是如果您有计算限制，那么继续训练您的模型可能是不可行的。
实验设置
对于这个例子，我在公共领域许可下使用 diamonds 数据集。这个数据集由分类变量和数字变量的组合组成。对于本文，我已经删除了分类特性。
https://www.kaggle.com/shivam2503/diamonds
该数据集提供了许多要素的大量数据。因此，展示不同的激活功能和不同的初始化功能应该足够复杂。
数据加载和缩放(由作者编写代码)
生成模型
使用的模型是在 TensorFlow 中设计的简单多层神经网络。请注意，这种结构非常适合初始化器，因为输入和输出层的大小相同——尤其是 Glorot，它是围绕相等的输入和输出大小设计的。
目标输出是连续的，损失设置为*均绝对误差。对于每个实验，激活被修改。最终模型有两个完全连接的层，每层有 50 个节点。
创建模型和参数初始化(由作者编写代码)
可视化结果
为了可视化实验的结果，我使用了库 Plotly。我过去广泛使用过这个包。复制文章中的情节的代码来自下面的代码。关于 Plotly 的细节可以在链接文章中找到。
只有验证损失显示在图中。这种选择纯粹是为了减少结果中的混乱。更有效的结果分析将包括训练和验证损失曲线，产生模型优化的完整可视化。
多个模型的图验证损失(作者代码)
激活和初始化方法的比较
为实验的每个激活函数和权重初始化方法生成新的模型。此外，还会跟踪培训历史，并显示培训中的验证损失。
学习率被设置得相对较低，以便揭示每个初始化器之间的细微差别。
完整的实验可以从下面的代码段运行。
激活函数和初始化实验(作者代码)
乙状结肠激活
使用 sigmoid 激活的权重初始化方法的比较(图片由作者提供)
双曲正切激活
权重初始化方法与 Tanh 激活方法的比较(作者提供图片)
整流线性单元激活
权重初始化方法与 ReLU 激活的比较(图由作者提供)
在这些实验中，学习率被故意设置得很低。基本原理是延长学习所需的时期数。然而，这突出了一些令人兴奋的结果。
首先是 sigmoid 函数的奇怪行为。没有额外的训练时期，这个实验的中间结果是最差的。最好的结果来自 tanh 实验，它似乎与实现的权重初始化器无关。
还提出了随机均匀分布。有趣的是，随机分布在 ReLU 激活中比其他初始化器表现得更好。虽然这个结果是惊人的，但最好的表现仍然比其他实验差。
停下来考虑结果与每个初始化器的预期用例的不一致。为每个激活函数设计的初始化器通常不是性能最好的。由此，我们可以得出两点。
- 模型的性能取决于权重初始化、使用的激活函数和训练持续时间。
- 性能之间的差异可能更多地取决于底层数据，而不是所实现的特定组合。
这些实验应该被认为是对激活函数和权重初始化器的各种组合的性能差异的介绍。关于更严格的细节，请参考下面的参考资料。
结论
在深度学习模型中选择激活函数和权重初始化方法是一项重要的任务。这些相同的变化通过模型波及到整体性能的惊人变化。
当选择一个激活函数时，停下来考虑这个选择如何与你正在使用的初始化方法配对。
这些小的设计决策加起来可以创建更强大、更健壮、更有效的深度学习模型。
如果你有兴趣阅读关于新颖的数据科学工具和理解机器学习算法的文章，可以考虑在 Medium 上关注我。我总是在我的文章中包含代码，您可以将其应用到您的工作中！
如果你对我的写作感兴趣，想直接支持我，请通过以下链接订阅。这个链接确保我会收到你的会员费的一部分。
https://zjwarnes.medium.com/membership
参考
加权线性回归
线性回归是最简单和最著名的监督机器学习模型之一。在线性回归中，响应变量(因变量)被建模为特征(自变量)的线性函数。线性回归依赖于几个重要的假设，而这些假设在某些应用中是不能满足的。在本文中，我们研究线性回归的一个主要陷阱:异方差。
线性回归模型
我们从线性回归数学模型开始。假设有 m 个观测值和 n 个特征。线性回归模型表示为
其中 y 为响应变量， x 为( n +1) × 1 特征向量， w 为( n +1) × 1 包含回归系数的向量， e 表示观测误差。注意，向量 x 的第一个元素是 1，表示拦截(或偏差):
线性回归模型也可以矩阵形式写成
其中 X 为尺寸为 m × ( n +1)的特征矩阵， y 为 m × 1 的响应向量， e 为代表观测误差的 m × 1 向量。可以看出，线性回归的系数估计为
注意 w 的第一个元素代表拦截的估计值。
假设
线性回归基于几个重要的假设:
- 线性:指因变量与自变量呈线性关系。
- 正态:表示观测误差正态分布。
- 独立性:指观测误差相互独立。
- 同方差:表示观察误差不是响应变量的函数，并且其方差对于所有观察都是恒定的。
- 多重共线性低:表示自变量之间相关性不高。
在许多有真实数据的情况下，很难满足所有这些假设。这并不一定意味着你不能使用线性回归。然而，如果这些假设中的任何一个不满足，则不能期望最佳性能，并且模型系数的推断可能不准确。在本文中，我们的重点是假设 4。
同方差
线性回归假设 e 内的观测误差是独立同分布(即同分布)正态随机变量(假设 2、3、4)。这种情况在数学上可以表示为
其中 C 为观测误差的协方差矩阵， I 为单位矩阵，E 代表期望值。换句话说， e 的协方差矩阵为
协方差矩阵的对角元素表示每个观测误差的方差，并且它们都是相同的，因为误差是同分布的。非对角元素表示两个观测误差之间的协方差，并且它们都为零，因为误差在统计上是独立的。这种情况称为同质性。
异方差
在某些应用中，不能保证同方差，而且观测误差实际上不是同分布的(尽管我们仍然假设它们是独立的)。在这种情况下，观测误差的协方差矩阵表示为
其中对角元素是不相同的，并且每个观察值都有其自己的方差。缺乏同方差对线性回归结果有几个影响。首先，模型的性能不再是最佳的。换句话说，该模型不会具有最低的均方误差(MSE)。第二，模型系数和标准误差将是不准确的，因此它们的推论和任何基于它们的假设检验将是无效的。
侦查
有许多方法可以检测出你正在处理的是异方差数据还是同方差数据。最简单的方法是绘制线性模型的残差与预测值(拟合值)的关系图，并寻找残差中的任何特定模式。
残差与预测值，左:同方差，右:异方差数据(图片由作者提供— 来源
同方差数据的残差图没有显示特定的模式，值均匀地分布在水*轴周围。另一方面，异方差数据的残差图显示了不同预测值的残差变化的方差(沿水*轴的垂直分布)。
加权线性回归
加权线性回归是线性回归的推广，其中误差的协方差矩阵包含在模型中。因此，当我们处理异方差数据时，这可能是有益的。这里，我们使用最大似然估计(MLE)方法来导出加权线性回归解。MLE 是一种通过最大化模型的似然函数来估计未知参数的方法。线性回归模型中的响应变量 y 为多元正态随机变量。因此，MLE 可以推导为
由于对数函数是非递减的，我们可以取似然函数的对数。我们也去掉任何不依赖于 T2 w T3 的项
这相当于
通过扩展括号内的项并删除常数项
我们通过对上述项相对于 w 求导来估计 w ，并将其设置为零
相对于 w 求解，我们得到加权线性回归的解
可以看到，加权线性回归的解与线性回归的解非常相似。唯一的区别是加权线性回归使用误差的协方差 C 来寻找回归系数。因为 C 是一个对角矩阵，它的逆矩阵简单地通过用它们的倒数替换对角元素来获得
该表达式表明，加权线性回归根据方差对每个观测值使用不同的权重。如果观测值具有较大的误差方差，它对最终解的影响将较小(由于权重较低),反之亦然。注意，如果所有的观测值都具有相同的方差，则上述表达式将与线性回归的解相同。
异常稳健性
加权线性回归的另一个优点是它对异常值的鲁棒性。加权线性回归可以给异常值分配较小的权重，从而减少它们对系数估计的影响。异常值可以通过绘制标准化残差(也称为学生化残差)与预测值的关系图来检测:
标准化残差与预测值对比以检测异常值(图片由作者提供— 来源
任何绝对标准化残差大于 3 的观察值都被认为是异常值。
未知协方差
加权线性回归的主要缺点是需要观测误差的协方差矩阵来求解。在许多应用中，这样的信息在之前是不可用的。在这种情况下，可以估计协方差矩阵。有几种方法可以估计协方差矩阵。这里提供了一种方法:
- 不用协方差矩阵求解线性回归(或通过设置 C = I 求解加权线性回归，与线性回归相同)
- 计算残差
- 从残差中估计协方差
- 使用估计的协方差求解加权线性回归
Python 示例
在本节中，我们提供了一个 Python 代码片段来运行异方差数据的加权线性回归，并将其与线性回归进行比较:
在这段代码中，我们生成了一组合成数据，其中观察误差的方差是特征的函数。线性回归模型的实际斜率和截距分别为 5 和 2。我们首先使用线性回归来寻找残差并估计协方差矩阵。然后，我们运行加权线性回归，找到系数
响应变量与特征变量(图片由作者提供)
上图显示，在存在异方差的情况下，加权线性回归为回归系数提供了更准确的估计。
结论
在本文中，我们提供了加权线性回归的简要概述。当观测误差不具有恒定方差且违反线性回归的同方差要求时，应使用加权线性回归。加权线性回归的主要缺点是它依赖于观测误差的协方差矩阵。
参考
加权最小二乘&稳健回归 (2021)，宾夕法尼亚州立大学统计系。
南 Chatterjee，A. S. Hadi，示例回归分析，第 5 版 (2013)，John Wiley & Sons。
南统计处理基础，第一卷:估计理论(1993)。
你以前可能没见过的奇怪的 Python 东西
Python 的一些鲜为人知的最奇怪的秘密。
(src =https://unsplash.com/photos/vb-3qEe3rg8
介绍
Python 编程语言是一种充满了惊人的多范例特性的编程语言。这很棒，因为它给了 Python 做许多不同任务的灵活性。例如，如果 Python 是一种纯面向对象的编程语言，不支持泛型编程概念，那么它在数据科学领域可能不会那么流行。这是因为数据科学家通常需要一种高级声明式编程语言，在这种语言中，可以在全局范围内定义事物。想象一下为 Jupyter-Notebook 编写一个主函数。那就奇怪了。
自然地，有了所有这些关于范式和语法的有趣探索，Python 的世界实际上可以是相当广阔的，通常有些东西很容易被忽略，因为在这种语言中有许多其他的东西要看。我花了两篇文章，每篇有二十个模块，介绍了标准库中我认为对某些事情有用的模块！也就是说，有很多东西需要用 Python 来解包。不仅在它所吹嘘的生态系统中，而且在它的标准库和基础内部。尽管读者可能已经知道了所有提到的 Python 特性，但毫无疑问，他们很可能不了解 Python 编程语言的每个方面。也许这种语言的一些奇怪的怪癖和特性会在你的下一个项目中派上用场！
指定返回类型
PEP3107
如果你是一个 C 程序员，很可能你熟悉返回类型。对于所有的非 C 程序员(或其他具有这种特性的语言，Java，C++，等等)。)返回类型就是函数结束时将要返回的数据类型。此外，如果你对 C 感兴趣，但在阅读之后不知道从哪里开始，我确实有一篇文章提供了对 C 的简单介绍，对新程序员来说非常友好。如果你想要这本书，你可以在这里查阅:
有些人可能会惊讶地发现，在 Python 中也可以这样做。我实际上是在一艘直到最*才知道这件事的人的船上。Python 首先处理类型和函数的方式相当奇怪…来自像 Julia 这样具有健壮的、强类型系统的语言，尽管 Python 是相对强类型的并且几乎没有隐式类型，但我仍然觉得奇怪的是指定参数类型基本上没有任何作用:
# This is weird.def add5(x : int): return(x + 5)print(add5(5))10print(add5("Hi"))TypeError: can only concatenate str (not "int") to str
对我来说很奇怪的是，即使我们没有提供正确的类型，这个函数还是试图执行。同样奇怪的事情也适用于获取返回类型。为了指定返回类型，我们使用带有->.的函数注释
def add5(n : int) -> int: return "Hi " + str(n)
您可能会注意到，尽管该函数的指定返回类型是整数，但该函数返回的是字符串。在像 C 这样的语言中，这是行不通的。在 C 语言中，一个有趣的事情是，它会从一个指针生成一个整数。换句话说，我们实际上正在经历 C 语言中的隐式类型。下面是演示这一点的代码示例:
#include <stdio.h>int main(){printf("Hello World");return "Hello";}
编译这段代码会产生以下结果:
main.c:15:12: warning: returning ‘char *’ from a function with return type ‘int’ makes integer from pointer without a cast [-Wint-conversion]15 | return "Hello";| ^~~~~~~Hello World...Program finished with exit code 0Press ENTER to exit console.
然而，Python 示例的问题在于，类型没有被隐式更改。因此，我们几乎可以从返回类型为 integer 的函数中返回一个字符串:
type(add5(5))str
这很奇怪——因为指定返回类型到底对我们的 Python 代码有什么影响？从这个角度来看，客观地说，当涉及到类型系统时，它什么也不做。我决定在这方面做一些研究，以便找出每当我们指定一个返回类型时到底会发生什么。
为了更好地理解这个特性，我在 Python.org 上读了一些 PEP 对这个特性的解释。如果你想读我读的东西，你可以在这里:
https://www.python.org/dev/peps/pep-3107/#return-values
然而，基本上所有这些反复出现在我脑海中的是，这是一个完全没有意义的功能。这看起来很奇怪，这样的东西被编程到 Python 中，却没有一个函数类型的系统真正使用它。我唯一的想法是，这可能实际上是有用的，也许它可以帮助编译。在我读到之前，这是有可能的
“……也就是说，现在参数列表后面可以跟一个文字->和一个 Python 表达式。与参数的注释一样，当执行函数定义时，将计算该表达式。
看起来这个特性在很大程度上并不那么有用，也许它可以用来为文档字符串生成一些元数据，也就是说，通过返回类型，它将使文档更容易自动生成。不管这个功能实际上是为谁或为了什么，它肯定是一个怪异的功能。
(functools)缓存
谈到 Python，我最喜欢的一件事就是装饰者。在我看来，装饰器对 Python 来说是一个非常有价值的特性，它给这种语言的编程带来了巨大的好处。老实说，我对业界远离 Python 感到兴奋，因为这种语言有太多的缺点，我真的觉得类型系统一点也不健壮。也就是说，我在许多其他编程语言中没有看到的一个可取之处是 decorators。
装饰器是 Python 中最简单、最容易使用的特性之一，它可以对您生成的代码产生巨大的影响。它们可以用来加速代码，改变代码的工作方式，甚至操纵对象在 Python 中存储数据的方式。也就是说，我的下一个奇怪的 Python 特性来自于标准库的 functools 模块中的缓存功能。此外，如果您想了解更多关于这个库的信息，我有一整篇关于它的文章，非常激进:
为了利用缓存，我们将像这样导入 lru_cache:
from functools import lru_cache
这个装饰器让一个函数缓存一定数量的计算。递归对于计算机来说是一个很大的问题，有很多情况下可以避免使用递归函数来解决问题。然而，一种常见的递归实现是阶乘函数。
def factorial(n):
return n * factorial(n-1) if n else 1
让我们用数字 15 来试试我们的新阶乘函数。我还会计时，以便我们能掌握计算机做这样的操作需要多长时间。
%timeit factorial(15)1.94 µs ± 68.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
现在让我们尝试一个更大数字的阶乘，我们看到这仍然需要很长时间:
%timeit factorial(20)1.94 µs ± 68.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
现在我们将使用新的定义 fact()编写相同的函数。唯一不同的是，这次我们将使用 lru_cache 来修饰我们的函数。
@lru_cachedef fact(n): return n * factorial(n-1) if n else 1
现在让我们重复 15 的阶乘计算:
%timeit fact(15)63.8 ns ± 1.83 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
我们看到，与之前没有缓存的尝试相比，这种计算基本上没有区别。真正的诀窍是当我们现在提高到 20 的阶乘时:
%timeit fact(20)64.1 ns ± 1.51 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
我们看到这个值的计算有了显著的改进。为什么会这样呢？lru_cache 函数将把一些计算结果保存到缓存中。这使得随后的调用已经知道函数调用的答案，并简单地从其先前的内存中返回那些值。这是非常有价值的，这个函数是一个突出的应用程序的很好的例子。在某些情况下，这将使二项式分布计算减半。
(数据类)数据类
我列出的怪异 Python 的下一个例子是 dataclass。这是另一个我认为非常有价值的装饰。虽然 decorator 的工作非常简单，但是它可以通过消除对初始化函数和典型 Python 类的其他组件的需求，非常有效地节省大量代码。如果你想阅读更多关于这个特定主题的内容，我有一整篇关于数据类的文章，以及为什么我认为它们很酷，你可以在这里阅读:
[## Python 的数据类被低估了
towardsdatascience.com](/pythons-data-classes-are-underrated-cc6047671a30)
dataclass 的全部意义在于在 Python 中有效地使之更类似于 C 语言中的经典结构类型。鉴于 Python 面向对象的特性，很容易理解为什么它有时会妨碍创建仅仅是数据结构的类型，而不是整个类。使用数据类，只需简单地调用一个装饰器，就可以有效地保护自己免受 Python 中特定类型的面向对象部分的影响。考虑下面的例子:
[@dataclass](http://twitter.com/dataclass)
class Food:
name: str
unit_price: float
stock: int = 0
def stock_value(self) -> float:
return(self.stock * self.unit_price)
注意，在这个实例中没有 init()函数。通常，如果我们编写这个类并提供我们的值、名称、单价和股票，我们会遇到一个错误。这是因为该类实际上接受 0 个参数，而不是我们试图提供的 3 个参数。不用说，如果我们只是想做一些更像结构的东西，这可能会有问题。如果在初始化过程中除了分配成员变量之外没有其他事情要做，这也可以节省很多代码行。这是我刚刚谈到的例子的一个用法，我们将会看到这个类没有参数:
class Other: name: str unit_price: float stock: int = 0spaghetti = Other("Spaghetti", 8.75, 28)TypeError: Other() takes no arguments
但是在之前的食物类的例子中，
lasagna = Food("Lasagna", 10.26, 45)
就地字符串串联
字符串有时很难精确地表达和输入不同的值。如果我想在 Python 中把一个值放在一个字符串的中间，我该怎么做呢？有些人可能会采取拆分的方法，或者尝试在字符串中的特定短语后插入——这些可能是不错的解决方案。然而，有一个更好的方法可以解决这个问题。假设我有以下两个数据部分，我的姓名和年龄:
name = "Emmett"age = 22
我想打印一个字符串，在一个完整的字符串中告诉我的名字和年龄。作为一个例子，我只允许再初始化一个字符串类型。我该怎么做？在字符串定义中的第一个引号前添加一个f将允许我们使用括号{}输入代码中标识符的值，如下所示:
print(f"Hello, my name is {name} and I am { age }")Hello, my name is Emmett and I am 22
还有另一种方法可以做到这一点，就像这样:
print("I'm a {Ds} Named {nm}".format(Ds = "Data Scientist", nm="Bob"))I'm a Data Scientist Named Bob
当然，在很多情况下，这样的东西会被证明是有用的。我想到的一个例子当然是标签处理。我正好有一篇关于 Python 中标签处理的文章，如果你想了解更多关于这个主题的内容，你可以在这里阅读这篇文章:
结论
Python 确实有许多奇怪的地方，其中一些比其他的更有用。这些只是其中的一些，还有很多。我希望在你的软件之旅中，这些奇怪的小轨迹能派上用场！非常感谢您阅读我的文章。如果这篇文章中有一个部分对我来说很突出，那可能是两个装饰者，因为根据我的经验，我发现他们非常有用。我有一篇文章列出了一堆我认为有用的不同装饰者，我强烈推荐它们！你可以在这里读到:
</10-fabulous-python-decorators-ab674a732871> [## 10 个神话般的 Python 装饰者
towardsdatascience.com](/10-fabulous-python-decorators-ab674a732871)
非常感谢您阅读我的文章。祝你好运，利用这些奇怪的附加到他们的最大潜力！
学习数据科学的怪异技巧
卡片和打孔机是必不可少的，但你还需要一样东西
人造霜供图
数据科学和数据工程是怎么学的？
24 小时自学数据科学？
但是如果我在接下来的 24 小时内忘记了呢？
假人的数据科学？
嗯，我不是傻瓜，我不认为拼写正确。
数据科学食谱？
我不确定数据科学是否和制作威灵顿牛肉一模一样，但我不知道如何制作威灵顿牛肉，所以也许是这样的。
我可以看到这些简化的吸引力，但它们从来没有为我工作过，所以让我提供一个替代的简化，加上这个奇怪的技巧。
我的解决方案的第一部分需要大约一个小时。第二部分，这个奇怪的小把戏，花了 4 年时间，但是相信我，时间过得太快了，你会发誓只有 3 年半。
第一部分——卡片
首先，选择一组与你希望应用的数据科学和数据工程相关的相互关联的主题。这里有一组样本:
-线性代数
-统计
-机器学习
-数据(多种数据库类型)
-编程(Python 数据科学堆栈)
- DevOps (Kubernetes 等。)
在每个科目中，寻找一套书籍和课程——找到 10 个候选人，筛选出 4-6 个。
通过查看作者/讲师在 GitHub 上提供的任何配套资源，以及阅读评论，您通常应该能够形成对潜在学习资源的看法。
手里有一套学习资源(比方说六个科目的 40 种资源)，准备一叠 15 张空白卡片。在每张卡片上写下一个主题，以及你将用于该主题的 4 到 6 个资源，间隔开，以便在每个资源下有打孔的空间。
在一两张卡片上，写下“动态分配”——当这些卡片出现时，你可以做任何主题/资源。
接下来，考虑到你有足够的时间来完成这项工作，选择一个卡块时间——当它出现时你可以花在任何卡上的时间。我认为一小时是最少的，四小时是最多的。这不是关于完成一项任务需要多少时间，而是关于你有多少时间可以专注于一项工作。
对于每种资源，拿一张 5 x 6 的卡(这越来越贵了！)并写出章节号和标题。在每个你认为大致相当于你的卡块时间大小的地方画圈。因此，如果你认为你能在每个卡块时间内覆盖 10 页，那么一个 30 页的章节旁边会有三个圆圈。
现在让我们第一次浏览这叠 3x5 的卡片:
每当你坐下来“学习数据科学”时，你就会抓起那叠卡片，看看上面的内容。你从卡片上列出的四到六种资源中选择一种，并把自己投入到那种资源中去。您可以在整个卡阻塞时间使用相同的资源，或者中途切换到同一张卡上的另一个资源。
当卡块时间结束时，你拿起打孔机，在你自己使用的资源下打一个洞——每半个卡块时间打一个洞。
把卡片放在叠的底部。下次你坐下来“学习数据科学”时，你可以用叠上的任何一张卡片重复这个过程。
随着您在资源方面取得进展(例如，完成一章)，您可以拿起一叠 5x6 的资源卡，在您完成的章节/部分标题旁边的圆圈中打勾。进步！
第二部分——一个奇怪的把戏
在接下来的四年里，无论哪一个周期适合你的生活方式，无论你有多少时间，都要坚持完成这一堆卡片。可能有些时候你有或多或少的可用时间——没问题，你可以减少卡块时间的大小，或者调整你自己对每一轮需要多少日历时间的预期。
在这个系统中，你不能真的“落后”——如果你休息一段时间，在你的下一个机会，你拿起牌叠，把牌放在最上面。堆栈不在乎你错过几天或几周。
这样做，每四张一组，所以一旦你把全套卡片做了四次，就把它们钉在一起，放在一边。写下你的下一组卡片，根据前一组卡片的调整。添加额外的资源，删除那些你已经用尽或没有用的资源，调整顺序。
每几轮过后，自我测试一下，看看你是否有所进步。为此，我有两种首选方法。一个是在 StackExchange 这样的网站上回答问题。你可以用找到一个你能实际回答的重要问题所花的时间，以及写出你的答案(用代码)所花的时间来量化这一点。
第二种方法是从零开始创建一些小问题的解决方案。从零开始，你可以更容易地跟踪你的方法的复杂性，以及你的执行速度。
就是这样！
嗯，可能会有更多，但一旦你有了这个卡系统运行，它很容易补充，只要你不用完 3x5 的卡。
欢迎来到变量的第一版！
变量
亲爱的读者们:
感谢您加入我们的创刊号变量，这是我们改版后的每周时事通讯。很少有人能阅读我们在 TDS 上发布的所有内容(太多了！).然而，我们知道，你们中的许多人不想错过我们在那里展示的最好的东西。从今天开始，我们将在每周四向您发送一批新的必读书目:这些精选书目反映了 TDS 作者与社区分享的不可思议的作品。
准备好开始了吗？
悖论、洪水和韩国流行音乐
如果这个世界对你来说还不够混乱，那就等着看 Francesco Casalegno 的《三个统计学悖论的介绍》吧，这是每个数据科学家都应该知道的。当你的大脑出汗的时候，赶上约翰娜·阿佩尔关于层次隐马尔可夫模型的演练。(Johanna 称之为“轻量级”，但它确实写得很好，用户友好。)
多年来，声音的研究吸引了数据科学家的注意；这是一个需要清晰和耐心解释的广泛话题。 Ketan Doshi 正在进行的“音频深度学习变得简单”系列是一个开始的好地方(我们已经在计划中的五个中的第三部分)。当然，声音不仅仅是物理现象——它们是我们文化和个性的一部分，莫妮卡·因德拉万(Monica Indrawan)对流行音乐粉丝态度的分析显示了音乐和数据的交汇有多丰富。
每周我们都会在 TDS 上涵盖从高级理论和观点到实用信息的全部内容。本周也不例外。想积累一些有用的技能吗？贾斯汀·特里的关于多智能体深度强化学习的教程或者马修·李的初学者友好的混乱矩阵视觉指南怎么样？另一方面，如果你在市场上寻找一些扩展视野的读物，可以看看罗伯特·兰格的最新精选的前沿深度学习论文、乔希·波杜斯卡的人工智能进化概述或埃弗里·帕金森的数据影响人类基因组测序史。
人工智能和数据科学反映世界——并改变世界
在很多方面，人工智能仍然是一项新兴技术。在其他国家，它的历史已经很长很复杂了。在偏见的问题上尤其如此:如果人工智能反映了一个不完美的世界，我们怎么能指望它公*地工作？最*在 TDS 播客上，主持人 Jeremie Harris 采访了斯坦福大学教授 Margot Gerritsen 关于人工智能需要发生什么才是道德的——特别是当大型科技公司继续在开发人工智能产品和管理其使用的指导方针方面发挥巨大作用的时候。
在不断变化的数据科学世界中找到立足点
在过去一周左右的时间里，我们不仅推出了您目前正在阅读的时事通讯，还推出了作者聚焦系列，我们很高兴与您分享。(如果您刚刚迈出数据科学的第一步，就更是如此。是的，你来对地方了。)
我们的第一位特约作家是 NLP 专家 Sara A. Metwalli:一位多产的 TDS 撰稿人和编辑助理，一位东京的博士生，一位通过公开写作找到社区(并战胜了偶尔出现的骗子综合症)的讲故事者。正如萨拉自己所说，“写作给了我一个目标，一种被认可的感觉[……]它让我认识新的人，结交新的朋友。”
Sara 是数据科学家的一个很好的例子，她总是将自己的专业知识与周围的世界联系起来，但她并不孤单。要阅读更多汇集数据和更广泛的文化现象的帖子，请查看 TDS 编辑 Caitlin Kindig 撰写的关于数据科学和文化对象的广泛阅读列表。
最后
变量可能是新的(感谢您阅读它，并让我们知道如何改进)；不是的是我们对每一位读者和 TDS 社区的每一位成员的感谢，感谢他们让我们的工作成为可能，感谢他们支持成千上万的作者，他们慷慨地与世界分享他们的知识、观点和项目。我们喜欢你在这里。
祝你今天过得愉快，
TDS 编辑
我们策划主题的最新内容:
入门指南
实践教程
深潜
思想和理论
- 为什么是 0.9？走向深度学习中更好的动力策略
- 为什么神经网络具有激活功能
- 关于机器学习，爱因斯坦能教给我们什么
架构完善的框架—在云上实现可靠性
通过整合应用解决方案架构的可靠性框架来克服业务损失
介绍
企业依靠对数据和应用程序的可靠访问来满足客户的需求。如果最终用户无法使用关键系统，最终会导致企业收入损失。因此，云架构的 可靠性 方面使您能够结合架构考虑和设计来克服这些业务挑战。
这是一系列帖子，将涵盖云架构良好的框架，其他帖子的参考网址是:
【1】架构良好的框架—云上的性能效率 【2】架构良好的框架—云的安全方面
高可用性架构
高可用性(HA)服务意味着在不影响业务的情况下吸收波动、故障、负载和临时故障。这意味着根据业务需求和目标以及 SLA，服务始终是可用的和在线的。
建议仔细考虑解决方案架构，并确定由于其他一些原因而变得不可用的潜在组件。这些组件可以是虚拟机、数据库和网络组件，如 LBs 或网关。由于计划维护、故障或某些云区域/数据中心脱离电网，这些组件可能变得不可用。因此，您必须确定您的故障点在哪里以及如何出现，并确定如何在您的架构中解决这些故障点。
根据以下参数评估解决方案架构:
- SLA &应用程序的 SLO
SLA 是服务提供者和服务消费者之间的服务级别协议，服务提供者承诺并受法律约束遵守该协议。吞吐量、可用性和容量等指标用于衡量 SLA。违反 SLA 会给服务提供商带来严重的财务后果和处罚。
SLO，即服务级别目标，是用于衡量性能、可靠性或可用性的目标度量值。这些是为支持服务的团队和消费这些服务的客户设定的目标和期望。因此，SLO 确定是否满足总体 SLA。
2。应用程序的 HA
要从故障分析的角度评估应用程序焦点的 HA，请考虑单点故障，以及关键组件，如果这些组件不可达、配置错误或出现故障，将会产生重大影响。
为了处理这种情况，评估应用程序的每个组件，用提供 HA 的组件(例如 LBs)包括或替换它们，或者使组件冗余以克服由它们引起的单点故障。
3。依赖应用的 HA
如果您向客户承诺 99.9%的正常运行时间，但您的应用程序所依赖的服务只有 99%的正常运行时间，这可能会使您面临无法满足客户 SLA 的风险。因此，如果依赖关系离线，解决方案架构应该处理替代解决方案。一种替代方法是使用缓存或加载工作队列。
因此，在为高可用性进行架构设计时，您将希望了解您向客户承诺的 SLA。然后评估您的应用程序所具有的 HA 功能以及相关系统的 HA 功能和 SLA。
灾难恢复策略
灾难是一种高影响事件，持续时间比高可用性部署应用程序预期的要长，此类事件无法缓解，最终可能导致停机或数据丢失。此类事件可能是自然发生的—地震、洪水，也可能是黑客从外部造成的。
灾难恢复计划
灾难恢复计划是一个单独的文档，详细说明了从灾难导致的数据丢失和停机中恢复所需的程序。该计划还确定了谁负责指导这些程序。这是一个全面的用户指南，用于在灾难发生后恢复应用程序连接和数据。
灾难恢复计划应包括以下指导原则:—
- 执行风险分析，检查不同种类的灾难对应用程序的影响。你甚至可以考虑分析任何假设的场景。风险评估还应考虑无法承受无限制停机的应用程序组件。重要的是，计划负责人可以使用该计划对需要注意的事项以及如何对每个项目进行优先排序进行全面盘点。
- 考虑恢复目标 RPO 和 RTO，R 恢复点目标(RPO) 是可接受的数据丢失的最大持续时间，而 RTO 是可接受的停机时间的最大持续时间。指定 RPO 和 RTO 不应该只是简单地选择任意值，该决策会影响工作负载和成本效益权衡的灾难恢复设计。
- 恢复步骤的详细信息构成了灾难恢复计划的核心，它是在发生灾难时要执行的行动手册，应该包括有关管理的信息—备份、数据副本、部署、依赖关系和配置。
将灾难恢复纳入解决方案设计
发生灾难时，灾难恢复计划的执行不是一个自动过程，需要手动执行这些步骤。任何灾难恢复计划都应该考虑两个主要问题
- 如何恢复数据？
- 如何恢复应用程序及其进程？
数据恢复 由备份以及与业务 SLO/SLA 相关的复制策略、工具和技术组成。备份策略应该包括允许返回多少时间来获取数据的只读快照。复制计划使系统能够在发生灾难时*乎实时地进行故障转移。因此，这是维护高可用性和灾难恢复设计的关键组件。相对于业务 SLA 和应用程序 RPO 的成本效益分析& RTO 对于决定备份和复制策略非常重要。这些可能是—仅备份、主动-被动复制或主动-主动复制策略。
应用恢复 侧重于灾难事件后应用恢复的方法、流程和路径选择。目标是设计您的应用程序需求，使您能够将其恢复到工作状态。这包括— 故障转移到辅助区域。同样，这些策略是由业务或应用程序的 RTO 和 SLOs 需求驱动的。
测试灾难恢复计划
测试灾难恢复计划是灾难恢复的一个重要方面，以确保方向、说明和责任是清晰的和最新的。验证恢复结果、确定差距并迭代地改进以克服新的挑战是至关重要的。确保在你的测试中也包括你的监控系统。
备份策略
您的应用程序跨文件系统或数据库管理不同类型的不同重要性的数据。应用程序的备份要求应反映基于不同数据源的备份需求、外部要求，如数据保留法律和业务合规性。
- 企业能够承受多少数据丢失？
- 实现完全数据恢复需要多长时间？
- 企业希望数据备份保持可用多长时间？
同样，基于定义的 RPO 和 RTO 的成本效益分析对于制定备份和恢复策略至关重要。该战略由框架、工具、流程、程序和利益相关方组成，以应对所有可能的灾难恢复情形。
最后，与灾难恢复策略的验证和确认不同，备份策略应该经过彻底的测试，并反复改进以纠正潜在的差距。
备份和恢复策略是确保您的体系结构能够从数据丢失或损坏中恢复的重要部分。
结论
在这篇文章中，我们讨论了云架构良好的框架的可靠性支柱的一些关键原则。我们已经了解了如何考虑在应用程序的整个解决方案架构的核心中整合高可用性的需求。
我们讨论了灾难恢复，以及如何为您的应用程序定义 RPO 和 RTO。还了解测试您的恢复计划以确保它们符合业务要求的重要性。
最后，在您的恢复策略中涉及备份和恢复，以防止典型的数据丢失情况。
在本系列的后续文章中，我将重点介绍云架构良好的框架的其他支柱。
在 LinkedIn 上和我联系进一步讨论
参考
[1] 微软 Azure 架构良好的框架—可靠性
【2】AWS 架构良好—可靠性
【3】谷歌云的架构框架—可靠性
架构完善的框架—云的安全方面
假设违规是显而易见的，并使用零信任模型克服安全挑战
介绍
在这个关于云良好架构框架的第二个帖子中，我将详细讨论云良好架构框架的 安全支柱 。我将详细阐述安全架构的纵深防御概念，以及公共提供商提供的工具和流程示例，以保护基础设施、应用程序和数据。我还将简要介绍安全的身份管理、网络安全和基础设施安全。
这一系列的帖子将涵盖云架构良好的框架，其他帖子的参考 URL 是:
【1】架构良好的框架—云上的性能效率
纵深防御
它包括确定安全组件、技术和方法的关键概念的整体方法，以支持每一层的深度防御策略。这种策略使组织能够采用一系列流程和治理机制来减缓旨在获取对信息的未授权访问的攻击。如果攻击者破坏了一层保护，那么就有后续层来防止进一步暴露。因此，深度防御的目标是保护数据，防止未经授权的访问。
中央情报局原则
安全政策的底线是确保—
- 保密性 —处理最低特权原则，将信息访问权限限制在明确授权的个人。
- 完整性 —防止对信息进行未经授权的更改。
- 可用性 —确保信息对授权用户可用。
安全层
让我们帮助您通过安全实施层来保护数据信息，从而实现纵深防御。这种方法消除了对任何单一保护层的依赖，充当了减缓攻击的屏障，并提供了可以自动或手动操作的警报遥测
信息安全的纵深防御层(src:自定义映像)
下面是分层安全实施的总结:
表—映射分层安全控制(src:自定义映像)
身份管理
无论是内部交易还是在线交易，身份都是当今商业和社交交易不可或缺的一部分。云为应用程序提供了各种强大的功能:为应用程序用户提供单点登录，为公司网络外的所有登录强制执行 MFA(多因素身份验证)。
单点登录（single sign-on 的缩写）
使用 SSO，用户只需要记住一个 ID 和密码。对于用户来说，跨应用程序的访问被绑定到单个身份，因此，管理访问修改很简单；例如，如果用户离开组织；禁用其帐户。实施基于活动目录(AD) 的单点登录允许组织使用集中式身份提供商，实现身份基础设施的集中安全控制、报告、警报和管理。
多因素认证
多因素身份验证通过要求两个或更多元素进行完全身份验证，为您的身份提供了额外的安全性。这些元素分为三类:
- 你知道的事情:密码或安全问题的答案。
- 你有的东西:接收通知的手机应用。
- 某种生物特征，比如指纹。
即使攻击者拥有单个因素的身份验证信息，也可能不足以进行身份验证，因此，攻击者将能够使用这些凭证进行身份验证。
加密
加密是保护数据安全的最重要的武器，它是使数据不可读和不可用的过程。使用或读取数据需要使用密钥。您应该通过静态加密和传输加密来保护数据。
静态加密
数据存储在物理介质上，可以是磁盘、数据库或磁带，因此，无论采用何种存储机制，静态加密都可以确保数据对于任何没有密钥的未经身份验证的用户都是不可读的。
传输中的加密
通过互联网或任何其他不受信任的硬件从一个位置移动到另一个位置(例如，从客户端到服务器，反之亦然)的数据需要在传输过程中进行加密。组织可以通过在通过网络发送数据之前对数据进行加密，或者设置安全通道在两个系统之间传输未加密的数据，来处理安全传输。
数据分类
数据分类解决了组织识别关键 v/s 非关键数据的关键目的。它能够为关键、敏感、非关键和不敏感的数据对象建立数据治理的流程和策略。相应地，数据可以分为:受限、私有或公开。
各种因素会影响治理的数据分类，例如业务需求和法律遵从性(PCI、HIPAA、GDPR 等)。组织必须遵守的法规要求通常推动了大部分数据加密要求。
公共云支持加密
所有主要的公共云提供商，Azure、GCP 或 AWS，都支持不同级别的数据加密。它们都提供工具和机制来:
- 加密静态数据，即磁盘、blob 存储、文件共享
- 加密虚拟机，即虚拟硬盘
- 加密数据库，即透明数据加密(TDE)
- 使用 HSM(硬件安全模块)加密保险库机密
- 备份加密
网络安全性
网络是进入组织数据城堡的大门。因此，保护组织的网络免受攻击和未经授权的访问对于任何体系结构设计都非常重要。
网络安全可以从多个方面来看，例如:
- 保护应用和互联网之间的网络流量—
限制和消除来自互联网的攻击，有助于实现这一目标的方法很少—评估和通过安全防火墙的入站和出站通信，或者使用第 7 层 WAF 来保护边界以防止 XSS 或 SQL 注入，或者防止其他 OWASP 3.0 漏洞。
- 保护应用程序之间的网络流量:——
通过在虚拟网络中实现安全性和保护，将资源之间的通信限制在所需的范围内。通过启用允许和限制虚拟机或 PaaS 服务上运行的应用程序之间的通信的策略，可以使用网络安全组在通信的虚拟机之间实施第 3 层保护。
- 保护应用程序和用户之间的网络流量:——
内部部署和云虚拟网络之间的安全网络集成。虚拟专用网络(VPN)连接是在网络之间建立安全通信通道的常用方式。在您的内部网络和公共云之间建立专用的私有连接，可以通过连接提供商提供的私有连接将您的内部网络扩展到云中。
基础设施安全
云上的整体基础架构安全性对于组织的安全状况至关重要。所有公共云提供商都启用了防止对云资源进行未经授权的特权访问的机制，例如使用 IAM(身份和访问管理)服务限制对虚拟机和数据库的访问。
基于角色的访问控制(RBAC)机制有助于将角色定义为访问权限的集合，此后这些角色被分配给安全主体并随后映射到用户 & 组。用户和组是在和(活动目录)中定义的实体。
服务原则
这是为服务和云资源提供身份的一种方式。服务主体是服务或应用程序使用的身份，与任何其他身份一样，它可以被分配角色。
结论
在这篇文章中，我们讨论了云架构良好的框架的安全性支柱的一些关键原则。我试图通过实施分层方法和在每一层解决安全性问题来强调安全性在您的体系结构中的重要性。我还提到了身份管理和通过使用 SSO & MFA 实现安全应用程序的重要性。此外，我试图解释为什么加密通常是防止访问您的数据的最后一道防线。最后，我们研究了保护应用程序和互联网之间流量的方法。
在本系列的后续文章中，我将重点介绍云架构良好的框架的其他支柱。
接我上LinkedIn进一步讨论
参考
[1] 微软 Azure 架构良好的框架—安全性
【2】AWS 架构良好—安全性
【3】Google Cloud 的架构框架—安全性
基于机器学习和 Python 的测井数据异常检测
异常值的识别是机器学习工作流程中的一个重要步骤
威尔·梅尔斯在 Unsplash 上拍照
离群值是数据集中的异常点。它们是不符合数据集的正态或预期统计分布的点，可能由于多种原因而出现，例如传感器和测量误差、较差的数据采样技术以及意外事件。
在测井测量和岩石物理数据中，异常值可能由于被冲刷的钻孔、工具和传感器问题、罕见的地质特征以及数据采集过程中的问题而出现。必须在工作流程的早期识别和调查这些异常值，因为它们会导致机器学习模型的预测不准确。
下图中的例子(来自 McDonald，2021)说明了岩心孔隙度与岩心渗透率的关系。大多数数据点形成一个连贯的聚类，但是，由红色正方形标记的点位于该主要点组之外，因此可以被视为异常值。为了确认它是否确实是一个异常值，需要对报告和原始数据进行进一步的调查。
岩心孔隙度和渗透率数据中的异常值示例。图片来自麦当劳(2021)
识别异常值
有多种方法可以识别数据集中的异常值，其中一些方法涉及可视化技术，如散点图(如交会图)和箱线图，而其他方法则依赖于单变量统计方法(如 Z 分数)或甚至无监督的机器学习算法(如 K *邻)。
本文将介绍以下异常值检测方法:
- 基于领域知识的手动删除
- 箱线图和 IQR
- 使用卡尺曲线
- 自动异常检测
岩石物理机器学习系列
本文是正在进行的系列文章的第三部分，该系列文章着眼于从基本测井记录测量到使用机器学习进行岩石物理性质预测的数据集。
这些文章最初是在 SPWLA 2021 大会的一个机器学习和人工智能研讨会上作为交互式笔记本展示的。它们后来被扩展和更新以形成这些文章。该系列包括:
- 探索性数据分析:使用 Pandas、Matplotlib 和 Seaborn 探索测井数据
- 在岩石物理机器学习之前识别和处理缺失的测井数据
- 测井数据异常值检测— 本文
- 使用机器学习预测关键储层属性
** 尚未完成**
数据
2018 年，Equinor 向公共领域发布了 Volve 领域的全部内容，以促进研究和学习。发布的数据包括:
- 测井记录
- 岩石物理解释
- 报告(地质、完井、岩石物理、岩心等)
- 核心测量
- 地震数据
- 地质模型
- 还有更多…
Volve 油田位于北海挪威部分斯塔万格以西约 200 公里处。1993 年在侏罗纪时代的胡金地层中发现了碳氢化合物。石油生产始于 2008 年，持续了 8 年(是计划时间的两倍)，直到 2016 年停止生产。在油田寿命期内，总共生产了 63 个 MMBO，达到了 56000 桶/天的稳定产量
有关 Volve 字段和整个数据集的更多详细信息，请访问:https://www . equinor . com/en/what-we-do/Norwegian-continental-shelf-platforms/Volve . html
这些数据在 Equinor 开放数据许可证下获得许可。
用于分析的选定数据
Volve 数据集由 24 口井组成，包含各种测井数据和其他相关测量数据。对于这个小教程系列，我们将选择五口井。这些是:
- 9 月 15 日-F-1 A
- 9 月 15 日-F-1 B
- 9 月 15 日-F-1 C
- 2011 年 9 月 15 日至 11 日
- 15/9-F-11 B
从这些井中，选择了一套标准的测井测量(特征)。它们的名称、单位和描述详见下表。
Volve 油田选定井的标准测井测量和岩石物理推导曲线。
该系列笔记本的目标是预测三种常见的岩石物理测量值:孔隙度(PHIF)、含水饱和度(西南)和页岩体积(VSH)。传统上，这些是通过一些经验公式计算出来的。
导入库和数据
项目这一部分的第一步是导入我们正在使用的库和数据。
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
import scipydf = pd.read_csv('data/spwla_volve_data.csv')
最初看一下 pandas 的describe()功能，我们可以看到输出的数据范围(最小和最大)。
df.describe()
从 pandas 返回使用 df.describe()方法的测井测量数据帧。
使用手动方法处理异常值
去除极端电阻率
电阻率测量提供了电流通过地层的难易程度的指示。简而言之，如果地层含有盐水，那么电阻率将会很低，而如果存在石油或孔隙空间很小，电阻率将会很高。
电阻率测量可能受到多种方式的影响，例如附*的套管、工具/传感器问题，甚至是非常高电阻的地层。此外，根据进行测量的工具类型(感应、电磁传播、侧向测井),在高电阻率值时，读数的准确度可能会受到限制。
我们正在处理的数据集包含电磁传播电阻率测量值，我们将应用以下截止值。这些限制并不特定于任何工具，并且会根据所使用的数据和技术而变化。
- 瑞秋> 60 岁
- 狐狸精> 100
- RPCHEM > 100
- RPCLEM > 200
包含高于这些值的电阻率测量值的任何行都将被删除。如果我们只删除数据值，我们以后会有丢失数据的问题。
我们可以通过以下方式做到这一点:
df = df.loc[~((df.RACEHM > 60) | (df.RACELM > 100) | (df.RPCEHM > 100) | (df.RPCELM > 200)),:]df.describe()
当我们返回数据帧摘要时，我们可以看到这些电阻率曲线的测量次数从 27，845 次减少到 23，371 次
去除高电阻率值后，使用熊猫公司的 df.describe()方法返回的测井测量数据帧。
将电阻率对数曲线转换为正常值
由于电阻率曲线的数值范围很大，从几十欧姆·毫米到几千欧姆·毫米，并且通常呈现偏斜分布，因此最好通过取数值的对数底 10 (log10)将测量值转换为更正态的分布。
# Select all resistivity curves
res_curves = ['RACEHM', 'RACELM', 'RPCEHM', 'RPCELM']
# Loop through each curve and transform it
for res in res_curves:
df[f'{res}_l10'] = np.log10(df[res])
# Drop out the original columns
df.drop(columns=[res],inplace=True)
df.head()
获取电阻率测量值的 LOG10 后的数据帧。
从上表中，我们可以看到新列已经添加到数据帧中，旧列已经删除。
用箱线图识别异常值
箱线图是一种基于五个关键数字显示数据分布的图形和标准化方法:最小值、第一个四分位数(第 25 个百分位数)、中值(第二个四分位数)。/第 50 个百分位数)、第 3 个四分位数(第 75 个百分位数)和“最大值”。最小值和最大值分别定义为 Q1-1.5 * IQR 和 Q3 + 1.5 * IQR。任何超出这些限制的点都被称为异常值。
箱线图的图形描述，突出显示关键组成部分，包括中位数、四分位数、异常值和四分位数间距。作者创造的形象。
我的 YouTube 频道上的以下视频介绍了 boxplots 的背景以及如何用 python 生成它们。
调用箱线图最简单的方法是在数据帧上使用.plot(kind='box)。但是，正如您将看到的，这将在一个刻度上绘制所有的列，如果曲线之间有不同的值范围，例如从 0 到 1，以及 3000 到 5000，那么较小的测量值将更难区分。
df.plot(kind='box')
plt.show()
使用 pandas 生成的测井数据的简单箱线图。图片由作者提供。
为了使这些图更容易查看和理解，我们可以从 seaborn 库调用 boxplot，并遍历 dataframe 中的每一列。
一旦我们创建了函数，我们就可以创建一个列的列表，并“弹出”或删除包含字符串数据的井名列。然后，我们可以对数据帧中的每条测井曲线运行该函数。
突出异常值的测井数据箱线图，每个都有自己的数据范围。作者图片
从生成的图中，我们可以看到一些测量值可能包含异常值，这些异常值以绿色突出显示。仅基于箱线图，不容易判断这些点是否是真正的异常值。这就是我们需要依靠领域知识和其他方法的地方。
用交会图识别异常值
当处理多个变量时，我们可以使用交会图来识别潜在的异常值。这些包括绘制一个测井测量值与另一个测井测量值的对比图。第三次测井测量可用于为绘图添加颜色，以增强异常值的识别。
在本例中，我们将使用一个函数来绘制密度与中子孔隙度数据的散点图(交会图)，该散点图将由卡尺着色。
所有井的中子孔隙度(NPHI)与体积密度(RHOB)的交会图。颜色表示由卡尺(CALI)测量的钻孔尺寸。作者图片
我们可以在返回的图上看到，有几个点以橙色/红色突出显示，这表明如果我们假设位大小为 8.5 英寸，可能会发生冲刷。
这表明一些测量可能会受到井筒条件的影响。许多测井工具能够补偿一定程度的冲蚀和粗糙。
在本例中，为了说明处理受冲刷影响的坏数据点的过程，我们将删除任何超过 9 英寸的点。超出标准 0.5 英寸。任何小于 8.5 英寸的点也将被删除。
我们可以通过以下方式做到这一点:
df = df[(df['CALI'] >= 8.5) & (df['CALI'] <= 9)]
df.describe()
删除受冲刷影响的坏数据点后的数据帧摘要。图片由作者提供。
我们现在可以看到，我们已经将数据集进一步减少到 22，402 个深度样本，低于初始数据集中的 27，845 个。
使用无监督机器学习方法识别异常值
监督和非监督机器学习方法都可以用于识别测井数据和岩石物理数据中的异常值。出于本教程的目的，我们将关注一些无监督学习技术。
无监督的机器学习模型试图在不需要标记类别的情况下识别数据中的潜在关系。有许多无监督的机器学习方法可用于识别数据集中的异常/异常值。
在本文中，我们将了解三种常见的方法:
- 隔离林(IF)
- 一级 SVM (SVM)
- 本地异常因素(LOF)
隔离林
隔离林方法基于决策树。该方法选择一个特征/测量值，并在最小值和最大值之间随机分割数据。然后，这个过程沿着决策树继续下去，直到数据中所有可能的分裂都已完成。任何异常/异常值都将在流程的早期被分离出来，使其易于识别并与其余数据隔离。
下图展示了一个非常简单的例子，它使用了一个变量——体积密度(RHOB)。
测井数据隔离林示例。图片由作者提供。
一等 SVM
支持向量机是一种常见的分类机器学习工具，这意味着它们适合根据数据特征将数据分成不同的组。这是通过识别数据组之间的最大边际超*面来实现的，如下面简单的多类示例所示。
SVM 划分两类数据的示例。作者图片
在传统的 SVM 分类中，我们有不止一个类或相。然而，当我们只有一类数据时，我们可以使用所谓的一类 SVM。
在异常值检测的情况下，我们要做的是找到将数据点与原点分开的边界(见下图中的左图)。在这种情况下，我们将原点视为第二类。边界线外的任何点都被视为异常值。我们可以通过提供想要在数据集中检测的异常值的数量来控制线的位置。这个参数被称为污染水*。
但实际上，离群值可能存在于与主数据云相关的任何一侧。在这种情况下，我们希望找到一个非线性超*面，将异常值从主数据点中分离出来(参见下图中的右图)。我们可以使用 RBF 核(径向基函数核)来寻找点之间的非线性边界。
我们可以通过指定污染水*来控制允许识别多少异常值。如果我们只需要少量的异常值，我们可以将其设置为一个较小的数字。类似地，如果我们想要检测更多的异常值，我们可以为算法提供更多的污染值。
使用一次 SVM 识别测井数据中异常值的示例。图片作者。
局部异常因素
该方法评估给定点周围数据点的密度。与其他点相比密度较低的点将被视为异常值。有关此方法的更多信息，请查看此链接:
https://medium . com/ml point/local-outlier-factor-a-way-to-detect-outliers-DDE 335d 77 E1 a
异常值检测的局部异常值因子示例。图片来自https://sci kit-learn . org/stable/auto _ examples/neighbors/plot _ lof _ outlier _ detection . html
创建模型
我们可以使用下面的代码非常简单地创建模型，这是使用 scikit 学习库完成的。
返回每个所选模型的异常分数的数据框架，以及数据点是异常值(-1)还是异常值(1)。图片由作者提供。
我们现在可以使用密度-中子交会图来检查每个模型的性能。这是通过使用 Seaborn 的 FacetGrid 并将散点图映射到它来实现的，如下所示。
这将为每种方法和已识别的异常数据点的数量返回以下图。
看来综合框架方法提供了更好的结果，其次是 LOF，然后是 SVM。在前两种方法中，图右侧的大部分异常值都被移除。
对于每种方法，我们可以更详细地查看每口井的数据。
它返回下面的图。
测井数据异常值检测中不同异常值识别方法的比较。异常值以橙色突出显示，内标/优点以蓝色突出显示。图片由作者提供。
这让我们更好地了解如何使用所选方法在每口井中识别异常。我们可以看到，LOF 方法突出显示了数据点中心的许多点，这些点可能不是真正的异常值。这就是领域专家知识在确认这些点是否确实是异常值时发挥作用的地方。
在测井图上显示异常点
为了确定在哪里检测到异常值，我们可以使用下面的代码为每种方法和每口井生成简单的测井曲线。
在绘制数据之前，我们可以根据井名将数据帧分成多个数据帧，这样会更简单
一旦数据帧被井分割，我们就可以使用列表的索引号来访问所需的数据。
如果我们循环通过井名列表，我们可以得到索引号和相关的井名。
它返回:
Wellname Index
15/9-F-1 A 0
15/9-F-1 B 1
15/9-F-1 C 2
15/9-F-11 A 3
15/9-F-11 B 4
然后，我们可以用它来选择所需的井
用红色显示已识别异常的测井曲线。图片由作者提供。
上面的图向我们展示了常规测井图上存在异常/潜在异常值的地方。从 3700 到 3875 的区间是包含缺失值的区间。因为我们使用的是线图，所以对该间隙两侧的点进行插值以创建一条线。
突出显示的间隔需要用领域知识进行更详细的评估，但是出于本教程的目的，我们将使用隔离森林方法的结果。
导出结果
现在我们有了一个干净的数据集，我们可以将其导出到机器学习阶段所需的文件中。
为此，我们首先需要创建我们的临时数据帧，其中我们只使用被隔离林算法识别为内联者的数据。一旦这些点被删除，我们就可以创建我们的输出数据框架。
创建监督学习文件
为了准备监督学习文件，我们需要执行几个步骤。
训练、验证和测试分割
在导出数据之前，我们首先需要将数据分成训练、验证和测试数据集。
训练数据集用于训练模型，验证数据集用于调整模型参数，而测试数据集用于在看不见的数据上验证模型。应该注意的是，这些术语可以互换使用，可能会引起混淆。
测试数据分离
首先，我们将分离一口井(15/9-F11 B)用于我们的测试数据集，其余的井和数据将被分配给training_val_wells
训练和验证数据集
接下来，我们将我们的training_val_wells数据分成训练特征和目标特征(软件，PHIF & VSH)。在我们使用 Sklearn 进行预测的情况下，我们通常只指定一个特征进行预测。但是，对于这个示例，我们将设置三个目标特性。
当我们检查培训功能(X)时，我们可以看到我们拥有所有必需的列。
X.head()
剔除异常值后的选定训练特征。图片作者。
我们还可以检查目标的头部特征(y):
y.head()
剔除异常值后选择的目标特征。
列车测试分离
Sklearn 的 train_test_split 模块。对于本例，我们将使用 70%的训练规模，剩下 30%用于验证和调整模型。random_state已被设置为固定值，以允许本次研讨会产生可重复的结果。如果你想每次都随机化这些值，你可以删除这个方法输入。
需要注意的是，这里使用的方法叫做 train_test_split。但我们实际上正在做的是分离训练和验证数据集。
摘要
在本文中，我们介绍了什么是异常值，以及使用图和无监督学习算法识别异常值的方法。一旦识别出异常值，就可以将其移除。这是通过结合使用方法和领域专业知识来完成的。如果盲目地丢弃分数，你可能会丢弃有价值的数据。所以要经常检查你识别的异常值是不是真的异常值。
这本笔记本最初是为 2021 年 SPWLA 大会上的 SPWLA 机器学习研讨会发布的，后来进行了修改。
感谢阅读！
如果您觉得这篇文章很有用，请随时查看我的其他文章，这些文章从不同方面介绍了 Python 和测井数据。你也可以在 GitHub 找到我在这篇文章和其他文章中使用的代码。
如果你想联系我，你可以在LinkedIn或者我的 网站 找到我。
有兴趣了解更多关于 python 和测井数据或岩石物理学的知识吗？跟我上 中 。
如果你喜欢阅读这些教程，并想支持我作为一名作家和创作者，那么请考虑报名成为一名媒体成员。一个月 5 美元，你就可以无限制地阅读数千篇各种主题的文章。如果您使用 我的链接 ，注册，我将为您赚取一小笔佣金，无需额外费用！
https://andymcdonaldgeo.medium.com/membership
我们正面临一场虚假的科学危机，而人工智能让它变得更糟
期刊撤回了越来越多的论文，因为这些论文并非出自他们声称的作者之手
《科学》杂志上低质量(和无质量)的论文数量正在增加。作者图片
然后，研究人员将任何重要的发现写在论文中，并提交给可能的出版物。在同行评审过程中，其他科学家检查研究是否合理，然后期刊发表论文供公众阅读。
因此，你可能有理由相信发表的论文相当可靠，符合高质量标准。你可能会想到在同行评审中被忽略的小错误，但不会有大的失误。毕竟是科学啊！
不过，你对这个的期望是错误的。真正的好科学确实存在，但也有令人担忧的大量虚假研究。在过去的几年里，它的数量以闪电般的速度增长，正如论文撤回数量的暴涨所证明的。
伪科学
目前的一些做法有可能破坏科学研究的合法性。它们包括虚构的作者，增加与论文无关的科学家作为合著者，甚至更邪恶的做法，如用低质量的人工智能写作垃圾来淹没期刊。
这个过程类似于杂货店的召回。如果以前销售的产品由于某种原因是坏的或危险的，商店可能会决定召回它，并要求所有顾客不要使用它。类似地，一份杂志可以回忆起一篇发表的论文，事后证明是伪造的。
当然，有时论文被收回是因为作者在他们的研究中犯了一个诚实的错误。然而，在超过一半的情况下，这是因为学术不端或欺诈。直到十年前，这种行为或多或少局限于研究人员伪造实验数据或歪曲结果以支持他们的理论。然而，技术变得越复杂，事情就变得越复杂。
一个简单的解决办法是忽略伪造的文件。然而，问题是它们通常很难识别。此外，一旦一篇论文从出版物中被撤下，整个期刊都会有点失色。如果这种情况经常发生，公众对科学的整体信心就会下降。因此，科学界作为一个整体需要认真对待这个问题。
卡米尔·诺斯
这个问题有些是模拟的。Camille Noû与人工智能没有太多关系，但它仍然值得一提。诺思出生于 2020 年 3 月，已经在天体物理学、计算机科学和生物学等不同领域合作撰写了 180 多篇论文
我说“它”是因为诺斯不是一个真实的人；更确切地说，它是由法国研究倡导组织 RogueESR 发明的人工制品。它带有中性的法语名字 Camille，并融合了古希腊词“νοῦς”，意思是理性或认知，以及法语词“nous”，意思是“我们”
nos 是为了回应一项备受批评的新法(来源于法语)而创建的，旨在重组法国的学术研究。尽管该法律的目的是让研究更好，但它的批评者认为科学家的工作将会不公*地不稳定，并根据其要求依赖外部资金。特别是，科学家获得的资助必须依赖于他们自己以前的成就，尽管研究通常是社区的努力。
为了让这种担忧可见，许多研究人员选择将诺思作为合著者。然而，负责检查这些论文的期刊和同行评审员并不总是被告知，诺斯并不是一个真实的人。
尽管到目前为止，所有这些论文的研究部分似乎都是合法的，但人们可以如此容易地添加一位甚至没有身份证的合著者，这令人担忧。尽管强调诺思等作家的共同努力是一个光荣的目标，但在当今时代凭空创造科学家的想法非常令人担忧。
社区的努力需要得到认可，但目前我们没有这样做的制度。作者图片
在不属于作者的地方添加作者
然而，突出同行评议系统和学术界的缺陷并不是这个问题表现的唯一地方。尤其是在关于 AI 的篇论文中，假冒合著的案例越来越多。这种欺骗包括在他们不知情或未同意的情况下，将一位知名科学家添加为合著者的做法。另一种方法是添加一个虚构的合著者，有点像 Camille Noû，但目的是假装国际合作或更广泛的科学讨论。
除了给人一种国际合作的错觉之外，添加具有良好资质的假作者可能有助于提高论文的可信度。许多科学家在阅读论文或在工作中引用论文之前，会在谷歌上搜索所有作者的名字。但是，看到一位来自知名机构的合著者可能会让他们更仔细地审视一篇论文，特别是如果它还没有经过同行评议的话。然后，一个机构的声望就可以像可信度的代理一样发挥作用，直到耗时数月的同行评审完成。
目前还不清楚有多少假作者被添加进来。首先，一些科学家可能会选择忽略他们的名字出现在他们没有写的论文上的事实，特别是当有问题的论文的内容通常并不可怕(尽管并不伟大)并且法律行动可能会过于昂贵和耗时。此外，在发表论文之前，目前还没有标准的方法来验证科学家的身份。这就给了假作者一张免费通行证。
所有这些问题表明某种类型的身份验证过程的必要性。目前还没有正式的协议，这很遗憾。在这个时代，每家银行都可以在线验证你的身份，并将其与你网络摄像头上的人脸进行匹配，科学甚至无法保护其最有价值的贡献者免受骗子的侵害。
当它是关于写科学论文的时候，一个好的古老的人类头脑的道路今天仍然比最好的人工智能更好。作者图片
算法正在产生糟糕的文章
1994 年，物理学家艾伦·索卡尔(Alan Sokal)想写一篇关于人文学科相关主题的论文，并将其提交给一家期刊。它被接受了，尽管没有人，包括作者本人，明白他在说什么。这不仅是荒谬的，而且也显示了同行评审者有多懒。在这种情况下，他们实际上接受了本质上是一篇胡言乱语的文章。
同样，在 2005 年，三个计算机科学专业的学生决定开发 SCIgen，作为对研究界的一个恶作剧。这个程序炮制出完全无意义的论文，里面有图表、数字和引文，夹杂着大量计算机科学的术语。他们的一篇胡言乱语的论文被当时的一个会议接受了。更有甚者，2013 年，120 篇论文在发现是 SCIgen 写的后，被各个出版社撤回。2015 年，该网站每年仍有 60 万的页面访问量。
然而不幸的是，伪造文件不仅仅是恶作剧。整个公司通过撰写胡言乱语的论文并将其提交给掠夺性期刊来赚钱，这些期刊几乎不拒绝任何东西，因为它们收取出版费。这些公司也被称为造纸厂，他们的方法越来越复杂。尽管欺诈检测也越来越好，但专家们有理由担心，这些肆无忌惮的行为者已经磨练了针对低质量期刊的技能，接下来可能会试图淹没真正的期刊。这可能导致造纸厂和不想发表伪作的期刊之间的军备竞赛。
当然，另一个问题即将出现:人类还会是唯一一个写研究论文的人吗？在 10 年或 20 年内，人工智能驱动的算法是否能够自动筛选大量文献，并将它们的结论放在一篇达到最高研究标准的新论文中？我们如何去信任这些算法或它们的创造者？
然而，今天，我们正在处理一个更愚蠢的问题:我们如何识别由相对不复杂的算法撰写的、没有产生任何合理内容的论文？我们如何应对它们？除了志愿者的努力和迫使欺诈作者撤回论文，科学界对这个问题的答案少得惊人。
大多数期刊迫切需要更新我们的安全系统来追踪假论文。作者图片
反对伪科学
大多数声誉不佳的期刊至少有一个基本的电子邮件验证程序，供希望提交论文的研究人员使用。这里的比如说，就是《T2》科学的验证系统。尽管如此，建立一个假的电子邮件地址，并通过它的过程是相当容易的。这种类型的欺诈仍然经常发生，正如每年从权威期刊撤回的论文数量所示。所以，我们需要更强大的系统。
验证科学家身份的一个好方法是或。基本上，通过这个系统，每个研究人员都可以获得一个唯一的标识符，然后自动链接到他们的跟踪记录。在期刊的同行评审和出版过程中使用 ORCID 将使伪造身份或在未经其他研究人员知情或同意的情况下使用他们的证书变得更加困难。虽然这是一个很好的倡议，但还没有主要期刊强制所有作者使用 ORCID 或其他地方的标识符。在我看来，这是一种耻辱，而这是很容易解决的。
最后，人工智能本身可能在这场斗争中有用。一些期刊正在部署 AI 模型检测虚假投稿。然而，到目前为止，各种期刊还不能就一个共同的标准达成一致。因此，缺乏资源或专业知识的期刊无法像排名较高的出版物那样应用相同的质量标准。
这扩大了高层次和低层次期刊之间的差距，对我来说，这清楚地证明了所有期刊应该团结起来，找到一种方法来共享欺诈检测的资源。当然，高水*的期刊可能会在短期内从缺乏竞争中获利。然而，从长远来看，拥有更多低标准的期刊可能会降低人们对科学出版的整体信心。
然而，这并不是说研究人员和科学期刊坐以待毙，而不是去追踪造假的作者。事实上，个体出版物正在做大量的工作来追查假论文。但是，如果一些期刊有办法，而另一些没有，那么出版物就不是在一个公*的竞技场上运作。此外，骗子总是能够用他们的假论文瞄准一些资金不足的期刊。期刊需要集体行动，找到追踪造纸厂的方法，并核实所有作者的身份。
超越科学:假新闻越来越造假
如果你认为虚假内容是仅限于科学的问题，那你就错了。仅仅几年前，在特朗普时代的鼎盛时期，“假新闻”是当时的流行语。自那以后，产生内容来影响公众舆论的方法变得更加复杂，它们与那些伪造的科学论文非常相似。
例如，假记者显然是各种保守媒体专栏的作者。他们的头像是用人工智能算法生成的。他们的 LinkedIn 和 Twitter 账户完全是假的，目前还不清楚谁是这些文章的真正幕后黑手。
还有几个假新闻 文章 生成器让制造假新闻头条变得轻而易举。虽然你可能无法用这样的内容说服一个有经验的事实审查员，但是你可能能够用它给普通的脸书用户留下深刻的印象，足以说服他们分享这篇文章。
这就是为什么我自己倾向于只相信来自已有来源的新闻和科学，或者我可以反复检查以确定其真实性的内容。我完全不考虑其他来源，因为我知道大部分来源从“一点点错误”到“完全捏造”
几年前我没有这种态度。我周围的人也没有。对新闻的信任已经急剧下降，我不知道我们如何才能恢复它。现在，已经发生在新闻上的事情正在发生在科学上。很难发现世界上正在发生的事情的真相，这已经够糟糕了。但是，如果人类知识的基础遭到侵蚀，那将是一场更大的灾难。
虽然围绕假新闻的争论自 2020 年大选以来已经*息，但远未结束。由于伪造内容的工具仍在变得越来越复杂，我相信在未来的几年里，这种对话将变得更加活跃。希望到那时，我们能就如何打击虚假内容和虚假研究达成共识。
本文原载于 建于 。
数据科学硕士能(和不能)为你做什么
最*毕业并找到一份数据工程师的工作后，我对数据科学研究生院的想法。
图片由德莱克·库克 | Unsplash 拍摄
我经过大约两年的研究生院实践工作，最*获得了数据科学硕士学位。鉴于人们通过 LinkedIn 和我过去的媒体帖子产生了一些兴趣，我认为阅读我对该决定的追溯评估以及我从这次经历中获得的最大收获可能会对一些人有所帮助。我还想讨论一下获得硕士学位你应该得到什么，不应该得到什么。
如果你读过标题，翻了翻白眼，心想，“又来了，又是一个人试图让我相信，要在这个行业走得更远，正规教育是必要的”，我要先说，我不是来试图说服任何人走这条路的。完成硕士课程的决定对我来说是正确的，但不是对每个人都是正确的！
我下面概述的道路旨在帮助那些可能与我几年前处境相同的人。对于那些正在考虑去数据科学研究生院学习的人来说，我希望这篇文章对你有所帮助。此外，如果你想一对一地谈谈你独特的情况或处境，我很乐意与你交谈。你可以在我的网站上找到我的联系方式:www.zach-alexander.com。
如果你想跳过我的个人经历，直接看文章的最后部分，它概述了一些关键问题，可能对你权衡决定有所帮助——请随意！
我的旅程
我现在在哪里
我今天坐在这里，距离提交我的最后一个顶点项目和完成我在纽约城市大学专业研究学院的硕士学位的全部 30 个学分还有三天。我明天就正式毕业了——这种感觉太棒了。最重要的是，六个月前，我在我的组织中成为了一名全职数据工程师。首先，我一直在帮助领导构建该组织的第一个基于云的数据仓库，协调数据管道，并自动化我们的许多日常服务。最终，我们计划利用我们的新基础设施，通过设置我们的系统来更好地兼容机器学习和数据科学工作，从而真正提高我们的分析输出。我对这份工作感到非常兴奋，因为有机会在两年前我觉得自己的职业生涯有点停滞不前时就想找到的位置上工作。那么这是怎么发生的呢？嗯，这很大程度上归功于我去了研究生院，花时间做了一些项目，这些项目给了我走上这条路所需的技能。
达成决定
对我来说，去读研究生的想法一直在我的脑海深处——尤其是当我快 30 岁的时候。那时，我已经毕业六年了，感觉自己获得了很多宝贵的工作经验。然而，我仍然在犹豫我想在哪个工作领域更上一层楼。我有很多工作兴趣——数据分析、研究、计算机编程、统计学、数学、网络开发等。然而，做出最终致力于一个项目和一个主题的决定，是我整个旅程中最艰难的部分之一。
在 2017 年和 2018 年，我一直在下班时间和周末潜入 web 开发项目。我是一个很好的自学者，最擅长的是自己动手做东西，解决出现的问题，在网上和同龄人中寻找资源来帮助提高我的理解。通过这种方法，我学会了如何用 JavaScript 框架创建简单的网站，轻松地使用命令行，并获得了如何设置前端和后端网站基础设施的基本知识。我甚至参加了一个初级网站开发人员的面试，但表现不够好，没有得到工作机会。我和一位非常亲切的朋友一起做了一些合作伙伴编码，他教了我函数式和面向对象编程的基础，并让许多其他朋友提供了关于不同职业道路和研究生课程的建议和见解。通过这次经历，我开始缩小潜在研究生院项目的不同选择范围。
到 2019 年初，我在工作中感到非常焦虑。我知道，通过最终决定读研，这个决定将有助于提供一些方向，并让我对可能的职业道路有一个新的视角。那时，我刚搬到纽约，在那里我找到了一份工作，在我现在工作的非营利组织做研究和数据助理。我通过以前的一些工作经验获得了这份工作，我对 SQL 有很好的理解，并断断续续地与 R 一起工作，但我一直在努力寻找一条前进的道路，让我能够在工作中追求更令人兴奋的分析和问题。这种感觉在过去的三四年里一直存在，我觉得在我目前作为一名数据分析师的角色中，我最终能做的事情已经达到了上限。
钻研数据科学
到那时，我已经读了很多关于数据科学，以及不断发展的利用机器学习算法和大数据更好地指导实践的领域。我仍然不确定我想把这些放在哪里，我决定研究一些研究生院的项目，看看哪些课题最让我感兴趣。两个数据科学项目尤其引人注目，两个项目都位于纽约市，一个是完全远程的，另一个是完全面对面的。此外，其中一所学校要求入学考试。因此，在申请之前，我参加了一个特殊的为期 6 周的 Coursera 线性代数课程，以及其他一些免费的 SQL 和微积分复习课程，以便通过入学考试。幸运的是，我在大学生物专业时学了大量的数学课程，这很有帮助！
最终，我被这两个项目录取了，但考虑到我对自学的强烈爱好和全职工作的要求，我决定继续攻读完全在线的项目。
研究生院核心班
全职工作，每学期两门课程对我来说似乎是最容易管理的设置，我觉得我有足够的时间深入每门课程，而且能够在两年内完成这个项目。我在纽约市立大学 SPS 选择的项目有一个在线时间表，这使我的工作和生活时间表变得易于管理(尽管两年来我的周末和一些工作日晚上都被预订了)。
该计划的核心课程集中在几个不同的方面:
- 数据采集和管理 —利用 SQL 和 R 从许多不同的来源(如文本文件、pdf、表格、json 等)提取和整理数据。).这个课程很重 R，并且很好地介绍了如何利用软件进行基本分析、读取文件、连接数据库和使用正则表达式。 我这个课程的期末项目可以在这里找到 。
- 数据分析的统计和概率 —只在 R 中工作，运行基本的统计分析，但也钻研贝叶斯统计和高斯方法。这门课非常有助于我回顾大学期间所学的知识，也是我在接下来几个学期中密切合作的基础。
- 计算数学基础 —一门更传统的数学课，侧重于线性代数、微积分、概率、统计理论，并在 R 中运行许多这些方法(通过构建自己的函数)。这门课对我来说是最具挑战性的课程之一，但它让我更好地了解了我将运行的许多未来算法是如何在幕后工作的。
- 高级编程技术——这是我们第一次单独用 Python 编写的课程。大多数作业都围绕 Python 基础，但是到最后变得越来越有挑战性，要求最终项目利用面向对象的编程技术、递归和其他更高级的编程方法。
- 商业分析和数据挖掘——有些人在课程开始时上过这门课，但我一直等到倒数第二学期才上这门课。它主要是在 R 中，并与回归和线性分析一起工作。
- 知识和可视化分析 —该课程深入研究了数据可视化，并介绍了许多可视化库中的工作和项目。我们用 R (Shiny)、Python (Plotly)工作，最终用 JavaScript (D3.js)实现了可视化。鉴于我之前对 JavaScript 的了解，我在这门课中度过了一段美好的时光— 我在这门课的最终项目可以在这里找到 。
选修课
- 推荐系统(Recommender Systems)——这是迄今为止我上过的最具挑战性的一门课，但也是我收获最大的一门课。 它实际上帮我找到了一份数据工程师的工作！ 我们了解了不同类型的推荐系统，致力于用 R 和 Python 构建我们自己的引擎，我们甚至被要求完成一个使用 PySpark 和/或 Hadoop 等大数据框架的最终项目。所有这些都是在 7 周内完成的，因为这是一个夏季课程！ 我的最终项目可以在这里找到 。
- Web Analytics —深入研究图论，利用社交媒体数据寻找网络之间的联系。这是一个非常有趣的课程，可以学习更多关于图形如何工作的知识。鉴于夏季学期的缩短(也只有 7 周)，我觉得我们只能对这门课略知皮毛。
- 机器学习和大数据 —这在“大数据”方面不太重要，主要集中在机器学习算法上。我们谈到了许多主要的监督和非监督学习方法。这是一个很好的课程，可以询问何时使用某些算法，如何正确评估模型输出，并将我的数据科学技能提升到一个新的水*。
顶点工程
- 构建一个太阳能计算器 并作为一个全功能的应用程序进行部署——我计划写一篇关于这个项目的单独文章，但它主要包含了过去两年的许多经验。用 Python、JavaScript 和 Postgresql 将非常复杂的模型模拟集成到复杂的工程基础设施中是一个独特的挑战；完全部署在 Google Firebase 和 Heroku 上(前端和后端部署)。 最终应用可以在这里找到。
随着我的旅程完整地呈现在你面前，我确实想简要地看看硕士学位能为你做和不能为你做的一些事情。
硕士学位能做的五件关键事情
- 我的学位让我对自己作为数据工程师的新工作更有信心。通过深入了解我们希望对数据进行的数据科学算法和分析的许多方面，我可以批判性地思考某些基础设施决策、软件和结构，这些将有助于优化我们未来的工作流。
- 我遇到了一大群数据科学家！尽管这个项目完全是远程的，但我一直通过 Slack 和 Google Hangouts 与他人交流。这是一个很好的方式，可以向他人学习，与拥有不同技能和背景的同龄人合作，并最终看到自己因为这些日常互动而提高。
- 这让我在工作中更加可信——我现在对我的组织中的数据*台和系统有了更好的了解，并且正在帮助我们为 700 多名员工构建云基础架构。如果没有我的学位，我将更难主张被放在这个位置上，并被信任做出这些将影响许多人的决定。
- 我从我构建的投资组合项目中获益良多。大多数学期都需要一个大型的期末项目，我真的要确保我的项目可以展示给未来的雇主。通过采取这一额外的步骤，我现在有了一个很好的项目集可以依靠，并真正深入到我在构建它们时学到的内容中——这对任何未来的面试或项目都有帮助。
- 我的项目和作业让我对 R 和 Python 有了深入的了解。我现在非常有信心，如果我必须使用这两种语言中的任何一种(我现在主要使用 Python，但是在程序的早期也使用了大量的 R)，我将能够在任何需要我做的项目中使用它。
硕士学位不会做的五件关键事情
- 虽然我很幸运，每天都能在工作中利用我的学位，但获得硕士学位并不总是能保证你能在数据科学或数据工程领域找到工作。很明显，我确定，但肯定需要沟通。
- 仅仅获得一个学位，并不能自动获得工作所需的所有必要的数据科学技能。其实拿到学位真的只是一个开始。这对于我来说仍然是正确的。我每天都在学习关于工程最佳实践的新信息。这个领域是不断发展的，所以你不会一毕业就成为领域专家。
- 很多时候，你的硕士学位不会让你为这些角色的未来面试做好准备。你可能需要真正的实践，做编码挑战，并彻底研究你申请的公司/组织。研究生院可以给你很多有助于面试对话的基础知识，但每个公司/组织都有独特的挑战，他们希望通过聘用数据科学家或工程师来解决这些挑战。
- 在你的时间里获得学位绝不是一件容易的事情。在将*两年的时间里，我几乎每个周末都在研究和做项目，所以承担这个任务，即使是一个完全在线的项目，也会消耗掉你很多精力。如果你试图同时*衡工作和读研，这不会让你有很多时间专注于工作的其他部分。
- 硕士学位不会宽恕你的银行账户。不能保证你的投资最终会马上得到回报。幸运的是，相对于大多数人来说，我完成的这个项目是非常便宜的。然而，如果你希望进入一个“顶级”数据科学项目，这种类型的财务承诺是值得考虑的！如果有人选择了一个更实惠的选择，我会说，你不一定需要去一所“顶级”学校才能获得一份出色的数据科学/工程工作！有成千上万的公司和非营利组织在寻找这种技能——他们不需要“精英”学校的学位。
为考虑数据科学研究生院的人准备的几个指导性问题
最后，我想我应该为那些正在权衡不同研究生院选择的人准备一系列问题。基于你自己的生活环境，有几件事会极大地影响你的决定。
- 你的学习风格是什么——你怎样学得最好？
2。你是打算一边做全职还是兼职一边读研？
根据你能投入的时间量来权衡项目|作者图片
3。你的预算——面对现实吧，读研可能很贵。你能在教育上实际花费多少？
基于成本的称重程序|作者图片
结论
我的临别赠言是，获得数据科学硕士学位的价值最终将取决于你投入的努力和时间(如果你最终追求它的话)——我知道这是陈词滥调，但却是事实。如果你决定不读正式的研究生课程，你仍然可以找到一份数据科学/工程的工作！对于那些对更正规的途径不感兴趣的人来说，通过 MOOCs、在线课程和免费内容工作绝对是一个选择。
最后，对于那些想从事数据科学职业的人来说，做最适合你的事情，但最终要找到一种方式，让你花时间完全沉浸在这个主题中，与帮助指导你的同行和专业人士一起工作，并找到挑战你对工作的承诺的方法！
什么是 TFRecord 以及如何创建它
如何使用 TFRecord 格式有效地训练神经网络
简·安东宁·科拉尔在 Unsplash 上拍摄的照片
TensorFlow 是当今最流行的深度学习框架之一。有些人相信它，有些人认为它是一个伟大但臃肿的工具，一个承载着沉重遗留代码负担的工具。
就个人而言，我更喜欢使用 PyTorch，但在我看来，每个机器学习(ML)研究人员或工程师都应该知道如何找到进入 TensorFlow 知识库的方法。该领域有很多创新，几乎一半是用 TensorFlow 表达的。
然而，在很大程度上，TensorFlow 是一个固执己见的框架。它最出名的僵硬 API 之一与数据处理和加载有关。
在这个故事中，我们转向基础，看看 TFRecords，它们是什么，如何生成它们，以及如何有效地使用它们来训练神经网络。
Learning Rate 是一份时事通讯，面向那些对 AI 和 MLOps 世界感到好奇的人。你会在每周五收到我关于最新人工智能新闻和文章的更新和想法。订阅这里！
TFRecords:什么和为什么
TFRecord 格式是 Tensorflow 自己的二进制存储格式。它使用协议缓冲区，这是一个跨*台、跨语言的库，用于结构化数据的高效序列化。使用 TFRecord 格式有许多优点:
- 效率:TF record 格式的数据可以比原始数据占用更少的空间。
- 快速 I/O : TensorFlow 可以通过并行 I/O 操作读取 TFRecord 格式的数据。当你使用 GPU 或 TPU 设备时，这非常有用。
- 自包含文件 : TFRecords 是自包含的，这意味着您可以在一个文件中拥有您需要的一切，数据及其元数据，并且格式允许您使用对您来说重要的任何内容。
TFRecords:如何
我们看到使用 TFRecords 代替原始数据格式有几个优点。然而，天下没有免费的午餐。您必须完成这项工作，并将原始数据转换为 TFRecords。
为了实现这一点，您需要主要使用两个类:
[tf.train.Example](https://www.tensorflow.org/api_docs/python/tf/train/Example)或[tf.train.SequenceExample](https://www.tensorflow.org/api_docs/python/tf/train/SequenceExample)取决于您的数据[tf.train.Feature](https://www.tensorflow.org/api_docs/python/tf/train/Feature)
此外，您需要以下列格式之一来表示数据集的要素:
[tf.train.BytesList](https://www.tensorflow.org/api_docs/python/tf/train/BytesList)[tf.train.FloatList](https://www.tensorflow.org/api_docs/python/tf/train/FloatList)[tf.train.Int64List](https://www.tensorflow.org/api_docs/python/tf/train/Int64List)
为此，让我们看看如何使用一个简单的示例来实现这一点，由 Dimitre Oliveira 提供:我们将把 COCO2017 数据集转换成 TFRecords。
简单的例子
COCO2017 数据集有两个子集:图像和注释元数据。它用于为执行对象检测、关键点检测、全景分割或解决密集任务的模型建立基线。
图像以 JPG 格式存储，注释数据存储为普通的 JSON 文件，包含以下属性:
id: int,
image_id: int,
category_id: int,
segmentation: RLE or [polygon], object segmentation mask
bbox: [x,y,width,height], object bounding box coordinates
area: float, area of the bounding box
iscrowd: 0 or 1, is single object or a collection
例如，特定图像的元数据可能是这样的:
{
"area": 367.89710000000014,
"bbox": [
265.67,
222.31,
26.48,
14.71
],
"category_id": 72,
"id": 34096,
"image_id": 525083,
"iscrowd": 0,
"segmentation": [
[
267.51,
222.31,
292.15,
222.31,
291.05,
237.02,
265.67,
237.02
]
]
}
我们可以看到，要转换这个数据集，我们需要使用 TFRecord API 提供的几乎所有类型。我们需要转换整数、浮点数、浮点数列表和图像。让我们把手弄脏吧。
将数据转换为 TFRecords
假设我们已经将数据加载到一个名为annotations的变量中，让我们指定每个 TFRecord 上的样本数，以及我们将创建多少个这样的文件:
现在，我们准备创建我们的助手函数，将每个特性转换成其等效的tf.train.Feature格式:
接下来，让我们再添加两个函数:一个使用上面的实用程序创建一个tf.train.Example对象，另一个解析它:
现在，剩下的就是读取数据并将它的点转换成 TFRecords:
在您的工作区中，您应该准备好了九个.tfrec文件。
训练简单的分类器
现在我们被读取来训练任何我们想要的模型，使用我们创建的.tfrec文件和 Keras。
首先，让我们创建一个助手函数，它将从我们之前创建的 TFrecords 生成数据集:
现在，我们准备好享受我们的工作成果，并训练一个简单的 Keras 分类器:
仅此而已！要端到端地运行整个示例，您可以使用由迪米特里·奥利维拉在 colab 上的这个优秀的笔记本。
结论
TensorFlow 是当今最流行的深度学习框架之一。每个机器学习(ML)研究人员或工程师都应该知道如何在 TensorFlow 存储库中导航。这个领域有很多创新，很多都是用 TensorFlow 表达的。
在这个故事中，我们看到了 TFRecord 格式，为什么应该使用它，以及如何使用。然后，我们使用了 Dimitre Oliveira 提供的一个极好的例子来练习我们的知识。
下次使用 Keras 训练神经网络时，考虑利用 TFRecords 的能力，尤其是如果您计划使用 TPUs 的话！
关于作者
我叫 Dimitris Poulopoulos ，我是一名为 Arrikto 工作的机器学习工程师。我曾为欧洲委员会、欧盟统计局、国际货币基金组织、欧洲央行、经合组织和宜家等主要客户设计和实施过人工智能和软件解决方案。
如果你有兴趣阅读更多关于机器学习、深度学习、数据科学和数据操作的帖子，请关注我的 Medium 、 LinkedIn 或 Twitter 上的 @james2pl 。
所表达的观点仅代表我个人，并不代表我的雇主的观点或意见。
关于数据可视化，苹果的天气应用能教会我们什么
你可以在下一次可视化、仪表板或演示中应用的三个经验
作者图片
我的工作是思考我们如何交流数据和分析，所以我不时会发现自己很羡慕别人是如何构建他们的产品和可视化的。
我最*用最新的 iOS 更新了我的手机，其中一个更新特别吸引我的是新的天气应用程序。我注意到苹果引入了新的可视化和提示来帮助人们理解屏幕上的内容，并且有一些有用的提示我们可以应用到我们自己的交流和可视化中。
下面是我们如何在数据产品中使用他们的设计的三个建议。
1.找到你的数据流
请考虑一下您与天气应用程序最频繁的交互。*均来说，我猜你现在最常去查看温度。下一个最常见的是看天气预报——今天会下雨吗？今晚我户外活动的温度是多少？你的第三大频率可能是查看即将到来的一天或本周晚些时候的天气。
现在，看看与上述内容相关的应用程序流程。从上到下，信息流从现在的(当前天气)到接下来的(接下来几个小时)的再到之后的(10 天天气预报)。该应用程序旨在让人们最便捷地获取他们最需要的信息。它还跟踪时间的逻辑顺序——现在、下一个、以后。
作者图片
将这个例子扩展到您的数据可视化世界，这个流的概念在构建仪表板和为演示创建叙述时尤其相关。
你的设计是为了让人们以他们思考的方式快速看到他们需要的信息吗？
在构建仪表板时，考虑人们首先、其次和第三寻找什么信息，并从上到下或从左到右组织内容，以反映人们将如何与您的产品交互。也许您有创建层次结构的产品类别，所以您可能想考虑从最高级别到最细粒度。或者，您有一个显示五年趋势、一年趋势和最*一个月的时间序列。找到正确流程的最简单的方法是与你最频繁的用户交谈，听听他们是如何谈论这个话题的，然后将它构建到项目中。
在创建演示文稿时，或者我们现在雄辩地称之为数据讲故事，我最有效的技巧之一是设身处地为观众着想，问自己幻灯片上的信息会引发什么最符合逻辑的问题，然后在下一张幻灯片中回答它。创造并遵循你的听众将拥有的(或你希望他们拥有的)思路。如果你显示一个时间序列有一个不寻常的峰值或谷值，接着解释为什么你会看到谷值——这是大多数人想要的最合理的下一条信息。
2.使用颜色来引起对重要区域的注意
我们中的许多人认为使用大小(即更大的文本)、粗体和颜色的变化是改变所呈现信息的有效方式。一个很少使用但非常有效的颜色技巧是使用灰色阴影来传达次要信息。看下面左边的图像，你首先看到的是什么？我的注意力很快被白色的文字吸引住了。快速浏览一下，您可能甚至不会注意到灰色的文本。然而，当你需要它的时候，你可以瞥一眼上面的白色来查看信息。
作者图片
明亮、大胆的颜色通常被认为是吸引信息注意力的方式，但也要记住，颜色的缺失也同样有效。这在交流某人已经熟悉并经常看到的信息时特别有用。
例如，您可能会将一些重要 KPI 的每周快照发送给您的经理或领导团队，或者您将这些信息作为仪表板的标题—用户已经知道这些 KPI，他们只想看到标题数字。通过为指标名称找到正确的灰度颜色，减少您所展示信息的认知负荷，然后使用大字体的强烈偏移色(如白色背景上的黑色)使您的标题数字突出。
3.提供人类可读的数字解释
如果你正在阅读这篇文章，很可能你是数据专家，并且对数字有天赋。考虑到这一点，你可能会忘记，你的听众往往对数据和数字没有同样的兴趣。他们可能是强大的产品创新者或项目经理。
对你来说，从数据中明显提取出来的东西对他们来说可能是一个等待解开的谜。
作为数据从业者，当我们看到数字时，我们会含蓄地或明确地“将点连接起来”，但为了确保每个人都在同一页上，我们应该尽一切努力阐明数字的含义和/或帮助人们将数字放入上下文。
我们再来重温一下天气 app 的最后一张截图。请注意在底部的方块中，围绕数据的有用的上下文和/或人类可读的解释。
作者图片
第一，苹果不仅让我们知道紫外线指数现在是多少，还让我们知道接下来一天会发生什么。对于第二点——尤其是我在北卡罗来纳州罗利的地方——感觉上的温度远远超过实际温度是很常见的，所以有一些有用的文字可以给你一个心理基准，告诉你现在的温度是多少。在第三个问题上，这篇文章给我们提供了下一个指标何时出现的信息。
回到应用程序的顶部，我们可以看到另一个可读文本的实例，它显示了今天剩余时间的内容。
作者图片
这里的技巧是使信息(1) 对读者来说是附加的——不仅仅是重复他们在屏幕上看到的数据点；(2) 篇幅简短——一般不超过一个简短的句子；(3) 使用简单明了的英语——避免行话和技术术语，用任何用户都能理解的语言表达。
我在 Tableau 中实现这一点的一种方法是使用创建的字段，这些字段提供了与基准的简单比较。例如，对于州级数据，我将使用一个简单的 if-else 语句在地图的工具提示中添加州是高于、等于还是低于某个指标的全国*均值。这个简单的基准可以帮助查看者将一个看似随机的数字放到有意义的上下文中。
如果您正在创建可视化、演示或数据产品，请不时看看您领域之外的信息呈现方式。这可以像高速公路上的标志一样简单——注意绿色背景上的白色大文本偏移，以便于阅读——也可以像苹果公司开发的应用程序一样复杂。
请记住，像苹果这样的公司拥有一些世界上最聪明和最好的设计师，像天气应用程序这样的东西，其核心是一种数据可视化产品，用于交流与温度、雨水和其他相关主题相关的信息。只要关注我们如何体验我们日常接触的产品，我们就能学到很多东西。
你也对这些话题感兴趣或有疑问吗？ 在 LinkedIn 上跟我联系 ！
深度学习中的激活函数有哪些？
深度学习/统计/张量流
像我五岁一样解释
乔希·里默尔在 Unsplash 上的照片
所有关于激活功能的问题都集中在这里。我会尽量长话短说。
什么是激活功能？
为什么神经网络需要激活函数？
激活功能有哪些类型？
如何在 TensorFlow / Keras 中实现它们？
如何为你的神经网络选择合适的激活函数？
先说最明显的问题:'什么是激活函数？ ' 假设你们所有的深度学习爱好者都知道人工神经网络(ANN)的基本结构，以及它的构建模块神经元在网络内部的实际功能，那么每个神经元肯定都很清楚:
- 从网络的输入层或前几层的神经元接收输入
- 对收到的信息进行某种处理或计算
- 向网络下一层的神经元发送输出信号
由于神经元执行所有这些功能，它们的输出各不相同，有时对网络并不重要。来自某些神经元的这种信息在被抑制时，会导致更高得分的网络。这就是激活功能发挥作用的地方。
一个激活函数是一个看似很小的数学表达式，它决定一个神经元 是否激活 。这意味着激活函数抑制了其输入对神经网络的整体应用没有意义的神经元。这就是为什么神经网络需要这样的函数来显著提高性能。
在大多数情况下，需要激活函数来向网络提供某种非线性。如果没有这些功能，神经网络基本上就变成了一个简单的线性回归模型。然而，线性激活函数也存在，我们将在下面看到:
激活功能的类型:
- 二元阶跃函数
- 线性激活函数
- 非线性激活功能 s (相当多)
1.二元阶跃函数
二元阶跃函数(图片由作者提供)
数学方程式:
当 x < 0 时，x = 0；当 x ≥ 0 时，x = 1
这是最不常用的激活函数，你可能甚至没有听说过它。二元步进激活函数是一个简单的阈值分类器。如果二进制阶跃函数的输入大于阈值条件，则神经元将被激活，这意味着神经元的输出将被成功传递到下一层。如果不是这样，神经元就不会被激活，对整个神经网络来说基本上是无用的。
2.线性激活函数
线性激活函数(图片作者提供)
数学方程式:
(x) = x
从等式中可以明显看出，激活与函数接收到的输入成正比。这里的梯度对于通过网络的每一步计算都保持不变。因此，lienar 激活函数应该用于不需要非线性的简单回归应用。
3.非线性激活函数
有许多有用的非线性激活函数可用于不同的应用:
ReLU(整流线性单元)激活功能:
ReLU 激活功能(图片由作者提供)
数学方程式:
(x) =最大值(0，x)
这是一个分段线性函数，如果输入为正，它将直接输出输入，否则，它将输出零。因此，它被称为“整流”线性单位。这是用于网络的输入和输出层之间的隐藏层的最常见的激活函数，因为它易于实现并且通常导致更好的性能。
然而，由于所有的负输入都被映射为 0，该激活中的梯度也变为零。因此，在反向传播过程中，一些神经元的权重可能不会更新，从而使它们变得无用。这就是所谓的‘垂死的 ReLU 问题’。
泄漏 ReLU 激活功能:
泄漏的 ReLU 激活功能(图片由作者提供)
数学方程式:
ф(x)= 1(x<0)(αx)+1(x>= 0)(x)；α是一个小常数
泄漏 ReLU 激活功能试图缓解垂死 ReLU 问题，该问题发生在具有小正斜率的 ReLU 中，不会导致零梯度问题。因此，在反向传播期间，负区域中的神经元也被考虑在内。
基于 ReLU 的其他很少使用的激活函数有:1)参数指数线性单元 (PELU)。2)指数线性单元 (ELU)。3)高斯误差线性单元 (GELU)。4)比例指数线性单元 (SELU)。这里不探讨它们，因为它们在最常见的神经网络模型中几乎从未使用过，本文旨在尽可能简短。
乙状结肠激活功能:
乙状结肠激活功能(图片由作者提供)
数学方程式:
(x) = 1/(1 + e^-x)
该函数接受负输入或正输入，并始终返回范围 (0，1) 内的输出。最大的输入非常接* 1，而最小的输入非常接* 0。这通常用于需要输出类别概率的应用。这是广泛用于二进制分类神经网络的输出层的激活函数。
Tanh 激活功能:
Tanh 激活功能(图片由作者提供)
数学方程式:
(x) = (e^x — e^-x) / (e^x + e^-x)
双曲正切激活函数遵循与 sigmoid 函数相同的梯度曲线，但是在这里，该函数输出的结果在范围 (-1，1) 内。由于该范围，由于该函数以零为中心，因此它主要用于神经网络的隐藏层。这个函数的输出也可以是负的。因此，结果可以强烈地映射到下一个输入神经元。
Softmax 激活功能:
softmax 激活函数基于 sigmoid 函数，该函数以范围(0，1)内的概率产生输出。softmax 函数可以定义为多个 sigmoid 函数的简单组合。
数学方程式:
(x)= exp(x)/(σk exp(y))；k 是类的数量，y 是输出向量
sigmoid 函数用于二进制分类并产生一个输出概率，而 softmax 函数总是用于多类分类应用，因为它产生应用中“k”个类中每个类的输出概率，其总和为 1。
Swish 激活功能:
Swish 激活功能(图片由作者提供)
数学方程式:
ф(x)= x sigmoid(βx)；β是一个可学习的参数
Swish 是谷歌最*才提出的一个自门控激活功能。“嗖嗖”是*滑的，不会像 ReLU 激活功能那样突然改变方向。它可以被认为是一个修改的漏重激活函数。小的负值没有被完全抑制，因此来自相关神经元的小的潜在模式也可以被网络捕获，同时还将较大的负值*坦化为零，这有利于保持稀疏的特征向量。出于这个原因，据报道，在许多不同的应用程序中，swish 激活功能的性能远远超过了传统的 ReLU 功能。
为您的模型选择正确的激活功能:
由格伦·卡斯滕斯-彼得斯在 Unsplash 上拍摄的照片
这里有一些方便的通用规则和惯例，您在为不同的应用程序构建神经网络时应该遵循。
- ReLU 激活函数是目前任何类型神经网络的隐藏层(而不是输出层)最常用的函数。
- 尽管 swish 激活函数在复杂的应用程序中似乎确实优于 ReLU 函数，但它应该主要用于深度超过 50 层的大型神经网络。
- 对于二进制分类应用，输出(最顶层)层应由 sigmoid 函数激活——对于多标签分类也是如此。
- 对于多类应用，输出层必须由 softmax 激活功能激活。
- 线性激活函数应仅用于简单回归神经网络的输出层。
- 对于递归神经网络(RNNs)tanh激活函数优先用于隐藏层 (s)。在 TensorFlow 中默认设置。
- 如果 ReLU 功能似乎不能提供最佳结果，将激活更改为泄漏 ReLU 在某些情况下可能会产生更好的结果和整体性能。
对于 Tensorflow 激活功能的实现，请从 Tensorflow 的官网查看这个方便的模块。
感谢您的阅读。如果你喜欢这篇文章，考虑关注并鼓掌。
你也可以在 LinkedIn 上和我联系。☺
Azure Synapse Analytics 中的专用 SQL 池是什么？
Azure Synapse Analytics 中的大数据解决方案
弗兰基·查马基在 Unsplash 上拍摄的照片
TLDR
- Synapse SQL 池的背景
- 什么是专用 SQL 池？
- 怎么用？
- 创建您第一个专用 SQL 池
- YouTube 视频对以下步骤进行了直观描述
Synapse SQL 池的背景
自从我的上一篇帖子( SQL On-Demand:一种更简单的数据查询方式|作者 Dayo bami kole | toward Data Science)以来，Azure Synapse Analytics 已经向公众公开(正式发布)，我在帖子中提到了 Synapse 的一些顶级功能，其中之一就是 SQL Pool。有几种方法可以在 Azure Synapse 中查询数据，有 SQL 池和 Apache Spark 池。有两种类型的 SQL 池:专用的和无服务器的。在随后的一篇文章中，我重点介绍了以前称为 SQL On-Demand 的无服务器 SQL 池。在这篇文章中，我将重点关注专用的 SQL 池。
什么事
SQL 池是传统的数据仓库。在加入 Synapse 家族之前，它的前身是 Azure SQL 数据仓库。它是一个大数据解决方案，以列存储的关系表格式存储数据。它还使用大规模并行处理(MPP)架构来利用多达 60 个节点来运行查询。一旦您将数据存储在专用的 SQL 池中，您就可以利用它从仪表板进行历史分析，将其用作机器学习的数据集，以及您可能用于大规模数据集的任何其他数据目标。
有关 Synapse SQL 架构的更多信息，请查看微软文档
https://docs . Microsoft . com/en-us/azure/synapse-analytics/SQL/overview-architecture
目标
使用专用 SQL 池的目标是存储大规模数据，并能够高效地进行查询。这更容易，因为它是以列格式存储的，并且您可以利用聚集列存储索引进行快速检索。
如何使用
你可能想知道如何将数据输入这个*台，对吗？
围绕专用 SQL 池，您会经常听到一个术语，即 Polybase。什么是 Polybase，它是一个允许你从外部资源查询数据的工具，例如 SQL Server，Oracle，Teradata，MongoDB 等。您可以看到使用专用 SQL 池的好处。一旦数据被摄取，Polybase 还提供了查询大数据的能力。
创建您的第一个专用 SQL 池
如果你已经有了 Synapse 环境，那就非常简单了。如果你需要一些帮助，看看我的介绍视频这里
在您的 Azure Synapse 环境中，单击管理
作者图片
在 SQL 池下，单击新建
作者图片
为专用 SQL 池命名
将性能级别扩展到您选择的级别。
作者图片
点击查看+创建
点击底部的创建
作者图片
创建您的第一个 SQL 池表
进入数据库部分。您可能需要刷新数据库部分。您应该会看到新创建的 SQLPool。展开它，您会看到 SQL Server 等数据库的相似之处。
要创建您的第一个表，您将右键单击“表”部分并选择“新 SQL 脚本”，然后选择“新表”
作者图片
这将创建一个默认的表脚本。您所要做的就是单击 Run 来创建您的第一个表
作者图片
显然，这只是一个示例脚本，您可以在这里编写各种类型的查询以用于大数据目的
结论
既然您已经创建了第一个专用的 SQL 池，那么您现在已经对 Azure Synapse 中有助于构建端到端数据解决方案的众多功能之一有了一些体验。请继续关注 Azure Synapse Analytics 的其他组件以及它们之间的联系。
什么是动态图，为什么它们很有趣？
由于复杂的现实生活情况可以用图表来模拟，它们随时间的演变可以用动态图表来捕捉。
一个无向图可以表示为 G ( V，E )其中 V 是顶点/节点，E 是两个顶点之间的边/连接。
我们以类似的方式定义一个动态图，但是作为一系列快照，即 G = (G₁，G₂，…)。Gₜ)，其中 gₜ=(eₜvₜ)，t 是快照的数量。在动态图中，新节点可以形成并创建与现有节点的链接，或者节点可以消失，从而终止现有链接。
这在某种程度上是一个正式的定义，但我们将使用一个简单的社交网络示例来理解动态图。
社交网络的演变
图一。社交网络示例(来源:作者)
让我们构建一个由 5 个人组成的小型社交网络图(见图 1)。这里的节点代表人，边代表两个人之间的友谊。这是 T = 0 时的情况。当他们相互作用一段时间后，一些新的关系会形成，一些会破裂。此外，请记住，新人可以在任何时间进入这个社交网络，现有成员也可以离开。
社交网络的演变(来源:作者)
在社交网络的发展过程中，我们在 3 个时间点获得了 3 个快照。所有这三个快照构成了动态图。我们见证了一些新友谊的建立，也见证了一些破裂。我们可能会遇到这样的情况:有新的输入节点(人们加入网络)和一些输出节点(人们离开网络)。
研究这些动态图表将为我们提供一些关于社交网络中人际关系的复杂行为的深刻见解。
这些动态图不仅适用于社交网络，还可以应用于其他领域，例如生物医学领域。让我们再看一个生物医学领域的例子，我们可以用动态图的形式来模拟一些生物实体。
蛋白质相互作用
蛋白质对于人类细胞中的大多数生物过程都很重要，如基因表达、细胞生长等等。但是蛋白质很少单独发挥作用，它们往往通过蛋白质-蛋白质相互作用 (PPIs)形成关联，以便在细胞内执行不同的分子过程。这些 PPI 是两个或多个蛋白质分子之间的物理接触，是细胞中发生的生化事件的结果。
这里，节点是编码蛋白质的基因，边是不同蛋白质之间的相互作用。有像 DNA 微阵列这样的实验使我们能够同时研究数千个基因的特性。这些微阵列为我们提供了检测基因的信息，这些基因可能会也可能不会被翻译成蛋白质。
来自微阵列实验的数据可以从几个样本细胞(健康的人类细胞、被冠状病毒感染的细胞等)中产生，并被存储为基因表达数据。这些实验在相同的基因上以规则的时间间隔进行，因此我们从这些基因表达数据中获得了时间信息。
作为动态图的 PPI 网络(来源:作者)
简单来说，我们有一个 T = 0 时的蛋白质相互作用图。我们使用来自基因表达数据的时间信息来识别哪些基因在什么时间点被激活，以便构建动态图。
例如，如果我们的 DNA 微阵列实验在 5 个不同的时间点(0h、3h、6h、9h 和 12h)进行，那么我们将在 5 个时间点得到 PPI 网络的动态图。
动态图的使用
正如我之前提到的，动态图有助于捕捉真实世界实体的复杂行为(比如社会网络中的人类，或者 PPI 网络中的基因编码蛋白质)。我们还将时间维度添加到数据集，以解释一个过程从开始到结束的演变。
为了从动态图数据中提取有价值的信息，我们可以采用机器学习技术。首先，我们需要学习动态图中存在的实体的数字表示，然后我们可以使用图形神经网络等方法来模拟几种用例，如节点分类、链接预测等。
这种图上的一个非常常见的任务是社区检测，这在 PPI 的上下文中被称为复杂检测。基本上，我们使用无监督的机器学习技术，如聚类，来识别每个时间点的重要组。对于 PPI 网络来说，这是有趣的，因为识别重要的蛋白质簇/复合物将导致更好的疾病药物发现。
我们还有一个图形比对任务，我们的目标是识别在不同类型的样品(如健康或受感染的细胞)中显示差异的蛋白质或复合物。这有助于生物学家找到他们在寻找治疗方法时应该关注的蛋白质。
在社交网络的情况下，我们可以使用动态图分析来识别网络中的垃圾邮件发送者(垃圾邮件检测)。动态图的核心思想是相同的，但不同的领域有自己的用例，我们可以使用机器学习模型来满足他们的需求。
使用链接预测，我们可以通过分析网络随时间的增长，向社交网络中的用户推荐朋友。对于 PPIs，我们可以提供一个蛋白质建议列表，这意味着我们希望提出一个具有形成新相互作用潜力的蛋白质列表。
结论
动态图的时间方面捕捉了网络的演变，这使我们能够对几个实体之间复杂的现实生活交互进行建模。存在最先进的机器学习技术，以在动态图的基础上建立预测模型，这具有强大的潜力来推动药物发现、人造肉(基于植物的肉生成)等的研究。
如果你看到了这篇文章的这一部分，感谢你的阅读和关注。我希望你觉得这篇文章内容丰富，并且可以通过 LinkedIn 、 Twitter 或 GitHub 联系到我。
机器学习中的集成方法有哪些？
作者图片
带有备忘单的机器学习集成方法的可视化漫游
背景
假设你搬到了一个新地方，想出去吃饭。你如何找到一个好地方？
解决方案 1: 找一位真正擅长自己工作的美食评论家，看看他/她对你所在地区的餐馆有什么推荐
解决方案 2: 使用谷歌，随机查看一个用户对几家餐馆的评论。
解决方案 3: 使用谷歌，查看多个用户对几家餐馆的评论，然后*均他们的评分。
让我们分析上述每一种解决方案。
解决方案 1:
- 食物评论家通常是非常准确的。
- 很难找到一个美食评论家
- 也许你找到的美食评论家是个严格的素食主义者，而你不是。在那种情况下，美食评论家的推荐将会有偏见。
解决方案 2:
另一方面，在网上随便拿起一个人对一家餐馆的星级评定就是
- 远不如准确
- 更容易找到
解决方案 3:
- 总的来说，它可以是你需要的正确的精确度
- 更容易在网上找到
- 因为给餐馆评分的用户来自不同的背景，所以不存在偏见。
因此，不需要问美食评论家，你只需看看一群随机的(但人数众多的)人的集体意见，就能得到相当不错的餐馆推荐。这就是所谓的 群体智慧 ，是各种信息网站的支柱，如 Quora、Stack-exchange 和 Wikipedia 等。
什么是系综方法？
机器学习中的集成方法集体使用多个弱学习器来预测输出。您不是为数据集训练一个大型/复杂的模型，而是训练多个小型/简单的模型(弱学习者)并聚合它们的输出(以各种方式)来形成您的预测，如下图所示
推论:系综法(图片由作者提供)
集合方法的类型
一般来说，有三种不同类型的集成方法目前常用于 ML
- 制袋材料
- 助推
- 堆垛
这些方法具有相同的 群体智慧 概念，但在细节上有所不同关注什么，使用 t 类型的弱学习者和用于形成最终输出的类型的聚集。
1.制袋材料
在 Bagging(Boot strapAggerating中，多个学困生被并行训练。对于每一个弱学习者，输入数据是从原始数据集中随机抽样替换并训练的。具有替换的子集的随机采样创建了接* iid 的样本。在推理过程中，测试输入被提供给所有弱学习者，输出被收集。通过对每个弱学习者的输出进行投票来进行最终预测。
完整的步骤如下面的框图所示。
集合方法— Bagging(图片由作者提供)
在 bagging 方法中，弱学习者通常属于同一类型。由于替换随机抽样产生 iid 样本，集合 iid 变量不会改变偏差，但会减少方差，因此 bagging 方法不会改变预测中的偏差，但会减少其方差。
2.助推
在 boosting 中，多个弱学习者被顺序学习。每个随后的模型通过给予被先前的弱学习者错误分类的数据点更多的重要性来训练。以这种方式，弱学习者可以关注特定的数据点，并且可以共同地减少预测的偏差。完整的步骤如下面的框图所示。****
集成方法—增强(图片由作者提供)
通过对数据集中的所有数据点赋予相等的权重来训练第一个弱学习者。一旦训练了第一个弱学习者，评估每个点的预测误差。基于每个数据点的误差，更新下一个学习者的数据点的相应权重。如果数据点被经过训练的弱学习者正确分类，则减少其权重，否则增加其权重。除了更新权重之外，每个弱学习者还维护一个标量 alpha，该 alpha 量化弱学习者在分类整个训练数据集方面有多好。
随后的模型在这些加权的点集上被训练。对一组加权点进行训练的一种方式是表示误差中的权重项。不使用均方误差，而是使用加权均方误差，以确保具有较高分配权重的数据点在被正确分类时被赋予更大的重要性。另一种方式可以是加权采样，即在训练时基于它们的权重来采样点。
在推理阶段，测试输入被提供给所有的弱学习者，他们的输出被记录下来。如上图所示，在使用弱学习者的输出进行投票之前，通过用相应的弱学习者的权重α缩放每个弱学习者的输出来实现最终预测。
3.堆垛
在堆叠中，多个弱学习者被并行训练，这类似于装袋中发生的情况。但与 bagging 不同，stacking 不执行简单的投票来聚合每个弱学习者的输出，以计算最终的预测。相反，另一个元学习者在弱学习者的输出上被训练，以学习从弱学习者输出到最终预测的映射。完整的框图如下所示。
集合方法—叠加(图片由作者提供)
堆叠通常有不同类型的弱学习者。因此，对所有弱学习者的预测给予同等权重的简单投票方法看起来并不是一个好主意(如果弱学习者在结构上是相同的，它本来会是一个好主意)。这就是元学习者出现的地方。它试图了解哪个弱学习者更重要。
弱学习者是并行训练的，而元学习者是顺序训练的。一旦弱学习者被训练，他们的权重保持不变来训练元学习者。通常，元学习者是在不同于弱学习者的子集上被训练的。
小抄
下面的备忘单涵盖了可能会派上用场的集合方法的主题。
小抄综合方法(来源:http://cheatsheets.aqeel-anwar.com/
摘要
集成方法不是训练一个网络，而是使用多个弱学习者，并聚集他们各自的输出来创建最终的预测。不同集合方法的比较可以在下表中看到。
集成方法的比较(图片由作者提供)
奖金:
可以在下面的链接中找到这个主题和机器学习中许多其他重要主题的紧凑备忘单
****https://medium.com/swlh/cheat-sheets-for-machine-learning-interview-topics-51c2bc2bab4f ****
如果这篇文章对你有帮助，欢迎鼓掌、分享和回复。如果你想了解更多关于机器学习和数据科学的知识，请关注我@Aqeel an war或者在LinkedIn上与我联系。****
Python 中的命名元组是什么
Python 中被忽略的扩展数据类型
Sebastian Pociecha 在 Unsplash 上拍摄的照片
介绍
元组是 Python 中最基本和最广泛使用的数据结构之一。大多数人不知道或者通常忘记的是，该语言附带了一个名为 Tuple 的扩展类型，它构建在核心 Tuple 类型之上。
在本文中，我们将探索命名元组——一个很少使用的集合，它增强了标准元组。我们将讨论它们的语法，如何在你的代码中使用它们，最重要的是何时使用。
什么是命名元组以及何时使用它们
字典提供键查找，非常适合我们需要使用助记键名称创建键值数据结构的情况。另一方面，列表和元组是任意对象的有序和可索引的集合。
命名元组位于字典和元组(甚至类！)因为它们便于位置和属性查找。这意味着集合中的对象可以通过它们的键或索引来访问。
“用于创建具有命名字段的元组子类的工厂函数”— Python 文档
命名元组容器数据类型是内置 [**tuple**](https://docs.python.org/3/library/stdtypes.html#tuple)的替代。这种扩展类型增强了标准元组，因此它们的元素可以通过它们的属性名和位置索引来访问。
在namedtuple实用程序下的 Python 标准库collections模块中可以获得命名元组。该类型接受 typename 的名称和与之相关的字段名称作为参数。然后，该实用程序将返回一个新的元组子类，该子类用给定的 typename 命名。
在下面的代码片段中，我们创建了一个名为Employee的namedtuple typename，它包含 4 个不同的字段。
为员工创建命名元组
现在我们可以使用生成的namedtuple typename 来创建对应于雇员的命名元组记录。
使用命名元组类型名创建雇员
注意，只要使用关键字参数，就可以通过以任意顺序传递参数来创建新的 typename 对象，如下所示。
使用关键字参数创建另一个雇员
现在我们可以通过属性或位置来访问命名元组中的元素
通过索引或命名属性访问命名元组中的元素
正如我们所见，命名元组结合了内置元组和字典的特征，甚至结合了 Python 类的特征。在幕后，这是通过创建一个从内置元组类型继承的新类(typename)来实现的。对于每个命名字段，添加一个@property访问器，将属性名映射到相应的位置。
命名元组是一种扩展和自定义数据类型，它用额外的实用程序丰富了内置元组。在我们需要创建一个可以被元素的位置索引和命名属性访问的数据结构时，它们非常有用。
使用命名元组的更多操作
当转换为字典时，命名元组也可以支持键查找。_as_dict()方法将返回一个OrderedDict()，其中键是命名元组的属性。因此，通常的基于键的操作可以在返回的字典上执行。
将命名元组解析为有序字典
此外，命名元组支持解包元组赋值。这意味着可以使用元组赋值将namedtuple的命名属性解包到相应的变量中。下面显示的代码片段演示了如何将命名属性解包到一个元组中。
解包命名元组的属性
除了可索引，命名元组也是可迭代的。Pyhton 中的 Iterables 实现了__iter__并返回一个迭代器，该迭代器能够一次返回其成员的一个元素。
遍历命名元组的属性
默认情况下，命名元组还提供了一个可读的__repr__，它表示元组的类型名及其键值属性:
最后，[typing](https://docs.python.org/3/library/typing.html)包提供的typing.NamedTuple是collections.namedtuple的类型化版本。
namedtuple 的类型化版本
上面显示的类型化版本相当于下面的代码片段:
带有类型提示的完整示例:
最后一句话
尽管命名元组很少使用，但仍然非常强大。这种特殊的扩展数据类型共享来自内置元组、字典甚至类的特征。当我们需要构建可以通过位置索引或属性名访问的数据结构时，命名元组通常很有用。
在本文中，我们讨论了名称元组的用途，并探索了如何创建和访问它们。此外，我们讨论了命名元组的一些操作和特性，如迭代和基于键的查找(当转换为字典时)。
最后要注意的是，命名元组是不可变的，这意味着它们的元素不能就地改变。在下面的文章中，你可以读到更多关于可变和不可变对象类型之间的区别，以及两者如何服务于 Python 的动态类型模型。
什么是后决策状态？他们想从我们这里得到什么？
阐明强化学习中的转移函数和状态-动作对
一个井字游戏完美地展示了后决策状态的概念[作者自己的作品]
以一个经验丰富的强化学习老手的反高潮开始；后决策状态并不新奇或惊天动地。还没点开？很好，因为实际上有一些内容出现了。在本文中，我们将更深入地研究状态-动作对和转移函数的概念，提供从一个问题状态转移到另一个问题状态的过程的洞察力。
转换函数
在强化学习(RL)的最简单表示中，我们有一些概率函数 p(s_t+1|s_t,a_t)引导我们到新的状态。我们处于状态s_t，采取行动a_t，并神奇地以某种概率p转移到状态s_t+1。此外，我们可以定义一个集合S’,它包含所有的结果状态s_t+1,在给定我们的动作的情况下，这些结果状态可以从我们的当前状态到达。自然地，该集合中所有状态的概率总和应该是 1。
听起来很简单，但是许多有趣的信息隐含在这个看似简单的概率函数中。如果我们的目标是更明确地试图描述从状态s_t移动到s_t+1的过程，我们可以称之为转移函数；一些明确的功能f()引导我们从一种状态到另一种状态。拥有“一些”结果状态S’并不是非常有用，因此在这一点上引入外部信息变量*ω_t* 是很好的。这个变量可以封装任何不在我们控制范围内的信息:骰子上的眼睛数量、明天的降雨量、比特币价格、未来的石油需求……简而言之，*ω_t* 捕捉到了我们转变的不确定性，并可能被视为区间(t,t+1]中透露的信息。这就是强化学习的内容；我们部分地通过自己的行为来影响回报，部分地预测世界会给我们带来什么。目的是仔细选择我们的行动，这样我们就能在有利的位置上面对未来。
有了我们的外生信息变量ω_t，我们现在可以尝试定义一个显式的转移函数。设Ω_t是所有可能变量ω_t的集合；将这些变量视为场景可能更方便。综上所述:我们从s_t到s_t+1的转变取决于当前(预决策)状态s_t，被选择的动作a_t和外生信息ω_t的实现:
转换函数(从一个预决策状态到下一个状态)
决策后状态
到目前为止，一切顺利。现在让我们来讨论一下 Q 值。正如你可能知道的，基于值的 RL 算法学习对应于状态-动作对的值。这些 Q 值——用Q(s_t,a_t)表示——捕获了我们当前行动的预期下游值。作为复习，看看 SARSA 算法的规范更新公式[2]:
用 SARSA 更新状态-动作对的 Q 值的函数
学习与状态-动作对相关的预期下游值听起来有点抽象，这就是后决策状态 — 在【2】中详细解释的地方——可能会有所启发。我们已经确定我们的转变是部分确定的(由于我们的行动a_t)和部分随机的(由于ω_t的随机表现)。为什么不把这两个元素分开，看看会发生什么？
首先，我们引入一个转移函数f^(1)来从我们当前的预决策状态s_t转移到后决策状态s_t^a。请注意，这种转变是完全确定的，并且不需要时间来向前移动，我们可以在选择一个操作的瞬间计算它:
从预决策状态到后决策状态的转换函数
第二，我们有一个转换函数f^(2)从决策后状态s_t^a移动到下一个决策前状态s_t+1。这个函数是完全随机的；完全取决于ω_t的实现。根据定义，我们的动作是基于状态s_t中嵌入的信息，因此，新信息ω_t必须在采取动作后到达。因此，第二个转换函数意味着时间的流逝，在此期间新的信息被揭示:
从决策后状态到下一个决策前状态的转换函数
所以现在我们有两个转移函数，而不是一个。这看起来没什么进步，但是请耐心听我说。
井字游戏
有什么比用一个老式的井字游戏更好的方式来说明一个概念呢？让我们考虑一下游戏开始时的状态。决策前状态s_0显然是一个空棋盘，而我们有九个可行的动作a_0(s_0)，因此可能达到九个决策后状态s_0^a(注意这相当于评估九个状态-动作对)。
决策前状态(左窗格)，九个可达到的决策后状态(右窗格)[作者自己的作品]
为了真正达到决策后状态，我们必须选择一个动作并填写f^(1)(s_t,a_t)。为了达到随后的预决策状态，我们必须等待——从我们的角度来看是外生的——对手的移动并填入f^(2)(s_t^a,ω_t)
第一个动作后的决策后状态(左窗格)和对手动作后的下一个决策前状态(右窗格)[作者自己的作品]
再举个例子？我们已经接*比赛的尾声了。我们有三个要考虑的行动，或者说，在上下文中，有三个可达到的决策后状态要评估。假设我们已经有了一些观察结果，我们可以知道两个后决策状态可能会产生很差的结果。
游戏接*尾声时可达到的决策后状态的可视化[作者自己的作品]
现在很容易看出价值函数Q(s,a)和Q(s^a)非常相似。后决策状态的关键是关于未来的确定性和随机性知识的综合分离。决策后状态提供了比决策前状态更多的最新信息，明确地捕获了最新的系统状态，而没有实际地及时向前移动。
特征设计
对于井字游戏来说，所有这些可能看起来有点做作，但是当我们为更现实的 RL 问题设计功能时，根据决策后状态进行思考的好处变得更加明显。通常，将这些特征建立在我们拥有的最新信息的基础上是有意义的。
假设我们有一个仓库，里面有一千种不同的商品，每种商品的数量反映在一个大的向量中(即状态)。根据预期的当前库存水*，我们决定(即行动)订购一定数量的每种商品。我们的决策后状态将是当前库存水*加上订单水*。这个更新的水*预测了，例如，预期的存储成本、过期库存和满足未来需求的能力——简而言之，预期的下游价值。因此，如果我们计算任何特征(例如所有项目的总体积、快速移动项目的数量)，我们是基于决策后向量来这样做的。实际上，这里的后决策向量是状态向量和动作向量的简单相加。从后决策到下一状态的转换减去ω_t的随机实现:
有 10 种产品类型的库存的转移函数示例。在左边的 f^(1)，通过向现有库存添加新订单，从 s_t 过渡到 s_t^a。右边的 f^(2)，从s_t^a to s_t+1 by subtracting stochastic demand.过渡
观察s_t^a是我们确定满足未来需求能力的最佳预测器。因此，当基于状态计算特性时，我们可能会利用某个函数ϕ_f:s_t^a↦θ_f(其中函数可以是神经网络，而s_t^a是输入向量)。当然，ϕ_f:(s_t,a_t)↦θ_f可能有完全相同的意思，但前者肯定更明确。正如 Python 的禅宗所说:
“显性比隐性好”
外卖食品
- 决策后状态与状态-动作对密切相关，但是提供了关于信息可用性的更明确的观点。具体地说，它们体现了将状态-动作对转换成单个信息变量。
- 我们将传统的转移函数分成两个部分，清晰地区分在单个时间点的确定性转移(基于选定的动作)和随着时间推移的随机转移(基于环境)。
- 从决策后状态的角度思考通常有利于特征设计，因为我们希望特征基于我们最*的信息。
本文关注状态-动作对和决策后状态之间的相似性。对差异感兴趣吗？请查看:
参考
[1]萨顿和巴尔托(2018 年)。强化学习:简介。麻省理工出版社。
[2]鲍威尔(2007 年)。*似动态规划:解决维数灾难。约翰·威利&的儿子们。
RMSE 和梅是什么？
评估指标的简单指南
均方根误差(RMSE)和*均绝对误差(MAE)是用于评估回归模型的指标。这些指标告诉我们我们的预测有多准确，以及与实际值的偏差有多大。
帕特丽夏·塞尔纳在 Unsplash 上的照片
从技术上来说，RMSE 是 E 错误的 S 方的 R oot，而 MAE 是Ab 错误的 M ean。在这里，误差是一个变量的预测值(由我们的回归模型预测的值)和实际值之间的差异。它们的计算方法如下:
仔细观察，你会发现两者都是误差的*均值。
我们用一个例子来理解这个。比如说，我想根据经验的年数来预测一个数据科学家的工资。所以，工资是我的目标变量(Y)，经验是自变量(X)。我有一些关于 X 和 Y 的随机数据，我们将使用线性回归来预测工资。让我们使用熊猫和 scikit-lear n 进行数据加载和创建线性模型。
import pandas as pd
from sklearn.linear_model import LinearRegressionsal_data={"Exp":[2,2.2, 2.8, 4, 7, 8, 11, 12, 21, 25],
"Salary": [7, 8, 11, 15, 22, 29, 37 ,45.7, 49, 52]}#Load data into a pandas Dataframe
df=pd.DataFrame(sal_data)
df.head(3)
#Selecting X and y variablesX=df[['Experience']]
y=df.Salary#Creating a Simple Linear Regression Model to predict salarieslm=LinearRegression()
lm.fit(X,y)#Prediction of salaries by the model
yp=lm.predict(X)
print(yp)[12.23965934 12.64846842 13.87489568 16.32775018 22.45988645 24.50393187 30.63606813 32.68011355 51.07652234 59.25270403]
现在，我们有了“yp”——我们的工资预测数组，我们将通过绘制预测工资(yp)和实际工资(y)来评估我们的模型。我正在用 bohek 进行我的可视化。
from bokeh.plotting import figure, show, output_filep=figure(title="Actual vs Predicted Salary", width=450, height=300)
p.title.align = 'center'
p.circle(df.Exp, df.Salary)
p.line(df.Exp, df.Salary, legend_label='Actual Salary', line_width=3, line_alpha=0.4)
p.circle(df.Exp, yp, color="red")
p.line(df.Exp,yp, color="red",legend_label='Predicted Salary', line_width=3, line_alpha=0.4)p.xaxis.axis_label = 'Experience'
p.yaxis.axis_label = 'Salary'show(p)
从上图中，我们看到预测数据点和实际数据点之间存在差距。在统计学上，这种差距/差异被称为残差，通常被称为误差，用于 RMSE 和 MAE。Scikit-learn 提供了度量库来计算这些值。然而，我们将通过使用上面的数学表达式来计算 RMSE 和 MAE。这两种方法会给你同样的结果。
import numpy as np
print(f'Residuals: {y-yp}')
np.sqrt(np.mean(np.square(y-yp))) #RMSEnp.mean(abs(y-yp)) #MAE#RMSE/MAE computation using sklearn library
from sklearn.metrics import mean_squared_error, mean_absolute_errornp.sqrt(mean_squared_error(y, yp))
mean_absolute_error(y, yp)**6.48
5.68**
这是我们的基线模型。MAE 约为 5.7——似乎更高。现在我们的目标是通过减少这个误差来改进这个模型。
让我们用同样的模型对“experience”(X)进行多项式变换，看看我们的误差是否减少了。
from sklearn.preprocessing import PolynomialFeatures
pf=PolynomialFeatures() #Linear Equation of degree 2
X_poly=pf.fit_transform(X) lm.fit(X_poly, y)
yp=lm.predict(X_poly)
我已经使用 Scikit-learn 多项式特性创建了一个 1、X 和 X2 的矩阵，并将其作为输入传递给我的模型。
计算我们的误差指标和…
#RMSE and MAE
np.sqrt(np.mean(np.square(y-yp)))
np.mean(abs(y-yp))**2.3974
1.6386**
瞧……他们这次低多了。它比我们的基线模型更适合！让我们画出 y 和 yp(就像我们之前做的那样)来检查重叠部分。
两条线之间的间隙已经减小。让我们使用 seaborn 的残差绘图函数来观察残差或误差(y-yp)的分布
print(y-yp) #residuals
[ 0.333921 0.447306 0.84028668 -0.136044 -4.190238 -0.434767
-0.847751 5.488121 -2.584481 1.083648]import seaborn as sns
sns.residplot(y, yp)
plt.show()
我们看到残差往往集中在 x 轴周围，这是有意义的，因为它们可以忽略不计。
还有第三个指标——R *方得分，通常用于回归模型。这衡量了我们的模型可以解释的变化量，即我们的模型返回的正确预测的百分比。它也被称为决定系数，通过以下公式计算:
让我们使用公式和 sklearn 库来计算 R2，并比较这些值。这两种方法应该给你相同的结果。
#Calculating R-Squared manually
a=sum(np.square(y-yp)) # a -> sum of square of residuals
b=sum(np.square(y-np.mean(y))) # b -> total sum of sqauresr2_value = 1-(a/b)
**0.979**#calculating r2 using sklearn
from sklearn.metrics import r2_score
print(r2_score(y, yp))
**0.979**
因此，总的来说，我们可以认为 98%的模型预测是正确的，误差的变化在 2 个单位左右。对于一个理想的模型，RMSE/梅=0，R2 分数= 1，所有的剩余点都在 X 轴上。对于任何业务解决方案来说，实现这样的价值几乎是不可能的！
我们可以用来提高模型准确性的一些技术包括:
- 变换/缩放功能
- 处理异常值(如果有)
- 添加新功能/功能工程
- 使用不同的算法
- 模型超参数调谐
在我的下一篇文章中，我将详细解释上面的一些概念。以上代码可以参考我的笔记本这里。
机器学习接下来要应对的最激动人心的挑战是什么？
随着机器学习和人工智能研究每天都在大步前进，人们常常会觉得该领域所有酷的创新前沿都已经有人问津了。如果你刚刚开始，尤其如此。本周，我们想提醒你(和我们自己)在这些领域还有多少需要学习、成长和提高的地方。如果你需要一点鼓励来继续下去，或者需要一点灵感来帮助你开始下一个项目，那就来吧！
- 熟悉三个有前途的机器学习挑战 。是的，大型语言模型和计算机视觉比我们几年前想象的还要强大。但是，正如 Vincent Vanhoucke 在他最*的帖子中明确指出的，仍然有很多事情要做。从逆向视频游戏问题到强化学习的下一阶段，文森特介绍了他认为该领域在未来几个月和几年将关注的三个方向。
- 探索利用 ML 和 NLP 支持心理健康服务提供者的新途径 。新冠肺炎让心理健康专家的工作变得比以往更加艰难:越来越多的人正经历焦虑和压力，人与人之间的联系更难(如果不是不可能的话)规划。 Tiffany Meshkat 和她在危机短信热线的同事使用自然语言处理方法来分析青少年的短信，使他们能够筛选和分类联系的人，并检测他们提出的问题的模式。
塞巴斯蒂安·佩纳·兰巴里在 Unsplash 上拍摄的照片
- 了解开放式强化学习的未来 。强化学习是人工智能的一个分支，在这个分支中，一个受奖励激励的代理人的任务是弄清楚一个环境及其规则。*年来，强化学习取得了令人印象深刻的进展。在 TDS 播客的最*一集里， Jeremie Harris 和他的嘉宾，DeepMind 的 Max Jaderberg，讨论了接下来会发生什么，以及人工智能代理如何很快能够赢得他们从未遇到过的游戏。
- 阅读可能彻底改变微生物分析的新研究 。使用深度学习方法， Sylwia Majchrowska 和jaros aw paw owski试图从根本上减少在培养皿中识别和计数微生物所需的时间。他们的帖子向我们介绍了他们的过程，分享了他们的结果，并指出进一步发展这种方法的前景。
- 探讨可持续深度学习模型的问题 。庞大的模型带来了巨大的成本——包括财务成本和环境成本。英特尔实验室的加迪·辛格在他的最新文章中，反思了持续科技进步带来的挑战。Gadi 建议公司和从业者专注于“分层访问结构”，这种结构可以让我们“增加能力，改善人工智能技术的成果，同时最大限度地降低功耗和系统成本。”
- 给你的数据科学工具包 添加哈希。如果本周你想获得更多的实践技巧，我们不会让你空手而归！Konstantin Kutzkov 的指南讨论了用于设计特定于数据的哈希函数的机器学习技术，并带您浏览了它们的应用。尽情享受吧！
如果你在本周的工作中遇到了新的令人兴奋的事情，我们很乐意听到它——留下评论，或者更好的是:写一篇关于它的帖子。感谢您一如既往地支持我们作者的工作。
直到下一个变量，
TDS 编辑
我们策划主题的最新内容:
入门
实践教程
- UMAP 降维——一种非常健壮的机器学习算法作者索尔·多比拉斯
- 由 Jamshaid Shahir 为口袋妖怪钻石璀璨和珍珠闪耀确定最佳口袋妖怪团队
- API 通过约翰·克莱门茨与 R 交互
- 你应该知道的时间序列预测误差指标作者康斯坦丁·林克
深潜
- 偏差、一致性和为数据驱动的工作设计 KPIs】作者 Rohit Pandey
- 两个随机行走的问题由西楚张
- Python 场景分析:使用 beta-PERT 分布对专家评估进行建模 Heiko Onnen
思想和理论
- 为什么斐波纳契数列的封闭形式不在竞技编程中使用？作者罗希特·潘迪
- Divya Gopinath和 David kuro kawa 的 ML 模型的 Shapley 值
- 处理生产环境中的泄漏、缺失数据作者 Sam Wilson
- 受限语言模型的力量作者卡雷尔·德·奥斯特林克
数据科学工作最受欢迎的技能是什么？求一个图形数据库！
通过用 TigerGraph、实际工作数据和 Kaggle API 构建 Indeed.com 工作图来寻找下一份工作
概观
图表无处不在，可以帮很多忙，包括找工作。像 LinkedIn 这样的*台由图表数据库驱动，帮助向你推荐工作。在这篇博客中，我们将创建一个可以帮助你回答一些问题的图表，比如什么技能最适合我想要的工作和工资范围。让我们构建图表，然后回答图表上的一些问题。
第一部分:在 TigerGraph 云上创建解决方案
首先，您需要在 TigerGraph Cloud 上创建一个解决方案。关注本博客了解更多详情:
https://www.tigergraph.com/blog/getting-started-with-tigergraph-3-0/
简而言之，您需要:
- 导航到https://tgcloud.io/.
- 单击“我的解决方案”选项卡。
- 点击右上角的蓝色“创建解决方案”按钮。
- 在第一页按“空白”。
- 不要更改第二页中的任何内容，然后按下一步。
- 根据您的详细信息定制第三页。
- 提交您的解决方案，等待它被创建。
第二部分:创建图表模式
现在让我们去 https://colab.research.google.com/的创建一个新的 Colab 笔记本。创建之后，让我们连接到图表，然后创建图表模式，这有点像我们将如何加载数据的地图。
步骤 1:连接到您的解决方案
首先，让我们安装并导入 pyTigerGraph。
!pip install pyTigerGraphimport pyTigerGraph as tg
接下来，让我们创建一个 TigerGraphConnection，将我们连接到我们刚刚创建的 TG 云解决方案。
注意:用您在第一部分中分配的子域和密码替换子域和密码。
conn = tg.TigerGraphConnection(host="https://SUBDOMAIN.i.tgcloud.io/", password="PASSWORD")
一旦运行，您就可以开始了！
第二步:创建您的模式和图表
现在我们已经连接到我们的解决方案，让我们创建一个新的图表，我们的 JobGraph。为此，我们将有六个顶点(工作、工作类型、职称、工资范围、公司和技能)和六条边。
print(conn.gsql('''CREATE VERTEX Job_Option(PRIMARY_ID job_id INT, job_link STRING, num_skills INT, num_reviews DOUBLE, num_stars DOUBLE)
CREATE VERTEX Job_Type(PRIMARY_ID job_type_id STRING) WITH PRIMARY_ID_AS_ATTRIBUTE="true"
CREATE VERTEX Job_Title(PRIMARY_ID job_title_id STRING) WITH PRIMARY_ID_AS_ATTRIBUTE="true"
CREATE VERTEX Salary_Range(PRIMARY_ID salary_range STRING) WITH PRIMARY_ID_AS_ATTRIBUTE="true"
CREATE VERTEX Company(PRIMARY_ID company_name STRING) WITH PRIMARY_ID_AS_ATTRIBUTE="true"
CREATE VERTEX Skill(PRIMARY_ID skill STRING) WITH PRIMARY_ID_AS_ATTRIBUTE="true"CREATE UNDIRECTED EDGE JOB_OPTION_JOB_TYPE(FROM Job_Option, TO Job_Type)
CREATE UNDIRECTED EDGE JOB_OPTION_JOB_TITLE(FROM Job_Option, TO Job_Title)
CREATE UNDIRECTED EDGE JOB_TYPE_JOB_TITLE(FROM Job_Type, TO Job_Title)
CREATE UNDIRECTED EDGE JOB_OPTION_SALARY_RANGE(FROM Job_Option, To Salary_Range)
CREATE UNDIRECTED EDGE JOB_OPTION_COMPANY(FROM Job_Option, To Company)
CREATE UNDIRECTED EDGE JOB_OPTION_SKILL(FROM Job_Option, To Skill)'''))
一旦你创建了顶点和边，把它们放在一起形成一个图，我们称之为 JobGraph。
print(conn.gsql('''CREATE GRAPH JobGraph(Job_Option, Job_Type, Job_Title, Salary_Range, Company, Skill,JOB_OPTION_JOB_TYPE, JOB_OPTION_JOB_TITLE, JOB_TYPE_JOB_TITLE, JOB_OPTION_SALARY_RANGE, JOB_OPTION_COMPANY, JOB_OPTION_SKILL)'''))
完美！通过按 Actions 和 GraphStudio 下的四个方块导航到 GraphStudio。
转到动作下的四个框，然后按“GraphStudio”(作者图片)
点击侧边栏中的“设计模式”。在那里，您将看到刚刚创建的模式！
查看 GraphStudio 中的模式(图片由作者提供)
第三步:更新你的图名和令牌
太棒了，我们快完成了！在加载数据和运行查询之前，让我们更新连接凭证。
conn.graphname = "JobGraph"conn.apiToken = conn.getToken(conn.createSecret())
完美！现在让我们输入数据。
第三部分:加载您的数据
第一步:创建一个 Kaggle 令牌
我们将从位于这里的 Kaggle 的 Indeed dataset 中获取数据。该数据包含数据科学家、数据分析师和数据工程师的工作信息。
https://www.kaggle.com/elroyggj/indeed-dataset-data-scientistanalystengineer
首先，在 kaggle.com 上创建一个帐户。
接下来，在主页中单击您的个人资料图片。在打开的边栏中，按下“帐户”
按下你的个人资料表，然后选择“帐户”(作者图片)
向下滚动页面，然后在 API 下，按“API 令牌过期”这将使任何现有的 API 过期。
按“过期 API 令牌”
接下来，按“创建新的 API 令牌”,它将自动下载您的令牌作为 kaggle.json。
按“创建新的 API 令牌”将下载“kaggle.json”(图片由作者提供)
完美！现在您已经有了 API 令牌，让我们在笔记本中加载数据。
第二步:从 Kaggle 加载数据
首先，您需要安装 Kaggle 库。
!pip install -q kaggle
接下来，让 Colab 提示您上传一个文件。上传刚刚下载的 kaggle.json 文件。
from google.colab import filesfiles.upload()
太棒了。现在让我们创建 Kaggle 文件夹并使其可访问，然后下载数据。我们将它存储在一个名为 data 的文件夹中。
! mkdir ~/.kaggle
! cp kaggle.json ~/.kaggle/
! chmod 600 ~/.kaggle/kaggle.json
! kaggle datasets list! kaggle datasets download -d elroyggj/indeed-dataset-data-scientistanalystengineer
! unzip indeed-dataset-data-scientistanalystengineer.zip -d data
! ls data
从结果来看！ls 数据，你会发现两个文件。有我们数据的文件是 indeed_job_dataset.csv(在 data 的目录下，所以 data/indeed_job_dataset.csv)。
ls 的结果(图片由作者提供)
太好了！现在让我们将数据加载到图表中。
第二步:将数据插入图表
让我们使用 pandas 创建一个 indeed_job_dataset.csv 的数据框架。
import pandas as pddata = pd.read_csv("data/indeed_job_dataset.csv")
接下来，让我们编辑一些列值和名称，以确保一切都可以向上插入。
data["id_val"] = [val for val in data["Unnamed: 0"]]
data = data.drop("Unnamed: 0", 1)data["Company"] = ["No Company Found" if type(i) != str else i for i in data["Company"]]
完美！现在我们的数据已经准备好了，让我们向上插入所有的顶点和边。
conn.upsertVertexDataFrame(data, "Job_Type", "Job_Type", attributes={"job_type_id": "Job_Type"})
conn.upsertVertexDataFrame(data, "Job_Title", "Job_Title", attributes={"job_title_id": "Job_Title"})
conn.upsertVertexDataFrame(data, "Salary_Range", "Queried_Salary", attributes={"salary_range": "Queried_Salary"})
conn.upsertVertexDataFrame(data, "Company", "Company", attributes={"company_name": "Company"})conn.upsertEdgeDataFrame(data, "Job_Option", "JOB_OPTION_SALARY_RANGE", "Salary_Range", "Job_Type", "Queried_Salary", attributes={})
conn.upsertEdgeDataFrame(data, "Job_Option", "JOB_OPTION_COMPANY", "Company", "Job_Type", "Job_Title", attributes={})
conn.upsertEdgeDataFrame(data, "Job_Type", "JOB_TYPE_JOB_TITLE", "Job_Title", "Job_Type", "Job_Title", attributes={})
conn.upsertEdgeDataFrame(data, "Job_Option", "JOB_OPTION_JOB_TITLE", "Job_Title", "id", "Job_Title", attributes={})
conn.upsertEdgeDataFrame(data, "Job_Option", "JOB_OPTION_JOB_TYPE", "Job_Type", "id", "Job_Type", attributes={})
由于“Skills”是数据帧中的一个列表，我们将分别向上插入每个顶点和边，而不是通过数据帧。运行此代码块以加载技能:
for job in range(len(data["Skill"])):
if type(data["Skill"][job]) == str:
for skill in eval(data["Skill"][job]):
conn.upsertVertex("Skill", skill, attributes={"skill": skill})
conn.upsertEdge("Job_Option", job, "JOB_OPTION_SKILL", "Skill", skill)
之后，我们将所有数据加载到我们的图表中！现在我们的图表已经准备好了，让我们开始查询我们的数据，从标题中提出问题。
第四部分:编写查询
问题 1:总体而言，什么是最受欢迎的技能(对于数据科学家、数据分析师和数据工程师而言)？
首先，我们来找最热门的整体技能。
conn.gsql('''USE GRAPH JobGraphDROP QUERY topSkillsCREATE QUERY topSkills () FOR GRAPH JobGraph {SumAccum<INT> @connectedJobs;Seed = {Job_Option.*};Res = SELECT tgt FROM Seed:s - (JOB_OPTION_SKILL:e) - Skill:tgt
ACCUM tgt.@connectedJobs+=1
ORDER BY tgt.@connectedJobs DESC
LIMIT 5;PRINT Res;}INSTALL QUERY topSkills''')
结果如下:
[
{
"Res": [
{
"attributes": {
"[@connectedJobs](http://twitter.com/connectedJobs)": 466,
"skill": "Python"
},
"v_id": "Python",
"v_type": "Skill"
},
{
"attributes": {
"[@connectedJobs](http://twitter.com/connectedJobs)": 434,
"skill": "Machine Learning"
},
"v_id": "Machine Learning",
"v_type": "Skill"
},
{
"attributes": {
"[@connectedJobs](http://twitter.com/connectedJobs)": 417,
"skill": "R"
},
"v_id": "R",
"v_type": "Skill"
},
{
"attributes": {
"[@connectedJobs](http://twitter.com/connectedJobs)": 351,
"skill": "SQL"
},
"v_id": "SQL",
"v_type": "Skill"
},
{
"attributes": {
"[@connectedJobs](http://twitter.com/connectedJobs)": 203,
"skill": "Data Mining"
},
"v_id": "Data Mining",
"v_type": "Skill"
}
]
}
]
因此，总而言之，最受欢迎的技能是:
- 计算机编程语言
- 机器学习
- 稀有
- 结构化查询语言
- 数据挖掘
完美！我们可以编写更多的查询来继续探索，但是我们现在已经回答了我们的主要问题。
第五部分:祝贺你！
恭喜你完成这篇博客！在这里，您了解了如何创建一个职位图来确定与数据相关的职位的主要技能。
如果您有任何问题，请随时加入 TigerGraph Discord 或在 TigerGraph 社区论坛中提问。
浙公网安备 33010602011771号