2021-02-20 21:59:42

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

@@ -72,9 +72,9 @@ Jupyter Notebook 是在本地运行的 Web 应用程序，其中包含实时代
     [I 20:03:01.045 NotebookApp] The Jupyter Notebook is running at: http://localhost:8888/ ?token=e915bb06866f19ce462d959a9193a94c7c088e81765f9d8a
     ```
 
-    转到该 HTTP 地址将在浏览器窗口中加载该应用程序，就像启动该应用程序时自动完成的一样。 关闭窗口不会停止应用程序； 这应该从终端通过键入 *Ctrl* + *C* 完成。
+    转到该 HTTP 地址将在浏览器窗口中加载该应用程序，就像启动该应用程序时自动完成的一样。 关闭窗口不会停止应用程序； 这应该从终端通过键入 *Ctrl* +`C`完成。
 
-5.  通过在终端中键入 *Ctrl* + *C* 关闭应用程序。 您可能还需要输入`y`进行确认。 同时关闭 Web 浏览器窗口。
+5.  通过在终端中键入 *Ctrl* +`C`关闭应用程序。 您可能还需要输入`y`进行确认。 同时关闭 Web 浏览器窗口。
 6.  加载 NotebookApp 时，有多种可用选项。 在终端中，通过运行以下命令查看可用选项的列表：
 
     ```py
@@ -546,7 +546,7 @@ scikit_learn==0.19.0
 
     ![Explore Boston housing datasetexploringthe Boston housing dataset](img/image1_069.jpg)
 
-    *n* 是样本数， *x* *<sub>i</sub>* 和 *y* *<sub>i</sub>* 是要累加的各个样本，![Explore Boston housing datasetexploringthe Boston housing dataset](img/X_1_1.jpg)和![Explore Boston housing datasetexploringthe Boston housing dataset](img/Y_1_1.jpg)是每组的平均值。
+   `n`是样本数，`x`*<sub>i</sub>* 和`y`*<sub>i</sub>* 是要累加的各个样本，![Explore Boston housing datasetexploringthe Boston housing dataset](img/X_1_1.jpg)和![Explore Boston housing datasetexploringthe Boston housing dataset](img/Y_1_1.jpg)是每组的平均值。
 
     与其费力地看着前面的表格，不如用热图可视化它。 使用 Seaborn 可以轻松做到这一点。
 
@@ -583,9 +583,9 @@ scikit_learn==0.19.0
 
 查看对角线上的直方图，我们看到以下内容：
 
-*   **a**：**RM** 和 **MEDV** 具有最接近正态分布的形状。
-*   **b**：**AGE** 偏向左侧，**LSTAT** 偏向右侧（这似乎是违反直觉的，但偏斜是根据均值的位置定义的 相对于最大值）。
-*   **c**：对于 **TAX**，我们发现大量分布在 700 左右。这从散点图中也很明显。
+*  `a`：**RM** 和 **MEDV** 具有最接近正态分布的形状。
+*  `b`：**AGE** 偏向左侧，**LSTAT** 偏向右侧（这似乎是违反直觉的，但偏斜是根据均值的位置定义的 相对于最大值）。
+*  `c`：对于 **TAX**，我们发现大量分布在 700 左右。这从散点图中也很明显。
 
 仔细观察右下角的 **MEDV** 直方图，我们实际上会看到类似于 **TAX** 的东西，其中有一个上限为$ 50,000 的大上限。 回想一下当我们执行`df.describe()`时，**MDEV** 的最小值和最大值分别为 5k 和 50k。 这表明数据集中的房屋中位价上限为 50k。
 
@@ -726,13 +726,13 @@ scikit_learn==0.19.0
 
     ![Activity B: Building a Third-Order Polynomial Model](img/image1_097.jpg)
 
