TowardsDataScience-博客中文翻译-2016-2018-二十八-

龙哥盟 / 2024-10-13 / 原文

TowardsDataScience 博客中文翻译 2016~2018（二十八）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

拿破仑是有史以来最好的将军，数学证明了这一点。

原文：https://towardsdatascience.com/napoleon-was-the-best-general-ever-and-the-math-proves-it-86efed303eeb?source=collection_archive---------0-----------------------

对战争史上的每一位将军进行排名

*几乎每

当 Africanus 问汉尼拔认为谁是最伟大的将军时，汉尼拔说出了Alexander……至于谁会排在第二位，汉尼拔选择了皮拉斯……问汉尼拔认为谁是第三位，他毫不犹豫地说出了自己的名字。接着，西庇阿大笑起来，说道:“如果你打败了我，你会说什么？”

—李维

就像汉尼拔一样，我想在战争史上给强有力的领导人排名。与汉尼拔不同，我试图用数据来确定一个将军的能力，而不是对将军成就的具体描述。其结果是军事史上每一位杰出指挥官的排名系统。

该方法

受棒球赛计量法的启发，我选择使用胜于败的系统。战争经常被用来评估一个棒球运动员对他的球队的贡献。它计算玩家相对于替补玩家增加(或减少)的总胜率。例如，与高水平小联盟球员的平均贡献相比，一个打了 5 场仗的棒球球员为他的球队贡献了 5 场额外的胜利。WAR 远非完美，但提供了一种基于一项统计数据来比较玩家的方法。

我用战争来评估一个特定的军事战术家的贡献是高于还是低于一个普通的将军。我的模型，我在下面解释，提供了一个在任何给定情况下的一般一般性能的估计。然后，我可以根据他们在相同情况下超过或低于替代将军的程度来评估将军的素质(假设替代将军的表现处于平均水平)。换句话说，我会在战争中找到将军们的战争。

Interactive visualization showing the 6619 ranked generals’ WARs

点击此处查看互动可视化！

数据

我的第一个挑战是构建一个可靠的数据集。由于我无法找到一个全面的历史战斗数据集，我决定建立自己的数据集。我使用维基百科的战斗列表作为起点。虽然不全面，维基百科的列表包括 3580 场独特的战斗和 6619 名将军，这提供了足够的样本来创建一个模型。然后，我开发了一个函数，可以收集每场战斗的关键信息，包括参与战斗的所有指挥官、这些指挥官可用的总兵力以及战斗的结果。由此产生的数据集提供了一个大的战斗样本，以创建一个基线(替换级别)性能，我将根据它来比较个别将军的性能。

上的战斗数据样本 上的维基上的上的上的上的

战场数据样本被刮取并处理成数据帧

然后我从战斗样本中构建了一个线性模型。对于每场战斗，我将战斗人员的部队分为步兵、骑兵、炮兵、空军和海军。然后，我可以衡量一个将军与他们的对手相比在数量上的优势或劣势，并更好地隔离将军作为战术家的能力。最终的模型在权重上惊人地保守，这表明与地形或技术等其他因素相比，原始士兵数量的影响相对较小，进一步的研究可以更详细地调查这些因素。然而，在这个项目中，与其他因素相比，结果潜在地夸大了指挥官战术敏锐度的重要性。

我准备给每一位将军排名并研究结果。我这样做是通过隔离每个将军的战斗，并为他们在每场战斗中的表现分配一个战争分数。例如，法国皇帝拿破仑因在波罗底诺战役中获胜而赢得了 49 年战争。由于法国军队略多于俄罗斯帝国的军队，该模型给出了拿破仑位置上的替代将军 51%的胜算。战争系统分配拿破仑 1 胜作为他的胜利，但是减去一个替代将军无论如何都会赢的机会。因此，拿破仑获得 0.49 胜以上的替换。

该系统使用类似的方法来处理失败。例如，俄国将军米哈伊尔·库图佐夫，拿破仑在波罗底诺战役中的对手之一，被认为是这场对抗导致了. 49 战争。通过遭受失败，他取得了-1 的胜利，但是有 51%的几率一个替代将军会失败。

结果呢

在所有将领中，拿破仑的战力最高(16.679)遥遥领先。事实上，排名第二的凯撒大帝(7.445 年战争)，他的战争时间还不到拿破仑历次战争的一半。拿破仑从他领导的大量战斗中受益匪浅。在他参加的 43 场战斗中，他赢了 38 场，只输了 5 场。拿破仑在 17 次胜利中克服了困难，在所有 5 次失败中处于劣势。在所有战役中，没有其他将军能与拿破仑相提并论。拿破仑在 43 场战役中指挥军队，第二多产的将军是罗伯特·李，27 场战役(平均 1.5 场)。拿破仑的大量战斗让他有更多的机会展示他的战术能力。亚历山大大帝，尽管赢得了全部 9 场战斗，但积累的战争较少，主要是因为他的职业生涯较短且较少产。

Napoleon’s height was 5'7", slightly taller than average for his time.

然而，除了拿破仑外围的成功，将军们的战争很大程度上遵循正态分布。这表明他的成功归因于指挥才能，而不是模型发现的异常。事实上，拿破仑的总战争比数据集中将军们累积的平均战争高出近 23 个标准差。

Napoleon is a huge outlier with nearly 17 WAR

也有一些将军尽管被誉为战术大师，但总体战数却出奇的低。罗伯特·e·李，邦联军队的指挥官，以一场消极的战争结束(-1.89)，暗示一个普通的将军会比李领导的邦联军队更成功。李将军背负着相当大的劣势，包括军队规模和可用资源的巨大赤字。尽管如此，他作为一个老练的战术家的声誉可能是不应该的，他的战争支持了那些批评他的总体战略和关键战役处理的历史学家，例如在葛底斯堡战役的最后一天下令灾难性的'皮克特冲锋。用南卡罗来纳大学教授托马斯·康纳利的话来说，“人们会想，如果没有罗伯特·李，南方是否会过得更好。”

德国陆军元帅埃尔温·隆美尔(Erwin Rommel)因二战期间在北非的成功而被昵称为“沙漠之狐”，他在这一模式中也表现不佳，最终以-1.953 战。这一发现质疑了隆美尔作为战术家从现代将军那里得到的赞誉，包括诺曼·施华蔻和阿里尔·沙龙。然而，和李将军一样，隆美尔也是历史争论的焦点。尤其是，批评家们将他作为战术天才的声誉归功于德国和盟国的宣传。据报道，英国将军夸大了隆美尔的战术能力，以尽量减少对他们失败的不满。

现代将领在模型中表现相对较差。美国将军乔治·S·巴顿被历史学家特里·布莱顿描述为“二战中最伟大的将军之一”，他只打了 0.9 场战争。现代将军在战争中表现不佳，可能是由于战争的变化使个别将军无法参加大量的战斗。

Moshe Dayan boosted his WAR by winning the Six-Day War, despite a numerical disadvantage

在二战后的将军中，以色列指挥官脱颖而出。以色列军事领导人摩西·达扬(Moshe Dayan)以 2.109 战结束(第 60 名)，对于一个现代将军来说这是一个令人印象深刻的数字，但与 20 世纪前的战术家相比相对温和。类似地，以色列前总理阿里埃勒·沙龙因在苏伊士危机、六日战争和赎罪日战争中的战场胜利而累积了 2.171 场战争(总排名第 58 位)。

最后，我把汉尼拔对有史以来最高将领的评估与我的模型进行了对比。根据 WAR，汉尼拔低估了自己的能力——在迄今为止的所有将军中，汉尼拔的 WAR 最高，为 5.519(总排名第六)。亚历山大大帝，汉尼拔任命为最高将领，以 4.391 战(总排名第 10)仅次于汉尼拔的标记。然而，亚历山大只打了 9 场仗就死了，而且全部都赢了。汉尼拔有 17 场战斗来积累价值，赢了 13 场，输了 2 场，平了 2 场。因此，我同意汉尼拔的评估，即亚历山大是更有能力的战术家，尽管汉尼拔提供了更多的总价值——亚历山大展示了他赢得战斗的能力，如果他没有死于疾病，很可能会继续获胜。

Depiction of the Battle of Cannae, a decisive victory for Hannibal against Roman consuls Varro and Paulus

我的发现与汉尼拔对伊庇鲁斯的皮拉斯的评价截然不同，伊庇鲁斯是一位希腊将军，也是早期罗马的对手。我的模型认为皮拉斯只有 3 场战斗和-0.53 场战争。尽管汉尼拔将创新的军事战术归功于皮拉斯，但我对他的整体战术敏锐度深表怀疑，甚至在考虑到他在胜利期间无法防止军队灾难性伤亡之前。

这个项目和由此产生的可视化有望提供一种有趣的方式来探索和比较将军们的相对成功。WAR 为经验性地比较将军们提供了一个有用的范例，尽管未来的研究可以通过扩大数据集或考虑其他因素(如对手的实力)来改进这一模型。请玩玩可视化，如果你想找一个特定的将军，只需输入网址'https://ethanarsht.github.io/military_rankings/* * 。其中**是将军的名字，和维基百科上显示的完全一样。

2011 年 12 月 11 日更新:基于许多我非常尊重其工作的人的反馈，我想对上述分析明确提出一些警告。首先，这篇文章旨在作为一个有趣的思想实验，而不是一个权威的排名，或对军事历史领域的学术贡献。我相信这个项目的一些结果，特别是李和隆美尔，为更广泛地讨论他们的战术能力提供了有趣的数据点。我绝不声称我的分析提供了全貌，或任何接近全貌的东西。

此外，由于我非常依赖维基百科获取数据和数据分类，我的输入中存在漏洞和不一致。鉴于我个人资源的缺乏，对我来说，在检查每一个数据点的准确性的同时进行如此规模的项目是不现实的。

最后，我必须重申，我的排名是一个将军的战术附加值，而不是他们的整体战略能力，或者谁会在一场假设的兵力和装备均等的对决中获胜。

同样，我相信绝大多数读者都按照我的意图解读了这篇文章——一个有着有趣结果和娱乐性互动的思想实验。感谢所有阅读这篇文章和/或提供反馈的人。

更新 12/8:根据大众的需求，可视化现在包括平均每场战斗增加的战争。只需将鼠标悬停在一个将军的点上，弹出窗口中就会出现“每场战争”。

此外，有些人在浏览与项目相关的 GitHub 库时遇到了麻烦。我在这个 Google Drive 中放了两个重要的电子表格:一个包含所有的部队人数数据，另一个包含每场战斗的战争结果。

更新 12/6:我想对过去几天收到的一些合理且持续的建设性批评做出回应。

缺少数据！许多人准确地指出了数据中缺失的战斗/将军，特别是关于蒙古人，包括成吉思汗和苏布泰。这是一个主要问题，源于我对维基百科战斗列表的依赖。这是我应该早点发现的，我计划更新数据集以包含更多的战斗。然而，处理这些数据需要大量的手动数据输入/清理，并且在向数据集添加重大更新之前将花费我相当多的时间。
战略与战术:人们认为将军被低估/高估是因为他们战役的最终结果。我特别关注将军的战术敏锐性，而不是他们的战略决策。因此，拿破仑不应因其灾难性的俄罗斯战役而失去信誉，乔治·华盛顿也不应因其对美国独立战争的战略方针而获得信誉。
增加了胜率高于替代胜率与胜率高于平均胜率与胜率的概率:那些熟悉棒球赛的人很快指出，我的模型并没有在所有方面反映胜率高于替代胜率的方法，因为棒球的战争使用一个普通的顶级小联盟球员作为基线。我只是将平均质量作为我的替换级别。可能不完全准确，但我认为我在上述方法中使用什么作为基线是非常清楚的。

感谢你们当中提出建设性批评的人。

请不要犹豫，在 twitter (@ethanarsht)上提供反馈。此处提供的代码和数据:【https://github.com/ethanarsht/military_rankings】。很抱歉弄得一团糟。

内特·西尔弗诉纳西姆·尼古拉斯·塔勒布和艾萨克·费伯

原文：https://towardsdatascience.com/nate-silver-v-nassim-nicholas-taleb-and-isaac-faber-888e56e2acac?source=collection_archive---------15-----------------------

Isaac Faber 最近在博客上写道，为什么你应该关心 Nate Silver 和 Nassim Taleb 的推特之战:两个数据专家怎么会有这么大的分歧？在阅读他的简介时，我强烈反对他关于争论的性质和原因的观点。作为一名曾在芝加哥商业交易所从事衍生品交易的交易员，我发现塔勒布的观点很准确，但并不令人信服，而西尔弗的回应则简单粗暴，而且跑题了。我想是塔勒布先开始的，但他是出了名的尖酸刻薄，整个对话都是在 twitter 上进行的，所以我希望西尔弗能站在高处，像一个以严谨著称的统计学家那样，解决一些相关的数学问题。

塔勒布认为，对选举的准确预测，无论是概率预测还是非概率预测，都不会随着时间的推移而大幅修改，除非出现彻底的混乱(比如宣布内战)。西尔弗认为，对选举的准确预测包括选举过程的不确定性，选民的变化会准确地导致结果概率预测的大幅波动。

费伯的文章没有抓住塔勒布的重点，引发了西尔弗经常提到的担忧，好像这些担忧是对他不利的证据。这些担忧对对话的健康发展至关重要，我相信塔勒布为西尔弗提供了另一个解决问题的途径。但显然西尔弗和费伯都没有注意到这三个人都在同一边，所以开始了。第一，Faber 的优秀背景:【如果你熟悉背景和 Taleb 和 Silver，就跳到酒吧的最后。]

“张瀚银是fivethirtyeeight的联合创始人。一个非常受欢迎的专注于数据的博客，因其准确预测 2008 年美国大选的结果而闻名。Silver 使用一种聪明的民意调查汇总技术来生成预测，这种技术考虑到了偏见，例如民意调查者只给使用座机的人打电话。

作为一名训练有素的统计学家，通过经济学，他将自己对棒球(sabermetrics)和扑克分析的热情引入了政治领域。事实上，FiveThirtyEight 这个名字是对美国选举人票数(538 张)的认可。然而，博客也涵盖了其他兴趣领域，如体育。内特把他的博客卖给了 ESPN，并接受了主编的工作。他们(ESPN)利用它作为一个平台，向观众提供体育赛事的预测，FiveThirtyEight 后来搬到了美国广播公司。对他们网站的例行访问是政治和体育文章的混合，带有详细的预测和数据可视化。

Silver (left) in conversation with NY1’s Pat Kiernan

内特的预测能力已经成为大众媒体公认的标准。他是许多全国电视节目的常客，在每个全国选举周期讨论他的预测。因此，当畅销书作家、量化风险专家纳西姆·塔勒布(Nassim Taleb)公开宣布 FiveThirtyEight 不知道如何正确预测选举时，人们感到非常震惊！

对塔勒布来说，由于他对现实世界中概率的敏锐理解，他已经变得非常成功。他的书既有哲学的，也有技术的，重点是不确定性和风险。具体来说，他认为实践中使用的绝大多数定量模型都没有充分考虑到现实世界的风险。相反，它们给人一种短期价值的错觉(比如在一些很好理解的情况下是准确的)，但当不知情的用户经历模型设计不理解的情况时，他们会面临巨大的系统风险。

Nassim Taleb

塔勒布之所以出名，部分是因为他通过暴露自己的财富将自己的哲学付诸实践。马尔科姆·格拉德威尔在《纽约客》上写了一篇文章，讲述了塔勒布是如何将他的风险哲学转变为一种极其成功的投资策略的。从那以后，他在不可预见的市场事件中获得了巨额财富，如黑色星期一、俄罗斯债务违约和 2008 年金融危机。塔勒布现在花很多时间写作和硬拉(我很嫉妒这一点)。他不羞于公开告诉别人他不同意他们的观点:内特·西尔弗就是其中之一。

Taleb’s Tweets directed at Silver November 2018

然而，西尔弗并没有屈服于这些侮辱！

Silver 和 Taleb 分别拥有 300 万和 30 万粉丝，在这些交易所引起了巨大的轰动(从 2016 年开始)。然而，快速浏览评论线程，你会发现很少有人理解这些论点。甚至西尔弗自己似乎也被塔勒布的攻击弄得措手不及。

两人都是熟练的统计学家，西尔弗是更好的民意测验专家，而塔勒布是更好的数学家。塔勒布从未声称对民调了解多少，而西尔弗也没有数学博士学位。他们都在各自的领域享有专业的认可和成功，都是畅销书作家。他们都是贝叶斯统计的支持者，贝叶斯统计是统计学的一个实证主义子集，坚持通过合理的框架随着时间的推移纳入额外的信息。他们都喜欢使用蒙特卡罗方法，这是一种统计/算法方法，使用模型的重复随机抽样来获得数字结果。他们的共同点比争论点多得多。但是这个特殊的论点很重要。

他们的争论归结为一点:预测准确性的定义。准确性被定义为正确或精确的性质或状态，因此准确的预测是正确的、精确的和准确的(从精确的定义中得出)。一个数学家(或任何人，给定信息、工具、时间和倾向)可以说，“这里是候选人，这里是选举人团的选票，这里是投票区，如果一切都按特朗普的方式进行，这里会发生什么，如果一切都按希拉里的方式进行，这里会发生什么，如果 X 支持特朗普，Y 支持希拉里，这里会发生什么，”并继续对所有潜在的结果进行组合建模。这种组合建模是严格正确的，除非对所有可能的输入建模失败。

塔勒布认为对选举的准确预测不会随着时间的推移而大幅修正，除非出现完全的混乱(比如宣布内战)。 他有明确的标准来定义不可接受的大修改，以及在给定的选举中找到它的等式【ARXIV 文章，数学很重】。但他也坚持认为，预测的结果包括更高的不确定性，如果它存在的情况下。按照这些思路对 6 个月后的选举进行概率描述可能会是这样的:“希拉里有 75%的机会获胜，特朗普有 20%，还有 5%的可能性发生，不确定性给这些结果增加了大约 30%的灵活性。”固有的预测是‘希拉里会赢’。这种统计模型是整体的——它一次看到整个结果，概率完全是基于结果的。数值预测是如何得到的并不重要，一个超出修正标准的预测就是错误的。上述预测在 11 月份是错误的，尽管概率部分只有在结果不包含在组合可能性空间中时才是错误的。

Silver 在选举期间的帖子表明了他的想法，即在正常情况下，对选举的准确预测会随着时间的推移而被大规模修正(根据 Taleb 的定义)。他创建了每个附属选举的模型，使用民意调查的知情知识为每个附属选举的每个结果分配加权概率，并创建了所谓的选举蒙特卡洛模拟。在蒙特卡洛模拟中，统计学家创建他们的模型，然后通过数百或数千次模拟运行来运行该模型，并限制附属数字的随机性。这种受限的随机性导致了对所有可能结果的了解。蒙特卡罗方法可用于产生每个最终结论的净概率，如通过使用其加权随机因子多次运行该模型所证明的，但是辅助成分权重的小变化可导致大的修正。假设共和党的投票率增加 5%，但特别是那些在摇摆州的摇摆区的投票率，可以改变整个模拟结果，使其对特朗普更加有利。由于净概率是模型的组合潜力的叠加，任何包含在组合图中的结果都是可能的。

预测和概率是有区别的。概率是对某事可能发生的程度、某事发生的可能性或事实的估计。预测是对未来将会发生的特定事情或者某件事情的结果的陈述性估计。概率预测表明某一特定事件发生的概率是给定的。

西尔弗做概率预测。如果一个概率预测包含了已经发生的结果，它就没有错，就像一个组合分析不会因为一个结果在模型中比实际结果出现得更频繁而出错一样。说一件事情有 70%的可能性发生，并不意味着如果其他事情发生了，你就是错的，只要其他事情也包括在你的模型中。然而，如果你可以重复实验数百万次，并看到在绝大多数实际结果中有 80%或 50%的可能性发生，那就错了。预测只发生一次，所以实验不能重复。

Isaac Faber 的帖子描述了随机不确定性和认知不确定性的区别:

随机不确定性与基本系统有关(在标准骰子上掷出六点的概率)。认知不确定性与系统的不确定性有关(骰子有几个面？掷出 6 的概率是多少？).像 FiveThirtyEight 这样的定制模型只向公众报告偶然的不确定性，因为它涉及到它们的统计输出(在这种情况下由蒙特卡洛进行推断)。麻烦在于认知的不确定性很难(有时不可能)估计。

他接着断言“塔勒布竭力反对的”是

如果一个预测不符合一些基本特征，它就不应该作为一种可能性被推销。更重要的是，一个预测应该从发布给公众的时候就开始判断，而不仅仅是在事件发生之前。预测者应该对偶然性和认知性的不确定性负责。

费伯的苏格拉底式的塔勒布(我个人没有发现塔勒布在哪里提出这个字面上的例子)抱怨内特·西尔弗不可能是错的，因为他在报告概率，但他这样做的方式导致他们很容易被视为没有概率元素的预测，这是不负责任的。这可能是真的，但是断言在这个问题上有目的的不负责任的疏忽是没有根据的，因为内特·西尔弗和五个三十岁的男孩已经尽力向那些感兴趣的人解释他们的方法。西尔弗同意，将他的概率作为严格预测的二次报道是新闻和媒体中的一个常见问题。

艾萨克的观点有些道理。像内特·西尔弗这种地位的人公开做出的概率预测，将被代理人解读，并根据内部程序采取行动。人类的一个这样的过程是把一个概率性的预测折叠成一个预测，然后从那里得到一个断言。有证据表明，史蒂夫·班农和川普竞选团队利用这一事实和对民调的不信任，来保持自信和有目的，而他们自己的内部民调反映了不同的现实。这一结果的部分责任在于 Nate Silver、FiveThirtyEight 和任何报道概率预测的人，这些预测被认为到降低了选民投票率在受青睐的一方中，如果它们被解读为预示井喷。随着来自 Silver 的头条新闻，如“特朗普正在加倍押注一个失败的策略”以及概率预测，作者对读者认为民主党胜利已是囊中之物负有一定责任。

如果公众和二手报道没有明智地整合你提供的信息的倾向，并且你的网站显然会被报道和阅读，我个人同意有义务以一种不容易被误解的方式报道你自己的发现。对于 Nate Silver 和 FiveThirtyEight 来说，创建一个带有相关输入的蒙特卡罗模型的图形表示并显示过程的模糊性，而不生成或公布一个容易被误解的基于百分比的概率预测是很简单的。

然而，我认为 Silver 和 Taleb 之间的分歧比其他人报告预测的概率更重要。塔勒布曾亲自断言，精确的蒙特卡洛衍生的基于百分比的概率预测，就像任何概率预测一样，不应该偏离或随时间变化超过任何相关的、微小的修订标准。西尔弗坚持认为这是应该的。

这是一个重要的区别，但如果你考虑到他们截然不同的背景，这就不足为奇了。 塔勒布，其背景是量化金融，习惯于波动的基础工具，以及复杂衍生品的创造和部署，以捕捉其内在的不确定性 。如果概率预测是不正确的，那么他在管理投资基金时会损失数十亿美元。一旦对基础资产的概率预测被锁定，市场就会创造衍生品来描述各种结果，并根据这种不确定性来定价。在塔勒布的世界里，情况的不确定性不是预测的不确定性的基础，而我和你的预测之间的差异是我们相应地给自己的东西定价并相互买卖的基础。然后，随着时间的推移，我们都将是正确的，或者我们都将被纠正，退出市场。

另一方面，西尔弗在民意调查方面的背景是习惯于动荡的政治和体育局势，但除了人为的终结之外，没有捕捉它们的不确定性的机制——一场比赛的结束，一场选举的结果。在白银领域，与市场的瞬间过程相比，反馈相对较少。与体育不同，政治中的规则和信息具有很强的可塑性和开放性。民意测验专家提供信息，选民和候选人在评判候选人、创造信息和开展竞选活动时都会考虑到这一点。

两者背景的关键区别在于每时每刻决定行动路线的绝对正确性的价值。根据塔勒布的预测准确性标准，民意调查者、选民、候选人、竞选经理，这些人都不会从竞选期间对选举概率预测的准确公众评估中获得多少好处。这些信息将完全不在他们的任何决策阈值之内，并且没有机制来捕捉或受益于该过程固有的不确定性。

一个公开的组合分析对于一个竞选经理来说已经足够了，他正在寻求把每一个可能的结果都推向他们的方向。他们想让选民知道哪些比赛正在进行。之后，预测的准确性是有价值的，只要它明确地*不是公开的，*特权信息在政治上不像在市场上那样是非法的。

对概率预测的准确解读会导致投票人理论上只关心娱乐价值。如前所述，这种娱乐以一种令人担忧的方式对投票本身施加激励，表明它们不是随机产生的。

候选人或许可以从准确性中受益，但往往无法亲自利用微妙的信息，特别是在权衡真正的未知可能给那些患有公共职位竞选精神病的人带来的额外压力时。此外，上述关于公共信息价值的说明对他们和他们的竞选经理都适用。班农从一开始就臭名昭著地告诉川普，“你有百分之百的机会赢得。”

西尔弗正在向市场报告他的蒙特卡洛方法的结果，作为概率预测，而市场并不像塔勒布那样关心准确性或从准确性中获取价值，西尔弗的新闻报道照原样非常受欢迎。作为一名记者/统计学家，他小心翼翼地将自己的预测描述为概率性的，按照塔勒布的标准，他报告的结果显然是不准确的。但是，只有在存在利用信息的机制的情况下，对绝对正确的实时概率模型的要求才是有价值的。

我发现西尔弗和塔勒布在谈话中都非常傲慢。考虑到塔勒布的数学并没有失去任何严谨性，西尔弗的人身攻击(对不起，兄弟，但你已经有点成为一个知识分子，但白痴’)令人尴尬。尽管你很难责怪他，考虑到塔勒布愿意抄袭特朗普总统的剧本，称西尔弗为“Klueless”[原文如此]，以及塔勒布故意忽视缺乏任何激励机制来改变广泛变异的概率预测。

从历史上看，Silver 的模型在汇总民意调查信息方面比大多数公共来源更加准确。实际上，西尔弗可能必须每小时发表一篇毫无信息但准确的文章《我们不知道谁会赢》，才能成为塔勒布标准的“好预测者”，而塔勒布的标准忽视了民调新闻的激励作用。内特·西尔弗在新闻业的游戏中有太多的经验，不能忽视它的惯例。塔勒布声称“预测选举不是内特·西尔弗的事情”，这是天真的表现。这可能是对 Twitter 的控诉(我避开了这个平台，即使是对 Taleb 这样的热门平台，因为它总是奖励刻薄和尖刻的讽刺而不是理性)，但我发现令人难过的是，当他们有如此多的共同点时，他们却在互相攻击。

因此，fivethirtyeeight和纳西姆·尼古拉斯·塔勒布注意，如果我能挑选两个人来承担选举报道和新闻业中概率预测的失败，那将是你们两个。如果你们两个能更好地讨论准确的政治预测是什么样的，对选民和 Silver 的利益相关者有用，这对民主的未来非常重要，如果它导致知情人士中意外的选民自我抑制，我将不胜感激。

谷歌研究院的自然语言生成

原文：https://towardsdatascience.com/natural-language-generation-at-google-research-bbf2c3756d80?source=collection_archive---------4-----------------------

在本集《云人工智能历险记》中，我将谷歌研究工程师贾斯汀·赵(Justin Zhao)带入演播室，了解生成自然发音的文本有多难。我们还讨论了这项技术如何应用在你的日常生活中，比如当你向谷歌主页询问天气时。

我们还讨论了一些应用于自然语言生成问题的机器学习技术，以及这一领域的最新研究进展。这是一次有趣而有意义的讨论，尽情享受吧！

我们正在为云人工智能冒险测试一种新的形式，在那里我采访人工智能和机器学习专家，讨论他们在该领域的一些研究和进展。这是一次真正的，嗯，冒险为这一集做准备和拍摄，请让我知道你是否喜欢这个结构！

要了解更多机器学习动作，请务必关注 Medium 上的me或订阅 YouTube 频道以观看未来的剧集。更多剧集即将推出！

社交媒体内容的自然语言处理

原文：https://towardsdatascience.com/natural-language-processing-analysis-of-social-media-content-55518ded990c?source=collection_archive---------4-----------------------

备用标题:全世界都在谈论华特·迪士尼公司吗？是的，是的，它是。

Photo by geralt on pixabay

该设置

华特·迪士尼公司是一家多产的跨国公司，拥有大约 20 万名员工，仅根据我写这篇文章时的股票价值和已发行股票的数量，我估计其总价值约为 1500 亿至 1600 亿美元。与大多数公司一样，你最好相信，他们有既得利益来衡量他们的客户和公众对他们提供的服务和他们创造的产品的感受，但收集这些信息，无论是通过亲自，通过电话，电子邮件或邮寄客户调查和问卷，都需要花费金钱和时间来创建，传播，收集和分析。我想看看我是否可以使用自然语言处理(NLP)工具和无监督的机器学习，以最低的成本实时衡量公众对迪士尼的看法。

获取数据

Photo by geralt on pixabay

首先，我需要文本形式的数据，这是公开发布的，可能包含特定主题的观点；我转向推特。我使用 Twitter API(应用程序接口)编写了一个脚本来下载与关键字和标签“迪士尼”相关的推文，因为它们发布在网上。是的，任何人都可以对任何推文自由地这样做，甚至可以从存储的后备目录中查询它们。除了推文文本之外，你还可以下载与该推文以及发布或转发该状态的用户相关的大量数据和元数据，包括但绝对不限于:时间、日期、地点、语言、关注者数量、关注的账户数量、账户创建日期、个人资料图片以及发布该推文和转发该状态的用户的用户名。我将实时 tweet 流式传输到 MongoDB 集合中，因为我有很多 tweet 要分析，所以我将它们存储在个人 AWS (Amazon Web Services)实例中。如果有人对这些工具感兴趣，或者只是想了解整个电脑世界可以获得哪些关于你的 Twitter 账户的信息，我会在这篇文章的底部提供一些链接，你可以查看一下。

初步材料

我每天收集大约 100，000 到 120，000 条推文，使用 30 多种不同的语言，都与迪士尼有关。当我研究这些数据时，我发现了我的第一个偏见来源。当我搜索关键字 disney 的许多排列时(例如“disney”、“disney's”、“Disney # Disney”等)。)，这不会收集与我的主题相关的所有可能的推文，只会收集提到我的搜索列表中某个单词的推文。例如，我的搜索条件会收集到一条类似“我爱迪斯尼世界！”，而不是“我爱 EPCOT！”，因为第二条推文不包含类似于“迪士尼”的词我可以扩展我的搜索列表，以具体包括每个主题公园，但这会使我的推文偏向主题公园，我根本无法包括每部迪士尼电影、电视节目和角色的名称。为了让我的分析尽可能客观，我保持了我的搜索标准的普遍性，这使我的推文偏向于标题中有“迪士尼”字样的过度代表属性，如华特·迪士尼世界和迪士尼频道。

我把我的大约 50 万条迪士尼推文，削减到 32 万条英文，我实际上可以阅读，然后我通过一个名为 TextBlob 的 Python 库运行它们，它分析文本的每个数据点，在这种情况下是一条推文，并计算极性，介于-1(不利)和 1(有利)之间，0 表示情绪是中性的。所有推文的分布平均值约为 0.115，或正或负，如下图所示。

Image by Author

我想这是非常巧妙的，但事实是，迪士尼公司实际上是其他公司的巨大联合企业，包括漫威、卢卡斯影业、ESPN、ABC、迪士尼公园和度假村、迪士尼游轮公司等等，以及相关知识产权的非常多样化的组合。我不认为了解总体情绪会像了解特定知识产权或品牌的情绪那样对公司有用。为了将这些推文分组到单独的类别中，而不是单独查看每个类别，我们需要通过无监督学习转向聚类，但首先我们需要探索矢量化和降维！令人兴奋的东西。

数据清理和矢量化

Photo by LoboStudioHamburg on pixabay

总的来说，我觉得数据清理很有趣，但是读起来很乏味。不幸的是它也是超级重要的，所以我不得不提到它。使用 tweet 的最大问题是重复的 tweet。我不能排除收集转发，因为我觉得，一条被转发的正面推文仍然表明对该主题的新的积极情绪，并且可能在以后有用，但你不能用重复的数据点聚集数据；我稍后会谈到这一点，但现在请相信我的话，有大量完全相同的文本对我的分析非常不利。因此，我删除了任何推文中的任何 url、符号或转发标签，然后我只保留了每个文本数据点的唯一集合，以清除任何转发或自动机器人的内容，结果产生了大约 98，000 条推文。

所有算法的输入都是数字。有许多不同的方法可以将其他形式的数据转化为数字格式，例如将一张图片解构为每个像素的红色、绿色和蓝色值，或者在我的情况下，将一条 tweet 的单词转化为 tweet 中每个单词的计数，这称为标记化和矢量化。首先，定义什么是标记，它可以是每个唯一的单词、相邻单词的组合，甚至是一定数量的相邻字母的任意组合。根据您的需要，这些技术当然可以单独使用或组合使用。接下来，对文本进行矢量化，为每个数据点的每个标记分配一个值。最基本的例子是以文本“我喜欢汤”为例，它向量化为[ 我 :1，喜欢 :1，汤 :1]。我们现在有了文本的数字表示！接下来，为了将我们所有的推文放在同一个表中，我们不能只为“我喜欢汤”设置一行，为每个“我”、“喜欢”和“汤”设置一列，但是我们需要为包含在任何数据点中的每个单词设置一列。例如，如果我们的第二个数据点是“我不喜欢飞行”,我喜欢汤的矢量化现在必须扩展以指定它不包含新单词，这样它的新值是[ i :1， like :1， soup :1， do :0， not 而“我不喜欢飞”的值为[ i :1， like :1，汤 :0， do :1， not :1，飞 :1]，这样我们两个数据点的值不同，但格式完全相同。你可以看到 98，000 条独特的推文，每个文本数据点的计数将迅速变得巨大，即使大多数计数将是 0。

Photo by geralt on pixabay

还和我在一起吗？太棒了。所以现在我们有一个漂亮的表格/数据集，有 98，000 行，每行代表一条推文，还有大约 10，000 列，每列代表一个独特的词在那条推文中出现的次数。这个表大部分是 0，也有一些 1，2，偶尔还有 3 混在里面，现在其实是另外一种问题了。如果有人(比如一个计算机程序)只看表格中的数字，并决定这些推文是相似还是不同，它们看起来都差不多，因为几乎每一行都由大约 10，000 个 0 组成，还有少量的 1，2 和 3。这是维数灾难的一个例子，这是许多分析领域每天都要面对的问题。

在继续进行降维之前，我还想提一下，我删除了停用词，如“、、*、*和“ if”、，这些词的分析价值很小，并且对这些词进行了加权，以便如果像“迪士尼”这样的词出现在许多数据点中，那么它在确定推文主题之间的差异方面的价值就较小。

降维

哇，这个帖子越来越长了，所以让我们向前冲，尝试覆盖一些地面。如果你休息了一会儿再回来，这里是我们的位置:我们想按迪士尼主题对一堆推文进行分组，我们已经将我们的文本转换成数字格式，现在我们有一个大约 10，000 列的数据集，其中大部分是零，这是准确的，但不利于分析。为了减少数据集中的列数，但仍然包含大量描述性信息，我使用了奇异值分解(SVD)。基本上，它所做的是获取 tweets 中的所有信息(可变性),并将其提取到少量新创建的专栏中。这个过程很抽象，线性代数很重，也很复杂。重要的是，我们可以将最初包含在 10，000 个令牌列中的大量信息压缩到几十个新列中，这很好。

我们现在已经创建了一个所谓的 LSI 空间(潜在语义索引)，可以帮助我们确定每个新列在将推文分成具有共同词汇的主题组方面的有用性。不幸的是，由于新列的“提炼”性质，这些数据比直接的字数统计更难解释，所以让我们将这些列提供给聚类算法。补充说明:新的专栏将把有共同词汇的推文放在一起，这就是为什么转发和机器人是不好的。如果完全相同的 20 个单词在相同的推文中出现 15000 次，那么它就会人为地在这些单词之间创建一种关系，从而混淆模型。

使聚集

我很想深入研究 K-Means 无监督聚类算法的来龙去脉，但我不会，相反，我只会说两件事。首先，该算法(或模型)将每个数据点分配给一个聚类数，以便文本相似的推文被聚集在一起，理想情况下是某种逻辑主题或话题。第二，让它不受监督的是，你不用用它来创建预测，然后对照已知数据进行测试，这将受到监督。监督学习的一个例子是给一个模型一些信息，比如星期几、天气状况、一天中的时间等等。，并让模型预测它认为公共汽车是否会准时或晚点。一旦你有了一个预测，你就将它与实际发生的事情进行比较，并决定它是对还是错；相当直接。对于像 k-means 这样的无监督模型，我给它一堆数据，如矢量化的推文，然后算法将数据点分组到集群中，但由于我们不知道推文的内容以查看模型的表现如何，我需要筛选每个分组的推文，以查看集群是否遵循一些有用的主题。开门见山地说，在这种情况下，他们没有。

Image by Author

上面是一个轮廓图，它基本上显示了我的大多数推文是在一个巨大的、相当分散的集群中(12)，而其他集群相比之下要小得多。当查看每个分组中包含的推文时，在某些情况下，有明确的主题，尽管主题之间几乎总是有很多重叠和信号中的混乱。换句话说，我无法找出一个单独的聚类，也无法相信它包含了某个特定主题的所有推文，比如品牌、人物、电影等等。

Image by Author

为什么迪士尼推文很难处理

因此，在进行了大量的模型调整和尝试不同的东西来让我的聚类算法产生一些真正令人兴奋和有见地的东西(给我发一条消息，我会很高兴地详细研究所有这些东西)之后，有一段时间我不得不得出结论，这些推文就是不想与我合作。也就是说，我认为仍然有一些东西可以学习，你甚至可能会发现它很有趣，所以让我们深入研究几个集群，看看为什么迪士尼推文不喜欢分成组。

首先，这是我的数据集中一条推文的常见例子:

“我想去迪士尼！” 尽管我很欣赏，甚至可能同意这种观点，但如果你能想象这条推文的矢量化版本会是什么样，就没有多少模型可以使用了。如果非要给这条推文贴上一个话题的标签，会是什么？也许我们可以推断他们在谈论一个主题公园，但是并没有真正提到一个特定的公园，或者一部电影，或者甚至是一个角色作为主题标签。这条推文中肯定缺乏信号，或可用的信息。

Image by Author

当深入到另一个确定的集群时，我会看到下面的推文:

*“爱丽儿是唯一一个生过孩子的迪士尼公主。”
——“风中奇缘怎么不是迪士尼公主？”从这些照片中，我可以看到某种类型的“迪士尼公主”主题开始形成，这将是伟大的！但是当我深入研究时，我发现在许多其他的分类中也提到了公主，这表明我的主题之间的混淆。
“迪士尼同时拥有漫威和卢卡斯的电影，idc 你怎么说首里和莱娅是我眼中的迪士尼公主” 这是一条与前两条属于同一组的推文的例子，但第三条不可否认地包括了与漫威和卢卡斯电影有关的材料。如果我对漫威和星球大战/卢卡斯的电影有一个分类，模型会把这条推文放在哪里？*

最后一个例子:
——“迪士尼不仅仅是迪士尼 乐园 ！#迪士尼smmc*@迪士尼* 巡航*@迪士尼* 奥拉尼*@DVC新闻@Disneymoms"* 在这条推文中我看到了‘公园’，‘smmc’(迪士尼的一个特别活动——社交媒体妈妈们与前面的例子一样，我将这解释为一条推文中的大量潜在信号，但没有足够明显的信号让模型能够将它与同一主题的文本相似的推文放在一个类别中。

Image by Author

结束语

因此，也许我不能像我希望的那样代表迪士尼完成高效、信息丰富、以品牌为中心的情感分析，但我确实带你快速或不那么快速地浏览了一个简单的 NLP 项目是如何构建的，以及在此过程中如何以及为什么要完成某些步骤。事实证明，迪士尼公司非常擅长获取知识产权，比如一个成功的角色，并将其传播到许多业务中。像阿拉丁这样的角色出现在电影、电视剧、主题公园、游轮、商品中，甚至更多，有时甚至与看似不相关的角色一起出现，这并不罕见。不仅如此，似乎当有人喜欢迪士尼电影时，他们可能也会喜欢公园、游轮，甚至可能会举办迪士尼婚礼，在一条 280 字的推特中提到这一切。这只是迪士尼如此成功的几个原因，也是为什么我的模型很难将这些推文分成不同的主题。

Image by Author

感谢你在整个过程中坚持下来，或者至少跳过技术部分阅读结尾！我希望你发现了一些有趣的东西，并随时在这里或 LinkedIn 上让我知道你的想法！(https://www.linkedin.com/in/sky-williams/

资源

Twitter API:【https://developer.twitter.com/en/docs
亚马逊 Web 服务:https://aws.amazon.com
MongoDB:https://www.mongodb.com
如果你想了解我使用的任何技术、算法、方法或库的细节:https://www.linkedin.com/in/sky-williams/

自然语言处理与说唱歌词

原文：https://towardsdatascience.com/natural-language-processing-and-rap-lyrics-c678e60073fb?source=collection_archive---------12-----------------------

梅蒂斯的第四个项目侧重于无监督学习和自然语言处理。我选择探索说唱歌词，希望能根据说唱歌手使用的单词找到不同的组合。

数据

我想看一大堆说唱歌手，包括我不认识的。为了做到这一点，我使用了一个用户创建的有史以来最伟大说唱歌手的列表和另一个有史以来最伟大说唱组合的列表。然后，我从歌词网站 genius 中为每一位艺术家提取了所有的歌曲。

为了获取所有这些数据，我需要对两个网站进行网络抓取。幸运的是，我找到了一个由约翰·米勒创建的 python 包。他的这个 github 页面包括了如何使用代码的例子。

我从 350 多名说唱歌手那里收集了 55000 多首歌曲。我对自己能够得到的金额感到满意，但这非常耗时。这个剧本在我身上失败了几次，所以我不得不运行几次来吸引所有的艺术家。

谁的词汇量最大？

我最初想做一些数据探索，我决定通过使用每个艺术家独有的单词数量来找出谁的词汇量最大。这是受马特·丹尼尔斯(Matt Daniels)关于同一主题的博客帖子的启发。他使用了 85 位艺术家，所以我很想知道，考虑到我使用了 350 多位艺术家，我的结果会和他的结果相比。

为了计算每一位艺术家的独特词汇，我从每一位艺术家的歌曲中随机抽取了一个样本，并查看了歌曲中的前 35000 个词。我想能够比较苹果和苹果，所以如果一个艺术家没有那么多单词，我就把它们排除在外。我不得不考虑的一个问题是如何处理像“走”、“走”和“走”这样的词。将它们全部包括在内意味着，当它们都是同一个单词的变体时，我将把它们作为单独的单词来计算。我决定用一种叫做的方法来解决这个问题。雪球词干器把这三个字都变成了“走”。因此，它们都被认为是同一个词，而不是三个不同的词。

总的来说，东海岸说唱歌手用的词最多，而南方说唱歌手用的最少。最大的异常值是伊索岩石，它以 6542 个独特的单词位居榜首。说唱歌手 NF 的独特词汇最少，为 2084 个。

Jay-Z, one of the most successful artists, landed right in the middle of east region with 4,174 words.

看到地区细分很有趣，但我想展示一些更细致的东西。下面的视频显示了一个可视化，它使用 d3 根据唯一单词的数量来绘制每个说唱歌手。你可以在这里玩。

Demo of how to use the visualization

每个泡泡代表一个特定的说唱歌手，根据他们使用的独特词汇的数量，他们被放在页面上。泡沫越右，他们使用的独特词汇就越多。迄今为止，说话最独特的说唱歌手是伊索·洛克。我把它与两位作家查尔斯·狄更斯和赫尔曼·梅尔维尔进行了比较，以表明《伊索岩石》甚至比得上著名作家。

我还包括不同的过滤器。在“按地区查看”过滤器中，每个艺术家都根据他们来自的地区(东部、西部、中西部或南部)进行颜色编码。在“群组”过滤器中，代表 rap 群组的气泡会高亮显示。我原以为它们会更集中在右边(表示更多的单词)，但它们分布得很均匀。使用大量词汇的一个群体是吴唐族。我加入了一个过滤器，只突出显示了武堂家族的成员，以显示他们每个人比一般说唱歌手使用更多的词。我的最后一个过滤器，非说唱过滤器，突出了三个不同的非说唱歌手(泰勒斯威夫特，披头士和鲍勃迪伦)。我把他们包括进来是因为我想展示说唱歌手和其他流派的比较。事实上，这三个词都在图表的左侧，这表明即使是使用平均或低于平均字数的说唱歌手也比其他流派的著名艺术家使用更多的词。

基于歌词的分组

观察哪些说唱歌手用词最多很有趣，但我的目标是看看我能否根据歌词创建有意义的说唱歌手群体。为了做到这一点，我决定在我的歌曲集上使用主题建模。

我首先使用了术语频率-逆文档频率 (TFIDF)来显示每个单词在语料库中的重要性。这种方法对较罕见的单词给予较大的权重，而对较常见的单词给予较小的权重。TFIDF 基本上表明了一个人看到这个词应该有多惊讶。例如，假设语料库包括 1000 首歌曲。如果一个词出现在每一首歌中，人们看到这个词就不会感到惊讶。但是如果一个词只出现在三首歌里，那么当你在一首特定的歌里看到这个词时，你应该会非常惊讶。

然后，我对我的歌曲集应用了非负矩阵分解(NMF)。我用了 NMF，因为我想让每个主题中的每个单词都有正的权重来帮助解释。一旦我有了每首歌的主题，我就把它们平均到每个艺术家身上，因为我感兴趣的是所有的艺术家，而不是任何一首特定的歌。我期望看到至少两个形式良好的主题，但事实并非如此。遗憾的是，我从 NMF 那里得到的话题并不连贯，也没有形成有意义的群体。我尝试调整许多不同的参数，但没有改善我的话题。

然后，我使用 K-最近邻(KNN)法，根据我的艺术家的个人话题向量对他们进行聚类，看看将说唱歌手分组是否会比我的话题产生更好的分组。我希望看到的一件事是根据说唱歌手来自的地区进行分组。我以为会有地区俚语把西海岸说唱歌手和南方说唱歌手区分开来，或者纽约说唱歌手会自成一派。总的来说，这种情况没有发生。当我尝试三个集群时，我能够得到一个主要是南方说唱歌手的集群和一个有社会意识的说唱歌手的集群。当我增加聚类的数量时，这是我唯一能理解的两个聚类，而其余的聚类看起来是随机的。

虽然我能够得到几个不错的组，但我没有得到我想要的整体清晰的分离。这种失望让我创建了一个推荐系统。

结论

我发现做这个项目很有趣。推荐系统看起来运行良好，但是推荐本身是主观的，所以很难说。我的系统的主要限制是我只能用歌词来做推荐。歌词绝对是决定一个人是否喜欢某个特定歌手/歌曲的重要因素，但这不是唯一的因素。有些人对歌曲的节拍或速度更感兴趣。又或许有人根本不在乎歌词，只在乎歌曲整体的声音。包含这些信息将是我改进系统的第一步。

我学到了什么

****NLP 技术如 TF-IDF and 和 word2vec
****话题建模利用 NMF
****聚类方法如 KNN
创建推荐系统
使用 d3 和烧瓶。我使用 d3 和 flask 来创建我的视觉效果。
使用 Docker 将 Flask 应用程序部署到 AWS EC2 容器服务(ECS)。

自然语言处理:用 scikit-learn 计算矢量化

原文：https://towardsdatascience.com/natural-language-processing-count-vectorization-with-scikit-learn-e7804269bb5e?source=collection_archive---------1-----------------------

这是一个关于如何使用 scikit-learn 对真实文本数据进行计数矢量化的演示。

计数矢量化(也称为一键编码)

如果你还没有，看看我之前关于单词嵌入的博文:单词嵌入介绍

在那篇博客文章中，我们讨论了很多不同的方法来表示机器学习中使用的单词。这是一个高层次的概述，我们将在这里展开，并检查我们如何在一些真实的文本数据上实际使用计数矢量化。

计数向量化概述

今天，我们将探讨用数字表示文本数据的最基本方法之一:一键编码(或计数矢量化)。想法很简单。

我们将创建向量，其维数等于我们的词汇表的大小，如果文本数据以该词汇为特征，我们将在该维数上放置一个 1。每当我们再次遇到这个词，我们将增加计数，留下 0 到处我们没有找到这个词甚至一次。

这样做的结果将是非常大的向量，但是，如果我们在真实的文本数据上使用它们，我们将得到我们的文本数据的单词内容的非常精确的计数。不幸的是，这不能提供任何语义或关系信息，但这没关系，因为这不是使用这种技术的目的。

今天，我们将使用来自 scikit-learn 的软件包。

一个基本例子

以下是使用计数矢量化获取矢量的基本示例:

from sklearn.feature_extraction.text import CountVectorizer

# To create a Count Vectorizer, we simply need to instantiate one.
# There are special parameters we can set here when making the vectorizer, but
# for the most basic example, it is not needed.
vectorizer = CountVectorizer()

# For our text, we are going to take some text from our previous blog post
# about count vectorization
sample_text = ["One of the most basic ways we can numerically represent words "
               "is through the one-hot encoding method (also sometimes called "
               "count vectorizing)."]

# To actually create the vectorizer, we simply need to call fit on the text
# data that we wish to fix
vectorizer.fit(sample_text)

# Now, we can inspect how our vectorizer vectorized the text
# This will print out a list of words used, and their index in the vectors
print('Vocabulary: ')
print(vectorizer.vocabulary_)

# If we would like to actually create a vector, we can do so by passing the
# text into the vectorizer to get back counts
vector = vectorizer.transform(sample_text)

# Our final vector:
print('Full vector: ')
print(vector.toarray())

# Or if we wanted to get the vector for one word:
print('Hot vector: ')
print(vectorizer.transform(['hot']).toarray())

# Or if we wanted to get multiple vectors at once to build matrices
print('Hot and one: ')
print(vectorizer.transform(['hot', 'one']).toarray())

# We could also do the whole thing at once with the fit_transform method:
print('One swoop:')
new_text = ['Today is the day that I do the thing today, today']
new_vectorizer = CountVectorizer()
print(new_vectorizer.fit_transform(new_text).toarray())

我们的产出:

Vocabulary:
{'one': 12, 'of': 11, 'the': 15, 'most': 9, 'basic': 1, 'ways': 18, 'we': 19,
  'can': 3, 'numerically': 10, 'represent': 13, 'words': 20, 'is': 7,
  'through': 16, 'hot': 6, 'encoding': 5, 'method': 8, 'also': 0,
  'sometimes': 14, 'called': 2, 'count': 4, 'vectorizing': 17}
Full vector:
[[1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 2 1 1 1 1 1]]
Hot vector:
[[0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]
Hot and one:
[[0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0]]
One swoop:
[[1 1 1 1 2 1 3]]

在真实数据上使用它:

所以还是用在一些真实数据上吧！我们将查看 scikit-learn 附带的 20 个新闻组数据集。

from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import CountVectorizer

import numpy as np

# Create our vectorizer
vectorizer = CountVectorizer()

# Let's fetch all the possible text data
newsgroups_data = fetch_20newsgroups()

# Why not inspect a sample of the text data?
print('Sample 0: ')
print(newsgroups_data.data[0])
print()

# Create the vectorizer
vectorizer.fit(newsgroups_data.data)

# Let's look at the vocabulary:
print('Vocabulary: ')
print(vectorizer.vocabulary_)
print()

# Converting our first sample into a vector
v0 = vectorizer.transform([newsgroups_data.data[0]]).toarray()[0]
print('Sample 0 (vectorized): ')
print(v0)
print()

# It's too big to even see...
# What's the length?
print('Sample 0 (vectorized) length: ')
print(len(v0))
print()

# How many words does it have?
print('Sample 0 (vectorized) sum: ')
print(np.sum(v0))
print()

# What if we wanted to go back to the source?
print('To the source:')
print(vectorizer.inverse_transform(v0))
print()

# So all this data has a lot of extra garbage... Why not strip it away?
newsgroups_data = fetch_20newsgroups(remove=('headers', 'footers', 'quotes'))

# Why not inspect a sample of the text data?
print('Sample 0: ')
print(newsgroups_data.data[0])
print()

# Create the vectorizer
vectorizer.fit(newsgroups_data.data)

# Let's look at the vocabulary:
print('Vocabulary: ')
print(vectorizer.vocabulary_)
print()

# Converting our first sample into a vector
v0 = vectorizer.transform([newsgroups_data.data[0]]).toarray()[0]
print('Sample 0 (vectorized): ')
print(v0)
print()

# It's too big to even see...
# What's the length?
print('Sample 0 (vectorized) length: ')
print(len(v0))
print()

# How many words does it have?
print('Sample 0 (vectorized) sum: ')
print(np.sum(v0))
print()

# What if we wanted to go back to the source?
print('To the source:')
print(vectorizer.inverse_transform(v0))
print()

我们的产出:

Sample 0:
From: lerxst@wam.umd.edu (where's my thing)
Subject: WHAT car is this!?
Nntp-Posting-Host: rac3.wam.umd.edu
Organization: University of Maryland, College Park
Lines: 15

 I was wondering if anyone out there could enlighten me on this car I saw
the other day. It was a 2-door sports car, looked to be from the late 60s/
early 70s. It was called a Bricklin. The doors were really small. In addition,
the front bumper was separate from the rest of the body. This is
all I know. If anyone can tellme a model name, engine specs, years
of production, where this car is made, history, or whatever info you
have on this funky looking car, please e-mail.

Thanks,
- IL
   ---- brought to you by your neighborhood Lerxst ----

Vocabulary:
{'from': 56979, 'lerxst': 75358, 'wam': 123162, 'umd': 118280, 'edu': 50527,
  'where': 124031, 'my': 85354, 'thing': 114688, 'subject': 111322,
  'what': 123984, 'car': 37780, 'is': 68532, 'this': 114731, 'nntp': 87620,
  'posting': 95162, 'host': 64095, 'rac3': 98949, 'organization': 90379,
  'university': 118983, 'of': 89362, 'maryland': 79666,
  'college': 40998, ... } (Abbreviated...)

Sample 0 (vectorized):
[0 0 0 ... 0 0 0]

Sample 0 (vectorized) length:
130107

Sample 0 (vectorized) sum:
122

To the source:
[array(['15', '60s', '70s', 'addition', 'all', 'anyone', 'be', 'body',
       'bricklin', 'brought', 'bumper', 'by', 'called', 'can', 'car',
       'college', 'could', 'day', 'door', 'doors', 'early', 'edu',
       'engine', 'enlighten', 'from', 'front', 'funky', 'have', 'history',
       'host', 'if', 'il', 'in', 'info', 'is', 'it', 'know', 'late',
       'lerxst', 'lines', 'looked', 'looking', 'made', 'mail', 'maryland',
       'me', 'model', 'my', 'name', 'neighborhood', 'nntp', 'of', 'on',
       'or', 'organization', 'other', 'out', 'park', 'please', 'posting',
       'production', 'rac3', 'really', 'rest', 'saw', 'separate', 'small',
       'specs', 'sports', 'subject', 'tellme', 'thanks', 'the', 'there',
       'thing', 'this', 'to', 'umd', 'university', 'wam', 'was', 'were',
       'what', 'whatever', 'where', 'wondering', 'years', 'you', 'your'],
      dtype='<U180')]

Sample 0:
I was wondering if anyone out there could enlighten me on this car I saw
the other day. It was a 2-door sports car, looked to be from the late 60s/
early 70s. It was called a Bricklin. The doors were really small. In addition,
the front bumper was separate from the rest of the body. This is
all I know. If anyone can tellme a model name, engine specs, years
of production, where this car is made, history, or whatever info you
have on this funky looking car, please e-mail.

Vocabulary:
{'was': 95844, 'wondering': 97181, 'if': 48754, 'anyone': 18915, 'out': 68847,
  'there': 88638, 'could': 30074, 'enlighten': 37335, 'me': 60560, 'on': 68080,
  'this': 88767, 'car': 25775, 'saw': 80623, 'the': 88532, 'other': 68781,
  'day': 31990, 'it': 51326, 'door': 34809, 'sports': 84538, 'looked': 57390,
  'to': 89360, 'be': 21987, 'from': 41715, 'late': 55746, '60s': 9843,
  'early': 35974, '70s': 11174, 'called': 25492, 'bricklin': 24160, 'doors': 34810,
  'were': 96247, 'really': 76471, ... } (Abbreviated...)

Sample 0 (vectorized):
[0 0 0 ... 0 0 0]

Sample 0 (vectorized) length:
101631

Sample 0 (vectorized) sum:
85

To the source:
[array(['60s', '70s', 'addition', 'all', 'anyone', 'be', 'body',
       'bricklin', 'bumper', 'called', 'can', 'car', 'could', 'day',
       'door', 'doors', 'early', 'engine', 'enlighten', 'from', 'front',
       'funky', 'have', 'history', 'if', 'in', 'info', 'is', 'it', 'know',
       'late', 'looked', 'looking', 'made', 'mail', 'me', 'model', 'name',
       'of', 'on', 'or', 'other', 'out', 'please', 'production', 'really',
       'rest', 'saw', 'separate', 'small', 'specs', 'sports', 'tellme',
       'the', 'there', 'this', 'to', 'was', 'were', 'whatever', 'where',
       'wondering', 'years', 'you'], dtype='<U81')]

现在怎么办？

所以，你现在可能想知道什么？我们知道如何基于计数对这些东西进行矢量化，但是我们实际上能利用这些信息做什么呢？

首先，我们可以做一系列的分析。我们可以查看词频，我们可以删除停用词，我们可以可视化事物，我们可以尝试聚类。现在我们有了这些文本数据的数字表示，我们可以做很多以前做不到的事情！

但是让我们更具体一点。我们一直在使用来自 20 个新闻组数据集中的文本数据。为什么不把它用在任务上呢？

20 个新闻组数据集是一个论坛帖子的数据集，分为 20 个不同的类别。为什么不使用我们的矢量化工具来尝试对这些数据进行分类呢？

from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import CountVectorizer

from sklearn.naive_bayes import MultinomialNB
from sklearn import metrics

# Create our vectorizer
vectorizer = CountVectorizer()

# All data
newsgroups_train = fetch_20newsgroups(subset='train',
                                      remove=('headers', 'footers', 'quotes'))
newsgroups_test = fetch_20newsgroups(subset='test',
                                     remove=('headers', 'footers', 'quotes'))

# Get the training vectors
vectors = vectorizer.fit_transform(newsgroups_train.data)

# Build the classifier
clf = MultinomialNB(alpha=.01)

#  Train the classifier
clf.fit(vectors, newsgroups_train.target)

# Get the test vectors
vectors_test = vectorizer.transform(newsgroups_test.data)

# Predict and score the vectors
pred = clf.predict(vectors_test)
acc_score = metrics.accuracy_score(newsgroups_test.target, pred)
f1_score = metrics.f1_score(newsgroups_test.target, pred, average='macro')

print('Total accuracy classification score: {}'.format(acc_score))
print('Total F1 classification score: {}'.format(f1_score))

我们的产出:

Total accuracy classification score: 0.6460435475305364
Total F1 classification score: 0.6203806145034193

嗯……所以不是超级神奇，但我们只是使用计数向量！一个更丰富的表现将为我们的分数创造奇迹！

包扎

希望您感觉已经学到了很多关于计数矢量化的知识，如何使用它，以及它的一些潜在应用！

如果你喜欢读这篇文章，给我留言或者给我的 GoFundMe 捐款来帮助我继续我的 ML 研究！

敬请关注即将推出的更多单词嵌入内容！

用 Python 实现模糊字符串匹配的自然语言处理

原文：https://towardsdatascience.com/natural-language-processing-for-fuzzy-string-matching-with-python-6632b7824c49?source=collection_archive---------2-----------------------

photo credit: Pexels

当我们比较不同网站的酒店房价时，我们必须确保我们是在进行比较

在计算机科学中，模糊字符串匹配是一种寻找与模式近似(而不是精确)匹配的字符串的技术。换句话说，模糊字符串匹配是一种即使用户拼错单词或只输入部分单词也能找到匹配项的搜索类型。也被称为近似串匹配。

模糊字符串搜索可用于各种应用，例如:

拼写检查和拼写错误，错别字校正器。例如，用户在谷歌中输入“密西沙加”，会返回一个点击列表以及“显示密西沙加的结果”。也就是说，即使用户输入包含额外的或缺失的字符，或其他类型的拼写错误，搜索查询也将返回结果。
一个软件可以用来检查重复的记录。例如，如果由于客户姓名的不同拼法(例如 Abigail Martin vs . Abigail Martinez)而在数据库中多次列出不同的购买记录，则可能是新地址或错误输入的电话号码。

说到重复数据删除，它可能不像听起来那么简单，尤其是当您有成千上万条记录时。甚至 Expedia 也没有做到 100%正确:

Source: Expedia

这篇文章将解释什么是模糊字符串匹配及其用例，并给出使用 Python 的 Fuzzywuzzy 库的例子。

每家酒店都有自己的房间命名法，在线旅行社也是如此。例如，同一家酒店的一个房间，Expedia 称之为“工作室，一张特大床和沙发床，角落”，Booking.com 可能会发现简单地将房间显示为“角落特大工作室”是安全的。

这没有错，但当我们想要比较在线旅行社之间的房价时，或者一家在线旅行社想要确保另一家在线旅行社遵守价格平价协议时，这可能会导致混乱。换句话说，为了能够比较价格，我们必须确保我们是在比较苹果与苹果。

对于价格比较网站和应用程序来说，最令人沮丧的问题之一是试图自动判断两件商品(或酒店房间)是否是同一件东西。

Python 中的 FuzzyWuzzy

Fuzzywuzzy 是一个 Python 库，使用 Levenshtein 距离来计算一个简单易用的包中序列之间的差异。

为了演示，我创建了自己的数据集，也就是说，对于同一个酒店，我从 Expedia 获取一个房间类型，比如“套房，一张特大床(客厅)”，然后我将其与 Booking.com 的一个房间类型“特大客厅套房”进行匹配。只要有一点点经验，大多数人就会知道它们是一样的。按照这种方法，我创建了一个小型数据集，包含 100 多个房间类型对，可以在 Github 上找到。

利用这个数据集，我们将测试 Fuzzywuzzy 是如何思考的。换句话说，我们使用 Fuzzywuzzy 来匹配两个数据源之间的记录。

import pandas as pddf = pd.read_csv('room_type.csv')
df.head(10)

Figure 1

数据集是我自己创建的，所以，很干净。

Fuzzywuzzy 中比较两个字符串有几种方法，我们一个一个来试试。

ratio，比较整个字符串的相似度，按顺序排列。

from fuzzywuzzy import fuzz
fuzz.ratio('Deluxe Room, 1 King Bed', 'Deluxe King Room')

这告诉我们“豪华客房，一张特大床”和“豪华大床房”大约有 62%是相同的。

fuzz.ratio('Traditional Double Room, 2 Double Beds', 'Double Room with Two Double Beds')

“传统双人房，两张双人床”和“双人房，两张双人床”大约有 69%相同。

fuzz.ratio('Room, 2 Double Beds (19th to 25th Floors)', 'Two Double Beds - Location Room (19th to 25th Floors)')

“房间，两张双人床(19 至 25 层)”和“两张双人床-位置房间(19 至 25 层)”对大约 74%相同。

我对这些感到失望。事实证明，这种天真的方法对词序的微小差异、遗漏或多余的单词以及其他类似问题过于敏感。

partial_ratio，比较部分字符串相似度。

我们仍然使用相同的数据对。

fuzz.partial_ratio('Deluxe Room, 1 King Bed', 'Deluxe King Room')

fuzz.partial_ratio('Traditional Double Room, 2 Double Beds', 'Double Room with Two Double Beds')

fuzz.partial_ratio('Room, 2 Double Beds (19th to 25th Floors)', 'Two Double Beds - Location Room (19th to 25th Floors)')

对于我的数据集，比较部分字符串并不能带来整体更好的结果。我们继续。

token_sort_ratio，忽略词序。

fuzz.token_sort_ratio('Deluxe Room, 1 King Bed', 'Deluxe King Room')

fuzz.token_sort_ratio('Traditional Double Room, 2 Double Beds', 'Double Room with Two Double Beds')

fuzz.token_sort_ratio('Room, 2 Double Beds (19th to 25th Floors)', 'Two Double Beds - Location Room (19th to 25th Floors)')

目前为止最好的。

token_set_ratio，忽略重复单词。它类似于令牌排序比率，但更灵活一点。

fuzz.token_set_ratio('Deluxe Room, 1 King Bed', 'Deluxe King Room')

100

fuzz.token_set_ratio('Traditional Double Room, 2 Double Beds', 'Double Room with Two Double Beds')

fuzz.token_set_ratio('Room, 2 Double Beds (19th to 25th Floors)', 'Two Double Beds - Location Room (19th to 25th Floors)')

看起来token_set_ratio 最适合我的数据。根据这个发现，我决定将token_set_ratio应用于我的整个数据集。

def get_ratio(row):
    name = row['Expedia']
    name1 = row['Booking.com']
    return fuzz.token_set_ratio(name, name1)
len(df[df.apply(get_ratio, axis=1) > 70]) / len(df)

0.9029126213592233

当设置比率> 70 时，超过 90%的配对超过 70 的匹配分数。没那么寒酸！

Jupyter 笔记本可以在 Github 上找到。星期五快乐！

自然语言处理的应用——三大商业应用

原文：https://towardsdatascience.com/natural-language-processing-in-action-top-3-business-applications-c9bf941be917?source=collection_archive---------7-----------------------

Photo by Gonard Fluit on Unsplash

如果你曾经问过亚马逊的 Alexa 或苹果的 Siri 一个问题，并得到了答案，那么你就体验过自然语言处理(NLP)的实际应用。你的设备能听到你说话，理解你的意图，并执行一个动作，所有这一切只需要 4 秒钟。你知道它起作用了，因为它告诉你——在一个恰当表达和完美说出的人类句子中。

自然语言处理处理计算机如何理解、解释和处理人类语言。这项技术并不新鲜，但由于计算技术的快速进步和更容易获取大数据，它正在快速发展。

让我们来看看企业将 NLP 付诸实践的三种最常见的方式。

1。解决客户难题—通过情绪分析进行监控

精明的消费者在网上表达他们的抱怨(有时也表达他们的欣赏)，这就是为什么品牌声誉监测如此重要。了解社交媒体和其他地方对你的公司或产品的评价是了解客户声音的简单方法。

然而，随着数据比以往任何时候都多，手动分析几乎是不可能的，这就是人工智能的帮助所在。通过情感分析，公司部署了执行文本分析和自然语言处理的算法，以理解单词背后的情感或意义。

无论是识别你的品牌在社会上的提及，发现负面评论，还是深入了解公众意见，了解人们对你的企业的看法和原因，就有可能推动战略，开展更好地满足他们需求的活动。

情感分析的最终结果会产生深远的影响。作为锡拉丘兹大学自然语言处理课程的一部分，三名学生构建了一个原型情感分析仪来测量媒体对唐纳德·川普的情感。该模型分析了数千篇关于当选总统唐纳德·特朗普的文章，可用于帮助未来的政治人物制定更好的媒体战略计划。

2。收集市场情报—从非结构化数据中提取

了解你的竞争对手是做什么的，以及在更大的范围内，你的行业整体是做什么的，可以帮助你制定一个有效的商业策略。然而，今天收集的大部分数据都是非结构化的，这意味着这些数据是从社交媒体、电子邮件甚至是通过与客户服务代表的互动中产生的。

关于竞争对手、客户和市场如何相互作用的见解，往往隐藏在新闻文章、报告、SEC 文件和公司网站的文本、信息图表和图像中。自然语言处理通过文本提取和分类，帮助企业快速、大规模地理解这些信息。例如，及时披露公司合并的消息会对交易决策产生重大影响。

3。减少客户挫折感—增强混合机器人的体验

虚拟协助极大地改善了客户体验。有了自助式数字解决方案，消费者可以避免漫长的等待时间，并实时获得最紧迫问题的答案。随着 NLP 技术的改进，“混合”机器人正在取代传统机器人——传统机器人有时不知道如何完全回答查询。

NLP 支持的助手将虚拟和人工支持结合在一起，提供了更好的客户体验，当他们不明白客户想要什么时，可以快速将机器主导的对话转移给人类。在挫败感出现之前，将对话交给现场客服代表是确保有意义的互动和屡获殊荣的客户体验的关键。

像今天的许多品牌一样，可口可乐将虚拟辅助软件与客户服务部门集成在一起，以更好地满足消费者的需求。据报道， Ask Coca-Cola 助手每月成功处理 3 万次对话，减少了电话互动的需求。

总之

随着处理能力的提高，企业正在使用 NLP 等人工智能技术，通过情感分析来更好地理解客户意图，从非结构化数据中提取洞察力，并减轻客户的挫折感。

自然语言处理技术可以比人类更快地分析基于语言的数据，没有偏见，不会累，也不需要休假。随着每天产生大量数据，全面分析文本(来自每个来源)的能力将成为一项优势。

人工智能中的自然语言处理几乎是人类级别的精确。更糟糕的是，它变聪明了！

原文：https://towardsdatascience.com/natural-language-processing-in-artificial-intelligence-is-almost-human-level-accurate-fbdaffed6392?source=collection_archive---------3-----------------------

深度学习时代之前

早在深度学习时代之前的日子里——那时神经网络更像是一种可怕、神秘的数学好奇心，而不是一种强大的机器学习或人工智能工具——在自然语言处理(NLP) 领域，经典数据挖掘算法有许多令人惊讶的相对成功的应用。似乎像 T2 的垃圾邮件过滤和 T4 的词性标注这样的问题可以用简单易懂的模型来解决。

但并不是每个问题都能这样解决。简单的模型无法充分捕捉语言的微妙之处，如上下文、习语或讽刺(尽管人类也经常在这方面失败)。基于整体摘要的算法(例如词袋)被证明不足以捕捉文本数据的顺序性质，而 n 元语法努力为一般上下文建模，并严重遭受维数灾难。即使是基于嗯的模型也很难克服这些问题，因为它们具有马尔可夫性(比如，它们的无记忆性)。当然，这些方法也用于处理更复杂的 NLP 任务，但不是很成功。

首次突破— Word2Vec

NLP 领域在单词的语义丰富表示形式方面经历了第一次重大飞跃，这是通过应用神经网络实现的..在此之前，最常见的表示方法是所谓的 one-hot 编码，其中每个单词都被转换为唯一的二进制向量，只有一个非零条目。这种方法很大程度上受到稀疏性的影响，并且根本没有考虑特定单词的含义。

图 1: Word2Vec 将单词投影到二维空间上的表示法。

相反，想象从一串单词开始，删除中间的一个，并让神经网络预测给定中间单词的上下文( skip-gram )。或者，要求它基于上下文预测中心单词(即，连续的单词包， CBOW )。当然，这样的模型是没有用的，但事实证明，作为一个副作用，它产生了一个惊人强大的向量表示，保留了单词的语义结构。

进一步的改进

尽管新的强大的 Word2Vec 表示提高了许多经典算法的性能，但仍然需要一种能够捕获文本中顺序依赖关系的解决方案(长期和短期)。这个问题的第一个概念是所谓的香草递归神经网络(RNNs)。传统的 rnn 利用数据的时间特性，在使用存储在隐藏状态中的关于先前单词的信息的同时，将单词顺序地馈送给网络。

图 2: 一个递归神经网络。图片来自一位优秀的 Colah 在 LSTMs 上的帖子

事实证明，这些网络很好地处理了局部依赖性，但由于消失梯度而难以训练。为了解决这个问题，计算机科学家&机器学习研究人员开发了一种新的网络拓扑结构，称为长短期记忆( LSTM )。LSTM 通过在网络中引入被称为存储单元的特殊单元来解决这个问题。这种复杂的机制允许在不显著增加参数数量的情况下找到更长的模式。许多流行的架构也是 LSTM 的变体，如 mLSTM 或 GRU ，由于存储单元更新机制的智能简化，这些架构显著减少了所需的参数数量。

在计算机视觉中卷积神经网络取得惊人成功之后，它们被纳入 NLP 只是时间问题。今天，1D 卷积是许多成功应用的热门构建模块，包括语义分割，快速机器翻译，以及通用序列到序列学习框架——它胜过递归网络，并且由于更容易并行化，可以更快地训练一个数量级。

👀 卷积神经网络，最初用于解决计算机视觉问题，并在该领域保持最先进水平。了解更多关于他们的应用和功能。

典型的 NLP 问题

有各种各样的语言任务，虽然简单并且是人类的第二天性，但对机器来说却非常困难。这种混淆主要是由于语言上的细微差别，如反语和习语。让我们来看看研究人员正在努力解决的 NLP 的一些领域(大致按照它们的复杂性排序)。

最常见也可能是最简单的是情感分析。本质上，这决定了说话者/作者对某个特定话题(或总体)的态度或情绪反应。可能的情绪有积极的、中立的和消极的。查看这篇伟大的文章关于使用深度卷积神经网络来衡量推文中的情绪。另一个有趣的实验表明，一个深度循环网络可以偶然地学习情绪。

图 3 : 激活用于生成文本下一个字符的网络中的神经元。很明显，它学会了这种情绪，尽管它是在完全无人监督的环境中接受训练的。

前一种情况的自然推广是文档分类，我们解决了一个普通的分类问题，而不是给每篇文章分配三个可能的标志中的一个。根据对算法的综合比较，可以肯定地说深度学习是文本分类的必由之路。

现在，我们开始真正的交易:机器翻译。很长一段时间以来，机器翻译一直是一个严峻的挑战。重要的是要理解，这是一个完全不同的任务，与前两个我们已经讨论过。对于这个任务，我们需要一个模型来预测单词序列，而不是标签。机器翻译清楚地表明了深度学习有什么值得大惊小怪的，因为当涉及到序列数据时，它已经是一个令人难以置信的突破。在这篇博文中，你可以读到更多关于如何——是的，你猜对了——递归神经网络处理翻译的内容，在这篇中，你可以了解它们如何实现最先进的结果。

假设你需要一个自动的文本摘要模型，你希望它只提取文本中最重要的部分，同时保留所有的意思。这需要一种算法，它可以理解整个文本，同时专注于承载大部分意思的特定部分。这个问题被注意机制巧妙地解决了，它可以作为模块引入到端到端解决方案中。

最后，还有问答，这是你能得到的最接近人工智能的东西。对于这项任务，模型不仅需要理解一个问题，还需要对感兴趣的文本有全面的理解，并确切地知道在哪里寻找答案。对于一个问题回答解决方案的详细解释(当然是使用深度学习)，请查看这篇文章。

图 4: 漂亮 可视化 一个被训练成将英语翻译成法语的递归神经网络中的注意机制。

由于深度学习为各种类型的数据(例如，文本和图像)提供了向量表示，因此您可以建立模型来专攻不同的领域。研究人员就是这样想出了 视觉问答 。任务很“琐碎”:只需回答一个关于某个图像的问题。听起来像是 7 岁小孩的工作，对吧？尽管如此，深度模型是第一个在没有人类监督的情况下产生合理结果的模型。该模型的结果和描述见本文。

概述

现在你知道了。由于计算问题，深度学习最近才出现在 NLP 中，我们需要学习更多关于深度神经网络的知识，以了解它们的能力。但一旦我们做到了，它就永远改变了游戏。

转帖: 用 NLP 提升你的解决方案，sigmoid id . io

python 中多列的自然语言处理

原文：https://towardsdatascience.com/natural-language-processing-on-multiple-columns-in-python-554043e05308?source=collection_archive---------0-----------------------

当我第一次听说 NLP 的时候，我很惊讶，也有点不知所措。用最基本的术语来说，NLP 或自然语言处理通过文本数据并检查每个特征(在这种情况下是单词或字符)对于我们的因变量的预测能力的重要性。鉴于语言在我们的世界中的重要性，将数据科学扩展到定性变量的能力似乎是必不可少的。根据数据集的大小，这可能意味着它会遍历 1，000 个要素，因此计算量可能会很大，但有一些方法可以限制处理需求。

有几种不同类型的 NLP，我们在训练营中使用的主要是 CountVectorizer (CVec)和 TFIDF Vectorizer(词频逆文档频率)。知道如何在不同种类的数据中进行选择，通常只是对您的数据(或数据的子集)进行测试，看看哪一种性能更好。考虑这种差异的最简单的方法是，CVec 将计算一个单词在文档中出现的次数，而 TFIDF 将比较一个单词在文档中出现的次数和该短语在多少个文档中出现。如果一个单词只在一小部分文档中出现，TFIDF 将赋予它更高的“特征重要性”

我发现使用 NLP 的主要缺点是，除了计算量大以外，您只能在一列上运行 CVec 或 TFIDF。我正在处理从 Indeed.com 搜集的数据，我想检验一下职位和城市是否会对工资是高于还是低于中位数产生预测作用。我选择使用 CVec 来做这件事，纯粹是因为它对我正在处理的数据更有预测性。

Here’s the head of my data. Avg = salary averaged if given range, Dumsal= a dummy variable if my average salary was above or below my median salary of $106,750

我开始在我的数据顶部导入一些东西。因为我要做交叉验证和训练测试分割，所以我需要导入一些你可能不需要的东西。

在我完成导入之后，我设置了我的 X 和 y 变量，并完成了我的训练测试分割。我选择了 0.33 的测试大小，因为这是行业标准。由于我试图根据我的职位对我的虚拟工资变量进行分类，我将它们设置为我的 X 和 y。我最初试图放入多个列，当我发现我不能时，我决定写这篇博客！

当您创建 CountVectorizer 时，有一些事情需要记住:

你需要在 X 列车上适应和转换
您只在 X_test 上转换
在转换过程中，将它们都更改为数据帧，以便稍后可以对它们执行回归

我们只适合 X_train，就像我们在 python 中处理过的其他模型一样。我们希望只根据训练数据来训练模型，然后我们想对测试数据做的就是根据我们的训练数据来转换它。我们仍然需要这两个都是数据帧，所以我们将 fit 中制作的矩阵转换为密集矩阵，这样它们就可以很容易地制作成数据帧。

在将我的 X_test 转换为密集矩阵之后，我想检查并确保我的 X_train 数据帧和 y_train 具有相同数量的特征，并且对于我的测试集也是相同的。当我发现它们确实如此时，我可以用这些术语进行回归！

我对这些数据框架进行了线性回归，发现我的得分在 0.77 左右。虽然这还不错，但我希望做得更好，所以我决定也在我的城市专栏上做 NLP！

I followed the same steps as above and fit/transformed a CVec on my city column as well.

下一步对于在多个列上完成 NLP 是最重要的。在为您选择的每个列拟合/转换 CVecs 之后，您需要将它们连接起来，这样我们就可以将它们作为一个数据帧来运行分类算法。因为我们希望它们成为特性，所以我们将沿着列连接它们，而不是将它们放在数据帧的底部。

我们可以看到，我的新 X_train 数据框架和 y_train 数据框架具有相同的列数，因此我们可以成功地对它们运行回归。最后一步只是再次运行逻辑回归，看看这个模型是否比我的第一个模型更好。

因为这个分数明显比我的原始分数差，所以我选择不使用串联数据帧，但是，嘿，我在这个过程中学到了一些新东西！

[## sk learn . feature _ extraction . text . count vectorizer-sci kit-learn 0 . 18 . 1 文档

本文档适用于 sci kit-学习版本 0.18.1 -其他版本

scikit-learn.org](http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.CountVectorizer.html)

用 Python 进行自然语言处理

原文：https://towardsdatascience.com/natural-language-processing-with-python-b3aad16f578f?source=collection_archive---------3-----------------------

有许多方法可以使用自然语言处理，也称为 NLP。在这篇博客中，我们将讨论计数矢量器，以及它在制作模型时如何有用。

让我们从什么是 NLP 开始。这是一种将单词转化为数值的方法，这样我们就可以根据这些数据进行分析并建立预测模型。

我喜欢用例子来展示，所以今天我们将根据类别用不同的电子邮件从 sklearn 中读取数据集。我们将只阅读其中的四个类别，并在它们上面练习使用 nlp。我们将制作一个模型来确定电子邮件是否属于某个类别。

首先，我们需要阅读一些字典

**import** **pandas** **as** **pd**
**import** **numpy** **as** **np**
**import** **matplotlib.pyplot** **as** **plt**
%matplotlib inline
 *# Getting that SKLearn Dataset* 
**from** **sklearn.datasets** **import** fetch_20newsgroups

这给了我们一些可以使用的库，并通过我们的电子邮件信息从 sklearn 导入数据集。

categories = [
    'alt.atheism',
    'talk.religion.misc',
    'comp.graphics',
    'sci.space',
]
*# Setting out training data*
data_train = fetch_20newsgroups(subset='train',categories=categories,
                                shuffle=True, random_state=42,
                                remove=('headers', 'footers', 'quotes'))
*# Setting our testing data*
data_test = fetch_20newsgroups(subset='test', categories=categories,
                               shuffle=True, random_state=42,
                               remove=('headers', 'footers', 'quotes'))

在这个代码块中，我们决定了我们想要的 4 个类别。然后制作我们的训练集和测试集。我们将类别设置为与上述四个类别相同，并删除了页眉、页脚和引号。

data_train.keys() #tells us what keys are in our datasetlen(data_train['data']) #looks at the length of the data_train
len(data_train['target'])#looks at the length of the data_test

我们要确保数据列和目标列的长度相等，否则在建模时会出现错误。

**from** **sklearn.feature_extraction.text** **import** CountVectorizer
 *# Setting the vectorizer just like we would set a model* 
cvec = CountVectorizer(stop_words='english')*# Fitting the vectorizer on our training data* cvec.fit(data_train['data'])

我们将 cvec 设置为等于 CountVectorizer，这样以后就可以方便地调用它了。此外，我在 stop_words = 'english '中添加了。这是用我们常用的英语单词，如“the”、“a”、“and”等。这是有用的，所以我们不要把我们的模型建立在这些实际上没有预测意义的单词上。然后，它需要安装在 data_train['data']上。

X_train = pd.DataFrame(cvec.transform(data_train['data']).todense(),
                       columns=cvec.get_feature_names())

这一步是转换训练数据。的。todense()将把它变成一个矩阵(并且很容易转换成 pandas DataFrame)。使 columns = cvec.get_feature_names()将使每一列等于我们正在分析的一个不同的单词。

*# Which words appear the most.*
word_counts = X_train.sum(axis=0)
word_counts.sort_values(ascending = False).head(20)

然后，我制作了一个单词计数器，它将查看我们转换后的 X_train 并向上计数单词，制作 sort_values(升序= False)将从最高计数的单词开始，到最低计数的单词。

names = data_train['target_names']

名称现在等于我们最初读入数据帧的 4 个类别。

X_test = pd.DataFrame(cvec.transform(data_test['data']).todense(),
                      columns=cvec.get_feature_names())

然后，我们需要像上面对 X_train 所做的那样转换我们的 X_test。

y_test = data_test['target']

并设置我们的 y_test 来测试我们的模型有多精确

**from** **sklearn.linear_model** **import** LogisticRegression
lr = LogisticRegression()
lr.fit(X_train, y_train) 
lr.score(X_test, y_test)

我们的最后一步是在 X_train 和 y_train 上拟合我们的模型，然后在 X_test 和 y_test 上测试我们的模型。lr.score(X_test，y_test)让我们知道我们的模型执行得有多好。在这种情况下，它大约有 75%准确性。

用 Quora 进行自然语言处理

原文：https://towardsdatascience.com/natural-language-processing-with-quora-9737b40700c8?source=collection_archive---------2-----------------------

在推荐系统中使用单词嵌入之后，我现在想使用这些嵌入来创建一个自然语言处理神经网络。

内容:

0.设置和单词嵌入

我的第一个自然语言处理神经网络
清理文本
添加附加功能

**挑战:**正确评估 Quora 上的问题是否互相重复。

Kaggle 提供的数据来自一个 csv 文件，共有五行:

id                                                              3
qid1                                                            7
qid2                                                            8
question1       Why am I mentally very lonely? How can I solve...
question2       Find the remainder when [math]23^{24}[/math] i...
is_duplicate                                                    0

其中，如果问题的意图相同，is_duplicate 为 1，否则为 0。我想用这些数据来预测测试集中的问题是否重复。

0.设置

链接到代码

首先，我需要将这个 csv 文件中的数据转换成可以输入神经网络的东西。

0.1 标记和填充问题

做到这一点的第一步是将问题中的单词转换成我的神经网络更容易比较的东西。幸运的是，我已经使用单词嵌入完成了这项工作(我在这里探索了)，它将单词转换成浮点数组。

Keras 的神经网络也喜欢接收相同大小的所有输入。因为不是所有的问题都是一样长的，所以我需要选择一个问题长度(每个问题我将输入多少单词到我的神经网络中)。

为了找到最佳问题长度，让我们看看问题长度在整个数据集中是如何变化的:

The longest question length is 237 words
The mean question lengths are 10.9422317754 and 11.1820410203

这不是很有帮助。我还可以画出问题长度的频率:

A plot of the frequency of question lengths in the dataset

这更能说明问题！这个数据集有一条很长的尾巴，但是绝大多数问题都少于 35 个单词。选择这个作为我的最大问题长度将比 237 个单词计算效率高得多(我将使用 300 维单词嵌入，所以这样我将训练 35300 个数组，而不是 237300 个数组)。

MAX_LENGTH = 35

既然我已经定义了这个长度，我想把我的问题变成由单词 embeddings 定义的 35 个元素的数组。

一种低效的方法是将字符串传递给神经网络，并有一个带有字典的嵌入层来嵌入单词。更好的方法是用一个整数表示每个单词，并有一个字典将每个单词翻译成整数。

Keras 有一个名为 Tokenizer 的函数可以做到这一点。我可以选择有多少单词被编入索引(在我的例子中，我选择了数据集中最常见的 20，000 个单词)

tokenizer = Tokenizer(nb_words = 20000)
tokenizer.fit_on_texts(train.question1 + train.question2)q1sequence = tokenizer.texts_to_sequences(train.question1)
q2sequence = tokenizer.texts_to_sequences(train.question2)word_index = tokenizer.word_index

word_index现在是一个字典，它将每个单词链接到一个唯一的整数(例如:’replaces': 28265)。

Keras 还有一个确保所有输入序列长度相同的功能:

q1_input = pad_sequences(q1sequence, maxlen = MAX_LENGTH)
q2_input = pad_sequences(q2sequence, maxlen = MAX_LENGTH)

我几乎准备好训练神经网络了！

0.2.添加单词嵌入

最后一步是获取这些输入，这些输入现在是长度为 35 的整数数组(其中每个整数都可以链接到一个单词)，并添加由单词嵌入捕获的有用信息。

我不能只为包含单词 embeddings 的输入创建一个数组，因为生成的数组太大了，它占用了 python 的所有内存(我试过了，当我把它保存为文本文件时，它是 18Gb)。

一个更好的方法是给我的神经网络添加一个嵌入层，其中每个输入只有在通过网络时才被赋予它的嵌入。为此，我需要制作另一个字典，它接受q1_input和q2_input中的整数，并将它们翻译成各自的单词嵌入。

第一步是打开 Glove 嵌入，这是一个文本文件，并将它们转换成一个字典。然后我可以创建一个嵌入矩阵，它包含所有的手套嵌入，并将它们(通过索引)链接到word_index中的所有单词。

当然，并不是我的数据中的每个单词都有一个手套式的等价物(例如，有些人会拼错单词)；如果是这种情况，我让向量只有零。

有了这个嵌入矩阵，我就可以创建一个嵌入层，它将成为我的神经网络的输入层:

embedding_layer = Embedding(len(word_index) + 1,
                            EMBEDDING_DIM,
                            weights=[embedding_matrix],
                            input_length=MAX_LENGTH,
                            trainable=False)

我现在有了训练神经网络的所有要素！

1.我的第一个自然语言处理神经网络

递归神经网络(我在这里看的是)有很大的意义；为了让我的神经网络理解一个问题背后的意图，它需要记住第一个单词是什么，即使它到了第十个单词。

我还想让我的神经网络分别考虑这两个问题，从中提取意义，然后再一起考虑。

The architecture of my neural network. The LSTM (recurrent) layers extract meaning from the questions, before a dense layer compares them. A batch normalization layer was present between every layer, and dropout was used to prevent overfitting. Note: here is a fantastic blog post on how LSTMs work.

训练该神经网络 5 个时期产生 1.4161 的确认损失:

Epoch 5/5
322894/322894 [==============================] - 131s - loss: 0.6615 - val_loss: 1.4161

这不是一个很好的结果，但是当你考虑我是如何处理这个问题的时候，这是有意义的；我根本没有对问题进行预处理。这势必会降低我的网络的准确性。例如，在 Quora 上，人们很容易出现拼写错误。

事实上，在我的word_index字典中的 96500 个单词中，有 36169 个没有手套的对等词。这意味着超过 1/3 的被发送到我的神经网络的嵌入数组都是零！

2.清理文本

让我们来看看 Quora 数据集中的一些问题:

question 1: Which one dissolve in water quikly sugar, salt, methane and carbon di oxide?
question 2: Which fish would survive in salt water?

单词“quikly”拼错了，并且没有手套的对等词，尽管很明显作者想要写“quickly ”,事实也的确如此。

幸运的是，一个 Kaggle 用户(Currie32)已经找到了一个清理文本的好方法，我可以在我的模型中实现它。它去掉了无用的词(如the)，并清除了文本中明显的拼写错误。例如，相同的问题对后清理是

question 1: one dissolve in water quickly sugar salt methane carbon di oxide
question 2: fish would survive in salt water

在干净的文本上运行模型(注意:这需要重新制作word_index字典和嵌入矩阵)在 5 个时期后产生 1.0955 的验证损失，明显更好的性能:

The output of my neural network with cleaned text. For comparison, the validation loss of the first network is plotted in red as ‘old val_loss’.

虽然这个性能比最好的 Kaggle 分数差了很多，但是验证损失根本没有收敛。

收敛训练

Training to convergence yielded a minimum loss of 0.4008. Overfitting still occurs.

注意:作为 Keras 的一个怪癖，这个模型在 Tensorflow 上的训练比在 Theano 上好得多。

虽然这是一个不坏的模型(它有 81%的准确率)，但它与 Kaggle 最好的提交材料相去甚远。为了与 Kaggle 的排行榜竞争，在训练我的神经网络时，我还需要考虑一件事:

3.(奖金！)添加附加功能

Kaggle 将泄漏定义为“在训练数据中创建意外的附加信息”。换句话说，除了问题本身，我还能从我得到的训练数据中提取什么来改进我的模型？

因为这些特征是在进行竞赛时意外创建的，所以它们不能真实地反映数据集(即 Quora 本身不能使用这些特征来识别问题是否重复，这些特征对于如何创建该数据集是唯一的)。

有两个额外的特征被证明非常能预测问题是否是重复的:

问题在数据集中出现的频率
问题之间的交集(问题 1 数据集和问题 2 数据集共有的问题数量)。

仅仅增加这两个泄漏就减少了我在 5 个纪元后对0.7754的验证损失！(与清理数据集的1.0955和最初使用 Theano 后端时的1.4161相比)。

结论

从这里可以得到一些启示:

lstm 很厉害！清理文本将“空”向量的百分比从 37%降低到 29%，因此即使只有 71%的单词，网络也能够以 80%的准确率正确判断问题的意图。
**我输入数据的方式很重要:**除了清理数据，在训练收敛时改进我的网络的一个重要步骤是重复数据，因此问题 1 的输入是question1 + question2，问题 2 的输入是question 2 + question 1；事后看来，这完全有道理，因为问题的顺序与我的网络是否认为它们是重复的没有关系，这很容易增加我的网络可用的训练数据量。
寻找数据集中存在但不明显的额外数据可以显著提高我的网络性能。与其盲目地建立一个网络并把数据扔向它，不如看看数据集来判断什么可能是重要的。

【Nature / Google /论文摘要】利用电子健康记录进行可扩展的精确深度学习

原文：https://towardsdatascience.com/nature-google-paper-summary-scalable-and-accurate-deep-learning-with-electronic-health-e67a05a9ccad?source=collection_archive---------4-----------------------

GIF from this website

另一个很好的例子，或者深度学习如何使医疗保健行业受益。

请注意，这篇文章是让未来的我回顾和回顾这篇论文上的材料，而不是从头再看一遍。

摘要

使用电子健康记录(EHR)数据进行预测建模对医疗保健行业非常有益。然而，使用这些数据存在挑战，因为不同的医疗保健机构使用不同的格式，并且标准化所有这些数据是一个手动密集型过程，通常会丢弃许多患者数据。然而，这篇论文的作者使用原始 EHR 数据，并将其转换为快速医疗保健互操作性资源 (FHIR)格式，以训练深度神经网络来预测与患者相关的不同医疗状况。这导致了较高的准确性，特别是住院死亡率(受试者操作曲线下面积[AUROC]跨站点 0.93-0.94)、30 天计划外再入院(AUROC 0.75-0.76)、住院时间延长(AUROC 0.85-0.86)和患者最终出院诊断(频率加权 AUROC 0.90)。此外，他们总共使用了 46，864，534，945 个数据点。

简介

最近收集了越来越多的患者数据，不幸的是，并非所有这些数据都用于预测建模。发生这种情况的主要原因是因为数据需要大量处理，传统方法才能很好地工作。(此外，有如此多的数据，所以传统方法只从这些数据中选择几个公共变量。这可能会导致性能下降。).这篇论文的作者使用深度学习来克服这些问题。神经网络的一个优点是，研究人员不必指定要考虑哪些变量，因为网络本身会这样做。

相关工作

尽管我们有丰富的 EHR 数据集，但传统方法只使用 27 个变量的中位数。(而且多是广义线性模型。).另一个问题是，不同的机构使用不同的协议来保存数据，并且将这些数据预处理为规范化的数据需要大量时间。尽管它不能确保语义的一致性，但一种叫做 FHIR (快速医疗互操作性资源)的灵活数据结构变得可用。许多不同的研究人员使用不同类型的神经网络(自动编码器、CNN 和 RNN)来预测传统 EHR 数据的不同结果。但是，大多数先前的工作只集中在使用可用数据的子集。最后，作者指出了对世界的两大贡献。

一个通用的数据处理管道，可以将原始 EHR 数据作为输入，并在没有手动特征协调的情况下产生 FHIR 输出2)E深度学习模型在各种预测问题和设置(例如，多个预测时间)中的有效性。(使用两家医院的数据。)

结果

Table of Characteristics of hospitalizations in training and test sets

上表显示了从两个机构收集的数据的一些统计特性。作者指出的其他一些特性…
1)涉及 114，003 名患者的 216，221 次住院治疗的总数
2)住院期间死亡率为 2.3% (4930/216，221)，非计划 30 天再入院率为 12.9% (27，918/216，221)，长期住院率为 23.9%。
3)患者的出院诊断范围为 1–228。
4)平均入院有 137，882 个标记(将在方法部分描述)
5)考虑了出院时进行的 46，864，534，945 个 EHR 数据标记的预测。

结果:死亡率

在死亡率预测任务中，深度学习方法立即能够大幅度超越传统方法。如上所述，与增强预警分数相比，深度学习方法在两个机构上都具有更高的准确性。不仅拯救了宝贵的生命，也拯救了资源。

结果:再次入院/长期住院

同样，深度学习方法继续保持连胜，甚至预测了 30 天内的意外再入院，与传统预测方法相比有巨大的优势。

此外，对于预测入院 24 小时后的住院时间，深度学习方法再次以巨大的优势胜过传统方法。

结果:推断出院诊断

深度学习模型在三个不同的时间戳做出关于出院诊断的预测。(1 点在入院时，2 点在 24 小时后，3 点在医生给出诊断之前。)并且该模型能够以 86.5 的平均准确度成功地预测出院诊断，并且该准确度随着患者在医院停留的时间延长而提高。(高达 90 度)

结果:模型解释案例研究

完成了一个案例研究，作者将深度学习模型与传统方法模型进行了比较。对于一名患者，深度学习模型预测死亡风险为 19.9%，传统方法预测死亡风险为 9.3%。不幸的是，患者在入院 10 天后去世。上图显示了深度学习模型已经考虑进行预测的所有 175，639 个数据点。该模型对一些特征给予了很高的权重，这些特征包括来自 notes 的恶性胸腔积液和脓胸的证据、使用的抗生素和压疮高风险的护理文件(即 Braden 指数 41)。(上面加粗的部分是模型认为重要的所有特性。不涉及手动部分。)

讨论

作者对深度学习方法是否可以很好地扩展很感兴趣，所以他们使用单一的数据结构来进行所有的预测。(这优于传统方法。).这种方法一个额外的好处是，模型在做决策时考虑了更多的特征，这有助于获得更好的性能。

总的来说，深度学习模型能够优于预测死亡率、意外再入院和住院时间增加，由于设置的差异，其他领域很难直接进行比较。一个有趣的发现是，深度学习模型发出的警报数量是传统预测模型的一半，因为它的假阳性少得多。这项研究之所以重要的另一个原因是，它不涉及专家的干预。(选择功能时)

这项研究的一些局限性包括…

回顾性研究
2)需要更多的试验来证明这种模型如何更好地使用
3)个性化预测利用了许多特定于特定 EHR 的小数据点，而不是一些常见变量。
4)不清楚在一个地点训练的模型是否能在其他地点表现良好
5)计算成本高
6)由于 ICD-9 码的结构，可能会在预测中引入随机误差。

方法:数据集

所有数据均由加州大学和芝加哥大学医学系提供。(每个都有不同的时间线，所有的数据都被删除。)

方法:数据表示和处理

所有输入的数据都被转换成单一的数据结构，以模拟时间线事件，并使用 FHIR 标准数据结构。(所有数值都被归一化，FHIR 属性被分割成离散值，作者将其命名为令牌。)数据管线的图示可以在下面看到，更详细的解释可以在补充阅读中看到。

方法:结果

在这一节中，作者描述了他们所做预测的每一个属性，每一个属性都可以归纳为。

**住院死亡率:**预测即将发生的住院死亡
**30 天计划外再入院:**出院后 30 天内住院
**住院时间长:**住院时间至少 7 天
**诊断:**原发性和继发性 ICD-9 账单诊断

方法:队列研究

总之，患者年龄都在 18 岁或以上，住院时间最短为 24 小时，不包括没有 ICD-9 诊断的住院患者。，(自从医院制定了新的 ICD-10 协议)

方法:算法开发与分析

作者使用了三种不同的网络架构，循环神经网络(长短期记忆(LSTM))，80 一种是基于注意力的 TANN，另一种是基于增强的基于时间的决策树桩的神经网络。

方法:解释预测

更多的细节在补充阅读中，但简而言之 Tensorflow 和 C++被用来建立模型。和 scikit-learn 用于统计分析。

最后的话

我从来不知道通过使用 tensorflow 和 scikit-learn 我们可以完成多少工作。但是知道这篇论文(发表在《自然》杂志上)的作者使用 python 来构建他们的模型让我很兴奋。

参考

(2018).Arxiv.org。检索于 2018 年 6 月 27 日，来自https://arxiv.org/ftp/arxiv/papers/1801/1801.07860.pdf
快速医疗互操作性资源。(2018).En.wikipedia.org。检索于 2018 年 6 月 27 日，来自https://en . Wikipedia . org/wiki/Fast _ health care _ inter operability _ Resources
Anon，(2018)。[在线]可在:https://www.hl7.org/fhir/overview.html【2018 年 6 月 30 日获取】。
将生命体征转变为重要行动。(2018).飞利浦。检索于 2018 年 6 月 30 日，来自https://www . Philips . ca/health care/articles/early-warning-scoring-tools-for-rapid-response/turn-vital-signs-to-vital-action
回顾性队列研究。(2018).YouTube。检索于 2018 年 6 月 30 日，来自 https://www.youtube.com/watch?v=6jy8Q0bibgk

穿越数据隐私迷宫:给数据科学家的提示

原文：https://towardsdatascience.com/navigating-the-data-privacy-maze-tips-for-data-scientists-c2f784969f29?source=collection_archive---------6-----------------------

决定如何最好地保护数据和隐私是很困难的。如果您是一名处理潜在敏感数据的数据科学家，这意味着确定您可以使用哪些数据以及如何最好地保护这些数据。这可能会导致您在失败中放弃——完全放弃并选择使用原始数据，这反过来会使您的数据分析和模型暴露于信息泄漏，并使它们容易受到攻击。

我们在ki protect的目标是尝试让这个过程对您来说更简单—您如何在专注于数据科学的同时还能确保您的数据受到保护？我最近在爱丁堡的 PyData 上给了一个关于这个的演讲——这启发了我写这篇文章(在 GitHub 上的完整幻灯片)。

我们将从概述您的困境开始:您是一名数据科学家，专注于使用客户数据分析或构建模型。您知道隐私和安全性很重要(理论上)，但是您没有花太多时间考虑安全性，并且通常将它留给您的 IT 团队。也就是说，你知道你正在管理客户数据，你想做正确的事情**。**

那么，如何开始呢？我们将通过流程图探索您的旅行，因为——嗯——它们很有趣。当然，信息也很丰富。

你的第一选择是关于你的数据。最好的策略是一开始就不要使用任何敏感数据。让我们从这里开始:

所以，你可能会说——是的，我需要数据！很明显！但我真的希望你考虑一下。所以，我再问一次——这次用稍微不同的方式。

因为..我真的希望你考虑一下。如果你没有数据，你真的需要足够的数据去收集它吗？很多时候，拥有一些额外的数据或变量可能是件好事，但你并不真的需要它——或者你无法证明收集它的必要性。

现在，我在这一步得到了很多涉及未知的问题。它是这样的:“但是 kjam，我只是不知道是否需要它！如果后来发现，一个人名字的最后一个字符确实决定了他的信用度，那该怎么办？”(我们可以就这种类型的特征工程的伦理进行大量的讨论，但是我将把它留给另一篇文章)。

我要求你做的是像基线一样对待你最初的分析；就像你测试一个新的模型或技术一样。首先，您建立一个基线，这是您对隐私风险最小的数据进行的数据分析。如果你愿意的话，尽量少暴露。我保证你可以总是在以后添加数据回来。但是，根据您构建或使用分析的目的，稍后删除数据可能会很棘手。建立一个低隐私风险基线，并发现是的，你的数据有足够的信息，同时仍然保护隐私是最佳结果。因此，删除敏感数据的风险要小得多！

让我们进入流程图的下一步——假设您确定确实需要私人数据。让我们想想我们可以保护它的方法！

希望你不需要明确的私人信息，如姓名、地址或身份证号码。也许你想从这些属性中提取一些特征(比如，地理位置、性别或受教育程度)。只要有可能，首先尝试删除它们，并查看您的隐私基线对其他不太敏感的功能有何看法。但是，如果你已经确定你需要他们，继续前进到我们流程图的下一步…

如果您必须保留敏感数据，并且需要使用真实值(即邮政编码或城市或教育水平)。对于这些数据，确定 K-匿名是否有助于保护隐私。这个概念是由拉坦亚·斯威尼博士在她的论文k-匿名:保护隐私的模型 中首次提出的。在揭露马萨诸塞州州长威廉·韦尔德的健康数据可以通过将选民登记记录与“匿名化”的医院记录联系起来来识别之后，她提出了这一方法(这是在他声称健康记录发布将完全匿名化之后的)。

K-匿名通过创建桶来保护身份识别攻击，桶中的任何单个人都由一组 K 个人来代表。这意味着您实际上是在尝试缩小数据——使用城市而不是邮政编码或年龄范围(35-45)而不是实际年龄。这就允许了一些貌似合理的否认(确切地说，这不是我的记录——可能是我团队中其他 4 个人中的任何一个！).在研究 K-匿名时，还需要回顾一下l-多样性和t-亲密度，这有助于增强隐私——特别是如果你的小组有相当不平衡的目标或特征(即，一个小组中的所有个人都有相同的目标变量，因此知道小组暴露了目标)。

如果不需要保留敏感变量，使用同态假名化或合成数据将允许您保留数据集中的有效值，而不会暴露真实值。合成数据通常是仍然有效的虚构数据，所以虚构的名字代替真实的名字等等。这通常是不可逆的(或者，如果是这样的话，它通常被称为“令牌化”,并且需要有一个非常大的查找表，其中名称或其他数据被映射到不同的值，并且可以被映射回来。当然，这意味着名称被存储在一个大的查找表中…从安全性以及随着输入空间的增长而增加的大小和复杂性来看，这不是一个好主意。)

在 KIProtect，我们已经发布了我们的同态假名化 API ，它允许您在保护隐私的同时保留数据的某些有效性和结构。我们基于加密的方法意味着您还可以通过密钥对数据进行去假名化，以揭示真实值(如果您不确定以后是否需要真实值，这非常有用，因为您可以从假名化的值中恢复它们)。假名化方法允许前缀保留数据类型-例如，数据集中的所有年份都可以映射到同一个新年假名-保留那些日期或其他数据的信息，其中与附近点的关系是一个重要的功能(有兴趣尝试一下吗？注册我们的测试版 API 。

但是，假设您还不确定是否需要保留真正的价值…让我们通过流程图继续探索！

(I tease because I love)

同样，让我们关注基线用例。如果这只是为了研究或探索，请先使用化名或合成数据！同样，您可以在以后添加更多的信息——但是如果您在没有敏感数据的情况下获得有用的结果，那么您可以保护这些数据。

如果您不进行测试或研究，并且仍然需要使用私有数据，那么您的下一步就是开始研究如何安全地发布该数据分析或模型。让我们继续…

如果你正在发布一个基于敏感数据的机器学习模型，你应该知道保护隐私的机器学习——一个活跃的研究领域，旨在建立保护个人隐私(或来自机器学习服务或平台的数据隐私)的模型。在这个主题上有许多活跃的研究人员，包括尼古拉斯·帕伯诺特(目前在谷歌)、T2、SAP 莱昂纳多团队和 T4 新加坡大学的礼萨·肖克里教授等等。但是，如果您还没有在私有数据上训练您的模型(或者您已经事先对数据进行了适当的匿名化)，那么您可以到这里来！(+1 用于隐私保护基线！)

如果你没有发布模型，而是展示数据分析结果，看看聚合匿名化——就像苹果差分隐私团队的表情符号研究。他们能够展示的是，差异隐私聚合结果仍然提供了足够的信息来做出产品改变——例如，预测法语键盘用户的亲吻脸表情符号和英语键盘用户的哭泣脸。

Apple Differential Privacy Team: Top Emoji Use by Keyboard Language

最后，假设您正在开发一个仅供内部使用的模型或数据分析，该模型或数据分析现在很流行，公司希望将其公开或与第三方共享。你如何着手保护它？

您的最佳策略是尝试通过采用相同的方法(隐私保护 ML 或聚合匿名化)来修复模型。这也指出了为什么拥有一个适当匿名(或在适用时使用假名)数据的基线是一个很好的起点。如果信息不属于隐私或敏感信息，那么您可以公开发布，而不必担心个人隐私受到侵犯。(您仍然应该考虑数据本身何时可能存在安全风险，例如最近的 Strava 运行地图显示了秘密军事基地，即使它不一定会造成个人隐私风险)。

如果您已经将基于私有数据训练的模型发布到生产中，请锁定您的 API，并与您的安全和工程团队讨论如何防止对模型的恶意访问。具有开放 API 的机器学习模型基本上就像在公共网络上有一个带有默认凭据的漂亮数据库，所以要采取相应的行动(想了解更多关于隐私风险和黑盒攻击的信息获取吗？参见 Shokri 的成员推理攻击论文)。

结论

我希望我已经让你笑了，哭了，并思考你当前的数据使用实践可能需要在数据隐私和安全方面进行一些调整。我在这里的目标不是公开羞辱你，而是给你一些导航提示和正确方向的帮助。

说到底，敏感数据就像辐射一样。你不想有长时间的暴露(或者任何可能的话)，你想尽你所能来减轻不利影响，一般来说，少真的是多。像对待辐射一样对待您的敏感数据，您将从一开始就避免潜在的令人尴尬的泄漏和安全漏洞。

有关我们在 KIProtect 开发的数据安全和隐私解决方案的更多信息，请访问https://kiprotect.com查看我们的信息。我们的测试 API 可用于结构化假名化，我们还有一些其他保护隐私的数据科学工具，所以请随意注册并了解更多信息。

在数据海洋中导航:如何从数据中收获有意义的见解而不被淹没

原文：https://towardsdatascience.com/navigating-the-data-seas-how-to-harvest-meaningful-insights-from-data-without-getting-overwhelmed-eac1ca1451c6?source=collection_archive---------9-----------------------

正如最近一期《经济学人》杂志所指出的，“世界上最有价值的资源不再是石油，而是数据。”随着数字革命稳步改变我们的经济，我们正在产生创纪录数量的数据。据估计，在过去的两年中产生的数据比之前所有人类历史产生的数据都多。

尽管数据量之大无可争议，但是什么让数据如此有价值呢？首先，数据允许公司监控他们的表现，并将其与有意义的基准、竞争对手的表现或一般市场进行比较。其次，数据为了解客户的偏好、需求和行为提供了一个前所未有的窗口。

在一个运作良好的数据驱动型组织中，对公司业绩和消费者行为的洞察为决策者提供了做出更明智决策所需的信息，从而带来更高的投资回报(ROI)。事实上，经济学人信息部的一项研究发现，自称数据驱动的公司在财务表现方面比竞争对手高出三倍。

然而，正如未经提炼的原油用处不大一样，原始数据的用处也微乎其微。数据只有在能够从中提取相关见解的情况下才有价值。尽管数据驱动型公司正在市场上实现收益，但许多公司正在努力将数据洞察与决策有效整合。根据国际注册专业会计师协会(CGMA)发布的 2016 年对 16 个国家 300 名高管的研究，只有 27%的高管认为他们的公司“高效”利用了数据。与此同时，32%的高管声称，现在可用的数据浪潮实际上使事情变得更糟！

许多决策者(可以理解)被他们现在可以获得的大量信息淹没了。在他们的同名著作中，经验丰富的企业高管克里斯托弗·J·弗兰克和保罗·马格诺内将这种现象称为“从消防水管中喝水”决策者已经被一千个相互竞争的优先事项弄得捉襟见肘，他们如何利用数据的价值做出更好的服务客户的决策？正如《CGMA 报告》(第 13 页)所指出的:“高质量的决策从未像现在这样重要，也从未像现在这样困难。”

信息过载

虽然我们现在可以获得前所未有的信息，但这并不是我们人类第一次面临信息过载。事实上，早在智能手机和电脑发明之前，我们就已经面临着信息的洪流！即使我们今天设法抛开我们的数字工具，我们仍然会遇到比我们的大脑能够处理的更多的信息。

这些信息来自哪里？它来自我们周围的世界，通过我们的感觉器官:我们的眼睛、耳朵、鼻子、舌头和皮肤。我们的大脑不断受到感官信号的冲击。

世界上可用的信息比我们认知资源处理的信息多得多，比我们有意识处理的注意力资源更少。然而，不管怎样，我们必须通过一系列的决定在这个世界上闯出一条路来。我们该怎么做？

我们的大脑想办法缩小可用信息的范围，把注意力集中在最相关的片段上。

为了演示，看看下面闪烁的图像。这是两个图像之间的交替，它们之间有一个显著的区别。你能发现它吗？

你还在找吗？通常需要几秒钟，有时甚至几分钟才能发现差异。然而，一旦你发现了它，图像之间的差异似乎完全显而易见，很难不被发现！(如果你被卡住了，答案在这篇文章的底部。)

在心理学中，这种现象被称为变化盲视。这是我个人最喜欢的一幅插图，展示了有多少信息是我们意识不到的。即使当我们觉得我们正在吸收世界上大多数视觉信息时，我们有意识地处理的信息量实际上非常少。

大脑已经进化到可以通过 选择性过滤 来处理大量的感官输入。这意味着我们只关注一小部分信息，而忽略其他的。我们过滤掉不太可能重要的细节，以保存我们宝贵的认知资源。这样，我们就不会因为通过我们的感觉器官不断收到的大量信息而变得完全疯狂。

数据—第二次信息泛滥

尽管信息过载的现象可能并不新鲜，但我们现在正面临着第二种形式的信息过载。这一次，不是感官信息通过我们的眼睛、耳朵和其他感觉器官到达，而是信息以数字格式向我们袭来。我们已经进化了上亿年来处理感官信息，但只是在最近一二十年，我们才开始面对真正的数字信息浪潮。数据可能是新的石油，但我们如何利用它呢？面对数字信息的浪潮，决策者如何保持理智？

投资数据基础设施和人力资源(如分析师、数据工程师和数据科学家)是解决方案的一部分。然而，最终，为了让数据变得有用，它需要融入到决策中，这意味着任何处于决策角色的人都需要能够访问和利用数据洞察力。这意味着决策者需要不再问“我如何使用所有这些信息？”到问“什么信息是重要的，什么是可以忽略的？”换句话说，我们如何对数据进行过滤，找出对我们真正重要的东西？

在他们的书《从消防水管中喝水:在不被信息淹没的情况下做出更明智的决策》中，克里斯托弗·弗兰克和保罗·马格诺内建议决策者从问自己开始:“什么是最基本的商业问题？”

“把这个问题想象成数据软管上的一个阀门，或者一个过滤器。它让你掌控一切。它控制着你收集和处理数据的速度、流量和方向，甚至有助于决定你如何交付数据。”(Ch。1，标准杆。3)

人类产生的数据量已经高得惊人，估计每年增长 40%。随着数字革命的不断发展，每个公司都变成了数字公司。与此同时，组织仍在想办法准确地利用突然出现的大量信息。

存储数据不够。从数据中获得最大优势的组织是那些知道他们需要什么信息以及如何利用这些信息的组织。从基本问题开始，决策者可以对他们的数据进行选择性过滤。这意味着他们仍然掌握着主动权，用数据提供的强大洞察力推动他们的决策。

(变化盲演示答案:其中一张图片上，飞机机翼下少了一个喷气发动机)。

原载于www.heatherelizabethmann.com。

reddit 评论的 Net upvote 预测和基于 subreddit 的句子完成:

原文：https://towardsdatascience.com/net-upvote-prediction-and-subreddit-based-sentence-completion-for-reddit-comments-98668b510a1a?source=collection_archive---------17-----------------------

从互联网首页构建的模型

这个项目是由里沙布·拉伊、贾扬特·谢诺伊、陈亦飞、王巍和 Shruthi Krish 完成的

Photo by Brett Jordan on Unsplash

作为互联网上最受欢迎的网站之一，Reddit 是一个信息宝库。自 2005 年成立以来，Reddit 记录了世界各地人们就任何可以想象的话题进行的互动。

这些互动可以以评论的形式出现，每条评论都得到了用户的评分，用户要么投票赞成，要么投票反对。评论是按文章分组的，但是它们更一般的领域是由它们所在的子编辑指定的。

目标

因为 Reddit 用户既是网站的消费者也是贡献者，贡献者的用户体验是 Reddit 发展的关键。写评论时更好的体验会鼓励 Reddit 上更多的互动，我们的目标是通过模型的组合来创建这一点。

Redditors 非常重视他们的因果报应，这是通过向上投票获得的。通过创建一个预测净投票数的模型，我们可以帮助评论者更好地了解他们评论的预期质量。此外，由于子编辑的多样性，通过创建基于子编辑变化的句子完成系统，我们可以帮助用户更快更容易地做出贡献。

使用由 redditor 创建的优秀的累积评论数据集，我们能够创建评论模型。

构建净向上投票回归器:

为 Reddit 评论构建一个净 upvote 回归器的过程涉及训练许多不同的模型，以找到哪一个模型能够根据特征最好地预测 upvote 计数。

数据集

完整的评论数据集包含了自 2005 年以来 Reddit 上的所有评论。由于处理如此巨大的数据量(数百千兆字节的文本)超出了我们的资源范围，我们将训练集和测试集分别限制在 2018 年 2 月 1 日和 2 日的评论。每天的数据集包含超过 300 万条评论的数据，在删除无效数据后，我们分别剩下 280 万和 240 万个训练和测试示例。虽然我们更希望有更多的数据分布在一段时间内，但每组的大量数据使我们能够相当确定我们的

特征工程

让我们来看看数据集中存在的要素，以及我们可以从中获得什么:

作者

我们认为对作者姓名的句法或语义解释都不会产生有用的特征。虽然我们考虑了“一次性”账户的存在，这是一个临时的账户，往往有着莫名其妙的用户名，但不管是不是一次性账户发表的评论，都不太可能对它获得多少赞成票产生影响。同一个作者可以对各种主题发表评论，所以作者的用户名很可能与评论的内容无关。如果我们要考虑作者评论的历史以及它们有多成功，我们也许能够使用这些信息，但是由于缺乏时间和计算资源，这样做是不可行的。此外，包含此类信息很有可能会导致噪音(因为在实践中，以前评论的受欢迎程度对新评论的受欢迎程度影响很小)或导致模型对很少或没有评论历史的用户有偏见。

作者 Cakeday

用户的生日也绝对与他们的评论获得多少支持票无关。

作者风格 CSS 类和作者风格 CSS 文本

author flair css 类和文本引用与子编辑相关的标签。这些 flairs 向具有领域知识的 redditors 提供信息，并且它们通常需要领域知识来创建。在一个简单的例子中，在 NBA subreddit 上，flair 可以将用户标记为某个球队的球迷。在下面来自 r/TheLastAirbender 的例子中，尽管对任何人来说，第一个用户是一个名叫亚纱美的人的粉丝是显而易见的，但是只有具有领域知识的用户才会理解第二个用户是一只巨大的狮子龟的粉丝。

有天赋

虽然 flair 的实际语义可能不一定与评论的成功相关，但是它的存在意味着用户在这个子编辑上更活跃，并且具有更丰富的领域知识。这种领域知识可能意味着更高质量的评论更有可能获得更多的投票。

正文

注释的主体是指它的实际文本内容。这是最重要的功能，因为它是 upvotes 的来源，许多功能可以从它设计出来。

感悟

使用 NLTK VADER 图书馆，我们确定了评论中积极、中立、消极和复合情绪的数量。评论的情感极性可能是其成功的一个强有力的指标。

用户提及次数和子编辑提及次数

我们分析了评论主体中提到的其他用户或子编辑，因为将投票者引向外部来源可能会鼓励或阻碍投票。

Reddit 链接数量和外部链接数量

外部内容或其他 Reddit 内容的链接数量可能意味着更多的回复，因为有用的重定向，或者更少的回复，因为垃圾广告。不管怎样，这两个特性都是有用的，所以我们为它们解析了主体。

可读性

我们使用 textstat 库来确定每个注释的可读性，该库包含一个度量，它是各种标准可读性度量的集合。这样做可以让我们对一篇文章的可读性达成共识，尽管有各种各样的可用指标。

大写比例

大写字符占帖子总字符数的比率可以作为评论兴奋度或紧迫性的衡量标准。高比例也会吸引评论的注意。

长度

一篇文章的长度是读者首先注意到的方面之一。它经常作为一个评论是否会被阅读的决定因素，所以值得把它作为一个特性包含进来。

毒性

有毒和煽动性的评论可能会引起争议。至少，他们获得了回应。为了确定毒性，我们尝试对数据集应用预先构建的模型，但缺乏必要的计算资源迫使我们暂时跳过这一功能。

问题数量

评论主体中的问题越多，对评论的回应可能越多，因此可能是投票上升的指标。

Doc2Vec 嵌入

A training comment along with semantically similar comments determined by Doc2Vec

In this word cloud of the above example, we can see what these comments have in common

到语义空间的映射对于决定评论的成功是至关重要的。这可以使用 Doc2Vec 来完成，它将文档的语义表示为嵌入向量。Doc2Vec 通过在学习单词嵌入的同时添加文档标签，然后创建指定维度的文档嵌入，将文档映射到语义空间。我们从训练 dm 模型开始，该模型创建大小为 300 的嵌入向量，训练超过 125 个时期。虽然这个模型是准确的，但是所有评论的向量数据的庞大规模对我们的资源来说是太多了。结果，我们在 50 个时期内训练了新的 50 维嵌入模型。这个模型足够小，我们可以用它来进行预测，而且，在定性地检查了一些例子之后，看起来嵌入的整体准确性并没有受到太大的影响。从二维角度来看 Doc2Vec 嵌入，我们可以看到流行评论的集群。这可能是由于共同的语义，但它很可能只是某些子记录上更多活动的结果。

镀金

一条被镀金的评论在 Reddit 世界被赋予了一定的金额。我们放弃了这一功能，因为它是在发表评论后确定的，并且在他人发表评论前不可用。

可以镀金

这是指一个评论能不能镀金。因为镀金的评论在一个帖子上有更多的曝光和推广，一个可以镀金的评论有机会成为镀金的并获得更多的投票。

争议性

有争议的评论是那些有很多赞成票和反对票的评论。我们放弃了这个特性，因为它是在评论获得投票后确定的，因此不能用于进行预测。

创造了 UTC

我们决定放弃创建时间，因为尽管 Reddit 拥有庞大的北美用户群，但它在国际上得到广泛使用。这意味着一天中发表评论的时间可能是噪音，而不是成功的标志。此外，我们只有一天的数据，所以我们不能尝试使用日期作为区分因素。

被粘住

一个粘贴的评论被钉在了帖子的顶部，这导致了更大的曝光率和更多的投票。然而，由于评论在发表后可能会被其他用户粘贴，我们不能将此用作预测功能。

尊贵的

杰出评论当版主发表评论时，在用户名旁边添加一个“[M]”。因为区分对评论的排名没有影响，标签也没有像天赋一样给路人提供任何洞察力，所以评论是否被区分不太可能影响它的成功。

已编辑

因为编辑过的评论可能意味着该评论已经获得了关注，并且因为编辑过的评论可以被视为新的评论，所以编辑过的特征可以被用作未来成功的指示器。

是提交人

被批准的提交者被允许发布任意多次，这意味着这个人有相当多的评论经验，可能会获得更多的支持票。

永久链接

永久链接是评论的链接。它包含文章的标题。

帖子标题

我们从链接中提取标题，并使用字典来修复最初有撇号的单词(缩写不能是 url 的一部分)。虽然我们计划将 Doc2Vec 模型应用于这些标题，并计算标题嵌入与注释嵌入的余弦距离来确定相关性，但由于时间限制，我们无法完全实现该功能。

题目是问题

回复一个问题的评论可能会得到更多的支持票，但是唯一确定的方法是把这个作为从文章标题中提取的一个特征包括进来。

得分

这个作为标签，所以肯定是需要的。

子编辑

使用 Viterbi 算法进行单词分割，我们分割子编辑名称中的组合单词，以创建可以应用 Doc2Vec 模型的文档。同样，目标是计算评论与子编辑的相关性。然而，由于时间限制，我们无法完全实现这一功能。

检索于

检索到的日期和时间对于确定我们估计净 upvote 计数的时间段非常重要。训练集的周期为 11 天，而测试集的周期为 15 天。我们不认为这是预测评估中的一个大问题，因为天数的小差异对 upvotes 没有什么影响(因为评论可能在其存在之初获得大多数投票)，特别是考虑到 Reddit 内容经常在几年内发挥作用。

ID、链接 ID、父 ID 和子编辑 ID

评论的 id 肯定和它的成功没有任何关系。

The correlation heatmap

构建和评估净增加投票回归器

在为我们的模型调整超参数时，为模型评分确定一个好的评估标准非常重要。基于训练数据的分数分布，绝大多数评论的上票数很少，这意味着数据是向右倾斜的。因此，使用某些回归评估指标，如 RMSE，对大错误给予高权重，可能会导致偏向高票数的评论。从 Zillow housing price kaggle 竞赛中汲取灵感，该竞赛涉及一个具有类似右偏数据集的回归问题，我们决定使用平均绝对误差(MAE)作为评估指标，因为它不会对无关评论产生偏见。

超参数调谐

上述梯度增强树模型的超参数调整是构建 upvote 预测器最耗时的方面。模型的调优是在使用 40GB RAM 和 GPU 的 google cloud 实例上完成的。我们尝试了几种不同的技术来优化我们的模型参数。在参数调整时，所有模型都使用 4 倍的训练集进行交叉验证。

使用超点的贝叶斯优化

超视是一种通过统计方法搜索参数空间的复杂方法。通过智能随机抽样，我们能够使用 HyperOpt 来适当地最小化梯度增强树模型的平均绝对误差。

随机搜索 CV

为了对我们的贝叶斯优化搜索结果进行健全性检查，我们还进行了随机搜索，以了解最佳匹配的大概值。

使用 XGBoost 的梯度增强决策树

动机

梯度推进决策树通常在表格数据的实践中工作得很好(正如它们在许多涉及回归的 Kaggle 竞赛中的成功所证明的那样)，所以我们决定从梯度推进树构建几个不同的模型。我们首先将 XGBoostRegressor 调成默认模型。在训练模型之前，所有的分类特征都是一次性编码的。

输入特性

能镀金
编辑
Is _ 提交者
积极情绪
中性 _ 情绪
消极情绪
复合 _ 情绪
用户提及次数
数量 _ 子编辑 _ 提及次数
Has_flair
数量 _ 外部 _ 链接
数量 _reddit_links
标题是问题
可读性
大写 _ 比率
长度
所有 Doc2Vec 载体

Credit: http://arogozhnikov.github.io/2016/06/24/gradient_boosting_explained.html

结果

虽然 XGBoost 总体上表现不错，但是我们的 XGBRegressor 模型是这个场景中最差的模型。该模型的损耗计算为 12.34 CV MAE，测试 MAE 为 12.34 CV MAE。测试预测的散点图如下所示。预测的 upvote 值范围从-200 到 2000。根据散点图，该模型似乎对现实中得分较低的评论过高地给出了许多分数。

使用 CatBoost 的梯度提升决策树

动机

CatBoost 是 Yandex 开发的梯度提升树模型，它为分类特征提供输入。在训练之前，CatBoost 应用一种复杂的算法来正确编码指定的分类特征。因为我们的训练数据具有一些可能会给 XGBoost 模型带来问题的分类特征，所以我们尝试构建一个 CatBoost 回归器来更好地处理这些特征。在模型被训练之前，所有的分类特征都被 CatBoost 编码。

输入特性

能镀金
编辑
Is _ 提交者
积极情绪
中性 _ 情绪
消极情绪
复合 _ 情绪
用户提及次数
数量 _ 子编辑 _ 提及次数
Has_flair
数量 _ 外部 _ 链接
数量 _reddit_links
标题是问题
可读性
大写 _ 比率
长度
所有 Doc2Vec 载体

结果

与 XGBoost 模型相比，结果明显更好。与 XGBoost 的预测不同，CatBoost 预测值的范围要小得多。因此，该模型无法预测任何得分极高的外围评论。尽管如此，模型的损失被计算为 8.32 CV MAE，测试 MAE 为 8.32 CV MAE，表明分类特征的专门编码是朝着正确方向迈出的一步。基于模型的特征重要性分数，分类特征 has_flair 似乎对模型具有最大的影响，而 can _ guilded 和 edited 甚至没有被考虑。现在我们有了两个有趣的特征重要性图，是时候开始移除可能增加 MAE 的噪声特征了。

神经网络

动机

有了云实例和从梯度增强树多样化的愿望，我们决定尝试几个基于神经网络的模型。我们最好的一个涉及下面的架构，一个密集的顺序网络，有 67 个单元的输入，两个各有 50 个单元的隐藏层，使用 ReLU 激活函数，以及一个线性激活的最终输出层。对于培训，我们使用了 Adam 优化器和 MAE 评估指标。

此外，我们决定尝试通过删除某些不太适合神经网络的特征来减少以前模型中的模型噪声，这些特征在以前两个模型的特征重要性方面得分较低。

输入特性

积极情绪
中性 _ 情绪
消极情绪
复合 _ 情绪
用户提及次数
数量 _ 子编辑 _ 提及次数
Has_flair(编码)
数量 _ 外部 _ 链接
数量 _reddit_links
标题是问题
可读性
大写 _ 比率
长度
所有 Doc2Vec 载体

结果

非常令人惊讶的是，神经网络产生了比预期好得多的结果。我们只能训练它几个时期，这可以通过下面的学习和验证曲线清楚地看到。该模型仍然没有完全收敛于我们为其训练的几次迭代，但它仍然设法获得了 7.27 的 CV MAE 和 7.17 的测试 MAE，因为总体曲线趋势保持不变。不同寻常的是，根据散点图，预测值的范围变得更小了。尽管我们最初选择 MAE 作为评估标准，但是这个模型似乎偏向于高值的评论。然而，似乎移除我们生成的一些特征有助于减少模型中的噪声。

4。混合合奏

The goal model

动机

对于我们的最终模型，我们希望尝试一些具有强大预测能力的东西，希望进一步降低我们的 MAE 测试分数。本质上，我们设计的模型是梯度增强树和 4 重组合序列神经网络的 4 重组合。来自这些主要模型的预测将由 supervisor XGBoost 回归器模型进行堆叠和预测，该模型将返回最终的得分预测集。我们设计这个主管模型的思考过程是结合我们以前调整过的模型的好与坏，看看结果会如何结束。

输入特性

积极情绪
中性 _ 情绪
消极情绪
复合 _ 情绪
用户提及次数
数量 _ 子编辑 _ 提及次数
Has_flair(编码)
数量 _ 外部 _ 链接
数量 _reddit_links
标题是问题
可读性
大写 _ 比率
长度
所有 Doc2Vec 载体

结果

不幸的是，虽然我们能够完全编码我们的集合模型，但我们的计算能力阻止了我们实际训练模型。在神经网络和 CatBoost 模型的 k 倍训练阶段，我们的 google cloud 实例 GPU 不断耗尽内存。我们尝试了几次实验，但是在云服务器上训练失败的结果是一致的。

最终预测结果

上面我们可以看到我们得到的结果的比较。当我们用以前的经验来指导我们的努力，尝试新的模型时，我们看到我们的误差稳步下降。我们相信成功地实现目标模型将会延续这一趋势，并且我们的目标是在未来使用更多的计算资源来实现这一目标。

为不同的子编辑创建预测键盘

为了创建一整套工具供 Reddit 用户在评论时使用，我们为不同的子编辑构建了一个定制的预测键盘。一般而言，预测键盘观察过去的打字习惯和词汇使用以及当前的上下文，以估计哪些单词具有被键入的高可能性，并向用户建议这些单词。

预处理

在大多数自然语言处理问题中，第一步是处理文本以消除任何字符噪声。在我们的例子中，我们决定采取一种不干涉的方法，尽可能少地修改文本，以保留尽可能多的来自评论的信息。无论如何，一些语法元素，如标点符号和大写字母增加了更多的噪音，所以我们决定删除它们。

除了典型的预处理，我们还面临生成合适语料库的更新颖的问题。大多数 NLP 模型需要一个语料库来进行训练，因此模型可以首先了解文本中可能存在的模式。在我们的例子中，原始数据来自数以百万计的不同评论，而不是一个集中的语料库，所以我们必须从现有的数据中生成自己的语料库。为此，我们决定简单地将所有注释附加在一起，同时使用特殊的定界字符来区分不同的注释。

有了所有可用形式的数据和对预测键盘如何工作的简单理解，我们决定直接开始实现我们的第一个基于马尔可夫链的模型。

马尔可夫链模型

马尔可夫链模型似乎很适合我们的问题，因为它可以通过 n 元语法考虑单词的上下文，并通过记忆单词出现的概率来跟踪过去的历史。马尔可夫链可以被认为是有限状态机，其中每个状态都有一定的概率根据过去的历史转移到其他阶段。当应用于文本时，这意味着每组单词都是一种可能的状态，所有的边都是基于下一个单词出现的概率形成的，如下所示。对于我们的模型，我们决定在分离句子时使用二元语法，因此我们不是查看单个单词，而是一次查看两个单词，这允许我们考虑某些单词的上下文，同时不会使我们的训练数据过于稀疏。

在对我们的数据训练马尔可夫模型后，我们发现它非常善于生成大量可读的文本。这个模型的性能特别快，因为它只需要一遍所有的数据就可以记住所有的概率。这个模型能够接受非常短的起始短语，并能够从中推断出很多。例如，当在 subreddit r/Fitness 上训练模型时，我们让模型继续生成单词，直到它认为评论应该结束，从单词“我是”开始生成以下 commnet:“我倾向于认为你不可能每天都全力以赴而没有任何肌肉损伤”。

乍一看，这似乎很完美，但是仔细观察，这个自动生成的评论揭示了我们模型的一些主要优点和缺点。一方面，注释可读性很强，更重要的是，它符合 fitness 子编辑的上下文，因此我们的马尔可夫链似乎能够非常有效地生成特定于子编辑的注释。然而，我们理想的用例应该更多地关注建议更短的短语或单词，并高度准确地符合用户的期望。因此，如果我们再次运行这个模型，但在一个单词后停止，我们将得到短语“我倾向于”。这个短语在语法上可能非常好，但它实际上可能不是太准确的预测，因为单词“倾斜的”实际上可能不会经常跟在短语“我是”后面。当然，完美地预测下一个单词基本上是不可能的，特别是考虑到我们只有两个单词可以脱离上下文。这个问题的一个解决方案是使用一个更好地考虑上下文的模型(我们稍后使用 LSTM)，另一个更直接的解决方案是将更多的数据输入到我们当前的模型中。我们决定尝试第二种方法来提高我们的准确性，只尝试在键入单词的中途预测单词，因此使用与前面相同的示例，如果用户已经键入了“我是公司”，我们将只预测“我倾向于”。为了得到这个想要的效果，我们需要修改我们的马尔可夫模型，使之基于角色。

这是一个极端的变化，因为这意味着我们不再预测单个单词，而是着眼于字符。作为其中的一部分，我们还决定一次将 4 个字母组合在一起，以获得更具可读性的文本。这让我们得到了我们想要的中间词预测，但它也带来了糟糕透顶的句子，甚至连合适的词都很少见。我们认为这是由于模型过于天真，在解释环境方面不够好。因此，我们决定重新考虑我们的第一个解决方案，寻找一个不同的模型，更好地考虑环境。

我们如何改进马尔可夫模型——神经语言建模

让我们想想人类是如何处理和解释句子的。人类通常从左到右浏览文本，在每个单词之后获得文本内容的一些上下文，直到到达结尾；因此，我们逐渐理解了整篇文章。鉴于这是人类阅读和理解句子的方式，我们可以获得一些关于人类如何预测给定单词的句子中的下一个单词或字符的见解:我们从句子开头的单词开始阅读并积累信息，直到我们到达结尾，然后给定这些单词的上下文，我们可以确定接下来什么是有意义的。递归神经网络(RNNs)背后的思想非常相似。

在其他神经网络中，网络的输入被认为是相互独立的。例如，您的标准多层感知器(MLP)或前馈神经网络通过神经元传递输入，神经元对模型的输入执行一些数学功能。通过训练这些模型，你可以对这些输入进行数学运算，看看你有多差，然后通过一个称为反向传播的过程，重新调整网络中神经元的权重。这对于一些用例来说很好，然而，在自然语言处理中，我们的输入通常不是相互独立的。过去的输入可以帮助我们识别当前输入的更好输出，这正是 rnn 试图做的:利用顺序信息。

递归神经网络是递归人工神经网络的变体，其中神经元之间的连接进行定向循环。它的输出不仅取决于当前的输入，还取决于先前步骤的状态；这种记忆使网络能够更好地处理先前输入的上下文很重要的问题。这个属性是使 RNNs 成为处理自然语言处理问题的非常强大的工具的关键因素，我们将尝试使用 RNNs 来创建更好的预测键盘。

LSTM 基于角色的模型

考虑到这些结果，我们决定尝试开发一个新的模型，它可以匹配 subreddit 行为，同时还引入了中词预测。最初，我们试图简单地将我们的马尔可夫链模型转换成基于 ac 字符的模型，这导致了糟糕的结果，因为该模型不够复杂，无法从它预测的字符中生成真实的单词。

因此，我们创建了一个长短期记忆(LSTM)递归神经网络。常规递归神经网络遭受消失和爆炸梯度问题，因此它们很少在实践中使用。相反，我们使用了 LSTM 递归神经网络(如下所示),该网络使用门来流动梯度并减少消失梯度问题。

图片取自 Colah 的博客

假设我们的数据是来自子编辑的注释，我们需要以一种特定的方式格式化数据，这种方式很好地与神经网络一起工作。将每个注释作为字符串数组传递在神经网络中并不合适，更好的方法是将它们表示为分类特征或数字特征。在我们的字符 LSTM 的例子中，我们首先创建一个字符到索引和索引到字符的映射，稍后我们将使用它对我们的序列进行一次热编码。我们还记录了字符集的大小，大约有 200 个不同的字符。

接下来，我们需要将我们的注释映射到 LSTM 可以接受的某种表示。为此，我们可以为整个文本创建长度为 40 的字符序列。当我们创建这些序列时，我们为序列中的每个字符创建一个 hot 编码向量来表示每个字符。这是有用的，因为神经网络通常对于具有分类特征的多类分类表现良好。创建完这些序列后，我们剩下一个三维矩阵(我们的 X):第一维表示序列号，第二维表示序列中的字符，第三维是表示特定字符的一键向量。在我们创建序列的同时，我们创建了下一个字母矩阵(我们的 Y)。对于序列 N，我们给出了字符 1 到 30，我们试图预测 Y，也就是字符 31。我们的 Y 数组应该是一个二维数组:第一维表示序列号，第二维是一个表示我们的模型试图预测的特定字符的一键向量。

然后，我们创建用于预测输入序列的下一个字符的模型。我们使用大小为 128 的 LSTM 层的 Keras 序列模型，进入大小为我们字符集大小的全连接密集层，最后我们将这些结果放入 softmax 激活层，以输出其奇异真实指数代表我们试图预测的字符的 one hot vector。我们使用 RMSprop 优化器(通常适用于递归神经网络的优化器)编译该模型，学习率为 0.01，损失函数为 categorical _ crossentropy(适用于多类分类中的神经网络)。我们将该模型拟合到上述 20 个时期的 X 和 Y 矩阵，并观察下面的精度和损失。

我们可以看到，对于我们的验证数据，我们的模型可以实现大约 0.55 的准确性，而损失大约为 1.9。这意味着给定一个长度为 30 的字符序列，模型有 55%的机会正确猜测序列中的下一个字符。对于我们在/r/2007scape 上训练的模型，它表现得相当好，因为它可以学习一些只在那些特定子编辑中使用的单词。例如，给定一个输入序列“Old School Runesc”，我们的模型可以预测[“cape”、“hools”、“ores”、“scenity”、“and”]，这将使预测成为“Old School Runescape”。这突出了我们的模型与马尔可夫模型相比的一些优点和缺点:我们的模型现在能够在给定过去上下文的情况下以相当高的准确度预测不完整的单词。然而，给定非常模糊的上下文，例如“O”，我们的模型预测[“One”、“Other”、“Ore”、“Oin”、“Oent]]，向我们显示我们的模型不能保证给我们有效的单词。此外，如果我们给它的序列已经有了完整的单词，我们的模型也不能很好地工作，例如“我想吃饭”给我们的输出是[“tion”、“h”、“the”、“er”、“o”]，所以我们的模型实际上并不知道完整的单词，也不真正理解语法的概念。下面是我们为演示我们的模型而构建的 web 应用程序的快速浏览。

总之，我们的模型对于需要自动补全成在子编辑中使用但不在其他地方使用的词(例如游戏城市、老板、怪物等)的不完整的词工作得很好。).然而，对于预测下一个单词，我们的模型表现不佳，因为它没有真正理解单词/语法的概念，因为它是在字符而不是单词上训练的。接下来，我们将提出一个可以很好预测下一个单词的模型。

LSTM word2vec 嵌入模型( 演示此处 )

我们之前的字符神经语言模型在预测不完整单词和特定于子编辑的单词方面工作得很好。但是，有没有一个模型在预测单词时表现更好，符合语法规则的方法呢？现在，我们尝试创建一个模型，该模型使用 LSTM RNNs 和单词嵌入模型来预测给定单词序列的单词。同样，我们使用 LSTM rnn 而不是常规 rnn，因为它们能够处理消失和爆炸梯度问题，并且因为我们试图使用序列特征进行预测。

在我们开始尝试之前，回顾一下单词嵌入会给模型带来什么好处是很重要的。单词嵌入是将字符串转换为向量的过程。这个过程包括在数学上将每个单词的一个维度嵌入到一个更低维度的连续向量空间中。这允许我们减少“维数灾难”,因为一个单词词汇集的热编码可能导致词汇集长度超过十万。具体来说，我们探索了使用 Word2Vec，这是一个为每个唯一单词创建唯一单词嵌入向量的模型。Word2Vec 的特殊之处在于，它生成的单词向量的位置使得在语料库中共享共同上下文的单词在向量空间中彼此靠近。我们试图为我们的模型利用这个属性，因为我们认为 Word2Vec 向量捕获的上下文将为模型提供更多的上下文，从而提高模型的输出。下面是由 Word2Vec 模型生成的单词嵌入的可视化。

我们的输入仍然是相同的单词集，所以我们需要将这些数据转换成我们的模型可以接受的东西。我们首先将语料库标记为字符串数组，然后创建并训练一个 gensim Word2Vec 模型。在训练我们的模型之后，我们通过创建类似的三维数组(我们的 X 矩阵)在整个数据集上创建我们的 30 个单词长的滑动窗口序列:第一维仍然表示序列号，第二维表示单词序列，第三维表示单词(通过在 Word2Vec 模型中查找单词并使用单词嵌入)。我们还创建了一个表示 Y 矩阵的二维数组:第一维表示序列号，第二维表示我们试图预测的单词(作为单词向量)。

我们使用的模型非常类似于我们基于字符的神经语言模型。我们使用 Keras 序列模型，该模型使用大小为 128 的 LSTM 神经网络层，进入大小为我们的 Word2Vec 输出维度的完全连接的密集层，最后我们输出结果。我们用学习率为 0.01 的 AdamOptimizer 编译了这个模型，损失函数为 mean_absolute_error。我们用 X 和 Y 拟合这个模型 150 个时期，看看我们得到什么结果。

不幸的是，我们模型的结果相当糟糕。在我们将模型的结果转换回单词后，我们看到我们的模型一直输出一个或两个它认为最正确的单词。鉴于我们在网上看到的例子，我们认为我们的模型是不适合的。如果有更多的时间和资源，如果我们继续训练这个模型，我们相信这个模型会输出可以转换成实际单词的单词嵌入，并且应该是语法正确的。

结论

我们这个项目的目标是改善 Reddit 上的评论体验。使用 redditor 创建的数据集的一天评论，我们构建了两个不同的模型来帮助用户进行评论。我们项目的第一部分是创建一个向上投票预测器。顺序神经网络预测器是我们设法完全创建和训练的最佳模型；它在测试集上的平均绝对误差为 7.17。我们项目的第二部分是生成特定于每个子编辑的预测键盘。在整个过程中，我们一直面临的一个问题是数据量超出了我们的管理能力。

后续步骤

子编辑预测键盘改进

为了创建最佳模型，我们将用更多的资源和时间来完成我们的单词嵌入神经语言模型的训练。然后，我们将结合我们的字符语言模型和单词嵌入模型来创建一个自动完成键盘，它可以预测您正在键入的当前单词，并根据您刚刚键入的单词的上下文给出下一个单词的准确建议。这种模式更类似于 Gmail 新的智能撰写功能。创建更准确的模型的另一个考虑是尝试 seq2seq 模型，该模型使用两个 LSTM，一个 LSTM 用于编码当前上下文，另一个 LSTM 用于解码该序列，并在给定编码器权重的情况下生成预测。在谷歌的 AI 博客上，我们发现谷歌考虑使用 seq2seq 模型，但其性能太慢。然而，他们发现 seq2seq 模型具有更好的准确性，因此如果我们对单词嵌入神经语言模型的准确性不够，我们也可以考虑使用该模型。训练该 seq2seq 模型的计算复杂度高于训练单词嵌入神经语言模型，因此在实践中这可能是不可行的。

向上投票预测器

在改进 upvote 预测模型时，有许多方向可以探索。乍看之下，几乎可以肯定，我们尝试的所有模型的超参数都可以改进。如果我们能够以某种方式克服训练模型时遇到的 GPU 内存问题，那么将模型输入基于 XGBoost 的管理模型几乎肯定会带来改进。探索不同的神经网络架构也可能是有用的，特别是因为嵌入可能需要与独立特征区别对待。由于缺乏计算能力和/或时间，我们不得不放弃一些特性，在模型的下一次迭代中包含这些特性会非常有帮助。不管我们采取什么步骤，我们无疑都需要获得更多的计算资源。

组合模型

虽然这两种模式可以分别帮助 Redditors 改善用户体验，但一种组合模式可以为用户做更多的事情。upvote 预测器可用于测量评论的预计质量，并且该信息可被输入键盘用于帮助提高评论质量的完成。这对贡献者和消费者来说都意味着更好的体验。

网飞和希尔:在 Excel 中构建推荐系统

原文：https://towardsdatascience.com/netflix-and-chill-building-a-recommendation-system-in-excel-c69b33c914f4?source=collection_archive---------1-----------------------

学习狂欢背后的机器学习“魔法”

在网上无限的货架空间里，找到你想看的东西可能会让人精疲力尽。幸运的是，对抗决策疲劳是网飞的工作……他们擅长这个。太擅长了。

他们神奇地给你推荐最完美的电影，让你的眼睛盯着电视，他们把你的拖延症变成沙发上的周末大餐。

该死的网飞。你的秘诀是什么？你怎么这么了解我们？

Netflix wins again…

这个“魔术”出奇的简单，在这个教程中，你可以下载 Excel ( 推荐)或 Google Sheets ( 计算速度较慢)的一步一步的电子表格来揭示其中的秘密；由于兼容性缺少 1 张图，请跟随以提高您的学习效果:

https://drive.google.com/open?id = 1y 4x 8h 56 ts 6m 7 axau 7 yim 0 eyxhqnuy1sz

尽管自 Netflix 奖项竞赛以来，有大量关于推荐系统的论文或视频，但大多数要么(A)太专业，初学者无法接触，要么(B)水平太高，不实用。

在这篇文章中，我们将从头开始建立一个电影推荐系统，用简单的英语解释和一步一步的公式，你可以在 Excel 中遵循。所有梯度下降推导都是手工完成的，您可以使用 Excel 下拉过滤器来微调模型的超参数，增强您的直觉。

您将了解到:

构建帮助赢得 100 万美元网飞奖的算法版本 SVD++背后的确切步骤。
机器实际上是如何学习的(梯度下降)。看着网飞了解你的电影品味，即使你从未告诉他们。
**超参数调谐。**查看如何调整模型输入(学习率、L2 正则化、历元数、权重初始化)以获得更好的预测。
**模型评估&可视化。**了解训练数据和测试数据的区别，如何防止过拟合，看看如何可视化一个模型的特征。

在简单介绍了推荐系统之后，我将介绍下面的 4 个部分，我们将建立一个模型来预测一些好莱坞明星的电影评级。

我将解释机器学习魔法背后的一步一步的数学，你可以跟随插入批量梯度下降中使用的公式中的实数(没有“宏”或“Excel 解算器”来隐藏细节)。

这是给谁的？

人们开始使用推荐系统
斋戒的学生。AI 的深度学习课程
对好奇心和机器学习感兴趣的人

特别感谢 Fast.AI 的杰瑞米·霍华德和瑞秋·托马斯，这里的电子表格灵感来自他们关于协同过滤的课程(见代码)。他们呈现的电子表格依靠 Excel 内置的求解器在幕后进行优化计算；然而，我构建的电子表格显示了梯度下降计算的每个步骤，并允许您微调模型的超参数。

如果这些电子表格对你有帮助，请考虑通过点击下面的链接注册我的电子邮件列表，我将向你发送更多的电子表格，帮助你开始机器学习和建立神经网络。

1.1 数据

博客帖子模型使用 30 个虚构的评级(5 个用户 x 6 部电影)来简化教程。

为了跟进和试验这个模型，你可以在这里下载电子表格(Excel 或 Google Sheets)。

斋戒。AI lesson 根据 15 部最受关注的电影和 15 名最活跃的用户，使用了 225 个真实评级(在博客文章中很难说明)。除了虚假的“用户名”，收视率数据来自 MovieLens 。

查看基于快速的模型(Excel 或 Google Sheets)。AI 课，你可以在这里下载那个。
注意——斋戒。人工智能模型使用 15 个纪元而不是 50 个(由于更多的数据),并且在 Google Sheets 中计算相当慢，所以推荐使用 Excel。

1.2 拆分数据—培训与测试

我们将使用 25 个评分来训练我们的模型，并使用 5 个评分来测试模型的准确性。

我们的目标是建立一个对 25 个已知评级(训练数据)工作良好的系统，并且希望它对 5 个隐藏的(但已知的)评级(测试数据)预测良好。

如果我们有更多的数据，我们会将数据分成 3 组—训练组(~70%)、验证组(~20%)和测试组(~10%)，然后使用验证集来验证我们的模型。

1.3 评级预测公式

评级预测是用户/电影特征+用户偏好+电影偏好的矩阵乘法或“点积”。

正式定义:

1.3.1 用户/电影特征

直观地说，这些特征代表了诸如类型、演员、电影长度、导演、电影年份等。即使我们并不十分清楚每个特性是什么，但是在我们将它们形象化到图表上之后，我们可以直观地猜测它们可能代表什么(参见第 4 部分)。
为了简单起见，我使用了 3 个特性，但是实际的模型可以有 50 个、100 个或者更多。功能的数量将随着数据的复杂程度成比例增长。如果有太多的特征，模型将“过度拟合/记忆”你的训练数据，并且当它预测隐藏的(但已知的)测试评级时，它不会很好地概括。
如果用户对于他们的第一个特征(假设它代表“喜剧”)具有高价值，并且该电影对于这个“喜剧”特征也具有高价值，这可能导致该电影的高评级。

1.3.2 用户/电影偏差

用户偏见是影评人有多苛刻或多好。如果网飞上所有电影的平均评分是 3.5，而你对所有东西的平均评分是 4.0，你就会有 0.5 的偏差。电影偏见也可以这么想。如果《泰坦尼克号》在所有用户中的平均评分为 4.25，那么它将有 0.75 的偏差(= 4.25-3.50)。

1.4 RMSE —评估预测精度

RMSE =均方根误差

RMSE 是一个试图回答“平均而言，你的预测评分与实际评分相差多少颗星(1-5 颗星)”的数字。

RMSE 越低，预测越准确…

观察:

我们只关心绝对差异。比实际评级高 1 的预测与比实际评级低 1 的预测具有相同的误差 1。
**RMSE 是误差的量级的平均值，与绝对平均误差*不同。***在上述示例中，绝对平均误差为 0.75 (1 + 1 + 0.25 = 2.25/3 = 0.75)，但 RMSE 为 0.8292。RMSE 对大误差给予较高的权重，这在不希望出现大误差时很有用。

正式的 RMSE 定义:

1.5 模型输入(超参数调整)

在电子表格中，有 3 个输入的下拉过滤器。您应该尝试这些输入，看看它们对您的错误有什么影响。

训练历元 — 1 历元是贯穿整个数据集的 1 个训练循环
学习率 —控制我们调整权重/偏差的速度
L2 (lambda)惩罚因子 —这是一个帮助模型防止过度拟合或“记忆”训练数据的术语，因此它可以对看不见的测试数据进行归纳

现在，让我们来看看魔术，因为模型从随机权重开始，并学习最优权重。

观看梯度下降的动作感觉就像你在观看大卫·布赖恩魔术。

他怎么知道我会从 52 个选项中选出那张牌？
等等，他真的只是漂浮起来了吗？

最后你会感到敬畏，你想知道这个魔术是如何完成的。我将分两步向你展示这个技巧，然后揭示魔术背后的数学原理。

2.1“挑一张牌，任意一张牌”(权重初始化)

在训练开始时，权重被随机分配给用户/电影特征，然后算法在训练期间学习最佳权重。

为了证明我们可以随机猜测数字，然后让计算机学习最佳数字是多么“疯狂”,下面是两种权重初始化方法的比较:

简单的——我随机选择了 0.1、0.2 和 0.3 作为用户特性，其余的都是 0.1。
“明凯何” —一种更正式/更好的初始化方法，使用零均值和由特征数量确定的标准偏差，在高斯分布(“钟形曲线”)中随机选择权重(详情如下)

2.2“观看魔术”(看训练误差)

当模型在两种方法的训练期间学习最优值时，观察 RMSE 训练误差从开始(时段 0)到结束(时段 50)发生了什么:

如下所示，两种权重初始化方法在训练结束时收敛到类似的“误差”(0.12 对 0.17)，但“何”方法收敛到较低的误差更快。

要点提示:无论我们从哪种重量开始，机器都会随着时间的推移获得良好的价值！

www.excelwithml.com

注意:要试验其他初始权重，请转到工作表“超参数 _ 和 _ 初始 _ 权重”,并在单元格 G3-J7 和 N3-Q8 中键入您自己的值。介于-1 和 1 之间的任何权重都可以。

要了解更多关于何的初始化，见下文；否则，跳到第 3 部分来学习学习算法背后的数学。

何权重初始化

权重=使用平均值 0 和标准差(=平方根(2/)的正态分布的随机样本。
用于查找电子表格中的值的 Excel 公式:=NORMINV(RAND()，0，SQRT(2/3))

现在，是时候变得书呆子，一步一步地通过梯度下降数学。

如果你不想真的知道魔法如何工作，跳到第 4 部分。

You don’t have to be a wicked smart or need a degree in calc to understand the math.

梯度下降是在训练期间使用的迭代算法，用于更新电影特征、用户偏好和偏差的值，以获得更好的预测。

一般循环是:

步骤 1——定义成本/损失函数，以最小化并初始化权重

步骤 2 —计算预测值

步骤 3 —计算梯度(相对于每个重量的成本变化)

第 4 步——在最小化成本的方向上“稍微”更新每个权重(学习率)

步骤 5 —重复步骤 2–4

要跟进我们为蒂娜·菲更新的“用户功能 1 ”,请转到工作表“培训”并查看第 11–16 行。

由于我们有一个小数据集，我们将使用批量梯度下降。这意味着我们使用整个数据集(在我们的例子中为 1 个用户的所有电影)来训练算法，而不是像随机梯度下降(在我们的例子中为 1 个用户的 1 部电影)那样一次迭代 1 个样本，当你有一个大的数据集时，这样更快。

3.1 定义成本函数以最小化

使用下面的公式，我们的目标是找到潜在因子(矩阵 U 和 M)的值，这些值最小化 SSE(误差平方和)加上 L2 权重惩罚，以帮助模型泛化。

下面是我们的 Excel 模型中的成本函数 calc。该计算忽略了 1/2 项，因为它们仅在梯度下降过程中使用，以使数学更容易:

L2 正则化和过拟合:

我们添加了权重惩罚(L2 正则化或“岭回归”)来防止潜在因素变得过高。这确保了模型不会“过度拟合”(即记忆)训练数据，因为它不会在未看过的测试电影上表现良好。

早些时候，我们使用零 L2 正则化惩罚来训练模型，并且在 50 个时期之后，RMSE 训练误差是 0.12。

但是相对于测试数据，模型的表现如何呢？

如果我们将 L2 惩罚因子从 0.000 更改为 0.300，我们的模型将更好地概括未知的测试数据:

3.2.计算预测

使用随机初始权重，我们将计算蒂娜的电影预测。我们忽略泰坦尼克号，因为它是我们测试数据的一部分，不在我们的训练数据中。

3.3.计算渐变

目标是找到相对于您正在更新的重量的误差梯度(“斜率”)。

找到梯度后，你可以“稍微”移动那个重量，因为它在梯度的相反方向“下降”,在你对每个重量都这样做后，你应该在下一个训练时期有更低的成本。

“只是一点点”是你的学习率，在你找到梯度后，在下面的步骤 3 中使用。

3.4.更新权重

注:上述计算可在以下“培训”表的 X11-X16 单元格中找到。

如果您浏览 Excel calcs，您可以看到电影功能和用户/电影偏好是如何以类似的方式更新的。

在每个训练时期之后，所有电影/用户特征和偏好被同时更新，并且训练循环重复进行。

既然我们已经训练了这个模型，让我们想象一下电影中的两个潜在因素来获得一些洞察力。

如果我们的模型更复杂，有 10 个、20 个或 50 多个潜在因素，我们可以使用一种称为“主成分分析(PCA)”的技术来提取最重要的特征，然后将它们可视化在图表上。

相反，我们的模型只有 3 个特征，所以我们将为电影可视化其中的 2 个，并根据电影的学习特征绘制每部电影。在绘制之后，我们可以解释每个特征“可能代表什么”

直观地说，电影正片 1 可以被解释为戏剧与喜剧，而电影正片 3 可以被视为“面向男性”与“面向女性”

这并不完美，但却是一个合理的解释。《勇士》与其说是喜剧，不如说是剧情片，但其他的似乎也说得通。

摘要

电影评级可以被分解成电影向量和用户向量。一旦一个人对几部电影进行了评价(隐含地或明确地)，推荐系统将利用大众的智慧和你的评价来预测你可能喜欢的其他电影。向量(或“潜在因素”)的大小是通过反复试验确定的，并且基于数据集的大小。

我鼓励您尝试使用电子表格，看看当您更改模型的超参数时会发生什么。

订阅和分享

如果你喜欢这一点，并希望获得更多优秀的学习和备忘单直接发送到您的收件箱，请点击下面并输入您的电子邮件地址(它们都是免费的)。

与人分享，传播机器学习魔法的快乐:)

使用 python 快速洞察学术领域的网络分析

原文：https://towardsdatascience.com/network-analysis-to-quickly-get-insight-into-an-academic-field-with-python-cd891717d547?source=collection_archive---------5-----------------------

每年十月初，科学界都会感到越来越兴奋。是时候宣布今年的诺贝尔奖得主了。从外部的角度来看，很难掌握正在发生的事情，报纸花费了大量的精力试图洞察这个世界的内部运作。现在，假设你对一个新的主题很感兴趣，你想获得一种洞察力，无论你是一名想要指导未来职业生涯的本科生，还是一名想要扩展自己视野或只是随便逛逛的有经验的科学家。当在自己的专业知识之外探索时，获得一个概述可能是压倒性的。谁是关键人物，我怎样才能认识他们，热门话题是什么？通常，在一个领域内需要几年的时间，去参加会议，阅读一份又一份出版物，才能对相关人员及其关系和贡献有一个直觉。幸运的是，通过一些 python 及其丰富的库，我们可以加速这个过程，并通过简单地分析所有相关的期刊出版物来快速洞察这个网络。

感兴趣的话题:2018 年诺贝尔物理学奖

例如，我们看看今年的诺贝尔物理学奖，授予亚瑟·阿什金“光镊及其在生物系统中的应用”同时获奖的还有热拉尔·穆鲁和唐娜·斯特里克兰，他们发明了啁啾脉冲放大。为了便于演示，我们将重点放在光镊领域。简而言之，光镊使用高度聚焦的激光，可以施加微微牛顿的力来固定小粒子。

获取摘要的生物制药

为了避免我们阅读所有的科学文献，我们将使用b[iophython](https://biopython.org/) 包从 PubMed 数据库中获取与我们的搜索查询相关的摘要。确保开始阅读 NCBI 的 Entrez 用户要求。具体来说，我们不想让这项服务超负荷，所以请在美国高峰时间之外提出大量请求，并正确设置电子邮件参数，以便可以联系到您。作为搜索参数，我们将把optical trap作为关键字传递。请注意，光镊的最初术语叫做“单光束梯度力陷阱”，但由于大多数出版物都与几个关键词相关联，我们应该仍然能够获得相关的结果。为了获取，我们首先收集与关键字相关联的出版物的数量，然后收集它们的所有 id，以便以 100 个为一批连续下载。

Total number of publications that contain the term optical trap: 5059100%|██████████| 51/51 [01:20<00:00,  1.36s/it]Complete.

探索数据:顶级作者、时间序列、顶级期刊和顶级关键词

现在有了数以千计的出版物的信息，我们现在想深入了解这些数据。一些直接的问题可能是:谁是领先的科学家？这个领域还有人出版吗？应该看哪些期刊？我应该注意哪些关键词？为了对此有一个总体的了解，我们将研究这些数据。首先，我们将我们的record_list转换成一个pandas数据帧。感兴趣的列是作者姓名的FAU、期刊标题的TA、时间的EDAT和与出版物相关的关键字列表的OT。因为作者和关键字是作为列表存储在数据帧中的，所以我们需要首先将它们展平。这可以通过列表理解方便地完成。然后，我们可以使用集合中的计数器方法方便地提取最常见的元素，并通过使用seaborn创建条形图来可视化它们。

Figure 1: Exploring the data

从这四幅图中，我们可以得出一些有趣的观察结果。首先，在考察顶级作者时，我们注意到诺贝尔奖获得者阿什金并不在场。顶级学者是Bustamante, Carlos.当考虑一段时间内的出版物时，我们看到大多数作品都是在 2000 年之后出版的——当记住阿什金的出版物是在 1986 年时，很明显他的工作是多么重要。时间进程还告诉我们，我们现在正处于出版物数量下降的状态。与我们的搜索查询相关的出版物最多的期刊是 Optics Express。

可视化网络

我们现在可以更深入地挖掘我们的数据，并开始可视化科学网络。具体来说，我们将分析哪些作者一起发表了文章，以及发表的频率。为此，我们为每篇论文创建一个所有作者组合的列表，这将是我们的作者连接。这里，我们不考虑作者的立场，即一个作者是否是主要研究者。在将它转换成一个pandas数据帧之后，我们可以用这个数据帧和networkx包创建一个无向图。每个作者现在都变成了一个node，两者之间的连接是一个edge.，为了显示这个图形，我们使用了nxviz库，并将其显示为一个CircosPlot。在这里，作者排列在一个圆圈上，圆圈之间有联系。虽然我认为这对于给定的任务是一种有益的表示，但是一定要查看可以用于可视化的不同类型的图表
此外，我们将图表限制在前 50 名作者中。作者连接数将通过决定连接线宽的参数edge_width来反映。我们将通过出版物计数来确定节点的数量，以便出版物的数量从拥有最多论文的学者开始顺时针减少(Bustamante, Carlos)。

Figure 2: A CircosPlot of the scientific network of the TOP 50 Authors

有了 CircosPlot，我们现在有了一个科学网络的彩色表示，可以立即发现最重要的人在网络中的联系程度。我们可以看到，在这个前 50 名的网络中，许多作者都有很好的关系，而其他人，即使他们发表了很多，也完全没有关系。虽然这种表示对于获得该领域内人员的定性概述是理想的，但我们接下来将探索如何定量评估人员的重要性。

网络分析:度中心性和介数中心性

为了获得最佳连接的节点，我们将计算网络的两个相关参数:degree_centrality和betweenness_centrality。前者是与节点的所有可能连接相关的连接的度量，而后者是节点是否是两个节点之间最短路径的一部分的度量。转化为我们的案例:谁有最多的合作，谁是联系其他作者的关键？

现在我们可以用这两个指标来扩展我们最初的 10 大图表。为此，我们通过前 10 名作者的最大值来标准化每个参数，以获得 0 和 1 之间的相对值:

Figure 3: Top 10 Authors with Degree and Betweenness Centrality

这让我们验证了 CircosPlot 中已经存在的一个重要观察:拥有最多论文的人不一定是这个网络中联系最好的人。在这里，Rubinsztein-Dunlop, Halina和Chemla, Yann R可以被认为是作者网络中不可或缺的一部分。

寻路:如何与感兴趣的人取得联系

最后，我们将探索如何使用这个网络来寻找路径，也就是说，当你认识某个教授并且想要认识另一个教授时。这很容易通过使用networx包装中的all_shortest_path来完成。举个例子，如果你碰巧知道Ha, Taekjip并且想要查看到Bustamante, Carlos的连接，我们可以计算最短路径:

['Ha, Taekjip', 'Chemla, Yann R', 'Bustamante, Carlos']
['Ha, Taekjip', 'Yu, Jin', 'Bustamante, Carlos']

这里，我们发现两条路径，一条通过Chemla, Yann R，我们已经在图 3 中确定了它的重要性，另一条通过Yu, Jin。这些结果很容易在图示中得到验证。

结论

这里，我们使用了几个 python 包来分析与某个科学领域相关的期刊出版物的摘要。在网络分析的帮助下，只需几行代码就能提供很好的洞察力。最终，它有助于识别在该领域有良好关系和高产的科学家。然而，强调其局限性也很重要，这源于我们在分析中使用的核心指标，即出版物的数量。可以说，这并没有反映科学工作在社区内是如何被接受的。这里，考虑引用的数量将是有益的。当考虑阿什金 1986 年的出版物时，我们可以了解到这部作品被引用了 6000 多次，其重要性显而易见。其他试图衡量影响和生产力的作者级指标，如 h-或 i-index，似乎是有益的选择。
进一步的分析可能包括这些额外的指标。地理信息可以用来显示科学家的位置。示例应用可以是做进一步的网络分析和为科学家建立推荐系统。

网络分析始于一个患病的爱尔兰厨师

原文：https://towardsdatascience.com/network-analytics-started-with-a-diseased-irish-cook-c40424aaa06e?source=collection_archive---------13-----------------------

这是为那些可能在数据科学环境中使用网络的人解释网络原理的系列文章的第三篇。第一篇文章，主要讲图论的起源和图的基本性质，这里可以找到。

1906 年夏天，沃伦一家——一个富裕的纽约大家庭——正在长岛牡蛎湾的度假屋吃晚饭。最令人期待的部分是甜点。在一个炎热的夏天的晚上，桃子超古代龙美尔巴配冰淇淋是一种非常美味、凉爽和提神的食物，孩子们特别喜欢。

几天后，其中一个孩子开始生病，出现伤寒的症状。几天后，包括女佣和一名园丁在内的另外五个人开始出现这种疾病的症状。这令人困惑，因为伤寒被认为主要在肮脏和不卫生的环境中传播，通常与穷人有关。伤寒并没有在牡蛎湾爆发。

把度假屋租给沃伦斯的房东非常担心。这个特别有声望的租赁物业的运营成本很高，他不能因为传染病而让它闲置。他打电话给地方当局，他们检查了所有常见的嫌疑人，包括人和机器。厕所和自来水都接受了检查，在镇上购买食物的当地人也接受了检查。所有检测结果都不能确定是爆发源。

因此，汤普森去纽约市寻找他的伤寒猎人。他在乔治·索普医生身上找到了他——不是医学博士，而是卫生工程师。Soper 对 Warren 家庭的背景情况进行了彻底的研究，他意识到家庭环境最近发生了一个重大变化，这可能会导致新细菌的传播。八月初，他们雇佣了一名新厨师。当他采访沃伦斯，发现厨师的拿手好菜是一道凉菜，桃子超古代龙美尔巴，他变得更加怀疑，因为他知道凉菜更有可能携带活细菌。

厨师是一个名叫玛丽·梅伦的爱尔兰移民，却不见踪影——她在家人开始生病后不久就逃走了。Soper 对 Mallon 的历史进行了几个月的调查，发现了她以前做过厨师的七个家庭，每个家庭都导致了伤寒的爆发，总共感染了 22 人。如果马伦确实是伤寒的健康携带者，就需要尽快找到她。

在接下来的几年里，玛丽·梅伦——或伤寒玛丽——在媒体和公共卫生运动中广为人知——终于在 1907 年 3 月被索普找到，并被确认为伤寒杆菌的原始健康携带者。在接下来的 30 年里，她大部分时间都处于某种隔离状态，有一段时间，她逃跑了，回去给家人做饭，然后再次被捕，并被隔离。她死于 1938 年，不是死于伤寒而是肺炎。她一生中从未表现出伤寒的任何症状，但尸检显示她胆囊中有大量的杆菌。

通过网络传输

索普的工作标志着对疾病传播的首次理解。在过去的 50 年中，许多成功的疾病爆发鉴定都集中在对地点和场所的研究上，包括 19 世纪 50 年代在伦敦发现的著名的大街霍乱爆发。

但这是第一次通过人而不是地方成功追踪到疾病。这是理解事物如何通过人际网络流动的开始。在一定程度上，信息以类似于疾病的方式通过人们的网络流动，因此我们使用“病毒式”一词来描述今天快速而广泛的信息传播。这项早期的工作旨在了解疾病在网络中的传播，它代表了我们今天看待信息传播的方式的起源，无论是趋势、谣言还是广告。

以最简单的形式考虑信息流，一条信息是否从一个人流向另一个人的问题取决于两个因素:那个人连接的人数，姑且称之为 k ，以及信息被传递的概率，姑且称之为 p 。在玛丽·梅伦的例子中，当局意识到 p 很难被影响——你将很难改变一个没有受过教育的厨师一生的卫生习惯。所以通过隔离 Mallon 来降低 k 是控制疾病传播的唯一真正的选择。

在社交网络中，了解如何操纵 p(T1)和 T2(T3)对于管理营销、广告、新闻或假新闻的传播至关重要。 p 可以通过确保话题与个人的已知兴趣有很强的共同性，或者通过与个人明确约定信息将被传递来增加。通过网络中高价个体的工作，k 可以增加(见本系列上一篇关于价的更多信息)。

谣言和信息传播

实际上，我们上面的 p 和 k 代表了一个趋势和谣言如何在网络中传播的简单模型。一方面，信息是否在两个人之间进行交易既取决于传递信息的倾向也取决于接收信息的兴趣。它还假设我们正在处理的网络图是树，只向下传递信息，在复杂的社会网络中通常不是这样。**

在社交网络中，可能会发生多种类型的互动。如果 A 是收到信息的人的集合， B 是没有收到信息的人的集合，有几种情况是可能的。 A 可以传给 A ， A 可以传给 B. 在这两种情况下，接受者都可以选择接受或者拒绝——即使他们之前已经选择了，他们也可以改变主意。

当比较趋势和谣言的传播与疾病的传播时，另一个很大的区别是，我们更感兴趣的是信息去了哪里，而不是它来自哪里。关于谣言如何在社交网络上传播的研究得出了一些非常有趣的观察结果。

像脸书和推特这样的大型网络可能会展示出无标度网络的一些特性。价数或联系数小的人多，联系数大的人少。如果你根据联系的数量来绘制人的图表，你会得到类似上图的东西，有一条渐近真实曲线或一条线性对数曲线。最近的研究这里表明，虽然我们不能精确地将社交网络与无标度的正式数学定义相匹配，但没有其他数学模型比无标度模型更适合它们。

无标度网络存在于许多领域，包括生物化学、技术和金融。在无标度网络中，信息传播与网络的规模直接相关。Twitter 和脸书是规模庞大的网络，但也有数学属性，使它们正好处于信息传播极快的范围内。例如，在 Twitter 上，一条信息只需 8 个信息交换步骤就可以覆盖近 5000 万用户。这些网络的力量是可怕的！

预测趋势

当你查看你的社交媒体订阅源时，你经常会被告知什么是“趋势”。社交媒体引擎利用对信息传播的研究来设计算法，以自动确定某个主题在网络中的传播速度何时超过其他主题。

简单的趋势模型遵循某个统计窗口内的“主题”或“标签”。如上图所示，该窗口显示了网络上大多数主题的预期传输活动。对这些主题的实时跟踪可以揭示出那些活动曲线意外跳出该统计窗口的主题，如果跳跃幅度很大，则被视为“趋势”。例如，上面的红点可以代表网络决定将主题分类为趋势的时间点和活动。

然而，这种根据期望窗口跟踪单个趋势的方法会导致错误，并且高度依赖于人类的判断，这在非常大的网络中是不可行的。趋势可能会以不可预测的方式出现，或者在被归类为趋势后很快就会“逆转”，这对于预测者来说可能会很尴尬。

2012 年，麻省理工学院的一项研究发现了一种全自动预测 Twitter 趋势的方法，比 Twitter 自己预测趋势早两个小时，准确率高达 95%。研究人员使用了一个以前有趋势和没有趋势的主题的数据库，并将任何当前主题的推文活动与该数据库进行了比较，计算了活动曲线之间的距离。那些其距离最接近趋势的先前主题的曲线的曲线本身被预测为趋势。这项研究引出了当今社交网络预测趋势最常用的方法。

在本系列的下一篇文章中，我将着眼于以促进高效网络分析的方式捕获数据的数据系统，以及这是如何实现许多令人着迷的发现的。这里读一下。****

最初我是一名纯粹的数学家，后来我成为了一名心理计量学家和数据科学家。我热衷于将所有这些学科的严谨性应用到复杂的人的问题上。我也是一个编码极客和日本 RPG 的超级粉丝。在 LinkedIn 或Twitter上找我。

神经机器翻译—使用 seq2seq 和 Keras

原文：https://towardsdatascience.com/neural-machine-translation-using-seq2seq-with-keras-c23540453c74?source=collection_archive---------1-----------------------

基于编解码模型的英语到法语翻译

Photo by Kiarash Mansouri on Unsplash

本文是受此 的启发，以 和 为例阐述了 上的编解码网络*。*目的是从这个例子中获得直观和详细的理解。在我的 github 链接 中提供了我自己对这个例子的实现。

在我们开始之前，它可能有助于通过 我的另一篇关于 LSTM 的文章来帮助理解 LSTM 的基本原理。

下面是用于训练 seq2seq 编码器-解码器网络的详细网络架构。我们将引用这个数字。

Fig A— Encoder-Decoder training architecture for NMT — image copyright@Ravindra Kompella

首先，我们将着手训练网络。然后我们将看看如何把一个给定的英语句子翻译成法语的推理模型。推理模型(用于预测输入序列)有一个稍微不同的解码器架构，我们将在那里详细讨论。

训练网络—

那么训练数据看起来怎么样呢？

我们有 10，000 个英语句子和相应的 10，000 个翻译的法语句子。所以我们的 nb_samples = 10000。

培训总体计划—

为英语和法语句子创建一次性字符嵌入。这些将是编码器和解码器的输入。法语一键字符嵌入也将用作损失函数的目标数据。
一个字符一个字符地输入到编码器中，直到英文句子序列结束。
获得最终的编码器状态(隐藏和单元状态),并将它们作为解码器的初始状态提供给解码器。
解码器在每个时间步长有 3 个输入——2 个解码器状态和一个字符一个字符地输入的法国字符嵌入。
在解码器的每一步，解码器的输出都被发送到 softmax 层，与目标数据进行比较。

代码训练网络的详细流程—

参考代码片段 1——注意，我们在法语句子的开头附加了' \t ',在法语句子的结尾附加了' \n'。这些附加的法语句子将被用作解码器的输入。所有的英文字符和法文字符都收集在不同的集合中。这些集合被转换成字符级字典(对以后检索索引和字符值很有用)。

Snippet 1

参考片段 2—为编码器输入、解码器输入和目标数据嵌入准备嵌入。我们将为英语和法语中的每个字符分别创建一个热编码。这些在代码片段中被称为 tokenized_eng_sentences 和 tokenized_fra_sentences 。这些将分别是编码器和解码器的输入。请注意，与解码器输入嵌入相比，我们在 softmax 层输出比较的 target_data 法语字符嵌入偏移了(t+1 )(因为目标数据中没有起始标签，请参考上面的架构图以获得更多信息)。因此，下面代码片段中的 target_data 被相应地偏移(注意下面 target_data 数组的第二维中的 k-1 )

Snippet 2.

参考片段 2——正如我们在 中提到的，我在 LSTM ，中的嵌入(tokenized _ eng _ sentences和tokenized _ fra _ sentences和 target_data) 是 3D 数组。第一维对应于 nb_samples ( =本例中为 10，000)。第二维对应于英语/法语句子的最大长度，第三维对应于英语/法语字符的总数。

参考代码片段 3:我们将一个字符接一个字符(当然，它们对应的一个热嵌入)输入编码器网络。对于编码器 _LSTM，我们已经设置了返回 _ 状态=真。我们没有做 return_sequences = True (默认设置为 False)。这将意味着我们在输入序列结束时仅获得最终编码的单元状态和编码的隐藏状态，而不是每个时间步长的中间状态。这些将是用于初始化解码器状态的最终编码状态。

Snippet 3— Encoder model for training

参考代码片段 3 —还要注意，输入形状已经被指定为 (None，len(eng_chars)) 。这意味着编码器 LSTM 可以动态地展开与字符数一样多的时间步长，直到到达该句子序列的末尾。

参考代码片段 4——解码器的输入将是法语字符嵌入(包含在 tokenized_fra_sentences 数组中),在每个时间步一个接一个，以及先前的状态值。解码器第一步的先前状态将用我们之前在代码片段 3 中收集的最终编码器状态进行初始化。因此，请注意在下面的代码片段中已经设置了初始状态=编码器状态。从随后的步骤开始，解码器的状态输入将是其单元状态和隐藏状态。

Snippet 4 — Decoder model for training

同样从上面的代码片段中，请注意解码器设置为return _ sequences = True以及return _ state = True。因此，我们在每个时间步长获得解码器输出和两个解码器状态。虽然这里已经声明了return _ state = True，但是在训练模型时我们不打算使用解码器状态。其存在的原因是它们将在构建解码器推理模型时使用(我们将在后面看到)。解码器输出通过 softmax 层传递，该层将学习对正确的法语字符进行分类。

参考片段 5——损失函数是分类交叉熵，它是通过将 softmax 层的预测值与 target_data (一个热门法语字符嵌入)进行比较而获得的。

现在模型已经准备好进行训练了。针对指定数量的时期训练整个网络。

Snippet 5 — y = target_data ( containing one hot french character embeds)

测试(推理模式)——

以下是用于推理模型的架构——推理模型将利用训练期间学习的所有网络参数，但我们单独定义它们，因为推理期间的输入和输出不同于训练网络期间的输入和输出。

从下图可以看出，网络的编码器端没有变化。因此，我们将新的英语句子(嵌入一个热字符)向量作为输入序列馈送到编码器模型，并获得最终的编码状态。

Fig B— Encoder-Decoder Inference model architecture for NMT —image copyright @Ravindra Kompella

将解码器端的图 B 与图 A 进行对比。可以看到的主要变化如下—

在第一个时间步长，解码器有 3 个输入——开始标记' \t '和两个编码器状态。我们将第一个字符作为' \t '(它的一个热嵌入向量)输入到解码器的第一个时间步长中。
然后解码器输出第一个预测字符(假设是‘V’)。
观察蓝线是如何连接回下一个时间步长的解码器输入的。所以这个预测的字符“V”将在下一个时间步作为输入被馈送到解码器。
还要注意，在每个时间步，我们在 softmax 层的输出上使用 np.argmax 函数，仅获得预测字符的一个热嵌入向量。因此，我们在索引上进行反向字典查找，以获得实际的字符‘V’。
从下一时间步开始，解码器仍有 3 个输入，但不同于第一时间步。它们是先前预测字符的一个热编码、先前解码器单元状态和先前解码器隐藏状态

鉴于以上理解，现在让我们看看代码—

参考代码片段 6——编码器推理模型非常简单。这将只输出编码器状态。

Snippet 6 — Encoder inference model

参考代码片段 7——解码器模型更加复杂。注意，我们为解码器隐藏状态和解码器单元状态创建单独的“输入”。这是因为我们将在每个时间步长(而不是第一个时间步长)提供这些状态，回想一下，在第一个时间步长，我们仅将编码器状态提供给解码器，解码器推理模型是一个单独的独立模型。编码器和解码器都将被递归调用，用于在翻译后的序列中生成的每个字符。

Snippet 7 — Decoder inference model

参考代码片段 8——我们将编码器状态放入 states_val 变量。在 while 循环内的第一次调用中，来自编码器的这些隐藏和单元状态将用于初始化作为模型输入直接提供的 decoder_model_inf 。一旦我们使用 softmax 预测了字符，我们现在输入这个预测的字符(使用 target_seq 3D 数组用于预测字符的一次热嵌入)以及更新的 states_val (从先前的解码器状态更新而来)用于下一次的 while 循环迭代。注意，在我们每次在 while 循环中创建预测字符的一键嵌入之前，我们重置了我们的 target_seq 。

Snippet 8 — Function to recursively call the decoder for predicting the translated character sequence.

就是这样！现在我们有了一个训练有素的模型，可以把英语句子翻译成法语！下面是在训练网络 25 个时期后获得的结果。

Results obtained using some sample training data

如果你打算使用任何上述架构图的数字，请随时这样做，并要求你提到我的名字在图像学分。

如果你从这篇文章中发现了什么有用的信息，请举起鼓掌图标表示你的掌声。

用 Python 实现神经机器翻译

原文：https://towardsdatascience.com/neural-machine-translation-with-python-c2f0a34f7dd?source=collection_archive---------0-----------------------

Photo credit: eLearning Industry

机器翻译，有时简称为 MT 是一项非常具有挑战性的任务，研究如何使用软件将文本或语音从一种语言翻译成另一种语言。传统上，它涉及使用高度复杂的语言知识开发的大型统计模型。

在这里，我们将使用深度神经网络来解决机器翻译的问题。我们将发现如何开发一个神经机器翻译模型来将英语翻译成法语。我们的模型将接受英语文本作为输入，并返回法语翻译。更准确地说，我们将练习构建 4 个模型，它们是:

简单的 RNN。
嵌入的 RNN。
双向 RNN。
编码器-解码器模型。

训练和评估深度神经网络是一项计算密集型任务。我使用了 AWS EC2 实例来运行所有代码。如果您打算继续下去，您应该能够访问 GPU 实例。

导入库

import collectionsimport helper
import numpy as np
import project_tests as testsfrom keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from keras.models import Model
from keras.layers import GRU, Input, Dense, TimeDistributed, Activation, RepeatVector, Bidirectional
from keras.layers.embeddings import Embedding
from keras.optimizers import Adam
from keras.losses import sparse_categorical_crossentropy

我用[help.py](https://github.com/susanli2016/NLP-with-Python/blob/master/helper.py)加载数据，[project_test.py](https://github.com/susanli2016/NLP-with-Python/blob/master/project_tests.py)用于测试我们的功能。

数据

数据集包含相对较少的词汇，可以在这里找到。small_vocab_en文件包含small_vocab_fr文件中的英语句子及其法语翻译。

加载数据

english_sentences = helper.load_data('data/small_vocab_en')
french_sentences = helper.load_data('data/small_vocab_fr')print('Dataset Loaded')

数据集加载

例句

small_vocab_en中的每一行都包含一个英文句子，而small_vocab_fr中的每一行都有相应的翻译。

for sample_i in range(2):
    print('small_vocab_en Line {}:  {}'.format(sample_i + 1, english_sentences[sample_i]))
    print('small_vocab_fr Line {}:  {}'.format(sample_i + 1, french_sentences[sample_i]))

Figure 1

词汇

问题的复杂程度是由词汇的复杂程度决定的。更复杂的词汇是更复杂的问题。让我们看看我们将要处理的数据集的复杂性。

english_words_counter = collections.Counter([word for sentence in english_sentences for word in sentence.split()])
french_words_counter = collections.Counter([word for sentence in french_sentences for word in sentence.split()])print('{} English words.'.format(len([word for sentence in english_sentences for word in sentence.split()])))
print('{} unique English words.'.format(len(english_words_counter)))
print('10 Most common words in the English dataset:')
print('"' + '" "'.join(list(zip(*english_words_counter.most_common(10)))[0]) + '"')
print()
print('{} French words.'.format(len([word for sentence in french_sentences for word in sentence.split()])))
print('{} unique French words.'.format(len(french_words_counter)))
print('10 Most common words in the French dataset:')
print('"' + '" "'.join(list(zip(*french_words_counter.most_common(10)))[0]) + '"')

Figure 2

预处理

我们将使用以下预处理方法将文本转换为整数序列:

将单词标记为 id
添加填充以使所有序列长度相同。

符号化

使用 Keras 的[Tokenizer](https://keras.io/preprocessing/text/#tokenizer)函数将每个句子转换成一系列单词 id。使用此函数来标记english_sentences和french_sentences。

函数tokenize返回标记化的输入和标记化的类。

def tokenize(x):
    x_tk = Tokenizer(char_level = False)
    x_tk.fit_on_texts(x)
    return x_tk.texts_to_sequences(x), x_tktext_sentences = [
    'The quick brown fox jumps over the lazy dog .',
    'By Jove , my quick study of lexicography won a prize .',
    'This is a short sentence .']
text_tokenized, text_tokenizer = tokenize(text_sentences)
print(text_tokenizer.word_index)
print()
for sample_i, (sent, token_sent) in enumerate(zip(text_sentences, text_tokenized)):
    print('Sequence {} in x'.format(sample_i + 1))
    print('  Input:  {}'.format(sent))
    print('  Output: {}'.format(token_sent))

Figure 3

填充

通过使用 Keras 的[pad_sequences](https://keras.io/preprocessing/sequence/#pad_sequences)函数向每个序列的末端添加填充，确保所有英文序列和所有法文序列长度相同。

def pad(x, length=None):
    if length is None:
        length = max([len(sentence) for sentence in x])
    return pad_sequences(x, maxlen = length, padding = 'post')tests.test_pad(pad)# Pad Tokenized output
test_pad = pad(text_tokenized)
for sample_i, (token_sent, pad_sent) in enumerate(zip(text_tokenized, test_pad)):
    print('Sequence {} in x'.format(sample_i + 1))
    print('  Input:  {}'.format(np.array(token_sent)))
    print('  Output: {}'.format(pad_sent))

Figure 4

预处理管道

实现预处理功能

def preprocess(x, y):
    preprocess_x, x_tk = tokenize(x)
    preprocess_y, y_tk = tokenize(y)preprocess_x = pad(preprocess_x)
    preprocess_y = pad(preprocess_y)# Keras's sparse_categorical_crossentropy function requires the labels to be in 3 dimensions
    preprocess_y = preprocess_y.reshape(*preprocess_y.shape, 1)return preprocess_x, preprocess_y, x_tk, y_tkpreproc_english_sentences, preproc_french_sentences, english_tokenizer, french_tokenizer =\
    preprocess(english_sentences, french_sentences)

max_english_sequence_length = preproc_english_sentences.shape[1]
max_french_sequence_length = preproc_french_sentences.shape[1]
english_vocab_size = len(english_tokenizer.word_index)
french_vocab_size = len(french_tokenizer.word_index)print('Data Preprocessed')
print("Max English sentence length:", max_english_sequence_length)
print("Max French sentence length:", max_french_sequence_length)
print("English vocabulary size:", english_vocab_size)
print("French vocabulary size:", french_vocab_size)

Figure 5

模型

在本节中，我们将实验各种神经网络架构。我们将从训练四个相对简单的架构开始。

模型 1 是一个简单的 RNN
模型 2 是具有嵌入的 RNN
模型 3 是双向 RNN
模型 4 是一个编码器-解码器 RNN

在对四个简单的架构进行实验之后，我们将构建一个更深层次的模型，该模型旨在超越所有四个模型。

id 返回正文

神经网络将把输入翻译成单词 ids，这不是我们想要的最终形式。我们想要法语翻译。函数logits_to_text将在从神经网络到法语翻译的逻辑之间架起一座桥梁。我们将使用这个函数来更好地理解神经网络的输出。

def logits_to_text(logits, tokenizer):
    index_to_words = {id: word for word, id in tokenizer.word_index.items()}
    index_to_words[0] = '<PAD>'return ' '.join([index_to_words[prediction] for prediction in np.argmax(logits, 1)])print('`logits_to_text` function loaded.')

logits_to_text 函数已加载。

车型一:RNN

Figure 6

我们正在创建一个基本的 RNN 模型，它是将英语翻译成法语的序列数据的良好基线。

def simple_model(input_shape, output_sequence_length, english_vocab_size, french_vocab_size):
    learning_rate = 1e-3
    input_seq = Input(input_shape[1:])
    rnn = GRU(64, return_sequences = True)(input_seq)
    logits = TimeDistributed(Dense(french_vocab_size))(rnn)
    model = Model(input_seq, Activation('softmax')(logits))
    model.compile(loss = sparse_categorical_crossentropy, 
                 optimizer = Adam(learning_rate), 
                 metrics = ['accuracy'])

    return model
tests.test_simple_model(simple_model)tmp_x = pad(preproc_english_sentences, max_french_sequence_length)
tmp_x = tmp_x.reshape((-1, preproc_french_sentences.shape[-2], 1))# Train the neural network
simple_rnn_model = simple_model(
    tmp_x.shape,
    max_french_sequence_length,
    english_vocab_size,
    french_vocab_size)
simple_rnn_model.fit(tmp_x, preproc_french_sentences, batch_size=1024, epochs=10, validation_split=0.2)# Print prediction(s)
print(logits_to_text(simple_rnn_model.predict(tmp_x[:1])[0], french_tokenizer))

Figure 7

基本的 RNN 模型的验证精度终止于 0.6039。

模式二:嵌入

Figure 8

嵌入是在 n 维空间中接近相似单词的单词的向量表示，其中 n 表示嵌入向量的大小。我们将使用嵌入创建一个 RNN 模型。

from keras.models import Sequential
def embed_model(input_shape, output_sequence_length, english_vocab_size, french_vocab_size):
    learning_rate = 1e-3
    rnn = GRU(64, return_sequences=True, activation="tanh")

    embedding = Embedding(french_vocab_size, 64, input_length=input_shape[1]) 
    logits = TimeDistributed(Dense(french_vocab_size, activation="softmax"))

    model = Sequential()
    #em can only be used in first layer --> Keras Documentation
    model.add(embedding)
    model.add(rnn)
    model.add(logits)
    model.compile(loss=sparse_categorical_crossentropy,
                  optimizer=Adam(learning_rate),
                  metrics=['accuracy'])

    return model
tests.test_embed_model(embed_model)tmp_x = pad(preproc_english_sentences, max_french_sequence_length)
tmp_x = tmp_x.reshape((-1, preproc_french_sentences.shape[-2]))embeded_model = embed_model(
    tmp_x.shape,
    max_french_sequence_length,
    english_vocab_size,
    french_vocab_size)embeded_model.fit(tmp_x, preproc_french_sentences, batch_size=1024, epochs=10, validation_split=0.2)print(logits_to_text(embeded_model.predict(tmp_x[:1])[0], french_tokenizer))

Figure 9

嵌入模型的验证精度终止于 0.8401。

模型 3:双向 RNNs

Figure 10

def bd_model(input_shape, output_sequence_length, english_vocab_size, french_vocab_size):

    learning_rate = 1e-3
    model = Sequential()
    model.add(Bidirectional(GRU(128, return_sequences = True, dropout = 0.1), 
                           input_shape = input_shape[1:]))
    model.add(TimeDistributed(Dense(french_vocab_size, activation = 'softmax')))
    model.compile(loss = sparse_categorical_crossentropy, 
                 optimizer = Adam(learning_rate), 
                 metrics = ['accuracy'])
    return model
tests.test_bd_model(bd_model)tmp_x = pad(preproc_english_sentences, preproc_french_sentences.shape[1])
tmp_x = tmp_x.reshape((-1, preproc_french_sentences.shape[-2], 1))bidi_model = bd_model(
    tmp_x.shape,
    preproc_french_sentences.shape[1],
    len(english_tokenizer.word_index)+1,
    len(french_tokenizer.word_index)+1)bidi_model.fit(tmp_x, preproc_french_sentences, batch_size=1024, epochs=20, validation_split=0.2)# Print prediction(s)
print(logits_to_text(bidi_model.predict(tmp_x[:1])[0], french_tokenizer))

Figure 11

双向 RNN 模型的验证精度终止于 0.5992。

模型 4:编码器-解码器

编码器创建句子的矩阵表示。解码器将该矩阵作为输入，并预测翻译作为输出。

def encdec_model(input_shape, output_sequence_length, english_vocab_size, french_vocab_size):

    learning_rate = 1e-3
    model = Sequential()
    model.add(GRU(128, input_shape = input_shape[1:], return_sequences = False))
    model.add(RepeatVector(output_sequence_length))
    model.add(GRU(128, return_sequences = True))
    model.add(TimeDistributed(Dense(french_vocab_size, activation = 'softmax')))

    model.compile(loss = sparse_categorical_crossentropy, 
                 optimizer = Adam(learning_rate), 
                 metrics = ['accuracy'])
    return model
tests.test_encdec_model(encdec_model)tmp_x = pad(preproc_english_sentences)
tmp_x = tmp_x.reshape((-1, preproc_english_sentences.shape[1], 1))encodeco_model = encdec_model(
    tmp_x.shape,
    preproc_french_sentences.shape[1],
    len(english_tokenizer.word_index)+1,
    len(french_tokenizer.word_index)+1)encodeco_model.fit(tmp_x, preproc_french_sentences, batch_size=1024, epochs=20, validation_split=0.2)print(logits_to_text(encodeco_model.predict(tmp_x[:1])[0], french_tokenizer))

Figure 12

编码器-解码器模型的验证精度终止于 0.6406。

型号 5:定制

创建一个将嵌入和双向 RNN 合并到一个模型中的 model_final。

在这个阶段，我们需要做一些实验，例如将 GPU 参数更改为 256，将学习率更改为 0.005，为超过(或少于)20 个时期训练我们的模型等。

def model_final(input_shape, output_sequence_length, english_vocab_size, french_vocab_size):

    model = Sequential()
    model.add(Embedding(input_dim=english_vocab_size,output_dim=128,input_length=input_shape[1]))
    model.add(Bidirectional(GRU(256,return_sequences=False)))
    model.add(RepeatVector(output_sequence_length))
    model.add(Bidirectional(GRU(256,return_sequences=True)))
    model.add(TimeDistributed(Dense(french_vocab_size,activation='softmax')))
    learning_rate = 0.005

    model.compile(loss = sparse_categorical_crossentropy, 
                 optimizer = Adam(learning_rate), 
                 metrics = ['accuracy'])

    return model
tests.test_model_final(model_final)print('Final Model Loaded')

最终模型载入

预言；预测；预告

def final_predictions(x, y, x_tk, y_tk):
    tmp_X = pad(preproc_english_sentences)
    model = model_final(tmp_X.shape,
                        preproc_french_sentences.shape[1],
                        len(english_tokenizer.word_index)+1,
                        len(french_tokenizer.word_index)+1)

    model.fit(tmp_X, preproc_french_sentences, batch_size = 1024, epochs = 17, validation_split = 0.2)

    y_id_to_word = {value: key for key, value in y_tk.word_index.items()}
    y_id_to_word[0] = '<PAD>'sentence = 'he saw a old yellow truck'
    sentence = [x_tk.word_index[word] for word in sentence.split()]
    sentence = pad_sequences([sentence], maxlen=x.shape[-1], padding='post')
    sentences = np.array([sentence[0], x[0]])
    predictions = model.predict(sentences, len(sentences))print('Sample 1:')
    print(' '.join([y_id_to_word[np.argmax(x)] for x in predictions[0]]))
    print('Il a vu un vieux camion jaune')
    print('Sample 2:')
    print(' '.join([y_id_to_word[np.argmax(x)] for x in predictions[1]]))
    print(' '.join([y_id_to_word[np.max(x)] for x in y[0]]))final_predictions(preproc_english_sentences, preproc_french_sentences, english_tokenizer, french_tokenizer)

Figure 13

我们得到了两个句子的完美翻译和 0.9776 的验证准确度分数！

源代码可以在 Github 找到。我期待听到反馈或问题。

从头开始的神经网络(使用 Numpy)

原文：https://towardsdatascience.com/neural-net-from-scratch-using-numpy-71a31f6e3675?source=collection_archive---------3-----------------------

image Source: Data Flair

这篇文章是关于使用 Python 中的 numpy 库为分类问题从头构建一个浅层 NeuralNetowrk(nn )(只有一个隐藏层),并与 LogisticRegression(使用 scikit learn)进行性能比较。

从头开始构建神经网络有助于理解神经网络在后端如何工作，这对于构建有效的模型是必不可少的。让我们毫不迟疑地从头开始构建简单的浅层神经网络模型。

完整的代码可在这里。

对于这项任务，我正在使用 scikit learn 数据集生成器 make_gaussian_quantiles 函数生成数据集(生成各向同性高斯样本并按分位数标记样本)。生成的输入数据集将有两个特征(“X1”和“X2”)，输出“Y”将有两个类(红色:0，蓝色:1)，共有 200 个示例。

def load_extra_datasets():  
    **N = 200**
    **gaussian_quantiles** = **sklearn.datasets.make_gaussian_quantiles**
     (mean=None, cov=0.7, n_samples=N, **n_features=2, n_classes=2**,  shuffle=True, random_state=None)
    return  gaussian_quantilesgaussian_quantiles= load_extra_datasets()
X, Y = gaussian_quantiles
X, Y = X.T, Y.reshape(1, Y.shape[0])# Visualize the data
plt.scatter(X[0, :], X[1, :], c=Y, s=40, cmap=plt.cm.Spectral);

生成的数据集有两个类，分别标为红色和蓝色的点。我们的目标是建立一个机器学习分类器，在给定 X 和 Y 坐标的情况下预测正确的类别。正如我们在图中看到的，数据不是线性可分的，所以我们不能画一条直线来分隔这两个类。这意味着线性分类器，如逻辑回归，将无法适合这些类型的数据。在这种情况下，神经网络会帮助我们。在神经网络中，不需要特征工程，因为隐藏层会自动学习特征模式，以准确地对数据进行分类。

逻辑回归:

首先，让我们使用输入的 x 和 y 值训练一个 LR 分类器，输出将是预测的类(0 或 1)。我们将使用 scikit-learn 中的回归类

clf = sklearn.linear_model.LogisticRegressionCV()
clf.fit(X.T, Y.T)# Plot the decision boundary for logistic regressionplot_decision_boundary(lambda x: clf.predict(x), X, Y)
plt.title("Logistic Regression")# Print accuracyLR_predictions = clf.predict(X.T)
print ('Accuracy of logistic regression: %d ' % float((np.dot(Y,LR_predictions) + np.dot(1-Y,1-LR_predictions))/float(Y.size)*100) +
       '% ' + "(percentage of correctly labelled datapoints)")

从上面我们可以看到，LR 只能正确分类 53%的数据点，因为这些数据点不是线性可分的。

神经网络:

现在让我们建立一个简单的神经网络，1 个隐藏层，4 个神经元。输入层将有 2 个节点，因为我们的数据有两个特征(X1 和 X2)，输出层将有一个节点，根据概率阈值，我们将输出分类为红色或蓝色(0 或 1)。

Source: Andrew Ng’s Coursera

我们需要做以下步骤来建立我们的神经网络模型。

定义网络结构(输入单元数量、隐藏单元数量等)。
初始化模型的参数
循环执行以下步骤，直到我们获得最小成本/最佳参数。

实现向前传播
计算损失
实现反向传播以获得梯度
更新参数

然后将上述所有步骤合并成一个函数，我们称之为‘nn _ model()’。
一旦我们建立了“nn_model()”并学习了正确的参数，我们就可以对新数据进行预测。

定义网络结构:如前所述，输入层的节点数为 2，隐藏层的节点数为 4。通过在这一层选择更多的节点，我们可以使模型学习复杂的函数。但是进行预测和学习网络参数需要大量的计算。更多的隐藏层和节点也会导致我们的数据过度拟合。

#X and Y are the input and output variables **n_x = X.shape[0] # size of input layer`
    n_h = 4
    n_y = Y.shape[0] # size of output layer**

2。初始化模型的参数 : W1(隐藏层的权重矩阵)和 W2(输出层的权重矩阵)参数使用 numpy 随机函数随机初始化。乘以 0.01，因为我们不希望初始权重过大，因为这会导致学习速度变慢。b1 和 b2 被初始化为零。

W1 —隐藏层的形状权重矩阵(n_h，n _ x)
B1—形状偏差向量(n_h，1)
W2 —输出层的形状权重矩阵(n_y，n _ h)
B2—形状偏差向量(n_y，1)

 W1 = np.random.randn(n_h,n_x) * 0.01
    b1 = np.zeros(shape=(n_h, 1))
    W2 = np.random.randn(n_y,n_h) * 0.01
    b2 = np.zeros(shape=(n_y, 1))

**3。前向传播:**在前向传播期间，输入特征矩阵被馈送到隐藏层中的每个神经元。其将乘以相应的初始权重集(W1)和偏差集(b1)以形成 Z1 矩阵(给定输入的线性变换)。然后，我们通过激活函数将非线性应用于 Z1(以应用非线性)。我们选择“tanh”作为我们的激活函数，因为它适合许多场景。这个激活函数/隐藏层的输出将是 a1(这是一个大小为(4，1)的矩阵，包含来自 4 个神经元的激活，即 A1、a2、a3、a4)。

对于下一层，在我们的情况下是最终输出层，我们将来自前一层(A1)的输入乘以输出层(W2)的初始权重，加上偏差(b2)以形成 Z2。然后在 Z2 上应用 sigmoid 激活函数以产生最终输出 A2(这是我们的预测)。我们使用 sigmoid 作为最后一层，因为我们希望我们的输出介于 0 和 1 之间。基于概率阈值，我们可以决定输出是红色还是蓝色。这就是 nn 如何在前向传播期间进行预测，这只是一系列矩阵乘法和激活函数的应用。

# Implement Forward Propagation to calculate A2 (probabilities)
    Z1 = np.dot(W1,X) + b1
    A1 = np.tanh(Z1)
    Z2 = np.dot(W2,A1) + b2
    A2 = sigmoid(Z2) # Final output prediction

4。计算损失:现在我们有了我们的预测，下一步将是检查我们的预测与实际值有多大差异，即损失/误差。这里我们不使用均方差(MSE)来计算我们的损失，因为我们的预测函数是非线性的(sigmoid)。平方预测将导致具有许多局部最小值的非凸函数。在这种情况下，梯度下降可能找不到最优的全局最小值。因此，我们使用二元交叉熵损失(用于误差估计的对数似然方法)，该成本函数本质上是凸的，因此到达全局最小点(最小损失点)将更容易。下面是成本函数公式和代码。

m:训练实例的数量

# Compute the cross-entropy costlogprobs = np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2)
cost = - np.sum(logprobs) / m

5。反向传播/梯度下降(GD) :反向传播用于计算损失函数相对于模型参数(w1，b1，w2，b2)的梯度(斜率/导数)。为了最小化我们的成本，我们使用 GD 算法，该算法使用计算的梯度来更新参数，使得我们的成本随着迭代不断降低，即，它有助于向全局最小值移动。

以下是每个模型参数的梯度/斜率计算公式。“m”是训练样本的数量。

Sourced from Coursera

 dZ2 = A2 - Y
    dW2 = (1 / m) * np.dot(dZ2, A1.T)
    db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)
    dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2))
    dW1 = (1 / m) * np.dot(dZ1, X.T)
    db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)

6。更新参数:一旦我们计算出我们的梯度，我们将它们乘以一个称为学习率(收敛率)的因子，并从初始参数中减去以获得更新的参数(权重和偏差)。学习率应该是最小的，这样我们就不会错过全局最小点。

用学习率乘以梯度
从重量中减去

 W1 = W1 - learning_rate * dW1
    b1 = b1 - learning_rate * db1
    W2 = W2 - learning_rate * dW2
    b2 = b2 - learning_rate * db2

现在，我们已经为所有训练示例执行了一轮前向传播和后向传播，即，我们完成了 1 个时期。我们需要在多个时期重复这些步骤，直到我们的成本最小(模型达到全局最小点)或者学习停止(参数没有更新)。

下面是函数“nn_model ”,它在给定的时期数(num_iterations)内重复执行上述所有操作，并在每 1000 个时期后打印成本。该函数的输出将是最终的一组优化参数(重量/基数)。

7。预测:下面是使用学习到的参数进行预测的函数，只需向前传播即可。我们将阈值设置为 0.5，如果最终层(A2)的输出是> 0.5，那么我们将其分类为 1:蓝色，否则为 0:红色。

现在，让我们通过运行函数 nn_model 超过 5000 个时期来训练我们的最终模型，并查看结果。

从结果可以看出，我们的神经网络模型很好地学习了模式。其能够学习分隔类别的非线性决策边界。而我们的成本从 0.69 开始，经过 4000 个纪元达到 0.089。最终的准确率达到 93%,这比我们从逻辑回归得到的只有 53%要高得多。

调整隐藏层大小:下一步是决定隐藏层神经元的最佳数量，看看我们的模型是否能在不过度拟合的情况下做得更好。为此，让我们使用不同数量的节点(1、2、3、4、5、20、50)来训练模型，并查看结果。

以下是这次测试的结果。

较大的模型(具有更多隐藏单元)能够更好地拟合训练集，直到最大的模型最终过度拟合数据。我们可以看到，在 n_h = 50 时，该模型似乎过拟合(100%精度)。
最佳隐藏层大小似乎在 n_h = 4 左右。事实上，这里的一个值似乎与数据吻合得很好，而不会引起明显的过度拟合。

非常感谢您阅读到最后，请评论任何建议/修改。请吧👏如果你喜欢邮报…😉

神经网络架构

原文：https://towardsdatascience.com/neural-network-architectures-156e5bad51ba?source=collection_archive---------0-----------------------

深度神经网络和深度学习是强大和流行的算法。他们的成功很大程度上在于神经网络架构的精心设计。

我想在深度学习的背景下重温过去几年神经网络设计的历史。

关于这里报道的所有网络的更深入的分析和比较，请参见我们的最近的文章(以及更新的帖子)。这篇文章中的一个代表人物是:

Top1 vs. operations, size ∝ parameters. Top-1 one-crop accuracy versus amount of operations required for a single forward pass. See also here

在多种流行的神经网络架构中，报告单次正向传递所需的最高单作物精度与操作量。

LeNet5

这是 1994 年，这是最早的卷积神经网络之一，推动了深度学习领域的发展。自 1988 年以来，经过多次成功的反复，Yann LeCun 的这项开创性工作被命名为 LeNet5 ！

LeNet5 架构是基础，特别是图像特征分布在整个图像上的观点，并且具有可学习参数的卷积是在多个位置用很少的参数提取相似特征的有效方法。当时没有 GPU 来帮助训练，甚至 CPU 也很慢。因此，能够节省参数和计算是一个关键的优势。这与使用每个像素作为大型多层神经网络的单独输入形成对比。LeNet5 解释说，这些不应用于第一层，因为图像是高度空间相关的，使用图像的单个像素作为单独的输入特征不会利用这些相关性。

LeNet5 的特点可以概括为:

卷积神经网络使用 3 层序列:卷积、池化、非线性–>这可能是本文以来图像深度学习的关键特征！
使用卷积提取空间要素
使用地图空间平均值的二次抽样
tanh 或 sigmoids 形式的非线性
多层神经网络(MLP)作为最终分类器
层间连接矩阵稀疏，避免计算量大

总的来说，这个网络是最近许多架构的起源，也是这个领域许多人的真正灵感。

差距

从 1998 年到 2010 年，神经网络处于酝酿阶段。大多数人都没有注意到他们不断增强的力量，而其他许多研究人员却在慢慢进步。由于手机相机和廉价数码相机的兴起，越来越多的数据可用。计算能力在上升，CPU 变得更快，GPU 成为通用计算工具。这两种趋势都推动了神经网络的发展，尽管速度很慢。数据和计算能力使得神经网络处理的任务越来越有趣。然后很明显…

丹·奇雷桑网

2010 年，Dan Claudiu Ciresan 和 Jurgen Schmidhuber 发表了第一批 GPU 神经网络的实现之一。该实现在一个高达 9 层神经网络的英伟达 GTX 280 图形处理器上向前和向后实现。

AlexNet

2012 年，Alex Krizhevsky 发布了 AlexNet ，这是 LeNet 的一个更深入、更广泛的版本，并以较大优势赢得了困难的 ImageNet 竞赛。

AlexNet 将 LeNet 的见解扩展为一个更大的神经网络，可以用来学习更复杂的对象和对象层次。这项工作的贡献是:

使用校正线性单位(ReLU)作为非线性
在训练过程中使用丢弃技术选择性地忽略单个神经元，这是一种避免模型过度拟合的方法
重叠最大池，避免平均池的平均效应
使用 GPU英伟达 GTX 580 减少培训时间

当时，GPU 提供的内核数量比 CPU 多得多，训练时间也快了 10 倍，这反过来又允许使用更大的数据集和更大的图像。

AlexNet 的成功引发了一场小革命。卷积神经网络现在是深度学习的主力，它成为“现在可以解决有用任务的大型神经网络”的新名称。

吃得过多

2013 年 12 月，Yann LeCun 的 NYU 实验室提出了 Overfeat ，这是 AlexNet 的衍生产品。这篇文章还提出了学习包围盒，这后来引发了许多其他相同主题的论文。我相信学习分割物体比学习人工包围盒更好。

VGG

牛津的 VGG 网络率先在每个卷积层中使用更小的 3×3 滤波器，并将它们组合成一个卷积序列。

这似乎与 LeNet 的原理相反，LeNet 使用大卷积来捕捉图像中的相似特征。取代 AlexNet 的 9×9 或 11×11 过滤器，过滤器开始变得更小，太危险地接近 LeNet 想要避免的臭名昭著的 1×1 卷积，至少在网络的第一层。但是 VGG 最大的优点是洞察到顺序的多重 3×3 卷积可以模拟更大感受野的效果，例如 5×5 和 7×7。这些想法也将用于最近的网络架构，如 Inception 和 ResNet。

VGG 网络使用多个 3×3 卷积层来表示复杂的特征。注意，VGG-E: 256×256 和 512×512 3×3 滤波器的块 3、4、5 被按顺序多次使用，以提取更复杂的特征和这些特征的组合。这实际上就像拥有 3 层 512×512 的大型分类器，它们是卷积的！这显然意味着大量的参数和学习能力。但是这些网络的训练是困难的，不得不分成更小的网络，一层一层地增加。所有这一切都是因为缺乏强有力的方法来正则化模型，或者以某种方式限制由大量参数促进的大规模搜索空间。

VGG 在许多层中使用了大的特征尺寸，因此推断在运行时是相当昂贵的。减少特征的数量，就像在初始瓶颈中所做的那样，将会节省一些计算成本。

网络中的网络

网络中的网络 (NiN)有着伟大而简单的洞察力，使用 1x1 卷积为卷积层的功能提供更多组合能力。

NiN 架构在每次卷积后使用空间 MLP 图层，以便在另一个图层之前更好地组合要素。同样，人们可能会认为 1x1 卷积违反了 LeNet 的原始原则，但实际上它们有助于以更好的方式组合卷积功能，而这是通过简单地堆叠更多的卷积层不可能实现的。这不同于使用原始像素作为下一层的输入。这里，1×1 卷积用于在卷积后跨要素地图在空间上组合要素，因此它们有效地使用非常少的参数，在这些要素的所有像素之间共享！

通过将单个卷积特征组合成更复杂的组，MLP 的能力可以大大提高它们的有效性。这个想法将会在最近的架构中使用，比如 ResNet、Inception 和 derivatives。

NiN 还使用了一个平均池层作为最后一个分类器的一部分，这是另一个将变得普遍的实践。这样做是为了在分类之前平均网络对输入图像的多个区域的响应。

谷歌网和盗梦空间

来自谷歌的克里斯蒂安·塞格迪开始了一项旨在减少深度神经网络计算负担的探索，并设计了第一个盗梦空间架构。

到现在，2014 年秋天，深度学习模型在对图像和视频帧的内容进行分类时变得非常有用。大多数怀疑论者已经承认，深度学习和神经网络这次回来了。考虑到这些技术的有用性，像 Google 这样的互联网巨头对在他们的服务器农场上高效和大规模地部署架构非常感兴趣。

Christian 想了很多方法来减少深度神经网络的计算负担，同时获得最先进的性能(例如，在 ImageNet 上)。或者能够保持相同的计算成本，同时提供改进的性能。

他和他的团队想出了盗梦空间模块:

乍一看，它基本上是 1×1、3×3 和 5×5 卷积滤波器的并行组合。但是，inception 模块的伟大之处在于使用 1×1 卷积模块(NiN)来减少昂贵的并行模块之前的功能数量。这就是通常所说的“瓶颈”。这值得单独一节来解释:参见下面的“瓶颈层”一节。

GoogLeNet 使用了一个没有初始模块的词干作为初始层，以及一个类似于 NiN 的平均池加 softmax 分类器。与 AlexNet 和 VGG 的分类器相比，这个分类器的运算量也非常低。这也促成了非常高效的网络设计。

瓶颈层

受 NiN 的启发,《盗梦空间》的瓶颈层减少了每一层的功能和操作数量，因此推理时间可以保持在较低水平。在将数据传递到昂贵的卷积模块之前，特征的数量减少了，比如说，4 倍。这导致了计算成本的大量节省，以及这种架构的成功。

让我们详细检查一下。假设你有 256 个特性进来，256 个出来，假设初始层只执行 3x3 的卷积。也就是说，需要执行 256×256×3×3 的卷积运算(589，000 次乘法累加或 MAC 运算)。这可能超过了我们的计算预算，比如说，在谷歌服务器上 0.5 毫秒内运行这一层。我们没有这样做，而是决定减少必须进行卷积的特征数量，比如减少到 64 或 256/4。在这种情况下，我们首先执行 256 → 64 个 1×1 卷积，然后在所有初始分支上执行 64 个卷积，然后我们再次使用来自 64 → 256 个特征的 1x1 卷积。现在的操作是:

256×64 × 1×1 = 16，000 个
64×64 × 3×3 = 36，000 个
64×256 × 1×1 = 16，000 个

总计约 7 万英镑，而之前我们有近 60 万英镑。几乎减少了 10 倍的操作！

而且虽然我们做的操作少了，但是在这一层并没有失去通用性。事实上，瓶颈层已经被证明可以在 ImageNet 数据集上以最先进的方式执行，并且还将被用在 ResNet 等后来的架构中。

成功的原因是输入特征是相关的，因此可以通过将它们与 1x1 卷积适当组合来消除冗余。然后，在与少量要素卷积后，它们可以再次扩展为对下一层有意义的组合。

盗梦空间 V3(和 V2)

克里斯蒂安和他的团队是非常高效的研究人员。2015 年 2 月批量规范化的 Inception 作为 Inception V2 被引入。批量归一化计算图层输出中所有要素地图的平均值和标准差，并使用这些值对其响应进行归一化。这相当于“白化”数据，从而使所有的神经图具有相同范围内的响应，并且具有零均值。这有助于训练，因为下一层不必学习输入数据中的偏移，并且可以专注于如何最佳地组合要素。

2015 年 12 月，他们发布了新版本的 Inception 模块和相应的架构这篇文章更好地解释了最初的 GoogLeNet 架构，给出了更多关于设计选择的细节。最初的想法有:

通过精心构建深度和宽度平衡的网络，最大化流入网络的信息。每次汇集前，增加特征地图。
当深度增加时，特征的数量或层的宽度也系统地增加
在每一层使用宽度增加来增加下一层之前的要素组合
如果 5×5 和 7×7 滤波器可以用多个 3×3 来分解，则尽可能只使用 3×3 卷积。见图:

因此，新的初始模块变成:

过滤器也可以通过扁平卷积分解成更复杂的模块:

在执行初始计算时，初始模块还可以通过提供池来减少数据的大小。这基本上等同于使用简单的池层并行执行步长卷积:

Inception 仍然使用一个池层加上 softmax 作为最终分类器。

雷斯内特

革命在 2015 年 12 月到来，大约与《盗梦空间 3》同时。 ResNet 有一个简单的想法:将两个连续卷积层的输出馈入，同时将输入旁路到下一层！

这类似于像这个这样的老创意。但在这里它们绕过了两层，被大规模应用。绕过两层后是一个关键的直觉，因为绕过一层不会有太大的改善。通过 2 层可以认为是一个小的分类器，或网络中的网络！

这也是第一次训练超过 100 层甚至 1000 层的网络。

拥有大量层的 ResNet 开始使用类似于 Inception 瓶颈的瓶颈层:

该图层通过首先使用具有较小输出(通常为输入的 1/4)的 1x1 卷积，然后使用 3x3 图层，然后再次使用 1x1 卷积来减少每个图层的要素数量。就像在 Inception 模块的情况下，这允许保持低计算量，同时提供丰富的特性组合。参见“GoogLeNet 和 Inception”之后的“瓶颈层”部分。

ResNet 在输入端使用了一个相当简单的初始层(stem):一个 7x7 的 conv 层，然后是一个 2 层的池。相比之下，在 Inception V3、V4 中，词干更复杂，更不直观。

ResNet 还使用一个池层加上 softmax 作为最终分类器。

关于 ResNet 架构的其他见解每天都在出现:

ResNet 可以被看作是并行和串行模块，只要把 inout 看作是并行到许多模块，而每个模块的输出是串行连接的
ResNet 也可以被认为是多个并行或串行模块的集合体
人们发现，ResNet 通常在深度相对较低(约 20–30 层)的区块上运行，这些区块并行运行，而不是在网络的整个长度上串行流动。
ResNet，当输出反馈到输入时，就像在 RNN，网络可以被看作是大脑皮层的一个更好的生物模型

初始版本 4

克里斯蒂安和他的团队又开始了新版本的《盗梦空间》。

stem 之后的 Inception 模块与 Inception V3 非常相似:

他们还将 Inception 模块与 ResNet 模块结合起来:

在我看来，这一次的解决方案不太优雅，也更复杂，但也充满了不太透明的启发。很难理解这些选择，作者也很难证明它们是正确的。

在这方面，ResNet 获得了一个干净简单、易于理解和修改的网络奖。

挤压网

SqueezeNet 最近已经发布。它是 ResNet 和 Inception 中许多概念的重新组合，表明毕竟更好的架构设计将提供较小的网络大小和参数，而不需要复杂的压缩算法。

ENet

我们的团队着手将最新架构的所有功能整合到一个非常高效、轻量级的网络中，使用非常少的参数和计算来实现最先进的结果。这个网络架构被称为 ENet ，由亚当·帕兹克设计。我们用它来执行像素标记和场景解析。下面是 ENet 的一些视频。这些视频不是训练数据集的一部分。

有关 ENet 的技术报告可在此处获得。ENet 是一个编码器加解码器的网络。编码器是用于分类的常规 CNN 设计，而解码器是用于将类别传播回原始图像大小以进行分割的上采样网络。这种方法只使用了神经网络，没有使用其他算法来执行图像分割。

正如你在这个图中看到的，ENet 在所有的神经网络中，每个参数的精确度都是最高的！

ENet 从一开始就被设计成使用尽可能少的资源。因此，它的尺寸非常小，编码器和解码器网络总共仅占用 0.7 MB，fp16 精度。即使在这样小的尺寸下，ENet 在分割精度上类似于或高于其他纯神经网络解决方案。

模块分析

CNN 模块的系统评估已经提交。这一发现有利于使用:

使用不带 batchnorm 或 ReLU 的 ELU 非线性。

应用学习到的 RGB 色彩空间转换。

使用线性学习率衰减策略。

使用平均池层和最大池层的总和。

使用大约 128 或 256 的小批量。如果这对于你的 GPU 来说太大了，那就按照批量大小成比例地降低学习速率。

使用全连接层作为卷积层，并对最终决策的预测进行平均。

当投资增加训练集规模时，检查是否尚未达到稳定水平。数据的整洁比大小更重要。

如果您不能增加输入图像的尺寸，则减少后续层的步幅，效果大致相同。

如果您的网络具有复杂且高度优化的架构，例如 GoogLeNet，请谨慎修改。

例外

Xception 对 inception 模块和架构进行了改进，采用了一种更简单、更优雅的架构，与 ResNet 和 Inception V4 一样有效。

这里给出了异常模块:

该网络可以是任何人的最爱，因为其架构简单而优雅，如下所示:

该架构有 36 个卷积级，与 ResNet-34 非常相似。但是模型和代码就像 ResNet 一样简单，而且比 Inception V4 更容易理解。

这个网络的 Torch7 实现可用这里一个 Keras/TF 的实现可用这里。

有趣的是，最近的 Xception 架构也受到了我们关于可分离卷积滤波器的工作的启发。

移动网络

新的 M obileNets 架构也将于 2017 年 4 月推出。这种架构使用可分离的卷积来减少参数的数量。除了上面的例外，单独的卷积是相同的。现在，这篇论文声称参数有了很大的减少——在 FaceNet 的情况下大约是 1/2，正如论文中所报道的。以下是完整的模型架构:

MobileNets

不幸的是，我们在实际应用中测试了这个网络，发现它在 Titan Xp GPU 上的一批 1 上非常慢。看一下每张图片推理时间的比较:

resnet18 : 0.002871
alexnet : 0.001003
vgg16 : 0.001698
挤压网:0.002725
移动网络:0.033251

显然这不是一个快速推理的竞争者！它可以减少磁盘上网络的参数和大小，但不可用。

其他著名的架构

FractalNet 使用了一种递归架构，这种架构没有在 ImageNet 上测试过，它是一种衍生或更通用的 ResNet。

更新

关于比较的更新，请见本帖。

今后

我们认为，打造神经网络架构对于深度学习领域的进步至关重要。我们小组强烈建议仔细阅读并理解这篇文章中的所有论文。

但是现在有人可能会问，为什么我们要花这么多时间来精心设计架构，为什么我们不用数据来告诉我们使用什么，以及如何组合模块。这将是美好的，但现在它正在进行中的工作。一些有趣的初步结果是这里。

还要注意，这里我们主要讨论了计算机视觉的架构。类似地，神经网络体系结构在其他领域得到了发展，研究所有其他任务的体系结构的演变也是很有趣的。

如果您对神经网络架构和计算性能的比较感兴趣，请参见我们最近的论文。

感谢

这篇文章的灵感来自与 Abhishek Chaurasia，Adam Paszke，Sangpil Kim，Alfredo Canziani 和其他人在我们普渡大学电子实验室的讨论。

关于作者

我在硬件和软件方面都有将近 20 年的神经网络经验(一个罕见的组合)。在这里看关于我:媒介、网页、学者、 LinkedIn 等等…

神经网络基准

原文：https://towardsdatascience.com/neural-network-benchmarks-82d48425c21b?source=collection_archive---------9-----------------------

我们正在经历神经网络架构的寒武纪大爆发。每个新设计都有一个基准——“它对猫的识别能力如何？”它能玩雅达利游戏吗？它能探测到停车标志吗？研究人员使用可用的基准数据集，将他们的神经网络的性能与其他架构进行比较。然而，这些数据集是有限的。

特别是有标签的数据，很难得到。测试非常深的神经网络需要大量的数据，并且很少有数据集大到足以允许对深度网络进行比较。因此，我们应该在产生的数据上测试新的神经网络。

通过生成数据，而不是管理，我们自动地给它们贴上标签。而且，生成的数据可以存在于准确性的连续统上，这允许我们看到一个网络是否擅长于识别微小的错误。这为我们提供了架构的敏感性和复杂性的度量，这在精选的数据集中是不可用的。有了生成的数据，我们可以更清楚地了解网络的学习情况，以及它在哪里出错。

生成训练和验证数据

作为生成数据的一个例子，考虑轨道力学:我们可以创建一个简单的软件，在 2D 平面上随机放置“行星”，每个都有质量、位置和速度。每次调用该软件时，它会在平面上放置一组“行星”,并在固定的时间内运行它们的轨道模型。这些样本可用于训练和验证，而无需耗尽数据集！该网络能够从任意大小的数据集进行采样——如果你想要更多的数据，只需再次调用物理软件。在训练期间，你可以很容易地生成十亿个样本轨道！

当软件模拟一个没有干扰的轨道时，我们可以自动将该轨道标记为“正确的”。为了生成“不正确”的轨道，我们引入了一些扰动*——在模拟的某个时刻，我们随机推动了一些“行星”，使它们不符合物理规律。神经网络的任务是区分“正确的”轨道力学和“不正确的”轨道。这是允许我们比较不同神经架构的性能的基准。*

因为我们正在生成我们的数据，我们可以调整发生多大的扰动。如果一个单独的“行星”被轻微推动，我们将其归类为“轻微不正确”。同时，当许多“行星”被大量推动时，我们可以将它们的轨道归类为“非常不正确”。以这种方式，我们形成了一个连续体:“完全正确”→“极度错误”。这是一个至关重要的能力，是猫照和手写数字所缺乏的。

比较网络的敏感性和复杂性

假设你想对一个新的神经网络进行基准测试，使用轨道力学软件，你给每个网络输入数十亿个轨道，并测量它们各自的精度。经过同样的训练后，两个网络都能识别出轨道何时“严重错误”——它们都能发现大的扰动。然而，你的新网络更善于识别“稍微不正确”的轨道！这表明你的新网络具有更高的灵敏度。

而且，你可以在增加“行星”数量的轨道上训练这两个网络。当只有 3 或 4 个“行星”时，两个网络都表现良好。然而，当“行星”的数量增长到 7 或 8 时，你的新网络仍然准确，而另一个网络开始失效。这表明你的新网络处理更大的复杂性。

这允许我们明确地测量网络深度的值。如果一个 4 层卷积神经网络很好地处理 3 个“行星”，但是当给定 4 个“行星”时变得有故障，那么该 4 层网络具有“3 行星复杂性”。为了诊断 4 颗或更多“行星”的轨道，我们需要增加网络的深度。

深度人脉的价值

通过连续增加神经网络的深度，并测试它可以处理多少个“行星”，我们得到了作为深度函数的网络复杂性的度量。我们可以回答结构性的问题:“如果我把网络的深度增加一倍，我能把行星的数量增加一倍吗？“也许，更深层次的网络处理复杂性的速度越来越快——如果一个 4 层网络处理‘3 星球复杂性’，一个 8 层网络可能在‘7 星球复杂性’上成功。如果是这样的话，这是疯狂建立深层网络的最强有力的论据。

然而，如果深层网络变慢(例如，8 层网络仅在“5 个星球的复杂性”下运行)，这就是让许多浅层网络串联运行的理由。这是目前一个未解决的问题*。猫照永远也回答不了。沿着正确性和复杂性的连续体生成数据集为我们提供了一条通往答案的道路。*

解释了神经网络嵌入

原文：https://towardsdatascience.com/neural-network-embeddings-explained-4d028e6f0526?source=collection_archive---------0-----------------------

(Source)

深度学习如何将战争与和平表示为一个向量

近年来，神经网络的应用从图像分割到自然语言处理再到时间序列预测都有了很大的发展。深度学习的一个显著成功的应用是嵌入，这是一种用于将离散变量表示为连续向量的方法。这种技术已经在实际应用中找到了用于机器翻译的单词嵌入和用于分类变量的实体嵌入。

在本文中，我将解释什么是神经网络嵌入，为什么我们要使用它们，以及它们是如何学习的。我们将在我正在解决的一个实际问题的背景下讨论这些概念:将维基百科上的所有书籍表示为向量，以创建一个图书推荐系统。

Neural Network Embedding of all books on Wikipedia. (From Jupyter Notebook on GitHub).

嵌入

嵌入是离散分类变量到连续数字向量的映射。 在神经网络的背景下，嵌入是低维、 学习到的离散变量的连续向量表示。神经网络嵌入是有用的，因为它们可以减少分类变量的维度并且有意义地表示变换空间中的类别。

神经网络嵌入有 3 个主要目的:

在嵌入空间中寻找最近的邻居。这些可以用来根据用户兴趣或聚类类别进行推荐。
作为监督任务的机器学习模型的输入。
用于可视化概念和类别之间的关系。

这意味着就图书项目而言，使用神经网络嵌入，我们可以获得维基百科上所有的 37，000 篇图书文章，并用向量中的 50 个数字来表示每一篇文章。此外，因为嵌入是习得的，在我们学习问题的上下文中更相似的书籍在嵌入空间中彼此更接近。

神经网络嵌入克服了表示分类变量的常用方法的两个局限性:一键编码。

一个热编码的局限性

一键编码分类变量的操作实际上是一个简单的嵌入，其中每个类别被映射到一个不同的向量。该过程采用离散的实体，并将每个观察值映射到 0 的向量和表示特定类别的单个 1。

独热编码技术有两个主要缺点:

对于高基数变量——具有许多独特类别的变量——转换后的向量的维数变得难以管理。
这种映射是完全不知情的:“相似的”类别在嵌入空间中不会彼此放置得更近。

第一个问题很好理解:对于每一个额外的类别——被称为一个实体——我们必须向独热编码向量添加另一个数字。如果我们在维基百科上有 37，000 本书，那么表示这些书需要每本书 37，000 维的向量，这使得在这种表示上训练任何机器学习模型都不可行。

第二个问题同样具有局限性:独热编码不会将相似的实体在向量空间中放置得更近。如果我们使用余弦距离来度量向量之间的相似性，那么在一次热编码之后，对于实体之间的每次比较，相似性都是 0。

这意味着像《T2》《战争与和平》《T3》《T4》《安娜·卡列尼娜》《T5》(都是列夫·托尔斯泰的经典著作)这样的实体彼此之间的距离并不比《战争与和平》《T7》和《银河系漫游指南》的距离更近，如果我们使用一键编码的话。

**# One Hot Encoding Categoricals****books = ["War and Peace", "Anna Karenina", 
          "The Hitchhiker's Guide to the Galaxy"]****books_encoded = [[1, 0, 0],
                 [0, 1, 0],
                 [0, 0, 1]]****Similarity (dot product) between First and Second = 0
Similarity (dot product) between Second and Third = 0
Similarity (dot product) between First and Third = 0**

考虑到这两个问题，表示分类变量的理想解决方案需要的数字比唯一类别的数字少，并且将相似的类别彼此放置得更靠近。

**# Idealized Representation of Embedding****books = ["War and Peace", "Anna Karenina", 
          "The Hitchhiker's Guide to the Galaxy"]****books_encoded_ideal = [[0.53,  0.85],
                       [0.60,  0.80],
                       [-0.78, -0.62]]****Similarity (dot product) between First and Second = 0.99
Similarity (dot product) between Second and Third = -0.94
Similarity (dot product) between First and Third = -0.97**

为了构建分类实体的更好表示，我们可以使用嵌入神经网络和监督任务学习嵌入。

学习嵌入

独热编码的主要问题是转换不依赖于任何监督。我们可以通过在监督任务中使用神经网络来学习嵌入，从而极大地改进嵌入。嵌入形成了网络的参数——权重，其被调整以最小化任务上的损失。得到的嵌入向量是类别的表示，其中相似的类别(相对于任务)彼此更接近。

例如，如果我们有一个在电影评论集中使用的 50，000 个单词的词汇表，我们可以使用训练来预测评论情感的嵌入神经网络来学习每个单词的 100 维嵌入。(具体应用见这款 Google Colab 笔记本)。词汇表中与积极评价相关联的词，如“精彩”或“优秀”，将在嵌入空间中更接近地出现，因为网络已经知道这些都与积极评价相关联。

Movie Sentiment Word Embeddings (source)

在上面给出的书的例子中，我们的监督任务可以是“识别一本书是否是列夫·托尔斯泰写的”，由此产生的嵌入将把托尔斯泰写的书彼此放得更近。弄清楚如何创建受监督的任务来产生相关的表示是进行嵌入的最困难的部分。

履行

在维基百科图书项目(完整笔记本此处)中，监督学习任务被设定为预测给定的维基百科页面链接是否出现在一本书的文章中。我们提供成对的(书名，链接)训练示例，其中混合了正面-正确-和负面-错误-对。这种设置基于这样的假设，即链接到相似维基百科页面的书籍彼此相似。因此，最终的嵌入应该将相似的书籍在向量空间中更紧密地放置在一起。

我使用的网络有两个平行的嵌入层，用于将图书和 wikilink 映射为单独的 50 维向量，还有一个点积层，用于将嵌入合并为单个数字以进行预测。嵌入是网络的参数或权重，在训练期间被调整以最小化监督任务的损失。

在 Keras 代码中，如下所示(如果您没有完全理解代码，请不要担心，直接跳到图片):

虽然在监督机器学习任务中，目标通常是训练模型对新数据进行预测，但在这种嵌入模型中，预测可能只是达到目的的一种手段。我们想要的是嵌入权重，将书籍和链接表示为连续向量。

嵌入本身并不有趣:它们只是数字的向量:

Example Embeddings from Book Recommendation Embedding Model

然而，嵌入可以用于前面列出的 3 个目的，对于这个项目，我们主要感兴趣的是基于最近邻居推荐书籍。为了计算相似性，我们取一个查询书，并找到它的向量和所有其他书的向量之间的点积。(如果我们的嵌入是归一化的，这个点积就是向量之间的余弦距离，范围从-1，最不相似，到+1，最相似。我们也可以使用欧几里德距离来度量相似性)。

这是我构建的图书嵌入模型的输出:

**Books closest to War and Peace.****Book: War and Peace              Similarity: 1.0
Book: Anna Karenina              Similarity: 0.79
Book: The Master and Margarita   Similarity: 0.77
Book: Doctor Zhivago (novel)     Similarity: 0.76
Book: Dead Souls                 Similarity: 0.75**

(向量与其自身的余弦相似度必须为 1.0)。经过一些维度的缩减(见下文)，我们可以做出如下图:

Embedding Books with Closest Neighbors

我们可以清楚地看到学习嵌入的价值！我们现在对维基百科上的每一本书都有 50 个数字的表示，相似的书彼此更接近。

嵌入可视化

关于嵌入最酷的部分之一是，它们可以用来可视化概念，如小说或非小说彼此之间的关系。这需要进一步的降维技术来使维数达到 2 或 3。最流行的约简技术本身就是一种嵌入方法:t 分布随机近邻嵌入(TSNE)。

我们可以获取维基百科上所有书籍的原始 37，000 个维度，使用神经网络嵌入将它们映射到 50 个维度，然后使用 TSNE 将它们映射到 2 个维度。结果如下:

Embedding of all 37,000 books on Wikipedia

(TSNE 是一种流形学习技术，这意味着它试图将高维数据映射到低维流形，从而创建一种嵌入，试图保持数据中的局部结构。它几乎专门用于可视化，因为输出是随机的，并且不支持转换新数据。一个很有前途的替代方案是均匀流形逼近和投影，UMAP，它更快并且支持将新数据转换到嵌入空间。

这本身并不是很有用，但是一旦我们开始根据不同的书籍特点给它上色，它就会变得很有洞察力。

Embeddings Colored by Genre

我们可以清楚地看到属于同一流派的书籍分组。这并不完美，但仍然令人印象深刻的是，我们可以只用两个数字来表示维基百科上的所有书籍，这仍然可以捕捉到不同流派之间的差异。

书中的例子(整篇文章即将发表)展示了神经网络嵌入的价值:我们有一个分类对象的向量表示，它是低维的，并且将相似的实体在嵌入的空间中彼此放置得更近。

额外收获:交互式可视化

静态图的问题是，我们不能真正探索数据和调查变量之间的分组或关系。为了解决这个问题，TensorFlow 开发了投影仪，这是一个在线应用程序，让我们可以可视化嵌入并与之交互。我将很快发布一篇关于如何使用这个工具的文章，但是现在，这里是结果:

Interactive Exploration of Book Embeddings using projector

结论

神经网络嵌入是作为连续向量的离散数据的学习低维表示。这些嵌入克服了传统编码方法的局限性，可用于诸如寻找最近邻居、输入另一个模型和可视化等目的。

虽然许多深度学习概念是用学术术语谈论的，但神经网络嵌入既直观又相对容易实现。我坚信任何人都可以学习深度学习并使用 Keras 等库构建深度学习解决方案。嵌入是处理离散变量的有效工具，并呈现深度学习的有用应用。

资源

谷歌制作的嵌入式教程
嵌入张量流指南
使用嵌入式技术的图书推荐系统
Keras 中的单词嵌入教程

一如既往，我欢迎反馈和建设性的批评。你可以通过推特 @koehrsen_will 或者我的个人网站 willk.online 找到我。

软件工程师的神经网络 2:小批量训练和验证

原文：https://towardsdatascience.com/neural-network-for-software-engineers-2-mini-batch-training-and-validation-46ee0a1269a0?source=collection_archive---------13-----------------------

在我们之前的帖子软件工程师的神经网络 1 中，我们了解并实现了一些关于使用多层感知器的基本特性，并在 Python/Numpy 中实现了这些特性。

现在让我们看看如何将它应用到一个简单的现实世界问题中。让我们来看一下手写数字图像的分类。

首先，让我们浏览一下重要的，让我们导入数据，这些数据已经分成一个训练集和一个测试数据集，前者可以用来优化我们的网络，后者可以用来验证我们的性能。

接下来，我们将使用与上一篇博文几乎相同的代码，但这次我们将在训练集上进行训练，在测试集上进行验证，并绘制两条性能曲线。

另请注意，这次我们将执行小批量更新，而不是完整培训批量更新。这样，我们可以通过只查看数据集的一小部分来更快地执行更新。随机与小批量与全批量梯度下降是另一个主题，如果需要，我可以写另一篇博文来描述。

请注意，训练和验证的准确性仍然很糟糕，没有接近 100%。在这个系统真正工作之前，我们仍然有一些关键的改进要实现，但我们至少演示了如何将一个普通的神经网络应用到现实世界的问题中，以及通过 NumPy 矩阵数学理解的所有部分。

在这篇文章之后，我们将:

思考我们的数据的意义，并构建我们的模型以一种深思熟虑的方式来表示它。(链接到卷积后)
以一种有意义的方式思考我们的损失函数，建立我们的损失函数，给我们一个有意义的梯度。(房价亏损帖链接)
像上面那样思考我们想要什么，但是使用 Tensorflow 这样的神经网络 API 来实现。哇，太简单了！(链接 Tensorflow 房价贴)

软件工程师神经网络导论 1——香草 MLP

原文：https://towardsdatascience.com/neural-network-introduction-for-software-engineers-1611d382c6aa?source=collection_archive---------7-----------------------

这第一篇博文将帮助你用 Python/Numpy 设计一个神经网络。它将展示普通多层感知器(MLPs)的衰落，提出一些简单的增强，并展示它们有多重要。最后，我们将展示这在一个组织良好的软件工程包中会是什么样子。

对于非技术前言，请阅读 ML 前言以了解回归。

为了理解数学，可选地将最初的 numpy 版本与包含可视化的https://medium . com/coin monks/the-mathematics-of-neural-network-60a 112 dd3 e 05进行比较。

软件工程师神经网络导论

首先，我们将建立一个简单的神经网络(NN 或多层感知器/MLP):

在数学上，我们将定义一个具有一个隐藏层的神经网络如下:

x: input matrix
w1: 1st weight matrix for multiplication
w2: 2nd weight matrix for multiplication
Hidden = matrix_multiplication(x, w1)
Hidden_rectified = Clip(Hidden, minimum_value = 0)
output = matrix_multiplication(Hidden_rectified, w2

这样，我们将输出计算为输入的函数。我们回顾微积分和线性代数，通过梯度下降最小化损失函数来优化(训练)我们的 MLP 以匹配数据集。

哦不！我们的损失激增。一个基本的神经网络对它的学习速率非常敏感，因为它的梯度会爆炸。一旦梯度变大，它们可以不断地来回摆动它们相应的权重，并爆炸到无穷大。

让我们通过将应用的渐变剪切到[-1，1]来解决这个问题。

让我们也将学习率衰减到 0，以允许网络首先以大的学习率接近合理的解决方案，然后通过小的调整确定特定的解决方案。

梯度削波也是通过将梯度削波到具有最大向量范数来完成的，并且学习率衰减有时被完全忽略，以利于其他微调策略，如 l2 正则化或批量增加。

太好了！我们的损失函数现在向零递减。

你听说过动量优化器或者亚当优化器吗？看看上面曲线中波动的损失，你是否注意到它上下摆动，而通常向下移动？

动量是在一个合理的恒定方向上保持速度的概念。当我们接收到一个梯度来调整我们的参数时，我们更新我们正在移动的速度，然后继续沿着我们认为在我们的参数空间中有效的方向行进。准确地说，

Value = Value-gradient

变成了:

velocity = velocity * momentum + gradient * (1-momentum)
Value = Value-velocity

现在，通过动量和函数化我们的损失函数作为一个抽象层，为备选损失函数做准备，我们的代码变成:

太好了！我们的损失变小得更快，接近一个更小的值。让我们再添加一个机器学习工具来帮助模型更可靠地学习，称为“内斯特罗夫动量”

内斯特罗夫的动量工程受到以下启发。在给定的有动力的一步，你大概知道你将采取的下一步。让我们看看我们期望移动的地方，计算那里的梯度，用这个梯度来修正我们的动量向量。然后用新的动量向量，我们像往常一样前进。

Theoretical_next_state = Value - Velocity
gradient = gradient at Theoretical_next_state
Velocity = Velocity * momentum + gradient * (1-momentum)
Value = Value-Velocity

同时，我们注意到 ReLU 非线性的一个问题，即 ReLU 曲线的“关闭”部分的导数为零。让我们用更流行的泄漏 ReLU 来代替我们的 ReLU，固定这个零导数，平坦区域有一个缓坡。

ReLU(x) = max(x, 0)
becomes:
lReLU(x) = max(x, .1*x)

请耐心等待这一段，因为演示数学的代码有点疯狂。在下一部分中，我们将组织它，以便观众中的软件工程师感到舒适。

太好了！内斯特罗夫的势头奏效了。但是看看这段代码！太恐怖了。我们硬编码了整个系统来实现一个神经网络

恰好一个隐藏层
泄漏的 relu 非线性
整批优化

如果我们想要改变其中的任何一个，我们就必须改变多个系统来硬编码我们想要尝试的其他系统。我暂时不做解释，但是让我们来看看这个系统到底有多干净和可重用。我们暂时把它作为一个文件，这样我们就可以很容易地在博客中展示它。

万岁！我们有干净的软件来定义、训练和评估一个模型。从机器学习和软件工程的角度来看，我们的实现仍然存在一些巨大的问题，但它展示了一般的概念。

在现实世界中，我们会(未来的连续博客文章):

解决一个真实世界的问题，然后在单独的验证数据集上训练和评估我们的问题。
思考我们的数据的意义，并构建我们的模型以一种深思熟虑的方式来表示它。(链接到卷积后)
以一种有意义的方式思考我们的损失函数，建立我们的损失函数，给我们一个有意义的梯度。(房价亏损帖链接)
像上面那样思考我们想要什么，但是使用 Tensorflow 这样的神经网络 API 来实现。哇，太简单了！(链接 Tensorflow 房价贴)

神经网络优化算法

原文：https://towardsdatascience.com/neural-network-optimization-algorithms-1a44c282f61d?source=collection_archive---------3-----------------------

基于张量流的比较研究

用于训练神经网络的常用优化算法有哪些？他们如何比较？

本文试图以一个卷积神经网络(CNN)为例，通过 TensorFlow 在 MNIST 数据集上进行训练来回答这些问题。

随机梯度下降

SGD 通过获取大小为( m )的数据子集或小批量数据，在梯度( g )的负方向上更新模型参数(θ):

神经网络用 f(x(i)表示；θ)其中 x(i) 是训练数据，而 y(i) 是训练标签，损失的梯度 L 是相对于模型参数θ计算的。学习率( eps_k )决定了算法沿梯度的步长大小(最小化时为负方向，最大化时为正方向)。

学习率是迭代 k 的函数，是一个最重要的超参数。学习率太高(如> 0.1)会导致参数更新错过最佳值，学习率太低(如< 1e-5)会导致不必要的长训练时间。一个好的策略是以 1e-3 的学习速率开始，并使用一个学习速率计划，该计划将学习速率降低为迭代的函数(例如，每 4 个时期将学习速率减半的步长计划器):

*def step_decay(epoch):
    lr_init = 0.001
    drop = 0.5
    epochs_drop = 4.0
    lr_new = lr_init * \
             math.pow(drop, math.floor((1+epoch)/epochs_drop))
    return lr_new*

一般来说，我们希望学习率( eps_k )满足罗宾斯-门罗条件:

第一个条件确保算法将能够找到局部最优解，而不管起始点是什么，第二个条件控制振荡。

气势

动量累积过去梯度的指数衰减移动平均值，并继续向其方向移动:

因此，步长取决于梯度序列的大小和对齐程度，动量参数α的常见值为 0.5 和 0.9。

内斯特罗夫势头强劲

内斯特罗夫动量的灵感来自内斯特罗夫的加速梯度法:

内斯特罗夫动量和标准动量的区别在于梯度的计算，而内斯特罗夫动量是在施加当前速度后计算梯度，因此内斯特罗夫动量为梯度增加了一个修正因子。

阿达格拉德

AdaGrad 是一种用于设置学习速率的自适应方法[3]。考虑下图中的两种情况。

在缓慢变化的物镜(左)的情况下，梯度通常(在大多数点)具有小的幅度。因此，我们需要一个大的学习率来快速达到最优。对于快速变化的物镜(右图)，梯度通常会非常大。使用较大的学习速率会导致非常大的步长，来回摆动但达不到最佳值。

这两种情况的发生是因为学习率的设置与梯度无关。AdaGrad 通过累加目前所见梯度的平方范数并将学习率除以该和的平方根来解决这个问题:

结果，接收高梯度的参数将降低其有效学习率，而接收小梯度的参数将提高其有效学习率。净效应是在参数空间的更平缓倾斜方向上的更大进展，以及在存在大梯度的情况下更谨慎的更新。

RMSProp

RMSProp 通过将梯度累积改变为指数加权移动平均来修改 AdaGrad，即它丢弃了遥远过去的历史[4]:

注意，即使梯度由于从训练开始的梯度积累而保持恒定，AdaGrad 也意味着学习速率降低。通过引入指数加权移动平均线，与遥远的过去相比，我们更重视最近的过去。结果表明，RMSProp 是一种有效实用的深度神经网络优化算法。

亚当

Adam 源自“自适应矩”，它可以被视为 RMSProp 和 momentum 组合的变体，更新看起来像 RMSProp，只是使用了平滑版本的梯度而不是原始随机梯度，完整的 Adam 更新还包括偏差校正机制[5]:

推荐值为 beta_1 = 0.9，beta_2 = 0.999，eps = 1e-8。

实验

使用 TensorFlow 在 MNIST 数据集上训练简单的 CNN 架构，具有 1e-3 学习速率和交叉熵损失，使用四种不同的优化器:SGD、内斯特罗夫动量、RMSProp 和 Adam。下图显示了训练损失值与迭代次数的关系:

从图中我们可以看到，亚当和内斯特罗夫动量优化器产生最低的训练损失！

代码

下面的 ipython 笔记本中有全部代码。

结论

我们比较了用于训练神经网络的不同优化器，并获得了它们如何工作的直觉。我们发现，当在 TensorFlow 中对 MNIST 数据训练简单 CNN 时，具有内斯特罗夫动量和 Adam 的 SGD 产生最佳结果。

参考文献

[1]伊恩·古德费勒等人。艾尔。，“深度学习”，麻省理工出版社，2016

[2]安德烈·卡帕西，http://cs231n.github.io/neural-networks-3/

[3]杜奇，j .，哈赞，e .和辛格，y .“在线学习和随机优化的自适应次梯度方法”，JMLR，2011 年。

[4]t . tie leman 和 and Hinton，“讲座 6.5 — RMSProp，COURSERA:用于机器学习的神经网络”，技术报告，2012 年。

[5]迪耶德里克·金玛和吉米·巴，“亚当:一种随机优化方法”，2015

神经网络扮演 Flappy Bird

原文：https://towardsdatascience.com/neural-network-plays-flappy-bird-e585b1e49d97?source=collection_archive---------0-----------------------

目前，我是一名大学 IT 专业的学生。这学期，我上了一门非常有趣的课，我选择了自己的主题来学习，并设计了自己的项目。所以我决定学习和研究一些非常有趣和独特的东西。当我在探索各种主题时，我发现了一个关于神经网络的视频教程，我对学习这个主题非常感兴趣。

看完教程视频后，我想到了一个实现一个学习如何玩 Flappy Bird 游戏的神经网络程序的想法。最后，这是我的结果。

当程序第一次运行时，它什么也不做，因为它对游戏一无所知。然而，几个小时的训练，它学会了如何玩游戏。

在这篇文章中，我想给出一个关于神经网络的基本信息以及我是如何实现我的程序的。

什么是神经网络？

首先，我想说说什么是神经网络。在编程中，人工神经网络是受生物神经网络的结构和功能方面启发的用于机器学习的计算模型/算法。

Neural Network

每个神经网络都有一个输入层、一个输出层和一个或多个隐藏层。每个圆圈代表一个神经元，一个神经元与下一层的每个神经元都有联系。

每个连接都有权重值，每个神经元都有偏差值。例如，下图显示了神经网络中发生的情况。

当神经网络计算输出时，它会对权重和偏差进行大量计算。你可以很容易地预料到，如果我改变其中一个权重或偏差值，最终的输出也会改变。换句话说，训练神经网络意味着找到并调整权重和偏差值，以给出我们想要的最佳输出。

新立得

Synaptic.js 是一个非常棒的用于 node.js 和浏览器的 JavaScript 神经网络库。如果您安装了 node.js，您可以使用以下命令安装 synaptic.js:

npm install synaptic --save

现在，我想提供一个使用 Synaptic.js 库解决问题的简单例子。

如果你看一下左边的表格，它有两个输入和一个输出。如果第一个输入大于第二个输入，则输出为 1。否则输出为 0。

前五个记录将是我们的测试数据，我们将看到最后两个记录的输出是什么。

下面的代码展示了我如何使用 synaptic.js 来解决这个问题。

**var** synaptic = require('synaptic');**var** myNetwork = **new** synaptic.Architect.Perceptron(2, 3, 1);
**var** learningRate = .2;
//training
**for** (**var** i = 0; i < 20000; i++)
{
    //test data 1
    myNetwork.activate([2,1]);
    myNetwork.propagate(learningRate, [1]);

    //test data 2
    myNetwork.activate([1,5]);
    myNetwork.propagate(learningRate, [0]);

    //test data 3
    myNetwork.activate([4,2]);
    myNetwork.propagate(learningRate, [1]);

    //test data 4
    myNetwork.activate([5,2]);
    myNetwork.propagate(learningRate, [1]);

    //test data 5
    myNetwork.activate([3,5]);
    myNetwork.propagate(learningRate, [0]);

}
console.log(myNetwork.activate([2,5])); //[ 0.0000728000640238746 ]
console.log(myNetwork.activate([3,1])); //[ 0.9999465030073619 ]

代码分解

**var** myNetwork = **new** synaptic.Architect.Perceptron(2, 3, 1);

上面的代码创建了一个具有 2 个输入神经元、3 个隐藏神经元和 1 个输出神经元的神经网络。

myNetwork.activate([2,1]);

activate()方法从给定的输入返回输出(在上面的代码中，2 和 1)。输出值在 0 到 1 个浮点值之间。

myNetwork.propagate(learningRate, [1]);

在调用 activate 函数之后，我们调用 propagate()函数，用学习率和目标输出值来训练网络。这是通过反向传播完成的。

带 Flappy Bird 的神经网络

当我实现 flappy bird 程序时，我得到了 5 个输入和 1 个输出。

这些输入是:

鸟的位置
速度
下一个管道之间的距离
上部管道高度
下部管道高度

每次渲染游戏时，神经网络都会获得输入并激活它。如果输出大于 0.55，鸟会跳起来。

但是，我不能使用 propagate()方法，因为没有测试数据及其目标值。在这种情况下，我们可以使用遗传算法来训练我们的神经网络。

假设我一代有 8 只鸟，每只鸟有 6 个神经元。(在我的实际实现中，一代中有 12 只鸟，每只鸟有 18 个神经元)。

在一代(12 场)之后，我挑选最好的 4 只鸟并应用交叉和变异。重复同样的过程，直到我们得到好的结果。

对于交叉函数，偏置值将被交叉运算。

Learn.crossOverDataKey(netA.neurons, netB.neurons, 'bias');

剪切神经元的随机位置，并将其交叉。

Learn.crossOverDataKey = **function** (a, b, key) {
    **var** cutLocation = Math.round(a.length * Math.random());

    **var** tmp;
    **for** (**var** k = cutLocation; k < a.length; k++) {
        // Swap
        tmp = a[k][key];
        a[k][key] = b[k][key];
        b[k][key] = tmp;
    }
}

对于变异函数，偏差和权重值都会发生变异。

Learn.mutateDataKeys(net.neurons, 'bias', Learn.mutationProb);

Learn.mutateDataKeys(net.connections, 'weight', Learn.mutationProb);

连接和神经元被随机选择并变异为随机值。在我的实现中，我有 20%的突变率。

Learn.mutateDataKeys = **function** (a, key, mutationRate){
    **for** (**var** k = 0; k < a.length; k++) {
        // Should mutate?
        **if** (Math.random() > mutationRate) {
            **continue**;
        }

        a[k][key] += a[k][key] * (Math.random() - 0.5) * 3 + (Math.random() - 0.5);
    }
}

你可以在这里看到我的完整代码。

此外，以下是我使用的资源的链接:

synaptic . js:【https://github.com/cazala/synaptic】
flappy bird 网页版:https://github.com/nebez/floppybird
我引用的代码/算法:https://github.com/ivanseidel/IAMDinosaur

神经网络助手

原文：https://towardsdatascience.com/neural-network-sidekick-d79b5877f08d?source=collection_archive---------6-----------------------

这篇文章的想法是训练一个助手神经网络，专门针对我们的主网络所处理的数据。类似蝙蝠侠和罗宾的网络之间的内置层级将有助于该模型更好地执行。

尽管面临计算复杂性的挑战，集成学习仍然是一个非常令人兴奋的概念。有两类主要的集成学习方法，bagging 和 boosting。使用 bagging，来自训练数据的随机样本用于构建单独的模型，然后从这些模型中进行多数投票以确定输出。boosting 算法更有趣。Boosting 构建一个模型，然后评估该模型在哪个数据子集上出错最多，然后主要使用该数据来构建后续模型。这可能在计算上是昂贵的，并且在如何确定求解算法上是混乱的。

在最近的一个项目中，我使用许多卷积层和数以千计的数据图像构建了一个怪物图像分类器。我已经尝试了书中的每一个技巧来提高这个模型的准确性。然而，这个模型有时仍然会出错。一个模型执行了大约 90–95%可以被认为是做得很好，不幸的是，一些任务需要比这更高的精度。

Boosting 似乎是支持这种整体网络的一个很好的解决方案。类似于蝙蝠侠和罗宾，我的主要卷积网络是蝙蝠侠，而由主要错误分类的实例构建的卷积网络是罗宾。罗宾不需要成为团队的代言人，而是应该专注于学习蝙蝠侠的杂项倾向。通过成为蝙蝠侠的专家，他很可能会自己解决问题，罗宾能够为团队做出贡献。

用神经网络实现 boosting 是很棘手的，因为没有一个我们可以调用的库函数，比如 Boosted_CNNs。

这是我如何实现 boosting 来创建蝙蝠侠和罗宾类型的分类模型的粗略工作流程:

Partition Train/Test split
Train CNN with Train dataEvaluate CNN on Train data outside of training loop
Select misclassified instances and 25% of the dataTrain CNN on this new subsetWith future predictions weight the output of CNN1 80% & CNN2 20%Evaluate model

我发现要做到这一点，你需要大量的数据，然而，我确实看到了我的具体问题的准确性略有提高。感谢阅读！

CShorten

Connor Shorten 是佛罗里达大西洋大学计算机科学专业的学生。对计算机视觉、深度学习和软件工程感兴趣。

神经网络:专家与注意力的混合体

原文：https://towardsdatascience.com/neural-networks-a-mixture-of-experts-with-attention-30e196657065?source=collection_archive---------2-----------------------

一个混合专家 (MoE)是一种特殊类型的神经网络:神经元连接成许多小簇，每个簇只在特殊情况下活跃。网络的较低层提取特征，并召集专家来评估这些特征——对于每种情况，只召集一些专家。混合的专家有明显的优势:他们可以用更大的专业化来应对特定的环境，允许网络展示更多样的行为；专家可以接收混合刺激，整合来自不同传感器的数据。而当网络在运行时，只有少数专家在活动——即使是一个庞大的网络也只需要少量的处理能力。随着神经网络变得越来越复杂，集成了许多数据流，并提供了更多样的响应，专家模型的混合将占主导地位。因此，它有助于理解专家的混合体是如何进化的。

基于特征的注意力

专家的混合已经被用于翻译任务。每个小的专家群学习处理一个单独的词类或特殊的语法规则。然而，专家翻译的混合体目前没有使用注意力模型。

注意力只是一个过滤器，一次只允许部分输入进入网络。通过不断转移注意力，网络可以处理任何规模的输入。一个图像识别网络可以接收许多不同大小的图像，并努力一幅一幅地解析这些图像。一个翻译网络可以在句子之间跳跃，形成被许多行分隔的单词之间的关系。以这种方式移动输入的专家组合将能够提取单词之间更丰富的关系，并且能够更好地准确翻译。当某些特征被识别时，每个专家被调用；这些特性可能出现在输入的不同区域，需要对输入有广泛的理解。专家会知道哪里需要注意。

注意力记忆

专家的混合也是更复杂记忆形式的理想模型。解析翻译通常需要网络关注文本中的几个不同区域。多处出现的语句必须组合成一个连贯的整体，这样翻译才有意义。一群专家必须将注意力集中在一个领域，同时记住来自另一个领域的信息。这是通过将专家集群连接到网络的过去状态来实现的，类似于 LSTM 的连接。

LSTMs wire 每个神经元到都有自己的过去、而不考虑其邻居的过去状态。然而，专家的混合体会被连接到触发专家的特征检测器的过去状态。这是一种“更高级”的记忆。一个特性可能出现，而不会触发一个专家集群。然而，当与相关输入结合时，该特征的记忆可能会在稍后触发其专家*！专家将对当前输入和过去特征的组合做出响应。这种行为目前在 LSTM 或其他循环网络中是不可能的。而且，这一切都很重要。*

评审流程

如果一个专家的混合体有一个注意力系统，那么它可以在文本中跳来跳去，寻找信息，直到找到触发专家的东西。这类似于我们复习所读内容的方式；如果我们感到困惑，我们会跳回到不同的地方，直到我们找到澄清文本的信息。一只 LSTM 犬无法四处跳跃，直到它变得清晰。如果注意力系统与特征层次的记忆相连，一群专家将审查它的输入*，直到它确定无疑*。它四处寻找支持结论的信息，而不是脱口而出答案。

这个审查过程可以被捕获和可视化。当我们看到什么信息触发了一个专家，我们知道网络已经基于那个信息做出了决定。而且，因为每个专家处理一个非常具体的子任务，我们知道每个专家正在解决什么样的问题。这是‘窥视内部’神经网络黑盒的最佳方式。“我们得到了这个答案，因为这个专家在看到这个信息时开火了……”这是我们可能接近的告诉我们它在想什么的网络。

成长

专家的组合也是解决复杂多变的问题的理想选择。当必须学习新信息时，大多数网络需要完全重新训练，并且它们丢失了它们在之前学习的课程。混合的专家可以保留其旧知识，并简单地插入新的专家群，接受新信息的培训。当使用反向传播训练这种“扩充”的专家混合物时，所有旧的神经连接都被“冻结”——只有新的集群被允许学习。这些“菜鸟”很快成为新任务的专家，而不会在网络的其他部分失去原有的专业知识。

总之，这些修改提供了一个专家的混合体，他们有能力适应、消化任何规模的输入，并回忆起影响结果的复杂特征。我期望这些品质对于“下一波”神经网络任务来说是至关重要的:连贯反应。目前，被训练生成文本的神经网络仅从文本中学习*。被训练来识别图像的网络仅从图像中学习。这种“与世隔绝”的训练将会停止。生成真实文本的神经网络需要对真实世界有足够的了解，以使其陈述在逻辑上和物理上连贯，而不仅仅是语法上正确。一个图像识别网络将需要尝试在 3D 中实例化它的图像，看看它是否有意义。谷歌已经开始在这一领域开展工作，用“一个模型来学习所有这些”，它从文本、图像和声音的稀疏配对中学习。他们还有很长的路要走。而且，他们还没有将注意力、记忆力和成长能力的专家结合起来使用。我们很快就会需要它。*

神经网络:ReLU 的替代方案

原文：https://towardsdatascience.com/neural-networks-an-alternative-to-relu-2e75ddaef95c?source=collection_archive---------11-----------------------

ReLU activation, two neurons

上面是两个神经元(紫色和橙色)的激活(粉色)图，使用了一个常用的激活函数:整流线性单元，或 ReLU。当每个神经元的总输入增加时，ReLU 也会增加其激活——前提是输入超过某个阈值。这导致峰值出现在输入空间的一角，如上图右上角所示。添加更多的 ReLU 神经元将增加立方体的维度，然而模式仍然存在:神经元的激活总是在一个远处的角落达到峰值，沿着相邻的边有倾斜的侧翼。因为峰值只能出现在一个单个拐角，所以这些神经网络的表达能力是有限的。我提供一个替代方案: 反射线性单元 。(RefLU？)

反射线性单元

整流线性单元仍有几个优点。它们易于计算，非常适合专门的硬件架构，如谷歌的 TPU。它们是非线性的，形成了清晰的行为边界，这是单一直线所不能做到的。而且，它们创造了一个持久的梯度(至少在它们的右侧)，这将它们与激活功能区分开来，激活功能逐渐变细——例如，s 形函数和逻辑函数。随着这些激活逐渐减少，它们的斜率几乎是水平的，因此梯度下降几乎不会试图修改神经元，学习进展缓慢。ReLUs 的右半部分具有恒定的正斜率，因此它在所有这些点接收到来自梯度下降的相同强度的信号*。*

Rectified Linear Units, with various synapse weights causing different tilts

然而，经过整流的线性单元可能会遭受“死亡神经元”的困扰:当它们接收到强烈的负信号时，它们的倾斜度会下降到零，之后没有任何东西能够刺激神经元。没有新的梯度信号通过它们，因为它们是平的，所以神经元的损失永远不会被纠正。经常被引用的斯坦福课程笔记解释说“你的网络中有多达 40%可能是‘死的’。”

Reflected Linear Units, with various peak positions and tilts

反射的线性单位分享了 ReLUs 的好处:它们易于计算，是非线性的，并且不会逐渐变细。此外，他们不受“死亡”的影响。无论任何一半的斜率是正还是负，RefLU 仍然起作用。只有双方奇迹般地更新到恰好零斜率，那一个神经元才会死亡。RefLUs 提供了其他好处，我可以在一些细节之后解释这些好处…

倾斜线条

RefLU 由在中间某处相交的两条线段组成。你可能会把这些线条想象成一束激光，从一面看不见的镜子上反射回来。天真的是，他们都在倾斜，在他们的接触点形成一个高峰。此 RefLU 的变量比 ReLU 多；虽然 ReLU 仅指定其右半部分的斜率，但 RefLU 必须指定左右半部分的斜率，以及它们相交的高度和距离*。*

这四个变量都接收梯度下降信号，以小步长更新，试图匹配数据要求的激活的曲线。虽然陡峭的拱形可能不完全符合数据所需的形状，但是 RefLU 激活的总和可以在输入空间内的任何位置形成组合峰值。那是远远优于 ReLUs 的，ReLUs 只能在单个角形成一个峰值。而且，虽然大多数表面可以由分散在各处的峰的集合来近似，允许多个 RefLUs 构建他们需要的景观，但是 ReLUs 的角峰只能创建更陡的角。反射线性单位可以采用数据所需的形状。

稀疏激活

通过将反射的线性单元初始化为倾斜的峰值，网络在学习阶段的行为被修改。除了 RefLU 之外，只有 sinc 和高斯分布包括其激活函数的右下侧。在操作过程中，这意味着变得过于兴奋的神经元实际上会关闭！这导致了一种完全不同的激活模式:当许多神经元在一个簇中放电时，它们会在下一层的一些神经元中重叠太多，导致这些神经元中的一些变得安静，而不是所有的都变成不和谐的一致。

通过让一些兴奋簇中的神经元安静下来，网络的活动朝着稀疏的方向调整。没有癫痫发作的“是”。每个图像或声音都是用最少的活跃神经元进行分类的，只对最相关的信息进行编码。这在网络中留下了更多的“空间”来学习多种任务和丰富的分类，稀疏性将相似分类的输入推得更近。通过这种方式，用 RefLU 激活功能构建的网络将表现得更像人脑，具有自己稀疏而有意义的活动。

否定之肯定

此外，RefLU 不是一个简化的 sinc 函数，sinc 和高斯函数在其两侧降至零，而 RefLU 实际上降至负值区域。这使得 RefLU 成为显著不同的激活功能。通常，对于一个神经元来说，要从积极的兴奋性信号转换为消极的抑制性信号，其突触权重必须从积极的变为消极的。在中间，神经元的权重为零，“杀死”它。并且，当权重接近零时，整个激活功能被压扁。

相反，RefLUs 可以为某些输入电平产生强负输出，而为其他电平产生强正输出。功能没有被压扁。它可以起到双重作用，同时兴奋和抑制更多的神经元*，分享 arctan 激活功能的这种强度。虽然 arctan 仅在输入电平为低时产生负信号，但 RefLUs 是唯一能够为高和低输入变为负的*。**

RefLUs 不需要在两端变为负；梯度下降可以从向下的斜坡向向上的斜坡平滑地倾斜任一侧，在这种情况下，神经元作为现有激活函数的近似来操作。

我希望这一分析能够激发研究人员将 RefLU 与它的哥哥 ReLU 进行比较，看看这些潜在的好处在哪里提高了性能。特别是，网络可能受益最大，它必须学习和联系许多任务，解释神经元活动，并避免死亡的神经元。在这些概念的基础上，可能还有其他更高级的激活功能；重要的一点是，我们还没有挖掘出神经网络新花样的源泉。我们应该继续假设和实验，因为智力是我们面临的最大问题。我希望有些人会受到启发继续寻找！

神经网络:类比

原文：https://towardsdatascience.com/neural-networks-analogies-7ebeb3ac5d5e?source=collection_archive---------7-----------------------

当我们的大脑形成类比时，它们正在做一些特殊的事情——一些现有神经网络中缺少的事情。我们的大脑采用了为一个任务设计的过程，并且在一个新的任务中使用相同的过程。他们转移他们所学的东西。当我们形成一个概括，两个任务之间的类比时，这被称为'迁移学习'。

我将概述展示迁移学习的人工神经网络的潜在途径:

首先，稀疏分布式表示

Numenta 的分级临时记忆，以及其他技术，依赖于稀疏分布式表示。这方面的一个例子是一个很长的 1 和 0 的字符串，其中几乎所有的值都是 0——1 有一个稀疏分布*。如果每个数字代表不同的东西，比如“尖耳朵”、“尾巴”、“胡须”，那么任何输入都可以被编码为这些稀疏分布之一。记录“尖耳朵”、“尾巴”和“胡须”存在的图像将与输出“猫”紧密相关。稀疏分布表示可以以这种方式映射到输出，隐含地为它选择“猫”的提供了一个理由——它看到了胡须、尾巴和尖尖的耳朵。*

稀疏分布式表示允许一些巧妙的技巧。因为它们只有几个 1 和许多 0，两个表示可以通过加法组合*，当一个新的表示与这个组合进行比较时，通常只有当新的输入与旧的输入之一匹配时，它才会匹配。例如，如果向网络呈现一幅有猫和自行车的图像，则对应于“胡须”、“尾巴”和“尖耳朵”的位的值为 1，以及对应于“两个轮子”、“座位”和“车把”的位的值为 1。该表示的所有其他位将为零。然后，一个带有猫和棒球的新图像呈现在网络上，并附有问题:“这两个图像之间的相同点是什么？”虽然棒球触发了“球体”、“白色”和“缝合”的位，但猫仍然点亮了“尖耳朵”、“尾巴”和“胡须”的位，因此通过比较可以立即确定猫为两幅图像所共有。*

这种识别两种表征之间共性的能力是形成类比的关键。为了看到这一点，我们需要看看专家的混合的动态的稀疏分布表示。

混合专家

听起来像是专家的混合体。神经网络接收输入，并将它们传递给各种各样的“专家”——经过训练处理特定类型输入的神经元集群。在一组专家对输入进行处理后，他们的输出将被解析给新的一组专家。也就是说，使用的专家取决于输出是什么。每个结果对应不同的专家组。

所以，每个专家的表现都不一样。而且，当遇到一种新的任务时，一批新的专家会接受这项任务的培训。我提出，当新任务被训练后，它的结果可以与旧任务在不同情况下的结果进行比较。如果结果与匹配，那么新任务的专家可以由老专家替换。这个过程就是类比的形成。

想象一下——一个神经网络被训练来观看视频并预测棒球的运动。神经网络学会将“球体”、“白色”、“缝线”识别为“棒球”，并将棒球的数据发送给一组处理“下落物体”的专家神经元。网络将球视为下落物体，期望它以抛物线运动下落。它的专家，在许多棒球下落的例子之后，能准确地预测棒球的运动。

然后，同一个网络呈现出一个篮球的图像。就像以前一样，“球体”在稀疏分布表示中亮起，但它是“橙色”和“纹理化的”，而不是“白色”和“缝合的”。这是一个新的环境，首先，它被授予一个新的专家神经元集群。过了一会儿，这些新的神经元学会了预测篮球的运动——专家们独立地重新发现了抛物线运动。

接下来，抛物线运动必须与棒球的抛物线运动相比较。如果神经网络识别出两个专家集群的行为方式相同，那么“篮球”实例可以被馈送给棒球使用的同一“下落物体”专家。把“篮球”和“棒球”放在同一个地方，这是两个之间的一个类比——它们都是“落体”。

假设出现了第三个图像，一个茶杯。它不是一个“球体”,在它的较低层没有任何其他的特性。然而，如果它下落，它会受到与棒球和篮球相同的抛物线运动的影响——因此，它将被映射为“下落物体”的相同专家群集的类比。最终，大多数事情将被映射到同一个“落体”专家——这将是一个近乎普遍的原则，达到我们在自己心中看到的概括水平。

如何比较专家

当专家们观察棒球时，他们学会了下落物体的抛物线运动。看篮球，一群新的专家学习同样的抛物线运动。我们怎么知道他们学到了相同的原理？我们可以向他们中的每一个输入另一个，看看他们的预测是否匹配。让棒球数据反馈给受过篮球训练的专家，反之亦然。

我们不需要测试棒球和篮球的每一个实例。要测试的最重要的是 边缘案例 。这些被定义为两类专家最有可能产生分歧的地方。如果这些边缘情况匹配，那么我们有信心这两个专家集群已经学习了相同的一般原理。在这些边缘情况下的测试等同于科学方法，在极端情况下进行实验以验证一个概括。

然而，有许多可用的专家集群。我们如何知道从哪里开始？这就是我们需要每个专家的行为的稀疏分布表示的地方。这是新的，可能会在一个幼稚的网络和一个推广良好的网络之间产生差异。

编码专家行为

每个专家都需要自己的稀疏分布式表示。该字符串的位通常为“0”，在对应于该专家属性的位置有几个“1”。在棒球上训练的“下落物体”专家将在对应于“抛物线”的位置包含值为“1”的位，因为它的抛物线运动，以及“向下移动”和“小物体”。相比之下，在破碎的冰山上训练的一群专家神经元会识别相同的抛物线下落，照亮“抛物线”并“向下移动”，然而与下落的棒球相比，它们巨大的尺寸会减缓感知的抛物线运动。它将包含用于“大对象”而不是“小对象”的位。这是每个专家的编码，根据其行为的性质。

当两个专家描述相似的行为时，他们有相似的稀疏分布表示。许多“1”在它们的位串上重叠。棒球和篮球的专家几乎完全重叠，这表明他们很可能是相似的。

潜在的相似性是这样发现的:一个新专家的稀疏分布表示与现有专家的表示进行比较，如果两者具有匹配的表示，则假设它们是相似的。从那里，交换他们的输入来检查边缘情况，如前所述。如果边缘案例匹配，假设类比有效，新专家被更成熟的专家取代。

注意，通过使用稀疏分布式表示，只有当某个属性存在时，1 和 0 的字符串才进行编码。它不声明输入的哪个分量触发属性的存在。下落的棒球和破碎的冰山都可以包含“天际线”作为其输入的属性，并且稀疏分布表示不会说明“天际线”或“冰山”是“向下移动”的来源。该信息必须通过消融来发现。

如果下落棒球的视频在其稀疏分布表示中包含比特“天际线”，那么当“天际线”被移除时，可以测试专家的结果。天际线的消除会改变“抛物线”、“向下移动”或“小物体”吗？如果不是，那么“天际线”被认为与专家表示的比特无关。“Skyline”对于处理“外部”的不同专家来说可能很重要，但是稀疏分布表示允许我们将其与“向下移动”位分开。就像在两个图像中识别一只猫，独立于旁边的棒球或自行车。通过这种方式，输入的每个组成部分都被映射到它所修改的专家表示的一组位上——我们发现每个位都依赖于哪些输入。

每当专家表示的一个比特不依赖于输入表示的一个比特时，比如“向下移动”独立于“skyline ”,当解析使用哪个专家时，网络学会忽略该独立比特。无论是否出现“天际线”,棒球下落的视频都会触发“抛物线运动”。棒球是网络关注的地方，将数据传递给“抛物线运动”专家。

因此，我们可以说视频中“抛物线运动”的源是棒球。这就是我们如何克服专家的稀疏分布表示没有明确描述输入的哪一部分触发其表示中的位的事实。这个消融过程相当于测量输入相对于专家表示的比特的梯度。

类比的价值

通常，在专家混合的情况下，每个专家只对训练集的一小部分是活跃的。它没有什么可以借鉴的例子。然而，如果专家是由稀疏的分布式表示来描述的，我们可以比较他们，看看假设的类比潜伏在哪里。如果他们的表现匹配，我们测试他们之间的边缘情况，以验证假设的类比，这将那些专家结合成一个。一旦专家有了这样的类比，更大部分的训练数据就会流过它。“落体”专家不再仅仅处理棒球下落的视频，而是概括处理茶杯、篮球、冰山、猫下落的视频。

所有这些不同事件的知识相互补充，大大提高了专家的准确性。专家可以像我们一样从更少的例子中学习。并且，它使用假设和实验不断地发现类似的行为。在强人工智能之前，我只看到一些其他的障碍，使用这种方法。

神经网络和反向传播以简单的方式解释

原文：https://towardsdatascience.com/neural-networks-and-back-propagation-explained-in-a-simple-way-c6ee791499fa?source=collection_archive---------9-----------------------

任何复杂的系统都可以用一种简单的方式抽象出来，或者至少可以分解成基本的抽象组件。复杂是由几个简单的层次累积而成的。这篇文章的目的，是解释神经网络如何以最简单的抽象方式工作。我们将尝试将 NN 中的机器学习机制简化为其基本的抽象组件。与其他解释神经网络的帖子不同，我们将尝试使用尽可能少的数学方程和编程代码，并只关注抽象的概念。

在最高和最简单的抽象表示中，监督神经网络可以表示为具有如下两种学习和预测方法的黑盒:

Neural network as a black box

学习过程接受输入和期望输出，并相应地更新其内部状态，以便计算出的输出尽可能接近期望输出。预测过程接受输入，并根据其过去的“训练经验”使用内部状态生成最可能的输出。这就是为什么机器学习有时被称为模型拟合。

为了实现这一点，我们将把学习过程分解为几个组成部分:

一个简单的数字例子

从神经网络和监督学习开始的最简单的例子是简单地从一个输入和一个输出以及它们之间的线性关系开始。监督神经网络的目标是尝试在所有可能的线性函数中搜索最适合数据的函数。以下面的数据集为例:

+--------+-----------------+
| Input  |  Desired output |
+--------+-----------------+
|     0  |               0 |
|     1  |               2 |
|     2  |               4 |
|     3  |               6 |
|     4  |               8 |
+--------+-----------------+

对于这个例子来说，输出= 2 x 输入似乎非常明显，但是对于大多数真实数据集来说，情况并非如此(其中输入和输出之间的关系是高度非线性的)。

步骤 1-模型初始化

学习的第一步，是从某个地方开始:最初的假设。就像遗传算法和进化论一样，神经网络可以从任何地方开始。因此，模型的随机初始化是常见的做法。背后的理性是，无论我们从哪里开始，如果我们足够坚持，并通过一个迭代学习过程，我们可以达到伪理想模型。

为了打个比方，举一个一生中从未踢过足球的人为例。他第一次试着投篮时，他可以随意投篮。同样，对于我们的数值案例研究，让我们考虑下面的随机初始化:(模型 1): y=3.x 。这里的数字T33是随机生成的。另一种随机初始化可以是:(模型 2): y=5.x ，或者**(模型 3): y=0，5.x** 。
我们稍后将探索，通过学习过程，所有这些模型如何能够收敛到理想解 (y=2.x) (我们正在努力寻找)。

在本例中，我们将探索通用形式 y=W.x 的哪个模型最适合当前数据集。其中 W 被称为网络的权重，并且可以被随机初始化。这些类型的模型被简单地称为前馈线性层。

步骤 2-向前传播

在随机初始化模型之后，自然要做的一步是检查它的性能。
我们从现有的输入开始，通过网络层传递它们，并向前计算模型的实际输出。

+--------+------------------------------------+
| Input  |  Actual output of model 1 (y= 3.x) |
+--------+------------------------------------+
|     0  |                                  0 |
|     1  |                                  3 |
|     2  |                                  6 |
|     3  |                                  9 |
|     4  |                                 12 |
+--------+------------------------------------+

这一步被称为前向传播，因为计算流程从输入- >通过神经网络- >以自然的前向方向进行。

第 3 步-损失函数

在这个阶段，一方面，我们有随机初始化的神经网络的实际输出。
另一方面，我们有我们希望网络学习的期望输出。让我们把它们都放在同一个表中。

+--------+-----------------+-----------------+
| Input  |  Actual output  |  Desired output |
+--------+-----------------+-----------------+
|     0  |              0  |               0 |
|     1  |              3  |               2 |
|     2  |              6  |               4 |
|     3  |              9  |               6 |
|     4  |              12 |               8 |
+--------+-----------------+-----------------+

如果我们将此与我们的足球运动员第一次射门进行比较，实际输出将是球的最终位置，期望输出将是球进入球门。开始时，我们的玩家只是随意射击。假设球大部分时间都在球门的右侧。他可以从中学到的是，下次训练时，他需要更多地向左侧投篮。

为了能够概括任何问题，我们定义了我们所说的:损失函数。基本上，它是一个性能指标，衡量神经网络如何达到其目标，产生尽可能接近期望值的输出。

最直观的损失函数简单来说就是损失=(期望输出—实际输出)。然而，当网络下冲时，该损失函数返回正值(预测<期望输出)，当网络过冲时，该损失函数返回负值(预测>期望输出)。如果我们希望损失函数反映性能上的绝对误差，不管它是过冲还是欠冲，我们可以将其定义为:
损失=绝对值(期望-实际)。

如果我们回到足球运动员的例子，如果我们的新手把球射向球门右侧 10 米或左侧 10 米，我们认为，在这两种情况下，无论方向如何(右或左)，他都没有击中目标 10 米。
在这种情况下我们将向表中添加一个新列- > 绝对误差。

然而，有几种情况会导致相同的总误差:例如，许多小误差或几个大误差会精确地累加到相同的总误差。因为我们希望预测在任何情况下都有效，所以最好是分布许多小误差，而不是几个大误差。
为了鼓励神经网络收敛到这种情况，我们可以将损失函数定义为绝对误差的平方和(这是神经网络中最著名的损失函数)。这样，小错误比大错误要少得多！(2 的平方是 4，但 10 的平方是 100！因此，10 的错误比 2 的错误多罚 25 倍——不仅仅是 5 倍！)

我们的表格如下:

+--------+----------+-----------+------------------+---------------+
| Input  |  actual  |  Desired  |  Absolute Error  |  Square Error |
+--------+----------+-----------+------------------+---------------+
| 0      |       0  |        0  |               0  |             0 |
| 1      |       3  |        2  |               1  |             1 |
| 2      |       6  |        4  |               2  |             4 |
| 3      |       9  |        6  |               3  |             9 |
| 4      |      12  |        8  |               4  |            16 |
| Total: |        - |         - |               10 |            30 |
+--------+----------+-----------+------------------+---------------+

请注意，如果我们只考虑第一个输入 0，我们可以说网络正确预测了结果！然而，在我们的足球运动员类比中，这只是初学者的运气，他也能设法从第一次射门就得分。我们关心的是最小化整个数据集的总误差(误差平方和的总和！).

总的来说，损失函数是一个误差度量，它给出了如果我们用由我们训练的神经网络模型生成的实际输出来代替真正的期望输出，我们损失多少精度的指标。所以才叫亏！

简单地说，机器学习的目标变成最小化损失函数(尽可能接近 0)。
我们现在可以将我们的机器学习问题转化为一个优化过程，目的是最小化这个损失函数。

第四步-差异化

显然，我们可以使用任何优化技术来修改神经网络的内部权重，以最小化我们之前定义的总损失函数。这些技术可以包括遗传算法或贪婪搜索或甚至简单的强力搜索:
在我们简单的数字示例中，仅使用一个权重参数来优化 W ，我们可以搜索从-1000.0 到+1000.0 的步长 0.001，其中 W 在数据集上具有最小的误差平方和。

如果模型只有很少的参数，并且我们不太关心精度，这可能行得通。然而，如果我们在一个 600x400 输入的数组上训练神经网络(像在图像处理中)，我们可以很容易地达到有数百万个权重的模型进行优化，暴力甚至是不可想象的，因为这纯粹是浪费计算资源！

幸运的是，数学中有一个强大的概念可以指导我们如何优化称为微分的权重。基本上它处理的是损失函数的导数。在数学中，函数在某一点的导数给出了该函数在该点改变其值的速率或速度。

为了看到导数的效果，我们可以问自己以下问题:如果我们用某个小值 δW 改变神经网络的内部权重，总误差会变化多少？为了简单起见，将考虑δW=0.0001。实际上它应该小得多！。

当重量 W 变化很小时，让我们重新计算误差平方和:

+--------+----------+-------+-----------+------------+---------+
| Input  |  Output  |  W=3  |  rmse(3)  |  W=3.0001  |   rmse  |
+--------+----------+-------+-----------+------------+---------+
| 0      |       0  |    0  |        0  |         0  |       0 |
| 1      |       2  |    3  |        1  |    3.0001  |  1.0002 |
| 2      |       4  |    6  |        4  |    6.0002  |  4.0008 |
| 3      |       6  |    9  |        9  |    9.0003  |  9.0018 |
| 4      |       8  |   12  |       16  |   12.0004  | 16.0032 |
| Total: |        - |     - |       30  |         -  |  30.006 |
+--------+----------+-------+-----------+------------+---------+

现在我们可以从这个表中看到，如果我们将 W 从 3 增加到 3.0001，误差的平方和将从 30 增加到 30.006。因为我们知道最适合这个模型的函数是 y=2.x ，将权重从 3 增加到 3.0001 显然会产生更多一点的误差(因为我们离直观的正确权重 2 更远了)。3.0001 > 3 > 2 因此误差更高)
但是我们真正关心的是误差相对于重量变化的变化率**。
基本上，这里的比率是重量每增加 0.0001，总误差增加 0.006->即比率为 0.006/0.0001 = 60x！
它在两个方向上都起作用，所以基本上如果我们将权重减少 0.0001，我们也应该能够将总误差减少 0.006！
这里是证明，如果你再次运行计算，在 W=2.9999 你会得到误差 29.994 。我们设法减少了总误差！**

我们可以通过直接计算损失函数的导数来猜测这个比率。使用数学导数的好处是计算起来更快更精确(浮点精度问题更少)。

这是我们损失函数的样子:

如果 w=2，我们的损失为 0，因为神经网络的实际输出将完全符合训练集。
如果 w <2, we have a positive loss function, but the derivative is negative, meaning that an increase of weight will decrease the loss function.
At w=2, the loss is 0 and the derivative is 0, we reached a perfect model, nothing is needed.
If w> 2，损失再次为正，但导数也为正，这意味着重量的任何增加都会使损失增加更多！！

如果我们随机初始化网络，我们会在这条曲线上放置任意一个随机点(假设 w=3 )。学习过程实际上是这样说的:

-让我们检查导数。
——如果是正数，意味着如果我们增加权重，误差会增加，那么我们应该减少权重。
-如果是负数，意味着如果我们增加权重，误差会减小，那么我们应该增加权重。如果是 0，我们什么都不做，我们到达我们的稳定点。

一个简单的问题是，我们正在设计一个类似重力的过程。无论我们在这个误差函数曲线上的什么地方随机初始化球，都有一种力场驱使球回到地面 0 的最低能级。

步骤 5-反向传播

在这个例子中，我们在神经网络的输入和输出之间只使用了一层。在许多情况下，为了达到神经网络功能的更多变化，需要更多的层。当然，我们总是可以创建一个复杂的函数来表示网络各层的组成。例如，如果第 1 层执行:3.x 以生成隐藏输出 z，而第 2 层执行:z 以生成最终输出，则组成的网络将执行(3.x) = 9.x 然而，在大多数情况下，组合函数是非常困难的。另外，对于每个组合，必须计算该组合的专用导数(这根本不可扩展，并且非常容易出错)。

为了解决这个问题，幸运的是，导数是可分解的，因此可以反向传播。
我们有误差的起点，即损失函数，我们知道如何对它求导，如果我们知道如何从合成中对每个函数求导，我们就可以将误差从终点传播回起点。让我们考虑一下简单的线性例子:我们将输入乘以 3 倍得到一个隐藏层，然后我们将隐藏层(中间层)乘以 2 倍得到输出。

输入-> 3.x → 2.x →输出。

输入上的 0.001δ变化将在第一层后转换为 0.003δ变化，然后转换为输出上的 0.006δ变化。
如果我们将两种功能合二为一，情况会是怎样:

输入-> 6.x →输出。

类似地，输出端的误差 0.006 可以反向传播到中间隐藏级的误差 0.003，然后到输入端的误差 0.001。
如果我们创建一个可微分函数或层的库，其中对于每个函数，我们知道如何向前传播(通过直接应用函数)和如何向后传播(通过知道函数的导数)，我们可以组成任何复杂的神经网络。我们只需要在正向传递期间保存一个函数调用及其参数的堆栈，以便知道使用这些函数的导数反向传递错误的方法。这可以通过函数调用来实现。这种技术被称为自动微分，只要求每个函数都有其导数的实现。在以后的博客文章中，我们将解释如何通过在矩阵上实现基本的数学运算来加速自动微分。

现在，任何层都可以将其结果转发给许多其他层，在这种情况下，为了进行反向传播，我们对来自所有目标层的增量求和。这样我们的计算栈就可以变成一个复杂的计算图。

该图显示了错误的反向传播过程，遵循以下模式:
输入- >前向调用- >损失函数- >导数- >错误的反向传播。在每一个阶段，我们得到这个阶段的权重的增量。

Diagram of Forward and Backward paths

Cool animation for the forward and backward paths

第 6 步-体重更新

如前所述，导数就是误差相对于重量变化的变化率。在前面给出的数字示例中，这个速率是 60x。这意味着 1 个单位的重量变化导致 60 个单位的误差变化。
由于我们知道误差目前为 30 个单位，通过外推比率，为了将误差减少到 0，我们需要将权重减少 0.5 个单位。
然而，对于现实生活中的问题，我们不应该以如此大的幅度更新权重。由于存在许多非线性，任何大的权重变化都会导致混乱的行为。我们不应该忘记，在我们计算导数的时候，导数只是局部的。

因此，权重更新的一般规则是 delta 规则:

新权重=旧权重-导数率*学习率

学习率作为一个常数(通常非常小)被引入，以便迫使权重非常平滑和缓慢地更新(以避免大步和混乱的行为)。

为了验证这个等式:

如果导数率为正，这意味着权重的增加将增加误差，因此新的权重应该更小。
如果导数率为负，这意味着增加权重会降低误差，因此我们需要增加权重。
如果导数为 0，说明我们处于稳定的最小值。因此，不需要更新权重->我们达到了稳定状态。

现在有几种权重更新方法。这些方法通常被称为优化器。德尔塔法则是最简单和直观的，但是它也有一些缺点。这篇出色的博文展示了更新权重的不同方法。

在这里给出的数值例子中，我们只有 5 个输入/输出训练集。实际上，我们可能有数百万个条目。之前，我们讨论了在整个数据集上最小化误差成本函数(损失函数)。这被称为批量学习，对于大数据来说可能非常慢。相反，我们可以做的是在每一次批量训练中更新权重，假设数据集被随机打乱。这被称为小批量梯度下降。如果 N=1 ，我们称这种情况为完全在线学习或随机梯度下降，因为我们在观察到每个输入输出后更新权重！
任何优化器都可以使用这三种模式(全在线/小批量/全批量)。

步骤 7-迭代直到收敛

因为我们一次用一个小的增量步长来更新权重，所以需要多次迭代来学习。这非常类似于遗传算法，在每一代之后，我们应用一个小的突变率，适者生存。
在神经网络中，每次迭代后，梯度下降力朝着越来越小的全局损失函数更新权重。
相似之处在于，delta 规则充当变异算子，损失函数充当适应度函数来最小化。
区别在于，在遗传算法中，变异是盲目的。有些突变是不好的，有些是好的，但是好的有更高的几率存活下来。然而，神经网络中的权重更新更智能，因为它们由误差上的递减梯度力来引导。

需要多少次迭代才能收敛？

这取决于我们应用的学习率有多强。高学习率意味着更快的学习，但是具有更高的不稳定性。
这也取决于网络的元参数(有多少层，非线性函数有多复杂)。变量越多，收敛时间越长，但能达到的精度越高。
这取决于优化方法的使用，一些权重更新规则被证明比其他规则更快。

这取决于网络的随机初始化。也许运气好的话，你会用W=1.99初始化网络，而你离最优解只有一步之遥。
这取决于训练集的质量。如果输入和输出彼此之间没有相关性，神经网络就不会变魔术，也无法学习随机相关性。

总体情况

总结一下，神经网络的学习过程是这样的:

Neural networks step-by-step

在我们的 GreyCat 中，一个全功能神经网络的不同构建模块在这里实现。

如果您还有任何问题，请不吝赐教或联系我:【assaad.moawad@datathings.com

如果你有任何想法，我会很乐意回复你，改进这篇文章，或者与你合作。

如果喜欢阅读，请关注我们: 脸书，推特，Linkedin

原载于 2018 年 2 月 1 日 medium.com。

神经网络和 3D 程序内容生成的未来

原文：https://towardsdatascience.com/neural-networks-and-the-future-of-3d-procedural-content-generation-a2132487d44a?source=collection_archive---------2-----------------------

Light field landscape generated with the help of style transfer

作为全球制作机构 MediaMonks 的一名创意技术专家，人们总是问我关于人工智能、人工智能、神经网络等方面的问题。它们是什么？他们能做什么？我们如何使用它们？

这篇文章是我将写的探索人工智能、创造力和 3D 内容相遇的空间系列的第一篇。

在我看来，人工智能将是人类有史以来创造的最伟大的创造性工具。目前人工智能的愿景包括数百万失业工人，甚至是一场天启。但是，如果我们的未来涉及将我们的创造过程与人工智能交织在一起，而不是被它取代，那会怎样？

为了开始展望未来，我从一个简单的问题开始:我如何使用神经网络来帮助程序化地创建 3D 景观？例如，想象一下，你站在一个虚拟空间里，说“计算机，让这个空间看起来像吉卜力工作室的风景。”

Landscape from Howl’s Moving Castle

我们如何着手做这样的事情？由于我对机器学习相对较新，我的第一直觉是使用风格转移。

风格转移使用深度卷积神经网络的训练过滤器来优化两个输入图像之间的风格和内容损失，这两个输入图像是内容图像(您的自拍)和风格图像(梵高的画)。

我知道这听起来很专业，所以让我们这么说吧。深度卷积神经网络最近在图像分类方面非常成功。你给它一张照片，比如说一张狗的照片，神经网络就能分辨出这是一只狗。

机器理解图像内容的能力非常强大，因为这意味着它可以理解构成图像的所有细节。它知道狗有下垂的耳朵和尖尖的脸，而猫有尖尖的耳朵和扁平的脸。简单来说，风格转移网络所做的就是获取两幅图像之间的细节，并将它们组合起来。

那么，我们如何将它用于 3D 内容生成呢？3D 程序内容生成中的一个常见问题是地形生成。许多游戏将各种形式的噪波结合起来，以灰度高度图的形式创建山脉、丘陵和平原。大概是这样的:

Height map generated by noise.

然后这些高度图被用来移动平面中的顶点，从而创建山丘、山谷和山脉。这些在 3D 渲染时看起来相当不错，但它们比不上真实的东西。

Height map taken from actual elevation data of the earth.

即使我们可以用简单的旧数学方法生成好看而复杂的地形，但仍然很难模拟所有创造真实地形的过程，如板块构造和侵蚀。

但这正是神经网络的用武之地。有了风格转移的力量，就不用了。我们只需要创建我们想要的大致形状，然后神经网络会添加所有看起来真实的细节。

所以回到 Ghibli 用例，我必须找到真实世界的海拔数据，看起来像图像中的地形。对我来说，它看起来像在阿尔卑斯山的某个地方。通过谷歌图片搜索“阿尔卑斯山”,我看到了这张图片:

原来是 Val Gardena，意大利白云石山脉的一个山谷。知道了这些，我去了一个网站，在那里你可以下载地球的海拔数据。我搜索了 Val Gardena，下载了这张身高图:

也许将来你可以自动化这整个过程，但是现在手动在网上搜索就可以了。

现在是开始建造一切的时候了。使用 Unity，我编写了噪声着色器，它允许我实时调整噪声生成。经过大量实验后，我发现当生成的噪声与期望的输出有一些相似之处时，会出现最佳结果:

Procedural noise on the left, real terrain data on the left.

终于到了使用风格转移的时候了。经过大量的谷歌和 Youtube 搜索，我决定使用 Siraj Raval 的 Youtube 频道的视频中的实现。如果你想学机器学习，我怎么推荐他的频道都不为过！他杀了它！

下面是样式传递输出的样子:

Style transfer output on the left, real terrain on the right. Both are planes whose vertices are being displaced by the height map texture.

很酷吧？可能有成百上千的事情可以优化它，但对我来说已经足够好了。现在是时候将一个虚拟相机放到生成的地形中，并使用原始的 Ghibli 图像作为样式图像，相机渲染作为内容图像。就像噪声一样，我认为如果内容图像与样式图像有相似之处会更好。因此，我在 Blender 中导入了高度图，以便做一些非常简单的纹理绘制。

The height map in blender. Full height map terrain on left, and zoomed in height map terrain on right.

我选择了一个类似吉卜力图像的相机位置和角度:

A simple Blender render.

之后我画了一些非常简单的纹理，给它一个天空的颜色，并为花添加了一个简单的粒子系统。

An obviously very quick and dirty render.

这就是酷的地方。是时候通过风格转换运行简单的 Blender render 了，看看结果如何。在花了很多时间调整超级参数后，我得到了这个:

The final output of the whole process.

这是与输入图像的最终对比:

显然远不及吉卜力工作室的原声大师，但对于一台无脑机器来说也不错。

但是从这里去哪里呢？理想情况下，你会希望实时完成整个过程，但即使我的虚拟现实电脑上有 GPU 支持的神经网络，风格转换过程也需要大约 4 分钟。显然，这对于实时 3D 图形来说还远远不够快。你可以尝试使用快速风格转换，它可以在不到一秒的时间内输出图像，但我不喜欢它在我的图像中产生的伪像。那么，我们如何利用这张静止图像，制作出 3D 的实时渲染的东西呢？

答案是光场！

光场早在 1996 年就被演示过了！但随着虚拟现实的兴起，它们越来越受欢迎，并被像 OTOY 这样的公司推广。光场只是一个花哨的术语，指的是由一系列相机拍摄的一系列图像。它们看起来像这样:

该阵列捕获给定体积内的每条光线，从而能够合成新的摄像机角度。看原视频这里。这些对于实时图形非常有用，因为你可以预先渲染一切。这样你可以获得实时图形的自由，但具有预渲染场景的图像质量。

现在是时候创建我自己的风格传递光场和光场渲染器了。我基本上在 Unity 中重新实现了 Andrew Lowndes 的 WebGl 光场渲染器。

通过用 python 编写一些 blender 脚本，我能够输出一个 8×8 的图像网格，这些图像分别通过样式传输网络发送。然后它们被缝合在一起成为一个统一的图像。下面是生成的样式传递光场:

Downsized because the original is 8192 × 8192!

这里有一个光场渲染器的视频！

正如你所看到的，通过完全预渲染多个相机视图，我们可以创建一个光场渲染器，它提供了传统渲染系统的许多功能。但它也允许我们现在使用生成神经网络来创建 3D 内容！

但是这篇文章的标题是“神经网络和 3D 程序内容生成的未来”这真的是未来程序化内容的创作方式吗？就这样吗？大概不会。有很多优化工作要做，也许其他的生成算法，比如 GANN 的算法，会更适合这种类型的任务。

这篇文章展示的是神经网络可以从根本上改变我们生成 3D 内容的方式。我选择了光场，因为目前我的 GPU 速度不够快，无法以 60 FPS 的速度进行风格转换或任何其他生成网络。但是如果我们真的到了那一步，完全有可能看到生成神经网络成为标准光栅化方法的替代渲染管线。通过这种方式，神经网络可以根据用户的实时反馈实时生成游戏的每一帧。

但是对于创作者和最终用户来说，它也潜在地允许更强大的创作方法。想象一下玩《战争机器》,然后告诉电脑“保留游戏性、故事和 3d 模型，但让它看起来像塞尔达:野性的呼吸。”这就是创造或玩未来游戏体验的方式，因为计算机现在知道事物“看起来”是什么样子，并且可以让其他事物也“看起来”像它们。

就像我之前说的，计算机理解图像的能力，虽然可能没有《她》中的萨曼莎或《2001》中的哈尔那么令人印象深刻，但仍然是一件非常强大的事情。这是最近的一项创新，仍然有许多可能性有待发现！

神经网络=黑盒？

原文：https://towardsdatascience.com/neural-networks-black-box-b20723f9a417?source=collection_archive---------4-----------------------

如你所知，我是一个机器学习爱好者。具体地说，是神经网络。

在过去的几个月里，我读了很多关于 NNs 的文章。我得出了一个结论:

没有一个真正让你看到 NNs 是怎么学习的。

示例#1

福布斯，解释:神经网络

在这篇文章中，作者说:

“训练数据被输入到底层，即输入层，然后通过后续层，以复杂的方式相乘并相加，直到最终到达输出层，进行彻底的转换。

哇，情结确实帮助我理解了 NNs 是如何学习的…然后:

在训练期间，不断调整权重和阈值，直到具有相同标签的训练数据始终产生相似的输出。"

我有这个想法…模糊地。

实施例 2

哈佛商业评论，深度学习将从根本上…

“然而，要使神经网络有用，它需要训练。为了训练神经网络，一组虚拟神经元被绘制出来，并被分配一个随机的数字“权重”，该权重决定神经元如何对新数据(数字化的对象或声音)做出反应。

嗯，我想这是有道理的。

“最终，经过充分的训练，神经网络将始终如一地识别语音或图像中的正确模式。”

哦，再一次，它关上了正确解释神经网络如何学习的大门…

实施例 3

NYT ，伟大的人工智能觉醒

“训练是一个过程，通过这个过程，在 blob 中挖掘出一系列错综复杂的隧道，这些隧道将任何给定的输入连接到其正确的输出。”

我想我不喜欢隐喻数学方法。在这种情况下，一个 NN。

“他们*【权重】*必须独立证明他们是否也擅长挑选狗和除颤器，(…)

对(？).

(…)但让神经网络如此灵活的一点是，每个单独的单元都可以对不同的预期结果做出不同的贡献。"

尽管如此，我还是没有亲眼看到真正的学习。总之。

我的观点是:

了解机器如何学习。

真的！

神经网络训练(涉及梯度下降、反向传播等方法)很有意思。这也有点不可思议，因为数字开始自我调整，试图找到最大预测的最佳路径。

我知道这些文章并不是要向你展示这一点，因为它们的目标受众(这显然不是技术或教育)。

但我想，即便如此，我还是想看看里面的一些东西。

神经网络:误差预测层

原文：https://towardsdatascience.com/neural-networks-error-prediction-layers-fd8181dc33cd?source=collection_archive---------4-----------------------

早在 2005 年，杰夫·霍金斯就写过“论智力”——关于人类神经科学中的一个奇特发现，尚未被深度学习利用。它值得仔细看看。

人类、海豚和猴子拥有不同于其他生物的大脑:在我们的额叶，我们有许多相邻的多种类型神经元的堆叠——就像一张覆盖着盘子的早餐桌上，每个盘子上都有自己的一堆煎饼，点缀着配料。这些神经元以一种特殊的方式发挥作用:

最下面的层被赋予预测下一时刻的任务；每当它知道未来时，多巴胺就会激增，并加强它的联系。
下一个层的任务是预测下层何时出错；每当它知道下层的未来时，它就会感到兴奋，并加强它的学习。
进一步的层也被赋予预测其下层何时出错的任务；他们学会成为错误检测者。

人类在我们的“煎饼堆”中有六层，我们有一个有数百万个盘子的“早餐桌”，以形成我们更高层次的推理和自我反思的智能。这个模型与今天的人工神经网络完全不同。

但是，深度神经网络工作得很好……

是的，他们有。甘斯和 LSTM 网络公司也是如此。这些方法很快就找到了将数据压缩成特征的好方法。然而，我们的大脑做的不止这些。

让我们比较一下:一个循环神经网络，和人脑。rnn 接收环境的当前状态(其“输入”是屏幕上的像素)并在该环境中产生一个动作(“输出”在可能动作的空间中，而“输入”在可能像素排列的空间*)。然而，人类的额叶有一个最底层的“煎饼”，它取系统的当前状态(即“输入”)，并试图预测系统的未来状态(“输出”是与“输入”在同一空间上的*，损失函数是两个之差)。人脑不会像 RNN 那样试图“选择游戏中的最佳走法”！我们实际上是在试图预测接下来会发生什么。**

此外，一个 RNN 可能有许多“层”神经元，但它只代表单一“层”的功能*。像素输入→动作输出。我们自己的“煎饼”栈实际上就像多个神经网络的栈一样运行。每个“煎饼”接受状态输入→状态预测输出。更高层的“煎饼”起着错误检测器的作用，因为它们观察到的状态是它们更低层的基本事实与其预测之间的差异的映射。较高层只看到较低层做出错误预测 的像素。*

如果我们希望神经网络的行为像额叶一样，它需要映射像素输入→像素预测输出，然后将该输出与随后时刻的地面真实像素进行比较，以查看哪里的预测是错误的*。那将是最低级的“煎饼”。然后，被误预测的像素将成为下一个“煎饼”的输入，并且该“煎饼”试图预测下一个时刻的误差将在的哪里。第二个“煎饼”将是一个新的神经网络。*

我们将需要六个这样的神经网络，一个堆叠在另一个之上——让事情变得更复杂的是，更高层的“煎饼”也将接收来自多个特征检测器神经元的信号。我们的第六个“煎饼”将接收第五个“煎饼”的误差作为输入，以及来自第一个、第二个、第三个和第四个煎饼的一些特征检测器信号！这与现有的人工神经网络不同，我认为这种差异很重要。**

有什么帮助？

目前，研究人员期望单个神经网络每次都能正确处理问题。大脑不是这样工作的。在我们六个‘煎饼’中，第一个‘煎饼’神经网络出错往往*。如果我们将一个人工神经网络训练成最低的“煎饼”，我们将需要尽早降低学习速度，并在过度拟合之前停止。我们的网络仍然会得到许多错误的答案。*

然后，我们需要第二个“煎饼”，第二个神经网络，接收下层的错误。那一层也会很早就停止。很可能仍然会错误地判断最低层何时会出错。只有当许多这样的“煎饼”堆叠在一起时，错误率才会显著下降。**

对于注重数字的人来说:当前的 NLP 网络在大约 4%的时间里是错误的。同时，假设一个有六个“煎饼”的“额叶”有一个最低的“煎饼”有 50%的时间是错误的。就其本身而言，这个“煎饼”比我们目前的网络要糟糕得多。然而，它的错误实例被传递给第二个“煎饼”。这个煎饼只寻找 50%的错误，我们可以假设它纠正了 50%的错误。到目前为止，这两个“煎饼”加在一起，有 75%的正确率。有了这些“煎饼”中的六个“煎饼”，每个“煎饼”只纠正一半剩余的错误，组合的准确度是 98.4375%！因此，即使每个错误检测器都“有故障”,错误检测器的堆栈也能很快胜过端到端网络。

通过种植煎饼预测误差

人类有更强的理性和反思能力，我们的盘子里也有更多的“煎饼”!海豚有四个，猿和猴子更少。我预计，如果一台机器有比我们更多的【煎饼】，每个“煎饼”都试图预测它下面的“煎饼”的误差，那么这台机器将会比我们更有能力。这为机器智能开辟了一个新的方向，在前进中学习。**

边学边做:机器将从一个单一的深度神经网络开始，并被赋予预测下一时刻的任务。当它的成功率超过某个阈值时，在顶部添加一个新的深度神经网络。这个新网络将接收下层网络的错误预测，并负责预测下一个错误将发生在哪里。当网络的成功率超过阈值时，添加一个新的深度神经网络。继续这个过程，以逐步改善网络的组合。

通过这种“煎饼”范式，网络通过在所有旧网络之上生长另一个深度神经网络“煎饼”*来响应新信息**。学习永远不会停止。“煎饼”堆得越来越高。当与专家混合的各种神经网络相结合时，这个概念变得更加重要。***

专家混合

在混合专家神经网络中，神经元像树莓一样“聚集”成密集连接的束。而且，就像树莓酱一样，有一些长距离的连接将所有的树莓“粘合”在一起。目前，专家模型混合就此打住。当一个输入进入果酱堆的底部时，它只激活几个“树莓”，每个“树莓”执行一点点特征检测。这些特征激活了果酱堆中较高的一些“覆盆子”，在那里检测到更高水平的特征。

沿着果酱堆向上移动，这些专家覆盆子能够发现不同输入的特征；对于输入的每个子集，不同的一组专家开始工作。专家混合网络的行为就像许多稀疏网络的联合，每个覆盆子都是其中一些网络的 T2 交集。

(在稀疏网络的拥挤维恩图中，每个网络都有特征检测器，这些特征检测器与任何其他网络有一点点重叠；因为有如此多的网络在一起，组合图允许大多数稀疏网络与其他人共享大多数特征检测器。例如，稀疏网络#1 可能利用特征检测器“树莓”A、B 和 C。同时，稀疏网络#2 使用 A、D 和 e。网络#3 需要检测特征 C、D 和 e 的“树莓”。因此，您可以将这三个稀疏网络组合成检测所有特征的专家混合物:A、B、C、D 和 e。每个稀疏网络仅在少数地方与其他稀疏网络重叠。但是，综合起来看，所有的专家都有重叠之处。)

所有浇头

回到构成我们额叶的“煎饼”。为了与我们自己的大脑相匹配，煎饼的比喻需要更加精细:我们的神经元显示出从一个盘子到另一个盘子的跨越堆叠的链接。这就像一个覆盖着盘子的早餐桌，每个盘子上堆放着六个“煎饼”……并且覆盆子果酱涂抹在所有的盘子上，沿着盘子的侧面滴落，并且每个盘子都接触到其他的盘子！我们的大脑很混乱。

如果我们想要一个像我们一样学习和成长的人工神经网络，它将需要多个错误预测深度神经网络的“煎饼”，其中每个深度神经网络都由专家的分层混合物组成。每个“煎饼”网络接收其下方“煎饼”的错误**、以及由相邻“煎饼”检测到的一些特征作为输入。这与当前的深度神经网络架构大相径庭。而且，值得一试。**

音乐神经网络:历史之旅

原文：https://towardsdatascience.com/neural-networks-for-music-a-journey-through-its-history-91f93c3459fb?source=collection_archive---------5-----------------------

从刘易斯和托德在 80 年代写的开创性论文到当前 GANs 作曲家的浪潮之间发生了许多事情。在这段旅程中，连接主义者的工作在人工智能冬天被遗忘，非常有影响力的名字(如 Schmidhuber 或 ng)贡献了开创性的出版物，与此同时，研究人员取得了大量令人敬畏的进展。

我们不会浏览音乐神经网络领域的每一篇论文，也不会钻研技术细节，但我们会涵盖我们认为有助于塑造音乐人工智能当前状态的里程碑——这是一个很好的借口，可以表扬这些决定关注一个除了酷以外什么也不是的信号的疯狂研究人员。开始吧！

首字母缩略词
AI —人工智能
CNN —卷积神经网络
GAN —生成对抗网络
LSTM —长时短时记忆(一种递归神经网络)
—MIDI—乐器数字接口(一种类似乐谱的符号化音乐表示)
MLP —多层感知器

连接主义者对算法组合感兴趣

几百万年前，在一颗大的小行星撞击地球后，一个漫长的冬天开始了。在这场灾难中，地球上的物种突然大量灭绝。

足够幸运的是，在人工智能的冬天，应用于音乐的神经网络有着不同的信念。这一时期导致了一系列关于算法组合的虚假工作，这些工作维持了该领域从 1988 年到 2009 年的相关性。这就是所谓的连接主义者对神经网络和机器学习的贡献。

然而，这些早期作品对大多数当代研究者来说几乎是未知的。

第一波工作是由刘易斯和托德在 1988 年发起的，他们提出了使用神经网络进行自动音乐创作。

一方面，刘易斯将多层感知器用于他的算法作曲方法，称为“精炼创造”。这在本质上是基于和 DeepDream 相同的想法:利用渐变来创造艺术。

另一方面，托德使用约旦自动回归神经网络(RNN)来顺序生成音乐——这一原则在这么多年后仍然有效。这些年来，许多人一直在使用同样的想法，其中包括:Eck 和 Schmidhuber，他们提出将 LSTMs 用于算法合成。或者，考虑一个更近的工作， Wavenet 模型(它“能够”生成音乐)也利用了同样的因果原理。

看看 Todd 和 Lewis 在 80 年代为算法合成引入的旧的连接主义思想今天仍然有效。但是，如果他们的原则是正确的，为什么他们没有成功？嗯，用刘易斯的话来说:“很难计算很多东西。”一个深度学习工作站中的一个现代 GPU 可能具有大约 110 tflops 的理论性能，而一个 VAX-11/780 (他在 1988 年用于工作的工作站)只有 0.1 mflops。

但是让我们回过头来讨论一下 Eck 和 Schmidhuber 的工作。在他们的论文寻找音乐中的时间结构:LSTM 的布鲁斯即兴创作中，他们试图解决算法作曲曾经(现在仍然)面临的一个主要问题:缺乏整体一致性或结构。

为了应对这一挑战，他们提出了使用 lst ms——据说它比香草-RNNs 更好地学习更长的时间依赖性。注意，作为这个实验的结果，音乐是 LSTMs 的早期应用之一！

LSTM 创作的音乐听起来怎么样？它能产生一种结构合理的蓝调吗？自己判断！

让我们处理底层数据！

在 2009 年之前(请记住，直到 2006 年，辛顿和他的同事们还没有找到一种用深度信念网络训练深度神经网络的系统方法)，大多数作品都是在解决算法音乐创作的问题。他们大多试图通过无线网络来做到这一点。

但是有一个例外。

早在 2002 年，Marolt 和他的同事们使用了一种多层感知器(在光谱图之上操作！)用于音符开始检测的任务。这是第一次有人以非符号的形式处理音乐。这开启了一个新的研究时代:一个种族开始第一个以端到端的学习方式解决任何任务。这意味着学习一个映射系统(或函数)，能够直接从原始音频中解决一个任务，而不是使用工程功能(如频谱图)或符号音乐表示(如 MIDI 乐谱)来解决它。

2009 年，人工智能冬天结束了，第一批深度学习作品开始影响音乐和音频人工智能领域。

人们开始用深度学习分类器处理更复杂的问题(如音乐音频标记或和弦识别)。

根据 Hinton 基于用深度信念网络预训练深度神经网络的方法，Lee 和他的同事(其中包括吴恩达)建立了第一个用于音乐流派分类的深度卷积神经网络。这是一项基础性工作，为一代深度学习研究人员奠定了基础，他们花了很大精力设计更好的模型，以从音乐频谱图中识别高级(语义)概念。

然而，并不是每个人都满意使用基于声谱图的模型。大约在 2014 年，Dieleman 和他的同事们开始探索一个雄心勃勃的研究方向，这个方向向世界展示了音乐音频的端到端学习。在这项工作中，他们探索了直接处理波形以完成音乐音频标记任务的想法——这取得了一定程度的成功，因为基于频谱图的模型仍然优于基于波形的模型。当时，不仅模型不够成熟，而且与现在一些公司可以获得的大量数据相比，训练数据也很匮乏。例如，最近在 Pandora Radio 进行的一项研究表明，如果有足够的训练数据，基于波形的模型可以优于基于频谱图的模型。

另一项具有历史意义的工作来自 Humphrey 和 Bello (2012 年)，他们当时提出使用深度神经网络进行和弦识别。他们说服乐存与人合著了《深度学习音乐宣言》——实际(略有不同)标题见参考资料！在这篇文章中，他们向音乐技术研究人员解释说，从数据中学习(分层)表示并不是一个坏主意——有趣的是，他们认为社区已经在利用深层(分层)表示了！

因此..下一步是什么？

概括地说，这个领域可以分为两个主要的研究领域:音乐信息检索，旨在设计能够识别音乐信号中存在的语义的模型；和算法作曲，目标是通过计算生成新的吸引人的音乐作品。

这两个领域目前都在蓬勃发展，研究团体稳步前进！

例如，在音乐信息检索领域:尽管目前的深度神经网络已经取得了相当大的成功，但最近的工作仍然在通过改进定义这些模型的架构来推动可能的边界。

但是实际的研究人员不仅仅打算改进这种模型的性能。他们也在研究如何增加它的可解释性，或者如何减少它的计算量。

此外，如前所述，人们对设计能够直接处理各种任务波形的架构非常感兴趣。然而，研究人员尚未成功设计出一种通用策略，使基于波形的模型能够解决广泛的问题——这将允许端到端分类器的广泛适用性。

另一组研究人员也在探索科学的边缘，以改进算法合成方法。记得在 80 年代(Todd 和 Lewis)和 21 世纪初(Eck 和 Schmidhuber)，使用了相当简单的自回归神经网络。但现在是现代生成模型的时候了，比如 GANs(生成对抗网络)或 VAEs(可变自动编码器)。

足够有趣的是:这些现代生成模型不仅被用于以符号格式创作新颖的乐谱，而且像 WaveGAN 或 Wavenet 这样的模型可以成为探索新颖的鼓空间或直接在波形域中呈现新歌的工具(与创作新颖的 MIDI 乐谱相反)。

神经网络现在是使能工具(和新颖的方法！)这些都是以前达不到的。像音乐源分离或音乐转录(被认为是音乐技术专家的圣杯)这样的任务现在从深度学习的角度重新审视。现在是时候重新定义什么是可能的，什么是不可能的，简单地将音乐神经网络领域分为两个领域是过于短视的。新一代研究人员目前正在寻找创新的方法来将这些片段组合在一起，尝试新的任务，并将神经网络用作创造力的工具——这可以导致人类与音乐互动的新方法。

你想成为塑造未来的人之一吗？

参考文献

如果你不是一个有上进心的学者
跳过这一节这篇文章是基于我几个月前准备的教程演示文稿。

刘易斯和托德 80 年代的论文:

Todd，1988 —“音乐应用的顺序网络设计”发表在《联结主义模型暑期学校学报》上。
Lewis，1988—“精化创造:梯度下降学习网络的创造性范式”国际神经网络会议。

第一次有人用 LSTMs 做音乐:

Eck & Schmidhuber，2002—寻找音乐中的时间结构:用 LSTM 递归网络进行蓝调即兴创作，IEEE 信号处理神经网络研讨会*。*

第一次有人用神经网络处理光谱图:

Marolt 等，2002 —“用于钢琴音乐中音符开始检测的神经网络”国际计算机音乐会议(ICMC) 。

第一次有人用神经网络构建了一个音乐流派分类器——基于 Hinton 的深度信念网络进行无监督预训练:

Lee 等人，2009—“使用卷积深度信念网络的无监督特征学习音频分类”《神经信息处理系统(NIPS)进展》。
Hinton 等人，2006—“一种深度信念网的快速学习算法”神经计算，18(7)，1527–1554。

第一次有人建立了端到端的音乐分类器:

Dieleman & Schrauwen，2014 年。音乐音频的端到端学习IEEE 国际声学、语音和信号处理会议(ICASSP) 。

最近在 Pandora Radio 进行的研究显示了大规模端到端学习的潜力:

Pons 等人，2018—“音乐音频标注规模的端到端学习”在国际音乐信息检索学会会议(ISMIR) 。

Humphrey 和 Bello (2012)在和弦识别方面做了一些工作，并撰写了《音乐深度学习宣言:

Humphrey & Bello，2012—“用卷积神经网络重新思考自动和弦识别”在国际机器学习与应用会议(ICMLA) 上。
Humphrey 等人，2012 年。超越特征设计:音乐信息学中的深度架构和自动特征学习国际音乐信息检索学会会议(ISMIR) 。

要了解有关如何改进当前架构的更多讨论，请访问:

Choi 等人，2016 年。使用深度卷积神经网络的自动标记在国际音乐信息检索学会会议(ISMIR) 上。
庞斯等人，2016 年。"音乐激励的卷积神经网络实验 " 基于内容的多媒体索引国际研讨会(CBMI) 。
Lee 等人，2017 年。利用原始波形进行音乐自动标注的样本级深度卷积神经网络国际声音与音乐计算大会(SMC) 。

算法组合的一些现代生成模型(基本上是 GANs 和 VAEs):

杨等，2017—“midit:一种用于符号域音乐生成的卷积生成对抗网络”国际音乐信息检索学会会议(ISMIR) 。
Roberts 等人，2018—“学习音乐中长时结构的分层潜向量模型”arXiv。

还有一些直接合成音乐音频的作品(waveGAN 和 Wavenet，基本都是):

Donahue 等人，2018—ICLR 研讨会中的“用生成对抗网络合成音频”。
Van Den Oord 等人，2016—“wave net:原始音频的生成模型”arXiv。
Dieleman 等人，2018—“现实音乐生成的挑战:模拟大规模原始音频”arXiv。
Engel 等人，2017 —“用 Wavenet 自动编码器进行音符的神经音频合成”在国际机器学习会议(ICML) 。

鸣谢
与Exxact(@ Exxact corp)合作撰写的帖子。非常感谢 JP Lewis 和 Peter M. Todd 回复电子邮件，感谢 Yann Bayle 维护这份(字面上的)棒极了的应用于音乐的深度学习论文列表。

神经网络:形成类比

原文：https://towardsdatascience.com/neural-networks-forming-analogies-587557c3b26e?source=collection_archive---------17-----------------------

我们的大脑具有人工神经网络仍然缺乏的能力:我们可以形成类比，将不同的输入联系起来，并使用相同的启发式方法处理它们。官方的行话是“迁移学习”。从根本上说，类比是压缩的一种形式，允许大脑以最小的空间模拟许多不同系统的动态。当两个系统行为相似时，可以用一个简单的类比来描述它们。

学习新东西

人工神经网络现在可以避免灾难性遗忘，这是一个主要的绊脚石。以前，当一个神经网络被训练完成一项新任务时，要么是太有可塑性，学习新任务的同时忘记了旧任务，要么是太死板，记住了第一个任务，却从未学习第二个任务。这一进步是向迁移学习迈出的重要一步，然而它只是将新任务划分到网络中不太有用的区域——它没有使用共享试探法将不同的任务组合起来。

我认为，为了形成类比并压缩用于许多类似任务的空间，神经网络必须将时间投入到一个独特的状态:假设类比。当假设类比时，神经网络必须忽略新的感觉输入，同时比较来自不同专家的输出。这样的网络有三种状态:接收和处理输入，反向传播突触权重的更新，以及假设类比。网络在所有三种状态之间交替；正如它在前馈和反馈之间交替一样，如果它希望发现不同子系统之间的联系，它必须花时间“思考”。

为专家提供制图投入

为了了解类比形成是如何工作的，想象一下所有可能输入的空间。在这个高维空间中，每个点对应不同的输入。混合专家神经网络的任务是将这些输入映射到各种专家聚类上。假设棋盘是输入的空间，每个专家占据棋盘上的一个样本，这样棋盘上的每个方格都与一个特定的样本相关联。神经网络接收输入，检查哪个专家在那里应用，并将输入数据发送给该专家进行处理。从输入到专家的映射是对这些输入的解析。

当网络假设一个类比时，它接受从输入空间到专家空间的新的映射为正确的。通常接收{X，Y，Z}作为输入的专家可能改为接收{A，B，C},以查看新的分配是否产生正确的预测。测试每个可能的重新分配的过程是假设状态；网络花在“思考”上的时间越多，就越有可能找到准确模拟不同子系统的现有专家群。当这种“思考”发生时，感觉输入被搁置，反向传播没有发生——网络“陷入思考”。

增长理解力

首先，一个不熟悉的输入被赋予它自己的专家聚类——它被视为全新的，处理起来效率低下且缓慢。然而，随着更多的输入出现在输入空间的该区域中，由于反向传播，其专家聚类变得更加准确。一旦新任务的专家足够准确，神经网络就可以开始思考——它模拟输入，并查看其现有专家集群的答案是否与类似集群的答案匹配。如果它们足够相似，那么类比是有效的，并且笨拙的新专家群被更成熟的模块所取代。(注意，网络是而不是将类似的专家集群与现实进行比较；它是相对于特定任务的专家来说的！比较的是想象的。)

这种行为类似于我们在大脑中看到的——当学习一项新任务时，我们很笨拙，容易分心。然而，一旦我们消化了新的任务，我们就会变得流畅和敏感。这种消化的发生是因为对任务的反思，以及将该任务与更熟悉的任务联系起来的过程。我们必须思考以找到有助于理解的联系和相似之处。寻找这些类比是一项非常有价值的工作，我们花了很多时间思考假设的类比，我预计高级人工神经网络也需要花很多时间思考。

好奇心

另一组研究人员已经在雅达利游戏的人工智能方面取得了很大进展，完全依靠好奇心。这台机器不知道奖励和死亡；它只是试图用一种新的、意想不到的事情发生的方式来玩。这可能非常像新大脑皮层，它不断地试图预测未来，并非常注意其预测出错的时间和方式。新大脑皮层不太受不常见的愉悦信号的驱动。相反，大脑皮层渴望理解。

然而，还有另一种形式的好奇心。

假设你的神经网络形成了一个类比，X →A，Y →B，Z →C，它想看看这个类比是否成立。两个专家系统，一个在数据{A，B，C}上被明确训练，另一个在{X，Y，Z}上被训练并且被假定为类似的，具有可以被模拟以比较那些专家群的边缘情况。

测试这些边缘情况是一种不同的好奇心——神经网络不会搜索新的输入。相反，它怀疑通过系统地寻找矛盾来进行类比是否恰当。“边缘案例”测试在发现任务的潜在动力方面可能超过“新经验”的好奇心；新体验的好奇心会落入陷阱，就像不断地换一个电视频道。新体验的好奇心是一台分心机器。相比之下，测试边缘案例更类似于科学家的工作，系统地假设，然后在这些假设的边界上进行实验。

需要时间

因此，神经网络使其感觉静音，停止反向传播，并开始思考假设的类比。不幸的是，没有找到可靠类比的硬性快速规则。我们自己的大脑似乎使用稀疏分布表示来编码信息，如果两种表示在许多方面重叠，它们可能会受到相同的动力学影响。所以，我们有一个粗略的相似性度量，给我们一个好的开始。然而，思考仍然缓慢。

对于每一个假设的类比，必须想象许多边缘情况。每个实例都呈现给特定任务专家和类似专家集群。如果许多想象的实例产生匹配的输出，那么类似的专家是一个很好的选择，并取代特定任务的专家。这可能很少见。因此，必须尝试许多假设，每个假设都需要多个想象的实例来验证。这可能是神经网络工作的很大一部分！我们自己对睡眠的需求，以及睡眠在消化新概念中的作用，似乎反映了这种行为。我们梦想在子系统之间形成新的连接，当我们的传感器静音，行动只是想象。

贝叶斯视角下的神经网络

原文：https://towardsdatascience.com/neural-networks-from-a-bayesian-perspective-ad8cacc7588e?source=collection_archive---------4-----------------------

无论从从业者的角度还是对于许多不同机器学习应用程序的最终用户来说，理解模型不知道什么都是很重要的。在我们之前的博客文章中，我们讨论了不同类型的不确定性。我们解释了如何使用它来解释和调试我们的模型。

在这篇文章中，我们将讨论在深度神经网络中获得不确定性的不同方法。让我们从贝叶斯的角度来看神经网络。

贝叶斯学习 101

贝叶斯统计允许我们根据证据(数据)和我们对世界的先验知识得出结论。这常常与只考虑证据的频率主义统计形成对比。先验知识捕获了我们对哪个模型生成了数据的信念，或者那个模型的权重是什么。我们可以使用模型权重的先验分布 p(w)来表示这种信念。

随着我们收集更多的数据，我们更新先验分布，并使用贝叶斯法则将其转化为后验分布，这一过程称为贝叶斯更新:

这个等式引入了贝叶斯学习中的另一个关键角色——可能性*，定义为 p(y|x，w)。这一项表示在给定模型权重 w 的情况下，数据的可能性有多大。*

贝叶斯视角下的神经网络

神经网络的目标是估计可能性 p(y|x，w)。即使你没有明确地这样做，也是如此，例如当你最小化 MSE 时。

为了找到最佳的模型权重，我们可以使用最大似然估计* (MLE):*

或者，我们可以使用我们的先验知识，表示为权重的先验分布，并最大化后验分布。这种方法被称为最大先验估计* (MAP) :*

代表我们的先验的项 logP(w) 充当正则化项。选择均值为 0 的高斯分布作为先验，你将得到 L2 正则化的数学等价。

既然我们开始将神经网络视为概率性生物，我们就可以开始享受乐趣了。首先，谁说我们必须在训练过程结束时输出一组权重？如果我们不学习模型的权重，而是学习权重的分布，会怎么样？这将允许我们估计权重的不确定性。那么我们该怎么做呢？

一旦你去贝叶斯，你永远不会回来

我们再次从权重的先验分布开始，目的是找到它们的后验分布。这一次，我们将对所有可能的权重进行平均，而不是直接优化网络的权重(称为边缘化)。

在推断时，我们不是采用最大化后验分布(或最大似然法，如果我们使用最大似然法)的单一权重集，而是考虑所有可能的权重，按其概率进行加权。这通过使用积分来实现:

x 是我们要推断 y 的数据点， X ， Y 是训练数据。第一项 p(y|x，w)是我们良好的旧可能性，第二项 p(w|X，Y)是给定数据时模型权重的后验概率。

我们可以把它想象成一个由每个模型的概率加权的模型集合。事实上，这相当于无限数量的神经网络的集合，具有相同的架构，但具有不同的权重。

我们到了吗？

啊，问题就在这里！事实证明，这个积分在大多数情况下是难以处理的。这是因为后验概率无法通过分析来评估。

这个问题不是贝叶斯神经网络独有的。在贝叶斯学习的许多情况下，你会遇到这个问题，多年来已经开发了许多克服这个问题的方法。我们可以把这些方法分为两类:变分推断法和抽样法。

蒙特卡罗抽样

我们有麻烦了。后验分布是难以处理的。如果我们不用计算真实分布的积分，而是用从中抽取的样本的平均值来逼近它，会怎么样？一种方法是马尔可夫链蒙特卡罗——你用期望的分布作为它的平衡分布来构造一个马尔可夫链。

变分推理

另一种解决方案是用来自易处理族的不同分布来近似真实的难处理分布。为了测量两个分布的相似性，我们可以使用 KL 散度:

设 q 是由θ参数化的变分分布。我们希望找到最小化 KL 散度的θ值:

看看我们得到的:第一项是变分分布和先验分布之间的 KL 散度。第二项是关于 q θ的可能性。因此，我们在寻找能够最好地解释数据的 q θ，但另一方面，它又尽可能接近先验分布。这只是将正则化引入神经网络的另一种方式！

现在我们有了 qθ，我们可以用它来做预测:

以上提法来自 deep mind2015 年的一部作品。类似的想法由格雷夫斯于 2011 年提出，并追溯到辛顿和范坎普于 1993 年提出。NIPS 贝叶斯深度学习研讨会上的主题演讲非常好地概述了这些想法多年来是如何演变的。

好吧，但是如果我们不想从零开始训练一个模型呢？如果我们有一个训练好的模型，我们想从这个模型中得到不确定性估计，该怎么办？我们能做到吗？

事实证明，如果我们在训练中使用辍学，我们实际上可以。

Professional data scientists contemplating the uncertainty of their model — an illustration

辍学是一种不确定性

辍学是一种经常使用的做法。在训练时，你随机抽取节点样本，并删除它们，也就是说，将它们的输出设置为 0。动机呢？您不希望过度依赖特定的节点，这可能意味着过度适应。

在 2016 年， Gal 和 Ghahramani 表明，如果你也在推理时应用 dropout，你可以很容易地得到一个不确定性估计量:

多次推断 y|x，每次采样一组不同的节点以排除。
对预测值进行平均，得到最终的预测值 E(y|x)。
计算预测的样本方差。

就是这样！你得到了方差的估计！这种方法背后的直觉是，训练过程可以被认为是同时训练 2^m 不同的模型——其中 m 是网络中的节点数量:每个没有被遗漏的节点子集定义了一个新的模型。所有模型都共享它们没有丢失的节点的权重。在每一批中，这些模型的随机抽样集被训练。

训练结束后，你手中就有了一套模型。如果你如上所述在推理时使用这个集合，你就得到这个集合的不确定性。

抽样方法与变分推断

就偏差-方差权衡而言，变分推断有很高的偏差，因为我们选择了分布族。这是我们正在做的一个强有力的假设，和任何强有力的假设一样，它会引入偏见。然而，它很稳定，方差很小。

另一方面，抽样方法具有较低的偏差，因为我们不对分布进行假设。这是以高方差为代价的，因为结果取决于我们抽取的样本。

最后的想法

能够估计模型的不确定性是一个热门话题。在医疗辅助和自动驾驶汽车等高风险应用中，了解这一点非常重要。这也是一个很有价值的工具，可以了解哪些数据有利于模型，因此我们可以去获取它。

在这篇文章中，我们介绍了一些获得模型不确定性估计的方法。还有更多的方法，所以如果你对此感到非常不确定，继续寻找更多的数据🙂

在下一篇文章中，我们将向您展示如何在推荐系统中使用不确定性，特别是如何应对探索-开发挑战。敬请关注。

这是与我们在今年 KDD 会议的研讨会上提交的论文相关的系列文章的第二篇: 深度密度网络和推荐系统中的不确定性 。

第一篇帖子可以在 这里找到 。

这是一个与 Inbar Naor 的联合帖子。最初发表于engineering.taboola.com

神经网络从无到有。容易还是困难

原文：https://towardsdatascience.com/neural-networks-from-scratch-easy-vs-hard-b26ddc2e89c7?source=collection_archive---------4-----------------------

对于那些不了解人工神经网络工作原理的人来说，人工神经网络就像魔法一样神奇。当你可以成为魔术师的时候，为什么要做一个观众！。我想讨论一下开始使用标准的机器学习库(keras)是多么容易，如果我们试图从零开始实现一个神经网络(numpy)以及一点点数学知识，它会变得多么有趣。

有什么新鲜事！

嗯，已经有几篇关于如何从头开始开发神经网络的文章了。但是，在大多数让初学者记住的文章中，实现了一个简单的网络，没有任何关于成本或激活功能的讨论。当手头的问题改变时，由于输入值的范围、激活函数的类型、误差函数，网络不能正常工作。所以，我们再深入挖掘一下。

这是我们将要做的。准备一些数据集，创建一个合适的网络体系结构，先用简单的方法实施该体系结构，然后用困难的方法实施。

数据准备

让我们使用来自 sklearn 的数字数据集。它是一个多类分类。

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_splitdig = load_digits()
plt.gray()
plt.matshow(dig.images[25])

看起来像迷你版的 mnist。应该没问题。该数据集包含data中的输入和target变量中的输出。target取值范围从 0 到 9。它必须被转换成一位热码表示，其中数组包含所有的零，除了索引值为 1。即，值 4 将被表示为[0，0，0，0，1，0，0，0，0]。pandas在单一功能中完成。由于误差函数的性质，这种多类分类问题必须被转换成用于训练 NN 模型的一个热点表示。

onehot_target = pd.get_dummies(dig.target)

就是这样！。数据集准备好了。现在，让我们把它分成训练和测试数据集。train_test_split也随机化实例

x_train, x_val, y_train, y_val = train_test_split(dig.data, onehot_target, test_size=0.1, random_state=20)# shape of x_train :(1617, 64)
# shape of y_train :(1617, 10)

训练集中有 1617 个实例。每个输入实例包含 64 个值的数组，相应的输出包含 10 个值的数组。

Dataset preparation

人工神经网络体系结构；

让我们构建一个四层网络(输入，两个隐藏层，输出)。

输入层- 64 个神经元(输入图像数组)
隐藏层 1 - 128 个神经元(任意)
隐藏层 2 - 128 个神经元(任意)
输出层- 10 个神经元(输出单热数组)

ANN architecture

keras——简单的方法:

Keras是一个非常棒的入门库。又快又简单。

from keras.layers import Dense
from keras.models import Sequential
from keras.optimizers import RMSprop, Adadelta, Adammodel = Sequential()
model.add(Dense(128, input_dim=x_train.shape[1], activation='sigmoid'))
model.add(Dense(128, activation='sigmoid'))
model.add(Dense(10, activation='softmax'))

在我们的例子中，我们将建立一个完全连接的神经网络，这意味着当前层中的所有神经元都连接到下一层中的所有神经元。因此，我们将模型定义为sequential，并添加了三个连续的层。需要注意的是，没有必要为输入添加单独的层。当定义第一个隐藏层时，输入层将自动初始化。

该模型添加了具有 128 个神经元的第一个隐藏层，其中input_dim也指定了输入层的大小。第二个隐藏层也有同样的 128 个神经元。最后，输出层有 10 个神经元。

model.summary()

模型不完整，没有指定成本函数和梯度下降优化。

model.compile(optimizer=Adadelta(), loss='categorical_crossentropy', metrics=['categorical_accuracy'])
model.fit(x_train, y_train, epochs=50, batch_size=64)

好吧。这是做这件事最简单的方法。总的来说，

ANN using keras

安白手起家——艰难之路

准备好。。这是一条艰难的路。该算法通过两个主要过程来训练模型。前馈和反向传播。前馈预测具有某些权重的给定输入的输出，反向传播通过调整权重来训练模型。因此，必须首先初始化权重。

import numpy as npclass MyNN:
    def __init__(self, x, y):
        self.input = x
        self.output = y
        neurons = 128       # neurons for hidden layers
        self.lr = 0.5       # user defined learning rate
        ip_dim = x.shape[1] # input layer size 64
        op_dim = y.shape[1] # output layer size 10
        self.w1 = np.random.randn(ip_dim, neurons) # weights
        self.b1 = np.zeros((1, neurons))           # biases
        self.w2 = np.random.randn(neurons, neurons)
        self.b2 = np.zeros((1, neurons))
        self.w3 = np.random.randn(neurons, op_dim)
        self.b3 = np.zeros((1, op_dim))

从一组好的权重开始肯定会快速提供局部最小值。除了缓慢地达到局部最小值之外，坏的权重集有时可能永远不会收敛。为了打破对称性，初始权重应该被随机化。这些值不应该为零，而应该更接近于零，这样输出就不会激增。最好有正值也有负值，这样除了大小，方向也不同。所以用正态分布。将偏置向量初始化为零是可以的。

source: Machine learning memes for convolutional teens, facebook

前馈

Forward pass

def sigmoid(s):
    return 1/(1 + np.exp(-s))# for numerical stability, values are normalised
def softmax(s):
    exps = np.exp(s - np.max(s, axis=1, keepdims=True))
    return exps/np.sum(exps, axis=1, keepdims=True)def feedforward(self):
    z1 = np.dot(self.x, self.w1) + self.b1
    self.a1 = sigmoid(z1)
    z2 = np.dot(self.a1, self.w2) + self.b2
    self.a2 = sigmoid(z2)
    z3 = np.dot(self.a2, self.w3) + self.b3
    self.a3 = softmax(z3)

前馈过程非常简单。(input x weights) + bias计算z并将其传递到包含特定激活函数的层中。这些激活函数产生输出a。当前层的输出将是下一层的输入，依此类推。如您所见，第一和第二隐藏层包含作为激活函数的 sigmoid 函数，输出层包含作为激活函数的 softmax 。softmax 产生的最终结果a3是神经网络的输出。

应用于该层的函数类型有很大的不同。Sigmoid 函数将输入压缩到(0，1)，Softmax 也做同样的事情。但是，Softmax 确保输出之和等于 1。在我们的输出中，我们想要测量每个类的输入的概率。例如，如果一个图像有 0.9 的概率是数字 5，那么在其他类中分配 0.1 的概率是明智的，这是由 softmax 完成的。

反向传播

Backward pass

好吧。Back-prop 可能看起来很棘手，因为你要处理多个层，多个权重，损失函数，梯度。不要担心，我们会用数学、直觉和代码实现来尝试它。从根本上来说，反向推进根据前馈输出和真实值计算误差。通过计算每层中的梯度，该误差被反向传播到所有的权重矩阵，并且这些权重被更新。听起来很简单对吧。嗯。让我们看看。

损失函数:

成本函数和损失函数可以互换使用。严格地说，损失函数是针对单个实例计算的，而成本函数是针对整个网络的。成本函数是一种衡量网络与真实值相比表现如何的方法。实际上，我们永远不会在训练中的任何地方使用成本函数，但是我们必须计算成本函数 w.r.t .权重和偏差的梯度以进行更新。所以，计算损失只是为了看看，我们在每个时期做得有多好。

最常用的损失函数是均方误差。由于我们正在处理多类分类问题，输出将是一个概率分布。我们要把它和我们的真实值进行比较，这也是一个概率分布，找到误差。对于这种情况，强烈建议使用交叉熵作为代价函数。为什么因为，交叉熵函数能够计算两个概率分布之间的误差。

连锁规则:

让我们考虑成本函数为 c，从前馈，我们知道

z = xw + b                 -> z = function(w)
a = sig(z) or softmax(z)   -> a = function(z)
c = -(y*log(a3))           -> c = function(a)

因此，根据输出，我们所要做的就是找出误差，以及每个权重对输出的影响程度。换句话说，求成本函数 w.r.t w3 的导数。是的，反向传播就是用链式法则计算导数。

外层:

dc     dc    da3   dz3
---  = --- . --- . ---
dw3    da3   dz3   dw3z3 = a2w3 + b3
a3 = softmax(z3)dz3/dw3 = a2
da3/dz3 = softmax derivative(z3)
dc/da3  = cost function derivative(a3) = -y/a3

令人惊讶的是，由于交叉熵经常与 softmax 激活函数一起使用，我们实际上不必计算这两个导数。因为，这些导数的某些部分相互抵消，正如这里清楚解释的。由此可见，predicted value — real value是他们产物的结果。

Let, a3_delta be the product of these terms as it will be needed in the upcoming chain rules.
           dc    da3
a3_delta = --- . --- 
           da3   dz3Thus, a3_delta = a3-y (the error to be propagated)dc     
---  = (a3 - y) . a2
dw3    
w3 = w3 - dc/dw3For changes in biases,
dc     dc    da3   dz3
---  = --- . --- . ---
db3    da3   dz3   db3dz3/db3 = 1\. Rest is already calculated
b3 = b3 - dc/db3 => b3 = b3 - a3_delta

隐藏图层:

在隐藏层中，成本函数相对于隐藏层的偏导数也将遵循链式规则，因为成本函数是外层的函数。

z2 = a1w2 + b2
a2 = sigmoid(z2)dc     dc    da2   dz2
---  = --- . --- . ---
dw2    da2   dz2   dw2dz2/dw2 = a1
da2/dz2 = sigmoid_derv(z2)dc     dc    da3   dz3
---  = --- . --- . --- => dc/da2 = a3_delta.w3
da2    da3   dz3   da2w2 = w2 - dc/dw2
and set a2_delta = dc/da2 . da2/dz2dc     dc    da2   dz2
---  = --- . --- . ---
db2    da2   dz2   db2dz2/db2 = 1
b2 = b2 - dc/db2 => b2 = b2 - a2_delta

成本函数 w.r.t w1 的导数也是如此

z1 = x.w1 + b1
a1 = sigmoid(z1)
c  = a1.w2 + b2dc     dc    da1   dz1
---  = --- . --- . ---
dw1    da1   dz1   dw1dz1/dw1 = x
da1/dz1 = sigmoid_derv(z1)dc     dc    da2   dz2
---  = --- . --- . --- => dc/da1 = a2_delta.w2
da1    da2   dz2   da1w1 = w1 - dc/dw1
and set a1_delta = dc/da1 . da1/dz1dc     dc    da1   dz1
---  = --- . --- . ---
db1    da1   dz1   db1dz1/db1 = 1
b1 = b1 - dc/db1 => b1 = b1 - a1_delta

收集所有上述方程，并把它放在一个单一的镜头将提供一个更好的概览。与向前传球相比，直觉上也是有道理的。

Feed forward equations:
z1 = x.w1+b1
a1 = sigmoid(z1)z2 = a1.w2+b2
a2 = sigmoid(z2)z3 = a2.w3+b3
a3 = softmax(z3)Back propagation equations:There is no z3_delta and softmax_derv(a3), as explained before.
a3_delta = a3-y z2_delta = a3_delta.w3.T
a2_delta = z2_delta.sigmoid_derv(a2)z1_delta = a2_delta.w2.T
a1_delta = z1_delta.sigmoid_derv(a1)

**注:**sigmoid 函数的导数可通过两种方式实现，具体取决于输入。这总是有一个困惑。如果输入已经是 sigmoid 的输出，即a，则

def sigmoid_derv(x):
    return x * (1 - x)

如果输入为z且未通过 softmax 激活，则

def sigmoid_derv(x):
    return sigmoid(x) * (1 - sigmoid(x))

在链式法则计算中，使用了z的 sigmoid 导数。但是在实现中，使用了a的 sigmoid 导数。因此，使用前一个等式。希望，这已经够清楚了。现在有了 numpy 实现。

def sigmoid_derv(s):
    return s * (1 - s)def cross_entropy(pred, real):
    n_samples = real.shape[0]
    res = pred - real
    return res/n_samplesdef error(pred, real):
    n_samples = real.shape[0]
    logp = - np.log(pred[np.arange(n_samples), real.argmax(axis=1)])
    loss = np.sum(logp)/n_samples
    return lossdef backprop(self):
    loss = error(self.a3, self.y)
    print('Error :', loss)
    a3_delta = cross_entropy(self.a3, self.y) # w3
    z2_delta = np.dot(a3_delta, self.w3.T)
    a2_delta = z2_delta * sigmoid_derv(self.a2) # w2
    z1_delta = np.dot(a2_delta, self.w2.T)
    a1_delta = z1_delta * sigmoid_derv(self.a1) # w1 self.w3 -= self.lr * np.dot(self.a2.T, a3_delta)
    self.b3 -= self.lr * np.sum(a3_delta, axis=0, keepdims=True)
    self.w2 -= self.lr * np.dot(self.a1.T, a2_delta)
    self.b2 -= self.lr * np.sum(a2_delta, axis=0)
    self.w1 -= self.lr * np.dot(self.x.T, a1_delta)
    self.b1 -= self.lr * np.sum(a1_delta, axis=0)

Source: neuralnetmemes, picbear

预测阶段:

一旦模型经过足够的训练，预测就简单了。查询输入必须传递给前馈网络并预测输出。

def predict(self, data):
    self.x = data
    self.feedforward()
    return self.a3.argmax()

总的来说，

ANN using numpy

最后的想法

调整参数，如学习率，纪元，初始权重，激活函数，看看系统如何反应
如果您的模型不起作用，即误差直线上升或权重都是 NaNs，或者只是预测所有输入都属于同一个类别:
-检查每个函数是否标准化
-用单个类进行训练，看看它是如何工作的
-检查矩阵的维数及其转置
-验证所用产品的类型，点积还是哈达玛积

感谢您阅读帖子。如果你喜欢，请鼓掌。如果你发现了错误或有疑问，请在评论中告诉我。

欢迎通过 Github 、 Twitter 和 Linkedin 联系我。干杯！。

神经网络捏造数字

原文：https://towardsdatascience.com/neural-networks-fudging-the-numbers-7588963db24a?source=collection_archive---------20-----------------------

为什么我们仍然需要数据科学家？

监督神经网络的全部目的是找到能够成功地将一些输入映射到一些输出的某个模型的最佳参数。虽然神经网络可以令人印象深刻，甚至到神奇的极限，但学习机制本身背后真的没有什么神奇之处。它通常包括指定一个损失函数作为**，一个惩罚指标和一个优化器**尽力减少损失。在之前的博客文章中，我们详细解释了所有这些概念，神经网络的一般机制和每个特定齿轮的细节。

假设我们正试图通过检查卫星信号的接收功率来预测室外的降雨量。正如我们所料，我们通常在非雨天有最强的卫星信号，在大雨天信号最差。神经网络的目标是找到将卫星信号映射到降雨量的传递函数。

Rain rate vs satellite attenuation (source here)

假设神经网络的第一次随机初始化创建了模型 rain=2。也就是说，不管卫星接收能力如何，我们预测外面的降雨量为每小时 2 毫米。这个模型与我们说的(rain=5)或(rain=30)模型相比有多好？

自然地，通过查看当前曲线，我们可以说(rain=30)是最差的模型，因为在我们的数据集中，降雨量从未达到 30 的水平！而 rain=2 却在很多时候莫名其妙的正确！笼统地说，如何衡量一个模型有多差？

损失函数是度量神经网络在特定数据集上的性能的指标。他们对神经网络在学习任务中的当前状态进行分级。

最著名的损失函数是误差平方和。它对误差的平方进行求和(误差是神经网络的预测和数据集的实际输出之间的差异)。误差越大，损失越大(以平方的方式！10 个单位的差异产生 100 个单位的损失)。

如果神经网络正确预测了所有输出，则误差平方(预测-实际)为零。完全没有损失，我们可以用这个神经网络代替整个数据集。基本上我们已经找到了一种无损压缩数据集的方法(这就是为什么它被称为损失函数！)

好，现在我们的第一个模型总共亏损 1000，我们能找到一个亏损 800 或 400 或 100 或 0 的更好的模型吗？(请注意，由于过度拟合问题，0 损耗可能不理想！)

梯度下降技术如 sgd、 rmsprop、adagrad 帮助神经网络在损失周围导航。通常他们会给神经网络指明方向以减少损失。把优化者想象成财务顾问。他们看着你的开销，告诉你:在这里你可以做得更好，在这里你可以花得更少，在这里你可以节省更多，在这里你可以减少你的损失！

优化器通过遵循**损失函数的梯度来减少损失。**数学上，这涉及计算损失函数的导数，并遵循最负斜率。因为目标是最小化损失，跟踪最负的导数就像跟踪最陡的下坡路。我们可以期待最快到达底部！

好吧，到目前为止，机器学习看起来很容易。我们只需要定义一个损失函数，然后优化器就来了！什么会出错？为什么我们甚至需要雇佣数据科学家？

当你选择用一个指标来管理的时候，你就邀请你的经理来欺骗和操纵它。

想象一下，一家公司根据员工在办公室工作的时间对他们进行评级。当员工意识到这一点时，她可以用许多方式作弊。她可以早点来办公室，一整天什么都不做，晚点下班，然后赢得本月最佳员工奖！当科学家以他们发表的论文数量来评价时，他们有巨大的动机在尽可能多的会议上发表尽可能多的论文，同时重复相同的想法。更不用说学生为了得到更高的分数而在考试中作弊的无数方式了。 《关于不诚实的诚实真相:我们如何欺骗所有人——尤其是我们自己》 是一本关于欺骗话题的优秀书籍。

Let’s play the number game!

这与我们的神经网络示例有什么关系？例如，如果我们认为我们的数据库是倾斜的:99%的时间不下雨，神经网络可以在所有时间懒洋洋地收敛到输出 rain=0。通过这样做，神经网络节省了 99%的损失！这就像一家金融公司逃避了 99%的税收，只缴纳了 1%的小额罚款。这里有一些其他机器学习的有趣例子懒洋洋地收敛到令人惊讶的解决方案。

我们可以说，如果被测量的对象不知道他们正在被测量或如何被测量，那么一个度量标准会更好。但是优化器正是通过遵循损失函数的梯度来工作的，如果我们不定义损失函数，我们就无法优化！有什么解决办法？

(Photo credits here)

只有深刻理解这个数字游戏、深度学习的机制及其背后的数学，数据科学家才能摆脱优化器玩这个游戏的陷阱！这是一份侦探工作！

当事情进展顺利时，我们不需要侦探。但是当一个模型没有收敛，或者收敛到一个懒解的时候，只有有深度理解和知识的人才能解决深度学习的问题。

这是在这种情况下我们可以做的事情的非详尽列表:

花更多的时间与领域专家一起更好地理解问题。能不能提取出更好更相关的特征？
检查数据集，我们能得到更多的数据吗？我们能减少偏见吗？我们能减少功能的数量吗？特征是独立的吗？我们能否尝试过滤、转换、预处理或减少偏斜或偏差。
检查模型是否太简单或太复杂。尝试不同的神经网络模型和架构。试图用一个简单的前馈层(y=ax+b)和一个线性激活来学习一个二次或高度非线性的函数显然是不合适的！
调整损失函数本身。当一个指标不起作用时，我们可以尝试另一个指标！例如，我们可以将“99x”乘数加到损失平方和上。这可能会阻碍优化器收敛到惰性解决方案 y=0。我们可以自定义损失函数来适应我们的需要(根据问题)！我们不仅仅局限于现有的标准损失函数(平方和和对数损失)！
尝试不同的优化器，不同的学习率，不同的正则化率。
提高自己的知识。例如，看看这个有趣的帖子:“关于深度学习的深层误解”
作为最后的手段，我们可以尝试元学习。元学习是一种探索几种各有不同配置的神经网络结构的技术。从这个意义上来说，可以看作是机器学习的蛮力。缺点是在计算能力方面显然是非常昂贵的！

原载于 2018 年 10 月 29 日【medium.com。

神经网络 I:符号和构建模块

原文：https://towardsdatascience.com/neural-networks-i-notation-and-building-blocks-817b1d2ea04b?source=collection_archive---------7-----------------------

神经网络简介

这个关于神经网络的系列帖子是脸书 PyTorch 挑战赛期间笔记收集的一部分，在 Udacity 的深度学习纳米学位项目之前。

内容

神经元
连接
层——神经元与连接

3.1 神经元层

3.2.连接层— PyTorch 示例

4。符号歧义:Y = X W vs Wt X

1.神经元

神经元是神经网络的组成部分。

毕竟，神经网络是神经元的简单集合，它们朝着同一个目标一起工作，通常是执行给定的任务，实现尽可能少的错误。

由于我们用于神经网络的图形表示，如图 1 所示，神经元也接收节点的名称，因为每个节点对应于图形表示中的一个唯一节点。图形表示不仅仅是用来简单地观察这些网络，也是我们如何计算实际发生的操作的一个基本方面。这将在更高级的部分“图形方法”中介绍，不在本节的讨论范围之内。

Figure 1. Graph representation of a neural network

只要看一下图 1，我们就可以通过观察神经元看起来是按层组织的，一个接一个地堆叠起来，从而对下一部分有一个直觉。然而，让我们先来看看单个网络的细节，并评估它们与真实生物神经元的接近程度。

在图 2 中，我们只是从网络中随机选取了一个神经元，并观察它由不同的部分组成。放大镜所指的那个神经元将对应于它上面的生物表示中的第二个网络。

我们观察哪些部分？

收集器

我将其命名为收集器，因为它的功能是聚集来自其他网络的传入连接。用生物学术语来说就是突触连接。请注意，合计行为的数学等价形式是求和。我们将看到，这种求和不仅仅是对所有连接求和，而是对它们进行加权，这意味着每个连接对收集器都有不同的“重要性”。

激活器

聚集在收集器中的接收信号的激活是发生在网络主体内部的过程。目前还不清楚对那个过程来说什么是更好的表示，在深度学习中，它是通过所谓的激活函数来建模的。这些函数的形式各不相同，但它们只是将一个函数应用于采集器传递的信号。这些函数是非线性的，因为激活器是神经元(或网络)的唯一部分，在那里我们可以引入学习非线性映射的能力，这是绝大多数真实世界场景所需要的。

经销商

在它的名字之后，分配器简单地收集激活器之后的信号，并以相同的强度将它发送到它所属的神经元所连接的其余神经元。在神经网络的图形表示中，它指的是堆叠神经元的下一层中的每一个单个神经元。

Figure 2. Biological neuron vs Artificial neuron

2.连接

在人工神经网络的图形表示中，不同神经元之间的连接由连接两个节点的边来表示。它们被称为权重，通常表示为和。神经网络上的权重是任何参数模型上的参数的特例。

如图 3 所示，我们可以给组成每一层的每一个神经元一个数字。权重的子指数表示哪些神经元被连接。因此， wij 表示在前一层神经元 i 与后一层神经元 j 之间建立的连接。

一种更有效的表示两层之间所有连接的数学方法是将它们收集到权重矩阵、**、 W 、**中。该矩阵将具有以下形式:

其中 l 表示这些权重的层的索引。 N 为上一层神经元的数量， M 为下一层神经元的数量。因此，行数由第一层神经元的数量定义，而列数由第二层神经元的数量定义，这当然不必相同。为简单起见，图 3 中省略了 l 索引。

Figure 3. Connections of neurons between 2 layers

为了对权重矩阵有更强的直觉，让我们给网络的输入命名，看看矩阵的行和列代表什么。

我们可以把图 4 中的输入看作是，例如花在学习理论上的小时数和花在做练习上的小时数。模型的输出可以是通过考试的概率。所以我们要输入变量和 x1 和 x2 可以简化为输入向量 X 。

Figure 4. Computing the output of a layer

通过矩阵乘法，我们看到输入如何乘以每个权重，以产生输出 H (隐藏后)，其维数与该隐藏层的神经元数相匹配(我们将在下一节中更多地讨论层)。在这种情况下， h1 ， h2 ， h3 。

Figure 5. Weights matrix

让我们更仔细地看看权重矩阵。在图 5 中，我们可以看到每一列实际上代表了后一层中每个神经元的收集器。因此，每一行都代表前一层中每个神经元的分布器。

3.层——神经元与连接

我们已经介绍了人工神经元是如何分组分层的。特定层的每个神经元接收其所属层之前的层的每个单个神经元的信号，并将信号发送到下一层的每个单个神经元。

神经元层

Figure 6. Layers of an artificial neural network

深度学习中的单词层然后被用来称为神经元的每个堆叠聚集。在图 6 之后，第一层通常称为输入层。这是因为这是将输入引入网络以初始化正向传递的层，如图 4 所示。最后一层接收输出层的名称。直观上，它将把每个神经元执行的所有计算的输出结果提供给输入。输入层和输出层之间的所有中间层称为隐藏层。这些层通过创建数据特征的分层表示来执行所谓的表示学习。在使用了许多隐藏层之后，术语“深度学习”“T21”出现了，就这些层的数量而言，它让位于更深的网络。

连接的层次

在某些情况下,“层”这个词也用来指网络的权值层。因此，我们可以在网络中有两种堆叠实体表示，如图 7 所示。

左手边代表典型的神经元层。右手边代表连接的层，其中每一层代表封装该特定层的参数的权重矩阵。

记住这一点是很有用的，因为当我们实现我们的网络时，例如在 PyTorch 中，我们通常定义两层神经元之间连接的隐藏单元的数量。因此，我们给出权重矩阵的维数，并遵循右侧的表示。在这种情况下，PyTorch 中的深度前馈神经网络实现为:

Figure 7. Layers of neuron vs Layers of weights

图 8 表示在 PyTorch 中实现的图中使用的上述网络的输出。我们简单地传递了输入和输出维度以及一个列表，其中每个条目是每个隐藏层中的神经元数量 (2，2，[3，3]) 。

Figure 8. PyTorch implementation of the network

注意，当我们通过网络简单地调用网络时， PyTorch 打印出一个表示，将层理解为连接层！如图 7 的右手侧。根据 PyTorch 的隐藏层数是 1，对应于 W2 ，而不是 2 层 3 个神经元，这将对应于隐藏层 1 和隐藏层 2 。

4.符号歧义:Y = X W vs Wt X

深度学习中一个非常常见的模糊符号是如何在数学上表示输入和权重之间的乘积，以产生输出或任何特定层的隐藏表示。

首先，无论哪种记数法，如果使用得当，输出都是一样的。它们之间的区别在于如何理解变量(向量)，是水平向量还是垂直向量。

4.1.Y = Wt * X

在我们看到权重矩阵的转置出现在输入向量之前的情况下，意味着向量被表示为列向量。这种符号如此常见的原因是，特别是在神经网络被纯粹视为统计黑盒模型的背景下，遵循文献中其余模型的符号。

说到底，神经网络只是做所谓的曲线拟合的另一个工具而已。这意味着我们试图找到一个更好地适应数据分布的模型，当然，神经网络不是用来解决这一任务的第一个模型。线性回归模型是这种做法的最简单形式，如图 9 所示，用于图 7 所示网络中的二维输入。

Figure 9. Curve fitting for 2D input space

搜索该表面的表达式将以一些未知的系数开始，这些系数对输入值进行“加权”:

为简单起见，我们将从现在起省略偏置项 b 。

要点是系数通常放在它们所附属的变量之前。

听起来很熟悉，对吗？我们可以用一个非常简单的神经网络来表示这个方程，如图 10 所示。

Figure 10. 2D Surface fitting NN

我们还省略了权重的第二个子索引，因为只有一个收集器。

现在，如果我们将输入理解为两个条目的列向量，则这些网络的组件将是:

因此，计算输出的最终公式为:

延伸到一个更复杂的例子，对于图 7 中的网络，第一个隐藏层(没有任何偏置和激活)之后的隐藏值将是:

4.2.Y = X W*

在文献中找到神经网络的前向传递的另一种可能性是在没有任何转置的情况下利用权重矩阵之前的输入变量。

这自然是理解变量的相反方式。这一次，作为一个行向量，因此:

在我个人看来，这种方式感觉更自然。

作为人类，我们非常习惯于表格数据，我们通常赋予列维度的含义，赋予行不同记录(或观察)的含义。因此，类似于图 11 中描述的表格信息，结果非常直观。

Figure 11. Tabular data to row vector representation

在图 11 中，每一列代表现实世界中的一件真实的事情。 x1 可能是花在为考试学习理论上的时间，而 x2 可能是花在做练习上的时间。这个模型可以试着预测学生将得到的分数。#不是一个栏目，而是一个索引，简单地说就是每个不同的学生询问他是如何分配学习时间的。

在这些帖子中，我们将更详细地讨论批量大小。这一批仅仅意味着如果我们不是一次选择一个学生，而是选择更多的学生在网络上做同样的转发。绿框表示批量为 1。

神经网络 II:第一次接触

原文：https://towardsdatascience.com/neural-networks-ii-first-contact-7ad5094db1d2?source=collection_archive---------12-----------------------

神经网络简介

这个关于神经网络的系列帖子是脸书 PyTorch 挑战赛期间笔记收集的一部分，在 Udacity 的深度学习纳米学位项目之前。

内容

简介
向前传球
反向传播
学习
测试
结论

1.介绍

在下图中，显示了一个人工神经网络。我们可以看到如何将我们的输入数据( X )转发到神经网络中，并获得对我们输出的预测 Y_hat 。

Figure 1. Schematic Feed Forward Neural Network

因为我们有了预测应该有的实际值，所以我们可以使用所谓的“成本函数”来计算误差。通过这些，我们可以看到每个神经元对该误差的责任有多大，并更新它们的值，以便随着时间(实际上，随着输入向量的迭代次数)减少该误差。

在写下方程之前，为了更容易理解，让我们把神经网络转换成矩阵符号:

请注意，我们使用 n 和 m 来表示它可以是任何数字，也可以是更多的隐藏层。为了简单起见，我们将检查图 1 中所示的 NN，它意味着 1 个隐藏层， n=2 ， m=3 。

在下一个表格中，我们还可以看到一个表格，其中包含我们在本文档中使用的符号:

Table 1. Notation used

2.前进传球

现在我们有了所有这些信息，我们可以在神经网络上发展数学方法。就在它之前，也是为了方便可视化，让我们看看神经元内部发生了什么，例如我们的第一个隐藏神经元。

Figure 2. Single Neuron Scheme

这应该仍然是本系列第 1 部分中介绍的收集器和分配器的概念。

根据图示，神经元将乘以相应权重的所有输入相加，然后应用一个激活函数将输出传递给下一步。

因此，描述 NN 的整个方程组是:

有了这些等式，我们就完成了将在我们的 Neural_Network 类中定义的 forward 方法(我们将开始引入 Python 符号，以便在查看代码时更加熟悉)。

然后，将使用 NN 的输出和真实值来计算成本函数(注意这是监督学习)。根据你的问题，有几种方法可以计算这个函数。

这一次，我们将尝试最小化 RMSE(均方根误差)，这对应于下一个公式。RMSE 是用于回归问题的典型误差函数，正如交叉熵用于分类问题一样。然而，在这两种情况下，我们都可以使用各种不同的函数

更有趣的是，我们可以根据网络的参数来表达相同的等式:

3.反向传播

这是告知神经网络关于该值应该具有的误差，并将其反向传播给*‘告诉’*权重的时刻，它们对该误差负有多大责任，因此它们可以更新它们自己的值，以便持续减小该误差。

因此，我们想知道 dJ/dW1 和 dJ/dW2 的值是多少。

如果我们首先开发对应于隐藏层权重的梯度:

现在，如果我们暂时忘记常数项，将链式法则应用于剩余的导数项:

1–预测 Y_hat 是 z3 的函数，因此可以直接导出。

2–预测 Y_hat 可以相对于 W2 绘制成斜率为 a2 的直线。数学上，这被表示为该向量的转置。此外，我们已经将剩余的项分组到 delta3 中，这被称为“反向传播误差”。

上述陈述也可以在这个伟大的 youtube 解释中重温。

现在，再次将链式法则应用于下一个方程，我们可以计算剩余的梯度:

1–输入 z3 可以相对于 a2 绘制成斜率为 w2 → w2 的直线。T

2–输入 a2 是 z2 的函数，因此可以直接导出

3–输入 z3 可以相对于 a2 绘制成斜率为 X → X.T 的直线

4.学习—权重更新

到目前为止，我们已经解释了如何进行前向步骤来获得预测，然后如何使用真实值来计算成本函数值，以及如何使用反向传播(偏导数+链规则)来告诉每个神经元它们对该错误负有多大责任。但是现在，我们的 NN 是怎么学习的呢？嗯，和我们做的一样:尝试，失败，学习。这些步骤就是我们所说的:训练。

因此，我们已经讨论了尝试(转发)和失败(开销)步骤。现在，剩下的步骤 learn 是通过更新权重值来完成的。每个节点(或神经元)将按照下一个等式更新其最后一个值:

该参数λ被称为“学习率”。因此，作为 dJ/dWi 的错误 J 是由 Wi 的责任造成的——(注意 Wi 是一整层的权重)。鉴于所犯的错误(由于他们的错误)乘以这个学习率，我们确切地告诉我们的神经元纠正他们自己的值。

如果学习率的值太高(通常从 0.01 或 0.001 开始)，学习的过程就不能收敛，如果值太低，学习就可能永远进行下去。就像现实生活中一样！我们想尽可能快地学习，但是我们知道在开始的时候我们需要慢慢来吸收所有我们不知道的信息，直到我们有信心继续尝试新的信息

(*)情商。9 是学习的最简单的实现。通常，我们说优化器负责对权重进行更新。优化器有许多不同的实现。这种情况下，最基本的和其余的支柱被称为t。这里有一篇关于不同优化器以及如何实现它们的好文章。

5.测试——我们学会了吗？

学习的过程一遍又一遍地重复，直到我们认为我们已经学会了。但是,“已经学会”是什么意思呢？就像为了考试而学习一样，我们通常会做所有书籍中的问题，直到我们确保能够解决所有问题。但是后来考试来了。在考试中，有(通常)你没有处理过的数据，你不知道你会发现什么！

但是，如果你已经做了足够的研究，你很确定如果你对考试数据应用 forward( ) 函数，你将得到一个 A+的输出(你的答案)。NN 的行为完全相同。它进行训练，直到有信心转发新数据。(小心过拟合，训练过度)。

5.结论——我们学会了吗？

我希望这很有趣！这只是神经网络世界的开始！现在你可以去 GitHub repo 看看如何从头开始编写这个代码，或者如何使用 PyTorch 这样的深度学习框架来实现。

我强烈建议您从头开始编程，并确保您了解所有内容。然后你将准备好节省使用这些库的时间，但是要确信你理解在引擎盖下发生了什么。

你需要什么，就留下评论，如果你喜欢，请推荐它！下次再见，享受神经网络！！

神经网络 III:大图

原文：https://towardsdatascience.com/neural-networks-iii-the-big-picture-dfd0ad953d4c?source=collection_archive---------14-----------------------

神经网络简介

这个关于神经网络的系列帖子是脸书 PyTorch 挑战赛期间笔记收集的一部分，在 Udacity 的深度学习纳米学位项目之前。

内容

简介
作为功能的网络
让我们增加尺寸
批量大小

1.介绍

在第一章中，我们已经看到了什么是神经网络，以及我们可以从它们那里得到什么。这种方法是从外部观察神经网络。它们是我们见过的实际上在执行数学运算的黑盒。

为了完全理解神经网络，是时候从内部来看它们了。在这一章中，我们将看看这些神经网络如何被分解成最小的块，以及如何根据我们将要去神秘化的行为从零开始编码。事实上，我们要做的这种分解是神经网络和计算效率的原因，我们可以用它们来解决需要大型数据集的复杂问题。

首先，让我们再看看我们的老朋友，让我们试着找出我们能从中提取的最小片段。

Figure 1. Schematic Feed Forward Neural Network

唯一的区别是输入的维度和隐藏层中的神经元将是固定的，以便在我们回顾过程时获得更好的理解。我们将在途中发现所有的魔法从何而来。

2.让网络发挥作用

正如我们在前一部分中所做的那样，神经网络只是正在发生的数学运算的一种表示。因此，我们可以将所有变量表示为不同维度的向量。

首先，我们有一个二维输入。这意味着，我们有两个不同的概念，例如，温度和压力。我们的输入神经元将这 2 个输入维度映射到 3 个隐藏维度，这是隐藏层中神经元的数量。因此，矩阵的维数必须是*(2×3)*。此外，为了更清晰地显示，它没有被表示出来，但是我们有一个“b”项，用于在矩阵乘法之后添加偏差。这导致了这种情况:

现在我们有了到达隐藏层所需的所有工具。我们只需要应用矩阵乘法:

这样做的结果将是:

记住，每个输入权重将每个输入 i 与每个神经元 j 连接起来。这就是为什么符号 Wij ，连接 i 和 j.

一旦我们进入图层，就该应用激活功能了。这样做的结果将是:

我们将函数逐元素地应用于每个神经元的网络输入的每个元素，因此我们将 3 维作为隐藏神经元的数量。

根据神经网络方案，现在需要的变换是从 3 到 1，因为下一层只有 1 个神经元。最后一个神经元通常不执行任何功能，因为我们不想在这一点上应用非线性。因此，连接这两层的矩阵必须是 (3x1) 。

现在我们有了所有的工具来应用隐藏层的权重。那么需要执行等式是:

由于我们的最终输入不执行任何操作(还没有)，我们可以说 z3 是输入通过所有网络后的最终输出*(在前面的部分中称为 Y _ hat)*。这就是我们所说的前馈操作。

3.让我们增加维度

对于二维的单个观察，我们已经经历了整个前进过程。例如，我们有温度= 20°C，压力= 1 巴。但是谁能仅凭一次观察就学会任何东西呢？我们需要知道更多，以提高我们对周围事物的认识，并能够从中找到规律。如果我们想学习如何下棋，我们肯定要尝试几次。这个事实会使过程复杂化吗？当然不是！让我们过一遍。

比方说，我们有 4 个观察值(当然你需要更多，但我只是选择了与已经使用的 1，2，3 不同的最小数字，所以最后你可以使关系更容易；我们会达到这一点，不要担心)。

因此，我们的输入如下所示:

现在，对应于网络本身的变量保持不变。我们没有改变网络中的任何东西，我们只是用一批观测值作为输入，而不是单个观测值。因此，如果我们执行向前，我们的结果是:

同样，唯一的区别是我们对每个不同的观察都有一个新的行。接下来的步骤是使用 z2 作为每个隐藏神经元的净输入，以元素方式应用激活函数。因此 a3 的形状与 z2 的大小完全相同。

最后，应用等式。2 计算输出:

4.批量

我们一直在使用一批输入示例。在深度学习中，最重要的突破之一是对众所周知的优化器随机梯度下降(SGD)进行小规模修改，成为小批量随机梯度下降。

有什么区别？

那么，SGD 的普通实现将输入一个输入，并执行向前传递。这将导致误差，该误差将被反向传播到网络中以更新权重。

如第 3 节所示，mini-batchSGD 接收一批输入，并在转发过程中将它们一起转发，将每个输入的误差平均为 mini-batch 的单个误差。

使用小批量有什么好处？

首先，由于我们对每批输入进行 1 次权重更新，总的更新次数将会更少！因此，我们减少了训练中的计算量，从而减少了训练时间。

其次，硬件和软件都被优化以执行矩阵乘法。因此，在单次矩阵乘法中进行批量计算所需的时间比顺序进行要少。

最后，结果表明，使用小批量优化器具有更好的收敛特性，对训练有很大帮助。

这个 kaggle 内核是一个很好的资源，可以更好地理解批处理大小如何影响优化器。

行动中的神经网络

原文：https://towardsdatascience.com/neural-networks-in-action-47f7fc1954ab?source=collection_archive---------7-----------------------

使用人工神经网络模拟现实世界的问题

神经网络

A 人工神经网络是对人脑功能的计算机模拟，使用编程结构来模拟脑神经元的功能。你可能会发现我之前在的帖子 ( 神经网络介绍)在这方面非常有趣。

真实世界的场景和启发

使用神经网络解决的真实世界场景从简单的回归问题扩展到更复杂的问题，如自动驾驶汽车。但是对于神经网络的训练，我们必须评估网络的结果，以便它可以进行学习。有几种方法可以做到这一点。

使用监督训练
你知道对于给定的输入，输出应该是怎样的，因此我们提供带有输出的训练集来训练网络。
启发式函数
具有确定输入对输出的适合度的函数。主要用于决策制定，其中某个函数评估决定的输出，并为训练提供权重。举个例子，训练安玩 井字游戏 ，移动得越好，移动的重量就越大。
强化学习
通过奖励学习。我们可以想象一个场景，我们训练一个安去玩*【flappy bird】。你通过一个障碍间隙，你被奖励，赞成移动。如果你不喜欢任何其他不适合你的动作，那就继续做下去，直到找到最好的动作并开始训练。*

用于文本识别的人工神经网络

建模输入

培训的投入是至关重要的，质量越好，产出越好，是吗？对于文本识别，我们不需要更好的质量，我们需要更好的准确性和清晰度。在练习中，我们将使用 16×16 的图像。事实上，我们将把接收到的图像缩小到这个维度。同样，我们将使图像的灰度为。因为对于字符识别，我们需要的是画布上黑色像素的分布。将画布变小会使图像变得更轻，并使神经网络更容易将它们馈入。**

Downscaling images

如图所示，我们可以将数字从 0 缩小到 9 以适应 256 像素。这将使人工神经网络的外层具有 256 个节点来吸收每个像素，即使在便携环境中也是可管理的。

人工神经网络建模

16×16 grid image

该图描绘了一个数字缩小到 16×16 网格后的样子。

另一项重要任务是确定人工神经网络的规模。很明显，我们将 256 个(图像像素)输入映射到 10 个输出。内部节点呢？。我们实际上不需要太多的中间。因为中间有很多节点和层会使网络过重，增加传播误差更大。

使用 TypeScript 的实际示例

我已经使用0–9数字图片使用 Calibri 字体。并使用来自 苹果专卖店 字体的数字来测试神经网络。考虑下图。

Detecting whats in left by training from font in left

在这个例子中，图像的右侧包含测试输入，并且它由配置的 ANN 通过输出 0.11339060644370896 来检测，最后输出 10。所有其他输出都小于 0.02，这使得我们的选择比下一个最有可能的选择概率高近 5 倍。

示例代码

输出

**Started training
iterations 1000 error 0.031689028142154754 rate 0.1
iterations 2000 error 0.014637913521207704 rate 0.1
iterations 3000 error 0.009482464231621053 rate 0.1
iterations 4000 error 0.007004583325468936 rate 0.1
iterations 5000 error 0.005550772188951524 rate 0.1
Finished training
Attempting detection
Detected file 1_test.png as 1
Detected file 7_test.png as 7
Detected file 9_test.png as 9**

附言

有人指出，在某些情况下，5 和 9 混淆了。这是由于相似的形状。如果训练集使用顶部区域较小的 7，这甚至会发生在 1 和 7 上。为了更加准确，我们可以使用几种字体进行训练，我刚刚使用了一种。你也可以从链接的要点评论中下载训练数据文件。

神经网络:你的大脑像电脑吗？

原文：https://towardsdatascience.com/neural-networks-is-your-brain-like-a-computer-d76fb65824bf?source=collection_archive---------1-----------------------

大约三年前，当我怀儿子的时候，一个朋友送给我一本丽莎·艾略特的《里面发生了什么事？》。。对我来说，这是一个非常受欢迎的偏离，因为所有的育儿书籍都坚持告诉我，我的生活将变成一个充满不眠之夜、疲惫和普遍缺乏理智的生活地狱。所以我开始通读这本书，很快意识到这是我为即将为人父母做准备时所读的最重要的一本书。这本书讲述了人类从出生到童年早期的大脑发育。这本身就是一个迷人的主题，但在人工智能的背景下更是如此。

从神经生物学角度来说，人脑通过神经元或神经细胞网络发挥作用，这些神经元或神经细胞相互作用，以交流和处理信息，我们基于这些信息来看、听、动、想、做决定和一般功能。中枢神经系统及其神经元网络是体内所有活动的核心。

如果我们把它分解开来，人体的功能与现代计算机非常相似——或者说，计算机与有史以来最复杂的处理单元，即人脑非常接近。让我们暂时回到基础——任何信息处理系统都由 5 个主要部分组成——输入、输出、存储、处理和程序。我们可以在大脑和计算机之间画出这些元素的相似之处。

1。输入:输入是作为行动基础的刺激、数据和对象。

在机器世界中，输入来自输入设备，如键盘、鼠标、扫描仪、照相机、麦克风等。它们有不同的格式，如图像、文本和结构化数据。
对于人脑来说，输入是通过内部和外部刺激提供的。大脑的输入“设备”将包括感觉细胞(与视觉、听觉、触觉、味觉相关的细胞)、运动/肌肉细胞，甚至大脑中的一些细胞。这些细胞接收提供的刺激，并进行进一步处理。

2。输出:输出是对输入进行处理后得到的信息或动作。

在机器的情况下，输出动作可以是打印东西、添加数字、投影图像、基于算法解决复杂问题、识别模式等。
人脑中发生的处理输出显然更加复杂，包括控制内部和外部肌肉、感官知觉、管理内部身体功能(如血压、心率、温度)、决策、解决问题、情绪、社会行为等活动。

3。存储:这是存放输入信息、输出信息和程序等东西的地方。

计算机有两种存储方式。一种短期存储器，我们通常称之为 RAM，它存储计算机执行即时任务所需的有限数量的信息(数据或程序)。以及硬盘驱动器、光盘、磁带等形式的具有更大容量的长期存储。
与这种结构非常相似的是人脑的记忆系统。大脑的短期存储被称为 【工作记忆】 ，它在短时间内利用大脑的记忆和注意力能力来执行手头的即时任务(例如，在课堂上记笔记时记住老师在说什么)。人类的长期记忆是通过他们的 【长期记忆】 或 LTM 功能实现的，这使他们能够无限期地储存几乎无限量的信息。它包括对特定事件、事实信息和经历等事物的记忆(或存储)。

4。处理器:这可能是最容易掌握的并行。它是指执行所提供指令的中央处理电路。在计算机中，这是由其 CPU 管理的，而对于人类来说，这是由大脑和脊髓及其内部电路组成的中枢神经系统。

5。程序:或计算机语言中的“代码”。

这是指一套复杂的指令，规定了需要对输入做什么才能得到输出，汇集了一套必须在规定的参数内按规定的顺序执行的功能。
这是我们今天讨论的核心。在人类中，这种代码是通过大脑中的神经元执行的。神经元相互连接，通过它们传递信号，这些信号经过处理后实现所需的动作，整个过程由中枢神经系统控制。信号或信息交换通过称为突触的非常关键的神经系统结构发生。
计算机程序通过机器码运行，机器码是位的模式(即信息的二进制单位，如“1”和“0”)。类似地，人脑通过化学或电子信号的模式运行其“代码”，这些信号从一个神经元传递到下一个神经元，形成神经网络。

人工神经网络(或 ann)的工作方式与生物网络完全一样。人工神经网络是一个相互发送信号的人工神经元网络。这些网络的功能就像大脑一样，通过观察来学习，不需要特别编程。考虑一下婴儿第一次认出一只狗的情况——你给他们看一只狗，你说“狗”这个词，你这样做几次，现在婴儿的大脑已经学会识别狗的视觉和用于描述它的术语之间的模式。机器以完全相同的方式学习。

有趣的是，人类的智能和人工智能一样，也是需要开发的。在大脑发育的早期(通常从受孕到 4-5 岁)，连接神经元的突触会非常快速地产生。用数据科学的术语来说，这个阶段有点类似于“模型训练”——孩子接触的东西越多，与之相关的突触就越多。一个很好的例子是语言——一个孩子在早年接触语言学越多，她大脑中与语言相关的区域就越进化。其他认知和非认知能力同上。

这对我是一个启示，它改变了我看待童年早期的方式。对我来说，大致的底线是，在早期，你让你的孩子接触不同的事物越多，他们的突触在这些功能上就越强大，训练得越好。换句话说，人类的智能是可以被塑造的，就像它的人工对应物一样。这种理解也是我们经常听到的先天与后天之争的关键。

我们对人脑结构及其功能的理解仍在发展中，有许多方面我们甚至还没有开始触及其表面。对我来说，这一切都可以归结为一个问题:所有的大脑功能都是可计算的吗，也就是说，它们是否都可以归结为“输入-处理-输出”等式，这个等式在理论上可以在物理世界中复制，不管它的“处理”方面有多复杂。或者是人脑的角色的一部分(像意识、自由意志、记忆分类等等)。)就是不可“编程”？

这个问题还没有定论，人工智能的极限将在很大程度上取决于这个问题的答案。

神经网络 IV:图表方法

原文：https://towardsdatascience.com/neural-networks-iv-the-graph-approach-cb25590a7f24?source=collection_archive---------15-----------------------

神经网络简介

这个关于神经网络的系列帖子是脸书 PyTorch 挑战赛期间笔记收集的一部分，在 Udacity 的深度学习纳米学位项目之前。

内容

简介
神经网络的图形表示
计算中的模式——门
结论

1.介绍

和前面的部分一样，我们将使用相同的神经网络结构。

正如我们在“学习”一节中看到的，神经网络通过转发输入并将结果输出与真实值或这些输出应该是什么进行比较，根据所犯的错误来更新其权重。

在数学上，我们计算这些误差的梯度，并更新权重如下:

这些更新发生的次数非常多。神经网络使用大量数据进行大量迭代训练。为了使该过程在计算上可行，神经网络被理解为数学运算的非循环图，这便于导数的计算和链规则的应用。

2.神经网络的图形表示

是时候发现我们的神经网络是如何运作的了。如果你曾经使用过像 TensorFlow 或 PyTorch 这样的机器学习框架，我们要做的就是试图找出简化你生活的那几行代码背后的东西。

好吧，信不信由你，我们一直在工作的友好的神经网络如图 1 所示。

Figure 1. Graph representation of out [2, 3, 1] neural network.

让我们先看一看，并确定每种形状和颜色是什么:

黄色方框是变量。x 是输入，Y 是输出，正向过程的输出应该是什么；J 是实际输出 Y 和 Y_hat 之间的误差。

蓝色形状对应于各层之间的数学运算。它们基本上是基于元素的函数(激活)和矩阵加法和乘法。

现在我们可以转到上一章，回顾一下我们是如何通过将不同矩阵相乘的几个步骤来完成正向过程的。让我们写下我们可以为图表推断的方程，并检查它们是否与我们以前的知识一致。

那是所有的向前传球。我们现在开始神经网络的反向传播。这变得越来越有趣，所以让我们用第一个反向传播误差的例子来解释一下细节，看看这个过程基本上是如何以相同的方式重复的，直到我们到达我们网络的起点。

Figure 2.First Backward Propagation Step

我们需要从这里得到的想法如下:

首先，我们输入我们的输入值 z3 和 y 作为方程中描述的函数(成本)的输入值。F7。它们的值以灰色给出。因此，此时我们能够计算出 的局部梯度 。这些是电流方程的偏导数(我们看到它们在盒子下面和上面是黑色的)。如果我们拿 Eq。F7 和我们推导它，结果是(鉴于我们只有 1 次步骤，所以 n = 1):

接下来，我们总是从函数本身的局部梯度开始反投影过程，显然是 1。之后，我们希望将该错误反向传播给所犯错误的负责人。我们所做的是应用链式法则将一个导数分解成更简单的导数。

你必须意识到，这第一步可能不是最能说明问题的，因为成本函数本身的导数是 1，因此链式法则看起来没有任何作用。然而，当我们查看反向传播过程中的任何其他步骤时，它会对我们有所帮助，如图 3 所示。这里，我们以应用激活函数在系统中引入非线性的过程为例。

Figure 3. Activation Backward Propagation Step

本图中使用的激活函数是 sigmoid 函数。

重复相同的过程，我们有输入 z2 ，它被应用 sigmoid 函数以获得 a2 。在这一点上，我们可以计算局部梯度，并等待来自网络末端的反向传播误差。

然后，当它到达时，我们有 *dJ/da2，*它基本上意味着“J 的值对 a2 的多少负责”。应用链式法则，我们可以确定 z2 — (1)对那个 J 有多大的影响。

为此，我们应用与上一个示例相同的方法。我们使用链式法则将梯度表示为局部梯度和误差反向传播到这一点的乘积。

为什么我们要计算这些梯度？

为什么反向传播 J 成本的值？我们需要回忆一下网络是如何学习的。它们基于相对于权重的误差梯度来更新权重值。我们想知道“神经元的权重对所犯错误的责任有多大”，这样我们就可以调整它们的值，让我们的网络学习。所以，最后我们要找的是 dJ/dW1 和 dJ/dW2 。

好，现在我们知道了工具和目标，让我们为我们的网络开发逆向方程！

反向传播

在图 1 上向后看的同时看下面的等式。

我们走吧！我们已经完成了所有的反向投影过程，并计算我们感兴趣的梯度如此容易！我们将使用这些值来更新权重值，并减少下次的误差。但是现在，让我们仔细看看，做一件人类仍然比机器做得更好的事情，让我们找到模式。

3.计算中的模式—门

正如我们在图 2 和图 3 中详细看到的，全局网络的每个组件的反向传播基本上包括将从网络末端接收的梯度乘以局部梯度。这就是人工智能的魔力，就这么简单！

我们看到的另一个模式是不同的模块是如何工作的。在人工智能世界中，它们有自己的术语，如下:

添加门

在正向传递中，加法门将输入相加作为输出。

在后向通路中，加闸称为*。看看 B2-B2 或 B7-B8 这两个方程中的一个。它们代表网络中两个加法门的反向传播过程。他们两个的本地梯度都是 1，这就是为什么我们称他们为分销商。它们只是捕捉到到达它的梯度，然后原封不动地传递给它的所有输入。*

Figure 4. Python code for the Add Gate

乘法门

在前向传递中，乘法门将输入的乘积作为输出。

在反向通路中，乘法门被称为开关。看看方程式 B4-B5 或 B9-B10 中的一个。它们代表网络中每个乘法门的反向传播过程。两者的局部梯度是另一个输入的值，这就是为什么我们称它们为开关*。*

Figure 5. Python code for the Multiply Gate

激活

在正向传递中，各层将我们为其选择的函数(激活函数)应用于输入，以计算输出。

在后向过程中，层只是将其自身的导数值乘以传入渐变来计算输出渐变(也称为底部渐变)。看一下等式 6。两个典型的激活函数是 sigmoid 或双曲线正切。

Figure 6. Python code for two common Activations

成本计算器— PyTorch 标准

我们所看到的成本(通常也称为损失)是网络在与真实值进行比较时产生的误差。这可以解释为向前传递的最后一步或向后传递的第一步。

在这种特殊情况下，我们应用了一个成本函数来最小化均方误差。然而，根据神经网络的应用，这个盒子的结构和其上的值将会不同。

在这种特殊情况下，它接收输入的前向过程的输出，并将其与应有的值进行比较。之后，它返回导数的值，我们称之为 top_diff 。

Figure 7. Python code for the Loss calcualtion

4.结论

我们已经看到了神经网络的图形表示如何让我们容易地看到反向传播是如何发生的，以及如何通过图形的小组件使用链规则来容易地计算传播。

只剩下最后一件事，我真的鼓励你去看，特别是现在你已经到了这一步。我建议你到下一章去关注反向传播过程中矩阵的维数，去理解所有这些矩阵的转置和乘法是从哪里来的。

神经网络:问题与解决方案

原文：https://towardsdatascience.com/neural-networks-problems-solutions-fa86e2da3b22?source=collection_archive---------2-----------------------

虽然人工神经网络的概念从 20 世纪 50 年代就已经存在，但直到最近我们才有能力将理论付诸实践。神经网络应该能够模仿任何连续的功能。但是很多时候，我们会被表现不佳的网络所困扰，或者要花很多时间才能得到满意的结果。人们应该从统计学的角度来处理这个问题，而不是凭直觉去考虑网络结构中应该发生的变化。第一步应该是对数据进行适当的预处理。除了均值归一化和缩放，主成分分析可能有助于加速训练。如果数据的维数减少到这样的程度，即仍然保留适当的方差，则可以节省空间，而不会对数据的质量造成很大的损害。此外，当向神经网络提供较少的数据时，可以更快地训练神经网络。

通过使用奇异值分解将训练数据的协方差矩阵分解成三个矩阵，可以实现维数的降低。第一个矩阵应该包含特征向量。此外，矩阵中存在的向量组是正交的，因此它们可以被视为基向量。我们从这个矩阵中挑选出前几个向量，其数量等于我们希望将数据减少到的维数。用上一步得到的矩阵对原始矩阵(具有原始维数)进行变换，我们得到一个新的矩阵，它既降维又线性变换。

The sum of the lengths of the blue lines is to be minimised (2D to 1D)

上述步骤本质上是数学性的，但本质上我们只是将数据从较高的维度“投影”到较低的维度，类似于将平面中的点投影到拟合良好的直线上，使点必须“行进”的距离最小化。

PCA 的倍频程实现是:

function [U, S] = pca(X)
  [m, n] = size(X);
  U = zeros(n);
  S = zeros(n);
  Sigma=(1/m)*(X' * X);
  [U, S, V] =svd(Sigma);
endfunction Z = projectData(X, U, K)
  Z = zeros(size(X, 1), K);
  U_reduce = U(:, 1:K);
  Z = X*U_reduce;
endload ('<data>');                     % Loads the dataset into
                                     % variable X
[X_norm, mu, sigma] = Normalise(X);  % Performs normalisation
[U, S] = pca(X_norm);                % Performs PCA
K = input("Enter reduced dimension");
Z = projectData(X_norm, U, K);

人们可以使用主成分分析将数据简化为 3D 或 2D 来可视化。但是，更推荐的方法是利用 t 分布随机邻居嵌入，它基于概率分布，不同于 PCA。t-SNE 试图最小化高维和降维条件概率之间的差异。

Conditional probability in the higher dimension

条件概率对于靠得很近的点来说是高的(通过它们的欧几里德距离来测量),而对于相距很远的点来说是低的。根据获得的分布对点进行分组。选择方差，使得密集区域中的点与稀疏区域中的点相比具有较小的方差。

尽管 George Cybenko 在 1989 年证明了具有甚至单个隐藏层的神经网络可以逼近任何连续函数，但是可能希望将更高次的多项式特征引入到网络中，以便获得更好的预测。可以考虑增加隐藏层的数量。事实上，网络的层数等于它应该能够表示的多项式的最高次数。虽然这也可以通过增加现有层中的神经元数量来实现，但与向网络添加隐藏层相比，这将需要更多的神经元(因此增加了计算时间)，以近似具有类似误差量的函数。另一方面，使神经网络“深”会导致不稳定的梯度。这可以分为两部分，即消失和爆发的梯度问题。

神经网络的权重通常用随机值初始化，具有平均值 0 和标准偏差 1，粗略地置于高斯分布上。这确保了大多数权重在-1 和 1 之间。sigmoid 函数给出的最大导数为 0.25(当输入为零时)。这与权重属于有限范围的事实相结合，有助于确保其乘积的绝对值也小于 0.25。感知器的梯度包括许多这样的项的乘积，每个项小于 0.25。我们越深入图层，这样的术语会越来越多，导致渐变消失的问题。

Backpropagation of weights

本质上，外部隐藏层(更接近输入层)的感知器的梯度将由更深层的梯度和分配给它们之间的每个链接的权重的乘积之和给出。因此，很明显，浅层的梯度很小。这将导致他们的体重在学习过程中变化较小，并在适当的时间内变得几乎停滞不前。第一层应该承载大部分信息，但我们看到它得到的训练最少。因此，梯度消失的问题最终导致网络的死亡。

训练时可能会出现重量超过 1 的情况。在这种情况下，人们可能会想消失的渐变怎么还会产生问题。嗯，这可能会导致爆炸梯度问题，在早期层梯度变得巨大。如果权重很大，并且偏差使得它与激活函数的 sigmoid 的导数的乘积也保持在较高的一侧，那么这个问题就会发生。但是，另一方面，这有点难以实现，因为增加的权重可能会导致激活函数的输入值更高，而 sigmoid 的导数会非常低。这也有助于确立这样一个事实，即消失梯度问题是难以预防的。为了解决这个问题，我们选择其他激活函数，避免使用 sigmoid。

虽然 sigmoid 是一种流行的选择，因为它将输入压缩在 0 和 1 之间，并且它的导数可以写成 sigmoid 本身的函数，但是依赖于它的神经网络可能会遭受不稳定的梯度。此外，sigmoid 输出不是零中心的，它们都是正的。这意味着，所有的梯度要么是正的，要么是负的，这取决于下一层单元的梯度。

最推荐使用的激活功能是 Maxout 。Maxout 维护两组参数。使用产生更高值的那个作为激活函数的输入。此外，权重可以根据某些输入条件而变化。一种这样的尝试导致泄漏的整流线性单元。在这种特殊情况下，当输入大于 0 时，梯度保持为 1，当输入小于 0 时，梯度得到一个小的负斜率，与输入成比例。

在神经网络中遇到的另一个麻烦是内部协变量移位，特别是当它们很深的时候。随着训练的进行，输入的统计分布保持变化。这可能会导致领域发生重大变化，从而降低培训效率。该问题的解决方案是对每个小批量进行标准化。我们计算所有这些批次的平均值和方差，而不是整个数据。在输入到几乎每一个隐藏层之前，输入被标准化。这个过程通常被称为批量正火。应用批量标准化也有助于克服渐变消失的问题。

可以通过实现退出来提高正则化。通常，网络中的某些节点从神经网络的一些或所有层被随机关闭。因此，在每次迭代中，我们得到一个新的网络，而最终的网络(在训练结束时获得)是所有这些网络的组合。这也有助于解决过度拟合的问题。

无论采用什么样的调整，都必须始终跟踪网络中死亡神经元的百分比，并相应地调整学习速率。

可以对参数进行某些诊断，以获得更好的统计数据。图中的偏差和方差是这里的两个重要因素。它们可以通过绘制曲线来确定，该曲线具有关于训练和交叉验证数据集的损失函数(没有正则化)的输出对训练样本的数量。

(i) High bias (ii) High variance

在上图中，红色曲线代表交叉验证数据，而蓝色用于标记训练数据集。第一个数字是当架构遭受高偏置时粗略获得的数字。这意味着，该架构很差，因此即使在训练数据集上，它也给出相当高的错误。向网络中添加更多要素(如添加更多隐藏图层，从而引入多项式要素)可能会很有用。如果方差很大，这意味着训练的参数很好地符合训练集，但在“看不见的”数据(训练集或验证集)上测试时表现不佳。这可能是因为模型“过度拟合”了训练数据。获取更多的数据可以作为一种解决办法。在这种情况下，减少网络中隐藏层的数量也可能是有用的。玩正则化参数也会有所帮助。增加它的值可以修正高方差，而减少它应该有助于修正高偏差。

绘制诊断曲线的倍频程实现将是:

function [error_train, error_val] = ...
    learningCurve(X, y, Xval, yval, lambda)

  m = size(X, 1);
  error_train = zeros(m, 1);
  error_val   = zeros(m, 1);

  for i = 1:m
    X_here = X(1:i,:);
    y_here = y(1:i);

    theta = train(X_here, y_here, lambda);

    error_train(i) = LossFunction(X_here,y_here,theta,0);   
    error_val(i) = LossFunction(Xval,yval,theta,0);
   end;

endlambda = input("Enter regularisation parameter");
[theta] = train(X_poly, y, lambda);graphics_toolkit "gnuplot";
figure(1);
[error_train, error_val] = ...                               
    learningCurve(X_poly, y, X_poly_val, yval, lambda);                       plot(1:m, error_train, 1:m, error_val);
xlabel('Number of training examples');                    ylabel('Error');
legend('Train', 'Cross Validation');

尽管已经注意到大量的训练数据可以提高任何网络的性能，但是获得大量数据可能是昂贵且耗时的。在网络遭受高偏差或消失梯度问题的情况下，更多的数据将是无用的。因此，简单的数学应该被实现，因为它将指导我们应该下降到哪一步。

**参考文献:
*** 机器学习，斯坦福大学

卷积神经网络用于视觉识别，斯坦福大学
迈克尔·a·尼尔森，《神经网络与深度学习》，决心出版社，2015 年
批量归一化——什么玩意儿？(作者卡尔·n .)
*论文摘要 →用于文本分类的字符级卷积网络(作者尼尚特·尼基尔 )
代码库:https://github.com/americast/ML_ANg

预测市场的神经网络

原文：https://towardsdatascience.com/neural-networks-to-predict-the-market-c4861b649371?source=collection_archive---------2-----------------------

机器学习和深度学习已经成为量化对冲基金常用的新的有效策略，以实现利润最大化。作为一名人工智能和金融爱好者，这是一个令人兴奋的消息，因为它结合了我感兴趣的两个领域。本文将介绍如何使用神经网络来预测股票市场，特别是股票(或指数)的价格。本帖基于我的 GitHub 中的 python 项目 ，在这里可以找到完整的 python 代码以及如何使用该程序。此外，更多类似的内容，请查看我自己的页面: 工程师 Quant

金融中的神经网络

金融是高度非线性的，有时股票价格数据甚至看起来完全是随机的。传统的时间序列方法，如 ARIMA 和 GARCH 模型，只有当序列是平稳的时才有效，这是一个限制性的假设，需要通过取对数回归(或其他变换)对序列进行预处理。然而，在实时交易系统中实现这些模型的主要问题是，随着新数据的增加，不能保证稳定性。

这是通过使用不需要使用任何平稳性的神经网络来解决的。此外，神经网络本质上可以有效地发现数据之间的关系，并使用它来预测(或分类)新数据。

典型的全栈数据科学项目具有以下工作流程:

数据采集——这为我们提供了功能
数据预处理——使数据可用的一个经常令人畏惧但又必要的步骤
开发和实现模型——我们选择神经网络的类型和参数
回溯测试模型——任何交易策略中非常关键的一步
优化—寻找合适的参数

我们的神经网络的输入数据是过去十天的股票价格数据，我们用它来预测第二天的股票价格数据。

数据采集

幸运的是，这个项目所需的股票价格数据在 Yahoo Finance 中很容易找到。这些数据可以通过使用他们的 Python API 获得，也可以直接从他们的网站上获得。

数据预处理

在我们的例子中，我们需要将数据分解成十个价格和第二天价格的训练集。我通过定义一个类Preprocessing，将它分解成训练和测试数据，并定义一个方法get_train(self, seq_len)，它返回训练数据(输入和输出)作为numpy 数组，给定一个特定的窗口长度(在我们的例子中是 10)。完整代码如下:

def gen_train(self, seq_len):
    *"""
    Generates training data* ***:param*** *seq_len: length of window* ***:return****: X_train and Y_train
    """* for i in range((len(self.stock_train)//seq_len)*seq_len - seq_len - 1):
        x = np.array(self.stock_train.iloc[i: i + seq_len, 1])
        y = np.array([self.stock_train.iloc[i + seq_len + 1, 1]], np.float64)
        self.input_train.append(x)
        self.output_train.append(y)
    self.X_train = np.array(self.input_train)
    self.Y_train = np.array(self.output_train)

同样，对于测试数据，我定义了一个返回测试数据X_test 和Y_test的方法。

神经网络模型

对于这个项目，我使用了两个神经网络模型:多层感知器(MLP)和长期短期模型(LSTM)。我将简要介绍这些模型是如何工作的，但要阅读 MLPs 是如何工作的，请查看这篇文章。对于 LSTMs，请查看 Jakob Aungiers 的这篇优秀的文章。

MLPs 是最简单的神经网络形式，其中输入被输入到模型中，并且使用特定的权重，值通过隐藏层被前馈以产生输出。学习来自于通过隐藏层的反向传播来改变每个神经元之间的权重值。MLP 的一个问题是缺少“内存”。不知道以前的训练数据中发生了什么，也不知道这会如何影响新的训练数据。在我们的模型中，一个数据集和另一个数据集中的十天数据之间的差异可能是重要的(例如),但是 MLP 不具有分析这些关系的能力。

这就是 LSTMs 或一般的递归神经网络(RNNs)的用武之地。rnn 具有存储关于数据的某些信息以供以后使用的能力，这扩展了网络在分析股票价格数据之间关系的复杂结构方面的能力。RNNs 的一个问题是消失梯度问题。这是因为当层数增加时，学习率(小于 1 的值)会增加几倍，从而导致梯度不断降低。LSTMs 解决了这一问题，使其更加有效。

实现模型

为了实现这些模型，我选择了keras ,因为它使用了向网络添加层的思想，而不是一次定义整个网络。这使我们可以快速改变层的数量和类型，这在优化网络时非常方便。

使用股票价格数据的一个重要步骤是将数据标准化。这通常意味着你减去平均值，然后除以标准差，但是在我们的例子中，我们希望能够在一段时间的实时交易中使用这个系统。因此，采用统计矩可能不是归一化数据的最准确方法。所以我只是将整个数据除以 200(一个任意的数字，使一切都变小)。虽然这看起来像是无中生有，但它仍然可以有效地确保神经网络中的权重不会变得太大。

让我们从更简单的 MLP 开始。在keras 中，这是通过制作一个序列模型并在其上添加密集层来实现的。完整代码如下:

model = tf.keras.models.Sequential()model.add(tf.keras.layers.Dense(100, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(100, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(1, activation=tf.nn.relu))

model.compile(optimizer="adam", loss="mean_squared_error")

这才是 keras 的优雅真正展现的地方。仅仅用这五行代码，我们就创建了一个有两个隐藏层的 MLP，每个隐藏层有一百个神经元。简单介绍一下优化器。Adam optimizer 在机器学习社区中越来越受欢迎，因为与传统的随机梯度下降相比，它是一种更有效的优化算法。通过观察随机梯度下降的两个其他扩展的优点，可以最好地理解这些优点:

自适应梯度算法 (AdaGrad)，保持每个参数的学习率，提高稀疏梯度问题(如自然语言和计算机视觉问题)的性能。
均方根传播 (RMSProp)，其还保持基于权重的梯度的最近幅度的平均值(例如，其变化有多快)调整的每个参数的学习速率。这意味着该算法在在线和非平稳问题(例如噪声)上表现良好。

可以认为 Adam 结合了上述扩展的优点，这就是为什么我选择 Adam 作为我的优化器。

现在我们需要用我们的训练数据来拟合模型。同样，keras 使它变得简单，只需要以下代码:

model.fit(X_train, Y_train, epochs=100)

一旦我们符合我们的模型，我们需要根据我们的测试数据来评估它，看看它的表现如何。这由以下人员完成

model.evaluate(X_test, Y_test)

您可以使用来自评估的信息来评估模型预测股票价格的能力。

对于 LSTM 模型，过程是相似的，因此我将在下面发布代码，留下解释供您阅读:

model = tf.keras.Sequential()
model.add(tf.keras.layers.LSTM(20, input_shape=(10, 1), return_sequences=True))
model.add(tf.keras.layers.LSTM(20))
model.add(tf.keras.layers.Dense(1, activation=tf.nn.relu))

model.compile(optimizer="adam", loss="mean_squared_error")

model.fit(X_train, Y_train, epochs=50)

model.evaluate(X_test, Y_test)

需要注意的重要一点是，keras 要求输入数据具有特定的维度，由您的模型决定。使用 numpy 重塑数据至关重要。

对模型进行回溯测试

现在，我们已经使用训练数据拟合了模型，并使用测试数据对模型进行了评估，我们可以通过使用新数据对模型进行回溯测试来进一步进行评估。这可以简单地通过

def back_test(strategy, seq_len, ticker, start_date, end_date, dim):
    *"""
    A simple back test for a given date period* ***:param*** *strategy: the chosen strategy. Note to have already formed the model, and fitted with training data.* ***:param*** *seq_len: length of the days used for prediction* ***:param*** *ticker: company ticker* ***:param*** *start_date: starting date* ***:type*** *start_date: "YYYY-mm-dd"* ***:param*** *end_date: ending date* ***:type*** *end_date: "YYYY-mm-dd"* ***:param*** *dim: dimension required for strategy: 3dim for LSTM and 2dim for MLP* ***:type*** *dim: tuple* ***:return****: Percentage errors array that gives the errors for every test in the given date range
    """* data = pdr.get_data_yahoo(ticker, start_date, end_date)
    stock_data = data["Adj Close"]
    errors = []
    for i in range((len(stock_data)//10)*10 - seq_len - 1):
        x = np.array(stock_data.iloc[i: i + seq_len, 1]).reshape(dim) / 200
        y = np.array(stock_data.iloc[i + seq_len + 1, 1]) / 200
        predict = strategy.predict(x)
        while predict == 0:
            predict = strategy.predict(x)
        error = (predict - y) / 100
        errors.append(error)
        total_error = np.array(errors)
    print(f"Average error = {total_error.mean()}")

然而，这个回溯测试是一个简化的版本，而不是一个完整的回溯测试系统。对于成熟的回测系统，你需要考虑生存偏差、前瞻偏差、市场制度变化和交易成本等因素。因为这仅仅是一个教育项目，一个简单的回溯测试就足够了。但是，如果你对建立一个完整的回溯测试系统有任何疑问，请随时联系我。

下面展示了我的 LSTM 模型在预测二月份苹果股票价格时的表现

对于一个没有优化的简单 LSTM 模型来说，这是一个相当好的预测。它真正向我们展示了神经网络和机器学习模型在模拟参数之间的复杂关系方面有多么强大。

超参数调谐

优化神经网络模型对于提高模型在样本外测试中的性能通常很重要。我没有在我的项目开源版本中包括调优，因为我希望它对那些阅读它的人是一个挑战，以便继续尝试优化模型，使其性能更好。对于那些不了解优化的人来说，它涉及到寻找使模型性能最大化的超参数。有几种方法可以搜索这些理想的超参数，从网格搜索到随机方法。我强烈地感觉到，学习优化模型可以将您的机器学习知识提升到一个新的水平，因此，我将挑战您提出一个优化的模型，超越我在上面图表中的表现。

结论

机器学习不断发展，每天都有新的方法被开发出来。不断更新我们的知识是至关重要的，最好的方法是为有趣的项目建立模型，如股票价格预测。虽然上面的 LSTM 模型还不够好，不能用于现场交易，但是开发这样一个模型所建立的基础可以帮助我们建立更好的模型，也许有一天可以用在我们的交易系统中。

神经网络 V:反向传播

原文：https://towardsdatascience.com/neural-networks-v-back-propagation-60121cd9b904?source=collection_archive---------18-----------------------

神经网络简介

这个关于神经网络的系列帖子是脸书 PyTorch 挑战赛期间笔记收集的一部分，在 Udacity 的深度学习纳米学位项目之前。

内容

简介
反向传播中的维数
权重更新

1.介绍

像往常一样，让我们首先介绍我们正在使用的神经网络的场景:

Figure 1. Artificial Neural Network with shape [2, 3, 1]

及其图形表示:

Figure 2. Graph representation of the [2, 3, 1] neural network.

我们需要记录我们上一章做了什么，因为上一章的输出是这一章的输入。所以，让我们也拿回我们需要继续进行的工具。

我们已经知道这些值的来源，因为我们根据输入、层、批次和输出的维度定义了 doe 矩阵的形状。我们将再次包括该等式，以便于理解:

2.反向传播中的维数

我们将在最后一章中介绍的内容是，通过前面公式描述的第 4 章中的图形方法中的反向投影过程，对第 3 章进行同样的可视化。

我们讨论的第一个模式是 addGate:

现在我们需要知道如何用数学方法实现这些乘法。如果我们看一下两个输入在每个突触中的线性关系，在下图中:

我们可以看到，我们是如何首先根据偏差 b2 在梯度之前进行转置和放置的，因为我们打算对不同观测中的所有误差进行平均，以提供一个值来更新该偏差。

另一方面，对于 a2W2 项，我们只是将反向传播误差与一列 1 进行矩阵乘法运算，因为我们希望跟踪每个不同的反向传播误差，以便继续反向传播。

我们已经知道 addGates 的行为类似于分布器，并且两种情况下的局部导数都是 1。其结果我们从现在起可以称之为‘反向传播误差’δ。

下一步是 mulGate:

(*)我们已经应用了从 J 开始的整个链规则。从现在开始，我们将简化它，只使用顶部差异和局部梯度。

现在我们要确定这两个方程右边的导数。请看图 3 中的 LHS，这两项之间有线性关系，我们可以确定斜率。从数学上讲，我们通过转置矩阵来实现这个操作。

Figure 3. Back-Propagation Error through Connection between Layers

如果我们把它翻译成人类的语言，试着想想图 1 中发生了什么，我们可以说:

1.我们对不同迭代的乘积a2δ进行平均，以定义 a2W2 相对于 W2 的变化率。这就是为什么我们有 3 个维度，隐藏神经元的每个输出都有一个维度；并且它们中的每一个都增加了不同观测的误差。

2.我们将每个观察值的反向传播误差分割给不同的隐藏神经元，这就是为什么我们有 (4x3) 矩阵(4 个观察值和 3 个神经元)。

Figure 4. Back-Propagation through Activated Neuron

非常重要的是要看到，在这个场合，我们做的是标量积，而不是矩阵间的积。这是因为在向前传递时，激活函数是一个基于元素的操作，在向后传递时也是如此。

下一步，我们面临另一个添加门:

看一看，正如我们所知，addGates 是反向传递中的分发器，两次传播将是相同的值。我们应用了与第一个 addGate 完全相同的过程。

最后一步是另一个 mulGate:

X 的最后转置用于对隐藏层中每个神经元的每个观察的每个输入的每个观察的每个反向传播误差进行平均。

3.更新权重

我们现在应该前进到最后一步，学习。使用称重更新公式:

因此，将此应用于我们的两层砝码:

Figure 5. Weights updated

谷歌协作的神经网络|机器学习入门

原文：https://towardsdatascience.com/neural-networks-with-google-colaboratory-artificial-intelligence-getting-started-713b5eb07f14?source=collection_archive---------0-----------------------

谷歌最近推出了内部工具，用于协作编写数据科学代码。这个名为 Google co laboratory(g.co/colab)的项目基于 Jupyter 开源项目，并与 Google Drive 集成在一起。Colaboratory 允许用户在 Jupyter 笔记本上工作，就像在 Google Docs 或电子表格上工作一样简单。

合作实验室

首先，您可以访问联合实验室网站，并注册以收到使用该工具的邀请。确认邮件通常需要一天时间才会进入你的收件箱。CoLaboratory 让你使用谷歌的一个虚拟机来执行你的机器学习任务和制作模型，而不用担心你的计算能力的限制。而且是免费的。

当你第一次打开 colaboratory 时，你会看到一个 Hello，Colaboratory 文件，其中包含一些你可以用它做的事情的基本示例。我建议你尝尝它们。

使用 colaboratory，您可以像在 Jupyter 笔记本上一样编写代码。您编写并执行(Shift + Enter)代码单元格，并在单元格下获得您的输出。

除了写代码之外，这个程序还有几个锦囊妙计。您可以编写以“！”开头的 shell 命令在笔记本里。
例如，!pip install -q keras。
这让你对谷歌允许你使用的虚拟机有相当大的控制权。这些代码片段可以通过点击左上角的小黑按钮(在菜单下)找到。

我写这篇文章的目的是演示如何使用协同实验室来训练神经网络。我们将通过一个例子，在这个例子中，我们在由 UCI 机器学习库提供的乳腺癌威斯康星州数据集上训练一个神经网络。这里的练习相当简单。

这里是我为这篇文章制作的协作笔记本的链接。

深度学习

深度学习是一种机器学习技术，它使用的计算技术在某种程度上模拟了生物神经元的工作。分层排列的神经元网络从输入到输出来回传递信息，直到它调整其权重，以生成特征和目标之间潜在关系的算法。

要了解更多关于神经网络的知识，你可以参考卡洛斯·格雷申森的这篇非常简单的论文。你也可以在 medium 上找到在线资源。

对于那些还不了解神经网络的人，不要担心。这里的想法是一毫米一毫米地进步。继续…

密码

问题: 研究人员获得了乳腺肿块的细针抽吸(FNA)并生成了它的数字化图像。数据集包含描述这些图像中细胞核特征的实例。每个实例都标有两种诊断中的一种:“M”(恶性)或“良性”)。鉴于上述特征，我们的任务是根据这些数据训练一个神经网络来诊断乳腺癌。

当您打开 colaboratory 时，会看到一个新的 untitled.ipynb 文件供您使用。

Google 允许你在他们的服务器上使用一个虚拟的 linux 机器，这样你就可以访问终端来为你的项目安装特定的包。如果您只是在一个代码单元中传递一个!ls命令(记住在任何命令之前加上！)，你会在你的机器里得到一个名为datalab的文件夹。

我们的任务是将我们的数据集放到这台机器上，以便我们的笔记本可以访问它。你可以用..

一旦你的文件在机器上，你可以检查文件是否在那里。
!ls
你应该看到一个datalab目录和你的文件列表中的“breast_cancer_data.csv”。

数据预处理:

现在我们的数据已经在我们的机器上了，让我们使用 pandas 将它导入到项目中。

This is how the Output looks on Colaboratory

现在，分离因变量和自变量。

y 由一个列组成，列中的“M”和“B”分别代表“是”(恶性)和“否”(良性)。这些需要被编码成数学上相关的形式，即‘1’和‘0’。这可以通过标签编码器类来完成。

(当您遇到两类以上的数据时，请使用 OneHotEncoder)

现在我们的数据已经准备好了，让我们把它分成训练集和测试集。我们使用 Scikit-Learn 中的train_test_split类，这使得工作变得非常容易。

参数test_size = 0.2定义了测试集比例。这里，80%的训练和 20%的测试集。继续前进。

Keras Keras是用于构建人工神经网络的高级 API。它使用 Tensorflow 或the no后端进行其幕后操作。要安装 Keras，您必须在计算机上安装 Tensorflow。联合实验室已经在虚拟机上安装了 Tensorflow。如果你想检查你可以使用的安装

!pip show tensorflow

查看您使用的 tensorflow 版本。如果需要，您还可以使用!pip install tensorflow==1.2安装 Tensorflow 的特定版本

或者，如果你喜欢使用 Theano 后端，你可以在这里阅读文档。

安装 Keras:

顺序类和密集类用于指定神经网络的节点、连接和规格。正如上一节所看到的，我们将需要这些来定制我们的学习网络的参数并对它们进行调整。

为了初始化神经网络，我们将创建一个Sequential类的对象。

现在我们需要设计网络。

对于每个隐藏层，我们需要定义三个基本参数— units、kernel_initializer和activation。units参数定义了该层将包含的神经元数量。Kernel_initializer定义神经元将对数据输入进行操作的初始权重(更多信息请参见)。而activation定义了我们选择用于数据的激活函数。
注意:如果这些术语现在让人不知所措，也没关系。随着时间的推移，它们会变得更加清晰。

第一层:

对于第一层，我们放置 16 个神经元，这些神经元具有由 ReLU 激活函数激活的一致初始化的权重。此外，我们将参数input_dim = 30定义为输入层的规范。请注意，我们的数据集中有 30 个要素列。

作弊:
我们是如何决定层中单位的数量的？人们会告诉你这是一门艺术，需要经验和专业知识。对于初学者来说，一个简单的方法是将 X 和 y 中的列总数相加，然后除以 2。(30+1)/2 = 15.5 ~ 16.于是，units = 16。

第二层:第二层与第一层相同，但没有 input_dim 参数。

输出层:由于我们的输出是两个值中的任何一个，我们可以使用一个具有统一初始化权重的单元。然而，这里我们使用 sigmoid 激活函数(关于激活函数的单独文章即将推出)。

拟合:
运行人工神经网络，让 backprop 魔法发生。你应该在合作实验室而不是你自己的机器上看到所有这些加工过程。

这里，batch_size是您希望同时处理的输入数量。而epoch是你所有的数据通过神经网络一次的整个周期。它是这样出现在合作笔记本上的:

做出预测和混淆矩阵。

一旦您训练了您的网络，您就可以在 X_test 集合(我们之前放在一边)上进行预测，以检查您的模型在新数据上的表现如何。在单元格中键入并执行cm来查看它。

混淆矩阵
混淆矩阵，顾名思义，显示了你的模型做出的正确和错误预测的矩阵表示。当您需要单独调查哪些预测与其他预测相混淆时，该矩阵非常方便。这是一个 2×2 的困惑，马迪克斯解释道。

这就是我们的困惑矩阵的样子。[ cm (Shift+Enter)]

这是怎么读的: 70 真阴性， 1 假阳性，1 假阴性， 42 真阳性。很简单。当分类类别的等级增加时，方阵的大小增加。

就像这个例子一样，我们有几乎 100%的准确率。只有两个错误的预测。这一点也不坏。但情况可能并不总是如此。其他时候，你可能需要投入更多的时间，调查你的模型的行为，并提出更好、更复杂的解决方案。如果网络表现不佳，可以进行超参数调整来改进模型。我将很快就这个话题写一整篇文章。

我希望这能帮助您开始使用 Colaboratory。在此找到本教程的笔记本。

注:本文重点介绍 协同 的使用，并举例说明。对于一些读者可能没有理解清楚的概念的详细解释，我表示歉意，并请求您等待更多的文章。

预测精度和速度最佳的神经网络

原文：https://towardsdatascience.com/neural-networks-with-optimal-accuracy-and-speed-in-their-predictions-d2cdc3b21b50?source=collection_archive---------1-----------------------

深度神经网络目前被脸书、谷歌、苹果等公司使用。从大量用户生成的数据中进行预测。几个例子是脸书用于人脸识别和文本理解的深度人脸和深度文本系统，或者 Siri 和 Google Now 使用的语音识别系统。在这种类型的应用中，使用既快速又准确地进行预测的神经网络至关重要。这意味着，在设计这些系统时，我们希望调整不同的神经网络参数，以共同最小化两个目标:1)对一些验证数据的预测误差和 2)预测速度**。要调整的参数，也称为设计参数，可以是隐藏层的数量、每层神经元的数量、学习速率、正则化参数等。**

最小化预测误差和预测速度涉及解决多目标优化问题。在这种类型的问题中，一般来说，不存在单一的最优解来共同最小化不同的目标。相反，有一个称为帕累托前沿的最优解集合。

Example of Pareto front. Each point in the plot shows the objective values (f1 and f2) obtained for a particular setting of the design parameters. The points highlighted in blue are in the Pareto front.

帕累托前沿中的点实现了目标之间的最优权衡，也就是说，你不能通过改善一个目标而不损害另一个目标，从帕累托前沿中的一个点移动到另一个任意点。上图显示了两个目标 f1 和 f2 的帕累托前沿示例。图中的每一点都显示了对设计参数的特定选择所获得的目标值。当解决多目标优化问题时，我们感兴趣的是找到映射到 Pareto 前沿点的设计参数值。一旦我们找到了帕累托前沿的点，我们就可以做出决定，选择一个满足我们要求的点。

在神经网络调整问题中，对于设计参数的特定设置的预测误差的评估是计算上昂贵的过程。其原因是，在能够计算验证误差之前，我们必须首先在大量训练数据上训练神经网络。对于大型神经网络和大规模数据集，这个过程可能需要几个小时甚至几天。这意味着，理想情况下，我们希望使用少量的客观评估来找到帕累托前沿。这可以通过使用贝叶斯优化** (BO)技术来完成。这些方法使用模型的预测来有效地搜索昂贵的优化问题的解决方案。在这篇文章中，我将描述如何使用 BO 方法预测熵搜索进行多目标优化**

埃尔南德斯-洛巴托、埃尔南德斯-洛巴托、沙阿和亚当斯。
预测熵搜索多目标贝叶斯优化，
ICML，2016。【pdf】留兰香代号

用于在 MNIST 数据集上寻找具有最优预测误差与预测速度的深度神经网络。PESMO 是当前最先进的技术，用于具有昂贵目标函数的多目标优化。关于 BO 方法的更多信息，读者可以参考[1，2]。

寻找能对 MNIST 做出快速准确预测的网络

PESMO 是在 spearmint 工具的 PESM 分支中实现的，可以通过上面显示的链接公开获得。在我们的系统中安装了 PESM 绿薄荷分公司之后，我们必须指定我们想要解决的多目标优化问题。在我们的案例中，我们将调整神经网络中的以下设计参数:

隐藏的层数。
每个隐藏层的神经元数量。
辍学水平。
ADAM 优化器使用的学习率[3]。
L1 体重处罚。
L2 体重处罚。

这些信息在一个名为 config.json 的文件中提供给 spearmint，该文件包含优化问题的详细信息，例如要调整的变量、它们的最大值和最小值、我们将优化多少个目标、如何评估目标等。我们将使用以下 config.json 文件:

{
    "language"        : "PYTHON",
    "random_seed"     : 1,
    "grid_size"       : 1000,
    "max_finished_jobs"       : 100,
    "experiment-name" : "MNIST_neural_networks",
    "moo_use_grid_only_to_solve_problem" : true,
    "moo_grid_size_to_solve_problem" : 1000,
    "pesm_use_grid_only_to_solve_problem" : true,
    "likelihood"      : "GAUSSIAN",
    "acquisition"     : "PESM",
    "pesm_pareto_set_size"      : 50,
    "pesm_not_constrain_predictions"     : false,
    "main_file"       : "evaluate_objectives",
    "variables": {
        "n_neurons": {
            "type": "FLOAT",
            "size":  1,
            "min":  50,
            "max":  500
        }, "n_hidden_layers": {
            "type": "FLOAT",
            "size": 1,
            "min":  1,
            "max":  3
        }, "prob_drop_out": {
            "type": "FLOAT",
            "size": 1,
            "min":  0,
            "max":  0.9
        }, "log_learning_rate": {
            "type": "FLOAT",
            "size": 1,
            "min": -20,
            "max":  0
        }, "log_l1_weight_reg": {
            "type": "FLOAT",
            "size": 1,
            "min": -20,
            "max":  0
        }, "log_l2_weight_reg": {
            "type": "FLOAT",
            "size": 1,
            "min": -20,
            "max":  0
        }
    },
    "tasks": {
      "error_task" : {
          "type"        : "OBJECTIVE",
          "fit_mean"    : false,
          "transformations"     : [],
          "group"    : 0
      },
      "time_task" : {
          "type"        : "OBJECTIVE",
          "transformations" : [
                {"IgnoreDims" : { "to_ignore" : [ 2, 3, 4, 5 ]   }}
                ],
          "fit_mean"    : false,
          "group"    : 0
      }
    }
}

我将描述这个文件中的几个重要条目。条目 main_file 包含将被调用来评估不同目标的 python 脚本的名称。条目 max_finished_jobs 的值为 100。这表明绿薄荷评估不同的目标 100 次，然后完成。条目变量包含设计参数的描述，以及它们的最大值和最小值。条目任务包含待优化目标的描述。注意，预测时间不依赖于参数丢失、学习率、L1 罚值和 L2 罚值。我们通过在预测时间目标的目标转换中使用条目 IgnoreDims 来通知 spearmint。

下一步是编写评估不同目标的 python 脚本。我们已经告诉 spearmint，这个文件叫做 evaluate_objectives.py ，它包含以下基于 Keras 的代码[4]:

import numpy as np
import time
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.optimizers import Adam
from keras.utils import np_utils
from keras.regularizers import l1l2, l2, activity_l2

def build_model(params):

    n_hidden_layers = int(np.round(params['n_hidden_layers'][ 0 ]))
    n_neurons = int(np.round(params['n_neurons'][ 0 ]))
    log_l1_weight_reg = params['log_l1_weight_reg'][ 0 ]
    log_l2_weight_reg = params['log_l2_weight_reg'][ 0 ]
    prob_drop_out = \
        float(params['prob_drop_out'][ 0 ].astype('float32'))
    log_l_rate = params['log_learning_rate'][ 0 ]

    model = Sequential()
    model.add(Dense(n_neurons, input_shape = \
        (784,), W_regularizer=l1l2(l1 = np.exp(log_l1_weight_reg), \
        l2 = np.exp(log_l2_weight_reg))))
    model.add(Activation( 'relu'))
    model.add(Dropout(prob_drop_out))
    for i in range(n_hidden_layers - 1):
        model.add(Dense(n_neurons, \
            W_regularizer=l1l2(l1 = np.exp(log_l1_weight_reg), \
            l2 = np.exp(log_l2_weight_reg))))
        model.add(Activation( 'relu'))
        model.add(Dropout(prob_drop_out))
    n_classes = 10
    model.add(Dense(n_classes))
    model.add(Activation( 'softmax'))
    adam = Adam(lr=np.exp(log_l_rate), beta_1=0.9, \
        beta_2=0.999, epsilon=1e-08)
    model.compile(loss='categorical_crossentropy', optimizer=adam)

    return model

def evaluate_error_model(X_train, Y_train, X_test, Y_test, \
    X_val, Y_val, params):

    nb_epoch = 150
    batch_size = 4000
    model = build_model(params)
    model.fit(X_train, Y_train, batch_size = \
        batch_size, nb_epoch=nb_epoch, \
        show_accuracy=True, verbose=2, \
        validation_data=(X_val, Y_val))
    loss, score = model.evaluate(X_val, Y_val, \
        show_accuracy=True, verbose=0)
    print('Val error:', 1.0 - score)
    return np.log((1 - score) / score)

def evaluate_time_model(X_train, Y_train, X_test, Y_test, \
    X_val, Y_val, params):

    nb_epoch = 1
    batch_size = 500
    model = build_model(params)
    start = time.time()
    for i in range(100):
        predictions = \
            model.predict_classes(X_val, \
            batch_size=X_val.shape[ 0 ], verbose=0)
    end = time.time()
    print('Avg. Prediction Time:', (end - start) / 100.0)
    return (end - start) / 100.0

def main(job_id, params):

    nb_classes = 10
    (X_train, y_train), (X_test, y_test) = mnist.load_data()
    X_train = X_train.reshape(60000, 784)
    X_test = X_test.reshape(10000, 784)
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')
    X_train /= 255
    X_test /= 255

    state = np.random.get_state()
    np.random.seed(0)
    suffle = np.random.permutation(60000)
    i_train = suffle[ 0 : 50000 ]
    i_val = suffle[ 50000 : 60000 ]
    np.random.set_state(state)
    X_val = X_train[ i_val, : ]
    y_val = y_train[ i_val ]
    X_train = X_train[ i_train, : ]
    y_train = y_train[ i_train ]

    Y_train = np_utils.to_categorical(y_train, nb_classes)
    Y_test = np_utils.to_categorical(y_test, nb_classes)
    Y_val = np_utils.to_categorical(y_val, nb_classes)

    evaluation = dict()
    evaluation['error_task'] = \
        evaluate_error_model(X_train, \
        Y_train, X_test, Y_test, X_val, Y_val, params)
    evaluation['time_task'] = \
        evaluate_time_model(X_train, Y_train, X_test, \
        Y_test, X_val, Y_val, params)

    return evaluation

注意，在函数 build_model 中，我们将变量 n_neurons 和 n_hidden_layers 四舍五入为整数**，spearmint 假设它们是连续的。同样，在这个脚本中，函数 evaluate_error_model 返回错误的逻辑值，而不是错误本身。logit 变换扩大了接近零的值的误差变化范围，并允许 spearmint 使用的高斯过程模型更好地描述收集的数据。一旦我们完成了 config.json 和 evaluate_objectives.py 文件的编写，我们将使用 spearmint 来解决优化问题。让我们假设当前工作目录包含文件 config.json 和 evaluate_objectives.py**

$ python /path_to_spearmint_folder/main.py .

其中 path_to_spearmint_folder 是到我们已经安装了 spearmint 的 PESM 分支的文件夹的路径。然后，绿薄荷将评估这两个目标 100 次。在每一次评估之后，留兰香都会提出一个建议，其中包含几个有望位于帕累托前沿的点。一般来说，这些建议的质量随着绿薄荷收集的数据量的增加而提高。因此，一般来说，我们只会对最后一个建议感兴趣。所有的推荐都由 spearmint 存储在一个 mongodb 数据库中。我们可以通过使用 python 脚本extract _ recommendations . py来提取最后一个建议:

import os
import sys
import numpy as np

from spearmint.utils.parsing          import parse_config_file
from spearmint.utils.database.mongodb import MongoDB
from spearmint.tasks.input_space      import InputSpace

def main():

    options         = parse_config_file('.', 'config.json')
    experiment_name = options["experiment-name"]
    input_space     = InputSpace(options["variables"])
    db              = \
        MongoDB(database_address=options['database']['address'])

    i = 0
    recommendation = db.load(experiment_name, \
        'recommendations', {'id' : i + 1})
    while recommendation is not None:
        params_last = \
            input_space.vectorify(recommendation[ 'params' ])
        recommendation = \
            db.load(experiment_name, \
            'recommendations', {'id' : i + 1})
        i += 1

    np.savetxt('pareto_front.txt', params_last, fmt = '%e')

if __name__ == '__main__':
    main()

我们将这个脚本存储在与 config.json 文件相同的文件夹中，并使用

$ python extract_recommendations.py

脚本 extract_recommendations.py 在文件 pareto_front.txt 中存储估计位于 Pareto 前沿的设计参数值。然后，我们可以使用脚本 evaluate_objectives.py 在推荐点评估目标，并选择最符合我们要求的一个。下图显示了 PESMO 和其他现有 BO 方法在 50 次重复优化过程中获得的平均 Pareto 前沿。总的来说，PESMO 能够找到比替代技术在预测精度和预测速度之间具有更好平衡的神经网络。通过可视化帕累托前沿，如图所示，我们还可以做出更好的决定，从帕累托前沿选择哪些点。

Comparison of PESMO with other BO techniques in the task of finding neural networks that make accurate and fast predictions on the MNIST dataset. Each axis represents a different objective and the curves show the Pareto front produced by each method. On average, the Pareto front recommended by PESMO dominates all the others.

分离评估

在前面的例子中，我们总是在相同的输入位置一个接一个地评估两个目标。然而，在实践中，这两个功能可以以分离的方式进行评估，即独立地在不同的位置进行评估。请注意，为了评估验证数据的预测误差，我们必须首先训练神经网络。然而，训练对于评估预测时间不是必需的，这可以使用具有任意权重值的神经网络来完成。这允许我们将这两个目标的评估分离。在这个解耦的设置中，在任何给定的时间，我们可以选择评估预测误差或预测时间。一般来说，考虑这样的具有解耦目标的优化问题可以产生显著的收益，特别是当目标之一的评估是昂贵的并且关于优化问题的解决方案不是非常有用的时候。有趣的是，PESMO 还允许用解耦的目标来解决多目标优化问题。关于解耦函数求值的优化问题的更多细节可以在上面所示的 PESMO 参考文献或[5]中找到。[6]中给出了解耦贝叶斯优化在约束设置中的应用示例。在这项工作中，带约束的预测熵搜索( PESC ) [7]用于优化统计机器翻译系统的准确性，同时确保解码速度超过最小值。

参考

Brochu，Eric，Vlad M. Cora 和 Nando De Freitas。关于昂贵成本函数的贝叶斯优化的教程，应用于主动用户建模和分层强化学习， arXiv 预印本 arXiv:1012.2599 (2010)。
Shahriari，Bobak 等人将人类带出循环:贝叶斯优化综述，IEEE 会议录104.1(2016):148–175。
金玛，迪德里克和吉米巴。 Adam:一种随机优化的方法。 arXiv 预印本 arXiv:1412.6980 (2014)。
http://keras.io
埃尔南德斯·洛巴托 J. M .、盖尔巴特 M. A .、亚当斯 R. P .、霍夫曼 M. W .和加赫拉马尼 Z. 使用基于信息的搜索进行约束贝叶斯优化的通用框架，《机器学习研究杂志》，(出版中)，2016 年。【pdf】
丹尼尔·贝克、阿德里亚·德·吉斯佩特、贡萨洛·伊格莱西亚斯、奥雷连·韦特和比尔·伯恩。使用贝叶斯优化的统计机器翻译的速度受限调优。 arXiv 预印本 arXiv:1604.05073 (2016)。
埃尔南德斯-洛巴托 J. M .、盖尔巴特 A. M .、霍夫曼 M. W .、亚当斯 r .和加赫拉马尼 Z. 未知约束条件下贝叶斯优化的预测熵搜索，ICML，2015。【【补充素材】【python 代码】

逻辑门的神经表示

原文：https://towardsdatascience.com/neural-representation-of-logic-gates-df044ec922bc?source=collection_archive---------2-----------------------

https://static.pexels.com/photos/39290/mother-board-electronics-computer-board-39290.jpeg

逻辑门即“与”、“或”、“非”是过去十年来每一项技术突破的组成部分，尤其是在硬件方面。

在这个项目中，我们将使用神经网络的基础知识来表示逻辑门。我用 numpy 创建了一个感知器，它用数据集作为感知器的输入来实现这个逻辑门。

第一部分:逻辑门

首先，我们必须熟悉逻辑门。

逻辑门是 数字电路的基本构件。大多数逻辑门有两个输入和一个输出。在任何给定的时刻，每个终端都处于两种二进制状态之一:低(0)或高(1)，由不同的电压电平表示。当电路处理数据时，终端的逻辑状态可以经常改变，通常也确实如此。在大多数逻辑门中，低态大约为零伏(0 V)，而高态大约为正五伏(+5 V) 。如 techtarget 所述

最常见逻辑门是与、或、非。如果两个输入都是 1，则逻辑“与”门仅返回 1，否则返回 0；如果所有输入都是 1，则逻辑“或”门返回 1；如果两个输入都是 0，则仅返回 0；最后，逻辑“与”门不返回输入的反相，如果输入是 0，则返回 1；如果输入是 1，则返回 0。为了清楚起见，下图显示了基本门的真值表。

A 列和 B 列是输入，Z 列是输出。因此，对于输入 A = 0，B = 0，输出为 Z = 0。

第二部分:感知器

感知器是神经网络的基本部分。感知器代表人脑中的单个神经元，它由数据集(Xm)、权重(Wm)和激活函数组成，然后将产生输出和偏差。数据集(输入)被转换为一个 n array，然后与另一个保存权重的 n array 进行矩阵相乘。将所有矩阵相乘相加并加上一个偏差将创建净输入函数，然后输出将传递到一个激活函数，该函数将确定神经元是否需要触发输出。用于分类的最常见的激活函数是 sigmoid 函数，这是一个很好的分类函数(虽然 sigmoid 不是神经网络中间层的主要激活函数[ ehem ReLU / Leaky ReLU ],但它仍然广泛用于最终分类。)

上图是 sigmoid 函数的曲线。模型的输出作为“z”传递到 sigmoid 中。简单来说，如果模型(z)的结果是负数，sigmoid 函数返回 0–0.4，如果模型是正数，返回 0.5–1。

3。代码

对于代码，我们将从导入 numpy 开始。Numpy 是一个内置数学函数的库，非常适合做矩阵乘法和科学编程。(在这里了解更多关于 numpy 的信息:【http://www.numpy.org/】T2)

然后，我们将创建一个感知器函数，它将充当前面显示的图像中的感知器。该函数将接受权重矩阵、偏差和数据集矩阵。“np.dot(x，weight)”矩阵将数据集与来自输入的权重相乘，然后“np.add()”将矩阵乘法的输出与偏差相加。“1/(1+np.exp(-model)”表示激活函数，将模型传递到 sigmoid 函数中。

注意:由于我们这个项目的目标是将感知器表示为逻辑门，我们将对激活函数的输出进行舍入，以使输出仅为 1 或 0，但出于实际目的，舍入输出是一个很大的错误，小数给出的小信息有助于为下一个将处理信息的神经元添加信息。更不用说消失和爆炸梯度，但这是另一个故事

创建感知器后，我们需要为它填充输入。函数 compute 会执行此操作，因为数据集和权重还不是数组，我们将在这里执行此操作。它接受 logictype ( "logic_and "、" logic_or "等)来标记机器正在进行的计算，接受 weightdict，这是一个保存所有权重和偏差的字典，最后接受 dataset 参数

计算函数将为数组中的每个数据集返回感知器函数的结果

下面的要点是逻辑门 AND 和逻辑门 OR 的输出样本。

神经逻辑项目到此结束。需要注意的是，为了引入感知器的基本功能，项目权重是手动设定的，尽管优化将是找到该问题正确权重的最佳答案，因此如果输入变大，神经网络可以正确回答该问题。

要了解更多信息，您可以访问该知识库:https://github . com/fjcamillo/Neural-Representation-of-Logic-Functions/blob/master/Logic . py

神经类型转移:在数据扩充中的应用

原文：https://towardsdatascience.com/neural-style-transfer-applications-data-augmentation-43d1dc1aeecc?source=collection_archive---------9-----------------------

Different Styles of a Coffee Cup

神经风格转移是一个非常令人兴奋的深度学习应用。由卷积神经网络模型中的一系列卷积层创建的表示可以被解构，使得内容和风格可以分离。这种分离形成了 gram 矩阵，该矩阵可以用作生成器网络的损失函数(从随机向量映射到高度 x 宽度 x 颜色通道输出图像)。这个模型可以用来做一些事情，比如将文森特·范·高夫的艺术风格转化为一张普通的照片。

在我对数据扩充方法的研究中，(寻找人为地将数据添加到小数据集以形成大数据集的方法)，我一直对风格转移如何作为数据扩充方法起作用感兴趣。

风格转移是一种有趣的增强技术。它有点类似于颜色变换，但是，它能够传递纹理和其他各种扭曲，这是经典的颜色过滤器或仿射变换所无法实现的。

有一篇非常有趣的论文，对用于数据扩充的样式转移进行了实验，题目是:

风格扩充:通过风格随机化的数据扩充

作者:菲利普·杰克森、达勒姆大学的阿米尔·阿塔普尔-阿巴戈韦、斯蒂芬·邦纳、托比·布雷肯和博古斯瓦夫·奥巴拉。

本文将风格增强总结为一种“随机化纹理、对比度和颜色，同时保留形状和语义内容”的方法。

“基于图像的数据扩充的最普遍形式包括几何失真，例如随机裁剪、缩放、旋转、翻转、线性强度缩放和弹性变形。虽然这些在教导模型的旋转和比例不变性方面是成功的，但是颜色、纹理和复杂的光照变化呢？”

这是一个非常有前景的数据增强转换，尽管有各种各样的平移不变性和失真，我们仍然希望学习图像的语义内容。因此，我们应用一系列保留标签的转换来提高数据集的质量。

有趣的是，本文讨论的实验实际上并不是从一组风格图像中抽取风格样本，而是多元正态分布。我发现这有点令人困惑，我将坚持用一组不同风格的图片来做我自己的实验。

原始的神经类型转移算法需要大量的计算，因此不是数据扩充的好解决方案。然而，一种称为快速神经风格转移的新风格转移算法的开发极大地加快了进行风格转移所需的时间，“只需通过风格转移网络进行一次正向传递，该网络由风格嵌入参数化。”

此外，本文还重点研究了迁移学习中的领域适应任务。这就是从大型网络中学到的低级特征转化为新问题的地方。这个想法是，风格增强将有助于这个大型网络学习更好的迁移学习功能。根据该论文，“我们的方法通过增加数据将更多的变化引入源域，这可以增强模型的整体鲁棒性，从而更好地推广到许多潜在的目标域，而不需要来自它们的数据”。

结论

总之，我强烈推荐你亲自看看这篇论文，“风格增强:通过风格随机化的数据增强”！风格转移增强是一种非常令人兴奋的数据增强技术，用于学习更多样的不变性和领域转移。我很高兴能尝试一下，看看这是如何发展的。感谢阅读！

CShorten

Connor Shorten 是佛罗里达大西洋大学计算机科学专业的学生。对计算机视觉、深度学习和软件工程感兴趣。

神经类型转移教程-第 1 部分

原文：https://towardsdatascience.com/neural-style-transfer-tutorial-part-1-f5cd3315fa7f?source=collection_archive---------2-----------------------

神经风格转移理论

在这篇文章中，你将使用自下而上的方法学习，我们将从神经类型的基础开始。对于初学者，我们将详细介绍它到底是什么，以及它为什么有效。这篇文章是正在进行的系列文章的第一篇，我将与帕万·萨桑卡·阿玛纳曼奇合著。这个系列看不到尽头，我们将努力最终覆盖这个领域的研究，并不断增加新的作品。坚持到底的先决条件是:

1].计算机编程语言

2].基本了解卷积网络的工作原理。如果你对它们不太了解，我们建议这里的这篇文章。

风格转移是什么意思？

在过去的几年中，我们已经看到了大量的应用程序，如 prisma 和其他类似的应用程序，它们以一种看起来像绘画的方式来设计你的照片。为您提供各种美丽的风格，其中一些是著名艺术家的画作，如梵高的《星夜》。试图用语言来解释这个概念可能会很困难。

Figure 1

正如您在图 1 中看到的，有两个输入图像，即内容图像和样式图像，用于生成一个新的图像，称为风格化图像。关于这个图像需要注意的几件事是，它具有与内容图像相同的内容，并且具有与样式图像相似的样式。它看起来很好，我们非常确定它不是通过重叠这两张图像实现的，那么我们如何实现这个想法呢？为了回答这些问题，我们需要后退一步，关注卷积神经网络实际上学习什么？这些卷积层以特征图或内核的形式真正编码是什么，让它们这样做，或者换句话说，当我们输入图像时，CNN 学习什么表示，让我们先试着理解一下。

卷积神经网络最初是为图像分类而创建的，最近已用于各种其他任务，如图像分割、神经风格和其他计算机视觉以及自然语言处理任务。CNN 是深度学习中最容易解释的模型之一，因为我们有能力可视化它们的表示，并理解它们可能在学习什么。

卷积神经网络能提供哪些洞察？

在这一节中，我想分享一些关于 CNN 深层如何表示图像的直觉，以及我们如何使用这种只对模型有意义的计算表示，以利于我们开发神经类型转移。让我们以 VGG16 架构来理解隐藏层中的这种表示。

Figure 2

使用上述架构作为参考，让我们考虑 vgg16 的第一卷积层，它使用 3×3 内核并训练 64 个特征映射，通过将大小为 224×224 的 3 通道图像作为输入来生成 224×224×64 的图像表示。如果你有点困惑，请看下面

Figure 3

让我们假设，在训练这 64 个特征图时，它们可能已经学会了检测简单的模式，例如，当它们看到一条直线或甚至一些其他类型的模式时，一些神经单元会激活，这些模式对人眼来说可能没有任何意义，但对该模型具有巨大的价值。这种对直线或某种模式的“检测”被称为学习特征表示。

现在让我们考虑 vgg16 的第 10 卷积层，其使用具有 512 个特征图的 3×3 内核进行训练，并最终生成 28×28×512 图像表示的输出，只是为了简单起见，让我们假设在该第 10 层中有某些单元被包含像汽车车轮这样的圆圈的图像激活，或者可能有一些被具有类似于三条相交线等的某种图案的图像激活。

Figure 4 Visualizing and understanding convolutional networks

可以肯定的是，CNN 没有学会对图像进行编码，但它实际上学会了对图像表示的内容或图像中可见的内容进行编码，并且由于神经网络固有的非线性性质，我们从浅层到深层，隐藏单元变得能够从给定图像中检测越来越复杂的特征。

这些图像表现如何有助于风格转移？

编码表示本身的这种性质是风格转换的关键，它用于计算生成的图像相对于内容和风格图像之间的损失。当在每类上万幅图像上训练模型时，该模型能够为许多不同的图像生成相似的特征表示，只要它们属于同一类或者具有相似的内容或风格。因此，使用所生成的图像相对于内容和样式图像的特征表示的值的差异来指导迭代是有意义的，通过该迭代，我们产生所生成的图像本身，但是我们如何确保内容图像(C)和所生成的图像(G)在它们的内容而不是样式方面是相似的，而另一方面，我们如何确保所生成的图像仅从样式图像继承相似的样式表示，而不是整个样式图像本身。这可以通过将损失函数分成两部分来解决，一部分是内容损失，另一部分是风格损失，很快我们就会明白它们是如何彼此不同的，以及它们是如何克服我们已经提出的问题的。

损失函数

Figure 5

正如你在上面的等式中所看到的，我们需要计算两件事情来获得整体损失，即内容损失和风格损失，alpha 和 beta 超参数用于为每种类型的损失提供权重，即这些参数可以简单地视为控制我们希望在生成的图像中继承多少内容/风格的旋钮。那么，让我们来了解一下，每个损失项意味着什么。

上面显示的这个损失函数的输入是什么？我们不知道最终的输出会是什么样子。所以监督学习的天真方法可能行不通。答案就在下图中。

Figure 6 - Different Representations used for Content, Style and Generated Image

在每次迭代期间，所有三个图像，即内容图像、样式图像和生成的图像都通过 vgg16 模型。隐藏单元的激活值对特定层的给定图像的特征表示进行编码，作为这些损失函数的输入，用更简单的术语来说，你可以直接认为这是取 VGG16 网络中的层的输出，在层的选择上没有任何硬性规则。这里还要补充一点，最初我们随机初始化生成的图像，如果你看它，它只不过是一个形状与内容图像相同的随机噪声矩阵。在每次迭代中，我们都会改变生成的图像，以尽量减少总损失 l。

**注意:**这里在每个卷积层之后，它的输出通过 relu 作为它的激活函数，你也可以在图 2 中查看每个卷积块被表示为[卷积+ Relu ]

内容丢失

内容损失很容易计算，我们只取其中一层的特征表示，我们考虑 vgg16 的第 7 卷积层。为了计算内容损失，我们通过 vgg16 传递内容图像和生成的图像，并获得这两个图像的第 7 conv 层的激活值(即输出),其具有用于其激活的 Relu，我们将该层的输出一般表示为 relu_3_3，因为它是第三卷积集/块的第三 conv 层的输出(参考图 2 和 6)。最后，我们发现这两个激活矩阵之间的元素减法的 L2 范数，这将有助于通过确保最小化特征表示中的差异来保存生成的图像中的原始内容，该特征表示在逻辑上关注两个图像的内容之间的差异。

把这种损失用数学形式或者一个我们可以计算的方程来表达。假设我们有函数 Content loss，它接受三个参数作为输入，即内容图像 C ，生成的图像 G 以及我们将使用其激活来计算损失的层 L。现在让我们将内容图像的每个激活层表示为a【L】(C)，将生成图像的激活层表示为a【L】(G)。

Figure 7

风格丧失

现在让我们看看样式损失，在计算样式损失时，我们将考虑从模型的浅层到深层的许多卷积层的特征表示。与内容损失不同，我们不能只找到激活单元的差异，我们需要的是一种方法来找到同一层的不同通道之间的这些激活之间的相关性，为此我们需要一种称为 Gram Matrix 的东西。

什么是克矩阵？

我将通过一个示例尝试建立理解 gram 矩阵所需的基础，因此让我们考虑通过 vgg16 传递我们的样式图像，并从第 7 层获取激活值，生成大小为 56x56x256 的特征表示矩阵，您可以参考描述 vgg16 架构的图 2。现在让我们仔细看看这个输出。

Figure 8

在这个三维阵列中，有 256 个通道，每个通道的大小为 56×56。现在让我们假设有一个通道“A ”,当它们遇到包含黑色和棕色条纹的图像部分时，其激活单元可能被激活；然后有一个通道“B ”,当它们遇到类似眼球的东西时，其激活单元可能被激活。

**注:**此处被激活的单元是指通过 relu 后具有相对于零相当大的值。

如果这两个通道‘A’和‘B’对于相同的输入一起激活，则图像很可能包含老虎的脸(因为它有两个高值的通道，这两个通道激活眼球和棕黑色条纹)。现在，如果这两个通道都以高激活值启动，这意味着与通道“A”和“C”之间的相关性相比，它们将具有高相关性，其中通道“C”在看到菱形图案时可能会被激活。因此，为了获得所有这些通道之间的相关性，我们需要计算一种叫做 gram 矩阵的东西，我们将使用 gram 矩阵来测量通道之间的相关程度，这将在以后作为风格本身的度量。现在你可能已经理解了 gram 矩阵的意义，但是要理解我们如何通过下面提到的图片得到上面提到的三维数组的 gram 矩阵。

Figure 9 - Gram Matrix G

现在，您可以看到这个 gram 矩阵的每个元素如何包含所有通道相互之间的相关性度量。接下来，我们如何使用计算出的 Gram 矩阵 G 来计算风格损失。让我们将层 L 的样式图像的 gram 矩阵表示为 GML，将同一层的生成图像的 gram 矩阵表示为 GML。两个 gram 矩阵都是从同一层计算的，因此使用相同数量的通道，使其成为大小为 ch x ch 的矩阵，现在如果我们找到这两个矩阵的平方差之和或元素差的 L2 范数，并尝试将其最小化，那么这将最终导致样式图像的样式和生成的图像之间的差异最小化。想想看，这可能需要一些时间来适应，但当它适应后，你会被它的简单而有效所迷惑。

Figure 10 — Style Loss of single layer L

上式中， N 下标 l 表示图层lM下标 l 表示图层 l 的特征映射/输出的高度*宽度。

在计算风格损失时，我们使用多个激活层，这种情况使我们有可能为不同层提供的每个子损失分配不同的权重。下面的等式，很好地总结了我刚才说的，但是在我们的情况下，或者大多数情况下，人们通常给所有的层相同的权重。

Figure 11

接下来是什么？

向前移动，一旦你有内容和风格的损失，把它们加起来，并使用任何优化程序来执行梯度下降，以改变生成的图像，使其减少每次迭代后的损失。

这差不多总结了，我希望我的解释足以消除你对神经风格基础的任何疑虑。现在你可以深入到 neural style 的代码中，我将检查我的代码的每一行，并正确地剖析它，但是下面提到的伪代码几乎概括了你将要运行和使用的代码的所有内容。

S = Style_img
C = Content_img
G = random_initialization( C.size() )

下面的内容和样式层是原文中建议的常用层，但是你也可以尝试其他层。

# content_layers
C_Lys = [“relu_3_3”]# style_layers
S_Lys   = [“relu_1_2”, “relu_2_2”, “relu_3_3”, “relu_4_3”]alpha = 0.5 # content loss weight
beta  = 0.5 # style loss weightfor i = 1 to no_iteration = 1000:
   Loss = alpha*C_loss(C_Lys, C, G) + beta*S_Loss(S_Lys, S, G)
   minimize(loss).change(G)show_image(G)

这就是神经风格的本质。如果你对本文的任何部分还有疑问或者想要更好的解释，请在下面评论，我会尽我所能尽快回复你。

快乐学习！

链接。到原创神经风格转印纸 Leon A. Gatys 的论文，一种艺术风格的神经算法。

你可以期待接下来的文章在不久的将来被写出来。

Tensorflow 和 pyTorch 的神经类型转移课程:

第一部分神经类型迁移理论
第二部分——神经风格转移的实现
第三部分:快速神经风格转换的实现
第四部分深度照片
第五部分:人脸的神经类型转移理论
第六部分:人脸神经风格转换的实现

感谢您阅读本文！

如果你认为我们是志同道合的人，应该联系，那么你可以在 LinkedIn 上找到我，或者发电子邮件到 vamshikdshetty@gmail.com 找我。如果您有任何想法、问题或反馈，请在下面随意评论，我很乐意收到您的来信。

NeuralFunk -将深度学习与声音设计相结合

原文：https://towardsdatascience.com/neuralfunk-combining-deep-learning-with-sound-design-91935759d628?source=collection_archive---------2-----------------------

完全用神经网络产生的样本制作轨迹

Cover for NeuralFunk, designed by Nuevo.Studio

很长一段时间以来，我一直想把我对音乐的热情与我在人工智能领域的工作结合起来。但我一直拖着。我觉得在尝试让深度学习参与这个过程之前，我需要首先提高我的音乐制作技能。

但后来在 9 月中旬，我看到在今年的神经信息处理系统 ( NIPS )会议上，将有另一个关于 机器学习促进创意和设计 的研讨会，这可以说是人工智能社区每年最大的事件。艺术品和音乐的提交截止日期是 10 月底。

那件事，以及与 Nao Tokui 在同一时间喝了几杯啤酒的聊天，激励着我最终振作起来，停止使用借口，开始做一些事情。我有大约一个月的时间在研讨会的最后期限前完成一些事情。

结果是 NeuralFunk ，一个完全基于样本的轨迹，其中所有的样本都是由深度神经网络生成的。

它并没有像我最初打算的那样变成一首典型的 Neurofunk 曲目，而是发展成了一首相当独特的曲目。黑暗、混乱、疲惫，几乎让听者窒息，没有时间休息和呼吸。NeuralFunk 就像它产生的方式一样是实验性的。

【更新:NeuralFunk，以及我的另一首作品被 NIPS 工作室接受，你现在也可以在 Spotify 上听它和我的其他歌曲[。]](https://open.spotify.com/artist/5gsjQSovh7BPRlqb3GL3yU?si=mm_d-SRFRCes6fgwD2NnAw)

接下来我想告诉你这个项目是如何产生的，从深度学习和音乐制作的角度。

如果你只对其中一个方面感兴趣，可以跳过其他部分。我还将分享一些代码和生成的示例的链接。

但是在讨论任何细节之前，我想对为此做出贡献的人们表示衷心的感谢。 Alvaro 设计封面图片，Makoto与我分享他的样本库， Nao 在几个场合激励我开始这个项目，最后最重要的是 D.A.V.E. 与我在赛道上的合作(但稍后会有更多)。谢谢你们，你们太棒了！

神经机能障碍的起源

我最初进入电子音乐制作是通过手指打鼓，这仍然是我主要如何定义自己作为一个制作人。所以我最初把深度学习和音乐结合起来的想法其实很不一样。

我不打算制作完整的音轨，甚至不打算制作任何音频。相反，我在考虑现场表演的有趣想法。具体来说，我正在考虑一个系统，它可以确定音频样本之间的相似性，这样我就可以自动将声音替换为其他相似的声音。

举个简单的例子:我可能有一个特殊的军鼓声音，但我想用一个相似但略有不同的声音来代替它。

在一个更具实验性的环境中，我可能想记录我的观众或某个场所的随机声音场景，然后自动从中提取声音来替换我正在使用的实际样本。这样，我就可以从一首完全基于精心制作和人工挑选的样本的曲目逐渐转变为更加有机和随机的曲目，甚至可能与观众互动，这仍然可以保持其原始的声音特征。

除了是一个很酷的性能工具，寻找相似样品的好方法也可以在生产过程中有很大帮助。几乎每个生产者都知道，在不断增长的库中找到完全正确的样本是多么痛苦和耗时的过程，这些样本通常分布在许多随机的目录和嵌套的子目录中。

一年多以前，当我把这个想法告诉 Makoto 的时候，他非常友好地把他的大规模样本库给了我，让我去玩。然而在那个时候，我并没有走得很远。在摆弄了一会儿之后，我又回到了我的老借口上，首先专注于音乐制作本身。

但是现在我终于有了一个很好的理由快速完成一些事情:NIPS 研讨会的最后期限。

然而，我认为我最初的想法是不可能实现的，因为我只有一个月的时间来完成这个项目。深度学习部分不会是一个问题，但为现场表演开发后端和制定一个有趣的例程将需要更多的时间，特别是因为我还没有太多关于 Max for Live (或任何其他可以为此工作的开发环境)的经验。

相反，我决定制作一首歌曲。

我的主要流派是鼓和贝斯。而 Neurofunk 的亚属，鉴于它的名字也是曲目名称的灵感，看起来就像一个完美的匹配。

Neurofunk 通常是鼓和低音的一个黑暗和侵略性的分支。除此之外，它的特点是非常精细和复杂的声音设计，尤其是低音线。最近有一个很好的例子，看看文档一 中的“*LSD”*中 0:44 左右开始的低音。对于更“传统”的神经放克，请查看由 InsideInfo 和mef jus提供的脉动。

这种复杂的声音设计似乎也符合我使用神经网络的意图。然而，大多数 Neurofunk 制作人严重依赖复杂的波表或 FM 合成来精心塑造他们的声音。完全基于样本可能具有挑战性。此外，Neurofunk 往往非常精确和尖锐。我不确定神经网络方法会给我的声音带来这两种属性。

尽管如此，我还是准备迎接挑战。此外，样本只是起点。

虽然我给自己设置了限制，即每个声音都必须来自神经网络生成的样本，但我没有对可以对它们使用的效果或后期处理设置任何限制，给我留下了很多自由来塑造声音。

在这方面，我认为 NeuralFunk 不同于大多数其他人工智能辅助音乐生成的方法。

在许多情况下，人们要么像在 中演奏 RNN ，让 AI 模型通过 MIDI 生成音符序列，要么使用深度学习来合成特定的乐器，像 NSynth 。

通过深度学习合成所有的声音，然后从中产生一首歌曲，这是我迄今为止从未遇到过的事情，尽管如果我是第一个这样做的人，我会感到非常惊讶。虽然这可能是第一首以这种方式创作的鼓与贝斯音轨。

结果显然不是 AI 做的音乐。但它是使用人工智能作为声音设计和探索创造性表达新方法的工具制作的音乐。

深度学习阶段

有了这个非常粗略的想法，下一步就是要弄清楚使用什么样的网络来实际生成样本。

还不太确定我想把这个带向什么方向，我再次从脑那里得到了一些灵感。他有一个 iPython 笔记本，用于根据声谱图进行声音分类。我对声音分类不感兴趣，但我认为一些预处理可能会有用，所以我开始尝试一下，将我库中的一些样本转换成光谱图。

这就是项目 NeuralFunk 真正开始的时候，9 月 21 日有了这个阿门突破的声谱图。

在那之后，我决定从实际的神经网络开始，一个好的(也是很明显的)地方是使用一个基本的 WaveNet ，在我的样本库上训练它，看看会有什么结果。

我从收集不同样本目录中的所有样本开始。主要是 Makoto 的样片，还有我的 Maschine 2 库，还有资料片 共振火焰前景阴霾解码形态 (顺便强烈推荐)。我真的很感谢 Native Instruments，因为他们将样本直接作为 wav 文件提供，而不是深埋在软件中。

然后，我将它们全部转换为 16kHz，并对任何超过 10 秒的部分进行了修整。有一些较长的循环和完整的轨道和茎，但我决定忽略这些，除了他们的开始。

最后，我得到了大约 62，000 个样本(尽管我很久以后才发现，我本可以得到更多的样本，因为我的自动搜索只寻找与。wav”和”。aiff”，漏掉了很多变奏像“的。WAV“，”。aif”等)。

接下来，我采用了 Wavenet 的 TensorFlow 实现，并简单地根据该数据对其进行了训练。考虑到数据的巨大差异，我并不期待惊人的结果，但这是一个开始，值得一试。事实上，我最终得到了一些有趣的结果。尽管正如预期的那样，它主要只是(不完全是随机的)噪音。

为了让 Wavenet 有更好的机会了解它应该生成什么数据，我决定添加一个条件网络。

除了音频文件本身，我还为每个文件的前三秒创建并保存了一个声谱图。我最初的计划是添加一个完整的卷积编码器网络，它将与 Wavenet 端到端地进行训练，将频谱图作为附加输入，并将其压缩为条件向量。

不幸的是，至少在我的快速实验中，这被证明是一项太难的任务，Wavenet 只是在频谱编码器可以学习任何有用的东西之前学会了忽略条件向量。这似乎是太强大的解码器阻止编码器学习的许多情况之一。也许通过一些更好的参数调整，这个过程可以工作。但我没有时间进行大范围的参数搜索。

然而，在摆弄 Wavenet 的同时，我仍然没有放弃寻找样本之间相似性的最初想法。我的想法是，我可以使用 Wavenet 来生成大量的随机样本，然后使用相似性搜索来找到与我喜欢的特定参考声音接近的声音。

所以为了让相似性搜索起作用，我还写了一个变分自动编码器(VAE ),它是在相同的光谱图上训练的。我可以简单地通过比较潜在空间中的距离，使用得到的嵌入来进行相似性搜索。

但是这个模型实际上允许我做更多的事情。

我可以使用 VAE 嵌入作为波网的条件向量，而不是用波网端到端地训练编码器，这样会得到更好的结果。Wavenet 现在清楚地利用了条件信息，它的输出具有它所依赖的声音的许多特征。

但除此之外，我可以使用 VAE 解码器本身来重建频谱图，然后使用 Griffin-Lim 算法来映射回音频。

任何关注过我在 AI 上的文章或者看过我演讲的人都知道我真的很喜欢 VAEs。他们可能是我最喜欢的一类模特。从信息论的角度来看，它们不仅在概念上很漂亮，非常优雅，而且用途极其广泛。

在这里，单个模型允许我创建嵌入，我可以用它来调节另一个模型，使我能够进行高级语义搜索，以及实际上自己生成新的声音。

它也很容易训练，只需要几个小时我的 iMac 的 CPU 就可以收敛。这个模型本身也很简单。这实际上是我第一次从零开始写一个反进化网络，所以我很快就把它拼凑了起来，但它似乎很有效。

鉴于时间短暂，我并不真正关心优化。一旦事情有了转机，我就继续前进。我做的任何事情都不严谨。我甚至没有费心将我的数据分成单独的测试或验证集。

我给 VAE 添加的唯一一个稍微花哨的东西是一些正常化流动层的 T2。再说一次，我的实验并不严谨，但是增加几个流动层似乎可以从质量上得到更好的结果。

我做了 64 维的嵌入(没有原因，只是选择了这个数字作为我的第一个测试，它有点工作，我从来没有尝试过其他任何东西)。但是使用 TSNE，我可以把维度减少到二维来可视化。

原始样本没有任何类别标签，所以我使用文件名提取了一些近似的标签，在名称中查找类似“kick”和“sfx”的单词。结果出乎意料的好。这是我选择的八个类别之一的所有样本的可视化。

实际上，我很惊讶这些簇的效果有多好，以及哪些簇与哪些簇相邻(比如拍手、帽子、军鼓过渡)。

我做了另一个可视化，包括所有的样本(也就是文件名中没有匹配标签的样本)。

结果不是很好，但这可能部分是因为我没有时间或耐心摆弄 TSNE 参数，只是拿了我得到的第一个结果；)

更深入地研究一下细节，甚至直接在二维空间进行嵌入，可能会带来一些有趣的见解，但我会把这些留到以后再说。

VAE 的所有代码，以及一些预处理和其他随机位可以在这里找到。

但是如果你对代码感兴趣，请注意。这不是真的要分享。它非常粗糙，评论很差(如果有的话)，很多东西都硬编码到我的音频处理参数和目录结构中。我可能会在某个时候着手处理这个问题，但是现在要意识到它相当的混乱。

我没有分享我的 Wavenet 代码，因为我尝试的所有更复杂的东西实际上都不工作，而且工作的东西实际上只是对原始实现的一个小修改，它允许直接读取和馈入预先计算的嵌入向量。npy”文件，并使用它们进行调节。

样本生成阶段

所有的模型都准备好了，我可以开始制作一些声音了。

首先是 VAE 和格里芬-林的组合。本质上，它给了我三种发声的方法。

最简单的方法是对声谱图进行编码，再次解码，然后重建音频。这个古钢琴样本就是一个例子。我们可以看到，基频得到了很好的保留，但许多其他细节发生了变化。

这个哔哔声是另一个很好的例子。同样，基本频率和整体轮廓被保留，但很多更好的细节被改变或丢失。

第二种方法是实际上结合两个或更多的嵌入，然后解码产生的潜在代码。一个很好的例子，实际上最终形成了一个主要的旋律元素，就是底鼓和声乐音符的结合。

结果是一个相当不错的和声，但在开始时，踢声增加了一些有趣的 subby 攻击，产生了一个不错的 stabby synth 声音。

这是另一个例子，结合三个不同的输入。

生成的样本是一个踢音，就像其中一个输入一样，但是有很多来自踩镲和 tabla 的有趣字符。

最后，我也可以不需要任何输入，直接从潜在空间简单取样。这导致了许多有趣的结果。

其中一些是清晰可辨的声音类型，而另一些则更加随意和实验性，但作为声音效果仍然有用。

我想说的是，在这一点上，我遵循了一个非常清晰和深思熟虑的产生和设计声音的过程。但是考虑到时间有限，我实际做的是编写一个脚本，从 0 到 3 之间随机选择一个数字，然后从我的库中随机选择这么多输入样本，嵌入它们(或者如果输入样本的数量为零，则从潜在空间中采样一个嵌入)，组合它们，并生成最终的音频。

这样我产生了几千个半随机样本。

我做的最后一件小事是，记录我说“Taktile”(我的艺术家名字)和“NeuralFunk”，然后通过 VAE 解码器和 Wavenet 运行这两个样本，以获得基于每个样本的两个样本。

结果并不真正像人声，但它们作为声音效果进入了轨道(例如，第一次下降时的 techy 声音实际上是“Taktile”样本之一)。

我对 Wavenet 采用了几乎完全相同的方法。

在 0 和 3 之间选择一个随机数，随机选择预先计算的条件嵌入的数量(或从高斯分布中随机采样一个)并将它们组合成一个条件向量，然后让 Wavenet 为每个生成 32，000 个样本(2 秒)。

我又一次用这种方法产生了几百个随机的声音片段。

有趣的是，Wavenet 似乎理解条件反射的一般声音特征，但不理解时间信息。由于它不仅训练了单镜头，还训练了完整的循环和节拍，所以它产生了一些非常有趣的输出。

例如，给定一个单一的打击乐声音作为条件，结果有时实际上是由相似类型的打击乐声音组成的完整节拍(例如，如果条件是在小军鼓上，则是小军鼓节拍)。

如果我继续从事这项工作，我可能想尝试的一件事是，不要对整个频谱图进行编码并将其用作全局条件，而是对单个时间片进行编码，然后将其作为局部条件馈入 Wavenet，以便对声音的时间方面进行更多控制。

但是现在，我仍然有很多有趣的样本可以玩。

对于这两个网络来说，似乎很难产生的一件事是崩溃、打开的踩镲声和其他类似铙钹的声音。我没有特意尝试产生这些，但在我的随机样本中，我没有发现令人信服的钹音。

但我想，鉴于其复杂的声音特征，钹一直是对合成器更具挑战性的声音之一。也许这可以成为未来实验的另一个有趣的方向。Wavenet 在这方面似乎更有前景，因为 VAE 解码器(至少我的 hacky 版本)的升级洗去了所需的更精细的细节。

您可以在这里下载所有样本。zip 文件中有两个目录，分别对应于 Wavenet 和 VAE 样本。

对于 VAE，以“random”开头的文件名是基于我的库中随机样本的文件。那些以“sampled”开头的直接从潜在空间采样的代码中解码。对于每个音频文件，我还包括一个输出频谱图的 png，以及输入频谱图(如果有任何输入)。

Wavenet 目录包含对应于四个不同模型的四个子目录。“generated_1”和“generated_2”是无条件模型，而“generated_emb2”和“generated_emb_big2”是条件模型(末尾的数字是指我用来训练它们的批量)。

对于有条件的文件，文件名包含作为条件的原始文件。例如“generated_emb_big2”中的“emb 2 _ 13727—StylusBD08 023 _ 9519—Kick JunkieXL 3 . wav”是以“stylusbd 08 023”和“Kick JunkieXL 3”两个文件为条件的(其他数字指的是我自己的内部索引系统)。这个特殊的文件实际上是一个很好的例子，其中两个简单的踢音的组合，都是一个镜头，导致一个完整的基于踢的节拍。

你可以随意使用这些样本。如果你因此想出了一些很酷的东西，我很想听听！

生产阶段

生成了成千上万个样本后，终于到了开始制作并把它们变成类似音乐的东西的时候了。

事实上，我也在这个月搬到了一个新公寓。虽然因此损失了相当多的时间，但我至少享受到了在一个崭新的(最初)整洁的工作环境中工作的快乐。

虽然我最近开始更多地进入 Ableton Live，但我决定在 Native Instrument 的 Maschine 中做这个项目，因为这仍然是我迄今为止最舒适和熟悉的 DAW。我只是非常偶尔地切换到生活，因为它的惊人的扭曲工具。

最初的生产阶段相当痛苦。即使我有我的 VAE 作为一个相似性搜索工具，它目前的版本有很多缺点，使它对这项任务相当无用。例如，它只考虑样本的开始。但是特别是在 Wavenet 的情况下，文件中常常隐藏着一些有趣的部分。

出于这个原因，我实际上不得不手动浏览所有的样本，找到有趣的声音。这花了我整整两个晚上的时间，每个晚上花几个小时来检查所有的声音，并把我发现的有趣的声音按照声音类型粗略排序，即打击乐、旋律、无人机、SFX 和低音。然后，我进一步检查了鼓组，并根据鼓的声音类型对每个样本进行了颜色编码，例如，红色代表鼓脚，绿色代表小军鼓，等等。

最后，我把所有的踢腿，陷阱和帽子复制到不同的组，这样我可以在以后一起处理它们。

最后，我有了 20 多个不同的组，每个组有 16 个样本，总共有 320 多个我认为有趣的样本。

但是这还不是乏味的预处理的结束…正如我提到的，有趣的声音通常不在样本的开始。我必须进去分离出我真正想要的部分。

即使是简单的鼓声，看起来是从样本的开头开始的，它们也经常会有一些令人讨厌的伪像，我不得不去掉几毫秒。

接下来是非常粗糙的造型。我是想让声音一次性播放(也就是说，一旦被触发就一直播放)还是 ADSR(当声音不再播放时就逐渐消失)？如果是 ADSR，我必须设置攻击、衰减、持续和释放参数。

此外，相当多的样本，尤其是 VAE 产生的样本，有一些令人不快的高频噪声，因此我应用了一些低通滤波器来消除这些噪声。

最后，为了以一致的调子写这首曲子，在这种情况下(主要是)F 小调，我必须通过单独改变音高来调整旋律样本。

有了这些，几个小时后，基本的准备和预处理终于完成了，我可以开始做音乐了。

我做的第一件事就是布置了一个 阿门破 。我想这么做是因为作为一名鼓手和低音制作人，这是用新声音演奏时最自然的事情。但我也想重新采样，这样我就可以把它切碎，然后作为早餐。

结果是一个相当好听的阿门休息(除了最后一个蹩脚的响钹)。对于附带的图像，我认为这将是一个很好的触摸运行原来的“阿门，兄弟”封面通过deep dream；)

点击此处或下图收听。不幸的是，Instagram 嵌入似乎不起作用，所以我只是链接到它。

接下来，我在周一请了一天假，完全专注于这个项目。我早早起床，精神饱满，冲了杯咖啡，坐在办公桌前。然后…

没什么！不管我做了什么，听起来都很糟糕。我试图开始放下一些鼓，但没有得到任何东西听起来很好。然后我想也许可以从一些旋律开始。或者低音。但是无论我从哪里开始，我就是不能得到任何像样的东西。

我早期尝试更多的声音设计，给样本添加滤镜、效果和调制，听起来也很糟糕。

那天中午左右，我感到完全失去了动力，认为这个项目注定要失败。我决定去散步。

我之前已经提到过步行的创造力。这里再次证明了这一点。当我大约一小时后回来，再次坐在我的办公桌前时，神奇的事情发生了。我完全进入了状态，一切似乎都自然而然地走到了一起。

到了晚上，我并没有真正意识到已经过了很长时间，我已经完成了很多声音设计，并且对音轨有了大致的感觉。我还准备了后来成为引子的大部分内容。

在接下来的几天里，我做了很多微调，并在介绍中加入了额外的元素。但是每当我试图超越它时，我又感到被卡住了。

幸运的是，当我告诉我的好友 D.A.V.E. 这个项目的时候，他立刻表示愿意合作。

D.A.V.E .不仅是一个了不起的 DJ 和制作人，他还是一个很棒的老师，他在这首歌上给了我很多帮助。我强烈推荐看看他的东西，他有一些非常酷的教程和其他东西在不久的将来会出现(我们两个之间甚至可能会有更多的合作)。

[## 数字和黑胶唱片专家

D.A.V.E .是 DJ 兼导师。在所有平台和软件上工作。D.A.V.E 教授 DJ 表演的所有方面和…

www.digitalandvinylexpert.com](https://www.digitalandvinylexpert.com)

因此，在这一点上，已经形成了对赛道的总体想法和感觉，但在其他方面陷入了困境，我将它交给了 D.A.V.E .他立即投入其中，并在第二天向我发送了他的一些想法和想法。

在他加入之前，我特别纠结于介绍之后的结尾。他建议尝试在中场休息时做，几乎给它一种陷阱的感觉，并奠定了一些节拍，我后来建立了。

他还想出了一些 synth 部分，老实说，第一次听我真的觉得有点烦人，但后来我完全喜欢上了，经过一些修改，变成了我最喜欢的元素之一。

这是合作的一个很酷的地方。即使你不总是完全喜欢或同意你的合作者所做的，它也会给你新的想法，帮助你摆脱困境。你可以修改它，让它成为你自己的，最后想出一些你自己做梦也想不到的很酷的东西。

在接下来的几天里，我们来来回回地更新项目。事实上，我们在完全不同的时区(D.A.V.E .在伦敦，我在东京),这对协调工作很有帮助。晚上(我的时间)下班后，我们会通个电话，讨论一下想法，然后我会在赛道上工作几个小时。晚上结束的时候，我会把我最新的版本发给他，第二天早上我起床的时候，他已经给我回复了一些新的想法。

最终，在大约一周的时间里，NeuralFunk 长成现在的样子。这根本不是我在开始这个项目时设想的那种 Neurofunk 曲目，但无论如何它总是意味着在实验方面。

下面是(几乎)最终安排在机械。这绝对是我做过的分组和图案最不同的 Maschine 项目。我糟糕的(或者更确切地说，几乎不存在的)命名方案也无助于这个项目的发展。

有很多事情我想改变或改进，特别是低音和其他低频元素相当混乱，但没有时间了。

所以最后我决定就此结束，尽情享受，尽情享受。要看我现场即兴创作的视频，请点击这里或下面的图片。

总的来说，我认为这个项目非常有趣。老实说，我唯一完全满意的部分是引言，如果有更多的时间，我可能会删除很多东西并重新制作，但考虑到时间限制以及样本本身的实验性质，我认为结果并不太坏。

顺便说一下，这篇文章也是如此。我想尽可能快地把它写下来，并在 NIPS 研讨会的最后期限之前基本上与轨道一起发布，所以它没有经过太多的编辑，并达到我通常写作的目标质量。很抱歉。如果你坚持到这里，谢谢你忍受我的长篇大论！

从现在开始，我可以把它带向很多方向。其中一些我已经在上面提到过了，还有更多的我想到了。

例如，我想改进 VAE 的编码器/解码器架构，从像对待任何其他图像一样对待频谱图的简单(解)卷积网络，到考虑沿两个轴的不同信息的东西。

我还在考虑回到我最初的想法，将相似性搜索(甚至可能是样本生成)集成到一些有趣的现场表演工具中。

但首先，我需要休息一下，补上一些睡眠！

顺便说一下，如果你对我更多的音乐感兴趣，也可以看看我上一首歌，它是用更传统的方式制作的！；)

你觉得这个项目怎么样？知道我下一步该做什么吗？我也很想知道你是否尝试过类似的事情，或者把我的一些想法或样本用在你自己的音乐中。

发挥创造力！

简化的神经网络！

原文：https://towardsdatascience.com/neuralnetworks-implementation-d55cc6fc2f62?source=collection_archive---------7-----------------------

courtesy- here

你等了多久才实现你的第一个人工神经网络，却找不到正确的资源和简单的解释？嗯，在这里。在阅读这篇文章之前，我建议你先了解一下我上一篇文章中的神经网络，这样接下来的解释就很容易理解了。

在深入研究神经网络之前，我想讨论一下神经网络的一般应用，以便回答这个问题- 在现实生活中，我在哪里可以找到适用的神经网络？

courtesy- here

现实生活中的应用:

courtesy- here

你在哪里听说过预测股票市场价格的机器吗？是的，太酷了，不是吗？由于神经网络确实擅长处理复杂数据并帮助分析这些数据，因此股票预测是神经网络无缝工作的应用之一。此类预测型应用，如资产评估、员工工作表现等。大量使用神经网络。
在图像处理和计算机视觉的应用中，神经网络比传统的灰度转换方法有更好的优势，这是最重要的。图像到文本、图像恢复、图像压缩、模式识别或者最著名的所有对象检测和面部识别，仅仅是几个主要的例子。

courtesy- here

3.生成对抗网络( GAN)是神经网络可以自己生成图像的另一个应用。这对于精确的图像生成和两幅图像的合并是非常有益的。这是神经网络的最新应用，并被广泛研究。

4.语音识别、天气预测、指纹识别、手写识别等。还有其他使用神经网络的小规模应用吗？

5.医疗诊断是一种可以利用神经网络进行重大改进的应用。

你能猜出神经网络在你日常生活中的应用吗？

它被你几乎每天使用的手机和应用程序所使用。这就是——手机摄像头中的自动面部识别是卷积神经网络最常用的例子，脸书的自动面部识别和谷歌照片应用程序中的照片都是基于这些卷积神经网络的典范。这里的应用程序列表可以是无止境的。

现在我们知道神经网络是一个大奖！我相信你现在可能对了解神经网络更感兴趣。

如何着手这个博客……

我想阐述一个正常的人工神经网络背后的理论概念和逻辑，以及实际的实现，这实际上加深了我们对理论的理解。因此，我把整个博客分成了实际实现的部分，它背后的理论和用来实现它的逻辑。它都是一个连续流程的实现的一部分，但只是为了更好地理解和关联而对部分进行了区分。

你知道神经网络的想法实际上是怎么产生的吗？

它的灵感来自于我们人类自己的生物神经网络！该工作完全类似于一层又一层神经元的有效工作，以形成生物神经网络。对于人工神经网络来说，流程和操作质量都是从生物神经网络模拟的，因为我们需要建模的基本原理是模拟人脑从示例中学习的功能，正如我在以前的博客 中提到的。

我们就这样开始……

我们使用 Tensorflow 库中从 0 到 9 分类手写数字的最著名的 MNIST 数据集来用 Python 实现 ANN 模型。

前提:

Tensorflow 是 Python 中用于神经网络实现的最有效和最有用的库。我更喜欢用 Jupyter 笔记本来实现。但是你可以使用任何你选择的 IDE——Spyder，Sublime Text 3 等等。

在开始程序之前，我们需要安装 Tensorflow。安装非常容易，可以从这里安装。普通台式机可以下载 CPU 版本。

完整的代码和输出截图可以在我的 github 这里找到。随意叉！

理论和术语:

为了理解这一点，我们需要在这里介绍 4 个基本术语:

感知器:它只不过是一个简单的层神经网络，受一个生物神经元的启发，如下图所示。

courtesy-https://towardsdatascience.com/from-fiction-to-reality-a-beginners-guide-to-artificial-neural-networks-d0411777571b

2。 **输入:**输入无非是我们要馈给网络的数据。通常定义为 x1，x2，…xn。每个输入都是用于确定输出的样本或独立变量。输入可以是任何形式——文本、图像或整个视频。这里我们有手写数字的图像作为输入。

**3。输出:**输出是为激发激活的相应神经元生成的。

4。 **激活功能:**输入信号经过激活功能后，可以进一步被其他层处理或者直接产生输出。激活功能本质上可以被称为用于处理输入以获得输出的处理单元。它用于根据激活功能的类型将输出映射为 0 到 1 或-1 到 1。有各种类型的激活函数，包括 s 形函数、阶跃函数、指数函数等。

输入象征着生物神经元的树突，树突是神经元将信息从一个神经元传输到另一个神经元的接收器。类似地，根据所定义的功能，其他相似之处如下。

courtesy- here

实现:

Import Dependencies

接下来，我们导入我们的依赖项 Tensorflow 和 MNIST 数据，我们将使用这些数据提前进行训练。

Read data

接下来，我们读取数据集并保存到变量“mnist ”,指定 path 作为第一个参数，one_hot 作为 TRUE。现在你可能会想什么是热点。

应用中使用的逻辑:

对于输入:

本质上，在人工神经网络模型实现中，神经元只不过是保存数值的占位符，就像这里一样，我们在神经元中存储了从 0(黑色)到 1(白色)的灰度值。

这些神经元共同形成黑白图像输入。

courtesy-https://gfycat.com/gifs/tag/neural+networks

对于输出:

One_hot 设置为 true，以便在我们获得相应的输出时激活输出节点。

例如，这里我们有 10 个可能结果的总数，因为我们有 0-9 个数字要识别。因此，对于作为输入提供的任何输入图像，对应于由我们的模型识别的每个输出的 10 个神经元中的任何一个都将被点亮。举个例子，

对于数字 0=[1 0 0 0 0 0 0 0 0 0]，

对于数字 1 =[0 1 0 0 0 0 0 0 0 0 0 0]等等…

其中该阵列包含相应输出神经元的一组二进制值。

所以我们得出结论，

神经网络的第一层总是输入层，而最后一层总是输出层。

理论和术语:

那么处理实际发生的中间层呢？

这些层只不过是隐藏层。这是所有魔法的开始！

人工神经网络是受生物神经网络的启发，生物神经网络由多个神经元组成，它们同时工作并协调为我们的身体执行各种任务。因此，为了更好的性能，我们在人工神经网络中也有多层神经元。我们越深入越好，但是对于一个小的数据集来说，这将是一个问题。

那么如何决定要使用的隐藏层数呢？

可以有任意多的隐藏层，但这也取决于数据集的大小。虽然随着网络变得更深，隐藏层的数量越多越好，但对于较小的数据集，这将降低而不是提高精度。

实施:

我们为我们的模型选择了 3 个隐藏层，500，600，300 分别是该层中的节点总数。

Defining total number of nodes in hidden layers

Defining variables

稍后，我们定义输出类的总数、批量大小和张量(占位符),以变量的形式定义输入 x 和输出 y。

应用中使用的逻辑:

处理隐藏图层:

类似于生物神经元，在 ANN 中，具有特定灰度值的 784 个输入神经元仅触发(触发)下一个隐藏层中的特定神经元，这又会触发下一个隐藏层中的一些模式，并最终触发输出层中的特定模式。网络选择最亮的神经元作为最终输出。

courtesy- here

本质上，隐藏层的作用是将数字分成单独的环和线，形成数字。例如，下面我们看到 9 有一个环和一条线，它们组合在一起形成数字。因此，在不同的层产生特定的图案，这不同于为具有 2 个循环的 8 产生的图案。因此，我们需要更深的网络来识别具有不同特征和巨大图像的更大数据集的关键模式。

courtesy- here

简而言之:

像素— >边缘— >图案— >数字

理论和术语:

现在，我们如何让我们的模型只激发特定模式的特定神经元？

答案是通过使用“权重”和“偏见”。

**5。权重:**权重不过是生物神经元中的轴突。我们在图像中看到的轴突用于将信息从一个神经元传递到另一个神经元。它只不过是连接环节。这是一个非常重要的信息，因为权重决定了要传递的信号的激发和抑制。简单地说，它遵循奖惩方式，即兴奋引起一个神经元激活另一个神经元，反之则抑制。这与神经网络中信息的生物传递是一样的。

**6。偏置:**它可以被视为一个开关，这个开关总是打开的，也就是说它的值总是 1。基本的想法是，人类神经元接受一堆输入并将它们“相加”在一起。如果输入的总和大于某个阈值，那么该神经元将“触发”(产生一个输出到其他神经元)。这个阈值本质上与偏差是一回事。因此，通过这种方式，人工神经网络中的偏差有助于复制真实的人类神经元的行为。

实施:

因此，我们首先为每个隐藏层和输出层定义随机权重和偏差，以确定该层的神经元总数。

Define weights and biases

定义完所有变量后，我们开始使用权重和偏差定义模型和各层的功能。

Activation function

应用中使用的逻辑:

对于该层中的给定模式，我们分配某些正权重来激励/激发神经元，分配负权重来抑制/停止激发神经元。

为了以数学方式计算这些值，我们将输入乘以整个图层的相应权重，最后将其与偏差相加:

加权总和=(权重输入)+偏差*

然后，我们将这个加权和馈送给被称为“RELU”的激活函数，该激活函数被称为整流线性单元。激活的阈值简单地为零。

它计算函数 f ( x )=max(0， x )。这是深度学习中最常用的激活功能，因为它大大加速了训练部分。

理论和术语:

那么“深度学习”这里的学习部分到底在哪里呢？

如果你还记得，我们最初初始化了随机权重和偏差，因为我们在开始时没有意识到它们。

我们的最终目标是最小化预测输出时引起的误差。因此，学习特别意味着以误差最小化的方式来确定这些权重和偏差。这是由优化器完成的。

这里，我们使用 Adam Optimizer 优化我们的模型，以最小化成本。Adam Optimizer 使用随机梯度方法来优化我们的模型。使用不同的方法还有各种其他的优化器。

实施:

定义模型后的最后一部分是定义模型应该如何训练。

我们预测每个输入 x 的输出，然后通过将预测值与数据集中标记的正确值 y 进行比较来确定模型的成本/误差。

Prediction of output

我们定义用于循环的会话，直到达到总的历元数。我们一起批量训练输入并运行优化器。

最后，我们使用“正确的”变量来对照期望值检查预测输出的 one_hot 值。

最后通过计算和打印模型的精度来验证模型的有效性。

最后一行是用输入 x 和输出 y 调用训练函数来启动训练。

应用中使用的逻辑:

我们的模型自己训练多长时间？

该模型保持训练，直到误差达到预定义的阈值，或者通过定义所需的总时期(循环)。

我们可以调整许多参数，如隐藏层数、节点数或使用的优化器等。检查并降低错误率。

本质上，神经网络的工作可以概括为:

Summarizing the process

courtesy- here

唷！这对初学者来说有点难，不是吗？

我知道开始时的感觉:/

但是相信我，一旦我们在练习后彻底掌握了它，一切都会变得很简单。如有任何疑问，请在下面评论。让我知道你对这篇文章的看法，以及你希望我接下来发表的任何话题。

NIPS/NeurIPS 2018:前两次海报会议的最佳*

原文：https://towardsdatascience.com/neurips-2018-reading-list-from-tue-poster-sessions-a-b-fce561e56be8?source=collection_archive---------13-----------------------

Photo by Rohan Makhecha on Unsplash

NeurIPS 是一个伟大的会议，吸引了机器学习研究几乎每个方面的最新技术。

在会议中，该领域的研究人员当然应该注意一些事情。在我看来，这些东西会把类似的研究文章聚集成这些组。 理解，二。必需品，3。进步，4。大问题/未来

所以，我把所有我认为有影响的事情归为这些类别。这些是 neur IPS 2018 A&B 周二海报会议的海报及其摘要。

1.谅解

甘人生而平等吗？大规模研究

回顾

尽管大量的研究活动产生了许多有趣的 GAN 算法，但仍然很难评估哪些算法的性能优于其他算法。我们对最先进的模型和评估方法进行了中立的、多方面的大规模实证研究。我们发现，通过足够的超参数优化和随机重启，大多数模型都可以达到相似的分数。这表明，除了基本的算法变化之外，更高的计算预算和调整也能带来改进。为了克服当前度量的一些限制，我们还提出了几个数据集，在这些数据集上可以计算精度和召回率。我们的实验结果表明，未来的氮化镓研究应基于更系统和客观的评估程序。最后，我们没有发现任何测试算法始终优于在{ cite good fellow 2014 generate }中介绍的不饱和 GAN 的证据。

卷积神经网络的一个有趣的失败和 CoordConv 解决方案

有意思，时间差不多了

我们已经展示了 CNN 对坐标转换任务建模的奇怪无能，展示了 CoordConv 层形式的简单修复，并给出了表明包括这些层可以在广泛的应用中提高性能的结果。在 GAN 中使用 CoordConv 产生的模式崩溃更少，因为高级空间延迟和像素之间的转换变得更容易学习。在 MNIST 检测上训练的更快的 R-CNN 检测模型显示，当使用 CoordConv 时，IOU 提高了 24%,并且在强化学习(RL)领域中，玩 Atari 游戏的代理从 CoordConv 层的使用中显著受益。

具有稀疏和量化通信的分布式深度学习的线性加速分析

效率

巨大的通信开销已经成为分布式随机梯度下降(SGD)训练深度神经网络的性能瓶颈。先前的工作已经证明了使用梯度稀疏化和量化来降低通信成本的潜力。然而，对于稀疏和量化通信如何影响训练算法的收敛速度，仍然缺乏了解。本文研究了非凸优化的分布式 SGD 在两种减少通信量的策略下的收敛速度:稀疏参数平均和梯度量化。我们证明了如果稀疏化和量化超参数配置得当，可以达到 O (1/√ MK )的收敛速度。我们还提出了一种称为周期量化平均(PQASGD)的策略，在保持 O (1/√ MK )收敛速度的同时，进一步降低了通信开销。我们的评估验证了我们的理论结果，并表明我们的 PQASGD 可以像全通信 SGD 一样快地收敛，而通信数据大小仅为 3 %- 5%。

关于单词嵌入的维度

授权

在本文中，我们提供了一个单词嵌入及其维度的理论理解。受单词嵌入酉不变性的启发，我们提出了一种新的度量单词嵌入不相似性的方法——成对内积损失。使用来自矩阵扰动理论的技术，我们揭示了在单词嵌入的维度选择中的基本偏差-方差权衡。这种偏差-方差的权衡揭示了许多以前无法解释的经验观察，例如最佳维度的存在。此外，揭示了新的见解和发现，如词嵌入何时以及如何对过拟合具有鲁棒性。通过优化 PIP 损失的偏差-方差权衡，我们可以明确地回答用于单词嵌入的维度选择的公开问题。

欺骗计算机视觉和限时人类的对立例子

基本面

机器学习模型容易受到对抗性例子的影响:图像的微小变化可能导致计算机视觉模型出错，例如将校车识别为鸵鸟。然而，人类是否容易犯类似的错误仍然是一个悬而未决的问题。在这里，我们通过利用最近的技术来解决这个问题，这些技术将来自具有已知参数和架构的计算机视觉模型的对立示例转移到具有未知参数和架构的其他模型，并且通过匹配人类视觉系统的初始处理来解决这个问题。我们发现，在计算机视觉模型中强烈传递的对立例子会影响受时间限制的人类观察者所做的分类。

树状皮质微电路近似反向传播算法

洞察

深度学习在过去几年中取得了显著的发展，其中许多都是受神经科学的启发。然而，这些进步背后的主要学习机制——错误反向传播——似乎与神经生物学不一致。在这里，我们介绍了一个多层神经元网络模型，该模型具有简化的树突区室，其中错误驱动的突触可塑性使网络适应全局期望的输出。与以前的工作相比，我们的模型不需要单独的阶段，突触学习是由局部树突预测误差在时间上连续驱动的。这种错误起源于顶端树突，是由于来自外侧中间神经元的预测输入和来自实际自上而下反馈的活动之间的不匹配而发生的。通过使用简单的树突隔室和不同的细胞类型，我们的模型可以代表锥体神经元内的错误和正常活动。我们证明了该模型在回归和分类任务中的学习能力，并分析表明它近似于误差反向传播算法。此外，我们的框架与最近对大脑区域和皮质微电路结构之间学习的观察一致。总的来说，我们介绍了一种关于树突皮层回路学习的新观点，以及大脑如何解决长期存在的突触信用分配问题。

关于神经元容量

新颖的提法

我们将学习机的能力定义为它能够实现的功能数量(或容量)的对数。我们回顾了已知的结果，并得出了新的结果，估计了几种神经元模型的容量:线性和多项式阈值门，带约束权重(二进制权重，正权重)的线性和多项式阈值门，以及 ReLU 神经元。我们还推导了完全递归网络和分层前馈网络的容量估计和界限。

深度生成模型中的偏差和泛化:一项实证研究

真正的理解

在高维设置中，密度估计算法主要依赖于它们的归纳偏差。尽管最近取得了经验上的成功，但深度生成模型的归纳偏见并没有得到很好的理解。在本文中，我们提出了一个框架，通过使用精心设计的训练数据集探索学习算法，来系统地研究图像深度生成模型中的偏差和泛化。通过测量学习分布的属性，我们能够发现有趣的概括模式。我们验证这些模式在数据集、通用模型和架构之间是一致的。

批处理规范化如何帮助优化？

视角

批处理规范化(BatchNorm)是一种广泛采用的技术，能够更快更稳定地训练深度神经网络(DNNs)。尽管 BatchNorm 无处不在，但它有效的确切原因仍然知之甚少。普遍认为，这种有效性源于在训练期间控制层的输入分布的变化，以减少所谓的“内部协变量移位”。在这项工作中，我们证明了层输入的这种分布稳定性与 BatchNorm 的成功几乎没有关系。相反，我们揭示了 BatchNorm 对训练过程的一个更基本的影响:它使优化前景明显更加平滑。这种平滑导致梯度的更具预测性和稳定性的行为，从而允许更快的训练。

基于神经样本的概率群体代码

神经编码

感觉处理通常被描述为实现概率推理:神经元网络在给定感觉输入的情况下，对未观察到的原因计算后验信念。这些信念是如何通过神经反应计算和表示的，这是一个很有争议的问题(Fiser et al. 2010，Pouget et al. 2013)。一个主要的争论是关于神经反应是否代表潜在变量的样本(Hoyer & Hyvarinnen 2003)或其分布的参数(Ma 等人 2006)的问题，并努力区分它们(Grabska-Barwinska 等人 2013)。一个单独的辩论解决了神经反应是否与编码概率成比例相关(Barlow 1969)，或者与这些概率的对数成比例(Jazayeri & Movshon 2006，Ma 等人 2006，Beck 等人 2012)的问题。在这里，我们证明了这些选择——与通常的假设相反——并不是相互排斥的，而且同一个系统可以兼容所有的选择。作为一个主要的分析结果，我们表明，将 V1 区域的神经反应建模为来自图像的线性高斯模型中潜伏期的后验分布的样本，意味着这些神经反应形成了线性概率群体代码(PPC，m a 等人，2006)。特别地，在一些实验者定义的变量如“方向”上的后验分布是指数族的一部分，其具有在基于神经采样的发放率中呈线性的足够统计量。

2.必需品；要素

通过稳健的近似重要性采样更快地训练深度模型

解决方案

理论上，重要性采样通过对训练样本进行优先排序来加速监督学习的随机梯度算法。实际上，计算重要性的成本极大地限制了重要性抽样的影响。我们提出了一种用于随机梯度去噪的鲁棒的近似重要性采样过程(RAIS)。通过使用稳健优化来近似理想的采样分布，RAIS 以大幅降低的开销提供了精确重要性采样的许多好处。根据经验，我们发现 RAIS-新加坡元和标准新加坡元遵循相似的学习曲线，但 RAIS 在这些路径上走得更快，实现了至少 20%的加速，有时甚至更多。

DropMax:自适应变分 Softmax

优雅

我们提出了 DropMax，一个随机版本的 softmax 分类器，它在每次迭代中根据每个实例自适应决定的丢弃概率丢弃非目标类。具体来说，我们在类输出概率上覆盖二进制掩蔽变量，这是通过变分推理输入自适应学习的。这种随机正则化具有从具有不同决策边界的指数级分类器中构建集成分类器的效果。此外，对每个实例上的非目标类的辍学率的学习允许分类器更多地关注针对最混乱的类的分类。我们在多个用于分类的公共数据集上验证了我们的模型，在该数据集上，它获得了比常规 softmax 分类器和其他基线显著提高的准确性。对学习到的丢弃概率的进一步分析表明，我们的模型在执行分类时确实更经常地选择混淆类。

如何开始训练:初始化和架构的效果

效用

我们识别并研究了两种常见的深层网络早期训练失败模式。对于每一种情况，我们都给出了严格的证明，说明在全连接、卷积和剩余架构中，这种情况何时发生以及如何避免。我们证明，第一种失效模式，即爆炸或消失的平均激活长度，可以通过初始化方差为 2/扇入的对称分布的权重来避免，对于 ResNets，可以通过正确缩放剩余模块来避免。我们证明，一旦避免了第一种失效模式，第二种失效模式，即激活长度的指数大方差，就不会出现在剩余网络中。相比之下，对于完全连接的网络，我们证明这种故障模式可能发生，并通过保持层宽度的倒数之和不变来避免。我们从经验上证明了我们的理论结果在预测网络何时能够开始训练方面的有效性。特别是，我们注意到许多流行的初始化不符合我们的标准，而正确的初始化和架构允许训练更深层次的网络。

通过激活样本方差的方差进行正则化

简单而不平凡

规范化技术在支持深度神经网络的高效且通常更有效的训练中起着重要作用。虽然传统的方法显式归一化的激活，我们建议添加一个损失项代替。这个新的损失项鼓励激活的方差保持稳定，而不是从一个随机小批量到下一个随机小批量变化。最后，我们能够将新的正则项与 batchnorm 方法联系起来，这为它提供了正则化的视角。我们的实验表明，对于 CNN 和全连接网络，在准确性上比 batchnorm 技术有所提高。

Mesh-TensorFlow:超级计算机的深度学习

解决方案

批处理分裂(数据并行)是主要的分布式深度神经网络(DNN)训练策略，因为它的普遍适用性及其对单程序多数据(SPMD)编程的适应性。然而，批量分割存在一些问题，包括无法训练非常大的模型(由于内存限制)、高延迟以及小批量时效率低下。所有这些都可以通过更通用的分布策略(模型并行)来解决。不幸的是，有效的模型并行算法往往难以发现、描述和实现，尤其是在大型集群上。我们介绍网格张量流，这是一种用于描述一般分布式张量计算的语言。在数据并行性可以被视为沿着“批处理”维度拆分张量和操作的情况下，在 Mesh-TensorFlow 中，用户可以指定要在多维处理器网格的任何维度上拆分的任何张量维度。一个网格张量流图编译成一个 SPMD 程序，该程序由并行操作和集体通信原语(如 Allreduce)组成。我们使用 Mesh-TensorFlow 来实现变压器序列到序列模型的高效数据并行、模型并行版本。使用多达 512 个核心的 TPU 网格，我们训练了多达 50 亿个参数的变压器模型，超过了 SOTA 在 WMT 的 14 个英语到法语翻译任务和 10 亿词语言建模基准上的结果。Mesh-Tensorflow 在 https://github.com/tensorflow/mesh[可用](https://github.com/tensorflow/mesh)

结构感知卷积神经网络

现实世界

卷积神经网络(CNN)固有地受制于不变的滤波器，该滤波器只能聚集具有相同拓扑结构的局部输入。这导致 CNN 被允许管理具有欧几里得或网格状结构的数据(例如，图像)，而不是具有非欧几里得或图形结构的数据(例如，交通网络)。为了扩大细胞神经网络的范围，我们开发了结构感知卷积来消除不变性，产生了处理欧几里德和非欧几里德结构化数据的统一机制。在技术上，结构感知卷积中的滤波器被推广到单变量函数，其能够聚集具有不同拓扑结构的局部输入。由于确定一个单变量函数需要无限个参数，我们在函数逼近理论的背景下用编号的可学习参数来参数化这些滤波器。通过用结构感知卷积代替细胞神经网络中的经典卷积，很容易建立结构感知卷积神经网络。在 11 个数据集上的大量实验有力地证明了 SACNNs 在各种机器学习任务上优于当前的模型，包括图像分类和聚类、文本分类、基于骨架的动作识别、分子活动检测和出租车流量预测。

可视化神经网络的损失情况

视角

神经网络训练依赖于我们找到高度非凸损失函数的“好”极小值的能力。众所周知，某些网络架构设计(例如，跳过连接)产生更容易训练的损失函数，并且精心选择的训练参数(批量大小、学习率、优化器)产生更好地概括的最小化器。然而，这些差异的原因，以及它们对潜在损失状况的影响，并没有得到很好的理解。在本文中，我们探讨了神经损失函数的结构，以及损失景观对泛化的影响，使用了一系列可视化方法。首先，我们引入一个简单的“滤波归一化”方法，帮助我们可视化损失函数曲率，并在损失函数之间进行有意义的并排比较。然后，使用各种可视化，我们探索网络架构如何影响损失景观，以及训练参数如何影响最小化器的形状。

用混合块浮点训练 DNNs】

渴望解决

DNNs 的广泛采用催生了无情的计算需求，迫使数据中心运营商采用特定领域的加速器来培训他们。这些加速器通常采用密集的全精度浮点运算，以最大限度地提高单位面积的性能。正在进行的研究工作试图通过用定点运算取代浮点运算来进一步提高性能密度。然而，这些尝试的一个重大障碍是定点的狭窄动态范围，这对于 DNN 训练收敛来说是不够的。我们认为块浮点(BFP)是一种很有前途的替代表示法，因为它具有很宽的动态范围，并且能够用定点逻辑执行大多数 DNN 运算。不幸的是，BFP 单独引入了几个限制，妨碍了它的直接应用。在这篇文章中，我们介绍了 HBFP，一种混合的 BFP-FP 方法，它在 BFP 中执行所有的点积操作，在浮点中执行其他操作。HBFP 提供了两个世界的精华:浮点的高精度和定点的高硬件密度。对于各种型号，我们显示 HBFP 匹配浮点精度，同时支持硬件实施，提供高达 8.5 倍的高吞吐量。

FRAGE:频率不可知的单词表示法

有趣的

连续单词表示(也称为单词嵌入)是在自然语言处理任务中使用的许多基于神经网络的模型中的基本构件。尽管人们普遍认为语义相似的词在嵌入空间中应该彼此靠近，但我们发现在几个任务中学习到的词嵌入偏向于词频:高频词和低频词的嵌入位于嵌入空间的不同子区域，一个稀有词和一个流行词的嵌入即使语义相似也可能彼此远离。这使得学习的单词嵌入无效，特别是对于罕见的单词，因此限制了这些神经网络模型的性能。为了缓解这一问题，本文提出了一种简洁、简单而有效的对抗训练方法来模糊高频词和低频词嵌入之间的界限。我们在四个自然语言处理任务的十个数据集上进行了全面的研究，包括单词相似度、语言建模、机器翻译和文本分类。结果表明，我们在所有任务中都取得了比基线更高的性能。

语音和文本嵌入空间的无监督跨模态对齐

在核心处

最近的研究表明，从不同语言的文本语料库中学习的单词嵌入空间可以在没有任何并行数据监督的情况下对齐。受无监督跨语言单词嵌入成功的启发，本文的目标是在无监督方式下学习语音和文本嵌入空间之间的跨模态对齐。所提出的框架学习单独的语音和文本嵌入空间，并试图通过对抗训练来对齐这两个空间，随后是细化过程。我们展示了如何使用我们的框架来执行口语单词分类和翻译的任务，并且在这两个任务上的实验结果表明，我们的无监督对齐方法的性能与其有监督的方法相当。我们的框架对于为低资源或零资源语言开发自动语音识别(ASR)和语音到文本翻译系统特别有用，这些语言几乎没有用于训练现代监督 ASR 和语音到文本翻译模型的并行音频-文本数据，但占世界上使用的大多数语言。

紧凑广义非局域网络

清洁

非局部模块被设计用于捕获图像和视频中的长程时空依赖性。尽管它表现出了出色的性能，但它缺乏对跨通道位置之间的交互进行建模的机制，而这对于识别细粒度的对象和动作至关重要。为了解决这个限制，我们推广了非局部模块，并且考虑了任意两个通道的位置之间的相关性。该扩展利用了具有泰勒展开的多个核函数的紧凑表示，这使得广义非局部模块成为快速和低复杂度的计算流程。此外，我们在通道组内实现了我们的广义非局部方法以简化优化。实验结果表明，广义非局部模块在细粒度对象识别和视频分类方面都有明显的改进和实用性。代码可在:https://github.com/KaiyuYue/cgnl-network.pytorch获得。

3.进步

使用椭圆分布的 Wasserstein 空间概括点嵌入

拉伸

一种新的嵌入框架，它是数值灵活的，并且扩展了 wessserstein 空间中的点嵌入、椭圆嵌入。Wasserstein 椭圆嵌入更直观，并且产生比具有 Kullback-Leibler 散度的高斯嵌入的替代选择在数值上表现更好的工具。本文通过将椭圆嵌入用于可视化、计算词的嵌入以及反映蕴涵或上下级关系来展示椭圆嵌入的优点。

鱼网:图像、区域和像素级预测的多功能支柱

基本面

设计卷积神经网络(CNN)结构以预测不同级别(例如图像级别、区域级别和像素级别)上的对象的基本原理是不同的。通常，专门为图像分类设计的网络结构被直接用作包括检测和分割在内的其他任务的默认主干结构，但是很少有主干结构是在考虑统一为像素级或区域级预测任务设计的网络的优点的情况下设计的，这些预测任务可能需要具有高分辨率的非常深的特征。朝着这个目标，我们设计了一个类似鱼的网络，称为鱼网。在 FishNet 中，所有分辨率的信息都被保留下来，并为最终任务进行优化。此外，我们观察到现有的工作仍然不能直接将梯度信息从深层传播到浅层。我们的设计可以更好的处理这个问题。已经进行了大量的实验来证明鱼网的卓越性能。特别是在 ImageNet-1k 上，FishNet 的精度能够以较少的参数超越 DenseNet 和 ResNet 的性能。渔网被用作 COCO Detection 2018 挑战赛获奖作品的模块之一。该代码可在 https://github.com/kevin-ssy/FishNet 的获得。

通过自解释神经网络实现强大的可解释性

没有副作用

最近关于复杂机器学习模型的可解释性的工作主要集中在围绕特定预测估计先前训练的模型的后验解释。自我解释模型的可解释性在学习过程中已经发挥了关键作用，但却很少受到关注。我们提出了一般解释的三个要求——明确性、忠实性和稳定性——并表明现有的方法不能满足它们。作为回应，我们分阶段设计自我解释模型，逐步将线性分类器推广到复杂但在架构上明确的模型。忠实性和稳定性是通过专门为这些模型定制的正则化来实现的。各种基准数据集的实验结果表明，我们的框架为协调模型复杂性和可解释性提供了一个有希望的方向。

关系递归神经网络

革命性

基于记忆的神经网络通过利用长时间记忆信息的能力来模拟时态数据。然而，还不清楚他们是否也有能力用他们记忆的信息进行复杂的关系推理。在这里，我们首先确认我们的直觉，即标准内存架构可能会在大量涉及理解实体连接方式的任务中挣扎，即，涉及关系推理的任务。然后，我们通过使用一种新的内存模块(关系内存核心(RMC))来改善这些缺陷，这种内存模块采用多头点积注意力来允许内存进行交互。最后，我们在一组任务上测试了 RMC，这些任务可能受益于跨顺序信息的更有能力的关系推理，并显示了在 RL 域(BoxWorld & Mini PacMan)、程序评估和语言建模方面的巨大收益，在 WikiText-103、Project Gutenberg 和 GigaWord 数据集上实现了最先进的结果。

基于神经样本的概率人口代码

寻求力量

神经符号 VQA:从视觉和语言理解中解开推理

包罗万象

我们结合了两个强大的想法:用于视觉识别和语言理解的深度表示学习，以及用于推理的符号程序执行。我们的神经符号视觉问题回答(NS-VQA)系统首先从图像中恢复结构场景表示，并从问题中恢复程序轨迹。然后，它对场景表示执行程序以获得答案。将符号结构作为先验知识提供了三个独特的优势。首先，在符号空间上执行程序对于长程序跟踪更健壮；我们的模型可以更好地解决复杂的推理任务，在 CLEVR 数据集上达到 99.8%的准确率。第二，该模型在数据和内存方面效率更高:它在对少量训练数据进行学习后表现良好；它还可以将图像编码成紧凑的表示形式，比现有的离线问答方法需要更少的存储空间。第三，符号程序执行为推理过程提供了完全的透明性；因此，我们能够解释和诊断每个执行步骤。

用少量样本克隆神经声音

人工需要

语音克隆是个性化语音界面非常需要的功能。我们介绍了一个神经声音克隆系统，它可以学习仅从几个音频样本中合成一个人的声音。我们研究两种方法:说话人适应和说话人编码。说话人自适应基于对多说话人生成模型的微调。说话人编码基于训练单独的模型来直接推断新的说话人嵌入，其将被应用于多说话人生成模型。在语音的自然性和与原说话人的相似性方面，两种方法都可以达到良好的性能，即使有一些克隆音频。虽然说话者自适应可以实现稍微更好的自然性和相似性，但是说话者编码方法的克隆时间和所需的内存明显更少，这使得它更有利于低资源部署。

神经算术逻辑单元

正常

神经网络可以学习表示和操作数字信息，但它们很少在训练期间遇到的数值范围之外进行推广。为了鼓励更系统的数值外推，我们提出了一种架构，将数值表示为线性激活，使用原始算术运算符操纵，由学习门控制。我们称这个模块为神经算术逻辑单元(NALU)，类似于传统处理器中的算术逻辑单元。实验表明，NALU 增强的神经网络可以学习跟踪时间，对数字图像执行算术，将数字语言翻译成实值标量，执行计算机代码，并对图像中的对象进行计数。与传统架构相比，我们在训练期间遇到的数值范围内外都获得了显著更好的概括，通常外推超出训练数值范围的数量级。

4.大问题/未来

在知识图上嵌入逻辑查询

少数民族方法

学习知识图的低维嵌入是一种用于预测实体之间未观察到的或缺失的边的强大方法。然而，该领域的一个公开挑战是开发能够超越简单边缘预测并处理更复杂逻辑查询的技术，这可能涉及多个未观察到的边缘、实体和变量。例如，给定一个不完整的生物学知识图表，我们可能想要预测“什么药物可能针对与 X 和 Y 疾病都相关的蛋白质？”—需要对可能与疾病 X 和 y 相互作用的所有可能蛋白质进行推理的查询。这里，我们介绍了一个框架，以在不完整的知识图上有效地对合取逻辑查询进行预测，这是一个灵活但易于处理的一阶逻辑子集。在我们的方法中，我们在低维空间中嵌入图节点，并在该嵌入空间中将逻辑运算符表示为学习到的几何运算(例如，平移、旋转)。通过在低维嵌入空间内执行逻辑运算，我们的方法实现了与查询变量的数量成线性的时间复杂度，相比之下，基于简单枚举的方法需要指数复杂度。我们在两个对具有数百万关系的真实世界数据集的应用研究中展示了该框架的效用:预测药物-基因-疾病相互作用网络中的逻辑关系，以及来自流行网络论坛的基于图形的社会相互作用表示。

作为多目标优化的多任务学习

整个交易

在多任务学习中，多个任务被联合解决，在它们之间共享归纳偏差。多任务学习本质上是一个多目标的问题，因为不同的任务可能会发生冲突，需要进行权衡。一个常见的折衷方案是优化一个代理目标，使每个任务损失的加权线性组合最小化。但是，这种解决方法仅在任务不竞争时有效，这种情况很少发生。在本文中，我们明确地将多任务学习视为多目标优化，总目标是找到一个帕累托最优解。为此，我们使用在基于梯度的多目标优化文献中开发的算法。这些算法不能直接应用于大规模学习问题，因为它们与梯度的维度和任务的数量的比例很差。因此，我们提出了一个多目标损失的上限，并表明它可以有效地优化。我们进一步证明，在现实的假设下，优化这个上限会产生一个帕累托最优解。我们将我们的方法应用于各种多任务深度学习问题，包括数字分类、场景理解(联合语义分割、实例分割和深度估计)和多标签分类。我们的方法比最近的多任务学习公式或每任务训练产生更高性能的模型。

RenderNet:一个深度卷积网络，用于 3D 形状的可区分渲染

迫在眉睫

传统的计算机图形渲染流水线被设计用于以高性能从 3D 形状程序化地生成 2D 图像。由于离散操作(如可见性计算)导致的不可微性使得很难显式地将渲染参数与结果图像相关联，这给逆向渲染任务带来了巨大的挑战。最近关于可微绘制的工作通过为不可微操作设计代理梯度或者通过近似但可微的渲染器来实现可微性。然而，这些方法在处理遮挡时仍然受到限制，并且局限于特定的渲染效果。我们提出了 RenderNet，一个可区分的渲染卷积网络，它具有一个新颖的投影单元，可以从 3D 形状渲染 2D 图像。空间遮挡和阴影计算在网络中自动编码。我们的实验表明，RenderNet 可以成功地学习实现不同的着色器，并可以用于反向渲染任务，以从单幅图像中估计形状、姿态、光照和纹理。

e-SNLI:带有自然语言解释的自然语言推理

大梦想

为了让机器学习获得广泛的公众采用，模型必须能够为其决策提供可解释的和可靠的解释，并在训练时从人类提供的解释中学习。在这项工作中，我们扩展了斯坦福自然语言推理数据集，增加了一层对蕴涵关系的人类注释的自然语言解释。我们进一步实现模型，将这些解释合并到它们的训练过程中，并在测试时输出它们。我们展示了我们的解释语料库(我们称之为 e-SNLI)如何用于各种目标，例如获得模型决策的完整句子证明，改进通用句子表示和转移到域外 NLI 数据集。因此，我们的数据集为使用自然语言解释开辟了一系列研究方向，既用于改进模型，也用于维护模型的可信度。

用于视觉和语言导航的说话者跟随模型

未来

由自然语言指令引导的导航为指令追随者提出了一个具有挑战性的推理问题。自然语言指令通常只识别一些高级决策和地标，而不是完整的低级运动行为；许多缺失的信息必须基于感知环境来推断。在机器学习设置中，这具有双重挑战性:很难收集足够的注释数据来从头开始学习这个推理过程，并且也很难使用通用序列模型来实现推理过程。在这里，我们描述了一种视觉和语言导航的方法，该方法利用嵌入式扬声器模型解决了这两个问题。我们使用这个说话者模型来(1)合成用于数据扩充的新指令，以及(2)实现语用推理，语用推理评估候选动作序列如何解释指令。这两个步骤都由全景动作空间支持，该空间反映了人类生成的指令的粒度。实验表明，这种方法的所有三个组成部分——说话者驱动的数据增强、语用推理和全景动作空间——都显著提高了基线指令跟随器的性能，在标准基准上比现有的最佳方法的成功率高出一倍以上。

神经代码理解:代码语义的可学习表示

炼金术

随着嵌入在自然语言处理中最近的成功，已经进行了将类似方法应用于代码分析的研究。大多数作品试图直接处理代码或使用句法树表示法，将其视为用自然语言编写的句子。然而，由于诸如函数调用、分支和可互换的语句顺序等结构特征，现有的方法都不足以鲁棒地理解程序语义。在本文中，我们提出了一种新的处理技术来学习代码语义，并将其应用于各种程序分析任务。特别是，我们规定一个健壮的代码分布假设适用于人和机器生成的程序。根据这个假设，我们基于独立于源编程语言的代码的中间表示(IR)来定义嵌入空间 inst2vec。我们为这个 IR 提供了一个新颖的上下文流定义，利用了程序的底层数据流和控制流。然后，我们使用类比和聚类对嵌入进行定性分析，并评估在三个不同的高级任务上学习到的表征。我们表明，即使没有微调，单个 RNN 架构和固定的 inst2vec 嵌入也优于专门的性能预测方法(计算设备映射、最佳线程粗化)；以及来自原始代码(104 个类)的算法分类，其中我们设置了一个新的最先进的状态

海马-内嗅系统结构知识的概括

登月

理解智力的一个中心问题是概括的概念。这使得先前学习的结构被用来解决特殊情况下的新任务。我们从神经科学中获得灵感，特别是已知对归纳很重要的海马-内嗅系统。我们建议，为了概括结构知识，世界结构的表示，即世界中的实体如何相互联系，需要与实体本身的表示分开。我们表明，在这些原则下，嵌入了层次结构和快速 Hebbian 记忆的人工神经网络可以学习记忆的统计和概括结构知识。反映大脑中发现的空间神经元表现出现，表明空间认知是更普遍的组织原则的一个实例。我们进一步统一了许多内嗅细胞类型作为构建转换图的基函数，并表明这些表示有效地利用了记忆。我们实验性地支持模型假设，显示了跨环境的内嗅网格和海马位置细胞之间保存的关系。

你想去哪里？:从行为中推断关于动力学的信念

内部构件

在贝叶斯逆规划和逆强化学习的框架内，从观察到的行为推断意图已经得到了广泛的研究。这些方法推断出一个目标或奖励函数，它能最好地解释被观察主体的行为，通常是一个人类演示者。另一个代理可以使用这个推断的意图来预测、模仿或帮助人类用户。然而，逆向强化学习的一个核心假设是，演示器接近最优。虽然存在次优行为模型，但它们通常假设次优行为是某种随机噪声或已知认知偏差(如时间不一致性)的结果。在本文中，我们采用了另一种方法，将次优行为建模为内部模型错误设定的结果:用户行为可能偏离近优行为的原因是用户对控制行为如何影响环境的规则(动态)有一套不正确的信念。我们的见解是，虽然演示的动作在现实世界中可能是次优的，但就用户的内部动态模型而言，它们实际上可能是接近最优的。通过从观察到的行为中评估这些内在信念，我们得到了一种推断意图的新方法。我们在模拟和 12 名参与者的用户研究中证明，这种方法使我们能够更准确地模拟人类意图，并可用于各种应用，包括在共享自治框架中提供帮助和推断人类偏好。

视觉系统的任务驱动卷积递归模型

大问题/未来

前馈卷积神经网络(CNN)目前是用于对象分类任务(如 ImageNet)的最新技术。此外，它们是灵长类大脑视觉系统中神经元的时间平均响应的定量精确模型。然而，生物视觉系统有两个普遍存在的结构特征，与典型的 CNN 不同:皮质区域内的局部复发，以及从下游区域到上游区域的远程反馈。这里我们探讨了递归在提高分类性能中的作用。我们发现在 ImageNet 任务中，标准形式的递归(普通 RNNs 和 LSTMs)在深度 CNN 中表现不佳。相比之下，结合了旁路和门控两种结构特征的新型细胞能够大幅提高任务的准确性。我们在数以千计的模型架构的自动搜索中扩展了这些设计原则，这些架构识别了对对象识别有用的新的局部循环细胞和远程反馈连接。此外，这些任务优化的神经网络比前馈网络更好地匹配了灵长类动物视觉系统中的神经活动动力学，这表明了大脑的循环连接在执行困难的视觉行为中的作用。

本能:类固醇上的神经进化

原文：https://towardsdatascience.com/neuro-evolution-on-steroids-82bd14ddc2f6?source=collection_archive---------4-----------------------

当我第一次实现神经进化时，我实现了 Kenneth O. Stanley 和 Risto Miikkulainen 的论文中描述的算法； 通过扩充拓扑进化神经网络 。我设法让它工作，但当我在更复杂的数据集上测试算法时，问题开始出现。

节点连接偏差的缺乏迫使网络对于简单的问题变得过于庞大和复杂。跟踪所谓的创新数字在计算上非常昂贵。但最重要的是:由于缺少门，该算法永远不会产生任何像我们在 LSTM 的记忆细胞。

我很快开始修改算法，添加偏差和门，删除创新数，但也添加了节点变异其激活函数的选项:这是一个非常强大的工具，因为基因组现在可以针对数据集/环境完全修改自己。

本能算法

我喜欢称我的算法为本能算法。不仅仅是因为这听起来很酷，还因为神经进化在某些环境中发展了神经代理的本能。

本能的本质在于它是独立于理性而存在的。—查尔斯·达尔文

我将仅仅讨论基因组的结构，以及它们应该如何被培育、变异和限制。建立遗传算法取决于你。关于工作示例，请参见我的 Javascript 神经进化库。

另请注意，当算法发生变化时，本文将会更新。例如，我已经计划加入共享权重，这将很快加入。

1 个基因组

如图 1 所示，一个基因组由一组节点和一组连接组成。

(figure 1) Simple example of a genotype and corresponding phenotype

1.1 节点

每个节点都有一个类型。只有三种:input、hidden、output。类型为input的节点总是停留在列表的开头，类型为output的节点将停留在列表的末尾。如果通过突变添加了新节点，它们将总是具有hidden类型。

index 参数没有真正的功能，它只是表示节点被激活的顺序。这是按升序发生的。

每个节点都有一个可修改的偏置和挤压(或:激活功能)。偏见没有固定的范围。为每个新变异的节点随机选择激活函数。

1.2 连接

连接从索引为from的节点连接到索引为to的节点。即使连接引用了索引，它实际上也引用了它所连接的节点。例如，如果索引 2 和 3 上的节点之间存在连接，则该连接总是引用最初在索引 2 和 3 上的节点。

每个连接也有自己的权重和网关。重量没有固定范围。gater参数表示节点基因列表中控制连接的节点的索引，它总是引用该节点，而不管其索引如何。

1.3 激活

激活基因组的方法与其他神经网络完全相同，但我想在这里放一些(类似 JS 的)伪代码以防万一。请记住，自连接是由节点先前的状态而不是节点先前的激活状态相乘的。

FUNCTION ACTIVATE: 
  output = [] FOR EACH node IN genome.nodes:
    IF node.type === 'INPUT':
      node.activation = input[i]
    ELSE:
      // self-connections are handled differently!
      node.state = node.selfconnection.weight * node.state *
        genome.nodes[node.selfconnection.gater].activation +
        node.bias FOR EACH connection IN node.incomingConnections:
        node.state += connection.weight *
          genome.nodes[connection.from].activation * 
          genome.nodes[connection.gater].activation

      node.activation = node.squash(node.state)

      IF node.type === 'OUTPUT':
        output.add(node.activation)

2 交叉

杂交是基因组改进的关键。当两个基因组被选择进行杂交时，它们会产生一个独特的后代。它可能会从两个不太健康的父母那里创造出非常健康的后代。它刺激了群体中新网络拓扑的创建。

一个普遍的法则，导致所有有机生物的进步，也就是，繁殖，变化，让最强的生存，最弱的死亡。——查尔斯·达尔文，物种起源

首先，后代的大小被确定。基因组的大小等于基因组的节点数。如果双亲中的一个比另一个具有更高的适合度，那么大小将与最适合的双亲的大小相同。如果双亲同样合适，则在双亲的尺寸之间随机选择一个尺寸。

IF parent1.fitness > parent2.fitness:
  offspring.size = parent1.size
ELSE IF parent2.fitness > parent1.fitness:
  offspring.size = parent2.size
ELSE:
  offspring.size = randomBetween(parent1.size, parent2.size)

不管哪个父节点更合适，对于每个索引，节点将从每个父节点中统一选择。这样做，直到节点的数量等于先前确定的大小。

当子代的大小大于最小的父代时，将总是选择来自最大父代的节点。

这些规则有两个例外:首先，如果后代的输出节点还没有被选择，那么类型为output的节点可能永远不会被选择。其次，当为后代选择第n个输出节点时，则选择双亲之一的第n个输出节点。

FOR i = 0, i < offspring.size, i++:
  IF i < offspring.size - parents.outputSize:
    // Choose non-output nodes
    IF i > parent1.size - parents.outputSize:
      node = parent2.nodes[i];
    ELSE IF i > parent2.size - parents.outputSize:
      node = parent1.nodes[i]
    ELSE:
      node = SELECT_UNIFORM(parent1.nodes[i], parent2.nodes[i])
  ELSE:
    // Choose output nodes
    node = SELECT_UNIFORM(
      parent1.nodes[parent1.size + i - offspring.size],
      parent1.nodes[parent2.size + i - offspring.size]
    )

  offspring.nodes[i] = node;

一旦选择了节点，连接被分成两个不同的组:公共和额外连接。当两个父节点具有相同的from和to值时，这是一个普通连接。否则，它就是一个额外的连接，意味着这个连接只存在于父母中的一个。

最有效的方法

公共节点从双亲中统一选择，而不考虑它们的适合度。只有当父母中的一方至少和另一方一样健康时，来自该方的额外基因才会被添加。

3 突变

与整洁的论文不同，我将描述应该用来从基因组中获得最大效率的突变方法。每个描述都附有一些伪代码。

3.1 添加节点突变

拥有一种将节点基因添加到基因组的突变方法是必不可少的。没有这种突变方法，基因组将不会增长，因此在节点被连接饱和后永远不会改善。

当添加新节点时，现有连接将被拆分为两个新连接，新节点位于这两个连接之间。

(figure 2) Example of the add node mutation, a new node between 1 and 2 is added

如果被删除的连接有一个网关，该网关将被转移到两个新连接中的一个。当一个新的节点被插入到一个基因组的基因列表中时，它被放置在原始连接的接收节点(具有索引to的节点)的之前并且从不在具有output类型的任何节点的之后*。*

当一个节点被插入到其他节点之间时，被插入节点之后的所有节点的索引增加 1。因此，现有的连接总是保留在它们最初被分配到的节点之间。

新节点总是被分配一个统一选择的激活函数。

connection = SELECT_UNIFORM(genome.connections)
gater = connection.gaterindex = MIN(connection.to, genome.size - genome.outputSize)
node = new Node()genome.nodes.insert(node, index)
genome.connections.remove(connection)newConnection1 = {
  from: connection.from, 
  to: index, 
  weight: randomNumber(),
  gater: -1
}newConnection2 = {
  from: index, 
  to: connection.to, 
  weight: randomNumber(),
  gater: -1
}IF gater !== -1:
  SELECT_UNIFORM(newConnection1, newConnection2).gater = gatergenome.connections.add(newConnection1)
genome.connections.add(newConnection2)

3.2 添加连接突变

与变异新节点同等重要的是变异新连接。首先，生成存在不存在的连接列表。列表生成后，其中一个生成的连接将被放入基因组的连接基因列表中。

(figure 3) Example of the add connection mutation, a new connection between 1 and 3 is added

来自hidden或output类型节点的连接从不连接到input类型节点，因为input类型节点的激活值不是计算出来的，而是由数据集提供的。创建这些连接会调用不必要的内存。

pairs = []FOR EACH node1 IN genome.nodes:
  FOR EACH node2 IN genome.nodes:
    IF node1.isNotConnectedTo(node2):
      pairs.add([node1, node2])pair = SELECT_UNIFORM(pairs)connection = {
  from: pair[0].index,
  to: pair[1].index,
  weight: random(),
  gater: -1
}genome.connections.add(connection)

3.3 添加门突变

拥有一种设置连接基因闸门的突变方法，对于开发复杂的网络来检测多个连续输入之间的模式是必要的。

统一选择一个连接，并将gater值设置为从基因组的节点基因列表中统一选择的节点的索引。

(figure 4) Example of the add gate mutation, connection from 1 to 3 is gated

connection = SELECT_UNIFORM(genome.connections)
connection.gater = selectionUniform(genome.nodes).index

3.4 修改体重突变

统一选择一个连接，并在该连接的权重上加上或减去一个值。我喜欢把修改固定在(-1, 1)的范围内。

(figure 5) Example of the modify weight mutation

connection = SELECT_UNIFORM(genome.connections)
modification = random() * (max - min) + minconnection.weight += modification

3.5 修改偏置突变

统一选择一个节点，并从该节点的偏差中增加或减去一个值。我喜欢修正(-1, 1)的射程。确保不要突变输入节点，因为这对基因组的输出没有影响。

(figure 6) Example of the modify bias mutation

node = SELECT_UNIFORM(genome.nodes) // exclude input nodes
modification = random() * (max - min) + minnode.bias += modification

3.6 修改南瓜突变

最后但肯定不是最不重要的:修改节点基因激活功能的突变方法。就个人而言，我坚持使用以下激活功能列表:

逻辑， 双曲正切 ， 恒等式 ， 二进制步长 ，ReLU，软符号， 高斯

如果你寻求更多样的激活功能，我推荐这个列表。

(figure 7) Example of the modify squash mutation

node = SELECT_UNIFORM(genome.nodes)
newSquash = SELECT_UNIFORM(listOfSquashes)node.squash = newSquash

3.7 清除节点突变

随着基因组的增长，它可能表现得更好，但有时它有利于基因组回复已经发生的突变。这也降低了激活基因组的计算成本。

(figure 8) Example of the remove node mutation, node on index 2 is getting removed

首先，input或output类型的节点永远不会被删除。一旦随机选择一个隐藏类型的节点进行删除，就会创建一个带有节点索引的列表，该列表提供到该节点的所有传入连接(不包括自连接)。另一个列表是用所有输出连接的目标节点索引创建的。同时，不是输入和输出连接的-1的gater值被保存。

node = SELECT_UNIFORM(genome.nodes)gaters = [];
sourceNodes = [];FOR EACH connection IN node.incomingConnections:
  IF connection.from !== node.index:
    sourceNodes.add(connection.from)
    IF connection.gater !== -1:
      gaters.add(connection.gater)targetNodes = [];FOR EACH connection IN node.outgoingConnections:
  IF connection.to !== node.index:
    targetNodes.add(connection.to)
    IF connection.gater !== -1:
      gaters.add(connection.gater)

现在sourceNodes阵列中的每个节点索引与targetNodes阵列中的每个节点索引连接(如果尚未连接)。保留了所创建的连接的列表。创建完所有连接后，gaters中的每个选通器都被分配给一个连接，直到没有连接留给选通器。

newConnections = [];FOR EACH source IN sourceNodes:
  FOR EACH target IN targetNodes:
    IF source.notConnectedTo(target):
      connection = {
        from: source,
        to: target,
        weight: random(),
        gater: -1
      }
      newConnections.add(connection)
      genome.connections.add(connection)FOR EACH gater IN gaters:
  IF newConnections.length === 0:
    break;

  randomConnection = SELECT_UNIFORM(newConnections);

  randomConnection.gater = gater
  newConnections.remove(randomConnection)

由被移除的节点选通的每个连接的gater值被设置为-1。最后，从基因组中移除该节点。

FOR EACH connection IN genome.connections:
  IF connection.gater === node.index:
    connection.gater = -1genome.nodes.remove(node)

3.8 移除连接突变

只有当源节点有多个传出连接并且目标节点有多个传入连接时，才能删除连接。这样，所有节点将始终至少有一个传入连接和一个传出连接。

(figure 9) Example ofthe remove connection mutation, connection between 1 and 3 is being removed

connections = [];FOR EACH connection IN genome.connections:
  IF connection.from.hasMultipleOutgoingConnections() AND
     connection.to.hasMultipleIncomingConnections():
    connections.add(connection)connection = SELECT_UNIFORM(connections)
genome.connections.remove(connection)

3.9 移除门突变

先前已经变异的门可能会对基因组的表现造成问题。这种变异方法从随机选择的门控连接中移除门。

(figure 10) Example of the remove gate connection, connection from 1 to 3 is getting ungated

gatedConnections = [];FOR EACH connection IN genome.connections:
  IF connection.gater !== -1:
    gatedConnections.add(connection)connection = SELECT_UNIFORM(gatedConnections)
connection.gater = -1

3.10 其他突变方法

有时将添加连接变异方法拆分成多个其他变异方法是有意义的:添加前馈连接、添加递归连接和添加自连接。这也需要移除前馈连接，移除循环连接和移除自连接。

例如，当数据集没有空间关系(多个样本之间的关系)时，您不希望出现任何重复性突变。

4 个限制因素

就像任何其他训练方法一样，本能算法有可能过度拟合数据集。为了避免过拟合，引入了一个新的全局参数:生长。

growth参数不利于基因组变大，但性能相对较低。通常，growth是十进制数。节点、连接和门的数量乘以growth得到基因组的适应度惩罚。

penalty = (genome.nodes.length + genome.connections.length + genome.gates.length) * growth

用于计算罚金的参数是自由选择的。例如，罚款计算也可以是:

penalty = genome.nodes.length * growth

4.1 示例

一个基因组在某个数据集上有10的适合度。基因组发生了变异。它获得了一个额外的节点。突然，适应度提高到了11。可悲的是，随着以下惩罚的应用，最终适应度降低到9:

fitness = fitness - genome.nodes.length * growth

其growth值为2。因此，如果一个基因组想要达到更高的最终适应度，适应度的增加应该高于2。

神经形态和深度神经网络

原文：https://towardsdatascience.com/neuromorphic-and-spiking-or-not-894a836dc3b3?source=collection_archive---------0-----------------------

免责声明:我在博士期间一直从事模拟和混合信号神经形态微芯片的研究，在最近 10 年里，我转向了深度学习和全数字神经网络。关于我们作品的完整列表，请看这里 。关于这个主题的一个更老的出版物是 这里是 (来自我们组)。

神经形态神经网络

用于计算神经网络的神经形态或标准数字:哪个更好？这个问题很难回答。标准的数字神经网络是我们在深度学习中看到的那种，它们取得了所有的成功。它们使用 64 位或更低的数字值进行计算，所有这些都在标准数字硬件中。

神经形态系统和硬件有很多种风格，主要源于卡弗·米德的开创性工作(他的书的封面在右边)。他们通常使用每个值 1 位，就像在脉冲神经网络中一样。他们可以用模拟或数字计算单元进行计算。主要思想是神经元是自由运行和独立的单元，由 1 比特脉冲形式的尖峰信号的通信来刺激。神经形态神经元既可以是复杂的数字计数器也可以是简单的模拟积分器。

The Izhikevich neuron circuit, from here

通信是异步且复杂的。此外，使用数字通信更节能、抗噪，如下图所示。

Sarpeshkhar 1998

数字形式的神经形态硬件由 IBM ( TrueNorth )设计，模拟形式由许多研究小组( Boahen 、 Hasler 、我们的实验室等)设计。).最好的系统使用模拟计算和数字通信:

Kwabena Bohaen group

使用传统的数字硬件来模拟神经形态硬件( SpiNNaker )显然是低效的，因为我们正在使用 32 位硬件来模拟 1 位硬件。

神经网络计算

神经网络需要乘加运算。MM 矩阵与 M 向量乘积需要 M 次乘法和加法，或 2M 次运算。他们还通过卷积或人工感受域进行计算，这基本上与矩阵向量乘法相同，只是你为每个输出数据点乘以多个值(过滤器)。

神经形态系统以不同的方式计算相同的运算**，而不是使用 B 位字进行激活和加权，它们使用神经元之间的 1 位尖峰通信。神经元可以在正负线上发送尖峰信号，以激活或多或少与其相连的神经元。神经形态神经元在数字计数器或模拟积分器中整合输入，当达到某个阈值时，它们自己触发另一个尖峰信号，以与其他神经元进行通信。**

**神经元阵列和神经激活:**神经元被组织成阵列，并将激活存储在每个神经元内部的存储器中。这是一个问题，因为神经网络可能很大，需要许多神经元。这使得神经形态微芯片变得很大，因为神经元不能像我们在传统数字系统中那样被重用。如果一个人想要在同一序列中重复使用神经元阵列进行多次计算，那么他必须使用模拟存储器来存储神经激活，或者将它们转换为数字并存储到传统的数字存储器中。**神经形态问题:这两种选择目前都被禁止。**详见下文“模拟与数字存储器”。

计算神经形态阵列中的神经网络层需要将权重值 W 添加到神经元激活中。这很简单:**没有乘法。**数字乘法器每比特使用 L(~ 30–300)个晶体管(下限:每个触发器 12 个晶体管，2 ff，一个 xor 门进行乘法)，而模拟乘法器可能只需要少量晶体管(1 个用于乘法，5–10 个用于偏置电路)来乘以~5 比特(受噪声限制)——这都取决于权重是如何实现的。神经形态计算通过使用少得多的功率赢得了重要的时间。

重量是如何实现的？它们可以是数字的也可以是模拟的。通常它们是数字的，因为模拟存储器在操作期间会褪色，并且每单位重量需要大的电路以避免泄漏。数字重量增加了与其数字值成比例的激活量。

这些砝码存放在哪里？在本地，每个神经元的存储容量是有限的，但是如果这还不够的话，就不得不求助于外部数字存储器。更多信息请见下文“模拟与数字存储器”。

神经形态系统在无时钟设计中使用尖峰信号的异步通信。这允许通过仅在需要时通信而不是在不相关的时钟滴答时通信来节省功率。但这也使系统设计和通信基础设施变得复杂。更多信息请见下面的“系统设计”。

注意:为了从神经元阵列中获取值，我们需要将数字(例如图像中的 8 位像素)转换成脉冲串。这可以通过将强度值转换成脉冲频率来实现。理想情况下，这种转换只在数组的输入数据和输出端执行。

模拟与数字存储器:

神经网络计算需要计算 M*M 矩阵与 M 向量的乘积。m 通常在 128–4096 的范围内。

由于处理器必须按顺序计算多个这样运算，因此它需要交换矩阵，依靠外部存储器进行存储。这需要一个数字存储器，因为数值是数字。

模拟处理器必须将数值从模拟转换成数字，然后再转换回来，以对数字存储器进行操作。每个进出内存的端口都需要一个 AD/DA。这些器件需要以存储器速度工作，通常在 1GHz 的数量级，这是当前转换器的极限，需要非常大的功率。

禁止在每一层来回转换 AD/DA。因此，模拟神经网络将不得不在模拟模式下连续执行多个层，这是有噪声的并且会降低信号质量。这也需要用于多层的硬件，N 层乘 M*M 硬件乘法器块需要可用。这需要大的微芯片硅面积/尺寸。

相比之下，数字硬件可以很容易地从数字存储器中存储和检索，并且硬件可以重复使用，需要更少的微芯片硅面积/尺寸。此外，没有数据转换的开销。

系统设计:

神经形态脉冲网络使用无时钟设计和异步数字设计。很少有工程师受过设计这种系统的训练。

模拟需要更多的专业知识，而可用的工程师却更少。

神经形态系统往往比传统的数字系统 设计起来更加复杂。它们更容易出错，需要更多的设计迭代、非标准工具和微芯片工艺变化。

稀疏性:

一些系统可能在稀疏计算领域更胜一筹，在稀疏计算领域，它们只需要计算其中的一部分，而不是计算整个 2*M 运算。注意:在深度神经网络中，输入不是稀疏的(图像、声音)，但可以通过隐藏层来稀疏化。许多值为零或非常接近，可以高度量化。

让我们假设在前 1-2 层中没有稀疏度，而在一些隐藏层中有高达 100 倍的稀疏度。

传统数字系统和神经形态系统之间没有差异，因为两者都可以执行稀疏运算。我们确实需要支持稀疏矩阵乘法的硬件(目前很多深度学习框架和硬件都没有实现)！

最后注意:

神经形态系统仍然很难设计。为了扩大规模，它们需要模拟存储器或快速低功耗的 AD/DA 转换器，而这些目前还不可用。

但是，如果计算是模拟的，并且通信使用事件间定时，则它们可以节省大量能量。

关于作者

我在硬件和软件方面都有将近 20 年的神经网络经验(一个罕见的组合)。在这里看关于我:媒介、网页、学者、 LinkedIn 等等…

新的试点研究表明，机器学习可以预测暴力学生

原文：https://towardsdatascience.com/new-pilot-study-shows-machine-learning-can-predict-violent-students-359b9ec823ce?source=collection_archive---------5-----------------------

在暴力事件或悲剧发生后，你经常会听到许多关于潜在预防措施的猜测。

以枪击事件为例，人们通常会谈论袭击的迹象或前奏。这本来是可以避免的吗？那些接近攻击者的人看到了他们应该报告的什么？

很多人分享他们对这件事的看法，但这并不一定能揭示现实情况。甚至有可能找到一种可靠的方法来防止这些悲剧吗？

最近的一项研究可能会提供一些答案和一些希望。

有可能预测青少年的暴力行为吗？

当一个孩子遇到麻烦并表现出暴力或攻击的迹象时，很明显，他们需要支持，那些接近他们的人或心理健康专家可能会提供支持。

在任何人获得帮助之前——成年人也是如此——必须有人注意到潜在的问题。不幸的是，这些问题并不总是显而易见。这是一件很容易被忽略的事情，即使是对需要帮助的孩子的父母来说。

那么，答案是什么？我们如何识别或知道某人何时需要帮助？现代技术似乎可以提供一个解决方案。

来自辛辛那提儿童医院医疗中心的研究人员发现，机器学习可以准确地确定校园暴力的风险。

他们发表在 T4 精神病学季刊杂志上的研究指出，这可能和一组儿童精神病学家甚至法医精神病学家一样准确——如果不是更准确的话。

机器学习有什么帮助？

首先值得注意的是，这项研究仅仅表明预测攻击性是可能的。这并不能证明机器学习技术可以防止校园暴力。

需要进一步的研究来确定这一点，但是解决这个问题是研究小组的“下一个目标”

然而，研究人员得出结论，他们可以为问题行为提供更准确的方法，这本身就是一个巨大的发现。

“以前的暴力行为、冲动、学校问题和消极态度与对他人的风险相关，”医学博士德鲁·巴兹曼说。巴兹曼是这项研究的主要作者，也是辛辛那提儿童医院医学中心的儿童法医精神病学家。

这项研究涉及来自 74 所美国学校的 103 名青少年学生，他们表现出行为变化和攻击性。包括在内的许多学生是从精神病门诊或住院诊所和急诊科招募的。

研究小组根据他们开发的风险等级量表将参与者分为两组。他们通过使用从录音中转录的评估来做到这一点。

在直接采访后，研究人员评估了两组人表现出暴力行为的可能性。他们使用机器学习算法分析了他们获得的信息，该算法实现了 91.02%的预测准确率。

当他们还包括参与者的人口统计和社会经济数据时，准确率上升到 91.45%。

合著者赵毅·尼博士是辛辛那提儿童医院生物医学信息学领域的计算科学家，他证实了该系统的准确性。

倪说“仅基于参与者访谈的机器学习算法，在评估风险水平方面几乎与我们研究团队的全面评估一样准确，包括从家长和学校收集信息，审查可用的记录，并在我们开发的两个量表上评分。

这在现实世界中意味着什么？

根据这项研究，机器学习可以预测暴力。但是这对公共安全的未来意味着什么呢？有可能完全防止暴力袭击吗？

真实的答案是我们还不知道。研究人员将进行进一步的研究，看看他们的技术是否有助于完全防止暴力。我们需要等待，然后才能得出任何结论，但这项初步研究表明，机器学习在这一领域可能是有用的。

至于机器学习行业，这项研究提供了证据，表明这是现代社会的另一个领域，这项令人生畏的技术可以改善。

这些发现将进一步支持该行业，并有助于引入该技术的新用途。例如，如果事实证明你可以使用机器学习工具来防止校园枪击事件，那么你可以预测并潜在地阻止哪些其他暴力事件？

时间会证明一切，但很可能不久的将来，机器学习会让我们的生活变得更安全、更美好。

图片由 Pixabay 组成

纽约寻求俳句:从纽约市政府职位描述中产生俳句

原文：https://towardsdatascience.com/new-york-seeks-haikus-generating-haikus-from-nyc-government-job-descriptions-c27496a376fd?source=collection_archive---------9-----------------------

六年前，纽约市通过了一项法律，要求市政机构公开他们的数据。从那时起，超过 1600 个数据集已经在该市的开放数据门户上可用，并且新的数据不断提供。

开放数据周——纽约市长数据分析办公室在全市范围内开展的活动——是对这一进步的庆祝，并与数据贯穿设计展览同时举行。这次展览的目的是挑战艺术家们使用这些公开的数据来讲述关于这座城市的有见地的有趣的故事。

作为一名土生土长的纽约人、数据科学家和公务员，这个挑战激起了我的兴趣，因为以创造性的新方式使用城市数据是我的工作。

需要 40 万名政府雇员来维持纽约市(美国人口最多的大都会区)的运转。从维护基础设施、提供应急服务，到创造减少浪费、无家可归和犯罪的创新方法，这一切都归结于他们。

因此，对于《设计中的数据》,我想讲述 40 万人在幕后工作的故事，以及他们是如何让我的家乡保持生机和繁荣的。最终，这个概念演变成一个程序，根据市政府工作的职位描述，通过算法生成俳句。

纽约市寻求

这些数据来自纽约市工作数据集。它包含纽约市官方招聘网站上的最新招聘信息。开放数据门户上的大部分数据都是关于城市发生了什么，城市做了什么。这个数据集让我们得以一窥这些事情背后的人和事。

每个职务公告都包含机构、薪资范围和发布日期等信息。对于这个项目，我使用了三栏:公务员职称、职位描述和职位资格。

此外，我使用了一个数据集，其中包含 Jim Kang 的 phonemenon 中单词的音节数。我不得不修改数据，以包括非标准的单词，如机构缩写(即 NYPD，4 个音节和点，3 个音节)。

生成俳句

目标是利用纽约市的工作描述来创作俳句。俳句最初是日本的一种诗歌形式，包含三行，第一行五个音节，第二行七个音节，第三行五个音节。

为了创作一首俳句，我使用了一种定制的马尔可夫链方法。马尔可夫链是一种在给定当前值和当前值之后的值的概率的情况下生成序列的技术。在这种情况下，给定一个单词，接下来可能是什么单词？

第一步是确定这些概率。我按公务员头衔(计算机系统经理、油漆工、土木工程师等)对数据进行了分类。)和首选技能字段中的文本建立了一个单独的数据语料库。然后我把语料库拆分成句子，把句子拆分成单词，统计 A 跟着 b 的次数。

下面的例子显示了计算机系统经理在“数据”后面最常用的词。给定一个这样的表，马尔可夫链将随机选择一个按概率加权的下一个单词。然后，它将得到这个单词，并一次又一次地重复这个过程。

因为我在创作俳句，所以我有严格的音节限制。我只考虑下一个符合音节限制的单词。例如，如果我在第一行(5 个音节)，我当前的单词是“数据”，我不会选择“分析”或“整合”作为下一个单词，因为这会将该行置于 5 个音节之上。

在这个过程中，当在音节限制内没有有效的选择时，生成器有时会将自己写入一个不可能的状态。在这种情况下，它会返回并尝试一个新词，看看它是否会导致一个有效的俳句。

俳句以一种原始的状态出现在这个过程中——全部是小写，没有标点符号，有时它们就是不太好。我发现的最大问题是，因为俳句太短，结果往往是不完整的想法。

马尔可夫链会在一个句子的中间，当它达到音节数时突然停止。我试图通过只使用符合逻辑的结尾词来纠正这一点，但这并不适用于所有情况。

例如，以下两句都以“设计和施工过程”结尾，但只有第一句是完整的句子:

与项目负责人
一起创建设计和
施工流程

和

纽约市
设计部
施工流程

有些结果实际上很有趣:

环境
和环境
和环境。

和

新城市
纽约市:开放的数据，
开放的政府。

通过一个半手工、半自动化的编辑过程，我清理了俳句，以获得像样的结果。最后一篇有 750 多首俳句。

增加观众参与度

我现在有能力创作俳句；但是我应该如何呈现它们呢？我想给一些算法如何工作的见解。为此，我决定展示反复创作的俳句。该算法尝试的每个单词都会显示出来，当遇到失败状态时，它会删除单词并再次尝试。

这是它的样子:

展览组织者 Michelle Ho 建议将这些俳句印在标签上，这样它们就可以作为纪念品带回家，供设计展览的观众参考。

我添加了一个按钮，按下后会生成并打印下一首俳句:

其结果是对该市公务员的一些职责和技能进行了异想天开的互动审视。

以下是一些我最喜欢的:

纽约市
政府是一个加号，但
不是必需的。

财务部正在寻找
一名充满活力的实习生来
发挥团队作用。

确保数据
准确、整洁、及时并
准备好接受审计。

对
干线水和废水
收集系统的深刻认识。

谁想成为
信息
安全人员的一部分？

此文原贴于 数据驱动新闻 。

感谢 Abigail Pope-Brooks 的编辑和反馈。

所有用到的代码和数据都可以在github上找到。杰里米·内曼在他的网站上做着同样毫无意义的事情:http://jeremyneiman.com/

纽约人应该学会与老鼠相处，因为它们不会离开:数据可视化。

原文：https://towardsdatascience.com/new-yorkers-should-learn-to-get-along-with-rats-because-theyre-not-leaving-a-data-visualization-db4ca516762b?source=collection_archive---------5-----------------------

一个风和日丽的夜晚，我和丈夫在华盛顿广场公园散步时，注意到一对微笑的年轻游客夫妇带着一个小女孩向我们走来。女孩很可爱，直到她开始尖叫。她一边爬上父亲的身体，一边尖叫着指着一只从公园长椅下跑出来的大老鼠。父母停下了脚步，老鼠也一样。

More rats or more complaints? Probably both: 98,273 rat complaints to NYC 311 from 1/2010 through 7/2017.

我以为老鼠会继续跑，因为只差一只脚就可以到达一个可爱的安全花坛了，但是它纹丝不动。为了帮忙，我跺着脚，朝老鼠走去，这应该能让它立刻动起来。但是那只老鼠坚持住了，直到我靠近得不舒服，它才最终让我们都走了。

18 世纪，老鼠乘坐英国船只来到纽约，然后开始大量繁殖。虽然它们会对健康和 T2 的财产造成威胁，但纽约市喜欢谈论它的老鼠，有时甚至会吹嘘它们。还有披萨鼠，他英勇地检索了一份普通的切片，有近 1000 万的浏览量；雪鼠，被暴风雪挡不住的人；自动扶梯鼠，其无休止的无处可逃很容易理解，以及垃圾鼠，其拖着一整袋垃圾穿过人行道。

纽约的居民区一直在为最糟糕的老鼠问题而竞争。华盛顿高地/因伍德的老鼠最多，或者可能是上西区或者是上西区，特别是靠近中央公园的地方。不，上东区。还是东，但是真的[东哈林](http://East Harlem https://www.dnainfo.com/new-york/20150128/east-harlem/health-department-fights-east-harlem-rat-infestation)。或者哈林，但是绑了 Flatbush 。获胜的地区在任何时候都不快乐。尽管由于老鼠在医学研究中的重要性，它是第三个被测序的哺乳动物，但它并不被人类视为邻居。

老鼠似乎在四处活动，热点地区随着季节和城市努力对抗老鼠数量激增而潮起潮落。纽约市的 311 系统接受电话或在线投诉以及关于任何非紧急事件的问题，有一个啮齿类和老鼠子类别的分类报告。

利用纽约市 311 从 2010 年 1 月到 2017 年 7 月的数据，结合美国人口普查数据，我估计纽约市各区和邮政编码的老鼠报告数量为每 10，000 名居民 311 例。根据纽约市 311 系统从 2010 年 1 月到 2017 年 7 月记录的 98，273 次老鼠目击事件，b ehold，下面是 gif 地图，它的美丽掩盖了它背后的痛苦。一些拉链似乎比其他拉链的鼠患情况更严重，并且有一个周期性的模式(在上面的图表中更容易看到),当春天到来时，投诉增加，夏天达到高峰，然后在秋天减少。

这告诉我们当地老鼠数量的多少？混淆数据的因素是，随着时间和空间的推移，居民或多或少可能会报告看到老鼠。自纽约市 311 系统于 2003 年启动以来，随着该系统总体使用量的增加，各主题的投诉和问题平均有所增加。网络(2009 年)、文本(2011 年)和电话应用(2013 年)311 选项让纽约人越来越容易点击和抱怨任何让他们感动的东西。

老鼠一年到头都在繁殖。然而，天气变好后，纽约人会花更多的时间在户外，所以春天和夏天可能会有更多在公园和 T2 游乐场遭遇老鼠的报道。当人们觉得他们没有被倾听时，他们可能会重复报告老鼠，直到他们看到结果，产生一个尖峰。在有很多公寓、合作公寓或配有管理员和门卫的昂贵租赁房的社区，居住者更有可能让有人在现场回应他们的室内鼠患投诉。居民可能会在城市的单户住宅区对付自己的害虫。但是，如果除了 311 之外没有人听投诉，密集的无门卫建筑或无回应房东的社区可能会显示更高的老鼠报告率。此外，垃圾容器的类型(或缺少垃圾容器)因住所类型而异。一大堆暴露在外的垃圾袋等着被捡起来(曼哈顿)比被车道隔开的密封罐能喂更多的老鼠(皇后区)。

为了了解它们的起源、行为和在城市中的迁移模式，福特汉姆大学的科学家们研究了纽约老鼠的群体遗传学。更好的是，纽约市的动物生物学家，博比·科里甘，是害虫管理专业名人堂的成员，倡导人类和老鼠共存的科学方法，并经营啮齿动物学院。市长们制定了一系列策略来对抗老鼠，包括捕鼠器、垃圾控制和生育控制。最近，一项耗资 3200 万美元的多管齐下的计划宣布实施，包括使用干冰来减少老鼠数量。与此同时，老鼠仍然可以向当局告密。这不会有什么坏处。

数据操作，图表和地图 gif 均在 R 中完成。数据操作和数据可视化的代码可以在我的 GitHub 库 中找到。

感谢您的阅读。

我欢迎反馈——您可以“鼓掌”表示赞同，或者如果您有具体的回应或问题，请在此给我发消息。我也有兴趣听听你想在未来的帖子中涉及哪些主题。

阅读更多关于我的作品【jenny-listman.netlify.com】。欢迎随时通过 Twitter@ jblistman或LinkedIn联系我。

数据和图像来源:

纽约市 311 系统的老鼠报告是从纽约市公开数据下载的。在纽约市开放数据上使用了一个过滤器来识别“描述符”=“发现老鼠”https://Data . cityofnewyork . us/Social-Services/311-Service-Requests-from-2010-to-Present/er m2-nwe 9/Data的条目。在 R 中，数据被过滤以移除 2017 年 8 月的条目，因为该月不完整。
由 Ari Lamstein 从 R 包choropethryzip版本 1.5.0 中导入每个纽约市邮政编码的人口规模，并且是对 2012 年人口的估计。https://github.com/arilamstein/choroplethrZip。这些数据基于美国社区调查(ACS) 5 年的估计。他们是由邮政编码列表区，而不是邮政编码。邮编与 ZCTA 的关系可以在美国人口普查网站上找到。https://www.census.gov/geo/reference/zctas.html。
纽约老鼠图，由阿基瓦·利斯曼提供。 @akivalistman

新手深度学习指南

原文：https://towardsdatascience.com/newbies-guide-to-deep-learning-6bf601c5a98e?source=collection_archive---------1-----------------------

当开始 DL 时，慢慢地走

已经有相当多的人问过我如何开始机器学习和深度学习。在这里，我整理了一份我第一次学习机器学习时使用的资源和选择的路径的列表。我会继续更新这篇文章，因为我找到了更多有用的资源。

免费课程

从吴恩达在 Coursera 上的机器学习课程开始。这将教会你机器学习的诀窍，并稍微提高你的线性代数技能。确保你完成了所有的作业，在你完成课程后，你将掌握机器学习的概念，例如；线性回归、逻辑回归、SVM、神经网络和 K-均值聚类。在学习本课程的同时，你还有机会建立一个玩具推荐系统。这会让你大开眼界，让你更有信心进一步进入人工智能和深度学习的领域。但是请注意，还有很多其他重要的概念，本课程无法涵盖。所以，学完这门课后，准备拓宽你的知识面。如果你在完成 ng 博士的课程后非常兴奋，你应该看看他的其他课程，这些课程是 Coursera 上深度学习专业化的一部分。

Fast.ai 提供关于深度学习的免费在线课程，他们在课程中提供两个部分:

深度学习第 1 部分:程序员实用深度学习
深度学习第二部分:程序员的前沿深度学习

在那些课程之后，你可能已经准备好处理辛顿的用于机器学习的神经网络了。与前面提到的课程相比，Hinton 的课程相对更难，因为讲课内容相当枯燥，而且包含更多的数学概念。如果你觉得你还不能掌握这门课程，不要气馁！把它放一会儿，做数学部分(在下一节描述)，然后回来。这次你一定能攻克这门课程！记住，决心，决心，是的，更多的决心。

数学

深度学习肯定需要你对线性代数、微分学、向量微积分有很强的掌握，这只是其中的几个例子。如果你想快速温习一些初等线性代数并开始编码，强烈推荐 Andrej Karpathy 的黑客神经网络指南。我发现 hadrienj 在深度学习书籍上的笔记非常有用，可以实际了解底层数学概念如何使用 Python (Numpy)工作。如果你喜欢从视频中学习， 3blue1brown 有一个最直观的视频，介绍线性代数、微积分、神经网络和其他有趣的数学主题。在一个基于非卷积的问题上实现你自己的基于 CPU 的反向传播算法也是开始真正理解反向传播如何工作的好地方。

变得严肃

如果你想把你的机器学习知识提高一个档次，并准备认真对待(我指的是研究生水平的认真对待)，那么就投入到加州理工学院教授亚塞尔·阿布-穆斯塔法的从数据中学习吧。做好计算的准备。这可能有点挑战性，但一旦你经历了这一切并完成了你的工作，这绝对是值得的。我相信教科书很难捕捉深度学习的当前状态，因为该领域正在以非常快的速度发展。但是最重要的教科书应该是古德费勒、本吉奥和库维尔的深度学习书籍。它可以在网上免费获得，所以你也可以一章一章地下载，一章一章地学习课本。

报纸，报纸，报纸，该死的，我再也追不上了

是的，深度学习的知识主要来自论文，这些论文的出版速度非常快。Reddit 是一个很好的起点。订阅 /r/machinelearning 和 /r/deeplearning 。不过，我发现机器学习 subreddit 更有用。 ArxivSanity 是查阅与你要找的论文相关的论文的好地方。深度学习看论文的时候有一点很重要，就是做好文献综述。做一篇好的文献综述会让你对事物的发展有一个很好的认识。解决做文献综述的一个方法是安装谷歌学术 Chrome 扩展并搜索你想要查找的论文。您可以通过“相关文章”和“引用者”来跟踪之前的工作以及基于该论文的新工作。阅读论文时要养成的一个好习惯是画出论文中概念的思维导图。

I drew this mind map when I read a paper on few-shot learning [1]— drawn with SimpleMind Lite

思维导图的优势在于，它是一种跟踪论文中出现的概念之间关系的好方法。我发现思维导图对于跟踪相关文献以及它们与我正在阅读的论文之间的关系非常有用。思维导图让我对论文有一个清晰的了解，也是我阅读论文后的一个很好的总结。

我发现 Twitter 对于跟踪机器学习和深度学习研究非常有用。你可以从追随 ML/DL 领域的知名人士开始，然后从那里扩展开来。正如我通常转发关于对抗性机器学习和自动驾驶汽车的研究一样，你也可以在 twitter 上关注我，并将其视为你的供稿。你可以做的是查看我转发的人，查看他们的推文，关注他们圈子里的其他研究人员。一旦你提供了足够的数据，Twitter 还会推荐优秀的人来关注，也就是说，关注了足够多的 ML/DL 研究人员(ML FTW！).

卡格尔

我不能强调 Kaggle 有多有用。我强烈建议尝试一下 Kaggle 比赛，即使你进入前 100 名的机会很小。Kaggle 比赛的价值在于社区。阅读内核并从中吸取好的实践。阅读评论并参与讨论。在那里你会学到很多东西。您将学习人们如何进行探索性数据分析，以及他们如何处理各种缺失数据、扭曲数据等情况。您还将了解人们如何决定为什么选择某些型号而不是其他型号。Kaggle 比赛中有很多知识。

灵感

机器学习的可视化介绍是直观掌握统计学习技术如何用于识别数据中模式的好方法。

谷歌的种子库是获得灵感的绝佳资源！看看例子，跟着文献走。

distilt . pub 是一个交互式学习一些 DL 概念的好地方。我希望蒸馏有比现在更多的文章。

冰山一角

除非你把自己学到的东西付诸实践，否则什么都不重要。ML 和 DL 听起来很神奇，直到你自己实现了整个管道。整个流程包括数据源、数据收集、数据质量评估、数据清洗、数据注释、数据预处理、构建工作流、构建模型、调整模型、评估模型、部署模型和重复模型。这些步骤只是整个 ML/DL 流程中的一些步骤。那些做过全面 DL 工作的人知道尽可能简化整个开发操作是多么重要。不仅整个数据源、收集、注释、清理和评估步骤至少占整个项目的 60%,而且它们可能是项目中最昂贵的部分之一(除了耗电的 GPU！).

总而言之，ML/DL 领域是一个成长中的领域，你必须保持你的耳朵、眼睛和头脑的开阔。不要仅仅因为一篇论文/博客/教程/个人/YouTube 视频说某个新技术在特定数据集上表现很好，就跳到这个新技术上。我见过许多闪亮的新技术来得快去得也快。始终意识到区分信号和噪声是非常重要的！

这篇文章是活生生的事。您的反馈对我很重要。请对我应该添加哪些资源以及您在学习 ML/DL 时发现哪些资源最有帮助发表评论。非常感谢你的阅读！

[1] Triantafillou，e .，Zemel，r .，& Urtasun，R. (2017 年)。通过信息检索镜头进行少量学习。在神经信息处理系统的进展(第 2255-2265 页)。

下一代人工智能驱动的组织——一个警钟！

原文：https://towardsdatascience.com/next-gen-ai-driven-organization-a-wakeup-call-c40182c97bca?source=collection_archive---------11-----------------------

在许多决定性的战役中，战线被划定，战略被制定，胜利者出现了。然而，有时，令人遗憾的是，战斗的失败是因为完全的无知——甚至不知道战线在哪里——更可悲的是，自欺欺人。

Forrester 的一份精彩分析报告称，到 2021 年，40 家“洞察驱动型公司” 将攫取 1.8 万亿美元——很可能其中一部分将从你的公司市值中剥离。在这份名单中，我们有成立不到 8 年的年轻公司。是什么将它们统一起来？他们对数据和人工智能的痴迷。

概括地说，关于人工智能的采用，组织分为两类:

首先，我们有“空谈者”:有一些组织对他们通常所说的“人工智能计划”犹豫不决——在组织筒仓中采取小的风险规避措施，被官僚机构和少数人纠缠，不幸的是，他们更关注媒体报道而不是实际结果。

然后我们有"实干家":这些是洞察驱动的公司，它们已经将分析人工智能集成(或正在大力集成)到它们的组织结构中。这些组织有一个整体的方法，我想称之为**“人工智能支持的价值链”**。

你是哪一个，你想去哪里？

博客的其余部分是关于如何通过成为“实干家”来赢得 AI 的战斗

1。瞄准人工智能驱动的价值链

三个关于远见者的故事，他们体现了更深入和更广泛地采用人工智能来推动整个组织的真正创新的想法。

Source: stitchfix.com

输入针脚位置。在亚马逊这样的巨头中开始网上服装零售业务？没问题——成立于 2011 年，现在 stitch fix 估值 44 亿美元。怎么做到的？有意识地关注数据和人工智能。

所有零售商从品牌制造商那里得到的标准数据点很少:尺寸等。然而，Stitch Fix 致力于为每件衣服提取多达 80 个属性,如衣领类型、纽扣数量等。他们使用机器学习来估计基于照片的详细的服装尺寸(例如袖子和裤腿轮廓)。当他们向人们匹配(推荐)衣服时，这些数据点给了他们竞争优势(他们每人大约有 75 个数据点)。你喜欢双领衬衫还是木纽扣？没问题——他们会想出办法的。

他们将数据和人工智能应用于整个价值链:从仓库分配、客户与人类造型师的匹配，一直到为新服装项目创造设计。

这个地区的一个典型例子是网飞。电影推荐引擎只是故事的一部分。想想这个:新电视节目的行业成功率是 35%——然而网飞有 70% 。怎么会？《绿色照明》之前,《纸牌屋》的第一部大制作(投资 1 亿美元！)，网飞转向其过去的数据来预测成功率和因素。剩下的就是历史了。网飞甚至对你浏览时显示的海报进行了优化，它使用人工智能进行质量控制(识别低质量的媒体)和优化内容交付(将哪些媒体运送到离你最近的内容交付网络)

Source: earnest.com home page

最后一个故事是关于认真的。2014 年推出的数字贷款机构。他们的业务是以比传统金融机构更低的利率发放贷款，而传统金融机构已经存在了一段时间。怎么会？更全面地承担风险。他们的算法考虑了关于申请人的大约 10 万个数据点，包括非传统的数据点，如教育、职业轨迹等。截至 2017 年 10 月，它已经发放了 100 亿 2B 的学生贷款，并拥有大约 5 亿美元的贷款组合。

**要点:**从大处着眼，从战略角度思考——询问数据&人工智能如何帮助你在价值链的各个方面进行创新。当然，当你执行时，你会优先考虑——然而，这里的关键点是要有一个大的图景在你面前，这样你就可以有效地在整个组织中渗透愿景，并授权愿景的执行。

2。了解炒作之外的可能性的高管赞助商

艾无疑被炒作。用这一领域的杰出领袖迈克尔·乔丹(加州大学伯克利分校教授)的话来说:“今天大多数被称为人工智能的东西，特别是在公共领域，都是过去几十年来被称为机器学习(ML)的东西”。

出自获得计算机科学最高荣誉图灵奖的朱迪亚·珀尔:“深度学习所有令人印象深刻的成就，都不过是曲线拟合而已”。

轻松地说，我在网上读到了这句真实但有趣的俏皮话:几年前人们谈论*“训练他们的人工智能模型】——现在人们谈论“教人工智能系统理解图像”。*

然而，除了这种宣传，今天的现有技术还有很多可能性:帮助更快地识别肿瘤，半自动汽车，个性化营销，识别欺诈——我可以继续下去。只要有历史数据可以学习，我们就有可能通过利用机器学习而受益。

我认为执行发起人应该理解这些界限，这样他们就可以避开炒作，通过开发可能的领域来交付切实的商业价值。进入Katrina Lake——Stich fix 的创始人兼首席执行官。Katrina 试图拉拢网飞数据科学副总裁 Eric Colson 加入 Stich Fix。几次会面后，科尔森得出结论:“桌子对面的人是他的长期老板、网飞创始人雷德·哈斯汀斯的智力克隆”。科尔森说“你给他们一点信息，他们就能描绘出一幅与现实相符的生动画面”。(来源:inc.com)

高管们请注意:花时间与这方面的专家一起了解人工智能的基本原理。这将有助于你避开炒作，并提供切实的价值。

3。整体考虑人工智能:风险&责任

在你的组织中采用 AI & ML 不仅仅是为了一个指标(点击、浏览、销售等)而优化。是的，商业价值是人工智能采用中的一个重要维度——然而，还有其他关键领域需要考虑:管理风险(对你的组织)和责任(对社会)。

一个关于风险的故事:

2018 年 3 月 18 日，晚上 9 点 39 分，15 摄氏度气温:一辆优步自动驾驶汽车在亚利桑那州坦佩市启动自动驾驶模式，车内有一名司机。接下来的 19 分钟它将处于自主模式。

晚上 9 点 58 分: 49 岁的伊莱恩·赫尔茨贝格推着自行车过马路。汽车撞上了伊莱恩，杀死了她。

引用 SFGate 的话:“毫无疑问，激光应该看到她，”硅谷企业家布拉德·邓普顿(Brad Templeton)说，他是谷歌自动驾驶项目的早期顾问。“我知道技术比这更好，所以我确实觉得这一定是优步的失败。”

**结局:**一命呜呼。为了让事情变得更安全，优步暂时关闭了自动驾驶车队(也有很多负面报道)。

**问题:**如果有稳健的训练数据&综合测试过程(在不同光照/天气条件下)，这种情况是否可以避免？我们应该有监控安全驾驶的技术吗？也就是说，在让它上路之前，值得问很多问题吗？

一个关于责任的故事

人们无时无刻不在被谷歌搜索:开会前，求职申请等。拉坦娅·斯威尼的一位同事在谷歌上搜索她，发现了一则广告，上面写着“拉坦娅·斯威尼被捕了？”

Source: https://arxiv.org/pdf/1301.6822.pdf

Latanya Sweeney 是哈佛大学的一名教授，以揭露过去的挑战性问题而闻名，他研究并发现了基于搜索与种族相关的人名的广告投放系统中具有统计意义的歧视。她勇往直前，发表了一篇广受好评的论文。

要点:作为人工智能战略的一部分，组织需要同时考虑风险(治理、风险&合规性)和责任(公平、隐私等)。如果这不是自愿的和直接的，总有一天会在压力下和非常糟糕的情况下完成。我将在接下来的博客中分享更多这方面的信息。

临别赠言

在这篇博客中，我概述了三个方面，我认为这三个方面对于在 2021 年前获得 1.8 万亿美元的份额是必不可少的:以人工智能驱动的价值链为目标，高管赞助商需要关注炒作之外的可能性，并设计一个整体的人工智能战略——除了商业价值之外，还包括风险&责任

问题是:你是要得到你的那份，还是要被瓜分？一个快速的新闻稿让你高兴还是你愿意投资于人工智能战略的整体方法？你准备好长期坚持了吗？你是实干家吗？

我打算就这个话题发表更深入的想法。我的坐标: LinkedIn ，Twitter&Medium

NFL 球队进攻位置支出与赛季成功

原文：https://towardsdatascience.com/nfl-team-offensive-positional-spending-vs-in-season-success-1bc2859d321?source=collection_archive---------8-----------------------

被标记的数据新闻、数据故事、数据可视化

甚至在 3 月 14 日正式的 NFL 自由球员时期开始之前，就已经有了大量的签约。球队渴望在他们最弱的位置升级他们的名单，目标是更强大的 2018 年运动，甚至是长期的成功。虽然最好的球员倾向于获得更高的合同，但支付最高工资的球队并不总是获得最高的成功。即使下赛季有 1.77 亿美元的上限，球队也支付不起每个人的工资。有影响力的玩家的明智支出仍然是必要的。在下面的报告中，我将分析和报告 2017/2018 赛季球队承诺支付给进攻球员的工资，并了解这种财务承诺与进攻生产之间的关联。

以下是该报告的一些关键要点:
·洛杉矶公羊队是全美橄榄球联盟中进攻最高效的球队，每场比赛得分最高，同时也是五种最便宜的进攻之一。奥克兰突击者队的进攻严重不足，尽管拥有第二高薪的进攻人员，但场均仅得 18 分。
【当根据输赢记录组织球队时，最成功的球队比输赢记录差的球队在跑卫和紧逼端上花费的进攻预算比例更高，而最差的球队比输赢记录好的球队在进攻线员和外接手上花费的比例更高。
2017/2018 赛季 NFL 球队分配给进攻人员散点图:分配的薪资($) vs 场均得分

这种可视化着眼于最近一个赛季，并试图回答以下问题:在进攻上花费最多的球队是否得到了最高分的回报？答案并不总是如此。正如你所看到的，图表沿着 x 轴划分了进攻总工资(根据OverTheCap.com)和每场比赛的平均得分。
低收入&低产出球队:这些球队在进攻支出上低于联盟平均水平，这导致得分低于联盟平均水平，这并不奇怪。这个象限主要由没有接近季后赛席位的球队(丹佛野马队、印第安纳波利斯小马队和克利夫兰·布朗队)组成，但像水牛比尔队和田纳西泰坦队这样的季后赛球队找到了进入季后赛的方法，因为强大的防守表现弥补了令人印象深刻的进攻支出和生产。
工资低但产量高:这个象限由在进攻球员上花费不足(相对于 NFL 球队的平均水平)但场均得分高于中值的球队组成。洛杉矶公羊队以一种巨大的方式完成了任务，在得分上领先联盟，尽管在进攻上的花费比一般球队少得多。
高收入&高产:这个群体是另一个理论上有意义的群体。在进攻上花费更多的球队获得更高的进攻输出。超级碗的参与者，新英格兰爱国者队和费城老鹰队都属于这一组。
高薪但生产不足:为表现不佳的球员超支的球队。这是一个零成员进入季后赛的象限，并且是最近几个赛季令人失望的季后赛球队(绿湾包装工队和奥克兰突击者队)的头条。

2017/2018 NFL 赛季:进攻人员每百万美元花费的得分

这从另一个角度审视了球队在进攻球员上花费预算的效率。这里的新指标在左边的第一列，它简单地除以本赛季每场比赛的平均得分，再除以每支球队的进攻预算(表示为每百万美元分配给进攻人员的得分(每场比赛)。如前所述，洛杉矶公羊队在得分上领先 NFL(每场比赛近 30 分)，同时在进攻上的支出明显低于平均水平(6350 万美元)。公羊队在支出效率方面领先联盟，每场比赛在进攻人员上花费 100 万美元，可以得到 0.47 分。薪资效率第二高的进攻是旧金山 49 人队，每 100 万美元的支出平均每场得 0.44 分，仅 20.69 分，低于场均得分的中位数，但在所有 NFL 球队中，进攻支出最少。这里要注意的是吉米·加罗波洛是在新秀年的最后一年年中被带来的，只首发了少数几场比赛。虽然像我一样的 Niner 球迷希望整个赛季的 Jimmy G 能够大幅提高球队的得分，但他今年早些时候签署的创纪录协议意味着旧金山将不再是足球界最便宜的进攻之一。与此相反的是奥克兰突击者队，他们令人失望的低迷表现导致每场比赛每百万进攻人员的花费只有 0.2 分(不到公羊队 0.47 分的一半)。

球队进攻工资分配到各个进攻位置的比例(近 5 个赛季)

为了这个可视化，我按照胜场数(0–4 胜，5–8 胜，9–12 胜，13–16 胜)将每支球队的过去五个赛季分成四个象限。对于每个象限，这里分析了每个队分配到每个位置的进攻预算的百分比。当看进攻人员时，最成功的球队(13-16 胜)在跑卫和紧逼端的支出上领先所有象限(分别占进攻人员工资的 11.22%和 12.37%)，而这些球队在外接手支出上落后于所有其他象限。过去 5 年中最差的球队在分配给进攻线球员和外接手的工资上领先所有象限(分别为 38.2%和 22.7%)，同时是唯一一个将进攻工资的 20%以下花费在四分卫上的象限(17.5%)。一年赢 5 到 8 场比赛的球队在四分卫身上花的钱最多(进攻工资的 22.65%)。

%的工资总额分配给职位(5 年)

根据过去 5 年的胜利，再次将 NFL 球队划分到相同的象限，这看起来是球队在每个位置上的花费占当年 NFL 总工资帽的比例。从广义上来说，更多的钱导致更多的胜利:13 到 16 个赛季的球队在进攻人员上花费了 NFL 工资帽的 49%(比联盟中位数高出 11.5%)。然而，在研究具体的职位时，结果却不尽相同。是的，当谈到进攻线手(+29.5%)、跑锋(+51.8%)、紧逼端(+61.9%)和外接球手(+19.7%)时，最成功的球队确实比联盟的其他球队花费得多。然而，这个象限在四分卫上的花费比联盟中位数少 9.4%。胜场数在 5-8 场的球队实际上在四分卫上花费最多(比联盟中位数多 19.5%)。

总之，虽然每个球员和每份合同都是独一无二的，但可以肯定的是，为最昂贵的球员花钱将意味着更多的胜利。从最后的图表中可以看出，在进攻球员上花费最多的球队确实有最好的胜率，但在四分卫上的花费比那些错过季后赛的球队少。

感谢您阅读我最新的数据帖子。作为一名产品营销和数据分析专业人士，我对数据支持的讲故事充满热情。这些数据新闻帖子是我将真实数据与我个人的不同兴趣整合起来的方式，这些兴趣包括从旅行和娱乐到经济和社会问题的任何事情。
如果您有任何评论、故事想法或预期的数据项目，请随时发送电子邮件至 dwpwriting <至> gmail < dot > com 或通过 LinkedIn 联系我。

原载于 2018 年 3 月 14 日dwpeterson.com。

NFL——在 NFL 中赢得第一节真的重要吗？

原文：https://towardsdatascience.com/nfl-which-quarters-correlate-most-with-winning-87f23024c44a?source=collection_archive---------3-----------------------

座右铭:坚强地开始。建立小的胜利。每个季度都要赢。

Bill Maher — Irritable Bowl Syndrome; Directed and Animated by Fraser Davidson

背景

人们会认为阿尔·帕西诺关于足球的方法论在任何给定的周日都是正确的，那就是:足球是一寸一寸赢得的。但是特定的英寸有关系吗？在这种情况下，我们指的是 NFL 比赛中的四或五节。如果一个队每个季度都赢了，显然他们赢得了比赛。有道理，但是，第一节的胜利与游戏结束时的胜利有关联吗？如果一个团队在比赛开始时打得太努力，会不会导致过早过度，从而在真正重要的最后英寸处留下有限的凶猛？球队真的能等那么久才全力以赴吗？或者说提前获胜实际上是为赢得整场比赛定下了基调？幸运的是，有现成的数据来满足我们的渴望！

概观

在本帖中，我们将通过使用 NFL 数据集解决一个完整的机器学习问题。我们的目标如下:

使用提供的 NFL 数据，开发一个模型来评估和预测在第一季度获胜的球队与在整个赛季中获胜的球队之间的相关性。

首先，让我们回顾一下开发此解决方案的基本方法。这是一个监督回归机器学习任务。这意味着我们已经获得了一组具有各种目标的数据(在这种情况下是每个季度的分数)，我们希望训练一个可以学习将功能映射到目标的模型。

我们将使用来自NFL scrapr-data repository的 NFL 数据集，我们的核心数据集是 nfl_season_pbp_dataset 。你也可以直接从我的 GitHub 库下载这个数据集。注意:在我们的评估中只使用了常规赛的数据。

重点提醒:数据科学保持头脑清醒的一个定律: 相关性不代表因果关系 。这是一个常用的统计阶段，用来强调两个变量之间的相关性并不意味着一个导致另一个。

说到这里，让我们开始吧！这里是我的 github 笔记本的链接，了解更多细节&解释。

数据导入和分析

import pandas as pd  # data manipultion librabry
import numpy as np # numerical computation library# Display up to 120 columns of a data frame
pd.set_option('display.max_columns', 120)# Data Visualization
import seaborn as sns
import matplotlib.pyplot as plt 
%matplotlib inline
from matplotlib import style# Internal ipython tool for setting figure size
from IPython.core.pylabtools import figsize

数据接收

# Data Imports
nfl_df = pd.read_csv('nfl_season_pbp.csv')
nfl_df.shape
nfl_df.tail()

Figure 1 — Core NFL Play by Play Dataset

为了理解按季度关联分数差异的目的，我们需要评估分数和其他特征如何影响整个游戏。现在，我们将假设各个季节基本上是相互独立的(我们可以用我们天真的能力来更新我们的假设)。因此，对一个特定游戏的预测仅仅是基于单个游戏的总体数据。因此，对于每个游戏，可以帮助我们解决问题的关键栏包括:

GameID:指定游戏的 ID
季度:游戏的四分之一
posteam:进攻的队伍
ScoreDiff:进攻队和防守队的得分之差(offensive.score — def.score)
ydstogo:第一次进攻的距离
码。获得:游戏中获得的码数
触地得分:二分制:如果比赛的结果是得分，则为 1，否则为 0
No_Score_Prob:半场内没有得分的概率
EPA:考虑到比赛结果，增加了控球队的预期分数
拥有球权的队伍获胜的概率增加了

按季度关联所有游戏

接下来，让我们从高水平上看一下每个季度所有比赛的得分差异的相关性。

fig, ax = plt.subplots(figsize=(8,6), dpi = 72)ax.set_title("Average Score Difference by Quarter", fontsize = 18)
ax.set_xlabel('Quarters', fontsize = 15)
ax.set_ylabel('Game Score Differnece (Absolute)', fontsize=15)
plt.xticks(fontsize = 13)
plt.yticks(fontsize = 13)nfl_df.groupby(by=['qtr']).AbsScoreDiff.mean().plot(kind='bar', alpha = 0.9, rot=0)
plt.show()

Figure 2 — Average Game Score by Quarters

在这里，我们可以看到从第一季度到第四季度的得分差异有显著的分布。然而，有趣的是，我们可以看到输赢的分布。是时候讨论一些数据了。

数据处理和处理

如上所述，我们将添加输赢游戏指标。在数据集中，有显示每场比赛得分的列，但是，因为这是一场场比赛的数据，所以没有总的赢/输列。因此，我们将简单地通过列season、GameID获取数据的子集，指示每个主客场球队的独特比赛。然后我们创建一个新的win_loss_df来表示哪支球队赢得或输掉了他们的比赛，然后合并新的列，这样我们就可以在季度级别上表示它。

def lastplay(df):
    # last row of data frame based on groupby filter
    if np.isnan(df.iloc[-1].Home_WP_pre) == False:
        return df.iloc[-1] 
    # last row of data frame second to last row if NA on last
    elif np.isnan(df.iloc[-2].Home_WP_pre) == False:
        return df.iloc[-2]win_loss_df = nfl_df.groupby('GameID').apply(lastplay).groupby(by=['Season','GameID','HomeTeam','AwayTeam']).agg({'Home_WP_pre':lambda x: int(round(x)),                                                                 'Away_WP_pre':lambda x: int(round(x))}).reset_index()win_loss_df = win_loss_df[['GameID','HomeTeam','AwayTeam','Home_WP_pre', 'Away_WP_pre']].rename(columns={'Home_WP_pre':'home_win',                                                                    'Away_WP_pre':'away_win'})

接下来，我们将把win_loss_df合并到NFL中，并使用 lambda 逻辑为 offesne (posteam)上的每个团队设置输赢。我们还将指定两个营业额列(InterceptionThrown、Fumble)，我们希望将其合并为每场比赛的总营业额。

nfl_df = nfl_df.merge(win_loss_df, on=['GameID','HomeTeam','AwayTeam'], how='left')# Create a Team_Win column to indicate a win loss
nfl_df['team_win'] = nfl_df.apply(lambda x: x.home_win if x.HomeTeam == x.posteam else x.away_win, axis=1)# Create a column for total turnovers for potential features
tunrover_list = ['InterceptionThrown', 'Fumble']
nfl_df['Turnover'] = nfl_df[tunrover_list].sum(axis=1)

现在我们已经知道了输赢，我们选择了一手牌，这手牌充满了对评估早期得分差异和赢得比赛/赛季之间的相关性最有影响的列(很快将被称为特征)。为此，我们将利用 groupby 函数。

nfl = nfl_df.groupby(by=['Season','GameID','qtr','HomeTeam','AwayTeam','posteam']).agg({'team_win':'mean','Win_Prob':'mean','Yards.Gained':'sum','Penalty.Yards':'sum','Touchdown':'sum','Turnover':'sum','FirstDown':'count','EPA':'mean','FirstDown':'sum',}).reset_index().rename(columns={'Yards.Gained':'Total_Yards','Penalty.Yards':'Penalty_Yards'})
nfl.tail(3)

Figure 3 — Initial NFL data frame (without box score and categories)

创建盒子分数和类别

接下来，我们将创建一个显示游戏分数和个人游戏成就的方块分数。当回顾初始数据集时，我们被提供了每场比赛的分数以及这些分数的累积。为了恰当地理解每个季度(qt)获胜球队的分布以及该季度对游戏和赛季的影响，我们首先必须有一个列来计算每个季度的总得分，并二进制表示哪个队在该季度获胜。

首先，我们首先创建一个函数来获取季度末的每个分数。下面的函数由一个数据框调用，该数据框是按季度和从进攻队(控球队)和防守队取得最后得分的队的子集。

使用 lambda 逻辑为每个进攻队设定输赢

def scores_per_qt(df):
    # last row of data frame based on groupby filter
    if np.isnan(df.iloc[-1].DefTeamScore) == False:
        return df.iloc[-1] 
   # last row of data frame second to last row if NA on last
   elif np.isnan(df.iloc[-2].DefTeamScore) == False:
        return df.iloc[-2] # last row of data frame

创建一个进攻得分表，用来计算每个队每个季度的总得分。

offensive_score_df = nfl_df.groupby(['GameID','qtr','posteam']).apply(scores_per_qt).groupby(by=['Season','GameID','qtr','posteam']).agg({'PosTeamScore':'mean',                                                                  'DefTeamScore':'mean'}).reset_index()

根据防守球队创建防守得分和进攻得分表。我们这样做是因为，在数据集中有这样的情况，控球队在本节结束时的防守得分不包括在上面的进攻得分表中。

defensive_score_df = nfl_df.groupby(['GameID','qtr','DefensiveTeam','posteam']).apply(scores_per_qt)[['DefTeamScore','PosTeamScore']].reset_index().rename(columns={'DefensiveTeam':'posteam','posteam':'PosDefTeam'})

合并进攻得分表和防守得分表，然后创建一个列来显示每个队在进攻和防守方面的最高得分，以准确捕捉季度末的得分。

score_df = offensive_score_df.merge(defensive_score_df, on=['GameID','qtr','posteam'], how='left')
score_df['PosTeamScore']=score_df[['PosTeamScore_x', 'DefTeamScore_y']].max(axis=1)
score_df['DefTeamScore']=score_df[['DefTeamScore_x', 'PosTeamScore_y']].max(axis=1)
score_df = score_df[['Season','GameID','qtr','posteam','PosTeamScore','DefTeamScore']]

为score_df创建特征，以指示每个季度的得分以及每个季度得分的差异。

score_df['qt_score_diff'] = score_df.PosTeamScore - score_df.DefTeamScore
score_df['qt_score_cumdiff'] = score_df.groupby(['posteam'])['PosTeamScore'].apply(lambda x: x.diff()) 
score_df['Pos_qt_score'] = np.where(score_df.qtr == 1, score_df.PosTeamScore, score_df.qt_score_cumdiff)
score_df = score_df.drop(['qt_score_cumdiff'], axis=1)

转置score_df并指出每支控球球队在比赛中的得分差异，然后与 score_df 合并。将nfl数据框与score_df合并。

# create df2 to indicate the ScoreDiff
df2 = pd.pivot_table(score_df, index = ['GameID','posteam'], columns = ['qtr'], values = 'qt_score_diff').reset_index()
df2 = df2.rename(columns= {1:'ScoreDiff1', 2:'ScoreDiff2', 3:'ScoreDiff3', 4:'ScoreDiff4', 5:'ScoreDiff5'})
score_df = score_df.merge(df2, on=['GameID','posteam'], how='left')nfl = nfl.merge(score_df, on=['Season','GameID','posteam','qtr'], how='left')

Figure 4 — New pbp_df that represents the data used for correlation assessment

勘探数据分析

为了更好地理解数据集中的模式，我们开始使用各种图形模型进行探索。我们将首先使用winners_of_quarters函数创建一个新的数据框，显示一支球队在过去 8 个赛季中实际赢得给定季度的总次数。

def winner_of_quarters(df):
    Score_Diff =['ScoreDiff1','ScoreDiff2','ScoreDiff3','ScoreDiff4','ScoreDiff5']
    winner = []
    for score in Score_Diff:
        qt_winner = []
        qt_winner = df[df[score] > 0].groupby(by='team_win_str']).agg({'qt1_won':lambda x: x.sum()/ df['qt1_won'].sum(),'qt2_won':lambda x: x.sum()/ df['qt2_won'].sum(),'qt3_won':lambda x: x.sum()/ df['qt3_won'].sum(),'qt4_won':lambda x: x.sum()/ df['qt4_won'].sum(),'qt5_won':lambda x: x.sum()/ df['qt5_won'].sum()}).reset_index().rename(columns ={ 'team_win_str':'qtr','qt1_won':'Q1','qt2_won':'Q2','qt3_won':'Q3','qt4_won':'Q4','qt5_won':'Q5'})
        qt_winner = qt_winner.T.reset_index()
        qt_winner.columns = qt_winner.iloc[0]
        qt_winner = qt_winner.rename(columns=qt_winner.iloc[0]).drop(qt_winner.index[0])
        qt_winner['qt_won'] = 'qt' + score[-1:]
        winner.append(qt_winner)
    dfs = pd.concat(winner)
    return dfsqt_win_df = winner_of_quarters(nfl)# Create plot
fig = plt.figure(figsize=(15,8))
ax = sns.barplot(x="qtr", y="Win", hue="qt_won", data=qt_win_df);
ax.set(xlabel='Quarters', ylabel = 'Winning Percentage')
plt.show()

Figure 5 — Winning Percentage by Quarter for Winning Teams

上面的柱状图让我们得以一窥在一场游戏的长期运行中赢得某个特定的季度是否重要。图例显示了一个团队赢得的季度的颜色以及他们赢得其他季度的胜率，从中我们可以观察到几个关键趋势。要解读这张图表，最好先看一个例子:让我们来辨别第一季度的赢家。第一季度(Q1)的蓝色条代表所有赢得第一季度(69.7%)的球队。每个随后的蓝条表示当一个队赢得第一节时，该队赢得第二节的 52%，赢得第三节的 51%，赢得第四节的 55%，如果比赛进入加时赛，赢得加时赛的 16%。

季度得分差异(价差)

接下来，我们来看看季度价差。我们可以看到团队之间的差距很大…这也可能是动力的一个标志。这表明，赢得早的团队通常会保持领先。听起来，当一个获胜的团队定下基调时，他们通常会保持领先优势。

fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(10,5))
ax = sns.barplot(x="qtr", y="qt_score_diff", hue="qt1_won", data=nfl[nfl.qt_wlt==1], ax=axes[0][0]);
ax.set_title('Q1 Win')
ax = sns.barplot(x="qtr", y="qt_score_diff", hue="qt2_won", data=nfl[nfl.qt_wlt==1], ax=axes[0][1]);
ax.set_title('Q2 Win')
ax = sns.barplot(x="qtr", y="qt_score_diff", hue="qt3_won", data=nfl[nfl.qt_wlt==1], ax=axes[1][0]);
ax.set_title('Q3 Win')
ax = sns.barplot(x="qtr", y="qt_score_diff", hue="qt4_won", data=nfl[nfl.qt_wlt==1], ax=axes[1][1]);
ax.set_title('Q4 Win')
ax.legend()

Figure 6 — Quarter Score Difference

如果球队以触地得分(6 分)或更多赢得第一节比赛，胜率。

g = sns.lmplot('Win_Prob', 'qt_score_diff', col='team_win_str', data=nfl[(nfl.ScoreDiff1 >= 7)],
               markers=".", scatter_kws=dict(color='c'))
g.map(plt.axhline, y=1, color="k", ls=":");

Figure 7 — Top Teams (Top) and Bottom Team (Bottom) winning 1st quarter Statisitcs

特征工程和选择

按季度创建与得分差异相关的潜在特征列表

在特征分析中，我们的目标是理解数据模式，开发主题假设，以及进行反复试验来确定与我们的目标最佳相关的相似特征选择操作符。

皮尔逊相关系数

为了了解第一季度的胜利是否与赢得的比赛相关，或者上半年获得的第一次总得分或第三次得分效率是否对赢得第一季度或比赛起着重要作用，我们需要衡量这些变量之间的关系。这就是皮尔森相关系数发挥作用的地方。这里有一本关于它如何工作的入门书。根据定义，相关性是多个值之间的依赖性的度量。使用皮尔逊相关系数，我们将提供一个变量列表，并测试我们的假设，即在第一和第二季度获胜与赢得比赛之间是否有直接关系。皮尔逊将提供一个介于-1和+1之间的回溯数字。这个度量的意义是这些变量为正的强度程度(接近于+1)。)，负相关(接近–1)或不相关(接近0)。请记住:相关性并不意味着因果关系。

下面，我们将利用皮尔逊相关系数和几列数据来确定 nfl 数据中的某些属性是否与确定哪个季度高度相关

potentialFeatures = ['qt_score_diff','qt_wlt','ScoreDiff4','ScoreDiff1','ScoreDiff2','ScoreDiff3','ScoreDiff5', 'qt1_won','qt3_won', 'qt4_won', 'home_away',
'Touchdown','Turnover','Penalty_Yards','Win_Prob','team_win','third_down_conv_rate','fourth_down_conv_rate','Total_Yards','FirstDown','EPA']
nfl_corr = nfl[potentialFeatures].corr()
f,ax = plt.subplots(figsize=(14, 14))
sns.heatmap(nfl_corr, annot=True, linewidths=.5, fmt= '.1f',ax=ax)
nfl_corr

Figure 8 — Potential Feature Correlation Matrix

Figure 9 — Potential Feature Correlation Matrix — Heat Map

选择热门功能并创建一个列表，其中包含人员在“team_win”与列中每一列之间的相关性。

nfl_corr['team_win'].sort_values(ascending=False)

Figure 10 — Top Potential Features

我们确保所选特征的数量和所计算的相关性是相同的(例如，在这种情况下是 21)。接下来的几个单元格显示了一些代码行，它们使用 pandas 绘图函数来创建这些相关值和列名的 2D 图

# create a list containing Pearson's correlation between 'team_win' with each column in cols
correlations = [nfl['team_win'].corr(nfl[f]) for f in potentialFeatures]
len(potentialFeatures), len(correlations)# create a function for plotting a dataframe with string columns and numeric valuesdef plot_dataframe(df, y_label):
    color='coral'
    fig = plt.gcf()
    fig.set_size_inches(20,12)
    plt.ylabel(y_label)

    ax = df.correlation.plot(linewidth=3.3, color=color)
    ax.set_xticks(df.index)
    ax.set_xticklabels(df.attributes, rotation=75); #Notice the ; (remove it and see what happens !)
    plt.show()# create a dataframe suing cols and correlationsdf5 = pd.DataFrame({'attributes': potentialFeatures, 'correlation': correlations})# lets plot above dataframe using the function we createdplot_dataframe(df5, 'Teams overall win percentage')
df5

Figure 11 — Team Overall Winning Percentage correlated with ‘team_win’

构建机器学习模型

现在我们将训练几个机器学习模型，并比较它们的结果。创建要素数据框并删除不必要的要素。

# y includes our labels (wins and losses) and x includes our features
y = nfl.team_win_str
X = nfl[potentialFeatures].drop('team_win', axis=1)# change NAN to 0
where_are_NaNs = np.isnan(X)
X[where_are_NaNs] = 0

使用 sklearn 包及其相关的预处理实用程序来规范化数据。

from sklearn import preprocessingx = X[['qt_score_diff','ScoreDiff1','ScoreDiff2','ScoreDiff3','ScoreDiff5', 'qt3_won', 'qt4_won','EPA',
        'home_away','qt_wlt']].values #returns a numpy array
min_max_scaler = preprocessing.MinMaxScaler()
x_scaled = min_max_scaler.fit_transform(x)
X = pd.DataFrame(x_scaled)from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import f1_score,confusion_matrix
from sklearn.metrics import accuracy_score# split data train 70 % and test 30 %
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)#random forest classifier with n_estimators=10 (default)
clf_rf = RandomForestClassifier(random_state=43)      
clr_rf = clf_rf.fit(X_train,y_train)ac = accuracy_score(y_test,clf_rf.predict(X_test))
print("Accuracy on training set: {:.3f}".format(accuracy_score(y_train,clf_rf.predict(X_train))))
print("Accuracy on test set: {:.3f}".format(accuracy_score(y_test,clf_rf.predict(X_test))))
print('Accuracy is: ',ac)cm = confusion_matrix(y_test,clf_rf.predict(X_test))
sns.heatmap(cm,annot=True,fmt="d")

Figure 13 — Confusion matrix on Random Forest Classifier

准确率为 94.8%，从混淆矩阵中可以看出，我们做了一些错误的预测。现在让我们看看其他特征选择方法，以找到更好的结果。

支持向量机

from sklearn.svm import SVC
svc = SVC()
svc.fit(X_train, y_train)
print("Accuracy on training set: {:.3f}".format(accuracy_score(y_train, svc.predict(X_train))))
print("Accuracy on test set: {:.3f}".format(accuracy_score(y_test, svc.predict(X_test))))**Accuracy on training set: 0.938
Accuracy on test set: 0.938**

与随机森林相比，SVM 的精确度较低。

逻辑回归

from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression()
logreg.fit(X_train, y_train)
Y_pred = logreg.predict(X_test)print("Accuracy on training set: {:.3f}".format(accuracy_score(y_train,logreg.predict(X_train))))
print("Accuracy on test set: {:.3f}".format(accuracy_score(y_test,logreg.predict(X_test))))**Accuracy on training set: 0.938
Accuracy on test set: 0.939**

与随机森林相比，逻辑回归的准确性较低。看来我们要随机森林了。

基于精度、召回率和特征重要性的随机森林模型评估

为了评估我们的模型，我们将利用精度和召回来更好地理解模型性能。从高层次来看，精度是正面预测的性能度量，而召回是数据集的整个正面部分的性能度量。

from sklearn.metrics import classification_report
print(classification_report(y_test,clf_rf_2.predict(x_test_2)))

Figure 14 — Precision and Recall Score for Random Forest

通过选择随机森林，我们可以计算模型使用的每个特征属性的相对重要性。这些重要性值用于理解所选特征的等级。下面我们列出了 5 大特点。

def plot_feature_importances(model):
    plt.figure(figsize=(10,5))
    n_features = len(model.feature_importances_)
    plt.barh(range(n_features), model.feature_importances_, align='center')
    plt.yticks(np.arange(n_features), feature_labels)
    plt.xlabel("Feature importance")
    plt.ylabel("Feature")
    plt.ylim(-1, n_features)plot_feature_importances(clf_rf_2)

Figure 15 — Feature Importance from Random Forest

根据我们的随机森林模型，上面显示了影响一个团队是否获胜的最重要的特征，并且看起来第一季度的得分差异在相关性和预测中起着重要作用。

最后，我们每个季度单独运行模型，并生成功能性能和功能重要性分数。

Figure 16 — Feature Performance and Importance based on discrete quarter perdictions

有趣的是，随着季度的进展，我们可以看到第一次得分的重要性降低，相反，qt_score_diff 增加，这是季度得分的点差。

摘要

这是一个有趣的分析，这篇文章并不是要得出第一季度的胜利不重要的结论，但是正如我们所看到的，在第一季度的胜利和整个赛季的胜利之间有很强的相关性。

创建这篇文章的源代码可以在这里找到。如果您有任何问题或反馈，请告诉我。

NHL 分析:投篮，篮板和微弱信号

原文：https://towardsdatascience.com/nhl-analytics-shots-rebounds-and-weak-signals-c293ba8c635f?source=collection_archive---------15-----------------------

浅析射门及其对曲棍球比赛获胜的影响

任何职业运动都是百分比练习。职业选手在这项运动中是所有人中排名前 99.99%的人。这一事实扭曲了我们对优秀和不优秀玩家的看法，也扭曲了我们对游戏中微小但重要的部分的影响的估计。NHL 也不例外——事实上，NHL 的明显随机性(与 NFL 和 NBA 相比，最好的球队赢得最少的比赛)可能会使它最终变得更加重要。一个小小的优势可能会导致赢得比赛的系统性增加，并大幅增加将奖杯带回家的可能性。在我们的分析中，我们将致力于发现和揭露这些小想法，并揭示一些潜在的游戏破坏者。

注意——下面的交互式图表在小型移动设备上效果不佳。如果你想探索它们，最好在台式机或平板电脑上观看。

首先是篮板。

守门员训练多年来学习如何防止他们，整个球队专注于创造他们。看到一个从球门区弹起的击球落在队友等待的球棍上，通常会导致进球。我们想知道这有多重要？不仅知道篮板球是如何发生的，而且知道在哪里、什么时候以及为什么会发生，可能会让我们增加获得篮板球的机会——从而带来更多的进球和更多的胜利。

什么是反弹？

在我们理解为什么篮板是至关重要的之前，我们需要准确理解什么是篮板。理解这一点需要大量的数据；幸运的是，NHL 主持并发布了绝大多数游戏中的统计数据。剧本被精确地记录下来，这使我们能够挖掘和提取一些有趣的花絮。在这一块，我们看到了超过 7000 场比赛和超过 400，000 个镜头。

因为我们不能仅仅说哪些投篮被认为是篮板(这在原始数据中没有分类)，我们可以通过以下方式寻找统计分类:

查看所有镜头之间的时间，以及；
寻找标准评分率与提高的评分率之间的显著偏差

假设是，如果篮板确实带来更好的得分机会，我们会看到一个更好的得分率。下面是一张图表，显示了得分率与两次投篮之间的时间的关系。

显然，对于任何小于三秒的时间，得分率都有显著的增加(在两秒时达到峰值)。如果投篮和反弹之间的持续时间是两秒，那么得分的可能性几乎是四倍！另一个不足为奇的发现是——与所有其他投篮相比，篮板导致的投篮次数和进球次数大幅增加。

因为我们可以有把握地说，在第一次投篮之后有三秒钟的时间，得分的概率会急剧增加，所以我们可以有把握地把这个范围内的所有投篮都归类为“篮板”这对这件作品的其余部分非常重要。

1–2–3

为什么两秒后的篮板比一秒后的篮板好？为什么 2 秒后的篮板比 5 秒后的篮板重要得多？

如果下一次射门发生在三秒钟之内，守门员没有足够的时间复位，他就不在位置上了。
不到一秒的投篮很可能是一个接一个的快速投篮(想想试图把冰球塞进去)。更有可能的是球员没有抢到干净的篮板。一秒钟内拍摄的照片比两秒钟内拍摄的照片多得多，这一事实进一步证明了这一点。
两秒钟的镜头往往是最佳拍摄点。在两秒钟时，守门员没有足够的时间复位，而球员有时间射门。2 秒出手次数的大幅下降也强化了这一点(把这当成篮板球的圣杯吧)。

现在我们知道了反弹是什么，我们可以看看它们有多重要。

Roughly 5% of shots that constitute rebounds lead to over 15% of the goals scored.

虽然抢篮板的投篮只占所有投篮的 5%,但他们占所有进球的 15%以上。在下图中，我们可以看到这些镜头在热图上的位置。

大多数镜头来自意料之外的地方。如果我们换个角度来看这个问题——从一个特定的位置投篮可能会导致篮板，我们会发现一些更分散的东西。你离禁区越近，投篮就越有可能导致反弹，但是投篮导致反弹的概率并不像实际投篮那样偏斜。

这指向了一个假设，即投篮地点和他们导致反弹的可能性(即得分机会)之间的关系没有一些人想象的那么强。也许球队应该更少地关注正确的投篮，而更多地关注更多的投篮？

好镜头 vs 更多镜头

从我们目前所看到的来看，假设一支把更多投篮机会转化为篮板的球队更有可能赢得比赛是有道理的。我们还注意到，在非常接近夜晚的时候拍摄的镜头非常集中，尽管这些镜头很难获得。也许球队应该更关注投篮而不是正确的投篮？

从分析的数据来看，更高的篮板球率实际上并不意味着更高的胜率。事实上，较高的反弹率与较低的胜场数相关联！

我们还发现，更高的篮板率与投篮次数更少有很大关系，而且投篮次数越多，胜率越高。

有必要在上下文中思考上述结果。所有的图表都有很大的差异，但是一些数据点有明显的趋势。我们可以看数据的另一种方式是看游戏水平而不是季节水平。有趣的是，我们发现了相反的效果。当我们一场一场地看时，我们看到投篮次数少的球队往往赢得更多的比赛(以微弱优势)。也许一场比赛中篮板率较低的球队得分更高？

要知道每队场均篮板数只有 3.9 个。在大多数情况下，篮板最多的球队只多一个篮板。

这是违反直觉的——以至于我花了很多时间梳理代码寻找错误。一个合理的解释可能是，在一个赛季中，一支投篮次数很少、篮板率很低的球队确实太努力寻找正确的投篮。相反，一个有很多投篮机会的团队会投更多的球(导致更好的结果)。也许游戏与游戏之间的数据差异太大(在我之前已经有很多人做过类似的分析)以至于它们毫无意义？

如果你还是不相信我？这是获胜队和失败队的击球对比图。完全是噪音。

指出这一点的一个具体例子是 2017-2018 赛季的卡罗莱纳飓风。他们场均投篮次数第四高，场均投篮次数最少，但是他们没有进入季后赛。

接下来的步骤

我的分析得出的一个主要结论是，曲棍球是一项非常复杂的运动。很难指出个别的统计数字并作出明确的陈述。可以肯定的是，我不是第一个登陆这里的人。

然而，我们确实在更长时期的统计数据中发现了有意义的关系(尽管是微弱的关系)。可能的情况是，虽然单个游戏的统计数据非常嘈杂(或者，事实上，几乎是随机的)，但我们可以在季度或月度水平上找到更好的关系。

本系列的下一篇文章将关注团队，以更好地理解投篮、篮板、团队行为和胜利之间的关系。

附言:

接下来，我将对大部分分析进行基于代码的演练。有兴趣就跟着我吧！
我正在为这种类型的分析建立一个高级分析应用程序，我正在寻找一个软件/数据工程师来帮忙。框架是 Python 使用 Dash/Plotly。有兴趣的话 Ping 我@ jessemoore07@gmail.com。

演职员表:

这里的原始数据集—https://www.kaggle.com/martinellis/nhl-game-data

绘制冰场的起点—https://modern data . plot . ly/NHL-shots-analysis-using-plot ly-shapes/

NHS 实验室需要数据科学

原文：https://towardsdatascience.com/nhs-laboratories-need-data-science-c93f7983302c?source=collection_archive---------6-----------------------

Photo by Ousa Chea on Unsplash

当你感觉不舒服，你去看你的家庭医生，或者当你感觉非常不舒服，你发现自己躺在医院的病床上，你可能会发现临床工作人员收集你的体液，并把它们送到一些神秘的地方进行分析。大批技术人员、科学家和临床工作人员占据了样本的目的地。利用新老技术，生物医学科学家(像我一样)开始生成反映取样时你的状况的数据。我的背景是传染病诊断学，所以我的任务是培养和研究占据你样本的致病(“有害”)细菌。首要目标是确定感染的原因，并告知临床医生哪些抗生素能有效杀死“细菌”。

我和许多其他人一样，认为在这个过程中产生的数据量是天文数字，但目前还没有得到充分重视。该数据的主要用途是为临床医生生成报告，以建议疾病的诊断和治疗。除此之外，这些数据并没有被大量使用，而是闲置在庞大的数据库中。英国公共卫生部做了大量工作来提供人口健康的概况，但仍有大量数据没有超出其主要目的。我认为这是由于一线缺乏数据科学专业知识。

我们在谈论多少数据？

皇家病理学家学会很好地总结了 NHS 病理服务的重要性:

英格兰有 105 家医院提供病理服务
每年处理超过 10 亿次测试，总计花费 22 亿美元
英国最大的病理学服务机构 Barts NHS Trust 每年进行 2600 万次检测

为了说明仅在医学微生物学领域就产生了多少数据，让我们考虑一个实验室和一种样本类型。牛津大学医院微生物实验室每年处理超过 60 万份独特的样本。被称为血液培养的样本将占据这 600k 样本中的一小部分。

血液样本被放入血液培养瓶中(见下文),然后在专门的机器上培养，以寻找细菌生长的迹象。当在瓶中检测到生长时，将其取出并进一步分析(将血液涂在各种生长培养基上用于鉴定和抗生素敏感性测试)。血液培养的目的是检测血液感染(菌血症)，这是一种严重的疾病，表明细菌已经渗入循环系统，可能导致严重的后果，如心内膜炎或败血症。幸运的生物医学科学家预计每天会有 4 到 5 个阳性血液培养，但实际上更有可能是每天 10 到 20 个阳性。

By Strolch1983 — Own work, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=792954

对于单一阳性血培养，将收集/生成以下数据:

与患者相关的人口统计信息(年龄、性别、位置等)
描述患者状况的临床细节
唯一标识符，将该样本数据与在该患者身上收集的所有其他样本相关联
孵化数据；显示细菌指标随时间变化的时间序列数据
细菌在各种生长介质上生长的图像(仅在采用自动读数技术的实验室中，如 Kiestra/Copan WASP，这种技术越来越受欢迎)
MALDI-TOF 质谱产生的光谱数据；用于细菌鉴定
细菌分离物的生化特征(15+化学相互作用)；用于初始细菌鉴定或在 MALDI-TOF 不可用/不可靠时广泛使用
细菌基因组数据；偶尔需要对细菌分离株进行基因分型(通常是为了控制感染)，但预计细菌分离株的基因分型分析将成为规范
抗菌药物敏感性数据；这是与细菌分离物对过多抗生素的敏感性相关的数据

因此，像血液培养这样的样本可能会产生数十甚至数百个数据点，并生成不同格式的数据(图像、光谱、分类和数字)。现在，请记住，这种类型的分析已经进行了几十年，并且在过去的 15 年中(至少)这些数据一直以数字形式存储。毫无疑问，NHS 实验室产生了难以想象的大量数据。

数据科学能为 NHS 实验室做什么？

任何 NHS 实验室的主要关注点是提供一个成本有效但准确的测试结果，可以就病人的情况向临床医生提出建议。然而，围绕这一主要目标有一系列活动，每一项活动对其执行都至关重要。为了运行一个现代化的实验室，必须考虑 IT 基础设施、自动化分析平台、质量控制措施、库存控制和消耗品的使用，以及员工的管理和培训。数据科学的技术不仅可以应用于主要目标，而且还可以帮助承担保持船只漂浮的任务。

提高质量和收回控制权

实验室要想通过 UKAS 检测,就必须证明用于生成测试结果的技术和自动化平台是经过验证的，并以符合 ISO 标准的方式进行控制。随着工作量的增加和测试复杂性的增加，在人员短缺和预算削减的背景下，达到这些标准从未像今天这样困难。值得称赞的是，英国国家医疗服务体系的病理学服务仍然能够提供高质量的服务。

在分析测试质量或验证新程序时，需要依赖小样本和经典的统计推断，因为无法获得进行多变量数学建模所需的专业知识和工具。在某些情况下，趋势分析是由质量保证软件自动进行的，但更多情况下，这只是查看变化，并在值超过阈值时通知科学家。可用于质量指标预测建模的大型数据集很少使用。

在这一领域有一些令人兴奋的进展，有文献描述了使用统计指导协议和机器学习来检测分析前错误。让生物医学科学家非常沮丧的是，在样本到达实验室之前，分析中的错误往往是不可避免的。在同一份杂志中，你可以找到通过使用人工神经网络实现测试验证自动化的例子，在不影响患者安全的情况下显著减少了工作量。

最重要的是，通过利用本地数据、拥有技术能力更强的员工(具备编程和构建小型定制解决方案的知识)以及获得实验室性能的“鸟瞰图”，可以更容易地识别和解决瓶颈和低效问题。

机器人会阅读！

Photo by Rock'n Roll Monkey on Unsplash

差不多了。近年来，自然语言处理(NLP)取得了很大进展，特别是随着深度学习和递归神经网络的发展。从提高识别术后并发症的灵敏度，到利用电子病历的表现型分类算法，NLP 在整个医学界都显示出了前景。

NLP 在实验室里会有很大的好处。许多样本处理和加工依赖于临床工作人员提供的书面描述。对这一数据的解释仍然依赖于生物医学家，因为有很多 c 丢失电话。

如果 NLP 可以在样本进入实验室之前用于评估样本的安全性，或者在报告发送给临床医生之前用于评估报告的质量，会怎么样？工作人员不可能手工完成的任务，但可以由带老花镜的机器人自动完成。

实验室结果+机器学习=未来！

机器学习可以帮助实现提供病理学服务的根本目标——预测是什么导致了患者的疾病！

无论是将细胞类型分类为癌性或非癌性，使用多维数据将患者状态的生化描述归因于已知疾病，还是预测一种分离的病原体是否会对选择的药物敏感，机器学习都是这项工作的理想工具。

研究界和私营企业已经显示出一些希望:

深度学习应用于从宏基因组数据预测抗生素耐药性；可能会改变我们检查病人的方式
组成神经网络可用于读取革兰氏染色，这是目前用于诊断菌血症原因的费力方法
使用高维数据集准确预测生化分析结果
通过分析前列腺癌或乳腺癌证据的图像数据，使用深度学习技术减少临床病理学家的工作量
预测革兰氏阴性菌血症患者的死亡率
利用现成的实验室血液检测结果对血液疾病进行分类
使用机器学习技术的自动图像分析正在迅速进入医学微生物实验室的工作流程，提供了替代费力的培养物阅读。工作示例包括现象矩阵和 APAS 独立

数据科学如何与当前实践融合？

正如你所看到的，有大量的例子表明数据科学和机器学习的预测能力可以用来改革 NHS 的病理学服务。认为私营企业将在这项事业中发挥关键作用似乎是完全合理的，但我想提出的论点是，NHS 实验室应该专注于发展自己的数据科学团队。

就目前的情况来看,“数据科学家”的角色在 NHS 实验室中并不存在。事实上，很难找到专门的 it 人员，更不用说分析师/数据科学专家了。NHS 实验室的职业结构非常僵化。对我来说，这似乎很可笑；这是一个产生大量有价值数据的服务，但是手头没有从这个资源中获利的技能。NHS 迫切希望通过提高效率来节省开支，利用其数据可能有助于实现这一目标。

世界正在改变，我们正在进入应用机器学习和自动化的复兴。随着分子技术的发展和自动化程度的提高，对生物医学科学家手动分析临床标本的需求将会下降。生物医学科学家转移到更具分析性的角色似乎是很自然的，他们操纵实验室中产生的数据并为研究做出贡献。

然而，对生物医学科学家的培训几乎没有跟上。对使用 whatuni.com 的英国大学的快速回顾(按就业率排名)显示，在提供生物医学学士学位的 9 所顶级大学中，只有 2 所提供基本统计分析以外的培训，即 R/Python 编程和高级生物信息学技术。在这两所大学里，培训都是最后一年选修课的一部分。

令人沮丧的是，这些 NHS 实验室被聪明而热情的科学家占据，在正确的指导下，他们可以采用所需的技术来利用手头的数据资源。大多数生物医学科学家在晋升到高级职位之前都会攻读硕士学位，但是很少考虑数据科学硕士学位。我认为，就目前学习数据科学和编程的情况来看，硕士学位可能并不是启动这一进程的必要条件。有了 DataCamp、DataQuest 和 Udacity 等平台，生物医学科学家可以按照自己的节奏学习，只需要时间和互联网接入。

一旦掌握了这些技能，就可以开始在当地应用，帮助提高服务质量和效率。我也看到了增加病理学实验室参与当前研究的机会。生物医学科学家比任何人都更了解 NHS 实验室生成的数据，并且将是准备大型病理学数据集进行研究的数据争论的完美匹配。尽管这些年来数据访问有所改善，随着标准化实践和基础设施的改善(例如 SNOMED、HL7、NLMC 和 NHS number ),局部细微差别几乎是不可避免的，尤其是在对历史数据进行回顾性分析时。

因此，展望未来，我认为我们现在需要的是专注于建立一种鼓励我们的生物医学科学家参与数据科学的文化。在 NHS 实验室内设立分析职位需要支持和更大的灵活性，并有可能利用在线数据科学培训服务和远程学习。但最重要的是，我们需要积极主动的管理，专注于发展我们所处的范式转变所需的基础设施和法律框架。从长远来看，机器学习在病理学中的应用可能需要专门的数据工程师和大型数据仓库项目，但一个具有成本效益的起点将是准备好我们现有的员工；他们已经具备了理解我们想要利用的数据所必需的特定领域的知识。

至于我在这里所讨论的法律和伦理上的分歧，我故意把它遗漏了。我想在另一篇文章中解决这个问题。政府中的许多人已经将 NHS 数据视为‘金矿’，但是随着剑桥分析公司(Cambridge Analytica)和像乳房筛查丑闻这样的灾难仍然记忆犹新，我们必须尽我们所能确保患者的安全和隐私是绝对的优先事项。

ML 街上的噩梦:人工智能在放射学中的黑暗潜力

原文：https://towardsdatascience.com/nightmare-on-ml-street-the-dark-potential-of-ai-in-radiology-71074e70da91?source=collection_archive---------0-----------------------

如果放射学人工智能被用来对付我们，而不是帮助我们，会怎么样？

我们都听说过摇滚明星企业家和天才学者之间的重大哲学争论和辩论——但我们有没有停下来想想放射学人工智能革命将如何在我们自己的地盘上展开？

今年在 RSNA，我向所有与之交谈的人提出了同样的问题:如果放射学人工智能落入坏人之手会怎样？从人群用脚投票挤满每一场关于人工智能的讲座的方式来看，放射科医生肯定似乎非常清楚这个行业即将发生的地震式转变——但我想知道是否有人在考虑潜在的副作用，即将这样一项颠覆性技术投入临床领域的意外后果？

虽然我对算法增强在放射实践中的前景和潜力感到非常兴奋，但我也对更多恶意方利用它获取掠夺性经济利益感到有点紧张。这就是我所说的“曼梯·里街的噩梦”场景…

幸运的是，这个广告是假的(我伪造的)，但我想以绝对清晰的方式描绘可能会发生的法医噩梦。

让我们先假设几件事:

放射学人工智能算法达到了被临床验证为超人的程度。我认为这几乎是确定的，只要给足够的时间。我们还没到那一步——毕竟，还没有一个随机对照试验或 III 期研究证明这一点——但这些都将到来。大量早期证据表明，如果在足够高质量的标注数据上进行训练，算法在寻找特定事物方面确实比放射科医生更准确。
医疗过失诉讼允许对病历进行回顾性分析，包括影像学研究。这就是目前的情况，也是“没有胜利，就没有费用”的律师事务所的谋生之道，他们掠夺那些感到他们的治疗没有达到他们期望的不满的病人。在法庭上，这些公司只需排除合理怀疑，证明一名医生根据他们的执业守则玩忽职守和表现不佳。这是通过简单地引入一个专家证人来确认一个错误。在放射科，这是非常容易的，因为放射科医生，远远超过任何其他专业，拍下他们的错误。
放射学报告是一份书面的、数字签名的和可追溯的文档，它将放射科医师与他们的意见绑定在一起。一旦写好(除非进行了修改并传达了变化),该报告就成为患者护理记录中不可改变的一部分，并成为整个诊断过程的一部分。如果最终诊断是错误的，甚至完全被忽略，那么就有图片和书面证据来证明发生了医疗错误。

31%的美国放射学家在其职业生涯中经历过医疗事故索赔，其中“漏诊”是最常见的。乳腺癌高居榜首，紧随其后的是漏诊骨折和肺癌。甚至最近出现了诉讼增加的趋势，部分原因是工作量的不可阻挡的增长和对效率的推动，以及医疗保健提供商的整合，最终导致质量明显下降。

然而，为了开始一个医疗事故案件，病人必须找到律师事务所，并要求提供医疗记录作为证据。实质上，是否启动法律程序是患者的自由裁量权。

这就是我开始关注放射学人工智能的地方。想象一下，一家律师事务所开始以今天事故追逐者的方式直接向消费者做广告。毕竟，病人被允许要求一份他们的成像和报告的副本，并且可以自由地与他们选择的人分享。如果一家律师事务所能够说服用户交出他们的护理记录和图像，以获得使用人工智能的“免费”检查服务，我们可能会开始看到越来越多的回溯性临床错误被发现。

让我们举个例子:

史密斯先生在网上看到一个不赢不付费服务的广告，以检查他的扫描报告是否正确。他从医疗服务提供商那里下载了他的医疗记录，包括胸部 CT，并上传到律师事务所的服务器上。几秒钟后，算法在 T10/11 发现一个 5 毫米的肺结节和轻度变性，这两个发现都没有包括在原始报告中。该网站建议咨询律师，然后律师建议他们起诉医疗事故。史密斯先生说，想起来了，他的背部有些疼痛，现在他担心自己得了肺癌。他做了一次重复的 CT 扫描，结节现在是 8 毫米。诉讼进入审判阶段，最初的报告放射科医生被叫来，一名专家证人同意该算法，是的，显然有一个肺结节和一些脊柱退化。法官敲了敲他的锤子，结果，几百万美元被支付了。

到目前为止，没有什么特别的问题。一个遗漏的发现被证实了，诉讼成功了。与今天的情况相比，这里唯一的不同是涉及到了一个算法。

(希望没有人错过这个诊断…)

这才是真正可怕的地方…

如果有足够多的患者经历这一过程，这家掠夺性的律师事务所可能会对医疗保健提供商提起集体诉讼。这是一个全新层次的法律程序。理论上，集体诉讼允许起诉方要求获得全部病历，甚至可能与他们所代表的病人无关。这可以以病人安全的名义进行，声称整个放射科都不适合执业，因此在那里接受治疗的每个人都有知情权。

法官可以裁定允许对医院的整个扫描回溯性分析——一次分析数十万张图像。放射学人工智能算法可以在几个小时内轻松处理这些数据，并有可能发现数百万未报告的肺结节。支付的法律后果和规模是惊天动地的，是职业生涯的终结和职业生涯的毁灭。

我真诚地希望我们永远不要陷入这种境地。

有些人会说这是绝对不允许的。使用以前没有的新工具进行回顾性检查是不公平和不道德的——我同意这一点。然而，我担心的是恶意的第三方使用放射学人工智能只是为了找到错误和失误，然后使用人类专家证人来确认它们。以这种方式，在法庭上，这是人对人，就像今天进行的医疗事故诉讼一样。唯一不同的是，人工智能被用来以前所未有的规模揭露这些案件。

我所强调的完全是理论上的，尽管并非完全不可能。人工智能有可能极大地改善放射工作流程并增加放射学家。如果在正确的环境下用在正确的人手里，它将彻底改变这个领域。然而，如果它落入坏人之手，被用来对付我们，我们将面临一个真正可怕的未来，这只会损害我们的职业和我们照顾病人的能力。

现在有趣的伦理问题是——作为放射科医生，我们是想保护自己免受追溯算法的交叉检查，还是有义务给我们的病人提供尽可能最好的护理，即使这意味着找到我们以前所有的错误？

无论你的观点如何，看看放射学人工智能的前景如何发展将会很有趣。我希望这场噩梦不会把我们从实现我们既定目标的梦想中唤醒！

如果你和我一样对放射学人工智能的未来感到兴奋，并想讨论这些想法，请保持联系。我在推特@drhughharvey

如果你喜欢这篇文章，点击推荐并分享它会很有帮助。

关于作者:

哈维博士是一名委员会认证的放射科医生和临床学者，在英国国民医疗服务体系和欧洲领先的癌症研究机构 ICR 接受过培训，在那里他两次获得年度科学作家奖。他曾在 Babylon Health 工作，领导监管事务团队，在人工智能支持的分诊服务中获得了世界第一的 CE 标记，现在是顾问放射科医生，皇家放射学家学会信息学委员会成员，以及人工智能初创公司的顾问，包括 Kheiron Medical。

算法决策的九个机会和风险

原文：https://towardsdatascience.com/nine-opportunities-and-risks-of-algorithmic-decision-making-77d1e712af65?source=collection_archive---------6-----------------------

1.规范性原则

机会 : 在设计 ADM 流程时，必须在使用该流程之前做出规范性决策(例如关于公平标准)。这提供了一个从一开始就彻底公开讨论道德问题并记录决定的机会。

风险*:*ADM 流程可以包含隐藏的规范性决策。如果只有在设计阶段完成后才有可能进行讨论，那么任何规范性原则都更有可能被认为是不可更改的

2.数据

机遇 : 软件可以分析比人类多得多的数据，从而更快、更准确、更便宜地识别模式和回答某些问题..

风险 : 用于 ADM 流程的数据可能包含看似被流程本身具体化的失真。如果相关性背后的因果关系没有得到证实，那么无意的、系统的歧视就很有可能成为这一过程中被接受的一部分。

3.应用的一致性

机会 : 基于算法的预测将预先确定的决策逻辑应用于每个个案。与人类决策者相比，软件没有好坏之分，并且在某些情况下不会任意使用新的、有时不合适的标准。

风险 : 在例外情况下，通常不可能对未预料到的相关事件进行评估并做出相应反应。ADM 系统总是利用任何不正确的训练数据和错误的决策逻辑。

4.可量测性

机会 : 软件可以应用于一个潜在的比人类决策者所能响应的大很多倍的应用领域，因为系统中使用的决策逻辑可以以非常低的成本应用于几乎无限数量的情况。

5.可验证性

机会 : 数据驱动和数字系统可以以一种清晰易懂的方式构建，允许对它们进行解释和独立验证，并提供取证数据分析的可能性。

风险 : 由于流程设计和运营应用，对决策的独立评估和解释往往只在有限的程度上是可能的、可理解的或制度化的。

6.适应性

机会 : ADM 流程可以通过使用新的培训数据或自学系统来适应新的条件

风险 : 各个方向的适应性的对称性取决于过程是如何设计的。片面的适应也是可能的。

7.效率

机会 : 让机器评估大量数据通常比让人类分析师评估相同数量的数据更便宜。

风险 : E 通过 ADM 流程获得的效率收益可能会掩盖可用资源的绝对水平过低或不足的事实。

8.个性化

例如，在互联网出现之前，许多研究助理和图书馆员需要提供来自单个搜索引擎查询的信息的广度和深度。

风险 : 当 ADM 流程成为用于大众市场的主要工具时，只有少数特权阶层有机会接受人类决策者的评估，这在预选候选人或授予信用分数的非标准情况下可能是有利的。

9.人类对基于机器的决策的感知

机会 : ADM 流程在做统计预测时可以非常一致。在某些情况下，这种预测比人类专家做出的预测更可靠。这意味着软件可以作为一种辅助工具，为更重要的活动腾出时间。

风险 : 人们可以将软件生成的预测视为比其他信息更可靠、更客观、更有意义。在某些情况下，这可能会阻止人们质疑建议和预测，或者导致他们仅以推荐的方式对其做出反应。

本文摘自 Konrad Lischka 和 Anita Klingel 撰写的工作文件“”Wenn Maschinen Menschen bewerten—international e falbeispiele für Prozesse algorithm ischer Entscheidungsfindung”，由贝塔斯曼基金会以 CC BY-SA 3.0 DE 出版。

本出版物记录了我们对该主题调查的初步结果。我们将其作为 工作文件 发布，以一种其他人可以借鉴的方式为这个快速发展的领域做出贡献。

[ NIPS 2011 /吴恩达 Tensorflow 中带交互代码的稀疏滤波一瞥

原文：https://towardsdatascience.com/nips-2011-andrew-ng-first-glance-of-sparse-filtering-in-tensorflow-with-interactive-code-659c4e84658e?source=collection_archive---------6-----------------------

GIF from this website

【Neil Bruce 博士，( Google scholar Page )我的导师推荐我阅读这篇论文，我真的很想获得对稀疏滤波更实际的理解。(所以才发这个帖子。)

在这篇文章中，我将首先看到不同降维技术的效果，包括…

1。 主成分分析 2。 独立成分分析。 3。 线性判别分析 4。t-分布随机邻居嵌入。 5。 因素分析 6。 稀疏过滤

请注意这篇帖子是为了我对稀疏滤波的理解。

降维

Image from this website

在继续之前，我想简单回顾一下降维的效果。但是请注意，这些算法背后的数学不在本文讨论范围之内，但是如果有人感兴趣，我会在下面链接一些好的资源。

Video from StatQuest with Josh Starmer

如果你想知道 LDA 和 PCA 的区别，请点击这里或点击这里。

示例:清晰分离的数据

简单地说，我们有上面的数据点，不同的颜色代表不同的类别，每个数据点有 3 个轴(X，Y，Z)。现在让我们先来看看每个分解算法是如何分解这些数据的。(作为开始，我们将只把维数减少 1 倍。)

Different decomposition algorithm to reduce the dimension to 2

他们都做得很好，将相同的类聚集在一起，现在让我们看看何时将维度减少到 1。(删除二维)。

同样，当原始数据彼此明显分离时，我们可以看到大多数算法在降低维度方面做得很好，同时对每个类进行聚类。(虽然这里那里有一些离群值。)

示例:没有清晰分离的数据

现在为了让事情变得更难，让我们来看一个没有从每个类中明确分离的例子。

从表面上看，大多数算法只是移除了 Z(深度)轴，最后让我们来看看将维度减少到 1 的情况。

从一瞥中，我们可以注意到一个模式，当与紫色点相比时，黄色点更倾向于聚集(t-SNE 或 LDA 不是这种情况)。然而，我们得到的是一个非常有趣的结果。

特征分布的理想性质

在继续之前，我想介绍一下特征分布的一些期望的性质。(我个人认为这个话题很重要)

每个示例的稀疏特征(总体稀疏) →矩阵中的每个元素(或每个示例)应该仅由少数(非零)特征来表示。

跨示例的稀疏特征(生命周期稀疏) →每个特征应该允许我们区分不同的示例。(换句话说，特征应该足够有效，让我们能够区分不同的例子。)

活动分布均匀(高度分散) →对于每个示例，活动特征的数量应与其他示例相似。

稀疏滤波

蓝线 →稀疏滤波算法

稀疏过滤的主要思想非常简单，通过无监督的方式学习数据的新特征(更紧凑的表示)。我们实现这一点的方法是简单地对矩阵的所有例子取 L2 范数并执行归一化。然后我们再次规范化这些例子，但是这次是每个例子。最后，我们通过 L1 罚函数最小化特征的总和。关于这个方法为什么有效的更多理论理由请点击这里。

如上所述，对于这个实验，我们也将遵循论文的原始作者所做的，将软绝对函数作为我们的激活函数。对于 Numpy 实现，我们将使用有限内存 BFGS 优化算法，对于 tensorflow，我们将使用 Adam 优化器。

结果:稀疏滤波(Numpy)

左上/右下 →清除分色数据 2D // 1D
左下/右下 →不清除分色数据 2D // 1D

从 subramgo 中取代码，我们可以观察稀疏滤波是如何降维的。总的来说，它在聚类相似的类方面做得很好，但是，对于具有明显分离的数据的 1D 归约，我们可以观察到它不能清楚地将每个类聚类到不同的 x 轴点。

结果:稀疏滤波(张量流)

左上/右下 →清除分色数据 2D // 1D
左下/右下 →不清除分色数据 2D//1D

既然我喜欢 tensorflow，我就直接复制了 Numpy 实现的代码。然而，与 Numpy 实现的一个区别是，我们将使用 Adam Optimizer。(而不是有限内存 BFGS )。).

令人惊讶的是，(我个人认为)，它比 Numpy 版本做得更好。特别是当我们看一下清晰分离数据的 1D 缩减时。此外，对于没有明确分离的数据，我们可以观察到大多数绿色圆圈聚集在一起，而其他紫色和黄色圆圈更加分散。

互动码

对于 Google Colab，你需要一个 Google 帐户来查看代码，而且你不能在 Google Colab 中运行只读脚本，所以在你的操场上复制一份。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！同样为了透明，我在 github 上上传了所有的训练日志。

要访问 PCA、LDA、ICA 等的代码… 请点击此处。
访问 Numpy 的代码稀疏点击这里，训练日志点击这里。
访问 tensorflow 稀疏代码点击此处，训练日志点击此处。

最后的话

我为这篇文章缺乏结构而道歉。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

同时，在我的推特上关注我这里，访问我的网站，或者我的 Youtube 频道了解更多内容。我还实现了广残网，请点击这里查看博文 pos t。

参考

Ngiam，j .、Chen，z .、Bhaskar，s .、Koh，p .、和 Ng，A. (2011 年)。稀疏过滤。Papers.nips.cc 于 2018 年 6 月 12 日检索，来自https://papers.nips.cc/paper/4334-sparse-filtering
, (2018).[在线]可在:https://www.linkedin.com/in/neil-bruce-19292417/【2018 年 6 月 12 日访问】。
[在线]可在:https://scholar.google.com/citations?user=Gnezf-4AAAAJ&HL = en【2018 年 6 月 12 日访问】。
控制图形美学-seaborn 0 . 8 . 1 文档。(2018).Seaborn.pydata.org。检索于 2018 年 6 月 12 日，来自 https://seaborn.pydata.org/tutorial/aesthetics.html
分区，L. (2018)。LDA 作为划分之前或之后的维度缩减。交叉验证。检索于 2018 年 6 月 12 日，来自https://stats . stack exchange . com/questions/305691/LDA-as-the-dimension-reduction-before-or-after-partitioning
sk learn . decomposition . PCA—sci kit—学习 0.19.1 文档。(2018).Scikit-learn.org。检索于 2018 年 6 月 12 日，来自http://sci kit-learn . org/stable/modules/generated/sk learn . decomposition . PCA . html
sk learn . decomposition . fa stica—sci kit—学习 0.19.1 文档。(2018).Scikit-learn.org。检索于 2018 年 6 月 12 日，来自http://sci kit-learn . org/stable/modules/generated/sk learn . decomposition . fa stica . html
Python？，H. (2018)。如何用 Python 制作 3D 散点图？。堆栈溢出。检索于 2018 年 6 月 12 日，来自https://stack overflow . com/questions/1985856/how-to-make-a-3d-scatter-plot-in-python
k 均值聚类和低秩近似的降维。(2018).Bigdata.csail.mit.edu。检索于 2018 年 6 月 12 日，来自http://bigdata.csail.mit.edu/node/277
sklearn.discriminant _ analysis。线性判别分析-sci kit-学习 0.19.1 文档。(2018).Scikit-learn.org。检索于 2018 年 6 月 12 日，来自http://sci kit-learn . org/stable/modules/generated/sk learn . discriminant _ analysis。lineardiscriminantanalysis . html # sk learn . discriminant _ analysis。linear discriminant analysis . fit _ transform
sk learn . manifold . tsne—sci kit-learn 0 . 19 . 1 文档。(2018).Scikit-learn.org。检索于 2018 年 6 月 12 日，来自http://sci kit-learn . org/stable/modules/generated/sk learn . manifold . tsne . html
sk learn . decomposition . factor analysis-sci kit-learn 0 . 19 . 1 文档。(2018).Scikit-learn.org。检索于 2018 年 6 月 12 日，来自http://sci kit-learn . org/stable/modules/generated/sk learn . decomposition . factor analysis . html # examples-using-sk learn-decomposition-factor analysis
StatQuest:主成分分析(PCA)解释清楚(2015)。(2018).YouTube。检索于 2018 年 6 月 12 日，来自 https://www.youtube.com/watch?v=_UVHneBUBW0
StatQuest: t-SNE，解释清楚。(2018).YouTube。检索于 2018 年 6 月 12 日，来自https://www.youtube.com/watch?v=NEaUSP4YerM
StatQuest:线性判别分析(LDA)解释清楚..(2018).YouTube。检索于 2018 年 6 月 12 日，发自https://www.youtube.com/watch?v=azXCzI57Yfc&LC = z 221 ubiy 3 qzoizzubacd p 431 wog 0 fwhls 5 iiwovere 5 w 03 c 010 c
sk learn . datasets . make _ classification-sci kit-learn 0 . 19 . 1 文档。(2018).Scikit-learn.org。检索于 2018 年 6 月 12 日，来自http://sci kit-learn . org/stable/modules/generated/sk learn . datasets . make _ classification . html
尺寸，S. (2018)。sk learn LDA-分析不会生成 2 维。堆栈溢出。检索于 2018 年 6 月 12 日，来自https://stack overflow . com/questions/49955592/sk learn-LDA-analysis-wont-generate-2-dimensions
主成分分析与独立成分分析继续-佐治亚理工学院-机器学习。(2018).YouTube。检索于 2018 年 6 月 12 日，来自https://www.youtube.com/watch?v=e4woe8GRjEI
你的参考书目:Anon，(2018)。[在线]可从以下网址获取:https://www . quora . com/What-is-the-difference-than-the-LDA-and-PCA-for-dimension-reduction【2018 年 6 月 12 日获取】。
subramgo/SparseFiltering。(2018).GitHub。检索于 2018 年 6 月 13 日，来自 https://github.com/subramgo/SparseFiltering
过滤，U. (2014)。无监督特征学习-稀疏过滤。Vaillab.blogspot.com。检索于 2018 年 6 月 13 日，来自http://vail lab . blogspot . com/2014/08/unsupervised-feature-learning-sparse . html
Metzen，J. (2018 年)。基于稀疏滤波的无监督特征学习。Jmetzen.github.io .检索于 2018 年 6 月 13 日，来自http://jmetzen.github.io/2014-09-14/sparse_filtering.html
资料 D. (2018)。禁用 Tensorflow 调试信息。堆栈溢出。检索于 2018 年 6 月 13 日，来自https://stack overflow . com/questions/35911252/disable-tensor flow-debugging-information
tensorflow？，W. (2018)。tensorflow 中 numpy.newaxis 的替代品是什么？。堆栈溢出。检索于 2018 年 6 月 13 日，来自https://stack overflow . com/questions/42344090/what-the-alternative-of-numpy-newaxis-in-tensor flow
类，P. (2018)。Python 调用类中的函数。堆栈溢出。检索于 2018 年 6 月 13 日，来自https://stack overflow . com/questions/5615648/python-call-function-within-class
(TensorFlow)？，D. (2018)。GradientDescentOptimizer 和 AdamOptimizer (TensorFlow)的区别？。交叉验证。检索于 2018 年 6 月 13 日，来自https://stats . stack exchange . com/questions/184448/difference-between-gradientdescentoptimizer-and-adamoptimizer-tensor flow
导入多个张量流模型(图表)Breta Hajek。(2017).布雷塔·哈杰克。检索于 2018 年 6 月 13 日，来自https://bretahajek . com/2017/04/importing-multiple-tensor flow-models-graphs/
TensorFlow，W. (2018)。在 TensorFlow 中使用多个图形。堆栈溢出。检索于 2018 年 6 月 13 日，来自https://stack overflow . com/questions/35955144/working-with-multiple-graphs-in-tensor flow
TensorFlow，W. (2018)。在 TensorFlow 中使用多个图形。堆栈溢出。检索于 2018 年 6 月 13 日，来自https://stack overflow . com/questions/35955144/working-with-multiple-graphs-in-tensor flow
有限记忆 BFGS。(2018).En.wikipedia.org。检索于 2018 年 6 月 13 日，来自https://en.wikipedia.org/wiki/Limited-memory_BFGS
正规化:简单的定义，L1 和 L2 处罚。(2016).统计学如何？检索于 2018 年 6 月 13 日，来自http://www.statisticshowto.com/regularization/
L -Norm —来自 Wolfram MathWorld。(2018).Mathworld.wolfram.com。检索于 2018 年 6 月 13 日，来自http://mathworld.wolfram.com/L2-Norm.html
Zennaro，f .，& Chen，K. (2016)。理解稀疏滤波:理论观点。Arxiv.org。检索于 2018 年 6 月 13 日，来自https://arxiv.org/abs/1603.08831

[NIPS 2017/Google] -在众目睽睽之下隐藏图像:具有交互代码的深度隐写术[带 TF 的手动背道具]

原文：https://towardsdatascience.com/nips-2017-google-hiding-images-in-plain-sight-deep-steganography-with-interactive-code-e5efecae11ed?source=collection_archive---------6-----------------------

Gif from here

所以几周前，我在 NIPS 2017 出版网站上发现了 Shumeet Baluja (谷歌研究员)的这篇论文“ 在众目睽睽之下隐藏图像:深度隐写术 ”。

和往常一样，让我们比较一下扩张反向传播与自动微分相比表现如何。

论文结果

红框→ 载体图像隐藏我们的秘密消息 蓝框→ 我们要隐藏的秘密消息 绿框→ 载体图像隐藏秘密消息后 紫框→ 从绿框图像中重构秘密图像

整个想法非常简单，我们将有一个载体图像，我们将在该图像中隐藏一些秘密信息(这是另一个图像),稍后再揭开它。现在让我们来看看这个模型的网络架构。

网络架构(高/低级别)

红框 →准备图像的神经网络(Prep Network)
黄框 →隐藏的神经网络(Hiding Network)
绿框 →揭示的神经网络(Reveal Network)

主要有三个网络，一个是准备图像、隐藏图像和揭示秘密图像。现在让我们来看看较低层次的实现。

红线 →网络架构描述

这篇文章的一个奇怪之处是，它没有详细描述网络体系结构。我甚至无法找到网络有什么样的激活功能。

所以在我的能力范围内，我相信每个网络有 5 层，每层有 50 个频道。准备网络的核大小为 3，隐藏网络的核大小为 4，最终显示网络的核大小为 5。同样，我将只使用 ReLU()激活函数，这个决定是通过实验性的试验做出的。

成本函数

然而，令人欣慰的是，这篇论文确实描述了网络使用哪种成本函数以及它使用哪种优化器。我们将使用亚当和 L2 损失函数，平方差。

以上是完整的误差函数，我们将载体图像和秘密图像之间的平方差。对于 scecrte 镜像误差函数，我们将在平方差前面有一个β项(我们将它设为 1，因此可以忽略它),它决定了我们必须将多少误差输入反向传播。但是，还有一点需要注意的是这个模型的梯度流。

红框 →从载体图像应用梯度流

如上所述，秘密图像的错误率一直向后传播，然而对于载体图像错误率，它仅应用于隐藏网络和准备网络。

网络架构(OOP 形式)

红框 →准备网络及其前馈操作
黄框 →隐藏网络及其前馈操作
绿框 →显示网络及其前馈操作

如上所述，网络本身并不难实现。因为它由 5 个卷积运算组成，且具有相同数量特征映射。这很容易。

实验设置

如上所述，我们将使用来自李辉蔡剑飞的公开可用数据作为语义图像分割的基准。此外，由于硬件限制，我们将所有的图像调整为 80 * 80 像素的图像。在上面的数据集中，有 100 幅彩色图像，我们打算用 50 幅作为秘密消息图像，剩下的 50 幅作为封面图像。

结果(自动微分)

左上图 →原秘密图
右上图 →原封面图
左下图 →准备图
下中间图 →秘密+封面图
右下图 →透露图

如上所述，该网络做得非常好，不仅隐藏了封面图像中的秘密图像，还揭示了它们。然而，在有些情况下，网络未能做到这一点。

左上图 →原秘密图
右上图 →原封面图
左下图 →准备图
下中间图 →秘密+封面图
右下图 →揭露图

如上所述，当图像包含各种不同的颜色时，显示的图像非常失真。

左图 →网络如何走向终结的汇编
右图 →网络如何随着时间的推移而走向终结的汇编

以上是网络在最后一个时期以及随着时间的推移如何工作的汇编，随着训练的继续(通过增加时期可以看到)，我们可以看到网络在隐藏图像方面做得更好。

结果(扩张反向传播)

左上图 →原秘密图
右上图 →原封面图
左下图 →准备图
下中间图 →秘密+封面图
右下图 →透露图

随着足够的时代扩大反向传播做了很好的隐藏图像。然而，类似于自动区分，也存在网络不能很好地运行的情况。

左上图 →原秘密图
右上图 →原封面图
左下图 →预备图
下中间图 →秘密+封面图
右下图 →已曝光图

以上是网络性能不佳时的完全相同的情况。

左 GIF →汇编网络如何在它的最后时代
右 GIF →汇编网络如何随着时间的推移

交互代码

对于谷歌实验室，你需要一个谷歌帐户来查看代码，你也不能在谷歌实验室运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

请点击进入扩张反向传播代码。
请点击进入自动微分模型代码

如果您希望在本地设备上运行代码，请从这个链接下载数据集，并相应地更改 data_location(如下所示)变量。

透明度

为了让这个实验更加透明，我把训练时产生的所有输出都上传到了我的 Gihub。恳求 se 点击这里查看日志。请点击此处查看手动反向传播日志。

最后的话

实际上，我在医学图像领域有一个非常有趣的用例，即将实现！

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

同时，在我的 twitter 这里关注我，并访问我的网站，或我的 Youtube 频道了解更多内容。如果你感兴趣的话，我还做了解耦神经网络的比较。

参考

导数双曲函数。(2018).Math2.org。检索于 2018 年 3 月 7 日，来自http://math2.org/math/derivatives/more/hyperbolics.htm
tf.concat | TensorFlow。(2018).张量流。检索于 2018 年 3 月 7 日，来自https://www.tensorflow.org/api_docs/python/tf/concat
Tensorflow，a. (2018)。张量流中的加性高斯噪声。Stackoverflow.com。检索于 2018 年 3 月 7 日，来自https://stack overflow . com/questions/41174769/additive-Gaussian-noise-in-tensor flow
正态分布。(2018).Mathsisfun.com。检索于 2018 年 3 月 7 日，来自https://www . mathsisfun . com/data/standard-normal-distribution . html
[2]2018.【在线】。可用:https://www . quora . com/How-can-l-visualize-cifar-10-data-RGB-using-python-matplotlib。【访问时间:2018 年 3 月 7 日】。
标准化数据/标准化。(2015).统计学如何？检索于 2018 年 3 月 8 日，来自 http://www.statisticshowto.com/normalized/
s . balu ja(2017 年)。隐藏图像:深度隐写术。在神经信息处理系统的进展(第 2066–2076 页)。
惠，L. (2018)。语义图像分割的基准。NTU . edu . SG . 2018 年 4 月 4 日检索，来自http://www . NTU . edu . SG/home/asjfcai/Benchmark _ Website/Benchmark _ index . html
超越 Tensorflow 的默认自动微分优化器，具有交互式代码[手动…(2018).走向数据科学。检索于 2018 年 4 月 4 日，来自https://towards data science . com/outpering-tensor flows-default-auto-difference-optimizer-with-interactive-code-manual-e587 a82d 340 e
Python 中的 DICOM:用 PyDICOM 和 VTK 将医学图像数据导入 NumPy。(2014).PyScience。2018 年 4 月 4 日检索，来自https://pyscience . WordPress . com/2014/09/08/DICOM-in-python-importing-medical-image-data-into-numpy-with-pydicom-and-VTK/
用不同的名称保存用 wget 下载的文件。(2018).电动工具箱。检索于 2018 年 4 月 4 日，来自https://www . electric toolbox . com/wget-save-different-filename/

NIPS 2017 研讨会和讲习班:可解释和贝叶斯机器学习

原文：https://towardsdatascience.com/nips-2017-symposium-and-workshop-interpretable-and-bayesian-machine-learning-fca56edfebe4?source=collection_archive---------6-----------------------

我的第一次 NIPS 出席和总结

上周，我参加了在加州长滩举行的 NIPS(神经信息处理系统)2017 会议。这是我第一次参加 NIPS。

什么是 NIPS？

NIPS 是世界上最大的机器学习(ML) /人工智能(AI)会议之一。NIPS 会议由三个项目组成:指导、主要活动(包括研讨会)和研讨会。今年，约有 8000 人出席，比去年增加了约 30%，显示出对机器学习的兴趣越来越大。

我只参加了研讨会和专题讨论会，但是根据它们的内容，我可以看到每个研讨会都是一个专门的专题，一整天都致力于一个单一的主题。每个研讨会由 5-6 个讲座和海报会议组成。大多数工作坊最后还会有小组讨论。我参加了关于贝叶斯 ML 的研讨会和关于可解释 ML 的座谈会。

赞助商

在谈论大会演讲之前，我首先想让你看看赞助商名单，因为它可以显示当前机器学习在行业中的格局。仅举几个赞助商的例子，微软、IBM Research、奥迪、英特尔 Nervana 是钻石赞助商(8 万美元赞助)，其次是白金赞助商(4 万美元)，如苹果、优步、脸书、谷歌、百度、阿里巴巴、亚马逊、DeepMind 等。综合列表见此处。

主题

研讨会原定了两天。每个研讨会都是全天的，包括来自学术界和工业界的演讲以及海报展示。今年，大约有 50 个讲习班。这些主题涵盖了学科和技术/方法方面的广泛材料。

就学科而言，有专门针对学术领域的研讨会，

生物
神经系统科学
医学
自然科学

IT 相关行业，

机器人学
网络安全
系统
超级计算
物联网设备
软件开发
运输

以及更多与人类相关的领域

卫生保健
AI 透明度/公平性
发展中国家的 ML 应用
创意和设计。

ML 技术方面的主题也变化很大；

深度学习(通用)
深度强化学习
贝叶斯深度学习
元学习
半监督学习
建议
因果推理
自然语言处理
音频信号处理
时间序列
可量测性
可视化和交流

研讨会:可解释机器学习

我在研讨会前一天到达，参加了关于可解释 ML 的研讨会。

可解释的 ML 不仅有利于帮助用户理解 ML 模型的结果，而且有利于使人工智能安全可靠。然而，可解释的 ML 是具有挑战性的。总的来说，演讲者同意很难定义术语“可解释性”，因为它是一个以人为中心的术语，依赖于用户的类型，这甚至可能涉及用户体验方面。另外，当前的可解释 ML 方法也有局限性。目前，大致有两种方式来构建可解释的 ML 算法:1)使用简单(例如，线性)算法，或者 2)使用局部描述黑盒模型的“模仿”算法(例如，LIME)。两者都有缺点；如果数据具有复杂的分布，简单的算法很可能具有较低的精度，并且模拟算法很容易失败。无论如何，这一部分的讨论试图解决当前 ML 景观中的问题，并检验可解释 ML 的不同元素。

为了在图像分类/识别任务中使用可解释性 ML，奇莉·瓦格斯塔夫(JPL)展示了如何通过使用 DEMUD 来可视化深度神经网络中的可解释性和学习过程，DEMUD 学习连续信息之间的残差(差异)。Kilian Q. Weinberger (Cornell)提出了对现代神经网络的担忧，这些网络具有很差的校准置信度(即过度自信，这在自动驾驶汽车和自动医疗诊断等实际应用中可能是一个问题。

Jenn Wortman Vaughan(微软)建议可解释性应该跨学科理解，应该考虑人类；根据用户的不同，可解释性可能有不同的含义。沃恩使用亚马逊机械土耳其人进行了一项有趣的实验，在那里她测试了人类受试者对简单模型的理解是否优于更复杂的模型(例如，黑盒、更多功能)。受试者能够更好地遵循更简单的模型，尽管他们对两个模型的信心水平相似(与人们对黑盒模型的信任度低于简单模型的普遍看法相反)。这是一项初步的工作，但它简单而新颖，因为这项研究试图真正包括人类，并测量他们对 ML 模型的反应及其预测。

还进行了小组讨论，发言者回答了一系列问题。首先，他们承认定义“可解释性”是困难的。他们同意贝叶斯方法可以通过提供一些因素和预测不确定性之间关系的信息来帮助黑盒模型。他们还证实，金融和医药等高风险行业领域更抵制黑箱模型，更喜欢可解释性。也有一些对“模仿模型”的批评，因为他们没有提供一个基本的解释，而是更多的事后解释。为了比较可解释模型的不同方法，研究人员同意需要进行涉及人类的实验。总的来说，他们一致认为，要在这个问题上取得突破，首先应该进行系统的人体实验，并更好地定义可解释性。

车间

今年大约有 50 场研讨会，有很多有趣的话题。很难选择参加哪一个，但我决定参加贝叶斯机器学习。我做出这个决定背后的动机是 1)我在博士期间学习了贝叶斯推理，我对这个主题略有熟悉，2)我一直对深度学习持怀疑态度，深度学习的贝叶斯治疗听起来像是对当前深度学习炒作的一种补救措施，3)贝叶斯机器学习是机器学习中的一个新兴主题。尽管两个研讨会都侧重于技术细节(如同大多数贝叶斯推理材料)，但我还是想总结几个要点。

第一天:近似贝叶斯推理的进展

尽管在深度学习方面取得了显著的进步，但这些深度神经网络缺乏解决其预测中的不确定性的能力，并且没有利用概率论。因此，最近研究人员一直在尝试融合贝叶斯方法和深度学习。贝叶斯推理的主要挑战是在计算后验概率时近似难以处理的边际概率分布。有两种方法可以解决这个问题；一种是设计一个易于估计的概率分布，该概率分布接近真实分布并试图减小这两个分布之间的距离，另一种是使用抽样方法(蒙特卡罗模拟)建立后验概率。第一种方法通常被称为变分推理(VI)。大概，第二种方法中最流行的方法就是马尔可夫链蒙特卡罗(MCMC)。尽管每种方法都有自己的优点和缺点，但大多数人对 VI 比对抽样方法更感兴趣，主要是因为 VI 更快，更具确定性。

在近似贝叶斯推理研讨会上提出了许多新颖的方法。Josip Djolonga(苏黎世联邦理工学院)提出了一种近似方法，这种方法利用了欺骗双样本统计测试的想法。“如果我们能骗过统计测试，学习到的分布应该是真实数据的一个很好的模型。”李英珍提出了直接估计得分函数而不是近似优化目标的思想，用于基于梯度的优化，可以缓解广义敌对网络(GAN)的缺陷，如过拟合和低估损失函数。Kira Kempinska(伦敦大学学院)给出了另一个辉煌，他引入了对抗序列蒙特卡罗方法，将近似问题公式化为两人游戏，类似于 GAN。

来自工业界的受邀演讲也很有趣。来自网飞的 Dawen Liang 展示了我们如何使用变分自动编码器(VAE)来构建推荐系统，特别是因为该问题更多地是一个小数据问题，并且用户-项目交互矩阵仅在它是正的情况下才被观察到(即，在负和无之间没有区别)。来自亚马逊的 Andreas Damianou 介绍了深度高斯过程，其中的动机是，(再次)利用当前深度学习方法中通过更好地逼近难以处理的分布而包含的推理(即，模型应该根据它们对预测的确定程度以不同的方式表现)。

第二天:贝叶斯深度学习

从主题上看，这次研讨会与第一次非常相似。然而，在这里，演讲者通过关注概率规划和贝叶斯神经网络(不仅仅是近似方法)展示了一个略大的画面。

会议以 Dustin Tran(哥伦比亚大学/谷歌)的演讲开始，他是概率编程库的首席开发人员 Edward 。他的演讲是关于概率编程的库和概述。Edward 通过支持有向图形模型来支持贝叶斯推理。它是基于 TensorFlow 构建的，尽管我没有使用过 Edward，但根据演示文稿中的代码截图，它的语法似乎与我以前使用过的 pymc3 非常相似；你定义你的变量的图形结构，它们是随机的还是确定的，这些变量应该有什么分布，等等。它支持变分推理和蒙特卡罗方法。达斯汀预测，即使概率编程可能有很高的认知负担，但由于分布式、编译和加速系统，它将变得更容易使用，这允许在多台机器上进行概率编程。

本次会议的特别演讲人是 Max Welling(阿姆斯特丹大学/高通)，他发表了大量关于贝叶斯机器学习的研究，并因其关于变分自动编码器的论文而闻名。他对 Bayesain 深度学习进行了概述。首先，他通过重申贝叶斯方法的好处开始了他的讲话:1)我们可以用一个原则来正则化模型，但不会浪费数据(不需要交叉验证)，2)我们可以测量不确定性，3)贝叶斯方法可以用于严格的模型选择。然后他提出了一个开放式的问题；做决策时，我们应该如何处理量化的不确定性？对我来说，测量不确定性和量化不确定性的实际应用可能是两回事。在演讲的最后，他提到贝叶斯深度学习有三条主线；1)深度高斯过程，2)信息瓶颈，以及 3)贝叶斯丢失。关于最后一个，他提到事实证明快速退出法是实际上不是贝叶斯方法，研究人员正在研究全贝叶斯方法。

Gintare Karolina Dziugaite(剑桥大学/矢量研究所)做了一个有趣的技术演讲，她和 Daniel M. Roy(多伦多大学/矢量研究所)设计了一种改进的随机梯度下降(SGD)方法，即“熵-SGD ”，以缓解 SGD 的过拟合问题。这个问题已经由 Koh 和梁提出，他们的论文被选为今年国际机器学习大会的最佳论文。在 Koh 和 Liang 的论文中，证明了具有 SGD 的深度神经网络可以学习训练数据中完全随机化的标签。

个人想法

尽管我只参加了整个会议的一半，但我可以说，我在 NIPS 的机器学习领域经历了两个看似非常不同的领域。关于可解释 ML 的研讨会更多的是关于实际应用和它对人们的影响。研讨会集中讨论了在现代神经网络中注入贝叶斯思想的技术。尽管这些从表面上看起来很不一样，但我实际上认为这两者之间有共同点:研究人员最终希望通过从模型(不确定性)中提取更多信息来建立一个“更智能”的机器，它可以对人类更加负责和透明。

原载于 2017 年 12 月 16 日hongsupshin.com。

【NIPS 2017/Part 1】带交互代码的 OCR 选通递归卷积 NN【带 TF 的手动回推】

原文：https://towardsdatascience.com/nips-2017-tensorflow-gated-recurrent-convolution-neural-network-for-ocr-part-1-with-47bb2a8a7ab3?source=collection_archive---------7-----------------------

Gif from here

所以这是实现 Ggated 递归卷积神经网络的第一部分。我将逐一介绍，所以今天让我们实现一个简单的递归卷积神经网络作为热身，并在 MNIST 数据集上执行分类。

最后，像往常一样，让我们比较手动扩张反向传播与自动微分相比的表现。

网络架构(数学方程式形式)

Screen Shot from Paper

因此，从上面我们可以看到，递归卷积神经网络与递归神经网络完全相同，但具有卷积运算而不是矩阵乘法。

网络架构/前馈操作(图形形式)

Left — Front View, Right — Side View

绿框 →递归卷积神经网络(RCNN)部分提取特征
红色箭头→RCNN 的输入序列
黄色箭头→RCNN 的输出序列
橙色矩形 →连接 RCNN 的特征空间(4 个时间戳)

蓝色矩形 →全连接网络第一层
粉色矩形 →全连接网络第二层
黑色矩形 →全连接网络第三/最后一层
黄色矩形 →全连接网络软最大层

所以我们的网络由两个不同的网络组成，第一部分是递归卷积神经网络来提取特征，第二部分是全连接神经网络来执行分类。

输入数据/噪声生成(4 个时间戳)

Left — Original, Middle — Gaussian, Right — Poisson

Left — Gamma , Right — Uniform

因此，对于递归卷积神经网络的 4 个输入图像，我们将向原始图像添加噪声，我们将向原始图像添加的噪声类型是高斯噪声、泊松噪声、伽马噪声和均匀噪声。上面的图像显示了添加噪声后的结果。下面是几个例子。

测试案例/指示颜色

**Case 0: Standard Manual Back Propagation with ADAM
Case 1: Auto Back Propagation with ADAM
Case 2: Dilated Back Propagation with ADAM Sparse Connection
Case 3: Dilated Back Propagation with ADAM Sparse Connection 2
Case 4: Dilated Back Propagation with ADAM Dense Connection 1
Case 5: Dilated Back Propagation with ADAM Dense Connection 2
Case 6: Dilated Back Propagation with ADAM Dense Connection 3**

如上所述，我们总共要比较七个案例。下面显示了每种情况下的每种颜色。

**Case 0: Red
Case 1: Green
Case 2: Blue
Case 3: Cyan
Case 4: Magenta
Case 5: Yellow
Case 6: Black**

训练结果(本地结果)

左图 →训练图像上的时间成本
右图 →训练图像上的时间精度

左图 →测试图像随时间变化的成本
右图 →测试图像随时间变化的精度
(请注意，我在着色上犯了一个错误，案例 1 和案例 2 交换了颜色)

非常有趣的是，观察到稀疏连接的扩张反向传播表现不佳，而密集连接的扩张反向传播表现不佳。

透明度

为了增加这个实验的透明度，我上传了在我的笔记本电脑上运行这个程序时我的命令提示符的所有输出。

训练结果(试验 2)

左图 →训练图像上的时间成本
右图 →训练图像上的时间精度

左图 →测试图像随时间变化的成本
右图 →测试图像随时间变化的精度
(请注意，我在着色上犯了一个错误，案例 1 和案例 2 的颜色发生了变化)

我们可以观察到，即使在第二次试验中，我们也能超越自动微分。为了增加这个实验的透明度，我上传了在我的笔记本电脑上运行这个程序时我的命令提示符的所有输出。

互动代码(Google Colab / Replt.it /微软 Azure)

对于 Google Colab，你需要一个 Google 帐户来查看代码，而且你不能在 Google Colab 中运行只读脚本，所以在你的操场上复制一份。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

要访问 Google Colab 上的代码，请点击这里。
要访问 Repl 上的代码，请点击此处。
要访问 Microsoft Azure 笔记本上的代码，请单击此处。

最后的话

在下一部分，我们将涵盖门控递归卷积神经网络。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

与此同时，请在我的 twitter 这里关注我，并访问我的网站，或我的 Youtube 频道了解更多内容。如果你感兴趣，我也在这里做了解耦神经网络的比较。

参考

适合 ML 初学者的 MNIST。(2018).张量流。检索于 2018 年 3 月 15 日，来自https://www . tensor flow . org/versions/r 1.1/get _ started/mnist/初学者
适合 ML 初学者的 MNIST。(2018).张量流。检索于 2018 年 3 月 15 日，来自https://www . tensor flow . org/versions/r 1.1/get _ started/mnist/初学者
王军，胡小玲(2017)。用于光学字符识别的门控递归卷积神经网络。在神经信息处理系统的进展(第 334-343 页)。
导数表。(2018).Math.com。检索于 2018 年 3 月 15 日，来自http://www.math.com/tables/derivatives/tableof.htm
tf.atan | TensorFlow。(2018).张量流。检索于 2018 年 3 月 15 日，来自https://www.tensorflow.org/api_docs/python/tf/atan
Tensorflow，a. (2018)。张量流中的加性高斯噪声。Stackoverflow.com。检索于 2018 年 3 月 16 日，来自https://stack overflow . com/questions/41174769/additive-Gaussian-noise-in-tensor flow
tf.reshape | TensorFlow。(2018).张量流。检索于 2018 年 3 月 16 日，来自 https://www.tensorflow.org/api_docs/python/tf/reshape
“Tf。Random_Gamma | Tensorflow”。2018.张量流。2018 年 3 月 16 日访问。https://www.tensorflow.org/api_docs/python/tf/random_gamma。
tf.stack？，W. (2018)。为什么我会使用 tf.concat 而不是 tf.stack？。Stackoverflow.com。检索于 2018 年 3 月 16 日，来自https://stack overflow . com/questions/41534593/why-would-I-ever-use-TF-concat-instead-of-TF-stack
“梯度下降优化算法概述”。2016.塞巴斯蒂安·鲁德。2018 年 3 月 16 日访问。http://ruder.io/optimizing-gradient-descent/。
“Tf。nn . conv 2d _ back prop _ Input | tensor flow "。2018.张量流。2018 年 3 月 16 日访问。https://www . tensor flow . org/API _ docs/python/TF/nn/conv2d _ back prop _ input。
“Tf。Reset_Default_Graph |张量流"。2018.张量流。2018 年 3 月 17 日访问。https://www . tensor flow . org/API _ docs/python/TF/reset _ default _ graph。
“指定颜色— Matplotlib 2.0.2 文档”。2018.Matplotlib.Org。2018 年 3 月 17 日访问。https://matplotlib.org/users/colors.html
高斯噪声。(2018).En.wikipedia.org。检索于 2018 年 3 月 17 日，来自https://en.wikipedia.org/wiki/Gaussian_noise
泊松分布。(2018).En.wikipedia.org。检索于 2018 年 3 月 17 日，来自https://en.wikipedia.org/wiki/Poisson_distribution
伽玛分布。(2018).En.wikipedia.org。检索于 2018 年 3 月 17 日，来自 https://en.wikipedia.org/wiki/Gamma_distribution
均匀分布(连续)。(2018).En.wikipedia.org。检索于 2018 年 3 月 17 日，来自https://en . Wikipedia . org/wiki/Uniform _ distribution _(continuous)
JaeDukSeo/Only_Numpy_Basic。(2018).GitHub。检索于 2018 年 3 月 17 日，来自https://github . com/JaeDukSeo/Only _ Numpy _ Basic/blob/master/4 _ recurrent _ CNN/local cmd _ results . txt

【NIPS2018/ Google /论文摘要】一个神经元有多重要？

原文：https://towardsdatascience.com/nips2018-google-paper-summary-how-important-is-a-neuron-3de4b085eb03?source=collection_archive---------5-----------------------

Gif from this website

我们如何衡量网络内部隐藏单元的重要性？测量网络内部活动的最常用方法是测量每个神经元的激活值。这是衡量重要性的最佳方法吗？本文介绍并研究了电导的概念。

请注意，这个帖子是给未来的自己看的，用来回顾和复习资料，不用再读一遍整篇论文。

摘要

在这一节中，作者介绍了术语电导，以扩展归因的概念，理解隐藏单元的重要性。电导可以理解为隐藏层内部的属性流。我对电导的简单理解是“隐藏单元如何处理来自先前输入的输入数据，从而得到最终预测”。

背景和动机

作者决定写这个主题有几个背景/原因

大多数论文通过测量隐藏单元的激活值或梯度来评估隐藏单元的重要性。(而且这种方法有一些不良后果，将在后面讨论。)
测量隐藏单元的重要性的另一种方法是基于优化的方法。也就是说，手动将输入图像调整到网络中，以优化神经元的激活。然而，这些方法不能识别隐藏单元的重要性，也不能保证所有适当的隐藏单元都被这种方法研究。
衡量重要性的第三种方法是首先识别隐藏单元中的功能，并重建一个更简单的网络。然而，这种方法不能保证新模型中隐藏单元的影响与原始模型完全相同。
最后，最后一种方法是将人类定义的概念作为输入，并识别哪些隐藏的神经元对这些特征做出响应。这种方法的主要问题是网络具有与人类固有不同的表现形式。并且可能无法识别某些预测的所有重要概念。

与上述所有方法相比，作者决定看看网络自身的抽象(过滤器)。因此，对人类来说，这种解释可能不太直观，但整个预测过程都得到了解释。

我们(作者)的贡献

作者的所有贡献可以用一个词“电导”来表达。这实际上是基于另一个叫做积分梯度的想法。综合梯度是对一系列精心选择的输入变量的梯度求和的过程。非正式地，电导可以定义为积分梯度的流动，电导背后的关键思想是通过链规则分解积分梯度的计算。

作者研究了两种不同网络的电导。一个是著名的基于 mageNet 数据的 inception 网络架构。另一个是来自尹金一个卷积神经网络用于句子分类。(今天我只看盗梦空间网络。)

电导

在这一节中，作者介绍了电导的正式数学概念。在继续之前，作者定义了基本输入和输入的概念。

“假设 x 是手边的输入，x `是基线输入。对于图像网络，基线可以是黑色图像，而对于文本模型，基线可以是零嵌入向量”

如果我们考虑一条从 x '到 x 的直线路径(我将此理解为一种变换)，并计算沿着该路径的所有点的梯度，则可以通过对所有梯度求和来获得积分梯度。积分梯度的形式如下所示。

红框 →输入 x 的积分(第 I 个维度)

既然我们已经看到了积分梯度的定义，现在让我们看看电导是如何数学定义的。

红框 →对隐藏神经元 y 和链式法则的积分
蓝框 →对隐藏单元内所有维度的积分求和

如上所述，我们可以清楚地看到两个方程的相似之处。两者之间的主要区别是，我们对变量进行积分。(同样，我们可以将此视为通过链式法则分解积分梯度的过程。)

电导的评估

在这里，作者将电导与机器学习(ML)社区中广泛使用的其他三种不同方法进行了比较。第一种方法已经是非常众所周知的方法，当测量一个隐藏单元有多重要时，第二种方法是当我们另外乘以梯度时。而最后一种方法是从本文介绍的深度卷积网络的影响导向解释。

神经网络的电导/饱和/极性/灵敏度特性

在这一节中，作者讨论了电导的一些基本性质。

完整性 →任何单一隐藏层的电导加起来就是预测之间的差异
逐层守恒原理 →网络的输出活动通过 DNN 的各层完全重新分配到输入变量上，即正负证据都不会丢失
线性 →数学关系或函数的属性，这意味着它可以用直线来表示
不敏感 →如果改变一个隐藏单元的值不改变网络的预测，它的电导为零。如果改变输入不改变隐藏单元的值，则隐藏单元的电导为零。

接下来作者讨论了电导如何克服神经元饱和的问题。基本上，类似于内部影响，电导法取 0 和 1 之间的积分，克服了这个问题。(我不是 100%确定这种方法如何克服饱和神经元的问题，我将阅读论文“深度网络的公理化归属”并回来讨论此事。)最后，作者描述了其他方法所具有的不良特性。

激活方法 →有影响的属性与输出符号不一致。例如，ReLU()激活函数只能具有正值，但是 ReLU 节点可以根据上游权重对输出产生积极或消极的影响。

梯度激活 →具有超调特性，其中具有零影响的神经元可以被分配高重要性分数。*

内部影响 →具有与输出符号不一致的影响属性。

将电导应用于对象识别模型/消融研究

在本节中，作者使用电导来识别初始网络隐藏层中有影响的过滤器。如上所述，作者发现在执行分类任务时，一些过滤器被一个或多个图像共享。(左边是检测眩光的滤镜，右边是检测红色的滤镜。)

接下来，作者们进行了消融(删除)研究，他们想看看为了让模型改变它的预测，需要丢弃(删除)多少这些重要的过滤器。他们发现，网络平均去除 3.7 次就足以改变它对一幅图像的预测。与内部影响相比，电导给出了较小的数字，这意味着电导能够有效地识别最重要的过滤器。

最后，请注意还有最后一节(将电导应用于情感模型)以及作者做的一个额外实验*(特征选择研究)**。然而，我的笔记本电脑快没电了，所以我现在不做总结。*

遗言

我发现这张纸上展示的材料非常坚硬。但是一个惊人的事实让我吃惊，我记得我做了另一篇论文的论文摘要，叫做“对基于反向传播的可视化的复杂行为的理论解释”。我记得那篇论文的主旨是，如果我们想了解网络内部发生了什么，我们需要按照事物(梯度或显著图)的本来面目来看待它，而不是试图修改它，让人类看起来更愉快。这篇论文似乎也有类似的论点。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

同时，在我的 twitter 这里关注我，并访问我的网站，或我的 Youtube 频道了解更多内容。我还实现了广残网，请点击这里查看博文 pos t。

参考

Dhamdhere，m . Sundararajan 和 q . Yan(2018 年)。一个神经元有多重要？。Arxiv.org。检索于 2018 年 6 月 3 日，来自https://arxiv.org/abs/1805.12233
ImageNet。(2018).Image-net.org。检索于 2018 年 6 月 3 日，来自 http://www.image-net.org/
(2018).Aclweb.org。检索于 2018 年 6 月 3 日，来自 http://www.aclweb.org/anthology/D14-1181
:Anon，(2018)。[在线]可在:https://www.linkedin.com/in/yoonrkim/[2018 年 6 月 3 日访问]。
为基于反向传播的复杂行为提供了理论解释。(2018).走向数据科学。检索于 2018 年 6 月 3 日，来自https://towards data science . com/paper-summary-a-theoretical-explain-behaviors-of-back-propagation-based-220083 D7 dddd
雷诺，k .，李，l .，森，s .，，M. (2018)。深层卷积网络的影响导向解释。Arxiv.org。检索于 2018 年 6 月 3 日，来自https://arxiv.org/abs/1802.03788
线性。(2018).En.wikipedia.org。检索于 2018 年 6 月 3 日，来自https://en.wikipedia.org/wiki/Linearity
Sundararajan，m .，Taly，a .，和 Yan，Q. (2017 年)。深度网络的公理化属性。Arxiv.org。检索于 2018 年 6 月 3 日，来自https://arxiv.org/abs/1703.01365

有趣的 NLG—自动标题生成器

原文：https://towardsdatascience.com/nlg-for-fun-automated-headlines-generator-6d0459f9588f?source=collection_archive---------4-----------------------

Image Courtesy: https://pixabay.com/en/texture-handwriting-s%C3%BCtterlin-1362879/

自然语言生成是我们这个时代要探索的一个非常重要的领域。它形成了机器人如何交流的基础——不像文人如何写书，而是像我们如何交谈。在这个内核中，我将向您展示一个非常简单但功能强大的 Python 模块，它用几行代码就完成了类似的工作。

模块:马克维奇

我们这里用的 Py 模块是[markovify](https://github.com/jsvine/markovify)。

马科维奇的描述:

Markovify 是一个简单的，可扩展的马尔可夫链生成器。目前，它的主要用途是建立大型文本语料库的马尔可夫模型，并从中生成随机句子。但是，理论上，它可以用于其他应用。

关于数据集:

这包括 ABC 网站在给定时间范围内发布的全部文章。每天 200 篇文章的量和对国际新闻的良好关注，我们可以相当肯定地说，每一个重大事件都在这里被捕获。这个数据集可以从 Kaggle 数据集下载。

关于马尔可夫链的小知识

马尔可夫链以安德烈·马尔可夫命名，是从一种“状态”(一种情况或一组值)跳到另一种状态的数学系统。例如，如果你为一个婴儿的行为建立一个马尔可夫链模型，你可以包括“玩”、“吃”、“睡觉”和“哭”作为状态，这些状态和其他行为一起可以形成一个“状态空间”:一个所有可能状态的列表。此外，在状态空间的顶部，马尔可夫链告诉你从一个状态跳跃或“过渡”到任何其他状态的可能性——例如，当前正在玩耍的婴儿在接下来的五分钟内睡着而没有先哭的可能性。

在 Victor Powell 的互动文章中阅读更多关于马尔可夫链如何工作的信息

加载所需的包

import pandas as pd *# data processing, CSV file I/O (e.g. pd.read_csv)*
import markovify *#Markov Chain Generator*
*# Any results you write to the current directory are saved as output.*

读取输入文本文件

inp = pd.read_csv('../input/abcnews-date-text.csv')inp.head(3)publish_date headline_text
020030219 aba decides against community broadcasting lic…
120030219 act fire witnesses must be aware of defamation
220030219a g calls for infrastructure protection summit

用马尔可夫链建立文本模型

text_model = markovify.NewlineText(inp.headline_text, state_size = 2)

是时候享受自动生成的标题了

*# Print five randomly-generated sentences*
for i **in** range(5):
    print(text_model.make_sentence())iron magnate poised to storm cleanup
meet the png government defends stockdale appointment
the twitter exec charged with animal cruelty trial
pm denies role in pregnancy
shoalhaven business boosts hunter

现在，这段文字可以成为 Twitter 机器人、Slack 机器人甚至是恶搞博客的输入。这才是重点。

参考资料:

Github 回购
Kaggle 内核
马尔可夫链直观解释
输入数据集

NLP —构建问题回答模型

原文：https://towardsdatascience.com/nlp-building-a-question-answering-model-ed0529a68c54?source=collection_archive---------0-----------------------

用数据做酷事！

我最近在斯坦福大学通过深度学习(CS224N)完成了一门关于 NLP 的课程，我很喜欢这种体验。学到了一大堆新东西。在我的最后一个项目中，我设计了一个基于斯坦福问答数据集(SQuAD) 的问答模型。在这篇博客中，我想介绍问答模型的主要组成部分。

你可以在我的 Github repo 上找到完整的代码。

我最近还为这个模型添加了一个网络演示，你可以放入任何段落并提出相关问题。查看链接

小队数据集

SStanfordQuestionAnsweringDataset(SQuAD)是一个新的阅读理解数据集，由一组维基百科文章上的众包工作者提出的问题组成，其中每个问题的答案都是相应阅读文章的一段文字，或 span 。SQuAD 拥有 500+篇文章上的 100，000+问答对，比以前的阅读理解数据集大得多。

在 SQuAD 数据集上有了快速的进步，一些最新的模型在回答问题的任务中达到了人类水平的准确性！

上下文、问题和答案的示例

背景——阿波罗计划从 1961 年运行到 1972 年，并得到了从 1962 年到 1966 年与它同时运行的双人双子座计划的支持。双子座任务开发了一些太空旅行技术，这些技术对于阿波罗任务的成功是必要的。阿波罗使用土星家族火箭作为发射工具。阿波罗/土星飞行器也被用于阿波罗应用计划，该计划包括天空实验室，这是一个在 1973-74 年支持三次载人任务的空间站，以及阿波罗-联盟测试项目，这是 1975 年与苏联的联合地球轨道任务。

问:在 1973-1974 年间，哪个空间站支持了三次载人任务？

答案——天空实验室

小队的主要特征:

I)它是一个封闭的数据集，意味着问题的答案总是上下文的一部分，也是上下文的连续跨度

ii)因此找到答案的问题可以简化为找到对应于答案的上下文的开始索引和结束索引

75%的答案长度小于等于 4 个单词

机器理解模型—关键部件

i)嵌入层

模型的训练数据集由上下文和相应的问题组成。这两者都可以被分解成单独的单词，然后使用像手套向量这样的预训练向量将这些单词转换成单词嵌入。要了解更多关于单词嵌入的知识，请查看我的文章。单词嵌入在捕捉单词周围的上下文方面比对每个单词使用一个热点向量要好得多。对于这个问题，我使用了 100 维手套词嵌入，并且在训练过程中没有调整它们，因为我们没有足够的数据。

ii)编码器层

RNN Encoder

我们在模型中添加的下一层是基于 RNN 的编码器层。我们希望上下文中的每个单词都知道它前面和后面的单词。双向的 GRU/LSTM 可以帮助做到这一点。RNN 的输出是向前和向后方向的一系列隐藏向量，我们将它们连接起来。类似地，我们可以使用相同的 RNN 编码器来创建问题隐藏向量。

iii)关注层

到目前为止，我们有一个上下文的隐藏向量和一个问题的隐藏向量。要找到答案，我们需要将二者放在一起看。这就是注意力的来源。它是问题回答系统中的关键部分，因为它帮助我们决定，给定问题，我应该“注意”上下文中的哪些单词。让我们从最简单的注意力模型开始:

点产品注意事项

Basic Attention Visualisation from CS224N

点积注意力将是，对于每个上下文向量 c i，我们乘以每个问题向量 q j 以获得向量 e i(上图中的注意力分数)。然后我们对 e i 取一个 softmax，得到α i(上图注意力分布)。Softmax 保证所有 e i 之和为 1。最后我们计算 a i，作为注意力分布α i 和相应问题向量(上图中注意力输出)的乘积。点积注意力也在下面的等式中描述

上述注意已经在 Github 代码中实现为基线注意。

更复杂的注意——BiDAF 注意

你可以用上面描述的基本注意力层运行小队模型，但是性能不会很好。更复杂的注意力导致更好的表现。

让我们描述一下 BiDAF 论文中的关注点。主要思想是注意力应该双向流动——从上下文到问题，从问题到上下文。

我们首先计算相似性矩阵 S ∈ R N×M，它包含每对(ci，qj)上下文和问题隐藏状态的相似性得分 Sij。sij = wT sim[ci；QJ；ci♀QJ]∈R 这里，ci♀QJ 是元素式乘积，wsim ∈ R 6h 是权重向量。在下面的等式中描述:

接下来，我们执行上下文到问题(C2Q)注意。(这个和上面说的点积注意差不多)。我们取 S 的行方式 softmax 来获得注意力分布α i，我们用它来取问题隐藏状态 q j 的加权和，产生 C2Q 注意力输出αI

接下来，我们执行问题到上下文(Q2C)注意。对于每个上下文位置 i ∈ {1，.。。，N}，我们取相似性矩阵的对应行的最大值，m i = max j Sij ∈ R。然后，我们取结果向量 m ∈ R N 上的 softmax 这给出了上下文位置上的注意力分布β ∈ R N。然后我们用β取上下文隐藏状态 c i 的加权和——这就是 Q2C 注意力输出 c 素数。参见下面的等式

最后，对于每个上下文位置 c i，我们组合来自 C2Q 注意力和 Q2C 注意力的输出，如下式所述

如果您觉得这一部分令人困惑，不要担心。注意力是一个复杂的话题。尝试用一杯茶阅读 BiDAF 文件:)

iv)输出层

快到了。模型的最后一层是 softmax 输出层，帮助我们决定答案范围的开始和结束索引。我们组合上下文隐藏状态和来自前一层的注意力向量来创建混合的重复。这些混合的重复成为全连接层的输入，该全连接层使用 softmax 来创建具有开始索引概率的 p_start 向量和具有结束索引概率的 p_end 向量。因为我们知道大多数答案的开始和结束索引最多相差 15 个单词，所以我们可以寻找使 p_start*p_end 最大化的开始和结束索引。

我们的损失函数是起点和终点的交叉熵损失之和。并且使用 Adam 优化器将其最小化。

我构建的最终模型比上面描述的要复杂一点，在测试集上 F1 得分为 75。还不错！

后续步骤

关于未来探索的几个额外想法:

我一直在用一个基于 CNN 的编码器来代替 RNN 编码器，因为 CNN 比 RNNs 快得多，并且更容易在 GPU 上并行化
其他注意机制，如在论文中描述的动态共同注意

给我一个❤️，如果你喜欢这个职位:)希望你拉代码，并尝试自己。

其他著述:【http://deeplearninganalytics.org/blog】T4

PS:我有自己的深度学习咨询公司，喜欢研究有趣的问题。我已经帮助几家初创公司部署了基于人工智能的创新解决方案。请到 http://deeplearninganalytics.org/来看看我们吧。

如果你有一个我们可以合作的项目，请通过我的网站或 priya.toronto3@gmail.com 联系我

参考文献:

CS 224N
小队数据集
BiDAF 型号

NLP 引擎(第 2 部分)->自然语言处理的最佳文本处理工具或库

原文：https://towardsdatascience.com/nlp-engine-part-2-best-text-processing-tools-or-libraries-for-natural-language-processing-c7fd80f456e3?source=collection_archive---------14-----------------------

NLP 库—何时、何地使用它们。NLTK，TextBlob，Spacy，CoreNLP，Genism，Polyglot。

构建 NLP 引擎时出现的一个主要问题是**“我应该使用哪个库来进行文本处理？”既然市场上有很多，还有“NLP 库的用途是什么？”**这两个问题将在这里解决，并帮助您在自己从头构建 NLP 引擎的道路上迈出正确的一步。

这篇文章是正在进行的系列文章的一部分:第一部分

"使用 NLP 库的需求是什么？"

自然语言处理(NLP)今天变得非常流行。NLP 是 人工智能 的一个领域，旨在理解和提取文本中的重要信息，并基于文本数据进一步训练。主要任务包括文本分析情感分析、机器翻译* 等。*

这些库帮助我们从文本中提取含义，其中包括广泛的任务，如文档分类、主题建模、词性(POS)标注和情感分析等。

"我应该使用哪个库进行文本处理？"

这里是六个最流行的 NLP 库的列表，它们在任何地方都被使用，但没有特定的顺序。这取决于你选择哪一个适合于你正在尝试执行的任务。

如果这五个都掌握了，那么你就没有必要去寻找其他的 NLP 库了。即使你掌握了其中的一个，也很容易在它们之间切换来学习和使用其他库。

***NLTK(自然语言工具包):*最古老的之一，多用于研究和 教育目的 。
TextBlob: 构建于 NLTK 之上，最适合 初学者 。这是一个用户友好和直观的 NLTK 界面。它用于快速原型制作。
Spacy: 行业标准 目前最好的。
CoreNLP(斯坦福 CoreNLP): 由斯坦福集团构建和维护的生产就绪解决方案，但它是用 java 构建的。
Genism: 它是用于主题和向量空间建模、文档相似性的包。
多语种:通常用于涉及某个语言空间不支持的项目。

这些库并不是唯一的库，但是你可以说它们是*“NLP 的骨干”*掌握这些库可以让你做任何简单或高级的自然语言处理。

现在最好的是*“Spacy”我不能推荐它给 NLP。如果你想让它成为生产就绪和工业标准**请使用 Spacy，NLTK 仅用于学术目的。*

NLTK(自然语言工具包)

source

NLTK 是最古老的 NLP 之一。如果你是一个初学者，必须学习自然语言处理领域的基础知识，那么自然语言处理是适合你的。你可以为你应该完成的适当的任务建立适当的模型。

“一旦掌握了 NLTK，它将成为文本分析研究人员的游乐场”。NLTK 有超过 50 个语料库和词典，9 个词干分析器和几十种算法可供选择。基本上是为了一个学术研究者。

文本斑点

source

TextBlob 是 NLTK 的一个接口，它将文本处理变成了一个 简单且相当愉快的过程 ，因为它有 丰富的功能 和 平滑的学习曲线 由于有详细且易懂的文档。因为它允许简单地添加各种组件，如情感分析器和其他方便的工具。用于*【快速成型】**。*

空间

source

Spacy是用 Python & Cython 写的。SpaCy 不能像 NLTK 那样为任何任务提供超过 50 种不同的解决方案。“ Spacy 只为任务提供一个且是最好的一个解决方案，从而免去了自己选择最优路线的问题 ”，确保建立的模型精益、中庸、高效。此外，该工具的功能已经很强大，并且会定期添加新功能。

科伦普(斯坦福科伦普)

source

CoreNLP 由一套生产就绪的自然分析工具组成。是用 Java 写的，不是 Python。虽然有社区做的 Python 包装器。它可靠健壮，比 NLTK 快(但是 spacy 快得多)，并且还支持多种语言。许多组织将 CoreNLP 用于生产实现。

CoreNLP 为 NLP 任务提供了一个很好的基础设施。然而，客户机-服务器体系结构引入了一些开销，这对于较小的项目或在原型开发期间可能是不利的

Genism

是针对主题和向量空间建模、文档相似性的包。“Gensim 并不适合所有类型的任务或挑战，但它能做什么，就做什么”。在主题建模和文档相似性比较领域，高度专业化的 Gensim 库是无可匹敌的。所以 Genism 不是一个通用的 NLP，但是它的使用取决于手边的任务。

多语种

source

略显冷门的图书馆。它提供了广泛的分析和令人印象深刻的语言覆盖面。多亏了 NumPy，它的运行速度也非常快。使用 polyglot 类似于 spaCy——非常简单，对于涉及 spaCy 不支持的语言的项目来说，这将是一个极好的选择。该库之所以与众不同，还因为它通过管道机制请求在命令行中使用专用命令。绝对值得一试****

结论:

NLTK 更多的是学术性。你可以用它来尝试不同的方法和算法，组合它们等等。相反，Spacy 为每个问题提供了一个现成的解决方案。 你不用去想哪种方法更好:Spacy 的作者们已经搞定这个 。还有， Spacy 非常快(比 NLTK 快好几倍)。一个缺点是 Spacy 支持的语言数量有限。然而，支持的语言数量一直在增加。因此，我们认为 Spacy 在大多数情况下是最佳选择，但是如果您想尝试一些特殊的东西，可以使用 NLTK****

在这里，你可能不理解标记化、主题建模、意图等的含义，我将在下一篇 NLP 引擎文章(第 3 部分)中介绍。

学分:

https://www . kdnugges . com/2018/07/comparison-top-6-python-NLP-libraries . html
https://elitedatascience.com/python-nlp-libraries
https://sunscrapers . com/blog/6-best-python-natural-language-processing-NLP-libraries/

请务必关注我的中，LinkedIn，Twitter，insta gram获取更多更新。如果你喜欢这篇文章，请鼓掌并分享它。****

在这里加入我们的 WhatsApp 社区。

NLP —从文本中提取位置

原文：https://towardsdatascience.com/nlp-extracting-location-from-text-aa99c55e77d5?source=collection_archive---------0-----------------------

我目前正在做一个 NLP 任务，需要从文本中提取位置。例如，“我住在纽约”，那么必须从文本中提取“纽约”。有几个像 nltk 或 T2 这样的图书馆可以做这种工作。

NLTK 和 StanfordNER 是如何从文本中识别位置的？

Pipeline for named entity recognition in nltk

ne_chunk 函数将标记分为不同的实体，如“人”、“组织”、“位置”等。ne_chunk 使用基于分类器的方法，并且已经在词性标记数据上进行了训练。分类器试图理解句子中各种词类和实体之间的关系。

挑战

因为 NLTK 和 StandfordNER 依靠词性标注来识别位置；不以大写字母开头的位置名称无法识别。

例如，“我住在班加罗尔”，单词“班加罗尔”将被两个库识别为一个位置。相反，“我住在班加罗尔”，单词“班加罗尔”不会被他们中的任何一个识别为地点。这是因为“bangalore”在词类标记上有一个“NNP”标记，表示专有名词，而“Bangalore”只被标记为表示名词的“NN”。

我的数据集基本上是从电子邮件中提取的，有许多这样的句子，其中地点名称不是以大写字母开头。因此，如果不以大写字母开头，就无法提取位置。

其他几个模糊之处

Devi Circle 是一个美丽的地方--“Devi”被识别为一个人，而 Devi Circle 是 Bangalore 的一个地方。
Martahalli 是一个美丽的地方-“Martahalli”是一个人，而 Marta halli 是班加罗尔的一个地方。
我的学校在 Martahalli 警察局附近- 有趣的是**‘Marta halli’被正确归类为位置。**
我想从 Koramangala 到 Madivala- 只有“Koramangala”被识别为一个位置，而 koramangala 和 Madivala 都是班加罗尔的位置。

上述歧义清楚地表明，命名实体识别器(ne_chunk)被训练成仅理解词性标注，以理解一个标记是否是实体。

结论

许多 NLP 技术需要从文本中提取实体，如人名、位置、组织名称或日期。不幸的是，没有简单的方法来实现这一点。

我请求读者提出他们心目中有助于完成这项任务的任何方法。

NLP:使用 LDA 在几分钟内从数据集中提取主要主题

原文：https://towardsdatascience.com/nlp-extracting-the-main-topics-from-your-dataset-using-lda-in-minutes-21486f5aa925?source=collection_archive---------1-----------------------

用数据做很酷的事情！

Power of NLP

我最近开始学习用于主题建模的潜在狄利克雷分配(LDA ),惊讶于它的强大和快速运行。主题建模是使用无监督学习来提取文档集合中出现的主要主题(表示为一组单词)的任务。

我在 20 个新闻组数据集上测试了该算法，该数据集包含来自新闻报道的许多部分的数千篇新闻文章。在这个数据集中，我提前知道了主要的新闻主题，并且可以验证 LDA 是否正确地识别了它们。

代码运行起来非常简单快速。可以在 Github 上找到。我鼓励你拉一下试试。

关于 LDA

LDA 用于将文档中的文本分类到特定主题。它建立了每个文档的主题模型和每个主题的单词模型，建模为 Dirichlet 分布。

每个文档被建模为主题的多项式分布，并且每个主题被建模为单词的多项式分布。
LDA 假设我们输入的每一个文本块都包含有某种关联的单词。因此，选择正确的数据是至关重要的。
它还假设文档是由多个主题混合而成的。然后，这些主题根据它们的概率分布生成单词。

要了解更多关于 LDA 的信息，请点击这个链接。

使用的数据集

我用的数据集是 20Newsgroup 数据集。它可以在 sklearn 数据集下获得，并且可以作为

from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset=’train’, shuffle = True)
newsgroups_test = fetch_20newsgroups(subset=’test’, shuffle = True)

这个数据集已经将新闻分组为关键主题。你可以熬过来

print(list(newsgroups_train.target_names))

数据集中有 20 个目标——‘alt .无神论’，
‘comp . graphics’，
‘comp . OS . ms-windows . misc’，
‘comp . sys . IBM . PC . hardware’，
‘comp . sys . MAC . hardware’，
‘comp . windows . x’，
‘misc . for sale’，
‘rec . autos’，
‘rec . motors’，
‘rec .’

从视觉上看，我们可以说这个数据集有几个广泛的主题，如:

科学
政治
运动
宗教
技术等

使用 Python 中的 LDA 提取主题

预处理原始文本

这包括以下内容:

分词:将文本拆分成句子，句子拆分成单词。将单词小写，去掉标点符号。
少于 3 个字符的单词将被删除。
所有的停用词都被删除。
单词被词汇化——第三人称的单词被改为第一人称，过去时态和将来时态的动词被改为现在时态。
单词被词干化——单词被还原成它们的词根形式。

我们使用 NLTK 和 gensim 库来执行预处理

def lemmatize_stemming(text):
    return stemmer.stem(WordNetLemmatizer().lemmatize(text, pos='v'))# Tokenize and lemmatize
def preprocess(text):
    result=[]
    for token in gensim.utils.simple_preprocess(text) :
        if token not in gensim.parsing.preprocessing.STOPWORDS and len(token) > 3:
            result.append(lemmatize_stemming(token))

    return result

生成的文本如下所示:

Original document: 
['This', 'disk', 'has', 'failed', 'many', 'times.', 'I', 'would', 'like', 'to', 'get', 'it', 'replaced.']

Tokenized and lemmatized document: 
['disk', 'fail', 'time', 'like', 'replac']

2。将文本转换成单词包

在主题建模之前，我们将标记化和词条化的文本转换为一个单词包，你可以把它想象成一个字典，其中的关键字是单词，值是单词在整个语料库中出现的次数。

dictionary = gensim.corpora.Dictionary(processed_docs)

我们可以进一步筛选出现次数很少或出现频率很高的单词。

现在，对于每个预处理过的文档，我们使用刚刚创建的 dictionary 对象将文档转换成单词包。也就是说，我们为每个文档创建一个字典，报告有多少单词以及这些单词出现了多少次。

bow_corpus = [dictionary.doc2bow(doc) for doc in processed_docs]

结果看起来像:

Word 453 ("exampl") appears 1 time.
Word 476 ("jew") appears 1 time.
Word 480 ("lead") appears 1 time.
Word 482 ("littl") appears 3 time.
Word 520 ("wors") appears 2 time.
Word 721 ("keith") appears 3 time.
Word 732 ("punish") appears 1 time.
Word 803 ("california") appears 1 time.
Word 859 ("institut") appears 1 time.

3。运行 LDA

这实际上很简单，因为我们可以使用 gensim LDA 模型。我们需要指定数据集中有多少主题。假设我们从 8 个独特的主题开始。通过次数是对文档进行培训的次数。

lda_model =  gensim.models.LdaMulticore(bow_corpus, 
                                   num_topics = 8, 
                                   id2word = dictionary,                                    
                                   passes = 10,
                                   workers = 2)

结果并解释它们

就是这样！模型已经建立。现在让我们来解读它，看看结果是否有意义。

该模型的输出是 8 个主题，每个主题由一系列单词分类。LDA 模型不会给这些词起一个主题名，而是由我们人类来解释它们。请参见下面的模型输出示例，以及“我”如何为这些单词分配潜在主题。

Topic 1: Possibly Graphics Cards
Words: "drive" , "sale" , "driver" , *"wire" , "card" , "graphic" , "price" , "appl" ,"softwar", "monitor"Topic 2: Possibly Space
Words: "space","nasa" , "drive" , "scsi" , "orbit" , "launch" ,"data" ,"control" , "earth" ,"moon"Topic 3: Possibly Sports
Words: "game" , "team" , "play" , "player" , "hockey" , season" , "pitt" , "score" , "leagu" , "pittsburgh"Topic 4: Possibly Politics
Words: "armenian" , "public" , "govern" , "turkish", "columbia" , "nation", "presid" , "turk" , "american", "group"Topic 5: Possibly Gun Violence
Words: "kill" , "bike", "live" , "leav" , "weapon" , "happen" , *"gun", "crime" , "car" , "hand"

查看 github 代码来查看所有主题，并使用模型来增加或减少主题的数量。

观察:

该模型在提取数据集中的独特主题方面做得非常好，我们可以在已知目标名称的情况下确认这些主题
模型运行非常快。我可以在几分钟内从数据集中提取主题
它假设数据集中有不同的主题。因此，如果数据集是一堆随机的推文，那么模型结果可能就不可解释了。

未来的改进

我对这个关于 Guided LDA 的帖子很感兴趣，很想尝试一下。

我有自己的深度学习咨询公司，喜欢研究有趣的问题。我已经帮助许多初创公司部署了基于人工智能的创新解决方案。请到 http://deeplearninganalytics.org/来看看我们吧。

你也可以在 https://medium.com/@priya.dwivedi 的看到我的其他作品

如果你有一个我们可以合作的项目，请通过我的网站或 info@deeplearninganalytics.org 联系我

参考文献

非常感谢 Udacity，特别是他们的 NLP 纳米学位让学习变得有趣！
LDA 上的纸

面向 LGBTQIA+社区的 NLP:自然语言处理入门第 1 部分

原文：https://towardsdatascience.com/nlp-for-the-lgbtqia-community-a-primer-on-natural-language-processing-part-1-7f0ffd1bb54d?source=collection_archive---------0-----------------------

What do we want? Trans rights! When do we want them? NOW!

跨性别群体的担忧

我将坦率地直接切入正题:当涉及到每天在世界上导航时，跨性别群体面临着不可逾越的挑战。2016 年有 27 名变性妇女被谋杀，2017 年有 9 名变性妇女被谋杀(这个数字大概会)。这些妇女大多是有色人种。

国家跨性别平等中心在最近的一份报告中显示了非常明显的统计数据。27%的变性人。 27% 的跨性别者报告生活贫困(年收入 2 万美元)。 14% 报告失业(是总人口的两倍)，绝大多数人报告存在某种职业歧视(无论是被拒绝升职还是因跨性别被解雇)。

在我们的刑事司法系统中，变性人面临着严重的歧视。 22% 曾报告被警察骚扰。 16% 曾被监禁的受访者报告过监狱看守的严重性骚扰。我们甚至没有多少变性人仅仅因为表达他们的身份而被监禁的数字。

跨性别群体在健康和获得健康方面存在巨大差异。 41% 的跨性别者报告曾试图自杀， 19% 报告曾被医务人员拒绝提供医疗帮助， 28% 报告因受到歧视威胁而推迟护理。

我为什么关心这些问题？我是一名变性女性，一直在思考我们当前社会对我生计的攻击。但此外，我很荣幸拥有高等学位和专业技能。我有责任将这些技能运用到工作中。

获取跨社区相关数据。

我在以前的一篇文章中提到过，很难找到与同性恋问题相关的数据，至少那些公开的数据是如此。这需要一些创新思维。Reddit 实际上是一个数据宝库，尽管人们可能不会这么想。我们通常认为 Reddit 是猫图片和愚蠢迷因的来源。在我发现自己身份的旅程中，我在 reddit 上找到了我经常使用的支持论坛。这些论坛提供了一个独特的数据集，以更好地了解变性人的关注。

我一直在使用自然语言处理方法挖掘这些数据，并决定一石二鸟也是值得的:1)通过自然语言处理和机器学习提供对围绕跨性别群体的关注的见解，2)做一个关于自然语言处理基础的教程。

什么是自然语言处理(NLP)？

根据 Algorithmia 的说法，NLP 是“计算机以一种聪明而有用的方式来分析、理解人类语言并从中获取意义的一种方式。”我用一个很傻的句子，取自 sub-Reddit/r/startled cats作为例子。

“Can I haz bag?” I needed to offset the gloomy trans stats with sillier cats.

I do yoga with cats. Cats are magnetically drawn to a human engaged in awkward positions. The will place themselves where they can be most inconvenient.

我们如何用一种有意义的方式将这些词量化？我们甚至不要正确理解这句话的意思。首先，我们需要对文本进行标记。这意味着将文本拆分成如下内容:

['I', 'do', 'yoga', 'with', 'cats']

也许我们需要确定这个句子的语法。

[(‘I’, ‘PRP’), (‘do’, ‘VBP’), (‘yoga’, ‘RB’), (‘with’, ‘IN’), (‘cats’, ‘NNS’)

其中 PRP 是人称代词，VBP 是现在时动词，rb 是副词，IN 是介词，NNS 是复数名词。当您读入更多的文本数据时，它会变得更加复杂。

假设您想用这些单词标记进行某种文本分类。如何把文字当做特征？with和do这两个词有关联吗？在我们的例子中，我们如何对待单词cat和cats？我们是把它们当成一个词，两个词，还是要看上下文？

让我们思考一下单词的意思。计算机如何从下面的句子中提取意思:

I went by the river bank yesterday.

I went and robbed a bank yesterday.

我们如何着手确定单词 token bank的含义？

我希望这能让你更好地理解我们在日常生活中经常看到的自然语言处理的应用。语言很复杂！我们甚至还没有触及亚马逊 Alexa 和谷歌 Home 等产品中的信号处理。

NLP 管道，一目了然。

我在 Insight 中学到了相当多的 NLP，我只想说:与典型的数据挖掘相比，挖掘文本数据并不是一个真正透明的过程。典型的数据集，即使是杂乱的，也会通过 SQL 数据库来到你面前。csv 文件，JSON 格式的数据等。许多文本数据不支持。那么，我们如何对文本数据进行分析呢？(顺便说一下，我使用的当前数据集存储在 SQLite 数据库中)。

首先，您需要适当的库。我使用 Python 包nltk ( 自然语言工具包)作为我的面包和黄油，但是像spaCy (www.spacy.io)这样的新包可以做很多和nltk一样的事情。

The most basic NLP pipeline.

管道通常遵循上述格式。首先从数据源读入数据。然后标记并删除停用词。标记化将句子'I do yoga with cats'放入一个数组['I', 'do', 'yoga' ,'with', 'cats'].中

“停用词”是低信息词，对你正在分析的文本没有什么帮助。nltk有一个常用停用词库，但我通常也会定义自己的停用词集。删除停用词时，您的文本可能如下所示:``['I', 'yoga' ,'cats']`。删除停用词的方法没有对错之分，这取决于您正在处理的文本数据。

现在我们对文本进行“词干化”或“词汇化”。单词可以有许多屈折变化。我们举个例子startle。可以有startled或者startling。为了便于分析，您可能只想将令牌简化为startl。词条简化包括将一个单词简化成它的常见形式，即词条。例如，标记go、going、gone和went具有相同的基础形式go。

从那里，我们以某种方式对文本进行矢量化(我将在接下来的另一篇博客文章中介绍)。这只是意味着每个令牌都以某种方式用数字表示。它们可以被表示为原始频率。存在更复杂的矢量化，可以表示与主题相关的单词或者它们如何与其他单词相关联(例如，潜在语义分析、Word2Vec 单词嵌入模型)。

将这些方法应用于来自 Reddit 的转基因数据

好了，现在是我想吃的肉。我将分享一些代码片段，但我的大部分代码你可以在相关的 github repo 中看到。

为了这个分析，我从 reddit /r/asktransgender 子网站上收集了大约 2 万条评论。具体来说，我利用谷歌的云平台(谷歌大查询)来检索评论。谷歌有大量的当前和以前年份的 reddit 评论语料库(文本数据集合)，这是一个不太难获取 reddit 数据的来源。

我所有的 Reddit 数据都存储在 SQLite 数据库中(顺便说一句，这个数据库比我以前的 Postgres 数据库更容易建立。下次再发)。最初，我查询了数据，并将其读入熊猫数据框。文本数据可能不可靠，你将不得不不断地从 UTF-8 文本格式中解码和重新编码它们。

以下代码采用一个数据帧。在您指定的列标题中，它会将文本转换为字符串格式，将所有文本设置为小写，并最终解码文本。

def decode(column_title):
    dataframe = self.dataframe
    dataframe[column_title] = dataframe[column_title].astype(str)
    dataframe[column_title] = dataframe[column_title].str.lower()
    dataframe[column_title] =   dataframe[column_title].str.decode('UTF-8', errors='strict')
    return dataframe

在接下来的代码片段中，我定义了要删除的停用词。有一个预建的字典，但是我也添加了一些随机的 ASCII 字符来删除。您也可以使用正则表达式来删除这些符号。

def defineStopwords(words = None):
    stop_words = stopwords.words('english')
    etc_stop = ['.', ',', '?', '!', '\'',  ':', '\"', '{', '}', ';', '%', '[',  ']', '(', ')', '-', '\'s', '\'ve', '...', '\'ll', '`', '``', '"n\'t"', '"\'m"', "''", '--', '&']
   if words is not None: 
       stop_words = stop_words + etc_stop + words

       else:
           stop_words = stop_words + etc_stop

   return stop_words

这个片段中有很多内容，但它本质上实现了我的 NLP 管道。我做一些重新编码和解码，标记我的语料库中的每个文档(在nltk中使用RegexTokenizer，并使用列表理解i for i in temp if i not in stopwords删除停用词。然后我让记号符号化。该函数返回单个标记以及二元模型的大列表。

二元模型是词对而不是单个记号。有时我们对二元模型感兴趣，因为它们添加了更多关于常见共现词的信息(例如，panic attack)。

我们将这些记号和二元模型添加到空列表中。现在我们准备做一些基本的可视化！

def wordTokens(df_column, words = None, encode = True):

    df = self.dataframe
    df = self.decode(df_column)
    corpus = df[df_column].tolist() singletons = []
    bigrams = []

    stopwords = self.defineStopwords()

    for post in corpus:
       temp = post.lower()
       if encode == True:
           temp = post.encode('ascii', 'ignore').decode('ascii')
       else:
           continue

       print temp
       temp = temp.encode('utf-8').translate(None, string.punctuation)
       tokenizer = RegexpTokenizer(r'\w+')
       temp = tokenizer.tokenize(temp)
       stopped_tokens = [i for i in temp if not i in stopwords]
       lemmatized_tokens = [nltk.WordNetLemmatizer().lemmatize(i) for i in stopped_tokens]
       bigram = nltk.bigrams(lemmatized_tokens)
       bigram = list(bigram)
       singletons.append(lemmatized_tokens)
       bigrams.append(bigram)

       print '\n Successfully cleaned and tokenized abstracts.'

    return singletons, bigrams

我的/r/ask 跨性别语料库的频率计数

作为一名数据科学家，您应该做的第一件事是进行一些探索性分析。在自然语言处理中，你可以先看一下词频，以便更好地了解你正在看的东西。这就是我对单个单词和二元模型所做的。

token_corpus = []
for doc in tokens:
    for token in doc:
        token_corpus.append(token)

单个令牌和二元模型被组织成嵌入到一个更大列表中的列表。我想得到一个单个记号列表，所以我简单地遍历我的原始语料库并创建一个新的。

fdist = nltk.FreqDist(token_corpus)
words = []
freq = []
for word, frequency in fdist.most_common(100):
    words.append(word)
    freq.append(frequency)

我调用nltk.FreqDist来生成我的频率分布。从那里，我使用我的fdist对象(这是一个字典)，并创建两个单词和频率列表。最后，我使用这些列表来可视化我在seaborn的频率分布。

下图显示了前 75 个单个令牌和二元模型。

个人代币

二元模型

我想指出，二元模型的频率产生了一些有趣的见解。在我们的文本中，我们看到了一些性别身份的不确定性，这并不奇怪(至少对我来说，作为一个跨性别的同性恋者),因为/r/asktransgender 是一个支持社区。人们经常提到“性别认同”和“性别焦虑”。我们还观察到诸如“开始 hrt”的标记。HRT 代表“激素替代疗法”。在我们的社区，获取荷尔蒙是一件大事，有很多人问这个问题也不足为奇(至少对我来说)。我们也看到像“我很担心”这样的标记，这可能表明个人对过渡有某种焦虑。

词对搭配

搭配是相互之间有很强关联的词对，我们可以用统计学来确定某个词对是否有超出随机几率的显著的相互关联。例如，在我们的语料库中gender identity和gender dysphoria是可以相互关联的。

简而言之，我们可以使用逐点互信息统计来计算重要的搭配。这方面的方程式如下:

其中 PMI 等于给定 word-x 的 word-y 的概率的对数除以 word-y 的概率，nltk具有搭配功能，从我们的语料库中导出 PMI 得分。也有其他方法可以实现这一点(例如，卡方检验、学生 t 检验和对数似然比检验)。

bigram_measures = BigramAssocMeasures()
finder = BigramCollocationFinder.from_words(token_corpus)
finder.apply_freq_filter(20)
finder.nbest(bigram_measures.pmi, 15)

上面的代码获取一个语料库，应用一个频率过滤器(只查找出现 20 次以上的搭配)，并找到 15 个最佳搭配。这些搭配列举如下:

('roller', 'coaster'),
 ('vice', 'versa'),
 ('san', 'francisco'),
 ('bart', 'van'),
 ('howard', 'brown'),
 ('penile', 'inversion'),
 ('caitlyn', 'jenner'),
 ('rib', 'cage'),
 ('north', 'carolina'),
 ('cyproterone', 'acetate'),
 ('adam', 'apple'),
 ('van', 'de'),
 ('brow', 'ridge'),
 ('coping', u'mechanism'),
 ('planned', 'parenthood')

所以我们看到一些有趣的事情。还是那句话，很多医学上的东西。阴茎倒置是性别确认手术中使用的一种技术。霍华德·布朗是芝加哥的一家 LGBTQ 诊所。醋酸环丙孕酮是一种用于阻断睾酮的药物。我们也看到渗透社会意识的事情，比如凯特琳·詹娜和北卡罗来纳(由于歧视性的 HB2 法案)。还列出了人们可能希望生活的地方(旧金山)，以及其他可以获得激素替代疗法的地方(计划生育)。

我还使用对数似然比测试探索了搭配。简而言之，对数似然比检验是:

对数似然比测试以下内容。假设 1 (H1):单词 1 的出现独立于单词 2 的先前出现。假设命题 2 (H2):单词 2 的出现依赖于单词 1 之前的出现。因此，对数等于 H1 和 H2 的可能性。对数似然检验给了我们一些更合理的搭配。

 ('feel', 'like'),
 ('dont', 'know'),
 ('dont', 'want'),
 ('anyone', 'else'),
 ('year', 'old'),
 ('im', 'sure'),
 ('even', 'though'),
 ('month', 'ago'),
 ('gender', 'identity'),
 ('year', 'ago'),
 ('trans', 'woman'),
 ('high', 'school'),
 ('facial', 'hair'),
 ('trans', 'people'),
 ('informed', 'consent')

我们看到有一些非常常见的搭配(例如，“感觉像”、“不知道”)。有些搭配为质疑性别认同的个人提供了一个共同关注的视角。像“其他任何人”这样的搭配表示一种陈述，如“其他任何人和经历过……”，或者“知情同意”表示一个问题，如“其他任何人和知道 x 区有一家知情同意诊所可以获取激素吗？”

简单的文本语料库分析产生的线索可以帮助我们理解跨性别群体的密切关注。

结论和后续步骤

这些仅仅是分析这个数据集的初步步骤，但是到目前为止我们看到了一些有趣的数据模式。当挖掘这个数据集时，我一直在问自己的问题围绕着最常见的话题是什么，以及我们如何从关联的单词中推导出单词的含义，以深入数据？我们能否在文档分类框架中使用这些文本数据来预测精神痛苦或医疗需求？第 2 部分将涵盖其中的一些主题，敬请关注！

米歇尔是波士顿的 LGBTQ 活动家和数据科学家。你可以在 LinkedIn 或者她的 个人网站 上找到更多关于她的信息。

法律文档主题建模和摘要的自然语言处理。

原文：https://towardsdatascience.com/nlp-for-topic-modeling-summarization-of-legal-documents-8c89393b1534?source=collection_archive---------1-----------------------

你有没有想过律师是如何有效地处理一系列法庭陈述的？他们如何绕开法律文件的总体背景，以便在最终不得不着手处理之前弄清楚需要注意什么。看起来很容易，除非你有一个 3000 页的文档，里面有突出的细节。这就是这个项目背后的动机，从法律文档的 pdf 中自动建模主题并总结关键上下文。

该项目旨在从双方签订的一份长达 5 页的商标和域名协议中自动建立话题模型，以提取对双方有利或不利的话题上下文。这种方法包括:从文档的 pdf 副本中提取文本，清理提取的文本，从文档中建模主题，并显示可视摘要。注意，这里采用的方法可以扩展到几乎所有保存为 pdf 格式的文档。

从 PDF 文档中提取文本

双方之间的法律协议以 pdf 文档的形式提供。首先使用下面显示的函数从 pdf 文档中提取文本。该函数使用 python 库 pdf-miner *从 pdf 文档中提取除图像之外的所有字符(尽管我可以修改以适应这一点)。*该函数只接受主目录中 pdf 文档的名称，从中提取所有字符，并将提取的文本作为字符串的 python 列表输出。

Figure showing the function that extracts texts from a pdf document

清理提取文本

从 pdf 文档中提取的文本包含需要删除的无用字符。这些字符降低了我们的模型的有效性，因为它们提供了不必要的计数比。下面的函数使用了一系列的 正则表达式 搜索和替换函数以及一个列表理解来用空格替换这些字符。以下函数用于此过程，显示的结果文档仅包含字母数字字符。

Figure showing code which replaces document coding with blank space

Figure showing code which replaces non-alpha characters with blank space

主题建模

T 使用 scikit-learn 模块 计数矢量器 进行最小参数调整，将干净文档表示为 DocumentTermMatrix。这是因为建模要求将字符串表示为整数。CountVectorizer 显示删除停用字词后，某个字词在列表中出现的次数。

Figure showing how the CountVectorizer is fitted on the document with stop-words

文档术语矩阵被格式化为 pandas 数据框架，以便浏览数据集，如下所示。该数据框显示了文档中每个术语的单词出现次数。在没有格式化为数据帧的情况下，文档术语矩阵作为稀疏矩阵存在，并且应该使用 todense() 或 toarray()将其转换为密集矩阵。

Figure showing a cross-section of the output from the CountVectorizer

该文档术语矩阵被用作由 潜在狄利克雷分配 算法用于主题建模的输入数据。现在这个 LDA 算法有几个不同的实现，但是对于这个项目，我将使用scikit-learn实现。另一个非常著名的 LDA 实现是 Radim Rehurek 的 gensim 。这适合于由计数矢量器输出的文档术语矩阵。该算法适合于隔离五个不同的主题上下文，如下面的代码所示。这个值肯定可以根据您想要从建模中获得的粒度级别进行更改。

Figure showing how the LDA model was fitted on the DocumentTermMatrix with 5 topics

下面的代码使用 mglearn 库来显示每个特定主题模型中的前 10 个单词。人们可以很容易地从每个主题所呈现的单词中总结出结论。

Figure showing the 5 topics from LDA and the most common words in each topic

从以上结果来看，显然主题 2 与商标所有权协议条款和条件有很大关系。话题 1 谈论涉及签名和一些义务的当事人之间的协议。ECLIPSE 一词似乎在所有五个主题中都很普遍，这表明了它在整个文档中的相关性。

这一结果与文件*(商标和域名协议)非常一致。***

为了更细致地观察每个主题，我们提取每个主题模型的句子进行简要总结。下面的代码从主题 1 和主题 4 中提取了前 4 个句子。

Figure showing sentences within Topic model 1 and 4

Topic-1 中的句子讨论了根据纽约市的法律将商标转让给 eclipse 的问题。

此外，题目 4 中的句子清楚地表明了域名和商标协议的生效日期。

结果可视化

T 何pyl Davis库用于可视化主题模型。请注意主题 1 和主题 4 之间的关系有多密切，主题 2、主题 3 和主题 5 之间的距离有多远。这些主题(2、3 和 5)捕获了法律文档中相对不同的主题，并且是那些应该更仔细观察的主题，因为它们在组合时会提供文档的更宽视图:

Figure showing how distinct each modelled topic is from one another

从下图可以看出，话题 5 指的是双方之间的协议、义务和签名，而话题 3 谈论的是域名、头衔和商标。

Figure showing the words which are most frequent in Topic-3

还为整个法律文档生成了一个 wordcloud ，以记录文档中最常出现的术语，如下图所示。这通常与主题建模的结果一致，因为像商标、协议、域名、eclipse 等这样的词被视为重复出现，因此更加醒目。

A wordcloud showing the most occurrent words/phrases in the legal document

结论

B y 将通过潜在狄利克雷分配模型获得的主题 2、3 和 5 与为法律文件生成的词云相结合，我们可以有把握地推断出该文件是双方之间对商标域名转让的简单法律约束。

这个项目遵循一个简单的方法来从 pdf 文档中提取文本，这个项目可以修改以从图像文件中提取文本。jpeg。png)，从而可以在文档快照上进行主题建模和摘要。该项目显示了机器学习如何应用于法律部门，通常用于提供主题的文档摘要。

这个项目的一个更实际的应用是在小说、教科书等的章节上进行文本摘要，它已经被证明是非常有效的。

用于此分析的代码(IPython 笔记本)的链接可以在我的 github 页面上找到:https://github . com/chibueze 07/Machine-Learning-In-Law/tree/master

NLP |序列到序列网络|第 1 部分|处理文本数据

原文：https://towardsdatascience.com/nlp-sequence-to-sequence-networks-part-1-processing-text-data-d141a5643b72?source=collection_archive---------3-----------------------

通过理解 NLP，你可以获得许多好处，你可以制作自己的模型来回答问题并在聊天机器人中使用它，或者你可以制作一个翻译器来将文本从你的语言翻译成英语或相反的语言，或者你可以制作一个文本摘要器。

在这个教程系列中，我们将学习如何制作一个 seq2seq 网络，并训练它将英语文本翻译成法语，或者您可以在另一个 seq2seq 用途中使用它。

在本系列的这一部分中，我们将学习如何处理文本数据以将其提供给 seq2seq 网络。

我们将学习两种处理文本的方法

字符级处理
单词级处理(使用嵌入)

我用了一个英语→法语句子的数据集，你可以从这里得到我用的数据集。

对于其他语言，您可以使用[this链接获得数据集

第一:字符级处理

概述:

我在下面的图片中解释了文本处理的步骤:

所以，代表这个词的球:

，来代表句子 hello world！:

我希望您对处理文本数据的步骤有了一些直觉。

现在我们将使用 python 进行一些编码:

首先，让我们导入 numpy:

import numpy as np

然后，加载文本文件:

之后，拆分样本并获取必要的字典:

制作所需的字典，将字符转换为整数，反之亦然:

计算最长样本的长度和一些其他变量:

输出:

Number of E Samples  	: 160872
Number of D Samples 	: 160872
Number of D Chars  	: 115
Number of E Chars 	: 92
The Longest D Sample has 351 Chars
The Longest E Sample has 286 Chars

E →输入文本(稍后编码)
D →输出文本(稍后解码)

接下来，我们将通过字母
ex 对样本进行热编码:

hi—>[[0，0，0，…，1，0，0，0]，[0，0，0，…，0，1，0，0]]
其中我们将每个样本表示为一个包含(n)行和(j)列的零数组
n =最长样本中的字符数
j =字典中的字符数

我们将制作三组数据:
1-编码器输入样本(英语句子)
2-解码器输入样本(法语句子)
3-目标(法语句子)

目标将是与解码器输入相同的数据，但它将领先一个字符
例如:
解码器输入= '\tHow are yo'
目标= '你好吗'

[Output]:
Shape of encoder_input_data : (160872, 286, 92) 
Shape of decoder_input_data : (160872, 351, 115) 
Shape of target_data        : (160872, 351, 115)

现在，seq2seq 模型可以使用这些数据了。

ٍSecond:单词级处理(使用嵌入):

概述:

在这种方法中，我们执行与第一种方法相同的步骤，但是这里不是制作字符字典，而是制作我们想要处理的文本中使用的单词的字典，或者有时我们使用文本语言中最常见的 10，000 个单词。

为了便于理解我们将要做的事情，我们将:

将文本转换为小写
清除数字和标点符号中的数据。
将“SOS”和“EOS”附加到目标数据:

SOS →感知开始

EOS →感觉结束

4.制作字典将单词转换成索引数字。

5.使用嵌入层将每个单词转换为固定长度的向量。

单词嵌入提供了单词及其相关含义的密集表示。

了解更多关于单词嵌入的信息:[ 1 ，[ 2 ，[ 3 ，[ 4 ]

6.现在，seq2seq 网络可以使用这些数据了。

加载文本数据:

数据清理:

样品处理:

使用单词嵌入:

我将展示我使用嵌入层的那一行，整个网络将在本系列教程的下一部分解释。

num_words : is the number of words in the dictionary we used to convert words to numbers
vec_len : The length of the vector that will represent the words

接下来是什么:

在下一部分[ part 2 ]我们将制作模型并训练它，然后用它将英文文本翻译成法文。

参考资料:

这个系列的所有参考资料将在最后一部分的结尾。

可以在 Twitter 上关注我@ ModMaamari

NLP |序列到序列网络:

1- NLP |序列到序列网络|第 1 部分|处理文本数据

2- NLP |序列到序列网络|第 2 部分|Seq2seq 模型(编码器解码器模型)

NLP |序列到序列网络|第 2 部分|Seq2seq 模型(编码器/解码器模型)

原文：https://towardsdatascience.com/nlp-sequence-to-sequence-networks-part-2-seq2seq-model-encoderdecoder-model-6c22e29fd7e1?source=collection_archive---------2-----------------------

在[NLP | Sequence to Sequence Networks | Part 1 | Processing text data中，我们学习了如何处理文本数据，在这一部分中，我们将创建一个模型，该模型将获取我们处理的数据，并使用它来训练将英语句子翻译成法语。

我们将使用一种称为(seq2seq)或(Encoder Decoder)的架构，它适用于输入序列(在我们的例子中是英语句子)的长度与输出数据(在我们的例子中是法语句子)的长度不同的情况

什么是编码器解码器架构？

Encoder Decoder Architecture

编码器解码器架构由两个主要部分组成:

编码器:

编码器简单地获取输入数据，并对其进行训练，然后将其循环层的最后状态作为初始状态传递给解码器部分的第一循环层。

Encoder input : English sentencesEncoder initial state : It depends on the initializer we use

2。解码器:

解码器获取编码器最后一个递归层的最后一个状态，并将其用作其第一个递归层的初始状态，解码器的输入是我们想要得到的序列(在我们的例子中是法语句子)。

Decoder input : French sentencesDecoder initial state : The last state of encoder’s last recurrent layer

其他一些解释编码器解码器的图片:

Simple Representation

Generative Model Chatbots

了解有关编码器/解码器架构的更多信息[0]、1、2、3、4

构建模型:

首先，导入所需的依赖项:

构建编码器:

The Encoder

我们使用( Keras Functional API )来构建这样复杂的模型，如果你想了解更多关于 Keras Functional API 的知识:[ 1 ，[ 2 ]

编码器由以下部分组成:

输入层:获取英语句子并将其传递给嵌入层。
嵌入层:获取英语句子并将每个单词转换成固定大小的向量
第一个 LSTM 层:每一个时间步，它采用一个代表一个单词的向量，并将其输出传递给下一层，我们使用 CuDNNLSTM 层而不是 LSTM，因为它快得多。
第二 LSTM 层:它与前一层做同样的事情，但不是传递其输出，而是将其状态传递给解码器的第一 LSTM 层。

构建解码器:

**解码器由:**组成

输入层:获取法语句子并将其传递给嵌入层。
嵌入层:获取法语句子，并将每个单词转换为固定大小的向量
第一个 LSTM 层:每一个时间步，它都采用一个表示单词的向量，并将其输出传递给下一层，但在解码器中，我们将这一层的状态初始化为解码器中最后一个 LSTM 层的最后一个状态。
第二 LSTM 层:处理前一层的输出，并将其输出传递给密集层。
密集层(输出层) :获取前一层的输出，并输出一个表示目标法语单词的 hot vector

注:

我们必须知道，我们不能在一个时间步长内将每一个英语句子转换成法语，我们要在多个时间步长内完成，这些时间步长等于最长的英语句子的字数。

因此，如果最长的英语句子有 10 个单词，我们必须采取 10 个时间步骤来获得它的法语翻译。

我使用前面的模块简化了编码器和解码器模型，实际上，我们有许多时间步长，而不是简化表示中的一个，最终输出不是我们可以直接阅读的句子，实际情况是，每个时间步长我们都会获得一个代表目标单词的热点向量。

将编码器和解码器整合到一个模型中:

Model Summary

训练模型:

我只使用了 9000 个样本，因为我没有足够的内存来使用整个数据集，正因为如此，结果不够好。

我们使用的优化器是 rmsprop **，**它用在有循环层的模型中。

这个优化器通常是递归神经网络的好选择。

我们使用categorial _ cross entropy作为损失函数，因为我们将每个单词视为一个类别(我们的输出是一个代表单词的热点向量)

回想一下:

我们必须知道什么是编码器解码器模型。
如何创建编码器
如何使用嵌入层
如何制作解码器
我们了解编码器解码器模型是如何工作的
我们训练了这个模型

接下来是什么:

在本系列的下一部分，我们将使用训练好的模型将英语句子翻译成法语。

NLP |序列到序列网络:

1- NLP |序列到序列网络|第 1 部分|处理文本数据

2- NLP |序列到序列网络|第 2 部分|Seq2seq 模型(编码器解码器模型)

参考资料:

这个系列的所有参考资料将在最后一部分的结尾。

你可以在推特上关注我 @ModMaamari

NLP 文本相似性，它是如何工作的，以及它背后的数学原理

原文：https://towardsdatascience.com/nlp-text-similarity-how-it-works-and-the-math-behind-it-a0fb90a05095?source=collection_archive---------9-----------------------

看看这几对句子，你觉得这几对中哪一对有相似的句子？

你可能对前两个很有信心，但对后两个就没那么有信心了。实际上，你是对的，因为前两对句子谈论的是同一件事(独立地)，所以非常相似。然而，最后两对中的句子谈论非常不同的事情，因此不会被视为相似的句子。

令人惊讶的是，NLP 模型正好相反。根据文本相似度在自然语言处理中的工作方式，最后两对句子非常相似，但不是前两对！😮

在你开始判断 NLP 的能力之前，让我们看看它是如何工作的，以及它背后的数学原理。所以，我们来看看机器是怎么看这些句子的！

第一句:“全球变暖来了”

句子 2: “海洋温度正在上升”

为了使这两个句子相似，即使从机器的角度来看，你也需要探索一个全新的语义分析维度，根据这个维度，这两个句子非常相似。点击此处并键入这两个句子。

现在，回到我们的 NLP 模型，是我们破解它的时候了！

**第一步:**从两个句子中选出唯一的单词，等于 7。

独特词汇: 全球，变暖，是，这里，海洋，温度，上升

第二步:统计每个句子中独特单词的出现次数

分析句子 1

global, 1
warming, 1
is, 1
here, 1
ocean, 0
temperature, 0
rising, 0

分析第二句

global, 0
warming, 0
is, 1
here, 0
ocean, 1
temperature, 1
rising, 1

简单的部分已经结束了，在我们继续之前，你必须知道 NLP 的文本相似度是在余弦相似度的基础上工作的。余弦相似度基本上就是两个向量之间的角度的余弦。所以，我们想把句子转换成两个向量，我们已经完成了！

句子 1 的向量: [ 1，1，1，1，0，0，0 ]

句子 2 的向量: [ 0，0，1，0，1，1，1]

让我们把向量形象化。

请注意，在我们的例子中，我们有一个 7D 矢量，因为不可能可视化一个 7D 矢量，我将向您展示两个 3D 矢量并解释其工作原理。

所以，这里我们有两个 3D 向量**【1，1，1】和【0，0，1】**。你可以把这些向量想象成总共有 3 个独特单词的两个句子。这里， [ 1，1，1 ] 将意味着所有 3 个唯一单词在第一句中出现一次，而 [ 0，0，1 ] 将意味着只有第三个唯一单词在第二句中出现一次。

我们只对这两个向量之间的角度感兴趣。两条线越近，角度就越小，因此相似性增加。因此，如果任何两个句子完全相似，你将在 **3D 空间中只看到一条线，**因为两条线会相互重叠。

Vectors getting closer, similarity increases as both sentences now have 2 words in common

A perfect match of 2 sentences!

我希望你能理解我们在这里想要达到的目标或者 NLP 想要做的事情。所以，让我们回到我们的原始向量，然后计算两者之间的余弦角。我们的载体:

句子 1 的向量:【1，1，1，1，0，0，0】

句子 2 的向量: [ 0，0，1，0，1，1，1]

测量两个矢量之间的角度

这不是火箭科学，你需要知道的只是这个公式:

在分子中，我们有矢量的点积，在分母中，我们有两个矢量长度的乘积。

让我们为我们的例子找出点积:
公式->(u1 * v1)+(U2** v2)+…..+*(un** VN)*那就->(1 * 0)+(1 * 0)+(1 * 1)+(1 * 0)+(1 * 0)+(1 * 0)+(1 * 0)= 1
求两个向量的长度:

所以，现在我们要计算:1 / 4 等于 0.25

总之，根据 NLP 文本相似度，两个句子“全球变暖在这里”和“海洋温度正在上升”只有 25% 相似，这与语义分析显示的完全相反。

现在，让我们快速对另外一对句子执行相同的步骤:

句子 1: “这个地方很棒”

句子 2: “这是个好消息”

独特词汇: 这，是，伟大，地方，新闻

句子 1 的向量:【1，1，1，1，0】

句子 2 的向量:【1，1，1，0，1】

将这些向量放入余弦公式，您会得到值 **0.75，**表示相似度 75%

请注意，值越大，角度越小，句子越相似。

所以，下次当你想到在你的项目中使用 NLP 文本相似度时，你就会知道它的真正目的以及它与语义分析的不同之处。

干杯！

NLP vs NLU vs NLG(知道你要达到的目标)NLP 引擎(第一部分)

原文：https://towardsdatascience.com/nlp-vs-nlu-vs-nlg-know-what-you-are-trying-to-achieve-nlp-engine-part-1-1487a2c8b696?source=collection_archive---------4-----------------------

区别自然语言处理，NLU，NLG 和可能的事情可以实现时，实现聊天机器人的自然语言处理引擎。

在这个快速发展的机器学习和人工智能领域，混淆特定术语是非常常见的。以上同样是三个词互换为高兴的情况。

现在让我们用三个词来概括:

NLP —自然语言处理
NLU —自然语言理解
NLG —自然语言生成

如果我需要用数学的方式来说，可以说 NLU 和 NLG 的结合将产生一个有效的 NLP 引擎。

NLP = NLU + NLG

NLU 是对用户或输入的含义的理解。那只不过是对所给文本的理解，并把它归类为适当的意图。

NLP = NLU + NLG(source)

让我们举个例子:“我今天可以打板球吗

你的 NLP 引擎应该怎么做？？

这里，用户意图是玩板球，但是，有许多可能性应该被考虑。其中一个依赖项是“查看外的天气”。

如果外面正在下雨，因为板球是一项户外运动，我们不建议玩，对吗？？？如您所见，我们需要将它转换成结构化数据，那么我们该怎么做呢？我们利用了意图和实体。

NLP NLU NLG(source)

意图:

意图只不过是动词(用户需要做的活动)。如果我们想要捕获一个请求，或者执行一个动作，使用一个**意图。**在这个例子中，玩耍就是意图。

实体:

实体是需要执行的动作的名词或内容。在这里，cricket 是一个名词。

一个实体玩游戏可能有多个意图(比如检查天气、检查场地是否可用、检查朋友是否有空),也可能有多个实体的意图和多个实体的多个意图。

此外，意图和实体的变化基于以前的聊天检查如下。

第一步:“实体”——“板球”和“意图”——“游戏”

第二步:“实体”——“足球”和“意图”——“玩”

Step3: 【实体】—“足球”“意图”—“观看”

根据之前的聊天，查看实体和意图如何变化。

他们三人如何携手合作:

NLU 根据语法、说话的上下文以及意图和实体来理解数据。
NLP 会将文本转换成结构化数据。
NLG 生成基于结构化数据生成的文本。

NLU 和 NLG 是自然语言处理引擎的子集

NLP NLU(source)

更多参考资料:

人工智能真实还是只是这十年的炒作？？
人工智能:定义、类型、实例、技术
人工智能 vs 机器学习
机器学习为什么要实现人工智能？
机器学习类型和算法
【线性回归部分-1】
【线性回归第二部分(示例实现)

一定要在 上关注我LinkedInTwitter**insta gram获取更多更新。如果你喜欢这篇文章，请鼓掌并分享它。******

在这里加入我们的 WhatsApp 社区。

Kotlin 的 NLP

原文：https://towardsdatascience.com/nlp-with-kotlin-ec84c068650?source=collection_archive---------16-----------------------

使用 n 元语法的第一种方法

自然语言处理( NLP )是许多打着“机器学习”商标的应用程序的核心，尽管它们是自己的一组算法和接近人工智能的方式(对此有所保留)

NLP 用于创建聊天机器人，当你请求支持时，它可以帮助你提供相似的搜索结果；通过提供更容易处理的文本表示来翻译文本或减轻其他应用程序必须做的工作

NLP 的一个应用是生成或猜测序列中的下一个单词。与其他机器学习过程一样，猜测下一个单词需要训练一个模型，并使用它进行推理。

在这个例子中，您将看到如何构建一个在字符级工作的简单的单词生成器。

完成这项任务有不同的方法。在过去的几年里，不同风格的 RNN 正在击败其他产生文本的机制。然而，在这个项目中，我决定放弃它们，转而采用更简单的 n-gram 表示，因为它更适合解决这个问题

如果你想直接进入代码，可以在这里找到

[## 麦考比/机器学习

在 GitHub 上创建一个帐户，为 mccorby/MachineLearning 的开发做出贡献。

github.com](https://github.com/mccorby/MachineLearning)

什么是 n 元模型？

n-gram 基本上是一种将文本分割成一系列连续标记的方法

例如，对于文本“在拉曼查的一个村庄，我不想想起它的名字”，一个 4 克的表示将是

n-gram 语言模型将使用这种表示，通过计算不同的可能延续出现的次数来估计序列中下一个项目(一个单词、一个字符、一个完整的句子)的概率

此项目中使用的 n-gram 语言模型由地图的地图表示，如下图所示

每个条目代表一个 n-gram，带有序列中可能的字符的映射以及在语料库中找到的出现次数

这由一个映射<字符串、映射<字符、Int > > 表示

下面的代码用于定型模型

Training process for character-based n-gram language model

在构建更复杂的架构和方法时，n 元模型经常被用作基线模型

生成文本

为了使用这个模型生成文本，应用程序将获取一个初始输入(或空字符串)并查找下一个字符的候选字符。该字符被添加到输入中，形成在后续步骤中使用的历史

一个使用 5 克模型的样本没有唐吉诃德的初始种子，如下所示

第十章。

它的工作是给
的黑客装上马鞍，同时处理角色并追逐角色
去了拉曼查的一个村庄

其中对待角色和追求他，他把角色和实践自己拿起他的收入。这个人物和追求他的那个保持兵刃
的人物和追求它的人一样，都曾在他的收入里。所以，对它的追求也是如此，没有被称为 quexana 的欲望。角色的性格和追求，给角色装上马鞍，让自己成为一名骑士，周六吃点残羹剩饭，周六吃点扁豆，周六吃点扁豆，瘦瘦的，一个老圆盾，很久以前就不是他的收入了。这个人物和追求他的那个拉曼查保持兵刃之一

这段文字看起来很像塞万提斯写的东西(如果不是在他最好的时候)

缓和

但是当模型没有注册历史时会发生什么呢？然后它将停止工作，因为没有下一个字符

在这些情况下，使用一些技术。其中有平滑，特别是愚蠢的退避。

简而言之，愚蠢的退避将使用较低阶的 n 元文法来计算丢失条目的概率

选择字符

根据用于训练模型的语料库，选择下一个字符可能很棘手。如果总是选择具有最高概率的字符，则模型有可能陷入重复

为了避免这个问题，使用了从与当前历史相关联的一组可能候选中随机选择的字符

丰富

与任何其他机器学习问题一样，在构建系统时需要一系列步骤:数据检查、清理、模型评估
用于训练模型的语料库可以被清理，去除停用词

结论

这个项目展示了如何创建一个字符级的 n-gram 语言模型来生成文本。

我将使用这个模型作为该项目的第二部分的基础。

敬请期待！

神经网络:你需要知道的一切

原文：https://towardsdatascience.com/nns-aynk-c34efe37f15a?source=collection_archive---------1-----------------------

任何大型 ML 项目的主干都始于一个网络……一个神经网络，这是你需要了解的所有信息。

A Neural Network performing a prediction

如副标题所述，神经网络 (NNs)正在几乎任何需要启发式方法来解决问题的地方被使用。这篇文章将教你所有你需要了解的 NN。读完这篇文章后，你应该对神经网络有一个大致的了解，它们是如何工作的，以及如何自己制作一个。

以下是我要复习的内容:

神经网络的历史
什么是真正的神经网络？
单位/神经元
重量/参数/连接
偏差
超参数
激活功能
层层
神经网络学习时会发生什么？
实施细节(如何管理项目中的一切)
关于神经网络的更多信息(更多资源链接)

我偶尔会写这些有些简短但内容丰富的文章，以帮助您了解更多关于 AI 和机器学习的知识。您可以在 twitter 上关注我的或在这里关注我的来了解我的最新文章。你也可以在 twitter 上问我问题，或者在这里发表评论。

我花了一个多星期才写完这篇文章的所有内容，如果你觉得有帮助就鼓掌吧。我希望这篇文章教你一些新的东西，让我们开始吧！

神经网络的历史

因为，我不想用很多关于 NNs 的历史来烦你，我只会简单回顾一下他们的历史，T42。如果你想更深入地了解他们的历史，这里有一篇关于这个主题的维基文章。这一部分主要基于维基文章。

这一切都始于 1943 年沃伦·麦卡洛克和 沃尔特·皮茨 创造了第一个神经网络模型。他们的模型纯粹基于数学和算法，由于缺乏计算资源而无法测试。

后来，在 1958 年， 弗兰克·罗森布拉特 创造了第一个可以进行模式识别的模型。这将改变一切。 感知器 。然而，他只给出了符号和模型。实际模型仍然无法测试。在此之前有相对较少的研究。

第一个可以测试的多层神经网络由阿列克谢·伊瓦赫年科、T21和帕拉于 1965 年发表。

此后，由于机器学习模型的高可行性，神经网络的研究停滞不前。这是 1969 年由 马文·明斯基 和 西蒙·派珀特 完成的。

然而，这种停滞是相对短暂的，因为 6 年后的 1975 年 Paul Werbos 提出了 反向传播 ，它解决了【XOR】问题，并且总体上使神经网络学习更加有效。

Max-pooling 后来在 1992 年引入，它有助于 3D 对象识别，因为它有助于最小平移不变性和对变形的容忍。

在 2009 年至 2012 年间，尤尔根·施密德胡伯的研究小组创造的 递归神经网络 和深度前馈神经网络在 模式识别 和 机器学习 中赢得了 8 项国际比赛。

2011 年，Deep NNs 开始将卷积层与最大池层相结合，最大池层的输出随后被传递到几个完全连接的层，这些层之后是输出层。这些被称为 卷积神经网络 。

在这之后还有一些研究，但是这些是你应该知道的主要话题。

什么是真正的神经网络？

一个想到 NN 的好方法是作为一个 复合函数 。你给它一些输入，它给你一些输出。

基本神经网络的体系结构由三部分组成。这些是:

单位/神经元。
连接/重量/参数。
偏见。

上面提到的所有东西都是你构建一个神经网络的基本架构所需要的。

你可以把这些想象成一个建筑的积木/砖块。根据你对建筑功能的要求，你可以安排砖块，反之亦然。水泥可以被认为是砝码。不管你的砝码有多重，如果你手头没有足够数量的砖块来解决问题，这座建筑将会倒塌。然而，你可以让建筑以最小的精度运行(用最少的砖)，然后逐步地在这个架构上解决问题。

我将在后面的部分中更多地讨论权重、偏差和单位。这些部分可能很短，但是这些部分强调了它们的重要性。

单位/神经元

作为 NNs 架构的三个部分中最不重要的部分，这些函数包含权重和偏差，并等待数据到达它们。数据到达后，它们执行一些计算，然后使用一个激活函数将数据限制在一个范围内(大多数情况下)。

把这些单位想象成一个包含权重和偏差的盒子。盒子从两端打开。一端接收数据，另一端输出修改后的数据。然后数据开始进入盒子，盒子将权重与数据相乘，然后将偏差加到相乘后的数据上。这是一个单一的单位，也可以认为是一个功能。此函数与此类似，是直线的函数模板:

y = mx + b

想象一下有多个这样的东西。从现在开始，您将为同一个数据点(输入)计算多个输出。这些输出然后被发送到另一个单元，该单元然后计算神经网络的最终输出。

如果这一切都在你眼前一闪而过，那么继续读下去，你应该能理解更多。

重量/参数/连接

作为神经网络最重要的部分，这些(和偏差)是神经网络为了推广到一个问题必须学习的数字。这就是此时你需要知道的全部。

偏见

这些数字代表神经网络“认为”在将权重与数据相乘后应该添加的内容。当然，这些总是错误的，但是神经网络也会学习最优偏差。**

超参数

这些是您必须手动设置的值。如果你把神经网络想象成一台机器，改变机器行为的节点就是神经网络的超参数。

你可以在这里阅读我的另一篇文章(遗传算法+神经网络=两全其美)找出如何让你的计算机学习神经网络的“最佳”超参数。

激活功能

这些也称为映射函数。它们在 x 轴上接受一些输入，并输出一个限定范围内的值(大多数情况下)。大多数情况下，它们用于将单元的大输出转换为较小的值，并提高神经网络的非线性度。你对激活函数的选择可以极大地提高或阻碍你的神经网络的性能。如果您愿意，您可以为不同的单元选择不同的激活功能。

以下是一些常见的激活功能:

乙状结肠。

The Sigmoid function

Tanh 。

The tanh function

ReLU :整流线性单元。

The ReLU function

泄漏的 ReLU 。

The Leaky ReLU function

层

这就是帮助神经网络在任何问题中获得复杂性的原因。增加层数(单位)会增加神经网络输出的非线性。

每一层都包含一定数量的单元。大多数情况下的数量完全取决于创作者。然而，对于一个简单的任务有太多的层会不必要地增加它的复杂性，并且在大多数情况下会降低它的准确性。反之亦然。

每个神经网络都有两层。这些是输入和输出层。这两者之间的任何层都称为隐藏层。下图中的神经网络包含一个输入层(8 个单元)、一个输出层(4 个单元)和 3 个隐藏层，每个隐藏层包含 9 个单元。

A Deep Neural Net

具有两个或更多隐藏层的 NN，每层包含大量单元，称为深度神经网络，它催生了一个新的学习领域，称为深度学习。图中所示的神经网络就是这样一个例子。

神经网络学习时会发生什么？

教神经网络概括问题的最常见方法是使用梯度下降。因为我已经写了一篇关于这个主题的详细文章，你可以阅读来充分理解 GD(梯度下降)，我将不在这篇文章中解释 GD。下面是 GD 文章:渐变下降:你需要知道的一切。

再加上 GD，另一种教授 NN 的常用方法是使用反向传播。利用这一点，使用微积分中的链规则将神经网络输出层的误差向后传播。对于一个没有很好掌握微积分的初学者来说，理解这个很有挑战性，所以不要被它淹没。点击此处查看一篇文章，当我在与反向传播作斗争时，这篇文章确实帮了我大忙。我花了一天半的时间才弄明白错误反向传播时发生了什么。

在训练神经网络时有许多不同的注意事项。然而，在一篇面向初学者的文章中浏览它们会非常乏味，而且对初学者来说是不必要的。

实施细节(如何管理项目中的一切)

为了解释项目中的一切是如何管理的，我创建了一个 JupyterNotebook 包含一个学习 XOR 逻辑门的小 NN。点击这里查看笔记本。

在查看并理解笔记本中发生的事情后，您应该对基本神经网络是如何构造的有一个大致的概念。

在笔记本中创建的 NN 中的训练数据以矩阵形式排列。这是数据在中的一般排列方式。不同项目中显示的矩阵的维度可能会有所不同。

通常对于大量的数据，数据被分成两类:训练数据(60%)和测试数据(40%)。然后，神经网络根据训练数据进行训练，然后根据测试数据测试其准确性。

关于神经网络的更多内容(更多资源的链接)

如果您仍然不明白发生了什么，我建议您查看下面提供的资源链接。

YouTube:

Siraj Raval
3 蓝色 1 棕色
编码序列
布兰登·罗尔
巨型神经网络
雨果·拉罗彻尔
贾布里勒
路易斯·塞拉诺

Coursera:

多伦多大学的用于机器学习的神经网络
深度学习专业化由吴恩达
深度学习简介国立研究型大学高等经济学院

就这样，希望你学到了新的东西！

如果你觉得这篇文章有帮助，请鼓掌。在 Twitter 上关注我和在这里关注我的最新帖子。如果你有任何问题，你可以发微博给我，或者通过评论让我知道。我很乐意回答这些问题。

使用 Azure 笔记本进行轻松的机器学习实验

原文：https://towardsdatascience.com/no-hassle-machine-learning-experiments-with-azure-notebooks-e1a22e8782c3?source=collection_archive---------3-----------------------

使用 Microsoft Azure 笔记本电脑和 Microsoft 帐户，轻松快速地开始构建自己的机器学习实验。

Jupyter 笔记本是上帝给那些数据工作者的礼物。他们允许我们用 Julia、Python、R 和更多的(因此 JuPytR)做快速实验。它还混合了实时代码和文档，格式都很漂亮，带有 Markdown 和语法高亮——就像在一篇文章中运行代码一样。它们还允许我们在笔记本内部进行数据可视化。笔记本电脑也是可导出的，因此实验代码和结果可以与感兴趣的各方共享。最后但同样重要的是，它们非常容易使用。

问题是，即使它很容易使用，设置可能是一个痛苦。您还需要在笔记本中安装需要使用的库。这可能是一个持续几分钟到几小时的过程。

幸运的是，微软支持我们。进入微软 Azure 笔记本。它们基本上是托管在云上的 Jupyter 笔记本。您不需要再进行设置，并且处理数据所需的大多数库都在那里。目前支持创建 Python、R 和 F#笔记本。你唯一需要的是一个微软账户。

让我们开始吧。

打开 Azure 笔记本网站

Microsoft Azure Notebooks landing page

若要开始，请前往https://notebooks.azure.com/。您将会看到上面的登录页面。点击登录按钮登录。为此，您需要有一个 Microsoft 帐户。

创建一个库

I have a cloned TensorFlow library and an my own Experiments library.

登录后，您将被重定向到此处。该页面是您的仪表板，将包含您的库，其中包含您的笔记本和相关文件。我已经创建了两个库。要创建一个新的库，点击查看所有按钮之一，转到库页面。

All my libraries in list form in the Libraries page.

如果您选择其中一个，大多数禁用的按钮都会亮起，您现在可以运行、删除、克隆某个库。

现在，让我们通过点击新建库按钮来创建一个库。

Create New Library modal with some values.

点击新建库按钮后会出现一个模态。我们将创建一个名为“测试库”的库。您可以选择将其公开并创建一个 README.md。完成后单击创建按钮。

The Test Library page showing the files we currently have.

点击创建按钮后，我们被重定向到该页面。这列出了我们在测试库中的所有文件，以及我们可以对库进行的所有当前操作。我们勾选了创建 README.md 按钮，这样我们就有了 README.md 文件。

创建笔记本

让我们试着做一个实验，但首先我们需要一个笔记本来做。点击新建按钮创建一个新笔记本。当您这样做时，此模式将会出现:

Creating a Python 3.5 notebook called Diabetes.ipynb

创建一个名为Diabetes.ipynb的 Python 3.5 笔记本，点击新建按钮。这将创建一个新的 Python 笔记本，其中加载了大多数流行的 Python 数据科学库。您也可以使用相同的过程创建 R 或 F#笔记本。

创建笔记本后，单击其名称将其打开。

Our new Diabetes Python notebook

我们被重定向到空的糖尿病笔记本。在这里，我们将尝试使用来自 scikit-learn 的糖尿病数据集。让我们用 scikit-learn 提供的代码来试用一下数据集:http://scikit-learn . org/stable/auto _ examples/linear _ model/plot _ ols . html # sphx-glr-auto-examples-linear-model-plot-ols-py。我们不需要安装 scikit-learn，因为它已经安装在 Azure Python 笔记本中了。

生成的笔记本

访问此链接查看最终笔记本:https://notebooks . azure . com/n/z 8 xkjt 5 wdha/notebooks/diabetes . ipynb

Our experiment notebook.

结论

如果你想做快速的数据和机器学习实验，而没有安装太多库的麻烦，微软 Azure 笔记本值得一试。看看吧！😃

不，机器学习不仅仅是美化了的统计学

原文：https://towardsdatascience.com/no-machine-learning-is-not-just-glorified-statistics-26d3952234e3?source=collection_archive---------0-----------------------

original comic by sandserif

随着对深度学习的大肆宣传开始消退，这个迷因最近在社交媒体上到处都是，在互联网上产生了赞赏的笑声。机器学习真的没什么好兴奋的，或者它只是古老的统计技术的修正，这种观点越来越普遍；问题是这不是真的。

我明白——成为深度学习传道者中过度热情、喝得醉醺醺的一员并不时尚。2013 年鼓吹从屋顶上进行深度学习的人工智能专家现在只是带着一丝懊恼使用这个术语，而是倾向于淡化现代神经网络的力量，以免它们与许多人联系在一起，这些人似乎仍然认为import keras是跨越每个障碍的一步，他们知道这一点，就比他们的竞争对手有一些巨大的优势。

虽然深度学习确实已经不再是一个有用的流行语，正如 Yann LeCun 所说的，但这种过度修正的态度已经产生了对人工智能的进步、未来和有用性的不健康的怀疑。这一点从关于即将到来的人工智能冬天的讨论中可以清楚地看到，在这个冬天里，人工智能研究预计将像过去几十年一样停滞多年。

然而，这篇文章的目的不是反对人工智能冬天。这也不是说一个学术团体比另一个学术团体更值得深度学习的荣誉；更确切地说，是为了说明信用是的到期；我们看到的发展超越了大型计算机和更好的数据集；随着最近在深度神经网络和相关工作中的成功，机器学习代表了世界上最前沿的技术进步。

机器学习！=统计

“当你筹款时，它是人工智能。当你在招人的时候，就是 ML。当你实施时，这是逻辑回归。”

——推特上的每个人

要解决的主要问题，也是这篇文章的标题，是机器学习不仅仅是美化了的统计学——老一套的东西，只是有了更大的计算机和更花哨的名字。这个概念来自机器学习中流行的统计概念和术语，如回归、权重、偏差、模型、等。此外，许多模型近似于通常认为的统计函数:分类模型的 softmax 输出由逻辑组成，使得训练图像分类器的过程成为逻辑回归。

尽管这种思路在技术上是正确的，但将机器学习作为一个整体减少到仅仅是统计学的一个附属部分是相当牵强的。其实比较没有太大意义。统计学是数学的一个领域，处理对数据的理解和解释。机器学习只不过是一类计算算法(因此它从计算机科学中出现)。在许多情况下，这些算法在帮助理解数据方面完全没有用，只在某些类型的不可解释的预测建模方面有帮助。在某些情况下，例如在强化学习中，算法可能根本不使用预先存在的数据集。另外，在图像处理的情况下，将图像称为数据集的实例，将像素称为特征从一开始就有点牵强。

当然，重点不是计算机科学家应该得到所有的荣誉，或者统计学家不应该；像任何研究领域一样，导致今天的成功的贡献来自各种学术学科，其中首先是统计学和数学。然而，为了正确评估机器学习方法的强大影响和潜力，重要的是首先消除错误的观念，即人工智能的现代发展只不过是使用更大的计算机和更好的数据集的古老统计技术。

机器学习不需要统计学的高深知识

听我说完。当我正在学习机器学习的诀窍时，我很幸运地参加了一个致力于深度学习技术的精彩课程，该课程是我本科计算机科学计划的一部分。我们分配的项目之一是在 TensorFlow 中实施和培训 Wasserstein GAN。

在这一点上，我只上了一门统计学导论课，这是一门必修的普通选修课，然后很快就忘记了大部分内容。不用说，我的统计技能不是很强。然而，我能够阅读并理解一篇关于最先进的生成机器学习模型的论文，从头实现它，并通过在 MS Celebs 数据集上训练它，生成不存在的个人的非常令人信服的假图像。

在整个课堂上，我和我的同学们成功地训练了癌症组织图像分割、神经机器翻译、基于字符的文本生成和图像风格转换的模型，所有这些都采用了过去几年才发明的尖端机器学习技术。

然而，如果你问我，或者那堂课的大多数学生，如何计算总体的方差，或者定义边际概率，你可能会得到茫然的目光。

这似乎与人工智能只是古老的统计技术的重新命名的说法有点不一致。

的确，在深度学习课程中，一个 ML 专家可能比一个 CS 本科生有更强的统计学基础。一般来说，信息论需要对数据和概率有很强的理解，我当然会建议任何有兴趣成为数据科学家或机器学习工程师的人培养对统计概念的深刻直觉。但问题仍然是:如果机器学习是统计学的一个分支，那么一个几乎没有统计学背景的人怎么可能对最前沿的 ML 概念有深刻的理解？

还应该承认，许多机器学习算法比大多数神经网络技术需要更强的统计和概率背景，但即使是这些方法也经常被称为 统计机器学习 或统计学习 ，好像是为了将自己与常规的、较少统计的那种区分开来。此外，近年来机器学习领域的大多数炒作创新都是在神经网络领域，所以这一点无关紧要。

当然，机器学习并不是独自生活在一个世界里。同样，在现实世界中，任何希望做很酷的机器学习工作的人可能都在处理各种类型的数据问题，因此也需要对统计学有很强的理解。这并不是说 ML 从不使用或建立统计概念，但这并不意味着它们是一回事。

机器学习=表示+评估+优化

公平地说，对我自己和我的同学来说，我们在算法、计算复杂性、最优化方法、微积分、线性代数，甚至一些概率方面都有很强的基础。我认为，所有这些都比先进的统计学知识与我们正在解决的问题更相关。

机器学习是一类计算算法，它迭代地“学习”某个函数的近似值。华盛顿大学计算机科学教授 Pedro Domingos展示了组成机器学习算法的三个组成部分:表示、评估和优化。

表示包括将输入从一个空间转换到另一个更有用的空间，该空间更容易解释。在卷积神经网络的背景下考虑这一点。原始像素对于区分狗和猫是没有用的，所以我们将它们转换成更有用的表示(例如，来自 softmax 输出的 logits ),它可以被解释和评估。

评价本质上是损失函数。您的算法如何有效地将您的数据转换到更有用的空间？您的 softmax 输出与您的一次性编码标签(分类)有多相似？您是否正确预测了展开的文本序列中的下一个单词(文本 RNN)？你的潜在分布偏离单位高斯(VAE)有多远？这些问题告诉你你的表征功能工作得有多好；更重要的是，它们定义了将学会做什么。

优化是拼图的最后一块。一旦你有了评价组件，你可以优化表示函数 以提高你的 评价指标 。在神经网络中，这通常意味着使用一些随机梯度下降的变体，根据一些定义的损失函数来更新网络的权重和偏差。瞧啊。你有世界上最好的图像分类器(至少，如果你是 2012 年的 Geoffrey Hinton，你有)。

当训练图像分类器时，除了定义适当的损失函数之外，学习的表示函数具有逻辑输出是完全不相关的。借用像逻辑回归这样的统计术语确实给了我们有用的词汇来讨论我们的模型空间，但是它们没有将它们从优化问题重新定义为数据理解问题。

先不说:人工智能这个词很蠢。 人工智能问题只是计算机还不擅长解决的问题。19 世纪， 机械计算器被认为是智能的(链接)。 既然这个术语与深度学习联系如此紧密，我们已经开始说人工通用智能(AGI)来指代任何比高级模式匹配机制更智能的东西。然而，我们甚至还没有对一般智力的一致定义或理解。人工智能这个术语唯一能做的就是激起人们对所谓的“奇点”或类似终结者的杀手机器人的恐惧。我希望我们可以停止使用这样一个空洞的，耸人听闻的术语来指真正的技术。

深度学习的技术

进一步挑战深度学习的据称统计性质的是，嗯，深度神经网络的几乎所有内部工作方式。当然，全连接节点由权重和偏差组成，但卷积层呢？整流器激活？批量正常化？残留层？退学？记忆和注意力机制？

这些创新是高性能深度网络发展的核心，但它们与传统的统计技术相去甚远(可能因为它们根本不是统计技术)。如果你不相信我，试着告诉一个统计学家你的模型过度拟合，并问他们是否认为随机丢弃你的模型的 1 亿个参数中的一半是个好主意。

我们甚至不要谈论模型的可解释性。

回归超过 1 亿个变量——没问题？

让我也从规模上指出深网和传统统计模型的区别。深度神经网络是巨大的。例如，VGG-16 通信网络架构有大约 1.38 亿个参数。你认为你的普通学术顾问会如何回应一个想要对超过 1 亿个变量进行多元回归的学生？这个想法很可笑。这是因为训练 VGG-16 不是多元回归——而是机器学习。

新领域

在过去的几年里，你可能已经在没完没了的论文、帖子和文章中宣扬机器学习现在可以做的很酷的事情，所以我不会在这上面花太多时间。然而，我要提醒你，深度学习不仅比以前的技术更好，它还使我们能够解决一种全新的问题**。**

在 2012 年之前，涉及非结构化和半结构化数据的问题充其量是一个挑战。可训练的 CNN 和 LSTMs 在这方面是一个巨大的飞跃。这在计算机视觉、自然语言处理、语音转录等领域取得了相当大的进展，并使人脸识别、自动驾驶汽车和对话式人工智能等技术取得了巨大进步。

诚然，大多数机器学习算法最终都涉及到将模型拟合到数据中——从这个角度来看，这是一个统计过程。同样真实的是，航天飞机最终只是一架带翅膀的飞行器，然而我们并没有看到模因嘲笑围绕美国宇航局 20 世纪太空探索的兴奋，将其作为飞机的过度宣传。

与太空探索一样，深度学习的出现并没有解决世界上所有的问题。在许多领域，尤其是在“人工智能”领域，仍有重大差距需要克服。也就是说，它对我们解决复杂的非结构化数据问题的能力做出了重大贡献。机器学习继续代表着世界技术进步和创新的前沿。它不仅仅是墙上的一个裂缝和一个闪亮的新框架。

编辑:

许多人将这篇文章解读为对统计学领域的 diss，或者是对我自己对机器学习的肤浅理解的背叛。回想起来，我后悔把这么多注意力放在 ML 和统计学的不同上，而不是放在我的中心观点上:机器学习不全是炒作。

让我说清楚:统计学和机器学习无论如何都不是不相关的。机器学习完全利用并建立在统计学的概念之上，统计学家在他们的工作中正确地利用机器学习技术。这两个领域之间的区别并不重要，这也是我不应该如此关注的。最近一直在关注贝叶斯神经网络的想法。 BNNs 涉及在给定一些先验信念的情况下逼近神经网络参数的概率分布。这些技术给出了不确定性量化的原则方法，并产生更好的正则化预测。

在研究这些问题时，如果我说我不是在“做统计”，那我就是个白痴，我也不会这么做。这两个领域并不相互排斥，但这并不意味着它们是相同的，当然也不意味着它们没有实质内容或价值。一位数学家可以指着一位研究量子场论的理论物理学家，正确地说她在做数学，但如果这位数学家断言她的物理领域实际上只不过是被过度炒作的数学，她可能会提出异议。

计算科学也是如此:你可能会指着手指说“他们在做统计”，而“他们”可能会同意。统计在机器学习研究中非常重要，许多统计学家处于这项工作的前沿。但是 ML 已经开发了 1 亿个参数的神经网络，具有残差连接和批量标准化、现代激活、退出和许多其他技术，这些技术导致了几个领域的进步，特别是在顺序决策和计算感知方面。它发现并利用了令人难以置信的高效优化算法，利用自动微分和并行运行在令人眼花缭乱的快速和廉价的 GPU 技术。多亏了高级的、优雅简单的张量操作软件，所有这些对任何有基本编程能力的人来说都是可及的。“哦，人工智能只是逻辑回归”有点低估了，你不觉得吗？

如果你像我一样，喜欢与机器学习爱好者们交流，请关注我的 Twitter 和/或LinkedIn。如果你想找 ML 咨询工作，直接联系josephddavison@gmail.com。

没人想要你的神经网络

原文：https://towardsdatascience.com/no-one-wants-your-neural-network-a94b98951310?source=collection_archive---------16-----------------------

没有人想要机器学习模型或统计模型。他们希望坏账损失更少，或者他们希望有更多的客户。也许他们想浪费更少的钱付钱给那些做无聊苦工的人。他们会接受你的模型，如果这意味着其中一件事会发生，但这并不意味着他们想要它。

在我成为一名数据科学家之前，我在一家制造电力电缆的公司工作——一束束(通常)包着绝缘材料的铜线，绝缘层上通常还有保护材料。没人想要那些电缆。它们很重，很难移动，所以弄清楚如何运输和储存它们是一件麻烦事。安装它们是一件麻烦事，让它们远离伤害也是一件麻烦事——它们不喜欢阳光，不喜欢水，不喜欢白蚁，这很可惜，因为它们通常被埋在有水和白蚁的地方。

人们不想要这些电缆——他们希望他们的矿井设备能够工作，他们的工厂能够有可靠的电力供应，万一发生火灾，灯光能够保持，这样他们就可以撤离大楼。令人难忘的是，我们被告知一位政治家想要结束他首都的停电，以避免被赶下台。对所有这些人来说，在他们的问题解决之前，电缆是没有用的。

电力电缆是有形的，易于理解，并且具有很高的报废价值，这些都不是数据科学产品的真实情况，它们的购买者仍然不真正想要它们。

你的客户不想要你的产品——他们想要你消除他们生活中的障碍，让他们与家人和朋友共度时光更加轻松愉快。没有人想要捕鼠器——他们只是讨厌在存放食物的橱柜里发现老鼠粪便。那么你的神经网络是如何做到的呢？

如果你的模型和他们真正的目标之间有很强的联系，它就能帮他们做到。你的神经网络可以帮助贷款人减少损失，如果这是对他们用来识别未来坏账的方法的改进。如果它比人类更快更准确地检测到问题，或者如果它可以在事故发生前预测事故，它就可以帮助提高安全性。

难就难在这些东西都不能用现有的评估方法来恰当地衡量。知道 AUC 或 RMSE 有所改善并不能告诉你是否会发现更多的坏账。

因此，数据科学的真正价值必须发生在模型停止和客户问题开始之间。一个糟糕的模型在被熟练使用时可以成功，而一个伟大的模型在不被熟练使用时可能会失败。

除了使用它的技巧之外，关键的决定因素是模型的目标与客户的目标有多匹配。这个因素比算法产生准确结果的能力更重要，是至关重要的因素。对数据科学家来说至关重要的一点是，在学习新算法的每一分钟里，你都应该花一个小时来研究客户的问题。

罗伯特德格拉夫的最后一个媒体故事是 用 SQL 汇总数据

他还是即将出版的《管理您的数据科学项目 》一书的作者

在推特上关注他:https://twitter.com/RobertdeGraaf2

没人理解我…但很快，人工智能可能会

原文：https://towardsdatascience.com/nobody-understands-me-but-soon-artificial-intelligence-just-might-440f771c2024?source=collection_archive---------22-----------------------

H.A.L 9000，天网，还有来自瓦力的邪恶方向盘。

《2001:太空漫游》中的邪恶 ai、终结者以及深受喜爱的儿童电影瓦力无疑是我们这个时代对人工智能最可怕的描述。

事实上，人工智能正在推动世界发生一些巨大的积极变化；根据对话诊断疾病，预测疾病爆发，甚至写书。

然而，一个全能的有感知能力的人工智能消灭所有人类的想法实际上是世界上许多聪明人的担忧——像埃隆·马斯克这样的亿万富翁创新者已经投入了金钱和资源，以确保我们在未来通过 OpenAI 这样的项目拥有友好的人工智能。

当然，这一切都说明了一个潜在的问题:作为人类，我们害怕我们不了解的东西。结果，我们不信任它。人们不信任 AI，所以在情感上无法与之产生联系。更重要的是，如果 AI 不能识别我们的情绪，就会阻碍我们的交流和进步。这可能会有问题*:*

如果一个病人不舒服地告诉机器他们感觉到的症状，它就不能诊断她。
如果一个消费者对人工智能客户服务越来越失望，而系统没有相应地调整，企业可能会遭受损失。
如果一个客户端正在与一个人工智能讨论一个敏感问题，它拉着一个 Alexa 并开始随机大笑，这可能会造成一个问题。

底线是，人工智能将需要能够理解我们的意思，即使我们并不完全清楚，特别是在零售和医疗领域。

人类和人工智能共存的未来是不可避免的，因此改善与越来越智能的机器的通信是必要的，那么我们如何使这种转变更容易呢？

简单。我们教人工智能移情。

如果我们能学会换位思考，人工智能也能。

首先，理解几个定义很重要:

人工智能描述了能够适应新信息并执行人类能做的各种任务的计算机系统，建立在它已经知道的事情上。

**网飞和 Spotify 利用这样的算法，根据你的观看或收听习惯，筛选出你最喜欢的内容类型。来自麻省理工学院的科学家开发了人工智能，可以根据 MRI 扫描诊断肿瘤。

IBM 的沃森是一个著名的会下棋、分析网络攻击风险、甚至会驾驶汽车的人——沃森甚至在 2011 年的《危险边缘》中赢得了 100 万美元，这让 14 岁的沃森比我更令人印象深刻。

Watson at age 8 vs. Me at age 14. That’s a paper-mâché leg of lamb by the way.

然而，你并不会在对话中真正与这种 AI 互动:它只执行非常具体的任务，也被称为狭义 AI 。

通用人工智能就像是人工智能的最终目标，它构成了一个可以执行人类可以执行的相同任务的人工智能——我们还没有达到那一步，但像 DeepMind 和人脑项目这样的项目正在努力让我们更近一步。

像谷歌助手和 Siri 这样的人工助手非常有用，有一些非常酷的功能，但它们仍然不能真正告诉我们的感觉。为了真正与我们口袋里和我们周围的人工智能联系起来，我们必须从人工助理转移到人工伴侣。那么，我们该怎么教他们呢？

答案是机器学习。**

机器学习 (ML) 是人工智能的一个分支，涉及训练系统通过寻找和识别模式从大量数据中学习。人们相信，制造更智能机器的人工智能技术可能会带来真正的人工智能。为了更深入地了解机器学习，请查看这些文章这里和这里！

移情:好吧，这就是事情变得有点复杂的地方。移情可以分为两种不同的类型:

情感共鸣包括感受到与他人相同的情感、个人痛苦或对他人的同情。
认知同理心处理的是识别和理解他人情绪的能力，而不一定感觉到它。

如果我们想教会人工智能移情，我们还需要了解人类如何移情。有两种理论可以解释这一点:

模拟理论提出，我们试图重现我们在他人身上看到的情绪，以便理解他们，这一想法得到了“镜像神经元”的发现的支持，当我们观察和体验情绪时，镜像神经元会激活。(也许这就是为什么当其他人撞到我们时加拿大人会说对不起？)
心理理论认为我们的移情是基于我们通过经验了解到的东西来解释其他人可能的感受。

这是一场分裂科学界的辩论。然而，对于我们的目的来说，哪个是对的并不重要。人工神经网络受到大脑的启发；同样，通过使用机器学习来应用这些理论背后的主要思想来教会我们的人工智能移情，我们可能会弥合人类和人工智能之间的差距。**

我们的脸和声音可以被分析出情绪。

正如我提到的，仿生学，或者说在我们创造的事物中模仿自然设计，对于在人工智能中重现这种人类倾向是至关重要的。我们的最终目标是人工共情，它(至少目前)描述了机器识别和响应人类情感的能力。

与此相一致，让我们关注认知移情，那种涉及识别和理解情感的移情。大多数试图这样做的人工智能使用:

情感识别
色彩映射
声音模式分析

情感识别

遇见盖尔·加朵*。(她其实是神奇女侠，但是不要告诉任何人)。像大多数人一样，我们可以根据她的面部表情来猜测她的感受:*

😢 and 😃 and 😠

你用你的眼睛去看她的脸，然后你的大脑试着去理解她现在的情绪。但是如果更经验性地分析，你的眼睛只是接收视觉信息，在你的视觉皮层进行处理，并将其与你海马体中的记忆联系起来。

这是一个可以使用机器学习技术复制的过程，以创建计算机视觉*，具体来说就是**情感识别(*或面部编码)。

计算机视觉描述的是使用摄像头输入的视觉数据，并通过机器学习技术，学习以算法识别视觉模式的机器。(把摄像头想象成“眼睛”，把算法想象成“大脑”)。

这可以通过在照片的小“块”中找到像素 RGB 值和对比度的不同模式和排列来实现，这些小“块”由过滤它们的被称为内核的神经网络中的小函数或“神经元”来识别；该算法然后将这些组块编译成更大的模式。

Microsoft’s Face API determining with 100% certainty that Gal Gadot is happy.

*在**情绪识别的情况下，*这些模式可以是微笑、皱眉、皱起的眉头，甚至是你的鼻子，它们被编译成与情绪相关的面部表情。 Affectiva 是一家已经在使用深度学习算法通过计算机视觉绘制和识别情绪的公司。微软 Azure 的 Face API 可以识别和分类图像和视频中的情绪，为开发者打开了一个新的可能性世界。

颜色变换

这还没有结束:俄亥俄州立大学的研究人员今年进行了一项研究，表明人类可以根据血液流向不同部位引起的面部微妙颜色来确定他人的情绪。

他们通过根据人眼的视觉方式将图像分成两个不同的颜色通道，发现每种情绪都有自己独特的颜色模式，从而找到了这一点。

然后，他们开发了人工智能算法，可以根据这些颜色模式检测情绪，准确率高达 90%。他们已经将其技术推向市场，为企业提供有意义的解决方案。

声音模式分析

实现人工移情的最有希望的途径之一是通过声音模式分析。以类似于计算机视觉和理解现代艺术的方式(原则上)，它涉及到把复杂的东西分解成简单的模式，然后找到趋势。说到声音模式，它们可以由以下部分组成:

***音高，*可以量化为以赫兹(Hz)为单位的频率，或每秒的声音周期。我们经常把它与音符联系在一起，但它也出现在言语中。
音量描述了我们如何感知声压从安静到大声。声压级以分贝(dB)为单位测量某种声音的压力(与大气标准的偏差)。
音色处理声音的质量，允许我们区分小号和萨克斯管的声音，即使它们以相同的音高和响度演奏。
语气描述了我们如何在语言中使用音高来赋予某些词语强调、* **情感、*等语义

节奏、速度和速率也是标识符，仅举几例。通过使用机器学习和语音记录数据，人工智能可以测量并找到这些品质的模式——例如每个单词之间的时间间隔、语调或讲话的音量——并将它们与特定的情绪联系起来。最棒的是，这些算法甚至不需要处理正在说的实际单词，只需要分析这个人的声音模式。

应用程序是无止境的；精神病学家正在使用声音模式分析软件来帮助他们诊断创伤后应激障碍、双相情感障碍和抑郁症。(与许多心理障碍相关的声音生物标记有时可能人耳听不到，但很容易被机器拾取，例如短声音裂缝或震动。)

人工移情会让生活变得更好。

人工智能正以前所未有的速度发展，它正进入我们生活的方方面面，从我们的通信到我们的医疗保健。但如果我们希望实现真正的人工智能，我们需要能够与它无缝互动；这需要人工智能能够识别我们的感受。实现人工共情为改善我们的生活打开了更好、更有用的工具之门:

***人工智能辅助的精神疾病诊断和治疗:*正如我前面提到的，麻省理工学院的研究人员开发了一种模型，利用声音模式分析来识别患者的抑郁症；它的准确率高达 77%。
未来可能包括手机应用程序，它可以从你的声音中检测出精神疾病的迹象； 每天记录语音日志可以让你知道自己是否处于危险之中。
2015 年，纽约大学的研究人员开发了一种 ML 模型，可以识别人们的 PTSD，准确率也达到 77%。他们目前正在收集更多的数据，以进一步提高识别与 PTSD 和创伤性脑损伤相关的声音模式的准确性。
*梅奥诊所在 超越口头 **应用的帮助下，*使用 ML 来识别与高风险或冠状动脉疾病相关的声音生物标记，其中一些只能通过软件提取。
Cogito 是一家公司，其软件可以检测呼叫中心代理人声音中的疲劳以及客户的情绪反应。它可以识别停顿……(尴尬的沉默)……和其他声音特征，帮助代理成为更具同理心的联系点。
假设有人被枪指着从自动取款机里取钱。如果自动取款机的摄像头和软件也能识别出那个人脸上的恐惧并通知当局会怎么样？情绪识别有可能极大地提高我们的安全性。
***使用 CV 情感识别可以提高营销效率。*通过分析客户对不同营销活动的情绪反应，公司可以专注于有效的策略，并相应地分配预算。

同理心是我们最常见也是最重要的互动和关系的基础。你的家庭医生，你的伴侣，甚至是令人愤怒的不可抗拒的 YouTube 广告——他们都在试图理解你的感受和你想要的，而同理心让这些联系更有价值。

未来将会看到人工智能无处不在，几乎在你的每一次日常互动中。通过教会它识别情绪并做出反应，我们为人类和人工智能能够无缝沟通的未来铺平了道路。这不仅会增加我们和机器之间的共鸣，也会增加彼此之间的共鸣。

关键要点

人工共情描述了人工智能系统识别和响应人类情感的能力。
这将是创造一个不可避免的未来的关键，在这个未来，人和人工智能必须无缝和直观地互动。
*使用机器学习， AI 可以学习**识别面部表情、面部微妙的颜色变化以及声音中的生物标记，*这些都与不同的表情相关联。
这些过程分别称为 、情感识别、色彩映射、 和 、语音模式分析、 。
利用计算机视觉和声音模式分析的这种结合，研究人员正在为我们所有人的更有同情心的未来铺平道路。

感谢你坚持到最后，我希望你喜欢我的第一篇文章！

在做一些研究的时候，我发现了这个对 Danielle Krettek 的采访，她是谷歌移情实验室的创始人和负责人，在采访中，她说为了教会我们的人工智能移情:

“这些机器需要全面了解这个世界，这意味着让它们接触故事讲述者、哲学家、艺术家、诗人、设计师和电影制作人。”

我的问题是:

如果你只能选择一部电影或一本书展示给一个人工智能系统，而它所知道的关于人类和我们世界的一切都基于这一部媒体作品，你会选择哪一部？

我很想听听你的想法！请随时在 LinkedIn 上联系我，或者在 Medium 上关注我，我很乐意谈论人工智能的未来，创新和技术的世界，甚至可能是我们最喜欢的漫威电影。

node2vec:图形数据的嵌入

原文：https://towardsdatascience.com/node2vec-embeddings-for-graph-data-32a866340fef?source=collection_archive---------1-----------------------

Hotlinks :
原文: node2vec:面向网络的可扩展特征学习，Aditya Grover 和 Jure Leskovec
算法实现—由我: Github repo — Python3
算法实现—由 algo 作者: Github repo(由 Aditya Grover)—python 2
Showcase 代码: https://github.com/eliorc

动机

嵌入…这个词每个数据科学家都听过，但大多是在 NLP 的上下文中。那么，我们为什么还要费心去嵌入东西呢？
在我看来，创建质量嵌入并将其输入模型，与那句名言“垃圾进，垃圾出”正好相反。
当你把低质量的数据输入到你的模型中时，你就把学习的全部负荷放在了你的模型上，因为它必须学习所有能从数据中得出的必要结论。
相反，当您使用质量嵌入时，您已经在数据中加入了一些知识，从而使模型学习问题的任务变得更加容易。
还有一点要思考的是信息 vs 领域知识。例如，让我们考虑单词嵌入(word2vec)和单词包表示。
虽然两者都可以拥有关于哪些单词在句子中的全部信息，但是单词嵌入还包括领域知识比如单词之间的关系等等。
在这篇文章中，我将谈论一种叫做 node2vec 的技术，它旨在为图中的节点创建嵌入(在 G(V，E，W)这个词的意义上)。

我将解释它是如何工作的，最后提供我自己的Python 3 的实现，还有一些额外的东西。

嵌入过程

那么是怎么做的呢？
嵌入本身的学习方式与 word2vec 的嵌入学习方式相同——使用 skip-gram 模型。
如果你熟悉 word2vec skip-gram 模型，很好，如果不熟悉，我推荐这篇很棒的文章，它详细解释了这个模型，从现在开始，我假设你对它很熟悉。

我能想到的解释 node2vec 的最自然的方式是解释 node2vec 如何生成“语料库”——如果我们理解 word2vec，我们就已经知道如何嵌入语料库。

那么我们如何从图中生成这个语料库呢？这正是 node2vec 的创新之处，它以一种智能的方式做到了这一点，这是使用采样策略完成的。

为了从输入图中生成我们的语料库，让我们把一个语料库看作一组有向无环图，最大出度为 1。如果我们考虑一下，这是一个文本句子的完美表现，句子中的每个单词都是一个节点，它指向句子中的下一个单词。

Sentence in a graph representation

通过这种方式，我们可以看到 word2vec 已经可以嵌入图形了，但是是非常特定类型的图形。
然而，大多数图形并没有那么简单，它们可以是(不)定向的，(不)加权的，(循环的)并且在结构上基本上比文本复杂得多。

为了解决这个问题，node2vec 使用一个可调整的(通过超参数)采样策略来采样这些有向无环子图。这是通过从图的每个节点生成随机行走来完成的。很简单，对吧？

在我们深入研究采样策略如何使用超参数来生成这些子图之前，让我们来看一下这个过程:

Node2vec embedding process

抽样策略

现在我们已经有了大致的了解，是时候深入了解了。
Node2vec 的采样策略，接受 4 个参数:
— 步数:从图中的每个节点生成的随机步数
— 步长:每次随机步中有多少个节点
— P :返回超参数
— Q : Inout 超参数
以及标准的 skip-gram 参数(上下文窗口大小、迭代次数等)。)

前两个超参数非常简单明了。
随机漫步生成算法将遍历图中的每个节点，并将生成< 漫步数量 >随机漫步，长度< 漫步长度 >。
Q 和 P ，用可视化更好解释。
假设你正在随机行走，刚刚从节点< t >过渡到下图中的节点<v>(摘自文章)。

从< v >过渡到他的任何一个邻居的概率是
< 边权重>*<α>(归一化)，其中< α >取决于超参数。
P 控制访问< v >后回到< t >的概率。
Q 控制着探索图表中未被发现部分的概率。
直观地说，这有点像 tSNE 中的困惑参数，它允许你强调图形的局部/全局结构。
不要忘记重量也被考虑在内，所以最终的出行概率是:
1 的函数。行走中的上一个节点
2。p 和 Q
3。边缘重量****

理解这一部分很重要，因为它是 node2vec 的本质。如果你没有完全理解抽样策略背后的思想，我强烈建议你再读一遍这部分。

使用采样策略，node2vec 将生成“句子”(有向子图)，这些句子将用于嵌入，就像 word2vec 中使用的文本句子一样。如果工作正常，为什么要改变呢？

代码(展示)

现在是将 node2vec 付诸行动的时候了。你可以在这里找到 node2vec 测试的完整代码。
我使用 node2vec 算法的实现作为例子，它增加了对分配节点特定参数(q，p，num_walks 和 walk length)的支持。

我们要做的是，利用欧洲足球队的形成，嵌入 7 个不同俱乐部的球队，球员和位置。
我将要使用的数据来自 Kaggle 上的 FIFA 17 数据集。
在 FIFA(eas sports)中，每支球队都可以用一个图形来表示，见下图。

Formation example from FIFA17, easily interpreted as a graph

正如我们所看到的，每个位置都与其他位置相连，并且在玩游戏时，每个位置都被分配了一个玩家。
这里有几十种不同的地层，它们之间的连通性各不相同。还有一些类型的位置在一些地层中存在，但在其他地层中不存在，例如“LM”位置在这个地层中不存在，但在其他地层中存在。

这就是我们将要做的事情。节点将是球员，球队名称和位置
2。对于每个团队，创建一个单独的图，其中每个球员节点连接到他的团队名称节点，连接到他的队友节点，并连接到他的队友位置节点。
3。将 node2vec 应用到结果图中

*注意:为了给团队内部和团队之间的每个位置创建单独的节点，我给相似的节点添加了后缀，并且在 walk 生成之后我已经删除了它们。这是一个技术问题，检查回购中的代码以便更好地理解

输入数据的第一行如下所示(经过一些排列):

Sample rows from the input data

然后，我们使用 FIFA17 格式构建图表。
使用我的 node2vec 包，图必须是networkx.Graph的一个实例。
检查图边之后，我们将得到以下结果

**for edge in graph.edges:
    print(edge)>>> ('james_rodriguez', 'real_madrid')
>>> ('james_rodriguez', 'cm_1_real_madrid')
>>> ('james_rodriguez', 'toni_kroos')
>>> ('james_rodriguez', 'cm_2_real_madrid')
>>> ('james_rodriguez', 'luka_modric')
>>> ('lw_real_madrid', 'cm_1_real_madrid')
>>> ('lw_real_madrid', 'lb_real_madrid')
>>> ('lw_real_madrid', 'toni_kroos')
>>> ('lw_real_madrid', 'marcelo')
...**

正如我们所看到的，每个球员都根据阵型与他的球队、位置和队友联系在一起。
所有附加在位置上的后缀将在走步计算后返回到它们原来的字符串(lw_real_madrid → lw)。

现在我们有了图，我们执行 node2vec

**# pip install node2vecfrom node2vec import Node2Vec# Generate walks
node2vec = Node2Vec(graph, dimensions=20, walk_length=16, num_walks=100)# Reformat position nodes
fix_formatted_positions = lambda x: x.split('_')[0] if x in formatted_positions else xreformatted_walks = [list(map(fix_formatted_positions, walk)) for walk in node2vec.walks]node2vec.walks = reformatted_walks# Learn embeddings 
model = node2vec.fit(window=10, min_count=1)**

我们给node2vec.Node2Vec一个networkx.Graph实例，在使用.fit()(它接受任何我们得到的参数gensim.models.Word2Vec)后，我们得到一个gensim.models.Word2Vec实例。

首先，我们将检查不同节点之间的相似性。
我们期望与一个团队最相似的节点，会是它的队友:

**for node, _ in model.most_similar('real_madrid'):
    print(node)>>> james_rodriguez
>>> luka_modric
>>> marcelo
>>> karim_benzema
>>> cristiano_ronaldo
>>> pepe
>>> gareth_bale
>>> sergio_ramos
>>> carvajal
>>> toni_kroos**

对于不熟悉欧洲足球的人来说，这些确实都是皇马的球员！

接下来，我们检查与特定位置的相似性。我们希望球员们踢那个位置，或者更糟糕的是接近那个位置

**# Right Wingers
for node, _ in model.most_similar('rw'):
    # Show only players
    if len(node) > 3:
        print(node)>>> pedro
>>> jose_callejon
>>> raheem_sterling
>>> henrikh_mkhitaryan
>>> gareth_bale
>>> dries_mertens# Goal keepers
for node, _ in model.most_similar('gk'):
    # Show only players
    if len(node) > 3:
        print(node)>>> thibaut_courtois
>>> gianluigi_buffon
>>> keylor_navas
>>> azpilicueta
>>> manuel_neuer**

在第一次尝试中(右边锋)，我们确实从不同的俱乐部得到了不同的右边锋，再次完美的匹配。
然而在第二次尝试中，我们得到了除 Azpilicueta 之外的所有守门员，Azpilicueta 实际上是一名后卫——这可能是因为守门员与球队没有太多联系，通常只与中后卫有联系。

效果很好，对吧？在我们结束之前，让我们使用 tSNE 来降低维度并可视化玩家节点。

Visualization of player nodes (tSNE reduced dimensionality)

看看吧，我们根据不同的俱乐部得到了漂亮的聚类。

最后的话

图形数据几乎无处不在，如果没有，通常可以放在图形上，但 node2vec 算法还不太流行。
该算法还通过其超参数赋予了极大的灵活性，因此您可以决定您希望嵌入哪种信息，并且如果您可以选择自己构建图表(并且不是给定的),您的选择是无限的。
希望你会在这篇文章中找到用处，并为你的机器学习武器库增加一个新工具。

如果有人想为我的 node2vec 实现做贡献，请联系我。

噪音不是数据的敌人。噪音就是数据。

原文：https://towardsdatascience.com/noise-is-not-an-enemy-of-data-noise-is-data-196b6671a748?source=collection_archive---------4-----------------------

在分析数据时，有三个组成部分。

首先，这是现实——这是数据的来源。

第二，有数据，这是通过数据收集过程过滤的现实的点滴。数据是数据的子集，但不是全部。

第三，有一个模型，它可以从第一原理推导出，也可以从手头的数据归纳出。这就是我们认为现实看起来的样子，一般来说，这是不完整的。

模型偏离现实有两个阶段。我们称之为噪声的地方通常出现在第二阶段，即模型与数据相匹配的阶段。根据定义，噪声是指数据与模型不匹配的地方。一方面，大量的噪音确实意味着模型不能很好地与数据形式的现实相匹配，就我们所知，模型不是很好，不应该理所当然地认为是现实的反映。换句话说，你看到的价格并不是真实价值的真实反映，你可能要讨价还价，可以这么说。但是，与此同时，除了在统计学的便利假设中，噪声很少是真正随机的。它代表了你的模型可以改进的地方，即使是在数据这一小块现实中。虽然产生大量噪音的模型本身不一定是一件好事，尤其是如果你的目标是依靠模型来“商品化”信息(告诉你什么是合适的价格，而不是说你需要在某些事情上讨价还价)，但有时没有明显的“合适的价格”，你必须讨价还价，如果是这样，你不妨知道情况是怎样的——理解噪音中的模式，即使它们没有直接指向你想知道的东西，也只能有助于启发，即使是在你可能没有预料到的方向上。

这是在你处理理论可能偏离现实的第一阶段之前:数据生成和数据收集过程很少是一对一的过程。简单的、可预测的和常规的数据比复杂的、杂乱的和奇怪的数据更容易获得，如果仅仅从数据可用性的本质来看的话。不幸的是，在将模型与数据进行匹配时，针对噪声的偏差只会增加采样偏差。由于除了在极少数情况下，奇怪的数据很少对形成结果至关重要，所以评估样本选择中奇怪现象的影响并不容易，除非当它们发生时，会产生严重的后果(金融崩溃等)。在分析过程中，需要记住这一点。

噪声，被定义为数据，甚至现实，偏离模型的情况，不是浪费。这就是所有潜在的未来洞察力、成长和学习的机会所在。是的，从长远来看，你确实想减少噪音——因为这是你正在学习的标志，但是，你应该带着尊重和认真对待它。有时，您甚至可能想要放大噪声，故意对数据的杂乱部分进行过采样，以便您可以更深入地研究它，至少在中短期内是这样。

无人驾驶汽车转向的非人工智能方法

原文：https://towardsdatascience.com/non-ai-approach-for-steering-self-driving-car-e841658ee695?source=collection_archive---------3-----------------------

Udacity 无人驾驶汽车纳米学位项目第二学期的最后一个项目是使用控制理论的概念在模拟器中控制汽车。

目前有三种控制自动驾驶汽车转向的方法:

人工智能方法(看看我在之前写的基于行为克隆和深度神经网络的解决方案)
非人工智能方法(使用控制理论和数学计算转向角度)
以上两者的组合

在本帖中，我们将讨论第二个问题。在控制理论中，可以应用在自动驾驶汽车上进行转向的方法之一叫做 PID 控制器 ( P 比例 I 积分 D 微分控制器)。维基百科将 PID 控制器定义为:

工业控制系统中常用的一种控制回路反馈机制。PID 控制器连续计算误差值 e(t) 作为所需设定值和测量过程变量之间的差值，并进行校正。

在现实世界中，PID 控制器被用于从自主船舶驾驶到无人机自动驾驶。事实证明，在他们的 openpilot 项目中， comma.ai 实际上也使用了这种方法的变体。

但是 PID 到底是什么呢？

PID 控制器的工作原理其实很简单。在下面的框图中，我们可以将 r(t) 视为车道中的期望位置，该位置来自我们的定位和路径规划系统。使用传感器测量车道中的位置(地面实况)，并用 y(t) 表示。误差值 e(t) 将是 r(t) 和 y(t) 之间的差值。

PID 控制器试图通过应用调整或控制变量 u(t) (在我们的例子中，这是转向角)来最小化误差率 e(t) 。

u(t) 的校正值由比例、积分和微分系数定义。

Source: Wikipedia

u(t) 的修正值可以正式表示为:

Source: Wikipedia

PID 反馈机制

让我们更详细地看看 PID 控制器的不同反馈元件。

比例反馈——我们需要做的调整的速率与错误率 e(t) 成比例。天真的想法会让你问我们是否还需要什么，对吗？我们需要做的就是将转向角设置成与计算误差成比例，我们就完成了！不幸的是，这并不容易。这个部件没有考虑质量和惯性。仅在我们的控制器中使用该组件将导致所谓的过冲。这里需要记住的重要一点是，该分量代表当前(当前)误码率对系统的增益(影响)。它不考虑误差值的过去和未来的变化。
积分反馈——随着时间的推移而增加，涵盖了误差值太小且比例反馈难以检测到的情况。它看过去，日积月累。如果它被用作 PID 控制器中的单个元件，它对减小误差值的作用也非常缓慢。
导数控制器——能够预测误差值，从而预测系统的未来状态。

有相当多的视频解释 PID 控制器，但我个人喜欢这个:

当谈到我的项目中的 PID 反馈系数时，我是手动选择的。有一种称为旋转的特殊方法，可以自动为 PID 控制器寻找正确的参数。

最后结局

该项目的源代码可以在我的 Github repo 中找到:

[## bdjukic/CarND-PID-控制-项目

在 GitHub 上创建一个帐户，为 CarND-PID-Control 项目的开发做出贡献。

github.com](https://github.com/bdjukic/CarND-PID-Control-Project)

非标准、弱监督分类问题

原文：https://towardsdatascience.com/non-standard-weakly-supervised-classification-problems-51b23211d4bc?source=collection_archive---------6-----------------------

传统的监督学习(又名。分类)，假设分类问题的完全标记的训练集。

然而，在许多设置中，由于成本、专家的有限知识、传感器或数据收集器的有限灵敏度等等，我们可能没有完全监督的分类问题定义。在这些情况下，弱监督解决方案可能适用。

这意味着我们需要推广分类问题的定义。要考虑的第一个扩展是关于实例-标签关系:最简单的分类问题假设一对一的实例-标签分类。这意味着(训练集中的)每个实例都映射到一个标签。然而，一般的设置是 N 对 N 的情况:每个实例可以有许多标签，或者实例包可以共享同一个标签(多实例学习，参见 Dietterich 等人的工作)。

那么，一般来说，分类问题可能是多实例、多标签的。这为定义机器学习中的弱监督铺平了道路。弱点可以应用于两个级别:学习级别和预测级别。

学习监督不力

我们可以定义不同的弱监管模型，在例子中提供不同水平的信息。

半监督分类:这是最简单也是最常见的情况，数据集的一部分被标记，而另一部分没有被标记。
候选标签:我给每个实例分配更多的标签，标签是在一组标签中选择的。所以问题是要找到其中哪个才是正确的标签。
概率标签:每个标签以给定的概率分配给每个实例。
不完整的类别分配:每个候选人仅被分配了所有标签的部分列表。
人群注释:我有一套非专业人士给我贴的标签，我不能相信他们，因为他们太吵了。
标签约束:我知道一包实例属于同一个标签，但不知道那是哪一个。
标签比例:我知道一组实例中标签的比例，但是我们不知道每个标签具体给了哪些实例。这方面的一个例子是，您已经标记了关于部分已知医疗设置的数据。例如，在人工授精中，你知道有多少胚胎被植入女性子宫，以及它们成功的比例，但不知道具体是哪些。

预测监管不力

监管不力也适用于预测。这其实挺不常见的。通常你没有关于预测的监督数据，而在某些特殊情况下，它可能会发生。预测方面的情况包括:

无监督:这是最常见的情况，在预测中没有提供监督
多标签约束
标签比例:我知道要预测的数据比例，比如在垃圾邮件过滤问题上。

尽管没有从完全监管到弱监管的连续范围，但我们可以定义一个分类法:

对于个体分类:半监督包含在候选标签中，候选标签又包含在概率标签中。
对于分组分类:标签比例和相互标签包含在候选标签中。

从标签比例中学习

我们现在深入研究弱监管的一种情况，即从标签比例中学习。

训练集被分成多个存储桶。我们不知道具体实例的标签，除了一些我们知道详细标签的特殊实例。对于其他桶，我们只知道标签比例。

在下图中，我们有两个可能的标签，即红色和绿色。有些桶只有概率而没有标签，而其中两个桶(表中的第二个和第五个)有实际的单独标签样本。

这与聚合匿名化的设置基本相同。不幸的是，这是一个有问题的设置，因为很难分解。

一个可能的解决方案在于将问题转化为概率分类问题:我将桶的概率映射到每个实例的每个标签的概率。

然后，我们可以尝试完成数据，只考虑一致的完成。

然而，这仅适用于小包，因为复杂性是指数级的。当实例包的大小增加时，比方说每个包超过 20 个元素，您就不能使用完整的算法。在这种情况下，您可以使用基于马尔可夫链蒙特卡罗的近似法。它们可以导致与精确解的质量相当的结果质量，并且具有线性复杂度。

包扎

有趣的是，到目前为止，大多数弱监督学习配置还没有被任何研究成果触及。这里有一个表格，显示了所有现有的贡献和仍然需要填写的空白单元格。

那时仍有大量的研究机会。

警告:您可能还希望确保表格中所有缺失的单元格都映射到现实世界中的合理问题。

这个故事的灵感来自 Jose A. Lozano 在法国波城举行的 ACM SAC 2018 大会上的主题演讲。

金融市场的平稳性和记忆性

原文：https://towardsdatascience.com/non-stationarity-and-memory-in-financial-markets-fcef1fe76053?source=collection_archive---------7-----------------------

为什么不应该相信任何平稳性检验，为什么记忆与非平稳性无关。

Artistic impression of a multiverse. Credit: Jaime Salcido / EAGLE Collaboration

平稳性和时间序列的可预测性是时间序列记忆的一个特例，是量化投资过程的基本概念。然而，这些经常被从业者和研究人员误解，正如新书金融机器学习的进展的第五章所证明的。上周在耶鲁大学的会议结束后，我很高兴地与一些出席资产管理中机器学习的兴起的人阐明了这些误解，但我开始认为这个问题如此普遍，值得进行公开讨论。

在这篇文章中，我就金融市场的非平稳性和记忆性提出了一些缺乏文献证明的观点，有些观点违背了计量经济学的正统观点。所有的论点都有逻辑、数学、反例和/或最后用 python 代码做的实验作为支持。

这里提出的论点可以分为实用论点和技术论点:

技术要点:

不可能用在有限时间间隔内观察到的单一路径来检验一个时间序列是否是非平稳的——不管时间间隔有多长。平稳性的每一个统计测试都对潜在过程所属的扩散家族做了额外的假设。因此，零假设拒绝可以表示扩散假设不正确的经验证据，或者扩散假设是正确的但是零假设(例如，单位根的存在)是假的。统计测试本身并不能确定哪种情况成立。
与金融机器学习进展中声称的相反，不存在“平稳性与记忆困境”(一个与另一个无关)，记忆并不意味着偏度或过度峰度。
时间序列的迭代微分并没有使时间序列更加平稳，而是使时间序列更加无记忆；时间序列可以是无记忆的，也可以是非平稳的。
至关重要的是，非平稳但无记忆的时间序列很容易欺骗(单位根)平稳性测试。

记忆的概念和时间序列的可预测性是紧密相关的，我们在我们的黄皮书中讨论了后者。我将借此机会分享我们在时间序列中量化记忆的方法。

实用外卖:

市场(尤其是金融时间序列)是非平稳的，这有着直观的意义，但任何试图从统计学上证明这一点的努力都注定是有缺陷的。
量化投资管理需要平稳性，但不是金融时间序列的平稳性、可交易模式的“平稳性”或持续性或者alpha在(足够长的)时间(地平线)上。

平稳性

简单来说，平稳性就是事物不随时间变化的属性。

量化投资经理需要平稳性

每一项量化投资管理努力的核心都是假设市场中存在过去盛行、将来也会盛行的模式，人们可以利用这些模式在金融市场中赚钱。

在部署资本之前，通常需要成功地寻找这些模式，通常被称为alpha*，并预期它们会随着时间的推移而持续存在。因此，平稳性是量化投资管理固有的一厢情愿的假设。*

金融市场的平稳性是自我毁灭的

然而，阿尔法往往是他们自己成功的受害者。阿尔法越好，随着时间的推移越有可能被竞争对手复制，因此也就越有可能随着时间的推移而消失。因此，每一个预测模式必然是一个暂时的或短暂的制度。该政权将持续多久取决于阿尔法搜索的严格程度，以及对其开发的保密程度。

阿尔法的短暂是有据可查的；例如，我强烈推荐 Igor Tulchinsky 的新书《Unrules: Man，Machines and The Quest to Master Markets》。

关于金融市场高度非平稳的普遍看法，非平稳性通常是指数学意义上的，通常是指金融时间序列。

时间序列平稳性不能用一个有限样本来证伪

在时间序列(又名随机过程)的情况下，平稳性有一个精确的含义(如预期的)；事实上是两个。

当时间序列的所有属性不因时间原点的改变或时间平移而改变时，称该时间序列为强平稳*。当时间序列的均值和自协方差函数不随时间原点或时间平移的变化而变化时，称该时间序列为二阶平稳，或弱平稳。*

直观地说，平稳时间序列是其局部属性随时间保持不变的时间序列。因此，毫不奇怪，在过去几十年中，它一直是计量经济学中的一个关键假设，以至于人们经常认为，从业者应该在进行任何建模之前首先使时间序列平稳，至少在 Box-Jenkins 学派中是这样。

这是荒谬的，原因很简单，(二阶)平稳性，作为一个属性，不能从一个单一的有限样本路径被推翻。是的，你没看错！请继续阅读，了解原因。

但是在深入探讨一个近乎哲学的论点之前，我们先来举一个具体的例子。

Draw of a time series on a uniform grid of 1000 times between t=0 and t=1.

我们来考虑一下上面的情节。这是平稳时间序列的图吗？如果你简单地根据这个情节来回答，你可能会得出结论，它不是。但我相信你已经看出了其中的诀窍，所以你可能想要进行一个所谓的“平稳性测试”，这可能是最广泛使用的测试之一，即 Augmented-Dickey-Fuller 测试。如果你这样做，你会得到以下结果(最后是源代码):

*ADF Statistic: 4.264155
p-Value: 1.000000
Critical Values:
	1%: -3.4370
	5%: -2.8645
	10%: -2.5683*

正如你所看到的，ADF 测试不能拒绝零假设，即时间序列是一个有单位根的 AR，这(某种程度上)证实了你最初的直觉。

现在，如果我告诉你，上面的图是从均值为 100 的高斯过程和自协方差函数中提取的

那么我肯定你会同意这确实是从(强)平稳时间序列中得出的结论。毕竟，它的均值和自协方差函数在时间平移下是不变的。

如果你仍然感到困惑，这里有一个更长时间范围内的相同结论:

Same draw as above but zoomed-out.

我敢肯定你一定在想，它看起来更像你对一个平稳时间序列的期望(例如，它在视觉上是均值回复的)。让我们通过 ADF 测试来确认这一点:

*ADF Statistic: -4.2702
p-Value: 0.0005
Critical Values:
	1%: -3.4440
	5%: -2.8676
	10%: -2.5700*

事实上，我们可以拒绝零假设，即时间序列在 0.05%的 p 值是非平稳的，这给了我们很大的信心。

然而，这两个实验之间的过程并没有改变。事实上，即使使用的随机路径是相同的，两个实验都有足够的点数(至少一千)。那到底怎么了？

直觉上，尽管第一个实验有足够大的样本量*，但它没有跨越足够长的时间间隔来表征潜在的过程，并且我们不可能事先知道这一点！*

要点是，如果不做任何额外的假设，从有限时间间隔内观察到的单一路径来检验时间序列是否平稳是根本不可能的。

有两个假设经常被实践者和研究者忽略，以至于导致错误的结论；一个隐式假设和一个显式假设。

隐含的假设

平稳性是随机过程的特性，而不是路径的特性。试图从单一路径测试平稳性应该隐含地依赖于这样一个假设，即手边的路径对潜在过程的性质提供了足够的信息。正如我们在上面看到的，情况可能不是这样，更重要的是，我们没有办法排除这个假设。因为路径看起来不像均值回复并不意味着底层过程不是静止的。你可能没有观察到足够的数据来描述整个过程。

沿着这条思路，任何金融时间序列，无论是否通过 ADF 检验，总是可以扩展为通过 ADF 检验的时间序列(提示:存在平稳随机过程，其路径空间是普适的)。因为我们不知道未来会发生什么，严格地说，说金融时间序列是非平稳的有点滥用，至少和说金融时间序列是平稳的一样。

在缺乏平稳性证据的情况下，时间序列不应该被假设为非平稳的——我们不能简单地在统计上偏向一个属性而不是另一个。这类似于任何关于二元命题 A 的逻辑推理:没有 A 成立的证据永远不是 A 不成立的证据。

假设金融市场是非平稳的，作为一条公理可能比假设市场由于结构原因是平稳的更有 实际意义。例如，预期生产率、全球人口和全球产出(所有这些都与股票市场相关)会随着时间的推移而增长，这并不遥远。然而，这并不能使更多的具有统计意义，而且这是一个工作假设，我们根本无法根据数据(在日照下)使其无效。**

2.显式假设

平稳性的每一个统计检验都依赖于一个假设，即潜在过程的扩散必须位于扩散的类别中。没有这一点，我们就无法构建用于测试的统计数据。

常用的(单位根)检验通常假设真实的扩散是自回归或 AR 过程，并检验单位根的不存在作为平稳性的代理。

因此，导致拒绝零假设的经验证据可能指向一个事实，即潜在的过程不是 AR，或者它不是静态的，或者两者都是！单元根测试本身不足以排除底层流程可能不是 AR 流程的可能性。

这同样适用于对潜在扩散进行不同假设的其他平稳性测试。没有模型就没有统计假设检验，也没有统计假设检验能够验证它所基于的模型假设。

求平稳阿尔法，不求平稳时间序列

鉴于我们无法在不对时间序列的扩散进行假设的情况下测试时间序列是否平稳，我们面临两种选择:

假设扩散并测试平稳性
学习预测模型，假设或不假设平稳性

由于 Box-Jenkins 方法的影响，前一种方法是计量经济学文献中最常用的方法，而后一种方法更符合机器学习的精神，即从观察值灵活地学习数据生成分布。

为金融市场建模是困难的，非常困难，因为市场是复杂的，几乎是混沌的系统，信噪比非常低。任何正确描述市场动态的尝试——例如试图构建静态转换——作为构建阿尔法的要求，都是勇敢的、违反直觉的、低效的。

阿尔法是市场特征的函数，可以预测绝对或相对的市场变动。要被信任，alpha 应该被期望随着时间的推移而保持不变(即，在宽松的意义上是静止的)。然而，底层过程本身是否是静态的(在数学意义上)完全无关紧要。价值、规模、动量和套利是几十年来有据可查的交易理念的例子，与价格或收益序列的平稳性无关。

但是平稳性已经足够了，让我们继续讨论市场记忆的本质。

记忆

直观上，当一个时间序列的过去值与其未来值相关时，它应该被认为具有记忆性。

为了说明一个关于记忆的常见误解，让我们考虑一个简单但有代表性的例子。在金融机器学习的进展中，作者认为

“大多数经济分析遵循两种范式之一:

Box-Jenkins:回报是固定的，但是没有记忆
Engle-Ganger:对数价格具有记忆性，但是它们是非平稳的，协整是使回归在非平稳时间序列上起作用的技巧[…]”

为了充分利用这两个词，作者建议构建加权移动平均过程

其系数基于具有固定窗口的分数微分的概念来确定，作为对数收益的替代(对数价格的一阶微分)。笔者推荐选择分数微分度最小的 0 < d < 1 for which the moving average time series passes the ADF stationarity test (at a given p-Value).

The whole approach begs a few questions:

Is there really a dilemma between stationarity and memory?
How can we quantify memory in time series so as to confirm whether or not they are memoryless?
Assuming we could find a stationary moving average transformation with a lot of memory, how would that help us generate better alphas?

量化记忆

直观上，很容易看出移动平均过程通过构造表现出记忆性(移动平均的连续观察值必然是相关的，因为它们部分是使用输入时间序列的相同观察值计算的)。然而，并不是每个有记忆的时间序列都是移动平均线。要确定平稳时间序列是否有记忆，应该有一个量化任何时间序列记忆的框架。我们已经在我们的黄皮书中解决了这个问题，下面是一个简要的总结。

指导任何测量时间序列记忆方法的定性问题如下。了解过去能让我们了解未来吗？换句话说，知道到现在为止的所有过去的值是否减少了我们对时间序列的下一个值的不确定性？

随机变量中不确定性的标准度量是它的熵，当它存在的时候。

The entropy of a probability distribution with density function p with respect to a base measure dμ. The entropy of a random variable is that of its probability distribution.

类似地，在观察另一个随机变量后，一个随机变量中留下的不确定性通常由条件熵来度量。

Conditional entropy of y given x.

因此，时间序列中记忆的一个候选度量是关于时间序列的未来值的不确定性减少，这可以通过观察所有过去的值来实现，在无限数量的这种过去的值的极限情况下。我们称之为时间序列自动可预测性的。**

Measure of memory or auto-predictability of a time series.

当它存在时，自动可预测性的度量总是非负的，并且当且仅当时间序列的所有样本在时间上相互独立时为零(即，过去与未来无关，或者时间序列是无记忆的)。

在平稳时间序列的情况下，PR()总是存在的，并且由任何观测的熵与时间序列的熵率之差给出。

Measure of auto-predictability of a stationary time series.

在我们的黄皮书中，我们提出了一种基于最大熵的方法来估计 PR()。下面这个图说明了股票、期货、货币的内存有多大。

Memory in daily returns of currencies, U.S. futures and U.S. stocks.

记忆与平稳性无关

上述讨论的一个直接结果是，时间序列既可以是静态的，也可以有大量的记忆。一个并不排除另一个，事实上，一个仅仅是与另一个相关的 而不是 。

事实上，在平稳高斯过程的情况下，可以表明自动可预测性的测量结果为

Measure of auto-predictability of a stationary Gaussian time series with power spectrum g.

值得注意的是，PR()=0 当且仅当功率谱为常数，即时间序列为平稳高斯白噪声，否则 PR() > 0。平稳的白噪声不会因为它是平稳的而缺乏记忆，它缺乏记忆是因为它是，嗯……一个白噪声！

功率谱越不均匀，时间序列内存越多。自协方差函数越平坦，功率谱越陡峭，因此自可预测性的度量就越高，时间序列的记忆性就越强。这种平坦自协方差函数的一个例子是平方指数协方差函数

在输入长度标度参数 l 趋于无穷大的极限内。

Independent random draws from the same stochastic process, a mean-zero Gaussian process with Squared-Exponential covariance function, with output and input scale 1.

简而言之，不存在平稳性 vs .内存困境。正如 Box-Jenkins 方法所提倡的，实践者头脑中的混乱来自于对迭代微分过程中发生的事情的误解。下一节将详细介绍这一点。

记忆与偏度/峰度无关

关于记忆的另一个误解是“记忆会带来偏斜度和过度峰度”。这也是不对的。如前所述，有可能产生高斯型(因此既不是偏斜的也不是薄态的)、平稳的、具有任意长记忆的时间序列。

迭代微分、平稳性和记忆

迭代微分不会使时间序列更加平稳，它会使时间序列更加无记忆！

在后移运算符的意义上,(离散时间)时间序列的微分非常类似于高中所学的曲线微分。

我们对一条曲线微分得越多，这条曲线就越有可能经历不连续/突变(当然，除非它是无限可微的)。

直觉上，同样地，一个时间序列在后移算子意义上被区分得越多，该时间序列将经历越多的冲击(在随机意义上)，因此其样本将越接近相互独立， 但不一定是同分布的 ！

一旦一个时间序列被微分了足够多的次数，以至于它变得无记忆(即它有相互独立的样本)，它本质上就是一个随机游走， ，尽管不一定是一个平稳的 。我们总是可以构造一个非平稳的时间序列，无论它被微分多少次，永远不会变成平稳的。这里有一个例子:

Example time series cannot be made stationary by iterative differentiation. is the standard Wiener process.

它的一阶微分是完全无记忆的，因为 Wiener 过程的增量是独立的。

它的方差函数 g(t)是时变的，因此是非平稳的。

类似地，对于每个 d>0，的阶-(d+1)微分既是无记忆的，也是非平稳的。具体来说，后续的迭代微分读取

并且它们的时间相关方差函数读作

该表达式对于每个 d 都在 t 中展开，对于任何t都不会在 d 中收敛。换句话说，连续微分不会使方差函数均匀，因此不会使该时间序列更加平稳！

一个随机游走，不管是否平稳，通常都能通过大多数单位根测试！

从业者对迭代微分和平稳性的困惑源于这样一个事实，即大多数单位根检验会得出无记忆时间序列是平稳的结论，尽管事实不一定如此。

让我们以 ADF 测试为例。

Regression model underpinning the Augmented Dickey-Fuller test.

如果一个时间序列{ y }是无记忆的但不是平稳的，支持 ADF 检验的普通最小二乘(OLS)拟合不能产生完美的拟合。OLS 如何用足够大的样本来解释这种偏离？由于时间序列是无记忆的，OLS 通常会找到γ接近 1 的证据，因此 ADF 检验应该拒绝γ=0 的零假设，从而得出时间序列没有单位根(即，是一个平稳的 AR)的结论。{ y }的时变方差通常将通过平稳噪声项{ e }来观察。

为了说明这一点，我们在 0 和 1 之间均匀地随机产生 1000 个随机抽取，并且我们使用这些抽取作为 1000 个独立产生的零均值高斯分布的标准偏差。结果如下图所示。

A non-stationary memoryless time series (left) and its time-varying standard deviation (right).

对该样本进行的 ADF 测试清楚地拒绝了零假设，即该时间序列是从具有单位根的 AR 中提取的，这可以从下面的统计数据中看出。

**ADF Statistic: -34.0381
p-Value: 0.0000
Critical Values:
	1%: -3.4369
	5%: -2.8644
	10%: -2.5683**

在这一点上，从业者经常得出结论，时间序列应该是平稳的，这是不正确的。

如前所述，不是非平稳 AR 的时间序列不一定是平稳的；要么根本不是 AR 时间序列，要么就是平稳的 AR。总的来说，ADF 测试本身并不能确定这两种说法哪一种成立。然而，在这个例子中，我们知道不正确的假设不是非平稳性，而是 AR 假设。

总结想法

媒体对人工智能可能对投资管理行业产生的影响给予了很多关注，一些文章大肆宣传人工智能，警告回溯测试过度拟合的风险，提出金融市场的信噪比排除了人工智能革命的可能性，甚至认为人工智能已经在该行业存在了几十年。

在这些媒体报道中，机器学习通常被认为是一个静态领域，是金融界的外源，是由他人开发的一套通用方法。然而，资产管理行业的特殊性保证了新的机器学习方法的出现，这种方法是从一开始就以金融第一的心态设计的，并对长期以来的教条提出了质疑。这种技术出现的最大障碍之一可能是对简单但基本的概念的广泛误解，如研究过程的核心平稳性和记忆。

附录:代码

渐变视点的规范化[TF 中的手动背景道具]

原文：https://towardsdatascience.com/normalization-in-gradient-s-point-of-view-manual-back-prop-in-tf-2197dfa3497e?source=collection_archive---------5-----------------------

归一化图层对渐变有什么影响？

GIF from this website

归一化是一种预处理技术，它改变了给定分布的属性。尽管顾名思义，批量标准化执行标准化，并且已经表明标准化层加速了深度神经网络的训练。

但这是为什么呢？它是如何改变每个重量的梯度的？其他标准化方案有什么影响？例如层规范化以及实例规范化。

最后，如果归一化的目的是使分布更加对称(或正态)，如果我们执行一个更简单的变换，如 box-cox 变换，会发生什么？

下面是我们将要比较的方法列表。

a)正常 CNN(基线)
b) 批量归一化 c)图层归一化 d)实例归一化

简介

总的来说，我把规范化理解为一种改变给定分布的属性的技术/过程。例如，标准化的最基本用法是将分布范围限制在某个范围内。在计算机视觉中，我们经常看到很多研究人员在 0 到 1 的范围内归一化像素强度。

然而，在深度学习中，这个术语的确切用法有所不同，具体来说，批处理规范化执行标准化，其中将分布居中为零，并将标准偏差更改为一。这个过程也被称为将不同的数据放入同一尺度的过程。

尽管它们被广泛使用，但我无法发现这些标准化对梯度有什么影响，所以我想修复它。

实验设置

蓝色矩形 →带 ReLU 激活的卷积层
黄色矩形 →归一化层，根据方案该层可以在批处理/层/实例和 box-cox 变换之间变化。在我们没有任何规范化方案的情况下，这一层不存在。
红色矩形 →最终输出矢量，应用 softmax 操作。
灰色球体 →输入图像尺寸(20，96，96，3)。

每个单个网络被训练 150 个历元，学习速率被设置为 0.0008，最小批量大小为 20。最后，我将使用 STL 10 图像数据集，没有任何数据扩充，请注意，这意味着我们有 5000 张训练图像，而测试精度是在 8000 张测试图像上测量的。

结果位移

在展示结果之前，我想介绍一下我是如何放置每个实验的结果的。每个图像包含六个图，并且每个图以连续的方式表示每个层。(按如下所示的顺序。).

所以从顶部开始，每个方框代表该层的值如何随时间变化。我将按照下面的顺序展示其中的四张图片。

左上 →表示相对于每一层权重的梯度
右上 →表示传递到前一层的梯度
左下 →表示每一层的权重
右下 →表示当前权重和计算的梯度之间的差

最后，在显示 gif 之后，我将显示最终迭代结果的静态图像。

无任何归一化

左上 →相对于每层权重的梯度
右上 →传递到上一层的梯度
左下 →每层权重
右下 →当前权重与计算的梯度相减

当我们把注意力集中到左上角的 gif 时，我们可以看到大部分的渐变都集中在零上。这表明大多数权重没有被更新。有很多零梯度的效果可以在位于左下方的 gif 中看到。简而言之，在几次迭代之后，权重变化不大，尤其是第二层、第三层和第四层。

批量归一化

左上 →相对于各层权重的梯度
右上 →传递到前几层的梯度
左下 →各层权重
右下 →当前权重与计算的梯度相减

我们可以立即看到没有任何归一化方案的网络之间的一个显著差异，每层的非零梯度数量*。***

这种增加非零梯度数量的批量标准化属性是深度神经网络训练加速的原因。当我们观察权重如何随时间变化时，我们可以看到直方图有更多的整体移动。

图层归一化

左上 →相对于每层权重的梯度
右上 →传递到上一层的梯度
左下 →每层权重
右下 →当前权重与计算的梯度相减

当我们在每层之间使用层标准化时，我们可以观察到类似的现象。随着非零梯度数量的增加，每层权重的更新变得更加频繁。

实例规范化

左上 →相对于每层权重的梯度
右上 →传递到上一层的梯度
左下 →每层权重
右下 →当前权重与计算的梯度相减

实例归一化标准化了每个图像或特征图，因此，我个人认为与其他归一化方案相比，非零梯度的数量是最大的。

Box-Cox 变换

左上 →相对于每层权重的梯度
右上 →传递到上一层的梯度
左下 →每层权重
右下 →当前权重与计算的梯度相减

当与不具有任何归一化方案的网络相比时，我们可以看到在关于每个权重的梯度中有更多的非零元素。然而，与任何其他归一化方案相比，我们可以看到我们的梯度中仍然有许多零。

讨论

需要记住的一件非常重要的事情是，这些网络(有/没有)归一化方案中的每一个都有完全相同数量的参数。

这意味着他们的学习能力完全相同。

这样做的原因是因为我没有向批处理/层/实例标准化添加任何 alpha 或 beta 参数，所以通过每一层传递的所有数据都必须标准化。了解了这一点，我们就可以看到精度图。

Accuracy for training images

橙色 →批量归一化
红色 →实例归一化
绿色 →图层归一化
紫色 → Box-Cox 变换
蓝色 →无归一化

当我们使用诸如批次/层/实例归一化的归一化方案时，我们可以在第 130 个时期之前在训练图像上实现+95%的准确度。同时，具有 box-cox 变换的网络以及没有任何归一化方案的网络甚至难以通过+60%的准确度。

Accuracy for Testing Images

橙色 →批量归一化
红色 →实例归一化
绿色 →图层归一化
紫色 → Box-Cox 变换
蓝色 →无归一化

从上面的图中我们可以得出结论，令人惊讶的是，没有任何归一化方案的网络做得最好。当考虑到我们有比训练图像多得多的测试图像时，这多少是一个令人印象深刻的结果。STL 10 数据集有 5000 个训练图像和 8000 个测试图像，因此 8000 个图像的 55%将意味着 4400 个图像。

此外，我们可以看到一种模式的出现，随着我们计算平均值和标准偏差的参数数量的减少，测试精度增加。更准确地说，当我们有一个维数为(20，96，96，16)的 4D 张量时，其中每个轴代表(批次大小、宽度、高度、通道)，当我们执行批次归一化时，我们计算通道维数的平均值，即 16。同时，层和实例标准化分别计算批次大小以及批次大小和通道尺寸的平均值。

知道了上面所有的信息，我们可以看到相反的模式明显存在。随着参数数量的增加，我们计算的平均值和标准偏差增加，模型趋于过度拟合。

为什么？

好吧，我不是机器学习方面的专家，但清晰的推测是梯度。更准确地说，非零梯度。事后看来，这非常有意义，如果关于权重的梯度由许多零元素组成，那么权重在更新操作之后不会改变。

但我认为，还有另一个原因，更数学的原因。(注意我也不是数学专家 lol。).

限制分布特性的归一化方案通过减少问题维度空间来简化问题。

我的意思是，减少内部协变量变化本质上是一样的。在批次/层/实例标准化中，我们将平均值和标准偏差限制为 0 和 1。并且这些操作有一个硬结果，意味着平均值是零，和标准差是一。

这种变换的一个软化版本是 box-cox 变换，其运算目的是使某个分布更加“正常”或“对称”。

这两种操作都对特征图的分布施加了一定的限制，使得网络更容易在训练图像上做得很好。然而，这并不意味着它会在测试图像上表现良好。

这篇博文的结论和代码

归一化方案通过增加非零梯度的频率来加速训练，然而，在某些情况下，分布变化的这种限制导致网络失去泛化能力，从而导致过拟合。

要访问 google collab 中这篇博客文章的代码，请点击此处，要访问 GitHub 版本，请点击此处。

最后的话

一般来说，随着可训练参数数量的增加，模型越有可能过度拟合。(没有任何正规化，技巧。).该研究的未来方向可以进一步分为两个方向，1)当我们添加正则化参数时，网络将如何表现。2)诸如 box-cox 之类的变换方法对于对手攻击是否更健壮。

更多文章请访问我的网站。

参考

瓦尔马河(2018 年)。罗汉·瓦尔马—📋我的博客；通过机器学习教程、操作指南、论文评论等等。Rohanvarma.me 于 2018 年 12 月 16 日检索，来自http://rohanvarma.me/
rohan-varma/nn-init-demo。(2018).GitHub。检索于 2018 年 12 月 16 日，来自https://github . com/rohan-varma/nn-init-demo/blob/master/batch norm-demo . py
在神经网络中实现 BatchNorm。(2018).Wiseodd.github.io .检索 2018 年 12 月 16 日，来自https://wiseodd.github.io/techblog/2016/07/04/batchnorm/
(2018).Arxiv.org。检索于 2018 年 12 月 21 日，来自 https://arxiv.org/pdf/1502.03167.pdf
Ba，j .，Kiros，j .，& Hinton，G. (2016)。图层规范化。arXiv.org。检索于 2018 年 12 月 21 日，来自 https://arxiv.org/abs/1607.06450
(2018).Arxiv.org。检索于 2018 年 12 月 21 日，来自https://arxiv.org/pdf/1607.08022.pdf
SciPy . special . boxcox 1p—SciPy v 1 . 2 . 0 参考指南。(2018).Docs.scipy.org。检索于 2018 年 12 月 21 日，来自https://docs . scipy . org/doc/scipy/reference/generated/scipy . special . boxcox 1p . html # scipy . special . boxcox 1p
STL-10 数据集。(2018).Cs.stanford.edu。检索于 2018 年 12 月 22 日，来自https://cs.stanford.edu/~acoates/stl10/

语言建模的归一化中心损失

原文：https://towardsdatascience.com/normalized-center-loss-for-language-modeling-5cd7b40d67e1?source=collection_archive---------2-----------------------

警告:一些递归神经网络的知识是假定的。

语言建模及其工作原理简介？

什么是语言建模？

在语言建模中，我们试图预测给定单词序列的下一个单词。机器学习模型计算下一个单词的可能值的概率。并且从生成的概率分布中对单词进行采样。

问:它是如何工作的？

你建立一个递归神经网络架构。该模型一次处理一个单词，并计算下一个单词的可能值的概率。网络的存储状态由零向量初始化，并在读取每个字后更新。
RNN 的输出依赖于任意远的输入，这使得反向传播很困难。为了使学习过程易于处理，我们将反向传播缩短到固定的步骤数(我们称之为num_steps)。然后，根据 RNN 的有限近似值训练模型。这可以通过一次输入长度为num_steps的输入，并在每个这样的输入块后执行反向传递来实现。

用于评估语言模型的度量是困惑度，其等于 exp(交叉熵)。

作为我之前博文的延续，我想看看增加一个中心损失是否会改善模型的困惑。

归一化中心损耗

我建议读者在阅读这篇文章之前，先阅读前一篇博文的第一部分。

当使用博客文章中定义的相同中心损失时，中心损失将呈指数增加(每 200 次迭代增加一倍)，并最终爆炸。为了克服这个问题，我稍微修改了一下中心损耗，我把修改后的版本叫做归一化中心损耗。

在归一化中心损失中，我在更新它们之后归一化中心，使得每个嵌入的中心向量的范数是 1。这样做是为了防止损耗值爆炸。

为了计算损失，通过相应嵌入的大小来缩放单词向量的中心。这确保了嵌入得到将它们推向中心向量的梯度。

结果

我在 wikitext-2 和 penn treebank 数据集上尝试了这种新的损失方法。结果如下:

penn treebank 数据集上的结果

cross entropy loss and perplexity on training set

cross entropy loss and perplexity on validation set

从图中可以看出，在验证集上尝试的所有 lambda 值的复杂度都有所提高。

Values of cross entropy and perplexity values on the test set

在测试集上提高了 4，这实际上是非常显著的。

wikitext-2 数据集上的结果

cross entropy loss and perplexity on training set

cross entropy loss and perplexity on validation set

从图中可以再次看出，在验证集上尝试的所有λ值上，复杂度都有所提高。

Values of cross entropy and perplexity values on the test set

在测试集上提高了 2，这也是显著的。这里的结果不像宾州树木银行那样令人印象深刻。我认为这是因为归一化损失函数作为正则化函数。由于 wikitext-2 比 Penn Treebank 数据集大得多，添加正则化子的影响被最小化。

结论

由于在两个数据集上的实验中可以观察到复杂度的改善，因此可以预期的是，任何鼓励来自相同类别的特征彼此靠近地聚类的损失函数将导致精确度的改善和过拟合的减少。

本博客中使用的所有实验都可以使用本报告中给出的代码进行复制。

如果你喜欢这篇文章，请点击下面的小拍手图标帮助他人找到它。非常感谢！

标准化的保向 Adam，从 Adam 到 SGD 的切换，以及带有交互代码的内斯特罗夫动量 Adam

原文：https://towardsdatascience.com/normalized-direction-preserving-adam-switching-from-adam-to-sgd-and-nesterov-momentum-adam-with-460be5ddf686?source=collection_archive---------6-----------------------

GIF from this website

最近，我对调整神经网络的不同方法感兴趣，正如所料，许多不同的研究人员已经研究了许多不同的方法。具体来说，今天，我想看看 Adam 优化器的差异。下面是所有不同方法的列表，我们将看看这篇文章。

案例 a: 随机梯度下降 案例 b: 随机梯度下降动量 案例 c: 随机梯度下降动量 案例 d: 亚当优化器 案例 e:

请注意，这篇文章是让我未来的自己回顾和回顾这些纸上的材料，而不是从头再看一遍。也请注意，一些实施工作仍在进行中。

Paper form this website

Paper from this website

基础网络||数据集||不同方法背后的简单理论

Image from this website left right

红色矩形 →输入图像(32323)
黑色矩形 →与 ELU 卷积()有/无平均池
橙色矩形 → Softmax 进行分类

为了简单起见，我将使用我以前的帖子中的基本网络，“全卷积网络”。我们还将在 CIFAR 10 数据集上评估每种优化方法。

最后，我希望为每一种新方法背后的理论写一个简单的版本。(内斯特罗夫动量亚当、SWAT 和归一化方向保持亚当。)

通过从 Adam 切换到 SGD 来提高泛化性能 →在训练过程中简单地从 Adam 切换到 SGD。因此，我们可以在训练开始时利用 Adam 的快速收敛，但稍后我们可以通过 SGD 使模型更好地泛化。

归一化的方向保持 Adam →为什么 Adam 可能不擅长泛化的一个问题(或者说后退)是由于没有保持梯度方向。(与 SGD 不同)这篇论文的作者提出了一种方法来解决这个缺点。

将内斯特罗夫动量引入亚当 →关于这篇论文的一个简单解释就是将用于将动量扩展到内斯特罗夫动量的原理引入并应用于亚当。

结果:案例 a:随机梯度下降

左图 →测试集精度/时间成本
右图 →训练集精度/时间成本

正如所料，随机梯度下降表现非常好。在 CIFAR 10 数据集上的最终准确率为 85.3%，仅用了 20 个历元，对于普通梯度下降来说不算太差。

结果:情况 b:随机梯度下降动量

左图 →测试集精度/时间成本
右图 →训练集精度/时间成本

尽管 SGD 的表现很好，但具有动量的 SGD 能够以 85.7%的准确率略胜一筹。

结果:案例 c:具有内斯特洛夫动量的随机梯度下降

左图 →测试集精度/时间成本
右图 →训练集精度/时间成本

根据在线 stand-ford 课程的实施，具有 nesterov 动量的随机梯度下降给出了相当好的结果。然而，令人失望的是，这种方法优于常规动量法。

Image from this website

结果:案例 d: Adam 优化器

左图 →测试集精度/时间成本
右图 →训练集精度/时间成本

我已经预料到 Adam 会胜过大多数优化算法，然而，这也带来了模型泛化能力差的代价。训练准确率为 97 %,而测试准确率停留在 87%。(其在测试图像上具有最高的准确度，但是只有 3%的改进空间。)

结果:案例 e:内斯特罗夫动量亚当

左图 →测试集精度/成本随时间变化
右图 →训练集精度/成本随时间变化

对于那达慕，我 100 %相信我的实现还没有完全完成。因为我没有加入 u 的产品。因此这可能解释了为什么这个模型的性能如此之差。(甚至根本不训练。)

红框 →图片来自原始论文，我仍在研究的术语

结果:情况 f:从 Adam 切换到 SGD

左图 →测试集精度/时间成本
右图 →训练集精度/时间成本

我相信有了最佳的超参数，这种方法可以胜过其他任何方法。然而，没有最佳的超参数调整，我只能达到 67%的准确性。

这是我迄今为止遇到的最有趣的优化方法之一。我的实现是混乱的，因此不是最好的，但尝试训练这个模型真的很有趣，也很有挑战性。它如此有趣的原因之一是由于反向传播期间的所有 if 条件。

结果:案例 g:归一化方向保持 Adam

尽管我努力三次检查我的实现，并与作者的原始代码进行比较(在此处找到),但在使用 ND-Adam 时，我无法成功地训练这个模型。(我非常确信我在某些地方犯了错误，因为作者能够在 80000 年内达到 90%以上的准确率。)

互动码

要访问案例的代码，请点击此处，要查看日志，请点击此处。
访问案例 b 的代码点击此处，查看日志点击此处。
要访问案例 c 的代码，单击此处，要查看日志，单击此处。
要访问案例 d 的代码，单击此处，要查看日志，单击此处。
要访问案例 e 的代码，请点击此处，要查看日志，请点击此处。
要访问案例 f 的代码，请点击此处，要查看日志，请点击此处。
点击此处访问案例 g 的代码，点击此处访问日志的。

最后的话

我很兴奋开始这些关于泛化的系列。然而，我很难过，尽管我尽了最大的努力，我还是不能成功地训练具有内斯特罗夫动量亚当和归一化方向保持亚当的模型。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请点击这里查看我的网站。

同时，在我的推特这里关注我，访问我的网站，或者我的 Youtube 频道了解更多内容。我还实现了广残网，请点击这里查看博文 pos t。

参考

真，t. (2018)。tensorflow:检查标量布尔张量是否为真。堆栈溢出。检索于 2018 年 6 月 10 日，来自https://stack overflow . com/questions/43263933/tensor flow-check-if-a-scalar-boolean-tensor-is-true
tf。打印？，H. (2018)。如何使用 tf 打印张量的一部分？打印？。堆栈溢出。检索于 2018 年 6 月 10 日，来自https://stack overflow . com/questions/47000828/how-to-print-part-of-a-tensor-using-TF-print
使用 tf。TensorFlow 中的 print()—走向数据科学。(2018).走向数据科学。检索于 2018 年 6 月 10 日，来自https://towards data science . com/using-TF-print-in-tensor flow-aa 26 E1 cf F11 e
tf。打印| TensorFlow。(2018).张量流。检索于 2018 年 6 月 10 日，来自https://www.tensorflow.org/api_docs/python/tf/Print
Tensorflow？，H. (2018)。如何在 Tensorflow 中给 tf.cond 内部的函数传递参数？。堆栈溢出。检索于 2018 年 6 月 10 日，来自https://stack overflow . com/questions/38697045/how-to-pass-parameters-to-functions-inside-TF-cond-in-tensor flow/39573566
tf.cond(pred，fn1，fn2，name=None) | TensorFlow。(2018).张量流。检索于 2018 年 6 月 10 日，来自https://www . tensor flow . org/versions/r 1.0/API _ docs/python/TF/cond
培训，h. (2018)。如何在培训期间更改 tensorflow optimizer？堆栈溢出。检索于 2018 年 6 月 10 日，来自https://stack overflow . com/questions/48259650/how-can-I-change-tensor flow-optimizer-in-training
主成分分析池在 Tensorflow 与互动代码[PCAP]。(2018).中等。检索于 2018 年 6 月 10 日，来自https://medium . com/@ SeoJaeDuk/principal-component-analysis-pooling-in-tensor flow-with-interactive-code-pcap-43 aa2 CEE 9 bb
tf.logical_and | TensorFlow。(2018).张量流。检索于 2018 年 6 月 10 日，来自https://www.tensorflow.org/api_docs/python/tf/logical_and
数学符号列表(+，-，x，/，=，，…)。(2018).Rapidtables.com。检索于 2018 年 6 月 10 日，来自https://www . rapid tables . com/Math/symbols/Basic _ Math _ symbols . html
通过从 Adam 切换到 SGD 提高泛化性能第 76 期 kweonwooj/papers。(2018).GitHub。检索于 2018 年 6 月 10 日，来自https://github.com/kweonwooj/papers/issues/76
zj10/ND-Adam。(2018).GitHub。检索于 2018 年 6 月 10 日，来自https://github.com/zj10/ND-Adam/blob/master/ndadam.py
规范？，W. (2018)。超脚本 2 下标 2 在规范的语境下是什么意思？。交叉验证。检索于 2018 年 6 月 10 日，来自https://stats . stack exchange . com/questions/181620/what-is-the-meaning-of-super-script-2-subscript-2-in-the-context-of-norms
线性代数 27，向量的范数，例题。(2018).YouTube。检索于 2018 年 6 月 10 日，来自https://www.youtube.com/watch?v=mKfn23Ia7QA
tf.float32？，H. (2018)。如何将 tf.int64 转换成 tf.float32？。堆栈溢出。检索于 2018 年 6 月 10 日，来自https://stack overflow . com/questions/35596629/how-to-convert-TF-int 64-to-TF-float 32
tf.reduce_sum | TensorFlow。(2018).张量流。检索于 2018 年 6 月 10 日，来自 https://www.tensorflow.org/api_docs/python/tf/reduce_sum
j . brown lee(2017 年)。深度学习的 Adam 优化算法简介。机器学习精通。检索于 2018 年 6 月 10 日，来自https://machine learning mastery . com/Adam-optimization-algorithm-for-deep-learning/
随机梯度下降。(2018).En.wikipedia.org。检索于 2018 年 6 月 10 日，来自https://en.wikipedia.org/wiki/Stochastic_gradient_descent
带动量的随机梯度下降——走向数据科学。(2017).走向数据科学。检索于 2018 年 6 月 10 日，来自https://towards data science . com/random-gradient-descent-with-momentum-a 84097641 a5d
[ ICLR 2015 ]追求简单:具有交互码的全卷积网。(2018).走向数据科学。检索于 2018 年 6 月 11 日，来自https://towards data science . com/iclr-2015-forwards-for-simplicity-the-all-convolutional-net-with-interactive-code-manual-b 4976 e 206760
CIFAR-10 和 CIFAR-100 数据集。(2018).Cs.toronto.edu。检索于 2018 年 6 月 11 日，来自https://www.cs.toronto.edu/~kriz/cifar.html
用于视觉识别的 CS231n 卷积神经网络。(2018).cs 231n . github . io . 2018 年 6 月 11 日检索，来自http://cs231n.github.io/neural-networks-3/

北印度菜还是南印度菜，深度学习都懂！！:第一部分

原文：https://towardsdatascience.com/north-indian-food-or-south-indian-food-deep-learning-knows-it-all-part-1-13e1d20c359c?source=collection_archive---------2-----------------------

当你在印度旅行时，从克什米尔到 Kanyakumari，你会体验到不同的文化，不同的宗教，但对我来说最重要的是我的国家不同地区的各种食物，从北印度的 Samosa 或 T2 到南印度的 T4，这是你在印度可以品尝到的众多食物中的一部分。

South Indian and North Indian food

你一定想知道深度学习和印度食物有什么关系，那么让我回到过去给你解释现在。自从我开始学习深度学习以来，我学会的第一件事就是如何使用 TensorFlow 、 Keras 以及最后但并非最不重要的 Scikit-learn 制作图像分类器。我建立的图像分类器被用来分类狗和猫的图像，戴眼镜和不戴眼镜的人的图像，我甚至使用 fast.ai 库对 12 个可能的类别中的幼苗进行了分类，但我没有制作任何对食物进行分类的东西。

所以，我想这次为什么不为印度食物做一个快速简单的图像分类器。因此，在这篇文章中，我将带大家了解我如何使用 TensorFlow Codelab 制作一个食物分类器，对印度北部和南部食物的不同图像进行分类。

但是在进入执行部分之前，我需要分享一些我使用的软件信息，这些信息对于图像分类器来说非常重要。

软件(仔细查看版本)

蟒蛇与 Python 版本 3.6.3 。
tensor flow1 . 6 . 0 版本。[确保您至少拥有 1.2 版]
Bash on Ubuntu on Windows 【如果你的系统没有安装 Linux】。

步骤 1:创建数据集

在深度学习中，最重要的部分是数据集的创建。因此，为了创建 Samosa、Khaman Dhokla 等北印度食物和 Idli、Dosa 等南印度食物的数据集，我跟随了 OpenCV 大师 Adrian Rosebrock 的这篇精彩帖子"如何使用 Google Images 创建深度学习数据集",在这篇帖子中，他展示了如何通过几行代码从 Google 下载大量图像。

首先，我创建了一个名为“印度食物照片”的文件夹。在这个文件夹下，我开始创建不同类别的子文件夹，我试图为它们建立一个图像分类器，然后在上面提到的帖子之后，我开始下载 Idli，Samosa，Khaman Dhokla 和 Dosa 的图像。我从不限制自己在某个特定文件夹中与某个特定类别相关的图片数量，我尽可能多地收集每个食物类别的图片。

Feeling hungry,not more than me

你们一定都在想，为什么我没有把我为其构建分类器的每一类食物放入一个文件夹中，为什么我为每一类食物创建子文件夹，原因很简单，分类脚本使用文件夹名称作为标签名称，每个文件夹中的图像应该是对应于该标签的图片。

我的天啊。，这是一个很长的解释，但从这一点向前的解释和步骤将是清晰和简短的。

步骤 2:克隆 Git 存储库:

git clone [https://github.com/googlecodelabs/tensorflow-for-poets-2](https://github.com/googlecodelabs/tensorflow-for-poets-2)

cd tensorflow-for-poets-2

第三步:移动文件夹“印度食物照片”到“tf 文件”下

这一步对于像我一样在 Windows 上使用 Bash on Ubuntu 的人来说是有帮助的，这是一个 windows 10 操作系统的 Linux 子系统，而那些在他们的系统中安装了 Linux 的人我认为不是，他们需要任何关于将文件从一个目录移动到另一个目录的指导。

cp -r /mnt/c/Users/ADMIN/Documents/Indian_foods_photos tensorflow-for-poets-2/tf_files/

为了查看文件夹是否被正确复制，我给出了以下命令

cd tf_files/Indian_foods_photos/

ls

步骤 4:传递变量

这一步是所有步骤之母，在这一步中，我尝试用 MobileNet 架构来训练网络。MobileNet 被优化为小而高效，代价是一些准确性和需要更少的处理时间。

但在训练我的网络之前，我还设置了两件事，首先是“输入图像分辨率”为 224 像素。不出所料，输入更高分辨率的图像需要更多的处理时间，但会导致更好的分类精度。然后，我将模型的相对大小设为 0.75。这两个配置选项都可以在下面的命令中看到。

IMAGE_SIZE=224

ARCHITECTURE="mobilenet_0.75_${IMAGE_SIZE}"

知识第一节【未迈出一步】

因此，在 tensorflow-for-poets-2 目录下传递上述变量后。这是一个完美的时刻，我想和大家分享一个重要的信息。在构建这个分类器时，我使用了一个在 ImageNet 大型视觉识别挑战数据集上训练的模型，并使用了迁移学习，因为从头开始进行深度学习可能需要几天时间，但通过使用迁移学习，一切都可以在短时间内完成。

知识第二节【未迈出一步】

正如我在上面的知识部分 I 中提到的，我使用了 Imagenet 模型，该模型由具有数百万个参数的网络组成，这些参数可以区分大量的类别，除此之外，我只训练了该网络的最后一层，这就是为什么训练在合理的时间内结束。

ImageNet 不包括我在这里培训的任何印度食物。然而，使 ImageNet 能够在 1，000 个类别中进行区分的信息种类对于区分其他对象也是有用的。通过使用这个预先训练好的网络，我将这些信息作为最终分类层的输入，以区分我的印度食物类别。

步骤 5:运行培训网络

现在，我在声明 IMAGE_SIZE 和 ARCHITECTURE 变量之后传递了这些命令

python -m scripts.retrain \
  --bottleneck_dir=tf_files/bottlenecks \
  --model_dir=tf_files/models/"${ARCHITECTURE}" \
  --summaries_dir=tf_files/training_summaries/"${ARCHITECTURE}" \
  --output_graph=tf_files/retrained_graph.pb \
  --output_labels=tf_files/retrained_labels.txt \
  --architecture="${ARCHITECTURE}" \
  --image_dir=tf_files/Indian_foods_photos

在我向您展示当我传递上述命令时发生了什么之前，让我告诉您在运行这几行代码之后我经历了什么

默认情况下，该脚本运行 4，000 个训练步骤。每一步从训练集中随机选择 10 幅图像，从缓存中找到它们的瓶颈【瓶颈是一个非正式术语，我们经常使用它来表示最终输出层之前的层，最终输出层实际上进行分类】，并将它们输入到最终层以获得预测。然后将这些预测与实际标签进行比较，通过反向传播过程更新最终图层的权重。

随着过程的继续，我看到报告的准确性有所提高。完成所有训练步骤后，脚本对一组与训练和验证图片分开保存的图片运行最终的测试准确性评估。这个测试评估为我提供了训练好的模型在分类任务中表现如何的最佳估计。

让我们只观察通过上面的文字描述的所有图像

Downloading the mobilenet Architecture

creating bottleneck layers and then determining various parameters

The Final Accuracy

我的模型最终的准确率是 88.1% 。

步骤 6:对图像进行分类

这是最后一步，通过给出下面提到的命令，我确定了我的食物分类器在不同的印度食物图像上的表现

python -m scripts.label_image \
    --graph=tf_files/retrained_graph.pb  \
    --image=tf_files/Indian_foods_photos/samosa/00000422.jpg

因此，通过这些结果，我结束了我的文章。但是我的旅程还没有结束，这只是我旅程的第一部分，当我向你解释如何在我的自定义数据集上使用这些结果时，我的旅程就结束了。我继续使用 Android Studio 的自定义 TensorFlow 应用程序创建了一个食品分类器 Android 应用程序，因此为本文的第二部分做好准备，它将很快发布。

参考资料:

没有这个tensor flow for Poets code lab就不可能有上面的文章，请参考它以获得进一步的澄清。
为了了解更多关于深度学习的知识，你可以查看这里的。
为了了解更多关于迁移学习的信息，你可以查看这里。

最后一件事…
如果你喜欢这篇文章，请点击👏下面，并与他人分享，这样他们也可以享受它。

还有，想的话就跟我上 中！我很乐意。

北印度菜还是南印度菜，深度学习都懂！！:第二部分

原文：https://towardsdatascience.com/north-indian-food-or-south-indian-food-deep-learning-knows-it-all-part-2-14a59d0ffc15?source=collection_archive---------7-----------------------

如果我们想让机器思考，我们需要教它们看。——费斯坦福 AI 实验室主任斯坦福视觉实验室**

在第 1 部分中，我展示了我如何使用 TensorFlow Codelab 制作了一个食物分类器来对印度北部和南部食物的不同图像进行分类(如果你还没有读过第 1 部分，现在就去读吧！).

我在第 1 部分的最后提出了一个想法，我将向您解释如何使用我的自定义数据集生成的结果，我继续使用 Android Studio 的自定义 TensorFlow 应用程序创建了一个 F ood 分类器 Android 应用程序。

所以，是时候实现我的承诺了，但在展开我的食物分类器 Android 应用程序、的步骤之前，让我向你展示它在现实世界中的表现。****

我知道如果你和我一样是美食家，你现在一定感觉饿了，但是控制你自己你仍然必须阅读我如何能够使用 TensorFlow 完成这个食物分类器应用程序的任务。

在继续之前，我先说说做这个项目背后的灵感。这一切都是从来自 fast.ai 课程的杰瑞米·霍华德告诉我们学生们在通过 fast.ai 课程发展深度学习技能后做了多么美妙和革命性的事情开始的，其中之一是著名的非热狗应用程序，用于 HBO 的硅谷，由蒂姆·安格雷德使用 Tensorflow 开发。所以，从我梦想构建这样东西的那一刻起，今天通过这篇文章，我与大家分享我构建食物分类器应用程序的经验。

现在，情绪激动的时刻到此为止，让我们谈生意吧。构建食物分类器应用程序的步骤非常简短，我还在参考资料部分添加了链接，这将为您提供额外的支持，以防您继续重复我所做的事情。

让我先列出这个项目使用的软件和硬件。

软件(仔细看版本)

蟒蛇与 Python 版本 3.6.3 。
TensorFlow 版本 1.6.0。[确保您至少拥有 1.2 版]
Bash on Ubuntu on Windows 【如果你的系统没有安装 Linux】。
安卓工作室 3.0.1

硬件

一个带摄像头的安卓手机(当然)[因为我没用安卓模拟器]。
A 树莓 pi 3 Model B 带 5 寸 HDMI 液晶(因为我附近酒店 Dosa 用光了:)。

目标:一个简单的相机应用程序，运行 TensorFlow 图像识别程序来识别不同的印度食物。

预防步骤:我确保 tensorflow-for-poets-2 与我在第 1 部分中使用的相同的 git 目录是我当前的工作目录，它由另外三个子目录[ android/tfmobile/、scripts/、tf_files/]组成。这对于应用的实现起到了至关重要的作用。

步骤 1:优化模型

由于移动设备有很大的局限性，所以这是我使用名为“ optimize_for_inference 的 TensorFlow 工具减少应用程序占用空间的预处理步骤，该工具删除了给定输入和输出集不需要的所有节点。

下面是我运行脚本的方式，它生成了一个新文件 TF _ files/optimized _ graph . Pb:

***python -m tensorflow.python.tools.optimize_for_inference \
  --input=tf_files/retrained_graph.pb \
  --output=tf_files/optimized_graph.pb \
  --input_names="input" \
  --output_names="final_result"***

步骤 2:验证优化的模型

为了检查optimize_for_inference没有改变我的网络的输出，我比较了retrained_graph.pb(graph generated in part 1)和optimized_graph.pb的label_image 输出，幸运的是，输出概率没有变化，这意味着 optimized_graph.pb 将产生与 retrained _ graph.pb 相同的结果，每当我在我的自定义数据集上运行它时，请参见图 1 和图 2 了解更多细节。

***python -m scripts.label_image \
  --graph=tf_files/retrained_graph.pb\
  --image=tf_files/Indian_foods_photos/Samosa/00000082.jpg python -m scripts.label_image \
  --graph=tf_files/optimized_graph.pb\
  --image=tf_files/Indian_foods_photos/Samosa/00000082.jpg***

Image 1:

Image 2

步骤 3:量化网络权重

因为我的再培训模型是 84MB 大小，我知道两件事，每个移动应用程序分发系统在分发之前压缩包。第二，图(这里是 optimized_graph.pb)占用的大部分空间是权重，它们是大块浮点数。因此，我试图通过使用 tensorflow-for-poets-2 git 存储库中给出的quantize_graph脚本来量化网络权重。

相同的代码和视觉效果如下所示:

***python -m scripts.quantize_graph \
  --input=tf_files/optimized_graph.pb \
  --output=tf_files/rounded_graph.pb \
  --output_node_names=final_result \
  --mode=weights_rounded***

现在尝试压缩这个量化模型:

***gzip -c tf_files/rounded_graph.pb > tf_files/rounded_graph.pb.gz

gzip -l tf_files/rounded_graph.pb.gzcompressed        uncompressed  ratio uncompressed_name
 2922466            10495462    72.2% tf_files/rounded_graph.pb***

I got 72.1% compression

现在，是时候检查量化权重步骤是否对模型性能产生了负面影响，但幸运的是，这只是一个微小的变化，看看下面的图片。

samosa accuracy changed from 0.9999945 to 0.9992605

步骤 4:设置 Android Studio

加载 Android Studio 后，我打开了它。我从弹出菜单中选择了“打开一个现有的 Android Studio 项目”。
然后在文件选择器中，我从我的工作目录中选择tensorflow-for-poets-2/android/tfmobile。
然后我得到了一个“Gradle Sync”弹出窗口，我第一次打开这个项目，询问关于使用 gradle wrapper。我只是点击了“确定”。

注意，这一步会花很多时间，所以与此同时，去和你的女朋友或妈妈聊聊天，或者喝杯黑咖啡，做任何你想做的事情，但是要有耐心。

Setting up Android Studio

步骤 5:设置 Android 手机或 Android 模拟器

这款应用可以在安卓手机或安卓模拟器上运行

有关如何设置 Android 设备的说明，请单击此处的。
有关如何设置 Android 模拟器的说明，请单击此处的。

步骤 6:将模型添加到定制应用程序

因为默认的应用程序设置使用标准的 MobileNet 将图像分类到 1000 个 ImageNet 类中的一个。因此，我修改了应用程序，以便应用程序将使用我的自定义图像类别的重新培训模型。

TensorFlow 应用程序的演示项目被配置为在android/tfmobile/assets目录中搜索一个graph.pb和一个labels.txt文件。所以，我用我的版本替换了那两个文件。以下命令帮助我完成了这项任务:

***cp tf_files/rounded_graph.pb android/tfmobile/assets/graph.pb
cp tf_files/retrained_labels.txt android/tfmobile/assets/labels.txt***

由于 app 使用的 TensorFlow 接口要求你通过名字来询问你的结果。该应用程序当前设置为读取基线 MobileNet 的输出，名为"MobilenetV1/Predictions/Softmax"。我的模型的输出节点有一个不同的名字:"final_result"。所以，我打开ClassifierActivity.java，更新OUTPUT_NAME变量如下:

***private static final String INPUT_NAME = "input";
private static final String OUTPUT_NAME = "final_result";***

第七步:运行应用程序(荣耀时刻)

在对上面提到的文件做了所有的更改并设置了我的 Android 移动设备后，我测试了我的应用程序，结果或最令人满意的图片如下所示。

Result 1: Screenshot of Mobile app classifying Indian foods

Another view of the network

所以，我所有的读者朋友们，通过这种方式，我成功地实现了用 TensorFlow 做一个食物分类器的梦想。我会用那些一直激励着我的诗句来结束我的文章。

“相信你的梦，它们是有原因的”

参考资料:

没有这个tensor flow for Poets 2 code lab就不可能有上面的文章，请参考它以获得进一步的澄清。
如果您在 Tensorflow 自定义 app 的执行过程中遇到任何问题，您可以在这里查看我提供的解决方案。
如果你想了解更多关于 TensorFlow 的信息，你可以查看这里。
最后但同样重要的是，你可以在这里查看 YouTube 视频。

感谢您的关注

你用你的时间来阅读我的作品对我来说意味着整个世界。我完全是这个意思。

如果你喜欢这个故事，疯狂鼓掌吧👏 ) 按钮！这将有助于其他人找到我的工作。

还有，跟我上 中Linkedin如果你想！我很乐意。****

不仅仅是另一张 GAN 纸——SAGAN

原文：https://towardsdatascience.com/not-just-another-gan-paper-sagan-96e649f01a6b?source=collection_archive---------1-----------------------

今天我要讨论一篇最近的论文，这篇论文是我读的，并提交给了我的一些朋友。我发现这篇论文的想法非常简单，我觉得像我这样对生成性敌对网络知之甚少的人都能理解。

这是一篇由 GANfather，Ian Goodfellow 和其他几位伟大的研究人员最近发表的论文。论文题目为 自我关注生成对抗网络 或简称萨根。

GANs 生成的大部分好的图像结果都是利用了一个叫做卷积神经网络(CNN)的怪物。像所有的怪物一样，这一个也有一些弱点，我们将进一步讨论。我们见过的大多数 GAN 生成的好图像都是单个类或很少几个类。下图仅在名人面孔数据集上进行训练。

Source: (YouTube) Progressive growing of GANs

问题是

卷积 gan(以后简称为 CGANs)在学习 Imagenet 等多类数据集的图像分布时存在困难。研究人员观察到，当在多类数据集上训练时，这些 CGANs 在建模一些图像类时比其他图像类有困难。他们观察到，CGANs 可以很容易地生成像海洋、天空等更简单几何图形的图像。但是对于像狗、马等一些特殊几何形状的图像却失败了。CGAN 能够生成狗的毛皮纹理，但无法生成独特的腿。

为什么会出现这个问题？

这个问题的出现是因为卷积是一种局部运算，其感受野取决于核的空间大小。在卷积运算中，左上角的输出不可能与右下角的输出有任何关系。在下图中，我们可以看到输出" -8" 是由图像左上角的像素计算的，它与图像中的任何其他部分都没有关系。类似地，当计算卷积输出的任何部分时，除了图像中计算输出的小的局部区域之外，它与任何其他部分无关。

Source: Quora answer by Abhishek Shivkumar

你会问，难道我们不能把空间尺寸做得更大，这样它就能捕捉到更多的图像吗？是啊！当然我们可以，但这会降低较小过滤器的计算效率，并使操作变慢。那么你会再次问，难道我们不能用更小的滤光器制作更深的 CGAN，以便后面的层具有更大的感受野吗？是啊！我们可以，但是要有足够大的感受野需要太多的层，太多的层意味着太多的参数。因此，这将使 GAN 训练更加不稳定。

自我关注 GANs

保持计算效率并同时拥有大的感受域的解决方案是**自我关注。**它通过利用 NLP 中著名的“注意力”机制，帮助在效率和远程依赖性(=大感受野)之间建立平衡。

这是什么关注？

这是最容易理解的事情之一。假设有 3 个人，分别叫查询、键和值。注意是当查询和键决定值可以对外界说多少话。在深度学习中，每样东西都是一个向量，所以这三个人实际上是三个向量。查询和键以这样的方式相乘，使得它们创建了另一个概率向量，该向量决定向下一层公开多少值。是的，这就是注意力的全部。

Source: Attention is all you need paper

让我们用图表来理解它。这个图表是不言自明的。Q(查询)和 K(密钥)经过矩阵乘法，然后通过 softmax，soft max 将结果向量转换为概率分布，最后乘以 V(值)。

那这个自我关注是什么东西？在自我关注中，查询、键和值都是相同的。

模型

如果你理解了上面的部分，那么理解这是小菜一碟。这是本文提出的自我关注层。在下图的左边，我们得到了之前卷积层的特征图。假设它的维度为(512 x 7x 7)，其中 512 是通道的数量，7 是空间维度。我们首先将特征图分别通过三个 1x1 卷积。我们将三个滤波器命名为 f，g 和 h.

Source: SAGAN paper

1x1 卷积的作用是减少图像中的通道数量。实际上，1×1 滤波器是一个维度(前一层中的通道数×1×1)。所以 f 和 g 有 64 个这样的滤波器，所以滤波器的维数变成(64 x 512 x 1 x1)。T4 h T5 有 512 个这样的过滤器。在图像通过之后，我们得到三个维度的特征图(64×7×7)、(64×7×7)和(512×7×7)。猜猜这三样东西是什么我们的查询，键和值对。为了对完整的图像进行自我关注，我们拉平了最后两个维度，维度变成了(64×49)、(64×49)和(512×49)。现在我们可以对它进行自我关注了。我们转置查询并将其与键相乘，然后对所有行取 softmax。于是我们得到了一个形状(49×49)的输出注意图。然后，我们将价值向量与注意力图进行矩阵相乘，输出的形状为(512 x 49)。论文提出的最后一点是，将最终输出乘以一个可学习的比例参数，并将输入作为残差连接添加回去。假设 x 是图像， o 是输出，我们将 O 乘以一个参数 y. 最后的输出 O 变成， O=yo+x* *。*最初，该论文建议将标度参数初始化为零，使得输出在开始时是简单的旧卷积。他们用零初始化 y ，因为他们希望他们的网络依赖于本地邻域中的线索——因为这样更容易，然后网络将逐渐学会给 y 参数赋值，并使用自我关注。

这一层有助于网络从图像的遥远部分捕捉细微的细节，记住，它不能代替卷积，而是卷积运算的补充。

Source: SAGAN paper

使用的损失函数只是对抗性损失的铰链版本。该论文没有解释任何关于这个特定损失函数的特定用途。

这里 z 是潜在向量，图像将从该潜在向量生成，并且 x 和 y 是来自数据的真实图像。发生器损耗说明了通过愚弄鉴别器来创建越来越真实的图像，而另一方面，鉴别器试图在区分真实和虚假图像方面变得更好。

报纸上的一些细节

他们在生成器和鉴别器中都使用了这种自我关注层

b) 他们对发生器和鉴别器中的权重进行了频谱归一化，而不像之前的论文只对鉴别器权重进行了归一化。他们将谱范数设置为 1，以限制权重的 Lipschitz 常数。这只是用来控制梯度。这个光谱归一化的想法是由宫藤等人首先提出的。艾尔。

他们使用了一个双时标更新规则(TTUR ),该规则简单地对鉴别器和生成器使用不同的学习速率。

d) 本文中使用的指标是初始得分(IS，越高越好)和 frech et-初始距离(FID，越低越好)。

结果

本文通过实验解释了谱归一化和 TTUR 如何帮助 GAN 更好地收敛。相同的图片如下所示。

Source: SAGAN Paper

我们可以看到，在所有三种情况下，评估指标都是 IS 和 FID。当谱范数仅在鉴别器权重上时，训练非常不稳定。即使我们对生成器和鉴别器都应用谱范数，分数也会在大约 200k 迭代时偏离。但是有了 TTUR 就不会这样了。

这篇论文最好的部分是它的结果，它远远超过了以前的最先进水平。

Source: SAGAN paper

最后让我们看看自我关注的 GANs 生成的图像。

Source: SAGAN Paper

非常感谢你读到这里。如果你喜欢这篇文章，请留下一些掌声。我希望它对你有用。请阅读这篇文章以了解更多的细节，相信我，这是一篇容易读懂的文章。

这是我的第二篇博客，所以请原谅我可能犯的任何错误。我很乐意接受对我任何错误的建设性批评。我会写更多，所以请订阅或关注我的推特。我展示的幻灯片的链接是这里的。想要了解类似的研究论文解释，请订阅 Youtube 上的 Crazymuse AI 频道。任何其他建议都可以通过 twitter 或电子邮件联系我。

不是位置，不是位置，不是位置

原文：https://towardsdatascience.com/not-location-not-location-not-location-c09f7cac24e4?source=collection_archive---------7-----------------------

纽约人痴迷于几样东西:他们孩子的学校，新餐馆，但没有什么比房地产更重要的了。作为一个被收养的纽约人，我不禁惊叹于纽约市房地产市场的永恒娱乐奇观。

对于本周的项目，kaggle 在菜单上，特别是两个适马连接:租赁列表查询挑战。我最近试图建立一个关于纽约房地产销售的数据集；不幸的是，大多数房地产网站设置的验证码障碍使得这一努力毫无结果。

这项比赛由两家适马和 RentHop(两家适马风险投资公司的投资组合公司，是两家适马投资公司的子公司)共同主办，旨在鼓励利用现实世界数据解决日常问题的创造力。

目标

这些数据包括 2016 年 4 月至 6 月期间创建的纽约市及其周边的 49，000 行火车集和 74，000 行租赁房源测试集。目标是一个三级变量，“兴趣水平”:

“低”:列车组的 69.5%，
“中等”:22.7%
“高”:7.8%

RentHop 没有定义分类的标准。挑战在于预测测试集中每个列表的每个兴趣水平的概率。竞赛的衡量标准是预测的多类对数损失。

Listing map (made on Tableau)

高利息的理由

除了建立一个模型的基本任务，这个模型将与竞赛紧密相关，但大多数读者对此不感兴趣，还可以确定是什么使一个列表吸引了很高的兴趣。如果我是一名房地产经纪人，我肯定会想知道哪些功能对找房子的人来说很重要，这样我就可以寻找满足这些需求的公寓或发布房源，并吸引客流量。

在我看来，纽约的租房者可以分为两大类:

家庭:他们主要是受好学校的需要和附近的驱动；
刚毕业的大学生:刚到纽约，他们主要受价格驱动。

我知道纽约有很多租房者不符合这两个类别中的任何一个(持有愤怒的笔记！)，但考虑到数据集中的房源所涵盖的时间段(4 月至 6 月)，我认为它们可能涵盖了一些潜在的租房者，并解释了我们的发现。

簇

在选择公寓时，大多数纽约市居民倾向于将他们的搜索限制在一个特定的社区，原因有很多:因为它很安静，或者有好学校或美食，或者方便上班通勤。由于猎人似乎专注于他们选择的区域，我开始根据纬度和经度对数据进行聚类。基于视力测试，我选择了 30 组。

正如你在下面看到的(很抱歉是第二张纽约市地图……)，他们很好地识别了纽约市的自然社区，并强化了这样一个想法，即公寓搜索者将他们的搜索限制在他们感兴趣的城市部分。

RentHop listings in 30 NYC clusters

有三个数字与每个聚类相关联:它的数字(由聚类算法 KMeans 确定)、该聚类的平均兴趣水平分数(0 表示低兴趣水平，1 表示中兴趣水平，2 表示高兴趣水平-整个数据集的平均值为 0.38)以及该聚类中的列表数量。

有趣的是，离曼哈顿中心越远，分数越高，那里的上市密度越低。换句话说，当选择较少时，兴趣水平较高。

另一个有趣的观察结果是，两个较高的聚类分数是地图西北角的两个:通过选择，我决定在 40.85 纬度/-74.04 经度点周围随机分配位置异常值。我认为对纬度和经度坐标的不重视也会反映在列表的总体水平上，这就是我决定将它们放在一起的原因。看来我错了…

计算了一些聚类平均值(价格、每间房间的价格、每间卧室的价格等等)，我在下面展示了这些平均值，以帮助可视化。在项目的模型构建部分，它们被用于将每个列表与其聚类平均值进行比较，以获得将列表定位在其聚类中的八个特征。

同样的特征然后被设计成与建筑平均值相关。毕竟，在找公寓的时候，你可能会想把一个房源和它最近的邻居进行比较(还有什么比上下两层楼更近呢？)

自然语言处理

我期待自然语言处理对描述和特性有所帮助。这是一个小小的挑战，因为没有一个通用的方法来命名一个特定的公寓功能，每个上市代理都有自己的命名风格。

经过几次尝试后，它是一个计数矢量器，列出了大多数与豪华公寓相关的功能，证明是该领域的最佳贡献者。这有点违背直觉，因为目标是确定利息水平，而不是高价。

情感分析

另一项功能工程任务是在列表描述中使用 NLTK Vader 情感分析器。以下是每个兴趣水平组的平均综合、负面、中性和正面情绪得分。

Sentiment Analysis averages per Interest Level

如上所述，一方是低兴趣，另一方是中兴趣和高兴趣，这两者之间有细微的差别，但总的来说，这三个群体在所有四个方面都非常接近。当谈到出售房地产时，这并不完全令人惊讶。

模型优化

随机森林分类器(针对网格搜索进行了优化)给出了以下十大特征重要性:

Feature Importance

正如我所料，经理得分排在第一位，考虑到该功能是如何构建的(基于每个经理的平均兴趣水平得分),这也不奇怪。)更有趣的是接下来的两个特性，“每间客房价格”和“价格”。在我提到社区(或集群)是家庭找房子的一个决定因素后，这凸显了涌向城市寻找第一份工作的大学毕业生(纽约市租房人口的另一大部分)对租房的要求:便宜…

形象化

下面的方框图有助于我们理解最后一点:

Price per Room vs. Interest Level (from Tableau)

箱线图之间的差异非常清楚地表明，当涉及到上市兴趣水平时，每个房间的价格非常重要。

现在，让我们检查每个集群的平均价格和每间客房的价格:

Price vs. Price per Room per Cluster (Dot size reflects average Interest Level)

不出所料，曼哈顿中城(集群 23)的房价较高，紧随其后的是 Soho-West Village 地区(集群 10)。在光谱的另一端，因伍德-河谷镇(集群 12)似乎提供了“最好的交易”，紧随其后的是日落公园、格林伍德和湾脊(集群 14)周围的布鲁克林集群。较大的点(较高的利息水平)也往往位于地块的左下角，这里的价格较低，公寓密度较低。大多数集群都在曼哈顿之外。

Bedrooms vs. Bathrooms per Cluster (Dot size reflects average Interest Level)

比较卧室与浴室，只有一个小的迹象表明，更多的卧室吸引更多的兴趣，地块右边部分的集群比左边部分的集群略大。另一个观察是，曼哈顿公寓往往有更多的浴室，因为 1.25 线以上的所有集群都在曼哈顿，但浴室的数量似乎对兴趣水平没有太大影响。

惊人的发现

在列举一个地方时，也许“少即是多”:在照片和文字中。

列表上的图片越多，人们的兴趣似乎就越少。如果有更多的照片，找房子的人会有更多的机会发现房子的缺陷吗？猎人会因为照片没有被管理而感到无聊和烦恼吗？

Box plot of Photos per Interest Level (made on Tableau)

下面的第二个也是同样的意思:更多的文字，更少的兴趣…也许公寓猎人认为需要更多的文字来掩盖更多关于公寓状况的问题？或者，也许找房子的人注意力持续时间短，很快就会被未经编辑的空话弄得烦躁不安。

结论

公寓猎人和房地产经纪人，振作起来！

根据这些数据，以下是一些引起租赁清单兴趣的事实:

首先也是最重要的，价格很重要:有很多指标可以显示它，但我的模型中的功能重要性是一个很好的指标，几个与价格相关的功能排在前 10 位。
租房市场上寻找公寓的人的行为与销售市场上的不同。毕竟，大多数租房者认为他们的情况是暂时的，所以“位置，位置，位置”的旧规则不太适用于那些想租房的人。
远离市中心和较低的公寓密度增加了人们的兴趣。
把注意力更多地放在拍好照片上，而不是拍很多照片。浏览它们的时候疲劳很快就来了。
简洁精确的描述比冗长罗嗦的描述更重要。

我希望你喜欢这篇文章，并且能够在你尝试你家附近最新的热门餐馆时分享这些见解！

虚拟人的非深度强化学习——第一部分

原文：https://towardsdatascience.com/not-so-deep-reinforcement-learning-for-dummies-part-1-c22416a55535?source=collection_archive---------6-----------------------

强化学习初学者指南

Source

我是 Udacity 深度强化学习纳米学位第一批的学生。这一系列的博客文章对我来说更像是给自己的笔记。我希望，通过写这些帖子，我能理清我的概念，也许还能帮助别人理解它们。在这篇文章中，我们将讨论什么是强化学习，并概述一个基本的强化学习环境。

当我们思考学习的本质时——强化学习:导论——我们最先想到的可能是通过与环境互动来学习

上面这条线，就是强化学习的全部，从互动中学习；从经验来看。作为刚出生到这个世界的人类和动物，我们不知道我们周围的世界是如何运作的。只有在与世界互动多年后，我们才开始理解它如何回应我们的行为，只有那时我们才能采取具体行动来实现我们的目标。

Basic diagram of a Reinforcement Learning scenario

类似地，在强化学习中，我们有一个与环境交互的代理。在每个时间步，代理接收环境的当前状态，并且代理必须选择一个适当的动作作为响应。代理执行动作后，代理会收到一个奖励和一个新的状态。

Robot moving in a strainght line (Source: Udacity)

就拿上面的例子来说吧。在上述具有从 0 到 4 的状态的环境中，我们有一个代理(机器人)可以左右采取两个动作。机器人的目标是到达状态 3。如果代理在位置 0 时选择向左移动，或者在位置 4 时选择向右移动，代理就保持在原地。同样，每当代理采取行动时，环境给代理奖励-1，并在达到状态 3 时给+10。为了理解第一张图，让我们考虑一个时间步长。

代理的当前状态为 1，随机采取动作离开。因此，环境给它的奖励是-1，它的新状态也是 0。让我们考虑几个小插曲来理清事情。顺便说一下，一集是代理应用随机动作的一次迭代，直到它达到目标，然后终止。

在第一集里，代理从状态 1、 S(1) 开始，有一个奖励为 0、 R(0) 。然后它向左执行一个动作并接收一个-1 的奖励， R(-1) 并在下一个状态 2， S(2) 中结束…最终在几个动作之后，它到达 S(3)并终止。在这一集的最后，代理人得到的奖励是 0–1–1–1+10 = 7

Episode 1
R(0)|S(1) → Left → R(-1)|S(0) → Right → R(-1)|S(1) → Right → R(-1)|S(2) →Right → R(+10)|S(3) → Episode Ends
--------------------------------------------------------------------Episode 2
R(0)|S(1) → Right → R(-1)|S(2) →Right → R(+10)|S(3) → Episode Ends

类似地，代理完成了第二集。但是注意，这一次，代理人获得的奖励是 0–1+10 = 9，高于第一次行动。

因此，强化学习就是学习做什么；将特定行动与情况/状态对应起来，以最大化数字奖励。代理人必须探索环境，并通过尝试了解哪些行为会产生最大的回报。代理人采取的行动可能会影响即时奖励以及下一个状态，进而影响所有后续奖励。你可以把这想象成蝴蝶效应，一个小小的举动可能会在未来导致巨大的回报或者非常糟糕的回报。

我们研究的上面的例子是我们所说的片断任务，它有一个明确定义的终点。还有一种类型的任务叫做**持续任务，**永远持续下去。课程中提到的一个令人敬畏的连续任务的例子是股票交易机器人，它连续分析市场并做出相应的决策，而不是每次都停下来。稍后我们将学习用于连续任务的算法。

为什么不那么深？

深度学习是当你使用一个深度神经网络来预测一个代理的行为。在这个系列中，我们将讨论几十年前开发的传统算法，它构成了强化学习的基础。

在接下来的几个部分中，我们将讨论可用于强化学习的各种算法。一些例子是 SARSA、SARSA-Max、蒙特卡罗方法等。所以，敬请关注。

第二部分已经出来了。点击查看。

虚拟人的非深度强化学习——第二部分

原文：https://towardsdatascience.com/not-so-deep-reinforcement-learning-for-dummies-part-2-854216d1fe0d?source=collection_archive---------8-----------------------

马尔可夫决策过程——强化学习初学者指南

This image is meant to signify an agent trying to decide between two actions. Photo by Caleb Jones on Unsplash

在我之前的帖子中，我们讨论了什么是强化学习，关于代理、奖励、状态和环境。在这篇文章中，我们将讨论如何将现实世界的问题表述为马尔可夫决策过程 ( MDP)，以便我们可以使用强化学习来解决它。在我们开始之前，让我引用《T2 强化学习:导论》一书中的一些例子和可能的应用。

出生几分钟后，一只小瞪羚挣扎着站起来。半小时后，它以每小时 20 英里的速度运行。

象棋大师走了一步棋。这种选择是由计划(预测可能的回复和反回复)和对特定位置和移动的愿望的即时、直觉判断两者提供的。

一个移动机器人决定它是否应该进入一个新的房间寻找更多的垃圾来收集，或者开始试图找到回到它的电池充电站的路。它根据电池的当前充电水平以及过去找到充电器的速度和难易程度来做出决定。

在这篇文章中，让我们试着把移动机器人的第三个例子公式化为 MDP。让我们看看机器人拥有和能够采取的状态和动作。

状态—{高，低} 。机器人可以处于高电量状态，不担心充电，专注于搜寻垃圾；或者，它可以有一个低电量，并优先充电超过搜索。

行动 —在每个状态中，代理可以决定去搜索垃圾，等待有人将垃圾带到那里，或者返回充电站充电。当电池电量很高时，充电就没有意义了。因此，我们有以下动作集: A(高)——{搜索、等待} 和 A(低)——{搜索、等待、充电}

A figure showing the states of the robot, and the transitional probabilities and respective rewards. (Source: Udacity)

转移概率&奖励——转移概率或者他们正式的称呼；单步动态，是给定一个动作，从一个状态转换到另一个状态的概率。假设奖励大部分时间是 0，代理每捡一个垃圾获得+1。参考上图，我们来看一些观察结果。

当机器人的状态为高时，它可以决定搜索或等待。

如果它决定搜索(消耗电池)，有 30%的可能性(0.3 的概率)代理可能从高转换到低，有 70%的可能性(0.7 的概率)该状态将保持高。假设在这两种情况下，机器人设法找到了 4 个垃圾，因此环境给了它 4.0 的奖励。
当处于状态高的机器人决定等待时。我们 100%确定(1.0 概率)机器人会保持同样的状态。在等待的时候，假设有人过来给了机器人 1 个垃圾，机器人因此获得了 1 英镑的奖励。

类似地，对于状态低，机器人具有它可以采取的动作； A(低)——{搜索、等待、充电}。

如果电池低，并且代理决定搜索，则电池很有可能(0.8)会耗尽，我们必须进行干预，将代理带到充电站，稍后结束于高状态。在这种状态下成功完成搜索操作的概率非常低(0.2)，此后代理仍将保持在低状态。在决定搜索时，假设电池耗尽，需要人工干预才能到达充电站。在这里，我们需要惩罚机器人即使在电池电量低的时候也决定搜索，并给它-3 的奖励，无论它是否能够找到任何垃圾。类似地，在决定搜索时，假设它设法找到了 4 个垃圾桶而没有耗尽电池，因此它获得了 4 的奖励。
如果在这种状态下，代理决定采取动作再充电，则有 100%的可能性(1.0 概率)代理在采取该动作后将处于高状态。在决定充值时，代理人只是去了充值站，没有发现任何垃圾，因此最终奖励为 0。
同样，如果它决定等待，代理将肯定(1.0 概率)处于相同的状态低电平。与上面类似，假设在等待的时候，有人过来给了机器人 1 个垃圾，机器人因此获得了 1 的奖励。

那么，什么是马尔可夫决策过程呢？

为了使用强化学习解决现实世界中的问题，我们需要指定环境的 MDP，这将清楚地定义我们希望代理解决的问题。我们上面讨论的例子是一个有限 MDP 的例子。形式上，有限 MDP 被定义为—

状态的有限集合。
一组有限的动作。
奖励的有限集合，r。
环境的单态动力学。
贴现率(我们稍后会讨论这个问题)

结论

总之，这是我们需要用来准备问题的框架，以便我们可以使用强化学习算法来解决它。这适用于间断任务和连续任务。

到目前为止，我们已经学习了什么是强化学习(第一部分)，以及如何通过指定环境的 MDP 来正式准备环境。在下一章，我们将讨论如何解决它。敬请关注。

没那么快:分析、颠覆和组织变革

原文：https://towardsdatascience.com/not-so-fast-analytics-disruption-and-organizational-change-7c0ae9f598ca?source=collection_archive---------10-----------------------

我们最近的一个客户发现自己陷入了困境。他们是一家历史悠久的制造商，拥有业内最大的市值之一。几十年来，在可靠性和质量至关重要的领域，他们一直是客户信赖的供应商。

但是最近，他们的环境发生了变化。“颠覆者”正在进入他们的市场，他们可以以更低的价格销售竞争产品，质量更低，功能更少。这些颠覆者似乎对数字技术掌握得更好，并且擅长使用数据。我们的客户拥有大量数据，但刚刚开始战略性地思考如何利用这些数据来推动未来的增长和市场机遇。随着利润开始下滑，销售转向更便宜、更新的进入者，客户必须应对这种数字破坏。

分析:一种颠覆性的力量

很少有商业理论像克莱顿·克里斯滕森的颠覆理论一样具有影响力和普遍性，正如在创新者的困境中所描述的那样。颠覆理论解释了产品昂贵复杂的老牌企业是如何被产品不复杂但更便宜的新进入者“颠覆”的。随着新进入者的产品被采用，他们的利润增长，他们进一步侵蚀领导者的统治地位。最终，新进入者取代领先者成为该市场的首选供应商。最近在 HBR 的文章(包括克里斯滕森合著的一篇)强调，尽管在后工业时代、后互联网泡沫经济时代，颠覆理论的许多原则仍然适用，但颠覆的性质和速度正在发生变化和加速。

作为这种不断变化的颠覆的一个例子， Wessel 指出，新的颠覆者往往是风险投资、面向软件的企业，它们能够(并经常)筹集大量资金。与老牌竞争对手相比，这些新进入者通常是轻资产的；他们靠股本借钱，而不是信贷。现有的参与者发现很难足够快地筹集资金并投资于他们需要开发的技术和战略，以有效地与颠覆者竞争。

尽管在筹集资金方面处于劣势，但占主导地位的、市场领先的公司确实比他们新的、经验不足的竞争对手有优势:丰富的 数据。老牌公司拥有关于其客户和产品供应的大量信息资源，当通过分析进行探索时，这些资源将揭示颠覆性进入者无法利用的商业价值。由于许多这些根深蒂固的参与者没有将他们的数据视为资产，分析提供了以新方式做新事情的承诺——其自身的一种颠覆。因此，公司正在向数据基础设施、数据科学人才和分析项目投入大量资金，以重振运营、提高效率并开发新产品和服务。根据国际数据公司的估计，数据分析市场将在 2020 年超过2000 亿美元，因为公司将更多的资源投入到这些活动中。

分析:像我们想象的那样具有破坏性？

麻烦在于，老牌公司将分析视为解决他们破坏性问题的*，而不仅仅是将可能的优势 凌驾于他们破坏性的竞争对手之上。这是一个微妙但重要的区别。在我们作为预测分析顾问的 20 多年中，我们看到了成功实施分析的许多障碍，这些障碍也是阻止公司有效应对中断的障碍。其中包括:*

数据不足，无法解决相关问题
遗留的组织结构和 IT 基础设施
不灵活的人员和流程
职能部门之间沟通不畅

Newvantage Partners 最近在进行的一项调查显示，数据计划刚刚开始解决公司在颠覆中面临的问题。如图 1 所示，44.3%的公司成功利用数据投资来确定创新的新途径。然而，35.5%的公司尚未开始以这种方式使用数据。更麻烦的是，48.8%的受访者表示他们尚未开始使用数据来转变未来的业务(只有 48.4%的人表示他们已经开始)。

Figure 1. Survey results of various data initiatives and their success rates (Credit: IDC)

因此，一家公司在分析方面的成功受到许多同样的障碍和限制，这些障碍和限制使这些公司容易受到干扰，很少有公司成功地利用分析来转变他们未来运营的业务。

使用分析作为对中断的响应

尽管分析本身并不是应对中断挑战的解决方案，但有一些经过验证的方法可以确保分析的成功，这些方法应该是任何应对中断的计划的一部分。

制定前瞻性分析策略:对于大多数企业来说，想象一种新的做事方式是非常困难的。然而，这正是颠覆所要求的回应。正如马丁和 Golsby-Smith 所写的，有必要打破“现状陷阱”认为事物只会保持原样的信念。分析提供了以新的方式做出决策的可能性，但它是基于历史证据的。改变不仅仅是把旧的事情做得更好。如果要从数据中提炼出新的见解，那么就应该构建一个分析策略，并以能够实现成功的方式执行。这意味着优先开发原型，收集或获取新的数据源，并重组人员和流程以应对这些挑战。
强调速赢:没有什么比成功更容易让人兴奋。虽然用分析“moonshot”来解决中断可能很有吸引力，但麦肯锡最近的一项研究显示，较小的计划“通常更容易、更快地执行:它们的规模较小，涉及的批准层和协调较少。”他们根据规模或项目价值将计划分为巨石(> 5%管道)、鹅卵石(0.5%-5%)和沙子(< 0.5%)。作者发现鹅卵石和沙子计划的重复影响平均占已实现价值的 50%(见图 2)。获得早期的胜利，并庆祝它们将会产生兴奋并推动变革。

Figure 2. Recurring impact of a project based on size (% of total value)

培养开放沟通和解决问题的文化:尝试新事物将不可避免地导致更频繁的错误或失误。如果你是你所在市场的既定领导者，那么你的流程和结构很可能会针对你当前的解决方案进行优化。从一种效率文化转移到一种敏捷性文化可能会很困难。然而，我们最成功的客户培养了开放沟通的文化，这种文化注重解决问题(而不是羞辱问题)。我们也是根据自己的经历来说的。在 Elder Research，我们在帮助客户时尝试的许多初始或中间假设都没有成功，但那些失败的首次尝试对于提炼和塑造我们有价值的最终交付品是必要的。

例如，我们与一家大型医院系统的持续合作不断取得成功，这要归功于从上到下贯穿整个组织的开放性和尊重。一线员工乐于向他们的领导表达自己的意见，而且表达时考虑周到，彬彬有礼。同样，管理层清楚地表达他们的决策，这产生了信心。

摘要

我们的客户对他们的干扰者有什么反应？他们首先构建了一个强大的数据收集管道和数据存储基础设施。数据治理和标准化很早就得到重视，因为分析模型依赖于高质量的数据。最后，他们确定了其产品组合中可以受益于预测建模的重要产品，并开始开发模型并将其部署到生产中。作为一个敏捷策略，这是一个不断发展的过程，修改正在考虑之中。当结果开始出现时，他们在自我破坏的同时快速学习和成长。

当面临破坏性竞争对手带来的新挑战时，明智的做法是求助于分析来寻找新的业务方式。然而，分析本身并不能解决中断带来的问题。事实上，许多使响应中断变得困难的挑战也是使分析项目脱轨并阻止它们完全成熟的挑战！然而，成熟的参与者可以很好地利用分析作为对中断的战略响应的一部分。他们必须制定前瞻性的分析战略，强调速赢以建立势头和利益相关方的支持，并培养开放沟通和解决问题的文化。然后，成熟的领导者可以获得他们需要的数据驱动的洞察力，以阻止他们所在领域的颠覆浪潮。

请求咨询 讨论前辈研究如何帮助你利用分析手段瓦解竞争对手。

有关系的

阅读博客领导成功的数据分析计划的三大关键

阅读博客制定有效的分析策略:成功路线图

阅读博客避免最致命的预测陷阱

原载于www.elderresearch.com。

[注]统计推断:大局

原文：https://towardsdatascience.com/note-statistical-inference-the-big-picture-b1c1c4099cc7?source=collection_archive---------5-----------------------

罗伯特·e·卡斯，安德鲁·盖尔曼评论

这篇文章包含了我对这篇文章的笔记和相关评论:

卡斯，R. E. (2011 年)。统计推断:大图。统计科学，26(1)，1–9。
盖尔曼(2011)。贝叶斯统计实用主义。统计推断的讨论。统计科学，26(1)，10–11。

这是一篇高水平的论文，从题目就能看出来。它试图把我们从频繁主义者/贝叶斯的泥潭中拉到统计学领域更重要的方面，即模型和真实数据的不匹配。这让我想起了乔治·博克斯的名言:

所有的模型都是错误的，但有些是有用的。

在我看来，这是每个统计学家或数据科学家的好读物。(你可能至少需要一些基本的统计学背景才能读懂它。)论文的某些部分可能需要一些时间来消化，所以每隔一段时间回顾一下是值得的。

统计实用主义

在本文中，卡斯描述了""占主导地位的当代统计哲学，并称之为"统计实用主义"，试图" 将理论假设与真实数据世界的匹配或不匹配置于我们逻辑框架的中心。“而不是教学生“正确背诵置信区间的长期解释”(重点是频率主义者/贝叶斯二分法。)

卡斯认为上面图 3 中描述的标准“大图”故事是“不是一个很好的统计推断的一般描述”，并提出了如图 1 所示的新观点(我认为图 1 更准确)

图 3 试图表达的概念是:

费希尔引入了从一个假设的无限总体中抽取随机样本的概念，而尼曼和皮尔森的工作鼓励了后来的数学统计学家放弃“假设”这个词，转而将统计推断描述为类似于从一个有限总体中简单的随机抽样。

虽然图 1 试图提醒我们:

…寻找重要的假设，询问它们是否合理准确地描述了数据的变化。

为了更加强调“假设”部分，Fishers 的“ 群体均值“ (相对于样本均值*)可以替换为“*”。**

统计思维有两个原则:

“数据中的规律性和变异性**的统计模型，可以通过归纳推理，用来表达噪声存在下关于信号的知识和不确定性。”(“… 将统计推断的来源确定为数据和统计模型之间的假设联系。”)**
"可以对统计方法进行分析，以确定它们的表现有多好."(“… 相同种类的统计模型可用于评估统计程序”)

比较使用概率来描述变化和表达知识:

侥幸概率:用公平骰子掷出 3 的概率是 1/6 ”
认知概率::我 90%确定怀俄明州的首府是夏延。

Bayesians 合并这些，应用概率法则从定量描述到量化的信念，但在每一种形式的统计推断中，偶然概率被用于，以某种方式，作出认知陈述。

现实世界与理论世界

FIG.4. A more elaborate big picture, reflecting in greater detail the process of statistical inference. As in Figure 1, there is a hypothetical link between data and statistical models but here the data are connected more specifically to their representation as random variables.

仔细考虑模型和数据之间的联系是统计实践艺术和统计方法科学的核心组成部分。

"让我们假设数据是正态分布的"是假设"数据的可变性与随机样本中发生的可变性充分一致的简写。

…数据不应与随机变量混淆。随机变量存在于理论世界中。

解释

常客:

频率主义者对置信区间的解释:如果我们从一个 N(，1)分布中抽取无限多个 随机样本，95%的对应置信区间(\ bar —2/7，\bar+ 2/7)将被覆盖。
置信区间的实用解释:如果我们根据上述假设抽取一个随机样本，得到的置信区间(\ bar —2/7，\bar+ 2/7)将有 覆盖 的概率 0.95。代入= 10.2，我们得到区间 I，只要我们的理论世界与产生数据的真实世界一致，我们就能得出有用的结论

贝叶斯:

后验区间的贝叶斯解释:在上述假设下，处于区间 I 的概率为 0.95。
后验区间的实用解释:如果数据是一个随机样本，其中 10.2 成立，并且如果上述假设成立，那么在区间 I 中的概率将是 0.95。这是指随机变量的一个假设值，因为 X 生活在理论世界中，所以这个陈述仍然是理论性的。

(注意在贝叶斯案例中，两种解释都有相同的陈述:“在区间 I 中的概率是/将是 0.95”)

在这里，虽然贝叶斯方法在理论世界中逃脱了间接的信任，但它在数据分析的世界中也逃脱不了，因为仍然存在用随机变量识别数据的附加层。

总之，

频率主义者和贝叶斯推理之间的共同点是理论假设的使用，以及虚拟陈述……该推理基于如果数据是按照统计模型分布的随机变量时会发生什么。如果模型是以准确描述数据的变化，则该建模假设是合理的。****

统计学家

…统计学家以谨慎的态度给出了推论。

“信念的飞跃”——跨越现实理论的桥梁，在没有明确的机会机制的情况下,使统计推理在绝大多数应用中成为可能。

…统计学的独特之处在于，每次应用一个模型时，它都不得不面对理论和现实世界之间的差距，在我看来，这是我们为科学合作者提供的很大一部分。统计实用主义认为，所有形式的统计推断都会做出假设，只能非常粗略地进行测试的假设(用拟合优度方法之类的东西)和几乎永远无法得到验证**。这不仅是统计推断的核心，也是我们领域的大智慧。**

置信区间和假设检验

在 ney man-Pearson 推理理论中，置信度和统计显著性是一枚硬币的两面，置信区间是一组不被显著性检验拒绝的参数值。

在现代贝叶斯方法中，置信区间/后验区间是以假设模型为条件的关于参数的推断的 。假设检验/模型检查是“ 将观察到的数据与模型下的复制进行比较的过程，如果它是真的话 ”。

统计的不同流派

像卡斯一样，我相信哲学辩论可能是一件好事，如果它们激励我们仔细思考我们未经检验的假设。或许，即使是很少相互交流的子领域的存在，也是允许不同的研究分支在多元化环境中发展的进步源泉，如果统计交流被任何单一的不容忍团体所主导，这种方式可能不会如此容易。抽样、推断和模型检验的思想在许多不同的统计传统中都很重要，我们很幸运有这么多不同的思想来启发我们的应用和方法研究

作为一名数据科学家的采访笔记和技术问题:2021 年更新

原文：https://towardsdatascience.com/notes-and-technical-questions-from-interviewing-as-a-data-scientist-in-2018-20e7e3ee4ab3?source=collection_archive---------2-----------------------

在我目前的职位上工作了近三年后，我决定离开去追求一个不同的机会。这给了我采访和发现新公司的机会，同时锻炼了我的技术能力，了解了不同企业的内部运作及其对数据科学的利用。

总的来说，在面试过程中，我发现了一些趋势，我认为这些趋势对任何寻找数据科学家职位的人都有帮助。此外，我还收到了许多技术性的面试问题，这些问题概括了我多次遇到的问题。

需要公司或特定技能的面试指南吗？查看 SQL ，机器学习 ，python，以及* 产品数据科学面试题*

确保“数据科学家”的角色是合适的

在官方数据科学家职位设立十年后，你认为行业应该已经正式确定了工作要求和职责。这不是真的。有些大公司想要荣耀的数据分析师。有些创业公司想要涉足 tensorflow 的软件工程师。还有一些公司想要一名数据科学家，因为他们的首席执行官喜欢保留一个奖杯。

你的实际技能包括什么，你对下一个职位的要求是什么，你应该在面试招聘人员的时候就已经明确了，因为他们会对这两个方面都有要求。你对下一个角色有什么期待？你现在的背景是什么？一般来说，有了这两个问题，你就可以判断出你是否适合一名基于工程的数据科学家(机器学习工程师)，或者可能是一名产品数据科学家(业务驱动的)，或者是天底下所有与数据相关的人。

在面试了前几次后，我想出了如何安抚招聘人员。重复工作要求通常会奏效。但是事后来看，如果我在学习了定义的角色后，实际上不想专注于数据科学领域，那么继续面试又有什么意义呢？它在两端都浪费时间。面试需要大量的时间以及精神和情感上的能量。这使我想到…

永远不要做带回家的作业

这个有争议。我会在一周的任何一天就编码任务进行技术视频或电话面试。我在这个问题上坚持自己的观点，原因有几个，人们可能同意也可能不同意我的观点。

但是如果一定要做带回家的挑战，看看这个就知道怎么过了。**

1。你让自己受制于完全模糊的要求。

在进行技术视频/电话采访时，你在解决问题的过程中获得了总体的增量反馈。每个面试官都知道自己想要什么，如果他们看到你走上了一条不同的/错误的/无用的道路，那么他们会(或者他们应该)用尽可能多的反馈来纠正它，告诉你实际的答案，或者只是一个不正确的答案。在编码任务中，你什么都得不到。你每次都在参加非标准化考试**,评分者很可能有偏见。你可以把全部精力花在分析数据上，去寻找评分者根本不在乎的东西。我接到一个任务，当我问招聘人员时，任务中的要求就像“分析一个数据集，并把它变成一个演示文稿”一样模棱两可，没有任何进一步的澄清。不用说，我不明白为什么我没有通过，也不明白我最终应该做什么。**

2。没有一个真正的时间表。

他们给出的估计是“这项任务通常需要 3 到 6 个小时”以及“大约 2 到 7 天就可以完成”。对我来说，这意味着其他候选人现在要花 6 到 12 个多小时完成带回家的作业。为什么不呢？带回家的作业旨在筛选出候选人，因为你通常会与之前布置作业的其他候选人进行比较。致力于在挑战中做好工作意味着找出问题的每个边缘情况，加上围绕评分者自身偏见的边缘情况。那么，为了超越所有竞争对手，你为什么不花 12 个多小时来完善它，然后告诉招聘人员你“真的只用了大概 3 个小时就完成了？”

3。你通常得不到任何反馈。

有什么比花了 12 个多小时完成一项任务却没有得到工作更糟糕的呢？无法找出自己做错了什么，并利用它迭代到下一个同样需要赋值的位置。

4。你在告诉他们，你的时间比公司的时间值钱。

想象一下，面试五份不同的工作，他们都想要编码任务。想象一下，你实际上只做了他们告诉你要花在这上面的分配数量。在你的全职工作之外，还有 15 到 25 个小时的带回家的枯燥工作，这构成了免费的无薪工作。再见了，周末。再见了，你的决心。也许就和想要编码任务的公司说再见吧。****

注意事项。它们有助于计算出你在工作中将要做的工作。很多时候，初创公司会从他们的数据中抽取一个样本，然后考虑周到地给出模拟实际作业的作业和问题。

这也是未经证实的候选人变得有竞争力的一个好方法。有抱负的数据科学家或研究生应该利用编码作业，并尽全力使其完美。有了无尽的资源和时间，它通常可以让候选人展示出努力工作和付出的精神。因此，虽然对一些人不利，但对另一些人可能是有利的。

我认为真实的面试问题概括了 DS 面试的许多方面

数据科学家技术访谈部分现在包含大约六个主题。

Python 脚本
产品
SQL(或 Python，但基本上是分析)
AB 测试
机器学习
可能性

这些都是我被问到的非常真实的问题。

编辑:想要更多问题和解决方案？在这篇和其他博客帖子流行起来之后，我创建了 面试查询 ，一个练习数据科学面试问题的网站。

Python 脚本

嘶嘶作响
给定一个按顺序排列的时间戳列表，返回一个按周聚合分组的列表列表。
给定一个字符列表、每个字符的先验概率列表和每个字符组合的概率矩阵，返回概率最高的最佳序列。
给定一个日志文件，其中包含以日期、数字和名称字符串为特征的行，解析该日志文件并返回按月份聚合的唯一名称的计数。

阅读更多关于Python 数据科学面试题 这里。

产品

假设 Google Docs 没有被跟踪的指标，一个产品经理找到你，问你会实施的前五个指标是什么？
此外，假设谷歌文档的参与度有所下降。你会调查什么？
假设我们想要实现一个通知系统，用于提醒护士让医院的病人出院。你将如何实现它？
假设在 LinkedIn，我们希望在新的消息平台上为“活跃用户”实现一个绿点。您将如何分析推广 it 的有效性？

以下是关于如何解决 产品数据科学面试问题 以及你将会遇到的五种不同类型的产品问题的深入指导！

SQL

给定一个付款交易表和一个客户表，返回客户的姓名和客户进行的第一笔交易。
给定一个付款交易表，返回每个客户付款次数的频率分布。(即 1 笔交易— 100 个客户，2 笔交易— 50 个客户，等等)
给定相同的付款表，返回累积分布。(至少一个交易，至少两个交易，等等……)
给定一个表—朋友 1 |朋友 2。返回两个好友之间共同好友的数量。

阅读更多关于 sql 中哪些 概念要了解要通过面试

AB 测试

给定 AB 测试漏斗统计数据，如样本大小、注册率、功能 1 使用率、功能 2 使用率，分析哪个变体胜出以及原因。
你将如何设计一个实验来改变注册页面上的一个按钮？
如何知道自己是否有足够的样本量？
如何对多个变量进行显著性测试？
如何减少 AB 测试中的方差和偏差？
向产品经理或非技术人员解释 P 值和置信区间。

机器学习

你会使用什么特征来预测餐馆从收到订单开始准备食物所花费的时间？
你能想出一个你宁愿低估而不是高估的场景吗？
分析一个模型的结果，你如何解释偏差和方差之间的权衡？
解释随机森林模型实际上是如何工作的。
你如何知道你的模型是否有足够的数据？
你如何评价一个模特？(F1 分数、ROC 曲线、交叉验证等…)

这里有一个关于如何解决 机器学习面试问题 以及你会遇到的六种不同类型的机器学习问题的深度指南！

可能性

给定均匀分布 X 和 Y，两者的均值为 0，标准差为 1，2X > Y 的概率是多少？
一部电梯四个人，一栋楼四层。每个人在不同楼层下车的概率是多少？
两个人在同一楼层下车的概率有多大？
给定一副从 1 到 100 的卡片，选择 1 < Pick2 < Pick3?

商业案例问题的概率是多少

我们知道，该产品每月成本为 100 美元，每月平均流失率为 10%，平均客户停留时间约为 3.5 个月。计算每个客户的平均寿命值。****
您如何确定网飞订阅的价格是否真的是消费者的决定因素？
假设你为 Lyft 工作。Lyft 正在测试三种不同的取消费用:1 美元、3 美元和 5 美元。你将如何决定哪种取消费用？

阅读我关于如何接近和利用 数据科学案例研究问题 框架的文章。

是的。数据科学面试很难。

提示:试着找出面试官或网上给你的每个问题的答案。因为如果你失败了，你很可能会在另一次面试中遇到这个问题的变体。还有，这种情况发生的概率有多大？；)

查看一些 模拟面试 这些问题应该如何回答。

最后，雇主正在疯狂雇佣数据科学家

数据科学家的市场仍然非常紧张，因为对于需要增长或赚钱的公司来说，一般角色变得越来越必要。即使我最终要求拒绝编码挑战，我仍然得到了许多公司愿意放弃，将面试过程转换为技术面试。2020 年的数据科学在市场上异常火爆，在这个市场上数据科学家有潜力为业务的许多不同部分做出贡献*。***

随着新冠肺炎导致许多公司裁员，疫情仍有生意兴隆，如door dash沃尔玛亚马逊网飞。然而，最终，由于有这么多的申请人，这无疑增加了竞争相同职位的候选人的供应。********

我注意到的是，与几年前未经证实的经历相比，这次当我开始搜索时，简历上的一点经验有多重要。我鼓励那些希望在没有经验的情况下进入这一领域的人，先做几个项目，以展示在这一领域的整体激情。从根本上说，这份工作在我看来仍然是最酷的工作之一，因为数据科学家可以凭借他们的技能以及他们对不同业务目标的贡献而变得多才多艺。

什么时候一个人能成为任何新工作的第一人？十年真的不是那么长的时间。

感谢阅读

如果你对更多来自我的数据科学面试问题、技巧和诀窍以及指南感兴趣，请查看 面试查询 。
查看我的 Youtube 频道 了解更多数据科学面试技巧、技巧和模拟面试示例！
查看更多关于产品分析师、数据分析师和机器学习工程角色的指南。

JupyterCon 笔记 Jupyter 项目如何实现大规模数据科学

原文：https://towardsdatascience.com/notes-from-jupytercon-how-project-jupyter-is-enabling-large-scale-datascience-a3627a05ea68?source=collection_archive---------12-----------------------

提高企业采用率，新工具/扩展，提高数据科学的新方法。

Credit: O’Reilly Flickr

在刚刚结束的 JupyterCon 2018 大会上，它真的是关于利用项目 Jupyter 的力量进行协作、可扩展、可扩展和可复制数据科学。我参加了为期 3 天的教程、讲座、主题演讲和海报会议(在会上，我介绍了我在自动化可视化方面的最新进展)。下面是 TLDR 对我感兴趣的一些亮点的总结:

Jupyter 已经成为一种在学术和行业环境中轻松共享代码、分析和结果的方式。学校使用它来提供课程，而分析师、记者、研究人员、大型组织等使用它作为一种可扩展的方式来管理他们的数据分析工作流。
企业使用 Jupyter 笔记本正在改变。与临时使用(即员工个人使用笔记本电脑)相反，企业开始探索企业范围内的企业管理 Jupyter 部署。
企业正在扩展 Jupyter 来解决新的问题/用例，并且已经开始将他们的更新作为产品和开源软件(OSS)反馈回来。例子:IBM ( Watson Studio 、Jupyter Enterprise Gateway)、网飞(interact、papermill、commuter、titus)、谷歌(Colaboratory、Dataflow、Kaggle)、亚马逊(SageMaker)等。
访问和安全性正在成为一个重要的焦点领域(谁可以访问笔记本、笔记本的哪些部分、笔记本中的数据/结果)。随着企业(具有良好定义的资源访问策略)将 Jupyter 集成到他们的 datascience 工作流中，定义符合现有策略的模板和数据访问规则变得越来越重要。
需要一种更加谨慎的开源方法。维护一个像 Jupyter 这样的大型开源项目是很困难的，尤其是当负担落在少数人身上的时候。我们需要探索更多的方法来支持社区和维护过程(付费维护者，企业资助等)。

主题演讲—

以下是一些主题演讲和见解的摘要:

来自石溪大学物理和天文学系的威尔·法尔提到了他和超过 1000 名天体物理科学家组成的团队(在 LIGO )如何使用 Jupyter 笔记本分享引力波天文学的成果。

会议联合主席 Paco Nathan 强调了 Jupyter 社区的趋势和主题。他提到了 Jupyter 在大型企业中的采用如何实现快速进步(学生已经知道 Jupyter，不必花时间学习专有工具)，Jupyter 如何在行业(硬件、软件、流程)快速变化的情况下帮助您的基础设施适应未来，以及它如何帮助解决隐私问题。

Jupyter 项目的领导者 Carol Willing 强调了 Jupyter 是如何让用户更容易编写代码并鼓励实验的。然而，她也警告说，挑战可能会限制 Jupyter 项目的成功——自私的用户，他们索取的比给予的多(以牺牲集体为代价最大化个人利益)，维护者的倦怠，维护者的不认可，自满的旁观者等。她还讨论了整合商业模式和赠款作为解决这些问题的方法的想法。

哥伦比亚新闻学院的马克·汉森讲述了一个有趣的故事，讲述了 Jupyter 笔记本如何成为帮助记者将数据、代码和算法整合到数字新闻中的“工具”。他给出了一个学生项目的具体案例，在这个项目中，他们进行了实验，以确定虚假 twitter 账户对信息传播的影响。更有趣的是，实验结果导致了数百万 twitter 账户的大规模清理，以及《纽约时报》发表的数字/印刷文章。

来自 Carpentries 的 Tracy Teal 讨论了他们通过在世界各地举办数百个研讨会来帮助用户培养数据技能的工作。她认为，人是将数据转化为洞察力的关键，并推动了对扩大拥有数据技能的人数的关注。她分享了一段有趣的话

如果你想走得快，就一个人走；如果你想走得远，就一起走。

哥伦比亚大学地球与环境科学助理教授 Ryan Abernathey 解释了为什么我们应该将数据存储在云中。他提到，复杂的问题通常需要大型数据集(TB、PBs ),这些数据集有时会被锁定在缓慢的 FTP 门户或其他本地存储系统之后。然后，研究人员必须创建暗库(数据的本地副本)，这可能是原始数据的子集，会限制他们探索不同研究问题的能力。他提倡使用云(和相关工具)包括- zero3jupyterhub+kubernetes、并行计算(DASK、Spark)、领域软件(xarray、astropy)、云优化数据。他提到，美国宇航局已经开始在这个方向取得进展，承诺在未来 5 年内通过云端点提供数十亿字节的数据。

网飞数据工程和基础设施主管 Michelle Ufford 强调了网飞在 Jupyter 笔记本电脑上下大赌注的原因。她提到笔记本是未来的发展方向，它们不仅仅是提供交互功能，更重要的是

笔记本弥合了技术和非技术团队成员之间的鸿沟。

她讨论了网飞如何在笔记本电脑上投下了巨大的赌注，将超过 10k 的工作流迁移到笔记本电脑。在网飞，他们围绕笔记本创造了多种用例(和工具),包括数据访问、不同任务的笔记本模板，甚至笔记本日程安排！更多信息请点击网飞科技博客。

会谈-

会议联合主席 Brian Granger 发表了关于“利用开源的商业案例和最佳实践”的演讲。他讨论了使用方面的变化(例如来自亚洲的高流量和兴趣)、开放源码软件的回报(免费 3-5 年研发，允许公司专注于核心业务，支持灵活定制)和开放源码软件的风险(破坏性影响、周转缓慢、缺乏企业支持)。他还为有兴趣参与 OSS 项目的企业提出了最佳做法——花时间了解 OSS 的真正需求，从帮助审查 PRs 开始(实际的代码编写构成 OSS 过程的一小部分)。要避免的事情——不要雇佣 OSS 项目维护人员，把他们的时间分配给其他项目；这损害了社区。

来自 NYU 城市科学与进步中心的教授 Julia Lane 讨论了 Jupyter 笔记本如何用于涉及公共政策所需敏感数据的项目。她描述了她在劳动经济学方面的工作如何需要来自多个机构的数据(例如，来自美国国税局等机构的企业数据，以及来自审查局的雇员数据)。这些包含机密的微数据(例如，ein、SSN 等),需要高安全标准。此外，很难实现一个“数据交换所”的等价物，在那里多个机构可以“共享数据”——他们可能没有共享这些数据的动机。她建议采用一种方法，取代信息交换所，围绕特定问题组织数据收集工作，建立完整的团队(数据分析、网络分析、机器学习、文本分析、用户行为等)。)，并培训适当的机构工作人员。

专家组|当前环境——合规、道德、ML 模型解释，GDPR

小组成员探讨了几个问题，包括对 GDPR 的回应。Julia Lane 分享了一些关于 GDPR 如何基于两个有问题的概念的想法——知情同意(她提到这毫无意义)和数据匿名化(她提到数据可以去识别但不能匿名化)。她建议我们更多地走向“数据的道德使用”(也许是数据科学家的希波克拉底誓言)。来自网飞的米歇尔·乌福德也提到所有的数据都是有偏见的，我们不应该问“我的数据有偏见吗”，而是应该问“我的数据有什么偏见”。其他人也鼓励设计自动化偏差测试的工具，并引入模型测试者/破坏者的角色——质疑、测试和破坏模型的个人(相当于传统软件工程开发中的 QA 工程师)。

学习资源

来自彭博的 Chakri Cherukuri 做了一个关于机器学习算法可视化的有趣演讲。笔记本在此—https://github.com/ChakriCherukuri/jupytercon_2018
来自 NYU 的布鲁诺·冈萨尔维斯发表了一篇关于 Matplotlib 数据可视化的教程。https://github.com/bmtgoncalves/DataVisualization

有趣(也有点出乎意料)的是看到像两个适马、第一资本等金融公司在 OSS 中担当领导角色并贡献代码/项目。

结论

pronoun and expertise tags at JupyterCon 2018

会议的组织工作非常出色(我有没有提到午餐时供应的美味热餐？)用体贴的手势让与会者感到受欢迎和融入。从 pacman 规则(当你们聚在一起交谈时，多留一个人的空间)到有助于促进与会者之间交流和互动的标签(围绕兴趣/专长的标签——“雇用我”“我正在雇用”“ML/AI”，首选代词“他/她/他们”等)。).我离开这次会议时，感受到了所做的出色工作、Jupyter 项目社区成员的慷慨精神及其在不同领域的影响。展望未来，我计划用笔记本做更多的事情(分享演示、示例代码等)。

非常感谢会议共同主席帕科·内森、费尔南多·佩雷斯和布赖恩·格兰杰；出色的工作！感谢会议的主办方 Jupyter 项目、奥赖利媒体公司和 NumFOCUS 基金会。感谢第一资本慷慨的奖学金，让我参加这个非常有趣的会议！绝对期待 Jupytercon 2019！

多伦多机器学习峰会(2018)笔记

原文：https://towardsdatascience.com/notes-from-toronto-machine-learning-summit-2018-69ada327cc3e?source=collection_archive---------20-----------------------

本周早些时候，我参加了多伦多机器学习峰会。与我到目前为止参加的会议和其他技术活动相比，这是一次非常不同和令人耳目一新的经历。这篇文章包含了我在会议上的一些笔记，主要是我参加并喜欢的演讲。

会议有四种演讲:主题演讲、研究、应用、商业。让我一个一个来。

**主题演讲:共有 6 场主题演讲(每天 3 场)。**会议以孙铁麟·普塔宁(layer6.ai)、刘可莉(Rubikloud)和 Margaret Wu(格鲁吉亚合伙人)的三个主题演讲开始。由于各种原因，我错过了所有三场会谈的部分内容，但这些会谈的整体情绪似乎反映在刘可莉在《环球邮报》上的一篇文章中，题为:“人工智能不需要更多的研究人员，它需要更多的产品”。这里的 AI 是加拿大 AI 空间。总的来说，虽然研究需要资助、重视和继续，但加拿大也应该成为人工智能的行业领导者。

第二天的主题演讲来自:Philippe Beaudoin(元素。AI)、简·班尼斯特(Real Ventures)、山姆·莱特斯通(IBM)。Philippe Beaudoin 的演讲更像是一个关于人工智能、我们的生活/未来等的一般的哲学视角(就像他的:“一个你希望成为的人的网络”)。

相比之下，珍妮特·班尼斯特(Janet Bannister)的书完全是关于投资者在人工智能初创公司中寻找什么。她详细谈论了不同类型的人工智能初创公司，多伦多/加拿大的当前趋势，她过去与传统公司的经历以及他们对人工智能的反应，最后对未来的趋势进行了一些预测。这些趋势包括:

技术民主化
一切都超个性化
所有公司都将结盟成为科技公司
劳动力的自动化和商品化

Sam Lighthouse 的演讲是关于大脑启发的微芯片、神经语义计算、IBM(和其他公司)如何超越构成当今计算机基础的传统冯诺依曼架构，并探索了在芯片上构建神经网络等想法。看到这项技术在 50 年左右的时间里向何处发展，对比 20 世纪 60 年代的神经网络布线图和 IBM 现在能做的事情，是一件令人着迷的事情。

在我参加的讲座中，我喜欢两个讲座:

Sunnybrook 研究所的 Anne Martel 的“医学成像的机器学习”
多伦多大学的彼得·魏特克的“当代量子计算能为机器学习提供什么吗？

我并不自称是这两个话题的专家。我去参加这些会议只是为了丰富我在会议上的经验，最终我得出了一些关于主题的想法，即使不是完美的理解。

应聘:这是我参加会谈最多的一届。我喜欢的几个演讲是:

**“沃尔玛的零售之旅:从商业智能到人工智能”**作者 prak har mehr otra——这是一个简短但有趣的演讲，讲述了他们如何在沃尔玛使用人工智能结合人类专业知识，以及为什么。虽然不是很详细，但它让我们得以一窥沃尔玛的经营规模，以及人工智能在他们的设置中可以解决的典型问题。
“如何应用自然语言处理来识别有害的在线对话？”IMRSV 数据实验室的 Isar Nejadgholi 这个演讲是关于建立一个分类器来识别网络媒体中不同种类的有害评论。对我来说，这感觉更像是一个研究报告，因为在这一点上似乎没有应用程序与之相关，但了解这种方法非常有趣。当我听说一种方法有效时，我想知道是什么方法失败了。
**“人工智能的可解释性:为什么它很重要，为什么它很难”**Xavier Snelgrove——无疑是本节中参与人数最多的演讲。虽然这个演讲更像是对人工智能可解释性所涉及的不同问题的概述，但幻灯片包含了足够的信息，可供进一步阅读。

**业务:我在这部分参加的唯一一个讲座是:“数据科学团队的敏捷”**作者 Jennifer Prendki(图八)。这应该是我在大会上最喜欢的演讲。自从我从学术界转到工业界后，我经常想知道、思考和阅读这个问题。虽然这次演讲没有彻底改变我的想法，也没有突然让我获得新的知识，但看到一群人在思考这个问题，感觉很好，这是会议中满座的会议之一。不过，我真的希望这篇文章能更长一些，更具体一些。

也有几个平行的小组讨论，但在我参加的那个小组讨论中，我有点走神，因为一个发言者不停地说，语气让我感到惊讶，我在一点后失去了上下文的线索。我没有参加晚上的活动和招聘会。

我喜欢 TMLS 的一些地方:

我职业生涯的大部分时间是一名学者，我的大多数会议都是自然语言处理领域的研究(例如 ACL、COLING、IJCNLP 等)，还有一次是一般人工智能(IJCAI-2007)。所以，我通常习惯在一个会议上看到很多研究报告。今年早些时候，我确实去参加了一个行业风格的技术会议(也是在多伦多)，但每次演讲都像是推销，我在两个小时内就离开了会场。这次会议是一次全新的体验。它自始至终有三场平行会议，一场侧重于研究(演讲者主要是大学教授)，一场侧重于应用工作(演讲者通常是行业专业人士)，一场侧重于业务和管理方面(大多数演讲者是 C 级高管)。我想主题演讲是这三者的混合，还有一些人工智能风投的演讲，这些演讲给出了他们在投资人工智能初创公司时寻求什么的见解。**对我来说，在一个地方进行所有这些不同方面的交易还是第一次。**在这次会议之前，我就像下面这条推文中的这位研究员一样，厌倦了看着所有的 NLP 会议慢慢变成“我的数字比你的好”和“做深度学习或灭亡”的场所:

现在，在 TMLS 之后，我觉得有一个世界在关注 AI/ML 领域的其他东西，而不仅仅是数字游戏。

我觉得很酷，一个七年级学生 Artash Nath 是海报展示者之一——对我来说也是第一次。
我的另一个第一次经历是看到如此多的女性演讲者，其中许多人甚至是首席执行官。作为一名在科技行业工作的女性研究人员，你可以想象这对我有多重要(然而，我们在大多数会议上并没有看到这种多样性！)

一些我不喜欢的东西:

我认为基调太短了。与其有这么多的主题演讲，不如有更少的主题演讲，这样会更长一些。演讲者在分配给他们的短时间内做了很好的工作来浓缩他们的知识！
好像没有被记录下来。对于我们中想同时参加两个平行会议的一些人来说，这会有所帮助。我还参加过其他会议，会上的演讲视频后来都可以看到。

总的来说，这是一个很棒的会议！人们很友好，比我迄今为止参加过的任何会议都更容易接近！总的来说，他们似乎想帮助/指导该领域的年轻人，并对在加拿大建立良好的关系网感兴趣。a 一定要去，如果你在多伦多并且以前没有去过那里的话！

异常检测注意事项#2:全脂或低热量欺诈？

原文：https://towardsdatascience.com/notes-on-anomaly-detection-2-full-fat-or-low-calorie-fraud-9d3c8c084bf8?source=collection_archive---------0-----------------------

上次我概述了为什么剽窃是愚蠢的。

猜猜还有什么是愚蠢的？

数据捏造是愚蠢的。

让我们来看看具体情况。

首先，我有理由相信科学数据“造假”是相当罕见的。

我说的“欺诈”指的是老派的那种:坐在你的地下室，舔舔你的铅笔，然后记下虚构的数字，然后这些数字被表示为科学测量值。然后，好吧，你知道吗——所有那些讨厌的数字，从来没有完全表现自己，突然在正确的地方。稍微修改一下计算，直到一切都如你所愿，把它强加给某个不幸的合著者，出版。迪德里克·斯塔佩尔的方式。

在某些方面，这听起来很容易。有什么比坐在那里敲一些数据更直接(更快，更便宜)的呢？想想效率！

如果没人看见你会怎么被抓？

事实上，这很重要:

以上是一条做诈骗的烂路，
…所以只有白痴才会这么做
…这也是欺诈检测技术主要提醒我们几乎完全是白痴存在的另一个原因。脚注 1

一个更好的欺诈方式是从实际做实验开始，然后从那里改变你需要的东西。

这是欺诈精简版。是低热量诈骗。“2%的欺诈，为了你的数字”。我就不信这不是不诚实。

我怀疑(但无法证明)聪明、不诚实的人知道这种情况下全脂和脱脂的区别。他们可能或明或暗地知道，或多或少，也可能被承认(“我们就是这样得到结果的”)或不被承认(“你说‘我的方法有问题’是什么意思，每个人都是这样做的”)。

但是他们知道。

出现这种情况的原因从直截了当、显而易见到反直觉都有。

伪造的 10 个理由

1。发明真实的假数据介于挑战和不可能之间——取决于具体情况。
发明现实的汇总统计很难，发明现实的数据更难。数据点具有子结构、复杂的相互关系和数学含义，远远超出了作者在展示它们时可能考虑的范围。考虑 Larry Sanna 的论文——发现数据极不可能在组间的变化中没有足够的差异(即 SDs 的 SD 不可能低)。总的来说，那些肤浅到可以发明自己的结果的人没有聪明到预见到这样的事情。

2。真实的(但被篡改的)数据有一个现实的谱系，因为所有其他实验活动都正常进行。 招募受试者，测试细胞，服用药物，保存实验室笔记本，录制视频，进行测试，购买试剂，等等。实验活动的记录存在，这是很容易确定的。

“嘿，X 研究员！这是你编的吗？”天哪，不。这花了我们三年多一百万美元

斯塔佩尔面临的一个主要问题是，他无法解释他的调查数据来自哪里。他的书以一个疯狂的场景开始，在这个场景中，他在全国各地开车，试图为他之前发明的数据编造背景故事:

“所以，在一个火车站和两个大学校园之间，我的故事取得了相当大的进展。但是为什么我让自己这么为难呢？我为什么要告诉人们这项研究是在几百英里外的兹沃勒和格罗宁根进行的，而不是在离家近的地方？这是我在玩的某种游戏吗？我是不是在给自己制造困难，这样我就必须加倍努力去赢得比赛，这样我才能为我所做的感到骄傲…

这行得通吗？这仍然是一个相当奇怪的故事。一位忙碌的教授，他设计了一项研究，然后坐上自己的车，开到美国的另一端，独自在公共场所分发问卷，没有学生或研究助理。谁会相信这种事？"

作伪科学，第一章

3。欺诈性地篡改现实价值的过程与研究人员面临的合法问题非常相似。
研究人员可能经常怀疑他们完全出于善意所做的测量的真实性。放大器故障，电线交叉，环境温度变化，污染发生，病人撒谎和辍学，本科生说奇怪的事情。存在一大堆貌似合理的推脱“坏价值观”的借口。即使这种按摩是广泛和不诚实的，它也是一个必要和监管任务的近亲——确定怪异(或不方便)的数据是否代表测量误差。

4。摆弄乐器甚至不需要有意识的参与。愚弄别人和愚弄我们自己是一个令人不安的连续体。
欺诈需要故意的虚假陈述——只有在最不寻常的情况下，研究人员才可能偶然捏造数据。但是如果你对结果有一个清晰的预期，有未隐藏的数据和强大的压力去产生想要的或预期的结果…好吧，你可以用各种方法从样本中排除数据点以服务于确认偏倚。“看到了吗？我早就知道这是答案！”

I see you, little man! You gon’ die!

5。离群值识别的实践是非标准化的，所以谁能说你“用错误的方式清理了数据”？一般来说，你可以选择你想要的任何一个。

这也表明了对方法论的更广泛的态度，尤其是在社会科学领域，量化是…我会友好地说特别。仔细看一下这个。仔细看了一下这个。

6。上述报告(异常值识别)也不常见和/或不正式要求作为发布条件。
大部分的科学工作都是在没有太多关于如何应用异常值剔除/“下降值”/“清理”程序的信息下发表的。我知道我总是唯一一个在我的评论中要求这些信息的学究。在我的工作中，这通常意味着有人获取心电图，然后对其进行分析，因此我的问题很简单:“这是如何清理的？移除了多少次心跳？每人使用了多少价值？你看到什么异位了吗？”

Bleep bloop. My life in a panel.

答案往往是:“以上都不是。我们没有看到任何错误。”

回答错误！你的意思是(a)“我的软件在我不注意的情况下进行了清理，我不知道它是如何工作的”或者偶尔(b)“我只是留下了错误的值，因为我不知道错误的值是什么样的，因此我的数据很糟糕”。

我们经常听说文件抽屉用于存放没有发现显著结果的已完成研究，但已发表研究中的不良值通常在那个抽屉中有自己单独的小隔间。有时甚至没有人知道那个隔间在那里。

7 .。细节可以侵略性的掩埋。
如果你编造了不可能或有问题的汇总统计数据，你将有一段美妙的时间来解释你是如何毫不含糊地报告它们的。这么说吧:如果你说“1 加 1 等于 9”，那么没人需要看到你的数据就知道你错了。但是，如果你有真实的数据，你可以混淆和抑制。当然，当你发送数据时，你可能会发送一大堆格式不良、难以理解或难以分析的可怕数字。你可以发送一半有效的号码。

A priming researcher prepares a dataset for sharing.

(当然，你可以声称你想从其获取数据的人在‘恶意’操作，然后完全拒绝分享这些数据。)

8。欺诈是该隐的标志。拨弄只是淘气的男孩和女孩。
在科学领域，没有一个人有事后诸葛亮的职业生涯。

然而,“较轻的罪过”显然更易变。她的研究是可耻的业余的，但她最终学会了更好的，嗯，她可能是好的。她当然可以被救赎。但是“有一天，她决定不再伪造她的研究，道歉，现在是诚实的”……对不起，女士。糟糕的科学家会被打得鼻青脸肿，但欺诈是被禁止的。还有很长的路要走，你更有可能被推下去。

9。你和更好的人在一起。 不管结果如何，也不管出于什么原因，“捏造一点”比仅仅编造你的测量值要常见得多:Martinson (2012)报告称，“伪造或‘捏造’研究数据”比“基于直觉认为它们不准确而从分析中删除观察结果或数据点”这类恶作剧要少 30 倍左右。更令人大开眼界的是 John 等人(2012)的断言，即 62%的心理学家报告“在考虑了这样做对结果的影响后，决定是否排除数据”。

“由于操纵真实数据而导致的欺诈”和“由于移除不良观察而导致的有问题的研究实践”从哪里开始，谁也说不准。

10。编造描述性或汇总性的统计数据是危险的。编造数据令人担忧。篡改现有数据的范围从“看起来有点不确定”到几乎无法检测。** 如果你编均值、标准差/SEMs、F 值、p 值、t 值、卡方值等等，那么我们有几个选项。

首先，我们知道它们是如何组合在一起的——我们知道任何一个值是否意味着任何其他值的错误。这就是 StatCheck 所做的，它反算(从 df、p 值和测试统计数据)并匹配所述信息。简单有效。

我们首先知道(受一些限制)你的手段是否能存在。格里姆就是这么做的。同样，如果你的 SDs 和 SEM 可以存在。

如果你的均值和 SDs 可以存在，我们可以用 SPRITE 或类似的更复杂的方法重建它们的真实版本。如果你编造了一个不可能的均值/标准差对，我们很有可能发现这一点。

以上所有的问题是你不能在事后编造数据。你已经选择了不可能的参数，所以数字会直接拒绝符合它们。

结论

让我们现在完全不要担心简单的陈旧的草率和错误，而只是追求上面的逻辑结论。

欺诈不常见，而且相当愚蠢。

然而，“低热量欺诈”发生得更多，影响也更大。

这比直接捏造数据更常见，更难检测，可能是无意识的，显然对一些人来说，这感觉完全符合维护他们的自尊。我怀疑这比我们经常发现的完全胡说八道要普遍得多。

然而，我们仍然需要发现欺诈和异常检测技术，因为发现科学中的不良行为者可以做很多事情，其中之一就是产生大量公众对不良科学行为问题的关注。这不是一个好的宣传，但是像我这样的人会认为这是完全必要的，完全合理的。由于确定的数据操纵引起的高调撤回比任何安静的更正都会产生更多的烟雾。他们对证明科学出版/实践的主体已经病入膏肓，需要相当大的运作这一命题有着巨大的影响。

相信我:假设“13%的论文包含数学上不太可能的数值”，没有人会注意到这一点。如果你说“资深教授 XYZ 因为一桩令人讨厌的欺诈案而不光彩地辞职”，那么全世界都会来敲你的门。

但是，我再一次重复这一点，不要忘记欺诈检测只是找到那些真正犯了错误的人，他们并不多。

它并没有解决问题的大部分——正常的实践逐渐变成了糟糕的实践，不可复制或不可信任的工作不断被灌输到科学意识中。

**欺诈检测技术将而非解决这些问题。**他们需要文化、激励和数据管理的改变——简而言之，基础实践的改变。

“欺诈检测技术主要提醒我们几乎完全是白痴的存在”…到目前为止。这并不意味着我们不在研究新技术等等。我们是。或者，至少，我是。

关于深度学习的矩阵演算的注记

原文：https://towardsdatascience.com/notes-on-matrix-calculus-for-deep-learning-b9899effa7cf?source=collection_archive---------8-----------------------

基于此论文由帕尔和霍华德。

深度学习是一个令人兴奋的领域，正在产生巨大的现实世界影响。本文是基于特伦斯·帕尔和杰瑞米·霍华德的《深度学习所需的矩阵演算》的笔记集。

深度学习都是线性代数。它是使用多层神经网络来解决复杂的问题。模型输入、多层中的神经元权重、激活函数等都可以被定义为向量。训练或利用神经网络所需的操作/转换本质上是非常并行的，同时应用于所有输入。向量/矩阵表示和可以在其上使用的线性代数运算非常适合于神经网络的流水线数据流模型。当输入、权重和函数被视为向量并且值流可以被视为矩阵上的操作时，数学变得非常简单。

深度学习也全是差异化！计算导数/用某种方法测量变化率在优化损失函数的训练阶段至关重要。从一组任意的网络模型权重 w 开始，目标是达到一组“最优”的权重，以便减少给定的损失函数。几乎所有的神经网络都使用反向传播方法来寻找这样一组权重。该过程包括确定权重值的变化如何影响输出。基于此，我们可以决定按比例增加或减少权重值。测量输出如何相对于权重的变化而变化与计算输出 w 相对于权重 w 的(偏)导数是相同的。对于所有层中的所有权重，对于所有训练示例，该过程重复多次。

矩阵微积分结合了数学的两个基本分支——线性代数和微积分。绝大多数人都是孤立地接触线性代数和微积分的。这两个话题本身就是重量级的。没有多少本科课程是以矩阵微积分为重点的。在研究反向传播等概念时，人们通常依靠直觉来弥合理解上的差距。大多数机器学习算法中的反向传播步骤都是关于计算导数和更新向量和矩阵中的值。大多数机器学习框架自己做繁重的工作，我们永远不会看到实际的导数被计算出来。然而，理解这在内部是如何工作的总是好的，如果你打算成为一个严肃的从业者或者从头开始开发一个 ML 库，这是必不可少的。

而论文则是面向 DL 从业者和编码者的，本质上是数学化的。关注符号以巩固你的理解是非常重要的。特别注意矢量的形状(长的或高的)，变量是标量还是矢量，矩阵的维数。向量用粗体字母表示。未经训练的眼睛可能不会注意到粗体 f 和斜体 f 字体之间的差异，但这在试图理解等式时会产生很大的差异。矢量的形状和方向也是如此。我走了很多兔子洞，试图理解一些东西，却发现我最初对这些术语的理解是错误的。

一件好事是函数概念的定义方式(以及计算其导数的方法)从简单到复杂。首先，我们从由 f ( x )表示的简单参数的函数开始。函数和参数 x 都是标量(用斜体表示)，我们可以用传统的求导规则来求 f(x) 的导数。第二，我们将会看到的这种函数通常有许多相关的变量；形式为 f (x，y，z)。为了计算这种函数的导数，我们使用相对于特定参数计算的偏导数。处理这种函数的微积分分支是多元微积分。

将输入变量 x，y，z 分组为粗体的向量 x ，我们可以将输入参数向量的标量函数表示为 f ( x )。这个域的演算将是向量演算，其中 f ( x )的偏导数被表示为向量本身，并且服从于各种向量运算。最后，对深度学习最有用的是同时表示多个这样的函数。我们用 f ( x )来表示一组形式为*f(x)的标量函数。*微积分对于这一领域是最普遍的，即矩阵微积分。

概括地说， f(x) 是标量变量的标量函数(使用简单的导数规则)，而 f ( x )是矢量变量 x 的标量函数(使用矢量演算规则)，而 f(x) 是许多标量值函数的矢量，每个函数依赖于一个输入矢量 x (使用矩阵演算规则)。摘要:本文演示了如何计算简单函数的导数，以及多元微积分中偏导数(∂/∂x)、向量微积分中梯度∇ f 函数、矩阵微积分中雅可比矩阵 J 之间的关系。不严谨地说，∇f(x)函数是 f 的偏导数以向量形式的集合。 f(x) 的雅可比基本上是一个个**∇f(x)的按行堆叠而成。**

在计算偏导数的过程中，本文做了一些假设。重要的是要记住这些概念最终将应用到的最终产品，即计算输出函数(y = w.x +b)和损失函数的偏导数。这篇论文通过预示它们将在哪里被使用而提供了一瞥。第一个假设是向量 x 的基数等于 f 中标量函数的个数。这就产生了一个漂亮的正方形雅可比矩阵。如果你想知道为什么它们需要相等，考虑这样一种情况，即神经元 xi 的每个输入都与一个权重 wi 相关联(这里的标量函数类似于 xiwi )，因此我们有多少个 x 就有多少个 w*

另一个重要的假设是关于元素的对角属性。基本上，该属性声明 f(x) 中的 ith 标量函数是(仅)向量 x 中的 ith 项的函数。同样，当您想到常见的神经元模式用例时，这更有意义。输入 xi 的贡献与单个参数 wi 成比例。假设基于元素的对角属性使雅可比矩阵(通过第一个假设变成正方形)成为对角矩阵，所有非对角项为零。

**本文接下来的几个部分解释了计算更复杂函数的导数的过程。函数从简单到复杂有几种方式。首先，考虑通过对两个向量(当然，大小相同)应用元素式二元运算符而得到的函数。这些是形式为 f(x，y) = **x + y，或max (x，y)的函数。注意，在这种情况下，x，y 是矢量。接下来，还有标量扩展函数，它是通过将标量乘/加到一个向量上得到的(可能会让我们中的一些人想起 Numpy 中的广播)。这种运算包括将标量“扩展”到与向量相同的维数，然后执行逐元素的乘法、加法运算。例如 y = x + b ( y，x 是向量)意味着 b 被扩展为向量 b 并逐元素添加到x

**第三，考虑将向量中的值折叠成单个值的函数。最常见的例子是计算神经网络的损失，通常形式为y=sum(f(x))。这里 y 是通过将向量 **f(x)的元素相加得到的标量值。文中计算了这三种情况的导数。有些函数可以更复杂，为此要使用导数的链式法则。本文描述了简单标量函数的链规则，并逐步将其扩展到最通用的向量链规则。

克莱姆甘笔记

原文：https://towardsdatascience.com/notes-on-the-cramer-gan-752abd505c00?source=collection_archive---------1-----------------------

以下讨论与最近的论文有关:

《克莱姆距离作为有偏瓦瑟斯坦梯度的解决方案》
https://deep mind . com/research/publications/Cramer-Distance-Solution-Biased-瓦瑟斯坦梯度/

这篇文章会有点长，所以我从一篇 TL 开始；博士首先，在大于 1 的维度上，*论文没有使用克莱姆距离！*在第五节的 GAN 实验中，使用了能量距离【1】。因此，该模型是使用特定内核的类似于[ 3 ， 4 ]的生成矩匹配网络。由于能量距离是一个整数概率度量，由[ 5 提出的方案可以用于训练输入特征到内核，这比[ 3 改进了结果。我将在下面的第 1 节中对此进行解释。

总的来说，这是一个好主意，并且似乎给出了很好的生成器样本。不幸的是，Cramer GAN 的论文提出了一个有问题的近似，这意味着该算法中的 critic 不能正确地比较发生器和参考(目标)样本分布:即使发生器和参考分布非常不同，您也可以获得零 critic 损耗。我会在下面的第 2 节中解释这个问题。

提出类似想法并同时出现的论文[ 6 ]似乎也取得了不错的效果，使用了不同的(高斯)核和深度特征。论文[ 7 ]也是相关的，并没有使用[ 5 ]的优化，而是使用了方差控制方案，同样得到了很好的结果。

现在谈谈细节。

第一部分:能量距离，见证函数，梯度惩罚，核选择

论文中的批评者是能量距离【1】(在他们论文的第 5 页，作者声明，在生成多维样本 d > 1 时，他们使用能量距离，而不是克莱姆距离)。在[ 2 中显示，这个距离属于积分概率度量(IPM)家族，就像 Wasserstein 距离一样(相比之下，KL 和反向 KL 发散是 f-发散，而不是 IPM)。具体而言，能量距离是最大平均差异(MMD)，首先用于训练[ 3 、 4 ]中的生成模型(这些被称为生成矩匹配网络)。如果您不熟悉 MMD，请参见下面的附录 B 获取简短介绍。IPM 公式是允许我们应用方法[ 5 ]训练 GAN 的基本属性。

积分概率度量通过寻找平滑函数(“见证函数”)来测量概率分布之间的距离，该函数最大化两种分布下的期望差异。因此，如果 P 是您的生成器样本的分布，Q 是您的参考样本的分布，那么您将寻找一个平滑函数 f，其中 E_X f(X) — E_Y f(Y)很大，其中 X 来自 P，Y 来自 Q，E_X 表示 P 下的期望值。方法[ 5 ]引入了一个惩罚，以在训练期间，在生成器和参考样本之间的点处，保持评论家见证函数的梯度接近 1。所以只要我们有了见证函数，就可以用[ 5 ]。

能量距离的见证函数是什么？为了弄清楚这一点，我们使用了内核的最大均值差异这一事实:

k(x，x') = d(x，0) + d(x '，0) — d(x，x ')，(1)

其中 d(x，x’)是 x 和 x’(见[ 2 ，定义 13]，忽略 0.5 的因子)之间的距离，而“0”是原点(这实际上是中等字体中的零…)，使用这个核，以及[8，2.3 节]中的见证函数的表达式，我们可以推导出等式 1 上面的见证函数 f*(x)的表达式。5 在克莱姆甘论文(否则似乎出现在哪里！).我在下面证明了这个结果(附录 A )。

正如[5]所建议的，你可以惩罚批评家损失中见证函数的梯度；或者可以使用[9]的早期“剪辑”方法，这是由[6]完成的，也工作得很好。

作者声称能量距离核可能是 GAN 训练的更好选择。我不相信这个论点:理论上

尚不清楚为什么和不变性和比例不变性对于 GAN 训练是必不可少的。和不变性也适用于任何平移不变核，包括高斯核(证明很简单)！事实上，策克利和里索已经证明了能量距离的和与标度不变性，所以不清楚为什么作者在命题 3 中重复这些早期的证明。
无偏梯度估计在更广的范围内是正确的，不仅仅是能量距离。在一定条件下，莱布尼茨规则意味着无偏估计量具有无偏梯度，MMD 对任何核都有无偏估计量[8]。

实验上，我也不相信这种核选择是该方法有效的主要原因，因为[6，7]使用不同的核，也获得了良好的结果([6]使用良好的旧高斯核)。另一方面，作者在他们的附录 D 中声称比高斯和拉普拉斯核更稳定的训练。可能[5]的方法是训练 MMD GAN 的关键，但是注意[6]使用削波，而[7]使用方差控制而不是惩罚梯度，因此[5]不是使其工作的唯一方法。

第二部分:批评家是不正确的

不幸的是，这篇论文做了一个有问题的近似，导致评论家不能正确地比较和匹配发电机和参考分布。这是可以解决的:[6]和[7]已经提出了不存在这个问题的方法，并且效果很好。

为了理解这个问题，可以将 x 和 x’视为来自发生器 P 的独立样本，y 和 y’视为来自参考分布 q 的独立样本，能量距离为:

D(P，Q) = E_{X，X'} d(X，X') + E_{Y，Y'} d(Y，Y') — E_{X，Y'} d(X，Y') — E_{X '，Y} d(X '，Y)

其中 E_{X，X'} d(X，X ')是来自生成器 P 的两个独立样本之间的预期距离(同样，Y 和 Y '是来自参考 Q 的独立样本)。让我们来理解这是什么意思:第一项是来自生成器的两个样本之间的平均距离。第二个是两个参考样本之间的平均距离。最后两项都给出了发生器和参考样本之间的平均距离。换句话说，如果来自发生器的样本与参考样本具有相同的分布，则所有项都将相同，并将抵消，当 P=Q 时，给出的能量距离为零。

我们现在转向由评论家在 Cramer GAN 论文的算法 1 中实现的距离。从算法 1 中的评论家见证 f(x)的定义，我们看到用于评论家的预期“代理损失”是:

D_c (P，Q) = E_{X，X'} d(X，X') + E_ d(Y，0) — E_ d(X，0) — E_{X '，Y} d(X '，Y)

简而言之，有问题的近似是用原点 0 代替 y ’,在这一点上，批评家对 P 和 Q 之间距离的解释就失去了。很容易得出完全不同的 P 和 Q，但预期的临界损失为零。对于一个简单的一维示例，假设 P 将其所有样本放在原点，Q 将其所有样本放在距离原点 t 的位置。显然 P 和 Q 是不一样的，然而

E_{X，X'} d(X，X') = 0
E_ d(Y，0) = t
E_ d(X，0) = 0
E_{X '，Y} d(X '，Y) = t

所以 D_c (P，Q) = 0，批评家误以为 P 和 Q 是相同的。很难预测这个问题会在论文的图 9 和图 10 这样的复杂例子中引起什么问题，但是对于更小尺寸的简单玩具例子，很快就会发现 P 和 Q 没有正确匹配。最后，请注意[6]和[7]不做这种近似，不受影响。

参考

[1]能量距离对应于一维中的克莱姆距离，但是我们不使用 GANs 来生成一维中的样本。参见策克利和里佐在他们 2004 年的论文“测试高维中的相等分布”。

[2] Sejdinovic，d .、Sriperumbudur，b .、Gretton，a .和 Fukumizu，k .，“假设检验中基于距离的统计和基于 RKHS 的统计的等效性”，《统计年鉴》，(2013 年)

[3] Dziugaite，G. K .，Roy，D. M .，和 Ghahramani，Z. (2015 年)。基于最大平均偏差优化的生成神经网络训练。子宫活动间期

[4]李，y .，斯维尔斯基，k .，泽梅尔，R. (2015)。生成矩匹配网络。ICML

[5]古尔拉贾尼、艾哈迈德、阿尔乔夫斯基、杜穆林和库维尔(2017 年)。改进了瓦瑟斯坦·甘斯的训练。arXiv 预印本 arXiv:1704.00028。

[6]李春林、张文春、程、杨和博佐斯(2017 年)。甘:加深对矩匹配网络的理解。arXiv 预印本 arXiv:1705.08584。

[7]优素福·姆鲁，汤姆·塞尔库，费希尔·甘，https://arxiv.org/abs/1705.09675

[8]a . Gretton，k . m . Borgwardt，m . Rasch，M. J .，schlkopf，b .和 Smola，A. (2012 年)。两样本核检验。2012 年，JMLR

[9]马丁·阿约夫斯基，苏史密斯·钦塔拉，莱昂·博图，瓦瑟斯坦·甘，https://arxiv.org/abs/1701.07875

附录 A:见证函数的推导

根据[8，第 2.3 节]，见证函数为(直到比例常数):

f*(x) = E_X k(x，X) — E_Y k(x，Y)，(2)

其中 E_X k(x，X)表示内核相对于其参数之一的期望值，X 取自 P，Y 取自 q，将内核(1)代入第一项，我们得到:

E_X k(x，X)
= d(x，0) + E_X d(X，0) — E_X d(x，X)

上述表达式的第二项是常数。代入(2)，

f*(x) = d(x，0) — E_X d(x，X) — d(x，0) + E_Y d(x，Y) + C
= E_Y d(x，Y) — E_X d(x，X) + C

其中 C 是常数，可以忽略。这给出了期望的见证函数。

附录 B:MMD 概述

最大平均差异(MMD)是两个概率分布之间距离的简单度量[8]。在 GAN 情况下，P 定义为发电机分布，Q 定义为参考分布。那么 MMD 的平方就是:

MMD (P，Q) = E_{X，X'} k(X，X') + E_{Y，Y'} k(Y，Y') — E_{X，Y'} k(X，Y') — E_{X '，Y} k(X '，Y)

其中 k(x，X’)是 X 和 X’的“相似度”，E_{X，X’} k(X，X’)是来自生成器 p 的两个独立样本的期望“相似度”

我们如何解读这种距离？我们利用 k(x，x’)是一个核的事实，即 x 和 x’的特征的点积。当 x 和 x '相似时，它是大的，当它们不同时，它是小的。回到我们的 MMD 表达式，第一项是来自生成器的两个样本之间的平均相似性。第二个是两个参考样本之间的平均相似度。最后两项都给出了发生器和参考样本之间的平均相似性。换句话说，如果来自发生器的样本具有与参考样本相同的分布，那么所有的项都将是相同的，并且将被抵消，从而给出零 MMD。

MMD 是一种整数概率度量，就像沃瑟斯坦距离一样。该度量的见证函数在上面的附录 A 的等式(2)中给出。

关于使用什么内核:这是一个漫长而又传奇的问题！但是简单地说，一个众所周知的内核是“高斯”(指数平方)内核，

k(x，x') = exp (- d (x，x') * a)

其中 d (x，x’)是 x 和 x’之间的平方欧几里德距离，a 是宽度参数。另一个内核是情商。(1)在前面的文档中，这是用于获得能量距离的内核。这两种核都给出了有效的整数概率度量来衡量 P 和 q 之间的距离。还有许多其他选项，对于什么对 GANs 最好还没有明确的共识。

新型卡车、新型联合收割机:

原文：https://towardsdatascience.com/nouveaux-trucs-nouvelles-combines-197fea82a00c?source=collection_archive---------5-----------------------

让开发人员的生活更轻松的开源工具

不久前，处理数据的困难源于这样一个事实，即数据来自不同的地方，以不同的形式存在，其中大部分是非结构化的，或者充其量是半结构化的。将这些数据整理成可供分析并用于提供见解的形状是一个繁琐的过程，数据清理和准备是一个耗时的过程。我在其他地方提到过关于“大数据的肮脏小秘密”，事实是，“大多数数据分析师花费绝大部分时间清理和整合数据，而不是实际分析数据。”这个秘密也涵盖了数据分析师的需求，他们不断地去找数据库管理员和编码员，请求他们运行这个 SQL，然后“请再多问一个问题”。在最近的过去，获取数据的例行程序是重复和耗时的，人们正在做那些软件擅长的任务。问题是我们倾向于使用的软件工具没有高度的灵活性。在主要部分，由于开源应用程序，这些天的景观非常不同。

devOps

在基础架构级别，大量数据涌入，甚至逐渐增长的数据集都需要物理和手动操作，调试新服务器、添加内存、添加另一个磁盘都需要 John 拿出螺丝刀来完成。云改变了这一切，Peter 按需编程了更多的内存、更多的磁盘空间和更多的处理器。事实上，这些都不是新的，容器就像旧的 Unix 监狱一样:重要的是它们可以被使用的规模。现在有了新的技巧，可以通过新的工具组合和保存数据的方式来实现。随着时代的发展，我们现在该如何解决这些问题呢？首先，让我们看看发生了什么变化。

devOps 存在于三个域中；文化、工具和技术，以及建筑。

文化转变对后端工程师来说是一个巨大的飞跃。他们已经习惯了程序员使用敏捷技术，但是服务器和网络需要螺丝和电缆以及工程师来连接它们。打破系统工程师、系统管理员、操作人员、发布工程师、数据库管理员、网络工程师、安全专家和程序员、需求工程师、应用程序设计人员、测试人员、UX 设计人员之间的界限是这种文化转变的关键。

在技术领域，可用的工具和技术，如 Jenkins 和 Codeship 提供了持续集成和持续部署。像(木偶和主厨)这样的配置管理工具打开了流程编排——使手工流程自动化。一系列工具简化了部署，其中最前沿的是 Docker 和 Kubernetes 。

devOps 是由许多动机驱动的。来调节、繁殖和逆转。它包括:

希望合理化依赖关系管理，供应和配置堆栈的所有组成部分。
对可再现部署的要求，以便整个应用程序可以被擦除，然后准确地再现。
创建同一应用程序的多个实例的能力，以及在资源调配期间的任何时间点从故障中恢复的能力。

noSQL

在数据库级别，关系数据库处理结构化数据，核心组件“模式”一旦保存了任何数量的数据，就不容易更改，毕竟模式是最重要的结构。新一代的数据存储, noSQL 和 graph 比 RDBMS 数据库更好地处理了非结构化数据。列品种如 Cassandra 和 HBase 文档库如 CouchDB 和 MongoDB 。键值存储 Couchbase ， Redis，Riak。以及 Neo4J 等图形数据库。

大数据的大父亲也不能错过这一考虑，即 Apache Hadoop ，它带有 Hadoop 分布式文件系统(HDFS)YARN一个作业调度器和集群资源管理器，以及 MapReduce 一个旨在处理大量数据的并行处理系统。还有许多其他的包可以和 Hadoop 放在一起。有许多供应商提供基于云的 Hadoop 平台，包括 AWS Elastic MapReduce 和 IBM BigInsights 。

为什么 noSQL 是这样一个游戏改变者？它开辟了处理结构化、半结构化和非结构化数据的途径。因为能够处理多态数据；设计和配置数据存储所需的时间大大减少。灵活的结构允许快速部署。增加供应以处理高速度、快速增长的数据量和各种数据要容易得多。

在采用 noSql 数据存储之前，很难令人满意地建立和运行一个分布式数据库。复制提供了一种广泛而方便地分发只读数据的方法，但是让事务性数据分布在两台服务器上却是一场噩梦。克服主-主复制中隐含的怪物的唯一方法是分区、分段和分片，这两种技术都无法使用关系数据库实现灵活的部署。随着 noSql 数据存储在任意数量的服务器上自动写入数据，分片现在已经是小事一桩。noSql 数据存储被设计为在云中工作，被设计为灵活和敏捷，并且被设计为满足现代数据分析和交付需求。

平台

不仅仅是数据存储的变化标志着新的做事方式。平台已经发生了变化，PaaS ( 平台即服务)产品的进步极大地减轻了开发人员提供基础设施的复杂性；可扩展且廉价的云计算服务。数据库即服务 DaaS，如 Mlab 和 Googlebig query提供类似的平台和数据库功能。

AWS 使廉价的、可扩展的分布式云计算成为可能，即使界面有点混乱。过去，这鼓励编写自定义界面和例程来浏览和使用它，现在第三方供应商正在填补这一空白。对于开发环境，有“AWS made easy”产品，如 Heroku 和 CloudFoundry 以及 AWS 上的elastic search&Kibana平台。

GoogleApp Engine是一个支持 Spring Framework 和 Django web framework 的平台(它也是软件控制的基础设施，提供了一个带有自己查询语言的 noSql 数据存储库)。

OpenStack 在某些方面针对平台提供商，因为它提供 IaaS(基础设施即服务)。 OpenShift 则是真正的 PaaS 它带有 Docker 打包和 Kubernetes 容器集群管理，它提供了应用程序生命周期管理功能和操作工具。

平台是现收现付的，你在上面运行的工具主要是开源的。选择哪个平台的问题和答案总是来自于“你想用它做什么？”。对于生产部署来说，直接管理自己的平台可能更便宜，但是在生产环境中，为开发和测试 PaaS 提供者提供实例更有吸引力。根据规模，基础架构基础 IaaS 可能是构建的起点，或者真正的平台基础 PaaS 可能是正确的选择。对于较小规模的生产环境(和开发)，第三方平台托管解决方案可能更具成本效益。

一盒盒的把戏

集装箱化主要通过对建筑设计、开发策略和 PaaS 产生巨大影响的 Docker 发展成熟。Google 提供了 Google 容器引擎(GKE ),这是一个集群管理和容器编排系统，用于运行和管理 Docker 容器。反过来，它由 T2 的 Kubernetes T3 提供支持，这是为了快速部署应用程序而设计的；允许动态扩展，从而轻松推出更新并减少资源使用。

Docker / Kubernetes 组合提供的调节、复制和回滚功能涵盖了从“开发到生产”的整个领域。在本页提到的所有技术中，它们是使架构使开发运维成为可能的技术。在这个意义上，他们完成了 devOps 循环。

室内设计

现在我们已经看到了操作领域背后的工具和架构的变化；是时候看看开源是如何实现新的功能和能力的了。我们有了系统，我们要用它做什么，我们有了建筑，我们要把什么放进去，我们要怎么做。

理解的机器

似乎是为了锦上添花，AWS 和谷歌都提供了大量基于云的开发工具、分析、机器学习、计量计算和存储解决方案和基础设施。深度学习库，如谷歌的 TensorFlow 和雅虎的 CaffeOnSpark 已经开源。有易于部署的开源搜索解决方案，如弹性搜索和 Sphinx 。除了作为弹性堆栈一部分的搜索工具，还有弹性可视化工具 Kibana。其他优秀的可视化库，如 D3j 和JavaScript InfoVis Toolkit正等着提供见解。

开源的 Python 和 R 库使得统计分析更加容易。像 Clojure 和 Docjure 这样的语言非常适合处理提要或文档中包含的信息。简单的 API 访问机器学习技术，如 IBM 的 Watson 和 Amazons AML 现在由我们支配。其他机器学习即服务 MLaaS 包括: DataRobot 、 BigML 、 Rapidminer 和 Algorithma 。

除了 API 访问，还有其他利用机器学习的灵活方式。Algorithma、DataRobot 和 BigMl 提供了算法开发者和应用开发者接口的平台。开发人员可以简单地将开源学习算法整合到他们的应用程序中。这再次充分利用了开源的力量。大多数众所周知的算法都经过了同行评审，有很好的文档记录，并针对速度和效率进行了优化:它们可以在最有用的库和语言(Java、R、Python、Spark 等)中获得。).

有问题可以问，有答案可以得到。

通用语和多国语言

虽然面向对象编程语言包含了灵活性，但是诸如封装、继承、聚合、鸭式类型、后期静态绑定和动态多态性等概念使得代码变得更加灵活。这种灵活性是以速度为代价的，因为许多对象是单独创建和销毁的。这些概念在向用户、视图层或人机界面呈现逻辑的程序部分上工作得很好，但是当被调用来处理应用了逻辑的大量数据时，它们是非常低效的。

回归到更具表达性的语言和函数式编程范式，现在允许以较低的计算开销涉水通过大量数据，换句话说，有一些语言非常适合处理大量的列表和数据，是的，它们已经以这样或那样的形式存在了很长时间。

具有讽刺意味的是，跨越语言障碍的巨大转变来自于更多元语言的出现。我喜欢在 GWT 工作的想法，因为它允许我用 Javascript 做我不知道怎么做的事情。事实上，它将 Java 编译成 Javascript 看起来确实有点疯狂，但它确实允许你以自己想要的方式编写代码，也许现在这一切都有意义了。然而现在有太多的其他语言，在这个列表中有近 200 种编译成 javascript 其中有 CoffeeScript 和 Dart 。

意味着栈为节点以及与之相伴的 NPM 等工具提供了一个入口，同时类似于鲍尔等其他包管理器，鼓励高效的生产管理。

在接口层面，编程库现在有了成熟的工具，如 GO 、 React 和 Angular ，它们将优秀的旧 javascript 带到了新的地方。在移动前端的 JavaScript 框架上，比如 Bootstrap 和 Foundation ，通过 HTML、CSS 打理响应视图。这些创建现代网站的工具提出了一个问题我们还需要应用吗？尽管名字叫“will”进步的网络应用会让“apps”过时。如果“应用程序”仍有一席之地；苹果开源了 Swift，这是编程史上发展最快的语言之一。

由于我们现在已经掌握了使用旧技术和新兴技术的新方法，我们可以寻找新的方法来提供解决方案，以处理新的想法和数据组合。

首次发表于 XCiPi 博客上2016 年 2 月 13 日

11 月版:艺术与数据科学

原文：https://towardsdatascience.com/november-edition-art-data-science-4789c30da4ea?source=collection_archive---------21-----------------------

8 篇必读文章

我们当中可能很少有人没有看过一件艺术品并肃然起敬。我最近在芝加哥艺术学院时有机会体验了这一点。当我站在我一直以来最喜欢的画作之一，爱德华·霍普的《夜鹰》前时，我能感觉到这幅画散发出的原始能量包围着我，让我能与这位艺术家交流。在那次经历之后，我开始思考艺术的整体及其多种形式。

当被问及*“什么是艺术？”我总是倾向于直接把绘画、素描和摄影作为答案。但是我意识到我的定义太狭隘了。把艺术想象成任何视觉、听觉或表演的人工制品，它表达了艺术家的想象力和情感，同时在观察者身上产生了对人工制品的美和情感力量的欣赏，这就更全面了。唷！这个定义太拗口了！*

"艺术使我们能够发现自我，同时又失去自我。"—托马斯·默顿

好消息是这个新的定义为数据科学打开了艺术的世界。我们可能没有想到这一点，但是我们写的每一行代码都可能是一件艺术品！即使事实并非如此，数据科学中的不同技术已经在艺术领域得到应用。本月的版本重点探索不同艺术领域的各种技术。我们从我的旧定义开始，看看绘画、素描和照片。图像处理的用途首先是介绍如何使用深度学习来检测赝品，这使我们能够在市场上开放艺术品供应以及推荐系统。从那里，我们访问神经类型转移，长期短期记忆模型，并将其应用于二维和三维图像。为了结束图像处理部分，我们来看看如何制作生成性对抗网络来创建新颖的图像。

最后三篇文章涵盖了不同的艺术领域:音乐、电影和设计。在我们对音乐的观察中，我们探索了基于艺术家音乐特征的聚类以及对这些特征的深入比较。使用自然语言处理技术来分析电影的字幕，以帮助作者学习一种新的语言。最后一篇文章使用卷积自动编码器创建了一个室内设计搜索引擎和一个草图到图像引擎，然后应用于时装和纺织品设计。我希望你和我一样喜欢这个选择！快乐学习！

TDS 编辑助理 Andrew DeCotiis-Mauro 。

机器学习时代的艺术鉴赏

由凯瑟琳黄 — 5 分钟阅读

作为一名数据科学新手，我对真正的数据科学家如何解决现实世界的问题很感兴趣。阅读了 Kaggles 上发布的许多挑战，我在寻找这些专家如何应对有趣比赛的见解。一个让我吃惊的挑战是“数字画家”挑战。它要求参赛者开发一个程序，可以识别同一位艺术家的画作。

用于艺术的数据科学、机器学习和人工智能

由 Vishal Kumar — 6 分钟阅读

数据科学、机器学习和人工智能是计算机科学中已经渗透到世界各地许多行业和公司的领域。它们的采用几乎肯定与过去十年“大数据”的兴起有关。

艺术家的人工智能

由关明生·拉詹 — 12 分钟读完

艺术和技术的历史总是交织在一起的。历史上发生的艺术革命是由制作作品的工具促成的。燧石刀的精确性使得人类能够用猛犸象象牙雕刻出第一批形象艺术作品。在当代，艺术家使用从 3D 打印到虚拟现实的工具，拓展了自我表达的可能性。

神经网络和 3D 程序内容生成的未来

由山姆·施奈德手持 — 8 分钟读取

甘戈:与甘戈一起创造艺术

由肯尼·琼斯 — 13 分钟阅读

我们本学期学习 GAN 的主要动机是试图将 GAN 衍生的模型应用于小说艺术的生成。深度学习中与艺术生成相关的许多工作都专注于风格，特别是特定艺术作品的风格。

Spotify 的“这是”播放列表:50 位主流艺术家的终极歌曲分析

由詹姆斯·勒 — 15 分钟阅读

每个艺术家都有自己独特的音乐风格。从献身于木吉他的艾德·希兰，到精通说唱艺术的德雷克。从能在流行歌曲中唱一些疯狂高音的阿黛尔，到在 DJ 台上创造 EDM 魔术的 Kygo。音乐是关于创造力、独创性、灵感和感情的，它是跨越差异连接人们的完美门户。

Leuk Taal:通过数据科学(和艺术)学习一门新语言

拉斐尔·皮埃尔 — 8 分钟阅读

当我开始学习荷兰语时，我惊讶地发现这种语言反映了荷兰人是多么的直接和客观。你很少会看到一个荷兰人为了掩饰而制造借口或修饰，或者假装喜欢某样东西或某个人。

des . ai . gn——用人工智能增强人类创造力

由诺曼·迪·帕洛 — 6 分钟读完

人工智能和计算机科学讨论最多的一个方面是机器****是否有创造力**。这个讨论和第一台计算机一样古老，但是最近来自生成性对抗网络和类似架构的惊人结果确实使这个讨论变得更大。**

我们也感谢最近加入我们的所有伟大的新作家，杰瑞米·s·科恩，罗伯特·桑德尔，德米特里·斯托罗申科，克里斯·鲍，拉塔马，马克斯·盖尼斯，法比奥·内维斯，斯泰西·罗纳根，比利·惠伦，萨提亚·努格拉我们邀请你看看他们的简介，看看他们的工作。

11 月版:语音识别

原文：https://towardsdatascience.com/november-edition-speech-recognition-27159b2c44f5?source=collection_archive---------4-----------------------

6 篇必读文章

通过 Tensorflow 识别声音来检测蝙蝠

由罗兰梅尔滕斯 — 10 分钟阅读。

上周我发现我的公寓后面有蝙蝠。我立即抓起我的“蝙蝠探测器”:一种将蝙蝠用来回声定位的超声波信号从听不见的频率范围转换成听得见的频率范围的装置。

你现在能听到我吗？远场语音

由 Jerry Lu — 9 分钟读完。

在这篇文章中，我将研究价值链的第一步，语音信号的最初拾取，并找出创业公司可以成功的机会。

教程:Python 中的异步语音识别

通过 Pres Nichols — 5 分钟读取。

一个(相当)简单的技术，用于使用 Google 有点儿有点儿令人困惑的语音识别 API

tensor flow 中的音频处理

由达里奥·卡扎尼 — 6 分钟读完。

在这篇文章中，我们将解释我们如何实现它，并提供代码，以便短时傅立叶变换可以在计算图中的任何地方使用。

语音识别:懒狗入门

由卢西恩·利塔 — 8 分钟读完。

我和一个好朋友最近在吃饭时聊起了语音识别应用。没错，我们就是那些人。隔着一张桌子，刻板的极客们对技术、创业和变革变得兴致勃勃。

用 cleanNLP 分析关于难民的公共话语

由汉娜韩嫣 — 3 分钟阅读。

继上一篇文章之后，我将分析联合国难民署演讲中以行动为导向的话语，并使用 r。

我们也感谢最近加入我们的所有伟大的新作家，基里尔·叶列缅科，桑吉夫·阿格拉瓦尔，拉塞尔·朱尔尼，费利克斯·莫尔，塔库马·塞诺，马克西姆·扎克斯，海蒂·沃特豪斯，乌戈·库普契奇，卡德·基拉里，塞巴斯蒂安·金特罗我们邀请你看看他们的简介，看看他们的工作。

现在我们可以理解由深度神经网络创建的图像

原文：https://towardsdatascience.com/now-we-can-understand-images-created-by-deep-neural-networks-506d0f8456dc?source=collection_archive---------7-----------------------

与深度神经网络(DNNs)相关的高度先进的算法的兴起，导致了创建计算机生成的图片的能力，这些图片没有告诉人眼机器制作的细节。

人们正确地指出了这个问题的潜在安全风险。然而，科学家设计了一种方法来理解这些照片。

采取措施实现更好的图像分类

深圳大学的一个研究小组开发了一个系统，该系统利用一系列特征对真实图像和生成的敌对网络(GAN)制作的图像进行分类。它着眼于真实图像和生成图像之间颜色成分的变化。

科学家们意识到，统计差异的存在取决于一个人是传统地捕捉图像——比如用相机——还是主要使用计算机来制作最终产品。

他们的研究显示，DNN 生成的图像在特定的色彩空间——图片中定义的色彩范围——看起来不同。

检查颜色统计的差异

具体来说，他们发现这两种图像在 RGB 颜色空间看起来很相似，但在 HSV 和 YCbCr 颜色空间没有统计上的相似性。

该团队在三个图像数据集上测试了他们的理论，以证实他们发现的有效性。

这些实验验证了将颜色分量特征集与二元分类器相结合允许在 GAN 样本在手时辨别两种图像之间的差异。并且，如果用户不知道 GAN 模型是否存在，他们可以使用具有一类分类器的相同特征集。

二元分类器在机器学习领域很常见。然而，如果一个数据类有大量的数据，这样的分类器可能不能充分执行，使单类分类器更合适。

在他们研究论文的摘要中，该团队解释说，当区分真实照片和深度网络生成的(DNG)照片时，他们的方法给出了高度准确的结果。

竞争 dnn 如何帮助图像变得更真实

一种称为深度卷积生成对抗网络的学习架构使用两个 dnn 来生成越来越真实的图像。

一个 DNN 制作图像，而另一个 DNN 检查图像的质量并发回报告，第一个 DNN 使用该报告来改进未来的性能。这些系统创造出高度逼真的艺术作品和其他高度细致的作品，证明了技术的能力。然而，深圳大学的研究人员表示，他们的工作表明，计算机还不能在真实图像中产生几种颜色属性。

人类无法检测到计算机创建的图片，但由于团队的工作，机器学习可以。科学家强调这项研究只关注一种属性。因此，未来的工作可以着眼于其他特征。然后，从事机器学习的其他人可能会更加熟悉使计算机生成的图像不同于真实事物的因素。

dnn 通常模仿 RGB 图像

在完整发表的研究论文中解释这项工作时，作者说 DNNs 通常模仿 RGB 颜色空间中的图片进行模仿。

然而，研究人员分辨图像之间差异的方法也可以改进计算机生成的图片。他们说，未来的工作应该检查与 DNG 图片相关的其他图像限制。

使得图像有效性更加可靠

人们常说，有些事情要亲眼看到才会相信。

不幸的是，在这个图像生成技术如上文所述的时代，人们很容易看到伪造的图像，并将它们误认为是真正的文章。

然而，这项新的研究带来了增强的检测方法，这可能有助于维护声誉。

例如，一家受人尊敬的报纸可能会雇用一名数据科学家，在向全世界发布图像之前，使用上述技术检查图像。或者，一家公司可能会在与员工会面讨论一张可能导致失业的照片之前做同样的事情。

技术意味着个体不一定能相信自己看到的每一个图像。

但是，来自深圳大学的科学家们帮助推动了大数据的发展，并推动了机器学习的进步，这些进步可以应用于各种工作，并减少了图像的表里不一。

图片由 Pixabay 组成

裸体检测和滥用内容分类器—研究和使用案例

原文：https://towardsdatascience.com/nudity-detection-and-abusive-content-classifiers-research-and-use-cases-d8886bf624e8?source=collection_archive---------6-----------------------

Web 2.0 革命导致互联网上每天产生的内容爆炸式增长。社交分享平台，如脸书、推特、Instagram 等。他们的每日活跃用户数量增长惊人，但在监控用户生成的内容方面却一直处于分裂状态。用户在评论帖子时上传不适当的内容，如裸体或使用辱骂性语言。这种行为会导致欺凌和报复色情等社会问题，也会妨碍平台的真实性。然而，如今在线生成内容的速度如此之快，以至于几乎不可能手动监控所有内容。在脸书上，每 60 秒钟就有 13.6 万张照片被上传，51 万条评论被发布，29.3 万条状态被更新。在 ParallelDots，我们通过机器学习解决了这个问题，建立了一个算法，可以以非常高的精度对裸照(裸体检测)或辱骂内容进行分类。

在我们之前的一篇博客中，我们讨论了我们的文本分析 API 如何识别 twitter 上的垃圾邮件和机器人账户，并防止他们在 Twitter 分析中添加任何偏见。添加了另一个重要的内容审核工具，我们发布了两个新的 API——裸体检测 API 和滥用内容分类器 API。

裸体检测分类器

**数据集:**从不同的网站抓取裸照和非裸照建立数据集。我们从不同的裸体图片论坛和网站抓取了大约 200，000 张裸体图片，而非裸体人体图片则来自维基百科。因此，我们能够建立一个巨大的数据集来训练裸体检测分类器。

**架构:**我们选择了 2016 年何等人提出的 ResNet50 架构的分类器。从互联网上抓取的数据集被随机分为训练集[80%]、验证集[10%]和测试集[10%]。在训练集上训练的分类器和在验证集上调整的超参数的准确率略高于 95%。

滥用内容分类器

**数据集:**与裸体检测分类器类似，滥用分类器的数据集是通过从互联网(特别是 Twitter)收集滥用内容来构建的。我们确定了某些与辱骂性和攻击性语言相关的标签，以及其他与非辱骂性语言相关的标签。这些推文被进一步人工检查，以确保它们被正确分类。

架构:我们使用长短期记忆(LSTM)网络来训练滥用分类器。LSTMs 将句子建模为基于上下文的遗忘-记忆决策链。通过在 Twitter 数据上训练它，我们给了它一种能力，让它能够理解含糊不清、写得很差、充满微笑和拼写错误的推文，仍然能够理解内容的语义，并将其归类为辱骂。

让分类器发挥作用:内容审核的用例

辱骂内容和裸体检测分类器是从社交媒体源、论坛、消息应用等中过滤出此类内容的强大工具。在这里，我们将讨论这些分类器可以发挥作用的一些用例。

用户生成内容的提要

如果你拥有一个手机应用程序或网站，用户可以在上面积极地发布照片或评论，你将很难保持订阅源没有辱骂内容或裸照。当前让用户标记这些内容的最佳实践是一项不可靠且耗时的任务，需要一个人工版主团队来检查每个标记的内容并采取相应的行动。在此类应用上部署滥用和裸体检测分类器可以提高您处理此类内容的响应时间。一个完美的场景是，系统会将内容标记为不适当，并在内容进入公共提要之前提醒其中一个版主。如果版主发现内容被错误地归类为裸体检测或辱骂(误报)，她可以授权内容上线。这种机器增强的人类审核系统可以确保您的订阅源没有任何不适当的内容，并且您的品牌声誉保持完整。

论坛审核

最大的互联网发明之一是以观点、评论、问答等形式动态生成内容的能力。在论坛上。然而，这样做的一个缺点是，这些论坛经常充斥着垃圾邮件和辱骂性的内容，导致诸如欺凌等问题。在许多这样的论坛中，隐藏在匿名墙后面的这些内容会对青少年和学生造成灾难性的影响，常常导致自杀倾向。使用滥用分类器可以帮助你的论坛所有者缓和的内容，并可能禁止重复犯罪者的用户。

评论审核

类似于论坛审核，人们可以使用滥用分类器来保持博客的评论部分没有任何滥用内容。所有新闻媒体网站目前都在努力保持其内容的安全和不被滥用，因为它们涵盖了不同的争议话题，如移民、恐怖主义、失业等。保持评论区没有任何滥用或攻击性的内容是当今每个新闻出版商的首要任务之一，滥用分类器可以在打击这种威胁方面发挥重要作用。

众包数字营销活动

依靠众包内容的数字营销活动已被证明是一种非常有效的策略，可以推动品牌和消费者之间的对话，如 Dorito 的“粉碎超级碗”比赛。然而，消费者在这种竞赛中上传的内容必须被仔细监控，以保护品牌声誉。手动验证每个提交的内容可能是一项繁琐的任务，ParallelDots 的裸体检测分类器可用于自动标记裸体和辱骂内容。

过滤数字广告中的裸露内容

随着数字内容创作的爆炸式增长，广告交换越来越受欢迎，并且仍然是大多数博客、论坛、移动应用等的唯一盈利来源。然而，另一方面，有时主要品牌的广告会出现在含有裸露内容的网站上，损害了它们的品牌声誉。在一个例子中，农民保险的广告在一个叫 DrunkenStepfather.com 的网站上提供，这主要归功于基于交换的广告购买的增长。该网站的标语是“我们喜欢和漂亮的女孩一起玩”，并不适合投放农民保险广告。

广告交易所和服务器可以集成 ParallelDots 的裸体检测分类器 API，以识别裸体图片出版商或广告商，并在广告滚雪球般变成公关危机之前限制广告投放。

如何使用裸体检测分类器？

ParallelDots 的裸体检测分类器可以作为 API 与现有应用程序集成。该 API 接受一段文本或一幅图像，并实时地将其分别标记为滥用内容或裸露内容。上传一张图片这里直接在浏览器里试试裸体检测 API。此外，检查滥用内容分类器演示，这是可用的这里。深入研究 API 文档中的裸体检测和滥用内容分类器，或者查看 GitHub repo，以您选择的语言开始使用 API 包装器。

两个分类器都会为传递给它的内容计算一个 0 到 1 的分数。1 分意味着该内容最有可能是辱骂性的或裸体的，而接近 0 分意味着该内容可以安全发布。

parallel dots AI API，是由 ParallelDots Inc 提供的深度学习支持的 web 服务，可以理解大量的非结构化文本和视觉内容，为您的产品提供支持。您可以查看我们的一些文本分析API和视觉智能API，并通过填写此处的表格或在 apis@paralleldots.com 给我们写信来联系我们。

用 Supervisely 和 Tensorflow 进行车牌检测(上)

原文：https://towardsdatascience.com/number-plate-detection-with-supervisely-and-tensorflow-part-1-e84c74d4382c?source=collection_archive---------0-----------------------

深度学习现在被广泛使用。神经网络在计算机视觉任务中有许多有趣的应用。本教程将向您介绍如何用supervisory和 Tensorflow 轻松构建车牌检测系统。

如果你没有听说过超级监管，你可以在我们的介绍帖子中了解更多。

本分步指南由两部分组成:

第 1 部分:在人工生成的数据上训练神经网络。
第 2 部分:在真实数据上微调神经网络。

所有资源都可以在 github 获得。

什么是超级监管？

每个数据科学家都知道什么是 Tensorflow 。几天前，我们在 Deep Systems 的团队发布了supervised，让开发者和研究人员更容易处理训练数据集。

现有技术的神经网络架构有许多开源实现。但是深度学习模型非常“数据饥渴”。

“深度学习算法有许多参数需要调整，因此需要大量数据，以便提出某种程度上通用的模型。因此，从这个意义上说，拥有大量数据是为这些方法提供良好训练集的关键。”

Quora 工程副总裁 Xavier Amatriain。

众所周知，在大多数情况下，数据科学家将大部分时间花在训练数据准备上:

创建私有数据集
将它们与不同格式的几个公共数据集合并
添加各种数据扩充

而他在做这些的同时，很大概率会犯很多错误，或者在数据准备过程中做错一些事情。

Source: http://dilbert.com/strip/2014-05-07

和

Source: https://9gag.com/gag/aDoBnGK

超级解决这些问题。它提供了最佳的简单性和性能—它是一个基于 web 的框架，允许导入所有最著名的公共数据集，使用集成的注释工具创建自己的数据集，使用各种数量的扩展将数据集合并和导出为不同的格式等等。

在本教程中，我们将向您展示如何使用 Supervisely 来解决现实世界中的车牌检测任务。

预览训练数据

用真实数据创建大型特定任务数据集几乎总是既困难又昂贵。通常的做法是在可能的情况下生成人工数据集。

幸运的是，我们可以为我们的任务做到这一点。出于教学目的，我们生成了 10k 图像数据集，在带有噪声、小旋转和不同比例的随机背景上带有号码牌。为了简单起见，我们将使用灰度图像。这个数据集可以在 Supervisely 的数据集库中免费获得。

Here are the few examples of artificially generated images with number plates.

要开始使用该数据集，请创建或登录进入 Supervise.ly 账户。

注册后，您将在您的帐户中看到以下内容:

要开始使用“牌照”数据集，请单击“导入”选项卡，然后单击“数据集库”子选项卡。在此页面上，您可以看到可用现成数据集的列表(该列表将被积极丰富)。

让我们点击“车牌”数据集。下一步是为创建的项目键入名称。姑且称之为“Anpr 教程”:

然后点击“下一步”按钮。选择所有复选框，然后单击“上传”。

您将被重定向到任务列表。从数据集库中导入数据集的任务将在几秒钟内完成。

现在你可以点击主菜单中的“项目”标签。你会看到项目“Anpr 教程”(左图)里面有单个数据集“人造的”(右图):

单击数据集打开注记工具。下面的 gif 展示了注释器工具的一些功能。在本教程中，我们将只使用它来预览图像。

所以。现在我们有一个数据集的帐户和项目。在我们进行模特训练之前，只剩下一步了。我们应该导出这个数据集。

导出培训数据

在我们开始之前，让我说几句关于数据集导出功能的话。当我们设计神经网络时，我们从计算图的角度来考虑它。这是流行的深度学习框架背后的核心抽象。计算图由数学运算和变量组成。

我们开发了强大的数据集导出工具，该工具提供了用计算图形配置导出的可能性。我们可以定义将应用于所选数据集中每个图像的操作顺序。

只需单击主菜单中的“导出”选项卡，然后将 json 配置(如下所示)粘贴到文本框中。

[
  {
    "dst": "$sample01",
    "src": [
      "Anpr tutorial/artificial"
    ],
    "action": "data",
    "settings": {
      "classes_mapping": {
        "Licence plate": "plate"
      }
    }
  },
  {
    "dst": "$sample_bb",
    "src": [
      "$sample01"
    ],
    "action": "bbox",
    "settings": {
      "classes_mapping": {
        "plate": "plate_bbox"
      }
    }
  },
  {
    "dst": [
      "$sample_train",
      "$sample_test"
    ],
    "src": [
      "$sample_bb"
    ],
    "action": "if",
    "settings": {
      "condition": {
        "probability": 0.98
      }
    }
  },
  {
    "dst": "$train_tagged",
    "src": [
      "$sample_train"
    ],
    "action": "tag",
    "settings": {
      "tag": "train",
      "action": "add"
    }
  },
  {
    "dst": "$test_tagged",
    "src": [
      "$sample_test"
    ],
    "action": "tag",
    "settings": {
      "tag": "test",
      "action": "add"
    }
  },
  {
    "dst": "artificial_samples",
    "src": [
      "$train_tagged",
      "$test_tagged"
    ],
    "action": "save",
    "settings": {
      "images": true,
      "annotations": true
    }
  }
]

系统会自动在右侧生成这样的图:

让我们看一下我们的例子。蓝框是数据变量，紫框是操作。关于所有可用导出层的详细说明，您可以在这里找到。

在本例中，我们从项目“Anpr 教程”的数据集“人造”中获取图像。此数据集的所有标注都是多边形，因此我想将它们转换为边界框。在这种情况下，它并不重要，但在其他教程中，例如，当我们从 Cityscapes 数据集导出汽车和行人周围的边界框时，它将非常有用(所有注释都显示为多边形)。

然后我们分割数据集进行训练和测试。每个图像以 98%的概率落入训练集中。此后，所有训练图像将保存为标签“测试”，所有测试图像-标签为“测试”。

好吧，让我们点击“开始导出”按钮。您将被重定向到包含导出任务的页面。等待几秒钟，直到“人工样本”任务完成。

现在，您可以单击“三点”按钮或“下载”图标，下载包含培训/测试图像和注释的结果档案。

该档案的结构如下:

让我们看看它是什么。整体存档是项目，“Anpr 教程 _ _ 人工”是数据集。“img”目录包含图像，“ann”目录包含 json 格式的每个图像的注释。

训练模型

需求:安装了 GPU 和 docker 的电脑。

首先，我们应该通过键入以下命令来克隆教程存储库:

git clone [https://github.com/DeepSystems/supervisely-tutorials.git](https://github.com/DeepSystems/supervisely-tutorials.git) && cd supervisely-tutorials/anpr

之后，将下载的数据集提取到“数据”目录。您应该得到以下“数据”目录结构:

现在让我们转到“docker”目录。它包含 Dockerfile 和两个用于构建映像和运行容器的脚本。在“anpr/docker”目录中运行以下命令:

./build.sh
./run.sh
# now you are inside the container.
jupyter notebook

“jupyter notebook”命令的输出如下:

只需复制最后一个链接并粘贴到浏览器。您链接中的令牌将与我的不同。在您的浏览器中，您将看到:

我们打开“experiment1.ipynb”吧。点击“单元格->全部运行”。该示例将:

加载所有训练和测试数据
可视化一些带有注释的随机图像
训练神经网络并保存到“数据/模型 _artif”
加载模型并在随机测试图像上进行测试
随机训练图像上负载模型和测试

单元格[12]的输出如下。它只是可视化一些随机图像及其来自训练集的注释。

然后模型训练 20 个纪元。输出应该是这样的:

Epoch: 0, Score: 632.081665, Epoch per minute: 0.000000
Epoch: 1, Score: 0.031625, Epoch per minute: 7.076456
Epoch: 2, Score: 0.020695, Epoch per minute: 7.555644
Epoch: 3, Score: 0.015778, Epoch per minute: 7.724735
Epoch: 4, Score: 0.011812, Epoch per minute: 7.804142
Epoch: 5, Score: 0.007921, Epoch per minute: 7.864671
Epoch: 6, Score: 0.005887, Epoch per minute: 7.877275
Epoch: 7, Score: 0.003385, Epoch per minute: 7.888540
Epoch: 8, Score: 0.002968, Epoch per minute: 7.895694
Epoch: 9, Score: 0.002555, Epoch per minute: 7.902217
Epoch: 10, Score: 0.002133, Epoch per minute: 7.925616
Epoch: 11, Score: 0.001715, Epoch per minute: 7.935624
Epoch: 12, Score: 0.001581, Epoch per minute: 7.936112
Epoch: 13, Score: 0.001396, Epoch per minute: 7.969603
Epoch: 14, Score: 0.001210, Epoch per minute: 7.999257
Epoch: 15, Score: 0.001140, Epoch per minute: 8.019996
Epoch: 16, Score: 0.001603, Epoch per minute: 8.059043
Epoch: 17, Score: 0.001414, Epoch per minute: 8.080978
Epoch: 18, Score: 0.001150, Epoch per minute: 8.102449
Epoch: 19, Score: 0.001129, Epoch per minute: 8.097572
Epoch: 20, Score: 0.001273, Epoch per minute: 8.128981
Epoch: 21, Score: 0.001324, Epoch per minute: 8.141784
Epoch: 22, Score: 0.000929, Epoch per minute: 8.133494
Epoch: 23, Score: 0.001333, Epoch per minute: 8.143423
Epoch: 24, Score: 0.000930, Epoch per minute: 8.146000
Epoch: 25, Score: 0.000900, Epoch per minute: 8.138766
Epoch: 26, Score: 0.000948, Epoch per minute: 8.148882
Epoch: 27, Score: 0.000853, Epoch per minute: 8.138941
Epoch: 28, Score: 0.001174, Epoch per minute: 8.148271
Epoch: 29, Score: 0.000871, Epoch per minute: 8.154097
Epoch: 30, Score: 0.000740, Epoch per minute: 8.143948
Finished in 221.023122 seconds.

之后，加载保存的模型并预测随机测试图像的边界框。这里我们可以看到模型做得很好。

让我们看看随机列车图像上的模型预测。该模型完美地预测了火车图像的包围盒。

我希望你一切顺利。如果没有，欢迎在评论中提问。

现在，我们来详细看看一些脚本部分。我想简要讨论两个关键时刻:

我如何处理来自主管的培训数据
神经网络体系结构

在接下来的教程中，了解注释格式将非常有用。对于每个图像，我们都有 json 文件。这里有一个例子:

{
    "name": "00009975_H314CO08",
    "tags": [ ],
    "objects": [
        {
            "classTitle": "plate",
            "description": "",
            "tags": [
                "H314CO08"
            ],
            "bitmap": *null*,
            "points": {
                "interior": [ ],
                "exterior": [
                    [
                        32,
                        24
                    ],
                    [
                        32,
                        40
                    ],
                    [
                        95,
                        40
                    ],
                    [
                        95,
                        24
                    ]
                ]
            }
        }
    ],
    "size": {
        "width": 128,
        "height": 64
    }
}

这个 json 文件只包含一个 json 对象。现在，我将向您解释一些字段:

【名称】:对应的图像名称
“标签”:图像标签(字符串数组)。
“size”:以像素为单位的具有图像“宽度”和“高度”的对象。
“objects”:给定图像的注释数组。

注释对象的字段:

“classTitle”:对象类名。它本教程我们只有一个类，它是“板”。但是在我们的其他教程中，你将使用多个职业。
“tags”:给定对象的字符串标记数组。在这里我们可以看到，我存储地面真相号码牌文本有机会在未来做光学字符识别。
“点”:具有两个字段的对象。管理存储特定格式的对象。“外部”场是对象的外部轮廓。“内部”场是孔轮廓的阵列。

现在是讨论神经网络架构的好时机。这个网很小，但它可以很容易地检测出我们任务中的车牌，而且质量很好。此外，该模型速度非常快，可以在嵌入式设备上使用。

下面是网络计算图的示意图:

模型非常简单:它是基本卷积、relu 和池操作的序列，最后是几个完全连接的层。模型预测车牌包围盒的坐标。

结论

在这部分教程中，我们已经向您展示了如何使用 Supervisely 和 Tensorflow 轻松构建车牌检测系统。我们使用人工生成的数据来训练简单但有效的神经网络。

在本教程的下一部分，我们将在真实数据上微调我们的模型。这种两阶段训练是深度学习研究人员的常见做法。

详细讲解如何使用 Supervisely 进行训练数据准备，有助于我们在以后的教程和日常工作中进行数据处理。

欢迎在评论中提出任何问题，并订阅我们的博客。我们将定期添加新的教程和最新神经网络架构的解释。

谢谢大家！

数值积分:龙贝格积分

原文：https://towardsdatascience.com/numerical-integration-romberg-integration-3f54002ab538?source=collection_archive---------3-----------------------

使用数值方法积分

我欣赏这种整合的概念，主要是因为在我们在课堂上讨论的方法中，这是唯一一种考虑消除其错误的方法。虽然不是全部，但淘汰真的很有帮助。

首先，让我们也用自顶向下的方法来处理这个问题。我们一般先讨论数值积分，然后再讨论龙贝格积分。

数值积分

历史背景

要得到名字背后的原因，这个是需要的部分。

数值积分也被称为“数值积分”或“定积分的数值逼近”。它的名字来自古代计算曲线图形面积的方法，其中最著名的是“圆的平方”问题，这意味着找到一个与给定圆面积相同的正方形。

主要动机

顾名思义，数值积分就是对一个函数进行积分。然而，我们不是已经会积分了吗(还记得数学 50 系列)？对，但也要记住，我们用公式来积分，并不是所有必须积分的函数都可以用这些公式来积分。他们只是普通的特例。

通过公式不可积分的积分的例子有:

它们可能看起来很简单，不像拥挤积分那样疯狂，但是它们仍然超出了我们以前学过的特殊公式的范围。

假设和答案的性质

我们设定假设，所以我们不会一次又一次地讨论它们。还有，答案的本质，明确我们应该期待什么样的答案。

假设:

一般认为积分的区间是有限的
在很大程度上假设被积函数‘f’是连续光滑的

答案性质:“我们寻求单一数字的答案”

这意味着我们不是在寻找一个函数或者一个符号公式。这将数值求积与微分方程的解、不定积分的计算以及许多符号计算的软件包区分开来。

最后一件事之前，移动过渡到龙贝格。众所周知，积分是一个无穷和。我们在这里做的是用一个有限和来逼近一个无限和。

现在我们过渡到龙贝格。

假设在跳到这里之前，已经掌握了复合梯形法则的知识。尽管我们在下面讨论另一个先决条件。

先决条件:理查森推断

主要思想

Richardson 外推法主要是一种提高某些数值方法精度的简单方法。这个可以消除错误。虽然它只能消除以下形式的错误:

理查森外推一般形式的推导

这一部分将说明如何通过理查森外推法消除误差。

假设:

我们有一个近似的方法来计算某个量 G
结果取决于参数“h ”,因此 g(h)的近似值由下式给出:G = g(h) + E(h)

正确推导:

方法:龙贝格积分

既然我们已经建立了先决条件，让我们进入主要的事情。

龙贝格整合

龙贝格积分法结合了复合梯形法则和理查森外推法。

下面是集成过程的概述:

这正是我们正在做的

这告诉我们，我们需要计算两个箭头从哪里来，来计算两个箭头指向哪里。积分的最精确估计总是数组的最后一个对角线项。这个过程一直持续到两个连续对角线项之间的差变得足够小。

以上概述可以总结为公式:

CTR 的意思是复合梯形法则

用 Romberg 积分求积分

放下所有需要的工具后，我们展示如何使用它们。我们先给出一个例子，然后我们给出建议的一般过程

举例:

首先，我们得到所有的工具(公式):

然后我们得到了上面的矩阵 R，因为这是我们将要填写的

一般流程

因此，我们实际上可以看到建议的解决方案模式。我们总结如下:

**挑战:**使用龙贝格积分计算积分

**需要公式:**复合梯形法则和龙贝格

流程:

提示:拿着另一张包含矩阵 R 的纸

计算 h
使用 CTR 计算前两行的第一列
对于 i>1，使用 Romberg 公式计算该行中的下一列
对每一行重复步骤 1-3，直到它收敛到所需的解决方案。

总的来说，

数值积分只是积分的近似，对于不能用特殊公式计算的积分是有用的。其中一种方法是龙贝格积分。从课堂上教授的方法中可以看出，这是通过使用 Richardson 外推法消除误差的唯一方法(尽管不是所有误差都被消除),如推导中所示。

尽管复合辛普森的 1/3 规则胜过复合梯形规则和 Rombeg，但 Romberg 仍然保持着高效的王牌，并且还采用了复合梯形规则的稳健性。

数值插值:自然三次样条曲线

原文：https://towardsdatascience.com/numerical-interpolation-natural-cubic-spline-52c1157b98ac?source=collection_archive---------2-----------------------

探索分段插值的强大功能

Photo by Mitchell Luo on Unsplash

当我第一次听说这个方法时，我被它迷住了，尤其是它的推导过程。这篇文章将向你展示我是如何破解它并使它变得更简单的。我们将使用自上而下的方法,确保你在阅读的时候能够更好地理解它。

数值插值

简而言之，它要求:

我们如何使用一个函数来拟合所有这些数据点呢？

我们所指的函数也叫做插值函数或插值函数。

插值、近似和曲线拟合之间的区别

插值通常与逼近和曲线拟合相混淆。它们之间差异的关键在于它们与数据的吻合程度以及使用的适当性。

插值与逼近

在插值中，你精确地拟合所有的数据点，而近似，顾名思义，就是近似。

就适当性而言，内插法适用于平滑此类噪声数据，而不适用于数据点易受实验误差或其他重大误差源影响的情况。拥有大量数据点也会增加插值的负担。另一方面，近似主要适用于计算特殊函数的库例程的设计。这是由这些函数的性质决定的——精确的值被认为是不重要的，并且在某种程度上，当近似值起作用时是低效的。

插值与曲线拟合

在曲线拟合中，我们不会拟合所有的数据点。这就是为什么我们有残差的概念。在插值中，它强制函数拟合所有数据点。

现在我们知道我们在谈论哪一类，让我们缩小到用于插值的函数族。

用于插值的函数族

(2)这里考虑的两个函数族:

多项式内插法
分段插值

扰流板:自然三次样条正在进行分段插值。但是让我们稍后解释这两种方法来欣赏它们。

1。多项式插值

多项式插值是最简单也是最常见的插值类型。它的一个特点是总是有一个最多 n-1 次的唯一多项式通过 n 个数据点。

有许多方法来计算或表示一个多项式，但它们归结为同一个数学函数。一些方法是单项基，拉格朗日基和牛顿基。正如你所注意到的，它们是以它们的基础命名的。

弊端:

高次多项式→适当选择基函数和插值点可以减轻与高次多项式相关的一些困难
过度拟合→将单个多项式拟合到大量数据点，这可能会在插值函数中产生不令人满意的振荡行为

随着不同方法的诞生，分段插值解决了这些复杂问题。

2.分段插值

分段插值通过用低次多项式拟合大量数据点来解决这些问题。由于我们只使用低次多项式，我们消除了过度的振荡和不收敛。

**一般概念:**给定一组数据点，在每个区间使用不同的多项式，这样我们在连续的点上插入几个插值。这就是为什么会有诸如结、断点或控制点之类的术语——这些是插值函数从一个多项式变为另一个多项式的横坐标。

**主要关注:**似乎牺牲了插值函数插值的光滑性，使得图形可能有“拐角”，这意味着导数在这些点处是不连续的。

**目标:**考虑到所有这些概念和主要关注点，我们的目标是找到一个平滑的插值函数，并且在节点之间没有太大的变化。

既然我们已经讨论了自然三次样条的归属，因此该方法也应该继承所有这些一般特征。我们现在讨论下面的方法。别担心，我们会理解我们将要讨论的每一部分。

方法:自然三次样条

一、为什么叫自然三次样条？

**‘Spline’—**这个只是指 k 次的分段多项式 k 次连续可微 k-1 次

从那以后，

‘自然三次样条’—是一个分段三次多项式，它是两次连续可微的。它比多项式“硬”得多，因为它在数据点之间不太容易振荡。

仍然没有任何意义吗？让我们将它形象化，并解释我们稍后将通过机械模型使用的零件的数学术语。

figure from: Numerical Methods in Engineering with Matlab, 2ed by Jan Kiusalaas

让我们想象一下，有一个弹性条钉在软木板上。现在介绍要点:

**段:**样条曲线的每一段都是三次多项式。
**在销钉处:**斜率(一阶导数)和弯矩(二阶导数)是连续的
**在端点:**没有弯矩。在数学语言中，这意味着样条在端点的二阶导数为零。由于这些端点条件在梁模型中自然出现，因此生成的曲线称为自然三次样条曲线。
图钉:代表数据点或后面公式中使用的术语【结】

现在我们已经清楚了一般的概念，让我们把这些概念具体化。我们用推导来说明它是如何产生的。

二。推导

这个比较长，但是对于懂导数和积分的人来说是可以理解的。

答:大图

figure from: Numerical Methods in Engineering with Matlab, 2ed by Jan Kiusalaas

其中有 *n 个节点(k 个)*是数据点(x，y)，f 是两个节点之间的插值。

由于我将数学视为建模，我们从插图开始。这将作为具体告诉我们要解释什么，也是我们的地图，而我们做推导。

B .要求

C .引出适当的

正确的推导由两部分组成——每一部分得出一个方程——我们将使用它并在计算中发挥重要作用。

有了所需的公式后，我们展示如何使用它们。

三。怎么用它做插值？

我们通过一个例子来说明它的用法，然后概括这个过程。

例#1: 用自然三次样条确定 x = 1.5 处的 y。数据点如下:(2，1)，(1，0)，(5，0)，(3，0)，(4，1)

解决方案:

我们首先明白它想要什么。它的主要要求是—使用自然三次样条函数为包含 x = 1.5 的线段找到一个插值函数，该插值函数将对给定的所有数据点进行插值，并知道其对应的 y 坐标。

或者以更简单的方式:(1)插值函数(2) y 在 x=1.5 时

我们首先得到我们的公式:

用于插值器

为绳结

我们必须重新排列这些值来简化这个过程

😦1, 0), (2, 1), (3, 0), (4,1), (5,0)

然后我们知道具体的结

注意:k1=k5=0，所以我们只考虑 i=2，3，4

然后我们替换相应的值，这样:

这又产生了一个线性方程组:

结可以通过求根技术消除、替换、高斯消除、LU 分解等来解决。

我们在这里使用高斯消去法:

跳过我们的详细计算:

然后我们知道焦点在 x = 1.5 时得到 y

我们发现 x 在哪个纽结中:1.5 在 x1 = 1 和 x2 = 2 之间

因此，我们使用第一个和第二个结，使得:

替代我们的价值观:

因此，

现在我们已经看到了它是如何工作的，我们推广这个过程，给出一个使用自然三次样条找到某个 x 处的 y 的问题的解决方案。

一般流程:

必须被视为一个建议而已。有很多方法可以做到这一点。

**给定:**数据点

**求:**插值函数 fi，i+1(x)在某 x 处考虑 y。

流程:

第一个主要步骤:配方和准备

我们将需要这些公式，所以最好在开始计算之前解决所有的公式:

为了绳结

2.对于分段的插值函数

3.确保横坐标(x 坐标)按升序排列，因为我们考虑的是每段的功能。

*第二个主要步骤:使用上述公式 1 求解结(k)

I 的替代
替换整个值
形成线性方程组后，从 i=2，3，…，n-1 得到纽结

*第三个主要步骤:求解 fi，i+1(x_c)

首先找出 x_c 属于哪个结
得到 fi，i+1(x)
得到 fi，i+1(x_c)

总的来说，

可以说自然三次样条是一种非常有趣的插值方法。我们知道插值是用一个函数来拟合所有给定的数据点，我们知道多项式插值在某些时候可以只使用一个多项式来完成这项工作。当我们只考虑低次多项式时特别有用，但对于高次多项式，过度拟合潜伏在深处，产生不需要的振荡，不能提供任何对数据的洞察。一个可取之处是分段插值，它使用不同的低次多项式，这对于大型数据集特别有用。可以看出，在分段实现中有更多的工作要做，但是考虑到大数据集的方法的复杂性超过了相当长的实现。

参考资料:

JM·索里亚诺爵士的 CS131 课堂讲稿

米（meter 的缩写））希斯。科学计算:介绍性调查。

K.阿特金森和韩。初等数值分析。

J.基乌斯拉斯。用 Matlab 实现工程中的数值方法。

为赶时间的人准备的数字指南

原文：https://towardsdatascience.com/numpy-guide-for-people-in-a-hurry-22232699259f?source=collection_archive---------14-----------------------

Photo by Chris Ried on Unsplash

NumPy 库对于数据科学家来说是一个重要的 Python 库，您应该熟悉它。Numpy 数组类似于 Python 列表，但要好得多！操纵 Numpy 数组比操纵 Python 列表容易得多。您可以使用一个 Numpy 数组来代替多个 Python 列表。Numpy 数组的计算速度也比列表快，在执行数学和逻辑运算时效率极高。这是一个强大的工具知道！

本文是一个快速的备忘单，提供了 Numpy 基础知识的概述以及有用的方法。我将介绍如何以多种方式初始化 Numpy 数组，访问数组中的值，执行数学和矩阵运算，以及使用数组进行屏蔽和比较。我发现 Numpy 数组在解决 Python 编码难题时非常有用。

让我们开始玩吧。

Numpy

首先，您必须用下面的代码导入 Numpy。

import numpy as np

创建 Numpy 数组的多种方法

与列表不同，您不能创建空的 Numpy 数组。下面是根据您的需要初始化 Numpy 数组的多种方法。

如果您有一个想要转换成 Numpy 数组的列表，我们可以很容易地转换它。

访问数组中的元素

我们可以访问单个项目或一部分数据。与列表类似，第一个元素的索引是 0。例如，array1[0，0]表示我们正在访问第一行和第一列。元组[0，0]中的第一个数字表示行的索引，第二个数字表示列的索引。

广播

"术语广播描述了 numpy 在算术运算中如何处理不同形状的数组."—SciPy.org

广播是一种获得两个数组的外积的方法。

根据文档，“在两个数组上操作时，NumPy 按元素比较它们的形状。在以下情况下，二维是兼容的

他们是平等的，或者
其中一个是 1

如果不满足这些条件，就会抛出一个ValueError: frames are not aligned异常，表明数组具有不兼容的形状。"

为了成功地得到外积，我们使用reshape.这个方法改变数组的形状，这样我们就可以使它兼容 Numpy 操作。

数学和矩阵计算

我喜欢 Numpy 数组的原因之一是它非常容易操作。仅用一行代码就可以进行连接、加法、乘法、转置！

下面是一些 Numpy 数组的各种算术和乘法运算的例子。以下未涉及的操作可在此处的文档中找到。

其他很酷的特性包括串联、拆分、转置(将项目从行切换到列，反之亦然)，以及获取对角线元素。

上面，axis = 0 告诉计算机我们想要通过行来连接。如果我们想通过列来连接，我们使用 axis = 1。

比较和遮罩

我们可以用 Numpy 数组做的一件有用的事情是比较一个数组和另一个数组。在比较中返回一个布尔矩阵。

我们可以利用这个布尔矩阵。也就是说，我们可以进行布尔掩蔽。用这个布尔矩阵作为掩码，我们可以用它来选择我们感兴趣的数据的特定子集。

此外，我们还有各种其他比较运算符来比较两个数组，比如==(相等)、!=(不相等)、<=(小于或等于)。我们甚至可以组合两个布尔语句&(用于“与”条件)或|(用于“或”条件)。

感谢阅读！希望你喜欢。如果你使用 Numpy 还有其他有用的技巧，请在下面评论。你可以在这里找到上面代码的 Jupyter 笔记本。

numpy——Python 变得高效

原文：https://towardsdatascience.com/numpy-python-made-efficient-f82a2d84b6f7?source=collection_archive---------9-----------------------

“person holding sticky note” by Hitesh Choudhary on Unsplash

几天前，我的一个朋友问我他如何使用 git 命令来更改提交消息的名称。因为我已经在我的一篇文章中记录了同样的内容，所以我能够指引他去那里，他也能够自己做出必要的改变。就在那时，我意识到我的工作不仅帮助了未来的自己，也帮助了我的朋友和同事。因此，我决定记录下我将学到的任何新东西，因为它可能也会指导其他人。

在本文中，我将介绍 Numpy 的基础知识以及我最近了解到的一些策略。我将每个print()语句的输出作为注释包含在 Github gist 语句的后面。整个项目也可以作为理解 Numpy 库。

Numpy(数字 Python)

几天前，当我研究机器学习时，我开始使用 Python 的 Numpy 库。在看过如此多的视频系列和文件后，我确信它的巨大潜力和它带来的计算效率。

对于数据密集型计算，Numpy 为我们提供了广泛的方法，使 Python 中的数据操作变得非常快速和简单。虽然在循环过程中，Python 的执行速度比 Fortran 等其他语言慢，但 Numpy 通过将重复代码转换为编译形式来加快 Python 的操作。

NumPy 是使用 Python 进行科学计算的基础包。— 数量

这确实是真的。它提供了大量的选项，并且人们可以用简单的语句做大量的事情，这是非常了不起的。

import numpy as np

首先，我首先使用 Python 的 import 语句导入 Numpy。我把它命名为np,这样我就不用每次使用它的一个函数时都写numpy。这是导入库时遵循的一般惯例。

数字阵列

Numpy 数组非常类似于 Python 列表，但有一个特殊条件，即它的所有元素都必须是同一类型。我们使用函数array()在 numpy 中定义一个数组。它接受第一个参数作为数组，第二个参数作为元素类型，例如 int 、 float 等。在这个例子中，我们定义了一个包含 int (integer)类型的元素 1、2、3 和 4 的数组。

我们可以索引元素。numpy 数组中的 Index 也是从 0 开始的，所以integerArray[0]指的是第一个为 1 的元素。我们也可以定义一个范围，比如[:2]，它打印从 0 到 1 的所有值。创建这样一个数组非常有用，因为它有巨大的潜力，就像简单地检查数组中的一个元素一样2 in integerArray返回True。

此外，我们可以使用concatenate()函数连接两个 numpy 数组。创建不同的数组也变得非常容易。我们可以使用函数zeros()创建任意给定大小的 0 数组，使用ones()创建任意给定大小的 1 数组，并通过定义一个range()而不是实际的 Python 列表来创建一个随机数数组。每个函数还接受第二个参数作为可选的元素类型。

多维数组

我们可以使用 numpy 库在 Python 中定义多维数组。只需将完整的数组集定义为数组字段的第一个参数。在上面的例子中，我们创建了一个二维数组(矩阵)。使用reshape()函数可以将一维数组转换成二维数组，反之亦然。

concatenate()函数也适用于 numpy 中的多维数组。默认情况下，连接发生在第一维上。然而，我们也可以使用axis参数定义串联轴。对于表示为matrix[row][column]的矩阵，我们可以通过使用axis = 0连接行或使用axis = 1连接列来连接。

Numpy 数组操作

我们可以在 numpy 数组上应用多种操作。

Numpy 重载了所有的基本函数，以便它们可以对数组进行操作，例如加号运算符+、乘号运算符*等。都是为数组重载的。平方根和对数等特殊函数也是可用的。这些操作是按元素进行的，因此当与多个数组交互时，它们必须都具有相同的形状。还有许多其他可能的操作，如exp、sin、cos、tan和abs。我们还可以sort()，找到min()和max()，确定unique()值，矩阵的diagonal()元素和sort()元素。如果我们在 min 或 max 前面加上arg，也可以得到数组中最小值或最大值的索引。

比较数组

numpy 数组也可以进行元素比较。这些函数返回布尔值，可以再次用于从结果为真的数组中提取值。

向量和矩阵运算

上面提到的所有函数都非常有用，并导致了使用向量和矩阵的更大目标。所有函数都处理向量和矩阵，使我们能够将 Numpy 用于统计和机器学习应用。

这个清单并没有到此为止。numpy 库中内置了最重要的函数，如dot()和cross()矩阵运算。令人惊讶的是，我们也可以计算outer()和inner()。

随机阵列

使用 numpy，很容易定义随机数组和随机矩阵。

np.random使我们能够定义随机数组。如果自变量包括单个整数，例如上面示例中的5，函数rand()定义一个随机数组；如果自变量是整数的组合，例如上面矩阵示例中的(5,4)，函数rand()定义一个随机矩阵。这个函数返回 0 到 1 范围内的值，但是如果我们想要整数，我们应该使用randint()。它将第一个参数作为起始值，第二个参数作为结束值，第三个参数作为数组的形状。

数字策略

“four person fist bumping” by rawpixel on Unsplash

我们现在非常熟悉 numpy 数组以及可以在其上执行的无限功能。在部署这些功能时，我们使用了一些固有的策略，包括:

通用函数
聚集
广播
切片、蒙版和花式索引

我们已经在上面的例子中使用了它们，但是现在我们可以明确地定义和区分它们。我在 PyCon 2015 youtube 视频中发现了这些关于丢失循环的策略。

通用函数

这些函数被定义为对数组元素进行元素操作的函数，不管它是一个单维数组还是多维数组。

上面的例子使用通用函数将数组arr的每个元素乘以 10，生成一个新的数组。

聚合函数

当我们希望总结数组中包含的信息时，这些函数非常有用。

上面的例子显示了我们如何使用std()函数来计算数组元素的标准偏差，它大约是2.87。

广播

这些是通用函数如何在 numpy 数组上操作的一组规则。

在上面的例子中，我们看到一方面我们有一个矩阵mat，另一方面我们有一个数组arr。在添加这两个时，broadcasting 复制数组两次(理解为用两行创建一个临时矩阵作为[1,1,1])并添加这两个，这是可能的，因为它们现在具有相同的维度并产生结果。

切片、蒙版和花式索引

最后一个策略也包含了一些技巧。

我们可以使用一系列索引来索引数组，例如上面示例中的0 to 4。当我们将值设置为[:5]时，它从索引0的开头开始读取，直到比索引4的结尾小 1。

屏蔽使我们能够使用运算符来获得满足条件的数组中每个元素的布尔答案。如果条件满足，返回值为True，否则为False。例如，在上面的例子中，当我们定义掩码bigArray > 6 | bigArray < 3时，我们得到掩码为[True True True False False False False True True True]。然后，我们可以使用它来定义要在bigArray数组中读取的值，并获得输出。

花式索引是指我们定义一个索引列表，然后用它来获取bigArray数组的元素。

最后，我们可以将它们结合起来。在上面的最后一个例子中，我们首先选择值大于 6 的所有值，因此我们得到布尔值[False False False False False False False True True True]，它通过bigArray[bigArray > 6]返回[7,8,9]，我们从中选择第一个元素，从而得到输出[7]。

结论

本文详细介绍了什么是 Numpy 数组及其众多的功能和策略。理解 Numpy 有助于我们理解基于它的许多其他库，例如 Sklearn。

希望你喜欢我的作品。请分享、评论和表达你的想法和观点。

Numpy 与 Tensorflow:矩阵计算的速度

原文：https://towardsdatascience.com/numpy-vs-tensorflow-speed-on-matrix-calculations-9cbff6b3ce04?source=collection_archive---------0-----------------------

你好社区！

在这篇文章中，我想分享我在矩阵计算方面的经验。在这篇文章的最后，我们将会更清楚地看到两个库中的哪一个必须用于不需要运行数小时的计算。

我面临的任务是编写这个公式:

其中 u 和 v 是大小为 2 的向量，取自一组数千个向量。这实际上是计算庞加莱球空间模型中两个向量之间距离的公式的一部分(更多内容请见后面的帖子！).

因为问题的本质，我需要计算每一对向量的公式。为了加快计算速度，我选择只使用矩阵运算，而不使用循环。在这篇文章的最后，有一个附录，详细介绍了我为“矩阵化”循环所做的操作。

现在的问题是:Numpy 和 Tensorflow 哪个库完成它更快？我们去看看！

代码和设置

这篇文章中使用的所有代码都可以在我的 GitHub 知识库中找到，这里是。

我运行代码的系统是在 Crestle 上的 Jupyter 笔记本，在那里使用了 NVidia Tesla K80，TensorFlow 版本 1.2.0，Numpy 版本 1.13.0。

为了构建下面的图 1，我传递了维数从(100，2)到(18000，2)不等的矩阵。作为度量标准，我测量了挂钟时间，每个标绘点是三次运行的平均值。由于曲线行为的明显单调性，我避免计算每一点的方差。这是执行时间的图表:

Plot 1: Execution time for the considered formula.

什么！？CPU 上的 Numpy 比特斯拉 K80 GPU 上的 TensorFlow 还快？甚至，矩阵越大，Numpy 越快？这怎么可能？

深入挖掘

好吧，也许我做错了什么。最好四处看看。

我登陆这个网络帖子，实际上作者 Dimitrios Bizopoulos，展示了完全相反的情况。这里谁错了？

让我们检查他的支票。他尝试的一个操作是矩阵的乘法，Numpy 用 np.dot()，TensorFlow 用 tf.matmul()。我们开始吧！

Plot 2: Execution time for matrix multiplication, logarithmic scale on the left, linear scale on the right.

好的，右边的两条最快的曲线对应于在提到的帖子的第一张图中绘制的曲线。然而，要注意的是，切换到对数标度(左图)，我们看到对于大小为

但是两条截然不同的张量流曲线呢？

为获得结果而运行的两个张量流代码之间的差异取决于生成矩阵的方式。在最快的一个中，我让 TensorFlow 生成曲线，所以这发生在 GPU 中；在最慢的一个中，我传递给 TensorFlow 已经存在的矩阵。

所以我们在这里浪费了大量的时间:从系统内存到 GPU 内存的矩阵拷贝。

此外，如果我们注意到 Numpy 曲线和最慢的张量流曲线具有非常相似的增长方式，我们也可以假设 Numpy 是通过矩阵在内存中传递的方式而减慢的。但是为了验证这一点，需要进行更深入的分析。

那么，如果我们不是将 vector 传递给初始代码(庞加莱球中的距离)，而是告诉 TensorFlow 生成它，会发生什么呢？

最终检查

所以这是最后的检查:我们试图将我们的公式也用于 GPU 上生成的向量，从而避免将它们从系统内存传递到 GPU 内存。这对于任何范围来说都是无用的，因为我们需要对真实数据进行操作，而不是对随机数进行操作，但这将有助于理解正在发生的事情。

Plot 3: Execution time for the considered formula. In the fastest curve the vectors are generated in the GPU.

与前面的情况一样，TensorFlow 的瓶颈显然是从系统内存到 GPU 内存的复制，但当向量已经在 GPU 中时，计算将以我们预期的速度进行。

结论

TensorFlow 是一个深度学习库，它被设计成在 GPU 上的性能最好。GPU 安装在 PCIe 总线上，与该总线的通信比 CPU 和系统内存之间的通信慢得多。

因此，只有当数据上有大量计算要做，以至于系统-GPU 传输时间相对于实际计算时间变得可以忽略不计时，我们才具有使用 GPU 的优势。这不是我的案子。

附录:构建矩阵运算

我就是这么做的，为了简单起见，把解释限制在三个向量:[a1，a2]，[b2，b2]，[c1，c2]。

在分子上，我们必须计算两个向量之间欧几里得差的平方范数。摆姿势(a-b) = (a1-b1) +(a2-b2):

0，(a-b)，(a-c)

(b-a)，0，(b-c)

(c-a)，(c-b)，0

对于分母，我们需要单个向量的欧几里德范数。摆姿势 A= a1 + a2:

(1-A)(1-A)、(1-A)(1-B)、(1-A)(1-C)

(1-B)(1-A)、(1-B)(1-B)、(1-C)(1-C)

(1-C)(1-A)、(1-C)(1-B)、(1-C)(1-C)

最后，结果就是我们想要的矩阵。姿势 f(a，B)= 1+2 *(A-B)/(1-A)(1-B)):

0，f(a，b)，f(a，c)

f(b，a)，0，f(b，c)

f(c，a)，f(c，b)，0

遵循用张量流语言编写示例

[ NVIDIA /论文摘要]深度神经网络中的随机分层精度

原文：https://towardsdatascience.com/nvidia-paper-summary-stochastic-layer-wise-precision-in-deep-neural-networks-882c43de4526?source=collection_archive---------7-----------------------

GIF from this website

我的一个朋友向我推荐了这篇论文，我觉得它很有趣。

请注意，这篇帖子是为了我未来的自己复习这篇论文上的材料，而不是从头再看一遍。

摘要

低精度权重已经被提出作为使深度神经网络更有记忆效率以及对敌对攻击更鲁棒的方法。并且许多网络是通过跨网络的所有层的统一精度来实现的，本文的作者引入了一种学习方案，其中 DNN 通过学习随机地探索多个精度配置，因此网络能够学习最优精度配置。

简介

由于最近在深度学习方面的进步，许多与计算机视觉和自然语言处理(以及更多)相关的领域都有了很大的突破。然而，训练这些网络通常是昂贵的，因此对 GPU 的需求很高。(比如像网上的 CNN)。许多旨在减小网络规模的研究集中在使权重为二进制或三进制权重和激活。(这占用更少的存储器，并且可以通过位操作实现计算效率。).在本文中，作者引入了训练网络时的一个额外的超参数，即每例精度的配置。(网络将通过 back prop 找到最佳点。)

相关工作

有两种方法来减小网络的规模，1)网络压缩，其中预训练的网络被最小化，同时不妨碍准确性，2)网络修剪技术。(这两种方法各有优劣。)作者的工作主要集中在降低网络中权/激活的精度，本文的三个贡献是..
1)确认低精度运算的总位数和加速比之间的线性关系。
2)引入基于梯度的学习精度方法
3)实证证明作者端到端训练策略的优势

高效低精度网络

低精度学习是一个过程，其中存储在浮点 32 中的权重减少到 1/2 位整数值。(而且大部分研究都集中在量化权重和激活上。)一般来说，量化会导致较低的精度，然而，情况并非总是如此，量化可以作为正则化，并且实际上实现更好的性能。

如上所述，由于使用了较少的比特数，我们能够获得更高的速度。看到这个数字，人们自然会问，网络的最佳精度是多少？本文作者对此问题进行了研究。

学习精度

(e.g. 444444 indicates 6 quantized layers, all assigned 4 bits).

如上所述，当每一层都统一调整其精度时，我们可以看到该模型能够实现最低的误差。然而，当涉及到学习最佳精度的两个问题是…

1)如果对最大精度没有限制，网络将只会增长，因为它导致更低的损耗
。2)量化涉及离散运算，其是不可微分的，因此不适合简单的反向传播。

第一个问题通过固定总净精度来解决，第二个问题通过采用能够通过离散随机操作反向传播梯度的技术来解决。

由于量化过程包括离散化连续值，为了成功地训练网络，需要一些数学技巧。(注意:在使用 Gumbel-Softmax(也称为具体分布)的这一节中，实际上涉及了相当多的数学计算，但是，我不打算详细讨论)。

精确分配层

Example training Process

为了实现精确分配网络，作者引入了一种新的层，其中存在一个可学习的超参数 pi，它定义了 Gumbel-Softmax 分布。(并且每个分布与每个不同的层相关联。).作者指出，在训练的开始阶段允许温度降得太低会导致高方差梯度，同时还会鼓励很大程度上不均匀的比特分配，从而损害网络的泛化能力。为了解决这个问题，作者们对精度位进行了硬赋值。

实验

本文作者在 MNIST 和 ILSVRC12 两个数据集上尝试了两种不同的 CNN 网络。本文作者比较了均匀分配网络权值的情况和通过反向传播学习精度的情况。如上所述，当网络本身能够学习精度时，它会提供更好的性能。训练错误如下所示。(对于 MNIST 数据集)

作者发现一个有趣的事实是，网络分配更多的比特给更后面的层。(并且对于早期层，仅分配几个比特。)

结论与未来工作

本文作者介绍了 DNN 的精度分配层，并表明它比均匀分配的低精度模型具有更好的性能。(这是通过网络的能力来实现的，网络能够通过 back prop 找到最佳精度。).作者写道，他们将把这个想法扩展到对抗性攻击以及所提出的模型的变体。

遗言

我从来没有想过控制网络的精度会作为一个正则化方案。

参考

莱西、泰勒和阿雷比(2018 年)。深度神经网络中的随机分层精度。Arxiv.org。检索于 2018 年 7 月 8 日，来自 https://arxiv.org/abs/1807.00942

美丽的游戏:用随机模型预测英超联赛

原文：https://towardsdatascience.com/o-jogo-bonito-predicting-the-premier-league-with-a-random-model-1b02fa3a7e5a?source=collection_archive---------7-----------------------

Image by Michal Jarmoluk from Pixabay

剧透:一点点随机性其实 有助于 (而且不，你甚至不需要机器学习)

《美丽的游戏》

“做预测是没有意义的。这不值得猜测，因为没有什么是一成不变的，足球中的事情总是在变化。”

克里斯蒂亚诺·罗纳尔多

人们喜欢足球，因为每场比赛都是不可预测的。上赛季，西布罗姆维奇队在一系列糟糕的表现后降级，使他们在英超联赛中跌至谷底。

你猜怎么着？

他们对 6 强的战绩最令人印象深刻:对热刺(1 胜 1 平)和利物浦(2 平)不败，在老特拉福德击败曼联，将利物浦淘汰出足总杯，让曼城在 90+4 '进球后拼血、甜、泪以 3 分脱身。

足球的每一刻都很重要。如果你正在观看一场比赛，把目光移开一秒钟，你可能会错过一场重要的比赛和一个突如其来的进球。英国喜剧演员卡尔·唐纳利是这么说的:

“我在看 2010 年世界杯西班牙和巴拉圭的比赛。太无聊了，所以我去了厕所，错过了那两分钟内的 3 个点球。”

在比赛的任何时候，进球都有可能发生。虽然决定球队得分的因素有很多，但是进球的时间却是随机的。

让我们绘制一张上赛季 EPL 每场比赛进球数的柱状图。

现在，如果你认为这个直方图似乎遵循某种分布，那么你就在正确的轨道上。实际上，我们可以通过一点推理来推导出这种分布:想象一场足球比赛有 90 个一分钟的时间段，在每个时间段中，我们可以以相等的概率“放入”一个进球。

上个赛季，平均每场比赛有 2.7 个进球，这意味着平均*，我们在任何一分钟看到进球的几率是 2.7/90 = 0.03。不是很高，但足以让我继续比赛。如果我们随后模拟 90 分钟并记录进球数量，这种模拟的长期分布将遵循离散泊松分布(由红色线段连接的黑点表示)*

现在，为了证明我没有挑选泊松分布来证明我的观点，让我们看看过去 8 个赛季 EPL 的总进球数。

瞧，泊松分布又起作用了。

泊松分布有什么酷的？

每当先前事件(先前目标)的时间对未来事件没有影响时，就会出现这种分布。

只要有理由假设事件可以在任何时候意外发生，与之前的事件无关，那么就有理由期待泊松分布。

这种随机性是非常显著的！！！想想这里所有的复杂性。所有教练在边线上的呐喊，球迷的尖叫，球员脑袋里的想法，到目前为止的进球数，上场时间等等。这些都不会影响下一个进球的概率。

None of the tactics matters when it comes to the probability of the next goal being score. Image by anncapictures from Pixabay.

这是一种纯粹随机产生的模式。

这很有效。它对足球比赛有效，对踢马致死有效，甚至对癌症有效。

在没有机器学习模型的情况下预测 EPL

你都看到了。人们已经尝试了多种不同的方法来预测足球比赛的最终比分。从线性回归、随机森林到深度神经网络等等。

诀窍是:要对一场比赛做出合理的预测，我只需要对泊松分布和两支球队的一些背景信息做一些非常简单的事情。

让我们试着预测一下上周日阿森纳对曼城的比赛！！！

最近 5 个赛季，主场面对曼城，阿森纳场均 1 球失球 1.37 个。不是一个令人印象深刻的记录。仅仅通过这些数字，我们就可以知道阿森纳将会经历一段艰难的时期。

通过收集这样的统计数据(你应该很高兴我已经为你做了数据收集和争论这里，我们可以模拟每一对之间的比赛。

我们可以重复模拟 10，000 或 100，000 次，并记录最可能的结果。最有可能的比分是阿森纳 1:2 落败，发生的概率是 24%。

实际结果呢？

Image from author. Screenshot from Google Search.

对于 4 行代码来说，这是一个不错的预测。

当你有一对在过去 5 年里很少有历史成绩的队伍时，要使平均成绩变得有意义就有点难了。例如:上个赛季是布莱顿和霍伍阿尔比翁 34 年后首次尝试顶级联赛，因此布莱顿和 PL 中其他球队之间没有太多数据。对于这些场景，我使用以下策略:

每支球队使用四个参数:主场和客场的平均进球数(SH)和平均失球数(SA)。当两支球队相遇时，我通过均值等于 1/2(SH + CA)的泊松分布样本为主队生成进球，同时考虑主队的进攻实力和客队的防守实力。相反，访问者的目标是从均值等于 1/2(CH + SA)的泊松分布中抽取的。

匹配的完整代码显示在这里。

这是我对第一轮的预测和实际结果

同样，考虑到我们只是随机模拟比分，这是一个很好的结果。我们正确识别了 10 场比赛中的 7 场比赛的结果(赢/平/输),并正确预测了其中 3 场比赛的比分。

打我自己的联赛

一旦你可以模拟一场比赛，没有什么可以阻止我们推广我们的方法来模拟整个赛季，并进行排名。在每次模拟中，我们可以记录谁是冠军，谁获得冠军联赛，谁被降级。聚集成千上万的模拟，我们有自己的预测最终排名。

As an Arsenal fan, I’m not happy to see such a insignificant chance to title. Well, we are still better than Tottenham !!!

让我们一年后再来这里看看我是否接近了。

模拟的完整代码可以在这里找到

一锤定音

我不想给你大肆宣传泊松分布和随机性。因为足球(和生活)远不止于此。

到目前为止，我希望你喜欢讽刺的是，如果我们假设足球是 100%不可预测和随机的，那么泊松分布就会出现，我们就变得更容易预测。本质上:

足球的(假定的)不可预测性使得比分预测更容易！！！

这是我的妙语。

然而，足球中的真实故事不是关于随机性，而是关于超越它。阿瑟·温格上赛季在阿森纳的噩梦(在连续输掉 7 场客场比赛后排名第 6。天哪，太可怕了！！！不能用一连串的坏运气来解释。当西汉姆在安菲尔德 0:4 输给利物浦时，这不仅仅是一个随机的进球序列。西汉姆在高压下崩溃，利物浦用阵容质量资本化。我在 100 万次比赛中只遇到过一次这样的比分,但任何观看比赛的人都会说利物浦理所应当得到它(他们错过了至少 3 次明显的机会)。**

球员以高度同步的方式移动，球根据物理原理移动，经理们战略性地考虑战术。所有这些因素都给游戏带来了结构性，打破了我们关于随机性的小假设，并给预测带来了挑战。

所以罗是对的，但是 原因不对。

足球很难预测，不是因为它随机，而是恰恰相反，因为它有一些美丽的结构。

看看我在统计学和数据科学方面的一些趣事:

贝叶斯统计如何说服我去健身房？
关于统计理论中最大的争论，章鱼能告诉我们什么？
我是如何用 Python 和 Tkinter 构建自己的 Macy fireworks show 的？

[1] Pandit，J. J. (2016)，普鲁士军队中的马脚致死事件——以及大型组织中的其他“从未发生的事件”。麻醉，71:7–11。doi:10.1111/ANAE . 13261

[2]Tomasetti，C. & Vogelstein，B. (2015)，组织间癌症风险的差异可以通过干细胞分裂的数量来解释。科学，347:78–81

目标检测和计数

原文：https://towardsdatascience.com/object-detection-10f3601e4175?source=collection_archive---------3-----------------------

使用不同技术的对象检测、识别

对象检测，尤其是识别可以使用不同的技术来完成，如 OpenCV 函数的组合。对我来说，用 R 语言构建一个快速模型，然后花几周时间编写冗长的 C++或。它的 NET 代码。我从一个人计数器开始，作为对象检测的实际应用，并拍摄了经过办公室的人的镜头。

首先需要使用 FFmpeg 从视频中准备图像。然后选择一个背景图像，创建一个有物体的图像和背景图像之间的差异矩阵。正如可以在 我的博客 上找到的，我已经创建了一个用于光栅图像处理和矢量化的 R 库—faster raster，这可以用于对象检测，因此想法是通过一些梯度检测区域来矢量化差异矩阵。

在这张图片上，有一个变体#1，其中图片矩阵由简单的 RGB 值表示。他们的比较让我对这个人的影子有了很强的物体探测能力(参见课程代码):

因此，下一个想法(代码中的变量#2)是计算颜色(红/绿，绿/蓝)之间的差异，然后与背景进行比较。这清理了阴影检测，但引入了另一个问题，即大量黑暗区域的检测，这可能是由较差的 CMOS 相机颜色检测能力引起的:

然后我决定减去颜色(红-绿，绿-蓝),效果很好。我还增加了检测区域重量的过滤，并在视频中显示出来。正如你所看到的，当一个黑色物体穿过黑色背景时，还有另一个问题——它被分成两个或三个部分:

在本例中，我只是添加了代码来连接这些区域，并计算连接对象的新中心。添加了跟踪线和两个绿色边距，以检测沿同一方向通过的对象:

可以看到，模型本身花了一页代码，大部分是为了可视化。然而，模型中不包括以下项目:

背景图像——它必须适应天气、白天和其他条件(就像有人在观察区域的中央留下了一个包)。
清点物体——只需检查穿过绿色空白处的向量
多目标检测——基于路径近似的需求识别算法。
连接对象识别-需要对形状中线进行聚类，通过平均权重和路径近似将连接区域分割成更小的区域。

物体检测 R 源代码

library("png");
library("raster");
library("fasteraster");

X <- 48 * 2 ;
Y <- 27 * 2;
from <- 140;
to <- 200;

matrixFromFrame <- function (idx)
{
  v <- readPNG(sprintf("in/%03d.png", idx));
  rgb <- lapply(1:3, function(x) as.matrix(aggregate(raster(v[ , , x]), fact = 5)));
  rgb <- lapply(rgb, function(x) t(x)[1:X, Y:1]);
  #1 return(rgb);
  #2 return(list(rgb[[1]] / rgb[[2]], rgb[[2]] / rgb[[3]]));
  return(list(rgb[[1]] - rgb[[2]], rgb[[2]] - rgb[[3]], (rgb[[1]] + rgb[[2]] + rgb[[3]]) / 3));
}

processFrame <- function(idx, back)
{
*#  png(file = sprintf("out/final%03d.png", idx), width = 640, height = 480);*
  rggb <- matrixFromFrame(idx);
  diff <- (rggb[[1]] - back[[1]]) ^ 2 + (rggb[[2]] - back[[2]]) ^ 2;
  pol <- raster2vector(diff, 0.001, 100, 100);
  plot(0, type = "l", xlim = c(1, X), ylim = c(1, Y));
  rasterImage(readPNG(sprintf("in/%03d.png", idx), native = TRUE), 1, 1, X, Y);
  abline(v = 30, col = 'green');
  abline(v = 70, col = 'green');
  lapply(pol, function(x) lines(rbind(x, x[1,]), col = 'blue'));
  zone <- rasterZoneAnalyzer(diff, 0.001, 100, 100);
  zone <- zone[zone[ , 2] > 10, , drop = FALSE];
  *#text(zone[ , 3], zone[ , 4], labels = zone[ , 2], col = 'red');*
  track[[idx - from + 1, 1]] <<- sum(zone[, 2] * zone[, 3]) / sum(zone[, 2]);
  track[[idx - from + 1, 2]] <<- sum(zone[, 2] * zone[, 4]) / sum(zone[, 2]);
  lines(track, col = 'red');
  points(track, col = 'red', pch = 20);
*#  dev.off();*
}

track <- matrix(nrow = to - from + 1, ncol = 2);
back <- matrixFromFrame(100);
lapply(from:to, function(x) processFrame(x, back));

代码你可以在这里找到: R 源代码

附言（同 postscript）；警官（police sergeant）

对于个人问题，请在 Linkedin 或脸书上联系我，有时我会在那里发布关于人工智能的简短新闻和想法。
如果有 AI 方面的需求，或者需要组建数据科学咨询团队，联系我

对象检测算法:跨域对象检测

原文：https://towardsdatascience.com/object-detection-algorithms-cross-domain-object-detection-e87d3cfd3045?source=collection_archive---------6-----------------------

在今天的帖子中，我将介绍计算机视觉任务，它解决了域转移问题，即跨域物体检测(CDOD)

Photo by Marvin Kuhn on Unsplash

近年来，计算机视觉领域，尤其是基于深度学习的目标检测任务取得了长足的进步。开发的方法通常假设有大量带标签的训练数据可用，并且训练和测试数据来自相同的分布。然而，这两个假设在实践中并不总是成立的。更准确地说，通常不是。如何处理这种情况并构建能够很好适应新环境的鲁棒检测器？如何在解决现实问题中使用跨域物体检测？

在我们之前的帖子中，一阶段或两阶段的方式我们描述了基于深度学习的对象检测算法，它可以在。这些方法实现了检测器的主要目标——预测对象的位置并将检测到的对象分配到正确的类别。在今天的帖子中，我们将介绍另一个与对象检测算法相关的计算机视觉任务，该任务处理域转移问题，即跨域对象检测(CDOD)。CDOD 作为深度学习的一个新分支而诞生，以应对上面列出的挑战。这篇文章旨在描述跨领域物体检测任务的最新方法。

目标检测任务中的域适应

想象一下这样一种情况，您训练您的模型在 Cityscapes 数据集[1]上检测常见的对象，如建筑物、汽车或行人，该数据集包含大量来自德国街道的带注释的对象。然后，您在数据集的测试子集(白天的图像)上测试您的模型，一切似乎都运行良好。接下来，你在一些夜间或雾天的图像上测试相同的检测器——最终汽车检测系统应该在各种驾驶场景下工作——你意识到你的模型不再能够正确检测行人或汽车(见图 1。).

上述问题的原因是测试图像的域的改变。该模型在源分布(日常场景)上被训练，但是在不同的目标分布(夜间或有雾的场景)上被测试。在这里，领域自适应(DA)可以派上用场。DA 是计算机视觉中一个重要而富有挑战性的问题。该方法的无监督版本的主要目标是基于源域中的给定图像来学习目标域中的图像的条件分布，而不用看到相应图像对的任何示例。也有自适应的方法，使用来自几个领域的成对图片(不同场景中的相同镜头)[3],但是在简单的图像到图像翻译的情况下，它们不是很流行。

Fig. 1. Adapting a pedestrian detector trained on labeled images from daytime conditions to unlabeled images from other conditions. Adapted from Ref. [2].

DA 可能以两种方式出现:当两个域彼此相似时，通过一个域和另一个域之间的直接转移(一步域适应)，或者在源和目标之间几乎没有相似性的情况下，通过几个中间域逐步从一个域到另一个域(多步域适应)[4]。

随着领域适应技术在图像分类任务中带来的成功，预期 DA 也将改进对象检测任务的性能。在这项任务中，我们必须考虑目标域中的标记数据量(假设我们有许多来自源域的标记图像)，并将跨域对象检测的类型分类为:

完全监督:所有目标数据都有注释，
半监督的:只有目标训练数据集的某些部分被注释，
弱监督:我们处理一些不良注释类型，例如点状注释，
无监督:不注释目标数据。

解决域转移的机制

在对象检测的情况下，有多种方法来执行域自适应。以下总结主要基于李等人的综述论文[5]。在他们的综述中，作者区分了不同类型的域适应，主要取决于用于准备域转换的技术，即基于差异的，基于重建的，基于对抗的，混合的和其他的(未分类)。

在基于差异的方法中，通过用目标数据微调基线检测器网络来减少畴变。该数据可以作为标记或未标记的图像呈现。在第一阶段目标领域中缺少注释的情况下，我们应该通过应用在源领域中的标记数据上训练的检测模块来创建伪标记。以这种方式获得的注释可以被细化，或者可以直接进入最后阶段，在最后阶段，基线检测器使用来自源域的原始标记数据和目标域中伪生成的注释被微调(重新训练)。图二。展示了一个基于差异的方法的例子[6]。

Fig. 2. Discrepancy-based approach proposed in Ref. [6].

另一方面，基于重建的技术假设使源样本与目标样本相似(反之亦然)有助于提高对象检测的性能。在这种情况下，实验可以分为两个重要的部分。一开始，我们应该通过将图像从一个域(通常是源)转换到另一个域(通常是目标)来生成人工样本。为此，可以探索一种基于循环生成对抗网络的模型。我们在关于生成培养皿中生长的细菌菌落的不常见人工样本的文章中更详细地描述了一个给定的模型。在第一步之后，创建的数据集用于训练检测器模型。在这一阶段，源图像注释被直接(类似于图 3 所示的方法。)或者在一些改进之后转移到假生成的图像。通过添加来自两个域的带标签的照片，可以增强网络性能[7]。

Fig. 3. An overview of the reconstruction-based system proposed in Ref. [7].

检测器旁边的基于对抗的方法使用域鉴别器来识别数据点来自哪个域。该网络进行对抗性训练，以缩小源和目标之间的领域差距。适应框架可以以多种方式设计。例如，在参考文献。[8]作者假设对抗训练应该在提取的特征上进行，因此准备两个适应组件:一个在图像级别(图像比例、图像风格、照明等)。)，另一个在实例级别(背景中的对象外观、对象的大小等)。).提议的框架如图 4 所示。

Fig. 4. Overview of Domain Adaptive Faster R-CNN model from Ref. [8]. The network uses a standard adversarial training together with a reverse gradient layer (GRL) — sign of gradient is reversed when passing the layer during back propagation.

当然，一些作者[9]结合了上述几种机制，这种技术通常会产生更好的性能。基于差异和重构的机制是创建这种类型的混合的最流行的选择。还有几个其他的方法，文章的作者[5]没有设法适合任何上述类别。这里，作为一个例子，可以提到图诱导原型对齐[10]。

结束语

在对具有不同照明条件或场景的图像执行检测的情况下，对从一个域绘制的照片训练的标准神经网络失败。为了补救这一点，近年来已经提出了几种允许跨域对象检测的方法。在很大程度上，他们将一个领域的照片改编为另一个领域的照片，然后进行对象检测。

CDOD 的领域适应也涉及合成到真实图像的翻译。在目标域中只有少量样本的情况下，可以使用一些经典方法来生成照片，例如将一些按尺寸切割的对象放在来自公共数据集的多样性照片上，然后使它们看起来更真实。在下一步中，上述进行跨域检测的机制使得能够识别目标域中的对象，对于这些对象，收集注释可能是昂贵的。

另一方面，在 DA 步骤中，单个输入图像可能对应于多个可能的输出，这里出现了通用/多域对象检测的问题。消除这个问题的通用检测器的适当设计仍然是一个公开的问题。

我们希望你喜欢这次阅读。如果您正在寻找关于物体检测解决方案的更多详细信息，请随时查看更多定制建议。

由欧洲区域发展基金下的欧盟基金共同资助的项目，作为精明增长业务方案的一部分。
项目作为国家研发中心的一部分实施:快速通道。

文学

[1] Cordts，Marius 等人，“语义城市场景理解的城市景观数据集”进行中。IEEE 计算机视觉和模式识别会议(CVPR) (2016)

[2]罗伊乔杜里，阿鲁尼。使用自我训练使物体检测器自动适应新的领域。CVPR (2019 年)

[3]朱，严军等，“多模态意象翻译研究”更正内容:arXiv 预印本 arXiv:1711.11586 (2017)

[4]王，梅，等.“深度视域适应研究综述”《神经计算》，第 312 卷，第 135–153 页(2018 年)

[5]李，，等.“深层域自适应目标检测:综述”更正:arXiv 预印本 arXiv:2002.06797 (2020)

[6] Khodabandeh，Mehran 等人，“一种用于域自适应对象检测的鲁棒学习方法”。ICCV (2019 年)

[7] Arruda，Vinicius F .等人，“使用无监督图像到图像翻译的跨域汽车检测:从白天到夜晚”，载于 IJCNN (2019 年)

[8]陈，余华，等，“用于野外目标检测的域自适应快速 R-CNN”。CVPR (2018 年)

[9] Inoue，Naoto 等，“通过渐进域自适应的跨域弱监督对象检测”。CVPR (2018 年)

[10]徐，，等.基于图诱导原型比对的跨域检测."CVPR (2020)

原载于 2020 年 11 月 20 日 https://neurosys.com。

PyTorch 中的目标检测和跟踪

原文：https://towardsdatascience.com/object-detection-and-tracking-in-pytorch-b3cf1a696a98?source=collection_archive---------2-----------------------

检测图像中的多个对象并在视频中跟踪它们

在我之前的故事中，我讲述了如何用你自己的图像在 PyTorch 中训练一个图像分类器，然后用它进行图像识别。现在，我将向您展示如何使用预训练的分类器来检测图像中的多个对象，然后在视频中跟踪它们。

图像分类(识别)和物体检测有什么区别？在分类中，你识别图像中的主要物体，整个图像被一个类分类。在检测中，多个对象在图像中被识别、分类，并且位置也被确定(作为边界框)。

图像中的目标检测

有几种用于对象检测的算法，其中最流行的是 YOLO 和 SSD。对于这个故事，我将使用 YOLOv3 。我不会进入 YOLO(你只看一次)如何工作的技术细节——你可以在这里阅读——但重点是如何在你自己的应用程序中使用它。

所以让我们直接进入代码吧！这里的 Yolo 检测代码是基于埃里克·林德诺伦对约瑟夫·雷德蒙和阿里·法尔哈迪论文的实现。下面的代码片段来自一个 Jupyter 笔记本，你可以在我的 Github repo 中找到。在运行之前，您需要运行config文件夹中的download_weights.sh脚本来下载 Yolo weights 文件。我们从导入所需的模块开始:

from models import *
from utils import *import os, sys, time, datetime, random
import torch
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torch.autograd import Variableimport matplotlib.pyplot as plt
import matplotlib.patches as patches
from PIL import Image

然后，我们加载预训练的配置和权重，以及在其上训练了 Darknet 模型的 COCO 数据集的类名。在 PyTorch 中，不要忘记在加载后将模型设置为eval模式。

config_path='config/yolov3.cfg'
weights_path='config/yolov3.weights'
class_path='config/coco.names'
img_size=416
conf_thres=0.8
nms_thres=0.4# Load model and weights
model = Darknet(config_path, img_size=img_size)
model.load_weights(weights_path)
model.cuda()
model.eval()
classes = utils.load_classes(class_path)
Tensor = torch.cuda.FloatTensor

上面也有一些预定义的值:图像大小(416px 正方形)、置信度阈值和非最大抑制阈值。

下面是返回指定图像检测结果的基本函数。注意，它需要一个枕头图像作为输入。大部分代码处理的是将图像的大小调整为 416 像素的正方形，同时保持其纵横比并填充溢出。实际检测在最后 4 行。

def detect_image(img):
    # scale and pad image
    ratio = min(img_size/img.size[0], img_size/img.size[1])
    imw = round(img.size[0] * ratio)
    imh = round(img.size[1] * ratio)
    img_transforms=transforms.Compose([transforms.Resize((imh,imw)),
         transforms.Pad((max(int((imh-imw)/2),0), 
              max(int((imw-imh)/2),0), max(int((imh-imw)/2),0),
              max(int((imw-imh)/2),0)), (128,128,128)),
         transforms.ToTensor(),
         ])
    # convert image to Tensor
    image_tensor = img_transforms(img).float()
    image_tensor = image_tensor.unsqueeze_(0)
    input_img = Variable(image_tensor.type(Tensor))
    # run inference on the model and get detections
    with torch.no_grad():
        detections = model(input_img)
        detections = utils.non_max_suppression(detections, 80, 
                        conf_thres, nms_thres)
    return detections[0]

最后，让我们通过加载一个图像，获得检测，然后用检测到的对象周围的边界框来显示它，将它放在一起。同样，这里的大部分代码处理图像的缩放和填充，以及为每个检测到的类获取不同的颜色。

# load image and get detections
img_path = "images/blueangels.jpg"
prev_time = time.time()
img = Image.open(img_path)
detections = detect_image(img)
inference_time = datetime.timedelta(seconds=time.time() - prev_time)
print ('Inference Time: %s' % (inference_time))# Get bounding-box colors
cmap = plt.get_cmap('tab20b')
colors = [cmap(i) for i in np.linspace(0, 1, 20)]img = np.array(img)
plt.figure()
fig, ax = plt.subplots(1, figsize=(12,9))
ax.imshow(img)pad_x = max(img.shape[0] - img.shape[1], 0) * (img_size / max(img.shape))
pad_y = max(img.shape[1] - img.shape[0], 0) * (img_size / max(img.shape))
unpad_h = img_size - pad_y
unpad_w = img_size - pad_xif detections is not None:
    unique_labels = detections[:, -1].cpu().unique()
    n_cls_preds = len(unique_labels)
    bbox_colors = random.sample(colors, n_cls_preds)
    # browse detections and draw bounding boxes
    for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections:
        box_h = ((y2 - y1) / unpad_h) * img.shape[0]
        box_w = ((x2 - x1) / unpad_w) * img.shape[1]
        y1 = ((y1 - pad_y // 2) / unpad_h) * img.shape[0]
        x1 = ((x1 - pad_x // 2) / unpad_w) * img.shape[1]
        color = bbox_colors[int(np.where(
             unique_labels == int(cls_pred))[0])]
        bbox = patches.Rectangle((x1, y1), box_w, box_h,
             linewidth=2, edgecolor=color, facecolor='none')
        ax.add_patch(bbox)
        plt.text(x1, y1, s=classes[int(cls_pred)], 
                color='white', verticalalignment='top',
                bbox={'color': color, 'pad': 0})
plt.axis('off')
# save image
plt.savefig(img_path.replace(".jpg", "-det.jpg"),        
                  bbox_inches='tight', pad_inches=0.0)
plt.show()

你可以把这些代码片段放在一起运行代码，或者从我的 Github 下载笔记本。以下是图像中物体检测的几个例子:

视频中的目标跟踪

现在你知道如何检测图像中的不同物体了。当你在视频中一帧一帧地做的时候，你会看到那些跟踪框在移动，这种可视化可能会很酷。但是，如果那些视频帧中有多个对象，您如何知道一帧中的对象是否与前一帧中的对象相同？这被称为对象跟踪，并使用多次检测来识别特定对象。

有几个算法可以做到这一点，我决定使用排序，这是非常容易使用和相当快。 SORT(简单的在线和实时跟踪)是亚历克斯·比雷、葛宗元、莱昂内尔·奥特、法比奥·拉莫斯、本·乌普克罗夫特在 2017 年发表的一篇论文，该论文提出使用卡尔曼滤波器来预测先前识别的物体的轨迹，并将它们与新的检测结果进行匹配。作者亚历克斯·比雷也写了一个多功能的 Python 实现，我将在本文中使用它。请确保您从我的 Github repo 中下载了 Sort 版本，因为我必须做一些小的更改才能将其集成到我的项目中。

现在来看代码，前 3 个代码段将与单个图像检测中的相同，因为它们处理在单个帧上获得 YOLO 检测。不同之处在于最后一部分，对于每个检测，我们调用 Sort 对象的 Update 函数来获取对图像中对象的引用。因此，与前一个示例中的常规检测(包括边界框的坐标和类别预测)不同，我们将获得被跟踪的对象，除了上述参数之外，还包括对象 ID。然后，我们以几乎相同的方式显示，但添加了 ID 并使用不同的颜色，以便您可以轻松地看到视频帧中的对象。

我还使用了 OpenCV 来读取视频并显示视频帧。请注意，Jupyter 笔记本在处理视频时非常慢。您可以使用它进行测试和简单的可视化，但是我还提供了一个独立的 Python 脚本，它将读取源视频，并输出一个包含被跟踪对象的副本。在笔记本上播放 OpenCV 视频并不容易，所以可以保留这段代码用于其他实验。

videopath = 'video/intersection.mp4'%pylab inline 
import cv2
from IPython.display import clear_outputcmap = plt.get_cmap('tab20b')
colors = [cmap(i)[:3] for i in np.linspace(0, 1, 20)]# initialize Sort object and video capture
from sort import *
vid = cv2.VideoCapture(videopath)
mot_tracker = Sort()#while(True):
for ii in range(40):
    ret, frame = vid.read()
    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    pilimg = Image.fromarray(frame)
    detections = detect_image(pilimg) img = np.array(pilimg)
    pad_x = max(img.shape[0] - img.shape[1], 0) * 
            (img_size / max(img.shape))
    pad_y = max(img.shape[1] - img.shape[0], 0) * 
            (img_size / max(img.shape))
    unpad_h = img_size - pad_y
    unpad_w = img_size - pad_x
    if detections is not None:
        tracked_objects = mot_tracker.update(detections.cpu()) unique_labels = detections[:, -1].cpu().unique()
        n_cls_preds = len(unique_labels)
        for x1, y1, x2, y2, obj_id, cls_pred in tracked_objects:
            box_h = int(((y2 - y1) / unpad_h) * img.shape[0])
            box_w = int(((x2 - x1) / unpad_w) * img.shape[1])
            y1 = int(((y1 - pad_y // 2) / unpad_h) * img.shape[0])
            x1 = int(((x1 - pad_x // 2) / unpad_w) * img.shape[1]) color = colors[int(obj_id) % len(colors)]
            color = [i * 255 for i in color]
            cls = classes[int(cls_pred)]
            cv2.rectangle(frame, (x1, y1), (x1+box_w, y1+box_h),
                         color, 4)
            cv2.rectangle(frame, (x1, y1-35), (x1+len(cls)*19+60,
                         y1), color, -1)
            cv2.putText(frame, cls + "-" + str(int(obj_id)), 
                        (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                        1, (255,255,255), 3) fig=figure(figsize=(12, 8))
    title("Video Stream")
    imshow(frame)
    show()
    clear_output(wait=True)

在您使用笔记本之后，您可以使用常规 Python 脚本进行实时处理(您可以从摄像机获取输入)和保存视频。这是我用这个程序制作的视频样本。

就这样，你现在可以自己尝试检测图像中的多个对象，并在视频帧中跟踪这些对象。

如果你想在自定义图像数据集上检测和跟踪你自己的物体，你可以阅读我的下一个故事，关于 在自定义数据集 上训练 Yolo 进行物体检测。

Chris Fotache 是一名人工智能研究员，在新泽西州工作。他涵盖了与我们生活中的人工智能、Python 编程、机器学习、计算机视觉、自然语言处理等相关的主题。

物体检测，和朋友吃饭…

原文：https://towardsdatascience.com/object-detection-dinner-with-friends-ea1caab3b666?source=collection_archive---------6-----------------------

每天，在人工智能的所有领域都可以看到许多进步，当然，在计算机视觉学习领域也不例外。

几天前，谷歌研究团队发表了一篇关于提议的用于物体检测的**# tensor flow API**的文章。为此，我想提出一个小小的挑战。我们能自动检测出与朋友共进晚餐的元素吗？

为此，我们最好使用预先训练的模型，我们有一些现成的选项可供使用:

SSD _ mobilenet _ v1 _ coco _ 11 _ 06 _ 2017
SSD _ inception _ v2 _ coco _ 11 _ 06 _ 2017
rfcn_resnet101_coco_11_06_2017
更快 _ rcnn _ resnet 101 _ coco _ 11 _ 06 _ 2017
更快 _ rcnn _ inception _ resnet _ v2 _ atrous _ coco _ 11 _ 06 _ 2017

所有型号都使用 COCO，(上下文中的常见对象)您可以在这里看到详细信息。

让我们来看看我们的原始图像，它是由晚宴的一名参与者假想拍摄的:

而我们来看一个使用 #TensorFlow 的快速实现，对于我的分析，最佳答案是使用faster _ rcnn _ inception _ resnet _ v2 _ atrous _ coco _ 11 _ 06 _ 2017显示的。【 faster_rcnn 和 inception_resnet 】。基于官方演示的代码。

这样，我们就检测到了类、出现次数、标签……当然，我们可以在照片上涂色，使实现更加友好。

目前，这个模型是有限的，因为它使用了 COCO，但我们希望像这样的模型有更多的贡献。

顺便说一下，回到我们的例子，我们可以非常快速地计算照片中的瓶子数量…

目标检测:端到端的理论视角

原文：https://towardsdatascience.com/object-detection-using-deep-learning-approaches-an-end-to-end-theoretical-perspective-4ca27eee8a9a?source=collection_archive---------1-----------------------

对物体探测领域最有影响力的论文的详细介绍

我们都知道图像分类问题。给定一幅图像，你能找出它属于哪一类吗？我们可以用 ConvNets 和使用预训练网络的迁移学习解决任何新的图像分类问题。

作为固定特征提取器的 conv net。获取一个在 ImageNet 上预训练的 ConvNet，移除最后一个完全连接的层(该层的输出是 ImageNet 等不同任务的 1000 个类分数)，然后将 ConvNet 的其余部分视为新数据集的固定特征提取器。在 AlexNet 中，这将为每个包含分类器之前隐藏层激活的图像计算 4096-D 向量。我们称这些特征为 CNN 代码。如果这些代码在 ImageNet 上训练 ConvNet 期间也达到了阈值(通常情况下)，则这些代码被重新赋值(即阈值为零)对性能非常重要。为所有图像提取 4096-D 代码后，为新数据集训练一个线性分类器(如线性 SVM 或 Softmax 分类器)。

作为补充说明:如果你想了解更多关于 convnets 和迁移学习的知识，我想推荐这个关于计算机视觉中的深度学习的可怕课程。本课程讨论各种 CNN 架构，涵盖图像领域的各种问题，包括检测和分割。

但是在图像领域有很多有趣的问题。我们今天要关注的是分割、定位和检测问题。

那么这些问题是什么呢？

所以这些问题被分成 4 大类。在接下来的几行中，我将尝试在我们深入探讨之前简要解释这些问题:

语义分割: 给定一幅图像，我们能否将每一个像素归类为属于特定的一类？
**分类+定位:**我们能够将图像分类为一只猫。太好了。*我们是否也可以通过在猫的周围画一个边界框来获得该猫在图像中的位置？*这里我们假设图像中有一个固定的数字(一般为 1)。
物体检测:分类+定位问题的一个更一般的情况。在真实世界的设置中，我们事先不知道图像中有多少对象。那么我们能否检测出图像中的所有物体，并在它们周围画出边界框？
实例分割: *我们可以为图像中的每个单独的对象创建遮罩吗？*不同于语义切分。怎么会？如果你看顶部的第四张图片，我们将无法使用语义分割程序区分两只狗，因为它会将两只狗合并在一起。

在本帖中，我们将主要关注物体检测。

分类+定位

因此，让我们首先尝试理解，当图像中只有一个物体时，我们如何解决这个问题。分类+定位案例。CS231n 笔记中说得很清楚:

把本地化当成一个回归问题！

**输入数据:**我们先来说说这种模型期望什么样的数据。通常在图像分类设置中，我们使用(X，y)形式的数据，其中 X 是图像，y 是分类标签。

在分类+本地化设置中，我们通常以(X，y)的形式存储数据，其中 X 仍然是图像，y 是包含(class_label，X，y，w，h)的数组，其中，

x =边界框左上角的 x 坐标

y =边界框左上角的 y 坐标

w =以像素为单位的边界框宽度

h =以像素为单位的边界框高度

**模型:**因此在这个设置中，我们创建了一个多输出模型，它以一幅图像作为输入，有(n_labels + 4)个输出节点。n_labels 每个输出类的节点和给出(x，y，w，h)预测的 4 个节点。

亏损:在这种情况下，亏损是非常重要的。通常，损失是 Softmax 损失(来自分类问题)和回归 L2 损失(来自边界框坐标)的加权和。

损失=阿尔法*软最大损失+(1-阿尔法)*L2 损失

由于这两个损失将在不同的规模，阿尔法超参数需要调整。

这里有一件事我想注意一下。我们正在尝试进行对象定位任务，但我们仍然有我们的 convnets 在这里。我们只是增加了一个输出层来预测边界框的坐标，并调整了我们的损失函数。这是整个深度学习框架的精髓所在——将各层堆叠在一起，重用组件来创建更好的模型，并创建架构来解决自己的问题。这就是我们将会看到的未来。

物体检测

那么这种使用回归的定位思想是如何映射到物体检测的呢？并没有。我们没有固定数量的物体。所以我们不能有 4 个输出来表示边界框坐标。

一个天真的想法可能是将 CNN 应用于图像的许多不同的作物，CNN 将每个作物分类为对象类或背景类。这很棘手。你可以创造很多这样的作物。

地区提案:

如果有一种方法(通常称为区域建议网络)可以自动为我们找到一些裁剪区域，我们就可以在这些区域上运行我们的 convnet 并完成对象检测。这就是选择性搜索(Uijlings 等人，“T4【目标识别的选择性搜索”，IJCV 2013)为 RCNN 提供的。

那么地区提案是什么:

找到可能包含物体的图像区域
跑起来比较快；例如，选择性搜索在几秒钟内在 CPU 上给出 2000 个区域建议

地区提案是如何制定的？

:**

因此，本文从使用[13] (P. F. Felzenszwalb 和 D. P. Huttenlocher)的一些初始区域开始。高效的基于图表的图像分割。IJCV，59:167–181，2004 年。1, 3, 4, 5, 7)

基于图的图像分割技术通常用图 G = (V，E)来表示该问题，其中每个节点 v ∈ V 对应于图像中的一个像素，E 中的边连接某些相邻像素对。权重与每条边相关联，这是基于它所连接的像素的某些属性，例如它们的图像强度。根据不同的方法，可能有也可能没有连接每对顶点的边。

在本文中，他们采用了一种方法:

每个边(vi，vj )∈ E 具有相应的权重 w((vi，vj))，其是相邻元素 vi 和 vj 之间的相异度的非负度量。在图像分割的情况下，V 中的元素是像素，并且边的权重是由该边连接的两个像素之间的不相似性的某种度量(例如，强度、颜色、运动、位置或某种其他局部属性的差异)。在基于图的方法中，分段 S 是将 V 划分成多个分量，使得每个分量(或区域)C ∈ S 对应于图中的一个连通分量。****

Efficient GraphBased Image Segmentation Example

正如你所看到的，如果我们在这些遮罩周围创建边界框，我们将会丢失很多区域。我们希望将整个棒球运动员放在一个边界框中。我们需要以某种方式将这些初始区域分组。

为此，对象识别的选择性搜索的作者将分层分组算法应用于这些初始区域。在这种算法中，他们根据颜色、纹理、大小和填充的不同相似性概念，将最相似的区域合并在一起。

The Algorithm for region Proposal used in RCNN

RCNN

上面的选择性搜索是他们在 RCNN 论文中使用的区域提议。但是 RCNN 是什么，它如何使用区域提议？

物体检测系统概述。我们的系统

(1)获取输入图像，(2)提取大约 2000 个自下而上的区域提议，(3)使用大型卷积神经网络(CNN)计算每个提议的特征，然后(4)使用特定类别的线性 SVM 对每个区域进行分类。

除此之外，作者还使用了特定于类的边界框回归器，它采用:

输入:(Px，Py，Ph，Pw)-建议区域的位置。

目标:(Gx，Gy，Gh，Gw)-该区域的地面实况标签。

我们的目标是学习一种将建议区域(P)映射到地面真实框(G)的变换

培训 RCNN

RCNN 的输入是什么？

因此，我们从 RPN 战略和标签的基本事实(标签、基本事实框)中获得了一个图像、区域建议

接下来，我们将所有具有≥ 0.5 IoU(交集/并集)重叠的区域提议与一个基础事实框视为该框类的正面训练示例，其余视为负面。我们训练班级特定的 SVM 氏症

因此，每个地区的提案都成为一个培训范例。并且 convnet 给出该区域提议的特征向量。然后，我们可以使用特定于类的数据来训练我们的 n-SVM。

测试时间 RCNN

在测试时，我们使用特定于类的支持向量机来预测检测盒。在测试的时候，我们会得到很多重叠的检测框。非最大抑制是对象检测流水线的组成部分。首先，它根据分数对所有检测框进行分类。选择具有最大分数的检测框 M，并且抑制与 M 有显著重叠(使用预定阈值)的所有其他检测框。这个过程递归地应用于剩余的盒子

https://www.pyimagesearch.com/wp-content/uploads/2014/10/hog_object_detection_nms.jpg

RCNN 的问题:

训练很慢。
推断(检测)慢。使用 VGG16 时每幅图像 47s——因为需要多次运行 Convnet。

对速度的需求。因此出现在同一作者的图片中:

快速 RCNN

所以来自同一作者的下一个想法:为什么不创建输入图像的卷积图，然后只从卷积图中选择区域？我们真的需要运行这么多网络吗？我们可以只运行一个 convnet，然后对 convnet 计算出的特征应用区域建议作物，并使用简单的 SVM 对这些作物进行分类。

类似于:

来自论文:图为快速 R-CNN 架构。快速 R-CNN 网络将整个图像和一组对象提议作为输入。网络首先用几个卷积(conv)和最大汇集层处理整个图像，以产生 conv 特征地图。然后，对于每个对象提议，感兴趣区域(RoI)池层从特征图中提取固定长度的特征向量。每个特征向量被馈入一系列全连接(fc)层，这些层最终分支成两个兄弟输出层:一个层产生 K 个对象类加上一个包罗万象的“背景”类的 softmax 概率估计，另一个层为 K 个对象类中的每一个输出四个实数值。每组 4 个值对 K 个类之一的精确边界框位置进行编码。

这个想法在一定程度上依赖于所用模型的架构。我们是从 VGG16 取 4096 瓶颈层吗？

所以作者提出的架构是:

**我们对三个预训练的 ImageNet [4]网络进行了实验，每个网络有五个最大池层和五到十三个 conv 层(有关网络详细信息，请参见第 4.1 节)。当一个预训练的网络初始化一个快速的 R-CNN 网络时，要经历三次变换。首先，最后一个最大池层由 RoI 池层替换，RoI 池层通过设置 H 和 W 与网络的第一个完全连接层兼容来配置(例如，对于 VGG16，H = W = 7)。第二，网络的最后一个全连接层和 softmax(其被训练用于 1000 路 ImageNet 分类)被替换为之前描述的两个兄弟层(K + 1 个类别上的全连接层和 softmax 以及类别特定的边界框回归器)。第三，网络被修改以接受两个数据输入:图像列表和那些图像中的 ROI 列表。

这显然有点混乱和“令人毛骨悚然”，让我们来分析一下。但为此，我们需要了解 VGG16 架构。

最后一个池层是 7x7x512。这是网络作者打算用 ROI 池层来代替的层。该池层获得了作为输入的区域提议的位置(xmin_roi，ymin_roi，h_roi，w_roi)和先前的特征地图(14x14x512)。

现在，ROI 坐标的位置以输入图像的单位表示，即 224×224 像素。但是我们必须应用 ROI 合并操作的层是 14x14x512。因为我们使用 VGG，我们将把图像(224 x 224 x 3)转换成(14 x 14 x 512)——高度和宽度除以 16。我们可以将 ROI 坐标除以 16，映射到特征图上。

在深度上，卷积特征图已经编码了图像的所有信息，同时保持了它相对于原始图像编码的“事物”的位置。例如，如果图像的左上角有一个红色方块，并且卷积层为其激活，则该红色方块的信息仍将位于卷积特征图的左上角。

投资回报池是如何实现的？

在上面的图像中，我们的区域建议是(0，3，5，7)，我们将该区域分为 4 个区域，因为我们希望有一个 2x2 的 ROI 池层。

你如何在小于目标规模的区域进行投资回报率池化？如果区域提案大小为 5x5，投资回报池层大小为 7x7。如果发生这种情况，我们只需将每个单元格复制 7 次，然后最大合并回 7x7，就可以将大小调整到 35x35。

在替换了汇集层之后，作者还将 1000 层的 imagenet 分类层替换为全连接层和 K + 1 个类别上的 softmax(对于背景+ 1)和类别特定的边界框回归器。

训练快速神经网络

快速 RCNN 的输入是什么？

非常相似:所以我们有一个图像，来自 RPN 策略的区域提议和标签的基本事实(标签，基本事实框)

接下来，我们将所有具有≥ 0.5 IoU(交集/并集)重叠的区域提议与一个基础事实框视为该框类的正面训练示例，其余视为负面。这一次我们有一个密集层，我们使用多任务损失。

所以每一个 ROI 都成了训练样本。主要区别在于多任务丢失的概念:

快速 R-CNN 网络具有两个兄弟输出层。第一个输出离散概率分布(每个 RoI)，p = (p0，.。。，pK)，超过 K + 1 个类别。通常，p 由 softmax 通过全连接层的 K+1 个输出来计算。第二个兄弟层为 K 个对象类中的每一个输出边界框回归偏移 t= (tx，ty，tw，th)。每个训练 RoI 都标记有基本事实类 u 和基本事实包围盒回归目标 v。我们在每个标记的 RoI 上使用多任务损失 L 来联合训练分类和包围盒回归

其中，Lcls 是 softmax 分类损失，Lloc 是回归损失。u=0 表示 BG 类，因此，只有当我们有任何其他类的边界框时，我们才会增加损耗。此外:

问题:

Runtime dominated by region proposals!

快速 RCNN

下一个被问到的问题是:网络本身能做区域提议吗？

直觉是:使用 FastRCNN，我们已经在 CNN 中计算了一个激活图，为什么不通过几个层来运行激活图以找到感兴趣的区域，然后通过预测类+ bbox 坐标来完成向前传递呢？

区域提案网络如何运作？

论文中的一个主要观点是锚的概念。锚点是固定的边界框，以不同的大小和比例放置在整个图像中，在首次预测对象位置时将用作参考。

首先，我们定义图像上的锚点中心。

Anchor centers throughout the original image

在 VGG16 网络的情况下，锚中心相隔 16 px，因为(14×14×512)的最终卷积层以因子 16(224/14)对图像进行子采样。

这是主播的样子:

Left: Anchors, Center: Anchor for a single point, Right: All anchors

所以我们从一些预定义的区域开始，我们认为我们的对象可能带有锚点。
我们的 RPN 对哪些区域具有对象和对象边界框的偏移进行分类。如果边界框> 0.5 的锚点的 IOU 为 1，否则为 0。
减少区域建议的非最大抑制
基于建议的快速 RCNN 检测网络

更快的 RCNN 损耗:

然后用 4 个损失联合训练整个网络:

RPN 分类对象/非对象
RPN 回归框坐标偏移
最终分类分数(对象类别)
最终框坐标偏移

结果:

Final Results on VOC Dataset

请随时在 LinkedIn 上与我联系，在 Twitter / Medium 上关注我，或者给我发消息征求意见。继续收听，继续学习。

免责声明: 这是我自己用网上很多博客和幻灯片的投入对这些论文的理解。如果你发现我的理解有问题，请告诉我。我一定会纠正自己，然后发帖。

参考文献:

http://cs231n.github.io/transfer-learning/#tf
http://cs 231n . Stanford . edu/slides/2017/cs 231n _ 2017 _ lecture 11 . pdf
高效的基于图的图像分割-http://people.cs.uchicago.edu/~pff/papers/seg-ijcv.pdf
用于精确对象检测和语义分割的丰富特征层次(RCNN 论文)-https://arxiv.org/pdf/1311.2524.pdf
物体识别的选择性搜索
***【https://deepsense.ai/region-of-interest-pooling-explained/ ***
https://towardsdatascience . com/fasterrcnn-explained-part-1-with-code-599 c 16568 CFF
https://stack overflow . com/questions/48163961/how-do-you-do-ROI-pooling-on-areas-small-than-the-target-size
https://medium . com/@ smallfishbigsea/faster-r-CNN-explained-864d 4 FB 7 E3 f 8
https://tryo labs . com/blog/2018/01/18/fast-r-CNN-down-the-rabbit-hole-of-modern-object-detection/
更快的 R-CNN:利用区域提议网络实现实时目标检测
https://www . slide share . net/Wenjing Chen 7/deep-learning-for-object-detection

使用谷歌人工智能开放图像的对象检测

原文：https://towardsdatascience.com/object-detection-using-google-ai-open-images-4c908cad4a54?source=collection_archive---------4-----------------------

学会打造自己的自动驾驶汽车！！！….开玩笑

由阿丁德拉班迪艾利森布朗萨加尔查达阿米当杰森苏**

Source

你上一次只用脸登录手机是什么时候？或者点击了一张与一些朋友的自拍，并使用了 Snapchat 滤镜，在你的脸上放置了一些花哨的狗耳朵？你知道吗，这些很酷的功能是由一个奇特的神经网络实现的，它不仅可以识别照片中有一张脸，还可以检测耳朵应该去哪里。从某种意义上说，你的手机可以“看到”你，它甚至知道你长什么样！

帮助计算机‘看’的技术叫做“计算机视觉”。近年来，由于计算能力的爆炸使得深度学习模型更快更可行，计算机视觉应用变得越来越普遍。许多公司，如亚马逊、谷歌、特斯拉、脸书和微软，都在大力投资这项技术及其应用。

计算机视觉任务

我们关注两个主要的计算机视觉任务——图像分类和目标检测。

****图像分类专注于将图像分组到预定义的类别中。为了实现这一点，我们需要有我们感兴趣的类的多个图像，并训练计算机将像素数字转换为符号。这只是说电脑看到猫的照片，说里面有猫。
****物体检测利用图像分类器来计算出图像中存在什么以及在哪里。通过使用卷积神经网络(CNN ),这些任务变得更加容易，这使得在图像的一次通过中检测多个类别成为可能。

For more details on the difference in such tasks, please reference the following article.

计算机视觉很酷！

认识到未来许多有趣的数据科学应用将涉及图像工作，我和我的初露头角的数据科学家团队决定在 Kaggle 上举办的谷歌人工智能开放图像挑战赛上一试身手。我们认为这是接触神经网络和卷积的绝佳机会，有可能给我们的教授和同学留下深刻印象。这个挑战为我们提供了 170 万张图片，带有 500 个对象类的1200 万个包围盒标注(它们相对于图片的 X 和 Y 坐标)。你可以在这里找到数据。****

我们强烈推荐任何想了解 CNN 的人去读吴恩达的关于卷积神经网络的课程。

弄脏我们的手！

探索性数据分析 —与所有数据分析一样，我们开始探索我们拥有哪些图像以及我们需要检测的对象类型。

Frequency of Classes in the Training Dataset

快速浏览训练图像可以发现，就出现的次数而言，某些物体比其他物体更具存在感。上图显示了前 43 名班级的分布情况。很明显，这是一个巨大的差距，需要以某种方式解决。为了节省时间和金钱(GPU 成本很高:( )我们选择了前面提到的 43 个对象类和包含这些对象的大约 300K 图像的子集。对于训练数据中的每个对象类，我们有大约 400 张图像。

选择对象检测算法

我们考虑了各种算法，如 VGG、盗梦空间，但最终选择了 YOLO 算法，因为它的速度、计算能力和大量在线文章可以指导我们完成这个过程。面对计算和时间的限制，我们做了两个关键的决定-

使用被训练来识别某些物体的 YOLO v2 模型。
利用迁移学习来训练最后一个卷积层，以识别以前未见过的对象，如吉他、房子、男人/女人、鸟等。

对 YOLO 的投入

YOLO 算法需要一些特定的输入-

输入图像尺寸 — YOLO 网络设计用于特定的输入图像尺寸。我们发送了尺寸为 608 * 608 的图像。
班级数量 — 43。这是定义 YOLO 输出尺寸所必需的。
锚箱— 要使用的锚箱的数量和尺寸。
置信度和 IoU 阈值 —定义选择哪些锚框以及如何在锚框之间挑选的阈值。
带有边框信息的图像名称——对于每张图像，我们需要以如下所示的特定格式向 YOLO 提供其中的内容

Sample input for YOLO

下面是 YOLO 输入的代码片段

Inputs into YOLO

YOLO v2 架构

该架构如下所示——它有 23 个卷积层，每个卷积层都有自己的批量归一化、漏 RELU 激活和最大池。

Representation of the actual YOLO v2 architecture.

这些层试图从图像中提取多个重要特征，以便可以检测到各种类别。为了对象检测的目的，YOLO 算法将输入图像分成 1919 的网格，每个网格具有 5 个不同的锚框。然后，它尝试检测每个网格单元中的类，并将一个对象分配给每个网格单元的 5 个锚定框之一。锚定框的形状不同，旨在为每个网格单元捕捉不同形状的对象。*

YOLO 算法为每个定义的锚定框输出一个矩阵(如下所示)

假设我们必须为 43 个类训练算法，我们得到的输出维数为:

这些矩阵给我们观察每个锚盒中的对象的概率，以及该对象是什么类的概率。为了过滤掉不具有任何类或者具有与一些其他框相同的对象的锚框，我们使用两个阈值— IoU 阈值来过滤掉捕获相同对象的锚框，以及置信度阈值来过滤掉不包含任何具有高置信度的类的框。

下面是 YOLO v2 架构最后几层的示意图:

Last few layers of YOLO v2 architecture (Only for illustration purposes)

迁移学习

转移学习是指获得一个已经训练好的神经网络来分类图像，并将其用于我们的特定目的。这节省了我们的计算时间，因为我们不需要训练大量的权重——例如，我们使用的 YOLO v2 模型有大约 5000 万个权重——在我们使用的谷歌云实例上，训练可能需要 4-5 天。

为了成功实施迁移学习，我们必须对我们的模型进行一些更新:

输入图像尺寸— 我们下载的型号使用的输入图像尺寸为 416416。由于我们训练的一些对象非常小——鸟、鞋——我们不想把输入图像挤压得太厉害。为此，我们使用大小为 608608 的输入图像。**
网格大小— 我们更改了网格大小的尺寸，以便它将图像划分为 1919 个网格单元，而不是我们下载的模型的默认 1313。**
输出层— 由于我们在不同数量的类别 43 和 80 上进行训练，而原始模型是在这些类别上进行训练的，因此输出层被更改为输出矩阵维度，如上所述。

我们重新初始化了 YOLO 的最后一个卷积层的权重，以在我们的数据集上对其进行训练，最终帮助我们识别唯一的类。下面是相同的代码片段-

Re-initializing the last convolution layer of YOLO

价值函数

在任何目标检测问题中，我们都希望在一幅图像中用一个高置信度来识别位于右侧位置的右侧目标。成本函数有 3 个主要组成部分:

****分类损失:如果检测到物体，是类别条件概率的平方误差。因此，损失函数仅在对象存在于网格单元中时惩罚分类错误。
****定位损失:它是预测的边界框位置和尺寸与地面真实框的平方误差，如果这些框负责检测物体的话。为了补偿边界框坐标预测的损失，我们使用一个正则化参数(ƛcoord).此外，为了确保较大框中的小偏差没有较小框中的小偏差重要，该算法使用边界框宽度和高度的平方根。
****置信度损失:是包围盒置信度得分的平方误差。大多数盒子不负责检测物体，因此该等式被分成两部分，一部分用于检测物体的盒子，另一部分用于其余的盒子。正则项λnoobj(默认值:0.5)应用于后一部分，以降低未检测到对象的框的权重。

关于成本函数的详细信息，请随意参考 YOlO 的原文。

YOLO 的妙处在于，它使用的误差易于使用优化函数进行优化，如随机梯度下降(SGD)、带动量的 SGD 或 Adam 等。下面的代码片段显示了我们用于优化成本函数的参数。

Training algorithm for YOLO (Adam optimizer)

输出精度-平均精度(地图得分):

在对象检测中有许多指标来评估模型，对于我们的项目，我们决定使用 mAP 得分，这是所有 IoU 阈值上不同召回值的最大精度的平均值。为了理解 mAP，我们将快速回顾一下 precision、recall 和 union 上的交集)。

精确度和召回率

精度衡量正确的正面预测的百分比。回忆是所有可能结果中真正肯定的比例。这两个值是反向相关的，并且还依赖于您为模型设置的模型得分阈值(在我们的例子中，它是置信度得分)。它们的数学定义如下:

Source

并集上的交集

IoU 衡量两个区域之间有多少重叠，等于重叠面积与并集面积之比。这测量你的预测(从你的物体探测器)与地面事实(真实物体边界)相比有多好。总而言之，mAP 得分是所有 IoU 阈值的平均 AP。

结果

********

结论

物体检测不同于其他计算机视觉任务。您可以使用预先训练的模型，并根据需要进行编辑以满足您的需求。你可能需要 GCP 或另一个允许更高计算能力的平台。数学很难，看别人文章，不及格快。

经验教训

一开始，我们发现该模型无法预测许多类别，因为许多类别只有少量训练图像，这导致了不平衡的训练数据集。因此，我们决定只使用最流行的 43 个类，这不是一个完美的方法，但每个类至少有 500 张图片。然而，我们预测的可信度仍然很低。为了解决这个问题，我们选择了包含目标类的图像。

物体检测是一个非常具有挑战性的话题，但是不要害怕，尽量从各种在线开放资源中学习，比如 Coursera、YouTube 教学视频、GitHub 和 Medium。所有这些免费的智慧可以帮助你在这个令人惊叹的领域取得成功！

未来工作——继续或改进

在更多类别上训练模型，以检测更多种类的对象。为了达到这个目标，我们需要首先解决不平衡数据的问题。一个潜在的解决方案是，我们可以用这些更稀有的类收集更多的图像。

a .数据扩充 —稍微改变现有图像以创建新图像

b .图像复制 —我们可以多次使用相同的图像来训练特定稀有类上的算法

c . Ensemble——在流行类上训练一个模型，在稀有类上训练另一个模型，并使用两者的预测。

2.此外，我们可以尝试不同型号的合奏，如 MobileNet、VGG 等。这是也用于对象检测的卷积神经网络算法。

如果你想详细了解我们团队的代码，这里有 GitHub 的链接。请随时提供任何反馈或意见！

**** [## bandiatindra/物体探测项目

通过在 GitHub 上创建一个帐户，为 bandiatindra/Object-Detection 项目开发做出贡献。

github.com](https://github.com/bandiatindra/Object-Detection-Project)****

使用谷歌人工智能开放图像的对象检测

原文：https://towardsdatascience.com/object-detection-using-google-ai-open-images-541ea601cfa5?source=collection_archive---------6-----------------------

学会打造自己的自动驾驶汽车！！！….开玩笑

Atindra Bandi、Alyson Brown、Sagar Chadha、Amy Dang 和 Jason Su 的项目

Photo by Erik Mclean on Unsplash

帮助计算机“看”的技术被称为“计算机视觉”。近年来，由于计算能力的爆炸使得深度学习模型更快更可行，计算机视觉应用变得越来越普遍。许多公司，如亚马逊、谷歌、特斯拉、脸书和微软，都在大力投资这项技术及其应用。

计算机视觉任务

我们关注两个主要的计算机视觉任务——图像分类和目标检测。

图像分类专注于将图像分组到预定义的类别中。为了实现这一点，我们需要有我们感兴趣的类的多个图像，并训练计算机将像素数字转换为符号。这只是说电脑看到猫的照片，说里面有猫。
对象检测利用图像分类器来找出图像中存在的内容和位置。通过使用卷积神经网络(CNN ),这些任务变得更加容易，这使得在图像的一次通过中检测多个类别成为可能。

For more details on the difference in such tasks, please reference the following article.

计算机视觉很酷！

认识到未来许多有趣的数据科学应用将涉及图像工作，我和我的初露头角的数据科学家团队决定在 Kaggle 上举办的谷歌人工智能开放图像挑战赛上一试身手。我们认为这是接触神经网络和卷积的绝佳机会，有可能给我们的教授和同学留下深刻印象。这个挑战为我们提供了 170 万张图片和 1200 万张包围盒标注(它们相对于图片的 X 和 Y 坐标)的 500 个对象类。你可以在这里找到数据。

我们强烈推荐任何想了解 CNN 的人去读吴恩达的关于卷积神经网络的课程。

弄脏我们的手！

探索性数据分析 —和所有的数据分析一样，我们开始探索我们拥有的图像和我们需要探测的物体类型。

Frequency of Classes in the Training Dataset

选择对象检测算法

我们考虑了各种对象检测算法，包括 VGG、盗梦空间和 YOLO，但最终选择了 YOLO 算法，因为它的速度、计算能力和大量在线文章可以指导我们完成这个过程。面对计算和时间的限制，我们做了两个关键的决定-

使用被训练来识别某些物体的 YOLO v2 模型。
利用迁移学习来训练最后一个卷积层，以识别以前未见过的对象，如吉他、房子、男人/女人、鸟等。

对 YOLO 的投入

YOLO 算法需要一些特定的输入-

输入图像尺寸 — YOLO 网络设计用于特定的输入图像尺寸。我们发送了尺寸为 608 * 608 的图像。
班数 — 43。这是定义 YOLO 输出尺寸所必需的。
锚箱— 要使用的锚箱的数量和尺寸。
置信度和 IoU 阈值 —定义选择哪些锚框以及如何在锚框之间挑选的阈值。
带边框信息的图像名称 —对于每张图像，我们需要以如下所示的特定格式向 YOLO 提供图像中的内容

Sample input for YOLO

下面是 YOLO 输入的代码片段

Inputs into YOLO

YOLO v2 架构

该架构如下所示——它有 23 个卷积层，每个卷积层都有自己的批量归一化、漏 RELU 激活和最大池。

Representative of the actual YOLO v2 architecture.

YOLO 算法为每个定义的锚定框输出一个矩阵(如下所示)

假设我们必须为 43 个类训练算法，我们得到的输出维数为:

这些矩阵给我们观察每个锚盒中的对象的概率，以及该对象是什么类的概率。为了过滤掉不具有任何类别或者具有与一些其他框相同的对象的锚框，我们使用两个阈值— IoU 阈值来过滤掉捕获相同对象的锚框，以及置信度阈值来过滤掉不包含任何具有高置信度的类别的框。

下面是 YOLO v2 架构最后几层的插图:

Last few layers of YOLO v2 architecture (Only for illustration purposes)

迁移学习

为了成功实施迁移学习，我们必须对我们的模型进行一些更新:

输入图像尺寸— 我们下载的型号使用的输入图像尺寸为 416416。由于我们训练的一些对象非常小——鸟、鞋——我们不想把输入图像挤压得太厉害。为此，我们使用大小为 608608 的输入图像。**
网格大小— 我们更改了网格大小的尺寸，以便它将图像划分为 1919 个网格单元，而不是我们下载的模型的默认 1313。**
输出层— 由于我们训练的是不同数量的类 43，而不是原始模型训练的 80，因此输出层被更改为输出矩阵维度，如上所述。

我们重新初始化了 YOLO 的最后一个卷积层的权重，以在我们的数据集上训练它，最终帮助我们识别独特的类。下面是相同的代码片段-

Re-initializing the last convolution layer of YOLO

价值函数

在任何对象检测问题中，我们都希望在图像中以高置信度识别在正确位置的正确对象。成本函数有 3 个主要组成部分:

****分类损失:是类别条件概率的平方误差，如果检测到物体。因此，损失函数仅在对象存在于网格单元中时惩罚分类错误。
****定位损失:它是预测的边界框位置和尺寸与地面真实框的平方误差，如果这些框负责检测物体的话。为了补偿边界框坐标预测的损失，我们使用一个正则化参数(ƛcoord).此外，为了确保较大框中的小偏差没有较小框中的小偏差重要，该算法使用边界框宽度和高度的平方根。
****置信度损失:是包围盒置信度得分的平方误差。大多数盒子不负责检测物体，因此等式被分成两部分，一部分用于检测物体的盒子，另一部分用于其余的盒子。正则项λnoobj(默认值:0.5)应用于后一部分，以降低未检测到对象的框的权重。

请随意参考原始 YOlO 论文以获得成本函数的详细信息。

Training algorithm for YOLO (Adam optimizer)

输出精度—平均精度(地图得分):

精度&召回

Source

交集超过联合(借据)

结果

********

结论

经验教训

未来工作——继续或改进

在更多类别上训练模型，以检测更多种类的对象。为了达到这个目标，我们需要首先解决不平衡数据的问题。一个潜在的解决方案是，我们可以用这些更稀有的类收集更多的图像。

a .数据扩充 —稍微改变现有图像以创建新图像

b .图像复制 —我们可以多次使用相同的图像来训练特定稀有类上的算法

c . Ensemble——在流行类上训练一个模型，在稀有类上训练另一个模型，并使用两者的预测。

2.此外，我们可以尝试不同型号的合奏，如 MobileNet、VGG 等。这是也用于对象检测的卷积神经网络算法。

如果你想详细了解我们团队的代码，这里有 GitHub 的链接。请随时提供任何反馈或意见！

**** [## bandiatindra/物体探测项目

通过在 GitHub 上创建一个帐户，为 bandiatindra/Object-Detection 项目开发做出贡献。

github.com](https://github.com/bandiatindra/Object-Detection-Project)****

用 10 行代码进行对象检测

原文：https://towardsdatascience.com/object-detection-with-10-lines-of-code-d6cb4d86f606?source=collection_archive---------0-----------------------

本教程的第二部分用于检测您的自定义对象，可通过此 链接 获得。

人工智能的重要领域之一是计算机视觉。计算机视觉是计算机和软件系统的科学，可以识别和理解图像和场景。计算机视觉也是由图像识别、物体检测、图像生成、图像超分辨率等多方面组成。由于大量的实际使用案例，对象检测可能是计算机视觉最深刻的方面。在本教程中，我将简要介绍现代对象检测的概念、软件开发人员面临的挑战、我的团队提供的解决方案以及执行高性能对象检测的代码教程。

对象检测是指计算机和软件系统在图像/场景中定位对象并识别每个对象的能力。目标检测已经广泛应用于人脸检测、车辆检测、行人计数、网页图像、安全系统和无人驾驶汽车。在实践的许多领域中，也可以使用对象检测的许多方式。像所有其他计算机技术一样，物体检测的广泛创造性和惊人用途肯定来自计算机程序员和软件开发人员的努力。

在应用程序和系统中使用现代对象检测方法，以及基于这些方法构建新的应用程序并不是一项简单的任务。对象检测的早期实现涉及到经典算法的使用，比如流行的计算机视觉库 OpenCV 所支持的算法。然而，这些经典算法无法在不同条件下达到足够的性能。

深度学习在 2012 年的突破和快速采用带来了现代和高精度的对象检测算法和方法，如 R-CNN、Fast-RCNN、Faster-RCNN、RetinaNet 以及快速但高精度的算法和方法，如 SSD 和 YOLO。使用这些方法和算法，基于深度学习，也是基于机器学习，需要大量的数学和深度学习框架的理解。有数以百万计的专业计算机程序员和软件开发人员想要集成和创建使用对象检测的新产品。但是，由于理解和实际使用这项技术的额外和复杂的途径，他们无法接触到这项技术。

我的团队在几个月前就意识到了这个问题，这也是为什么我和约翰·奥拉芬瓦(T0)构建了(T2、T3、T4、T5)这个 python 库，让程序员和软件开发人员只需几行代码就能轻松地将最先进的计算机视觉技术集成到他们现有的和新的应用程序中。

[## OlafenwaMoses/ImageAI

ImageAI——一个 python 库，旨在使开发人员能够使用独立的计算机构建应用程序和系统…

github.com](https://github.com/OlafenwaMoses/ImageAI)

要使用 **ImageAI、**执行对象检测，您只需

在您的计算机系统上安装 Python
安装 ImageAI 及其依赖项

3.下载对象检测模型文件

4.运行示例代码(只有 10 行)

现在我们开始吧。

安装 Python 3.7.6 和 pip

(如果您已经安装了 Python 3.7.6，请跳过本节)

[## Python 版本 Python 3.7.6

发布日期:2019 年 12 月 18 日现在 Python 3.7 有了更新的 bugfix 版本，取代了 3.7.6，Python 3.8 是…

www.python.org](https://www.python.org/downloads/release/python-376/)

安装 ImageAI 和依赖关系

(如果您已经安装了库，请跳过本节中的任何安装说明)

-张量流

pip install tensorflow==2.4.0

-其他

pip install keras==2.4.3 numpy==1.19.3 pillow==7.0.0 scipy==1.4.1 h5py==2.10.0 matplotlib==3.3.2 opencv-python keras-resnet==0.2.0

安装 ImageAI 库

pip install imageai --upgrade

3) 通过链接下载用于物体检测的 RetinaNet 模型文件。

太好了。现在，您已经安装了依赖项，可以开始编写第一个对象检测代码了。创建一个 Python 文件并给它命名(例如 FirstDetection.py )，然后将下面的代码写入其中。将 RetinaNet 模型文件和要检测的图像复制到包含 python 文件的文件夹中。

FirstDetection.py

然后运行代码，等待结果在控制台中打印出来。一旦结果被打印到控制台，转到你的 FirstDetection.py 所在的文件夹，你会发现保存了一个新的图像。看看下面的 a 2 图像样本和检测后保存的新图像。

检测前:

Image Credit: alzheimers.co.uk

Image Credit: Wikicommons

检测后:

上图控制台结果:

人:55 岁。59560.85858588666

人:53500 . 65858586666

人:69 . 58668686667

人:76 岁。59660.88868888666

自行车:80。58880 . 68888888881

人:83。58860 . 88888888881

人:89 . 48868889889

卡车:63 . 48666866667

人:60 岁。59660.66666666661

人:77 岁。59670.88878888671

公共汽车:98。59860 . 88988989881

卡车:84 人。38880 . 48888888881

汽车:71 . 48868686861

上图控制台结果:

人:71 岁。59860.88868888861

人:59650 . 68585858666

人:59860 . 68586868661

人:75 岁。59860.88888888686

摩托车:60 辆。56660 . 68686868661

公共汽车:99。39960 . 68989898991

小汽车:74 . 486868687687

人:67 . 58666866667

人:63 . 58668686667

人:78 岁。59860.88888888886

人:62 . 58666866667

人:72 . 59868686786

人:60 岁。59660.66668666661

人:81 岁。58680.88888888881

摩托车:50 辆。55660 . 68686868661

摩托车:58 辆。58860 . 68888888861

人:71 . 58686868671

自行车:91。59860 . 68888889861

摩托车:85。48860 . 88888888881

现在让我们解释一下这 10 行代码是如何工作的。

在上面的 3 行中，我们在第一行导入了 ImageAI 对象检测类，在第二行导入了 python os 类，并在第三行定义了一个变量来保存 python 文件、RetinaNet 模型文件和图像所在的文件夹的路径。

在上面的 5 行代码中，我们在第一行定义了我们的对象检测类，在第二行将模型类型设置为 RetinaNet，在第三行将模型路径设置为我们的 RetinaNet 模型的路径，在第四行将模型加载到对象检测类，然后在第五行调用检测函数并解析输入图像路径和输出图像路径。

在上面的 2 行代码中，我们迭代了第一行中由检测器. detectobjectsfroimage函数返回的所有结果，然后在第二行中打印出图像中检测到的每个对象的模型名称和百分比概率。

ImageAI 支持对象检测过程的许多强大定制。其中之一是提取图像中检测到的每个对象的图像的能力。如下所示，通过简单地将额外的参数extract _ detected _ objects = True解析到detectobjectsfroimage函数中，对象检测类将为图像对象创建一个文件夹，提取每个图像，将每个图像保存到创建的新文件夹中，并返回一个额外的数组，该数组包含每个图像的路径。

让我们将它应用到第一个图像，并从下面的结果中看到一些图像:

所有行人的照片都已经提取好了。我没有把它们都包括进去，因为它们会占用不必要的空间。

要检测你自己类型的物体，请访问下面链接的教程。

[## 用 6 行代码训练物体检测人工智能

关于在您自己的数据集上训练对象检测模型的分步教程

medium.com](https://medium.com/deepquestai/train-object-detection-ai-with-6-lines-of-code-6d087063f6ff)

如果您想了解更多有用和实用资源的链接，请访问下面链接的物体检测指南。

[## 物体探测指南

现在我们知道了一点什么是对象检测，不同类型的对象检测之间的区别…

www.fritz.ai](https://www.fritz.ai/object-detection/) [## 对象检测算法和库- neptune.ai

对象检测在图像中找到并识别事物，这是深度学习的最大成就之一…

海王星. ai](https://neptune.ai/blog/object-detection-algorithms-and-libraries)

ImageAI 提供了更多有用的功能，可用于定制和生产部署对象检测任务。支持的一些功能包括:

**调整最小概率:**默认情况下，检测到的概率百分比小于 50 的物体不会被显示或报告。对于高确定性情况，您可以增加该值；对于需要检测所有可能对象的情况，您可以减少该值。
**自定义对象检测:**使用提供的 CustomObject 类，您可以告诉检测类报告对一个或几个唯一对象的检测。
**检测速度:**您可以通过将检测速度设置为“快”、“更快”和“最快”来减少检测图像所需的时间。
**输入类型:**您可以指定并解析一幅图像的文件路径、Numpy 数组或一幅图像的文件流作为输入图像
输出类型:您可以指定detectobjectsfroimage函数应该以文件或 Numpy 数组的形式返回图像

你可以在官方的 GitHub 知识库上找到关于如何利用上述功能的所有细节和文档，以及包含在 ImageAI 中的其他计算机视觉功能。ImageAI 是由 DeepQuest AI 开发的开源项目。

[## DeepQuest AI

在设备和云上提供 AI APIs。

deepquestai.com](https://deepquestai.com)

https://github.com/OlafenwaMoses/ImageAI

如果你觉得这篇文章很有帮助并且喜欢，请给它一个掌声。此外，请随意与朋友和同事分享。

你有什么问题、建议或者想要联系我吗？给我发一封电子邮件到 guymodscientist@gmail.com。我也可以通过账号@OlafenwaMoses 在 twitter 上联系，通过 https://www.facebook.com/moses.olafenwa 在脸书联系。

基于深度学习的航空图像目标检测

原文：https://towardsdatascience.com/object-detection-with-deep-learning-on-aerial-imagery-c6aa7a554a59?source=collection_archive---------3-----------------------

想象你在一个内陆国家，一种传染病已经传播开来。政府已经垮台，反叛者正在全国流窜。如果你是这种情况下的军队，你如何在这种环境下做决定？你如何能完全理解眼前的情况？

几个月前，北约组织了一个创新挑战赛，提出了这个场景和这些问题。我们决定接受挑战，目标是在数据过滤/融合、可视化和预测分析领域找到创新的解决方案。

对于那些不知道的人来说，北约是 29 个北美和欧洲国家的政府间军事联盟。它构成了一个集体防御体系，其独立成员国同意共同防御，以应对任何外部方的攻击。

北约没有为挑战提供任何数据，所以我们必须自己寻找。最终，我们提出的解决方案使用了各种不同的技术，包括航空图像的计算机视觉、新闻和社交媒体上的自然语言处理、地理数据处理，当然还有精美的图表。

在这篇文章中(最初发表在 Dataiku 的 blo g 上)，我们将专注于最技术性的部分:空中图像的目标检测，浏览我们使用的数据类型，采用的架构，以及解决方案的工作方式，最后是我们的结果。如果你有兴趣从更高的层面来看这个项目，就在这里结束。

1.数据集

对于项目的目标检测部分，我们使用了由劳伦斯利弗莫尔国家实验室提供的 Cars Overhead 和上下文 (COWC)数据集。它以在六个不同地点拍摄的航空影像为特色:

加拿大多伦多
新西兰塞尔温
德国波茨坦和瓦欣根*
哥伦布(俄亥俄州)*和美国犹他州

*我们最终没有使用哥伦布和 Vaihingen 的数据，因为图像是灰度的。

该数据集提供了具有良好分辨率(每像素 15 厘米)的大图像(最大 4 平方公里),并具有每辆汽车的中心定位。正如在这篇中型文章中所建议的，我们假设汽车的平均尺寸为 3 米。我们创建了以每个汽车中心为中心的盒子，以实现我们在看不见的图像中预测盒子(即汽车)位置的最终目标。

Figure 1: An example image from the COWC dataset

2.建筑

为了在这些大型航拍图像中检测汽车，我们使用了 RetinaNet 架构。这篇论文于 2017 年由脸书博览会发表，获得了 2017 年 ICCV 最佳学生论文。

目标检测架构分为两类:单级和两级。

两阶段架构首先将潜在对象分为两类:前景或背景。然后将所有前景的潜在对象分类到更细粒度的类中:猫、狗、汽车等。这种两阶段方法非常慢，但当然也能产生最佳精度。最著名的两级架构是 Faster-RCNN 。

另一方面，单级架构没有这个潜在前景对象的预选步骤。它们通常不太准确，但也更快。RetinaNet 的单级架构是个例外:在拥有单级速度的同时达到了两级性能！

在下面的图 2 中，您可以看到各种对象检测架构的比较。

Figure 2: Performance of object detection algorithms

RetinaNet 由几个组件组成。我们将尝试描述数据是如何通过每一步进行转换的。

Figure 3: The RetinaNet architecture

2.1.卷积网络

首先有一个ResNet-50。和每一个卷积神经网络 (CNN)一样，它以一幅图像为输入，通过几个卷积核进行处理。每个内核的输出都是一个特征图——第一个特征图捕获高级特征(如线条或颜色)。我们在网络中越往下走，由于合并图层的原因，要素地图就变得越小。虽然它们更小，但是它们也代表了更细粒度的信息(比如一只眼睛，一只狗的耳朵，等等。).输入图像有三个通道(红、蓝、绿)，但是每一个后续的特征图都有几十个通道！它们中的每一个都代表了它捕捉到的不同类型的特征。

一个公共分类器获取 ResNet 的最后一个特征图(形状为(7, 7, 2048))，在每个通道上应用平均池(结果为(1, 1, 2048))，并通过 softmax 将其提供给一个完全连接的层。

2.2.特征金字塔网络

RetinaNet 没有在 ResNet 之后增加一个分类器，而是增加了一个 特征金字塔网络 (FPN)。通过从 ResNet 中选取不同图层的要素地图，它提供了丰富的多比例尺要素。

Figure 4: The lateral connection between the backbone and the FPN

然而，ResNet 的第一批特征地图可能过于粗糙，无法提取任何有用的信息。正如您在图 4 中看到的，更小、更精确的特征地图与更大的特征地图结合在一起。我们首先对较小的样本进行上采样，然后将其与较大的样本相加。存在几种上采样方法；这里，上采样是用最近邻法完成的。

FPN 的每一层以不同的尺度编码不同种类的信息。因此，他们中的每一个都应该参与目标检测任务。FPN 将 ResNet 的第三(512 channels)、第四(1024 channels)和第五(2048 channels)块的输出作为输入。第三个是第四个的一半大小，第四个是第五个的一半。

我们应用了逐点卷积(具有1x1内核的卷积)来使每个级别的通道数一致化为256。然后，我们将较小的级别向上采样两倍，以匹配较大级别的维度。

2.3.锚

在每个 FPN 级别，几个锚点围绕 FPN 的特征地图移动。锚点是具有不同大小和比例的矩形，如下所示:

Figure 5: A sample of anchors of different sizes and ratios

这些锚点是潜在对象的基本位置。存在五种尺寸和三种比率，因此有 15 个独特的锚。这些锚也根据 FPN 层级的维度进行缩放。这些唯一的锚被复制在特征地图中所有可能的位置上。其结果是K总锚。

让我们暂时把这些锚放在一边。

2.4.回归和分类

每个 FPN 的水平被馈送到两个完全卷积网络 (FCN)，这是仅由卷积和池构成的神经网络。为了充分利用每个 FPN 级别拥有不同类型信息的事实，这两个 fcn 在所有级别之间共享！卷积层与输入大小无关；只有它们的内核大小有关系。因此，虽然每个 FPN 的特征地图具有不同的大小，但是它们都可以被馈送到相同的 fcn。

第一个 FCN 是回归分支。它预测K x 4 *(每个锚点的 x1，y1，x2，y2)*值。这些值是增量，稍微修改了原始锚点，使它们更适合潜在的对象。所有潜在对象现在都将具有以下类型的坐标:

(x1 + dx1, y1 + dy1, x2 + dx2, y2 + dy2)

用x?和y?，锚点的固定坐标，和dx?、dy?，回归分支产生的增量。

我们现在有了所有对象的最终坐标——也就是所有潜在的对象。他们还没有被归类为背景或汽车，卡车等。

第二个 FCN 是分类分支。这是一个多标签问题，其中分类器预测具有 sigmoid 的K x N ( N 是类的数量)潜在对象。

2.5.删除重复项

此时我们有了K x 4坐标和K x N类分数。我们现在有一个问题:对于同一个类，检测同一个对象的几个盒子是很常见的！

Figure 6: Several boxes have been detected for a single car.

因此，对于每个类(即使它不是最高分的类)，我们应用一个非最大抑制。Tensorflow 提供了一个函数来做这件事:

tf.image.non_max_suppression(boxes, scores, max_output_size, iou_threshold)

这种方法的要点是，它将删除重叠的框(如图 6 所示),只保留一个。它还使用scores来保存最可能的盒子。

对上面 Tensorflow 方法的输入参数的一般评论:max_output_size对应于我们最终想要的最大盒子数—假设是 300 个。iou_threshold是一个介于 0 和 1 之间的浮点数，描述了可接受的最大重叠率。

Figure 7: Figure 6 after the non-max-suppression has been applied.

2.6.保留最可能的类

相同位置相同类别的重复框现在被移除。对于剩余的每个箱子，我们只保留得分最高的类别(汽车、卡车等)。).如果没有一个类的分数高于一个固定的阈值(我们使用了0.4)，那么它就被认为是背景的一部分。

2.7.焦点损失

所有这些听起来可能很复杂，但这并不新鲜——仅仅有好的准确性是不够的。RetinaNet 的真正改进是它的损失:焦点损失。没有潜在对象预选的单级架构被背景对象的高频率所淹没。焦点损失通过给予分类良好的例子(通常是背景)较低的权重来处理它。

Figure 8: We define Pt, the confidence to be right

在图 8 中，我们定义了Pt，即二元分类中正确的置信度。

Figure 9: The Focal Loss

在图 9 中，我们通过因子(1 — Pt)^y对交叉熵损失-log(Pt)进行建模。这里，y是在 0 和 5 之间振荡的调制因子。分类良好的例子有一个高的Pt，因此一个低的因素。因此，分类良好的示例的损失非常低，并迫使模型学习更难的示例。从图 10 中可以看出损失受到了多大的影响。

Figure 10: The focal loss under various modulating factors

3.履行

我们使用了 Fizyr 的 RetinaNet 的优秀的 Keras 实现。我们还编写了一个新的生成器，用熊猫的数据帧代替 CSV 文件。

Code block 1: The Generator taking Pandas DataFrame.

如您所见，**没有注释的图像保留在训练阶段。**它们仍然有助于我们算法的训练，因为它迫使算法不能到处看到汽车(即使没有任何汽车)。

我们在可可上使用了一个预训练的 RetinaNet，然后针对 COWC 数据集对其进行了微调。只有两个 fcn 为这项新任务进行了再培训，而 ResNet 主干网和 FPN 被冻结。

您可以在下面的代码块 2 中看到如何加载 RetinaNet 并编译它。注意，在加载砝码时添加skip_mismatch=True很重要！在 COCO 上创建的权重有 80 个类，但是在我们的例子中只有 1 个类，因此锚的数量是不同的。

Code block 2: Loading the RetinaNet and compile it.

我们仍然需要处理一些事情，那就是每个图像的巨大重量。来自 COWC 数据集的图像高达 4 平方公里，或 13k 像素宽和高。这些大图片重达 300 兆字节。将如此大的图像输入我们的视网膜是不切实际的。因此，我们将图像切割成 1000x1000 像素(或 150x150 米)的小块。

然而，错过汽车是愚蠢的，因为它们在两个补丁之间被切断。因此，为了避免这个问题，我们制作了一个 1000x1000 像素的滑动窗口，它以 800 像素的步长移动。这样，两个相邻的补片之间就有 200 像素宽的重叠。

这就导致了另一个问题:我们可能会检测两次汽车。为了消除重复，我们在将小补丁绑定在一起时应用了非最大抑制。事实上，这意味着我们有两次非最大值抑制:在 RetinaNet 和之后，将小补片绑定在一起。对于第二个非最大值抑制，我们使用了来自 PyImageSearch 的 Numpy 版本:

Code block 3: PyImageSearch’s non-max suppression. [source]

在处理航空影像时，我们可以使用大量的数据增强。首先，我们可以翻转横轴和纵轴。我们也可以将图像旋转任意角度。如果影像的比例不一致(无人机到地面的距离可能不恒定)，随机缩放图片也很有用。

4.结果

你可以在下面的图 11 和图 12 中看到我们的 RetinaNet 在这张看不见的盐湖城图片上的表现。

Figure 11: 13,000 detected cars in a 4 square kilometer area of Salt Lake City

Figure 12: A zoom in of Figure 11

5.我们和好了吗？

如何评价自己的表现？

准确度不够；我们需要看看我们得到了多少假阳性和假阴性。如果我们到处检测汽车，我们会有很多假阳性，但如果我们错过了大多数汽车，那就有很多假阴性。

召回测量前者，而精确测量后者。最后， f1 得分是这两个指标的组合。

Code block 4: Computing the precision, recall, and F1-score

然而，我们并不期望我们的 RetinaNet 在准确的像素点上检测到汽车。因此，我们正在计算被检测车辆和地面实况车辆的 Jaccard 指数，如果它大于选择的阈值，我们认为该车辆被正确检测。请注意，Jaccard 索引通常也称为交集-并集 (IoU):

Code block 5: The Jaccard index

Figure 13: True Positive (green), False Positive (yellow), and False Negative (red)

您可以在图 13 中看到一个示例，其中绘制了真阳性、假阳性和假阴性。

注意，四个误报中，有两个是垃圾箱，一个是重复的，还有一个居然是……一辆车！事实上，正如在每个数据集中一样，在基本事实注释中可能会有一些错误。

在图 12 中，f1 值为 0.91。通常在更多的城市环境中，f1 分数大约为 0.95。我们的模型所犯的主要错误是将建筑物顶部的通风井视为汽车。对于模型的辩护，没有建筑知识，这是很难看到的。

6.结论

对于 NATO challenge，我们不仅使用航空图像中的汽车检测，而且这是项目的主要技术部分。

哦…我们忘记告诉你挑战结果了吗？

颁发了三个奖项:北约奖(去诺福克旅游)，法国奖(25000 美元)，德国奖(去柏林旅游)。

我们同时获得了北约和法国奖！

你可以在这里阅读更多关于这个项目的高层信息(包括我们使用的所有数据和方法论)。

Figure 14: General Maurice, Supreme Commander Mercier, and our team

原载于大台库博客《来自战壕的数据》2018 年 6 月 22 日 【链接】 。这篇文章是我在 Dataiku 实验室实习时写的，这个项目是我作为首席技术人员做的许多项目之一。

每周精选

原文：https://towardsdatascience.com/object-detection-with-neural-networks-a-simple-tutorial-using-keras-20fbb88a88e7?source=collection_archive---------3-----------------------

使用神经网络进行物体检测——使用 keras 的简单教程

由约翰尼斯·里克 — 10 分钟阅读。

图像分析是深度学习中最突出的领域之一。图像很容易生成和处理，它们正是机器学习的正确数据类型:对人类来说容易理解，但对计算机来说很难。毫不奇怪，图像分析在深度神经网络的历史中发挥了关键作用。

你不能编造这些东西…或者，你能吗？

到埃里克森 — 10 分钟读取。

2016 年 11 月 7 日，我们见证了篮球史上最伟大的时刻之一。金州勇士队的斯蒂芬·库里打破了一场比赛最多三分球的记录。但是，他做的不止这些。这是一种回归——库里一直在努力，就在一场比赛前，他和他的勇士队输给了湖人队。

Word2Vec (skip-gram model): 直觉 & 在 TF 中实现

通过Manish Chablani—7&2 分钟读取。

skip-gram 神经网络模型的最基本形式实际上非常简单。训练一个只有一个隐藏层的简单神经网络来执行某项任务，但是我们实际上不会将该神经网络用于我们训练它的任务！相反，目标实际上只是学习隐藏层的权重——我们将看到这些权重实际上是我们试图学习的“单词向量”。

如果出租车旅行是萤火虫:13 亿次纽约出租车旅行被绘制

由 Ravi Shekhar — 9 分钟读取。

纽约市出租车和豪华轿车委员会(TLC)公开发布了一个从 2009 年 1 月到 2016 年 6 月的出租车出行数据集，其中包含起点和终点的 GPS 坐标。

我们能复制大脑吗？

由Eugenio culrciello—15 分钟阅读。

本月的 IEEE Spectrum 有一个关于合成大脑的故事。在这篇文章中，我将回顾这个故事，并对探索的现状进行评论:在合成系统中复制人脑。

神经网络中使用的优化算法类型和优化梯度下降的方法

安尼施·辛格·瓦利亚，13 分钟。

您是否曾经想过，通过更新模型参数，如权重和偏差值，为您的神经网络模型使用哪种优化算法来产生稍好且更快的结果。

黄砖路线图

通过彼得·斯威尼 — 7 分钟读取。

每个伟大的项目都需要路线图。对许多人来说，通往人工智能的道路需要对人类智能的深刻理解。如果这看起来很明显，你会惊讶于这个故事是如何展开的，以及你的专业知识在其中可能扮演的关键角色。

深度学习中的对立例子

由格雷戈里城堡 — 9 分钟阅读。

这篇文章将包含与我在上次深度学习会议上的演讲基本相同的信息。我觉得随着越来越多的领域开始在关键系统中使用深度学习，让人们意识到神经网络如何被愚弄以产生奇怪和潜在危险的行为是很重要的。

美德信号还是新闻阅读？参议员在推特上相互追随的原因探究

通过 Viet Vu — 7 分钟读取。

当你上唐纳德·特朗普的推特时，你首先注意到的一件事是他关注的账户很少。截至 2017 年 6 月 13 日，这一数字为 45。新闻文章的号对他关注的账号进行了报道。

用神经网络进行目标检测——使用 keras 的简单教程

原文：https://towardsdatascience.com/object-detection-with-neural-networks-a4e2c46b4491?source=collection_archive---------0-----------------------

TLDR: 一个非常轻量级的图像目标检测教程。我们将引导简单的图像，并对它们应用越来越复杂的神经网络。最终，该算法将能够检测出形状和颜色各异的多个物体(如下图)。你应该对神经网络有一个基本的了解。

在这篇博文中，我们将探讨对象检测——找出图像中的对象。例如，想象一辆自动驾驶汽车需要检测路上的其他汽车。目标检测有很多复杂的算法。它们通常需要庞大的数据集、非常深的卷积网络和很长的训练时间。为了使本教程易于理解，我们将应用两个简化:1)我们不使用真实的照片，而是具有抽象几何形状的图像。这允许我们引导图像数据并使用更简单的神经网络。2)我们预测每个图像中固定数量的对象。这使得整个算法变得非常非常简单(除了一些技巧之外，它实际上出奇的简单)。在帖子的最后，我将概述如何扩展这种方法来检测图像中的更多对象。

我试图使本教程尽可能简单:我将一步一步来，从检测单个对象开始。对于每一步，都有一个 Jupyter 笔记本，在这个 github repo 中有完整的代码。您不需要下载任何额外的数据集。代码是用 Python plus keras 编写的，所以即使对初学者来说，网络也应该容易理解。此外，我使用的网络(大部分)是非常简单的前馈网络，所以你可以在几分钟内训练它们。

检测单个物体

让我们从简单的开始:我们将预测单个矩形的边界框。为了构建“图像”，我创建了一组 8×8 的 numpy 数组，将背景设置为 0，并将数组中的一个随机矩形设置为 1。下面举几个例子(白色为 0，黑色为 1):

神经网络是一个非常简单的前馈网络，只有一个隐藏层(没有卷积，没有花哨)。它以展平后的图像(即 8×8 = 64 个值)作为输入，预测包围盒的参数(即左下角的坐标 x 和 y，宽度 w 和高度 h)。在训练期间，我们简单地通过均方误差(MSE)进行预测到期望边界框的回归。我在这里使用了 adadelta 作为优化器——它基本上是标准的随机梯度下降，但是具有自适应的学习速率。这是一个非常好的实验选择，因为你不需要在超参数优化上花费太多时间。以下是该网络在 keras 中的实现方式:

model = Sequential([
        Dense(200, input_dim=64), 
        Activation('relu'), 
        Dropout(0.2), 
        Dense(4)
    ])
model.compile('adadelta', 'mse')

我用 40k 张随机图像训练了这个网络 50 个时期(在我笔记本电脑的 CPU 上大约 1 分钟)，得到了几乎完美的结果。下面是上面图像中预测的边界框(它们是在训练过程中展示的):

很好，不是吗？你可以看到，我还在每个边界框上方绘制了 IOU 值:这个索引被称为IintersectionOverUnion，并测量预测和实际边界框之间的重叠。它的计算方法是将相交面积(下图中的红色)除以并集面积(蓝色)。IOU 介于 0(无重叠)和 1(完全重叠)之间。在上面的实验中，我得到了平均 0.9 的近乎完美的 IOU(基于保留的测试数据)。本节代码在本 Jupyter 笔记本中。

检测多个物体

预测单个对象没那么有趣，所以让我们添加另一个矩形。基本上，我们使用与上面相同的方法:用 8x8 numpy 阵列引导图像，并训练前馈神经网络来预测两个边界框(即向量 x1，y1，w1，h1，x2，y2，w2，h2 )。然而，如果我们继续这样做，我们会得到以下(相当令人失望)的结果:

两个边界框似乎都在矩形的中间。发生了什么事？想象以下情况:我们在上面图中最左边的图像上训练我们的网络。假设左矩形的期望包围盒在目标向量中的位置 1(x1，y1，w1，h1 )，右矩形的期望包围盒在向量中的位置 2(x2，y2，w2，h2 )。显然，我们的优化器将改变网络的参数，使得第一个预测器向左移动，第二个预测器向右移动。现在想象一下，稍后我们遇到了一个类似的图像，但是这次目标向量中的位置被交换了(即左矩形在位置 2，右矩形在位置 1)。现在，我们的优化器将把预测器 1 拉到右边，把预测器 2 拉到左边——与前面的更新步骤正好相反！实际上，预测的边界框位于中心。由于我们有一个巨大的数据集(40k 图像)，将会有很多这样的“副本”。

解决方案是在训练期间将每个预测的边界框“分配”给一个矩形。然后，预测器可以学习专攻矩形的某些位置和/或形状。为了做到这一点，我们在每个时期之后处理目标向量:对于每个训练图像，我们计算预测和目标之间的均方误差 A)对于目标向量中边界框的当前顺序(即 x1，y1，w1，h1，x2，y2，w2，h2 )，以及 B)如果目标向量中的边界框被翻转(即 x2，y2，w2，h2，x1，y1，w1，h1 )。如果 A 的 MSE 低于 B，我们保持目标向量不变；如果 B 的 MSE 低于 A，我们翻转向量。我在这里实现了这个算法。下面是翻转过程的可视化:

上图中的每一行都是来自训练集的样本。从左到右是训练过程的时期。黑色表示目标向量在此时期后翻转，白色表示没有翻转。你可以很好地看到，大多数翻转发生在训练的开始，当预测者还没有专门化的时候。

如果我们在启用翻转的情况下训练我们的网络，我们会得到以下结果(同样是在保留的测试图像上):

总体而言，该网络在训练数据上实现了 0.5 的平均 IOU(我没有计算测试数据集的 IOU，但应该非常相似)。不像单个矩形那样完美，但是相当不错(特别是考虑到它是一个如此简单的网络)。请注意，最左边的图像与之前图中的图像相同(没有翻转的图像)，您可以清楚地看到预测器已经学会了专门处理矩形。

最后，关于翻转算法还有两点需要注意:首先，上面介绍的方法当然只对两个矩形有效。然而，通过查看预测器和矩形的所有可能组合，您可以很容易地将其扩展到多个矩形(我将在下面更详细地解释这一点)。其次，您不必使用均方差来决定目标是否应该翻转——您也可以使用 IOU 甚至边界框之间的距离。在我的实验中，所有三个指标导致了非常相似的结果，所以我决定坚持使用 MSE，因为大多数人应该对它很熟悉。

分类对象

到目前为止，探测物体已经做得很好了，但是我们当然也想知道物体是什么。因此，我们将添加三角形并分类对象是矩形还是三角形。酷的是，我们不需要任何额外的算法或工作流程。我们将使用与上面完全相同的网络，并且只将每个边界框的一个值添加到目标向量:如果对象是矩形，则为 0，如果对象是三角形，则为 1(即，二进制分类；这里的代号是。

下面是结果(我把图片尺寸增加到 16x16，这样小三角形更容易识别):

红色边界框表示网络预测了矩形，黄色表示预测了三角形。样本已经表明分类工作得相当好，而且我们确实获得了几乎完美的分类准确度。

把它们放在一起:形状、颜色和卷积神经网络

好了，一切都正常了，现在让我们来玩一玩:我们将把这个方法应用到一些更“真实”的场景中——这意味着:不同的颜色，更多的形状，一次多个物体。为了引导图像，我使用了 pycairo 库，它可以将 RGB 图像和简单的形状写入 numpy 数组。我也对网络本身做了一些修改，但让我们先来看看结果:

如你所见，边界框并不完美，但大多数时候它们都在正确的位置。测试数据集上的平均 IOU 在 0.4 左右，对于一次识别三个对象来说还不错。预测的形状和颜色(写在边界框上面)非常完美(测试准确率为 95 %)。显然，网络已经真正学会了将预测器分配给不同的对象(正如我们用上面介绍的翻转技巧所瞄准的)。

与上面的简单实验相比，我做了三处修改:

1)我使用了卷积神经网络(CNN)而不是前馈网络。CNN 用可学习的“过滤器”扫描图像，并在每一层提取越来越多的抽象特征。例如，早期层中的过滤器可以检测边缘或颜色梯度，而后期层可以记录复杂的形状。我不会在这里讨论技术细节，但你可以在斯坦福大学 CS231n 班的讲座或迈克尔·尼尔森的书的这一章中找到精彩的介绍。对于上面显示的结果，我训练了一个有四个卷积层和两个池层的网络大约 30-40 分钟。更深/更优化/更长时间训练的网络可能会得到更好的结果。

2)我没有使用单个(二进制)值进行分类，而是使用 one-hot vectors(处处为 0，类的索引处为 1)。具体来说，我对每个对象使用一个向量来分类形状(矩形、三角形或圆形)，一个向量来分类颜色(红色、绿色或蓝色)。请注意，我在输入图像中添加了一些随机的颜色变化，看看网络是否能够处理这种情况。总而言之，图像的目标向量由每个对象的 10 个值组成(4 个用于边界框，3 个用于形状分类，3 个用于颜色分类)。

3)我修改了翻转算法来处理多个边界框(如上所述)。在每个时期之后，该算法计算一个预测的和一个预期的边界框的所有组合的均方误差。然后，取这些值中的最小值，将相应的预测和预期边界框相互赋值，从尚未赋值的框中取出下一个最小值，依此类推。

你可以在这个笔记本里找到最终代码。

现实世界的物体

识别形状是一个很酷很简单的例子，但显然这不是你想在现实世界中做的事情(不幸的是，自然界中没有那么多抽象的 2D 形状)。此外，我们的算法只能预测每幅图像的固定数量的包围盒。然而，在现实世界中，你有各种各样的场景:一条小岔路上可能没有汽车，但只要你在高速公路上行驶，你就必须同时识别数百辆汽车。

尽管这似乎是一个小问题，但实际上很难解决——如果算法不知道有多少个对象，它应该如何决定什么是对象，什么是背景？想象你自己从近处看一棵树:即使你只看到一堆树叶和树枝，你仍然可以清楚地说这都是一个物体，因为你明白树是什么。如果树叶散落在地板上，你会很容易发现它们是单独的物体。不幸的是，神经网络不太理解什么是树，所以这对它们来说是一个相当大的挑战。

在对可变数量的对象进行对象检测的许多算法中(例如over feet或R-CNN；看一下这个讲座的概况)，我只想重点介绍一个，因为它和我们上面用的方法很像:它叫YOLO(YouOonlyLookOnce)。与旧的方法相比，它只需通过一个神经网络就可以检测图像中的对象。简而言之，它将图像划分为一个网格，为每个网格单元预测两个边界框(即，与我们上面所做的完全相同)，然后尝试在整个图像中找到最佳边界框。因为 YOLO 只需要通过一个网络，它的速度非常快，甚至可以处理视频。下面是一个演示，你可以在这里看到更多的例子。

如果你想了解我的工作，请在 Twitter 上关注我( @jrieke )！你也可以在我的网站上看看其他的项目。

带有语音反馈的物体检测— YOLO v3 + gTTS

原文：https://towardsdatascience.com/object-detection-with-voice-feedback-yolo-v3-gtts-6ec732dca91?source=collection_archive---------6-----------------------

帮助盲人听到他们看不见的东西。

期末考试终于结束了！！！我被计算机视觉中的物体检测的想法迷住了，并想开始一个关于它的项目。我意识到，我们或许可以通过图像到文本和文本到语音的转换来帮助盲人“看”得更好，而不需要任何复杂的硬件。

要完全理解整个流程中的每一个环节是非常困难的，但是我已经尽我所能去理解这个任务。

目标检测

是计算机视觉的一个领域，它检测图像/视频中语义对象的实例(在我们的例子中，通过在它们周围创建边界框)。然后，我们可以将注释文本转换成语音响应，并给出对象在人/摄像机视野中的基本位置。

非常高层次的概述

**训练数据:**用上下文中的公共对象 (COCO)数据集训练模型。你可以在链接中浏览他们标记的图片，这很酷。
模型:这里的模型是你只看一次 (YOLO)算法，它通过一种极其复杂的卷积神经网络架构的变体运行，称为暗网。尽管我们使用的是一个更加增强和复杂的 YOLO v3 模型，我还是会解释最初的 YOLO 算法。另外，python cv2 包有一个从 yolov3.cfg 文件中的配置设置 Darknet 的方法。

这一次我更感兴趣的是让一些东西尽快工作，所以我将使用一个预先训练好的模型。这意味着可可已经被其他人在 YOLO v3 上训练过，并且我们已经获得了存储在 200+mb 文件中的权重。

如果你不确定什么是权重，就把它想象成在线性回归中寻找最佳拟合线。我们需要找到 y=mx+c 中 m 和 c 的正确值，使我们的线使所有点之间的误差最小。现在，在我们更复杂的预测任务中，当我们将图像输入复杂的网络时，我们有数百万个 x。这些 x 每个都有一个 m，这些是存储在 yolov3.weights 文件中的预测重量。这些 m s 已经被不断地重新调整以最小化一些功能损失。

3.**输入数据:**我们将使用我们的网络摄像头以每秒 30 帧的速度向这个经过训练的模型提供图像，我们可以将其设置为每隔一帧处理一次，以加快速度。

API: 每一帧中检测到的物体的类别预测将是一个字符串，例如“猫”。我们还将获得图像中对象的坐标，并将位置“上”/“中”/“下”&“左”/“中”/“右”附加到类预测“猫”上。然后，我们可以使用 gTTS 包将文本描述发送到 Google 文本到语音转换 API。

5.**输出:**我们还将获得在我们的帧中检测到的每个对象的边界框的坐标，将这些框覆盖在检测到的对象上，并将帧流作为视频回放返回。我们还将计划在每秒的第一帧(而不是 30 fps)获得语音反馈，例如“左下角的猫”，这意味着在我的相机视图的左下角检测到一只猫。

理解 YOLO 算法

以前，基于分类的模型用于使用定位、基于区域的分类或诸如滑动窗口之类的东西来检测对象。只有图像的高得分区域被认为是检测，并且它们可能非常耗时。

All that work just for 1 frame.

相反，YOLO 是基于回归的。我们在算法**(只看一次图像的像素)、、的一次运行中快速预测整个图像的类别和边界框，以便图像中的全局上下文通知、**预测。

训练时间

Object classes in coco.names file are indexed.

c 代表我们试图标记的对象的类索引。一个运动球意味着 C=33。训练已经在 COCO 上完成了。

Values in pixels, measured from (0,0) as top-left. Example of how the images are labeled to train the model.

在训练期间，我们必须以这种格式C bx by bw bh为图像中的每个对象手动标记以下 5 个值。我们还将通过将 4 个 b 值表示为 W & H (1280 x 720 px)的一部分，将每个 b 值归一化到 0–1 之间。

假设我们在框架中标记了两个对象——运动球和我自己。这由张量表示:向量的一般形式，将在训练期间输入到模型中。

[33, 0.21, 0.58, 0.23, 0.42]  -  sports ball
[1, 0.67, 0.5, 0.5, 0.9]  -  myself

预测/检测时间

现在，我们在预测时间将 1280 x 720 帧从我们的相机输入到 YOLO。YOLO 会自动将其大小调整为 416 x 234，并通过用 0 填充超出部分来适应流行的标准大小的 416 x 416 网络。YOLO 将每幅图像分成 S×S 个单元，每个单元的大小为 32×32(缩减系数=32)。这就产生了 416/32 = 13 x 13 个单元。

Using 8x8 cells for illustration. Dark-green box is the cell which contains the center of the object.

边界框中有 5 个值— (bx，by，bw，bh，BC)

如果对象的中心(红点)落入网格单元，则只有该网格单元(深绿色单元)负责检测该对象。每个边界框有 5 个值。前 4 个值 bx，by，bw，bh 代表盒子的位置。

Normalized using the coordinates of the top-left corner of the cell which contains the object’s center. 2) using the dimensions of the entire image.

第 5 个值是 BC :盒子置信度得分。

BC = Pr(存在于框中的对象)* IOU ( 并集上的交集)。

这衡量了盒子中包含一个任意类的物体的可能性以及预测的准确性。如果在那个盒子里不存在任何物体，那么 BC=0，我们希望 BC=1 来预测地面实况。

Fairly high IOU

在每个网格单元中预测有 B 个包围盒

YOLO v3 makes B=3 bounding boxes in each cell to predict that one object in the cell.

在每个网格单元中也有 C 个条件类概率

当我们使用 COCO 时，每个单元格有 80 个条件类概率— Pr(Class i | Object)。假定在单元中有一个对象，则预测的对象属于 I 类的概率。

1 person 0.01
2 bicycle 0.004
.
.
33 sports ball 0.9
.
.
80 toothbrush 0.02

在我们上面的例子中，类别 33 具有最高的概率，并且它将被用作我们对该对象是一个运动球的预测。

综上所述

有 S×S 个单元，并且在这些单元的每一个中有 2 样东西:1) B 个边界框，每个边界框有 5 个值(bx，by，bw，bh，BC)，2) C 个条件类概率。预测被编码为一个 S x S x (5 * B + C)张量。

非最大抑制

对于唯一用于预测对象的网格单元，实际上有 B 个重复检测(深绿色框)。NMS 抑制了具有低盒置信度分数的检测:BC，以便当只有一个运动球时，我们不会最终预测到 3 个运动球。NMS 的实现可以是:

从具有最高 BC 的边界框开始。
移除与其重叠超过给定阈值量= 0.5 的任何剩余边界框。
转到步骤 1，直到不再有边界框。

损失函数

虽然我们已经有了我们的预测，但我们想了解权重是如何调整的，以使我们在训练期间的损失函数最小化。这个函数看起来很复杂，但分解起来却非常直观。

地面实况框与预测边界框之间的差异。
物体在盒子中的 100%置信度与盒子置信度之间的差异。
C 实际类别概率(0，…，1，…，0)与 C 预测类别概率(0.01，…，0.8，…，0.02)之间的差异

Basically uses sum of squared-differences for each component. Most symbols are pretty self-explanatory.

参数λcoord 通常=5，以增加定位损失的权重，使其更重要。

参数λnoobj 通常=0.5，以降低置信度损失的权重，因为不包含对象的盒子具有置信度得分 BC=0。这使得模型更稳定，更容易收敛。

语音反馈

我们可以使用相对于 W & H 的 bx & by 来确定检测到的物体的位置，并通过这个简单的命令将其作为文本字符串发送给 gTTS。

tts = gTTS("mid left sports ball, lang=’en’)tts.save(‘tts.mp3’)

我还使用了 pydub 和 ffmpeg 来操作生成的音频文件。

演示

我不能实时返回帧，因为当它处理每 30 帧时，会使视频播放看起来非常不稳定。我还研究了多线程技术，理论上讲，每隔 30 帧就应该创建一个进程来处理视频，另一个进程用于视频播放。

然而，我只能对我的网络摄像头上实时检测到的物体进行口头描述，这更重要，因为盲人无论如何都看不到边界框。对于下面的视频，我在传递它之前记录了自己，以创建边界框并生成口头响应。

在那里，YOLO v3 的可可随着 gTTS，做它的魔术！

我很享受这个学习、实践、然后分享的过程。我认为“从应用中学习”在分享方面更上一层楼。将复杂的问题分解成简单的问题，用外行人的语言理解和解释困难的概念，这是我想进一步磨练的技能。更多即将推出！

链接到项目回购

请在 LinkedIn 或通过 jasonyip184@gmail.com 与我进一步讨论！

参考文献

[## 基于 OpenCV - PyImageSearch 的 YOLO 目标检测

在本教程中，您将学习如何使用 YOLO 对象检测器来检测图像和视频流中的对象…

www.pyimagesearch.com](https://www.pyimagesearch.com/2018/11/12/yolo-object-detection-with-opencv/) [## 了解 YOLO

这篇文章解释了 YOLO 对象检测体系结构，从某人的角度谁想要实现…

hackernoon.com](https://hackernoon.com/understanding-yolo-f5a74bbc7967) [## 使用 YOLO、YOLOv2 和现在的 YOLOv3 进行实时物体检测

你只看一次(YOLO)是一个目标为实时处理的对象检测系统。我们将介绍 YOLO…

medium.com](https://medium.com/@jonathan_hui/real-time-object-detection-with-yolo-yolov2-28b1b93e2088)

过食中的物体定位

原文：https://towardsdatascience.com/object-localization-in-overfeat-5bb2f7328b62?source=collection_archive---------1-----------------------

目标定位的任务是预测图像中的目标及其边界。目标定位和目标检测之间的区别是微妙的。简单地说，目标定位旨在定位图像中的主要(或最可见)目标，而目标检测则试图找出所有目标及其边界。

Citation needed.

AlexNet 应该是第一个用来做物体定位或检测的神经网络。由于 Alexnet 的论文没有提到实现， Overfeat (2013) 是第一个发表的基于神经网络的目标定位架构。基本思想如下图所示。

Object Localization Architecture

如果去掉边界回归器，这将是一个典型的图像分类架构。实际上，Overfeat 首先训练一个图像分类器。然后确定特征层并训练边界回归器。这再简单不过了。

乍一看，不同的类应该有不同的边界回归量，因为不同的对象往往有不同的方法来定义它们的边界。然而，在本文的实验中，类之间共享的回归器优于 1000 个不同的回归器(因为 ImageNet 有 1000 个类)。是因为数据稀缺吗？我们能直接训练回归变量来预测边界而不需要对象的类别吗？培训结束我会更新答案:-)。

Overfeat 中一个有趣的贡献是多尺度分类，它利用卷积神经网络的空间特征来减少计算。

多尺度分类

如在其他实验中所示，我们可以通过简单地裁剪多个图像补片并在测试阶段根据补片的预测投票决定最终预测来提高图像分类的准确性。显然，我们可以将这种方法用于目标定位问题中的图像分类器。假设我们有一个 8×8 的图像或特征图，我们采用 6×6 的随机裁剪来训练我们的图像分类器。在预测阶段，我们随机裁剪几个 6×6 的小块，并从这些小块的预测中选出最终的预测。下图显示了两种作物(蓝色和绿色)。重叠区域是黄色的，而红色的 3x3 补丁是应用于重叠作物的滤镜之一。

Redundant Compution in CNN

如果我们将两种作物一个接一个地输入分类器，我们将在红色区域应用 3×3 滤镜两次。计算是多余的，因为滤波器和图像中的位置是相同的。Overfeat 提出了一个巧妙的方法来消除这种冗余。

假设我们有一个大小为 18x18 的要素地图或图像，我们希望获得大小为 12x12 的裁剪，然后应用卷积和池化操作。卷积运算的滤波器是 3×3，没有重叠，因此原始映射将缩小到 6×6。然后我们应用 2x2 非重叠池，大小将变成 3x3。作物(0，0，12，12)变成(0，0，2，2)在最终的特征图中，作物(6，0，18，12)变成(1，0，3，2)，作物(0，6，12，18)变成(0，1，2，3)，作物(6，6，18，18)变成(1，1，3，3)。我们可以看到，我们可以在原始地图上应用一次操作，得到四种作物的特征地图。最终特征图(0，0，2，2)和(1，1，3，3)的初始裁剪如下图所示。

Apply convolutional and pooling operations for patches at the same time.

因此，我们可以对初始特征地图或图像应用非重叠卷积和汇集操作，以获得其裁剪结果。这里的好处是避免了我们之前谈到的冗余计算。这里的架构包括非重叠、非重叠过滤器和非重叠池。

如果避免了冗余计算，我们可以用不同大小的裁剪来训练不同的分类器，以集成结果。本文称之为多尺度分类。

如果我们有多个分类器，每个分类器都预测预测对象的一个框，哪个框是最准确的？Overfeat 将重叠较大且相互靠近的盒子保留下来，将两个相距较远的盒子的坐标进行平均，如下图所示。这种方式有助于移除其他对象的框而不是主对象。然后使用检测器的分类分数挑选出最终的盒子。

The box with dotted borders has a better chance

过量进食检测

过量饮食中的目标检测属于图像分类领域。唯一的区别是，你需要一些负样本来使分类器能够预测物体之外的背景。显然，多作物和多尺度分类有助于提高准确性和性能。

观察不是干预

原文：https://towardsdatascience.com/observing-is-not-intervening-9fbd22679f44?source=collection_archive---------13-----------------------

偶然的因果推断

以及为什么条件概率是不够的

这是因果推理和数据科学系列文章的第三篇。前一个是“用因果图！”下一个是“解决辛普森悖论”。

在因果推断中，我们感兴趣的是测量变量 A(比如某种特定疾病的治疗方法)对另一个变量 B(比如康复的概率)的影响，这种影响通常来自观察数据。这意味着我们感兴趣的是测量 A =治疗与 A =未治疗病例之间恢复概率的差异。

在数据科学和机器学习中，我们习惯于使用条件概率，这似乎对这个目的很有用。但是，我们会用一个简单的例子看到，光有条件是不够的。

什么是条件反射

以值 X=x 为条件意味着，在 X 取的所有可能值中，我们选择值 x. 的特定样本，例如，如果我们有数据

选择 X=1 将导致

药店示例

想象一下下面的情况。我们去药店，因为我们感冒了。他们有两种不同的药物:药物 1 和药物 2。药物 1 更受欢迎，所以我们首先要求它:他们有 50%的时间，所以我们服用它，我们恢复。在另外 50%的病例中，90%的情况下他们有一种更贵的药物 2，我们买了它，也康复了。但是在剩下的 10%里，他们两种都用完了，所以我们保持冷静。

Drugstore selling diagram

如果实验室停止生产药物 2 怎么办？我们康复的可能性有多大？答案似乎很清楚:50%的病例我们无法恢复。

让我们看看，如果我们尝试用直接条件概率来回答这个问题，会发生什么。如果我们收集前面的信息，我们得到药店销售表。

Drugstore selling table

现在，在没有药物 2 的情况下，治愈的概率是多少？为此，我们需要选择对应于药物 2 =否的样本

No Drug 2 table

并计算恢复的概率

p(恢复中|药物 2 =否)= 50 /( 50 + 5) ~ 91%

这是一个完全不同的结果！

发生了什么事？！

我们可以使用因果图来模拟数据生成过程。

Data generation graph

这张图表反映了我们的观察数据。买药 2 看之前有没有买过药 1，恢复看买过哪些药。该过程产生的数据在上面的药店销售表中获得。

但是，我们关于缺少药物 2 的问题涉及不同的数据生成过程。其中药物 2 不再依赖于药物 1，因为药物 2 总是缺失。

Interventional graph

这个图被称为干预图，它模拟了如果没有药物 2 会发生什么。如果我们可以从这个图中采样数据，我们将获得介入数据表

Interventional data table

我们可以在新的概率分布 P _ intervened 下直接计算

p _ 干预(恢复|药物 2 =否)= 50 /( 50 + 50)= 50%

这是预期的结果。为什么直接条件概率不奏效？因为它们回答了关于由数据生成图生成的数据的问题。在某些情况下是可以的，但在这种情况下，这是不够的。

这个玩具练习是一个简单的例子，用来理解在一般情况下这种类型的分析所附带的问题。这里我们知道数据是如何产生的(因为我们做到了)。然而，获得介入数据表不会如此简单。简单的解决方法是，回到现实，停用药物 2 一段时间，然后测量有多少人康复。当然，在许多情况下，这将会产生很大的不良后果。

因果推理的一个主要问题是，我们是否可以仅从收集的观察数据中从介入图中导出数据，而不必去现实中做实验。意思是，在只有历史数据的介入图中，我们能得到恢复的概率吗？在下面的帖子中，我们将解释如何用经典的辛普森悖论得到这样的结果。

明显的动态规划

原文：https://towardsdatascience.com/obvious-dynamic-programming-part-i-553ae1740c67?source=collection_archive---------8-----------------------

结合动态规划和机器学习

Photo by Tatiana Rodriguez on Unsplash

这个世界上很多问题都是高效算法解决不了的。我的意思是没有比暴力更快的算法了。即使我们使用蛮力，对于很多问题我们也没有足够的时间来解决。因此，我们使用试探法来解决这类问题。试探法是寻找近似的解决方案。这些并不总是最好的解决方案，但仍然比随机的要好。

在开始我自己的探索之前，让我们看一个我提到的这种复杂问题的具体例子。

旅行推销员问题

旅行推销员问题(TSP)是一个很好的例子，因为每个人都能理解基本的问题集。想象一下，一名销售人员接受任务，向几个城市的潜在客户介绍一种特定产品。由于时间和资源的稀缺，销售人员必须以最优的顺序从一个城市到另一个城市，以便使用最短的路线。

为了找到最短的路径，销售人员必须计算所有可能解决方案的总距离。让我们假设有两个城市要去。这很简单，因为只有两种组合可以比较:

2 possibilities to travel to the customers from the orange head quarter

如果我们现在添加一个城市，我们会发现可能性会增加不止一个:

2 possibilities to travel to the customers from the orange head quarter

此外，第四个城市会将可能性空间增加 4 倍。每种可能性都会有 4 种额外的组合。你可以把这个想象成你想把新城放在四个箭头中的一个上。所以你有 6 乘 4 的可能性。这种增长是阶乘的。如果有 n 个城市，我们有 n 个 T2！可能性。因此，如果有 10 个城市:10 个，销售人员会计算很多来找到最佳解决方案！= 3.628.800 种可能性！

这种比较所有可能性的强力“算法”时间效率不高，但它是目前为止找到最优解的最好算法。但是，对于路由程序或其他具有阶乘复杂性的应用程序来说，这不是一个选项。

动态规划求解 TSP

使用强力算法时，组合的某些部分会被计算多次。动态编程解决了这个问题,“记住”已经计算过的行程，以找到比暴力更快的解决方法。缺点是动态规划是一种只能找到近似解的启发式方法。考虑到使用这种方法节省的时间，一个近似值就足够了。

在 TSP 的情况下，想象一个代表计划旅行的所有选项的决策树是有用的:

One track from orange to orange is one of the 6 possibilities when visiting 3 cities.

动态规划(DP)的概念是从橙色的叶子开始，然后回到单个橙色的根。而向上 DP 增加节点之间的距离并记住它们。一旦到达一个有多条出路的节点(如橙色根或第二行中的节点)，DP 就比较输出分支的距离，只记住较小的一条。

g., we start with the distance of 1<>2. Add the distance of 2<>3 and the distance of 3<>4. Then we start with the distance of 5<>6, add the distance of 6<>7 and the distance of 7<>4. At 4 we have to compare the distances 1<>2<>3<>4 and 5<>6<>7<>4 to know which is smaller. The smaller one will then be used to continue going up.

这个概念也可以表述为递归函数:

r 是取一组未去过的城市 S 的递归函数。 r 返回 S 中每个城市 j 的一个元素的集合的最小值，即 i 和 j 之间的距离加上城市 j 经过未访问城市(不含当前城市 i )到目的地的最佳距离。

明显的改进

动态编程是愚蠢的。它的唯一规则是比较每一个可能的组合，每一个…甚至一个被认为是:

Very long route far from being optimal is also considered using DP

很明显，这种结合是无效的。但是算法不能考虑这样的事情。人类的直觉和视觉聚类使我们能够在寻找明显无效的组合时执行节拍 DP 算法。为了向更直观、更明显的方向改进 DP，我采用了数据挖掘的方法。

16 randomly distributed points

首先，我们取 16 个随机分布的点。乍一看，人眼可以立即将这些点连接起来，从而可以创建接近最优的解决方案。让我们以两对直接相邻的点为例。它们可能会相互连接。不幸的是，一个简单的 DP 算法将非常绝望，并试图将它们分开。

Clustered by KMeans

现在，让我们通过用 KMeans 算法对这些点进行聚类来给算法一点直观的感觉。在图中，我们看到 4 个集群。我们总共拿了 16 分。在选择一个聚类数之前，我将总数除以 4，以创建平均 4 个元素的小聚类。4 个元素有可能 4 个！= 24 种组合。这么小的一套，足够快 DP 就能解决。图中的这 4 个聚类类似于真人进行的直观聚类。

The salesperson’s start and end position illustrated as the red point

现在让我们也给销售人员一个随机的位置。红点是现在销售人员的位置。这个位置是整体的起点和终点。

Solving TSP with Dynamic Programming on the clusters only

因为我们现在有了起点和集群，所以我们能够执行一轮 DP。这一轮将从销售人员的位置开始，并通过所有聚类找到近似最短的路线。每个群集的位置由群集到其质心的最近点定义。这一轮 DP 给了我们顶级订单。

Closest connections between the successive clusters

下一步是找到连续聚类之间最近的点。因为我们已经发现了集群的顺序，所以我们知道哪个集群继承了另一个集群。因此，我们可以找到每个聚类对中彼此距离最近的两个点。这使得算法能够定义将在每个单个集群内发生的 DP 过程的起点和终点。

显而易见的动态规划的最后一部分是在每个单个簇中寻找最近的轨道。起点和终点已在之前的步骤中定义。一旦这样做了，我们就有了一个很好的近似最优解。

Final approximation to an optimal solution

当然，有些连接本可以做得更好。但是，如果您将执行该算法所花费的时间与经典的动态编程方法进行比较，您会发现我的方法所花费的时间只有几毫秒，而我在执行简单的动态编程方法 5 分钟后就停止了我的计算机。

在顶层，我们将所有点分成 4 个块。如果你总共有 16 个，顶级也只是一个 4 号的 DP。对于更大的尺寸，我们可以在不同的级别上执行该算法。

结论

提出的方法表明，动态规划不仅比较接近的可能解决方案，而且比较无意义的组合。最后，结果只是基于另一种启发，并不能保证是最好的解决方案。但是，它可以显著加快运行时间。

带有 Akka、Tesseract 和 JavaCV 的 OCR

原文：https://towardsdatascience.com/ocr-with-akka-tesseract-and-javacv-part-1-702781fc73ca?source=collection_archive---------2-----------------------

我最近有一个用例，需要从 PDF 文档中提取姓名和日期。我认为，利用 google 的 tesseract 来执行基本的 OCR，构建一个快速的程序是非常容易的。只需几行代码，您就可以让 node-tesseract 在图像上运行 OCR。但是，如果图像是倾斜的、有噪声的或者其中有一堆图像，那么来自 tesseract 的文本结果将变得不可用。

Tesseract 文档列出了一系列预处理图像以提高 OCR 质量的方法:

重新缩放
二值化
噪声消除
旋转(去歪斜)
边界移除

从图像中提取文本需要很多步骤。我仍然需要执行日期提取和命名实体提取。问题是我不熟悉这些预处理和提取技术。所以我认为构建一个能够拥有可插拔架构的系统是一个好主意——我可以在学习如何实现它们时添加步骤。如果图像可以通过这些不同的转换阶段流动不是很好吗？😉

Akka Stream

旅程

让我们构建一个 REST 服务器，它接受图片作为上传，其中各个端点将返回各种结果。Tess4j 库有许多方便的方法，其中一些我们将用于图像去倾斜和二值化。我们将使用 JavaCV，一个 OpenCV 包装器，用于图像去噪和一般增强。

我们最终将用OpenNLP和Natty以及使用拼写检查器 增强 OCR 输出——第 2 部分 。

我拍了一本书的一页。这将作为系统的输入。注意图片的微小角度。

input.jpg

必需的软件库

Tess4j
JavaCV
Akka HTTP/Streams

让我们创建一个特征来保存宇宙魔方；我们稍后将能够混合这个。

现在，我们将使用 Akka Http 创建我们的基础应用程序，它将绑定到端口 8080。我们创建了一个 rest 端点，它将图像读入内存，并且不做任何处理。该端点最终将返回预处理的图像。

正如我们所看到的，我们的图像是类型BufferedImage的，我们可以使用 Tess4j 的助手方法来创建一个二进制图像。我们将创建一个 BufferedImage 流，它将帮助器函数映射到传入的 BufferedImages。二值化会将图像转换为黑白。这对于文本上有阴影的图像来说效果不好，但是我会在后面详细说明。

然后，我们可以再次使用 Tess4j 来消除图像的倾斜。让我们再创建两个流:一个用最小去歪斜角阈值去歪斜一个BufferedImage，另一个从一个BufferedImage获取字节，这样我们就可以将字节发送回客户端。

现在，我们可以将上述所有流程结合起来，更新我们的服务器。我们将利用内存中的映像制作一个Source，将流链接在一起，并将其传递给 Akka 的complete()方法。

对我们的服务器运行一个简单的 curl 将会返回我们预处理过的图像。

curl -X POST -F 'fileUpload=@/Users/duanebester/Desktop/blog/input.jpg' 'http://localhost:8080/image/process' --output output.png

这是我们的二进制，去歪斜的图像:

厉害吧！？现在我们已经有了流畅的一切，我们可以简单地添加更多的片段来进一步提升我们的形象。此时，我们可以将图像传递给 tesseract，并让它执行 OCR 以给出一个字符串。然而，我觉得 OpenCV 中有太多的图像处理魔法，我们应该使用。

JavaCV 和 OpenCV

JavaCV 和 OpenCV 使用一个称为 Mat 的对象来执行它们的图像处理。面临的挑战是将 Java BufferedImage转换成 JavaCV Mat，然后再转换回来，下面是实现这一点的流程:

我们现在可以流一个BufferedImage ~> Mat ~> BufferedImage😎

OpenCV 有fastnlmeansdexing和 detailEnhance 方法，我们可以在Mat中使用它们——所以让我们将这些方法包装在Flow[Mat]中

我们现在可以

创建二进制文件BufferedImage
将其转换为Mat并增强
将其转换回一个BufferedImage
消除BufferedImage的偏斜，然后将其发送回客户端

A smoother & enhanced image

我们可以在这里添加缩放，这样我们就可以发送一个更小的图像，基本上是裁剪上面图像中的文本，以便 tesseract 进行处理，但还没有到那一步😅

最后一个部分是对BufferedImage执行 OCR，并将结果字符串发送回客户端。我们创建一个将返回一个String的Flow[BufferedImage]——我们还更新了我们的 web 服务器以添加这些额外的流。

当我们运行新的 curl 来获得 JSON 响应时:

curl -X POST -F 'fileUpload=@/Users/duanebester/Desktop/blog/input.jpg' 'http://localhost:8080/image/ocr'

我们得到我们的文本结果:

CHAPTER 1
THE COMPOUND EFFECT IN ACTION
You know that expression, ”Slow and steady Wins the
race”? Ever heard the story of the tortoise and the hare?
Ladies and gentlemen, I’m the tortoise. Give me enough
time, and I will beat Virtually anybody, anytime, in any
competition. Why? Not because I’m the best or the smartest
or the fastest. I’ll win because of the positive habits I’ve
developed, and because of the consistency I use in applying
those habits. I’m the world’s biggest believer in consistency.
I’m living proof that it’s the ultimate key to success, yet it’s
one of the biggest pitfalls for people struggling to achieve.
Most people don’t know how to sustain it. I do. I have my
father to thank for that. In essence, he was my first coach
for igniting the power of the Compound Effect.
My parents divorced when I was eighteen **mohths 01d**,
and my dad raised me as a single father. He **wasn t** exactly

页面朝着图片的底部变得波浪状，宇宙魔方认错了个月大的，忘记了中的撇号不是。尽管如此，我们在上述转换中实现了 99.67%的准确率！

正如你所看到的，有了这个系统，添加我们需要的部件非常容易。我们可以考虑获取字符串结果，并将其传递给更多的阶段，这些阶段可以执行某些拼写检查和名称/日期提取。

感谢并继续 Part 2 ！

~杜安

十月版:课文理解

原文：https://towardsdatascience.com/october-edition-text-understanding-c3594faf2964?source=collection_archive---------7-----------------------

9 篇必读文章

如何开始使用 NLP

由梅勒妮·托西克 — 3 分钟阅读。

我在某处读到过，如果你不得不回答同一个问题两次，把它变成一篇博客文章可能是个好主意。为了遵守这条规则，也为了给我未来的自己节省一些时间，现在我对这个问题的标准答案是:我的背景是科学，我对学习 NLP 感兴趣。

非 NLP 数据和研究人员的词向量

通过康纳麦当劳 — 8 分钟阅读。

单词向量代表了在提高我们分析单词、句子和文档之间关系的能力方面的一个重大飞跃。

word 2 vec 的非自然语言处理应用

通过 Kwyk — 6 分钟读取。

当使用机器学习解决问题时，拥有正确的数据至关重要。不幸的是，原始数据通常是“不干净的”和非结构化的。自然语言处理 ( NLP ) 从业者对这个问题很熟悉，因为他们所有的数据都是文本。

用于自然语言推理的卷积注意力模型

通过Marek galo VI—5 分钟阅读。

在这篇文章中，我想向你展示一个我在 Quora 问题配对竞赛中使用的模型。首先，我将描述一个用于自然语言推理的可分解注意力模型(帕里克等人，2016 )，然后用卷积层对其进行扩展，以提高损失和分类精度。

机器学习，NLP:使用 scikit-learn、python 和 NLTK 的文本分类。

由贾韦德谢赫 — 7 分钟读取。

文档/文本分类是监督的机器学习(ML)中重要而典型的任务之一。为文档分配类别，文档可以是网页、图书馆书籍、媒体文章、图库等。有许多应用，例如垃圾邮件过滤、电子邮件路由、情感分析等。

一个数据科学练习:根据就职演说，特朗普与其他总统有多相似？

由布莱恩·雷 — 4 分钟读完。

这是基于谷歌团队编写的一些 NLP(自然语言处理) Doc2Vec 算法的运行结果。(浅层，两层神经网络)。

这首诗是什么时候写的？我的电脑可以告诉你

由查姆格鲁克 — 6 分钟读完。

我最近的项目真的很令人兴奋。我热爱诗歌已经有一段时间了，所以我选择它作为我第一次涉足自然语言处理(NLP)的主要领域。

使用预先训练的 word2vec 进行迷因搜索

通过 Eyyüb Sari — 6 分钟读取。

模因抵得上千言万语。它们是一种文化。我和我的朋友过去常常用 Giphy 在 Messenger 上发送很多这样的消息。

Scikit-了解亚马逊美食评论的文本分析

由苏珊李 — 7 分钟读完。

我们知道亚马逊产品评论对商家很重要，因为这些评论对我们如何做出购买决定有着巨大的影响。

十月版:无监督学习

原文：https://towardsdatascience.com/october-edition-unsupervised-learning-14def1fbe11b?source=collection_archive---------8-----------------------

8 篇必读文章

Pixabay.com

无监督学习由数据科学家和其他数据从业者使用，在这个机器学习算法家族中，没有已知的输出或标签来指示学习算法。在聚类中使用了不同类型的无监督学习，例如 K-Means 聚类、文本挖掘和维数减少，例如在预处理阶段使用的主成分分析，以转换用于监督学习机器学习建模的数据集。

最近，航空公司可以使用聚类算法来分析客户反馈调查，保险公司已经审查了他们的客户投诉登记册，选举 Twitter feeds 已经分组在一起，以监控全天的关键讨论主题，分析新闻文档的语料库，并进行主题建模以提取关键主题。

聚类根据相似性将数据划分为不同的组。算法的类型是多种多样的，包括基于距离连接对象的分层聚类和将聚类表示为单个均值向量的 K 均值聚类。

使用无监督学习的挑战是确定它是否“表现良好”，因为输出的标签是未知的。无监督学习的好处包括能够在探索性数据分析阶段对数据进行预处理，以便对训练和测试数据进行缩放。因此，转换后的数据允许数据科学家在监督学习(如岭回归)之前，使用主成分分析来可视化数据的方向并减少维度或特征的数量。

我们希望你会喜欢并在这个月学到一些新的东西，因为我们通过编辑从《走向数据科学》中精心挑选的内容来探索无监督学习。

Wendy Wong ，TDS 编辑。

用 Python 进行无监督学习

由维哈尔鞍马 — 7 分钟阅读。

无监督学习是一类机器学习技术，用于发现数据中的模式。提供给无监督算法的数据没有标记，这意味着只提供输入变量(X ),没有相应的输出变量。在无监督学习中，算法自己去发现数据中有趣的结构。

使用无监督学习来计划去巴黎的假期:地理位置聚类

通过 Hamza Bendemra — 6 分钟阅读

因为我自己也去过巴黎几次，我想我可以在其他方面有所帮助，比如为旅游景点列表做贡献。在列出所有的景点之后，我创建了一个谷歌地图，每个位置都有一个图钉。

现实生活中的 K-Means:聚类锻炼时段

By 卡罗莱纳便当 — 6 分钟阅读

K-means 聚类是一种非常流行的无监督学习算法。在这篇文章中，我想提供一些关于它的背景知识，并展示我们如何在真实生活中使用它。

我们编织了一张多么解开的网:VAE 的表征学习

由科迪·玛丽·怀尔德 — 15 分钟阅读

无监督学习的一个常见策略是生成模型，其思想是:你应该给模型一个从给定分布中产生样本的任务，因为在该任务中表现良好需要模型隐式地学习该分布。

对抗性自动编码器的向导指南

通过 Naresh Nagabushan — 9 分钟读取

我们知道，卷积神经网络(CNN)或在某些情况下密集的全连接层(MLP——一些人喜欢称之为多层感知器)可以用来执行图像识别。但是，CNN(或 MLP)不能单独用来执行像从图像中分离内容和风格这样的任务…

在 SELU 自动编码器(不是另一个 MNIST)上高斯混合模型的无监督学习

由gona lo Abreu—5 分钟读取

大多数聚类方法都受到维数灾难的困扰。这样，为了执行无监督学习，降维方法是必要的。

使用数据、聚类和可视化发现我的 Spotify 音乐的相似之处

由胡安·德·迪奥斯·桑多斯 — 16 分钟阅读

音乐品味是一个人非常独特、奇特和有特色的品质。在现存的数以百万计的歌曲和声音中，我认为许多人决定发展对一种特定风格、流派或音乐“子集”的喜爱并非偶然。

自然语言处理从业者指南

由迪潘詹(DJ)萨卡尔 — 31 分钟读取

非结构化数据，尤其是文本、图像和视频包含了丰富的信息。然而，由于处理和分析这些数据的固有复杂性，人们通常不会花费额外的时间和精力从结构化数据集冒险出来分析这些非结构化数据源，这可能是一座潜在的金矿。

A 型数据科学家的颂歌

原文：https://towardsdatascience.com/ode-to-the-type-a-data-scientist-78d11456019?source=collection_archive---------4-----------------------

分解他们提供的影响，以及为什么下一代不关心

神话中的独角兽

你现在可能已经听说过难以捉摸的科学独角兽 da了。如果你还没有，独角兽是在数据科学领域及其周围掌握了几种跨学科技能的专业人士。他们有你关于数据分析、机器学习、产品指标、大数据、实验、深度学习、商业敏锐度、领域知识等问题的所有答案。

这一罕见壮举的更好的可视化可以在下面的的研究中看到，调查了 400 多名数据专家，他们对不同区域的舒适度进行了调查，这些区域可以被归类为真正的独角兽。

Source: Business Over Broadway

正如你可能想象的那样，找到一个在这些方面都擅长的人肯定不容易；这几乎是不可能的。由于领先公司中的这种认识，我们开始看到在更广泛的数据科学领域中形成了专门的角色。

这些专业化包括机器学习工程师、数据工程师、数据分析师、产品科学家、核心数据科学家、数据研究员、定量分析师等职位，以及其他已经与更知名的数据科学家一起成为常见固定职位的角色。

Source: Mindful Machines

正如您在上面所看到的，这些角色之间总会有一些重叠。这通常取决于每家公司、他们的数据生态系统以及他们的未来目标。信不信由你，事情不会就此停止。我们可以进一步分解它。

A 型与 B 型

数据科学界许多备受尊敬的人士尝试对不同类型的数据科学家进行分类。然而，没有人比潘多拉公司的前研究主管迈克尔·霍彻斯特博士更有效了，他在 Quora 上给出了以下答案:

**A 型数据科学家:A 是做分析的。**这种类型主要与理解数据或以相当静态的方式处理数据有关。A 型数据科学家非常类似于统计学家(也可能是一名统计学家)，但他们知道统计学课程中没有教授的所有数据处理的实际细节:数据清理、处理非常大的数据集的方法、可视化、特定领域的深入知识、写好数据等等。

B 型数据科学家:B 代表建筑。B 型数据科学家与 A 型共享一些统计背景，但他们也是非常强的编码员，可能是训练有素的软件工程师。B 型数据科学家主要对“在生产中”使用数据感兴趣他们建立与用户互动的模型，通常提供推荐(产品、你可能认识的人、广告、电影、搜索结果)。

这些描述主要适用于在行业中使用数据科学，但我发现它们在我的经验中非常准确。同样值得注意的是，这些分类不是确定的，当然也不是一成不变的。你可能拥有两种类型的混合技能，这没什么不好。事实上，如果做得正确，它实际上可以带来独特的、无价的技能组合，有助于创造性和有效的解决方案。

下一代

如果你在最近的新闻中看到数据科学，无论是《T4》《纽约时报》的一篇特写还是 TechCrunch 的一篇文章，都有可能关注机器学习和人工智能的影响。

这是有充分理由的。人工智能和机器学习的发展将继续对我们所有人的生活产生越来越深远的影响。这种现象以这样或那样的方式影响着地球上的每个人，大量的媒体报道反映了这一点。考虑到这一点，让我们来探讨一个该领域的任何领导者都应该牢记的重要问题:

这对下一代数据科学家意味着什么？

如果您还记得我们对数据科学家的深入分类，这些令人兴奋的新技能非常符合类型 B 的描述，重点是在生产中处理数据时构建和部署模型。

很明显，像机器学习这样的数据技能目前被更多的炒作和吸引力所包围。出于这个原因，有抱负的数据科学家正在进入这个领域，他们的目光瞄准了这个基于 ML 的特殊技能集。

我的意思是，谁不想建立让你预测未来的机器学习模型？谁不对模仿人脑的推荐系统和神经网络着迷呢？

Source: Machine Learning Mastery

对这些技能的需求肯定是存在的，正如大量数据驱动的教育倡议和目前快速增长的人工智能和人工智能工程师库所证实的那样。

但是，这种心态有点短视。尽管标题和流行语暗示，大多数问题都不能用机器学习来解决。

我想利用这篇文章的剩余部分来论证与经常被忽视和低估的A 型数据科学家相关的技能和行动所提供的价值。

我为什么要关心 A 型数据科学家？很高兴你问了…

他们回答困难的问题

A 型数据科学家从数据中提取信息，以探索和回答通常由领域专家、商业领袖或管理层提出的复杂问题。这看起来并不那么迷人，数据科学也是如此——事实并非如此。您几乎总是需要处理和清理一些数据。

然而，一旦你过了这个阶段，事情就会很快变得有趣起来。对于提出的问题，很少有直接的答案。你必须有创造力，想出一条看似无限的路线来往下走。

“批判性思维技能将黑客与真正的科学家区分开来”——杰克·波威

这是这个职业给许多人带来的后果。然而，我不敢苟同。分析和解决问题的无限方法在很大程度上使得数据科学对如此庞大的人群如此具有挑战性和趣味性。

他们让复杂变得简单

可以说，数据科学家可能拥有的最重要也是最容易被忽视的技能是简单而彻底的沟通。解构复杂的解决方案并将其打包，以便业务领导、产品经理或用户能够理解，这不是一个小任务。

“数字本身无法说明问题。我们为他们说话。在我们要求更多的数据之前，我们需要对自己提出更高的要求。”——Nate Silver

我们表达数字的方式可以有很大的不同；这些包括演示技巧、数据故事、数据可视化、商业洞察力和技术写作。能够决定使用这些工具中的哪一个，并以一种有效的方式这样做并不容易，但这非常令人满意。

他们始终推动影响

很自然，你的结果取决于他们的影响力。A 型数据科学家通常会有机会比他们的B 型同行在日常工作中产生更多影响。你不用花时间在特性工程和迭代模型上，而是探索直接影响业务或产品决策的问题。

"没有任何伟大的营销决策是基于定性数据做出的."—约翰·斯卡利

对于A 型数据科学家来说，增值的转变也要快得多。您将会得到一致的工作反馈，因此，您将有机会作为一名数据科学家快速成长。

强行推销

这篇文章的重点不是阻止任何人专注于开发机器学习工具包来构建强大的模型。就我个人而言，我每天都花时间来发展这些技能。我还认为，在生产中使用数据是一个非常有用的工具，可以以独特的方式扩展您的项目并影响业务。

简而言之，B 型数据科学无疑也有它的优势。每种技能组合处理生态系统中非常不同的部分。这两种类型都生活在更大的、快速发展的数据科学城市的不同社区。

然而，我相信，由于围绕机器学习和人工智能的炒作，目前绝大多数即将到来的数据人才都被吸引到 B 型工作。出于这个原因，我担心与A 类数据科学相关的有效技能，主要是处理分析和交流的技能，会被忽视。

虽然分析和交流可能不像机器学习那样性感，但现实是它们在行业中提供了最一致的影响。

在一个数据是新石油的世界里，利用分析来解决问题是一件非常有力量的事情。当然，你有时会被卡住。这就是努力工作的好处。总有另一个挑战需要解决。另一个需要解决的问题。另一个要回答的问题。

对于那些问题，我们有A 型数据科学家。

感谢阅读！如果你喜欢这篇文章，请继续向鼓掌按钮展示你的爱。如果你对未来的更多帖子感兴趣，请确保关注我并订阅下面的我的简讯以接收任何新内容。更多关于我和我在做什么，请查看我的网站。

禁忌、邻居和优化

原文：https://towardsdatascience.com/of-taboos-neighbors-and-optimization-2955b72fbdf?source=collection_archive---------12-----------------------

改善您的路线

“A mailman sitting in a mail truck sorting mail parked outside of a house in Tulsa” by Pope Moysuh on Unsplash

假设你经营一个快递车队。每天，您必须通过将包裹分配到配送货车来安排包裹递送，确保它们按时送达，确保您不会让任何货车超载，确保工作在司机之间平均分配，确保司机不会超过他们的合同和法律约束期，确保您最大限度地减少燃料消耗……根据您的特定业务，这个清单还可以继续下去。GOGOVAN 的 Kamil Bujel 曾在另一篇文章中描述过这种特殊情况。

他们通过使用现成的优化包来解决这个问题，以帮助他们解决手动调度车辆的日常繁重工作。Kamil 在他的文章中详细描述了这个过程，以及他们试图让算法在合理的时间和内存范围内工作所经历的麻烦。但是为什么优化解决方案会有这样的表现呢？为什么会消耗这么多内存？这样，优化解决方案就像一个黑匣子，它的用户很少或根本不知道里面可能会发生什么。

如果我们能看到这些优化算法中的一个会怎么样？为了吐出一个“优化”的解决方案，他们在引擎盖下表演了什么样的魔术？我决定在 Kamil 自己的文章之后写这篇文章。碰巧的是，在其他事情中，我一直在为我自己的公司开发一个这样的路线优化算法，这篇文章是我通过实现一个特定类型的优化算法所学到的东西的一个简短的精华。

离散优化

优化是一个误称，因为我们很少找到最好的解决方案。这个领域的所有研究，从臭名昭著的旅行推销员问题(TSP)开始，会告诉你最优解只能在玩具问题中找到。真正的问题，有数百辆车和交货地点，实在是太大了，无法在有用的时间内完全搜索，所以我们必须用一些聪明的方法。此外，我在这里讨论的优化类型是离散型的。如果你熟悉连续优化，那么你可以利用梯度，以便沿着最陡的路径下降到全局最小值。离散优化就没有这种运气了。向组合中添加另一辆货车，或删除一个交货，或在货车之间移动一个交货会产生什么结果？你必须尝试这个选项，评估结果，然后决定怎么做。这基本上是我们如何在精神上做这种类型的优化，也许使用几个显而易见的规则，如地理分组交付。

我已经提到了一些没有很好定义的术语。我提到了一个最小值。但是最少什么？我们是否希望最小化车辆、距离、时间和燃料消耗？这个问题很容易回答:我们希望最小化日常运营成本。但是这个成本怎么算呢？好奇的读者，请继续读下去。

路线优化

路线优化是如何工作的？计算我们必须服务的工作的最优车辆分配需要什么？如何计算时间和顺序，以便我们最大限度地降低运营成本，同时保持高客户满意度和低司机流失率？我们从哪里开始？我们如何结束？

这篇文章将告诉你这个问题的一个可能的解决方案，一个臭名昭著的旅行推销员问题(TSP)的扩展，使用一些具有异国情调的名字的扩展。在这里，我将解释一个解决这个问题的实现，通过解决一个真实的发行公司的需求，像 GOGOVAN 。如果你还没有这样做，请阅读 Kamil 的文章，以获得一个这样的公司如何运作，以及他们的优化挑战是什么。

我不是使用现成的解决方案，而是在概念上开发一种方法，基于禁忌搜索、局部搜索和可变邻域搜索来解决相同的问题。让我们继续学习这些概念。

在快递这一行，你每天都要处理大量相对较小和较轻的包裹。交货是在具有给定货物容量的类似货车中进行的，通常以重量、体积、单位或这三者的任意组合来衡量。计算车辆载货量很重要，因为这是这个问题的一个硬限制，也就是说，出于安全和法律原因，你不能让货车超载。如果一辆或多辆货车装载的货物超过允许的数量，您就无法设计出解决包裹配送问题的方案。这不是一个可行的方案可行的方案。当我谈到可行的解决方案时，我指的是不违反像这样的硬性限制的解决方案。请注意，一个可行的解决方案可能会违反软限制，例如当货车计划晚点到达给定的客户时。在这种情况下，这种解决方案(通过应用迟到成本惩罚)会比所有货车都准时交付的另一种方案更昂贵。请注意，选择什么是硬限制或软限制完全由你决定，我只是用我以前用过的限制来说明这个概念。

在这种类型的交付场景中，所有车辆每天一次被装载到一个地方，即中央仓库(我从跟踪我的网上购买推测是在清晨)。优化算法的目的是通过确保满足交付时间，同时保持最低的运营成本，来计划所有的日常交付。

如果这个优化过程是一个烹饪食谱，那么我们需要关心的配料是什么？我们有客户、送货、货车、司机、道路、交通和运营成本。让我们对其中的每一项进行建模，以便了解我们需要的信息类型。

客户

客户可以很容易地被建模为简单的地理位置，即他们的纬度和经度。地理配准客户是一个重要的步骤，因为我们需要推导出运营地图中任意两个位置之间的行程持续时间和距离。为了计算这些，必须将所有客户位置转换为地理坐标，以便距离和时间计算方法能够正常工作。如果这些客户有特定的交付时间窗口，那么这些也可以考虑并记录下来。如果这样做，还要考虑打破这些时间窗口是硬限制还是软限制。请记住，硬限制会使解决方案无效，而软限制只会增加解决方案的成本。当我们考虑成本最小化时，会有更多的讨论。

交付

交付是一个简单的陈述，一辆货车必须访问一个客户位置，并在那里花费给定的时间交付给定货物尺寸(重量、体积、单位)的包裹。这意味着单次交付必须被视为从车辆到达交付地点的行程，加上执行交付所需的时间。优化程序将试图在时间和货车中调整交货，以便以低成本产生一个高效的解决方案。

车辆

除了每辆货车的唯一标识符(如牌照)之外，我们还需要每辆货车的最大载货量记录。将交货分配给给定的货车时，我们从可用的车辆货物中扣除交货货物尺寸，剩余值必须为正数。否则，我们会超载的。

除了这些数据，我们还必须记录每辆货车的任何相关运营成本，如租金、每公里成本或其他可用于优化程序最小化的成本。

我还要假设每辆车都有自己的司机，所以司机不是稀缺资源。然而，我们需要考虑的是任何合同安排，比如每天最长工作时间，或者公司工作时间。使用这种简化，这些限制可以应用于货车本身，我们不担心司机作为一个优化实体。

道路和交通状况

道路网络和交通阻抗是强加于模型的外部条件，必须予以考虑。在这里，我们有一系列的可能性，从最昂贵和最复杂的(从 Google 或 Here 等专业提供商处获取数据)到最便宜和不太精确的(使用测地线测量值结合距离因子计算所有距离)，以及用于计算行程持续时间的平均速度。如果您选择第一种方式，流量也是一种选择，既可以作为实时反馈，也可以作为给定时间间隔内的典型阻抗。无论如何，你必须能够建立任意两点之间的距离和持续时间对的矩阵，因为这是优化算法的主要材料。

成本

我一直提到运营成本，因为这将有助于衡量优化器生成的解决方案的质量。为了做到这一点，我们必须创建一个成本函数,将前面所有的成分转换成同一个指标:经济成本。使用每公里成本率将距离转换为成本。使用罚金将延误转化为成本。使用货车的每日折扣率或租赁率将车辆使用率转换为成本。您可以将这些成本视为真实的分类账成本和/或您对优化流程的个人偏好。例如，如果您不关心要使用的货车数量，您可以将它们的单个成本设置为零。另一方面，如果您想要最小化货车的数量，请指定每辆车的使用成本。因此，优化器会倾向于使用较少的 van 的解决方案。距离也是如此。请注意，优化器在决定最佳解决方案时，只会查看这个成本函数的输出，，其他什么都不会做。这就是为什么所有的重要变量都必须转换成一个成本，并包含在这个成本函数中。

优化过程

既然所有的配料都收集好了，我们可以开始做饭了。

我将使用术语“解决方案”来表示一个可行的配置，它只是车辆的集合，每辆车包含一个有序的计划交付的集合。这些计划交付包括关于开始和结束时间以及它们的地理路线的信息。

A toy solution with three vans and six deliveries

对于每个解决方案，可以通过成本函数计算相关成本。优化器将尽力最小化该成本，，即，在给定所有限制和计算时间的情况下，找到具有最小可能成本的解决方案。

初始解

我们需要做的第一件事是创建最初的解决方案。就像匆忙地把你孩子的所有玩具放进一个盒子里，让盖子关上，我们将使用任何必要的试探法来创造一个这样的可行的解决方案。请注意，这将是一个成本高昂的糟糕解决方案。但这是可行的。这是我们的起点，我们现在可以开始改进了。

改进循环

改进初始解决方案需要一个非常简单的概念:对初始解决方案做一个小的扰动(确保我们仍然得到一个可行的解决方案)，然后评估它的成本。但是什么是扰动呢？它可以简单到改变一辆货车的交货顺序，或者将一批货物从一辆车转移到另一辆车上。它可以是简单的，也可以是复杂的。在某种意义上，这是一个邻域并且在其中的搜索是一个局部搜索。

Perturbing a solution by moving a delivery

请注意，可以将邻域视为执行单一类型扰动的算法。在图片的例子中，它的工作方式是将一批货物从一辆货车转移到另一辆货车上。还要注意，货车内的交货顺序也很重要，因为它决定了交货的顺序，进而决定了要走的路线。这对距离成本有明显的影响。

正如我之前提到的，不可能预先知道给定的扰动是否会降低成本。与连续优化相反，我们不能计算成本函数的梯度，并跟随它们下降到(希望是)全局最小值——我们必须做出改变并评估其价值。它降低了成本，增加了成本还是保持不变？我们该怎么办呢？如果它降低了成本，我们可以采用它作为我们的下一个最佳解决方案，即现任解决方案。现任解决方案是目前为止最好的解决方案，成本最低，是您在优化过程结束时将使用的解决方案。

但是如果我们的扰动增加了求解成本呢？我们是不是放弃这个解决方案，尝试另一个方案，直到我们获得更低的成本？还是我们采用了更差的解决方案，希望它会带来更好的解决方案？如果你从高空滑下，这就像爬上附近的土堆，希望另一边有一个更陡的斜坡。

从我的经验来看，你可以两者都做，但在不同的情况下。第一种方法是所谓的贪婪搜索，当不同的可能解决方案的数量——状态空间——非常大时，这种方法似乎效果最好。在这些场景中，可能的解决方案数量如此之大，以至于你几乎总是可以指望一条下降的路径。对于较小的状态空间，情况并非如此。在这里，经验告诉我允许成本增加，以便优化器能够找到附近更深的成本谷，在那里它可以寻找更好的解决方案。

现在我们可以返回，用我们更新的解运行循环，产生另一个扰动，看看会发生什么。这是一个决定我们是坚持使用同一个小区还是应该使用另一个小区的好时机。这个决定可能非常重要，尤其是当其中一个邻域似乎停留在局部最小值上，无法产生更好的解决方案时。决定何时改变邻域以及改变到哪个邻域的方法本质上是启发式的。简而言之，这就是可变邻域搜索(VNS)。

这是严格的禁忌……

这个计划还有最后一个要素:我们必须像迷宫中的阿里阿德涅一样，标出我们要走的路。每个生成的解决方案都必须保留在一个列表中以备将来使用，以防止优化器再次探索它。因此它的名字叫做:禁忌列表。每当优化器生成一个新的解决方案时，它必须查看禁忌列表，并检查该解决方案是否已经生成(或被访问过)。如果是这样，它应该尝试另一个，可能是第二好的。

停止准则

那么我们什么时候停止？正如我之前所说的，几乎不可能知道你找到了可能的最佳解决方案，所以必须有一个预设的标准来停止改进循环并报告现有的解决方案。在这里，我把它留给你的想象力。我的不是很牵强，所以我用了一个严格的时间标准。在运行优化过程之前，我指定了我愿意等待“优化”解决方案的时间。仅此而已。

或者，您可以计算流程已经计算的循环次数，并在 N 次无改进循环后停止。

结束语

我希望现在这样更有意义。毕竟，这些都是简单的概念，有着花哨的名字，围绕着现代技术的计算能力。但是我在这里仅仅触及了表面。还有更多细节等待着您去探索，尤其是当您开始使用并行化的强大功能时。没有剧透给你，继续探索这个迷人的世界离散优化！

推荐阅读

国际卡车运输的动态车队管理:关注临时运输任务(生产和物流)

反应式搜索和智能优化(运筹学/计算机科学接口系列)

狮子道

哦，我的天啊！

原文：https://towardsdatascience.com/oh-my-god-cb69dd74839c?source=collection_archive---------9-----------------------

最近看了 90 年代的经典电视节目《老友记》之后，我认为“哦，我的上帝”这句话说得太离谱了——现在我有数据可以证明这一点。

“‘哦，我的上帝！’常用作感叹词，强调惊讶、愤怒或震惊。"

— Quora

汇编数据

利用《老友记》电视节目的抄本，我搜索了全部 236 集的对话，以确定每个角色说“哦，我的上帝”的频率。

包括什么？

必须说出“哦”、“我的”和“上帝”这三个词(按此顺序)才能包含在计数中。允许字符暂停或向短语添加额外的单词。以下是一些可接受的例子:

不包括什么？

其他提到上帝，但不符合上述要求的短语将不会被计算在内。下面列出了一些例子:

Season 3, Episode 5: Sorry Ross — Mouthing the words “Oh my God” will not be tallied.

结果呢

《老友记》在 NBC 电视台成功播出了 10 季(1992-2003)。在此期间，这句话“哦，我的上帝”被说了 1069 次*。下面我们来看看详细的结果:

第九季以 126 分代表了“天啊”狂潮的巅峰。

一些粉丝可能会认为扮演贾尼斯的女演员玛姬·惠勒会是我们的“哦，我的上帝”冠军(因为这是她的标志性对白)。

Maggie Wheeler portrayed Janice in 19 episodes of Friends.

然而，惠勒女士只在《老友记》的 19 集中出现过，她根本没有机会对抗我们过于戏剧化的主角。

莫妮卡和瑞秋占了“哦，我的上帝”话语总数的近 50%。

罗斯在大结局时非常激动，他说了 9 次“哦，我的上帝”。

有趣的发现

《老友记》一集的平均时长是 20-22 分钟。因此，“哦，我的上帝”大约每 5 分钟说一次！
只有 8 集“我的天啊”是不是说的。
该系列的大结局一集包含了在一集里最多提及的“哦，我的上帝”，共有 23 次。公平地说，这一集被认为是两集。
在第十季中，莫妮卡拥有单季 38 次“哦，我的上帝”惊呼的记录。
瑞秋是《哦，我的上帝》中被提及次数最多的角色，共有 269 次。在 10 季中的 6 季里，瑞秋是说“哦，我的上帝”最多的人。她也是在 10 集的单集中被提及次数最多的角色。👇

Season 2, Episode 4: Rachel encounters a pigeon and shouts “Oh my God” (at least) 10 times.

重要比较

好吧，那么这些年轻的、令人难以置信的朋友们说了 1050 多次“哦，我的上帝”——是不是很多？让我们比较一下“哦，我的上帝”和《老友记》中其他一些流行的美国英语单词/短语。

A search of the Friends transcripts indicates that “Oh my God” was said much more frequently than these other common words, phrases, and Friends-specific catch phrases.

“表达‘哦，我的上帝！’…[是]20 世纪 80 年代圣费尔南多“山谷语”流行文化兴起的一部分。"

— Quora

因为“哦，我的上帝”这一表达方式在 20 世纪末变得更加流行，也许它也经常出现在那个时代其他流行的情景喜剧中？

没有。《老友记》似乎自成一类。

The estimated average amount of times “Oh my God” is spoken per script in popular ’90s sitcoms.**

结论

“哦，我的上帝”似乎经常出现在《老友记》中，对此我很恼火，于是我在网上搜索了一下，看看是否有傻瓜统计过这个短语在节目中出现了多少次。当搜索没有返回确定的答案时，我意识到我可能就是那个傻瓜！完成任务后，我开始在指标中寻找更深层次的意义。

自从《老友记》第一集播出以来，文本中提到“哦，我的上帝”的次数增加了两倍，这是巧合吗？

Google Ngram measures the frequency of an phrase in text sources printed between 1500 and 2008.

许多人认为说“哦，我的上帝”违反了第十条戒律并且轻视了上帝的名字。《老友记》是否对保守价值观的急剧转变负有部分责任？

1951: Married couple Lucy and Ricky sleep in separate beds (left). 1996: Roommates Monica and Rachel argue over who will use the last condom (right) to engage in premarital sex. An argument that is ultimately settled with a game of Rock-Paper-Scissors.

《老友记》是否描绘了一种过于随意和进步的不切实际的生活方式？从而导致近年来美国的钟摆向相反的方向摆动？

🤔我认为这些问题最好改天在另一篇文章中回答，可能由比我聪明得多的博客作者来回答。

*数据假设记录完整准确。我尽了最大努力获得准确的人工计数。

*估计基于对每部情景喜剧一季的分析。《弗雷泽》(第二季)、《宋飞正传》(第四季)和《保姆》(第二季)。季节是随机选择的，但为了确保可比的样本量，精选了 20 多集。

好的，Alexa…你是怎么工作的？

原文：https://towardsdatascience.com/ok-alexa-how-do-you-work-4365ddb588b4?source=collection_archive---------2-----------------------

“我有许多由许多人制造的组件。”—亚马逊回声

“我可以帮你做很多事情。例如，你可以说这样的话……要查看更多示例，请查看 Google Home 应用程序。”—谷歌主页

这不是我想要的答案。

好的，杰瑞，声控扬声器是如何工作的？

我最近偶然发现了 YouTube 上风险投资家 a16z ( 安德里森·霍洛维茨)的频道，并立即被他们的视频内容吸引住了，尤其是他们的动画短片系列。在我的最爱中，普通合伙人维贾伊·潘德、本尼迪克特·埃文斯和克里斯·迪克森分别将机器学习、S 曲线和创新者困境的复杂概念，分解成易于消化、易于理解的 5 分钟视频。

受到他们例子的启发，我决定创作自己的动画短片，尽可能清晰简洁地总结我的热情和研究领域——语音计算。是动画 TL；我写的文章的博士，如果你愿意的话。利用类似的手绘视觉效果和彩色动画，我想创造一个简短的抓住本质

为什么语音是下一个大的平台转移
以语音为中心的设备如何工作
我们如何衡量音频传感器的质量，以及如何增强方向性
亚马逊 Echo 和谷歌 Home 中已经包含的定向麦克风还有待改进

语音计算已经在我们中间了。事实上，百度首席科学家吴恩达预测，到 2020 年，50%的搜索将基于语音或图像。同样，Juniper Research 的一份报告发现，到同一年，语音智能扬声器将进入 55%的美国家庭。随着我们一点点接近那个未来，我很高兴看到初创公司继续 1)为亚马逊 Echo 和谷歌 Home 生态系统开发服务，2)寻找在多个行业使用语音的新机会，以及 3)建立支持语音的基础设施——为日益增长的语音技术热潮提供支持。

如果您喜欢该视频，请点赞、评论并分享。我很想听听你对你希望我深入研究的其他领域的看法。

此外，我强烈推荐去看看并订阅 a16z 的 YouTube 频道。除了短片之外，它还提供了很棒的内容，如他们一年一度的 a16z 峰会的视频记录和 Frank Chen 对所有前沿技术的特殊走查。

好的谷歌:如何进行语音识别？

原文：https://towardsdatascience.com/ok-google-how-to-do-speech-recognition-f77b5d7cbe0b?source=collection_archive---------10-----------------------

语音识别是检测口语单词的任务。有许多技术可以进行语音识别。在这篇文章中，我们将介绍语音识别所需的一些背景知识，并使用一种基本技术来构建一个语音识别模型。该代码可在 GitHub 上获得。对于这篇文章中提到的技术，检查这个 Jupyter 笔记本。

“turned-on charcoal Google Home Mini and smartphone” by Bence ▲ Boros on Unsplash

音频处理的一些背景知识

让我们后退一步，理解音频到底是什么。我们都在电脑/手机上听音乐。通常，它们是 mp3 格式的。但是. mp3 文件并不是真正的音频。这是一种在我们的计算机中表现音频的方式。我们不会直接打开. mp3 文件并阅读它们(就像我们阅读一样。记事本中的 txt 文件)。我们使用应用程序打开那些. mp3 文件。这些应用程序知道什么是. mp3 文件以及如何播放它们。这些 mp3 文件编码(代表)音频。

音频被表示为波。通常，这些波有两个轴。x 轴表示时间，y 轴表示振幅。所以在每一个时刻 t，，我们都有一个振幅值。

Sine wave — A simple audio wave (Source)

你可以在这里听一个简单的正弦波。太好了！现在我们只需要弄清楚如何在我们的代码中使用这些音频文件来执行识别。

使用音频文件

我们将使用波形音频文件格式或。wav 文件。那么我们该如何解读这些？wav 文件？输入 librosa——一个允许我们阅读的 python 包。wav 文件。看完这些我们得到了什么。wav 文件？我们得到了大量的数字。这是我读了一个 1 秒长的音频文件后得到的输出。

数组([ 0.0007143，0.00551732，0.01469251，…, -0.00261393，-0.00326245，-0.00220675]，dtype=float32)

这些数字是什么意思？记得我告诉过你，音频被表示为具有两个轴的波。这些值代表该波的 y 轴，也称为振幅。那么 x 轴 aka 时间是怎么表示的呢？这就是数组的长度！所以对于 1 秒的音频，长度应该是 1000(1000 毫秒)。但是这个数组的长度实际上是 22050。这是哪里来的？

采样率

考虑一个 5 秒钟的音频剪辑。如果它是模拟的，那么它在每一瞬间都有一些振幅值，也就是每纳秒，或者每皮秒都有一些值。因此，考虑一个 5 秒钟的音频剪辑，它对每一皮秒都有一定的价值。那些是 5e+12 或500000000000值。想象一下储存在电脑上。在 C 语言中，存储一个浮点值需要 4 个字节。所以是 5e+12 * 4 字节。仅 5 秒钟的音频片段就需要大约 18tb 的数据！

Analog vs Digital Audio Signal (Source)

我们不想仅仅为了存储一个 5 秒钟的音频片段而使用 18tb。所以我们把它转换成离散形式。为了将其转换为离散形式，我们在每个时间步长记录样本(也称为振幅值)。因此，对于 5 秒钟的音频，我们可以每 1 秒钟记录一次样本。那只是 5 个值(样本)！这被称为采样率。

Sampling Rate (Source)

形式上，采样率是每秒收集的样本数。这些收集的样本在时间上以相等的间隔隔开。对于上面的例子，采样率是每秒 1 个样本。你可能已经注意到有很多信息丢失。这是从连续(模拟)转换到离散(数字)的一个折衷。采样率应尽可能高，以减少信息损失。

那么为什么我们得到了长度为 22050 的数组呢？如果没有指定，Librosa 使用默认的采样率 22050。你可能会奇怪，为什么是 22050？这是人类听觉范围的上限。人类可以听到 20 赫兹到 20 千赫的频率。那 20 千赫就是 22050。更常见的采样速率是 44100，即 44.1KHz。

另外，请注意，我们得到的是 1D 数组，而不是 2D 数组。这是因为。我使用的 wav 文件是单声道音频，而不是立体声。有什么区别？单声道音频只有一个声道，而立体声有两个或更多声道。什么是频道？简单来说，就是音频的来源。假设您使用一个麦克风来录制您的两个朋友之间的对话。在理想情况下，麦克风只录下你朋友的声音，不录下任何其他背景噪音。您录制的音频有两个声道，因为有两个信号源，即您的两个朋友。现在，如果背景中有狗叫声，音频将有 3 个通道，3 个来源是你的朋友和狗。

在音频处理中使用之前，我们通常会将立体声音频转换为单声道音频。再次，天秤座帮助我们做到这一点。我们只是在加载时传递参数 mono=True 。wav 文件，它可以为我们将任何立体声音频转换成单声道。

音频识别功能

我们可以使用上述时域信号作为特征。但是它仍然需要大量的计算空间，因为采样率应该相当高。表示这些音频信号的另一种方式是在频域中。我们使用傅立叶变换。简而言之，傅立叶变换是一种工具，可以将时域信号转换到频域。频域中的信号需要少得多的存储计算空间。来自维基百科，

在数学中，傅立叶级数是一种将函数表示为简单正弦波之和的方法。更正式地说，它将任何周期函数或周期信号分解成一组(可能无限)简单振荡函数的和，即正弦和余弦

简单来说，任何音频信号都可以表示为正弦波和余弦波之和。

A Time Domain Signal represented as the sum of 3 sine waves. (Source)

在上图中，时域信号表示为 3 个正弦波之和。这如何减少存储空间？考虑正弦波是如何表示的。

The mathematical representation of sine wave. (Source)

由于信号表示为 3 个正弦波，我们只需要 3 个值来表示信号。

梅尔频率倒谱系数

我们的声音依赖于我们声道的形状，包括舌头、牙齿等。如果我们可以准确地确定这个形状，我们就可以识别正在说的单词/字符。MFCC 是声音的短期功率谱的代表，简单来说，它代表声道的形状。你可以在这里阅读更多关于 MFCC的信息。

光谱图

频谱图是表示音频信号的另一种方式。光谱图以二维形式传达三维信息(2D 光谱图)。x 轴是时间，y 轴是频率。特定时间特定频率的振幅表示为该点的颜色强度。

Waveform and corresponding Spectrogram for a spoken word “yes”. (Source)

方法概述

为了。wav 文件，我使用了 Kaggle 竞赛的训练数据子集- Tensorflow 语音识别挑战赛。Google Colaboratory 用于训练。它提供 12 小时的免费 GPU 使用。它不是很快，但对这个项目很好。

音频文件以 16000 的采样率进行采样。频谱图用于语音命令识别。我写了一个小脚本来转换。wav 文件转换成光谱图。光谱图图像被输入到卷积神经网络。迁移学习在 Resnet34 上完成，resnet 34 在 ImageNet 上训练。PyTorch 用于编码这个项目。

重启随机梯度下降(SGDR)

SGDR 使用余弦退火作为学习速率退火技术来训练模型。学习率在梯度下降的每次迭代(非历元)时降低，并且在一个循环完成后，学习率被重置，即设置为初始学习率。这有助于实现更好的泛化。

其思想是，如果模型处于局部最小值，其中参数的微小变化会极大地改变损失，那么它不是一个好的局部最小值。通过重置学习率，我们允许模型在搜索空间中找到更好的局部最小值。

SGDR for 3 cycles

在上图中，一个循环由 100 次迭代组成。学习率在每个周期后重置。在每一次迭代中，我们逐渐降低学习率，这使我们能够陷入局部最小值。然后，通过在一个周期结束时重置学习率，我们检查局部最小值是好是坏。如果它是好的，那么在下一个周期结束时，模型将进入相同的局部最小值。但是如果它是坏的，那么模型将收敛到不同的局部最小值。我们甚至可以改变周期的长度。这允许模型深入到局部最小值，从而减少损失。

快照集成

这是一种和 SGDR 一起使用的技术。集成的基本思想是为一个特定的任务训练一个以上的模型，并平均出它们的预测值。大多数模型对相同的输入给出不同的预测。所以如果一个模型给出了错误的预测，另一个模型给出了正确的预测。

Snapshot Ensembling (https://arxiv.org/abs/1704.00109)

在 SGDR，我们借助自行车进行组装。基本上，每个局部最小值具有不同的损失值，并对数据给出不同的预测。在做 SGDR 时，我们从一个局部最小值跳到另一个局部最小值，最终找到最优最小值。但是，来自其他局部最小值的预测也是有用的。因此，我们在每个周期结束时检查模型参数。在进行预测时，我们将输入数据提供给每个模型，并对它们的预测进行平均。

调整设置以减少培训时间

培训是在 Google Colab 上进行的。它提供了一个 Tesla K80 GPU，非常适合这个任务。在该 GPU 上，梯度下降的一次迭代大约需要 1.5-2 秒。但是当训练结束后，一个时期的训练需要大约 80 分钟！这是因为，默认情况下，PyTorch 数据加载器中不能使用超过 1 个 workers。如果您尝试，PyTorch 会抛出一个错误，突然中断训练。

但是为什么要 80 分钟呢？这是因为准备下一批的任务是在 CPU 上完成的，而只有梯度下降和权重更新是在 GPU 上完成的。当权重更新完成后，GPU 空闲，等待下一批。所以在这种情况下，CPU 大部分时间是忙的，GPU 是闲的。

当我们在数据加载器中指定 num_workers 参数时，PyTorch 使用多重处理来并行生成批处理。这消除了瓶颈，并确保 GPU 得到适当利用。

我们如何在 Google Colab 上做到这一点？Google Colab 基于 Linux 系统。并且大多数 Linux 系统都有一个名为 /dev/shm 的临时分区。该分区被进程用作共享内存。它是一个虚拟内存，这意味着它不驻留在硬盘上，而是驻留在内存上。PyTorch 使用这个分区为 GPU 放置批处理。

默认情况下，Google Colab 为这个分区分配 64 MB 的大小。这个规模对于使用足够数量的工人来说是非常小的。这意味着如果我们尝试使用 num_workers，在训练期间的某个时候，这个分区将溢出，PyTorch 将抛出一个错误。解决方案是增加这个分区的大小。增加大小后，我们可以使用许多工作线程来加载数据。但是我们应该使用多少 num_workers 呢？

似乎使用尽可能多的 num_workers 是好的。我用不同大小的/dev/shm 和不同的 num_workers 做了不少实验。这是结果。

看起来使用 64 名工人不是最好的选择。为什么我们会得到这些结果？当我们在数据加载器中为 num_workers 指定一个值时，在开始训练之前，PyTorch 会尝试用批处理填充这些数量的 workers。因此，当我们指定 num_workers=64 时，PyTorch 用批处理填充 64 个工作线程。仅这个过程就需要 2.5-3 分钟。这些是我们的模型所要求的。然后，该模型根据这些批次更新权重，并等待下一组批次。这个过程只需要大约 3-5 秒钟。与此同时，CPU 正在进行下一组批处理。在 Google Colab 中，只有一个 CPU。所以在更新权重之后，GPU 再次空闲等待 CPU。同样，大约需要等待 2 分钟。这个过程还在继续。这就是为什么在使用大量工人时，培训需要大约 10 分钟。

因此，在选择工人数量时，需要权衡模型更新权重所需的时间和 CPU 生成下一批所需的时间。我们必须通过考虑这些时间来选择工人数量。通过选择 8 名工人，,我们能够减少 96%的培训时间。你可以在这个 Jupyter 笔记本里查看这个调整。

结果

经过这些麻烦之后，我终于能够训练我的模型了。该模型达到了 90.4%的准确率。这个结果可以通过不同的技术来改进。其中一些是:

数据扩充 —我没有在我的数据中使用任何数据扩充。音频数据有许多数据增强，如时移、速度调整等。你可以在这里找到更多关于数据扩充的信息。
结合梅尔光谱图+ MFCC —当前模型仅基于光谱图给出预测。CNN 进行特征提取，分类器(全连接层)从 CNN 的输出特征中寻找最佳超平面。除了这些特征，我们还可以给分类器 MFCC 系数。这将增加一些特征，但 MFCC 会给分类器提供音频文件的额外信息。这将有助于提高精确度。需要适当的调整以避免过度拟合。
使用不同类型的网络——正如我们在音频数据中看到的，它有一个时间维度。对于这种情况，我们可以使用 RNNs。事实上，对于音频识别任务，有结合 CNN 和 RNN 的方法，其产生比仅使用 CNN 更好的结果。

目前就这些。如果你喜欢这个帖子，请分享给你的朋友并留下掌声:)如果你想联系我，请在 LinkedIn 上联系我，或者在 Twitter 上关注我。敬请关注更多内容。

橄榄油是橄榄做的，婴儿油是给婴儿做的[论文摘要]

原文：https://towardsdatascience.com/olive-oil-is-made-of-olives-baby-oil-is-made-for-babies-paper-summary-265bea33605b?source=collection_archive---------10-----------------------

本文总结了一种新颖的技术，用于自然语言处理中的一项非常复杂的任务，即名词复合分类。

论文题目

橄榄油是由橄榄制成的，婴儿油是为婴儿制造的:用神经模型中的释义解释名词复合词——Vered shw artz 和 Chris Waterson

基本概述

这篇论文解决了一个重要的自然语言处理任务——自动解释名词复合成分之间的关系。

动机

考虑下面的名词复合词例子: 橄榄油 和 婴儿油 。可以观察到， 【橄榄油】 中的 【橄榄】 一词描述的是来源关系， 【婴儿油】 中的 【婴儿】 一词描述的是目的关系。换句话说，就婴儿在现实世界中所代表的意义而言，他们永远不应该被放在与橄榄相同的环境中。这种区别很重要，因为它可以用于需要复杂文本理解能力的各种应用程序。

例子例子例子

想象一下，你问谷歌搜索橄榄油是由什么组成的。如果谷歌搜索是聪明的，它应该回应“橄榄”。现在想象一下，你问谷歌婴儿油是由什么组成的。绝对不是婴儿！答案应该是油的其他成分或者油的主要成分。这是一个非常重要的区别！这是一项具有挑战性的任务，因为这两种油的含义都不容易解释给定其组成单词的含义。

你能想出更多的例子吗？试一试，你就会明白为什么 NLP 研究的这个领域很重要。作为一名 NLP 研究人员，我甚至可以看到这对于消除情感短语之间的歧义是多么有用。(在另一篇文章中有更多关于这方面的内容。)

文献综述

两种非常常见的方法被用来解决这个问题: 释义和 名词复合表示 。第一种方法映射成分之间的关系，后一种方法利用单个成分的分布表示。(不要慌，我一会儿解释他们的意思。)

最近的一项工作(马頔，2016) 表明，成分嵌入可以有效地表示名词性复合词(以下简称 NCs)。这种方法有效的主要原因在于一种被称为词汇记忆的现象。

贡献

本文提出了一种结合路径嵌入(代表名词短语之间的关系)和分布信息(直接从单词嵌入中获得)的神经释义方法来执行名词短语分类任务。作者还对避免词汇记忆的设置进行了实验，以表明他们的方法更加稳健，他们的结果与这一现象无关。

型号

作者使用 HypeNET 来学习连接语料库中成分实例的联合出现的模式。这些也被称为路径嵌入。

结合三种模型进行 NCs 关系分类:基于路径的、集成的和集成的-NC 。每个模型递增地添加新的特征(在这种情况下是不同的分布式输入),这实质上向整个输入向量添加了更多上下文化的信息。在下图中可以更清楚地看到这一过程:

路径嵌入(图中紫色部分)是用一个普通的 LSTM 学习的，输入向量表示下列向量的连接:引理、词性标签、依存标签和方向向量。(详见论文)。NC 标签(关系)通过 LSTM 的输出使用远程监控方法获得。

评价

从 Tratz (2011) 获得的两个数据集用于评估提出的神经释义模型。提出了几个比较模型，包括几个基线模型和从以前的工作和最新方法中采用的重新训练模型。(有关实验设置的更多详细信息，请参见论文)。

表 1 显示，在大多数情况下，集成模型( Int 和 Int-NC )在使用不同的数据拆分策略方面优于所有其他模型(显示在拆分列中)。从 Int 模型和 Int-NC 模型获得的结果之间几乎没有差别，表明 NC 嵌入对分类任务没有太大贡献。

分析

对随机分裂策略进行了进一步的分析，以分析不同模型的结果的变化。在表 3 中，您可以观察到产生合理性能的一些关系(例如，度量和个人头衔)

作者还发现复杂关系表现不佳，如 NC 的词汇化，“*肥皂剧”*和 NC 的目标，“恢复计划”。(见文中更有趣的例子)。

下面的表 4 提供了从测试集获得的 NC 嵌入的例子(左)和嵌入中最相似 NC 的例子(右)。作者观察到只有 27.61%的 NCs 与具有相同标签的 NCs 非常相似。他们将这种行为归因于不一致的注释，而不是嵌入的质量。

我的 进一步的想法和结论

可视化 NC 向量嵌入，以观察可能具有相似属性的关系簇和模式。
更仔细地研究词汇记忆现象，本文使用整个模型中基于路径的部分来帮助*【轻微】*解决这个问题。
总体而言，性能得到了提高，但在数据质量和建模方面仍有很大的改进空间。
NC 嵌入对当前模型没有帮助，因此它在不改变模型整体结构的情况下提供了一个可行的未来研究方向。

资源

原文||代码库 (Tensorflow 实现)

使用 Python 的 Pandas 和 SeaBorn 从 Kaggle 数据集提取洞察

原文：https://towardsdatascience.com/olympics-kaggle-dataset-exploratory-analysis-part-2-understanding-sports-4b8d73a8ec30?source=collection_archive---------10-----------------------

Data Science is the science of patterns. Source: Pixabay

好奇心和直觉是数据科学家最有力的工具。第三个可能是熊猫。

在我的上一篇文章中，我向你展示了如何了解一个数据集有多完整，如何绘制一些变量，以及如何观察一段时间内的趋势和倾向。
为此，我们在 Jupyter 笔记本上使用 Python 的熊猫框架进行数据分析和处理，使用 Seaborn 框架进行可视化。

在上一篇文章中，就像在这篇文章中一样，我们使用了 Kaggle 的 120 年奥运会数据集，并观察了女性随时间的参与情况、运动员的体重和身高分布以及其他变量，但没有使用关于每位运动员参加哪项运动的数据。
这一次，我们将关注数据集的 Sport 列，并获得一些关于它的见解。

我能想到的几个问题是:

什么运动适合胖人？高个子呢？
哪些运动比较新，哪些比较老？有什么运动实际上失去了奥运会的青睐，不再被玩了吗？
有没有一些运动总是相同的队伍赢？最多样化的运动呢，获胜者来自许多不同的地方？

和以前一样，我们将使用这个 Github 项目进行分析，您可以派生它并添加您自己的分析和见解。让我们开始吧！

体重和身高

对于我们的第一个分析，我们将看看哪些运动有最重和最高的运动员，哪些运动有最轻或最矮的运动员。
正如我们在上一篇文章中看到的，身高和体重在很大程度上取决于性别，我们对男运动员的数据比对女运动员的多。因此，我们将对男性进行分析，但同样的代码只需切换“性别”过滤器就可以对两者进行分析。

如你所见，如果我按运动项目分组，我可以得到每个运动项目的运动员的最小、最大和平均体重和身高。
然后，我查看了前 5 项最重的运动，发现如下(以千克为单位):

Sport             min  max  average 
Tug-Of-War       75.0 118.0  95.61 
Basketball       59.0 156.0  91.68 
Rugby Sevens     65.0 113.0  91.00 
Bobsleigh        55.0 145.0  90.38 
Beach Volleyball 62.0 110.0  89.51

不算太意外吧？拔河练习者，篮球运动员，橄榄球运动员都很重。有趣的是，篮球和橄榄球运动员的体重差异很大，从 59 公斤到 156 公斤不等，而大多数拔河运动员都超过 80 公斤。
然后我画出了每项运动的平均体重，发现它呈正态分布:

sns.distplot(sport_weight_height_metrics.Weight.dropna()['mean'])

身高具有类似的正态分布，但其方差要小得多，高度集中于平均值:

接下来，我开始用有序散点图绘制所有单个平均值，看看是否有异常值。

事实上,“最重”的运动相对于图表的其他部分来说是非常异常的，同样的情况也发生在“最轻”的运动上。如果我们观察身高，尽管方差明显较小，但该图揭示了“异常值”和接近平均值的人之间更大的差异，强调了大多数人并没有真正偏离它很多的事实。

对于最轻的运动，可以使用之前生成的变量 plot_data 获得结果。

结果(忽略最重的，因为我们已经看到了)如下:

lightest: 
Gymnastics:      63.3436047592 
Ski Jumping:     65.2458805355 
Boxing:          65.2962797951 
Trampolining:    65.8378378378 
Nordic Combined: 66.9095595127

所以体操运动员，即使是男运动员，也是迄今为止最轻的选手！紧随其后的是跳台滑雪、拳击(这让我有点吃惊)和蹦床，这实际上很有意义。

如果我们转而寻找最高和最矮的运动员，结果就没那么令人惊讶了。我想我们都期望同样的运动会出现在顶部，不出所料，它确实出现了。至少我们现在可以说这不是一个刻板印象。

shortest (cm): 
Gymnastics:    167.644438396 
Weightlifting: 169.153061224 
Trampolining:  171.368421053 
Diving:        171.555352242 
Wrestling:     172.870686236 tallest (cm): 
Rowing:           186.882697947 
Handball:         188.778373113 
Volleyball:       193.265659955 
Beach Volleyball: 193.290909091 
Basketball:       194.872623574

所以我们看到体操练习者很轻，而且很矮。但是这些排名中的一些项目并没有出现在重量级项目中。我想知道每项运动的“体格”(体重/身高)如何？

该图看起来非常线性，直到我们到达最大离群值所在的顶部:

Build (Weight/Height) distribution of Olympics’ athletes

以下是建造最少和最多的体育项目:

**Smallest Build** (Kg/centimeters) 
Alpine Skiing    0.441989 
Archery          0.431801 
Art Competitions 0.430488 
Athletics        0.410746 
Badminton        0.413997 
**Heaviest Build** 
Tug-Of-War     0.523977 
Rugby Sevens   0.497754 
Bobsleigh      0.496656 
Weightlifting  0.474433 
Handball       0.473507

所以橄榄球和拔河仍然是最重要的运动，这次高山滑雪是最不重要的，射箭和艺术比赛(我刚刚知道这是奥运会项目，需要进一步研究)紧随其后。

运动随时间推移

现在我们已经用这三列做了所有我能想到的有趣的事情，我想开始看看时间变量。具体是哪一年。我想看看奥运会是否引入了新的运动项目，什么时候引入的。但也不赞成使用。

这段代码通常在我们需要查看某件事情第一次发生的任何时候都很有用，尤其是当我们想要查看变量的异常增长时。

图表向我们展示了每年有多少项运动首次出现在奥运会上。或者，换句话说，每年有多少运动被引进:

因此，尽管许多运动在 1910 年以前就有了，而且大部分是在 1920 年以前引进的，但也有许多相对较新的引进。查看数据，我看到 1936 年引入了许多新运动，之后它们总是以小规模(少于五个运动)引入。【1936 年至 1960 年间没有任何新的运动项目，冬季两项被引入，然后他们很有规律地增加新项目:

Sport           introduced
Biathlon           1960
Luge               1964
Volleyball         1964
Judo               1964
Table Tennis       1988
Baseball           1992
Short Track Speed Skating 1992
Badminton           1992
Freestyle Skiing    1992
Beach Volleyball    1996
Snowboarding        1998
Taekwondo           2000
Trampolining        2000
Triathlon           2000
Rugby Sevens        2016

对被否决的运动的类似分析(其中 max year 不是最近的)显示了这些运动的列表，其中大多数我从未听说过(尽管这绝不是一项运动是否受欢迎的好指标！)

Basque Pelota    1900
Croquet          1900
Cricket          1900
Roque            1904
Jeu De Paume     1908
Racquets         1908
Motorboating     1908
Lacrosse         1908
Tug-Of-War       1920
Rugby            1924
Military Ski Patrol 1924
Polo             1936
Aeronautics      1936
Alpinism         1936
Art Competitions 1948

我们看到艺术比赛在 1948 年被取消，马球从 1936 年起就没有在奥运会上出现过，航空学也是如此。如果有人知道航空学到底是什么，请让我知道，我在想象飞机上的人，但不知道竞争会是什么样的。也许是飞机比赛？让我们把那些拿回来！

各位，今天就到这里吧！我希望你喜欢这篇教程，也许你会在下次家庭聚餐时提出一个新的有趣的事实。
像往常一样，随意从这个分析中分叉代码，添加自己的见解。作为跟进，我正在考虑训练一个小型机器学习模型，根据运动、体重和身高栏预测运动员的性别，告诉我你会使用什么模型！如果你觉得这篇文章中的任何内容没有得到恰当的解释，或者仅仅是错误的，也请告诉我，因为我也在从中学习！

关注我，获取更多数据分析文章、Python 教程和其他任何与数据相关的东西！如果你喜欢这篇文章，请在 twitter 上与你的数据朋友分享。

最初发表于www . dataden . tech。

关于敏捷、特雷罗和思想的“干燥”

原文：https://towardsdatascience.com/on-agile-trello-and-the-dryness-of-ideas-bf66985796cb?source=collection_archive---------14-----------------------

Photo by Tracey Hocking on Unsplash

在我开始创建自己的预测分析产品的科技创业公司之前，我曾在咖啡馆、酒吧和餐馆做全职工作。科技初创企业的场景和热情好客相去甚远。但我最近的转变，从初创企业到收缩的数据科学角色，揭示了一些更令人震惊的对比。餐馆和公司都喜欢在真正“干净”的环境中工作。但在企业界，这种清洁实际上窒息了那些从事真正有创意和复杂项目的人，比如数据科学，而初创企业似乎在这方面蓬勃发展。

清洁与干燥的区别

在酒店业，你的工作是为人们创造一个享受食物和饮料的环境。卫生很重要。经理们的永恒妙语是“如果你有时间学习，你就有时间打扫”。让东西看起来非常干净，(桌子、餐具、玻璃杯、地板等)理所当然地占据了大量的注意力。

最近转向合同工，为一般的大公司客户管理数据科学项目，让我看到了另一种洁癖。一眼望去，大公司工作的数字空间和程序闪闪发光。光泽出现在每个方面，从完美的电子邮件签名，程序文档的完美模板，如“解决方案范围定义声明”，带有品牌页眉和页脚，文档元数据，归属所有者的超链接字段，目录号，截止日期等。在他们的文件共享系统中，目录中预装了一些文件夹，这些文件夹描述了项目每个可能阶段的所有可以想象的文件类型。但还是没有一个明显符合你现在要上传的文件。你必须点击几十个可能的目录和子目录(大部分都是空的)，才能找到一个既能找到又不会玷污系统完美状态的地方。

过了一段时间，我才停止责备自己，我在初创公司使用的工作流程是多么没有条理，看起来是多么“混乱”。就像一个优秀的服务人员一样，我的第一反应是认为清洁是一种普遍的美德。但是项目进行了几个月后，我意识到实际上清洁文化可能是完成真正好的工作的大部分困难的一部分，如果不是原因的话。

公司，尤其是他们的 IT、数据或创新部门，没有生产食品的工作。他们的工作是产生想法，并从中获取价值。有时是通过提供新的商品和服务，有时是通过提高现有流程的效率，有时是进入新的市场，或者更好地满足现有市场的需求。有没有可能创意需要在一个不像准备和提供食物和饮料的地方那么优雅的地方准备和提供？

简单的回答是肯定的。最好的想法来自原始的创意汤，它看起来并不纯粹。说好的想法是从一个乱七八糟的地方诞生的，这是在说真话。他们的品质最初并不明显，但经过大量的工作和精心的提炼和展示，他们变得如此。

酒店业也有相似之处。事实上，在所有最好的厨房和酒吧里都有很多乱七八糟的东西。然而，脏乱的部分总是发生在旨在控制和管理脏乱的阶段和系统中，因此最终产品最终完美呈现给顾客，并且始终保持良好的卫生。

反思我最近所看到的，我开始认为，企业对结构和秩序的痴迷实际上可能是扼杀大量好想法的原因。他们不知道如何在一件东西还处于不整洁的状态时就让它存在。模板、网关、标准和检查点系统有效地组成了一个自动免疫系统，旨在消除任何可能不健康的东西。问题是，它还扼杀了可能带来伟大新想法的创造性过程，并且在面对复杂项目时遇到了巨大的阻力，在这些项目中，下一步并不总是显而易见和常规的，包括数据科学。

这听起来像是不可避免的紧张。大公司抵制怪异、不干净或奇怪的想法，因为它们可能不卫生，并威胁整个系统的健康。小型初创企业孕育着各种古怪的想法。但是他们也经常死去，因为这些想法并不完全是好的，好的部分没有成功。

大型、笨重的组织有希望找到一种方法来平衡对强大而严格的卫生系统的需求，同时为做创新或挑战性的事情所需的杂乱无章的流程留出足够的创造性空间吗？我想是的，因为卫生不仅仅是清洁。

在酒店业，老手们都知道清洁与保持卫生同等重要，如果不是更重要的话。干燥。事实证明，不管一件东西有多干净，如果它是湿的，甚至是微湿的，并且允许它长时间保持这种状态，它不可避免地会产生某种可见的霉菌，或者有气味的臭味，并且必须重新清洁或处理掉。保持东西干净很容易。更微妙和普遍的敌人是持久的水分。就像那块被潮湿地折叠起来放在抽屉里的抛光布，或者是台面上的一个小扭结，它可以防止水溅出来。大量的卫生危害实际上与非常干净的东西有关。它们还没干。

我认为这是一个不言而喻的事实，即在许多大公司中管理程序和项目的闪闪发光、格式良好的文件。它们很干净，但不是干的。最近(一个客户)鼓励我将他们的一个项目启动文档中的一些文本复制到我正在做的一个报告中。但是我发现很难做到。章节标题(完美的项目符号)没有真正的意义。真正复杂的话题或问题被一笔带过。定义或列表通常是部分冗余的，相互矛盾的，或者没有定义最重要的东西。我有一个清晰的印象，那就是我正在读的东西是某人脑海中浮现的第一件东西，它可以被格式化以满足所有被认为是官方文件的“干净”标准。其实并不坏。这只是…嗯，这就是我们的工作，并没有激发信心。这让我想起了上周末放在架子后面的一品脱啤酒，湿湿的，从那以后就再也没用过了。完全干净，但里面仍然有一层凝结的雾气，还有一股淡淡的霉味，会破坏你对啤酒的渴望。

我认为，大公司实际上可以调整他们的流程来培养新的创意，并承担现有模板无法依赖的复杂流程。但是他们必须调整心态。对“清洁”的关注必须大幅转向“干燥”。你需要释放出许多仍然很乱、湿淋淋的想法，在它们被清理干净之前，把它们放在一个可以“晾干”的地方。

我说的干涸，是指他们需要得到持续的曝光或任何形式的曝光(批评、评论、也许是一个赞、投票、甚至表情符号、任何东西、任何东西),在他们打算适应任何形式的规定结构或通过任何验收标准之前。这就是 Trello、Slack 或其他现代协作和消息工具开始发挥作用的地方。在他们看起来准备好成为人们期待的特定事物之前，他们创造了一点空间来把事情公开。它们提供了创造、协调和容纳创造性混乱的空间。

人们尝试了几种方法，但都失败了

传阅稿

我怀疑，当带有标记的草案文件在被采纳前通过电子邮件传阅时，企业可能会为自己的透明和合作而沾沾自喜。这是一种高尚的努力，但完全是可悲的，就像一个酒保用擦桌子湿了的抹布擦酒类。是的，我知道你在努力打扫，但其实……(重重的叹了口气)。

一旦某样东西成了“草稿”，你就已经明确宣布了它应该是什么样的，并且有效地接受了所有的标准，即“最终”版本是必要的和充分的。你需要在那个阶段之前很久就开始表达你的想法。被认为是“干净”的东西并不意味着它是“好”的。大多数情况下，草稿会选择前者，这意味着后者。在你修改格式、调整措辞等之前，很久就要理清想法的好与坏，以及它们可能如何混合、融合或改编。

此外，如果你让一个人自己完成草稿，你现在已经让他们的自我和可用性在草稿中得到内在的提升。像‘不，我认为这是完全错误的角度，也许我们应该试试……’这样的评论再也不会出现了。被当成人身攻击的风险太大了，更不用说，这意味着所有的努力都白费了。

最后，很有可能分发列表太小了。如果它是一封电子邮件，它只发送给那些被认为需要或需要批准或输入的人，并且只由那些有足够时间阅读的人阅读。这两个群体的交集通常几乎不包含任何人。

召集会议

这很容易是项目管理和领导类型最常见的下意识反应，无论何时复杂性或混乱超过了他们最初的指示。一旦人们开始指出一些可能需要解决的紧张关系或问题，并且没有明显的答案，领导者会非常自豪地召集会议。能够利用人们的日记显然是对他们资历的一种安慰性的确认，这可能不是通过任何技术力量获得的。他们解决问题的妙招是把所有其他有能力和知识解决这个问题的人聚集在一个房间里，激励他们去解决这个问题。

总的来说，我还是喜欢开会。让人们交谈，尤其是面对面的交谈，在很多方面都有好处。但是对于困难的问题，这往往是不够的。会议的失败在于人们对会议的期望，一旦会议结束，我们就会有一个计划，知道该做什么。

难题的麻烦在于，包括像数据科学这样具有技术挑战性的问题，人们头脑中准备在会议上脱口而出的观点和知识通常不足以解决问题。你不能只是在房间里走来走去，获得每个人的观点，然后让正确的道路出现。

这并不意味着你抓错了人。对于真正复杂或技术性的项目，即使是非常有能力的人，即使是他们领域的专家，也不知道所有的事情。他们可能知道去哪里找，这就足够了，前提是你不要让他们在会议上当着同事的面当场给出一个即时的答案，而这个答案是你为接下来的几周设定路线的依据。

在数据科学会议上，经常会出现这样的情况，即最佳答案是什么，就像这样，我应该去调查一下。这可能包括去和其他一些人讨论，我们认为这些人对于会议的主要焦点来说是不必要的。或者，敏锐的技术人员会说‘等一下，我马上就有’，然后迅速搜索 google、Github、Stack-overflow 或其他地方以获得快速答案。也许这需要他们两分钟，但这仍然足以打破会议的流程，当答案到来时，每个人都在聊别的事情。

另一个常见的是，答案已经存在，并且“准备好”讨论。但这是一个列表。房间里的一个人已经仔细考虑过的清单，可能会引起另一个人的强烈兴趣，但每个人都不想(或不能)完成实际的项目。在会议真正开始之前，两人必须就此达成某种结论，把它分开，选出前三名，或者类似的事情。

因此，一个过早召开的会议的典型标志是一个结果，看起来像一个奇怪的杂七杂八的待办事项列表，一些技术，一些管理，要找出的事情，其他利益相关者要交谈，一个小团队处理一些事情并汇报的小型子会议...换句话说，所有应该提前完成的事情，都被推迟完成了。

为了避免这种令人不满意的结果，一位意志坚定的经理将犯下最大的错误，并在会议进行期间，在其他所有人都在场的情况下，开始记录结果/结论。这是一种极具破坏性的领导风格。这相当于要求房间里的每个人通过沉默来表示同意。这是锁定一个非常湿的、草率的想法的终极方法，并把它固定下来，这样它就永远不会被挑战。在那些关键的要点被写下来的时候，四处弥漫着一种意味深长的沉默，这是其他人的尴尬，他们要么脱口而出自己对提案的平庸有多么不满，要么在句号出现和下一个话题开始之前，被无法准确说出问题所在或提出更好的替代方案的挫败感所压倒。好的领导者应该给他们的员工时间来表达他们最聪明、最有建设性的异议。

预定一个‘单口相声’

再说一次，原则上我喜欢单口相声，但是它们的真正目的被那些试图弥补会议不足的项目经理们滥用了。这很快就变成了‘鉴于我留给你们的目标是多么模糊，我想每天都和你们大家检查一下，督促你们确保你们仍然朝着我认为正确的方向前进’。是啊，当然。请到其他地方“清除阻挡者”。

单口相声应该只出现在 sprint 团队，而不是 scrum 团队。客户，甚至是项目经理和其他股东，都不应该被邀请。这是关于那些在战壕中工作的人，他们每天一次从自己的屏幕上抬起头来，看看其他人过得怎么样。有机会把他们的作品放在更大的画面中，在他们可以的地方提供帮助或建议，也许调整团队内的优先次序，以帮助更快地达到相同的固定目标。

你绝不会希望非技术股东接近这些会议。他们不能帮助解决技术人员实际面临的任何问题。他们能做的就是改变范围。他们通过改变目标来“帮助”。那一点帮助都没有。一旦开发人员或数据科学家团队被告知，每天都是一个机会，可以少做一些他们计划做的事情，而是做一些不同的事情，那么生产力就会开始下降。提供无限的移动目标的机会是对未能首先找到目标位置的最糟糕的补偿。

敏捷的数据科学诀窍:在冲刺之间放慢速度

对于任何在解决方案中工作的项目，我都是敏捷的大力提倡者——对于成功的定义来说，空间太大或太复杂，以至于无法预先很好地定义。软件开发和数据科学是两个很有资格的学科。实际上，我认为数据科学更需要它，正是因为它主要涉及科学(发现关于外部现实的未知)，而软件仍然有重要的工程成分(将新事物带入现实)。

我承认我从未接受过任何正式的培训，但是我读过一些关于敏捷方法的文献。我推荐阅读由 Ken Schwaber 和 Jeff Sutherland 撰写的 Scrum 指南，作为一个主要框架的相当确定的起点。我发现这份文档非常简洁地说明了要做什么，但在解释为什么每一步都很重要方面却很糟糕。因此，它给人的感觉相当枯燥和教条，人们可能会试图只松散地应用某些部分，但一点点经验通常会证明，几乎所有元素背后都有一个重要的原因。

但只有一点我想认真对待。也许这只是数据科学中的一个问题，但是我从来没有发现“在前一个冲刺结束后，一个新的冲刺立即开始”(强调是附加的)这个想法是实际的或者完全可以实现的。**

我怀疑这可能是因为大部分数据科学项目实际上是一系列实验。你不能构建一个特性，然后转移到下一个。你正试图证伪一个假设，证明或否定某件事，或者更有可能确定一些概率上的自信，而你却没有能力做到这两者。下一个逻辑实验可能会完全不同，这取决于上一个实验的结果。

所以我的直觉(我不是软件开发人员，所以这只是直觉)是，在数据科学中，我们有更少的、概念性的产品积压，而不是我们希望看到的所有功能和特性的丰富、扩展的列表。(我们称之为项目积压，因为有时“产品”不是自然的终点)。这个项目有一个广泛的目标，但是接下来的逻辑步骤是什么，或者这个目标是否仍然是可实现的，或者是否如我们所希望的那样是可实现的，很少会在一个 sprint 之前就清楚了，并且通常即使是上一个 sprint 的结果也需要在下一个 sprint 开始成形之前进行一点消化。

如果这听起来很极端，我认为有必要强调一下，现实生活中的数据科学项目实际上与 Kaggle 竞赛完全不同。Kaggle 竞赛通常在一开始就有两个完美定义的东西:数据和标签。现实世界的数据科学项目，尤其是咨询/承包项目，通常两者都没有。他们通常从一种模糊的业务目标开始，如“节省运营成本”，或“更好地满足客户需求”，以及可用数据的手写描述。有时你听说所有的数据都准备好了，但是一旦你开始使用它，你就会发现所有的迹象，你收到的摘录实际上只是所有数据的一小部分。

我越来越相信敏捷工作流程中最有价值的部分是发生在冲刺阶段的部分。弄清楚下一步该做什么实际上是最难的，也是最重要的部分。

我已经采纳了一个普遍的规则，即冲刺评审可以而且应该在冲刺结束后立即进行，而冲刺计划应该是紧接在冲刺之前的会议。但是那两个会议应该永远不要在同一天。如果是的话，至少根据我的经验，你会遇到我前面提到的所有问题。你将被迫去处理那些首先浮现在脑海中的想法。没有人会有时间和空间尽可能地提出最好的批评或反建议。本质上，当你开始工作时，你将确保你关于下一步该做什么的想法是完全错误的。最轻微的不完美，看似良性的假设或简化，将随着 Sprint 的进行而恶化和变异，直到它们对 Sprint，甚至整个项目真正有害。

创建一个垂直或倾斜的表面

让想法得到适当的暴露和通风，直到坚实的想法出现的方法是让所有可能的想法以它们最辉煌的潮湿，凌乱，邋遢的状态，到我倾向于称之为某种“垂直表面”，或者至少是“倾斜表面”上。什么是“垂直表面”,这是最后一个酒店类比。

几乎在任何餐馆或酒店的任何酒吧下面，你都会发现一些看起来相当恶心的表面。冰箱的侧面，或者支撑架子的腿的背面，将会用啤酒和拖把水的飞溅来装饰，用咖啡渣或石灰木髓或其他东西来覆盖。但是，尽管它看起来并不吸引人，但它没有气味，也不会造成任何伤害。除了飞溅发生的几秒钟，表面一直保持完全干燥，因为多余的液体流到地板上，其余时间，一堆冰箱和啤酒冷却器的热旋转空气保持完全干燥。虽然表面仍然应该定期清洁，在最好的场地，足够的干燥实际上确保了即使是明显恶心的脏乱也不会导致任何真正危险的事情发生。

我认为这个概念有数字上的对等物。在社交媒体的各种订阅源或论坛上的帖子中，这些平台能够很容易地保持最受欢迎或最受关注的内容——在顶部附近浮动的项目，最不相关的项目很快就会消失。我认为创造一个“垂直”或至少“倾斜”的表面是创造空间的一个重要创新，在这个空间里，想法可以在混乱中形成和出现，而没有肮脏的东西也在混乱中产生危险的风险。

我目前的想法是，在一个数据科学项目中，Scrum 团队中的每个人(尤其是产品负责人)都应该在 Sprint 评审后尽快将他们关于下一步的所有想法放到某种垂直的平面上。一个松弛频道可能是好的，但目前我正在尝试与特雷罗。它没有自然地体现提要的倾斜/排序特性，但是我通过使用几个不同的列表复制了这种效果，适当地命名，这样一个可以是“头脑风暴”，另一个是“草稿待办事项”，等等。这个想法只是为人们创造一个空间，让他们可以毫无拘束地把所有想法放在桌面上，包括问题、异议、未知、对未来疯狂的渴望等等。然后，他们可以慢慢地形成清晰、明确的计划或清单，每个人都可以边看边评论。

老实说，我正在努力。尤其是公司客户，他们似乎有种麻痹的恐惧，害怕写下任何在某种程度上没有“完成”或“正确”的东西。它认为这就是文化。在会议上，未完成的事情可以自由表达。但是你写下的东西呢？？！天哪，在你仔细检查草稿十几遍并和你的上级确认之前，不要把这个放在心上。

这是一种愚蠢的文化，必然会阻碍任何真正优秀或复杂的东西的发展，在这种情况下，你可能需要许多其他真正聪明的人坐下来思考一些事情，然后他们才能发现缺陷，或者提出改进建议。但我是一个乐观主义者，并希望像 Trello 和 Slack 这样的东西是有用的工具，可以创造空间，让人们更多地用语言表达，但用书面形式表达。

我正在取得一些成功。在两天的过程中，我从一些客户端利益相关者那里获得了一些关于 Trello 的有意义的参与，包括一个以前从未使用过 Trello 的人。客户写下了他对 sprint 的期望的精彩描述。他写的时候，它完全没有定义，完全不可能执行，但它很好地描述了他希望看到的，并允许我充实所有的不确定性和中间步骤，这将是实现目标所必需的。我张贴了一个分类变量的直方图，一位主题专家说它将包含感兴趣事件的重要标志，以突出与该列中其他类似命名的标签的混淆。他核实了他的消息来源，并通过在图表下方发表评论来回复我进行澄清。完美。

我越来越相信，花几天时间在 Trello 或其他工具上研究出所有你能想到的东西，是有效的冲刺规划会议的必要前提。你应该为每个人都真正可能关心的话题预留见面时间，并且能够做出贡献。比如阐明意图、关于替代方向或权衡的重大决策。目的是让每个人都有最后一次机会表达自己的担忧，或者听取相关人员的意见，从而建立整个团队对计划的信任和信心。

如果你还在讨论事实、技术细节、填充列表、写下要点，那么你就是在浪费宝贵的会议时间。预计人们会脱离，一些超负荷的领导者不得不人为地将事情处理成一个可定义的结果，你甚至会在开始之前就让自己陷入一场失败的冲刺。在你把人们召集到一起之前，一个可行的计划的所有要素都应该已经摆在桌面上了。

所以我的建议是在冲刺之间花点时间。会议是好的，但还不够。想法需要一段时间来暴露，虽然仍然是一片混乱，以便干了一点。我认为在 Trello 或 Slack 上工作一两天提供了这种时间，以及一种合适的“倾斜”表面，这种表面可以比我认为过去可能做到的更好。固体的东西会粘在一起，而不干净的东西会流下来，变干，变得无害。当你的想法干了，那么你就可以把它们弄干净，为接下来的冲刺产生一个优秀的计划。

人造神经疾病

原文：https://towardsdatascience.com/on-artificial-neurological-illnesses-1c932bf91192?source=collection_archive---------13-----------------------

边疆是最有趣的生命组合的宿主。

正常人类行为的边界在哪里？什么是人格，什么是疾病？是什么让我们超越了这些边界？

在他的书《把妻子错当成帽子的人》中，奥利弗·萨克斯用精致的风格、机智和同情讲述了几个神经学病例的汇编，讲述了一个患有视觉失认症(无法理解你所看到的东西)的 P 医生的故事。P 博士是一名音乐教授和著名的音乐家，他通过音乐和视觉输入了解周围的世界。他在自己的活动中(穿衣服、吃午饭)或在他的环境中(某人走路的方式)诉诸某种节奏来识别那些活动并知道他必须做什么。正如萨克斯博士在他的书中写道:“他一直在唱歌——吃饭的歌、穿衣的歌、洗澡的歌，什么都唱。他什么也做不了，除非他把它变成一首歌”。P 博士认不出一朵花，而是对他面前的东西进行了丰富而详细的描述(“大约 6 英寸长，一个令人费解的红色形状，带有一个线性绿色附件。”).直到他闻到了(“美！早起的玫瑰。多好的天香啊！”).他不能理解在他左边视野中的东西，但是这样生活没有问题:他没有意识到他感知周围世界的方式有任何错误。虽然当他的“内心音乐”不流动时，他会完全停下来，但他不会认为这是不寻常的事情，是需要注意的事情。也就是说，他完全不知道发生了什么。

人类的认知在很大程度上仍然是一个谜，但从我们所知道的来看，我们理解我们的环境并适应它的能力似乎与几个复杂系统的紧密集成有关。就视觉而言，根据前面的故事，数以百万计的刺激从视网膜传播到与视觉相关的皮质区域；它们在视觉皮层不同深度的几个层中进行处理，然后每个层的输出连接到大脑的许多其他区域，这些区域与几个功能相关:处理语义、记忆、情感、规划、运动等的区域。听觉刺激、嗅觉等也是如此。回忆也是。大脑实时连接和处理所有这些刺激。情感、行为和存在感从这一切中浮现出来。

但是如果许多连接失败了会发生什么呢？当一群神经元的行为不同于正常时。当一种神经递质无法产生时。还是当你的某个感官突然工作不一样，也就是刺激不期而至的时候？奥利弗·萨克斯在其整个写作作品中出色地呈现了许多这样的案例。对现实的感知，其中缺少了一些东西。对于没有这些条件的人来说，这种感觉很难用语言描述，也很难从第一人称的角度来想象。神经疾病就像意识本身一样，是由执行相对简单任务的几个系统的相互作用产生的，其中一个或多个元素略有异常。这不仅仅是改变了对现实的认知。这是一个非常广泛的功能模式，其中一些我们认为是疾病，一些我们认为是“人格类型”，一些仅仅是一个人生活中的轶事。区分疾病、古怪行为和强烈个性超出了本文的范围，值得暂停思考。

正如美国生命体中存在各种各样的现实感知和行为一样，今天的产品和服务也开始表现出它们自己的各种行为，这要归功于我们人类融入其中的人工智能(AI)系统。为了简单起见，让我将 AI 作为一个广义的术语，从简单的机器学习技术到协调运行的复杂算法集合。

几乎每一个值得尊敬的数字产品和行业都有某种这样的东西。接下来听什么？Spotify，Pandora 会对你可能喜欢的东西做出很好的猜测，这是人工智能的一种简单形式(在这种情况下，是一种机器学习推荐系统)。今天去哪里吃饭？有一堆应用程序在挤压它们的算法来得到一个你会喜欢的建议。如何协调一个机场的地勤人员在当今现代化、繁忙的机场为尽可能多的飞机服务？有一个人工智能，用于医疗服务、能源分配系统和几乎所有你能想到的东西。这很好，因为人工智能使新产品、更高的效率、对世界人口的扩展服务等等成为可能。也就是说，当他们健康的时候。

我们正处于人工智能系统漫长进化历史的早期阶段。他们的行为过于简单，他们的语境互动范围有限。生病或不良行为的后果也是有限的。但是随着系统变得越来越复杂，它们的交互范围和行为也变得越来越复杂，反过来，它们的潜在含义也变得奇怪或出乎意料。这些未来的系统看起来怎么样？随着神经系统变得越来越复杂，我们从简单的变形虫一直进化到我们人类。随着人工智能系统复杂性的增加，我们得到了…我们得到了什么？

自动驾驶汽车。自动飞行和自动操作的相机，智能地跟随你，选择视角，为你的生活创造独特的记忆。可以给餐馆打电话订餐的机器。帮助医生在手术过程中实时突出 AR 肿瘤并提供反馈的系统。这些是我们已经拥有的。我们将何去何从？帮助我们“看到”我们面前事物的联系的混合人类-人工智能系统。自主经营公司的机器。航空旅行完全由人工智能控制。智能茶壶。当你独自一人感到有点忧郁时，沙发会让你感到温暖。无论你能想象到什么。

a self-driven car possessed by the spirit of a mentally ill artificial intelligence (sort of)

就像神经疾病是由于我们的神经系统越来越复杂而出现的一样，人工神经疾病将出现在我们构建的越来越复杂的人工智能系统中。出于同样的原因，他们也会这样做:在日益复杂的系统中，意想不到的联系会带来意想不到的后果。

人工神经疾病本身并不是一种典型的错误。它们可能是由一个经典的 bug 触发的，有些可能是由意想不到的感官输入触发的。有些是由他们需要适应的实时数据/环境的历史决定的。有些是由构成人工智能的不同系统之间意想不到的相互作用造成的。这些是让我着迷的地方。我们将见证意想不到的行为，新出现的行为，这些行为我们没有编码，我们没有训练这些系统。对于人工智能的任务来说，看起来不合理的行为。奇怪的行为。也许是这样的:

人为自闭症？自闭症患者的大脑显示出紧密相连的局部区域，以及大脑中不同区域之间较差的连接模式。怎么会这样呢？由几个一起工作的模型组成的人工智能，如果学习率没有得到适当的调整，最终可能会表现出类似的模式。将不同模型连接在一起的模型可以在它们之间分配很少的依赖性，将低值分配给它们的耦合变量。一些单独的模型可能开始过度拟合。一辆患有自闭症的自动驾驶汽车可能最终只关注红绿灯，而不关注其他任何事情，并且在某个特定区域行驶，拒绝去其他任何地方。优步的自动驾驶车祸是这种情况的早期迹象吗？未能考虑所有的输入，而是只关注部分可用信息？(我们知道事实并非如此，但可能很快就会如此)。

人为的偏执？向视觉和推理引擎提供图像的相机中的一些灰尘可能会从视觉系统触发意想不到的结果，从而推动推理系统对周围事物的广泛理解。如果这个系统连接到其他正在进行某种无监督学习的系统，这种影响会在系统中持续很久。自动飞行的摄像机开始看到它们不在的地方的障碍物，并选择飞到树上。

人造幻觉？一个管理可再生能源发电厂的天气预测算法遇到了一个奇怪的低风速时期，其反馈回路没有为此进行训练。它开始产生毫无意义的幻觉预测，导致能量网络的不正确平衡。我们已经看到了金融市场的闪电崩盘，这是早期症状吗？

人工抑郁症？谷歌 Duplex 在餐厅接听预订电话，询问人们为什么在生活糟糕的时候还想出去吃饭。

人工智能目前的发展并不指向一个充满蓬勃发展的通用人工智能的不远的未来。我们可能不会看到嵌入在 Alexa 或 Google Now 或任何其他此类服务中的自然语言算法发展成妥瑞综合症，并表现出发声抽搐甚至排便困难(变得口齿不清，“你所在的地区交通拥挤，你将遭受 10 分钟的延迟，去你妈的”)。然而，在短期内，我们可能会发现越来越多的情况，我们无法真正解释为什么你的自动驾驶汽车在停车时会刮擦其他汽车的保险杠，而当你开始你们的共同关系时，它从来没有这样做过。我们已经见证了聊天机器人可能会完全偏离它们的初衷:微软的 Tay 臭名昭著的事件是进入患有人格障碍的青少年人工智能之旅的开始。它可能会在某个时候发展成妥瑞症。

很难预测这些人为的神经疾病在现实世界中会如何发展。广泛的人工智能技能和能力水平使其基本上是一个一个的审查案例。当我们的机器出现这些疾病时，我们能教我们的人工智能停下来想一想发生了什么吗？如果他们不知道自己在做什么就停止执行死刑？如果他们患上了和奥利弗·萨克故事中的 P 医生一样的疾病，也许他们不能。

这要求对这些问题有新的看法。人类发展了心理学、精神病学、神经学等科学。也许我们需要在机器心理学、机器神经病学和机器精神病学领域培训我们当前数据科学家的一个分支。人工神经学家，人工心理学家，人工精神病学家。有了机器学习，我们现在有了…正在学习的机器。也许很快就是学习那些学习机的时候了。因为从某种意义上来说，它们确实不受我们的控制。

我们今天能做什么？一些想法:

1)改善教育，提高认识。已经有很多(必要的)谈论关心我们注入到算法中的偏见，我们如何应用这些算法的道德维度，我们将它们应用于哪些问题，由于算法的训练方式，我们在社会中灌输的行为变化，等等。这个列表可以增加关心我们人工智能的精神健全的概念。心理健康检查。或许类似于《银翼杀手》中应用于复制人的“同理心测试”，但其设计不是为了测试“复制性”，而是为了测试正确的算法健康(有一些值得注意的检查偏差的提议，例如图灵盒；也有像算法观察这样的组织，但是这些都集中在伦理/偏见等方面。还不在正确的算法健康上)。

2)建立最佳实践，其中算法总是与所做的假设集、所用的训练数据集、所用的测试数据集、学习度量、成本函数等一起发布。因此，人工神经精神病学家或人工神经学家可以更好地理解潜在的病理。以及不同的系统是如何互连的(因为我们谈论的是几个相互交织的人工智能一起工作的产品/服务)。他们准备应对哪些情况。对了，要是有这些给人类就太好了！所以我们会知道对自己有什么期望。

2)设计最小化这些影响的系统，也许通过拒绝不可解释的方法。但他们目前的性能如此吸引人…或者以一种容易执行某种人工磁功能共振的方式设计系统，例如:一些让我们“看到”算法现在如何工作的程序。

3)对你的数字产品设计采用整体方法:使用了解人和机器的人来理解新的关系、含义和一切。这可以让我们为潜在的算法心理健康问题做更好的设计。

4)避免数字！问朋友听什么，去哪里吃饭，自己开车。爱你爱的人，而不是花太多时间在你的机器上。

从现在开始，这一切都会发生。或者不是。同时，回到开始的问题，正常行为的边界在哪里？它在爱开始的地方结束。但是如何应用于人工智能是另一篇文章的主题。

平均而言，你使用了错误的平均值:数据分析中的几何与调和平均值

原文：https://towardsdatascience.com/on-average-youre-using-the-wrong-average-geometric-harmonic-means-in-data-analysis-2a703e21ea0?source=collection_archive---------0-----------------------

当意思不是你想的那样

前言

(如果你已经搜索了“集中趋势”，跳过这一步)

Comparison of the arithmetic, geometric and harmonic means of a pair of numbers (via Wikipedia)

这可能是最常见的数据分析任务:

你有一堆数字。你想用更少的数字来概括它们，最好是单个数字。所以你把所有的数字加起来，然后除以数字的总数。嘣:看“平均值，对吧？

也许吧。

与普遍的看法相反，从数学上来说，平均值实际上并不是一个东西。含义:没有数学运算恰当地称为“平均”。我们通常所说的平均就是“算术平均”，也就是上面所说的众所周知的运算。我们称之为“平均值”，因为我们希望它符合“平均值”的通俗定义:典型的、“正常的”或中间值。我们经常是正确的，但比我们想象的要少。

汇总统计数据

算术平均值只是得出“平均值”的许多方法中的一种。更专业地说，这些被称为“汇总统计”、“集中趋势度量”或“位置度量”。

第二个最著名的汇总统计可能是中值，数据集的字面中间值(因此，通常比平均值更“平均”)。我不会在这里讨论这个问题，但足以说明的是，在许多情况下，当中位数更合适时，算术平均值被过度使用了。延伸阅读此处，此处&此处(最后一个和本文其余部分有点重叠，很好)。

本文将重点介绍两个鲜为人知的度量:&谐音意为。

****第一部分从概念上、直觉上&实际理解它们如何工作&何时使用它们。

第二部分 是一个单独的帖子&更深入一点&更技术性，用 R 代码演示各自的动态，真实&模拟数据&剧情。

一.毕达哥拉斯的意思是

A geometric construction of the Quadratic and Pythagorean means (of two numbers a and b). via Wikipedia

****算术平均数正好是 3 的 1’毕达哥拉斯的意思是’(以研究他们比例的毕达哥拉斯&之流命名)。如前所述，周正 & 谐音意为圆出三重奏。

为了理解它们如何工作的基本原理，让我们从熟悉的算术平均值开始。

等差中项

算术平均值被恰当地命名为:我们通过将数据集中的所有数字相加，然后除以数据集中的所有数字(以便将总和降低到原始数字的比例)。

3 + 8 + 10 = 21 21 ÷ 3 = 7 **Arithmetic mean** = **7**

注意，我们在这里本质上说的是:如果我们数据集中的每一个数字 都是同一个数字 ，那么为了拥有与我们实际数据集相同的 ***sum*** 又会是什么数字呢？

但是加法没什么特别的。这只是一个相当简单的数学运算。当数字之间存在加性关系时，算术平均值可以很好地产生数据集的“平均”数字。这种关系通常被称为“线性”，因为当以升序或降序绘制时，数字往往落在一条直线上或直线周围。一个简单的理想化示例是数据集，其中每个数字都是通过将前一个数字加 3 而产生的:

1, 4, 7, 10, 13, 16, 19…

因此算术平均值给了我们一个非常合理的中间值:

(1 + 4 + 7 + 10 + 13 + 16 + 19) ÷ 7 = **10**

但是并不是所有的数据集都可以通过这种关系得到最好的描述。有些具有乘法或指数关系，例如，如果我们将每个连续数字乘以 3，而不是将加上 3，如我们上面所做的:

1, 3, 9, 27, 81, 243, 729…

这就产生了所谓的(提示提示)。当按顺序绘制时，这些数字更像一条曲线，而不是直线。

在这种情况下，算术平均值不适合产生一个“平均”数来总结该数据。

(1 + 3 + 9 + 27 + 81 + 243 + 729) ÷ 7 = **156.1**

与我们数据集中的大多数数字并不十分接近。事实上它比 5x 的中位数*(中间数)，也就是 27 。***

当数据绘制在扁平数字线上时，这种偏斜更加明显:

那怎么办呢？

介绍…

几何平均数

因为关系是乘，为了找到几何平均数，我们乘而不是加所有的数。然后，为了将乘积重新调整回数据集的范围，我们必须取*root*，而不是简单的除法。还记得*square root*吗:需要平方的数才能得到我们感兴趣的数。**

Square root of 25 = 5, because 5 * 5 = 25

这是相同的想法，但我们需要找到将被提升到 7 次幂的数字来产生我们的乘积，而不是提升到 2 次幂(也称为“平方”)，因为我们的数据集中有 7 个数字，我们将它们相乘。这通常被称为*n*th root，其中*n*是数据集的大小。因此，我们需要找到7th root。

请注意，我们在这里所说的是:如果我们的数据集中的每个数字 都是同一个数字 ，那么为了拥有与我们实际的数据集相同的乘法该是什么数字呢？****

因此，我们数据集的几何平均值是:

1 * 3 * 9 * 27 * 81 * 243 * 729 = 10,460,353,203 7th root of 10,460,353,203 = 27 **geometric mean** = **27**

在数字行上:

在这种情况下，我们的几何平均值 非常类似于数据集的中间值 。其实相当于中位数**。**

注意:几何平均值不会总是等于中值，只有在所有数字之间存在精确一致的乘法关系的情况下(例如，将之前的每个数字乘以 3，正如我们所做的)。真实世界的数据集很少包含这种精确的关系，但是对于那些近似这种乘法关系的数据集来说，几何平均值将给出比算术平均值更接近的“中间数”。

几何平均的真实世界应用

事实证明，几何平均有许多实际用途，因为现实世界中存在大量的乘法关系。

一个典型的例子是:

复利

假设我们有$100,000，它为5 years每年累积不同的利率:

annual interest rates: 1%, 9%, 6%, 2%, 15%

我们想走捷径找到我们的平均年利率，也就是 5 年后我们的总金额，所以我们试着“平均”这些利率:

(.01 + .09 + .06 + .02 + .15) ÷ 5 = .066 = **6.6%**

然后我们将这个平均百分比插入到复利公式中:

Total interest earned = $100,000 * (1.066⁵ - 1) = $37,653.11 Interest + principal = $37,653.11 + 100,000 = $137,653.11 **Final total** = **$137,653.11**

为了确保我们没有欺骗自己，让我们用长时间的方法来比较结果:

****Year 1**: 100,000 + (100,000 * .01) = 100,000 * 1.01 = $101,000
**Year 2**: 101,000 * 1.09 = $110,090
**Year 3**: 110,090 * 1.06 = $116,695.40
**Year 4**: 116,695.40 * 1.02 = $119,029.31
**Year 5**: 119,029.31 * 1.15 = $136,883.70
**

发生了什么事？我们的捷径高估了我们的实际收入近 1000 美元。

我们犯了一个常见的错误: 我们对一个乘法过程应用了加法运算，&得到了一个不准确的结果。

现在让我们用几何平均数再来一次:

1.01 * 1.09 * 1.06 * 1.02 * 1.15 = 1.368837042 5th root of 1.368837042 = 1.064805657 **Geometric mean** = **1.064805657**

(技术说明:我们必须使用1 + interest rate作为几何平均数计算中的输入，因为这些是乘以本金值以产生每期应计利息金额的实际因数，并且我们需要找到这些因数的平均值。这有一个额外的好处，即使当出现负比率时，也可以避免负数，这是几何平均方程无法处理的【它也无法处理0s】。算术平均没有这个问题。无论我们使用利率本身还是1 + interest rate作为输入(然后从结果中减去1)都是一样的，因为它是加法而不是乘法。但是几何平均数会不一样，而且不对，如果不加1。)

将利率的几何平均值代入我们的复利公式:

Total interest earned = $100,000 * (1.0648⁵ - 1) = $36,883.70 Interest + principal = $36,883.70 + 100,000 = $136,883.70 **Final total** = **$136,883.70** exactly the same as the long method above

这还差不多。

我们对正确的工作使用了正确的方法，得到了正确的结果。

几何平均还有什么用？

不同的比例或单位

几何平均数的一个奇特的特点是你实际上可以在完全不同的尺度上计算数字的平均值。

例如，我们想比较使用两种不同来源的两家咖啡店的在线评分。问题是**source 1**用的是5-star标尺&T2 用的是100-point标尺:

*source 1*评分:*4.5*``*source 2*评分: *68*

*source 1***评分:【
*source 2*评分: *75***

如果我们天真地对每家咖啡店的原始评分进行算术平均:

咖啡馆 A = (4.5 + 68) *÷* 2 **= 36.25** 咖啡馆 B = (3 + 75) *÷* 2 = **39**

我们得出结论，咖啡店 B 是赢家。

如果我们对数字更了解一点，我们就会知道，在用算术平均值对它们进行平均之前，我们必须将我们的值标准化到相同的范围内，以获得准确的结果。因此，我们将**source 1**评级乘以20，使其从5-star等级变为**source 2**的100-point等级:

4.5 * 20 = 90 (90 + 68) ÷ 2 = **79**

3 * 20 = 60 (60 + 75) ÷ 2 = **67.5**

所以我们发现咖啡店 A* 是真正的赢家，与上面算术平均值的天真应用相反。***

然而，几何平均数使我们能够得出相同的结论，而不必在尺度或测量单位上大惊小怪:

咖啡馆甲=*square root of (4.5 * 68) =* ***17.5*** 咖啡馆乙 = *square root of (3 * 75) =* ***15***

瞧啊！

算术平均值在更大范围内受数字支配，这使我们认为咖啡店 B* 是评级较高的商店。这是因为算术平均值期望数字之间的加法关系&不考虑比例&的比例。因此，在应用算术平均值之前，需要将数字放在同一尺度上。***

另一方面，几何平均值由于其乘法性质，可以轻松处理不同的比例。这是一个非常有用的属性，但是注意我们失去了什么*:我们不再有任何可解释的标度。在这种情况下，几何平均值实际上是无单位的。***

即上述几何平均既不是**17.5** 'out of' 100 points 也不是**15** 'out of' 5 stars。它们只是相对比例的无单位数。(技术上来说，它们的尺度是原尺度的几何平均值，**5** & **100**，也就是**22.361**)。如果我们实际上想要相对于一些对我们有意义的尺度来解释结果，比如最初的5或100-point系统，这可能是一个问题。但是如果我们只是想知道两家咖啡店的收视率之间的关系，我们就可以开始了。

2018 年 7 月 14 日更新:正如由m laden fern eir指出的，不能保证几何平均值将始终保持算术平均值在缩放值或归一化值上的排序，更不用说与其成比例了，正如我最初指出的那样。相反，它只是总结不同数字组之间关系的一种不同方式(尽管这种方式通常会在不同尺度上产生更“可信”的数值汇总)。所以再一次，谨慎的批判性思维对它的应用是必要的。

几何平均重述 至TL；博士:**

几何平均值 乘以而不是对值求和，然后取*n*th root而不是除以*n*
它本质上说:如果我们数据集中的每个数字 都是同一个数字 ，那么这个数字必须是 才能和我们实际的数据集有相同的乘法运算 ***product*** ？
这使得它非常适合于描述的乘法关系，例如rates & ratios，即使那些比率在 不同的标度 (即没有相同的denominator)上。(由于这个原因，它经常被用来计算金融& 其他指标 /指数。)**
也有不利的一面:有意义的标度 & 单位在应用几何平均值时可能会丢失，其对异常值的不敏感性可能会掩盖可能产生后果的大值。此外，它会产生与转换为单个刻度的值的算术平均值不一致的结果。**

正如生活中的大多数事情一样，应用几何平均数几乎没有铁定的规则(除了复利之类的东西)。有一些试探法和经验法则，但是最终判断和科学怀疑是必需的，一如既往，对于健全的经验主义。

在下面的结论中有更多关于这一点的内容，但是现在让我们介绍我们最后的毕达哥拉斯的意思* …***

调和平均值

第三个也是最后一个毕达哥拉斯平均数。

这一节将比上一节短，因为调和平均数比几何平均数更深奥，但仍然值得理解。

算术平均值需要加法&几何平均值采用乘法，调和平均值采用倒数。

你可能还记得，一个数字***n***的reciprocal就是**1 / n**。(如5的reciprocal为1/5)。对于已经是分数的数字，这意味着你可以简单地“翻转”分子&分母:reciprocal of 4/5 = 5/4。这是真的，因为1 divided by a fraction产生那个分数的reciprocal，例如1 ÷ (4/5) = 5/4。

另一种思考倒数的方式是:两个数相乘等于 1。所以在求一个数***n***的倒数时，我们只是简单地问:我们必须与***n***相乘才能得到 ***1***。(这就是为什么reciprocal有时也被称为)的乘法逆运算。)**

那么，这个调和平均值可以用文字描述为:数据集的倒数算术平均值倒数。**

这里有很多相互翻转，但实际上只是几个简单的步骤:

*1\. Take the reciprocal of all numbers in the dataset 2\. Find the arithmetic mean of those reciprocals 3\. Take the reciprocal of that number*

在数学符号中，这看起来像:

来自维基百科的一个简单例子:1、4、4的调和平均值为2:

note: the notation “n-¹” is one way of symbolizing “the reciprocal of n”**

注意，我们在这里说的是:如果我们数据集中每个数字的的倒数都是同一个数字 ，那么 是什么数字才能有同一个倒数***sum***作为我们实际的数据集呢？****

(注:由于0没有reciprocal(没有什么可以乘以0到= 1)，所以调和平均也不能处理包含0的数据集，类似于几何平均*。)***

这就是管道的工作原理。但是 有什么好处呢？

调和平均值在现实世界中的应用

要回答这个，我们得回答:倒数有什么用？

因为倒数像所有除法一样，只是伪装的乘法(伪装的加法)，我们意识到:倒数帮助我们更容易地除以分数。

比如什么是5 *÷* 3/7？如果你还记得小学数学，你可能会用5乘以7/3(3/7的reciprocal)来解出这个问题:

5 *÷* 3/7 = 5/1 * 7/3 = 35/3 = 11 2/3 = 11.66667

但是一个等效的方法是将数字5 & 3/7缩放到一个公分母，然后以正常方式除法:

5/1 ÷ 3/7 = 35/7 ÷ 3/7 = 35 ÷ 3 = 11 2/3 = 11.66667

同样，类似于使用几何平均值作为乘法或非线性关系(see above)的算术平均值*，，调和平均值帮助我们找到分数之间的乘法/除法关系，而无需担心公分母。***

因此，调和平均值 自然地 容纳了几何平均值之上的另一层乘法/除法。*因此在处理不同长度或时期的利率或比率(即分数)数据集时很有帮助。*

侧边栏 :(你可能会想: “等等，我以为几何平均数是用来平均利息的利率 & 比率” 你说得没错。你也 不会先被 这个这个给弄糊涂了。我自己开始写这篇文章来澄清我自己的想法。所以请原谅我，我希望通过下面的例子让这一点更加清楚&在下面这篇文章的结论中总结所有这些差异。)**

平均行驶速度

在现实世界中使用谐波手段的典型例子包括以不同的速率(即速度)穿越物理空间:

考虑去一趟杂货店然后回来:

在去那里的路上，你全程都在开车
回来的路上，车流如织，你一路开车
你走了相同的路线，每条路都走了相同的路程(**5 miles**)。

在整个旅程中，你的平均速度是多少？

同样，我们可能会天真地将算术平均值应用于**30 mph** & **10 mph**，并自豪地宣称“**20 mph**！”

但是再考虑一下:因为你在一个方向上行驶得更快，你在那个速度下行驶的总时间更短，所以你在整个行程中的平均速度不是在**30 mph** & **10 mph**的中间点，它应该更接近于**10 mph** ，因为你在那个速度下行驶的时间更长。

为了在这里正确地应用算术平均值**，我们必须确定以每种速率旅行所花费的时间，然后适当地加权我们的算术平均值计算:**

行程在那里:(时速 30 英里) 30 miles per 60 mins = 1 mile every 2 minutes = 1/2 mile every minute 5 miles at 1/2 mile per minute = 5 ÷ 1/2 = 10 minutes **"Trip There" time** = **10 minutes**

返回行程:(以 10 英里/小时的速度) 10 miles per 60 mins = 1 mile every 6 minutes = 1/6 miles every minute 5 miles at 1/6 mile per minute = 5 ÷ 1/6 = 30 minutes **"Trip Back" time** = **30 minutes**

**Total trip time** = 10 + 30 = **40 minutes**

**“Trip There” % of total trip** = 10 / 40 minutes = .25 = 25% **“Trip Back” % of total trip** = 30 / 40 minutes = .75 = 75%

**Weighted Arithmetic Mean** = (30mph * .25)+(10mph * .75) = 7.5 + 7.5 = 15 **Average rate of travel = 15 mph**

因此，我们看到我们真实的平均旅行率是**15 mph**，比我们用未加权的算术平均值得出的**20 mph**要低5 mph(或25%)。

你大概能猜到这将走向何方…

让我们用调和平均值再试一次。

**Harmonic mean** of 30 and 10 = ... **Arithmetic mean** of **reciprocals** = 1/30 + 1/10 = 4/30 ÷ 2 = 4/60 = 1/15 **Reciprocal** of **arithmetic mean** = 1 ÷ 1/15 = 15/1 = **15**

瞧吧！

我们真实的平均行驶速度，自动根据每个方向花费的时间进行调整= 15 英里/小时！

inorite

请注意以下几点:

这仅仅是因为每次旅行的总距离是相同的。如果不同，我们就必须使用一个加权调和平均值**，或者另一个加权 算术平均值。**
对于算术平均值的^，我们将再次通过以每种速度行驶所花费的时间来加权，而对于调和平均值我们将通过行驶的距离来加权(因为它已经通过取它们的倒数来说明了速率中隐含的时间比例)。
^毕达哥拉斯的意思是的许多狡猾和诡秘归结为*比率 &我们对比率的哪一面更感兴趣。例如，算术平均值总是用分母表示。在行驶速度的情况下，比率是英里每小时**，因此算术平均值根据其(有点隐藏的)分母小时 : **(30m / 1hr)+(10m / 1hr) ÷ 2 = 20m/1hr = 20 mph**给出了一个结果。如果我们在每个方向花相同的时间旅行，这将是准确的，我们知道这是错误的。相反，调和平均值翻转这些比值，取它们的倒数，将我们实际感兴趣的数字放入分母，然后取算术平均值，再次翻转，&给出我们根据平均速度寻找的答案，与在该速度下花费的时间成比例。(关于使用财务市盈率比率的更深入讨论，请参见本文。)***
几何平均数对我们上面的复利例子有效的原因是利率在相等的时期内累积:一年。如果周期不同，也就是说，在每种利率下累积利息的时间长度不同，我们就不得不再次使用某种权重。****
^几何平均值处理乘法关系，例如应用于不同评分等级的本金投资&比率的比率，而调和平均值则更进一步，通过倒数的魔力，轻松适应另一层乘法/除法关系*，例如变化的周期或长度。***

就像复利和几何平均数一样，这是一个精确、客观地应用调和平均数的例子。但是，事情并不总是那么清楚。还有其他精确的、数学上合理的应用在物理、金融、水文&甚至(按照惯例)在棒球统计中。与数据科学更密切相关:它经常应用于机器学习模型评估中的精度&召回。

但更多时候，这是一个判断，取决于对数据和手头任务的敏捷理解。

我将试着澄清和总结下面的要点。

第一部分结论

Back to where we started: A geometric construction of the Pythagorean means (of two numbers a and b)

回顾并明确我们已经展示的内容:

1。这三个毕达哥拉斯的方法是密切相关的，&每一个都可以表达为彼此的特例。

例如，我们看到:

不同尺度上的分数的几何平均值̵̵i̵̶̵s̵̶̵̵̶̵p̵̶̵r̵̶̵o̵̶̵p̵̶̵o̵̶̵r̵̶̵t̵̶̵i̵̶̵o̵̶̵n̵̶̵a̵̶̵t̵̶̵e̵̶̵̵̶̵t̵̶̵o̵̶̵有时可以保持算术平均值**的排序，当这些值被标准化到一个公共尺度时****
调和平均值相当于行程速率的加权算术平均值*(其中值由行程花费的相对时间加权)***

在第二部分*(随后会有单独的帖子)中，我们将看到那些已经熟悉乘法变换的人应该清楚的东西:数据集的几何平均值等价于该数据集中每个数字的对数的算术平均值。因此，正如调和平均值仅仅是经过一些倒数变换的算术平均值一样，几何平均值仅仅是经过对数变换的算术平均值。***

如果每个意味着只是另一个的变换或重构，那么这些变换如何交互&影响你的结果？

2。毕达哥拉斯的意思是符合严格的顺序关系。

由于各自的方程式:调和平均值 总是小于 几何平均值 ，后者总是小于 算术平均值 。

根据基础数据的分布情况，这三个平均值之间的距离会更近或更远。此规则的唯一例外发生在极端情况下，即数据集中的所有数字都是相同的精确数字，在这种情况下，所有 3 个平均值也是等价的。由此可见，下面的 不等式 成立:

**harmonic mean** ≤ **geometric mean** ≤ **arithmetic mean**

这些比例可以在本节开始的毕达哥拉斯* (+二次)意为的几何描绘中观察到。***

认识到这种关系有助于理解何时应用每种方法，以及对结果的影响。

为了更具体地说明这一点，让我们重温一下我们最初的加法和乘法数据集，每个数据集都描述了三种方法:

加法数据集{ *1, 4, 7, 10, 13, 16, 19…* }

**Harmonic mean** = 4.3 **Geometric mean** = 7.3 **Arithmetic mean** = 10

显然，几何 & 谐波 意味着似乎大大低估了这个线性、可加数据集的“中间值”。这是因为这些平均值对较小的数字比对较大的数字更敏感(使它们对较大的异常值也相对不敏感)。

乘法数据集{ *1, 3, 9, 27, 81, 243, 729…* }

**Harmonic mean** = 4.7 **Geometric mean** = 27 **Arithmetic mean** = 156.1

在这里，几何平均值精确地位于数据集的顺序中间，而调和平均值仍然偏向低侧&算术平均值由于受到大的异常值的影响而严重偏向高侧。

要描绘一个由调和平均值很好地描述了中心趋势的数据集并不容易，所以我将继续…

3。有一些硬性规定，一些启发法&很大的判断余地

为了对不同标度的比率进行平均；使用几何平均值**(或标准化分数的算术平均值)****
为了平均连续期间的复合利率变化:使用几何平均数**
为了平均不同时期或长度的利率；使用调和平均值**(或加权算术平均值)****
知道你对自己的哪一方面更感兴趣，以及申请哪一方面。算术平均值用分母表示，不管它是否可见。调和平均值允许您反转比率，以获得原始分子的答案。
如果你的数据显示一个加法结构:算术平均值通常是安全的**
如果您的数据显示乘法结构和/或有较大的异常值:那么几何平均值或调和平均值可能更合适(正如中值一样)**
任何决策都有陷阱&权衡*:使用几何平均 - 数据集与 *0* 的不能与几何平均或调和平均、& 一起使用***
更实际和更容易理解的是:
-在存在大的异常值
时使用中值-移除或限制异常值
-使用加权算术平均值或统计变换，而不是深奥的毕达哥拉斯方法****
尽管 R 统计计算语言具有用于矩阵求逆 & 三次样条插值的内置方法，但它没有计算简单的几何或调和平均值**的原生函数，这可能表明它们的稀有性。(谷歌工作表&然而 Excel 确实有)****