2021-02-22 21:25:35

f99a01f3 · wizardforcel · cbee1893 · f99a01f3 · f99a01f3 · f99a01f3
29 changed file
--- a/new/begin-ds-py-jupyter/1.md
+++ b/new/begin-ds-py-jupyter/1.md
@@ -615,11 +615,11 @@ scikit_learn==0.19.0

    ![Linear models with Seaborn and scikit-learn](img/image1_087.jpg)

-    最佳拟合线是通过最小化普通最小二乘误差函数来计算的，当我们调用`regplot`函数时，Seaborn 会自动执行。 还要注意线条周围的阴影区域，代表 95％的置信区间。
+    最佳拟合线是通过最小化普通最小二乘误差函数来计算的，当我们调用`regplot`函数时，Seaborn 会自动执行。 还要注意线条周围的阴影区域，代表 95% 的置信区间。

    ### 注意

-    通过获取垂直于最佳拟合线的仓中数据的标准偏差，有效地确定沿最佳拟合线的每个点的置信区间，可以计算出这 95％的置信区间。 在实践中，这涉及 Seaborn 引导数据，该过程是通过随机采样替换产生新数据的过程。 自举的样本数是根据数据集的大小自动确定的，但也可以通过传递`n_boot`参数来手动设置。
+    通过获取垂直于最佳拟合线的仓中数据的标准偏差，有效地确定沿最佳拟合线的每个点的置信区间，可以计算出这 95% 的置信区间。 在实践中，这涉及 Seaborn 引导数据，该过程是通过随机采样替换产生新数据的过程。 自举的样本数是根据数据集的大小自动确定的，但也可以通过传递`n_boot`参数来手动设置。

 3.  Seaborn 也可以用于绘制这些关系的残差。 通过运行包含以下内容的单元来绘制残差：

@@ -860,7 +860,7 @@ scikit_learn==0.19.0

    从图中的看，只有很少的样品具有较低的 AGE，而有更多的样品具有较高的 AGE。 这通过最右边的分布的陡度来表示。

-    红线表示分布中的 1/3 和 2/3 点。 观察分布分布与这些水平线相交的地方，我们可以看到，只有约 33％的样本的 AGE 小于 55，而 33％的样本的 AGE 大于 90！ 换句话说，三分之一的住房社区在 1940 年之前建造房屋的比例不到 55％。这些社区被认为是相对较新的社区。 另一方面，另外三分之一的住房社区在 1940 年之前建造了超过 90％的房屋。这些房屋被认为是非常古老的。
+    红线表示分布中的 1/3 和 2/3 点。 观察分布分布与这些水平线相交的地方，我们可以看到，只有约 33% 的样本的 AGE 小于 55，而 33% 的样本的 AGE 大于 90！ 换句话说，三分之一的住房社区在 1940 年之前建造房屋的比例不到 55%。这些社区被认为是相对较新的社区。 另一方面，另外三分之一的住房社区在 1940 年之前建造了超过 90% 的房屋。这些房屋被认为是非常古老的。

    我们将使用红色水平线截取分布的位置作为将要素划分为类别的指导：**相对较新**，**相对较旧**和**较旧**。

@@ -887,7 +887,7 @@ scikit_learn==0.19.0

    ![Create categorical fieldscreatingcategorical fields from continuous variables and make segmented visualizations](img/image1_143.jpg)

-    查看结果，可以看出两个班级的人数相当相等，而“非常老”的一班人大约大 40％。 我们有兴趣保持类的大小可比，以使每个类都有很好的表示，并且可以直接从分析中进行推断。
+    查看结果，可以看出两个班级的人数相当相等，而“非常老”的一班人大约大 40%。 我们有兴趣保持类的大小可比，以使每个类都有很好的表示，并且可以直接从分析中进行推断。

    ### 注意

@@ -906,7 +906,7 @@ scikit_learn==0.19.0

    小提琴图显示了每个年龄类别的房屋中值分布的核密度估计。 我们看到它们都类似于正态分布。 “非常老”组的房价中位数样本最低，并且宽度相对较大，而其他组则更紧密地围绕其平均值。 青年组偏向高端，这可以从右半部分的放大和白点在分布主体内的粗黑线中的位置明显看出。

-    这个白点代表平均值，粗黑线跨越了大约 50％的总体（填充到白点两侧的第一个分位数）。 黑色的细线代表箱线图的晶须，覆盖 95％的人口。 通过将`inner='point'`传递给`sns.violinplot()`，可以修改此内部可视化以显示各个数据点。 现在开始吧。
+    这个白点代表平均值，粗黑线跨越了大约 50% 的总体（填充到白点两侧的第一个分位数）。 黑色的细线代表箱线图的晶须，覆盖 95% 的人口。 通过将`inner='point'`传递给`sns.violinplot()`，可以修改此内部可视化以显示各个数据点。 现在开始吧。

 6.  重做小提琴图，将`inner='point'`参数添加到`sns.violinplot`调用中：

@@ -931,7 +931,7 @@ scikit_learn==0.19.0

    ![Create categorical fieldscreatingcategorical fields from continuous variables and make segmented visualizations](img/image1_151.jpg)

-与`MEDV`小提琴图不同，在每个小提琴图中，分布图的宽度大致相同，而这里的宽度随`AGE`的增加而增加。 以旧房屋为主的社区（“极老”部分）的居民数量很少，甚至很多，而相对较新的社区更可能是较高阶级的人群，超过 95％的样本的较低阶级百分比低于“非常”阶级 旧社区。 这是有道理的，因为相对而言，新街区会更昂贵。
+与`MEDV`小提琴图不同，在每个小提琴图中，分布图的宽度大致相同，而这里的宽度随`AGE`的增加而增加。 以旧房屋为主的社区（“极老”部分）的居民数量很少，甚至很多，而相对较新的社区更可能是较高阶级的人群，超过 95% 的样本的较低阶级百分比低于“非常”阶级 旧社区。 这是有道理的，因为相对而言，新街区会更昂贵。

 # 摘要


--- a/new/begin-ds-py-jupyter/2.md
+++ b/new/begin-ds-py-jupyter/2.md
@@ -310,7 +310,7 @@

    在这里，我们正在选择数据的子集，并将其输入到`train_test_split`函数中。 此功能具有四个输出，这些输出被打包到功能（`X`）和目标（`y`）的训练和测试单元中。

-    观察输出数据的形状，其中测试集大约有 30％的样本，训练集大约有 70％的样本。
+    观察输出数据的形状，其中测试集大约有 30% 的样本，训练集大约有 70% 的样本。

    在准备用于训练预测模型的实际数据时，我们将在以后看到类似的代码块。

@@ -432,7 +432,7 @@ print(df.left.isnull().sum())

    ![Activity A: Preparing to Train a Predictive Model for the Employee-Retention Problem](img/image2_32.jpg)

-    我们可以看到`average_montly_hours`丢失了约 2.5％，`time_spend_company`丢失了 1％，`is_smoker`丢失了 98％！ 让我们使用已经学到的几种不同策略来处理这些策略。
+    我们可以看到`average_montly_hours`丢失了约 2.5%，`time_spend_company`丢失了 1%，`is_smoker`丢失了 98%！ 让我们使用已经学到的几种不同策略来处理这些策略。

 2.  由于`is_smoker`指标中几乎没有任何信息，因此让我们删除此列。 通过运行以下命令来执行此操作：`del df['is_smoker']`。
 3.  由于`time_spend_company`是一个整数字段，因此我们将使用中位数来填充此列中的`NaN`值。 可以使用以下代码完成此操作：
@@ -619,7 +619,7 @@ k 最近邻分类算法可存储训练数据并根据特征空间中的 K 个最
    >> accuracy = 75.9%
    ```

-    我们预测测试样本的目标，然后使用 scikit-learn 的`accuracy_score`函数确定准确性。 结果看起来很有希望，达到〜75％！ 对于我们的第一个模型来说还不错。 但是请记住，目标是不平衡的。 让我们看看每个班级的预测有多准确。
+    我们预测测试样本的目标，然后使用 scikit-learn 的`accuracy_score`函数确定准确性。 结果看起来很有希望，达到〜75%！ 对于我们的第一个模型来说还不错。 但是请记住，目标是不平衡的。 让我们看看每个班级的预测有多准确。

 8.  计算混淆矩阵，然后通过运行包含以下代码的单元格来确定每个类别中的准确性：

@@ -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`。 如下所示：
@@ -1010,7 +1010,7 @@ k 折交叉验证算法如下：

    ![Training a predictive model for the employee retention problem](img/image2_54.jpg)

-    对于较小的最大深度，我们看到该模型无法拟合数据。 通过使决策树更深，并在数据中编码更复杂的模式，总精度会急剧增加。 随着最大深度的进一步增加和的准确性接近 100％，我们发现该模型过度拟合了数据，导致训练和验证的准确性不断提高。 基于此图，让我们为模型选择`6`的`max_depth`。
+    对于较小的最大深度，我们看到该模型无法拟合数据。 通过使决策树更深，并在数据中编码更复杂的模式，总精度会急剧增加。 随着最大深度的进一步增加和的准确性接近 100%，我们发现该模型过度拟合了数据，导致训练和验证的准确性不断提高。 基于此图，让我们为模型选择`6`的`max_depth`。

    我们确实应该对`n_estimators`做同样的事情，但是出于节省时间的精神，我们将跳过它。 欢迎您自己绘制。 您应该在训练和验证集之间找到适用于各种价值的协议。 通常，最好在“随机森林”中使用更多的决策树估计器，但这是以增加训练时间为代价的。 我们将使用 200 个估算器来训练我们的模型。

@@ -1119,7 +1119,7 @@ k 折交叉验证算法如下：

    ![Training a predictive model for the employee retention problem](img/image2_57.jpg)

-    将其与先前的结果进行比较，我们发现 1 级精度有所提高！ 现在，大多数验证集返回的准确性都超过 90％。 可以将 90.6％的平均精度与降低尺寸之前的的 85.6％的精度进行比较！
+    将其与先前的结果进行比较，我们发现 1 级精度有所提高！ 现在，大多数验证集返回的准确性都超过 90%。 可以将 90.6% 的平均精度与降低尺寸之前的的 85.6% 的精度进行比较！

    让我们选择它作为我们的最终模型。 在生产中使用它之前，我们需要在整个样本空间上对其进行重新训练。

