Merge pull request #411 from jiangzhonglian/master

例子和案例 统一修改为 示例

README.md

@@ -6,7 +6,7 @@
 <table>
     <tr align="center">
         <td><a title="sklearn 0.21.3[master] 中文文档" href="https://sklearn.apachecn.org/" target="_blank"><font size="5">sklearn 0.21.3 中文文档</font></a></td>
-        <td><a title="sklearn 0.21.3[master] 中文案例" href="https://sklearn.apachecn.org/docs/examples" target="_blank"><font size="5">sklearn 0.21.3 中文案例</font></a></td>
+        <td><a title="sklearn 0.21.3[master] 中文示例" href="https://sklearn.apachecn.org/docs/examples" target="_blank"><font size="5">sklearn 0.21.3 中文示例</font></a></td>
         <td><a title="sklearn 英文官网" href="https://scikit-learn.org" target="_blank"><font size="5">sklearn 英文官网</font></a></td>
     </tr>
 </table>

docs/examples/Generalized_Linear_Models/plot_document_classification_20newsgroups.md

@@ -4,7 +4,7 @@
 >翻译者:[@Loopy](https://github.com/loopyme)        
 >校验者:[@barrycg](https://github.com/barrycg)
 
-这个例子展示了如何使用scikit-learn中的单词包方法，根据主题对文档进行分类。本例使用scipy.sparse中的矩阵来存储特征，并演示各种能够有效处理稀疏矩阵的分类器。
+这个示例展示了如何使用scikit-learn中的单词包方法，根据主题对文档进行分类。本例使用scipy.sparse中的矩阵来存储特征，并演示各种能够有效处理稀疏矩阵的分类器。
 
 本例中使用的数据集是20条新闻组数据集。通过scikit-learn可以自动下载该数据集，并进行缓存。
 

docs/examples/Generalized_Linear_Models/plot_ridge_path.md

@@ -8,7 +8,7 @@
 
 `岭回归` 是本例中使用的预测模型。每种颜色都分别表示不同特征下的回归系数向量，岭系数alpha是正则化项的参数。下图表示了岭系数作为变量参数,回归系数在岭回归模型中的变化。
 
-这个例子还显示了将岭回归应用于高病态矩阵的有效性。在高病态矩阵中，一些变量的微小变化会导致计算权重(回归系数)的巨大差异。在这种情况下，设置一个确定的正则化项(alpha)可以减少这种不良差异(噪声)。
+这个示例还显示了将岭回归应用于高病态矩阵的有效性。在高病态矩阵中，一些变量的微小变化会导致计算权重(回归系数)的巨大差异。在这种情况下，设置一个确定的正则化项(alpha)可以减少这种不良差异(噪声)。
 
 当alpha很大时，正则化项是平方损失函数的主要影响因子，回归系数的影响趋于零。在路径的末端，当alpha趋近零时,损失函数会慢慢变成普通最小二乘，回归系数表现出较大的波动。在实践中，有必要对alpha进行调优，以便在两者之间保持平衡。
 

docs/examples/Generalized_Linear_Models/plot_tomography_l1_reconstruction.md

@@ -4,9 +4,9 @@
 >翻译者:[@Loopy](https://github.com/loopyme)        
 >校验者:[@barrycg](https://github.com/barrycg)
 
-这个例子展示了从一组沿不同角度获得的平行投影来重建图像的过程。这样的数据集是在CT(计算机断层扫描)中获得的。
+这个示例展示了从一组沿不同角度获得的平行投影来重建图像的过程。这样的数据集是在CT(计算机断层扫描)中获得的。
 
-在没有任何样本得先验信息的情况下，重建图像所需的投影数与图像的线性大小l(以像素为单位)相同。为了简单起见，我们在这里考虑稀疏图像，其中只有对象边界上的像素具有非零值(例如:这些数据可以对应于细胞材料)。但是请注意，大多数图像在不同的基(basis)上是稀疏的，比如Haar小波 。只获得了l/7的投影，因此有必要利用关于样品的现有信息(稀疏性):这是压缩感知的一个例子。
+在没有任何样本得先验信息的情况下，重建图像所需的投影数与图像的线性大小l(以像素为单位)相同。为了简单起见，我们在这里考虑稀疏图像，其中只有对象边界上的像素具有非零值(例如:这些数据可以对应于细胞材料)。但是请注意，大多数图像在不同的基(basis)上是稀疏的，比如Haar小波 。只获得了l/7的投影，因此有必要利用关于样品的现有信息(稀疏性):这是压缩感知的一个示例。
 
 层析投影操作是一种线性变换。除了线性回归对应的数据保真项外，我们还对图像的L1范数进行了惩罚，以解释其稀疏性。由此产生的优化问题称为Lasso。我们使用类sklearn.linear_model.Lasso,它是使用坐标下降算法实现的。重要的是，这种在稀疏阵上算法的计算效率比这里投影算子更高。
 

docs/examples/README.md

-# 例子
+# 示例
 
 英文地址: <https://scikit-learn.org/stable/auto_examples/index.html>
 
-## 其他例子
+## Miscellaneous 示例
 
-scikit学习的其他和入门示例。
+scikit-learn 的 Miscellaneous 和入门示例。
 
 | | | | |
 | -- | -- | -- | -- |
@@ -75,7 +75,7 @@ scikit学习的其他和入门示例。
 | ![](img/sphx_glr_plot_compare_cross_decomposition_thumb.png) <br/> [比较交叉分解方法](https://scikit-learn.org/stable/auto_examples/cross_decomposition/plot_compare_cross_decomposition.html#sphx-glr-auto-examples-cross-decomposition-plot-compare-cross-decomposition-py)[](https://scikit-learn.org/stable/auto_examples/index.html#id57) |
 
 
-## 数据集的例子
+## 数据集的示例
 
 有关[`sklearn.datasets`](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.datasets "sklearn.datasets")模块的示例。
 

docs/examples/SUMMARY.md

-* 其他例子
+* Miscellaneous 示例
 * 广义线性模型
     * [分类特征稀疏的文本](Generalized_Linear_Models/plot_document_classification_20newsgroups.md)
     * [Lasso和Elastic Net(弹性网络)在稀疏信号上的表现](Generalized_Linear_Models/plot_lasso_and_elasticnet.md)

docs/master/10.md

@@ -96,7 +96,7 @@ Number of mislabeled points out of a total 150 points : 6
 
 与多项分布朴素贝叶斯的规则不同 伯努利朴素贝叶斯明确地惩罚类 ![y](img/0775c03fc710a24df297dedcec515aaf.jpg) 中没有出现作为预测因子的特征 ![i](img/43e13b580daefe5ba754b790dfbd216c.jpg) ，而多项分布分布朴素贝叶斯只是简单地忽略没出现的特征。
 
-在文本分类的例子中，统计词语是否出现的向量(word occurrence vectors)(而非统计词语出现次数的向量(word count vectors))可以用于训练和使用这个分类器。 `BernoulliNB` 可能在一些数据集上表现得更好，特别是那些更短的文档。 如果时间允许，建议对两个模型都进行评估。
+在文本分类的示例中，统计词语是否出现的向量(word occurrence vectors)(而非统计词语出现次数的向量(word count vectors))可以用于训练和使用这个分类器。 `BernoulliNB` 可能在一些数据集上表现得更好，特别是那些更短的文档。 如果时间允许，建议对两个模型都进行评估。
 
 > **参考资料**:
 >*   C.D. Manning, P. Raghavan and H. Schütze (2008). Introduction to Information Retrieval. Cambridge University Press, pp. 234-265.

docs/master/12.md

@@ -147,7 +147,7 @@ True
 
 通过对多个随机树中的 **预期贡献率** （expected activity rates） **取平均**，可以减少这种估计的 **方差** ，并将其用于特征选择。这被称作平均纯度减少，或MDI。关于MDI以及随机森林特征重要性的更多信息，请参考[L2014]。
 
-下面的例子展示了一个面部识别任务中每个像素的相对重要性，其中重要性由颜色（的深浅）来表示，使用的模型是 [`ExtraTreesClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesClassifier.html#sklearn.ensemble.ExtraTreesClassifier "sklearn.ensemble.ExtraTreesClassifier") 。
+下面的示例展示了一个面部识别任务中每个像素的相对重要性，其中重要性由颜色（的深浅）来表示，使用的模型是 [`ExtraTreesClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesClassifier.html#sklearn.ensemble.ExtraTreesClassifier "sklearn.ensemble.ExtraTreesClassifier") 。
 
 [![https://scikit-learn.org/stable/_images/sphx_glr_plot_forest_importances_faces_001.png](/img/69bbc745b66051792cd1b5166ce18420.jpg)](https://scikit-learn.org/stable/auto_examples/ensemble/plot_forest_importances_faces.html)
 
@@ -190,7 +190,7 @@ AdaBoost 既可以用在分类问题也可以用在回归问题中:
 
 ### 1.11.3.1. 使用方法
 
-下面的例子展示了如何训练一个包含 100 个弱学习器的 AdaBoost 分类器:
+下面的示例展示了如何训练一个包含 100 个弱学习器的 AdaBoost 分类器:
 
 ```py
 >>> from sklearn.model_selection import cross_val_score
@@ -251,7 +251,7 @@ GBRT 的缺点:
 
 ### 1.11.4.1. 分类
 
-[`GradientBoostingClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html#sklearn.ensemble.GradientBoostingClassifier "sklearn.ensemble.GradientBoostingClassifier") 既支持二分类又支持多分类问题。 下面的例子展示了如何训练一个包含 100 个决策树弱学习器的梯度提升分类器:
+[`GradientBoostingClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html#sklearn.ensemble.GradientBoostingClassifier "sklearn.ensemble.GradientBoostingClassifier") 既支持二分类又支持多分类问题。 下面的示例展示了如何训练一个包含 100 个决策树弱学习器的梯度提升分类器:
 
 ```py
 >>> from sklearn.datasets import make_hastie_10_2
@@ -484,7 +484,7 @@ Accuracy: 0.95 (+/- 0.04) [Ensemble]
 
 具体的权重可以通过权重参数 `weights` 分配给每个分类器。当提供权重参数 `weights` 时，收集每个分类器的预测分类概率， 乘以分类器权重并取平均值。然后将具有最高平均概率的类别标签确定为最终类别标签。
 
-为了用一个简单的例子来说明这一点，假设我们有 3 个分类器和一个 3 类分类问题，我们给所有分类器赋予相等的权重：w1 = 1,w2 = 1,w3 = 1 。
+为了用一个简单的示例来说明这一点，假设我们有 3 个分类器和一个 3 类分类问题，我们给所有分类器赋予相等的权重：w1 = 1,w2 = 1,w3 = 1 。
 
 样本的加权平均概率计算如下：
 
@@ -563,7 +563,7 @@ Accuracy: 0.95 (+/- 0.04) [Ensemble]
 ## 1.11.6. 投票回归器(Voting Regressor)
 [投票回归器](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.VotingRegressor.html#sklearn.ensemble.VotingRegressor)背后的思想是将概念上不同的机器学习回归器组合起来，并返回平均预测值。这样一个回归器对于一组同样表现良好的模型是有用的，以便平衡它们各自的弱点。
 
-下面的例子展示了如何匹配投票回归器:
+下面的示例展示了如何匹配投票回归器:
 ``` py
 >>> from sklearn import datasets
 >>> from sklearn.ensemble import GradientBoostingRegressor

docs/master/13.md

@@ -103,7 +103,7 @@ array([[0, 0, 1, 1, 1],
 
 ### 1.12.2.1. 多类学习
 
-下面是一个使用 OvR 的一个例子：
+下面是一个使用 OvR 的一个示例：
 
 ```py
 >>> from sklearn import datasets
@@ -139,7 +139,7 @@ array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
 ### 1.12.3.1. 多类别学习
 
-下面是一个使用OvO进行多类别学习的例子:
+下面是一个使用OvO进行多类别学习的示例:
 
 ```py
 >>> from sklearn import datasets
@@ -175,7 +175,7 @@ array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
 ### 1.12.4.1. 多类别学习
 
-下面是一个使用Output-Codes进行多类别学习的例子:
+下面是一个使用Output-Codes进行多类别学习的示例:
 
 ```py
 >>> from sklearn import datasets
@@ -230,7 +230,7 @@ array([[-154.75474165, -147.03498585,  -50.03812219],
 
 Multioutput classification 支持能够被添加到任何带有 `MultiOutputClassifier` 标志的分类器中. 这种方法为每一个目标训练一个分类器。 这就允许产生多目标变量分类器。这种类的目的是扩展评估器用于评估一系列目标函数 (f1,f2,f3…,fn) ，这些函数在一个单独的预测矩阵上进行训练以此来预测一系列的响应 (y1,y2,y3…,yn)。
 
-下面是多输出分类的一个例子:
+下面是多输出分类的一个示例:
 
 ```py
 >>> from sklearn.datasets import make_classification

docs/master/14.md

@@ -84,14 +84,14 @@ array([[0, 1],
 给定一个外部的估计器，可以对特征赋予一定的权重（比如，线性模型的相关系数），recursive feature elimination ( [`RFE`](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.RFE.html#sklearn.feature_selection.RFE "sklearn.feature_selection.RFE") ) 通过考虑越来越小的特征集合来递归的选择特征。 首先，评估器在初始的特征集合上面训练并且每一个特征的重要程度是通过一个 `coef_` 属性 或者 `feature_importances_` 属性来获得。 然后，从当前的特征集合中移除最不重要的特征。在特征集合上不断的重复递归这个步骤，直到最终达到所需要的特征数量为止。 [`RFECV`](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.RFECV.html#sklearn.feature_selection.RFECV "sklearn.feature_selection.RFECV") 在一个交叉验证的循环中执行 RFE 来找到最优的特征数量
 
 >**示例:**
->*   [Recursive feature elimination](https://scikit-learn.org/stable/auto_examples/feature_selection/plot_rfe_digits.html#sphx-glr-auto-examples-feature-selection-plot-rfe-digits-py) : 通过递归式特征消除来体现数字分类任务中像素重要性的例子。
+>*   [Recursive feature elimination](https://scikit-learn.org/stable/auto_examples/feature_selection/plot_rfe_digits.html#sphx-glr-auto-examples-feature-selection-plot-rfe-digits-py) : 通过递归式特征消除来体现数字分类任务中像素重要性的示例。
 >*   [Recursive feature elimination with cross-validation](https://scikit-learn.org/stable/auto_examples/feature_selection/plot_rfe_with_cross_validation.html#sphx-glr-auto-examples-feature-selection-plot-rfe-with-cross-validation-py) : 通过递归式特征消除来自动调整交叉验证中选择的特征数。
 
 ## 1.13.4. 使用 SelectFromModel 选取特征
 
 [`SelectFromModel`](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectFromModel.html#sklearn.feature_selection.SelectFromModel "sklearn.feature_selection.SelectFromModel") 是一个 meta-transformer（元转换器） ，它可以用来处理任何带有 `coef_` 或者 `feature_importances_` 属性的训练之后的评估器。 如果相关的``coef_`` 或者 `featureimportances` 属性值低于预先设置的阈值，这些特征将会被认为不重要并且移除掉。除了指定数值上的阈值之外，还可以通过给定字符串参数来使用内置的启发式方法找到一个合适的阈值。可以使用的启发式方法有 mean 、 median 以及使用浮点数乘以这些（例如，0.1*mean ）。
 
-有关如何使用的例子，可以参阅下面的例子。
+有关如何使用的示例，可以参阅下面的示例。
 
 >**示例:**
 >*  [Feature selection using SelectFromModel and LassoCV](https://scikit-learn.org/stable/auto_examples/feature_selection/plot_select_from_model_boston.html#sphx-glr-auto-examples-feature-selection-plot-select-from-model-boston-py): 从 Boston 数据中自动选择最重要两个特征而不需要提前得知这一信息。

docs/master/17.md

@@ -16,7 +16,7 @@
 
 *   [`GaussianNB`](https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html#sklearn.naive_bayes.GaussianNB "sklearn.naive_bayes.GaussianNB") 往往将概率推到 0 或 1（注意直方图中的计数）. 这主要是因为它假设特征在给定类别的条件下是独立的, 在该数据集中不包含 2 个冗余特征.
 
-*   [`RandomForestClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn.ensemble.RandomForestClassifier "sklearn.ensemble.RandomForestClassifier") 解释了相反的行为：直方图在约 0.2 和 0.9 的概率时显示峰值, 而接近 0 或 1 的概率非常罕见. Niculescu-Mizil 和 Caruana [4] 给出了一个解释：”诸如 bagging 和 random forests（随机森林）的方法， 从基本模型的平均预测中可能难以将预测置于 0 和 1 附近, 因为基础模型的变化会偏离预测值, 它们应该接近于零或偏离这些值, 因为预测被限制在 [0,1] 的间隔, 由方差引起的误差往往是靠近 0 和 1 的一边， 例如，如果一个模型应该对于一个案例，预测 p = 0，bagging 可以实现的唯一方法是假设所有的 bagging 树预测为零. 如果我们在 bagging 树上增加噪声, 这种噪声将导致一些树预测大于 0 的值, 因此将 bagging 的平均预测从 0 移开. 我们用随机森林最强烈地观察到这种效应, 因为用随机森林训练的 base-level 树由于特征划分而具有相对较高的方差. 因此，校准曲线也被称为可靠性图 (Wilks 1995 [5] ) 显示了一种典型的 sigmoid 形状, 表明分类器可以更多地信任其 “直觉”, 并通常将接近 0 或 1 的概率返回.
+*   [`RandomForestClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn.ensemble.RandomForestClassifier "sklearn.ensemble.RandomForestClassifier") 解释了相反的行为：直方图在约 0.2 和 0.9 的概率时显示峰值, 而接近 0 或 1 的概率非常罕见. Niculescu-Mizil 和 Caruana [4] 给出了一个解释：”诸如 bagging 和 random forests（随机森林）的方法， 从基本模型的平均预测中可能难以将预测置于 0 和 1 附近, 因为基础模型的变化会偏离预测值, 它们应该接近于零或偏离这些值, 因为预测被限制在 [0,1] 的间隔, 由方差引起的误差往往是靠近 0 和 1 的一边， 例如，如果一个模型应该对于一个示例，预测 p = 0，bagging 可以实现的唯一方法是假设所有的 bagging 树预测为零. 如果我们在 bagging 树上增加噪声, 这种噪声将导致一些树预测大于 0 的值, 因此将 bagging 的平均预测从 0 移开. 我们用随机森林最强烈地观察到这种效应, 因为用随机森林训练的 base-level 树由于特征划分而具有相对较高的方差. 因此，校准曲线也被称为可靠性图 (Wilks 1995 [5] ) 显示了一种典型的 sigmoid 形状, 表明分类器可以更多地信任其 “直觉”, 并通常将接近 0 或 1 的概率返回.
 
 *   线性支持向量分类 ([`LinearSVC`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html#sklearn.svm.LinearSVC "sklearn.svm.LinearSVC")) 显示了作为 RandomForestClassifier 更多的 Sigmoid 曲线, 这是经典的最大边距方法 (compare Niculescu-Mizil and Caruana [[4]](#id3)), 其重点是靠近决策边界的 hard samples（支持向量）.
 

docs/master/2.md

@@ -714,7 +714,7 @@ scikit-learn 中实现的 [`TheilSenRegressor`](https://scikit-learn.org/stable/
 
 我们看到，所得的 _polynomial regression_ 与我们上文所述线性模型是同一类（即关于 ![w](img/8a58e8df6a985a3273e39bac7dd72b1f.jpg) 是线性的），因此可以用同样的方法解决。通过用这些基函数建立的高维空间中的线性拟合，该模型具有灵活性，可以适应更广泛的数据范围。
 
-这里是一个例子，使用不同程度的多项式特征将这个想法应用于一维数据:
+这里是一个示例，使用不同程度的多项式特征将这个想法应用于一维数据:
 
 [![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_polynomial_interpolation_0011.png](img/cda529a3abe8af421f1f218b1a390091.jpg)](https://scikit-learn.org/stable/auto_examples/linear_model/plot_polynomial_interpolation.html)
 

docs/master/20.md

@@ -30,7 +30,7 @@
 
 > **示例**:
 >*   一个利用高斯混合模型在鸢尾花卉数据集（IRIS 数据集）上做聚类的协方差实例，请查阅 [GMM covariances](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm_covariances.html#sphx-glr-auto-examples-mixture-plot-gmm-covariances-py)
->*   一个绘制密度估计的例子，请查阅 [Density Estimation for a Gaussian mixture](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm_pdf.html#sphx-glr-auto-examples-mixture-plot-gmm-pdf-py)
+>*   一个绘制密度估计的示例，请查阅 [Density Estimation for a Gaussian mixture](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm_pdf.html#sphx-glr-auto-examples-mixture-plot-gmm-pdf-py)
 
 ### 2.1.1.1. 优缺点 [`GaussianMixture`](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.GaussianMixture.html#sklearn.mixture.GaussianMixture "sklearn.mixture.GaussianMixture")
 
@@ -51,7 +51,7 @@
 [![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_gmm_selection_0011.png](img/8615ac5c8ea1fb8ae6e726f7659a29e9.jpg)](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm_selection.html)
 
 > **示例**:
->*   一个用典型的高斯混合进行的模型选择的例子，请查阅 [Gaussian Mixture Model Selection](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm_selection.html#sphx-glr-auto-examples-mixture-plot-gmm-selection-py)
+>*   一个用典型的高斯混合进行的模型选择的示例，请查阅 [Gaussian Mixture Model Selection](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm_selection.html#sphx-glr-auto-examples-mixture-plot-gmm-selection-py)
 
 ### 2.1.1.3. 估计算法期望最大化（EM）
 
@@ -73,7 +73,7 @@
 
 **[![plot_bgmm](img/d7151d4911c077ded512eba1c6cd2bb0.jpg)](https://scikit-learn.org/stable/auto_examples/mixture/plot_concentration_prior.html) [![plot_dpgmm](img/ed352c0fca166fdaa12d7da93676df50.jpg)](https://scikit-learn.org/stable/auto_examples/mixture/plot_concentration_prior.html)**
 
-下面的例子将具有固定数量分量的高斯混合模型与具有Dirichlet process prior（狄利克雷过程先验）的变分高斯混合模型进行了比较。此处，一个经典高斯混合模型被指定由 5 个分量（其中两个是聚类）在某个数据集上拟合而成。 我们可以看到，具有狄利克雷过程的变分高斯混合模型 在相同的数据上进行拟合时,可以将自身分量数量制在 2 。在该例子中，用户选择了 `n_components=5` ，这与真正的试用数据集（toy dataset）的生成分量数量不符。很容易注意到, 狄利克雷过程先验的变分高斯混合模型可以采取保守的策略，仅拟合生成一个分量。
+下面的示例将具有固定数量分量的高斯混合模型与具有Dirichlet process prior（狄利克雷过程先验）的变分高斯混合模型进行了比较。此处，一个经典高斯混合模型被指定由 5 个分量（其中两个是聚类）在某个数据集上拟合而成。 我们可以看到，具有狄利克雷过程的变分高斯混合模型 在相同的数据上进行拟合时,可以将自身分量数量制在 2 。在该示例中，用户选择了 `n_components=5` ，这与真正的试用数据集（toy dataset）的生成分量数量不符。很容易注意到, 狄利克雷过程先验的变分高斯混合模型可以采取保守的策略，仅拟合生成一个分量。
 
 [![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_gmm_0011.png](img/c009aed89f1926875e5637127af6000c.jpg)](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm.html)
 
@@ -82,9 +82,9 @@
 [![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_gmm_sin_0011.png](img/d2b34f499ce1bbd28a276bc0d7afdde1.jpg)](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm_sin.html)
 
 > **示例**:
-> *   一个用 [`GaussianMixture`](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.GaussianMixture.html#sklearn.mixture.GaussianMixture "sklearn.mixture.GaussianMixture") 和 [`BayesianGaussianMixture`](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.BayesianGaussianMixture.html#sklearn.mixture.BayesianGaussianMixture "sklearn.mixture.BayesianGaussianMixture") 绘制置信椭圆体的例子， 请查阅 [Gaussian Mixture Model Ellipsoids](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm.html#sphx-glr-auto-examples-mixture-plot-gmm-py)
-> *   [Gaussian Mixture Model Sine Curve](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm_sin.html#sphx-glr-auto-examples-mixture-plot-gmm-sin-py) 这个例子展示了用 [`GaussianMixture`](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.GaussianMixture.html#sklearn.mixture.GaussianMixture "sklearn.mixture.GaussianMixture") 和 [`BayesianGaussianMixture`](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.BayesianGaussianMixture.html#sklearn.mixture.BayesianGaussianMixture "sklearn.mixture.BayesianGaussianMixture") 来拟合正弦波。
-> *   一个使用不同的 `weight_concentration_prior_type` 用以不同的 `weight_concentration_prior` 参数值的 *BayesianGaussianMixture* 来绘制置信椭圆体的例子。 请查阅 [Concentration Prior Type Analysis of Variation Bayesian Gaussian Mixture](https://scikit-learn.org/stable/auto_examples/mixture/plot_concentration_prior.html#sphx-glr-auto-examples-mixture-plot-concentration-prior-py)
+> *   一个用 [`GaussianMixture`](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.GaussianMixture.html#sklearn.mixture.GaussianMixture "sklearn.mixture.GaussianMixture") 和 [`BayesianGaussianMixture`](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.BayesianGaussianMixture.html#sklearn.mixture.BayesianGaussianMixture "sklearn.mixture.BayesianGaussianMixture") 绘制置信椭圆体的示例， 请查阅 [Gaussian Mixture Model Ellipsoids](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm.html#sphx-glr-auto-examples-mixture-plot-gmm-py)
+> *   [Gaussian Mixture Model Sine Curve](https://scikit-learn.org/stable/auto_examples/mixture/plot_gmm_sin.html#sphx-glr-auto-examples-mixture-plot-gmm-sin-py) 这个示例展示了用 [`GaussianMixture`](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.GaussianMixture.html#sklearn.mixture.GaussianMixture "sklearn.mixture.GaussianMixture") 和 [`BayesianGaussianMixture`](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.BayesianGaussianMixture.html#sklearn.mixture.BayesianGaussianMixture "sklearn.mixture.BayesianGaussianMixture") 来拟合正弦波。
+> *   一个使用不同的 `weight_concentration_prior_type` 用以不同的 `weight_concentration_prior` 参数值的 *BayesianGaussianMixture* 来绘制置信椭圆体的示例。 请查阅 [Concentration Prior Type Analysis of Variation Bayesian Gaussian Mixture](https://scikit-learn.org/stable/auto_examples/mixture/plot_concentration_prior.html#sphx-glr-auto-examples-mixture-plot-concentration-prior-py)
 
 ### 2.1.2.2. [`BayesianGaussianMixture`](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.BayesianGaussianMixture.html#sklearn.mixture.BayesianGaussianMixture "sklearn.mixture.BayesianGaussianMixture") 下的变分推理的优缺点
 

docs/master/21.md

@@ -41,8 +41,8 @@
 流形学习可以被认为是将线性框架（如 PCA ）推广到对数据中非线性结构敏感的一次尝试。虽然存在监督变量，但是典型的流形学习问题是无监督的：它从数据本身学习数据的高维结构，而不使用预定的分类。
 
 > **示例**:
->*   参见 [Manifold learning on handwritten digits: Locally Linear Embedding, Isomap…](https://scikit-learn.org/stable/auto_examples/manifold/plot_lle_digits.html#sphx-glr-auto-examples-manifold-plot-lle-digits-py) ,手写数字降维的例子。
->*   参见 [Comparison of Manifold Learning methods](https://scikit-learn.org/stable/auto_examples/manifold/plot_compare_methods.html#sphx-glr-auto-examples-manifold-plot-compare-methods-py) ,玩具 “S曲线” 数据集降维的例子。
+>*   参见 [Manifold learning on handwritten digits: Locally Linear Embedding, Isomap…](https://scikit-learn.org/stable/auto_examples/manifold/plot_lle_digits.html#sphx-glr-auto-examples-manifold-plot-lle-digits-py) ,手写数字降维的示例。
+>*   参见 [Comparison of Manifold Learning methods](https://scikit-learn.org/stable/auto_examples/manifold/plot_compare_methods.html#sphx-glr-auto-examples-manifold-plot-compare-methods-py) ,玩具 “S曲线” 数据集降维的示例。
 
 以下概述了 scikit-learn 中可用的流形学习实现
 
@@ -266,7 +266,7 @@ t-SNE 的主要目的是实现高维数据的可视化。因此，当数据将
 
 在此实现的 Barnes-Hut t-SNE 通常比其他流形学习算法慢得多。优化是很困难的，梯度的计算是 ![O[d N log(N)]](img/f60c0101ae8f649bb02ed8b24b30fd83.jpg) ，其中 ![d](img/adf83056bc2bd05628e24c40cb728b3d.jpg) 是输出维数，![N](img/a44a7c045f2217894a894c482861387a.jpg) 是样本个数。Barnes-Hut 方法在 t-SNE 复杂度为 ![O[d N^2]](img/9642d01a97f06869baba6159e3438677.jpg) 的精确方法之上进行了改进，但有其他几个显著区别:
 
-*   Barnes-Hut 仅在目标维度为3或更小时,才有效。构建可视化时，基于2-D的案例是典型的案例。
+*   Barnes-Hut 仅在目标维度为3或更小时,才有效。构建可视化时，基于2-D的示例是典型的示例。
 *   Barnes-Hut 仅适用于密集的输入数据。稀疏数据矩阵只能用精确方法嵌入，或者可以通过密集的低阶投影来近似，例如使用 [`sklearn.decomposition.TruncatedSVD`](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.TruncatedSVD.html#sklearn.decomposition.TruncatedSVD "sklearn.decomposition.TruncatedSVD")
 *   Barnes-Hut 是精确方法的一种近似。这种近似方法使用 angle 作为参数，因此当参数 method=”exact” 时，angle 参数无效。
 *   Barnes-Hut 的拓展性很高。Barnes-Hut 可用于嵌入数十万个数据点，而精确方法只能处理数千个样本，再多就很困难了。

docs/master/22.md

@@ -175,7 +175,7 @@ AP聚类算法主要的缺点是算法的复杂度. AP聚类算法的时间复
 ```py
 similarity = np.exp(-beta * distance / distance.std())
 ```
-请看这样一个应用程序的例子。
+请看这样一个应用程序的示例。
 
 > **示例**:
 >*   [Spectral clustering for image segmentation](https://scikit-learn.org/stable/auto_examples/cluster/plot_segmentation_toy.html#sphx-glr-auto-examples-cluster-plot-segmentation-toy-py): Segmenting objects from a noisy background using spectral clustering.
@@ -236,13 +236,13 @@ Agglomerative cluster 存在 “rich get richer” 现象导致聚类大小不
 
 ### 2.3.6.2. 添加连接约束
 
-[`AgglomerativeClustering`](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.AgglomerativeClustering.html#sklearn.cluster.AgglomerativeClustering "sklearn.cluster.AgglomerativeClustering") 中一个有趣的特点是可以使用连接矩阵(connectivity matrix)将连接约束添加到算法中（只有相邻的聚类可以合并到一起），连接矩阵为每一个样本给定了相邻的样本。 例如，在 swiss-roll 的例子中，连接约束禁止在不相邻的 swiss roll 上合并，从而防止形成在 roll 上重复折叠的聚类。
+[`AgglomerativeClustering`](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.AgglomerativeClustering.html#sklearn.cluster.AgglomerativeClustering "sklearn.cluster.AgglomerativeClustering") 中一个有趣的特点是可以使用连接矩阵(connectivity matrix)将连接约束添加到算法中（只有相邻的聚类可以合并到一起），连接矩阵为每一个样本给定了相邻的样本。 例如，在 swiss-roll 的示例中，连接约束禁止在不相邻的 swiss roll 上合并，从而防止形成在 roll 上重复折叠的聚类。
 
 **[![unstructured](img/63f146cd209ad922f402bf81bfdeb621.jpg)](https://scikit-learn.org/stable/auto_examples/cluster/plot_ward_structured_vs_unstructured.html) [![structured](img/50bc02ed6fb21594c72e30d1a33bbf89.jpg)](https://scikit-learn.org/stable/auto_examples/cluster/plot_ward_structured_vs_unstructured.html)**
 
 这些约束对塑造局部结构是很有用的，而且这也使得算法更快，特别是当样本数量巨大时。
 
-连通性的限制(connectivity constraint)是通过连接矩阵来实现的: scipy sparse matrix 仅仅在行列的交界处有元素存在，而这些行列记录相连接的数据集的索引。这个矩阵可以通过先验信息构建:例如，你可能通过仅仅将从一个连接指向另一个的链接合并页面来聚类页面。也可以从数据中学习到, 例如使用 [sklearn.neighbors.kneighbors_graph](https://www.studyai.cn/modules/generated/sklearn.neighbors.kneighbors_graph.html#sklearn.neighbors.kneighbors_graph) 限制与最近邻的合并， 就像 [这个例子](https://www.studyai.cn/auto_examples/cluster/plot_agglomerative_clustering.html#sphx-glr-auto-examples-cluster-plot-agglomerative-clustering-py) 中那样, 或者使用 [sklearn.feature_extraction.image.grid_to_graph](https://www.studyai.cn/modules/generated/sklearn.feature_extraction.image.grid_to_graph.html#sklearn.feature_extraction.image.grid_to_graph) 仅合并图像上相邻的像素点， 就像 [这个 coin 例子](https://www.studyai.cn/auto_examples/cluster/plot_coin_ward_segmentation.html#sphx-glr-auto-examples-cluster-plot-coin-ward-segmentation-py) 。
+连通性的限制(connectivity constraint)是通过连接矩阵来实现的: scipy sparse matrix 仅仅在行列的交界处有元素存在，而这些行列记录相连接的数据集的索引。这个矩阵可以通过先验信息构建:例如，你可能通过仅仅将从一个连接指向另一个的链接合并页面来聚类页面。也可以从数据中学习到, 例如使用 [sklearn.neighbors.kneighbors_graph](https://www.studyai.cn/modules/generated/sklearn.neighbors.kneighbors_graph.html#sklearn.neighbors.kneighbors_graph) 限制与最近邻的合并， 就像 [这个示例](https://www.studyai.cn/auto_examples/cluster/plot_agglomerative_clustering.html#sphx-glr-auto-examples-cluster-plot-agglomerative-clustering-py) 中那样, 或者使用 [sklearn.feature_extraction.image.grid_to_graph](https://www.studyai.cn/modules/generated/sklearn.feature_extraction.image.grid_to_graph.html#sklearn.feature_extraction.image.grid_to_graph) 仅合并图像上相邻的像素点， 就像 [这个 coin 示例](https://www.studyai.cn/auto_examples/cluster/plot_coin_ward_segmentation.html#sphx-glr-auto-examples-cluster-plot-coin-ward-segmentation-py) 。
 
 > **示例**:
 >*   [A demo of structured Ward hierarchical clustering on a raccoon face image](https://scikit-learn.org/stable/auto_examples/cluster/plot_face_ward_segmentation.html#sphx-glr-auto-examples-cluster-plot-face-ward-segmentation-py): Ward clustering to split the image of a raccoon face in regions.
@@ -784,7 +784,7 @@ Rosenberg 和 Hirschberg 进一步定义 **V-measure** 作为 **同质性和完
 
 ### 2.3.10.5. Silhouette 系数
 
-如果不知道真实簇标签，则必须使用模型本身进行度量。Silhouette 系数 ([`sklearn.metrics.silhouette_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.silhouette_score.html#sklearn.metrics.silhouette_score "sklearn.metrics.silhouette_score")) 是一个这样的评估例子，其中较高的 Silhouette 系数得分和能够更好定义的聚类的模型相关联。Silhouette 系数 是依据每个样本进行定义，由两个得分组成:
+如果不知道真实簇标签，则必须使用模型本身进行度量。Silhouette 系数 ([`sklearn.metrics.silhouette_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.silhouette_score.html#sklearn.metrics.silhouette_score "sklearn.metrics.silhouette_score")) 是一个这样的评估示例，其中较高的 Silhouette 系数得分和能够更好定义的聚类的模型相关联。Silhouette 系数 是依据每个样本进行定义，由两个得分组成:
 
 *   **a**: 样本与同一类别中所有其他点之间的平均距离。
 *   **b**: 样本与 _下一个距离最近的簇_ 中的所有其他点之间的平均距离。
@@ -829,7 +829,7 @@ Rosenberg 和 Hirschberg 进一步定义 **V-measure** 作为 **同质性和完
 *   凸簇的 Silhouette 系数通常比其他类型的簇更高，例如通过 DBSCAN 获得的基于密度的簇。
 
 > **示例**:
->*   [Selecting the number of clusters with silhouette analysis on KMeans clustering](https://scikit-learn.org/stable/auto_examples/cluster/plot_kmeans_silhouette_analysis.html#sphx-glr-auto-examples-cluster-plot-kmeans-silhouette-analysis-py) : 在这个例子中，silhouette 分析用于为 n_clusters 选择最佳值.
+>*   [Selecting the number of clusters with silhouette analysis on KMeans clustering](https://scikit-learn.org/stable/auto_examples/cluster/plot_kmeans_silhouette_analysis.html#sphx-glr-auto-examples-cluster-plot-kmeans-silhouette-analysis-py) : 在这个示例中，silhouette 分析用于为 n_clusters 选择最佳值.
 
 ### 2.3.10.6. Calinski-Harabaz 指数
 

docs/master/23.md

@@ -32,11 +32,11 @@ array([[ 1,  2],
 
 算法在给双向簇分配行列的方式不同, 会导致不同的双向聚类结构。当行和列分成区块时，会出现块对角或者棋盘结构。
 
-如果每一行和每一列仅属于一个双向簇,重新排列数据矩阵的行和列,会使得双向簇出现在对角线上。下面是一个例子，此结构的双向簇具有比其他行列更高的平均值:
+如果每一行和每一列仅属于一个双向簇,重新排列数据矩阵的行和列,会使得双向簇出现在对角线上。下面是一个示例，此结构的双向簇具有比其他行列更高的平均值:
 
 [![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_spectral_coclustering_0031.png](img/9812effbd6ddac1053fd0b63ebe8c2fb.jpg)](https://scikit-learn.org/stable/auto_examples/bicluster/images/sphx_glr_plot_spectral_coclustering_003.png)
 
-在棋盘结构的例子中, 每一行属于所有的列簇, 每一列属于所有的行簇。下面是一个例子，每个双向簇内的值差异较小:
+在棋盘结构的示例中, 每一行属于所有的列簇, 每一列属于所有的行簇。下面是一个示例，每个双向簇内的值差异较小:
 
 [![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_spectral_biclustering_0031.png](img/4e0d8935ff82f26fc3a46a3202bd1fa3.jpg)](https://scikit-learn.org/stable/auto_examples/bicluster/images/sphx_glr_plot_spectral_biclustering_003.png)
 
@@ -81,7 +81,7 @@ array([[ 1,  2],
 
 > **示例**:
 >*   [A demo of the Spectral Co-Clustering algorithm](https://scikit-learn.org/stable/auto_examples/bicluster/plot_spectral_coclustering.html#sphx-glr-auto-examples-bicluster-plot-spectral-coclustering-py): 如何用双向簇产生一个数据矩阵并应用。
->*   [Biclustering documents with the Spectral Co-clustering algorithm](https://scikit-learn.org/stable/auto_examples/bicluster/plot_bicluster_newsgroups.html#sphx-glr-auto-examples-bicluster-plot-bicluster-newsgroups-py):一个在 20 个新闻组数据集中发现双向簇的例子
+>*   [Biclustering documents with the Spectral Co-clustering algorithm](https://scikit-learn.org/stable/auto_examples/bicluster/plot_bicluster_newsgroups.html#sphx-glr-auto-examples-bicluster-plot-bicluster-newsgroups-py):一个在 20 个新闻组数据集中发现双向簇的示例
 
 > **参考资料**:
 >*   Dhillon, Inderjit S, 2001. [Co-clustering documents and words using bipartite spectral graph partitioning](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.140.3011).
@@ -115,7 +115,7 @@ j}} + \overline{L_{\cdot \cdot}}](img/d670eea3215462f64d74d9366622a490.jpg)
 例如，如果已计算得到 ![p](img/e2f9b08680b30cfb80102f69264fdd5c.jpg) 个奇异向量,![q](img/dc074c105944810a277030dfab298376.jpg) 个 最佳得奇异向量可以被找出, 因为![q<p](img/cc9d324e8bc61a67cc1947f73bf5b618.jpg) 。让![U](img/11c00539ec3e5944afd76511830591db.jpg) 为列是 ![q](img/dc074c105944810a277030dfab298376.jpg) 个最佳左奇异向量的矩阵, 并且 ![V](img/5303ecbc70bf5189b8785555c03c54ee.jpg)  是用右奇异向量组成的矩阵. 为了划分行, 将 ![A](img/eeaf066f8cca5064b706ccfc4728323d.jpg) 投影到 ![q](img/dc074c105944810a277030dfab298376.jpg) 维空间: ![A * V](img/99988260d9d836d14b2569c2fc921e81.jpg)。把![m \times q](img/ccc8bedf9424617c5d6a61fbe9a1cc36.jpg) 矩阵的 ![m](img/94156b879a7455cb0d516efa9c9c0991.jpg) 行作为样本, 然后使用 k-means 的聚类处理产生行标签。类似地，将列投影到 ![A^{\top} * U](img/c57acf47ae694e71f55f0005d1e52c55.jpg) ，并且对 ![n \times q](img/cd58ff0ab17f3ead1d5179426f2dae50.jpg) 矩阵进行聚类得到列标签。
 
 > **示例**:
->*   [A demo of the Spectral Biclustering algorithm](https://scikit-learn.org/stable/auto_examples/bicluster/plot_spectral_biclustering.html#sphx-glr-auto-examples-bicluster-plot-spectral-biclustering-py): 一个简单的例子显示如何生成棋盘矩阵和对它进行双向聚类。
+>*   [A demo of the Spectral Biclustering algorithm](https://scikit-learn.org/stable/auto_examples/bicluster/plot_spectral_biclustering.html#sphx-glr-auto-examples-bicluster-plot-spectral-biclustering-py): 一个简单的示例显示如何生成棋盘矩阵和对它进行双向聚类。
 
 > **参考资料**:
 >*   Kluger, Yuval, et. al., 2003. [Spectral biclustering of microarray data: coclustering genes and conditions](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.135.1608).

docs/master/27.md

@@ -12,7 +12,7 @@
 
 ## 2.8.1. 密度估计: 直方图
 
-直方图是一种简单的数据可视化方法，其中定义了组( bins )，并且统计了每个组( bin )中的数据点的数量。在下图的左上角中可以看到一个直方图的例子:
+直方图是一种简单的数据可视化方法，其中定义了组( bins )，并且统计了每个组( bin )中的数据点的数量。在下图的左上角中可以看到一个直方图的示例:
 
 **[![hist_to_kde](img/10a8344b866fca53744b728ef788a668.jpg)](https://scikit-learn.org/stable/auto_examples/neighbors/plot_kde_1d.html)**
 
@@ -20,7 +20,7 @@
 
 直观地说，你也可以把一个直方图看成由一堆块组成，每个点上放一个块. 通过在合适的网格空间中堆积这些块，我们就可以得到直方图。但是，如果不是把这些块堆叠在一个规则的网格上，而是把每个块定位在它所代表的点上，然后把每个位置的总高度相加呢?这样可以得到如上图左下角所示的可视化.它可能不像直方图那样整洁，但是由数据决定块的位置意味着它能更好地表示基本的数据。
 
-这个可视化是核密度估计的一个例子，该例中用的是一种顶帽核(top-hat kernel)（即每个点上放一个方块）。我们可以通过使用一种更平滑的核来得到一个更平滑的分布。上图右下角展示了一个高斯核密度估计，其中每个点都给总的分布贡献一条高斯曲线。结果是从数据中得到了一个平滑的密度估计，并且可作为一个强大的非参数的点分布模型。
+这个可视化是核密度估计的一个示例，该例中用的是一种顶帽核(top-hat kernel)（即每个点上放一个方块）。我们可以通过使用一种更平滑的核来得到一个更平滑的分布。上图右下角展示了一个高斯核密度估计，其中每个点都给总的分布贡献一条高斯曲线。结果是从数据中得到了一个平滑的密度估计，并且可作为一个强大的非参数的点分布模型。
 
 ## 2.8.2. 核密度估计
 

docs/master/30.md

@@ -61,7 +61,7 @@ _k_-折交叉验证得出的性能指标是循环计算中每个值的平均值
 
 使用交叉验证最简单的方法是在估计器和数据集上调用 [`cross_val_score`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_val_score.html#sklearn.model_selection.cross_val_score "sklearn.model_selection.cross_val_score") 辅助函数。
 
-下面的例子展示了如何通过分割数据，拟合模型和计算连续 5 次的分数（每次不同分割）来估计 linear kernel 支持向量机在 iris 数据集上的精度:
+下面的示例展示了如何通过分割数据，拟合模型和计算连续 5 次的分数（每次不同分割）来估计 linear kernel 支持向量机在 iris 数据集上的精度:
 
 ```py
 >>> from sklearn.model_selection import cross_val_score
@@ -189,7 +189,7 @@ array([0.96..., 1.  ..., 0.96..., 0.96..., 1.        ])
 array([0.97..., 0.97..., 0.99..., 0.98..., 0.98...])
 ```
 
-这里是一个使用单一指标的 `cross_validate` 的例子:
+这里是一个使用单一指标的 `cross_validate` 的示例:
 
 ```py
 >>> scores = cross_validate(clf, iris.data, iris.target,
@@ -239,7 +239,7 @@ array([0.97..., 0.97..., 0.99..., 0.98..., 0.98...])
 
 [`KFold`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html#sklearn.model_selection.KFold "sklearn.model_selection.KFold") 将所有的样例划分为 ![k](img/f93871977da52a6d11045d57c3e18728.jpg) 个组，称为折叠 (fold) （如果 ![k = n](img/2953c3498ec0877c5ebcc172050cce88.jpg)， 这等价于 _Leave One Out（留一）_ 策略），都具有相同的大小（如果可能）。预测函数学习时使用 ![k - 1](img/79b52c5c00ce59ba04383f6a0d670c6d.jpg) 个折叠中的数据，最后一个剩下的折叠会用于测试。
 
-在 4 个样例的数据集上使用 2-fold 交叉验证的例子:
+在 4 个样例的数据集上使用 2-fold 交叉验证的示例:
 
 ```py
 >>> import numpy as np
@@ -253,7 +253,7 @@ array([0.97..., 0.97..., 0.99..., 0.98..., 0.98...])
 [0 1] [2 3]
 
 ```
-这个例子是关于交叉验证的可视化的。请注意KFold不被分类所影响．
+这个示例是关于交叉验证的可视化的。请注意KFold不被分类所影响．
 ![sphx_glr_plot_cv_indices_0041.png](img/sphx_glr_plot_cv_indices_0041.png)
 
 每个折叠由两个 arrays 组成，第一个作为 _training set_ ，另一个作为 _test set_ 。 由此，可以通过使用 numpy 的索引创建训练/测试集合:
@@ -327,7 +327,7 @@ LOO 潜在的用户选择模型应该权衡一些已知的警告。 当与 ![k](
 
 [`LeavePOut`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.LeavePOut.html#sklearn.model_selection.LeavePOut "sklearn.model_selection.LeavePOut") 与 [`LeaveOneOut`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.LeaveOneOut.html#sklearn.model_selection.LeaveOneOut "sklearn.model_selection.LeaveOneOut") 非常相似，因为它通过从整个集合中删除 ![p](img/e2f9b08680b30cfb80102f69264fdd5c.jpg) 个样本来创建所有可能的 训练/测试集。对于 ![n](img/c87d9110f3d32ffa5fa08671e4af11fb.jpg) 个样本，这产生了 ![{n \choose p}](img/c683d0fa5d21d783e383612dda8ecad3.jpg) 个 训练-测试 对。与 [`LeaveOneOut`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.LeaveOneOut.html#sklearn.model_selection.LeaveOneOut "sklearn.model_selection.LeaveOneOut") 和 [`KFold`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html#sklearn.model_selection.KFold "sklearn.model_selection.KFold") 不同，当 ![p > 1](img/aaa84c285eb96ed446fd34be4b51bbec.jpg) 时，测试集会重叠。
 
-在有 4 个样例的数据集上使用 Leave-2-Out 的例子:
+在有 4 个样例的数据集上使用 Leave-2-Out 的示例:
 
 ```py
 >>> from sklearn.model_selection import LeavePOut
@@ -353,7 +353,7 @@ LOO 潜在的用户选择模型应该权衡一些已知的警告。 当与 ![k](
 
 可以通过设定明确的 `random_state` ，使得伪随机生成器的结果可以重复。
 
-这是一个使用的小例子:
+这是一个使用的小示例:
 
 ```py
 >>> from sklearn.model_selection import ShuffleSplit
@@ -382,7 +382,7 @@ LOO 潜在的用户选择模型应该权衡一些已知的警告。 当与 ![k](
 
 [`StratifiedKFold`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.StratifiedKFold.html#sklearn.model_selection.StratifiedKFold "sklearn.model_selection.StratifiedKFold") 是 _k-fold_ 的变种，会返回 _stratified（分层）_ 的折叠：每个小集合中， 各个类别的样例比例大致和完整数据集中相同。
 
-在有 10 个样例的，有两个略不均衡类别的数据集上进行分层 3-fold 交叉验证的例子:
+在有 10 个样例的，有两个略不均衡类别的数据集上进行分层 3-fold 交叉验证的示例:
 
 ```py
 >>> from sklearn.model_selection import StratifiedKFold
@@ -413,7 +413,7 @@ LOO 潜在的用户选择模型应该权衡一些已知的警告。 当与 ![k](
 
 如果潜在的生成过程产生依赖样本的 groups ，那么 i.i.d. 假设将会被打破。
 
-这样的数据分组是特定于域的。一个例子是从多个患者收集医学数据，从每个患者身上采集多个样本。而这样的数据很可能取决于个人群体。 在我们的例子中，每个样本的患者 ID 将是其 group identifier （组标识符）。
+这样的数据分组是特定于域的。一个示例是从多个患者收集医学数据，从每个患者身上采集多个样本。而这样的数据很可能取决于个人群体。 在我们的示例中，每个样本的患者 ID 将是其 group identifier （组标识符）。
 
 在这种情况下，我们想知道在一组特定的 groups 上训练的模型是否能很好地适用于看不见的 group 。为了衡量这一点，我们需要确保验证对象中的所有样本来自配对训练折叠中完全没有表示的组。
 

docs/master/31.md

@@ -5,7 +5,7 @@
 翻译者:
         [@\S^R^Y/](https://github.com/apachecn/scikit-learn-doc-zh)
 
-超参数，即不直接在估计器内学习的参数。在 scikit-learn 包中，它们作为估计器类中构造函数的参数进行传递。典型的例子有：用于支持向量分类器的 `C` 、`kernel` 和 `gamma` ，用于Lasso的 `alpha` 等。
+超参数，即不直接在估计器内学习的参数。在 scikit-learn 包中，它们作为估计器类中构造函数的参数进行传递。典型的示例有：用于支持向量分类器的 `C` 、`kernel` 和 `gamma` ，用于Lasso的 `alpha` 等。
 
 搜索超参数空间以便获得最好 [交叉验证](https://scikit-learn.org/stable//modules/cross_validation.html#cross-validation) 分数的方法是可能的而且是值得提倡的。
 

docs/master/32.md

@@ -60,7 +60,7 @@ Model selection （模型选择）和 evaluation （评估）使用工具，例
 | ‘neg_median_absolute_error’ | [`metrics.median_absolute_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.median_absolute_error.html#sklearn.metrics.median_absolute_error "sklearn.metrics.median_absolute_error") |   |
 | ‘r2’ | [`metrics.r2_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html#sklearn.metrics.r2_score "sklearn.metrics.r2_score") |   |
 
-使用案例:
+使用示例:
 
 ```py
 >>> from sklearn import svm, datasets
@@ -105,7 +105,7 @@ ValueError: 'wrong_choice' is not a valid scoring value. Valid options are ['acc
 
 第二个用例是使用 [`make_scorer`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html#sklearn.metrics.make_scorer "sklearn.metrics.make_scorer") 从简单的 python 函数构建一个完全 custom scorer object （自定义的记分对象），可以使用几个参数 :
 
-*   你要使用的 python 函数（在下面的例子中是 `my_custom_loss_func`）
+*   你要使用的 python 函数（在下面的示例中是 `my_custom_loss_func`）
 *   python 函数是否返回一个分数 (`greater_is_better=True`, 默认值) 或者一个 loss （损失） (`greater_is_better=False`)。 如果是一个 loss （损失），scorer object （记分对象）的 python 函数的输出被 negated （否定），符合 cross validation convention （交叉验证约定），scorers 为更好的模型返回更高的值。
 *   仅用于 classification metrics （分类指数）: 您提供的 python 函数是否需要连续的 continuous decision certainties （判断确定性）（`needs_threshold=True`）。默认值为 False 。
 *   任何其他参数，如 `beta` 或者 `labels` 在 函数 [`f1_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html#sklearn.metrics.f1_score "sklearn.metrics.f1_score") 。
@@ -145,7 +145,7 @@ ValueError: 'wrong_choice' is not a valid scoring value. Valid options are ['acc
 >
 >虽然在调用函数的旁边定义自定义计分函数应该使用默认的joblib后端(loky)，但是从另一个模块导入它将是一种更健壮的方法，并且独立于joblib后端。
 >
->例如，在下面的例子中，要使用大于1的`n_jobs`,`custom_scoring_function`函数保存在用户创建的模块中(custom_scorer_module.py)并导入:
+>例如，在下面的示例中，要使用大于1的`n_jobs`,`custom_scoring_function`函数保存在用户创建的模块中(custom_scorer_module.py)并导入:
   ```py
   >>> from custom_scorer_module import custom_scoring_function
   >>> cross_val_score(model,
@@ -206,14 +206,14 @@ Scikit-learn 还允许在 `GridSearchCV`, `RandomizedSearchCV` 和 `cross_valida
 
 [`sklearn.metrics`](classes.html#module-sklearn.metrics "sklearn.metrics") 模块实现了几个 loss, score, 和 utility 函数来衡量 classification （分类）性能。 某些 metrics （指标）可能需要 positive class （正类），confidence values（置信度值）或 binary decisions values （二进制决策值）的概率估计。 大多数的实现允许每个样本通过 `sample_weight` 参数为 overall score （总分）提供 weighted contribution （加权贡献）。
 
-其中一些仅限于二分类案例:
+其中一些仅限于二分类示例:
 
 |调用|功能|
 |---|---|
 | [`precision_recall_curve`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve "sklearn.metrics.precision_recall_curve")(y_true, probas_pred) | Compute precision-recall pairs for different probability thresholds |
 | [`roc_curve`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html#sklearn.metrics.roc_curve "sklearn.metrics.roc_curve")(y_true, y_score[, pos_label, …]) | Compute Receiver operating characteristic (ROC) |
 
-其他也可以在多分类案例中运行:
+其他也可以在多分类示例中运行:
 
 |调用|功能|
 |---|---|
@@ -222,7 +222,7 @@ Scikit-learn 还允许在 `GridSearchCV`, `RandomizedSearchCV` 和 `cross_valida
 | [`hinge_loss`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.hinge_loss.html#sklearn.metrics.hinge_loss "sklearn.metrics.hinge_loss")(y_true, pred_decision[, labels, …]) | Average hinge loss (non-regularized) |
 | [`matthews_corrcoef`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html#sklearn.metrics.matthews_corrcoef "sklearn.metrics.matthews_corrcoef")(y_true, y_pred[, …]) | Compute the Matthews correlation coefficient (MCC) |
 
-有些还可以在 multilabel case （多重案例）中工作:
+有些还可以在 multilabel case （多重示例）中工作:
 
 |调用|功能|
 |---|---|
@@ -393,7 +393,7 @@ array([[2, 0, 0],
 
 ### 3.3.2.6. 分类报告
 
-[`classification_report`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html#sklearn.metrics.classification_report "sklearn.metrics.classification_report") 函数构建一个显示 main classification metrics （主分类指标）的文本报告。这是一个小例子，其中包含自定义的 `target_names` 和 inferred labels （推断标签）:
+[`classification_report`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html#sklearn.metrics.classification_report "sklearn.metrics.classification_report") 函数构建一个显示 main classification metrics （主分类指标）的文本报告。这是一个小示例，其中包含自定义的 `target_names` 和 inferred labels （推断标签）:
 
 ```py
 >>> from sklearn.metrics import classification_report
@@ -507,7 +507,7 @@ weighted avg       0.67      0.60      0.59         5
 
 ![F_\beta = (1 + \beta^2) \frac{\text{precision} \times \text{recall}}{\beta^2 \text{precision} + \text{recall}}.](img/b3edbb24837112f795a22e3574457416.jpg)
 
-以下是 binary classification （二分类）中的一些小例子:
+以下是 binary classification （二分类）中的一些小示例:
 
 ```py
 >>> from sklearn import metrics
@@ -630,7 +630,7 @@ Similarly, labels not present in the data sample may be accounted for in macro-a
 0.6666...
 ```
 
-在具有二分类标签指示符的多标签案例中：
+在具有二分类标签指示符的多标签示例中：
 ```py
 >>> jaccard_score(y_true, y_pred, average='samples')  
 0.5833...
@@ -667,7 +667,7 @@ array([1. , 0. , 0.33...])
 
 ![L_\text{Hinge}(y_w, y_t) = \max\left\{1 + y_t - y_w, 0\right\}](img/6569ca3d831148970ddb4c7dfc3f2572.jpg)
 
-这里是一个小例子，演示了在 binary class （二类）问题中使用了具有 svm classifier （svm 的分类器）的 [`hinge_loss`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.hinge_loss.html#sklearn.metrics.hinge_loss "sklearn.metrics.hinge_loss") 函数:
+这里是一个小示例，演示了在 binary class （二类）问题中使用了具有 svm classifier （svm 的分类器）的 [`hinge_loss`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.hinge_loss.html#sklearn.metrics.hinge_loss "sklearn.metrics.hinge_loss") 函数:
 
 ```py
 >>> from sklearn import svm
@@ -715,7 +715,7 @@ Log loss，又被称为 logistic regression loss（logistic 回归损失）或
 
 ![L_{\log}(y, p) = -\log \operatorname{Pr}(y|p) = -(y \log (p) + (1 - y) \log (1 - p))](img/7d1cd85c2f165c7bde33eccf4be29e75.jpg)
 
-这扩展到 multiclass case （多类案例）如下。 让一组样本的真实标签被编码为 1-of-K binary indicator matrix ![Y](img/966bd0680e0e71a4df98abab98818724.jpg), 即 如果样本 ![i](img/43e13b580daefe5ba754b790dfbd216c.jpg) 具有取自一组 ![K](img/e279b8169ddd6581c5606c868ba52fae.jpg) 个标签的标签 ![k](img/f93871977da52a6d11045d57c3e18728.jpg) ，则 ![y_{i,k} = 1](img/7947f721109ac76f1366b72715d3e7e3.jpg) 。令 ![P](img/4bfe956324cef23278c5192b0fb8029b.jpg) 为 matrix of probability estimates （概率估计矩阵）， ![p_{i,k} = \operatorname{Pr}(t_{i,k} = 1)](img/418f3dbcb32031257a948ec23d05e53e.jpg) 。那么整套的 log loss 就是
+这扩展到 multiclass case （多类示例）如下。 让一组样本的真实标签被编码为 1-of-K binary indicator matrix ![Y](img/966bd0680e0e71a4df98abab98818724.jpg), 即 如果样本 ![i](img/43e13b580daefe5ba754b790dfbd216c.jpg) 具有取自一组 ![K](img/e279b8169ddd6581c5606c868ba52fae.jpg) 个标签的标签 ![k](img/f93871977da52a6d11045d57c3e18728.jpg) ，则 ![y_{i,k} = 1](img/7947f721109ac76f1366b72715d3e7e3.jpg) 。令 ![P](img/4bfe956324cef23278c5192b0fb8029b.jpg) 为 matrix of probability estimates （概率估计矩阵）， ![p_{i,k} = \operatorname{Pr}(t_{i,k} = 1)](img/418f3dbcb32031257a948ec23d05e53e.jpg) 。那么整套的 log loss 就是
 
 ![L_{\log}(Y, P) = -\log \operatorname{Pr}(Y|P) = - \frac{1}{N} \sum_{i=0}^{N-1} \sum_{k=0}^{K-1} y_{i,k} \log p_{i,k}](img/5fc2f399717cfe5187dc09896972a850.jpg)
 
@@ -759,7 +759,7 @@ Log loss，又被称为 logistic regression loss（logistic 回归损失）或
 
 当有两个以上的标签时， MCC 的值将不再在 -1 和 +1 之间。相反，根据已经标注的真实数据的数量和分布情况，最小值将介于 -1 和 0 之间。最大值始终为 +1 。
 
-这是一个小例子，说明了使用 [`matthews_corrcoef`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html#sklearn.metrics.matthews_corrcoef "sklearn.metrics.matthews_corrcoef") 函数:
+这是一个小示例，说明了使用 [`matthews_corrcoef`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html#sklearn.metrics.matthews_corrcoef "sklearn.metrics.matthews_corrcoef") 函数:
 
 ```py
 >>> from sklearn.metrics import matthews_corrcoef
@@ -859,7 +859,7 @@ array([0. , 0.5, 1. ])
 
 > “A receiver operating characteristic (ROC), 或者简单的 ROC 曲线，是一个图形图，说明了 binary classifier （二分分类器）系统的性能，因为 discrimination threshold （鉴别阈值）是变化的。它是通过在不同的阈值设置下，从 true positives out of the positives (TPR = true positive 比例) 与 false positives out of the negatives (FPR = false positive 比例) 绘制 true positive 的比例来创建的。 TPR 也称为 sensitivity（灵敏度），FPR 是减去 specificity（特异性） 或 true negative 比例。”
 
-该函数需要真正的 binar value （二分值）和 target scores（目标分数），这可以是 positive class 的 probability estimates （概率估计），confidence values（置信度值）或 binary decisions（二分决策）。 这是一个如何使用 [`roc_curve`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html#sklearn.metrics.roc_curve "sklearn.metrics.roc_curve") 函数的小例子:
+该函数需要真正的 binar value （二分值）和 target scores（目标分数），这可以是 positive class 的 probability estimates （概率估计），confidence values（置信度值）或 binary decisions（二分决策）。 这是一个如何使用 [`roc_curve`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html#sklearn.metrics.roc_curve "sklearn.metrics.roc_curve") 函数的小示例:
 
 ```py
 >>> import numpy as np
@@ -955,7 +955,7 @@ Brier 分数损失也在0到1之间，分数越低（均方差越小），预测
 
 其中: ![N](img/a44a7c045f2217894a894c482861387a.jpg) 是预测的总数， ![f_t](img/9b5fb6c6e0f320a3e8e0ba606d601c98.jpg) 是实际结果 ![o_t](img/09eb9862841b1c17d77e2e4830df3770.jpg) 的预测概率。
 
-这是一个使用这个函数的小例子:
+这是一个使用这个函数的小示例:
 
 ```py
 >>> import numpy as np
@@ -1002,7 +1002,7 @@ Brier 分数损失也在0到1之间，分数越低（均方差越小），预测
 
 与 ![\text{rank}_{ij} = \left|\left\{k: \hat{f}_{ik} \geq \hat{f}_{ij} \right\}\right|](img/5eea9f6c78020e75b9cc37d038d297ab.jpg) 。给定等级定义，通过给出将被分配给所有绑定值的最大等级， `y_scores` 中的关系会被破坏。
 
-这是一个使用这个函数的小例子:
+这是一个使用这个函数的小示例:
 
 ```py
 >>> import numpy as np
@@ -1028,7 +1028,7 @@ Brier 分数损失也在0到1之间，分数越低（均方差越小），预测
 
 与 ![\mathcal{L}_{ij} = \left\{k: y_{ik} = 1, \hat{f}_{ik} \geq \hat{f}_{ij} \right\}](img/f6ce0899ba52f1169500b726ee9c8a92.jpg)， ![\text{rank}_{ij} = \left|\left\{k: \hat{f}_{ik} \geq \hat{f}_{ij} \right\}\right|](img/5eea9f6c78020e75b9cc37d038d297ab.jpg) 和 ![|\cdot|](img/f7dd5b16c1d8c3e278e9a1fa7f49dcd2.jpg) 是集合的 l0 范数或基数。
 
-这是一个使用这个函数的小例子:
+这是一个使用这个函数的小示例:
 
 ```py
 >>> import numpy as np
@@ -1054,7 +1054,7 @@ Brier 分数损失也在0到1之间，分数越低（均方差越小），预测
 
 其中 ![|\cdot|](img/f7dd5b16c1d8c3e278e9a1fa7f49dcd2.jpg) 是 ![\ell_0](img/abee3460000f8532d0df4e1b1d1928e8.jpg) 范数或集合的基数。
 
-这是一个使用这个函数的小例子:
+这是一个使用这个函数的小示例:
 
 ```py
 >>> import numpy as np
@@ -1091,7 +1091,7 @@ Brier 分数损失也在0到1之间，分数越低（均方差越小），预测
 
 最好的得分是 1.0, 值越低越差.
 
-下面是一下有关 [`explained_variance_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.explained_variance_score.html#sklearn.metrics.explained_variance_score "sklearn.metrics.explained_variance_score") 函数使用的一些例子:
+下面是一下有关 [`explained_variance_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.explained_variance_score.html#sklearn.metrics.explained_variance_score "sklearn.metrics.explained_variance_score") 函数使用的一些示例:
 
 ```py
 >>> from sklearn.metrics import explained_variance_score
@@ -1115,7 +1115,7 @@ array([ 0.967...,  1.        ])
 如果 ![\hat{y}_i](img/07794b8fa83c7e18c5d1fb175fd7d7bd.jpg) 是 ![i](img/43e13b580daefe5ba754b790dfbd216c.jpg)-th 样本的预测值, 并且 ![y_i](img/4a22ca544916918b2358e5fc7c71b8e6.jpg) 是对应的真实值，则将最大误差定义为
 ![\text{Max Error}(y, \hat{y}) = max(| y_i - \hat{y}_i |)](img/score008.png)
 
-以下是`max_error`函数的一个例子：
+以下是`max_error`函数的一个示例：
 ```py
 >>> from sklearn.metrics import max_error
 >>> y_true = [3, 2, 7, 1]
@@ -1133,7 +1133,7 @@ array([ 0.967...,  1.        ])
 
 ![\text{MAE}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \left| y_i - \hat{y}_i \right|.](img/7d379816608eb84009d45f0e26772256.jpg)
 
-下面是一个有关 [`mean_absolute_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_absolute_error.html#sklearn.metrics.mean_absolute_error "sklearn.metrics.mean_absolute_error") 函数用法的小例子:
+下面是一个有关 [`mean_absolute_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_absolute_error.html#sklearn.metrics.mean_absolute_error "sklearn.metrics.mean_absolute_error") 函数用法的小示例:
 
 ```py
 >>> from sklearn.metrics import mean_absolute_error
@@ -1161,7 +1161,7 @@ array([ 0.5,  1. ])
 
 ![\text{MSE}(y, \hat{y}) = \frac{1}{n_\text{samples}} \sum_{i=0}^{n_\text{samples} - 1} (y_i - \hat{y}_i)^2.](img/ba3c1f82d7a66df41015761326619e26.jpg)
 
-下面是一个有关 [`mean_squared_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html#sklearn.metrics.mean_squared_error "sklearn.metrics.mean_squared_error") 函数用法的小例子:
+下面是一个有关 [`mean_squared_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html#sklearn.metrics.mean_squared_error "sklearn.metrics.mean_squared_error") 函数用法的小示例:
 
 ```py
 >>> from sklearn.metrics import mean_squared_error
@@ -1177,7 +1177,7 @@ array([ 0.5,  1. ])
 ```
 
 > **示例**
->*   点击 [Gradient Boosting regression](https://scikit-learn.org/stable/auto_examples/ensemble/plot_gradient_boosting_regression.html#sphx-glr-auto-examples-ensemble-plot-gradient-boosting-regression-py) 查看均方误差用于梯度上升（gradient boosting）回归的使用例子。
+>*   点击 [Gradient Boosting regression](https://scikit-learn.org/stable/auto_examples/ensemble/plot_gradient_boosting_regression.html#sphx-glr-auto-examples-ensemble-plot-gradient-boosting-regression-py) 查看均方误差用于梯度上升（gradient boosting）回归的使用示例。
 
 ### 3.3.4.5. 均方误差对数
 
@@ -1189,7 +1189,7 @@ array([ 0.5,  1. ])
 
 其中 ![\log_e (x)](img/001d34ad977d110ce0931112c362d07e.jpg) 表示 ![x](img/5c82dbae35dc43d2f556f9f284d9d184.jpg) 的自然对数. 当目标具有指数增长的趋势时, 该指标最适合使用, 例如人口数量, 跨年度商品的平均销售额等. 请注意, 该指标会对低于预测的估计值进行估计.
 
-下面是一个有关 [`mean_squared_log_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_log_error.html#sklearn.metrics.mean_squared_log_error "sklearn.metrics.mean_squared_log_error") 函数用法的小例子:
+下面是一个有关 [`mean_squared_log_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_log_error.html#sklearn.metrics.mean_squared_log_error "sklearn.metrics.mean_squared_log_error") 函数用法的小示例:
 
 ```py
 >>> from sklearn.metrics import mean_squared_log_error
@@ -1213,7 +1213,7 @@ array([ 0.5,  1. ])
 
 该 [`median_absolute_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.median_absolute_error.html#sklearn.metrics.median_absolute_error "sklearn.metrics.median_absolute_error") 函数不支持多输出.
 
-下面是一个有关 [`median_absolute_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.median_absolute_error.html#sklearn.metrics.median_absolute_error "sklearn.metrics.median_absolute_error") 函数用法的小例子:
+下面是一个有关 [`median_absolute_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.median_absolute_error.html#sklearn.metrics.median_absolute_error "sklearn.metrics.median_absolute_error") 函数用法的小示例:
 
 ```py
 >>> from sklearn.metrics import median_absolute_error
@@ -1234,7 +1234,7 @@ array([ 0.5,  1. ])
 
 其中 ![\bar{y} =  \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}} - 1} y_i](img/7a95e7e32309847d96c207051da29ea9.jpg).
 
-下面是一个有关 [`r2_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html#sklearn.metrics.r2_score "sklearn.metrics.r2_score") 函数用法的小例子:
+下面是一个有关 [`r2_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html#sklearn.metrics.r2_score "sklearn.metrics.r2_score") 函数用法的小示例:
 
 ```py
 >>> from sklearn.metrics import r2_score

docs/master/34.md

@@ -63,7 +63,7 @@ array([[0.90..., 0.84..., 0.94..., 0.96..., 0.93...],
 
 ## 3.5.2. 学习曲线
 
-学习曲线显示了对于不同数量的训练样本的估计器的验证和训练评分。它可以帮助我们发现从增加更多的训 练数据中能获益多少，以及估计是否受到更多来自方差误差或偏差误差的影响。如果在增加训练集大小时，验证分数和训练 分数都收敛到一个很低的值，那么我们将不会从更多的训练数据中获益。在下面的图中看到一个例子：朴素贝叶斯大致收敛到一个较低的分数。
+学习曲线显示了对于不同数量的训练样本的估计器的验证和训练评分。它可以帮助我们发现从增加更多的训 练数据中能获益多少，以及估计是否受到更多来自方差误差或偏差误差的影响。如果在增加训练集大小时，验证分数和训练 分数都收敛到一个很低的值，那么我们将不会从更多的训练数据中获益。在下面的图中看到一个示例：朴素贝叶斯大致收敛到一个较低的分数。
 
 [![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_learning_curve_0011.png](img/a70da26e29baa95b2f65f3cbc2e5fbfa.jpg)](https://scikit-learn.org/stable/auto_examples/model_selection/plot_learning_curve.html)
 

docs/master/36.md

@@ -17,7 +17,7 @@
 
 具有两个目标特征的PDP显示了这两个特征之间的相互作用。例如，上图中的双变量PDP显示了房价中值与房屋年龄和每户平均居住者的联合值之间的关系。我们可以清楚地看到这两个特征之间的相互作用:对于平均入住率大于2的情况，房价几乎与房屋的年龄无关，而对于数值小于2的情况，则与年龄有很强的依赖关系。
 
-[`sklearn.inspection`](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.inspection)提供了一个方便的函数[`plot_partial_dependency`](https://scikit-learn.org/stable/modules/generated/sklearn.inspection.plot_partial_dependence.html#sklearn.inspection.plot_partial_dependence)来创建单向和双向PDP。在下面的例子中，我们展示了如何创建一个局部依赖图的网格:两个用于特征0和1的单向PDP，以及两个特征之间的双向PDP:
+[`sklearn.inspection`](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.inspection)提供了一个方便的函数[`plot_partial_dependency`](https://scikit-learn.org/stable/modules/generated/sklearn.inspection.plot_partial_dependence.html#sklearn.inspection.plot_partial_dependence)来创建单向和双向PDP。在下面的示例中，我们展示了如何创建一个局部依赖图的网格:两个用于特征0和1的单向PDP，以及两个特征之间的双向PDP:
 ```py
 >>> from sklearn.datasets import make_hastie_10_2
 >>> from sklearn.ensemble import GradientBoostingClassifier

docs/master/38.md

@@ -132,7 +132,7 @@ PCA(copy=True, ...)
 
 ### 5.1.1.3. 缓存转换器：避免重复计算
 
-适配转换器是很耗费计算资源的。设置了``memory`` 参数， [`Pipeline`](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html#sklearn.pipeline.Pipeline "sklearn.pipeline.Pipeline") 将会在调用``fit``方法后缓存每个转换器。 如果参数和输入数据相同，这个特征用于避免重复计算适配的转换器。典型的例子是网格搜索转换器，该转化器只要适配一次就可以多次使用。
+适配转换器是很耗费计算资源的。设置了``memory`` 参数， [`Pipeline`](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html#sklearn.pipeline.Pipeline "sklearn.pipeline.Pipeline") 将会在调用``fit``方法后缓存每个转换器。 如果参数和输入数据相同，这个特征用于避免重复计算适配的转换器。典型的示例是网格搜索转换器，该转化器只要适配一次就可以多次使用。
 
 `memory` 参数用于缓存转换器。`memory` 可以是包含要缓存的转换器的目录的字符串或一个 [joblib.Memory](https://pythonhosted.org/joblib/memory.html) 对象:
 
@@ -172,7 +172,7 @@ Pipeline(...,
   >>> print(pca1.components_)
       [[-1.77484909e-19  ... 4.07058917e-18]]
 ```
->开启缓存会在适配前触发转换器的克隆。因此，管道的转换器实例不能被直接查看。 在下面例子中， 访问 `PCA` 实例 `pca2` 将会引发 `AttributeError` 因为 `pca2` 是一个未适配的转换器。 这时应该使用属性 `named_steps` 来检查管道的评估器:
+>开启缓存会在适配前触发转换器的克隆。因此，管道的转换器实例不能被直接查看。 在下面示例中， 访问 `PCA` 实例 `pca2` 将会引发 `AttributeError` 因为 `pca2` 是一个未适配的转换器。 这时应该使用属性 `named_steps` 来检查管道的评估器:
 >
 ```py
   >>> cachedir = mkdtemp()
@@ -257,7 +257,7 @@ R2 score: -4.50
 >**注意**
 >可以通过设置transformer或函数对func和inverse_func来触发转换。但是，同时设置这两个选项会产生错误。
 
->**例子**
+>**示例**
 >* [Effect of transforming the targets in regression model](https://scikit-learn.org/stable/auto_examples/compose/plot_transformed_target.html#sphx-glr-auto-examples-compose-plot-transformed-target-py)
 
 ## 5.1.3. FeatureUnion（特征联合）: 复合特征空间
@@ -357,7 +357,7 @@ array([[1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0],
        [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
        [0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1]]...)
 ```
-在上面的例子中，`CountVectorizer`希望接受一维数组作为输入，因此列被指定为字符串(`'title'`)。然而,`preprocessing.OneHotEncoder`就像大多数其他转换器一样，期望2D数据，因此在这种情况下，您需要将列指定为字符串列表(`['city']`)。
+在上面的示例中，`CountVectorizer`希望接受一维数组作为输入，因此列被指定为字符串(`'title'`)。然而,`preprocessing.OneHotEncoder`就像大多数其他转换器一样，期望2D数据，因此在这种情况下，您需要将列指定为字符串列表(`['city']`)。
 
 除了标量或单个项列表外，列选择可以指定为多个项、整数数组、片或布尔掩码的列表。如果输入是DataFrame，则字符串可以引用列，整数总是解释为位置列。
 
@@ -390,7 +390,7 @@ array([[1. , 0.5],
        [0.5, 0.5],
        [1. , 0. ]])
 ```
-函数 [`make_column_transformer`](https://scikit-learn.org/stable/modules/generated/sklearn.compose.make_column_transformer.html#sklearn.compose.make_column_transformer)可用来更简单的创建类对象 [`ColumnTransformer`](https://scikit-learn.org/stable/modules/generated/sklearn.compose.ColumnTransformer.html#sklearn.compose.ColumnTransformer) 。 特别的，名字将会被自动给出。上面的例子等价于
+函数 [`make_column_transformer`](https://scikit-learn.org/stable/modules/generated/sklearn.compose.make_column_transformer.html#sklearn.compose.make_column_transformer)可用来更简单的创建类对象 [`ColumnTransformer`](https://scikit-learn.org/stable/modules/generated/sklearn.compose.ColumnTransformer.html#sklearn.compose.ColumnTransformer) 。 特别的，名字将会被自动给出。上面的示例等价于
 ```py
 >>> from sklearn.compose import make_column_transformer
 >>> column_trans = make_column_transformer(

docs/master/39.md

@@ -18,7 +18,7 @@
 
 类 [`DictVectorizer`](https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.DictVectorizer.html#sklearn.feature_extraction.DictVectorizer "sklearn.feature_extraction.DictVectorizer") 实现了 “one-of-K” 或 “one-hot” 编码，用于分类（也称为标称，离散）特征。分类功能是 “属性值” 对，其中该值被限制为不排序的可能性的离散列表（例如主题标识符，对象类型，标签，名称…）。
 
-在下面的例子，”城市” 是一个分类属性，而 “温度” 是传统的数字特征:
+在下面的示例，”城市” 是一个分类属性，而 “温度” 是传统的数字特征:
 
 ```py
 >>> measurements = [
@@ -505,7 +505,7 @@ array([[1, 1, 1, 0, 1, 1, 1, 0],
 
 ```
 
-在上面的例子中，使用 `'char_wb` 分析器’，它只能从字边界内的字符（每侧填充空格）创建 n-grams。 `'char'` 分析器可以创建跨越单词的 n-grams:
+在上面的示例中，使用 `'char_wb` 分析器’，它只能从字边界内的字符（每侧填充空格）创建 n-grams。 `'char'` 分析器可以创建跨越单词的 n-grams:
 
 ```py
 >>> ngram_vectorizer = CountVectorizer(analyzer='char_wb', ngram_range=(5, 5))
@@ -631,7 +631,7 @@ True
   >>> vect = CountVectorizer(tokenizer=LemmaTokenizer())  
   ```
   （请注意，这不会过滤标点符号。）
-  例如，以下例子将英国的一些拼写变成美国拼写::
+  例如，以下示例将英国的一些拼写变成美国拼写::
   ```py
   >>> import re
   >>> def to_british(tokens):
@@ -650,7 +650,7 @@ True
   >>> print(CustomVectorizer().build_analyzer()(u"color colour"))
   [...'color', ...'color']
   ```
-  用于其他样式的预处理; 例子包括 stemming, lemmatization, 或 normalizing numerical tokens, 后者说明如下:
+  用于其他样式的预处理; 示例包括 stemming, lemmatization, 或 normalizing numerical tokens, 后者说明如下:
     * [Biclustering documents with the Spectral Co-clustering algorithm
 ](https://scikit-learn.org/stable/auto_examples/bicluster/plot_bicluster_newsgroups.html#sphx-glr-auto-examples-bicluster-plot-bicluster-newsgroups-py)
 

docs/master/40.md

@@ -80,7 +80,7 @@ array([[-2.44...,  1.22..., -0.26...]])
 
 使用这种缩放的目的包括实现特征极小方差的鲁棒性以及在稀疏矩阵中保留零元素。
 
-以下是一个将简单的数据矩阵缩放到``[0, 1]``的例子:
+以下是一个将简单的数据矩阵缩放到``[0, 1]``的示例:
 
 ```py
 >>> X_train = np.array([[ 1., -1.,  2.],
@@ -126,9 +126,9 @@ X_scaled = X_std * (max - min) + min
 
 ```
 
-类 [`MaxAbsScaler`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MaxAbsScaler.html#sklearn.preprocessing.MaxAbsScaler "sklearn.preprocessing.MaxAbsScaler") 的工作原理非常相似，但是它只通过除以每个特征的最大值将训练数据特征缩放至 `[-1, 1]` 范围内，这就意味着，训练数据应该是已经零中心化或者是稀疏数据。 例子::用先前例子的数据实现最大绝对值缩放操作。
+类 [`MaxAbsScaler`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MaxAbsScaler.html#sklearn.preprocessing.MaxAbsScaler "sklearn.preprocessing.MaxAbsScaler") 的工作原理非常相似，但是它只通过除以每个特征的最大值将训练数据特征缩放至 `[-1, 1]` 范围内，这就意味着，训练数据应该是已经零中心化或者是稀疏数据。 示例::用先前示例的数据实现最大绝对值缩放操作。
 
-以下是使用上例中数据运用这个缩放器的例子:
+以下是使用上例中数据运用这个缩放器的示例:
 
 ```py
 >>> X_train = np.array([[ 1., -1.,  2.],
@@ -247,7 +247,7 @@ Box-Cox transform:
 
 ![\begin{split}x_i^{(\lambda)} =\begin{cases}\dfrac{x_i^\lambda - 1}{\lambda} & \text{if } \lambda \neq 0, \\[8pt]\ln{(x_i)} & \text{if } \lambda = 0,\end{cases}\end{split}](img/preprocessing002.png)
 
-Box-Cox只能应用于严格的正数据。在这两种方法中，变换都是参数化的，通过极大似然估计来确定。下面是一个使用Box-Cox将样本从对数正态分布映射到正态分布的例子:
+Box-Cox只能应用于严格的正数据。在这两种方法中，变换都是参数化的，通过极大似然估计来确定。下面是一个使用Box-Cox将样本从对数正态分布映射到正态分布的示例:
 
 ```py
 >>> pt = preprocessing.PowerTransformer(method='box-cox', standardize=False)
@@ -261,9 +261,9 @@ array([[ 0.49...,  0.17..., -0.15...],
        [-0.05...,  0.58..., -0.57...],
        [ 0.69..., -0.84...,  0.10...]])
 ```
-上述例子设置了参数`standardize`的选项为 False 。 但是，默认情况下，类[PowerTransformer](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PowerTransformer.html#sklearn.preprocessing.PowerTransformer)将会应用`zero-mean`,`unit-variance normalization`到变换出的输出上。
+上述示例设置了参数`standardize`的选项为 False 。 但是，默认情况下，类[PowerTransformer](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PowerTransformer.html#sklearn.preprocessing.PowerTransformer)将会应用`zero-mean`,`unit-variance normalization`到变换出的输出上。
 
-下面的例子中 将 Box-Cox 和 Yeo-Johnson 应用到各种不同的概率分布上。 请注意 当把这些方法用到某个分布上的时候， 幂变换得到的分布非常像高斯分布。但是对其他的一些分布，结果却不太有效。这更加强调了在幂变换前后对数据进行可视化的重要性。
+下面的示例中 将 Box-Cox 和 Yeo-Johnson 应用到各种不同的概率分布上。 请注意 当把这些方法用到某个分布上的时候， 幂变换得到的分布非常像高斯分布。但是对其他的一些分布，结果却不太有效。这更加强调了在幂变换前后对数据进行可视化的重要性。
 
 [![sphx_glr_plot_map_data_to_normal_0011.png](img/sphx_glr_plot_map_data_to_normal_0011.png)](https://scikit-learn.org/stable/auto_examples/preprocessing/plot_map_data_to_normal.html)
 
@@ -334,7 +334,7 @@ array([[-0.70...,  0.70...,  0.  ...]])
 >对于稀疏输入，在被提交给高效Cython例程前，数据被 **转化为压缩的稀疏行形式** (参见 `scipy.sparse.csr_matrix` )。为了避免不必要的内存复制，推荐在上游选择CSR表示。
 
 ## 5.3.4 类别特征编码
-在机器学习中，特征经常不是连续的数值型的而是标称型的(categorical)。举个例子，一个人的样本具有特征`["male", "female"]`, `["from Europe", "from US", "from Asia"]`, `["uses Firefox", "uses Chrome", "uses Safari", "uses Internet Explorer"]` 等。 这些特征能够被有效地编码成整数，比如 `["male", "from US", "uses Internet Explorer"]` 可以被表示为 `[0, 1, 3]`,`["female", "from Asia", "uses Chrome"]` 表示为 `[1, 2, 1]` 。
+在机器学习中，特征经常不是连续的数值型的而是标称型的(categorical)。举个示例，一个人的样本具有特征`["male", "female"]`, `["from Europe", "from US", "from Asia"]`, `["uses Firefox", "uses Chrome", "uses Safari", "uses Internet Explorer"]` 等。 这些特征能够被有效地编码成整数，比如 `["male", "from US", "uses Internet Explorer"]` 可以被表示为 `[0, 1, 3]`,`["female", "from Asia", "uses Chrome"]` 表示为 `[1, 2, 1]` 。
 
 要把标称型特征(categorical features) 转换为这样的整数编码(integer codes), 我们可以使用 [OrdinalEncoder](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OrdinalEncoder.html#sklearn.preprocessing.OrdinalEncoder) 。 这个估计器把每一个categorical feature变换成 一个新的整数数字特征 (0 到 n_categories - 1):
 ```py
@@ -349,7 +349,7 @@ array([[0., 1., 1.]])
 
 另外一种将标称型特征转换为能够被scikit-learn中模型使用的编码是one-of-K， 又称为 独热码或dummy encoding。 这种编码类型已经在类[OneHotEncoder](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html#sklearn.preprocessing.OneHotEncoder)中实现。该类把每一个具有n_categories个可能取值的categorical特征变换为长度为n_categories的二进制特征向量，里面只有一个地方是1，其余位置都是0。
 
-继续我们上面的例子:
+继续我们上面的示例:
 ```py
 >>>
 >>> enc = preprocessing.OneHotEncoder()
@@ -427,7 +427,7 @@ One-hot 编码的离散化特征 可以使得一个模型更加的有表现力(e
 ...               [  6., 3., 11 ]])
 >>> est = preprocessing.KBinsDiscretizer(n_bins=[3, 2, 2], encode='ordinal').fit(X)
 ```
-默认情况下，输出是被 one-hot 编码到一个稀疏矩阵。(请看[类别特征编码](#534-类别特征编码))。 而且可以使用参数`encode`进行配置。对每一个特征， bin的边界以及总数目在 `fit`过程中被计算出来，它们将用来定义区间。 因此，对现在的例子，这些区间间隔被定义如下:
+默认情况下，输出是被 one-hot 编码到一个稀疏矩阵。(请看[类别特征编码](#534-类别特征编码))。 而且可以使用参数`encode`进行配置。对每一个特征， bin的边界以及总数目在 `fit`过程中被计算出来，它们将用来定义区间。 因此，对现在的示例，这些区间间隔被定义如下:
 - 特征 1:`[-∞,-1],[-1,2),[2,∞)`
 - 特征 2:`[-∞,5),[5,∞)`
 - 特征 3:`[-∞,14],[14,∞)`
@@ -452,7 +452,7 @@ array([[ 0., 1., 1.],
 
 ### 5.3.5.2 特征二值化
 
-**特征二值化** 是 **将数值特征用阈值过滤得到布尔值** 的过程。这对于下游的概率型模型是有用的，它们假设输入数据是多值 [伯努利分布(Bernoulli distribution)](https://en.wikipedia.org/wiki/Bernoulli_distribution) 。例如这个例子 [`sklearn.neural_network.BernoulliRBM`](https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.BernoulliRBM.html#sklearn.neural_network.BernoulliRBM "sklearn.neural_network.BernoulliRBM") 。
+**特征二值化** 是 **将数值特征用阈值过滤得到布尔值** 的过程。这对于下游的概率型模型是有用的，它们假设输入数据是多值 [伯努利分布(Bernoulli distribution)](https://en.wikipedia.org/wiki/Bernoulli_distribution) 。例如这个示例 [`sklearn.neural_network.BernoulliRBM`](https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.BernoulliRBM.html#sklearn.neural_network.BernoulliRBM "sklearn.neural_network.BernoulliRBM") 。
 
 即使归一化计数(又名术语频率)和TF-IDF值特征在实践中表现稍好一些，文本处理团队也常常使用二值化特征值(这可能会简化概率估计)。
 
@@ -556,4 +556,4 @@ array([[0.        , 0.69314718],
 ```
 通过设置`check_reverse`=True并在转换之前调用`fit`，可以确保`func`和`inverse_func`是彼此的拟过程。请注意，请注意一个`warning`会被抛出，并且可以使用`filterwarnings`将其转为一个`error`
 
-使用一个 [`FunctionTransformer`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.FunctionTransformer.html#sklearn.preprocessing.FunctionTransformer "sklearn.preprocessing.FunctionTransformer") 类来做定制化特征选择的例子，请见 [Using FunctionTransformer to select columns](https://scikit-learn.org/stable/auto_examples/preprocessing/plot_function_transformer.html#sphx-glr-auto-examples-preprocessing-plot-function-transformer-py) 。
+使用一个 [`FunctionTransformer`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.FunctionTransformer.html#sklearn.preprocessing.FunctionTransformer "sklearn.preprocessing.FunctionTransformer") 类来做定制化特征选择的示例，请见 [Using FunctionTransformer to select columns](https://scikit-learn.org/stable/auto_examples/preprocessing/plot_function_transformer.html#sphx-glr-auto-examples-preprocessing-plot-function-transformer-py) 。

docs/master/41.md

@@ -89,7 +89,7 @@ IterativeImputer(add_indicator=False, estimator=None,
  [ 6. 12.]
  [ 3.  6.]]
 ```
-[`SimpleImputer`](https://scikit-learn.org/stable/modules/generated/sklearn.impute.SimpleImputer.html#sklearn.impute.SimpleImputer)和[IterativeImputer](https://scikit-learn.org/stable/modules/generated/sklearn.impute.IterativeImputer.html#sklearn.impute.IterativeImputer)都可以用来在管道中构建支持计算的复合估计器。在构建估算器之前，请参阅[一个估算缺失值的例子](https://scikit-learn.org/stable/auto_examples/impute/plot_missing_values.html#sphx-glr-auto-examples-impute-plot-missing-values-py)。
+[`SimpleImputer`](https://scikit-learn.org/stable/modules/generated/sklearn.impute.SimpleImputer.html#sklearn.impute.SimpleImputer)和[IterativeImputer](https://scikit-learn.org/stable/modules/generated/sklearn.impute.IterativeImputer.html#sklearn.impute.IterativeImputer)都可以用来在管道中构建支持计算的复合估计器。在构建估算器之前，请参阅[一个估算缺失值的示例](https://scikit-learn.org/stable/auto_examples/impute/plot_missing_values.html#sphx-glr-auto-examples-impute-plot-missing-values-py)。
 
 ### 5.4.3.1 多变量插补的灵活性
 在R数据科学生态系统中，有许多成熟的估算包:Amelia, mi, mice, missForest等。misforest是一种很流行的算法，它是不同序列计算算法的一个特殊实例，这些算法都可以使用[IterativeImputer](https://scikit-learn.org/stable/modules/generated/sklearn.impute.IterativeImputer.html#sklearn.impute.IterativeImputer)来实现，通过传递不同的回归函数来预测缺失的特征值。在misforest的情况下，这个回归因子是一个随机森林。请参见[Imputing missing values with variants of IterativeImputer](https://scikit-learn.org/stable/auto_examples/impute/plot_iterative_imputer_variants_comparison#imputing-missing-values-with-variants-of-iterativeimputer)

docs/master/45.md

@@ -10,7 +10,7 @@ The [`sklearn.metrics.pairwise`](classes.html#module-sklearn.metrics.pairwise "s
 
 本模块同时包含距离度量和核函数，对于这两者这里提供一个简短的总结。
 
-距离度量是形如 `d(a, b)` 例如 `d(a, b) < d(a, c)` 如果对象 `a` 和 `b` 被认为 “更加相似” 相比于 `a` 和 `c`. 两个完全相同的目标的距离是零。最广泛使用的例子就是欧几里得距离。 为了保证是 ‘真实的’ 度量, 其必须满足以下条件:
+距离度量是形如 `d(a, b)` 例如 `d(a, b) < d(a, c)` 如果对象 `a` 和 `b` 被认为 “更加相似” 相比于 `a` 和 `c`. 两个完全相同的目标的距离是零。最广泛使用的示例就是欧几里得距离。 为了保证是 ‘真实的’ 度量, 其必须满足以下条件:
 
 > 1.  对于所有的 a 和 b，d(a, b) >= 0
 > 2.  正定性：当且仅当 a = b时，d(a, b) == 0

docs/master/48.md

@@ -25,7 +25,7 @@
 
 #### 7.1.1.2. 提取特征
 
-2. 可以是 scikit-learn 支持的的不同 *特征提取 <feature_extraction>* 方法中的任何相关的方法。然而，当处理那些需要矢量化并且特征或值的集合你预先不知道的时候，就得明确注意了。一个好的例子是文本分类，其中在训练的期间你很可能会发现未知的项。从应用的角度上来看，如果在数据上进行多次通过是合理的，则可以使用有状态的向量化器。否则，可以通过使用无状态特征提取器来提高难度。目前，这样做的首选方法是使用所谓的 [哈希技巧](feature_extraction.html#feature-hashing)，在 [`sklearn.feature_extraction.FeatureHasher`](https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.FeatureHasher.html#sklearn.feature_extraction.FeatureHasher "sklearn.feature_extraction.FeatureHasher") 中，其中有分类变量的表示为 Python 列表或 [`sklearn.feature_extraction.text.HashingVectorizer`](https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.HashingVectorizer.html#sklearn.feature_extraction.text.HashingVectorizer "sklearn.feature_extraction.text.HashingVectorizer") 文本文档。
+2. 可以是 scikit-learn 支持的的不同 *特征提取 <feature_extraction>* 方法中的任何相关的方法。然而，当处理那些需要矢量化并且特征或值的集合你预先不知道的时候，就得明确注意了。一个好的示例是文本分类，其中在训练的期间你很可能会发现未知的项。从应用的角度上来看，如果在数据上进行多次通过是合理的，则可以使用有状态的向量化器。否则，可以通过使用无状态特征提取器来提高难度。目前，这样做的首选方法是使用所谓的 [哈希技巧](feature_extraction.html#feature-hashing)，在 [`sklearn.feature_extraction.FeatureHasher`](https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.FeatureHasher.html#sklearn.feature_extraction.FeatureHasher "sklearn.feature_extraction.FeatureHasher") 中，其中有分类变量的表示为 Python 列表或 [`sklearn.feature_extraction.text.HashingVectorizer`](https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.HashingVectorizer.html#sklearn.feature_extraction.text.HashingVectorizer "sklearn.feature_extraction.text.HashingVectorizer") 文本文档。
 
 #### 7.1.1.3. 增量学习
 
@@ -60,13 +60,13 @@
 
 对于分类，有一点要注意的是，虽然无状态特征提取程序可能能够应对新的/未知的属性，但增量学习者本身可能无法应对新的/未知的目标类。在这种情况下，你必须使用 `classes=` 参数将所有可能的类传递给第一个 `partial_fit` 调用。
 
-选择合适的算法时要考虑的另一个方面是，所有这些算法随着时间的推移不会给每个样例相同的重要性。比如说， `Perceptron` 仍然对错误标签的例子是敏感的，即使经过多次的样例训练，而 `SGD*` 和 `PassiveAggressive*` 族对这些鲁棒性更好。相反，对于后面传入的数据流,算法的学习速率随着时间不断降低,后面两个算法对于那些显著差异的样本和标注正确的样本倾向于给予很少的重视。
+选择合适的算法时要考虑的另一个方面是，所有这些算法随着时间的推移不会给每个样例相同的重要性。比如说， `Perceptron` 仍然对错误标签的示例是敏感的，即使经过多次的样例训练，而 `SGD*` 和 `PassiveAggressive*` 族对这些鲁棒性更好。相反，对于后面传入的数据流,算法的学习速率随着时间不断降低,后面两个算法对于那些显著差异的样本和标注正确的样本倾向于给予很少的重视。
 
 #### 7.1.1.4. 示例
 
 最后，我们有一个完整的 [Out-of-core classification of text documents](https://scikit-learn.org/stable/auto_examples/applications/plot_out_of_core_classification.html#sphx-glr-auto-examples-applications-plot-out-of-core-classification-py) 文本文档的核心分类的示例。旨在为想要构建核心学习系统的人们提供一个起点，并展示上述大多数概念。
 
-此外，它还展现了不同算法性能随着处理例子的数量的演变。
+此外，它还展现了不同算法性能随着处理示例的数量的演变。
 
 **[![accuracy_over_time](img/dc40e3a6d4022bfb488e0a4283b656b9.jpg)](https://scikit-learn.org/stable/auto_examples/applications/plot_out_of_core_classification.html)**
 
@@ -117,7 +117,7 @@ performance optimization （性能优化）的一个重要方面也是它可能
 
 **[![bulk_prediction_latency](img/45c6e9fedc8fe61dd8d3f388a0464d30.jpg)](https://scikit-learn.org/stable/auto_examples/applications/plot_prediction_latency.html)**
 
-为了对您的案例的不同的 estimators 进行基准测试，您可以在此示例中简单地更改 `n_features` 参数: [Prediction Latency](https://scikit-learn.org/stable/auto_examples/applications/plot_prediction_latency.html#sphx-glr-auto-examples-applications-plot-prediction-latency-py). 这应该给你估计 prediction latency （预测延迟）的数量级。
+为了对您的示例的不同的 estimators 进行基准测试，您可以在此示例中简单地更改 `n_features` 参数: [Prediction Latency](https://scikit-learn.org/stable/auto_examples/applications/plot_prediction_latency.html#sphx-glr-auto-examples-applications-plot-prediction-latency-py). 这应该给你估计 prediction latency （预测延迟）的数量级。
 
 #### 7.2.1.2. 配置 Scikit-learn 来减少验证开销
 
@@ -163,7 +163,7 @@ print("input sparsity ratio:", sparsity_ratio(X))
 
 对于 [`sklearn.linear_model`](classes.html#module-sklearn.linear_model "sklearn.linear_model") (例如 Lasso, ElasticNet, SGDClassifier/Regressor, Ridge & RidgeClassifier, PassiveAgressiveClassifier/Regressor, LinearSVC, LogisticRegression…) 在预测时间应用的 decision function （决策函数）是一样的（dot product（ 点积）），所以 latency （延迟）应该是等效的。
 
-这里有一个例子使用 `sklearn.linear_model.stochastic_gradient.SGDClassifier` 和 `elasticnet` penalty（惩罚）。 regularization strength（正则化强度）由 `alpha` 参数全局控制。有一个足够高的 `alpha` ，可以增加 `elasticnet` 的 `l1_ratio` 参数，以在模型参数中执行各种稀疏程度。这里的 Higher sparsity （较高稀疏度）被解释为 less model complexity （较少的模型复杂度），因为我们需要较少的系数充分描述它。当然， sparsity （稀疏性）会随着稀疏点积 产生时间大致与非零系数的数目成比例地影响 prediction time （预测时间）。
+这里有一个示例使用 `sklearn.linear_model.stochastic_gradient.SGDClassifier` 和 `elasticnet` penalty（惩罚）。 regularization strength（正则化强度）由 `alpha` 参数全局控制。有一个足够高的 `alpha` ，可以增加 `elasticnet` 的 `l1_ratio` 参数，以在模型参数中执行各种稀疏程度。这里的 Higher sparsity （较高稀疏度）被解释为 less model complexity （较少的模型复杂度），因为我们需要较少的系数充分描述它。当然， sparsity （稀疏性）会随着稀疏点积 产生时间大致与非零系数的数目成比例地影响 prediction time （预测时间）。
 
 [![en_model_complexity](img/fde3a2898bfc0ce1823058fe7b706b9e.jpg)](https://scikit-learn.org/stable/auto_examples/applications/plot_model_complexity_influence.html)
 
@@ -228,7 +228,7 @@ Optimized(优化的) BLAS / LAPACK 实现包括:
 >>> with sklearn.config_context(working_memory=128):
 ...     pass  # do chunked work here
 ```
-遵循此设置的块操作的一个例子是metric.pairwise_distances_chunked，用于计算成对距离矩阵的行压缩。
+遵循此设置的块操作的一个示例是metric.pairwise_distances_chunked，用于计算成对距离矩阵的行压缩。
 
 #### 7.2.3.3. 模型压缩
 
@@ -243,7 +243,7 @@ clf.predict(X_test)
 
 ```
 
-在这个例子中，我们更喜欢 `elasticnet` penalty（惩罚），因为它通常是 model compactness（模型紧凑性）和 prediction power （预测能力）之间的一个很好的妥协。还可以进一步调整 `l1_ratio` 参数（结合正则化强度 `alpha` ）来控制这个权衡。
+在这个示例中，我们更喜欢 `elasticnet` penalty（惩罚），因为它通常是 model compactness（模型紧凑性）和 prediction power （预测能力）之间的一个很好的妥协。还可以进一步调整 `l1_ratio` 参数（结合正则化强度 `alpha` ）来控制这个权衡。
 
 对于 synthetic data （合成数据），典型的 [benchmark](https://github.com/scikit-learn/scikit-learn/blob/master/benchmarks/bench_sparsify.py) 在模型和输入时都会降低 30% 的延迟。稀疏（分别为 0.000024 和 0.027400 非零系数比）。您的里程可能会因您的数据和模型的稀疏性和大小而有所不同。 因此，为了减少部署在生产服务器上的预测模型的内存使用，扩展可能非常有用。
 

docs/master/5.md

@@ -123,7 +123,7 @@ LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
 
 `dual_coef_` 的形状是 `[n_class-1, n_SV]`, 这个结构有些难以理解. 对应于支持向量的列与 `n_class * (n_class - 1) / 2` “one-vs-one” 分类器相关. 每一个支持向量用于 `n_class - 1` 分类器中.对于这些分类器,每一行的 `n_class - 1` 条目对应于对偶系数(dual coefficients).
 
-通过这个例子更容易说明:
+通过这个示例更容易说明:
 
 考虑一个三类的问题,类0有三个支持向量 ![v^{0}_0, v^{1}_0, v^{2}_0](img/0992b23a98660c7b2102695e74407be2.jpg) 而类 1 和 2 分别有 如下两个支持向量 ![v^{0}_1, v^{1}_1](img/60337a9162822d71dc32e68952b4e02a.jpg) and ![v^{0}_2, v^{1}_2](img/5c0b2807058791d6069327b709fae60c.jpg).对于每个支持 向量 ![v^{j}_i](img/ed6a1db8527fda759b14943c1b36d88e.jpg), 有两个对偶系数.在类别 ![i](img/43e13b580daefe5ba754b790dfbd216c.jpg) 和 ![k](img/f93871977da52a6d11045d57c3e18728.jpg) ![\alpha^{j}_{i,k}](img/6f0cdccb5dc60bae6e7a303075ddbdf6.jpg) 中, 我们将支持向量的系数记录为 ![v^{j}_i](img/ed6a1db8527fda759b14943c1b36d88e.jpg) 那么 `dual_coef_` 可以表示为:
 
@@ -221,7 +221,7 @@ array([ 1.5])
 
     当C值较大时，[`LinearSVC`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html#sklearn.svm.LinearSVC)和[`LinearSVR`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVR.html#sklearn.svm.LinearSVR)对C值较不敏感，即当C值大于特定阈值后，模型效果将会停止提升。同时，较大的C值将会导致较长的训练时间，Fan et al.(2008)的论文显示，训练时间的差距有时会达到10倍。
      
-*   支持向量机算法本身不能够很好地支持非标准化的数据，所以 **我们强烈建议您将数据标准化**。 举个例子，对于输入向量 X， 规整它的每个数值范围为 [0, 1] 或 [-1, +1] ，或者标准化它的为均值为0方差为1的数据分布。请注意， 相同的缩放标准必须要应用到所有的测试向量，从而获得有意义的结果。 请参考章节 [预处理数据](preprocessing.html#preprocessing) ，那里会提供到更多关于缩放和规整。
+*   支持向量机算法本身不能够很好地支持非标准化的数据，所以 **我们强烈建议您将数据标准化**。 举个示例，对于输入向量 X， 规整它的每个数值范围为 [0, 1] 或 [-1, +1] ，或者标准化它的为均值为0方差为1的数据分布。请注意， 相同的缩放标准必须要应用到所有的测试向量，从而获得有意义的结果。 请参考章节 [预处理数据](preprocessing.html#preprocessing) ，那里会提供到更多关于缩放和规整。
 *   在 [`NuSVC`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.NuSVC.html#sklearn.svm.NuSVC)/[`OneClassSVM`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.OneClassSVM.html#sklearn.svm.OneClassSVM)/[`NuSVR`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.NuSVR.html#sklearn.svm.NuSVR) 内的参数 `nu` ， 近似是训练误差和支持向量的比值。
 *   在 [`SVC`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC), ，如果分类器的数据不均衡（例如，很多正例很少负例），设置 `class_weight='balanced'` 与/或尝试不同的惩罚系数 `C` 。
 * **底层实现的随机性**:[`SVC`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC)和[`NuSVC`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.NuSVC.html#sklearn.svm.NuSVC)的底层实现仅使用随机数生成器来打乱数据顺序进行概率估计(当`probability`被设置为True时)。这种随机性可以用`random_state`参数来控制。如果将`probability`设为False，这些估计器就不是随机的，random_state对结果没有影响。底层的[`OneClassSVM`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.OneClassSVM.html#sklearn.svm.OneClassSVM)实现类似于[`SVC`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC)和[`NuSVC`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.NuSVC.html#sklearn.svm.NuSVC)的实现。由于[`OneClassSVM`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.OneClassSVM.html#sklearn.svm.OneClassSVM)没有提供概率估计，所以它不是随机的。
@@ -268,7 +268,7 @@ array([ 1.5])
 
 您的内核必须要以两个矩阵作为参数，大小分别是 `(n_samples_1, n_features)`, `(n_samples_2, n_features)` 和返回一个内核矩阵，shape 是 `(n_samples_1, n_samples_2)`.
 
-以下代码定义一个线性核，和构造一个使用该内核的分类器例子:
+以下代码定义一个线性核，和构造一个使用该内核的分类器示例:
 
 ```py
 >>> import numpy as np
@@ -347,7 +347,7 @@ array([0, 1])
 
 >注意:
 >
->虽然这些SVM模型是从 [libsvm](http://www.csie.ntu.edu.tw/~cjlin/libsvm/) 和 [liblinear](http://www.csie.ntu.edu.tw/~cjlin/liblinear/) 中派生出来，使用了 `C` 作为调整参数，但是大多数的 攻击使用了 `alpha`。两个模型的正则化量之间的精确等价，取决于模型优化的准确目标函数。举 个例子，当使用的估计器是 `sklearn.linear_model.Ridge` 做回归时，他们之间的相关性是 ![C = \frac{1}{alpha}](img/c74889dd434ec9a5f4e1b57a549263e7.jpg)。
+>虽然这些SVM模型是从 [libsvm](http://www.csie.ntu.edu.tw/~cjlin/libsvm/) 和 [liblinear](http://www.csie.ntu.edu.tw/~cjlin/liblinear/) 中派生出来，使用了 `C` 作为调整参数，但是大多数的 攻击使用了 `alpha`。两个模型的正则化量之间的精确等价，取决于模型优化的准确目标函数。举 个示例，当使用的估计器是 `sklearn.linear_model.Ridge` 做回归时，他们之间的相关性是 ![C = \frac{1}{alpha}](img/c74889dd434ec9a5f4e1b57a549263e7.jpg)。
 
 这些参数能通过成员 `dual_coef_`、 `support_vectors_` 、 `intercept_` 去访问，这些成员分别控制了输出 ![y_i \alpha_i](img/bf9baf4863bf6d025348b7d91c888066.jpg)、支持向量和无关项 ![\rho](img/b91e4507d9fd7068b02f689d697f8714.jpg) ：
 

docs/master/51.md

@@ -12,7 +12,7 @@
 
 **内容提要**
 
-在本节中，我们介绍一些在使用 scikit-learn 过程中用到的 [机器学习](https://en.wikipedia.org/wiki/Machine_learning) 词汇，并且给出一些例子阐释它们。
+在本节中，我们介绍一些在使用 scikit-learn 过程中用到的 [机器学习](https://en.wikipedia.org/wiki/Machine_learning) 词汇，并且给出一些示例阐释它们。
 
 ## 机器学习：问题设置
 
@@ -22,9 +22,9 @@
 
 *   [监督学习](https://en.wikipedia.org/wiki/Supervised_learning) , 其中数据带有一个附加属性，即我们想要预测的结果值（ [点击此处](https://scikit-learn.org/stable/supervised_learning.html#supervised-learning) 转到 scikit-learn 监督学习页面）。这个问题可以是:
 
-*   [分类](https://en.wikipedia.org/wiki/Classification_in_machine_learning) : 样本属于两个或更多个类，我们想从已经标记的数据中学习如何预测未标记数据的类别。 分类问题的一个例子是手写数字识别，其目的是将每个输入向量分配给有限数目的离散类别之一。 我们通常把分类视作监督学习的一个离散形式（区别于连续形式），从有限的类别中，给每个样本贴上正确的标签。
+*   [分类](https://en.wikipedia.org/wiki/Classification_in_machine_learning) : 样本属于两个或更多个类，我们想从已经标记的数据中学习如何预测未标记数据的类别。 分类问题的一个示例是手写数字识别，其目的是将每个输入向量分配给有限数目的离散类别之一。 我们通常把分类视作监督学习的一个离散形式（区别于连续形式），从有限的类别中，给每个样本贴上正确的标签。
 
-*   [回归](https://en.wikipedia.org/wiki/Regression_analysis) : 如果期望的输出由一个或多个连续变量组成，则该任务称为 _回归_ 。 回归问题的一个例子是预测鲑鱼的长度是其年龄和体重的函数。
+*   [回归](https://en.wikipedia.org/wiki/Regression_analysis) : 如果期望的输出由一个或多个连续变量组成，则该任务称为 _回归_ 。 回归问题的一个示例是预测鲑鱼的长度是其年龄和体重的函数。
 
 *   [无监督学习](https://en.wikipedia.org/wiki/Unsupervised_learning), 其中训练数据由没有任何相应目标值的一组输入向量x组成。这种问题的目标可能是在数据中发现彼此类似的示例所聚成的组，这种问题称为 [聚类](https://en.wikipedia.org/wiki/Cluster_analysis) , 或者，确定输入空间内的数据分布，称为 [密度估计](https://en.wikipedia.org/wiki/Density_estimation) ，又或从高维数据投影数据空间缩小到二维或三维以进行 _可视化_ （[点击此处](https://scikit-learn.org/stable/unsupervised_learning.html#unsupervised-learning) 转到 scikit-learn 无监督学习页面）。
 
@@ -96,7 +96,7 @@ array([0, 1, 2, ..., 8, 9, 8])
 
 在 scikit-learn 中，分类的估计器是一个 Python 对象，它实现了 `fit(X, y)` 和 `predict(T)` 等方法。
 
-估计器的一个例子类 `sklearn.svm.SVC` ，实现了 [支持向量分类](https://en.wikipedia.org/wiki/Support_vector_machine) 。 估计器的构造函数以相应模型的参数为参数，但目前我们将把估计器视为黑箱即可:
+估计器的一个示例类 `sklearn.svm.SVC` ，实现了 [支持向量分类](https://en.wikipedia.org/wiki/Support_vector_machine) 。 估计器的构造函数以相应模型的参数为参数，但目前我们将把估计器视为黑箱即可:
 
 ```py
 >>> from sklearn import svm
@@ -106,7 +106,7 @@ array([0, 1, 2, ..., 8, 9, 8])
 
 > **选择模型的参数**
 >
->在这个例子中，我们手动设置 `gamma` 值。不过，通过使用 [网格搜索](31#321-网格追踪法穷尽的网格搜索) 及 [交叉验证](30#31-交叉验证：评估估算器的表现) 等工具，可以自动找到参数的良好值。
+>在这个示例中，我们手动设置 `gamma` 值。不过，通过使用 [网格搜索](31#321-网格追踪法穷尽的网格搜索) 及 [交叉验证](30#31-交叉验证：评估估算器的表现) 等工具，可以自动找到参数的良好值。
 
 我们把我们的估计器实例命名为 `clf` ，因为它是一个分类器（classifier）。它现在必须拟合模型，也就是说，它必须从模型中 _learn（学习）_ 。 这是通过将我们的训练集传递给 `fit` 方法来完成的。作为一个训练集，让我们使用数据集中除最后一张以外的所有图像。 我们用 `[:-1]` Python 语法选择这个训练集，它产生一个包含 `digits.data` 中除最后一个条目（entry）之外的所有条目的新数组
 
@@ -133,7 +133,7 @@ array([8])
 
 正如你所看到的，这是一项具有挑战性的任务：图像分辨率差。你是否认同这个分类？
 
-这个分类问题的一个完整例子可以作为一个例子来运行和学习： 识别手写数字。 [Recognizing hand-written digits](https://scikit-learn.org/stable/auto_examples/classification/plot_digits_classification.html#sphx-glr-auto-examples-classification-plot-digits-classification-py).
+这个分类问题的一个完整示例可以作为一个示例来运行和学习： 识别手写数字。 [Recognizing hand-written digits](https://scikit-learn.org/stable/auto_examples/classification/plot_digits_classification.html#sphx-glr-auto-examples-classification-plot-digits-classification-py).
 
 ## 模型持久化
 
@@ -206,7 +206,7 @@ dtype('float64')
 
 ```
 
-在这个例子中，`X` 原本是 `float32` ，被 `fit_transform(X)` 转换成 `float64` 。
+在这个示例中，`X` 原本是 `float32` ，被 `fit_transform(X)` 转换成 `float64` 。
 
 回归目标被转换为 `float64` ，但分类目标维持不变:
 

docs/master/54.md

@@ -48,7 +48,7 @@
 >
 >当用任意的学习算法进行实验时，最重要的就是不要在用于拟合估计器的数据上测试一个估计器的预期值，因为这不会评估在 **新数据** 上估计器的执行情况。这也是数据集经常被分为 _训练_ 和 _测试_ 数据的原因。
 
-**KNN(k 最近邻)分类器例子**：
+**KNN(k 最近邻)分类器示例**：
 
 [![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_classification_001.png](img/86003b5287219bcbec1586985a110629.jpg)](https://scikit-learn.org/stable/auto_examples/neighbors/plot_classification.html)
 
@@ -76,7 +76,7 @@ array([1, 1, 1, 0, 0, 0, 2, 1, 2, 0])
 
 ### 维度惩罚
 
-为了使一个估计器有效，你需要邻接点间的距离小于一些值：![d](img/adf83056bc2bd05628e24c40cb728b3d.jpg)，这取决于具体问题。在一维中，这需要平均 *n sim 1/d* 点。在上文 ![k](img/f93871977da52a6d11045d57c3e18728.jpg)-NN 例子中，如果数据只是由一个0到1的特征值和 ![n](img/c87d9110f3d32ffa5fa08671e4af11fb.jpg) 训练观察值所描述，那么新数据将不会超过 ![1/n](img/0a3546c8f30354c128ef2acb96e91e16.jpg)。因此，最近邻决策规则会很有效率，因为与类间特征变量范围相比， ![1/n](img/0a3546c8f30354c128ef2acb96e91e16.jpg) 很小。
+为了使一个估计器有效，你需要邻接点间的距离小于一些值：![d](img/adf83056bc2bd05628e24c40cb728b3d.jpg)，这取决于具体问题。在一维中，这需要平均 *n sim 1/d* 点。在上文 ![k](img/f93871977da52a6d11045d57c3e18728.jpg)-NN 示例中，如果数据只是由一个0到1的特征值和 ![n](img/c87d9110f3d32ffa5fa08671e4af11fb.jpg) 训练观察值所描述，那么新数据将不会超过 ![1/n](img/0a3546c8f30354c128ef2acb96e91e16.jpg)。因此，最近邻决策规则会很有效率，因为与类间特征变量范围相比， ![1/n](img/0a3546c8f30354c128ef2acb96e91e16.jpg) 很小。
 
 如果特征数是 ![p](img/e2f9b08680b30cfb80102f69264fdd5c.jpg)，你现在就需要 ![n \sim 1/d^p](img/6bcc641ece97b81c42261e28eaad3ad7.jpg) 点。也就是说我们在一维 ![[0, 1]](img/35b3276dd7e50cda7dd79a91161a1a26.jpg) 空间里需要10个点，在 ![p](img/e2f9b08680b30cfb80102f69264fdd5c.jpg) 维里就需要 ![10^p](img/e5ad06b17e1bacf475bf9247d93d1419.jpg) 个点。当 ![p](img/e2f9b08680b30cfb80102f69264fdd5c.jpg) 增大时，为了得到一个好的估计器，相应的训练点数量就需要成倍增大。
 
@@ -172,7 +172,7 @@ LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)
 ...    plt.scatter(this_X, y, s=3)
 ```
 
-这是 **bias/variance tradeoff** 中的一个例子：岭参数 `alpha` 越大，偏差越大，方差越小。
+这是 **bias/variance tradeoff** 中的一个示例：岭参数 `alpha` 越大，偏差越大，方差越小。
 
 我们可以选择 `alpha` 来最小化排除错误，这里使用糖尿病数据集而不是人为数据：
 
@@ -271,7 +271,7 @@ LogisticRegression(C=100000.0, class_weight=None, dual=False,
 
 [支持向量机](5#14-支持向量机) 属于判别模型家族：它们尝试通过找到样例的一个组合来构建一个两类之间最大化的平面。通过 `C` 参数进行正则化设置：`C` 的值小意味着边缘是通过分割线周围的所有观测样例进行计算得到的(更正则化)；`C` 的值大意味着边缘是通过邻近分割线的观测样例计算得到的(更少正则化)。
 
->例子：
+>示例：
 >
 >*   [Plot different SVM classifiers in the iris dataset](https://scikit-learn.org/stable/auto_examples/svm/plot_iris.html#sphx-glr-auto-examples-svm-plot-iris-py)
 
@@ -301,7 +301,7 @@ SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
 |
 |`>>> svc = svm.SVC(kernel='linear')`|`>>> svc = svm.SVC(kernel='poly',degree=3)`|`>>> svc = svm.SVC(kernel='rbf')` |
 
->**交互例子**
+>**交互示例**
 >
 >查看 [SVM GUI](https://scikit-learn.org/stable/auto_examples/applications/svm_gui.html#sphx-glr-auto-examples-applications-svm-gui-py) 来下载 `svm_gui.py`；通过左右按键添加两类数据点，拟合模型并改变参数和数据。
 

docs/master/55.md

@@ -47,7 +47,7 @@ scikit-learn 有可以生成训练/测试索引列表的类，可用于流行的
 
 类提供了 `split` 方法，方法允许输入能被分解的数据集，并为每次选择的交叉验证策略迭代生成训练/测试集索引。
 
-下面是使用 `split` 方法的例子。
+下面是使用 `split` 方法的示例。
 
 ```py
 >>> from sklearn.model_selection import KFold, cross_val_score

docs/master/56.md

@@ -43,7 +43,7 @@ k_means 算法无法保证聚类结果完全绝对真实的反应实际情况。
 >
 >**Don’t over-interpret clustering results（不要过分解读聚类结果）**
 
->**Application example: vector quantization（应用案例:向量量化(vector quantization)）**
+>**Application example: vector quantization（应用示例:向量量化(vector quantization)）**
 >
 >一般来说聚类，特别是 K_means 聚类可以作为一种用少量样本来压缩信息的方式。这种方式就是 [vector quantization](https://en.wikipedia.org/wiki/Vector_quantization) 。例如，K_means 算法可以用于对一张图片进行色调分离:
 >

docs/master/59.md

@@ -109,7 +109,7 @@ comp.graphics
 
 ```
 
-监督学习需要让训练集中的每个文档对应一个类别标签。 在这个例子中，类别是每个新闻组的名称，也刚好是每个储存文本文件的文件夹的名称。
+监督学习需要让训练集中的每个文档对应一个类别标签。 在这个示例中，类别是每个新闻组的名称，也刚好是每个储存文本文件的文件夹的名称。
 
 由于速度和空间上效率的原因 `scikit-learn` 加载目标属性为一个整型数列， 它与 `target_names` 列表中类别名称的 index（索引）相对应。 每个样本的类别的整数型 id 存放在 `target` 属性中:
 

docs/master/6.md

@@ -90,7 +90,7 @@ array([ 29.6...])
  *   `loss="log"`: logistic regression （logistic 回归），
  *   and all regression losses below（以及所有的回归损失）。
 
-前两个 loss functions（损失函数）是懒惰的，只有一个例子违反了 margin constraint（边界约束），它们才更新模型的参数, 这使得训练非常有效率,即使使用了 L2 penalty（惩罚）我们仍然可能得到稀疏的模型结果。
+前两个 loss functions（损失函数）是懒惰的，只有一个示例违反了 margin constraint（边界约束），它们才更新模型的参数, 这使得训练非常有效率,即使使用了 L2 penalty（惩罚）我们仍然可能得到稀疏的模型结果。
 
 使用 `loss="log"` 或者 `loss="modified_huber"` 来启用 `predict_proba` 方法, 其给出每个样本 ![x](img/5c82dbae35dc43d2f556f9f284d9d184.jpg) 的概率估计 ![P(y|x)](img/3cca81fd08a4732dc7061cd246b323ed.jpg) 的一个向量：
 

docs/master/7.md

@@ -17,7 +17,7 @@
 
 [`sklearn.neighbors`](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.neighbors) 可以处理 Numpy 数组或 `scipy.sparse` 矩阵作为其输入。 对于密集矩阵，大多数可能的距离度量都是支持的。对于稀疏矩阵，支持搜索任意的 Minkowski 度量。
 
-许多学习路径/方法都是依赖最近邻作为核心。 一个例子是 [核密度估计](https://scikit-learn.org/stable/modules/density.html#kernel-density) , 在 [密度估计](https://scikit-learn.org/stable/modules/density.html#density-estimation) 章节中有讨论。
+许多学习路径/方法都是依赖最近邻作为核心。 一个示例是 [核密度估计](https://scikit-learn.org/stable/modules/density.html#kernel-density) , 在 [密度估计](https://scikit-learn.org/stable/modules/density.html#density-estimation) 章节中有讨论。
 
 ## 1.6.1. 无监督最近邻
 
@@ -73,7 +73,7 @@ array([[ 1.,  1.,  0.,  0.,  0.,  0.],
 
 ### 1.6.1.2. KDTree 和 BallTree 类
 
-另外，我们可以使用 [`KDTree`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KDTree.html#sklearn.neighbors.KDTree "sklearn.neighbors.KDTree") 或 [`BallTree`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.BallTree.html#sklearn.neighbors.BallTree "sklearn.neighbors.BallTree") 来找最近邻。 这是上文使用过的 [`NearestNeighbors`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.NearestNeighbors.html#sklearn.neighbors.NearestNeighbors "sklearn.neighbors.NearestNeighbors") 类所包含的功能。 [`KDTree`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KDTree.html#sklearn.neighbors.KDTree "sklearn.neighbors.KDTree") 和 [`BallTree`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.BallTree.html#sklearn.neighbors.BallTree "sklearn.neighbors.BallTree") 具有相同的接口； 我们将在这里展示使用 [`KDTree`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KDTree.html#sklearn.neighbors.KDTree "sklearn.neighbors.KDTree") 的例子：
+另外，我们可以使用 [`KDTree`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KDTree.html#sklearn.neighbors.KDTree "sklearn.neighbors.KDTree") 或 [`BallTree`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.BallTree.html#sklearn.neighbors.BallTree "sklearn.neighbors.BallTree") 来找最近邻。 这是上文使用过的 [`NearestNeighbors`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.NearestNeighbors.html#sklearn.neighbors.NearestNeighbors "sklearn.neighbors.NearestNeighbors") 类所包含的功能。 [`KDTree`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KDTree.html#sklearn.neighbors.KDTree "sklearn.neighbors.KDTree") 和 [`BallTree`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.BallTree.html#sklearn.neighbors.BallTree "sklearn.neighbors.BallTree") 具有相同的接口； 我们将在这里展示使用 [`KDTree`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KDTree.html#sklearn.neighbors.KDTree "sklearn.neighbors.KDTree") 的示例：
 
 ```py
 >>> from sklearn.neighbors import KDTree
@@ -125,7 +125,7 @@ scikit-learn 实现了两种不同的最近邻回归：[`KNeighborsRegressor`](h
 使用多输出的最近邻进行回归分析 [Face completion with a multi-output estimators](https://scikit-learn.org/stable/auto_examples//plot_multioutput_face_completion.html#sphx-glr-auto-examples-plot-multioutput-face-completion-py)。 |
 
 
-利用多输出估计器，演示了多输出最近邻回归方法在人脸补全中的应用。在这个例子中，输入 X 是脸上半部分像素，输出 Y 是脸下半部分像素。
+利用多输出估计器，演示了多输出最近邻回归方法在人脸补全中的应用。在这个示例中，输入 X 是脸上半部分像素，输出 Y 是脸下半部分像素。
 
 ![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_multioutput_face_completion_0011.png](img/sphx_glr_plot_multioutput_face_completion_0011.png)
 
@@ -231,13 +231,13 @@ NearestCentroid(metric='euclidean', shrink_threshold=None)
 
 该 [`NearestCentroid`](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.NearestCentroid.html#sklearn.neighbors.NearestCentroid "sklearn.neighbors.NearestCentroid") 分类器有一个 `shrink_threshold` 参数, 它实现了 nearest shrunken centroid 分类器. 实际上, 每个质心的每个特征的值除以该特征的类中的方差. 然后通过 `shrink_threshold` 来减小特征值. 最值得注意的是, 如果特定特征值过0, 则将其设置为0. 实际上，这个方法移除了影响分类器的特征。 这很有用, 例如, 去除噪声特征.
 
-在以下例子中, 使用一个较小的 shrink 阀值将模型的准确度从 0.81 提高到 0.82.
+在以下示例中, 使用一个较小的 shrink 阀值将模型的准确度从 0.81 提高到 0.82.
 
 
 [![nearest_centroid_1](img/27eaae520bfaa9c4bdbef494c5029741.jpg)](https://scikit-learn.org/stable/auto_examples/neighbors/plot_nca_classification.html) [![nearest_centroid_2](img/a561362ff63affeb799b9d33423235a3.jpg)](https://scikit-learn.org/stable/auto_examples/neighbors/plot_nca_classification.html)
 
 > **示例**:
->*   [Nearest Centroid Classification](https://scikit-learn.org/stable/auto_examples//neighbors/plot_nearest_centroid.html#sphx-glr-auto-examples-neighbors-plot-nearest-centroid-py): 一个分类的例子, 它使用了不同 shrink 阀值的最近质心.
+>*   [Nearest Centroid Classification](https://scikit-learn.org/stable/auto_examples//neighbors/plot_nearest_centroid.html#sphx-glr-auto-examples-neighbors-plot-nearest-centroid-py): 一个分类的示例, 它使用了不同 shrink 阀值的最近质心.
 
 ## 1.6.6 邻域成分分析
 
@@ -252,7 +252,7 @@ NearestCentroid(metric='euclidean', shrink_threshold=None)
 
 NCA分类在不同规模和难度的数据集的实际应用中显示出良好的效果。与线性判别分析等相关方法相比，NCA没有对类的分布做任何假设。而最近邻分类自然会产生高度不规则的决策边界。
 
-要使用这个模型进行分类，需要将一个[NeighborhoodComponentsAnalysis](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.NeighborhoodComponentsAnalysis.html#sklearn.neighbors.NeighborhoodComponentsAnalysis)实例与一个[KNeighborsClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier)实例结合起来，[NeighborhoodComponentsAnalysis](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.NeighborhoodComponentsAnalysis.html#sklearn.neighbors.NeighborhoodComponentsAnalysis)实例拟合最优转换，[KNeighborsClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier)实例在投影空间中执行分类。下面是一个使用这两个类的例子:
+要使用这个模型进行分类，需要将一个[NeighborhoodComponentsAnalysis](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.NeighborhoodComponentsAnalysis.html#sklearn.neighbors.NeighborhoodComponentsAnalysis)实例与一个[KNeighborsClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier)实例结合起来，[NeighborhoodComponentsAnalysis](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.NeighborhoodComponentsAnalysis.html#sklearn.neighbors.NeighborhoodComponentsAnalysis)实例拟合最优转换，[KNeighborsClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier)实例在投影空间中执行分类。下面是一个使用这两个类的示例:
 
 ```py
 >>> from sklearn.neighbors import (NeighborhoodComponentsAnalysis,