原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

统计分布

原文：https://towardsdatascience.com/statistical-distributions-24b5b4ba43cc?source=collection_archive---------10-----------------------

分解离散和连续分布，研究数据科学家如何最有效地应用统计数据。

什么是概率分布？

概率分布是一种数学函数，它提供了实验中各种可能结果出现的概率。概率分布用于定义不同类型的随机变量，以便根据这些模型做出决策。有两种类型的随机变量:离散的和连续的。根据随机变量所属的类别，统计学家可能决定使用与该类随机变量相关的不同方程来计算平均值、中值、方差、概率或其他统计计算。这很重要，因为随着实验变得越来越复杂，用于计算这些参数(如平均值)的标准公式将不再产生准确的结果。

A continuous distribution (Normal Distribution) vs. a discrete distribution (Binomial Distribution)

离散分布

离散分布显示了具有有限值的随机变量的结果的概率，并用于模拟离散随机变量**。**离散分布可以用表格来表示，随机变量的值是可数的。这些分布由概率质量函数定义。

概率质量函数(或 pmf)计算随机变量采用一个特定值的概率:Pr(X=a)。下面显示了一些离散分布的图示示例。对于离散框架中的任何 x 值，都有一个概率对应于特定的观察结果。

连续分布

连续分布显示具有无限值的随机变量的结果的概率范围，并用于模拟连续随机变量**。**连续分布衡量一些东西，而不仅仅是计数。事实上，这些类型的随机变量是不可数的，在一个特定点上连续随机变量的概率为零。连续分布通常由概率分布函数描述。

概率密度函数(或 pdf)是用于计算连续随机变量小于或等于其计算值的概率的函数:Pr(a≤X≤b)或 Pr(X≤b)。为了计算这些概率，我们必须分别在[a-b]或[0-b]范围内对 pdf 进行积分。下面显示了一些连续分布的图形表示示例。可以观察到，这些图具有曲线性质，每个 x 值没有不同的值。这是因为，在任何给定的特定 x 值或连续分布中的观察值，概率为零。我们只能计算一个连续的随机变量位于一个值范围内的概率。还应注意，曲线下方的面积等于 1，因为这代表所有结果的概率。

期望值或平均值

每种分布，无论是连续的还是离散的，都有不同的相应公式，用于计算随机变量的期望值或均值。随机变量的期望值是随机变量集中趋势的度量。描述期望值的另一个术语是“第一时刻”。这些公式中的大部分通常不像人们直观预期的那样工作，这是由于分布将我们置于其中。重要的是要记住期望值是人们对随机变量的期望值。

为了手动计算离散随机变量的期望值，必须将随机变量的每个值乘以该值的概率(或 pmf)，然后对所有这些值求和。例如，如果我们有一个离散随机变量 X，它具有(值，概率):[(1，0.2)，(2，0.5)，(3，0.3)]，那么 E[X](或 X 的期望值)等于(1 * 0.2) + (2 * 0.5) + (3 * 0.3)= 2.1。这个策略可以被认为是对 X 可以假设的所有值进行加权平均。

为了“手动”计算连续随机变量的预期值，必须在 x 的整个定义域上对 x 乘以随机变量的 pdf(概率分布函数)进行积分。如果您还记得，pdf 在整个定义域上的积分结果是值 1，因为这是在假设随机变量在其定义域中的任何值的情况下计算随机变量的概率。这类似于这样一个概念:如果我们将离散随机变量 X 的每个值的所有概率相加，而不乘以 X 的每个对应值，那么总和将等于 1。在积分中乘以 x，可以让我们考虑这个值，就像在离散变量求和中乘以 x，可以让我们考虑这个值一样。当我们将 pdf 乘以 x 时，我们得到了随机变量 x 的所有可能观测值的加权平均值。

差异

每个定义的随机变量也有一个与之相关的方差。这是对随机变量中观察值的集中程度的度量。这个数字将告诉我们观察值与平均值相差有多远。常数的方差为零，因为常数的均值等于常数，只有一个观测值恰好是均值。标准差也很有用，它等于方差的平方根。当计算方差时，想法是计算随机变量的每个观察值离它的期望值有多远，平方它，然后取所有这些平方距离的平均值。方差的公式如下:

开始学习统计和概率的时候，分布的个数和它们各自的公式会变得非常令人应接不暇。值得注意的是，如果我们知道一个随机变量遵循一个定义的分布，我们可以简单地使用它们的均值或方差公式(有时甚至是它们的参数)来计算这些值。然而，如果随机变量并不明显遵循定义的分布，最好使用应用求和与积分的基本公式来计算平均值和方差，或您分析中可能需要的任何其他值，其中随机变量 x 乘以每个观察值的 pmf 或 pdf，并分别求和或积分。为了找到方差，请遵循方差公式，并通过使用与第一个矩相同的程序获得随机变量的第二个矩，但是，用 x 替换 x。例如，有时通过一些检查很容易发现，或者我们被告知某个随机变量遵循某个分布，而其他时候我们只得到可能不熟悉的 pmf 或 pdf，以匹配已知的分布。

随着使用这些随机变量的实践，识别随机变量的 PMF 和 pdf 变得更加容易。能够在实践中快速识别各种分布是有利的，因为它可以节省大量时间，并帮助统计学家和精算师变得更有效率。

然而，对于数据科学家来说，Python 中的 scipy.stats 库为您需要处理的每种概率分布都提供了方便的类，可以用来轻松地可视化和处理这些分布。我们能够生成遵循特定分布的随机变量，并以图形方式显示这些分布。下面显示了使用 Python 代码获得离散和连续分布可视化的一些示例。

First, matplotlib.pyplot and seaborn should be imported

From there, we are able to import the distribution we want to examine, define it’s parameters, and plot the distribution using seaborn’s distplot. Here, we look at the continuous distribution called Uniform Distribution.

Here we examine one of the most common continuous distributions, the Normal Distribution.

Here we look at a discrete distribution called the Binomial Distribution.

Here we look at another discrete distribution that may be less common, the Logser Distribution.

scipy.stats 中还内置了“屏蔽统计函数”,使我们能够快速计算随机变量的不同特征(均值、标准差、方差、变异系数、峰度等。).最后，通过使用这个 Python 库，我们能够轻松地对数据应用不同的变换，例如 BoxCox 变换或 z-score 变换。

我们来连线:

https://www.linkedin.com/in/mackenzie-mitchell-635378101/