@@ -1181,7 +1181,7 @@ k 折交叉验证算法如下：
    >> array([[ 0.06576239,  0.93423761]])
    ```

-    我们看到该模型预测她辞职的准确率为 93％。
+    我们看到该模型预测她辞职的准确率为 93%。

    由于这显然是管理层的一个危险信号，他们决定制定一个计划，将她的每月工作时间减少到`100`，并将公司的时间减少到`1`。

@@ -1192,7 +1192,7 @@ k 折交叉验证算法如下：
    >> array([[ 0.61070329,  0.38929671]])
    ```

-    出色的！ 现在我们可以看到该模型返回她退出的可能性仅为 38％！ 相反，它现在预测她不会离开公司。
+    出色的！ 现在我们可以看到该模型返回她退出的可能性仅为 38%！ 相反，它现在预测她不会离开公司。

 我们的模型允许管理层做出数据驱动的决策。 通过减少她在公司的工作时间这一特定数额，该模型告诉我们，她很可能将继续在公司任职！


--- a/new/handson-ds-py-ml/00.md
+++ b/new/handson-ds-py-ml/00.md
@@ -2,7 +2,7 @@

 成为科技行业的数据科学家是当今地球上最有意义的职业之一。 我去研究了技术公司中数据科学家角色的实际职位描述，并将这些要求简化为您将在本课程中看到的主题。

-*动手数据科学和 Python 机器学习*确实很全面。 我们将从 Python 速成班开始，并回顾一些基本的统计数据和概率，但随后我们将直接探讨数据挖掘和机器学习中的 60 多个主题。 其中包括贝叶斯定理，聚类，决策树，回归分析，实验设计等； 我们将全部看一下。 其中一些主题真的很有趣。
+《Python 数据科学和机器学习实用指南》确实很全面。 我们将从 Python 速成班开始，并回顾一些基本的统计数据和概率，但随后我们将直接探讨数据挖掘和机器学习中的 60 多个主题。 其中包括贝叶斯定理，聚类，决策树，回归分析，实验设计等； 我们将全部看一下。 其中一些主题真的很有趣。

 我们将使用实际的用户电影分级数据来开发实际的电影推荐系统。 我们将创建一个实际上可用于 Wikipedia 数据的搜索引擎。 我们将构建一个垃圾邮件分类器，该分类器可以正确地对您的电子邮件帐户中的垃圾邮件和非垃圾邮件进行分类，并且我们还将在整个章节中介绍如何使用 Apache Spark 将其扩展到在大数据上运行的集群。


--- a/new/handson-ds-py-ml/01.md
+++ b/new/handson-ds-py-ml/01.md
 # 入门

-由于将有与此书相关联的代码以及您需要获取的样本数据，所以让我首先向您展示如何获取该代码，然后我们将继续。 我们需要先进行一些设置。 首先，让我们获取本书所需的代码和数据，以便您可以随意学习并实际使用一些代码。 最简单的方法是转到*入门*。
+由于将有与此书相关联的代码以及您需要获取的样本数据，所以让我首先向您展示如何获取该代码，然后我们将继续。 我们需要先进行一些设置。 首先，让我们获取本书所需的代码和数据，以便您可以随意学习并实际使用一些代码。 最简单的方法是转到“入门”。

 在本章中，我们将首先在可运行的 Python 环境中安装并做好准备：

@@ -64,7 +64,7 @@
 ![](img/f48fb38b-f3e7-4680-aa80-02591d6569e0.png)

 11.  按下“返回”按钮后，将安装一个额外的模块，在我们稍后讨论决策树和呈现决策树时，我们将在本书的稍后部分中使用该模块。
-12.  一旦完成 **pydotplus** 的安装，它应该会回来并说它已成功安装，瞧，您现在就拥有开始所需的一切！ 至此，安装已完成-但让我们再采取一些步骤，以确认我们的安装运行良好。
+12.  一旦完成`pydotplus`的安装，它应该会回来并说它已成功安装，瞧，您现在就拥有开始所需的一切！ 至此，安装已完成-但让我们再采取一些步骤，以确认我们的安装运行良好。

 # 进行安装测试

@@ -95,7 +95,7 @@

 好的，现在让我们再次从上而下-我们对 IPython / Jupyter Notebook 的首次探索。 如果您尚未这样做，请导航到`DataScience`文件夹，我们在其中下载了本书的所有材料。 对我来说，这是`E:DataScience`，如果您在前面的安装部分中没有这样做，请双击并打开`Outliers.ipynb`文件。

-现在，当我们双击此 IPython `.` **`ipynb`** 文件时，将首先触发 Canopy，如果尚未触发，则将其触发。 启动网络浏览器。 这是完整的`Outliers`笔记本电脑网页在浏览器中的显示方式：
+现在，当我们双击此 IPython `.ipynb`文件时，将首先触发 Canopy，如果尚未触发，则将其触发。 启动网络浏览器。 这是完整的`Outliers`笔记本电脑网页在浏览器中的显示方式：

 ![](img/54ec0bbe-fb6c-447a-a671-b7ed06498363.png)

@@ -181,7 +181,7 @@ plt.show()

 新版本的 Canopy 将在您的 Web 浏览器中打开代码，而不是在 Canopy 编辑器中打开代码！ 没关系！

-关于 Python 的一件很酷的事情是，有几种方法可以使用 Python 运行代码。 您可以像使用普通编程语言一样将其作为脚本运行。 您还可以编写称为 *IPython Notebook* 的东西，这就是我们在这里使用的东西。 因此，在这种格式下，您实际上具有类似于 Web 浏览器的视图，在其中实际上可以在 HTML 标记内容中为自己写一些符号和注释，还可以嵌入实际使用 Python 解释器运行的实际代码。
+关于 Python 的一件很酷的事情是，有几种方法可以使用 Python 运行代码。 您可以像使用普通编程语言一样将其作为脚本运行。 您还可以编写称为 *IPython 笔记本*的东西，这就是我们在这里使用的东西。 因此，在这种格式下，您实际上具有类似于 Web 浏览器的视图，在其中实际上可以在 HTML 标记内容中为自己写一些符号和注释，还可以嵌入实际使用 Python 解释器运行的实际代码。

 # 了解 Python 代码

@@ -591,7 +591,7 @@ for ship in captains:

 # Python 基础-第 2 部分

-除了 *Python 基础知识-第 1 部分*之外，让我们现在尝试详细了解更多 Python 概念。
+除了“Python 基础知识-第 1 部分”之外，让我们现在尝试详细了解更多 Python 概念。

 # Python 中的函数


--- a/new/handson-ds-py-ml/02.md
+++ b/new/handson-ds-py-ml/02.md
--- a/new/handson-ds-py-ml/03.md
+++ b/new/handson-ds-py-ml/03.md
@@ -283,7 +283,7 @@ plt.show()

 ```

-您可以在这段代码中看到我正在创建一个值为`12`，`55`，`4`，`32`和`14`值的饼图。 我为这些值的每一个分配了明确的颜色，为这些值的每一个分配了明确的标签。 我将饼图的俄文部分放大了 20％，并为该图添加了“学生位置”标题并显示出来。 以下是您应该看到的输出：
+您可以在这段代码中看到我正在创建一个值为`12`，`55`，`4`，`32`和`14`值的饼图。 我为这些值的每一个分配了明确的颜色，为这些值的每一个分配了明确的标签。 我将饼图的俄文部分放大了 20%，并为该图添加了“学生位置”标题并显示出来。 以下是您应该看到的输出：

 ![](img/46c057a3-e9a6-40da-8748-ff1b8107251e.png)

@@ -348,7 +348,7 @@ plt.show()

 最后，让我们看一下箱须图。 请记住，在上一章中，当我们谈论百分位数时，我谈到了这一点。

-同样，使用箱须图，该框代表两个内部四分位数，其中 50％的数据位于该四分位数中。 相反，另外 25％的居民位于该盒子的两侧。 晶须（在我们的示例中为虚线）代表数据的范围（异常值除外）。
+同样，使用箱须图，该框代表两个内部四分位数，其中 50% 的数据位于该四分位数中。 相反，另外 25% 的居民位于该盒子的两侧。 晶须（在我们的示例中为虚线）代表数据的范围（异常值除外）。

 我们将箱须图中的离群值定义为四分位间距或框的大小的 1.5 倍以外的任何值。 因此，我们将盒子的大小乘以 1.5，直到点状晶须上的那个点，我们将这些部分称为四分位数外。 但是外部四分位数之外的任何东西都被视为离群值，这就是外部四分位数以外的线所代表的含义。 那就是我们根据盒须图绘制的定义来定义离群值的地方。

@@ -376,7 +376,7 @@ plt.show()

 ![](img/77d95176-b924-4737-b914-454a2ebca453.png)

-您可以看到该图形显示的框代表了所有数据的内部 50％，然后我们有了这些离群值线，在其中我们可以看到位于其中的每个离群值的小叉（在您的版本中可能是圆圈） 范围。
+您可以看到该图形显示的框代表了所有数据的内部 50%，然后我们有了这些离群值线，在其中我们可以看到位于其中的每个离群值的小叉（在您的版本中可能是圆圈） 范围。

 # 自己尝试

@@ -566,13 +566,13 @@ correlation (pageSpeeds, purchaseAmount)

 这里有一个例子会更有意义，所以请允许我。

-假设我给您，我的读者两个测试，并且你们中有 60％通过了这两个测试。 现在，第一个测试更加容易，您中的 80％通过了该测试。 我可以使用此信息来计算通过第一项考试的读者中还通过第二项考试的读者所占的百分比。 因此，这是一个真实的例子，说明给定 B 的 B 概率与 A 和 B 的概率之间的差异。
+假设我给您，我的读者两个测试，并且你们中有 60% 通过了这两个测试。 现在，第一个测试更加容易，您中的 80% 通过了该测试。 我可以使用此信息来计算通过第一项考试的读者中还通过第二项考试的读者所占的百分比。 因此，这是一个真实的例子，说明给定 B 的 B 概率与 A 和 B 的概率之间的差异。

 我将 A 表示通过第一项测试的概率，将 B 表示通过第二项测试的概率。 我要寻找的是给定您通过了第一项考试即第二项考试的概率，即 *P（B | A）*。

 ![](img/e4de6cdd-edda-437a-8e02-a49b596bf779.png)

-因此，假设您通过了第一个测试，则通过第二个测试的概率等于通过两个测试的概率 *P（A，B）*（我知道您中有 60％的人通过了两个测试，而与每个测试都无关 其他）除以通过第一项测试的概率 *P（A）*，即 80％。 算出 60％的人通过了两个测试，80％的人通过了第一次测试，因此，如果您通过了第一个测试，则通过第二次测试的概率为 75％。
+因此，假设您通过了第一个测试，则通过第二个测试的概率等于通过两个测试的概率 *P（A，B）*（我知道您中有 60% 的人通过了两个测试，而与每个测试都无关 其他）除以通过第一项测试的概率 *P（A）*，即 80%。 算出 60% 的人通过了两个测试，80% 的人通过了第一次测试，因此，如果您通过了第一个测试，则通过第二次测试的概率为 75%。

 好吧，围绕这个概念有点困难。 我花了一些时间才真正地内化了某些事物给定某种事物的概率与两件事相互独立发生的概率之间的差异。 在继续之前，请确保内部化此示例及其实际工作方式。

@@ -627,7 +627,7 @@ print ("P(purchase | 30s): ", PEF)

 ```

