2021-03-12 18:10:36

new/begin-ds-py-jupyter/1.md

@@ -309,7 +309,7 @@ scikit_learn==0.19.0
 
 1.  打开`lesson 1` Jupyter 笔记本，然后滚动到`Subtopic D: Python Libraries`部分。
 
-    就像常规 Python 脚本一样，可以随时将库导入到笔记本中。 最佳做法是将您使用的大多数软件包放在文件顶部。 有时在笔记本中途加载东西是有意义的，这完全可以。
+    就像常规 Python 脚本一样，可以随时将库导入到笔记本中。 最佳做法是将您使用的大多数包放在文件顶部。 有时在笔记本中途加载东西是有意义的，这完全可以。
 
 2.  运行单元来导入外部库并设置绘图选项：
 
@@ -887,13 +887,13 @@ scikit_learn==0.19.0
 
     ![Create categorical fieldscreatingcategorical fields from continuous variables and make segmented visualizations](img/image1_143.jpg)
 
-    查看结果，可以看出两个班级的人数相当相等，而“非常老”的一班人大约大 40%。 我们有兴趣保持类的大小可比，以使每个类都有很好的表示，并且可以直接从分析中进行推断。
+    查看结果，可以看出两个类别的人数相当相等，而“非常老”的一类人大约大 40%。 我们有兴趣保持类的大小可比，以使每个类都有很好的表示，并且可以直接从分析中进行推断。
 
     ### 注意
 
     并非总是可以将样本均匀地分配给类，在现实世界中，找到高度不平衡的类是很常见的。 在这种情况下，请务必牢记，对于人数不足的类别很难做出具有统计意义的声明。 类不平衡的预测分析可能特别困难。 [以下博客文章提供了有关在进行机器学习时处理不平衡类的方法的出色总结](https://svds.com/learning-imbalanced-classes/)。
 
-    让我们看看通过新功能`AGE_category`进行细分时目标变量的分布情况。
+    让我们看看通过新函数`AGE_category`进行细分时目标变量的分布情况。
 
 5.  通过运行以下代码制作提琴图：
 

new/begin-ds-py-jupyter/2.md

@@ -91,11 +91,11 @@
 
 ### 探索数据预处理工具和方法
 
-1.  通过执行`jupyter notebook`从项目目录启动`NotebookApp`。 导航到`Lesson-2`目录并打开`lesson-2-workbook.ipynb`文件。 找到顶部附近的程序包加载单元，然后运行它。
+1.  通过执行`jupyter notebook`从项目目录启动`NotebookApp`。 导航到`Lesson-2`目录并打开`lesson-2-workbook.ipynb`文件。 找到顶部附近的包加载单元，然后运行它。
 
     我们将从展示 Pandas 和 Scikit-learn 的一些基本工具开始。 然后，我们将更深入地研究重建缺失数据的方法。
 
-2.  向下滚动至`Subtopic B: Preparing data for machine learning`，然后运行包含`pd.merge?`的单元格，以在笔记本中显示`merge`功能的文档字符串：
+2.  向下滚动至`Subtopic B: Preparing data for machine learning`，然后运行包含`pd.merge?`的单元格，以在笔记本中显示`merge`函数的文档字符串：
 
     ![Explore data preprocessing tools and methods](img/image2_02.jpg)
 
@@ -619,7 +619,7 @@ K 最近邻分类算法可存储训练数据并根据特征空间中的 K 个最
     >> accuracy = 75.9%
     ```
 
-    我们预测测试样本的目标，然后使用 Scikit-learn 的`accuracy_score`函数确定准确性。 结果看起来很有希望，达到约 75%！ 对于我们的第一个模型来说还不错。 但是请记住，目标是不平衡的。 让我们看看每个班级的预测有多准确。
+    我们预测测试样本的目标，然后使用 Scikit-learn 的`accuracy_score`函数确定准确性。 结果看起来很有希望，达到约 75%！ 对于我们的第一个模型来说还不错。 但是请记住，目标是不平衡的。 让我们看看每个类别的预测有多准确。
 
 8.  计算混淆矩阵，然后通过运行包含以下代码的单元格来确定每个类别中的准确性：
 
@@ -825,7 +825,7 @@ K 折交叉验证算法如下：
 
     训练数据应该已经在笔记本的内存中，但是让我们重新加载它以提醒我们正在使用什么。
 
-2.  加载数据并为训练/验证集选择`satisfaction_level`和`last_evaluation`功能。 这次我们将不使用火车测试拆分，因为我们将改用 K 折验证。 运行包含以下代码的单元格：
+2.  加载数据并为训练/验证集选择`satisfaction_level`和`last_evaluation`函数。 这次我们将不使用火车测试拆分，因为我们将改用 K 折验证。 运行包含以下代码的单元格：
 
     ```py
     df = pd.read_csv('../data/hr-analytics/hr_data_processed.csv')
@@ -894,7 +894,7 @@ K 折交叉验证算法如下：
 
     有关完整的代码，请参考`Lesson 2`文件夹中的`Lesson 2.txt`文件。
 
-    现在我们可以看到每折的班级准确性！ 很整洁吧？
+    现在我们可以看到每折的类别准确性！ 很整洁吧？
 
 8.  让我们继续展示如何使用`model_selection.validation_curve`来计算验证曲线。 此函数使用分层的 K 折交叉验证来训练给定参数各种值的模型。
 
@@ -950,7 +950,7 @@ K 折交叉验证算法如下：
 *   在标记的训练数据上进行有监督的学习
 *   具有两个类别标签的分类问题（二进制）
 
-尤其是，我们正在训练模型，以根据一系列连续和明确的特征来确定员工是否已离开公司。 在“活动 A”和“训练员工保留问题的预测模型”中准备了用于机器学习的数据之后，我们接着实现了 SVM，K 最近邻和随机森林算法仅使用两个功能。 这些模型能够以超过 90% 的总体准确性进行预测。 但是，在查看特定班级的准确性时，我们发现离职的员工（`class-label 1`）只能以 70-80% 的准确度进行预测。 让我们看看可以通过利用全部功能空间将改进多少。
+尤其是，我们正在训练模型，以根据一系列连续和明确的特征来确定员工是否已离开公司。 在“活动 A”和“训练员工保留问题的预测模型”中准备了用于机器学习的数据之后，我们接着实现了 SVM，K 最近邻和随机森林算法仅使用两个功能。 这些模型能够以超过 90% 的总体准确性进行预测。 但是，在查看特定类别的准确性时，我们发现离职的员工（`class-label 1`）只能以 70-80% 的准确度进行预测。 让我们看看可以通过利用全部功能空间将改进多少。
 
 1.  在`lesson-2-workbook.ipynb`笔记本中，向下滚动到该部分的代码。 我们应该已经从上一节中加载了预处理的数据，但是如果需要，可以通过执行`df = pd.read_csv('../data/hr-analytics/hr_data_processed.csv')`再次完成。 然后，使用`print(df.columns)`打印`DataFrame`列。
 2.  定义所有功能的列表，方法是将`df.columns`中的输出复制并粘贴到新列表中（确保删除目标变量`left`）。 然后，像之前一样定义`X`和`Y`。 如下所示：
@@ -1047,7 +1047,7 @@ K 折交叉验证算法如下：
 
     ![Training a predictive model for the employee retention problem](img/image2_56.jpg)
 
-    从单热编码变量`department`和`salary`的有用贡献看来，我们并没有从中获得太多。 同样，`promotion_last_5years`和`work_accident`功能似乎不太有用。
+    从单热编码变量`department`和`salary`的有用贡献看来，我们并没有从中获得太多。 同样，`promotion_last_5years`和`work_accident`函数似乎不太有用。
 
     让我们使用主成分分析（PCA）将所有这些弱功能浓缩为几个主要成分。
 

new/handson-ds-py-ml/01.md

@@ -21,11 +21,11 @@
 
 # 安装 Enthought Canopy
 
-让我们深入研究并获取安装所需的内容，以便在您的桌面上使用数据科学实际开发 Python 代码。 我将指导您安装名为 Enthought Canopy 的软件包，该软件包同时包含开发环境和您需要预安装的所有 Python 软件包。 它使生活变得非常轻松，但是，如果您已经了解 Python，那么您的 PC 上可能已经有一个现有的 Python 环境，并且如果您想继续使用它，也许可以。
+让我们深入研究并获取安装所需的内容，以便在您的桌面上使用数据科学实际开发 Python 代码。 我将指导您安装名为 Enthought Canopy 的包，该包同时包含开发环境和您需要预安装的所有 Python 包。 它使生活变得非常轻松，但是，如果您已经了解 Python，那么您的 PC 上可能已经有一个现有的 Python 环境，并且如果您想继续使用它，也许可以。
 
-最重要的是，您的 Python 环境具有 Python 3.5 或更高版本，它支持 Jupyter 笔记本（因为这是我们将在本课程中使用的语言），并且您已在本书中安装了所需的关键软件包。 环境。 我将通过几个简单的步骤来确切说明如何实现完整安装-这将非常容易。
+最重要的是，您的 Python 环境具有 Python 3.5 或更高版本，它支持 Jupyter 笔记本（因为这是我们将在本课程中使用的语言），并且您已在本书中安装了所需的关键包。 环境。 我将通过几个简单的步骤来确切说明如何实现完整安装-这将非常容易。
 
-让我们首先概述那些关键软件包，其中大部分 Canopy 都会自动为我们安装。 Canopy 将为我们安装 Python 3.5，以及我们需要的其他一些软件包，包括：`scikit_learn`，`xlrd`和`statsmodels`。 我们需要手动使用`pip`命令来安装名为`pydot2plus`的软件包。 就是这样-Canopy 非常容易！
+让我们首先概述那些关键包，其中大部分 Canopy 都会自动为我们安装。 Canopy 将为我们安装 Python 3.5，以及我们需要的其他一些包，包括：`scikit_learn`，`xlrd`和`statsmodels`。 我们需要手动使用`pip`命令来安装名为`pydot2plus`的包。 就是这样-Canopy 非常容易！
 
 完成以下安装步骤后，我们将具备启动和运行所需的一切，因此，我们将打开一个小示例文件并进行一些实际的数据科学处理。 现在，让您开始快速入门所需的一切：
 
@@ -223,7 +223,7 @@ print ("Hooray! We're all done.")
 
 # 导入模块
 
-像任何语言一样，Python 本身在功能上也相当有限。 使用 Python 进行机器学习，数据挖掘和数据科学的真正力量是可用于此目的的所有外部库的力量。 这些库之一称为`NumPy`或数字 Python，例如，在这里我们可以`import` `Numpy`软件包，该软件包作为`np`包含在 Canopy 中。
+像任何语言一样，Python 本身在功能上也相当有限。 使用 Python 进行机器学习，数据挖掘和数据科学的真正力量是可用于此目的的所有外部库的力量。 这些库之一称为`NumPy`或数字 Python，例如，在这里我们可以`import` `Numpy`包，该包作为`np`包含在 Canopy 中。
 
 这意味着我将`NumPy`包称为`np`，我可以将其命名为任何内容。 我可以称其为`Fred`或`Tim`，但最好坚持使用确实有意义的东西。 现在，我正在调用`NumPy`包`np`，我可以使用`np`来引用它：
 
@@ -232,7 +232,7 @@ import numpy as np
 
 ```
 
-在此示例中，我将调用`NumPy`程序包的一部分提供的`random`函数，并调用其正态函数使用这些参数实际生成随机数的正态分布并打印出来。 由于它是随机的，因此每次我应该得到不同的结果：
+在此示例中，我将调用`NumPy`包的一部分提供的`random`函数，并调用其正态函数使用这些参数实际生成随机数的正态分布并打印出来。 由于它是随机的，因此每次我应该得到不同的结果：
 
 ```py
 import numpy as np
@@ -382,7 +382,7 @@ x
 
 # `append`函数
 
-如果您只想在该列表中添加其他内容，则可以使用`append`功能。 所以我只想在末尾贴上数字`9`，我们就可以了：
+如果您只想在该列表中添加其他内容，则可以使用`append`函数。 所以我只想在末尾贴上数字`9`，我们就可以了：
 
 ```py
 x.append(9)
@@ -865,6 +865,6 @@ while (x < 10):
 
 # 总结
 
-在本章中，我们从构建书中最重要的垫脚石-安装有思想的檐篷开始了旅程。 然后，我们转向安装其他库并安装不同类型的软件包。 我们还借助各种 Python 代码掌握了 Python 的一些基础知识。 我们介绍了诸如模块，列表和元组之类的基本概念，并最终通过更好地了解 Python 中的函数和循环知识，进一步了解了 Python 基础知识。 最后，我们从运行一些简单的 Python 脚本开始。
+在本章中，我们从构建书中最重要的垫脚石-安装有思想的檐篷开始了旅程。 然后，我们转向安装其他库并安装不同类型的包。 我们还借助各种 Python 代码掌握了 Python 的一些基础知识。 我们介绍了诸如模块，列表和元组之类的基本概念，并最终通过更好地了解 Python 中的函数和循环知识，进一步了解了 Python 基础知识。 最后，我们从运行一些简单的 Python 脚本开始。
 
 在下一章中，我们将继续理解统计和概率的概念。
\ No newline at end of file

new/handson-ds-py-ml/02.md

@@ -198,7 +198,7 @@ Out[1]: 27173.098561362742
 
 # 使用 Matplotlib 可视化数据
 
-让我们可视化这些数据，使其更具意义。 因此，还有一个名为`matplotlib`的软件包，以后我们将再次讨论更多，但这是一个软件包，可以让我在 IPython 笔记本中制作漂亮的图形，因此这是一种可视化您的数据的简单方法，看看发生了什么。
+让我们可视化这些数据，使其更具意义。 因此，还有一个名为`matplotlib`的包，以后我们将再次讨论更多，但这是一个包，可以让我在 IPython 笔记本中制作漂亮的图形，因此这是一种可视化您的数据的简单方法，看看发生了什么。
 
 在此示例中，我们使用`matplotlib`创建我们的收入数据的直方图，该直方图分为`50`个不同的存储桶。 因此，基本上，我们要获取连续数据并将其离散化，然后可以在`matplotlib.pyplot`上调用`show`来实际显示该直方图。 请参考以下代码：
 
@@ -218,7 +218,7 @@ plt.show()
 
 因此，举例来说，对于每个给定的值范围，我们看到在该邻域中大约有`600`个数据点。 有很多人都在 27,000 大关附近，但是当您走到`80,000`之类的离群值时，并没有很多人，而且显然还有一些穷人甚至在`-40,000`时负债累累，但又一次，它们非常罕见且不太可能，因为我们定义了正态分布，这就是正态概率曲线的样子。 再次，我们将在以后更详细地讨论这一点，但是如果您还不知道，那么我只是想让您想到这个想法。
 
-# 使用 NumPy 软件包计算中位数
+# 使用 NumPy 包计算中位数
 
 好了，因此计算中位数与计算均值一样简单。 就像我们有 NumPy `mean`一样，我们也有 NumPy `median`函数。
 
@@ -279,7 +279,7 @@ Out[5]:127160.38252311043
 
 这个故事的寓意是：如果您怀疑其中可能包含离群值，那么请任何谈论均值或均值的人都参与进来，而收入分配肯定就是这种情况。
 
-# 使用 SciPy 软件包计算众数
+# 使用 SciPy 包计算众数
 
 最后，让我们看看众数。 我们将只生成一堆随机整数，准确地说是其中的 500 个，范围在`18`和`90`之间。 我们将为人们创造一堆假年龄。
 
@@ -339,7 +339,7 @@ Out[11]: ModeResult(mode=array([29]), count=array([14]))
 
 因此，这是一个非常简单的概念。 您可以再玩几次，只是为了好玩。 这有点像旋转轮盘赌。 我们将再次创建一个新的发行版。
 
-简而言之，您将拥有平均值，中位数和众数。 使用 SciPy 和 NumPy 软件包非常简单。
+简而言之，您将拥有平均值，中位数和众数。 使用 SciPy 和 NumPy 包非常简单。
 
 # 一些练习
 
@@ -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

new/handson-ds-py-ml/03.md

@@ -4,7 +4,7 @@
 
 本章将涵盖以下主题：
 
-*   使用`matplotlib`程序包绘制图形
+*   使用`matplotlib`包绘制图形
 *   了解协方差和相关性来确定数据之间的关系
 *   通过示例了解条件概率
 *   了解贝叶斯定理及其重要性
@@ -91,7 +91,7 @@ plt.show()
 
 ```
 
-在此示例中，首先使用`plt.axes`获得轴。 一旦有了这些轴对象，就可以对其进行调整。 通过调用`set_xlim`，我可以将 x 范围设置为 -5 到 5，并通过设置`set_ylim`来将 y 范围设置为 0 到 1。您可以在下面的输出中看到，我的 x 值的范围是`-5`到`5`，并且 y 从 0 到 1。我还可以明确控制轴上刻度线的位置。 因此，在前面的代码中，我想让 x 刻度线位于`-5`，`-4`，`- 3`等位置，而 y 刻度线则使用`set_xticks()`和`set_yticks()`功能。 现在，我可以使用`arange`函数来更紧凑地执行此操作，但要点是您可以明确控制那些刻度线的确切位置，也可以跳过一些标记。 您可以按所需的增量或分布进行配置。 除此之外，这是一回事。
+在此示例中，首先使用`plt.axes`获得轴。 一旦有了这些轴对象，就可以对其进行调整。 通过调用`set_xlim`，我可以将 x 范围设置为 -5 到 5，并通过设置`set_ylim`来将 y 范围设置为 0 到 1。您可以在下面的输出中看到，我的 x 值的范围是`-5`到`5`，并且 y 从 0 到 1。我还可以明确控制轴上刻度线的位置。 因此，在前面的代码中，我想让 x 刻度线位于`-5`，`-4`，`- 3`等位置，而 y 刻度线则使用`set_xticks()`和`set_yticks()`函数。 现在，我可以使用`arange`函数来更紧凑地执行此操作，但要点是您可以明确控制那些刻度线的确切位置，也可以跳过一些标记。 您可以按所需的增量或分布进行配置。 除此之外，这是一回事。
 
 调整轴后，我便用要绘制的函数调用了`plot()`，并调用了`show()`来显示它。 果然，您可以得到结果。
 
@@ -202,7 +202,7 @@ plt.show()
 
 # 标记轴并添加图例
 
-您将更常做的事情是标记轴。 您永远都不想真空呈现数据。 您绝对想告诉人们它代表什么。 为此，您可以使用`plt`上的`xlabel()`和`ylabel()`功能在轴上实际放置标签。 我将标记 x 轴 Greebles 和 y 轴概率。 您还可以添加图例插图。 通常，这是同一回事，但只是为了表明它是独立设置的，我还在以下代码中设置了图例：
+您将更常做的事情是标记轴。 您永远都不想真空呈现数据。 您绝对想告诉人们它代表什么。 为此，您可以使用`plt`上的`xlabel()`和`ylabel()`函数在轴上实际放置标签。 我将标记 x 轴 Greebles 和 y 轴概率。 您还可以添加图例插图。 通常，这是同一回事，但只是为了表明它是独立设置的，我还在以下代码中设置了图例：
 
 ```py
 axes = plt.axes() 
@@ -544,7 +544,7 @@ correlation (pageSpeeds, purchaseAmount)
 
 # 相关性的活动
 
-因此，请弄脏您的手，卷起袖子，我希望您使用`numpy.cov()`功能。 这实际上是让 NumPy 为您计算协方差的一种方法。 我们看到了如何使用`corrcoef()`函数计算相关性。 因此，返回并仅使用`numpy.cov()`函数重新运行这些示例，看看是否获得相同的结果。 它应该是相当不错的，所以不要使用我从头开始编写的协方差函数来做到这一点，而要使用 NumPy 看看是否可以获得相同的结果。 同样，此练习的目的是使您熟悉使用 NumPy 并将其应用于实际数据。 因此，看看它在哪里。
+因此，请弄脏您的手，卷起袖子，我希望您使用`numpy.cov()`函数。 这实际上是让 NumPy 为您计算协方差的一种方法。 我们看到了如何使用`corrcoef()`函数计算相关性。 因此，返回并仅使用`numpy.cov()`函数重新运行这些示例，看看是否获得相同的结果。 它应该是相当不错的，所以不要使用我从头开始编写的协方差函数来做到这一点，而要使用 NumPy 看看是否可以获得相同的结果。 同样，此练习的目的是使您熟悉使用 NumPy 并将其应用于实际数据。 因此，看看它在哪里。
 
 在理论和实践中都有协方差和相关性。 有一项非常有用的技术，因此请务必记住本节。 让我们继续。
 

new/handson-ds-py-ml/04.md

@@ -93,7 +93,7 @@ scatter(pageSpeeds, purchaseAmount)
 
 您可以通过观察看到肯定存在线性关系，这是因为我们确实在源数据中对实际的线性关系进行了硬编码。
 
-现在让我们看看是否可以梳理一下，并使用普通的最小二乘方找到最佳拟合线。 我们讨论了如何进行普通最小二乘法和线性回归，但是您不必自己做任何数学运算，因为 SciPy 程序包具有可导入的`stats`程序包：
+现在让我们看看是否可以梳理一下，并使用普通的最小二乘方找到最佳拟合线。 我们讨论了如何进行普通最小二乘法和线性回归，但是您不必自己做任何数学运算，因为 SciPy 包具有可导入的`stats`包：
 
 ```py
 from scipy import stats
@@ -174,7 +174,7 @@ plt.show()
 
 # 使用 NumPy 实现多项式回归
 
-幸运的是，NumPy 具有`polyfit`功能，可以超级轻松地玩此游戏并尝试不同的结果，所以让我们来看一下。 是时候玩多项式回归了。 顺便说一句，我确实认为这很有趣。 看到所有中学数学实际上都已投入实际应用，真是太酷了。 继续打开`PolynomialRegression.ipynb`，让我们玩得开心。
+幸运的是，NumPy 具有`polyfit`函数，可以超级轻松地玩此游戏并尝试不同的结果，所以让我们来看一下。 是时候玩多项式回归了。 顺便说一句，我确实认为这很有趣。 看到所有中学数学实际上都已投入实际应用，真是太酷了。 继续打开`PolynomialRegression.ipynb`，让我们玩得开心。
 
 让我们在页面速度和购买量伪造数据之间创建一个新的关系，这次我们将创建一个更复杂的非线性关系。 我们将采用页面速度，并使其具有购买速度的页面速度除法功能：
 
@@ -289,7 +289,7 @@ p4 = np.poly1d(np.polyfit(x, y, 3))
 
 # 使用 Python 的多元回归
 
-幸运的是，有一个`statsmodel`软件包可用于 Python，使进行多元回归非常容易。 让我们来看看它是如何工作的。 让我们使用 Python 进行一些多元回归。 我们将在这里使用一些有关凯利蓝皮书中汽车价值的真实数据。
+幸运的是，有一个`statsmodel`包可用于 Python，使进行多元回归非常容易。 让我们来看看它是如何工作的。 让我们使用 Python 进行一些多元回归。 我们将在这里使用一些有关凯利蓝皮书中汽车价值的真实数据。
 
 ```py
 import pandas as pd
@@ -297,7 +297,7 @@ df = pd.read_excel('http://cdn.sundog-soft.com/Udemy/DataScience/cars.xls')
 
 ```
 
-我们将在此处引入一个名为`pandas`的新程序包，它使我们能够非常轻松地处理表格数据。 它使我们能够读入数据表，并对它们进行重新排列，修改，切分并以不同的方式切成小方块。 我们将大量使用。
+我们将在此处引入一个名为`pandas`的新包，它使我们能够非常轻松地处理表格数据。 它使我们能够读入数据表，并对它们进行重新排列，修改，切分并以不同的方式切成小方块。 我们将大量使用。
 
 我们将`pandas`导入为`pd`，并且`pd`具有`read_Excel()`函数，我们可以使用该函数继续通过 HTTP 从 Web 读取 Microsoft Excel 电子表格。 因此，那里的 Pandas 功能相当强大。
 

new/handson-ds-py-ml/05.md

@@ -125,7 +125,7 @@ testY = purchaseAmount[80:]
 
 现在，在前面的部分中，我已经说过，您不应该像这样将数据集一分为二，而是应该随机抽样以进行训练和测试。 但是在这种情况下，由于我的原始数据无论如何都是随机生成的，因此可以解决问题，所以实际上并没有韵律或原因。 但是在实际数据中，您需要在拆分数据之前先对其进行混洗。
 
-现在，我们将介绍一种方便的方法，您可以将其用于整理数据的目的。 另外，如果您使用的是 Pandas 软件包，则其中有一些方便的功能可以自动为您制作训练和测试数据集。 但是，我们将在这里使用 Python 列表进行操作。 因此，让我们可视化最终得到的训练数据集。 我们将散布我们的培训页面速度和购买金额的图表。
+现在，我们将介绍一种方便的方法，您可以将其用于整理数据的目的。 另外，如果您使用的是 Pandas 包，则其中有一些方便的功能可以自动为您制作训练和测试数据集。 但是，我们将在这里使用 Python 列表进行操作。 因此，让我们可视化最终得到的训练数据集。 我们将散布我们的培训页面速度和购买金额的图表。
 
 ```py
 scatter(trainX, trainY) 
@@ -253,7 +253,7 @@ R 平方值原来是`0.6`，这并不奇怪，因为我们在训练数据上对
 
 现在有一个原因叫朴素贝叶斯。 朴素是因为我们假设单词本身之间没有任何关系。 我们只是在消息中单独查看每个单词，然后基本上将每个单词对垃圾邮件的贡献的所有概率结合起来。 我们不是在看单词之间的关系。 因此，更好的垃圾邮件分类器可以做到这一点，但显然要困难得多。
 
-因此，这听起来很麻烦。 但是总体想法并不难，Python 中的 Scikit-learn 使它实际上很容易实现。 它提供了一个称为`CountVectorizer`的功能，使将电子邮件实际拆分到其所有组成词并分别处理这些词变得非常简单。 然后它具有`MultinomialNB`功能，其中 NB 代表朴素贝叶斯，它将为我们完成朴素贝叶斯的所有繁重工作。
+因此，这听起来很麻烦。 但是总体想法并不难，Python 中的 Scikit-learn 使它实际上很容易实现。 它提供了一个称为`CountVectorizer`的功能，使将电子邮件实际拆分到其所有组成词并分别处理这些词变得非常简单。 然后它具有`MultinomialNB`函数，其中 NB 代表朴素贝叶斯，它将为我们完成朴素贝叶斯的所有繁重工作。
 
 # 使用朴素贝叶斯实现垃圾邮件分类器
 
@@ -304,7 +304,7 @@ data = data.append(dataFrameFromDirectory(
 
 ```
 
-因此，我们需要做的第一件事是以某种方式阅读所有这些电子邮件，并且我们将再次使用 Pandas 来简化此操作。 同样，Pandas 是用于处理表格数据的有用工具。 我们在这里的示例中导入将要使用的所有不同软件包，其中包括`os`库，`io`库，NumPy，Pandas，以及来自 Scikit-learn 的`CountVectorizer`和`MultinomialNB`。
+因此，我们需要做的第一件事是以某种方式阅读所有这些电子邮件，并且我们将再次使用 Pandas 来简化此操作。 同样，Pandas 是用于处理表格数据的有用工具。 我们在这里的示例中导入将要使用的所有不同包，其中包括`os`库，`io`库，NumPy，Pandas，以及来自 Scikit-learn 的`CountVectorizer`和`MultinomialNB`。
 
 现在让我们详细研究这段代码。 现在，我们可以跳过`readFiles()`和`dataFrameFromDirectory()`的函数定义，然后转到我们的代码实际要做的第一件事，即创建一个 Pandas `DataFrame`对象。
 
@@ -314,7 +314,7 @@ data = data.append(dataFrameFromDirectory(
 
 如果您在这里玩耍，请确保修改传递给`dataFrameFromDirectory()`函数的路径以匹配您在系统中安装书籍资料的位置！ 同样，如果您使用的是 Mac 或 Linux，请注意反斜杠和正斜杠以及所有其他内容。 在这种情况下，这没关系，但是如果您不在 Windows 上，则不会有驱动器号。 因此，只需确保这些路径实际上指向此示例的`spam`和`ham`文件夹所在的位置即可。
 
-接下来，`dataFrameFromDirectory()`是我编写的函数，基本上说我有一个目录的路径，并且我知道给它指定了分类，垃圾邮件或火腿，然后它使用了我也编写的`readFiles()`函数，该函数将迭代目录中的每个文件。 因此，`readFiles()`使用`os.walk()`功能来查找目录中的所有文件。 然后，它为该目录中的每个文件建立完整的路径名，然后将其读入。在读入时，它实际上跳过了每封电子邮件的标题，并通过查找第一个空白行直接转到文本。
+接下来，`dataFrameFromDirectory()`是我编写的函数，基本上说我有一个目录的路径，并且我知道给它指定了分类，垃圾邮件或火腿，然后它使用了我也编写的`readFiles()`函数，该函数将迭代目录中的每个文件。 因此，`readFiles()`使用`os.walk()`函数来查找目录中的所有文件。 然后，它为该目录中的每个文件建立完整的路径名，然后将其读入。在读入时，它实际上跳过了每封电子邮件的标题，并通过查找第一个空白行直接转到文本。
 
 它知道在第一个空行之后的所有内容实际上都是邮件正文，而在第一个空行之前的所有内容只是一堆标题信息，我实际上并不想在上面训练垃圾邮件分类器。 因此，它既给我返回了每个文件的完整路径，又给了邮件正文。 这就是我们读取所有数据的方式，这就是大部分代码！
 
@@ -498,7 +498,7 @@ plt.show()
 
 # 活动
 
-因此，我希望您为某项活动做的是尝试使用不同的 k 值，然后查看最终结果。 只是盯着前面的图，看起来四个就可以了。 真的吗？如果我增加 k 太大会怎样？ 我的结果如何？ 它试图将事物分解成什么，甚至有意义？ 因此，尝试一下，尝试使用`k`的不同值。 因此，在`n_clusters()`功能中，将 5 更改为其他值。 再次运行所有内容，看看最终结果如何。
+因此，我希望您为某项活动做的是尝试使用不同的 k 值，然后查看最终结果。 只是盯着前面的图，看起来四个就可以了。 真的吗？如果我增加 k 太大会怎样？ 我的结果如何？ 它试图将事物分解成什么，甚至有意义？ 因此，尝试一下，尝试使用`k`的不同值。 因此，在`n_clusters()`函数中，将 5 更改为其他值。 再次运行所有内容，看看最终结果如何。
 
 这就是 K 均值聚类的全部内容。 就这么简单。 您可以只使用 Scikit-learn 的`cluster`中的`KMeans`东西。 唯一的难题：请确保您缩放数据，对其进行规范化。 您要确保使用 K 均值的事物彼此可比，并且`scale()`函数将为您做到这一点。 因此，这些是 K 均值聚类的主要内容。 非常简单的概念，甚至更简单地使用 Scikit-learn 进行操作。
 
@@ -730,7 +730,7 @@ print clf.predict([[10, 0, 4, 0, 0, 0]])
 
 ![](img/76760aeb-0024-4cec-8ca3-5cd9c64c2ebe.jpg)
 
-因此，在这种情况下，我们最终决定了两者的聘用决定。 但是，有趣的是有一个随机成分。 实际上，您每次都不会得到相同的结果！ 通常，失业者不会获得工作机会，如果您继续经营下去，通常会发现这种情况。 但是，装袋的随机性，自举聚合这些树的每一棵树，意味着您不会每次都得到相同的结果。 因此，也许十棵树还不够。 因此，无论如何，这是在这里学习的好课！
+因此，在这种情况下，我们最终决定了两者的聘用决定。 但是，有趣的是有一个随机成分。 实际上，您每次都不会得到相同的结果！ 通常，失业者不会获得工作机会，如果您继续经营下去，通常会发现这种情况。 但是，装袋的随机性，自举聚合这些树的每一棵树，意味着您不会每次都得到相同的结果。 因此，也许十棵树还不够。 因此，无论如何，这是在这里学习的经验！
 
 # 活动
 
@@ -777,7 +777,7 @@ print clf.predict([[10, 0, 4, 0, 0, 0]])
 
 支持向量机找到可以在其上划分数据的高维支持向量（从数学上讲，这些支持向量定义了超平面）。 也就是说，在数学上，支持向量机可以做的是找到更高维的支持向量（这就是它的名字），它定义了将数据分成不同簇的更高维平面。
 
-显然，这一切使数学很快变得很奇怪。 幸运的是，`scikit-learn`程序包将为您完成所有操作，而无需您真正参与其中。 在幕后，您需要了解，尽管它使用了一种称为内核技巧的东西来实际上找到那些在较低维度上可能不明显的支持向量或超平面。 您可以使用不同的内核，以不同的方式执行此操作。 要点是，如果您拥有具有许多不同功能的高维数据，并且可以使用具有不同计算成本并且可以更好地解决当前问题的不同内核，则 SVM 是一个不错的选择。
+显然，这一切使数学很快变得很奇怪。 幸运的是，`scikit-learn`包将为您完成所有操作，而无需您真正参与其中。 在幕后，您需要了解，尽管它使用了一种称为内核技巧的东西来实际上找到那些在较低维度上可能不明显的支持向量或超平面。 您可以使用不同的内核，以不同的方式执行此操作。 要点是，如果您拥有具有许多不同功能的高维数据，并且可以使用具有不同计算成本并且可以更好地解决当前问题的不同内核，则 SVM 是一个不错的选择。
 
 重要的一点是，SVM 使用一些先进的数学技巧对数据进行聚类，并且可以处理具有许多功能的数据集。 它也相当昂贵-“内核技巧”是唯一使之成为可能的事情。
 

new/handson-ds-py-ml/07.md

@@ -83,7 +83,7 @@ movieProperties.head()
 
 这给了我们另一个`DataFrame`，它告诉我们，例如`movie_id 1`的评分为`452`（这是其受欢迎程度的衡量标准，即实际上有多少人观看并对其进行了评级）， 平均评价得分 3.8。 因此，`452`人观看了`movie_id 1`，他们给它的平均评价为 3.87，这是相当不错的。
 
-现在，原始评分等级对我们没有太大用处。 我的意思是我不知道`452`是否受欢迎。 因此，为了标准化，我们要做的基本上是根据每部电影的最大和最小收视率来衡量。 我们可以使用`lambda`功能来做到这一点。 因此，我们可以通过这种方式将功能应用于整个`DataFrame`。
+现在，原始评分等级对我们没有太大用处。 我的意思是我不知道`452`是否受欢迎。 因此，为了标准化，我们要做的基本上是根据每部电影的最大和最小收视率来衡量。 我们可以使用`lambda`函数来做到这一点。 因此，我们可以通过这种方式将功能应用于整个`DataFrame`。
 
 我们要做的是使用`np.min()`和`np.max()`函数查找在整个数据集中找到的最大评分数和最小评分数。 因此，我们将拍摄最流行的电影和最不流行的电影，然后在此处找到范围，并针对该范围对所有内容进行归一化：
 

new/handson-ds-py-ml/08.md

@@ -135,7 +135,7 @@ print scores.mean()
 
 ```
 
-我们已经有了一个模型，我们为此预测定义了 SVC 模型，您需要做的就是在`cross_validation`程序包上调用`cross_val_score()`。 因此，您要在此函数中传递给定类型（`clf`）的模型，即所有测量的整个数据集，即我的所有特征数据（`iris.data`）和我的所有目标数据 （所有物种），`iris.target`。
+我们已经有了一个模型，我们为此预测定义了 SVC 模型，您需要做的就是在`cross_validation`包上调用`cross_val_score()`。 因此，您要在此函数中传递给定类型（`clf`）的模型，即所有测量的整个数据集，即我的所有特征数据（`iris.data`）和我的所有目标数据 （所有物种），`iris.target`。
 
 我想要`cv=5`，这意味着它实际上将使用 5 个不同的训练数据集，同时保留`1`进行测试。 基本上，它将运行 5 次，这就是我们需要做的。 这将针对整个数据集自动评估我们的模型，分解出五种不同的方式，并给我们单独的结果。
 

new/handson-ds-py-ml/09.md

@@ -80,7 +80,7 @@
 
 ![](img/7b1ca113-5535-438e-88fd-dea58a24ef55.png)
 
-确保您获得了预构建的版本，然后选择“直接下载”选项，以便所有这些默认设置都可以正常使用。 继续并单击说明 4 旁边的链接以下载该软件包。
+确保您获得了预构建的版本，然后选择“直接下载”选项，以便所有这些默认设置都可以正常使用。 继续并单击说明 4 旁边的链接以下载该包。
 
 现在，它下载了您可能不熟悉的 **TGZ**（GZip 中的 Tar）。 老实说，Windows 是 Spark 的事后想法，因为在 Windows 上，您将没有内置的工具来实际解压缩 TGZ 文件。 这意味着，如果您还没有一个，则可能需要安装它。 我使用的一个称为 WinRAR，您可以从[这个页面](http://www.rarlab.com)中进行选择。 如果需要，请转到“下载”页面，然后下载 32 位或 64 位 WinRAR 的安装程序，具体取决于您的操作系统。 正常安装 WinRAR，这将允许您在 Windows 上实际解压缩 TGZ 文件：
 
@@ -90,7 +90,7 @@
 
 ![](img/edaa679b-44dd-4811-bbed-52b39f6488bc.png)
 
-因此，我现在应该在与该软件包关联的`Downloads`文件夹中有一个文件夹。 让我们打开它，其中就有 Spark 本身。 您应该看到类似如下所示的文件夹内容。 因此，您需要将其安装在可以记住的地方：
+因此，我现在应该在与该包关联的`Downloads`文件夹中有一个文件夹。 让我们打开它，其中就有 Spark 本身。 您应该看到类似如下所示的文件夹内容。 因此，您需要将其安装在可以记住的地方：
 
 ![](img/417d9e6f-4b8c-4a51-bb1c-694e1cf23530.png)
 
@@ -170,7 +170,7 @@
 
 ![](img/f84bdcce-2d85-4a17-888e-6e7020a1d3ed.png)
 
-我们还需要设置`HADOOP_HOME`，这就是我们安装`winutils`软件包的位置，因此我们将其指向`c:\winutils`：
+我们还需要设置`HADOOP_HOME`，这就是我们安装`winutils`包的位置，因此我们将其指向`c:\winutils`：
 
 ![](img/65b2e661-efd4-4c80-b6a6-d7ad02f60df2.png)
 
@@ -358,7 +358,7 @@ rdd.map(lambda x: x*x)
 *   `countByValue()`：此功能将为您提供该 RDD 中每个唯一值出现多少次的细分。
 *   `take()`：您也可以使用`take()`从 RDD 中采样，这将从 RDD 中随机抽取条目。
 *   `top()`：`top()`将为您提供该 RDD 中的前几项，如果您只是想了解其中的内容以进行调试的话。
-*   `reduce()`：`reduce()`是更强大的操作，它实际上使您可以将相同的公用键值的值组合在一起。 您还可以在键值数据的上下文中使用 RDD。 `reduce()`功能可让您定义一种将给定键的所有值组合在一起的方式。 它的实质与 MapReduce 非常相似。 `reduce()`基本上与 MapReduce 中的`reducer()`类似，并且`map()`与`mapper()`类似。 因此，实际上很容易进行 MapReduce 作业，并使用这些功能将其转换为 Spark。
+*   `reduce()`：`reduce()`是更强大的操作，它实际上使您可以将相同的公用键值的值组合在一起。 您还可以在键值数据的上下文中使用 RDD。 `reduce()`函数可让您定义一种将给定键的所有值组合在一起的方式。 它的实质与 MapReduce 非常相似。 `reduce()`基本上与 MapReduce 中的`reducer()`类似，并且`map()`与`mapper()`类似。 因此，实际上很容易进行 MapReduce 作业，并使用这些功能将其转换为 Spark。
 
 还要记住，在您调用动作之前，Spark 实际上不会发生任何事情。 调用了其中一种操作方法后，Spark 便会退出并使用有向无环图进行操作，并实际上计算出获取所需答案的最佳方法。 但是请记住，在该操作发生之前，什么都不会发生。 因此，有时在编写 Spark 脚本时可能会绊倒您，因为您可能在其中有一个打印语句，并且可能希望得到一个答案，但是直到实际执行操作时它才会真正出现。
 
@@ -509,7 +509,7 @@ def createLabeledPoints(fields):
 
 我们要做的第一件事是加载此`PastHires.csv`文件，这与我们在本书前面所做的决策树练习中使用的文件相同。
 
-让我们暂停一下，以提醒自己该文件的内容。 如果您没记错的话，我们有很多应聘者的属性，而且我们有一个领域是否应聘这些人。 我们正在尝试做的是建立一个可以预测的决策树-考虑到这些属性，我们会雇用还是不雇用一个人？
+让我们暂停一下，以提醒自己该文件的内容。 如果您没记错的话，我们有很多应聘者的属性，而且我们有一个字段是否应聘这些人。 我们正在尝试做的是建立一个可以预测的决策树-考虑到这些属性，我们会雇用还是不雇用一个人？
 
 现在，让我们快速浏览`PastHires.csv`，它将是一个 Excel 文件。
 
@@ -658,7 +658,7 @@ model = DecisionTree.trainClassifier(trainingData, numClasses=2,
 
 ```
 
-我们将调用`DecisionTree.trainClassifier`，这实际上是在构建决策树本身。 我们传入`trainingData`，它只是一个充满`LabeledPoint`数组`numClasses=2`的 RDD，因为基本上我们会做出一个是或否的预测，这个人是否会被录用 ？ 下一个参数称为`categoricalFeaturesInfo`，这是一个 Python 字典，它将字段映射到每个字段中的类别数。 因此，如果您对给定的领域有连续的范围（例如经验的年限），则根本不会在此处指定，但是对于本质上属于类别的领域（例如，他们拥有什么程度）， 例如，将`fieldID3`，映射到获得的学位，它有四种不同的可能性：没有学历，BS，MS 和 PhD。 对于所有的是否字段，我们将它们映射到 2 个可能的类别，是否或 0/1 是将它们转换为的类别。
+我们将调用`DecisionTree.trainClassifier`，这实际上是在构建决策树本身。 我们传入`trainingData`，它只是一个充满`LabeledPoint`数组`numClasses=2`的 RDD，因为基本上我们会做出一个是或否的预测，这个人是否会被录用 ？ 下一个参数称为`categoricalFeaturesInfo`，这是一个 Python 字典，它将字段映射到每个字段中的类别数。 因此，如果您对给定的字段有连续的范围（例如经验的年限），则根本不会在此处指定，但是对于本质上属于类别字段（例如，他们拥有什么程度）， 例如，将`fieldID3`，映射到获得的学位，它有四种不同的可能性：没有学历，BS，MS 和 PhD。 对于所有的是否字段，我们将它们映射到 2 个可能的类别，是否或 0/1 是将它们转换为的类别。
 
 继续进行`DecisionTree.trainClassifier`调用，我们将在测量熵时使用`'gini'`杂质度量。 我们的`maxDepth`为 5，这只是我们要走多远的上限，如果您愿意，可以更大。 最后，`maxBins`只是一种折衷计算费用的方法，因此，它至少需要至少是每个功能中具有类别的最大数量。 记住，在我们调用一个动作之前，什么都不会发生，所以我们将实际使用该模型对测试候选人进行预测。
 

new/master-py-ds/01.md

@@ -4,7 +4,7 @@
 
 进行此类分析的第一步是解析原始数据。 数据解析涉及以下步骤：
 
-*   **从源中提取数据**：数据可以多种形式出现，例如 Excel，CSV，JSON，数据库等。 在一些有用的软件包的帮助下，Python 使得从源中读取数据变得非常容易，本章将对此进行介绍。
+*   **从源中提取数据**：数据可以多种形式出现，例如 Excel，CSV，JSON，数据库等。 在一些有用的包的帮助下，Python 使得从源中读取数据变得非常容易，本章将对此进行介绍。
 *   **清理数据**：完成完整性检查后，需要适当清理数据，以便将其用于分析。 您可能具有有关班级学生的数据集，以及有关他们的身高，体重和成绩的详细信息。 可能还会有某些行缺少高度或重量。 根据执行的分析，这些具有缺失值的行可以忽略，也可以替换为平均身高或体重。
 
 在本章中，我们将讨论以下主题：
@@ -19,7 +19,7 @@
 
 Python 默认情况下为，它具有可用于数组操作的数据结构，例如列表，但是 Python 列表本身并不适合执行繁重的数学运算，因为它没有为此进行优化。
 
-NumPy 是 Travis Oliphant 生产的一个很棒的 Python 软件包，它是从根本上为科学计算而创建的。 它有助于处理大型多维数组和矩阵，以及处理这些数组的大型高级数学函数库。
+NumPy 是 Travis Oliphant 生产的一个很棒的 Python 包，它是从根本上为科学计算而创建的。 它有助于处理大型多维数组和矩阵，以及处理这些数组的大型高级数学函数库。
 
 与 Python 列表相比，NumPy 数组需要更少的内存来存储相同数量的数据，这有助于以更快的方式读取和写入数组。
 
@@ -226,7 +226,7 @@ Array[10 10 10 10]
 
 # Pandas 数据分析
 
-Pandas 库由 Wes McKinny 在 AQR Capital Management 工作时开发。 他想要一种足够灵活的工具来对财务数据进行定量分析。 后来，Chang She 加入了他，并帮助进一步开发了该软件包。
+Pandas 库由 Wes McKinny 在 AQR Capital Management 工作时开发。 他想要一种足够灵活的工具来对财务数据进行定量分析。 后来，Chang She 加入了他，并帮助进一步开发了该包。
 
 Pandas 库是一个开源代码 Python 库，专门用于数据分析。 它建立在 NumPy 上，可以轻松处理数据。 NumPy 是一个相当底层的工具，可以很好地处理矩阵。
 
@@ -375,7 +375,7 @@ Minor_axis axis: 0 to 2
 
 ### CSV
 
-要从`.csv`文件读取数据，可以使用以下`read_csv`功能：
+要从`.csv`文件读取数据，可以使用以下`read_csv`函数：
 
 ```py
 >>> d = pd.read_csv('Data/Student_Weight_Status_Category_Reporting_Results__Beginning_2010.csv')
@@ -389,7 +389,7 @@ Minor_axis axis: 0 to 2
 
 ```
 
-`read_csv`功能采用`.csv`文件的路径来输入数据。 此后的命令将在数据中打印`Location`列的前五行。
+`read_csv`函数采用`.csv`文件的路径来输入数据。 此后的命令将在数据中打印`Location`列的前五行。
 
 要将数据写入`.csv`文件，可以使用以下`to_csv`函数：
 
@@ -405,14 +405,14 @@ Minor_axis axis: 0 to 2
 
 ### XLS
 
-除了 Pandas 软件包外，还需要安装`xlrd`软件包，Pandas 才能从 Excel 文件中读取数据：
+除了 Pandas 包外，还需要安装`xlrd`包，Pandas 才能从 Excel 文件中读取数据：
 
 ```py
 >>> d=pd.read_excel('Data/Student_Weight_Status_Category_Reporting_Results__Beginning_2010.xls')
 
 ```
 
-先前的功能是，类似于 CSV 读取命令。 要写入 Excel 文件，需要安装`xlwt`软件包：
+先前的功能是，类似于 CSV 读取命令。 要写入 Excel 文件，需要安装`xlwt`包：
 
 ```py
 >>> df.to_excel('sample_data.xls')
@@ -431,7 +431,7 @@ Minor_axis axis: 0 to 2
 
 ```
 
-在前面的命令中，`open()`函数打开与文件的连接。 `json.load()`函数将数据加载到 Python 中。 `json_data.close()`功能关闭与文件的连接。
+在前面的命令中，`open()`函数打开与文件的连接。 `json.load()`函数将数据加载到 Python 中。 `json_data.close()`函数关闭与文件的连接。
 
 Pandas 库还提供了读取 JSON 文件的功能，可以使用`pd.read_json()`对其进行访问。
 
@@ -729,7 +729,7 @@ a41  0.547655  0.692852  0.681825
 
 ## 合并数据
 
-要将数据集组合在一起，可以利用 Pandas 的`concat`功能。 让我们以`Area Name`和`County`列的前五行为例：
+要将数据集组合在一起，可以利用 Pandas 的`concat`函数。 让我们以`Area Name`和`County`列的前五行为例：
 
 ```py
 >>> d[['AREA NAME', 'COUNTY']][0:5]
@@ -751,7 +751,7 @@ a41  0.547655  0.692852  0.681825
 
 ```
 
-数据的前两行在`p1`中，后三行在`p2`中。 这些片段可以使用`concat()`功能进行组合：
+数据的前两行在`p1`中，后三行在`p2`中。 这些片段可以使用`concat()`函数进行组合：
 
 ```py
 >>> pd.concat([p1,p2])
@@ -987,7 +987,7 @@ MIDDLE/HIGH      53089   59.251116   65.905591
 
 # 总结
 
-在本章中，我们熟悉了 NumPy 和 Pandas 软件包。 我们了解了 Pandas 中不同的数据类型以及如何利用它们。 我们学习了如何执行数据清除和操作，其中我们处理了缺失值并执行了字符串操作。 本章为我们提供了数据科学的基础，您可以通过单击以下链接来更深入地了解 NumPy 和 Pandas：
+在本章中，我们熟悉了 NumPy 和 Pandas 包。 我们了解了 Pandas 中不同的数据类型以及如何利用它们。 我们学习了如何执行数据清除和操作，其中我们处理了缺失值并执行了字符串操作。 本章为我们提供了数据科学的基础，您可以通过单击以下链接来更深入地了解 NumPy 和 Pandas：
 
 *   [**NumPy 文档**](http://docs.scipy.org/doc/)
 *   [**Pandas 文档**](http://pandas.pydata.org/)

new/master-py-ds/02.md

@@ -41,7 +41,7 @@
 
 在上式中，`n`是硬币被抛掷的次数，`p`是成功的概率，`q`为（`1 – p`），这是失败的可能性。
 
-Python 的 SciPy 软件包提供了有用的功能来执行统计计算。 您可以从[这个页面](http://www.scipy.org/)安装。 以下命令有助于绘制二项式分布：
+Python 的 SciPy 包提供了有用的功能来执行统计计算。 您可以从[这个页面](http://www.scipy.org/)安装。 以下命令有助于绘制二项式分布：
 
 ```py
 >>> from scipy.stats import binom
@@ -59,7 +59,7 @@ Python 的 SciPy 软件包提供了有用的功能来执行统计计算。 您
 
 ```
 
-SciPy 软件包中的`binom`函数有助于生成二项式分布以及与之相关的必要统计信息。 如果您观察到上述命令，则其中的某些部分来自 Matplotlib，我们现在将使用它们来绘制二项分布。 稍后的章节将详细介绍 Matplotlib 库。 `plt.subplots`功能有助于在屏幕上生成多个图。 `binom`功能接受尝试的次数和成功的可能性。 `ax.vlines`函数用于绘制垂直线，其中的`rv.pmf`帮助计算各种`x`值时的概率。 `ax.legend`功能为图形添加了图例，最后`plt.show`显示了图形。 结果如下：
+SciPy 包中的`binom`函数有助于生成二项式分布以及与之相关的必要统计信息。 如果您观察到上述命令，则其中的某些部分来自 Matplotlib，我们现在将使用它们来绘制二项分布。 稍后的章节将详细介绍 Matplotlib 库。 `plt.subplots`函数有助于在屏幕上生成多个图。 `binom`函数接受尝试的次数和成功的可能性。 `ax.vlines`函数用于绘制垂直线，其中的`rv.pmf`帮助计算各种`x`值时的概率。 `ax.legend`函数为图形添加了图例，最后`plt.show`显示了图形。 结果如下：
 
 ![A normal distribution from a binomial distribution](img/B03450_02_05.jpg)
 
@@ -179,7 +179,7 @@ array([1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0,
 
 ```
 
-NumPy 程序包具有一个具有正态函数的随机模块，其中 50 是分布的平均值，10 是分布的标准差，60 是要生成的值的数量。 您可以使用以下命令绘制正态分布：
+NumPy 包具有一个具有正态函数的随机模块，其中 50 是分布的平均值，10 是分布的标准差，60 是要生成的值的数量。 您可以使用以下命令绘制正态分布：
 
 ```py
 >>> plt.hist(classscore, 30, normed=True) #Number of breaks is 30
@@ -568,7 +568,7 @@ T 检验用于将总体平均值与样本进行比较，或在样本量小于 30
 
 ```
 
-要执行 T 检验，我们可以使用 SciPy 软件包中的`ttest_ind()`函数：
+要执行 T 检验，我们可以使用 SciPy 包中的`ttest_ind()`函数：
 
 ```py
 >>> stats.ttest_ind(class1_score,class2_score)
@@ -647,7 +647,7 @@ F 统计量由以下公式给出：
 
 卡方检验中的零假设是观察值类似于预期值。
 
-可以使用 SciPy 软件包中的`chisquare`函数执行卡方：
+可以使用 SciPy 包中的`chisquare`函数执行卡方：
 
 ```py
 >>> stats.chisquare(observed,expected)
@@ -670,7 +670,7 @@ F 统计量由以下公式给出：
 | 640 | 90 | 200 | 350 | Women |
 | 920 | 150 | 320 | 450 |   |
 
-卡方独立性检验可以使用 SciPy 软件包中的`chi2_contingency`函数执行：
+卡方独立性检验可以使用 SciPy 包中的`chi2_contingency`函数执行：
 
 ```py
 >>> men_women = np.array([[100, 120, 60],[350, 200, 90]])

new/master-py-ds/03.md

@@ -262,7 +262,7 @@
 
 ## 在船上有家人的各个舱位中，非幸存者的分布是什么？
 
-为了回答这个问题，我们将使用以下代码再次绘制条形图，使用每个班级中每个都有家人的非幸存者的总数以及相对于乘客总数的百分比：
+为了回答这个问题，我们将使用以下代码再次绘制条形图，使用每个类别中每个都有家人的非幸存者的总数以及相对于乘客总数的百分比：
 
 ```py
 >>> #Checking for the null values

new/master-py-ds/04.md

@@ -117,7 +117,7 @@ Matplotlib 的一个非常有用的功能是，它使得绘制多个图很容易
 
 第一个参数取`x`轴值，第二个参数取`y`轴值。 第三个参数是需要添加到绘图中的文本。 乳胶表达式已用于在图中绘制`mu`平均值。
 
-可以使用注释命令来注释图表的某个部分。 带注释的命令将获取文本，需要指向的绘图部分的位置以及文本的位置：
+可以使用标注命令来标注图表的某个部分。 带标注的命令将获取文本，需要指向的绘图部分的位置以及文本的位置：
 
 ```py
 >>> ax = plt.subplot(111)
@@ -447,7 +447,7 @@ Matplotlib 库中的样式包使更改绘图图的样式更加容易。 更改
 
 ![A scatter plot matrix](img/B03450_04_19.jpg)
 
-`scatter_matrix()`功能有助于绘制上图。 它接受数据帧对象和定义用于自定义绘图的必需参数。 您可能已经观察到对角线图被定义为直方图，这意味着在绘图矩阵中变量与其自身相对的部分中，绘制了直方图。
+`scatter_matrix()`函数有助于绘制上图。 它接受数据帧对象和定义用于自定义绘图的必需参数。 您可能已经观察到对角线图被定义为直方图，这意味着在绘图矩阵中变量与其自身相对的部分中，绘制了直方图。
 
 除了直方图，我们还可以使用对角线的核密度估计：
 
@@ -507,7 +507,7 @@ Matplotlib 库中的样式包使更改绘图图的样式更加容易。 更改
 
 # 六边形图
 
-可以使用`DataFrame.plot()`功能和`kind = 'hexbin'`创建六边形图。 如果您的散点图过于密集而无法解释，则这种图非常有用。 它有助于对图表的空间区域和颜色强度进行装箱，可以将六边形解释为更集中在该区域的点。
+可以使用`DataFrame.plot()`函数和`kind = 'hexbin'`创建六边形图。 如果您的散点图过于密集而无法解释，则这种图非常有用。 它有助于对图表的空间区域和颜色强度进行装箱，可以将六边形解释为更集中在该区域的点。
 
 以下代码有助于绘制六边形箱图，并且代码的结构类似于前面讨论的图：
 
@@ -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`度角的视图：
 

new/master-py-ds/06.md

@@ -254,12 +254,12 @@ Coefficient value of the height is [ 1.00092142]
 
 ```
 
-我们首先使用`b_data`的`values.copy()`将数据帧转换为数组结构。 然后，我们使用 SciKit 中`cross_validation`的`train_test_split`功能将数据分为 80% 的数据训练和测试集。
+我们首先使用`b_data`的`values.copy()`将数据帧转换为数组结构。 然后，我们使用 SciKit 中`cross_validation`的`train_test_split`函数将数据分为 80% 的数据训练和测试集。
 
-我们将学习如何使用以下程序包构建线性回归模型：
+我们将学习如何使用以下包构建线性回归模型：
 
 *   statsmodels 模块
-*   SciKit 软件包
+*   SciKit 包
 
 甚至 Pandas 都提供了**普通最小二乘**（**OLS**）回归，您可以在完成本章之后进行尝试。 普通最小二乘法是一种估算未知系数和回归方程截距的方法。 我们将从 statsmodels 包开始。 **统计模型**是一个 Python 模块，允许用户浏览数据，估计统计模型和执行统计测试。 描述性统计信息，统计检验，绘图函数和结果统计信息的广泛列表适用于不同类型的数据和每个估计量：
 
@@ -368,7 +368,7 @@ Intercept is 15.5129271596
 
 ![Training and testing a model](img/3450_06_15.jpg)
 
-系数和截距类似于使用 statsmodels 软件包构建的模型。
+系数和截距类似于使用 statsmodels 包构建的模型。
 
 为了计算 SciKit 中的 R 平方，使用了 SciKit 包的交叉验证模块：
 
@@ -389,7 +389,7 @@ array([-0.3043391 , -0.42402161,  0.26890649])
 
 ```
 
-我们在这里使用了 SciKit 软件包的`mean_squared_error`功能。
+我们在这里使用了 SciKit 包的`mean_squared_error`函数。
 
 最后，实际图与预测图将与 statsmodels 的第一个模型图相同：
 

new/master-py-ds/07.md

@@ -60,7 +60,7 @@
 
 在前面的代码中，我们删除了`Ticket`，`Cabin`和`Name`列，然后删除了缺少的值。
 
-我们将使用名为 Patsy 的 Python 软件包，该软件包有助于描述统计模型。 它有助于定义与 R 相似的因变量和自变量公式。在`~`左侧定义的变量是因变量，在其右侧定义的变量是自变量。 `C()`中包含的变量被视为分类变量。
+我们将使用名为 Patsy 的 Python 包，该包有助于描述统计模型。 它有助于定义与 R 相似的因变量和自变量公式。在`~`左侧定义的变量是因变量，在其右侧定义的变量是自变量。 `C()`中包含的变量被视为分类变量。
 
 现在，我们将根据数据创建训练和测试集：
 
@@ -261,7 +261,7 @@ Area under the ROC curve : 0.879934
 
 因此，误报率告诉我们，在所有未幸存的人中，有百分之几被预测为幸存。 真实阳性率告诉我们，在所有幸存的人中，有百分之多少被预测为幸存了。 理想情况下，假阳性率应低，真阳性率应高。
 
-通过将 TPR 和 FPR 设置为不同的阈值，然后将它们相互绘制，可以创建`roc_curve`功能。
+通过将 TPR 和 FPR 设置为不同的阈值，然后将它们相互绘制，可以创建`roc_curve`函数。
 
 `roc_curve`函数在不同的阈值下给出假阳性率和真阳性率，这将用于绘制 ROC 曲线：
 
@@ -315,7 +315,7 @@ Area under the ROC curve : 0.879934
 
 ![Model building and evaluation with SciKit](img/B03450_07_14.jpg)
 
-第一列包含我们的因变量名称，第二列包含系数值。 我们可以看到，我们的预测变量的系数与使用 statsmodels 软件包构建的模型相似但不相同。
+第一列包含我们的因变量名称，第二列包含系数值。 我们可以看到，我们的预测变量的系数与使用 statsmodels 包构建的模型相似但不相同。
 
 让我们看看我们的精确度和召回率是如何表现的：
 

new/master-py-ds/11.md

@@ -77,7 +77,7 @@
 
 ![Preprocessing data](img/B03450_11_03.jpg)
 
-我们需要下载并安装`nltk`的`stopwords`软件包，可以使用以下命令来完成：
+我们需要下载并安装`nltk`的`stopwords`包，可以使用以下命令来完成：
 
 ```py
 >>> import nltk
@@ -518,7 +518,7 @@ Actual: of  Lemma: of
 
 # 使用 Twitter 对世界领导人执行情感分析
 
-在开始分析推文之前，我们需要安装 Python 的`Twython`软件包，该软件包有助于与 Twitter API 进行交互以从 Twitter 获取推文。 可以从[这个页面](https://github.com/ryanmcgrath/twython)下载。
+在开始分析推文之前，我们需要安装 Python 的`Twython`包，该包有助于与 Twitter API 进行交互以从 Twitter 获取推文。 可以从[这个页面](https://github.com/ryanmcgrath/twython)下载。
 
 另外，您需要从[这个页面](https://apps.twitter.com/app/new)获取使用者密钥和使用者秘密密钥。
 

new/py-ds-essentials/2.md

@@ -275,7 +275,7 @@ In:  print (iris_iterator.get_chunk(10).shape) Out: (10, 5) In:  print (iris_ite
 
 在此示例中，我们首先定义了迭代器。 接下来，我们检索了一条包含 10 行的数据。 然后，我们又获得了 20 行，最后得到了最后打印的两行。
 
-除 Pandas 外，您还可以使用 CSV 软件包，该软件包提供了两个功能来迭代文件中的小块数据：`reader`和`DictReader`函数。 让我们通过导入 CSV 包来说明这些功能：
+除 Pandas 外，您还可以使用 CSV 包，该包提供了两个功能来迭代文件中的小块数据：`reader`和`DictReader`函数。 让我们通过导入 CSV 包来说明这些功能：
 
 ```py
 In:import csv  
@@ -285,7 +285,7 @@ In:import csv
 
 以本机方式读取列表不是限制。 例如，使用快速的 Python 实现（例如 PyPy）来加速代码会更容易。 此外，我们始终可以将列表转换为 NumPy `ndarrays`（我们即将介绍的数据结构）。 通过将数据读取为 JSON 样式的字典，将很容易获得`DataFrame`。
 
-这是一个使用 CSV 软件包中的此类功能的简单示例。
+这是一个使用 CSV 包中的此类功能的简单示例。
 
 让我们假设从[这个页面](http://mldata.org/)下载的`datasets-uci-iris.csv`文件是一个巨大的文件，我们无法将其完全加载到内存中（实际上，我们只是假装，这种情况是因为我们记得我们在本章的开头看到了该文件；它仅由 150 个示例组成，并且 CSV 缺少标题行）。
 
@@ -366,7 +366,7 @@ In: import numpy as np
 
 到目前为止，我们仅处理 CSV 文件。 为了加载 MS Excel，HDFS，SQL，JSON，HTML 和 Stata 数据集，Pandas 包提供了类似的功能（和功能）。 由于这些格式中的大多数格式在数据科学中并未常规使用，因此大多数人只能了解如何加载和处理每种格式，您可以参考 [Pandas 网站上的可用文档](http://pandas.pydata.org/pandas-docs/version/0.16/io.html)。 在这里，我们将仅演示如何有效地使用磁盘空间以快速有效的方式存储和检索机器学习算法信息的要点。 在这种情况下，您可以利用 [SQLite 数据库](https://www.sqlite.org/index.html)来访问特定的信息子集并将其转换为 Pandas `DataFrame`。 如果您不需要对数据进行特定的选择或过滤，但是唯一的问题是从 CSV 文件读取数据非常耗时，并且每次都需要很多工作（例如，设置正确的变量类型和名称），则可以使用 [HDF5 数据结构](https://support.hdfgroup.org/HDF5/whatishdf5.html)来加快保存和加载数据的速度。
 
-在第一个示例中，我们将使用 SQLite 和 SQL 语言存储一些数据并检索其过滤后的版本。 与其他数据库相比，SQLite 具有许多优点：它是独立的（所有数据都将存储在一个文件中），无服务器（Python 将提供存储，操作和访问数据的接口）且速度很快。 导入`sqlite3`程序包（它是 Python 栈的一部分，因此无论如何都不需要安装）后，您定义了两个查询：一个删除同名的先前数据表，另一个创建一个新表，它能够保留日期，城市，温度和目的地数据（并且您使用整数，浮点数和`varchar`类型，它们对应于`int`，`float`和`str`）。
+在第一个示例中，我们将使用 SQLite 和 SQL 语言存储一些数据并检索其过滤后的版本。 与其他数据库相比，SQLite 具有许多优点：它是独立的（所有数据都将存储在一个文件中），无服务器（Python 将提供存储，操作和访问数据的接口）且速度很快。 导入`sqlite3`包（它是 Python 栈的一部分，因此无论如何都不需要安装）后，您定义了两个查询：一个删除同名的先前数据表，另一个创建一个新表，它能够保留日期，城市，温度和目的地数据（并且您使用整数，浮点数和`varchar`类型，它们对应于`int`，`float`和`str`）。
 
 打开数据库（此时已创建，如果尚未在磁盘上创建的数据库）之后，执行两个查询，然后提交更改（通过提交，[实际上是在一个批量中开始执行所有先前的数据库命令](https://www.sqlite.org/atomiccommit.html)）：
 
@@ -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 文件：
 
@@ -455,7 +455,7 @@ In: my_wrong_own_dataset = pd.DataFrame({'Col1': range(5),
      ValueError: arrays must all be same length 
 ```
 
-为了组装整个现有的`DataFrame`，您必须使用基于连接的其他方法。 Pandas 软件包提供了`concat`命令，该命令通过在轴`0`（默认选项）上工作时堆叠行或在轴`1`上连接时堆叠列来对 Pandas 数据结构（`Series`和`DataFrame`）进行操作：
+为了组装整个现有的`DataFrame`，您必须使用基于连接的其他方法。 Pandas 包提供了`concat`命令，该命令通过在轴`0`（默认选项）上工作时堆叠行或在轴`1`上连接时堆叠列来对 Pandas 数据结构（`Series`和`DataFrame`）进行操作：
 
 ```py
 In: col5 = pd.Series([4, 3, 2, 1, 0])
@@ -679,7 +679,7 @@ In: def square(x):
 
 由于使用 Jupyter 时 Windows 中存在多处理问题，因此以下示例只能在 Linux 机器上运行，或者如果转换为脚本后只能在 Windows 机器上运行，[正如以下 Stack Overflow 答案所建议的那样](https://stackoverflow.com/questions/37103243/multiprocessing-pool-in-jupyter-notebook-works-on-linux-but-not-windows)。
 
-为了缩短此类计算延迟，您可以通过创建`parallel_apply`函数来利用多处理程序包。 这样的函数将一个`DataFrame`，一个函数以及该函数的参数作为输入，并创建一个工作池（许多 Python 复制内存中，理想情况下每个线程都在系统的不同 CPU 上运行） 并行执行所需的转换：
+为了缩短此类计算延迟，您可以通过创建`parallel_apply`函数来利用多处理包。 这样的函数将一个`DataFrame`，一个函数以及该函数的参数作为输入，并创建一个工作池（许多 Python 复制内存中，理想情况下每个线程都在系统的不同 CPU 上运行） 并行执行所需的转换：
 
 ```py
 In: import multiprocessing
@@ -704,7 +704,7 @@ In: squared_iris = parallel_apply(iris[['sepal_length', 'sepal_width',
 
 # 数据选择
 
-我们将关注的关于 Pandas 的最后一个主题是数据选择。 让我们从一个例子开始。 我们可能遇到数据集包含索引列的情况。 我们如何正确地将其与 Pandas 一起进口？ 然后，我们可以积极利用它来简化我们的工作吗？
+我们将关注的关于 Pandas 的最后一个主题是数据选择。 让我们从一个例子开始。 我们可能遇到数据集包含索引列的情况。 我们如何正确地将其与 Pandas 一起导入？ 然后，我们可以积极利用它来简化我们的工作吗？
 
 我们将使用一个非常简单的数据集，其中包含一个索引列（这只是一个计数器而不是功能）。 为了使示例更加通用，让我们从 100 开始索引。因此，行号`0`的索引为`100`：
 
@@ -794,7 +794,7 @@ In: dataset.iloc[range(2), [2,1]]
 
 分类和数值的加号是布尔值。 实际上，它们可以看作是分类的（特征的存在/不存在），或者另一方面，可以认为特征具有展览（已显示，未显示）的概率。 由于许多机器学习算法不允许将输入分类，因此布尔特征通常用于将分类特征编码为数值。
 
-让我们继续以天气为例。 如果要映射包含当前天气并采用集合`[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]  
@@ -802,7 +802,7 @@ Categorical_feature = sunny   binary_features = [1, 0, 0, 0, 0] Categorical_feat
 
 只有一个二元特征揭示了分类特征的存在。 其他保持`0`。 这称为二进制编码或一种热编码。 通过执行此简单步骤，我们从分类世界转移到了数字世界。 此操作的代价是它在内存和计算方面的复杂性； 现在，我们有五个功能，而不是单个功能。 通常，我们将创建`N`个特征，而不是具有`N`个可能水平的单个分类特征，每个特征都有两个数值（1/0）。 该操作称为伪编码。
 
-Pandas 软件包可帮助我们完成此操作，只需一个命令即可简化映射：
+Pandas 包可帮助我们完成此操作，只需一个命令即可简化映射：
 
 ```py
 In: import pandas as pd
@@ -1118,7 +1118,7 @@ In: section = soup.find_all(id='mw-normal-catlinks')[0]
 
 作为最佳实践，我们建议您在数据仍然是异构的（数字和符号值的混合）工作阶段和将其转换为数据数字表的另一个阶段之间划分任务。 数据表或矩阵排列在代表示例的行中，而列则包含示例的特征观察值（即变量）。
 
-根据我们的建议，您必须在两个用于科学分析的关键 Python 软件包 Pandas 和 NumPy 之间进行纠缠，并在它们的两个关键数据结构`DataFrame`和`ndarray`之间进行权衡。 这意味着您的数据科学管道将更加高效，快捷。
+根据我们的建议，您必须在两个用于科学分析的关键 Python 包 Pandas 和 NumPy 之间进行纠缠，并在它们的两个关键数据结构`DataFrame`和`ndarray`之间进行权衡。 这意味着您的数据科学管道将更加高效，快捷。
 
 由于我们要馈入下一个机器学习阶段的目标数据结构是由`NumPy ndarray`对象表示的矩阵，因此让我们从要获得的结果开始，即如何生成`ndarray`对象。
 
@@ -1161,7 +1161,7 @@ Python 列表数据结构实际上更麻烦，更慢，它是将列表结构链
 
 无论 NumPy 数组的尺寸如何，数据始终将按连续的值序列（连续的内存块）进行排列。 正是对数组大小和步幅（告诉我们必须在内存中跳过多少字节才能沿着某个轴移至下一个位置）的跨度知识，才能轻松正确地表示和操作数组。
 
-为了快速实现内存优化，为了存储多维数组，严格地有两种方法称为**行优先**和**列优先**。 由于 **RAM**（**随机存取存储器**）被安排在存储单元的线性存储中（存储单元作为一条线的点是连续的– RAM 中没有像数组这样的东西 ），您必须将阵列展开为向量并将其存储在内存中。 展开时，您可以在 NumPy 软件包中逐行（主要顺序）执行 C/C++ 的典型操作，或者逐列（主要顺序执行）的 Fortran 或 R.Python 的典型操作。 在实现中，使用主要行排序（也称为 C 连续，而主要列排序也称为 Fortran 连续），这意味着在逐行应用的计算操作中，它比逐列工作更快。 无论如何，在创建 NumPy 数组时，您可以根据对行或列进行更多操作的期望来确定数据结构的顺序。 导入软件包`import numpy as np`后，给定数组`a = [[1,2,3],[4,5,6],[7,8,9]]`，您可以按行优先顺序`c = np.array(a, order='C')`或按列优先顺序`f = np.array(a, order='F')`重新定义它
+为了快速实现内存优化，为了存储多维数组，严格地有两种方法称为**行优先**和**列优先**。 由于 **RAM**（**随机存取存储器**）被安排在存储单元的线性存储中（存储单元作为一条线的点是连续的– RAM 中没有像数组这样的东西 ），您必须将阵列展开为向量并将其存储在内存中。 展开时，您可以在 NumPy 包中逐行（主要顺序）执行 C/C++ 的典型操作，或者逐列（主要顺序执行）的 Fortran 或 R.Python 的典型操作。 在实现中，使用主要行排序（也称为 C 连续，而主要列排序也称为 Fortran 连续），这意味着在逐行应用的计算操作中，它比逐列工作更快。 无论如何，在创建 NumPy 数组时，您可以根据对行或列进行更多操作的期望来确定数据结构的顺序。 导入包`import numpy as np`后，给定数组`a = [[1,2,3],[4,5,6],[7,8,9]]`，您可以按行优先顺序`c = np.array(a, order='C')`或按列优先顺序`f = np.array(a, order='F')`重新定义它
 
 相反，代表多个维度的数据结构列表只能将自己变成嵌套列表，从而增加访问数据时的开销和内存碎片。
 
@@ -1657,7 +1657,7 @@ NumPy 还提供了一个对象类矩阵，它实际上是`ndarray`的子类，
 
 除了以类似于 MATLAB 的方式进行操作带来的便利之外，它们没有提供任何其他优势。 您可能会有脚本混乱的风险，因为您必须为矩阵对象和数组处理不同的产品表示法。
 
-从 Python 3.5 开始，Python 中引入了一个新的运算符`@`（AT）运算符，专门用于矩阵乘法（更改适用于 Python 中的所有软件包，而不仅仅是 NumPy）。 引入此新运算符会带来很多好处。
+从 Python 3.5 开始，Python 中引入了一个新的运算符`@`（AT）运算符，专门用于矩阵乘法（更改适用于 Python 中的所有包，而不仅仅是 NumPy）。 引入此新运算符会带来很多好处。
 首先，不会再有`*`运算符用于矩阵乘法的情况了。 `*`运算符将仅用于按元素的操作（在具有相同维的两个矩阵（或向量）的情况下，您将操作应用于两个矩阵中具有相同位置的元素之间的运算）。
 然后，表示公式的代码将具有更高的可读性，因此变得更易于阅读和解释。 您将不再需要一起评估运算符（`+ - / *`）和方法（`.`），只需评估运算符（`+ - / * @`）。
 您可以了解有关此介绍的更多信息（这只是形式上的-使用`.dot`方法可与`@`运算符一起使用之前可以应用的所有内容），并通过阅读 **Python** 查看一些应用示例。 [Python 基金会网站上的**增强提案**（**PEP465**）](https://www.python.org/dev/peps/pep-0465/)。

new/py-ds-essentials/4.md

 # 机器学习
 
-在说明了数据科学项目中的所有数据准备步骤之后，我们终于到达了学习阶段，在此阶段应用了学习算法。 为了向您介绍 Scikit-learn 和其他 Python 软件包中现成的最有效的机器学习工具，我们准备了所有主要算法系列的简要介绍。 我们使用超参数示例和技巧来完成此过程，以确保获得最佳结果。
+在说明了数据科学项目中的所有数据准备步骤之后，我们终于到达了学习阶段，在此阶段应用了学习算法。 为了向您介绍 Scikit-learn 和其他 Python 包中现成的最有效的机器学习工具，我们准备了所有主要算法系列的简要介绍。 我们使用超参数示例和技巧来完成此过程，以确保获得最佳结果。
 
 在本章中，我们将介绍以下主题：
 
@@ -17,7 +17,7 @@
 
 # 准备工具和数据集
 
-如前几章所述，用于机器学习的 Python 软件包是 Scikit-learn。 在本章中，我们还将使用 XGboost，LightGBM 和 Catboost：您将在相关部分中找到说明。
+如前几章所述，用于机器学习的 Python 包是 Scikit-learn。 在本章中，我们还将使用 XGboost，LightGBM 和 Catboost：您将在相关部分中找到说明。
 
 法国计算机科学与自动化研究所 [Inria](https://www.inria.fr/en/) 开发的 Scikit-learn 的使用动机是多种多样的。 在这一点上，有必要提及使用 Scikit-learn 成功实现数据科学项目的最重要原因：
 
@@ -64,7 +64,7 @@ In: import pickle
                                     "newsgroups_dataset.pickle", "wb"))
 ```
 
-如果下载程序的任何部分对您不起作用，我们将为您直接下载数据集。 获取压缩的 zip 软件包后，您要做的就是将其数据解压缩到当前工作的 Python 目录中，您可以通过使用以下命令在 Python 界面（Jupyter 笔记本电脑或任何 Python IDE）上运行来找到该目录：
+如果下载程序的任何部分对您不起作用，我们将为您直接下载数据集。 获取压缩的 zip 包后，您要做的就是将其数据解压缩到当前工作的 Python 目录中，您可以通过使用以下命令在 Python 界面（Jupyter 笔记本电脑或任何 Python IDE）上运行来找到该目录：
 
 ```py
 In: import os
@@ -172,7 +172,7 @@ y_pred[i] = sign(X[i] * W)
 
 在上面的公式中，您具有：`logistic(α) = exp(α) / (1 + exp(α))`。
 
-为什么`logistic`功能而不是其他功能？ 好吧，因为它在大多数实际情况下都很好用。 在其余情况下，如果您对其结果不完全满意，则可能需要尝试其他一些非线性函数（不过，合适的函数种类有限）。
+为什么`logistic`函数而不是其他功能？ 好吧，因为它在大多数实际情况下都很好用。 在其余情况下，如果您对其结果不完全满意，则可能需要尝试其他一些非线性函数（不过，合适的函数种类有限）。
 
 # 朴素贝叶斯
 
@@ -499,7 +499,7 @@ In: import pickle
 
 **粘贴**是我们将讨论的第一类平均集成。 在粘贴过程中，使用从数据中获取的小样本来构建一定数量的估算器（使用不替换的样本）。 最后，将结果汇总起来，通过对结果进行平均（在回归的情况下）或在处理分类时采用投票率最高的类别来获得估计值。 当处理非常大的数据时（例如无法容纳到内存中的情况），粘贴非常有用，因为它只允许处理计算机的可用 RAM 和计算资源可管理的那些数据部分。
 
-作为一种方法，随机森林算法的创建者 Leo Breiman 首先设计了这种策略。 尽管可以通过使用可用的装袋算法（下段主题`BaggingClassifier`或`BaggingRegressor`，并将其`bootstrap`设置为）轻松实现，但 Scikit-learn 软件包中没有使用粘贴的特定算法。 `False`和`max_features`设为 1.0。
+作为一种方法，随机森林算法的创建者 Leo Breiman 首先设计了这种策略。 尽管可以通过使用可用的装袋算法（下段主题`BaggingClassifier`或`BaggingRegressor`，并将其`bootstrap`设置为）轻松实现，但 Scikit-learn 包中没有使用粘贴的特定算法。 `False`和`max_features`设为 1.0。
 
 # 弱分类器的装袋
 
@@ -836,7 +836,7 @@ IO 参数定义如何加载（甚至由模型存储）数据：
 
 在过拟合的情况下，您可以尝试设置`lambda_l1`，`lambda_l2`和`min_gain_to_split`并获得更多的正则化。 您也可以尝试`max_depth`避免生长过深的树木。
 
-在我们的示例中，我们承担与之前相同的任务，以对 Forest Covertype 数据集进行分类。 我们首先导入必要的软件包。
+在我们的示例中，我们承担与之前相同的任务，以对 Forest Covertype 数据集进行分类。 我们首先导入必要的包。
 
 接下来，下一步是为该增强算法设置参数以使其正常工作。 我们定义目标（'`multiclass`'），设置较低的学习率（0.01），并允许其分支几乎完全像随机森林一样散布：其树的最大深度设置为 128，并且结果数 leaves 是 256。为此，我们还对情况和特征都进行了随机抽样（每次将其中的 90% 装袋）：
 
@@ -988,7 +988,7 @@ In: from sklearn.metrics import accuracy_score, confusion_matrix
 
 # 处理大数据
 
-大数据将数据科学项目置于四个角度：数量（数据量），速度，多样性和准确性（您的数据是否真正代表了它应该是什么，还是受到一些偏见，失真或错误的影响？）。 Scikit-learn 软件包提供了一系列类和函数，可以帮助您有效地处理如此大的数据，以至于无法完全容纳在标准计算机的内存中。
+大数据将数据科学项目置于四个角度：数量（数据量），速度，多样性和准确性（您的数据是否真正代表了它应该是什么，还是受到一些偏见，失真或错误的影响？）。 Scikit-learn 包提供了一系列类和函数，可以帮助您有效地处理如此大的数据，以至于无法完全容纳在标准计算机的内存中。
 
 在向您提供大数据解决方案概述之前，我们必须创建或导入一些数据集，以便使您更好地了解不同算法的可伸缩性和性能。 这将需要约 1.5 GB 的硬盘空间，实验后将释放该硬盘空间。
 （本身不是大数据-如今，很难找到内存少于 4 GB 的计算机-但是，甚至没有玩具数据集，它也应该提供一些想法）。
@@ -1229,7 +1229,7 @@ In: New_text = ["A 2014 red Toyota Prius v Five with fewer than 14K" +
 
 # 窥探自然语言处理（NLP）
 
-本节与机器学习不是严格相关的，但它包含自然语言处理领域的一些机器学习结果。 Python 有许多处理文本数据的程序包，用于文本处理的功能最强大且最完整的工具箱之一是 **NLTK**，即自然语言工具箱。
+本节与机器学习不是严格相关的，但它包含自然语言处理领域的一些机器学习结果。 Python 有许多处理文本数据的包，用于文本处理的功能最强大且最完整的工具箱之一是 **NLTK**，即自然语言工具箱。
 
 适用于 Python 社区的其他 NLP 工具包是 [gensim](https://radimrehurek.com/gensim/) 和 [spaCy](https://spacy.io/)。
 
@@ -1266,7 +1266,7 @@ In: import nltk
       'coolest', 'job', 'of', 'the', '1990s', '?']
 ```
 
-在执行此调用或其他一些 NLTK 程序包调用时，如果出现错误消息`"Resource u'tokenizers/punkt/english.pickle' not found."`，只需在控制台上键入`nltk.download()`并选择下载所有内容或浏览触发警告的丢失资源。
+在执行此调用或其他一些 NLTK 包调用时，如果出现错误消息`"Resource u'tokenizers/punkt/english.pickle' not found."`，只需在控制台上键入`nltk.download()`并选择下载所有内容或浏览触发警告的丢失资源。
 
 在这里，质量更好，并且每个令牌都与文本中的一个单词相关联。
 
@@ -1556,7 +1556,7 @@ In: K_dataset_2 = 4
 
 正如预期的那样，绘制的结果很好。 质心和聚类正是我们在查看未标记数据集时所想到的。 现在，我们将检查是否有其他聚类方法可以帮助我们解决非球形聚类问题。
 
-在实际情况下，您可以考虑使用轮廓系数来了解群集的定义良好程度。 它是组内一致性的评估指标，适用于各种聚类结果，甚至适用于监督学习中的班级结构。 您可以在[这个页面](http://scikit-learn.org/stable/modules/clustering.html#silhouette-coefficient)上了解有关剪影系数的更多信息。
+在实际情况下，您可以考虑使用轮廓系数来了解群集的定义良好程度。 它是组内一致性的评估指标，适用于各种聚类结果，甚至适用于监督学习中的类别结构。 您可以在[这个页面](http://scikit-learn.org/stable/modules/clustering.html#silhouette-coefficient)上了解有关剪影系数的更多信息。
 
 # DBSCAN ——一种基于密度的聚类技术
 
@@ -1646,7 +1646,7 @@ In: word_dic.filter_extremes(no_below=10, no_above=0.2)
     bow = [word_dic.doc2bow(doc) for doc in processed_docs]
 ```
 
-最后，这是 LDA 的核心课程。 在此示例中，我们指示 LDA 在数据集中只有两个主题。 我们还提供了其他参数来使算法收敛（如果不收敛，您将收到 Python 解释器的警告）。 请注意，此算法可在计算机上的许多 CPU 上使用，以加快处理速度。 如果它不起作用，请使用具有相同参数的单进程类`gensim.models.ldamodel.LdaModel`：
+最后，这是 LDA 的核心类。 在此示例中，我们指示 LDA 在数据集中只有两个主题。 我们还提供了其他参数来使算法收敛（如果不收敛，您将收到 Python 解释器的警告）。 请注意，此算法可在计算机上的许多 CPU 上使用，以加快处理速度。 如果它不起作用，请使用具有相同参数的单进程类`gensim.models.ldamodel.LdaModel`：
 
 ```py
 In: lda_model = gensim.models.LdaMulticore(bow, num_topics=2, 

new/py-ds-essentials/5.md

@@ -4,7 +4,7 @@
 
 在本章中，您将学习如何执行以下操作：
 
-*   使用`matplotlib`程序包中的基本`pyplot`功能
+*   使用`matplotlib`包中的基本`pyplot`函数
 *   利用 Pandas `DataFrame`进行**探索性数据分析**（**EDA**）
 *   与 Seaborn 一起创建漂亮的交互式图表
 *   可视化我们在第 3 章，“数据管道”和第 4 章，“机器学习”中讨论的
@@ -20,7 +20,7 @@
 
 取而代之的是，我们可以提供一系列快速，重要的基本秘籍，使您可以开始使用 Python 进行可视化，并且可以在需要创建特定图形图表时随时参考。 将所有代码片段都视为可视化构建块； 您只需使用我们将为您提供的大量参数，就可以为它们安排不同的配置和功能。
 
-`matplotlib`是用于绘制图形的 Python 软件包。 它是由约翰·亨特（John Hunter）创建的，旨在解决 Python 与具有图形功能（例如 MATLAB 或 gnuplot）的外部软件之间缺乏集成的问题。 `matplotlib`在很大程度上受到 MATLAB 的操作方式和功能的影响，其语法非常相似。 特别是，与 MATLAB 完全兼容的`matplotlib.pyplot`模块将成为我们介绍所有必要的图形工具以表示数据和分析的基本介绍的核心。 MATLAB 确实是数据分析和科学界可视化的标准，因为它在探索性分析方面具有公认的功能，这主要是因为它具有平滑且易于使用的绘图功能。
+`matplotlib`是用于绘制图形的 Python 包。 它是由约翰·亨特（John Hunter）创建的，旨在解决 Python 与具有图形功能（例如 MATLAB 或 gnuplot）的外部软件之间缺乏集成的问题。 `matplotlib`在很大程度上受到 MATLAB 的操作方式和功能的影响，其语法非常相似。 特别是，与 MATLAB 完全兼容的`matplotlib.pyplot`模块将成为我们介绍所有必要的图形工具以表示数据和分析的基本介绍的核心。 MATLAB 确实是数据分析和科学界可视化的标准，因为它在探索性分析方面具有公认的功能，这主要是因为它具有平滑且易于使用的绘图功能。
 
 每个`pyplot`命令都会对最初实例化的图形进行更改。 设置图形后，所有其他命令都将在该图形上运行。 因此，很容易逐步改进和丰富您的图形表示。 为了使您能够利用代码并能够根据需要进行个性化设置，以下所有示例均与注释的构建块一起提供，以便您以后可以起草基本表示形式，然后在本章中查找特定的参数。 在示例中，以按计划改进图表。
 
@@ -34,7 +34,7 @@ In: import numpy as np
     import matplotlib as mpl  
 ```
 
-这样，我们始终可以将 MATLAB 风格的模块`pyplot`称为`plt`，并在`mpl`的帮助下访问完整的`matplotlib`功能集。
+这样，我们始终可以将 MATLAB 风格的模块`pyplot`称为`plt`，并在`mpl`的帮助下访问完整的`matplotlib`函数集。
 
 如果您正在使用 Jupyter 笔记本（或 Jupyter Lab），则可以使用以下行魔术：`%matplotlib`内联。 在笔记本的单元格中写入命令并运行命令后，您可以直接在笔记本本身上绘制绘图，而不必在单独的窗口中显示图形（默认情况下，`matplotlib`的 GUI 后端是`TkAgg`后端）。 如果您更喜欢 [Qt](https://www.qt.io/) 等通常随 Python 科学发行版一起分发的后端，则只需运行以下行魔术：`%matplotlib` Qt。
 
@@ -326,7 +326,7 @@ In: import pandas as pd
 
 以下段落中介绍的所有示例都将使用`iris_df DataFrame`。
 
-`pandas`软件包实际上依赖于 Matplotlib 函数进行可视化。 它只是为其他复杂的绘图指令提供了一个方便的包装器。 这在速度和简便性方面具有优势，这是任何 EDA 过程的核心价值。 相反，如果您的目的是通过使用精美的可视化效果最好地传达发现，您可能会注意到自定义 Pandas 图形输出并不是那么容易。 因此，当最重要的是要创建特定的图形输出时，最好使用 Matplotlib 指令从头开始直接工作。
+`pandas`包实际上依赖于 Matplotlib 函数进行可视化。 它只是为其他复杂的绘图指令提供了一个方便的包装器。 这在速度和简便性方面具有优势，这是任何 EDA 过程的核心价值。 相反，如果您的目的是通过使用精美的可视化效果最好地传达发现，您可能会注意到自定义 Pandas 图形输出并不是那么容易。 因此，当最重要的是要创建特定的图形输出时，最好使用 Matplotlib 指令从头开始直接工作。
 
 # 使用箱线图和直方图
 
@@ -439,12 +439,12 @@ In: from pandas.tools.plotting import parallel_coordinates
 
 正如我们在上一段中所看到的那样，Pandas 可以将可视化的数据浏览速度提高，因为它可以打包成单个命令，而使用 Matplotlib 则需要完整的代码片段。 其背后的想法是，除非需要定制和配置特殊的可视化效果，否则使用包装器可以使您更快地创建标准图形。
 
-除 Pandas 外，其他软件包还将来自 Matplotlib 的低级指令组装为更用户友好的命令，以用于特定的表示形式和用法：
+除 Pandas 外，其他包还将来自 Matplotlib 的低级指令组装为更用户友好的命令，以用于特定的表示形式和用法：
 
-*   Seaborn 是一个软件包，它通过为您提供一组统计图来扩展趋势图和区分组的功能，从而扩展了您的可视化功能
+*   Seaborn 是一个包，它通过为您提供一组统计图来扩展趋势图和区分组的功能，从而扩展了您的可视化功能
 *   `ggplot`是流行的 R 库[`ggplot2`](https://ggplot2.tidyverse.org/)的端口，它基于 Leland Wilkinson 的书《图形语法》中提出的可视化语法。 R 库是不断开发的，它提供了很多功能； [Python 移植](http://ggplot.yhathq.com/)具有[基础知识](http://ggplot.yhathq.com/docs/index.html)，[并且其完整的开发工作仍在进行中](https://github.com/yhat/ggpy)。
 *   [MPLD3](http://mpld3.github.io/) 利用 JavaScript 库进行图形处理 D3.js，以便轻松地将任何 Matplotlib 输出转换为 HTML 代码，可以使用浏览器和工具（如 Jupyter 笔记本； 或在互联网网站中。
-*   [Bokeh](https://bokeh.pydata.org/en/latest/) 是一个交互式可视化程序包，它利用 JavaScript 和浏览器呈现的输出。 它是 D3.js 的理想替代品，因为您只需要 Python 即可利用 JavaScript 的功能以交互方式快速表示数据。
+*   [Bokeh](https://bokeh.pydata.org/en/latest/) 是一个交互式可视化包，它利用 JavaScript 和浏览器呈现的输出。 它是 D3.js 的理想替代品，因为您只需要 Python 即可利用 JavaScript 的功能以交互方式快速表示数据。
 
 在接下来的页面中，我们将介绍 Seaborn，并提供一些构建块以利用它们在您的数据科学项目中的可视化效果。
 
@@ -459,9 +459,9 @@ $> pip install seaborn
 $> conda install seaborn
 ```
 
-在这些示例中，我们使用了 Seaborn 软件包的 0.9 版。
+在这些示例中，我们使用了 Seaborn 包的 0.9 版。
 
-您可以通过以下方式上传软件包并将 Seaborn 样式设置为默认的 Matplotlib 样式：
+您可以通过以下方式上传包并将 Seaborn 样式设置为默认的 Matplotlib 样式：
 
 ```py
 In: import seaborn as sns 
@@ -610,7 +610,7 @@ In: new_palette=sns.color_palette('hls', 10)
 
 Seaborn 不仅使您的图表更加美观，而且在其方面也易于控制。 它还为您提供了用于 EDA 的新工具，可帮助您发现变量之间的分布和关系。
 
-在继续之前，让我们重新加载程序包，并以 Pandas `DataFrame`格式准备好 Iris 和波士顿数据集：
+在继续之前，让我们重新加载包，并以 Pandas `DataFrame`格式准备好 Iris 和波士顿数据集：
 
 ```py
 In: import seaborn as sns 
@@ -638,7 +638,7 @@ In: import seaborn as sns
 
 至于鸢尾花数据集，目标变量已转换为鸢尾花种类的描述性文本。 对于波士顿数据集，连续目标变量（自有住房的中位数）已分为三个相等的部分，分别代表较低，中位数和较高的价格（使用 Pandas 函数`qcut`）。
 
-Seaborn 首先可以找出离散值或分类变量与数字变量之间的关系，从而帮助您进行数据探索。 这可以通过`catplot`功能实现：
+Seaborn 首先可以找出离散值或分类变量与数字变量之间的关系，从而帮助您进行数据探索。 这可以通过`catplot`函数实现：
 
 ```py
 In: with sns.axes_style('ticks'): 
@@ -713,7 +713,7 @@ In: with sns.axes_style("darkgrid"):
 
 ![](img/b730fc3d-50ad-483e-9747-3db8e1d67418.png)
 
-至于评估跨班级的数据分布，Seaborn 提供了另一种工具，即[提琴图](https://medium.com/@bioturing/5-reasons-you-should-use-a-violin-graph-31a9cdf2d0c6)。 提琴图只是一个箱形图，其框是根据密度估计来成形的，因此可以直观地传达信息：
+至于评估跨类别的数据分布，Seaborn 提供了另一种工具，即[提琴图](https://medium.com/@bioturing/5-reasons-you-should-use-a-violin-graph-31a9cdf2d0c6)。 提琴图只是一个箱形图，其框是根据密度估计来成形的，因此可以直观地传达信息：
 
 ```py
 In: with sns.axes_style("whitegrid"):     
@@ -940,18 +940,18 @@ Bottle 是一个 Python 网络框架，是 HTTP 上微型应用的起点。 这
 1.  我们开始从 Bottle 模块中导入所需的功能和类。
 2.  然后，我们指定 HTTP 服务器将侦听的端口。
 3.  在示例中，我们选择端口`9099`； 您可以随意将其更改为另一个，但是首先请检查是否有其他服务正在使用它（请记住 HTTP 位于 TCP 之上）。
-4.  下一步是 API 端点的定义。 当对指定为参数的路径执行 HTTP 调用时，`route`装饰器将应用其后定义的功能。 请注意，在路径中，它表示`name`，这是即将到来的函数的参数。 这意味着`name`是呼叫的参数； 您可以在 HTTP 调用中选择所需的任何字符串，然后您的选择将作为参数名称传递给函数。
+4.  下一步是 API 端点的定义。 当对指定为参数的路径执行 HTTP 调用时，`route`装饰器将应用其后定义的功能。 请注意，在路径中，它表示`name`，这是即将到来的函数的参数。 这意味着`name`是调用的参数； 您可以在 HTTP 调用中选择所需的任何字符串，然后您的选择将作为参数名称传递给函数。
 5.  然后，在功能主页中，返回了带有 HTML 代码的模板。 以一种更简单的方式，将其视为`template`函数，该函数将创建您将从浏览器中看到的页面。
 
 **模板**，是一个示例，它只是一个普通的 HTML 页面，但它可能更复杂（它实际上可以是一个模板页面，其中需要填充一些空白）。 模板的完整描述超出了本节的范围，因为我们仅将框架用于简单的纯输出。 如果您需要其他信息，请浏览 Bottle 帮助页面。
 
-6.  最后，在`print`功能之后，有核心`run`功能。 这是一个阻止功能，它将在作为参数提供的主机和端口上设置 Web 服务器。 当您运行清单中的代码时，一旦执行了该功能，就可以打开浏览器并将其指向`http://localhost:9099/personal/Carl`，您将找到以下文本：`Hi Carl!`
+6.  最后，在`print`函数之后，有核心`run`函数。 这是一个阻止功能，它将在作为参数提供的主机和端口上设置 Web 服务器。 当您运行清单中的代码时，一旦执行了该功能，就可以打开浏览器并将其指向`http://localhost:9099/personal/Carl`，您将找到以下文本：`Hi Carl!`
 
 当然，将 HTTP 调用中的名称从`Carl`更改为`Tom`或任何其他名称将导致不同的页面，其中包含调用中指定的名称。
 
 请注意，在此虚拟示例中，我们仅定义了`/personal/<name>`路由。 除非代码中定义，否则任何其他调用都将导致`Error 404`。
 
-要关闭它，我们需要在命令行中按`Ctrl + C`（记住`run`功能正在阻止）。
+要关闭它，我们需要在命令行中按`Ctrl + C`（记住`run`函数正在阻止）。
 
 现在让我们创建一个更加面向数据科学的服务； 我们将创建一个 HTML 页面，该页面的表单要求隔垫的长度和宽度以及花瓣的长度和宽度，以对鸢尾花样本进行分类。 在此示例中，我们将使用鸢尾花数据集来训练 Scikit-learn 分类器。 然后，对于每个预测，我们只需在分类器上调用`predict`函数，将预测发送回去：
 
@@ -993,6 +993,6 @@ Bottle 是一个 Python 网络框架，是 HTTP 上微型应用的起点。 这
 
 # 总结
 
-本章通过提供数据，机器学习过程和结果的基本和高级图形表示的示例，概述了基本数据科学。 我们探索了来自 Matplotlib 的`pylab`模块，该模块可让您最轻松，最快地访问该软件包的图形功能。 我们将 Pandas 用于 EDA，并测试了 Scikit-learn 提供的图形工具。 所有示例都像构建块一样，并且都易于定制，以便为您提供快速的可视化模板。
+本章通过提供数据，机器学习过程和结果的基本和高级图形表示的示例，概述了基本数据科学。 我们探索了来自 Matplotlib 的`pylab`模块，该模块可让您最轻松，最快地访问该包的图形功能。 我们将 Pandas 用于 EDA，并测试了 Scikit-learn 提供的图形工具。 所有示例都像构建块一样，并且都易于定制，以便为您提供快速的可视化模板。
 
 在下一章中，将向您介绍**图**，它们是与预测变量/目标平坦矩阵的有趣偏差。 现在，它们已成为数据科学中的热门话题。 期望深入研究非常复杂和复杂的网络。
\ No newline at end of file

new/py-ds-essentials/7.md

@@ -9,7 +9,7 @@
 *   如何将预训练的网络用于分类和迁移学习
 *   如何将 LSTM 用于序列操作
 
-我们将使用 [Keras 软件包](https://keras.io/)，这是用于深度学习的高级 API，它将使用于深度学习的神经网络更加容易和易于理解，因为其特点是类似于乐高的方法（这里的积木是神经网络的组成元素）。
+我们将使用 [Keras 包](https://keras.io/)，这是用于深度学习的高级 API，它将使用于深度学习的神经网络更加容易和易于理解，因为其特点是类似于乐高的方法（这里的积木是神经网络的组成元素）。
 
 # 接近深度学习
 
@@ -79,7 +79,7 @@ In: import keras
 Out: Using TensorFlow backend.
 ```
 
-现在是时候开始处理了，因此我们必须为任务定义一些静态参数。 其中有两种，主要是：我们要识别的不同信号的数量（即类别的数量）和图片的大小。 班级数量是 43; 也就是说，我们可以识别 43 种不同的交通标志。
+现在是时候开始处理了，因此我们必须为任务定义一些静态参数。 其中有两种，主要是：我们要识别的不同信号的数量（即类别的数量）和图片的大小。 类别数量是 43; 也就是说，我们可以识别 43 种不同的交通标志。
 
 第二个参数，图像大小，很重要，因为输入图像可以具有不同的大小和形状。 我们需要将它们调整为标准尺寸，以便对它们运行深层网络。 我们选择`32x32`像素作为标准像素：它足够小以识别信号，并且同时不需要太多内存（也就是说，每个灰度图像仅使用 1,024 字节或 1 KB）。 增加大小意味着增加保存数据集所需的内存，再加上深网的输入层和计算所需的时间。 在文献中，对于只有一个项目的图像，`32x32`是相当标准的选择。 因此，就我们而言，我们有充分的理由来决定该大小。
 
@@ -92,7 +92,7 @@ In: N_CLASSES = 43
 
 1.  导入处理所需的模块。 最重要的是 Scikit-learn（即 Sklearn），其中包含处理图像的功能。
 2.  我们一个接一个地读取图像。 标签包含在路径中。 例如，图像`GTSRB/Final_Training/Images/00000/00003_00024.ppm`的标签为`00000`，即`0`； 并且图像`GTSRB/Final_Training/Images/00025/00038_00005.ppm`带有标签`00025`，即`25`。 标签存储为标记编码的数组，该数组是一个 43 单元长的数组，只有一个值为`1`的数组（所有其他均为`0`）。
-3.  图像以 **PPM**（**可移植像素图**）格式存储，这是一种将像素存储在图像中的无损方式。 Scikit 图像或只是 [skimage](https://scikit-image.org/) 可以使用功能`imread`读取该格式。 如果您的系统上尚未安装 Scikit 映像，只需在 shell 中键入以下内容：`conda install scikit-image`或`pip install -U scikit-image`。 返回的对象是 3D NumPy 数组。
+3.  图像以 **PPM**（**可移植像素图**）格式存储，这是一种将像素存储在图像中的无损方式。 Scikit 图像或只是 [skimage](https://scikit-image.org/) 可以使用函数`imread`读取该格式。 如果您的系统上尚未安装 Scikit 映像，只需在 shell 中键入以下内容：`conda install scikit-image`或`pip install -U scikit-image`。 返回的对象是 3D NumPy 数组。
 4.  然后将包含图像像素表示的 3D NumPy 数组（具有三个通道-红色，蓝色和绿色）转换为灰度。 在这里，我们首先转换为 LAB 颜色空间（请参见[这个页面](https://hidefcolor.com/blog/color-management/what-is-lab-color-space)-该颜色空间比线性颜色更具感知性） 其他，这意味着颜色值的相同变化量应产生相同视觉重要性的影响），然后保留第一个通道（包含亮度）。 再次，此操作很容易使用 Skimage 完成。 结果，我们有一个包含图像像素的一维 NumPy 数组。
 5.  最终，再次使用 Skimage 函数将图像调整为`32x32`像素格式。
 
@@ -489,7 +489,7 @@ Out: Predicted: [('n02704792', 'amphibian', 0.20315942),
 
 正如预期的那样，由于它不在其预定义的类别之内，因此网络无法识别第一个预测标签中的盆景。
 
-实际上，可以通过所谓的**迁移学习技术**来训练预训练的模型甚至识别全新的课程。 这项技术不在本书的讨论范围之内，[但是您可以从 Keras 的博客中的示例中了解它](https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html)。
+实际上，可以通过所谓的**迁移学习技术**来训练预训练的模型甚至识别全新的类别。 这项技术不在本书的讨论范围之内，[但是您可以从 Keras 的博客中的示例中了解它](https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html)。
 
 最后，让我们看看如何从中间层提取要素，如下所示：
 

new/py-ds-essentials/8.md

@@ -285,7 +285,7 @@ In: def sq(x):
 Out: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 ```
 
-尽管输出正确，但是`sq`功能占用大量空间； 借助 Python 的`lambda`表达式，我们可以更简洁地重写转换：
+尽管输出正确，但是`sq`函数占用大量空间； 借助 Python 的`lambda`表达式，我们可以更简洁地重写转换：
 
 ```py
 In: numbers_rdd.map(lambda x: x**2).collect()
@@ -369,7 +369,7 @@ Out: [('even', 20), ('odd', 25)]
 *   `groupByKey()`：这将创建一个 RDD，其中对于每个键，其值是在输入数据集中具有该键的
     值序列。
 *   `reduceByKey(function)`：这将通过键汇总输入的 RDD，然后，
-    将`reduce`功能应用于每个组的值。
+    将`reduce`函数应用于每个组的值。
 *   `sortByKey(ascending)`：按
     升序或降序对 RDD 中的元素进行排序。
 *   `union(otherRDD)`：这会将两个 RDD 合并在一起。
@@ -932,9 +932,9 @@ In: for table in sqlContext.tableNames():
 
 **MLlib** 是 Spark 机器学习库； 尽管它是用 Scala 和 Java 构建的，但是它的功能也可以在 Python 中使用。 它包含分类，回归，推荐算法，一些用于降维和特征选择的例程，并且具有许多用于文本处理的功能。 它们所有人都能够应对庞大的数据集，并利用集群中所有节点的力量来实现其目标。
 
-到目前为止，它由两个主要程序包组成：MLlib（可在 RDD 上运行）和 ML（可在`DataFrame`上运行）。 由于后者表现良好，并且是表示数据科学中数据的最流行方式，因此开发人员选择贡献和改进 ML 分支，让 ML 分支保留下来，但没有进一步的发展。 MLlib 乍看之下似乎是一个完整的库，但是，在开始使用 Spark 之后，您会注意到默认包中既没有统计库，也没有数值库。 在这里，SciPy 和 NumPy 会为您提供帮助，它们再次对数据科学至关重要。
+到目前为止，它由两个主要包组成：MLlib（可在 RDD 上运行）和 ML（可在`DataFrame`上运行）。 由于后者表现良好，并且是表示数据科学中数据的最流行方式，因此开发人员选择贡献和改进 ML 分支，让 ML 分支保留下来，但没有进一步的发展。 MLlib 乍看之下似乎是一个完整的库，但是，在开始使用 Spark 之后，您会注意到默认包中既没有统计库，也没有数值库。 在这里，SciPy 和 NumPy 会为您提供帮助，它们再次对数据科学至关重要。
 
-在本节中，我们将尝试探索`pyspark.ml`软件包的功能； 截至目前，与最新的 Scikit-learn 库相比，它仍处于早期阶段，但它肯定在未来具有很大的潜力。
+在本节中，我们将尝试探索`pyspark.ml`包的功能； 截至目前，与最新的 Scikit-learn 库相比，它仍处于早期阶段，但它肯定在未来具有很大的潜力。
 
 Spark 是一款高级，分布式且复杂的软件，应仅在大数据上以及具有多个节点的集群使用； 实际上，如果数据集可以容纳在内存中，那么使用其他库（例如 Scikit-learn 或类似库）就更方便了，这些库仅关注问题的数据科学方面。 在小型数据集的单个节点上运行 Spark 的速度可能比 Scikit-learn 等价算法慢五倍。
 
@@ -1044,7 +1044,7 @@ Out: root
 # 特征工程
 
 从视觉分析来看，只有四个字段是字符串：`protocol_type`，`service`，`flag`和`target`（这是预期的多类目标标签）。
-由于我们将使用基于树的分类器，因此我们希望将每个级别的文本编码为每个变量的数字。 使用 Scikit-learn，可以使用`sklearn.preprocessing.LabelEncoder`对象完成此操作。 在 Spark 中等效的是`pyspark.ml.feature`软件包的`StringIndexer`。
+由于我们将使用基于树的分类器，因此我们希望将每个级别的文本编码为每个变量的数字。 使用 Scikit-learn，可以使用`sklearn.preprocessing.LabelEncoder`对象完成此操作。 在 Spark 中等效的是`pyspark.ml.feature`包的`StringIndexer`。
 我们需要用 Spark 编码四个变量，然后我们必须将四个`StringIndexer`对象以级联的方式链接在一起：它们每个都将在`DataFrame`的特定列上操作，并输出一个带有附加列的`DataFrame`（类似`map`操作）。 映射是自动的，按频率排序：Spark 在所选列中对每个级别的计数进行排名，将最流行的级别映射到`0`，然后映射到`1`，依此类推。 请注意，通过此操作，您将遍历数据集一次以计算每个级别的出现次数。 如果您已经知道该映射，则广播该映射并使用`map`操作会更有效，如本章开头所示。
 
 更笼统地说，`pyspark.ml.feature`包中包含的所有类都用于从`DataFrame`中提取，转换和选择要素。 他们所有人都在`DataFrame`中读取一些列并创建其他列。
@@ -1152,8 +1152,8 @@ Out: Row(features=SparseVector(41, {1: 8.0, 7: 181.0, 15: 1.0, 16: 2.0, 22:
 
 最后，我们到达了任务的热点：训练分类器。 分类器包含在`pyspark.ml.classification`包中，对于本示例，我们使用随机森林。 对于 Spark 2.3.1，可以在[这个页面](https://spark.apache.org/docs/2.3.1/ml-classification-regression.html)中找到可用的算法的广泛列表。 算法列表非常完整，包括线性模型，SVM，朴素贝叶斯和树集成。 请注意，并非所有这些工具都能够处理多类问题，并且可能具有不同的参数。 始终检查与使用版本有关的文档。 除分类器外，Spark 2.3.1 中使用 Python 接口实现的其他学习器如下：
 
-*   群集（`pyspark.ml.clustering`程序包）：KMeans
-*   推荐人（`pyspark.ml.recommendation`软件包）：ALS（协同过滤推荐器，基于交替最小二乘法）
+*   群集（`pyspark.ml.clustering`包）：KMeans
+*   推荐人（`pyspark.ml.recommendation`包）：ALS（协同过滤推荐器，基于交替最小二乘法）
 
 让我们回到 KDD99 挑战的目标。 现在，该实例化随机森林分类器并设置其参数了。 要设置的参数是`featuresCol`（包含特征矩阵的列），`labelCol`（包含目标标签的数据帧的列），`seed`（使实验可复制的随机种子）和`maxBins` （用于树的每个节点中的分割点的最大箱子数）。 森林中树木数量的默认值为`20`，每棵树的最大深度为 5 级。 此外，默认情况下，此分类器在`DataFrame`中创建三个输出列：`rawPrediction`（用于存储每个可能标签的预测得分），`probability`（用于存储每个标签的可能性）和`prediction`（最可能的标签）：
 
@@ -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）和二进制分类器的评估器对象在同一包中可用。
 
 # 机器学习管道的力量
 
@@ -1271,9 +1271,9 @@ In: from pyspark.mllib.evaluation import MulticlassMetrics
 
 # 手动调整
 
-尽管`F1-score`接近`0.97`，但归一化的混淆矩阵显示类别非常不平衡，并且分类器刚刚学会了如何正确地对最受欢迎的类别进行分类。 为了改善结果，我们可以对每个班级进行重新采样，从而有效地尝试更好地平衡训练数据集。
+尽管`F1-score`接近`0.97`，但归一化的混淆矩阵显示类别非常不平衡，并且分类器刚刚学会了如何正确地对最受欢迎的类别进行分类。 为了改善结果，我们可以对每个类别进行重新采样，从而有效地尝试更好地平衡训练数据集。
 
-首先，让我们计算一下每个课程的训练数据集中有多少个案例：
+首先，让我们计算一下每个类别的训练数据集中有多少个案例：
 
 ```py
 In: train_composition = (train_df.groupBy("target")
@@ -1292,7 +1292,7 @@ Out: {'neptune': 107201,
       'phf': 4}
 ```
 
-这清楚地表明了严重的不平衡。 我们可以尝试通过对稀有类进行过度采样和对太受欢迎的类进行二次采样来提高性能。 在此示例中，我们将创建一个训练数据集，其中每个班级至少代表 1,000 次，但最多代表 25,000 次。 为此，我们执行以下步骤：
+这清楚地表明了严重的不平衡。 我们可以尝试通过对稀有类进行过度采样和对太受欢迎的类进行二次采样来提高性能。 在此示例中，我们将创建一个训练数据集，其中每个类别至少代表 1,000 次，但最多代表 25,000 次。 为此，我们执行以下步骤：
 
 1.  让我们首先创建子采样/过采样率，并将其在整个集群中广播，然后`flatMap`训练数据集的每一行对其进行正确的重新采样：
 
@@ -1419,7 +1419,7 @@ 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`对象时设置的（在这种情况下，是列名，种子和最大数量的容器）。
 
@@ -1482,6 +1482,6 @@ In: bc_sample_rates.unpersist()
 
 在本章的稍后部分，我们学习了使用 Spark 进行机器学习的知识，其中包括读取数据集，培训学习器，机器学习管道的功能，交叉验证，甚至测试通过示例数据集获得的知识。
 
-到此结束我们围绕 Python 进行数据科学基础研究的旅程，下一章只是刷新和增强 Python 基础的附录。 总之，通过本书的所有章节，我们已经完成了数据科学项目的介绍，接触了项目的所有关键步骤，并向您展示了使用 Python 成功操作自己的项目的所有基本工具。 作为学习工具，这本书陪同您完成了数据科学的所有阶段，从数据加载到机器学习和可视化，阐述了无论数据大小的最佳实践和避免常见陷阱的方法。 作为参考，本书涉及各种命令和程序包，为您提供了简单明了的说明和示例，如果在项目中重复使用这些示例和示例，则可以在工作期间节省大量时间。
+到此结束我们围绕 Python 进行数据科学基础研究的旅程，下一章只是刷新和增强 Python 基础的附录。 总之，通过本书的所有章节，我们已经完成了数据科学项目的介绍，接触了项目的所有关键步骤，并向您展示了使用 Python 成功操作自己的项目的所有基本工具。 作为学习工具，这本书陪同您完成了数据科学的所有阶段，从数据加载到机器学习和可视化，阐述了无论数据大小的最佳实践和避免常见陷阱的方法。 作为参考，本书涉及各种命令和包，为您提供了简单明了的说明和示例，如果在项目中重复使用这些示例和示例，则可以在工作期间节省大量时间。
 
 从现在开始，Python 肯定会在您的项目开发中扮演更重要的角色，到目前为止，我们很高兴能陪同您一起为数据科学掌握 Python。
\ No newline at end of file

new/py-ds-essentials/9.md

@@ -175,7 +175,7 @@ c_dict['a_key']
 # requiring a nonexistent key will always return the string 'empty'
 ```
 
-可以使用`def`或`lambda`命令定义`defaultdict`使用的`default`功能，如下节所述。
+可以使用`def`或`lambda`命令定义`defaultdict`使用的`default`函数，如下节所述。
 
 # 定义函数
 
@@ -200,7 +200,7 @@ def sigmoid(x):
              return 1.0
 ```
 
-最后，您可以使用`lambda`函数来创建匿名函数。 将匿名函数视为简单函数，您可以在代码中的任何位置内联定义，而无需使用`verbose`构造函数（以`def`开头的函数）。 只需调用`lambda`，然后输入其输入参数即可； 然后，冒号将发信号通知要由`lambda`功能执行的命令的开始，这些命令必须在同一行上。 （没有`return`命令！这些命令将从`lambda`函数返回。）您可以将`lambda`函数用作另一个函数的参数，如先前在`defaultdict`中看到的那样，也可以使用它在一行中表达一个功能。 在我们的示例中就是这种情况，我们通过返回`lambda`函数并结合第一个参数来定义函数：
+最后，您可以使用`lambda`函数来创建匿名函数。 将匿名函数视为简单函数，您可以在代码中的任何位置内联定义，而无需使用`verbose`构造函数（以`def`开头的函数）。 只需调用`lambda`，然后输入其输入参数即可； 然后，冒号将发信号通知要由`lambda`函数执行的命令的开始，这些命令必须在同一行上。 （没有`return`命令！这些命令将从`lambda`函数返回。）您可以将`lambda`函数用作另一个函数的参数，如先前在`defaultdict`中看到的那样，也可以使用它在一行中表达一个功能。 在我们的示例中就是这种情况，我们通过返回`lambda`函数并结合第一个参数来定义函数：
 
 ```py
 def sum_a_const(c): 
@@ -327,7 +327,7 @@ Hello world, I'm the constructor
 
 # 异常
 
-异常和错误密切相关，但是它们是不同的东西。 例如，可以很好地处理异常。 以下是一些例外示例：
+异常和错误密切相关，但是它们是不同的东西。 例如，可以很好地处理异常。 以下是一些异常示例：
 
 ```py
 0/0 
@@ -352,7 +352,7 @@ except ZeroDivisionError:
  a = 0
 ```
 
-您可以使用一个以上的`except`子句来处理多个异常。 您最终可以使用最终的`all-the-other`例外情况句柄。 在这种情况下，结构如下：
+您可以使用一个以上的`except`子句来处理多个异常。 您最终可以使用最终的`all-the-other`异常处理器。 在这种情况下，结构如下：
 
 ```py
 try: 

new/thoughtful-ds/00.md

@@ -47,11 +47,11 @@
 
 第 1 章，“开发人员对数据科学的观点”，我尝试通过我自己的经验来定义数据科学，并建立一个数据管道来在 Twitter 上执行帖子情感分析。 我认为这是一项团队运动，并且在大多数情况下，数据科学团队和工程团队之间存在孤岛，这会导致不必要的摩擦，效率低下，最终导致无法充分发挥其潜力。 我还认为，数据科学将继续存在，并最终将成为当今所谓的计算机科学不可或缺的一部分（我想有一天会有新术语出现，例如“计算机数据科学”更好地捕捉了这种双重性）。
 
-第 2 章，“借助 Jupyter 笔记本和 PixieDust”，我开始深入研究流行的数据科学工具，例如 Python 及其专用于数据科学的开源库生态系统，以及 Jupyter 笔记本。 我解释了为什么我认为 Jupyter 笔记本电脑将在未来几年成为大赢家。 我还从简单的`display()`方法开始介绍 PixieDust 开源库功能，该方法使用户可以通过构建引人注目的图表直观地浏览交互式用户界面中的数据。 使用此 API，用户可以从多个渲染引擎（例如 Matplotlib，Bokeh，Seaborn 和 Mapbox）中进行选择。 `display()`功能是 PixieDust MVP（最低可行产品）中的唯一功能，但是随着时间的流逝，当我与许多数据科学从业人员进行互动时，我为快速成为 PixieDust 工具箱添加了新功能：
+第 2 章，“借助 Jupyter 笔记本和 PixieDust”，我开始深入研究流行的数据科学工具，例如 Python 及其专用于数据科学的开源库生态系统，以及 Jupyter 笔记本。 我解释了为什么我认为 Jupyter 笔记本电脑将在未来几年成为大赢家。 我还从简单的`display()`方法开始介绍 PixieDust 开源库功能，该方法使用户可以通过构建引人注目的图表直观地浏览交互式用户界面中的数据。 使用此 API，用户可以从多个渲染引擎（例如 Matplotlib，Bokeh，Seaborn 和 Mapbox）中进行选择。 `display()`函数是 PixieDust MVP（最低可行产品）中的唯一功能，但是随着时间的流逝，当我与许多数据科学从业人员进行互动时，我为快速成为 PixieDust 工具箱添加了新功能：
 
 *   `sampleData()`：一个简单的 API，可轻松将数据加载到 Pandas 和 Apache Spark`DataFrame`中
 *   `wrangle_data()`：用于清理和按摩数据集的简单 API。 此功能包括使用正则表达式从非结构化文本中提取内容的功能，可将列分解为新的列。 `wrangle_data()` API 也可以基于预定义的模式提出建议。
-*   **包管理器**：允许用户在 Python 笔记本中安装第三方 Apache Spark 软件包。
+*   **包管理器**：允许用户在 Python 笔记本中安装第三方 Apache Spark 包。
 *   **Scala 桥接**：使用户能够在 Python 笔记本中运行 Scala 代码。 在 Python 端定义的变量可以在 Scala 中访问，反之亦然。
 *   **Spark 作业进度监视器**：使用实时进度条跟踪您的 Spark 作业状态，该进度条直接显示在正在执行的代码的输出单元格中。
 *   **PixieApp**：提供一个以 HTML/CSS 为中心的编程模型，使开发人员可以构建复杂的仪表板，以对笔记本中内置的分析进行操作。 PixieApps 可以直接在 Jupyter 笔记本中运行，也可以使用 PixieGateway 微服务作为分析 Web 应用进行部署。 PixieGateway 是 PixieDust 的开源配套项目。

new/thoughtful-ds/02.md

@@ -31,7 +31,7 @@ Scala 还提供了一种非常简洁的语法，可以将其转换为更少的
 
     2017 年的兴趣趋势
 
-在一个良性循环中，Python 的受欢迎程度不断提高，带动了一个广泛且不断发展的范围广泛的库，可以使用 PIP Python 软件包安装程序轻松将其导入到您的项目中。 数据科学家现在可以访问许多功能强大的开源 Python 库，以进行数据处理，数据可视化，统计，数学，机器学习和自然语言处理。
+在一个良性循环中，Python 的受欢迎程度不断提高，带动了一个广泛且不断发展的范围广泛的库，可以使用 PIP Python 包安装程序轻松将其导入到您的项目中。 数据科学家现在可以访问许多功能强大的开源 Python 库，以进行数据处理，数据可视化，统计，数学，机器学习和自然语言处理。
 
 即使初学者也可以使用流行的 [Scikit-learn 包](http://scikit-learn.org)快速构建机器学习分类器，而无需成为机器学习专家，也可以使用 [Matplotlib](https://matplotlib.org) 或 [Bokeh](https://bokeh.pydata.org) 快速绘制丰富的图表。
 
@@ -101,7 +101,7 @@ my_data = [
 
 您还将发现 PixieDust 包含一些与 Apache Spark 相关的额外工具，例如：
 
-*   **包管理器**：这使您可以在 Python 笔记本中安装 Spark 软件包。
+*   **包管理器**：这使您可以在 Python 笔记本中安装 Spark 包。
 *   **Scala 桥接**：您可以使用`%%scala`魔术在 Python 笔记本中直接使用 Scala 。 变量自动从 Python 传输到 Scala，反之亦然。
 *   **Spark 作业进度监视器**：通过直接在单元格输出中显示进度条来跟踪任何 Spark 作业的状态。
 
@@ -168,7 +168,7 @@ c.NotebookApp.open_browser = False
 
 ### 提示
 
-我强烈建议您使用 [Anaconda](https://anaconda.org)，它提供了出色的 Python 软件包管理功能。 如果像我一样喜欢试验不同版本的 Python 和库依赖关系，建议您使用 Anaconda 虚拟环境。
+我强烈建议您使用 [Anaconda](https://anaconda.org)，它提供了出色的 Python 包管理功能。 如果像我一样喜欢试验不同版本的 Python 和库依赖关系，建议您使用 Anaconda 虚拟环境。
 
 它们是轻量级的 Python 沙箱，非常易于创建和激活（请参见[这个页面](https://conda.io/docs/user-guide/tasks/manage-environments.html)）：
 
@@ -345,16 +345,16 @@ display(london_info)
 
 在大多数情况下，在受控实验中工作与在现实世界中工作不同。 我的意思是，在开发过程中，我们通常会选择（或者我应该说是制造）一个旨在表现出来的样本数据集。 它具有正确的格式，符合架构规范，没有数据丢失，依此类推。 目标是专注于验证假设并构建算法，而不是集中在数据清理上，这可能非常痛苦且耗时。 但是，在开发过程中尽早获得尽可能接近真实数据的数据具有不可否认的优势。 为了帮助完成此任务，我与 IBM 的两个同事 Jamie Jennings 和 Terry Antony 合作，他们自愿为 PixieDust 扩展了名为`pixiedust_rosie`的扩展。
 
-该 Python 包实现了一个简单的`wrangle_data()`方法，以自动执行原始数据的清理。 `pixiedust_rosie`软件包当前支持 CSV 和 JSON，但是将来会添加更多格式。 底层数据处理引擎使用 **Rosie 模式语言**（**RPL**）开源组件，这是一个正则表达式引擎，旨在使开发人员更容易使用，性能更高， 并可以扩展到大数据。 [您可以在此处找到有关 Rosie 的更多信息](http://rosie-lang.org)。
+该 Python 包实现了一个简单的`wrangle_data()`方法，以自动执行原始数据的清理。 `pixiedust_rosie`包当前支持 CSV 和 JSON，但是将来会添加更多格式。 底层数据处理引擎使用 **Rosie 模式语言**（**RPL**）开源组件，这是一个正则表达式引擎，旨在使开发人员更容易使用，性能更高， 并可以扩展到大数据。 [您可以在此处找到有关 Rosie 的更多信息](http://rosie-lang.org)。
 
-首先，您需要使用以下命令安装`pixiedust_rosie`软件包：
+首先，您需要使用以下命令安装`pixiedust_rosie`包：
 
 ```py
 !pip install pixiedust_rosie
 
 ```
 
-`pixiedust_rosie`软件包依赖于`pixiedust`和`rosie,`，如果尚未安装在系统上，它们将自动下载。
+`pixiedust_rosie`包依赖于`pixiedust`和`rosie,`，如果尚未安装在系统上，它们将自动下载。
 
 `wrangle_data()`方法与`sampleData()` API 非常相似。 当不带参数调用时，它将显示预整理的数据集列表，如下所示：
 
@@ -446,7 +446,7 @@ display(wrangled_df)
 
 运行前面的单元格将使您能够浏览和可视化新数据集。
 
-我们在本节中探讨的`wrangle_data()`功能是帮助数据科学家花更少的时间清理数据并花更多时间分析数据的第一步。 在下一部分中，我们将讨论如何帮助数据科学家进行数据探索和可视化。
+我们在本节中探讨的`wrangle_data()`函数是帮助数据科学家花更少的时间清理数据并花更多时间分析数据的第一步。 在下一部分中，我们将讨论如何帮助数据科学家进行数据探索和可视化。
 
 # 可视化——用于数据可视化的简单交互式 API
 

new/thoughtful-ds/03.md

@@ -524,7 +524,7 @@ analyses = [("Commit Activity", load_commit_activity)]
 
 ### 注意
 
-**注意**：`load_commit_activity`功能将在本节稍后讨论。
+**注意**：`load_commit_activity`函数将在本节稍后讨论。
 
 出于此示例应用的目的，该数组仅包含一个与提交活动相关的元素，但是将来您可能添加的任何元素都将由 UI 自动选择。
 

new/thoughtful-ds/04.md

@@ -74,7 +74,7 @@ source activate <<my_env>>
 
 您应该在终端中看到您的环境名称，这表明您已正确激活它。
 
-接下来，通过运行以下命令从 PyPi 安装`pixiegateway`软件包：
+接下来，通过运行以下命令从 PyPi 安装`pixiegateway`包：
 
 ```py
 pip install pixiegateway
@@ -83,7 +83,7 @@ pip install pixiegateway
 
 ### 注意
 
-[**注意**：您可以在此处找到有关 PyPi 上`pixiegateway`软件包的更多信息](https://pypi.python.org/pypi/pixiegateway)。
+[**注意**：您可以在此处找到有关 PyPi 上`pixiegateway`包的更多信息](https://pypi.python.org/pypi/pixiegateway)。
 
 一旦所有依赖项都已安装，就可以启动服务器了。 假设您要使用`8899 port`，则可以使用以下命令启动 PixieGateway 服务器：
 
@@ -461,7 +461,7 @@ app.run()
 
     **注意**：目前，PixieGateway 不提供任何认证/授权机制。 第三方授权，例如 [OAuth 2.0](https://oauth.net/2)，[JWT](https://jwt.io) 等未来将被添加。
 
-*   **导入**：显示由 PixieDust 发布者自动检测到的 Python 软件包依赖项列表。 这些导入的软件包（如果尚不存在）将自动安装在运行应用的内核上。 当检测到特定的依赖项时，PixieDust 会查看当前系统以获取版本和安装位置，例如 PyPi 或自定义安装 URL（例如 GitHub 存储库）。
+*   **导入**：显示由 PixieDust 发布者自动检测到的 Python 包依赖项列表。 这些导入的包（如果尚不存在）将自动安装在运行应用的内核上。 当检测到特定的依赖项时，PixieDust 会查看当前系统以获取版本和安装位置，例如 PyPi 或自定义安装 URL（例如 GitHub 存储库）。
 *   **内核规范**：您可以在此处为 PixieApp 选择内核规范。 默认情况下，PixieDust 选择 PixieGateway 服务器上可用的默认内核，但是，例如，如果您的笔记本依赖于 Apache Spark，则您应该能够选择支持它的内核。 使用管理控制台部署 PixieApp 之后，也可以更改此选项。
 
 这是 PixieApp 发布对话框的示例屏幕截图：
@@ -546,7 +546,7 @@ def do_search(self, query):
 
 显示 PixieApp 参数的单元元数据
 
-如果您正在使用`persist_args`功能，则可能会发现在进行迭代开发时，总是去单元格元数据删除参数变得很麻烦。 作为一种快捷方式，PixieApp 框架在右上方的工具栏中添加了一个主页按钮，只需单击一下即可重置参数。
+如果您正在使用`persist_args`函数，则可能会发现在进行迭代开发时，总是去单元格元数据删除参数变得很麻烦。 作为一种快捷方式，PixieApp 框架在右上方的工具栏中添加了一个主页按钮，只需单击一下即可重置参数。
 
 作为的替代方案，您还可以避免在笔记本中运行时将路由参数完全保存在单元元数据中（但在 Web 上运行时仍然保存）。 为此，您需要使用`web`作为`persist_args`参数的值，而不是`true`：
 

new/thoughtful-ds/05.md

@@ -194,7 +194,7 @@ app.run()
 
 在前面的代码中，`Go`按钮具有以下属性：
 
-*   `pd_app="WCChildApp"`：使用子 PixieApp 的类名。 请注意，如果您的孩子 PixieApp 生活在导入的 Python 模块中，则需要使用完全限定的名称。
+*   `pd_app="WCChildApp"`：使用子 PixieApp 的类名。 请注意，如果您的子 PixieApp 生活在导入的 Python 模块中，则需要使用完全限定的名称。
 *   `pd_options="url=$val(url{{prefix}})"`：将用户输入的 URL 作为初始化选项存储到子 PixieApp。
 *   `pd_target="wordcloud{{prefix}}"`：告诉 PixieDust 将子 PixieApp 的输出放在 ID 为`wordcloud{{prefix}}`的 DIV 中。
 
@@ -299,7 +299,7 @@ app.run()
 
 `StreamingDataAdapter`架构
 
-在实现`StreamingDataAdapter`的子类时，必须重写基类提供的`doGetNextData()`方法，将重复调用该方法以获取新数据以更新可视化效果。 您还可以选择覆盖`getMetadata()`方法，以将上下文传递给渲染引擎（我们稍后将使用此方法来配置 Mapbox 渲染）。
+在实现`StreamingDataAdapter`的子类时，必须覆盖基类提供的`doGetNextData()`方法，将重复调用该方法以获取新数据以更新可视化效果。 您还可以选择覆盖`getMetadata()`方法，以将上下文传递给渲染引擎（我们稍后将使用此方法来配置 Mapbox 渲染）。
 
 `doGetNextData()`的抽象实现如下所示：
 
@@ -416,9 +416,9 @@ display(adapter)
 
 [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%205/sampleCode9.py)。
 
-前一个 DIV 通过`pd_entity`属性绑定到`avgChannelData`实体，并负责创建每秒更新一次的实时图表（`pd_refresh_rate = 1000 ms`）。 依次通过对`getStreamingChannel(),`的调用来创建`avgChannelData`实体，该调用将传递给`self`。 `computeAverage`功能负责更新所有流数据的平均值。 重要的是要注意，`avgChannelData`是从`StreamingDataAdapter`继承的类，因此可以传递给`display()`框架以构建实时图表。
+前一个 DIV 通过`pd_entity`属性绑定到`avgChannelData`实体，并负责创建每秒更新一次的实时图表（`pd_refresh_rate = 1000 ms`）。 依次通过对`getStreamingChannel(),`的调用来创建`avgChannelData`实体，该调用将传递给`self`。 `computeAverage`函数负责更新所有流数据的平均值。 重要的是要注意，`avgChannelData`是从`StreamingDataAdapter`继承的类，因此可以传递给`display()`框架以构建实时图表。
 
-最后一个难题是让 PixieApp 返回`display()`框架所需的`displayHandler`。 这是通过重写`newDisplayHandler()`方法来完成的，如下所示：
+最后一个难题是让 PixieApp 返回`display()`框架所需的`displayHandler`。 这是通过覆盖`newDisplayHandler()`方法来完成的，如下所示：
 
 ```py
 def newDisplayHandler(self, options, entity):
@@ -617,7 +617,7 @@ PixieDust 设计为高度可扩展的。 您可以根据所显示的实体创建
 
 PixieDust 扩展层
 
-要开始使用**显示扩展层**，您需要通过创建一个继承自`pixiedust.display.DisplayHandlerMeta`的类来在菜单中显示可视化效果。 此类包含两个需要重写的方法：
+要开始使用**显示扩展层**，您需要通过创建一个继承自`pixiedust.display.DisplayHandlerMeta`的类来在菜单中显示可视化效果。 此类包含两个需要覆盖的方法：
 
 *   `getMenuInfo(self,entity,dataHandler)`：如果不支持作为参数传递的实体，则返回一个空数组，否则返回包含带有菜单信息的 JSON 对象集的数组。 每个 JSON 对象必须包含以下信息：
 
@@ -731,7 +731,7 @@ PixieDust 随附了一些内置渲染器，例如 Matplotlib，Seaborn，Bokeh
     *   `histogram`
 
 3.  （可选）使用`@commonChartOptions`装饰器创建一组动态选项。
-4.  （可选）通过重写`get_options_dialog_pixieapp()`方法来自定义从`pixiedust.display.chart.options.baseOptions`包中的`BaseOptions`类继承的 PixieApp 类的完全限定名称，从而自定义选项对话框。
+4.  （可选）通过覆盖`get_options_dialog_pixieapp()`方法来自定义从`pixiedust.display.chart.options.baseOptions`包中的`BaseOptions`类继承的 PixieApp 类的完全限定名称，从而自定义选项对话框。
 
 例如，让我们使用渲染器扩展层重写先前的自定义`SimpleDisplay`表可视化：
 
@@ -1165,7 +1165,7 @@ app.run()
 
 ![Client-side debugging](img/00103.jpeg)
 
-使用调试器在客户端调试 JavaScript 代码； 陈述
+使用调试器在客户端调试 JavaScript 代码
 
 # 在 Python 笔记本中运行 Node.js
 
@@ -1210,9 +1210,9 @@ import pixiedust_node
 
 *   `node.cancel()`：停止 Node.js 子进程中的当前代码执行。
 *   `node.clear()`：重置 Node.js 会话； 所有现有变量将被删除。
-*   `npm.install(package)`：安装一个 NPM 软件包并使其可用于 Node.js 会话。 该软件包在各个会话之间均保持不变。
-*   `npm.uninstall(package)`：从系统和当前 Node.js 会话中删除 NPM 软件包。
-*   `npm.list()`：列出当前安装的所有 NPM 软件包。
+*   `npm.install(package)`：安装一个 NPM 包并使其可用于 Node.js 会话。 该包在各个会话之间均保持不变。
+*   `npm.uninstall(package)`：从系统和当前 Node.js 会话中删除 NPM 包。
+*   `npm.list()`：列出当前安装的所有 NPM 包。
 
 `pixiedust_node`创建一个单元魔术，使您可以运行任意 JavaScript 代码。 只需在单元顶部上使用`%%node`魔术，然后照常运行即可。 然后将在 Node.js 子进程 REPL 会话中执行代码。
 

new/thoughtful-ds/06.md

@@ -213,7 +213,7 @@ with tf.Session() as sess:
 
 [**注意**：本节讨论示例 PixieApp 的源代码。 如果您想继续学习，可以在以下位置下载完整的笔记本电脑](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/TensorFlow%20classification.ipynb)。
 
-在使用低级 TensorFlow API 使用张量，图和会话之前，最好先熟悉`Estimators`软件包中提供的高级 API。 在本节中，我们将构建一个简单的 PixieApp，它将 Pandas `DataFrame`作为输入并使用分类输出训练分类模型。
+在使用低级 TensorFlow API 使用张量，图和会话之前，最好先熟悉`Estimators`包中提供的高级 API。 在本节中，我们将构建一个简单的 PixieApp，它将 Pandas `DataFrame`作为输入并使用分类输出训练分类模型。
 
 ### 注意
 

new/thoughtful-ds/07.md

@@ -695,7 +695,7 @@ display(parquet_batch_df)
 
 幸运的是，IBM Watson 提供了`watson_developer_cloud`开源库，其中包括多个开源 SDK，这些 SDK 支持某些最受欢迎的语言，包括 Java，Python 和 Node.js。 对于本项目，[我们将使用 Python SDK 和位于此处的源代码和代码示例](https://github.com/watson-developer-cloud/python-sdk)。
 
-以下`pip`命令直接从 Jupyter 笔记本安装`watson_developer_cloud`软件包：
+以下`pip`命令直接从 Jupyter 笔记本安装`watson_developer_cloud`包：
 
 ```py
 !pip install Watson_developer_cloud
@@ -975,7 +975,7 @@ def start_parquet_streaming_query(csv_sdf):
 
 在准备工作的中，我们还需要管理 PixieApp 将创建的不同流的生命周期，并确保在用户重新启动仪表板时正确​​停止了基础资源。 为了解决这个问题，我们创建了一个`StreamsManager`类，该类封装了 Tweepy `twitter_stream`和 CSV Streaming `DataFrame`。 此类具有`reset`方法，该方法将停止`twitter_stream`，停止所有活动的流查询，删除从先前查询创建的所有输出文件，并使用新的查询字符串开始一个新的输出文件。 如果在没有查询字符串的情况下调用`reset`方法，则我们不会启动新的流。
 
-我们还创建了一个全局`streams_manager`实例，即使重新启动仪表板，该实例也将跟踪当前状态。 由于用户可以重新运行包含全局`streams_manager`的单元格，因此我们需要确保在删除当前全局实例的时自动调用`reset`方法。 为此，我们重写了对象的`__del__`方法，这是 Python 实现析构函数并调用`reset`的方法。
+我们还创建了一个全局`streams_manager`实例，即使重新启动仪表板，该实例也将跟踪当前状态。 由于用户可以重新运行包含全局`streams_manager`的单元格，因此我们需要确保在删除当前全局实例的时自动调用`reset`方法。 为此，我们覆盖了对象的`__del__`方法，这是 Python 实现析构函数并调用`reset`的方法。
 
 `StreamsManager`的代码如下所示：
 
@@ -1553,7 +1553,7 @@ def init(state):
 
 [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%207/sampleCode31.py)。
 
-**注意**：我们需要通过位于右侧上下文窗格中 Python 编辑器窗口上方的 **Python 软件包**链接安装`Watson_developer_cloud`库，如以下屏幕截图所示：
+**注意**：我们需要通过位于右侧上下文窗格中 Python 编辑器窗口上方的 **Python 包**链接安装`Watson_developer_cloud`库，如以下屏幕截图所示：
 
 ![Enriching the tweets data with the Streaming Analytics service](img/00163.jpeg)
 

new/thoughtful-ds/08.md

@@ -97,7 +97,7 @@ Jupyter 笔记本中的内联帮助。
 
 使用这种方法，我可以快速迭代候选函数，直到找到适合我需求的函数为止。
 
-重要的是要注意，`np.lookfor()`不限于查询 NumPy 模块； 您也可以在其他模块中搜索。 例如，以下代码在`statsmodels`程序包中搜索与[​​HTG1]（自相关函数）相关的方法：
+重要的是要注意，`np.lookfor()`不限于查询 NumPy 模块； 您也可以在其他模块中搜索。 例如，以下代码在`statsmodels`包中搜索与[​​HTG1]（自相关函数）相关的方法：
 
 ```py
 import statsmodels
@@ -642,11 +642,11 @@ 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 系列紧密集成。
 
 ### 注意
 
-**注意**：如果尚未完成，我们将使用以下命令安装`statsmodels`软件包，并在完成后重新启动内核：
+**注意**：如果尚未完成，我们将使用以下命令安装`statsmodels`包，并在完成后重新启动内核：
 
 ```py
 !pip install statsmodels
@@ -1109,7 +1109,7 @@ class MovingAverageSubApp(BaseSubApp):
 
 ## `AutoCorrelationSubApp`——第三个子 PixieApp
 
-对于第三个孩子，PixieApp 调用了`AutoCorrelationSubApp`； 我们显示所选股票`DataFrame`的 ACF 和 PACF，这些数据是使用`statsmodels`包计算的。
+对于第三个子项，PixieApp 调用了`AutoCorrelationSubApp`； 我们显示所选股票`DataFrame`的 ACF 和 PACF，这些数据是使用`statsmodels`包计算的。
 
 以下代码显示了`AutoCorrelationSubApp`的实现，该实现也使用了`add_ticker_selection_markup`装饰器和名为`lag_slider`的`pd_widget`：
 
@@ -1304,7 +1304,7 @@ display(logmsft_diff)
 
 **注意**：在统计中，统计假设检验包括通过抽取样本并确定主张是否成立来质疑所提出的假设是否成立。 我们看一下 [p 值](https://en.wikipedia.org/wiki/P-value)，它有助于确定结果的重要性。 有关统计假设检验的更多详细信息，[请参见此处](https://en.wikipedia.org/wiki/Statistical_hypothesis_testing)。
 
-以下代码使用`statsmodels.tsa.stattools`程序包中的`adfuller`方法：
+以下代码使用`statsmodels.tsa.stattools`包中的`adfuller`方法：
 
 ```py
 from statsmodels.tsa.stattools import adfuller
@@ -1322,7 +1322,7 @@ pp.pprint({labels[i]: ad_fuller_results[i] for i in range(4)})
 
 [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%208/sampleCode23.py)。
 
-我们使用了`pprint`软件包，该软件包用于*精美打印*任何 Python 数据结构。 有关`pprint`的更多信息，请参见[这个页面](https://docs.python.org/3/library/pprint.html)。
+我们使用了`pprint`包，该包用于*精美打印*任何 Python 数据结构。 有关`pprint`的更多信息，请参见[这个页面](https://docs.python.org/3/library/pprint.html)。
 
 结果（在[这个页面](http://www.statsmodels.org/devel/generated/statsmodels.tsa.stattools.adfuller.html)中进行了详细说明）显示在此处：
 
@@ -1610,7 +1610,7 @@ class ForecastArimaSubApp(BaseSubApp):
     *   一个`<div>`元素，它调用`show_acf`路由以显示 ACF 图。
     *   调用`show_pacf`路由以显示 PACF 图表的`<div>`元素。
 
-*   我们使用一个空数组`[]`作为`@BaseSubApp.add_ticker_selection_markup`装饰器的参数，以确保当用户选择另一个股票报价器时刷新整个屏幕，并从第一个屏幕重新启动。 我们还需要重置内部变量。 为了实现这一目标，我们对`add_ticker_selection_markup`进行了更改，以在`BaseSubApp`中定义了一种称为`set_active_ticker`的新方法，该方法是父 PixieApp 对`set_active_ticker`的包装方法。 想法是让子类重写此方法，并在需要时注入额外的代码。 我们还更改了 TAB 元素的`pd_script`属性，以在用户选择新的代码符号时调用此方法，如以下代码所示：
+*   我们使用一个空数组`[]`作为`@BaseSubApp.add_ticker_selection_markup`装饰器的参数，以确保当用户选择另一个股票报价器时刷新整个屏幕，并从第一个屏幕重新启动。 我们还需要重置内部变量。 为了实现这一目标，我们对`add_ticker_selection_markup`进行了更改，以在`BaseSubApp`中定义了一种称为`set_active_ticker`的新方法，该方法是父 PixieApp 对`set_active_ticker`的包装方法。 想法是让子类覆盖此方法，并在需要时注入额外的代码。 我们还更改了 TAB 元素的`pd_script`属性，以在用户选择新的代码符号时调用此方法，如以下代码所示：
 
     ```py
     [[BaseSubApp]]
@@ -1644,7 +1644,7 @@ class ForecastArimaSubApp(BaseSubApp):
 
 [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%208/sampleCode33.py)。
 
-然后，在`ForecastArimaSubApp`子 PixieApp 中，重写`set_active_tracker`方法，首先调用父级，然后调用`self.setup()`重新初始化内部变量：
+然后，在`ForecastArimaSubApp`子 PixieApp 中，覆盖`set_active_tracker`方法，首先调用父级，然后调用`self.setup()`重新初始化内部变量：
 
 ```py
 [[ForecastArimaSubApp]]

new/thoughtful-ds/11.md

@@ -4,7 +4,7 @@
 
 # 注解
 
-*   `@PixieApp`: 必须添加到任何 PixieApp 类的类注释。
+*   `@PixieApp`: 必须添加到任何 PixieApp 类的类注解。
 
     参数：无
 
@@ -17,7 +17,7 @@
         pass
     ```
 
-*   `@route`: 需要使用方法注释来表示方法（可以具有任何名称）与路由相关联。
+*   `@route`: 需要使用方法注解来表示方法（可以具有任何名称）与路由相关联。
 
     参数：`**kwargs`。 表示路由定义的关键字参数（键值对）。 PixieApp 调度程序将根据以下规则将当前内核请求与路由进行匹配：
 
@@ -49,7 +49,7 @@
 
     [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%205/sampleCode25.py)。
 
-*   `@templateArgs`: 允许在 Jinja2 模板中使用任何局部变量的注释。 请注意，不能将`@templateArgs`与`@captureOutput`结合使用：
+*   `@templateArgs`: 允许在 Jinja2 模板中使用任何局部变量的注解。 请注意，不能将`@templateArgs`与`@captureOutput`结合使用：
 
     参数：无
 
@@ -70,7 +70,7 @@
 
     [您可以在此处找到代码文件](https://github.com/DTAIEB/T4houghtful-Data-Science/blob/master/chapter%205/sampleCode26.py)。
 
-*   `@captureOutput`: 可以使用路由方法更改合同的注释，这样就不必再返回 HTML 片段。 相反，方法主体可以像在笔记本单元中那样简单地输出结果。 该框架将捕获输出并将其作为 HTML 返回。 请注意，在这种情况下，您不能使用 Jinja2 模板。
+*   `@captureOutput`: 可以使用路由方法更改合同的注解，这样就不必再返回 HTML 片段。 相反，方法主体可以像在笔记本单元中那样简单地输出结果。 该框架将捕获输出并将其作为 HTML 返回。 请注意，在这种情况下，您不能使用 Jinja2 模板。
 
     参数：无