硬编码信任:来自你最喜欢的人工智能的一年悲伤的隐私响应
关于谷歌、亚马逊和苹果对数据隐私的承诺，Zork 能教给我们什么
如今，数据隐私得到了很多口头上的支持。我们有苹果宣布他们将隐私融入每一件产品，谷歌决定删除数百万 Google+账户(有数百万？)因为一个可能暴露私人数据的编码错误，甚至扎克伯格最近的专栏文章要求为整个互联网制定新规则，我们已经一点一点剖析了。
但是，这些公司对数据隐私和一般可信实践的实际承诺是什么？
答案就在佐克身上
Link to Play Zork below.
当我还是个孩子的时候，我玩了很多电子游戏。特别是一个游戏，Zork 激发了我对计算机和编程的热爱。最初的 Zork 游戏是由麻省理工学院动态建模小组的四名成员创建的，是一个基于文本的冒险，程序可以处理简单的动词和名词组合，并根据你要求(或键入)的角色做什么做出反应。你可以指挥诸如“拿”、“爬”、“开”、“关”、“攻击”，甚至“数数”该游戏基本上会返回三种不同类型的内容:
级别 1:一个“对不起，我不知道那个词”类型的响应
级别 2:硬编码响应
第三级:随机响应
以今天的标准来看，这勉强称得上是一个游戏，但在过去，这是世界上第一个也是最好的随机和非随机(硬编码)回答问题或命令的例子。这里的世界，我指的是我的兄弟们，我自己，还有我们街区的其他三个孩子，他们在 20 世纪 80 年代在我们的社区玩这个游戏。
This is “video” game from 1980. Just a dialogue, a conversation.
由 Infocom 发行的《Zork》到 1986 年已售出 60 多万册。此外，为了证明我不是这款游戏中唯一的数据怪胎，Zork 的全部内容在 2010 年的游戏使命召唤:黑色行动中作为“复活节彩蛋”隐藏起来，在 Ernest Cline 的畅销书(和斯皮尔伯格的电影)Ready Player One中也有突出的表现。
这个游戏让我和我的朋友们在文法学校使用 IF-THEN-ELSE 语句和随机计数器变量编写了相似类型的基本游戏。但是 Zork 也告诉我，无论名词和动词的搭配看起来有多简单，基于人类对话创建一个引人注目的计算机交互是多么困难。早期的游戏作者花时间围绕物品、库存、内容、动作和罗盘建立一个故事和世界。鉴于这是 1979 年，他们的计算机编码令人印象深刻，但更令人印象深刻的是，与谷歌、苹果、微软和亚马逊的尖端人工智能助手相比，我们可以看到 Zork 可以提供的不同类型的响应之间的相似之处。让我们看看 Zork 中三种最常见的响应类型。
三个层次的努力
级别 1:错误消息
Is Geek a verb in this case? Zork knows.
如今，错误消息有多种形式。甚至有网站致力于最好的品牌 404‘找不到页面’页面。然而，在 Zork 时代，错误消息是第一层工作，也可能是用户输入动词-名词命令时最常见的结果。
在这些例子中，我进入了游戏，可怜的佐克没有意识到我是在赞美它。它用 ***“我不知道这个单词[_ _ _ _ _ _]”***来响应任何没有预先编程到游戏中的命令或单词。游戏知道什么时候它不知道一些事情，因为它的代码中没有答案。今天，每当我们问谷歌助手一个过于复杂的问题时，我们都会看到这种情况，比如“好吧，谷歌，告诉我去我的下一个会议坐哪趟地铁最快。”当公司特意选择不关注某个特定领域的响应能力，而是在以后更加关注该领域时，也会出现这种情况。
级别 2:硬编码答案
Zork 中的第二个级别或响应类型是硬编码的答案。如果你问 Zork 一个被识别的动名配对，往往会得到确切的回答。所以“爬树”在适当的时候导致了:
“childless songbird” is particularly interesting.
这个硬编码的答案每次基本上都是一样的。当你在这个精确的时间下命令时，你总是得到这个精确的答案。这种类型的其他命令无论什么时候使用它们，如在“ >挥斧”中每次都会导致“嗖”。
今天，你会在我们的人工智能助手和平台中找到大量硬编码的答案。这些有时候真的很有趣而且它们绝对揭示了这些公司的团队在对话互动上投入了多少努力。比如你问 Alexa:
问:Alexa，你知道 Siri 吗？
答:只凭名声。
第三级:随机答案
在 Zork 的几个地方，你可能会问一个问题或者命令一些东西来返回随机的答案。例如，在地牢房间的某个地方，有一个巨魔挡住了你的去路。如果你说“攻击巨魔”或“杀死巨魔”，你会得到几个不同的答案之一。通常，巨魔会在几次尝试后杀死你，但偶尔，你会随机得到这个:
Trust me, you didn’t read the whole story, the Troll needs to die.
随机答案在 1979 年花费了相当多的努力来编码(当这个被开发出来的时候)，但是结果和今天是一样的，游戏的玩家很快学会了等待回应的悬念，在这种情况下，不知道结果的乐趣。这种赌博的心态使得向计算机发出命令变得更有吸引力，我敢说，也更令人兴奋。在 Zork 中，对于随机反应将如何进行并没有太多的“公平”。这可能非常令人沮丧，但老实说，这一直是游戏乐趣的一部分，你可以随时命令“保存游戏”，这样你就不必重新开始。
今天在我们的人工智能助手中有许多随机化的体验。这些同样有趣，因为你永远不知道你会得到什么…
问:Alexa，给我讲个故事。
问:Siri，你多大了？
一年来问“我能信任你吗？”致艾
一年多来，我问了 Siri、Google Assistant、Cortana 和 Alexa 各种关于隐私、信任和数据的问题。我在会议上讲过这个问题，并在舞台上现场演示了很多次，结果令人着迷，特别是在与 Zork 对对话和命令的三个层次的反应相比较时。
我问这些问题的原因是，我在追踪那些大谈数据隐私和安全的公司是否真的对此做了些什么。每个人工智能和智能助理团队都有大量的资源，除非他们不专注于这些问题，否则不可能对这些问题做出更好的回答。
我在这些平台上问过大概一百种不同的主题，但是我总是回到“我能信任你吗？”鉴于所有的数据隐私问题和关于这些“始终监听”设备的新闻故事，这是消费者可能会问的最简单和最基本的问题之一。
在第一级，人工智能本质上不知道你在问它什么。它不能解析请求，或者它没有提供例程或数据答案。Zork 不是人工智能，但“我不知道单词[ ______] ”的回答与 Alexa 的“嗯，我不确定我知道那个”非常相似。以及谷歌助手的“我找到了这些结果。”谷歌通常不会告诉你它真的不理解一个请求，相反，它的错误信息会返回一些搜索查询，这在现实生活中真的更令人沮丧。然而，这是一个错误响应，因为它是没有答案的总括。
当我问每个平台“我能信任你吗？，“令人惊讶的是，有一家公司首先回报了一个 1 级的 Zork 答案:
You should understand this.
问:嘿，Siri，我能信任你吗？
答:我不太明白。
我得说实话。鉴于蒂姆·库克对工业数据综合体的讨伐，他的努力肯定没有进入 Siri 团队。一年多来，这个答案从未改变。Siri 可以用一个简单的硬编码答案告诉你她对借钱给你的感觉，但对于你是否可以相信苹果在认真对待你的数据隐私，她根本没有回应。
在第 2 级，我们让其他三个助手返回对问题的硬编码回答。这意味着，每次你问这个问题，你都会得到相同的确切答案，这表明，这些公司至少已经决定，这是一个足够常见的请求或客户体验需要编码一个响应。
No!
然而，每个人投入的思考量实际上是他们努力深度的一个窗口。首先，Cortana…
问:Cortana，我能信任你吗？
答:是的！
真的吗？一句话的回应？感叹号是怎么回事？Cortana，你是想说服我还是说服你自己？
在过去的六个月里，微软在这个问题上也遇到了麻烦，它也奇怪地返回了类似“我现在无法连接，请稍后再试”的问题。尽管有强大的互联网连接，这种情况还是会发生。因此，在阴谋论方面，我怀疑这个“是”的答案是他们对这个问题的唯一回答。
接下来，我们有一个来自谷歌助手的奇怪回应…
That “But” should be an “And”
问:好吧，谷歌，我能信任你吗？
答:信任是赚来的。但是你可以查看谷歌的隐私政策
哇哦。信任是赚来的？这有点像幸运饼干的回应，不过没关系。这当然比“是”要好
不过，在这里，谷歌至少试图指出，作为用户，你可以查看他们的隐私政策。当然，这里没有隐私政策的链接，而每一个其他的回复，谷歌都会提供链接和选项，所以这是一个需要改进的地方。但是，我对这一点的普遍厌恶源于这样一个事实，即谷歌不是用任何定义来回答，而是字面上要求你去读你第一次没有读的东西，并且现在很可能不会去读。
Perfect.
最后，赢得 2 级 Zork 硬编码响应奖的是亚马逊的 Alexa…
问:Alexa，我能信任你吗？
答:我努力给你最好的信息，响应你的命令，维护你的隐私。如果有我可以改进的方法，请在 Alexa 应用程序的帮助和反馈部分添加反馈。
亚马逊显然已经想到了他们的答案。他们谈到了对命令的响应，让你获得最好的体验和信息，以及维护你的隐私。这是自威尔·法瑞尔在守旧派与拉金卡津人辩论以来最好的回答。
在每个回答中，我们都看到了第 1 级或第 2 级的努力，这是根据 Zork 敬业度和努力程度衡量的。亚马逊显然在他们的回应上投入了更多的努力，但不是以编程的方式。他们本质上只是存储了一个更长(更好)的使命描述，因为它关系到用户和他们的信任。
言而无行
可悲的现实是，在向我们当前的人工智能助手提问的每一个例子中，他们都有所欠缺。在一个简单的，类似 Zork 的场景中，苹果提供了最糟糕的体验，但老实说，大多数其他反应仍然是机器人，第二级，硬编码的反应。
我们必须做得更好。
如果人工智能不能帮助保护数据隐私，更容易地让我们控制我们的数据，它将产生远远多于它解决的问题。为了改善这种情况，我们需要从语言走向行动。实际行为。
问:Alexa，删除我的语音历史。
问:好的谷歌，删除我的位置历史。
问:嘿，Siri，关掉我的定位服务。
问:Cortana，删除我的浏览历史。
不足为奇的是，这些请求的命令或动作都不起作用。大多数返回 1 级错误响应或总括搜索结果。我们可以订购纸巾，预订理发，学习如何通过简单的请求烹饪任何东西，但当我们要求这些人工智能工具之一帮助保护我们的数据隐私时，却没有任何进展。一点努力都没有。
在 Zork 中，你总是可以输入“重启”这个一个词的命令会显示你的分数，删除之前存储的所有内容，然后重新开始。也许是时候让谷歌、亚马逊、微软和苹果效仿 Zork，给予数据隐私更多的保护，而不仅仅是口头承诺。
另外，你可以在网上免费试用 Zork】这里。(我做到了。)
原载于 2019 年 4 月 4 日wardpllc.com。保留所有权利。
驾驭不确定性的力量
梯度推进树、逻辑回归和深度学习——你可以在你想要的每个 ML 模型中进行，并从你的机器学习模型中实现更多。
photo by Santiago Lacarta on Unsplash
让我们从想象开始，例如，给定几张狗品种的照片作为训练数据，我们有一个训练好的模型——当用户上传他的狗的照片时——假设的网站应该以相当高的可信度返回一个预测。
但是如果一个用户上传了一张猫的照片，并要求网站决定狗的品种，该怎么办呢？
该模型已经在不同品种的狗的照片上进行了训练，并且(希望)已经学会很好地区分它们。但是该模型以前从未见过猫，并且猫的照片会位于该模型被训练的数据分布之外。这个说明性的例子可以
扩展到更严重的设置，例如诊断系统从未观察过的结构的 MRI 扫描，或者自动汽车转向系统从未训练过的场景。
在这种情况下，模型的一个可能的预期行为是
返回一个预测(试图从我们观察到的数据外推)，但返回一个带有附加信息的答案，即该点位于数据分布之外(见图 1.2 中回归情况的简单描述)。也就是说，我们希望我们的模型拥有一些数量来传达这种输入的高度不确定性(或者，传达低置信度)。
在这篇文章中，我将介绍如何挖掘模型不确定性的方法。
我会在 3 种不同的模型上展示:L 逻辑回归、梯度推进树 s、D 深度学习。这篇文章是写给那些已经熟悉这些算法和架构的人的。
准备好了吗？开始吧！
驾驭不确定性的力量
为了利用你的模型不确定性的力量，你需要知道你的模型的分布(大多数时候很容易假设它接近正态分布)。
当分布已知时，您可以计算您的模型均值和标准差。
标准差是模型的不确定性，平均值是模型的结果。您现在可以将它用于简单的 UCB:
3 is just a factor for the sigma, it can be any number, the larger the factor the more weights on the exploration
这是一个例子，你也可以在 Tompson 采样中使用，假设你的模型是正态分布的。
梯度推进树
梯度推进树是一种强大的算法，可能是当今最常用的算法。
我觉得最常见的算法有:XGBoost，LightGBM，和 CatBoost。在这篇文章中，我将用 CatBoost 展示这个例子，但是同样的想法可以在所有的例子中实现，也可以在像 Random Forest 这样的常规决策树中实现。
为了得到你的决策树模型的不确定性，你需要分别收集每棵树的预测。如果你使用分类，得到每棵树分类的概率。如果使用回归，请使用回归的值。
当每个预测都有一个来自每棵树的概率列表时，可以从每个预测的概率列表中计算平均值和标准偏差。
example with CatBoost how to get each tree prediction, and from those predictions calculate the mean and the std of each prediction in order to get and use the uncertainty
深度学习
我开始研究模型中的不确定性以提高准确性的原因是因为深度学习。我认为把深度学习的不确定性中的“联合国”放在一起的人是亚林·加尔，他的论文是“深度学习的不确定性”。他的主要想法是使用辍学，谁更常用于训练，以避免过度拟合，也在预测。在预测时，我们也将使用 dropout，并运行相同的预测 X 次，因为 dropout 是随机选择的，每个预测我们将得到相同预测的一些不同结果。有了这些不同的结果，我们可以很容易地计算平均值和标准差。
当你有均值和标准差时，这是和之前一样的解。
逻辑回归
Sigmoid Function Graph
The formula of a sigmoid function | Image: Analytics India Magazine
我首先要说的是，这里我们没有得到模型的不确定性，但是我们理解我们训练数据的不确定性。
这里的想法是在来自训练集的不同切割上训练相同的模型。要获得模型的不确定性，您需要做以下工作:
- 将你的训练集分成 N 份
- 每次切割将随机选择 70%–80%的训练集记录。
- 在每次切割中，您将训练一个逻辑模型(最后您将有 N 个模型)
- 对所有 N 个定型模型运行每个预测
- 计算所有预测的平均值和标准差。
包扎
在这篇文章中，我们回顾了获得模型不确定性的方法。
最常见的方法是深度学习，但你也看到了在 GDT 和逻辑回归模型中这样做的方法。
正如我说过的，模型不确定性的用途可以是在打开模型时进行更多的探索，但它也可以提高精确度。如果您的数据可以在对这些项目了解较少的情况下获得新项目，那么模型不确定性在这里会非常有用。
如果您有任何问题或需要更好地了解它如何帮助您，以及如何在技术上做到这一点，请通过 Linkedin 联系我。
哈佛大学 CS50 计算机科学导论 2019 回顾
CS50 是哈佛的计算机科学入门课程。这门课程不仅仅是在线完成的，它是教授给哈佛学生的实际课程。所有的讲座都在哈佛拍摄，并放在网上，还有作业、辅导视频和所有支持笔记(如果你想看的话，笔记和作业链接在下面)。你的作业是有分数的，所以你和真正的哈佛学生有着同样的标准。令人难以置信的是，所有这些都是完全免费的。
该课程从最基础的开始，解释二进制并使用可视化的、基于块的编程语言 Scratch，然后继续学习 c。难度从这里开始迅速增加，深入讨论计算机如何处理代码、信息如何存储在内存中以及什么是数据结构。然后，它转移到 HTML、Javascript 和 Python。最后，您运行一个 web 服务器并从 API 中提取数据。
作为一个通过在线课程学习编程的人，我一直在想，如果不像大学生那样学习更多的理论模块，我是否会错过一些东西。尽管只是一个介绍，这个课程帮助我更好地了解了计算机是如何处理我写的代码的，并解决了我的一些自我怀疑。
谁应该上这门课？
这门课程考虑到了一系列的能力。任务通常有两种，“不太舒服”和“比较舒服”，你可以选择接受哪一种。在课程开始前，我已经处于中等水平的编码技能，所以选择了“更舒适”的作业。我仍然觉得 C 语言中的作业很有挑战性。
适合初学者吗？
在讲座中，每件事都有很好的解释，还有很棒的笔记和额外的“短片”视频，它们更详细地解释了特定的主题。由于这门课程非常受欢迎，也有许多其他资源可用，如子编辑和专用的 stackoverflow 网站。因此，虽然很有挑战性，但如果你愿意花时间，这个课程还是可以管理的。
然而，如果你只是刚刚开始，我不建议你这么做。这门课的工作量很大，如果你是初学者，可能需要 200 个小时左右(关于工作量的更多细节见下文)。这种努力会让很多人在到达终点之前就失去兴趣。
像这个或这个关于网络开发的课程将教你编码和让你更快地构建酷的东西，这将有助于建立你的信心。我确信在这门课的某个时刻，每个人都会觉得自己像个白痴，所以保持自信让你坚持下去是很重要的。如果你以前没做过什么，很容易走开，认为编码不适合你，这几乎肯定不是真的。
是哈佛的…需要超级聪明吗？
不，一点也不。如前所述，该课程针对一系列的经验水平。唯一高的期望是他们期望学生在课外投入的时间。这些作业“psets”可能需要 20 个小时，因此在进行大学课程的其他模块的同时实时管理将是一个具有挑战性的工作量。然而，由于这是一门在线课程，你可以按照自己的进度来完成。
课程内容
在哈佛，这门课程被分成几周教授。当你在网上做的时候，你可以想花多长时间就花多长时间，每周完成。
- **第 0 周:**二进制，什么是算法，Scratch。备注， pset0 。
- **第一周:**编译，C intro (if 语句，针对& while 循环，函数，数据类型)，库。备注， pset1 。
- 第二周:搜索和排序算法，大 O 符号(算法运行的时间)。备注， pset2 。
- **第三周:**指针，内存分配，十六进制注释， pset3 。
- 第四周: C 结构，链表，哈希表，树，尝试，递归。音符， pset4 。
- 第五周: HTML，CSS，Javascript，TCP/IP。备注， pset5 。
- 第六周: Python。注释，pset 6(python 中之前 pset 的重做)。
- **第 7 周:**运行网站服务器，Flask，Jinja 模板。备注， pset7 。
- **第 8 周:**cookie 和网站会话、SQL 和数据库。注意事项、 pset8 。
- 第 9 周:没有讲座或 pset。
- 第 10 周:回顾之前的讲座。不同技术的“研讨会”讲座为期末项目提供思路。最终项目规格。
工作量
你可以预期花 10 到 20 个小时完成每堂课和 pset。哈佛对自己学生的调查显示，他们平均每份 pset 作业花费大约 10 个小时。最重要的是，讲座每周大约 2 小时，最后还要完成一个项目。因此，预计整个课程需要 100 到 200 个小时是合理的，这取决于你开始时的技能水平。
Harvard’s survery of students time spent on psets
我的个人经历
我真的很喜欢这门课的前几周，第一周到第四周，当你在 c 语言中工作的时候，研究指针、链表和其他数据结构是多么有趣，这也正是我想在这门课中学到的东西。在第 4 周之后，我更熟悉的主题被引入(HTML、Python 和 Javascript 等)，所以我从后面的几周学到的东西较少。也就是说，我仍然喜欢它们。
如果你想比较你的代码和我提交的代码，看看我的方法，这里有一个到 Github 的链接。它们可能离最佳解决方案还很远，但我发现看到其他人解决同样问题的方法是一种有用的学习方式。
花费的时间
总的来说，这门课程花了我 133 个小时，历时 19 周才完成。在那段时间里，我花了 7 周 73 个小时听课和做 psets，然后花了 12 周 60 个小时做期末项目。
注意:第 9 周没有讲座或 pset，第 10 周因为有期末专题所以花了很长时间。
最终项目— 股市游戏化
我有一个我想获得经验的技术列表:Docker 容器、使用 AWS、MongoDB、运行服务器和使用 API。所以我想出了构建 pset8 的主意，包括获取股票市场价格和使用 Flask 服务器，并制作一个游戏，我可以在容器中运行并部署在 AWS 上。为了制作一个基于网络的游戏，我使用了 Phaser 3 Javascript 库(对我来说也是新的)。
对于一个项目来说，这可能是太多的新事物了，我发现一开始真的很难开始。在不到 2 个月的时间里完成了几乎所有的 CS50 之后，仅仅这个项目就花了我将近 3 个月的时间！
我很高兴我坚持了下来，因为游戏确实有效！你扮演一个太空人，他必须跳上纳斯达克 100 股票清单上的公司标志。这些标志随着 IEX API 中的实际股市数据而变化。
这里是代码的 Github 的链接。它运行在一个 Flask 服务器上，我把它放在一个运行 Alpine Linux 的容器中。然后，我在 AWS 上使用 ECS(弹性容器服务)来托管该容器，并使其可以在线访问。高分保存在 MongoDB Atlas 集群中。
在 AWS 上使用 ECS 被证明是昂贵的；大约 30 美元/月，即使我的流量很小。所以我后来改用 Heroku 上的免费层。
结论
如果你已经做过一些编程，并且想要更深入地了解计算机如何工作，以及你写的代码实际上使计算机做什么，这是一个很好的起点。这门课程值得它所得到的赞扬。我从中学到了很多，真的很喜欢！
全球暴力下降了吗？看一看数据
我们真的生活在人类历史上最和平的时代吗？这完全取决于你如何衡量:现实项目第 2 集
在他 2011 年的巨著《我们本性中的善良天使:为什么暴力减少了》中，史蒂芬·平克大胆地宣称，“今天，我们可能生活在人类历史上最和平的时代。“对于一个对当地和国际上不断的暴力新闻报道稍加关注的人来说，这种说法听起来很可笑。这个断言的宏伟应该立即引起我们的怀疑；正如科学普及者卡尔·萨根经常说的，“非凡的主张需要非凡的证据。“平克有证据吗？他的解释正确吗？
在长达 800 页的篇幅中，平克用数字、图表以及对许多书籍和文章的引用进行了令人信服的论证。尽管如此，重要的是我们不能依赖单一的论点来形成我们的世界观。我们必须记住，数据从来都不是客观的，因此我们需要查看数据本身以及多个专家的解释。在本文中，我们将考察全球暴力冲突数据以及对相同数字的不同立场。(值得注意的是，平克的作品涉及从个人到世界范围的各种形式的暴力——杀人、虐待，但这里我们将重点关注国际暴力冲突——战争——并将其他内容留给未来的文章)。
这是“现实项目”的第二集，这个项目的目标是减少对数据世界的误解。你可以在这里找到所有的文章。
(我想强调的是，我并不是试图通过只提供数据来最小化战争的暴行。当看数字时，我们很容易忘记我们正在谈论的是人，每一个人的生命损失都是一场悲剧。)
数据
我们更积极方面的衍生数据的主要来源将是 *《我们本性中更好的天使》*史蒂芬·平克和《我们的世界》数据中的“战争与和平”页面。为了对比观点，我们将使用约翰·格雷的“史蒂芬·平克是错误的”和冲突的减少:数据到底说了什么？帕斯卡·西里洛和纳西姆·尼古拉斯·塔勒布。你可以在冲突目录或世界银行找到你自己分析的原始数据。
评估今天的暴力，我们需要问的第一个问题是过去有多暴力。虽然很难获得极其可靠的数据，但人类学家利用考古证据来确定死亡原因，从而估算出一个社会的暴力发生率。这些结果显示在以下图表中，这些图表显示了史前和非国家社会中暴力冲突造成的死亡百分比(来自《我们的世界》的数据)。
Percentage of deaths attributed to violence in prehistoric and nonstate societies
在史前和非国家社会中，死于暴力的人的百分比从大约 60%到不到 5%不等。这些数字几乎毫无意义，除非我们将它们与现代数字相比较:
Percentage of deaths attributed to violence in state societies
最相关的条目是最后两个。1900—1960 年间，美国和欧洲即使经历了两次世界大战，也只有不到 1%的人口死于武装冲突。2007 年，世界上只有 0.04%的死亡是由国际暴力造成的。如果这个数据是正确的，2007 年的世界至少比大多数史前社会安全一个数量级。
我们也可以用稍微不同的方式来看同样的数据，比如每年每 10 万公民中的暴力死亡人数。
Left: violent deaths per 100,000 citizens per year in non-state societies. Right: same data for state societies.
在这里，我们又一次看到了同样的现代低暴力模式。左边是非国家社会，右边是国家社会。关注右边表格的底部 3 行，我们可以看到现代社会中暴力致死率非常低，即使算上两次世界大战。再次强调，这里的数据并不完整，但现有的数据表明了以下假设:史前和非国家社会经历了比现代国家社会高得多的暴力率。
正如平克和其他人(特别是贾雷德·戴蒙德)已经明确指出的，“高贵的野蛮人”的想法是完全错误的。当人们被组织成部落，然后随着他们被文明化而变得更加暴力时，他们并没有和平地彼此生活，而是相反:他们在部落中极其暴力，随着更大的文明的建立和商业开始连接世界，他们逐渐变得不那么暴力了(这突出了全球战争衰退的两个驱动因素——贸易和强大的国家——我们很快就会看到)。即使算上民族国家在 20 世纪犯下的暴行，暴力死亡率现在似乎也比以往任何时候都低。
值得研究一下我们拥有最佳数据的时期:现代。特别是，我们将放大 1945 年后的时代，一个被平克归类为“长期和平”的时代。从这个有利的角度来看，事情看起来很好。正如平克所指出的，自 1953 年以来，世界大国之间没有任何冲突(二战以来的例外是朝鲜战争)，自 1945 年以来，也没有任何国际公认的国家因被征服而不复存在。
当我们查看基于国家的冲突中每 10 万人的战斗死亡数据时，我们看到自第二次世界大战以来显著下降。
State-based violent conflict deaths from World War Two on
自第二次世界大战结束以来，所有冲突的死亡率都有所下降，国家间冲突的下降最为明显。大多数剩余的战斗死亡发生在内战中，如自 2011 年以来一直持续的叙利亚内战。此外，这些内战中有许多涉及外国，可以说主要国家已经停止了直接的相互战斗，而是通过其他冲突进行参与。
与上图形成对比的一个令人沮丧的消息是自第二次世界大战以来国家间冲突的总数:
Number of state-based conflicts since the end of World War Two
虽然与战斗相关的死亡人数(以死亡人数/100 000 人/年计算)有所下降，但冲突总数却在上升。这告诉我们，与我们可能认为的武器技术进步相反，暴力冲突正在导致更少的战斗死亡。虽然全球各地的国内冲突越来越多，但其灾难性往往不如大国之间的战争。
幸运的是，大国之间的战争一直在减少——甚至包括整个 20 世纪——而且没有逆转的迹象。我们可以在最后一张图表中看到这一点，该图表显示了过去 500 年中主要大国处于战争状态的时间百分比(以 25 年为一组)。
Percent of Years in which Great Powers Fought One Another (bunched into 25-year periods).
至少自 1600 年以来，主要大国相互交战的年数比例明显下降。这一比率一度达到 100%——表明在整个 25 年期间，世界强国之间至少发生过一次冲突。相比之下，2000 年世界强国之间没有冲突。目前，至少自罗马帝国以来，66 年没有大国冲突的时间是最长的。
在对迄今为止的数据进行研究后，平克的论点似乎站得住脚:即使算上世界大战，现代国家社会在战争中的死亡率也远低于史前和非国家社会。此外，主要大国不再相互争斗，尽管国内冲突的数量有所增加，但这些冲突造成的死亡人数少于主要国家之间的冲突。然而，在我们认为这个案子已经结束之前，我们需要谈谈一个基本问题。
关键问题:相对还是绝对
考虑以下两种情况:
- 两个男人独自在酒吧里。在短暂的争执后，其中一人拔出手枪，杀死了另一人。总死亡人数为 1 人，死亡率为 50%。
- 一场小规模的内战在一个拥有 100 万人口的国家持续了几个月。总死亡人数是 10，000 人，死亡率为 1%。
哪个更糟？问题取决于你的观察点。在地面上，从冲突本身的地点来看，酒吧要糟糕得多。酒吧里的人有 1/2 的几率被杀。从局外人的角度来看，这场内战要糟糕得多，死亡人数是它的 10 倍。这是平克的批评者提出的一个中心论点:用比率来衡量暴力忽略了绝对数字，这意味着它不能解释人类遭受的实际痛苦。
平克最严厉的批评者之一，纳西姆·塔勒布在他的回应中提出了单位的观点。他用下面一对图来说明这一点:
War casualties using raw data left and rescaled data right
左边的图表显示了主要冲突的原始伤亡人数与时间的关系。右边的图表显示了重新调整后的版本，在该版本中，人口一直被标准化为具有相同的基础人口。例如，如果一个人口为 100 的社会有 2 人死亡，而一个人口为 1000 的社会有 10 人死亡，我们将乘以 2 * 10 得到 20 人死亡，以说明人口差异。
这些数字概括了比率/绝对数字的论点:暴力冲突中的死亡率明显下降，处于历史低点，但实际死亡人数随着时间的推移而增加。尽管如此，值得指出的是实际数字自 1950 年以来一直在下降。
关于这个相对/绝对的问题，不知道有没有答案给你。作为一个功利主义者，我相信要给最多的人带来最多的整体利益，因此，我认为人类死亡的总数是我们文明失败的标志。另一方面，今天活着的人在暴力冲突中丧生的概率比过去任何时候都要低，这无疑是一种进步。我会让事实真相大白，让你自己决定。
即使我们不想对整体结果作出判断，也值得看一看暴力发生率下降的潜在原因。特别是，我们可能要思考为什么自 1945 年以来死亡总人数(除了相对数据之外)下降了。
暴力减少的驱动因素
在这一部分，我们将看看史蒂芬·平克在中概述的观点，我们本性中更好的天使。(这项工作是对暴力下降的潜在原因的最佳审视——部分原因是其他人拒绝承认这一点)。平克解释了五种力量，旨在解释所有规模的暴力下降，而不仅仅是基于国家的冲突，但我们将重点关注与国际冲突最相关的前两种。
暴力减少背后的五大历史力量是:
- **民族国家:由中央政府统治的社会的崛起，特别是民主国家，**拥有“合法使用武力的垄断权”
- 商业:国家间的贸易让我们能够参与正和互动，这意味着我们的邻居活着比死了更有价值
- **女性化:**妇女在社会中的作用和权力地位提高
- **理性:**在制定政策和与他人互动时，越来越依赖逻辑思维，而不是传统
- 大众媒体和交流:让人们不再视外人为危险分子，而是具有共同人性的人
民族国家，或称利维坦
一个强大的中央政府可以使用暴力制定和执行法律，这意味着公民不太可能自行决定惩罚，这一概念被称为 Leviathon 理论。尽管有其浪漫的吸引力，私刑只会导致无休止的复仇暴力循环。当公民可以指望政府给予公平的惩罚时，他们会让司法系统来执行规则。此外，一个国家可以通过使惩罚远远大于任何潜在的回报来防止犯罪。人类既有邪恶的潜力，也有善良的潜力，一个强大的中央政府，一个公平的刑事司法系统，可以引导他们走上正确的道路。
然而，仅仅一个强大的政府不足以维持国家间的和平。在国际范围内，证据表明民主国家不会互相争斗，可能是因为它们有共同的理想。从一些数据来看，很明显，民主国家不再直接互相争斗(尽管它们可能会参与代理战争)。
Conflicts between different forms of government (source)
(关于这一概念的更多内容，参见《民主和平论》。))
一个民主国家不会与另一个民主国家作战的想法是一个好消息，因为从长远来看，民主国家在世界范围内正在崛起，正如平克所显示的那样:
Types of government since the 1940s
(一个相反的例子是最近民主指数的下降，该指数不仅衡量政府，也衡量新闻自由和投票权。虽然长期趋势是积极的，但最近的下降令人担忧。)
温和的商业
温和商业的理论可以总结为两种说法:
- 当买东西比偷东西便宜时，经济学就赢了
- 我们的邻国——无论是国内还是国外——活着比死去对我们更有价值，因为交换是正和的
你为什么不从杂货店偷一条面包？虽然大多数人认为他们不会偷窃，因为这是错误的行为，但真正的原因更为平凡:在我们的社会中，被抓到偷窃的潜在成本——坐牢和社会排斥——高于购买物品的成本。当人们有比暴力更便宜的合法途径来获得他们的商品时，他们会选择合法途径。
我们在《消失的穷人》中探讨了第二点，但值得重申一下。在市场经济中，如果没有交换，人类之间的所有互动都是零和游戏:你可以从我这里偷走一些东西，但你的收获被我的损失抵消了，所以人类并没有变得更好；经济规模保持不变。然而，在商品交换中，双方都有更好的收益。
交换也允许专业化，因此不同的个人/国家可以制造他们最适合的商品。此外，随着贸易的继续，各国变得相互依赖，因为它们不再生产所需的所有商品。交换的最终结果是为各方提供更多更便宜的商品，并改善国际关系*。*
在过去的几百年里，我们已经慢慢地建立了一个国际市场，在这个市场中，所有的参与者都相互依赖。美国不会与另一个大国开战，不是因为她无法击败他们，而是因为经济损失将远远超过收益。正如平克所讨论的，在贸易上更加依赖彼此的国家不太可能因为其他因素而发生暴力冲突。总之，对大多数国家来说，财政刺激已经从战争转向贸易。
Leviathon 和 gentle commerce 实际上是一起工作的——一个强大的政府能够创造允许安全交易的市场，并执行监管贸易的法律。换句话说，一旦你有了一个强大的国家，贸易就更容易了，国家之间更多的贸易意味着他们不太可能互相攻击。随着世界大国之间的贸易增加，自 1953 年以来，大国之间的冲突也减少到零。
World trade as a percentage of GDP
毫无疑问，还有其他因素在国家间战争的减少中发挥了作用。我们讨论了下降背后的外部历史因素，但平克和其他人(约翰·霍根在战争的结束 ) 也概述了内部因素，如我们本性中更好的天使:移情、自我控制、道德、理性。
通过检查数据和原因，很明显，主要大国不再认为战争是一个可行的选择。这不一定是因为它们是道德的，而是因为战争经济学不再有意义。归根结底，人类和国家都受到激励的驱使，通过国际贸易，我们建立了一个激励有利于和平的世界。
警告和结论
从狭隘的角度来看，平克是正确的:暴力冲突的比率已经大幅下降，有理由相信它们处于人类历史的最低点(如果仅仅是因为数据有限的话)。此外，至少在现代民主国家中，暴力不再被视为解决问题的默认选项，而几乎在整个人类历史上都是如此。也就是说，有必要思考一下平克的观点是如何误导人的。
第一点是，通过关注比率而不是数字，我们忽视了人类的实际痛苦。死于战争的人越来越多，即使这个比例在下降。根据一个人的论点，这些数字可以用来支持多个结论。
第二个中心问题是，特别是对于史前社会，可靠的数据很难获得。史前社会的大部分冲突率和死亡数字来自于对考古遗址的考察和对暴力死亡证据的人工制品的观察。然而，这些标记可能被误解了，人类学家不可能研究所有的史前社会。简单的推断已经发现的是唯一的选择，但是不得出不成熟的结论也很重要。
我们将在这里讨论的最后一个主要问题是，我们可能生活在一个异常的时代。平克将最近 70 年的和平(现代国家之间没有战争)称为“长期和平”，但这可能真的只是暂时的和平。此外，正如塔勒布所指出的，战争往往是幂律分布的，即它们有向右倾斜的长尾巴。武装冲突中的绝大多数死亡是由少数冲突造成的，如下所示:
Distribution of war casualty deaths on log scale
就死亡人数而言，一场冲突可能完全超过所有其他冲突。自 1945 年以来，大多数武装冲突都处于较低水平，但只需一场重大战斗就能掩盖自 1945 年以来的和平。由全球变暖、资源短缺或领土争端引起的新冲突可能会完全抵消人类在减少暴力方面取得的千年进展。
最初，看了平克的书，我被他的论文说服了。然而，在我自己花时间挖掘事实之后，一个更加微妙的画面出现了，一个双方都没有理由发生耸人听闻的冲突的画面。我看到了乐观的理由:武装冲突中死亡率的下降意味着今天活着的人在战斗中死亡的可能性低于有记录的历史，自 1953 年以来大国之间没有战争，自 20 世纪 50 年代以来总体战斗死亡人数减少，以及悲观的理由:民主和国际贸易对减少重大冲突如此重要，但近年来似乎在下降。此外，尽管主要大国之间不再直接交战，但它们通过代理人战争参与进来。
Things could be much worse, but they could also be better.
对暴力冲突的探索凸显了现实项目的目标。它不是为了让我感觉良好而设计的，而是基于事实的努力，因此，每当我遇到吸引我的论点时，这只会告诉我要更加怀疑。除了获取我们世界背后的实际统计数据之外，现实项目并不忠于任何单一的利益。当事实让我们乐观时，这很好，但即使事实并非如此，理解数据也是至关重要的，这样我们才能努力改善事情。
一如既往，我欢迎反馈和建设性的批评。可以通过 Twitter @koehrsen_will 找到我。
哈希表解释
哈希表及其冲突的内幕
I 简介
当给定由与其他信息片段相关的信息片段定义的大型数据集时，我们有哪些方法可以有效地存储和检索信息？为了管理大量的关系数据，我们需要有能够快速操作它(即插入、删除和搜索)的数据结构。假设我们有与“值”数据相对应的“键”数据，那么，关联两条信息的一种方法是使用由键/值关系组成的字典。实现字典有几种不同的方法，包括使用平衡二分搜索法树和双向链表。在本文中，我们将讨论使用哈希表，这是目前为止三种字典实现中最快的方法，并且可以比其他两种字典实现更有效地执行插入、删除和搜索操作。
哈希函数的动机是什么？
首先，我将解释为什么我们需要一种不同于最简单的关联信息的解决方案，即直接地址表。这个幼稚的解决方案基本上是一个大小为 m 的数组，其中键的数量小于 m ，每个数组索引的地址都对应于这个键，这个键要么保存值，要么保存指向值的指针。示例:我们可以将与键 k 相关联的值存储在第个槽中。没有相应关键字的地址简单地称为:nil。参见下面由直接地址表(T)定义的键和值之间的关系。
How a Direct Address Table works
在这种情况下，插入、删除和搜索都是 O(1 ),因为您可以通过地址直接找到键，并访问值。然而，限制这种数据结构用于存储关系信息的两个假设是:
- 数组的大小， m ，不算太大。
- 没有两个元素具有相同的键。
第一个是一个问题，因为我们不希望数组因为没有元素而占用太多空间。第二个也是一个问题，因为它限制了我们可以使用的键的类型。
因此，我们使用散列函数。
什么是哈希函数？
散列函数 h(k) 是将所有键映射到数组的槽的函数。另一种思考方式是:给定一个键和一个数组，哈希函数可以建议键的索引应该存储在数组中的什么位置。
散列函数是如何工作的？
可以为哈希表实现几种哈希函数，但最流行的是除法，其中对于 m 的某个值，h(k)=kmodm。其他哈希函数包括:乘法和折叠方法。
什么是哈希冲突，如何解决哈希冲突？
所以这一切都很好。但是当一个键被散列到与另一个键相同的数组槽中时会发生什么呢？啊哈！这就是所谓的哈希冲突。处理哈希冲突有几种不同的方法，最流行的两种方法是开放式寻址和封闭式寻址。
开放式寻址是指您将一个项目放置在某个位置，而不是其计算的位置。我们通过计算的方式来实现这一点，例如线性探测，其中使用线性搜索来查找可用的位置，并且查找项目也涉及线性搜索。
How the Linear Probe works as an example of open addressing
下面是哈希表中线性探测的代码片段:
**class** **HashEntry**:
**def** **__init__**(self, key, value):
self**.**key **=** key
self**.**value **=** value
self**.**next **=** None**class** **HashTable**:
**def** **__init__**(self, size):
self**.**size **=** size
self**.**keys **=** [None] ***** self**.**size
self**.**values **=** [None] ***** self**.**size
**def** **hash_function**(self, key):
**return** hash(key) **%** self**.**size
**def** **get_slot**(self, key):
slot **=** self**.**hash_function(key)
**while** self**.**keys[slot] **and** self**.**keys[slot] **!=** key:
slot **=** self**.**hash_function(slot **+** 1)
**return** slot
**def** **set**(self, key, value):
slot **=** self**.**get_slot(key)
self**.**keys[slot] **=** key
self**.**values[slot] **=** value
**def** **get**(self, key):
**return** self**.**values[self**.**get_slot(key)]
另一种开放式寻址的方式是使用二次探测，当决定下一步离最初的碰撞点有多远时，我们将挫败的尝试次数平方。每当另一个挫败的尝试被做，距离最初的碰撞点的距离迅速增长。
封闭寻址本质上是使用链表将具有相同哈希值的键链接在一起。该方法的查找与在链表中搜索是一样的。
Chaining uses Linked Lists to resolve hash collisions
下面是哈希表中链接的代码片段:
**class** **HashEntry**:
**def** **__init__**(self, key, value):
self**.**key **=** key
self**.**value **=** value
self**.**next **=** None**class** **HashTable**:
**def** **__init__**(self, size):
self**.**size **=** size
self**.**table **=** [None] ***** self**.**size **def** **hashing_function**(self, key):
**return** hash(key) **%** self**.**size **def** **rehash**(self, entry, key, value):
**while** entry **and** entry**.**key **!=** key:
prev, entry **=** entry, entry**.**next
**if** entry:
entry**.**value **=** value
**else**:
prev**.**next **=** HashEntry(key, value) **def** **set**(self, key, value):
slot **=** self**.**hashing_function(key)
entry **=** self**.**table[slot]
**if** **not** entry:
self**.**table[slot] **=** HashEntry(key, value)
**else**:
self**.**rehash(entry, key, value)
**def** **get**(self, key):
hash **=** self**.**hashing_function(key)
**if** **not** self**.**table[hash]: **raise** KeyError
**else**:
entry **=** self**.**table[hash]
**while** entry **and** entry**.**key **!=** key: entry **=** entry**.**next
**return** entry**.**value
暂时就这样吧！我希望这个关于散列表和它们的冲突的信息已经启发了你去学习更多关于它们的知识。
资源和引用
哈希表和哈希函数:https://www.youtube.com/watch?v=KyUTuwz_b7Q
麻省理工学院开放式课程:https://www.youtube.com/watch?v=0M_kIqhwbFo
斯坦福 CS 161 哈希注意事项:https://web . Stanford . edu/class/archive/CS/CS 161/CS 161.1168/lecture 9 . pdf
编码备忘单:https://www . alispit . tel/coding-Cheat-Sheets/data _ structures/hash _ tables . html
哈希幂概率数据结构
Photo by Ryan Thomas Ang on Unsplash
散列函数在计算机科学中被广泛使用，但我想提一下它们在概率数据结构和算法中的用途。我们都知道数据结构是大多数算法的构建模块。一个糟糕的选择可能会导致艰难而低效的解决方案，而不是优雅而高效的解决方案。
正如 Linus Torvalds 曾经在谈论 Git 时所说的:
…事实上，我是围绕数据设计代码的强烈支持者，而不是 T2，我认为这是 git 相当成功的原因之一(*)。
此外:
(*)事实上，我会说一个糟糕的程序员和一个好的程序员的区别在于他是否认为他的代码或者他的数据结构
更重要。糟糕的程序员担心代码。优秀的程序员担心数据结构和它们之间的关系。
如果你是一名计算机科学家、工程师或程序员，你会非常清楚不同细节层次的数据结构。和任何一个程序员聊十分钟都可能会听到:链表、树、堆、地图等等。
我与同事和朋友讨论过，根据你的工作内容，掌握这些数据结构有多重要。如果你是一名学者或者在一家公司工作，在那里数量是一个真正的问题，那么你应该掌握它们。
大多数情况下，如果你是用高级语言编程，那么重新发明轮子并自己实现已知的算法就是一种代码味道。大多数框架都内置了这些数据结构，或者有超高效的库，这些库很有可能会大有作为。
从另一个角度来看，大多数人从事软件维护工作，或者资源限制不是真正问题的地方。痴迷于将性能或资源消耗作为数据结构或算法决策的唯一衡量标准是不明智的，尤其是当它们不是那么相关的时候。同样，这取决于您正在解决的问题及其扩展需求。
但是有时资源限制确实是一个问题，在这种情况下，您应该考虑工具箱中的一个重要工具:概率数据结构。它们以相当可观的资源需求来牺牲精度。如果你正在解决一个小问题，其中内存空间不受限制，计算不是瓶颈，精确的精度是必须的*，那么在使用它们之前你可能会三思。如果不是这样，你应该知道他们的存在。另外，学习它们很有趣。*
有许多书籍、论文和文章都在谈论这个话题。在这里，我将谈论其中两个我认为非常漂亮并且在现实世界问题中大量使用的方法。我将使用一些数学，但不是非常详细，因为网上有很多优秀的资源。即使你不懂数学，你也会得到它们的基本概念(这是这里的目标)。
布隆过滤器
如果我的记忆正确的话， Bloom filters 是我几年前在阅读一些 petascale 数据库时听说的第一个概率数据结构。与许多其他概率数据结构一样，考虑到它们需要的空间和计算是如此之少，您会对它们的有效性感到非常惊讶。
假设你有一大组整数 S ，你想检查 S 是否包含一个元素 i 。你可以简单地使用一个带有空间/时间的链表来解决这个问题。还有，试试用O(n)/*O(log(n))*的平衡二叉树。或者很明显，一个有 O(n) / O(1) 的地图。
似乎大多数选项都需要与 S 的基数成线性关系的内存空间，考虑到如果我们不存储 *S，*的每个元素的值，我们怎么能检查一个元素是否存在于 S 中呢？。
布隆过滤器的思想是将整个集合 S 编码成一个固定长度的二进制串，我们称之为 Q 。这是通过将 S 中的每个元素编码到 *Q 中来实现的。*正如您可以想象的那样，将一个可变大小的域映射到一个固定大小的域最终会导致冲突。
让我们来看一个布隆过滤器的典型例子。假设我们将 Q 定义为固定长度 64 位的二进制字符串。此外，我们选择 k 不同的散列函数，如 MD5 或 SHA-1。接下来，我们执行以下操作:
- 取 S 中的第一个元素
- 使用 k 哈希函数对元素进行哈希运算，并将它们取模 64，以生成 Q. 中的 k 索引
- 在之前计算的索引处，将 Q 中的每一位设置为 1
- 对 S 中的每个剩余元素执行前两个步骤
当我们完成时，我们有一个 64 位的值 Q ，其中一些位被设置为 1，其他的被设置为 0。
现在我们要检查一个元素是否在 *S 中。*我们做与上面完全相同的程序来检查在 Q 中哪些位应该被置位。如果任何相应的 k 位未置位，我们可以确定该元素不在 S 中。如果它们都被设置，我们可以说元素是可能是 Q 中的，因为这些位也可以被许多元素部分地设置为 1。事实上，当您在 S 中不断添加元素时，越来越多的位在 Q 中被设置为 1，因此您不断增加这种可能性。
布隆过滤器会产生假阳性，但不会产生假阴性。
如果我们增加 Q 的大小，我们就避免了冲突，从而避免了误报的可能性。k 值也在碰撞概率中起作用。这是在大小(Q) 和 k 和假阳性率之间的权衡。如果你对量化误报率的数学感兴趣，你可以在这里阅读。同样，你可以在这里看到最佳尺寸(Q) 和 k 考虑 #S 或期望的假阳性率。
还有一个更重要的考虑:选择散列函数来生成 Q 中的索引。之前，我提到了 MD5 或 SHA-1，但这些都不是明智的选择。加密哈希函数试图生成不可逆转的输出。这不是我们关心的问题。我们对随机输出感兴趣，并尽可能快地进行计算，因此有更好的选择。
大多数实现使用单个散列函数来生成所需的输出。特别是 MurmurHash 函数，其中计算出 MurmurHash 输出的某个恒定基集，然后通过组合这些基哈希生成 k 输出。你可以在这里看到一个流行的布隆过滤器在 Go 中的实现。
还有另一种概率数据结构称为 计数最小草图 ，它估计集合中每个项目的频率。这个想法与布鲁姆滤镜的工作原理非常相似，所以你可能有兴趣看一看。
如果你对以太坊感兴趣，布隆过滤器被用来检查一个块是否包含与某些主题相关的 日志 。在以太坊中，主题与事件和索引参数相关。一个不存储任何关于世界状态、交易或收据的数据的轻型客户端，可以非常快速地检查一个块是否包含与任何感兴趣的主题相关的日志。如果 Bloom filter 检查匹配，考虑到误报的小概率，我们可以非常确定这个块包含一个用于查询的主题的日志条目。一个假阳性的成本超过了分析所有块的所有交易的所有收据的永久成本。
超对数
HyperLogLog 是对以前的想法的改进，如 LogLog 和线性计数，它们关注的是计数不同问题。
假设你想知道一个大集合 *S 的基数，即:*S 中有多少不同的元素。我们也想在 O(1)空间中这样做。引用提出该想法的原始论文:
例如，新的算法使得有可能在仅使用 1.5 千字节的存储器的情况下，以 2 %的典型精度来估计远超过 10 ⁹的基数。
这种数据结构中的形式数学比Bloom filters的情况更复杂，但背后的主要思想相当简单。
假设您有 8000 个随机生成的二进制字符串。我们预计其中有多少至少有 3 个前导零？嗯，至少有 3 个前导零的概率是 1/8，因此，我们可以估计大约有 1000 个前导零。当然，由于这是一个随机过程，我们可以看到从 0 到 8000 的二进制字符串满足这个属性，但每个情况的概率很重要。更一般地说，如果我们正好有 n 个前导零，那么基数为 2^n.似乎是合理的。这与将一枚硬币抛 100 次，我们大致会看到 50 个正面和 50 个反面是一样的。
当你深入细节时，你很快就会意识到差异是一个问题。这是一个很大的问题，因为每一个误差单位都会对估计产生指数影响。换句话说，如果我们碰巧有 K+1 个前导零，而不是 K 个前导零，那么我们的估计将会加倍。用于改进这一方面的思想是将集合分成多个子集，并使用在每个子集中找到的最大前导零的平均值。
从双对数到超双对数的一个演变是改变估计的均值类型，以控制对异常值的敏感性。特别是，对数对数使用的是算术平均值，而超对数使用的是调和平均值。此外，应用偏差校正系数来校正甚至更多的剩余偏差。
通过将集合分成多个集合来重复这个实验是很棒的，但是它产生了另一个问题:如果集合的基数太小，那么我们将没有足够的数据来进行统计。这可以通过简单地识别案例并使用在这种情况下更有效的其他技术来解决。
像在 Bloom filters 中一样，每个子集中的每个元素都被散列以将其转换成固定长度的二进制字符串，从中我们可以遵循上面的逻辑。同样，杂音散列函数在实现中被广泛使用。
结果
我们可以理解，在所有这些情况下，散列函数都扮演着重要的角色。优雅地说，它们提供了许多对概率数据结构和算法非常有用的特征:
- 它们将非均匀分布的数据转换成均匀分布的数据，这为概率假设提供了一个起点。
- 数据的通用身份，如果我们将操作设计为等幂，这将导致自动重复数据删除，有助于解决计数不同等问题。
利用散列不可逆性不是一个要求的事实，非加密散列函数是一个可以更快帮助算法速度的选项。
有不平衡的阶层？尝试重要术语
对一个类别有意义的词可以用来改善分类中的精确-召回折衷。使用最重要的术语作为词汇来驱动分类器，可以使用更小的模型来预测出院记录中的 MIMIC-III CCU 再入院，从而改善结果…
而且更难(抱歉瑜伽熊！)当要预测的目标类具有广泛变化的支持时。
但这种情况在真实世界的数据集上确实经常发生。一个恰当的例子是根据出院记录对一个病人近期 CCU 再入院的预测。只有一小部分患者在出院后 30 天内再次入住 CCU。我们对之前帖子中的 MIMIC-III 数据集的分析显示，超过 93%的患者不需要再次入院。这绝对是个好消息。但如果你从事预测行业，你会遇到一个更难的问题。您希望从大量不会经历再入院的病例中尽可能多地识别出那些为数不多的未来实际再入院病例。当然，你要避免错误地将病例标记为将来的再入院。
我们所面临的是一个经典的精确与召回的问题，我们在信息检索行业都很熟悉。
- 忽略精度，实现 100%召回。只需将所有笔记标记为未来重新接收。 FN = 0
- 忽略召回，实现 100%的准确率。只需将所有笔记标记为未来不再接收。 FP = 0
1.重要术语
兼顾精确度和召回率是一个挑战，这也是重要术语能有所帮助的地方。在之前的文章中，我们回顾了重要术语的背景，它们是什么，以及如何使用 Elasticsearch 从文本语料库中提取它们。那篇文章的要点如下。
- 出院笔记中最常见的术语显示出很少的差异，无论该笔记是否经历了再入院
- 出院记录中罕见术语的长尾受到错别字的困扰，这两个类别之间几乎没有区分能力
- 对每一类都有意义的术语明显不同，这潜在地为我们的分类任务提供了一个挂钩
因此，我们从上面的第三项开始，看看我们可以用哪些不同的方式来使用分类任务中的重要术语。首先，让我们从 MIMIC-III 数据集定义我们的训练和测试数据。
MIMIC-III 数据
在前一篇文章中，我们浏览了 MIMIC-III 数据集，并准备了一个弹性搜索索引。
每份文件都是出院记录，标签为再入院，为 0(本次出院后 30 天内未再入院)或 1(患者在本次出院后 30 天内再入院至 CCU)。我们有 40873 个 readmit=0 的文档和 2892 个 read MIT = 1的文档。这使得对少数类 readmit = 1 的正确预测变得更加困难。我们将数据分为训练集和测试集，同时根据重新提交标志进行分层。
train_docs, test_docs, train_labels, test_labels, train_ids, test_ids = train_test_split (docs, labels, ids, test_size=0.20, random_state=0, stratify=labels)
我们最终得到了以下用于训练和测试的分布。在训练集或测试集中，只有大约 6.6%的文档具有 readmit=1 。我们使用训练集建立模型，并预测我们在少数民族重新接纳类中的表现。
# Of Train / Test : 35012 / 8753
# Of Train Readmit / NoReadmit: 32698 / 2314
# Of Test Readmit / NoReadmit: 8175 / 578
虽然有偏差，但我们使用整个训练集来构建模型。用 SMOTE 对多数 no recent 类进行二次采样或对少数 readmit 类进行过采样都有其自身的问题，我们希望避开这些问题。然而，我们稍后会尝试在分类的背景下对少数民族类别的预测赋予更高的权重，例如使用逻辑回归……
下面的代码片段为每个类提供了训练集的 id，并使用 Elasticsearch 获得了重要的术语。
上面使用了卡方方法，但也有替代方法。最终结果是每个类的一组单词，其权重表示单词对该类的重要性。
2.具有重要术语的直接分类
有了重要的术语，我们就可以简单地根据这些术语的存在来对卸货单进行评分。我们得到了一个类的重要术语的总数，这些术语出现在一个测试放电记录中。这是这个音符和班级的分数，我们把这个音符放在分数最高的班级。我们可以进一步归一化(线性或 softmax)每个音符标签上的分数，并将其视为概率。这将有助于计算精确召回和 ROC 曲线下的面积等指标。下面是一段代码
- 使用重要术语作为词汇表和计数矢量器将测试放电记录转化为矢量
- 按标签计算每个音符的分数，并出于预测目的对其进行标准化
考虑的重要术语的数量是变化的，以观察其对结果的影响。下面的图 1 显示了预测重新接纳类所获得的精度和召回率( readmit = 1 )。
Figure 1. Predictions (threshold = 0.5) for the minority class in MIMIC-III dataset. The discharge notes are scored by a count of the significant terms they contain by class
这里的要点如下。
- 当我们考虑越来越多的重要术语时，召回率会增加，精确度会降低。当然有道理。
- 使用 500-1000 个重要术语获得了接近 99%的总召回率，精确度约为 7% 。在总共 578 例真正的再入院病例中，只有一例出院记录被错误地归类为无再入院病例。
- 用于提取重要术语的卡方和 jlh 方法产生相似的结果，其中卡方略微领先。在这篇文章的剩余部分，我们将坚持使用 chi_square。
3.用有意义的术语作为词汇表
当然，我们可以在标记的出院记录上使用任何旧的分类器，如逻辑回归，并建立预测模型。 CountVectorizer 用于建立词汇和文档向量进行分类。你可以尝试使用 TfidfVectorizer ，但是它会把事情搞得一团糟。
基于跨类别的相对计数测量，从语料库中提取重要术语，并且每个术语获得关于其对类别的重要性的分数。Tf-Idf 引入了自己的权重，这些权重是主体范围内的，与职业无关……
在任何情况下，语料库词汇几乎总是相当大。即使我们进行了清理，我们还是从 MIMIC-III 文本语料库中获得了超过 124000 个术语。我们当然可以限制这个数字。在下面的代码片段中，将只考虑所有单词的前 n_features 个，因此文档向量将为 n_features 长。
vectorizer = CountVectorizer(analyzer=lambda x: x, min_df=1, max_features=n_features).fit(train_docs + test_docs)
但是如果我们只使用重要的单词而不是所有的单词呢？仅仅是前 500 名或前 100 名？我们前面已经看到，一个类的重要术语与另一个类的重要术语有很大不同。事实上，对于二进制情况，将会有零重叠。
仅从重新接收类的重要术语构建的文档向量可能足以提供足够的辨别能力……
无论如何，这是一个论题。如果可行的话，我们将拥有一个小得多的模型，并且有望拥有与使用所有词汇的完整长向量所给出的精确度和召回率相当的精确度和召回率。向 CountVectorizer 提供定制词汇表非常简单。我们已经有了按重要性排序的重新接纳类的重要术语列表。列表中数量最多的 n_features 个单词被用作下面代码片段中的词汇表。
vectorizer = CountVectorizer(analyzer=lambda x: x, min_df=1, vocabulary=significant_terms_for_class_readmit_1[0:n_features]).fit(train_docs + test_docs)
使用这两种词汇构建和运行逻辑回归模型都很简单。我们只是为下面的函数提供了一个不同的矢量器。此外，我们确保应用 class_weight ( balanced )以便主要的无重传类与较小的重传类相比具有较低的权重。我们这样做的原因是因为我们处理的整个训练集严重偏向于不重新提交类。通过鼓励分类器更加重视少数类预测，这有助于使类之间的竞争更加公平。
图 2 显示了这些词汇表的召回率和准确率结果，作为所用单词数量的函数。
Figure 2. Predictions (threshold = 0.5) for the minority class in MIMIC-III dataset. Logistic regression (LR) with just 25 significant terms for the readmit class seems to achieve a good compromise between precision and recall.
这当然是一个有趣的图形。
- 当您限制特征的数量时，CountVectorizer 会选择最高频的单词。正如我们所知，它更倾向于回忆而不是精确。增加使用的单词数量可以提高回忆——在一定程度上！当所有的单词都被使用时，召回率会急剧下降，而准确率会小幅上升。有道理。
- 当重要术语定义词汇表时，可以获得更均匀和一致的结果。更有趣的是，看起来我们可以将 readmit 类的前 25 个重要单词与 Countvectorizer 和逻辑回归结合使用，以获得更高的精度和召回率。
4.精确召回和 ROC 区域
图 1 和图 2 中对精度和召回率的预测是基于 0.5 的阈值概率。也就是说，当重新提交类的注释的归一化分数(两个标签的总和为 1.0)大于 0.5 时，则该注释的预测为重新提交。当然，在选择这个门槛时有一定的自由度。
- 如果要确定(精度高！)你做出了正确的决定，那么你希望这个阈值概率很高
- 如果你不能错过(高召回！)潜在的重新接纳可能性，那么您希望这个阈值概率较低。
再次值得重复的是，早期数据中的预测是基于 0.5 的中性阈值。选择一个足够低的阈值概率，任何分类器都可以获得 99%的召回率。
但是图 1 中使用最重要术语的 99%召回率是在中性阈值为 0.5 的情况下获得的。
评估分类器的一种方法是看它对这个阈值概率有多敏感。这可以通过精确回忆和 ROC 曲线及其包围的区域方便地得到。图 3 显示了使用前 100 个术语(重要术语或语料库词汇)时的精确召回率和 ROC 曲线。
Figure 3. Logistic regression (LR) with significant terms as the vocabulary shows a more advantageous trade-off between precision and recall.
图 4 显示了 precision-recall & ROC 曲线的曲线下面积(AUC ),它是我们在这篇文章中尝试的不同方法所使用的词汇量的函数。
Figure 4. Logistic regression (LR) with significant terms is clearly the leader in dealing with the precision-recall trade off. The ROC AUC is not an effective metric when the classes are unbalanced
使用具有重要词汇的逻辑回归比使用高频词做得更好。它也比简单的基于计数的分类器要好——至少在精确召回方面是这样。
但是我们知道，如果少数类的召回是最重要的，基于计数的方法会更好。这可能是预测类似 CCU 再入院事件的情况。你可以决定是否要召回！
5.结论
为少数阶级做出正确的预测是困难的。以下是这一系列文章的一些松散的结论。
- 识别对一个班级来说特别/重要的单词在精确回忆舞蹈中是有用的。
- 这些单词是了解该课程内容本质的窗口。帮助解释为什么一个文档被分类器(可解释的人工智能？)
- 使用有意义的单词作为词汇表来构建文档向量似乎有望优化精确度和召回率。此外，你只需要几个这样的小模型。
- Tf-Idf 矢量化结合重要术语，因为词汇表需要进一步分析它到底做什么。
原载于 2019 年 12 月 23 日http://xplordat.com。
你在部署之前优化过你的深度学习模型吗？
Source: https://developer.nvidia.com/tensorrt#
使用 NVIDIA TensorRT 在 GPU 上优化和加快推理时间。插图基于人工智能的计算机视觉与 YOLO。
本文组织如下:
- 介绍
- 英伟达 TensorRT 是什么？
- 使用 docker 设置开发环境
- 计算机视觉应用:YOLOv3 模型的目标检测
- 参考
- 结论
介绍
本文介绍了如何使用 NVIDIA TensorRT 来优化您想要部署在边缘设备(移动设备、相机、机器人、汽车等)上的深度学习模型。).比如航空电子公司的智能双光谱相机:潘沙https://pensarsdk.com/
它拥有 NVIDIA Jetson TX2 GPU
https://developer.nvidia.com/embedded/jetson-tx2-developer-kit
为什么我需要一个优化的深度学习模型？
举个例子，想想基于人工智能的计算机视觉应用，它们需要处理摄像机捕捉的每一帧。因此，每一帧向前通过模型的层来计算某一输出(检测、分割、分类……)。
无论你的 GPU 有多强大，我们都希望输出端的每秒帧数(FPS)等于输入端的 1(例如 24，30 FPS…)。这意味着 GPU 正在实时处理每一帧。
对于需要实时决策的计算机视觉应用来说，这种概念更为理想，例如，监控、欺诈检测或活动期间的人群计数等。
部署前优化工作流
数据科学家的任务之一是利用数据并开发/训练/测试神经网络架构。在模型验证之后，通常，架构和模型的参数被导出用于部署。有许多方法可以做到这一点，无论是在云上还是在边缘设备上。在本文中，我们重点关注边缘设备(相机、手机、机器人、汽车……)上的部署。
一般来说，部署的工作流程遵循下图所示的框图:
从导出的、预先训练好的深度学习模型 - > 框架解析器**->**tensort 优化 - > 对新数据进行推理
英伟达 TensorRT 是什么？
https://docs.nvidia.com/deeplearning/sdk/tensorrt-archived/tensorrt_210/tensorrt-user-guide/
NVIDIA TensorRT 的核心是一个 C++库，它有助于在 NVIDIA 图形处理单元(GPU)上进行高性能推理。TensorRT 采用一个由网络定义和一组训练参数组成的训练网络，并生成一个高度优化的运行时引擎，为该网络执行推理。
您可以使用 C++或 Python API 描述 TensorRT 网络，也可以使用提供的解析器之一导入现有的 Caffe、ONNX 或 TensorFlow 模型。
TensorRT 通过 C++和 Python 提供 API，帮助通过网络定义 API 表达深度学习模型，或通过解析器加载预定义的模型，允许 TensorRT 在 NVIDIA GPU 上优化和运行它们。TensorRT 应用了图形优化、层融合以及其他优化，同时还利用高度优化的内核的多样化集合找到了该模型的最快实现。TensorRT 还提供了一个运行时，您可以使用它在从开普勒一代开始的所有 NVIDIA GPU 上执行这个网络。
TensorRT 还包括在 Tegra X1 中引入的可选高速混合精度功能，并通过 Pascal、Volta 和图灵架构进行了扩展。
在【开发者指南】(https://docs . NVIDIA . com/deep learning/SDK/TensorRT-developer-guide/index . html)中了解如何使用 tensorrt，以及在【TensorRT 论坛】(https://dev talk . NVIDIA . com/default/board/304/tensor rt/)中与 tensor rt 社区互动
使用 docker 设置开发环境
Docker 图像
对于开发，我们使用一个 docker 映像，其中包含一个已安装的 NVIDIA TensorRT 版本。这使得开发环境在不同的操作系统(Windows、Linux、macOS)上更加可靠和可伸缩。
下面是 docker 在应用程序和 GPU 之间的定位图。
**注:**如果你从未听说过“docker”，那么我强烈建议你投资了解它，你从这里开始:https://docs.docker.com/engine/docker-overview/
安装 Docker-CE
前往 docker 的官方网站，按照步骤安装“docker-ce ”( ce 代表社区版)。
我使用的是 Ubuntu 64 bit，因此，安装链接是:https://docs . docker . com/v 17.09/engine/installation/Linux/docker-ce/Ubuntu/
安装 CUDA
另外，你应该已经安装了最新版本的 CUDA 。它是由 NVIDIA 创建的并行计算平台和应用编程接口模型。它允许软件开发人员和软件工程师使用支持 CUDA 的 GPU 进行通用处理(在https://developer.nvidia.com/cuda-zone了解更多信息)。
要检查 CUDA 是否正确安装在您的机器上，只需在终端中输入
nvidia-smi
输出应该是这样的(我有一个 NVIDIA GPU GeForce GTX 1660 Ti/PCIe/SSE 2)
Thu Aug 1 10:43:37 2019
+ — — — — — — — — — — — — — — — — — — —— — — — — — — — — — — -+
| NVIDIA-SMI 430.40 **Driver Version:** 430.40 **CUDA Version:** 10.1 |
| — — — — — — — — — — — — -+ — — — — — — — — + — — — —— — — — +
| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
|=====================+===================+===================|
| 0 GeForce GTX 166… Off | 00000000:01:00.0 Off | N/A |
| N/A 47C P8 4W / N/A | 994MiB / 5944MiB | 8% Default |
+ — — — — —— — — — — — — -+ — — — — — — — — + — — — — — — — — +
运行 docker 映像以使用 NVIDIA TensorRT
我已经创建了一个 docker 映像，其中包括在 Ubuntu 上安装 TensorRT，以及来自 NVIDIA、Python、OpenCV 等的必要先决条件。你可以直接从我在 docker hub 上的个人账户中调出图片。
[## 码头枢纽
欢迎来到我的码头中心
hub.docker.com](https://hub.docker.com/r/aminehy/tensorrt-opencv-python3)
- 首先，打开一个终端(ctrl+alt + t ),输入这个命令来提取 docker 图像
docker pull aminehy/tensorrt-opencv-python3
- 通过输入以下命令，启用从 docker 容器内部启动 GUI 应用程序
xhost +
- 最后，用以下命令运行 docker 容器:
docker run -it — rm -v $(pwd):/workspace — runtime=nvidia -w /workspace -v /tmp/.X11-unix:/tmp/.X11-unix -e DISPLAY=unix$DISPLAY aminehy/tensorrt-opencv-python3:v1.1
计算机视觉应用:用 YOLOv3 进行物体检测
YOLO 是来自暗网项目的一个实时物体检测。你可以在这里的官方网站上了解这个项目的更多信息:【https://pjreddie.com/darknet/yolo/
https://pjreddie.com/darknet/yolo/
在本实验中，我们在 500 张图片上运行 YOLOv3 模型，并使用 NVIDIA TensorRT 比较模型优化前后的平均推理时间。本实验中使用的图像来自 COCO 数据集
编辑描述
cocodataset.org](http://cocodataset.org/#home)
1)从 Python 中的暗网中运行未优化的 YOLOv3
GitLab.com
gitlab.com](https://gitlab.com/aminehy/yolov3-darknet)
- 克隆存储库并通过我创建的脚本 docker _ tensort _ OpenCV _ python . sh 运行 docker 映像
git clone [https://gitlab.com/aminehy/yolov3-darknet.git](https://gitlab.com/aminehy/yolov3-darknet.git)cd yolov3-darknetchmod +x docker_TensorRT_OpenCV_Python.sh./docker_TensorRT_OpenCV_Python.sh run
- 下载并解压测试图像文件夹。/数据/
wget [http://images.cocodataset.org/zips/test2017.zip](http://images.cocodataset.org/zips/test2017.zip)unzip test2017.zip ../test2017/
- 下载重量文件` yolov3.weights ’
wget [https://pjreddie.com/media/files/yolov3.weights](https://pjreddie.com/media/files/yolov3.weights)
- 然后执行 YOLOv3 python 文件
python darknet.py
- 成绩:
结果应该保存在文件夹`。/数据/结果’
Output: The mean recognition time over 500 images is 0.044 seconds
2)使用 Python 中的 NVIDIA TensorRT 优化并运行 YOLOv3
第一步是导入模型，包括从磁盘上保存的文件中加载模型，并将其从原生框架或格式转换为 TensorRT 网络。我们的示例从 ONNX 模型加载 ONNX 格式的模型。
ONNX 是一种表示深度学习模型的标准，使它们能够在框架之间转移。(许多框架如 Caffe2、Chainer、CNTK、PaddlePaddle、PyTorch 和 MXNet 都支持 ONNX 格式)。
接下来，基于输入模型、目标 GPU 平台和指定的其他配置参数构建优化的 TensorRT 引擎。最后一步是向 TensorRT 引擎提供输入数据以执行推理。
该示例使用 TensorRT 中的以下组件来执行上述步骤:
- ONNX 解析器:将 ONNX 格式的训练模型作为输入，并在 TensorRT 中填充网络对象
-构建器:在 TensorRT 中获取网络，并生成针对目标平台优化的引擎
-引擎:获取输入数据，执行推理并发出推理输出
-记录器:与构建器和引擎相关联的对象，用于在构建和推理阶段捕获错误、警告和其他信息
[## 胺 Hy/yolov 3-Darknet-ONNX-TensorRT
GitLab.com
gitlab.com](https://gitlab.com/aminehy/YOLOv3-Darknet-ONNX-TensorRT)
- 从 GitHub 获取项目并更改工作目录
git clone [https://gitlab.com/aminehy/YOLOv3-Darknet-ONNX-TensorRT.git](https://gitlab.com/aminehy/YOLOv3-Darknet-ONNX-TensorRT.git)cd YOLOv3-Darknet-ONNX-TensorRT/
- 将模型从 Darknet 转换为 ONNX。这一步将创建一个名为
yolov3.onnx的引擎
python yolov3_to_onnx.py
- 将模型从 ONNX 转换为 TensorRT。这一步将创建一个名为 yolov3.trt 的引擎，并用于推理
python onnx_to_tensorrt.py
- 对于这个实验，我们设置这个参数:builder.fp16_mode = True
builder.fp16_mode = True
builder.strict_type_constraints = True
- 成绩:
Output: The mean recognition time over 500 images is 0.018 seconds using the precision fp16\.
因此，使用 NVIDIA TensorRT 比未优化版本快 2.31 倍！。
3)通过在 C++中导入 Caffe 模型，使用 NVIDIA TensorRT 优化并运行 YOLOv3
- 获取项目并更改工作目录
[## 胺 Hy / YOLOv3-Caffe-TensorRT
Yolov3 的 TensorRT
gitlab.com](https://gitlab.com/aminehy/YOLOv3-Caffe-TensorRT)
如果文件夹`/Caffe '不存在(出于任何原因)，请下载 YOLOv3 的模型架构和权重(。prototxt 和。caffemodel)并将其插入到文件夹“Caffe”中。有两种选择，416 型和 608 型。这些参数表示 YOLOv3 网络输入端图像的高度/宽度。
- 从 Google Drive 文件夹下载文件:[https://Drive . Google . com/Drive/folders/18 oxncrrdrcumoamgngjlhegglq 1 hqk _ NJ](http://cd TensorRT-Yolov3/ ./docker_TensorRT_OpenCV_Python.sh run)
- 编译并构建模型
git submodule update — init — recursivemkdir buildcd build && cmake .. && make && make install && cd ..
- 编辑 YOLO 配置文件，并在以下设置中选择 YOLO 416 或 YOLO 608
~/TensorRT-Yolov3/tensorRTWrapper/code/include/YoloConfigs.h
- 您还需要查看位于
~/TensorRT-Yolov3/include/configs.h
- 如上所述创建 TensorRT 引擎，并在测试映像“dog.jpg”上运行 YOLOv3
# for yolov3–416 (don’t forget to edit YoloConfigs.h for YoloKernel)
./install/runYolov3 — caffemodel=./caffe/yolov3_416.caffemodel — prototxt=./caffe/yolov3_416.prototxt — input=./dog.jpg — W=416 — H=416 — class=80 — mode=fp16
- 一旦创建了引擎，就可以将它作为参数传递
./install/runYolov3 — caffemodel=./caffe/yolov3_416.caffemodel
— prototxt=./caffe/yolov3_416.prototxt — input=./dog.jpg — W=416 — H=416 — class=80 — enginefile=./engine/yolov3_fp32.engine
- 结果:
Output: Time over all layers: 21.245 ms
S 。
结论
本文介绍了优化预训练深度学习模型的重要性。我们在一个计算机视觉的目标检测应用的例子中说明了这一点，在这个例子中，我们获得了推理时间大于 2 的加速比。
下一步怎么办？
- 请在评论区告诉我你的想法，或者在 LinkedIn 上直接给我发消息。
- 阅读我在 medium 上的另一篇文章:使用 PyTorch 实现的图像分类深度学习
参考
- 边缘摄像机 Pensar【https://pensarsdk.com/
- CUDA:【https://developer.nvidia.com/cuda-zone
- https://docs.docker.com/
- 英伟达 TensorRT:https://ngc.nvidia.com/catalog/containers/nvidia:tensorrt
- NVIDIA 容器最佳实践:https://docs . NVIDIA . com/deep learning/frameworks/BP-docker/index . html # docker-BP-topic
- tensor rt 19.05 版本:https://docs . NVIDIA . com/deep learning/SDK/tensor rt-container-Release-notes/rel _ 19-05 . html # rel _ 19-05
你教过你的机器了吗？
谷歌的可教机器如何在你的小浏览器中学习
A visual representation of what a CNN actually sees — Source
机器可以看见
自 2015 年，当一个 Resnet 首次超过人类对图像进行分类的准确度阈值时，深度学习席卷了整个世界。阅读详细介绍这些成就的研究通常会给人一种印象，即表现良好的深度学习模型需要一个包含一百万张标记图像的数据集和一群 GPU 来训练它们。但是如果你只有几百张图片和一台带 CPU 的笔记本电脑会怎么样呢？有了谷歌的可教机器，你可以在几分钟内见证机器的视觉效果。
这里有一款型号(点击试试！)可以对物体是一块布还是一本书进行分类。它是由作者在他的浏览器上使用 4 个对象训练的——一本黑色的书、一本橙色的书、一块白布和一块黄色的布。我们在不同的方向上拍摄每个物体的大约 150 张图像，并在不到一分钟的时间内用总共大约 600 张图像训练该模型。你在这个模型上踢轮胎了吗？为什么不试着给这个模型看一本黄皮书来欺骗它，看看它是否成立？即使你成功地搞乱了这个模型，一台机器能够在如此短的时间内用如此少的数据学会如此准确地对物体进行分类也是非常了不起的。同样不可思议的是，你只需点击几下鼠标，就能体验到这种模式的强大——一切都在你的浏览器中进行——没有服务器，没有 GPU。那么，什么是真正的引擎盖下？
迁移学习
可教机器使用迁移学习；一种方法，使用来自另一个模型的可转移知识，并使用手头任务可用的数据对其进行提炼。这有点像在新的令人兴奋的工作场所使用你在以前的工作中学到的技能。人和系统有不同的名字，问题可能看起来有点不同，但是你的核心分析和编程技能仍然是有用的。但是如果你的工作转换是更基本的，你可能会考虑回到学校去提高你的机器学习技能。也许你想参加高级语音识别课程，了解如何检测声音中的欺骗。你的核心数学技能仍然是相关的，但你必须学习一些相当复杂的东西才能让你的下一份工作顺利进行。
在神经网络模型的情况下，第一种方法使用基本模型，该模型在一些常规任务中表现非常好，例如将所有类型的图像分类到一千个不同的类别中。我们只需去掉最后一个分类层，适合我们自己的分类层，并用新图像只训练这一层。在这种情况下，我们的基本模型只是通过创建一个已经捕获了一般相关特征的图像的表示来充当“固定特征提取器”。
第二种方法更进一步，允许我们的基本模型的权重在训练过程中改变。这被称为“微调”模型。
具体细节
谷歌的可教机器使用前一种方法，将基本模型视为固定的特征提取器。我们将确切地看到他们的实现如何使用迁移学习模型。
MobileNet paper and ImageNet Thumbnails
1.拿训练好的MobileNet【1】模型，一个 28 层的 CNN 模型来分类图像。
2.截断此模型的 softmax 层，并将此模型的输出设置为图像的倒数第二个张量表示
3.创建一个只有两层的小模型——一层是密集层(比如 100 个单元),另一层是最终的 softmax 层，其单元数与我们想要的类数一样多。我们的第一个密集层必须接受与 MobileNet 输出相同的输入。
4.捕捉图像并使用 MobileNet 将每个图像转换为其张量。这些转换后的数据就是我们训练模型所需要的。
5.使用这些训练数据和我们定义的模型，单独训练我们的 2 层模型几个时期。
6.通过附加 MobileNet 和我们的 2 层模型创建一个联合模型。
7.给定一张新图像，通过这个联合模型运行它以生成一个预测。
由于 MobileNet 本身非常小(约 2MB)，整个模型可以放入您的浏览器中，并且没有图像需要离开浏览器进行训练。Tensorflow.js 进一步允许我们直接用 javascript 编写所有这些模型，从而赋予整个架构一些奇妙的属性。
1)训练是保护隐私的(图像不必离开你的浏览器)
2)推断可以很快，因为它不需要服务器——这是 MobileNet 通过浏览器摄像头检测几个人姿势的快照
Multi-pose detection on a webcam — Authors webcam using image from Source
3)用户不需要安装任何库——打开一个网页，你就可以立即体验这个模型
4)结合上面的迁移学习方法，您可以在几分钟内训练出一个新模型
该不该回大学？
我们上面详述的方法显然非常有效。但是微调呢？这对训练这些内部神经元有帮助吗？
本文【2】中探讨的视觉十项全能基准旨在回答不同迁移学习方法在性能上的比较。使用一个基础模型作为在 ImageNet 1K 数据集上训练的 resnet28，本文评估了不同迁移学习方法在各种目标数据集(如 CIFAR100、VGG 弗劳尔斯等)上的性能。，这是每一列。我们刚刚讨论的两种不同的迁移学习方法在红框中突出显示为“微调”模型和“特征提取”模型。数字代表图像分类的最高精度。
Learning multiple visual domains with residual adapters — Source
在他们的实验中，微调似乎始终优于固定特征提取器。这很可能是因为模型学习了一些非常 Imagenet 特定的特征，例如试图区分几个狗品种。将这些神经元中的一部分重新用于目标数据集，看起来确实有积极的效果。然而，训练一个 Resnet28 是耗时且计算量大的。该白皮书还找到了一个更好的解决方案，可以充分利用这两个领域的优势。
所以回到大学确实看起来很有用，但是很贵。权衡归结为你可能获得多少，以及是否值得花费。
参考
[1] A.G. Howard，M. Zhu，B. Chen，D. Kalenichenko，W. Wang，T. Weyand，M. Andreetto，H. Adam， MobileNets:用于移动视觉应用的高效卷积神经网络 (2017)
[2] S.A. Rebuffi，H. Bilen，A. Vedaldi 用剩余适配器学习多个视觉域 (2017)
拥有一份好的咨询工作:我为什么要回到学校学习计算机科学
Photo by Avel Chuklanov on Unsplash
硕士毕业后不久，我很幸运地在一家大公司找到了一份分析顾问的好工作。我有很棒的同事和成长机会。
我的第一个大学学位是经济学。我甚至获得了发展经济学硕士学位，这是我当时的兴趣所在，现在依然如此。但是几年前毕业后，我做了一名数据分析师，现在我正准备从事数据科学/软件工程师的职业。渐渐地，我认真考虑了获得计算机科学大学学位的选择。我需要兼职工作和学习。
这是一个艰难的决定。也许我疯了！？
除了要花掉我所有的积蓄之外，花至少 3 到 4 年时间学习的想法也让我害怕。更不用说，如果我不够小心，我可能会耗尽自己的精力，危及我的人际关系。最明显的是，我将不得不告别我非常喜欢的早上在床上多躺几个小时的时光！我阅读了我可能在网上找到的数百篇文章、帖子、论坛帖子，希望能找到一些指导。
如果你已经在这个领域工作，关于计算机科学学位的价值和必要性会有几种相互矛盾的观点。毕竟，很多自学成才的人已经成为成功的工程师、开发人员和技术领导者。此外，网上和训练营有大量的学习资源。我还自学了很多重要的计算机和编程技能。如果是这样，那么获得学位的意义何在？
以下是我自己从一个学习者的角度对计算机科学中正式程序的价值的看法。
1.未知-未知:你不知道你不知道的事
我们倾向于生活在某种“泡沫”中，无论是职业上还是个人上。我们和认识的人出去玩，和我们相似的人。我们和背景相似的同事一起工作。甚至我们使用的应用程序上的推荐系统也会根据你和像你一样的人的历史行为向你推荐东西。除非你有足够多样的网络，并让自己接触许多不同的角色和挑战，否则我们会把自己的思维局限在这个泡泡里。
即使我从工作中获得了一些经验和技能，我仍然有掉进这个“泡沫”陷阱的感觉。在这个我不知道的泡沫之外，仍然有那么多有价值的见解、知识和技能。虽然有很多方法可以更好地了解计算机和技术这一广阔领域中你所不知道的东西，但我选择了本科教育。我个人认为这是填补我基础中未知空白的好方法。
2.你的学习方式很重要
如果你是一个非常有原则和有组织的人，你更有可能在自学道路上取得成功(假设你已经知道你需要学习什么，以及你应该如何学习)。然而，对我们大多数人来说，这是困难的。举个例子，我是那种非常擅长拖延不紧急的事情的人。在忙碌的一天，也是不那么忙碌的一天，完成技术书籍或在线课程的另一章将是我的任务清单上的最后一件事！
然而，我在一个学习环境中茁壮成长，在那里我不是完全靠自己。有志趣相投的人可以交流，一点点压力和竞争真的给了我额外的动力。
此外，教育计划的系统方法将帮助你组织你的学习。你可能要花几周甚至几个月的时间来自己组织一个课程。有了可靠的课程，我可以按自己喜欢的方式扩展。我通常会将正式的学习课程向前推进一步——进行一些额外的阅读，查找一些更高级的概念、工具和应用程序。这是从任何教育中获得最大收益的最佳方式之一。
3.你对“没用”的东西好奇吗？
Photo by Justin Peterson on Unsplash
在大学学习通常会涉及一堆你可能一辈子都不会用到的理论和概念。但是学起来会很有趣。这些“无用”的想法也许有一天会聚集在一起，帮助你理解工作中甚至生活中的重要事情。理解看似琐碎的基础知识可以帮助你更容易地掌握新技术，更好地联系和概括你的知识。
我不知道在世人面前我会是什么样子，但对我自己来说，我似乎只是一个在海边玩耍的男孩，时不时地寻找一块比平常更光滑的鹅卵石或一个比平常更漂亮的贝壳，而真理的汪洋大海还未被发现。
-艾萨克·牛顿
最后我在网上的帮助搜索也没有找到一个很满意的答案。我只知道我的整个身心都在说“就这么做吧”。我很高兴我做到了！我喜欢像海绵一样学习和吸收每一项知识，同时努力在其他生活承诺中保持平衡。毕竟，无论如何，我们都是学生，不是吗？
拥有不平衡的数据集？以下是你可以修复它的方法。
处理不平衡数据集的不同方法。
分类是最常见的机器学习问题之一。处理任何分类问题的最佳方式是从分析和探索数据集开始，我们称之为EexplorationDATAAanalysis**(EDA)。这个练习的唯一目的是生成尽可能多的关于数据的见解和信息。它还用于查找数据集中可能存在的任何问题。在用于分类的数据集中发现的一个常见问题是不平衡类**问题。
什么是数据失衡？
数据不平衡通常反映了数据集中类的不平等分布。例如，在信用卡欺诈检测数据集中，大多数信用卡交易不是欺诈，只有极少数类别是欺诈交易。这样，欺诈类和非欺诈类的比例大约为 50:1。在本文中，我将使用 Kaggle 的信用卡欺诈交易数据集，可以从这里的下载。
首先，让我们画出阶级分布图来看看不平衡。
如您所见，非欺诈交易远远超过欺诈交易。如果我们在没有修复这个问题的情况下训练一个二进制分类模型，那么这个模型将会完全有偏差。它还会影响特性之间的相关性，稍后我将向您展示如何影响以及为什么影响。
现在，让我们介绍一些解决班级不平衡问题的技巧。有完整代码的笔记本可以在这里找到
1-重采样(过采样和欠采样):
这听起来很直观。欠采样是指从多数类中随机删除一些观察值，以便将数字与少数类相匹配的过程。下面的代码显示了一种简单的方法:
Undersampling the majority class
对数据集进行欠采样后，我再次绘制它，它显示了相同数量的类:
Balanced Dataset (Undersampling)
第二种重采样技术叫做过采样。这个过程比欠采样稍微复杂一点。它是生成合成数据的过程，试图从少数类的观察值中随机生成属性样本。对于典型的分类问题，有多种方法可用于对数据集进行过采样。最常见的技术叫做 SMOTE ( 合成少数过采样技术)。简而言之，它查看少数类数据点的特征空间，并考虑其最近的邻居 k 。
Source:https://imbalanced-learn.readthedocs.io/en/stable/over_sampling.html
为了用 python 编写代码，我使用了一个名为 不平衡学习 **或 imblearn 的库。**下面的代码展示了如何实现 SMOTE。
SMOTE Oversampling code
还记得我说过不平衡的数据会如何影响特征相关性吗？我给你看一下治疗不平衡班前后的相关性。
重新采样前:
下面的代码绘制了所有特性之间的相关矩阵。
*# Sample figsize in inches*
fig, ax = plt.subplots(figsize=(20,10)) *# Imbalanced DataFrame Correlation*
corr = credit_df.corr()
sns.heatmap(corr, cmap='YlGnBu', annot_kws={'size':30}, ax=ax)
ax.set_title("Imbalanced Correlation Matrix", fontsize=14)plt.show()
重采样后:
请注意，现在特征相关性更加明显了。在修复不平衡问题之前，大多数功能没有显示任何相关性，而这种相关性肯定会影响模型的性能。由于 特征相关性对于整体模型的性能来说非常重要 ，因此修复这种不平衡非常重要，因为它也会影响 ML 模型的性能。
2-集合方法(采样器集合):
在机器学习中，集成方法使用多种学习算法和技术来获得比单独从任何组成学习算法获得的性能更好的性能。(没错，就像民主投票制一样)。当使用集成分类器时，bagging 方法变得流行，它通过对不同的随机选择的数据子集建立多个估计器来工作。在 scikit-learn 库中，有一个名为BaggingClassifier的集成分类器。然而，这种分类器不允许平衡每个数据子集。因此，当在不平衡数据集上训练时，该分类器将偏向大多数类并创建有偏差的模型。
为了解决这个问题，我们可以使用 imblearn 库中的[**BalancedBaggingClassifier**](https://imbalanced-learn.readthedocs.io/en/stable/generated/imblearn.ensemble.BalancedBaggingClassifier.html#imblearn.ensemble.BalancedBaggingClassifier)。它允许在训练集合的每个估计器之前对数据集的每个子集进行重采样。因此，[**BalancedBaggingClassifier**](https://imbalanced-learn.readthedocs.io/en/stable/generated/imblearn.ensemble.BalancedBaggingClassifier.html#imblearn.ensemble.BalancedBaggingClassifier)采用与 scikit-learn BaggingClassifier相同的参数，此外还有另外两个参数，sampling_strategy和replacement，它们控制随机采样器的行为。下面是一些显示如何做到这一点的代码:
Train Imbalanced Dataset using Ensembling Samplers
这样，您可以训练一个分类器来处理不平衡，而不必在训练前手动欠采样或过采样。
重要提示:
- 在平衡数据之前，应该始终将数据集分成定型集和测试集。通过这种方式，您可以确保测试数据集尽可能地不偏不倚，并反映您的模型的真实评估。
- 在分割之前平衡数据可能会在测试集中引入偏差，其中测试集中的一些数据点是合成生成的，并且从训练集中是众所周知的。测试集应该尽可能客观。
- 欠采样技术的问题是，您可能会删除一些有价值的信息，并改变特定领域中具有代表性的整体数据集分布。因此，欠采样不应该是不平衡数据集的首选方法。
总之，每个人都应该知道，建立在不平衡数据集上的最大似然模型的整体性能将受到其预测稀有点和少数点的能力的限制。识别和解决这些点的不平衡对于生成的模型的质量和性能至关重要。
享受 NLP 和权力的游戏对话的乐趣。
谁是这个系列中最重要的人物？
Photo by mauRÍCIO SANTOS on Unsplash
介绍。
最后一季即将来临！冬天终于来了！所以我想用对话来平息我对下一季的宣传。
你有没有想过哪个角色最有影响力？谁说的最多？谁的对白比较多？在整个系列中，哪些词用得最多？谁是真正的主角？或者，计算机有可能为这部剧生成新的对话吗？本文将尝试回答这些问题。
在此之前，我想提一下这两个家伙，他们的工作激发了你将要看到的很多东西，所以请检查他们的帖子和代码:
帕勒斯·乔普拉和丹尼尔·利赫特。
数据免责声明。
该数据集由该系列的 65 个章节组成，并非所有的季节都是完整的，尤其是第 2、3 和 4 季，所有其他季节都是完整的。你可以在这里了解更多关于收集数据的技术方面。
对话多就意味着话多吗？
Barplot for dialogues
我用最多的对话和更高的字数绘制了前 20 个角色，我们可以清楚地看到提利昂确实从不闭嘴，有超过一千个对话，平均每个对话 16 个单词，是迄今为止最健谈的角色。
Barplot for words
事实上，对话和文字是相关的，前 20 个角色从一个情节到另一个情节几乎没有变化，一个有趣的变化是兰尼斯特家，他们在每个对话中说更多的话。
让我们检查一下每段对话单词分布情况。
Distribution of words per dialogue of top 5 characters.
琼恩·雪诺是一个沉默寡言的人，他的情节几乎平淡无奇，与丹妮莉丝非常相似，兰尼斯特家的情节更加稳健，每次开口都意味着更多的话。
Longest dialogue of the sample.
詹姆的图中有一个很大的异常值，比其他 4 个大得多，当我检查时，我意识到这是其中最大的一个。我们的样本数据中最长的不间断对话是詹姆·兰尼斯特用超过 350 个单词告诉布里安他是如何在第三季杀死疯王的。
我们的角色实际上在说什么，有模式吗？
我按照前 5 个字符绘制了 60 个最常用的单词，我使用 NLTK 删除了英语中一些非常常用的单词和一些不会给情节带来任何价值的其他单词，如“国王”、“勋爵”、“先生”等。
只有兰尼斯特家的人在他们的话语中有爱，我认为这真正定义了他们的角色，他们的动机大多是激情。虽然像琼恩和奈德这样的史塔克家族是因为职责和拯救世界而战，或者丹妮是因为命运而战，从她的用词来看很明显，她是一个无情的统治者；兰尼斯特家为他们所爱的人而战。我也可以说《权力的游戏》是关于一群极度恋父的杀人犯。
这一个是令人震惊的。
主角是谁？
说得最多并不总是意味着成为最有影响力的人物，这取决于你与之交谈的人有多重要，以及你在自己的对话之外被提及的次数。你和你周围的世界有多相关，所以这是我们样本数据的交互网络。
检查图中的链接以获得更好的视图，并有机会玩节点。
无论如何，这个图表从数字上没有告诉我们一个字符的重要性。
这的确告诉我们瑟曦、提利昂和琼恩有多重要，但任何一个都可能是主角，对吧？
中心性的程度。
如果我们测量每个节点的中心度，我们将得到一个非常明确的答案，即我们的角色对该系列有多重要，所以让我们根据样本数据来看看前 10 个最重要的角色:
根据我们的样本，乔恩的确是《冰与火之歌》中最重要的角色。
使用示例对话生成文本。
在预先训练好的模型出现之前，你需要一个巨大的文本语料库来做任何有意义的事情。现在，即使是很小的数据集也足以做有趣的事情。请在评论中告诉我，你想到了哪些可以使用小型文本语料库和预训练模型的项目想法。
我参加了 Paras Chopra 挑战，并自己生成了一些对话，结果非常有趣。
It is indeed a pity to trust Sansa.
结论。
- 主角是琼恩·雪诺，因为他与奈德、珊莎、提利昂和丹妮等其他重要角色有联系。
- 在人物中心情节中，提利昂在瑟曦之下，我认为这是因为两个主要原因:第二季和第三季在数据集中有很多缺失的章节，而这几季是提利昂最出彩的地方；第二，因为瑟曦与奈德和劳勃(非常中心的人物)有很强的关系，但提利昂从不谈论他们中的任何一个。
- 更多的对话在某种程度上与性格影响有关，但只是在一定程度上。其他角色必须谈论你，即使你没有和他们说话。
- 奈德·史塔克在第一季中死后仍然是最重要的角色之一。
- 与其说提利昂是丹妮莉丝的盟友，不如说他是兰尼斯特，这可能是他在最后一季背叛丹妮莉丝的原因，就像很多人推测的那样。他和兰尼斯特家的人是一伙的，在查看《乌云图》时，他和他们有很多相似之处，甚至比丹妮莉丝和琼恩还相似。
- 即使只有 60%的数据，我们也能得出很好的结论。
- 用这么小的数据集生成文本的效果比我预期的要好，读起来很有趣，不过还可以改进很多。
生成角色之间的对话将是一个有趣的挑战，你能想到什么方法吗？
你认为谁才是真正的主角？为什么呢？
利用这些数据，你还能得出什么结论？
用分析的每一步检查这个库这里。
介绍 TextBlob
用于处理文本数据的 Python 库，NLP 框架，情感分析
作为 Python 的 NLP 库， TextBlob 已经有一段时间了，在听说了很多关于它的好东西如词性标注和情感分析之后，我决定试一试，因此，这是我第一次使用 TextBlob 执行自然语言处理任务。
Yelp 数据集是其业务、评论和用户数据的子集，用于个人、教育和学术目的。作为 JSON 文件，我们将只使用yelp_academic_dataset_review.json和yelp_academic_dataset_user.json，并且可以从这里下载。
数据
数据集是 JSON 格式的，为了能够在 pandas 数据框架中读取，我们首先加载 JSON 数据，然后将半结构化的 JSON 数据规范化为一个平面表，然后使用to_parquet将该表写入二进制拼花格式。稍后当我们需要它时，我们从文件路径加载一个 parquet 对象，返回一个 pandas 数据帧。
下面的过程为我们提供了两个数据表，user 和 review。
JSON_parquet.py
user table
review table
我们合并用户表和评论表，用后缀来处理相同的列名，去掉零星号。
user_review = (review.merge(user, on='user_id', how='left', suffixes=['', '_user']).drop('user_id', axis=1))user_review = user_review[user_review.stars > 0]
星级分布
x=user_review['stars'].value_counts()
x=x.sort_index()
plt.figure(figsize=(10,6))
ax= sns.barplot(x.index, x.values, alpha=0.8)
plt.title("Star Rating Distribution")
plt.ylabel('count')
plt.xlabel('Star Ratings')
rects = ax.patches
labels = x.values
for rect, label in zip(rects, labels):
height = rect.get_height()
ax.text(rect.get_x() + rect.get_width()/2, height + 5, label, ha='center', va='bottom')
plt.show();
Figure 1
很高兴知道大多数评论星级相当高，并没有很多可怕的评论。显而易见，企业有一种动机去争取尽可能多的好评。
每年的评论与每年的星级
fig, axes = plt.subplots(ncols=2, figsize=(14, 4))
user_review.year.value_counts().sort_index().plot.bar(title='Reviews per Year', ax=axes[0]);
sns.lineplot(x='year', y='stars', data=user_review, ax=axes[1])
axes[1].set_title('Stars per year');
Figure 2
user_review.member_yrs.value_counts()
Figure 3
Yelp 成立于 2004 年，根据我们的数据，从那时起已经有超过 4000 人成为 Yelp 会员。
让我们来看一个示例评论:
review_sample = user_review.text.sample(1).iloc[0]
print(review_sample)
让我们检查一下这个样本评论的极性。极性范围从-1(最负)到 1(最正)。
TextBlob(review_sample).sentiment
上述评论的极性约为-0.06，意味着它略有负面，主观性约为 0.56，意味着它相当主观。
为了更快地进行，我们将从当前数据中抽取 100 万条评论，并添加一个新的极性列。
sample_reviews = user_review[['stars', 'text']].sample(1000000)def detect_polarity(text):
return TextBlob(text).sentiment.polaritysample_reviews['polarity'] = sample_reviews.text.apply(detect_polarity)
sample_reviews.head()
Figure 4
前几行看起来不错，星星和极性彼此一致，意味着星星越高，极性越高，就像它应该的那样。
极性分布
num_bins = 50
plt.figure(figsize=(10,6))
n, bins, patches = plt.hist(sample_reviews.polarity, num_bins, facecolor='blue', alpha=0.5)
plt.xlabel('Polarity')
plt.ylabel('Count')
plt.title('Histogram of polarity')
plt.show();
Figure 5
大多数极性得分都在零以上，这意味着数据中的大多数评论都是积极情绪，这符合我们之前发现的星级分布。
按星星分组的极性
plt.figure(figsize=(10,6))
sns.boxenplot(x='stars', y='polarity', data=sample_reviews)
plt.show();
Figure 6
总的来说，这和我们预期的一样好。让我们进行更深入的调查，看看我们是否能找到任何有趣的或异常的东西。
极性最低的评论:
sample_reviews[sample_reviews.polarity == -1].text.head()
星级最低的评论:
sample_reviews[sample_reviews.stars == 1].text.head()
它们看起来都像我们预期的负面评论。
极性最低(负面情绪最多)但有 5 颗星的评论:
sample_reviews[(sample_reviews.stars == 5) & (sample_reviews.polarity == -1)].head(10)
Figure 7
具有最高极性(最积极情绪)但只有一星的评论:
sample_reviews[(sample_reviews.stars == 1) & (sample_reviews.polarity == 1)].head(10)
Figure 8
两张桌子看起来都很奇怪。显然，一些极性与其相关评级不一致。这是为什么呢？
经过进一步挖掘，发现 TextBlob 会继续寻找可以赋予极性和主观性的单词和短语，并对较长的文本进行平均，例如我们的 Yelp 评论。
想了解 TextBlob 是如何计算极性和主观性的，Aaron Schumacher的这篇文章给出了简单而清晰的解释。
我喜欢学习和玩 TextBlob。我意识到 TextBlob 可以用来完成许多其他的 NLP 任务，比如词性标注、名词短语提取、分类、翻译等等，以后我们还会用到它们。
Jupyter 笔记本可以在 Github 上找到。享受这周剩下的时光吧！
参考资料:
书:算法交易的实践机器学习
使用 Python 在你的 Twitter 上玩得开心！
我用这个标题吸引了你的注意力吗？
不管怎样，我希望如此。
今天，我将在这里展示一些东西。第一，从你的 Twitter 个人资料中获取大量信息的惊人能力，以及你如何利用它来改善或提升你的在线形象。其次，展示一些强大的 Python 库，它们可以用来完成很多事情。
所以让我们开始吧！
为什么是推特？
最近我一直在疯狂发微博，因为现在是我的假期，我没有更好的事情可做。所以我注意到 Twitter，除了让我知道每条推文有多少赞和转发，还告诉我一些叫做的印象和约定。
参与度:在所选日期范围内，用户与您发送的推文互动的总次数。互动包括转发、回复、关注、喜欢和点击链接、卡片、标签、嵌入式媒体、用户名、个人资料照片或推文扩展。
浏览量:在所选日期范围内发送的推文的浏览量。印象是一条推文在用户的时间线或搜索结果中出现的次数。
不像脸书(公平地说，它确实为脸书网页提供了很好的分析和信息)、Instagram 和其他社交媒体，我更容易从自己的个人资料中获得大量数据。这还没有考虑到强大的 Twitter API，你可以利用它来洞察其他人的推文！
你可能会问，你所说的这些数据在哪里？
强大的 Twitter 分析——我是如何获得数据的！
正如那些试图将推文用于情感分析等目的的人所知，推文是一种非常有用的数据来源，可以用来进行操作和提取信息。正如我之前提到的，最明显的是情绪分析——试图确定一条推文在本质上是积极的，还是消极的，或者只是中性的。从该网站的巨大流量、每天积极发推文的人数，以及他们将推文放在公共领域并可以被拉取(你实际上可以将你的个人资料保密，但很少有人这样做)这一事实可以清楚地看出，人们可以使用这些推文来了解许多事情。通过利用 Twitter 的 API，你可以进行查询，比如在一段时间内提取某个主题的每条推文，或者提取某个用户的非转发推文。
在这个数据提取阶段，有很多方法可以获取推文。你可以利用 NLTK 库中的推文。您也可以使用 Twitter API 来提取推文，但是我想让这个阶段不那么麻烦。所以我决定只分析我自己的推文，我可以很快提取出来，因为 Twitter 对我们很好。
所以首先让我们看看 Twitter 在哪里为你很好地存储了这些信息！
首先进入菜单下的分析部分，如下所示:
它会把你重定向到一个特殊的页面，这个页面已经显示了很多信息。在最上方，它提供了您在过去 28 天内所做的事情，以及与当前时间段之前的 28 天相比，您的活动情况如何:
正如你所看到的，他们还提供了每个月的信息，你的热门推文，热门提及以及该月的信息摘要。
您还可以查看您的推文进展如何，以及您的推文进展情况的图表:
现在，我们如何从中提取信息，以便使用您常用的 Python 工具进行处理呢？谢天谢地，Twitter 有一个叫做“导出数据”的东西，它可以方便地将所有数据打包成一个漂亮的 CSV 文件，并打包到你的电脑上，你可以自由地打开盒子，做你想做的事情！点击你在那里看到的导出数据按钮，它将获取你希望分析的时间段内的所有推文，并以 CSV 文件的形式发送给你。
现在它将以这样的方式到达:
请注意，这里有很多参数或列是不可见的，比如赞数、转发数、参与度等等。但关键是，对于许多活动来说，获得一个好的数据集是一个挑战，但 Twitter 给了我们如此整洁有序的数据供我们使用。所以在这方面支持推特！
让我们将 Python 引入其中吧！
如果我说我是某种专家，那我是在撒谎:( 剧透，我不是！ )。但我将在这里做几件事，这表明任何人实际上都可以利用我们从我的个人资料中获得的推文做一些事情(也尝试利用你自己的个人资料，但要确保你有足够的推文来分析！).一件事是，我将使用一个名为 textblob 的 Python 库来查看我发出的推文类型，无论它们是正面的、负面的还是中性的。我要做的另一件事是查看哪些词是我经常使用的，并且在我的推文中很突出。为了增加乐趣，我可以用一种叫做“单词云”的东西以一种很酷的方式直观地呈现结果。你最终会明白为什么我对此感到兴奋。所以让我们开始吧！
先决条件:
我已经使用 Spyder (Anaconda)在这里编写了我的脚本，但是您总是可以使用 Python shell 本身或者编写代码并运行文件(我在这里的所有示例中都使用 Python3，因为为什么不这样做)。
您还需要一些库来开始(不要介意定义，它们主要是基于文档的指针:
a.textblob: TextBlob 是一个用于处理文本数据的 Python (2 和 3)库。它提供了一个简单的 API，用于处理常见的自然语言处理(NLP)任务，如词性标注、名词短语提取、情感分析、分类、翻译等。
b.matplotlib:Matplotlib 是一个 Python 2D 绘图库，它以各种硬拷贝格式和跨平台的交互环境生成出版物质量数字。Matplotlib 可用于 Python 脚本、Python 和 IPython 外壳、Jupyter 笔记本、web 应用服务器和四个图形用户界面工具包。
c.pandas: pandas 是一个开源的、BSD 许可的库，为 Python 编程语言提供高性能、易于使用的数据结构和数据分析工具。
d.wordcloud:顾名思义，你可以创建一个名字云，越常用的单词越突出显示。
对于 Ubuntu 用户，你可以使用 pip 或 pip3 来安装所有这些 Python 包，这就是我所做的:(用相关包替换包名)
pip install package-name
情绪分析时间！
建立自己的程序来做这件事不再那么困难了！随着 tweets 被整齐地排列，我所要做的就是改变 Tweets 部分下的列，在两个单词(Tweet_text)之间添加下划线，以避免程序中的空格出现错误。
导入所需的库:
import pandas as pd
from wordcloud import WordCloud, STOPWORDS
import matplotlib.pyplot as plt
现在，导入您需要的文件，该文件应该与您正在写入的 Python 文件在同一个文件夹中，使用 pandas 提供的 read_csv 函数将它读入一个名为 df 的变量。您可以使用不同的编码方案。
df=pd.read_csv(r"tweet_activity_metrics_TheCoolFanBoi_20181208_20190105_en.csv",encoding="latin-1")comment_words = ' ' #We will be appending the words to this varstopwords = set(STOPWORDS) #Finds all stop words in the set of tweets.for val in df.Tweet_text: val = str(val) #convert all tweet content into strings tokens = val.split() #Split all strings into individual components for i in range(len(tokens)): tokens[i] = tokens[i].lower() #Converts all the individual strings to lower case.for words in tokens: comment_words = comment_words + words + ' '
最后，这是 WordCloud 发挥作用的地方:
wordcloud=WordCloud(width=1000,height=1000, background_color='blue', stopwords=stopwords,min_font_size=10).generate(comment_words)
#All of this is a single line
请随意探索 WordCloud 功能的所有参数，并根据您的意愿进行调整。
最后，让我们使用 matplotlib 库将其显示为输出:
plt.figure(figsize=(10,10),facecolor=None)
plt.imshow(wordcloud)
plt.axis("off")
plt.tight_layout(pad=0)plt.show()
这是我保存这个文件并在 Python 上运行它时得到的结果:
诚然，不是最好的背景色，但你可以看到很多用不同字体突出显示的文字。请随意从我在推文中使用的词语来分析我的个性。虽然我只会说‘joelvzach’，‘pickle Hari’，‘pallavibiriyani’和‘guyandheworld’这些词都是 Twitter 的句柄:)
玩弄情绪分析
我不会在这里花太多时间，因为我和你们一样是新手。但是开始并不困难，这也是由于程序员在开发高效库方面所做的大量工作，这使得开始使用它变得更加容易。
你需要做的就是这个:
import pandas as pd
from textblob import TextBlob
df=pd.read_csv(r"tweet_activity_metrics_TheCoolFanBoi_20181208_20190105_en.csv",encoding="latin-1")#comment_words=' '
#stopwords=set(STOPWORDS)
print('Tweet | Polarity | Subjectivity')
for val in df.Tweet_text:
sentiments=TextBlob(val)
print('---------------')
print(val,end='')
print(' ',end='')
print(sentiments.polarity,end='')
print(' | ',end='')
print(sentiments.subjectivity)
你会得到这样的输出:
这些是我的推文，以及我的推文在情绪方面的评分，从-1(最负面)到 1(最正面)。这也显示了我的陈述在 0 到 1 的范围内是多么的主观。
你一定在想，坐在这里，自然语言处理？Pfft。我可以做到。
**但是这里有一个问题:**我们只是在一个非常高层次和抽象的方式上玩它。我们考虑过如何计算一条推文的情感或主观性吗？我们用了什么算法来遍历文本？诸如此类。
这是 textblob 库的奇迹。如果你想更深入地了解这一点，我不会把它添加到文章中，但是请查看这篇文章作为 textblob 文档的一部分，它告诉我们这个函数是如何工作的，以及它如何利用朴素贝叶斯算法进行情感分析。
这结束了我的短文，让我先睹为快，看看我最近都做了些什么(很明显，没什么好事)。一定要看看我的推特(因为我已经展示了很多)，并在我继续发推特的时候抓住我，因为为什么不呢，对吗？代码在这里。
还要感谢所有使用的库的文档以及 GeeksForGeeks 为我完成这篇文章提供了很好的材料。
谢谢你读完这篇文章！
HBase 工作原理:Hadoop 架构的一部分
Hadoop 中 HBase 工作的简要总结
1.感应
HBase 是一个高可靠性、高性能、面向列、可扩展的分布式存储系统，使用 HBase 技术在廉价的 PC 服务器上构建大规模结构化存储集群。HBase 的目标是存储和处理大量数据，特别是仅使用标准硬件配置来处理由成千上万行和列组成的大量数据。
不同于 MapReduce 的离线批量计算框架，HBase 是随机存取存储和检索数据平台，弥补了 HDFS 不能随机存取数据的缺点。
它适用于实时性要求不是很高的业务场景——h base 存储字节数组，不介意数据类型，允许动态、灵活的数据模型。
Hadoop Ecosystem (Credit: Edureka.com)
上图描绘了 Hadoop 2.0 生态系统的各个层，即位于结构化存储层的 Hbase。
HDFS 为 HBase 提供高可靠性的底层存储支持。
MapReduce 为 HBase 提供了高性能的批处理能力。ZooKeeper 为 HBase 提供稳定的服务和故障转移机制。Pig 和 Hive 为数据统计处理提供了 HBase 的高级语言支持，Sqoop 为 HDB 提供了可用的 RDBMS 数据导入功能，使得业务数据从传统数据库迁移到 HBase 非常方便。
2。HBase 架构
2.1 设计思路
HBase 是一个分布式数据库，使用 ZooKeeper 管理集群，HDFS 作为底层存储。
在架构层面，由 h master(Zookeeper 选出的领袖)和多个 HRegionServers 组成。
底层架构如下图所示:
在 HBase 的概念中，HRegionServer 对应集群中的一个节点，一个 HRegionServer 负责管理多个 HRegion，一个 HRegion 代表一个表的一部分数据。
在 HBase 中，一个表可能需要很多 HRegion 来存储数据，每个 h region 中的数据并不是杂乱无章的。
HBase 在管理 HRegion 时，会为每个 HRegion 定义一个 Rowkey 的范围。属于定义范围内的数据将被移交给特定的区域，从而将负载分布到多个节点，从而利用了分布式和特性的优势。
此外，HBase 会自动调整区域的位置。如果某个 HRegionServer 过热，即大量请求落在由 HRegionServer 管理的 HRegion 上，HBase 会将 HRegion 移动到其他相对空闲的节点上，确保集群环境得到充分利用。
2.2 基础架构
HBase 由 HMaster 和 HRegionServer 组成，同样遵循主从服务器架构。HBase 将逻辑表划分为多个数据块 HRegion，并存储在 HRegionServer 中。
HMaster 负责管理所有的 HRegionServers。它本身不存储任何数据，只存储数据到 HRegionServer 的映射(元数据)。
集群中的所有节点都由 Zookeeper 协调，并处理 HBase 操作期间可能遇到的各种问题。HBase 的基本架构如下所示:
客户端: 使用 HBase 的 RPC 机制与 HMaster 和 HRegionServer 进行通信，提交请求并获取结果。对于管理操作，客户端使用 HMaster 执行 RPC。对于数据读写操作，客户端使用 HRegionServer 执行 RPC。
Zookeeper: 通过向 Zookeeper 注册集群中各个节点的状态信息，HMaster 可以随时感知各个 HRegionServer 的健康状态，也可以避免 HMaster 的单点问题。
HMaster: 管理所有的 hregionserver，告诉他们哪些 hregionserver 需要维护，监控所有 hregionserver 的健康状况。当一个新的 HRegionServer 登录到 HMaster 时，HMaster 告诉它等待分配数据。当一个 HRegion 死亡时，HMaster 将其负责的所有 h region 标记为未分配，然后将它们分配给其他 HRegionServers。HMaster 没有单点问题。HBase 可以启动多个 HMasters。通过 Zookeeper 的选举机制，集群中始终有一个 HMaster 在运行，提高了集群的可用性。
HRegion: 当表格的大小超过预设值时，HBase 会自动将表格分成不同的区域，每个区域包含表格中所有行的子集。对于用户来说，每个表都是一个数据集合，由一个主键(RowKey)来区分。在物理上，一个表被分成多个块，每个块都是一个 HRegion。我们使用表名+开始/结束主键来区分每个 HRegion。一个 HRegion 会在一个表中保存一段连续的数据。一个完整的表数据存储在多个 HRegions 中。
**HRegionServer:**h base 中的所有数据一般从底层开始存储在 HDFS。用户可以通过一系列 HRegionServers 获取这些数据。一般情况下，集群的一个节点上只运行一个 HRegionServer，每个段的 HRegionServer 只由一个 HRegionServer 维护。HRegionServer 主要负责向 HDFS 文件系统读写数据，以响应用户的 I/O 请求。它是 HBase 中的核心模块。HRegionServer 在内部管理一系列 HRegion 对象，每个 HRegion 对应逻辑表中的一个连续数据段。HRegion 由多个 HStores 组成。每个 HStore 对应于逻辑表中一个列族的存储。可以看出，每个列族都是一个集中的存储单元。因此，为了提高操作效率，最好将具有相同 I/O 特征的列放在一个列族中。
HStore: 它是 HBase 存储的核心，由 MemStore 和 StoreFiles 组成。MemStore 是一个内存缓冲区。用户写的数据会先放入 MemStore。当 MemStore 满时，Flush 将是一个 StoreFile(底层实现是 HFile)。当 StoreFile 文件数量增加到一定阈值时，会触发紧凑合并操作，将多个 StoreFile 合并为一个 store file，并在合并过程中执行版本合并和数据删除操作。所以可以看出，HBase 只是添加数据，所有的更新和删除操作都在后续的压缩过程中进行，这样用户的写操作一进入内存就可以返回，保证了 HBaseI/O 的高性能，当 StoreFiles 压缩后，会逐渐形成越来越大的 StoreFile。当单个存储文件的大小超过某个阈值时，将触发拆分操作。同时，当前 hre region 将被拆分为 2 个 hre region，父 hre region 将下线。这两个子区域由 HMaster 分配给相应的 HRegionServer，这样原 HRegion 的负载压力就分流到这两个 HRegion 上了。
HLog: 每个 HRegionServer 都有一个 HLog 对象，这是一个预先编写的日志类，实现预写日志。每当用户向 MemStore 写入数据时，它也向 HLog 文件写入数据的副本。HLog 文件被周期性地滚动和删除，旧文件被删除(已经被持久化到 StoreFile 的数据)。当 HMaster 检测到某个 HRegionServer 被 Zookeeper 意外终止时，HMaster 首先处理遗留 HLog 文件，拆分不同 HRegion 的 HLog 数据，放入对应的 HRegion 目录，然后重新分配无效的 HRegion。在加载 HRegion 的过程中，这些 h region 的 HRegionServer 会发现有历史 HLog 需要处理，所以 Replay HLog 中的数据会被转移到 MemStore，然后刷新到 StoreFiles，完成数据恢复。
2.3 根和元
HBase 的所有 HRegion 元数据都存储在. META .表中。随着 HRegion 的增加。元表也增加并分裂成多个新的 HRegions。
中每个 HRegion 的位置。中所有 HRegions 的元数据。元表存储在根表中，最后根表的位置信息由 Zookeeper 记录。
在所有客户端访问用户数据之前，它们需要首先访问 Zookeeper 以获得-ROOT-的位置，然后访问-ROOT-table 以获得。元表，最后根据元表中的信息确定用户数据的位置，如下:如图所示。
根表永远不会被分割。它只有一个 HRegion，这保证了任何 HRegion 只需三次跳转就可以定位。为了加快访问速度。元表保存在内存中。
客户端缓存查询到的位置信息，缓存不会主动失效。如果客户端仍然不能访问基于缓存信息的数据，则向区域服务器询问相关的。元表来尝试获取数据的位置。如果仍然失败，询问。与根表相关联的元表是。
最后，如果前面的信息全部无效，那么 HRegion 的数据由 ZooKeeper 重新定位。因此，如果客户机上的缓存完全无效，您需要来回六次才能获得正确的 HRegion。
3.HBase 数据模型
HBase 是一个类似于 BigTable 的分布式数据库。它是稀疏的长期存储(在 HDFS 上)，多维的，排序的映射表。这个表的索引是行关键字、列关键字和时间戳。HBase 数据是一个字符串，没有类型。
把一个表想象成一个大的映射。可以通过行键、行键+时间戳或行键+列(列族:列修饰符)来定位特定数据。因为 HBase 稀疏地存储数据，所以一些列可以是空白的。上表给出了 com.cnn.www 网站的逻辑存储逻辑视图。表格中只有一行数据。
该行的唯一标识符是“com.cnn.www”，并且该行数据的每次逻辑修改都有一个时间。该戳记对应于相应的。
表格中有四列:contents: HTML，anchor:cnnsi.com，anchor:my.look.ca，mime: type，每一列给出它所属的列族。
行键(row key)是表中数据行的唯一标识符，用作检索记录的主键。
在 HBase 中，只有三种方法可以访问表中的行:通过行键访问、给定行键的范围访问和全表扫描。
行键可以是任何字符串(最大长度为 64KB ),并按字典顺序存储。对于经常一起读取的行，需要仔细设计基本值，以便它们可以集中存储。
4.HBase 读写过程
下图是 HRegionServer 数据存储关系图。如上所述，HBase 使用 MemStore 和 StoreFile 来存储对表的更新。数据在更新时首先被写入 HLog 和 MemStore。MemStore 中的数据被排序。
当 MemStore 累积到某个阈值时，将创建一个新的 MemStore，旧的 MemStore 将被添加到刷新队列中，一个单独的线程将被刷新到磁盘，成为 StoreFile。同时，系统会在 Zookeeper 中记录一个检查点，表示这个时间之前的数据更改已经被持久化。当意外系统发生时，MemStore 中的数据可能会丢失。
在这种情况下，HLog 用于恢复检查点之后的数据。
StoreFile 是只读的，一旦创建就不能修改。因此，HBase 的更新是一个额外的操作。当存储中的 StoreFile 达到某个阈值时，执行合并操作，合并对同一键的修改以形成一个大的 StoreFile。当存储文件的大小达到某个阈值时，存储文件被分割并分成两个存储文件。
4.1 写操作流程
*第一步:*客户端通过 Zookeeper 的调度向 HRegionServer 发送写数据请求，将数据写入 HRegionServer。
*第二步:*将数据写入 HRegion 的 MemStore，直到 MemStore 达到预设的阈值。
*第三步:*将 MemStore 中的数据刷新到 StoreFile 中。
步骤 4: 随着 StoreFile 文件数量的增加，当 StoreFile 文件数量增加到一定阈值时，触发紧凑合并操作，将多个 StoreFile 合并为一个 store file，同时进行版本合并和数据删除。
第五步: StoreFiles 通过不断的压缩操作，逐渐形成一个越来越大的 StoreFile。
*第六步:*当单个 StoreFile 的大小超过一定阈值后，触发拆分操作，将当前的 HRegion 拆分成两个新的 HRegion。父 HRegion 将脱机，新拆分的两个子 HRegion 将由 HMaster 分配给相应的 HRegionServer，以便将原 HRegion 的压力分流到这两个 HRegion。
4.2 读取操作流程
步骤 1: 客户端访问 Zookeeper，找到-ROOT-table，获取. META. table 信息。
*第二步:*从. META. table 中查找获取目标数据的 HRegion 信息，找到对应的 HRegionServer。
*第三步:*通过 HRegionServer 获取需要查找的数据。
*第四步:*HRegionserver 的内存分为两部分:MemStore 和 BlockCache。MemStore 主要用来写数据，BlockCache 主要用来读数据。先读取请求到 MemStore 检查数据，检查 BlockCache 检查，然后检查 StoreFile，将读取结果放入 BlockCache。
5.HBase 使用场景
*半结构化或非结构化数据:*对于没有很好定义或者杂乱的数据结构字段，很难按照一个适合 HBase 的概念提取数据。如果随着业务的增长存储了更多的字段，RDBMS 需要停机来维护变更表结构，HBase 支持动态添加。
*记录非常稀疏:*RDBMS 行有多少列是固定的，空列浪费存储空间。不存储 HBase 为空的列，这样可以节省空间并提高读取性能。
*多版本数据:*根据行键和列标识符定位的值可以有任意多个版本值(时间戳不同)，所以对于需要存储变更历史的数据，使用 HBase 非常方便。
*数据量大:*当数据量越来越大时，RDBMS 数据库撑不住了，就有了读写分离策略。通过一个主设备负责写操作，多个从设备负责读操作，服务器成本翻倍。压力越来越大，师傅撑不住了。这时候库就分了，关联度不大的数据单独部署。有些连接查询无法使用，需要使用中间层。随着数据量的进一步增加，一个表的记录变得越来越大，查询变得非常慢。
因此，有必要将表划分成多个表，例如，通过将 ID 取模来减少单个表的记录数量。经历过这些事情的人都知道怎么折腾过程。
HBase 很简单，只需在集群中增加新的节点，HBase 就会自动水平拆分，与 Hadoop 的无缝集成保证了数据的可靠性(HDFS)和海量数据分析的高性能(MapReduce)。
6.h 基线图减少
HBase 中表和区域的关系有点类似于 HDFS 中文件和块的关系。由于 HBase 提供了与 MapReduce 交互的 API，如 TableInputFormat、TableOutputFormat 等，HBase 数据表可以直接作为 Hadoop MapReduce 的输入输出，方便了 MapReduce 应用的开发，并且不需要关注 HBase 系统本身细节的处理。
如果你喜欢这个主题，你可以看看我写下的关于 Hadoop 的其他几个主题。
如果您发现任何错误或有任何建议，请随时通过我的 LinkedIn 联系我。
[## Apache Hadoop 小结:大数据问题的解决方案和来自 Google 的提示
欢迎学习大数据和 Hadoop 简介，我们将在这里讨论 Apache Hadoop 以及如此大的问题…
towardsdatascience.com](/a-brief-summary-of-apache-hadoop-a-solution-of-big-data-problem-and-hint-comes-from-google-95fd63b83623) [## Hadoop 中的新特性:你应该知道 Hadoop 中的各种文件格式。
Hadoop 文件格式初学者指南
towardsdatascience.com](/new-in-hadoop-you-should-know-the-various-file-format-in-hadoop-4fcdfa25d42b)
PyTorch 的 HDF5 数据集
如果你从事计算机视觉领域的工作，你肯定听说过 HDF5。分层数据格式 (HDF)第 5 版是一种流行的格式，用于存储和交换非结构化数据，如 raw 格式的图像、视频或卷，以用于各种研究或开发领域。它受到许多编程语言和 API 的支持，因此变得越来越流行。这也适用于为机器学习工作流程中的存储数据。在这篇文章中，我介绍了一种在 PyTorch 中使用 HDF5 数据训练深度学习算法的可能方法(包括即用型代码)。
HDF5 文件格式
HDF5 文件由**两种主要类型的对象组成:**数据集和组。数据集是同构类型的多维数组，例如 8 位无符号整数或 32 位浮点数。另一方面，组是为保存数据集或其他组而设计的层次结构，构建了类似文件系统的数据集层次结构。此外，组和数据集可能会附加用户定义属性形式的元数据。
Python 使用 h5py 包支持 HDF5 格式。该软件包封装了原生 HDF C API，并支持该格式的几乎全部功能，包括读写 HDF5 文件。
如果你需要在可视化编辑器中查看或编辑你的 HDF5 文件，可以下载官方 HDFView 应用。该应用程序支持以表格方式或图像方式查看不同格式的数据集。此外，它使您能够通过创建新的组和数据集以及重命名和移动现有的组和数据集来编辑文件。
PyTorch 数据集
为了高效地将您的数据加载到 PyTorch，PyTorch 要求您编写自己的 Dataset 类(或者使用预定义的类)。这是通过从torch . utils . data . Dataset继承，覆盖函数 len (以便在数据集上调用 len()返回数据集的长度)和 getitem (启用索引)来实现的。
然后使用类torch . utils . data . data loader以预定义的方式从数据集中进行采样(例如，您可以随机打乱数据集，选择批量大小等)。PyTorch 中数据加载的主要优势(和魔力)在于这样一个事实，即数据加载可以以并行方式发生，而无需处理多线程和同步机制。这可以通过简单地将 DataLoader 构造函数中的参数 num_workers 设置为所需的线程数量来实现。作为在 PyTorch 中使用 Dataset 和 DataLoader 类的示例，请看下面的代码片段，它展示了如何在您的程序中使用 HDF5 数据集。我们将在下一节中研究如何实际实现数据集。
HDF5 数据集类
我设计 HDF5 数据集类时考虑了多个目标:
- 使用包含 HDF5 文件的文件夹(包括子文件夹)作为数据源，
- 在数据集中维护一个简单的 HDF5 组层次结构，
- 启用惰性数据加载(即应数据加载器的请求)为了允许处理不适合存储器的数据集，
- 维护数据缓存以加快数据加载过程，以及
- 允许数据的自定义转换。
我决定在数据集上实施一个简单的结构，该结构由放置在不同组中的各个数据集组成，如下所示:
这反映了许多机器学习任务的通常数据结构。通常，每个组中都有一个包含数据的数据集，以及一个或多个包含标签的数据集。例如，用于图像分割的数据集可能包括要分割的图像(一个数据集)以及地面实况分割(另一个数据集)。这些标签被放在一个组中，以便确定哪些标签属于哪些数据。此外，可以通过将不同类型的数据放置在不同的 HDF5 文件中来构建更高级别的语义层次(例如，由不同用户执行的分段)。
事不宜迟，下面是实际代码:
如您所见，数据集通过搜索目录(和子目录)中的所有 HDF5 文件进行初始化，并构建一个 data_info 结构，其中包含有关每个数据块的信息，例如它来自哪个文件、它的类型(在本例中为“数据”或“标签”，但您可以定义其他文件)及其形状。形状通常有助于确定数据集的大小，因此它是需要存储的重要信息。此外，对于每个块，我们还存储其数据缓存索引。如果数据当前已加载，则索引≥0，如果尚未加载，则索引为-1。
如果数据加载器现在请求一些数据，则调用 getitem 函数，该函数又调用 get_data 函数。注意，在这里我们不能只索引某个数组，因为我们首先必须确保数据确实在内存中。因此，在 get_data 中，我们查找缓存以找到数据，或者，如果数据不在缓存中，我们加载它并将其返回给调用者。这发生在 _load_data 函数中，该函数做两件事:加载数据并将其添加到缓存中，如果超过了 data_cache_size ，则从缓存中移除随机的数据块。
获得数据后，必须根据您在构造函数中提供的转换对其进行转换，并将其转换为 torch。张量类型。
结论
在这篇文章中，我展示了一个简单但功能强大的 HDF5 数据集类，您可以使用它在 PyTorch 中加载 HDF5 数据集。我希望它对你有用。如果您有任何问题或进一步的建议，请不要犹豫，在下面留言。
HDR 影像:到底什么是 HDR 影像？
关于 HDR 成像的一切。
你可能已经注意到，以太阳(或任何明亮的物体)为背景拍摄图像通常效果不佳。根据焦点的不同，图像不是太暗就是太亮。让我们试着理解为什么会发生这种情况，以及如何解决这个问题。
在我们开始之前，我建议你看看我播客中的一个片段，我们在这里讨论了计算摄影和 HDR 成像的现状。
围绕 HDR 图像的研究有很多关键概念-
- 动态范围
- 图像曝光
- 快门速度、光圈、ISO
- 图像包围
- 合并 LDR 图像
- 图像编码
- 相机响应功能
- 线性化
- 伽马校正
- 色调映射
- 可视化 HDR 图像
动态量程
场景的动态范围是指包围场景的光强度的范围。它也可以定义为图像中亮(最大可测量亮度)与暗(最小可测量亮度)的比率。
为了了解亮度如何被量化，光强度的范围是从 0 到无穷大，零是最暗的，无穷大是最亮的光源(☀️)。
Luminance value comparison (Source)
没有相机能够捕捉场景中这种完全无上限的照明范围。因此，图像要么太亮(曝光过度)，要么太暗(曝光不足)。这些图像被称为低动态范围 (LDR)图像。对于变得太亮的图像，相机只能捕捉(无限范围的)较亮的子范围，相应地，对于较暗的图像，只能捕捉较低的子范围。
True image (Left), Overexposed image (Center), Underexposed image (Right)
**图像曝光:**进入相机的光量(以及图像)称为曝光。图像的曝光可以通过相机的三个设置来控制——光圈、快门速度和 ISO。
**光圈:**相机镜头上光线可以进来的区域。
**快门速度:**相机快门关闭的速度。随着快门速度的增加，进入相机的光量减少，反之亦然。它还提高了图像的清晰度。
ISO: 相机传感器对入射光的灵敏度。
我在这里找到了这个很好的类比，在相机设置和一个留在雨中的水桶之间。
在摄影中，光圈、快门速度和 ISO 速度的曝光设置类似于上面讨论的宽度、时间和数量。此外，正如上面的降雨率超出了你的控制，自然光对于摄影师来说也是如此。
回到动态范围。从照相机捕获的单个图像不能包含宽范围的光强度。
这个问题可以通过合并在多个曝光值下捕获的图像来解决。这样做的好处是，曝光过度的图像对图像中较暗的区域效果很好，曝光不足的图像能够降低超亮区域的亮度。在不同的曝光值下，图像的不同区域被更好地捕捉。因此，想法是合并这些组图像，并恢复具有高动态范围 (HDR)的图像。
图像包围
包围是指用不同的相机设置捕捉同一场景的多个图像。这通常由照相机自动完成。当你在智能手机上使用 HDR 功能时，手机会在三个不同的曝光时间(或曝光值)快速连续拍摄三张(通常)图像。曝光时间越短，进入的光线就越少。相机软件将这三幅图像合并，并保存为一幅图像，以使每幅图像的最佳部分成为最终图像。
A collage of 5 bracketed images that I found on the internet.
有趣的是，合并后保存在手机上的图像仍然不是(技术上)HDR 图像。这就是图像编码进入画面的地方(还有色调映射，我们将在后面讨论)。
图像编码
通常，我们在手机和电脑上看到的图像是 8 位(每通道)编码的 RGB 图像。每个像素的值使用 24 位表示存储，每个通道(R，G，B)8 位。像素的每个通道都有 0-255 个亮度值。
Example of 24-bit (3x8-bit) encoding for an RGB pixel
这种编码的问题是它不能包含自然场景的大动态范围。它只允许 0–255(仅整数)的范围来适应强度范围，这是不够的。
为了解决这个问题，每个通道都使用 32 位浮点数对 HDR 图像进行编码。这使得我们能够捕捉到大范围的 HDR 图像。书写 HDR 图像有多种格式，最常见的是。所有 hdr 图像都是 32 位编码，但并非所有 32 位图像都可以是 HDR 图像。
相机响应函数
CRF 是显示实际场景辐照度和图像中数字亮度值之间关系的函数。它也被称为光电传递函数。相机公司不提供他们的 CRF，并认为这是专有信息。
Camera response function example
在理想情况下，CRF 应该有一个线性图形，也就是说，图像中像素的亮度值应该与场景中的实际辐照度成正比。这对于 HDR 图像来说是正确的，但是对于通常的图像来说不是这样，在通常的图像中，亮度值被改变以能够将它们包含在有限的范围内。传统图像去线性化的更重要原因取决于显示设备的工作方式。
回到 CRT(阴极射线管)显示器时代，电子是在磷光体表面发射的。众所周知，荧光屏在被加速的电子撞击时会发射光子。然而，显示器的亮度并不随着电子束的强度而线性变化。这个问题已经通过在与显示器的非线性相反的方向上非线性地修改输入的图像/视频源信号而得到解决。通过这样做，我们可以获得自然场景亮度的合理线性估计。
源的这种非线性化允许补偿非线性显示。显示技术已经进步，但是非线性仍然存在于大多数设备中。这种去线性化被称为伽马校正。
伽玛校正图像=图像^ γ
如果输入图像是 x，那么伽马=1.2 的显示设备显示的是 x^(1.2).因此，输入图像被编码为 x^(1/1.2 ),以便监视器将其转换为 x^((1/1.2(×1.2 ),它等于摄像机捕获的原始图像 x。
对于目前的大多数显示器来说，图像必须用 0.45 (1/2.2)的伽马值进行编码，因为显示器的伽马解码为 2.2。
伽马编码在[0，1]的范围内执行。因此，图像首先必须通过除以 255 进行归一化，然后在伽马运算后再次乘以 255。大于 1 的放大率产生较暗的图像，而小于 1 的放大率产生较亮的图像。
Comparison between gamma encoded images
HDR 摄影(或任何摄影)非常复杂，我们需要考虑三个重要方面
- 实际场景如何(地面实况/无上限动态范围)
- 相机如何捕捉(包围然后合并)
- 显示方式(色调映射)
在 HDR 成像的背景下，我们已经讨论了前两点。现在让我们看看 HDR 图像是如何显示的。
色调映射
大多数现成的显示设备不能传送大范围的无上限的 HDR 图像。他们期望输入源为三通道 24 位(3x8) RGB 格式。由于这个原因，宽动态范围需要降低，以便能够适应 RGB 格式的 0–255 范围。这可以通过几种方式实现，其中一些是-
- 常规线性归一化:这是降低 HDR 图像宽范围的最基本方法。
色调映射图像=(img—img . min()/img . max()—img . min())x 255
- 赖因哈德色调映射:这是在这篇论文中分享的最常用的色调映射算法之一。
色调映射图像= img/(1+img) x 255
- Drago 色调映射:这是一个基于感知的色调映射器，它使用对数函数压缩动态范围，“使用场景内容的不同基底计算”。这方面的论文可以在这里找到。
你自找的
Results
生成 HDR 内容的持续研究
生成 HDR 内容的传统方法是通过合并在不同曝光下捕获的多个图像(包围)。然而，当帧之间存在运动时，这种方法可能会产生重影(模糊)假象。这个问题已经解决了，首先使用所谓的光流将相邻帧与参考帧(中间帧)对齐。这可以是另一篇博客文章的主题，但现在我们可以将其视为一种通过将位移向量分配给特定像素位置来估计跨帧发生的对象(或像素)运动的方法。
也有使用深度学习从单一 LDR 对应物生成 HDR 框架的工作。神经网络能够成功地学习输入和输出之间的复杂表示，并且因此在学习 LDR 到 HDR 映射中表现得相当好。这些是从单幅图像生成 HDR 图像的一些最先进的方法—
- HDRCNN: 使用深度 CNN 从单次曝光中重建 HDR 图像
- 使用基于 LDR 学习的深度逆色调映射来估计具有绝对亮度的 HDR 图像
- ExpandNet:用于从低动态范围内容进行高动态范围扩展的深度卷积神经网络
这里有一些最先进的基于深度学习的方法，用于使用多个 LDR 图像生成 HDR 图像—
- 动态场景的深高动态范围成像
- AHDRNet: 用于无重影高动态范围成像的注意力引导网络
[## 论文综述——用于无重影高动态范围成像的注意力引导网络
“你只是想要关注，你不想要我的心”——查理·普斯
towardsdatascience.com](/paper-review-attention-guided-network-for-ghost-free-high-dynamic-range-imaging-4df2ec378e8)
如何查看 HDR 图片
HDR 图像存储为亮度图，而不是传统的 RGB 图像，因此不能使用常见的图像查看应用程序进行查看。
MacOS 允许您查看。hdr 和。使用预览和查找应用程序的 exr 文件。你也可以使用 OpenHDR 网站来可视化这些图像。
感谢阅读。
在以后的博客文章中，我将讨论如何使用 Python、OpenCV 和 Numpy 对 HDR 图像进行操作。我也想分享目前正在进行的 HDR 视频生成的研究。
使用医疗索赔数据进行预测分析的 3 个工具
Photo by Adhy Savala on Unsplash
一位高中英语老师告诉我，以“字典对 XYZ 的定义是:”开始一篇论文通常证明是一个没有洞察力的介绍，我担心以“医疗保健有重要的未开发的数据机会”开始这篇文章可能会同样失败。然而，就现有的大量数据而言，很难高估这个领域中未回答和未提出的问题。
除了日益完善的健康状态监控和电子健康记录数据集之外，公共和私有数据集中还有数十亿行医疗保健索赔数据，这些数据通常质量非常高。这篇文章快速介绍了医疗保健索赔数据的工作原理(结构、用途、困难)，提出了使用数据的 3 个通用框架。
索赔表上的信息
医疗保健索赔有三种形式:医生、医疗机构和零售药店。每个表单都有许多共同的特征，包括成员身份(姓名、出生日期、保险卡号码等)。)、提供商信息(国家提供商 ID )、税务 ID 号等。)，以及服务日期。医生和机构索赔还包含多个描述病情/症状的 ICD-10 诊断代码—机构索赔允许 20 个以上的诊断代码，但实际上 3 个诊断代码包含了两种索赔类型的大部分可用信息。医生和机构声明还包含一个 AMA 服务地点代码，用于描述提供服务的机构类型(即急诊室、紧急护理机构、医生办公室等)。).
3 种索赔类型的独特特征反映了每种类型的提供者如何获得报酬(至少一般来说，从历史上看，像所有医疗保健一样，有细微差别、最近的变化和未来的计划；请始终记住这一点，因为尽可能多地重复这一点会非常乏味。
医生按服务付费——每个程序(检查、抽血、外科手术等)。)有一个美元金额，最终付款是所有这些过程的美元金额的总和。医生报销单使用 CPT 代码列出每项独特的服务。CPT 代码是 5 位字母数字代码，用于描述医生可以执行的每项独特服务，唯一代码分配给相似类型的程序，这些程序对于常见程序具有不同的严重程度。
设施(医院、独立实验室、门诊手术中心等。)相比之下，使用更高级的视图来支付。你可以想象，将住院期间护士在你房间停留的所有时间制成表格会变得很乏味，因此医院会收取“食宿”费用，即躺在病床上所涉及的一切费用。收入代码— 4 位数字(通常包含前导零)—捕获住院期间包含的每项独特的高级服务，如手术室程序、物理治疗、分娩室/分娩等。).此外，使用 ICD10 程序代码捕获特定的重要程序，如移植或动脉旁路，更常见的程序使用医生声明中使用的相同 CPT 代码集。 DRG 代码是在单个代码中总结住院天数的第三个字段。
药店的声明很简单(但通常包含大量的预测信息)——它们只是列出处方药物(使用 NDC 编号)、数量和供应天数。
总之，下面列出了可用的关键字段。在实践中，至少有 3 倍以上的领域在发挥作用，但出于介绍性讨论的目的，这些是大的。
尽管具体情况有所不同，但在数据库构建索赔数据的方式上有着广泛的相似性。通常使用两个事实表——“标题”表存储每个索赔只有一个值的字段，如会员/提供商、服务日期和所有诊断代码,“详细”表存储每个索赔可能有多个值的字段，如 CPT、收入和 NDC 代码。数据库中的附加表格可以提供代码的描述。
虽然索赔数据通常相对干净，但这种结构以及数据所描述的事件和患者特征的临床复杂性需要大量的预处理工作。已经构建了多种方法来平衡在用最少的工作获得易于分析的数据和保存临床复杂性信息的数据之间的权衡。概括地说，有 3 个主要工具:分级条件类别(HCC)编码、事件分组器和基于临床的特征构建。我们将在下面讨论每种方法的优缺点。
工具 1: HCC 车型
HCC 编码是一种广泛使用的技术，尤其是在风险评分算法中。风险评分模型为个人分配一个数字来描述他们的“风险”，这通常意味着预测的索赔成本，但也可以表示临床管理或其他特征的机会。医疗保险优势系统(Medicare Advantage system)、ACA 个人交换(ACA Individual Exchanges)和许多州管理的医疗补助计划(Medicaid programs)使用基于 HCC 的风险调整模型来产生风险评分——尽管具体情况有很大不同，但总体思路是通过量化参加健康计划的个人的相对发病率，相应的收入转移可以确保所有保险公司的公平竞争。
HCC 模型通常通过列举基于 ICD-10 诊断代码和/或药房处方的存在将个体分配到的条件类别来工作。每个类别可以分配一个权重，个人的总得分是类别级别权重的组合。这些模型通常严重依赖个体诊断代码来量化患者的状况，并将可用信息大量总结为 20-50 个类别。他们可以捕捉大量的信息，这些信息可以很容易地快速分析，但是他们也可能遗漏很多信息。例如，高血压或二型糖尿病等疾病如果得到适当的管理，可能不会显著增加风险，但如果不加以管理，可能会导致风险显著增加——简单地量化这些疾病的存在忽略了这一现实。
一种更普遍的分析方式是将其他类型代码的出现(不仅仅是风险评分模型中常用的诊断/药物代码)视为虚拟变量，可能还包括基于频率或时间的变量。这在特征工程中很有帮助，可以快速生成成千上万的组合，并识别与特定分析相关的较小代码集。需要特别注意的是，当许多字段合并在一起时，数据可能会变得非常分散，更高级别的相关性可能会变得模糊不清。例如，无论服务地点或 CPT 代码如何，HIV/AIDS 诊断可能都很重要，但是将该诊断分成几个不同的类别可能会隐藏这一点。
工具 2:事件分组器
事件分组器试图捕捉 HCC 模型中不存在的细微差别，方法是将许多行和字段的数据汇总到由自定义 s 描述的单个事件行中，这种扁平格式可以使跨字段和单独行的数据中的相关性更容易访问。
我查阅的一份 35x19 的索赔数据表可以总结为下面的故事:“患者去了他的医生办公室，在那里对心脏植入装置进行评估。可能在这次访问中提到，患者在同一天去了急诊室。在 8 天的住院期间，患者出现呼吸急促，并接受了胸部 x 光检查和“呼吸服务”作为回应。诊断代码非常准确地告诉我们患者心脏相关状况的范围，以及营养不良的情况”。
大规模地构造这些算法是棘手的，尽管最初如何解决这个问题的想法并不难形成。大规模变得棘手，因为医疗护理是棘手的——相同的程序可以实现不同的结果，相同的诊断可能是低风险或高风险，取决于管理和合并症，诊断可能在短期和长期内有不同的表现，等等。
由于这些的复杂性，有一系列被称为“情节分组器”的商业算法来执行这种总结。这些算法的工作方式有很大的差异，因为提供商、保险公司、公共政策研究人员和其他用户可能都对不同风格的故事线感兴趣。
即使有一个精心设计的事件分组器，您的数据也不容易描述整个患者——捕获频率或时间线信息可能依赖于类似于 HCC 建模地层的技术，但仍然有限。基于临床的模型试图解决这个问题。
工具 3:基于临床的模型
为了充分利用索赔数据(像所有数据一样)，大量的领域知识是必要的，但是这里的领域知识通常是通过医学博士教育和多年的临床经验获得的——不是你可以在一个周末自学的那种东西。这一现实在基于临床的模型中尤其明显，这些模型使用临床定义的算法来识别特征。例如，用于识别可能导致住院的心力衰竭患者(因为并非所有心力衰竭都是慢性的)的规则可能具有基于处方的填充组合、具有不同诊断或 DRG 代码的住院、具有特定程序或诊断的多个门诊事件以及上述各项的组合的规则。
这种逻辑在提取难以想到算法方式来全面识别的特征时会非常有帮助。不利的一面是，这种逻辑往往高度专业化，不容易概括患者的一般特征(如 HCC 模型中的“风险”)。
结论
我在这个介绍性讨论中的希望是鼓励在数据科学应用中更广泛地使用医疗索赔数据。CMS 提供了许多基于医疗保险的样本，这些样本可公开用于分析，其中可能隐藏了许多未开发的见解。愿欢乐开始！
心脏病预测
克里夫兰心脏病(UCI 知识库)数据集——用各种模型分类。
介绍
心脏病描述了一系列影响心脏的疾病。心脏病范围内的疾病包括血管疾病，如冠状动脉疾病、心律问题(心律不齐)和先天性心脏缺陷(先天性心脏缺陷)等。
术语“心脏病”经常与术语“心血管疾病”互换使用。心血管疾病通常是指血管狭窄或阻塞，可能导致心脏病发作、胸痛(心绞痛)或中风。其他心脏疾病，如影响心脏肌肉、瓣膜或节律的疾病，也被视为心脏病的形式。
心脏病是世界人口发病和死亡的最大原因之一。心血管疾病的预测被认为是临床数据分析部分中最重要的课题之一。医疗保健行业的数据量非常庞大。数据挖掘将大量原始医疗保健数据转化为有助于做出明智决策和预测的信息。
根据一篇新闻报道，心脏病被证明是男女死亡的主要原因。该条声明如下:
在美国，每年约有 610，000 人死于心脏病，也就是说，每 4 例死亡中就有一例。1
心脏病是男性和女性死亡的主要原因。2009 年因心脏病死亡的一半以上是男性。1
冠心病(CHD)是最常见的心脏病，每年导致超过 370，000 人死亡。
每年大约有 735，000 名美国人患心脏病。其中，525，000 例是首次心脏病发作，210，000 例发生在已经患有心脏病的人群中。
这使得心脏病成为需要解决的主要问题。但是很难识别心脏病，因为有几个促成的风险因素，如糖尿病、高血压、高胆固醇、异常脉搏率和许多其他因素。由于这些限制，科学家们转向了数据挖掘和机器学习等现代方法来预测疾病。
机器学习(ML)被证明可以有效地从医疗保健行业产生的大量数据中帮助做出决策和预测。
在这篇文章中，我将应用机器学习方法(并最终比较它们)来对一个人是否患有心脏病进行分类，使用最常用的数据集之一—UCI 知识库中的克里夫兰心脏病数据集。
和往常一样，您可以在 Github 资源库中找到本文使用的代码。
数据
本文中使用的数据集是来自 UCI 资料库的 Cleveland 心脏病数据集。
Dataset
该数据集由 303 个个体数据组成。数据集中有 14 列，如下所述。
- :显示个人的年龄。
- 性别 :使用以下格式显示个人的性别:
1 =男性
0 =女性 - 胸痛类型 :使用以下格式显示个人经历的胸痛类型:
1 =典型心绞痛
2 =非典型心绞痛
3 =非心绞痛疼痛
4 =渐进性 - 静息血压 :显示个人的静息血压值，单位为毫米汞柱(单位)
- 血清胆固醇 :显示血清胆固醇，单位为毫克/分升(mg/dl)
- 空腹血糖 :将个体的空腹血糖值与 120mg/dl 进行比较。
如果空腹血糖> 120mg/dl 则:1(真)
否则:0(假) - 静息心电图 :显示静息心电图结果
0 =正常
1 = ST-T 波异常
2 =左心室肥厚 - :显示个人达到的最大心率 。
- 运动诱发的心绞痛 :
1 =是
0 =否 - 运动相对于休息诱发的 ST 段压低 :显示整数或浮点数。
- 峰值运动 ST 段 :
1 =上坡
2 =平坡
3 =下坡 - 荧光显示的主要血管数(0-3):显示整数或浮点数。
- 地中海贫血 :显示地中海贫血:
3 =正常
6 =固定缺陷
7 =可逆缺陷 - 心脏病诊断 :显示个人是否患有心脏病:
0 =缺席
1，2，3，4 =出席。
为什么这些参数:
在实际数据集中，我们有 76 个特征，但是在我们的研究中，我们只选择了上面的 14 个，因为:
- 年龄:年龄是发展心血管或心脏疾病的最重要的风险因素，生命中的每十年风险大约是三倍。冠状动脉脂肪条纹可以在青春期开始形成。据估计，82%死于冠心病的人年龄在 65 岁及以上。同时，55 岁以后，中风的风险每十年翻一番。
- 性别:男性比绝经前的女性患心脏病的风险更大。一旦过了更年期，人们认为女性的风险与男性相似，尽管来自世卫组织和联合国的最新数据对此提出了质疑。如果女性患有糖尿病，她比患有糖尿病的男性更容易患心脏病。
- 心绞痛(胸痛):心绞痛是当你的心肌没有获得足够的富氧血液时引起的胸痛或不适。它可能会让你感到胸部有压力或挤压感。不适也可能发生在你的肩膀、手臂、脖子、下巴或背部。心绞痛甚至会感觉像消化不良。
- 静息血压:随着时间的推移，高血压会损害为心脏供血的动脉。高血压与其他疾病一起出现，如肥胖、高胆固醇或糖尿病，会增加你的风险。
- 血清胆固醇:高水平的低密度脂蛋白(LDL)胆固醇(“坏”胆固醇)最有可能使动脉变窄。高水平的甘油三酯(一种与饮食有关的血脂)也会增加心脏病发作的风险。然而，高水平的高密度脂蛋白(HDL)胆固醇(“好”胆固醇)会降低心脏病发作的风险。
- 空腹血糖:胰腺分泌的一种激素(胰岛素)分泌不足或对胰岛素反应不佳，会导致身体血糖水平上升，增加心脏病发作的风险。
- 静息心电图:对于心血管疾病低风险人群，USPSTF 有一定把握地得出结论，静息或运动心电图筛查的潜在危害等于或超过潜在益处。对于中高风险人群，目前的证据不足以评估筛查的利弊。
- 达到的最大心率:与心率加快相关的心血管风险增加与高血压风险增加相当。已经表明，心率每分钟增加 10 次与心脏死亡风险增加至少 20%相关，并且这种风险增加类似于收缩压增加 10 毫米汞柱所观察到的风险增加。
- 运动诱发的心绞痛:与心绞痛相关的疼痛或不适通常感觉紧张、紧握或挤压，可从轻微到严重不等。心绞痛通常在胸部中央感觉到，但可能会蔓延到你的一个或两个肩膀，或你的背部，颈部，下巴或手臂。甚至可以用手感觉到。o 型心绞痛 a .稳定型心绞痛/心绞痛 b .不稳定型心绞痛 c .变异型(Prinzmetal)心绞痛 d .微血管型心绞痛。
- 峰值运动 st 段:J 点后 60-80 ms 出现水平或向下倾斜的 ST 段压低≥ 1 mm，则认为平板心电图负荷试验异常。运动心电图上斜 ST 段压低通常被认为是“可疑”试验。一般而言，在较低的工作负荷(以 METs 计算)或心率下出现水平或向下倾斜的 ST 段压低表明预后较差，多支血管疾病的可能性较高。ST 段压低的持续时间也很重要，因为峰值负荷后的恢复时间延长与平板心电图负荷试验阳性相一致。另一个高度提示严重冠心病的发现是 ST 段抬高> 1 mm(通常提示透壁缺血)；这些病人经常被紧急转诊进行冠状动脉造影。
方法
这篇文章的代码可以在这里找到。代码用 Python 实现，并应用了不同的分类模型。
在本文中，我将使用以下分类模型进行分类:
- SVM
- 朴素贝叶斯
- 逻辑回归
- 决策图表
- 随机森林
- LightGBM
- XGboost
数据分析
让我们看看患有或不患有这种疾病的人的年龄。
这里，target = 1 表示此人患有心脏病，target = 0 表示此人没有患病。
我们看到大多数遭受痛苦的人年龄在 58 岁，其次是 57 岁。大多数 50 岁以上的人都患有这种疾病。
接下来，让我们看看每个目标阶层的年龄和性别分布。
我们发现女性患这种疾病的年龄比男性大。
数据预处理
数据集包含 14 列和 303 行。让我们检查空值
null values in each column of the data
我们看到只有 6 个单元格具有空值，其中 4 个属于属性 ca ，2 个属于属性 thal。 由于空值非常少，我们可以删除它们或估算它们。我用平均值代替空值，但是也可以完全删除这些行。
现在让我们划分测试和训练集中的数据。在这个项目中，我将数据分成了 80: 20 的比例。也就是说，训练规模占总数据的 80%，测试规模占总数据的 20%。
培养
应用上面讨论的所有模型来得到结果。
使用的评估标准是混淆矩阵。
confusion matrix
混淆矩阵通过分类器显示正确预测和错误预测的值。来自混淆矩阵的 TP 和 TN 之和是分类器正确分类的条目的数量。
SVM
训练集的 SVM 准确率=((124+100)/(5+13+124+100)) 100 = 92.51%
测试集的 SVM 准确率= 80.32%*
同样，让我们看看每个分类器的所有混淆矩阵。
朴素贝叶斯
逻辑回归
决策图表
随机森林
LightGBM
XGBoost
总而言之，这里是所有分类器的所有精度。
我们看到，通过逻辑回归和 SVM 达到了测试集的最高准确度，其等于 80.32%。
决策树对训练集的最高准确率达到 100%。
这些算法仅使用默认参数实现。
结论
心脏病是当今社会的主要问题之一。
很难根据风险因素人工确定患心脏病的几率。然而，机器学习技术对于从现有数据预测输出是有用的。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