-    与`x`不同，现在每行中的数组的长度为 4，其中的值已计算为 *x* *<sup>0</sup>* ， *x* *<sup>1</sup>* ， *x* *<sup>2</sup>* 和 *x* *<sup>3 [</sup>* 。
+    与`x`不同，现在每行中的数组的长度为 4，其中的值已计算为`x`*<sup>0</sup>* ，`x`*<sup>1</sup>* ，`x`*<sup>2</sup>* 和`x`*<sup>3 [</sup>* 。
 
-    我们现在将使用此数据来拟合线性模型。 将特征标记为 *a* ， *b* ， *c* 和 *d* ，我们将计算系数*α* *<sub>0</sub>* ，*α* *<sub>1</sub>* ，*α* *<sub>2</sub>* 和*α* *<sub>3</sub>* 的线性模型：
+    我们现在将使用此数据来拟合线性模型。 将特征标记为`a`，`b`，`c`和`d`，我们将计算系数*α* *<sub>0</sub>* ，*α* *<sub>1</sub>* ，*α* *<sub>2</sub>* 和*α* *<sub>3</sub>* 的线性模型：
 
     ![Activity B: Building a Third-Order Polynomial Model](img/image1_123.jpg)
 
-    我们可以插入 *a* ， *b* ， *c* 和 *d* 的定义，以获得以下多项式模型，其中系数 与以前的相同：
+    我们可以插入`a`，`b`，`c`和`d`的定义，以获得以下多项式模型，其中系数 与以前的相同：
 
     ![Activity B: Building a Third-Order Polynomial Model](img/image1_125.jpg)
 

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

@@ -794,10 +794,10 @@ k 最近邻分类算法可存储训练数据并根据特征空间中的 K 个最
 k 折交叉验证算法如下：
 
 1.  将数据拆分为大小近似相等的 k 个“折叠”。
-2.  在不同的折叠组合上测试并训练 *k* 模型。 每个模型将包括 *k-1* 折叠训练数据，剩余的折叠用于测试。 在这种方法中，每个折叠最终仅被用作一次验证数据。
-3.  通过取 *k* 值的平均值来计算模型精度。 还计算标准偏差以在值上提供误差线。
+2.  在不同的折叠组合上测试并训练`k`模型。 每个模型将包括 *k-1* 折叠训练数据，剩余的折叠用于测试。 在这种方法中，每个折叠最终仅被用作一次验证数据。
+3.  通过取`k`值的平均值来计算模型精度。 还计算标准偏差以在值上提供误差线。
 
-标准设置为 *k = 10* ，但如果使用大数据集，则应考虑使用 *k* 较小的值。
+标准设置为 *k = 10* ，但如果使用大数据集，则应考虑使用`k`较小的值。
 
 此验证方法可用于可靠地比较具有不同超参数（例如，SVM 的`C`参数或 KNN 分类器中最近邻居的数量）的模型性能。 它也适合比较完全不同的模型。
 

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

@@ -802,7 +802,7 @@ Bokeh 是一个用于 Python 的交互式可视化库。 其目标是提供与 D
 
     ![Introduction to interactive visualizations with Bokeh](img/image3_35.jpg)
 
-    通过将键/值对的字典传递给`ColumnDataSource`构造函数，为图定义数据源。 该来源包括 *x* 位置， *y* 位置和每个点的大小，以及每个点的随机字母`A`，`B`或`C`。 这些随机字母被指定为悬停工具的标签，该标签还将显示每个点的大小。 然后将**悬停工具**添加到图形中，并通过特定的绘制方法从每个元素中检索数据，在这种情况下为圆形。
+    通过将键/值对的字典传递给`ColumnDataSource`构造函数，为图定义数据源。 该来源包括`x`位置，`y`位置和每个点的大小，以及每个点的随机字母`A`，`B`或`C`。 这些随机字母被指定为悬停工具的标签，该标签还将显示每个点的大小。 然后将**悬停工具**添加到图形中，并通过特定的绘制方法从每个元素中检索数据，在这种情况下为圆形。
 
     结果是，我们现在可以将鼠标悬停在这些点上，并查看我们为**悬停工具**选择的数据！
 
@@ -862,7 +862,7 @@ Bokeh 是一个用于 Python 的交互式可视化库。 其目标是提供与 D
 
     ![Activity B: Exploring Data with Interactive Visualizations](img/image3_39.jpg)
 
-    这与我们在上一个练习中介绍 Bokeh 时看到的最终示例非常相似。 我们为每个点设置了 *x* 和 *y* 坐标以及国家/地区名称的自定义数据源。 此国家/地区名称已通过传递给**悬停工具**，因此将鼠标悬停在点上时可以看到。 我们将此工具与以及其他一组有用的工具一起传递给图中。
+    这与我们在上一个练习中介绍 Bokeh 时看到的最终示例非常相似。 我们为每个点设置了`x`和`y`坐标以及国家/地区名称的自定义数据源。 此国家/地区名称已通过传递给**悬停工具**，因此将鼠标悬停在点上时可以看到。 我们将此工具与以及其他一组有用的工具一起传递给图中。
 
 5.  In the data, we see some clear outliers with high populations. Hover over these to see what they are:
 

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

@@ -575,7 +575,7 @@ plt.plot(x, norm.pdf(x))
 
 ```
 
-在前面的示例中，我们正在创建一个 x 值列表，以使用`arange`函数绘制介于-3 和 3 之间的值，并在它们之间以 0.001 为增量。 因此，这些是图形上的 x 值，我们将使用这些值绘制 *x* 轴。 *y* 轴将成为正态函数`norm.pdf`，即在这些 x 值上正态分布的概率密度函数。 我们最终得到以下输出：
+在前面的示例中，我们正在创建一个 x 值列表，以使用`arange`函数绘制介于-3 和 3 之间的值，并在它们之间以 0.001 为增量。 因此，这些是图形上的 x 值，我们将使用这些值绘制`x`轴。`y`轴将成为正态函数`norm.pdf`，即在这些 x 值上正态分布的概率密度函数。 我们最终得到以下输出：
 
 ![](img/a7cd81e2-a685-4e43-bc34-1d79beccfcea.png)
 

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

@@ -18,7 +18,7 @@
 
 ![](img/0c9e8d83-c2cb-419a-a681-48b1790465ed.png)
 
-我在 *x* 轴上显示了重量，在 *y* 轴上显示了高度，我可以绘制所有这些数据点，例如人们的体重与身高， 我可以说：“嗯，这看起来像是线性关系，不是吗？也许我可以在其中拟合一条直线，然后用它来预测新值”，这就是线性回归的作用。 在本例中，我的斜率为 0.6， *y* -截距为 130.2，它们定义了一条直线（直线的等式为 *y = mx + b* ， 其中，m 是斜率，b 是 *y* -截距）。 给定一个斜率和一个 *y* -截距，该截距适合我所拥有的最佳数据，我可以使用该线来预测新值。
+我在`x`轴上显示了重量，在`y`轴上显示了高度，我可以绘制所有这些数据点，例如人们的体重与身高， 我可以说：“嗯，这看起来像是线性关系，不是吗？也许我可以在其中拟合一条直线，然后用它来预测新值”，这就是线性回归的作用。 在本例中，我的斜率为 0.6，`y`-截距为 130.2，它们定义了一条直线（直线的等式为 *y = mx + b* ， 其中，m 是斜率，b 是`y`-截距）。 给定一个斜率和一个`y`-截距，该截距适合我所拥有的最佳数据，我可以使用该线来预测新值。
 
 您可以看到，我观察到的重量仅上升到重 100 公斤的人。 如果有人重 120 公斤怎么办？ 好吧，我可以根据之前的数据，使用那条线找出身高 120 公斤的人的身高在哪里。
 
@@ -32,13 +32,13 @@
 
 ![](img/4afbc931-a14b-4756-99f7-936312f2fd71.png)
 
-现在，您将不再需要真正地自己动手做，但是如果您出于某些原因必须这样做，或者您只是对幕后发生的事情感到好奇，我现在将为您描述整体算法，并 如何实际计算斜率和 *y* -如果需要一天的时间，则很难拦截自己。 其实并不那么复杂。
+现在，您将不再需要真正地自己动手做，但是如果您出于某些原因必须这样做，或者您只是对幕后发生的事情感到好奇，我现在将为您描述整体算法，并 如何实际计算斜率和`y`-如果需要一天的时间，则很难拦截自己。 其实并不那么复杂。
 
-还记得直线的斜率截距方程吗？ 它是 *y = mx + c* 。 斜率刚好是两个变量之间的相关性乘以 *Y* 中的标准偏差除以 *X* 中的标准偏差。 标准差只是自然而然地渗入到数学中似乎有些奇怪，但是请记住，相关性也已纳入标准差，因此不必重新引入该术语也就不足为奇了。
+还记得直线的斜率截距方程吗？ 它是 *y = mx + c* 。 斜率刚好是两个变量之间的相关性乘以`Y`中的标准偏差除以`X`中的标准偏差。 标准差只是自然而然地渗入到数学中似乎有些奇怪，但是请记住，相关性也已纳入标准差，因此不必重新引入该术语也就不足为奇了。
 
-然后可以将截距计算为 *Y* 的平均值减去斜率乘以 *X* 的平均值。 再说一次，尽管实际上并不是那么困难，Python 会为您完成所有工作，但要点是，这些并不是要运行的复杂事情。 实际上，它们可以非常有效地完成。
+然后可以将截距计算为`Y`的平均值减去斜率乘以`X`的平均值。 再说一次，尽管实际上并不是那么困难，Python 会为您完成所有工作，但要点是，这些并不是要运行的复杂事情。 实际上，它们可以非常有效地完成。
 
-请记住，最小二乘最小化了从每个点到线的平方误差之和。 关于线性回归的另一种思考方式是，您定义一条线，该线代表该处观察线的最大可能性。 也就是说，对于给定的 *x* 值， *y* 值的最大概率。
+请记住，最小二乘最小化了从每个点到线的平方误差之和。 关于线性回归的另一种思考方式是，您定义一条线，该线代表该处观察线的最大可能性。 也就是说，对于给定的`x`值，`y`值的最大概率。
 
 人们有时将线性回归最大似然估计称为“线性回归最大似然估计”，这只是人们在一个非常简单的名称上冠以幻想的例子，因此，如果您听到有人谈论最大似然估计，那么他们实际上就是在谈论回归。 他们只是想听起来很聪明。 但是现在您也知道该术语，因此您听起来也很聪明。
 
@@ -133,7 +133,7 @@ plt.show()
 
 ![](img/bbdc1831-fa60-406a-b31c-2da0b56d83bb.png)
 
-这段代码将创建一个函数，以在数据旁边绘制最佳拟合线。 这里还有更多的 Matplotlib 魔术。 我们将创建一个`fitLine`列表，并使用编写的`predict()`函数获取`pageSpeeds`（即 *x* -轴），并创建 Y 函数 从那开始。 因此，我们将不使用支出金额的观察值，而只是使用`slope`乘以`x`加上从上述`linregress()`调用中获得的`intercept`来找到预测值。 本质上，在这里，我们将像以前一样做一个散点图，以显示原始数据点，即观察值。
+这段代码将创建一个函数，以在数据旁边绘制最佳拟合线。 这里还有更多的 Matplotlib 魔术。 我们将创建一个`fitLine`列表，并使用编写的`predict()`函数获取`pageSpeeds`（即`x`-轴），并创建 Y 函数 从那开始。 因此，我们将不使用支出金额的观察值，而只是使用`slope`乘以`x`加上从上述`linregress()`调用中获得的`intercept`来找到预测值。 本质上，在这里，我们将像以前一样做一个散点图，以显示原始数据点，即观察值。
 
 然后，我们还将使用通过返回的线方程式创建的`fitLine`在同一`pyplot`实例上调用`plot`，并将它们一起显示。 当我们这样做时，它看起来如下图：
 
@@ -155,7 +155,7 @@ plt.show()
 
 并非所有关系都是线性的，但是线性回归只是我们可以做的一整类回归的一个例子。 如果您还记得我们最终得到的线性回归线的形式为 *y = mx + b* ，则可以从普通最小二乘法或其他方法的线性回归分析中获得 m 和 b 的值 你选。 现在，这只是一阶或一阶多项式。 阶数或次数是您看到的 x 的幂。 这就是一阶多项式。
 
-现在，如果需要，我们还可以使用二阶多项式，看起来像 *y = ax ^ 2 + bx + c* 。 如果我们使用二阶多项式进行回归，则将获得 a，b 和 c 的值。 或者我们可以做一个 *ax ^ 3 + bx ^ 2 + cx + d* 形式的三阶多项式。 阶数越高，可以表示的曲线越复杂。 因此，将 *x* 混合在一起的能力越强，可以获得的形状和关系就越复杂。
+现在，如果需要，我们还可以使用二阶多项式，看起来像 *y = ax ^ 2 + bx + c* 。 如果我们使用二阶多项式进行回归，则将获得 a，b 和 c 的值。 或者我们可以做一个 *ax ^ 3 + bx ^ 2 + cx + d* 形式的三阶多项式。 阶数越高，可以表示的曲线越复杂。 因此，将`x`混合在一起的能力越强，可以获得的形状和关系就越复杂。
 
 但是，获得更多学位并不总是更好。 通常，您的数据中存在某种自然关系，实际上并没有那么复杂，如果您发现自己在拟合数据时投入了很大的精力，那您可能就过度拟合了！
 
@@ -196,7 +196,7 @@ scatter(pageSpeeds, purchaseAmount)
 
 您会发现这并不是真正的线性关系。 我们可以尝试在其上拟合一条线，这样对于很多数据来说都可以，可能在图形的右侧向下，而在左侧则不然。 我们确实有更多的指数曲线。
 
-现在，恰好 NumPy 具有`polyfit()`函数，该函数可让您将所需的任意多项式拟合到该数据。 因此，例如，我们可以说 *x* -轴是我们拥有的页面速度（`pageSpeeds`）的数组，而我们的 *y* -轴是我们的页面速度的数组 购买金额（`purchaseAmount`）。 然后，我们可以仅调用`np.polyfit(x, y, 4)`，这意味着我们希望对该数据进行四次多项式拟合。
+现在，恰好 NumPy 具有`polyfit()`函数，该函数可让您将所需的任意多项式拟合到该数据。 因此，例如，我们可以说`x`-轴是我们拥有的页面速度（`pageSpeeds`）的数组，而我们的`y`-轴是我们的页面速度的数组 购买金额（`purchaseAmount`）。 然后，我们可以仅调用`np.polyfit(x, y, 4)`，这意味着我们希望对该数据进行四次多项式拟合。
 
 ```py
 x = np.array(pageSpeeds)

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

@@ -151,7 +151,7 @@ scatter(testX, testY)
 
 现在，我们将尝试将 8 次多项式拟合到此数据，并且我们将随机选择数字`8`，因为我知道这是一个非常高的阶数，并且可能过度拟合。
 
-让我们继续使用`np.poly1d(np.polyfit(x, y, 8))`拟合我们的 8 阶多项式，其中 *x* 仅是训练数据的数组，而 *y* 仅是训练数据的数组。 我们仅使用预留给训练的 80 个点来查找模型。 现在，我们有了此`p4`函数，可以将其用于预测新值：
+让我们继续使用`np.poly1d(np.polyfit(x, y, 8))`拟合我们的 8 阶多项式，其中`x`仅是训练数据的数组，而`y`仅是训练数据的数组。 我们仅使用预留给训练的 80 个点来查找模型。 现在，我们有了此`p4`函数，可以将其用于预测新值：
 
 ```py
 x = np.array(trainX) 
@@ -707,7 +707,7 @@ Image(graph.create_png())
 
 现在，假设我们要使用随机森林，您知道，我们担心我们可能过度拟合训练数据。 创建包含多个决策树的随机森林分类器实际上非常容易。
 
-因此，为此，我们可以使用之前创建的相同数据。 您只需要`*X*`和`*y*`向量，这就是要在其上进行预测的功能集和列：
+因此，为此，我们可以使用之前创建的相同数据。 您只需要``X``和``y``向量，这就是要在其上进行预测的功能集和列：
 
 ```py
 from sklearn.ensemble import RandomForestClassifier 

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

@@ -25,11 +25,11 @@ KNN 听起来很花哨，但实际上它是其中最简单的技术之一！ 假
 
 ![](img/cdac4f24-ef67-463c-ade8-14188ba538e5.jpg)
 
-在这里，我们可以根据散点图中任意两点之间的等级和受欢迎程度来计算某种距离。 假设有一个新观点出现，一部我们不知道其类型的新电影。 我们可以做的是将 *K* 设置为`3`，然后将`3`最近的邻居设为散点图上的该点； 然后他们都可以对新的点/电影的分类进行投票。
+在这里，我们可以根据散点图中任意两点之间的等级和受欢迎程度来计算某种距离。 假设有一个新观点出现，一部我们不知道其类型的新电影。 我们可以做的是将`K`设置为`3`，然后将`3`最近的邻居设为散点图上的该点； 然后他们都可以对新的点/电影的分类进行投票。
 
 您可以看到是否带了三个最近的邻居（ *K = 3* ），我有 2 部戏剧电影和 1 部科幻电影。 然后，我让他们全部投票，然后我们将基于最近的 3 个邻居为该新点选择戏剧的分类。 现在，如果我将这个圈子扩大到包括 5 个最近的邻居，即 *K = 5* ，我得到一个不同的答案。 因此，在这种情况下，我选择了 3 部科幻小说和 2 部戏剧电影。 如果让他们全部投票，我最终将得到一部关于新电影的科幻小说分类。
 
-我们对 K 的选择可能非常重要。 您想确保它足够小，以至于您不会走得太远并开始拾取不相关的邻居，但是它必须足够大以包含足够的数据点以获得有意义的样本。 因此，通常必须使用训练/测试或类似技术来实际确定给定数据集的 *K* 正确值。 但是，归根结底，您必须从直觉开始，然后从那里开始工作。
+我们对 K 的选择可能非常重要。 您想确保它足够小，以至于您不会走得太远并开始拾取不相关的邻居，但是它必须足够大以包含足够的数据点以获得有意义的样本。 因此，通常必须使用训练/测试或类似技术来实际确定给定数据集的`K`正确值。 但是，归根结底，您必须从直觉开始，然后从那里开始工作。
 
 这就是全部，就这么简单。 因此，这是一种非常简单的技术。 您要做的只是从散点图上选出 k 个最近的邻居，然后让他们全部对分类投票。 它确实属于监督学习，因为它使用一组已知点（即已知分类）的训练数据来告知新点的分类。
 
@@ -178,7 +178,7 @@ print movieDict[4]
 
 我们有一个`getNeighbors()`小功能，可以拍摄我们感兴趣的电影以及我们要查找的 K 个邻居。 它将遍历我们拥有的每部电影； 如果实际上是与我们正在看的电影不同的电影，它将计算之前的距离得分，并将其添加到我们拥有的结果列表中，并对结果进行排序。 然后，我们将得出 K 个最佳结果。
 
-在此示例中，我们将 *K* 设置为 10，找到 10 个最近的邻居。 我们将使用`getNeighbors()`找到 10 个最近的邻居，然后迭代所有这 10 个最近的邻居并计算每个邻居的平均评分。 该平均收视率将使我们了解到有关电影的收视率预测。
+在此示例中，我们将`K`设置为 10，找到 10 个最近的邻居。 我们将使用`getNeighbors()`找到 10 个最近的邻居，然后迭代所有这 10 个最近的邻居并计算每个邻居的平均评分。 该平均收视率将使我们了解到有关电影的收视率预测。
 
 副作用是，我们还基于距离函数获得了 10 个最近的邻居，我们可以称其为相似的电影。 因此，该信息本身很有用。 回到“观看过的顾客也观看过”的示例，如果您想做一个仅基于此距离度量而非实际行为数据的类似功能，那么这可能是一个合理的起点，对吧？
 
@@ -439,17 +439,17 @@ ETL 是一种古老的做法，您需要先脱机转换一堆数据，然后再
 
 *   同样，从代理的一组环境状态开始（我旁边有鬼吗？在我面前有药丸吗？类似的事情。），我们将其称为 s。
 *   在这些状态下，我可以执行一组可能的操作，我们将其称为 a。 对于吃豆人，这些可能的动作是向上，向下，向左或向右移动。
-*   然后我们为每个状态/动作对都有一个值，我们将其称为 Q； 这就是为什么我们将其称为 Q 学习。 因此，对于每个状态，围绕吃豆人的一组给定条件，给定动作将具有值 *Q* 。 因此，例如，向上移动可能具有给定的值 Q，而向下移动可能具有负的 *Q* 值，例如，这意味着遇到重影。
+*   然后我们为每个状态/动作对都有一个值，我们将其称为 Q； 这就是为什么我们将其称为 Q 学习。 因此，对于每个状态，围绕吃豆人的一组给定条件，给定动作将具有值`Q`。 因此，例如，向上移动可能具有给定的值 Q，而向下移动可能具有负的`Q`值，例如，这意味着遇到重影。
 
-因此，对于吃豆人可能处于的每种可能状态，我们从 *Q* 值开始为 0。而且，当吃豆人探索迷宫时，随着吃豆人的坏事发生，我们减少了 “吃豆人”当时所处状态的 *Q* 值。 因此，如果吃豆人最终被鬼魂吞噬，我们将惩罚他在当前状态下所做的一切。 吃豆人吃东西或吃鬼东西时，吃豆人都会遇到好事，我们会为该动作增加 *Q* 值，以了解他所处的状态。然后， 可以做的就是使用这些 *Q* 值来告知 Pac-Man 未来的选择，并建立一种性能最佳的智能代理，从而制作出完美的 Pac-Man。 从上面看到的相同的 Pac-Man 图像，我们可以进一步定义 Pac-Man 的当前状态，方法是定义他在西边有一堵墙，在北边和东边有空白空间，在南边有个幽灵。
+因此，对于吃豆人可能处于的每种可能状态，我们从`Q`值开始为 0。而且，当吃豆人探索迷宫时，随着吃豆人的坏事发生，我们减少了 “吃豆人”当时所处状态的`Q`值。 因此，如果吃豆人最终被鬼魂吞噬，我们将惩罚他在当前状态下所做的一切。 吃豆人吃东西或吃鬼东西时，吃豆人都会遇到好事，我们会为该动作增加`Q`值，以了解他所处的状态。然后， 可以做的就是使用这些`Q`值来告知 Pac-Man 未来的选择，并建立一种性能最佳的智能代理，从而制作出完美的 Pac-Man。 从上面看到的相同的 Pac-Man 图像，我们可以进一步定义 Pac-Man 的当前状态，方法是定义他在西边有一堵墙，在北边和东边有空白空间，在南边有个幽灵。
 
-我们可以看看他可以采取的行动：他实际上根本不能向左移动，但是他可以向上，向下或向右移动，我们可以为所有这些动作分配一个值。 向上或向右走，实际上什么也没有发生，没有药丸或点药可消耗。 但是，如果他走了，那绝对是一个负值。 可以说，对于吃豆人所处的当前状况所给出的状态，下移将是一个非常糟糕的选择。 为此，应该有一个负的 *Q* 值。 根本无法向左移动。 向上或向右移动或保持中性，对于给定状态的那些动作选择， *Q* 值将保持为 0。
+我们可以看看他可以采取的行动：他实际上根本不能向左移动，但是他可以向上，向下或向右移动，我们可以为所有这些动作分配一个值。 向上或向右走，实际上什么也没有发生，没有药丸或点药可消耗。 但是，如果他走了，那绝对是一个负值。 可以说，对于吃豆人所处的当前状况所给出的状态，下移将是一个非常糟糕的选择。 为此，应该有一个负的`Q`值。 根本无法向左移动。 向上或向右移动或保持中性，对于给定状态的那些动作选择，`Q`值将保持为 0。
 
-现在，您还可以稍作展望，以打造一个更加智能的代理。 所以，我实际上距离这里获得药丸只有两步之遥。 因此，当吃豆人探索这个状态时，如果我想在下一个状态下吃该药的情况，我实际上可以将其计入上一个状态的 *Q* 值中。 如果您只是某种折扣因素，则根据您的时间间隔，距离的步数，您可以将所有因素综合考虑在内。 因此，这实际上是在系统中构建一点内存的一种方式。 您可以在计算 Q 时使用折扣因子“向前看”多个步骤（此处 *s* 是先前状态， *s'*是当前状态）：
+现在，您还可以稍作展望，以打造一个更加智能的代理。 所以，我实际上距离这里获得药丸只有两步之遥。 因此，当吃豆人探索这个状态时，如果我想在下一个状态下吃该药的情况，我实际上可以将其计入上一个状态的`Q`值中。 如果您只是某种折扣因素，则根据您的时间间隔，距离的步数，您可以将所有因素综合考虑在内。 因此，这实际上是在系统中构建一点内存的一种方式。 您可以在计算 Q 时使用折扣因子“向前看”多个步骤（此处`s`是先前状态， *s'*是当前状态）：
 
 *Q(s,a) += discount * (reward(s,a) + max(Q(s')) - Q(s,a))*
 
-因此，我在服用该药丸时遇到的 *Q* 值实际上可能会提高我在此过程中遇到的先前 *Q* 值。 因此，这是使 Q 学习更好的一种方法。
+因此，我在服用该药丸时遇到的`Q`值实际上可能会提高我在此过程中遇到的先前`Q`值。 因此，这是使 Q 学习更好的一种方法。
 
 # 探索问题
 
@@ -457,13 +457,13 @@ ETL 是一种古老的做法，您需要先脱机转换一堆数据，然后再
 
 # 简单的方法
 
-一种简单的方法是始终为我到目前为止计算出的最高 *Q* 值的给定状态选择动作，如果有平局，则随机选择。 因此，最初我所有的 *Q* 值都可能为 0，而我一开始只是随机选择动作。
+一种简单的方法是始终为我到目前为止计算出的最高`Q`值的给定状态选择动作，如果有平局，则随机选择。 因此，最初我所有的`Q`值都可能为 0，而我一开始只是随机选择动作。
 
-当我开始获得有关给定动作和给定状态的更好的 *Q* 值的信息时，我将开始使用它们。 但是，这最终会导致效率低下，如果我将自己束缚于始终选择迄今为止计算出的最佳 *Q* 值的严格算法中，那么我实际上可能会错过很多路径。
+当我开始获得有关给定动作和给定状态的更好的`Q`值的信息时，我将开始使用它们。 但是，这最终会导致效率低下，如果我将自己束缚于始终选择迄今为止计算出的最佳`Q`值的严格算法中，那么我实际上可能会错过很多路径。
 
 # 更好的方法
 
-因此，一种更好的方法是在我探索时在我的动作中引入一些随机变化。 因此，我们称其为ε项。 因此，假设我们有一些价值，我掷骰子，我有一个随机数。 如果最终小于该 epsilon 值，则我实际上不遵循最高的 *Q* 值； 我没有做有意义的事情，我只是随意走一条路尝试一下，看看会发生什么。 实际上，这使我能够在探索阶段更有效地探索更广泛的可能性，更广泛的行动，从而更有效地应对更广泛的国家。
+因此，一种更好的方法是在我探索时在我的动作中引入一些随机变化。 因此，我们称其为ε项。 因此，假设我们有一些价值，我掷骰子，我有一个随机数。 如果最终小于该 epsilon 值，则我实际上不遵循最高的`Q`值； 我没有做有意义的事情，我只是随意走一条路尝试一下，看看会发生什么。 实际上，这使我能够在探索阶段更有效地探索更广泛的可能性，更广泛的行动，从而更有效地应对更广泛的国家。
 
 因此，我们所做的工作可以用非常花哨的数学术语来描述，但是从概念上讲，这很简单。
 
@@ -479,13 +479,13 @@ ETL 是一种古老的做法，您需要先脱机转换一堆数据，然后再
 
 *   **决策**：在给定状态下，如果给定一组可能性，我们将采取什么行动？
 *   **在结果部分为随机的情况下**：嗯，有点像我们在那里的随机探索。
-*   **部分受决策者**的控制：决策者是我们计算出的 *Q* 值。
+*   **部分受决策者**的控制：决策者是我们计算出的`Q`值。
 
-因此，MDP，马尔可夫决策过程是描述我们刚刚为强化学习而描述的探索算法的一种理想方式。 表示法甚至相似，状态仍然描述为 s，而 s'是我们遇到的下一个状态。 对于给定的 s 和 s'状态，我们具有定义为 *P <sub class="calibre50">a</sub>* 的状态转换函数。 我们有 *Q* 值，它们基本上表示为奖励函数，对于给定的 s 和 s'， *R <sub class="calibre50">和</sub>* 值。 因此，从一种状态转移到另一种状态具有与之相关的给定奖励，并且从一种状态转移到另一种状态由状态转换函数定义：
+因此，MDP，马尔可夫决策过程是描述我们刚刚为强化学习而描述的探索算法的一种理想方式。 表示法甚至相似，状态仍然描述为 s，而 s'是我们遇到的下一个状态。 对于给定的 s 和 s'状态，我们具有定义为 *P <sub class="calibre50">a</sub>* 的状态转换函数。 我们有`Q`值，它们基本上表示为奖励函数，对于给定的 s 和 s'， *R <sub class="calibre50">和</sub>* 值。 因此，从一种状态转移到另一种状态具有与之相关的给定奖励，并且从一种状态转移到另一种状态由状态转换函数定义：
 
-*   状态仍然描述为 *s* 和 *s''*
+*   状态仍然描述为`s`和 *s''*
 *   状态转换函数描述为 *Pa（s，s'）*
-*   我们的 *Q* 值描述为奖励函数 *Ra（s，s'）*
+*   我们的`Q`值描述为奖励函数 *Ra（s，s'）*
 
 因此，再次描述马尔科夫决策过程，只是描述我们所做的事情，只有一种数学符号和一个听起来更奇特的单词。 而且，如果您想听起来更聪明，也可以使用另一个名称来调用马尔可夫决策过程：离散时间随机控制过程。 听起来很聪明！ 但是概念本身就是我们刚刚描述的东西。
 
@@ -497,17 +497,17 @@ ETL 是一种古老的做法，您需要先脱机转换一堆数据，然后再
 
 *   **解决复杂问题的方法**：与创建智能吃豆人相同，最终结果非常复杂。
 *   **通过将其分解为更简单的子问题的集合**：例如，对于 Pac-Man 可能处于的给定状态，采取的最佳措施是什么。Pac-Man 可以有许多不同的状态 陷入困境，但这些州中的每个州都代表着一个更简单的子问题，我只能做出有限的选择，并且有一个正确的答案可以做出最好的举动。
-*   **存储其解**：这些解是与每个状态下每个可能动作相关的 *Q* 值。
-*   **理想情况下，使用基于内存的数据结构**：嗯，当然，我需要存储这些 *Q* 值并将它们与状态关联，对吗？
-*   **下次再次出现相同的子问题**：下次吃豆人处于给定状态时，我具有一组 *Q* 值。
-*   **无需重新计算其解，而是简单地查找先前计算的解**：我已经从探索阶段获得了 *Q* 值。
+*   **存储其解**：这些解是与每个状态下每个可能动作相关的`Q`值。
+*   **理想情况下，使用基于内存的数据结构**：嗯，当然，我需要存储这些`Q`值并将它们与状态关联，对吗？
+*   **下次再次出现相同的子问题**：下次吃豆人处于给定状态时，我具有一组`Q`值。
+*   **无需重新计算其解，而是简单地查找先前计算的解**：我已经从探索阶段获得了`Q`值。
 *   **从而节省了计算时间，但以适度的存储空间开销为代价**：这正是我们刚刚进行的强化学习。
 
 我们有一个复杂的探索阶段，该阶段寻找给定状态下与每个动作相关的最佳奖励。 一旦有了针对给定状态要采取的正确行动的表格，我们就可以非常快速地使用它来使“吃豆人”以最佳方式移动，这是他之前从未见过的全新迷宫。 因此，强化学习也是动态编程的一种形式。 哇！
 
 概括地说，您可以通过半随机地探索给定不同条件的运动的不同选择来制作智能的 Pac-Man 代理，其中，这些选择是动作，而这些条件是状态。 我们会随时跟踪与每个动作或状态相关的奖励或惩罚，实际上，我们可以打折，如果您想使其更好的话，可以分多个步骤进行。
 
-然后，我们存储最终与每个状态相关联的 *Q* 值，并可以使用它来告知其将来的选择。 因此，我们可以进入一个全新的迷宫，并拥有一个真正聪明的吃豆人，可以独自避开鬼魂并有效地将它们吃掉。 这是一个非常简单的概念，但是功能非常强大。 您也可以说您了解很多花哨的术语，因为它们全称为同一件事。 Q 学习，强化学习，马尔可夫决策过程，动态规划：所有这些都捆绑在同一个概念中。
+然后，我们存储最终与每个状态相关联的`Q`值，并可以使用它来告知其将来的选择。 因此，我们可以进入一个全新的迷宫，并拥有一个真正聪明的吃豆人，可以独自避开鬼魂并有效地将它们吃掉。 这是一个非常简单的概念，但是功能非常强大。 您也可以说您了解很多花哨的术语，因为它们全称为同一件事。 Q 学习，强化学习，马尔可夫决策过程，动态规划：所有这些都捆绑在同一个概念中。
 
 我不知道，我认为通过这样一种简单的方法实际上可以制造出一种人工智能的吃豆人真是太酷了，它确实有效！ 如果您想更详细地研究它，请参考以下示例，这些示例具有一个实际的源代码，您可以查看并可以使用 [**Python Markov Decision Process Toolbox**](http://pymdptoolbox.readthedocs.org/en/latest/api/mdp.html)。
 

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

@@ -94,7 +94,7 @@
 
 ![](img/417d9e6f-4b8c-4a51-bb1c-694e1cf23530.png)
 
-您显然不想将其保留在`Downloads`文件夹中，所以让我们继续在此处打开一个新的文件浏览器窗口。 我转到`C`驱动器并创建一个新文件夹，让我们将其命名为`spark`。 因此，我的 Spark 安装将在`C:\spark`中运行。 同样，很容易记住。 打开该文件夹。 现在，我回到下载的`spark`文件夹，并使用 *Ctrl* + *A* 选择 Spark 发行版中的所有内容， *Ctrl* + *C* 复制它，然后返回`C:\spark`，我要放置在其中，然后 *Ctrl* + *V* 粘贴到：
+您显然不想将其保留在`Downloads`文件夹中，所以让我们继续在此处打开一个新的文件浏览器窗口。 我转到`C`驱动器并创建一个新文件夹，让我们将其命名为`spark`。 因此，我的 Spark 安装将在`C:\spark`中运行。 同样，很容易记住。 打开该文件夹。 现在，我回到下载的`spark`文件夹，并使用 *Ctrl* +`A`选择 Spark 发行版中的所有内容， *Ctrl* +`C`复制它，然后返回`C:\spark`，我要放置在其中，然后 *Ctrl* +`V`粘贴到：
 
 ![](img/e5a2e48a-10c4-4849-9ef2-11833945eaa8.png)
 
@@ -120,7 +120,7 @@
 
 ![](img/6257dac5-b9be-45d2-a9dc-58ad1ac9d705.png)
 
-现在，由于我们要在桌面上本地运行脚本，所以这没什么大不了的，我们不需要真正安装 Hadoop。 这只是绕过了另一个在 Windows 上运行 Spark 的怪癖。 因此，现在我们有了它，让我们在`Downloads`文件夹中找到它， *Ctrl* + *C* 复制它，然后转到`C`驱动器并创建一个位置 为了生存：
+现在，由于我们要在桌面上本地运行脚本，所以这没什么大不了的，我们不需要真正安装 Hadoop。 这只是绕过了另一个在 Windows 上运行 Spark 的怪癖。 因此，现在我们有了它，让我们在`Downloads`文件夹中找到它， *Ctrl* +`C`复制它，然后转到`C`驱动器并创建一个位置 为了生存：
 
 ![](img/dccddda5-a8d8-47c0-b4ec-d9c636fe4513.png)
 

new/master-py-ds/02.md

@@ -29,7 +29,7 @@
 
 ![A normal distribution](img/B03450_02_02.jpg)
 
-请看下图：它显示了三个具有正态分布的曲线。 曲线 **A** 的标准偏差为 1，曲线 **C** 的标准偏差为 2，曲线 **B** 的标准偏差为 3，这意味着 曲线 **B** 的值分布最大，而曲线 **A** 的值分布最小。 另一种看待它的方法是，如果曲线 **B** 代表一个国家的高度，那么这个国家的许多人具有高度的不同，而曲线**的国家** 发行版的身高彼此相似。
+请看下图：它显示了三个具有正态分布的曲线。 曲线`A`的标准偏差为 1，曲线`C`的标准偏差为 2，曲线`B`的标准偏差为 3，这意味着 曲线`B`的值分布最大，而曲线`A`的值分布最小。 另一种看待它的方法是，如果曲线`B`代表一个国家的高度，那么这个国家的许多人具有高度的不同，而曲线**的国家** 发行版的身高彼此相似。
 
 ![A normal distribution](img/B03450_02_03.jpg)
 
@@ -39,7 +39,7 @@
 
 ![A normal distribution from a binomial distribution](img/3450_02_04.jpg)
 
-在上式中， *n* 是硬币被抛掷的次数， *p* 是成功的概率， *q* 为（ *1– p* ），这是失败的可能性。
+在上式中，`n`是硬币被抛掷的次数，`p`是成功的概率，`q`为（ *1– p* ），这是失败的可能性。
 
 Python 的 SciPy 软件包提供了有用的功能来执行统计计算。 您可以从[这个页面](http://www.scipy.org/)安装。 以下命令有助于绘制二项式分布：
 
@@ -100,11 +100,11 @@ SciPy 软件包中的`binom`函数有助于生成二项式分布以及与之相
 
 ## 泊松分布
 
-泊松分布是间隔中独立间隔出现的概率分布。 二项式分布用于确定二进制出现的概率，而泊松分布用于基于计数的分布。 如果 lambda 是每个时间间隔内事件的平均发生率，则在给定的时间间隔内发生 *k* 的可能性由以下公式给出：
+泊松分布是间隔中独立间隔出现的概率分布。 二项式分布用于确定二进制出现的概率，而泊松分布用于基于计数的分布。 如果 lambda 是每个时间间隔内事件的平均发生率，则在给定的时间间隔内发生`k`的可能性由以下公式给出：
 
 ![A Poisson distribution](img/3450_02_10.jpg)
 
-在此， *e* 是欧拉数， *k* 是要确定概率的出现次数，λ是平均出现次数。
+在此，`e`是欧拉数，`k`是要确定概率的出现次数，λ是平均出现次数。
 
 让我们通过一个例子来理解这一点。 一小时内通过桥梁的汽车数量为 20。一小时内有 23 辆汽车通过桥梁的概率是多少？
 
@@ -123,7 +123,7 @@ SciPy 软件包中的`binom`函数有助于生成二项式分布以及与之相
 
 ## 伯努利发行
 
-您可以执行具有两个可能结果的实验​​：成功或失败。 成功的概率为 *p* ，失败的概率为 *1-p* 。 在成功的情况下取`1`值，在失败的情况下取`0`值的随机变量称为伯努利分布。 概率分布函数可以写成：
+您可以执行具有两个可能结果的实验​​：成功或失败。 成功的概率为`p`，失败的概率为 *1-p* 。 在成功的情况下取`1`值，在失败的情况下取`0`值的随机变量称为伯努利分布。 概率分布函数可以写成：
 
 ![A Bernoulli distribution](img/3450_02_11.jpg)
 
@@ -162,7 +162,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,
 
 ![A z-score](img/3450_02_15.jpg)
 
-在此， *X* 是分布中的值， *µ* 是分布的平均值，*σ*是分布的标准偏差
+在此，`X`是分布中的值， *µ* 是分布的平均值，*σ*是分布的标准偏差
 
 让我们尝试从学校教室的角度来理解这个概念。
 
@@ -386,7 +386,7 @@ p 值为：
 
 ![A confidence interval](img/3450_02_25.jpg)
 
-在此， *s* 是样品的标准偏差， *n* 是样品的元素数。
+在此，`s`是样品的标准偏差，`n`是样品的元素数。
 
 可以使用 SciPy 包的`sem()`函数来计算：
 
@@ -459,7 +459,7 @@ p 值为：
 
 ![Correlation](img/3450_02_29.jpg)
 
-前面的公式将皮尔逊相关性定义为 *X* 和 *Y* 之间的协方差，除以 *X* 和 *Y* 的标准偏差。 ，或者也可以将其定义为随机变量相对于均值的差值之和的期望均值除以 X 和 Y 的标准偏差。让我们以一个示例来理解。 让我们看一下各种汽车的行驶里程和马力，看看两者之间是否有关系。 这可以使用 SciPy 包中的`pearsonr`函数来实现：
+前面的公式将皮尔逊相关性定义为`X`和`Y`之间的协方差，除以`X`和`Y`的标准偏差。 ，或者也可以将其定义为随机变量相对于均值的差值之和的期望均值除以 X 和 Y 的标准偏差。让我们以一个示例来理解。 让我们看一下各种汽车的行驶里程和马力，看看两者之间是否有关系。 这可以使用 SciPy 包中的`pearsonr`函数来实现：
 
 ```py
 >>> mpg = [21.0, 21.0, 22.8, 21.4, 18.7, 18.1, 14.3, 24.4, 22.8, 19.2, 17.8, 16.4, 17.3, 15.2, 10.4, 10.4, 14.7, 32.4, 30.4,
@@ -581,9 +581,9 @@ f 统计量由以下公式给出：
 
 ![The F distribution](img/3450_02_33.jpg)
 
-*s* <sub>`1`</sub> 是 *n* <sub>`1`[</sub> 大小 *s* <sub>`2`</sub> 是样本 2 的标准偏差，其中大小 *n* <sub>`2`</sub> *σ* <sub>`1`</sub> 是样本*1σ* <sub>`2`的总体标准差 ]</sub> 是样本 12 的总体标准偏差。
+`s`<sub>`1`</sub> 是`n`<sub>`1`[</sub> 大小`s`<sub>`2`</sub> 是样本 2 的标准偏差，其中大小`n`<sub>`2`</sub> *σ* <sub>`1`</sub> 是样本*1σ* <sub>`2`的总体标准差 ]</sub> 是样本 12 的总体标准偏差。
 
-**f** 统计信息的所有可能值的分布称为 F 分布。 下图中的`d1`和`d2`表示自由度：
+`f`统计信息的所有可能值的分布称为 F 分布。 下图中的`d1`和`d2`表示自由度：
 
 ![The F distribution](img/B03450_02_34.jpg)
 
@@ -593,15 +593,15 @@ f 统计量由以下公式给出：
 
 ![The chi-square distribution](img/3450_02_35.jpg)
 
-在此， *n* 是样本的大小， *s* 是样本的标准偏差，*σ*是总体的标准偏差。
+在此，`n`是样本的大小，`s`是样本的标准偏差，*σ*是总体的标准偏差。
 
 如果我们反复采样并定义卡方统计量，则可以形成卡方分布，该分布由以下概率密度函数定义：
 
 ![The chi-square distribution](img/3450_02_36.jpg)
 
-这里， *Y* <sub>`0`</sub> 是取决于自由度数的常数， *X* <sub>*2 [*</sub> 是卡方统计量， *v = n-1* 是自由度数， *e* 是等于自然对数底数的常数 系统。
+这里，`Y`<sub>`0`</sub> 是取决于自由度数的常数，`X`<sub>*2 [*</sub> 是卡方统计量， *v = n-1* 是自由度数，`e`是等于自然对数底数的常数 系统。
 
-*Y* <sub>`0`</sub> 的定义使得卡方曲线下的面积等于 1。
+`Y`<sub>`0`</sub> 的定义使得卡方曲线下的面积等于 1。
 
 ![The chi-square distribution](img/B03450_02_37.jpg)
 

new/master-py-ds/04.md

@@ -115,7 +115,7 @@ matplotlib 的一个非常有用的功能是，它使得绘制多个图很容易
 
 ![Playing with text](img/B03450_04_06.jpg)
 
-第一个参数取 *x* 轴值，第二个参数取 *y* 轴值。 第三个参数是需要添加到绘图中的文本。 乳胶表达式已用于在图中绘制`mu`平均值。
+第一个参数取`x`轴值，第二个参数取`y`轴值。 第三个参数是需要添加到绘图中的文本。 乳胶表达式已用于在图中绘制`mu`平均值。
 
 可以使用注释命令来注释图表的某个部分。 带注释的命令将获取文本，需要指向的绘图部分的位置以及文本的位置：
 
@@ -340,7 +340,7 @@ matplotlib 库中的样式包使更改绘图图的样式更加容易。 更改
 
 ```
 
-创建一个`NullFormatter`对象，该对象将用于消除直方图的 *x* 和 *y* 标签：
+创建一个`NullFormatter`对象，该对象将用于消除直方图的`x`和`y`标签：
 
 ```py
 >>> nullfmt   = NullFormatter()         # no labels
@@ -373,7 +373,7 @@ matplotlib 库中的样式包使更改绘图图的样式更加容易。 更改
 
 ```
 
-通过使用`set_major_formatter`方法消除直方图的 *x* 和 *y* 轴标签，并通过为其分配`NullFormatter`对象，可以绘制散点图：
+通过使用`set_major_formatter`方法消除直方图的`x`和`y`轴标签，并通过为其分配`NullFormatter`对象，可以绘制散点图：
 
 ```py
 >>> # no labels
@@ -385,7 +385,7 @@ matplotlib 库中的样式包使更改绘图图的样式更加容易。 更改
 
 ```
 
-*x* 和 *y* 轴的极限使用以下代码计算，其中 *x* 和 *y* 值的最大值 。 然后将最大值除以 bin，然后将其加一个，然后再与 bin 值相乘。 这样做是为了使`max`值前面有一些空间：
+`x`和`y`轴的极限使用以下代码计算，其中`x`和`y`值的最大值 。 然后将最大值除以 bin，然后将其加一个，然后再与 bin 值相乘。 这样做是为了使`max`值前面有一些空间：
 
 ```py
 >>> # now determine nice limits by hand:
@@ -546,7 +546,7 @@ matplotlib 库中的样式包使更改绘图图的样式更加容易。 更改
 
 ![Trellis plots](img/B03450_04_25.jpg)
 
-在前面的代码中，`rplot.RPlot`带有`tips_data`对象。 同样，定义了 *x* 和 *y* 轴值。 此后，根据吸烟者和性别定义网格网格。 最后，我们使用`GeomHistogram()`绘制直方图。
+在前面的代码中，`rplot.RPlot`带有`tips_data`对象。 同样，定义了`x`和`y`轴值。 此后，根据吸烟者和性别定义网格网格。 最后，我们使用`GeomHistogram()`绘制直方图。
 
 要将网格图更改为内核密度估计，我们可以使用以下代码：
 
@@ -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/05.md

@@ -126,7 +126,7 @@
 
 # 线性回归
 
-线性回归是建模中的方法，可帮助建模标量因变量 *Y* 与自变量 *X* 之间的标量线性关系，后者可以是一个或多个 价值：
+线性回归是建模中的方法，可帮助建模标量因变量`Y`与自变量`X`之间的标量线性关系，后者可以是一个或多个 价值：
 
 ![Linear regression](img/B03450_05_05.jpg)
 
@@ -153,11 +153,11 @@
 | 75 | 166 |
 | 65 | 160 |
 
-如果我们通过一个简单的线性回归函数（将在下一章中进行介绍）运行，则权重为因变量 *y* ，而自变量 *x* 是高度，我们得到以下方程式：
+如果我们通过一个简单的线性回归函数（将在下一章中进行介绍）运行，则权重为因变量`y`，而自变量`x`是高度，我们得到以下方程式：
 
 *y = 1.405405405 x + 57.87687688*
 
-如果您将前面的方程式绘制为以`57.88`作为截距的直线，并且该线的斜率在 *y* 轴和`Height`的散点图顶部为`1.4`在 *x* 轴上，则获得以下图：
+如果您将前面的方程式绘制为以`57.88`作为截距的直线，并且该线的斜率在`y`轴和`Height`的散点图顶部为`1.4`在`x`轴上，则获得以下图：
 
 ![Linear regression](img/B03450_05_06.jpg)
 
@@ -171,9 +171,9 @@ Logistic 回归是另一种监督学习技术，它基本上是一种概率分
 
 ![Logistic regression](img/B03450_05_07.jpg)
 
-此处， *x* 将是自变量， *F（x）*将是因变量。
+此处，`x`将是自变量， *F（x）*将是因变量。
 
-如果尝试绘制从负无穷大到正无穷大的逻辑函数，则将得到以下 *S* 形图：
+如果尝试绘制从负无穷大到正无穷大的逻辑函数，则将得到以下`S`形图：
 
 ![Logistic regression](img/B03450_05_08.jpg)
 
@@ -191,7 +191,7 @@ Logistic 回归是另一种监督学习技术，它基本上是一种概率分
 
 ![The naive Bayes classifier](img/B03450_05_09.jpg)
 
-在上式中， *A* 和 *B* 是事件， *P（A）*和 *P（B）*是[ *A* 和 *B* 相互依赖。 *P（A | B）*是 *A* 的概率，假设 *B* 是`True`，这是一个条件概率。 假设 *A* 为`True`，则 *P（B | A）*是 *B* 的概率。 朴素的贝叶斯公式如下：
+在上式中，`A`和`B`是事件， *P（A）*和 *P（B）*是[`A`和`B`相互依赖。 *P（A | B）*是`A`的概率，假设`B`是`True`，这是一个条件概率。 假设`A`为`True`，则 *P（B | A）*是`B`的概率。 朴素的贝叶斯公式如下：
 
 ![The naive Bayes classifier](img/B03450_05_13.jpg)
 
@@ -201,7 +201,7 @@ Logistic 回归是另一种监督学习技术，它基本上是一种概率分
 
 *   *AI* ：此事件表明 Stacy 的参与正在下雨
 *   *A2* ：此事件表明在 Stacy 的订婚中不下雨
-*   *B* ：此事件表明天气预报员预测会下雨
+*  `B`：此事件表明天气预报员预测会下雨
 
 以下是基于上述事件的概率：
 
@@ -224,19 +224,19 @@ Logistic 回归是另一种监督学习技术，它基本上是一种概率分
 
 # k 均值聚类
 
-k 均值聚类是一种无监督的学习技术，有助于将 *n* 观测值的数据划分为相似观测值的 *K* 桶。
+k 均值聚类是一种无监督的学习技术，有助于将`n`观测值的数据划分为相似观测值的`K`桶。
 
 ![The k-means clustering](img/B03450_05_10.jpg)
 
-之所以称其为聚类算法，是因为它通过计算特征的均值来进行操作，这些均值是指我们对事物进行聚类的因变量，例如根据平均交易量和每季度购买的平均产品数量对客户进行细分 一年 然后，该平均值成为群集的中心。 *K* 数是指簇数，即，通过计算均值 *K* 数，从而导致周围数据的*聚类*组成的技术 这些 k 均值*。*
+之所以称其为聚类算法，是因为它通过计算特征的均值来进行操作，这些均值是指我们对事物进行聚类的因变量，例如根据平均交易量和每季度购买的平均产品数量对客户进行细分 一年 然后，该平均值成为群集的中心。`K`数是指簇数，即，通过计算均值`K`数，从而导致周围数据的*聚类*组成的技术 这些 k 均值*。*
 
-我们如何选择这个 K？ 如果我们对所要寻找的东西有所了解，或者期望或想要多少个集群，那么在启动引擎并让算法进行计算之前，将 *K* 设置为该数字。
+我们如何选择这个 K？ 如果我们对所要寻找的东西有所了解，或者期望或想要多少个集群，那么在启动引擎并让算法进行计算之前，将`K`设置为该数字。
 
 如果我们不知道有多少，那么我们的探索将花费更长的时间并涉及一些反复试验，例如，当我们尝试 *K = 3* ，`4`和`5`，直到我们看到集群在我们的领域对我们有意义。
 
 ![The k-means clustering](img/B03450_05_11.jpg)
 
-*|| x* <sub>*i*</sub> *-v* <sub>*j*</sub> *||* 是 *xi* 与 *vj* ， *c* <sub>*i*</sub> 在*中的欧几里德距离。 在* <sup>*第*</sup> 个群集中，数据点的数量， *c* 是群集中心的数量。
+*|| x* <sub>`i`</sub> *-v* <sub>`j`</sub> *||* 是 *xi* 与 *vj* ，`c`<sub>`i`</sub> 在*中的欧几里德距离。 在* <sup>*第*</sup> 个群集中，数据点的数量，`c`是群集中心的数量。
 
 k 均值聚类广泛用于计算机视觉，市场细分，天文学，地统计学和农业。
 

new/master-py-ds/06.md

@@ -13,7 +13,7 @@
 
 *y = A + Bx*
 
-这里， *y* 是因变量， *x* 是自变量， *A* 是截距（其中 *x* 等于 零）， *B* 是系数
+这里，`y`是因变量，`x`是自变量，`A`是截距（其中`x`等于 零），`B`是系数
 
 我们将使用的数据集包含一个男性样本的身高（cm）和体重（kg）。
 
@@ -103,7 +103,7 @@ Coefficient value of the height is [ 1.00092142]
 
 ![Multiple regression](img/3450_06_17.jpg)
 
-其中， *Y* 是因变量， *a* 是截距， *b1* 和 *b2* 是系数， *x1* 和 *x2* 是自变量
+其中，`Y`是因变量，`a`是截距， *b1* 和 *b2* 是系数， *x1* 和 *x2* 是自变量
 
 另外，请注意，平方因变量仍使其线性，但如果系数为平方，则为非线性。
 
@@ -271,9 +271,9 @@ OLS 函数有助于创建具有因变量和自变量的线性回归对象。 `fi
 
 ![Training and testing a model](img/3450_06_11.jpg)
 
-前面的摘要提供了有关该模型的大量信息。 要查找的主要参数是 *r* 平方值，它告诉您模型捕获了因变量的多少方差。 它的范围从`0`到`1`，并且 *p* 值告诉我们该模型是否有效。
+前面的摘要提供了有关该模型的大量信息。 要查找的主要参数是`r`平方值，它告诉您模型捕获了因变量的多少方差。 它的范围从`0`到`1`，并且`p`值告诉我们该模型是否有效。
 
-从前面的输出中，我们可以看到`R-square`的值为`0.265`，这不是很好。 我们可以看到模型显示`x3`为最高有效变量，即`success_field_goals`变量。 根据经验，任何小于 0.05 的 *p* 值都可以认为是有意义的。
+从前面的输出中，我们可以看到`R-square`的值为`0.265`，这不是很好。 我们可以看到模型显示`x3`为最高有效变量，即`success_field_goals`变量。 根据经验，任何小于 0.05 的`p`值都可以认为是有意义的。
 
 让我们仅使用成功的目标变量来重新创建模型，并查看该模型如何执行：
 

new/master-py-ds/08.md

@@ -86,7 +86,7 @@ movie_user_preferences['William']['Gone Girl']
 
 ![The Euclidean distance score](img/B03450_08_01.jpg)
 
-使用前面的 DataFrame 的，我们将通过将`Django`保持为 *y* 轴，而将`Avengers`保持为 *x* 轴来绘制不同的用户：
+使用前面的 DataFrame 的，我们将通过将`Django`保持为`y`轴，而将`Avengers`保持为`x`轴来绘制不同的用户：
 
 ```py
 >>> plt.scatter(df.django, df.avenger)

new/master-py-ds/10.md

@@ -11,13 +11,13 @@
 
 # k-means 算法及其工作
 
-k 均值聚类算法通过计算特征的平均值（例如我们用于聚类的变量）来进行操作。 例如，根据平均交易金额和每季度购买的平均产品数量对客户进行细分。 然后，这意味着成为群集的中心。 *K* 数是聚类数，也就是说，该技术包含计算 *K* 数的均值，这些均数导致围绕这些 k 均值的数据聚类。
+k 均值聚类算法通过计算特征的平均值（例如我们用于聚类的变量）来进行操作。 例如，根据平均交易金额和每季度购买的平均产品数量对客户进行细分。 然后，这意味着成为群集的中心。`K`数是聚类数，也就是说，该技术包含计算`K`数的均值，这些均数导致围绕这些 k 均值的数据聚类。
 
-我们如何选择 *K* ？ 如果我们对所要寻找的东西有所了解，或者期望或想要多少个集群，则可以在启动引擎并进行算法计算之前将 *K* 设置为该数字。
+我们如何选择`K`？ 如果我们对所要寻找的东西有所了解，或者期望或想要多少个集群，则可以在启动引擎并进行算法计算之前将`K`设置为该数字。
 
 如果我们不知道有多少个集群，那么我们的探索将花费更长的时间并涉及一些反复试验，例如，当我们尝试 *K = 3* ，`4`时， 和`5`。
 
-k 均值算法是迭代的。 首先从数据中随机选择 *K* 点，然后将它们用作聚类中心。 然后，在每个迭代步骤中，此算法都会确定哪些行值最接近聚类中心，并为其分配 *K* 点。
+k 均值算法是迭代的。 首先从数据中随机选择`K`点，然后将它们用作聚类中心。 然后，在每个迭代步骤中，此算法都会确定哪些行值最接近聚类中心，并为其分配`K`点。
 
 完成此操作后，我们便有了新的积分安排。 因此，由于聚类的中心或均值可能已更改，因此再次对其进行了计算。 什么时候不转移？ 当我们拥有稳定的集群并且进行迭代直到无法从进一步迭代中受益时，这就是我们的结果。
 

new/py-ds-essentials/1.md

@@ -1110,7 +1110,7 @@ In: def plot_scatter(X,Y,R=None):
 
 ![](img/e4c174c2-7be7-4fa6-b9ce-0251a6ed2c04.png)
 
-在我们的示例中，随着 *X* 增加， *Y* 减少。 但是，这不会以恒定的速率发生，因为变化率会一直升高到一定的 *X* 值，然后降低并变为恒定。 这是非线性的条件，我们可以使用回归模型将其进一步可视化。 该模型假设 *X* 和 *Y* 之间的关系是线性的，形式为 *y = a + bX* 。 根据特定标准估算其 *a* 和 *b* 参数。
+在我们的示例中，随着`X`增加，`Y`减少。 但是，这不会以恒定的速率发生，因为变化率会一直升高到一定的`X`值，然后降低并变为恒定。 这是非线性的条件，我们可以使用回归模型将其进一步可视化。 该模型假设`X`和`Y`之间的关系是线性的，形式为 *y = a + bX* 。 根据特定标准估算其`a`和`b`参数。
 
 在第四个单元格中，我们分散了此问题的输入和输出值：
 
@@ -1233,7 +1233,7 @@ In: print (type(iris.data)) Out: <class 'numpy.ndarray'>
 
 例如，让我们观察一下当您希望通过使用散点图矩阵组合四个可用变量中的至少两个时，如何轻松地分离类。
 
-散点图矩阵以矩阵格式排列，其列和行是数据集变量。 矩阵的元素包含单个散点图，其 *x* 值由矩阵的行变量确定， *y* 值由列变量确定。 矩阵的对角元素可以同时在其行和列中包含分布直方图或变量的其他单变量表示形式。
+散点图矩阵以矩阵格式排列，其列和行是数据集变量。 矩阵的元素包含单个散点图，其`x`值由矩阵的行变量确定，`y`值由列变量确定。 矩阵的对角元素可以同时在其行和列中包含分布直方图或变量的其他单变量表示形式。
 
 pandas 库提供了一种现成的功能，可快速构建散点图矩阵并开始探索数据集中定量变量之间的关系和分布：
 

new/py-ds-essentials/2.md

@@ -800,7 +800,7 @@ In: dataset.iloc[range(2), [2,1]]
 Categorical_feature = sunny   binary_features = [1, 0, 0, 0, 0] Categorical_feature = cloudy  binary_features = [0, 1, 0, 0, 0] Categorical_feature = snowy   binary_features = [0, 0, 1, 0, 0] Categorical_feature = rainy   binary_features = [0, 0, 0, 1, 0] Categorical_feature = foggy   binary_features = [0, 0, 0, 0, 1]  
 ```
 
-只有一个二元特征揭示了分类特征的存在。 其他保持`0`。 这称为二进制编码或一种热编码。 通过执行此简单步骤，我们从分类世界转移到了数字世界。 此操作的代价是它在内存和计算方面的复杂性； 现在，我们有五个功能，而不是单个功能。 通常，我们将创建 *N* 个特征，而不是具有 *N* 个可能水平的单个分类特征，每个特征都有两个数值（1/0）。 该操作称为伪编码。
+只有一个二元特征揭示了分类特征的存在。 其他保持`0`。 这称为二进制编码或一种热编码。 通过执行此简单步骤，我们从分类世界转移到了数字世界。 此操作的代价是它在内存和计算方面的复杂性； 现在，我们有五个功能，而不是单个功能。 通常，我们将创建`N`个特征，而不是具有`N`个可能水平的单个分类特征，每个特征都有两个数值（1/0）。 该操作称为伪编码。
 
 pandas 软件包可帮助我们完成此操作，只需一个命令即可简化映射：
 
@@ -1147,9 +1147,9 @@ NumPy 提供了具有以下属性的`ndarray`对象类（n 维数组）：
 
 在 Python 中，数组是特定类型的内存连续数据块，其标头包含索引方案和数据类型描述符。
 
-多亏了索引方案，数组可以表示多维数据结构，其中每个元素都以 *n* 整数的元组索引，其中 *n* 是维数。 因此，如果您的数组是一维的（即顺序数据的向量），则索引将从零开始（如 Python 列表中所示）。
+多亏了索引方案，数组可以表示多维数据结构，其中每个元素都以`n`整数的元组索引，其中`n`是维数。 因此，如果您的数组是一维的（即顺序数据的向量），则索引将从零开始（如 Python 列表中所示）。
 
-如果是二维的，则必须使用两个整数作为索引（ *x* ， *y* 类型的坐标元组）； 如果存在三个维度，则使用的整数数将为三个（元组 *x* ， *y* ， *z* ），依此类推。
+如果是二维的，则必须使用两个整数作为索引（`x`，`y`类型的坐标元组）； 如果存在三个维度，则使用的整数数将为三个（元组`x`，`y`，`z`），依此类推。
 
 在每个索引位置，数组将包含指定数据类型的数据。 数组可以存储许多数值数据类型，以及字符串和其他 Python 对象。 也可以创建自定义数据类型，从而处理不同类型的数据序列，尽管我们建议不要这样做，并且建议您在这种情况下使用 pandas DataFrame。 熊猫数据结构确实对于数据科学家所必需的任何异构数据类型的密集使用都具有更大的灵活性。 因此，在本书中，我们将仅考虑特定的已定义类型的 NumPy 数组，并留给熊猫处理异质性。
 
@@ -1352,7 +1352,7 @@ Out: array([[1, 2],
 
 之前，我们提到了如何更改数组元素的类型。 现在，我们将停一会儿，以研究最常见的指令来修改现有数组的形状。
 
-让我们从使用`.reshape`方法的示例开始，该方法接受 *n* -元组，其中包含新尺寸的大小作为参数：
+让我们从使用`.reshape`方法的示例开始，该方法接受`n`-元组，其中包含新尺寸的大小作为参数：
 
 ```py
 In: import numpy as np
@@ -1798,7 +1798,7 @@ In: np.vstack((dataset,a_few_lines))
 In: np.vstack((dataset,single_line,single_line))
 ```
 
-另一种常见情况是，您必须向现有数组添加新变量。 在这种情况下，您必须使用`hstack`（**h** 代表**水平**），而不是刚刚显示的`vstack`命令（其中 **v** 为**垂直**）。
+另一种常见情况是，您必须向现有数组添加新变量。 在这种情况下，您必须使用`hstack`（`h`代表**水平**），而不是刚刚显示的`vstack`命令（其中`v`为**垂直**）。
 
 1.  假设您必须向原始数组中添加单位值的`bias`：
 
@@ -1911,7 +1911,7 @@ In: print(sparse_coo) Out: (0, 1)    1.0
  (1, 2)    1.0 (3, 2)    2.0 (3, 4)    1.0 (4, 2)    2.0
 ```
 
-从输出表示中，我们可以得出一个稀疏坐标格式矩阵的工作原理是将打印值存储在三个单独的存储数组中：一个用于 *x* 坐标，一个用于 *y* 坐标，以及 一个值。 这意味着在插入信息时，COO 矩阵的确非常快（每个新元素是每个存储阵列中的新行），但是处理起来缓慢，因为它无法立即找出行或列中的值以进行扫描 数组。
+从输出表示中，我们可以得出一个稀疏坐标格式矩阵的工作原理是将打印值存储在三个单独的存储数组中：一个用于`x`坐标，一个用于`y`坐标，以及 一个值。 这意味着在插入信息时，COO 矩阵的确非常快（每个新元素是每个存储阵列中的新行），但是处理起来缓慢，因为它无法立即找出行或列中的值以进行扫描 数组。
 
 对于列表（**lil**）矩阵中的（**dok**）键和**列表的**字典也是如此。 第一个使用坐标字典操作（因此它可以快速检索单个元素），第二个使用两个列表，两个列表排列成代表行，在行中包含非零坐标，其他两个值（很容易 通过添加更多行进行扩展）。
 COO 矩阵的另一个优点是，它们可以立即转换为专门用于在行或列级别有效工作的其他类型的矩阵：csr 和 csc 矩阵。****

new/py-ds-essentials/3.md

@@ -96,7 +96,7 @@ In: scatterplot = iris.plot(kind='scatter',
 
 ![](img/6e332947-47fe-450a-8354-87a2ce0be9e8.png)
 
-趋势十分明显。 我们推断 *x* 和 *y* 密切相关。 您通常在 EDA 期间执行的最后一项操作是检查功能的分布。 要使用大熊猫进行管理，您可以使用直方图来估算分布，这要归功于以下代码段：
+趋势十分明显。 我们推断`x`和`y`密切相关。 您通常在 EDA 期间执行的最后一项操作是检查功能的分布。 要使用大熊猫进行管理，您可以使用直方图来估算分布，这要归功于以下代码段：
 
 ```py
 In: distr = iris.petal_width.plot(kind='hist', alpha=0.5, bins=20)
@@ -1304,7 +1304,7 @@ In: from sklearn import model_selection
 
 使用预定义值只需要您从列表中选择一个评估指标（有一些用于分类和回归，有一些用于聚类）并通过将字符串直接插入或使用字符串变量插入`GridSearchCV`功能。
 
-`GridSearchCV`还接受称为`param_grid`的参数，该参数可以是一个字典，其中包含要更改的所有超参数的指示作为键，并作为要引用字典键的值包含要测试的参数列表。 因此，如果要测试关于超参数 *C* 的假设的性能，则可以创建如下字典：
+`GridSearchCV`还接受称为`param_grid`的参数，该参数可以是一个字典，其中包含要更改的所有超参数的指示作为键，并作为要引用字典键的值包含要测试的参数列表。 因此，如果要测试关于超参数`C`的假设的性能，则可以创建如下字典：
 
 ```py
 {'C' : [1, 10, 100, 1000]}
@@ -1613,7 +1613,7 @@ Out: In-sample accuracy: 1.000
      Out-of-sample accuracy: 0.667 
 ```
 
-我们有一个带有大量变量的小型数据集。 这是 *p > n* 类型的问题，其中 *p* 是变量数， *n* 是观察数。
+我们有一个带有大量变量的小型数据集。 这是 *p > n* 类型的问题，其中`p`是变量数，`n`是观察数。
 
 在这种情况下，数据集中肯定会有一些信息变量，但是其他变量提供的噪声可能会在为正确的特征分配正确的系数时使学习算法蒙蔽。 请记住，这种情况不是进行数据科学的最佳操作环境。 因此，最多只能期待平庸的结果。
 
@@ -1685,7 +1685,7 @@ Out: Variables selected: 3
 
 实际上，仅通过使用`RandomizedLogisticRegression`类的默认参数，我们获得了与基于 L1 的选择相似的结果。
 
-该算法工作正常。 它是可靠的并且开箱即用（没有参数可调整，除非您想降低 *C* 值以加快速度）。 我们只是建议您将`n_resampling`参数设置为较大的数目，以便您的计算机可以在合理的时间内处理稳定性选择。
+该算法工作正常。 它是可靠的并且开箱即用（没有参数可调整，除非您想降低`C`值以加快速度）。 我们只是建议您将`n_resampling`参数设置为较大的数目，以便您的计算机可以在合理的时间内处理稳定性选择。
 
 如果要对回归问题求助于相同的算法，则应改用`RandomizedLasso`类。 让我们看看如何使用它。 首先，我们创建一个足以解决回归问题的数据集。 为简单起见，我们将使用 100 个样本，10 个特征的观察矩阵； 信息特征的数量为`4`。
 

new/py-ds-essentials/4.md

@@ -108,11 +108,11 @@ In: %timeit regr.fit(X_train, y_train) Out: 544 µs ± 37.4 µs per loop
 
 那真的很快！ 结果当然不是那么好（如果您在本书前面的第 1 章和*第一步*）。 但是，线性回归在性能与训练速度和简单性之间提供了很好的权衡。 现在，让我们看一下该算法的内幕。 为什么这么快却不那么准确？ 答案在某种程度上是可以预期的-这是因为它是一种非常简单的线性方法。
 
-让我们简要地对此技术进行数学解释。 让我们将 *X（i）*命名为*第*个样本（实际上是具有数字特征的行向量），并将 *Y（i）*作为目标。 线性回归的目标是找到一个良好的权重（列）向量 *W* ，该向量最适合于与观察向量相乘时近似目标值，即 *X（i）* WɈY（i）*（请注意，这是点积）。 *W* 应该相同，并且对每个观察结果都是最佳的。 因此，解决以下等式变得容易：
+让我们简要地对此技术进行数学解释。 让我们将 *X（i）*命名为*第*个样本（实际上是具有数字特征的行向量），并将 *Y（i）*作为目标。 线性回归的目标是找到一个良好的权重（列）向量`W`，该向量最适合于与观察向量相乘时近似目标值，即 *X（i）* WɈY（i）*（请注意，这是点积）。`W`应该相同，并且对每个观察结果都是最佳的。 因此，解决以下等式变得容易：
 
 ![](img/11faed20-2131-458d-97c3-846e307fe09f.png)
 
-*W* 可以借助矩阵求逆（或更可能是伪求逆，这是一种计算有效的方法）和点积的帮助容易地找到。 这就是线性回归如此之快的原因。 请注意，这只是一个简单的解释-实际方法添加了另一个虚拟功能来补偿过程的偏差。 但是，这并没有很大程度地改变回归算法的复杂性。
+`W`可以借助矩阵求逆（或更可能是伪求逆，这是一种计算有效的方法）和点积的帮助容易地找到。 这就是线性回归如此之快的原因。 请注意，这只是一个简单的解释-实际方法添加了另一个虚拟功能来补偿过程的偏差。 但是，这并没有很大程度地改变回归算法的复杂性。
 
 我们现在进行逻辑回归。 尽管顾名思义，它是一个分类器，而不是回归器。 它只能用于仅处理两个类的分类问题（二进制分类）。 通常，目标标签是布尔值； 也就是说，它们的值为 True / False 或 0/1（指示是否存在预期结果）。 在我们的示例中，我们继续使用相同的数据集。 目标是猜测房屋价值是高于还是低于我们感兴趣的阈值的平均值。本质上，我们从回归问题转向二元分类问题，因为现在我们的目标是猜测一个示例的可能性有多大 成为一个小组的一部分。 我们开始使用以下命令来准备数据集：
 
@@ -162,7 +162,7 @@ Out: 2.75 ms ± 120 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
 
 *y_pred <sub>i</sub> =符号（X <sub>i</sub> * W）*
 
-在此，如果 *a* 大于或等于零，则*符号（a）= +1* ，否则为 0。
+在此，如果`a`大于或等于零，则*符号（a）= +1* ，否则为 0。
 
 为了降低阈值的难度并预测属于某个类别的可能性，逻辑回归求助于`logit`函数。 它的输出是一个（0 到 1）实数（只能通过舍入获得 0.0 和 1.0；否则， *logit* 函数将趋向于它们），这表示观察值属于 1 类的可能性。 使用公式，结果如下：
 

new/py-ds-essentials/5.md

@@ -40,7 +40,7 @@ In: import numpy as np
 
 # 尝试曲线图
 
-我们的第一个问题将要求您使用`pyplot`绘制函数。 绘制函数非常简单； 您只需要获取一系列 *x* 坐标，然后使用要绘制的函数将它们映射到 *y* 轴即可。 由于映射结果存储在两个向量中，因此`plot`函数将处理曲线表示。 如果映射的点足够多（50 个点是一个好的采样数），则表示的精度将更高：
+我们的第一个问题将要求您使用`pyplot`绘制函数。 绘制函数非常简单； 您只需要获取一系列`x`坐标，然后使用要绘制的函数将它们映射到`y`轴即可。 由于映射结果存储在两个向量中，因此`plot`函数将处理曲线表示。 如果映射的点足够多（50 个点是一个好的采样数），则表示的精度将更高：
 
 ```py
 In: import numpy as np
@@ -50,7 +50,7 @@ In: import numpy as np
     y_sin = np.sin(x)   
 ```
 
-使用 NumPy `linspace()`函数，我们将创建一系列 50 个等距的数字，范围从 0 到 5。我们可以使用它们将 *y* 映射到余弦和正弦函数：
+使用 NumPy `linspace()`函数，我们将创建一系列 50 个等距的数字，范围从 0 到 5。我们可以使用它们将`y`映射到余弦和正弦函数：
 
 ```py
 In: plt.figure() # initialize a figure
@@ -197,7 +197,7 @@ In: import numpy as np
 
 ![](img/cf8aabb7-2178-4f2b-ba45-55c8039b3928.png)
 
-在计算了 *h* （箱宽）后，通过将最大值和最小值之间的差除以 *h* 来计算箱数：
+在计算了`h`（箱宽）后，通过将最大值和最小值之间的差除以`h`来计算箱数：
 
 *bins =（max-min）/ h*
 
@@ -949,7 +949,7 @@ Bottle 是一个 Python 网络框架，是 HTTP 上微型应用程序的起点
 
 请注意，在此虚拟示例中，我们仅定义了`/personal/<name>`路由。 除非代码中定义，否则任何其他调用都将导致`Error 404`。
 
-要关闭它，我们需要在命令行中按 *Ctrl* + *C* （记住`run`功能正在阻止）。
+要关闭它，我们需要在命令行中按 *Ctrl* +`C`（记住`run`功能正在阻止）。
 
 现在让我们创建一个更加面向数据科学的服务； 我们将创建一个 HTML 页面，该页面的表单要求隔垫的长度和宽度以及花瓣的长度和宽度，以对虹膜样本进行分类。 在此示例中，我们将使用虹膜数据集来训练 scikit-learn 分类器。 然后，对于每个预测，我们只需在分类器上调用`predict`函数，将预测发送回去：
 

new/thoughtful-ds/02.md

@@ -497,7 +497,7 @@ display(cars)
 
 PixieDust Charts 菜单
 
-首次调用图表菜单时，将显示一个选项对话框，以配置一组基本配置选项，例如 *X* 和 *Y* 轴所使用的类型 聚合等等 为了节省您的时间，该对话框将预先填充 PixieDust 从 DataFrame 自动检查的数据模式。
+首次调用图表菜单时，将显示一个选项对话框，以配置一组基本配置选项，例如`X`和`Y`轴所使用的类型 聚合等等 为了节省您的时间，该对话框将预先填充 PixieDust 从 DataFrame 自动检查的数据模式。
 
 在以下示例中，我们将创建一个条形图，显示按马力计算的平均里程消耗：
 

new/thoughtful-ds/03.md

@@ -688,7 +688,7 @@ def load_commit_activity(owner, repo_name):
 
 在单独的单元格中使用 display（）获取可视化配置
 
-要获取上述图表，您需要选择**折线图**，然后在**选项**对话框中，将`week`列拖放到**键[** 框和`total`列到 **Values** 框。 您还需要选择 Bokeh 作为渲染器。 完成后，请注意，PixieDust 将自动检测到 *x* 轴为日期时间，并将相应地调整渲染。
+要获取上述图表，您需要选择**折线图**，然后在**选项**对话框中，将`week`列拖放到**键[** 框和`total`列到 **Values** 框。 您还需要选择 Bokeh 作为渲染器。 完成后，请注意，PixieDust 将自动检测到`x`轴为日期时间，并将相应地调整渲染。
 
 使用**编辑元数据**按钮，我们现在可以复制图表选项 JSON 片段：
 

new/thoughtful-ds/04.md

@@ -104,7 +104,7 @@ Pixiedust version 1.1.10
 
 ### 注意
 
-**注意**：要停止 PixieGateway 服务器，只需从终端使用 *Ctrl* + *C* 。
+**注意**：要停止 PixieGateway 服务器，只需从终端使用 *Ctrl* +`C`。
 
 现在，您可以通过以下 URL 打开 PixieGateway 管理控制台：`http://localhost:8899/admin`。
 

new/thoughtful-ds/05.md

@@ -1126,7 +1126,7 @@ PixieApp 编程模型的设计原则之一是最大程度地减少开发人员
 
 ### 注意
 
-**注意**：每种浏览器版本都有其自己的调用开发者控制台的方式。 例如，在 Google Chrome 浏览器中，您将使用**视图** | **开发人员** | **JavaScript 控制台，**或*命令* + *Alt* + *J* 快捷键。
+**注意**：每种浏览器版本都有其自己的调用开发者控制台的方式。 例如，在 Google Chrome 浏览器中，您将使用**视图** | **开发人员** | **JavaScript 控制台，**或*命令* + *Alt* +`J`快捷键。
 
 我特别喜欢的另一种调试技术是使用`debugger;`语句以编程方式插入 JavaScript 代码的断点中。 除非打开浏览器开发人员工具并启用源调试，否则该语句无效；在这种情况下，执行将在`debugger;`语句处自动中断。
 

new/thoughtful-ds/06.md

@@ -64,7 +64,7 @@
 
 ![What is deep learning?](img/00114.jpeg)
 
-其中![What is deep learning?](img/00115.jpeg)是 *i* 和 *i + 1* 层之间的权重矩阵。 这些权重是在训练阶段计算出来的，稍后我们将简要讨论。
+其中![What is deep learning?](img/00115.jpeg)是`i`和 *i + 1* 层之间的权重矩阵。 这些权重是在训练阶段计算出来的，稍后我们将简要讨论。
 
 ### 注意
 
@@ -123,7 +123,7 @@ TensorFlow 高级 API 架构
 提醒一下，XOR 运算符只有四个训练示例：
 
 <colgroup class="calibre23"><col class="calibre24"> <col class="calibre24"> <col class="calibre24"></colgroup> 
-| **X** | **和** | **结果** |
+|`X`| **和** | **结果** |
 | 0 | 0 | 0 |
 | 0 | 1 | 1 |
 | 1 | 0 | 1 |

new/thoughtful-ds/08.md

@@ -669,7 +669,7 @@ plt.show()
 
 滞后= 100 的 MSFT 的 ACF
 
-上图显示了 *x* 横坐标给出的多个先前数据点（滞后）处数据的自相关。 因此，在滞后`0`处，您始终具有`1.0`的自相关（您始终与自己完美相关），滞后`1`显示与先前数据点的自相关，滞后`2`显示与以下数据的自相关 落后两个步骤的数据点。 我们可以清楚地看到，随着滞后的增加，自相关减小。 在上一张图表中，我们仅使用了 100 个滞后，并且我们看到自相关仍然在 0.9 左右具有统计显着性，这告诉我们长时间分隔的数据是不相关的。 这表明数据具有趋势，当浏览整体价格图表时，这一趋势非常明显。
+上图显示了`x`横坐标给出的多个先前数据点（滞后）处数据的自相关。 因此，在滞后`0`处，您始终具有`1.0`的自相关（您始终与自己完美相关），滞后`1`显示与先前数据点的自相关，滞后`2`显示与以下数据的自相关 落后两个步骤的数据点。 我们可以清楚地看到，随着滞后的增加，自相关减小。 在上一张图表中，我们仅使用了 100 个滞后，并且我们看到自相关仍然在 0.9 左右具有统计显着性，这告诉我们长时间分隔的数据是不相关的。 这表明数据具有趋势，当浏览整体价格图表时，这一趋势非常明显。
 
 为了确认这个假设，我们用更大的`lags`参数绘制 ACF 图表，例如`1000`（鉴于我们的系列有 10,000 个以上的数据点这一事实，这是不合理的），如以下屏幕快照所示：
 
@@ -938,7 +938,7 @@ def add_ticker_selection_markup(refresh_ids):
 
 ## StockExploreSubApp –第一个孩子 PixieApp
 
-现在，我们可以实现名为`StockExploreSubApp`的第一个子 PixieApp。 在主屏幕中，我们创建两个`<div>`元素，每个元素均具有`pd_options`属性，该属性以`Adj. Close`和`daily_spread`作为值调用`show_chart`路由。 反过来，`show_chart`路由返回一个`<div>`元素，该元素的`pd_entity`属性指向`parent_pixieapp.get_active_df()`方法，该属性带有一个`<pd_options>`元素，该元素包含一个 JSON 有效载荷，用于显示带有`Date`的散景折线图 ]作为 *x* 横坐标，并且将任何值作为参数传递为 *y* 纵坐标的列。 我们还使用`BaseSubApp.add_ticker_selection_markup`装饰器装饰路线，并使用前两个`<div>`元素的 ID 作为`refresh_ids`参数。
+现在，我们可以实现名为`StockExploreSubApp`的第一个子 PixieApp。 在主屏幕中，我们创建两个`<div>`元素，每个元素均具有`pd_options`属性，该属性以`Adj. Close`和`daily_spread`作为值调用`show_chart`路由。 反过来，`show_chart`路由返回一个`<div>`元素，该元素的`pd_entity`属性指向`parent_pixieapp.get_active_df()`方法，该属性带有一个`<pd_options>`元素，该元素包含一个 JSON 有效载荷，用于显示带有`Date`的散景折线图 ]作为`x`横坐标，并且将任何值作为参数传递为`y`纵坐标的列。 我们还使用`BaseSubApp.add_ticker_selection_markup`装饰器装饰路线，并使用前两个`<div>`元素的 ID 作为`refresh_ids`参数。
 
 以下代码显示了`StockExplorerSubApp`子 PixieApp 的实现：
 
@@ -1187,9 +1187,9 @@ ARIMA 是最受欢迎的时间系列预测模型之一，顾名思义，它由
 
     ![Time series forecasting using the ARIMA model](img/00185.jpeg)
 
-    其中![Time series forecasting using the ARIMA model](img/00186.jpeg)是从先前观察值和![Time series forecasting using the ARIMA model](img/00187.jpeg)中获知的模型的权重，是观察值 *t* 的残差。
+    其中![Time series forecasting using the ARIMA model](img/00186.jpeg)是从先前观察值和![Time series forecasting using the ARIMA model](img/00187.jpeg)中获知的模型的权重，是观察值`t`的残差。
 
-    我们也将 *p* 称为自回归模型的阶，该阶数定义为上式中包含的滞后观测次数。
+    我们也将`p`称为自回归模型的阶，该阶数定义为上式中包含的滞后观测次数。
 
     例如：
 
@@ -1201,7 +1201,7 @@ ARIMA 是最受欢迎的时间系列预测模型之一，顾名思义，它由
 
     ![Time series forecasting using the ARIMA model](img/00189.jpeg)
 
-*   **I**: Stands for **integrated**. For the ARIMA model to work, it is assumed that the time series is stationary or can be made stationary. A series is said to be stationary ([https://en.wikipedia.org/wiki/Stationary_process](https://en.wikipedia.org/wiki/Stationary_process)) if its mean and variance doesn't change over time.
+*  `I`: Stands for **integrated**. For the ARIMA model to work, it is assumed that the time series is stationary or can be made stationary. A series is said to be stationary ([https://en.wikipedia.org/wiki/Stationary_process](https://en.wikipedia.org/wiki/Stationary_process)) if its mean and variance doesn't change over time.
 
     ### 注意
 
@@ -1209,7 +1209,7 @@ ARIMA 是最受欢迎的时间系列预测模型之一，顾名思义，它由
 
     使用数学符号，严格平稳性可以转换为：
 
-    ![Time series forecasting using the ARIMA model](img/00190.jpeg)和![Time series forecasting using the ARIMA model](img/00191.jpeg)对于任何 *t* ， *m* 和 *k，*都是相同的，其中 *F* 是联合概率分布 。
+    ![Time series forecasting using the ARIMA model](img/00190.jpeg)和![Time series forecasting using the ARIMA model](img/00191.jpeg)对于任何`t`，`m`和 *k，*都是相同的，其中`F`是联合概率分布 。
 
     实际上，此条件太强了，最好使用前面提供的较弱的定义。
 
@@ -1217,7 +1217,7 @@ ARIMA 是最受欢迎的时间系列预测模型之一，顾名思义，它由
 
     ![Time series forecasting using the ARIMA model](img/00192.jpeg)
 
-    在系列实际变为固定时间之前，可能需要多次对数差分转换。 我们称 *d* 为使用对数差分对序列进行变换的次数。
+    在系列实际变为固定时间之前，可能需要多次对数差分转换。 我们称`d`为使用对数差分对序列进行变换的次数。
 
     例如：
 
@@ -1241,7 +1241,7 @@ ARIMA 是最受欢迎的时间系列预测模型之一，顾名思义，它由
 
     是时间序列的平均值，![Time series forecasting using the ARIMA model](img/00187.jpeg)是序列中的残差，![Time series forecasting using the ARIMA model](img/00195.jpeg)是滞后残差的权重。
 
-    我们将 *q* 称为移动平均窗口的大小。
+    我们将`q`称为移动平均窗口的大小。
 
     例如：
 
@@ -1251,12 +1251,12 @@ ARIMA 是最受欢迎的时间系列预测模型之一，顾名思义，它由
 
     ![Time series forecasting using the ARIMA model](img/00196.jpeg)
 
-根据先前的定义，我们使用符号 *ARIMA（p，d，q）*定义 ARIMA 模型，其阶数为 *p* 的自回归模型，阶为[ *d* 和大小为 *q* 的移动平均窗口。
+根据先前的定义，我们使用符号 *ARIMA（p，d，q）*定义 ARIMA 模型，其阶数为`p`的自回归模型，阶为[`d`和大小为`q`的移动平均窗口。
 
-实现所有代码以建立 ARIMA 模型可能非常耗时。 幸运的是，`statsmodels`库在`statsmodels.tsa.arima_model`包中实现了`ARIMA`类，该类提供了使用`fit()`方法训练模型并使用`predict()`方法预测值所需的所有计算。 它还照顾日志差异以使时间序列固定。 诀窍在于找到用于构建最佳 ARIMA 模型的参数 *p* ， *d* 和 *q* 。 为此，我们使用 ACF 和 PACF 图表，如下所示：
+实现所有代码以建立 ARIMA 模型可能非常耗时。 幸运的是，`statsmodels`库在`statsmodels.tsa.arima_model`包中实现了`ARIMA`类，该类提供了使用`fit()`方法训练模型并使用`predict()`方法预测值所需的所有计算。 它还照顾日志差异以使时间序列固定。 诀窍在于找到用于构建最佳 ARIMA 模型的参数`p`，`d`和`q`。 为此，我们使用 ACF 和 PACF 图表，如下所示：
 
-*   *p* 值对应于滞后数（在 *x* 横坐标上），ACF 图表首次超过统计显着性阈值。
-*   类似地， *q* 值对应于 PACF 图表首次超过统计显着性阈值的滞后次数（在 *x* 横坐标上）。
+*  `p`值对应于滞后数（在`x`横坐标上），ACF 图表首次超过统计显着性阈值。
+*   类似地，`q`值对应于 PACF 图表首次超过统计显着性阈值的滞后次数（在`x`横坐标上）。
 
 ## 为 MSFT 库存时间序列建立 ARIMA 模型
 
@@ -1343,7 +1343,7 @@ pp.pprint({labels[i]: ad_fuller_results[i] for i in range(4)})
 
 p 值低于显着性水平； 因此，我们可以否定 *AR（1）*模型中存在单位根的零假设，这使我们确信时间序列是固定的。
 
-然后我们绘制 ACF 和 PACF 图表，这将为我们提供 ARIMA 模型的 *p* 和 *q* 参数：
+然后我们绘制 ACF 和 PACF 图表，这将为我们提供 ARIMA 模型的`p`和`q`参数：
 
 以下代码构建了 ACF 图表：
 
@@ -1410,7 +1410,7 @@ with warnings.catch_warnings():
 
 **注意**：我们使用`warnings`包来避免在使用较旧版本的 NumPy 和 pandas 时可能发生的弃用警告。
 
-在前面的代码中，我们将`train_set['Adj. Close']`用作`ARIMA`构造函数的参数。 由于我们对数据使用序列，因此我们还需要为`dates`参数传递`train_set['Date']`系列。 请注意，如果我们通过带有`DateIndex`索引的 pandas DataFrame 来传递，则不必使用`dates`参数。 `ARIMA`构造函数的最后一个参数是`order`参数，它是表示 *p* ， *d* 和 *q* 顺序的三个值的元组， 如本节开头所讨论的。
+在前面的代码中，我们将`train_set['Adj. Close']`用作`ARIMA`构造函数的参数。 由于我们对数据使用序列，因此我们还需要为`dates`参数传递`train_set['Date']`系列。 请注意，如果我们通过带有`DateIndex`索引的 pandas DataFrame 来传递，则不必使用`dates`参数。 `ARIMA`构造函数的最后一个参数是`order`参数，它是表示`p`，`d`和`q`顺序的三个值的元组， 如本节开头所讨论的。
 
 然后，我们调用`fit()`方法，该方法返回将用于预测值的实际 ARIMA 模型。 出于信息目的，我们使用`arima_model.resid.describe()`打印有关模型剩余误差的统计信息。
 
@@ -1540,7 +1540,7 @@ def stock_explore_screen(self):
 
 [您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%208/sampleCode31.py)。
 
-`ForecastArimaSubApp`子 PixieApp 由两个屏幕组成。 第一个屏幕显示时间序列图表以及 ACF 和 PACF 图表。 该屏幕的目的是为用户提供必要的数据探索，以找出 *p* ， *d* 和 *q* 的值是什么。 ARIMA 模型的[]顺序，如上一节所述。 通过查看时间序列图，我们可以找出时间序列是否固定（提醒一下，这是构建 ARIMA 模型的必要条件）。 如果没有，用户可以单击**添加差异**按钮，尝试使用对数差异转换来制作 DataFrame 信纸。 然后，使用转换后的 DataFrame 更新这三个图表。
+`ForecastArimaSubApp`子 PixieApp 由两个屏幕组成。 第一个屏幕显示时间序列图表以及 ACF 和 PACF 图表。 该屏幕的目的是为用户提供必要的数据探索，以找出`p`，`d`和`q`的值是什么。 ARIMA 模型的[]顺序，如上一节所述。 通过查看时间序列图，我们可以找出时间序列是否固定（提醒一下，这是构建 ARIMA 模型的必要条件）。 如果没有，用户可以单击**添加差异**按钮，尝试使用对数差异转换来制作 DataFrame 信纸。 然后，使用转换后的 DataFrame 更新这三个图表。
 
 以下代码显示了`ForecastArimaSubApp`子 PixieApp 的默认路由：
 
@@ -1756,7 +1756,7 @@ def show_pacf_screen(self):
 
 应用差异的第一个预测屏幕
 
-下一步是实现由**继续预测**按钮调用的`do_forecast`路由。 这条路线负责建立 ARIMA 模型； 首先显示一个配置页面，其中包含三个输入文本，这些文本可让用户输入 *p* ， *d* 和 *q* 订单，通过查看 数据浏览屏幕中的图表。 我们添加一个`Go`按钮以使用`build_arima_model`路线进行模型构建，我们将在本节稍后讨论。 标头上还有一个`Diagnose Model`按钮，该按钮调用另一个负责评估模型准确性的页面。
+下一步是实现由**继续预测**按钮调用的`do_forecast`路由。 这条路线负责建立 ARIMA 模型； 首先显示一个配置页面，其中包含三个输入文本，这些文本可让用户输入`p`，`d`和`q`订单，通过查看 数据浏览屏幕中的图表。 我们添加一个`Go`按钮以使用`build_arima_model`路线进行模型构建，我们将在本节稍后讨论。 标头上还有一个`Diagnose Model`按钮，该按钮调用另一个负责评估模型准确性的页面。
 
 此处显示了`do_forecast`路由的实现。 请注意，当用户选择其他股票行情自动收录器时，我们将`add_ticker_selection_markup`与空数组一起使用以刷新整个页面：
 

new/thoughtful-ds/09.md

@@ -20,11 +20,11 @@
 
 将柯尼斯堡七桥问题简化为图形问题
 
-使用更正式的定义，**图**是表示对象（称为**顶点**或**节点**）之间对象之间的成对关系（称为**边缘**）的数据结构。 ）。 通常使用以下表示法表示图形： *G =（V，E）*其中 *V* 是顶点集，而 *E* 是顶点集 的边缘。
+使用更正式的定义，**图**是表示对象（称为**顶点**或**节点**）之间对象之间的成对关系（称为**边缘**）的数据结构。 ）。 通常使用以下表示法表示图形： *G =（V，E）*其中`V`是顶点集，而`E`是顶点集 的边缘。
 
 图主要有两大类：
 
-*   **有向图（称为有向图）**：成对关系的顺序很重要，即，从顶点 **A** 到顶点 **B** 的边（AB） ]不同于从顶点 **B** 到顶点 **A** 的边缘（BA）。
+*   **有向图（称为有向图）**：成对关系的顺序很重要，即，从顶点`A`到顶点`B`的边（AB） ]不同于从顶点`B`到顶点`A`的边缘（BA）。
 *   **无向图**：成对关系的顺序无关紧要，即边（A-B）与边（B-A）相同。
 
 下图显示了示例图的表示形式，即无向（边缘没有箭头）和有向（边缘有箭头）：
@@ -35,13 +35,13 @@
 
 主要有两种表示图形的方式：
 
-*   **Adjacency matrix**: Represents the graph using an *n* by *n* matrix (we'll call it *A*), where *n* is the number of vertices in the graph. The vertices are indexed using 1 to *n* integers. We use ![Graph representations](img/00214.jpeg) to denote that an edge exists between vertex *i* and vertex *j* and ![Graph representations](img/00215.jpeg) to denote that no edge exists between vertex *i* and vertex *j*. In the case of undirected graphs, we would always have ![Graph representations](img/00216.jpeg)![Graph representations](img/00217.jpeg) because the order doesn't matter. However, in the case of digraphs where order matters, *A**<sub class="calibre29">i,j</sub>* may be different from *A**<sub class="calibre29">j,i</sub>*. The following example shows how to represent a sample graph in an adjacency matrix both directed and undirected:
+*   **Adjacency matrix**: Represents the graph using an`n`by`n`matrix (we'll call it `A`), where`n`is the number of vertices in the graph. The vertices are indexed using 1 to`n`integers. We use ![Graph representations](img/00214.jpeg) to denote that an edge exists between vertex`i`and vertex`j`and ![Graph representations](img/00215.jpeg) to denote that no edge exists between vertex`i`and vertex`j`. In the case of undirected graphs, we would always have ![Graph representations](img/00216.jpeg)![Graph representations](img/00217.jpeg) because the order doesn't matter. However, in the case of digraphs where order matters,`A`<sub class="calibre29">i,j</sub>* may be different from`A`<sub class="calibre29">j,i</sub>*. The following example shows how to represent a sample graph in an adjacency matrix both directed and undirected:
 
     ![Graph representations](img/00218.jpeg)
 
     图的邻接矩阵表示（有向和无向）
 
-    重要的是要注意，邻接矩阵表示具有恒定的空间复杂度，即![Graph representations](img/00219.jpeg)，其中 *n* 是顶点数，但是的时间复杂度为 *O（1）*，这是恒定时间，用于计算两个顶点之间是否存在边连接。 当图形密集（边缘很多）时，高空间复杂度可能还可以，但在图形稀疏时可能会浪费空间，在这种情况下，我们可能更喜欢以下邻接表表示形式。
+    重要的是要注意，邻接矩阵表示具有恒定的空间复杂度，即![Graph representations](img/00219.jpeg)，其中`n`是顶点数，但是的时间复杂度为 *O（1）*，这是恒定时间，用于计算两个顶点之间是否存在边连接。 当图形密集（边缘很多）时，高空间复杂度可能还可以，但在图形稀疏时可能会浪费空间，在这种情况下，我们可能更喜欢以下邻接表表示形式。
 
     ### 注意
 
@@ -55,7 +55,7 @@
 
     图的邻接表表示（有向和无向）
 
-    与邻接矩阵表示法相反，邻接列表表示法具有较小的空间复杂度，即 *O（m + n）*，其中 *m* 是边的个数， *n* 是顶点数。 但是，与邻接矩阵的 *O（1）*相比，时间复杂度增加到 *O（m）*。 由于这些原因，当图稀疏连接时（即没有很多边），最好使用邻接表表示。
+    与邻接矩阵表示法相反，邻接列表表示法具有较小的空间复杂度，即 *O（m + n）*，其中`m`是边的个数，`n`是顶点数。 但是，与邻接矩阵的 *O（1）*相比，时间复杂度增加到 *O（m）*。 由于这些原因，当图稀疏连接时（即没有很多边），最好使用邻接表表示。
 
 正如前面的讨论所暗示的那样，要使用哪种图形表示形式在很大程度上取决于图形密度，还取决于我们计划使用的算法类型。 在下一节中，我们将讨论最常用的图形算法。
 
@@ -96,7 +96,7 @@
 
         （来源：https://en.wikipedia.org/wiki/Centrality#Closeness_centrality）
 
-        其中 *d（y，x）*是节点 *x* 和 *y* 之间的边缘长度。
+        其中 *d（y，x）*是节点`x`和`y`之间的边缘长度。
 
     *   **Shortest path betweenness**: Measure based on how many times the given vertex is part of the shortest path between any two nodes. The intuition is that the more a vertex contributes to shortest paths, the more important it is. The mathematical equation for shortest path betweenness is provided here:
 
@@ -104,7 +104,7 @@
 
         （来源：https：//en.wikipedia.org/wiki/Centrality#Betweenness_centrality）
 
-        其中![Graph algorithms](img/00225.jpeg)是从顶点 *s* 到顶点 *t* 的最短路径总数，![Graph algorithms](img/00226.jpeg)是通过 *v* 的![Graph algorithms](img/00227.jpeg)的子集。 。
+        其中![Graph algorithms](img/00225.jpeg)是从顶点`s`到顶点`t`的最短路径总数，![Graph algorithms](img/00226.jpeg)是通过`v`的![Graph algorithms](img/00227.jpeg)的子集。 。
 
         ### 注意
 
@@ -1438,7 +1438,7 @@ plt.show()
 
 PARI 图表以获取 ARRIVAL_DELAY 数据的对数差异
 
-作为第 8 章，*金融时间序列分析和预测*的提醒，ARIMA 模型由三个阶组成： *p* 和 *d* 和 *q* 。 从前面的两个图表中，我们可以推断出要构建的 ARIMA 模型的这些顺序：
+作为第 8 章，*金融时间序列分析和预测*的提醒，ARIMA 模型由三个阶组成：`p`和`d`和`q`。 从前面的两个图表中，我们可以推断出要构建的 ARIMA 模型的这些顺序：
 
 *   **自回归阶数 p 为 1**：对应于 ACF 第一次越过有效水平
 *   **积分顺序 d 为 1**：我们必须做一次对数差异