{
 "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 0x7f784882de58>"
      ]
     },
     "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": 6,
   "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": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f77bfd4f860>]"
      ]
     },
     "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": [
    "# 画出图像\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.plot(x_train, y_train, 'bo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-1.1286], 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": 37,
   "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": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_ = linear_model(x_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "经过上面的步骤我们就定义好了模型，在进行参数更新之前，我们可以先看看模型的输出结果长什么样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f77bfcbc630>"
      ]
     },
     "execution_count": 11,
     "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": 13,
   "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": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(94.9309, 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": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自动求导\n",
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-126.6150])\n",
      "tensor([-18.3376])\n"
     ]
    }
   ],
   "source": [
    "# 查看 w 和 b 的梯度\n",
    "print(w.grad)\n",
    "print(b.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f77bfc38cc0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYeklEQVR4nO3df2xc5Z3v8fcnwU0wQdALFpsSYlNtlUt+kJAYbrhV2whCSBvED1FpQb6FrJaa0qWlq4oV3UhLVeB2r+4VuQVWBIuyQON22YaKzVZ0CYW0UDVQnFwnLUkaECTBaXbjhDYFnDQ//L1/zDgY4/HM2DM+M+d8XtJoZs4cn/lmFH/m8XOe8zyKCMzMrP5NSLoAMzOrDAe6mVlKONDNzFLCgW5mlhIOdDOzlDgpqTc+88wzo6WlJam3NzOrSxs3btwfEU3DvZZYoLe0tNDV1ZXU25uZ1SVJuwq95i4XM7OUcKCbmaWEA93MLCWK9qFLmgy8AEzK778mIu4css9y4H8De/KbHoiIh8st5ujRo/T09HD48OFyf9QKmDx5MtOmTaOhoSHpUsysyko5Kfon4JKIeFdSA/ALST+JiJeG7PdERNw6lmJ6eno49dRTaWlpQdJYDmVARHDgwAF6eno499xzky7HzKqsaJdL5Lybf9qQv1VlRq/Dhw9zxhlnOMwrRBJnnHGG/+IxqxGdndDSAhMm5O47Oyt7/JL60CVNlNQN7AOejYiXh9ntWklbJK2RdE6B47RL6pLU1dvbW+i9SizdSuHP06w2dHZCezvs2gURufv29sqGekmBHhHHI2IeMA24SNLsIbv8G9ASEecDzwKPFThOR0S0RkRrU9Ow4+LNzFJpxQro6/vgtr6+3PZKKWuUS0T8AVgPLB2y/UBE/Cn/9GFgQUWqq0MtLS3s378/6TLMrMbs3l3e9tEoGuiSmiSdnn98MnAZsH3IPlMHPb0S2Fa5Egurdn9URNDf31/Zg5pZJk2fXt720SilhT4VWC9pC/AKuT70H0v6lqQr8/t8VdKrkjYDXwWWV67E4VWrP2rnzp3MmDGDG264gdmzZ3PXXXdx4YUXcv7553Pnne+P1rz66qtZsGABs2bNoqOjY4z/GjNLu3vugcbGD25rbMxtr5iISOS2YMGCGGrr1q0f2lZIc3NELso/eGtuLvkQw3rzzTdDUmzYsCGeeeaZ+OIXvxj9/f1x/PjxWLZsWfz85z+PiIgDBw5ERERfX1/MmjUr9u/fn6+rOXp7e8dWRIWV87maWfWsXp3LKCl3v3p1+ccAuqJArtbtlaLV7I9qbm5m4cKFrFu3jnXr1nHBBRcwf/58tm/fzmuvvQbAfffdx9y5c1m4cCFvvfXWie1mVjuq3S1brrY22LkT+vtz921tlT1+YrMtjtX06bluluG2j9Upp5wC5P56+cY3vsHNN9/8gdd/9rOf8dOf/pQNGzbQ2NjIokWLPNbbrMYMdMsOjCwZ6JaFygdprajbFvp49EddfvnlPPLII7z7bu66qj179rBv3z4OHjzIRz/6URobG9m+fTsvvTT0olkzS9p4DBOsNXXbQh/4hl2xItfNMn16Lswr+c27ZMkStm3bxsUXXwzAlClTWL16NUuXLmXVqlWcd955zJgxg4ULF1buTc2sIsZjmGCtUa6Pffy1trbG0AUutm3bxnnnnZdIPWnmz9WyqKVl+G7Z5uZc/3W9krQxIlqHe61uu1zMzEYyLsMEa4wD3cxSqa0NOjpyLXIpd9/Rkd4TolDHfehmZsW0taU7wIdyC93MLCUc6GZmKeFANzNLCQf6GDz66KP87ne/O/H8pptuYuvWrWM+7s6dO/n+979f9s8tX76cNWvWjPn9rbBau5TcbLD6DvSEf7uGBvrDDz/MzJkzx3zc0Qa6Vdd4rDhjNhb1G+hV/O1avXo1F110EfPmzePmm2/m+PHjLF++nNmzZzNnzhxWrlzJmjVr6Orqoq2tjXnz5nHo0CEWLVrEwMVSU6ZM4fbbb2fWrFksXryYX/3qVyxatIiPf/zjrF27FsgF96c+9Snmz5/P/Pnz+eUvfwnAHXfcwYsvvsi8efNYuXIlx48f5/bbbz8xje9DDz0E5OaaufXWW5kxYwaLFy9m3759Y/63W2FZvJTc6kyhaRirfRvr9LnVmj9369atccUVV8SRI0ciIuKWW26Jb37zm7F48eIT+/z+97+PiIjPfOYz8corr5zYPvg5EE8//XRERFx99dVx2WWXxZEjR6K7uzvmzp0bERHvvfdeHDp0KCIiduzYEQOfyfr162PZsmUnjvvQQw/FXXfdFRERhw8fjgULFsQbb7wRTz75ZCxevDiOHTsWe/bsidNOOy1++MMfDvtvsrGThv8vJyVdmWUJI0yfW7/j0Ks0UcNzzz3Hxo0bufDCCwE4dOgQS5cu5Y033uArX/kKy5YtY8mSJUWP85GPfISlS3Mr9c2ZM4dJkybR0NDAnDlz2Jm/7vjo0aPceuutdHd3M3HiRHbs2DHssdatW8eWLVtO9I8fPHiQ1157jRdeeIHrr7+eiRMn8rGPfYxLLrlkTP92G1k1Z/g0q4T67XKp0npOEcGNN95Id3c33d3d/Pa3v+U73/kOmzdvZtGiRaxatYqbbrqp6HEaGhqQBMCECROYNGnSicfHjh0DYOXKlZx11lls3ryZrq4ujhw5UrCm+++//0RNb775ZklfKlZZWbyU3OpL/QZ6lX67Lr30UtasWXOiP/rtt99m165d9Pf3c+2113L33XezadMmAE499VTeeeedUb/XwYMHmTp1KhMmTOB73/sex48fH/a4l19+OQ8++CBHjx4FYMeOHbz33nt8+tOf5oknnuD48ePs3buX9evXj7oWKy6Ll5JbfanfLpcqzZ87c+ZM7r77bpYsWUJ/fz8NDQ3ce++9XHPNNScWjP72t78N5IYJfulLX+Lkk09mw4YNZb/Xl7/8Za699loef/xxli5demJhjfPPP5+JEycyd+5cli9fzm233cbOnTuZP38+EUFTUxNPPfUU11xzDc8//zwzZ85k+vTpJ6b5terJ2qXkVl88fW4G+HM1Sw9Pn2tmlgEOdDOzlKi5QE+qCyit/HmaZUdNBfrkyZM5cOCAQ6hCIoIDBw4wefLkpEsxs3FQdJSLpMnAC8Ck/P5rIuLOIftMAh4HFgAHgL+IiJ3lFjNt2jR6enro7e0t90etgMmTJzNt2rSkyzCzcVDKsMU/AZdExLuSGoBfSPpJRLw0aJ+/An4fEX8u6TrgfwF/UW4xDQ0NnHvuueX+mJmZUUKXS376gHfzTxvyt6F9IlcBj+UfrwEu1cBlkmZmNi5K6kOXNFFSN7APeDYiXh6yy9nAWwARcQw4CJwxzHHaJXVJ6nK3iplZZZUU6BFxPCLmAdOAiyTNHs2bRURHRLRGRGtTU9NoDmFmZgWUNcolIv4ArAeWDnlpD3AOgKSTgNPInRw1M7NxUjTQJTVJOj3/+GTgMmD7kN3WAjfmH38eeD489tCsJnjZvOwoZZTLVOAxSRPJfQH8S0T8WNK3yE20vhb4LvA9Sa8DbwPXVa1iMyvZwMJeAystDSzsBZ5kLI1qanIuM6uslpbhF+Vobob8OitWZzw5l1lGVWlhL6tRDnSzFKvSwl5WoxzoZinmZfOyxYFuViW1MLrEy+ZlS/0uQWdWw2ppdImXzcsOt9DNqmDFivfDfEBfX267WbU40M2qwKNLLAkO9Iyohf7cLPHoEkuCAz0DBvpzd+2CiPf7cx3q1ePRJZYEB3oGuD93/Hl0iSXBl/5nwIQJuZb5UBL0949/PWY2er70P+Pcn2uWDQ70DHB/rlk2ONAzwP25ZtngK0UzwlcLmqWfW+hmZinhQDczSwkHuplZSjjQLfU87YFlhU+KWqrV0jS2ZtXmFrqlmqc9sCxxoFuqeRpbyxIHuqVamqY98LkAK8aBbqmWlmkPPAWylaJooEs6R9J6SVslvSrptmH2WSTpoKTu/O3vq1OuWXnSMu2BzwVYKUoZ5XIM+HpEbJJ0KrBR0rMRsXXIfi9GxBWVL9FsbNIw7YHPBVgpirbQI2JvRGzKP34H2AacXe3CzOx9aToXYNVTVh+6pBbgAuDlYV6+WNJmST+RNKvAz7dL6pLU1dvbW361ZhmVlnMBVl0lB7qkKcCTwNci4o9DXt4ENEfEXOB+4KnhjhERHRHRGhGtTU1NoyzZLHvSci7AqqukJegkNQA/Bp6JiHtL2H8n0BoR+wvt4yXozMzKN6Yl6CQJ+C6wrVCYS/qz/H5Iuih/3AOjL9nMzMpVyiiXTwJfAH4tqTu/7e+A6QARsQr4PHCLpGPAIeC6SGr1aTOzjCoa6BHxC0BF9nkAeKBSRZmZWfl8paiZWUo40M3MUsKBbmaWEg50M7OUcKCbmaWEA93MLCUc6GZmKeFANzNLCQe6mVlKONDNzFLCgW5mlhIOdDOzlHCgm5mlhAPdzCwlHOhmZinhQDczSwkHuplZSjjQzcxSwoFuievshJYWmDAhd9/ZmXRFZvWplEWizaqmsxPa26GvL/d8167cc4C2tuTqMqtHbqFbolaseD/MB/T15babWXkc6Jao3bvL225mhTnQLVHTp5e33cwKc6Bbou65BxobP7itsTG33czKUzTQJZ0jab2krZJelXTbMPtI0n2SXpe0RdL86pRradPWBh0d0NwMUu6+o8MnRM1Go5RRLseAr0fEJkmnAhslPRsRWwft81ngE/nbfwMezN+bFdXW5gA3q4SiLfSI2BsRm/KP3wG2AWcP2e0q4PHIeQk4XdLUildrZmYFldWHLqkFuAB4echLZwNvDXrew4dDH0ntkrokdfX29pZZqpmZjaTkQJc0BXgS+FpE/HE0bxYRHRHRGhGtTU1NozmEmZkVUFKgS2ogF+adEfGjYXbZA5wz6Pm0/DYzMxsnpYxyEfBdYFtE3Ftgt7XADfnRLguBgxGxt4J1mplZEaWMcvkk8AXg15K689v+DpgOEBGrgKeBzwGvA33AX1a8UjMzG1HRQI+IXwAqsk8Af12poszMrHy+UtTMLCUc6GZmKeFANzNLCQe6mVlKONDNzFLCgW5mlhIOdDOzlHCgm5mlhAPdzCwlHOhmZinhQDczSwkHegV1dkJLC0yYkLvv7Ey6IjPLEgd6hXR2Qns77NoFEbn79naHetb4S92S5ECvkBUroK/vg9v6+nLbLRv8pW5FVfkb34FeIbt3l7c9a7LQcvWXuo1oHL7xHegVMn16eduzJCstV3+p24jG4RvfgV4h99wDjY0f3NbYmNuedVlpufpL3UY0Dt/4DvQKaWuDjg5obgYpd9/RkduedVlpufpL3UY0Dt/4DvQKamuDnTuhvz937zDPyUrL1V/qNqJx+MZ3oFvVZanl6i91K2gcvvEd6ClRy6NI3HI1y6vyN/5JFT2aJWJgFMnAiceBUSRQO6HZ1lY7tZillVvoKZCVUSRmNjIHegpkZRSJWdlquS+yCooGuqRHJO2T9JsCry+SdFBSd/7295Uv00aSlVEkZmXJyhVtg5TSQn8UWFpknxcjYl7+9q2xl2XlyNIoErOSZbAvsmigR8QLwNvjUIuNkkeRmA0jg32RlepDv1jSZkk/kTSr0E6S2iV1Serq7e2t0FsbePyz2YdksC+yEoG+CWiOiLnA/cBThXaMiI6IaI2I1qampgq8tZlZARnsixxzoEfEHyPi3fzjp4EGSWeOuTIzs7HIYF/kmC8skvRnwH9GREi6iNyXxIExV2ZmNlYZu6KtaKBL+gGwCDhTUg9wJ9AAEBGrgM8Dt0g6BhwCrouIqFrFZmY2rKKBHhHXF3n9AeCBilVkZmaj4itFzcxSwoFuZpYSDnQzs5RwoJuZpYQD3cwsJRzoZcrYbJxmVkcc6GXI4GyclgZuhWSGA70MGZyN0+qdWyGZ4kAvQwZn47R651ZIpjjQy5DB2Titloym68StkEypq0BPuiswg7NxWq0YbdeJWyGZUjeBXgtdgRmcjdNqxWi7TtwKyRQlNTFia2trdHV1lbx/S0suxIdqbs6t0GOWahMm5FoyQ0m5ZapG0tmZC/7du3Mt83vucSukjknaGBGtw7025vnQx4u7Ai3Tpk8fvkVTStdJxuYEz7K66XJxV6DVnUqe9HHXiZWgbgLd/5+trlT6pI9P4FgJ6qYPHdwVaHVg4D/pcN0j4JM+Nmap6EMHdwVajRtolQ8djTKYT/pYFdVNl4tZTRipX3y4oYVD+aSPVVFdtdDNEjW0BT7QLw65Px2Ltb590seqzC10s1IVu7hnpNa3T2LaOHCgm5Wq2MUQhYZirV6dOxHqMLcqc6Bb+lVqPHixiyE8tNAS5kC3dKvkePBSLoZoa8u1xvv73Sq3cVc00CU9ImmfpN8UeF2S7pP0uqQtkuZXvkyzUarkfOBugVuNK6WF/iiwdITXPwt8In9rBx4ce1lmFVLpSYDcArcaVjTQI+IF4O0RdrkKeDxyXgJOlzS1UgWajYknAbIMqUQf+tnAW4Oe9+S3mSXPkwBZhozrSVFJ7ZK6JHX19vaO51tbVrnf2zKkEoG+Bzhn0PNp+W0fEhEdEdEaEa1NTU0VeGtLhWqvLeh+b8uISgT6WuCG/GiXhcDBiNhbgeNamhQK7VpYW9AsJYrO5SLpB8Ai4ExJPcCdQANARKwCngY+B7wO9AF/Wa1irU6NNAfKSMMK3ZI2K0tdzYdudWqkBWF37x79WplmGTTSfOi+UtSqb6Sx4B5WaFYxDnSrvpFC28MKzSrGgW7VN1Joe1ihWcV4gQurvoFwLrQgrNcWNKsIB7qND4e2WdW5y8XMLCUc6FlR7asxzSxx7nLJgmKLG5tZKriFnhYjtcAruciDmdUst9DToFgLvNKLPJhZTXILPQ2KtcB9NaZZJjjQ06BYC9xXY5plggM9DYq1wH01plkmONDToJQWuBd5MEs9B3oauAVuZniUS3r40nqzzHMLvZJ8NaaZJciBXi6vjWlmNcpdLuXw2phmVsPcQi/HSKHtqzHNLGEO9HJ4bUwzq2EO9HJ4bUwzq2EO9HJ4bUwzq2E+KVoOr41pZjXMgV4uh7aZ1aiSulwkLZX0W0mvS7pjmNeXS+qV1J2/3VT5Us3MbCRFA13SROAfgc8CM4HrJc0cZtcnImJe/vZwhevM8ZWYZmYFldLlchHwekS8ASDpn4GrgK3VLOxDvC6mmdmISulyORt4a9Dznvy2oa6VtEXSGknnDHcgSe2SuiR19fb2llep18U0MxtRpYYt/hvQEhHnA88Cjw23U0R0RERrRLQ2NTWV9w6+EtPMbESlBPoeYHCLe1p+2wkRcSAi/pR/+jCwoDLlDeIrMc3MRlRKoL8CfELSuZI+AlwHrB28g6Spg55eCWyrXIl5vhLTzGxERQM9Io4BtwLPkAvqf4mIVyV9S9KV+d2+KulVSZuBrwLLK16pr8Q0MxuRIiKRN25tbY2urq5E3tvMrF5J2hgRrcO95rlczMxSwoFuZpYSDnQzs5RwoJuZpYQD3cwsJRIb5SKpF9hVwq5nAvurXE498udSmD+b4flzKayePpvmiBj2UvvEAr1UkroKDdHJMn8uhfmzGZ4/l8LS8tm4y8XMLCUc6GZmKVEPgd6RdAE1yp9LYf5shufPpbBUfDY134duZmalqYcWupmZlcCBbmaWEjUZ6JLOkbRe0tb8tLy3JV1TLZE0UdL/k/TjpGupJZJOzy+BuF3SNkkXJ11TrZD0N/nfpd9I+oGkyUnXlBRJj0jaJ+k3g7b9F0nPSnotf//RJGscrZoMdOAY8PWImAksBP5a0syEa6olt1GNRUTq33eAf4+I/wrMxZ8RAJLOJrdOQWtEzAYmkluoJqseBZYO2XYH8FxEfAJ4Lv+87tRkoEfE3ojYlH/8DrlfzOEWps4cSdOAZeSW+rM8SacBnwa+CxARRyLiD4kWVVtOAk6WdBLQCPwu4XoSExEvAG8P2XwV76+F/Bhw9XjWVCk1GeiDSWoBLgBeTriUWvF/gb8F+hOuo9acC/QC/5TvjnpY0ilJF1ULImIP8H+A3cBe4GBErEu2qppzVkTszT/+D+CsJIsZrZoOdElTgCeBr0XEH5OuJ2mSrgD2RcTGpGupQScB84EHI+IC4D3q9M/mSsv3B19F7kvvY8Apkv5HslXVrsiN5a7L8dw1G+iSGsiFeWdE/CjpemrEJ4ErJe0E/hm4RNLqZEuqGT1AT0QM/CW3hlzAGywG3oyI3og4CvwI+O8J11Rr/nNgsfv8/b6E6xmVmgx0SSLXF7otIu5Nup5aERHfiIhpEdFC7qTW8xHhlhYQEf8BvCVpRn7TpcDWBEuqJbuBhZIa879bl+ITxkOtBW7MP74R+NcEaxm1mgx0ci3RL5BrgXbnb59LuiireV8BOiVtAeYB/zPZcmpD/q+WNcAm4Nfkfu9Tcan7aEj6AbABmCGpR9JfAf8AXCbpNXJ/0fxDkjWOli/9NzNLiVptoZuZWZkc6GZmKeFANzNLCQe6mVlKONDNzFLCgW5mlhIOdDOzlPj/zgP8vFf64CgAAAAASUVORK5CYII=\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": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1.9596)\n",
      "epoch: 0, loss: 1.9595526456832886\n",
      "tensor(0.2388)\n",
      "epoch: 1, loss: 0.23876741528511047\n",
      "tensor(0.2067)\n",
      "epoch: 2, loss: 0.20673297345638275\n",
      "tensor(0.2060)\n",
      "epoch: 3, loss: 0.2059527039527893\n",
      "tensor(0.2058)\n",
      "epoch: 4, loss: 0.20575186610221863\n",
      "tensor(0.2056)\n",
      "epoch: 5, loss: 0.2055628001689911\n",
      "tensor(0.2054)\n",
      "epoch: 6, loss: 0.20537473261356354\n",
      "tensor(0.2052)\n",
      "epoch: 7, loss: 0.20518775284290314\n",
      "tensor(0.2050)\n",
      "epoch: 8, loss: 0.20500165224075317\n",
      "tensor(0.2048)\n",
      "epoch: 9, loss: 0.2048165202140808\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": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f77bd9b2b38>"
      ]
     },
     "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": [
    "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": 21,
   "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": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f77bd970c50>"
      ]
     },
     "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",
    "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": 23,
   "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": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f77bd90cac8>"
      ]
     },
     "execution_count": 26,
     "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": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(509.5237, grad_fn=<MeanBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# 计算误差，这里的误差和一元的线性模型的误差是相同的，前面已经定义过了 get_loss\n",
    "loss = get_loss(y_pred, y_train)\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自动求导\n",
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ -64.6688],\n",
      "        [ -84.8521],\n",
      "        [-431.2343]])\n",
      "tensor([-16.0116])\n"
     ]
    }
   ],
   "source": [
    "# 查看一下 w 和 b 的梯度\n",
    "print(w.grad)\n",
    "print(b.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f77bd8869b0>"
      ]
     },
     "execution_count": 31,
     "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": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 20, Loss: 1.55844\n",
      "epoch 40, Loss: 0.53303\n",
      "epoch 60, Loss: 0.28755\n",
      "epoch 80, Loss: 0.22432\n",
      "epoch 100, Loss: 0.20383\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": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f77bd815b70>"
      ]
     },
     "execution_count": 36,
     "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
}