TowardsDataScience 博客中文翻译 2020（二百五十四）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

利用脸书先知预测犯罪率

原文：https://towardsdatascience.com/crime-rate-prediction-using-facebook-prophet-5348e21273d?source=collection_archive---------39-----------------------

充分利用 FB Prophet 进行时间序列预测的指南

I mg 通过链接从 unsplash】

时间序列预测是任何数据科学家都必须知道的技术之一。像预测天气、产品销售、购物中心的客户访问或要维护的库存数量等问题都与时间序列预测有关，这使它成为数据科学家技能组合的重要补充。

在这篇文章中，我将介绍**如何使用脸书预言家预测芝加哥的犯罪率。**分成 5 部分:

1.先知游戏攻略

2.电子设计自动化(Electronic Design Automation)

3.数据处理

4.模型预测法

5.外卖食品

让我们开始旅程吧🏃‍♀️🏃‍♂️.

1。先知介绍

2017 年，脸书核心数据科学团队开源 Prophet🎉🎉。正如其 Github 页面所述，Prophet 是:

• 预测时间序列数据的程序；
• 基于附加模型；
• 用每年、每周和每天的季节性以及假日效应来拟合非线性趋势。

Prophet 使用一个可分解模型，该模型有三个主要部分，包括趋势、季节性和假期，组合如下:

其中:

• g(t) 是对非周期性变化建模的趋势函数；
• s(t) 表示周期性变化(例如，每周和每年的季节性)；
• h(t) 表示节假日对潜在不规则时间表的影响；
• 误差项表示模型不适应的任何特殊变化。

因此，使用时间作为回归变量，Prophet 试图将时间的线性和非线性函数拟合为组件。实际上，Prophet 将预测问题框定为曲线拟合练习，而不是查看每个观察的基于时间的依赖性，这带来了灵活性、快速拟合和可解释的参数。

Prophet 最适用于具有强烈季节效应的时间序列和几个季节的历史数据。

2。EDA

这里使用的数据是来自 Kaggle 的芝加哥犯罪数据集。它包含了 2001 年至 2017 年发生在芝加哥市的已报告犯罪的汇总。

快速查看下面的数据，您会注意到数据集有 23 列和 7，941，282 条记录，包括 ID、案例号、块、主要类型、描述等。

芝加哥原始犯罪数据集一览

首先，让我们删除未使用的列。具体来说，

df.drop([‘Unnamed: 0’, ‘ID’, ‘Case Number’, ‘IUCR’, ‘X Coordinate’,  ‘Y Coordinate’,’Updated On’,’Year’, ‘FBI Code’, ‘Beat’,’Ward’,’Community Area’,‘Location’, ‘District’, ‘Latitude’, ‘Longitude’],
axis = 1, inplace=True)

图 1 删除列后的数据视图

如图 1 所示，*【日期】*栏为日期格式。让我们将它转换成熊猫可以理解的日期格式，并将其设置为索引。具体来说，

df.Date = pd.to_datetime(df.Date, format = ‘%m/%d/%Y %I:%M:%S %p’)
df.index = pd.DatetimeIndex(df.Date)
df.drop(‘Date’, inplace = True, axis = 1)

现在，数据可以进行可视化了。**首先，让我们看看每年的犯罪分布。**具体来说，

plt.plot(df.resample(‘Y’).size())
plt.xlabel(‘Year’)
plt.ylabel(‘Num of crimes’)

注意上面的 df.resample('Y ')。size() 产生年度犯罪计数。

如图 2 所示，从 2002 年到 2005 年，犯罪率开始下降。但是从 2006 年开始，犯罪率开始上升，在 2009 年达到顶峰，然后一直下降到 2018 年。这条曲线可能反映了经济对社会犯罪的影响。金融危机前后，犯罪率逐年下降，但金融危机导致的经济不景气导致犯罪率上升。

图 2 犯罪率的年度分布

其次，我们来看一下季度犯罪率分布。如图 3 所示，犯罪率呈周期性起伏的下降趋势。

图 3 犯罪率的月度分布

同样，如图 4 所示，月度犯罪率显示出与季度分析相同的模式。

图 4 犯罪率的季度分布

3。数据处理

Prophet 的输入始终是包含两列的数据帧:“ds”和“y”。“ds”(datestamp)列应该是 Pandas 所期望的格式，最好是 YYYY-MM-DD 表示日期，或者 YYYY-MM-DD HH:MM:SS 表示时间戳。“y”列必须是数字，代表我们希望预测的测量值。

具体来说，

df_m = df.resample(‘M’).size().reset_index()
df_m.columns = [‘Date’, ‘Monthly Crime Count’]
df_m_final = df_m.rename(columns = {‘Date’: ‘ds’, ‘Monthly Crime Count’: ‘y’})

4。模型预测

从 EDA 分析中，我们发现有的月度和季度季节性，而没有 的年度季节性。 默认情况下，如果时间序列超过两个周期，Prophet 适合每周和每年的季节性。用户可以使用“添加季节性”方法添加季节性，如每小时、每月和每季度。

要进行预测，请实例化一个新的 Prophet 对象，并调用 fit 方法对数据进行训练。具体来说，

*m = Prophet(interval_width=0.95, yearly_seasonality=False)
m.add_seasonality(name=’monthly’, period=30.5, fourier_order=10)
m.add_seasonality(name=’quarterly’, period=91.5, fourier_order=10)
m.fit(df_m_final)*

注意 ‘interval_width=0.95’ ，产生一个围绕预测的置信区间。Prophet 使用部分傅立叶和来近似周期信号。傅立叶级数决定了季节性变化的速度。

预测是在一个数据帧上进行的，该数据帧有一列‘ds’包含要进行预测的日期。例如，要预测接下来的 24 个月，请尝试以下方法:

*future = m.make_future_dataframe(periods = 24, freq = ‘M’)
pred = m.predict(future)*

如图 5 所示，预测值’ yhat’ 被分配给具有下限和上限的每个日期。

图 5 预测结果

如图 6 所示，黑点是历史数据，深蓝线是模型预测。浅蓝色阴影是预测值周围 95%的置信区间。蓝线显示与图 3 中的模式匹配良好，表明对历史数据的预测良好。😇😇

图 6 预测图

最后，图 7 显示了✨✨.犯罪率模式的非周期性趋势以及月度和季度季节性成分

图 7 预测模式组件图

5。外卖

我们介绍了如何充分利用脸书先知。具体来说，

• 使用 EDA 来探索历史数据模式，帮助创建最合适的模型
• 使用数据处理为建模准备数据
• 利用 Prophet 拟合历史数据，预测未来犯罪率

如果你觉得这篇文章有帮助，请随意点击👏s！如果想看用 Python 实现的代码，看我的仓库 这里 。🤞🤞🤞

参考:

1.脸书先知官方文件

2.先知论文:Sean J. Taylor，Benjamin Letham (2018)大规模预测。美国统计学家 72(1):37–45(https://peerj.com/preprints/3190.pdf)。

CRISP-数据挖掘和大数据领域的数据挖掘方法领导者

原文：https://towardsdatascience.com/crisp-dm-methodology-leader-in-data-mining-and-big-data-467efd3d3781?source=collection_archive---------3-----------------------

机器学习方法的一步一步的简短指南

图片来自Pixabay【1】的二面体

2015 年 3 月，我与 Alberto Cavadia 和 Juan Gómez 合作撰写了一篇名为“大数据项目开发的方法论商业建议”的论文[2]。当时，我们意识到大数据项目通常有 7 个部分。

不久之后，我在论文中使用了 CRISP-DM 方法，因为它是一个开放的标准，在市场上广泛使用 [3]，而且(感谢之前的论文)我知道它与其他方法非常相似。

论文结论与 CRISP-DM 步骤之间的比较 Israel Rodrigues

随着我的数据层职业生涯的发展，我不可避免地注意到 CRISP-DM 方法仍然非常相关。实际上，数据管理单元和 IT 配置文件是围绕这种方法的步骤构建的。所以我决定，写一个小故事，来描述长期成功方法的步骤。

肯尼斯·简森的图片描述了步骤【4】

CRISP-DM 代表数据挖掘的跨行业标准过程，是 1996 年为塑造数据挖掘项目而创建的方法。构思一个数据挖掘项目包括 6 个步骤，并且可以根据开发人员的需要进行循环迭代。这些步骤是业务理解、数据理解、数据准备、建模、评估和部署。

第一步是业务理解，其目标是给出目标和数据的上下文，以便开发人员/工程师了解特定业务模型中数据的相关性。

它包括会议、在线会议、文档阅读、特定的现场学习，以及他们帮助开发团队的一长串方法，提出关于相关上下文的问题。

这一步的结果是开发团队理解了项目的上下文。项目的目标应该在项目开始前定义。例如，开发团队现在应该知道目标是增加销售，在这一步结束后，了解客户销售什么以及他们如何销售。

第二步是数据理解，其目标是了解从数据中可以预期和实现什么。它从几个方面检查数据质量，如数据完整性、值分布、数据治理合规性。

这是项目的关键部分，因为它定义了最终结果的可行性和可信度。在这一步，团队成员就如何提取信息的最佳价值进行头脑风暴。如果开发团队不清楚某些数据的用途或相关性，他们可以暂时后退一步，了解业务以及它如何从这些信息中受益。

由于这一步骤，数据科学家现在知道，就数据而言，结果应该满足项目的目标，什么算法和过程产生该结果，数据的当前状态如何，以及它应该如何，以便对所涉及的算法和过程有用。

伊斯罗德里格的一些数据理解技巧

第三步是数据准备，涉及 ETLs 或 ELTs 过程，通过算法和过程将数据片段转化为有用的东西。

有时，数据治理策略在组织中没有得到尊重或设置，为了赋予数据真正的意义，标准化信息成为数据工程师和数据科学家的工作。

同样，一些算法在某些参数下表现更好，一些算法不接受非数字值，另一些算法在值的方差很大的情况下不能正常工作。话又说回来，标准化信息是开发团队的责任。

大多数项目在这一步花费了大部分时间。这一步，我相信，是有一个 IT 概况称为数据工程师的原因。由于这非常耗时，在处理大量数据时会变得非常复杂，因此 IT 部门可以利用专门的资源来执行这些任务。

第四步是建模，是任何机器学习项目的核心。这一步负责应该满足或帮助满足项目目标的结果。

虽然这是项目中最吸引人的部分，但也是时间最短的部分，就好像之前的一切都做得很好，几乎没有什么需要调整的。如果结果是可改进的，该方法将返回到数据准备并改进可用数据。

一些算法，如 k-means、层次聚类、时间序列、线性回归、k-最近邻等，是该方法中这一步的核心代码行。

以色列罗德里格斯的一些建模技巧

第五步是评估，由它来验证结果是否有效和正确。如果结果是错误的，该方法允许回顾第一步，以了解为什么结果是错误的。

通常，在数据科学项目中，数据科学家将数据分为训练和测试。在这一步中，使用测试数据，其目的是验证模型(建模步骤的产品)是否与现实相符。

根据任务和环境的不同，有不同的技术。例如，在监督学习的环境中，对于分类项目的任务，一种验证结果的方法是使用混淆矩阵。对于无监督学习，进行评估变得更加困难，因为没有静态值来区分“正确”和“不正确”，例如，对项目进行分类的任务将通过计算(一些)聚类中元素之间的内部和内部距离来评估。

在任何情况下，指定一些误差测量源都是很重要的。这个误差度量告诉用户他们如何对结果有信心，或者是“肯定这将工作”或者“肯定它不会”。如果在所有情况下，误差度量恰好为 0 或没有，这将表明模型过拟合，而现实可能表现不同。

第六步也是最后一步是部署，它包括以有用和可理解的方式呈现结果，通过实现这一点，项目应该实现其目标。这是唯一不属于循环的步骤。

根据最终用户的不同，有用和可理解的方式可能会有所不同。例如，如果最终用户是另一个软件，就像销售网站程序询问其推荐系统向购买者推荐什么一样，一种有用的方式是 JSON 携带对特定查询的响应。在另一种情况下，就像一位高层管理人员需要计划的信息来进行决策一样，呈现这些发现的最佳方式是将其存储在分析数据库中，并作为商业智能解决方案的仪表板来呈现。

一些部署的例子由以罗德里格

我决定写这篇简短的描述/解释，因为我对这种方法的长期相关性感到惊讶。这种方法已经存在很长时间了，而且看起来它会流行更久。

这种方法非常符合逻辑，并且向前推进了一步。因为它评估数据挖掘项目的所有方面，并允许对其执行进行循环，所以是健壮的和可信的。毫不奇怪，大多数开发人员和项目经理都选择它，而且备选方法非常相似。

我希望这篇简短的介绍，能够帮助 IT 专业人员对他们的任务的方法开发进行论证。信息学的其他几个领域可以阅读这个故事，并基本了解数据科学家正在做什么，以及它与数据工程师和商业智能等其他方面的关系。

我希望你喜欢它，因为这是我的第一个故事:)。

参考资料:

[1] algedroid，Team，Work，Business，Cooperation (2019)，URL:https://pix abay . com/photos/Team-Work-Business-Cooperation-4503157/

[2] Alberto Cavadia，Juan Gómez，e . Israel rodríguez，大数据项目发展的方法建议(2015 年)，《数据科学论文》

[3] Gregory Piatetsky ， CRISP-DM，仍然是分析、数据挖掘或数据科学项目的顶级方法论(2014)，URL:https://www . kdnugges . com/2014/10/CRISP-DM-top-methodology-analytics-data-mining-data-science-projects . html

[4] Kenneth Jensens，显示 CRISP-DM (2012)不同阶段之间关系的流程图，URL:https://es . Wikipedia . org/wiki/Cross _ Industry _ Standard _ Process _ for _ Data _ Mining #/media/Archivo:CRISP-DM _ Process _ diagram . png

基于可视化理论的清晰 python 绘图

原文：https://towardsdatascience.com/crisp-python-plots-based-on-visualization-theory-5ac3a82c398e?source=collection_archive---------15-----------------------

是时候从 Matplotlib 升级到 Plotly 了——下面是方法和原因。

P 实际上，这个帖子是我们都可以从经典中学习到的一大块东西，量化信息的可视化展示 —爱德华·塔夫特。我还介绍了如何用 Python 实现它。

展示信息的支柱

卓越的图形

这就是演示文稿的质量。通过删除多余的形状、分散注意力的颜色和不一致的字体，您的数据将更容易被查看。根据我的经验(以及爱德华·塔夫特的经验)，优秀的图形来自于许多小变化的累积收益。你地块上的每一滴墨水都很重要。

图形完整性

这就是演讲的真相。通过确保您的坐标轴正确缩放并反映趋势，您的数据将得到更真实的解释。从长远来看， 真相总是更有价值 。每个人都见过其中一个用非线性 y 轴使假设看起来更强的图——发誓永远不这样做。

本教程是你需要的几行代码，可以清晰真实地显示你的数据。

如果你对你的数据感兴趣，我会拿一份。

对于所有的数据科学家和信息书呆子来说， 定量信息的可视化显示 是最终的茶几书。它是展示信息书籍中无可争议的王者，这是有原因的，而且阅读起来也很愉快。

我一直在使用其中概述的方法，在我的机器人和机器学习研究论文中创建强大的情节。下面是几个摘录，由于 Medium 缺乏渲染 pdf 图像(目前)，请进行缩减采样。

左)散点图具有内在的密度感。右图)通过线条+标记绘制的彩色轨迹分散对象。

这个职位有三个目标。

1. 我想确保每个人都理解他们在使用默认绘图功能时犯的一些关键错误。
2. 向我的听众介绍 Plotly ，他与数据打交道，并在人工智能和数据领域探索自我完善的文章。
3. 涵盖可视化理论的基础知识，以及在拥挤的数字领域中让你的作品吸引眼球的先进技术。

包含的代码摘自我的教程报告中的plot.py,我将扩展它以包含 3d 绘图、动画等的最佳实践。

