更新第三章

docs/29.md

+# 3\. 模型选择和评估
+* [3.1 交叉验证：评估估算器的表现](docs/30.md?id=_31-交叉验证：评估估算器的表现)
+    * [3.1.1 计算交叉验证的指标](docs/30.md?id=_311-计算交叉验证的指标)
+        * [3.1.1.1 cross_validate 函数和多度量评估](docs/30.md?id=_3111-cross_validate-函数和多度量评估)
+        * [3.1.1.2 通过交叉验证获取预测](docs/30.md?id=_3112-通过交叉验证获取预测)
+    * [3.1.2 交叉验证迭代器](docs/30.md?id=_312-交叉验证迭代器)
+        * [3.1.2.1 交叉验证迭代器–循环遍历数据](docs/30.md?id=_3121-交叉验证迭代器–循环遍历数据)
+            * [3.1.2.1.1 K 折](docs/30.md?id=_31211-k-折)
+            * [3.1.2.1.2 重复 K-折交叉验证](docs/30.md?id=_31212-重复-k-折交叉验证)
+            * [3.1.2.1.3 留一交叉验证 (LOO)](docs/30.md?id=_31213-留一交叉验证-loo)
+            * [3.1.2.1.4 留 P 交叉验证 (LPO)](docs/30.md?id=_31214-留-p-交叉验证-lpo)
+            * [3.1.2.1.5 随机排列交叉验证 a.k.a. Shuffle & Split](docs/30.md?id=_31215-随机排列交叉验证-aka-shuffle-&-split)
+        * [3.1.2.2 基于类标签、具有分层的交叉验证迭代器](docs/30.md?id=_3122-基于类标签、具有分层的交叉验证迭代器)
+            * [3.1.2.2.1 分层 k 折](docs/30.md?id=_31221-分层-k-折)
+            * [3.1.2.2.2 分层随机 Split](docs/30.md?id=_31222-分层随机-split)
+        * [3.1.2.3 用于分组数据的交叉验证迭代器](docs/30.md?id=_3123-用于分组数据的交叉验证迭代器)
+            * [3.1.2.3.1 组 k-fold](docs/30.md?id=_31231-组-k-fold)
+            * [3.1.2.3.2 留一组交叉验证](docs/30.md?id=_31232-留一组交叉验证)
+            * [3.1.2.3.3 留 P 组交叉验证](docs/30.md?id=_31233-留-p-组交叉验证)
+            * [3.1.2.3.4 Group Shuffle Split](docs/30.md?id=_31234-group-shuffle-split)
+        * [3.1.2.4 预定义的折叠 / 验证集](docs/30.md?id=_3124-预定义的折叠-/-验证集)
+        * [3.1.2.5 交叉验证在时间序列数据中应用](docs/30.md?id=_3125-交叉验证在时间序列数据中应用)
+            * [3.1.2.5.1 时间序列分割](docs/30.md?id=_31251-时间序列分割)
+    * [3.1.3 A note on shuffling](docs/30.md?id=_313-a-note-on-shuffling)
+    * [3.1.4 交叉验证和模型选择](docs/30.md?id=_314-交叉验证和模型选择)
+* [3.2 调整估计器的超参数](docs/31.md?id=_32-调整估计器的超参数)
+    * [3.2.1 网格追踪法–穷尽的网格搜索](docs/31.md?id=_321-网格追踪法–穷尽的网格搜索)
+    * [3.2.2 随机参数优化](docs/31.md?id=_322-随机参数优化)
+    * [3.2.3 参数搜索技巧](docs/31.md?id=_323-参数搜索技巧)
+        * [3.2.3.1 指定目标度量](docs/31.md?id=_3231-指定目标度量)
+        * [3.2.3.2 为评估指定多个指标](docs/31.md?id=_3232-为评估指定多个指标)
+        * [3.2.3.3 复合估计和参数空间](docs/31.md?id=_3233-复合估计和参数空间)
+        * [3.2.3.4 模型选择：开发和评估](docs/31.md?id=_3234-模型选择：开发和评估)
+        * [3.2.3.5 并行机制](docs/31.md?id=_3235-并行机制)
+        * [3.2.3.6 对故障的鲁棒性](docs/31.md?id=_3236-对故障的鲁棒性)
+    * [3.2.4 暴力参数搜索的替代方案](docs/31.md?id=_324-暴力参数搜索的替代方案)
+        * [3.2.4.1 模型特定交叉验证](docs/31.md?id=_3241-模型特定交叉验证)
+        * [3.2.4.2 信息标准](docs/31.md?id=_3242-信息标准)
+        * [3.2.4.3 出袋估计](docs/31.md?id=_3243-出袋估计)
+* [3.3 模型评估: 量化预测的质量](docs/32.md?id=_33-模型评估:-量化预测的质量)
+    * [3.3.1 `scoring` 参数: 定义模型评估规则](docs/32.md?id=_331-`scoring`-参数:-定义模型评估规则)
+        * [3.3.1.1 常见场景: 预定义值](docs/32.md?id=_3311-常见场景:-预定义值)
+        * [3.3.1.2 根据 metric 函数定义您的评分策略](docs/32.md?id=_3312-根据-metric-函数定义您的评分策略)
+        * [3.3.1.3 实现自己的记分对象](docs/32.md?id=_3313-实现自己的记分对象)
+        * [3.3.1.4 使用多个指数评估](docs/32.md?id=_3314-使用多个指数评估)
+    * [3.3.2 分类指标](docs/32.md?id=_332-分类指标)
+        * [3.3.2.1 从二分到多分类和 multilabel](docs/32.md?id=_3321-从二分到多分类和-multilabel)
+        * [3.3.2.2 精确度得分](docs/32.md?id=_3322-精确度得分)
+        * [3.3.2.3 Balanced accuracy score](docs/32.md?id=_3323-balanced-accuracy-score)
+        * [3.3.2.4 Cohen’s kappa](docs/32.md?id=_3324-cohen’s-kappa)
+        * [3.3.2.5 混淆矩阵](docs/32.md?id=_3325-混淆矩阵)
+        * [3.3.2.6 分类报告](docs/32.md?id=_3326-分类报告)
+        * [3.3.2.7 汉明损失](docs/32.md?id=_3327-汉明损失)
+        * [3.3.2.8 精准，召回和 F-measures](docs/32.md?id=_3328-精准，召回和-f-measures)
+            * [3.3.2.8.1 二分类](docs/32.md?id=_33281-二分类)
+            * [3.3.2.8.2 多类和多标签分类](docs/32.md?id=_33282-多类和多标签分类)
+        * [3.3.2.9 Jaccard 相似系数 score](docs/32.md?id=_3329-jaccard-相似系数-score)
+        * [3.3.2.10 Hinge loss](docs/32.md?id=_33210-hinge-loss)
+        * [3.3.2.11 Log 损失](docs/32.md?id=_33211-log-损失)
+        * [3.3.2.12 马修斯相关系数](docs/32.md?id=_33212-马修斯相关系数)
+        * [3.3.2.13 多标记混淆矩阵](docs/32.md?id=_33213-多标记混淆矩阵)
+        * [3.3.2.14 Receiver operating characteristic (ROC)](docs/32.md?id=_33214-receiver-operating-characteristic-roc)
+        * [3.3.2.15 零一损失](docs/32.md?id=_33215-零一损失)
+        * [3.3.2.16 Brier 分数损失](docs/32.md?id=_33216-brier-分数损失)
+    * [3.3.3 多标签排名指标](docs/32.md?id=_333-多标签排名指标)
+        * [3.3.3.1 覆盖误差](docs/32.md?id=_3331-覆盖误差)
+        * [3.3.3.2 标签排名平均精度](docs/32.md?id=_3332-标签排名平均精度)
+        * [3.3.3.3 排序损失](docs/32.md?id=_3333-排序损失)
+    * [3.3.4 回归指标](docs/32.md?id=_334-回归指标)
+        * [3.3.4.1 解释方差得分](docs/32.md?id=_3341-解释方差得分)
+        * [3.3.4.2 最大误差](docs/32.md?id=_3342-最大误差)
+        * [3.3.4.3 平均绝对误差](docs/32.md?id=_3343-平均绝对误差)
+        * [3.3.4.4 均方误差](docs/32.md?id=_3344-均方误差)
+        * [3.3.4.5 均方误差对数](docs/32.md?id=_3345-均方误差对数)
+        * [3.3.4.6 中位绝对误差](docs/32.md?id=_3346-中位绝对误差)
+        * [3.3.4.7 R² score, 可决系数](docs/32.md?id=_3347-r²-score,-可决系数)
+    * [3.3.5 聚类指标](docs/32.md?id=_335-聚类指标)
+    * [3.3.6 虚拟估计](docs/32.md?id=_336-虚拟估计)
+* [3.4 模型持久化](docs/33.md?id=_34-模型持久化)
+    * [3.4.1 持久化示例](docs/33.md?id=_341-持久化示例)
+    * [3.4.2 安全性和可维护性的局限性](docs/33.md?id=_342-安全性和可维护性的局限性)
+* [3.5 验证曲线: 绘制分数以评估模型](docs/34.md?id=_35-验证曲线:-绘制分数以评估模型)
+    * [3.5.1 验证曲线](docs/34.md?id=_351-验证曲线)
+    * [3.5.2 学习曲线](docs/34.md?id=_352-学习曲线)

