6_pytorch/3-linear-regression.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 0x7f6140077130>"
      ]
     },
     "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": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f60ec84f0d0>]"
      ]
     },
     "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": 5,
   "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": 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 0x7f60ec8b6c50>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAD4CAYAAADFAawfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAXYklEQVR4nO3de3Bc5XnH8d8jWcYRuIQaNQMYS9BJCL5jC2qaCXHBMS6mCYyZFiISnMSYSyG0zdCacWegBU96G1yShotKKBeLhMZkMjQlwQFMSIhJkEEmxYBJbNnI0FpWiEN8iXV5+sfZtWWxqz2Szu6+Z/f7mdHs7tHx7qOz8k/vvud932PuLgBAuGrKXQAAYHgENQAEjqAGgMAR1AAQOIIaAAI3rhhPevzxx3tTU1MxnhoAKtLGjRt3u3tDru8VJaibmprU3t5ejKcGgIpkZtvzfY+uDwAIHEENAIEjqAEgcEXpo86lt7dXXV1dOnDgQKlesuJNmDBBkydPVl1dXblLAVBEJQvqrq4uTZw4UU1NTTKzUr1sxXJ39fT0qKurS6ecckq5ywFQRCXr+jhw4IAmTZpESCfEzDRp0iQ+oQABaGuTmpqkmprotq0t2ecvWYtaEiGdMI4nUH5tbdLy5dK+fdHj7dujx5LU0pLMa3AyEQDGYOXKwyGdtW9ftD0pBHVMTU1N2r17d7nLABCYHTtGtn00gg3qYvb5uLsGBgaSe0IAVWvKlJFtH40ggzrb57N9u+R+uM9nLGHd2dmp0047TZ/5zGc0ffp03XrrrTrzzDM1c+ZM3XzzzYf2u+iiizR37lxNmzZNra2tCfw0QJiKfQKsWqxaJdXXH7mtvj7anhh3T/xr7ty5PtTmzZvfsy2fxkb3KKKP/GpsjP0U77Ft2zY3M9+wYYM/8cQTfuWVV/rAwID39/f74sWL/Qc/+IG7u/f09Li7+759+3zatGm+e/fuTE2N3t3dPfoCimQkxxXIWrPGvb7+yP9f9fXRdozcmjVRPplFt6M5jpLaPU+mBtmiLlafT2Njo+bNm6d169Zp3bp1OuOMMzRnzhy99tpreuONNyRJX/7ylzVr1izNmzdPb7755qHtQCUpxQmwatLSInV2SgMD0W1Soz2ySjo8L64pU6Lujlzbx+Loo4+WFH2KuOmmm3TVVVcd8f1nnnlGTz75pDZs2KD6+nrNnz+fccqoSKU4AYbkBNmiLnafz/nnn6/77rtPv/nNbyRJO3fu1K5du7Rnzx4dd9xxqq+v12uvvabnn38+mRcEAlOKE2BITpBB3dIitbZKjY2SWXTb2prcx4mFCxfqU5/6lM4++2zNmDFDl1xyid59910tWrRIfX19Ov3007VixQrNmzcvmRcEAlOSE2BIjEV92Mlqbm72oRcOePXVV3X66acn/lrVjuOK0Wpri/qkd+yIWtKrViXft4r4zGyjuzfn+l6QfdQAiq+lhWBOiyC7PgAAhxHUABA4ghoAAkdQA0DgCGoACBxBncP999+vt95669DjZcuWafPmzWN+3s7OTj388MMj/ndLly7V2rVrx/z6ANIpVlCb2V+a2Stm9j9m9nUzm1Dswsq5tNfQoL733ns1derUMT/vaIMaQHUrGNRmdpKkL0hqdvfpkmolXVrUqoqxzqmkNWvW6KyzztLs2bN11VVXqb+/X0uXLtX06dM1Y8YMrV69WmvXrlV7e7taWlo0e/Zs7d+/X/Pnz1d2As8xxxyjG2+8UdOmTdOCBQv005/+VPPnz9epp56qxx57TFIUyB/96Ec1Z84czZkzRz/+8Y8lSStWrNAPf/hDzZ49W6tXr1Z/f79uvPHGQ8ut3nPPPZKitUiuu+46nXbaaVqwYIF27do1pp8bQMrlW1Yv+yXpJElvSvpdRRNkviNp4XD/ZqzLnBZjndPNmzf7hRde6AcPHnR392uuucZvueUWX7BgwaF93nnnHXd3/9jHPuYvvPDCoe2DH0vyxx9/3N3dL7roIv/4xz/uBw8e9I6ODp81a5a7u+/du9f379/v7u5btmzx7PFYv369L168+NDz3nPPPX7rrbe6u/uBAwd87ty5vnXrVn/00Ud9wYIF3tfX5zt37vRjjz3Wv/nNb+b9uQCkn4ZZ5rTgzER332lm/yJph6T9kta5+7qh+5nZcknLJWnKWFd2KcLSXk899ZQ2btyoM888U5K0f/9+LVq0SFu3btX111+vxYsXa+HChQWfZ/z48Vq0aJEkacaMGTrqqKNUV1enGTNmqLOzU5LU29ur6667Th0dHaqtrdWWLVtyPte6dev08ssvH+p/3rNnj9544w09++yzuuyyy1RbW6sTTzxR55577qh/bgDpF6fr4zhJn5R0iqQTJR1tZpcP3c/dW9292d2bGxoaxlZVEZb2cnddccUV6ujoUEdHh15//XXdcccd2rRpk+bPn6+7775by5YtK/g8dXV1h67+XVNTo6OOOurQ/b6+PknS6tWr9YEPfECbNm1Se3u7Dh48mLemr3zlK4dq2rZtW6w/FgCqS5yTiQskbXP3bnfvlfQtSX9Y1KqKsLTXeeedp7Vr1x7q7/3lL3+p7du3a2BgQEuWLNFtt92mF198UZI0ceJEvfvuu6N+rT179uiEE05QTU2NHnroIfX39+d83vPPP1933XWXent7JUlbtmzR3r17dc455+iRRx5Rf3+/3n77ba1fv37UteC9uAQV0ibOokw7JM0zs3pFXR/nSWof/p+MUXalmASX9po6dapuu+02LVy4UAMDA6qrq9Ptt9+uiy+++NCFbr/0pS9JiobDXX311Xrf+96nDRs2jPi1rr32Wi1ZskQPPvigFi1adOiCBTNnzlRtba1mzZqlpUuX6oYbblBnZ6fmzJkjd1dDQ4O+/e1v6+KLL9bTTz+tqVOnasqUKTr77LNH/XPjSNnz1Nmrm2TPU0ssUIRwxVrm1Mz+TtKfSeqT9JKkZe7+23z7s8xp6XBcj1Ro6c6mptxXD2psjC6hBJTLmJc5dfebJd1ccEegjOK0lrkEFdKImYmoGHEu2MolqJBGJQ3qON0siI/jeaQ4rWUuQYU0KllQT5gwQT09PYRLQtxdPT09mjChuLP5Qxwhka+mOK3lYl+Ps1qE+HtRyUp2zcTe3l51dXXpwIEDib9etZowYYImT56surq6ojz/0D5fKWp9ljPYhqtJCq/eShTi70UlGO5kYsmCGukT4giJQjVxwdbiC/H3ohIQ1BiVmppokZWhzKTM0POSC7GmasN7UBzDBTWjPpBXiCMkQqyp2vAelB5BjbxCHCERYk3Vhveg9Ahq5BXiCIkQa6o2vAelRx91AZycAlAK9FGPUpEuNIOUYuwwyoWgHkacKcmoDvzRRjkR1MNgAR9k8Ucb5URQD4NhSMjijzbKiaAeBsOQkMUfbZQTQT0MhiEhiz/aKKdYFw6oZi0tBDOKcnU4IDZa1Bizahm21tISLTo0MBDdEtLV896XGy1qjAkXi61evPelw8xEjFpbm3TFFVJ//3u/x5KXlY/lTpPFzEQkLtuayhXSUvGHrfGRu/wYslg6BDVGJdcEkMGKOWyNWYJhYMhi6RDUGJXhWk3FHrbGLMEwMGSxdAhqjEq+VlNtbfHHmvOROwzMMygdghqjkq819cADxf+PykfucDBksTQIaoxKOVtTfORGtWEcNUatXLM2mSWIakNQI5WY2o9qQtcHAASOoAaAwBHUqFjMXkSloI8aFYkFg1BJaFGjIjF7EZWEoEZFYvYiKglBjYo03OxF+q6RNgQ1KlK+2YsXXMDKe0gfghoVKd8U98cfp+8a6RPrCi9m9n5J90qaLsklfc7dN+Tbnyu8IFQ1NVFLeiizaGEhoFySuMLLHZK+5+4fljRL0qtJFQeUEivvIY0KBrWZHSvpHElfkyR3P+juvypyXUBRsPIe0ihOi/oUSd2S/sPMXjKze83s6KE7mdlyM2s3s/bu7u7ECwWSwGL3SKM4QT1O0hxJd7n7GZL2SloxdCd3b3X3ZndvbmhoSLhMlEo1DF1jsXukTZyg7pLU5e4/yTxeqyi4UWG4aCwQpoJB7e7/K+lNMzsts+k8SZuLWhXKgmnXQJjiLsp0vaQ2MxsvaaukzxavJJQL066BMMUKanfvkJRzfB8qx5QpUXdHru0AyoeZiTiEoWtAmIIJ6moYbRA6hq4BYQriwgEs8h4OLhoLhCeIFjWjDQAgvyCCmtEGAJBfEEHNQjnJo88fqBxBBDWjDZLFDEOgsgQR1Iw2SBZ9/kBliXXhgJHiwgHlxeL4QPokceEApAh9/kBlIagrEH3+QGUhqCsQff5AZQliZiKSxwxDoHLQogaAwBHUkMQEGSBkdH2ARbGAwNGiBhNkgMClNqj5qJ4cFsUCwpbKoGYti2QxQQYIWyqDmo/qyWKCDBC2VAY1H9WTxQQZIGypHPXB1bKTxwQZIFypbFHzUR1ANUllUPNRHUA1SWXXh8RHdQDVI5UtagCoJgQ1AASOoAaAwBHUABA4ghoAAkdQA0DgCGoACBxBDQCBI6gBIHAENQAEjqAGgMDFDmozqzWzl8zsO8UsCABwpJG0qG+Q9GqxCgEA5BYrqM1ssqTFku4tbjkAgKHitqj/VdJfSxooXikAgFwKBrWZXShpl7tvLLDfcjNrN7P27u7uxAoEgGoXp0X9EUmfMLNOSd+QdK6ZrRm6k7u3unuzuzc3NDQkXCYAVK+CQe3uN7n7ZHdvknSppKfd/fKiVwYAkMQ4agAI3oiumejuz0h6piiVAAByokUNAIEjqAEgcAQ1AASOoAaAwBHUABA4ghoAAkdQA0DgCGoACBxBDQCBI6gBIHAENQAEjqAGgMAR1AAQOIIaAAJHUANA4AhqAAgcQQ0AgSOoASBwBDUABI6gBoDAEdQAEDiCGgACR1ADQOAIagAIHEENAIEjqAEgcAQ1AASOoAaAwBHUABA4ghoAAkdQA0DgCGoACBxBDQCBI6gBIHAENQAEjqAGgMAR1AAQuIJBbWYnm9l6M9tsZq+Y2Q2lKAwAEBkXY58+SV909xfNbKKkjWb2fXffXOTaAACK0aJ297fd/cXM/XclvSrppGIXBgCIjKiP2syaJJ0h6Sc5vrfczNrNrL27uzuh8gAAsYPazI6R9Kikv3D3Xw/9vru3unuzuzc3NDQkWSMAhK2tTWpqkmpqotu2tkSfPk4ftcysTlFIt7n7txKtAADSrK1NWr5c2rcverx9e/RYklpaEnmJOKM+TNLXJL3q7rcn8qoAUClWrjwc0ln79kXbExKn6+Mjkj4t6Vwz68h8XZBYBQCQZjt2jGz7KBTs+nD3H0myxF4RACrJlClRd0eu7QlhZiIAjMWqVVJ9/ZHb6uuj7QkhqAFgLFpapNZWqbFRMotuW1sTO5EoxRz1AQAYRktLosE8FC1qACOXHTdsJo0bF90WYfwwIrSoAYzM0HHD/f3RbRHGDyNCixqoVqOdTZdr3HBWwuOHEaFFDVSjscymKzQ+OMHxw4jQogaq0Vhm0xUaH5zg+GFECGqgGo1lNl2uccNZCY8fRoSgBqpRvlZvnNbw4HHDklRbG90WYfwwIgQ1UI3GOpuupUXq7JTcpb6+6Lazk5AuEoIaqEYlmE2H5BDUQFxFXhy+5LKt4oEBWsOBI6hRfa699vBsunHjoseFZIezbd8efczPDmdLe1gjFQhqVK5cLeBrr5XuuuvwbLr+/uhxobAuweLwQD4ENdKnrU06/vioRWwW3c+2bAevQfHpT7+3BXz33bmfs7V1+NcsweLwQD7MTES6tLVJn/ucdPDg4W09PdJnPys995z0wAOHW77uR/7bfNOepcMt7HxKsDg8kA8taqTLypVHhnRWb2/UKh4ujIeTHQucTwkWhwfyIaiRLsN1NRRqFUvSMcfk3p5d5yIfhrOhjAhqjF451iQerquhUKu4vj7qo77mmsP71tZGj++8s/BrM5wNZUJQY3j5xg4PHq4mvXdN4mKF9apV0vjx791eVxe97tDuCctcl3lwC/jOOw/PpuvrixfSQDm5e+Jfc+fOdaTMmjXujY3uknttbXQ7aZJ7XV10P/tVX3/kvvm+GhuLW+ukSYdfa9KkaNvgn8Msus1uBwInqd3zZKr50DPjCWhubvb29vbEnxcj0NYWnXjbsSPqLli1Kv9H9aFrExfS2Bg973C/O2ZRFwGAWMxso7s35/oeXR+VaKSz6Ia7Ykcu2fAfDsPWgMQQ1JVopLPoRjppI9tCZ01ioCQI6ko00ll0I2n9ZkOYNYmBkiGoK9FIF4UfrnU8frw0aVLuscOsSQyUBEFdiUY6i2641vF990m7dzN2GCgjgrqQNK5BPJpZdLSOgWCxKNNwhg5by46ekMIPsJaW8GsEEAst6uGwBjGAAKQ3qEvRJcEaxAACkM6gLtVlkUY6egIAiiCcoB5JC7lUXRKsQQwgAGEE9UhbyKXqkmANYgABCGNRpqam3Jc5amyMhoiNdX8ACFz4izKNtIVMlwSAKhIrqM1skZm9bmY/N7MViVcx0pN2dEkAqCIFg9rMaiV9VdIfS5oq6TIzm5poFaNpIXNZJABVIk6L+ixJP3f3re5+UNI3JH0y0SpoIQNAXnGmkJ8k6c1Bj7sk/cHQncxsuaTlkjRlNOOMmfIMADkldjLR3VvdvdndmxsaGpJ6WgCoenGCeqekkwc9npzZBgAogThB/YKkD5rZKWY2XtKlkh4rblkAgKyCfdTu3mdm10l6QlKtpPvc/ZWiVwYAkBRzPWp3f1zS40WuBQCQQ1GmkJtZt6Qcc7wTc7yk3UV8/qSkoc401Cilo8401Cilo8401CglW2eju+cciVGUoC42M2vPNyc+JGmoMw01SumoMw01SumoMw01SqWrM4y1PgAAeRHUABC4tAZ1a7kLiCkNdaahRikddaahRikddaahRqlEdaayjxoAqklaW9QAUDUIagAIXNBBXeiCBWZ2jpm9aGZ9ZnZJoDX+lZltNrOXzewpM2sMtM6rzexnZtZhZj9KfM3xBGoctN8SM3MzK8vwrRjHcqmZdWeOZYeZLQuxzsw+f5r5/XzFzB4OrUYzWz3oOG4xs1+VusZMHYXqnGJm683spcz/9QsSLcDdg/xSNF39F5JOlTRe0iZJU4fs0yRppqQHJV0SaI1/JKk+c/8aSY8EWufvDLr/CUnfC63GzH4TJT0r6XlJzYEey6WS/q3UtY2izg9KeknScZnHvxdajUP2v17REhYhHstWSddk7k+V1JlkDSG3qAtesMDdO939ZUkD5ShQ8Wpc7+77Mg+fV7T6YKnFqfPXgx4eLanUZ5njXqDiVkn/KOlAKYsbpPgX0khGnDqvlPRVd39Hktx9V4A1DnaZpK+XpLIjxanTJf1O5v6xkt5KsoCQgzrXBQtOKlMt+Yy0xs9L+m5RK8otVp1m9udm9gtJ/yTpCyWqLatgjWY2R9LJ7v7fpSxsiLjv+ZLMR+C1ZnZyju8XW5w6PyTpQ2b2nJk9b2aLSlZdJPb/n0yX4SmSni5BXUPFqfMWSZebWZeidZGuT7KAkIO6opjZ5ZKaJf1zuWvJx92/6u6/L+lvJP1tuesZzMxqJN0u6YvlriWG/5LU5O4zJX1f0gNlriefcYq6P+Yraq3+u5m9v5wFDeNSSWvdvb/cheRxmaT73X2ypAskPZT5nU1EyEGdhgsWxKrRzBZIWinpE+7+2xLVNthIj+U3JF1UzIJyKFTjREnTJT1jZp2S5kl6rAwnFAseS3fvGfQ+3ytpbolqGyzOe94l6TF373X3bZK2KAruUhnJ7+WlKk+3hxSvzs9L+k9JcvcNkiYoWrApGaXumB9BB/44SVsVfdzJduBPy7Pv/SrPycSCNUo6Q9GJiA+GfCwH1yfpTyS1h1bjkP2fUXlOJsY5licMun+xpOcDrXORpAcy949X9PF+Ukg1Zvb7sKROZSboBXosvytpaeb+6Yr6qBOrt+Q/9AgP0AWK/sr/QtLKzLa/V9QylaQzFbUK9krqkfRKgDU+Ken/JHVkvh4L9FjeIemVTI3rhwvJctU4ZN+yBHXMY/mlzLHclDmWHw60TlPUnbRZ0s8kXRpajZnHt0j6h3IcwxEcy6mSnsu85x2SFib5+kwhB4DAhdxHDQAQQQ0AwSOoASBwBDUABI6gBoDAEdQAEDiCGgAC9//LndHc+WrBWAAAAABJRU5ErkJggg==\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": [
    "这个时候需要计算我们的误差函数，也就是\n",
    "\n",
    "$$\n",
    "E = \\sum_{i=1}^n(\\hat{y}_i - y_i)^2\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(707.7994, dtype=torch.float64, grad_fn=<SumBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# 计算误差\n",
    "def get_loss(y_, y):\n",
    "    return torch.sum((y_ - y) ** 2)\n",
    "\n",
    "loss = get_loss(y_, y_train)\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([-97.4823])\n",
      "tensor([-235.5424])\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 0x7f60e9691f50>"
      ]
     },
     "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: 11.90346992832533\n",
      "epoch: 39, loss: 11.900438531066033\n",
      "epoch: 59, loss: 11.898479754350051\n",
      "epoch: 79, loss: 11.897213885058171\n",
      "epoch: 99, loss: 11.896395921460359\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 0x7f60e9623fd0>"
      ]
     },
     "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 次更新，可以发现红色的预测结果已经比较好的拟合了蓝色的真实值。"
   ]
  },
  {
   "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": [
    "首先定义一个需要拟合的目标函数，这个函数是个三次的多项式"
   ]
  },
  {
   "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": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f60e9465b90>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 画出这个函数的曲线\n",
    "x_sample = np.arange(-3, 3.1, 0.1)\n",
    "y_sample = b_target[0] + w_target[0] * x_sample + w_target[1] * x_sample ** 2 + w_target[2] * x_sample ** 3\n",
    "\n",
    "plt.plot(x_sample, y_sample, label='real curve')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接着构建数据集，需要 x 和 y，同时是一个三次多项式，所以取 $x,\\ x^2, x^3$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 37,
   "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)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以画出没有更新之前的模型和真实的模型之间的对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f60e9272c10>"
      ]
     },
     "execution_count": 38,
     "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": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1142.4613, grad_fn=<MeanBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# 计算误差，这里的误差和一元的线性模型的误差是相同的，前面已经定义过了 get_loss\n",
    "loss = get_loss(y_pred, y_train)\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自动求导\n",
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ -87.0812],\n",
      "        [-175.5444],\n",
      "        [-564.6998]])\n",
      "tensor([-32.2705])\n"
     ]
    }
   ],
   "source": [
    "# 查看一下 w 和 b 的梯度\n",
    "print(w.grad)\n",
    "print(b.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "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": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f60e9193bd0>"
      ]
     },
     "execution_count": 44,
     "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": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 20, Loss: 105.40151\n",
      "epoch 40, Loss: 25.56023\n",
      "epoch 60, Loss: 6.89382\n",
      "epoch 80, Loss: 2.50217\n",
      "epoch 100, Loss: 1.44329\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": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f60e9135810>"
      ]
     },
     "execution_count": 46,
     "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",
    "* 上面的例子是一个三次的多项式，尝试使用二次的多项式去拟合它，看看最后能做到多好\n"
   ]
  }
 ],
 "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
}