[## NATO Lambert/绘图-基础

Plotly 和 Matplotlib 中干净地块基础的代码行集合— natolambert/plotting-basics

github.com](https://github.com/natolambert/plotting-basics)

T utorial 从这里开始。本教程将同时使用两种绘图工具— Matplotlib 和 Plotly。

左— Matplotlib 徽标，右— Plotly 徽标。

1. Matplotlib :老旧的绘图引擎驱动着那么多遗留的实验代码，工程师的拐杖卡在了过去。
2. plottly:数据科学、分析学以及我的职业生涯的未来。

自始至终，我认为 plotly 为用户提供了更多的工具来保持图形的优秀和完整性。

0.设置

这是我们要建立的情节。小杂乱，简单的数据。更高级表现的平台。

我在这篇文章的最后包括了设置(导入和数据加载)，所以人们可以根据需要复制它。依赖性的障碍很低，所以我们可以很容易地获得顶层绘图和安全保存机制。更少的依赖意味着更多的人会借鉴、复制和构建你的作品。

• 易于开发的绘图工具:matplotlib、matplotlib.pyplot、plotly、 plotly.graph_objects
• 数学和数据工具:numpy，pandas
• 系统工具:os，sys

初始化绘图

创建新数据可视化的第一步可能会给用户带来失败。 总是创建一个轴或一个特定的图形对象 。这允许完全控制数据以何种方式发送到哪里。

Plotly 已经领先一步。使用子图时，图形会根据每一行和每一列进行索引，而不是根据 matplotlib 中必须跟踪的轴列表进行索引(当 n=1 时，plt.subplots调用有效)。

###### Init plot / subplots ######
# mpl
fig_mpl, ax = plt.subplots()# plotly
fig_plo = plotly.subplots.make_subplots(rows=1, cols=1)###### add data ######
for i in range(0, 4):
    # mpl
    ax.plot(...)

    # plotly
    fig_plo.add_trace(go.Scatter(...))

1.删除额外信息

网格线应该消失

数字和印刷混乱的最终来源是网格线。即使渲染成 PDF 格式，网格线看起来也不是很好(缩小来看看网格线是什么样子)，而且它们很少帮助专注的读者理解。让趋势自己说话。

# mpl
ax.grid(False)#plotly
fig.update_layout(xaxis_showgrid=False, yaxis_showgrid=False)

多余的框线是没有用的

使用空白。在任何媒介中，空间都是有限的。将您的数据装箱会从页面中移除宝贵的空间，而您可以在这些空间中呈现数据。右边和上面的线应该去掉，但是有时候左边和下面的线很漂亮。

# mpl
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.set_xlabel("Year")
ax.set_ylabel("Market Share (%)")# plotly
fig_plo.update_xaxes(title_text="Year", linecolor='black', 
                     row=1, col=1, zeroline=True,)
fig_plo.update_yaxes(title_text="Market Share", linecolor='black',
                     row=1, col=1, zeroline=True,)

掌控你的传奇

总会有快速读者在剧情中跳跃。总是有一个传奇人物来回答他们的问题。Plotly 拥有令人难以置信的图例工具，如分组、始终可见的隐藏项目，以及显示所选图例条目子集的交互式绘图。

使用交互式 plotly 仪表板，让您的用户看到完整的数据，并了解他们想要的内容。

# mpl
ax.legend()# plotly
fig_plo.update_layout(showlegend=True,)

plotly 仪表盘的一个例子— 来源。

2.一致的字体

尺寸很重要&与你的媒介相匹配

字体往往被忽视。将 Arial 字体的字体放入 Times 字体的复杂报表中，看起来总是不合适。缩放字体大小以匹配文本(几乎)并始终匹配字体。

# mpl
font = {'size': 24, 'family': 'serif', 'serif': ['Times']}
matplotlib.rc('font', **font)
matplotlib.rc('text', usetex=True)# plotly
fig_plo.update_layout(font=dict(
                            family="Times New Roman, Times, serif",
                            size=24,
                            color="black"
                            ),
                  )

3.可印刷的

移除背景并使用高分辨率

总是在你的图上提高分辨率。默认情况下，它们是低 dpi 和小尺寸的，所以把它们投影到屏幕上几乎没有用。 *Plotly 允许您设置查看和保存的分辨率，因此您可以在显示时准确地看到将要保存的图形，*这是一个成功之处，当您尝试它时就会明白。

Matplotlib 将保存和查看分开，这使您生成与使用savefig()不同的图with show()，并导致头痛。

# mpl
ax.set_facecolor((1, 1, 1))
# no resolution tool until saving :(# plotly
fig_plo.update_layout(plot_bgcolor='white',)
fig_plo.update_layout(width=1000, height=1000,)

4.在头脑中使用屏幕

另存为 PDF

可移植文档格式(PDF)将您的绘图保存为一系列彩色矢量对象，因此当它在屏幕上移动或移动到新设备时，它会被再次渲染。 PDF 将使你在演示文稿或手稿中再也不会有像素化的情节。

# mpl
plt.savefig(os.getcwd()+"plop_mpl.pdf", dpi=300)
plt.show()# plotly
fig_plo.write_image(os.getcwd()+"plot_plotly.pdf")
fig_plo.show()

低对比度颜色

屏幕上漂亮的颜色。柔软，独特，由我独特设计。

屏幕绘图的一个微妙之处是使用哪种颜色。颜色应该是 1)可区分的和 2)悦目的。这最终被*淘汰，*核心色。看看下面可用的颜色图，但首先我有一些经过测试的颜色。

我的颜色天蓝色T2、红苹果T3、苔绿、芥末黄T5。下面是查看 matplotlib 和 plotly 中一些颜色的链接。

[## 在 Matplotlib - Matplotlib 3.1.0 文档中选择色彩映射表

Matplotlib 有许多内置的色彩映射表，可以通过。还有外部库，如[palettable]和…

matplotlib.org](https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html) [## 离散颜色

同样，笛卡尔坐标中标记的 X 或 Y 位置可以用来表示连续值…

plotly.com](https://plotly.com/python/discrete-color/)

输出

在继续滚动之前，仔细看看这些图。看哪个更一致，更无 bug。然后你就可以决定用哪个平台了。其中一个里面的 bug 来自源头，无法避免，这对于我来说是不成立的立场。

左)Matplotlib，右)Plotly。Matplotlib 版本的 auto-legend location 是一个彻底的失败，一些字体没有得到正确的转换，并且总的来说不够清晰。

我是 team plotly(右上方)，无 bug 且敏锐。

Plotly 的改进版本

Plotly 的 API 有一个很容易访问的工具，几乎可以用于绘图中的每个设置，你可以通过一两行代码批量传递它们。这里是我喜欢的情节中的调整(偏好)的集合。它允许您 a)控制图例形状和位置，b)删除绘图周围的空白。试一试，看看 API——您会发现大量的工具。

# advanced 
fig_plo.update_layout(legend_orientation="h",
                  legend=dict(x=.6, y=0.07,
                              bgcolor='rgba(205, 223, 212, .4)',
                              bordercolor="Black",
                              ),
                  margin=dict(r=10, l=10, b=10, t=10),
                  )

