machinelearning_notebook/6_pytorch/1_NN/linear-regression-gradient-descend.ipynb

{
 "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 0x7fe7240c4cd0>"
      ]
     },
     "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": 8,
   "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": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fe6d149d0f0>]"
      ]
     },
     "execution_count": 9,
     "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": 10,
   "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": 11,
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_ = linear_model(x_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "经过上面的步骤我们就定义好了模型，在进行参数更新之前，我们可以先看看模型的输出结果长什么样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fe6d1458128>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "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": 14,
   "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": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(94.9309, grad_fn=<MeanBackward1>)\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": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自动求导\n",
    "loss.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "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": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fe6d14283c8>"
      ]
     },
     "execution_count": 19,
     "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": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0, loss: 1.9595526456832886\n",
      "epoch: 1, loss: 0.23876741528511047\n",
      "epoch: 2, loss: 0.20673297345638275\n",
      "epoch: 3, loss: 0.2059527039527893\n",
      "epoch: 4, loss: 0.20575186610221863\n",
      "epoch: 5, loss: 0.2055628001689911\n",
      "epoch: 6, loss: 0.20537473261356354\n",
      "epoch: 7, loss: 0.20518775284290314\n",
      "epoch: 8, loss: 0.20500165224075317\n",
      "epoch: 9, loss: 0.2048165202140808\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:11: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n",
      "  # This is added back by InteractiveShellApp.init_path()\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",
    "    \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.data[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fe6d163f6d8>"
      ]
     },
     "execution_count": 21,
     "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": 20,
   "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": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7ff9c871af28>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJzt3Xl8VPW9//HXJxthCVsIiwQIuwqoQESo1muLVqvWtYLWXSt63Vtvq9Vbbau9V2tra9trLVWLWxFFq9atVupuWQKyCQTCmkSWsCQkhGwzn98fGfihZc1McmYy7+fjkcecOXNmvp8TwnvOfOd7vsfcHRERaf1Sgi5ARERahgJfRCRJKPBFRJKEAl9EJEko8EVEkoQCX0QkSSjwRUSSxEEHvpk9YWabzGzxHuu6mtk/zGxF5LZLZL2Z2W/NrMjMFprZqOYoXkREDt6hHOFPAU770ro7gBnuPhiYEbkP8E1gcORnEvCH6MoUEZFo2aGcaWtmecBr7j48cr8QOMnd15tZL+A9dx9qZn+MLE/98nb7e/1u3bp5Xl5ek3ZERCRZzZ07d7O75xxou7Qo2+mxR4hvAHpElnsDxXtsVxJZt9/Az8vLo6CgIMqSRESSi5mtPZjtYvalrTd+VDjkiXnMbJKZFZhZQVlZWazKERGRL4k28DdGunKI3G6KrC8F+uyxXW5k3b9x98nunu/u+Tk5B/xEIiIiTRRt4L8KXB5Zvhx4ZY/1l0VG64wFKg7Ufy8iIs3roPvwzWwqcBLQzcxKgHuA+4HnzexqYC0wIbL5G8DpQBFQDVzZ1ALr6+spKSmhpqamqS8he5GZmUlubi7p6elBlyIiLeSgA9/dL9rHQ+P3sq0DNzS1qD2VlJSQlZVFXl4eZhaLl0x67s6WLVsoKSmhf//+QZcjIi0k7s+0rampITs7W2EfQ2ZGdna2PjWJJJm4D3xAYd8M9DsVST4JEfgiIq3Zw++sYNaqLc3ejgK/BVxxxRVMnz496DJEJA6tKqvi1+8sZ9bqrc3elgL/ELg74XA46DIACIVCQZcgIjHw9My1pKcaF47pc+CNo6TAP4A1a9YwdOhQLrvsMoYPH05xcTFvv/0248aNY9SoUVxwwQVUVVUB8LOf/Yxjjz2W4cOHM2nSJA40T1FRUREnn3wyRx99NKNGjWLlypW89957nHnmmbu3ufHGG5kyZQrQOPXE7bffzqhRo3jwwQcZM2bMF+ocMWIEAHPnzuU//uM/GD16NKeeeirr1+sUCJF4tKO2gekFJZw+ohfdszKbvb1o59JpUT/922cs+Xx7TF/zyMM6cs+3hu13mxUrVvDkk08yduxYNm/ezH333cc777xD+/bteeCBB3jooYe4++67ufHGG7n77rsBuPTSS3nttdf41re+tc/Xvfjii7njjjs499xzqampIRwOU1xcvM/tAbKzs5k3bx4Azz33HKtXr6Z///5MmzaNiRMnUl9fz0033cQrr7xCTk4O06ZN46677uKJJ544xN+MiDS3l+eXUlnbwGXj+rVIewkV+EHp168fY8eOBWDmzJksWbKE448/HoC6ujrGjRsHwLvvvssvfvELqqur2bp1K8OGDdtn4FdWVlJaWsq5554LNJ4IdTAmTpy4e3nChAlMmzaNO+64g2nTpjFt2jQKCwtZvHgxp5xyCtDY9dOrV6+m7biINBt356lP1jLssI6M6tulRdpMqMA/0JF4c2nfvv3uZXfnlFNOYerUqV/Ypqamhuuvv56CggL69OnDT37ykyaNc09LS/vC9wRffo09a5k4cSIXXHAB5513HmbG4MGDWbRoEcOGDeNf//rXIbctIi1n1uqtFG6s5BfnH9Viw6TVh3+Ixo4dy8cff0xRUREAO3bsYPny5buDuVu3blRVVR1wVE5WVha5ubm8/PLLANTW1lJdXU2/fv1YsmQJtbW1lJeXM2PGjH2+xsCBA0lNTeXee+/dfeQ/dOhQysrKdgd+fX09n332WdT7LSKx9dS/1tCpbTrfOvqwFmszoY7w40FOTg5Tpkzhoosuora2FoD77ruPIUOGcM011zB8+HB69uzJsccee8DXevrpp7n22mu5++67SU9P54UXXmDAgAFMmDCB4cOH079/f0aOHLnf15g4cSI/+MEPWL16NQAZGRlMnz6dm2++mYqKChoaGrj11lsZNiyYT0ci8u/WV+zk759t5OoT+tM2I7XF2j2kK141t/z8fP/yBVCWLl3KEUccEVBFrZt+tyLBeOjtQn73bhHv/9fX6JvdLurXM7O57p5/oO3UpSMi0oJqG0L8ZfY6vj60e0zC/lAo8EVEWtBbizewuaqOS1toKOaeEiLw46nbqbXQ71QkGE9+soa87HacOLjlr/AX94GfmZnJli1bFFAxtGs+/IMd+y8isbGguJx568q5dFweKSktP2Nt3I/Syc3NpaSkBF3gPLZ2XfFKRFrOYx+tJqtNGhPyg/m/F/eBn56erqsyiUjCKy3fyRuL1nPV8XlkZQZzadG479IREWkNpnzceK7MFccHdwCrwBcRaWaVNfU8N7uY00f0onfntoHVocAXEWlm0+YUU1nbwDVfDbZ7OiaBb2bfM7PPzGyxmU01s0wz629ms8ysyMymmVlGLNoSEUkkDaEwf/54DWPyunJUbudAa4k68M2sN3AzkO/uw4FU4ELgAeDX7j4I2AZcHW1bIiKJ5q3PNlBavpPvBnx0D7Hr0kkD2ppZGtAOWA98Hdg1ZeSTwDkxaktEJCG4O3/6cDV52e0Yf0SPoMuJPvDdvRT4JbCOxqCvAOYC5e7eENmsBOi9t+eb2SQzKzCzAo21F5HWZO7abSwoLufqE/qTGsCJVl8Wiy6dLsDZQH/gMKA9cNrBPt/dJ7t7vrvn5+S0/KnGIiLN5bEPV9OpbTrnj46Pkxxj0aVzMrDa3cvcvR54CTge6Bzp4gHIBUpj0JaISEJYs3kHf1+ygYuP60u7jPg4xzUWgb8OGGtm7azxOl3jgSXAu8C3I9tcDrwSg7ZERBLCHz9YSUZqClcGeKLVl8WiD38WjV/OzgMWRV5zMnA78H0zKwKygcejbUtEJBFsqKhh+twSJuT3ISerTdDl7BaTzxnufg9wz5dWrwLGxOL1RUQSyZ8+XEXYYdKJA4Iu5Qt0pq2ISAxt3VHHX2at4+xjDqNP15a9otWBKPBFRGJoyserqWkIcf1JA4Mu5d8o8EVEYqSypp4pn6zh1CN7Mqh7VtDl/BsFvohIjDw7ax3baxq4/mvxd3QPCnwRkZioqQ/x2Ier+ergboFPkrYvCnwRkRh4oaCYzVW1XH/SoKBL2ScFvohIlOpDYR59fxWj+nZm7ICuQZezTwp8EZEovTSvhNLyndzwtUE0TjgQnxT4IiJRqGsI89sZRRyV24mvH9496HL2S4EvIhKFF+YWU1q+k++dMiSuj+5BgS8i0mS1DSF+/88iRvbtzElD4n96dwW+iEgTTZtTzPqKGm47ZWjcH92DAl9EpElq6kP837tFjMnryvGDsoMu56Ao8EVEmuAvs9axcXttQvTd76LAFxE5RDvrQjzy3krGDchm3MDEOLoHBb6IyCF7ZuZaNlc1Ht0nEgW+iMgh2FHbwKPvr+Srg7sxpn/8nlW7Nwp8EZFD8PhHq9myoy7hju5BgS8ictA2V9Xyx/dXcuqwHozq2yXocg6ZAl9E5CD9bsYKahrC/PC0w4MupUkU+CIiB2HN5h08O2sdE4/tw8CcDkGX0yQxCXwz62xm081smZktNbNxZtbVzP5hZisit4n3+UdEJOLBtwtJT03h1vGDgy6lyWJ1hP8w8Ja7Hw4cDSwF7gBmuPtgYEbkvohIwllQXM7rC9dzzYkD6N4xM+hymizqwDezTsCJwOMA7l7n7uXA2cCTkc2eBM6Jti0RkZbm7vzvm0vp1iGDSScOCLqcqMTiCL8/UAb82cw+NbPHzKw90MPd10e22QD02NuTzWySmRWYWUFZWVkMyhERiZ33CsuYuWorN48fTIc2aUGXE5VYBH4aMAr4g7uPBHbwpe4bd3fA9/Zkd5/s7vnunp+TE//Ti4pI8giFnfvfXEZedjsuGtM36HKiFovALwFK3H1W5P50Gt8ANppZL4DI7aYYtCUi0mKmzy2mcGMlPzj1cNJTE39QY9R74O4bgGIzGxpZNR5YArwKXB5ZdznwSrRtiYi0lO019Tz490Ly+3Xh9BE9gy4nJmLVIXUT8KyZZQCrgCtpfDN53syuBtYCE2LUlohIs/vtOyvYsqOOKVeOSZjpjw8kJoHv7vOB/L08ND4Wry8i0pKKNlUx5ZM1TMzvw/DenYIuJ2YSv1NKRCSG3J2fvbaEthmp/NepQw/8hASiwBcR2cOMpZv4YHkZt548hG4d2gRdTkwp8EVEImobQtz7+hIGde/AZeP6BV1OzCnwRUQinvhoDWu3VHP3mUe2imGYX9b69khEpAk2ba/h9/9cwclH9ODEIa3zJFAFvogIcO/rS6kPOf99xhFBl9JsFPgikvTeK9zE3xZ8zg1fG0Ret/ZBl9NsFPgiktR21oX48SuLGZDTnutOSuzZMA8ksad+ExGJ0sMzVlC8dSfPTRpLm7TUoMtpVjrCF5GktWzDdh77cBUT8nMZOyA76HKanQJfRJJSOOz86KVFdGybzo++2Xq/qN2TAl9EktJfZq/j03Xl/PcZR9ClfUbQ5bQIBb6IJJ1N22t44K1lHD8om3NH9g66nBajwBeRpOLu/PfLi6ltCHPfOSNazdTHB0OBLyJJ5ZX5n/P2ko381zeG0L8Vj7nfGwW+iCSNjdtruPuVxYzu14WrT2jdY+73RoEvIknB3bnjxYXUhcL88oKjSU1Jnq6cXRT4IpIUXphbwruFZdx+2uFJ15WziwJfRFq9z8t3cu/fljB2QFcuH5cXdDmBUeCLSKvm7tz+4kJC7jz47aNJScKunF1iFvhmlmpmn5rZa5H7/c1slpkVmdk0M0uOMxtEJK48M2sdH67YzJ2nH0Gfru2CLidQsTzCvwVYusf9B4Bfu/sgYBtwdQzbEhE5oMINldz32hJOHJLDxcf1DbqcwMUk8M0sFzgDeCxy34CvA9MjmzwJnBOLtkREDkZNfYibps4jKzOdX11wdFKdYLUvsTrC/w3wQyAcuZ8NlLt7Q+R+CZA85y+LSODufW0JyzdW8dCEo8nJahN0OXEh6sA3szOBTe4+t4nPn2RmBWZWUFZWFm05IiK8uWg9z85ax7UnDmi116dtilgc4R8PnGVma4DnaOzKeRjobGa7LrCSC5Tu7cnuPtnd8909PydH/zAiEp3S8p3c/uJCjs7txG3fGBp0OXEl6sB39x+5e6675wEXAv9094uBd4FvRza7HHgl2rZERPanIRTmlqmfEnb47UUjyUjTyPM9Nedv43bg+2ZWRGOf/uPN2JaICL95ZwUFa7dx3znD6ZednGfT7k9Mr2nr7u8B70WWVwFjYvn6IiL78o8lG/n9u0VcMDqXc5JojvtDoc87IpLwVpZV8f1p8xnRuxP3njM86HLilgJfRBJaVW0D1z09l/S0FB69dDSZ6alBlxS3FPgikrDcnR9OX8DKsip+f9FIenduG3RJcU2BLyIJa/IHq3hj0Qbu+ObhfGVQt6DLiXsKfBFJSB8XbeaBt5ZxxlG9uOaryXf1qqZQ4ItIwinaVMV/PjOXQd078Ivzj9I8OQdJgS8iCWVLVS1XTZlDRloKj19+LO3bxHR0eaum35SIJIya+hDXPFXAxu01TLt2XNLPb3+oFPgikhDCYee2FxbwaXE5j3xnFMf06Rx0SQlHXToikhB++XYhry9cz4++eTjfHNEr6HISkgJfROLec7PX8ch7K/nOcX01IicKCnwRiWtvLV7PnX9dxIlDcvjpWcM0IicKCnwRiVsfLC/jpqmfckyfzjx6ySjSUxVZ0dBvT0TiUsGarUx6uoBB3bP48xVjaJehMSbRUuCLSNz57PMKrpwyh16d2vLUVWPo1C496JJaBQW+iMSVVWVVXPb4bLLapPHMd4/TBchjSIEvInFjVVkV3/nTLACe/u5xmv0yxtQpJiJxYcXGSr7z2CzCYeeZ7x7HwJwOQZfU6ijwRSRwS9dv55LHZpGSYjw3aSyDe2QFXVKrpC4dEQnU4tIKLvrTTNJTU5imsG9WOsIXkcB8um4blz0xm46Z6Uy9Zix9szUZWnOK+gjfzPqY2btmtsTMPjOzWyLru5rZP8xsReS2S/Tlikhr8f7yMi55bBZd22fw/HXjFPYtIBZdOg3Abe5+JDAWuMHMjgTuAGa4+2BgRuS+iAjPzynmqilz6JfdnheuHafROC0k6i4dd18PrI8sV5rZUqA3cDZwUmSzJ4H3gNujbU9EEpe785t3VvDwjBWcOCSHRy4eRQddwKTFxPQ3bWZ5wEhgFtAj8mYAsAHoEcu2RCSx1IfC3PnSIl6YW8IFo3P5n/NGaG6cFhazwDezDsCLwK3uvn3PGe3c3c3M9/G8ScAkgL59+8aqHBGJIxXV9dw4dR4frtjMLeMHc+vJgzXrZQBi8vZqZuk0hv2z7v5SZPVGM+sVebwXsGlvz3X3ye6e7+75OTk5sShHROJI4YZKzvq/j5i5agsPnD+C750yRGEfkFiM0jHgcWCpuz+0x0OvApdHli8HXom2LRFJLK8vXM+5j3xMdV2I5yaNZeKx+hQfpFh06RwPXAosMrP5kXV3AvcDz5vZ1cBaYEIM2hKRBBAKOw/+vZBH31/JqL6d+cMlo+nRMTPospJeLEbpfATs6/PZ+GhfX0QSS1llLd9/fj4frtjMxcf15Z5vDSMjTV/OxgONhxKRmHl32SZ+MH0BlTUNPHD+CHXhxBkFvohEraY+xP1vLmPKJ2s4vGcWf7lmLEM0J07cUeCLSFQKN1Ryy3OfsmxDJVcen8ftpx1OZnpq0GXJXijwRaRJ6kNhJn+wiodnrKBjZhpTrjyWk4Z2D7os2Q8FvogcsvnF5dzx4kKWbajk9BE9+elZw3UpwgSgwBeRg7ajtoFfvb2cKZ+spntWJpMvHc03hvUMuiw5SAp8ETkgd+fNxRv4+etLKS3fyaVj+/HD04aSlZkedGlyCBT4IrJfC0vKufe1JcxZs43De2Yx/bpx5Od1DbosaQIFvojs1fqKnTz4ViEvfVpKtw4Z/O95I5iQ34fUFM2Dk6gU+CLyBZurapn8wSqe+tcawg7/edJArj9poLpvWgEFvogAsKmyhsnvr+KZWWupawhz9jG9+f4pQ+jTVZcebC0U+CJJ7vPynTz+0WqejQT9OSN7c+PXBjEgp0PQpUmMKfBFkpC7M3ftNv78yRreWrwBgHOO6c2NXx9E/27tA65OmosCXySJ1NSHeHPxev788RoWllTQMTONq0/oz6Vj+6nrJgko8EVaOXdnfnE5L84r4dX5n7O9poGBOe2595zhnD+qN+0yFAPJQv/SIq1U8dZq/rbwc16cW8LKsh1kpqdw6rCefHt0LscP7EaKhlcmHQW+SCvh7qzYVMVbizfw98828Nnn2wE4Nq8Lk04cwOkjemloZZJT4IsksB21DcxevZWPijbzz2WbWL15BwCj+nbmztMP57Rhveibrb55aaTAF0kg1XUNLCypYNaqrXxctJl567bREHYy0lI4rn9Xrj6hP984sgfddf1Y2QsFvkicqg+FWb15BwtLKvh03TY+XVdO4cZKQmHHDEb07sQ1Jw7ghEHdGN2viy46IgekwBcJWE19iHVbq1m7pZqiTVUUbtjOsg2VrCyroj7kAGRlpnFMn87ccOQgRvbtzMg+nencLiPgyiXRNHvgm9lpwMNAKvCYu9/f3G2KxAN3Z0ddiG076iirqmXT9ho2bq9lw/YaNm6voWTbTtZu2cHG7bVfeN5hnTIZ2jOLk4Z25/CeWQw7rCMDczpoVI1ErVkD38xSgf8DTgFKgDlm9qq7L2nOdqXlVNc1UFZZy+aqWsqr69leU8/2nQ1s39m4vKMuRE1diJ31jT819SFqG8KEwk59yGkINS6HvPFINnKzW2qKkWK7bo3UFCMtxUhLTSE1xUhPNdJSUkhPNdJTU0hLjSynpJAWWZeeapH1KaSl/P/X2HWbkmKYNbaTYoYBDoTdcW8M7rA3drHUhcLUN/ju5eq6BqrrQlTXhtgRWa7YWU95dT0VO+t2H6HvKS3F6J7Vht5d2nLCoBzystvRN7sd/bLb079bezq11UgaaR7NfYQ/Bihy91UAZvYccDagwE8AobBTum0nxduqKdlWTcm2nZGfajZV1rK5spYddaF9Pr9teirt26TRNiOFzLRU2makkpmWSoc2aZGw/f9hnGKw6/jVrHHJ3Qk5hMNO2L3xjSHsNERu60NhauvDVIUaGt88wmHqQ43r60NhGkJOXeR212OxsuvNpl1GGu0yUiM/jcuDu3egc7sMOrdLp0u7dDq3zSAnqw3dO7ahR8dMurbL0NG6BKK5A783ULzH/RLguGZuUw6Ru1NavpPFpRUs31hF0aYqVmyqYlVZFbUN4d3bpaYYvTpl0rtzW47O7UxOVhu6dWhDtw4ZdMtqQ9d2GXRsm07HzDSyMtPJSEsJcK/+3a4j9YbwrjeBxjeOXet33YbdSYkc8ZsZFjnyT9/9iSFFc8JLQgr8S1szmwRMAujbt2/A1SSH8uo6CtZsY2FJOQtKKlhUWsHWHXW7H8/t0pZB3TtwwqBsBnXvQN+u7cnt0pZenTJJS42vED8UZkaqQWpKKm0C/8sXaXnN/WdfCvTZ435uZN1u7j4ZmAyQn58fu8/cslt5dR2zVm9l5qotzFy1lWUbtuPeeMQ+uHsHTj6iOyNyOzOidyeG9OiguVVEWqnm/p89BxhsZv1pDPoLge80c5tJz91ZtqGSGUs3MmPZJuYXl+MObdJSyM/rwvdPHsJxA7IZ0bsTbTM0dlskWTRr4Lt7g5ndCPydxmGZT7j7Z83ZZrIKh53Za7byxqL1zFi6idLynQAclduJW8YP5vhB3TgqtxNt0hTwIsmq2T+7u/sbwBvN3U6yWrp+Oy/PL+Vv8z/n84oaMtNTOGFQN278+iC+fnh3eugUexGJUGdtAqqormf6vBKen1NM4cZK0lKME4fkcPs3D+eUI3uoD15E9krJkEAWlVTw9Mw1vLrgc2rqw4zs25l7zx7G6SN6kd2hTdDliUicU+DHuYZQmNcXreeJj1azoKSCdhmpnDcql0uO68eRh3UMujwRSSAK/DhV2xDixbmlPPr+StZtrWZgTnt+etYwzh3Vm466iIWINIECP87sqG1g6ux1/OnDVWzcXsvRuZ2464zRnHJED52OLyJRUeDHifpQmOfmFPPwOyvYXFXLVwZm89CEY/jKwOzdc8uIiERDgR8wd+etxRt48O+FrNq8gzF5XfnjpaMY3a9r0KWJSCujwA/Q3LVbue/1pXy6rpzB3Tvw2GX5jD+iu47oRaRZKPADsHVHHfe/uZTnC0ro0bEND5w/gvNH5Sb0xGQiEv8U+C0oHHZemFvM/W8uo7KmgWtPHMDN4wfTXlM3ikgLUNK0kMINldz110UUrN3GsXlduO+cEQztmRV0WSKSRBT4zSwUdv704Soeens57duk8ovzj+Lbo3M1xFJEWpwCvxmt21LNbS/MZ86abZw6rAf/c+4ITYEgIoFR4DcDd2fanGLufW0JKWY8NOFozh3ZW6NvRCRQCvwYq6iu57YXFvDO0o18ZWA2D15wNL07tw26LBERBX4sLS6t4D+fncuGihp+fOaRXPmVPPXVi0jcUODHgLszdXYxP/nbZ3Rrn8Hz145jZN8uQZclIvIFCvwo7awLcdfLi3hpXilfHdyNhy8cSdf2GUGXJSLybxT4USgt38nVU+ZQuLGSW8YP5ubxg0lVF46IxCkFfhMtLCnn6icLqKkL8cQVx/K1od2DLklEZL8U+E3w1uL13DptPtnt2/Ds9ccxpIfOmBWR+BfVbF1m9qCZLTOzhWb2VzPrvMdjPzKzIjMrNLNToy81eO7Oo++v5Lpn5nFEr468fMPxCnsRSRjRTs/4D2C4ux8FLAd+BGBmRwIXAsOA04BHzCw1yrYC1RAKc+dfF3H/m8s446heTL1mLDlZOmtWRBJHVIHv7m+7e0Pk7kwgN7J8NvCcu9e6+2qgCBgTTVtBqm0IcdPUT5k6u5gbvjaQ3104ksz0hH7/EpEkFMs+/KuAaZHl3jS+AexSEln3b8xsEjAJoG/fvjEsJzZ21oW49pm5fLC8jB+feSRXn9A/6JJERJrkgIFvZu8APffy0F3u/kpkm7uABuDZQy3A3ScDkwHy8/P9UJ/fnLbX1HP1lDnMXbuNX5x/FBOO7RN0SSIiTXbAwHf3k/f3uJldAZwJjHf3XYFdCuyZjrmRdQljS1Utl/95NoUbKvndRaM446heQZckIhKVaEfpnAb8EDjL3av3eOhV4EIza2Nm/YHBwOxo2mpJZZW1TJw8kxUbq5h8Wb7CXkRahWj78H8PtAH+EZn6d6a7X+fun5nZ88ASGrt6bnD3UJRttYitO+q45LFZlG7byZNXjWHsgOygSxIRiYmoAt/dB+3nsZ8DP4/m9Vtaxc56Ln18Fmu27ODPVxyrsBeRViXacfitRmVNPZc/MZsVG6v446Wj+cqgbkGXJCISUwp8oLqugaumzGFxaQW//85ITtK8OCLSCiV94NfUh/jukwXMXbuNhy8cyTeG7W0EqohI4kvqydPCYee2FxbwycotPDThaI3GEZFWLamP8P/njaW8vnA9d55+OOeNyj3wE0REEljSBv7jH63msY9Wc8VX8rjmqwOCLkdEpNklZeC/vnA9972+hNOG9eTHZx5J5BwCEZFWLekCf/bqrXzv+fmM7tuF31x4jC5JKCJJI6kCf1VZFd99cg65Xdryp8vyNcWxiCSVpAn87TX1XPNUAWmpKTx55Ri6tM8IuiQRkRaVFIEfCju3PjeftVuqeeTiUfTp2i7okkREWlxSBP6v3i7kn8s2cc9ZwzQ/jogkrVYf+H9b8DmPvLeSi8b05ZLj4u+KWiIiLaVVB/7i0gp+MH0B+f268NOzhmn4pYgktVYb+Fuqarn26bl0aZfBHy4ZTUZaq91VEZGD0irn0gmHne/zE334AAAFOklEQVQ9v4CyqlqmXzeOnKw2QZckIhK4VnnY++gHK/lgeRk/PvNIjsrtHHQ5IiJxodUF/pw1W/nV28s546he+pJWRGQPrSrwt+6o46a/fEpul7bcf94IfUkrIrKHVtOHHw47339+Plt31PHS9V8hKzM96JJEROJKqznC/+MHq3ivsIwfn3kEw3t3CrocEZG4E5PAN7PbzMzNrFvkvpnZb82syMwWmtmoWLSzLwVrtvLLtws5Y0QvLhnbrzmbEhFJWFEHvpn1Ab4BrNtj9TeBwZGfScAfom1nfzLTUzl+UDf+93z124uI7EssjvB/DfwQ8D3WnQ085Y1mAp3NrNkuGDu8dyeeumoMHdVvLyKyT1EFvpmdDZS6+4IvPdQbKN7jfklk3d5eY5KZFZhZQVlZWTTliIjIfhxwlI6ZvQP03MtDdwF30tid02TuPhmYDJCfn+8H2FxERJrogIHv7ifvbb2ZjQD6Awsi/ea5wDwzGwOUAn322Dw3sk5ERALS5C4dd1/k7t3dPc/d82jsthnl7huAV4HLIqN1xgIV7r4+NiWLiEhTNNeJV28ApwNFQDVwZTO1IyIiBylmgR85yt+17MANsXptERGJXqs501ZERPZPgS8ikiSssfclPphZGbC2iU/vBmyOYTlB0r7Ep9ayL61lP0D7sks/d8850EZxFfjRMLMCd88Puo5Y0L7Ep9ayL61lP0D7cqjUpSMikiQU+CIiSaI1Bf7koAuIIe1LfGot+9Ja9gO0L4ek1fThi4jI/rWmI3wREdmPVhX4ZnZv5Apb883sbTM7LOiamsrMHjSzZZH9+auZdQ66pqYyswvM7DMzC5tZwo2oMLPTzKwwcgW3O4Kup6nM7Akz22Rmi4OuJVpm1sfM3jWzJZG/rVuCrqkpzCzTzGab2YLIfvy0WdtrTV06ZtbR3bdHlm8GjnT36wIuq0nM7BvAP929wcweAHD32wMuq0nM7AggDPwR+C93Lwi4pINmZqnAcuAUGicInANc5O5LAi2sCczsRKCKxosTDQ+6nmhELqjUy93nmVkWMBc4J9H+XaxxquH27l5lZunAR8AtkQtHxVyrOsLfFfYR7fniVbgSiru/7e4NkbszaZxiOiG5+1J3Lwy6jiYaAxS5+yp3rwOeo/GKbgnH3T8AtgZdRyy4+3p3nxdZrgSWso+LLMWzyFUBqyJ30yM/zZZbrSrwAczs52ZWDFwM3B10PTFyFfBm0EUkqYO+epsEw8zygJHArGAraRozSzWz+cAm4B/u3mz7kXCBb2bvmNnivfycDeDud7l7H+BZ4MZgq92/A+1LZJu7gAYa9yduHcy+iMSamXUAXgRu/dIn/ITh7iF3P4bGT/FjzKzZutuaaz78ZrOvK3DtxbM0zst/TzOWE5UD7YuZXQGcCYz3OP+y5RD+XRKNrt4WpyJ93i8Cz7r7S0HXEy13Lzezd4HTgGb5Yj3hjvD3x8wG73H3bGBZULVEy8xOA34InOXu1UHXk8TmAIPNrL+ZZQAX0nhFNwlQ5MvOx4Gl7v5Q0PU0lZnl7BqBZ2ZtaRwc0Gy51dpG6bwIDKVxRMha4Dp3T8ijMTMrAtoAWyKrZibwiKNzgd8BOUA5MN/dTw22qoNnZqcDvwFSgSfc/ecBl9QkZjYVOInGWRk3Ave4++OBFtVEZnYC8CGwiMb/7wB3uvsbwVV16MzsKOBJGv+2UoDn3f1nzdZeawp8ERHZt1bVpSMiIvumwBcRSRIKfBGRJKHAFxFJEgp8EZEkocAXEUkSCnwRkSShwBcRSRL/D/uFTGLU33onAAAAAElFTkSuQmCC\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": "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 0x7ff9c867b7b8>"
      ]
     },
     "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=<MeanBackward1>)\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 0x7ff9c8640320>"
      ]
     },
     "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": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 20, Loss: 24.61406\n",
      "epoch 40, Loss: 5.92470\n",
      "epoch 60, Loss: 1.55844\n",
      "epoch 80, Loss: 0.53303\n",
      "epoch 100, Loss: 0.28755\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:14: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n",
      "  \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[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到更新完成之后 loss 已经非常小了，我们画出更新之后的曲线对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7ff9c8603e10>"
      ]
     },
     "execution_count": 33,
     "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}