-考虑到您 30 岁左右时大约占 30％，我最终有可能购买某种东西：
+考虑到您 30 岁左右时大约占 30%，我最终有可能购买某种东西：

 ```py
 P(purchase | 30s): 0.2992959865211 
@@ -656,7 +656,7 @@ P(30's): 0.16619

 ```

-我知道进入您的`30s`的可能性约为 16％。
+我知道进入您的`30s`的可能性约为 16%。

 现在，我们将找出 *P（E）*，它仅代表购买产品的总体可能性，与您的年龄无关：

@@ -668,9 +668,9 @@ P(Purchase): 0.45012

 ```

-在此示例中，结果约为 45％。 我可以将每个人购买的商品总数（不分年龄），再除以总人数即可得出购买的总体概率。
+在此示例中，结果约为 45%。 我可以将每个人购买的商品总数（不分年龄），再除以总人数即可得出购买的总体概率。

-好吧，那我这里有什么？ 假设您在 30 多岁时购买的东西大约是 30％，那么我有购买的可能性，那么总体上，我有购买大约 45％的东西的可能性。
+好吧，那我这里有什么？ 假设您在 30 多岁时购买的东西大约是 30%，那么我有购买的可能性，那么总体上，我有购买大约 45% 的东西的可能性。

 现在，如果 E 和 F 独立，并且年龄无关紧要，那么我希望 *P（E | F）*与 *P（E）*大致相同。 考虑到您 30 多岁，我希望购买商品的可能性与购买商品的整体可能性大致相同，但事实并非如此，对吧？ 而且因为它们不同，所以告诉我它们实际上是某种程度上的依赖。 因此，这是使用条件概率来梳理数据中这些依赖关系的一种小方法。

@@ -683,7 +683,7 @@ P(30's)P(Purchase) 0.07480544280000001

 ```

-算下来大约是 7.5％。
+算下来大约是 7.5%。

 从概率的工作方式来看，我知道，如果我想获得两件事同时发生的概率，那就像乘以它们各自的概率一样。 因此，事实证明 *P（E，F）*的发生与 *P（E）P（F）*相同。

