2021-03-11 23:13:09

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

@@ -451,7 +451,7 @@ scikit_learn==0.19.0
     df = pd.concat((y, df), axis=1)
     ```
 
-    在这里，我们引入了一个虚拟变量`y`来保存目标列的副本，然后再将其从`DataFrame`中删除。 然后，我们使用 Pandas 串联函数将其与沿第 1 轴（而不是第 0 轴，后者组合行）的其余`DataFrame`组合在一起。
+    在这里，我们引入了一个虚拟变量`y`来保存目标列的副本，然后再将其从`DataFrame`中删除。 然后，我们使用 Pandas 连接函数将其与沿第 1 轴（而不是第 0 轴，后者组合行）的其余`DataFrame`组合在一起。
 
     ### 注意
 

new/master-py-ds/01.md

@@ -193,7 +193,7 @@ Array[10 10 10 10]
 
 ## 形状处理
 
-创建数组后，我们也可以更改其形状。 以下命令将数组展平：
+创建数组后，我们也可以更改其形状。 以下命令将数组展开：
 
 ```py
 >>> n_array.ravel()

new/master-py-ds/10.md

@@ -308,7 +308,7 @@ dtype: float64
 
 数组中的每个值都是平方的平均和，该平方具有一个群集到一组十个群集。
 
-现在，我们使用以下数据绘制 K 均值聚类的**肘形曲线**（这是曲线开始展平的点）：
+现在，我们使用以下数据绘制 K 均值聚类的**肘形曲线**（这是曲线开始展开的点）：
 
 ```py
 >>> #Choosing the cluster number

new/py-ds-essentials/1.md

@@ -1199,7 +1199,7 @@ In: from sklearn import datasets
 加载数据集后，我们可以浏览数据描述并了解特征和目标的存储方式。 所有 Scikit-learn数据集都提供以下方法：
 
 *   `.DESCR`：这提供了数据集的一般描述
-*   `.data`：包含所有功能
+*   `.data`：包含所有特征
 *   `.feature_names`：此报告功能的名称
 *   `.target`：包含目标值，以值或编号的类别表示
 *   `.target_names`：这将报告目标中的类的名称

new/py-ds-essentials/2.md

@@ -11,7 +11,7 @@
 *   选择您需要的数据
 *   清理任何丢失或错误的数据
 *   添加，插入和删除数据
-*   分组和转换数据以获得新的有意义的信息
+*   分组和转换数据来获得新的有意义的信息
 *   管理获取数据集矩阵或数组以馈入数据科学管道
 
 # 数据科学过程
@@ -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])
@@ -463,7 +463,7 @@ In: col5 = pd.Series([4, 3, 2, 1, 0])
                               ignore_index = True, keys=['Col5', 'Col6']) my_new_dataset = pd.concat([my_own_dataset, a_new_dataset], axis=1) my_new_dataset
 ```
 
-结果数据集是`col5`和`col6`系列的串联：
+结果数据集是`col5`和`col6`系列的连接：
 
 ![](img/cf788dcf-3724-4619-9e4e-141bc314f0ef.png)
 
