{
 "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": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f4b6e22ee58>"
      ]
     },
     "execution_count": 1,
     "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": 2,
   "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": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f4ae584a5f8>]"
      ]
     },
     "execution_count": 3,
     "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": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([2.2691], requires_grad=True)\n"
     ]
    }
   ],
   "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 进行初始化\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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\n",
    "\n",
    "def logistc_regression(x):\n",
    "    return torch.sigmoid(x*w+b) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_ = linear_model(x_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "经过上面的步骤我们就定义好了模型，在进行参数更新之前，我们可以先看看模型的输出结果长什么样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f4ae5750208>"
      ]
     },
     "execution_count": 7,
     "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": 8,
   "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": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(153.3520, grad_fn=<MeanBackward0>)\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": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自动求导\n",
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "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": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f4ae34c85f8>"
      ]
     },
     "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": [
    "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": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(3.1358)\n",
      "epoch: 0, loss: 3.135772228240967\n",
      "tensor(0.3551)\n",
      "epoch: 1, loss: 0.355089008808136\n",
      "tensor(0.3030)\n",
      "epoch: 2, loss: 0.30295446515083313\n",
      "tensor(0.3013)\n",
      "epoch: 3, loss: 0.30131959915161133\n",
      "tensor(0.3006)\n",
      "epoch: 4, loss: 0.3006228804588318\n",
      "tensor(0.2999)\n",
      "epoch: 5, loss: 0.2999469041824341\n",
      "tensor(0.2993)\n",
      "epoch: 6, loss: 0.299274742603302\n",
      "tensor(0.2986)\n",
      "epoch: 7, loss: 0.2986060082912445\n",
      "tensor(0.2979)\n",
      "epoch: 8, loss: 0.2979407012462616\n",
      "tensor(0.2973)\n",
      "epoch: 9, loss: 0.29727888107299805\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",
    "    print(loss.data)\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.item()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f4ae34c1400>"
      ]
     },
     "execution_count": 15,
     "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": 16,
   "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": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f4ae3409080>"
      ]
     },
     "execution_count": 17,
     "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": 18,
   "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": 19,
   "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": 21,
   "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": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f4ae339fef0>"
      ]
     },
     "execution_count": 22,
     "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": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(447.3372, grad_fn=<MeanBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# 计算误差，这里的误差和一元的线性模型的误差是相同的，前面已经定义过了 get_loss\n",
    "loss = get_loss(y_pred, y_train)\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自动求导\n",
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ -60.7756],\n",
      "        [ -81.7448],\n",
      "        [-401.0452]])\n",
      "tensor([-15.4545])\n"
     ]
    }
   ],
   "source": [
    "# 查看一下 w 和 b 的梯度\n",
    "print(w.grad)\n",
    "print(b.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f4ae331fd68>"
      ]
     },
     "execution_count": 27,
     "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": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 20, Loss: 22.71861\n",
      "epoch 40, Loss: 5.37627\n",
      "epoch 60, Loss: 1.32816\n",
      "epoch 80, Loss: 0.38091\n",
      "epoch 100, Loss: 0.15742\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.item()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到更新完成之后 loss 已经非常小了，我们画出更新之后的曲线对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f4ae329bba8>"
      ]
     },
     "execution_count": 29,
     "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}