notebooks/05.03-Hyperparameters-and-Model-Validation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Scikit-Learn简介](05.02-Introducing-Scikit-Learn.ipynb) | [目录](Index.ipynb) | [特征工程](05.04-Feature-Engineering.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/wangyingsm/Python-Data-Science-Handbook/blob/master/notebooks/05.03-Hyperparameters-and-Model-Validation.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hyperparameters and Model Validation\n",
    "\n",
    "# 超参数和模型验证"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "> In the previous section, we saw the basic recipe for applying a supervised machine learning model:\n",
    "\n",
    "> 1. Choose a class of model\n",
    "2. Choose model hyperparameters\n",
    "3. Fit the model to the training data\n",
    "4. Use the model to predict labels for new data\n",
    "\n",
    "上一节中，我们学习了应用有监督机器学习模型的基本配方：\n",
    "\n",
    "1. 选择一个模型类别\n",
    "2. 选择模型超参数\n",
    "3. 将模型拟合到训练数据上\n",
    "4. 将模型在新数据上进行预测\n",
    "\n",
    "> The first two pieces of this—the choice of model and choice of hyperparameters—are perhaps the most important part of using these tools and techniques effectively.\n",
    "In order to make an informed choice, we need a way to *validate* that our model and our hyperparameters are a good fit to the data.\n",
    "While this may sound simple, there are some pitfalls that you must avoid to do this effectively.\n",
    "\n",
    "上面的前两步，选择模型类别和超参数，也许是有效使用这些工具和技术的最关键部分。为了作出一个明智的选择，我们需要一个方式来*验证*我们的模型和超参数，看它们是否拟合数据集。虽然这个方式听起来很简单，但是里面有很多坑你需要避开。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Thinking about Model Validation\n",
    "\n",
    "## 思考模型验证\n",
    "\n",
    "> In principle, model validation is very simple: after choosing a model and its hyperparameters, we can estimate how effective it is by applying it to some of the training data and comparing the prediction to the known value.\n",
    "\n",
    "原则上，模型验证非常简单：选择了模型类别和它的超参数之后，我们将它应用到一些训练数据上进行训练，然后将它的预测值和已知值进行比较。\n",
    "\n",
    "> The following sections first show a naive approach to model validation and why it\n",
    "fails, before exploring the use of holdout sets and cross-validation for more robust\n",
    "model evaluation.\n",
    "\n",
    "下面首先介绍一个原始的模型验证方法和为什么它不正确，然后再介绍使用预留的子集及交叉验证方法来获得更健壮的模型评估结果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model validation the wrong way\n",
    "\n",
    "### 错误的模型验证\n",
    "\n",
    "> Let's demonstrate the naive approach to validation using the Iris data, which we saw in the previous section.\n",
    "We will start by loading the data:\n",
    "\n",
    "让我们展示使用鸢尾花数据集来进行模型验证的一个原始方法，首先导入数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "iris = load_iris()\n",
    "X = iris.data\n",
    "y = iris.target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Next we choose a model and hyperparameters. Here we'll use a *k*-neighbors classifier with ``n_neighbors=1``.\n",
    "This is a very simple and intuitive model that says \"the label of an unknown point is the same as the label of its closest training point:\"\n",
    "\n",
    "下面我们选择模型和超参数。这里我们会使用*k近邻*分类器，超参数`n_neighbors=1`。这是一个非常简单和直观的模型，它认为“未知的点的标签与距离它最近的训练点的标签是一样的”。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "model = KNeighborsClassifier(n_neighbors=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Then we train the model, and use it to predict labels for data we already know:\n",
    "\n",
    "然后我们训练模型，用训练好的模型来预测训练集的标签："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(X, y)\n",
    "y_model = model.predict(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Finally, we compute the fraction of correctly labeled points:\n",
    "\n",
    "最后，我们计算得到准确率："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "accuracy_score(y, y_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We see an accuracy score of 1.0, which indicates that 100% of points were correctly labeled by our model!\n",
    "But is this truly measuring the expected accuracy? Have we really come upon a model that we expect to be correct 100% of the time?\n",
    "\n",
    "我们看到准确率是1.0，这表示100%的点都被我们的模型正确标记了。但是这是否代表这我们模型真实的准确率？我们是否真的能碰到一个模型能够100%正确的处理所有数据？\n",
    "\n",
    "> As you may have gathered, the answer is no.\n",
    "In fact, this approach contains a fundamental flaw: *it trains and evaluates the model on the same data*.\n",
    "Furthermore, the nearest neighbor model is an *instance-based* estimator that simply stores the training data, and predicts labels by comparing new data to these stored points: except in contrived cases, it will get 100% accuracy *every time!*\n",
    "\n",
    "你直觉上应该就能知道答案是否定的。事实上，这个方法有着一个最基本的错误：*使用同样的数据集来训练和评估性能*。并且，最近邻模型是一个*基于实例*的评估器保存训练数据，然后将这些新数据和保存的数据点进行比较来预测标签：除非在人为干预情况下，它总是会获得100%的准确率。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model validation the right way: Holdout sets\n",
    "\n",
    "### 模型验证的正确方式：保留部分数据\n",
    "\n",
    "> So what can be done?\n",
    "A better sense of a model's performance can be found using what's known as a *holdout set*: that is, we hold back some subset of the data from the training of the model, and then use this holdout set to check the model performance.\n",
    "This splitting can be done using the ``train_test_split`` utility in Scikit-Learn:\n",
    "\n",
    "那么应该怎么做？将一部分数据集*保留*出来不参与训练，并使用它们对模型的性能进行评估才是正确的办法：意思就是我们将数据中的部分子集从训练集中分离出来，然后再将它们预测的结果和预先标记的结果进行对比得到模型性能。这可以通过Scikit-Learn的`train_test_split`工具完成："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9066666666666666"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "# 将数据集按照50%分成两个子集-训练集和测试集\n",
    "X1, X2, y1, y2 = train_test_split(X, y, random_state=0,\n",
    "                                  train_size=0.5)\n",
    "\n",
    "# 使用训练集对模型进行拟合\n",
    "model.fit(X1, y1)\n",
    "\n",
    "# 使用模型对测试集进行预测，并评估结果\n",
    "y2_model = model.predict(X2)\n",
    "accuracy_score(y2, y2_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We see here a more reasonable result: the nearest-neighbor classifier is about 90% accurate on this hold-out set.\n",
    "The hold-out set is similar to unknown data, because the model has not \"seen\" it before.\n",
    "\n",
    "这样我们就得到了一个更加合理的结果：最近邻分类器在这样划分了训练集和测试集后，能得到大约90%的准确率。这里保留出的子数据集类似未知的数据，因为模型根本没有*见过*它们。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model validation via cross-validation\n",
    "\n",
    "### 对模型使用交叉验证\n",
    "\n",
    "> One disadvantage of using a holdout set for model validation is that we have lost a portion of our data to the model training.\n",
    "In the above case, half the dataset does not contribute to the training of the model!\n",
    "This is not optimal, and can cause problems – especially if the initial set of training data is small.\n",
    "\n",
    "上面的保留子数据集来验证模型的方式有一个缺点，那就是我们其中一部分的数据无法参与模型训练过程。在上面例子中，一半的数据集对于训练模型没有任何贡献。这不是最优化的方式，而且可能导致问题，特别是原始训练数据规模比较小的情况下。\n",
    "\n",
    "> One way to address this is to use *cross-validation*; that is, to do a sequence of fits where each subset of the data is used both as a training set and as a validation set.\n",
    "Visually, it might look something like this:\n",
    "\n",
    "解决这个缺点的方法是使用*交叉验证*；也就是使用一系列的拟合过程，其中每次拟合的时候都是用完整的数据集，但是不同的训练集和测试集来进行验证。下面描绘了这个过程：\n",
    "\n",
    "![](figures/05.03-2-fold-CV.png)\n",
    "[附录中生成图像的代码](06.00-Figure-Code.ipynb#2-Fold-Cross-Validation)\n",
    "\n",
    "> Here we do two validation trials, alternately using each half of the data as a holdout set.\n",
    "Using the split data from before, we could implement it like this:\n",
    "\n",
    "这里我们使用两次验证过程，每次使用不同的一半数据作为保留的数据集来验证模型。使用上面分好的数据，我们使用下面的代码实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.96, 0.9066666666666666)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y2_model = model.fit(X1, y1).predict(X2)\n",
    "y1_model = model.fit(X2, y2).predict(X1)\n",
    "accuracy_score(y1, y1_model), accuracy_score(y2, y2_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> What comes out are two accuracy scores, which we could combine (by, say, taking the mean) to get a better measure of the global model performance.\n",
    "This particular form of cross-validation is a *two-fold cross-validation*—that is, one in which we have split the data into two sets and used each in turn as a validation set.\n",
    "\n",
    "上面输出了两个准确率结果，我们可以组合（例如通过取平均值）来获得更好的全局性能结果。上面这个特殊的交叉验证过程被称为*双重检查验证*，也就是我们将数据均分为两个子数据集，然后依次使用它们作为测试集。\n",
    "\n",
    "> We could expand on this idea to use even more trials, and more folds in the data—for example, here is a visual depiction of five-fold cross-validation:\n",
    "\n",
    "我们可以将这个方法扩展到更多的拟合过程，将数据划分为更多子集进行更多重训练验证，例如下图是一个五重交叉验证：\n",
    "\n",
    "![](figures/05.03-5-fold-CV.png)\n",
    "[附录中生成图像的代码](06.00-Figure-Code.ipynb#5-Fold-Cross-Validation)\n",
    "\n",
    "> Here we split the data into five groups, and use each of them in turn to evaluate the model fit on the other 4/5 of the data.\n",
    "This would be rather tedious to do by hand, and so we can use Scikit-Learn's ``cross_val_score`` convenience routine to do it succinctly:\n",
    "\n",
    "这里我们将数据分成5组，每次使用其中一组来评估模型，其余的4/5用来训练模型。每次都要手动完成这项工作是很无聊的，因此我们可以使用Scikit-Learn的`cross_val_score`工具来直接完成它："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.96666667, 0.96666667, 0.93333333, 0.93333333, 1.        ])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(model, X, y, cv=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Repeating the validation across different subsets of the data gives us an even better idea of the performance of the algorithm.\n",
    "\n",
    "使用不同的子数据集重复对模型进行验证能为我们提供更好的算法性能结果。\n",
    "\n",
    "> Scikit-Learn implements a number of useful cross-validation schemes that are useful in particular situations; these are implemented via iterators in the ``cross_validation`` module.\n",
    "For example, we might wish to go to the extreme case in which our number of folds is equal to the number of data points: that is, we train on all points but one in each trial.\n",
    "This type of cross-validation is known as *leave-one-out* cross validation, and can be used as follows:\n",
    "\n",
    "Scikit-Learn实现了许多有用的交叉验证方案，它们适合于特定的场景；这些方案都是在`model_selection`模块中实现的。例如，我们可能希望采用一种极端的方案，该方案中数据的分组等于数据的样本数：也就是说，我们使用除了一个数据点外的其他所有数据进行训练。这种交叉验证被成为*leave-one-out*交叉验证，如下例：\n",
    "\n",
    "译者注：本翻译将所有旧版的`cross_validation`模块改为了`model_selection`模块，下面的LeaveOneOut实例化也修改为无参数的新版本。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 0., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import LeaveOneOut\n",
    "scores = cross_val_score(model, X, y, cv=LeaveOneOut())\n",
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Because we have 150 samples, the leave one out cross-validation yields scores for 150 trials, and the score indicates either successful (1.0) or unsuccessful (0.0) prediction.\n",
    "Taking the mean of these gives an estimate of the error rate:\n",
    "\n",
    "因为我们有150个样本，leave-one-out交叉验证会得到150个验证结果，结果只有两种状态：验证成功（1.0）或验证失败（0.0）。对上面的结果数组求平均值能得到一个估计的准确率："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.96"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Other cross-validation schemes can be used similarly.\n",
    "For a description of what is available in Scikit-Learn, use IPython to explore the ``sklearn.cross_validation`` submodule, or take a look at Scikit-Learn's online [cross-validation documentation](http://scikit-learn.org/stable/modules/cross_validation.html).\n",
    "\n",
    "其他交叉验证方案也是类似的使用。想要查阅Scikit-Learn中可用的交叉验证方案，可以使用IPython来浏览`sklean.model_selection`模块或者浏览Scikit-Learn在线[交叉验证文档](http://scikit-learn.org/stable/modules/cross_validation.html)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selecting the Best Model\n",
    "\n",
    "## 选择最佳模型\n",
    "\n",
    "> Now that we've seen the basics of validation and cross-validation, we will go into a litte more depth regarding model selection and selection of hyperparameters.\n",
    "These issues are some of the most important aspects of the practice of machine learning, and I find that this information is often glossed over in introductory machine learning tutorials.\n",
    "\n",
    "我们已经学习了模型验证和交叉验证的基础，现在可以继续深入了解模型选择和超参数选择的内容。这些话题是机器学习实践中最重要的一些内容，作者发现这部分信息经常在机器学习入门教程中被一笔带过。\n",
    "\n",
    "> Of core importance is the following question: *if our estimator is underperforming, how should we move forward?*\n",
    "There are several possible answers:\n",
    "\n",
    "> - Use a more complicated/more flexible model\n",
    "- Use a less complicated/less flexible model\n",
    "- Gather more training samples\n",
    "- Gather more data to add features to each sample\n",
    "\n",
    "其中的核心问题是：*我们的评估器是否表现不佳？我们应该如何继续改进？*这可能有如下的答案：\n",
    "\n",
    "- 使用一个更加复杂或更加灵活的模型\n",
    "- 使用一个没那么复杂或没那么灵活的模型\n",
    "- 收集更多的训练样本\n",
    "- 对每个样本收集更多信息，增加特征\n",
    "\n",
    "> The answer to this question is often counter-intuitive.\n",
    "In particular, sometimes using a more complicated model will give worse results, and adding more training samples may not improve your results!\n",
    "The ability to determine what steps will improve your model is what separates the successful machine learning practitioners from the unsuccessful.\n",
    "\n",
    "对这个问题的解答经常是反直觉的。比方说有时使用一个更复杂的模型可能会得到一个更差的结果，而增加样本数量不能改进你的结果。决定采用哪些方法步骤来改进模型的能力是成功的机器学习实践者和不成功的实践者之间的主要区别。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Bias-variance trade-off\n",
    "\n",
    "### 偏差方差的权衡\n",
    "\n",
    "> Fundamentally, the question of \"the best model\" is about finding a sweet spot in the tradeoff between *bias* and *variance*.\n",
    "Consider the following figure, which presents two regression fits to the same dataset:\n",
    "\n",
    "“最佳模型”问题根本上是关于寻找*偏差*和*方差*的最佳均衡点。考虑下图，这是对同一个数据集的两个回归：\n",
    "\n",
    "![](figures/05.03-bias-variance.png)\n",
    "[附录中生成图像的代码](06.00-Figure-Code.ipynb#Bias-Variance-Tradeoff)\n",
    "\n",
    "> It is clear that neither of these models is a particularly good fit to the data, but they fail in different ways.\n",
    "\n",
    "很明显这两个模型都不是拟合数据的最佳模型，但是它们失败的地方是不一样的。\n",
    "\n",
    "> The model on the left attempts to find a straight-line fit through the data.\n",
    "Because the data are intrinsically more complicated than a straight line, the straight-line model will never be able to describe this dataset well.\n",
    "Such a model is said to *underfit* the data: that is, it does not have enough model flexibility to suitably account for all the features in the data; another way of saying this is that the model has high *bias*.\n",
    "\n",
    "左边的模型试图找出一条直线来拟合数据。因为这个数据很明显比直线要复杂的多，因此直线模型不可能很好的描述这个数据集。这样的模型我们称为“欠拟合”：也就是说，它没有提供足够的模型灵活性来反映出数据的所有特征；用另一种说法就是这个模型有着高的*偏差*。\n",
    "\n",
    "> The model on the right attempts to fit a high-order polynomial through the data.\n",
    "Here the model fit has enough flexibility to nearly perfectly account for the fine features in the data, but even though it very accurately describes the training data, its precise form seems to be more reflective of the particular noise properties of the data rather than the intrinsic properties of whatever process generated that data.\n",
    "Such a model is said to *overfit* the data: that is, it has so much model flexibility that the model ends up accounting for random errors as well as the underlying data distribution; another way of saying this is that the model has high *variance*.\n",
    "\n",
    "右边的模型试图使用一个高阶的多项式来拟合数据。这个模型具有足够的灵活性几乎完美的描述了数据中的特征，虽然它很精确的描述了训练数据，但是它的这种精确性可能更多反映了对数据噪声特征的反映而不是内在主要特征的反映。这样的模型被称为是“过拟合”的：也就是说它有着很好的模型灵活性，甚至反映了数据的随机误差；另一种说法就是这个模型有着高的*方差*。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> To look at this in another light, consider what happens if we use these two models to predict the y-value for some new data.\n",
    "In the following diagrams, the red/lighter points indicate data that is omitted from the training set:\n",
    "\n",
    "从另一个角度来看，如果我们使用这两个模型来预测一些新数据的y值的话，下图中的红色的点代表这数据中从训练集中分出来的数据点：\n",
    "\n",
    "![](figures/05.03-bias-variance-2.png)\n",
    "[附录中生成图像的代码](06.00-Figure-Code.ipynb#Bias-Variance-Tradeoff-Metrics)\n",
    "\n",
    "> The score here is the $R^2$ score, or [coefficient of determination](https://en.wikipedia.org/wiki/Coefficient_of_determination), which measures how well a model performs relative to a simple mean of the target values. $R^2=1$ indicates a perfect match, $R^2=0$ indicates the model does no better than simply taking the mean of the data, and negative values mean even worse models.\n",
    "From the scores associated with these two models, we can make an observation that holds more generally:\n",
    "\n",
    "> - For high-bias models, the performance of the model on the validation set is similar to the performance on the training set.\n",
    "- For high-variance models, the performance of the model on the validation set is far worse than the performance on the training set.\n",
    "\n",
    "这里使用的评估标准是$R^2$分值，或者称为[决定系数](https://en.wikipedia.org/wiki/Coefficient_of_determination)，计算的是相对目标值的简单平均值差距，用来衡量模型预测性能的好方法。$R^2=1$代表完全复合，$R^2=0$代表模型与简单取数据平均值没有区别，负数值代表模型的表现还不如简单取平均值。从两个模型的这个分值中，我们可以得到更普遍的结论：\n",
    "\n",
    "- 对于高偏差的模型来说，模型的性能在测试集上与在训练集上类似。\n",
    "- 对于高方差的模型来说，模型的性能在测试集上比在训练集上差了非常多。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> If we imagine that we have some ability to tune the model complexity, we would expect the training score and validation score to behave as illustrated in the following figure:\n",
    "\n",
    "如果想象我们有某种能力能够调节模型的复杂度，我们可以绘制下面的图形代表着训练分数和测试分数的情况：\n",
    "\n",
    "![](figures/05.03-validation-curve.png)\n",
    "[附录中生成图像的代码](06.00-Figure-Code.ipynb#Validation-Curve)\n",
    "\n",
    "> The diagram shown here is often called a *validation curve*, and we see the following essential features:\n",
    "\n",
    "> - The training score is everywhere higher than the validation score. This is generally the case: the model will be a better fit to data it has seen than to data it has not seen.\n",
    "- For very low model complexity (a high-bias model), the training data is under-fit, which means that the model is a poor predictor both for the training data and for any previously unseen data.\n",
    "- For very high model complexity (a high-variance model), the training data is over-fit, which means that the model predicts the training data very well, but fails for any previously unseen data.\n",
    "- For some intermediate value, the validation curve has a maximum. This level of complexity indicates a suitable trade-off between bias and variance.\n",
    "\n",
    "这幅图像通常被称为*验证曲线*，我们观察到下面这些关键特征：\n",
    "\n",
    "- 训练分数在任何地方都比验证分数要高。这基于：模型在它见过的数据上会比它没见过的数据上更加拟合。\n",
    "- 对于低复杂度模型（高偏差模型）来说，训练数据是欠拟合的，这代表着模型既不能很好的预测训练数据也不能很好的预测未知数据。\n",
    "- 对于非常高复杂度模型（高方法模型）来说，训练数据是过拟合的，这代表着模型能非常好的预测训练数据，但是不能很好的预测未知数据。\n",
    "- 对于中间部分来说，验证曲线有一个最大值。这个点代表着偏差和方差的最佳平衡点。\n",
    "\n",
    "> The means of tuning the model complexity varies from model to model; when we discuss individual models in depth in later sections, we will see how each model allows for such tuning.\n",
    "\n",
    "不同的模型有着不同的模型复杂度调整的含义；当我们在后面章节深入讨论单个模型时，我们会看到每种模型在这方面的调整方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Validation curves in Scikit-Learn\n",
    "\n",
    "### Scikit-Learn中的验证曲线\n",
    "\n",
    "> Let's look at an example of using cross-validation to compute the validation curve for a class of models.\n",
    "Here we will use a *polynomial regression* model: this is a generalized linear model in which the degree of the polynomial is a tunable parameter.\n",
    "For example, a degree-1 polynomial fits a straight line to the data; for model parameters $a$ and $b$:\n",
    "\n",
    "下面我们来看一个例子说明使用交叉验证来计算一种模型的验证曲线。这里我们将使用*多项式回归*模型：这是一个广义的线性模型，其中的多项式的阶是可调整的参数。例如，一阶的多项式将数据拟合到一条直线上；模型参数有$a$和$b$：\n",
    "\n",
    "$$\n",
    "y = ax + b\n",
    "$$\n",
    "\n",
    "> A degree-3 polynomial fits a cubic curve to the data; for model parameters $a, b, c, d$:\n",
    "\n",
    "一个三阶的多项式将数据是配到一条三次方程曲线上；模型参数有$a, b, c, d$：\n",
    "\n",
    "$$\n",
    "y = ax^3 + bx^2 + cx + d\n",
    "$$\n",
    "\n",
    "> We can generalize this to any number of polynomial features.\n",
    "In Scikit-Learn, we can implement this with a simple linear regression combined with the polynomial preprocessor.\n",
    "We will use a *pipeline* to string these operations together (we will discuss polynomial features and pipelines more fully in [Feature Engineering](05.04-Feature-Engineering.ipynb)):\n",
    "\n",
    "我们可以推广到任意阶的多项式中。在Scikit-Learn中我们可以通过将线性回归与多项式预处理器结合起来实现这个任务。我们会使用*管道*将这些操作串联起来（我们会在[特征工程](05.04-Feature-Engineering.ipynb)中更详细的讨论多项式特征和管道）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.pipeline import make_pipeline\n",
    "\n",
    "def PolynomialRegression(degree=2, **kwargs):\n",
    "    return make_pipeline(PolynomialFeatures(degree),\n",
    "                         LinearRegression(**kwargs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "> Now let's create some data to which we will fit our model:\n",
    "\n",
    "现在我们让我们创建一些数据来拟合模型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def make_data(N, err=1.0, rseed=1):\n",
    "    # 随机数据取样生成\n",
    "    rng = np.random.RandomState(rseed)\n",
    "    X = rng.rand(N, 1) ** 2\n",
    "    y = 10 - 1. / (X.ravel() + 0.1)\n",
    "    if err > 0:\n",
    "        y += err * rng.randn(N)\n",
    "    return X, y\n",
    "\n",
    "X, y = make_data(40)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We can now visualize our data, along with polynomial fits of several degrees:\n",
    "\n",
    "然后对数据进行可视化，包含着不同阶的多项式匹配结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set()  # 用Seaborn可视化\n",
    "\n",
    "X_test = np.linspace(-0.1, 1.1, 500)[:, None]\n",
    "\n",
    "plt.scatter(X.ravel(), y, color='black')\n",
    "axis = plt.axis()\n",
    "for degree in [1, 3, 5]:\n",
    "    y_test = PolynomialRegression(degree).fit(X, y).predict(X_test)\n",
    "    plt.plot(X_test.ravel(), y_test, label='degree={0}'.format(degree))\n",
    "plt.xlim(-0.1, 1.0)\n",
    "plt.ylim(-2, 12)\n",
    "plt.legend(loc='best');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The knob controlling model complexity in this case is the degree of the polynomial, which can be any non-negative integer.\n",
    "A useful question to answer is this: what degree of polynomial provides a suitable trade-off between bias (under-fitting) and variance (over-fitting)?\n",
    "\n",
    "这个例子中控制模型复杂度的开关就是多项式的阶数，可以使任何非负的整数。这里关键的问题是：哪个阶的多项式在偏差（欠拟合）和方差（过拟合）之间达到了合适的平衡？\n",
    "\n",
    "> We can make progress in this by visualizing the validation curve for this particular data and model; this can be done straightforwardly using the ``validation_curve`` convenience routine provided by Scikit-Learn.\n",
    "Given a model, data, parameter name, and a range to explore, this function will automatically compute both the training score and validation score across the range:\n",
    "\n",
    "我们还可以进一步将这个特殊的数据和模型的验证曲线绘制出来；这可以直接通过Scikit-Learn提供的`validation_curve`工具完成。给定模型、数据、参数名称和一个范围，这个函数能够自动计算范围内所有的训练分数和验证分数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.model_selection import validation_curve\n",
    "degree = np.arange(0, 21)\n",
    "train_score, val_score = validation_curve(PolynomialRegression(), X, y,\n",
    "                                          'polynomialfeatures__degree', degree, cv=7)\n",
    "\n",
    "plt.plot(degree, np.median(train_score, 1), color='blue', label='training score')\n",
    "plt.plot(degree, np.median(val_score, 1), color='red', label='validation score')\n",
    "plt.legend(loc='best')\n",
    "plt.ylim(0, 1)\n",
    "plt.xlabel('degree')\n",
    "plt.ylabel('score');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> This shows precisely the qualitative behavior we expect: the training score is everywhere higher than the validation score; the training score is monotonically improving with increased model complexity; and the validation score reaches a maximum before dropping off as the model becomes over-fit.\n",
    "\n",
    "上图精确的展示了我们期望的定量行为：训练分数在任何地方都高于验证分数；训练分数是一个单调递增函数，随着模型复杂度增加而增加；然而验证分数在达到最大值后会因为过拟合而开始下降。\n",
    "\n",
    "> From the validation curve, we can read-off that the optimal trade-off between bias and variance is found for a third-order polynomial; we can compute and display this fit over the original data as follows:\n",
    "\n",
    "从验证曲线中，我们可以看到最优的偏差和方差平衡出现在三阶的多项式附近；我们可以在原始数据上计算并展示这个模型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X.ravel(), y)\n",
    "lim = plt.axis()\n",
    "y_test = PolynomialRegression(3).fit(X, y).predict(X_test)\n",
    "plt.plot(X_test.ravel(), y_test);\n",
    "plt.axis(lim);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Notice that finding this optimal model did not actually require us to compute the training score, but examining the relationship between the training score and validation score can give us useful insight into the performance of the model.\n",
    "\n",
    "请注意寻找这个最优模型并不需要计算训练分数，但是检验训练分数和验证分数之间的关系能为我们提供模型性能的内在含义。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Curves\n",
    "\n",
    "## 学习曲线\n",
    "\n",
    "> One important aspect of model complexity is that the optimal model will generally depend on the size of your training data.\n",
    "For example, let's generate a new dataset with a factor of five more points:\n",
    "\n",
    "对于模型复杂度来说一个重要的相关性是它依赖于训练数据的规模。例如，我们创建一个数据集，具有5倍数量的样本："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X2, y2 = make_data(200)\n",
    "plt.scatter(X2.ravel(), y2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We will duplicate the preceding code to plot the validation curve for this larger dataset; for reference let's over-plot the previous results as well:\n",
    "\n",
    "我们重复前面的代码来绘制这个大的数据集的验证曲线；为了对比我们将前面的结果也用虚线画出来："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "degree = np.arange(21)\n",
    "train_score2, val_score2 = validation_curve(PolynomialRegression(), X2, y2,\n",
    "                                            'polynomialfeatures__degree', degree, cv=7)\n",
    "\n",
    "plt.plot(degree, np.median(train_score2, 1), color='blue', label='training score')\n",
    "plt.plot(degree, np.median(val_score2, 1), color='red', label='validation score')\n",
    "plt.plot(degree, np.median(train_score, 1), color='blue', alpha=0.3, linestyle='dashed')\n",
    "plt.plot(degree, np.median(val_score, 1), color='red', alpha=0.3, linestyle='dashed')\n",
    "plt.legend(loc='lower center')\n",
    "plt.ylim(0, 1)\n",
    "plt.xlabel('degree')\n",
    "plt.ylabel('score');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The solid lines show the new results, while the fainter dashed lines show the results of the previous smaller dataset.\n",
    "It is clear from the validation curve that the larger dataset can support a much more complicated model: the peak here is probably around a degree of 6, but even a degree-20 model is not seriously over-fitting the data—the validation and training scores remain very close.\n",
    "\n",
    "实线展示新的结果，而虚线展示的是前面小数据集的结果。从验证曲线很明显看出大的数据集能够支持更复杂的模型：上图中的峰值大约出现在阶数6的位置上，但是甚至到了20阶的多项式模型中，也没有出现严重的过拟合，验证分数和训练分数依然很接近。\n",
    "\n",
    "> Thus we see that the behavior of the validation curve has not one but two important inputs: the model complexity and the number of training points.\n",
    "It is often useful to to explore the behavior of the model as a function of the number of training points, which we can do by using increasingly larger subsets of the data to fit our model.\n",
    "A plot of the training/validation score with respect to the size of the training set is known as a *learning curve.*\n",
    "\n",
    "因此我们看到了验证曲线不止有一个而是有两个重要的输入参数：模型复杂度和数据样本量。研究模型的性能与样本量之间的关系函数经常也很有帮助，我们可以通过不断增加数据中用来训练的子数据集规模来进行研究。绘制一幅训练/验证分数随着训练集规模变化的图像被称为*学习曲线*。\n",
    "\n",
    "> The general behavior we would expect from a learning curve is this:\n",
    "\n",
    "> - A model of a given complexity will *overfit* a small dataset: this means the training score will be relatively high, while the validation score will be relatively low.\n",
    "- A model of a given complexity will *underfit* a large dataset: this means that the training score will decrease, but the validation score will increase.\n",
    "- A model will never, except by chance, give a better score to the validation set than the training set: this means the curves should keep getting closer together but never cross.\n",
    "\n",
    "从学习曲线中我们一般可以观察到下面的结论：\n",
    "\n",
    "- 在小数据集的情况下，一个给定复杂度的模型很可能会*过拟合*：这意味着训练分数相对来说比较高而验证分数比较低。\n",
    "- 在大数据集的情况下，一个给定复杂度的模型很可能会*欠拟合*：这意味着训练分数会下降而验证分数会上升。\n",
    "- 一个模型应该永远（除非很偶然的情况下）在训练集给出比测试集更高的分值：这意味着两根曲线会一直接近但是不会相交。\n",
    "\n",
    "> With these features in mind, we would expect a learning curve to look qualitatively like that shown in the following figure:\n",
    "\n",
    "有了上述结论，我们预计的学习曲线如下图："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/05.03-learning-curve.png)\n",
    "[附录中生成图像的代码](06.00-Figure-Code.ipynb#Learning-Curve)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The notable feature of the learning curve is the convergence to a particular score as the number of training samples grows.\n",
    "In particular, once you have enough points that a particular model has converged, *adding more training data will not help you!*\n",
    "The only way to increase model performance in this case is to use another (often more complex) model.\n",
    "\n",
    "学习曲线的一个著名特征就是当训练样本量增加时，两根曲线会收敛。这意味着，一旦你已经有了足够的样本量使得某种模型已经收敛的话，*增加更多的训练数据不会提供任何帮助*。在这种情况下提升模型性能的唯一方法就是使用另一个（通常更复杂）的模型。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning curves in Scikit-Learn\n",
    "\n",
    "### Scikit-Learn中的学习曲线\n",
    "\n",
    "> Scikit-Learn offers a convenient utility for computing such learning curves from your models; here we will compute a learning curve for our original dataset with a second-order polynomial model and a ninth-order polynomial:\n",
    "\n",
    "Scikit-Learn提供了一个方便的工具来计算模型的学习曲线；下面我们计算我们原始数据集在二阶多项式模型和九阶多项式模型上的学习曲线："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.model_selection import learning_curve\n",
    "\n",
    "fig, ax = plt.subplots(1, 2, figsize=(16, 6))\n",
    "fig.subplots_adjust(left=0.0625, right=0.95, wspace=0.1)\n",
    "\n",
    "for i, degree in enumerate([2, 9]):\n",
    "    N, train_lc, val_lc = learning_curve(PolynomialRegression(degree),\n",
    "                                         X, y, cv=7,\n",
    "                                         train_sizes=np.linspace(0.3, 1, 25))\n",
    "\n",
    "    ax[i].plot(N, np.mean(train_lc, 1), color='blue', label='training score')\n",
    "    ax[i].plot(N, np.mean(val_lc, 1), color='red', label='validation score')\n",
    "    ax[i].hlines(np.mean([train_lc[-1], val_lc[-1]]), N[0], N[-1],\n",
    "                 color='gray', linestyle='dashed')\n",
    "\n",
    "    ax[i].set_ylim(0, 1)\n",
    "    ax[i].set_xlim(N[0], N[-1])\n",
    "    ax[i].set_xlabel('training size')\n",
    "    ax[i].set_ylabel('score')\n",
    "    ax[i].set_title('degree = {0}'.format(degree), size=14)\n",
    "    ax[i].legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> This is a valuable diagnostic, because it gives us a visual depiction of how our model responds to increasing training data.\n",
    "In particular, when your learning curve has already converged (i.e., when the training and validation curves are already close to each other) *adding more training data will not significantly improve the fit!*\n",
    "This situation is seen in the left panel, with the learning curve for the degree-2 model.\n",
    "\n",
    "这是一项非常有价值的分析，因为它为我们提供了模型随着训练数据增加发生性能变化的可视化展示。而且当你的学习曲线已经收敛时（例如当训练和验证曲线已经非常接近的情况下）*增加更多的训练数据不会显著的提升拟合度*。这个结论很容易从左图二阶模型的学习曲线中获得。\n",
    "\n",
    "> The only way to increase the converged score is to use a different (usually more complicated) model.\n",
    "We see this in the right panel: by moving to a much more complicated model, we increase the score of convergence (indicated by the dashed line), but at the expense of higher model variance (indicated by the difference between the training and validation scores).\n",
    "If we were to add even more data points, the learning curve for the more complicated model would eventually converge.\n",
    "\n",
    "要提升已经收敛的学习曲线的性能唯一方法就是使用一个不同的（通常更复杂的）模型。我们可以从右图中看到：当使用了复杂的多的模型后，我们将收敛的分数值（使用虚线表示）提升了，付出的代价是更高的模型方差（图中训练曲线和验证曲线的间距）。如果我们继续增加更多的样本，更复杂模型的学习曲线最终也会收敛。\n",
    "\n",
    "> Plotting a learning curve for your particular choice of model and dataset can help you to make this type of decision about how to move forward in improving your analysis.\n",
    "\n",
    "绘制模型和数据集的学习曲线能帮助你作出进一步改善性能的决定。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validation in Practice: Grid Search\n",
    "\n",
    "## 验证实践：网格搜索\n",
    "\n",
    "> The preceding discussion is meant to give you some intuition into the trade-off between bias and variance, and its dependence on model complexity and training set size.\n",
    "In practice, models generally have more than one knob to turn, and thus plots of validation and learning curves change from lines to multi-dimensional surfaces.\n",
    "In these cases, such visualizations are difficult and we would rather simply find the particular model that maximizes the validation score.\n",
    "\n",
    "前面的讨论意在为你提供直观的偏差和方差权衡的知识，它取决于模型复杂度和训练集规模。在实践中，模型通常有多于一个开关进行调节，因此前面关于验证曲线和学习曲线的二维线条就会变成多维平面。在这些情况下，要将它可视化出来是很困难的，并且我们更希望简单的找到特定模型能最大化验证分数。\n",
    "\n",
    "> Scikit-Learn provides automated tools to do this in the grid search module.\n",
    "Here is an example of using grid search to find the optimal polynomial model.\n",
    "We will explore a three-dimensional grid of model features; namely the polynomial degree, the flag telling us whether to fit the intercept, and the flag telling us whether to normalize the problem.\n",
    "This can be set up using Scikit-Learn's ``GridSearchCV`` meta-estimator:\n",
    "\n",
    "Scikit-Learn提供了自动化的工具来完成这项任务，它们在网格搜索模块中。下面是一个使用网格搜索找到最优多项式模型的例子。我们会探索模型特征的一个三维网格；包括多项式阶数，一个是否拟合截距的标志和一个是否归一化问题的标志。这可以通过Scikit-Learn的`GridSearchCV`元评估器来设置："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "param_grid = {'polynomialfeatures__degree': np.arange(21),\n",
    "              'linearregression__fit_intercept': [True, False],\n",
    "              'linearregression__normalize': [True, False]}\n",
    "\n",
    "grid = GridSearchCV(PolynomialRegression(), param_grid, cv=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Notice that like a normal estimator, this has not yet been applied to any data.\n",
    "Calling the ``fit()`` method will fit the model at each grid point, keeping track of the scores along the way:\n",
    "\n",
    "网格搜索模型和普通模型一样，实例化后还未应用到任何数据上。通过调用`fit()`方法会将模型的每个网格点拟合到数据上，同时过程中保存了验证的分数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid.fit(X, y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Now that this is fit, we can ask for the best parameters as follows:\n",
    "\n",
    "拟合完后，我们可以使用下面代码来获得最佳参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'linearregression__fit_intercept': False,\n",
       " 'linearregression__normalize': True,\n",
       " 'polynomialfeatures__degree': 4}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Finally, if we wish, we can use the best model and show the fit to our data using code from before:\n",
    "\n",
    "最终，需要的话，我们可以使用代码将最佳模型、数据及它们的拟合情况绘制出来："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = grid.best_estimator_\n",
    "\n",
    "plt.scatter(X.ravel(), y)\n",
    "lim = plt.axis()\n",
    "y_test = model.fit(X, y).predict(X_test)\n",
    "plt.plot(X_test.ravel(), y_test);\n",
    "plt.axis(lim);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The grid search provides many more options, including the ability to specify a custom scoring function, to parallelize the computations, to do randomized searches, and more.\n",
    "For information, see the examples in [In-Depth: Kernel Density Estimation](05.13-Kernel-Density-Estimation.ipynb) and [Feature Engineering: Working with Images](05.14-Image-Features.ipynb), or refer to Scikit-Learn's [grid search documentation](http://Scikit-Learn.org/stable/modules/grid_search.html).\n",
    "\n",
    "网格搜索提供很多其他参数，包括指定自定义的评分函数，并行化计算和执行随机搜索等等。需要更多信息，参见[深入：核密度估计](05.13-Kernel-Density-Estimation.ipynb)和[特征工程](05.14-Image-Features.ipynb)，或者参考Scikit-Learn的[网格搜索在线文档](http://Scikit-Learn.org/stable/modules/grid_search.html)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "## 总结\n",
    "\n",
    "> In this section, we have begun to explore the concept of model validation and hyperparameter optimization, focusing on intuitive aspects of the bias–variance trade-off and how it comes into play when fitting models to data.\n",
    "In particular, we found that the use of a validation set or cross-validation approach is *vital* when tuning parameters in order to avoid over-fitting for more complex/flexible models.\n",
    "\n",
    "在本节中，我们开始探讨模型验证和超参数优化的概念，聚焦在偏差方差权衡的直观概念和它在模型拟合数据时扮演的角色。特别是，我们强调使用测试集验证和交叉验证方法的重要性，当在复杂/灵活模型中调节参数时要避免过拟合。\n",
    "\n",
    "> In later sections, we will discuss the details of particularly useful models, and throughout will talk about what tuning is available for these models and how these free parameters affect model complexity.\n",
    "Keep the lessons of this section in mind as you read on and learn about these machine learning approaches!\n",
    "\n",
    "在后续章节中，我们会讨论每种模型的细节，并在过程中介绍这些模型可以调节哪些参数以及这些参数如何影响模型复杂度。请将本节的内容牢记，当你在后面继续学习机器学习方法的时候，本节内容会提供重要的帮助。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Scikit-Learn简介](05.02-Introducing-Scikit-Learn.ipynb) | [目录](Index.ipynb) | [特征工程](05.04-Feature-Engineering.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/wangyingsm/Python-Data-Science-Handbook/blob/master/notebooks/05.03-Hyperparameters-and-Model-Validation.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}