提交 d303785b 编写于 作者: W wizardforcel

2021-03-12 22:08:42

上级 91facca8
......@@ -415,7 +415,7 @@ scikit_learn==0.19.0
该文档字符串显示了`DataFrame`输入参数。 我们要为数据输入`boston['data']`,并为标头使用`boston['feature_names']`。
7. 运行接下来的几个单元格以打印数据,其形状和要素名称:
7. 运行接下来的几个单元格以打印数据,其形状和特征名称:
![Load the Boston housing dataset](img/image1_051.jpg)
......@@ -817,7 +817,7 @@ scikit_learn==0.19.0
![Activity B: Building a Third-Order Polynomial Model](img/image1_135.jpg)
与线性模型`LSTAT`残差图相比,多项式模型残差似乎更紧密地聚集在`y = 0`周围。 注意,`y`是样本`MEDV`,`ŷ`是预测值。 仍然存在清晰的模式,例如`x = 7`和`y = -7`附近的,这表明模型不是最佳的。
与线性模型`LSTAT`残差图相比,多项式模型残差似乎更紧密地聚集在`y = 0`周围。 注意,`y`是样本`MEDV`,`ŷ`是预测值。 仍然存在清晰的模式,例如`x = 7`和`y = -7`附近的群集,这表明模型不是最佳的。
使用多项式模型成功建模数据后,让我们通过查看分类特征来结束本节。 特别是,我们将构建一组分类特征,并使用它们来更详细地探索数据集。
......@@ -825,11 +825,11 @@ scikit_learn==0.19.0
通常,我们发现数据集包含连续字段和分类字段。 在这种情况下,我们可以通过使用分类字段对连续变量进行分段来了解我们的数据并找到模式。
举一个具体的例子,假设您正在评估广告系列的投资回报率。 您可以访问的数据包含一些计算出的**投资回报率****ROI**)度量的度量。 每天计算这些值并记录,您正在分析上一年的数据。 您的任务是寻找以数据为依据的见解,以改善广告系列。 查看 ROI 的每日时间序列,您会看到每周的数据波动。 按星期几细分,您会发现以下 ROI 分布(其中 0 代表一周的第一天,而 6 代表最后一天)。
举一个具体的例子,假设您正在评估广告序列的投资回报率。 您可以访问的数据包含一些计算出的**投资回报率****ROI**)度量的度量。 每天计算这些值并记录,您正在分析上一年的数据。 您的任务是寻找以数据为依据的见解,以改善广告序列。 查看 ROI 的每日时间序列,您会看到每周的数据波动。 按星期几细分,您会发现以下 ROI 分布(其中 0 代表一周的第一天,而 6 代表最后一天)。
![Subtopic D: Using Categorical Features for Segmentation Analysis](img/image1_137.jpg)
此清楚地表明,该广告列在一周开始时获得了最大的投资回报率,随后逐渐减少。 因此,建议可能是减少下周的广告支出。 为了继续寻找见解,您还可以想象对按月分组的 ROI 重复相同的过程。
此清楚地表明,该广告列在一周开始时获得了最大的投资回报率,随后逐渐减少。 因此,建议可能是减少下周的广告支出。 为了继续寻找见解,您还可以想象对按月分组的 ROI 重复相同的过程。
由于在我们正在使用的波士顿房屋数据集中没有任何分类字段,因此我们将通过有效离散连续字段来创建一个分类字段。 在我们的案例中,这将涉及将数据分为“低”,“中”和“高”类别。 重要的是要注意,我们并不是简单地创建分类数据字段来说明本节中的数据分析概念。 可以看到,这样做可以从数据中揭示洞察力,否则这些洞察力将很难被发现或完全不可用。
......@@ -856,13 +856,13 @@ scikit_learn==0.19.0
![Create categorical fieldscreatingcategorical fields from continuous variables and make segmented visualizations](img/image1_141.jpg)
注意,我们设置`kde_kws={'lw': 0}`是为了绕过上图中绘制核密度估计值的过程。
注意,我们设置`kde_kws={'lw': 0}`是为了绕过上图中绘制核密度估计值的过程。
从图中的看,只有很少的样品具有较低的`AGE`,而有更多的样品具有较高的`AGE`。 这通过最右边的分布的陡度来表示。
从图中的看,只有很少的样本具有较低的`AGE`,而有更多的样本具有较高的`AGE`。 这通过最右边的分布的陡度来表示。
红线表示分布中的 1/3 和 2/3 点。 观察分布分布与这些水平线相交的地方,我们可以看到,只有约 33% 的样本的`AGE`小于 55,而 33% 的样本的`AGE`大于 90! 换句话说,三分之一的住房社区在 1940 年之前建造房屋的比例不到 55%。这些社区被认为是相对较新的社区。 另一方面,另外三分之一的住房社区在 1940 年之前建造了超过 90% 的房屋。这些房屋被认为是非常古老的。
我们将使用红色水平线截取分布的位置作为将要素划分为类别的指导:**相对较新**,**相对较旧**和**较旧**。
我们将使用红色水平线截取分布的位置作为将特征划分为类别的指导:**相对较新**,**相对较旧**和**较旧**。
3. 将分段点设置为 50 和 85,通过运行以下代码来创建新的分类功能:
......
此差异已折叠。
......@@ -311,7 +311,7 @@ x[3:]
因此,请记住,永远不要忘记,在大多数语言中,您是从 0 开始而不是从 1 开始计数。
现在,这可能会使事情变得混乱,但是在这种情况下,确实是直观的。 您可以认为冒号意味着我想要一切,我想要前三个要素,并且我可以再次将其更改为四个,以表明我们实际上在这里做点真正的事情:
现在,这可能会使事情变得混乱,但是在这种情况下,确实是直观的。 您可以认为冒号意味着我想要一切,我想要前三个特征,并且我可以再次将其更改为四个,以表明我们实际上在这里做点真正的事情:
```py
x[:4]
......
......@@ -691,7 +691,7 @@ plt.plot(x, poisson.pmf(x, mu))
# 百分位数和矩
接下来,我们将讨论百分位数和时刻。 您一直在新闻中听到有关百分位数的消息。 收入最高的 1% 的人:这是百分位数的一个例子。 我们将对此进行解释,并提供一些示例。 然后,我们将讨论时刻,这是一个非常花哨的数学概念,但事实证明,从概念上理解它非常简单。 让我们深入探讨百分位和矩,这是统计学中的几个非常基本的概念,但是同样,我们正在努力研究艰巨的事物,因此在本次回顾中,请耐心等待。
接下来,我们将讨论百分位数和矩。 您一直在新闻中听到有关百分位数的消息。 收入最高的 1% 的人:这是百分位数的一个例子。 我们将对此进行解释,并提供一些示例。 然后,我们将讨论矩,这是一个非常花哨的数学概念,但事实证明,从概念上理解它非常简单。 让我们深入探讨百分位和矩,这是统计学中的几个非常基本的概念,但是同样,我们正在努力研究艰巨的事物,因此在本次回顾中,请耐心等待。
# 百分位数
......@@ -815,16 +815,16 @@ Out[5]:-0.41810340026619164
准备好? 开始了!
1. 第一时刻只是您要查看的数据的平均值。 而已。 第一刻是平均值。 就这么简单。
2. 第二时刻是变化。 而已。 数据集的第二个时刻与方差值相同。 这些东西自然地不属于数学范畴,似乎有些令人毛骨悚然,但请考虑一下。 方差实际上是基于均值差异的平方,因此想出一种数学方法来表示方差与均值相关并不是很大。 就这么简单。
1. 第一只是您要查看的数据的平均值。 而已。 第一刻是平均值。 就这么简单。
2. 第二矩是变化。 而已。 数据集的第二个矩与方差值相同。 这些东西自然地不属于数学范畴,似乎有些令人毛骨悚然,但请考虑一下。 方差实际上是基于均值差异的平方,因此想出一种数学方法来表示方差与均值相关并不是很大。 就这么简单。
3. 现在,当我们进入第三和第四时刻时,事情会变得有些棘手,但它们仍然是易于理解的概念。 第三时刻称为偏斜,基本上可以衡量分布的偏斜程度。
3. 现在,当我们进入第三和第四矩时,事情会变得有些棘手,但它们仍然是易于理解的概念。 第三矩称为偏斜,基本上可以衡量分布的偏斜程度。
![](img/94f6ca96-30ca-4930-b926-a7a488f8e6b3.png)
* 您可以在上面的两个示例中看到,如果我在左侧有一个较长的尾巴,那么那现在是负偏斜,而如果我在右边有一个较长的尾巴,那就是正偏斜。 虚线表示没有偏斜的正态分布形状。 虚线在左侧出现,然后在该示例中以负偏斜结束,或者在另一侧以正偏斜结束。 好的,这就是所有的偏差。 它基本上是在一侧或另一侧伸出尾巴,并且可以衡量分布的偏斜程度或偏斜程度。
4. 第四时刻称为峰度。 哇,真是个好话! 真正的意思是,尾巴有多厚,峰有多尖。 同样,它是对数据分布形状的一种度量。 这是一个例子:
4. 第四称为峰度。 哇,真是个好话! 真正的意思是,尾巴有多厚,峰有多尖。 同样,它是对数据分布形状的一种度量。 这是一个例子:
![](img/912d4b01-0a9f-4c55-9f5e-ae25596d2a18.png)
......@@ -834,7 +834,7 @@ Out[5]:-0.41810340026619164
# 用 Python 计算矩
让我们在 Python 中玩转并实际计算这些时刻,然后看看如何做到这一点。 要解决这个问题,请继续打开`Moments.ipynb`,您可以在这里与我一起关注。
让我们在 Python 中玩转并实际计算这些,然后看看如何做到这一点。 要解决这个问题,请继续打开`Moments.ipynb`,您可以在这里与我一起关注。
让我们再次创建随机数据的相同正态分布。 同样,我们将使其以零为中心,具有 0.5 个标准差和 10,000 个数据点,并将其绘制出来:
......@@ -869,7 +869,7 @@ Out [2]:-0.0012769999428169742
输出结果非常接近零,就像我们期望以零为中心的正态分布数据一样。 因此,到目前为止,世界是有意义的。
现在我们找到第二个时刻,这只是方差的另一个名字。 我们可以使用下面的代码来做到这一点,就像我们之前看到的那样:
现在我们找到第二个,这只是方差的另一个名字。 我们可以使用下面的代码来做到这一点,就像我们之前看到的那样:
```py
np.var(vals)
......@@ -885,7 +885,7 @@ Out[3]:0.25221246428323563
该输出结果约为 0.25,并且再次进行了良好的健全性检查。 请记住,标准差是方差的平方根。 如果您取 0.25 的平方根,则得出 0.5,这是我们在创建此数据时指定的标准差,因此再次进行检验。
第三时刻是歪斜的,为此,我们将需要使用 SciPy 包而不是 NumPy。 但是,这再次内置于任何科学计算包中,例如 Enthought Canopy 或 Anaconda。 一旦有了 SciPy,函数调用就和前面的两个一样简单:
第三是歪斜的,为此,我们将需要使用 SciPy 包而不是 NumPy。 但是,这再次内置于任何科学计算包中,例如 Enthought Canopy 或 Anaconda。 一旦有了 SciPy,函数调用就和前面的两个一样简单:
```py
import scipy.stats as sp
......@@ -902,7 +902,7 @@ Out[4]: 0.020055795996111746
我们只需要在`vals`列表中调用`sp.skew`,就可以得到偏斜值。 由于此中心位于零附近,因此应该几乎为零偏斜。 事实证明,在随机变化的情况下,它确实会稍微偏斜,并且实际上与我们在图中看到的形状吻合。 看来我们确实有点消极了。
第四个时刻是峰度,它描述了尾巴的形状。 同样,对于应该为`zero.SciPy`的正态分布,我们可以进行另一个简单的函数调用
第四个是峰度,它描述了尾巴的形状。 同样,对于应该为`zero.SciPy`的正态分布,我们可以进行另一个简单的函数调用
```py
sp.kurtosis(vals)
......@@ -918,9 +918,9 @@ Out [5]:0.059954502386585506
确实,它确实为零。 峰度以两种链接的方式显示了我们的数据分布:尾巴的形状或峰的尖锐程度如果我只是将尾巴压扁,它会推高该峰以使其更尖,或者同样地,如果将其分布降低,您可以想象这有点分散了东西,使尾巴更胖,峰值更矮了。 这就是峰度的含义,在此示例中,峰度几乎为零,因为它只是一个普通的正态分布。
如果您想使用它,请继续,然后再次尝试修改发行版。 使它以除 0 以外的内容为中心,并查看该值是否实际发生任何变化。 应该是? 嗯,这确实不应该,因为这些都是分布形状的度量,也并没有真正说明分布的确切位置。 这是形状的度量。 那就是时刻的全部。 继续尝试一下,尝试不同的中心值,尝试不同的标准差值,看看它对这些值有什么影响,并且它根本不会改变。 当然,您期望诸如均值之类的东西会发生变化,因为您正在更改均值,但方差,偏斜也许不会。 玩耍,找出答案。
如果您想使用它,请继续,然后再次尝试修改发行版。 使它以除 0 以外的内容为中心,并查看该值是否实际发生任何变化。 应该是? 嗯,这确实不应该,因为这些都是分布形状的度量,也并没有真正说明分布的确切位置。 这是形状的度量。 那就是的全部。 继续尝试一下,尝试不同的中心值,尝试不同的标准差值,看看它对这些值有什么影响,并且它根本不会改变。 当然,您期望诸如均值之类的东西会发生变化,因为您正在更改均值,但方差,偏斜也许不会。 玩耍,找出答案。
那里有百分位数和时刻。 百分位数是一个非常简单的概念。 片刻听起来很难,但实际上很容易理解如何做,在 Python 中也很容易。 现在,您已经可以使用它了。 现在该继续前进了。
那里有百分位数和。 百分位数是一个非常简单的概念。 片刻听起来很难,但实际上很容易理解如何做,在 Python 中也很容易。 现在,您已经可以使用它了。 现在该继续前进了。
# 总结
......
......@@ -805,13 +805,13 @@ P(Purchase): 0.4003
关键的见解是,依赖于`B`的事物的概率在很大程度上取决于`B``A`的基本概率。人们一直都忽略这一点。
一个常见的例子是药物测试。 我们可能会说,假设您的药物测试呈阳性,那么成为药物的实际使用者的可能性是多少。 贝叶斯定理之所以重要,是因为它指出,这在很大程度上取决于`A`的概率和`B`的概率。假设您测试为阳性,成为吸毒者的概率在很大程度上取决于`B`的基本总体概率。 成为毒品使用者和测试呈阳性的总体可能性。 药物测试准确的可能性在很大程度上取决于成为人群中吸毒者的总体可能性,而不仅仅是测试的准确
一个常见的例子是药物测试。 我们可能会说,假设您的药物测试呈阳性,那么成为药物的实际使用者的可能性是多少。 贝叶斯定理之所以重要,是因为它指出,这在很大程度上取决于`A`的概率和`B`的概率。假设您测试为阳性,成为吸毒者的概率在很大程度上取决于`B`的基本总体概率。 成为毒品使用者和测试呈阳性的总体可能性。 药物测试准确的可能性在很大程度上取决于成为人群中吸毒者的总体可能性,而不仅仅是测试的准确
这也意味着,给定`A``B`的概率与给定`B``A`的概率不是同一回事。也就是说,假设您被测为阳性,成为吸毒者的概率与假设为正的概率非常不同。 你是吸毒者。 您可以看到前进的方向。 这是一个非常现实的问题,其中医学诊断测试或药物测试会产生许多误报。 您仍然可以说,测试检测到用户的可能性很高,但这并不一定意味着在您测试为肯定的情况下成为用户的可能性就很高。 这是两个不同的事物,贝叶斯定理可让您量化该差异。
让我们再把这个例子钉在家里。
同样,药物测试可能是应用贝叶斯定理证明观点的常见示例。 即使是高度准确的药物测试,也会产生比真实阳性更多的假阳性。 因此,在这里的示例中,我们将提出一种药物测试,该测试可以在 99% 的时间内准确地识别出某种药物的使用者,并且对于 99% 的非使用者来说准确地得出阴性结果,但只有 0.3% 整个人口实际上正在使用有问题的药物。 因此,我们实际成为毒品使用者的可能性很小。 看来 99% 的非常高的准确实际上还不够高,对吧?
同样,药物测试可能是应用贝叶斯定理证明观点的常见示例。 即使是高度准确的药物测试,也会产生比真实阳性更多的假阳性。 因此,在这里的示例中,我们将提出一种药物测试,该测试可以在 99% 的时间内准确地识别出某种药物的使用者,并且对于 99% 的非使用者来说准确地得出阴性结果,但只有 0.3% 整个人口实际上正在使用有问题的药物。 因此,我们实际成为毒品使用者的可能性很小。 看来 99% 的非常高的准确实际上还不够高,对吧?
我们可以算出以下公式:
......@@ -826,7 +826,7 @@ P(Purchase): 0.4003
![](img/dc189173-51c2-4167-9314-8c8d5e278215.png)
因此,假设您实际上是一名吸毒者,则检测结果呈阳性的概率就是成为吸毒者整体(`P(A)`)的概率,即 3%(您知道 (3% 的人口是吸毒者)乘以`P(B | A)`,即假设您是用户,则该测试为阳性的概率除以总体测试为阳性的概率 1.3 %。 再次,此测试听起来像是 99% 的非常高的准确性。 我们有 0.3% 的人口使用某种药物,乘以 99% 的准确度,再除以总体检测呈阳性的概率,即 1.3%。 因此,如果您对它进行了阳性测试,那么成为该药物的实际使用者的概率只有 22.8%。 因此,即使此药物测试在 99% 的时间内都是准确的,但在您测试呈阳性的大多数情况下,它仍提供错误的结果。
因此,假设您实际上是一名吸毒者,则检测结果呈阳性的概率就是成为吸毒者整体(`P(A)`)的概率,即 3%(您知道 (3% 的人口是吸毒者)乘以`P(B | A)`,即假设您是用户,则该测试为阳性的概率除以总体测试为阳性的概率 1.3 %。 再次,此测试听起来像是 99% 的非常高的准确率。 我们有 0.3% 的人口使用某种药物,乘以 99% 的准确率,再除以总体检测呈阳性的概率,即 1.3%。 因此,如果您对它进行了阳性测试,那么成为该药物的实际使用者的概率只有 22.8%。 因此,即使此药物测试在 99% 的时间内都是准确的,但在您测试呈阳性的大多数情况下,它仍提供错误的结果。
即使`P(B | A)`高(99%),也并不意味着`P(A | B)`高。
......
此差异已折叠。
......@@ -414,7 +414,7 @@ myRatings
这种代表像我这样的人,他们喜欢《星球大战》和《帝国反击战》,但讨厌电影《乱世佳人》。 那么,这代表一个真正热爱星球大战但不喜欢旧风格,浪漫戏剧的人,好吗? 因此,我将`5`星的评分定为`The Empire Strikes Back (1980)``Star Wars (1977)`,将`1`星的评分定为`Gone with the Wind (1939)`。 因此,我将尝试为该虚拟用户找到建议。
那么,我该怎么做呢? 好吧,让我们开始创建一个名为`simCandidates`列,然后我将介绍我所评价的每部电影。
那么,我该怎么做呢? 好吧,让我们开始创建一个名为`simCandidates`列,然后我将介绍我所评价的每部电影。
```py
simCandidates = pd.Series()
......@@ -469,7 +469,7 @@ simCandidates.head(10)
# 使用`drop`命令删除条目
因此,我可以使用以下代码迅速删除原始评分列中的所有行:
因此,我可以使用以下代码迅速删除原始评分列中的所有行:
```py
filteredSims = simCandidates.drop(myRatings.index)
......@@ -499,13 +499,13 @@ filteredSims.head(10)
我们还可以改善以下事实:即使我不喜欢《乱世佳人》,我们在结果中也看到了很多与《乱世佳人》相似的电影。 您知道我们对这些结果的加权程度低于与我喜欢的电影的相似度,但是也许这些电影实际上应该受到惩罚。 如果我非常讨厌《乱世佳人》,那么也许应该惩罚《绿野仙踪》等与《乱世佳人》的相似之处,而且,你知道他们的得分降低了而不是提高了。
这是您可以进行的另一个简单修改。 我们的用户评分数据集中可能存在一些离群值,如果我要抛弃对一些荒谬电影评分的人怎么办? 也许他们歪曲了一切。 实际上,您可以尝试识别这些用户并将其丢弃,这是另一个想法。 而且,如果您真的想要一个大型项目,如果您真的想尽全力投入其中,则可以使用培训/测试技术来实际评估此推荐引擎的结果。 因此,如果不是用一个任意的推荐分数来求和各个电影的相关性分数,而是实际将其缩小到每个给定电影的预测等级,该怎么办?
这是您可以进行的另一个简单修改。 我们的用户评分数据集中可能存在一些离群值,如果我要抛弃对一些荒谬电影评分的人怎么办? 也许他们歪曲了一切。 实际上,您可以尝试识别这些用户并将其丢弃,这是另一个想法。 而且,如果您真的想要一个大型项目,如果您真的想尽全力投入其中,则可以使用训练/测试技术来实际评估此推荐引擎的结果。 因此,如果不是用一个任意的推荐分数来求和各个电影的相关性分数,而是实际将其缩小到每个给定电影的预测等级,该怎么办?
如果我的推荐系统的输出是一部电影,并且是该电影的预测收视率,那么在火车/测试系统中,我实际上可以尝试找出我对用户实际上已经看过并收视过的电影的预测程度如何? 好的? 因此,我可以搁置一些收视率数据,看看我的推荐器系统能够如何预测用户对这些电影的收视率。 并且,这将是一种量化和原则性的方法来衡量此推荐引擎的错误。 但是,与此同时,还有一门艺术而不是一门科学。 即使 Netflix 奖品实际上使用了这种误差度量,即所谓的均方根误差,也是他们特别使用的误差度量,这是否真的可以衡量一个好的推荐系统?
如果我的推荐系统的输出是一部电影,并且是该电影的预测收视率,那么在训练/测试系统中,我实际上可以尝试找出我对用户实际上已经看过并收视过的电影的预测程度如何? 好的? 因此,我可以搁置一些收视率数据,看看我的推荐器系统能够如何预测用户对这些电影的收视率。 并且,这将是一种量化和原则性的方法来衡量此推荐引擎的错误。 但是,与此同时,还有一门艺术而不是一门科学。 即使 Netflix 奖品实际上使用了这种误差度量,即所谓的均方根误差,也是他们特别使用的误差度量,这是否真的可以衡量一个好的推荐系统?
基本上,您正在衡量推荐系统预测一个人已经看过的电影的收视率的能力。 但是,推荐器引擎的目的不是推荐一个人没有看过的,可能会喜欢的电影吗? 那是两件事。 因此,不幸的是,要真正测量要测量的东西并不容易。 因此有时候,您确实需要遵循直觉。 而且,衡量推荐器引擎结果的正确方法是衡量您试图通过该引擎推广的结果。
也许我是想让人们看更多的电影,或者对新电影给予更高的评价,或者购买更多的东西。 与使用培训/测试相反,在真实的网站上运行实际的受控实验将是为此进行优化的正确方法。 因此,您知道的是,我在那儿进了一些细节,比我可能应该做的要多,但是教训是,您不能总是以黑白方式考虑这些问题。 有时,您不能真正地直接,定量地测量事物,而您必须使用一些常识,这就是一个例子。
也许我是想让人们看更多的电影,或者对新电影给予更高的评价,或者购买更多的东西。 与使用训练/测试相反,在真实的网站上运行实际的受控实验将是为此进行优化的正确方法。 因此,您知道的是,我在那儿进了一些细节,比我可能应该做的要多,但是教训是,您不能总是以黑白方式考虑这些问题。 有时,您不能真正地直接,定量地测量事物,而您必须使用一些常识,这就是一个例子。
无论如何,这些都是关于如何回溯并改进我们编写的此推荐器引擎的结果的一些想法。 因此,请随时调整它,看看是否可以根据自己的意愿进行改进,并从中获得乐趣。 这实际上是本书中非常有趣的一部分,所以希望您喜欢!
......
......@@ -431,7 +431,7 @@ ETL 是一种古老的做法,您需要先脱机转换一堆数据,然后再
在探索整个空间的过程中,我可以建立一套吃豆人可能处于的所有可能状态,以及在每个状态中沿给定方向移动所关联的值,这就是强化学习。 在探索整个空间时,它会针对给定状态优化这些奖励值,然后可以使用这些存储的奖励值来选择最佳决策,以在给定当前条件的情况下做出决定。 除《吃豆人》外,还有一个名为《猫与老鼠》的游戏,该游戏是一个常用的示例,稍后我们将进行介绍。
这种技术的好处是,一旦您探究了智能体可能处于的所有可能状态集,那么当您运行此智能体的不同迭代时,您很快就会获得非常好的性能。 因此,您知道,您可以基本地做出智能的吃豆人,通过运行强化学习,并让其探索可以在不同状态下做出的不同决策的值,然后存储该信息,从而给定它在未知条件下看到的未来状态时,快速做出正确的决策。
这种技术的好处是,一旦您探究了智能体可能处于的所有可能状态集,那么当您运行此智能体的不同迭代时,您很快就会获得非常好的表现。 因此,您知道,您可以基本地做出智能的吃豆人,通过运行强化学习,并让其探索可以在不同状态下做出的不同决策的值,然后存储该信息,从而给定它在未知条件下看到的未来状态时,快速做出正确的决策。
# Q 学习
......@@ -441,7 +441,7 @@ ETL 是一种古老的做法,您需要先脱机转换一堆数据,然后再
* 在这些状态下,我可以执行一组可能的操作,我们将其称为`a`。 对于吃豆人,这些可能的动作是向上,向下,向左或向右移动。
* 然后我们为每个状态/动作对都有一个值,我们将其称为`Q`; 这就是为什么我们将其称为 Q 学习。 因此,对于每个状态,围绕吃豆人的一组给定条件,给定动作将具有值`Q`。 因此,例如,向上移动可能具有给定的值`Q`,而向下移动可能具有负的`Q`值,例如,这意味着遇到重影。
因此,对于吃豆人可能处于的每种可能状态,我们从`Q`值开始为 0。而且,当吃豆人探索迷宫时,随着吃豆人的坏事发生,我们减少了 “吃豆人”当时所处状态的`Q`值。 因此,如果吃豆人最终被鬼魂吞噬,我们将惩罚他在当前状态下所做的一切。 吃豆人吃东西或吃鬼东西时,吃豆人都会遇到好事,我们会为该动作增加`Q`值,以了解他所处的状态。然后, 可以做的就是使用这些`Q`值来告知 PacMan 未来的选择,并建立一种性能最佳的智能智能体,从而制作出完美的 PacMan。 从上面看到的相同的 PacMan 图像,我们可以进一步定义 PacMan 的当前状态,方法是定义他在西边有一堵墙,在北边和东边有空白空间,在南边有个幽灵。
因此,对于吃豆人可能处于的每种可能状态,我们从`Q`值开始为 0。而且,当吃豆人探索迷宫时,随着吃豆人的坏事发生,我们减少了 “吃豆人”当时所处状态的`Q`值。 因此,如果吃豆人最终被鬼魂吞噬,我们将惩罚他在当前状态下所做的一切。 吃豆人吃东西或吃鬼东西时,吃豆人都会遇到好事,我们会为该动作增加`Q`值,以了解他所处的状态。然后, 可以做的就是使用这些`Q`值来告知 PacMan 未来的选择,并建立一种表现最佳的智能智能体,从而制作出完美的 PacMan。 从上面看到的相同的 PacMan 图像,我们可以进一步定义 PacMan 的当前状态,方法是定义他在西边有一堵墙,在北边和东边有空白空间,在南边有个幽灵。
我们可以看看他可以采取的行动:他实际上根本不能向左移动,但是他可以向上,向下或向右移动,我们可以为所有这些动作分配一个值。 向上或向右走,实际上什么也没有发生,没有药丸或点药可消耗。 但是,如果他走了,那绝对是一个负值。 可以说,对于吃豆人所处的当前状况所给出的状态,下移将是一个非常糟糕的选择。 为此,应该有一个负的`Q`值。 根本无法向左移动。 向上或向右移动或保持中性,对于给定状态的那些动作选择,`Q`值将保持为 0。
......@@ -498,7 +498,7 @@ Q(s,a) += discount * (reward(s,a) + max(Q(s')) - Q(s,a))
下一次出现相同的子问题时,无需重新计算其解决方案,只需查找先前计算出的解决方案,从而节省了计算时间,但以(希望的)适度的存储空间开销为代价:
* **解决复杂问题的方法**:与创建智能吃豆人相同,最终结果非常复杂。
* **通过将其分解为更简单的子问题的集合**:例如,对于 PacMan 可能处于的给定状态,采取的最佳措施是什么。PacMan 可以陷入许多不同的状态,但这些州中的每个州都代表着一个更简单的子问题,我只能做出有限的选择,并且有一个正确的答案可以做出最好的举动。
* **通过将其分解为更简单的子问题的集合**:例如,对于 PacMan 可能处于的给定状态,采取的最佳措施是什么。PacMan 可以陷入许多不同的状态,但这些状态中的每个状态都代表着一个更简单的子问题,我只能做出有限的选择,并且有一个正确的答案可以做出最好的举动。
* **存储其解**:这些解是与每个状态下每个可能动作相关的`Q`值。
* **理想情况下,使用基于内存的数据结构**:嗯,当然,我需要存储这些`Q`值并将它们与状态关联,对吗?
* **下次再次出现相同的子问题**:下次吃豆人处于给定状态时,我具有一组`Q`值。
......
......@@ -42,19 +42,19 @@
![](img/459a0f30-4b0c-4dfd-a4fb-91b39c005369.png)
以此来看,误差等于偏差平方加方差。 因此,这些因素都会造成整体误差,而偏差实际上会造成更大的误差。 但请记住,这是您真正要最小化的错误,而不是具体的偏差或方差,并且过于复杂的模型最终可能具有高方差和低偏差,而过于简单的模型将具有低方差和高偏差。 偏见。 但是,它们最终都可能在一天结束时具有相似的错误条件。 尝试拟合数据时,您只需要找到这两件事的正确的快乐媒介即可。 在接下来的部分中,我们将讨论一些实际上避免过拟合的更原则的方法。 但是,这只是我想克服的偏见和差异的概念,因为人们确实在谈论它,并且您将被期望知道这意味着什么。
以此来看,误差等于偏差平方加方差。 因此,这些因素都会造成整体误差,而偏差实际上会造成更大的误差。 但请记住,这是您真正要最小化的误差,而不是具体的偏差或方差,并且过于复杂的模型最终可能具有高方差和低偏差,而过于简单的模型将具有低方差和高偏差。 偏见。 但是,它们最终都可能在一天结束时具有相似的错误条件。 尝试拟合数据时,您只需要找到这两件事的正确的快乐媒介即可。 在接下来的部分中,我们将讨论一些实际上避免过拟合的更原则的方法。 但是,这只是我想克服的偏见和差异的概念,因为人们确实在谈论它,并且您将被期望知道这意味着什么。
现在,让我们将其与本书中较早的概念联系起来。 例如,在`k`个最近的邻居中,如果我们增加 K 的值,我们就会开始平均扩展到更大区域的邻居。 这具有减少方差的效果,因为我们可以在更大的空间上使事物平滑,但是它可能会增加我们的偏见,因为我们将要挑选到的人群可能与我们开始时的相关性越来越小 。 通过在大量邻居上平滑 KNN,我们可以减小方差,因为我们正在通过更多值平滑事物。 但是,我们可能会引入偏见,因为我们引入了越来越多的点,而这些点与开始时的点之间的关联性却不那么高。
决策树是另一个例子。 我们知道,单个决策树很容易过拟合,因此可能暗示它具有很大的方差。 但是,随机森林寻求权衡一些方差以减少偏差,并且它通过拥有多个随机变异的树并将其所有解决方案求平均来做到这一点。 就像当我们通过增加 KNN 中的 K 来对事物进行平均时:我们可以通过使用多个使用相似森林的随机森林决策树来平均决策树的结果。
这是偏差方差的权衡。 您知道必须在值的整体准确,值的分散程度或紧密程度之间做出决定。 那就是偏差-方差的权衡,它们都会导致整体误差,这是您真正关心的要最小化的事情。 因此,请记住这些条款!
这是偏差方差的权衡。 您知道必须在值的整体准确,值的分散程度或紧密程度之间做出决定。 那就是偏差-方差的权衡,它们都会导致整体误差,这是您真正关心的要最小化的事情。 因此,请记住这些条款!
# 用于避免过拟合的 K 折交叉验证
在本书的前面,我们讨论了训练和测试,将其作为防止过拟合并实际测量模型在从未见过的数据上的性能的好方法。 我们可以使用称为 K 折交叉验证的技术将其提升到一个新的水平。 因此,让我们谈谈您的武器库中用于对抗过拟合的强大工具; K 折交叉验证并了解其工作原理。
在本书的前面,我们讨论了训练和测试,将其作为防止过拟合并实际测量模型在从未见过的数据上的表现的好方法。 我们可以使用称为 K 折交叉验证的技术将其提升到一个新的水平。 因此,让我们谈谈您的武器库中用于对抗过拟合的强大工具; K 折交叉验证并了解其工作原理。
回想一下火车/测试,当时的想法是,我们将要构建机器学习模型的所有数据分为两个部分:训练数据集和测试数据集。 想法是,我们仅使用训练数据集中的数据来训练模型,然后使用为测试数据集保留的数据评估模型的性能。 这样可以防止我们过拟合现有的数据,因为我们正在针对该模型进行过从未见过的数据测试。
回想一下训练/测试,当时的想法是,我们将要构建机器学习模型的所有数据分为两个部分:训练数据集和测试数据集。 想法是,我们仅使用训练数据集中的数据来训练模型,然后使用为测试数据集保留的数据评估模型的表现。 这样可以防止我们过拟合现有的数据,因为我们正在针对该模型进行过从未见过的数据测试。
但是,训练/测试仍然有其局限性:您仍然可能最终过度适合您的特定训练/测试单元。 也许您的训练数据集并不能真正代表整个数据集,并且太多的东西最终出现在您的训练数据集中,使事情发生了偏差。 因此,这就是 K 折交叉验证的用武之地,它需要训练/测试并将其提升一个档次。
......@@ -73,13 +73,13 @@
# 使用 Scikit-learn 的 K 折交叉验证的示例
幸运的是,Scikit-learn 使得此操作确实非常容易,并且比进行常规培训/测试更容易! 进行 K 折叠交叉验证非常简单,因此您也可以这样做。
幸运的是,Scikit-learn 使得此操作确实非常容易,并且比进行常规训练/测试更容易! 进行 K 折叠交叉验证非常简单,因此您也可以这样做。
现在,这一切在实践中的工作方式是您将要尝试调整一个模型,并且该模型将具有不同的变体,您可能需要对其进行调整的不同参数,对吗?
例如,多项式拟合的多项式次数。 因此,我们的想法是尝试使用模型的不同值,不同的变体,使用 K 折交叉验证对它们进行度量,然后找到一个对测试数据集最小化误差的变量。 那是您在那里的最佳去处。 在实践中,您想使用 K 折交叉验证来衡量模型相对于测试数据集的准确性,并且只是不断完善该模型,继续尝试其中的不同值,继续尝试该模型的不同变体,甚至尝试完全不同的建模方法,直到您找到使用 K 折交叉验证最大程度地减少错误的技术为止。
例如,多项式拟合的多项式次数。 因此,我们的想法是尝试使用模型的不同值,不同的变体,使用 K 折交叉验证对它们进行度量,然后找到一个对测试数据集最小化误差的变量。 那是您在那里的最佳去处。 在实践中,您想使用 K 折交叉验证来衡量模型相对于测试数据集的准确率,并且只是不断完善该模型,继续尝试其中的不同值,继续尝试该模型的不同变体,甚至尝试完全不同的建模方法,直到您找到使用 K 折交叉验证最大程度地减少误差的技术为止。
让我们深入一个例子,看看它是如何工作的。 我们将再次将其应用于鸢尾花数据集,重新访问 SVC,然后我们将进行 K 折交叉验证,看看它有多简单。 我们实际上使用一些真实的 Python 代码在此处进行 K 折交叉验证和训练/测试。 您会发现它实际上非常易于使用,这是一件好事,因为这是您应使用的一种技术,用于在监督学习中测量模型的准确和有效性。
让我们深入一个例子,看看它是如何工作的。 我们将再次将其应用于鸢尾花数据集,重新访问 SVC,然后我们将进行 K 折交叉验证,看看它有多简单。 我们实际上使用一些真实的 Python 代码在此处进行 K 折交叉验证和训练/测试。 您会发现它实际上非常易于使用,这是一件好事,因为这是您应使用的一种技术,用于在监督学习中测量模型的准确和有效性。
请继续打开`KFoldCrossValidation.ipynb`,然后继续操作。 我们将再次查看鸢尾花数据集; 还记得我们在谈到降维时介绍过的吗?
......@@ -109,13 +109,13 @@ clf.score(X_test, y_test)
```
我们要做的是使用 Scikit-learn 的`cross_validation`库,我们首先进行常规的火车测试拆分,仅进行一次火车/测试拆分,然后看看如何工作。
我们要做的是使用 Scikit-learn 的`cross_validation`库,我们首先进行常规的训练测试拆分,仅进行一次训练/测试拆分,然后看看如何工作。
为此,我们有一个`train_test_split()`函数,使它非常容易。 因此,此方法的工作方式是将一组特征数据输入到`train_test_split()`中。 `iris.data`仅包含每朵花的所有实际测量值。 `iris.target`基本上是我们要预测的事情。
在这种情况下,它包含每朵花的所有种类。 `test_size`说我们要训练与测试的百分比。 因此,0.4 表示我们将随机抽取 40% 的数据用于测试,并将 60% 的数据用于培训。 这带给我们的是 4 个数据集,基本上是特征数据和目标数据的训练数据集和测试数据集。 因此,`X_train`最终包含鸢尾花测量值的 60%,`X_test`包含 40% 用于测试模型结果的测量值。 `y_train``y_test`包含这些段中每个段的实际种类。
在这种情况下,它包含每朵花的所有种类。 `test_size`说我们要训练与测试的百分比。 因此,0.4 表示我们将随机抽取 40% 的数据用于测试,并将 60% 的数据用于训练。 这带给我们的是 4 个数据集,基本上是特征数据和目标数据的训练数据集和测试数据集。 因此,`X_train`最终包含鸢尾花测量值的 60%,`X_test`包含 40% 用于测试模型结果的测量值。 `y_train``y_test`包含这些段中每个段的实际种类。
然后,在此之后,我们继续构建一个 SVC 模型,以根据鸢尾花物种的测量值来预测它们,然后仅使用训练数据来构建该模型。 我们使用线性核,仅使用训练特征数据和训练种类数据(即目标数据)来拟合此 SVC 模型。 我们称该模型为`clf`。 然后,我们在`clf`上调用`score()`函数以仅针对我们的测试数据集测量其性能。 因此,我们根据为鸢尾花测量保留的测试数据和鸢尾花种类对模型进行评分,并观察其效果如何:
然后,在此之后,我们继续构建一个 SVC 模型,以根据鸢尾花物种的测量值来预测它们,然后仅使用训练数据来构建该模型。 我们使用线性核,仅使用训练特征数据和训练种类数据(即目标数据)来拟合此 SVC 模型。 我们称该模型为`clf`。 然后,我们在`clf`上调用`score()`函数以仅针对我们的测试数据集测量其表现。 因此,我们根据为鸢尾花测量保留的测试数据和鸢尾花种类对模型进行评分,并观察其效果如何:
![](img/7d9b6519-0e08-4385-af2a-4dc643935313.jpg)
......@@ -139,11 +139,11 @@ print scores.mean()
我想要`cv=5`,这意味着它实际上将使用 5 个不同的训练数据集,同时保留`1`进行测试。 基本上,它将运行 5 次,这就是我们需要做的。 这将针对整个数据集自动评估我们的模型,分解出五种不同的方式,并给我们单独的结果。
如果我们将其输出打印出来,它将为我们提供这些迭代中的每一个迭代(即,这些折叠中的每一个)的实际错误度量的列表。 我们可以将它们平均在一起,以获得基于 K 折交叉验证的总体误差度量:
如果我们将其输出打印出来,它将为我们提供这些迭代中的每一个迭代(即,这些折叠中的每一个)的实际误差度量的列表。 我们可以将它们平均在一起,以获得基于 K 折交叉验证的总体误差度量:
![](img/705c48f3-a3b4-4d63-ae15-c4159c0e5c76.png)
当我们这样做超过 5 倍时,我们可以看到我们的结果甚至比我们想象的还要好! 98% 的准确性。 太酷了! 实际上,在几次运行中我们都具有完美的准确性。 所以这真是太神奇了。
当我们这样做超过 5 倍时,我们可以看到我们的结果甚至比我们想象的还要好! 98% 的准确率。 太酷了! 实际上,在几次运行中我们都具有完美的准确率。 所以这真是太神奇了。
现在,让我们看看是否可以做得更好。 以前我们使用线性核,如果我们使用多项式核甚至更高级怎么办? 这会过拟合还是实际上会更好地拟合我们拥有的数据? 这种类型取决于这些花瓣测量值与实际物种之间是否存在线性关系或多项式关系。 因此,让我们尝试一下:
......@@ -161,7 +161,7 @@ print scores.mean()
事实证明,当我们使用多项式拟合时,最终得出的总体得分甚至低于我们的原始得分。 因此,这告诉我们多项式内核可能过拟合。 当我们使用 K 折交叉验证时,它显示出比线性核函数更低的分数。
这里重要的一点是,如果我们仅使用单个火车/测试单元,就不会意识到我们过拟合。 如果我们像在线性内核上那样只进行一次训练/测试拆分,我们实际上会得到相同的结果。 因此,我们可能会无意间在此处过拟合数据,甚至在不使用 K 折交叉验证的情况下甚至都不知道。 因此,这是一个很好的例子,它说明了救援人员使用 K 折的情况,并警告您过拟合,在这种情况下,单次火车/测试分站可能无法解决这一问题。 因此,请将其放在工具箱中。
这里重要的一点是,如果我们仅使用单个训练/测试单元,就不会意识到我们过拟合。 如果我们像在线性内核上那样只进行一次训练/测试拆分,我们实际上会得到相同的结果。 因此,我们可能会无意间在此处过拟合数据,甚至在不使用 K 折交叉验证的情况下甚至都不知道。 因此,这是一个很好的例子,它说明了救援人员使用 K 折的情况,并警告您过拟合,在这种情况下,单次训练/测试分站可能无法解决这一问题。 因此,请将其放在工具箱中。
如果您想更多地玩这个游戏,请尝试不同程度的尝试。 因此,您实际上可以指定其他数量的度数。 多项式内核的默认值为 3 度,但是您可以尝试其他一个,也可以尝试两个。
......@@ -192,7 +192,7 @@ print scores.mean()
* 也许我正在看有关电影的数据。 电影在不同国家/地区可能具有不同的名称,或者一本书在不同国家/地区可能具有不同的名称,但它们的含义相同。 因此,您需要在需要规范化数据,可以用许多不同方式表示相同数据的地方,并需要将它们组合在一起以获得正确的结果。
* **格式化**:这也可能是一个问题; 事物的格式可能不一致。 以日期为例:在美国,我们总是执行月日年(`MM/DD/YY`),但是在其他国家,他们可能会执行日月年(`DD/MM/YY`),谁知道呢。 您需要了解这些格式差异。 电话号码可能在区号周围带有括号,也许没有。 也许数字的每个部分之间都有破折号,也许没有。 也许社会保险号有破折号,也许没有。 这些都是您需要注意的事情,并且您需要确保在处理过程中不会将格式的变化视为不同的实体或不同的分类。
因此,有很多事情需要提防,而前面的列表只是要注意的主要问题。 记住:垃圾进,垃圾出。 您的模型仅与您提供给它的数据一样好,这是非常非常正确的! 您可以拥有一个非常简单的模型,如果您向其提供大量干净的数据,则其性能将非常好,并且实际上它可能会在较脏的数据集上胜过复杂的模型。
因此,有很多事情需要提防,而前面的列表只是要注意的主要问题。 记住:垃圾进,垃圾出。 您的模型仅与您提供给它的数据一样好,这是非常非常正确的! 您可以拥有一个非常简单的模型,如果您向其提供大量干净的数据,则其表现将非常好,并且实际上它可能会在较脏的数据集上胜过复杂的模型。
因此,确保您拥有足够的数据和高质量的数据通常是最主要的任务。 您会惊讶于现实世界中使用的一些最成功的算法是如此简单。 它们只有通过输入的数据质量和输入的数据量才能成功。 您并不总是需要精美的技术来获得良好的结果。 通常,数据的质量和数量与其他任何事物一样重要。
......@@ -522,11 +522,11 @@ for result in results[:20]:
# 归一化数值数据
这是一个非常快速的部分:我只想提醒您标准化数据的重要性,请确保您的各种输入要素数据在相同范围内并且具有可比性。 而且,有时很重要,有时没有。 但是,您只需要了解它的时间即可。 只需将其放在脑后,因为如果不这样做,有时会影响结果的质量。
这是一个非常快速的部分:我只想提醒您标准化数据的重要性,请确保您的各种输入特征数据在相同范围内并且具有可比性。 而且,有时很重要,有时没有。 但是,您只需要了解它的时间即可。 只需将其放在脑后,因为如果不这样做,有时会影响结果的质量。
因此,有时模型将基于几个不同的数值属性。 如果您还记得多变量模型,那么我们可能正在寻找的汽车具有不同的属性,并且它们可能不是直接可比的度量。 或者,例如,如果我们查看年龄与收入之间的关系,年龄可能在 0 到 100 之间,但以美元计的收入可能在 0 到十亿之间,并且取决于货币,范围可能更大! 某些模型可以。
如果您要进行回归分析,通常这没什么大不了的。 但是,除非将这些值先按比例缩小到一个通用比例,否则其他模型的性能将不佳。 如果不小心,可能会导致某些属性的数量超过其他属性。 如果您试图将这两个值视为模型中的可比较值,那么收入可能最终会超过年龄。
如果您要进行回归分析,通常这没什么大不了的。 但是,除非将这些值先按比例缩小到一个通用比例,否则其他模型的表现将不佳。 如果不小心,可能会导致某些属性的数量超过其他属性。 如果您试图将这两个值视为模型中的可比较值,那么收入可能最终会超过年龄。
因此,这也会给属性带来偏差,这也是一个问题。 您知道,也许您的一组数据是偏斜的,有时您需要对事物与该组值看到的实际范围进行归一化,而不仅仅是将 0 缩放到最大刻度。 对于何时应该和不应该进行这种归一化没有固定的规则。 我只能说您始终在阅读文档以了解所使用的技术。
......
......@@ -372,7 +372,7 @@ rdd.map(lambda x: x*x)
那么,MLlib 可以做什么? 好吧,其中之一就是特征提取。
您可以按比例做的一件事是术语频率和逆文档频率,这对于例如创建搜索索引很有用。 实际上,本章后面将通过一个示例。 同样,关键是它可以使用海量数据集在整个集群中做到这一点,因此您可以潜在地为网络创建自己的搜索引擎。 它还提供基本的统计功能,卡方检验,Pearson 或 Spearman 相关性,以及一些更简单的内容,例如最小值,最大值,均值和方差。 这些本身并不十分令人兴奋,但令人兴奋的是,您实际上可以跨庞大的数据集计算方差,均值或其他任何东西或相关分数,并且实际上会将数据集分解为多个块,并在必要时在整个群集中运行。
您可以按比例做的一件事是词频和逆文档频率,这对于例如创建搜索索引很有用。 实际上,本章后面将通过一个示例。 同样,关键是它可以使用海量数据集在整个集群中做到这一点,因此您可以潜在地为网络创建自己的搜索引擎。 它还提供基本的统计功能,卡方检验,Pearson 或 Spearman 相关性,以及一些更简单的内容,例如最小值,最大值,均值和方差。 这些本身并不十分令人兴奋,但令人兴奋的是,您实际上可以跨庞大的数据集计算方差,均值或其他任何东西或相关分数,并且实际上会将数据集分解为多个块,并在必要时在整个群集中运行。
因此,即使其中的一些操作不是很有趣,但有趣的是它可以运行的规模。 它还可以支持线性回归和逻辑回归等功能,因此,如果您需要将函数拟合到大量数据并将其用于预测,则也可以这样做。 它还支持支持向量机。 我们将在这里介绍一些更高级的算法,一些更高级的算法,并且它们也可以使用 Spark 的 MLlib 扩展到海量数据集。 MLlib 中内置了一个朴素贝叶斯分类器,因此,还记得我们在本书前面构建的垃圾邮件分类器吗? 实际上,您可以使用 Spark 在整个电子邮件系统中执行此操作,然后将其扩展到所需的范围。
......@@ -759,7 +759,7 @@ clusters = KMeans.train(data, K, maxIterations=10,
```
我们传入想要的簇数,即 K 值,该参数为要执行的处理量设置了上限。 然后,我们告诉它使用默认的 K 均值初始化模式,在该模式中,我们仅对簇进行初始质心抽取,然后开始对其进行迭代,然后返回可使用的模型。 我们将其称为`clusters`
我们传入想要的群集数,即 K 值,该参数为要执行的处理量设置了上限。 然后,我们告诉它使用默认的 K 均值初始化模式,在该模式中,我们仅对群集进行初始质心抽取,然后开始对其进行迭代,然后返回可使用的模型。 我们将其称为`clusters`
好了,现在我们可以使用该集群了。
......@@ -789,7 +789,7 @@ print (results)
```
为了获得实际结果,我们要做的是使用`countByValue`,而要做的就是给我们返回一个 RDD,该 RDD 的每个簇中有多少个点。 请记住,`resultRDD`当前已将每个单独的点映射到最终的集群,因此现在我们可以使用`countByValue`来计算每个给定集群 ID 所能看到的值。 然后,我们可以轻松地将该列表打印出来。 实际上,通过在其上调用`collect`,我们也可以查看该 RDD 的原始结果,这将使我获得每个点簇的分配,我们可以打印出所有这些点。
为了获得实际结果,我们要做的是使用`countByValue`,而要做的就是给我们返回一个 RDD,该 RDD 的每个群集中有多少个点。 请记住,`resultRDD`当前已将每个单独的点映射到最终的集群,因此现在我们可以使用`countByValue`来计算每个给定集群 ID 所能看到的值。 然后,我们可以轻松地将该列表打印出来。 实际上,通过在其上调用`collect`,我们也可以查看该 RDD 的原始结果,这将使我获得每个点群集的分配,我们可以打印出所有这些点。
# 在设定的平方误差总和内(WSSSE)
......@@ -836,22 +836,22 @@ spark-submit SparkKMeans.py
接下来,我们打印出每个点的聚类分配,并且,如果您还记得的话,构成该数据的原始数据是按顺序进行的,因此,将所有 3 个和所有 1 个一起查看实际上是一件好事 ,以及所有 4s 在一起,看起来好像开始与 0s 和 2s 有点混淆了,但是总的来说,它似乎非常好地发现了我们最初创建数据的集群。
最后,我们计算了 WSSSE 指标,在本示例中为 19.97。 因此,如果您想稍微尝试一下,我鼓励您这样做。 您可以看到随着增加或减小 K 值,该错误度量会发生什么,并思考为什么会这样。 如果不对所有数据进行归一化,您还可以尝试发生什么,这是否会对您的结果产生有意义的影响? 这实际上是一件重要的事情吗? 您还可以在模型本身上使用`maxIterations`参数进行试验,从而很好地了解实际对最终结果的影响以及它的重要性。 因此,可以随意使用它并进行实验。 这是使用 MLlib 和 Spark 以可扩展方式完成的 K 均值聚类。 很酷的东西。
最后,我们计算了 WSSSE 指标,在本示例中为 19.97。 因此,如果您想稍微尝试一下,我鼓励您这样做。 您可以看到随着增加或减小 K 值,该误差度量会发生什么,并思考为什么会这样。 如果不对所有数据进行归一化,您还可以尝试发生什么,这是否会对您的结果产生有意义的影响? 这实际上是一件重要的事情吗? 您还可以在模型本身上使用`maxIterations`参数进行试验,从而很好地了解实际对最终结果的影响以及它的重要性。 因此,可以随意使用它并进行实验。 这是使用 MLlib 和 Spark 以可扩展方式完成的 K 均值聚类。 很酷的东西。
# TF-IDF
因此,我们最后的 MLlib 示例将使用称为术语频率逆文档频率或 TF-IDF 的东西,它是许多搜索算法的基本组成部分。 和往常一样,这听起来很复杂,但没有听起来那么糟糕。
因此,我们最后的 MLlib 示例将使用称为词频逆文档频率或 TF-IDF 的东西,它是许多搜索算法的基本组成部分。 和往常一样,这听起来很复杂,但没有听起来那么糟糕。
因此,首先让我们讨论 TF-IDF 的概念,以及如何使用它来解决搜索问题。 我们实际上要使用 TF-IDF 的方法是使用 MLlib 中的 Apache Spark 为维基百科创建一个基本的搜索引擎。 那有多棒? 让我们开始吧。
TF-IDF 代表术语频率和文档逆向频率,这基本上是两个指标,它们在进行搜索和弄清楚给定单词与文档的相关性(给定大量文档)时紧密相关。 因此,例如,对于维基百科上的每篇文章,可能都会有一个术语频率与之相关,对于该文档中出现的每个单词,互联网上的每个页面都可能会与术语频率相关联。 听起来很花哨,但是,正如您将看到的,这是一个非常简单的概念。
TF-IDF 代表词频和文档逆向频率,这基本上是两个指标,它们在进行搜索和弄清楚给定单词与文档的相关性(给定大量文档)时紧密相关。 因此,例如,对于维基百科上的每篇文章,可能都会有一个词频与之相关,对于该文档中出现的每个单词,互联网上的每个页面都可能会与词频相关联。 听起来很花哨,但是,正如您将看到的,这是一个非常简单的概念。
* **所有词频**表示给定文档中给定单词出现的频率。 那么,在一个网页内,在一篇维基百科文章内,在任何内容内,给定单词在该文档中的普遍程度如何? 您知道,该单词在该文档中所有单词中的出现率是多少? 而已。 这就是所有术语的频率。
* **文档频率**是相同的想法,但是这次是该单词在整个文档库中的频率。 因此,这个词多久出现在我拥有的所有文档,所有网页,维基百科上的所有文章中,无论如何。 例如,`a``the`之类的常用词的文档出现频率很高,我希望它们的术语出现频率也很高,但这并不一定意味着它们与给定文档相关 。
* **所有词频**表示给定文档中给定单词出现的频率。 那么,在一个网页内,在一篇维基百科文章内,在任何内容内,给定单词在该文档中的普遍程度如何? 您知道,该单词在该文档中所有单词中的出现率是多少? 而已。 这就是所有单词的频率。
* **文档频率**是相同的想法,但是这次是该单词在整个文档库中的频率。 因此,这个词多久出现在我拥有的所有文档,所有网页,维基百科上的所有文章中,无论如何。 例如,`a``the`之类的常用词的文档出现频率很高,我希望它们的单词出现频率也很高,但这并不一定意味着它们与给定文档相关 。
您可以看到我们将如何发展。 因此,假设给定单词的词频很高,而文档词频很低。 这两件事的比例可以使我对该词与文档的相关性有所了解。 因此,如果我看到某个单词在给定文档中经常出现,但在文档的整体空间中却很少出现,那么我知道这个单词可能对该特定文档传达了一些特殊含义。 它可能传达了本文档的实际含义。
因此,这就是 TF-IDF。 它仅代表术语频率 x 反向文档频率,这只是表达术语频率高于文档频率的一种奇妙方式,也只是一种表达该单词在本文档中出现的频率与在文档中出现的频率相比的奇特方式。 整个文件? 就这么简单。
因此,这就是 TF-IDF。 它仅代表词频 x 反向文档频率,这只是表达词频高于文档频率的一种奇妙方式,也只是一种表达该单词在本文档中出现的频率与在文档中出现的频率相比的奇特方式。 整个文件? 就这么简单。
# 实践中的 TF-IDF
......@@ -863,7 +863,7 @@ TF-IDF 代表术语频率和文档逆向频率,这基本上是两个指标,
# 使用 TF-IDF
我们如何将其变成实际的搜索问题? 一旦有了 TF-IDF,我们就可以衡量每个单词与每个文档的相关性。 我们该怎么办? 嗯,您可以做的一件事是为我们在整个文档正文中遇到的每个单词计算 TF-IDF,然后假设我们要搜索给定术语,给定单词。 假设我们要搜索“我的一组维基百科文章中与葛底斯堡最相关的维基百科文章?” 我可以按照葛底斯堡的 TF-IDF 分数对所有文档进行排序,并获得最佳结果,而这就是我对葛底斯堡的搜索结果。 而已。 只需使用您的搜索词,计算 TF-IDF,然后获得最高的结果。 而已。
我们如何将其变成实际的搜索问题? 一旦有了 TF-IDF,我们就可以衡量每个单词与每个文档的相关性。 我们该怎么办? 嗯,您可以做的一件事是为我们在整个文档正文中遇到的每个单词计算 TF-IDF,然后假设我们要搜索给定项目,给定单词。 假设我们要搜索“我的一组维基百科文章中与葛底斯堡最相关的维基百科文章?” 我可以按照葛底斯堡的 TF-IDF 分数对所有文档进行排序,并获得最佳结果,而这就是我对葛底斯堡的搜索结果。 而已。 只需使用您的搜索词,计算 TF-IDF,然后获得最高的结果。 而已。
显然,在现实世界中,要搜索的内容不止这些。 Google 有许多人致力于解决这个问题,实际上它的方法更加复杂,但这实际上将为您提供有效的搜索引擎算法,并产生合理的结果。 让我们继续前进,看看它是如何工作的。
......@@ -888,7 +888,7 @@ from pyspark.mllib.feature import IDF
```
因此,这就是在我们的文档中计算术语频率`TF`)和反向文档频率(`IDF`)的原因。
因此,这就是在我们的文档中计算词频`TF`)和反向文档频率(`IDF`)的原因。
# 创建初始 RDD
......@@ -1090,7 +1090,7 @@ data = inputLines.map(lambda x: x.split(",")).map(lambda x: (float(x[0]), Vector
```
我们要做的第一件事是使用`map`函数将数据拆分,该函数仅将每行拆分为列表中的两个不同值,然后将其映射为 MLlib 期望的格式。 这将是一个浮点标签,然后是要素数据的密集向量。
我们要做的第一件事是使用`map`函数将数据拆分,该函数仅将每行拆分为列表中的两个不同值,然后将其映射为 MLlib 期望的格式。 这将是一个浮点标签,然后是特征数据的密集向量。
在这种情况下,我们只有一点特征数据即权重,因此我们拥有的向量中只有一件事,但是即使只是一件事,MLlib 线性回归模型也需要一个密集的向量。 这就像旧版 API 中的`labeledPoint`,但是我们必须在这里用困难的方式做到这一点。
......@@ -1102,7 +1102,7 @@ df = data.toDF(colNames)
```
我们将告诉 MLlib,结果 RDD 中的这两列实际上对应于标签和功能,然后我可以将该 RDD 转换为`DataFrame`对象。 此时,我有一个实际的数据帧,或者,如果有的话,我将有一个包含两个列,标签和要素的数据集,其中标签是浮点高度,而要素列是浮点权重的密集向量。 这是 MLlib 要求的格式,而 MLlib 可能对此有些挑剔,因此请务必注意这些格式。
我们将告诉 MLlib,结果 RDD 中的这两列实际上对应于标签和功能,然后我可以将该 RDD 转换为`DataFrame`对象。 此时,我有一个实际的数据帧,或者,如果有的话,我将有一个包含两个列,标签和特征的数据集,其中标签是浮点高度,而特征列是浮点权重的密集向量。 这是 MLlib 要求的格式,而 MLlib 可能对此有些挑剔,因此请务必注意这些格式。
现在,就像我说的,我们将数据分成两半。
......
......@@ -38,7 +38,7 @@ A/B 测试会将人们分成看到橙色按钮的人们和看到蓝色按钮的
* **设计更改**:这些可以是按钮颜色,按钮位置或页面布局的更改。
* **UI 流程**:因此,也许您实际上是在改变购买渠道的工作方式以及人们在您的网站上结帐的方式,并且您实际上可以衡量其效果。
* **算法更改**:让我们考虑在第 6 章,“推荐系统”中讨论过的电影推荐示例。 也许我想测试一种算法与另一种算法。 我真正关心的不是去依靠错误指标和我进行火车测试的能力,而是要去驱动购买或租赁,或者本网站上的任何内容。
* **算法更改**:让我们考虑在第 6 章,“推荐系统”中讨论过的电影推荐示例。 也许我想测试一种算法与另一种算法。 我真正关心的不是去依靠错误指标和我进行训练测试的能力,而是要去驱动购买或租赁,或者本网站上的任何内容。
* A/B 测试可以让我直接测量该算法对我真正关心的最终结果的影响,而不仅仅是我预测别人已经看过的电影的能力。
* 您还可以梦想得到的任何其他东西,实际上,影响用户与您的网站交互方式的任何更改都值得测试。 也许甚至可以使网站更快,或者可以是任何东西。
......@@ -167,7 +167,7 @@ stats.ttest_ind(A, B)
# 当两组之间没有真正的区别时
就像进行健全性检查一样,让我们​​继续进行更改,以使这两组之间没有真正的区别。 因此,我将更改组`B`(在这种情况下为对照组),使其与治疗相同,其中均值为 25,标准差不变,样本大小不变,如下所示:
就像进行健全性检查一样,让我们​​继续进行更改,以使这两组之间没有真正的区别。 因此,我将更打乱`B`(在这种情况下为对照组),使其与治疗相同,其中均值为 25,标准差不变,样本大小不变,如下所示:
```py
B = np.random.normal(25.0, 5.0, 10000)
......
......@@ -18,11 +18,11 @@
第 6 章,“使用线性回归执行预测”可帮助您建立简单的回归模型,然后建立多个回归模型以及测试模型有效性的方法。 线性回归是当今业界用于模型构建的最流行技术之一。
第 7 章,“估计事件的可能性”教您如何建立逻辑回归模型以及评估它的不同技术。 使用逻辑回归,您将能够学习如何估事件发生的可能性。
第 7 章,“估计事件的可能性”教您如何建立逻辑回归模型以及评估它的不同技术。 使用逻辑回归,您将能够学习如何估事件发生的可能性。
第 8 章,“通过协同过滤生成建议”教您创建并应用推荐模型。 它类似于网站(例如 Amazon),该网站能够建议您可能会在其页面上购买的商品。
第 9 章,“使用集成模型推展边界”使您熟悉集成技术,该技术用于组合多个模型的功能以增强预测的准确。 这样做是因为有时单个模型不足以估计结果。
第 9 章,“使用集成模型推展边界”使您熟悉集成技术,该技术用于组合多个模型的功能以增强预测的准确。 这样做是因为有时单个模型不足以估计结果。
第 10 章,“将分段与 K 均值聚类一起应用”教您有关 K 均值聚类及其使用方法。 细分在行业中广泛用于将相似的客户分组在一起。
......
......@@ -242,7 +242,7 @@ Pandas 库本质上具有三个数据结构:
### 序列
`Series`是一维数组,它可以保存任何类型的数据,例如也可以是整数,浮点数,字符串和 Python 对象。 可以通过调用以下命令来创建列:
`Series`是一维数组,它可以保存任何类型的数据,例如也可以是整数,浮点数,字符串和 Python 对象。 可以通过调用以下命令来创建列:
```py
>>> import pandas as pd
......@@ -257,9 +257,9 @@ dtype: float64
```
`random.randn`参数是 NumPy 包的一部分,它生成随机数。 `series`函数创建一个由索引组成的 Pandas 系列,第一列是索引,第二列由随机值组成。 输出的底部是系列的数据类型。
`random.randn`参数是 NumPy 包的一部分,它生成随机数。 `series`函数创建一个由索引组成的 Pandas 序列,第一列是索引,第二列由随机值组成。 输出的底部是序列的数据类型。
可以通过调用以下命令来定制列的索引:
可以通过调用以下命令来定制列的索引:
```py
>>> pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])
......@@ -296,7 +296,7 @@ dtype: int64
* 序列
* 2D NumPy 数组
可以通过调用以下命令从列字典创建`DataFrame`
可以通过调用以下命令从列字典创建`DataFrame`
```py
>>> d = {'c1': pd.Series(['A', 'B', 'C']),
......@@ -634,7 +634,7 @@ a41 0.547655 0.692852 0.681825
```
在前面的命令中,使用了列的`str`属性。 `str`类包含`extract`方法,可以使用正则表达式来提取数据,这非常强大。 也可以在`AREA NAME`中提取另一个单词作为单独的列:
在前面的命令中,使用了列的`str`属性。 `str`类包含`extract`方法,可以使用正则表达式来提取数据,这非常强大。 也可以在`AREA NAME`中提取另一个单词作为单独的列:
```py
>>> df['AREA NAME'][0:5].str.extract('(\w+)\s(\w+)')
......
......@@ -386,7 +386,7 @@ p 值为:
![A confidence interval](img/3450_02_25.jpg)
在此,`s`是样品的标准差,`n`是样品的元素数。
在此,`s`是样本的标准差,`n`是样本的元素数。
可以使用 SciPy 包的`sem()`函数来计算:
......
......@@ -460,7 +460,7 @@ Matplotlib 库中的样式包使更改绘图图的样式更加容易。 更改
![A scatter plot matrix](img/B03450_04_20.jpg)
核密度估计是估计随机变量的概率密度函数的非参数方法。 从根本上讲,它有助于理解数据是否正态分布以及数据偏斜的方向。
核密度估计是估计随机变量的概率密度函数的非参数方法。 从根本上讲,它有助于理解数据是否正态分布以及数据偏斜的方向。
# 区域图
......@@ -548,7 +548,7 @@ Matplotlib 库中的样式包使更改绘图图的样式更加容易。 更改
在前面的代码中,`rplot.RPlot`带有`tips_data`对象。 同样,定义了`x``y`轴值。 此后,根据吸烟者和性别定义网格网格。 最后,我们使用`GeomHistogram()`绘制直方图。
要将网格图更改为核密度估计,我们可以使用以下代码:
要将网格图更改为核密度估计,我们可以使用以下代码:
```py
>>> plt.figure()
......@@ -581,7 +581,7 @@ Matplotlib 库中的样式包使更改绘图图的样式更加容易。 更改
该代码与上一个示例类似。 唯一的区别是`GeomScatter()``GeomPolyFit`用于获得绘图上的拟合线。
通过使用以下代码,可以将散点图与 2D 核密度图组合:
通过使用以下代码,可以将散点图与 2D 核密度图组合:
```py
>>> plt.figure()
......@@ -618,7 +618,7 @@ Matplotlib 库中的样式包使更改绘图图的样式更加容易。 更改
![A 3D plot of a surface](img/B03450_04_29.jpg)
在前面的代码中,我们定义了`x``y`轴,其值介于 -4 到 4 之间。我们创建了一个带有`meshgrid()`的坐标矩阵,然后将这些值平方`x``y`的总和,最后将它们总结。 然后将其输入到`plot_surface`函数。 简单来说,`rstride``cstride`参数有助于确定表面细胞的大小。
在前面的代码中,我们定义了`x``y`轴,其值介于 -4 到 4 之间。我们创建了一个带有`meshgrid()`的坐标矩阵,然后将这些值平方`x``y`的总和,最后将它们总结。 然后将其输入到`plot_surface`函数。 简单来说,`rstride``cstride`参数有助于确定表面单元的大小。
让我们使用`view_int`调整视图。 以下是`0`度仰角和`0`度角的视图:
......
......@@ -74,7 +74,7 @@
决策树模型基本上有两种类型:
* **分类树**:这些树是指采用有限值的因变量。 在这些树结构中,分支表示导致类标签的要素规则,而叶子则表示结果的类标签。
* **分类树**:这些树是指采用有限值的因变量。 在这些树结构中,分支表示导致类标签的特征规则,而叶子则表示结果的类标签。
* **回归树**:当因变量采用连续值时,它们称为回归树。
让我们举个例子。 以下数据根据天气,湿度和风力的总体情况表示您是否应该打网球:
......@@ -156,14 +156,14 @@ y = 1.405405405 x + 57.87687688
逻辑回归可以应用于以下情况:
1. 在零售商店中为购买已推出的新产品的客户得出倾向得分。
2. 变压器无法使用与其关联的传感器数据的可能性。
2. 转换器无法使用与其关联的传感器数据的可能性。
3. 用户根据其行为点击在网站上显示的广告的可能性。
逻辑回归具有更多的应用,下面的章节将通过示例更详细地讨论逻辑回归。
# 朴素贝叶斯分类器
朴素贝叶斯分类器是基于贝叶斯定理的简单概率分类器。 所做的假设是,要素之间存在很强的相互依赖性,因此将其称为朴素。 以下是贝叶斯定理:
朴素贝叶斯分类器是基于贝叶斯定理的简单概率分类器。 所做的假设是,特征之间存在很强的相互依赖性,因此将其称为朴素。 以下是贝叶斯定理:
![The naive Bayes classifier](img/B03450_05_09.jpg)
......@@ -204,7 +204,7 @@ K 均值聚类是一种无监督的学习技术,有助于将`n`观测值的数
![The k-means clustering](img/B03450_05_10.jpg)
之所以称其为聚类算法,是因为它通过计算特征的均值来进行操作,这些均值是指我们对事物进行聚类的因变量,例如根据平均交易量和一年中每季度购买的平均产品数量来细分客户。 然后,该平均值成为群集的中心。`K`数是指数,即,技术包含计算`K`个均值,从而产生这些 K 均值周围数据的*群集*
之所以称其为聚类算法,是因为它通过计算特征的均值来进行操作,这些均值是指我们对事物进行聚类的因变量,例如根据平均交易量和一年中每季度购买的平均产品数量来细分客户。 然后,该平均值成为群集的中心。`K`数是指群集数,即,技术包含计算`K`个均值,从而产生这些 K 均值周围数据的*群集*
我们如何选择这个 K? 如果我们对所要寻找的东西有所了解,或者期望或想要多少个集群,那么在启动引擎并让算法进行计算之前,将`K`设置为该数字。
......
......@@ -261,7 +261,7 @@ Coefficient value of the height is [ 1.00092142]
* statsmodels 模块
* SciKit 包
甚至 Pandas 都提供了**普通最小二乘****OLS**)回归,您可以在完成本章之后进行尝试。 普通最小二乘法是一种估未知系数和回归方程截距的方法。 我们将从 statsmodels 包开始。 **统计模型**是一个 Python 模块,允许用户浏览数据,估计统计模型和执行统计测试。 描述性统计信息,统计检验,绘图函数和结果统计信息的广泛列表适用于不同类型的数据和每个估计量:
甚至 Pandas 都提供了**普通最小二乘****OLS**)回归,您可以在完成本章之后进行尝试。 普通最小二乘法是一种估未知系数和回归方程截距的方法。 我们将从 statsmodels 包开始。 **统计模型**是一个 Python 模块,允许用户浏览数据,估计统计模型和执行统计测试。 描述性统计信息,统计检验,绘图函数和结果统计信息的广泛列表适用于不同类型的数据和每个估计量:
```py
>>> result = sm.OLS( y_train, add_constant(X_train) ).fit()
......
# 第 7 章。估计事件的可能性
逻辑回归是一种回归分析,可帮助您根据某些给定参数估事件发生的可能性。 它用作具有二进制结果的分类技术。 使用逻辑函数,根据解释性变量(预测变量)对描述单个试验可能结果的概率进行建模。
逻辑回归是一种回归分析,可帮助您根据某些给定参数估事件发生的可能性。 它用作具有二进制结果的分类技术。 使用逻辑函数,根据解释性变量(预测变量)对描述单个试验可能结果的概率进行建模。
在第 5 章“发现机器学习”中,已经向您介绍了 *Logisitc 回归*。 在本章中,您将学习:
......@@ -205,7 +205,7 @@
## 根据测试数据评估模型
让我们使用测试数据上的模型通过进行预测,并通过保持`0.7`的阈值来通过精度和召回率显示模型的性能
让我们使用测试数据上的模型通过进行预测,并通过保持`0.7`的阈值来通过精度和召回率显示模型的表现
```py
>>> y_pred = res.predict(x_test)
......@@ -234,7 +234,7 @@
让我们了解精确度和召回率的含义。
* **精度**:精度告诉您,在 0 类或 1 类的所有预测中,有多少个已正确预测。 因此,在上述情况下,非幸存者的预测的 76% 是正确的,而幸存者的预测的 100% 是正确的。
* **召回**:召回告诉您,在实际实例中,有多少个已正确预测。 因此,在上述情况下,所有未幸存的人都可以 100% 的准确正确预测,但是在所有幸存的人中,只有 53% 的人被正确预测了。
* **召回**:召回告诉您,在实际实例中,有多少个已正确预测。 因此,在上述情况下,所有未幸存的人都可以 100% 的准确正确预测,但是在所有幸存的人中,只有 53% 的人被正确预测了。
让我们绘制**受试者工作特性****ROC**)曲线,其解释如下:
......@@ -282,7 +282,7 @@ Area under the ROC curve : 0.879934
![Evaluating a model based on test data](img/B03450_07_13.jpg)
精度由 ROC 曲线下的面积衡量。 面积 1 代表完美测试; `0.5`区域表示该模型与随机猜测一样好。 对诊断测试的准确进行分类的大致指南是传统的学术评分系统,如下所示:
精度由 ROC 曲线下的面积衡量。 面积 1 代表完美测试; `0.5`区域表示该模型与随机猜测一样好。 对诊断测试的准确进行分类的大致指南是传统的学术评分系统,如下所示:
| 范围 | 类别 |
| --- | --- |
......@@ -340,7 +340,7 @@ Area under the ROC curve : 0.879934
![Model building and evaluation with SciKit](img/B03450_07_16.jpg)
我们可以看到与我们创建的先前模型相比,性能略有不同。 有两种肯定的预测已转变为否定的预测。
我们可以看到与我们创建的先前模型相比,表现略有不同。 有两种肯定的预测已转变为否定的预测。
让我们计算曲线下的 ROC 和面积:
......
......@@ -554,4 +554,4 @@ movie_user_preferences['William']['Gone Girl']
在本章中,您学习了如何执行基于用户和基于项目的协同过滤。 您还了解了一些可用于计算用户和项目之间相似度的度量标准,以及如何应用此相似度为最终用户生成建议。
下一章将介绍不同的集成模型,这些模型基本上将多个模型结合起来以提高预测的性能。
\ No newline at end of file
下一章将介绍不同的集成模型,这些模型基本上将多个模型结合起来以提高预测的表现。
\ No newline at end of file
# 第 9 章。使用集成模型扩展边界
集成建模是一个过程,其中生成两个或多个模型,然后将其结果合并。 在本章中,我们将介绍一个随机森林,这是一种非参数建模技术,其中在训练期间创建了多个决策树,然后将这些决策树的结果取平均值,以提供所需的输出。 之所以称为**随机森林**,是因为在训练期间会根据随机选择的要素创建许多决策树。
集成建模是一个过程,其中生成两个或多个模型,然后将其结果合并。 在本章中,我们将介绍一个随机森林,这是一种非参数建模技术,其中在训练期间创建了多个决策树,然后将这些决策树的结果取平均值,以提供所需的输出。 之所以称为**随机森林**,是因为在训练期间会根据随机选择的特征创建许多决策树。
一个比喻是试图猜测一个玻璃罐中的卵石数量。 有些人试图猜测罐子里的卵石数量。 单独地,每个人在猜测玻璃罐中的卵石数量时都会犯错,但是当您对他们的每个猜测进行平均时,所得到的平均猜测将非常接近罐中卵石的实际数量。
......@@ -335,7 +335,7 @@ GPA 高且属于非常春藤盟校的申请人与 GPA 低且属于非常春藤
![Decision trees](img/B03450_09_12.jpg)
我们可以看到,收入不超过 50K 刀的人们可以得到很好的预测,其准确度为 85%,召回率为 87%。 收入超过 50K 刀的人只能以 56% 的准确度和 52% 的召回率来预测
我们可以看到,收入不超过 50K 刀的人们可以得到很好的预测,其准确率为 85%,召回率为 87%。 收入超过 50K 刀的人只能以 56% 的准确率和 52% 的召回率来预测
请注意,公式中给出的因变量的顺序将略微更改这些值。 您可以尝试查看更改变量的顺序是否会提高其精度/调用率。
......@@ -371,9 +371,9 @@ GPA 高且属于非常春藤盟校的申请人与 GPA 低且属于非常春藤
![Random forests](img/B03450_09_13.jpg)
我们可以看到,我们提高了收入和收入不超过 50K 刀的人的准确和召回率。
我们可以看到,我们提高了收入和收入不超过 50K 刀的人的准确和召回率。
让我们尝试通过使用`min_samples_split`参数并将其设置为`5`来对进行微调,以使模型获得更好的性能。 此参数告诉我们创建拆分所需的最小样本数为`5`
让我们尝试通过使用`min_samples_split`参数并将其设置为`5`来对进行微调,以使模型获得更好的表现。 此参数告诉我们创建拆分所需的最小样本数为`5`
```py
>>> clf = sk.RandomForestClassifier(n_estimators=100, oob_score=True,min_samples_split=5)
......@@ -435,6 +435,6 @@ GPA 高且属于非常春藤盟校的申请人与 GPA 低且属于非常春藤
# 总结
在本章中,我们探索了普查数据中的模式,然后了解了如何构建决策树,并且还基于给定的数据建立了决策树模型。 然后,您在随机森林的帮助下学习了集成模型的概念,并通过使用随机森林模型提高了预测的性能
在本章中,我们探索了普查数据中的模式,然后了解了如何构建决策树,并且还基于给定的数据建立了决策树模型。 然后,您在随机森林的帮助下学习了集成模型的概念,并通过使用随机森林模型提高了预测的表现
在下一章中,您将学习聚类,基本上是将彼此相似的元素分组在一起。 我们将为此使用 K 均值聚类。
\ No newline at end of file
......@@ -6,7 +6,7 @@
在本章中,您将学习以下主题:
* 通过 K 均值技术确定理想的
* 通过 K 均值技术确定理想的群集
* 用 K 均值算法聚类
# K 均值算法及其原理
......@@ -21,7 +21,7 @@ K 均值算法是迭代的。 首先从数据中随机选择`K`点,然后将
完成此操作后,我们便有了新的积分安排。 因此,由于聚类的中心或均值可能已更改,因此再次对其进行了计算。 什么时候不转移? 当我们拥有稳定的集群并且进行迭代直到无法从进一步迭代中受益时,这就是我们的结果。
在某些情况下 K 均值不会收敛,也就是说,没有稳定的,但在这里我们不做讨论。 您可以在[这个页面](http://webdocs.cs.ualberta.ca/~nray1/CMPUT466_551/kmeans_convergence.pdf)上进一步了解 K 均值的收敛性。
在某些情况下 K 均值不会收敛,也就是说,没有稳定的群集,但在这里我们不做讨论。 您可以在[这个页面](http://webdocs.cs.ualberta.ca/~nray1/CMPUT466_551/kmeans_convergence.pdf)上进一步了解 K 均值的收敛性。
## 一个简单的例子
......@@ -78,7 +78,7 @@ K 均值算法是迭代的。 首先从数据中随机选择`K`点,然后将
您会看到尺寸小的人,例如身材矮小,身高矮,体重轻且呈蓝色。 类似地,对于其他 T 恤尺寸,人的身高和体重彼此围绕在一起。
在前面的案例中,我们为 T 恤尺寸设置了标签。 但是,如果我们没有随身携带的 T 恤尺寸,而是拥有个人的身高和体重,而我们想根据身高和体重来估尺寸,那么这就是 K 均值算法可以帮助我们的地方:
在前面的案例中,我们为 T 恤尺寸设置了标签。 但是,如果我们没有随身携带的 T 恤尺寸,而是拥有个人的身高和体重,而我们想根据身高和体重来估尺寸,那么这就是 K 均值算法可以帮助我们的地方:
```py
>>> from math import sqrt
......@@ -219,7 +219,7 @@ dtype: float64
```
## 确定
## 确定群集
在应用 K 均值算法之前,我们想估计一个理想的集群数量到称为国家的组:
......@@ -233,7 +233,7 @@ dtype: float64
```
在前面的代码中,我们定义了 1 到 10 之间的多个。使用 SciPy 库的 **K 均值函数**,我们计算了质心,以及这些质心和观测值之间的失真,它们相关于质心和群集的观测值之间的失真:
在前面的代码中,我们定义了 1 到 10 之间的多个群集。使用 SciPy 库的 **K 均值函数**,我们计算了质心,以及这些质心和观测值之间的失真,它们相关于质心和群集的观测值之间的失真:
```py
>>> euclidean_centroid = [cdist(df.values, centroid, 'euclidean') for (centroid,var) in k_clusters]
......@@ -258,7 +258,7 @@ dtype: float64
```
我们在组的每个簇中取重心,并使用 SciPy 中的`dist`函数计算从空间中所有点到簇的重心的**欧几里德距离**
我们在组的每个群集中取重心,并使用 SciPy 中的`dist`函数计算从空间中所有点到群集的重心的**欧几里德距离**
您可以看到第一个集群只有一个列,因为它只有一个集群,而第二个集群有两个列,因为它有两个集群:
......
......@@ -302,17 +302,17 @@ CC: conjunction, coordinating & 'n and both but either et for less minus neither
## 词干提取
词干是将单词还原为词根形式的过程。 词根形式本身不是单词,但可以通过在单词后添加正确的后缀来形成单词。
词干提取是将单词还原为词根形式的过程。 词根形式本身不是单词,但可以通过在单词后添加正确的后缀来形成单词。
如果您取鱼,钓鱼和捕鱼,它们都可以阻止捕鱼。 同样,学习,学习和学习也可以被限制为学习,这不是英语的一部分。
有各种类型的词干算法,例如 Porter,Lancaster,Snowball 等。
有各种类型的词干提取算法,例如 Porter,Lancaster,Snowball 等。
波特是最常用的词干。 它也是最温和的词干之一,并且在算法方面占用大量计算资源。
波特是最常用的词干提取。 它也是最温和的词干提取之一,并且在算法方面占用大量计算资源。
Snowball 算法被认为是对 Porter 的改进。 实际上,波特本人也承认 Snowball 算法比他的算法更好。
Lancaster 是一种更具攻击性的词干算法。 读者可以理解 Porter 和 Snowball 的词根提取功能,但 Lancaster 不能理解,因为这会使单词更加晦涩难懂。 Lancaster 被认为是这三种算法中最快的算法,它可以与大量单词配合使用,但是如果您正在寻找更具特色的东西,那么 Lancaster 不适合您。
Lancaster 是一种更具攻击性的词干提取算法。 读者可以理解 Porter 和 Snowball 的词根提取功能,但 Lancaster 不能理解,因为这会使单词更加晦涩难懂。 Lancaster 被认为是这三种算法中最快的算法,它可以与大量单词配合使用,但是如果您正在寻找更具特色的东西,那么 Lancaster 不适合您。
让我们使用以下代码尝试波特提取算法:
......@@ -415,9 +415,9 @@ Actual: of Stem: of
## 词形还原
词形还原与词干相似,但与词干不同,它引入了词的上下文。
词形还原与词干提取相似,但与词干提取不同,它引入了词的上下文。
基于词形化的算法会将火车与单词机车匹配,但词干算法将无法做到这一点。 词形还原算法利用字典来链接单词。
基于词形化的算法会将火车与单词机车匹配,但词干提取算法将无法做到这一点。 词形还原算法利用字典来链接单词。
`WordNet`是普林斯顿的英语词汇数据库,我们将使用其词素化技术:
......@@ -706,6 +706,6 @@ David Cameron 的推文在本质上更趋向积极。
# 总结
在本章中,您学习了如何清除非结构化文本数据,然后从这些数据中绘制了一个词云。 您学习了如何使用 NLTK 标记单词和句子。 您学习了如何执行部分词性标记以及词干和词根化的概念。 向您介绍了命名实体识别,并学习了如何使用 Stanford NER 应用它。 最后,您学习了如何使用 Twitter API 来获取推文,然后对其进行情感分析。
在本章中,您学习了如何清除非结构化文本数据,然后从这些数据中绘制了一个词云。 您学习了如何使用 NLTK 标记单词和句子。 您学习了如何执行部分词性标记以及词干提取和词形还原的概念。 向您介绍了命名实体识别,并学习了如何使用 Stanford NER 应用它。 最后,您学习了如何使用 Twitter API 来获取推文,然后对其进行情感分析。
在下一章中,您将学习如何在大数据世界中使用 Python。
\ No newline at end of file
......@@ -28,7 +28,7 @@
第 6 章,“社交网络分析”为读者提供了处理代表社会关系和互动的数据的实用有效技巧。
第 7 章,“超越基础的深度学习”演示了如何从头开始构建卷积神经网络,介绍了该行业的所有工具以增强您的深度学习模型,并说明了*迁移学习*以及如何使用递归神经网络对文本进行分类和预测序列的工作。
第 7 章,“超越基础的深度学习”演示了如何从头开始构建卷积神经网络,介绍了该行业的所有工具以增强您的深度学习模型,并说明了*迁移学习*以及如何使用循环神经网络对文本进行分类和预测序列的工作。
第 8 章,“用于大数据的 Spark”介绍了一种新的数据处理方式:水平扩展大数据。 这意味着运行已安装 Hadoop 和 Spark 框架的计算机集群。
......
......@@ -483,7 +483,7 @@ import pandas as pd
# Scikit-learn
作为 **SciKits****SciPy 工具包**)的一部分开始,Scikit-learn 是 Python 数据科学运算的核心。 它提供了数据预处理,有监督和无监督学习,模型选择,验证和错误度量方面可能需要的所有功能。 希望我们在本书中详细讨论这个包。 Scikit-learn 于 2007 年由 David Cournapeau 发起,是一个 Google Summer of Code 项目。 自 2013 年以来,它已由 **INRIA****国家信息和自动化研究所**,即法国计算机科学与自动化研究所)的研究人员接管:
作为 **SciKits****SciPy 工具包**)的一部分开始,Scikit-learn 是 Python 数据科学运算的核心。 它提供了数据预处理,有监督和无监督学习,模型选择,验证和误差度量方面可能需要的所有功能。 希望我们在本书中详细讨论这个包。 Scikit-learn 于 2007 年由 David Cournapeau 发起,是一个 Google Summer of Code 项目。 自 2013 年以来,它已由 **INRIA****国家信息和自动化研究所**,即法国计算机科学与自动化研究所)的研究人员接管:
* [**网站**](http://scikit-learn.org/stable)
* **打印时的版本**:0.19.1
......@@ -661,7 +661,7 @@ $> cd python-package $> python setup.py install
# LightGBM
**LightGBM** 是由 Microsoft 开发的一种梯度增强框架,它以与其他 GBM 不同的方式使用基于树的学习算法,从而有利于探索更有前途的叶子(叶面),而不是逐层开发 。
**LightGBM** 是由 Microsoft 开发的一种梯度提升框架,它以与其他 GBM 不同的方式使用基于树的学习算法,从而有利于探索更有前途的叶子(叶面),而不是逐层开发 。
In graph terminology, LightGBM is pursuing a depth-first search strategy than a breadth-first search one.
......@@ -1094,7 +1094,7 @@ In: selector = SelectKBest(f_regression, k=1)
print (X.shape) Out:(506, 1)
```
对于`In:`,我们选择`SelectKBest`类的一项功能(最具区别性的一项),该功能通过使用`.fit()`方法适合数据。 因此,我们借助通过对所有行和所选要素建立索引进行选择的操作将数据集简化为向量,可以通过`.get_support()`方法检索该索引。
对于`In:`,我们选择`SelectKBest`类的一项功能(最具区别性的一项),该功能通过使用`.fit()`方法适合数据。 因此,我们借助通过对所有行和所选特征建立索引进行选择的操作将数据集简化为向量,可以通过`.get_support()`方法检索该索引。
由于目标值是向量,因此,我们可以尝试查看输入(特征)和输出(房屋价值)之间是否存在线性关系。 当两个变量之间存在线性关系时,输出将以相同的比例量和方向不断对输入的变化做出反应:
......@@ -1110,7 +1110,7 @@ In: def plot_scatter(X,Y,R=None):
![](img/e4c174c2-7be7-4fa6-b9ce-0251a6ed2c04.png)
在我们的示例中,随着`X`增加,`Y`减少。 但是,这不会以恒定的速率发生,因为变化率会一直升高到一定的`X`值,然后降低并变为恒定。 这是非线性的条件,我们可以使用回归模型将其进一步可视化。 该模型假设`X``Y`之间的关系是线性的,形式为`y = a + bX`。 根据特定标准估`a``b`参数。
在我们的示例中,随着`X`增加,`Y`减少。 但是,这不会以恒定的速率发生,因为变化率会一直升高到一定的`X`值,然后降低并变为恒定。 这是非线性的条件,我们可以使用回归模型将其进一步可视化。 该模型假设`X``Y`之间的关系是线性的,形式为`y = a + bX`。 根据特定标准估`a``b`参数。
在第四个单元格中,我们分散了此问题的输入和输出值:
......
......@@ -32,7 +32,7 @@
根据我们在该领域的经验,我们可以向您保证,无论您的计划在开始分析数据时有多么有希望,最终,您的解决方案都将与任何最初设想的想法有很大不同。 与实验结果相抵触,您将获得规则,包括数据处理,优化,模型以及在达到令人满意的项目效果之前必须经过的总迭代次数。 这就是为什么如果您想成为一名成功的数据科学家,仅提供理论上合理的解决方案根本是不够的。 必须能够在最快的时间内快速建立大量可能的解决方案的原型,以便确定哪一条是最佳途径。 我们的目的是通过在数据科学过程中使用本书提供的代码段帮助您最大程度地加速。
项目的结果由错误或优化措施(为了表示业务目标而精心选择)表示。 除了错误度量之外,您的成就还可以通过可解释的见解来传达,该见解必须以口头或视觉方式描述给数据科学项目的发起者或其他数据科学家。 在这一点上,使用表格,图表和图表适当地可视化结果和见解确实是必不可少的。
项目的结果由错误或优化措施(为了表示业务目标而精心选择)表示。 除了误差度量之外,您的成就还可以通过可解释的见解来传达,该见解必须以口头或视觉方式描述给数据科学项目的发起者或其他数据科学家。 在这一点上,使用表格,图表和图表适当地可视化结果和见解确实是必不可少的。
也可以使用首字母缩写词 **OSEMN****获取****清理****探索****建模****解释**),由 Hilary Mason 和 Chris Wiggins 在博客 [*dataists*](http://www.dataists.com/2010/09/a-taxonomy-of-data-science/),描述了数据科学分类法。 OSEMN 也很令人难忘,因为它与`possum``awesome`押韵:
......@@ -116,7 +116,7 @@ In: y = iris['target']
Name: target, dtype: object
```
对象`y`的类型是 Pandas 列。 现在,将其视为带有轴标签的一维数组,我们稍后将对其进行深入研究。 现在,我们刚刚了解到,Pandas `Index`类的作用类似于表中各列的字典索引。 请注意,您还可以获得按其索引引用它们的列的列表,如下所示:
对象`y`的类型是 Pandas 列。 现在,将其视为带有轴标签的一维数组,我们稍后将对其进行深入研究。 现在,我们刚刚了解到,Pandas `Index`类的作用类似于表中各列的字典索引。 请注意,您还可以获得按其索引引用它们的列的列表,如下所示:
```py
In: X = iris[['sepal_length', 'sepal_width']]
......@@ -131,21 +131,21 @@ In: X = iris[['sepal_length', 'sepal_width']]
![](img/a295947d-5326-40ac-9005-3f11abce5498.png)
在这种情况下,结果是一个 Pandas `DataFrame`。 使用相同功能时,结果为何如此不同? 在第一种情况下,我们要求提供一列。 因此,输出为一维向量(即 Pandas 系列)。 在第二个示例中,我们询问了多列,并获得了类似矩阵的结果(并且我们知道矩阵被映射为 Pandas `DataFrame`)。 新手阅读者只需查看输出标题即可发现差异。 如果列被标记,则说明您正在处理 Pandas `DataFrame`。 另一方面,如果结果是向量,并且不显示标题,则为 Pandas 系列。
在这种情况下,结果是一个 Pandas `DataFrame`。 使用相同功能时,结果为何如此不同? 在第一种情况下,我们要求提供一列。 因此,输出为一维向量(即 Pandas 序列)。 在第二个示例中,我们询问了多列,并获得了类似矩阵的结果(并且我们知道矩阵被映射为 Pandas `DataFrame`)。 新手阅读者只需查看输出标题即可发现差异。 如果列被标记,则说明您正在处理 Pandas `DataFrame`。 另一方面,如果结果是向量,并且不显示标题,则为 Pandas 序列。
到目前为止,我们已经从数据科学过程中学到了一些常见步骤; 加载数据集后,通常会分离特征和目标标签。
在分类问题中,目标标签是指示与每组要素关联的类的序数或文本字符串。
在分类问题中,目标标签是指示与每组特征关联的类的序数或文本字符串。
然后,以下步骤要求您了解问题的严重程度,因此,您需要了解数据集的大小。 通常,对于每个观察,我们计算一条线,对于每个要素,计算一列。
然后,以下步骤要求您了解问题的严重程度,因此,您需要了解数据集的大小。 通常,对于每个观察,我们计算一条线,对于每个特征,计算一列。
要获取数据集的维度,只需在 Pandas `DataFrame`列上使用属性形状,如以下示例所示:
要获取数据集的维度,只需在 Pandas `DataFrame`列上使用属性形状,如以下示例所示:
```py
In: print (X.shape) Out: (150, 2) In: print (y.shape) Out: (150,)
```
生成的对象是一个元组,其中包含每个维度中矩阵/数组的大小。 另外,请注意,Pandas 列遵循相同的格式(即只有一个元素的元组)。
生成的对象是一个元组,其中包含每个维度中矩阵/数组的大小。 另外,请注意,Pandas 列遵循相同的格式(即只有一个元素的元组)。
# 处理有问题的数据
......@@ -403,7 +403,7 @@ In: connection.close()
**HDF5** 是一种文件格式,最初是由**国家超级计算应用中心****NCSA**)开发的,用于存储和访问大量科学数据。 1990 年代 NASA 的要求,以便对地球观测系统和其他太空观测系统产生的数据具有便携式文件格式。 HDF5 安排为分层数据存储,可保存同构类型或组的多维数组,这些数组是数组和其他组的容器。 作为文件系统,它非常适合`DataFrame`结构,并且通过自动数据压缩,对于大文件,这样的文件系统可以使数据加载比简单地读取 CSV 文件快得多。
使用 Pandas 包可以使用 HDF5 格式存储列和`DataFrame`数据结构。 您可能会发现它对于存储二进制数据(例如预处理的图像或视频文件)也非常有用。 当您需要从磁盘访问大量文件时,由于文件分散在文件系统中,因此将数据存入内存可能会遇到一些延迟。 将所有文件存储到单个 HDF5 文件中将仅解决问题。 您可以在[这个页面](https://www.h5py.org/),尤其是[上阅读如何使用`h5py`包,这是一个 Python 包,它提供了以 NumPy 数组形式存储和检索数据的接口。 ] http://docs.h5py.org/en/stable/](http://docs.h5py.org/en/stable/) ,其主要文档网站。 您也可以通过发出`conda install h5py``pip install h5py`命令来安装`h5py`
使用 Pandas 包可以使用 HDF5 格式存储列和`DataFrame`数据结构。 您可能会发现它对于存储二进制数据(例如预处理的图像或视频文件)也非常有用。 当您需要从磁盘访问大量文件时,由于文件分散在文件系统中,因此将数据存入内存可能会遇到一些延迟。 将所有文件存储到单个 HDF5 文件中将仅解决问题。 您可以在[这个页面](https://www.h5py.org/),尤其是[上阅读如何使用`h5py`包,这是一个 Python 包,它提供了以 NumPy 数组形式存储和检索数据的接口。 ] http://docs.h5py.org/en/stable/](http://docs.h5py.org/en/stable/) ,其主要文档网站。 您也可以通过发出`conda install h5py``pip install h5py`命令来安装`h5py`
我们将从使用`HDFStore`命令初始化 HDF5 文件`example.h5`开始,该命令允许对数据文件进行低级操作。 实例化文件后,您可以像使用 Python 字典一样开始使用它。 在以下代码段中,将`Iris`数据集存储在字典键`iris`下。 之后,您只需关闭 HDF5 文件:
......@@ -430,7 +430,7 @@ In: fast_iris_upload = storage['iris']
# 将数据放在一起
最后,可以通过合并列或其他类似列表的数据来创建 Pandas `DataFrame`。 请注意,标量将转换为列表,如下所示:
最后,可以通过合并列或其他类似列表的数据来创建 Pandas `DataFrame`。 请注意,标量将转换为列表,如下所示:
```py
In: import pandas as pd
......@@ -463,7 +463,7 @@ In: col5 = pd.Series([4, 3, 2, 1, 0])
ignore_index = True, keys=['Col5', 'Col6']) my_new_dataset = pd.concat([my_own_dataset, a_new_dataset], axis=1) my_new_dataset
```
结果数据集是`col5``col6`列的连接:
结果数据集是`col5``col6`列的连接:
![](img/cf788dcf-3724-4619-9e4e-141bc314f0ef.png)
......@@ -788,19 +788,19 @@ In: dataset.iloc[range(2), [2,1]]
# 处理分类和文本数据
通常,您会发现自己要处理两种主要的数据:分类数据和数值数据。 温度,金额,使用天数或门牌号之类的数字数据可以由浮点数(例如 1.0,-2.3、99.99 等)或整数(例如 -3, 9、0、1,依此类推)。 数据可以假定的每个值与其他值都具有直接关系,因为它们具有可比性。 换句话说,您可以说值为 2.0 的要素要比假定值为 1.0 的要素更大(实际上是两倍)。 这种类型的数据定义非常明确且易于理解,具有等于,大于和小于等二进制运算符。
通常,您会发现自己要处理两种主要的数据:分类数据和数值数据。 温度,金额,使用天数或门牌号之类的数字数据可以由浮点数(例如 1.0,-2.3、99.99 等)或整数(例如 -3, 9、0、1,依此类推)。 数据可以假定的每个值与其他值都具有直接关系,因为它们具有可比性。 换句话说,您可以说值为 2.0 的特征要比假定值为 1.0 的特征更大(实际上是两倍)。 这种类型的数据定义非常明确且易于理解,具有等于,大于和小于等二进制运算符。
您在职业中可能会看到的另一种数据类型是分类数据。 类别基准表示无法测量的属性,并采用一组有限或无限值(通常称为级别)中的值。 例如,天气是一种分类特征,因为它采用离散集`sunny``cloudy``snowy``rainy``foggy`中的值。 其他示例包括包含 URL,IP,设备品牌,您放入电子商务购物车中的项目,设备 ID 等的功能。 在此数据上,您无法定义等于,大于和小于二元运算符,因此无法对它们进行排名。
分类和数值的加号是布尔值。 实际上,它们可以看作是分类的(特征的存在/不存在),或者另一方面,可以认为特征具有展览(已显示,未显示)的概率。 由于许多机器学习算法不允许将输入分类,因此布尔特征通常用于将分类特征编码为数值。
让我们继续以天气为例。 如果要映射包含当前天气并采用集合`[sunny, cloudy, snowy, rainy, foggy]`中的值并将其编码为二进制特征的要素,则应创建五个`True`/`False`函数,每个级别的分类功能。 现在,映射很简单:
让我们继续以天气为例。 如果要映射包含当前天气并采用集合`[sunny, cloudy, snowy, rainy, foggy]`中的值并将其编码为二进制特征的特征,则应创建五个`True`/`False`函数,每个级别的分类功能。 现在,映射很简单:
```py
Categorical_feature = sunny binary_features = [1, 0, 0, 0, 0] Categorical_feature = cloudy binary_features = [0, 1, 0, 0, 0] Categorical_feature = snowy binary_features = [0, 0, 1, 0, 0] Categorical_feature = rainy binary_features = [0, 0, 0, 1, 0] Categorical_feature = foggy binary_features = [0, 0, 0, 0, 1]
```
只有一个二元特征揭示了分类特征的存在。 其他保持`0`。 这称为二进制编码或一种热编码。 通过执行此简单步骤,我们从分类世界转移到了数字世界。 此操作的代价是它在内存和计算方面的复杂性; 现在,我们有五个功能,而不是单个功能。 通常,我们将创建`N`个特征,而不是具有`N`个可能水平的单个分类特征,每个特征都有两个数值(1/0)。 该操作称为伪编码。
只有一个二元特征揭示了分类特征的存在。 其他保持`0`。 这称为二进制编码或热编码。 通过执行此简单步骤,我们从分类世界转移到了数字世界。 此操作的代价是它在内存和计算方面的复杂性; 现在,我们有五个功能,而不是单个功能。 通常,我们将创建`N`个特征,而不是具有`N`个可能水平的单个分类特征,每个特征都有两个数值(1/0)。 该操作称为伪编码。
Pandas 包可帮助我们完成此操作,只需一个命令即可简化映射:
......@@ -917,7 +917,7 @@ In: from sklearn.feature_extraction.text import CountVectorizer
word_count.shape Out: (1187, 25638)
```
首先,我们实例化一个`CountVectorizer`对象。 然后,我们调用该方法对每个文档中的术语进行计数,并为每个文档生成特征向量(`fit_transform`)。 然后,我们查询矩阵大小。 请注意,输出矩阵是稀疏的,因为每个文档只有很少的单词选择是很常见的(因为每行中非零元素的数量非常少,并且存储所有冗余零都没有意义)。 无论如何,输出形状为`(1187, 25638)`。 第一个值是数据集中的观测数量(文档数量),而第二个值是要素数量(数据集中唯一单词的数量)。
首先,我们实例化一个`CountVectorizer`对象。 然后,我们调用该方法对每个文档中的单词进行计数,并为每个文档生成特征向量(`fit_transform`)。 然后,我们查询矩阵大小。 请注意,输出矩阵是稀疏的,因为每个文档只有很少的单词选择是很常见的(因为每行中非零元素的数量非常少,并且存储所有冗余零都没有意义)。 无论如何,输出形状为`(1187, 25638)`。 第一个值是数据集中的观测数量(文档数量),而第二个值是特征数量(数据集中唯一单词的数量)。
`CountVectorizer`转换后,每个文档都与其特征向量相关联。 让我们看一下第一个文档:
......@@ -954,7 +954,7 @@ Out: Word: from appears 2 times
[...]
```
到目前为止,一切都非常简单,不是吗? 让我们前进到另一个增加复杂性和有效性的任务。 数词固然好,但我们可以管理更多; 我们可以计算他们的频率。 您可以跨大小不同的数据集进行比较。 它给出了一个单词是停止词(即一个很常见的词,例如`a``an``the``is`)还是一个稀有的,唯一的单词的想法。 通常,这些术语是最重要的,因为它们能够根据这些单词来表征实例和功能,这在学习过程中是非常有区别的。 要检索每个文档中每个单词的出现频率,请尝试以下代码:
到目前为止,一切都非常简单,不是吗? 让我们前进到另一个增加复杂性和有效性的任务。 数词固然好,但我们可以管理更多; 我们可以计算他们的频率。 您可以跨大小不同的数据集进行比较。 它给出了一个单词是停止词(即一个很常见的词,例如`a``an``the``is`)还是一个稀有的,唯一的单词的想法。 通常,这些单词是最重要的,因为它们能够根据这些单词来表征实例和功能,这在学习过程中是非常有区别的。 要检索每个文档中每个单词的出现频率,请尝试以下代码:
```py
In: from sklearn.feature_extraction.text import TfidfVectorizer
......@@ -977,7 +977,7 @@ In: from sklearn.feature_extraction.text import TfidfVectorizer
频率的总和为 1(或由于近似值而接近 1)。 发生这种情况是因为我们选择了`l1`规范。 在这种特定情况下,单词`frequency`是概率分布函数。 有时,增加稀有词与常见词之间的差异会很好。 在这种情况下,可以使用`l2`范数归一化特征向量。
向量化文本数据的一种更有效的方法是使用`tf-idf`。 简而言之,您可以将构成文档的单词的术语频率乘以单词本身的逆文档频率(即,它出现在文档中的数量或对数缩放转换中)。 这对于突出显示有效描述每个文档的单词非常有用,这些单词是数据集中强大的区分元素:
向量化文本数据的一种更有效的方法是使用`tf-idf`。 简而言之,您可以将构成文档的单词的词频乘以单词本身的逆文档频率(即,它出现在文档中的数量或对数缩放转换中)。 这对于突出显示有效描述每个文档的单词非常有用,这些单词是数据集中强大的区分元素:
```py
In: from sklearn.feature_extraction.text import TfidfVectorizer
......@@ -1926,7 +1926,7 @@ CSR 和 CSC 的性能实际上取决于所使用的算法及其优化参数的
在本章中,我们讨论了 Pandas 和 NumPy 如何为您提供所有工具来加载和有效地修剪数据。
我们从 Pandas 及其数据结构,`DataFrame`列开始,然后进行到最终的 NumPy 二维数组,该数组具有适合于后续实验和机器学习的数据结构。 在此过程中,我们涉及到诸如向量和矩阵的操纵,分类数据编码,文本数据处理,修复丢失的数据和错误,切片和切块,合并和堆叠等主题。
我们从 Pandas 及其数据结构,`DataFrame`列开始,然后进行到最终的 NumPy 二维数组,该数组具有适合于后续实验和机器学习的数据结构。 在此过程中,我们涉及到诸如向量和矩阵的操纵,分类数据编码,文本数据处理,修复丢失的数据和错误,切片和切块,合并和堆叠等主题。
Pandas 和 NumPy 肯定比我们在此介绍的基本构建块以及所示的命令和过程提供更多的功能。 现在,您可以获取任何可用的原始数据,并应用数据科学项目所需的所有清理和整形转换。
......
此差异已折叠。
此差异已折叠。
......@@ -303,7 +303,7 @@ In: plt.imshow(digits.images[0],
# 精选的 Pandas 图形实例
使用适当设置的超参数,许多机器学习算法可以最佳地学习如何根据目标结果映射数据。 但是,通过解决数据中隐藏和细微的问题,可以进一步提高其预测性能。 这不仅仅是检测任何丢失或异常情况的问题。 有时,这取决于数据中是否存在任何组或异常分布(例如,多峰分布)。 明确起草的数据图可以阐明变量之间的关系,并且可以导致创建新的更好的特征,从而以更高的准确性预测目标变量。
使用适当设置的超参数,许多机器学习算法可以最佳地学习如何根据目标结果映射数据。 但是,通过解决数据中隐藏和细微的问题,可以进一步提高其预测表现。 这不仅仅是检测任何丢失或异常情况的问题。 有时,这取决于数据中是否存在任何组或异常分布(例如,多峰分布)。 明确起草的数据图可以阐明变量之间的关系,并且可以导致创建新的更好的特征,从而以更高的准确率预测目标变量。
刚刚描述的实践称为**探索性数据分析****EDA**),并且可以通过以下方式相应地获得有效的结果:
......@@ -352,7 +352,7 @@ In: boxplots = iris_df.boxplot(column='sepal length (cm)',
![](img/a7306609-c7b9-4e87-9546-a8fd60da93dd.png)
通过这种方式,您可以快速知道变量是否是组差异的良好区分。 无论如何,箱形图无法以直方图和密度图的形式为您提供完整的分布图。 例如,通过使用直方图和密度图,您可以确定是否存在分布峰或谷:
通过这种方式,您可以快速知道变量是否是组差异的良好区分。 无论如何,箱形图无法以直方图和密度图的形式为您提供完整的分布图。 例如,通过使用直方图和密度图,您可以确定是否存在分布峰或谷:
```py
In: densityplot = iris_df.plot(kind='density')
......@@ -387,7 +387,7 @@ In: colors_palette = {0: 'red', 1: 'yellow', 2:'blue'}
![](img/68a58c9d-abe2-4497-904d-3c07eb98284d.png)
散点图可以变成六边形合并图。 此外,它们还可以帮助您有效地可视化点密度,这些点自然会更多地聚集在一起,从而揭示隐藏在数据中的。 为了获得这样的结果,可以使用数据集中最初存在的一些变量,或者使用 PCA 或其他降维算法获得的尺寸:
散点图可以变成六边形合并图。 此外,它们还可以帮助您有效地可视化点密度,这些点自然会更多地聚集在一起,从而揭示隐藏在数据中的群集。 为了获得这样的结果,可以使用数据集中最初存在的一些变量,或者使用 PCA 或其他降维算法获得的尺寸:
```py
In: hexbin = iris_df.plot(kind='hexbin', x=0, y=1, gridsize=10)
......@@ -399,7 +399,7 @@ In: hexbin = iris_df.plot(kind='hexbin', x=0, y=1, gridsize=10)
`gridsize`参数指示图表将在一个网格中汇总多少个数据点。 较大的网格将创建大型网格单元,而较小的网格将创建小型网格单元。
散点图是双变量的。 因此,每个变量组合都需要一个图。 如果变量的数量不是很多(否则,可视化将变得混乱),一种快速的解决方案是使用`pandas`命令自动绘制散点图矩阵(使用核密度估计`'kde'`依次在图表的对角线上绘制每个要素的分布):
散点图是双变量的。 因此,每个变量组合都需要一个图。 如果变量的数量不是很多(否则,可视化将变得混乱),一种快速的解决方案是使用`pandas`命令自动绘制散点图矩阵(使用核密度估计`'kde'`依次在图表的对角线上绘制每个特征的分布):
```py
In: from pandas.plotting import scatter_matrix
......@@ -420,9 +420,9 @@ In: from pandas.plotting import scatter_matrix
# 通过平行坐标发现模式
散点图矩阵可以通知您有关要素的联合分布。 它可以帮助您找到数据中的组并验证它们是否可区分。 平行坐标是另一种绘图,有助于为您提供有关数据中存在的最多区分组变量的提示。
散点图矩阵可以通知您有关特征的联合分布。 它可以帮助您找到数据中的组并验证它们是否可区分。 平行坐标是另一种绘图,有助于为您提供有关数据中存在的最多区分组变量的提示。
通过将所有观测值相对于所有可能的变量绘制为平行线(在横坐标上任意对齐),平行坐标将帮助您发现是否有观测流分组为您的类,并了解最能区分这些流的变量( 最有用的预测变量)。 自然地,为了使图表有意义,图中的要素应具有与鸢尾花数据集相同的比例尺(否则将其标准化):
通过将所有观测值相对于所有可能的变量绘制为平行线(在横坐标上任意对齐),平行坐标将帮助您发现是否有观测流分组为您的类,并了解最能区分这些流的变量( 最有用的预测变量)。 自然地,为了使图表有意义,图中的特征应具有与鸢尾花数据集相同的比例尺(否则将其标准化):
```py
In: from pandas.tools.plotting import parallel_coordinates
......@@ -743,18 +743,18 @@ In: with sns.axes_style("whitegrid"):
# 学习曲线
学习曲线是有用的诊断图形,它描述了机器学习算法(您的假设)相对于可用观察量的行为。 这样做的目的是比较使用不同样本内大小的交叉验证(通常为十倍)时训练性能(样本内案例的错误或准确性)如何表现。
学习曲线是有用的诊断图形,它描述了机器学习算法(您的假设)相对于可用观察量的行为。 这样做的目的是比较使用不同样本内大小的交叉验证(通常为十倍)时训练表现(样本内案例的误差或准确率)如何表现。
就训练错误而言,您应该期望它在开始时会很高,然后再减少。 但是,根据假设的偏差和方差级别,您会注意到不同的行为:
就训练误差而言,您应该期望它在开始时会很高,然后再减少。 但是,根据假设的偏差和方差级别,您会注意到不同的行为:
* 高偏差假说倾向于从平均错误性能开始,在暴露于更复杂的数据时迅速降低,然后再保持相同的性能水平,无论您进一步添加多少种情况。
* 低偏的学习器在很多情况下倾向于更好地概括,但是他们近似复杂数据结构的能力有限,因此其性能有限。
* 高方差的假设往往会开始提高错误性能,然后随着您添加更多案例而逐渐降低。 由于它具有记录样本内特性的高容量,因此趋于缓慢降低。
* 高偏差假说倾向于从平均误差表现开始,在暴露于更复杂的数据时迅速降低,然后再保持相同的表现水平,无论您进一步添加多少种情况。
* 低偏的学习器在很多情况下倾向于更好地概括,但是他们近似复杂数据结构的能力有限,因此其表现有限。
* 高方差的假设往往会开始提高误差表现,然后随着您添加更多案例而逐渐降低。 由于它具有记录样本内特性的高容量,因此趋于缓慢降低。
至于交叉验证,我们可以注意到两种行为:
* 高偏见的假设往往始于低表现,但增长很快,直到达到与训练几乎相同的表现。 然后,它停止增长。
* 高方差的假设往往始于非常低的性能。 然后,随着更多案例的推广,它稳步但缓慢地改善了。 它几乎不读取样本中的演奏,并且它们之间始终存在差距。
* 高方差的假设往往始于非常低的表现。 然后,随着更多案例的推广,它稳步但缓慢地改善了。 它几乎不读取样本中的演奏,并且它们之间始终存在差距。
能够估计您的机器学习解决方案表现为高偏差还是高方差假设,将立即帮助您决定如何改善数据科学项目。 尽管有了`learning_curve`类,但 Scikit-learn 使得计算可视化图形所需的所有统计信息更为简单,尽管正确地可视化它们还需要一些进一步的计算和命令:
......@@ -800,7 +800,7 @@ In: import numpy as np
`learning_curve`类需要以下内容作为输入:
* 一系列存储在列表中的训练值
* 指示要使用的折数以及错误度量
* 指示要使用的折数以及误差度量
* 您要测试的机器学习算法(参数估计器)
* 预测变量(参数`X`)和目标结果(参数`y`
......@@ -810,7 +810,7 @@ In: import numpy as np
# 验证曲线
由于学习曲线适用于不同的样本大小,因此验证曲线会根据超参数可以采用的值来估计训练和交叉验证性能。 与在学习曲线中一样,可以应用类似的注意事项,尽管这种特殊的可视化将使您对参数的优化行为有更深入的了解,并在视觉上向您建议应将搜索重点放在超参数空间的一部分:
由于学习曲线适用于不同的样本大小,因此验证曲线会根据超参数可以采用的值来估计训练和交叉验证表现。 与在学习曲线中一样,可以应用类似的注意事项,尽管这种特殊的可视化将使您对参数的优化行为有更深入的了解,并在视觉上向您建议应将搜索重点放在超参数空间的一部分:
```py
In: from sklearn.learning_curve import validation_curve
......@@ -854,7 +854,7 @@ In: from sklearn.learning_curve import validation_curve
正如在第 3 章,“数据管道”的结论中所讨论的那样,选择正确的变量可以通过减少噪声,估计方差和过多计算负担来改善学习过程 。 集成方法(例如,随机森林)可以为您提供与数据集中其他变量一起使用时变量所扮演角色的不同视图。
在这里,我们向您展示如何提取随机森林和极端树模型的重要性。 重要性的计算方式最初由 Breiman,Friedman 等人在《分类和回归树》一书中描述。 1984 年。这是一个真正的经典,为分类树奠定了坚实的基础。 在本书中,重要性用*基尼重要性**平均减少不纯度*来描述,这是由于在整个集成树上平均一个特定变量而导致的节点杂质的总减少量。 换句话说,平均减少不纯度是在该变量上分割的节点的总错误减少乘以路由到每个节点的样本数。 值得注意的是,根据这种重要性计算方法,减少错误不仅取决于误差度量-基尼或熵用于分类,而 MSE 用于回归,而且树顶的拆分也被认为更重要,因为它们涉及处理更多问题。 例子。
在这里,我们向您展示如何提取随机森林和极端树模型的重要性。 重要性的计算方式最初由 Breiman,Friedman 等人在《分类和回归树》一书中描述。 1984 年。这是一个真正的经典,为分类树奠定了坚实的基础。 在本书中,重要性用*基尼重要性**平均减少不纯度*来描述,这是由于在整个集成树上平均一个特定变量而导致的节点杂质的总减少量。 换句话说,平均减少不纯度是在该变量上分割的节点的总误差减少乘以路由到每个节点的样本数。 值得注意的是,根据这种重要性计算方法,减少误差不仅取决于误差度量-基尼或熵用于分类,而 MSE 用于回归,而且树顶的拆分也被认为更重要,因为它们涉及处理更多问题。 例子。
在几个步骤中,我们将学习如何获取此类信息并将其投影到清晰的可视化文件中:
......@@ -889,7 +889,7 @@ In: from sklearn.datasets import load_boston
![](img/f04b4cbf-f992-42af-abd8-435893538ac4.png)
对于每个估计量(在我们的示例中,我们有 100 个模型),该算法估计得分以对每个变量的重要性进行排名。 随机森林模型由决策树组成,决策树可以由许多分支组成,因为该算法试图获得非常小的终叶。 如果在随意排列其原始值之后,排列后的模型的结果预测与原始模型的预测相比在准确方面有很大差异,则认为该变量之一很重要。
对于每个估计量(在我们的示例中,我们有 100 个模型),该算法估计得分以对每个变量的重要性进行排名。 随机森林模型由决策树组成,决策树可以由许多分支组成,因为该算法试图获得非常小的终叶。 如果在随意排列其原始值之后,排列后的模型的结果预测与原始模型的预测相比在准确方面有很大差异,则认为该变量之一很重要。
重要性向量在估计器的数量上平均,并且估计的标准差通过列表理解(重要性和`std`的赋值)进行计算。 现在,根据重要性得分(向量索引)进行排序,结果将投影到带有标准差提供的误差线的条形图上。
......@@ -897,7 +897,7 @@ In: from sklearn.datasets import load_boston
# 梯度提升树的部分依赖图
对功能重要性的估计是一条信息,可以帮助您根据最佳选择来确定要使用的功能。 有时,您可能需要更好地理解为什么变量对预测特定结果很重要。 通过控制分析中涉及的所有其他变量的效果,梯度增强树为您提供了变量与预测结果之间关系的清晰观点。 与使用非常有效的 EDA 可能获得的信息相比,此类信息可以为您提供更多因果关系动态的见解:
对功能重要性的估计是一条信息,可以帮助您根据最佳选择来确定要使用的功能。 有时,您可能需要更好地理解为什么变量对预测特定结果很重要。 通过控制分析中涉及的所有其他变量的效果,梯度提升树为您提供了变量与预测结果之间关系的清晰观点。 与使用非常有效的 EDA 可能获得的信息相比,此类信息可以为您提供更多因果关系动态的见解:
```py
In: from sklearn.ensemble.partial_dependence import
......
......@@ -10,7 +10,7 @@
# 图论概论
基本上,图是一种能够表示对象集合中的关系的数据结构。 在这种范式下,对象是图的节点,关系是图的链接(或边)。 如果链接具有方向(在概念上,它们就像城市的单向街道),则对图形进行定向。 否则,该图是无向的。 下表提供了众所周知的图形的示例:
基本上,图是一种能够表示对象集合中的关系的数据结构。 在这种范式下,对象是图的节点,关系是图的链接(或边)。 如果链接具有方向(在概念上,它们就像城市的单向街道),则图是有向的。 否则,该图是无向的。 下表提供了众所周知的图的示例:
| **图示例** | **类型** | **节点** | **边** |
| --- | --- | --- | --- |
......@@ -31,13 +31,13 @@
Find all people who are friends of my friends, but not my friends
```
2. 在图上将前面的查询与下面的查询进行比较:
2. 在图上将前面的查询与下面的查询进行比较:
```py
Get all friends connected to me having distance=2
```
3. 现在,让我们看看如何使用 Python 创建图形或社交网络。 在本章中将广泛使用的库称为`NetworkX`。 它能够处理中小型图形,并且功能齐全:
3. 现在,让我们看看如何使用 Python 创建图或社交网络。 在本章中将广泛使用的库称为`NetworkX`。 它能够处理中小型图,并且功能齐全:
```py
In: %matplotlib inline
......@@ -54,9 +54,9 @@ In: %matplotlib inline
![](img/f9e925a4-23ad-4203-8d5f-b35e2407fa11.png)
该命令是不言自明的。 检查之前的代码,在包导入之后,我们将首先定义一个(`NetworkX`)图形对象(默认情况下,它是无向的)。 然后,我们将在两个节点之间添加一条边(即一个连接)(由于节点尚未在图中,因此会自动创建它们)。 最后,我们将绘制图形。 库自动生成图形布局(节点的位置)。
该命令是不言自明的。 检查之前的代码,在包导入之后,我们将首先定义一个(`NetworkX`)图对象(默认情况下,它是无向的)。 然后,我们将在两个节点之间添加一条边(即一个连接)(由于节点尚未在图中,因此会自动创建它们)。 最后,我们将绘制图。 库自动生成图布局(节点的位置)。
使用`.add_note()`方法,将其他节点添加到图非常简单。 例如,如果要添加节点`3``4`,则可以简单地使用以下代码:
使用`.add_note()`方法,将其他节点添加到图非常简单。 例如,如果要添加节点`3``4`,则可以简单地使用以下代码:
```py
In: G.add_nodes_from([3, 4])
......@@ -68,7 +68,7 @@ In: %matplotlib inline
![](img/fb90b78c-5230-44a8-9377-c434b5c58f43.png)
前面的代码将添加两个节点。 由于它们未链接到其他节点,因此将断开连接。 同样,要向图添加更多边,可以使用以下代码:
前面的代码将添加两个节点。 由于它们未链接到其他节点,因此将断开连接。 同样,要向图添加更多边,可以使用以下代码:
```py
In: G.add_edge(3,4)
......@@ -86,7 +86,7 @@ In: G.nodes() Out: [1, 2, 3, 4]
In: G.edges() Out: [(1, 2), (1, 4), (2, 3), (3, 4)]
```
有几种表示和描述图的方法。 在以下部分中,我们将说明最受欢迎的。 第一种选择是使用邻接表。 它列出了每个节点的邻居; 即,`list[0]`包含以邻接表格式表示的邻接节点:
有几种表示和描述图的方法。 在以下部分中,我们将说明最受欢迎的。 第一种选择是使用邻接表。 它列出了每个节点的邻居; 即,`list[0]`包含以邻接表格式表示的邻接节点:
```py
In: list(nx.generate_adjlist(G)) Out: ['1 2 4', '2 3', '3 4', '4']
......@@ -94,13 +94,13 @@ In: list(nx.generate_adjlist(G)) Out: ['1 2 4', '2 3', '3 4', '4']
按照这种格式,第一个数字始终是来源,后面的数字始终是目标,[如以下 URL 所示](https://networkx.github.io/documentation/stable/reference/readwrite/adjlist.html)
为了使描述独立,可以将图形表示为列表的字典。 由于其简洁,这是描述图形的最流行(也是实用)方法。 在这里,节点的名称是字典键,其值是节点的邻接表:
为了使描述独立,可以将图表示为列表的字典。 由于其简洁,这是描述图的最流行(也是实用)方法。 在这里,节点的名称是字典键,其值是节点的邻接表:
```py
In: nx.to_dict_of_lists(G) Out: {1: [2, 4], 2: [1, 3], 3: [2, 4], 4: [1, 3]}
```
另一方面,您可以将图描述为边的**集合**。 在输出中,每个元组的第三个元素是边的属性。 实际上,每个边缘都可以具有一个或多个属性(例如其权重,其基数等)。 由于我们创建了一个非常简单的图,因此在以下示例中,我们没有属性:
另一方面,您可以将图描述为边的**集合**。 在输出中,每个元组的第三个元素是边的属性。 实际上,每个边缘都可以具有一个或多个属性(例如其权重,其基数等)。 由于我们创建了一个非常简单的图,因此在以下示例中,我们没有属性:
```py
In: nx.to_edgelist(G) Out: [(1, 2, {}), (1, 4, {}), (2, 3, {}), (3, 4, {})]
......@@ -130,7 +130,7 @@ In: nx.to_numpy_matrix(G) Out: matrix([[ 0., 1., 0., 1.],
![](img/ea88aeb5-d78f-4d2e-bf84-7de068c2287a.png)
当然,如果要加载 NetworkX 图,则可以使用相反的功能(将函数名称中的`from`更改为`to`),并且可以加载 NetworkX 列表,边列表以及 NumPy,SciPy 和`pandas`结构的字典中的图
当然,如果要加载 NetworkX 图,则可以使用相反的功能(将函数名称中的`from`更改为`to`),并且可以加载 NetworkX 列表,边列表以及 NumPy,SciPy 和`pandas`结构的字典中的图。
图中每个节点的重要度量是其度。 在无向图中,节点的度数表示该节点具有的链接数。 对于有向图,度有两种类型:入度和出度。 这些分别计算节点的入站和出站链接。
......@@ -141,11 +141,11 @@ In: G.add_edge(1, 3)
nx.draw_networkx(G) plt.show()
```
的结果图如下:
图的结果图如下:
![](img/f4dfdea6-7d2c-4455-9604-fb47bf03bb0d.png)
本章中的图形可能与在本地计算机上获得的图形有所不同,因为图形布局的初始化是使用随机参数进行的。
本章中的图可能与在本地计算机上获得的图有所不同,因为图布局的初始化是使用随机参数进行的。
节点的度显示如下:
......@@ -166,14 +166,14 @@ In: k = nx.fast_gnp_random_graph(10000, 0.01).degree()
# 图算法
为了从图中获得见解,已经开发了许多算法。 在本章中,我们将在`NetworkX`中使用一个众所周知的图形,即`Krackhardt Kite`图形。 它是一个包含 10 个节点的伪图,通常用于证明图算法。 大卫·克拉克哈特(David Krackhardt)是风筝形状的结构的创造者。 它由两个不同的区域组成。 在第一个区域(由节点 0 到 6 组成)中,节点相互链接; 在另一个区域(节点 7 至 9)中,它们以链状连接:
为了从图中获得见解,已经开发了许多算法。 在本章中,我们将在`NetworkX`中使用一个众所周知的图,即`Krackhardt Kite`。 它是一个包含 10 个节点的伪图,通常用于证明图算法。 大卫·克拉克哈特(David Krackhardt)是风筝形状的结构的创造者。 它由两个不同的区域组成。 在第一个区域(由节点 0 到 6 组成)中,节点相互链接; 在另一个区域(节点 7 至 9)中,它们以链状连接:
```py
In: G = nx.krackhardt_kite_graph()
nx.draw_networkx(G) plt.show()
```
在以下图表中,您可以检查 Krackhardt Kite 的图结构:
在以下图表中,您可以检查 Krackhardt Kite 的图结构:
![](img/8389be0e-413f-479c-bc1e-66f02a3dc210.png)
......@@ -289,7 +289,7 @@ In: nx.harmonic_centrality(G) Out: {0: 6.083333333333333,
节点`3`是具有最高谐波中心度的节点,而`5``6`具有可比较但较低的值。 同样,这些节点位于网络的中心,平均而言,它们可以通过几跳到达所有其他节点。 相反,节点`9`具有最低的谐波中心度; 实际上,它平均距离所有其他节点最远。
* **特征向量中心性**:如果图形是有向的,则节点表示 Web 页面,而边缘表示页面链接。 稍作修改的版本称为 PageRank。 该指标由拉里·佩奇(Larry Page)发明,是 Google,必应(Bing)以及其他搜索引擎的核心排名算法。 从随机冲浪者的角度来看,它可以使每个节点衡量该节点的重要性。 其名称源于以下事实:如果将图形视为马尔可夫链,则图形表示与最大特征值相关的特征向量。 因此,从这个角度来看,这种概率测度表示访问节点概率的静态分布。 让我们看下面的例子:
* **特征向量中心性**:如果图是有向的,则节点表示 Web 页面,而边缘表示页面链接。 稍作修改的版本称为 PageRank。 该指标由拉里·佩奇(Larry Page)发明,是 Google,必应(Bing)以及其他搜索引擎的核心排名算法。 从随机冲浪者的角度来看,它可以使每个节点衡量该节点的重要性。 其名称源于以下事实:如果将图视为马尔可夫链,则图表示与最大特征值相关的特征向量。 因此,从这个角度来看,这种概率测度表示访问节点概率的静态分布。 让我们看下面的例子:
```py
In: nx.eigenvector_centrality(G) Out: {0: 0.35220918419838565,
......@@ -321,11 +321,11 @@ In: nx.clustering(G) Out: {0: 0.6666666666666666,
9: 0.0}
```
在图的高度连接的部分中可以看到较高的值,而在连接最少的区域中可以看到较低的值。
在图的高度连接的部分中可以看到较高的值,而在连接最少的区域中可以看到较低的值。
# 分割网络
现在,让我们看一下将网络划分为节点的多个子网络的方式。 最常用的算法之一是 Louvain 方法,该方法专门用于精确检测大型图形(具有一百万个节点)中的社区。 我们将首先介绍模块化措施。 这是对图形结构的度量(它不是面向节点的),其形式上的数学定义非常长且复杂,并且超出了本书的范围(读者可以在[这个页面](https://sites.google.com/site/findcommunities/))。 它直观地衡量将图划分为社区的质量,将实际的社区联系与随机的联系进行比较。 模块化得分在 -0.5 至 +1.0 之间; 值越高,划分就越好(组内连接密集,而组间连接稀疏)。
现在,让我们看一下将网络划分为节点的多个子网络的方式。 最常用的算法之一是 Louvain 方法,该方法专门用于精确检测大型图(具有一百万个节点)中的社区。 我们将首先介绍模块化措施。 这是对图结构的度量(它不是面向节点的),其形式上的数学定义非常长且复杂,并且超出了本书的范围(读者可以在[这个页面](https://sites.google.com/site/findcommunities/))。 它直观地衡量将图划分为社区的质量,将实际的社区联系与随机的联系进行比较。 模块化得分在 -0.5 至 +1.0 之间; 值越高,划分就越好(组内连接密集,而组间连接稀疏)。
这是一个两步迭代的算法:首先是局部优化,然后是全局优化,然后是局部优化,依此类推:
......@@ -335,7 +335,7 @@ In: nx.clustering(G) Out: {0: 0.6666666666666666,
为了在实际示例中窥视该算法,我们首先需要创建一个更大的图。 让我们考虑一个具有 100 个节点的随机网络:
1. 在此示例中,我们将使用`powerlaw`算法构建图,该算法试图维持近似平均聚类。
1. 在此示例中,我们将使用`powerlaw`算法构建图,该算法试图维持近似平均聚类。
2. 对于添加到图中的每个新节点,还将向其中添加`m`个随机边缘,每个随机边缘都有`p`的概率来创建三角形。
3. 源代码未包含在`NetworkX`中,但在名为`community`的单独模块中。 以下示例显示了该算法的实现:
......@@ -375,9 +375,9 @@ Out: Community 0
最后,该算法返回解决方案的模块化评分:0.79(这是一个很高的评分)。
关于图形的简短介绍将要介绍的最后一个算法是`coloring`。 这是一种为节点分配标签的图形方式,邻居(即具有链接的节点)必须具有不同的标签(或颜色)。 为了解释该算法为何如此重要,我们将使用一个实际示例。 电信网络由遍布地球的不同频率的天线组成。 将每个天线视为一个节点,并将频率视为该节点的标签。 如果天线的距离小于定义的距离(假设距离足够近,会引起干扰),则说明它们与边缘相连。 我们是否可以找到分配的最低频率数(以使公司必须支付的费用降至最低)并避免相邻天线之间的干扰(即通过为链接节点分配不同的频率)?
关于图的简短介绍将要介绍的最后一个算法是`coloring`。 这是一种为节点分配标签的图方式,邻居(即具有链接的节点)必须具有不同的标签(或颜色)。 为了解释该算法为何如此重要,我们将使用一个实际示例。 电信网络由遍布地球的不同频率的天线组成。 将每个天线视为一个节点,并将频率视为该节点的标签。 如果天线的距离小于定义的距离(假设距离足够近,会引起干扰),则说明它们与边缘相连。 我们是否可以找到分配的最低频率数(以使公司必须支付的费用降至最低)并避免相邻天线之间的干扰(即通过为链接节点分配不同的频率)?
该解决方案由图着色算法给出。 从理论上讲,这类算法的解决方案是 NP 难解的,尽管有很多近似方法可以快速获得次优解决方案,但几乎找不到最佳解决方案。 NetworkX 实现贪婪方法来解决着色问题。 该函数返回的是一个字典,其中每个节点(字典中的键)包含颜色(字典中键的值)。 作为示例,让我们在示例图中查看颜色的分配,然后让我们看到颜色:
该解决方案由图着色算法给出。 从理论上讲,这类算法的解决方案是 NP 难解的,尽管有很多近似方法可以快速获得次优解决方案,但几乎找不到最佳解决方案。 NetworkX 实现贪婪方法来解决着色问题。 该函数返回的是一个字典,其中每个节点(字典中的键)包含颜色(字典中键的值)。 作为示例,让我们在示例图中查看颜色的分配,然后让我们看到颜色:
```py
In: G = nx.krackhardt_kite_graph()
......@@ -388,7 +388,7 @@ In: G = nx.krackhardt_kite_graph()
plt.show() Out:{3: 0, 5: 1, 6: 2, 0: 2, 1: 1, 2: 3, 4: 3, 7: 0, 8: 1, 9: 0}
```
这是图形的图,对链接的节点使用了不同的颜色:
这是图的图形,对链接的节点使用了不同的颜色:
![](img/ae8b7126-3774-4c5e-85fd-11651abd10e5.png)
......@@ -396,11 +396,11 @@ In: G = nx.krackhardt_kite_graph()
# 图加载,转储和采样
除了`NetworkX`以外,还可以使用其他软件来生成和分析图和网络。 可用于分析的最佳开源多平台软件之一称为 Gephi。 这是一种视觉工具,不需要编程技能。 可在[这个页面](http://gephi.github.io/)免费获得。
除了`NetworkX`以外,还可以使用其他软件来生成和分析图和网络。 可用于分析的最佳开源多平台软件之一称为 Gephi。 这是一种视觉工具,不需要编程技能。 可在[这个页面](http://gephi.github.io/)免费获得。
与机器学习数据集中一样,甚至图都具有用于存储,加载和交换的标准格式。 这样,您可以使用 NetworkX 创建图,将其转储到文件中,然后使用 Gephi 进行加载和分析。
与机器学习数据集中一样,甚至图都具有用于存储,加载和交换的标准格式。 这样,您可以使用 NetworkX 创建图,将其转储到文件中,然后使用 Gephi 进行加载和分析。
最常用的格式之一是**图形建模语言****GML**)。 现在,让我们看看如何将图形转储到 GML 文件中:
最常用的格式之一是**图建模语言****GML**)。 现在,让我们看看如何将图转储到 GML 文件中:
```py
In: dump_file_base = "dumped_graph"
......
......@@ -4,7 +4,7 @@
* 深度学习的基础
* 如何优化深度网络
* 速度/复杂性/准确问题
* 速度/复杂性/准确问题
* 如何将 CNN 用于图像分类
* 如何将预训练的网络用于分类和迁移学习
* 如何将 LSTM 用于序列操作
......@@ -24,9 +24,9 @@
该网络具有以下特征:
* 它分为三层。 左边的一层称为输入层,右边的一层称为输出层,中间的一层称为隐藏层。 通常,在神经网络中,总是有一个输入层和一个输出层,以及零个或多个隐藏层(当隐藏层为零时,整个神经架构将有效地转化为逻辑回归系统)。
* 输入层由五个单位组成,这意味着每个观察向量由五个数值特征组成(即观察矩阵有五列)。 请注意,要素必须是数字并且在值的有限范围内(为实现更好的数值收敛,理想情况下范围为 0 到 +1,但 -1 到 +1 也可以)。 因此,必须对分类特征进行预处理才能使其成为数值。
* 输入层由五个单元组成,这意味着每个观察向量由五个数值特征组成(即观察矩阵有五列)。 请注意,特征必须是数字并且在值的有限范围内(为实现更好的数值收敛,理想情况下范围为 0 到 +1,但 -1 到 +1 也可以)。 因此,必须对分类特征进行预处理才能使其成为数值。
* 输出层由三个单元组成,这意味着我们要在三个输出类之间进行区分(即执行三类分类)。 在发生回归问题的情况下,这一层应该只有一个单元。
* 隐藏层由八个单元组成。 请注意,对于在深层结构中应显示多少个隐藏层以及每个应具有多少个单元没有任何规则。 这些参数留给科学家使用,通常,它们需要进行一些优化和微调才能发挥最佳性能
* 隐藏层由八个单元组成。 请注意,对于在深层结构中应显示多少个隐藏层以及每个应具有多少个单元没有任何规则。 这些参数留给科学家使用,通常,它们需要进行一些优化和微调才能发挥最佳表现
* 每个连接都有一个与之关联的权重。 在学习算法中对此进行了优化。
输入层的每个单元都连接到下一层的所有单元。 在同一层中的单元之间既没有连接,在彼此之间的距离大于 1 的两个层中的单元之间也没有连接。
......@@ -44,7 +44,7 @@
典型的激活函数是 Sigmoid,双曲正切和`softmax`(用于分类问题)函数,尽管目前最流行的函数是**整流线性单元**(或 **ReLU**),其输出是 0 和输入之间的最大值(其中输入是上一层输出和连接权重之间的点积)。
激活函数(单位数量和隐藏层数量)是深层网络的参数,科学家应该对其进行优化以获得更好的性能
激活函数(单元数量和隐藏层数量)是深层网络的参数,科学家应该对其进行优化以获得更好的表现
训练具有多个层次的神经网络是一项艰巨的操作,因为要调整的参数非常多(有时数百万):权重。 向连接分配权重的最常见方法是使用类似的方法来梯度下降,这种方法称为反向传播,因为它会将误差从输出层传播回输入层,并根据误差的梯度成比例地更新每个权重。 指向网络。 最初,权重是随机分配的,但是经过几步,它们应该收敛到最佳值。
......@@ -69,7 +69,7 @@ J. Stallkamp, M. Schlipsing, J. Salmen, and C. Igel. The German Traffic Sign Rec
下一步是导入 Keras 并检查后端是否配置正确。 在本章中,我们将使用 TensorFlow 后端,并且所有代码都在该后端上进行了测试。
后端选择是可逆的。 如果要从 TensorFlow 切换到另一个后端,[请遵循此处的指南](https://keras.io/backend)。 无论使用哪种后端,使用 Keras 编写的脚本都可以成功运行(尽管在计算时间和最小化错误方面的性能可能有所不同)。
后端选择是可逆的。 如果要从 TensorFlow 切换到另一个后端,[请遵循此处的指南](https://keras.io/backend)。 无论使用哪种后端,使用 Keras 编写的脚本都可以成功运行(尽管在计算时间和最小化错误方面的表现可能有所不同)。
要检查您的后端,请运行以下代码,并检查操作是否成功执行,并且结果输出与此处报告的结果匹配。
......@@ -191,10 +191,10 @@ Out: (29406, 32, 32, 1)
这是创建卷积深度网络的时刻。 我们从一个简单易懂的神经网络开始。 然后,我们将转到更复杂但更准确的地方。
用 Keras 创建深层网络非常容易:您必须依次定义所有层。 Keras 对象需要按名为`Sequential`的序列定义层。 在这里,我们将创建一个包含三层的深层网络:
用 Keras 创建深层网络非常容易:您必须依次定义所有层。 Keras 对象需要按名为`Sequential`的序列定义层。 在这里,我们将创建一个包含三层的深层网络:
1. 输入层定义为卷积 2D 层​​(实际上是图像和内核之间的卷积运算),包含 32 个`3x3`像素形状的滤镜,并带有 ReLU 类型的激活层。
2. 平滑前一个输出的图层; 也就是说,将展开方形观察以创建一维数组。
1. 输入层定义为卷积 2D 层​​(实际上是图像和内核之间的卷积运算),包含 32 个`3x3`像素形状的过滤器,并带有 ReLU 类型的激活层。
2. 平滑前一个输出层; 也就是说,将展开方形观察以创建一维数组。
3. 激活`softmax`的密集输出层,由 43 个单元组成,每个单元一个。
然后编译模型,最后将其拟合到训练数据。 在此操作期间,我们选择了以下内容:
......@@ -247,7 +247,7 @@ Out: Train on 29406 samples, validate on 9803 samples
loss: 0.0617 - acc: 0.9897 - val_loss: 0.2208 - val_acc: 0.9574
```
训练集的最终准确接近 99%,而测试集则接近 96%。 我们有点过拟合,但让我们在测试集中查看该模型的混淆矩阵和分类报告。 我们还将打印混淆矩阵的`log2`,以更好地识别错误分类。
训练集的最终准确接近 99%,而测试集则接近 96%。 我们有点过拟合,但让我们在测试集中查看该模型的混淆矩阵和分类报告。 我们还将打印混淆矩阵的`log2`,以更好地识别错误分类。
为此,我们首先需要预测标签,然后应用`argmax`运算符选择最可能的类别:
......@@ -285,7 +285,7 @@ Out:
avg / total 0.96 0.96 0.96 9803
```
以下是诊断图,可为您提供有关模型性能的证据:
以下是诊断图,可为您提供有关模型表现的证据:
![](img/2cd34df1-f804-46cc-ab57-0078a2ef64ae.png)
......@@ -297,19 +297,19 @@ Out:
* **丢弃层**:这等效于正则化,并且可以防止过拟合。 基本上,在训练的每个步骤中,都会停用一部分单元,因此该层的输出不会过分依赖其中的一些单元。
* **批量规范化层**:通过减去批次平均值并将其除以标准差,此 z 标准化层。 这对于更新数据很有用,并且在每个步骤都会放大/衰减信号。
* **最大池化**:这是一个非线性变换,用于通过对内核下的每个区域应用最大滤波器来对输入进行下采样。 用于选择最大功能,该功能在同一类中的位置可能略有不同。
* **最大池化**:这是一个非线性变换,用于通过对内核下的每个区域应用最大过滤器来对输入进行下采样。 用于选择最大功能,该功能在同一类中的位置可能略有不同。
除此之外,总是有改变深层网络和训练属性的空间。 也就是说,优化程序(及其参数),批量大小和期数。 在下一个单元格中,这里是具有以下几层的改进的深层网络:
除此之外,总是有改变深层网络和训练属性的空间。 也就是说,优化程序(及其参数),批量大小和期数。 在下一个单元格中,这里是具有以下几层的改进的深层网络:
1. 卷积层,具有 32 个`3x3`滤镜和 ReLU 激活
1. 卷积层,具有 32 个`3x3`过滤器和 ReLU 激活
2. `BatchNormalization`
3. 另一个卷积层,然后是`BatchNormalization`
4. 丢弃层,被丢弃的可能性为 0.4
5. 展开层
6. 512 单密集层,具有 ReLU 激活
6. 512 单密集层,具有 ReLU 激活
7. `BatchNormalization`
8. 丢弃层,被丢弃的可能性为 0.5
9. 输出层; 如上例所示,这是一个具有 43 个单`softmax`密集层
9. 输出层; 如上例所示,这是一个具有 43 个单`softmax`密集层
那将如何在我们的数据集上执行?
......@@ -362,7 +362,7 @@ Out: Train on 29406 samples, validate on 9803 samples
<keras.callbacks.History at 0x7fd7ac0f17b8>
```
训练集的准确性与测试集的准确性相似,均为约 99%; 也就是说,每 100 张图像中有 99 张用正确的标签分类! 该网络更长,需要更多的内存和计算能力,但不太容易过拟合并且性能更好。
训练集的准确率与测试集的准确率相似,均为约 99%; 也就是说,每 100 张图像中有 99 张用正确的标签分类! 该网络更长,需要更多的内存和计算能力,但不太容易过拟合并且表现更好。
现在,让我们看一下分类报告和混淆矩阵(完整版本和`log2`版本):
......@@ -398,7 +398,7 @@ Out:
* 简化网络; 也就是说,通过删除参数和变量
* 使用预训练的网络,该网络已经由功能足够强大的人进行过训练
在这两种情况下,我们都将在次优条件下工作,因为深度网络不会像我们曾经使用的那样强大。 更具体地说,在第一种情况下,网络的精度不是很高,因为我们的参数较少。 在第二种情况下,我们必须应对其他人的决策和培训。 尽管这不是一件容易的事,但预训练的模型也可以根据您的数据集进行微调。 在这种情况下,网络将不会随机初始化参数。 尽管这很有趣,但是此操作不在本书的讨论范围之内。
在这两种情况下,我们都将在次优条件下工作,因为深度网络不会像我们曾经使用的那样强大。 更具体地说,在第一种情况下,网络的精度不是很高,因为我们的参数较少。 在第二种情况下,我们必须应对其他人的决策和训练。 尽管这不是一件容易的事,但预训练的模型也可以根据您的数据集进行微调。 在这种情况下,网络将不会随机初始化参数。 尽管这很有趣,但是此操作不在本书的讨论范围之内。
在本节中,我们将快速展示如何使用预训练的模型,这是一种常见的处理方法。 请记住,预训练模型可以在多种情况下使用:
......@@ -491,7 +491,7 @@ Out: Predicted: [('n02704792', 'amphibian', 0.20315942),
实际上,可以通过所谓的**迁移学习技术**来训练预训练的模型甚至识别全新的类别。 这项技术不在本书的讨论范围之内,[但是您可以从 Keras 的博客中的示例中了解它](https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html)
最后,让我们看看如何从中间层提取要素,如下所示:
最后,让我们看看如何从中间层提取特征,如下所示:
1. 第一步,让我们验证标签名称:
......@@ -529,7 +529,7 @@ Out: (1, 2048)
[[0.12340261 0.0833823 0.7935947 ... 0.50869745 0.34015656]]
```
如您所见,`avg_pool`层包含`2048`位,该函数的输出正好是 2,048D 数组。 现在,您可以将此数组连接到您选择的任何其他要素数组。
如您所见,`avg_pool`层包含`2048`元,该函数的输出正好是 2,048D 数组。 现在,您可以将此数组连接到您选择的任何其他特征数组。
# 处理时间序列
......@@ -590,9 +590,9 @@ In: print(X_train[0])
这里提出的模型分为三层:
1. 嵌入层。 原始词典设置为 25,000 个单词,组成嵌入的单位数(即图层的输出)为 256。
1. 嵌入层。 原始词典设置为 25,000 个单词,组成嵌入的单元数(即层的输出)为 256。
2. LSTM 层。 **LSTM** 代表**长短期记忆**,它是最强大的序列深度模型之一。 得益于其深厚的架构,它能够从序列中相距较远的单词中提取信息(因此得名)。 在此示例中,像元数设置为`256`(作为上一层输出尺寸),其中`0.4`的缺失用于正则化。
3. 具有 Sigmoid 活化的密集层。 这就是我们需要的二进制分类器。
3. 具有 Sigmoid 活化的密集层。 这就是我们需要的二分类器。
这是执行此操作的代码:
......@@ -629,7 +629,7 @@ In: from keras.models import Sequential
loss:0.0377 - acc:0.9878 - val_loss:0.8090 - val_acc:0.8230
```
这就是 25K 审查测试数据集的准确。 这是可以接受的结果,因为我们通过这样一个简单的模型实现了 80% 以上的正确分类。 如果您想对其进行改进,可以尝试使架构更复杂,但是请始终记住,通过增加网络的复杂性,训练和预测结果所需的时间,以及内存占用量会增加。
这就是 25K 审查测试数据集的准确。 这是可以接受的结果,因为我们通过这样一个简单的模型实现了 80% 以上的正确分类。 如果您想对其进行改进,可以尝试使架构更复杂,但是请始终记住,通过增加网络的复杂性,训练和预测结果所需的时间,以及内存占用量会增加。
# 总结
......
......@@ -25,7 +25,7 @@
除了这些标准,最近几年还出现了许多其他 V,它们试图解释大数据的其他特征。 其中一些如下:
* **准确率**:提供数据中包含的异常,偏差和噪声的指示; 最终表明其准确
* **准确率**:提供数据中包含的异常,偏差和噪声的指示; 最终表明其准确
* **波动率**:指示可以将数据用于提取有意义的信息的时间
* **有效率**:数据的正确性
* **价值**:根据数据指示投资回报率
......@@ -103,7 +103,7 @@ HDFS 的架构是主从结构。 如果主服务器(称为**名称节点**)
**Apache Spark** 是 Hadoop 的演进,并在最近几年变得非常流行。 与 Hadoop 及其以 Java 和批量为重点的设计相比,Spark 能够以快速简便的方式生成迭代算法。 此外,它具有用于多种编程语言的非常丰富的 API 套件,并且本身支持许多不同类型的数据处理(机器学习,流传输,图形分析,SQL 等)。
Apache Spark 是一个集群框架,旨在用于大数据的快速通用处理。 速度的提高之一来自以下事实:与 Hadoop,MapReduce 和 HDFS 一样,每项工作之后的数据都保留在内存中,而不是存储在文件系统中(除非您愿意这样做)。 由于内存提供的延迟和带宽比物理磁盘更具性能,因此这种事情使迭代作业(例如群集 K 均值算法)越来越快。 因此,运行 Spark 的集群需要为每个节点配备大量 RAM。
Apache Spark 是一个集群框架,旨在用于大数据的快速通用处理。 速度的提高之一来自以下事实:与 Hadoop,MapReduce 和 HDFS 一样,每项工作之后的数据都保留在内存中,而不是存储在文件系统中(除非您愿意这样做)。 由于内存提供的延迟和带宽比物理磁盘更具表现,因此这种事情使迭代作业(例如群集 K 均值算法)越来越快。 因此,运行 Spark 的集群需要为每个节点配备大量 RAM。
尽管 Spark 是在 Scala(类似于 Java 一样在 JVM 上运行)中开发的,但它具有适用于多种编程语言的 API,包括 Java,Scala,Python 和 R。在本书中,我们将重点介绍 Python。
......@@ -526,9 +526,9 @@ Out: In the file there are 13053 lines
尽管广播和累加器变量很简单,并且变量非常有限(一个变量是只读变量,另一个变量是只写变量),但是可以将它们有效地用于创建非常复杂的操作。 例如,让我们尝试在分布式环境中的`iris`数据集上应用不同的机器学习算法。 我们将通过以下方式构建 Spark 作业:
* 读取数据集并将其广播到所有节点(因为它足够小以适合内存)。
* 每个节点将在数据集上使用不同的分类器,并在整个数据集上返回分类器名称及其准确得分。 请注意,在此简单示例中,为了使事情变得简单,我们将不进行任何预处理,训练/测试拆分或超参数优化。
* 每个节点将在数据集上使用不同的分类器,并在整个数据集上返回分类器名称及其准确得分。 请注意,在此简单示例中,为了使事情变得简单,我们将不进行任何预处理,训练/测试拆分或超参数优化。
* 如果分类器引发异常,则错误的字符串表示形式以及分类器名称应存储在累加器中。
* 最终输出应包含执行分类任务且没有错误的分类器列表及其准确得分。
* 最终输出应包含执行分类任务且没有错误的分类器列表及其准确得分。
第一步,我们加载`iris`数据集并将其广播到集群中的所有节点:
......@@ -556,7 +556,7 @@ In: from pyspark import AccumulatorParam
errAccum = sc.accumulator([], ErrorAccumulator())
```
现在,让我们定义映射功能:每个节点都应在广播`iris`数据集上训练,测试和评估分类器。 作为参数,该函数将接收分类器对象,并应返回一个元组,该元组包含分类器名称及其准确分数(包含在列表中)。
现在,让我们定义映射功能:每个节点都应在广播`iris`数据集上训练,测试和评估分类器。 作为参数,该函数将接收分类器对象,并应返回一个元组,该元组包含分类器名称及其准确分数(包含在列表中)。
如果这样做引发异常,则将分类器名称和以字符串引用的异常添加到累加器中,并返回一个空列表:
......@@ -1047,7 +1047,7 @@ Out: root
由于我们将使用基于树的分类器,因此我们希望将每个级别的文本编码为每个变量的数字。 使用 Scikit-learn,可以使用`sklearn.preprocessing.LabelEncoder`对象完成此操作。 在 Spark 中等效的是`pyspark.ml.feature`包的`StringIndexer`
我们需要用 Spark 编码四个变量,然后我们必须将四个`StringIndexer`对象以级联的方式链接在一起:它们每个都将在`DataFrame`的特定列上操作,并输出一个带有附加列的`DataFrame`(类似`map`操作)。 映射是自动的,按频率排序:Spark 在所选列中对每个级别的计数进行排名,将最流行的级别映射到`0`,然后映射到`1`,依此类推。 请注意,通过此操作,您将遍历数据集一次以计算每个级别的出现次数。 如果您已经知道该映射,则广播该映射并使用`map`操作会更有效,如本章开头所示。
更笼统地说,`pyspark.ml.feature`包中包含的所有类都用于从`DataFrame`中提取,转换和选择要素。 他们所有人都在`DataFrame`中读取一些列并创建其他列。
更笼统地说,`pyspark.ml.feature`包中包含的所有类都用于从`DataFrame`中提取,转换和选择特征。 他们所有人都在`DataFrame`中读取一些列并创建其他列。
类似地,我们可以使用单热编码器生成数值观察矩阵。 对于单编码器,在`DataFrame`中将有多个输出列,每个分类特征的每个级别对应一个输出列。 为此,Spark 提供了`pyspark.ml.feature.OneHotEncoderEstimator`类。
......@@ -1055,7 +1055,7 @@ Out: root
回到该示例,我们现在想将每个分类变量中的级别编码为离散数字。 正如我们所解释的,为此,我们将为每个变量使用`StringIndexer`对象。 此外,我们可以使用 ML 管道并将其设置为其阶段。
然后,要适合所有索引器,只需调用管道的`fit`方法。 在内部,它将顺序地适合所有暂存的对象。 完成拟合操作后,将创建一个新对象,我们可以将其称为拟合管道。 调用此新对象的`transform`方法将顺序调用所有已登台的元素(已装配),每个元素都在上一个元素完成后被调用。 在以下代码片段中,您将看到运行中的管道。 请注意,变压器组成了管道。 因此,由于不存在任何动作,因此实际上不执行任何操作。 在输出`DataFrame`中,您会注意到另外四列,它们的名称与原始分类的列相同,但后缀为`_cat`
然后,要适合所有索引器,只需调用管道的`fit`方法。 在内部,它将顺序地适合所有暂存的对象。 完成拟合操作后,将创建一个新对象,我们可以将其称为拟合管道。 调用此新对象的`transform`方法将顺序调用所有已登台的元素(已装配),每个元素都在上一个元素完成后被调用。 在以下代码片段中,您将看到运行中的管道。 请注意,转换器组成了管道。 因此,由于不存在任何动作,因此实际上不执行任何操作。 在输出`DataFrame`中,您会注意到另外四列,它们的名称与原始分类的列相同,但后缀为`_cat`
```py
In: from pyspark.ml import Pipeline
......@@ -1092,7 +1092,7 @@ Out: [StringIndexer_44f6bd05e502a8ace0aa,
```
`DataFrame`中提取某些列就像在 SQL 查询中使用`SELECT`一样容易。 现在,让我们为所有数字功能建立一个名称列表。 从标题中找到的名称开始,我们删除分类名称,并将其替换为
数字衍生的名称。 最后,由于只需要要素,因此删除了目标变量及其从数值上导出的等效项:
数字衍生的名称。 最后,由于只需要特征,因此删除了目标变量及其从数值上导出的等效项:
```py
In: features_header = set(header) \
......@@ -1139,7 +1139,7 @@ In: from pyspark.ml.feature import VectorAssembler
.select("features", "target_cat"))
```
同样,`VectorAssembler`的默认行为是生成`DenseVectors``SparseVectors`。 在这种情况下,由于要素的向量包含许多零,因此它将返回稀疏向量。 要查看输出内容,我们可以打印第一行。 请注意,这是一个动作。 因此,将在打印结果之前执行作业:
同样,`VectorAssembler`的默认行为是生成`DenseVectors``SparseVectors`。 在这种情况下,由于特征的向量包含许多零,因此它将返回稀疏向量。 要查看输出内容,我们可以打印第一行。 请注意,这是一个动作。 因此,将在打印结果之前执行作业:
```py
In: Xy_train.first()
......@@ -1199,7 +1199,7 @@ Out: First observation after classification stage:
# 评估学习器的表现
任何数据科学任务的下一步都是检查学习器在训练和测试数据集上的表现。 对于此任务,我们将使用`F1-score`,因为它是合并精度和召回性能的好指标。 评估指标包含在`pyspark.ml.evaluation`包中; 在我们拥有的几种选择中,我们正在使用一种来评估多类分类器:`MulticlassClassificationEvaluator`。 作为参数,我们提供指标(`precision``recall``accuracy``F1-score`等)以及包含真实标签和预测标签的列的名称:
任何数据科学任务的下一步都是检查学习器在训练和测试数据集上的表现。 对于此任务,我们将使用`F1-score`,因为它是合并精度和召回表现的好指标。 评估指标包含在`pyspark.ml.evaluation`包中; 在我们拥有的几种选择中,我们正在使用一种来评估多类分类器:`MulticlassClassificationEvaluator`。 作为参数,我们提供指标(`precision``recall``accuracy``F1-score`等)以及包含真实标签和预测标签的列的名称:
```py
In: from pyspark.ml.evaluation import MulticlassClassificationEvaluator
......@@ -1216,7 +1216,7 @@ Out: F1-score train set: 0.993
F1-score test set: 0.968
```
所获得的值非常高,并且训练数据集和测试数据集的性能之间存在很大差异。 除了用于多类分类器的评估器之外,用于回归器(度量标准可以是 MSE,RMSE,R2 或 MAE)和二进制分类器的评估器对象在同一包中可用。
所获得的值非常高,并且训练数据集和测试数据集的表现之间存在很大差异。 除了用于多类分类器的评估器之外,用于回归器(度量标准可以是 MSE,RMSE,R2 或 MAE)和二分类器的评估器对象在同一包中可用。
# 机器学习管道的力量
......@@ -1292,7 +1292,7 @@ Out: {'neptune': 107201,
'phf': 4}
```
这清楚地表明了严重的不平衡。 我们可以尝试通过对稀有类进行过度采样和对太受欢迎的类进行二次采样来提高性能。 在此示例中,我们将创建一个训练数据集,其中每个类别至少代表 1,000 次,但最多代表 25,000 次。 为此,我们执行以下步骤:
这清楚地表明了严重的不平衡。 我们可以尝试通过对稀有类进行过度采样和对太受欢迎的类进行二次采样来提高表现。 在此示例中,我们将创建一个训练数据集,其中每个类别至少代表 1,000 次,但最多代表 25,000 次。 为此,我们执行以下步骤:
1. 让我们首先创建子采样/过采样率,并将其在整个集群中广播,然后`flatMap`训练数据集的每一行对其进行正确的重新采样:
......@@ -1387,7 +1387,7 @@ In: full_model = full_pipeline.fit(sampled_train_df)
Out: F1-score test set: 0.967
```
5.`50`树的分类器上进行测试。 为此,我们可以构建另一个管道(名为`refined_pipeline`),并用新的分类器代替最后一个阶段。 即使训练数据集的大小已减少,性能似乎也相同:
5.`50`树的分类器上进行测试。 为此,我们可以构建另一个管道(名为`refined_pipeline`),并用新的分类器代替最后一个阶段。 即使训练数据集的大小已减少,表现似乎也相同:
```py
In: clf = RandomForestClassifier(
......@@ -1410,7 +1410,7 @@ Out: F1-score test set: 0.968
在尝试了许多不同的配置之后,我们可以继续进行手动优化并找到合适的模型。 这样做会导致时间的大量浪费(以及代码的可重用性),并使测试数据集过拟合。 交叉验证是运行超参数优化的正确关键。 现在让我们看看 Spark 如何执行这项关键任务。
首先,由于培训将被多次使用,因此我们可以`cache`。 因此,让我们在所有转换后使用`cache`
首先,由于训练将被多次使用,因此我们可以`cache`。 因此,让我们在所有转换后使用`cache`
```py
In: pipeline_to_clf = Pipeline(
......@@ -1419,11 +1419,11 @@ In: pipeline_to_clf = Pipeline(
test = pipeline_to_clf.transform(test_df)
```
`pyspark.ml.tuning`包中包含使用交叉验证进行超参数优化的有用类。 两个要素是必不可少的:参数的网格图(可以使用`ParamGridBuilder`构建)和实际的交叉验证过程(由`CrossValidator`类运行)。
`pyspark.ml.tuning`包中包含使用交叉验证进行超参数优化的有用类。 两个特征是必不可少的:参数的网格图(可以使用`ParamGridBuilder`构建)和实际的交叉验证过程(由`CrossValidator`类运行)。
在此示例中,我们要设置分类器的一些参数,这些参数在整个交叉验证过程中都不会改变。 就像 Scikit-learn 一样,它们是在创建`classification`对象时设置的(在这种情况下,是列名,种子和最大数量的容器)。
然后,借助网格生成器,我们决定应为交叉验证算法的每次迭代更改哪些参数。 在此示例中,我们要检查分类性能是否将森林中每棵树的最大深度从`3`更改为`12`(增加 3),并将森林中的树数从 20 或 50 改变为最后。 设置网格图,我们要测试的分类器和折叠次数后,启动交叉验证(使用`fit`方法)。 参数评估器是必不可少的:它会告诉我们哪种是交叉验证后保持的最佳模型。 请注意,此操作可能需要 15-20 分钟才能运行(在引擎盖下,训练并测试了`4 * 2 * 3 = 24`模型):
然后,借助网格生成器,我们决定应为交叉验证算法的每次迭代更改哪些参数。 在此示例中,我们要检查分类表现是否将森林中每棵树的最大深度从`3`更改为`12`(增加 3),并将森林中的树数从 20 或 50 改变为最后。 设置网格图,我们要测试的分类器和折叠次数后,启动交叉验证(使用`fit`方法)。 参数评估器是必不可少的:它会告诉我们哪种是交叉验证后保持的最佳模型。 请注意,此操作可能需要 15-20 分钟才能运行(在引擎盖下,训练并测试了`4 * 2 * 3 = 24`模型):
```py
In: from pyspark.ml.tuning import ParamGridBuilder, CrossValidator
......@@ -1441,7 +1441,7 @@ In: from pyspark.ml.tuning import ParamGridBuilder, CrossValidator
cvModel = cv.fit(train)
```
最后,我们可以使用交叉验证的模型来预测标签,因为我们本身就是在使用管道或分类器。 在这种情况下,通过交叉验证选择的分类器的性能要比前一种情况稍好,这使我们能够克服`0.97`障碍:
最后,我们可以使用交叉验证的模型来预测标签,因为我们本身就是在使用管道或分类器。 在这种情况下,通过交叉验证选择的分类器的表现要比前一种情况稍好,这使我们能够克服`0.97`障碍:
```py
In: predictions = cvModel.transform(test)
......@@ -1480,7 +1480,7 @@ In: bc_sample_rates.unpersist()
在本章中,我们向您介绍了 Hadoop 生态系统,包括架构,HDFS 和 PySpark。 介绍之后,我们开始设置本地 Spark 实例,并在群集节点之间共享变量后,我们使用 RDD 和`DataFrame`在 Spark 中进行了数据处理。
在本章的稍后部分,我们学习了使用 Spark 进行机器学习的知识,其中包括读取数据集,培训学习器,机器学习管道的功能,交叉验证,甚至测试通过示例数据集获得的知识。
在本章的稍后部分,我们学习了使用 Spark 进行机器学习的知识,其中包括读取数据集,训练学习器,机器学习管道的功能,交叉验证,甚至测试通过示例数据集获得的知识。
到此结束我们围绕 Python 进行数据科学基础研究的旅程,下一章只是刷新和增强 Python 基础的附录。 总之,通过本书的所有章节,我们已经完成了数据科学项目的介绍,接触了项目的所有关键步骤,并向您展示了使用 Python 成功操作自己的项目的所有基本工具。 作为学习工具,这本书陪同您完成了数据科学的所有阶段,从数据加载到机器学习和可视化,阐述了无论数据大小的最佳实践和避免常见陷阱的方法。 作为参考,本书涉及各种命令和包,为您提供了简单明了的说明和示例,如果在项目中重复使用这些示例和示例,则可以在工作期间节省大量时间。
......
......@@ -58,7 +58,7 @@
直到我看到 IBM Watson Question Answering 系统的演示,它在 2011 年在 *Jeopardy* 游戏中击败了长期冠军 Brad Rutter 和 Ken Jennings。哇! 这是一个突破性的技术,它是一种能够回答自然语言问题的计算机程序。 我很感兴趣,在进行了一些研究之后,与参与该项目的一些研究人员会面,并了解了用于构建该系统的技术,例如 NLP,机器学习和通用数据科学,我意识到了如果将技术应用于业务的其他部分,这种技术有多少潜力。
几个月后,我有机会加入 IBM 新组建的 Watson 部门,领导一个工具团队,其任务是为 Watson 系统建立数据提取和准确分析功能。 我们最重要的要求之一就是确保我们的客户易于使用这些工具,这就是为什么回想起来,将这一责任赋予开发人员团队是正确的做法。 从我的角度来看,从事这项工作既充满挑战,又富有。 我离开了一个熟悉的世界,在那里我擅长基于众所周知的模式设计架构并实现前端,中间件或后端软件组件,而这个世界主要专注于处理大量数据; 获取,清理,分析,可视化并构建模型。 我花了前六个月的时间从消防水龙头喝酒,阅读和学习有关 NLP,机器学习,信息检索和统计数据科学的知识,至少足以使用我正在构建的功能。
几个月后,我有机会加入 IBM 新组建的 Watson 部门,领导一个工具团队,其任务是为 Watson 系统建立数据提取和准确分析功能。 我们最重要的要求之一就是确保我们的客户易于使用这些工具,这就是为什么回想起来,将这一责任赋予开发人员团队是正确的做法。 从我的角度来看,从事这项工作既充满挑战,又富有。 我离开了一个熟悉的世界,在那里我擅长基于众所周知的模式设计架构并实现前端,中间件或后端软件组件,而这个世界主要专注于处理大量数据; 获取,清理,分析,可视化并构建模型。 我花了前六个月的时间从消防水龙头喝酒,阅读和学习有关 NLP,机器学习,信息检索和统计数据科学的知识,至少足以使用我正在构建的功能。
那时,我与研究团队进行了互动,将这些算法推向市场,我意识到开发人员和数据科学家需要更好地协作的重要性。 的传统方法是让数据科学家孤立地解决复杂的数据问题,然后将结果“扔给开发人员”,让开发人员对其进行操作是不可持续的,并且无法扩展,考虑到要处理的数据量保持指数级增长,所需的上市时间不断缩小。
......@@ -82,7 +82,7 @@
* 最佳实践框架和语言
* 部署和操作分析的最佳实践架构
指导我们选择的指标很多:准确,可伸缩性,代码可重用性,但最重要的是,改善了数据科学家与开发人员之间的协作。
指导我们选择的指标很多:准确,可伸缩性,代码可重用性,但最重要的是,改善了数据科学家与开发人员之间的协作。
# 深入探讨具体示例
......@@ -140,7 +140,7 @@
4. **测试**:此活动应真正包含在的每个步骤中,但是在这里,我们谈论的是根据现场使用情况创建反馈回路:
* 创建衡量模型的准确的指标
* 创建衡量模型的准确的指标
* 优化模型,例如,获取更多数据,查找新功能等等
# 成为数据科学家需要什么样的技能?
......
......@@ -77,7 +77,7 @@ GitHub 上的 Jupyter 笔记本的搜索结果
请务必注意,PixieDust `display()` API 主要支持两种流行的数据处理框架:
* [**pandas**](https://pandas.pydata.org):迄今为止,最流行的 Python 数据分析包,Pandas 提供了两种主要数据结构:用于处理两个- 一维列状数据集和列。
* [**pandas**](https://pandas.pydata.org):迄今为止,最流行的 Python 数据分析包,Pandas 提供了两种主要数据结构:用于处理两个- 一维列状数据集和列。
### 注意
......
......@@ -860,7 +860,7 @@ class SimpleDisplayWithRenderer(BaseChartDisplay):
<div>Hello World</div>
```
细胞魔力必须位于细胞顶部; 任何其他位置都将导致执行错误。 单元魔术下方的所有内容均作为参数传递给处理器,以根据单元魔术规范进行解释。 例如,HTML 单元魔术师希望单元格内容的其余部分为 HTML。
单元魔术必须位于单元顶部; 任何其他位置都将导致执行错误。 单元魔术下方的所有内容均作为参数传递给处理器,以根据单元魔术规范进行解释。 例如,HTML 单元魔术师希望单元格内容的其余部分为 HTML。
下面的代码示例调用一个引发`ZeroDivisionError`异常的函数,并激活了`pdb`自动调用:
......@@ -1114,7 +1114,7 @@ app.run()
![Troubleshooting issues using PixieDust logging](img/00102.jpeg)
查询带有特定术语的日志
查询带有特定项目的日志
这样就完成了我们关于服务器端调试的讨论。 在下一节中,我们将介绍执行客户端调试的技术
......
......@@ -69,13 +69,13 @@
### 注意
**注意**:上式中的偏差表示偏差神经元的权重,它是添加到 x 值为 +1 的每一层的额外神经元。 偏向神经元是特殊的,因为它有助于下一层的输入,但它没有连接到上一层。 但是,通常仍然像其他神经元一样学习其重量。 偏向神经元背后的直觉是,它在线性回归方程中提供了常数项 b:
**注意**:上式中的偏差表示偏差神经元的权重,它是添加到 x 值为 +1 的每一层的额外神经元。 偏向神经元是特殊的,因为它有助于下一层的输入,但它没有连接到上一层。 但是,通常仍然像其他神经元一样学习其权重。 偏向神经元背后的直觉是,它在线性回归方程中提供了常数项 b:
![What is deep learning?](img/00116.jpeg)
当然,在`A`上应用神经元激活函数`g(x)`不能简单地产生二进制(0 或 1)值,因为如果存在多个类的得分为 1,我们将无法正确地排列最终候选答案。相反,我们使用激活函数,该函数提供介于 0 和 1 之间的非离散得分,并设置阈值(例如 0.5)来决定是否激活神经元。
乙状结肠功能是最受欢迎的激活函数之一:
Sigmoid 功能是最受欢迎的激活函数之一:
![What is deep learning?](img/00118.jpeg)
......@@ -85,11 +85,11 @@
使用 Sigmoid 函数计算神经元输出
其他流行的激活函数包括双曲正切`tanh(x)`**整流线性单****ReLu**):`max(x, 0)`。 ReLu 在有很多层时效果更好,因为可以激发*神经元的稀疏性*,从而降低噪音并加快学习速度。
其他流行的激活函数包括双曲正切`tanh(x)`**整流线性单****ReLu**):`max(x, 0)`。 ReLu 在有很多层时效果更好,因为可以激发*神经元的稀疏性*,从而降低噪音并加快学习速度。
在模型评分期间使用前馈传播,但是在训练神经网络的权重矩阵时,使用的一种流行方法称为[**反向传播**](https://en.wikipedia.org/wiki/Backpropagation)
以下高级步骤描述了培训的工作方式:
以下高级步骤描述了训练的工作方式:
1. 随机初始化权重矩阵(最好使用较小的值,例如`-ε, ε`)。
2. 使用所有训练示例上所述的前向传播,使用您选择的激活函数来计算每个神经元的输出。
......@@ -130,7 +130,7 @@ TensorFlow 高级 API 架构
| 1 | 0 | 1 |
| 1 | 1 | 0 |
有趣的是,[线性分类器](https://en.wikipedia.org/wiki/Linear_classifier)无法学习 XOR 转换。 但是,我们可以通过一个简单的神经网络来解决此问题,该神经网络的输入层中包含两个神经元,一个隐藏层中包含两个神经元,而输出层中包含一个神经元(二进制分类),如下所示:
有趣的是,[线性分类器](https://en.wikipedia.org/wiki/Linear_classifier)无法学习 XOR 转换。 但是,我们可以通过一个简单的神经网络来解决此问题,该神经网络的输入层中包含两个神经元,一个隐藏层中包含两个神经元,而输出层中包含一个神经元(二分类),如下所示:
![Getting started with TensorFlow](img/00124.jpeg)
......@@ -217,7 +217,7 @@ with tf.Session() as sess:
### 注意
**注意**:分类输出本质上有两种类型:分类输出和连续输出。 在分类器模型中,只能从具有或不具有逻辑顺序的有限预定义值列表中选择输出。 我们通常将二进制分类称为只有两个类的分类模型。 另一方面,连续输出可以具有任何数值。
**注意**:分类输出本质上有两种类型:分类输出和连续输出。 在分类器模型中,只能从具有或不具有逻辑顺序的有限预定义值列表中选择输出。 我们通常将二分类称为只有两个类的分类模型。 另一方面,连续输出可以具有任何数值。
首先要求用户选择一个数值列进行预测,然后对`DataFrame`中存在的所有其他数值列进行分类模型训练。
......@@ -255,7 +255,7 @@ display(crimes)
犯罪数据集的表格视图
看起来就像`nonviolent`是二进制分类的良好候选者。 现在让我们调出一个条形图,以确保我们在此列中具有良好的数据分布:
看起来就像`nonviolent`是二分类的良好候选者。 现在让我们调出一个条形图,以确保我们在此列中具有良好的数据分布:
![Simple classification with DNNClassifier](img/00129.jpeg)
......@@ -314,7 +314,7 @@ def do_training(train, train_labels, test, test_labels, num_classes):
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode2.py)
`classifier.train`方法使用`train_input_fn`方法,该方法负责提供训练输入数据(又称地面实况)作为小批量,返回`tf.data.Dataset``(features, labels)`的元组。 我们的代码也正在使用`classifier.evaluate`执行模型评估,以通过根据测试数据集对模型评分并在给定标签中比较结果来验证准确。 然后将结果作为函数输出的一部分返回。
`classifier.train`方法使用`train_input_fn`方法,该方法负责提供训练输入数据(又称地面实况)作为小批量,返回`tf.data.Dataset``(features, labels)`的元组。 我们的代码也正在使用`classifier.evaluate`执行模型评估,以通过根据测试数据集对模型评分并在给定标签中比较结果来验证准确。 然后将结果作为函数输出的一部分返回。
此方法需要与`train_input_fn`相似的`eval_input_fn`方法,除了我们在评估期间不使数据集可重复。 由于这两种方法共享大多数相同的代码,因此我们使用一种称为`input_fn`的辅助方法,这两种方法都使用适当的标志来调用该方法:
......@@ -507,7 +507,7 @@ self.train_x, self.train_y, self.test_x, self.test_y, self.num_classes
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode6.py)
以下屏幕快照显示了成功创建模型后的结果,并包括分类模型的评估指标表,其准确为 87%:
以下屏幕快照显示了成功创建模型后的结果,并包括分类模型的评估指标表,其准确为 87%:
![Simple classification with DNNClassifier](img/00133.jpeg)
......@@ -820,7 +820,7 @@ for url in image_urls:
[**注意**:您可以下载完整的笔记本,以按照此处的讨论进行操作](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/Tensorflow%20VR%20Part%202.ipynb)
提醒一下,PixieApp 的`setup`方法(如果已定义)是在应用开始运行之前执行的。 我们使用选择模型并初始化图
提醒一下,PixieApp 的`setup`方法(如果已定义)是在应用开始运行之前执行的。 我们使用选择模型并初始化图:
```py
from pixiedust.display.app import *
......@@ -952,9 +952,9 @@ def do_score_url(self, score_url):
[提醒一下,您可以在以下位置找到完整的笔记本](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/Tensorflow%20VR%20Part%202.ipynb)
我们的 MVP 应用即将完成。 在下一节中,我们将在笔记本中直接集成 TensorBoard 图可视化。
我们的 MVP 应用即将完成。 在下一节中,我们将在笔记本中直接集成 TensorBoard 图可视化。
## 第 3 部分——集成 TensorBoard 图可视化
## 第 3 部分——集成 TensorBoard 图可视化
### 注意
......@@ -1005,7 +1005,7 @@ app.run()
使用`TemplateTabbedApp`超类的另一个好处是,分别定义了子 PixieApps,这使代码更易于维护和重用。
首先让我们看一下`TensorGraphApp` PixieApp。 它的主要路由返回一个 HTML 片段,该片段将`tf-graph-basic.build.html``https://tensorboard.appspot.com,`加载到 IFrame 中,并使用 JavaScript 加载监听器应用通过`tf.Graph.as_graph_def`方法计算的序列化图定义。 为确保图定义保持合理的大小,并避免浏览器客户端上不必要的性能下降,我们调用`strip_consts`方法来移除具有大尺寸的恒定值的张量。
首先让我们看一下`TensorGraphApp` PixieApp。 它的主要路由返回一个 HTML 片段,该片段将`tf-graph-basic.build.html``https://tensorboard.appspot.com,`加载到 IFrame 中,并使用 JavaScript 加载监听器应用通过`tf.Graph.as_graph_def`方法计算的序列化图定义。 为确保图定义保持合理的大小,并避免浏览器客户端上不必要的性能下降,我们调用`strip_consts`方法来移除具有大尺寸的恒定值的张量。
`TensorGraphApp`的代码如下所示:
......@@ -1118,7 +1118,7 @@ class LabelsApp():
[**注意**:本节中的代码改编自《将 TensorFlow 用于作诗》教程](https://github.com/googlecodelabs/tensorflow-for-poets-2/blob/master/scripts/retrain.py)
在大多数情况下,获得高质量的培训数据可能是最艰巨且耗时的任务之一。 在我们的示例中,我们要训练的每个类都需要大量的图像。 为了简单和可重复性,我们使用 ImageNet 数据库方便地提供用于获取 URL 和相关标签的 API。 我们还将下载的文件限制为`.jpg`文件。 当然,如有需要,随时获取您自己的培训数据。
在大多数情况下,获得高质量的训练数据可能是最艰巨且耗时的任务之一。 在我们的示例中,我们要训练的每个类都需要大量的图像。 为了简单和可重复性,我们使用 ImageNet 数据库方便地提供用于获取 URL 和相关标签的 API。 我们还将下载的文件限制为`.jpg`文件。 当然,如有需要,随时获取您自己的训练数据。
我们首先下载了 2011 年秋季版本中所有图像 URL 的列表,[可在此处下载](http://image-net.org/imagenet_data/urls/imagenet_fall11_urls.tgz),然后将文件解压缩到您选择的本地目录(例如,我选择`/Users/dtaieb/Downloads/fall11_urls.txt`)。我们还需要下载[上所有`synsets`的 WordNet ID 和单词之间的映射,网址为 http://image-net.org/archive/ words.txt](http://image-net.org/archive/words.txt) ,我们将使用它来查找包含我们需要下载的 URL 的 WordNet ID。
......@@ -1263,7 +1263,7 @@ with open(os.path.join(image_dir, "retrained_label.txt"), "w") as f_label:
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode27.py)。
3. 在公共名称空间下,使用`add_final_training_ops`方法添加最终的训练操作,以便在可视化图时更易于操作。 训练步骤如下:
3. 在公共名称空间下,使用`add_final_training_ops`方法添加最终的训练操作,以便在可视化图时更易于操作。 训练步骤如下:
1. 使用`tf.truncated_normal` API 生成随机权重:
......@@ -1309,7 +1309,7 @@ with open(os.path.join(image_dir, "retrained_label.txt"), "w") as f_label:
train_step = optimizer.minimize(cross_entropy_mean)
```
为了可视化重新训练的图,我们首先需要更新`TensorGraphApp` PixieApp,以让用户选择要可视化的模型:通用 MobileNet 或自定义。 这是通过在主路径中添加`<select>`下拉菜单并附加`pd_script`元素来更新状态来完成的:
为了可视化重新训练的图,我们首先需要更新`TensorGraphApp` PixieApp,以让用户选择要可视化的模型:通用 MobileNet 或自定义。 这是通过在主路径中添加`<select>`下拉菜单并附加`pd_script`元素来更新状态来完成的:
```py
[[TensorGraphApp]]
......@@ -1339,7 +1339,7 @@ self.graph = self.custom_graph if self.graph is not self.custom_graph else self.
可视化再训练图
单击火车节点将显示运行反向传播算法的嵌套操作,以最小化前面的`add_final_training_ops`中指定的`cross_entropy_mean`成本函数:
单击训练节点将显示运行反向传播算法的嵌套操作,以最小化前面的`add_final_training_ops`中指定的`cross_entropy_mean`成本函数:
```py
with tf.name_scope('cross_entropy'):
......@@ -1406,7 +1406,7 @@ self.current_labels = self.custom_labels if self.current_labels is not self.cust
![Part 4 – Retrain the model with custom training data](img/00143.jpeg)
显示每个型号的标签信息
显示每个模型的标签信息
我们的第 4 部分 MVP 的最后一步是更新`score_image`方法,以使用两个模型对图像进行分类,并将结果添加到带有每个模型条目的字典中。 我们定义了一个本地方法`do_score_image`,该方法返回前 5 个候选答案。
......@@ -1482,7 +1482,7 @@ def do_score_url(self, score_url):
![Part 4 – Retrain the model with custom training data](img/00144.jpeg)
使用通用 MobileNet 和定制培训模型进行评分
使用通用 MobileNet 和定制训练模型进行评分
读者会注意到,定制模型的分数非常低。 一种可能的解释是,训练数据采集是完全自动化的,无需人工管理即可使用。 此示例应用的一项可能增强是将训练数据获取和再训练步骤移至其自己的标签 PixieApp 中。 我们还应该给用户机会验证图像​​并拒绝质量低劣的图像。 让用户重新标记被错误分类的图像也将是很棒的。
......@@ -1490,11 +1490,11 @@ def do_score_url(self, score_url):
[完整的第四部分笔记本可以在以下位置找到](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/Tensorflow%20VR%20Part%204.ipynb)
在本节中,我们讨论了使用 TensorFlow 在 Jupyter 笔记本中构建图像识别示例应用的增量方法,特别着重于使用 PixieApps 操作算法。 我们首先使用 TensorFlow `DNNClassifier`器从 Pandas `DataFrame`构建简单的分类模型。 然后我们分四个部分构建了图像识别示例应用的 MVP 版本:
在本节中,我们讨论了使用 TensorFlow 在 Jupyter 笔记本中构建图像识别示例应用的增量方法,特别着重于使用 PixieApps 操作算法。 我们首先使用 TensorFlow `DNNClassifier`器从 Pandas `DataFrame`构建简单的分类模型。 然后我们分四个部分构建了图像识别示例应用的 MVP 版本:
1. 我们加载了预训练的 MobileNet 模型
2. 我们为图像识别示例应用创建了一个 PixieApp
3. 我们将 TensorBoard 图可视化集成到 PixieApp 中
3. 我们将 TensorBoard 图可视化集成到 PixieApp 中
4. 我们使用户能够使用来自 ImageNet 的自定义训练数据来重新训练模型
# 总结
......
......@@ -37,7 +37,7 @@ Spark 高级架构
* **Spark SQL**:此组件的核心数据结构是 Spark `DataFrame`,它使了解 SQL 语言的用户可以轻松处理结构化数据。
* **Spark Streaming**:模块用于处理流数据。 稍后我们将看到,我们将在示例应用中使用此模块,尤其是使用结构化流(在 Spark 2.0 中引入)。
* **MLlib**:模块,提供了功能丰富的机器学习库,可在 Spark 规模上工作。
* **GraphX**:模块用于执行图并行计算。
* **GraphX**:模块用于执行图并行计算。
主要有两种使用 Spark 集群的方法,如下图所示:
......@@ -668,7 +668,7 @@ display(parquet_batch_df)
在这一部分中,我们使用情感信息来丰富 Twitter 数据,例如*正*,*负*和*中性*。 我们还希望从推文中提取最相关的实体,例如运动,组织和位置。 这些额外的信息将通过实时仪表板进行分析和可视化,我们将在下一部分中构建。 用于从非结构化文本中提取情感和实体的算法属于计算机科学和人工智能领域,称为**自然语言处理**(**NLP**)。 网络上有很多教程,其中提供了有关如何提取情感的算法示例。 例如,可以在[这个页面](https://github.com/scikit-learn/scikit-learn/blob/master/doc/tutorial/text_analytics/working_with_text_data.rst)。
但是,对于此示例应用,我们将不会构建自己的 NLP 算法。 相反,我们将选择一种基于云的服务,该服务提供文本分析,例如情感和实体提取。 当您有通用要求(例如不需要培训定制模型)时,这种方法非常有效,但是即使那样,大多数服务提供商现在都提供了实现此目的的工具。 与创建您自己的模型相比,使用基于云的供应商具有主要优势,例如节省了开发时间以及更好的准确性和性能。 通过一个简单的 REST 调用,我们将能够生成所需的数据并将其集成到我们的应用流中。 而且,如果需要,更改提供者将非常容易,因为负责与服务接口的代码已被很好地隔离了。
但是,对于此示例应用,我们将不会构建自己的 NLP 算法。 相反,我们将选择一种基于云的服务,该服务提供文本分析,例如情感和实体提取。 当您有通用要求(例如不需要训练定制模型)时,这种方法非常有效,但是即使那样,大多数服务提供商现在都提供了实现此目的的工具。 与创建您自己的模型相比,使用基于云的供应商具有主要优势,例如节省了开发时间以及更好的准确率和性能。 通过一个简单的 REST 调用,我们将能够生成所需的数据并将其集成到我们的应用流中。 而且,如果需要,更改提供者将非常容易,因为负责与服务接口的代码已被很好地隔离了。
对于此示例应用,我们将使用 **IBM Watson 自然语言理解**(**NLU**)服务,该服务是 IBM Watson 认知服务家族的一部分,可在 IBM Cloud 上使用。
......
......@@ -8,7 +8,7 @@
本章首先介绍 NumPy 库及其最重要的 API,这些 API 将在构建描述性分析以分析表示股票历史财务数据的时间序列时得到很好的利用。 使用[`statsmodels`](https://www.statsmodels.org/stable/index.html)之类的 Python 库,我们将展示如何进行统计探索并查找平稳性,**自相关函数****ACF**)和**部分自相关函数****PACF**)。 有助于发现数据趋势和创建预测模型。 然后,我们将通过构建一个 PixieApp 来对这些分析进行操作,该 PixieApp 可以总结有关股票历史财务数据的所有重要统计信息和可视化效果。
在第二部分中,我们将尝试建立一个预测股票未来趋势的时间序列预测模型。 我们将使用称为 **ARIMA** 的集成移动平均的自回归模型,其中我们使用时间序列中的先前值来预测下一个值。 ARIMA 是当前使用最流行的模型之一,尽管基于递归神经网络的新模型开始流行起来。
在第二部分中,我们将尝试建立一个预测股票未来趋势的时间序列预测模型。 我们将使用称为 **ARIMA** 的集成移动平均的自回归模型,其中我们使用时间序列中的先前值来预测下一个值。 ARIMA 是当前使用最流行的模型之一,尽管基于循环神经网络的新模型开始流行起来。
与往常一样,我们将通过在`StockExplorer` PixieApp 中合并 ARIMA 时间序列预测模型的构建来结束本章。
......@@ -642,7 +642,7 @@ display(investment)
在尝试生成预测模型之前,必须了解时间序列是否具有可识别的模式,例如季节性或趋势。 一种流行的技术是根据指定的时滞来查看数据点与先前的数据点之间的关系。 直觉是自相关将揭示内部结构,例如,确定发生高相关(正或负)时的时间段。 您可以尝试不同的滞后值(即,对于每个数据点,要考虑多少个先前的点),以找到正确的周期。
计算 ACF 通常需要为[数据点集](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient)计算 Pearson R 相关系数。 好消息是`statsmodels` Python 库具有`tsa`包(**时间序列分析**),该包提供了辅助方法来计算 ACF, 与 Pandas 列紧密集成。
计算 ACF 通常需要为[数据点集](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient)计算 Pearson R 相关系数。 好消息是`statsmodels` Python 库具有`tsa`包(**时间序列分析**),该包提供了辅助方法来计算 ACF, 与 Pandas 列紧密集成。
### 注意
......@@ -669,7 +669,7 @@ plt.show()
上图显示了`x`横坐标给出的多个先前数据点(滞后)处数据的自相关。 因此,在滞后`0`处,您始终具有`1.0`的自相关(您始终与自己完美相关),滞后`1`显示与先前数据点的自相关,滞后`2`显示与落后两个步骤的数据点的自相关。 我们可以清楚地看到,随着滞后的增加,自相关减小。 在上一张图表中,我们仅使用了 100 个滞后,并且我们看到自相关仍然在 0.9 左右具有统计显着性,这告诉我们长时间分隔的数据是不相关的。 这表明数据具有趋势,当浏览整体价格图表时,这一趋势非常明显。
为了确认这个假设,我们用更大的`lags`参数绘制 ACF 图表,例如`1000`(鉴于我们的列有 10,000 个以上的数据点这一事实,这是不合理的),如以下屏幕快照所示:
为了确认这个假设,我们用更大的`lags`参数绘制 ACF 图表,例如`1000`(鉴于我们的列有 10,000 个以上的数据点这一事实,这是不合理的),如以下屏幕快照所示:
![Autocorrelation function (ACF) and partial autocorrelation function (PACF)](img/00177.jpeg)
......@@ -1053,7 +1053,7 @@ $("[id^=slider][id$={{prefix}}]").each(function() {
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%208/sampleCode19.py)
`MovingAverageSubApp`中,我们使用`add_ticker_selection_markup`装饰器并将`chart{{prefix}}`作为默认路由的参数,以添加股票选择器选项卡,并添加一个名为`lag_slider``<div>`元素,其中包含`<pd_event_handler>`设置`self.lag`变量并刷新`chart` DIV。 `chart` DIV 将`pd_entity`属性与调用`rolling`方法的[`get_moving_average_df()`方法](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.rolling.html)一起使用,从选定的 Pandas `DataFrame`返回滚动均值,并在其上调用`mean()`方法。 由于 PixieDust `display()`尚不支持 Pandas 系列,因此我们将系列索引用作名为`x`的列来构建 Pandas `DataFrame`,并以`get_moving_average_df()`方法返回它。
`MovingAverageSubApp`中,我们使用`add_ticker_selection_markup`装饰器并将`chart{{prefix}}`作为默认路由的参数,以添加股票选择器选项卡,并添加一个名为`lag_slider``<div>`元素,其中包含`<pd_event_handler>`设置`self.lag`变量并刷新`chart` DIV。 `chart` DIV 将`pd_entity`属性与调用`rolling`方法的[`get_moving_average_df()`方法](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.rolling.html)一起使用,从选定的 Pandas `DataFrame`返回滚动均值,并在其上调用`mean()`方法。 由于 PixieDust `display()`尚不支持 Pandas 序列,因此我们将序列索引用作名为`x`的列来构建 Pandas `DataFrame`,并以`get_moving_average_df()`方法返回它。
以下代码显示了`MovingAverageSubApp`子 PixieApp 的实现
......@@ -1177,7 +1177,7 @@ class AutoCorrelationSubApp(BaseSubApp):
# 使用 ARIMA 模型的时间序列预测
ARIMA 是最受欢迎的时间系列预测模型之一,顾名思义,它由三个术语组成:
ARIMA 是最受欢迎的时间序列预测模型之一,顾名思义,它由三个项组成:
* **AR**: 代表**自回归**,无非就是使用一种线性回归算法,该算法使用一个观测值和自己的滞后观测值作为训练数据。
......@@ -1199,7 +1199,7 @@ ARIMA 是最受欢迎的时间系列预测模型之一,顾名思义,它由
![Time series forecasting using the ARIMA model](img/00189.jpeg)
* `I`: 代表**集成**。 为了使 ARIMA 模型正常工作,假设时间序列是固定的或可以使其固定。 [如果其均值和方差不随时间变化,据说一个列是固定的](https://en.wikipedia.org/wiki/Stationary_process)
* `I`: 代表**集成**。 为了使 ARIMA 模型正常工作,假设时间序列是固定的或可以使其固定。 [如果其均值和方差不随时间变化,据说一个列是固定的](https://en.wikipedia.org/wiki/Stationary_process)
### 注意
......@@ -1215,7 +1215,7 @@ ARIMA 是最受欢迎的时间系列预测模型之一,顾名思义,它由
![Time series forecasting using the ARIMA model](img/00192.jpeg)
列实际变为固定时间之前,可能需要多次对数差分转换。 我们称`d`为使用对数差分对序列进行变换的次数。
列实际变为固定时间之前,可能需要多次对数差分转换。 我们称`d`为使用对数差分对序列进行变换的次数。
例如:
......@@ -1262,7 +1262,7 @@ ARIMA 是最受欢迎的时间系列预测模型之一,顾名思义,它由
![Build an ARIMA model for the MSFT stock time series](img/00197.jpeg)
MSFT 股票列图
MSFT 股票列图
在开始建立模型之前,让我们首先保留数据的最后 14 天以进行测试,然后将其余部分用于训练。
......@@ -1278,7 +1278,7 @@ train_set, test_set = msft[:-14], msft[-14:]
从上图可以清楚地看到从 2012 年开始的增长趋势,但没有明显的季节性。 因此,我们可以放心地假设没有平稳性。 让我们首先尝试一次应用对数差分转换,并绘制相应的 ACF 和 PACF 图表。
在以下代码中,我们通过在`Adj. Close`列上使用`np.log()`来构建`logmsft`Pandas 列,然后使用`logmsft`与 1 的滞后时间之间的差值来构建`logmsft_diff` pandas `DataFrame``shift()`方法)。 像以前做过一样,我们也调用`reset_index()``Date`索引转换为一列,以便 PixieDust `display()`可以处理它:
在以下代码中,我们通过在`Adj. Close`列上使用`np.log()`来构建`logmsft`Pandas 列,然后使用`logmsft`与 1 的滞后时间之间的差值来构建`logmsft_diff` pandas `DataFrame``shift()`方法)。 像以前做过一样,我们也调用`reset_index()``Date`索引转换为一列,以便 PixieDust `display()`可以处理它:
```py
logmsft = np.log(train_set['Adj. Close'])
......@@ -1296,7 +1296,7 @@ display(logmsft_diff)
![Build an ARIMA model for the MSFT stock time series](img/00198.jpeg)
应用对数差异后的 MSFT 股票
应用对数差异后的 MSFT 股票
通过查看前面的图,我们可以合理地认为我们已经成功地使时间序列固定为 0。 我们还可以使用更严格的方法通过使用 [Dickey-Fuller 测试](https://en.wikipedia.org/wiki/Dickey%E2%80%93Fuller_test),它测试`AR(1)`模型中存在单位根的原假设。
......@@ -1408,7 +1408,7 @@ with warnings.catch_warnings():
**注意**:我们使用`warnings`包来避免在使用较旧版本的 NumPy 和 Pandas 时可能发生的弃用警告。
在前面的代码中,我们将`train_set['Adj. Close']`用作`ARIMA`构造器的参数。 由于我们对数据使用序列,因此我们还需要为`dates`参数传递`train_set['Date']`列。 请注意,如果我们通过带有`DateIndex`索引的 Pandas `DataFrame`来传递,则不必使用`dates`参数。 `ARIMA`构造器的最后一个参数是`order`参数,它是表示`p``d``q`阶数的三个值的元组, 如本节开头所讨论的。
在前面的代码中,我们将`train_set['Adj. Close']`用作`ARIMA`构造器的参数。 由于我们对数据使用序列,因此我们还需要为`dates`参数传递`train_set['Date']`列。 请注意,如果我们通过带有`DateIndex`索引的 Pandas `DataFrame`来传递,则不必使用`dates`参数。 `ARIMA`构造器的最后一个参数是`order`参数,它是表示`p``d``q`阶数的三个值的元组, 如本节开头所讨论的。
然后,我们调用`fit()`方法,该方法返回将用于预测值的实际 ARIMA 模型。 出于信息目的,我们使用`arima_model.resid.describe()`打印有关模型剩余误差的统计信息。
......@@ -1754,7 +1754,7 @@ def show_pacf_screen(self):
应用差异的第一个预测屏幕
下一步是实现由**继续预测**按钮调用的`do_forecast`路由。 这条路由负责建立 ARIMA 模型; 首先显示一个配置页面,其中包含三个输入文本,这些文本可让用户输入`p``d``q`阶数,通过查看数据浏览屏幕中的图表。 我们添加一个`Go`按钮以使用`build_arima_model`路由进行模型构建,我们将在本节稍后讨论。 标头上还有一个`Diagnose Model`按钮,该按钮调用另一个负责评估模型准确的页面。
下一步是实现由**继续预测**按钮调用的`do_forecast`路由。 这条路由负责建立 ARIMA 模型; 首先显示一个配置页面,其中包含三个输入文本,这些文本可让用户输入`p``d``q`阶数,通过查看数据浏览屏幕中的图表。 我们添加一个`Go`按钮以使用`build_arima_model`路由进行模型构建,我们将在本节稍后讨论。 标头上还有一个`Diagnose Model`按钮,该按钮调用另一个负责评估模型准确的页面。
此处显示了`do_forecast`路由的实现。 请注意,当用户选择其他股票行情自动收录器时,我们将`add_ticker_selection_markup`与空数组一起使用以刷新整个页面:
......@@ -1930,6 +1930,6 @@ def build_arima_model_screen(self, p_order, d_order, q_order):
# 总结
在本章中,我们谈到了时间序列分析和预测的主题。 当然,我们只是从头开始,当然还有很多需要探索的地方。 通过非常积极的研究,它也是该行业的一个非常重要的领域,尤其是在金融领域。 例如,我们看到越来越多的数据科学家试图基于[递归神经网络](https://en.wikipedia.org/wiki/Recurrent_neural_network)算法建立时间序列预测模型,并取得了巨大的成功。 我们还演示了 Jupyter 笔记本与 PixieDust 和`pandas``numpy``statsmodels,`之类的库生态系统相结合如何帮助加速分析的开发,以及将其操作化投入业务用户线可使用的应用。
在本章中,我们谈到了时间序列分析和预测的主题。 当然,我们只是从头开始,当然还有很多需要探索的地方。 通过非常积极的研究,它也是该行业的一个非常重要的领域,尤其是在金融领域。 例如,我们看到越来越多的数据科学家试图基于[循环神经网络](https://en.wikipedia.org/wiki/Recurrent_neural_network)算法建立时间序列预测模型,并取得了巨大的成功。 我们还演示了 Jupyter 笔记本与 PixieDust 和`pandas``numpy``statsmodels,`之类的库生态系统相结合如何帮助加速分析的开发,以及将其操作化投入业务用户线可使用的应用。
在下一章中,我们将研究另一个重要的数据科学用例:图形。 我们将构建一个与飞行旅行相关的示例应用,并讨论如何以及何时应用图算法来解决数据问题。
\ No newline at end of file
此差异已折叠。
......@@ -16,7 +16,7 @@ Drew 的数据科学 Conway Venn 图现在包括开发人员
# 前瞻性思维——对 AI 和数据科学的期望
这是我非常喜欢的部分,因为我无需表达准确就可以表达前瞻性意见,因为根据定义,这些只是我的观点😊。
这是我非常喜欢的部分,因为我无需表达准确就可以表达前瞻性意见,因为根据定义,这些只是我的观点😊。
正如我在第 1 章,"开发人员对数据科学的观点"中所解释的那样,我相信 AI 和数据科学将继续存在,它们将继续对现有行业造成破坏。 在可预见的未来,最有可能以加速的速度发展。 这肯定会影响工作的总数,并且类似于我们过去看到的其他技术革命(农业,工业,信息等),有些将消失,而新的将被创造。
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册