207297.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "![](https://ai-studio-static-online.cdn.bcebos.com/61c6f63d666f4a81b98171b775ee8d486e610cf8fa654225b5cdd3c4b7db96ce)本项目对应视频课程已上线，点击前往学习[深度学习CV从入门到实战](https://aistudio.baidu.com/aistudio/course/introduce/789)课节2波士顿房价预测"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "经典的线性回归模型主要用来预测一些存在着线性关系的数据集。回归模型可以理解为：存在一个点集，用一条曲线去拟合它分布的过程。如果拟合曲线是一条直线，则称为线性回归。如果是一条二次曲线，则被称为二次回归。线性回归是回归模型中最简单的一种。 本教程使用PaddlePaddle建立起一个房价预测模型。\n",
    "\n",
    "在线性回归中：\n",
    "\n",
    "（1）假设函数是指，用数学的方法描述自变量和因变量之间的关系，它们之间可以是一个线性函数或非线性函数。 在本次线性回顾模型中，我们的假设函数为 Y’= wX+b ，其中，Y’表示模型的预测结果（预测房价），用来和真实的Y区分。模型要学习的参数即：w,b。\n",
    "\n",
    "（2）损失函数是指，用数学的方法衡量假设函数预测结果与真实值之间的误差。这个差距越小预测越准确，而算法的任务就是使这个差距越来越小。 建立模型后，我们需要给模型一个优化目标，使得学到的参数能够让预测值Y’尽可能地接近真实值Y。这个实值通常用来反映模型误差的大小。不同问题场景下采用不同的损失函数。 对于线性模型来讲，最常用的损失函数就是均方误差（Mean Squared Error， MSE）。\n",
    "\n",
    "（3）优化算法：神经网络的训练就是调整权重（参数）使得损失函数值尽可能得小，在训练过程中，将损失函数值逐渐收敛，得到一组使得神经网络拟合真实模型的权重（参数）。所以，优化算法的最终目标是找到损失函数的最小值。而这个寻找过程就是不断地微调变量w和b的值，一步一步地试出这个最小值。 常见的优化算法有随机梯度下降法（SGD）、Adam算法等等"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**首先导入必要的包**，分别是：\r\n",
    "\r\n",
    "**paddle.fluid**--->PaddlePaddle深度学习框架\r\n",
    "\r\n",
    "**numpy**---------->python基本库，用于科学计算\r\n",
    "\r\n",
    "**os**------------------>python的模块，可使用该模块对操作系统进行操作\r\n",
    "\r\n",
    "**matplotlib**----->python绘图库，可方便绘制折线图、散点图等图形"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import paddle.fluid as fluid\r\n",
    "import paddle\r\n",
    "import numpy as np\r\n",
    "import os\r\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# **Step1：准备数据。**\n",
    "\n",
    "（1）uci-housing数据集介绍\n",
    "\n",
    "数据集共506行,每行14列。前13列用来描述房屋的各种信息，最后一列为该类房屋价格中位数。\n",
    "\n",
    "PaddlePaddle提供了读取uci_housing训练集和测试集的接口，分别为paddle.dataset.uci_housing.train()和paddle.dataset.uci_housing.test()。\n",
    "\n",
    "(2)train_reader和test_reader\n",
    "\n",
    "paddle.reader.shuffle()表示每次缓存BUF_SIZE个数据项，并进行打乱\n",
    "\n",
    "paddle.batch()表示每BATCH_SIZE组成一个batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[==================================================]housing/housing.data not found, downloading http://paddlemodels.bj.bcebos.com/uci_housing/housing.data\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/paddle/dataset/uci_housing.py:49: UserWarning: \n",
      "This call to matplotlib.use() has no effect because the backend has already\n",
      "been chosen; matplotlib.use() must be called *before* pylab, matplotlib.pyplot,\n",
      "or matplotlib.backends is imported for the first time.\n",
      "\n",
      "The backend was *originally* set to 'module://ipykernel.pylab.backend_inline' by the following code:\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/runpy.py\", line 193, in _run_module_as_main\n",
      "    \"__main__\", mod_spec)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/runpy.py\", line 85, in _run_code\n",
      "    exec(code, run_globals)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/ipykernel_launcher.py\", line 16, in <module>\n",
      "    app.launch_new_instance()\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/traitlets/config/application.py\", line 658, in launch_instance\n",
      "    app.start()\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/ipykernel/kernelapp.py\", line 505, in start\n",
      "    self.io_loop.start()\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/tornado/platform/asyncio.py\", line 132, in start\n",
      "    self.asyncio_loop.run_forever()\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/asyncio/base_events.py\", line 421, in run_forever\n",
      "    self._run_once()\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/asyncio/base_events.py\", line 1425, in _run_once\n",
      "    handle._run()\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/asyncio/events.py\", line 127, in _run\n",
      "    self._callback(*self._args)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/tornado/ioloop.py\", line 758, in _run_callback\n",
      "    ret = callback()\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/tornado/stack_context.py\", line 300, in null_wrapper\n",
      "    return fn(*args, **kwargs)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/tornado/gen.py\", line 1233, in inner\n",
      "    self.run()\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/tornado/gen.py\", line 1147, in run\n",
      "    yielded = self.gen.send(value)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/ipykernel/kernelbase.py\", line 357, in process_one\n",
      "    yield gen.maybe_future(dispatch(*args))\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/tornado/gen.py\", line 326, in wrapper\n",
      "    yielded = next(result)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/ipykernel/kernelbase.py\", line 267, in dispatch_shell\n",
      "    yield gen.maybe_future(handler(stream, idents, msg))\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/tornado/gen.py\", line 326, in wrapper\n",
      "    yielded = next(result)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/ipykernel/kernelbase.py\", line 534, in execute_request\n",
      "    user_expressions, allow_stdin,\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/tornado/gen.py\", line 326, in wrapper\n",
      "    yielded = next(result)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/ipykernel/ipkernel.py\", line 294, in do_execute\n",
      "    res = shell.run_cell(code, store_history=store_history, silent=silent)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/ipykernel/zmqshell.py\", line 536, in run_cell\n",
      "    return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/IPython/core/interactiveshell.py\", line 2821, in run_cell\n",
      "    self.events.trigger('post_run_cell', result)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/IPython/core/events.py\", line 88, in trigger\n",
      "    func(*args, **kwargs)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/ipykernel/pylab/backend_inline.py\", line 164, in configure_once\n",
      "    activate_matplotlib(backend)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/IPython/core/pylabtools.py\", line 314, in activate_matplotlib\n",
      "    matplotlib.pyplot.switch_backend(backend)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/matplotlib/pyplot.py\", line 231, in switch_backend\n",
      "    matplotlib.use(newbackend, warn=False, force=True)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/matplotlib/__init__.py\", line 1422, in use\n",
      "    reload(sys.modules['matplotlib.backends'])\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/importlib/__init__.py\", line 166, in reload\n",
      "    _bootstrap._exec(spec, module)\n",
      "  File \"/opt/conda/envs/python35-paddle120-env/lib/python3.5/site-packages/matplotlib/backends/__init__.py\", line 16, in <module>\n",
      "    line for line in traceback.format_stack()\n",
      "\n",
      "\n",
      "  matplotlib.use('Agg')\n",
      "\n"
     ]
    }
   ],
   "source": [
    "BUF_SIZE=500\r\n",
    "BATCH_SIZE=20\r\n",
    "\r\n",
    "#用于训练的数据提供器，每次从缓存中随机读取批次大小的数据\r\n",
    "train_reader = paddle.batch(\r\n",
    "    paddle.reader.shuffle(paddle.dataset.uci_housing.train(), \r\n",
    "                          buf_size=BUF_SIZE),                    \r\n",
    "    batch_size=BATCH_SIZE)   \r\n",
    "#用于测试的数据提供器，每次从缓存中随机读取批次大小的数据\r\n",
    "test_reader = paddle.batch(\r\n",
    "    paddle.reader.shuffle(paddle.dataset.uci_housing.test(),\r\n",
    "                          buf_size=BUF_SIZE),\r\n",
    "    batch_size=BATCH_SIZE)  \r\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "(3)打印看下数据是什么样的？PaddlePaddle接口提供的数据已经经过归一化等处理\n",
    "\n",
    "(array([-0.02964322, -0.11363636,  0.39417967, -0.06916996,  0.14260276,\n",
    "       -0.10109875,  0.30715859, -0.13176829, -0.24127857,  0.05489093,\n",
    "        0.29196451, -0.2368098 ,  0.12850267]), array([15.6])),"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([-0.0405441 ,  0.06636364, -0.32356227, -0.06916996, -0.03435197,\n",
      "        0.05563625, -0.03475696,  0.02682186, -0.37171335, -0.21419304,\n",
      "       -0.33569506,  0.10143217, -0.21172912]), array([24.]))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "#用于打印，查看uci_housing数据\r\n",
    "train_data=paddle.dataset.uci_housing.train();\r\n",
    "sampledata=next(train_data())\r\n",
    "print(sampledata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# **Step2:网络配置**\n",
    "\n",
    "**（1）网络搭建**：对于线性回归来讲，它就是一个从输入到输出的简单的全连接层。\n",
    "\n",
    "对于波士顿房价数据集，假设属性和房价之间的关系可以被属性间的线性组合描述。\n",
    "\n",
    "![](https://ai-studio-static-online.cdn.bcebos.com/f3f567e7aa7a499fb3abb767aaaa1b943eed373cf4694d87beb382e161ea8edc)\n",
    "\n",
    "![](https://ai-studio-static-online.cdn.bcebos.com/f6c44a96e1624828829bbd438c29c17ead9ecc45c68b4310bfbbb0a4dc96c3fe)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#定义张量变量x，表示13维的特征值\r\n",
    "x = fluid.layers.data(name='x', shape=[13], dtype='float32')\r\n",
    "#定义张量y,表示目标值\r\n",
    "y = fluid.layers.data(name='y', shape=[1], dtype='float32')\r\n",
    "#定义一个简单的线性网络,连接输入和输出的全连接层\r\n",
    "#input:输入tensor;\r\n",
    "#size:该层输出单元的数目\r\n",
    "#act:激活函数\r\n",
    "y_predict=fluid.layers.fc(input=x,size=1,act=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**(2)定义损失函数**\n",
    "\n",
    "此处使用均方差损失函数。\n",
    "\n",
    "square_error_cost(input,lable):接受输入预测值和目标值，并返回方差估计,即为（y-y_predict）的平方"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cost = fluid.layers.square_error_cost(input=y_predict, label=y) #求一个batch的损失值\r\n",
    "avg_cost = fluid.layers.mean(cost)                              #对损失值求平均值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**(3)定义优化函数**\n",
    "\n",
    "此处使用的是随机梯度下降。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001)\r\n",
    "opts = optimizer.minimize(avg_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "test_program = fluid.default_main_program().clone(for_test=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "在上述模型配置完毕后，得到两个fluid.Program：fluid.default_startup_program() 与fluid.default_main_program() 配置完毕了。\n",
    "\n",
    "参数初始化操作会被写入**fluid.default_startup_program()**\n",
    "\n",
    "**fluid.default_main_program**()用于获取默认或全局main program(主程序)。该主程序用于训练和测试模型。fluid.layers 中的所有layer函数可以向 default_main_program 中添加算子和变量。default_main_program 是fluid的许多编程接口（API）的Program参数的缺省值。例如,当用户program没有传入的时候， Executor.run() 会默认执行 default_main_program 。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# **Step3.模型训练** and **Step4.模型评估**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**（1）创建Executor**\n",
    "\n",
    "首先定义运算场所 fluid.CPUPlace()和 fluid.CUDAPlace(0)分别表示运算场所为CPU和GPU\n",
    "\n",
    "Executor:接收传入的program，通过run()方法运行program。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\r\n",
    "use_cuda = False                         #use_cuda为False,表示运算场所为CPU;use_cuda为True,表示运算场所为GPU           \r\n",
    "place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()\r\n",
    "exe = fluid.Executor(place)              #创建一个Executor实例exe\r\n",
    "exe.run(fluid.default_startup_program()) #Executor的run()方法执行startup_program(),进行参数初始化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**（2）定义输入数据维度**\n",
    "\n",
    "DataFeeder负责将数据提供器（train_reader,test_reader）返回的数据转成一种特殊的数据结构，使其可以输入到Executor中。\n",
    "\n",
    "feed_list设置向模型输入的向变量表或者变量表名"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 定义输入数据维度\r\n",
    "feeder = fluid.DataFeeder(place=place, feed_list=[x, y])#feed_list:向模型输入的变量表或变量表名"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**（3）定义绘制训练过程的损失值变化趋势的方法draw_train_process**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "iter=0;\r\n",
    "iters=[]\r\n",
    "train_costs=[]\r\n",
    "\r\n",
    "def draw_train_process(iters,train_costs):\r\n",
    "    title=\"training cost\"\r\n",
    "    plt.title(title, fontsize=24)\r\n",
    "    plt.xlabel(\"iter\", fontsize=14)\r\n",
    "    plt.ylabel(\"cost\", fontsize=14)\r\n",
    "    plt.plot(iters, train_costs,color='red',label='training cost') \r\n",
    "    plt.grid()\r\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**（4）训练并保存模型**\n",
    "\n",
    "Executor接收传入的program,并根据feed map(输入映射表)和fetch_list(结果获取表) 向program中添加feed operators(数据输入算子)和fetch operators（结果获取算子)。 feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量。\n",
    "\n",
    "注：enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pass:0, Cost:783.22180\n",
      "Test:0, Cost:154.32607\n",
      "Pass:1, Cost:519.22571\n",
      "Test:1, Cost:92.79891\n",
      "Pass:2, Cost:606.54010\n",
      "Test:2, Cost:92.41443\n",
      "Pass:3, Cost:279.49731\n",
      "Test:3, Cost:185.88803\n",
      "Pass:4, Cost:356.30026\n",
      "Test:4, Cost:129.92186\n",
      "Pass:5, Cost:419.08685\n",
      "Test:5, Cost:111.01654\n",
      "Pass:6, Cost:390.89267\n",
      "Test:6, Cost:102.50714\n",
      "Pass:7, Cost:363.88116\n",
      "Test:7, Cost:103.34782\n",
      "Pass:8, Cost:256.58975\n",
      "Test:8, Cost:110.39152\n",
      "Pass:9, Cost:351.81763\n",
      "Test:9, Cost:102.23664\n",
      "Pass:10, Cost:283.22528\n",
      "Test:10, Cost:28.30433\n",
      "Pass:11, Cost:168.48587\n",
      "Test:11, Cost:13.69916\n",
      "Pass:12, Cost:151.80196\n",
      "Test:12, Cost:62.51043\n",
      "Pass:13, Cost:270.92618\n",
      "Test:13, Cost:86.74022\n",
      "Pass:14, Cost:277.52686\n",
      "Test:14, Cost:102.50578\n",
      "Pass:15, Cost:138.70033\n",
      "Test:15, Cost:7.86415\n",
      "Pass:16, Cost:165.45930\n",
      "Test:16, Cost:64.38410\n",
      "Pass:17, Cost:152.47154\n",
      "Test:17, Cost:29.15284\n",
      "Pass:18, Cost:138.93571\n",
      "Test:18, Cost:10.48840\n",
      "Pass:19, Cost:119.68816\n",
      "Test:19, Cost:29.43134\n",
      "Pass:20, Cost:197.25444\n",
      "Test:20, Cost:24.20947\n",
      "Pass:21, Cost:160.16647\n",
      "Test:21, Cost:9.46981\n",
      "Pass:22, Cost:119.94437\n",
      "Test:22, Cost:44.95092\n",
      "Pass:23, Cost:123.78200\n",
      "Test:23, Cost:50.50562\n",
      "Pass:24, Cost:124.72739\n",
      "Test:24, Cost:12.59006\n",
      "Pass:25, Cost:87.68204\n",
      "Test:25, Cost:1.80894\n",
      "Pass:26, Cost:120.34269\n",
      "Test:26, Cost:128.54480\n",
      "Pass:27, Cost:92.00354\n",
      "Test:27, Cost:12.28447\n",
      "Pass:28, Cost:31.87757\n",
      "Test:28, Cost:97.24959\n",
      "Pass:29, Cost:53.11855\n",
      "Test:29, Cost:29.35019\n",
      "Pass:30, Cost:125.88458\n",
      "Test:30, Cost:16.12622\n",
      "Pass:31, Cost:74.63180\n",
      "Test:31, Cost:13.28822\n",
      "Pass:32, Cost:31.88729\n",
      "Test:32, Cost:43.91414\n",
      "Pass:33, Cost:130.80821\n",
      "Test:33, Cost:25.24403\n",
      "Pass:34, Cost:75.27191\n",
      "Test:34, Cost:12.12042\n",
      "Pass:35, Cost:93.65819\n",
      "Test:35, Cost:10.82217\n",
      "Pass:36, Cost:115.08681\n",
      "Test:36, Cost:14.19905\n",
      "Pass:37, Cost:53.95051\n",
      "Test:37, Cost:13.51565\n",
      "Pass:38, Cost:63.14687\n",
      "Test:38, Cost:25.04268\n",
      "Pass:39, Cost:15.51875\n",
      "Test:39, Cost:16.89660\n",
      "Pass:40, Cost:34.37993\n",
      "Test:40, Cost:7.67218\n",
      "Pass:41, Cost:105.88936\n",
      "Test:41, Cost:73.32098\n",
      "Pass:42, Cost:43.80605\n",
      "Test:42, Cost:41.20872\n",
      "Pass:43, Cost:28.96686\n",
      "Test:43, Cost:0.36368\n",
      "Pass:44, Cost:113.72699\n",
      "Test:44, Cost:4.48252\n",
      "Pass:45, Cost:133.08170\n",
      "Test:45, Cost:10.91978\n",
      "Pass:46, Cost:70.03806\n",
      "Test:46, Cost:48.56998\n",
      "Pass:47, Cost:68.39425\n",
      "Test:47, Cost:2.08680\n",
      "Pass:48, Cost:133.85884\n",
      "Test:48, Cost:1.99625\n",
      "Pass:49, Cost:48.71880\n",
      "Test:49, Cost:19.31082\n",
      "save models to /home/aistudio/work/fit_a_line.inference.model\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "EPOCH_NUM=50\r\n",
    "model_save_dir = \"/home/aistudio/work/fit_a_line.inference.model\"\r\n",
    "\r\n",
    "for pass_id in range(EPOCH_NUM):                                  #训练EPOCH_NUM轮\r\n",
    "    # 开始训练并输出最后一个batch的损失值\r\n",
    "    train_cost = 0\r\n",
    "    for batch_id, data in enumerate(train_reader()):              #遍历train_reader迭代器\r\n",
    "        train_cost = exe.run(program=fluid.default_main_program(),#运行主程序\r\n",
    "                             feed=feeder.feed(data),              #喂入一个batch的训练数据，根据feed_list和data提供的信息，将输入数据转成一种特殊的数据结构\r\n",
    "                             fetch_list=[avg_cost])    \r\n",
    "        if batch_id % 40 == 0:\r\n",
    "            print(\"Pass:%d, Cost:%0.5f\" % (pass_id, train_cost[0][0]))    #打印最后一个batch的损失值\r\n",
    "        iter=iter+BATCH_SIZE\r\n",
    "        iters.append(iter)\r\n",
    "        train_costs.append(train_cost[0][0])\r\n",
    "       \r\n",
    "   \r\n",
    "    # 开始测试并输出最后一个batch的损失值\r\n",
    "    test_cost = 0\r\n",
    "    for batch_id, data in enumerate(test_reader()):               #遍历test_reader迭代器\r\n",
    "        test_cost= exe.run(program=test_program, #运行测试cheng\r\n",
    "                            feed=feeder.feed(data),               #喂入一个batch的测试数据\r\n",
    "                            fetch_list=[avg_cost])                #fetch均方误差\r\n",
    "    print('Test:%d, Cost:%0.5f' % (pass_id, test_cost[0][0]))     #打印最后一个batch的损失值\r\n",
    "    \r\n",
    "    #保存模型\r\n",
    "    # 如果保存路径不存在就创建\r\n",
    "if not os.path.exists(model_save_dir):\r\n",
    "    os.makedirs(model_save_dir)\r\n",
    "print ('save models to %s' % (model_save_dir))\r\n",
    "#保存训练参数到指定路径中，构建一个专门用预测的program\r\n",
    "fluid.io.save_inference_model(model_save_dir,   #保存推理model的路径\r\n",
    "                                  ['x'],            #推理（inference）需要 feed 的数据\r\n",
    "                                  [y_predict],      #保存推理（inference）结果的 Variables\r\n",
    "                                  exe)              #exe 保存 inference model\r\n",
    "draw_train_process(iters,train_costs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "\n",
    "# **Step5.模型预测**\n",
    "\n",
    "**（1）创建预测用的Executor**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "infer_exe = fluid.Executor(place)    #创建推测用的executor\r\n",
    "inference_scope = fluid.core.Scope() #Scope指定作用域"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**（2）可视化真实值与预测值方法定义**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "infer_results=[]\r\n",
    "groud_truths=[]\r\n",
    "\r\n",
    "#绘制真实值和预测值对比图\r\n",
    "def draw_infer_result(groud_truths,infer_results):\r\n",
    "    title='Boston'\r\n",
    "    plt.title(title, fontsize=24)\r\n",
    "    x = np.arange(1,20) \r\n",
    "    y = x\r\n",
    "    plt.plot(x, y)\r\n",
    "    plt.xlabel('ground truth', fontsize=14)\r\n",
    "    plt.ylabel('infer result', fontsize=14)\r\n",
    "    plt.scatter(groud_truths, infer_results,color='green',label='training cost') \r\n",
    "    plt.grid()\r\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**(3)开始预测**\n",
    "\n",
    "通过fluid.io.load_inference_model，预测器会从params_dirname中读取已经训练好的模型，来对从未遇见过的数据进行预测。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "infer results: (House Price)\n",
      "0: 15.05\n",
      "1: 15.20\n",
      "2: 15.07\n",
      "3: 16.41\n",
      "4: 15.53\n",
      "5: 16.07\n",
      "6: 15.84\n",
      "7: 15.56\n",
      "8: 13.82\n",
      "9: 15.49\n",
      "10: 13.18\n",
      "11: 14.53\n",
      "12: 15.07\n",
      "13: 14.68\n",
      "14: 14.66\n",
      "15: 15.43\n",
      "16: 16.23\n",
      "17: 16.14\n",
      "18: 16.56\n",
      "19: 15.37\n",
      "20: 16.00\n",
      "21: 14.77\n",
      "22: 16.37\n",
      "23: 15.77\n",
      "24: 15.60\n",
      "25: 15.12\n",
      "26: 16.18\n",
      "27: 16.04\n",
      "28: 16.87\n",
      "29: 15.89\n",
      "30: 15.74\n",
      "31: 15.16\n",
      "32: 15.32\n",
      "33: 14.41\n",
      "34: 14.04\n",
      "35: 15.54\n",
      "36: 15.59\n",
      "37: 16.00\n",
      "38: 16.18\n",
      "39: 16.03\n",
      "40: 15.12\n",
      "41: 14.89\n",
      "42: 15.99\n",
      "43: 16.22\n",
      "44: 16.16\n",
      "45: 15.94\n",
      "46: 15.59\n",
      "47: 16.29\n",
      "48: 16.37\n",
      "49: 16.62\n",
      "50: 15.47\n",
      "51: 15.68\n",
      "52: 15.33\n",
      "53: 15.57\n",
      "54: 16.32\n",
      "55: 16.65\n",
      "56: 16.31\n",
      "57: 16.69\n",
      "58: 16.80\n",
      "59: 17.07\n",
      "60: 17.30\n",
      "61: 17.21\n",
      "62: 15.79\n",
      "63: 16.29\n",
      "64: 16.90\n",
      "65: 17.38\n",
      "66: 17.09\n",
      "67: 17.48\n",
      "68: 17.44\n",
      "69: 17.73\n",
      "70: 16.37\n",
      "71: 15.98\n",
      "72: 16.69\n",
      "73: 15.57\n",
      "74: 16.52\n",
      "75: 17.01\n",
      "76: 18.03\n",
      "77: 18.27\n",
      "78: 18.41\n",
      "79: 18.29\n",
      "80: 17.80\n",
      "81: 18.08\n",
      "82: 17.24\n",
      "83: 17.80\n",
      "84: 17.32\n",
      "85: 16.63\n",
      "86: 16.02\n",
      "87: 17.39\n",
      "88: 18.01\n",
      "89: 21.00\n",
      "90: 21.09\n",
      "91: 20.90\n",
      "92: 19.93\n",
      "93: 20.66\n",
      "94: 20.87\n",
      "95: 20.43\n",
      "96: 20.56\n",
      "97: 21.70\n",
      "98: 21.49\n",
      "99: 21.83\n",
      "100: 21.74\n",
      "101: 21.52\n",
      "ground truth:\n",
      "0: 8.50\n",
      "1: 5.00\n",
      "2: 11.90\n",
      "3: 27.90\n",
      "4: 17.20\n",
      "5: 27.50\n",
      "6: 15.00\n",
      "7: 17.20\n",
      "8: 17.90\n",
      "9: 16.30\n",
      "10: 7.00\n",
      "11: 7.20\n",
      "12: 7.50\n",
      "13: 10.40\n",
      "14: 8.80\n",
      "15: 8.40\n",
      "16: 16.70\n",
      "17: 14.20\n",
      "18: 20.80\n",
      "19: 13.40\n",
      "20: 11.70\n",
      "21: 8.30\n",
      "22: 10.20\n",
      "23: 10.90\n",
      "24: 11.00\n",
      "25: 9.50\n",
      "26: 14.50\n",
      "27: 14.10\n",
      "28: 16.10\n",
      "29: 14.30\n",
      "30: 11.70\n",
      "31: 13.40\n",
      "32: 9.60\n",
      "33: 8.70\n",
      "34: 8.40\n",
      "35: 12.80\n",
      "36: 10.50\n",
      "37: 17.10\n",
      "38: 18.40\n",
      "39: 15.40\n",
      "40: 10.80\n",
      "41: 11.80\n",
      "42: 14.90\n",
      "43: 12.60\n",
      "44: 14.10\n",
      "45: 13.00\n",
      "46: 13.40\n",
      "47: 15.20\n",
      "48: 16.10\n",
      "49: 17.80\n",
      "50: 14.90\n",
      "51: 14.10\n",
      "52: 12.70\n",
      "53: 13.50\n",
      "54: 14.90\n",
      "55: 20.00\n",
      "56: 16.40\n",
      "57: 17.70\n",
      "58: 19.50\n",
      "59: 20.20\n",
      "60: 21.40\n",
      "61: 19.90\n",
      "62: 19.00\n",
      "63: 19.10\n",
      "64: 19.10\n",
      "65: 20.10\n",
      "66: 19.90\n",
      "67: 19.60\n",
      "68: 23.20\n",
      "69: 29.80\n",
      "70: 13.80\n",
      "71: 13.30\n",
      "72: 16.70\n",
      "73: 12.00\n",
      "74: 14.60\n",
      "75: 21.40\n",
      "76: 23.00\n",
      "77: 23.70\n",
      "78: 25.00\n",
      "79: 21.80\n",
      "80: 20.60\n",
      "81: 21.20\n",
      "82: 19.10\n",
      "83: 20.60\n",
      "84: 15.20\n",
      "85: 7.00\n",
      "86: 8.10\n",
      "87: 13.60\n",
      "88: 20.10\n",
      "89: 21.80\n",
      "90: 24.50\n",
      "91: 23.10\n",
      "92: 19.70\n",
      "93: 18.30\n",
      "94: 21.20\n",
      "95: 17.50\n",
      "96: 16.80\n",
      "97: 22.40\n",
      "98: 20.60\n",
      "99: 23.90\n",
      "100: 22.00\n",
      "101: 11.90\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with fluid.scope_guard(inference_scope):#修改全局/默认作用域（scope）, 运行时中的所有变量都将分配给新的scope。\r\n",
    "    #从指定目录中加载 推理model(inference model)\r\n",
    "    [inference_program,                             #推理的program\r\n",
    "     feed_target_names,                             #需要在推理program中提供数据的变量名称\r\n",
    "     fetch_targets] = fluid.io.load_inference_model(#fetch_targets: 推断结果\r\n",
    "                                    model_save_dir, #model_save_dir:模型训练路径 \r\n",
    "                                    infer_exe)      #infer_exe: 预测用executor\r\n",
    "    #获取预测数据\r\n",
    "    infer_reader = paddle.batch(paddle.dataset.uci_housing.test(),  #获取uci_housing的测试数据\r\n",
    "                          batch_size=200)                           #从测试数据中读取一个大小为200的batch数据\r\n",
    "    #从test_reader中分割x\r\n",
    "    test_data = next(infer_reader())\r\n",
    "    test_x = np.array([data[0] for data in test_data]).astype(\"float32\")\r\n",
    "    test_y= np.array([data[1] for data in test_data]).astype(\"float32\")\r\n",
    "    results = infer_exe.run(inference_program,                              #预测模型\r\n",
    "                            feed={feed_target_names[0]: np.array(test_x)},  #喂入要预测的x值\r\n",
    "                            fetch_list=fetch_targets)                       #得到推测结果 \r\n",
    "                            \r\n",
    "    print(\"infer results: (House Price)\")\r\n",
    "    for idx, val in enumerate(results[0]):\r\n",
    "        print(\"%d: %.2f\" % (idx, val))\r\n",
    "        infer_results.append(val)\r\n",
    "    print(\"ground truth:\")\r\n",
    "    for idx, val in enumerate(test_y):\r\n",
    "        print(\"%d: %.2f\" % (idx, val))\r\n",
    "        groud_truths.append(val)\r\n",
    "    draw_infer_result(groud_truths,infer_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PaddlePaddle 1.4.1 (Python 3.5)",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}