@@ -693,7 +693,7 @@ P(30's, Purchase) 0.04974

 ```

-现在，由于数据的随机分布，它不可能完全相同。 记住，我们在这里谈论的是概率，但是它们在同一范围内，所以有意义的是，大约 5％对 7％，足够接近。
+现在，由于数据的随机分布，它不可能完全相同。 记住，我们在这里谈论的是概率，但是它们在同一范围内，所以有意义的是，大约 5% 对 7%，足够接近。

 现在，这又不同于 *P（E | F）*，因此既在`30s`中又购买东西的概率不同于在`30s`中购买东西的概率 ]。

@@ -711,7 +711,7 @@ Out []:0.29929598652145134

 ```

-果然，它确实可以解决。 如果我考虑买入某物的概率高于您在`30s`中的总概率，那么我们最终得到大约 30％，这几乎是我们最初为 *P（E | F ）*。 所以方程式起作用了，是的！
+果然，它确实可以解决。 如果我考虑买入某物的概率高于您在`30s`中的总概率，那么我们最终得到大约 30%，这几乎是我们最初为 *P（E | F ）*。 所以方程式起作用了，是的！

 好吧，很难缠住这些东西。 我知道这有点令人困惑，但是如果您需要，请再次进行遍历，研究一下，并确保您了解这里发生的事情。 我在这里尝试输入足够的示例，以说明对这些内容的不同思考组合。 一旦您将其内部化，我将挑战您自己在这里实际进行一些工作。

@@ -763,9 +763,9 @@ for _ in range(100000):

 ```

-我在这里所做的是，我使用了原始代码段来创建我们的年龄组字典，以及每个年龄组为 100,000 个随机人群购买了多少代码。 我没有使购买概率取决于年龄，而是使它成为 40％的恒定概率。 现在，我们只是将人们随机分配到一个年龄段，他们都有相同的购买可能性。 让我们继续运行它。
+我在这里所做的是，我使用了原始代码段来创建我们的年龄组字典，以及每个年龄组为 100,000 个随机人群购买了多少代码。 我没有使购买概率取决于年龄，而是使它成为 40% 的恒定概率。 现在，我们只是将人们随机分配到一个年龄段，他们都有相同的购买可能性。 让我们继续运行它。

-现在，这一次，如果我计算 *P（E | F）*，即假设您在`30s`中，则有购买某物品的可能性，我得出了大约 40％的概率。
+现在，这一次，如果我计算 *P（E | F）*，即假设您在`30s`中，则有购买某物品的可能性，我得出了大约 40% 的概率。

 ```py
 PEF = float(purchases[30]) / float(totals[30]) 
@@ -775,7 +775,7 @@ P(purchase | 30s):  0.398760454901

 ```

-如果将其与购买的总体可能性进行比较，那也大约是 40％。
+如果将其与购买的总体可能性进行比较，那也大约是 40%。

 ```py
 PE = float(totalPurchases) / 100000.0 
@@ -811,7 +811,7 @@ P(Purchase): 0.4003

 让我们再把这个例子钉在家里。

-同样，药物测试可能是应用贝叶斯定理证明观点的常见示例。 即使是高度准确的药物测试，也会产生比真实阳性更多的假阳性。 因此，在这里的示例中，我们将提出一种药物测试，该测试可以在 99％的时间内准确地识别出某种药物的使用者，并且对于 99％的非使用者来说准确地得出阴性结果，但只有 0.3％ 整个人口实际上正在使用有问题的药物。 因此，我们实际成为毒品使用者的可能性很小。 看来 99％的非常高的准确度实际上还不够高，对吧？
+同样，药物测试可能是应用贝叶斯定理证明观点的常见示例。 即使是高度准确的药物测试，也会产生比真实阳性更多的假阳性。 因此，在这里的示例中，我们将提出一种药物测试，该测试可以在 99% 的时间内准确地识别出某种药物的使用者，并且对于 99% 的非使用者来说准确地得出阴性结果，但只有 0.3% 整个人口实际上正在使用有问题的药物。 因此，我们实际成为毒品使用者的可能性很小。 看来 99% 的非常高的准确度实际上还不够高，对吧？

 我们可以算出以下公式：

@@ -820,15 +820,15 @@ P(Purchase): 0.4003

 因此，让事件 A 表示您是某种药物的使用者，事件 B 表示您使用此药物测试对药物进行了积极测试的事件。

-我们需要确定总体上进行积极测试的可能性。 如果您是用户，则可以通过测试呈阳性的概率之和，如果您不是用户，则可以通过测试呈阳性的概率之和。 因此，在此示例中，P（B）计算为 1.3％（0.99 * 0.003 + 0.01 * 0.997）。 因此，我们有 B 的概率，即在不了解您的情况下对整个药物进行积极测试的概率。
+我们需要确定总体上进行积极测试的可能性。 如果您是用户，则可以通过测试呈阳性的概率之和，如果您不是用户，则可以通过测试呈阳性的概率之和。 因此，在此示例中，P（B）计算为 1.3%（0.99 * 0.003 + 0.01 * 0.997）。 因此，我们有 B 的概率，即在不了解您的情况下对整个药物进行积极测试的概率。

 假设您的测试积极，让我们进行数学计算并计算出成为该药物使用者的可能性。

 ![](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）*高。
+即使 *P（B | A）*高（99%），也并不意味着 *P（A | B）*高。

 人们一直无视这一点，因此，如果要从贝叶斯定理中吸取教训，那就总是将这类事情付之东流。 将贝叶斯定理应用于这些实际问题，您经常会发现，如果您要解决给定问题的总体发生率较低的情况，那么听起来准确率很高的结果实际上可能会产生非常令人误解的结果。 我们在癌症筛查和其他类型的医学筛查中也看到了同样的事情。 这是一个非常现实的问题。 由于不了解贝叶斯定理，导致许多人接受非常非常非常真实且不必要的手术。 如果您要进入具有大数据的医学专业，请，请记住这个定理。


--- a/new/handson-ds-py-ml/05.md
+++ b/new/handson-ds-py-ml/05.md
@@ -110,7 +110,7 @@ scatter(pageSpeeds, purchaseAmount)

 ![](img/a215de99-d26a-4838-9482-274b254b3d20.jpg)

-接下来，我们将拆分数据。 我们将使用 80％的数据，并将保留这些数据作为培训数据。 因此，这些点中只有 80％将用于训练模型，然后我们将保留另外 20％的点，以针对看不见的数据测试该模型。
+接下来，我们将拆分数据。 我们将使用 80% 的数据，并将保留这些数据作为培训数据。 因此，这些点中只有 80% 将用于训练模型，然后我们将保留另外 20% 的点，以针对看不见的数据测试该模型。

 我们将在此处使用 Python 的语法拆分列表。 前 80 分将进入训练集，而后 20 分（80 之后的所有事物）将进入测试集。 您可能在前面的《 Python 基础知识》一章中记起了这一点，在该章中，我们介绍了执行此操作的语法，并且我们将在此处针对购买金额执行相同的操作：

@@ -217,7 +217,7 @@ print r2

 ```

-r 平方值原来是`0.6`，这并不奇怪，因为我们在训练数据上对其进行了训练。 坦率地说，测试数据有点未知，也无法测试。 30％，那是 F！
+r 平方值原来是`0.6`，这并不奇怪，因为我们在训练数据上对其进行了训练。 坦率地说，测试数据有点未知，也无法测试。 30%，那是 F！

 因此，这是一个示例，其中我们使用了训练/测试来评估监督学习算法，就像我之前说的那样，Pandas提供了一些使这一过程变得更加容易的方法。 我们稍后再讨论，还将在本书的稍后部分中查看更多训练/测试示例，包括 k 折交叉验证。


--- a/new/handson-ds-py-ml/07.md
+++ b/new/handson-ds-py-ml/07.md
@@ -343,7 +343,7 @@ PCA 模型带给我们的东西`explained_variance_ratio`。 基本上，这告

 ![](img/b5dd7d8a-29b5-4e7e-be53-21821ac9418c.png)

-它所带给您的实际上是我们保留的 2 个维度的 2 个项目的列表。 这告诉我，在第一个维度中，我实际上可以保留数据中 92％的方差，而第二个维度仅给了我 5％的方差。 如果将它们放在一起，这就是我将数据投影到的这两个维度，我仍然保留了源数据中 97％以上的方差。 我们可以看到，实际上并不需要 4 个维度来捕获此数据集中的所有信息，这很有趣。 这是很酷的东西！
+它所带给您的实际上是我们保留的 2 个维度的 2 个项目的列表。 这告诉我，在第一个维度中，我实际上可以保留数据中 92% 的方差，而第二个维度仅给了我 5% 的方差。 如果将它们放在一起，这就是我将数据投影到的这两个维度，我仍然保留了源数据中 97% 以上的方差。 我们可以看到，实际上并不需要 4 个维度来捕获此数据集中的所有信息，这很有趣。 这是很酷的东西！

 如果您考虑一下，为什么会这样呢？ 好吧，也许花的整体大小与其中心的物种有一定关系。 也许是花瓣和萼片的长宽比。 您知道，对于给定的物种或给定的花朵总大小，其中某些事物可能会彼此协同移动。 因此，PCA 自己提取的这四个维度之间可能存在关系。 这很酷，功能也很强大。 让我们继续进行可视化。


--- a/new/handson-ds-py-ml/08.md
+++ b/new/handson-ds-py-ml/08.md
@@ -113,15 +113,15 @@ clf.score(X_test, y_test)

 为此，我们有一个`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()`函数以仅针对我们的测试数据集测量其性能。 因此，我们根据为虹膜测量保留的测试数据和虹膜种类对模型进行评分，并观察其效果如何：

 ![](img/7d9b6519-0e08-4385-af2a-4dc643935313.jpg)

-事实证明，它确实做得很好！ 在超过 96％的时间中，我们的模型仅基于该虹膜的测量值就能够正确预测它从未见过的虹膜的种类。 太酷了！
+事实证明，它确实做得很好！ 在超过 96% 的时间中，我们的模型仅基于该虹膜的测量值就能够正确预测它从未见过的虹膜的种类。 太酷了！

-但是，这是一个相当小的数据集，如果我没记错的话，大约有 150 朵花。 因此，我们仅使用 150 朵花中的 60％进行训练，而仅使用 150 朵花中的 40％进行测试。 这些仍然是很小的数字，因此我们仍然可能过度适合于我们进行的特定训练/测试分组。 因此，让我们使用 k 倍交叉验证来防止这种情况。 事实证明，使用 k 折交叉验证（即使它是更可靠的技术），实际上实际上比训练/测试更容易使用。 所以，这很酷！ 因此，让我们看看它是如何工作的：
+但是，这是一个相当小的数据集，如果我没记错的话，大约有 150 朵花。 因此，我们仅使用 150 朵花中的 60% 进行训练，而仅使用 150 朵花中的 40% 进行测试。 这些仍然是很小的数字，因此我们仍然可能过度适合于我们进行的特定训练/测试分组。 因此，让我们使用 k 倍交叉验证来防止这种情况。 事实证明，使用 k 折交叉验证（即使它是更可靠的技术），实际上实际上比训练/测试更容易使用。 所以，这很酷！ 因此，让我们看看它是如何工作的：

 ```py
 # We give cross_val_score a model, the entire data set and its "real" values, and the number of folds: 
@@ -143,7 +143,7 @@ print scores.mean()

 ![](img/705c48f3-a3b4-4d63-ae15-c4159c0e5c76.png)

-当我们这样做超过 5 倍时，我们可以看到我们的结果甚至比我们想象的还要好！ 98％的准确性。 太酷了！ 实际上，在几次运行中我们都具有完美的准确性。 所以这真是太神奇了。
+当我们这样做超过 5 倍时，我们可以看到我们的结果甚至比我们想象的还要好！ 98% 的准确性。 太酷了！ 实际上，在几次运行中我们都具有完美的准确性。 所以这真是太神奇了。

 现在，让我们看看是否可以做得更好。 以前我们使用线性核，如果我们使用多项式核甚至更高级怎么办？ 这会过拟合还是实际上会更好地拟合我们拥有的数据？ 这种类型取决于这些花瓣测量值与实际物种之间是否存在线性关系或多项式关系。 因此，让我们尝试一下：


--- a/new/handson-ds-py-ml/10.md
+++ b/new/handson-ds-py-ml/10.md
@@ -120,7 +120,7 @@ p 值基本上是该实验满足原假设的概率，即对照和治疗行为之

 您想要看到的是高 t 统计量和低 p 值，这将意味着显着的结果。 现在，在开始实验之前，您需要确定成功的门槛，这意味着与业务负责人一起确定门槛。

-那么，您愿意接受什么 p 值来衡量成功？ 是百分之一吗？ 是 5％吗？ 同样，这基本上是没有实际影响的可能性，这仅仅是随机方差的结果。 这只是一天结束时的判断电话。 很多时候人们使用 1％，有时如果感觉有点风险则使用 5％，但总有机会将您的结果只是虚假的随机数据输入。
+那么，您愿意接受什么 p 值来衡量成功？ 是百分之一吗？ 是 5% 吗？ 同样，这基本上是没有实际影响的可能性，这仅仅是随机方差的结果。 这只是一天结束时的判断电话。 很多时候人们使用 1%，有时如果感觉有点风险则使用 5%，但总有机会将您的结果只是虚假的随机数据输入。

 但是，您可以选择愿意接受的可能性，使其具有足够的效果，这是真实的效果，值得将其推广到生产中。

@@ -180,11 +180,11 @@ stats.ttest_ind(A, B)

 ![](img/81066228-b08e-4aa3-85af-015efe4ac2b3.jpg)

-请记住，这是根据标准偏差得出的。 因此，这意味着除非我们还有更高的 p 值（超过 30％），否则那里可能没有真正的变化。
+请记住，这是根据标准偏差得出的。 因此，这意味着除非我们还有更高的 p 值（超过 30%），否则那里可能没有真正的变化。

 现在，这些数字仍然相对较高。 您会看到随机变化可能是一种阴险的事情。 这就是为什么您需要提前决定 p 值可接受的限制的原因。

-您知道之后，可以看看事实，然后说：“ 30％的几率，这还不错，我们可以接受，”但是，没有。 我的意思是，在现实和实践中，您希望看到 p 值低于 5％，理想情况下低于 1％，而 30％的值实际上意味着结果不那么强。 因此，不要在事后证明其合理性，而要进行实验以了解阈值是多少。
+您知道之后，可以看看事实，然后说：“ 30% 的几率，这还不错，我们可以接受，”但是，没有。 我的意思是，在现实和实践中，您希望看到 p 值低于 5%，理想情况下低于 1%，而 30% 的值实际上意味着结果不那么强。 因此，不要在事后证明其合理性，而要进行实验以了解阈值是多少。

 # 样本量是否有所不同？

@@ -224,7 +224,7 @@ stats.ttest_ind(A, B)

 ![](img/7b3983dd-a665-431d-adee-6de6bb8b15ee.jpg)

-那是做什么的？ 好吧，现在，我们的 t 统计量回到了 1 以下，我们的价值约为 35％。
+那是做什么的？ 好吧，现在，我们的 t 统计量回到了 1 以下，我们的价值约为 35%。

 随着样本数量的增加，我们会在任一方向上看到这种波动。 这意味着从 10,000 个样本增加到 100,000 个至 1,000,000 个样本并不会改变您的结果。 进行这样的实验是一种良好的直觉，可以使您感觉需要进行多长时间。 实际需要多少个样本才能得出明显的结果？ 而且，如果您提前知道有关数据分布的信息，则可以实际运行这些模型。

@@ -245,7 +245,7 @@ stats.ttest_ind(A, A)

 继续进行下去，看看不同标准差对初始数据集，均值差异和不同样本量的影响。 我只想让您深入研究这些不同的数据集并进行实际运行，并查看它们对 t 统计量和 p 值的影响。 希望这会使您对如何解释这些结果有更多的了解。

-同样，要了解的重要一点是，您正在寻找较大的 t 统计量和较小的 p 值。 P 值很可能就是您要与企业沟通的内容。 记住，p 值越低越好，您希望看到单位数，最好在宣布胜利之前低于 1％。
+同样，要了解的重要一点是，您正在寻找较大的 t 统计量和较小的 p 值。 P 值很可能就是您要与企业沟通的内容。 记住，p 值越低越好，您希望看到单位数，最好在宣布胜利之前低于 1%。

 在本章的其余部分中，我们将更多地讨论 A / B 测试。 SciPy 可以非常轻松地为给定的数据集计算 t 统计量和 p 值，因此您可以非常轻松地比较对照组和治疗组之间的行为，并衡量该效应是真实的还是只是概率 随机变化的结果。 确保您专注于这些指标，并且正在衡量进行这些比较时关心的转化指标。

@@ -255,7 +255,7 @@ stats.ttest_ind(A, A)

 如果您公司中的某人开发了一个新的实验，他们想要测试的新变更，那么他们就对成功有浓厚的兴趣。 他们投入了大量的工作和时间，并且希望它取得成功。 也许您已经进行了数周的测试，但您仍未在该实验中获得正面或负面的重大成果。 您知道他们将无限期地继续运行它，以期最终显示出积极的结果。 由您决定您愿意运行此实验的时间。

-如何知道完成 A / B 测试的时间？ 我的意思是，预测获得显着结果所需的时间并不总是那么简单，但是很明显，如果您获得了显着结果，p 值低于 1％或 5％或任何阈值， 选择，您就完成了。
+如何知道完成 A / B 测试的时间？ 我的意思是，预测获得显着结果所需的时间并不总是那么简单，但是很明显，如果您获得了显着结果，p 值低于 1% 或 5% 或任何阈值， 选择，您就完成了。

 届时，您可以拔掉实验的插头，将更改更广泛地推出或删除，因为它实际上具有负面影响。 您总是可以告诉人们回去再试一次，利用他们从实验中学到的知识，也许可以进行一些更改后再试一次，并减轻一点打击。

@@ -275,7 +275,7 @@ stats.ttest_ind(A, A)

 我要说明的一个重要问题是，即使您使用 p 值以原则方式测量 A / B 测试的结果，也不是福音。 实际上，有许多影响因素可能会扭曲实验结果，并导致您做出错误的决定。 让我们仔细研究其中的一些，让您知道如何注意它们。 让我们谈谈 A / B 测试的一些陷阱。

-说 p 值为 1％听起来很正式，这意味着给定实验只有 1％的机会是由于虚假结果或随机变化引起的，但这并不是衡量成功与否的全部 做一个实验。 有许多事情可能会歪曲或混淆您需要注意的结果。 因此，即使您看到一个看起来很令人鼓舞的 p 值，您的实验仍然可能对您不利，并且您需要了解可以实现该目标的事情，以免做出错误的决定。
+说 p 值为 1% 听起来很正式，这意味着给定实验只有 1% 的机会是由于虚假结果或随机变化引起的，但这并不是衡量成功与否的全部 做一个实验。 有许多事情可能会歪曲或混淆您需要注意的结果。 因此，即使您看到一个看起来很令人鼓舞的 p 值，您的实验仍然可能对您不利，并且您需要了解可以实现该目标的事情，以免做出错误的决定。

 请记住，关联并不意味着因果关系。


--- a/new/master-py-ds/02.md
+++ b/new/master-py-ds/02.md
@@ -35,7 +35,7 @@

 ### 来自二项式分布的正态分布

-让我们拿一个硬币并将其翻转。 出现头或尾的概率为 50％。 如果您使用同一枚硬币并将其翻转六次，则可以使用以下公式计算获得三倍正面的概率：
+让我们拿一个硬币并将其翻转。 出现头或尾的概率为 50%。 如果您使用同一枚硬币并将其翻转六次，则可以使用以下公式计算获得三倍正面的概率：

 ![A normal distribution from a binomial distribution](img/3450_02_04.jpg)

@@ -119,7 +119,7 @@ SciPy 软件包中的`binom`函数有助于生成二项式分布以及与之相

 ```

-使用泊松函数，我们定义了平均值，即 20 辆汽车。 `rv.pmf`函数给出 23 辆车通过桥的可能性，大约为 6％。
+使用泊松函数，我们定义了平均值，即 20 辆汽车。 `rv.pmf`函数给出 23 辆车通过桥的可能性，大约为 6%。

 ## 伯努利发行

@@ -154,7 +154,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,

 ```

-如果前面的输出是候选人的票数，则候选人拥有 70％的票数。
+如果前面的输出是候选人的票数，则候选人拥有 70% 的票数。

 # Z 得分

@@ -227,13 +227,13 @@ NumPy 程序包具有一个具有正态函数的随机模块，其中 50 是分

 `cdf`函数给出了将值提高到`1.334`的 z 分数的可能性，而减一则将给我们获得 z 分数（在其之上）的概率。 换句话说，0.09 是获得高于 60 的分数的概率。

-我们再问一个问题：“有多少学生进入了班级前 20％？”
+我们再问一个问题：“有多少学生进入了班级前 20%？”

-在这里，我们必须向后进行操作，以确定高于该水平的所有学生都位于班级前 20％的分数：
+在这里，我们必须向后进行操作，以确定高于该水平的所有学生都位于班级前 20% 的分数：

 ![A z-score](img/B03450_02_18.jpg)

-现在，要获得得分最高的 20％的 z 分数，我们可以在 SciPy 中使用`ppf`函数：
+现在，要获得得分最高的 20% 的 z 分数，我们可以在 SciPy 中使用`ppf`函数：

 ```py
 >>> stats.norm.ppf(0.80)
@@ -242,7 +242,7 @@ NumPy 程序包具有一个具有正态函数的随机模块，其中 50 是分

 ```

-用于确定前 20％标记是否位于 0.84 的先前输出的 z 得分如下：
+用于确定前 20% 标记是否位于 0.84 的先前输出的 z 得分如下：

 ```py
 >>> (0.84 * classscore.std()) + classscore.mean()
@@ -251,7 +251,7 @@ NumPy 程序包具有一个具有正态函数的随机模块，其中 50 是分

 ```

-我们将 z 分数与标准偏差相乘，然后将结果与分布的平均值相加。 这有助于将 z 分数转换为分布中的值。 `55.83`分数表示分数超过该分数的学生位于分布的前 20％。
+我们将 z 分数与标准偏差相乘，然后将结果与分布的平均值相加。 这有助于将 z 分数转换为分布中的值。 `55.83`分数表示分数超过该分数的学生位于分布的前 20%。

 z 分数是统计学中必不可少的概念，已被广泛使用。 现在您可以理解，它基本上用于标准化任何分布，以便可以对其进行比较或从中推论得出。

@@ -265,7 +265,7 @@ p 值是当假设被证明是正确的时，否定原假设的概率。 零假

 让我们以一个示例为例，来了解一下的概念：**零假设**是学生在数学上获得 68 分的普遍现象。

-让我们将显着性水平定义为 5％。 如果 p 值小于 5％，则原假设被拒绝，在数学中得分 68 分并不常见。
+让我们将显着性水平定义为 5%。 如果 p 值小于 5%，则原假设被拒绝，在数学中得分 68 分并不常见。

 让我们获得 68 分的 z 分数：

@@ -287,7 +287,7 @@ p 值是当假设被证明是正确的时，否定原假设的概率。 零假

 ![A p-value](img/B03450_02_20.jpg)

-因此，您可以看到 p 值为 3.2％，低于显着性水平。 这意味着无效的假设可以被拒绝，并且可以说在数学上获得 68 分并不常见。
+因此，您可以看到 p 值为 3.2%，低于显着性水平。 这意味着无效的假设可以被拒绝，并且可以说在数学上获得 68 分并不常见。

 # 一尾和二尾测试

@@ -297,7 +297,7 @@ p 值是当假设被证明是正确的时，否定原假设的概率。 零假

 ![One-tailed and two-tailed tests](img/B03450_02_21.jpg)

-在双尾检验中，当使用 5％的显着性水平时，则在两个方向上均等分布，即，在一个方向上为 2.5％，在另一个方向上为 2.5％。
+在双尾检验中，当使用 5% 的显着性水平时，则在两个方向上均等分布，即，在一个方向上为 2.5%，在另一个方向上为 2.5%。

 让我们通过一个例子来理解这一点。 国家一级的数学考试平均成绩为 60 分，标准差为 3 分。

@@ -320,7 +320,7 @@ p 值为：

 ```

-因此，p 值为 0.98％。 原假设将被拒绝，并且在钟形曲线的任一方向上，p 值均应小于 2.5％。 由于 p 值小于 2.5％，因此我们可以拒绝原假设，并明确声明该类别的平均成绩与全国平均水平显着不同。
+因此，p 值为 0.98%。 原假设将被拒绝，并且在钟形曲线的任一方向上，p 值均应小于 2.5%。 由于 p 值小于 2.5%，因此我们可以拒绝原假设，并明确声明该类别的平均成绩与全国平均水平显着不同。

 # 类型 1 和类型 2 错误

@@ -330,7 +330,7 @@ p 值为：

 让我们通过一个例子来理解这个概念。 正在开发一种新药，需要对其是否有效抵抗疾病进行测试。 零假设是它在对抗疾病方面无效。

-显着性水平保持在 5％，以便可以在 95％的时间自信地接受原假设。 但是，在 5％的情况下，尽管必须接受该假设，但我们仍会接受该假设的拒绝，这意味着即使该药物无效，也被认为是有效的。
+显着性水平保持在 5%，以便可以在 95% 的时间自信地接受原假设。 但是，在 5% 的情况下，尽管必须接受该假设，但我们仍会接受该假设的拒绝，这意味着即使该药物无效，也被认为是有效的。

 通过控制显着性水平（即 alpha）来控制类型 1 错误。 Alpha 是发生 1 类错误的最高概率。 Alpha 值越低，Type 1 错误就越小。

@@ -346,7 +346,7 @@ p 值为：

 ![A confidence interval](img/B03450_02_23.jpg)

-让我们尝试通过一个例子来理解这个概念。 让我们以肯尼亚每个男人的身高为标准，并以 95％的置信区间确定全国范围内肯尼亚男人的平均身高。
+让我们尝试通过一个例子来理解这个概念。 让我们以肯尼亚每个男人的身高为标准，并以 95% 的置信区间确定全国范围内肯尼亚男人的平均身高。

 让我们以 50 个人为例，其身高以厘米为单位：

@@ -409,7 +409,7 @@ p 值为：

 *183.24-（1.96 * 1.38）= 180.53*

-1.96 标准偏差覆盖正态分布中 95％的面积。
+1.96 标准偏差覆盖正态分布中 95% 的面积。

 我们可以自信地说，人口平均值在 180.53 厘米至 185.94 厘米之间。

@@ -767,7 +767,7 @@ f 统计量由以下公式给出：

 ```

-输出的第一个值给出 F 值，第二个值给出 p 值。 由于 p 值略微大于 5％，因此我们可以看出三个国家的身高平均值没有显着差异。
+输出的第一个值给出 F 值，第二个值给出 p 值。 由于 p 值略微大于 5%，因此我们可以看出三个国家的身高平均值没有显着差异。

 # 摘要


--- a/new/master-py-ds/03.md
+++ b/new/master-py-ds/03.md
@@ -41,7 +41,7 @@

 *   **店铺行为**：以下是用于简化分析的问题：

-    *   百分之八十的店铺占收入的 80％？
+    *   百分之八十的店铺占收入的 80%？
    *   哪种网点的销售量最高？
    *   什么样的商店主要销售优质产品？

@@ -183,8 +183,8 @@
 这些是我们的观察结果：

 *   幸存者的最大人数分别是一等和三等
-*   对于每个班级的乘客总数，头等舱的最大幸存者约为 61％
-*   对于每个舱位的乘客总数，三等舱的幸存者人数最少，约为 25％
+*   对于每个班级的乘客总数，头等舱的最大幸存者约为 61%
+*   对于每个舱位的乘客总数，三等舱的幸存者人数最少，约为 25%

 这是我们的主要收获：

@@ -262,7 +262,7 @@
 这些是我们的观察：

 *   所有班级中大多数幸存者是女性
-*   头等舱和二等舱中超过 90％的女性乘客幸存
+*   头等舱和二等舱中超过 90% 的女性乘客幸存
 *   在头等舱和三等舱中幸存下来的男性乘客百分比是可比的

 此是我们的主要收获：

--- a/new/master-py-ds/05.md
+++ b/new/master-py-ds/05.md
@@ -197,7 +197,7 @@ Logistic 回归是另一种监督学习技术，它基本上是一种概率分

 让我们尝试通过下面的示例解决这个方程，以理解朴素的贝叶斯公式：

-明天，Stacy 会在奥斯汀的户外仪式上与她订婚。 在过去的几年中，奥斯汀一年只有六个雨天。 不幸的是，天气预报员明天已经预报了降雨。 在 80％的时间里，天气预报员准确地预测了降雨。 但是，他在不下雨时有 20％的时间错误地预测了天气。 确定在 Stacy 订婚那天下雨的概率。 以下是一些事件，基于这些事件可以计算出概率：
+明天，Stacy 会在奥斯汀的户外仪式上与她订婚。 在过去的几年中，奥斯汀一年只有六个雨天。 不幸的是，天气预报员明天已经预报了降雨。 在 80% 的时间里，天气预报员准确地预测了降雨。 但是，他在不下雨时有 20% 的时间错误地预测了天气。 确定在 Stacy 订婚那天下雨的概率。 以下是一些事件，基于这些事件可以计算出概率：

 *   *AI* ：此事件表明 Stacy 的参与正在下雨
 *   *A2* ：此事件表明在 Stacy 的订婚中不下雨
@@ -207,8 +207,8 @@ Logistic 回归是另一种监督学习技术，它基本上是一种概率分

 *   *P（AI）= 6/365 = 0.016438* ：这意味着每年下雨六天
 *   *P（AII）= 359/365 = 0.98356* ：这意味着一年中不会下雨 359 天
-*   *P（B | AI）= 0.8* ：这意味着在 80％的时间里，天气预报员下雨了
-*   *P（B | AII）= 0.2* ：这意味着 20％的时间不会像天气预报员所预测的那样下雨
+*   *P（B | AI）= 0.8* ：这意味着在 80% 的时间里，天气预报员下雨了
+*   *P（B | AII）= 0.2* ：这意味着 20% 的时间不会像天气预报员所预测的那样下雨

 以下公式可帮助我们计算朴素贝叶斯概率：

@@ -218,7 +218,7 @@ Logistic 回归是另一种监督学习技术，它基本上是一种概率分

 *P（AI | B）= 0.065*

-因此，前面的计算表明，即使气象员预测会下雨，根据贝叶斯定理，实际上也只有 6.5％的机会会下雨
+因此，前面的计算表明，即使气象员预测会下雨，根据贝叶斯定理，实际上也只有 6.5% 的机会会下雨

 朴素的贝叶斯在电子邮件过滤中大量使用。 它采用电子邮件中每个单词的实例，并计算电子邮件是否为垃圾邮件的概率。 朴素的贝叶斯模型从以前的电子邮件历史中学习，并将邮件标记为垃圾邮件，这有助于得出有关电子邮件是否为垃圾邮件的结论。


--- a/new/master-py-ds/06.md
+++ b/new/master-py-ds/06.md
@@ -136,12 +136,12 @@ Coefficient value of the height is [ 1.00092142]
 3.  最高的球员是 7.7 英尺（沙奎尔·奥尼尔站在 7.1 英尺）。
 4.  体重最轻的球员只有 105 磅，这是相当晦涩的。
 5.  最重的球员是 263 磅。
-6.  球员的最佳投篮命中率是 60％。
-7.  球员最差的投篮命中率是 29％。
-8.  一名球员的平均投篮命中率为 45％，但是从较小的标准偏差中，我们可以看到大多数球员的投篮命中率在 40％至 50％之间。
+6.  球员的最佳投篮命中率是 60%。
+7.  球员最差的投篮命中率是 29%。
+8.  一名球员的平均投篮命中率为 45%，但是从较小的标准偏差中，我们可以看到大多数球员的投篮命中率在 40% 至 50% 之间。
 9.  在罚球中，有一位球员错过了 3/4 的时间。
-10.  最佳罚球手的成功率达到 90％。
-11.  大多数球员的罚球成功率约为 70％至 80％。
+10.  最佳罚球手的成功率达到 90%。
+11.  大多数球员的罚球成功率约为 70% 至 80%。
 12.  玩家每场比赛最高得分是 27。
 13.  得分最低是 3。
 14.  玩家平均得分为 12 分。
@@ -252,7 +252,7 @@ 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% 的数据训练和测试集。

 我们将学习如何使用以下程序包构建线性回归模型：


--- a/new/master-py-ds/07.md
+++ b/new/master-py-ds/07.md
@@ -233,8 +233,8 @@ Logistic 回归是一种回归分析，可帮助您根据某些给定参数估

 让我们了解精确度和召回率的含义。

-*   **精度**：精度告诉您，在 0 类或 1 类的所有预测中，有多少个已正确预测。 因此，在上述情况下，非幸存者的预测的 76％是正确的，而幸存者的预测的 100％是正确的。
-*   **调用**：调用告诉您，在实际实例中，有多少个已正确预测。 因此，在上述情况下，所有未幸存的人都可以 100％的准确度正确预测，但是在所有幸存的人中，只有 53％的人被正确预测了。
+*   **精度**：精度告诉您，在 0 类或 1 类的所有预测中，有多少个已正确预测。 因此，在上述情况下，非幸存者的预测的 76% 是正确的，而幸存者的预测的 100% 是正确的。
+*   **调用**：调用告诉您，在实际实例中，有多少个已正确预测。 因此，在上述情况下，所有未幸存的人都可以 100% 的准确度正确预测，但是在所有幸存的人中，只有 53% 的人被正确预测了。

 让我们绘制**接收器工作特性**（**ROC**）曲线，其解释如下：


--- a/new/master-py-ds/09.md
+++ b/new/master-py-ds/09.md
@@ -344,7 +344,7 @@ GPA 高且属于非常春藤盟校的申请人与 GPA 低且属于非常春藤

 ![Decision trees](img/B03450_09_12.jpg)

-我们可以看到，收入不超过$ 50K 的人们可以得到很好的预测，其准确度为 85％，召回率为 87％。 收入超过$ 50K 的人只能以 56％的准确度和 52％的召回率来预测
+我们可以看到，收入不超过$ 50K 的人们可以得到很好的预测，其准确度为 85%，召回率为 87%。 收入超过$ 50K 的人只能以 56% 的准确度和 52% 的召回率来预测

 请注意，公式中给出的因变量的顺序将略微更改这些值。 您可以尝试查看更改变量的顺序是否会提高其精度/调用率。

@@ -399,7 +399,7 @@ GPA 高且属于非常春藤盟校的申请人与 GPA 低且属于非常春藤

 ![Random forests](img/B03450_09_14.jpg)

-我们将召回率提高了 0％至 90％，1％至 56％和 1％至 65％的精度。
+我们将召回率提高了 0% 至 90%，1% 至 56% 和 1% 至 65% 的精度。

 我们将使用`min_leaf`参数将最小叶数增加到`2`，从而进一步调整模型。 此参数的含义表示要创建的最小节点数为`2`：

@@ -422,7 +422,7 @@ GPA 高且属于非常春藤盟校的申请人与 GPA 低且属于非常春藤

 ![Random forests](img/B03450_09_15.jpg)

-我们进一步将召回率从 0％提高到了 92％，并将查准率提高了 1％至 70％。 这个模型表现不错。
+我们进一步将召回率从 0% 提高到了 92%，并将查准率提高了 1% 至 70%。 这个模型表现不错。

 让我们看看有助于预测的变量的重要性。 我们将使用`clf`对象的特征重要性属性，并使用它来绘制重要特征，例如按重要性排序的因变量：


--- a/new/master-py-ds/10.md
+++ b/new/master-py-ds/10.md
 # 第 10 章。通过 k-means 聚类应用细分

-聚类属于无监督学习，有助于以一种使组中的实例具有相似特征的方式将一个实例划分为多个组。 亚马逊可能想了解他们的高价值，中价值和低价值用户是谁。 以最简单的形式，我们可以通过将每个用户的总交易金额存储在三个存储桶中来确定这一点。 高价值客户将排在前 20％的百分比范围内，中值客户将排在第 20 至 80％的百分比范围内，而最低 20％的百分比将包含低价值客户。 亚马逊将由此了解他们的高价值客户，并确保在发生某些情况（例如交易付款失败）时会照顾他们。 在这里，我们使用了一个变量，例如交易金额，并且我们手动存储了数据。
+聚类属于无监督学习，有助于以一种使组中的实例具有相似特征的方式将一个实例划分为多个组。 亚马逊可能想了解他们的高价值，中价值和低价值用户是谁。 以最简单的形式，我们可以通过将每个用户的总交易金额存储在三个存储桶中来确定这一点。 高价值客户将排在前 20% 的百分比范围内，中值客户将排在第 20 至 80% 的百分比范围内，而最低 20% 的百分比将包含低价值客户。 亚马逊将由此了解他们的高价值客户，并确保在发生某些情况（例如交易付款失败）时会照顾他们。 在这里，我们使用了一个变量，例如交易金额，并且我们手动存储了数据。

 我们需要一种算法，该算法可以采用多个变量，并可以帮助我们进行存储分区实例。 k 均值是执行聚类的最流行算法之一，因为它是在聚类下最容易理解的机器学习算法。 此外，细分是将客户分为多个组的过程，而聚类是一种有助于发现组中相似点并帮助将客户分配给特定组的技术。


--- a/new/py-ds-essentials/1.md
+++ b/new/py-ds-essentials/1.md
@@ -45,7 +45,7 @@ Python 创建于 1991 年，是一种通用的，解释性的和面向对象的

 # Python 2 还是 Python 3？

-Python 有两个主要分支：2.7.x 和 3.x。 在本书的第三版修订时，Python 基金会（ [www.python.org/](http://www.python.org/) ）正在提供 Python 版本 2.7.15（发布日期为 2018 年 1 月 5 日）和 3.6 的下载。 .5（发布日期 2018 年 1 月 3 日）。 尽管最新的 Python 3 版本，但*较旧的* Python 2 在 2017 年仍在科学（采用 20％）和商业（采用 30％）领域中使用，[如本调查所详细描述的那样 通过 JetBrains](https://www.jetbrains.com/research/python-developers-survey-2017/)。 如果您仍在使用 Python 2，那么情况很快就会变得很麻烦，因为在短短的一年时间内，Python 2 将被淘汰并且维护将停止（ [pythonclock.org/](https://pythonclock.org/) 将为您提供倒计时， 但是要获得对此的正式声明，只需阅读[这个页面](https://www.python.org/dev/peps/pep-0373/)，[实际上只有少数几个库在两者版本之间仍然不兼容](http://py3readiness.org/)并没有足够的理由继续使用旧版本。
+Python 有两个主要分支：2.7.x 和 3.x。 在本书的第三版修订时，Python 基金会（ [www.python.org/](http://www.python.org/) ）正在提供 Python 版本 2.7.15（发布日期为 2018 年 1 月 5 日）和 3.6 的下载。 .5（发布日期 2018 年 1 月 3 日）。 尽管最新的 Python 3 版本，但*较旧的* Python 2 在 2017 年仍在科学（采用 20%）和商业（采用 30%）领域中使用，[如本调查所详细描述的那样 通过 JetBrains](https://www.jetbrains.com/research/python-developers-survey-2017/)。 如果您仍在使用 Python 2，那么情况很快就会变得很麻烦，因为在短短的一年时间内，Python 2 将被淘汰并且维护将停止（ [pythonclock.org/](https://pythonclock.org/) 将为您提供倒计时， 但是要获得对此的正式声明，只需阅读[这个页面](https://www.python.org/dev/peps/pep-0373/)，[实际上只有少数几个库在两者版本之间仍然不兼容](http://py3readiness.org/)并没有足够的理由继续使用旧版本。

 除了所有这些原因之外，Python 3 和 2 之间没有立即的向后兼容性。实际上，如果尝试使用 Python 3 解释器运行一些为 Python 2 开发的代码，则可能无法正常工作。 最新版本进行了重大更改，这影响了以前的兼容性。 一些数据科学家已经将大部分工作建立在 Python 2 及其软件包上，因此他们不愿意切换到新版本。


--- a/new/py-ds-essentials/2.md
+++ b/new/py-ds-essentials/2.md
@@ -38,7 +38,7 @@

 ![](img/043ff19e-e531-479e-98a9-f36e4ebc9510.png)

-我们永远不会厌倦于说明一切都是从整理数据开始的，并且整理可能很容易需要数据项目中多达 80％的工作。 由于即使是最长的旅程也只有一步之遥，所以让我们立即进入本章，学习成功的调整阶段的基础！
+我们永远不会厌倦于说明一切都是从整理数据开始的，并且整理可能很容易需要数据项目中多达 80% 的工作。 由于即使是最长的旅程也只有一步之遥，所以让我们立即进入本章，学习成功的调整阶段的基础！

 # Pandas数据加载和预处理

@@ -1888,7 +1888,7 @@ In: sparsity = 1.0 - (sparse_coo.count_nonzero() /
 Out: 0.8
 ```

-稀疏度为`0.8`； 也就是说，矩阵的 80％实际上是空的。
+稀疏度为`0.8`； 也就是说，矩阵的 80% 实际上是空的。

 您也可以使用 matplotlib 中的`spy`命令以图形方式研究稀疏性。 在下面的示例中，我们将创建一个随机的稀疏矩阵，并以图形形式轻松表示它，以提供一个关于矩阵中有效可用数据的概念：


--- a/new/py-ds-essentials/3.md
+++ b/new/py-ds-essentials/3.md
--- a/new/py-ds-essentials/4.md
+++ b/new/py-ds-essentials/4.md
@@ -77,7 +77,7 @@ In: import os

 线性回归和逻辑回归是分别可用于线性预测目标值或目标类别的两种方法。 让我们从线性回归预测目标值的示例开始。

-在本节中，我们将再次使用 Boston 数据集，其中包含 506 个样本，13 个特征（所有实数）和一个（实数）数字目标（这使其非常适合回归问题）。 我们将使用训练/测试拆分交叉验证来将我们的数据集分为两部分，以测试我们的方法（在本示例中，我们的数据集的 80％用于训练，而 20％的数据在测试集中）：
+在本节中，我们将再次使用 Boston 数据集，其中包含 506 个样本，13 个特征（所有实数）和一个（实数）数字目标（这使其非常适合回归问题）。 我们将使用训练/测试拆分交叉验证来将我们的数据集分为两部分，以测试我们的方法（在本示例中，我们的数据集的 80% 用于训练，而 20% 的数据在测试集中）：

 ```py
 In: from sklearn.datasets import load_boston
@@ -833,7 +833,7 @@ IO 参数定义如何加载（甚至由模型存储）数据：

 在我们的示例中，我们承担与之前相同的任务，以对 Forest Covertype 数据集进行分类。 我们首先导入必要的软件包。

-接下来，下一步是为该增强算法设置参数以使其正常工作。 我们定义目标（'`multiclass`'），设置较低的学习率（0.01），并允许其分支几乎完全像随机森林一样散布：其树的最大深度设置为 128，并且结果数 leaves 是 256。为此，我们还对情况和特征都进行了随机抽样（每次将其中的 90％装袋）：
+接下来，下一步是为该增强算法设置参数以使其正常工作。 我们定义目标（'`multiclass`'），设置较低的学习率（0.01），并允许其分支几乎完全像随机森林一样散布：其树的最大深度设置为 128，并且结果数 leaves 是 256。为此，我们还对情况和特征都进行了随机抽样（每次将其中的 90% 装袋）：

 ```py
 In: import lightgbm as lgb
@@ -1458,7 +1458,7 @@ In: X1_train = tf_vect.fit_transform(cleaned_docs_train)
    print ("Accuracy=", accuracy_score(y_test, y1_pred)) Out: Accuracy= 0.893670886076
 ```

-此处理需要更多时间，但我们获得了约 1.5％的精度。 对`Tfidf`参数的精确调整和对分类器参数的交叉验证选择最终将使准确性提高到 90％以上。 到目前为止，我们对这种性能感到满意，但是您可以尝试突破这一障碍。
+此处理需要更多时间，但我们获得了约 1.5% 的精度。 对`Tfidf`参数的精确调整和对分类器参数的交叉验证选择最终将使准确性提高到 90% 以上。 到目前为止，我们对这种性能感到满意，但是您可以尝试突破这一障碍。

 # 无监督学习概述

@@ -1629,7 +1629,7 @@ In: processed_docs = [tokenize(doc) for doc in documents]
    print("Num tokens:", len(word_dic)) **Out:** **Num tokens: 16161**
 ```

-在数据集中，有超过 16,000 个不同的词。 现在是时候过滤太常见的单词和太稀有的单词了。 在这一步中，我们将使单词出现至少 10 次，且不超过文档的 20％。 至此，我们有了每个文档的“单词袋”（或 BoW）表示形式； 也就是说，每个文档都表示为字典，其中包含每个单词在文本中出现的次数。 文本中每个单词的绝对位置都会丢失，就像将文档中的所有单词都放在袋子中一样。 结果，并非基于此方法在功能中捕获文本中的所有信号，但在大多数情况下，足以建立有效的模型：
+在数据集中，有超过 16,000 个不同的词。 现在是时候过滤太常见的单词和太稀有的单词了。 在这一步中，我们将使单词出现至少 10 次，且不超过文档的 20%。 至此，我们有了每个文档的“单词袋”（或 BoW）表示形式； 也就是说，每个文档都表示为字典，其中包含每个单词在文本中出现的次数。 文本中每个单词的绝对位置都会丢失，就像将文档中的所有单词都放在袋子中一样。 结果，并非基于此方法在功能中捕获文本中的所有信号，但在大多数情况下，足以建立有效的模型：

 ```py
 In: word_dic.filter_extremes(no_below=10, no_above=0.2)

--- a/new/py-ds-essentials/5.md
+++ b/new/py-ds-essentials/5.md
@@ -125,7 +125,7 @@ In: import matplotlib.pyplot as plt
 您还可以将`plot`命令坐标与另一个字符串参数一起使用，这对于定义颜色和所表示曲线的类型很有用。 字符串通过组合您可以在以下链接上找到的代码来工作：

 *   [`matplotlib.lines.Line2D.set_linestyle`](https://matplotlib.org/api/lines_api.html#matplotlib.lines.Line2D.set_linestyle)：将显示不同的线型。
-*   [颜色 API](https://matplotlib.org/api/colors_api.html)：提供基本内置颜色的完整概述。 该页面还指出，您可以将`color`参数与 HTML 名称或十六进制字符串一起用于颜色，也可以通过使用 RGB 元组来定义所需的颜色，其中元组的每个值都在 *[0,1]* 。 例如，有效参数为`color = (0.1,0.9,0.9)`，它将创建由 10％红色，90％绿色和 90％蓝色构成的颜色。
+*   [颜色 API](https://matplotlib.org/api/colors_api.html)：提供基本内置颜色的完整概述。 该页面还指出，您可以将`color`参数与 HTML 名称或十六进制字符串一起用于颜色，也可以通过使用 RGB 元组来定义所需的颜色，其中元组的每个值都在 *[0,1]* 。 例如，有效参数为`color = (0.1,0.9,0.9)`，它将创建由 10% 红色，90% 绿色和 90% 蓝色构成的颜色。
 *   [标记 API](https://matplotlib.org/api/markers_api.html)：列出您可以为点采用的所有可能的标记样式。

 # 为数据关系绘制散点图

--- a/new/py-ds-essentials/6.md
+++ b/new/py-ds-essentials/6.md
@@ -152,7 +152,7 @@ In: G.add_edge(1, 3)
 In: G.degree() Out: {1: 3, 2: 2, 3: 3, 4: 2}
 ```

-对于大型图，此度量是不切实际的，因为输出字典的每个节点都有一个项目。 在这种情况下，通常使用节点度的直方图来近似其分布。 在以下示例中，构建了一个具有 10,000 个节点且链接概率为 1％的随机网络。 然后，提取节点度的直方图，如下所示：
+对于大型图，此度量是不切实际的，因为输出字典的每个节点都有一个项目。 在这种情况下，通常使用节点度的直方图来近似其分布。 在以下示例中，构建了一个具有 10,000 个节点且链接概率为 1% 的随机网络。 然后，提取节点度的直方图，如下所示：

 ```py
 In: k = nx.fast_gnp_random_graph(10000, 0.01).degree()
@@ -452,7 +452,7 @@ In: dump_file_base = "dumped_graph"

 最后一种采样方法不是`NetworkX`的一部分，但是您可以在`snowball_sampling.py`文件中找到相同的实现。

-在此示例中，我们将从具有`alberto` ID 的人开始对`LiveJournal`网络进行二次采样，然后递归扩展两次（在第一个示例中）和三次（在第二个示例中）。 在后一种情况下，每个链接后面都有 20％的概率，因此减少了检索时间。 这是一个说明相同的示例：
+在此示例中，我们将从具有`alberto` ID 的人开始对`LiveJournal`网络进行二次采样，然后递归扩展两次（在第一个示例中）和三次（在第二个示例中）。 在后一种情况下，每个链接后面都有 20% 的概率，因此减少了检索时间。 这是一个说明相同的示例：

 ```py
 In: import snowball_sampling

--- a/new/py-ds-essentials/7.md
+++ b/new/py-ds-essentials/7.md
@@ -163,7 +163,7 @@ Out: Label: [[1\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\

 ![](img/72c8bd47-7601-4110-aa85-c1d5c671908d.png)

-现在让我们将数据集分为训练和测试。 我们使用 Scikit-learn 随机分离并随机排列图像。 在此单元格中，我们选择数据集的 25％作为测试集； 也就是说，几乎有 10,000 张图像，剩下的 29K +张图像用于训练深层网络：
+现在让我们将数据集分为训练和测试。 我们使用 Scikit-learn 随机分离并随机排列图像。 在此单元格中，我们选择数据集的 25% 作为测试集； 也就是说，几乎有 10,000 张图像，剩下的 29K +张图像用于训练深层网络：

 ```py
 In: from sklearn.model_selection import train_test_split
@@ -244,7 +244,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`运算符选择最可能的类别：

@@ -359,7 +359,7 @@ Out: Train on 29406 samples, validate on 9803 samples
 <keras.callbacks.History at 0x7fd7ac0f17b8>
 ```

-训练集的准确性与测试集的准确性相似，均为约 99％； 也就是说，每 100 张图像中有 99 张用正确的标签分类！ 该网络更长，需要更多的内存和计算能力，但不太容易过拟合并且性能更好。
+训练集的准确性与测试集的准确性相似，均为约 99%； 也就是说，每 100 张图像中有 99 张用正确的标签分类！ 该网络更长，需要更多的内存和计算能力，但不太容易过拟合并且性能更好。

 现在，让我们看一下分类报告和混淆矩阵（完整版本和`log2`版本）：

@@ -468,7 +468,7 @@ Out: Predicted: [('n04507155', 'umbrella', 0.88384396),
                 ('n03888257', 'parachute', 0.012849103)]
 ```

-我们确认这是一个很好的结果； 第一个标签（得分为 88％）是一把雨伞，其次是足球和降落伞。 现在让我们测试一个肯定更困难的图像，该图像的标签未包含在 InceptionV3 训练集中：
+我们确认这是一个很好的结果； 第一个标签（得分为 88%）是一把雨伞，其次是足球和降落伞。 现在让我们测试一个肯定更困难的图像，该图像的标签未包含在 InceptionV3 训练集中：

 ```py
 In: predict_top_3(model, "101_ObjectCategories/bonsai/image_0001.jpg")
@@ -626,7 +626,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% 以上的正确分类。 如果您想对其进行改进，可以尝试使体系结构更复杂，但是请始终记住，通过增加网络的复杂性，训练和预测结果所需的时间会增加，因为 以及内存占用量。

 # 概括


--- a/new/py-ds-essentials/8.md
+++ b/new/py-ds-essentials/8.md
@@ -950,7 +950,7 @@ Spark 是一款高级，分布式且复杂的软件，应仅在大数据上以

 # 读取数据集

-首先，让我们下载并解压缩数据集。 我们将非常保守，只使用原始训练数据集的 10％（75 MB，未压缩），因为我们所有的分析都是在小型虚拟机上运行的。 如果想尝试一下，可以取消注释以下代码段中的行，并下载完整的训练数据集（未压缩的 750 MB）。 我们使用 bash 命令下载训练数据集，测试（47 MB）和功能名称：
+首先，让我们下载并解压缩数据集。 我们将非常保守，只使用原始训练数据集的 10%（75 MB，未压缩），因为我们所有的分析都是在小型虚拟机上运行的。 如果想尝试一下，可以取消注释以下代码段中的行，并下载完整的训练数据集（未压缩的 750 MB）。 我们使用 bash 命令下载训练数据集，测试（47 MB）和功能名称：

 ```py
 In: !mkdir datasets

--- a/new/thoughtful-ds/02.md
+++ b/new/thoughtful-ds/02.md
@@ -233,7 +233,7 @@ building_df

 Spark DataFrame 的默认输出

-即使此代码不是那么大，也必须每次都重复，并且很可能需要花费时间进行 Google 搜索以记住正确的语法。 数据也可以采用其他格式，例如 JSON，这将要求为Pandas和 Spark 调用不同的 API。 数据的格式也可能不正确，并且可能在 CSV 文件中包含错误的行或 JSON 语法错误。 不幸的是，所有这些问题并非罕见，并助长了数据科学的 80/20 规则，该规则指出，数据科学家平均花费 80％的时间来获取，清理和加载数据，而只有 20％的时间用于实际分析。
+即使此代码不是那么大，也必须每次都重复，并且很可能需要花费时间进行 Google 搜索以记住正确的语法。 数据也可以采用其他格式，例如 JSON，这将要求为Pandas和 Spark 调用不同的 API。 数据的格式也可能不正确，并且可能在 CSV 文件中包含错误的行或 JSON 语法错误。 不幸的是，所有这些问题并非罕见，并助长了数据科学的 80/20 规则，该规则指出，数据科学家平均花费 80% 的时间来获取，清理和加载数据，而只有 20% 的时间用于实际分析。

 PixieDust 提供了一个简单的`sampleData` API，以帮助改善这种情况。 当不带参数调用时，它将显示准备分析的预整理数据集的列表：


--- a/new/thoughtful-ds/04.md
+++ b/new/thoughtful-ds/04.md
@@ -683,7 +683,7 @@ PixieDust Chart 选项

    *   **内核名称**：这是带有钻取链接的内核名称，其中显示**内核规范**，**日志**和 **Python 控制台[**。
    *   **状态**：将状态显示为`idle`或`busy`。
-    *   **繁忙比率**：这是一个介于 0 到 100％之间的值，表示自启动以来的内核利用率。
+    *   **繁忙比率**：这是一个介于 0 到 100% 之间的值，表示自启动以来的内核利用率。
    *   **正在运行的应用程序**：这是正在运行的 PixieApps 的列表。 每个 PixieApp 是一个向下钻取链接，该链接显示预热代码并运行 PixieApp 的代码。 这对于解决错误非常有用，因为您可以看到 PixieGateway 正在运行什么代码。
    *   **用户计数**：这是此内核中具有打开会话的用户数。


--- a/new/thoughtful-ds/05.md
+++ b/new/thoughtful-ds/05.md
@@ -886,7 +886,7 @@ class SimpleDisplayWithRenderer(BaseChartDisplay):

 ![Debugging on the Jupyter Notebook using pdb](img/00095.jpeg)

-使用％debug 进行事后调试会话
+使用%debug 进行事后调试会话

 与常规 Python 脚本类似，您也可以通过`pdb.set_trace()`方法以编程方式显式设置断点。 但是，建议使用由 IPython 核心模块提供的`set_trace()`增强版本，该版本提供语法着色：


--- a/new/thoughtful-ds/06.md
+++ b/new/thoughtful-ds/06.md
@@ -506,7 +506,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)