{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 线性模型和梯度下降\n",
    "\n",
    "本节我们简单回顾一下线性回归模型，并演示一下如何使用PyTorch来对线性回归模型进行建模和模型参数计算。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 一元线性回归\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": [
    "## 2. 梯度下降法\n",
    "在梯度下降法中，我们首先要明确梯度的概念，随后我们再了解如何使用梯度进行下降。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 梯度\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": [
    "### 2.2 梯度下降法\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": [
    "### 2.3 PyTorch实现\n",
    "\n",
    "上面是原理部分，下面通过一个例子来进一步学习线性模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f6c99769e50>"
      ]
     },
     "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(2021)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f6c970c7650>]"
      ]
     },
     "execution_count": 2,
     "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_train = np.random.rand(20, 1)\n",
    "y_train = x_train * 3 + 4 + 3*np.random.rand(20,1)\n",
    "\n",
    "# 画出图像\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.plot(x_train, y_train, 'bo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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": 4,
   "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": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_ = linear_model(x_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "经过上面的步骤我们就定义好了模型，在进行参数更新之前，我们可以先看看模型的输出结果长什么样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f6c96f743d0>"
      ]
     },
     "execution_count": 6,
     "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",
    "E = \\sum_{i=1}^n(\\hat{y}_i - y_i)^2\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算误差\n",
    "def get_loss(y_, y):\n",
    "    return torch.sum((y_ - y) ** 2)\n",
    "\n",
    "loss = get_loss(y_, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(719.2896, dtype=torch.float64, grad_fn=<SumBackward0>)\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": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自动求导\n",
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-153.8987])\n",
      "tensor([-237.1102])\n"
     ]
    }
   ],
   "source": [
    "# 查看 w 和 b 的梯度\n",
    "print(w.grad)\n",
    "print(b.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f6c93fe0790>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 19, loss: 15.28364363077673\n",
      "epoch: 39, loss: 14.795312869325372\n",
      "epoch: 59, loss: 14.536351699107472\n",
      "epoch: 79, loss: 14.39902521175574\n",
      "epoch: 99, loss: 14.326200708394845\n"
     ]
    }
   ],
   "source": [
    "for e in range(100): # 进行 100 次更新\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",
    "    if (e + 1) % 20 == 0:\n",
    "        print('epoch: {}, loss: {}'.format(e, loss.item()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f6c93f60750>"
      ]
     },
     "execution_count": 14,
     "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": [
    "经过 100 次更新，我们发现红色的预测结果已经比较好的拟合了蓝色的真实值。\n",
    "\n",
    "现在你已经学会了你的第一个机器学习模型了，再接再厉，完成下面的小练习。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 练习题\n",
    "\n",
    "重启 notebook 运行上面的线性回归模型，但是改变训练次数以及不同的学习率进行尝试得到不同的结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 多项式回归模型"
   ]
  },
  {
   "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": 15,
   "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": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f6c93ee6190>"
      ]
     },
     "execution_count": 16,
     "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": 17,
   "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": 18,
   "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": 19,
   "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\n",
    "\n",
    "def get_loss(y_, y):\n",
    "    return torch.mean((y_ - y) ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以画出没有更新之前的模型和真实的模型之间的对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f6c93e196d0>"
      ]
     },
     "execution_count": 20,
     "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": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1144.2655, grad_fn=<MeanBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# 计算误差，这里的误差和一元的线性模型的误差是相同的，前面已经定义过了 get_loss\n",
    "loss = get_loss(y_pred, y_train)\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自动求导\n",
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ -94.7455],\n",
      "        [-139.1247],\n",
      "        [-629.8584]])\n",
      "tensor([-25.7413])\n"
     ]
    }
   ],
   "source": [
    "# 查看一下 w 和 b 的梯度\n",
    "print(w.grad)\n",
    "print(b.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f6c93db3690>"
      ]
     },
     "execution_count": 25,
     "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": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 20, Loss: 65.56586\n",
      "epoch 40, Loss: 15.41177\n",
      "epoch 60, Loss: 3.70702\n",
      "epoch 80, Loss: 0.97122\n",
      "epoch 100, Loss: 0.32874\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": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f6c93cd05d0>"
      ]
     },
     "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": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 4. 练习题\n",
    "\n",
    "上面的例子是一个三次的多项式，尝试使用二次的多项式去拟合它，看看最后能做到多好\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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}