TowardsDataScience 博客中文翻译 2019（二百九十三）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

深度学习入门:14 岁孩子教的

原文：https://towardsdatascience.com/intro-to-deep-learning-taught-by-a-14-year-old-6c49fc94d66?source=collection_archive---------14-----------------------

跳入深度学习的最深处

Manhattan Digest, “Streets of New York.” Image annotated by me using the Faster RCNN Inception V2 Model.

“我是一个乐观主义者，我相信我们可以创造出对世界有益的人工智能。它能与我们和谐相处。我们只需要意识到危险，识别它们，采用尽可能最好的实践和管理，并提前为其后果做好准备。”斯蒂芬·霍金

你们中的许多人可能已经开始听到人工智能治愈癌症的传奇故事，或者听到智能机器人接管的可怕故事。今天，或者无论哪一天你正在阅读这篇文章(你好，未来机器人霸主)，我将解释什么是深度学习，为什么人们如此害怕它，以及如何使用它。

随着人类在 S.T.E.M .方面取得新的进展，有一个领域似乎每天都在快速进步。机器学习和人工智能的子集深度学习正在以惊人的速度前进。几乎每天，谷歌(Google)和亚马逊(Amazon)等大公司都会想出新的方法，让计算机能够检测出一些东西，比如一个人是否患有癌症，或者能够在放射扫描中快速检测出骨折。这些计算机可以比普通医生更精确、更快速地检测到这一点。

Google Teachable Machine learning hand gestures (it took me 2 minutes to train).

人工智能 vs 机器学习 vs 深度学习:认知计算进化简史

This graphic from Nvidia shows the transition from Artificial Intelligence to Deep Learning as technology and understanding of the human nervous system improved.

人工智能:模仿人类智能

与你所想的相反，人工智能已经存在了很长时间。直到 1956 年关于人工智能的达特茅斯夏季研究项目，机器展示人类智能的想法才看起来像是一项可能的成就。那次会议标志着该领域努力的开始，虽然标准计算在当时并不复杂，但它似乎仍然是一个重要的里程碑。“50 年代创造的人工智能能做什么？”你可能会问。最受欢迎的例子是几乎每台电脑都预装的象棋应用程序。如果你决定与计算机下棋，你实际上是在使用人工智能的最基本形式。计算机根据硬编码算法知道下一步该怎么走。

机器学习:人工智能的新观点

通过人工智能的子集机器学习，工程师能够将大量关系数据输入计算机，并获得对未来数据的有根据的预测。这在理解一个地区的房价、天气模式、垃圾邮件等方面非常流行。虽然机器学习在其应用领域取得了成功，但由于其许多限制(更适合少量数据)，它仍然没有得到广泛使用。

深度学习:证明大脑高度活跃

深度学习是机器学习的一个子集，它赋予计算机“学习”(逐步提高特定任务的性能)的能力，而无需明确编程如何完成所述任务。深度神经网络能够接受数据输入，如图像和音频文件，并从被标记的内容中学习。由于对人类神经系统的新的和改进的理解以及硬件的改进，这项新技术最近才开始实施。以前，这些网络所需的巨大计算能力使得训练和评估模型几乎不可能。随着 GPU(显卡)的兴起，这种用于比特币挖掘的关键组件，研究人员每秒钟能够进行更多的数学运算。深度学习是如此之新，以至于许多计算机仍然没有足够的能力来运行模型；当我试图教一个网络扑克牌之间的区别时，在我的笔记本电脑上训练需要 28 周，而我的带 GPU 的台式机只需要 15 分钟。

My custom object detector for playing cards in a deck.

背后的神经科学

当事情发生时，我们的大脑能够通过遍布全身的神经元做出反应来理解我们所经历的事情。一个例子是，我们手中的一些神经元可能只有在物体热的时候才会向我们的大脑发出电脉冲，而其他神经元可能只有在物体冷的时候才会发出电脉冲。神经元遍布我们的身体和大脑，每一个都有不同的任务。仅大脑就有大约 860 亿个神经元。这个由神经元互联网络组成的系统，向大脑提供数据，发展成为一个令人难以置信的科学突破:深度学习。