docs/31.md

+# 3.2\. 调整估计器的超参数
+
+校验者:
+        [@想和太阳肩并肩](https://github.com/apachecn/scikit-learn-doc-zh)
+翻译者:
+        [@\S^R^Y/](https://github.com/apachecn/scikit-learn-doc-zh)
+
+超参数，即不直接在估计器内学习的参数。在 scikit-learn 包中，它们作为估计器类中构造函数的参数进行传递。典型的例子有：用于支持向量分类器的 `C` 、`kernel` 和 `gamma` ，用于Lasso的 `alpha` 等。
+
+搜索超参数空间以便获得最好 [交叉验证](https://scikit-learn.org/stable//modules/cross_validation.html#cross-validation) 分数的方法是可能的而且是值得提倡的。
+
+通过这种方式，构造估计器时被提供的任何参数或许都能被优化。具体来说，要获取到给定估计器的所有参数的名称和当前值，使用:
+
+```py
+estimator.get_params()
+```
+
+搜索包括:
+
+*   估计器(回归器或分类器，例如 `sklearn.svm.SVC()`)
+*   参数空间
+*   搜寻或采样候选的方法
+*   交叉验证方案
+*   [计分函数](#_3231-指定目标度量)
+
+有些模型支持专业化的、高效的参数搜索策略, [描述如下](#alternative-cv) 。在 scikit-learn 包中提供了两种采样搜索候选的通用方法:对于给定的值, [GridSearchCV](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV) 考虑了所有参数组合；而 [RandomizedSearchCV](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.RandomizedSearchCV.html#sklearn.model_selection.RandomizedSearchCV) 可以从具有指定分布的参数空间中抽取给定数量的候选。介绍完这些工具后，我们将详细介绍适用于这两种方法的 [最佳实践](#_323-参数搜索技巧) 。
+
+**注意**，通常这些参数的一小部分会对模型的预测或计算性能有很大的影响，而其他参数可以保留为其默认值。 建议阅读估计器类的相关文档，以更好地了解其预期行为，可能的话还可以阅读下引用的文献。
+
+## 3.2.1\. 网格追踪法–穷尽的网格搜索
+
+`GridSearchCV` 提供的网格搜索从通过 `param_grid` 参数确定的网格参数值中全面生成候选。例如，下面的 `param_grid`:
+
+```py
+param_grid = [
+  {'C': [1, 10, 100, 1000], 'kernel': ['linear']},
+  {'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001], 'kernel': ['rbf']},
+ ]
+
+```
+
+探索两个网格的详细解释： 一个具有线性内核并且C在[1,10,100,1000]中取值； 另一个具有RBF内核，C值的交叉乘积范围在[1,10，100,1000]，gamma在[0.001，0.0001]中取值。
+
+`GridSearchCV` 实例实现了常用估计器 API：当在数据集上“拟合”时，参数值的所有可能的组合都会被评估，从而计算出最佳的组合。
+
+>示例:
+>*   有关在数字数据集上的网格搜索计算示例，请参阅 [基于交叉验证的网格搜索参数估计](https://scikit-learn.org/stable//auto_examples/model_selection/plot_grid_search_digits.html#sphx-glr-auto-examples-model-selection-plot-grid-search-digits-py)。
+>*   有关来自文本文档特征提取器（n-gram计数向量化器和TF-IDF变换器）的网格搜索耦合参数与分类器（这里是使用具有弹性网格的SGD训练的线性SVM 或L2惩罚）使用 *pipeline.Pipeline* 示例,请参阅 [用于文本特征提取和评估的示例管道](https://scikit-learn.org/stable//auto_examples/model_selection/grid_search_text_feature_extraction.html#sphx-glr-auto-examples-model-selection-grid-search-text-feature-extraction-py)。
+>*   有关iris数据集的交叉验证循环中的网格搜索示例, 请参阅 [嵌套与非嵌套交叉验证](https://scikit-learn.org/stable//auto_examples/model_selection/plot_nested_cross_validation_iris.html#sphx-glr-auto-examples-model-selection-plot-nested-cross-validation-iris-py)。
+>*   有关用于同时评估多个指标的GridSearchCV示例，请参阅 [cross_val_score 与 GridSearchCV 多指标评价的实证研究](https://scikit-learn.org/stable//auto_examples/model_selection/plot_multi_metric_evaluation.html#sphx-glr-auto-examples-model-selection-plot-multi-metric-evaluation-py)。
+
+## 3.2.2\. 随机参数优化
+
+尽管使用参数设置的网格法是目前最广泛使用的参数优化方法, 其他搜索方法也具有更有利的性能。 [RandomizedSearchCV](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.RandomizedSearchCV.html#sklearn.model_selection.RandomizedSearchCV) 实现了对参数的随机搜索, 其中每个设置都是从可能的参数值的分布中进行取样。 这对于穷举搜索有两个主要优势:
+
+*   可以选择独立于参数个数和可能值的预算
+*   添加不影响性能的参数不会降低效率
+
+指定如何取样的参数是使用字典完成的, 非常类似于为 `GridSearchCV` 指定参数。 此外, 通过 `n_iter` 参数指定计算预算, 即取样候选项数或取样迭代次数。 对于每个参数, 可以指定在可能值上的分布或离散选择的列表 (均匀取样):
+
+```py
+{'C': scipy.stats.expon(scale=100), 'gamma': scipy.stats.expon(scale=.1),
+  'kernel': ['rbf'], 'class_weight':['balanced', None]}
+
+```
+
+本示例使用 `scipy.stats` 模块, 它包含许多用于采样参数的有用分布, 如 `expon`，`gamma`，`uniform` 或者 `randint`。 原则上, 任何函数都可以通过提供一个 `rvs` （随机变量样本）方法来采样一个值。 对 `rvs` 函数的调用应在连续调用中提供来自可能参数值的独立随机样本。
+>**警告**
+>
+>scipy 0.16之前的版本不允许指定随机状态，而是使用`np.random`来产生随机状态，或是使用`np.random.set`来指定状态．然而在scikit-learn 0.18以后，如果scipy版本大于0.16，则[sklearn.model_selection](https://scikit-learn.org/stable//modules/classes.html#module-sklearn.model_selection)可以通过用户指定来获得随机状态
+
+
+对于连续参数 (如上面提到的 `C` )，指定连续分布以充分利用随机化是很重要的。这样，有助于 `n_iter` 总是趋向于更精细的搜索。
+
+>示例:
+>
+>*   随机搜索和网格搜索的使用和效率的比较： [有关随机搜索和网格搜索超参数估计的对比](https://scikit-learn.org/stable//auto_examples/model_selection/plot_randomized_search.html#sphx-glr-auto-examples-model-selection-plot-randomized-search-py)
+
+>引用:
+>*   Bergstra, J. and Bengio, Y., Random search for hyper-parameter optimization, The Journal of Machine Learning Research (2012)
+
+## 3.2.3\. 参数搜索技巧
+
+### 3.2.3.1\. 指定目标度量
+
+默认情况下, 参数搜索使用估计器的评分函数来评估（衡量）参数设置。 比如 [sklearn.metrics.accuracy_score](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html#sklearn.metrics.accuracy_score) 用于分类和 [sklearn.metrics.r2_score](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html#sklearn.metrics.r2_score) 用于回归。 对于一些应用, 其他评分函数将会更加适合 (例如在不平衡的分类, 精度评分往往是信息不足的)。 一个可选的评分功能可以通过评分参数指定给 `GridSearchCV`， `RandomizedSearchCV` 和许多下文将要描述的、专业化的交叉验证工具。 有关详细信息, 请参阅 [评分参数:定义模型评估规则](doc/32)。
+
+### 3.2.3.2\. 为评估指定多个指标
+
+`GridSearchCV` 和 `RandomizedSearchCV` 允许为评分参数指定多个指标。
+
+多指标评分可以被指定为一个预先定义分数名称字符串列表或者是一个得分手名字到得分手的函数或预先定义的记分员名字的映射字典。 有关详细信息, 请参阅 [多指标评估](docs/33)。
+
+在指定多个指标时,必须将 `refit` 参数设置为要在其中找到 `best_params_`,并用于在整个数据集上构建 `best_estimator_` 的度量标准（字符串）。 如果搜索不应该 refit, 则设置 `refit=False`。在使用多个度量值时,如果将 refit 保留为默认值,不会导致结果错误。
+
+有关示例用法, 请参见 [cross_val_score 与 GridSearchCV 多指标评价的实证研究](https://scikit-learn.org/stable/auto_examples/model_selection/plot_multi_metric_evaluation.html#sphx-glr-auto-examples-model-selection-plot-multi-metric-evaluation-py)。
+
+### 3.2.3.3\. 复合估计和参数空间
+
+[管道：链式评估器](docs/57) 描述了如何使用这些工具搜索参数空间构建链式评估器。
+
+### 3.2.3.4\. 模型选择：开发和评估
+
+通过评估各种参数设置，可以将模型选择视为使用标记数据训练网格参数的一种方法。
+
+在评估结果模型时, 重要的是在网格搜索过程中未看到的 held-out 样本数据上执行以下操作: 建议将数据拆分为开发集 (**development set**,供 `GridSearchCV` 实例使用)和评估集(**evaluation set**)来计算性能指标。
+
+这可以通过使用效用函数 [train_test_split](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html#sklearn.model_selection.train_test_split) 来完成。
+
+### 3.2.3.5\. 并行机制
+
+`GridSearchCV` 和 `RandomizedSearchCV` 可以独立地评估每个参数设置。如果您的OS支持,通过使用关键字 `n_jobs=-1` 可以使计算并行运行。 有关详细信息, 请参见函数签名。
+
+### 3.2.3.6\. 对故障的鲁棒性
+
+某些参数设置可能导致无法 `fit` 数据的一个或多个折叠。 默认情况下, 这将导致整个搜索失败, 即使某些参数设置可以完全计算。 设置 `error_score=0` (或`=np.NaN`) 将使程序对此类故障具有鲁棒性,发出警告并将该折叠的分数设置为0(或`NaN`), 但可以完成搜索。
+
+## 3.2.4\. 暴力参数搜索的替代方案
+
+### 3.2.4.1\. 模型特定交叉验证
+
+某些模型可以与参数的单个值的估计值一样有效地适应某一参数范围内的数据。 此功能可用于执行更有效的交叉验证, 用于此参数的模型选择。
+
+该策略最常用的参数是编码正则化矩阵强度的参数。在这种情况下, 我们称之为, 计算估计器的正则化路径(**regularization path**)。
+
+以下是这些模型的列表:
+
+|模型 |描述 |
+|---|---|
+| [`linear_model.ElasticNetCV`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.ElasticNetCV.html#sklearn.linear_model.ElasticNetCV "sklearn.linear_model.ElasticNetCV")([l1_ratio, eps, …]) | Elastic Net model with iterative fitting along a regularization path |
+| [`linear_model.LarsCV`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LarsCV.html#sklearn.linear_model.LarsCV "sklearn.linear_model.LarsCV")([fit_intercept, …]) | Cross-validated Least Angle Regression model |
+| [`linear_model.LassoCV`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LassoCV.html#sklearn.linear_model.LassoCV "sklearn.linear_model.LassoCV")([eps, n_alphas, …]) | Lasso linear model with iterative fitting along a regularization path |
+| [`linear_model.LassoLarsCV`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LassoLarsCV.html#sklearn.linear_model.LassoLarsCV "sklearn.linear_model.LassoLarsCV")([fit_intercept, …]) | Cross-validated Lasso, using the LARS algorithm |
+| [`linear_model.LogisticRegressionCV`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegressionCV.html#sklearn.linear_model.LogisticRegressionCV "sklearn.linear_model.LogisticRegressionCV")([Cs, …]) | Logistic Regression CV (aka logit, MaxEnt) classifier. |
+| [`linear_model.MultiTaskElasticNetCV`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.MultiTaskElasticNetCV.html#sklearn.linear_model.MultiTaskElasticNetCV "sklearn.linear_model.MultiTaskElasticNetCV")([…]) | Multi-task L1/L2 ElasticNet with built-in cross-validation. |
+| [`linear_model.MultiTaskLassoCV`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.MultiTaskLassoCV.html#sklearn.linear_model.MultiTaskLassoCV "sklearn.linear_model.MultiTaskLassoCV")([eps, …]) | Multi-task L1/L2 Lasso with built-in cross-validation. |
+| [`linear_model.OrthogonalMatchingPursuitCV`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.OrthogonalMatchingPursuitCV.html#sklearn.linear_model.OrthogonalMatchingPursuitCV "sklearn.linear_model.OrthogonalMatchingPursuitCV")([…]) | Cross-validated Orthogonal Matching Pursuit model (OMP) |
+| [`linear_model.RidgeCV`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.RidgeCV.html#sklearn.linear_model.RidgeCV "sklearn.linear_model.RidgeCV")([alphas, …]) | Ridge regression with built-in cross-validation. |
+| [`linear_model.RidgeClassifierCV`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.RidgeClassifierCV.html#sklearn.linear_model.RidgeClassifierCV "sklearn.linear_model.RidgeClassifierCV")([alphas, …]) | Ridge classifier with built-in cross-validation. |
+
+### 3.2.4.2\. 信息标准
+
+一些模型通过计算一个正则化路径 (代替使用交叉验证得出数个参数), 可以给出正则化参数最优估计的信息理论闭包公式。
+
+以下是从 Akaike 信息标准 (AIC) 或贝叶斯信息标准 (可用于自动选择模型) 中受益的模型列表:
+
+|模型 |描述 |
+|---|---|
+| [`linear_model.LassoLarsIC`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LassoLarsIC.html#sklearn.linear_model.LassoLarsIC "sklearn.linear_model.LassoLarsIC")([criterion, …]) | Lasso model fit with Lars using BIC or AIC for model selection |
+
+### 3.2.4.3\. 出袋估计
+
+当使用基于装袋的集合方法时，即使用具有替换的采样产生新的训练集，部分训练集保持不用。 对于集合中的每个分类器，训练集的不同部分被忽略。
+
+这个省略的部分可以用来估计泛化误差，而不必依靠单独的验证集。 此估计是”免费的”，因为不需要额外的数据，可以用于模型选择。
+
+目前该方法已经实现的类以下几个:
+
+|方法 |描述 |
+|---|---|
+| [`ensemble.RandomForestClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn.ensemble.RandomForestClassifier "sklearn.ensemble.RandomForestClassifier")([…]) | A random forest classifier. |
+| [`ensemble.RandomForestRegressor`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestRegressor.html#sklearn.ensemble.RandomForestRegressor "sklearn.ensemble.RandomForestRegressor")([…]) | A random forest regressor. |
+| [`ensemble.ExtraTreesClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesClassifier.html#sklearn.ensemble.ExtraTreesClassifier "sklearn.ensemble.ExtraTreesClassifier")([…]) | An extra-trees classifier. |
+| [`ensemble.ExtraTreesRegressor`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesRegressor.html#sklearn.ensemble.ExtraTreesRegressor "sklearn.ensemble.ExtraTreesRegressor")([n_estimators, …]) | An extra-trees regressor. |
+| [`ensemble.GradientBoostingClassifier`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html#sklearn.ensemble.GradientBoostingClassifier "sklearn.ensemble.GradientBoostingClassifier")([loss, …]) | Gradient Boosting for classification. |
+| [`ensemble.GradientBoostingRegressor`](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html#sklearn.ensemble.GradientBoostingRegressor "sklearn.ensemble.GradientBoostingRegressor")([loss, …]) | Gradient Boosting for regression. |

docs/33.md

-# 3\. 模型选择和评估
-
-*   [3.1\. 交叉验证：评估估算器的表现](/docs/34?id=_31-交叉验证：评估估算器的表现)
-    *   [3.1.1\. 计算交叉验证的指标](/docs/34?id=_311-计算交叉验证的指标)
-        *   [3.1.1.1\. cross_validate 函数和多度量评估](/docs/34?id=_3111-cross_validate-函数和多度量评估)
-        *   [3.1.1.2\. 通过交叉验证获取预测](/docs/34?id=_3112-通过交叉验证获取预测)
-    *   [3.1.2\. 交叉验证迭代器](/docs/34?id=_312-交叉验证迭代器)
-    *   [3.1.3\. 交叉验证迭代器–循环遍历数据](/docs/34?id=_313-交叉验证迭代器–循环遍历数据)
-        *   [3.1.3.1\. K 折](/docs/34?id=_3131-k-折)
-        *   [3.1.3.2\. 重复 K-折交叉验证](/docs/34?id=_3132-重复-k-折交叉验证)
-        *   [3.1.3.3\. 留一交叉验证 (LOO)](/docs/34?id=_3133-留一交叉验证-（loo)
-        *   [3.1.3.4\. 留 P 交叉验证 (LPO)](/docs/34?id=_3134-留-p-交叉验证-（lpo)
-        *   [3.1.3.5\. 随机排列交叉验证 a.k.a. Shuffle & Split](/docs/34?id=_3135-随机排列交叉验证-aka-shuffle-&-split)
-    *   [3.1.4\. 基于类标签、具有分层的交叉验证迭代器](/docs/34?id=_314-基于类标签、具有分层的交叉验证迭代器)
-        *   [3.1.4.1\. 分层 k 折](/docs/34?id=_3141-分层-k-折)
-        *   [3.1.4.2\. 分层随机 Split](/docs/34?id=_3142-分层随机-split)
-    *   [3.1.5\. 用于分组数据的交叉验证迭代器](/docs/34?id=_315-用于分组数据的交叉验证迭代器)
-        *   [3.1.5.1\. 组 k-fold](/docs/34?id=_3151-组-k-fold)
-        *   [3.1.5.2\. 留一组交叉验证](/docs/34?id=_3152-留一组交叉验证)
-        *   [3.1.5.3\. 留 P 组交叉验证](/docs/34?id=_3153-留-p-组交叉验证)
-        *   [3.1.5.4\. Group Shuffle Split](/docs/34?id=_3154-group-shuffle-split)
-    *   [3.1.6\. 预定义的折叠 / 验证集](/docs/34?id=_316-预定义的折叠-/-验证集)
-    *   [3.1.7\. 交叉验证在时间序列数据中应用](/docs/34?id=_317-交叉验证在时间序列数据中应用)
-        *   [3.1.7.1\. 时间序列分割](/docs/34?id=_3171-时间序列分割)
-    *   [3.1.8\. A note on shuffling](/docs/34?id=_318-a-note-on-shuffling)
-    *   [3.1.9\. 交叉验证和模型选择](/docs/34?id=_319-交叉验证和模型选择)
-*   [3.2\. 调整估计器的超参数](/docs/35?id=_32-调整估计器的超参数)
-    *   [3.2.1\. 网格追踪法–穷尽的网格搜索](/docs/35?id=_321-网格追踪法–穷尽的网格搜索)
-    *   [3.2.2\. 随机参数优化](/docs/35?id=_322-随机参数优化)
-    *   [3.2.3\. 参数搜索技巧](/docs/35?id=_323-参数搜索技巧)
-        *   [3.2.3.1\. 指定目标度量](/docs/35?id=_3231-指定目标度量)
-        *   [3.2.3.2\. 为评估指定多个指标](/docs/35?id=_3232-为评估指定多个指标)
-        *   [3.2.3.3\. 复合估计和参数空间](/docs/35?id=_3233-复合估计和参数空间)
-        *   [3.2.3.4\. 模型选择：开发和评估](/docs/35?id=_3234-模型选择：开发和评估)
-        *   [3.2.3.5\. 并行机制](/docs/35?id=_3235-并行机制)
-        *   [3.2.3.6\. 对故障的鲁棒性](/docs/35?id=_3236-对故障的鲁棒性)
-    *   [3.2.4\. 暴力参数搜索的替代方案](/docs/35?id=_324-暴力参数搜索的替代方案)
-        *   [3.2.4.1\. 模型特定交叉验证](/docs/35?id=_3241-模型特定交叉验证)
-            *   [3.2.4.1.1\. `sklearn.linear_model`.ElasticNetCV](/docs/35?id=_32411-`sklearnlinear_model`elasticnetcv)
-            *   [3.2.4.1.2\. `sklearn.linear_model`.LarsCV](/docs/35?id=_32412-`sklearnlinear_model`larscv)
-            *   [3.2.4.1.3\. `sklearn.linear_model`.LassoCV](/docs/35?id=_32413-`sklearnlinear_model`lassocv)
-                *   [3.2.4.1.3.1\. Examples using `sklearn.linear_model.LassoCV`](/docs/35?id=_324131-examples-using-`sklearnlinear_modellassocv`)
-            *   [3.2.4.1.4\. `sklearn.linear_model`.LassoLarsCV](/docs/35?id=_32414-`sklearnlinear_model`lassolarscv)
-                *   [3.2.4.1.4.1\. Examples using `sklearn.linear_model.LassoLarsCV`](/docs/35?id=_324141-examples-using-`sklearnlinear_modellassolarscv`)
-            *   [3.2.4.1.5\. `sklearn.linear_model`.LogisticRegressionCV](/docs/35?id=_32415-`sklearnlinear_model`logisticregressioncv)
-            *   [3.2.4.1.6\. `sklearn.linear_model`.MultiTaskElasticNetCV](/docs/35?id=_32416-`sklearnlinear_model`multitaskelasticnetcv)
-            *   [3.2.4.1.7\. `sklearn.linear_model`.MultiTaskLassoCV](/docs/35?id=_32417-`sklearnlinear_model`multitasklassocv)
-            *   [3.2.4.1.8\. `sklearn.linear_model`.OrthogonalMatchingPursuitCV](/docs/35?id=_32418-`sklearnlinear_model`orthogonalmatchingpursuitcv)
-                *   [3.2.4.1.8.1\. Examples using `sklearn.linear_model.OrthogonalMatchingPursuitCV`](/docs/35?id=_324181-examples-using-`sklearnlinear_modelorthogonalmatchingpursuitcv`)
-            *   [3.2.4.1.9\. `sklearn.linear_model`.RidgeCV](/docs/35?id=_32419-`sklearnlinear_model`ridgecv)
-                *   [3.2.4.1.9.1\. Examples using `sklearn.linear_model.RidgeCV`](/docs/35?id=_324191-examples-using-`sklearnlinear_modelridgecv`)
-            *   [3.2.4.1.10\. `sklearn.linear_model`.RidgeClassifierCV](/docs/35?id=_324110-`sklearnlinear_model`ridgeclassifiercv)
-        *   [3.2.4.2\. 信息标准](/docs/35?id=_3242-信息标准)
-            *   [3.2.4.2.1\. `sklearn.linear_model`.LassoLarsIC](/docs/35?id=_32421-`sklearnlinear_model`lassolarsic)
-                *   [3.2.4.2.1.1\. Examples using `sklearn.linear_model.LassoLarsIC`](/docs/35?id=_324211-examples-using-`sklearnlinear_modellassolarsic`)
-        *   [3.2.4.3\. 出袋估计](/docs/35?id=_3243-出袋估计)
-            *   [3.2.4.3.1\. `sklearn.ensemble`.RandomForestClassifier](/docs/35?id=_32431-`sklearnensemble`randomforestclassifier)
-                *   [3.2.4.3.1.1\. Examples using `sklearn.ensemble.RandomForestClassifier`](/docs/35?id=_324311-examples-using-`sklearnensemblerandomforestclassifier`)
-            *   [3.2.4.3.2\. `sklearn.ensemble`.RandomForestRegressor](/docs/35?id=_32432-`sklearnensemble`randomforestregressor)
-                *   [3.2.4.3.2.1\. Examples using `sklearn.ensemble.RandomForestRegressor`](/docs/35?id=_324321-examples-using-`sklearnensemblerandomforestregressor`)
-            *   [3.2.4.3.3\. `sklearn.ensemble`.ExtraTreesClassifier](/docs/35?id=_32433-`sklearnensemble`extratreesclassifier)
-                *   [3.2.4.3.3.1\. Examples using `sklearn.ensemble.ExtraTreesClassifier`](/docs/35?id=_324331-examples-using-`sklearnensembleextratreesclassifier`)
-            *   [3.2.4.3.4\. `sklearn.ensemble`.ExtraTreesRegressor](/docs/35?id=_32434-`sklearnensemble`extratreesregressor)
-                *   [3.2.4.3.4.1\. Examples using `sklearn.ensemble.ExtraTreesRegressor`](/docs/35?id=_324341-examples-using-`sklearnensembleextratreesregressor`)
-            *   [3.2.4.3.5\. `sklearn.ensemble`.GradientBoostingClassifier](/docs/35?id=_32435-`sklearnensemble`gradientboostingclassifier)
-                *   [3.2.4.3.5.1\. Examples using `sklearn.ensemble.GradientBoostingClassifier`](/docs/35?id=_324351-examples-using-`sklearnensemblegradientboostingclassifier`)
-            *   [3.2.4.3.6\. `sklearn.ensemble`.GradientBoostingRegressor](/docs/35?id=_32436-`sklearnensemble`gradientboostingregressor)
-                *   [3.2.4.3.6.1\. Examples using `sklearn.ensemble.GradientBoostingRegressor`](/docs/35?id=_324361-examples-using-`sklearnensemblegradientboostingregressor`)
-*   [3.3\. 模型评估: 量化预测的质量](/docs/36?id=_33-模型评估:-量化预测的质量)
-    *   [3.3.1\. `scoring` 参数: 定义模型评估规则](/docs/36?id=_331-`scoring`-参数:-定义模型评估规则)
-        *   [3.3.1.1\. 常见场景: 预定义值](/docs/36?id=_3311-常见场景:-预定义值)
-        *   [3.3.1.2\. 根据 metric 函数定义您的评分策略](/docs/36?id=_3312-根据-metric-函数定义您的评分策略)
-        *   [3.3.1.3\. 实现自己的记分对象](/docs/36?id=_3313-实现自己的记分对象)
-        *   [3.3.1.4\. 使用多个指数评估](/docs/36?id=_3314-使用多个指数评估)
-    *   [3.3.2\. 分类指标](/docs/36?id=_332-分类指标)
-        *   [3.3.2.1\. 从二分到多分类和 multilabel](/docs/36?id=_3321-从二分到多分类和-multilabel)
-        *   [3.3.2.2\. 精确度得分](/docs/36?id=_3322-精确度得分)
-        *   [3.3.2.3\. Cohen’s kappa](/docs/36?id=_3323-cohen’s-kappa)
-        *   [3.3.2.4\. 混淆矩阵](/docs/36?id=_3324-混淆矩阵)
-        *   [3.3.2.5\. 分类报告](/docs/36?id=_3325-分类报告)
-        *   [3.3.2.6\. 汉明损失](/docs/36?id=_3326-汉明损失)
-        *   [3.3.2.7\. Jaccard 相似系数 score](/docs/36?id=_3327-jaccard-相似系数-score)
-        *   [3.3.2.8\. 精准，召回和 F-measures](/docs/36?id=_3328-精准，召回和-f-measures)
-            *   [3.3.2.8.1\. 二分类](/docs/36?id=_33281-二分类)
-            *   [3.3.2.8.2\. 多类和多标签分类](/docs/36?id=_33282-多类和多标签分类)
-        *   [3.3.2.9\. Hinge loss](/docs/36?id=_3329-hinge-loss)
-        *   [3.3.2.10\. Log 损失](/docs/36?id=_33210-log-损失)
-        *   [3.3.2.11\. 马修斯相关系数](/docs/36?id=_33211-马修斯相关系数)
-        *   [3.3.2.12\. Receiver operating characteristic (ROC)](/docs/36?id=_33212-receiver-operating-characteristic-（roc)
-        *   [3.3.2.13\. 零一损失](/docs/36?id=_33213-零一损失)
-        *   [3.3.2.14\. Brier 分数损失](/docs/36?id=_33214-brier-分数损失)
-    *   [3.3.3\. 多标签排名指标](/docs/36?id=_333-多标签排名指标)
-        *   [3.3.3.1\. 覆盖误差](/docs/36?id=_3331-覆盖误差)
-        *   [3.3.3.2\. 标签排名平均精度](/docs/36?id=_3332-标签排名平均精度)
-        *   [3.3.3.3\. 排序损失](/docs/36?id=_3333-排序损失)
-    *   [3.3.4\. 回归指标](/docs/36?id=_334-回归指标)
-        *   [3.3.4.1\. 解释方差得分](/docs/36?id=_3341-解释方差得分)
-        *   [3.3.4.2\. 平均绝对误差](/docs/36?id=_3342-平均绝对误差)
-        *   [3.3.4.3\. 均方误差](/docs/36?id=_3343-均方误差)
-        *   [3.3.4.4\. 均方误差对数](/docs/36?id=_3344-均方误差对数)
-        *   [3.3.4.5\. 中位绝对误差](/docs/36?id=_3345-中位绝对误差)
-        *   [3.3.4.6\. R² score, 可决系数](/docs/36?id=_3346-r²-score,-可决系数)
-    *   [3.3.5\. 聚类指标](/docs/36?id=_335-聚类指标)
-    *   [3.3.6\. 虚拟估计](/docs/36?id=_336-虚拟估计)
-*   [3.4\. 模型持久化](/docs/37?id=_34-模型持久化)
-    *   [3.4.1\. 持久化示例](/docs/37?id=_341-持久化示例)
-    *   [3.4.2\. 安全性和可维护性的局限性](/docs/37?id=_342-安全性和可维护性的局限性)
-*   [3.5\. 验证曲线: 绘制分数以评估模型](/docs/38?id=_35-验证曲线:-绘制分数以评估模型)
-    *   [3.5.1\. 验证曲线](/docs/38?id=_351-验证曲线)
-    *   [3.5.2\. 学习曲线](/docs/38?id=_352-学习曲线)
\ No newline at end of file
+# 3.4\. 模型持久化
+
+校验者:
+        [@why2lyj（Snow Wang）](https://github.com/why2lyj)
+        [@小瑶](https://github.com/apachecn/scikit-learn-doc-zh)
+翻译者:
+        [@那伊抹微笑](https://github.com/apachecn/scikit-learn-doc-zh)
+
+在训练完 scikit-learn 模型之后，最好有一种方法来将模型持久化以备将来使用，而无需重新训练。 以下部分为您提供了有关如何使用 pickle 来持久化模型的示例。 在使用 pickle 序列化时，我们还将回顾一些安全性和可维护性方面的问题。
+
+pickle的另一种方法是使用[相关项目](https://scikit-learn.org/stable/related_projects.html#related-projects)中列出的模型导出工具之一将模型导出为另一种格式。与pickle不同，一旦导出，就不能恢复完整的Scikit-learn estimator对象，但是可以部署模型进行预测，通常可以使用支持开放模型交换格式的工具，如“[ONNX](https://scikit-learn.org/stable/modules/model_persistence.html#id2)”或“[PMML](https://scikit-learn.org/stable/modules/model_persistence.html#id4)”。
+
+## 3.4.1\. 持久化示例
+
+可以通过使用 Python 的内置持久化模型将训练好的模型保存在 scikit 中，它名为 [pickle](https://docs.python.org/2/library/pickle.html):
+
+```py
+>>> from sklearn import svm
+>>> from sklearn import datasets
+>>> clf = svm.SVC()
+>>> iris = datasets.load_iris()
+>>> X, y = iris.data, iris.target
+>>> clf.fit(X, y)
+SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
+ decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',
+ max_iter=-1, probability=False, random_state=None, shrinking=True,
+ tol=0.001, verbose=False)
+
+>>> import pickle
+>>> s = pickle.dumps(clf)
+>>> clf2 = pickle.loads(s)
+>>> clf2.predict(X[0:1])
+array([0])
+>>> y[0]
+0
+
+```
+
+在这个 scikit 的特殊示例中，使用 joblib 来替换 pickle（`joblib.dump` & `joblib.load`）可能会更有意思，这对于内部带有 numpy 数组的对象来说更为高效， 通常情况下适合 scikit-learn estimators（预估器），但是也只能是 pickle 到硬盘而不是字符串:
+
+```py
+>>> from sklearn.externals import joblib
+>>> joblib.dump(clf, 'filename.pkl')
+
+```
+
+之后你可以使用以下方式回调 pickled model 可能在另一个 Python 进程中）:
+
+```py
+>>> clf = joblib.load('filename.pkl')
+
+```
+
+>**注意**
+>`joblib.dump` 和 `joblib.load` 函数也接收类似 file-like 的对象而不是文件名。 更多有关使用 Joblib 来持久化数据的信息可以参阅 [这里](https://pythonhosted.org/joblib/persistence.html).
+
+## 3.4.2\. 安全性和可维护性的局限性
+
+pickle（和通过扩展的 joblib），在安全性和可维护性方面存在一些问题。 有以下原因，
+
+*   绝对不要使用未经 pickle 的不受信任的数据，因为它可能会在加载时执行恶意代码。
+*   虽然一个版本的 scikit-learn 模型可以在其他版本中加载，但这完全不建议并且也是不可取的。 还应该了解到，对于这些数据执行的操作可能会产生不同及意想不到的结果。
+
+为了用以后版本的 scikit-learn 来重构类似的模型, 额外的元数据应该随着 pickled model 一起被保存：
+
+*   训练数据，例如：引用不可变的快照
+*   用于生成模型的 python 源代码
+*   scikit-learn 的各版本以及各版本对应的依赖包
+*   在训练数据的基础上获得的交叉验证得分
+
+这样可以检查交叉验证得分是否与以前相同。
+
+由于模型内部表示可能在两种不同架构上不一样，因此不支持在一个架构上转储模型并将其加载到另一个体系架构上。
+
+如果您想要了解更多关于这些问题以及其它可能的序列化方法，请参阅这个 [Alex Gaynor 的演讲](http://pyvideo.org/video/2566/pickles-are-for-delis-not-software).

docs/37.md

-# 3.4\. 模型持久化
-
-校验者:
-        [@why2lyj（Snow Wang）](https://github.com/why2lyj)
-        [@小瑶](https://github.com/apachecn/scikit-learn-doc-zh)
-翻译者:
-        [@那伊抹微笑](https://github.com/apachecn/scikit-learn-doc-zh)
-
-在训练完 scikit-learn 模型之后，最好有一种方法来将模型持久化以备将来使用，而无需重新训练。 以下部分为您提供了有关如何使用 pickle 来持久化模型的示例。 在使用 pickle 序列化时，我们还将回顾一些安全性和可维护性方面的问题。
-
-## 3.4.1\. 持久化示例
-
-可以通过使用 Python 的内置持久化模型将训练好的模型保存在 scikit 中，它名为 [pickle](https://docs.python.org/2/library/pickle.html):
-
-```py
->>> from sklearn import svm
->>> from sklearn import datasets
->>> clf = svm.SVC()
->>> iris = datasets.load_iris()
->>> X, y = iris.data, iris.target
->>> clf.fit(X, y)
-SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
- decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',
- max_iter=-1, probability=False, random_state=None, shrinking=True,
- tol=0.001, verbose=False)
-
->>> import pickle
->>> s = pickle.dumps(clf)
->>> clf2 = pickle.loads(s)
->>> clf2.predict(X[0:1])
-array([0])
->>> y[0]
-0
-
-```
-
-在这个 scikit 的特殊示例中，使用 joblib 来替换 pickle（`joblib.dump` & `joblib.load`）可能会更有意思，这对于内部带有 numpy 数组的对象来说更为高效， 通常情况下适合 scikit-learn estimators（预估器），但是也只能是 pickle 到硬盘而不是字符串:
-
-```py
->>> from sklearn.externals import joblib
->>> joblib.dump(clf, 'filename.pkl')
-
-```
-
-之后你可以使用以下方式回调 pickled model 可能在另一个 Python 进程中）:
-
-```py
->>> clf = joblib.load('filename.pkl')
-
-```
-
-Note
-
-`joblib.dump` 和 `joblib.load` 函数也接收类似 file-like 的对象而不是文件名。 更多有关使用 Joblib 来持久化数据的信息可以参阅 [这里](https://pythonhosted.org/joblib/persistence.html).
-
-## 3.4.2\. 安全性和可维护性的局限性
-
-pickle（和通过扩展的 joblib），在安全性和可维护性方面存在一些问题。 有以下原因，
-
-*   绝对不要使用未经 pickle 的不受信任的数据，因为它可能会在加载时执行恶意代码。
-*   虽然一个版本的 scikit-learn 模型可以在其他版本中加载，但这完全不建议并且也是不可取的。 还应该了解到，对于这些数据执行的操作可能会产生不同及意想不到的结果。
-
-为了用以后版本的 scikit-learn 来重构类似的模型, 额外的元数据应该随着 pickled model 一起被保存：
-
-*   训练数据，例如：引用不可变的快照
-*   用于生成模型的 python 源代码
-*   scikit-learn 的各版本以及各版本对应的依赖包
-*   在训练数据的基础上获得的交叉验证得分
-
-这样可以检查交叉验证得分是否与以前相同。
-
-由于模型内部表示可能在两种不同架构上不一样，因此不支持在一个架构上转储模型并将其加载到另一个体系架构上。
-
-如果您想要了解更多关于这些问题以及其它可能的序列化方法，请参阅这个 [Alex Gaynor 的演讲](http://pyvideo.org/video/2566/pickles-are-for-delis-not-software).
\ No newline at end of file

docs/38.md

-# 3.5\. 验证曲线: 绘制分数以评估模型
-
-校验者:
-        [@正版乔](https://github.com/apachecn/scikit-learn-doc-zh)
-        [@正版乔](https://github.com/apachecn/scikit-learn-doc-zh)
-        [@小瑶](https://github.com/apachecn/scikit-learn-doc-zh)
-翻译者:
-        [@Xi](https://github.com/apachecn/scikit-learn-doc-zh)
-
-每种估计器都有其优势和缺陷。它的泛化误差可以用偏差、方差和噪声来分解。估计值的 [**](#id2)偏差**是不同训练集的平均误差。估计值的**方差**用来表示它对训练集的 变化有多敏感。噪声是数据的一个属性。
-
-在下面的图中，我们可以看到一个函数 [:math:`f(x) = \cos (\frac{3}{2} \pi x)`_](#id4) 和这个函数的一些噪声样本。 我们用三个不同的估计来拟合函数： 多项式特征为1,4和15的线性回归。我们看到，第一个估计最多只能为样本和真正的函数提供一个很差的拟合 ，因为它太简单了(高偏差），第二个估计几乎完全近似，最后一个估计完全接近训练数据， 但不能很好地拟合真实的函数，即对训练数据的变化（高方差）非常敏感。
-
-[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_underfitting_overfitting_0011.png](img/a6509a4f7b1838eb6d76d30036a00ffd.jpg)](https://scikit-learn.org/stable/auto_examples/model_selection/plot_underfitting_overfitting.html)
-
-偏差和方差是估计所固有的属性，我们通常必须选择合适的学习算法和超参数，以使得偏差和 方差都尽可能的低（参见偏差-方差困境 [`Bias-variance dilemma<https://en.wikipedia.org/wiki/Bias-variance_dilemma>`_](#id10)）。 另一种降低方差的方法是使用更多的训练数据。不论如何，如果真实函数过于复杂并且不能用一个方 差较小的估计值来近似，则只能去收集更多的训练数据。
-
-在一个简单的一维问题中，我们可以很容易看出估计值是否存在偏差或方差。然而，在高维空间中， 模型可能变得非常难以具象化。 出于这种原因，使用以下工具通常是有帮助的。
-
-示例:
-
-*   [Underfitting vs. Overfitting](https://scikit-learn.org/stable/auto_examples/model_selection/plot_underfitting_overfitting.html#sphx-glr-auto-examples-model-selection-plot-underfitting-overfitting-py)
-*   [Plotting Validation Curves](https://scikit-learn.org/stable/auto_examples/model_selection/plot_validation_curve.html#sphx-glr-auto-examples-model-selection-plot-validation-curve-py)
-*   [Plotting Learning Curves](https://scikit-learn.org/stable/auto_examples/model_selection/plot_learning_curve.html#sphx-glr-auto-examples-model-selection-plot-learning-curve-py)
-
-## 3.5.1\. 验证曲线
-
-我们需要一个评分函数（参见模型评估：[模型评估: 量化预测的质量](model_evaluation.html#model-evaluation)）来验证一个模型， 例如分类器的准确性。 选择估计器的多个超参数的正确方法当然是网格搜索或类似方法 （参见调优估计的超参数 [调整估计器的超参数](grid_search.html#grid-search) ），其选择一个或多个验证集上的分数最高的超参数。 请注意，如果我们基于验证分数优化了超参数，则验证分数就有偏差了，并且不再是一个良好的泛化估计。 为了得到正确的泛化估计，我们必须在另一个测试集上计算得分。
-
-然而，绘制单个超参数对训练分数和验证分数的影响，有时有助于发现该估计是否因为某些超参数的值 而出现过拟合或欠拟合。
-
-本例中,下面的方程 [`validation_curve`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.validation_curve.html#sklearn.model_selection.validation_curve "sklearn.model_selection.validation_curve") 能起到如下作用:
-
-```py
->>> import numpy as np
->>> from sklearn.model_selection import validation_curve
->>> from sklearn.datasets import load_iris
->>> from sklearn.linear_model import Ridge
-
-```
-
-```py
->>> np.random.seed(0)
->>> iris = load_iris()
->>> X, y = iris.data, iris.target
->>> indices = np.arange(y.shape[0])
->>> np.random.shuffle(indices)
->>> X, y = X[indices], y[indices]
-
-```
-
-```py
->>> train_scores, valid_scores = validation_curve(Ridge(), X, y, "alpha",
-...                                               np.logspace(-7, 3, 3))
->>> train_scores
-array([[ 0.94...,  0.92...,  0.92...],
- [ 0.94...,  0.92...,  0.92...],
- [ 0.47...,  0.45...,  0.42...]])
->>> valid_scores
-array([[ 0.90...,  0.92...,  0.94...],
- [ 0.90...,  0.92...,  0.94...],
- [ 0.44...,  0.39...,  0.45...]])
-
-```
-
-如果训练得分和验证得分都很低，则估计器是不合适的。如果训练得分高，验证得分低，则估计器过拟合， 否则估计会拟合得很好。通常不可能有较低的训练得分和较高的验证得分。所有三种情况都可以 在下面的图中找到，其中我们改变了数字数据集上 SVM 的参数 ![\gamma](img/6552bde3d3999c1a9728016416932af7.jpg) 。
-
-[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_validation_curve_0011.png](img/d49a868d9c8c944f42202a30647ff7cf.jpg)](https://scikit-learn.org/stable/auto_examples/model_selection/plot_validation_curve.html)
-
-## 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)
-
-我们可能需要使用评估器或者一个当前评估器的参数化形式来学习更复杂概念（例如有一个较低的偏差）。 如果训练样本的最大时，训练分数比验证分数得分大得多，那么增加训练样本很可能会增加泛化能力。 在下面的图中，可以看到支持向量机（SVM）可以从更多的训练样本中获益。
-
-[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_learning_curve_0021.png](img/86d43b01a4c13ac9d69265ff0d546720.jpg)](https://scikit-learn.org/stable/auto_examples/model_selection/plot_learning_curve.html)
-
-我们可以使用:func:[`](#id8)learning_curve`函数来绘制这样一个学习曲线所需的值（已使用的样本数量，训练集 上的平均分数和验证集上的平均分数）:
-
-```py
->>> from sklearn.model_selection import learning_curve
->>> from sklearn.svm import SVC
-
->>> train_sizes, train_scores, valid_scores = learning_curve(
-...     SVC(kernel='linear'), X, y, train_sizes=[50, 80, 110], cv=5)
->>> train_sizes
-array([ 50, 80, 110])
->>> train_scores
-array([[ 0.98...,  0.98 ,  0.98...,  0.98...,  0.98...],
- [ 0.98...,  1\.   ,  0.98...,  0.98...,  0.98...],
- [ 0.98...,  1\.   ,  0.98...,  0.98...,  0.99...]])
->>> valid_scores
-array([[ 1\. ,  0.93...,  1\. ,  1\. ,  0.96...],
- [ 1\. ,  0.96...,  1\. ,  1\. ,  0.96...],
- [ 1\. ,  0.96...,  1\. ,  1\. ,  0.96...]])
-
-```
\ No newline at end of file