machinelearning_notebook/6_pytorch/1_NN/1-linear-regression-gradient-descend.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 线性模型和梯度下降\n",
    "这是神经网络的第一课，我们会学习一个非常简单的模型，线性回归，同时也会学习一个优化算法-梯度下降法，对这个模型进行优化。线性回归是监督学习里面一个非常简单的模型，同时梯度下降也是深度学习中应用最广的优化算法，我们将从这里开始我们的深度学习之旅"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一元线性回归\n",
    "一元线性模型非常简单，假设我们有变量 $x_i$ 和目标 $y_i$，每个 i 对应于一个数据点，希望建立一个模型\n",
    "\n",
    "$$\n",
    "\\hat{y}_i = w x_i + b\n",
    "$$\n",
    "\n",
    "$\\hat{y}_i$ 是我们预测的结果，希望通过 $\\hat{y}_i$ 来拟合目标 $y_i$，通俗来讲就是找到这个函数拟合 $y_i$ 使得误差最小，即最小化\n",
    "\n",
    "$$\n",
    "\\frac{1}{n} \\sum_{i=1}^n(\\hat{y}_i - y_i)^2\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "那么如何最小化这个误差呢？\n",
    "\n",
    "这里需要用到**梯度下降**，这是我们接触到的第一个优化算法，非常简单，但是却非常强大，在深度学习中被大量使用，所以让我们从简单的例子出发了解梯度下降法的原理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 梯度下降法\n",
    "在梯度下降法中，我们首先要明确梯度的概念，随后我们再了解如何使用梯度进行下降。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 梯度\n",
    "梯度在数学上就是导数，如果是一个多元函数，那么梯度就是偏导数。比如一个函数f(x, y)，那么 f 的梯度就是 \n",
    "\n",
    "$$\n",
    "(\\frac{\\partial f}{\\partial x},\\ \\frac{\\partial f}{\\partial y})\n",
    "$$\n",
    "\n",
    "可以称为 grad f(x, y) 或者 $\\nabla f(x, y)$。具体某一点 $(x_0,\\ y_0)$ 的梯度就是 $\\nabla f(x_0,\\ y_0)$。\n",
    "\n",
    "下面这个图片是 $f(x) = x^2$ 这个函数在 x=1 处的梯度\n",
    "\n",
    "![](https://ws3.sinaimg.cn/large/006tNc79ly1fmarbuh2j3j30ba0b80sy.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "梯度有什么意义呢？从几何意义来讲，一个点的梯度值是这个函数变化最快的地方，具体来说，对于函数 f(x, y)，在点 $(x_0, y_0)$ 处，沿着梯度 $\\nabla f(x_0,\\ y_0)$ 的方向，函数增加最快，也就是说沿着梯度的方向，我们能够更快地找到函数的极大值点，或者反过来沿着梯度的反方向，我们能够更快地找到函数的最小值点。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 梯度下降法\n",
    "有了对梯度的理解，我们就能了解梯度下降发的原理了。上面我们需要最小化这个误差，也就是需要找到这个误差的最小值点，那么沿着梯度的反方向我们就能够找到这个最小值点。\n",
    "\n",
    "我们可以来看一个直观的解释。比如我们在一座大山上的某处位置，由于我们不知道怎么下山，于是决定走一步算一步，也就是在每走到一个位置的时候，求解当前位置的梯度，沿着梯度的负方向，也就是当前最陡峭的位置向下走一步，然后继续求解当前位置梯度，向这一步所在位置沿着最陡峭最易下山的位置走一步。这样一步步的走下去，一直走到觉得我们已经到了山脚。当然这样走下去，有可能我们不能走到山脚，而是到了某一个局部的山峰低处。\n",
    "\n",
    "类比我们的问题，就是沿着梯度的反方向，我们不断改变 w 和 b 的值，最终找到一组最好的 w 和 b 使得误差最小。\n",
    "\n",
    "在更新的时候，我们需要决定每次更新的幅度，比如在下山的例子中，我们需要每次往下走的那一步的长度，这个长度称为学习率，用 $\\eta$ 表示，这个学习率非常重要，不同的学习率都会导致不同的结果，学习率太小会导致下降非常缓慢，学习率太大又会导致跳动非常明显，可以看看下面的例子\n",
    "\n",
    "![](https://ws2.sinaimg.cn/large/006tNc79ly1fmgn23lnzjg30980gogso.gif)\n",
    "\n",
    "可以看到上面的学习率较为合适，而下面的学习率太大，就会导致不断跳动\n",
    "\n",
    "最后我们的更新公式就是\n",
    "\n",
    "$$\n",
    "w := w - \\eta \\frac{\\partial f(w,\\ b)}{\\partial w} \\\\\n",
    "b := b - \\eta \\frac{\\partial f(w,\\ b)}{\\partial b}\n",
    "$$\n",
    "\n",
    "通过不断地迭代更新，最终我们能够找到一组最优的 w 和 b，这就是梯度下降法的原理。\n",
    "\n",
    "最后可以通过这张图形象地说明一下这个方法\n",
    "\n",
    "![](https://ws3.sinaimg.cn/large/006tNc79ly1fmarxsltfqj30gx091gn4.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面是原理部分，下面通过一个例子来进一步学习线性模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f53f805ecd0>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "from torch.autograd import Variable\n",
    "\n",
    "torch.manual_seed(2017)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读入数据 x 和 y\n",
    "x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],\n",
    "                    [9.779], [6.182], [7.59], [2.167], [7.042],\n",
    "                    [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)\n",
    "\n",
    "y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],\n",
    "                    [3.366], [2.596], [2.53], [1.221], [2.827],\n",
    "                    [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f539410ee48>]"
      ]
     },
     "execution_count": 9,
     "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": [
    "# 画出图像\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.plot(x_train, y_train, 'bo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 转换成 Tensor\n",
    "x_train = torch.from_numpy(x_train)\n",
    "y_train = torch.from_numpy(y_train)\n",
    "\n",
    "# 定义参数 w 和 b\n",
    "w = Variable(torch.randn(1), requires_grad=True) # 随机初始化\n",
    "b = Variable(torch.zeros(1), requires_grad=True) # 使用 0 进行初始化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构建线性回归模型\n",
    "x_train = Variable(x_train)\n",
    "y_train = Variable(y_train)\n",
    "\n",
    "def linear_model(x):\n",
    "    return x * w + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_ = linear_model(x_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "经过上面的步骤我们就定义好了模型，在进行参数更新之前，我们可以先看看模型的输出结果长什么样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f53940f2320>"
      ]
     },
     "execution_count": 13,
     "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.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real')\n",
    "plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**思考：红色的点表示预测值，似乎排列成一条直线，请思考一下这些点是否在一条直线上？**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个时候需要计算我们的误差函数，也就是\n",
    "\n",
    "$$\n",
    "\\frac{1}{n} \\sum_{i=1}^n(\\hat{y}_i - y_i)^2\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算误差\n",
    "def get_loss(y_, y):\n",
    "    return torch.mean((y_ - y) ** 2)\n",
    "\n",
    "loss = get_loss(y_, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(153.3520, grad_fn=<MeanBackward1>)\n"
     ]
    }
   ],
   "source": [
    "# 打印一下看看 loss 的大小\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义好了误差函数，接下来我们需要计算 w 和 b 的梯度了，这时得益于 PyTorch 的自动求导，我们不需要手动去算梯度，有兴趣的同学可以手动计算一下，w 和 b 的梯度分别是\n",
    "\n",
    "$$\n",
    "\\frac{\\partial}{\\partial w} = \\frac{2}{n} \\sum_{i=1}^n x_i(w x_i + b - y_i) \\\\\n",
    "\\frac{\\partial}{\\partial b} = \\frac{2}{n} \\sum_{i=1}^n (w x_i + b - y_i)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自动求导\n",
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([161.0043])\n",
      "tensor([22.8730])\n"
     ]
    }
   ],
   "source": [
    "# 查看 w 和 b 的梯度\n",
    "print(w.grad)\n",
    "print(b.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 更新一次参数\n",
    "w.data = w.data - 1e-2 * w.grad.data\n",
    "b.data = b.data - 1e-2 * b.grad.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "更新完成参数之后，我们再一次看看模型输出的结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f53940bc438>"
      ]
     },
     "execution_count": 19,
     "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": [
    "y_ = linear_model(x_train)\n",
    "plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real')\n",
    "plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从上面的例子可以看到，更新之后红色的线跑到了蓝色的线下面，没有特别好的拟合蓝色的真实值，所以我们需要在进行几次更新"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0, loss: 3.135772228240967\n",
      "epoch: 1, loss: 0.355089008808136\n",
      "epoch: 2, loss: 0.30295446515083313\n",
      "epoch: 3, loss: 0.30131959915161133\n",
      "epoch: 4, loss: 0.3006228804588318\n",
      "epoch: 5, loss: 0.2999469041824341\n",
      "epoch: 6, loss: 0.299274742603302\n",
      "epoch: 7, loss: 0.2986060082912445\n",
      "epoch: 8, loss: 0.2979407012462616\n",
      "epoch: 9, loss: 0.29727888107299805\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:11: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    }
   ],
   "source": [
    "for e in range(10): # 进行 10 次更新\n",
    "    y_ = linear_model(x_train)\n",
    "    loss = get_loss(y_, y_train)\n",
    "    \n",
    "    w.grad.zero_() # 记得归零梯度\n",
    "    b.grad.zero_() # 记得归零梯度\n",
    "    loss.backward()\n",
    "    \n",
    "    w.data = w.data - 1e-2 * w.grad.data # 更新 w\n",
    "    b.data = b.data - 1e-2 * b.grad.data # 更新 b \n",
    "    print('epoch: {}, loss: {}'.format(e, loss.data[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f53942d5550>"
      ]
     },
     "execution_count": 21,
     "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": [
    "y_ = linear_model(x_train)\n",
    "plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real')\n",
    "plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "经过 10 次更新，我们发现红色的预测结果已经比较好的拟合了蓝色的真实值。\n",
    "\n",
    "现在你已经学会了你的第一个机器学习模型了，再接再厉，完成下面的小练习。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**小练习：**\n",
    "\n",
    "重启 notebook 运行上面的线性回归模型，但是改变训练次数以及不同的学习率进行尝试得到不同的结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多项式回归模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面我们更进一步，讲一讲多项式回归。什么是多项式回归呢？非常简单，根据上面的线性回归模型\n",
    "\n",
    "$$\n",
    "\\hat{y} = w x + b\n",
    "$$\n",
    "\n",
    "这里是关于 x 的一个一次多项式，这个模型比较简单，没有办法拟合比较复杂的模型，所以我们可以使用更高次的模型，比如\n",
    "\n",
    "$$\n",
    "\\hat{y} = w_0 + w_1 x + w_2 x^2 + w_3 x^3 + \\cdots\n",
    "$$\n",
    "\n",
    "这样就能够拟合更加复杂的模型，这就是多项式模型，这里使用了 x 的更高次，同理还有多元回归模型，形式也是一样的，只是出了使用 x，还是更多的变量，比如 y、z 等等，同时他们的 loss 函数和简单的线性回归模型是一致的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先我们可以先定义一个需要拟合的目标函数，这个函数是个三次的多项式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 0.90 + 0.50 * x + 3.00 * x^2 + 2.40 * x^3\n"
     ]
    }
   ],
   "source": [
    "# 定义一个多变量函数\n",
    "\n",
    "w_target = np.array([0.5, 3, 2.4]) # 定义参数\n",
    "b_target = np.array([0.9]) # 定义参数\n",
    "\n",
    "f_des = 'y = {:.2f} + {:.2f} * x + {:.2f} * x^2 + {:.2f} * x^3'.format(\n",
    "    b_target[0], w_target[0], w_target[1], w_target[2]) # 打印出函数的式子\n",
    "\n",
    "print(f_des)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以先画出这个多项式的图像"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f53910144e0>"
      ]
     },
     "execution_count": 23,
     "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": [
    "# 画出这个函数的曲线\n",
    "x_sample = np.arange(-3, 3.1, 0.1)\n",
    "y_sample = b_target[0] + w_target[0] * x_sample + w_target[1] * x_sample ** 2 + w_target[2] * x_sample ** 3\n",
    "\n",
    "plt.plot(x_sample, y_sample, label='real curve')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接着我们可以构建数据集，需要 x 和 y，同时是一个三次多项式，所以我们取了 $x,\\ x^2, x^3$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构建数据 x 和 y\n",
    "# x 是一个如下矩阵 [x, x^2, x^3]\n",
    "# y 是函数的结果 [y]\n",
    "\n",
    "x_train = np.stack([x_sample ** i for i in range(1, 4)], axis=1)\n",
    "x_train = torch.from_numpy(x_train).float() # 转换成 float tensor\n",
    "\n",
    "y_train = torch.from_numpy(y_sample).float().unsqueeze(1) # 转化成 float tensor "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([61, 3])\n"
     ]
    }
   ],
   "source": [
    "print(x_train.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接着我们可以定义需要优化的参数，就是前面这个函数里面的 $w_i$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义参数和模型\n",
    "w = Variable(torch.randn(3, 1), requires_grad=True)\n",
    "b = Variable(torch.zeros(1), requires_grad=True)\n",
    "\n",
    "# 将 x 和 y 转换成 Variable\n",
    "x_train = Variable(x_train)\n",
    "y_train = Variable(y_train)\n",
    "\n",
    "def multi_linear(x):\n",
    "    return torch.mm(x, w) + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以画出没有更新之前的模型和真实的模型之间的对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5390feddd8>"
      ]
     },
     "execution_count": 28,
     "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": [
    "# 画出更新之前的模型\n",
    "y_pred = multi_linear(x_train)\n",
    "\n",
    "plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label='fitting curve', color='r')\n",
    "plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以发现，这两条曲线之间存在差异，我们计算一下他们之间的误差"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(413.9844, grad_fn=<MeanBackward1>)\n"
     ]
    }
   ],
   "source": [
    "# 计算误差，这里的误差和一元的线性模型的误差是相同的，前面已经定义过了 get_loss\n",
    "loss = get_loss(y_pred, y_train)\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自动求导\n",
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ -34.1391],\n",
      "        [-146.6133],\n",
      "        [-215.9149]])\n",
      "tensor([-27.0838])\n"
     ]
    }
   ],
   "source": [
    "# 查看一下 w 和 b 的梯度\n",
    "print(w.grad)\n",
    "print(b.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 更新一下参数\n",
    "w.data = w.data - 0.001 * w.grad.data\n",
    "b.data = b.data - 0.001 * b.grad.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5390fb8a20>"
      ]
     },
     "execution_count": 33,
     "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": [
    "# 画出更新一次之后的模型\n",
    "y_pred = multi_linear(x_train)\n",
    "\n",
    "plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label='fitting curve', color='r')\n",
    "plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为只更新了一次，所以两条曲线之间的差异仍然存在，我们进行 100 次迭代"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 20, Loss: 73.67843\n",
      "epoch 40, Loss: 17.97095\n",
      "epoch 60, Loss: 4.94101\n",
      "epoch 80, Loss: 1.87171\n",
      "epoch 100, Loss: 1.12812\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:14: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "# 进行 100 次参数更新\n",
    "for e in range(100):\n",
    "    y_pred = multi_linear(x_train)\n",
    "    loss = get_loss(y_pred, y_train)\n",
    "    \n",
    "    w.grad.data.zero_()\n",
    "    b.grad.data.zero_()\n",
    "    loss.backward()\n",
    "    \n",
    "    # 更新参数\n",
    "    w.data = w.data - 0.001 * w.grad.data\n",
    "    b.data = b.data - 0.001 * b.grad.data\n",
    "    if (e + 1) % 20 == 0:\n",
    "        print('epoch {}, Loss: {:.5f}'.format(e+1, loss.data[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到更新完成之后 loss 已经非常小了，我们画出更新之后的曲线对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5390f019e8>"
      ]
     },
     "execution_count": 35,
     "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": [
    "# 画出更新之后的结果\n",
    "y_pred = multi_linear(x_train)\n",
    "\n",
    "plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label='fitting curve', color='r')\n",
    "plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到，经过 100 次更新之后，可以看到拟合的线和真实的线已经完全重合了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**小练习：上面的例子是一个三次的多项式，尝试使用二次的多项式去拟合它，看看最后能做到多好**\n",
    "\n",
    "**提示：参数 `w = torch.randn(2, 1)`，同时重新构建 x 数据集**"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}