Comparison between the connected networks within our bodies and a simple neural network (via https://www.quora.com/What-is-the-differences-between-artificial-neural-network-computer-science-and-biological-neural-network)

深度学习是如何学习的

监督学习

卷积神经网络是使用监督学习的最常见的神经网络类型。监督学习是指人类获取非对应的输入数据，并对这些数据进行标记，以帮助模型进行学习。对于图像训练，这将需要标记图像中的对象，以便计算机能够用“答案”进行自我测试。这是我用扑克牌做的；我必须给 100 张不同的照片贴上标签，告诉电脑每种类型的卡片在给定的照片中的位置。

The architecture of a traditional convolutional network.

This person is not a real, it was created by a GAN. Source

Using CycleGAN to turn a video of a horse into a zebra.

无监督学习

OpenAI learning how to play Atari Breakout.

生成对抗网络

GAN(生成对抗网络)是一种无监督学习，能够从图像训练数据中从头生成数据。英伟达创造了生成人脸的 GAN 虽然照片中的脸看起来是真实的，但它绝不是曾经存在过的人类。甘拍摄了人类的照片，并发现了人类长相之间的共性。

强化学习

一种用无监督学习训练神经网络的新方法被称为强化学习。虽然大多数卷积神经网络模型都是用监督学习(模型根据给定的输入数据评估自身)来训练的，但强化学习模型根据给定的奖励来评估其性能。目前，这种形式的训练正在视频游戏中进行测试，游戏中的得分可以立即让模型满意，表明有所改善。谷歌 DeepMind 的 AlphaGo 最近就使用了这种方法，它在非常复杂的围棋比赛中以 5 比 0 击败了 3 次欧洲冠军。AlphaGo 计算机能够在没有任何指令的情况下学习。

人工智能的道德

这些新的科学突破让我们得以一瞥未来的社会，在未来，汽车为我们驾驶，医疗分析更便宜、更准确，我们的生活由机器人个人助理(如 Siri、Alexa 或 Google Home)组织。许多主流高管和研究人员担心，如果我们滥用这些新技术，会有什么后果。由于深度学习是一门新学科，我们无法确定它的使用范围；像强化学习这样的训练方法可能会导致计算机变得更加独立于人类，因为我们让它们自己去理解世界。无论这些可能性听起来有多好，它都会导致一些严重的未解问题，比如人造生命的权利，或者我们今天所知的社会终结的可能性。

根据我在页面顶部引用的斯蒂芬·霍金的话，他总结了由于早期采用者的错误决策而导致的这些新技术的误用。虽然在这一点上我们无法确定人工智能会给未来带来什么，但我们必须回忆起我们可能看过的机器人入侵的电影，并警惕人工智能可能带来的危险，尽管这听起来很荒谬。

Autonomous vehicles get confused when tape is put on top of a stop sign. Source: U.C. Berkeley

深度学习可能还没有做好大规模商业应用的准备，主要是因为一个致命的缺陷:深度学习训练数据是让它给出预测的东西，而不是道德。正如 2018 年 10 月亚马逊审判所证明的那样，亚马逊在意识到由于不良数据而导致的性别歧视后，取消了一项人工智能倡议。亚马逊试图通过创造一个人工智能来帮助决定申请人是否是合格的员工候选人，从而使亚马逊的招聘过程变得更容易。这个人工智能已经训练出亚马逊员工过去雇佣历史的信息，并拒绝了申请。那些雇用应聘者的人通常是性别歧视的，因为过去不合格的男性比合格的女性更容易被雇用。这是一个很好的例子，说明糟糕的训练数据会导致糟糕的模型。另一个糟糕的训练数据的例子是自动驾驶汽车的早期测试，其中如果标志上有便利贴，计算机无法检测到停车标志，而大多数人仍然知道这是停车标志。

2019 年深度学习的现状

虽然人工智能有许多优点，但如果不深入思考，它也有许多似乎并不具有威胁性的缺点。事实上，人工智能失控并终结人类的可能性非常小，至少现在是这样。对社会更大的威胁是失业；一个经常被忽略的工作是卡车驾驶。现在在美国，有超过 350 万卡车司机。沃尔沃和优步已经在测试他们的全自动卡车，这种卡车有能力让司机下班。截至 2019 年 1 月 30 日，亚马逊已经在 10 号州际公路上测试完全自动驾驶的卡车。随着 350 万卡车司机工作岗位的流失，如果司机不需要停下来休息，许多小型卡车站也会倒闭。

The Daimler Freightliner driverless truck. Source: Wall Street Journal

深度学习实际上是第四次工业革命，可能会被证明有利于就业率。继蒸汽机、电力和内燃机以及互联网等发明引发的革命之后，深度学习有望创造比失业人数更多的就业机会。当互联网普及时，许多人担心失业，但它创造了比以前更多的就业机会；一些因为互联网而创造的工作岗位的例子包括社交媒体经理、数据科学家、优步司机等等——这些工作在 15 年前甚至不存在。

深度学习帮助下的创新不会很快停止，因为刚刚签署了一项行政命令，将大量资源用于将美国变成人工智能的世界领导者，而不是中国。“2017 年 7 月，[中国]公布了一项成为人工智能世界领导者的计划，旨在到 2030 年为其经济创造价值 1500 亿美元的产业，两个中国城市承诺为此投资 70 亿美元，”《纽约时报》报道。

IBM’s Project Debater in a live debate against one of the world’s best debaters. Source: IBM

处理深度学习已经在当今社会中实施的事实是令人生畏的，但它不会很快停止。谷歌的一个团队正在使用人工智能帮助医生为印度的糖尿病患者预防失明，在印度，医生自己无法足够快地分析患者。2011 年，IBM 的沃森电脑赢得了“危险边缘！”他的奖金是连续 74 场比赛获胜的著名选手肯·詹宁斯的 7 倍多。最终，游戏之间的竞争表明沃森是明显的胜利者，正如肯·詹宁斯所表达的，“我，欢迎我们新的计算机霸主。”IBM 在智慧游戏中击败人类的持续追求最近在 2019 年 2 月 12 日继续进行，当时 IBM 与哈里什·纳塔拉詹(Harish Natarajan)进行了辩论，后者通常被认为是世界上最好的辩手。虽然 IBM 给出了许多有说服力的论据来说明为什么应该补贴学前教育，但 IBM 的 debater 由于其单调的声音，未能在情感层面上与评委建立联系。要是 IBM 能从谷歌的 Tacotron 自然音频合成器那里学到一些技巧就好了。不要为 IBM 的损失感到太难过…谷歌的 DeepMind 刚刚创造了一个 AI，它打败了最优秀的人类星际争霸玩家。

A graphic of how DeepMind’s AI is able to understand the map of the game. Source: DeepMind

结论

虽然一开始可能很难相信电视节目想到的许多不可思议的想法已经进入市场，但这不应该看起来很可怕。深度学习才刚刚起步；许多曾经被认为是不可解决的想法现在正成为似是而非的发明。我希望这篇文章没有让你回避深度学习，而是拥抱可能出现的好东西，并希望激励你继续学习更多关于制作神经网络的知识。

奉献

如果没有我的学校 Pine Crest School 和佛罗里达州大西洋大学机器感知和认知机器人实验室的人的帮助，我永远不会找到我对深度学习的热情。我记得当威廉·哈恩博士和伊兰·巴伦霍尔茨博士在一次创新会议上对 Pine Crest 讲话时，我对了解深度学习是什么感到非常兴奋。这段旅程是一次不可思议的经历，我期待着进一步研究人工智能和深度学习。

“智慧的真正标志不是知识，而是想象力.”-阿尔伯特·爱因斯坦

使用 DEAP 介绍进化计算

原文：https://towardsdatascience.com/intro-to-evolutionary-computation-using-deap-618ca974b8cb?source=collection_archive---------14-----------------------

Pixabay

介绍

进化计算是一种非常强大的通用优化技术，其主要灵感来自自然选择进化理论。自然选择进化是一个非常优雅的理论，它对自然界生物多样性的解释依赖于两个主要部分:

• 随机突变
• 选择压力

不同的生态栖息地对生存的挑战和要求是不同的。根据进化理论，在任何生态位中，由于 DNA 的随机突变和复制中的复制错误，不同生物的特征将是不同的。由于性状的这种变异，对于具有更适合生存的性状的生物来说，将会有不同的生存优势，也就是说，大自然隐含地施加了一种选择适合个体的压力。因为最健康的生物更有可能存活下来，它们会把“健康”基因传给它们的后代，后代也更有可能存活下来。

进化可以被认为是一种优化适应度的算法。这是进化优化的核心思想。换句话说，如果我们有一个问题，我们可以为它生成不同的解决方案，那么我们可以使用每个解决方案的性能作为适应度的度量，这可以驱动进化算法找到越来越好的解决方案。进化算法有不同的风格，这些风格共享它们的大部分组件，然而，在每个组件的细节和特征上有所不同。进化算法的主要组成部分是:

• 表示方案(例如基因型、表型等)
• 配对运算符(例如交叉)
• 变异操作符(如比特翻转)
• 健康指标
• 选择策略(如锦标赛选择)
• 进化策略(如 mu、lambda)

你可以在我的上一篇文章中找到关于进化算法不同变体的更详细的介绍。出于本教程的目的，我将重点关注一种叫做进化策略(ES)的变体，接下来我将简要介绍它。完整的 jupyter 笔记本可在这里获得。

进化策略

正如我提到的，所有的进化算法都有前述的大部分组成部分，只是细节不同。对于专家系统，表示方案主要是一种表型，即个体(或解)被明确地表示为数字向量。每个个体都会有一个伴随的向量，叫做策略，它只是一个控制其变异的向量。ES 中使用了不同的交配算子，但我们将使用的是混合算子，它主要是交配亲本之间的一种线性组合形式。我们将使用的变异算子是对数正态的，像 ES 中的所有变异算子一样，它依赖于上面提到的策略向量来变异个体的表示向量中的不同值。选择策略将是锦标赛选择，其中对一个子集个体进行多次随机选择，每次选择最佳个体。适应度函数是任何进化算法中必须委托给用户来定义的唯一部分，即用户将提供一些函数，该函数将基于对于手边的问题的合适的测量来分配适应度给群体中的每个个体。进化策略控制种群的大小，这里我将使用(mu，lambda)_ 读作‘mu 逗号 lambda’_，其中 mu 和 lambda 是正整数，mu 指的是父代种群的大小，而 lambda 指的是所产生的后代的大小。在这个策略中，选择策略(即本例中的锦标赛选择)仅适用于后代。

像所有的进化算法一样，ES 是在被称为代的迭代中完成的。每一代，后代都是由群体中当前的父母通过交配然后突变而产生的。然后评估新成员的适应度，并应用选择策略来选择将存活到下一代的个体。

DEAP

DEAP 是一个实现进化算法的 python 框架。它为协调任何进化算法所需的不同组件提供了一种有组织的简化方法。对于任何组件，DEAP 提供了预定义组件的大多数常见变化，同时提供足够的灵活性来定义自己的变化，以防常用组件不足以解决您的问题。

让我们首先定义一个可以使用 ES 优化的虚拟问题。在许多情况下，你会有一些自然的过程，我们称之为数据生成过程，你想要建模，以便你可以在以后做出预测。数据生成过程就像一个黑匣子，你永远无法看到里面，但你可以给它一个输入，它就会用一个输出来回应。

正如您在上面看到的，这个数据生成过程接受一个输入，并基于某个三次多项式产生一个输出。请注意，我们从来没有访问这个公式，这只是为了说明的目的。其实我们的任务就是用 ES 来建模这个未知的公式。我们只能“查询”这个黑盒并获得响应，也就是说，我们可以对它进行采样，

注意，增加了一个附加随机项。这个术语代表噪声，由于有许多来源，噪声是任何观测中不可避免的成分。

为了使用进化算法对一个过程建模，我们需要一个候选模型，基本上，一个关于我们正在寻找的模型类型的假设或“归纳偏差”。这可能来自另一个分析来源或以前的数据分析。对于我们的虚拟情况，我们将假设我们知道我们正在搜索的模型是最多四次的多项式，所以我们决定使用四次多项式，

“a”变量集是未知的，我们需要进化算法来优化它们，以便模型输出符合我们的数据。这将反映在我们下面讨论的评估函数的定义中。但是首先，我们需要准备我们的 ES 算法。

让我们导入实现所需的基本子包，

要使用 DEAP 实现 ES，我们首先需要将我们的个体、策略和适应性定义为数据类型。这可以在 DEAP 完成，不需要显式定义自己的类，

第一行定义了我们的健身数据类型。第一个参数给出了数据类型名称，第二个参数给出了基类，即 DEAP 提供的适应度度量的基类，第三个参数将适应度权重设置为负值，这意味着进化优化将尝试最小化该值。我们试图最小化适应度可能看起来很奇怪，但是正如你将看到的，我们将使用的适应度函数实际上是一个误差函数，也就是说，它测量我们的解决方案偏离观察值多少，因此，我们需要最小化它。

注意，在运行这一行之后，数据类型 FitnessMin 被动态地添加到 creator 子包中，您可以作为“creator”直接访问它。健身。

第二行类似，但是，它定义了个人。从第四个参数开始，您提供的任何参数都将作为字段或属性添加到已定义的数据类型中。对于个人来说，我们定义了 DEAP 所要求的一个必要条件，那就是健康。当 DEAP 想要更新适应值或读取它时，它将寻找这个。你可以看到我们把我们定义的 FitnessMin 传递给它。ES 算法需要策略属性，因为它依赖于策略向量来进行变异。我们将其初始化为“None ”,因为稍后我们将自己填充它。您可以将您需要的任何其他属性传递给 create 函数，它们将被添加到您的数据类型中。第三行定义了策略数据类型。

现在我们需要注册一些函数，以便于使用我们定义的数据类型来生成个体，并将它们聚合成一个群体。DEAP 为此提供了一个特殊的实用“工具箱”,

首先，我们定义一个函数，它接受我们的个体和策略类以及个体的大小，即个体向量中包含多少参数，并生成一个随机初始化的个体，并用随机初始化的策略向量填充它。然后，我们初始化我们的工具箱，并使用它的注册函数两次。第一种用法是注册一个名为“个人”的函数。您可以看到，第二个参数是我们实际定义的函数实现，其余参数是调用时默认传递给函数的参数。

第二种用法定义了另一个重要的函数，叫做‘population ’,我们将用它来生成人口。我们传递一个 DEAP 预定义的函数，它是 initRepeat。initRepeat 之后的参数也是调用时默认传递给它的参数。当我们从工具箱中调用函数“population”时，将调用 initRepeat，它将使用第二个参数初始化一组个体，这是我们预定义的个体生成函数，它将把它们放入“list”类型的容器中，这是它的第一个参数，并返回它。

我们现在需要注册评估功能，DEAP 将使用该功能为不同的个人分配适合度。这就是我们假设的多项式模型发挥作用的地方，

“pred”函数获取一个个体和一个数据点，并通过计算四次多项式返回模型输出。您可以看到，个人参数 1–4 用作不同指数的 x 的系数，第五个用作偏差/截距，即不含 x 的项。

“fitness”函数计算实际输出和我们的模型输出(使用前面的函数“pred”计算)之间的均方误差(MSE)。更健康的个体将具有更小的 MSE，这就是我们在开始时定义的健康被赋予负权重的原因。我们对使 MSE 更小感兴趣。

最后，我们使用特殊的关键字“evaluate”在工具箱中注册我们的适应度函数，以便 DEAP 在计算适应度时可以找到它。

我们需要注册一些操作所必需的函数，它们是变异、交叉和选择操作符。我们可以通过在工具箱中注册一组函数来实现，这些函数都有特定的名字，DEAP 在执行这些操作时会查找这些名字，

配对、变异和选择分别是交叉、变异和选择操作符。对于所有这些组件，我们使用预定义的 DEAP 组件，并传递它们所需的参数。

到目前为止，这些是 ES 运行的大部分必要组件。DEAP 提供的一个非常方便的可选工具是“统计”工具，我们可以配置它来获得每一代进化算法的一些统计数据，

当我们初始化我们的统计数据时，我们在构造函数中提供了一个函数定义，它将在 DEAP 调用时接收一个个体，我们需要返回我们希望对其应用统计运算符的个体的属性。注册的函数名将被用作相应 stat 的标签，例如{‘avg’:

另一个方便的工具是“名人堂”,我们可以对其进行配置，DEAP 会将每一代中最优秀的 k 个人填入其中，

“1”表示它将只由最优秀的个体填充。

现在，我们准备启动 ES，让它为我们带来奇迹，

第一行只是初始化一个新的群体，它被传递了我们的 mu 值作为它的大小，因为我们将使用前面描述的(mu，lambda 或 MuCommaLambda)算法。第二行使用提到的算法运行单代 ES(ngen = 1 ),传递第二个需要的参数 lambda。你可以看到我们还通过了我们定义的工具箱，它包含了我们所有配置的函数和操作符，我们的统计数据和名人堂。下面是 100 代运行的可视化。

参考

• https://deap.readthedocs.io/en/master/
• 贝克，t .，福格尔，D. B .，&米切莱维奇，z .(编辑。).(2018).进化计算 1:基本算法和算子。CRC 出版社。

数据科学的特征选择方法介绍

原文：https://towardsdatascience.com/intro-to-feature-selection-methods-for-data-science-4cae2178a00a?source=collection_archive---------6-----------------------

让数据更易于管理的指南

作者:瑞安·法玛尔，韩宁，玛德琳·麦康贝

Photo by Eugenio Mazzone on Unsplash

什么是特征选择？

好吧，让我们从定义什么是特性开始。要素是数据集中的 X 变量，通常由列定义。如今，许多数据集可能有 100 多个要素供数据分析师进行排序！这对于正常处理来说是一个荒谬的数量，这就是特征选择方法派上用场的地方。它们允许您在不牺牲预测能力的情况下减少模型中包含的特征数量。多余或不相关的特征实际上会对模型性能产生负面影响，因此删除它们是必要的(也是有益的)。想象一下，通过制作纸飞机来学习骑自行车。我怀疑你第一次骑马能走多远。

功能选择的好处

特征选择的主要好处是它减少了过度拟合。通过删除无关的数据，它允许模型只关注数据的重要特性，而不会被无关紧要的特性所困扰。删除不相关信息的另一个好处是，它提高了模型预测的准确性。它还减少了获取模型所需的计算时间。最后，要素数量越少，模型的可解释性越强，也越容易理解。总的来说，特征选择是能够以任意精度预测值的关键。

概观

有三种类型的特征选择:包装方法(向前、向后和逐步选择)、过滤方法(ANOVA、Pearson 相关、方差阈值)和嵌入方法(Lasso、Ridge、决策树)。我们将在下面用 Python 的例子来解释每一个。

包装方法

包装方法计算具有特定特征子集的模型，并评估每个特征的重要性。然后，他们迭代并尝试不同的功能子集，直到达到最佳子集。这种方法的两个缺点是，对于具有许多特征的数据，计算时间较长，并且当没有大量数据点时，它往往会使模型过拟合。最著名的特征选择包装方法是向前选择、向后选择和逐步选择。

正向选择从零个特征开始，然后针对每个单独的特征，运行一个模型，并确定与所执行的 t 检验或 F 检验相关的 p 值。然后，它会选择 p 值最低的要素，并将其添加到工作模型中。接下来，它采用所选的第一个要素，运行添加了第二个要素的模型，并选择 p 值最低的第二个要素。然后，它采用之前选择的两个要素，并使用第三个要素运行模型，依此类推，直到所有具有显著 p 值的要素都被添加到模型中。任何在迭代中尝试时从未具有显著 p 值的要素都将从最终模型中排除。

反向选择从数据集中包含的所有特征开始。然后运行模型，并为每个要素计算与模型的 t 检验或 F 检验相关联的 p 值。然后，将从模型中移除具有最大无关紧要 p 值的要素，并重新开始该过程。这种情况会持续下去，直到从模型中移除所有 p 值不显著的要素。

逐步选择是向前和向后选择的混合体。如上所述，它从零个要素开始，添加一个具有最低有效 p 值的要素。然后，遍历并找到具有最低有效 p 值的第二个要素。在第三次迭代中，它将寻找具有最低有效 p 值的下一个特征，并且它还将移除 先前添加的现在具有不重要 p 值的任何特征。这使得最终的模型包含了所有重要的特性。

上述不同选择方法的好处是，如果您对数据以及哪些特征可能是重要的没有直觉，它们将为您提供一个良好的起点。此外，它有效地从大量数据中选择具有重要特征的模型。然而，一些缺点是，这些方法不能贯穿每一个单一的特征组合，因此它们可能不会以绝对最佳的模型结束。此外，它还会产生具有高度多重共线性的模型(由于要素之间的关系而导致 beta 系数膨胀)，这对于精确预测来说并不太好。

过滤方法

过滤方法使用除差错率之外的度量来确定该特征是否有用。不像在包装器方法中那样调整模型，而是通过有用的描述性度量对特性进行排序来选择特性的子集。过滤方法的好处是计算时间非常短，不会过度拟合数据。然而，一个缺点是它们看不到特征之间的任何交互或相关性。这需要单独考虑，这将在下面解释。三种不同的过滤方法是 ANOVA、Pearson correlation 和方差阈值法。

ANOVA (方差分析)测试查看特征处理内以及处理间的变化。这些差异是这种特定过滤方法的重要指标，因为我们可以确定某个特征是否很好地解释了因变量的变化。如果每个特定处理的方差大于处理之间的方差，那么该特征没有很好地解释因变量的变化。为了进行 ANOVA 检验，使用分子(SST，通常与 SSTotal 混淆)中的处理之间的变化和分母中的处理内的变化来计算每个单独特征的 F 统计量。然后，针对零假设( H0:所有处理的平均值相等)和替代假设( Hα:至少两个处理不同)对该检验统计量进行检验。

皮尔逊相关系数是两个特征相似性的度量，范围在-1 和 1 之间。接近 1 或-1 的值表示这两个特征具有高相关性，并且可能是相关的。要使用此相关系数创建要素减少的模型，您可以查看所有相关性的热图(如下所示),并选择与响应变量(Y 变量或预测变量)相关性最高的要素。高相关性与低相关性的临界值取决于每个数据集中相关系数的范围。高相关性的一般度量是 0.7<|相关性| < 1.0。这将允许使用所选特征的模型包含数据集中包含的大部分有价值的信息。

The response variable for this dataset SalePrice (top row) shows the correlation with the other variables. The light orange and dark purple show high correlations.

特征减少的另一种滤波方法是方差阈值化。一个特征的方差决定了它包含多少预测能力。方差越低，特征中包含的信息就越少，它在预测响应变量中的价值就越小。鉴于这一事实，方差阈值是通过找到每个特征的方差，然后将低于某个方差阈值的所有特征丢弃来完成的。如果您只想移除响应变量的每个实例中具有相同值的要素，则该阈值可以为 0。但是，要从数据集中移除更多要素，可以将阈值设置为 0.5、0.3、0.1 或其他对方差分布有意义的值。

如前所述，有时将交互添加到您的模型中会很有用，尤其是当您怀疑两个特征之间存在关系，可以为您的模型提供有用的信息时。交互可以作为交互项添加到回归模型中，显示为 B3X1X2。贝塔系数(B3)修改 X1 和 X2 的乘积，并测量两个特征(x)组合的模型的效果。要查看某个交互项是否显著，您可以执行 t 检验或 f 检验，并查看该项的 p 值是否显著。一个重要的注意事项是，如果相互作用项是重要的，两个低阶 X 项都必须保留在模型中，，即使它们是不重要的。这是为了保持 X1 和 X2 作为两个独立的变量，而不是一个新的变量。

嵌入方法

嵌入式方法将特征选择作为模型创建过程的一部分。这通常导致前面解释的两种特征选择方法之间的折衷，因为选择是结合模型调整过程完成的。 Lasso 和 Ridge regression 是这种类型的两种最常见的特征选择方法，并且决策树也使用不同类型的特征选择来创建模型。

偶尔，您可能希望在最终模型中保留所有特征，但不希望模型过于关注任何一个系数。岭回归可以通过惩罚模型的 beta 系数过大来做到这一点。基本上，它降低了与可能没有其他变量重要的变量的相关性强度。这将处理数据中可能存在的任何多重共线性(要素之间的关系会增大它们的β值)。通过将惩罚项(也称为岭估计量或收缩估计量)添加到回归的成本函数中，可以实现骑行回归。惩罚项采用所有的 betas，并通过必须调整的项 lambda (λ)对它们进行缩放(通常使用交叉验证:比较相同的模型，但使用不同的 lambda 值)。Lambda 是一个介于 0 和无穷大之间的值，尽管从 0 和 1 之间的值开始比较好。λ值越高，系数收缩得越多。当 lambda 等于 0 时，结果将是没有惩罚的常规普通最小二乘模型。

Function from: https://codingstartups.com/practical-machine-learning-ridge-regression-vs-lasso/

This shows how Ridge regression can adjust some of the large coefficients found in linear regression by making them closer to zero.

As the value of lambda (alpha) increases, the coefficients are pushed toward zero with at the cost of MSE.

套索回归是另一种惩罚模型中贝塔系数的方法，与岭回归非常相似。它还向模型的成本函数添加了一个惩罚项，其中 lambda 值必须进行调整。与岭回归最重要的区别是，套索回归可以强制贝塔系数为零，这将从模型中移除该特征。这就是为什么套索有时是首选，尤其是当你想降低模型的复杂性。模型的特征数量越少，复杂性就越低。为了迫使系数为零，添加到成本函数中的罚项取β项的绝对值，而不是求其平方，当试图最小化成本时，这会否定函数的其余部分，导致β等于零。

Function from: https://codingstartups.com/practical-machine-learning-ridge-regression-vs-lasso/

脊套回归的一个重要注意事项是你所有的特征都必须标准化。Python 和 R 中的许多函数会自动完成这项工作，因为 lambda 必须平等地应用于每个特性。一个要素的值以千为单位，而另一个要素的值以十进制为单位，这种情况不会发生，因此需要标准化。

另一种使用特征选择对数据建模的常见方法称为决策树，它可以是回归树或分类树，分别取决于响应变量是连续的还是离散的。该方法基于某些特征在树中创建分割，以创建算法来找到正确的响应变量。构建树的方式使用嵌入方法中的包装方法。我们的意思是，在制作树模型时，函数内置了几种特征选择方法。在每次分割时，用于创建树的函数会尝试所有要素的所有可能分割，并选择将数据分割为最相似组的分割。简单地说，它选择最能预测树中每个点的响应变量的特性。这是一个包装器方法，因为它尝试了所有可能的特性组合，然后选择了最好的一个。

预测响应变量时最重要的特征用于在树的根(开始)附近进行分割，而更不相关的特征直到树的节点(结束)附近才用于进行分割。这样，决策树惩罚了对预测响应变量没有帮助的特征(嵌入式方法)。生成树后，可以选择返回并“修剪”一些没有为模型提供任何附加信息的节点。这可以防止过度拟合，通常通过维持测试集的交叉验证来实现。

总结

那么，现在你已经经历了这一切，你要带走的最重要的想法是什么？尽管数据集可能有成百上千个要素，但这并不意味着所有要素都很重要或有用。尤其是现在，我们生活在一个拥有难以想象的海量数据的世界里，重要的是要努力关注那些重要的信息。还有很多(复杂的)方法来执行特征选择，我们在这里没有提到，但是所描述的方法是一个很好的起点！祝你好运，继续努力！

关键词汇:

**特征:**x 变量，通常是数据集中的一列
**特征选择:**通过选择要使用的特征子集来优化模型

**包装器方法:**用不同的特征子集尝试模型并挑选最佳组合
**正向选择:**逐个添加特征以达到最优模型
**反向选择:**逐个移除特征以达到最优模型
**逐步选择:**混合正向和反向选择，逐个添加和移除特征以达到最优模型

**过滤方法:**通过除误差之外的度量选择特征子集(该度量是特征固有的，不依赖于模型)
**皮尔逊相关:**两个变量之间线性相关的度量
**方差阈值:**选择方差截止点以上的特征以保留数据中的大部分信息
ANOVA: (方差分析)用于观察处理(样本)均值差异的一组统计估计过程和模型；可用于判断某个特征何时对模型具有统计显著性
**交互术语:**当两个特征依赖于另一个的值时，对它们之间的关系进行量化；减轻多重共线性，并可提供对数据的进一步了解
**多重共线性:**当两个或多个独立变量彼此高度相关时发生

**嵌入式方法:**在模型创建过程中选择和调整特征子集
**岭回归:**一种改进的最小二乘回归，通过将λ项应用于成本函数来惩罚具有膨胀的β系数的特征
**拉索回归:**类似于岭回归，但不同之处在于添加到成本函数的λ项可以迫使β系数为零
**决策树:**一种非参数模型，使用特征作为节点来分割样本以在随机森林模型中，可以使用平均下降基尼系数来计算特征重要性。
**交叉验证:**一种迭代生成训练和测试数据集的方法，用于估计未来未知数据集上的模型性能

预测简介

原文：https://towardsdatascience.com/intro-to-forecasting-3dc183570d96?source=collection_archive---------31-----------------------

预测是另一种使用结构化数据(通常通过使用来自自然语言处理和物体识别的技术获得)来通知决策的技术。预测技术预测未来的结果或状态。

我们为什么要预测呢？说你要买房子。预测一年后你的投资价值可能会有用。如果你翻新了厨房呢？预测技术可以帮助你确定厨房改造可以增加多少价值。作为一个企业，预算非常重要。如果您可以预测需求、客户流失、预防性维护成本和收益等，您就可以在整个企业中高效地部署资源。如果你有一个网上商店，并能准确地预测你的客户下一步可能购买什么，你可以在他们的搜索结果或广告中显示该商品，以增加销售的可能性。

预测使用大量历史数据来创建历史上表现相似的组。然后，它可以将新数据点与其中一个组进行匹配，并使用该组的历史表现来预测未来。预测不同于优化，优化你可以在这里阅读更多关于的内容，因为它不需要决定采取哪些步骤来达到既定目标。它只是将新数据与历史数据中的模式进行匹配。您可能会注意到，预测的第一部分听起来很像聚类和分类，我们之前在这里讨论过。预测技术通常基于聚类和分类算法。

预测算法使用我们称之为“特征”的东西来识别行为相似的群体。这些特征是独立于我们试图预测的事物的可测量的特性。比方说，我们正试图预测一所房子的价格，就像我们之前提到的那样。我们可能使用的几个特征是房子的年龄和卧室的数量。房子的价格，也就是我们试图预测的东西，至少部分是由其特征决定的(在这种情况下，是其年龄和卧室数量)。我们说特征是独立的，是指特征本身，房子的房龄和卧室数量，不会因为价格的变化而增减。价格(我们的因变量)当然会随着房子变旧或者我们决定增加一间卧室而改变。

在这个简单的例子中，我们有两个特征。如果我们制作一个历史价格和卧室的年龄和数量的表格，我们可以做一些简单的数学，并且可能在不使用人工智能的情况下预测房子的价格。问题是，房子的价格不仅仅取决于我们在这个例子中使用的两个特征。房子有多大？有花园吗？门廊？它有多少故事？附近的学校有多好？这个地区的平均收入是多少？利率趋势如何？该地区就业情况好吗？我们可以考虑的特征数量几乎是压倒性的。住房甚至不是我们在预测中要解决的最复杂的问题。如果不使用人工智能，就很难为这些更复杂的问题开发出任何精确度的预测模型。

随着特征数量的增加，训练精确模型所需的训练数据量也在增加。这些数据被用来试图隔离每个特征对我们试图预测的东西的影响。在我们之前的房子示例中，如果我们的训练数据只有 1 间卧室的旧房子和 4 间卧室的新房子，我们的模型在预测价格时将无法从卧室数量中分离出年龄。我们希望有一个训练集，其变化代表接近所有的年龄和卧室数量的组合。正如您可能猜到的，当您开始添加更多功能时，您需要覆盖所有这些变化的训练数据量会显著增加。

如果我们试图解决一个有成百上千个特征的问题，事情会变得更加复杂。我们显然需要更多的训练数据，但我们也需要更多的计算能力。这增加了训练数据所需的时间，这意味着模型调整需要更长的时间，计算资源的成本也增加了。数据科学家开发了几种技术来帮助减少所需的计算资源量。

数据科学家用来降低必要计算能力的两种技术是“提升”和“打包”。这些技术不是同时在所有要素和所有历史数据上训练算法，而是划分训练数据并在数据的子集上训练算法。他们多次这样做，对不同的数据子集进行训练，然后将结果合并到一个模型中。提升保持所有特征不变，但是限制了训练样本的数量。在房价的例子中，这意味着在您拥有的所有历史房屋销售数据中，boosting 算法(例如 XGBoost )将只关注一些房屋销售。然后它会再次运行，关注不同的子集。一旦完成，它将合并结果。相比之下，Bagging 会关注所有的房屋销售，但只会关注我们正在考虑的一部分特征(比如年龄和卧室数量)。然后，bagging 算法(例如随机森林)会考虑其他特征(比如地区收入中位数和学校排名)再次运行，然后合并结果。这只是对这两种“元算法”非常粗略的描述。我们将在以后的文章中进一步深入探讨。

关于预测，需要记住的一件重要事情是，它无法理解特征的含义。在我们之前的例子中，房子的年龄很可能是一辆车的年龄，或者是从某人的最后一个生日算起的天数。该算法无法理解它正在解决的问题背后的意义，而是在数据中寻找数学模式。这种缺乏理解可能是一个特征，因为它可以识别人类通常不能识别的模式。这也可能是一种限制。如果用于为算法定型的历史数据有内置偏差，则生成的算法也会有内置偏差。例如，亚马逊花了数年时间训练一个人工智能系统来整理简历，并根据过去的招聘数据预测哪些候选人最有可能被录用。这些简历随后会出现在负责面试这些候选人的招聘经理面前。然而，他们建立的算法一贯贬低女性候选人，因为在历史数据中，男性更有可能被录用。你可以在这里阅读更多关于亚马逊的人工智能招聘系统。

另一个问题是，预测算法的决策过程可能是不透明的，这加剧了固有偏见的问题。虽然分类和回归树等更简单的模型为他们的决策过程如何工作提供了一些透明度，但更复杂的模型通常是人类难以理解的。如果预测算法预测某人更有可能在贷款上违约，我们将无法解释为什么该算法预测违约，只能说它反映在训练数据中。这使得很难识别预测系统中的固有偏差，除非通过观察其预测。我们将在以后的博客文章中讨论算法透明性和偏差消除技术的问题。

预测是目前人工智能研究中最活跃的领域之一。有了足够的无偏见的历史数据，人工智能可以对未来做出准确的预测。无论是预测客户流失、估价还是预测性维护，准确的预测都是无价的。

原载于 2019 年 4 月 10 日【https://www.foundationai.com】。

地理绘图介绍

原文：https://towardsdatascience.com/intro-to-geographical-plotting-237f59fec735?source=collection_archive---------8-----------------------

使用 Python 在任意地图上可视化 geographic数据

Photo by Kelsey Knight on Unsplash

在 数据科学领域，我们经常致力于将数据可视化，这为我们提供了关于数据的清晰模式，并使其易于分析。幸运的是，python 为此提供了强大的数据可视化工具。此外，可视化世界各地或任何特定国家的基于地图的数据会更有趣，这给了我们关于地理数据的很酷的见解。地理地图很重要，因为它们为我们的数据值提供了背景。

所以，让我们来看看 Python 的交互式可视化工具— plotly。使用 Plotly，我们可以从地理数据中创建美丽的 Choropleth 地图。

Choropleth 地图:

Choropleth maps 帮助我们绘制出全球或全国范围的信息。它让我们看到某个变量是如何在一个区域内分布的。在这篇博客中，我们将重点介绍如何使用**plotly**绘制 choropleth 地图。

阴谋地

Plotly 是一个开源库，它允许我们创建可用于仪表盘或网站的交互式绘图。Plotly 也是一家公司，支持在线和离线托管数据可视化。现在让我们使用离线模式，因为它是开源的，并且它使得在我们的 Python Jupyter 笔记本中工作变得容易。

由于数据格式多样，使用 plotly 进行地理绘图起初有点困难，因此请参考此备忘单了解所有类型的plotly绘图的语法。

让我们从下面的例子开始理解这个概念…

来自 Kaggle 的数据集:

让我们找出全球以及全国范围内的星巴克门店，并使用 choropleth 地图将这些数据可视化。数据集(directory.csv)可以从这里下载。该数据集包括截至 2017 年 2 月目前正在运营的每家星巴克门店的记录。

我们将经历以下步骤:

1. 导入所有的库，并将我们的 Jupyter 笔记本设置为脱机模式。
2. 使用 pandas 将星巴克数据提取到 Dataframe。
3. 为“美国国家”创建“数据和“布局对象，并绘制 choropleth 地图。
4. 为“全球”创建“数据和“布局对象，并绘制 choropleth 地图。

让我们先把plotly安装到 Jupyter 笔记本上

pip install plotly

第一步:

import plotly.plotly as py 
import plotly.graph_objs as go #importing graphical objects
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot

download_plotlyjs允许 plotly 在离线模式下工作。
init_notebook_mode将 Javascript 连接到我们的笔记本。

第二步:

import pandas as pd
df = pd.read_csv('directory.csv')

在进入第 3 步之前，让我们快速执行以下任务:

☑从上述数据集中获取子集数据(美国国家数据),并将其分配给新的数据框。
☑向数据集添加了一个新列——“商店计数”，以获得每个州的商店总数。

df_US = df[df['Country'] == 'US']

13608 entries for ‘US’ country

现在，要向数据框架添加新列“商店数量”，我们可以在“州/省”列上使用groupby(),如下所示

df_US['Store Count'] = df_US['Store Number'].groupby(df_US['State/Province']).transform('count')

State ‘AK’ has a total of 49 stores

df_US[df_US['State/Province'] == 'CA'][['State/Province','Store Count']].head(1)  # to check num of stores in 'California'

‘CA’ has a total of 2821 stores

**第三步:**绘制 ’ 美国国家地图

让我们定义我们的’数据和’布局对象如下:

**data** = dict(type='choropleth',
            locations = df_US['State/Province'],
            locationmode = 'USA-states',
            colorscale = 'Reds',
            text = df_US['Brand'],
            z = df_US['Store Count'],
            colorbar = {'title':"Stores Count"}
            )

type:定义地图的类型(choropleth)
locations:所有州的名称
locationmode:通过给出国家名称
colorscale来指定位置:显示彩色地图。(更多色阶请参考下文)
text:悬停在地图上时显示每个状态元素
z的文本:显示每个状态元素
colorbar的“商店计数”的整数值:【右侧栏标题】

colorscales:
[‘灰色’，’ YlGnBu ‘，‘绿色’，’ YlOrRd ‘，‘蓝色’，’ RdBu '，
‘红色’，‘蓝色’，‘野餐’，‘彩虹’，‘波特兰’，‘喷气机’，【T41 '，‘热’，‘黑体’，‘地球’，‘电’，‘绿色’，‘公民’]

**layout** = dict(title = 'Starbucks locations in USA Map',
              geo = dict(scope='usa')
             )

现在，我们可以使用go.Figure()方法为地图创建一个对象，然后使用iplot()方法生成绘图

choromap = go.Figure(data = [data],layout = layout)
iplot(choromap)

Interactive Choropleth map for ‘US’ country[Image by Author]

酷！我们的“美国”国家 choropleth 地图已经生成，从上面我们可以看到，当鼠标悬停在地图上的每个元素上时，每个州都会显示文本、商店数量和州名，数据越集中在一个特定区域，地图上的颜色就越深。这里的“加州”有更多的商店(2821)，所以颜色很深。

类似于 Choropleth 地图，我们有另一个很酷的交互式地图，叫做“散点图”。

**“散点图”**提供地图上的每个数据点(表示为标记点)以及由 x(经度)和 y(纬度)列表示的位置。

我们可以使用数据集中的列“经度”和“纬度”来生成散点图。

让我们使用下面的代码创建一个散点图。

**data** = go.Scattergeo(
        lon = df_US['Longitude'],
        lat = df_US['Latitude'],
        text = df_US['text'],
        mode = 'markers',
        marker = dict(symbol = 'star',size=5,colorscale = 'Reds'
                      ),
        marker_color = df_US['Store Count'],
        )
**layout** = dict(title = 'Starbucks locations in USA Map',
              geo_scope = 'usa'
             )
choromap = go.Figure(data = [data],layout = layout)
iplot(choromap)

‘Star’ markers represent store locations for each state[Image by Author]

**第四步:**绘制 ’ 世界地图

像我们之前做的那样，添加了一个新列“商店数量”。此外，我还在数据集“国家代码”中添加了一列，其中包含 ISO 3(3 位数)代码。

下面是创建 choropleth 世界地图的代码…

**data** = dict(
        type = 'choropleth',
        locations = df['CountryCode'],
        z = df['Store Count'],
        text = df['Brand'],
        colorbar = {'title' : 'Starbucks Stores - World Wide'},
      )
**layout** = dict(
    title = 'Stores Count',
    geo = dict(
            showframe = False,
            projection = {'type':'natural earth'}
    )
)
choromap = go.Figure(data = [data],layout = layout)
iplot(choromap)

Sample screenshots represent stores count in India and Australia[Image by Author]

我们的地理数据可视化部分到此结束。请查看plotly地图官方页面查看更多有趣的剧情类型。

我希望这篇文章对你有用，请在下面的评论区分享你的评论/反馈。谢谢大家！！

使用 Networkx 在 Python 中创建图表

原文：https://towardsdatascience.com/intro-to-graphs-in-python-using-networkx-cfc84d1df31f?source=collection_archive---------11-----------------------

图表和数据科学

用 Python 构建第一个图表的介绍

如果你对用 Python 做图论分析感兴趣，并且想知道从哪里开始，那么这是给你的博客。我们将首先介绍几个关键概念，然后使用方便的 Networkx 包在 Python 中实现它们。

一些图论术语

• 一个图 G ( V ， E )是由一组顶点( V )和一组边( E )定义的数据结构。
• 顶点 ( v )或节点是一个不可分割的点，由下图中的字母组件表示
• 一条边 ( vu )将顶点 v 和顶点 u 连接在一起。
• 由 n 个顶点组成的完全图是这样一个图，其中每个顶点与其他所有顶点共享一条边，因此包含最多的边。
• 任何有 n 个顶点的简单图的最大可能边集的大小等于( n *( n -1))/2。这是因为它相当于顶点对组合的数量，即。( n 选 2) = n ！/( ( n -2)！(2!)).
• 图 G ( V ， E )的顶点 s 上的一个诱导子图gg*s*是这样一个图，使得 S ⊂ V 和 G [ S 的边集合由
• 图 G 的一个团 C 是 G 的任何诱导子图，它也是一个完全图

安装软件包并创建您的第一个图表

您需要做的第一件事是在您的机器上安装 Networkx 包。使用 Pip 非常简单:

pip install networkx

安装完成后，导入包并初始化图形对象

import networkx as nxG = nx.Graph()

添加前两个节点以及它们之间的边

G.add_node(1)
G.add_node(2)
G.add_edge(1, 2)

在这一点上，我们的图只是两个相连的节点

Fig. 1 A two vertex Graph

一次添加一条边非常慢，但幸运的是，我们还可以添加节点列表和边列表，其中每条边由一个节点元组表示。

G.add_nodes_from([2,3,4,5,6])
G.add_edges_from([(1,2),(4,5),(3,5),(2,3),(5,6)])

我们的图表现在应该看起来像这样

Fig 2. Our graph now has seven vertices

访问和存储信息

通过打印图形的这些属性，我们可以看到节点或边的列表。

print(G.nodes())
>>>[0, 1, 2, 3, 4, 5, 6]
print(G.edges())
>>>[(0, 1), (1, 2), (2, 3), (3, 4), (3, 5), (5, 6)]

也可以将节点定义为字符串。

G.add_node('ib')
G.add_edge(3,'ib')

最重要的是，可以为每个节点分配任意数量的属性，然后存储在字典中。

G.nodes[1]['color'] = 'red'
G.nodes[1]['count'] = 10
print(G.nodes.data())
>>>[(0, {}), (1, {'color': 'red', 'count': 10}), (2, {}), (3, {}), (4, {}), (5, {}), (6, {}), ('ib', {})]

为了使这些数据更易于管理，将 nodes.data()的输出提供给一个 dict()函数，让它进入一个可爱的嵌套字典，其中每个节点都是一个键。

print(dict(G.nodes.data()))
{0: {}, 1: {'color': 'red', 'count': 10}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}, 'ib': {}}

最大团估计

为了找到最大团，我们需要从 networkx 导入近似包，因为它不包含在默认导入中

from networkx.algorithms import approximation as aprx

现在，为了测试最大团，我们将通过添加边(4，6)在当前图中创建一个大小为 3 的团

G.add_edge(4,6)

Fig 3. Now with 8 vertices and a clique of size 3

因此，顶点集{4，5，6}包含我们的最大团大小为 3，该顶点集正是 max_clique 函数将返回的。

print(aprx.max_clique(G))
>>>{4, 5, 6}
print(len(approximation.max_clique(G)))
>>>3

要查看该顶点集的诱导子图，我们需要将上述与子图方法结合起来

max_clique = G.subgraph(approximation.max_clique(G))

这将为我们提供以下完整的 3 顶点图。

The induced subgraph of the maximum clique

最后的想法和问题

Python 有很多图形库，但我选择了 Networkx，因为它可读性强、易于设置，尤其是因为它有出色的文档。如果您有任何进一步的问题或希望更多地探索图书馆，请参考官方文档。

来源

https://networkx.github.io/
https://en.wikipedia.org/wiki/Induced_subgraph
https://en . Wikipedia . org/wiki/Clique _(graph _ theory)

自然语言处理的非技术性介绍

原文：https://towardsdatascience.com/intro-to-nlp-using-inaugural-speeches-of-presidents-8c7ca32cbdfe?source=collection_archive---------18-----------------------

总统就职演说分析

虽然神经网络和 CNN 在计算机视觉领域取得了巨大的进步，但自然语言处理却没有得到应有的重视。它经常被忽视，因为还没有超越人类水平的表现。然而，正如我们将通过这个系列看到的，我们可以制作一些非常漂亮的工具，不仅可以帮助我们获得洞察力，还可以自动化任务。

所有提到的代码都可以在这里获得。你可能需要从 github 链接中复制一些我写的帮助函数。在这里提到它会使一切都过于集中。

首先，我们将对从第一任总统到 2009 年奥巴马的演讲做一个基本的分析。这里我们将使用三个库
1。nltk
2。pyphen——将单词分成音节。matplotlib——嗯，为了绘图
,所有这些都可以使用 pip install 安装。

你需要下载语料库。您可以通过执行下面给出的代码来做到这一点

nltk.download(‘inaugural’)
nltk.download('stopwords')

或者你可以直接执行 nltk.download() 在下载器弹出后下载语料库部分的“inaugral”和“stopwords”，如下图截屏所示。您也可以通过这种方式探索其他语料库。

how to download nltk corpus

现在我们用下面的代码导入 nltk 包和语音(这可能需要几秒钟，取决于您的计算机)

import nltk
from nltk.corpus import stopwords 
from nltk.corpus import inaugural
from nltk.tokenize import word_tokenize, sent_tokenize
import matplotlib.pyplot as plt
import pyphen

现在我们已经导入了就职演说，我们可以看看数据。我们可以看到我们有 56 位总统的数据，从华盛顿到 2009 年的奥巴马。

让我们来看看这些演讲。要获得数据的原始格式，我们可以简单地使用inaugural.raw()。但正如我们所看到的，我们不能清楚地把它分成单词。幸运的是，我们有inaugural.words()为我们做这项工作。

既然我们已经把我们的演讲分解成单词，我们可以开始对它做一些基本的分析。我们从频率分布开始。这将告诉我们一个特定的单词出现了多少次。而且已经按降序排列了。

我们遇到了一个问题，它被停用词淹没了。通常有一些单词和标点符号比其他单词和标点符号重复得更频繁，它们通常不会给我们提供更多的数据信息。nltk 已经有了一个类似的单词列表，它们被称为stopwords。它们可用于多种语言。我们在导入的停用词列表中添加了一些符号。

现在我们有了一个停用词列表，我们编写一个小代码来删除演讲中的所有停用词，并再次找出频率分布。

这更好，也给了我们一些关于数据的见解。但这只给了我们一次演讲的数据，我们需要一些东西来比较更多总统的演讲。

所以我们开始计算 xyz 总统使用了多少个 2，3，4 字母单词。然后，我们取每位总统每个词的平均字母数，并绘制出来。

“我感到快乐”——每个单词的平均字母数为 3.33 (1+4+5)/3。

“我散发出欣快感”——每个单词的平均字母数为 4.66(1+5+8)/3。

更高的每个单词的字母数意味着总统最常用“大”字。我们先数一下每位总统用了多少个 x 字母单词。

当我们这样做的时候，我们还将每个单词的平均字母数存储在一个名为presidents_avg的变量中。使用 matplotlib 来绘制它，我们可以看到它明显地随着时间/总统而减少。

沿着类似的路径，我们开始计算 xyz 总统在一个句子中说了多少个单词。然后我们取每位总统每句话的平均字数，并绘制出来。

每句话的平均字数更高意味着总统最常用“大”句子。我们还将每句话的平均字数存储在一个名为presidents_avg_words_per_sentence的变量中。使用 matplotlib 来绘制它，我们可以看到它明显地随着时间/总统而减少。

现在让我们看看单体型分析是否能给我们带来什么。在语料库语言学中，hapax legomenon 是一个在语境/言语中只出现一次的词。words.hapaxes()给出了给定语料库中所有独特的单词。

但是计算独特单词的数量是不够的。我们还需要用它除以整个演讲的长度。为什么？因为演讲的长度变化很大，所以一个更大的演讲可能有更多独特的单词，我们需要消除这种偏见。因此，我们在一篇演讲中找到独特的词，统计它们，平均它们，并为每位总统绘制它们。

似乎在减少一点，虽然不是很明显。

在最后的分析中，我们计算每位总统在演讲中使用的每个单词的音节，我们使用 pyphen 库，因为像“Afghasnistan”这样的名词通常没有预定义的音节数。

然后我们取每位总统每个词的平均音节数，并绘制出来。

当我们看到图表时，我们看到它随着时间的推移而减少。

所以相比较而言，现在的总统比以前的总统使用更少的单词和更短的句子。
这可能是由多种原因造成的，英语本身在 200 年的时间里发展了很多，但也可能是因为媒体的进步。随着总统的演讲开始被普通人所接受，他们自然喜欢较短的句子和较小的单词，总统的演讲开始根据新的听众而改变。他们不是为了给华盛顿少数受过教育的人留下深刻印象，而是为了从普通人那里获得选票。

优化简介

原文：https://towardsdatascience.com/intro-to-optimization-f27ec87fbef1?source=collection_archive---------29-----------------------

许多人工智能技术都是关于将数据转换成对我们更有用的形式，获取自由形式的文本、图像和音频等非结构化数据，并从中提取意义。虽然这种新的转换数据(我们在图像中识别的对象，我们在自由文本中识别的意图和实体，我们在音频中识别的单词)比它所来自的非结构化数据更有用，但我们没有对它做任何有意义的事情。

优化的核心是解决问题和计划。使用由像自然语言处理或对象识别这样的技术提供的结构化数据作为上下文，它可以确定实现目标的最有效方式。这个目标可以是任何事情，从在棋盘游戏或电脑游戏中最大化得分，到成功谈判一笔交易，再到优化供应链。与之前讨论的技术不同，优化使用另一种称为强化学习的方法，这些技术要么依赖于为算法提供预先标记的数据(监督学习)，要么提供数据并要求它对数据进行分类(非监督学习)。

最简单的形式，优化看起来就像反复试错。该算法对其行为进行小的改变，并观察这是否使其更接近其目标。如果有，它会继续对相同的行为进行更改。如果没有，它会尝试其他方法。强化学习使优化算法能够记住其先前的动作以及它们对其目标的影响。这使它能够开始发展战术，导致更高的分数。

让我们以学习玩超级马里奥兄弟的优化算法为例。在这个游戏中，对于那些自 1983 年以来生活在岩石下的人来说，玩家控制马里奥或路易吉从一个平台跳到另一个平台，通过关卡向右(定向)移动。有些敌人要么可以通过跳过它们来躲避，要么可以通过跳到它们身上来打败它们。如果你想训练一个优化算法来打败这个游戏，你不能简单地把它的目标定为“打败超级马里奥”，然后一直等到它这样做。这将花费很长时间，当它最终通过随机机会击败游戏时，算法不会学到任何东西。这是因为需要给算法设定短期目标，以激励它朝着正确的方向前进。虽然你和我本能地知道向右移动并避开敌人，但这是机器必须学会的。击败超级马里奥兄弟这个大问题必须被分解成小得多的问题。而不是打败游戏的最终目标，你必须给它一个会导致游戏被打败的目标:最大化它的分数。然后你建立一个积分系统，当算法向右移动，跳到更高的平台上，杀死敌人时，它会得到积分。该点系统将通过物体识别来启用。通过反复试验(经过数千次或数百万次尝试)，该算法将制定策略，使其能够向右移动，跳到更高的平台上，并杀死敌人。最大化这些目标将最终导致它击败游戏。

但是，如果我们谈论的是像国际象棋、围棋或 DOTA 2 这样的对抗性游戏(与对手进行的游戏)呢？一个人不可能玩一百万次游戏来对抗一个算法来训练它。首先，这将花费太长时间(而且对人类参与者来说太无聊了)。第二，机器只会比它所面对的人类对手略胜一筹。这就是生成性对抗网络(GANs)的用武之地。该算法不是面对人类对手，而是成千上万次地扮演一个略有不同的版本。每次游戏结束后，双方都将从两种算法中学习到的知识整合到一起，然后开始新的游戏。gan 使这些算法能够更快地获得经验，因为他们可以以更快的速度玩这些游戏。它们还使优化算法能够超越人类的技能水平，因为它们不会将自己与人类进行比较。这就是 DeepMind 如何训练他们的 AlphaGo 算法在围棋上击败世界上最好的人类选手。

所以，我们完了！如果你激励一个优化算法来最大化它的分数，它最终会发展出足够的技能来击败最好的人类玩家，对吗？不完全是。优化方法倾向于关注短期的最大化。在短期收益最终会带来长期成功的情况下(比如《超级马里奥兄弟》)，这种方法非常有效。在更复杂的情况下，就像我们在《星际争霸》和《DOTA 2》等视频游戏中看到的那样，短期牺牲可以带来长期成功。这是人工智能在复杂多变的环境中难以击败人类玩家团队的部分原因，这些游戏需要不容易模拟的战略思维。

研究人员通过结合不同的系统来解决这一弱点，试图平衡短期和长期战略。一种算法将试图确定下一步最佳行动，而另一种算法将着眼于整个游戏可能如何结束。这两种算法结合在一起，就能找出通往胜利的最佳路径。一个名为 Libratus 的系统使用了类似的方法，该系统能够击败经验丰富的扑克玩家。它的一种算法使用强化学习来自学游戏，然后确定最佳的下一步行动。第二个关注游戏的最终结果。第三种算法将识别 Libratus 之前下注的模式，并引入随机性来摆脱其他玩家。

视频游戏、棋盘游戏和纸牌游戏——这些与优化如何帮助您运营业务有什么关系？我们在谈论优化时谈论游戏的原因是，研究人员将这些游戏用作测试，以了解他们的算法工作得有多好。就像我们给优化算法的短期目标是击败超级马里奥兄弟一样，击败电脑游戏是一个短期目标，旨在构建可以处理现实世界的健壮优化算法。最终目标不是设计一个可以打败计算机游戏的系统，而是训练可以在充满不确定性的复杂多变环境中工作的算法。

优化可以应用于现实世界中有明确目标要实现的情况。脸书已经使用优化技术训练聊天机器人像人类一样谈判简单的商品。优化也被用来优化供应链，设计轮班，并提出建议。如果一个大的决策可以被分解成更小的决策，这些决策可以使用试错法进行优化，那么就可以使用优化来确定最有效的行动方案。

原载于 2019 年 4 月 10 日【https://www.foundationai.com】。

使用 Python 读写电子表格简介

原文：https://towardsdatascience.com/intro-to-reading-and-writing-spreadsheets-with-python-b635ae514ab8?source=collection_archive---------5-----------------------

这个帖子是给谁的？

初学者和 Mac 用户(Windows 用户需要先安装和设置 Python)

你需要什么？

任何 Mac，一个文本编辑器(我推荐 Atom )和持久性

你能从中得到什么？

您将学习如何使用 Python 读取、转换和输出电子表格。对于转型，我们将着眼于获得在某个日期之前与我们交谈过的客户。

我到底是谁？

我是爱电子表格的创始人。我们的目标是在 Excel 用户和程序员之间架起一座桥梁。

I .验证和安装库

首先，我们将检查是否安装了 Python，并安装另一个将帮助我们处理电子表格的库。

库是一个代码集合，它以一种更简单的方式实现了(通常)难以实现的事情。

1. 我们需要首先打开终端，让我们与系统进行交互。在 Mac 上进入搜索，找到并打开终端

Search and Open the Terminal Application

2.打开你的终端，输入 python 然后按回车

$ python

注意:美元符号指定了终端行的开始，在开始处可能会有很多不同的文本 。

您应该会看到一个控制台，其中 Python 版本正在运行。我运行的是 Python 2.7，但是本教程和代码将会运行到 Python 3.7。如果你遇到任何问题，让我知道。

Type in python and click enter to see the console

如果这里有一个错误，那么谷歌这个错误，看看你需要做些什么来修复它。

3.如果 python 显示正确，首先我们需要按退出 python

Ctrl + d

这将把我们带回到带有＄的命令终端

现在我们将安装这个库，它将帮助我们阅读和处理电子表格。它叫做 pandas ，我们将用下面的命令安装它。键入以下内容并按下键进入:

$ pip install pandas

我们还将安装另外两个库 xlrd、openpyxl 来帮助 Excel 读写。您不会处理这些库，但它们需要安装。

$ pip install xlrd openpyxl

4.如果成功安装了 pandas 库，您将看到一串文本，最后一行声明安装成功。如果您在这里遇到错误，您需要在继续之前修复它。

There will be a bunch of text and it will not match mine but as long as the Successfully installed statement appears with no errors, you are good

同样，如果成功安装了 xlrd 和 openpyxl 库，您将会得到与 pandas 类似的“成功安装”消息

二。组织文件

现在，我们将保存示例电子表格并创建一个 Python 文件，我们将在其中编写代码。

5.我创建了一个名为 CustomerSample.xlsx. 的样本数据文件，你可以点击这里下载。

该文件有两页:客户和*潜在客户。*该文件有 8 列虚拟数据。

6.现在我们将创建一个 Python 代码文件。打开 *Atom 或任何文本编辑器。*现在不用写任何东西，保存为 excel.py 。

7.有几件非常重要的事情需要记住:

I .customer sample . xlsx和 Excel.py 文件都应该放在桌面上同一个名为python spreadsheettutorial的文件夹中，这里的所有代码才能工作

These aren’t rules but if you are new it’s easier to follow my naming first before branching out

二。文件和文件夹的名称应该是上面的名称，这样代码才能工作

三。读取 Excel 文件

如果你已经做到了这一步，恭喜你！大多数人在设置好环境，准备好一切的时候就放弃了。

现在我们终于可以开始有趣的部分了。最后的代码只有 4 行，如下所示。我们将在邮件中分解它

The full excel.py file

8.打开您创建的 excel.py 文件，准备编写一些代码

读取文件的整个代码只有 2 行

import pandas as pdcustomer_sample_file = pd.read_excel("CustomerSample.xlsx", sheet_name="Prospects", parse_dates=[0])

9.第一行告诉 python 我们将在代码中使用熊猫库，我们将把它命名为 pd

10.第二行是我们如何阅读熊猫的电子表格。我们创建一个变量customer _ sample _ file***并存储调用函数PD . read _excel*的结果(从 Pandas 库中读取 _ excel)

11. pd.read_excel 函数接受 1 个强制参数，电子表格的名称和位置(这就是为什么命名和位置正确很重要，但是如果您决定更改它，您需要在这里将其更改为完整路径)。

我们提供了另外两个可选参数， sheet_name 和 parse_dates 。 sheet_name 告诉函数要读取哪个工作表，而 parse_dates 获取应该作为日期读取的列的列表。0 指定第一列，依此类推。

这个函数有很多你可以指定的参数。我鼓励你在这里阅读它们。

您可以试验不同的参数，看看它们能做什么。

12.变量 customer_sample_file 现在包含了数据框中电子表格的所有行和列，因为我们的第一行是列名，所以它们成为了这个数据框的列名。

如果您打印出 customer_sample_file ，那么您会看到它包含以下内容

THIS IS NOT PART OF THE CODE. I PRINTED THIS SEPARATELY

四。转换文件

对于我们的转换，我们将只获取 2017 年或更早时间记录的记录。

这部分的代码是 1 行。

**customers_2017_or_earlier = customer_sample_file[customer_sample_file["DateTime Recorded"] < "2018-01-01"]**

13.我们创建了另一个变量customers _ 2017 _ or _ earlier**，并将其分配给在 2018 年 1 月 1 日之前记录的客户。**

14.这分两步完成，内部代码

**customer_sample_file["DateTime Recorded"] < "2018-01-01"**

当记录的日期时间的列值小于2018 年 1 月 1 日时，为每个记录分配 True 或 False 值，然后是代码的外部部分

**customer_sample_file[customer_sample_file["DateTime Recorded"] < "2018-01-01"]**

从数据框中选择那些记录

动词 （verb 的缩写）输出记录

太好了，现在我们有了以前的记录，我们可以将它们输出到他们自己的小 Excel 文件中。

这个代码也只有一行

**customers_2017_or_earlier.to_excel("Customers2017OrEarlier.xlsx")**

15.我们采用变量customers _ 2017 _ or _ earlier并运行函数来 _excel 。这个函数接受一个参数，它是您想要创建的新文件的名称

16.既然文件已经完成，我们需要运行脚本。为此，我们需要打开终端、并导航到保存 excel.py 文件的文件夹，即桌面上的python spreadsheettutorial。

在我的终端中运行以下命令，然后按键进入****

**$ cd ~/Desktop/PythonSpreadsheetTutorial**

如果您将 excel.py 文件保存在不同的文件夹中，那么您需要指定路径。波浪线表示您位于用户的主目录中，然后构建脚本文件夹的剩余路径。如果它工作正常，那么您将会在$符号变成文件夹名称之前看到名称

There should be a clear change when you have entered the correct folder

17.现在是最后命令的时候了。在我们的文件夹中，从终端运行以下命令并按下回车。****

**$ python excel.py**

Press Enter to run the script and that’s it

如果没有错误，那么什么也不会发生，您应该会看到一个新文件出现在您的文件夹中，其中包含 2017 年或之前的所有记录！

我希望这有所帮助，如果你有任何问题，请在评论中告诉我！

使用强化学习打乒乓球

原文：https://towardsdatascience.com/intro-to-reinforcement-learning-pong-92a94aa0f84d?source=collection_archive---------5-----------------------

对强化学习关键原则的简明介绍

Home version of the Atari Pong console, released in 1975, by Sears Tele-Games [Source: youtube.com]

这篇文章的目的是通过训练一个代理玩游戏 Pong 的例子来介绍强化学习的一些关键原则。它呼应了很多资源，但我以一种对我来说直观的方式来写它——希望它对其他人也有一些用处。

注意:关于神经网络和机器学习的一些知识是假定的，但是不要因此而影响你阅读这篇文章。

简要背景

2013 年，DeepMind 的研究员 Volodymyr Minh 与 deep mind 的同事发表了一篇论文，引起了新闻界和机器学习界的关注。在论文中，他们开发了一个系统，该系统使用深度强化学习(深度 RL)来玩各种雅达利游戏，包括 Breakout 和 Pong。该系统纯粹从视频游戏显示器的图像/帧的像素作为其输入来训练，而不必显式地编程任何规则或游戏知识。更引人注目的是，论文中详细描述的系统在多个 Atari 游戏中使用(几乎)相同的架构击败了人类的表现，并且基于相对简单的概念，这些概念已经分别在强化学习(RL)和机器学习(ML)领域中被了解和研究了几十年。

A short snippet of a game that was the output of a Neural Network I trained — the green paddle is controlled by RafAI Nadal.

这一发现是第一个被证明可以推广到多个游戏的方法之一。自 2013 年最初的论文以来，其他几个研究小组已经在雅达利设置和其他几个场景中建立并超过了这些结果，例如 p 奠定 DOTA 或创建一个通用算法，可以通过自我游戏掌握多种游戏，如国际象棋&围棋。

怎样才能程序化的打败 Pong？

如果我们试图在没有任何正式方法的情况下编写代码来击败 Pong，我们可以尝试并捕获所有可能的动作，并查看哪些动作最终导致了游戏的胜利。

为了手动地做到这一点，我们可以根据两个玩家的球和桨的位置，为给定的输入帧选择最佳动作，并在每个场景中提出建议的动作，例如，在场景 A 中，如果 AI 桨在屏幕的顶部，球的轨迹朝向底部，则 AI 应该向下移动。

让我们回顾一下我们在这里处理的数字:模拟 Pong 的 Atari 仿真器输出一个 210 x160 RGB 显示，这是 100，800 像素。这些像素中有许多对于代理理解如何玩 Pong 是不相关的——在技巧部分中有更多的相关内容，所以我们可以丢弃它们，但是即使我们减少了 50%的输入像素，我们仍然有大量的像素。

手动计算出一个给定状态的正确动作是非常痛苦的。此外，如果我们编写一些试探法来分组屏幕的各种场景，例如在场景 A 中，并为给定的场景编写一个动作，这将意味着我们最终会编写非常 Pong /游戏特定的代码，这不是我们想要的。

我们如何才能避免手动编写推荐操作的代码？最天真的解决方案是，首先对输入采取随机动作，看看哪些动作有效，并在如下所示的地图中存储给定输入图像中哪些动作效果好(即，导致游戏获胜):

这允许我们估计场景的概率，并通过选择具有最高概率的动作来选择更好的动作。

例如，在 Pong 游戏中，如果我们想要比较给定图像的向上和向下动作，我们会看到下面的分数是否超过 0.5，并且在这种情况下选择向上动作:

For Pong, assuming we only have UP & DOWN actions, we only need to store counts for either UP or DOWN to get the correct fraction

如果概率是 0.5，我们可以抛硬币选择一个随机动作。

通过大量的游戏和平均，这将很好地工作，因为我们对给定图像的哪些动作有效的经验有助于通知代理(基本上是 AI)一个比完全随机的动作更好的动作。上面描述的自动化方法可以更正式地描述为强化学习，，因为我们有一个代理，它正在对其环境执行动作，观察结果，收集奖励，并使用收集的奖励知识来修改任何未来的动作，以便表现得更好。

尽管上述方法存在一些低效之处:

1. 奖励的稀疏性使得这种方法相当无效，因为在游戏过程中可能有多个动作和过渡，但是在 Pong 的情况下，比如说 10 个来回的回合只有一个奖励，每个回合包含大约 10 个动作/移动，所以大约每 100 个动作有一个奖励。其他游戏可能比 Pong 少得多，其中一个动作现在影响游戏进行几分钟，也许几小时后。这使得给一个特定的行为分配信用变得相当具有挑战性。
2. 你可能知道在 Pong 中有一类行动，其中代理人只是保持反弹，而另一类行动可能会赢得比赛，包括在赢得比赛之前的行动。
3. 对于我们以前没有见过的图像，它不会工作得很好，因为它不能处理看起来相似的图像。这意味着我们必须运行更多的迭代，以允许 AI 探索整个状态空间和/或直到我们开始得到好的结果。

天真地将一场胜利游戏中的每一个动作都贴上好的标签是危险的，可能会导致混乱的结果，并且可能需要很长时间才能击败对手。稍后我将谈到我们如何解决这个问题，但首先请阅读 RL 的更正式定义。

什么是强化学习？

RL 的主要前提是通过在多个周期内在环境中尝试各种允许的动作，观察那些动作的结果，并使用经验来通知未来的动作，来为 AI(在该领域中被称为代理)建立经验历史。这是一个反复试验的过程，适合于完全自主运行的代理，不依赖于人的输入。对于一个学习有效玩 Atari Pong 游戏的 AI 代理来说，它需要玩多轮游戏，观察给定输入*图像的哪些动作效果最好，然后修改其行为以增加对输入效果好的动作的频率，反之亦然。

*暂且不提对强化学习感兴趣的术语

注意，输入对应于我们的 Pong 示例的状态。 状态 是代理认为它对允许它做出决策的环境的了解的表示。

代理的环境可以是或 部分可观察的 :在 Pong 的情况下，环境是完全可观察的，假定整个游戏区域是可见的，并且可以完全被输入图像所占据。完全可观察的环境，其中输入映射到状态的情况很少发生，例如在现实生活场景中，机器人使用相机在户外导航其环境，它部分观察其环境并基于其观察结果计算状态，这可能是存储障碍物及其感兴趣特征的某种地图。在这种情况下，摄像机输入并不映射到整个状态，而是只贡献其中的一小部分。

A simple diagram showing the way in which an Agent interacts with its environment [Source — OpenAI Spinning up]

RL 使用奖励的想法来决定执行哪些动作，对于 Pong 游戏，代理人每赢一轮，奖励就是+1，而对手 CPU 每赢一轮，奖励就是-1。对于其他游戏，如太空入侵者，奖励可以与击落不同类型的外星人获得的分数增量挂钩，但在现实生活中，计算奖励可能会更棘手，尤其是在没有明显的单一分数或目标需要优化的情况下。

在 RL 领域中，策略是规则、策略或行为功能，它评估并推荐给定特定状态的下一个动作；实际上，它可以被认为是从国家到行动的地图。一个策略在本质上可能是确定性的或随机的，由于一个 RL 代理的最终目标是最大化它的回报，我们希望选择一个策略来最大化给定行为的未来预期回报。Pong 情况下的策略帮助代理选择一个可能的动作，即向上、向下移动球拍或什么也不做。

Markov Decision Process diagram [Source — Wikipedia] . Green Circles represent states, red nodes represent actions, decimals represents probabilities of given actions, lines represent transitions between states. The expected reward for a transition is represented by the number at the end of the yellow wiggly line

RL 基于称为马尔可夫决策过程 (MDPs)的模型，这些模型是包含与环境中的可能状态相对应的不同节点的状态图，以及与代理可能采取的行动、其概率和预期回报相对应的状态之间的链接/边。Pong 也可以建模为 MDP，其中桨&球的每个配置都是一个状态，每个状态都有两个可能的状态转换箭头，每个转换都有一个奖励 0，除了最终的终端状态，奖励可能是+1 或-1。将问题公式化为 MDP 允许我们受益于马尔可夫属性，该属性陈述:

“鉴于现在，未来独立于过去.”

MDPs 的主要优点是，当前状态可以完全描述问题的特征，并允许代理独立于历史做出最优决策，因为历史可以编码在当前状态中。

*暂且不提对强化学习感兴趣的术语

值函数 是一种评估给定状态或状态-动作对有多好的方法，可用于选择试图将代理转换到未来状态的动作。有多种类型的价值函数，它们对将用于计算价值的政策做出不同的假设。要获得大量资源，请查看 OpenAI 对值函数类型的解释 。

在 基于模型的 学习中，模型编码了一种对世界的理解，这种理解是由一个代理探索其环境而获得的，并且这种对世界的理解被用于在执行任何动作之前提前计划和计算对未来状态的期望。基于模型的代理的缺点是选择一个动作会导致较高的计算成本，但是可能更适合于具有大量状态的环境，其中评估所有状态是不可能的，例如在国际象棋游戏中。

在 无模型 学习中，一个智能体利用没有关于世界的先验知识，例如物理定律，关于如何玩其他游戏的知识，来采取一个行动。在这篇文章中，我们使用了一个无模型代理，因为神经网络被用来直接选择未来的行动，而政策并没有直接给我们任何关于世界未来状态的预测。

稍后我们将使用一个非常简单的优势函数，它是一个标量。

在一场胜利的游戏中，除了给每个动作平均分配奖励，我们还能做得更好吗？

前面描述的随机方法结合存储获胜动作的计数可以被描述为一种策略，一种糟糕的策略，但仍然是某种策略。

我们可以做得更好的方法之一是通过奖励折扣更明智地分配行为奖励。在代理人收到奖励之前的最近动作或帧是最相关的，因此在正面奖励的情况下应该鼓励，在负面奖励的情况下不鼓励。从收到奖励时起，时间上更早的任何行为或帧都被归因于指数因子贴现因子γ(γ)的较少功劳，在本文稍后编码的示例中将其初始化为 0.99:

*1\. def discount_rewards(rewards):2\.    discounted_r = np.zeros_like(rewards)3\.    sum_of_rewards = 04\.    for t in reversed(xrange(0, rewards.size)):5\.        if rewards[t] != 0: running_add = 06\.        sum_of_rewards = sum_of_rewards * gamma + rewards[t]7\.        discounted_rewards[t] = sum_of_rewards8\.    return discounted_rewards*

这段代码是在一集的基础上运行的(一集是一系列回合，直到一个玩家达到 21 岁)，但实际上我们只对一个回合应用折扣，因为上面第 5 行的sum_of_rewards变量在奖励不为零时被重置，这是在每个“回合”结束时。

The effect of discounting rewards — the -1 reward is received by the agent because it lost the game is applied to actions later in time to a greater extent [Source — Deep Reinforcement Bootcamp Lecture 4B Slides]

折扣的效果是更准确地将奖励归因于可能对奖励有重要贡献的行为，因此帮助我们更接近我们想要的地方。

Pong 有一个非常简单的奖励设置，因为只有赢得游戏的奖励，但在更复杂的问题中，折扣函数可以用作 RL 问题中值函数的一部分，以根据预期的未来奖励来评估状态:

Finite-horizon reward discounting function, γ is the discounting factor, n is the number of timesteps, r is the magnitude of the reward for a given timestamp t + n, and H is the horizon for which we count the rewards. H may be infinity if we wish to account for actions an infinite amount of time away, which in practice is difficult.

更好的架构是什么样子的？我们实际上是如何编码的呢？

正如前面所观察到的，手动尝试捕获程序的状态是很棘手的-来自 DeepMind 论文的关键见解是使用神经网络作为一种手段来近似策略函数，而不必为每个输入图像状态显式编码。

Architecture of the Neural Network used in the code example later in this post [Source — Andrej Karpathy, Pong from Pixels blog post]

策略函数，或称策略网络，用于根据 Pong 和许多 Atari 游戏的输入来决定下一步做什么，是一个具有 n 个隐藏层的全连接神经网络，这就是为什么这种方法被称为 Deep RL，尽管在本文中我们只有一个隐藏层。神经网络将游戏的一帧图像作为输入，其中每个像素对应于一个单独的输入神经元，并输出一个介于 0 和 1 之间的小数概率，该概率对应于我们的代理过去对类似图像采取的行动是向上移动的概率。请注意，如果概率低于 0.5，并且越接近 0，代理采取向下移动的动作的概率越高。由于该策略输出一个概率，因此该策略是随机的。

对于隐藏层代表什么的直觉，它可以被认为对应于各种游戏场景，例如，一个可能的场景是球向上移动，代理桨在底部。在下面的链接代码中，我们在隐藏层中有 200 个单元，这比 6400 个输入神经元减少了很多(参见技巧预处理部分了解我们如何从 100000 像素增加到 6400 像素)。

隐藏层中的单元数量是系统的超参数，对于我们的系统，我们有 200 个单元。这个数字是我们需要多少表示的粗略猜测，但在实践中，我们将使用自动方法来确定隐藏层的数量和大小。

隐藏层的输出被映射到一个 sigmoid 函数，它有效地将输出压缩到 0 & 1 之间的概率范围内。

然后，我们使用这个神经网络输出和一个锁定的随机数生成器来生成一个介于 0 和 1 之间的浮点数，以确定下一步是上涨还是下跌。

*action = 'DOWN' if np.random.uniform() < action_prob else 'UP'*

Playing pong before much training, the green paddle, RafAI Nadal, is struggling to keep up since it is initially performing completely random actions

随机数生成器的目标是引入对新状态的探索，这在早期神经网络无法真正区分好的行为和坏的行为时至关重要，因为神经网络权重是随机初始化的，并且由于 sigmoid 函数的形状，任何给定输入图像的概率输出都接近 0.5。这导致我们的代理人随机采取一系列行动，起初没有协调感…附带说明:根据随机因素调整的计算行动概率选择行动的过程也称为采样。

随着神经网络越来越多地被训练，并且假设政策平均回报增加，随机性因素起着较小的作用，因为随着时间的推移，应该采取某个行动的概率更接近于 0 或 1 的极端值，并且action_prob决定结果。有助于代理探索状态空间的另一个因素是随机策略的使用——如果策略是确定性的，我们将只依赖随机数生成器进行探索，这最初是好的，但是这将意味着任何新的动作都是完全随机的，并且较少受 NN 捕获的先验概率的驱动。由于代理停止探索状态空间，探索的减少和对已知良好动作的更大利用也会使策略陷入局部最优。

神经网络方法的另一个好处是，如果前面描述的映射实际上没有遇到输入图像，这对神经网络来说不是问题，因为大部分像素可能与神经网络已经看到和训练的图像相似，所以神经网络可能输出与先前看到的图像相似的预测。同样，我们可以手动进行这种相似性比较，但这需要更多的工作，而且神经网络是免费的。

但是当&强化学习中的神经网络是如何得到训练的呢？

强化学习(RL)使用尝试各种动作的多个周期来教会自主代理如何在环境中执行任务。

在一个情节 *** 中，在多个回合 *** 中尝试了一系列动作之后，我们通过使用该情节中发生的所有动作来训练NN。

Pong 中回合 对应其中一方玩家获得分数&奖励 1 并赢得一场拉力赛，输的玩家获得分数 0 和奖励-1。*

在 Pong 比赛中，安 第一集 一直进行到其中一名选手得分达到 21 分。剧集是一个术语，在所有 OpenAI 健身房环境 中使用，包含一个严格定义的任务。*

要更深入地了解神经网络是如何训练的，请继续阅读…

在监督学习中，我们通常有代表样本输入的基本事实的标签，这有助于我们计算损失(预测和实际标签之间的差异)，进而有助于我们使用反向传播和优化算法调整神经网络的权重。

**

Supervised learning has a lot in common with Policy Gradients [Source — Andrej Karpathy’s blog]. The diagram on the left shows the supervised learning case: an image of Pong in which the agent’s best action is DOWN, and there is a label corresponding to the DOWN action, therefore the gradient that encourages the DOWN label for the input image is encouraged. The diagram on the right shows the Policy Gradient case: an image of Pong in which the action ‘sampled’ was UP, however given the game in which the action took place led to an eventual reward of -1 (due to a loss), a negative gradient is used to discourage the UP action for the given image.

在 RL 中，没有标签，也没有地面真相，所以我们改为使用假标签*，它对应于一轮结束时收到的奖励，以便计算损失和梯度。如同常规的监督学习一样，损耗和梯度向量被用于使用反向传播和优化算法来更新 NN 权重，该算法被用于鼓励导致正奖励的行为(通过增加其输出概率)，反之则为负奖励。假标签由我们之前计算的贴现优势因子 A *i、决定，其大小取决于我们对该行为的奖励贴现多少。让我们看一个例子:

The loss function for the Neural Network that implements the Policy Gradient. y is the action we happened to sample given the image x, and A is a number that we call an advantage, which is a number from between -1 & 1 for our Pong example*.** Maximize this function for when an action has a positive reward, minimize when action has a negative reward*

如果我们的策略采样的动作是向上，但是发生该动作的一轮导致最终奖励-1，因为它是一个失败的一轮，负梯度用于阻止给定图像的向上动作-参见上图右侧的直观解释。

请注意，我们只能在 Pong 的一轮比赛结束后更新 NN 的权重，因为当我们知道这一轮比赛的结果时，我们只能得出优势因子*/假标签。*

这种技术被称为策略梯度，因为我们使用梯度向量来更新 NN 权重，以改进 RL 问题中用于选择动作的策略。当通过足够的迭代训练时，策略梯度是一种非常有效的方法，它可以让我们训练出一个平均可以击败 Pong CPU 玩家的代理。

提高我们代理绩效的其他“技巧”

我们可以做一些小技巧来帮助我们减少计算时间，在给定的“挂钟时间”内运行更多的剧集，并总体上提高性能。

图像预处理

• 图像裁剪 —正如你从 Pong 截图中看到的，有许多冗余区域对我们的算法没有任何价值，例如分数部分，以及分数下方的白色条。这有一个额外的好处，允许我们忽略比赛结果已经决定的部分，即在球已经过了挡板之后。

Diagram illustrating the case for ignoring / cropping the image section after the ball passes the paddle [Source — Deep RL Bootcamp Lecture]

• 灰度 —像素的颜色是不相关的，因此我们可以移除它们，无论是背景色还是桨色。球拍和球可以是相同的颜色，但应该是与背景不同的颜色。
• 下采样/降低分辨率 —让我们更少关心图像，并降低内存和计算要求。

Pong image after cropping, downsampling cropping

所有这些预处理步骤允许我们将超过 100，000 像素的图像转换为 6400 像素(80px * 80px 图像)，如右图所示。

数值方法

• 获取一帧和另一帧之间的差异，而不是仅仅向神经网络提供图像——这允许我们捕捉图像中的运动
• RMS Prop 优化算法用于更新神经网络中的权重——每 10 集我们进行一次参数更新，以确保神经网络梯度得到调整，从而尝试更快地收敛
• 在将奖励传递给反向传播算法之前，将奖励标准化(减去平均值，除以标准偏差)。

编写代理程序

库& GitHub 库

代码使用了 python 和 numpy ，但没有深度学习库——正向&反向传播步骤是手工完成的。此外, OpenAI gym environment 用于加载 Atari Pong 仿真器并接收输入，这允许我们的代理采取行动。健身房环境也将奖励从环境反馈给我们的代理——因此我们不需要手动解析游戏图像中的分数。

更多细节可在 GitHub Repo 中找到:

* [## omkarv/像素乒乓

训练神经网络从像素播放 Pong-omkarv/Pong-from-pixels

github.com](https://github.com/omkarv/pong-from-pixels)

这个回购是基于安德烈·卡帕西的出色报道和要点。我添加了解释性的行内注释，录制视频功能，修复了一个小问题，所以我现在比基本报告裁剪更多的图像宽度，原因如上所述。

我修改了学习率，使其比源 repo 收敛得更快，并实现了一个提高性能的修复。

超参数值也可以在上面的报告中找到，但被设置为源报告的默认值，除了 RMSProp 的学习率被设置为 1e-03，而不是 1e-04，因为它的训练速度比 1e-03 快 3-4 倍。

接受过 GitHub 回购培训的代理的表现

Average reward per episode for the agent

玩这个游戏的代理在大约 13 个小时的时间里接受了 10000 集的训练，使用的是 2.6GHz i7 (6 核)的 MacBook Pro 2018。

在后面的 100 集里，在我停止训练的那一点，每集的运行平均分数是 2.5，也就是说，训练的 AI 智能体将赢得每集 21 分，达到 18.5 分。这篇博文的目标已经达到，所以我们现在可以停止了，但是如果你想知道进一步的训练是否会产生更好的表现…

在暂停训练脚本后再训练 5000 集，在大约 10 小时的时间内，每集的运行平均分数达到 5，即被训练的 AI 智能体将赢得每集 21 分对 16 分。随着剧集数量的增加，回报明显减少且更加嘈杂。噪音可以通过降低学习速度来减少，但代价是训练时间。

我还运行了没有上述 bugfix 的基本代码，并获得了更差的性能——花了 12000 集才达到每集-5 的尾随平均分数。性能上的差异有多少可以用 bugfix 或用于发现新状态的随机性来解释，这并不明显，只能通过两种解决方案的重复迭代来测试，不幸的是我没有时间进行测试。

感谢阅读！

参考资料/灵感

• 动词 （verb 的缩写）Mnih，K. Kavukcuoglu，D. Silver 等人，用深度强化学习玩雅达利(2013) ，NIPS 深度学习研讨会 2013
• 安德烈·卡帕西，学习玩像素乒乓
• 深度 RL 训练营视频
• 开放 AI 在 RL 中加速旋转
• 大卫·西尔弗深度 RL 系列讲座*

用 R 语言中的 OpenBUGS 求解基本贝叶斯网络简介

原文：https://towardsdatascience.com/intro-to-solving-basic-bayesian-networks-with-openbugs-in-r-51def271f3ed?source=collection_archive---------31-----------------------

贝叶斯网络是一种概率图形模型，它通过有向无环图表示一组变量及其条件依赖关系。“定向的”意味着连接图的节点的箭头是定向的(即具有方向)，因此条件依赖具有单向方向。“无环”是指不可能通过网络循环。它只能上升或下降。

让我们从一个例子开始:

曼彻斯特联队正在参加英格兰超级联赛。在俱乐部历史上最成功的教练弗格森爵士退休后，他们一直在努力保持他们作为世界上最大的俱乐部之一的形象。去年，他们在联赛中只获得了第 6 名。因此，在 2019/20 赛季开始时，球迷们认为俱乐部将以 0.2 的概率排名联盟前 3，以 0.3 的概率排名第 4，以 0.5 的概率排名前 4。

这些可能性只有在俱乐部的关键球员马库斯·拉什福德整个赛季都没有严重受伤的情况下才成立。他受重伤的概率是 0.2。如果发生这种情况，上述季末头寸的概率分别为 0.1、0.2 和 0.7。

如果他们以前 3 名结束，他们将获得明年冠军联赛小组赛的资格。如果他们获得第四名，他们将不得不通过冠军联赛资格赛，因此他们进入冠军联赛小组赛的概率降低到 0.7。

曼联也在参加欧洲联赛，欧洲冠军联赛的第二梯队。作为前冠军，如果拉什福德身体健康，他们有 0.6 的概率再次赢得欧联杯。如果拉什福德受伤，概率降低到 0.4。如果他们赢得欧联杯，那么他们即使进不了前 3，也保证以 0.99 的概率在明年的欧冠小组赛中占有一席之地，除非欧足联改变明年的规则。

如果俱乐部获得了明年冠军联赛小组赛的资格，他们将有 0.7 的机会签下他们的首要转会目标之一，来自里斯本竞技的布鲁诺·费尔南德斯。如果没有，签下费尔南德斯的几率降低到 0.4。

2020/2021 赛季初，布鲁诺·费尔南德斯是曼联球员。

-拉什福德受伤的概率有多大？

-俱乐部获得欧冠资格的概率有多大？

-俱乐部进入前 3 名的概率有多大？

-俱乐部获得第四名的概率有多大？

-俱乐部赢得欧联杯的概率有多大？

当涉及的变量和依赖项的数量很小时，这种类型的一些问题可以直接使用贝叶斯定理公式来解析求解。然而，对于像上面的例子这样的问题，使用贝叶斯分析的软件应用程序来找到有问题的概率要容易得多。

这里，我们将使用 R 中的库“R2OpenBUGS”来求解这些概率。该库基于 OpenBUGS 软件，用于使用马尔可夫链蒙特卡罗(MCMC )方法对复杂统计模型进行贝叶斯分析。“bug”代表(贝叶斯推断使用吉布斯采样)。因此，要运行这个库，需要安装 OpenBUGS。安装说明可以在 这里 找到。

首先，我们导入库“R2OpenBUGS ”,并定义 OpenBUGS 程序的安装路径。

然后，我们将定义我们的模型

这里，先生表示马库斯·拉什福德，当先生大约为 2 时，拉什福德受伤，我们将该事件分配给受伤先生。请注意，在这种情况下，当先生在 1 左右返回时，拉什福德是合适的。这些事件的顺序可能会改变，这取决于我们以后如何分配概率。在这种情况下，我们几乎可以映射像(MRfit，MRinjured) -> (1，2)这样的事件。

类似地，还定义了其他变量。请注意，由于曼联在英超(EPL)的表现取决于马库斯·拉什福德的状况，因此在我们定义 EPL 变量时，“先生”变量也包括在内。其他依赖项也遵循类似的方式。

接下来，我们分配我们拥有的数据(即概率、确凿证据)。

我们看到 BF 被设置为 1。这是因为我们从这个问题中知道布鲁诺·费尔南德斯将在本赛季结束后与曼联签约。因此，这是确凿的证据，我们将 BF 变量赋值为 1。

其余的数据是给定的概率。具有相关性的概率具有矩阵的形式。请注意，这里定义矩阵的方式不同于 OpenBUGS 本身的原生矩阵配置。更多关于如何在 OpenBUGS 软件上定义矩阵的信息可以在 这里 找到。

接下来，我们需要遵循一个默认的强制步骤，称为初始化。然而，这更适用于涉及连续随机分布的问题，我们不需要在这里初始化任何值。但是，如果我们没有给初始化步骤赋值，那么这个包会返回一个错误，所以我们把它赋值为 NULL。

现在，我们可以运行模型来计算有确凿证据的概率。

“调试”默认为假。但是，建议将其切换为 True，因为在模型不运行的情况下更容易看到错误。我们现在可以运行代码让模型运行起来。这里，我们将运行并迭代模型 100，000 次，然后丢弃前 1，000 个结果，以确保不包括任何大的初始变化。

当模型运行时，OpenBUGS 将打开并显示一个类似上面的窗口。

它包含了我们正在寻找的所有答案，但是如果我们希望一切都在 R 中，我们将需要关闭应用程序，以便 R 代码可以完成运行。然后我们使用下面的代码在 r 中显示结果。

鉴于布鲁诺-费尔南德斯与曼联签约的消息，曼联获得明年欧冠参赛资格的概率为 81%。他们赢得欧联杯的概率也提高到了 62.5%。他们在英超联赛中获得前 3 名或第 4 名的概率也略高，分别为 20.8%和 30.3%。

值得注意的是，马库斯·拉什福德受伤的概率降低到了 17.6%，因为他对球队的表现起着重要作用，并直接影响到球队是否有资格参加 UCL 的比赛，这直接影响到费尔南德斯是否决定与曼联签约。

library(R2OpenBUGS)
OpenBUGS.pgm = "c:/Program Files (x86)/OpenBUGS/OpenBUGS323/OpenBUGS.exe"#Setting up the model
model <- function() {

 MR ~ dcat(p.MR[]);
 MRinjured <- equals(MR, 2);

 EPL ~ dcat(p.EPL[MR,]);
 EPLTop3 <- equals(EPL,1);
 EPL4th <- equals(EPL,2);
 EPLElse <- equals(EPL,3);

 Europa ~ dcat(p.Europa[MR,]);
 WonEL <- equals(Europa,1);

 UCL ~ dcat(p.UCL[EPL,Europa,]);
 InUCL <- equals(UCL,1);

 BF ~ dcat(p.BF[UCL,])
}#Hard evidence: 1 is TRUE and 2 is FALSEdata <- list( BF = 1,p.MR = c(0.8,0.2),p.Europa = structure(.Data =  c(0.6,0.3,
                         0.4,0.7), .Dim = c(2,2)),p.EPL = structure(.Data = c(0.2,   0.1,    
                   0.3,   0.2, 
                   0.5,   0.7), .Dim = c(2,3)),p.UCL = structure(.Data = c(1, 0.99, 0.99,     1, 0.7, 0,
                    0, 0.01, 0.01,     0, 0.3, 1), .Dim = c(3,2,2)),p.BF = structure(.Data = c( 0.7,  0.4,
                            0.3,  0.6), .Dim = c(2,2)) 
)#Initialization
inits <- NULL#Run BUGS and save resultsout <- bugs(data = data, 
                inits = inits, 
                parameters.to.save = c("MRinjured", "EPLTop3", "EPL4th", "EPLElse", "WonEL", "InUCL"),
                model.file = model, 
                digits = 5,
                n.chains = 1,
                n.burnin = 1000,
                n.iter = 100000,
                OpenBUGS.pgm=OpenBUGS.pgm, 
                WINE = WINE, 
                WINEPATH = WINEPATH,
                useWINE=F,
                debug = T,
                working.directory=getwd(),
                DIC = F
                )print(out$summary)