[## plotly - 4.6.0 文档的 Python API 参考

这是 plotly 的 API 的参考。另请参见 plotly 的文档网站。

plotly.com](https://plotly.com/python-api-reference/)

通过更好的可视化向前迈出一步。来源—作者。

不太花哨的细节:

进口

下面是我如何为绘图脚本/模块构建我的导入。

# file tools
import os
import sys# plotting tools
import plotly
import plotly.graph_objects as go
import seaborn as sns
import matplotlib
import matplotlib.pyplot as plt# Core
import numpy as np

数据

我从本教程中使用的数据是从一个 plotly 线绘图的例子。你可以在这里查看。值得注意的一点是，plotly 有很好的色彩科学——柔和的颜色在数字观看时更容易被眼睛看到(较低的总颜色数 r+g+b)。

# Frome [https://plotly.com/python/line-charts/](https://plotly.com/python/line-charts/)
title = 'Main Source for News'
labels = ['Television', 'Newspaper', 'Internet', 'Radio']
colors = ['#1f77b4',  # muted blue
          '#ff7f0e',  # safety orange
          '#2ca02c',  # cooked asparagus green
          '#d62728',  # brick red
          ]mode_size = [8, 8, 12, 8]
line_size = [2, 2, 4, 2]x_data = np.vstack((np.arange(2001, 2014),)*4)y_data = np.array([
                   [74, 82, 80, 74, 73, 72, 74, 70, 70, 66, 66, 69],
                   [45, 42, 50, 46, 36, 36, 34, 35, 32, 31, 31, 28],
                   [13, 14, 20, 24, 20, 24, 24, 40, 35, 41, 43, 50],
                   [18, 21, 18, 21, 16, 14, 13, 18, 17, 16, 19, 23],
                   ])

敬美丽的情节！

更多？订阅我关于机器人、人工智能和社会的时事通讯！

[## 自动化大众化

一个关于机器人和人工智能的博客，让它们对每个人都有益，以及即将到来的自动化浪潮…

robotic.substack.com](https://robotic.substack.com/)

从数据科学的角度看促成秋粘虫传播的关键因素

原文：https://towardsdatascience.com/critical-factors-contributing-to-the-spread-of-fall-armyworms-from-a-data-science-perspective-a1fec38cff32?source=collection_archive---------43-----------------------

Shravani Basu 博士、Á·安赫尔·德贾恩·戈塔雷多纳博士、Sébastien Foucaud 博士和 Mukti Sadhan Basu 博士——SBSF 咨询公司

研究的目标

尽管在美国本土的热带和亚热带地区已经存在了几十年，秋粘虫(草地夜蛾)；一汽)在开始传播到非洲和世界其他地方之前，并没有被深入研究。因此，从这种害虫的爆发中获得的信息非常有限，这种害虫正在各大洲迅速变得难以根除。减轻虫害带来的巨大损失的唯一方法是详细了解虫害，并制定多管齐下的作物保护和虫害控制策略。

这项研究试图通过结合三个不同的数据集，提供 FAW 潜在爆发的补充信息，阐明有利于 FAW 传播的条件。

由于粮农组织使用的数据收集方法的局限性，综合数据集不允许建立预测模型。因此，这项研究的重点是提取推动一汽在非洲传播的特征，因为大部分数据都是在非洲收集的。

虽然基于非洲数据集，但我们进行分析的方式使得研究结果可以扩展到全球任何一汽事故。

秋季粘虫:全球威胁

FAW 蛾的幼虫期是一种害虫，以 350 多种植物物种为食，对重要的经济作物如玉米、水稻、高粱等造成广泛损害；棉花、甘蔗、花生等经济作物；水果作物，如苹果和橘子，以及蔬菜作物等。然而，玉米仍然是优选的宿主。因为毛虫吃了太多的植物，它们对作物的存活和产量非常有害。

据粮农组织称，非洲每年损失多达 1800 万吨玉米，足以养活数千万以玉米为主要作物的人，这意味着非洲大陆的经济损失高达 46 亿美元。此外，针对具体国家的研究表明，一汽暴露与杀虫剂使用强度之间存在正相关。有几种控制一汽虫害的措施，但并没有显著减少损失。

一汽疫情于 2016 年在非洲发现，此后蔓延至包括中东和大洋洲在内的亚洲。这种昆虫繁殖迅速，每年繁殖几代，饮食多样化，可以通过迁移到不同的地方(跨洲)或躲藏起来，在条件更有利的时候跳回来，在恶劣的条件下生存。这种蛾每晚能飞 100 公里。雌蛾在产卵前可以迁移 500 公里。然而，这种昆虫不适应低温。它们不能在低于 0℃的温度下迁徙和繁殖。由于全球变暖，暖冬为一汽大规模繁殖创造了良好的条件。

图 1: 秋粘虫生活史图。节选自 FAO 的一汽指南。

图 2: 一汽虫害的早期在植物上留下白色斑块(照片由印度班加罗尔农业科学大学 G. Keshavareddy 博士提供)。

图 3: 晚熟幼虫破坏轮纹，使其外观粗糙(照片由印度班加罗尔农业科学大学 G. Keshavareddy 博士提供)。

图 4: 相对早期阶段玉米棒的发病率(照片由印度班加罗尔农业科学大学 G. Keshavareddy 博士提供)。

FAW 造成的全球虫害和国家损害的程度详见粮农组织 2020 年 1 月至 3 月的《食物链危机预警公报》 №34 。这里简要介绍了风险最大的国家的情况以及所报告的破坏规模。

在非洲:

安哥拉 -据报道，2017 年，一汽有超过 19，000 公顷的玉米、小米和高粱作物被毁，造成约。180 万美元的损失。

埃塞俄比亚——FAW 攻击四季种植的玉米:主雨季、短雨季、灌溉玉米。在该国，超过 458 个玉米种植区受到一汽的影响。

马拉维——在 2016/17 年主雨季(11 月-3 月)首次报道了一汽的存在。这种害虫对全国的玉米、反季节灌溉玉米(4 月-10 月)和小麦等其他作物造成了严重损害。在 2017/18 年准备收获季节(11 月至 3 月)，政府宣布因虫害而进入灾难状态。

乌干达——乌干达所有 121 个地区(100%的领土)都证实了这种害虫的存在。

南苏丹 -全国各地(全国所有前 10 个州)都证实了一汽的存在。实地观察和农民报告表明，当作物受到水分胁迫时，FAW 虫害严重。

斯威士兰——2016/17 赛季首次报道了一汽的存在。这种害虫对全国各地的高粱、小米和玉米造成了严重损害，一直持续到 2017/18 赛季。

埃及(北非)- 一汽自 2019 年 5 月起在埃及南部玉米地正式报道。法奥得以穿越撒哈拉沙漠的天然屏障。因此，北非国家面临风险。

苏丹- 自 2017 年以来，已有来自苏丹的 FAW 报告，尼罗河流域可能被认为是传入埃及的可能途径。埃及和苏丹的气候允许许多寄主植物连续种植，这增加了害虫传播和破坏的可能性。

坦桑尼亚、赞比亚和津巴布韦——在 2016/17 年度首次报告了一汽的存在，该虫害在 2017/18 年度生产季节(11 月至 3 月)继续对玉米造成损害。

在亚洲:

孟加拉- 一汽于 2018 年 8 月首次被检出。从那以后，它传播到了全国的几个地方。

柬埔寨- 截至 2019 年 6 月 11 日，柬埔寨共有 11，142 公顷的玉米作物被销毁，其中拜林省 2，544 公顷，马德望省 3，033 公顷，班迭棉吉省 4，715 公顷，以及 Tboung Khmum 省 850 公顷。

缅甸 -根据农业、畜牧业和灌溉部的数据，自 2019 年 1 月的第一周以来，一汽入侵了该国的玉米田。FAW 在伊洛瓦底地区得到确认，然后在同一年的短时间内传播到 9 个邦/地区。伊洛瓦底省大约有 4 046 公顷的土地受到影响。

**印度尼西亚-**2019 年 3 月在西苏门答腊首次检出一汽。在四个月内，这种害虫已经蔓延到苏门答腊、爪哇和加里曼丹部分地区的 12 个省。

菲律宾- 到 2019 年 6 月，东内格罗斯省马比奈当地政府宣布，一汽袭击了这个山城 32 个镇中的 28 个。

斯里兰卡 - FAW 主要在阿努拉德普勒、莫纳拉加拉和安帕赖地区感染玉米，但在该国几乎所有地区的农场中都发现了。FAW 在上述三个地区种植玉米的总面积分别为 61，010 公顷和 34，856 公顷。此外，据报道，一汽已蔓延到水稻、番茄、小米、绿豆和一些牧草品种，如甘蔗。在斯里兰卡种植的 82，000 公顷中，据报道有 43，037 公顷被 FAW 侵染。该国的作物总损失估计在 10%到 25%之间。

也门(西亚)-自 2018 年以来，一汽的传入和存在一直被报道，这增加了传入阿曼和沙特等邻国的风险。

中国——未列入粮农组织报告，但据新闻报道2020 年 3 月 5 日，中国政府在新闻发布会上承认一汽于 2018 年首次入侵中国。南部和西南部省份受影响最大。中国当局发现，从 11 月到 2019 年 1 月，中国南部和西南部的小鹿数量正在增加。受灾面积达 4 万公顷，是去年同期的 90 倍。由于这种害虫已经侵袭了邻国老挝的 80，000 多公顷土地，当局预测中国可能会出现更糟糕的情况。

根据中国农业和农村事务部发布的指导方针，一汽北移将比去年提前一个月。一旦他们向北移动，黄河和淮河周围地区 50%的玉米地将受到威胁。

一汽也从 2019 年 6 月开始在台被举报。根据动植物卫生检验检疫局(BAPHIQ)的数据，截至 2019 年 7 月 10 日，台湾已有 199 起确认的一汽目击事件，超过 50 公顷的玉米地受到影响。

印度——不是来自粮农组织的报告，而是独立核实，根据国家农业昆虫资源局(NBAIR)2018 年 7 月进行的一项调查，第一次报道 FAW 是在卡纳塔克邦(印度南部)的 Chikkaballapur 区的田地里。这种害虫已经摧毁了卡纳塔克邦 70%以上的农作物，现在已经蔓延到印度南部、西部、北部和东北部。玉米种植面积约为 930 万公顷，年产量接近 2800 万吨。

澳大利亚——FAW 没有被包括在粮农组织的报告中，它已经在北领地和西澳大利亚北部的多个地区被检测到，并可能很快威胁昆士兰州 Wide Bay 地区的农作物。农业和渔业部表示，自今年 2 月在澳大利亚发现 FAW 以来，仅在玉米、高粱和大豆作物中发现过 FAW。如果成立，一汽有可能成为澳大利亚北部棉花的害虫。

数据集

我们为这项研究合并了三个互补的、公开的数据集。

1. 本研究中使用的核心数据集是在联合国粮食及农业组织(FAO)为全球秋季粘虫控制行动( 秋季粘虫)发起的项目下收集的数据，该项目对 FAW 爆发的病例进行了分类，主要发生在非洲国家。一汽监测预警系统(FAMEWS) 由一个分发给农民用于数据收集的移动应用程序和一个用于绘制当前情况的全球平台组成。这些数据大多由农民自己直接在 FAMEWS 应用程序中收集，使用两种检测技术:使用信息素陷阱收集昆虫(一汽指导说明 3 )或侦察田地(秋粘虫侦察)。本研究使用的数据集版本涵盖了 2018 年 2 月 27 日至 2019 年 9 月 30 日之间登记的病例。所选数据集包括 39013 个案例，每个案例测量了 44 个变量。不幸的是，粮农组织的这个数据集不再在他们的网站上免费提供了。
2. 结合 FAW 疫情数据集，我们使用了饥荒预警系统网络(FEWS 网)陆地数据同化系统(FLDAS)中 VIC 模型的再分析天气数据。这些数据的分辨率为 0.25 度，覆盖了从 2001 年 1 月到现在的整个非洲大陆(在这项研究中，我们使用了 2018 年 2 月到 2019 年 10 月之间的可用数据)。时间分辨率是每日的。有关数据集的更多信息，请访问: FLDAS:项目目标。从模型中总共提取了 21 个变量，包括降水量、温度和风速，并在 FLDAS 模型数据描述| LDAS 中描述。
3. 使用的最后一个数据集是来自统一的世界土壤数据库(HWSD)的土壤数据。这是一个 30 角秒的栅格数据库，有 15 000 多个不同的土壤制图单元，结合了世界各地现有的区域和国家土壤信息更新(SOTER、ESD、中国土壤图、WISE)。数据可通过粮农组织门户网站获取:世界土壤数据库 1.2 版|粮农组织土壤门户网站。数据集包括 58 个变量，描述了土壤单位的组成和土壤参数的特征(有机碳、pH 值、蓄水能力、土壤深度、土壤和粘土部分的阳离子交换能力、总可交换养分、石灰和石膏含量、钠交换百分比、盐度、结构等级和粒度)。变量的更多细节可以在:http://www.fao.org/3/aq361e/aq361e.pdf找到。

这三个数据集根据 FAMEWS 数据中提供的作物田地的地理坐标进行合并。

方法

A.选择

在 FAMEWS 数据集中使用了两种不同的检查方法:侦察和信息素陷阱。不同的检测方法，无论是单独使用还是组合使用，都可能产生意想不到的偏差。因此，我们将研究限于使用 Scouting 检测的样本，因为它代表了最大的样本(69%的病例，即 26901 例——见图 5)。

**图 5:**fame ws 数据集中不同检查方法的份额。

如图 6 所示，在 FAMEWS 的搜索样本中，当观察 FAW 阳性和阴性检测的相对分布时，阳性病例占样本的 85.9%。数据集中非常强的阳性检测偏倚实际上表明，通过移动应用程序收集数据是在 FAW 实际爆发后开始的。如果数据收集来自给定地区的系统调查(调查期间该地区所有农民的输入，不考虑 FAW 的发生率)，我们预计在数据集中发现的比例会小得多。

**图 6:**FAMEWS 数据集中阳性和阴性检查的分布。

这一观察结果实际上被侦察检查随时间的分布所证实，如图 7 所示:缺乏时间一致性是反应模式的症状，而不是系统的数据收集。

**图 7:**fame ws 数据集中过去几个月检查次数的总体分布。

关注图 8 中所示的非洲特定区域，支持类似的结论:检查数量的分布因位置而异(对于图 8 中红色的选定区域- 左，2019 年的检查数量接近于零)。

图 8: 左 : 侦察检查的空间分布；红色区域中的检验用于相邻地块。 右侧 :所选区域当月检验次数分布。

正如所展示的，基于侦察检查的数据集高度偏向于阳性检测。这很可能是由于疫情爆发后数据收集的反应性质(农民只在他们的田地被感染后才使用该应用程序)。这样一个不平衡的数据集不允许我们在给定的日期为给定的领域建立一汽爆发的预测模型。为了实现这一目标，有必要进行更加系统和公正的数据收集，以提供疫情病例的现实表现。

因此，我们决定将我们的研究重点放在一汽在玉米作物中传播的驱动因素和加重因素上。在实践中，我们正在使用机器学习建模来提取一组具有预测能力的特征，以识别一汽的存在。我们希望确保这些特征的预测重要性可以通过位置和时间来推断，以便我们从非洲过去的疫情中获得的见解在未来对其他国家(如印度)也有效。

B.模型、预处理和验证策略

我们决定训练一个极端梯度增强( XGBoost )优化来预测，作为一个目标变量，在一个给定的检测点被一汽侵染的植物的百分比。如前一节所述，害虫传播的预测(例如，田地是否会受到影响？)是不可能的，因为检测样本中存在偏差。因此，我们选择将重点放在虫害程度的预测上(即，知道田地已经虫害，预计受影响的比例是多少？)

图 9 显示了每次侦察检查的潜在侵扰程度范围，表明二元目标变量(阳性，检测到，与阴性，未检测到)无法完全掌握问题。我们还从训练集中删除了虫害为 0%和 100%的案例，因为它们似乎与调查信息的缺乏更相关，因为输入是由农民键入的。

图 9: 每次检查中受侵染植物的比例(%)分布(基于侦察)

在任何模型训练之前，我们对数据集进行适当的预处理:

• 将数据集限于非洲大陆和玉米作物(因为其他作物的信息也存在于数据集中)——将总样本减少到 16705 个案例；
• 删除重复的行和常量列；
• 从 FLDAS、FAMEWS 和 HWDS 数据集中进行领域驱动的特征选择(仅关注相关信息，放弃不相关或重复的特征，例如数据库 IDs
• 某些字段的标准化(例如“cropFieldSize”，因为根据应用程序的用户使用不同的测量单位)；
• 手动特征工程，为我们的研究以更相关的方式组合特征；
• 汇总天气数据以反映每周平均水平。

鉴于 FAMEWS 数据集的性质，以及所使用的空间和时间要素(土壤和天气数据)的混合，我们必须实施特定的验证策略，以确保最重要的要素将在时间和位置上正确地概化。我们的验证策略基于时间分离，其中 2018 年的数据用于训练，2019 年的数据用于验证。然而，为了消除任何空间影响，我们对这一基本策略进行了如下改进:

• 对于 2019 年的验证集，我们定义了 3 个特定区域作为经度区间:A (-16，-1)，B (26，33)，C (35.5，46)。这些区域经过精心设计，以最大限度地提高培训和验证实例的数量。
• 然后，我们在训练/验证中分割我们的检查数据集三次，每次在 2018 数据集上训练模型，排除验证区域中的数据(例如，区域 A 外的所有 2018 数据)，并用验证区域内的 2019 数据集进行验证(例如，A 内的所有 2019 数据)。

通过这种验证策略，我们优化了最重要的超参数，首先是全局网格搜索，然后是更局部的网格搜索以进行微调。使用上述三个分割，在微调模型的超参数时，我们可以计算验证集之间的模型平均绝对误差(MAE)。MAE 越低，模型通过位置和时间进行概化的能力越高。

C.特征选择

一旦模型被训练，我们可以为每个特征计算 XGBoost 目标函数中的增益，该增益是当模型的决策树之一使用该特征在数据集中进行分割时获得的。然后，我们将 XGBoost 模型中一个特性的重要性定义为所有这些收益的总和。

然而，特征的重要性可以通过隐藏的相关性或掩盖关于位置或时间的信息来人为地提高。为了确保所选择的特征正确地概括，对于每个特征，我们再次微调和训练模型，而不考虑该特征。然后，我们将排除该特性的新模型的 MAE 与包含该特性的旧模型进行比较。如果在不考虑该特征时 MAE 显著增加(大于 0.005)，我们丢弃该特征。在这种情况下，再次重新计算重要特征的集合，将被丢弃的特征从我们的预测器集合中去除。

被丢弃的功能示例:

• instant _ yearly:MAE 中的 0.7934 移除后的改进
• 第一阶段:MAE 中的 0.5037 移除后的改进
• cropFieldSize:对 MAE 中的 0.0863 的改进

从 FLDAS、HWSD 和 FAMEWS 数据集的原始组合变量集中选出的最终 14 个特征对 FAW 虫害具有最高的预测能力，它们是:

分析和结果

为了直观显示所选特征区分严重和轻微虫害作物的能力，我们使用二元目标构建了一个决策树，如果作物的 FAW 植物百分比超过中位数(大约 25%的虫害)，则该目标被定义为真，否则为假，如图 10 所示。

决策树从上到下如下所示:

• 每个单元格代表基于所述条件的样本分成两部分(例如，顶部单元格‘Psurf _ f _ tavg _ mean < 96627.656’)；如果条件得到满足(True ),则对照左边的下一级单元格检查相应的拆分样本，如果不满足(False ),则在右边检查；
• 在每个细胞中，阴性(在我们的情况下较少侵染)和阳性(在我们的情况下较多侵染)的分数在括号中表示(例如在顶部细胞上‘值=[0.513，0.487]’，因此 51.3%的阴性和 48.7%的阳性)；
• 每个单元所代表的完整样本的比例也同样被指示(例如在顶部单元中“样本= 100%”)；
• 阳性细胞比例越高(感染越多)，细胞越蓝，阴性细胞比例越高(感染越少)，细胞越红。

为了更好地理解如何读树，让我们来看两个最极端的例子:

1 -第一个实例对应于具有最暗蓝色阴影的单元，其占用于本研究的样本集的 5.7%(在非洲对玉米作物的侦察检查)，其中每个田地(在该子集中)的 85.4%受到侵害(“值=[0.146，0.854])，有利于以下条件:

• 低地面气压(’ Psurf _ f _ tavg _ mean≤96627.656 ')；
• 粘土的低重量分数(尽管不极端)(’ 10.5<t_clay></t_clay>
• high fraction of Organic Content (‘T_OC>0.955 ')；
• 而没有下雨(’ Rainf_f_tavg_mean≤0 ')。

2 -第二个实例对应于具有最暗红色阴影的单元，其占用于本研究的样本集的 5.5%(在非洲对玉米作物的侦察检查)，其中每个田地(在该子集中)只有 17.1%受到侵害(“值=[0.829，0.171])，有利于以下条件:

• 中间地面大气压力(’ 96627.656<psurf_f_tavg_mean></psurf_f_tavg_mean>
• high Humidity Rate (‘Qair_f_tavg_mean>0.015 ')；
• 田间施肥情况(“crop fertilizer _ no≤0.5”)；
• 和较老的作物(“年龄> 54.5”)。

图 10: 决策树模型基于我们的 14 个高度预测特征来预测虫害程度。

尽管决策树对所选特征之间的重要性和相互作用提出了有趣的见解，但现在让我们尝试解释为什么这些所选特征中的一些具有高预测能力。我们将重点放在一些选定的分析上，并不打算进行详尽的研究。同样，我们的目标是证明所使用的方法使我们能够确定一汽传播背后最重要的驱动因素。

土壤密度的影响

在这里，我们需要强调的是，其中一些特征只有在与其他特征相结合时才具有真正的预测能力。例如，如图 11 所示，粘土的分数“T_CLAY”独立地与我们的目标具有相当弱的相关性。然而，图 11 中的第二个图显示，当与地面压力“Psurf_f_tavg_mean”结合时，其影响更大。这个事实已经可以通过决策树推导出来了。

图 11: 对于所有检查(左侧)和在较低表面大气压力下进行的检查(右侧)(拟合三阶回归函数)，作为粘土重量分数函数的侵染率百分比。

一个初步的解释是，在较高的地面大气压力下，不管土壤的成分如何，土壤的密度都较大。在较低的大气压力下，土壤密度较低，那么粘土的质地将对密度产生更大的影响。由于土壤密度较低(因此大气压力较低，粘土含量较低)，一旦蛹羽化，FAW 成虫蛾更容易从土壤中出来，增加了感染的风险。

图 12: 作为有机物含量的重量分数的函数的侵染率百分比(拟合三阶回归函数)。

类似的解释也可以用图 12 所示的有机物含量部分来提出:有机物含量部分越高，土壤的密度越小，因此虫害的风险就越高。

请注意，在图 11 和图 12 中，我们使用了三阶回归。在粘土或有机物含量重量分数的极端情况下，测量中的低统计数据阻止了任何此类测量的解释，并且可能不够可靠。

作物生长阶段和作物健康的影响

图 13: 作为作物年龄函数的侵染率百分比(拟合二阶回归函数)。

FAW 毛虫主要以玉米叶子和轮叶的嫩部分为食，这解释了幼龄作物感染风险较高，而老龄作物感染风险迅速降低的原因，如图 13 所示。虫害的高峰期大约是 30-80 天。玉米在种植后 130-135 天成熟，这解释了超过这个年龄的统计数据(和虫害案例)迅速减少的原因，因为这些案例可能主要与数据收集中的错误有关(因为年龄是根据农民直接收集的数据计算的)。

图 14: 作为土壤温度函数的侵害率百分比(拟合二阶回归函数)。

在图 14 中，我们研究了土壤温度对侵染率的影响(空气温度和土壤辐射温度与土壤温度密切相关，因此我们只关注这一变量)。在 20-25℃(293-298k)附近有一个明显的峰值，在 17℃ (290K)以下和 27℃ (300K)以上有强烈的下降。这些温度对应于玉米根有效生长的理想土壤温度，这意味着该变量与作物的内在健康相关(更健康的作物显然对应于更高的侵染率)。

天气条件的影响

图 15: 作为平均风速的函数的侵害率百分比(拟合三阶回归函数)。

当显示风对虫害的影响时，如图 15 所示，一开始，当风更大时(高达 2 米/秒)，虫害会明显增加，但当风越来越大时，虫害会减少(高达 4 米/秒)。一种潜在的解释是，一些风增加了 FAW 蛾在农田的不同区域传播和恢复循环的机会，但更强的风阻止了 FAW 毛虫留在叶子上继续进食。

图 16: 作为空气湿度的函数(左)和作为前一周降雨量的函数(右)(拟合一阶回归函数)的侵害率百分比。

图 16 显示了虫害与空气比湿度和降雨量之间的负相关关系。这些结果表明，尽管湿度和降雨量有利于植物的发育，但过多的雨水会将幼虫从叶子上冲走，事实上降低了侵染率。这是一个有争议的结果，因为文献中的一些研究倾向于表明相反的情况。

灌溉的影响

图 17: 左: 作为土壤湿度函数的侵染率百分比(拟合一阶回归函数)； 中心: 基于灌溉类型(雨养/灌溉/未知)的感染率百分比； 右: 基于灌溉类型的土壤湿度(雨养/灌溉/未知)。

如图 16 所示，降雨似乎减缓了虫害。我们进一步调查浇水的影响，看看降雨是否真的对一汽有害。

在图 17- 左图中，土壤湿度与虫害发生率呈现出与空气湿度和降雨量相似的负相关关系。然而，在图 17- 中部观察不同类型灌溉的效果时，很明显，虽然灌溉似乎有利于虫害，但雨水灌溉确实降低了虫害发生率，证实了上述结果。如图 17- 右图所示，降雨条件下的土壤湿度平均高于灌溉条件下的土壤湿度，这意味着雨水也有利于植物的生长(事实上，土壤湿度还取决于土壤成分，这是由我们数据集中的有效水容量‘AWC _ CLASS’提供的信息。)

从这一分析中可以清楚地观察到，任何模拟降雨的灌溉系统(如洒水器)都可以再现雨养的效果(降低感染率)。

还值得注意的是，我们的分析中没有证据表明土壤水分缺乏(水分胁迫)会加剧 FAW 的侵扰，正如上述粮农组织报告中来自南苏丹的报告所述。要理解这种差异，需要更多的数据和更深入的调查。

结论和建议

所进行的工作，除了提供一些可操作的见解(例如，关于灌溉)，还证明了采用基于数据科学的方法来使用各种信息来源的重要性，超出了有限调查的范围，以支持全面和以结果为导向的农业项目的发展。

1. 我们强调整体方法的重要性，通过结合不同但高度互补的数据集(来自农民“FAMEWS”、天气“FLDAS”和土壤数据“HWSD”的输入)，得出一致和可靠的图像。正如在研究中所看到的，所有重要的特征都是从三个数据集中提取的，并且大多数洞察都是基于来自各种数据源的特征的组合而提供的(从决策树中可以看到)。
2. 这整个工作是基于开放存取数据的可用性。我们要感谢构建这些数据集的团队所做的工作(数据收集、数据分析、建模和模拟)。我们要再次强调自由分享此类数据的重要性，并对粮农组织最近从其网站上移除对 FAMEWS 数据集的访问感到难过(根据最新状态，截至 2019 年底仍可下载 csv/excel 格式)。
3. 我们已经确定了一组明确的重要特征(14 个特征)，可用于更好地了解一汽传播背后的驱动因素。虽然我们建议聚合尽可能多的数据，但是这些特性可以用作未来数据收集策略的指导原则。当然，这里进行的大多数分析结果都有以前的研究和常识的支持，但这种分析提供了可量化的信息，可用于建立预测模型和确定可操作的措施来限制害虫的传播。
4. 数据采集是任何研究的关键要素，FAMEWS 所做的出色工作值得在此强调。向农民提供一个应用程序来通知他们农田的状况，是防止 FAW 等害虫传播的一个主要武器。然而，由于农民的“非正式”输入，数据集存在自身的局限性，导致一定程度的准确性缺失，并产生不可控制的偏差。FAMEWS 采取的收集策略意味着对疫情爆发后的测量存在重大偏差，因为农民大多在虫害发生后使用该应用程序，这使得无法建立一汽传播的预测模型。

我们建议采用系统的调查策略，直接在农场一级收集信息，独立于几个季节的虫害，并将农民的投入与独立的天气和土壤信息相结合。调查的设计需要有预测性和规范性的模型作为目标，在此基础上可以采取措施尽可能消除偏见。这类项目从一开始就需要数据科学家和机器学习专家的参与。

Cronbach 的 Alpha:理论及其在 Python 中的应用

原文：https://towardsdatascience.com/cronbachs-alpha-theory-and-application-in-python-d2915dd63586?source=collection_archive---------13-----------------------

理解并计算秤可靠性的最重要衡量标准。

图片来自 bongkarn thanyakij

克朗巴赫的 Alpha 是心理学和社会科学中衡量量表可靠性的主要标准。它的重要性怎么强调都不为过，你会在你读到的几乎所有定量实证研究中发现它。令人惊讶的是，还没有一篇关于 Medium 的文章报道它在 Python 中的应用。最重要的是，像 NumPy、Pandas 或 Sklearn 这样的公共数据科学库都没有 Cronbach alpha 度量。这篇文章将告诉你如何去做。

首先，我将解释克朗巴赫的阿尔法背后的一些理论和数学。然后，我们将快速着手动手编程。

克朗巴赫的阿尔法值是多少？

心理测验理论

每当我们使用多个项目来测量一个潜在(不可观察)结构，我们就称这套项目为量表。例如，在商业环境中，我们可能想要了解我们的客户对产品 p 的态度，这对营销人员来说非常有帮助。然而，与体重(例如 50 公斤)、收入(例如 100 万英镑)等概念相反。$)或出勤(真/假)，我们无法直接衡量态度。

简单地问他们“你对产品 P 的态度是什么？”一开始看起来是个不错的解决方案。然而，因为这是由你的客户来定义什么是真正的态度，你不会得到可靠的结果。相反，您应该自己定义该结构，并尝试使用多种客观且可观察的方法来度量它。如果一个顾客把一个产品评价为“好”、“有趣”、“令人兴奋”和“有用”，这可能是一种态度的衡量，尽管这个词本身并没有被使用。可以说，你可以用这 4 个问题作为衡量态度的尺度。

为了确保我们在构建量表方面做得很好，我们需要使用一些质量度量。总的来说，我们要测试一个量表的有效性和可靠性和**。如果秤实际测量了它应该测量的结构，那么它就是有效的。如果每次测的都是一样的，那就是可靠的。**

克朗巴赫的阿尔法如何帮助？

克朗巴赫的阿尔法是对可靠性的一种衡量。确切地说，它告诉我们内部如何一致**我们的规模。这是量表中所有项目测量相同结构的程度。如果“好的”、“有趣的”、“令人兴奋的”和“有用的”都有助于衡量同一件事，克朗巴赫的阿尔法就会很高。然而，如果我们试图用形容词“美味”、“丰富”、“沮丧”和“寒冷”来衡量态度，我认为克朗巴赫的阿尔法值会很低。这些项目看起来确实不一致。这正是克朗巴赫的阿尔法帮助我们的。它回答了这样一个问题:我选择用来度量一个结构的项目排成一行了吗？**

克朗巴赫的阿尔法值介于 0 和 1 之间。较高的值表示较高的内部一致性。一般来说，0.7 或更高的克朗巴赫α被认为是可接受的。现在，让我们来看看这些数字是如何产生的。如果你想直接进入编码领域，可以跳过这一部分。

我们如何计算克朗巴赫的阿尔法值？

这是我们需要的公式:

这里，N 是项目(问题)的数量，r 是项目之间的平均相关性。让我们回到例子来理解这意味着什么。假设我们询问了 6 位顾客对产品 p 的看法，然后我们计算了“好”、“有趣”、“令人兴奋”和“有用”之间的相关性。假设有结果:

我们可以看到所有的相关性都很高。这应该会导致高克朗巴赫阿尔法值。下图说明了如何将公式应用于数据。

我们得到了一个克朗巴赫的阿尔法值为. 965** ，这是异常的！**

我们已经(在某种程度上)算完了！让我们开始编码吧！

我们如何在 Python 中应用这一点？

让我们编写自己的函数来计算克朗巴赫的阿尔法。首先，我们来进口熊猫和 numpy。

import pandas as pd
import numpy as np

现在，我们需要什么来“教授”这个函数呢？

1. 将数据帧输入转换成相关矩阵。
2. 计算 N 和 r。
3. 使用公式计算克朗巴赫的阿尔法值

你可以这样做:

def cronbach_alpha(df): # 1\. Transform the df into a correlation matrix
    df_corr = df.corr()

    # 2.1 Calculate N
    # The number of variables equals the number of columns in the df
    N = df.shape[1]

    # 2.2 Calculate R
    # For this, we'll loop through the columns and append every
    # relevant correlation to an array calles "r_s". Then, we'll
    # calculate the mean of "r_s"
    rs = np.array([])
    for i, col in enumerate(df_corr.columns):
        sum_ = df_corr[col][i+1:].values
        rs = np.append(sum_, rs)
    mean_r = np.mean(rs)

   # 3\. Use the formula to calculate Cronbach's Alpha 
    cronbach_alpha = (N * mean_r) / (1 + (N - 1) * mean_r)
    return cronbach_alpha

如果我们对样本数据使用该函数，我们将得到以下输出:

结果是 0.966。用手工计算，我们得到 0.965。这很可能是由于舍入。

总有另一种方法…

听着，我要告诉你一些事。有另一种方法来计算克朗巴赫的阿尔法，更适合 numpy 计算。不过，有个原因我还没告诉你。您刚刚学习的方法更加直观，也更容易理解。最重要的是，除非您使用非常大的数据集，这在 Cronbach 的 Alpha 主要应用的调查统计中并不常见，否则您使用上面的函数不会有任何问题。我不会在本文中讨论这种方法。然而，我鼓励你利用你的新知识，自己做一些进一步的研究。

无论如何，我希望这篇文章对你有所帮助，教会你一个新的统计概念和/或改进你的工作流程！

非常感谢您的阅读！

使用机器学习在浏览器中裁剪和识别图像或视频中的特定对象

原文：https://towardsdatascience.com/crop-and-identify-specific-objects-in-an-image-or-video-in-the-browser-using-machine-learning-9b68780b2bb7?source=collection_archive---------33-----------------------

利用客户端机器学习的力量

视频来源:https://www.youtube.com/watch?v=Yi_kDT5L5s4

简介—浏览器中的机器学习

Tensorflow.js 允许我们在浏览器中完全在客户端训练模型和运行推理。这开启了一大堆新的机会！

在本文中，我们将构建一个工具，允许用户裁剪图像的特定部分，并对裁剪后的图像进行推理。我们将使用一个图像分类模型来帮助我们将图像分类到一个特定的类别，但理论上你可以使用任何模型。

演示

应用的现场演示 如上图 gif 所示。下面的注释中提到了使用说明。

Github 库

注:

1. 要使用实时工具，单击实时演示链接，这将打开应用程序。接下来上传你选择的任何视频剪辑。此时屏幕仍将保持空白。要播放视频，点击播放按钮，视频将开始播放。接下来，在感兴趣的视频实例上点击暂停按钮。这将初始化框架上的裁剪器。选择感兴趣的区域进行裁剪，点击裁剪按钮。这将弹出一个显示裁剪图像的模态。点击进行预测按钮，对裁剪后的图像进行推断。结果将显示在模态中。
2. 演示中显示的工具是我们将在本文中构建的工具的扩展版本。您可以查看 github repo 以获取源代码。

我们开始吧

目录结构

我们将创建一个简单的目录结构，如下所示。

|-- index.html
|-- index.js
|-- style.css
|-- |-- Images
|   `-- image.jpg

超文本标记语言

这就是我们的 index.html 的样子

在 head 标签中，我们使用 cdn 导入 css 样式表和某些库来帮助我们。我们将使用的库是:

cropper . js**😗*一个Javascript 图像裁剪库。

tensor flow . js:JavaScript 中用于机器学习的库。

在主体中，我们有三个容器。第一个容器是我们将要测试的图像。第二个容器是我们放置按钮的地方，第一个按钮用于初始化图像的裁剪工具，第二个按钮用于裁剪选定的部分，并对图像的裁剪部分进行推理。第三个容器是空的，但是一旦我们运行推理，我们将使用 JavaScript 动态地填充结果。最后，我们导入 cropper.js 库和 index.js 脚本。

半铸钢ˌ钢性铸铁(Cast Semi-Steel)

我们的风格. css

接下来，我们添加一些 css 来限制边界内的图像，并使一切看起来很好。

html 和 css 完成后，页面看起来会像这样:

图片来源:http://www . new thinktank . com/WP-content/uploads/2010/05/Animals _ 311 . jpg

Java Script 语言

这是最重要的部分。让我们了解一下代码是做什么的。

首先，我们抓住所有的元素，以便我们可以操纵它们。这包括图像、按钮等。

接下来，我们运行 loadModel 函数。该函数下载 MobileNet 预训练模型，该模型已经在具有数千个类别的大型数据集上进行了训练。MobileNet 指的是神经网络的特定架构。

我们给这两个按钮添加了事件监听器，这样它们就可以在点击时做出响应。

当我们点击第一个按钮——“初始化裁剪器”时，我们运行函数 initializeCropper。这个函数在我们的图像上创建一个裁剪器的新实例，并且清空我们的结果容器。

第二个按钮——“裁剪图像并进行预测”运行预测功能。该函数获取从 cropper 获得的裁剪后的图像数据，并将其提供给我们的 MobileNet 模型。然后，该模型输出裁剪图像所属的类别或种类以及置信度概率。然后，我们动态地创建一个 img 元素和一个 h1 元素，并将它们添加到我们的结果容器中以显示结果。

流程是:

1. 点击“初始化裁剪器”按钮
2. 点击“裁剪图像并进行预测”
3. 将显示结果

在上面的例子中，我裁剪了右边的北极熊，并对裁剪后的图像进行了推理。正如我们所见，该模型以相当高的可信度正确预测了它的类别。

结论

在本文中，我们构建了一个简单的工具，允许用户裁剪图像的特定部分，并对裁剪后的图像运行图像分类模型。

希望你喜欢它！尽管这是一个基本的例子，但它可以扩展到构建令人惊叹的东西。一个例子是在视频中使用它，正如我在演示中展示的( github )。

客户端的机器学习已经打开了许多可能性，我鼓励你去创造令人敬畏的东西。

“如果你不创造东西，就没有东西”——埃隆·马斯克

如果您有任何反馈或想取得联系，请在 ms.neerajkrishna@gmail.com 的上给我留言

参考

1. 【tensorflow.org/js
2. https://fengyuanchen.github.io/cropperjs/
3. https://code labs . developers . Google . com/code labs/tensor flow js-teacheble machine-code lab/index . html # 0

交叉注意力才是你需要的！

原文：https://towardsdatascience.com/cross-attention-is-what-you-need-fusatnet-fusion-network-b8e6f673491?source=collection_archive---------13-----------------------

新成绩 / CVPR 2020

FusAtNet:用于高光谱和激光雷达分类的基于双注意的光谱空间多模态融合网络

FusAtNet:用于高光谱和激光雷达分类的基于双注意的光谱空间多模态融合网络

**萨蒂扬·莫拉等。al，**IEEE/CVF 计算机视觉和模式识别会议(CVPR)研讨会，2020 年，第 92–93 页

如今，随着传感技术的进步，多模态数据正变得易于用于各种应用，特别是在遥感(RS)中，其中许多数据类型如多光谱(MSI)、超光谱(HSI)、激光雷达等。都是可用的。

今天，多模态数据很容易获得！

这些多源数据集的有效融合变得越来越重要，因为这些多模态特征已被证明能够生成高度精确的土地覆盖图。然而，考虑到数据中涉及的冗余和多种模态之间的大范围差异，RS 环境下的融合并不是微不足道的。此外，不同模态的特征提取模块之间很难交互，这进一步限制了它们的语义相关性。

为什么单一融合表示很重要？

组合多模态图像的几个优点包括:

1. 生成丰富、融合的表示有助于选择任务相关的特征
2. 改进分类，提高可信度，减少歧义
3. 补充缺失或有噪声的数据
4. 减少数据大小

有趣的是，今天大多数常见的方法往往只是使用早期连接、CNN 提取的特征级连接或多流决策级融合方法等方法，完全忽略了跨域特征。视觉一个注意 *，*深度学习研究人员的工具箱中最近增加的一个是 在多模态领域中基本上未被探索。

一个问题出现了:如何最好地融合这些模态，形成一个联合的、丰富的表示，可以用于下游的任务？

基于多模态融合的分类任务的一般示意图。目标是有效地组合两种模态(这里是 HSI 和 LiDAR ),使得结果表示具有丰富的、融合的特征，这些特征对于精确分类来说是足够相关和鲁棒的。

一个理想的融合方法是将两种模态协同地结合起来，并确保结果反映输入模态的显著特征。

一个新概念:交叉注意

在这项工作中，我们提出了“交叉注意”的新概念，并在土地覆盖分类的背景下提出了基于注意的 HSI-LiDAR 融合。

多通道融合中的自我注意与交叉注意。自我注意模块(左)仅在单一通道上工作，其中隐藏表征和注意屏蔽都来自同一通道(HSIs)。另一方面，在交叉注意模块(右)中，注意掩模来自不同的模态(LiDAR ),并且被利用来增强来自第一模态的潜在特征

交叉注意是一种新颖且直观的融合方法，其中来自一种模态(此处为 LiDAR)的注意掩模被用于突出显示另一种模态(此处为 HSI)中提取的特征。注意，这不同于自我注意，在自我注意中，来自 HSI 的注意屏蔽被用来突出它自己的光谱特征。

FusAtNet:在实践中使用交叉注意

本文提出了一个用于 HSIs 和 LiDAR 数据的集体土地覆盖分类的特征融合和提取框架 FusAtNet。所提出的框架有效地利用了 HSI 通道，使用“自我注意”机制来生成强调其自身光谱特征的注意图。类似地，同时使用“交叉注意”方法来利用激光雷达导出的注意图，该注意图强调 HSI 的空间特征。然后，这些注意的光谱和空间表示与原始数据一起被进一步探索，以获得特定于模态的特征嵌入。由此获得的面向模态的联合光谱-空间信息随后被用于执行土地覆盖分类任务。

**fusat net 示意图(呈现在休斯顿数据集上)。**首先，高光谱训练样本 XH 被送到特征提取器 FHS 获取潜在表征，并送到光谱注意模块生成光谱注意掩模。同时，相应的激光雷达训练样本 XL 被发送到空间注意模块 AT 以获得空间注意掩模。注意屏蔽被单独乘以潜在 HSI 表示以获得 MS 和 MT。MS 和 MT 然后与 XH 和 XL 连接并被发送到模态特征提取器 FM 和模态注意模块 AM。然后将两者的输出相乘得到 FSS，然后将其发送到分类模块 C 进行像素分类。

结果

在三个 HSI-LiDAR 数据集上的实验评估表明，所提出的方法达到了最先进的分类性能，包括在现有最大的 HSI-LiDAR 基准数据集 Houston 上，为多模态特征融合分类开辟了新的途径。

休斯顿

带有分类地图的休斯顿超光谱和激光雷达数据集。(a)HSI 的真彩色合成，(b)激光雷达图像，©地面实况。(d) SVM (H)，(e) SVM (H+L)，(f)两个分支的 CNN (H)，(g)两个分支的 CNN (H+L)，(h) FusAtNet (H)，(i) FusAtNet (H+L)

休斯顿数据集上的精度分析(单位为%)。‘H’仅代表 HSI，而‘H+L’代表融合的 HSI 和激光雷达

特伦托

带有分类地图的 Trento 高光谱和激光雷达数据集。(a)HSI 的真彩色合成，(b)激光雷达图像，©地面实况。(d) SVM (H)，(e) SVM (H+L)，(f)两个分支的 CNN (H)，(g)两个分支的 CNN (H+L)，(h) FusAtNet (H)，(i) FusAtNet (H+L)

Trento 数据集上的精度分析(以百分比表示)。‘H’仅代表 HSI，而‘H+L’代表融合的 HSI 和激光雷达

MUUFL

带有分类地图的 MUUFL 高光谱和激光雷达数据集。(a)HSI 的真彩色合成，(b)激光雷达图像，©地面实况。(d) SVM (H)，(e) SVM (H+L)，(f)两个分支的 CNN (H)，(g)两个分支的 CNN (H+L)，(h) FusAtNet (H)，(i) FusAtNet (H+L)

mu ufl 数据集的精度分析(单位为%)。 H 仅代表 HSI，而 H+L 代表融合的 HSI 和激光雷达

可以清楚地看到，对于所有情况，我们的方法在所有途径中以显著的优势优于所有现有技术方法，无论是 OA(休斯顿、特伦托和穆弗勒数据集的相应准确度为 89.98%、99.06%和 91.48%)、AA(相应值为 94.65%、98.50%和 78.58%)还是κ。很容易观察到，在类/生产者的准确度的情况下，对于大多数类，我们的方法的性能优于其他方法，而对于少数类，我们的方法仅略微超过其他方法。对于休斯顿数据集，可以注意到，与其他方法相比，我们的方法对于“商业”类(92.12%)的准确性有显著提高。这可以归因于这样的事实，即商业区域通常具有可变的布局，并且频繁的海拔变化被基于 LiDAR 的注意力地图有效地捕捉到。在休斯顿分类地图中也观察到，诸如 SVM 和双分支 CNN 的方法倾向于将阴影区域分类为水(在地图的右边部分),因为它们的色调较暗。我们的方法也在很大程度上缓解了这个问题。

**从 FusAtNet 获得的分类图往往噪声较小，并且具有平滑的类间过渡(此处为 MUUFL 数据集)**HSI(左上)、激光雷达图像(左下)、分类图(右)的真彩色合成图。

类似地，在 Trento 数据集的情况下,“道路”类显示出显著的准确性提高(93.32%)。该增量也是由于道路轮廓相对于其高度的变化。

此外，例如在 MUUFL 中，可以从视觉上验证从 FusAtNet 获得的分类图往往噪声更小，并且具有平滑的类间过渡。

消融

我们进一步进行了不同的消融研究，以突出我们模型的各个方面。

表 4: 通过改变所有数据集上的注意力层进行消融研究(精确度为%)

表 4 表示在网络中描述的各种注意层存在的情况下的性能，证明了对所有三个注意模块的需要。

表 5: 有和无数据增强的训练消融研究(准确度百分比)

表 5 显示了数据扩充的性能。

表 6: 通过改变 MUUFL 数据集上训练样本的分数来对性能建模(精度百分比)

表 6 表示训练数据减少后的性能。

除了明显的观察结果，即数据扩充&训练数据的增加增加了准确性，有趣的是注意到 我们的网络仅用 50%的训练数据就开始胜过现有的 SOTA 方法。

结论

总之，我们的工作是在土地覆盖分类的背景下为 HSI-LiDAR 融合引入注意力学习概念的首批方法之一。在这方面，我们引入了基于“交叉注意”的概念，在模态间进行特征学习，这是一种新颖直观的融合方法，它利用来自一个模态(此处为激光雷达)的注意来突出另一个模态(HSI)中的特征。我们在三个基准 HSI-LiDAR 数据集上展示了最先进的分类性能，优于所有现有的深度融合策略。

发表为 (点击下方)

FusAtNet:用于高光谱和激光雷达分类的基于双注意的光谱空间多模态融合网络

***萨蒂扬·莫赫拉，*希瓦姆·潘德，比普拉·班纳吉，苏哈西斯·乔杜里；IEEE/CVF 计算机视觉和模式识别会议(CVPR)研讨会，2020 年，第 92–93 页

Python 中基于跨列的数据操作

原文：https://towardsdatascience.com/cross-column-based-data-manipulation-in-python-dfa5d8ffdd64?source=collection_archive---------57-----------------------

基于单个命令和 ETL 过程中的多列清理和特征工程数据

假设您的经理给了您一个随机数据集，并告诉您进行“基本”清理:“只保留在 A、B 和 C 列中有值的记录，或者在这三列中没有任何值的记录”。你会怎么做？

在 Unsplash 上拍摄的 ThisisEngineering RAEng

介绍

特征工程可以是非常基本的，例如缩放和编码，但有时很神秘。最近，我遇到了这种基于跨列的需求，这让我想到，为什么清理逻辑听起来如此简单，但在数据清理和特性工程中却是内在复杂的？

用词直白，用代码不那么直观

我们从现有课程中学到的大多数数据操作技能都集中在行方式应用程序上。这种类型的功能在数据分析包(如 Pandas)中写得很好，这意味着分析师或数据科学家不必从头开始创建新的应用程序。然而，当涉及到基于列的应用时，事情就没那么简单了，尤其是涉及到多个列的时候。如果我们想执行我在引言中提到的简单请求，我们必须在流程中混合一些更高级的东西，比如逻辑关系。

在这篇文章中，我将演示一个基本的用例以及一个关于跨列操作的更复杂的情况。我还将包括完整的操作函数，展示如何在常规 ETL 过程中应用这些函数。以下文章中分享的技术包括:

1. 计算数值的跨列聚合指标
2. 用跨列逻辑运算验证记录

数据集介绍

去年春天，我和我的朋友参加了布朗大学举办的 2020 年数据马拉松比赛。主题是根据信用局数据和邮政编码级别的人口统计数据预测潜在的购房者在哪里。这些特征包括诸如银行卡限额、打开的银行卡数量和最近抵押贷款的余额等指标。

所提供的数据集涵盖 2019 年 4 月至 9 月，CSV 文件也相应拆分。总共有 36，000，000 多行和 300 多列，它们的总大小约为 10GB。我会用这个来展示我的想法。

数据集的片段

问题 1:使用聚集方法减少跨数据集聚集指标

简单来说就是数据一塌糊涂。在对不同时间的数据集进行组合后，只要进行简单的计算，数据的总大小就可以冻结一台普通的笔记本电脑。因此，我想提出一种方法，将相同的指标推广到不同的月份(例如，每个月都有一个“未结银行卡数量”指标。我喜欢减少功能的总数，但保留这些信息)。

各种机器学习技术(例如，PCA、聚类)可以实现类似的效果。然而，我会用最直接的方式转换特征，这就是平均。

解决方案 1:谨慎使用熊猫内置计算

这只是说，我们需要在一段时间内对指标进行平均。我们可以通过pd.DataFrame.mean()轻松实现这一点。熊猫包还提供了sum()、std()等各种聚合功能。

预期的结果

这是一项相对容易的任务。然而，诀窍是设置正确的管道来组织新的列并构建新的数据帧。这里有几个值得一提的提示:

• pd.DataFrame()不允许你像pd.read_csv()那样单独指定列的数据类型(我知道这很奇怪)。为了适应这些限制，建议在构建新的数据框后分配astype()功能。
• 此外，如果您同时要分配不同类型的数字数据，那么在使用值列表构建一个pd.DataFrame()时，要小心可能的信息丢失。整数和浮点之间的自动转换会在没有任何警告的情况下损坏值！(更不用说数值型数据转换成字符串值也会在这个过程中丢失几个数字)

整个功能如下所示。注意，“df”是要处理的数据，“df_col”只是用于构建列名的列表。

问题 2:清理跨列逻辑关系的数据

直到这一点，它没有太多的麻烦。但是困难来了。虽然我们缩小了数据范围，但还是有些不对劲。

一般来说，如果一条记录(一个区域)有一笔抵押贷款，那么在描述第一笔抵押贷款的每一列(平均贷款额、平均余额、比例)中都应该有一个值。如果一条记录根本没有抵押贷款，那么这三列中应该根本没有值(因为该区域没有抵押贷款)。然而，我只看了几行就发现了差异。有些行有平均贷款额但没有平均余额，有些行只有第二笔贷款的比例而没有其他两笔对应的贷款。

三个共存列的描述

如果模型不能识别高维数据的正确模式，这种类型的错误会严重损害模型。为了使模型或分析更加稳健，应该从数据集中排除有问题的记录。

用文氏图思考

为了理解这个问题，文氏图可能有助于理解。对于我在这里尝试做的，以及大多数一般类似的特别情况，我正在查看子集完全不相交部分和完全相交部分，它们分别是 000 (All - (A∪B∪C))和 111 (A⋂B⋂C)。

来源:https://en.wikipedia.org/wiki/Venn_diagram

有了这个想法，因为 Pandas 支持逻辑操作符(&，|，~)，我可以这样配置逻辑:

## 111
((df[col_1].astype(bool) & df[col_2].astype(bool) & df[col_3].astype(bool))## 000
(~df[col_1].astype(bool) & ~df[col_2].astype(bool) & ~df[col_3].astype(bool)))

注:如果你想知道，不，这不是你在做否定逻辑条件时需要把 AND 转换成 OR 的情况(因为这里的元素都是二进制的，真或假)。另一个例子见这个螺纹。

然后，我将这些逻辑运算符整合成一行，形成一个系列:

## 111 or 000
s_bool = ((df[col_1].astype(bool) & df[col_2].astype(bool) & df[col_3].astype(bool))|(~df[col_1].astype(bool) & ~df[col_2].astype(bool) & ~df[col_3].astype(bool)))

在将所有的布尔序列连接成一个数据帧之后，我使用all()和apply()以及lambda创建一个短函数，同时沿着列轴应用它。更具体地说，all(x)将执行另一个逻辑操作来确保所有不同的部分(列组；例如，6 月份第三次贷款的一组列，8 月份第五次抵押贷款的一组列)遵守我首先设定的规则(在维恩图中是 111 或 000 关系)。这最终归结为一系列布尔函数:

s_agg_bool = df_bool.apply(lambda x: all(x), axis = 'columns')
# We can then use this series of booleans to subset the right records out of the raw data.

这是最后一个 ETL 函数，我对数据集进行了清理。请注意，它被设计为应用于多组列，例如来自不同月份或不同类别的指标:

在进行逻辑工作之前，我们必须将所有 NaN 值转换为 0，并将所有数值转换为布尔数据类型，这样我们就可以利用 Pandas 逻辑的机制(所有零值将为假，所有非零值将为真)。

结论

我快速浏览了一些基于交叉列的数据操作的技巧和例子。然而，我知道这很难成为类似用例的全面指南。

数据操作异常困难，因为我们经常面临动态问题，即在现实世界中，单个函数不足以估算缺失值或识别有偏差的数据。在试图找到相关资源后，我意识到没有系统的指导或讨论彻底覆盖实际的东西，因为它的本质是很难归类和非传统的。因此，这是分享可能的解决方案的一种尝试，我希望这篇文章能够激发新的想法，发现更多非常规的方法。

克里斯蒂安·埃斯科瓦尔在 Unsplash 上拍摄的照片

祝贺并感谢你的阅读！欢迎回复任何想法和意见，或者在我的 Linkedin 页面上留言！

附:如果你对新冠肺炎的一些州级信息感兴趣，一定要访问这个简洁的个人仪表盘来跟踪曲线。

杰夫

交叉熵去神秘化。

原文：https://towardsdatascience.com/cross-entropy-demystified-f0886a64883f?source=collection_archive---------35-----------------------

深入研究交叉熵，其必要性和实用性背后的直觉和推理。

引言。

很长一段时间，我没有完全理解交叉熵损失。我们为什么要取指数(softmax)？那我们为什么要拿走木头？我们为什么要拍下这个日志？我们是如何以必须最小化的正损失结束的？

这些问题越来越让我困惑，以至于我只是接受了我必须使用交叉熵进行多标签分类，并没有想太多。

最近我开始浏览 fastai 的 2020 课程，Jeremy 在解释交叉熵，尽管我认为他做得很好，但我之前的问题没有得到很好的回答。于是我开始琢磨和摆弄笔记本，终于弄明白了。

在这篇文章中，我会问一些简单的问题，然后我会回答这些问题，希望之后你不会再有任何关于交叉熵的令人难以置信的问题。

损失函数的目标是什么？

损失函数的目标是简单地输出一个数字(我们如何得到这个数字很快就会清楚)，这个数字有 2 个要求。

1. 数字必须是正数。
2. 我们的模型越不准确，这个数字就应该越大。

我们的目标是最小化这个数字，我们的损失越接近零，我们的模型就越精确。

注意:我不会探究为什么会这样，我假设你知道神经网络的目标是最小化损失。如果你想了解更多，请访问 fast.ai，跟随杰里米的惊人深度学习课程。这适用于所有与交叉熵无关的问题，但是我愿意在评论中回答它们。

第一站，激活。

我们的第一站是激活。这些是神经网络的最后一层输出，是我们的网络对我们图像标签的猜测。激活离标签越近，我们的模型就越精确。

让我们考虑一个网球的图像，我们试图找出这个图像是否是以下三个事物之一:

1. 篮球
2. 网球
3. 足球

网球的标号将是[0，1，0]。这些预测是 100%准确的。猜测分别对应 0%篮球，100%网球，0%足球。

现在假设我们的激活是[0.001，4.334，2.90]。这些只是我凭空想象出来的随机数。然而，如果我们假设这些是激活，我们可以清楚地看到网球的激活是最高的，然而，我们如何量化呢？或者用百分比概率怎么说呢？

此外，如果我们有一组不同的激活，比如[4.334，2.90，0.01]，现在最高的激活是篮球，但我们的图像是一个网球，如何量化我们的模型有多错误？

这就是交叉熵的用武之地。

交叉熵是一个损失函数，它量化了我们的模型有多错误。

这种疯狂主要有 3 个步骤(尽管一旦你理解了它的超级简单和直观)。

1.Softmax

第一步是使我们的激活值在 0 和 1 之间。我们这样做，所有激活值对应于图像属于某个类别的概率，现在我们可以简单地最大化对应于正确类别的一个值，这将自动减少对应于错误类别的值。如果我们使用原始激活，这个过程会困难得多。

注意:当我说我们想要最大化激活时，不要混淆。我们确实想最大化激活，我们只想最小化损失。激活是我们的模型做出的猜测，损失是我们模型错误的度量。
我们想减少错误(丢失)，增加正确预测(正确标签对应的激活)。

我们怎么做 softmax？
对于每一项，取每一项的指数，除以所有项的指数之和。

对于我们的激活[4.334，2.90，0.01]，让我们计算每个项目的指数。

acts = [4.334，2.90，0.01]

exp_acts = [76.2487，18.1741，1.0101]

sum(exp_acts) = 95.4329

acts_softmax = [0.7990，0.1904，0.0106]

看看最高激活是如何对应最高概率的，这就是为什么我们做 softmax

侧边栏:我们为什么不干脆做 acts = acts/sum(acts)呢？
让我们试试:
acts/sum(acts) = [0.5983，0.4003，0.0014]
将此与 softmax 进行比较，较高的激活对应于使用 softmax 的概率比使用归一化的概率高。在分类中，这个特性在大多数时候是需要的，因此我们使用 softmax。

2.原木

考虑 2 个交叉熵值，一个是 0.99，第二个是 0.999。他们看起来比较接近，如果我们根据 softmax 计算我们的损失，两者的损失不会相差太远。然而，这是不可取的。
考虑 10000 个项目，第一个 softmax 为 0.99，100 个项目被误分类，而第二个 softmax 为 0.999，只有 10 个项目被误分类。本质上 0.999 的 softmax 好了 10 倍，而不仅仅是好了一点点。这种质量上的差异最好用测井曲线来表示。

log(0.01)=-4.6051
log(0.001)=-6.9077

尽管 softmax 值接近，但 log 值中的 cast 差异非常有用。
也 log(1) = 0，所以当 softmax 概率为正确类的 100%时，损失(如果只是 log(softmax)为 0)。

我们计算损耗的方法是，其中 label ==1，我们取-log(softmax)，这就是损耗。

3.为什么是负的对数损失？

在我们的例子中，softmax 为 1，log softmax 为 0，因此损失为零。这是正确的。

但当我们的 softmax 为 0.01 时，我们的 log softmax 为- **4.6，**但我们知道我们的损失必须是一个必须最小化的高正数，所以我们取它的负值，使我们的-log(softmax)为正，这是损失的正确值。

由于曲线的性质，Log 为负。

许可证 CC BY-NC-SA 3.0 下 x < 1 are negative. Image by Saylor 学院的记录值

因为 softmax 值总是小于或等于 1，所以 log 总是负的，因此-log(softmax)是正的。

重申一下:-Log(softmax)是我们的损失值。我们取数据集或小批量中每个损失值的平均值，以获得总损失，我们试图将其最小化。

外卖想法

1. 我们采用激活指数使预测概率之间的差距更大。
2. 我们取 softmax 的对数，将 softmax 的小差异等同于损失的大差异，这是应该存在的。在某种意义上，我们使用 softmax 对激活进行处理，以帮助预测，但我们使用 log 对激活进行反处理，以准确评估损失。
3. 我们对 log 取负值以得到正损失，因为 log 对小于 1 的值返回负值(softmax 值就是这种情况)。

信用

1. 这里的许多想法来自杰瑞米·霍华德的 Fastai 课程，我只是试图解释我更好地理解的内容，并添加了我的一些想法。
2. https://saylordotorg . github . io/text _ intermediate-algebra/S10-03-logarithus-functions-and-the I . html，就是我得到对数图的地方。

用于分类的交叉熵

原文：https://towardsdatascience.com/cross-entropy-for-classification-d98e7f974451?source=collection_archive---------0-----------------------

李建刚在 Unsplash 上拍照

二元、多类和多标签分类

TL；博士在最后

交叉熵是分类任务常用的损失函数。让我们看看为什么要使用它，在哪里使用它。我们将从一个典型的多类分类任务开始。

多类分类

图片上是哪一类——狗、猫还是熊猫？只能是其中之一。让我们想象一只狗。

预测是一个概率向量，这意味着它表示所有类别的预测概率，总计为 1。

在神经网络中，通常通过 softmax 函数激活最后一层来实现这种预测，但任何事情都可以，它只是必须是一个概率向量。

让我们计算这张图片的交叉熵损失。

损失是对模型性能的一种度量。越低越好。学习时，模型的目标是获得尽可能低的损失。

目标表示所有类别的概率—狗、猫和熊猫。

多类分类的目标是一个热点向量，这意味着它在单个位置上为 1，在其他位置上为 0。

对于 dog 类，我们希望概率为 1。对于其他类，我们希望它是 0。

我们将开始分别计算每个类别的损失，然后将它们相加。每个单独类别的损耗计算如下:

不要太担心公式，我们马上会谈到它。请注意，如果目标的职业概率是 0，那么它的损失也是 0。

最后——狗类的损失:

那个数字是什么意思？

让我们看看，如果预测的概率不同，损失会如何表现:

• 预测为 1 时损失为 0(与目标相同)。
• 如果预测值为 0(与我们的目标完全相反)，损失就是无穷大。
• 我们永远不会预测小于 0 或大于 1 的东西，所以我们不用担心这个。

如果我们预测中间的东西呢？

我们离目标越远，损失越大。
你可以把它想成一个类似于平方误差的概念——我们离目标越远，误差增长越快。

为什么猫和熊猫类的损失为 0？

看起来我们是在奖励低损失的模型，即使它预测了图像中不存在的类别的高概率。

我们不介意模型预测有一只猫有 80%的概率，如果没有，因为它只剩下 20%的概率来预测正确的类别。在那里，损失会大得多。换句话说，我们不关心模型在哪些类上浪费了预测的概率，只关心它如何正确地识别唯一的当前类。

该图像的总损失是每类损失的总和。

它可以被公式化为所有类的总和。

这就是交叉熵公式，可以作为任意两个概率向量的损失函数。这是我们损失了一张图片——我们一开始展示的一只狗的图片。如果我们想要我们的批次或整个数据集的损失，我们只需合计单个图像的损失。

假设我们有两个不同的模型给出以下预测:

在交叉熵的眼中，模型 B 更好——它的交叉熵损失更低。如果你能明白为什么——干得好！有一只熊猫。

照片由杰瑞米 C 在 Unsplash 上拍摄

通过惩罚大错误比惩罚小错误多得多来训练模型，在机器学习中被证明是一个好主意。

如果大多数类别的损失为 0，为什么要对所有类别求和？
如果我们的目标是一个热点向量，我们确实可以忽略所有其他类别的目标和预测，只计算热点类别的损失。这是我们预测的负自然对数。

这被称为分类交叉熵——交叉熵的一个特例，其中我们的目标是一个热点向量。

事情是这样的——交叉熵损失甚至适用于非热点向量的分布。
即使对于这个任务，损失也会起作用:

有了交叉熵，我们仍然能够计算损失，如果所有的类都是正确的，损失将是最小的，并且仍然具有惩罚更大错误的属性。

在我们的单热目标例子中，熵是 0，所以最小损失是 0。如果你的目标是一个而不是的概率向量，熵(最小损失)将大于 0，但是你仍然可以使用交叉熵损失。

如果你更好奇熵是什么，我推荐你看这个视频。

二元分类

二进制交叉熵是交叉熵的另一个特例——如果我们的目标是 0 或 1，就使用它。在神经网络中，通常通过激活 sigmoid 来实现这种预测。

目标是而不是一个概率向量。我们仍然可以用一点小技巧来使用交叉熵。

我们希望预测图像中是否包含熊猫。

这就好像我们将目标转换为一个热点向量，将我们的预测转换为一个概率向量——熊猫的概率将与预测相同，而非熊猫的概率将是 1-预测。换句话说，如果我们预测 0.6，这意味着我们说 60%是熊猫，40%不是熊猫。

这种损失可以用交叉熵函数来计算，因为我们现在只比较两个概率向量，或者甚至用分类交叉熵来计算，因为我们的目标是一个热点向量。它也可以在没有使用二进制交叉熵进行转换的情况下进行计算。

我们只是将自然对数应用于我们的预测和目标之间的差异。

这就是二元交叉熵的全部内容。

多标签分类

交叉熵也可以用作多标签问题的损失函数，方法很简单:

注意我们的目标和预测是而不是一个概率向量。有可能图像中有所有的类，也有可能没有。在神经网络中，通常通过激活乙状结肠来实现这一点。

我们可以把这个问题看作多个二元分类子任务。假设我们只想预测有没有狗。

我们知道我们的目标是 1，而我们预测的是 0.6

我们将计算这个子任务的二元交叉熵:

对其他班级也这样做。

对于猫，我们的目标是 0，所以二进制交叉熵的另一部分抵消了:

并合计每个子任务的损失:

这就是多标签分类的交叉熵损失。

结论/TL；速度三角形定位法(dead reckoning)

交叉熵 —通用公式，用于计算两个概率向量之间的损失。我们离目标越远，误差就越大——类似于平方误差。

多类分类 —我们使用多类交叉熵—交叉熵的一种特殊情况，其中目标是一个热点编码向量。它可以用交叉熵公式计算，但可以简化。

二进制分类 —我们使用二进制交叉熵——交叉熵的一种特殊情况，我们的目标是 0 或 1。如果我们将目标分别转换为像[0，1]或[1，0]这样的单热点向量和预测，则可以使用交叉熵公式来计算。即使没有这种转换，我们也可以用简化的公式来计算。

多标签分类 —我们的目标可以一次表示多个(甚至零个)类。我们分别计算每一类的二元交叉熵，然后将它们相加得到完全损失。

交叉熵、对数损失及其背后的直觉

原文：https://towardsdatascience.com/cross-entropy-log-loss-and-intuition-behind-it-364558dca514?source=collection_archive---------42-----------------------

在这篇博客中，你会对交叉熵和对数损失在机器学习中的应用有一个直观的了解。

absolute vision在 Unsplash 上拍摄的照片。

在浏览这个博客之前，你不需要知道任何事情，因为我将从基础开始。以下内容将在本博客中详细介绍和解释。

1. 随机变量
2. 信息内容
3. 熵
4. 交叉熵和 K-L 散度
5. 日志丢失

随机变量:

这被定义为一个获取随机事件输出的变量。例如，我们可以定义一个变量 X，它取掷骰子的输出值。这里 X 可以取 1 到 6 的值。

我们有时也会计算随机变量取特定值的概率。例如，P(X=1)是 1/6，这对于其他值也是一样的，因为它们同样可能发生。

信息内容(IC):

当我们讨论信息内容时，我们是在随机变量的背景下进行的。你可以这样想，如果你知道一个事件将要发生，而且这个事件经常发生，那么信息量就非常少。现在，如果你知道一个事件将要发生，而这个事件很少发生，那么信息量就很大。比如有两个随机变量 X 和 Y，这里 X 告诉太阳会不会升起，Y 告诉今天会不会有地震**(惊喜元素)**。你很容易得出 Y 包含更多信息的结论。

信息含量与惊喜元素成正比。

因此，我们可以得出结论，一个随机变量的信息含量取决于一个事件发生的概率。如果概率很低，信息量就很大。我们可以用数学方法写成如下:

信息内容

因此 IC 是概率的函数。这里 P(X=S)表示 X 取值 S 的概率，这将用于博客的其余部分。信息内容显示以下属性。

如果 X 和 Y 是独立事件，IC 的性质。

上图中的第二个性质见于对数函数族。这给了我们用对数作为函数来计算 IC 的直觉。因此，现在我们可以用数学方法定义 IC 如下:

IC 公式。

熵:

随机变量的熵被定义为随机变量的期望信息量。我们会用电子学分支的信息论来更直观的解释。

在信息论中，发送值 X=某个值的比特数称为信息量。如果随机变量有 N 个值，那么我们说它是一个信号。事实上，我们将信号定义为取 N 个值的随机变量。一个信号在不同的时间间隔取不同的值，因此我们可以定义一个随机变量，它取信号可以取的 N 个可能的值。现在我们找到发送信号所需的比特数，这就是随机变量的预期信息内容。换句话说，我们称之为熵。下面的例子将使它更清楚。

举例说明如何计算熵。

使用以下公式计算熵/预期 IC

计算熵/预期 IC 的公式

使用这个公式我们得到熵= (1/21)+(1/42)+(1/4*2) = 3/2。因此，平均而言，我们将使用 1.5 位来发送该信号。

交叉熵和 K-L 散度:

数据传送

在接收端，我们不知道随机变量的实际分布。我们将看到接收到 100 个信号，然后估计随机变量的分布。现在让我们假设发送方的实际分布是“y ”,估计是’y^'.在这里，分布意味着随机变量取特定值的概率。以下是发送数据所需的位数。

计算发送方和接收方位数的公式。

现在我们已经知道位数和熵是一样的。发送方的熵称为熵，接收方的估计熵称为交叉熵。现在，这被称为交叉熵，因为我们使用实际分布和估计分布来计算接收端的估计熵。你一定会想到的另一个问题是，为什么我们在接收端使用实际分布(y)。答案是，我们正在估计接收到的随机变量(-log(yi^).)的每个值所需的比特数所使用的比特数将取决于接收机接收到的随机变量的分布。如果在这之后还不清楚，那么让我们举个例子。

我们估计 P(X=A)是 1/4，而实际是 1/8，那么估计的比特数将是-(log(1/4)) = 2，但是对最终答案的贡献将是 1/8*(2) = 1/4，因为我们将在接收器接收这个值 1/8 次。现在我想这已经很清楚了。

K-L 散度等于交叉熵和熵之差。

K-L 散度。

日志丢失:

现在我们将转到机器学习部分。我想我们知道 y^是什么意思。如果你不知道，那么 Y^就是给定数据点属于特定类别/标签的预测概率。例如，我们可以在机器学习中有一个模型，它将判断一个文本是否是滥用的。计算 y^的公式如下

数据点属于某一类的概率公式。

这里**‘w’是权重向量**，‘x’是数据点的 d 维表示，‘b’是偏差项。

我们在所有机器学习中的主要目标是正确估计训练数据集中数据点的分布。

在这里，训练集可以被视为发送者，而模型可以被视为试图估计分布的接收者。

当 K-L 散度最小时，将出现最佳估计。因此我们将找到对应于最小 K-L 散度的(w，b)。在更新(w，b)时，我们忽略熵项，因为它是一个常数，只有交叉熵项变化。因此，我们的损失方程如下。

失败

这是损失项，我们通常称之为对数损失，因为它包含对数项。

对于二进制分类，其中‘yi’可以是 0 或 1。这个损失看起来将类似于loss =-(y * log(y)+(1-y)* log(1-y))。这是我们大多数人都熟悉的。暂时就这些了。我希望你都记下了。

如果你喜欢这个内容，请在下面的评论中告诉我。

参考资料:

https://en.wikipedia.org/wiki/Cross_entropy

https://en.wikipedia.org/wiki/Information_content

https://en.wikipedia.org/wiki/Random_variable

如果你想了解什么是校准，那就去看看这个 博客 。

[## 机器学习中的校准

在这篇博客中，我们将学习什么是校准，为什么以及何时应该使用它。

medium.com](https://medium.com/analytics-vidhya/calibration-in-machine-learning-e7972ac93555)

想学习如何防止自己的模型欠拟合、欠拟合，那就去翻翻这篇 博客 。

[## 机器学习中的过拟合和欠拟合

在这篇文章中，你将了解什么是过度拟合和欠拟合。您还将学习如何防止模型…

towardsdatascience.com](/overfitting-and-underfitting-in-machine-learning-89738c58f610)

交叉熵损失函数

原文：https://towardsdatascience.com/cross-entropy-loss-function-f38c4ec8643e?source=collection_archive---------0-----------------------

法托斯 Bytyqi 在 Unsplash 上的照片

当处理机器学习或深度学习问题时，损失/成本函数用于在训练期间优化模型。目标几乎总是最小化损失函数。损失越低，模型越好。交叉熵损失是最重要的代价函数。它用于优化分类模型。交叉熵的理解依赖于对 Softmax 激活函数的理解。我在下面放了另一篇文章来讨论这个先决条件

[## Softmax 激活功能——实际工作原理

Softmax 是放置在深度学习网络末端的函数，用于将 logits 转换为分类概率。

towardsdatascience.com](/softmax-activation-function-how-it-actually-works-d292d335bd78)

考虑一个4级分类任务，其中图像被分类为狗、猫、马或猎豹。

输入图片来源:Victor Grabarczyk 在 Unsplash 上拍摄的照片。作者图解。

在上图中，Softmax 将 logits 转换为概率。交叉熵的目的是获取输出概率§并测量与真值的距离(如下图所示)。

交叉熵(L)(来源:作者)。

对于上面的例子，对于类别dog的期望输出是[1,0,0,0]，但是模型输出是[0.775, 0.116, 0.039, 0.070]。

目标是使模型输出尽可能接近期望的输出(真值)。在模型训练期间，模型权重被相应地迭代调整，目的是最小化交叉熵损失。调整权重的过程就是定义模型训练的过程，随着模型不断训练并且损失最小化，我们说模型正在学习。

交叉熵的概念可以追溯到信息论领域，克劳德·香农在 1948 年引入了熵的概念。在深入交叉熵代价函数之前，让我们先介绍一下熵。

熵

随机变量 X 的熵是该变量可能结果中固有的不确定性水平。

对于p(x)——概率分布和随机变量 X，熵定义如下

等式 1:熵的定义。注对数以 2 为基数计算。

负号原因: log(p(x))<0为(0,1)中的所有p(x)。p(x)是一个概率分布，因此值必须在 0 和 1 之间。

log(x)的图。对于 0 到 1 之间的 x 值，log(x) <0 (is negative). (Source: Author).

The greater the value of entropy, 【 , the greater the uncertainty for probability distribution and the smaller the value the less the uncertainty.

示例

考虑以下三种形状的“容器”:三角形和圆形

3 个三角形和圆形容器。(来源:作者)。

容器 1: 拣出三角形的概率是 26/30，拣出圆形的概率是 4/30。由于这个原因，选择一种形状和/或不选择另一种形状的概率更确定。

容器 2: 选择三角形的概率为 14/30，否则为 16/30。几乎有 50–50%的机会选择任何特定的形状。选择给定形状的确定性比 1 中的低。

容器 3: 从容器 3 中选取的形状极有可能是圆形。选择圆形的概率是 29/30，选择三角形的概率是 1/30。很有可能选择的形状是圆形。

让我们计算熵，这样我们就能确定我们的断言，即选择一个给定的形状是确定的。

正如所料，第一个和第三个容器的熵小于第二个容器。这是因为在容器 1 和 3 中选择给定形状的概率比在容器 2 中更确定。我们现在可以继续讨论交叉熵损失函数。

交叉熵损失函数

又称对数损失、对数损失或逻辑损失。将每个预测类别概率与实际类别期望输出 0 或 1 进行比较，并计算得分/损失，该得分/损失基于该概率与实际期望值的差距来惩罚该概率。惩罚本质上是对数的，对于接近 1 的大差异产生大的分数，对于趋向于 0 的小差异产生小的分数。

当在训练期间调整模型权重时，使用交叉熵损失。目标是最小化损失，即损失越小，模型越好。完美模型的交叉熵损失为 0。

交叉熵被定义为

等式 2:交叉熵的数学定义。请注意，对数是以 2 为基数计算的，与 ln()相同。

二元交叉熵损失

对于二进制分类(具有两个类别 0 和 1 的分类任务)，我们将二进制交叉熵定义为

等式 3:数学二元交叉熵。

二进制交叉熵通常被计算为所有数据示例的平均交叉熵，即，

等式 4

例子

考虑具有以下软最大概率(S)和标签(T)的分类问题。目标是在给定这些信息的情况下计算交叉熵损失。

Logits)和具有分类交叉熵损失函数的一键编码真值标签(T ),用于测量预测概率和真值标签之间的“距离”。(来源:作者)

分类交叉熵的计算如下

Softmax 是连续可微函数。这使得计算损失函数相对于神经网络中每个权重的导数成为可能。该属性允许模型相应地调整权重以最小化损失函数(模型输出接近真实值)。

假设在模型训练的一些迭代之后，模型输出以下逻辑向量

0.095小于前次损失，即0.3677暗示模型正在学习。优化过程(调整权重以使输出接近真实值)一直持续到训练结束。

Keras 提供了以下交叉熵损失函数:二元、分类、稀疏分类交叉熵损失函数。

范畴交叉熵和稀疏范畴交叉熵

类别交叉熵和稀疏类别交叉熵都具有等式 2 中定义的相同损失函数。两者之间唯一的区别是如何定义真理标签。

• 当真实标签被一热编码时，使用分类交叉熵，例如，我们对于 3 类分类问题[1,0,0]、[0,1,0]和[0,0,1].具有以下真实值
• 在稀疏分类交叉熵中，真值标签是整数编码的，例如，3 类问题的[1]、[2]和[3]。

我希望这篇文章能帮助你更清楚地理解交叉熵损失函数。

[## Softmax 激活功能——实际工作原理

Softmax 是放置在深度学习网络末端的函数，用于将 logits 转换为分类概率。

towardsdatascience.com](/softmax-activation-function-how-it-actually-works-d292d335bd78)

感谢阅读:-)

强化学习的交叉熵方法

原文：https://towardsdatascience.com/cross-entropy-method-for-reinforcement-learning-2b6de2a4f3a0?source=collection_archive---------7-----------------------

在 Unsplash 上由 Franck V. 拍摄的照片

如果你曾经鼓起勇气探索强化学习领域，很有可能你会发现自己迷失在花哨的词汇中。大词，复杂算法的名字，背后有更复杂的数学。但是，如果有更简单、更直观、效率更高的算法能够很好地工作呢？

来看看交叉熵方法:一种用于参数化政策优化的进化算法，John Schulman 声称这种算法在复杂的 RL 问题上“令人尴尬地好”。

什么是交叉熵方法？

从生物学的角度来看，这是一种 T4 进化算法。一些个体是从群体中抽样出来的，只有最优秀的个体才能决定后代的特征。

在数学上，它可以被视为一种无导数优化 (DFO)技术，即，它可以在没有计算导数的开销的情况下找到最优解(无反向传播！).

这种方法是如何工作的？

假设您不知道什么是代理、环境和策略。你只是得到了一个“黑匣子”，它接受一些数字作为输入，输出一些其他的数字。您只能选择输入值并观察输出。如何猜测输入，使输出成为您想要的值？

一种简单的方法是获取一组输入，观察产生的输出，选择产生最佳输出的输入，并对其进行调整，直到您对看到的输出满意为止。这本质上就是交叉熵方法所做的。

那么，我该如何用它来解决我的 RL 问题呢？

让我们通过一个例子来逐步理解 CEM 的工作原理。为了更好地理解实现，我在每个步骤中都添加了一些 python 代码片段。代码大量借用了 Udacity 关于深度强化学习的课程(惊人的 python RL 资源 btw，本文末尾 Github 链接)。

考虑你的政策网络。你想要找到最佳的权重，它可以基于你的代理的状态采取正确的“有意义的”行动。用于找到这些权重的基于 CEM 的方法如下:

**第一步:**从随机分布中抽取一串初始权重。尽管通常选择高斯分布，但您可以选择您认为权重来自的任何分布。假设我从具有均值 μ 和方差 σ 的高斯分布中抽取了 10 个权重候选值 w1 、 w2 、…、 w10 。

考虑μ=0，σ=1，n_weights=10(候选数)，weights_dim 表示权重向量的维数。

mean = 0.0       
std = 1.0
n_weights = 10weights_pop = [mean + std*np.random.randn(weights_dim) for i_weight in range(n_weights)]

步骤 2: 现在让代理根据这些权重从策略网络中选择行动，让代理运行一集并收集环境生成的奖励。对于我们的例子，比如说 w1 产生一个累积奖励 r1 ， w2 产生 r2 等等。

用于代理的评估方法将权重候选作为输入，播放一集并输出来自该集的累积奖励。

rewards = [agent.evaluate(weights) for weights in weights_pop]

第三步:找出产生最佳回报的权重。假设最佳的 4 种重量是 w1 、 w2 、 w5 和 w6 (也称为“精英”重量)。这里 4 是我们选择的一个数字。一般来说，你考虑最好的 n 权重，其中 n 由你选择。

n_elite = 4
elite_idxs = np.array(rewards).argsort()[-n_elite:]
elite_weights = [weights_pop[idx] for idx in elite_idxs]

步骤 4: 从精英权重定义的分布中选择新权重。说 μ’ 是最佳权重的平均值( w1 、 w2 、 w5 和w6)**σ’是它们的方差。我们现在从具有平均值μ’和方差σ’**的高斯分布中抽取 10 名候选人。

mean = np.array(elite_weights).mean()
std = np.array(elite_weights).std()weights_pop = [mean + std*np.random.randn(weights_dim) for i_weight in range(n_weights)]

第五步:重复第二步到第四步，直到你对得到的奖励感到满意。

如果你不喜欢 python 代码，而你喜欢用数学术语阅读算法，这里有一些伪代码:

鸣谢:约翰·舒尔曼关于深度强化学习的 MLSS 2016

结论

交叉熵方法是一种简单的算法，可以用来训练 RL 代理。在包括 Tetris⁴.游戏在内的著名任务上，该方法已经胜过了几种 RL 技术在转向更复杂的 RL 算法(如 PPO、A3C 等)之前，您可以将此作为基线。CEM 有几种变体，但是，本文中定义的结构是所有变体的主干。

这篇关于交叉熵强化学习方法的文章到此结束。我希望您喜欢您刚刚阅读的内容，并感谢您的宝贵时间。

参考

[1]https://github . com/uda city/deep-reinforcement-learning/tree/master/cross-entropy

[2] MLSS 2016 关于深度强化学习由约翰·舒尔曼(https://www.youtube.com/watch?v=aUrX-rP_ss4)

[3]http://karpathy.github.io/2016/05/31/rl/

[4] I. Szita 和 A. Lorincz，用有噪声的交叉熵方法学习俄罗斯方块 (2006)，神经计算

交叉熵方法性能分析

原文：https://towardsdatascience.com/cross-entropy-method-performance-analysis-161a5faef5fc?source=collection_archive---------37-----------------------

深度强化学习讲解— 07

交叉熵训练循环的实现

在这篇文章中，我们将详细描述交叉熵方法的训练循环，这是我们在上一篇文章中跳过的，同时看看我们如何在考虑更复杂的神经网络的情况下改进代理的学习。此外，我们将介绍该方法的改进变体，它为训练过程的多次迭代保留“精英”片段。最后，我们将展示交叉熵方法激励其他方法的局限性。

1.训练循环概述

接下来，我们将详细介绍构成我们在上一篇文章中介绍的训练循环的代码。

本帖的 完整代码可以在 GitHub 和 上找到，使用此链接 可以作为 Colab 谷歌笔记本运行。

主要变量

代码从定义方法的主要参数开始。

BATCH_SIZE = 100
GAMMA = 0.9PERCENTILE = 30
REWARD_GOAL = 0.8

助手类

我们建议使用两个助手类来简化代码的可解释性:

from collections import namedtupleEpisode = namedtuple(‘Episode’, field_names=[‘reward’, ‘steps’])EpisodeStep = namedtuple(‘EpisodeStep’, 
                          field_names=[‘observation’, ‘action’])

这里我们将定义两个助手类，它们被命名为标准库中的collections包中的元组:

• EpisodeStep:这将用来表示我们的代理在剧集中做的一个单独的步骤，它存储了从环境中观察到的状态以及代理完成了什么动作。奖励没有被记录，因为它总是0.0，除了最后一个过渡。请记住，我们将使用“精英”剧集中的剧集步骤作为训练数据。
• Episode:这是储存了总折扣奖励和 EpisodeStep 集合的单集。

变量的初始化

此时，我们将在训练循环中使用的一组变量被初始化。我们将按照循环中的要求逐一介绍:

iter_no = 0reward_mean = 0full_batch = []
batch = []episode_steps = []
episode_reward = 0.0state = env.reset()

训练循环

我们在上一篇文章中了解到，实现交叉熵算法的代理的训练循环重复 4 个主要步骤，直到我们对结果满意为止:

1 —播放 N 集数

2-计算每集的预期回报，并确定回报界限

3-丢弃所有回报低于界限的剧集。

4-使用“精英”剧集中的剧集步骤训练神经网络

我们已经决定，代理必须接受培训，直到达到一定的奖励阈值。具体来说，我们决定了一个 80%的阈值，如变量REWARD_GOAL所示:

while reward_mean < REWARD_GOAL:

步骤 1-播放 N 集

下一段代码是生成包含剧集的批处理的代码:

action = select_action(state)
next_state, reward, episode_is_done, _ = env.step(action)episode_steps.append(EpisodeStep(observation=state,action=action))episode_reward += rewardif episode_is_done: # Episode finished
    batch.append(Episode(reward=episode_reward,
                         steps=episode_steps))
    next_state = env.reset()
    episode_steps = []
    episode_reward = 0.0 <STEP 2> <STEP 3> <STEP 4>state = next_state

我们将使用的主要变量是:

• batch累积Episode实例的列表(BATCH_SIZE=100)。
• episode_steps累积当前剧集中的步骤列表。
• episode_reward为当前剧集维护一个奖励计数器(在我们的例子中，我们只在剧集的结尾有奖励，但是该算法是针对更一般的情况描述的，其中我们不仅可以在最后一步有奖励)。

情节步骤列表增加了(观察、行动)对。值得注意的是，我们保存了用于选择动作的观察结果state(而不是作为动作结果由环境返回的观察结果next_state):

episode_steps.append(EpisodeStep(observation=state,action=action))

奖励将添加到当前剧集的总奖励中:

episode_reward += reward

当当前剧集结束时(洞或目标状态)，我们需要将最终完成的剧集添加到批处理中，保存我们已采取的总奖励和步骤。然后，我们重置环境以重新开始，我们重置变量episode_steps和episode_reward以开始跟踪下一集:

batch.append(Episode(reward=episode_reward, steps=episode_steps))next_obs = env.reset()
episode_steps = []
episode_reward = 0.0

第二步——计算每集的回报，并确定回报界限

下一段代码实现了步骤 2:

if len(batch) == BATCH_SIZE:
    reward_mean = float(np.mean(list(map(lambda s: 
                  s.reward, batch))))
    elite_candidates= batch
    ExpectedReturn = list(map(lambda s: s.reward * (GAMMA **          
                     len(s.steps)), elite_candidates))
    reward_bound = np.percentile(ExpectedReturn, PERCENTILE)

当运行了等于BATCH_SIZE的播放次数时，训练循环执行该步骤:

if len(batch) == BATCH_SIZE:

首先，代码计算当前批次中所有剧集的预期回报:

elite_candidates= batch
ExpectedReturn = list(map(lambda s: s.reward * (GAMMA **          
                 len(s.steps)), elite_candidates))

在此步骤中，根据给定的剧集批次和百分点值，我们计算边界奖励，该奖励将用于过滤“精英”剧集以训练代理神经网络:

reward_bound = np.percentile(ExpectedReturn, PERCENTILE)

为了获得边界奖励，我们将使用 NumPy 的 percentile 函数，该函数从值列表和所需的百分位数中计算百分位数的值。在这段代码中，我们将使用前 30%的剧集(由变量PERCENTILE表示)来创建“精英”剧集。

在此步骤中，我们计算用于决定何时结束训练循环的reward_mean:

reward_mean = float(np.mean(list(map(lambda s: s.reward, batch))))

第三步——扔掉所有回报低于界限的剧集

接下来，我们将使用以下代码过滤掉我们的剧集:

train_obs = []
train_act = []
elite_batch = []for example, discounted_reward in zip(elite_candidates, 
                                      ExpectedReturn):
    if discounted_reward > reward_bound:
       train_obs.extend(map(lambda step: step.observation, 
                            example.steps))
       train_act.extend(map(lambda step: step.action, 
                            example.steps))
       elite_batch.append(example)full_batch=elite_batch
state=train_obs
acts=train_act

对于批次中的每一集:

for example, discounted_reward in zip(elite_candidates,
                                      ExpectedReturn):

我们将检查这一集的总回报是否高于我们的界限:

if discounted_reward > reward_bound:

如果有，我们将填充我们将训练的观察状态和动作的列表，并跟踪精华片段:

train_obs.extend(map(lambda step: step.observation,example.steps))
train_act.extend(map(lambda step: step.action, example.steps))
elite_batch.append(example)

然后，我们将使用“精英”剧集更新该树变量，这些剧集是我们用来训练神经网络的状态和动作列表:

full_batch=elite_batch
state=train_obs
acts=train_act

步骤 4——使用“精英”剧集中的剧集步骤训练神经网络

每当我们的循环累积足够的片段(BATCH_SIZE)时，我们计算“精英”片段，并且在相同的迭代中，循环用以下代码训练代理的神经网络:

state_t = torch.FloatTensor(state)
acts_t = torch.LongTensor(acts)optimizer.zero_grad()
action_scores_t = net(state_t)
loss_t = objective(action_scores_t, acts_t)
loss_t.backward()
optimizer.step()

iter_no += 1
batch = []

这段代码使用“精英”剧集中的剧集步骤训练神经网络**，使用状态 s 作为输入，发出动作 a 作为标签(期望输出)。让我们更详细地注释所有代码行:**

首先，我们将变量转换成张量:

state_t = torch.FloatTensor(state)
acts_t = torch.LongTensor(acts)

我们将神经网络的梯度归零

optimizer.zero_grad()

并将观察到的状态传递给神经网络，获得其动作得分:

action_scores_t = net(state_t)

这些分数被传递给目标函数，该函数将计算神经网络输出和代理采取的动作之间的交叉熵

loss_t = objective(action_scores_t, acts_t)

请记住，我们只考虑“精英”行动。这种想法是为了加强我们的神经网络，以执行那些带来良好回报的“精英”行动。

最后，我们需要使用backward方法计算损失的梯度，并使用优化器的step方法调整神经网络的参数:

loss_t.backward()
optimizer.step()

监控代理的进度

为了监控代理的学习进度，我们在培训循环中加入了以下内容:

print(“%d: loss=%.3f, reward_mean=%.3f” % 
      (iter_no, loss_t.item(), reward_mean))

我们用它来显示迭代次数、损失和批次的平均回报(在下一节中，我们也将相同的值写入 TensorBoard 以获得一个漂亮的图表):

0: loss=1.384, reward_mean=0.020 
1: loss=1.353, reward_mean=0.040  
2: loss=1.332, reward_mean=0.010  
3: loss=1.362, reward_mean=0.020  
4: loss=1.337, reward_mean=0.020   
5: loss=1.378, reward_mean=0.020 . . .639: loss=0.471, reward_mean=0.730  
640: loss=0.511, reward_mean=0.730 
641: loss=0.472, reward_mean=0.760 
642: loss=0.481, reward_mean=0.650 
643: loss=0.472, reward_mean=0.750 
644: loss=0.492, reward_mean=0.720 
645: loss=0.480, reward_mean=0.660 
646: loss=0.479, reward_mean=0.740 
647: loss=0.474, reward_mean=0.660  
648: loss=0.517, reward_mean=0.830 

我们可以检查reward_mean变量的最后一个值是允许完成训练循环的值。

2.用更好的神经网络改进智能体

在之前的帖子中，我们已经介绍了 TensorBoard，这是一个有助于数据可视化过程的工具。取而代之的是上一节中使用的“打印”，我们可以用这两个句子来描绘这两个变量的行为:

writer.add_scalar(“loss”, loss_t.item(), iter_no)
writer.add_scalar(“reward_mean”, reward_mean, iter_no)

在这种情况下，输出是:

更复杂的神经网络

出现的一个问题是，我们是否可以改进代理的神经网络。例如，如果我们考虑一个具有更多神经元的隐藏层，比如说 128 个神经元，会发生什么情况:

HIDDEN_SIZE = 128
net= nn.Sequential(
           nn.Linear(obs_size, HIDDEN_SIZE),
           nn.Sigmoid(),
           nn.Linear(HIDDEN_SIZE, n_actions)
           )objective = nn.CrossEntropyLoss()
optimizer = optim.Adam(params=net.parameters(), lr=0.001)train_loop()

结果可以在这里显示(或者执行 GitHub 代码):

我们可以看到，这个网络比前一个网络学习得更快。

ReLU 激活功能

如果我们改变激活函数会发生什么？例如，用 ReLU 代替乙状结肠？

下面你可以看到发生了什么:网络收敛得更早，仅仅 200 次迭代就已经完成了。

3.交叉熵算法的改进

到目前为止，我们已经展示了如何改进神经网络架构。但我们也可以改进算法本身:我们可以将“精英”剧集保留更长时间。该算法的前一版本从环境中采样剧集，对最佳剧集进行训练，然后将其丢弃。然而，当成功剧集的数量很少时，可以将“精英”剧集保持更长时间，保持它们几次迭代以在其上进行训练。我们只需要修改代码中的一行:

elite_candidates= full_batch + batch#elite_candidates= batch

通过 TensorBoard 看到的结果是:

我们可以看到所需的迭代次数再次减少。

4.交叉熵方法的局限性

到目前为止，我们已经看到，通过所提出的改进，通过很少的训练循环迭代，我们可以找到一个好的神经网络。但这是因为我们在谈论一个非常简单的“防滑”环境。但是如果我们有一个“湿滑”的环境呢？

slippedy_env = gym.make(‘FrozenLake-v0’, is_slippery=True)class OneHotWrapper(gym.ObservationWrapper):
      def __init__(self, env):
          super(OneHotWrapper, self).__init__(env)
          self.observation_space = gym.spaces.Box(0.0, 1.0,
                (env.observation_space.n, ), dtype=np.float32)

      def observation(self, observation):
          r = np.copy(self.observation_space.low)
          r[observation] = 1.0
          return renv = OneHotWrapper(slippedy_env)

再次 TensorBoard 是一个大的帮助。在下图中，我们看到了算法在第一次迭代中的行为。它不能够脱去奖赏的价值:

但是，如果我们再等待 5000 次迭代，我们会看到它会有所改善，但从那里开始，它会停滞不前，不再能够超过某个阈值:

尽管我们已经等待了两个多小时，但它仍然没有改善，没有超过 60%的阈值:

5.摘要

在这两篇关于交叉熵方法的文章中，读者熟悉了这种方法。我们选择这种方法是因为它是一个很好的热身，因为它简单但非常强大，尽管它有局限性，并且合并了强化学习和深度学习。

我们将它应用于冰冻湖环境。我们已经看到，对于简单的“防滑”环境，with 可以找到一个很好的神经网络。但是如果我们考虑一个“光滑”的环境，交叉熵方法就无法找到(训练神经网络的)解决方案。在本系列的后面，您将熟悉解决这些限制的其他方法。

在开始本系列新部分的下一篇文章中，我们将转向对 RL 方法的更系统的研究，并讨论基于值的方法家族。

下期见！。

这篇文章的全部代码可以在 GitHub上找到，使用这个链接 可以作为一个 Colab 谷歌笔记本运行。**

鸣谢:这篇文章中的代码是从 Maxim Lapan 的代码中得到启发的，他写了一本关于这个主题的优秀的实用书籍。

深度强化学习讲解系列

由 UPC 巴塞罗那理工大学 和 巴塞罗那超级计算中心

一个轻松的介绍性系列以一种实用的方式逐渐向读者介绍这项令人兴奋的技术，它是人工智能领域最新突破性进展的真正推动者。

** [## 深度强化学习解释-乔迪托雷斯。人工智能

本系列的内容](https://torres.ai/deep-reinforcement-learning-explained-series/)

关于这个系列

我在五月开始写这个系列，在巴塞罗那的**封锁期。**老实说，由于封锁，在业余时间写这些帖子帮助了我 #StayAtHome 。感谢您当年阅读这份刊物；它证明了我所做的努力。

免责声明 —这些帖子是在巴塞罗纳封锁期间写的，目的是分散个人注意力和传播科学知识，以防对某人有所帮助，但不是为了成为 DRL 地区的学术参考文献。如果读者需要更严谨的文档，本系列的最后一篇文章提供了大量的学术资源和书籍供读者参考。作者意识到这一系列的帖子可能包含一些错误，如果目的是一个学术文件，则需要对英文文本进行修订以改进它。但是，尽管作者想提高内容的数量和质量，他的职业承诺并没有留给他这样做的自由时间。然而，作者同意提炼所有那些读者可以尽快报告的错误。**

对脏数据的最后一击

原文：https://towardsdatascience.com/cross-field-validation-using-pandas-f7a316fd37b7?source=collection_archive---------28-----------------------

用熊猫进行跨领域验证

照片由 伊恩·贝克利 上 像素

介绍

如今，数据不再来自单一来源。通常情况下，它被收集在不同的位置，并合并在一起。合并数据时的一个常见挑战是数据完整性。简而言之，通过使用多个字段检查另一个字段的有效性来确保我们的数据是正确的。用更好的术语来说，这个过程叫做交叉字段验证。

对数据集的数据完整性进行健全性检查对于进行准确的分析和运行机器学习模型至关重要。交叉字段验证应该在您处理了大多数其他清理问题(如缺失值插补、确保字段约束到位等)之后进行。

我为这篇文章写了关于执行时间的代码片段。由于跨字段验证可能涉及对数百万个观察值跨多个列执行操作，因此执行速度非常重要。这里建议的解决方案应该具有足够的可伸缩性，甚至可以处理大规模数据集。

设置

我生成了假数据来进行跨领域验证:

交叉字段验证，示例 1

在设置部分，我们加载了一个假的people数据集。举例来说，我们将假设这些数据是从两个来源收集的:提供每个人的全名和生日的人口普查数据，这些数据后来与他们的医院记录合并在一起。

为了进行准确的分析，我们应该确保我们的数据是有效的。在这种情况下，我们可以检查两个字段的有效性:年龄和身体质量指数(身体质量指数)。

先说年龄。我们必须确保当我们从当前年份中减去他们的出生年份时，结果与age列相匹配。

当您执行跨字段验证时，速度应该是主要考虑的问题。与我们的小例子不同，您可能需要处理数百万次观察。对任何规模的数据集进行跨字段验证的最快方法之一是pandas的apply函数。

这里有一个简单的apply的例子:

上面是一个按列执行的例子。apply接受一个函数名作为参数，并在被调用的列的每个元素上调用该函数。该函数有一个额外的参数axis，默认设置为0或rows。如果我们将其设置为1或columns，该功能将转换为按行执行。

关于axis参数的说明:axis='rows'表示沿着垂直的行轴执行操作，因为行是垂直堆叠的。axis='columns'表示沿水平的列轴执行操作，因为列是水平堆叠的。这两个术语让很多人感到困惑，因为它们看起来像是在做与他们被告知的相反的事情。事实上，只需要改变视角，或者用你愿意的话来说。

让我们创建一个函数来验证一个人的年龄:

因为我们将使用apply进行逐行操作，所以它的输入将是数据集的每一行。这就是为什么我们可以像在正常情况下一样轻松地访问每一列的值。

使用我们之前导入的datetime包，我们将存储今天的日期。然后，我们通过相互减去年份来计算年龄。为此，您必须确保birthday列具有datetime数据类型。

在return语句中，我们比较了计算的年龄和给定的年龄，如果它们匹配，则返回True，否则返回False:

该功能按预期工作。现在，我们可以对无效年龄(如果有)的数据进行子集划分:

people[people['age_valid'] == False]

有 75 行的年龄无效。如果你算一下，年龄是不匹配的。为了纠正这些值，我们可以编写一个新的函数，但是这将涉及代码重复。我们可以更新validate_age来用有效值替换任何无效值:

我们可以使用assert语句来确保操作成功:

交叉字段验证，示例 2

接下来，我们将验证体重指数列。

体重指数是从一个人的体重和身高得出的数值。

快速的谷歌搜索给出了计算身体质量指数的公式:

图片由 维基 提供

使用第一个示例中的思想，我们将为身体质量指数创建用正确值替换无效身体质量指数的函数:

用validate_启动所有的验证函数是一个很好的实践。这向代码的读者发出了您正在执行验证的信号。

跨字段验证、速度比较

在本节中，我们将对不同的跨字段验证方法进行速度比较。我们将从验证bmi的apply函数开始:

10k 数据集大约需要 0.3 秒。接下来，我们将使用熊猫iterrows()的 for 循环:

花了 10 倍的时间！况且这个时间差不会是线性的。对于更大的数据集，这种差异变得越来越大。我不认为任何 for 循环能打败apply函数，但我们也试试一般比iterrows()更快的itertuples:

还是比apply慢很多。所以，跨字段验证的一般经验是总是使用apply函数。

如果你喜欢这篇文章，请分享并留下反馈。作为一名作家，你的支持对我来说意味着一切！

阅读更多与主题相关的文章:

[## 掌握 DS/ML 中最耗时的任务，#1

处理常见的数据问题

towardsdatascience.com](/data-type-constraints-data-range-constraints-duplicate-data-with-pandas-44897a350b1e) [## 掌握 DS/ML 中最讨厌的任务

用 Pandas 清理分类数据

towardsdatascience.com](/master-the-most-hated-task-in-ds-ml-3b9779276d7c) [## FuzzyWuzzy:Python 中的模糊字符串匹配，初学者指南

…以及在真实数据集上的动手实践

towardsdatascience.com](/fuzzywuzzy-fuzzy-string-matching-in-python-beginners-guide-9adc0edf4b35) [## 数据科学中的数据一致性

处理熊猫最常见的一致性问题

towardsdatascience.com](/data-uniformity-in-data-science-9bec114fbfae) [## 认识熊猫最难的功能，第一部分

掌握 pivot_table()、stack()、unstack()的时机和方式

towardsdatascience.com](/meet-the-hardest-functions-of-pandas-part-i-7d1f74597e92)

基于颤振的跨平台 NLP 图形用户界面

原文：https://towardsdatascience.com/cross-platform-nlp-gui-on-flutter-75d59170864?source=collection_archive---------14-----------------------

Flutter + Python REST 后端的情感分析 GUI

适用于 Android、平板电脑和网络(iOS 也是！)

目标:

根据我的上一篇文章 [2]，我启动了一个项目来构建一个黑仔聊天应用程序，该应用程序利用 NLP 情绪分析器在实时聊天中执行实时聊天分析。本文是该项目的 R & D 阶段:

• 用于情感分析的后端 REST 服务
• 前端可视化工具来查看模型产生的结果

虽然我可以在 Python 笔记本中更容易地做到这一点，但我最终将在 Flutter 中构建聊天 GUI，所以这是一个很好的实践！

后端 Python 服务

在对 NLP 情感分析器的变体进行了大量研究之后[4]，我挑选了几个简单的进行交叉比较:

• 维德
• 文本 Blob
• Azure 文本分析(认知服务)
• 谷歌云自然语言 API

还有十几个其他的库，我计划建立我自己的“Foo NLP”(为了体验)，我将在另一个博客中详述。最终，我会添加圣杯 BERT [5],但这需要一些关于如何微调和操作 w/o 的策略，这让我在 Azure 上花费了$$$计算时间。

我的 REST API 有一个简单的接口:

• 输入:文本字符串
• 输出:情绪得分(-1 到+1，即从负到正的范围)

URL 获取格式为"【http://nlp.foostack.ai/nlp/sa/all?textinput=I 爱你】***"***您可以现场测试并查看其余 JSON 结果:

休息服务结果

Python 实现使用了 Flask web 框架，并公开了一个 REST API，该 API 反过来调用一些 NLP 情感分析器库或 web 服务，并将结果聚合到 JSON 响应中。Azure 上简单而便宜的托管服务。

REST 服务的代码[1]

颤振跨平台图形用户界面

大多数人都知道 Flutter 是一个很棒的 Android+iOS 跨平台开发系统，但截至 2019 年年中，它还做 Web。网络支持工作得非常好，尽管有它的怪癖:

• 一些第三方控件可能无法工作。(例如，Url 启动器直到最近升级后才在 web 上运行)
• 复制-粘贴在 Web 中不起作用。文本等看起来像不可点击的图像或奇怪的东西(我需要进一步调查)
• 开发周期是一个有点笨重的单独构建和测试 web
• 添加自定义 web 控件或 HTML/JS 似乎很困难

最终，Flutter Web 对 FooStack 的客户来说绰绰有余。

我的应用程序的结构

Flutter 将所有内容嵌套在子部件中。比如，垂直堆叠条目的列部件，增加空间的填充部件，标签的文本部件，等等。使一个简单的乐高式可互换系统。只需找出要抓取的组件，并将其堆叠在另一个小部件的上方、下方或内部。

我的 Flutter 应用程序的抽象结构:

- <Widget build>
 - Scaffold               # shortcut with top,body,footer areas
   - appBar:
   - body:Center          # centers all subcomponents
     - Column             # aligns subcomponents down the col
       - Padding
       - Text             # title (Foo Sentiment Analyzer)
       - ContrainedBox    # width controlling container
        - TextFormField   # input box for text to analyze
       - FlatButton       # submit button
       - Text             # title (Results)
       - Wrap             # wrap n-results across and down 
        - Container
         - Column         # single column result table 
          - DataTable     # formatted results table
            - DataColumns # headers  
            - DataCells   # rows
   - floatingButton:      # bottom right help button

相同逻辑应用的可视化:

颤振代码/布局的直观表示

应用程序的实际飞镖/颤振代码

另一个有趣的代码是我们如何从 GUI 调用 REST 服务。在 Go 按钮上，我们有一个事件处理程序“onPressed ”,它被映射到 _submit 函数。

**FlatButton** (
  child: Text(**'**Go**'**),
  color: Colors.*blue*,
  textColor: Colors.*white*,
 **onPressed: _submit,** ),

我们将 submit()定义为一个向 REST 服务发出 HTTP 请求并返回 JSON 的方法。JSON 被重新映射到供 GUI 处理的映射列表。还有更多关于 GUI 如何自动更新的内容，我就不多说了(StatefulWidgets 等)。

**void _submit() async {
***// call REST service and extract JSON body* var host = 'http://flaskmli.azurewebsites.net/nlp/sa/alldata=';var response = await http.get(host+inputController.text);
  var resp = response.body; *// extract JSON "results" array to a Map (dictionary)
  // push it onto the new dataList array (list of Maps)*  Map<String, dynamic> nlps = jsonDecode(resp);
  List<dynamic> results = nlps['results'];
  List<Map<String, dynamic>> dataList = [];
  results.forEach((result) {
    dataList.add(result);
  }); *// bit of hack here, add input text to _rawContentList*  _rawContentList.insert(0,[dataList, inputController.text])inputController.text = ''; *// reset focus (clears keyboard on mobile devices)*  FocusScope.*of*(context).requestFocus(FocusNode());
  setState(() {});   *// make GUI refresh from _rawContentList*
}

都搞定了！ 我越来越擅长旋舞了，这个只用了几天就造好了。

我可以通过 Android Studio 和谷歌 Play 商店开发并发布我的 Android、平板电脑和 iPhone 应用程序。要发布我的 Flutter Web 应用程序，我只需运行“flutter build web”并手动将 web/build 构件部署到我的 Web 服务器上(实际上是将它们复制到一个现有的站点上，在我的例子中是复制到http://foostack.ai/nlp——请随意测试)。

现场 Foostack NLP 试用http://foostack.ai/nlp

感谢阅读。

参考与启示

[1]之前我的 Flutter NLP 聊天项目的文章—https://medium . com/Flutter-community/NLP-Chat-on-Flutter-azure-676 a 4768 fbb

[2]学习颤振的前期文章—https://code burst . io/why-I-a-Sr-manager-learned-Flutter-8d a9 a 05 b 2326？来源= - 5 -

[3]启发我的好文章—https://towards data science . com/a-practices-guide-to-natural-language-processing-part-I-processing-understanding-text-9 F4 abfd 13 e 72

[4]关于 BERT 和一些其他 NLP 模型的一些信息—https://medium . com/swlh/BERT—双向—编码器—表示—来自—变压器—C1 ba 3 ef 5 e 2 f 4