1.2-simple-linear-regression-for-car-price-prediction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Simple Linear Regression\n",
    "\n",
    "在上一章中，我们介绍了简单线性回归（Simple Linear Regression）的基本知识。希望帮助你对简单线性回归的原理有了一个大概的了解。\n",
    "\n",
    "现在，我们进入这个教程的第一个实战环节。在这一章中，我们会用Python来分析一个简单的二手车数据库，试着分析车辆使用年限（以下简称“车龄”）和价格的关系。\n",
    "\n",
    "在本章的教程中，你会学到：\n",
    "* 如何将数据可视化，观察数据之间的线性关系\n",
    "* 如何建立简单的线性模型\n",
    "* 如何用建立的模型进行预测\n",
    "* 如何理解模型的结果\n",
    "\n",
    "## 1. 准备工作\n",
    "\n",
    "首先我们来引入这一章需要的Python库，简单介绍一下：\n",
    "* Pandas相当于Python版本的Excel，Python通过Pandas来读取数据。\n",
    "* Matplotlib是数据可视化的工具，就像Excel中各种图表\n",
    "* Numpy是计算工具，它包含一些很方便的计算方法，比如说求和、平均值、中位数等等。\n",
    "* `%matplotlib inline`的目的是让matplotlib做的图在这个notebook里面显示出来。\n",
    "\n",
    "以上工具都是Data Science领域最常用到的工具，大家以后会经常看到。\n",
    "\n",
    "如果你对Pandas和Numpy不是很熟悉，可以参考下面的教程：\n",
    "* [Numpy教程](https://www.machinelearningplus.com/python/101-numpy-exercises-python/)\n",
    "* [Pandas教程](https://www.machinelearningplus.com/python/101-pandas-exercises-python/)\n",
    "\n",
    "但在这个教程中，我们不需要Pandas和Numpy的基础。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 引入各种分析需要的库\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# 这行代码是让matplotlib绘制的图表在notebook中显示出来\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 读取数据\n",
    "\n",
    "接着，我们来读取二手车数据，看一看数据中包含的值。\n",
    "\n",
    "**(1) 读入数据**\n",
    "\n",
    "pd是pandas的简写，我们在引入时用的语句的时候声明了`import pandas as pd`。\n",
    "\n",
    "下面代码第一行使用pandas的read_csv函数，读取了指定路径的csv文件，然后把csv文件中的数据存储在auto_df变量中。\n",
    "\n",
    "此时，auto_df的数据类型叫做dataframe，这是一个类似Excel表格的概念。此处你可以简单理解为auto_df是一个存储在python中的Excel表格，自带一些很方便的函数（比如马上会介绍的head函数）。\n",
    "\n",
    "`index_col=0`的意思是将数据表的第0列作为索引。你可以看到粗体的黑色数字，他们是csv文件中的第0列的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "auto_df = pd.read_csv('./data/auto_simple.csv', index_col=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(2) 显示数据**\n",
    "\n",
    "`head()`函数可以打印出数据表格（dataframe）的前5行。当遇到很大的数据表时，打印全部表格就会很浪费时间和内存。所以`head()`函数让我们快速方便的查看数据表的结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ageOfCar</th>\n",
       "      <th>price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>17</td>\n",
       "      <td>1799</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>17</td>\n",
       "      <td>2249</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>14</td>\n",
       "      <td>1950</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>15</td>\n",
       "      <td>2950</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>18</td>\n",
       "      <td>1999</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ageOfCar  price\n",
       "0        17   1799\n",
       "1        17   2249\n",
       "2        14   1950\n",
       "3        15   2950\n",
       "4        18   1999"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "auto_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(3) 数据字典**\n",
    "- ageOfCar: 车辆的使用年数。\n",
    "- price: 二手车的出售价格。\n",
    "\n",
    "由于我们这一章的研究课题是用车龄预测价格，所以车龄（ageOfCar）是predictor，价格（price）是outcome。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(4) 数据量**\n",
    "\n",
    "Pandas的`shape()`函数可以给出数据表格（dataframe）的行数和列数，以(a,b)的形式输出。a指的行数，也就是吧observation的数量；b指的列数，也就是feature的数量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(120, 2)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "auto_df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "所以这个数据库中，包含120辆二手车的信息，2个feature（price和ageOfCar）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(5) 数据可视化**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "虽然我们了解了数据的内容，但是我们不知道的是数据之间有什么样的关系。既然我们此处要用simple linear regression来建立价格（price）和车龄（ageOfCar）之间的关系，那么这两个数据之间也需要符合线性关系。\n",
    "\n",
    "`plot()`函数可以将数据表（dataframe）中的数据可视化，帮助我们观察数据之间的关系。现在，我们用下面的代码对数据进行可视化，看一看车龄和售价之间的关系。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d1de940>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "auto_df.plot(kind='scatter', x='ageOfCar', y='price', title='Explore Used Car Data')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`plot()`中参数的功能是：\n",
    "* kind: 图标的种类。此处我们观察数据之间的关系，用散点图（scatter plot）观察数据分布的情况。\n",
    "* x: x轴的数值，我们用x轴表示车龄（ageOfCar），用feature的名称即可，python会在auto_df这个数据表格中找到对应的数值。\n",
    "* y: y轴的数值，我们用y轴表示价格（price）。\n",
    "* title: 图片的标题。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从散点图（scatter plot）中我们看出，价格和车龄之间有一个大致的线性关系，随着车龄的增加，价格按照一个大致的比例降低。\n",
    "所以，simple linear regression看起来似乎是可以适用于描绘车龄（ageOfCar）和价格（price）之间的关系。\n",
    "\n",
    "接下来我们来建立一个简单的线性模型，量化价格和车龄之间的关系，看看结果如何。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 建立模型（Simple Linear Model）\n",
    "\n",
    "**(1) 数据预处理**\n",
    "\n",
    "如上一章介绍，通过simple linear regression，我们会得到一个线性模型，它的公式是：\n",
    "\n",
    "$y = \\beta_0 + \\beta_1x$\n",
    "\n",
    "以上各部分具体含义是：\n",
    "- $y$ 是outcome，在这里指的是车的价格（price）\n",
    "- $x$ 是predictor，在这里指的是车的使用年限（ageOfCar）\n",
    "- $\\beta_0$ 是截距（intercept）\n",
    "- $\\beta_1$ x的系数（coefficient）\n",
    "\n",
    "$\\beta_0$ 和 $\\beta_1$ 统称为模型系数（model coefficients）。 我们用Simple Linear Regression找到最优直线的过程, 本质上就是找到最好模型系数的过程。\n",
    "\n",
    "接下来，我们用一个python的库：Statsmodels来建立模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/Cellar/python3/3.6.0/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/numpy/core/fromnumeric.py:2389: FutureWarning: Method .ptp is deprecated and will be removed in a future version. Use numpy.ptp instead.\n",
      "  return ptp(axis=axis, out=out, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "import statsmodels.api as sm\n",
    "X = auto_df['ageOfCar']\n",
    "Y = auto_df['price']\n",
    "X = sm.add_constant(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上这一步，X是predictor，Y是outcome。\n",
    "\n",
    "我们对X和Y进行了赋值，并且在X中加入常数1。加入常数1的目的是让我们的linear model可以写成这个形式$y = \\beta_0x_0 + \\beta_1x_1$，其中$x_0 = 1$，这样做只是为了方便计算。\n",
    "\n",
    "我们把X和Y用`head()`函数打印出前5行，验证一下是我们希望的格式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>const</th>\n",
       "      <th>ageOfCar</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>4.123106</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>4.123106</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>3.741657</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>3.872983</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.0</td>\n",
       "      <td>4.242641</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   const  ageOfCar\n",
       "0    1.0  4.123106\n",
       "1    1.0  4.123106\n",
       "2    1.0  3.741657\n",
       "3    1.0  3.872983\n",
       "4    1.0  4.242641"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1799\n",
       "1    2249\n",
       "2    1950\n",
       "3    2950\n",
       "4    1999\n",
       "Name: price, dtype: int64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你也许会看到，X和Y的格式不一样。这是因为，由于Y只有1列，所以Y变成了一个叫做Series的数据格式，不再是数据表格(dataframe)。但这对我们的分析没有影响。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(2) 训练模型**\n",
    "\n",
    "接下来我们来找最优的模型系数。\n",
    "\n",
    "这个过程代码上非常简单，我们只需要下面这一行，程序就会自动帮我们找到最佳系数$\\beta_0, \\beta_1$。\n",
    "\n",
    "这里的中间过程我们在上一章有介绍，就是找到最小的误差平方和的过程。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = sm.OLS(Y, X).fit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上代码中，sm是statsmodels.api的简称，因为我们在引入statsmodels的时候告诉python：`import statsmodels.api as sm`。\n",
    "\n",
    "`OLS`是指的我们的线性模型，传入我的的数据X，Y，然后调用`fit()`方法就开始训练了。如果你对这个代码不是非常理解，没有关系，现在只需要记住传入X和Y就可以训练出线性模型。\n",
    "\n",
    "我们将线性模型存储在变量`model`中。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 模型参数总结\n",
    "\n",
    "接下来我们看看模型的效果如何。\n",
    "\n",
    "Statsmodel提供了一个非常方便的summary方法，这里有完整的评估模型质量的参数指标。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"simpletable\">\n",
       "<caption>OLS Regression Results</caption>\n",
       "<tr>\n",
       "  <th>Dep. Variable:</th>          <td>price</td>      <th>  R-squared:         </th> <td>   0.692</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Model:</th>                   <td>OLS</td>       <th>  Adj. R-squared:    </th> <td>   0.690</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Method:</th>             <td>Least Squares</td>  <th>  F-statistic:       </th> <td>   265.7</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Date:</th>             <td>Sun, 14 Jul 2019</td> <th>  Prob (F-statistic):</th> <td>5.39e-32</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Time:</th>                 <td>16:00:43</td>     <th>  Log-Likelihood:    </th> <td> -975.01</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>No. Observations:</th>      <td>   120</td>      <th>  AIC:               </th> <td>   1954.</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Df Residuals:</th>          <td>   118</td>      <th>  BIC:               </th> <td>   1960.</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Df Model:</th>              <td>     1</td>      <th>                     </th>     <td> </td>   \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Covariance Type:</th>      <td>nonrobust</td>    <th>                     </th>     <td> </td>   \n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "      <td></td>        <th>coef</th>     <th>std err</th>      <th>t</th>      <th>P>|t|</th>  <th>[0.025</th>    <th>0.975]</th>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>const</th>    <td> 8493.2537</td> <td>  416.985</td> <td>   20.368</td> <td> 0.000</td> <td> 7667.510</td> <td> 9318.997</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>ageOfCar</th> <td> -422.2039</td> <td>   25.904</td> <td>  -16.299</td> <td> 0.000</td> <td> -473.500</td> <td> -370.908</td>\n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "  <th>Omnibus:</th>       <td> 0.416</td> <th>  Durbin-Watson:     </th> <td>   1.493</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Prob(Omnibus):</th> <td> 0.812</td> <th>  Jarque-Bera (JB):  </th> <td>   0.123</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Skew:</th>          <td>-0.022</td> <th>  Prob(JB):          </th> <td>   0.940</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Kurtosis:</th>      <td> 3.151</td> <th>  Cond. No.          </th> <td>    89.5</td>\n",
       "</tr>\n",
       "</table><br/><br/>Warnings:<br/>[1] Standard Errors assume that the covariance matrix of the errors is correctly specified."
      ],
      "text/plain": [
       "<class 'statsmodels.iolib.summary.Summary'>\n",
       "\"\"\"\n",
       "                            OLS Regression Results                            \n",
       "==============================================================================\n",
       "Dep. Variable:                  price   R-squared:                       0.692\n",
       "Model:                            OLS   Adj. R-squared:                  0.690\n",
       "Method:                 Least Squares   F-statistic:                     265.7\n",
       "Date:                Sun, 14 Jul 2019   Prob (F-statistic):           5.39e-32\n",
       "Time:                        16:00:43   Log-Likelihood:                -975.01\n",
       "No. Observations:                 120   AIC:                             1954.\n",
       "Df Residuals:                     118   BIC:                             1960.\n",
       "Df Model:                           1                                         \n",
       "Covariance Type:            nonrobust                                         \n",
       "==============================================================================\n",
       "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
       "------------------------------------------------------------------------------\n",
       "const       8493.2537    416.985     20.368      0.000    7667.510    9318.997\n",
       "ageOfCar    -422.2039     25.904    -16.299      0.000    -473.500    -370.908\n",
       "==============================================================================\n",
       "Omnibus:                        0.416   Durbin-Watson:                   1.493\n",
       "Prob(Omnibus):                  0.812   Jarque-Bera (JB):                0.123\n",
       "Skew:                          -0.022   Prob(JB):                        0.940\n",
       "Kurtosis:                       3.151   Cond. No.                         89.5\n",
       "==============================================================================\n",
       "\n",
       "Warnings:\n",
       "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n",
       "\"\"\""
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这是一个非常完整的表格，里面包含了完整的模型参数。但此刻最重要的是下面2项：\n",
    "\n",
    "**模型系数 $\\beta_0, \\beta_1$**\n",
    "\n",
    "找到好的系数是我们建模和主要目的，模型系数在上表中名为`coef`。我们可以看到两个predictor对应的系数分别为：$\\beta_0 = 8493.2537,  \\beta_1 = -422.2039$。\n",
    "\n",
    "所以我们得到的模型就是：$y = -422.2039x + 8493.2537$\n",
    "\n",
    "\n",
    "**R-squared**\n",
    "\n",
    "R-squared是一个0-1之间的值，表示的是我们的模型对数据的解释能力。\n",
    "\n",
    "* 当R-squared为1的时候，代表我们的模型完美的“吸取”了所有数据的信息。\n",
    "\n",
    "* 当R-squared为0的时候，代表我们的模型没有办法帮助我们用X来预测Y，等同于瞎猜。\n",
    "\n",
    "所以，越接近1说明模型对于数据的解释能力越强，越接近0说明模型对数据的解释能力越弱。\n",
    "\n",
    "我们的R-squared值是0.692，你可以简单理解为我们的模型可以解释69.2%的数据中的信息。通常大于0.6就是一个不错的数值。\n",
    "\n",
    "我们在这里没有深入到R-squared复杂的数学原理，感兴趣的同学可以参考这个非常清晰的教程：[How To Interpret R-squared in Regression Analysis](https://statisticsbyjim.com/regression/interpret-r-squared-regression/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 模型的应用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(1) 预测**\n",
    "\n",
    "我们的模型存储在变量model中，model有一个`predict()`函数可以用来做预测。\n",
    "\n",
    "我们只需要建立一个与训练数据X相同格式的数据，放到model的`predict()`函数中就可以。譬如说我们有一个车龄10年的车，需要预测价格，那么做法如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4271.214516129038"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_X = [1, 10]\n",
    "new_predictions = model.predict(new_X)\n",
    "new_predictions[0] #结果以数组形式输出，此处的[0]是将数组中的数字取出。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "所以说，对于一辆车龄为10年的车，我们可以预期它的售价约为4271美金。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(2) 模型的应用范围**\n",
    "\n",
    "如果我们有一辆30年车龄的车，那么价格会是多少呢？我们来看一看。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4172.863824884782"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_X = [1, 30]\n",
    "new_predictions = model.predict(new_X)\n",
    "new_predictions[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们会发现，结果出现了不可能的数值。这是因为，在我们建立模型的过程中，使用的模型数据的车辆年限在6-20之间。所以模型的有效应用范围也在这个区间之间。\n",
    "我们的模型在训练的过程中，并没有见过30年的车辆，所以预测这样的数据也不在模型能力范围内，于是会出现这样离谱的预测结果。\n",
    "\n",
    "由于在\"数据可视化\"的部分，**我们看到训练数据中，车龄的分布是在6-20年之间，所以我们的模型的适用范围也是针对6-20年之间的车辆。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 模型评估"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(1) 预测的随机性**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "理想的情况下，基于每一个不同的车龄，我们的预测结果的误差应该是随机的。\n",
    "\n",
    "如果不同车龄的预测误差不是随机的，那么说明我们还有其他的信息可以从数据中“榨取”出来。\n",
    "\n",
    "所以我们用散点图来可视化预测误差和车龄，看看与上面的假设是否一致。\n",
    "\n",
    "我们定义X轴为predictor（ageOfCar），Y轴为预测的误差（Y_pred - Y)。首先得到预测值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y_pred = model.predict(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后用预测价格Y_pred减去真实价格Y，得到误差（residual）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "residual = Y_pred - Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后用matplotlib的`plt()`函数画出散点图，将X坐标作为第一个参数传入，Y坐标作为第二个参数传入即可："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x11d3739b0>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X.ageOfCar, residual)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们能看到，大体上，数据比较均匀的分布在Y=0这条直线的两侧。所以整体来看，这个模型的预测结果具备一定的随机性。\n",
    "\n",
    "但是如果我们仔细观察，会发现右侧的数据，当ageOfCar大于14的时候，图像顶部有一个向下的滑坡，我对这个pattern有一些疑虑。\n",
    "\n",
    "一个可能的解释是：车辆的贬值速度是越来越慢的。新车的贬值速度比较快，但是如果一辆车已经开了15年，那么再开一年对它的影响/损坏很可能比前几年要小。而我们的模型$y = -422.2039x + 8493.2537$表达的是车辆每年以匀速的价格贬值，所以这是为什么ageOfCar大于14的时候，我们的模型会给出整体偏低的价格预测。\n",
    "\n",
    "要解决这个问题，有两个思路：\n",
    "> 1.对ageOfCar进行一定的运算转换成新的predictor，比如开根号，这样车龄的“增长”速度也会逐渐减慢，更符合现实中车辆贬值的情况。\n",
    ">\n",
    "> 2.增加predictor的种类，将更多的信息纳入进来，减弱车龄（ageOfCar）对结果的影响。\n",
    "\n",
    "同学们可以自己动手尝试一下思路1，同时我们在下一章Multiple Linear Regression中尝试思路2。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(2) 均方根误差 Root Mean Squared Error**\n",
    "\n",
    "均方根误差简称RMSE，是一种广泛使用的衡量模型的指标。\n",
    "\n",
    "RMSE的计算方法简单， $RMSE = \\sqrt{\\frac{1}{n}\\Sigma_{i=1}^{n}{({ypred}_i -y_i)^2}}$。它的计算方法是：\n",
    "* 1.计算预测值\n",
    "* 2.计算每一个预测值与对应真实值的差\n",
    "* 3.将2的结果中的每一项平方，算平均值\n",
    "* 4.将3的结果开根号\n",
    "\n",
    "反应的是我们的预测值与实际值的偏差的概况，越小越好。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1634.8290513702962\n"
     ]
    }
   ],
   "source": [
    "rmse = np.sqrt(sum(residual**2) / 30)\n",
    "print(rmse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(3) 备注**\n",
    "\n",
    "需要注明的是，此处我们使用了用于训练模型的数据做验证。\n",
    "\n",
    "正确的做法是将数据集拆分，一部分数据做训练、另一部分数据做测试。\n",
    "\n",
    "此处我们先介绍模型验证的思想，在后续章节我们会介绍数据的拆分，使用更正确的方式来验证模型的表现。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. 模型的解释"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如何解释最终的结果，决定了Data Science项目的成败。如果我们可以理解模型的含义，并且符合我们对实际问题的认知，那么我们会增强对于模型的信心，客户也更容易接受我们提供的结果。\n",
    "\n",
    "对于这一章我们建立的模型，我们的解释是：\n",
    "\n",
    "由于我们的模型是：$y = -422.2039x + 8493.2537$\n",
    "\n",
    "结合模型的应用范围，对于使用6-20年的二手车，每多开一年，其售价的期望会下降422.2039美元。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary & Next\n",
    "\n",
    "通过本章的学习，你也许第一次接触到了Simple Linear Regression的代码实现，并且得出了有意义的二手车市场结论。\n",
    "\n",
    "在Simple Linear Regression的过程中，我们首先对数据进行绘图来观察其规律，然后对数据做了预处理（增加const），然后进行建模。\n",
    "\n",
    "这三步是解决Data Science问题的基本步骤，在之后的学习中会不断的出现。\n",
    "\n",
    "同时我们还会逐渐的加入新的步骤，来提升分析的效果。\n",
    "\n",
    "\n",
    "下一章中，我们会给大家介绍一些关键的统计概念，然后继续分析这一章中模型的结果。\n",
    "\n",
    "**下一章：**[1.3 基础的Data Science知识1](https://github.com/RyC37/data-science-tutorial-for-beginners/blob/master/1.3-stats-basic-1.ipynb)"
   ]
  }
 ],
 "metadata": {
  "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}