统计学简介—查看数据

原文：https://towardsdatascience.com/intro-to-statistics-looking-at-data-1-23c49ef2bbd8?source=collection_archive---------15-----------------------

有许多关于统计的免费学习课程和资料。

统计学可以有效地用于分析、估计，有时甚至预测现实世界的事件。当正确使用时，它将引导我们根据数据观察做出更好、更安全的决策。它是数据科学中的基本支柱，也是许多领域中极其有用的工具。

你能找到的最优秀的课程之一是【乌达城统计学导论】。

你会发现一个温和的和自定进度的领域介绍。对于那些像我一样在大学学位完成几年后对数据科学感兴趣的人来说，更新知识并开始在自己的模型中工作是完美的。我想全面地介绍一门统计学课程，作为课程完成的一部分，我正在写一些关于所有测试、编码和补充研究的帖子。

这些帖子可以在不参加课程的情况下阅读，因为它们主要涉及小测验，但我想对正在参加或考虑参加的人来说会更有趣——这是我强烈推荐的。

我希望你喜欢它们，让我们开始吧。

第 2 课:查看数据

在本课程的第 2 课中(第 1 课只是一个预告片)，通过一组关于房价的实际例子介绍了数据探索的基本概念。

这些概念引入线性回归作为估计值的最简单形式。给定一个遵循直接关系的样本数据集，您可以估计一个表示直线的函数，这将使您能够估计任何值。