@@ -481,7 +481,7 @@ In: key = pd.Series([1, 2, 4])
  keys=['Col5', 'Col7']) reference_table
 ```
 
-这是`key`和`value`到一个`DataFrame`之间的串联：
+这是`key`和`value`到一个`DataFrame`之间的连接：
 
 ![](img/e7db965a-1b36-4a5f-a308-9cae74eeebd3.png)
 
@@ -569,12 +569,12 @@ In: iris['target'].unique() Out: array(['Iris-setosa', 'Iris-versicolor', 'New l
 *   `median`：返回中位数； 即第 50 个百分位
 *   `min`：最低值
 *   `max`：最高值
-*   `mode`：模式，是最频繁出现的值
+*   `mode`：众数，是最频繁出现的值
 *   `var`：方差，用于测量值的离散度
 *   `std`：标准差，是方差的平方根
 *   `mad`：平均绝对偏差，这是一种测量对异常值稳健的值的离散度的方法
-*   `skew`：偏度的度量，指示分布对称性
-*   `kurt`：峰度的量度，指示分布形状
+*   `skew`：偏度，指示分布对称性
+*   `kurt`：峰度，指示分布形状
 
 下一步，我们可以尝试使用`groupby`的几个示例。 通过按目标（即标签）对观察结果进行分组，我们可以检查每组特征的平均值和方差之间的差异：
 
@@ -596,7 +596,7 @@ In: grouped_targets_var = iris.groupby(['target']).var()
 
 ![](img/d89cc76a-fb61-43b0-a558-a8c9840a65e2.png)
 
-由于您可能需要对每个变量进行多个统计，因此您可以直接使用`agg`方法，并针对每个变量应用特定的功能，而不是通过串联将多个聚合的数据集放在一起。 您可以通过字典定义变量，字典中的键是变量标签，值是要应用的函数的列表–由字符串（例如`'mean'`，`'std'`，`'min'`，`'max'`，`'sum'`和`'prod'`）或通过当场声明的预定义函数甚至是 Lambda 函数：
+由于您可能需要对每个变量进行多个统计，因此您可以直接使用`agg`方法，并针对每个变量应用特定的功能，而不是通过连接将多个聚合的数据集放在一起。 您可以通过字典定义变量，字典中的键是变量标签，值是要应用的函数的列表–由字符串（例如`'mean'`，`'std'`，`'min'`，`'max'`，`'sum'`和`'prod'`）或通过当场声明的预定义函数甚至是 Lambda 函数：
 
 ```py
 In: funcs = {'sepal_length': ['mean','std'],
@@ -896,8 +896,8 @@ In: print(twenty_sci_news.data[0]) Out: From: flb@flb.optiplan.fi ("F.Baube[tm]"
 
 例如，让我们制作一个小的，易于处理的数据集：
 
-*   `Document_1`：我们热爱数据科学
-*   `Document_2`：数据科学很难
+*   `Document_1`：`we love data science`
+*   `Document_2`：`data science is hard`
 
 在包含`Document_1`和`Document_2`的整个数据集中，只有六个不同的词：`we`，`love`，`data`，`science`，`is`和`hard`。 给定此数组，我们可以将每个文档与特征向量关联：
 
@@ -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')`重新定义它
 
 相反，代表多个维度的数据结构列表只能将自己变成嵌套列表，从而增加访问数据时的开销和内存碎片。
 
@@ -1179,7 +1179,7 @@ Python 列表数据结构实际上更麻烦，更慢，它是将列表结构链
 
 *   通过将现有数据结构转换为数组
 *   通过从头开始创建数组并使用默认值或计算值填充它
-*   通过将一些数据从磁盘上传到阵列
+*   通过将一些数据从磁盘上传到数组
 
 如果要转换现有的数据结构，则最好使用结构化列表或 Pandas `DataFrame`。
 
@@ -1640,7 +1640,7 @@ In: coefs = np.array([1., 0.5, 0.5, 0.5, 0.5])
 In: np.dot(M,coefs) Out: array([  5.,  20.,  35.,  50.,  65.])  
 ```
 
-3.  或向量通过数组：
+3.  或向量到数组：
 
 ```py
 In: np.dot(coefs,M) Out: array([ 25.,  28.,  31.,  34.,  37.])  
@@ -1773,7 +1773,7 @@ In: import numpy as np
     dataset = np.arange(10*5).reshape(10,5)  
 ```
 
-2.  现在，让我们添加一行和一排要彼此串联的行：
+2.  现在，让我们添加一行和一排要彼此连接的行：
 
 ```py
 In: single_line = np.arange(1*5).reshape(1,5)
@@ -1792,7 +1792,7 @@ In: np.vstack((dataset,single_line))
 In: np.vstack((dataset,a_few_lines))  
 ```
 
-5.  或者，如果您想多次添加同一行，则该元组可以表示新串联数组的顺序结构：
+5.  或者，如果您想多次添加同一行，则该元组可以表示新连接数组的顺序结构：
 
 ```py
 In: np.vstack((dataset,single_line,single_line))

new/py-ds-essentials/3.md

@@ -4,7 +4,7 @@
 
 在本章中，您将学习如何执行以下操作：
 
-*   简要浏览数据并创建新功能
+*   简要浏览数据并创建新特征
 *   降低数据的维数
 *   发现并处理异常值
 *   确定项目的最佳得分或损失指标
@@ -1134,8 +1134,8 @@ Out: LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
 
 *   学习算法（`estimator`）
 *   一组预测变量（`X`）
-*   `target`变量（`y`）
-*   交叉验证倍数（`cv`）
+*   目标变量（`y`）
+*   交叉验证器（`cv`）
 *   评分函数（`scoring`）
 *   要使用的 CPU 数（`n_jobs`）
 

new/py-ds-essentials/4.md

@@ -732,7 +732,7 @@ XGBoost 算法在 [Kaggle](http://www.kaggle.com) 和 KDD-cup 2015 等数据科
 *   `eta`：相当于 Scikit-learn 的 GTB 中的学习率。 它影响算法学习的速度，从而影响需要多少棵树。 较高的值有助于更好地融合学习过程，但代价是要花费更多的训练时间和更多的树木。
 *   `gamma`：这是树开发中的停止标准，因为它表示在树的叶节点上进行进一步分区所需的最小损失减少。 更高的价值使学习更加保守。
 *   `min_child_weight`：这些代表树的叶子节点上存在的最小权重（示例）。 较高的值可防止过拟合和树的复杂性。
-*   `max_depth`：树中的交互数。
+*   `max_depth`：树的最大深度。
 *   `subsample`：训练数据中示例的一部分，将在每次迭代中使用。
 *   `colsample_bytree`：在每次迭代中使用的特征分数。
 *   `colsample_bylevel`：在每个分支分割中使用的特征分数（如在随机森林中）。
@@ -899,7 +899,7 @@ In: y_probs = bst.predict(covertype_test_X,
 
 您可以为算法提供分类变量的索引，并设置一个`one_hot_max_size`参数，告诉 CatBoost 使用单热编码来处理分类变量（如果变量的级别小于或等于该级别）。 如果变量具有更多分类级别，从而超过了`one_hot_max_size`参数，则算法将以与均值编码不太相同的方式对它们进行编码，如下所示：
 
-1.  排列示例顺序。
+1.  排列示例级别。
 2.  根据损耗函数将级别转换为整数，以使其最小化。
 3.  根据对目标的随机排序，根据对级别标签进行计数，将级别号转换为浮点数值（更多详细信息请参见[这个页面](https://tech.yandex.com/catboost/doc/dg/concepts/algorithm-main-stages_cat-to-numberic-docpage/)（带有简单示例）。
 
@@ -915,7 +915,7 @@ CatBoost 除了具有 R 和 Python API 并在 GBM 领域中以与 XGBoost 和 Li
 *   `iterations`：迭代次数
 *   `od_wait`：评估指标未改善时要等待的迭代次数
 *   `learning_rate`：学习率
-*   `depth`：树木的深度
+*   `depth`：树的深度
 *   `l2_leaf_reg`：正则化系数
 *   `random_strength`和`bagging_temperature`控制随机装袋
 
@@ -964,7 +964,7 @@ In: model.fit(covertype_train, eval_set=covertype_val,
 
 ![](img/3b213c6d-0a5e-4336-8232-de0335d2cb4e.png)
 
-5.  训练后，我们只需预测班级及其相关概率：
+5.  训练后，我们只需预测类别及其相关概率：
 
 ```py
 In: preds_class = model.predict(covertype_test) 
@@ -1053,7 +1053,7 @@ In: import os
 
 *   批量大小
 *   数据预处理
-*   相同示例的通过次数
+*   相同示例的传递次数
 *   验证和参数微调
 
 批量大小通常取决于您的可用内存。 原理是数据块越大越好，因为随着数据样本的大小增加，数据样本将获得更多的数据分布代表。 此外，数据预处理也具有挑战性。 增量学习算法可以很好地处理`[-1, +1]`或`[0, +1]`范围内的数据（例如，多项式贝叶斯不接受负值）。 但是，要缩放到如此精确的范围，您需要事先知道每个变量的范围。 或者，您必须执行以下操作之一：一次传递所有数据，记录最小值和最大值，或者从第一批数据中导出它们，并修剪超出初始最大值和最小值的以下观察值。

new/py-ds-essentials/5.md

@@ -799,7 +799,7 @@ In: import numpy as np
 
 `learning_curve`类需要以下内容作为输入：
 
-*   一系列存储在列表中的训练量
+*   一系列存储在列表中的训练值
 *   指示要使用的折数以及错误度量
 *   您要测试的机器学习算法（参数估计器）
 *   预测变量（参数`X`）和目标结果（参数`y`）

new/py-ds-essentials/6.md

@@ -6,7 +6,7 @@
 
 *   图，因为社交网络通常以这种形式表示
 *   用于从图中获取见解的重要算法
-*   如何加载，转储和采样大图
+*   如何加载，转储和采样大型图
 
 # 图论概论
 

new/py-ds-essentials/7.md

@@ -3,11 +3,11 @@
 在本章中，我们将介绍深度模型，并且将显示三个如何构建深度模型的示例。 更具体地说，在本章中，您将学习以下内容：
 
 *   深度学习的基础
-*   如何优化深网
+*   如何优化深度网络
 *   速度/复杂性/准确性问题
-*   如何使用 CNN 对图像进行分类
-*   如何使用预训练的网络进行分类和迁移学习
-*   如何使用 LSTM 对序列进行操作
+*   如何将 CNN 用于图像分类
+*   如何将预训练的网络用于分类和迁移学习
+*   如何将 LSTM 用于序列操作
 
 我们将使用 [Keras 软件包](https://keras.io/)，这是用于深度学习的高级 API，它将使用于深度学习的神经网络更加容易和易于理解，因为其特点是类似于乐高的方法（这里的积木是神经网络的组成元素）。
 
@@ -36,11 +36,11 @@
 它如何产生最终预测？ 让我们逐步了解它的工作方式：
 
 1.  从隐藏层的顶部单元开始，它在第一层的输出向量（即输入观察向量）与第一层和第一层的第一单元之间的连接权重向量之间执行点积。 隐藏层。
-2.  然后使用该单元的激活功能转换该值。
+2.  然后使用该单元的激活函数转换该值。
 3.  对隐藏层中的所有单元重复此操作。
 4.  最后，我们可以以相同的方式计算隐藏层和输出层之间的前馈传播值，从而产生网络的输出。
 
-这个过程看起来非常简单，它由多个令人尴尬的并行任务组成。 解释的最后一个缺失点是激活功能：它是什么，为什么需要它？ 激活函数有助于使二元决策更加可分离（它使决策边界成为非线性，从而有助于更好地分离示例），并且它是每个单元的属性（或属性）； 理想情况下，每个单元应该具有不同的激活功能，尽管通常将它们按层分组。
+这个过程看起来非常简单，它由多个令人尴尬的并行任务组成。 解释的最后一个缺失点是激活函数：它是什么，为什么需要它？ 激活函数有助于使二元决策更加可分离（它使决策边界成为非线性，从而有助于更好地分离示例），并且它是每个单元的属性（或属性）； 理想情况下，每个单元应该具有不同的激活函数，尽管通常将它们按层分组。
 
 典型的激活函数是 Sigmoid，双曲正切和`softmax`（用于分类问题）函数，尽管目前最流行的函数是**整流线性单元**（或 **ReLU**），其输出是 0 和输入之间的最大值（其中输入是上一层输出和连接权重之间的点积）。
 
@@ -304,11 +304,11 @@ Out:
 1.  卷积层，具有 32 个`3x3`滤镜和 ReLU 激活
 2.  `BatchNormalization`层
 3.  另一个卷积层，然后是`BatchNormalization`层
-4.  退出层，被丢弃的可能性为 0.4
-5.  展平层
-6.  512 单位致密层，具有 ReLU 激活
+4.  丢弃层，被丢弃的可能性为 0.4
+5.  展开层
+6.  512 单位密集层，具有 ReLU 激活
 7.  `BatchNormalization`层
-8.  退出层，被丢弃的可能性为 0.5
+8.  丢弃层，被丢弃的可能性为 0.5
 9.  输出层； 如上例所示，这是一个具有 43 个单位的`softmax`密集层
 
 那将如何在我们的数据集上执行？
@@ -404,7 +404,7 @@ Out:
 
 *   特征增强，以将特征（在这种情况下为预测标签）以及观察向量添加到模型中
 *   迁移学习，以将更多特征（来自一层或模型层的系数）以及观察向量添加到模型中
-*   预言; 也就是说，计算标签
+*   预测；也就是说，计算标签
 
 现在让我们看看如何使用预训练的网络来实现我们的目的。
 
@@ -592,7 +592,7 @@ In: print(X_train[0])
 
 1.  嵌入层。 原始词典设置为 25,000 个单词，组成嵌入的单位数（即图层的输出）为 256。
 2.  LSTM 层。 **LSTM** 代表**长短期记忆**，它是最强大的序列深度模型之一。 得益于其深厚的架构，它能够从序列中相距较远的单词中提取信息（因此得名）。 在此示例中，像元数设置为`256`（作为上一层输出尺寸），其中`0.4`的缺失用于正则化。
-3.  具有 Sigmoid活化的致密层。 这就是我们需要的二进制分类器。
+3.  具有 Sigmoid活化的密集层。 这就是我们需要的二进制分类器。
 
 这是执行此操作的代码：
 

new/py-ds-essentials/8.md

@@ -89,7 +89,7 @@ HDFS 的架构是主从结构。 如果主服务器（称为**名称节点**）
 *   **映射器**：从每个块中生成一系列键值对。 每个映射器实例将相同的映射函数应用于不同的数据块。 继续前面的示例，对于每一行，在此步骤中生成了三个键值对-一个键值对包含该行中的字符数（键可以简单地是*字符串*），其中一个包含单词个数（在这种情况下，密钥必须不同，所以假设是*单词*），其中一个包含行数，该行数始终为 1（在这种情况下，密钥可以是*行*）。
 *   **打乱器**：从可用键的数量和可用的化简器的数量，混洗器将具有相同键的所有键-值对分配给同一异化器。 通常，此操作是计算键的哈希值，将其除以精简器的数量，然后使用余数来指出特定的精简器。 这应确保每个异径管有足够数量的钥匙。 该功能不是用户可编程的，而是由 MapReduce 框架提供的。
 *   **归约器**：每个简化器都接收一组特定键的所有键值对，并且可以产生零个或多个聚合结果。 在该示例中，所有与*单词*键相关的值都到达简化器； 它的工作只是总结所有价值。 其他键也一样，这将产生三个最终值：字符数，单词数和行数。 请注意，这些结果可能在不同的减速器上。
-*   **输出编写器**：减速器的输出写在文件系统（或 HDFS）上。 在默认的 Hadoop 配置中，每个归约器都会写入一个文件（`part-r-00000`是第一个归约器的输出，`part-r-00001`是第二个归约器的输出，依此类推）。 要在文件上显示完整的结果列表，应将所有结果串联起来。
+*   **输出编写器**：减速器的输出写在文件系统（或 HDFS）上。 在默认的 Hadoop 配置中，每个归约器都会写入一个文件（`part-r-00000`是第一个归约器的输出，`part-r-00001`是第二个归约器的输出，依此类推）。 要在文件上显示完整的结果列表，应将所有结果连接起来。
 
 在视觉上，可以简单地传达和理解此操作，如下所示：
 

new/py-ds-essentials/9.md

@@ -16,7 +16,7 @@
 *   列表
 *   字典
 *   类，对象和面向对象的编程
-*   例外情况
+*   异常
 *   迭代器和生成器
 *   条件
 *   推导式
@@ -82,7 +82,7 @@ del a_list[0]
 # a_list is now [2.5, 'a', True, 5]
 ```
 
-*   要串联两个列表，请使用`+`，如下所示：
+*   要连接两个列表，请使用`+`，如下所示：
 
 ```py
 a_list += [1, 'b'] 

new/thoughtful-ds/06.md

@@ -75,7 +75,7 @@
 
 当然，在`A`上应用神经元激活函数`g(x)`不能简单地产生二进制（0 或 1）值，因为如果存在多个类的得分为 1，我们将无法正确地排列最终候选答案。相反，我们使用激活函数，该函数提供介于 0 和 1 之间的非离散得分，并设置阈值（例如 0.5）来决定是否激活神经元。
 
-乙状结肠功能是最受欢迎的激活功能之一：
+乙状结肠功能是最受欢迎的激活函数之一：
 
 ![What is deep learning?](img/00118.jpeg)