machinelearning_notebook/6_pytorch/3-linear-regression-gradient-descend.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 线性模型的PyTorch实现\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": [
    "那么如何最小化这个误差呢？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 梯度下降法\n",
    "\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "梯度有什么意义呢？从几何意义来讲，一个点的梯度值是这个函数变化最快的地方。具体来说，对于函数 f(x, y)，在点 $(x_0, y_0)$ 处，沿着梯度 $\\nabla f(x_0,\\ y_0)$ 的方向，函数增加最快，也就是说沿着梯度的方向，能够更快地找到函数的极大值点，或者反过来沿着梯度的反方向，能够更快地找到函数的最小值点。\n",
    "\n",
    "针对一元线性回归问题，就是沿着梯度的反方向，不断改变 $w$ 和 $b$ 的值，最终找到一组最好的 $w$ 和 $b$ 使得误差最小。\n",
    "\n",
    "在更新的时候，需要决定每次更新的幅度就是每次往下走的那一步的长度，这个长度称为学习率，用 $\\eta$ 表示。不同的学习率都会导致不同的结果，学习率太小会导致下降非常缓慢；学习率太大又会导致跳动非常明显。\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$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. PyTorch实现\n",
    "\n",
    "上面是原理部分，下面通过一个例子来进一步学习线性模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f87041343f0>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "torch.manual_seed(2021)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Matplotlib is building the font cache; this may take a moment.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f85e9151580>]"
      ]
     },
     "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 = torch.randn(1, requires_grad=True) # 随机初始化\n",
    "b = torch.zeros(1, requires_grad=True) # 使用 0 进行初始化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构建线性回归模型\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 0x7f85e9048640>"
      ]
     },
     "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(733.2964, 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([-135.3880])\n",
      "tensor([-239.5816])\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 0x7f85e8fcb2e0>"
      ]
     },
     "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: 17.798984092741378\n",
      "epoch: 39, loss: 16.14508120463308\n",
      "epoch: 59, loss: 15.55101918276564\n",
      "epoch: 79, loss: 15.33763961353287\n",
      "epoch: 99, loss: 15.26099545058815\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 0x7f85e8735970>"
      ]
     },
     "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": [
    "## 4. 多项式回归模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面更进一步尝试一下多项式回归，下面是关于 x 的多项式：\n",
    "\n",
    "$$\n",
    "\\hat{y} = w_0 + w_1 x + w_2 x^2 + w_3 x^3 \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 0x7f85e86d5640>"
      ]
     },
     "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 = torch.randn((3, 1), dtype=torch.float, requires_grad=True)\n",
    "b = torch.zeros((1), dtype=torch.float, requires_grad=True)\n",
    "\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 0x7f85e8619220>"
      ]
     },
     "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.2654, 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 0x7f85e860c9a0>"
      ]
     },
     "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 0x7f85e8584ee0>"
      ]
     },
     "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": [
    "## 5. 练习题\n",
    "\n",
    "上面的例子是一个三次的多项式，尝试使用二次的多项式去拟合它，看看最后能做到多好\n",
    "\n",
    "**提示：参数 `w = torch.randn(2, 1)`，同时重新构建 x 数据集**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}