[## 麦肯齐米切尔 6 -概述

在 GitHub 上注册您自己的个人资料，这是托管代码、管理项目和与 40…

github.com](https://github.com/mackenziemitchell6)

参考资料:

[## 统计函数(scipy.stats) - SciPy v1.3.0 参考指南

这个模块包含了大量的概率分布以及不断增长的统计函数库。

docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/stats.html#random-variate-generation) [## 教练精算师

你具备成为精算师的条件。我们有备考工具来帮助您有效地利用视频…

www.coachingactuaries.com](https://www.coachingactuaries.com/) [## Python 中的概率分布

概率和统计是数据科学的基础支柱。事实上，机器的基本原理…

www.datacamp.com](https://www.datacamp.com/community/tutorials/probability-distributions-python)

统计学习和知识工程

原文：https://towardsdatascience.com/statistical-learning-and-knowledge-engineering-all-the-way-down-1bb004040114?source=collection_archive---------34-----------------------

结合机器学习和知识库的途径

Photo by Joao Tzanno on Unsplash

Cycorp，Inc .的首席执行官兼 AAAI 研究员道格·勒纳特，在AAAI Make 会议期间，在斯坦福大学 AAAI 之春研讨会上做了一个有趣的主题演讲。

当前的社会趋势与人们受教育程度越来越高的普遍看法相反。的确，事实表明，我们生活在这样一个时代，我们可以看到:

• 平均人口中猖獗的算术(即，对数学相关问题的无知，包括非常基本的概念)，与年龄、性别和社会阶层无关。举个例子，请看这个案例:“为什么我们在麦当劳买 1/3 磅肉和 1/4 磅肉要花同样的钱？你多收了我们的钱。”
• 与现实和知识的联系减少，最终导致对事实的无知(因为你可以依靠谷歌！)
• 人们普遍不相信存在(并且可能存在)一个真实的客观现实
• 假设问题的答案总是可用的，

今天，人们依靠机器获取知识，而当前的引擎不具备将来自许多不同来源的知识整合在一起并得出结论或答案的逻辑。

Photo by Lacie Slezak on Unsplash

例如，埃菲尔铁塔比美国国会大厦高吗？在谷歌上无法完全自动找到答案，因为没有现有的网页明确讨论这一点，尽管答案的各个部分都是可用的。

这是由于机器学习的困难:

• 专家对结果意见不一的情况
• 确认偏差的风险
• 荒谬的答案或中间结论
• 可用的少量数据
• 当答案暗示“常识”时
• 当顶级专家比普通人强很多的时候

对于理解问题和答案，机器学习可以对人类生成的文本(从社交媒体到莎士比亚的情节，如罗密欧与朱丽叶)做一些事情，通过使用不同的有限逻辑:从命题逻辑到完全一阶逻辑。但是，相对于随便阅读文本或观看情节表演或电影的人所能回答的问题而言，人类能够提出和我们能够回答的问题的数量是极其有限的(至今仍然如此)。最重要的是，有一个悬而未决的问题，人工智能很难回答:为什么？

大多数时候，一阶逻辑的计算速度不够快(更不用说二阶或更高阶逻辑了)。

Doug 提出的想法包括将推理中的两个重要成分分开，以处理表达能力和效率之间的权衡:

• 认识论方面
• 启发式方面

通过将两者分开，您可以将非常高效的语言用于启发式部分，而将非常强大(和不太高效)的语言用于认识论部分。因此我们在游戏中有两种语言:启发式层次语言(HL) 和认识论层次语言(EL) 。

对推理的另一个有趣贡献是语境:语境应该是知识过程中的一等公民，因为知识在不同的语境中可能是不同的。

该系统能够使用溯因推理(或溯因推理)来提出答案中可能的可能性，例如为什么故事中会发生什么。

这与道格和赛克公司的历史有关。早在七十年代，斯坦福的一群朋友就在为人工智能概念而奋斗。他们决定加入逻辑、人工智能和专家系统，并致力于解决 EL-HL 分裂的工作方法和工程解决方案。

这项工作主要是通过教授事实和逻辑规则来教育系统，然后设计推理方法，该项目历时 30 年，预算超过 200 MLN 元，能够建立包含数亿条断言的知识资产。

将机器学习和知识库结合起来的途径是利用它们潜在的协同作用。

Google doodle about Bach’s music, where ML was not combined with KE.

实际上，这包括以下选项:

• 实现商定的自定义 API
• 使用知识库作为机器学习系统的大量训练数据的生成器。因为我们知道 80%的事实实际上可以从三重模型中产生，这已经是一笔巨大的财富了。
• 使用机器学习来生成假设，然后使用知识库来检查不良形式或矛盾(可以使用这种方法的一个例子是改进最近关于巴赫音乐的谷歌涂鸦，其中巴赫风格的一些基本概念化可以避免生成的音乐中的重大错误，这产生了音乐专家的巨大反斜杠)。

但是 AI 和 KB 结合的实际价值真的更广阔。

这一贡献的主要长期破坏性影响之一是使分析能力从相关性转移到因果关系成为可能。这可能会给整个领域带来全新的味道。

Photo by dylan nolte on Unsplash

这个故事的灵感来自于 Cycorp，Inc .的首席执行官兼 AAAI 研究员 Doug Lenat 在斯坦福大学 AAAI 之春研讨会上的一次演讲。

统计建模——实用指南

原文：https://towardsdatascience.com/statistical-modeling-the-full-pragmatic-guide-7aeb56e38b36?source=collection_archive---------14-----------------------

第 2 部分—解释机器学习模型

继续我们关于如何解释机器学习算法和预测的系列文章。

About the importance of explaining predictions.

第 0 部分(可选)— 什么是数据科学和数据科学家
第 1 部分— 可解释性介绍
第 1.5 部分(可选)— 统计学简史(可能对理解本帖有用)
第 2 部分—(本帖)解读高偏倚和低方差模型。线性回归。
第 3 部分——解读低偏差和高方差模型。
第 4 部分——有可能解决偏倚和方差之间的权衡吗？
第 5 部分——可解释性的本地方法。
第 6 部分——可解释性的全局方法。利用沙普利终于打开了黑盒！

在本帖中，我们将关注高偏差和低方差模型的解释，正如我们在上一帖中解释的，这些算法是最容易解释的，因此假设数据中有几个先决条件。让我们选择线性回归来代表这组算法。如果你不知道什么是线性模型，你可能想看看文章统计简史。

该职位的所有代码可在 Kaggle 上获得。

这里的目的不是解释这些线性模型是什么或它们是如何工作的，而是如何解释它们的参数和估计，但简单介绍一下可能会有帮助。线性模型可以是简单回归，如 OLS，可以是常规回归，如拉索和岭，
它们可以是分类模型，如逻辑回归，甚至是时间序列模型，如 ARIMA 过滤器。它们都有一个共同的事实，即它们具有线性参数，也就是说，当我们估计变量的“权重”时，它们对于任何水平都是恒定的。有趣的是，如果神经网络的激活层是线性的(f (x) = x)，它也可以是线性模型，这样的单层网络将类似于我们在这里使用的简单线性回归，但效率低得令人难以置信。

Linear models, well Spacious, high bias and low variance and Neural Networks that adapt to any behavior.

让我们创造一个理论世界，在那里我们有兴趣解释各种变量对人们收入的影响。在我们假设的世界里，我们的最低工资是 1000 美元，每受一年教育，月薪平均增加 500 美元。因为我们的世界是随机的(不是确定性的)，所以我们有随机性。

ScatterPlot Salary x Education

运行回归模型时，我们得到产生最小可能误差的直线:yhat = x * 496 + 1084。也就是说，该模型能够“理解”我们创建的现实，并估计斜率系数约为 496(非常接近创建的 500 美元),截距约为 1084，这种情况下的解释非常简单。他确定了最低工资(当教育等于零时)和当一年的教育改变人们的收入时，500 美元。

Best fit line (which produces the smallest error).

但是这个案例很简单，离现实很远。顺便说一下，这种情况非常类似于高尔顿在十九世纪创建的模型，相关系数’ R '与 R 相同(只是平方)。在现实世界中，我们有许多解释工资的变量，所以让我们在这个模型中插入更多的变量。

在我们的“世界 v2”中，我们将有以下更像现实的行为:

*工资由以下三个部分解释:

• Grit =范围从 0 到 16 的随机变量。
  -教育=从 0 到 16 的随机变量+努力的一部分，因为努力影响你自己受教育的程度。
  -实验=从 0 到 25 的随机变量。*

=毅力 * 200 +经验 200 + 学历 * 300 +随机部分*

查看变量之间这些关系的一种方法是通过热图中的关联图:

HeatMap with correlations between variables

看第一列，我们会认为最重要的变量是毅力/爪，因为它与工资的相关性最高，我们会说经验和教育有几乎相等的影响。

显示变量之间行为的另一种方式是通过图表，这是我更喜欢的方式，但仍然不能普及，其中每个节点都是一个变量，边的颜色强度是它们相关性的“强度”:

Alternative way to represent the correlations between the variables, developed by the author.

我们可以更清楚地看到，工资是中心变量，教育和爪是相互关联的，所以通过估计爪和工资的相关性，我们可能捕捉到了教育的一部分效果，高估了爪的效果，低估了爪的效果。教育。我们说这种相关性被“污染”了。
如何解决？

偏相关

解释线性回归的一大诀窍是理解偏相关是如何工作的。如果你深刻理解这一点，那么开始做另一篇文章主题的因果分析就成功了一半。要做到这一点，让我们用维恩图创建一种“统计语言”，如下所示:

• 每个圆圈代表一个变量。
• 圆圈的大小代表这个变量的方差；
• 圆圈之间的交点代表这些变量的协方差。我们可以解释为相关性而不失一般性。

Venn diagram representing Variance and Covariance.

我们如何解读这种表述？基本上，工资有一个方差，可以用教育和毅力来解释，但由于教育和毅力是相关的，它们可以解释相同的方差，即有重复计算。当我们使用这种偏相关时，基本上我们正在做的是扔掉这种重复计算，只捕捉纯相关性，它与任何其他模型变量都不相关。在这种情况下，我们将使用由 Grit 和 Educ 解释的数字 100，我们将只留下 200 (Grit -> $)和 300 (Educ -> $)。这正是线性回归为我们做的:

Each column is a model that has been run and each row is a variable. Values ​​are estimates for the effect of variables.

让我们播放它。当在没有教育变量或没有砂砾变量的情况下回归时，我们注意到它们捕捉到了彼此的影响，即，为了预测工资，移除变量不会干扰太多，因为它们是相关的，部分影响被剩余的变量捕捉到了。为了解释这些影响，理想情况下，我们把所有重要的变量都放进去，否则估计的影响会被污染。在 Exp 变量的情况下(它是在与其他变量不相关的情况下构建的)，部分相关性与传统相关性非常相似，因为没有联合效应。使用文氏图:

Venn diagram showing orthogonal / independent variables.

统计建模及其解释。

正如我们多次重复的，这个模型有许多先决条件，所以让我们开始分解它们并解释它们。

非线性行为。

最强有力的假设之一是，变量(X)对目标(y)的回报必须是常数，因此线性模型的名称(因为估计的参数是线性的)。但是如果行为不完全是线性的呢？我们必须求助于其他模式吗？简单的回答是否定的，
我们可以通过对问题建模来理解非线性。让我们来看例子:

让我们想象一下，相对于工资，教育回报率不再稳定，而是实际上达到峰值，然后开始下降。也就是说，它不仅不会永远增加，而且增加的速度会降低，直到发生逆转。这是一个非常容易接受的假设，可以用真实数据观察到。在估计这个新现实的线性模型时，我们有一个相当奇怪的结果:

Adjustment of a linear regression by a quadratic behavior. Don’t mind the numbers, it’s simulated data.

看起来不太合适，对吧？这在问题的本质中是很常见的，我们的影响会随着变量的变化而变强或变弱，我们处理它的方式是通过两次添加教育变量，一个线性(原始)部分和一个二次部分，因此线性模型可以理解非线性行为:

Linear Regression Adapting to Nonlinear Behaviors

由于模型继续估计偏相关，为了解释这些变量，我们需要同时考虑教育的两个部分，估计的线性和二次部分是:648 和-32，而实际数据是 600 和-30。例如，我们可以通过取曲线的最大值来计算使工资最大化的教育程度。

弹性模型。

另一个非常常见的非线性效应的例子是，变量不是具有恒定的名义效应，而是具有恒定的百分比效应。一个例子是估计人数(X)对面包店产量(y)的影响。如果只有一个员工，生产率就很高。当你多雇一个人，产量就会增加很多，他们可以轮流工作，而一个人满足另一个人补充库存，等等。随着我们增加更多的员工，生产率在下降，增加第十个员工不再那么有效率，而是增加了产量。我们称之为边际递减效应，对此问题建模的一种方法是应用自然对数(ln)。当你有 1 个员工时，多一个员工是 100%的增长，而当你有 10 个员工时，多一个员工只是 10%的增长。
除了纠正这种百分比增加行为之外，日志记录还有助于减轻左侧不对称分布、异常值的影响，并且通常会将这种分布转换为与正态分布非常相似的分布。

通过对数变换后，我们如何解读这个新变量？基本上是百分比变化而不是名义变化。让我们来看例子:

Histograms of the annual salary variable. No logging in the left corner and logging in the right side. The interpretation must be a percentage interpretation!

当我们对 1990 年的工资进行回归时，会发生两件事。首先是 R2 从 0.065 增加到 0.125(翻了一倍！)，意味着我们的建模走上了正轨。但是当我们看教育的估计值时，我们看到它从 300 到 0.0062，如何解释它呢？百分比变化！新的解释是，多受一年教育而不是增加 300 美元的工资，这个模型增加了 0.0062%，我们称之为对数水平，估计值变成了半弹性。如果我们记录这两个变量，这将是一个逻辑模型。记录和解释将是:对于教育 1%的增长，增加变量 y 的估计百分比值。我们称之为效应弹性(等于我们在定价团队中经常看到的价格弹性)。

分类变量

我们已经从其他模型中知道了如何添加分类变量，我们需要将其建模为虚拟变量(0 或 1)并用这个新变量进行回归，让我们在我们的工资模型中创建一个这样的变量，它将代表该个人是否出生在巴西，因为我们的制度不是最好的，对于具有相同经历、教育和努力的同一个人来说，在巴西生活的“仇恨”是(在我们的理论世界中)1000 美元。

ScatterPlot representing the actual (blue) points and the red predicted values. The differences between the lines is caused by the dummy that affects only the intercept and not the inclines.

请注意，预测值是平行的，这表明线的斜率完全由教育给出，出生或不出生在巴西只是将整个曲线下移。

假人超级强大，可以帮助控制许多复杂的效果，包括时间，但这是一个因果张贴的问题。

变量之间的相互作用。

最后，我们需要纠正一个相当复杂的自然行为，即变量之间的相互作用。这方面的一个例子是前一种情况，不管其他变量如何，教育回报率是一样的吗？在巴西生活与否应该不会影响这次回归吧？如果是这样的话，这个模型，因为它非常简单，它不理解这个行为，我们需要再次建模，以便模型能够理解。

在我们的示例中，变量“巴西”将与变量 Education 交互。为了让模型理解这种行为，我们只需要创建第三个变量，它是两个变量的乘积。请注意，我们乘以 1 和 0，因此当观察值等于 1 时，新变量将具有重复教育列，否则将为零，回归结果如下:

Inclination of the return of education interacting with the variable “Brazil”, making the inclination different for each situation.

允许模型与两个变量相互作用允许教育的回报因情况而异。现在的解读将是，虽然出生在巴西有负面影响(保持一切不变)，但巴西的教育回报比巴西以外更高(线更倾斜)。也就是说，我有一个估计的教育倾向(例如 300)，一个估计的巴西出生率(例如-1000)，一个估计的巴西人的教育价值(例如 50)，当我们想要分析巴西的教育回报时，我们需要加上 300(来自每个人)+作为巴西人的回报 50。

所有代码和图形都可以在 Kaggle 中找到。

帖子系列:

• [统计简史](http://A Brief History of Statistics)；
• 为数据科学家推荐书籍、课程和电影。
• 数据科学 的范围是什么；
• 解释机器学习。

LinkedIn GitHub

线性回归的统计概述(Python 中的示例)

原文：https://towardsdatascience.com/statistical-overview-of-linear-regression-examples-in-python-80a38680e053?source=collection_archive---------4-----------------------

在统计学中，我们经常寻找方法来量化现实生活中的因素和反应之间的关系。

也就是说，我们可以把我们想要理解的反应大致分为两种类型:分类反应和连续反应。

对于分类案例，我们正在研究某些因素是如何影响我们在一组选项中做出哪种反应的决定的。

例如，考虑一个关于脑瘤的数据集。在这种情况下，这些因素包括肿瘤的大小和患者的年龄。另一方面，反应变量必须是肿瘤是良性的还是恶性的。

这些类型的问题通常被称为分类问题，实际上可以通过一种称为逻辑回归的特殊类型的回归来处理。

然而，对于连续的情况，我们正在观察我们的因素在多大程度上影响我们的反应变量的可测量的变化。

在我们的特定示例中，我们将查看广泛使用的波士顿住房数据集，该数据集可以在 scikit-learn 库中找到

虽然该数据集通常用于预测性多元回归模型，但我们将专注于统计处理，以了解房间大小增加等特征如何影响住房价值。

模型符号和假设

线性回归模型表示如下:

其中:

为了“拟合”线性回归模型，我们建立关于随机误差的某些假设，一旦这些假设适用，这些假设将确保我们对实际现象有一个很好的近似。

这些假设如下:

探索性研究

为了这个模型的目的，我们将把 MEDV 作为响应变量。MEDV 是以 1000 美元为单位的自有住房的中值

在这里，我们将会看到在 y 轴上有 MEDV 的那一行。也就是说，我们将查看房屋价值与数据集中所有其他要素之间关系的散点图。

你可以在这里找到所有数据集名称的完整描述:
https://www . cs . Toronto . edu/~ delve/data/Boston/Boston detail . html

All Features vs the Median Value of Owner Occupied Homes

一个特别突出的线性关系是每个住宅的平均房间数(RM)。

让我们仔细看看:

简单线性回归

最简单的线性回归形式只包含截距和单因子项。

在这种情况下，我们将使用最小二乘法拟合模型。

最小二乘法

当我们说“适合”模型时，我们的意思是找到最适合给定数据的因子项的估计值。在回归的情况下，这意味着我们找到最小化回归线和每个观察数据点之间距离的距离。

也就是说，我们将平方误差降至最低，数学上表示为:

其中 sigma 是数据集中所有行的总和。

下面是我们如何使用 python 库 statsmodel 拟合模型。

我们首先导入库:

import statsmodels.api as sm

我们现在准备安装:

请注意，我们必须添加一列称为“截距”的数字。

这是因为我们可以使用线性代数重写我们的模型，以便:

所以 1 列是 X 矩阵的第一列，所以当我们乘以因子系数向量时，我们得到了每个方程的截距值。

这种形式用于扩展多元回归的情况，但我们不会在本文中广泛涉及这种数学。

适合摘要

slr_results.summary()

这些是因子系数的估计值。考虑截距术语的解释通常是没有意义的。例如，在我们的例子中，截距项与房子有 0 个房间的情况有关…房子没有房间是没有意义的。

另一方面，RM 系数有很多含义。它表明，每增加一个房间，业主自住房屋的中值就会增加 9102 美元。

P > |t|: 这是一个双尾假设检验，其中零假设是 RM 对 MEDV 没有影响。由于 p 值很低，接近于零，因此有强有力的统计证据来否定 RM 对 MEDV 没有影响的说法

**R 平方:**这是模型解释的方差，通常被认为是对模型拟合程度的衡量。然而，这个因素可以被抛弃，因为它可以通过增加因素的数量而被人为地夸大，即使这些因素并不重要。因此，我们还必须考虑调整的 R 平方，它调整计算以适应因子的数量。然而，在简单的线性回归中，这两者是相同的。

How our line fit’s the data

多元线性回归:

当我们加入其他因素时会发生什么？

既然我们没什么别的事可做，为什么不干脆把它们都扔了呢
(免责声明:也许你不应该在家里尝试……尤其是如果你有成千上万的功能…)

• 除了 CHAS:因为它是二进制的*

好吧…我为那张汇总表有多长而道歉:/

请注意，R 平方和调整后的 R 平方显著增加。然而，也请注意，现在有一个强有力的统计证据支持它不影响 MEDV 的说法。

这一特点是年龄，我们将删除它从我们的模型和改装。

我们将继续修剪和比较，直到我们有所有的统计显著特征。

Red: Dropped, Black: R-squared, Green: Adjusted R-squared

正如我们所看到的，列 Age 和 Indus 对模型的拟合没有贡献，最好不要考虑它们。

Prob(F-statistic): 是与整体模型的显著性检验相关联的 p 值。在这种情况下，零假设是模型总体上不显著。由于我们的值远低于 0.01，我们可以拒绝零假设，而支持另一种选择，即该模型具有统计学意义。

**注意 * *

对于多元线性回归，β系数的解释略有不同。

例如，RM coef 建议，对于每一个额外的房间，我们可以预期自有住房的中值增加 3485 美元，所有其他因素保持不变。还要注意，系数的实际值也发生了变化。

模型诊断

此时，您可能想知道我们可以做些什么来提高模型的拟合度。由于 adj. R-squared 为 0.730，当然还有改进的空间。

我们可以考虑的一件事是，我们可以向数据集添加哪些对我们的模型可能很重要的新功能。

除此之外，我们还需要进行测试，看看首先应用线性回归实际上是否合理。

为此，我们寻找剩余图。

这里的好处是残差是对模型中随机误差的一个很好的估计。也就是说，我们将能够绘制残差与特征(或预测值)的关系图，以了解残差的分布情况。

我们预计，如果模型假设成立，我们将看到一个完全分散的图，点的范围在某个恒定值之间。这意味着残差是独立的，正态分布的，具有零均值和恒定方差。

standard residual plot

然而，在我们的单反案例中，我们有 RM

这里我们可以看到，有一些非线性模式的迹象，因为残差图似乎在底部是弯曲的。

这违反了我们的模型假设，我们假设模型具有恒定的方差。

事实上，在这种情况下，方差似乎是根据其他函数而变化的。我们将使用 box-cox 方法来处理这个问题。

我们可以通过创建一个 QQ 图来进一步检验我们的正态性假设。对于正态分布，QQ 图将趋向于直线。

但是请注意，这条线明显是倾斜的。

博克斯-考克斯方法

这是一个过程，通过这个过程，我们可以找到最合适的变换的最大似然估计，我们应该应用于响应值，以便我们的数据能够具有恒定的方差。

使用 scipy.stats 实现后，我们得到的 lambda 值为 0.45，我们可以将它用作 0.5，因为它不会在拟合方面产生巨大的差异，但它会使我们的答案更具可解释性。

import scipy.stats as stats
df.RM2,fitted_lambda = stats.boxcox(df.RM)

下面你会发现一个常见的 lambda 值及其建议的响应转换表。

Common Lambda Values — taken from statistics how-to

此后，我们相应地改变我们的回应:

df.MEDV2 = np.sqrt(df.MEDV)

然后我们将模型拟合到 MEDV2，它是 MEDV 的平方根。

在特征数量相同的情况下，我们的 R 平方值和调整后的 R 平方值都上升了不少。有点酷吧？

此外，我们的剩余地块也有一些改进:

此外，我们还可以尝试将我们的转换应用于特征变量的每个

X = df[['intercept','CRIM', 'ZN','NOX', 'RM','DIS', 'RAD',
       'TAX', 'PTRATIO', 'B', 'LSTAT']]
X2 = X.apply(np.sqrt)

然后，我们拟合由 X2 作为我们的特征矩阵和 MEDV2 作为我们的响应变量组成的模型。

在这里，我们看到在相同数量的特性下，这些值有了更大的提高。

我们最后的剩余图看起来像这样:

所以很明显还有改进的空间，但是我们确实取得了一些进步。

一些附加说明

回归模型的统计理解还有更多的部分。例如，我们有可能得出围绕每个节拍系数甚至围绕我们的预测值的置信区间。

此外，关于 *CHAS，*由于它的{1，0}编码，包含 chase 也没问题。对于更多的选项，除非选项有自然的顺序，否则很难或不可能解释贝塔系数。当我们用 chas 拟合最终模型时，调整后的 R 平方为 0.794。在这种情况下，对β系数 0.077 的解释是:

如果房屋区域毗邻查尔斯河，那么在所有其他因素保持不变的情况下，业主自住房屋的中值将比未毗邻查尔斯河的房屋高出 77 美元。

结论

我希望我能够让大家明白回归不仅仅是基于某些特征进行预测。事实上，有一个回归分析的世界致力于使用这些技术来更深入地了解我们周围现实世界中的变量。

用于比较机器学习和基准性能的统计测试

原文：https://towardsdatascience.com/statistical-tests-for-comparing-machine-learning-and-baseline-performance-4dfc9402e46f?source=collection_archive---------5-----------------------

当将机器学习方法与当前解决方案进行比较时，我希望了解任何观察到的差异是否具有统计显著性；这不太可能仅仅是由于数据中的偶然因素或噪声。

评估统计显著性的适当测试取决于您的机器学习模型预测的内容、数据的分布以及您是否正在比较对主题的预测。这篇文章强调了常见的测试以及它们适用的地方。

零假设统计检验

零假设统计检验用于比较两个数据样本，并计算在更广泛的人群中观察到的数学特征的感知差异(例如，不同的平均值)的统计置信度。

尽管对零假设显著性检验有持续的批评，但它仍然是最常用的验证技术。

虚假设

零假设是两个数据样本的分布之间不存在差异的陈述；任何差异都是由于噪音或偶然因素造成的。

就机器学习而言，我们的零假设是性能指标相等，观察到的任何小的增益或损失在统计上不显著。

p 值

测试表明我们是否应该拒绝，或者拒绝不存在差异的无效假设。下面讨论的统计检验倾向于提供检验统计量和 p 值。

如果 p 值低于给定的阈值(通常为 0.05)，我们可以拒绝零假设，并推断差异具有统计学意义。

商务口译

如果您正在将您的机器学习解决方案与当前基线进行比较，并且您看到了性能的提高，那么这一显著提高是一个好消息！

类似地，如果您使用这些技术来测试某个特定的模型是否比另一个模型表现得更好，这可以指导您决定继续使用哪个模型。

如果您不能拒绝零假设(p 值大于或等于阈值)，则两个数据集之间的任何观察到的效应或差异都不具有统计显著性。如果您正在尝试自动执行一项任务，匹配当前的手动性能就足够了，这可能是一个积极的消息。但是，如果成功的标准是超越当前场景，没有统计上的显著性差异意味着您不太可能看到将该模型用于生产的好处。

假设

数据分布

当对回归模型使用假设检验时，区分应该使用参数检验还是非参数检验是很重要的。参数检验是首选，因为它们通常比非参数检验具有更大的统计功效；这意味着他们更有可能检测到统计上的显著影响，如果存在的话。然而，这些测试假设数据是正态分布的；如果这个假设不成立，就必须使用非参数检验。

If you plot error values, it is likely they will be of a non-normal distribution

当您比较误差值时，它们很可能是向左倾斜的:大多数误差都很小，随着误差值的增加，频率会降低。如果你要绘制你的数据，你也许可以直观地解释它，但是也有正态性检验，你可以用它来进行数学上的确认。

成对或不成对观察值

如果为每个模型从相同的受试者收集数据，这被称为“配对”。在机器学习中，这意味着基线和训练模型的测试数据是相同的。

从两个独立组收集的数据被称为“不成对的”。这在科学研究或 A/B 测试中很常见，当你比较一个对照组和一个治疗组时。

适当的统计测试

回归

如果您的机器学习模型正在预测数值，则误差度量往往是以下之一:

• 均方误差
• 平均绝对误差
• 平均绝对百分比误差(MAPE)
• 加权平均绝对百分比误差

当使用假设检验来比较平均误差时，您看到的是误差来自同一分布的可能性；如果可能性足够低，则两个平均误差值之间的差异具有统计学意义。

对于正态分布的数据，两种合适的测试要么是学生 t 检验要么是韦尔奇 t 检验。它们都检验两个总体具有相同的均值，但 Welch 的 t 检验更可靠，因为方差或样本量存在差异。根据观察值是成对的还是不成对的，有两种实现方式。

两个非参数检验是曼-惠特尼 U 检验或威尔科克森符号秩检验，这再次取决于观察值是否成对。

分类

如果您的机器学习模型预测一个实例属于哪个类，则误差度量往往是以下之一:

• 准确(性)
• 精确
• 回忆
• f1-分数

虽然您的企业必须决定应该优先考虑哪个指标，但是分类模型最常用的技术只是评估错误的比例是否有显著差异。如果您明确希望测试精确度或 F1 分数的统计显著性，则需要进一步的研究。

分类模型可以是二元的(例如搅动的或未搅动的)，也可以是多类的(例如体育、政治或科学)。对于二元分类模型比较，合适的测试是麦克内马测试，而对于多类，合适的测试是斯图亚特-麦克斯韦测试。

算法比较和超参数调整

当评估一个模型相对于基线(或者另一个模型)的结果时，使用上述指标。

当评估不同的算法或超参数时，通常使用 k 倍交叉验证。这允许您训练和测试 k 模型，并收集它们的评估指标，使用它们的平均值作为算法性能的指示。如果对两种算法都这样做，可以使用统计测试来比较这两种方法。

例如，如果要比较逻辑回归模型和随机森林模型。你可以把数据分成 10 份，训练 10 个逻辑回归模型和 10 个随机森林模型。这两个模型将分别具有 10 个相应的性能度量值(例如准确性)，然后可以将这些值传递给统计测试，以查看任何观察到的差异是否具有统计显著性。

随着 k 重交叉验证对数据进行重新采样，训练集之间存在重叠。这意味着这些值不是独立的，这通常是统计假设检验的一个假设。因此，两种最常见的技术是使用修改的 t 检验的 5x2 交叉验证和麦克内马检验。

统计学家证明统计很无聊

原文：https://towardsdatascience.com/statistician-proves-that-statistics-are-boring-4fc22c95031b?source=collection_archive---------0-----------------------

用细致入微的词汇回归基础

我要给你看一个逻辑证明，统计学很无聊…为了帮助你们理解像我这样的统计学家进行的所有那些花哨计算的点。作为一个额外的奖励，这几乎是你在大多数 STAT101 课程的第一天所学到的，所以它也是对统计数据好奇的间谍任务。让我们从沉湎于一些本地术语开始。

This statistician is about to prove that statistics are boring. Pulling faces all the while — I’m still learning how to use my face. Humaning is hard. Come pull a face back at me here if you like.

人口

当典型的人类想到“人口”这个词时，他们会想到什么？人，对吧？不是一两个，而是很多。所有的人！在我们的学科，更像是所有的事情。一个群体可以是人、像素、南瓜、神奇宝贝，或者任何你感兴趣的东西。

群体是我们感兴趣的所有项目的集合。

停下来。花点时间。你现在看到的是处于整个追求核心的法律合同。

事情是这样的:通过写下对你的人口的描述，你同意只有人口，整个人口，除了人口之外没有任何东西对你的决定感兴趣。通过进一步阅读，您接受这些条款和条件。(正如你所料，这篇博客详细描述了大量的人口。在这里找到更多的沉思。)

如果列出你感兴趣的人群听起来令人生畏，请记住，选择你感兴趣的内容是由你自己决定的。没有不正确的选择，只要具体彻底。我会说得很透彻，我会给你一千个单词:下图中的树木是我们对这篇文章感兴趣的人群。

If my population is all trees in this forest, they represent everything I care about for this decision. I’m getting pretty excited about these trees. Actually, to be quite honest with you, the excitement is real: I’m irrationally fond of this graphic because I’ve been using it in my lectures for many years. Allow me my misguided nostalgia just this once… of course trees floating on some planes in space make perfect sense.

因为这是我的种群，我应该记住我没有理由放弃我的分析，因为我相信我已经了解了其他森林中的树木。我的发现充其量只能应用于这些树。在最坏的情况下，嗯…我们只能说在一个数据科学家的一生中可能会有一些塑造性格的时刻。

这里有你看不见的树吗？对你来说死了，没意思。它不是我们人口的一部分。随便挑一棵树？对你也一样。一样无聊。这不是你的全部人口。只有他们所有人(一起！)对我们来说很有趣。这是法律合同上说的。

样品

样本是总体中任何项目的集合。

样本是你拥有的数据，总体是你希望拥有的数据。

Either of these orange collections of trees is a sample. I hope you have some intuition as to which one is the better one here. In a future article, I’ll tell you all about what makes a sample a good sample. I’m going to use the one that irritates professionals for the rest of this example to prove a point.

观察

观察值是对样本中一个单一项目的测量。

The measurement we took from this blue-labeled tree is an observation. Sticklers for precise language will notice that a “sample” is a collective noun for a group of observations. Technically, “samples” as a plural does not mean “observations”, it means “multiple collections of observations.”

统计的

啊哈！统计！这肯定是重要的事情，因为我们以这些事情命名了我们的学科！

统计是将样本数据混合在一起的任何方式。

那么…什么是统计？这只是将我们现有的数据进行混合的一种方式。多么令人失望！提示悲伤的长号噪音。事实证明，统计学和统计学学科是两码事，在这里阅读全部相关内容。

Example of a statistic: if we’re interested in tree heights, you wouldn’t be surprised to see a statistic like the average height of all those orange-labeled trees. If you feel like it, though, you could also take those sample tree heights, find the top three, add them up, take the log, add to it the square root of the difference of the bottom two tree heights, send the whole unholy thing through a meat grinder… and out pops another statistic! Maybe useful, maybe not so useful, but also a statistic.

证明统计数据很无聊

假设我们感兴趣的是平均树高，在这个例子中恰好是 22.5 米。这个数字对我们来说有意思吗？

我们再回头参考一下我们签约的法律合同:只有人口才是有趣的。这个样本是人群吗？没有。因此，我们对此不感兴趣。我们从一些无聊的树上取了一些无聊的测量值，然后我们把这些无聊的测量值搅成糊状……这个过程产生的结果也是无聊的。

所以我向你们证明了你们心里一直都知道的:统计很无聊！神盾局。

用词不当！

统计学家疯了吗？为什么我们要用一些无聊的数字来命名我们的学科？其实是用词不当。

我们这些天使用这些术语的方式是，分析是关于计算统计数据的学科，但统计是关于超越那些数据混乱的*——一个伊卡洛斯式的飞跃进入未知(如果你不小心的话，预计会有一个大的冲击)。在此了解更多关于数据科学的子学科。*

我们学科的真实名称(从你可以用来召唤巫师的真实名称的意义上来说)会更冗长:统计的消化… 但是这听起来有点粗俗，所以我们把它缩短成一些通俗易懂的东西。(由于我们脾气暴躁的名声，我们需要尽可能的平易近人。)

让我解释一下。

参数

进入我们节目的明星: 参数 。这东西太花哨太闪亮了。演出结束后，它会收到一束鲜花，通常还会收到自己的希腊字母(通常是 θ )。您可以将参数视为统计数据的总体版本—参数是将所有感兴趣的数据组合在一起的任何方式，我们通常无法访问 IRL。

一个参数为您汇总了总体。

我们一致认为，我们对这些树深感兴奋，现在我将为你总结你所关心的一切？安静点，你的小心脏！参数让你如此激动！

Parameter value revealed: the true average height of all the trees just so happens to be 21.1 meters.

想象一下，这是一个星期六的早晨，你正站在森林中的一块空地上。你还没有测量过任何树木，但是你真的很想知道这个数字——这是你梦寐以求的一切。(通过法律合同，即。一旦我们写完这篇文章，你就可以回到正常人的生活中，对生活有其他的兴趣。)

要知道这个参数需要什么？

你必须准确无误地测量所有的树！一旦你做到了，你还有什么不确定的吗？不，你有所有的信息。你可以通过使用分析来结束——继续计算平均值。那么统计量 就是 这个参数，因为你的样本 就是 这个总体。你处理的是纯粹的 事实 。由于拥有完善和完整的数据，不需要复杂的计算。

我碰巧住在纽约市——是我自己选择的！离树越远越好。因此，当我面临“完美地测量所有这些树”这样令人生畏的任务时，懒惰就开始了我很想知道这个参数，但是我开始思考，“我真的需要完全了解它吗？或者我可以只测量几棵树吗？也许我可以只看一眼全貌，就能得出一个对政府工作足够好的参数的最佳猜测。

当我以这种方式思考时，我是在以统计学的方式思考！我永远不会知道答案。我的懒惰意味着我不得不放弃获取事实或确定性，但希望我最终会得到一些仍然对做决定有合理帮助的东西。我仍然可以把它变成一个合理的行动。那就是统计学的全部内容。

Speaking of measuring trees perfectly, this photo on Reddit made me laugh. The caption was: “My brother wanted to measure the trees in his yard. This is how did he did it.”

无中生有？

你们中的一些人希望我会说，“有了 这个 的神奇公式，你就能把不确定性变成确定性！”没有，当然没有。没有无中生有的魔法。

当我们没有事实时，我们所能希望的就是结合数据和假设来做出合理的决定。

假设

一个假设是关于宇宙可能看起来如何的描述，但它不一定是真的。我们将弄清楚我们的样本是否让我们的假设看起来荒谬，以确定我们是否应该改变我们的想法，但这超出了这篇博文的范围——在这里继续讨论。

Here I am, uttering some uninformed garbage like “The true average height of all the trees is less than 20 meters.” That’s a hypothesis. You know the truth (I’m wrong!) because you’re omniscient in this example …but I don’t know anything. My statement is a perfectly valid hypothesis, describing how reality might potentially look. I’ll see how I feel about it after I get some data.

估计和估算者

如果我们知道参数，我们现在就能回家了。我们寻找的是事实，但不幸的是事实并不总是存在的。由于我们无法计算参数，我们只能使用统计数据对其进行最佳猜测。

估计只是一个最好的猜测的花哨词。

估计只是一个关于参数真实值的 最佳猜测(估计命令)的花哨词语。它是你猜测的值，而估计值是你用来得出那个数字的公式。

让我告诉你，你已经很擅长统计估计了。准备好了吗？

让我们假设你只知道其中一棵树有 23 米高。你能告诉我你对所有树的真实平均高度的估计吗？

23m？是啊，我也是！

如果这是我们仅有的信息，我们不得不猜测 2300 万——如果我们猜测其他任何东西，我们只是在编造。我们只知道 23m，所以只能猜 23m。为了得到其他的东西，我们不得不加入更多的信息(在这个例子中我们没有)或者我们不得不做出假设…在这一点上，我们再次处理事实之外的东西。

好吧，让我们试试另一个！假设我们有一个样本，我们只知道它的平均高度是 22.5 米。你现在最大的猜测是什么？

22.5 米？哇！你太擅长这个了！你甚至不需要一门课程！

这里是几个教科书章节的统计数据的妙处，包括矩估计法、最大似然估计法以及所有它们的表亲:结果证明彩虹尽头的答案就是你刚刚直观得出的答案！在现实生活中，你遇到的 99%以上的情况下，只要把你的样本当作你的总体来对待，不管里面有什么，你就能得到最好的猜测。你不需要任何特别的课程。哒哒，我们完了！

总是需要统计是骗人的；你不知道。如果你只是试图做出最好的猜测来获得的灵感，分析是你的最佳选择。不要理会那些 p 值，你不需要不必要的压力。

相反，你可以选择遵循这些原则:更多(相关)数据更好，你的直觉很适合做出最佳猜测，但不知道这些猜测有多好……所以保持谦逊。

然而，不要认为我在抨击我的纪律。十多年来，我一直致力于研究统计数据，我喜欢认为自己没有完全疯掉。

当采取统计方法有用时，它的 非常 有用。

那么你什么时候真正需要它呢？它什么时候能阻止你伤害自己？看我的 “统计学有什么意义？” 找出…

Learn more about the difference between the subdisciplines in data science here.

感谢阅读！人工智能课程怎么样？

如果你在这里玩得开心，并且你正在寻找一个为初学者和专家设计的有趣的应用人工智能课程，这里有一个我为你制作的娱乐课程:

Enjoy the entire course playlist here: bit.ly/machinefriend

喜欢作者？与凯西·科兹尔科夫联系

让我们做朋友吧！你可以在 Twitter 、 YouTube 、 Substack 和 LinkedIn 上找到我。有兴趣让我在你的活动上发言吗？用这个表格联系。

R 平方解释| R 平方线性回归

原文：https://towardsdatascience.com/statistics-for-machine-learning-r-squared-explained-425ddfebf667?source=collection_archive---------3-----------------------

Photo by Roman Mager on Unsplash

机器学习涉及大量的统计数据。在前面的文章中，我们将看看 R 平方的概念，它在特性选择中很有用。

相关性(也称为“R”)是一个介于 1 和-1 之间的数字，其中值+1 意味着 x 的增加会导致 y 的增加，-1 意味着 x 的增加会导致 y 的减少，0 意味着 x 和 y 之间没有任何关系。与相关性一样，R 会告诉您两个事物的相关程度。然而，我们倾向于使用 R，因为它更容易解释。r 是由两个变量之间的关系解释的变化百分比(即从 0 到 1 变化)。

后者听起来相当复杂，所以让我们看一个例子。假设我们决定绘制工资和工作经验之间的关系。在上图中，每个数据点代表一个个体。

我们可以通过将样本中所有个体的总和除以样本中个体的总数来计算平均值。

整个数据集的方差等于每个数据点之间的距离和均方值之和。差值的平方使得低于平均值的点不会被高于平均值的点抵消。

var(mean) = sum(pi - mean)²

现在说，我们找了同样的人，但是这一次，我们决定画出他们的工资和身高之间的关系。

注意，不管我们把什么作为自变量，平均工资都保持不变。换句话说，我们可以用人民生活的其他方面作为 x 但工资会保持不变。

假设我们使用线性回归找到了最佳拟合线。

R 的值可以表示为:

**R² = (var(mean) - var(line)) / var(mean)**

其中 var(mean) 是相对于平均值的方差，而 var(line) 是相对于直线的方差。

就像我们之前提到的，方差可以通过计算个人工资和均方差之间的差来计算。

使用相同的逻辑，我们可以确定橙色线周围的变化。

假设我们获得了线的方差和均值的下列值。

我们可以使用之前描述的公式计算 R 。

R 值意味着线周围的变化比平均值小 96%。换句话说，工资和工作年限的关系解释了 96%的变异。换句话说，工作年限是薪水的一个很好的预测指标，因为当工作年限增加时，薪水也会增加，反之亦然。

密码

让我们看看如何用 R 来评估一个线性回归模型。首先，导入以下库。

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
import seaborn as sns
from sklearn.metrics import r2_score
from sklearn.linear_model import LinearRegression
sns.set()

我们将使用以下数据集。如果您想跟进，请将其内容复制到 csv 文件中。

YearsExperience,Salary
1.1,39343.00
1.3,46205.00
1.5,37731.00
2.0,43525.00
2.2,39891.00
2.9,56642.00
3.0,60150.00
3.2,54445.00
3.2,64445.00
3.7,57189.00
3.9,63218.00
4.0,55794.00
4.0,56957.00
4.1,57081.00
4.5,61111.00
4.9,67938.00
5.1,66029.00
5.3,83088.00
5.9,81363.00
6.0,93940.00
6.8,91738.00
7.1,98273.00
7.9,101302.00
8.2,113812.00
8.7,109431.00
9.0,105582.00
9.5,116969.00
9.6,112635.00
10.3,122391.00
10.5,121872.00

我们使用 pandas 将数据加载到我们的程序中，并使用 matplotlib 绘制它。

df = pd.read_csv('data.csv')plt.scatter(df['YearsExperience'], df['Salary'])

接下来，我们对工资数据训练一个线性回归模型。

X = np.array(df['YearsExperience']).reshape(-1, 1)y = df['Salary']rf = LinearRegression()rf.fit(X, y)y_pred = rf.predict(X)

我们可以通过运行下面几行来查看模型生成的最佳拟合线。

plt.scatter(df['YearsExperience'], df['Salary'])
plt.plot(X, y_pred, color='red')

然后，我们用上一节讨论的公式计算 R。

def r2_score_from_scratch(ys_orig, ys_line):
    y_mean_line = [ys_orig.mean() for y in ys_orig]
    squared_error_regr = squared_error(ys_orig, ys_line)
    squared_error_y_mean = squared_error(ys_orig, y_mean_line)
    return 1 - (squared_error_regr / squared_error_y_mean)def squared_error(ys_orig, ys_line):
    return sum((ys_line - ys_orig) * (ys_line - ys_orig))r_squared = r2_score_from_scratch(y, y_pred)print(r_squared)

我们可以利用 sklearn r2_score函数，而不是每次都从头开始实现。

r2_score(y, y_pred)

统计学是数据科学的语法—第 1/5 部分

原文：https://towardsdatascience.com/statistics-is-the-grammar-of-data-science-part-1-c306cd02e4db?source=collection_archive---------10-----------------------

统计复习，开启您的数据科学之旅

英国数学家、现代统计学之父卡尔·皮尔逊被认为是这句话的作者:

“统计学是科学的语法”

在这里，我们将重点关注与数据科学
*相关的统计数据——看到我在那里做了什么吗？*😄

像 Tensorflow 或 scikit-learn 这样的机器学习库对用户隐藏了几乎所有复杂的数学。
这意味着我们不需要成为数学专家，但是对基本原理有一个基本的理解是绝对必要的；这将帮助我们更好地利用这些图书馆。

我正在撰写一个由 5 篇短文组成的系列文章，涵盖以下主题，以启动并随后伴随我们的数据科学之旅:

第 1 部分:数据类型|集中趋势度量|可变性度量第 2 部分:数据分布第 3 部分:位置度量|矩第 4 部分:协方差|相关性

让我们从 1️⃣…部分开始

数据类型

我们不能再简单了:数据分为三类，数据科学家根据这三类选择如何进一步分析和处理数据:

#1。数字数据代表一些可测量的可量化信息，并进一步分为两个子类别:

• 离散数据，基于整数(如人数)
• 连续的数据，以十进制为基础(如价格、距离、温度)。

#2。分类数据是用于将数据分类的定性数据(想象一下编程中的枚举)。例如，性别、汽车品牌、居住国等。有时我们可以给类别分配数字，这样它们会更紧凑，但是它们没有任何数学意义。

*#3。序数数据代表离散的和有序的单位，例如冠军联赛排名(第 1、第 2、第 3)、错误优先级(低、关键或表演停止)或酒店评级(1–5 )。

集中趋势的度量

假设我们有一个由 5 个数字组成的数据集:

*{ 6, 3, 100, 3, 13 }*

平均

平均值(用希腊字母 mu— μ表示)是数据集的平均值。为了计算平均值，我们将所有值相加，然后除以值的个数。

*E.g. 6 + 3 + 100 + 3 + 13 = 125 →
     μ = 125 ÷ 5 = 25*

中位数

中位数是数据集的中间点。为了计算中间值，我们对所有值进行排序(按升序或降序),并取中间值。

*E.g. 3, 3, **6**, 13, 100 → 6*

如果有偶数个数据点，那么我们计算落在中间的两个数据点的平均值。

中位数比平均值更不容易受到离群值的影响，因此我们需要考虑数据分布的样子，以选择使用哪一个。

方式

众数是数据集中最常见的值。为了计算模式，我们找到出现频率更高的数字。

*E.g. 3:2, 6:1, 13:1, 100:1 → 3*

模式通常只与离散数值数据相关，与连续数据无关。

差异量数

范围

范围是数据集的最低和最高数字之间的差。为了计算范围，我们从最大值中减去最小值。

*E.g. 100 – 3 = 97*

它向我们展示了数据集是如何变化的，也就是说，它是如何分布的，但同样，像均值一样，它对异常值非常敏感。

差异

方差衡量如何展开数据。为了计算方差，我们从平均值中取方差的平均值。

• ***#1。*求数据点的平均值

*From previous section it is 25*

• ***#2。*从每个数据点中减去平均值

*6 - 25 = -19
3 - 25 = -22
100 - 25 = 75
3 - 25 = -22
13 - 25 = -12*

• ***#3。*平方每个结果

*(-19)^2 = 361
(-22)^2 = 484
(75)^2 = 5,625
(-22)^2 = 484
(-12)^2 = 144*

• ***#4。*求结果的平均值(即求和并除以 n)

*361 + 484 + 5,625 + 484 + 144 = 7,098 →
7,098 ÷ 5 = 1,419.6*

✏️《平方和》
在第 3 步我们之所以使用平方和的区别是双重的:

• 负面差异与正面差异具有相同的影响，即它们不会相互抵消
• 它放大了数据集中异常值的影响。

✏️数据完整性
根据数据集的完整性，第 4 步有细微的区别:

• 对于完全群体，我们除以数据点的数量(n)，即第 4 步是正确的，因为在我们的情况下，我们有一个完全群体
• 对于样本，我们除以数据点数减 1 (n - 1)

*7,098 ÷ 4 = 1774.5*

标准偏差

标准差(用希腊字母 sigma — σ表示)就是方差的平方根。

*E.g. σ = SQRT(1,419.6) = 37.68*

它是一种离差的度量，即它偏离平均值多少标准差，正如我们将在下面的文章中看到的，它用于判断哪个数据点是异常值。

*100 was a rather big number in our example, let's see how many standard deviations it is away from the mean:μ = 25
σ = 37.68
100 / 37.68 = 2.65*

感谢阅读！第二部快到了…

我定期在 媒体 上撰写关于技术的&数据——如果你想阅读我未来的帖子，请“关注”我！

统计学是数据科学的语法—第 2/5 部分

原文：https://towardsdatascience.com/statistics-is-the-grammar-of-data-science-part-2-8be5685065b5?source=collection_archive---------8-----------------------

统计复习，开启您的数据科学之旅

这是“统计学是数据科学的语法”系列的第二篇文章，涵盖了各种类型的概率分布以及我们如何绘制它们。

修订本

其余文章的书签，便于访问:

文章系列 第 1 部分:数据类型|集中趋势度量|可变性度量
第 2 部分:数据分布🚩
第 3 部分:位置|矩的度量
第 4 部分:协方差|相关性
第 5 部分:条件概率|贝叶斯定理

概率分布函数

概率分布是描述事件或结果的可能性的函数。它们有许多形状，但只有一种大小:分布中的概率总和总是 1。我们现在将根据数据集是连续的还是离散的来深入研究不同类型的分布。

概率密度函数

当我们看到类似下图的图表时，我们认为它显示了给定值发生的概率。然而，这对于连续的数据来说并不完全正确，因为数据点的数量是无限的。因此，特定值发生的概率可能非常小——无限小！

PDF 表示给定的值范围出现的概率。因此有了“密度”这个词！为了形象化概率，我们将数据集绘制成曲线。两点之间曲线下的面积对应于变量落在这两个值之间的概率。

Courtesy: scipy.stats.gennorm

✏️ “臭名昭著”的钟形标准正态分布
为了更好地理解这一点，我们将研究 PDF 的一个特例:

Courtesy: Princeton University

在平均值和一个标准差(1σ)之间，有 34.1%的可能性值落在该范围内。因此，对于给定值，有 68.2%的机会落在-1σ和 1σ之间，这是非常可能的！！！
这意味着在平均值附近有一个集中值，当我们超出一个标准差(±)时，概率变得越来越小。

概率质量函数(PMF)

当谈到离散数据时，PMF 是给我们一个给定值发生的概率的度量。为了直观显示概率，我们将数据集绘制成直方图。

Courtesy: scipy.stats.rv_discrete

连续数据分布

现在我们了解了 PDF 和 PMF 之间的区别，我们将看到最常见的分布类型，从连续分布开始。

#PDF-1:均匀/矩形分布

均匀分布意味着某个值在给定范围内出现的概率为平坦常数，并且与同样可能发生的事件有关。

Courtesy: scipy.stats.uniform

在上面的图中，我们不希望看到低于 0.0 或高于 1.0 的范围之外的任何东西。但是在这个范围内，我们有一条平坦的线，因为这些值中的任何一个出现的概率是恒定的。

#PDF-2:正态/高斯分布

当我们探索 PDF 是什么时，我们看到了一个标准的正态分布。如果我们引入“随机”元素，正态分布看起来不像一条完美的曲线，而更像下面的例子。

Courtesy: scipy.stats.norm

标准正态分布的平均值为零，标准差为一。

#PDF-3: T 分布

T 或 Student 的 T 分布看起来很像正态分布的钟形曲线，但稍短一些，尾部较重。当我们有小样本和/或总体方差未知时，使用它(而不是正态分布)。

Courtesy: scipy.stats.t

#PMF-4:卡方分布

卡方(χ)分布用于评估一系列问题:

• 数据集是否符合特定的分布
• 两个总体的分布是否相同
• 两个事件是否可能是独立的
• 人群中是否存在不同的变异性。

曲线向右倾斜。

Courtesy: scipy.stats.chi2

#PDF-5:指数概率分布

另一个经常遇到的分布函数是指数概率分布函数，其中事物以指数方式下降。

Courtesy: scipy.stats.expon

大值越来越少，小值越来越多，也就是说，某件事发生的可能性很大，接近于零，但当我们离它越远，它就会急剧下降。

一个日常的例子是顾客一次去超市花的钱:花小额钱的人多，花大额钱的人少。

它被广泛用于模拟事件之间经过的时间以及可靠性**，后者处理产品持续的时间量，例如汽车电池持续的时间量(从现在开始),以月为单位。**

在我们进入下一部分之前，我想向推荐来自 Sean Owen 的这篇关于 pdf 的特别文章，他在文章中创建了他们的关系图:

Courtesy: Sean Owen — Cloudera

离散数据分布

至于离散概率分布，两个主要类别包括:

#PMF-1:二项式分布

让我们考虑一个有两种可能结果的实验:要么成功要么失败。假设实验重复几次，重复次数彼此独立。结果证明是成功的实验总数是一个随机变量，其分布称为二项式分布。

Courtesy: scipy.stats.binom

#PMF-2:泊松分布

泊松分布给出了在固定时间间隔内发生的事件数量的概率，如果这些事件发生:

• 具有已知的平均速率和
• 独立于自上次事件以来的时间。

Courtesy: scipy.stats.poisson

一个经典的例子是呼叫中心接到的电话数量。
—或者—
如果我们知道给定时间段内发生的事情的平均数量，另一个用例可以是预测在给定的未来时间获得另一个值的可能性。例如，我的中型帖子平均每天有 1000 次浏览；我可以使用泊松概率质量函数来估计 1500 次访问的概率。

今天的文章到此结束！我希望这对于理解各种类型的分布是什么以及它们看起来是什么样子是有用的，即使我“隐藏”了所有的数学类型！

感谢阅读！第三部即将上映……

我定期在 媒体 上撰写关于技术&的数据——如果你想阅读我未来的帖子，请“关注”我！

统计学是数据科学的语法—第 3/5 部分

原文：https://towardsdatascience.com/statistics-is-the-grammar-of-data-science-part-3-5-173fdd2e18c3?source=collection_archive---------6-----------------------

统计复习，开启您的数据科学之旅

这是“统计学是数据科学的语法”系列的第 3 篇文章，涵盖了位置的度量(百分位数和四分位数)和矩。

修订本

其余文章的书签，便于访问:

文章系列 第 1 部分:数据类型|集中趋势的度量|可变性的度量
第 2 部分:数据分布
第 3 部分:位置|矩的度量🚩
第四部分:协方差|相关性
第五部分:条件概率|贝叶斯定理

位置的测量

百分位数

百分位数将有序数据分成百分之和百分之。在一个排序的数据集中，一个给定的百分位数是数据百分比比我们现在所处的点少的点。

第 50 百分位几乎是中间值。

例如，想象一下女婴从出生到两岁的成长图表。顺着这条线，我们可以看到 98%的一岁女婴体重不到 11.5 公斤。

Girls’ growth chart. Courtesy: World Health Organisation Child Growth Standards

另一个流行的例子是一个国家的收入分配。第 99 个百分位数是指美国其余 99%的人收入低于这个数字，而 1%的人收入高于这个数字。在下图中的英国，这个数字是 75，000。

UK income distribution. Courtesy: Wikipedia

四分位数

四分位数是特殊的百分位数，它将数据分成个四分位数。第一个四分位数 Q1 与第 25 个百分位数相同，第三个四分位数 Q3 与第 75 个百分位数相同。中位数被称为第二个四分位数，Q2，和第 50 个百分位数。

I 四分位数范围( IQR)

IQR 是一个指示如何分布数据集的中间一半(即中间的 50%)的数字，可以帮助确定异常值。这就是 Q3 和 Q1 的区别。

IQR = Q3 - Q1

IQR. Courtesy: Wikipedia

一般来说，异常值是那些不在 Q1-1.5 倍 IQR 和 Q3 + 1.5 倍 IQR 范围内的数据点。

箱线图

箱线图(也称为箱线图和须线图)说明了:

• 数据有多集中
• 极值值离大部分数据有多远。

Elements of a boxplot. Courtesy: Wikimedia

箱形图由一个缩放的水平或垂直轴和一个矩形框组成。

最小值和最大值是轴的端点(本例中为-15 和 5)。 Q1 标记盒子的一端，而 Q3 标记蓝色盒子的另一端。

‘须条’(显示为紫色)从框的两端延伸至最小和最大数据值。也有箱线图，其中的点标记了异常值(显示为红色)。在这些情况下，胡须不会延伸到最小值和最大值。

正态分布的✏️箱线图
正态分布的箱线图有一个微妙的差别:尽管它们被称为四分位数 1 (Q1)和四分位数 3 (Q1)，但它们并不真正代表 25%的数据！他们代表 34.135%，介于两者之间的区域不是 50%，而是 68.27%。

Comparison of a boxplot of a nearly normal distribution (top) and a PDF for a normal distribution (bottom). Courtesy: Wikipedia

朋友圈

瞬间描述了我们分布的本性和形状的各个方面。

#1 —一阶矩是数据的均值，描述了分布的位置。

#2 —二阶矩是方差，描述了分布的差。高值比小值更分散。

#3 —第三个矩是偏斜度，它基本上是一个衡量分布有多不平衡的指标。正的偏斜意味着我们有一个左倾和一个长的右尾巴。这意味着平均值在大部分数据的右边。反之亦然:

Skewness. Courtesy: Wikipedia

#4 —第四个矩是峰度，描述尾部有多粗，波峰有多尖。它表明在我们的数据中找到极值的可能性有多大。较高的值更有可能产生异常值。这听起来很像 spread(方差),但有细微的不同。

Kurtosis illustration of three curves. Courtesy: Wikipedia

我们可以看到，较高的峰值具有较高的峰度值，即最顶部的曲线比最底部的曲线具有较高的峰度。

那都是乡亲们！这是一篇相当短的文章；我们知道了百分位数有多重要，因为它们表明了我们相对于其他人的地位。然后，我们看到了一个特殊的类别，称为四分位数，以及它们在寻找异常值中的应用。最后，我们探索了描述曲线形状的四个“矩”。

感谢阅读！第四部分即将到来……

我定期在 中型 上写关于技术的&数据——如果你想阅读我未来的帖子，请“关注”我！

统计学是数据科学的语法—第 4/5 部分

原文：https://towardsdatascience.com/statistics-is-the-grammar-of-data-science-part-4-5-e9b1ce651064?source=collection_archive---------16-----------------------

统计复习，开启您的数据科学之旅

这是“统计学是数据科学的语法”系列的第 4 篇文章，涵盖了协方差和相关性的重要主题。

修订本

其余文章的书签，便于访问:

文章系列 第 1 部分:数据类型|集中趋势度量|可变性度量
第 2 部分:数据分布
第 3 部分:位置度量|矩
第 4 部分:协方差|相关性🚩
第五部分:条件概率|贝叶斯定理

介绍

为了给本文打下基础，我们将假设我们有一个散点图，每个数据点代表一个人:一个轴上是他们多年的职业经历，另一个轴上是他们的收入。

‘Professional experience vs. Income’ scatterplot

如果散点图看起来像右边的，那么我们得出经验和收入之间没有真正的关系，即对于任何给定的经验，都可能有一个收入范围。

相反，在左图中，这些属性之间存在明显的线性关系。

协方差和相关性为我们提供了一种测量数据集属性相互依赖程度的方法**。**

注意:在这个例子中，描述的数据类型是双变量的——两个变量的“bi”。实际上，统计学家使用的是多元数据，即许多变量。

协方差

协方差是两个(或更多)随机变量之间关联的度量。

顾名思义,“co + variance”类似于方差，但用于比较两个变量——我们用叉积之和代替平方和。方差告诉我们单个变量如何偏离均值；协方差告诉我们两个变量如何彼此不同。因此，可以公平地说:

协方差是衡量两个变量之间的方差。

协方差可以是负的也可以是正的(或者明显为零):正的值意味着两个变量趋向于以相同的方向变化(即如果一个增加，那么另一个也增加)，一个负的值意味着它们以相反的方向 变化(即如果一个增加，那么另一个减少)，而零意味着它们不一起变化。

公式

这个公式可能很难解释，但更重要的是理解它的含义:

Covariance between variables X and Y

如果我们认为一个随机变量的数据集被表示为一个向量，那么在前面的例子中，我们有两个向量，分别是经验和收入。以下是我们需要遵循的步骤:

• #1 。将这两个向量转换为平均值的方差向量。
• #2 。取两个矢量的点积(等于它们之间夹角的余弦)。
• #3 。除以样本量(n 或 n - 1，如前所述，基于是否为完全总体)。

第二步，我们有效地测量这两个向量之间的角度，所以如果它们彼此接近，就意味着这些变量是紧密耦合的。

主要限制

值得注意的是，虽然协方差确实度量了两个变量之间的方向关系，但它并不显示它们之间的关系强度。

实际上，这种度量的最大问题是它依赖于使用的单位。例如，如果我们将几年的经验转换成几个月的经验，那么协方差会大 12 倍！

这就是相关性发挥作用的地方！

Rainbow scatterplot. Courtesy: Scipy

相互关系

相关性是统计学中最常见的度量之一，它描述了两个随机变量之间的关联程度。它被认为是协方差的归一化版本。让我们看看为什么…

公式

相关性(用希腊字母ρ — rho 表示)可以用以下公式表示:

Correlation between variables X and Y

相关性被限制在-1 和 1 之间。与协方差一样，相关性的符号表示关系的方向:正表示随机变量一起移动，负表示随机变量向不同方向移动。

端点(即 1 和-1)表示两个变量之间存在完美的关系。例如，米和厘米之间的关系总是 1 米对应 100 厘米。如果我们画出这个关系，它将是一条完美的线，因此相关性是 1。

请注意，完美的关系在现实生活数据中非常罕见，因为两个随机变量通常不会通过常数因子相互映射。

相关性为 0 意味着两个变量之间没有线性关系。可能有一个 x = y 关系。

关键特征

相关性不仅指示关系的方向，还指示其强度，(取决于绝对值有多大)因为它是无单位的:因为我们将协方差除以标准偏差，所以单位被抵消了。

最后，我们需要记住’ 相关性并不意味着因果关系 ':两个随机变量之间的高度相关性只是意味着它们彼此关联，但它们的关系在本质上并不一定是因果关系。证明因果关系的唯一方法是用受控实验，在这里我们排除外部变量，隔离两个变量的影响。

😆 Courtesy: Pinterest

全部完成！我们已经学会了如何使用协方差和相关性来衡量数据集中的两个不同属性是否以线性方式相互关联，以及为什么相关性通常是首选，因为它是无单位的。

感谢阅读！第五部即将到来……

我定期在 媒体 上撰写关于技术&的数据——如果你想阅读我未来的帖子，请“关注”我！

统计学是数据科学的语法—第 5/5 部分

原文：https://towardsdatascience.com/statistics-is-the-grammar-of-data-science-part-5-5-3f6099faad04?source=collection_archive---------7-----------------------

统计复习，开启您的数据科学之旅

这是“统计学是数据科学的语法”系列的第 5 篇(也是最后一篇)文章，涵盖了条件概率和贝叶斯定理及其重要性。准备好了吗？

修订本

其余文章的书签，便于访问:

文章系列 第 1 部分:数据类型|集中趋势度量|可变性度量
第 2 部分:数据分布
第 3 部分:位置度量|矩
第 4 部分:协方差|相关性
第 5 部分:条件概率|贝叶斯定理🚩

条件概率

条件概率是一个事件发生的可能性，基于一个先前事件的发生。

条件概率的符号是 P(A|B)，读作’给定 B 的概率’。条件概率的公式是:

Conditional Probability of A given B

A ∩ B 是维恩图中 A 和 B 的交集，所以 P(A∩B)是 A 和 B 同时出现的概率。
照这样:

给定 B 的概率等于 A 和 B 发生的概率除以 B 单独发生的概率。

Venn diagram: Probabilities of events A and B.

✏️的例子:

假设我们从一个袋子里抽出三颗弹珠——红色、绿色和蓝色。

在已经画了红色的弹珠之后，再画蓝色弹珠的条件概率是多少？

如果事件 A 是首先获得红色弹珠的事件，而事件 B 是获得蓝色弹珠的事件，我们希望计算 P(A∩B) :

• P(A) 是第一回合得到红色弹珠的概率。因为这是三种可能结果中的一种:

P(A) = 1/3 = 33.33%

• P(B|A) 是第二回合得到蓝色弹珠的概率。因为还剩下两个弹珠:

P(B) = 1/2 = 50%

• P(A ∩ B) 是第一轮画出红色弹珠，第二轮画出蓝色弹珠的概率:

P(A ∩ B) = P(A) * P(B|A) = 33.33% * 50% = 16.66%

为了形象化这一点，我们可以使用树形图——每个分支都有一个条件概率

Tree Diagram for the marble bag example

原因

我们在第四部分中看到了因果关系的含义。条件概率不不表示两个事件之间有必然的因果关系，也不表示两个事件同时发生。

独立事件

独立事件是那些其结果不影响其他事件结果的概率的事件。由于这个原因:

P(A|B) = P(A)
P(B|A) = P(B)

互斥事件

互斥是指那些不能同时发生的事件，即如果一个事件已经发生，另一个就不能发生。因此:

P(A|B) = 0
P(B|A) = 0

Neon sign showing the simple statement of Bayes’ theorem. Courtesy: Wikipedia

贝叶斯定理

刚刚探索了什么是条件概率，让我们来看看贝叶斯定理。它只是说:

给定 B 的概率等于给定 A 的 B 的概率乘以 A 的概率，除以 B 的概率。

Bayes’ Rule

换句话说，它提供了一种在 P(A|B)和 P(B|A)之间转换的有用方法。

在更大的范围内，它是统计学中整个领域的基石(“贝叶斯统计学”)。它被用于各种学科，最著名的例子是医学和药理学，但也用于金融，例如预测一项投资成功的概率。

将这些条件变量应用于贝叶斯定理时，数量几乎和质量一样重要。例如，假设我们想计算借钱给借款人的风险。如果我们考虑其他可能性，如借款人的年龄、信用评级和风险偏好，借钱给特定个人的可能性会有所不同。

正如理论本身所假定的那样:

变量越多，我们对这些变量越有把握，就越能利用条件概率得出准确的结论！

✏️的例子:

假设我们是诊所的医生，我们知道:肝病患者的概率是 20%，酗酒者的概率是 5%，在被诊断为肝病的患者中，10%是酗酒者。我们现在想知道:

如果一个病人是个酒鬼，那么他患肝病的条件概率是多少？

• P(A) 是患肝病的概率:

P(A) = 20%

• P(B) 是成为酗酒者的概率:

P(B) = 5%

• P(B|A) 是假设患者患有肝病，则患者为酗酒者的条件概率:

P(B|A) = 10%

• P(A|B) 是假设患者是酗酒者，他们患肝病的条件概率:

P(A|B) = (10% * 20%) / 5% = 40%

互斥事件

贝叶斯定理的一个特例是当事件 A 是二进制值时。在这种情况下，我们用‘A–’表示事件 A 已经发生，用‘A+’表示事件 A 没有发生(即事件 A–和 A+是互斥的)。
公式表示如下:

Bayes’ Rule for mutually exclusive events A- and A+

准确(性)

一个真正是模型正确预测正类的结果。类似地，真负是模型正确预测负类的结果。

假阳性是模型错误地预测阳性类别的结果。类似地，假阴性是模型错误地预测阴性类的结果。

灵敏度表示测试正确预测病例的概率→真阳性。

特异性表示检测将正确识别阴性病例→真阴性的概率。

Sensitivity = true positives / (true positives + false negatives)
Specificity = true negatives / (true negatives + false positives)

✏️的例子:

我们假设某种疾病的发病率为 2%。如果假阴性率为 10%，假阳性率为 1%:

一个测试呈阳性的人实际患有这种疾病的条件概率是多少？

如果事件 A 是个体患有这种疾病的事件，并且事件 B 是个体测试呈阳性的事件，我们希望计算 P(A|B) ，即假设个体测试呈阳性(B)，他们实际上患有疾病(A)。

• P(A+) 或 P(A) 为患此病的概率:

P(A+) = 2%

• P(A–**)**为不患此病的概率，可推导出:

P(A-) = 100% - 2% = 98%

• **P(B | A–)**是假阳性的概率，即没有患病(A–)但呈阳性(B):

P(B|A-) = 1%

• **P(B –| A)**是假阴性的概率，即患有疾病(A)但结果为阴性(B –)

P(B-|A) = 10%

• P(B|A+) 或 P(B|A) 为真阳性，即患病(A)和阳性(B)，可推导出:

P(B|A) = 100% - 10% = 90%

• 我们现在有了计算 P(A|B)的所有信息:

P(A|B) = [ P(B|A) x P(A) ] **/** [ P(B|A-) x P(A-) **+** P(B|A+) x P(A+) ]
       = [ 90% x 2% ] / [ 1% x 98% + 90% x 2% ] =
       = 64.7%

我们可以用一个矩阵来显示测试精度:

在树形图中:

完毕完毕。今天我们学习了条件概率反映了一个事件对另一个事件的概率的影响。然后我们深入研究了贝叶斯定理，这是统计学的基础，因为它允许概率推理。

结束了

Photo by Matt Botsford on Unsplash

这是《统计学是数据科学的语法》续集的结尾。我希望您现在已经具备了开始数据科学之旅的知识！如果你想了解其他内容，请在评论中给我留言，并尝试把它添加到我的下一篇文章中。

感谢阅读！

我定期在 中型 上写关于技术的&数据——如果你想阅读我未来的帖子，请“关注”我！

棒球迷的统计数据:进攻的唯一指标是 OPS。

原文：https://towardsdatascience.com/stats-for-baseball-fans-the-single-metric-for-offense-is-ops-fc568af5e87b?source=collection_archive---------19-----------------------

今年夏天，我爱上了棒球，因为我把我喜欢的东西(统计学)和我不太感兴趣的东西(芝加哥小熊队和箭牌棒球场)结合了起来。)

现在，我如何找到小熊队的故事可以成为自己的博客帖子——它充满了浪漫，从南方搬到亚特兰大勇士队，一份新工作，住在离箭牌球场几步之遥的地方……有一天我会写这本书。

但是…今天的博客是关于用统计数据来证明你只需要关注一个数据就能了解你的球队中最好的进攻球员，从而成为我所能做到的最有见识的球迷。这个数据就是 OPS(上垒率加上击球率。)

TLDR:你最喜欢的球队中 OPS 数据最高的球员很可能是他们整体进攻最好的球员。当他们来到本垒时，大声欢呼。

数字，数字，无处不在…

你去过 MLB 棒球场，注意到记分牌是数字的海洋吗？AVG、OBP、SLG、OPS，这些指标在棒球卡上、报纸上和电视分析师那里都有报道。它们有什么意义吗？

事实证明确实如此。每个人都试图测量表面上看起来很重要的击球方面。SLG 是一个用来了解玩家实力的指标；OBP 是一个衡量一个球员有多擅长跑垒的标准。

作为一名分析师和数据科学家，这些指标让我着迷。作为一个只想享受比赛的球迷，他们可能会感到困惑。当我想了解我支持的球队中最好的击球手时，肯定有一个指标是我应该注意的。

我喜欢简单的运动——它让啤酒、饼干和热狗味道更好。

现在我意识到有时候很容易理解你最好的击球手。尤其是，当你的球队中有一个像迈克·特劳特这样的强力击球手或者每个人都喜欢的球员——芝加哥小熊队的贾维·贝兹。从粉丝反应就能看出来。这很好，但我如何才能穿过噪音，只关注那些为球队得分的球员呢？

这就是我们求助于统计数据的地方。

理解棒球数据的问题是:球员也是人。

用球员的个人表现来理解统计数据的价值有一个很大的问题。不幸的是，球员生病，有孩子，休息几天，被送到小联盟，玩疯了或者只是过了糟糕的一天。

换句话说，玩家也是人。

为了消除我们数据库中讨厌的人类特征，我们做了一点小技巧来消除玩家噪音。不分析球员，我们来分析球队。球队不休假，通常一年打 162 场比赛(当我们除去像 1994 年 MLB 罢工这样的离群值时。)平均来说，每支球队都应该有相似的击球次数和均等的得分机会。因为它不太人性化和规范化，所以团队级别的数据是理解棒球统计重要性的门票。

• 查德威克棒球数据库(见此 帖子 了解更多信息)。)

从球员分析过渡到球队分析使我们的数据正常化；让统计学家更容易完成这个项目。

进攻=跑垒。

Dictionary.com 是这样定义棒球的:

(棒球)两个九人队之间的一种球类运动，通常在一个场地上打九局，该场地的焦点是一个菱形内场，该内场有一个本垒板和三个相距 90 英尺(27 米)的其他垒，形成一个必须由跑垒者完成才能得分的回路，中心进攻动作包括用木制或金属球棒击打投球并跑垒， 获胜者是得分最多的队 。

我们关心跑垒，因为这是进攻球员唯一最重要的目标——打击跑者或通过到达本垒使自己跑起来。该分析需要运行目标函数(y)。分析的目标是找到与跑垒最相关的击球统计数据。我们的假设是，一个球员让自己得一分®和一分(rbi)的能力将会是一个强有力的进攻球员的信号。我们如何在单一指标中捕捉到这一点？

OPS 与跑步最相关。

我们通过计算一些你会发现投射在整个 MLB 体育馆的记分牌上的统计数据来开始这项分析。潜在的指标包括击球率(AVG)、击球率(SLG)、上垒率(OBP)、上垒率加击球率(OPS)以及其他常见的击球指标(AB、H、2B、3B、HR 等)。)

我们不得不从头开始创建一些指标，它们的定义如下所示:

SLG =(安打+双打+(三双2) +(小时3)) /在击球时

AVG =击球数

OBP =(安打+保送+投球命中)/(击球+保送+投球命中+牺牲苍蝇)

OPS = OBP + SLG

早些时候，我提到过我们通过使用团队赛季总数而不是个人球员总数来标准化我们的数据。我通过去除一些异常的季节进一步规范化。以下是我的团队剔除异常值的全部细节:

• 删除 1970 年之前的球队:1970 年赛季之前没有跟踪几个关键指标(包括牺牲苍蝇、被投球击中和其他)。)
• 删除了比赛场次低于 156 场的赛季:这将删除因罢工和其他日程怪事而缩短的赛季。(再见 1994 赛季。)
• 删除了不参加国家或美国联赛的球队:我们不关心这个分析中的小联盟或春训联盟。

一旦我们有了干净的数据，我们就可以运行将常见命中指标与运行相关联的分析。分析结果表明，OPS 是唯一最重要的指标，相关系数为 0.95(与运行高度相关。)

有史以来最好的玩家(在随机森林的帮助下)

现在我们知道我们应该最关注运营，我想问的下一个问题是，根据这个标准，谁是最好的玩家？答案很容易计算…

事实上，他们不是。

在这篇文章的早些时候，我提到在某些棒球时代，球员的统计数据并没有保持干净。1954 年，形成我们今天看到的牺牲飞统计的规则被创造。在 1954 年之前，MLB 对 SF 有不同的定义或者根本没有跟踪。

那么，我们要如何为 1954 年之前的玩家定义 OPS 呢？

我使用随机森林算法根据 MLB 收集的数据来预测玩家丢失的数据。然后我用预测的数据来估算 1954 年之前玩家的 OPS。我不打算用这个博客来展示随机森林方法，但是我会展示一些输出，这样你就知道是我做的。

随机森林模型

我选择的包是 R 图书馆，randomForest。下面是调整后的射频算法和输出预测牺牲苍蝇的球员的统计数据保存:

你会看到随机森林在模拟牺牲苍蝇方面非常有效，92.4%的方差可以用已知的命中变量来解释。我超级自信我的 OPS 对于 1954 年之前的玩家来说是合理的。

不再赘述，以下是 OPS 评选出的前 15 名史上最伟大球员名单；在我看来是有史以来最伟大的进攻球员。

根据行动计划，我儿时的偶像弗兰克·托马斯晋级了。迈克·特劳特是前 15 名中唯一活跃的选手；而贝比鲁斯是进攻之王……愿他统治长久。

最后

OPS 是一个可靠的指标，它包含了棒球进攻策略的两个关键组成部分。

1. OBP:球员将自己置于得分位置的能力。
2. 玩家的力量和他们创造打击的能力，这种能力可以让玩家在垒周围移动(包括他们自己)。)

我的建议是小心那些拥有极高 OPS 数据的玩家。他们通常会是你最兴奋的击球手。根据数据，0.8 的 OPS 是例外的；我以此为标准来评估今天的球员。

站在数据科学的前沿

原文：https://towardsdatascience.com/staying-on-top-of-data-science-baeff05ca59f?source=collection_archive---------25-----------------------

Data Scientists trying to stay on top of technological developments in the 1880s.

在最近的一条推文中，一位 DS 招聘经理报告说，他问了一位候选人一个具体的框架，当候选人承认他们没有听说过这个框架时，他给出了否定的回答。在为自己的立场辩护时，招聘经理表示，负面分数的原因是不了解框架会让候选人看起来跟不上新的发展。

数据科学家需要做出特殊努力来跟上新发展的想法非常普遍。数据科学被认为是一个不断出现新发展的前沿领域。然而，数据科学课程反映了相反的情况——新的数据科学家被教授用 SQL、Python 和 R 编写代码——年龄分别为 40 岁、25 岁和 26 岁。

另一方面，机器学习算法和统计技术往往更古老——逻辑回归通常被认为是在 1944-75 年前开发的；C&RT 发明了将近 40 年。神经网络是在 20 世纪 60 年代发明的。

深度学习可以说是最引人注目的例外。尽管它的根源在于从 20 世纪 80 年代到 21 世纪初的一系列发展，但最常被引用的“突破时刻”发生在 2012 年。针对不同应用使用不同的架构吸引了新的发展，深度学习的相对年轻也是如此。

然而，每周新的深度学习架构或新的 R 包的存在并不意味着数据科学家应该感到必须学习它们。需要有一个理由来解释为什么这些新的发展会增加你的技能。

困难在于，虽然学习一个新的框架或库可能会略微提高您的生产率，但随着大多数数据科学领域达到的成熟水平，生产率的差异将是微不足道的。在很大程度上，通过学习每一个额外的新工具，你将看到的收益会比以前的框架小一些。

与此同时，提高你作为数据科学家的效率的最佳方式不是学习一种新技术来帮助你更快地训练一种算法，或者甚至更快或更好地准备数据。而是花更多的时间去了解你工作的领域，花更多的时间去了解你的客户想要从数据科学中得到什么。

对新技术的不懈追求将会偏离这一目标；花在阅读 R 包文档上的时间通常是你没有花在更好地了解你的用户上的时间，或者至少(假设你的用户没有无限的时间和你在一起)你没有花在训练自己更好地理解你的客户对你说的话上的时间。

数据科学已经存在了大约 50 年。直觉上，一年的创新价值不到 2%的额外知识。统计创新没有摩尔定律。

与此同时，大多数完成了基本培训和几年工作的数据科学家在技术上并不弱。更有可能的是技术是他们的优势。成为更好的数据科学家的最有效的方法不是学习更多的技术，而是找到一个较弱的领域并努力改进。最有可能的是，薄弱环节将是沟通技巧、销售技巧或最有效的与用户产生共鸣的方式。

罗伯特·德格拉夫的书 管理你的数据科学项目 ，已经通过出版社出版。

在 Twitter 上关注罗伯特

一步一步:在罗宾汉建立自动交易系统

原文：https://towardsdatascience.com/step-by-step-building-an-automated-trading-system-in-robinhood-807d6d929cf3?source=collection_archive---------0-----------------------

Photo by Maxim Hopman on Unsplash

在这篇文章中，我将探索通过 Python 代码与 Robinhood API 集成的用法。

想法是用 Robinhood 做交易平台。Robinhood API 对市场数据的访问非常有限。不建议将他们的 API 用于数据目的。

什么是罗宾汉？

Robinhood 提供了一种允许客户买卖股票和交易所交易基金(ETF)而无需支付佣金的方式。它是一个交易平台，还没有提供官方的 API。

注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。

开始吧

如果你搜索Robinhood API python，有大量的 Github 链接或者文档。但是大部分都不支持最新的 API。还有一些项目很久没更新了，见 sanko 的罗宾汉。

这里我用的是 Robinhood (一个 python 框架)，它最初来自 Jamonek 的 Robinhood 框架。自从 Robinhood 实施强制 MFA 以来，我做了一些改变以确保它的工作。

在控制台中找到您想要下载的位置，然后简单地运行:

git 克隆https://github.com/LichAmnesia/RobinhoodCD 罗宾汉
sudo python3 setup.py install

那你就可以走了！

注册

默认方式需要你手持手机输入验证码。

这样，您需要每 24 小时登录一次，因为您的身份验证令牌将过期。

使用类似这样的内容登录:

如果不想启用 2FA，可以跳过这一部分。启用 2FA 后，每次登录罗宾汉网站时都需要输入验证码。

若要启用 2FA，请转到您的 Robinhood Web 应用程序。进入设置，打开 2FA，选择“认证 App”，点击“扫描不了？”，并复制 16 个字符的二维码。

使用类似这样的内容登录:

访问市场数据

数据是任何策略的支柱，但 Robinhood API 只返回股票非常基本的信息。

如果您需要历史价格数据:

目前，API 仅支持 5 分钟| 10 分钟| 30 分钟|天|周的时间间隔。日期范围为日|周|年| 5 年|全部。

从 API 交易

Robinhood 需要你有 25k 以上才能做日内交易。否则 5 天只能做 4 天的交易。参见罗宾汉模式日交易。

由于 Robinhood 没有任何纸质账户，因此从 API 执行的所有订单都与在 App 中执行的订单相同。

这里我用DWT举例，每股 5 美元。

现在我提交一份市价单:

此处GFD表示当天有效，如果今天未满将被取消。此外，您可以设置GTC,这意味着直到取消良好。

做市价单截图:

我可以看到一个市场买入订单在排队，一个市场卖出订单错过了。

在这里我收到了400 Client Error: Bad Request for url: https://api.robinhood.com/orders/。因为如果你没有足够的库存，罗宾汉不允许你发出卖出指令。

记得平仓你的DWT。

现在我试着做限价单并取消它:

限价单制作和取消截图:

所有支持的订单功能:

place _ market _ buy _ order
place _ market _ sell _ order
place _ limit _ buy _ order
place _ limit _ sell _ order
place _ stop _ loss _ sell _ order
place _ stop _ limit _ sell _ order

账户管理

如果您想查看您的当前头寸和当前市值:

然后

学习和建立一个自动交易系统并不容易。有了正确的工具，你现在可以开始制作你的第一个交易算法。接下来，我打算谈谈如何在 Robinhood 中建立一个基本的交易策略。如果你有任何问题，请在下面提问。

从头开始构建自己的神经网络的分步指南

原文：https://towardsdatascience.com/step-by-step-guide-to-building-your-own-neural-network-from-scratch-df64b1c5ab6e?source=collection_archive---------2-----------------------

学习深度学习的基础知识，并为图像分类建立自己的神经网络

Photo by Aron Visuals on Unsplash

关于机器学习、深度学习和人工智能的实践视频教程，请查看我的 YouTube 频道。

“什么”和“为什么”

什么是深度学习

我们之前都听说过深度学习。由于计算能力、数据可用性和算法方面的最新进展，它在数据科学从业者中非常受欢迎，现在被用于各种环境中。

但是深度学习到底是什么*？*

简单来说，深度学习就是指训练一个神经网络。

现在，什么是神经网络？

嗯，它只是一个适合某些数据的函数。最简单的形式是用一个函数来拟合一些数据，如下所示。这种结构被称为神经元。

Schematic of a neuron

函数可以是任何东西:线性函数或 sigmoid 函数。当然，单个神经元并没有优于传统机器学习算法的优势。

所以一个神经网络结合了多个神经元。将神经元视为神经网络的构建模块。通过堆叠它们，可以构建如下所示的神经网络:

Schematic of a neural network

注意上面每个输入是如何输入到每个神经元的。神经网络会自己计算出哪个函数最符合数据。你需要提供的只是输入和输出。

为什么要用深度学习？

深度学习已经成功应用于许多监督学习设置中。传统的神经网络应用于在线广告目的。卷积神经网络( CNN )非常适合照片标记，递归神经网络( RNN )用于语音识别或机器翻译。

近年来，我们的数字活动显著增加，产生了非常大量的数据。虽然传统机器学习方法的性能将随着更多数据的使用而趋于平稳，但足够大的神经网络将随着更多数据的可用而提高性能。近年来，数据存储变得非常便宜，计算能力允许训练这种大型神经网络。

这就是为什么深度学习现在如此令人兴奋。我们可以访问大量的数据，我们有计算能力来快速测试、构思和重复实验，以提出强大的神经网络！

现在我们知道了什么是深度学习，以及它为什么如此棒，让我们编码我们的第一个用于图像分类的神经网络！点燃你的 Jupyter 笔记本！

Yes, our neural network will recognize cats. Classic, but it’s a good way to learn the basics!

你的第一个神经网络

目标是建立一个神经网络，该网络将图像作为输入和输出，不管它是不是猫的图片。

在此随意获取整个笔记本和数据集。它还包含一些用于导入数据集的实用工具。

导入数据

和往常一样，我们首先导入相关的包来使我们的代码工作:

然后，我们加载数据，看看图片是什么样的:

您应该会看到以下内容:

Example of a cat image in the dataset

然后，让我们打印出关于数据集的更多信息:

您应该会看到:

General information about the dataset

如你所见，我们在训练集中有 209 幅图像，我们有 50 幅图像用于训练。每个图像是一个 64px 宽和高的正方形。此外，您会注意到图像的第三维是 3。这是因为图像由三层组成:红色层、蓝色层和绿色层(RGB)。

A picture is composed of three layers

每层中的每个值都在 0 到 255 之间，它代表该像素的红色，或蓝色，或绿色，为每种组合生成一种独特的颜色。

现在，我们需要在将图像输入到我们的神经网络之前将它们展平:

太好了！您现在应该看到训练集的大小为(12288，209)。这意味着我们的图像被成功地展平了

12288 = 64 x 64 x 3。

最后，我们将数据集标准化:

选择激活功能

建立神经网络的第一步是找到合适的激活函数。在我们的例子中，我们希望预测一张图片是否有猫。因此，这可以被框定为一个二元分类问题。理想情况下，我们应该有一个为猫图片输出 1 的函数，否则输出 0。

你可能已经知道，sigmoid 函数在这里是有意义的。我假设你知道 sigmoid 函数的大部分性质。不然可以在这里了解更多。

数学上，sigmoid 函数表示为:

Sigmoid function

因此，让我们定义 sigmoid 函数，因为稍后它会变得很方便:

太好了，但是什么是 z ？它是加权输入，表示为:

Weighted input

其中 w 为权重矩阵， b 为偏差。现在，我们需要初始化权重和偏差。

将权重视为一个特性的重要性。通常我们将其初始化为非零随机值。

偏差是我们添加的常数，就像线性方程的截距。这为神经网络提供了一个额外的参数来调整，以提高拟合度。偏置可以初始化为 0。

现在，我们需要为正向传播和反向传播定义一个函数。

在前向传播期间，执行一系列计算以生成预测并计算成本。成本是我们希望最小化的函数。在我们的例子中，成本函数将是:

Cost function

其中 y 是观察值，而 y_hat 是预测值。

然后，反向传播计算梯度或导数。这在优化阶段将是有用的，因为当导数接近或等于 0 时，这意味着我们的参数被优化以最小化成本函数。

因此，我们编写以下函数:

太好了！如上所述，我们需要重复正向传播和反向传播来更新参数，以便最小化成本函数。这是使用梯度下降完成的。为此，我们设置了一个学习率，它是一个小的正值，控制每次运行时参数的变化幅度。

为学习率 a 选择一个合适的值很重要，如下所示:

Pot of the cost as a function of the weights. Left: small learning rate. Right: large learning rate.

如果太小，就需要更长的时间来训练你的神经网络，如左图所示。如果它太大，你可能永远不会达到全局最小值，梯度下降将永远振荡。

在我们的例子中，我们将像这样更新参数:

Gradient descent

其中 alpha 是学习率。在代码中，我们写道:

太棒了，我们快完成了！我们需要做的就是计算一个预测。知道 sigmoid 函数输出一个 0 到 1 之间的值，我们就确定如果值大于 0.5，我们就预测一个正例(是猫)。否则，我们将预测一个错误的例子(不是猫)。

太神奇了！将我们所有的功能组合成一个单一的模型应该是这样的:

现在，我们可以训练我们的模型并进行预测了！

运行上面的代码单元后，您应该看到在测试集上获得了 99%的训练准确率和 70%的准确率。对于一个简单的神经网络来说还不错！

您甚至可以将成本绘制为迭代次数的函数:

您应该会看到:

Cost function going down as more iterations are performed

你会看到每次迭代后成本确实在下降，这正是我们想要的。

随意试验不同的学习速率和迭代次数，看看它如何影响训练时间和模型的准确性！

恭喜你！您学习了深度学习的基础知识，并建立了您的第一个用于图像分类的神经网络！这篇文章中解释的概念是理解更复杂和更高级的神经网络结构的基础。

在未来的中，我们将通过建立一个具有更多层的更深神经网络，将我们的图像分类器带到下一个级别，并看看它是否能提高性能。

敬请关注，继续学习！

来源: 深度学习 AI

创建文本到语音到文本电子邮件助手的分步指南

原文：https://towardsdatascience.com/step-by-step-guide-to-creating-a-text-to-voice-to-text-email-assistant-ca62eaf96437?source=collection_archive---------28-----------------------

Photo by Charles 🇵🇭 on Unsplash

在这篇文章中，我将描述如何创建您的个人电子邮件秘书。

这个电子邮件秘书是一个电子邮件应用程序，它使用 Gmail API 读取您的电子邮件，使用 Google 文本到语音 API 和“playsound”API 读出您的电子邮件，使用“py audio”API 听到您的响应，使用 Google 语音到文本 API 将音频响应转换为文本，最后使用 Gmail API 再次发送响应。

要查看这个电子邮件助手的运行情况，请观看视频

我相信你一定很想知道它是如何创建的，以及所有的步骤都需要什么。所以让我们开始吧。我将详细列出所有应该易于遵循和实施的步骤

步骤 1:创建虚拟环境并安装 Python 库

整个程序是在 mac-book-pro 上编写的，但它是独立于平台的，可以在 windows pc/laptop 上遵循相同的步骤。除此之外，我使用 anaconda python 安装和 pycharm 社区版作为编程编辑器。如果您熟悉创建虚拟环境和安装 python 库，请直接跳到下一节。

在虚拟环境中工作总是安全的，以防止应用程序之间的库冲突

1a。创建虚拟环境

在 mac 终端窗口创建您的虚拟环境，并安装 playsound 和 pyaudio 库

*#conda create — name p36
#conda activate p36
#pip install playsound
#pip install pyaudio*

第二步:配置谷歌云平台

在这一步中，我们需要转到 google cloud 开发者平台，创建服务密钥、凭证并激活相关的 API 来使用它们。谷歌。

2a。激活环境

在激活时，谷歌会要求你提供信用卡，并承诺在年底不会拖欠你的费用。如果提供 300 美元的 1 年免费信贷，则使用 API

链接激活您的账户【https://console.developers.google.com/

Google Cloud Platform Activation Steps

Google Cloud Platform Activation Success

不幸的是，随后启用 API、创建服务密钥和凭证的后续步骤相当复杂，但请继续

2b。创建服务帐户密钥

Create Service Account Key — Input

完成这一步后，会创建一个扩展名为. json 的密钥文件。下载此服务帐户密钥。此密钥是根据您的程序的身份验证要求提供的

2c。创建 OAuth2.0 凭据

这一步是为了让您的应用程序能够访问 GMAIL。我们将申请’撰写’和’发送’电子邮件，以便能够适时运行我们的原型

在此步骤之后，凭证页面将如下所示，即带有服务帐户密钥和 OAuth 客户端 id。

Final Credentials Page

下载相关凭证到您计算机上存储 python 脚本的文件夹中(任何地方都可以，只要您提供应用程序的正确路径)

2d。激活文本到语音、语音到文本和 Gmail APIs

最后，我们激活文本到语音 API、语音到文本 API 和 Gmail API。在仪表板上，您会看到“启用 API 和服务”选项。

Enable APIS on the dashboard

从过多的 API 和服务中启用的最简单的方法是通过搜索(常见的是 Google，你还能在那里做什么)。请参见下面的搜索文本到语音和语音到文本 API 的示例。

Searching for APIS to enable

找到 API 后，只需点击启用(下面是 Gmail 的示例)

Enable Gmail API

最后，我们准备研究程序本身。

步骤 3:运行应用程序

现在是比较容易的部分。这很简单，因为大多数代码示例都可以在 GCP 教程网站上找到，可以选择复制，还有很多解释。另一方面，这些链接有很多深层链接，为用户提供了所有的 API 选项。这导致新用户容易迷路。

在这里，我向您描述了启动和运行原型的相关部分。之后，根据 GCP 站点上的文档，按照您的特定需求进行配置就容易多了。我提供了每个特定部分的 GCP 教程的链接

运行原型的步骤是

• 从 github 下载代码到特定文件夹
• 将凭据(服务帐户密钥和 OAuth 密钥)复制到与代码相同的文件夹中
• 在 Main.py 中替换要导出的 GOOGLE_APPLICATION_CREDENTIALS 的路径

#Replace this with the correct file path of the service account key
os.environ[**'GOOGLE_APPLICATION_CREDENTIALS'**] = \
    **"/Users/name/Documents/GitHub/Python-Exercises/googleSpeechToText/GMAIL_gTtS_gStT_ServiceAccountKey.json"**

• 在 RaSmails.py 中替换 OAuth2.0 文件的名称

#Replace this with correct file path of credentials .json
flow = InstalledAppFlow.from_client_secrets_file(
    **'oath2_credentials_mailreceiver349.json'**, SCOPES)

• 在终端窗口中激活虚拟环境(#conda activate — name p36)
• 以#python Main.py 的身份运行代码

代码流程的简要概述如下:

获取 Gmail 服务实例>获取最新 5 封电子邮件的片段>将最新片段转换为音频>播放音频文件(最新电子邮件) >录制回复电子邮件>将音频转换为文本>发送回复电子邮件

以下链接详细描述了正在使用的 API

• 阅读邮件，
• 将文本转换为语音，
• 将语音转换为文本最后
• 发送邮件。

我希望你喜欢这个原型。乐意回答任何问题。让我知道你的想法

创建 R 和 Python 库的分步指南(在 JupyterLab 中)

原文：https://towardsdatascience.com/step-by-step-guide-to-creating-r-and-python-libraries-e81bbea87911?source=collection_archive---------3-----------------------

r 和 Python 是当今机器学习语言的面包和黄油。r 提供了强大的统计和快速的可视化，而 Python 提供了直观的语法和丰富的支持，是当今主流 AI 框架的首选接口。

在本文中，我们将看看用 R 和 Python 创建库的步骤。这是每个机器学习从业者都应该拥有的技能。库帮助我们组织代码并与他人共享，为数据社区提供打包的功能。

注意:在本文中，我交替使用了术语“*库”*和“包”。虽然有些人区分这些词，但我不认为这种区分有用，而且很少在实践中看到这样做。我们可以把一个库(或者包)想象成一个包含函数的脚本目录。这些功能组合在一起，帮助工程师和科学家解决挑战。

创建图书馆的重要性

如果不广泛使用库，构建今天的软件是不可能的。库极大地减少了团队将工作投入生产所需的时间和精力。通过利用开源社区，工程师和科学家可以将他们独特的贡献推向更多的受众，并有效地提高他们代码的质量。各种规模的公司都使用这些库来将他们的工作置于现有功能之上，从而使产品开发更加高效和集中。

但是创建库不仅仅是为了生产软件。库对于快速原型化想法至关重要，可以帮助团队快速验证假设和制作实验软件。虽然流行的图书馆享有大量的社区支持和一套最佳实践，但较小的项目可以在一夜之间转化为图书馆。

通过学习创建轻量级的库，我们养成了维护代码和共享工作的习惯。我们自己的开发速度大大加快，我们将编码工作锚定在一个有形的工作单元上，我们可以随着时间的推移而改进。

文章范围

在本文中，我们将重点关注用 R 和 Python 创建库，以及在 GitHub 上托管和安装它们。这意味着我们不会关注流行的托管站点，比如 R 的 CRAN 和 Python 的 PyPI 。这些额外的步骤超出了本文的范围。

只关注 GitHub 有助于鼓励从业者更频繁地开发和共享库。CRAN 和 PyPI 有许多必须满足的标准(它们经常变化)，这会减慢我们发布工作的过程。请放心，其他人从 GitHub 安装我们的库也一样容易。此外，CRAN 和 PyPI 的步骤可以在以后添加，如果你觉得你的库可以从托管站点中受益的话。

我们将使用相同的环境(JupyterLab)构建 R 和 Python 库，对这两种语言使用相同的高级步骤。这应该有助于您建立将代码打包成库所需的核心步骤的工作知识。

让我们开始吧。

设置

我们将用 R 和 Python 创建一个名为 datapeek 的库。datapeek 库是一个简单的包，提供了一些处理原始数据的有用函数。这些功能是:

encode_and_bind

remove_features

apply_function_to_column

get_closest_string

我们将在后面研究这些函数。现在，我们需要设置一个 R 和 Python 环境来创建 datapeek，以及一些支持打包代码的库。我们将在一个 Docker 容器中使用 JupyterLab ，以及一个我们需要的“Docker 栈”。

安装并运行 Docker

我们将使用的 Docker 栈被称为jupyter/data science-notebook。该图包含 R 和 Python 环境，以及许多通常在机器学习中使用的包。

因为这些都是在 Docker 里面运行的，所以你必须在你的机器上安装 Docker。所以 安装 Docker 如果你还没有的话，一旦安装好，在终端中运行以下命令拉data science-notebook:

docker pull jupyter/datascience-notebook

这将提取 Docker Hub 上托管的最新图像。

注意 : 任何时候你从 Docker Hub 拉一个项目，你都会得到最新的版本。如果距离上次拉动已经过了一段时间，请再次拉动以更新您的图像。

运行上述命令后，您应该立即看到以下内容:

一旦所有东西都被取出，我们就可以通过运行以下命令来确认我们的新映像存在:

docker images

…显示类似如下的内容:

现在我们有了 Docker 堆栈，让我们来设置 JupyterLab。

JupyterLab

我们将在一个 JupyterLab 环境中创建我们的库。JupyterLab 是一个基于 web 的编程用户界面。有了 JupyterLab，我们在浏览器中有了一个轻量级的 IDE，方便了构建快速应用程序。JupyterLab 提供了用 R 和 Python 创建库所需的一切，包括:

• 一个终端环境，用于运行 shell 命令和下载/安装库；
• 一个 R 和 Python 控制台，用于与这些语言交互工作；
• 一个简单的文本编辑器，用于创建各种扩展名的文件；
• Jupyter 笔记本用于 ML 工作的原型制作。

我们刚刚获取的 datascience-notebook 包含 JupyterLab 的安装，因此我们不需要单独安装它。在运行我们的 Docker 映像之前，我们需要挂载一个卷来确保我们的工作保存在容器之外。

首先，在你的桌面上创建一个名为 datapeek 的文件夹(或者任何你想创建的地方),然后进入这个目录。我们需要用 JupyterLab ，运行 Docker 容器，因此我们的完整命令应该如下所示:

docker run -it -v `pwd`:/home/jovyan/work -p 8888:8888 jupyter/datascience-notebook start.sh jupyter lab

你可以在这里了解更多关于 Docker 命令的信息。重要的是，上面的命令公开了我们在端口 8888 上的环境，这意味着我们可以通过浏览器访问我们的容器。

运行以上命令后，您应该会在最后看到以下输出:

这告诉我们将提供的 URL 复制并粘贴到浏览器中。打开浏览器，在地址栏中添加链接，然后按 enter 键(您的令牌会有所不同):

**localhost**:8888/?token=11e5027e9f7cacebac465d79c9548978b03aaf53131ce5fd

这将在您的浏览器中自动打开 JupyterLab 作为一个新标签:

我们现在准备开始建造图书馆。

我们从 R 开始这篇文章，然后看看 Python 。

在 R 中创建库

r 是机器学习的“两大”语言之一。在撰写本文时，它已经拥有超过 10，000 个图书馆。转到按发布日期 和运行日期列出的可用起重机包…

document.getElementsByTagName('tr').length

…在浏览器控制台中显示 13858。减去标题和最后一行，得到 13856 个包装。不用说，R 不需要变化。凭借强大的社区支持和简洁(如果不是直观的话)的语言，R 轻松地位居值得学习的统计语言之首。

关于创建 R 包最著名的论文是哈德利·威卡姆的书 R 包。它的内容可以在网上免费获得。如果想更深入地了解这个话题，我建议去那里看看。

我们将使用 Hadley 的 devtools 包来抽象出创建包所涉及的繁琐任务。dev tools已经安装在我们的 Docker Stacks 环境中。我们还需要 roxygen2 包，它帮助我们记录我们的函数。因为它没有预装我们的映像，所以让我们现在安装它。

注意:从现在开始我们将使用 JupyterLab 中的终端，以便于在浏览器中保存我们的工作。

打开 JupyterLab 发射器内的终端:

注意:如果您想将 JupyterLab 更改为黑暗主题，点击顶部的设置，点击 JupyterLab 主题，然后点击 JupyterLab 黑暗:

在控制台内键入 R，然后…

install.packages("roxygen2")
library(roxygen2)

安装好必要的软件包后，我们就可以开始每一步了。

步骤 1:创建包框架

我们需要为我们的包创建一个目录。我们可以使用 devtools create 函数，在一行代码中做到这一点。在终端运行中:

devtools::create("datapeek")

这将自动创建定义我们的 R 包所需的基本文件和目录。在 JupyterLab 中，你会在左侧看到一组新创建的文件夹和文件。

注意:你还会看到你的新目录结构在你的桌面上(或者你选择创建它的任何地方)被创建，因为我们在设置期间挂载了一个卷到我们的容器中。

如果我们在 JupyterLab 检查我们的包装，我们现在看到:

**datapeek**
├── **R**
├── datapeek.Rproj
├── DESCRIPTION
├── NAMESPACE

R 文件夹最终会包含我们的 R 代码。我的包。Rproj 文件是特定于 RStudio IDE 的，所以我们可以忽略它。描述文件夹存放我们包的元数据(关于的详细讨论可以在这里找到)。最后， NAMSPACE 是一个确保我们的库与其他库很好地配合的文件，并且更多的是一个 CRAN 需求。

命名规格

命名 R 包时，我们必须遵循这些规则:

• 在曲柄上必须是唯一的(你可以在这里查看所有当前的 R 库)；
• 是否只能由字母、数字和句点组成；
• 不能包含下划线或连字符；**
• 必须以字母**开始*；*
• 不能在周期内结束*；*

你可以在这里阅读更多关于命名包的内容。我们的包名“datapeek”通过了上述标准。让我们转向曲柄并执行命令+F* 搜索“数据检查”以确保它没有被占用:*

Command + F search on CRAN to check for package name uniqueness.

…看起来我们很好。

步骤 2:填写描述细节

文件的工作是存储关于我们包的重要元数据。这些数据包括运行我们的库所需的其他包，我们的许可证，以及我们的联系人信息。从技术上来说，R 中的包的定义是包含一个DESCRIPTION文件的任何目录，所以总是要确保它存在。

C 点击 JupyterLab 目录列表中描述文件上的 。您将看到我们运行devtools::create(“datapeek”)时自动创建的基本细节:

让我们添加我们的具体细节，以便我们的包包含必要的元数据。只需在 JupyterLab 中编辑这个文件。以下是我补充的细节:

• 包装 : datapeek
• 标题 : Provides useful functions for working with raw data.
• 版本 : 0.0.0.1
• 作者@R : person(“Sean”, “McClure”, email=”sean.mcclure@example.com”, role=c('aut','cre'))
• 描述:data peek 包帮助用户转换用于机器学习开发的原始数据。
• 取决于 : R (≥ 3.5.1)
• 执照 : MIT
• 编码 : UTF-8
• LazyData : true

当然你应该用你自己的细节填写这些部分。你可以在哈德利关于元数据的章节中读到更多关于这些的定义。作为一个简单的概述…这些package、title和version部分是不言自明的，只要确保将* title 保持在一行。Authors@R必须遵循你上面看到的格式，因为它包含可执行的 R 代码。注意角色参数，它允许我们列出本库的主要贡献者。常见的有:*

aut : 作者

cre : 创建者或维护者

ctb : 投稿人

cph : 版权所有者

还有更多的选项，完整列表见此处。

您可以通过将多个作者列为一个向量来添加他们:

*Authors@R: as.person(c(
    "Sean McClure <sean.mcclure@example.com> [aut, cre]", 
    "Rick Deckard <rick.deckard@example.com> [aut]",
    "RachaelTyrell <rachel.tyrell@example.com> [ctb]"
))*

注意:如果你计划在 CRAN 上托管你的图书馆，确保你的电子邮件地址是正确的，因为 CRAN 会用这个联系你。

description可以是多行，限 1 段。我们使用depends来指定我们的包所依赖的 R 的最低版本。您应该使用与您用来构建库的版本相同或更高的 R 版本。今天大多数人把他们的License设置为 MIT，它允许任何人“使用、复制、修改、合并、出版、分发、再许可和/或出售软件的拷贝”,只要你的版权包括在内。你可以在这里了解更多关于麻省理工学院许可证的信息。Encoding确保我们的库可以使用现代解析器打开、读取和保存，而LazyData指的是如何加载我们包中的数据。因为我们将我们的设置为 true，这意味着我们的数据在被使用之前不会占用内存。

步骤 3:添加函数

3A:向 R 文件夹添加功能

我们的图书馆没有功能就没什么用。让我们添加本文开头提到的 4 个函数。下面的要点显示了我们在 R 中的 datapeek 函数:

我们必须将我们的函数添加到 R 文件夹，因为这是 R 在库中查找函数的地方。

***datapeek**
├── **R**
├── datapeek.Rproj
├── DESCRIPTION
├── NAMESPACE*

由于我们的库只包含 4 个函数，我们将把它们放入一个名为 utilities 的文件中。R ，这个文件位于 R 文件夹中。

进入 JupyterLab 中的目录，打开 R 文件夹。**点击启动器中的文本文件*** 并粘贴到我们的 4 R 函数中。右击该文件并重命名为 utilities.R。*

3B:导出我们的函数

仅仅将 R 函数放在我们的文件中是不够的。每个函数都必须导出才能向我们库的用户公开。这是通过在每个函数上方添加 @export 标签来实现的。

导出语法来自 Roxygen ，并确保我们的函数被添加到名称空间中。让我们将@export 标签添加到我们的第一个函数中:

对其余的函数也这样做。

注意 :在更大的库中，我们只导出需要在我们的包之外可用的函数。这有助于减少与另一个库冲突的机会。

3C:记录我们的功能

记录我们的功能很重要。文档功能为用户提供信息，这样当他们输入?datapeek时，他们就可以获得关于我们的包的细节。文档还支持使用小插图，这是一种长格式的文档。你可以在这里阅读更多关于记录函数的信息。

我们将采取 2 个子步骤:

• 添加文档注释
• 运行

—添加文档注释

文档被添加到我们的功能之上*，直接在我们的#’ @export 行之上。下面是我们第一个函数的例子:***

为了可读性，我们将这些行隔开，添加了标题、描述和函数使用的任何参数。让我们为我们的剩余功能这样做:

—运行 devtools::document()

将文档添加到我们的函数中，然后在根目录外的终端、中运行以下内容:

*devtools::document()*

注意:确保你在 datapeek 目录之外的一级。

您可能会得到错误:

*Error: ‘roxygen2’ >= 5.0.0 must be installed for this functionality.*

在这种情况下打开 JupyterLab 中的 端子并安装 roxygen2* 。您还应该安装 data.table 和 mltools，因为我们的第一个函数使用这些工具:***

*install.packages('roxygen2')
install.packages('data.table')
install.packages('mltools')*

再次运行devtools::document()。您应该看到以下内容:

这会生成*。Rd 文件里面有一个新的人文件夹**。你会注意到。Rd 文件是为我们包中的每个函数*创建的。**

如果您查看您的描述文件，它现在会在底部显示一个新行:

这也将生成一个名称空间文件:

我们可以看到我们的 4 个功能已经暴露。现在让我们继续确保在我们的库中指定依赖关系。

步骤 4:列出外部依赖关系

我们的函数经常需要其他库中的函数。我们必须做两件事来确保外部功能对我们库的功能可用:

1. 在我们的函数中使用 双冒号来指定我们所依赖的库；
2. 将 导入添加到我们的描述文件中。

你会注意到，在上面的要点中，我们只是将我们的库列在了顶部。虽然这在独立的 R 脚本中工作得很好，但这不是在 R 包中使用依赖关系的方式。当创建 R 包时，我们必须使用" 双冒号方法 "来确保正确的函数被读取。这与 R 包中的“顶层代码”(不像函数那样是对象的代码)如何只在编译包时执行，而不是在加载包时执行有关。

例如:

***library(mltools)**do_something_cool_with_mltools <- function() {
    auc_roc(preds, actuals)
}*

…不起作用，因为auc_roc将不可用(运行库(datapeek)不重新执行库(mltools))。这个将工作:

*do_something_cool_with_mltools <- function() {
    **mltools::**auc_roc(preds, actuals)
}*

我们的 datapeek 包中唯一需要额外包的函数是我们的第一个函数:

Using the double-colon approach to specify dependent packages in R.

注意每次我们调用一个外部函数时，我们都会在它前面加上外部库和双冒号。

我们还必须在我们的DESCRIPTION文件中列出外部依赖项，这样它们才能被正确处理。让我们将 我们的导入添加到描述文件:

确保导入的库用逗号分隔。注意，我们没有为外部依赖项指定任何版本。如果我们需要指定版本，我们可以在包名后面使用括号:

*Imports:
    data.table (>= 1.12.0)*

由于我们的encode_and_bind函数没有利用任何最新的更新，我们将不对它指定任何版本。

步骤 5:添加数据

有时在我们的库中包含数据是有意义的。包数据可以让我们的用户练习我们的库的功能，也有助于测试*，因为机器学习包总是包含摄取和转换数据的功能。将外部数据添加到 R 包的 4 个选项是:*

1. 二进制数据
2. 解析的数据
3. 原始数据
4. 序列化数据

你可以在这里了解更多关于这些不同方法的信息。对于本文，我们将坚持使用最常见的方法，即将外部数据添加到 R 文件夹。

让我们将虹膜数据集添加到我们的库中，以便为用户提供一种快速测试我们功能的方法。数据必须在中。rda 格式，使用 R 的**save()**函数创建，并具有与文件相同的名称。我们可以通过使用 devtools 的use_data函数来确保满足这些标准:

*x <- read.csv("[http://bit.ly/2HuTS0Z](http://bit.ly/2HuTS0Z')")
devtools::use_data(x, iris)*

在上面，我从 Iris 数据集的 URL 中读取它，并将数据帧传递给devtools::use_data()。

在 JupyterLab 中，我们看到创建了一个新的数据文件夹，以及我们的 iris.rda 数据集:

***datapeek**
├── **data** └── iris.rda
├── **man**
├── **R** ├── datapeek.Rproj
├── DESCRIPTION
├── NAMESPACE*

在接下来的部分中，我们将使用我们添加的数据集来运行测试。

步骤 6:添加测试

测试是软件开发的一个重要部分。测试有助于确保我们的代码按预期工作，并使调试代码成为一个更快、更有效的过程。点击了解更多关于测试 R 包的信息。

测试中的一个常见挑战是知道我们应该测试什么。测试大型库中的每一个功能都很麻烦，而且并不总是需要，而测试不足会使发现和纠正出现的错误变得更加困难。

我喜欢马丁·福勒关于何时测试的下面这段话:

每当您想在 print 语句或调试器表达式中键入某些内容时，请将其编写为测试—马丁·福勒

如果您定期构建应用程序原型，您会发现自己经常向控制台写东西，看看一段代码是否返回您所期望的结果。在数据科学中，编写交互式代码甚至更常见，因为机器学习工作是高度实验性的。一方面，这提供了充分的机会来思考编写哪些测试。另一方面，机器学习代码的不确定性意味着测试 ML 的某些方面可能不那么简单。作为一般规则，寻找每次都应该返回相同输出的明显确定性代码段。

我们在数据科学中做的交互测试是手动*，但是我们在我们的包中寻找的是自动测试。自动化测试意味着我们运行一套预定义的测试，以确保我们的包端到端地工作。*

虽然在软件中有很多种测试，但这里我们主要讨论“单元测试”从单元测试的角度思考迫使我们将代码分解成更多的模块化组件，这是软件设计中的良好实践。

注意 :如果你习惯用 Python 这样的语言测试，注意 R 本质上更 functional (即方法属于函数而不是类)，所以会有一些区别。

我们将采取 2 个子步骤来测试我们的 R 库:

6A :创建tests/testthat文件夹；

6B :写作测试。

— 6A: 创建 **tests/testthat** 文件夹

正如 R 希望我们的 R 脚本和数据放在特定的文件夹中一样，它也希望我们的测试也是如此。为了创建 tests 文件夹，我们在 JupyterLab 的 R 控制台中运行以下命令:

*devtools::use_testthat()*

您可能会得到以下错误:

*Error: ‘testthat’ >= 1.0.2 must be installed for this functionality.*

如果是这样的话，使用上面相同的方法在 Jupyter 的终端中安装 roxygen2。

*install.packages('testthat')*

运行devtools::use_testthat()将产生以下输出:

** Adding testthat to Suggests
* Creating `tests/testthat`.
* Creating `tests/testthat.R` from template.*

现在我们的主目录中会有一个新的测试文件夹:

***datapeek**
├── **data** ├── **man**
├── **R** ├── **tests** └── testthat.R├── datapeek.Rproj
├── DESCRIPTION
├── NAMESPACE*

上面的命令还在 tests 文件夹中创建了一个名为testthat.R的文件。当R CMD check运行时，它会运行所有的测试(我们很快就会看到)。您还会注意到test 在我们的DESCRIPTION文件中的建议下添加了*:*

— 6B:写作测试

test 这是 R 最流行的单元测试包，至少有 2600 个 CRAN 包使用，更不用说 Github 上的库了。你可以在 Tidyverse 页面这里查看关于 testthat 的最新消息。也可以查看它的文档。

我们需要考虑 3 个级别的测试:

• ****期望(断言):一次计算的预期结果；
• ****测试:将单个功能的多个期望，或者跨多个功能的相关功能组合在一起；
• ****文件:将多个相关测试组合在一起。文件被赋予一个人类可读的名称context().

断言

断言是我们选择的测试库中包含的函数。我们使用断言来检查我们自己的函数是否返回预期的输出。断言有多种风格，这取决于被检查的内容。在接下来的部分，我将介绍 R 编程中使用的主要测试，展示每一个失败的测试，这样你就可以理解它是如何工作的。

相等断言断言****

• expect_equal()
• expect_identical()
• expect_equivalent

***# **test for** **equality**
a <- 10
expect_equal(a, 14)> Error: `a` not equal to 14.# **test for identical** 
expect_identical(42, 2)> Error: 42 not identical to 2.# **test for equivalence** 
expect_equivalent(10, 12)> Error: 10 not equivalent to 12.***

上面的例子之间有细微的差别。例如，expect_equal用于检查在数值公差内是否相等，而expect_identical用于测试是否完全相等。以下是一些例子:****

***expect_equal(10, 10 + 1e-7) # true
expect_identical(10, 10 + 1e-7) # false***

随着你写更多的测试，你会明白什么时候使用每一个。当然，如有疑问，请参考上述文件。

测试字符串和是否匹配****

• expect_match()

***# **test for string matching**
expect_match("Machine Learning is Fun", "But also rewarding.")> Error: "Machine Learning is Fun" does not match "But also rewarding.".***

测试长度****

• expect_length

***# **test for length** 
vec <- 1:10
expect_length(vec, 12)> Error: `vec` has length 10, not length 12.***

比较测试

• expect_lt
• expect_gt

***# **test for less than**
a <- 11
expect_lt(a, 10)> Error: `a` is not strictly less than 10\. Difference: 1# **test for greater than**
a <- 11
expect_gt(a, 12)> Error: `a` is not strictly more than 12\. Difference: -1***

测试逻辑****

• expect_true
• expect_false

***# **test for** **truth** 
expect_true(5 == 2)> Error: 5 == 2 isn't true.# **test for** **false** 
expect_false(2 == 2)> Error: 2 == 2 isn't false.***

测试输出****

• expect_output
• expect_message

***# **testing for outputs** 
expect_output(str(mtcars), "31 obs")> Error: `str\(mtcars\)` does not match "31 obs".# **test for warning** 
f <-function(x) {
  if(x < 0) {
    message("*x* is already negative")
  }
}expect_message(f(1))> Error: `f(1)` did not produce any messages.***

testthat 库中包含了更多。如果你是测试新手，开始写一些简单的来适应这个过程。随着时间的推移，你会对测试什么和何时测试有一个直觉。

写作测试

一个测试是一组断言。我们在 tests 中编写如下测试:**

*****test_that**("this functionality does what it should", {
    // group of assertions here
})***

我们可以看到我们既有描述*(测试名称)又有代码(包含断言)。描述完成了句子，“测试那个…”***

上面，我们说“测试这个功能做了它应该做的事情。”

断言是我们想要测试的输出。例如:

*****test_that**("trigonometric functions match identities", {
      expect_equal(sin(pi / 4), 1 / sqrt(2))
      expect_equal(cos(pi / 4), 1 / sqrt(10))
      expect_equal(tan(pi / 4), 1)
    })> Error: Test failed: 'trigonometric functions match identities'***

注 :结合我们的测试文件，需要考虑内聚和耦合之间的平衡。正如 Hadley 在书中所说，“这两个极端显然是不好的(所有测试在一个文件中，每个测试一个文件)。你需要找到一个适合你的快乐的媒介。一个好的起点是为每个复杂的功能准备一个测试文件。”

创建文件

我们在测试中做的最后一件事是创建文件。如上所述，测试中的“文件”是一组覆盖相关功能集的测试。我们的测试文件必须位于tests/testthat/目录中。下面是 GitHub 上的 stringr 包的测试文件示例:

Example Test File from the stringr package on GitHub.

这个文件叫做测试用例。r(以“test”开头)位于tests/testthat/目录中。顶部的上下文只允许我们提供文件内容的简单描述。当我们运行测试时，它会出现在控制台中。**

让我们创建我们的测试文件*，它将包含与我们的 4 个函数相关的测试和断言。像往常一样，我们在 Launcher 中使用 JupyterLab 的文本文件来创建和重命名一个新文件:***

Creating a Test File in R

现在让我们添加我们的测试:

对于第一个函数，我将确保返回具有正确特征数量的数据帧*😗**

注意我们如何调用我们的encode_and_bind函数，然后简单地检查维度和预期输出之间的相等性。我们在任何时候运行我们的自动化测试，以确保我们的测试文件运行，并且我们得到预期的输出。在控制台中运行devtools::test()运行我们的测试:

我们也得到了一个笑脸！

由于我们的第二个函数删除了一个指定的特征，我将使用与上面相同的测试，检查返回的框架的尺寸。我们的第三个函数将指定的函数应用到选择的列，所以我将编写一个测试来检查给定指定函数的结果。最后，我们的第四个函数返回最接近的匹配字符串，所以我将简单地检查返回的字符串以获得预期的结果。**

以下是我们的完整测试文件:

注意 :注意测试文件中数据的相对路径。

测试我们的包

如上所述，我们使用以下命令运行测试:

***devtools::test()***

这将运行我们放在 testthat 目录中的任何测试文件中的所有测试。让我们来看看结果:

我们在 4 个单元测试中有 5 个断言，放在一个测试文件中。看来我们没事了。如果我们的任何测试失败，我们将在上面的打印输出中看到这一点，在这一点上，我们将寻求纠正问题。

步骤 7:创建文档

这通常是通过在 R 中使用“Vignettes”来完成的。你可以在这里了解如何为你的 R 包创建 R vignettes。就我个人而言，我认为这是一种过时的文档方法。我更喜欢用类似于狮身人面像或者 T21 的东西。文档应该很容易共享、搜索和托管。

点击 julepcode.com 大学的问号，了解如何使用 Julep。

我为我们的 R datapeek 库创建并托管了一些简单的文档，你可以在这里找到。

当然我们也会在 GitHub 上有这个库，我会在下面介绍。

第八步:共享你的 R 库

正如我在引言中提到的，我们应该定期创建库，这样其他人就可以受益于并扩展我们的工作。最好的方法是通过 GitHub ，这是开源软件项目分发和协作的标准方式。

如果您是 GitHub 的新手，这里有一个快速教程可以帮助您入门，这样我们就可以将我们的 datapeek 项目推到远程 repo。

注册/登录 GitHub 并 创建一个新的库 。

…这将为我们提供通常的屏幕:

使用我们的远程回购设置，我们可以在我们的机器上初始化我们的本地回购*，并发送我们的第一个提交。***

打开 JupyterLab 中的终端，进入 datapeek 目录:

初始化本地 repo :

***git init***

添加远程原点(您的链接会有所不同):

***git remote add origin [https://github.com/sean-mcclure/datapeek.git](https://github.com/sean-mcclure/datapeek.git)***

现在运行git add .将当前目录和所有子目录下所有修改的和新的(未跟踪的)文件添加到 staging 区域:

***git add .***

不要忘记上面命令中的“点”。现在我们可以提交我们的更改，这将任何新代码添加到我们的本地回购中。**

但是，由于我们在 Docker 容器中工作，与我们的本地回购相关联的用户名和电子邮件不能被自动检测。我们可以通过在终端中运行以下命令来设置****:****

*****git config --global user.email {emailaddress}
git config --global user.name {name}*****

使用您用来登录 GitHub 的电子邮件地址和用户名。

现在我们可以承诺:

*****git commit -m 'initial commit'*****

提交新代码后，我们可以进行推送，将最后一次提交转移到我们的 remote repo:

*****git push origin master*****

注意 :因为我们在 Docker 中，你可能会再次被要求认证。出现提示时，只需添加您的 GitHub 用户名和密码。然后再次运行上面的命令。****

一些读者会注意到我们没有在目录中放置一个.gitignore文件。将所有文件放入较小的 R 库中通常没问题。对于更大的库，或者包含大型数据集的库，你可以使用站点 gitignore.io 来看看常见的 gitignore 文件是什么样子的。这里是一个用于 R 的通用 R .gitignore 文件:

Example .gitignore file for an R package

概括地说，git add 将当前目录中所有修改过的和新的(未跟踪的)文件添加到 staging 区域。提交将任何更改添加到我们的本地回购，而推送将最后的提交转移到我们的远程回购。虽然git add可能看起来是多余的，但它存在的原因是因为有时我们只想提交某些文件，这样我们可以有选择地存放文件。上面，我们通过在git add后使用“点”来暂存所有的文件。****

你可能还注意到我们没有包括一个自述文件。您确实应该包括这一点，但是为了简洁起见，我省略了这一步。****

现在，任何人都可以使用我们的库。👍让我们看看怎么做。

步骤 9:安装你的 R 库

正如在引言中提到的，我不会在本文中讨论 CRAN。坚持使用 GitHub 使得频繁共享我们的代码变得更加容易，并且我们总是可以在以后添加 CRAN 标准。

要从 GitHub 安装一个库，用户只需在本地机器上运行以下命令:

*****devtools::install_github("yourusername/mypackage")*****

因此，我们可以简单地指示希望使用 datapeek 的其他人在他们的本地机器上运行以下命令:

*****devtools::install_github("sean-mcclure/datapeek")*****

这是我们将包含在自述文件和/或我们创建的任何其他文档中的内容。这将像我们从 CRAN 获得的任何其他软件包一样安装我们的软件包:

然后，用户像往常一样加载库，一切就绪:

*****library(datapeek)*****

我建议在一个新的 R 环境中尝试上述命令，以确认新库的安装和加载符合预期。

用 PYTHON 创建库

创建 Python 库遵循与我们之前看到的 r 相同的高级步骤。我们需要一个基本的目录结构和适当的命名约定，函数和描述*，导入，指定依赖关系，添加数据集，文档，以及能够共享并允许其他人安装我们的库*****

我们将使用 JupyterLab 来构建我们的 Python 库，就像我们对 r。

库 vs 包 vs 模块

*****在本文的开始，我讨论了“**库”**和“**包”*之间的区别，以及我是如何喜欢交替使用这些术语的。这同样适用于 Python 库。"模块"是另一个术语，在 Python 中简单地指任何包含 Python 代码的文件。Python 库显然包含作为脚本的模块。

在我们开始之前:

我在介绍中说过，我们将在 GitHub 上托管和安装我们的库。这鼓励了库的快速创建和共享，而不会因为在流行的 R 和 Python 包托管站点上发布标准而陷入困境。

Python 最流行的托管站点是 Python 包索引( PyPI )。这里是寻找、安装和发布* python 库的地方。每当您运行pip install <package_name>(或easy_intall)时，您都会从 PyPI 获取一个包。*****

虽然我们不会讨论在 PyPI 上托管我们的包，但是看看我们的库名是否是唯一的还是一个好主意。这将最大限度地减少与其他流行 Python 库的混淆，并提高我们的库名与众不同的可能性，如果有一天我们决定在 PyPI 上托管它的话。

首先，我们应该遵循一些 Python 库的命名约定。

Python 库命名约定

• 全部用小写；
• 让名字在 PyPI 上唯一(在 PyPI 上搜索名字)****
• 没有连字符(可以用下划线分隔单词)****

我们的库名是 datapeek ，所以满足第一个和第三个标准；让我们检查 PyPI 的唯一性:

一切都好。👍

我们现在已经准备好完成创建 Python 库所需的每个步骤。

步骤 1:创建包框架

JupyterLab 应按照本文设置部分中的说明启动并运行。

使用 JupyterLab 的新文件夹和文本文件选项创建以下目录结构和文件*😗****

*******datapeek**
├── **datapeek**
    └── __init__.py
    └── utilities.py
├── setup.py*****

注 : 粗体名称为文件夹和浅色名称为文件*。我们将把内部 datapeek 文件夹称为“模块目录”，把外部 datapeek 目录称为“根目录”。*****

下面的视频展示了我在 JupyterLab 中创建 datapeek 目录的过程:

有些文件我们不想提交给源代码管理。这些文件是由 Python 构建系统创建的。照此，我们也把加上下面的。gitignore 文件到我们的包框架:****

注 :在撰写本文时，JupyterLab 缺少在浏览器中切换隐藏文件的前端设置。因此，我们将简单地把我们的文件命名为 gitignore(前面没有点)；在推送到 GitHub 之前，我们会把它改成一个隐藏文件。

将你的 gitignore 文件作为一个简单的文本文件添加到根目录:

*******datapeek**
├── **datapeek**
    └── __init__.py
    └── utilities.py
├── setup.py
├── gitignore*****

步骤 2:填写描述细节

正如我们对 R 所做的一样，我们应该添加关于我们新库的元数据。我们使用设置工具来完成这项工作。Setuptools 是一个 Python 库，旨在方便打包 Python 项目。****

打开 setup.py 并为我们的库添加以下详细信息:

当然，您应该将创作更改为您自己的创作。稍后我们将向该文件添加更多的细节。这些关键字是不言自明的。url是我们项目在 GitHub 上的 URL，后面会添加；除非您已经创建了 python repo，在这种情况下，现在添加 URL。我们在 R 部分讨论了许可。zip_safe简单地说，我们的包可以作为一个 zip 文件安全地运行，这是通常的情况。你可以在这里了解更多关于可以添加到 setup.py 文件的内容。

步骤 3:添加函数

我们的库显然需要函数有用。对于更大的库，我们将组织我们的模块以平衡内聚/耦合，但是因为我们的库很小，我们将简单地把所有的函数放在一个文件中。

我们将添加与 R 相同的函数，这次是用 Python 编写的:

****将这些函数添加到utilities.py模块，在 datapeek 的模块目录中。

步骤 4:列出外部依赖关系

我们的库经常需要其他包作为依赖关系。当安装我们的库时，我们用户的 Python 环境需要知道这些(所以也可以安装这些其他的包)。 Setuptools 提供了install_requires关键字来列出我们的库所依赖的任何包。

我们的 datapeek 库依赖于用于模糊字符串匹配的 fuzzywuzzy 包和用于数据结构高性能操作的 pandas 包。要指定我们的依赖关系、、*，请将以下内容添加到您的 setup.py 文件中:*******

*****install_requires=[
    'fuzzywuzzy',
    'pandas'
]*****

您的 setup.py 文件当前应该如下所示:

我们可以通过在 JupyterLab 终端会话中运行以下命令来确认一切正常:

*****python setup.py develop*****

注意 :在 datapeek 的根目录下运行这个。

运行该命令后，您应该会看到类似这样的内容:

…结尾写道:

Finished processing dependencies for datapeek==0.1

如果我们的一个或多个依赖项在 PyPI 上不可用，但在 Github 上可用(例如，一个尖端的机器学习包只在 GitHub 上可用…或者它是我们团队的另一个库，只托管在 GitHub 上)，我们可以在设置调用中使用dependency_links:

*****setup(
    ...
    dependency_links=['http://github.com/user/repo/tarball/master#egg=package-1.0'],
    ...
)*****

如果要添加额外的元数据，比如状态、许可、语言、版本等。我们可以这样使用classifiers:****

*****setup(
    ...
    classifiers=[
        'Development Status :: 3 - Alpha',
        'License :: OSI Approved :: MIT License',
        'Programming Language :: Python :: 2.7',
        'Topic :: Text Processing :: Linguistic',
      ],
    ...
)*****

要了解更多关于可以添加到 setup.py 文件中的不同分类器的信息，请参见这里的。

步骤 5:添加数据

正如我们在 R 中所做的一样，我们可以将数据添加到我们的 Python 库中。在 Python 中，这些文件被称为非代码文件，可以包括图像*、数据、文档等。*****

我们将数据添加到我们库的模块目录中，这样任何需要这些数据的代码都可以使用来自消费模块的__file__变量的相对路径。****

让我们将虹膜数据集添加到我们的库中，以便为用户提供一种快速测试我们功能的方法。首先，使用 JupyterLab 中的新建文件夹按钮在模块目录下新建一个名为 data* 的文件夹:*****

*******datapeek**
├── **datapeek**
    └── __init__.py
    └── utilities.py
    └── **data**
├── setup.py
├── gitignore*****

…然后在名为 iris.csv 的数据文件夹中创建一个新的文本文件，并且*将中的数据粘贴到新文件中。*******

如果您关闭并打开新的 csv 文件，它将在 JupyterLab 中以适当的表格形式呈现:

CSV file rendered in JupyterLab as formatted table.

我们使用一个MANIFEST.in文件来指定非代码文件。创建另一个名为MANIFEST.in的文本文件，将其放入根文件夹:

*******datapeek**
├── **datapeek**
    └── __init__.py
    └── utilities.py
    └── **data**
├── MANIFEST.in
├── setup.py
├── gitignore*****

…然后将这一行添加到文件中:****

*****include datapeek/data/iris.csv*****

注:manifest . in 通常不需要，但为了完整起见包含在本教程中。更多讨论见此处。

我们还需要在 setup.py 中包含下面一行:****

*****include_package_data=True*****

我们的 setup.py 文件现在应该如下所示:

步骤 6:添加测试

与我们的 R 库一样，我们应该添加测试，以便其他人可以扩展我们的库，并确保他们自己的函数不会与现有代码冲突。添加一个测试文件夹到我们库的模块目录:

*******datapeek**
├── **datapeek**
    └── __init__.py
    └── utilities.py
    └── **data** └── **tests**├── MANIFEST.in
├── setup.py
├── gitignore*****

我们的测试文件夹应该有自己的__init__.py文件以及测试文件本身。创建那些现在使用 JupyterLab 的文本文件选项:

*******datapeek**
├── **datapeek**
    └── __init__.py
    └── utilities.py
    └── **data** └── **tests** └──__init__.py
        └──datapeek_tests.py
├── MANIFEST.in
├── setup.py
├── gitignore*****

我们的 datapeek 目录结构现在被设置为存放测试函数，我们现在将编写这些函数。

写作测试

用 Python 编写测试类似于用 r 编写测试。断言用于检查本库函数产生的预期输出。我们可以使用这些“单元测试来检查各种期望的输出，这取决于什么可能会失败。例如，我们可能希望确保返回一个数据帧，或者在某种已知的转换后返回正确的列数。

我将为我们的 4 个函数添加一个简单的测试。请随意添加您自己的测试。思考应该检查什么，并记住马丁·福勒在本文 R 部分引用的话。

我们将使用 Python 中流行的单元测试框架。****

将 单元测试添加到 datapeek_tests.py 文件中，确保单元测试和 datapeek 库被导入:

为了运行这些测试，我们可以使用 Nose ，它扩展了 unittest，使测试更加容易。使用 JupyterLab 中的终端会话安装 机头；****

***$ pip install nose***

我们还需要向 setup.py 添加以下几行:**

***setup(
    ...
    **test_suite='nose.collector',
    tests_require=['nose'],**
)***

我们的 setup.py 现在应该是这样的:

从根目录运行以下命令来运行我们的测试:

***python setup.py test***

如果需要，Setuptools 将负责安装 nose 并运行测试套件。运行上述程序后，您应该会看到以下内容:

我们所有的测试都通过了！

如果任何测试失败，unittest 框架将显示哪些函数没有通过。此时，检查以确保您正确地调用了函数，并且输出确实是您所期望的。故意先写测试失败的代码，然后写你的函数直到它们通过，这也是一个很好的实践。

步骤 7:创建文档

正如我在 R 部分提到的，我使用 Julep 来快速创建可共享和可搜索的文档。这避免了编写晦涩的注释，并提供了立即托管我们的文档的能力。当然，这并不像其他文档那样附带 IDE 挂钩，但是对于快速交流来说，它是有效的。

你可以在这里找到我为这个库创建的文档。

步骤 8:共享你的 Python 库

共享 python 库的标准方法是通过 PyPI。正如我们没有介绍 R 中的 CRAN 一样，我们也不会介绍在 PyPI 上托管我们的库。虽然要求比 CRAN 少，但要在 PyPI 上成功托管，仍然需要采取许多步骤。在 GitHub 之外的站点上托管所需的步骤可以在以后添加。

开源代码库

我们在 R 小节中介绍了向 GitHub 添加项目的步骤。同样的步骤也适用于此。

我在上面提到需要重命名我们的 gitignore 文件使其成为一个隐藏文件。您可以在终端中运行以下命令:**

***mv gitignore .gitignore***

您会注意到这个文件在我们的 JupyterLab 目录中不再可见(它最终会消失)。由于 JupyterLab 仍然缺乏切换隐藏文件的前端设置，因此只需随时在终端中运行以下命令即可查看隐藏文件:

***ls -a*** 

如果我们需要在 JupyterLab 中查看/编辑该文件，我们可以通过运行以下命令使其再次可见:

***mv .gitignore gitignore***

这里有一个关于将我们的库推送到 GitHub 的快速回顾(将 git URL 改为你自己的):

• 在 GitHub 上创建一个名为 datapeek_py 的新 repo
• 使用git init初始化你的库的目录
• 使用您的 GitGub 电子邮件和用户名(如果使用 Docker)配置您的本地回购:

***git config --global user.email {emailaddress}
git config --global user.name {name}***

• 使用 git remote add origin [https://github.com/sean-mcclure/datapeek_py.git](https://github.com/sean-mcclure/datapeek_py.git)添加您的新远程原点
• 阶段你的图书馆使用git add .
• 使用git commit -m ‘initial commit’提交所有文件
• 使用git push origin master将您的库推送到远程 repo(出现提示时进行身份验证)

现在，任何人都可以使用我们的 python 库。👍让我们看看怎么做。

步骤 9:安装 Python 库

虽然我们通常使用以下命令安装 Python 库:

***pip install <package_name>***

…这需要在 PyPI 上托管我们的库，正如上面解释的，这超出了本文的范围。相反，我们将学习如何从 GitHub 安装我们的 Python 库，就像我们对 r 所做的那样。这种方法仍然需要pip install命令，但是使用 GitHub URL 而不是包名。

从 GitHub 安装我们的 Python 库

我们的库托管在 GitHub 上，我们只需使用pip install git+，后跟 GitHub repo 上提供的 URL(可通过点击 GitHub 网站上的克隆或下载按钮获得):**

***pip install git+https://github.com/sean-mcclure/datapeek_py***

现在，我们可以将我们的库导入到 Python 环境中。对于单一功能:**

***from datapeek.utilities import encode_and_bind***

…对于所有功能*😗**

***from datapeek.utilities import ****

让我们在新的 Python 环境中做一个快速检查，以确保我们的函数可用。创建一个新的 Docker 容器，我运行以下代码:

获取数据集:

***iris = pd.read_csv('[https://raw.githubusercontent.com/uiuc-cse/data-fa14/gh-pages/data/iris.csv'](https://raw.githubusercontent.com/uiuc-cse/data-fa14/gh-pages/data/iris.csv'))***

检查功能:

*****encode_and_bind**(iris, 'species')***

*****remove_features**(iris, ['petal_length', 'petal_width'])***

*****apply_function_to_column**(iris, ['sepal_length'], 'times_4', 'x*4')***

*****get_closest_string**(['hey there','we we are','howdy doody'], 'doody')***

成功！

摘要

在本文中，我们研究了如何使用运行在 Docker 容器中的 JupyterLab 来创建 R 和 Python 库。Docker 允许我们利用 Docker 栈，这样我们的环境很容易控制，并且可以使用公共包。这也使得使用相同的高级接口通过浏览器为 2 种不同的语言创建库变得容易。因为我们在 Docker 中装入了一个卷，所以所有的文件都被写到我们的本地机器上。

创建库对于任何机器学习从业者来说都是一项关键技能，我也鼓励其他人经常这么做。库有助于将我们的工作隔离在有用的抽象中，提高可再现性，使我们的工作可共享，并且是设计更好软件的第一步。使用轻量级的方法确保我们可以快速地构建原型和共享，并根据需要选择添加更详细的实践和发布标准。

一如既往，如果你遇到问题，请在评论区提出问题*。快乐编码。***

如果你喜欢这篇文章，你可能也会喜欢:

*** [## 学习建立机器学习服务，原型真实的应用程序，并部署您的工作…

在这篇文章中，我将向读者展示如何将他们的机器学习模型公开为 RESTful web 服务，原型真实…

towardsdatascience.com](/learn-to-build-machine-learning-services-prototype-real-applications-and-deploy-your-work-to-aa97b2b09e0c) [## 用 D3.js 从玩具视觉过渡到真实应用

我们经常孤立地学习技术和方法，与数据科学的真正目标脱节；至…

towardsdatascience.com](/combining-d3-with-kedion-graduating-from-toy-visuals-to-real-applications-92bf7c3cc713) [## 机器学习工作流的 GUI 化:快速发现可行的流水线

前言

towardsdatascience.com](/gui-fying-the-machine-learning-workflow-towards-rapid-discovery-of-viable-pipelines-cab2552c909f)

进一步阅读和资源

• 哈雷·威克姆的 R 包
• 哈德利·韦翰的测试
• Scott Torborg 的 Python 打包
• Jupyter 数据科学笔记本
• Docker —定位和设置
• JupyterLab 文档
• 按发布日期列出的可用起重机包
• 记录 R 中的功能
• 七月
• gitignore.io
• Python 包索引
• 设置工具文档
• GitHub 上的虹膜数据集
• 单元测试—维基百科文章
• unitest——一个单元测试框架
• Nose——Python 更好的测试
• 测试驱动开发—维基百科上的文章
• 对接器运行参考***