第一个数据集显示以下值:

Quiz: Valuing Houses 1 – Image from Udacity Intro to Satistics –

在这种情况下，首先要做的是绘制值。我们可以通过下面的源代码轻松实现:

# --编码:utf-8 --

导入 matplotlib
matplotlib . use(’ Agg ')

将 numpy 作为 np 导入
将 matplotlib.pyplot 作为 plt 导入

size = [ 1400，2400，1800，1900，1300，1100]
cost = [ 112000，192000，144000，152000，104000，88000]

plt.scatter(size，cost)
PLT . save fig(’ values 1 . png ')

Valuing Houses — Plot 1

这是一个理想化的场景，其中所有的点都正确对齐。没有必要做数学来提取线参数来回答一个 1300 英尺的房子多少钱，这个问题是数据的一部分和所有的数据点完全对齐。请注意，如果这些点没有对齐，数据集中的精确数据点并不意味着价格有效。

即使这是一种理想化的情况，并且不需要计算线性回归，我们也将使用第一个例子来实现我们的第一个线性回归。

我们的第一个线性回归

用直线来逼近数据集的统计操作称为线性回归。线性回归基本上是一种算法——实际上，它是实现相同目标的一系列算法——它找到一条尽可能接近所有数据点的线。正确的定义可以在维基百科中找到，它简洁明了，所以我们在这里引用它:

在统计学中，线性回归是一种线性方法，用于模拟标量响应(或因变量)与一个或多个解释变量(或自变量)之间的关系。一个解释变量的情况称为简单线性回归。[1]

在第一个课程示例(测验 1)中，展示了所有数据点对齐的特殊情况。在这种情况下，线性回归可以有效地跨越所有数据点。这是一个很好的机会来看看线性回归提供的统计数据会发生什么。

为了计算线性回归，我们可以使用 SciPy 包中的 stats 模块。

# --编码:utf-8 --

导入 matplotlib
matplotlib . use(’ Agg ')

从 scipy import stats 导入 numpy 作为 np
导入 matplotlib.pyplot 作为 plt

#散点图

size = [ 1400，2400，1800，1900，1300，1100]
成本= [ 112000，192000，144000，152000，104000，88000]

plt.scatter(size，cost)
PLT . xlabel(’ \n size in ft2 ')
PLT . ylabel('美元价格\ n ')

#线性回归

gradient，intercept，r_value，p_value，std_err = stats . Lin regressive(size，cost)
打印“梯度和截距”，Gradient，intercept
打印“R 平方”，r_value**2
打印“p 值”，p_value
打印“标准误差”，STD _ err

lr_x = np.linspace(1000，2500，100)
lr _ y = gradient * lr _ x+intercept

plt.plot(lr_x，lr_y，‘蓝色’)

#构建图

plt.xlim([1000，2600])
plt.ylim([80000，200000])
PLT . save fig(’ values1b . png ')

Valuing Houses — Plot 1 with linear regression line

该代码还从计算的线性回归中提供以下值:

梯度和截距 80.0 -2.91038304567e-11
R 平方 1.0
p 值 1.5e-40
标准误差 0.0

线梯度为 80，与数据集有意义；一栋 1300 英尺的房子意味着 104.000 美元的价格，也就是 80 乘以 1300。截距点几乎为零(与 y 轴刻度相比可以忽略不计)。

关于 R 平方、零假设、p 值和标准误差

我们的第一个例子是探索第一个统计变量的绝佳机会。线性回归不仅提供了数据的估计模型，而且我们还可以测量我们的模型有多精确和可靠。

我不会深入回顾这些概念，因为它们在其他地方会有更好的解释(我会提供链接)，但至少我会提到它们，说明它们如何帮助您了解您使用的模型是否可靠。

—

R 的平方 是决定系数。它介于 0 和 1 之间，代表线性回归模型与数据的拟合程度。接近 1 的值意味着模型非常符合数据。因为它实际上跨越了所有的数据点。所以这是我们能得到的最好的了。

**R 的平方是决定系数。它是数据与拟合回归线接近程度的统计度量。

—

不先理解零假设**就无法解释 p 值*。*

在推断统计学中，零假设是一个一般的陈述或默认立场，即两个测量的现象之间没有关系，或者组之间没有关联。[2]

所以基本上，默认情况下，你假设因变量和自变量完全不相关。这就好比，除非被证明有罪，否则每个人都是无罪的。维基百科对零假设提供了一个很好且容易理解的解释。

—

p -values 帮助你确定你的结果/模型的重要性。它基本上衡量你是否否认/拒绝零假设。较小的值(小于 0.05)表示反对零假设的有力证据。较大的值(大于 0.05)表明您的模型/分析未能否定/拒绝零假设，因此您的模型/分析没有证明变量之间的依赖性。更多关于 p 值的信息可以在找到。

p 值帮助您确定结果/模型的重要性。它基本上衡量你是否否认/拒绝零假设。

在这个例子中，p 值可以被认为几乎为零，因此我们可以相当确定自变量和因变量之间存在相关性。

—

线性回归的标准误差代表观察值偏离回归线的平均距离。一个合适的定义可以在这里找到。

线性回归的标准误差表示观察值偏离回归线的平均距离。[3]

在我们的例子中是零，因为所有的数据都完全符合我们的模型。

你的模型准备好了

Quiz: Valuing Houses 3 – Image from Udacity Intro to Satistics –

现在你已经提出了一个模型，你可以准确地估计其他价格值，比如一个 2100 英尺。由于坡度为 80 °,而截距为零，得到的值就是坡度乘以平方英尺。

p =大小梯度+截距= 210080 = 168000

第二课复习到此结束。在本课程中，所有示例价格都是在假设数据是线性的情况下计算的。这篇文章更准确地解释了线性是如何计算的，以及线性回归在完美的线性数据集中是如何表现的(这在现实世界中几乎不会发生)。

参考

[1]https://en.m.wikipedia.org/wiki/Linear_regression

[2]https://en.m.wikipedia.org/wiki/Null_hypothesis

[3]http://statisticsbyjim . com/glossary/standard-error-regression/

[4]https://eu.udacity.com/course/intro-to-statistics-ST 101

结合交易实例介绍支持向量机

原文：https://towardsdatascience.com/intro-to-support-vector-machines-with-a-trading-example-1d4a7997ced6?source=collection_archive---------7-----------------------

让我们试着理解支持向量机，以及如何在金融市场中实现它们

就像任何其他机器学习算法一样，支持向量机(SVM)将数据作为输入，试图找到并识别模式，然后告诉我们它学到了什么。支持向量机属于监督学习的范畴，这意味着它创建一个将给定输入映射到输出的函数。更具体地说，SVM 是一种分类算法。

在我们开始实现交易算法和寻找阿尔法值之前，让我们弄清楚 SVM 是如何工作的

最大间隔分类器

支持向量机算法来自于最大间隔分类器。 最大间隔分类器 使用距给定决策边界的距离来对输入进行分类。距离或裕量越大，分类器处理数据就越好。在笛卡尔平面上，边界可以被认为是一条线。在三维空间中，它是一个平面，但在此之后，它变得难以概念化。这个边界可以更好地被认为是一个 超平面 ，特别是维度 p-1 中的一个，其中 p 是数据点的维度。
我们的边界或超平面被称为分离超平面，因为它用于将数据点分成所需的类别。一般来说，有许多超平面可以分离给定的数据集，但我们关心的是 最大间隔超平面 或 o 最佳分离超平面。这个分离超平面是与训练集中的每个数据点具有最大最小距离的超平面。通过使用这个超平面来分类来自测试集的数据点，我们得到了最大间隔分类器。

Source: Introduction to Statistical Learning

上图中的线代表超平面。请注意，它完全分隔了图表中蓝色和紫色区域的所有点。

现在，最大间隔分类器在一定程度上起作用了。如果你有一个不能被超平面分割的数据集，你就不能再使用它了。有时，您可能会遇到具有两个以上类别的数据，这使得线性边界毫无用处。

此时，您必须考虑您的选择:

1. 如前所述，您可以将分类器基于分离超平面。但是超平面不存在…所以你没有分类器。
2. 考虑一个不完美的分类器，但是它在某些时候/大部分时间都可以工作

支持向量分类器

我也喜欢第二种选择。通过使用一个不完美的分类器，您至少可以处理大多数观察结果，并在模型出现新数据时引入一定程度的适应性。

最大间隔分类器的这种演变被称为 支持向量分类器 (SVC)，或者软间隔分类器。SVC 的分类并不精确，也不是非常稳健，它允许一些观察值位于边缘和/或超平面的错误一侧(软来自于此),以便得到最正确的分类。

在不涉及太多数学知识的情况下，该算法通过找到一个优化问题的解决方案来确定一个观察值将位于超平面的哪一侧，该优化问题使用一个调整参数、边缘的宽度(它试图最大化该宽度)和松弛变量。

调谐参数用于控制偏差-方差权衡。当它很小时，分类器非常适合数据，因为边距很小。换句话说，低偏差，高方差。更大的调谐参数是相反的。它允许更多的观察值位于误差的错误一侧，从而允许高偏差和低方差。

尤其是松弛变量非常酷。它们允许数据点位于边缘或超平面的一侧。它们还被用来将不平等转化为平等。松弛值的值也可以告诉我们给定数据点的行为。如果给定数据点的松弛变量等于 0，则该数据点位于页边距的右侧。如果松弛变量大于 0 但小于 1，则数据点位于页边距的错误一侧，但位于超平面的右侧。如果松弛变量大于 1，则数据点位于超平面的错误一侧。

这种优化的主要原因是它对超平面的影响。影响超平面并进而影响数据点如何分类的唯一值是那些位于边缘或错误一侧的值。如果一个物体在超平面的右边，它对它没有影响。分类器的名字来源于之前的数据点，因为它们被称为支持向量。

最后，支持向量机

支持向量机通过使用内核来增长特征空间，从而在支持向量分类器中建立优化。

与前面的优化类似，内核使用了相当多的数学知识。简而言之，内核告诉我们数据点有多相似。通过给数据序列分配权重，它可以识别两个点有多相似，因为它已经学会了如何比较它们。内核允许以更简单的方式处理数据，而不是在高维空间中处理。更具体地说，它计算特征空间中所有数据点对的所有可能输出之间的内积。通过使用核而不是扩大特征空间，该算法可以更加有效。它使用一个函数来比较不同数据点对，而不是对数据集中的原始要素使用函数。

存在许多不同的核，包括 RBF 核、图形核、线性核、多项式核。例如，线性核通过使用它们的二元相关性来比较一对数据点。多项式核试图在高维空间中拟合 SVC。支持向量分类器与使用具有 1 次多项式核的 SVM 是一样的。

基本上，支持向量机的主要目标是构建一个超平面，然后使用它来分类数据。尽管通常被归类为分类算法，但有一个用于回归的支持向量机的扩展，称为支持向量回归。

交易的支持向量机

在我进入这个应用程序之前，这绝不是关于你应该如何交易的建议。那是你的责任。

我们将从收集数据开始。

我们将使用大约五年前的时间段，从 2014 年 10 月 28 日到 2019 年 10 月 28 日。我们将获得数据的股票是道琼斯工业平均指数的组成部分。

雅虎财经曾经很容易获得数据，但大多数软件包不再工作，所以我们也将在这个过程中创建一个网络刮刀。

我们要做的第一件事是导入我们需要的所有包。

然后我们将使用 requests 包来抓取雅虎财经上这个页面的内容。该页面包含组成道琼斯工业平均指数的公司名称，以及它们的代码。接下来，我们将使用beautiful soup 4使 Dow_Content 中的信息可搜索。

上面的几行代码解析从 web 页面收集的数据，并搜索与页面上的表格相对应的 HTML 代码。这可以通过右键单击页面区域，检查元素来找到，稍微调查一下就可以找到上面使用的类名。

搜索将会遇到两种类型的行:

1. 包含股票代码的行
2. 包含公司名称但没有股票代号的行

我们不关心后者，所以当循环找到它们时，它忽略那个位并继续前进。一些字符串操作来删除多余的脂肪，我们有我们的股票。然后，每一个股票都被添加到一个列表中，以便安全保管。

Yahoo Finance 在他们的 URL 中使用了 Unix 时间戳，所以我们使用了 time 包来将我们的开始和结束日期转换成所需的格式。它可以采用 struct_time (这里有更多关于的内容)或者一个由 9 个时间参数组成的元组。我们真的不在乎任何过期的东西。

ScrapeYahoo 函数有四个参数:

1. data_df ，你指定的存储输出的数据结构
2. ticker ，代表给定股票的字符串
3. start ，一个代表开始日期的 Unix 时间戳
4. end ，代表当天的 Unix 时间戳

它将这些与 Yahoo Finance 的基本 URL 结合起来，并从所需的网页中获取数据。我们不再像以前那样处理它，而是从页面中解析 JSON 数据。雅虎财经现在用 cookies，单纯用 HTML 代码会抛出错误。

后面的几行解析 JSON 数据的内容。在我最初探索数据集时，Python 字典的 keys() 方法非常有用。这使得遍历 JSON 数据变得更加容易。你可以在这里读到它

字典 Stock_Data 将保存我们解析的数据。字典中的关键字将是给定股票的代码。对于每只股票，函数 ScrapeYahoo 将创建一个包含开盘价、最高价、最低价、收盘价和成交量数据的数据框架。

我们有历史价格数据，现在呢？回想一下，支持向量机是一种分类算法。我们将尝试在技术分析的帮助下为我们的模型创建特性。

技术分析是一种利用过去的数据来预测价格未来走向的方法。一般来说，技术指标在计算中使用价格数据和交易量。选择这些指标的动机来自于文章末尾参考文献部分列出的论文。

继续前进之前需要注意的一件非常重要的事情: 前瞻偏差 。我们已经有了所有的结算数据，这些数据将用于计算。在现实世界中，你最多只有前一天的收盘。我们必须确保我们的计算不会包含技术上尚未出现的数据。为此，我们将滞后数据。也就是说，将我们的数据向后移一天。

技术分析

我们将利用 talib 库执行技术分析计算。

Example of a chart with Bollinger Bands Source: Trading With Rayner

我们将使用我们的回报栏来计算我们每个交易日的标签。如果返回为 0 或正数，则标记为 1，否则标记为 0。请注意，returns 列使用的是开盘价而不是收盘价，以避免前瞻偏差。

训练模型

在我们开始建立模型之前，必须对数据进行规范化。这样，当 SVM 计算其距离时，所有的要素都会被缩放并赋予同等的重要性。

我们使用了maxabscaler，它根据每个特征的最大绝对值对其进行缩放。

接下来，我们创建了一个字典来存储训练和测试数据。如果不删除 NaN 值，模型将不会运行。变量 X 将包含模型的所有特征，然后将被缩放。丢弃信号和返回列是很重要的。我们正在预测这个信号，如果它保持下去，这个模型将近乎完美。如果我们保留 Returns 列，也会对模型产生太大的影响。请记住，信号列最初是通过使用计算的回报率计算的。 Y 是我们要预测的，所以我们把它赋给包含信号的列。

我们的模型将使用 70%的数据进行训练，30%的数据进行测试，如第 11 行所示。

该模型由模型变量定义(以防您感到困惑)。我在下面链接的笔记本中留下了各种内核配置，您可以随意使用。该模型符合训练数据，并用于预测信号列中的值。

最后，我们将每只股票的准确度、精确度和召回率添加到我们的模型字典中。

快到了！下一段代码使用来自 SVM 模型的信号计算回报。通过对熊猫数据帧使用 iloc 方法，将信号附加到末尾比我们之前所做的要容易得多。

我们将计算相对于市场表现的回报率，并以此作为我们的基准。投资组合的表现通过使用夏普比率来衡量。

最后，绘制预测结果的图表。

输出的几个例子如下:

Not bad!

Not too good…

结论

无论如何，这个模型并不完美，但它确实适用于道琼斯工业平均指数中的一些股票。有几种方法可以改进这一点:

1. 使用技术指标创造信号，而不仅仅是回报
2. 根据长/短场景调整模型
3. 使用不同的技术指标
4. 创建一个投资组合，包括头寸规模、交易成本、滑点等。

金融市场是一个非常复杂的地方，而我们的模型相当简单。这个例子简单地分类了以前的回报是否预示了未来的价格走向。

有很大的改进空间，所以尝试一下吧。参考资料中会有笔记本的链接，所以可以随意使用代码。

我希望这有助于你理解支持向量机！

参考

[1] R .罗西洛、J .吉纳、d .德拉·富恩特和 r .皮诺，标准普尔 500 指数中基于支持向量机的交易系统 (2012)，2012 年国际人工智能会议论文集，ICAI，2012

[2] B. Henrique，V. Sobreiro 和 H. Kimura，使用支持向量回归对每日和最新价格进行股票价格预测 (2018)，《金融和数据科学杂志》

[3] X. Di，用 SVM (2014)的技术指标预测股票走势

[4] G. James，D. Witten，T. Hastie 和 R. Tibshirani，统计学习导论及其在 R 中的应用(2017)

Python 代码

编辑:修正了在代码的不同部分使用“shift”的问题。感谢那些喊出它的人，我感谢他们的反馈。

介绍 Arauto:一个用于时间序列预测的交互式工具

原文：https://towardsdatascience.com/introducing-arauto-an-interactive-tool-for-time-series-forecasting-14b3e36b5f81?source=collection_archive---------16-----------------------

时间序列模型的快速实验和训练工具

Photo by Aron Visuals on Unsplash

时间序列预测一直是应用机器学习和统计模型的一个杰出领域，尽管许多数据科学家可能不认为它是一个像计算机视觉或 NLP 这样性感的领域。事实是，许多公司依靠时间序列预测和分析来了解业务的未来，如预测收入、活跃客户、平均门票等。

今天，我想介绍一个工具，它帮助我优化和提高了构建时间序列模型的效率: Arauto，这是一个用 Python 开发的开源应用程序，旨在为提供一种交互式和直观的方式来构建混合自回归移动平均模型(AR，MA，ARMA，ARIMA，SARIMA，ARIMAX，SARIMAX) 。

动机

在我目前的工作中，我负责创建和维护生产中运行的多个时间序列模型。 Hotmart 是世界上最大的数字产品平台之一，我们的高管、投资者、经理和领导层需要了解我们对未来一些关键业务指标的预期，比如我们将获得多少收入，我们将在基础设施上花费多少资金，或者我们预计未来几个月有多少活跃用户。

然而，我注意到我在构建模型时有两个主要问题:

• 我的大部分时间都浪费在了重复构建流程和代码上:那些肯定可以自动化的东西；
• 为我的模型迭代和试验不同的模型和参数不是很有成效。

这几点促使我开发了一个工具，它可以帮助我——当然也可以帮助更多面临类似问题的人——在我的项目中更加敏捷和高效。这个项目的结果是自动的。

Arauto at work!

阿拉图是什么？

Arauto 是一个开源工具，结合了一个交互式和直观的 web 应用程序，引导你完成时间序列模型的分析和构建。Arauto 的目标是在几分钟内给你一个预测模型，在这个过程的最后，它会生成用于转换和训练模型的代码，这样你就可以在 Jupyter 笔记本或 Python 脚本上复制和修改它。以下是 Arauto 的一些功能:

• 支持外生回归变量；
• 季节性分解，让你知道数据的趋势、季节性和残差；
• 使用增强的 Dickey-Fuller 检验的平稳性检验；
• 数据转换的平稳性定制:您可以使用从一阶差分到季节日志来转换您的数据；
• 用于项估计的 ACF (自相关函数) PACF (部分相关函数)；
• 定制 ARIMA 条款或让 Arauto 根据您的数据选择最适合您的；
• 网格搜索功能用于参数调整；
• 代码生成:在过程结束时，Arauto 返回用于转换数据和训练模型的代码

Arauto predicting in-sample and out-of-sample data

如何安装

网

使用 Arauto 非常容易。如果你对你能做什么感到好奇，有一个在线版本，你可以点击这个链接进入。请记住，这是一个用于演示目的的轻量级版本，因为它使用的是 Heroku 的自由层实例。

码头工人

Arauto 可以很容易地安装使用 Docker。通过运行三个命令，您将准备好在自己的基础设施上使用 Arauto。

**# Clone the repository**
git clone https://github.com/paulozip/arauto.git
cd arauto**# Run the docker compose**
docker-compose up --build

还有另一个选择是通过使用 Conda 的环境来安装 Arauto。更多信息请参考 Github 知识库。

The code used to transform the data and train your model will be available at the end of the process

如何使用 Arauto

Arauto 被设计得尽可能直观，即使对于那些没有深入统计知识的人也是如此。然而，我们在几分钟内为你制作了一个完整的教程来帮助你开始使用 Arauto。请， 参考 Arauto 的文档了解更多 。

You can customize Arauto or let it choose the best parameters for you

如何投稿

目前，这个项目只由一个人维护。如果有更多的人合作并为这个开源项目做出贡献，那就太好了。如果你想和 Arauto 合作，你可以这样做:

• 文档和教程:让用户一打开浏览器就进入 Arauto 真的很重要。教程和更深入的文档可以帮助我们实现它。
• 新算法:我们可以给 Arauto 添加许多不同的算法，比如 ARCH、VAR 和基于树的算法等等。你所需要做的就是派生存储库，构建特性并打开一个 PR 来合并它。
• 错误修复:某些东西可能被破坏了。我们需要优秀的人来修复它。
• 测试 : Arauto 不包含测试，这是错误的。
• 请求功能 : 您可以使用我们的问题跟踪功能提出新的想法和功能。请求将通过竖起大拇指表情符号(👍)

获取更新

Arauto 将增加新功能。如果你想知道新版本何时到来，请订阅 Arauto 的时事通讯，了解新的事情。我们不会发送垃圾邮件或共享您的电子邮件。只会发送与 Arauto 相关的内容。

我希望你对和 Arauto 一起创造新事物感到兴奋。我是 Paulo Vasconcellos， Hotmart 的数据科学家，数据黑客的联合创始人:巴西最大的数据科学和机器学习社区。欢迎在 Linkedin 或 Twitter 上关注我(推文和帖子在 PT-BR 中)了解更多关于 Arauto 和数据科学的信息。再见！

熊猫图形用户界面 Bamboolib 简介

原文：https://towardsdatascience.com/introducing-bamboolib-a-gui-for-pandas-4f6c091089e3?source=collection_archive---------3-----------------------

几天前，Tobias Krabel 先生通过 LinkedIn 联系我，向我介绍他的产品，一个名为 Bamboolib 的 Python 库，他说这是一个学习熊猫的 GUI 工具——Python 的数据分析和可视化库。

Photo by Marius Masalar on Unsplash

他说，我引用他的话:

我们的目标是帮助人们快速学习和使用熊猫，我们希望加入下一代 python 数据科学家。

我不得不承认，一开始我持怀疑态度，主要是因为我不是 GUI 工具和拖放原则的忠实粉丝。尽管如此，我还是打开了网址，看了介绍视频。

这是少有的一次我被合理地激起了兴趣。

从那以后，我很快回复了 Tobias，他友好地让我测试一下这个库，看看我是否喜欢它。

情况怎么样？嗯，你必须继续阅读才能找到答案。所以让我们开始吧。

免费吗？

在一个像 Numpy 和 Pandas 这样令人惊叹的图书馆可以免费使用的世界里，这个问题可能甚至不会出现在你的脑海里。然而，它应该，因为不是所有版本的 Bamboolib 都是免费的。

如果你不介意与他人分享你的作品，那么是的，它是免费使用的，但如果这造成了一个问题，那么它会让你每月至少花费 10 美元，这对于普通用户来说可能是令人失望的。下面是完整的价目表:

正如该库的开发者所说，Bamboolib 旨在帮助你学习熊猫，因此我认为使用免费选项没有问题——如果你刚刚开始，很可能不会从事一些绝密项目。

然而，这篇评论将基于私人版本的图书馆，因为这是托拜厄斯给我的。话虽如此，这篇文章绝不是抱着劝你买许可证的想法写的，它只提供我个人的看法。

在进入好的内容之前，您需要首先安装库。

安装过程

要做的第一件也是最明显的事情是 pip 安装:

pip install bamboolib

然而，如果你想让这个东西完全工作，还有很多事情要做。它被设计成一个 Jupyter Lab 扩展(或者 Jupyter Notebook，如果你还在用那些)，所以我们也需要在那里设置一些东西。

在命令行中键入以下内容:

jupyter nbextension enable --py qgrid --sys-prefix
jupyter nbextension enable --py widgetsnbextension --sys-prefix
jupyter nbextension install --py bamboolib --sys-prefix
jupyter nbextension enable --py bamboolib --sys-prefix

现在您需要找到安装在您机器上的 Jupyter Lab 的主要版本。您可以使用以下命令获得它:

jupyter labextension list

我的是“1.0”，但是你的可以是任何东西，所以这里是你需要执行的下一个命令的通用版本:

jupyter labextension install @jupyter-widgets/jupyterlab-manager@MAJOR_VERSION.MINOR_VERSION --no-build

请注意，您需要替换“MAJOR_VERSION。MINOR_VERSION”和版本号，在我的例子中是“1.0”。

再多几个命令，你就可以开始摇滚了:

jupyter labextension install @8080labs/qgrid@1.1.1 --no-build
jupyter labextension install plotlywidget --no-build
jupyter labextension install jupyterlab-plotly --no-build
jupyter labextension install bamboolib --no-build

jupyter lab build --minimize=False

就这样。现在你可以开始 Juypter 实验室，我们可以深入到好东西。

第一次使用

在 Jupyter 中，您可以导入 Bamboolib 和 Pandas，然后使用 Pandas 加载一些数据集:

以下是使用库查看数据集的方式:

当你第一次使用图书馆时，这是行不通的。您需要激活它，因此请确保将许可证密钥放在附近的某个地方:

输入电子邮件和许可证密钥后，您应该会收到以下消息，表明一切顺利:

很好，现在您可以再次执行前一个单元格了。你马上会看到一个陌生的，但看起来很友好的界面:

现在一切都准备好了，我们可以开始一些基本的功能了。走到这一步需要做很多工作，但是相信我，这是值得的！

数据过滤

任何数据分析师/科学家最常见的日常任务之一就是数据过滤。基本上，你只想保留在给定时刻与你相关的数据子集。

要开始用 Bamboolib 过滤，点击过滤器按钮。

应该会弹出一个类似下面的侧菜单。我决定按“年龄”列进行筛选，只保留“年龄”值小于 18 的行:

一旦你按下执行，你会看到动作立即发生:

太好了！但是你还能做什么呢？

替换值

另一个常见的日常任务是用相应的数字替换字符串值。这个数据集非常适合演示值替换，因为我们可以很容易地将“性别”列中的字符串值替换为数字值。

首先，点击替换值按钮，指定列、要替换的值以及要替换的内容:

一旦按下执行按钮:

太棒了。对于“女”的选项也可以这样做，但要不要做由你自己决定。

分组依据

是的，您还可以执行聚合！要开始，点击聚合/分组按按钮，并在侧边菜单中指定应该做什么。

我决定按“Pclass”分组，因为我想看看每个乘客级别的幸存者总数:

这将产生以下输出:

厉害！在结束之前，让我们再探索一件事。

一个热编码

很多时候，在为机器学习准备数据时，您会想要创建虚拟变量，因此为给定属性的每个唯一值创建一个新列。这样做是个好主意，因为许多机器学习算法无法处理文本数据。

要通过 Bamboolib 实现该逻辑，点击 OneHotEncoder 按钮。我决定从“apollowed”属性创建虚拟变量，因为它有 3 个不同的值，你不能说一个比另一个好。此外，确保移除第一个虚拟变量，以避免共线性问题(的变量是其他变量的完美预测变量):

如您所料，执行将在数据集中创建两个新列:

很好，我已经完成了我的转变，但是下一步是什么？

获取代码

直到现在都是有趣的游戏，但是迟早你会注意到这些操作没有在适当的位置执行——因此如果你不明确地指定它,数据集将不会被修改。

这不是一个错误，因为它使您能够在不弄乱原始数据集的情况下进行试验。然而，Bamboolib 要做的是，它将生成 Python 代码来实现期望的转换。

要获取代码，首先点击导出按钮:

现在指定您希望它如何导出—我选择了第一个选项:

最后，它会给出您可以复制并应用到数据集的代码:

值得吗？

至此，我简要展示了 Bamboolib 的主要功能——这绝不是详尽的教程——只是想向您展示它背后的思想。

问题是，它值这个钱吗？

如果你决定走付费路线的话。你仍然可以免费使用它，前提是你不介意与他人分享你的作品。该库本身值得一试，主要有两个原因:

1. 它提供了一个学习熊猫的好方法——通过做来学习比通过读来学习要容易得多，而且像这样的 GUI 工具肯定只会对你有所帮助
2. 它非常适合摆弄数据——让我们面对现实吧，有时候你知道你想做什么，但你就是不知道如何用代码实现它——bamboo lib 可以提供帮助

请记住——付费版本不会给你带来任何额外的功能——唯一真正的好处是你的作品将是私有的，并且可以选择用于商业用途。

即使你还没有准备好拿你的信用卡，尝试一下免费版并看看它是否能让你受益也不会有什么坏处。

感谢阅读。保重。

喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。

[## 通过我的推荐链接加入 Medium-Dario rade ci

作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…

medium.com](https://medium.com/@radecicdario/membership)

在深度学习中引入卷积神经网络

原文：https://towardsdatascience.com/introducing-convolutional-neural-networks-in-deep-learning-400f9c3ad5e9?source=collection_archive---------10-----------------------

卷积神经网络又名 Convnets 或 CNN，是深度学习中神经网络的超级明星。这些网络能够执行图像、声音、文本、视频等相对复杂的任务。第一个成功的卷积网络是在 20 世纪 90 年代后期由 Yann LeCunn 教授为贝尔实验室开发的。

在类似 MNIST 的分类问题中，多层感知器(MLP)是最常用的，并且提供非常好的结果(很高的准确度)，此外，训练时间保持合理。然而，对于具有较大图像的较大数据集，模型的参数数量呈指数增长，因此，训练变得更长，性能更差。

爆炸参数的数量

MLP 对于解决几类问题非常有效，例如分类、估计、近似、识别等。但是，它们很快就会变得有限，尤其是对于非常高维的输入数据。

假设我们想要创建一个深度学习模型来执行猫或狗的分类任务。该模型在大小为 420x420px 灰度的图像数据集上训练；训练结束后，我们希望模型能够说出图像是狗还是猫。例如，第一种方法是使用具有 128 个神经元的输入层的多层感知器。由于该层的每个神经元接收 420x420 像素值作为输入，并为每个像素值分配一个权重，因此我们得到每个神经元 420x420 = 176400 个权重，乘以总共 128 个神经元，最后加上 128 个偏差，每个神经元一个偏差。这个微小的模型将不得不学习超过 2200 万个参数，只需要 128 个神经元和一个中间层。如果我们想要一个强大的模型，它将需要几个附加层和每层更多的神经元。参数数量激增。例如，一个 3 层模型(128–256–1)需要将近 2300 万个参数。这种模型需要大量的数据来训练，并且由于要调整的参数多得多，训练阶段将持续更长时间，并且性能下降；让我们清楚地说，即使我们有足够的计算能力，也不可能正确地训练这个模型，因为这不是唯一需要处理的问题。

图像的空间退化

训练多层感知器需要以向量(一维数组)的形式提供输入数据。如果输入数据是一个矩阵图像，那么它必须被展平以得到一个矢量。然而，在自然图像中，相邻像素之间存在非常强的联系；通过展平图像，我们丢失了这些信息，网络在训练阶段解释数据变得更加困难。这证明了对解决这种问题的另一种神经网络结构的兴趣。让我们首先介绍卷积是由什么组成的。

卷积算法

卷积是一种滤波器(也称为内核)与图像矩阵的乘积运算，用于从中提取一些预先确定的特征。从字面上讲，我们使用卷积过滤器来“过滤”图像，只显示对我们真正重要的内容。所考虑的图像是矩阵，所使用的滤波器也是矩阵，通常是 3×3 或 5×5。让我们看看卷积如何与下面的内核一起工作，

Convolution filter

6x6px 矩阵代表一幅图像。开始时，卷积核(此处为 3×3 矩阵)位于矩阵图像的左上角，然后该核覆盖该矩阵图像的一部分，然后我们对两个重叠块进行逐个元素(逐元素)的乘积，最后对这些乘积求和，最终结果对应于输出图像的一个像素。

Convolution algorithm

然后，我们将卷积核从水平向右移动一个像素，我们生成一个新的元素乘积，然后相加得到输出图像的新系数。

一旦到了一行的末尾，内核垂直向下移动，然后从左边开始，我们同样迭代，直到内核覆盖了所有的矩阵图像。值得注意的是，内核始终保持在初始矩阵上，不会溢出。

当然，我们不能使用任何过滤器，我们的内核的系数将取决于我们希望过滤器突出的特征。让我们看看一些著名滤波器的卷积结果。

垂直索贝尔滤波器

它的作用是突出显示对象的垂直线。应用到左边的初始图像，这是结果，

Vertical Sobel filter

水平索贝尔滤波器

这次是为了突出图像的水平轮廓。这是应用于左侧图像的结果，

Horizontal Sobel filter

可以组合这些过滤器的动作来执行更复杂的操作。根据要解决的任务，已经列出了几个可以直接以这种方式使用的滤波器:平均滤波器、高斯滤波器等。在深度学习出现之前，人类专家必须计算并确定要使用的正确过滤器，以便执行特定的图像处理操作:人脸检测、照片编辑，像 Snapchat 过滤器等。现在有了深度学习，确定这些过滤器是通过学习自动完成的，模型会根据要解决的问题，从训练数据中找到好的过滤器。例如，在猫或狗的分类问题中，过滤器可以突出分类的决定性特征:耳朵的形状、眼睛的形状、口鼻的形状、轮廓等。

卷积神经网络

卷积神经网络，也称为 CNN 或 Convnets，使用上面介绍的卷积技术来建立模型，以解决在数据集上进行训练的各种问题。让我们看看经典的猫或狗分类问题中卷积网络的细节。

卷积的深度学习方法

在这个分类问题中，我们有两类，即狗和猫。将图像分类为这些类别中的一个类别，取决于诸如头骨形状、耳朵形状、眼睛形状等单一特征。只有这些特征对执行这一分类任务至关重要，其他信息对我们来说并不重要。

因此，理想的情况是从一幅图像开始，能够通过使用适当的过滤器来提取对分类问题感兴趣的主要特征。在深度学习环境中，它将是通过对数据集进行训练来确定这些过滤器的模型。

训练从内核(滤波器)的随机初始化值开始，在训练期间，这些值将通过梯度反向传播来更新。既然我们说的是深度学习，我们可以猜测几层卷积会一层接一层叠加起来，以增加模型性能。

填充和边缘效果

让我们再次以上面的卷积动画为例，看看输出图像的尺寸，也称为特征映射。输入图像是 6x6px 大小的矩阵，滤波器是 3x3 的矩阵。我们可以看到特征图(输出矩阵)是 4x4px 大小的。顺便说一下，一般来说，特征图的大小是，

Feature map size

其中 n 表示输入图像的尺寸，而 p 表示滤波器的尺寸。例如，对于初始 120x120px 图像和 5x5 内核，特色图像的大小为 116x116px。请注意，卷积会减小输入图像的大小。如果我们要输出一个与输入图像大小相同的特征图，我们必须在卷积之前在输入图像周围加零，输入图像是“用零填充”的，因此这种操作的名字， **padding。**我们来看一个例子。

带 3x3 滤波器的 6x6px 矩阵示例。

我们希望特征图具有与输入图像相同的尺寸，即具有 3x3 卷积滤波器的 6x6px。在上面给出的等式中，p = 3，m = 6，因此 n = 6+3–1 = 8。因此，有必要使输入图像的大小为 8x8px，这意味着我们必须在原始矩阵图像周围添加零，以达到 8x8px 的大小；因此下面的矩阵，

“Padded” matrix

填充不是强制的，一般会碰巧忽略；这可能看起来像轶事，但它确实有实际用途。让我们看看边缘像素，例如最左边的，他们只看到卷积核一次，而大多数其他像素看到它两次以上。因此，边缘像素对特征图的影响较小。为了限制这种副作用，我们用零“填充”原始输入图像，这样边缘的像素就不会被忽略。

激活功能

在训练期间，我们知道滤波器的系数被更新；这些可以是负的，正如我们在上面用 Sobel 滤波器所看到的，然后特征图的系数可以在训练期间保持大的负值。由于我们知道这些值代表像素级别，因此是正值，我们可以应用一个函数用零替换负值，并保持正值不变。这是一个名为 relu 的激活功能。但是请记住，还有其他激活函数，其思想基本上与 relu 相同，以保持特征映射值的合理性。

卷积层

提醒一下，卷积是将过滤器或内核应用于输入图像，然后我们得到一个突出输入图像的特征或“特征”的特征图:轮廓、斑点、形状等。每个过滤器都有一个简单而精确的任务要完成。所以，为了解决我们的分类问题(猫或狗)，我们将不得不使用几个过滤器；并且通过组合由那些过滤器突出显示的特征；例如耳朵、眼睛和轮廓的形状，我们的模型将能够被训练来区分狗和猫。因此，我们必须选择要做的卷积的数量，也就是要使用的滤波器的数量，知道我们的滤波器越多，提取的用于分类的细节就越多，要学习的模型的参数就越多，但是模型保证的性能就越好(更高的精度)。之后，我们必须决定是否填充以及使用哪个激活函数。这定义了一个卷积层。使用多少个过滤器？64，128，256 …哪个激活功能？relu，乙状结肠，tanh …有没有垫？

比方说，我们有一个 128 个过滤器的卷积层；它为每个过滤器提供了一个特征映射，因此一个输入图像总共有 128 个特征映射。这些特征图代表了图像中包含的不同信息，所以我们可以把它们看作这个图像的不同通道。由于 rgb 图像包含三个通道(红色、绿色和蓝色)，具有 128 个过滤器的卷积层提供了一个具有 128 个通道的单一特征图。如果相同的图像通过另一层 256 个过滤器，它将被输出为 256 通道的特征图，以此类推。

池算法

在自然图像中，像素之间有很强的局部相关性。这意味着，对于一幅图像，如果你知道一个像素是红色的，它的四个最接近的像素很可能也是红色的阴影。在灰度图像的情况下，例如，如果像素具有 180 的强度，则其最近的像素也将具有大约 180 的强度。因此，有可能通过仅保留每个像素局部块的局部代表来减小图像的尺寸，这被称为池化。一般来说，我们会将块中亮度最大(因此值最高)的像素— max pooling —我们也可以将块中像素的亮度平均— average pooling —并将其作为代表。

Max pooling operation

从上面可以看出，池将输入图像的每个维度(高度和宽度)减半。人们可能会认为，池化通过仅用一个像素表示一个像素块而严重降低了初始图像的质量；但实际上输出图像(特征图)当然是一半大，但包含了输入图像的主要特征。

例如，让我们将最大池化应用于水平 Sobel 滤波器输出的特征图，“池化”的图像已经被放大用于比较。

Feature map after two max-pooling

请注意，即使经过两次合并，轮廓仍然清晰可见，图像的细节也不太丰富。池化不仅仅是调整大小，还仅仅保留输入图像的有意义的特征。

通常，在卷积网络中，有一系列操作；卷积-池层-卷积-池层等等。通过多次重复这些操作，我们最终获得仅具有输入图像的有意义(根据所解决的问题)特征的特征图。我们现在可以利用多层感知器的能力来完成分类任务。

展平特征图

为了最终将图像分类到一个类别，比如猫或狗，我们将在最后一个卷积层的顶部设置一个多层感知器(多层感知器)。先前的卷积和汇集操作已经极大地减小了输入图像的大小，以唯一地保持分类的有意义的特征。由于供给 MLP 需要输入向量(一维数组或 1d 数组)，我们需要“展平”输出特征图。因此，MLP 接收小尺寸的特征地图作为 1d 阵列，并选择关于那些特征地图的相应类别。

Flattening operation

现在你知道了卷积神经网络的所有关键步骤，如果你想更深入地研究卷积神经网络，你可以阅读下面的段落。

卷积的高级方法

在前面的描述中，据说卷积是将滑动矩阵(内核或滤波器)与输入矩阵图像相乘。虽然这种解释在深度学习社区中广泛存在，但实际的解释略有不同，但并没有复杂多少。让我们以我们的第一个卷积(漂亮的 gif)为例，它有一个 3x3 内核和一个 6x6px 矩阵。我们使用上面的公式来预测特征图的大小，4x4px。

Receptive fields of neurons

特征图左上角位置的像素值直接取决于输入图像中的像素值和卷积核的值。该像素的值根据卷积算法，

Feature map pixel value

其中 wi 是卷积核的系数， xi 是绿框中矩阵的系数。让我们提醒一下卷积核，

Convolution kernel

上面，我们有例如 w1 = w2 = w5 = 2 和 w9 = 1，还有 x1 = 0，x2 = 1，x5 = 1。注意像素值表达式中的加权和。这就好像我们有一个神经元，其中 xi 是输入，细胞核的 wi 系数是输入的权重。神经元计算加权和，然后是特征图中像素的值，这里是 5。被框住的区域被称为神经元的感受野；左上角神经元感受野上方的绿色部分。

当内核在卷积过程中在输入图像上移动时， xi 的值发生变化，但内核的权重和的值保持不变。然后，通过梯度反向传播来更新它们。特别地，所有这些神经元共享相同的权重和，这些权重是卷积核的系数，因为它们针对相同的特征(例如眼睛或轮廓的存在)查看输入图像。我们还可以给那些神经元加上一个共享偏置 b 。前面提到的激活函数实际上应用于那些神经元。

可以看出，第二个神经元的感受野与第一个神经元的感受野部分重叠，依此类推。由于这些神经元的感受野相互重叠，如果想要的特征被平移——向上、向下、向左或向右——它必然会在另一个神经元的感受野中，从而被这个神经元检测到。我们说我们通过平移得到了不变性。在不太复杂的情况下，20 世纪 60 年代进行的生物学工作使科学家能够识别一些动物视觉皮层中的相同结构。特别是，视觉过程中涉及的第一批细胞将识别非常简单的几何形状:线、圆、点等。然后，更先进的细胞将使用这些信息来识别一个复杂的模式。类似地，在卷积神经网络中，第一卷积层将检测一般的几何形状:角、圆、斑点、轮廓等。接下来的图层将这些元素结合起来，以识别更具体的形状:头骨、眼睛、耳朵等。

再次从上面的公式开始，我们知道使用 pxp 滤波器对大小为 nxn 的图像进行卷积，输出——没有填充——大小为 mxm 的特征图；已知特征图的每个像素与一个神经元相关联，然后我们使用 m ** 2 个神经元，每个神经元观察大小为 pxp 的场，具有 p ** 2 个权重(每个滤波器系数一个)和一个偏差。由于这些参数是共享的，我们最终得到了 m ** 2 神经元的 p ** 2 + 1 参数。

例如，对于大小为 420x420px 灰度的输入图像和大小为 5 * 5 的内核，我们将得到大小为 m = 420–5+1 = 416 的特征图，因此一个卷积需要 416 * 416 = 173056 个神经元！仅用 26(5*5 + 1)个参数来学习。

这是卷积神经网络的兴趣点。为了执行卷积，换句话说，为了检测模式，神经元共享相同的突触权重和可能的偏差，这大大减少了要学习的参数数量。

结论

本文的目的是介绍卷积神经网络及其主要兴趣。一般来说，这些网络为分类和识别任务提供了极好的结果。它们也用于解释声音、文本和视频数据。如果要解决的问题是在序列中寻找模式，那么卷积网络将是很好的候选。在以后的文章中，我们将详细研究卷积网络的连续层如何在训练阶段演变，我们还将了解如何使用热图让这些网络说话。

蒙特卡罗模拟中 Copula 的引入

原文：https://towardsdatascience.com/introducing-copula-in-monte-carlo-simulation-9ed1fe9f905?source=collection_archive---------9-----------------------

概率油气体积估算的一个演示案例

Source

在石油和天然气行业，从地表到地下，不确定性无处不在。为了在任何估计中嵌入不确定性，需要概率方法。

一个简单的例子是体积估计。估算碳氢化合物(石油/天然气)初始地质储量(HCIIP)的公式如下:

Source

为了对 HCIIP 进行概率估计，使用了蒙特卡罗方法，并遵循以下步骤(来源):

1. 定义可能输入的域
2. 根据域上的概率分布随机生成输入
3. 对输入执行确定性计算
4. 汇总结果

概率油气远景评价的一个 Ms Excel 实现可以在这里得到。

如果所有输入都是 独立 随机变量或者 正态分布 ，那么随机抽样就相当简单了。然而，输入，例如孔隙度和碳氢化合物饱和度在某种程度上与 相关，并具有不同的分布。在这种情况下，随机抽样是困难的。这时 系词 来拯救我们了。

介体

根据维基百科，一个 copula 是一个多元的累积分布函数，对于这个函数，每个变量的边际概率分布是均匀的。

上面的定义很抽象，很难理解。然而，实现相当容易。托马斯·威奇写了一篇鼓舞人心的文章，直观地展示了系词。

为了完全掌握 copula 的概念，需要理解随机变量变换。

随机变量变换

让我们从 0 和 1 之间的均匀分布开始采样。

x = stats.uniform(0, 1).rvs(10000)

Uniformly distributed samples

这些样本不是均匀的，而是可以通过累积密度函数(CDF)的倒数转换成任何感兴趣的概率分布。假设我们希望这些样本呈正态分布。我们可以将这些样本传递给正态分布的逆 CDF 函数(例如 ppf 函数在 scipy.stats 中)。我们将得到以下正态分布的样本。

norm **=** stats**.**distributions**.**norm()
x_trans **=** norm**.**ppf(x)

Transformed samples that are normally distributed

如果我们在同一图上绘制均匀样本、变换样本和反向 CDF 曲线，我们得到:

Overlaying uniform and transform (normally distributed) sample along with the CDF curve

当我们想从给定的分布中抽取样本时，计算机会在幕后进行这种转换。

重要的是，这个过程是可逆的；这意味着我们可以通过相同的 CDF 将任何分布的样本转换回统一的分布。

高斯连接函数-添加变量相关性

高斯连接函数的步骤如下:

1. 从相关的多元正态分布中抽取样本。变量相关性通过协方差矩阵指定。
2. 转换相关样本，使边缘(每个输入)一致。
3. 将统一边际转换为任何利益分布。例如，孔隙度服从截尾正态分布，碳氢化合物饱和度服从三角形分布等。

让我们从相关多元正态分布中抽取样本开始。

mvnorm = stats.multivariate_normal([0, 0], [[1., 0.5], [0.5, 1.]])
x = mvnorm.rvs((10000,))

Correlated samples from a multivariate normal distribution with a covariance of 0.5

接下来，我们将边缘转换为均匀分布。

norm = stats.norm([0],[1])
x_unif = norm.cdf(x)

The joint & marginal distributions of X1 and X2

如我们所见，X1 和 X2 的联合分布是相关的，而它们的边际是一致的。

现在，我们可以在保持相关性的同时，将边际转化为任何感兴趣的分布。例如，我们想从三角形分布中得出 X1，从正态分布中得出 X2。

x1_tri  = stats.triang.ppf(x_unif[:, 0],  c=0.158 , loc=36, scale=21)
x2_norm =stats.norm(525, 112).ppf(x_unif[:, 1])

The transformed marginal of X1

The transformed marginal of X2

The joint distribution of X1 and X2

现在我们从不同的分布中得到 X1 和 X2 的期望的联合分布。

HCIIP 的概率估计

有了 copula ，我们已经准备好将变量相关性引入蒙特卡罗的采样阶段。以下是计算 OIIP 的完整 python 代码:

import seaborn as sns
from scipy import stats
import numpy as np
import matplotlib.pyplot as plt
# HCIIP = GRV*NTG*POR*SHC/FVF
means = [0.]*5
cov = [[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]]mvnorm_std = stats.multivariate_normal(means,cov)
x = mvnorm_std.rvs(10000,random_state=42)
norm_std = stats.norm()
x_unif = norm_std.cdf(x)#create individual distr.
grv = stats.triang(c=0.1 , loc=10000, scale=300).ppf(x_unif[:, 0])
ntg = stats.triang(c=0.2 , loc=0.5, scale=0.5).ppf(x_unif[:, 1])
phi = stats.truncnorm(-2*1.96,1.96,0.2,0.05).ppf(x_unif[:, 2])
shc = stats.norm(0.6,0.05).ppf(x_unif[:, 3])
fvf= stats.truncnorm(-1.96,2*1.96,1.3,0.1).ppf(x_unif[:, 4])stoiip = 7758*grv*ntg*phi*shc/fvf/1e6
sns.distplot(stoiip  , kde=False, norm_hist=True)
plt.figure()
sns.distplot(stoiip ,hist_kws=dict(cumulative=True),
kde_kws=dict(cumulative=True))
plt.show()

无变量相关情况

对于没有相关性的情况，协方差矩阵是一个对角矩阵(除了对角单元之外，处处为零)。

cov = [[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]]

运行上面的代码，我们得到下面的 OIIP 直方图和累积概率分布。

Histogram of OIIP for no correlation case

Cumulative distribution of OIIP for no correlation case

可变相关情况

为了说明可变相关性的情况，我们任意指定 NTG、POR 和 SHC 之间的正相关性。

cov = [[1., 0., 0., 0., 0.],
[0., 1., 0.7, 0.6, 0.],
[0., 0.7, 1., 0.8, 0.],
[0., 0.6, 0.8, 1., 0.],
[0., 0., 0., 0., 1.]]

Histogram of OIIP for correlation case

Cumulative distribution of OIIP for correlation case

总结

通过观察 OIIP 直方图和累积分布，我们可以看到，包括变量相关性或依赖性扩展了计算 OIIP 的 P10-P90 范围。这是合理的，因为通过包括相关性，采样可以探索极端空间，否则，在没有相关性的情况下可能会被错过。在下一篇文章中，我们将看看贝叶斯下降曲线分析(DCA)。

介绍深层 Java 库(DJL)

原文：https://towardsdatascience.com/introducing-deep-java-library-djl-9de98de8c6ca?source=collection_archive---------11-----------------------

用 Java 构建和部署深度学习模型

我们很高兴地宣布深度 Java 库(DJL) ，这是一个开源库，使用直观的高级 API 来开发、训练和运行 Java 深度学习模型。如果你是一个对学习深度学习感兴趣的 Java 用户，DJL 是一个开始学习的好方法。如果你是一名使用深度学习模型的 Java 开发人员，DJL 将简化你训练和运行预测的方式。在这篇文章中，我们将展示如何在几分钟内用预训练的深度学习模型进行预测。

代表团

在开始编码之前，我们想分享一下我们构建这个库的动机。在调查深度学习领域时，我们发现 Python 用户有丰富的资源。比如数据分析的 NumPy 可视化的 MatplotlibMXNet、PyTorch、TensorFlow 等等框架。但是面向 Java 用户的资源非常少，尽管它是企业中最受欢迎的语言。我们的目标是为数百万 Java 用户提供开源工具，用他们已经熟悉的语言来训练和服务深度学习模型。

DJL 是在现有深度学习框架之上，用原生 Java 概念构建的。它为用户提供了深度学习方面的最新创新，以及使用尖端硬件的能力。简单的 API 抽象出了开发深度学习模型所涉及的复杂性，使它们易于学习和应用。通过 model-zoo 中捆绑的一组预训练模型，用户可以立即开始将深度学习集成到他们的 Java 应用程序中。

• Other frameworks currently not supported.

DJL 的例子

深度学习正在渗透到企业的各种用例中。在零售业，它被用来预测客户需求，分析客户与聊天机器人的互动。在汽车行业，它用于导航自动驾驶汽车，并发现制造过程中的质量缺陷。在体育行业，实时教练和训练洞察正在改变比赛的方式。想象一下，能够使用深度学习模型来模拟对手的移动或确定如何定位您的团队。在这篇文章中，你可以了解西雅图海鹰队如何使用深度学习来告知游戏策略并加速决策。

在本帖中，我们分享了一个让我们队的足球迷们产生共鸣的例子。我们演示了一个异议检测模型，该模型使用来自 DJL 模型动物园的预训练单镜头检测器模型从图像中识别球员。您可以在 Linux 和 macOS 中运行这个示例。

要在应用程序项目中使用 DJL，用 IntelliJ IDEA 创建一个 gradle 项目并将以下内容添加到您的 build.gradle 配置中。

注意:MXNet 的运行时依赖对于 Linux 和 macOS 环境是不同的。参考 GitHub 文档 。

我们用这个足球图像进行检测。

Source: Offered under Apache-2.0 license on Gluon-CV

我们使用下面共享的代码块运行预测。这段代码从 model-zoo 加载一个 SSD 模型，从该模型创建一个Predictor，并使用predict函数来识别图像中的对象。然后，辅助工具函数在检测到的对象周围布置边界框。

这段代码识别图像中的三名球员，并将结果作为 ssd.png 保存在工作目录中。

该代码和库可以很容易地修改，以测试和运行 model-zoo 中的其他模型。但乐趣不止于此！你可以使用问题回答模型来训练你自己的文本助手，或者使用图像分类模型来识别杂货店货架上的物品等等。请访问我们的 Github repo 获取更多示例。

了解更多并做出贡献

在这篇文章中，我们介绍了 DJL，这是我们为 Java 用户提供最新、最棒的深度学习开发体验的一份微薄之力。我们用预先训练好的模型演示了 DJL 如何在几分钟内从图像中检测出物体。我们在 DJL GitHub 资源库上提供了更多示例和附加文档。

我们欢迎社区参与我们的旅程。前往我们的 Github 仓库并加入我们的 slack 频道开始吧。让我们开始酝酿吧！☕️

引入 flythub——可扩展的开源“点击式”人工智能。

原文：https://towardsdatascience.com/introducing-flytehub-open-source-click-button-ai-that-scales-ffaeb7ebae44?source=collection_archive---------35-----------------------

好得难以置信？

执行机器学习(尤其是大规模)涉及大量的协调和无数的技术。直到最近，这还需要建立针对特定机器学习任务的定制环境。然而，最近的技术进步已经使得创建复杂的机器学习工作流成为可能，这些工作流可以移植到新的环境中，并且只需点击一个按钮就可以运行。

FlyteHub 是一个新的开源机器学习工作流的免费公共注册表。使用 FlyteHub，您可以点击运行任何开源工作流，并大规模执行强大的机器学习，而无需编写任何代码。由于这些工作流是可移植的，它们可以在您的笔记本电脑上运行，或者跨 1000 台机器的集群运行。

想象以下场景:

• 数据科学家编写工作流来执行图像识别。
• 数据科学家意识到其他人可能会从他们的工作中受益，并将工作流上传到 FlyteHub。
• 由于 flythub 工作流是可移植的，任何安装了 flythub 的人都可以点击导入这个开源工作流，执行图像识别，而无需编写任何代码，也无需安装任何额外的包。
• 这些用户可以对项目做出贡献，为每个人改进工作流程。

事实上，FlyteHub 已经有了图像识别的开源工作流。您可以在 5 分钟内运行它们，而无需编写任何代码，甚至可以训练您自己的模型来识别自定义对象。

FlyteHub 现在之所以成为可能，是因为几个行业的进步，包括几周前在 KubeCon 推出的“Flyte”。现在就试试flythehub吧，或者继续阅读，了解今天使开源工作流成为可能的进步的时间表。

在这个过程中，我们将展示如何使用开源工作流来搜寻和捕获难以捉摸的大脚野人(更好地称为“大脚怪”)。

• the target (not to scale)

类似的工作流程可以用于发现“拉撒路物种”(像大村鲸鱼这样的生物，曾经被认为已经灭绝)，或者追踪超稀有的西伯利亚虎，其数量被认为低于 5000 只。

让我们回到 2013 年。

来自 BFRO(大脚野外研究者组织)的数据显示，西雅图郊外的金县出现了多次大脚野人。我们在瞄准点附近的树林里安装了摄像头，每隔几秒钟就会自动拍摄一张照片。

我们没有时间看所有的照片。幸运的是，我们有一位数据科学家，他写了一些 Python 代码，他称之为“大脚探测器”。该代码使用计算机视觉扫描每张照片，并告诉我们它是否包含大脚怪。

我们希望与加利福尼亚的一个团队共享此代码，这样他们也可以使用它。现在是 12 月，报告显示这种生物可能正在向南迁徙。

在 2013 年之前，用户需要在他们的计算机上手动安装所有必要的要求，然后才能使用该代码。

要运行我们的 Python 任务，加州团队必须安装正确版本的 Python，以及所有必需的库。如果任务需要不同的技术，比如 Apache Spark，他们需要确保 Java 和 Spark 已经安装，并且配置正确。

用这种方式创建可移植的“点击式”人工智能是非常困难的，因为每个任务都有一套独特的需求。不同的人工智能任务甚至可能需要同一个库的不同版本。即使对于经验丰富的工程师来说，这也是一种令人沮丧的体验，通常被称为“依赖地狱”。

加州团队没有工程师，我们不想让他们经历依赖地狱。我们需要尽可能多的帮助。世界上的任何人都应该只需点击一个按钮就可以提交他们的照片，并加入追捕大脚怪的行列。

2013:容器彻底改变了我们共享代码的方式

“容器”就像一段代码，捆绑了所有必要的需求。例如，我们的容器可以包含 Python 3.6 版，以及完成我们的大脚探测器任务所需的所有 Python 包。

容器在隔离的环境中运行。如果您在笔记本电脑上启动大脚怪检测器容器，该容器将使用 Python 3.6 运行，即使您的笔记本电脑安装了 Python 2，或者根本没有安装 Python。

当您运行开源 FlyteHub 工作流时，所有代码都在容器内运行。这确保了代码可以在所有环境中可靠地运行。

解决了？没那么快。

某些人工智能任务可能需要很长时间来运行(尤其是在大规模的情况下)。

当我们取回相机时，我们将拥有一百万张照片。如果 AI 代码处理每张图像需要 10 秒，那么计算机完成所有 100 万张图像需要 115 天。

我知道你在想什么:“115 天？！野兽可能在去墨西哥的半路上！”

我们需要更快的反馈。

为了加速这个过程，我们可以使用 100 台计算机，在它们之间分配图像。如果每台机器处理 10000 张图像，1 天就可以完成全部 100 万张照片。

由于代码被打包到一个容器中，您不需要担心在所有这些计算机上安装任何要求，但是，您仍然需要指示 100 台计算机中的每一台运行 Bigfoot 检测器容器。

我们可以编写循环 100 次的代码，告诉每台机器运行容器。但是，如果代码假设正好有 100 台机器，那么代码是不可移植的。

为了让这项人工智能任务具有可移植性，我们的团队应该能够在一天内在 100 台计算机上执行这项任务。加州团队(他们没有 100 台计算机)应该能够在一台笔记本电脑上执行相同的任务，并在 115 天内处理图像。换句话说，代码不需要理解它运行的基础设施。

2015 年:推出 Kubernetes

Kubernetes 是一个在计算机“集群”上启动容器的平台。您的集群可能只有一台机器(您的笔记本电脑)，或者 1000 台机器。

当您指示 Kubernetes 启动 100 个容器时，Kubernetes 会尽快将它们安排在您的机器集群上。

Kubernetes 跟踪有多少机器资源可用。如果您的集群只够同时运行 50 个容器，Kubernetes 将立即启动前 50 个容器。一旦其中一个容器运行完毕，Kubernetes 将检测到现在还有空闲空间，并启动第 51 个容器。随着更多容器的完成，Kubernetes 将继续推出新的容器，直到所有容器完成。

如果您只有足够的资源一次启动一个容器，大脚怪探测器工作流程将需要 115 天才能运行，但它最终会完成。

FlyteHub 开源 AI 运行在 Kubernetes 上。Kubernetes 集群可以小到像笔记本电脑这样的单台机器，也可以是 AWS 中的大型集群。Kubernetes 确保工作流在任一场景下都能成功运行。

解决了？没那么快。

一旦所有这些大脚探测器容器完成，我们有一百万个输出(每个图像一个输出)。我们需要把这些结果结合成有用的东西。

为了解决这个问题，我们可以创建另一个容器来组合来自每个图像处理容器的结果，并寻找积极的结果。

问题是，订购对这个容器很重要。

与可以同时运行的大脚探测器容器不同，我们需要等到所有大脚探测器任务完成之后，才能启动最后一个容器。

这不是容器排序很重要的唯一场景。在运行图像处理之前，我们应该将照片分成小批，以便我们可以为每批照片启动一个大脚探测器容器。我们的逻辑流程如下所示:

• 第一步:将照片分成小批。
• 步骤 2:为每批照片启动大脚探测器容器。
• 第三步:结合第二步的结果，并检查任何积极的结果。

(all steps run inside containers)

数据科学过程倾向于采取类似于这样的“任务”的“工作流”的形式。这些工作流程可能会变得非常复杂。工作流中的任务可能包括数据收集、数据预处理、特征提取、模型训练、模型评估等等。

一些任务(如大脚探测器)可以并行运行。其他任务(如“检查阳性”任务)需要等待前面的任务完成后才能启动。

由于 Kubernetes 对我们的排序逻辑一无所知，它不知道要等待一些任务完成后再开始其他任务。

我们需要一个理解我们工作流程逻辑的“工作流程经理”。“工作流管理器”需要在工作流运行时照看它。当前面的所有步骤都完成后，它应该只在 Kubernetes 中启动容器。为了完成我们的工作流，工作流管理器需要做这样的事情:

1. 告诉 Kubernetes 启动“分割照片”任务。
2. 等待任务完成。
3. 告诉 Kubernetes 为每批启动“大脚探测器”任务。
4. 等待所有大脚探测器任务完成。
5. 告诉 Kubernetes 启动最后一个任务来检查积极的结果。
6. 存储结果，并显示给用户。
7. 用户捕获大脚怪，并与马戏团环游世界。

2019: Lyft 推出 Flyte

Flyte 是使工作流可移植所需的拼图中缺失的一块。

Flyte 引入的一个关键概念是“工作流规范”。工作流规范提供了一种健壮的方式来表达工作流中的逻辑流。

Flyte 中的所有工作流都必须符合该规范。Flyte 可以阅读这些工作流，理解任务的排序，并以正确的顺序在 Kubernetes 上启动它们。

Flyte 不仅理解排序，还理解工作流中的数据流。通常，一个任务的输出成为下一个任务的输入。从工作流规范中，Flyte 明白这一点。

Flyte 确保一个任务的输出可用于下一个任务，即使这些任务运行在完全独立的计算机上。不管我们是在 1 台笔记本电脑上运行大脚怪检测器，还是在 1000 台机器上运行，这些图像识别任务的输出都可以用于“检查阳性”任务。

当我们将工作流上传到 flythehub 时，flythehub 会存储工作流规范。任何大脚猎人都可以导入工作流，提交他们的照片，并获得结果，而不需要了解它如何工作的任何细节。

事实上，该工作流程最近被蒙大拿州的一名家庭研究员用于制作以下照片:

看着这张照片，很明显这种类型的头发只能来自于…神话本人。

结论

今天的帖子只是触及了这些技术所释放的可能性的表面。在后续文章中，我将进一步描述 Flyte 工作流规范，并展示开发人员如何通过将任务组合成超级工作流来利用彼此的工作。

试试 FlyteHub 吧。我希望通过在开源工作流程上的合作，我们可以创造出更好的产品。

敬请关注更新。