boston_housing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 机器学习工程师纳米学位\n",
    "## 模型评价与验证\n",
    "## 项目 1: 预测波士顿房价\n",
    "\n",
    "\n",
    "欢迎来到机器学习工程师纳米学位的第一个项目！在此文件中，有些示例代码已经提供给你，但你还需要实现更多的功能来让项目成功运行。除非有明确要求，你无须修改任何已给出的代码。以**编程练习**开始的标题表示接下来的内容中有需要你必须实现的功能。每一部分都会有详细的指导，需要实现的部分也会在注释中以**TODO**标出。请仔细阅读所有的提示！\n",
    "\n",
    "除了实现代码外，你还**必须**回答一些与项目和实现有关的问题。每一个需要你回答的问题都会以**'问题 X'**为标题。请仔细阅读每个问题，并且在问题后的**'回答'**文字框中写出完整的答案。你的项目将会根据你对问题的回答和撰写代码所实现的功能来进行评分。\n",
    "\n",
    ">**提示：**Code 和 Markdown 区域可通过 **Shift + Enter** 快捷键运行。此外，Markdown可以通过双击进入编辑模式。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 第一步. 导入数据\n",
    "在这个项目中，你将利用马萨诸塞州波士顿郊区的房屋信息数据训练和测试一个模型，并对模型的性能和预测能力进行测试。通过该数据训练后的好的模型可以被用来对房屋做特定预测---尤其是对房屋的价值。对于房地产经纪等人的日常工作来说，这样的预测模型被证明非常有价值。\n",
    "\n",
    "此项目的数据集来自[UCI机器学习知识库(数据集已下线)](https://archive.ics.uci.edu/ml/datasets.html)。波士顿房屋这些数据于1978年开始统计，共506个数据点，涵盖了麻省波士顿不同郊区房屋14种特征的信息。本项目对原始数据集做了以下处理：\n",
    "- 有16个`'MEDV'` 值为50.0的数据点被移除。 这很可能是由于这些数据点包含**遗失**或**看不到的值**。\n",
    "- 有1个数据点的 `'RM'` 值为8.78. 这是一个异常值，已经被移除。\n",
    "- 对于本项目，房屋的`'RM'`， `'LSTAT'`，`'PTRATIO'`以及`'MEDV'`特征是必要的，其余不相关特征已经被移除。\n",
    "- `'MEDV'`特征的值已经过必要的数学转换，可以反映35年来市场的通货膨胀效应。\n",
    "\n",
    "运行下面区域的代码以载入波士顿房屋数据集，以及一些此项目所需的Python库。如果成功返回数据集的大小，表示数据集已载入成功。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 载入此项目所需要的库\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import visuals as vs # Supplementary code\n",
    "\n",
    "# 检查你的Python版本\n",
    "from sys import version_info\n",
    "if version_info.major != 2 and version_info.minor != 7:\n",
    "    raise Exception('请使用Python 2.7来完成此项目')\n",
    "    \n",
    "# 让结果在notebook中显示\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boston housing dataset has 489 data points with 4 variables each.\n"
     ]
    }
   ],
   "source": [
    "# 载入波士顿房屋的数据集\n",
    "data = pd.read_csv('housing.csv')\n",
    "prices = data['MEDV']\n",
    "features = data.drop('MEDV', axis = 1)\n",
    "    \n",
    "# 完成\n",
    "print \"Boston housing dataset has {} data points with {} variables each.\".format(*data.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 第二步. 分析数据\n",
    "在项目的第一个部分，你会对波士顿房地产数据进行初步的观察并给出你的分析。通过对数据的探索来熟悉数据可以让你更好地理解和解释你的结果。\n",
    "\n",
    "由于这个项目的最终目标是建立一个预测房屋价值的模型，我们需要将数据集分为**特征(features)**和**目标变量(target variable)**。\n",
    "- **特征** `'RM'`， `'LSTAT'`，和 `'PTRATIO'`，给我们提供了每个数据点的数量相关的信息。\n",
    "- **目标变量**：` 'MEDV'`，是我们希望预测的变量。\n",
    "\n",
    "他们分别被存在`features`和`prices`两个变量名中。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习 1：基础统计运算\n",
    "你的第一个编程练习是计算有关波士顿房价的描述统计数据。我们已为你导入了` numpy `，你需要使用这个库来执行必要的计算。这些统计数据对于分析模型的预测结果非常重要的。\n",
    "在下面的代码中，你要做的是：\n",
    "- 计算`prices`中的`'MEDV'`的最小值、最大值、均值、中值和标准差；\n",
    "- 将运算结果储存在相应的变量中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statistics for Boston housing dataset:\n",
      "\n",
      "Minimum price: $105,000.00\n",
      "Maximum price: $1,024,800.00\n",
      "Mean price: $454,342.94\n",
      "Median price $438,900.00\n",
      "Standard deviation of prices: $165,171.13\n"
     ]
    }
   ],
   "source": [
    "#TODO 1\n",
    "\n",
    "#目标：计算价值的最小值\n",
    "minimum_price = np.min(prices)\n",
    "\n",
    "#目标：计算价值的最大值\n",
    "maximum_price = np.max(prices)\n",
    "\n",
    "#目标：计算价值的平均值\n",
    "mean_price = np.mean(prices)\n",
    "\n",
    "#目标：计算价值的中值\n",
    "median_price = np.median(prices)\n",
    "\n",
    "#目标：计算价值的标准差\n",
    "std_price = np.std(prices)\n",
    "\n",
    "#目标：输出计算的结果\n",
    "print \"Statistics for Boston housing dataset:\\n\"\n",
    "print \"Minimum price: ${:,.2f}\".format(minimum_price)\n",
    "print \"Maximum price: ${:,.2f}\".format(maximum_price)\n",
    "print \"Mean price: ${:,.2f}\".format(mean_price)\n",
    "print \"Median price ${:,.2f}\".format(median_price)\n",
    "print \"Standard deviation of prices: ${:,.2f}\".format(std_price)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 1 - 特征观察\n",
    "\n",
    "如前文所述，本项目中我们关注的是其中三个值:`'RM'`、`'LSTAT'` 和`'PTRATIO'`，对每一个数据点:\n",
    "- `'RM'` 是该地区中每个房屋的平均房间数量；\n",
    "- `'LSTAT'` 是指该地区有多少百分比的业主属于是低收入阶层（有工作但收入微薄）；\n",
    "- `'PTRATIO'` 是该地区的中学和小学里，学生和老师的数目比（`学生/老师`）。\n",
    "\n",
    "_凭直觉，上述三个特征中对每一个来说，你认为增大该特征的数值，`'MEDV'`的值会是**增大**还是**减小**呢？每一个答案都需要你给出理由。_\n",
    "\n",
    "**提示：**你预期一个`'RM'` 值是6的房屋跟`'RM'` 值是7的房屋相比，价值更高还是更低呢？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 1 - 回答：\n",
    "1. 'RM':增大RM值‘MEDV’会增大，房间数越多相应的房子的面积也越大，房屋的价格也就越高\n",
    "2. 'LSTAT':增大LSTAT值‘MEDV’会减小，一个地区的低收入阶层越多，表明该地区业主平均收入越少，所能负担的房屋价格也就越低\n",
    "3. 'PTRATIO':增大PTRATIO值‘MEDV’会减小，学生和老师的数目比越大，说明该地区教育资源有限，经济发展相对落后，所以房屋价格会较低"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习 2: 数据分割与重排\n",
    "接下来，你需要把波士顿房屋数据集分成训练和测试两个子集。通常在这个过程中，数据也会被重排列，以消除数据集中由于顺序而产生的偏差。\n",
    "在下面的代码中，你需要\n",
    "\n",
    "使用 `sklearn.model_selection` 中的 `train_test_split`， 将`features`和`prices`的数据都分成用于训练的数据子集和用于测试的数据子集。\n",
    "  - 分割比例为：80%的数据用于训练，20%用于测试；\n",
    "  - 选定一个数值以设定 `train_test_split` 中的 `random_state` ，这会确保结果的一致性；"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 2\n",
    "\n",
    "# 提示： 导入train_test_split\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(features, prices, test_size=0.2, random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 2 - 训练及测试\n",
    "*将数据集按一定比例分为训练用的数据集和测试用的数据集对学习算法有什么好处？*\n",
    "\n",
    "*如果用模型已经见过的数据，例如部分训练集数据进行测试，又有什么坏处？*\n",
    "\n",
    "**提示：** 如果没有数据来对模型进行测试，会出现什么问题？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 2 - 回答:\n",
    "好处：能够基于独立的数据集评估分类器或回归的性能；使用各自的训练和测试数据作为过度拟合的检查因素，避免过拟合  \n",
    "坏处：无法很好的评估模型的准确性和是否过拟合,测试集只是测试模型在未知数据的表现，并没有办法改变模型，无法避免过拟合欠拟合，我们只能通过比较比较模型在测试集和训练集的表现，判断是否出现了过拟合或者欠拟合。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 第三步. 模型衡量标准\n",
    "在项目的第三步中，你需要了解必要的工具和技巧来让你的模型进行预测。用这些工具和技巧对每一个模型的表现做精确的衡量可以极大地增强你预测的信心。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习3：定义衡量标准\n",
    "如果不能对模型的训练和测试的表现进行量化地评估，我们就很难衡量模型的好坏。通常我们会定义一些衡量标准，这些标准可以通过对某些误差或者拟合程度的计算来得到。在这个项目中，你将通过运算[*决定系数*](http://stattrek.com/statistics/dictionary.aspx?definition=coefficient_of_determination) R<sup>2</sup> 来量化模型的表现。模型的决定系数是回归分析中十分常用的统计信息，经常被当作衡量模型预测能力好坏的标准。\n",
    "\n",
    "R<sup>2</sup>的数值范围从0至1，表示**目标变量**的预测值和实际值之间的相关程度平方的百分比。一个模型的R<sup>2</sup> 值为0还不如直接用**平均值**来预测效果好；而一个R<sup>2</sup> 值为1的模型则可以对目标变量进行完美的预测。从0至1之间的数值，则表示该模型中目标变量中有百分之多少能够用**特征**来解释。_模型也可能出现负值的R<sup>2</sup>，这种情况下模型所做预测有时会比直接计算目标变量的平均值差很多。_\n",
    "\n",
    "在下方代码的 `performance_metric` 函数中，你要实现：\n",
    "- 使用 `sklearn.metrics` 中的 [`r2_score`](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html) 来计算 `y_true` 和 `y_predict`的R<sup>2</sup>值，作为对其表现的评判。\n",
    "- 将他们的表现评分储存到`score`变量中。\n",
    "\n",
    "或 \n",
    "\n",
    "- (可选) 不使用任何外部库，参考[决定系数的定义](https://en.wikipedia.org/wiki/Coefficient_of_determination)进行计算，这也可以帮助你更好的理解决定系数在什么情况下等于0或等于1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 3\n",
    "\n",
    "# 提示： 导入r2_score\n",
    "from sklearn.metrics import r2_score\n",
    "\n",
    "def performance_metric(y_true, y_predict):\n",
    "    \"\"\"计算并返回预测值相比于预测值的分数\"\"\"\n",
    "    \n",
    "    score = r2_score(y_true, y_predict)\n",
    "\n",
    "    return score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 3 可选\n",
    "\n",
    "# 不允许导入任何计算决定系数的库\n",
    "\n",
    "def performance_metric2(y_true, y_predict):\n",
    "    \"\"\"计算并返回预测值相比于预测值的分数\"\"\"\n",
    "    SSres = 0\n",
    "    SStot = 0\n",
    "    y_true_mean = np.mean(y_true)\n",
    "    for i in range(0 , len(y_true)):  \n",
    "        SSres += (y_predict[i] - y_true[i])*(y_predict[i] - y_true[i])\n",
    "        SStot += (y_true[i] - y_true_mean)*(y_true[i] - y_true_mean)\n",
    "    \n",
    "    score = 1 - SSres/SStot\n",
    "\n",
    "    return score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 3 - 拟合程度\n",
    "\n",
    "假设一个数据集有五个数据且一个模型做出下列目标变量的预测：\n",
    "\n",
    "| 真实数值 | 预测数值 |\n",
    "| :-------------: | :--------: |\n",
    "| 3.0 | 2.5 |\n",
    "| -0.5 | 0.0 |\n",
    "| 2.0 | 2.1 |\n",
    "| 7.0 | 7.8 |\n",
    "| 4.2 | 5.3 |\n",
    "*你觉得这个模型已成功地描述了目标变量的变化吗？如果成功，请解释为什么，如果没有，也请给出原因。*  \n",
    "\n",
    "**提示**：运行下方的代码，使用`performance_metric`函数来计算模型的决定系数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model has a coefficient of determination, R^2, of 0.923.\n"
     ]
    }
   ],
   "source": [
    "# 计算这个模型的预测结果的决定系数\n",
    "score = performance_metric([3, -0.5, 2, 7, 4.2], [2.5, 0.0, 2.1, 7.8, 5.3])\n",
    "print \"Model has a coefficient of determination, R^2, of {:.3f}.\".format(score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 3 - 回答:  \n",
    "这个模型成功地描述了目标的变化，R^2的值大于0.9已经非常接近1了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 第四步. 分析模型的表现\n",
    "在项目的第四步，我们来看一下不同参数下，模型在训练集和验证集上的表现。这里，我们专注于一个特定的算法（带剪枝的决策树，但这并不是这个项目的重点），和这个算法的一个参数 `'max_depth'`。用全部训练集训练，选择不同`'max_depth'` 参数，观察这一参数的变化如何影响模型的表现。画出模型的表现来对于分析过程十分有益，这可以让我们看到一些单看结果看不到的行为。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 学习曲线\n",
    "下方区域内的代码会输出四幅图像，它们是一个决策树模型在不同最大深度下的表现。每一条曲线都直观得显示了随着训练数据量的增加，模型学习曲线的在训练集评分和验证集评分的变化，评分使用决定系数R<sup>2</sup>。曲线的阴影区域代表的是该曲线的不确定性（用标准差衡量）。\n",
    "\n",
    "运行下方区域中的代码，并利用输出的图形回答下面的问题。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xfc3aba8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 根据不同的训练集大小，和最大深度，生成学习曲线\n",
    "vs.ModelLearning(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 4 - 学习曲线\n",
    "*选择上述图像中的其中一个，并给出其最大深度。随着训练数据量的增加，训练集曲线的评分有怎样的变化？验证集曲线呢？如果有更多的训练数据，是否能有效提升模型的表现呢？*\n",
    "\n",
    "**提示：**学习曲线的评分是否最终会收敛到特定的值？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 4 - 回答:  \n",
    "对于图像2，它的最大深度是3，训练集曲线评分稳定在0.8附近并趋于收敛，验证集曲线在0.7附近，没有收敛，如果有更多的训练数据，不能有效提升模型表现，因为从图像上来看两条曲线的距离比较小了，方差小\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 复杂度曲线\n",
    "下列代码内的区域会输出一幅图像，它展示了一个已经经过训练和验证的决策树模型在不同最大深度条件下的表现。这个图形将包含两条曲线，一个是训练集的变化，一个是验证集的变化。跟**学习曲线**相似，阴影区域代表该曲线的不确定性，模型训练和测试部分的评分都用的 `performance_metric` 函数。\n",
    "\n",
    "运行下方区域中的代码，并利用输出的图形并回答下面的两个问题。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xecf3e48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 根据不同的最大深度参数，生成复杂度曲线\n",
    "vs.ModelComplexity(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 5 - 偏差（bias）与方差（variance）之间的权衡取舍\n",
    "*当模型以最大深度 1训练时，模型的预测是出现很大的偏差还是出现了很大的方差？当模型以最大深度10训练时，情形又如何呢？图形中的哪些特征能够支持你的结论？*\n",
    "  \n",
    "**提示：** 你如何得知模型是否出现了偏差很大或者方差很大的问题？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 5 - 回答:  \n",
    "当模型以最大深度 1训练时，模型的预测是出现很大的偏差，因为两条曲线的R2值都比较小；当模型以最大深度 10训练时，模型的预测是出现很大的方差，因为两条曲线的R2值距离较大。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 6- 最优模型的猜测\n",
    "*结合问题 5 中的图，你认为最大深度是多少的模型能够最好地对未见过的数据进行预测？你得出这个答案的依据是什么？*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 6 - 回答:  \n",
    "我认为最大深度是4的模型能够最好地对未见过的数据进行预测，深度4时，模型有较好的准确度：验证R2在0.75附近，没有欠拟合的情况，同时两条曲线的距离不大，方差小，没有出现过拟合的情况。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 第五步. 选择最优参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 7- 网格搜索（Grid Search）\n",
    "*什么是网格搜索法？如何用它来优化模型？*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 7 - 回答:  \n",
    "网格搜索法是指定参数值的一种穷举搜索方法，通过将估计函数的参数通过交叉验证的方法进行优化来得到最优的学习算法。 \n",
    "将各个参数可能的取值进行排列组合，列出所有可能的组合结果生成“网格”。然后将各组合用于模型训练，并使用指定的验证算法对表现进行评估。\n",
    "网格搜索会搜索模型的参数是使用者指定的,不会搜索所有参数,参数的取值范围也是指定的,给出几个可能的最优值进行搜索;\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 8 - 交叉验证\n",
    "- 什么是K折交叉验证法（k-fold cross-validation）？\n",
    "- [GridSearchCV](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html)是如何结合交叉验证来完成对最佳参数组合的选择的？\n",
    "- [GridSearchCV](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html)中的`'cv_results_'`属性能告诉我们什么？\n",
    "- 网格搜索时如果不使用交叉验证会有什么问题？交叉验证又是如何解决这个问题的？\n",
    "\n",
    "**提示：** 在下面 fit_model函数最后加入 `print pd.DataFrame(grid.cv_results_)` 可以帮你查看更多信息。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 8 - 回答：  \n",
    "- K 折交叉验证是将训练集的所有数据分为 K 份（通常选择 K = 10），取第 K 份作为验证集，验证集的作用是：确定网络结构或者控制模型复杂度的参数，剩下的 K-1 份作为交叉验证的训练集\n",
    "- 对每一个参数组合进行一次 K 折交叉验证，得到对应的平均分数；最后选择平均分数最高的参数组合作为模型的最优参数组合\n",
    "- 'cv_results_'属性返回一个字典，记录了每一组网格参数每一次训练/验证( K 折对应 K 次)对应的训练结果，包括训练/验证时间、训练/验证评估分数以及相关时间和评分的统计信息\n",
    "- 如果不使用交叉验证,会有两个问题:1.最终模型与参数的选取将极大程度依赖于你对训练集和测试集的划分方法,不同的数据集划分方法对于模型的性能有很大的影响,如果划分不合理,验证集不具代表性,就会影响模型在未知数据上的表现;2.只使用了部分数据进行模型的训练.当用于模型训练的数据量越大时，训练出来的模型通常效果会越好。所以训练集和测试集按比例划分意味着我们无法充分利用我们手头已有的数据，所以得到的模型效果也会受到一定的影响。  \n",
    "而交叉验证把数据集将所有样本分成K份，一般每份样本的数量相等或相差不多。取一份作为测试样本，剩余K-1份作为训练样本。这个过程重复K次，这样避免了划分数据集时不合理的情况,同时模拟了比实际拥有更多的数据;\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习 4：训练最优模型\n",
    "在这个练习中，你将需要将所学到的内容整合，使用**决策树算法**训练一个模型。为了得出的是一个最优模型，你需要使用网格搜索法训练模型，以找到最佳的 `'max_depth'` 参数。你可以把`'max_depth'` 参数理解为决策树算法在做出预测前，允许其对数据提出问题的数量。决策树是**监督学习算法**中的一种。\n",
    "\n",
    "在下方 `fit_model` 函数中，你需要做的是：\n",
    "1. **定义 `'cross_validator'` 变量**: 使用 `sklearn.model_selection` 中的 [`KFold`](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html) 创建一个交叉验证生成器对象;\n",
    "2. **定义 `'regressor'` 变量**: 使用  `sklearn.tree` 中的 [`DecisionTreeRegressor`](http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html) 创建一个决策树的回归函数;\n",
    "3. **定义 `'params'` 变量**: 为 `'max_depth'` 参数创造一个字典，它的值是从1至10的数组;\n",
    "4. **定义 `'scoring_fnc'` 变量**: 使用 `sklearn.metrics` 中的 [`make_scorer`](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html)  创建一个评分函数；\n",
    " 将 `‘performance_metric’` 作为参数传至这个函数中；\n",
    "5. **定义 `'grid'` 变量**: 使用 `sklearn.model_selection` 中的 [`GridSearchCV`](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html) 创建一个网格搜索对象；将变量`'regressor'`, `'params'`, `'scoring_fnc'`和 `'cross_validator'` 作为参数传至这个对象构造函数中；\n",
    "  \n",
    "如果你对python函数的默认参数定义和传递不熟悉，可以参考这个MIT课程的[视频](http://cn-static.udacity.com/mlnd/videos/MIT600XXT114-V004200_DTH.mp4)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 4\n",
    "\n",
    "#提示: 导入 'KFold' 'DecisionTreeRegressor' 'make_scorer' 'GridSearchCV' \n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.metrics import make_scorer\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "def fit_model(X, y):\n",
    "    \"\"\" 基于输入数据 [X,y]，利于网格搜索找到最优的决策树模型\"\"\"\n",
    "    \n",
    "    cross_validator = KFold()\n",
    "    \n",
    "    regressor = DecisionTreeRegressor()\n",
    "\n",
    "    params = {'max_depth':range(1,11)}\n",
    "\n",
    "    scoring_fnc = make_scorer(performance_metric)\n",
    "\n",
    "    grid = GridSearchCV(regressor,params,scoring = scoring_fnc,cv = cross_validator)\n",
    "\n",
    "    # 基于输入数据 [X,y]，进行网格搜索\n",
    "    grid = grid.fit(X, y)\n",
    "    #print pd.DataFrame(grid.cv_results_)\n",
    "    # 返回网格搜索后的最优模型\n",
    "    return grid.best_estimator_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习 4：训练最优模型 （可选）\n",
    "在这个练习中，你将需要将所学到的内容整合，使用**决策树算法**训练一个模型。为了得出的是一个最优模型，你需要使用网格搜索法训练模型，以找到最佳的 `'max_depth'` 参数。你可以把`'max_depth'` 参数理解为决策树算法在做出预测前，允许其对数据提出问题的数量。决策树是**监督学习算法**中的一种。\n",
    "\n",
    "在下方 `fit_model` 函数中，你需要做的是：\n",
    "\n",
    "- 遍历参数`‘max_depth’`的可选值 1～10，构造对应模型\n",
    "- 计算当前模型的交叉验证分数\n",
    "- 返回最优交叉验证分数对应的模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 4 可选\n",
    "\n",
    "'''\n",
    "不允许使用 DecisionTreeRegressor 以外的任何 sklearn 库\n",
    "\n",
    "提示: 你可能需要实现下面的 cross_val_score 函数\n",
    "\n",
    "def cross_val_score(estimator, X, y, scoring = performance_metric, cv=3):\n",
    "    \"\"\" 返回每组交叉验证的模型分数的数组 \"\"\"\n",
    "    scores = [0,0,0]\n",
    "    return scores\n",
    "'''\n",
    "\n",
    "def fit_model2(X, y):\n",
    "    \"\"\" 基于输入数据 [X,y]，利于网格搜索找到最优的决策树模型\"\"\"\n",
    "    \n",
    "    #最优交叉验证分数对应的最优模型\n",
    "    best_estimator = None\n",
    "    \n",
    "    return best_estimator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 9 - 最优模型\n",
    "*最优模型的最大深度（maximum depth）是多少？此答案与你在**问题 6**所做的猜测是否相同？*\n",
    "\n",
    "运行下方区域内的代码，将决策树回归函数代入训练数据的集合，以得到最优化的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameter 'max_depth' is 4 for the optimal model.\n"
     ]
    }
   ],
   "source": [
    "# 基于训练数据，获得最优模型\n",
    "optimal_reg = fit_model(X_train, y_train)\n",
    "\n",
    "# 输出最优模型的 'max_depth' 参数\n",
    "print \"Parameter 'max_depth' is {} for the optimal model.\".format(optimal_reg.get_params()['max_depth'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 9 - 回答：\n",
    "最优模型的最大深度是4,与问题6猜测一致"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 第六步. 做出预测\n",
    "当我们用数据训练出一个模型，它现在就可用于对新的数据进行预测。在决策树回归函数中，模型已经学会对新输入的数据*提问*，并返回对**目标变量**的预测值。你可以用这个预测来获取数据未知目标变量的信息，这些数据必须是不包含在训练数据之内的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 10 - 预测销售价格\n",
    "想像你是一个在波士顿地区的房屋经纪人，并期待使用此模型以帮助你的客户评估他们想出售的房屋。你已经从你的三个客户收集到以下的资讯:\n",
    "\n",
    "| 特征 | 客戶 1 | 客戶 2 | 客戶 3 |\n",
    "| :---: | :---: | :---: | :---: |\n",
    "| 房屋内房间总数 | 5 间房间 | 4 间房间 | 8 间房间 |\n",
    "| 社区贫困指数（％被认为是贫困阶层） | 17% | 32% | 3% |\n",
    "| 邻近学校的学生-老师比例 | 15：1 | 22：1 | 12：1 |\n",
    "\n",
    "*你会建议每位客户的房屋销售的价格为多少？从房屋特征的数值判断，这样的价格合理吗？为什么？* \n",
    "\n",
    "**提示：**用你在**分析数据**部分计算出来的统计信息来帮助你证明你的答案。\n",
    "\n",
    "运行下列的代码区域，使用你优化的模型来为每位客户的房屋价值做出预测。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted selling price for Client 1's home: $411,417.39\n",
      "Predicted selling price for Client 2's home: $230,828.57\n",
      "Predicted selling price for Client 3's home: $937,230.00\n"
     ]
    }
   ],
   "source": [
    "# 生成三个客户的数据\n",
    "client_data = [[5, 17, 15], # 客户 1\n",
    "               [4, 32, 22], # 客户 2\n",
    "               [8, 3, 12]]  # 客户 3\n",
    "\n",
    "# 进行预测\n",
    "predicted_price = optimal_reg.predict(client_data)\n",
    "for i, price in enumerate(predicted_price):\n",
    "    print \"Predicted selling price for Client {}'s home: ${:,.2f}\".format(i+1, price)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 10 - 回答：\n",
    "我建议的房屋售价分别为:  411,417.39,  230,828.57, 937,230.00  \n",
    "通过房屋特征分析,房间数越多房价越高(客户3房间数8最高),贫困指数越高房屋价格越低(客户2贫困指数32%),教育资源也对房价有影响(3>1>2),综合三个特征向量的分析来看，模型预测出的结果是合理的。  \n",
    "该地区房屋的平均房价为:454,342.94,最小值为:105,000,最大值为:1,024,800,可以看到预测的三个房屋的价格都在合理范围内."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习 5\n",
    "你刚刚预测了三个客户的房子的售价。在这个练习中，你将用你的最优模型在整个测试数据上进行预测, 并计算相对于目标变量的决定系数 R<sup>2</sup>的值**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal model has R^2 score 0.80 on test data\n"
     ]
    }
   ],
   "source": [
    "#TODO 5\n",
    "\n",
    "# 提示：你可能需要用到 X_test, y_test, optimal_reg, performance_metric\n",
    "# 提示：你可能需要参考问题10的代码进行预测\n",
    "# 提示：你可能需要参考问题3的代码来计算R^2的值\n",
    "\n",
    "r2 = performance_metric(y_test,optimal_reg.predict(X_test))\n",
    "\n",
    "print \"Optimal model has R^2 score {:,.2f} on test data\".format(r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题11 - 分析决定系数\n",
    "\n",
    "你刚刚计算了最优模型在测试集上的决定系数，你会如何评价这个结果？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题11 - 回答  \n",
    "决定系数为0.8,说明模型性能较好"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 模型健壮性\n",
    "\n",
    "一个最优的模型不一定是一个健壮模型。有的时候模型会过于复杂或者过于简单，以致于难以泛化新增添的数据；有的时候模型采用的学习算法并不适用于特定的数据结构；有的时候样本本身可能有太多噪点或样本过少，使得模型无法准确地预测目标变量。这些情况下我们会说模型是欠拟合的。\n",
    "\n",
    "### 问题 12 - 模型健壮性\n",
    "\n",
    "模型是否足够健壮来保证预测的一致性？\n",
    "\n",
    "**提示**: 执行下方区域中的代码，采用不同的训练和测试集执行 `fit_model` 函数10次。注意观察对一个特定的客户来说，预测是如何随训练数据的变化而变化的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trial 1: $409,500.00\n",
      "Trial 2: $411,417.39\n",
      "Trial 3: $415,800.00\n",
      "Trial 4: $428,316.00\n",
      "Trial 5: $413,334.78\n",
      "Trial 6: $411,931.58\n",
      "Trial 7: $399,663.16\n",
      "Trial 8: $407,232.00\n",
      "Trial 9: $402,531.82\n",
      "Trial 10: $413,700.00\n",
      "\n",
      "Range in prices: $28,652.84\n"
     ]
    }
   ],
   "source": [
    "# 请先注释掉 fit_model 函数里的所有 print 语句\n",
    "vs.PredictTrials(features, prices, fit_model, client_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 12 - 回答：\n",
    "预测结果收敛在40w左右,说明模型健壮"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 13 - 实用性探讨\n",
    "*简单地讨论一下你建构的模型能否在现实世界中使用？* \n",
    "\n",
    "提示：回答以下几个问题，并给出相应结论的理由：\n",
    "- *1978年所采集的数据，在已考虑通货膨胀的前提下，在今天是否仍然适用？*\n",
    "- *数据中呈现的特征是否足够描述一个房屋？*\n",
    "- *在波士顿这样的大都市采集的数据，能否应用在其它乡镇地区？*\n",
    "- *你觉得仅仅凭房屋所在社区的环境来判断房屋价值合理吗？*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 13 - 回答：\n",
    "- 不适用,地区可能发生的较大的变化,包括但不限于:富裕程度,教育水平,医疗,房屋新旧\n",
    "- 不足够,影响房屋价格的因素还有很多,比如:年龄,治安,装修.....\n",
    "- 不能,不同的地区影响房屋价格的特性也不同\n",
    "- 不合理,影响房屋价格的因素还有很多,比如:年龄,治安,装修....."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 可选问题 - 预测北京房价\n",
    "\n",
    "（本题结果不影响项目是否通过）通过上面的实践，相信你对机器学习的一些常用概念有了很好的领悟和掌握。但利用70年代的波士顿房价数据进行建模的确对我们来说意义不是太大。现在你可以把你上面所学应用到北京房价数据集中 `bj_housing.csv`。\n",
    "\n",
    "免责声明：考虑到北京房价受到宏观经济、政策调整等众多因素的直接影响，预测结果仅供参考。\n",
    "\n",
    "这个数据集的特征有：\n",
    "- Area：房屋面积，平方米\n",
    "- Room：房间数，间\n",
    "- Living: 厅数，间\n",
    "- School: 是否为学区房，0或1\n",
    "- Year: 房屋建造时间，年\n",
    "- Floor: 房屋所处楼层，层\n",
    "\n",
    "目标变量：\n",
    "- Value: 房屋人民币售价，万\n",
    "\n",
    "你可以参考上面学到的内容，拿这个数据集来练习数据分割与重排、定义衡量标准、训练模型、评价模型表现、使用网格搜索配合交叉验证对参数进行调优并选出最佳参数，比较两者的差别，最终得出最佳模型对验证集的预测分数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 6\n",
    "\n",
    "# 你的代码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题14 - 北京房价预测\n",
    "你成功的用新的数据集构建了模型了吗？他能对测试数据进行验证吗？它的表现是否符合你的预期？交叉验证是否有助于提升你模型的表现？\n",
    "\n",
    "**提示：**如果你是从零开始构建机器学习的代码会让你一时觉得无从下手。这时不要着急，你要做的只是查看之前写的代码，把每一行都看明白，然后逐步构建你的模型。当中遇到什么问题也可以在我们论坛寻找答案。也许你会发现你所构建的模型的表现并没有达到你的预期，这说明机器学习并非是一项简单的任务，构建一个表现良好的模型需要长时间的研究和测试。这也是我们接下来的课程中会逐渐学到的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题14 - 回答"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}