卡普兰·迈耶曲线:介绍
这个帖子的代码可以在 Github 上找到 。一个完全交互式的应用程序，可以调整样本大小、审查、生存收益等参数，并查看对风险比的影响……可以在shinyapps找到。
K aplan-Meier 曲线广泛用于临床和基础研究，但在制作或解释它们时，需要注意一些重要的陷阱。在这篇短文中，我将给出一个关于卡普兰迈耶图上数据表示的基本概述。
Kaplan-Meier 估计量用于估计生存函数。这个函数的可视化表示通常被称为卡普兰-迈耶曲线，它显示了某个时间间隔内某个事件(例如，生存)的概率是多少。如果样本量足够大，曲线应该接近被调查人群的真实生存函数。
它通常在一项研究中比较两组(比如接受治疗 A 的一组和接受治疗 B 的一组)。
治疗 B 似乎比治疗 A 做得更好(中位生存时间为+/- 47 个月对 30 个月，具有显著的 p 值)。在这篇文章中，我只探讨治疗组 A，不会比较两组。
基本卡普兰迈耶图
让我们从创建一些基本数据开始。我们有 10 名患者参与了一项研究(所谓的“风险”)，随访时间为 10 个月。每个参与者都得到相同的待遇。
Cohort without censored data
如果我们仔细看看“跟进”和“事件类型”列:
- 后续时间可以是任何时间间隔:分钟、天、月、年。
- 事件类型 1 等于一个事件。癌症试验中的典型事件可能是死亡，但卡普兰-迈耶曲线也可以用于其他类型的研究。例如，安参加了一项虚构的抗癌新药研究，但在 4 个月后去世。
- 事件类型 0 等于右删截事件。
为了简单起见，在第一个例子中没有审查事件。
研究开始。每个月都有一名参与者体验一次活动。每发生一次事件，存活概率下降剩余曲线的 10%(=事件数除以处于危险中的人数)，直到研究结束时达到零。
带有删失数据的卡普兰迈耶图
让我们给前面的图表添加一些删失数据。
当关于存活时间的信息不完整时，观察值被称为删失的；最常见的形式是右删截(与左删截和区间删截相反，这里不讨论)。在研究期间没有经历感兴趣事件的患者被称为“右删截”。此人的存活时间被认为至少与研究持续时间一样长。右删截的另一个例子是当一个人在研究观察时间结束之前退出研究，并且没有经历该事件。换句话说，删失数据是一种缺失数据。
安、玛丽和伊丽莎白在研究完成前就离开了。在研究结束时，Kate 没有出现事件。与之前的“楼梯”模式相比，曲线看起来已经非常不同了。
Cohort with censored data (Ann, Mary, Elizabeth and Kate). Note that Andy experienced an event at 6.2 months instead of 7 months in the example above (and was not censored).
现在，事件、审查和卡普兰迈耶曲线上的下降之间的关系是什么？
如果我们看一下第一个有活动的参与者(约翰)，我们会发现 1 个月后我们下降了 0.1，或者说剩余高度的 10%:
如果我们再等一会儿，我们可以看到在第 5 个月，还有 6 名患者处于危险之中。两个已经有了一个事件，还有两个已经被审查。在下一个事件中，曲线下降剩余高度的 16%(而不是研究开始时的 10%)，因为处于危险中的人更少:
这种情况一直持续到研究期结束，或者直到处于危险中的患者数量达到 0。最后一滴是最大的。在最后一次下降时，曲线下降剩余高度的 50%(或总高度的 20%)。然而，仍然只有一个人经历了一次事件，与研究开始时相同(当时跌落仅为剩余(=总)高度的 10%)。这是因为在研究中只有 2 人处于危险中。
置信区间的重要性
特别是当只有极少数患者处于危险中时，一个删失事件的影响会对 KM 曲线的外观产生很大的影响。
在前面的情节中，似乎生存曲线在 20%的生存概率处达到平稳状态。如果我们在 Joe 和 Kate(参与者 9 和 10)之间交换审查状态，KM 曲线会发生剧烈变化，并在研究期结束时降至 0。在这种情况下(曲线 B)，所有参与者要么有一个事件，要么被审查。
The event type for Joe and Kate are reversed in scenario B
换句话说，只有一个事件标志着存活曲线达到 0 或达到稳定在 20%的平台之间的差异。
如果我们在 KM 曲线上绘制 95%的置信区间，我们也可以看到这一点。置信区间非常宽，这表明该研究的参与者非常少。此外，随着时间的推移，95%置信区间会增加，因为受审查个体的数量会增加。
排除审查数据:是还是不是？
小型数据集
我们可以模拟最好的情况(删截等于无事件)和最坏的情况(删截等于事件)，并将其与实际曲线进行比较。
The first 3 observations for every scenario (best, worst and actual)
在最好的情况下，曲线在研究结束时停止在 40%的生存概率，而在最坏的情况下，曲线下降到 0。中位存活时间也大不相同:
- 实际曲线:6.2 个月
- 最好的情况:8.1 个月
- 最坏情况:5.5 个月
大型数据集
如果我们增加样本量，这就更加惊人了。在模拟中，样本量从 10 个增加到 100 个，随访时间为 48 个月。在这个模拟中，40%的个体在第 0 个月和第 48 个月之间被(随机)审查。这再次表明，中位存活时间可以有很大的不同。
结论
- 删失数据会显著影响 KM 曲线，但在拟合模型时必须包括在内。
- 如果出现大的落差，在解释 KM 的终点时要小心，尤其是在研究接近尾声时。这通常意味着没有很多人处于危险中(并且 95% CI 区间更宽)。
- 即使没有报告或者没有显示置信区间，跌落的高度也可以告诉你有多少病人处于危险中。
关于作者:
我是 Ruben Van Paemel 博士，2017 年从医学院毕业后，我开始在根特大学(医学遗传学中心)担任博士研究员，由研究基金会 Flanders 资助。我也是根特大学医院的儿科住院医师。可以在推特上关注我:@ RubenVanPaemel
我从事神经母细胞瘤的研究，这是一种罕见但极具破坏性的肿瘤，最常见于非常年幼的儿童。我们的团队试图了解潜在的基因改变，以提高神经母细胞瘤儿童的诊断、治疗和最终存活率。
参考
- 这篇文章的灵感来自 Pancanology 给出的解释:https://www.youtube.com/watch?v=KE1tkZmWhqU。
- 关于审查的定义:https://www.cscu.cornell.edu/news/statnews/stnews78.pdf
- 封面照片: Unsplash
卡普兰·迈耶的错误
了解如何避免常见的生存分析错误并改善预后因素研究
Photo Credit: Louis Reed
患者的预后是指未来医疗结果的风险，如手术并发症、肿瘤复发或死亡。预后因素研究是对可以预测患者预后的信息的研究。经验证的预后因素是转化研究的重要组成部分，转化研究用于为临床决策提供信息，对疾病机制进行假设，并对患者进行分层以获得个性化药物。
生存数据被用来研究预后因素，而卡普兰迈耶分析因其假定的易用性而经常被使用。不幸的是，一些研究人员误解了 Kaplan Meier 的分析，并错误地使用了它，这给他们的分析带来了统计问题，并可能导致医疗错误。
这篇文章的目标是以一种不具备深厚统计学背景的研究人员可以理解的方式强调常见的 Kaplan Meier 错误。虽然我更喜欢写如何正确分析生存数据，但这种希望几乎是不可能的。生存分析是一个复杂的领域，整个教科书都致力于这个主题。相反，我希望读完这篇文章后，你能够发现常见的错误，在你自己的研究中避免这些错误，并提高你评论预后因素研究的能力。
卡普兰·迈耶评论
在我们讨论卡普兰迈耶分析的问题之前，卡普兰迈耶到底是什么？Kaplan Meier 估计值是一种统计方法，用于估计一段时间内的生存概率。这一估计很重要，因为它描述了疾病的总体预后——这是帮助患者和医生讨论医疗保健计划的有用信息。卡普兰迈耶图形象化了患者存活一定时间的概率。图 1 描绘了 NCCTG 群组肺癌存活概率。中位生存期，即 50%的患者仍然存活的时间，约为 300 天。曲线两侧的浅红色带是 95%的置信区间，表明真实的生存概率可能在红色区域内。图 1 是我们在没有关于患者的任何额外信息的情况下所能做出的最全面的风险评估。它是 NCCTG 队列中所有个体的生存概率。
Figure 1. Overall survival of NCCTG lung cancer patients. Data from the lung dataset in the R survival package. Note the median survival time is indicated by the dotted line intercepting the x-axis.
尽管图 1 很好地总结了肺癌患者的总体预后，但我们知道有许多因素导致不同的生存时间。有了额外的信息，我们可以给个体患者更准确的生存估计。NCCTG 数据集包括每个患者的性别，让我们分别估计男性和女性的生存概率，如图 2 所示。
Figure 2. Overall survival for lung cancer patients stratified by sex.
图 2 显示女性患者比男性患者存活时间更长。您可能会注意到，图 1 中的曲线出现在图 2 中曲线的中间。这不是巧合；在没有任何患者信息的情况下，图 1 中的总体估计值平均了男性和女性的生存概率。
注意卡普兰·迈耶的解释没有提到生存差异测试。这是因为卡普兰·迈耶估计量只估计生存概率。它不会比较它们。为了对这些生存概率做出推断，我们需要对数秩检验。
对数秩检验是一种假设检验，用于比较两组之间的生存概率。它计算一个 p 值，表明数据和零假设之间的相容性，前提是所有的测试假设都是正确的。当我们有一个来自较大总体的数据样本，并且我们想对总体进行陈述时，假设检验是有用的。因为我们没有每个肺癌患者的测量数据，所以我们的患者样本存在不确定性。统计检验通过为关于总体的陈述提供一种证据尺度来帮助我们应对这种不确定性。尽管统计测试可以帮助我们对总体做出推断(决定)，但测试也有其局限性。众所周知，p 值很难解释，许多统计学家呼吁结束统计显著性，即如果 p 值小于 0.05，则将发现标记为显著的做法。查看《自然》杂志上的这篇评论，了解更多关于 p 值的局限性。
现在让我们来看一个对数秩检验的简单例子。我们已经从 NCCTG 研究中收集了肺癌患者的数据，我们想对性别特异性存活率做出推断。首先，我们假设男性和女性肺癌患者之间存在生存差异。无效假设是男性和女性之间不存在生存差异。另一个假设是生存差异确实存在。然后，我们使用统计软件来计算对数秩检验的 p 值。该测试产生 0.001 的 p 值，表明在普通肺癌人群中男性和女性之间存在生存差异。
从现在开始，我将使用 Kaplan Meier 分析来表示使用 Kaplan Meier 图和对数秩检验来分析生存差异。本文的其余部分将检查研究人员在使用 Kaplan Meier 分析生存数据时所犯的错误。
分析连续变量
二元、分类和连续变量在医学研究中很普遍。二元变量仅由两个值组成，如治疗对不治疗。分类变量类似于二元变量，但有两个以上的选择，如安慰剂对药物 A 对药物 b。连续变量是数字变量，如年龄、基因表达、血压和肿瘤大小。这些变量可以取无限多的值，这取决于变量测量的精确程度。因为连续变量可以取无穷大的值，所以没有像二元或分类变量那样的组。
试图用 Kaplan Meier 分析来分析连续变量的研究人员会立即遇到问题:log-rank 检验只比较组间存活率。我们如何在没有任何分组的情况下分析一个变量？要使用对数秩检验，连续变量必须以某种方式分成几组。最常见的方法是将变量二分化,从而将值分类为低或高。中值分界点通常用于区分高低分组(图 3)。
Figure 3. Adapted from Liu et al. 2018. Patients were separated into groups of low and high mRNA expression. The initial equal number of patients in each group indicates the median was used as the cutpoint.
一些研究使用“最优”分界点将连续变量二分法。最佳分界点被定义为在组间产生最大生存间隔，产生最小 p 值的值。要确定最佳切割点，通常要检查所有可能的值，并选择产生最小 p 值的切割点。这种方法是有问题的，因为测试每个切割点会产生多重测试问题。测试这么多不同的切割点会夸大 p 值，并大大增加假阳性的机会。更糟糕的是，最佳分界点通常依赖于数据集，这意味着在一项研究中发现的分界点在其他 studies⁴⁻中不太可能相同。研究人员应该避免使用最佳分界点来二分法连续变量。
即使研究人员避免“最佳”分界点并使用中位数，二分法也会导致统计能力的损失，并对风险的分布做出错误的假设。统计功效是假设我们寻找的效应存在，我们的统计测试检测到它的概率。功效取决于样本数量、数据的可变性和所用的统计方法(一些方法比其他方法更有效)。高能量对于科学发现是至关重要的，因为低能量的研究常常会错过重要的结果。研究人员应该使用最大化统计能力的方法。
将连续变量二分法通过强制所有测量值采用简单的是或否值来降低功耗。使用二元变量而不是连续变量可以将检测效果所需的样本数量增加三倍。使用低统计功效的方法不仅成本高昂，而且不道德，因为需要的患者比必要的要多(图 4)。应该使用不二分法的方法，如 Cox 回归。
Figure 4. Simulations comparing statistical power of median cutpoint Kaplan Meier (Median KM) and linear Cox regression (Linear Cox) to detect a continuous linear effect on survival. The dashed red line represents 80% power. HR=Hazard Ratio. Simulation details can be found here.
两分法还对 patients⁴.的风险分布做出了错误的假设例如，考虑将年龄作为心肌梗塞(MI)的预后因素。老年通常与更大的心肌梗死风险相关。使用 65 岁的中位年龄，所有小于 65 岁的患者将被分类为年轻，而超过 65 岁的患者被分类为老年。这种二分法假定所有年轻患者都有相同的心肌梗死风险。它还假设所有老年患者都比年轻患者有相同的、更高的心肌梗死风险(图 5)。这种假设显然是错误的，因为 64 岁的人比 40 岁的人更容易患心脏病。没有理由一个 64 岁的人应该和一个 40 岁的人在同一个危险群；没有哪种生物开关在我们 65 岁时突然开启，会大幅增加我们 64 岁时患心脏病的风险。
Figure 5. Stepwise risk function assumed by dichotomizing a continuous variable into low and high groups
虽然一些生物变量确实显示出逐步的作用机制，在达到某个值之前什么都不会发生——想想神经元中打开离子门控通道的 55mV 动作电位——但研究表明大多数生理变量并不遵循这样的 mechanisms⁹.相反，风险随着变量的变化而逐渐变化。一些变量甚至遵循非线性趋势(图 6)。像 Cox 回归这样的连续建模方法可以考虑到这些趋势，考虑到 40 岁的人与 41 岁的人而不是 64 岁的人有相似的风险。
Figure 6. Adapted from Regression Modeling Strategies by Frank Harrell. Probability of survival gradually increases as the treadmill score increases. Cox regression can use nonlinear functions to model this type of relationship.
协变量调整
预后研究通常分析多个变量，也称为协变量。常见的情况是，研究单独分析每个变量，也分析多个变量(图 7)。单独分析每个变量是单变量分析，而一起分析多个变量被称为多变量分析。
FIgure 7. Adapted from Bill-Axelson et al. Hazard ratios for prostate cancer prognostic factors. The 4th column shows hazard ratios only adjusted for age (practically univariable), while the 5th column shows hazard ratios adjusted for multiple variables (multivariable).
这两种分析方法都很受欢迎，尽管单变量模型很少提供关于预后因素重要性⁻的信息。当多个因素影响生存率时，单变量分析会高估或低估预后效应，因为分析假设多个变量的效应归因于被分析的单个变量。这被称为遗漏变量偏差，解释了为什么图 7 中的单变量风险比远大于多变量风险比。需要多变量模型来调整多个预后因素，减少遗漏变量的偏倚，并理清每个变量对生存率的影响。
卡普兰迈耶是一个单变量的方法。这意味着 Kaplan Meier 的结果很容易有偏差，夸大了预后的重要性或完全错过了信号。在单变量 Cox 回归中分析单个连续标志物是单变量分析的另一个例子，会产生无信息的结果。应该使用可以调整多个变量的多变量方法，如 Cox 回归。
许多研究将声称一种新的生物标志物仅从单变量 Kaplan Meier 分析中预测。虽然生物标志物可能是预后性的，但这很难仅从单变量分析中得到证明。至少应该用 Cox 模型和其他基本预后因素来分析这个变量。像年龄和性别这样的信息通常是可以获得的，并且是许多疾病的预后信息，可以作为很好的基线变量进行调整。虽然不可能对每个潜在变量进行调整，但进行文献回顾和与临床医生交谈是识别对分析有重大影响的强预后因素的好方法。如果信号在多变量分析中仍然成立，新的生物标志物就有希望了。
增值价值
虽然在多变量模型中显示一个小的 p 值是提示一个标志物具有预后价值的最低限度，但是有更严格的方法来评估预后因子重要性⁴.因为许多预后因素已经存在，研究人员应该调查新的预后因素的附加值，量化新的标记改善预测的程度。
有许多方法可以量化新的预后标记物增加了多少信息。ROC 曲线下面积(AUC-ROC)、似然比检验和 r 是衡量预测性能⁻ ⁵.的常用指标虽然讨论每个指标的利弊超出了本文的范围，但是研究人员必须证明他们的新标记的附加值。
量化附加值后，评估与附加值相关的成本至关重要。并非所有的生物标志物都是相同的，一些标志物可以提供比其他标志物更多的信息。根据疾病的不同，传统的临床实验室可以提供比遗传标记或医疗记录更多的信息。重要的是要明白这些标记中的每一个都有不同的成本。像基因标记这样更昂贵的测试可能需要比更便宜的替代方法提供更多的信息来证明它们的成本。只有医生和患者才能决定增加的信息是否值得增加的成本，因此预后研究严格量化附加值是至关重要的。
结论
错误分析生存数据的方法有很多。研究人员应该避免将连续变量二分法，使用多变量模型，并量化新的预后标记物的附加值。遵循这些指南可以降低我们对低质量研究的容忍度，并改善未来的研究，从而改善患者护理。
如果你想了解更多关于生存分析方法的知识，比如 Cox 回归，可以看看我关于生存分析最佳实践的演讲。
参考
[1] R. Riley 等，预后研究策略(进展)2:预后因素研究(2013)， PLOS 医学
[2] A. Hingorani 等，预后研究策略(进展)4:分层医学研究(2013)， BMJ
[3] S. Greenland 等人，统计检验、P 值、置信区间和功效:误解指南(2016 年)，欧洲流行病学杂志
[4] C. Bennette 等人，反对分位数:流行病学研究中连续变量的分类及其不满意之处(2012 年)， BMC 医学研究方法学
[5] D. Altman，在预后因素评估中使用“最佳”切割点的危险(1994 年)， JNCI:国家癌症研究所杂志
[6] K. Metze，连续数据的二分法—预后因素研究中的一个陷阱(2008 年)，病理学—研究和实践
[7] P. Royston 等人，多元回归中的二分法连续预测值:一个坏主意(2006 年)，医学统计学
[8] N. Dawson 等人，统计分析中的二分法连续变量:避免实践(2012)，医疗决策
[9] A. Giannoni 等，连续生理变量中的最佳预后阈值真的存在吗？分析表观阈值的来源，对峰值耗氧量、射血分数和脑钠肽进行系统综述(2014)， PLOS 一
[10] D. Altman，将连续变量二分法中的问题(1994)，美国流行病学杂志
[11] D. Altman，P. Royston，将连续变量二分法的成本(2006 年)， BMJ:英国医学杂志
[12] K. Moons，新标记物的科学评价标准:展望(2010)，临床化学
[13] E. Steyerberg 等人，评估诊断和预后标志物的增量价值:综述和说明(2012 年)，欧洲临床研究杂志
[14] M. Pencina 等人，评估新标记物的额外预测能力:从 ROC 曲线下面积到重新分类和重新分类之后(2008 年)，医学统计学
[15] E. Steyerberg 等，预后研究策略(进展)3:预后模型研究(2013)， PLOS 医学
Kedro:数据科学的新工具
用于生产就绪数据管道的新 Python 库
在本帖中，我将介绍 Kedro ，这是一款面向数据科学家和数据工程师的全新开源工具。在简要描述了它是什么以及为什么它可能成为每个专业人员工具链的标准部分之后，我将在一个教程中描述如何使用它，您应该能够在十五分钟内完成。为未来的太空飞行系好安全带！
Image by stan (licensed under CC BY-SA 2.0)
假设你是一名数据科学家，为一名为公司做出关键财务决策的高管工作。她请你提供一个特别的分析，当你这样做时，她感谢你为她的计划提供了有用的见解。太好了！
三个月后，新晋升的主管，现在是你的 CEO，要求你在下一次计划会议上重新进行分析…而你不能。代码被破坏是因为您覆盖了文件的一些关键部分，并且您不记得当时使用的确切环境。或者，代码可能是好的，但它在一个大的 Jupyter 笔记本中，所有文件路径都是硬编码的，这意味着您必须费力地检查和更改每一个新数据输入。不太好！
数据科学家对软件工程的一些日常原则并不熟悉，他们并不都有广泛的编程背景。事实上，许多数据科学家都是自学的，作为研究项目的一部分或在工作中必要时学习编程。也许，一些数据科学家会争辩说他们的代码不需要高标准，因为他们不是在生产系统上工作。
任何支持业务决策流程的代码都应被视为生产代码
数据科学家可能不认为他们工作的主要产出是代码，但这并不意味着他们编写的代码不应该遵循软件工程团队期望的标准。事实上，它至少应该具有以下特征:
- 版本化 —使用 git 或类似的工具定期保存您的更改，无论您是独自工作还是在团队中工作。
- 再现性 —您应该能够将一个项目转移到另一台计算机上并运行它，而不需要大量的工作或重新配置。
- 遵循标准——通用的项目结构、标准的编码约定和工具。
- 文档 —自动化文档，使您的文档与您的代码保持同步。
- 模块化——代码可以很容易地执行和测试。
关于这些原则的更多细节，请看来自 QuantumBlack 的 Thomas Huijskens 的有用的博客文章。
凯卓是什么？
Kedro 是一个开发工作流工具，允许你创建可移植的数据管道。它将软件工程最佳实践应用到您的数据科学代码中，因此它是可复制的、模块化的和有据可查的。如果你使用 Kedro，你可以更少地担心如何编写生产就绪的代码(Kedro 为你做了繁重的工作),你将标准化你的团队合作的方式，让你们所有人更有效地工作。
许多数据科学家需要执行例行的数据清理、处理和编译任务，这些任务可能不是他们最喜欢的活动，但却占了他们日常任务的很大一部分。Kedro 使得构建数据管道来自动化“繁重的工作”变得更加容易，并且减少了在这种任务上花费的时间。
Kedro 由高级分析公司 QuantumBlack 创建，该公司于 2015 年被咨询巨头麦肯锡&公司收购。QuantumBlack 已经在麦肯锡的 60 多个项目中使用了 Kedro，现在决定将其开源。他们的目标是让员工、客户和第三方开发人员能够使用 Kedro 并在其上进行构建。通过根据自己的需求扩展这一开放工具，数据专业人员能够有效地完成他们的常规任务，并有可能将他们的改进分享给社区。
The team from Quantum Black explain Kedro
Kedro 是工作流调度器吗？
Kedro 不像 Airflow 和 Luigi 那样是工作流调度器。Kedro 使您的数据管道原型化变得容易，而 Airflow 和 Luigi 是互补的框架，在管理部署、调度、监控和警报方面非常出色。Kedro 管道就像是制造汽车零件的机器。气流或路易吉告诉不同的机器打开或关闭，以便一起工作，生产出一辆汽车。QuantumBlack 构建了一个 Kedro-Airflow 插件，提供了更快的原型开发时间，并降低了将管道转移到两个工作流调度器的门槛。
我需要知道什么？
Kedro 的文档是为初学者设计的，帮助他们开始创建自己的 Kedro 项目(Python 3.5+)。如果你只有非常基础的 Python 知识，那么你可能会发现学习曲线更具挑战性，但是忍耐一下，并遵循文档的指导。
与凯卓进行十五分钟的太空飞行
我简单易懂的 15 分钟教程将基于以下场景:
现在是 2160 年，太空旅游业正在蓬勃发展。在全球范围内，有数千家航天飞机公司将游客送上月球并返回。你已经能够找到三个(虚构的)数据集，包括每架航天飞机提供的便利设施、顾客评论和公司信息。您希望训练一个线性回归模型，该模型使用数据集来预测班车租赁价格。但是，在开始训练模型之前，您需要通过进行一些数据工程来准备数据，这是通过创建主表来为模型构建准备数据的过程。
正在设置
第一步，将 kedro pip 安装到一个新的 Python 3.5+虚拟环境中(我们推荐 conda )，并通过键入以下命令确认安装正确
kedro info
您应该会看到如下所示的 Kedro 图形:
这将另外给你你正在使用的 Kedro 版本。我在 2019 年 5 月基于版本 0.14.0 编写了本教程，由于这是一个活跃的开源项目，随着时间的推移，可能会对代码库进行更改，从而导致示例项目发生微小变化。我们将努力保持示例代码最新，虽然不是这篇博客，所以如果你发现任何不一致的地方，你应该参考 Kedro 文档和发布说明。
Kedro 工作流程
构建 Kedro 项目时，通常会遵循标准的开发工作流程，如下图所示。在本教程中，我将走过每一个步骤。
设置项目模板
为了简单起见，QuantumBlack 团队已经提供了您需要的所有代码，因此您只需从其 Github Repo 中克隆示例项目。在本教程中，您不需要设置项目样板。
一旦有了 Spaceflights 项目的代码，为了确保有必要的依赖项，请在 Python 3.5+虚拟环境中运行以下代码:
kedro install
设置数据
当可能需要引用不同位置的数据集时，Kedro 使用配置文件使项目的代码可以跨不同环境进行复制。
要为 Kedro 项目设置数据，通常需要将数据集添加到 data 文件夹中，并配置管理数据加载和保存的数据源注册表
本教程使用了航天公司往返月球的三个数据集，并使用了两种数据格式:。csv 和. xlsx .文件存储在项目目录的data/01_raw/文件夹中。
为了使用所提供的数据集，所有 Kedro 项目都有一个conf/base/catalog.yml文件，作为所使用数据集的注册表。注册数据集就像在。yml 文件，包括文件位置(路径)、给定数据集的参数、数据类型和版本。Kedro 支持一些类型的数据，如 csv，如果您查看 Spaceflights 教程的 catalog.yml 文件，您会看到所用数据集的以下条目:
companies:
type: CSVLocalDataSet
filepath: data/01_raw/companies.csvreviews:
type: CSVLocalDataSet
filepath: data/01_raw/reviews.csv
要检查 Kedro 是否正确加载了数据，并检查前五行数据，请打开一个终端窗口，并在 Kedro 项目目录中启动一个 IPython 会话(当您想要结束会话并继续学习本教程时，只需键入(exit()):
kedro ipython
io.load(‘companies’).head()
创建并运行管道
工作流的下一部分是从一组节点创建管道，这些节点是执行不同的单独任务的 Python 函数。在典型的项目中，项目的这一阶段包括三个步骤:
- 编写并记录您的节点函数
- 通过为每个节点指定输入和输出来构建管道
- 运行 Kedro，选择是顺序运行还是并行运行节点
数据工程管道
我们已经审查了 Spaceflights 项目的原始数据集，现在是时候考虑数据工程管道了，该管道在数据科学管道内处理数据并为模型做准备。这个管道预处理两个数据集，并将它们与第三个数据集合并到一个主表中。
在 nodes 文件夹内的文件 data_engineering.py 中，您将找到preprocess_companies和preprocess_shuttles函数(在 pipeline.py 中指定为管道内的节点)。每个函数接收一个数据帧并输出一个预处理数据，分别为预处理公司和预处理班车…
当 Kedro 运行数据工程管道时，它确定数据集是否在数据目录中注册(conf/base/catalog.yml)。如果注册了数据集，它会自动保存到指定的路径，而无需在函数本身中指定任何代码。如果数据集没有注册，Kedro 会在管道运行时将它存储在内存中，然后删除它。
在本教程中，预处理后的数据登记在conf/base/catalog.yml中:
preprocessed_companies:
type: CSVLocalDataSet
filepath: data/02_intermediate/preprocessed_companies.csvpreprocessed_shuttles:
type: CSVLocalDataSet
filepath: data/02_intermediate/preprocessed_shuttles.csv
选择CSVLocalDataSet是因为它的简单，但是你可以选择任何其他可用的数据集实现类来保存数据，例如，保存到数据库表、云存储(像 S3、Azure Blob Store 等)。)等。
data_engineering.py 文件还包括一个函数create_master_table,数据工程管道使用该函数将公司连接在一起，将数据帧传送并审核到一个主表中。
数据科学管道
数据科学管道构建了一个使用数据集的模型，由价格预测模型组成，该模型使用了来自 scikit-learn 库的简单 LinearRegression 实现。代码在src/kedro_tutorial/nodes/price_prediction.py文件中。
预测模型的测试大小和随机状态参数在conf/base/parameters.yml中指定，Kedro 在执行流水线时将它们输入到目录中。
合并管道
本工程的管线在 pipeline.py 中注明:
def create_pipeline(**kwargs): de_pipeline = Pipeline(
[
node(preprocess_companies, “companies”, “preprocessed_companies”),
node(preprocess_shuttles, “shuttles”, “preprocessed_shuttles”),
node(create_master_table,[“preprocessed_shuttles”, “preprocessed_companies”, “reviews”],“master_table”,),
],
name=”de”,
)ds_pipeline = Pipeline(
[
node(split_data,[“master_table”, “parameters”],[“X_train”, “X_test”, “y_train”, “y_test”],),
node(train_model, [“X_train”, “y_train”], “regressor”),
node(evaluate_model, [“regressor”, “X_test”, “y_test”], None),
],
name=”ds”,
)return de_pipeline + ds_pipeline
de_pipeline将对数据进行预处理，然后使用create_master_table将preprocessed_shuttles、preprocessed_companies和reviews组合成master_table数据集。然后ds_pipeline将创建特征，训练和评估模型。ds_pipeline 的第一个节点输出 4 个对象:X_train、X_test、y_train、y_test，这些对象随后用于训练模型，并且在最终节点中用于评估模型。
两条管线在de_pipeline + ds_pipeline合并在一起。添加管道的顺序并不重要，因为 Kedro 会自动检测所有节点的正确执行顺序。如果您指定了ds_pipeline + de_pipeline，将会产生相同的整体管道。
当您调用 kedro run 时，这两个管道都将被执行，您应该会看到类似如下的输出:
如果您在启动和运行教程代码时遇到任何问题，您应该检查您是否在 Python 3.5 环境中工作，并且已经安装了项目的所有依赖项。如果仍有问题，您应该前往 Stack Overflow 寻求社区的指导，如果您观察到的行为似乎是 Kedro 的问题，请在 Kedro 的 Github 库上提出问题。
凯卓跑步者
有两种不同的方式来运行 Kedro 管道。您可以指定:
SequentialRunner—按顺序运行您的节点:一旦一个节点完成了它的任务，下一个节点就会开始ParallelRunner—并行运行您的节点:独立节点能够同时运行，允许您利用多个 CPU 内核，并且当您的管道中有独立分支时，效率会更高。注意ParallelRunner执行任务并行化(即可以一次运行多个任务)，但不并行化任务内的计算。
默认情况下，当您调用 kedro run 时，Kedro 使用一个SequentialRunner。切换到使用ParallelRunner非常简单，只需提供一个额外的标志，如下所示:
kedro run — parallel
贯穿 Kedro 基础的教程到此结束。还有更多关于各种配置选项和优化的文档，您可以在自己的项目中使用，例如:
欢迎投稿！
如果您开始与 Kedro 合作，并希望为 Kedro 项目提供一个示例或更改，我们将欢迎与您合作的机会。请查阅投稿指南。
承认
Spaceflights 的例子是基于 QuantumBlack Labs 的 Kedro 团队编写的教程(Yetunde Dada、Ivan Danov、Dmitrii Deriabin、Lorena Balan、Gordon Wrigley、Kiyohito Kunii、Nasef Khan、Richard Westenra 和 Nikolaos Tsaousis)，他们好心地让我提前获得他们的代码和文档，以便为 TowardsDataScience 制作这个教程。谢谢大家！
把机器人关在笼子里——合作机器人有多有效(和安全)？
Co-bots are filling a niche in industrial manufacturing between humans and caged industrial robots, but do they offer enough value when balanced against the risk of injury? IPOPBA — FREEPIK
制造机器人正在挣脱牢笼。传感器技术和人工智能现在已经发展到这样一个阶段，即协作机器人(co-bots) 可以在各种各样的应用中与人类一起安全地工作，包括超市、农场和医院。但是制造业是联合机器人真正帮助提高生产力的地方，远远超过人类和机器人单独工作的生产力。
然而，随着市场的扩大，企业必须做好适当的准备，以充分利用合作机器人，避免代价高昂(如果不是危险的话)的错误。
让机器人与人类近距离接触是我们技术进步的巨大进步，将使我们能够实现新的复杂程度，并最大限度地降低受伤风险，特别是在制造业。但是就像任何新的强大的技术一样，在将合作机器人融入企业之前，有一些重要的考虑事项。
生产率悖论
与机器人一起工作是一个新概念:我们已经习惯了机器人在装配厂工作或在笼子里勤奋工作的想法，但与人类一起工作的机器人似乎仍然好得难以置信。这是因为工业机器人被专门设计成不与人类互动，这是有充分理由的:例如，2015 年，一名在大众汽车工厂安装机器人的承包商被误认为是汽车零件后，被 抓住并压在金属板 上。虽然这样的事件并不常见，但这些机器人的预期目的(举重物、使用腐蚀性化学品、高强度焊接)要求它们在执行太危险、太精确、对旁观者有潜在危险或人类自己根本不可能完成的任务时保持隔离。然而，由于这种符合目的的设计，使机器人在人类周围安全可能实际上降低了它们有效完成工作的能力——如果我们限制合作机器人，使它们在人类周围安全，它们能像笼子里的同类一样表现吗？
SAP Industries的联合总裁彼得·梅尔解释说:“合作机器人比传统的工业机器人更小更轻……[并且]配备了传感器，如果它感觉到有人在它的道路上，它就会指示合作机器人后退。”迈尔说，合作机器人在人类周围工作时会小心翼翼，这对我们来说是好事，但也提出了一个问题，即它们是否比工业机器人有更多好处，因为工业机器人“比合作机器人的操作精度、准确度和速度更高”。
最初，联合机器人可能会更多地被无力承担传统工业机器人空间和资金的公司使用，但随着它们的智能增长和传感器技术的进一步改善，联合机器人将找到自己的优势。
迄今为止，将人类和机器人分开一直是我们成功的唯一衡量标准，但迈尔和其他许多人认为，“合作机器人协助人类驱动的任务的能力提高了整个过程的生产率”，因为它确保了人类不必在危险或重复的任务上浪费时间。麻省理工学院的一项研究发现， 联合机器人将人类的闲置时间减少了 85% ，他们与斯帕坦堡宝马工厂的合作发现，某些任务(如在车门内侧卷起一层保护箔)消除了人类重复性劳损的风险，而不会对装配线造成任何额外的风险。
安全第一
合作机器人应该被视为不同于工业机器人。合作机器人不会取代需要关在笼子里的机器人，而是最有可能致力于增加人类的劳动:正如迈尔所说，“合作机器人正在接受从烤汉堡到执行高度专业化的手术任务的一切测试。”然而，协同机器人并不完全是即插即用的:就像任何学习和适应其环境的应用程序一样，它们需要接受适当的训练，目标要适合它们的特定任务(这并不总是像听起来那么容易)。Robotiq 的首席技术官 Jean-Phillipe Jobin 建议企业仔细考虑他们如何使用合作机器人，并为他们的员工和工作环境做好适当的准备，以避免在不适当的实施上浪费时间、精力和金钱。乔宾表示，制造企业在实施合作机器人时，尤其必须问自己三个至关重要的问题:“机器人在执行什么任务，机器人系统本身在做什么，它是否安全，以及机器人在哪个空间内移动？”
“一旦这些问题得到回答，”乔宾说，“制造商应该对涉及的每一步进行风险评估，包括如果机器人用于多项任务，将机器人从一项活动转移到另一项活动。”这种远见不仅对从合作机器人的特殊技能中受益至关重要，而且对确保它们在人类中安全运行也至关重要。Jobin 还指出，“每个人都有独特的视角，只有当每个使用机器人的人都参与进来时，安全才是可能的”——尽管对于首席管理人员来说，准确理解联合机器人在做什么很重要，但那些直接与联合机器人一起工作的人将不可避免地受到公司联合机器人战略的最大影响。
这种协作的元素(名字“合作机器人”的内在特征)也是一个不总是被考虑的要点:即合作机器人被设计成与人类一起完成某些任务，并完成既不适合人类也不适合传统笼中机器人的 肮脏、危险和枯燥的 工作。在实施联合机器人时，乔宾强调公司需要记住联合机器人的预期目的，即“将操作员从这些任务中解放出来，让他们专注于更有价值的任务”，并认为联合机器人安全完成任务的能力“与安全措施同步增长”。
合作机器人来了(说‘嗨’)
联合机器人的有效性将在未来几年得到检验，并且必须被证明超越了任何合理的怀疑，联合机器人才能真正起飞。我们已经看到直接或间接与人类合作的机器人数量大幅增加( 亚马逊 和 沃尔玛 最近公开涉足)，尽管过去几年头条新闻充斥着关于 联合机器人对就业 影响的猜测，但对联合机器人的真正考验是证明它们可以在大规模制造环境中安全工作。
正如乔宾所说，“曾经导致工人受伤的繁重任务现在可以由合作机器人安全高效地完成，”那些考虑将机器人带到工厂车间的人应该记住，这种增强是合作机器人的设计目的，并据此准备他们的业务。
这意味着培训和咨询员工，考虑技术的每一种可能的用途，并设置合作机器人来完成任务，让员工专注于更重要的事情。
合作机器人可能对一些人来说仍然是一个新奇的事物，但是一旦他们的利基建立起来，制造业就可以期待液压辅助的生产力激增。
原载于【https://www.forbes.com】。****
关注混杂因素:计算偏相关矩阵的演练
一个 R 演示程序，演示了计算部分相关矩阵的两种方法
Don’t forget about potential confounding variables! Photo from Wikimedia Commons
分析师在数据管理/预处理后执行的最常见步骤之一是运行相关性分析，以标准化的方式检查变量之间的成对关联。这是一种快速且相当轻松的方式来感受您的数据。然而，如果在您的数据集中潜伏着与两个感兴趣的变量相关的其他混淆变量，那么孤立地查看两个变量之间的关系可能会产生误导。
因此，在某些情况下，计算偏相关矩阵可能是更好的选择。这种矩阵将允许人们快速测量和观察 2 个变量之间的关联，同时控制数据集中的所有其他变量。下面，我们将从头开始讨论计算部分相关矩阵的两种方法，并说明如何使用“ppcor”软件包。
对于这个示例，我们将使用空气质量数据集的一部分，该数据集包含 1973 年部分时间内纽约每日空气质量水平的信息。
Manhattan in 1970. Photo from Wikimedia Commons
Overview of the “airquality” data set
首先，我们将运行相关性分析来检查这些质量度量之间的关系。谈到一些结果，我们可以看到较高水平的臭氧与气温上升有关，而较高的风速与较低水平的臭氧有关。风和太阳辐射几乎相互垂直。
我们可以使用“corrplot”包改进可视化。
现在我们已经看了相关结构，让我们继续计算一个部分相关矩阵。这里的想法与运行多元线性回归并试图“控制”其他混杂变量(如 X2 和 X3)的想法相同，同时查看感兴趣的预测变量 X1 对结果变量 y 的影响。偏相关矩阵的好处是可以在标准化矩阵中获得所有这些关联，以便于查看。
我们将介绍的计算偏相关矩阵的第一种方法是求解一系列(等于数据集中变量的数量)两个相关的线性回归模型。我们从这些结果模型中提取残差，并计算它们之间的相关性。为了澄清，让我们说，我们要计算臭氧和太阳之间的部分相关性。
我们有两个模型:
1)模型 1:臭氧~风+温度
2)模型 2:太阳能。风+温度
并对残差进行相关以计算偏相关，结果为 0.242。
我们将概括这一点，在下面的空气质量数据集中以成对的方式找到偏相关。
我们可以并排查看相关矩阵和部分相关矩阵，以了解系数是如何变化的。考虑到我们在“控制”数据集中的其他变量，所有系数的大小都有所降低，这并不奇怪。这种减少在某些情况下更加明显。例如，温度和风之间的相关性是-.5。温度和风之间的偏相关，考虑到了太阳。r 和臭氧，只有 0.13。
我们要研究的第二种计算偏相关的方法使用矩阵代数，而且更简洁。
从相关矩阵 R 开始，我们首先需要找到反镜像协方差矩阵 AICOV 。为了找到 AICOV ，我们需要 D ，即 R 的逆的对角元素的逆。有了 D ，我们可以计算出 AICOV 如下: AICOV = DR⁻ D 。
利用 AICOV 矩阵，我们可以计算反图像相关矩阵 *AICOR。*这里， D 等于 AICOV 的对角线，平方根，求逆。 AICOR = D / AICOV D /。
在 AICOR 的对角线上是负的部分相关值。我们可以将一个负数乘以 AICOR 的非对角元素，得到偏相关矩阵。下面是一个函数，它可以接受数据集或相关矩阵，并返回部分相关矩阵。
最后，为了确保所有之前的计算都是正确的，我们
可以使用“ppcor”包和“pcor”函数来轻松计算
偏相关系数，并获得用于显著性
测试的指标。
在本演示中，我们查看了从头开始计算偏相关的两种不同方法，并观察了在考虑数据集中的其他变量时，系数(之前在相关中观察到的)会发生怎样的剧烈变化。
希望这是有用的，如果合适的话，你可以在查看数据时检查偏相关！
保持数据科学的科学性
Oil painting by Francesco Masci.
卡尔·波普尔会如何看待这门最新的科学学科？
下面，我解释了丹尼尔·卡尼曼的畅销书《思考，快与慢》中最初提出的研究问题:
肝癌发病率最高和最低的地区都在农村。为什么？
我会在帖子的最后回到这个问题。但是现在，让我们讨论一下，从我们收集的关于我们自己的空前数量的信息中，知识会得到什么，会失去什么。
数据科学的标准定义是:“使用科学方法、流程、算法和系统从结构化和非结构化数据中提取知识和见解的多学科领域。”随着信息时代的不断发展，互联网连接和个人计算几乎无处不在。发达国家每一个 50 岁以下的人都在不停地敲击手机屏幕，在笔记本电脑上打字，享受各种数字内容，世界科技公司正在积累前所未有的海量数据。数据科学领域已经开始组织和优化这些数据，通常是为了提高数字服务的性能，如亚马逊商店产品推荐和 Spotify“每周发现”播放列表背后的算法。然而，数据科学也让我们能够在以前无法想象的水平上研究错综复杂的社会行为。随着智能扬声器进入我们的家庭，智能汽车上路，我们只会继续收集更多关于自己的信息。
Data data data (Source: Ourworldindata.org)
然而，拥有更多的数据和信息并不会自动转化为更高的知识和理解。我们将数据转化为真正洞察力的能力仍然依赖于正确运用科学方法。这绝不是保证；根据一些知识分子的说法，几十年来，社会严重依赖未经提炼的科学。
出生于奥地利的英国哲学家卡尔·波普尔(Karl Popper)以其对可证伪性、科学方法以及对归纳法的批评而闻名，他概括了这一令人警醒的思路。波普尔认为，真正的科学依赖于可被证伪的假设。科学严谨的理论在透彻的研究和逻辑检验的基础上做出假设，然后用一切可用的手段证明假设是错误的。这种类型的科学推动人类前进；正如波普尔的信徒纳西姆·尼古拉斯·塔勒布指出的，牛顿的运动理论为人类理解物理创造了奇迹，尽管几百年后被爱因斯坦证明是错误的。进步来自于发现不能被证明是错误的断言，并坚持不懈地进行实验来反驳理论。
Karl Popper
演绎和归纳之间的二分法完美地概括了波普尔等人所认为的科学的不恰当实施。在前一种情况下，我们通过从理论到假设，再到经验观察，最后拒绝假设来进行推理。另一方面，归纳法使用经验事实来发现模式，产生假设并形成理论。归纳法更难反驳，也更危险，因为正如塔勒布所说，它让我们“被随机性所愚弄”。诱导可能表面上看起来无害，但实际上有有害的副作用；当你利用历史数据建立模型，并在房价永远不会下跌的假设下运行时，你就遇到了麻烦。
波普尔追求的是社会科学家，他们创立了表面上看似革命性，但实际证明摇摇欲坠的宏大理论。这是因为这些类型的理论是不可能反驳的。例如，考虑西格蒙德·弗洛伊德关于恋母情结的理论。人们怎么可能否认孩子潜意识里对父母有性吸引力呢？你不能。因此，这是一个不科学的分析，并不比暗示上帝的存在更严格。然而，在许多情况下，不科学的理论被广泛认为是真理。主流经济学是这一现象的完美例子。这一学科的模型变得越来越复杂、数学化，并且脱离现实，在预测成功方面没有任何改进。正如统计学家内特·西尔弗(Nate Silver)所言:“经济预测正在好转的任何幻想，都应该被经济学家在金融危机爆发前犯下的可怕错误击碎。”[1]
当我们专门使用历史数据(也称为经验知识)来制定理论时，我们创建的模型平均来说非常准确，但仍然容易受到边缘情况的影响。正如在一个问题上投入更多的钱并不一定等于解决了这个问题，向我们的模型中添加更多的数据并不一定会使它们更好地反映现实世界。根据定义，模型是一种模拟，有了更多的数据，很容易过度拟合并将信号误认为噪声。但是数据的价值不在于它的整体质量，而在于我们磨练、塑造和解释数据的能力。是关于的过程。
一个好的数据科学家应该对科学方法有很强的理解，提出正确的问题，并对经验知识保持怀疑，特别是在建立具有严重后果的模型时。我们应该记住，“我们学的越多，知道的越少”这句话是有一定道理的；爱因斯坦的相对论可以说创造了更多关于宇宙的问题，而不是答案。
因此，如果你深入研究农村社区的社会行为，并使用数据科学来分析化学品暴露、生活方式差异、文化规范、营养模式等。我相信你可以找到一些令人信服的结果来解释为什么美国农村社区肝癌发病率最高和最低。当我第一次遇到这个研究问题时，我当然绞尽脑汁寻找这样的答案。但是 Popper 对使用你的实证分析建立一个模型来预测农村社区未来的肝癌发病率持怀疑态度。为什么？
此后不久，Kahnman 提醒读者，农村社区的人口比城市地区少，因此考虑到它们的统计分布，它们具有更高的方差和更多样的结果，导致更高和更低的癌症发病率。较小的样本量增加了随机性的影响。当没有因果关系时，人类倾向于创造故事和假设因果关系，所以我们的直觉是对事件做出“科学”的解释，即使统计规律是对小农村社区癌症发病率进一步波动的完美合理的解释。当我们开始研究点击量和点赞数提供给我们的信息宝库时，牢记机遇的作用并对经验主义保持怀疑是很重要的。
引用的作品
[1] N .西尔弗，信号与噪声 (2012)。
保持数据科学简单
数据科学是一个充满新奇事物的领域。简单和复杂的概念都有很酷的名字，让你声称自己是“人工智能驱动的”。虽然这不一定是一个问题，但它可能会误导有抱负的数据科学家。像任何领域一样，花哨的名字和复杂的概念吸引了很多关注。这有助于给人留下这样的印象:尖端建模是聚会所在。然而，数据科学不仅仅是关于谁拥有最多的卷积神经网络或最深入的学习。疯狂的人工智能技能在某些情况下可能会被证明是有价值的，但数据科学是关于为工作选择正确的工具，并有效地使用它来解决现实世界的问题。最后一部分，解决现实世界的问题，应该永远是最终目标。持续实现这一目标是数据科学职业生涯的基础。
为了帮助建立这个基础，需要遵循三个简单的步骤，
- 专注于解决现实世界的问题，同时衡量你的解决方案。
- 为工作选择合适的工具，这可能是最简单的。
- 不断重复。
Keep it simple
适合这项工作的工具通常是最简单的，至少在开始时是这样。复杂的模型会崩溃，它们的行为可能很难培养出一种直觉，实现它们也很耗时。专注于简单，你会开始更多的项目，这些项目本身可能会有更高的成功率。当开始数据科学职业生涯时，拥有提供真实世界价值的记录将会给你巨大的推动。机器学习、统计或编程方面的教育将为你提供基本的技能，但证明你能够将这些技能应用于现实世界的问题，并有效地传达你的解决方案，则更有价值。
从简单的项目开始，直到完成，这将有助于你建立记录。一个项目可以从一个简单的 SQL 查询开始，所以试着列出你公司内外可能的项目，然后逐一尝试。创造和衡量价值应该优先于几乎所有事情。重要的是要记住，你如何衡量你的解决方案取决于你试图解决什么问题。如果我试图创建一个抵押贷款审批模型，我可能更关心正确地筛选出欺诈者，而不是错误地拒绝那些善意的人。我如何衡量我的解决方案应该反映这些优先事项。这种方法不仅是建立投资组合的最佳方式；这是任何数据科学工作的重要组成部分。与利益相关者交谈，找到问题的根源，并找到衡量您的解决方案所提供价值的最佳方式。
摘要
如果你想进入数据科学领域，找到现实世界中的问题，并尽可能快地解决它们。最简单的方法将帮助你完成更多你开始的事情，并让你更快得到结果。建立一个坚实的技能基础是很重要的，但是能够展示你的技能所带来的影响比它们听起来有多令人兴奋更有价值。
保持优雅:Quizlet 如何使用层次分类来标记学术主题的内容
Quizlet 的社区管理的学习集目录非常庞大(3 亿个，并且还在增长),涵盖了广泛的学术主题。拥有如此大而多样的内容目录使 Quizlet 用户能够掌握世界上的任何主题，但这也产生了有趣的信息检索问题。Quizlet 的搜索、导航和个性化系统都依赖于能够将我们的内容组织成直观的学术主题。在这篇文章中，我们将讨论如何开发我们的学术主题分类，以及如何使用机器学习(ML)来自动为 Quizlet 平台上发布的每个研究集分配主题标签。
定义和组织学术主题
这个项目的第一步是定义构成 Quizlet 学习集目录的学术主题的组织结构。学术主题可以用多种方式定义，而且在主题应该如何组织的问题上没有共识。经过一些研究，我们决定将我们的学术主题组织成一个层次分类树(图 1 )。这种结构类似于著名的系统发生树，用于组织不同生物物种之间的等级关系。我们选择这种组织结构不仅是因为它的直观性和与以前的文献的重叠，也是因为它与可用于高效搜索和信息检索的图形数据结构的一致性。
Figure 1, A subset of Quizlet’s Academic Subject Taxonomy. Subjects are defined in a hierarchical tree, with each node representing increasingly specific subjects as one moves away from the root node All (subjects). Subjects were identified from a combination of pedagogical research and analysis of the content of Quizlet study sets.
为了定义构成我们的分类图的特定主题，我们从各种在线资源中汇编了定义(例如维基百科定义了从公共学术课程中派生的广泛的主题层次)。除了标准主题定义之外，我们还挖掘 Quizlet 内容，以确定平台上经常出现但标准定义中可能没有的主题(例如，体育或阅读词汇是大多数主题分类法定义中没有的常见 Quizlet 研究主题)。
图 1 描述了 Quizlet 使用的主题分类法的子集。该分类法包含数百个独立的主题，跨越八个层次的特性。例如，主题冷战将与层级中的叶节点相关联，该叶节点遵循来自层级根节点的路径:
所有→人文→历史→世界历史→世界大战→冷战
分配带有主题标签的器械包
有了主题分类法，我们接下来的任务就是给所有 Quizlet 研究集贴上最相关的主题标签。由于器械包和可用主题的数量，手工标记所有器械包是不合理的。解决像我们这样的大规模标签问题的一种常见方法是使用 ML 来构建自动标签系统。这种方法需要训练计算机算法来学习像“包含单词线粒体的研究集通常被分配主题标签科学”这样的模式。然后，我们使用经过训练的算法来预测新研究集的标签。ML 方法提供了比人工标记更好的规模、速度和一致性，但代价是实施所需的时间和技术专长。
构建学习数据集
为了让 ML 模型学习，我们必须为模型提供一个输入-目标对的数据集，这些数据集一致地表现出我们希望模型识别的期望模式。在我们的应用程序中，输入属性可以是研究集的标题和文本内容，目标是分配给研究集的主题标签。学习数据集需要包含每个目标值的足够观察值，以允许模式识别算法捕捉输入和目标之间的关系。根据输入-目标关系的复杂性，学习可能需要大量的观察。
我们发现，由于类别的数量以及内容和主题标签之间关系的复杂性，手动管理一个足够大的学习数据集是不可行的。然而，在训练期间，学习数据集通常分为两个子集:用于优化模型参数的训练集，以及用于评估最终模型在野外表现如何的测试集。测试集的这种支持有助于减轻被称为 过拟合 的现象，提高泛化性能。然而，也证明了，只要训练集足够大(例如，在高方差模型体系中的，在训练集中具有噪声比在测试集中问题更少。
在这一概念的指导下，我们生成了我们的学习数据集，以使我们的应用程序具有足够的大小，如下所示:我们使用正则表达式基于研究集标题中关键模式的存在，将主题标签从我们的分类法分配给研究集，生成了一个由(~1M)“不完美”训练观察值组成的大型训练集。然后，我们手工生成一个小得多的测试集(大约 10k 个观察值),以确保得到的观察值具有准确的输入-目标对应关系，并且充分覆盖了分类法主题标签。
制定和培训模型
除了生成学习数据集，我们还需要为我们的自动标注应用程序制定和训练一个 ML 模型。主题标注自然是作为一个离散的分类问题提出的，其目标是估计一个函数F(φ(s))，该函数将集合φ(s)的输入特征值映射到一个或多个分类标签 l ∈ L 。在这种情况下，我们的候选分类标签 L 是我们派生的主题分类法中的主题标签。
计算模型特征
特征化函数φ(s)将输入观察值的属性转换成可以被 ML 模型的算法解释的数值。对于这项工作，φ(s)将集合标题和内容文本中最具信息性的单词的平均嵌入向量与集合中出现的语言的二进制编码连接起来。嵌入向量模型在从数百万 Quizlet 集合中采样的文本上进行训练，并捕捉这些集合中出现的单词之间的语义关系。特征变换φ(s)可以被解释为集合 s 在高维语义空间中的位置的数字表示。这个“语义位置”是 ML 学习算法用来将集合的内容与最相关的主题相关联的关键信号。
我们将φ(s)应用于我们学习数据集中的所有集合，产生用于训练多个候选 ML 模型的数字特征(即各种 F 函数)。下一节描述了我们在模型开发过程中尝试的各种建模方法。
非结构化预测
我们的应用程序的一种建模方法是简单地忽略分类法的层次结构，将分类法树中的每个节点视为一个独立的类标签。使用这个非结构化预测策略，我们估计一个单一的、全局的分类器，该分类器跨整个分类法预测最佳主题标签。我们也将非结构化预测称为扁平化方法，因为它本质上是将树形层次结构扁平化为一个节点层(图 2A )。
扁平策略直观、简单，并且受益于这样一个事实，即由于分类法本身是分层的，所以可以免费获得关于任何父节点的信息。此外，与我们接下来将讨论的结构化预测策略相比，扁平策略具有更简单的推理过程，并且需要更少的外来数据结构。但是，因为扁平策略提出了一个全局分类问题，它可能无法利用本地分类结构来提高决策功能的特异性。结果是，与树中较深节点相关联的高度专门化的主题可能被忽略，而优先选择不太专门化的标签，因为它们更容易与干扰物分开。
结构化预测&分层推理
在结构化预测方法下，我们使用主题分类的分层结构将一般分类任务分解为多个子问题，每个子问题专用于分类树的本地子部分。例如，如果我们想要一个区分主题二战和冷战的模型，对主题人体解剖学或生物学甚至科学的信息进行编码会增加不相关的信息。原则上，通过允许每个局部分类问题仅关注输入中的细微差别，将任务分解成子问题应该提高所得模型的整体特异性，这有助于它最好地区分局部类目标。
与非结构化预测的情况不同，我们不是训练单个全局分类器，而是训练多个局部分类器，一个用于树中的每个父节点。当训练每个局部分类器时，训练目标是当前节点的子节点的索引。注意，只有训练数据集中的观察值的子集将被分配与这些子节点相关联的标签。因此，我们必须划分训练数据集，以仅包括那些与本地分类器相关的观察值。当训练局部分类器时，我们使用两种策略来划分训练集:
- 排他划分 ( 图 2B ):这种划分策略仅使用训练集中那些被分配了与子节点直接关联的标签的观察值。这种策略受益于对目标节点的高度特异性，代价是如果我们还包括与子节点的后代相关联的观察，则可能使用比可用数据更少的数据。
- 包含划分 ( 图 2C ):使用这种策略，当前分类器节点下的每个子树都与目标子节点索引相关联。这种策略增加了与每个目标节点相关联的观察值的数量，代价是可能给局部分类问题引入噪声。
Figure 2, Various Modeling Approaches and Training Data Partitioning Strategies. When training a hierarchical classification system, classifiers are trained for one or more parent nodes in the associated tree hierarchy. Node color indicates the taxonomy labels used to identify target observations for the current classifier. Three possible strategies for training the hierarchical classification system are displayed. A) unstructured prediction uses Flat partitioning and fits a single, global classifier with each node in the taxonomy being considered an independent class. B) Exclusive partitioning is used for structured prediction; only those observations that are associated with the children of the current node are used to train the current parent classifier. C) Inclusive partitioning is also used for structured prediction, but also includes observations associated with each subtree under the current classifier node as being labeled as a single target class.
训练一个结构化的预测模型需要训练N=(V-Z)个局部分类器，其中 V 是分类中的顶点总数， Z 是叶节点数。然而，一旦每个分类器的训练数据已经被划分，所有的局部分类器就彼此独立，并且可以被并行训练。所以训练一个结构化的预测模型，实际上在实践中是相当快的。
层次推理
在所有局部分类器被训练之后，我们使用分层推理来对新的观察结果进行预测(图 3 )。等级推理从等级的根节点开始，选择相关分类器在给定当前输入特征的情况下为其分配最大概率的子节点。在下一步中，所选子节点的分类器成为当前父分类器，并且在给定当前输入特征的情况下，选择具有最大概率的子节点，等等(图 3B )。重复这种逐级推理过程，直到到达树中的叶节点，或者当前目标/子集合的最大概率小于推理过程中来自前一级的子集合的最大概率(图 3C )。
Figure 3, Hierarchical Inference Procedure. Inference for a new observation is performed in a greedy, stage-wise fashion. A) The first stage starts with the root node, calculating the probability for the current observation over all candidate children nodes (Relative probability is depicted here as the thickness of the border for each candidate node). B) The candidate node with the maximum probability is then taken to be the next parent node. C) The process is repeated until either the maximum probability at the current inference stage is less than the maximum probability in the previous stage, or a leaf node is reached.
模型评估
现在我们有了一个框架来训练模型，这些模型可以预测我们的分层主题分类法中研究集的标签，我们需要一些方法来量化给定模型在现实世界中满足我们的应用需求的程度。一般来说，我们希望评估模型的以下属性:
- *预测质量:*预测与现实同步的程度如何？它们准确吗？对于用户体验来说，不正确的预测至少是合理可接受的吗？重要的是每个局部分类器尽可能准确，以避免由于在树的根节点附近做出不正确的决定而可能发生的错误传播。
- *性能:*训练模型需要多长时间？一个新的观察需要多长时间进行推理，会对用户体验产生负面影响吗？运行模型需要多少内存？
一旦我们有了评估给定模型的质量和性能的方法，我们就可以比较多个候选模型，从而为我们的应用程序确定最佳框架。下面，我们将讨论如何评估层次分类模型的质量和性能的一些细节。
评估预测质量
与假设二元正确/不正确结果的标准多类分类不同，等级分类可以具有不同程度的正确性。比如，把一个被贴上冷战标签的物品归类为微蜂窝生物就比贴上二战标签差多了。标准分类指标如精确度、召回率和 F1 分数，这些都是基于二元结果的假设得出的，并不处理不同程度的正确性。
因此，在这项工作中，我们使用了这些标准指标的层次版本。本质上，精确度和召回率的层次类似物考虑了分类层次中被正确或错误预测的边的数量，而不是基于单个原子标签进行评估(图 4 )。
Figure 4: Hierarchical Classification Quality Metrics: Due to the structured nature of the hierarchical classification problem, standard classification metrics like precision and recall must be extended into hierarchical analogs. Left: Precision is defined as the ratio of the number of correct taxonomy edges predicted by the classifier to the total number of taxonomy edges predicted by the classifier. Right: Recall is defined as the ratio of the number of correct taxonomy edges predicted to the actual number of edges. A Hierarchical F1 score can be calculated as the harmonic mean of hierarchical precision and recall.
不是所有的人都会同意某一特定物品的确切标签。有人称之为艺术史，另一个人可能称之为*艺术欣赏。*这些主观偏见反映在我们的测试数据集中分配的标签中，并可能会对侧重于标签预测的评估指标产生偏见。因此，除了测量不同标签正确性的分级分类度量标准(图 4 )之外，我们还试图评估预测的语义准确性。为了捕捉语义准确性，我们计算给定项目的实际和预测主题的嵌入向量之间的余弦相似性。
评估绩效
除了质量，我们还关心我们的应用程序所采用的任何 ML 模型的性能。因此，我们还测量给定模型的训练和评估时间。当在具有相似质量范围的竞争模型之间进行选择时，这些性能指标通常可以用作“决胜局”。
把所有的放在一起
既然我们有多种方法来评估给定的 ML 模型，我们可以比较各种候选模型的质量和性能，以便为我们的自动标记应用程序确定最佳框架。我们训练了 14 种不同的结构化和非结构化模型架构，使用了之前讨论的各种数据集分区策略(参见图 2 )。体系结构的简要概述如下:
结构化预测模型
- decisiontreeclassifiereexclusive:使用独占分区和决策树模型作为每个节点的基本分类器
- decisiontreeclassifierrinclusive:与decisiontreeclassifierrexclusive相同，但是使用包含数据分区
- GaussianNBExclusive :使用排他分区和朴素贝叶斯模型作为每个节点的基本分类器
- 高斯非独占:与高斯非独占相同，但使用非独占数据分区
- kneighborsclassifier Exclusive:使用独占数据分区和 K-最近邻模型作为每个节点的基本分类器。
- kneighborsclassifier Inclusive:与kneighborsclassifier exclusive相同，但是使用包含数据分区
- LogisticRegressionExclusive:使用独占数据分区和逻辑回归作为每个节点的基本分类器。
- LogisticRegressionExclusive:与LogisticRegressionExclusive相同，但使用包含数据分区
非结构化预测模型
- DecisionTreeFlat :使用单个全局决策树分类器
- GaussianNBFlat :使用单个全局朴素贝叶斯分类器
- *kneighborsclassifier flat:*使用单个全局 K 近邻分类器
- LogisticRegressionFlat :使用单一的全局逻辑回归分类器
- RocchioTaxonomyClassifierFlat:使用单个全局 Rocchio 分类器算法
- anntaxomyclassifierflat:使用单个全局三层人工神经网络分类器
每个算法都使用相同的学习数据集进行训练和评估。我们使用五重交叉验证和网格搜索来确定每个模型架构的最佳参数。
结果
为了评估每个候选模型架构的标签预测质量，我们计算了测试集中所有观察值的分层 F1 分数。为了说明与分类法中更深层次相关联的分类任务通常更具体且潜在地更困难的概念，我们还对在主题分类法的前六个层次中的每一个层次上标记有类别的观察结果单独分组 F1 分数(图 5 )。
Figure 5, Hierarchical F1 scores for candidate model architectures. In order to account for the notion that classification tasks associated with deeper levels in the taxonomy are more specific, we group the Hierarchical F1 for those testing set observations that are labeled at the specificity of each of the first six levels of the subject taxonomy. Error bars are the standard error estimated across all testing set observations in a group. In general structured prediction with Inclusive data partitioning performs the best, for all local classifier families.
通常，使用包含数据分区的结构化预测的体系结构性能最佳。此外，对本地分类器采用逻辑回归和 K-最近邻算法的模型提供了跨所有分类级别的最高质量的预测。有趣的是，非结构化预测模型提供了令人惊讶的好结果，尤其是对于分类中的较高级别。对于全局朴素贝叶斯模型来说尤其如此。采用独占数据分区的模型通常表现出较差的性能。这大概是由于这样的事实:当与排他和平坦划分策略相比时，排他规则减少了有效的训练集样本大小。
图 6 描绘了为候选模型计算的语义相似性质量度量。类似于在图 5 中绘制的 F1 分数，余弦相似性根据测试集观察结果进行分组，这些观察结果在分类体系的前六个级别中的每一个级别上都标有主题。
Figure 6, Semantic similarity scores for candidate model architectures. The cosine similarity between the actual and predicted subjects classes within a word embedding space is plotted for each model. In order to account for the notion that classification tasks associated with deeper levels in the taxonomy are more specific, we group similarities for observations that are labeled at the specificity of each of the first 6 levels of the subject taxonomy. Error bars are the standard error estimated across all testing set observations in a group.
类似于基于 F1 分数的结果，我们发现具有包容性数据划分的结构化预测模型工作得相当好。然而，非结构化模型，尤其是人工神经网络也提供具有高度语义相似性的预测。
有趣的是，平均语义相似性得分似乎随着分类法的深度而增加。这表明分类模型确实捕捉到了分类法中更深层的细微差别:因为嵌入向量的变化在分类法的更深层次上减少了，所以在更深层次上正确地分类标签平均来说给出了更高的相似性。这些结果还表明，即使主题标签可能没有被完美地预测，预测和实际标签之间的语义相似度通常相当高，表明定性的良好预测。
除了质量，我们还绘制了候选模型的评估时间(图 7 )和试衣时间(图 8 )。由逻辑回归分类器组成的结构化预测模型表现相当好，提供了亚毫秒级的推理时间，同时还提供了高质量的预测(图 4 & 5 )。
Figure 7, Evaluation time for candidate models. Evaluation times range from sub-millisecond to tens of milliseconds. Though the K-nearest neighbor and Naive Bayes algorithms provide good quality predictions (See Figures 5 & 6), they are time-consuming to evaluate. B) Same information as A), but zoomed to evaluation times less than one millisecond.
图 8 显示了所有候选模型的拟合时间。试衣时间从不到一秒到几分钟不等。对于我们的应用程序来说，这些培训持续时间没有一个被认为是特别禁止的。如前所述，因为组成结构化预测模型的局部分类器可以被并行训练，并且因为每个局部分类器正被拟合到训练数据的子集，所以这些结构预测的模型拟合时间通常相当快。
Figure 8, Training times in seconds for candidate models.
一般来说，逻辑回归模型比其他模型族需要更长的训练时间。这是由于用于优化逻辑回归模型参数的迭代定点算法。当使用整个训练集时，计算复杂性尤其明显，就像使用 LogisticRegressionFlat 模型的情况一样，这是迄今为止训练时间最长的模型。
考虑到总体质量和性能指标，我们决定继续部署结构化预测模型，该模型使用包容性数据划分来训练本地逻辑回归分类器。我们发现结果模型提供了预测质量和评估时间的最佳折衷。
部署
一旦我们训练了一个适用于我们的应用程序的 ML 模型，我们需要部署一个生产框架，该框架可以用于对历史集合进行分类或重新分类(在分类法更新的情况下)，以及对新发布或更新的集合进行分类。图 9 显示了我们生产框架的概要。
Figure 9, Overview of data flowing through Quizlet’s production subject classification deployment. All arrows in green indicate steps that are coordinated by Apache Airflow ETL jobs. Blue arrows indicate processes not directly related to the classification computations. Application data for newly published or updated sets are written to the application database (AppDB), which is regularly copied to BigQuery. ETL jobs regularly analyze the application data using BigQuery to identify the newly published or updated sets, extract the content of these sets, and send classification requests to one or more classifier services running on Docker instances. The set subject predictions provided by classifier services are then written to Google Cloud Spanner, which used as a read-only database by the application.
在这个框架中，使用由 Apache Airflow 协调的 ETL 在预定的批次中执行分类(关于 Quizlet 如何使用 Airflow 的更多信息，请查看这个帖子)。在每个 ETL 作业中，已经从应用程序数据库(AppDB)导出到 Google BigQuery 的应用程序数据将被分析，以寻找新发布和更新的数据集。然后使用 BigQuery 提取这些集合的属性，并通过 Google Kubernetes 发送到一个或多个 Docker 容器中运行的分类器服务。每个分类器服务都使用一个先前训练过的产品分类器模型工件的副本，该工件存储在 Google Cloud storage(GCS)中。分类器服务的结果随后被写入一个 Google Cloud Spanner 数据库表的行中，该表被应用程序用作只读数据库。
未来的工作
我们的主题分类系统已经生产了将近一年，我们对目前的结果很满意。也就是说总有改进空间。未来，我们计划从多方面改进我们的系统:
- *改善学习数据集分层。*当前的训练数据集偏向于 Quizlet 平台上内容的底层分布。因此，一些常见主题在训练集中出现过多。我们通过使用数据分区在一定程度上减轻了这种偏差，但只针对结构化预测模型。我们可能会看到，增加更多的观察来解释我们目录中的稀有主题，可能会带来最大的好处。
- *扩展输入特征空间。*当前的输入特征空间相当简单，仅表示关于集合内容的特定类型的信息，即集合的“语义位置”。在我们模型的未来迭代中，我们希望将特征空间扩展到 NLP 中更多的常见特征，以及包括使用无监督学习方法(如潜在狄利克雷分配或分层狄利克雷过程)导出的主题模型特征。
- *局部分类器的特征修剪。*很可能并非输入要素的所有维度都对解决所有局部分类问题有用。如果我们发现一些特性与预测层次结构中的下一条路径无关，那么它们很可能在层次结构中也不再有用。因此，删除这些不相关的功能可以提高性能和质量。
- *改进分层推理算法。*当子节点的预测概率小于逻辑的前一阶段中父节点的预测概率时(或者当到达叶节点时)，我们的推理的当前逻辑停止。比较从两个不同分类器返回的概率是有问题的，并且可能负面影响推理过程的质量。推理过程的未来迭代将试图减轻这些缺点。一种方法是将当前父节点索引作为每个本地分类器的候选目标之一。
感谢
许多击掌称赞 Quizlet 团队的所有成员，他们帮助研究和评估了这里讨论的多种 ML 方法，部署了我们的生产模型，并对这篇文章提供了深思熟虑的评论。我看着你沙恩·穆尼、孙凯伦、温斯顿·黄、乔希·拉伊、丹·克劳利、劳拉·奥本海默、提姆·米勒！
肯德尔等级相关解释。
*肯德尔秩相关(也称为肯德尔的 tau-b)怎么样？这是什么？我如何开始？我什么时候用肯德尔的 tau-b？嘿，教我你所知道的关于肯德尔等级相关的一切。”——*一颗好奇的心。
什么是相关性？
相关性是一种双变量分析，衡量两个变量之间的关联强度和关系方向。就关系的强度而言，相关系数的值在+1 和-1 之间变化。值为 1 表示两个变量之间的完美关联程度。随着相关系数值趋向于 0，两个变量之间的关系将变弱。关系的方向由系数的符号表示；加号表示正相关，减号表示负相关。
通常，在统计学中，我们衡量四种类型的相关性:
- 皮尔森相关性(参数)
- 肯德尔等级相关(非参数)
- Spearman 相关(非参数)
- 点双列相关。
肯德尔等级相关
也就是俗称的“肯德尔的τ系数”。Kendall 的 Tau 系数和 Spearman 的等级相关系数基于数据的等级评估统计关联。当您正在处理的数据未能通过一个或多个假设测试时，肯德尔等级相关(非参数)是皮尔森相关(参数)的替代方法。当您的样本量很小并且有许多并列的等级时，这也是 Spearman 相关(非参数)的最佳替代方法。
肯德尔等级相关用于测试按数量排列时数据排序的相似性。其他类型的相关系数使用观察值作为相关的基础，Kendall 的相关系数使用成对的观察值，并基于成对观察值之间的一致和不一致的模式来确定关联的强度。
- **一致:**以相同的方式排序(一致性)，即它们相对于每个变量的顺序相同。例如，如果(x1 < x2)和(y1 < x2)或(x1 > x2)和(y1 > x2)，则一对观察值 X 和 Y 被认为是一致的
- **不一致:**排序不同(不一致)，即数值排列方向相反。例如，如果(x1 < x2)和(y1 > x2)或(x1 > x2)和(y1 < x2)，一对观察值 X 和 Y 被认为是不一致的
肯德尔的τ相关系数通常比斯皮尔曼的ρ相关系数的值小。计算是基于和谐和不和谐的配对。对错误不敏感。样本量越小，p 值越准确。
肯德尔排名相关性答案的问题。
- 学生的考试成绩(A，B，C…)和花在学习上的时间之间的相关性分类(<2 hours, 2–4 hours, 5–7 hours…)
- Customer satisfaction (e.g. Very Satisfied, Somewhat Satisfied, Neutral…) and delivery time (< 30 Minutes, 30 minutes — 1 Hour, 1–2 Hours etc)
- 我把第三个问题留给了你和宇宙…玩得开心！
假设
在开始使用肯德尔等级相关之前，您需要检查您的数据是否满足假设。这将确保您可以实际使用有效的结果，而不仅仅是显示器上的数字。
- 这些变量是在顺序或连续标度上测量的。顺序量表通常是衡量非数字概念的标准，如满意度、幸福度和不适度。例如非常满意、有些满意、中性、有些不满意、非常不满意。连续秤本质上是区间*(即温度如 30 度)或者比例变量(如体重、身高)。*
- 理想的如果您的数据似乎遵循单调关系。简单来说，随着一个变量的值增加，另一个变量也增加，并且随着一个变量的值增加，另一个变量减少。原因如下:肯德尔的等级相关性衡量两个变量之间存在的关联的强度和方向(确定是否存在单调关系)。知道了这一点，测试单调关系的存在是有意义的。但是，就像我说的，这是可取的。
Monotonic vs Non-Monotonic Relationship
就这样！又短又甜！你可以走了！
您还可以查看:
开普勒。GL & Jupyter 笔记本:优步开源开普勒的地理空间数据可视化。标距长度
在 Jupyter 笔记本中绘制地理空间数据&轻松地与开普勒的用户界面交互以调整可视化。
kepler.gl for Jupyter 是一款优秀的大地理空间数据可视化工具。将世界一流的可视化工具、易于使用的用户界面(UI)以及 python 和 Jupyter 笔记本的灵活性结合起来(下面是 3D 可视化 GIF，文章中有更多内容)。
3D building footprints
kepler.gl 是基于网络的大型地理空间数据集可视化工具，构建在 deck.gl 之上。优步去年将其开源，其功能令人印象深刻。您可以轻松地拖放您的数据集，并在 web 上立即调整它，以便轻松地可视化大规模地理空间数据集。看看下面这张展示开普勒网络应用的 GIF。
Kepler.gl Source
我喜欢在 Jupyter 笔记本中工作，Kepler.gl 的相同功能在 Jupyter 笔记本环境中也是可用的。在本教程中，我将重点介绍如何在笔记本中集成 kepler.gl for Jupyter 可视化工具。
使用开普勒 Jupyter 笔记本的优点是，你既可以获得作为开普勒伟大的可视化工具的 Jupyter 笔记本的灵活性。
在 Kelpler Jupyter 笔记本中显示数据
我们在本教程中使用的数据集来自纽约开放数据门户。都是 2018 年纽约报道的事件。
import pandas as pd
from keplergl import KeplerGl
import geopandas as gpddf = gpd.read_file("NYPD_complaints_2018.csv")
df.head()
数据集的前几行如下。事件数据、类别和事件发生地的坐标是该数据集中可用的列。
要使用开普勒绘制数据，首先需要创建一张地图。让我们只用一行代码就能做到。
#Create a basemap
map = KeplerGl(height=600, width=800)#show the map
map
笔记本中会出现带有深色底图的默认地图。如果你愿意，你可以很容易地改变它。
Empty base map
现在，让我们将数据添加到地图中。将数据直接添加到 Kepler.gl 的最简单方法是将其转换为地理数据框架，我们可以使用 Geopandas 快速完成此操作。
# Create a gepdataframe
gdf = gpd.GeoDataFrame(df, geometry=gpd.points_from_xy(df.Longitude, df.Latitude))# Add data to Kepler
map.add_data(data=gdf, name=”crimes”)
我们将数据添加到我们创建的第一个地图中(您可以再次调用 map 来显示在下面的单元格中，但这不是必需的)。这些点出现在上面创建的底图的顶部。
Points plotted in Kepler Jupyter
地图点多，乱。让我们做一些调整。
UI:在 Jupyter 笔记本中调整和交互地图
下面是有趣的部分，你可以用开普勒的用户界面轻松地调整可视化的类型、颜色和大小。让我们改变地图的颜色和大小(见下面的 GIF 图)。
Kepler.gl Jupyter notebook User Interface
上面我们只展示了一种可视化的方式，这通常取决于手边的数据集。不过，以下是 Kepler.gl 现在提供的功能(见下图)。您可以将您的数据可视化为点、六边形、热图、弧形或带有线数据的线，以及具有 3D 可用性的建筑物可视化。
Kepler visualisation types. Source
让我们来看看更多的数据可视化(见 GIF 下面的六边形可视化)。开普勒自动计算每个六边形并将其可视化。请从下面的地图中查看周边地区如何减少事故。
Kepler.gl Jupyter notebook 中的另一个很棒的工具是内置的时间序列动画。
Time-series animation
处理您的数据，可视化，永远不要离开 Jupyter 笔记本
它的美妙之处在于，你不用离开 Jupyter 笔记本就能获得开普勒的功能。假设我们对将数据聚合到社区中感兴趣。我下载了邻域文件并执行了一个简单的空间连接来计算每个邻域内有多少个事件。
我创建了一个函数来实现这一功能:空间连接、分组，然后返回地理数据框架。
def count_incidents_neighborhood(data, neighb):
# spatial join and group by to get count of incidents in each poneighbourhood
joined = gpd.sjoin(gdf, neighb, op=”within”)
grouped = joined.groupby(‘ntaname’).size()
df = grouped.to_frame().reset_index()
df.columns = [‘ntaname’, ‘count’]
merged = Neighborhood.merge(df, on=’ntaname’, how=’outer’)
merged[‘count’].fillna(0,inplace=True)
merged[‘count’] = merged[‘count’].astype(int)
return mergedmerged_gdf = count_incidents_neighborhood(gdf, Neighborhood)
一旦我们有了想要绘制的数据，我们就可以创建开普勒地图。让我们在一个单独的地图中这样做；我们称之为地图 2。我们添加刚刚创建的数据来可视化它。
map2 = KeplerGl(height=600, width=800)
# Add data to Kepler
map2.add_data(data=merged_gdf, name=”NeighborhoodCrimes”)
map2
这是最初的地图，你可以如何调整它。
Polygon visualisation
三维可视化
开普勒也有方便的三维可视化。这是一个使用旧金山开放数据构建足迹的示例。
装置
要安装 Keplergl Jupyter notebook，只需在终端上运行这三行代码。
pip install ipywidgets
pip install keplergl
jupyter nbextension install --py --sys-prefix keplergl
结论
我们已经介绍了 Kepler.gl Jupyter notebook 可视化地理空间数据的一些用例。我发现这个工具非常有用，因为它在 Jupyter notebook 中提供了令人印象深刻的功能。尝试一下，让我知道你是否尝试过。
开普勒& QGIS:开源地理空间工具浅析
了解它们是如何工作的，它们的特点是什么，以及我们为什么需要一个新工具
Earthquakes in California, 2000 to 2018, kepler.gl
先说为什么。
为什么我们需要地理空间分析？为什么现在比以往任何时候都重要？
人类大脑主要基于时间、日期和地点来识别信息。例如，“记得我们昨天在剧院见过吗？”或者“你现在在哪里？”其次是“我在大学”。
借助今天的技术——手机、全球定位系统、社交媒体等等——人们可以收集他们周围甚至全球发生的几乎任何事件的地理参考(时间和地点)数据。
地理空间分析正在利用这些数据构建地图、统计图、统计数据和图表，以显示变化是如何发生的以及具体发生在哪里。大规模呈现数据可以揭示我们周围正在发生的重大转变，例如气候变化。地理空间分析的应用包括但不限于供需匹配、气候变化建模、地理营销、更好的 ETA 估计和人口预测。
如今，公司大多使用像 Kepler.gl 和 QGIS 这样的开源工具。虽然这些工具确实适用于地理空间分析的某些方面，但它们需要在其他方面发挥作用。让我们更详细地探讨一下。
开普勒
开普勒是一个基于网络的平台，用于可视化大规模位置数据。它是由优步大学的可视化团队创建的，其使命是创建行业级开源框架来增强大数据。有四种主要套装可供使用——Deck、Luma、React map 和 React vis——来制作漂亮的数据驱动地图。开普勒用 deck.gl 打造，利用 WebGL (一种 JavaScript API)更快更高效地渲染大数据。
开普勒仅仅是一个可视化工具。但就像机器人一样，它非常擅长高效地完成特定的工作。它采用 CSV、JSON 和 geoJSON 文件。开普勒的基本流程是，在本地机器上对数据库执行一些操作，如果不在本地机器上，就下载并在开普勒上绘制。
New York taxi rides via Kepler.gl
Layers available
为了使这些可视化更丰富，它提供了几个层，你可以从中选择，这是非常容易的。例如，要使用点图层，您必须从数据中选择纬度和经度列，瞧！不仅如此，你还可以在一层之上添加多层。是不是很酷？
除此之外，您还可以添加过滤器(时间、日期或大小)、选择颜色、设置不透明度、为地图上的点设置轮廓，以及选择查看内置的地图图层，如土地、道路、水和 3D 建筑物。它也有一个比较视图，您可以启用和可视化两个地图并排。
然而…
地理空间分析不仅仅是美丽的可视化。正如我之前所说，开普勒目前只提供可视化。一个完整的地理空间分析工具中应该有的许多重要功能都缺失了。其中一些是:
- 您总是不得不手动添加数据文件(电子表格或 geoJSON ),并且无法做出任何实时决策。
- 空间操作是地理空间分析工具的一个重要方面，如合并、连接和聚类在 Kepler 中不可用。不仅合并和连接，而且更简单的计算都必须在外部完成，然后放入 CS 系统。
- 在开普勒，添加不同种类的地图是不可能得到更多的背景。
- 目前，他们提供了自己的一套颜色供你选择，对我来说，这是一个挫折。不可否认，他们有很多选择，但是我喜欢在我的想象中选择我想要的颜色
但是等一下…
2019 年开普勒发展路线图承诺了许多新功能，包括高级图层，空间操作和自定义色标。获取完整列表并在此更新。
QGIS
QGIS 是一个完全开源的桌面软件，由社区维护。安装和使用 QGIS 的成本为零，但这是一个挑战，除非你以前做过，尤其是如果你有其他软件的冲突包。如果你熟悉编程，你甚至可以自己添加功能。它消耗几乎所有类型的数据(超过 70 种矢量格式)。它是跨平台的，可以在所有三种主要的操作系统 Windows、Mac 和 Linux 上使用。
QGIS 就像地理空间世界的excel。从创建地图、执行空间操作到使用 QGIS 数据库，您几乎可以做任何事情。它可以用于非常大的项目，从开始到结束的一切，如果你有一个 GIS 项目，没有其他类型的数据。它提供了一些插件，可以为你的项目增加一颗额外的星星，其中一些是，
- QuickOSM 允许下载 OpenStreetMap 数据
- QuickOSM 查询引擎—帮助您从 QuickOSM 插件下载特定数据
- 数据绘图—允许创建矢量数据的 D3 图
然而…
QGIS 是迄今为止最丰富和最有用的地理空间分析工具。然而，就像其他工具一样，它也有自己的局限性。而且我们在现场相信，不仅仅是工具，地理空间数据本身也充满了挑战。
安装和管理 QGIS 是非常不同的，除非你已经这样做了，特别是如果你从其他软件的冲突包。QGIS 难以处理大数据，并且没有真正提供对流数据的支持。在流数据上执行地理空间查询变得非常计算密集型，而我们没有支持它的工具。虽然有时，开发人员会创建他们自己的内部工具集，但这些工具并不适合全球使用，因为它们专注于他们正在执行的特定任务。
此外，当连接到数据库时，它工作得很好，但它是一个桌面应用程序，而不是在云上。此外，如果一个商业人士想使用 QGIS，它不是很直观，因为它需要空间数据知识。该分析不能与任何人共享，不能使用企业规模和更现代的聚合方法，如地理哈希或六边形网格。要知道这些是什么意思，请参考这篇文章。
Locale.ai
那么什么是 Locale，我们为什么要建立它呢？
一切都始于一个个人问题。作为处理地理空间数据的数据科学家，现有的分析产品在我们的日常工作流程中毫无用处。因此，我们必须为我们的日常工作流程构建自己的工具和库。
在这样做的时候，我们意识到不仅仅是我们。谈到位置数据，全球各地的数据科学家都面临着类似的问题。因此，企业正在努力提高运营效率。在现场，我们计划一劳永逸地解决这个问题。
我们正在努力使位置分析成为整个分析生态系统的一部分。因为当然，位置智能不仅仅是在地图上跟踪和标绘点。您可以混合搭配空间和非空间数据库，并回答您的所有问题。我们的目标是让商业用户在不依赖开发者的情况下获得空间洞察力。
位置情报不仅仅是在地图上追踪和标绘点。
借助我们的平台，您可以大规模传输空间数据，这意味着所有这些都是在大规模、实时和非常精细的级别上进行的。我们还添加了一个拖放界面，为业务用户(不知道如何编写复杂的空间查询)编写复杂的查询，以获得他们问题的答案。您可以使用 Locale 的平台轻松定制您的空间模型。
Locale 在一个地方提供团队专用的控制台。它有警报和触发器，以防有任何异常值，如果您想将数据导出到您的系统中，它还提供 API。
如果你对这个问题有共鸣，想投稿，我们 招聘 不同角色。如果你想深入研究，请查看我们的 网站 或通过hello @ locale . ai联系我们！
原载于 2019 年 9 月 18 日 现场 。
电话培训通知的 Keras 回拨
创建一个简单的 Keras 回调，将培训进度作为通知发送到您的手机。
Photo by Jonah Pettrich on Unsplash
训练神经网络通常需要几个小时甚至几天才能完成，当您无法监控训练进度时，这可能会令人沮丧。这个想法很简单，很容易实现一个回调来发送通知到你想要的应用程序。
为了发送通知，我使用了一个名为 Notifiers 的 python 库。它支持大多数流行的应用程序，如:
- 容易做的事情
- 推杆
- 简单推送
- 松弛的
- 谷歌邮箱
- 电报
- 特维利奥
还有很多。看文档这里。
在这个介绍中，我将使用 PushBullet。所有的服务都差不多。从所需的服务获取一个 API 令牌，并在身份验证中使用它。
你完了！！
谢谢你。
学习如何执行 Twitter 情绪分析
Keras 挑战复仇者联盟
情感分析，也称为意见挖掘，是自然语言处理中的一个有用工具，它允许我们识别、量化和研究主观信息。由于每天都会产生数十亿字节的数据，这种技术使我们有可能提取这些数据的属性，例如关于某个主题的负面或正面意见，以及关于正在谈论的主题和表达该意见的个人或实体的特征的信息。
Twitter 越来越受欢迎，如今，人们每天都在使用它来表达对不同话题的看法，如产品、电影、音乐、政治家、事件、社会事件等。每年都有很多电影上映，但如果你像我一样是漫威的粉丝，你可能会迫不及待地想最终观看新的《复仇者联盟》电影。就我个人而言，我想知道人们对此的感受。
在之前的中，我们已经讨论了如何使用 Twitter API 来传输推文，并将其存储在关系数据库中。现在，我们将使用这些信息来执行情感分析。但在此之前，我们应该考虑一些事情。首先，我们使用“复仇者”这个词来发布推文，但没有任何额外的考虑。很有可能我们有成千上万条重复的推文。就情感分析而言，处理它们不会增加任何额外的价值，相反，它将是计算上昂贵的。因此，我们需要访问数据库，删除重复的推文，保留第一个事件。第二，我们有一个未标记的数据库。为了让模型在训练期间学习，我们应该声明推文是正面的还是负面的。理想的解决方案是手动标注数据集，这非常准确，但需要大量时间。然而，有几个选择比如使用开源数据集标记工具，比如 斯坦福 CoreNLP 。
有许多框架可以用于机器学习任务，但是，我们将使用Keras，因为它提供了一致而简单的 API，最大限度地减少了所需的用户操作数量，更重要的是，它易于学习和使用。我们还将利用 自然语言工具包 (NLTK)，它提供了许多语料库和词汇资源，这些资源将方便地用于标记、解析和语义推理，以及Scikit-learn，它为数据挖掘和数据分析提供了有用的工具。
准备好开始了吗？让我们看看 Keras 能从《复仇者联盟》中学到什么。
首先，我们需要检索之前存储在 PostgreSQL 数据库中的 tweets。为此，我们将利用[sqlalchemy](https://www.sqlalchemy.org/)，这是一个 Python SQL 工具包和对象关系映射器，允许我们以一种简单的方式连接和查询数据库。sqlalchemy 的一个特点是包含了最常见数据库的方言(它用来与数据库通信的系统)实现，比如 MySQL、SQLite 和 PostgreSQL 等等。我们将使用create_engine()函数，该函数基于给定的数据库 URL 生成一个引擎对象，其典型形式如下:dialect+driver://username:password**@host**:port/database。在我们的例子中，方言是 PostgreSQL，而驱动程序是 psycopg2。创建引擎对象后，我们将使用来自pandas模块的函数read_sql_query来查询数据库，以获取存储在我们的tweet 表中的所有数据(‘select * from tweet _ table’)并收集在DataFrame中检索的信息:
在我们深入分析“复仇者联盟”的公众意见之前，我们需要采取一个重要步骤:预处理推文文本。但这意味着什么呢？文本预处理包括遵循一组常用的简单规则的基本文本清理，但也包括考虑语法和词汇信息的高级技术。在我们的项目中，我们将执行以下步骤:
- 使用
**.lower()**函数将推文转换成小写，以使所有推文保持一致的形式。通过这样做，我们可以确保进一步的转换和分类任务不会受到数据中不一致或大小写敏感问题的影响。 - 删除
**‘RT’**、用户提及和*链接:*在 tweet 文本中，我们通常可以看到每一句都包含一个引用，它是一个转发(’ RT ')、一个用户提及或一个 URL。因为它通过许多推文被重复，并且它没有给我们任何关于情绪的有用信息，我们可以删除它们。 - ***删除数字:*同样，数字不包含任何情绪，因此从 tweet 文本中删除它们也是常见的做法。
- ***删除标点符号和特殊字符:*因为这会生成高频率的标记，从而影响我们的分析，所以删除它们很重要。
- ***替换拉长的单词:*拉长的单词定义为包含两次以上重复字符的单词，例如‘awesooome’。替换这些单词非常重要，因为分类器会将它们视为与源单词不同的单词，从而降低它们的频率。但是，有一些英语单词包含重复的字符，主要是辅音，所以我们将使用 NLTK 中的 wordnet 来与英语词典进行比较。
- 移除停用词:停用词是在所有推文中出现频率很高的功能词。没有必要分析它们，因为它们没有提供有用的信息。我们可以从 NLTK stopwords 函数中获得这些单词的列表。
- 用反义词处理否定 : 分析情绪时出现的一个问题就是处理否定及其对后续词语的影响。让我们举一个例子:假设我们找到了推文“我不喜欢这部电影”,我们丢弃了停用词，我们将去掉“我”和“没有”的词。所以最后，我们将得到“喜欢”和“电影”的标记，这与原始推文的意思相反。有几种处理否定的方法，并且有很多关于这个的研究正在进行；然而，对于这个项目，特别是，我们将扫描我们的推文，并用我们的否定词后面的名词、动词或形容词的反义词(我们将从 wordnet 的词条中获得)来替换。
在我们清理了数据之后，但在我们开始构建情绪分析模型之前，我们可以进行探索性的数据分析，看看在我们的“复仇者联盟”推文中出现最频繁的词是什么。对于这一部分，我们将展示关于被标记为正面的推文和被标记为负面的推文的图表。
首先，我们将使用 WordCloud 来表示所有推文中的单词使用情况，根据每个单词的频率按比例调整其大小。尽管出于不同的原因，这个图表似乎不是最合适的，但它提供了一个文本分析和一个关于哪种类型的词在我们的推文中出现得更频繁的总体想法。Python 有一个[WordCloud](http://amueller.github.io/word_cloud/)库，允许我们使用从硬盘上传的图像应用遮罩，选择背景、单词颜色图、最大字数、字体大小以及图形的其他特征。
正面推文的 WordCloud:
负面推文的 WordCloud:
当我们观察正面推文的词云时，一些以较大尺寸出现的词没有特定的内涵，可以被解释为中性的，如“惊奇队长”、“无限战争”。另一方面，其他单词，即使有些较小，也可以被解释为在推文中具有积极的意义，如“好”、“很好”、“最好”和“喜欢”。相反，负面推文的 WordCloud 显示的大多是中性词，如“电影”、“残局”和带有负面内涵的非常小的词，如“从不”和“操”。
之后，我们可以在一张图表中列出正面和负面推文中与“复仇者联盟”词语共现的 50 个最频繁的词。我们将从使用来自sklearn的函数CountVectorizer开始，该函数将把 tweets 的集合转换成令牌计数的矩阵，产生计数的稀疏表示。然后，我们对每个令牌的所有计数求和，获得频率，并将它们存储为数据帧。
我们现在可以通过使用matplotlib函数bar在柱状图中绘制这些值。
**
我们可以看到，正面和负面推文中的第一个常用词是:“漫威”、“残局”，此外，除了正面推文中的“好”、“太棒了”、“爱”、“最喜欢”和“最好”等词之外，大多数词都有中性的含义。
我们最终可以检查在正面和负面推文中出现的单词的频率之间是否有任何相关性。我们将连接两个词频数据帧，之后，我们将使用 seaborn regplot图:
除了一两点看起来相关之外，从上面的图表中无法得出正面和负面推文中出现的单词之间有任何有意义的联系。
在可视化我们的数据之后，下一步是将数据集分成训练集和测试集。为此，我们将利用sklearn包的train_test_split功能。我们将按照 20–80%规则抽取 20%的数据集进行测试。剩下的 80%用于训练集，我们将保留一部分用于验证我们的模型。
我们还需要将我们的情感列转换成我们的模型可以理解的类别。我们将使用 0 代表负面，1 代表中性，2 代表正面。
最后，我们需要使用TfidfVectorizer 处理我们的输入 tweet 列，这将把 tweet 的集合转换成一个术语频率/反转文档频率(TF-IDF)特征矩阵。这个函数非常关键的一点是，它将返回归一化的频率；特征归一化是构建机器学习算法的关键步骤。经过几次尝试，3500 是返回的最大特征数，它最适合我们的模型。
现在，是时候建立我们的模型了:一个神经网络。如果不熟悉神经网络的工作原理，可以查看我之前的帖子。幸运的是，Keras 使构建神经网络变得非常简单和容易，只需几行代码。
让我们来剖析一下我们的模型:Sequential()是一种由层组成的网络，这些层按照给出的顺序堆叠和执行。那么，我们有哪种类型的层？我们注意到，我们已经为我们的三个层(输入、隐藏和输出层)添加了Dense层，这意味着一个层中的每个节点都接收来自前一层中所有节点的输入，实现了以下操作:[output = activation(dot(input, weights) + bias)](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense)。在它们之间，我们使用了Dropout方法，该方法采用一个介于 0 和 1 之间的浮点数(我们将把它作为drop传递，稍后再进行调整),表示在训练期间将被随机丢弃的神经元部分，以防止过度拟合。关键层是输入层和输出层，因为它们将决定我们网络的形状，正确了解我们的期望是很重要的。因为我们将使用3500作为矢量化过程中返回的maximum features，所以我们需要使用这个确切的数字作为输入形状的大小。我们还将包括第一层将产生多少输出(作为layer1传递)，稍后我们将修改该参数，以便使该层更简单或更复杂。在这种情况下，我们将选择relu作为我们的激活函数，它比其他函数有几个好处，比如减少消失梯度的可能性。对于最后一层，我们将选择对应于三个不同输出的三个节点，因为我们想要获得分类分布，我们将使用softmax作为激活函数。对于隐藏层，我们也将大小作为layer2 传递，它通常是layer1的一半，因为这是一个分类问题，我们将使用sigmoid激活(如果你想知道更多关于使用哪个激活函数，检查这个视频)。
之后，应该说明要使用的优化器及其参数。我们将使用具有固定衰减和β的 AdamOptimizer，但稍后我们将调整学习速率和ε值。 Adam 是一种随机优化，它具有几个优点，例如实现简单、计算效率高、内存需求小、对梯度的对角线重定标不变，以及非常适合于数据和/或参数较大的问题。
训练前的最后步骤之一是编译网络，澄清我们想要的损失。在这种情况下，我们将使用sparse_categorical_crossentropy,因为我们将类别表示为数字。我们还需要澄清优化器，以及要评估的指标(对我们来说，就是准确性)。此外，我们需要拟合模型，说明 X 和 Y 值的集合、batch size(通过网络传播的样本数量)、epochs(我们将扫描所有数据的次数，我们还将调整的参数)、validation split(将保存哪个百分比以验证我们的结果)，以及我们是否每次都以相同的方式呈现数据，或者，我们将对其进行洗牌(shuffle)。
在尝试了dropout、features、shuffle、learning rate、 layer size、epsilon、validation_split、epochs几个参数后，我们最终得出了以下模型:
我们可以看到，我们的最终验证准确度从时段 1 的 71.91 提高到时段 5 的 76.54%。此外，增加，甚至更多，纪元提高了训练精度，但降低了验证精度。
尽管我们总是希望有更高的准确性，但我们现在可以继续尝试在我们创建的新数据集中识别观点，就像我们用于训练和验证的数据集一样。
为此，我们将查询我们的新数据库，执行相同的文本预处理步骤，对我们的推文进行标记，并使用我们训练的模型使用model.predict()预测对“复仇者联盟”的情绪。如果我们想让人类更容易阅读，我们可以将数字预测转换为我们的分类标签‘正、中和、负’。
现在是真相大白的时候了！我们可以使用饼图来绘制每个情感类别中包含了多少条推文:
正如你所看到的，53.1%的推文对“复仇者联盟”有正面的含义，而剩下的 46.9%是中性的或有负面的含义。如果我在推特上谈论这个话题，我应该被列入积极的一面，或者至少我可以有 76%的信心我会。你呢？
接下来，我们将通过 NetworkX 使用 Tweets 信息来可视化 Twitter 上的用户交互。
如果你想了解这个项目的全部代码，请查看我的 GitHub 库 。
MNIST 数据集的 Keras 自定义数据生成器示例
Photo by Carlos Muza on Unsplash
通常，在现实世界的问题中，用于训练我们模型的数据集占用的内存比我们在 RAM 中的要多得多。问题是我们不能将整个数据集加载到内存中，并使用标准的 keras fit 方法来训练我们的模型。
解决这个问题的一种方法是只把一批数据装入内存，然后把它输入网络。重复这个过程，直到我们用所有数据集训练了网络。然后我们打乱所有的数据集，重新开始。
为了制作自定义生成器，keras 为我们提供了一个序列类。这个类是抽象的，我们可以创建继承它的类。
我们将编码一个自定义数据生成器，该生成器将用于生成 MNIST 数据集的批量样本。
首先，我们将导入 python 库:
**import** tensorflow **as** tf
**import** os
**import** tensorflow.keras **as** keras
**from** tensorflow.keras.models **import** Sequential
**from** tensorflow.keras.layers **import** Dense, Dropout, Flatten
**from** tensorflow.keras.layers **import** Conv2D, MaxPooling2D
**import** numpy **as** np
**import** math
然后，我们将 MNIST 数据集加载到 RAM 内存中:
mnist = tf.keras.datasets.mnist(x_train, y_train), (x_test, y_test) = mnist.load_data()
MNIST 数据集由 60000 幅手写数字训练图像和 10000 幅测试图像组成。
每个图像尺寸为 28×28 像素。你应该考虑到，为了训练模型，我们必须将 uint8 数据转换为 *float32。*float 32 中的每个像素需要 4 字节的内存。
因此，整个数据集需要:
每像素 4 字节* (28 * 28)每图像像素* 70000 个图像+ (70000*10)个标签。
总共 220 Mb 的内存完全可以放在 RAM 内存中，但在现实世界的问题中，我们可能需要更多的内存。
我们的生成器模拟生成器将从 RAM 中加载图像，但在实际问题中，它们将从硬盘中加载。
class **DataGenerator**(tf.compat.v2.keras.utils.Sequence):
def **__init__**(self, X_data , y_data, batch_size, dim, n_classes,
to_fit, shuffle = True): self.batch_size = batch_size
self.X_data = X_data
self.labels = y_data
self.y_data = y_data
self.to_fit = to_fit
self.n_classes = n_classes
self.dim = dim
self.shuffle = shuffle
self.n = 0
self.list_IDs = np.arange(len(self.X_data))
self.on_epoch_end() def **__next__**(self):
# Get one batch of data
data = self.__getitem__(self.n)
# Batch index
self.n += 1
# If we have processed the entire dataset then
if self.n >= self.__len__():
self.on_epoch_end
self.n = 0
**return** data def **__len__**(self):
# Return the number of batches of the dataset
**return** math.ceil(len(self.indexes)/self.batch_size) def **__getitem__**(self, index):
# Generate indexes of the batch
indexes = self.indexes[index*self.batch_size:
(index+1)*self.batch_size] # Find list of IDs
list_IDs_temp = [self.list_IDs[k] for k in indexes]
X = self._generate_x(list_IDs_temp)
if self.to_fit:
y = self._generate_y(list_IDs_temp)
**return** X, y
else:
**return** X def **on_epoch_end**(self):
self.indexes = np.arange(len(self.X_data))
if self.shuffle:
np.random.shuffle(self.indexes) def **_generate_x**(self, list_IDs_temp):
X = np.empty((self.batch_size, *self.dim))
for i, ID in enumerate(list_IDs_temp):
X[i,] = self.X_data[ID]
# Normalize data
X = (X/255).astype('float32')
**return** X[:,:,:, np.newaxis] def **_generate_y**(self, list_IDs_temp):
y = np.empty(self.batch_size)
for i, ID in enumerate(list_IDs_temp):
y[i] = self.y_data[ID]
**return** keras.utils.to_categorical(
y,num_classes=self.n_classes)
然后我们要建立分类网络:
n_classes = 10
input_shape = (28, 28)model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu',
input_shape=(28, 28 , 1)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(n_classes, activation='softmax'))model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy'])
下一步是制作我们的生成器的一个实例:
train_generator = DataGenerator(x_train, y_train, batch_size = 64,
dim = input_shape,
n_classes=10,
to_fit=True, shuffle=True)val_generator = DataGenerator(x_test, y_test, batch_size=64,
dim = input_shape,
n_classes= n_classes,
to_fit=True, shuffle=True)
如果我们想检查生成器是否正常工作，我们可以调用产生一批样本和标签的 next() 方法。然后检查图像和标签的数据类型是否正确，检查批次的尺寸等…
images, labels = next(train_generator)
print(images.shape)
print(labels.shape)
如果我们希望在一个时期内将整个数据集输入网络:
steps_per_epoch = len(train_generator)
validation_steps = len(val_generator)
最后，我们将使用 keras 函数 fit_generator()来训练网络。
model.fit_generator(
train_generator,
steps_per_epoch=steps_per_epoch,
epochs=10,
validation_data=val_generator,
validation_steps=validation_steps)
感谢阅读这篇文章。希望你觉得有用。
Keras 定制训练循环
Amazing photo by Dan Meyers on Unsplash
如何在 Keras 引擎的底层构建一个定制的训练循环，K.function，opt.get_updates 用法和其他东西
在所有其他深度学习库中，Keras 是一个高水平的库，我们都很喜欢它。它抽象了我们同样钟爱的 Tensorflow 在 GPU 上非常高效地处理数据带来的大部分痛苦。
我在工作和个人项目中使用 Keras，我非常喜欢它的 API 和建模方法。但是，当您想要做一些开箱即用的事情时，会发生什么呢？我告诉你，你偶然发现了这个框架。哪个框架？Keras 范式的框架。在 Keras 中，事情是简单而实用的，你按照步骤去做，事情就会惊人地好。但是，如果出于某种原因，你需要跳过或绕过主要路线，事情就会变得混乱。
你可能会说:*“但是 Keras 非常灵活，它有这个惊人的功能 API 来构建 daydream 迷宫模型，支持编写自定义层，强大的生成器来处理序列、图像、多处理、多输入输出、GPU 并行和……”，*我知道，事实上，我知道你知道，或者至少我期待它，否则，你不会阅读这篇文章。
但是，尽管有这种灵活性，我仍然可以指出 Keras 中一些相当令人讨厌的体验，例如具有多个输入/参数的损失函数，使用自定义层加载保存的模型…但不知何故，您可以通过一些变通方法或深入代码来解决这些问题。
然而，我最纠结的一件事是创建一个定制的训练循环。但是，你为什么要首先建立一个定制的训练循环呢？Keras 的全部意义不就是抽象出这样的细微差别，以便您可以专注于模型吗？嗯，这是非常正确的，但也有一些你想亲自动手的情况:当你的模型有不同形状的多个输入和输出(不可连接)以及一个独特的损失函数时，当你需要在训练时访问优化的梯度时…或者如果你想要特定的应用:就我而言主要是 GANs 和强化学习(如果你发现其他的，请在评论中告诉我，这样我也可以学习)。写这篇文章的主要原因是澄清(或者如果你喜欢的话，用文档记录)Keras 引擎中某些工具的用法，以构建一个定制的训练循环，而不严格受限于框架。
所以，无聊的够了，给我看看代码！
代码
在这里，所以你可以看看:
你可以把它分成几部分:
- 数据集创建:我们示例中的虚拟数据集。
- Keras 默认工作流程:包括模型、损失函数和优化器定义。
- 图形创建:创建计算图形并链接其所有部分。此部分不同于默认的 Keras 工作流，因为它是由 Keras 引擎在幕后完成的。
K.function用法:这是棘手的部分，K.function它没有被很好地记录，所以我会试着说明这个问题。- 训练循环:这里没有什么特别的，只有 for 循环和一些监控训练(当然还有测试)进展的打印。
资料组
我们案例中的虚拟数据集。给定[0，9]范围内的两个数，网络必须预测这两个数的和。所以:
- 样本= [ 100 x 2 ]，因此 100 个样本包含两个特征(这两个数字相加)
- Targets = [ 100 ]，这 100 个样本相加的结果，理想情况下，我希望它是[ 100 x 1 ]，但我们都熟悉 Numpy 在降维时的工作方式。
还创建了一个包含 10 个样本的小型测试数据集。
# Training samples
samples = np.random.randint(0, 9, size=(100,2)) targets = np.sum(samples, axis=-1)# Samples for testing
samples_test = np.random.randint(0, 9, size=(10,2)) targets_test = np.sum(samples_test, axis=-1)
Keras 工作流程
你已经知道了这一点，所以:
# Model
x = Input(shape=[2])
y = Dense(units=1)(x)
model = Model(x, y)
# Loss
def loss_fn(y_true, y_pred):
# You can get all the crazy and twisted you
# want here no Keras restrictions this time :)
loss_value = K.sum(K.pow((y_true - y_pred), 2))
return loss_value # Optimizer to run the gradients
optimizer = Adam(lr=1e-4)
这里唯一的事情是，你可以让损失函数变得疯狂和扭曲，因为 Keras 引擎不会用它的_standarize_user_data ( 链接)阻止你，也不会抱怨。你可以有多个输入，可配置的参数损失函数…我为这个演示实现了一个简单的误差平方和(SSE)。
图形创建和链接
这是棘手的部分。在 Keras 中，您定义的唯一图形是您的模型的计算流程(如果您愿意，也可以是损失函数，但有一些限制)。但是您没有定义损失函数、模型和梯度计算或参数更新之间的链接。
这时，我们需要将我们的观点从代码工作流转变为图形工作流，或张量流(喜欢这个笑话吗？).因此，除了定义模型的输入、模型本身和损失函数(我们已经完成了)之外，我们还需要:
- 为我们的地面实况创建输入，这样我们可以计算损失，即所谓的
y_true - 得到模型的输出，或者说预测，俗称
y_pred - 将模型预测和地面实况与损失函数(也已创建)联系起来
y_true = Input(shape=[0])
y_pred = model(x)
loss = loss_fn(y_true, y_pred)
如果你密切注意这一点，你会发现这个图的唯一输入是x和y_true(我知道你猜到了，因为只有分配了Input调用的变量，但是以防万一……)。
因此，我们已经有了输入、模型和要最小化的损失，所有这些都在一个计算图或一个张量流的图中(抱歉，我不能停止它)。
剩下唯一要做的事情是定义用于计算相对于模型权重的损失梯度的图形，并根据学习速率更新那些权重。简单对吗？嗯，这正是optimizer.get_updates所做的。给定一些参数和依赖于这些参数的损失，它返回计算图用于计算梯度(使用臭名昭著的 K.gradients)和更新权重。
optimizer.get_updates返回用于计算梯度和更新权重的计算图，给定一些要优化的参数(权重)和依赖于这些参数的损失
这是通过用我们定义的loss和参数或者模型的可训练权重来调用optimizer.get_updates来优化的。
# Operation fort getting
# gradients and updating weights
updates_op = optimizer.get_updates(
params=model.trainable_weights,
loss=loss)
k .函数用法
现在我们已经完成了图表。我们实际上有两张图表:
- 图表 1:输入= [ x，y_true ]，输出= [ loss]
- 图表 2:输入= [损失，权重]，输出=[更新的权重]
第一个图对应于网络的正向传递，图 2 对应于反向传递或优化循环。
现在我们有两张图，它们应该可以在 GPU 上非常高效地运行，那么，我们该如何运行它们呢？这就是K.function帮助我们的地方。
K.function(或keras.backend.function为了完整起见)的用法类似于 Tensorflow (这个是合法的)tf.Session用于实例化图形，session.run用于运行它。因此K.function的描述应该是:
K.function返回一个函数，该函数调用计算图的单次迭代或正向传递，如前所述，并通过其作为参数给出的inputs和outputs引用。如果设置了updates关键字，它也运行向后传递，图中描述的操作作为updates关键字的参数传递。
考虑到这一点，我们创建了两个函数来执行前面定义的图形:
train 函数，它的特点是对它的每次调用都有一个向前和一个向后的传递。它被配置为:
train = K.function(
inputs=[x, y_true],
outputs=[loss],
updates=updates_op)
以及测试函数，该函数仅计算前向传递，假定它旨在用于测试而不是用于更新权重。注意没有设置updates关键字。
test = K.function(
inputs=[x, y_true],
outputs=[loss])
注意，这两个函数都有一个参数作为输入，它是一个列表。该列表必须包含inputs中指定的输入张量。另一方面，输出将是一个带有在outputs关键字中指定的输出张量的列表。
在我们的例子中，一个呼叫将像这样完成:loss = train([sample, target])，然后损失将是一个列表，所以:loss = loss[0]。但是你可以在代码中查看它的上下文。
训练循环
最后，我们可以设置我们的自定义训练循环。这里没有什么特别的，只是一个默认的训练循环，不过，我会备注一些细节。虽然在代码中你可以看到训练循环和测试循环，但我将只关注前者，你可以把它扩展到后者。
细节决定成败，所以:
- 这只是一个实现进度条的库，进度条将告知一个时期内训练的进度。
- 由于我们一次抽取一个样本，
batch_size = 1，Numpy 挤压批次维度，但是模型期望一个具有 2 个维度、批次和特征的输入，因此我们需要使用np.expand_dims手动添加批次维度。 - 该图使用张量，因此我们需要用
K.constant将图的输入转换成张量。 - 已经实施了一个训练损失累加器来计算
loss_train_mean中每一步的平均值，该指标在每一时间步打印在进度条上，以监控训练的进展。
train功能的使用值得特别注意。每次调用时，train函数将使用给定的输入在 GPU 上运行图形的单次执行，向前和向后传递。该图将样本和目标作为输入来执行训练步骤，并将张量列表作为输出返回，在我们的示例中，只有一个张量，这是该训练步骤的损失。
检查每个输入张量的维数必须匹配，这是由 Keras 引擎默认完成的，但在这里我们的目标是控制。所以，当我们调用train([sample, target])时，sample必须和x = Input(shape=[2])有相同的维数，so ^ 2，批量和特征维数，target必须和y_true = Input(shape=[0])有相同的维数，后者是一个零维张量，或者是一个单一的数(标量)。
如果您运行该代码，您会看到类似这样的内容:
Evolution of the training with a slow laptop GPU
其中Training Loss是该时期的训练损失的平均值，而Test Loss是测试数据集的样本的测试损失的平均值。
在一些迭代之后，您可以体会到训练损失和测试损失将如何减少。
其他方法
尽管本指南的目的是展示如何在低抽象层次上使用 Keras，但这并不是一个好的实践或首选方法。为什么？因为 Keras 的高度抽象是精心设计的项目所期望的结果。所以这些工具的使用应该是一个例外，而不是常规，除非你真的想在一个低抽象层次上工作。
但是，如果我想在较低的抽象层次上工作呢？(也许你是一名优化研究人员，正在编写一个新的优化器，或者你正在从事科学计算的代数工作……谁知道呢？)在这种情况下，你可以问自己:如果我真的想控制一切，有没有其他方法来建立训练循环？
嗯，我很高兴你问了这个问题，因为作为一名工程师，我无法在不提出任何其他备选方案的情况下给出一个解决方案。还有另外两个很好的方法来轻松训练你的模型，并且仍然让事情在你的控制之下:
- 张量层:谷歌的一个被广泛忽视的项目，旨在提供深度学习模型的主要构建模块，而不放弃底层细节。
- TensorFlow 2.0 定制训练循环:通过将 Keras 集成到 TensorFlow 2.0 版本中，您可以同时拥有两个世界的优点，即 Keras 的高级构建模块和 TensorFlow 的低级流控制。
因此，如果你真的需要 Tensorflow 的低级 go，如果你只是需要一个适度的抽象级别，请使用 TensorLayer，但如果你像我一样，主要在 Keras 的高级 go 中工作，并使用这些技巧来克服你真的需要它的不寻常的角落情况。
Keras 数据生成器及其使用方法
您可能遇到过这样的情况:您试图加载一个数据集，但是您的计算机没有足够的内存。随着机器学习领域的进步，这个问题变得越来越普遍。今天，这已经是视觉领域中的挑战之一，在视觉领域中，要处理大数据集的图像和视频文件。
在这里，我们将重点讨论如何构建数据生成器，以便在 Keras 中加载和处理图像。
数据生成器的功能是什么
在 Keras 模型类中，有三个方法让我们感兴趣:fit_generator、evaluate_generator 和 predict_generator。这三者都需要数据生成器，但并非所有生成器都是同等创建的。
让我们看看每种方法需要哪种生成器:
拟合 _ 生成器
需要两个生成器，一个用于训练数据，另一个用于验证。幸运的是，它们都应该返回一个元组(输入，目标),并且它们都可以是 Sequence 类的实例。
评估 _ 生成器
这里的数据生成器与 fit_generator 中的要求相同，并且可以与训练生成器相同。
预测生成器
这里的发电机有点不同。它应该只返回输入。
记住这一点，让我们构建一些数据生成器。由于 fit_generator 和 evaluate_generator 中的生成器相似，我们将重点构建 fit_generator 和 predict_generator 的数据生成器。
ImageDataGenerator 类
ImageDataGenerator 类在图像分类中非常有用。有几种方法可以使用这个生成器，取决于我们使用的方法，这里我们将重点介绍 flow_from_directory 取一个路径到包含在子目录中排序的图像和图像增强参数的目录。
让我们看一个例子:
我们将使用可从https://www.kaggle.com/c/dogs-vs-cats/data下载的数据集，其结构如下:
data/
train/
dogs/
dog001.jpg
dog002.jpg
...
cats/
cat001.jpg
cat002.jpg
...
validation/
dogs/
dog001.jpg
dog002.jpg
...
cats/
cat001.jpg
cat002.jpg
...
首先，让我们导入所有必要的库，并创建一个带有一些图像增强的数据生成器。
最后，创建一个模型并运行 fit_generator 方法。
ImageDataGenerator 是一种为图像分类任务批量加载和扩充图像的简单方法。但是！如果你有一个分段任务呢？为此，我们需要构建一个定制的数据生成器。
灵活的数据生成器
要构建自定义数据生成器，我们需要从 Sequence 类继承。让我们这样做，并添加我们需要的参数。
Sequence 类迫使我们实现两个方法；len 和 getitem。如果我们想让生成器在每个纪元后做一些事情，我们也可以在 _epoch_end 上实现这个方法。
len 方法应该返回每个时期的批数。一种可能的实现如下所示。
如果 shuffle=True，此示例中的 on_epoch_end 可以对训练的索引进行混洗。但是这里可以有任何我们想要在每个纪元后运行的逻辑。
我们必须实现的第二个方法是 getitem 它完全符合您的预期。如果我们进行预测，它应该会返回一批图像和遮罩。这可以通过将 to_fit 设置为 True 或 False 来控制。
整个数据生成器应该如下所示:
假设我们有两个目录，一个保存图像，另一个保存蒙版图像，并且每个图像都有一个同名的相应蒙版，下面的代码将使用自定义数据生成器为模型定型。
最后，如果我们想使用数据生成器进行预测，应该将 to_fit 设置为 False，并调用 predict_generator。
结论
虽然 Keras 提供了数据生成器，但是它们的能力有限。原因之一是每个任务都需要不同的数据加载器。有时每个图像有一个遮罩，有时有几个，有时遮罩被保存为图像，有时被编码，等等…
对于每个任务，我们可能需要调整我们的数据生成器，但结构将保持不变。
参考链接
斯坦福大学的 Keras 如何使用数据生成器的详细示例
python keras 2 fit _ generator Afshine Amidi 和 Shervine Amidi 的大型数据集多重处理您是否曾经不得不…
stanford.edu](https://stanford.edu/~shervine/blog/keras-how-to-generate-data-on-the-fly)
Keras 模型类
在函数式 API 中，给定一些输入张量和输出张量，您可以通过以下方式实例化一个模型:from…
keras.io](https://keras.io/models/model/)
Keras ImageDataGenerator 类
keras . preprocessing . image . image data generator(feature wise _ center = False，samplewise_center=False…
keras.io](https://keras.io/preprocessing/image/)
初学者的 Keras:建立你的第一个神经网络
关于使用 Keras 在 Python 中实现简单神经网络的初学者友好指南。
Keras 是一个简单易用但功能强大的 Python 深度学习库。在这篇文章中，我们将看到建立一个前馈神经网络并训练它解决 Keras 的一个实际问题是多么容易。
这篇文章是为完全初学 Keras 的人写的，但是假设他有神经网络的基础背景知识。我的关于神经网络的介绍涵盖了这篇文章中你需要知道的一切(以及更多)——如果有必要的话，请先阅读。
我们开始吧！
只想要代码？下面是 完整源代码 。
问题:MNIST 数字分类
我们要解决一个经典的机器学习问题: MNIST 手写数字分类。很简单:给定一个图像，将其归类为一个数字。
Sample images from the MNIST dataset
MNIST 数据集中的每幅图像都是 28x28，包含一个居中的灰度数字。我们将把每个 28x28 展平成一个 784 维向量，我们将把它作为神经网络的输入。我们的输出将是 10 个可能的类之一:每个数字一个。
1.设置
我假设您已经准备好了基本的 Python 安装(您可能已经准备好了)。让我们首先安装一些我们需要的软件包:
$ pip install keras tensorflow numpy mnist
注意:我们需要安装
*tensorflow*，因为我们要在一个TensorFlow后端上运行 Keras(即 tensor flow 将为 Keras 供电)。
现在，您应该能够导入这些包并浏览 MNIST 数据集:
2.准备数据
如前所述，我们需要将每个图像展平，然后才能将其传递到我们的神经网络中。我们还将从[0，255]到[-0.5，0.5]归一化像素值，以使我们的网络更容易训练(使用较小的居中值通常更好)。
我们准备好开始构建我们的神经网络了！
3.构建模型
每个 Keras 模型要么使用代表线性层堆栈的顺序类构建，要么使用可定制性更强的功能性模型类构建。我们将使用更简单的Sequential模型，因为我们的网络实际上是层的线性堆叠。
我们从实例化一个Sequential模型开始:
Sequential构造器接受一个 Keras 层的数组。因为我们只是在构建一个标准的前馈网络，所以我们只需要密集层，也就是常规的全连接(密集)网络层。
让我们扔进 3 层Dense:
前两层各有 64 个节点，使用 ReLU 激活功能。最后一层是一个有 10 个节点的 Softmax 输出层，每个类一个节点。
如果需要复习，读我的 简单 Softmax 解释 。
我们总是需要做的最后一件事是告诉 Keras 我们的网络的输入将会是什么样子。我们可以通过给Sequential模型中的第一层指定一个input_shape来实现:
指定输入形状后，Keras 将自动推断后续图层的输入形状。我们已经完成了模型的定义！我们的情况是这样的:
4.编译模型
在开始培训之前，我们需要配置培训流程。在编译步骤中，我们决定 3 个关键因素:
- 优化器。我们将坚持一个非常好的默认设置:基于梯度的优化器。Keras 还有许多其他的优化器，你也可以看看。
- 损失函数。由于我们使用的是 Softmax 输出层，我们将使用交叉熵损失。Keras 区分了
binary_crossentropy(2 类)和categorical_crossentropy( > 2 类)，所以我们将使用后者。查看所有 Keras 损失。 - 一系列指标。由于这是一个分类问题，我们将让 Keras 报告准确性指标。
这是编译后的样子:
向前！
5.训练模型
在 Keras 中训练一个模型实际上只包括调用fit()和指定一些参数。有许多可能的参数，但我们将只手动提供几个:
- 训练数据(图像和标签)，分别俗称 X 和 Y。
- 要训练的历元数(整个数据集的迭代次数)。
- 训练时使用的批次大小(每次梯度更新的样本数)。
看起来是这样的:
然而，这实际上还没起作用——我们忽略了一件事。Keras 希望训练目标是 10 维向量，因为在我们的 Softmax 输出层中有 10 个节点，但是我们提供了一个单个整数来表示每个图像的类。
方便的是，Keras 有一个实用方法可以解决这个问题:to _ categorial。相反，它将我们的类整数数组变成了一个由单热点向量组成的数组。例如，2会变成[0, 0, 1, 0, 0, 0, 0, 0, 0, 0](它是零索引的)。
我们现在可以将所有东西放在一起训练我们的网络:
运行这段代码会得到如下结果:
Epoch 1/5
60000/60000 [==============================] - 2s 35us/step - loss: 0.3772 - acc: 0.8859
Epoch 2/5
60000/60000 [==============================] - 2s 31us/step - loss: 0.1928 - acc: 0.9421
Epoch 3/5
60000/60000 [==============================] - 2s 31us/step - loss: 0.1469 - acc: 0.9536
Epoch 4/5
60000/60000 [==============================] - 2s 31us/step - loss: 0.1251 - acc: 0.9605
Epoch 5/5
60000/60000 [==============================] - 2s 31us/step - loss: 0.1079 - acc: 0.9663
经过 5 个周期，我们达到了 96.6%的训练准确率。然而，这并没有告诉我们太多——我们可能过度适应了。真正的挑战将是看看我们的模型在我们的测试数据上表现如何。
6.测试模型
评估模型非常简单:
跑步带给我们:
10000/10000 [==============================] - 0s 15us/step
[0.10821614159140736, 0.965]
evaluate() 返回一个数组，该数组包含测试损失，后跟我们指定的任何指标。因此，我们的模型实现了 0.108 的测试损失和 96.5%的测试精度！对你的第一个神经网络来说还不错。
7.使用模型
现在我们有了一个工作的、经过训练的模型，让我们将它投入使用。我们要做的第一件事是将它保存到磁盘，这样我们就可以随时将它加载回来:
model.save_weights('model.h5')
现在，我们可以随时通过重建模型并加载保存的权重来重新加载训练好的模型:
使用训练好的模型进行预测很容易:我们将一个输入数组传递给predict()，它返回一个输出数组。请记住，我们网络的输出是 10 个概率(因为 softmax)，所以我们将使用 np.argmax() 将这些转换成实际的数字。
8.扩展ˌ扩张
到目前为止，我们所涉及的只是一个简单的介绍——我们还可以做更多的事情来试验和改进这个网络。我在下面列举了几个例子:
调谐超参数
一个好的超参数是亚当优化器的学习率。当你增加或减少它的时候会发生什么？
批量大小和历元数呢？
网络深度
如果我们删除或添加更多全连接层，会发生什么？这对培训和/或模型的最终表现有什么影响？
激活
如果我们使用 ReLU 以外的激活，例如 sigmoid ，会怎么样？
拒绝传统社会的人
如果我们尝试添加下降层，这是众所周知的防止过度拟合？
确认
我们还可以在训练期间使用测试数据集进行验证。Keras 将在每个时期结束时评估验证集上的模型，并报告损失和我们要求的任何指标。这使我们能够在训练期间监控模型的进度，这对于识别过度拟合甚至支持早期停止是有用的。
结论
你已经用 Keras 实现了你的第一个神经网络！我们在 5 个历元后在 MNIST 数据集上取得了 96.5% 的测试准确率，对于这样一个简单的网络来说已经不错了。我将在下面再次包含完整的源代码，供您参考。
如果你想了解接近 MNIST 的更先进的技术，我推荐查看我的卷积神经网络介绍(CNN)。在这篇文章中，我们看到了如何使用更复杂的网络在 MNIST 上实现更高的准确率。我也推荐我的指南用 Keras 实现一个 CNN，它类似于这篇文章。
你可能感兴趣的进一步阅读材料包括:
感谢阅读这篇文章！完整的源代码如下。
完整的代码
云中的 Keras 超参数优化
使用 Talos 和 Docker 在云中高效搜索大型参数空间
Photo by Roberta Sorge on Unsplash
当训练机器学习模型时，将计算卸载到远程服务器通常更方便(也更有必要)。虽然免费服务如 Google Colab 和 Azure Notebooks 对于 Jupyter 笔记本中的初始手动工作来说很棒，但它们不太适合长时间运行的实验，如超参数训练，因为它们在几个小时后会自动关闭。
以 AWS 为例云提供商，最直接的翻译就是在 Sagemaker 上运行笔记本。然而，通过在 Docker 容器中设置培训并自己进行部署，可以获得更高的成本效率。在这种类型的环境中开发一个模型还具有可移植性和可再现性的优势(后面会详细介绍)。
在 AWS 中，对于这种类型的作业，有三种主要的 Docker 部署选项:
- ECS Fargate:抽象出服务器级配置，只需要基本的网络、权限和 CPU/内存要求。
- ECS EC2:提供精细控制，同时仍允许 ECS 管理群集和整体资源使用情况。
- EC2:提供完整的端到端配置来运行容器。
为了比较各选项的成本，我们将该地区固定为 US-East-1，并使用 Fargate 的 CPU/内存定价来提供一个实例等效成本($ 0.04048/vCPU/HR+$ 0.004445/GB/HR)。
实例类型:m5.xlarge (4 个 vCPU / 16 GB)
- AWS sage maker = 0.269 美元/小时>>每 3 天 19.37 美元
- AWS Fargate(等值)= 0.23304 美元/小时>>每 3 天 16.78 美元
- 按需 AWS EC2 = 0.192 美元/小时>>每 3 天 13.82 美元
- AWS EC2 现货= 0.0827 美元/小时>>每 3 天 5.95 美元
很明显，如果我们能够利用 spot 实例，将会有显著的成本优势，同样的优势也适用于 c5.large 等其他实例类型。 spot 实例的主要限制是容量可以随时回收，但是超参数培训工作非常适合这种情况。
此外，由于 ECS 实际上旨在管理集群，我们将通过采取以下步骤来部署我们自己的 EC2 实例以避免这种开销:
- 设置样板 Docker 容器
- 在容器内部本地开发模型和优化方法
- 为 EC2 准备一个自定义 Docker 容器
- 将容器部署到 EC2 spot 实例，该实例将结果保存到 S3
- 本地下载结果并可视化
- 选择最佳部署模式
值得注意的是，Sagemaker 还提供了一套 a 服务，用于培训和超参数优化，此处未考虑。
模型概述
对于这个例子，我们将使用来自 Kaggle 的一个简单的数据集，它展示了各种葡萄酒属性和相关的质量分数。
具有 Tensorflow 后端的 Keras 将是机器学习库的选择，对于超参数优化，我们将选择一个名为 Talos 的新库，它具有非常易于使用的工作流。有关介绍，请访问他们关于走向数据科学的文章:
towardsdatascience.com](/hyperparameter-optimization-with-keras-b82e6364ca53)
环境设置
将本地实验迁移到远程服务器的最简单方法是始终在 Docker 容器内工作，因为这允许您通过 Python 包从操作系统移植环境的精确副本。
作为基础，我们可以在 Python 3 中使用 Tensorflow 的 Docker 图像。首先导航到您的项目目录，然后运行下面的命令来启动一个 shell 会话。
$ docker run -it -p 8888:8888 --rm -v $PWD:/root \
-w /root tensorflow/tensorflow:1.13.1-py3
然后在 Docker shell 中安装所需的最小 Python 库:
$ pip install jupyter keras talos
注意:在撰写本文时，PyPi 上可用的 Talos 版本是 v0.4.9。然而，v0.6 很快就会有重大变化，因此使用了这个分支。为此，需要安装 *apt-get update && apt-get install -y git* ，然后将分支传递给 pip，而不是 *talos* ，例如 pip install git+https://github.com/autonomio/talos.git@daily-dev。我还创建了一个快照，这样这个例子就可以重现了: https://github.com/mikepm35/talos.git@v0.6-prerelease。
然后可以通过下面的命令启动 Jupyter 会话，并在您的本地机器上的http://localhost:8888/访问。
$ jupyter notebook --ip=0.0.0.0 --no-browser --allow-root
通过将容器内的工作目录映射到项目目录，所有文件都将被创建并保存在您的本地机器上。
模型设置
笔记本配置
这个例子的模式是模型开发在 Jupyter 笔记本中进行，它也可以在“笔记本即服务”平台上运行，比如 Google Colab。然后，它被转换成一个常规的 Python 文件，用于在云中执行长期运行的优化实验。
为了帮助解决这一问题，我们提供了以下元素来正确配置笔记本电脑:
- 定义数据流和实验参数的控制字典。
- 如果在笔记本服务(如 Google Colab)上运行，可选择安装 Python 包的标志。
- 运行无头优化实验时，使用当前系统用户名来避免图形 UI 显示的导入逻辑语句。(注意，还有其他模式可以用来处理 matplotlib 安装，比如将逻辑移入控制字典)。
数据准备
假设属性跨越多个数量级，我们将归一化所有的特征列(X)。
标签列(Y)将基于阈值被编码为两个类别(差质量、好质量)的一个热点。这也遵循来自 Kaggle 的数据的附带描述的指导。
一个值得关注的问题是，这些类别非常不平衡，只有 13.6%的观察结果被标记为“高质量”。在本节中，我们计算了可选合并到训练中的类权重，但是手动实验没有显示性能的改善，因此它被排除在最终模型之外。
模型配置
为 Talos 建立一个实验遵循正常的 Keras 序列模型的模式，除了为用于优化的参数添加替换(params)。为了允许不同数量的隐藏层，使用了 Talos 函数，而不是直接在我们的函数中构建它们。
优化实验的输入被定义为离散值[a, b, c]或范围(min, max, steps)的字典。有关可用参数的更多信息，请参见 Talos 文档。
调用Scan()时，实际实验开始。这里fraction_limit定义了将运行的全网格参数空间的百分比，即所有可能参数组合的 25%将实际运行。这个例子中没有显示 Talos 中定义优化策略的众多选项。
扫描开始后，Talos 将提供要运行的实验总数以及预计完成时间。在我们的例子中，有 5，760 次运行，大约需要 10 个小时。(请注意，随着新运行的执行，时间估计将会更新，这个实验的实际总执行时间是 22 小时)。
实验完成后，我们可以创建一个部署包，其中包含由val_acc定义的最佳 Keras 模型。这个 zip 文件和每次运行后生成的 csv 结果将被上传到 S3。
部署和培训
模型设置完成后，在 Docker 容器中运行以下命令来保存 Python 依赖项:
$ pip freeze > requirements.txt
如果您使用 Talos 的单独分支，一定要用 git url 替换talos==0.6.0。
为部署设置 Docker 容器
为了部署实验，必须开发一个定制的 Docker 映像来重新创建本地环境。这个 docker 文件从同一个基本 Tensorflow 映像开始，复制 Jupyter 笔记本文件、数据和需求，然后安装所有 Python 包。还创建了一个新用户kerasdeploy，这是安装适当的 matplotlib 后端的触发器。
由于这是一个无头实验，我们将使用 nbconvert 将笔记本转换成一个常规的 Python 文件，然后在容器启动时立即执行。
FROM tensorflow/tensorflow:1.13.1-py3RUN useradd -ms /bin/bash kerasdeployWORKDIR /home/kerasdeployRUN apt-get update && apt-get install -y gitCOPY keras_remote_training.ipynb winequality-red.csv requirements.txt ./RUN pip install -r requirements.txtRUN chown -R kerasdeploy:kerasdeploy ./
USER kerasdeployRUN jupyter nbconvert --to script keras_remote_training.ipynbCMD ["python","-u","keras_remote_training.py"]
完成后，构建容器…
$ docker build -t keras-remote-training .
…然后在本地运行几次，以验证一切正常。
$ docker run --name keras-remote-training \
--rm keras-remote-training:latest
AWS 配置和部署
现在 Docker 映像已经完成，需要设置云环境。在本例中，我们将使用 ECR 作为 Docker 储存库，但是类似的 push/pull 命令也可以用于 Docker hub(或其他)储存库。
导航到 ECR，创建一个新的存储库keras-remote-training，并注意 URI。使用这个 URI 标记构建，检索基本的 auth 凭证，然后推送到 ECR。
$ docker tag keras-remote-training:latest \
<ecr_id>.dkr.ecr.<region>.amazonaws.com/keras-remote-training:latest$ (aws ecr get-login --no-include-email --region <region>)$ docker push \
<ecr_id>.dkr.ecr.<region>.amazonaws.com/keras-remote-training:latest
在 AWS 中，启动“启动实例”向导，并使用以下选项:
- 图片
ami-0f812849f5bc97db5来自为 ECR/Docker 预建的社区 AMIs - 实例类型 m5.xlarge(或其他变体)
- 选择“请求 spot 实例”
- 选择允许访问 S3 和 ECR 的 IAM 角色(例如，附加了 AmazonS3FullAccess 和 amazone 2 containerregistyrepoweruser 策略)
- 在“高级选项”下添加一个启动脚本，该脚本将自动提取并运行 Docker 映像。如果需要，这也允许在终止时自动重启。
当实例启动时，优化实验将自动开始执行，并将结果保存到 S3！
当训练停止时(例如，当平均 CPU 利用率下降到< 10%至少五分钟时)，设置 CPU 警报作为代理非常有用。该警报可以发送电子邮件通知，或自动终止实例以减少费用。
Photo by Andrew Wulf on Unsplash
结果
Talos 包含内置的报告功能，但是，为了提供进一步的定制，我们将把结果文件直接加载到 Pandas 数据框架中。因为这些结果在 S3，所以我们将运行本地实例，而不执行 Scan()。
Kaggle 文档提到 AUC 目标值为 0.88，我们将从最佳模型中计算出该值作为第一参考值。结果是 0.89，这是一个好的开始。
为了探索拟合的质量，我们将绘制验证准确性与损失的关系图，以及培训损失与验证损失的关系图。
从上述图表中可以得出两个主要结论:
- 大多数优化实验都是高价值的，如验证准确性上限周围的紧密聚类所示。
- 在有过度拟合趋势的地方产生二次分布。
为了处理实验中的过度拟合，我们将向结果添加一个新参数，该参数表示验证损失和训练损失之间的差异(正值表示过度拟合)。正值表示过度拟合，为后续滤波设置阈值。
使用这个新参数，我们现在可以查看没有过度拟合的最佳结果。尽管我们是按准确度排序的，但我们也将包括作为混淆矩阵代理的马修斯相关系数。
正如所料，根据loss_diff的测量，压差的增加与过度拟合的减少相关。对准确度和马修斯相关系数影响最大的因素是学习速率和隐藏层，与批量大小和时期的关系较弱。
后续步骤
根据所需的微调，这些结果可以直接用于部署模型，或构建更窄的后续实验。
这个例子使用了一个非常小的数据集，所以内存优化的实例不是最好的选择。在价格是 m5.xlarge 一半的 c5.large 中重新运行，对于 0.81 美元的实验，我们可以观察到更好的资源利用率和合理的总成本。
$ docker statsCPU % MEM USAGE / LIMIT MEM %157.47% 394.4MiB / 3.618GiB 10.64%
要查看与本文相关的代码，请访问https://github.com/mikepm35/KerasRemoteTraining。
深度学习的 Keras vs PyTorch
想获得灵感？快来加入我的 超级行情快讯 。😎
对于许多科学家、工程师和开发人员来说，TensorFlow 是他们的第一个深度学习框架。TensorFlow 1.0 发布于 2017 年 2 月；至少可以说，它对用户不太友好。
在过去的几年里，两个主要的深度学习库获得了巨大的人气，主要是因为它们比 TensorFlow 更容易使用: Keras 和 PyTorch 。
本文将涵盖 Keras vs. PyTorch 的 4 个不同方面，以及为什么您会选择一个库而不是另一个库。
克拉斯
Keras 本身并不是一个框架，实际上是一个位于其他深度学习框架之上的高级 API。目前它支持 TensorFlow、Theano 和 CNTK。
Keras 的妙处在于好用。这是迄今为止最容易快速启动和运行的框架。定义神经网络是直观的，使用函数式 API 可以将层定义为函数。
PyTorch
Pyorch 是由脸书人工智能研究小组开发的深度学习框架(类似 TensorFlow)。像 Keras 一样，它也抽象掉了编程深度网络的许多混乱部分。
就高级和低级编码风格而言，Pytorch 介于 Keras 和 TensorFlow 之间。与 Keras 相比，您有更多的灵活性和控制力，但同时您不必进行任何疯狂的声明式编程。
深度学习的实践者整天都在考虑应该使用哪个框架。一般看个人喜好。但是当你做出选择时，你应该记住 Keras 和 Pytorch 的一些方面。
It’s Pytorch!
(1)用于定义模型的类与函数
为了定义深度学习模型，Keras 提供了函数式 API。使用函数式 API，神经网络被定义为一组连续的函数，一个接一个地应用。例如，功能定义层 1 的输出是功能定义层 2 的输入。
img_input = layers.Input(shape=input_shape)
x = layers.Conv2D(64, (3, 3), activation='relu')(img_input)
x = layers.Conv2D(64, (3, 3), activation='relu')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2))(x)
在 Pytorch 中，您将网络设置为一个类，该类扩展了 torch 库中的 torch.nn .模块。与 Keras 类似，Pytorch 为您提供了作为构建块的层，但由于它们位于 Python 类中，因此它们在该类的 init()方法中被引用，并由该类的 forward()方法执行。
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 64, 3)
self.conv2 = nn.Conv2d(64, 64, 3)
self.pool = nn.MaxPool2d(2, 2)
def forward(self, x):
x = F.relu(self.conv1(x))
x = self.pool(F.relu(self.conv2(x)))
return x
model = Net()
因为 Pytorch 让您可以访问 Python 的所有类特性，而不是简单的函数调用，所以定义网络可以更清晰、更优雅。这真的没有太大的坏处，除非你真的觉得尽快编写网络代码对你来说是最重要的，那么 Keras 会更容易使用。
(2)张量和计算图形与标准数组
Keras API 隐藏了许多不经意间被编码者发现的混乱细节。定义网络层很直观，默认设置通常足以让您入门。
只有在实现一个相当前沿或“奇特”的模型时，才真正需要深入到底层的、本质的张量流。
棘手的部分是，当你真的深入到底层 TensorFlow 代码时，你会得到随之而来的所有具有挑战性的部分！你需要确保所有的矩阵乘法都排成一行。哦，甚至不要想打印出你的层的输出之一，因为你只会得到一个很好的张量定义打印在你的终端上。
Pytorch 在这些方面更宽容一些。您需要知道每一层的输入和输出大小，但是这是比较容易的方面之一，您可以很快掌握。你不必处理构建一个抽象的计算图，你看不到里面的调试。
Pytorch 的另一个优点是可以在 torch 张量和 Numpy 数组之间来回切换。如果您需要实现一些自定义的东西，那么在 TF tensors 和 Numpy 数组之间来回切换可能会很痛苦，需要开发人员对 TensorFlow 会话有很好的理解。
Pytorch 互操作实际上要简单得多。您只需要知道两个操作:一个是将 Torch 张量(一个可变对象)切换到 Numpy，另一个是相反的方向。
当然，如果您从来不需要实现任何花哨的东西，那么 Keras 会做得很好，因为您不会遇到任何 TensorFlow 路障。但如果你这样做了，Pytorch 可能会顺利得多。
(3)培训模式
Time to train!
在 Keras 训练一个模特超级容易！只需一个简单的.fit()动作，你就可以尽情享受旅程了！
history = model.fit_generator(
generator=train_generator,
epochs=10,
validation_data=validation_generator)
在 Pytorch 中训练模型包括几个步骤:
- 在每批训练开始时初始化梯度
- 通过模式运行正向传递；
- 向后传球
- 计算损失并更新权重
for epoch in range(2): # loop over the dataset multiple times running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# Get the inputs; data is a list of [inputs, labels]
inputs, labels = data # (1) Initialise gradients
optimizer.zero_grad() # (2) Forward pass
outputs = net(inputs)
loss = criterion(outputs, labels) # (3) Backward
loss.backward() # (4) Compute the loss and update the weights
optimizer.step()
光是运行培训就有很多步骤！
我想这样你总是能意识到发生了什么。同时，这是完全不必要的，因为这些模型训练步骤对于训练不同的模型基本上保持不变。
(4)控制 CPU 与 GPU 模式
We need MORE POWER
如果您已经安装了tensorflow-gpu，那么在 Keras 中，默认情况下会启用并使用 GPU。然后，如果您希望将某些操作转移到 CPU，您可以使用一行程序来完成。
with tf.device('/cpu:0'):
y = apply_non_max_suppression(x)
对于 Pytorch，您必须为每个 torch 张量和 numpy 变量显式启用 GPU。这使代码变得混乱，如果您为了不同的操作在 CPU 和 GPU 之间来回移动，可能会有点容易出错。
例如，要将我们以前的模型转移到 GPU 上运行，我们必须执行以下操作:
# Get the GPU device
device **=** torch**.**device("cuda:0" **if** torch**.**cuda**.**is_available() **else** "cpu")# Transfer the network to GPU
net**.**to(device)# Transfer the inputs and labels to GPU
inputs, labels **=** data[0]**.**to(device), data[1]**.**to(device)
Keras 的优势在于它的简单性和良好的默认设置
选择框架的一般建议
我通常给的建议是从 Keras 开始。
Keras 绝对是最容易使用、理解和快速启动并运行的框架。你不必担心 GPU 的设置，摆弄抽象代码，或一般做任何复杂的事情。你甚至可以做一些事情，比如实现自定义层和损失函数，而无需接触 TensorFlow 的任何一行。
如果您开始深入到深层网络的更细粒度的方面，或者正在实现一些非标准的东西，那么 Pytorch 就是您的首选库。在 Keras 上会有一点额外的工作，但不会太多以至于减慢你的速度。您仍然能够快速实现、训练和测试您的网络，同时还能轻松调试！
喜欢学习？
在推特上关注我，我会在那里发布所有最新最棒的人工智能、技术和科学！也在 LinkedIn 上和我联系吧！
非线性分类中的核函数
了解内核函数如何将特性映射到更高维度。
由于数据点在其原始特征空间中是非线性可分的，线性分类器可能无法确定决策边界在哪里。然而，将原始特征空间( x ∈ ℝᵈ)映射到更高维的特征空间( ϕ ( x ) ∈ ℝᵉ，e > d)可以帮助复活线性分类器来正确地完成工作。
图一。阐释了通过特征映射对数据点进行分类的概念。本来，二维空间中具有特征向量 x = [ x ₁， x ₂]的数据点具有同心圆分布(这里不是严格的数学描述)。不可能使用线性分类器来区分决策边界。
尽管如此，通过结合某种映射函数 ϕ ( x )，特征向量可以被变换到三维特征空间。具有三维特征向量ϕ(x)=[x₁，x₂,(x₁+x₂]的新数据点现在可以使用线性分类器来确定决策边界超平面。这就是特性映射的力量，它可以让我们用更强的表达能力来处理更复杂的数据分布模式。
Figure 1. Mapping data points with 2-D feature vectors into 3-D feature vectors
但是，直接使用 ϕ ( x )的缺点是
- 有时很难直接显式构造一个 ϕ ( x )。
- 随着特征尺寸的增加，计算能力迅速提高。
但是内核函数可以提供一种有效的方法来解决这个问题。
核函数
核函数的思想是在两个特征向量之间取内积，并且计算内积不需要很大的计算量。然后，我们可以在算法中只利用内积的结果。例如，如果我们想让 ϕ ( x )如下:
核函数取两个特征向量之间的内积如下，
因此，核函数的形式对于我们来说将比在更高的特征维度中直接使用映射函数更容易构造。
内核合成规则
有几个内核组合规则可以用来构造更复杂的内核函数。
径向基核
核函数甚至可以赋予特征向量无限维的能力。一种常见的核函数是径向基核。定义如下。
因为指数可以扩展到无穷幂级数，所以径向基核赋予特征映射更多的表现力。下面是径向基核是核函数的证明。
核感知器算法
这里回忆一下感知器算法，感知器算法一旦一个数据点被误分类，就更新θ=θ+y⁽ʲ⁾x⁽ʲ⁾。换句话说， θ 可以替换地表达如下。**
其中，α ⱼ 是感知器在第 j 个数据点上犯的错误数。如果在映射特征空间中，则 θ 可以表示如下。
**利用 θ的核心形式，核心感知器算法的伪代码可以描述如下。
***# Kernel Perceptron Algorithm**# initialize* α**ⱼ**
*# totally m data points* for i = 1 .. m do
αᵢ = 0*# totally T epoches to iterate*
for t = 1 .. T do
* # totally m data points*
for i = 1 .. m do
*# misclassify data points*
if y⁽ⁱ⁾***∑*ⱼ(**α**ⱼ**y⁽ʲ⁾*K*(x⁽ʲ⁾,x⁽ⁱ⁾)**)** ≦ 0
then
αᵢ = αᵢ + 1θ*ϕ*(x⁽ⁱ⁾)= ***∑*ⱼ(**α**ⱼ**y⁽ʲ⁾*K*(x⁽ʲ⁾,x⁽ⁱ⁾)**)****
内核在运行
图二。通过径向基核感知器算法可视化决策边界的更新。注意，由径向基核感知器算法绘制的决策边界可以在 2 个 epoches 内收敛于这种数据分布。径向基核的γ在这里使用 0.3。
Figure 2. Updating the decision boundaries by the RBK perceptron algorithm. May take time to load.
示例代码
在 Jupyter 笔记本上写的感知器算法的样本代码可以在这里找到。您可以自己处理数据和超参数，看看内核感知器算法的表现如何。
内核回归—示例和代码
Photo by Markus Spiske on Unsplash
本文讨论了如何利用核函数作为权函数来建立非参数回归模型。在文章的开始，简要讨论了核函数的性质和围绕数据点构建核的步骤。
核函数
在非参数统计中，核是满足以下性质的加权函数。
- 一个核函数必须对称。从数学上讲，这种性质可以表示为 K (-u) = K (+u)。核函数的对称性质使其最大值( max(K(u) )位于曲线的中间。
An illustration of Gaussian kernel function
2.函数曲线下的面积必须是等于 1。从数学上来说，该属性表示为:
3.核函数的值不能为负，即K(u)≥0 for all-<u<∞。
核估计
在本文中，高斯核函数用于计算数据点的核。高斯核的等式是:
其中 xi 为观察数据点。 x 是计算核函数的值， h 称为带宽。核回归中的带宽被称为平滑参数，因为它控制输出中的方差和偏差。本文稍后将讨论带宽值对模型预测的影响。
例子
假设有六个数据点，每个数据点显示单个学生在某一科目中获得的分数。使用高斯核函数在每个数据点构建核的步骤如下所述。
【Xi】= { 65，75，67，79，81，91}其中 x1 = 65，x2= 75…X6= 91。
需要三个输入来构建围绕数据点的核心曲线。
一.观察数据点，
二。的值 h 的值
三。线性间隔的数据点系列，包括需要估计 K 值的观察数据点。如: Xj = {50，51，52 …99}
对于给定的h 值，计算K 值*【Xj】值的步骤如下表所示，其中【Xi】= 65、h= 5.5。表格中的最后一列显示了内核的纵坐标为= 65。*****
下面绘制 Xj 和 K 来可视化内核。注意图中的 x 轴是 Xj ，在其上构建内核曲线，在高斯分布的情况下，以【Xi】为均值，【h】为标准差。
类似地，在所有六个观察到的数据点，内核值被估计并绘制如下。据观察，【Xj】与【Xi】相差甚远的 K 的值接近 0。例如，Xj= 99 的内核值对于= 65 是零。****
Kernels plotted for all xi
核回归
在本节中，内核值用于从给定的输入导出权重以预测输出。计算权重并最终将其用于预测输出变量所涉及的步骤，预测变量中的 y ， x 将在以下章节中详细说明。让我们从一个例子开始，清楚地理解内核回归是如何工作的。
例子
在本例中，开发了一个核心回归模型来预测集水区的河流流量。如下图所示，集水面积(平方英里)和河流流量(立方英尺/秒)之间存在非线性关系。在本例中， y 为河流流量，x 为流域面积。
Example data set to build kernel regression
作为加权函数的核
最初，如前几节所述，使用所有输入的带宽值来估计核。然后用它们来计算重量。在本例中，带宽值 10 用于解释内核回归。然而，带宽值需要优化以适当地适应数据。在不同的 x 值下绘制的内核如下图所示。
*重要的是要理解，内核是在所有的 xi 值下开发的。内核回归背后的基本计算是针对给定的*预测值 xi，估计所有观察到的 y 值的加权和。权重只不过是内核值，范围在 0 和 1 之间，在给定的 xi 与垂直于 x 轴的线相交(如下图所示)。
Scattered plot showing input-output data (above) and kernels at all inputs using a bandwidth of 10 (below)
Intersection of predictor variable, area = 50 with surrounding kernels
上面的星形标记显示了交叉点及其相应的内核值。内核值在 0 和 1 之间缩放，以将其用作权重。以下等式用于在 0 和 1 之间缩放内核值。
其中 wi 为输入的权重In为数据点总数。 x = 50 的输出 y 计算为所有观察到的 y 值的加权和，如下式所示。****
其中 y11 是面积= 11 的河流流量， w11 是相应的重量，等式中的其他项也是如此。
下表显示了从输入 x = 50 的内核值计算权重所涉及的步骤。表中的最后一列提供了最终输出，即 50 平方英里区域的计算河流流量。
同样，对于 x、 的所有值，权重如上表所述进行估算，并用于计算相应的 y 值。下表和下图显示了不同区域输入的预测河流流量值。
Computed river flow from kernel regression
带宽灵敏度
以上计算基于带宽值 10。内核带宽对预测的影响很大，如下图所示。
Kernel regression output for bandwidth value = 5
Kernel regression output for bandwidth value = 10
Kernel regression output for bandwidth value = 15
在为预测时，由于较窄的内核对训练数据集中的“【Xi】”的*【易】* 赋予较高的权重，因此较小的带宽值过拟合数据。低带宽会在输出中产生大量看起来不真实的变化，而高带宽值会使输出过于平滑，无法揭示输入和输出之间的真实关系。因此，为了达到偏差-方差的平衡，应该在核回归中优化带宽。******
核回归的 r 代码
*****#Kernel regression
data <- data.frame(Area = c(11,22,33,44,50,56,67,70,78,89,90,100), RiverFlow = c(2337,2750,2301,2500,1700,2100,1100,1750,1000,1642, 2000,1932))
x <- data$Area
y <- data$RiverFlow#function to calculate Gaussian kernel
gausinKernel <- function(x,b){
K <- (1/((sqrt(2*pi))))*exp(-0.5 *(x/b)^2)
return(K)
}b <- 10 #bandwidth
kdeEstimateyX <- seq(5,110,1)
ykernel <- NULL
for(xesti in kdeEstimateyX){
xx <- xesti - x
K <-gausinKernel(xx,b)
Ksum <- sum(K)
weight <- K/Ksum
yk <- sum(weight*y)
xkyk <- c(xesti,yk)
ykernel <- rbind(ykernel,xkyk)
}
plot(x,y,xlab = "Area", ylab = "Flow", col = 'blue', cex = 2)
lines(ykernel[,1],ykernel[,2], col = 'red', lwd = 2)*****
参考
R.蒂布拉尼和 l .乏色曼，非参数回归，统计机器学习(2015)——卡耐基梅隆大学讲稿
机器学习中的核心秘密。一
这个帖子不是关于深度学习的。但也可能是无妨的。这就是内核的力量。它们普遍适用于任何机器学习算法。为什么你会问？我将在这篇文章中尝试回答这个问题。
一般在机器学习中，我们要把相似的东西放在相似的地方。这条规则适用于所有的机器学习，无论是监督的、非监督的、分类的还是回归的。问题是，我们如何确切地确定什么是相似的？为了阐明这个问题，我们将从学习内核的基本基础开始，点积。
两个向量之间的点积是一件神奇的事情。我们可以肯定地说，它在某种意义上衡量了相似性。通常，在机器学习文献中，点积表示如下:
表示向量 x 和 x’之间的点积。注意，为了简洁起见，我省略了向量符号的箭头。这个符号是矢量分量乘积之和的简写:
巧合的是，向量的范数是与其自身的点积的平方根，表示为:
这当然不是全部。我们还知道余弦法则，即点积等于向量之间夹角的余弦乘以它们的范数(这很容易通过简单的三角学来证明):
谈论角度和范数的好处是，我们现在可以想象这个点积是什么意思。让我们画出这两个向量，它们之间的夹角为α:
所以如果我们用点积来衡量相似性。什么时候会达到最大值？意味着向量是最相似的。显然，当余弦等于 1 时，会发生这种情况，当角度为 0 度或弧度时会发生这种情况。如果向量各自的范数相同，那么显然我们说的是同一个向量！还不错。让我们把到目前为止学到的东西刻在石头上:
点积是向量之间相似性的度量。
现在你有希望理解为什么讨论点积是有用的了。
当然，点积作为相似性的度量，在问题中可能有用，也可能完全无用，这取决于您要解决的问题。因此，我们需要对输入空间进行某种变换，使点积作为相似性的度量变得实际有用。我们用ϕ.来表示这种转变现在，我们可以定义一个**核的含义，**映射空间中的点积:
因此，核的定义非常直接，它是映射空间中相似性的一种度量。事实是，数学家喜欢具体化。对于它们所处理的底层函数和空间，不应该有隐含的假设，因此函数分析的内核背后有相当多的理论，这需要另一篇或几篇文章来讨论。简而言之，我们需要明确说明我们希望ϕ:发挥什么样的作用
我们想要一个函数，它从定义域 X 映射到一个点积定义明确的空间，这意味着它是一个很好的相似性度量。
内核可以作为任何可以用点积(或范数)来定义的算法的一般化。使用核作为其主干的算法的最著名的例子是支持向量机和高斯过程，但是也有核用于神经网络的例子。
Photo by Annie Spratt on Unsplash
我们需要内核和映射函数ϕ的另一个原因是输入空间可能没有明确定义的点积。让我们简短地研究一下文档分析的例子，我们只是想根据主题得出两个文档之间的相似性，然后对它们进行聚类。在这种情况下，这两个文档之间的点积到底是多少？一种选择是获取文档字符的 ASCII 码，并将它们连接成一个巨大的向量——当然，这不是你在实践中会做的事情，但这是相当值得思考的。很高兴我们现在把文档定义为向量。但是问题仍然在于长度，即不同的文件有不同的长度。但是没什么大不了的，我们可以通过用 EOS 字符将较短的文档填充到一定的长度来解决这个问题。然后我们可以在这个高维空间里计算一个点积。但是，还有一个问题，这个点积的相关性，或者说，这个点积实际上意味着什么。显然，字符的微小变化都会改变点积。即使我们把一个词和它的同义词交换，它也会改变点积。这是您在按主题比较两个文档时想要避免的事情。
那么内核是如何发挥作用的呢？理想情况下，您会希望找到一个映射函数ϕ，该函数将您的输入空间映射到点积具有您想要的含义的特征空间。在文档比较的情况下，对于语义相似的文档，点积较高。换句话说，这种映射应该使分类器的工作更容易，因为数据变得更容易分离。
我们现在可以看看典型的 XOR 例子来理解这个概念。XOR 函数是一个二元函数，看起来像这样:
蓝色点被分类为 0，红色点被分类为 1。我们可以假设这是一个噪声异或，因为集群有一个大的传播。我们马上注意到一件事，数据不是线性可分的。也就是说，我们不能在红点和蓝点之间划一条线，将它们分开。
在这种情况下我们能做什么？我们可以应用一个特定的映射函数，使我们的工作容易得多。具体来说，让我们构造一个映射函数，该函数将对穿过红点簇的线周围的输入空间进行单侧反射。我们将围绕这条线来反映这条线下面的所有点。我们的映射函数会有以下结果:
映射后，我们的数据变得很好地线性分离，所以如果我们有一个模型试图适应一个分离的超平面(例如感知器)，这是一个理想的情况。显然，线性可分性是一件非常好的事情。但是为了建立有效的模型，我们不一定需要线性可分性，这意味着为了建立有效的模型，不是所有的映射函数都需要导致线性可分的数据。
人们经常混淆应用内核和应用映射函数的概念。核函数的输出是一个标量，是两点的相似性或不相似性的度量。映射函数的输出是一个向量，我们基于它来计算相似性。关于内核有趣的事情是，我们有时可以计算原始空间中映射的点积，而不需要显式地映射输入。这允许我们处理无限维映射！这是一件很难理解的事情，所以我将在以后的文章中讨论。
作为结束语，我想推荐 Smola 和 Schoelkopf 的书:用内核学习。这本书对核心机器及其理论背景进行了全面的论述。除此之外，请继续关注内核！
Photo by Eric Nopanen on Unsplash
直接相关的文章/推荐阅读:
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
