Lab11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 实验课 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "完整的数据科学过程包括：\n",
    "\n",
    "* 定义研究目标\n",
    "* 收集数据（实验8、实验9-1）\n",
    "* 数据预处理（实验10-1）\n",
    "* 数据概览（实验10-1）\n",
    "* 数据建模与评价\n",
    "* 数据可视化（实验7-3）\n",
    "\n",
    "接下来的实验我们主要从**数据建模与评价**角度入手，从统计模型、机器学习模型、数据挖掘模型这三个类别中为大家简介并演示一些经典的数据建模技术。无论采取哪种技术，大多数模型构建包括以下步骤：\n",
    "\n",
    "* 选择模型技术和变量\n",
    "* 执行模型\n",
    "* 模型评价与进一步修正"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实验11-1 Scikit-Learn库简介"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scikit-Learn是最流行的机器学习算法库，它为各种常用机器学习算法提供了高效版本，无需我们实现复杂的算法。\n",
    "\n",
    "Scikit-Learn中的所有机器学习算法都是通过API实现的，它为各种机器学习应用提供了统一的接口，常用使用步骤如下：\n",
    "\n",
    "* 导入适当的模型类和评估器类；\n",
    "* 配置模型的超参数，实例化模型类；\n",
    "* 整理数据并输入\n",
    "* 调用模型实例的`fit()`方法对数据进行拟合；\n",
    "* 对新数据应用模型：\n",
    "> 监督学习模型：使用`predict()`方法预测新数据的标签；\n",
    ">\n",
    "> 无监督学习模型：使用`transform()`和`predict()`方法转换或推断数据的性质。\n",
    "\n",
    "Scikit-Learn非Python自带库，需要我们手动安装。请启动Anaconda Powershell Prompt，并切换到你的环境（若有），输入`conda list`，查看是否已安装`scikit-learn`，若没有，请在命令行输入`conda install scikit-learn`并按回车，开始自动下载并安装。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实验11-2 线性回归"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在高中数学课上学习了一元线性回归模型，对一些散点拟合出一条近似的一次函数曲线 y=wx+b.\n",
    "\n",
    "现在我们使用计算机来构造线性回归模型，并拟合出一条直线。\n",
    "\n",
    "假设我们的数据点大致分布在 y=2x+1 这条直线的两侧，首先我们先生成一些数据点，并且生成散点图（为了程序每次运行时生成的随机数相同，我们设定一下随机数种子）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.random.seed(2)\n",
    "x = np.linspace(0,10)\n",
    "err = np.random.randn(50) * 2  # 人为将误差范围适当扩大一点\n",
    "y = 2 * x + 1 + err\n",
    "\n",
    "plt.scatter(x,y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来我们导入模型类和评估器类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "配置模型的超参数并且实例化：一个模型类有很多的超参数，我们可以通过[查阅API文档](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegression)了解各个超参数的含义，这里我们采取默认值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = LinearRegression()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数据我们在之前已经准备完毕，变量x是一个一维数组，但是现实生活中符合的更多是多项式函数，x是一个二维矩阵，并且scikit-learn接受的是二维数组（其中行为样本，列为特征）。\n",
    "\n",
    "我们需要将变量x转换为二维数组，x中的每个值作为样本。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "in_x = x.reshape((len(x),1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression()"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(in_x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`fit()`方法经过大量运算拟合出一条函数曲线，函数各项的系数（一次函数中就是斜率）和截距分别存储在`coef_`和`intercept_`参数中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.12172401]\n",
      "0.11189199513946946\n"
     ]
    }
   ],
   "source": [
    "print(model.coef_)\n",
    "print(model.intercept_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里拟合出的一次函数即为 y=2.12x+0.11 ，噪点会对拟合过程产生一定影响。\n",
    "\n",
    "我们把散点和拟合出的函数图像绘制在一起："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "pre_y = model.coef_ * x + model.intercept_\n",
    "plt.scatter(x,y)\n",
    "plt.plot(x,pre_y,color='r',label='y=%.2fx+%.2f'%(model.coef_,model.intercept_))\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后我们利用评估器类输出拟合出的函数曲线与标准函数曲线的误差，这里我们采用均方误差（MSE）作为指标：\n",
    "\n",
    "均方误差的计算公式为：\n",
    "\n",
    "$$\n",
    "MSE=\\frac{1}{n}\\sum_{i=1}^n(\\hat{y_i}-y_i)^2\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.203395730197267\n"
     ]
    }
   ],
   "source": [
    "mse = mean_squared_error(y,pre_y)\n",
    "print(mse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上是简单的拟合一元线性函数，通过`LinearRegression`类还可以拟合多元线性函数：\n",
    "\n",
    "$$\n",
    "y=x_0+w_1x_1+w_2x_2+...+w_nx_n\n",
    "$$\n",
    "\n",
    "也就是拟合出三维空间中的一个平面或者是更高维空间中的一个超平面。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实验11-3 多项式回归"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "假如我们有如图所示的数据点：\n",
    "\n",
    "![Poly](img/Lab11-3-1.png)\n",
    "\n",
    "如果使用线性回归显然是不合适的，这时候需要利用复杂的函数去拟合这些数据点。不过非线性函数实在是太多了，例如三角函数、对数函数、指数函数……，我们事先并不知道这些数据点更切合哪种函数。\n",
    "\n",
    "在高等数学中我们学过利用**泰勒公式**通过多项式函数去近似表达一些初等函数，例如：\n",
    "\n",
    "![ex](img/Lab11-3-2.png)\n",
    "\n",
    "理论上我们可以用多项式函数去近似绝大多数初等函数，这样我们拟合非线性数据点就有了解决方案。\n",
    "\n",
    "现在我们生成一些位于函数曲线\n",
    "\n",
    "$$\n",
    "y=0.1x^3+0.35x^2+0.1x+1\n",
    "$$\n",
    "\n",
    "附近的数据点。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.random.seed(0)\n",
    "x = np.linspace(-5,3)\n",
    "err = np.random.randn(50) * 0.5  # 噪音点幅度手动调低\n",
    "y = 0.1 * x ** 3 + 0.35 * x ** 2 + 0.1 * x + 1 + err\n",
    "\n",
    "plt.scatter(x,y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scikit-Learn没有直接提供多项式回归模型，不过我们可以通过“基函数”对原始数据进行变换，间接地利用线性回归模型构造非线性回归模型。\n",
    "\n",
    "我们先预测该数据由二次函数产生的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.72482744 0.05720164]\n",
      "1.8479289699622798\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "in_x = x.reshape(len(x),1)\n",
    "\n",
    "model_1 = Pipeline([('Poly',PolynomialFeatures(degree=2)),('Linear',LinearRegression())])\n",
    "model_1.fit(in_x,y)\n",
    "\n",
    "print(model_1.named_steps['Linear'].coef_)\n",
    "print(model_1.named_steps['Linear'].intercept_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "模型拟合的二次函数为\n",
    "\n",
    "$$\n",
    "y=1.85+0.72x+0.05x^2\n",
    "$$\n",
    "\n",
    "我们再画出拟合的函数图像："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "b = model_1.named_steps['Linear'].intercept_\n",
    "w1 = model_1.named_steps['Linear'].coef_[1]\n",
    "w2 = model_1.named_steps['Linear'].coef_[2]\n",
    "y_pre = b + w1 * x + w2 * x **2\n",
    "plt.scatter(x,y)\n",
    "plt.plot(x,y_pre,color='r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "看起来二次函数似乎不太拟合数据点的分布，我们可以从均方误差看出来："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.1866314281737795\n"
     ]
    }
   ],
   "source": [
    "mse = mean_squared_error(y,y_pre)\n",
    "print(mse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们再尝试用三次函数拟合一下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.07156479 0.33771211 0.09350349]\n",
      "1.0076593425711207\n"
     ]
    }
   ],
   "source": [
    "model_2 = Pipeline([('Poly',PolynomialFeatures(degree=3)),('Linear',LinearRegression())])\n",
    "model_2.fit(in_x,y)\n",
    "\n",
    "print(model_2.named_steps['Linear'].coef_)\n",
    "print(model_2.named_steps['Linear'].intercept_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "模型拟合的三次函数为\n",
    "\n",
    "![tri_math](img/Lab11-3-3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "看起来与理想的\n",
    "\n",
    "![math](img/Lab11-3-4.png)\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": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "b = model_2.named_steps['Linear'].intercept_\n",
    "w1 = model_2.named_steps['Linear'].coef_[1]\n",
    "w2 = model_2.named_steps['Linear'].coef_[2]\n",
    "w3 = model_2.named_steps['Linear'].coef_[3]\n",
    "y_pre = b + w1 * x + w2 * x ** 2 + w3 * x ** 3\n",
    "\n",
    "plt.scatter(x,y)\n",
    "plt.plot(x,y_pre,color='r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.2677793418459817\n"
     ]
    }
   ],
   "source": [
    "mse = mean_squared_error(y,y_pre)\n",
    "print(mse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看出三次函数可以较好地拟合原始数据点，并且MSE相对于二次函数有了大幅度的下降。\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": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1507617232094932\n"
     ]
    }
   ],
   "source": [
    "model_3 = Pipeline([('Poly',PolynomialFeatures(degree=20)),('Linear',LinearRegression())])\n",
    "model_3.fit(in_x,y)\n",
    "\n",
    "b = model_3.named_steps['Linear'].intercept_\n",
    "w = [x for x in model_3.named_steps['Linear'].coef_[1:]]\n",
    "w.insert(0,None)  # 在w列表开头插入一个占位符，便于系数与下标对应\n",
    "\n",
    "y_pre = b\n",
    "for i in range(1,21):\n",
    "    y_pre += w[i] * x ** i\n",
    "\n",
    "plt.scatter(x,y)\n",
    "plt.plot(x,y_pre,color='r')\n",
    "plt.show()\n",
    "\n",
    "print(mean_squared_error(y,y_pre))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "看起来拟合出的函数曲线更加契合数据点，并且MSE更加小了。\n",
    "\n",
    "但是不要忘记原始数据点是**包含噪声**的，过度拟合原始数据并不是完美的情况（假如极端情况大部分数据点的y值介于1-2之间，有一个异常点的y值达到了100，我们没有必要也不能为了拟合这个异常点而突然“拔高”函数曲线），理想的状态就是近似地拟合数据（泛化性）。后面的实验我们会继续探讨**过拟合**和**欠拟合**的问题。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实验11-4 处理真实数据之前……"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "刚才介绍的回归示例为大家简单展示了如何利用Scikit-Learn库快速构造模型并使用。但是刚才的数据点都是我们用计算机生成的，并且我们了解这些数据点是如何生成的（虽然我们“自以为是”地添加了一些噪声）。\n",
    "\n",
    "实际生活中数据是如何产生的、这些数据符合什么分布等等这些问题我们并不了解；此外对于训练出的模型我们还要通过一些**测试数据**对其进行评估，对于唯一的数据集如何既要训练又要测试又是一个问题。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 训练集与测试集"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "虽说我们处于“大数据”时代，数据唾手可得，但是数据也是很珍贵的资源，对于数据工程来说快速生成一个比较准确的模型是主要任务，有的时候可能由于客观条件限制无法继续获得数据，这时候对于我们手中已有的数据，需要进行合理的划分：一部分用于训练模型（训练集）；另一部分用于测试模型（测试集）。\n",
    "\n",
    "例如我们读取鸢尾花数据集（Scikit-Learn库中也自带该数据集），目标是根据花的四个特征确定是哪一种鸢尾花。那么每条数据包含四个浮点数和一个文字标签，我们把全部数据分为训练集和测试集，先使用训练集训练出模型，再将测试集的每一条数据输入模型，对比模型输出与理想输出是否一致。\n",
    "\n",
    "小规模数据集（万数量级以下）训练集与测试集的划分比例一般为7:3或8:2；大规模数据集训练集与测试集的划分比例一般为98:2或99:1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "全体数据量： 150\n",
      "训练集数据量： 120\n",
      "测试集数据量： 30\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "iris_data = load_iris()\n",
    "x = iris_data['data']\n",
    "y = iris_data['target']\n",
    "print('全体数据量：',len(x))\n",
    "\n",
    "x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.2,shuffle=True)  # shuffle参数用于“洗牌”，打乱原始的数据行排列顺序\n",
    "print('训练集数据量：',len(x_train))\n",
    "print('测试集数据量：',len(x_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 归一化/标准化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "归一化/标准化实质是一种线性变换，线性变换有很多良好的性质，这些性质决定了对数据改变后不会造成“失效”，反而能提高数据的表现。在使用梯度下降的方法求解最优化问题时，归一化/标准化后可以加快梯度下降的求解速度，即提升模型的收敛速度。如左图所示，未归一化/标准化时形成的等高线偏椭圆，迭代时很有可能走“之”字型路线（垂直长轴），从而导致迭代很多次才能收敛。而如右图对两个特征进行了归一化，对应的等高线就会变圆，在梯度下降进行求解时能较快的收敛。\n",
    "![GD](img/Lab11-4-1.png)\n",
    "\n",
    "例如我们对刚才的训练集数据的四个特征进行归一化："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                0           1           2           3\n",
      "count  120.000000  120.000000  120.000000  120.000000\n",
      "mean     5.796667    3.074167    3.614167    1.149167\n",
      "std      0.832323    0.470918    1.764224    0.767622\n",
      "min      4.300000    2.000000    1.000000    0.100000\n",
      "25%      5.100000    2.800000    1.500000    0.275000\n",
      "50%      5.700000    3.000000    4.200000    1.300000\n",
      "75%      6.400000    3.400000    5.025000    1.800000\n",
      "max      7.900000    4.400000    6.900000    2.500000\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import pandas as pd\n",
    "\n",
    "temp_x = pd.DataFrame(x_train)\n",
    "print(temp_x.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                0           1           2           3\n",
      "count  120.000000  120.000000  120.000000  120.000000\n",
      "mean     0.415741    0.447569    0.443079    0.437153\n",
      "std      0.231201    0.196216    0.299021    0.319842\n",
      "min      0.000000    0.000000    0.000000    0.000000\n",
      "25%      0.222222    0.333333    0.084746    0.072917\n",
      "50%      0.388889    0.416667    0.542373    0.500000\n",
      "75%      0.583333    0.583333    0.682203    0.708333\n",
      "max      1.000000    1.000000    1.000000    1.000000\n"
     ]
    }
   ],
   "source": [
    "min_max_scaler = MinMaxScaler()\n",
    "processed_x = min_max_scaler.fit_transform(x_train)\n",
    "temp_x = pd.DataFrame(processed_x)\n",
    "print(temp_x.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们看到处理后的数据均介于0-1之间。如果原始数据特征的方差不大，可以使用归一化；如果数据存在异常值和较多噪音，则需要用标准化处理数据。\n",
    "\n",
    "标准化将数据按属性（也就是列）减去其均值，并除以其方差。得到的结果是，对于每个属性来说所有数据都聚集在0附近，方差为1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                  0             1             2             3\n",
      "count  1.200000e+02  1.200000e+02  1.200000e+02  1.200000e+02\n",
      "mean  -2.335169e-15 -1.049161e-15 -2.905084e-16  2.581269e-16\n",
      "std    1.004193e+00  1.004193e+00  1.004193e+00  1.004193e+00\n",
      "min   -1.805719e+00 -2.290569e+00 -1.487979e+00 -1.372507e+00\n",
      "25%   -8.405241e-01 -5.846370e-01 -1.203380e+00 -1.143574e+00\n",
      "50%   -1.166277e-01 -1.581541e-01  3.334552e-01  1.973183e-01\n",
      "75%    7.279180e-01  6.948117e-01  8.030436e-01  8.514119e-01\n",
      "max    2.537659e+00  2.827226e+00  1.870290e+00  1.767143e+00\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "scale = StandardScaler()\n",
    "processed_x = scale.fit_transform(x_train)\n",
    "\n",
    "temp_x = pd.DataFrame(processed_x)\n",
    "print(temp_x.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实验练习11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在实验练习08中我们使用的数据为两个城市在不同因素影响下某小时共享单车租用的数量。现在我们利用该数据集构建一个回归预测模型，根据数据中的某些属性预测该时段内的单车租用数量，该表所有值均为整型数据，表结构为：\n",
    "\n",
    "* id 记录编号，无其他意义\n",
    "* city 城市代号，0为北京，1为上海\n",
    "* hour 小时，代表时间\n",
    "* is_workday 是否为工作日，0为否，1为是\n",
    "* temp_air 大气温度，单位为摄氏度\n",
    "* temp_body 体感温度，单位为摄氏度\n",
    "* weather 天气代号，1为晴天，2为多云或阴天，3为雨天或雪天\n",
    "* wind 风级，数值越大代表风速越大\n",
    "* y 该小时内共享单车被租用的数量\n",
    "\n",
    "请完成以下任务："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 数据获取：数据集已下载至`bike.csv`文件中，请使用pandas库读取该文件。\n",
    "\n",
    "> 提示：原始数据集共10,000条数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. 数据预处理 I：`id`属性对构建回归预测模型没有帮助，请剔除掉该列。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. 数据预处理 II：我们暂不考虑不同城市对单车租用的影响，请筛选出上海市的所有数据，然后剔除`city`列。\n",
    "\n",
    "> 提示：目前剩余4,998条数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. 数据预处理 III：为简化数据，请将`hour`列中原来6点-18点统一为1；19点-次日5点统一为0。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. 数据预处理 IV：`y`列为单车租用数量，是我们的预测目标（标签），请将该列提取出来，并转换为一个numpy**列向量**，将原先的`y`列剔除。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. 数据预处理 V：请将DataFrame对象转换为Numpy数组，方便后续操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. 数据集划分：请按照训练集与测试集8:2的比例将原始数据集划分。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. 数据预处理 VI：请分别对训练集数据、训练集标签、测试集数据和测试集标签进行归一化。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. 模型构建：请先构建一个**线性回归模型（多元一次函数）**，然后利用训练集训练模型。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10. 模型测试：利用测试集对训练好的模型进行评估。\n",
    "\n",
    "> 提示：使用`predict(data_array)`方法输入测试集，该函数返回值为模型预测值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "11. 模型评估：请使用均方根误差（RMSE）作为评估指标，并输出RMSE值。\n",
    "\n",
    "均方根误差(Root of Mean Squared Error)，公式为\n",
    "$$\n",
    "RMSE=\\sqrt{\\frac{1}{n}\\sum_{i=1}^n(\\hat{y_i}-y_i)^2}\n",
    "$$\n",
    "可以直接通过对MSE求平方根获得。"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}