DL-with-Python-and-PyTorch2/pytorch-02/pytorch-02_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 使用Tensor和Autograd\n",
    "在神经网络中，一个重要内容就是进行参数学习，而参数学习离不开求导，PyTorch是如何进行求导的呢？  \n",
    "\t现在大部分深度学习架构都有自动求导的功能，PyTorch也不列外，torch.autograd包就是用来自动求导的。autograd包为张量上所有的操作提供了自动求导功能，而torch.Tensor和torch.Function为autograd包的两个核心类，它们相互连接并生成一个有向非循环图。接下来我们先简单介绍tensor如何实现自动求导，然后介绍计算图，最后用代码实现这些功能。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.1 自动求导要点\n",
    "\tautograd包为对tensor进行自动求导，为实现对tensor自动求导，需考虑如下事项。  \n",
    "1）创建叶子节点(leaf node)的tensor，使用requires_grad参数指定是否记录对其的操作，以便之后利用backward()方法进行梯度求解。requires_grad参数默认值为False，如果要对其求导需设置为True，与之有依赖关系的节点自动变为True。  \n",
    "2）可利用requires_grad_()方法修改tensor的requires_grad属性。可以调用.detach()或with torch.no_grad():将不再计算张量的梯度，跟踪张量的历史记录。这点在评估模型、测试模型阶段常常使用。  \n",
    "3）通过运算创建的tensor（即非叶子节点），会自动被赋于grad_fn属性。该属性表示梯度函数。叶子节点的grad_fn为None。  \n",
    "4）最后得到的tensor执行backward()函数，此时自动计算各变在量的梯度，并将累加结果保存grad属性中。计算完成后，非叶子节点的梯度自动释放。  \n",
    "5）backward()函数接受参数，该参数应和调用backward()函数的Tensor的维度相同，或者是可broadcast的维度。如果求导的tensor为标量（即一个数字），backward中参数可省略。  \n",
    "6）反向传播的中间缓存会被清空，如果需要进行多次反向传播，需要指定backward中的参数retain_graph=True。多次反向传播时，梯度是累加的。  \n",
    "7）非叶子节点的梯度backward调用后即被清空。  \n",
    "8）可以通过用torch.no_grad()包裹代码块来阻止autograd去跟踪那些标记为.requesgrad=True的张量的历史记录。这步在测试阶段经常使用。  \n",
    "\t在整个过程中，PyTorch采用计算图的形式进行组织，该计算图为动态图，它的计算图在每次正向传播时，将重新构建。其他深度学习架构，如TensorFlow、Keras一般为静态图。接下来我们介绍计算图，用图的形式来描述就更直观了，该计算图为有向无环图（DAG）。\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.2计算图\n",
    "\t计算图是一种有向无环图像，用图形方式表示算子与变量之间的关系，直观高效。如图2-9所示，圆形表示变量，矩形表示算子。如表达式z=wx+b可写成两个表示式：如果y=wx，则z=y+b。其中x、w、b为变量，是用户创建的变量，不依赖于其他变量，故又称为叶子节点。为计算各叶子节点的梯度，需要把对应的张量参数requires_grad属性设置为True，这样就可自动跟踪其历史记录。y、z是计算得到的变量，非叶子节点，z为根节点。mul和add是算子（或操作或函数）。这些变量及算子就构成一个完整的计算过程（或正向传播过程）。\n",
    "![image.png](attachment:image.png)\n",
    "<center>图2-9正向传播计算图</center>\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们的目标是更新各叶子节点的梯度，根据复合函数导数的链式法则，不难算出各叶子节点的梯度。\n",
    "$$\\frac{\\partial z}{\\partial x}=\\frac{\\partial z}{\\partial y}\\frac{\\partial y}{\\partial x}=w\\tag{2,1}$$\n",
    "$$\\frac{\\partial z}{\\partial w}=\\frac{\\partial z}{\\partial y}\\frac{\\partial y}{\\partial w}=x\\tag{2,2}$$\n",
    "$$\\frac{\\partial z}{\\partial b}=1 \\tag{2,3}$$\n",
    "PyTorch调用backward()，将自动计算各节点的梯度，这是一个反向传播过程，这个过程可用图2-9表示。在反向传播过程中，autograd沿着图2-10，从当前根节点z反向溯源，利用导数链式法则，计算所有叶子节点的梯度，并梯度值将累加到grad属性中。对非叶子节点的计算操作（或function）记录在grad_fn属性中，叶子节点的grad_fn值为None。\n",
    "![image.png](attachment:image.png)\n",
    "<center>图2-10 梯度反向传播计算图</center>  \n",
    "\t下面我们用代码实现这个计算图。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 2.5.3 标量反向传播\n",
    "PyTorch使用torch.autograd.backward来实现反向传播，backward函数的具体格式如下：  \n",
    "<font color=blue>\n",
    "torch.autograd.backward(  \n",
    "\t\ttensors,   \n",
    "\t\tgrad_tensors=None,   \n",
    "\t\tretain_graph=None,   \n",
    "\t\tcreate_graph=False,   \n",
    "\t\tgrad_variables=None)\n",
    "</font>  \n",
    "参数说明如下。  \n",
    "- tensor: 用于计算梯度的tensor。\n",
    "- grad_tensors: 在计算非标量的梯度时会用到。其形状一般需要和前面的tensor保持一致。\n",
    "- retain_graph: 通常在调用一次backward后，pytorch会自动把计算图销毁，如果要想对某个变量重复调用backward，则需要将该参数设置为True\n",
    "- create_graph: 当设置为True的时候可以用来计算更高阶的梯度\n",
    "- grad_variables:这个参数后面版本中应该会丢弃，直接使用grad_tensors就好了。  \n",
    "假设x、w、b都是标量，z=wx+b，对标量z调用backward()，我们无须对backward()传入参数。以下是实现自动求导的主要步骤。    \n",
    "1）定义叶子节点及算子节点。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x,w,b的require_grad属性分别为：False,True,True\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "#定义输入张量x\n",
    "x=torch.Tensor([2])\n",
    "#初始化权重参数W,偏移量b、并设置require_grad为True，为自动求导\n",
    "w=torch.randn(1,requires_grad=True)\n",
    "b=torch.randn(1,requires_grad=True)\n",
    "y=torch.mul(w,x)  #等价于w*x\n",
    "z=torch.add(y,b)  #等价于y+b\n",
    "#查看x,w，b页子节点的requite_grad属性\n",
    "print(\"x,w,b的require_grad属性分别为：{},{},{}\".format(x.requires_grad,w.requires_grad,b.requires_grad))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2）查看叶子节点、非叶子节点的其他属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y，z的requires_grad属性分别为：True,True\n",
      "x，w，b，y，z的是否为叶子节点：True,True,True,False,False\n",
      "x，w，b的grad_fn属性：None,None,None\n",
      "y，z的是否为叶子节点：<MulBackward0 object at 0x000001CB4CC20DC8>,<AddBackward0 object at 0x000001CB4CC39108>\n"
     ]
    }
   ],
   "source": [
    "#查看非叶子节点的requres_grad属性,\n",
    "print(\"y，z的requires_grad属性分别为：{},{}\".format(y.requires_grad,z.requires_grad))\n",
    "#因与w，b有依赖关系，故y，z的requires_grad属性也是：True,True\n",
    "#查看各节点是否为叶子节点\n",
    "print(\"x，w，b，y，z的是否为叶子节点：{},{},{},{},{}\".format(x.is_leaf,w.is_leaf,b.is_leaf,y.is_leaf,z.is_leaf))\n",
    "#x，w，b，y，z的是否为叶子节点：True,True,True,False,False\n",
    "#查看叶子节点的grad_fn属性\n",
    "print(\"x，w，b的grad_fn属性：{},{},{}\".format(x.grad_fn,w.grad_fn,b.grad_fn))\n",
    "#因x，w，b为用户创建的，为通过其他张量计算得到，故x，w，b的grad_fn属性：None,None,None\n",
    "#查看非叶子节点的grad_fn属性\n",
    "print(\"y，z的是否为叶子节点：{},{}\".format(y.grad_fn,z.grad_fn))\n",
    "#y，z的是否为叶子节点：<MulBackward0 object at 0x7f923e85dda0>,<AddBackward0 object at 0x7f923e85d9b0>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3）自动求导，实现梯度方向传播，即梯度的反向传播。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "参数w,b的梯度分别为:tensor([2.]),tensor([1.]),None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\wumgapp\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:10: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the gradient for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations.\n",
      "  # Remove the CWD from sys.path while we load stuff.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "非叶子节点y,z的梯度分别为:None,None\n"
     ]
    }
   ],
   "source": [
    "#基于z张量进行梯度反向传播,执行backward之后计算图会自动清空，\n",
    "#如果需要多次使用backward，需要修改参数retain_graph为True，此时梯度是累加的\n",
    "#z.backward(retain_graph=True)\n",
    "z.backward()\n",
    "#查看叶子节点的梯度，x是叶子节点但它无需求导，故其梯度为None\n",
    "print(\"参数w,b的梯度分别为:{},{},{}\".format(w.grad,b.grad,x.grad))\n",
    "#参数w,b的梯度分别为:tensor([2.]),tensor([1.]),None\n",
    "\n",
    "#非叶子节点的梯度，执行backward之后，会自动清空\n",
    "print(\"非叶子节点y,z的梯度分别为:{},{}\".format(y.grad,z.grad))\n",
    "#非叶子节点y,z的梯度分别为:None,None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.4 非标量反向传播\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "backward(gradient=None, retain_graph=None, create_graph=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1、非标量简单示例  \n",
    "\t我们先看目标张量为非标量的简单实例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "grad can be implicitly created only for scalar outputs",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-bcdd95b78431>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mones\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mrequires_grad\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mY\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m**\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mY\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\torch\\tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[0;32m    219\u001b[0m                 \u001b[0mretain_graph\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    220\u001b[0m                 create_graph=create_graph)\n\u001b[1;32m--> 221\u001b[1;33m         \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    222\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    223\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\torch\\autograd\\__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[0;32m    124\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    125\u001b[0m     \u001b[0mgrad_tensors_\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_tensor_or_tensors_to_tuple\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgrad_tensors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtensors\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 126\u001b[1;33m     \u001b[0mgrad_tensors_\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_make_grads\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtensors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    127\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mretain_graph\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    128\u001b[0m         \u001b[0mretain_graph\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\torch\\autograd\\__init__.py\u001b[0m in \u001b[0;36m_make_grads\u001b[1;34m(outputs, grads)\u001b[0m\n\u001b[0;32m     48\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrequires_grad\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     49\u001b[0m                 \u001b[1;32mif\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnumel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 50\u001b[1;33m                     \u001b[1;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"grad can be implicitly created only for scalar outputs\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     51\u001b[0m                 \u001b[0mnew_grads\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mones_like\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmemory_format\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpreserve_format\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     52\u001b[0m             \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mRuntimeError\u001b[0m: grad can be implicitly created only for scalar outputs"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "X= torch.ones(2,requires_grad=True)\n",
    "Y = X**2+3\n",
    "Y.backward()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如何避免类似错误呢？我们手工计算Y的导数。已知：\n",
    "$$X=[x_1,x_2]$$\n",
    "$$Y=[x_1^2+3,x_2^2+3]$$\n",
    "如何求$\\frac{\\partial Y}{\\partial X}$呢？\n",
    "\tY为一个向量，如果我们想办法把这个向量转变成一个标量不就好了？比如我们可以对Y求和，然后用求和得到的标量在对X求导，这样不会对结果有影响，例如：\n",
    "$$Y_{sum}=\\sum y_i =x_1^2+x_2^2+6$$\n",
    "$$\\frac{\\partial Y_{sum}}{\\partial x_1}=2x_1,\\frac{\\partial Y_{sum}}{\\partial x_2}=2x_2$$\n",
    "这个过程可写成如下代码。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([2., 2.])\n"
     ]
    }
   ],
   "source": [
    "x = torch.ones(2,requires_grad=True)\n",
    "y = x**2+3\n",
    "y.sum().backward()\n",
    "print(x.grad)  #tensor([2., 2.])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到对y求和后再计算梯度没有报错，结果也与预期一样。\n",
    "实际上，对Y求和就是等价于Y点积一个的全为1的向量或矩阵。即,而这个向量矩阵V也就是我们需要传入的grad_tensors参数。（点积只是相对于一维向量而言的，对于矩阵或更高为的张量，可以看做是对每一个维度做点积。）   \n",
    "2.非标量复杂实例  \n",
    "（1）定义叶子叶子节点及计算节点"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "#定义叶子节点张量x，形状为1x2\n",
    "x= torch.tensor([[2, 3]], dtype=torch.float, requires_grad=True)\n",
    "#初始化Jacobian矩阵\n",
    "J= torch.zeros(2 ,2)\n",
    "#初始化目标张量，形状为1x2\n",
    "y = torch.zeros(1, 2)\n",
    "#定义y与x之间的映射关系：\n",
    "#y1=x1**2+3*x2，y2=x2**2+2*x1\n",
    "y[0, 0] = x[0, 0] ** 2 + 3 * x[0 ,1]\n",
    "y[0, 1] = x[0, 1] ** 2 + 2 * x[0, 0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（2）手工计算y对x的梯度  \n",
    "(这里省略手工计算过程，详细内容请参考书中对应章节)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（3）调用backward获取y对x的梯度  \n",
    "\t这里我们可以分成两步的计算。首先让v=(1,0)得到y_1对x的梯度，然后使v=(0,1)，得到y_2对x的梯度。这里因需要重复使用backward(),需要使参数retain_graph=True,具体代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[4., 3.],\n",
      "        [2., 6.]])\n"
     ]
    }
   ],
   "source": [
    "#生成y1对x的梯度\n",
    "y.backward(torch.Tensor([[1, 0]]),retain_graph=True)\n",
    "J[0]=x.grad\n",
    "#梯度是累加的，故需要对x的梯度清零\n",
    "x.grad = torch.zeros_like(x.grad)\n",
    "#生成y2对x的梯度\n",
    "y.backward(torch.Tensor([[0, 1]]))\n",
    "J[1]=x.grad\n",
    "#显示jacobian矩阵的值\n",
    "print(J)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个结果与手工运行的式（2.5）结果一致。  \n",
    "（4）如果V值不对，将导致错误结果。  \n",
    "如果取v=[1,1]将导致错误结果，代码示例如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "Trying to backward through the graph a second time, but the saved intermediate results have already been freed. Specify retain_graph=True when calling backward the first time.",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-1087ea950c0d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0my\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgrad\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;31m#结果为tensor([[6., 9.]])\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\torch\\tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[0;32m    219\u001b[0m                 \u001b[0mretain_graph\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    220\u001b[0m                 create_graph=create_graph)\n\u001b[1;32m--> 221\u001b[1;33m         \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    222\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    223\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\torch\\autograd\\__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[0;32m    130\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[0;32m    131\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 132\u001b[1;33m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[0;32m    133\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    134\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mRuntimeError\u001b[0m: Trying to backward through the graph a second time, but the saved intermediate results have already been freed. Specify retain_graph=True when calling backward the first time."
     ]
    }
   ],
   "source": [
    "y.backward(torch.Tensor([[1, 1]]))\n",
    "print(x.grad)\n",
    "#结果为tensor([[6., 9.]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个结果与我们手工运算的不符，显然这个结果是错误的，错在哪里呢？这个结果的计算过程是：\n",
    "$$J^T∙v^T=\\left(\\begin{matrix}{4}&2 \\\\ {3}&6\\end{matrix}\\right)\\left(\\begin{matrix}1 \\\\ 1\\end{matrix}\\right)=\\left(\\begin{matrix}6 \\\\ 9\\end{matrix}\\right)\\tag{2.7}$$\n",
    "\t由此，错在v的取值错误，通过这种方式得的到并不是y对x的梯度。\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.小结  \n",
    "1）PyTorch不允许张量对张量求导，只允许标量对张量求导，求导结果是和自变量同型的张量。  \n",
    "2）为避免直接对张量求导，可以利用torch.autograd.backward()函数中的参数grad_tensors, 把它转换标量来求导。 y.backward(v) 的含义是：先计算 loss = torch.sum(y * v)，然后求 loss 对（能够影响到 y 的）所有变量 x 的导数。这里，y和 v是同型 Tensor。也就是说，可以理解成先按照 v对y的各个分量加权，加权求和之后得到真正的 loss，再计算这个 loss 对于所有相关变量的导数。  \n",
    "3）PyTorch中的计算图是动态计算图，动态计算图有两个特点：正向传播是立即执行的；反向传播后计算图立即销毁。我们把PyTorch使用自动微分的计算图的生命周期用图2-11来表示。\t\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.5切断一些分支的反向传播\n",
    "训练网络时，有时候我们希望保持一部分的网络参数不变，只对其中一部分的参数进行调整；或者只训练部分分支网络，并不让其梯度对主网络的梯度造成影响，这时候可以使用detach()函数来切断一些分支的反向传播。\n",
    "\tdetach_()将张量从创建它的计算图（Graph）中分离，把它作为叶子节点，其grad_fn=None且requires_grad=False。\n",
    "\t假设y是作为x的函数，而z则是y和x的函数。如果我们想计算z关于x的梯度，但由于某种原因，我们希望将y视为一个常数。为此，我们可以分离y来返回一个新变量c，c变量与y具有相同的值， 但丢弃计算图中如何计算y的任何信息。 换句话说，梯度不会向后流经c到x。 因此，下面的反向传播函数计算z=c*x关于x的偏导数，同时将c作为常数处理，即有$\\frac{∂z}{∂x}=c$，而不是把$z=x^3+3$关于x的偏导数，$\\frac{∂z}{∂x}≠3x^2$。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "x = torch.ones(2,requires_grad=True)\n",
    "y = x**2+3\n",
    "##对分离变量y，生成一个新变量c。\n",
    "c = y.detach()\n",
    "z = c*x\n",
    "z.sum().backward()\n",
    "x.grad==c  ## tensor([True, True])\n",
    "x.grad     ## tensor([4., 4.])\n",
    "c.grad_fn==None  ## True\n",
    "c.requires_grad  ##False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于变量c记录了y的计算结果，在y上调用反向传播， 将得到y= x**2+3关于的x的导数，即2*x。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([True, True])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.grad.zero_()\n",
    "y.sum().backward()\n",
    "x.grad == 2 * x  ##tensor([True, True])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 2.6 使用NumPy实现机器学习"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(100) \n",
    "x = np.linspace(-1, 1, 100).reshape(100,1) \n",
    "y = 3*np.power(x, 2) +2+ 0.2*np.random.rand(x.size).reshape(100,1)  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "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",
    "plt.scatter(x, y)\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 随机初始化参数\n",
    "w1 = np.random.rand(1,1)\n",
    "b1 = np.random.rand(1,1) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr =0.001 # 学习率\n",
    "\n",
    "for i in range(800):\n",
    "    # 前向传播\n",
    "    y_pred = np.power(x,2)*w1 + b1\n",
    "    # 定义损失函数\n",
    "    loss = 0.5 * (y_pred - y) ** 2\n",
    "    loss = loss.sum()\n",
    "    #计算梯度\n",
    "    grad_w=np.sum((y_pred - y)*np.power(x,2))\n",
    "    grad_b=np.sum((y_pred - y))\n",
    "    #使用梯度下降法，是loss最小\n",
    "    w1 -= lr * grad_w\n",
    "    b1 -= lr * grad_b\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2.98927619]] [[2.09818307]]\n"
     ]
    }
   ],
   "source": [
    "plt.plot(x, y_pred,'r-',label='predict',linewidth=4)\n",
    "plt.scatter(x, y,color='blue',marker='o',label='true') # true data\n",
    "plt.xlim(-1,1)\n",
    "plt.ylim(2,6)  \n",
    "plt.legend()\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.show()\n",
    "print(w1,b1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.7 使用Tensor及autograd实现机器学习\n",
    "使用PyTorch中张量及自动微函数（autograd）替换2.6小节中手工计算梯度的反向传播。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch \n",
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "torch.manual_seed(100) \n",
    "dtype = torch.float\n",
    "#生成x坐标数据，x为tenor，形状为100x1\n",
    "x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) \n",
    "#生成y坐标数据，y为tenor，形状为100x1，另加上一些噪音\n",
    "y = 3*x.pow(2) +2+ 0.2*torch.rand(x.size())                 \n",
    "\n",
    "# 画图，把tensor数据转换为numpy数据\n",
    "plt.scatter(x.numpy(), y.numpy())\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 随机初始化参数，参数w，b为需要学习的，故需requires_grad=True\n",
    "w = torch.randn(1,1, dtype=dtype,requires_grad=True)\n",
    "b = torch.zeros(1,1, dtype=dtype, requires_grad=True) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr =0.001 # 学习率\n",
    "\n",
    "for ii in range(800):\n",
    "    # forward：计算loss\n",
    "    y_pred = x.pow(2).mm(w) + b\n",
    "    loss = 0.5 * (y_pred - y) ** 2\n",
    "    loss = loss.sum()\n",
    "    \n",
    "    # backward：自动计算梯度\n",
    "    loss.backward()\n",
    "    \n",
    "    # 手动更新参数，需要用torch.no_grad()更新参数\n",
    "    with torch.no_grad():\n",
    "        w -= lr * w.grad\n",
    "        b -= lr * b.grad\n",
    "    \n",
    "    # 因通过autigrad计算的梯度，会累加到grad中，故每次循环需把梯度清零\n",
    "        w.grad.zero_()\n",
    "        b.grad.zero_()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEKCAYAAADuEgmxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dd3gU5fbA8e9JgRCKSBFBIEFFUZAiRQGvDa/XgqCCimJF4Ac2LKggFkS52BWEKzeKDSKo2FCvF1FQrw0NAooiCpIgglRFIBAgOb8/Znezs9mEEHa2JOfzPPtk5513Zk8mmz0785YRVcUYY4wpj6RYB2CMMSZxWNIwxhhTbpY0jDHGlJslDWOMMeVmScMYY0y5WdIwxhhTbp4mDRGpKyIzReRHEVkqIl1D1ouITBCR5SLyrYgc62U8xhhj9k+Kx/sfD/xXVfuKSDUgPWT9mUBL3+M44CnfT2OMMXHIszMNEakDnAhMAVDVXar6Z0i13sCL6vgSqCsijb2KyRhjzP7x8kzjUGAD8JyItAMWAMNUdXtQnUOAX4OWV/vK1gbvSEQGA4MBatas2bFVq1Yehm2MMZXPggULNqpqw/3dj5dJIwU4FrheVeeLyHhgBHBXUB0Js12JeU1UNQvIAujUqZPm5OR4EK4xxlReIpIXif142RC+GlitqvN9yzNxkkhonWZBy02BNR7GZIwxZj94ljRU9XfgVxE50lfUA/ghpNos4HJfL6rjgS2quhZjjDFxyeveU9cD2b6eU78AV4nIEABVnQz8BzgLWA7kA1d5HI8xxpj94GnSUNVFQKeQ4slB6xW41ssYjDGV0+7du1m9ejU7d+6MdShxJS0tjaZNm5KamurJ/r0+0zDGGE+sXr2a2rVrk5mZiUi4PjVVj6qyadMmVq9eTYsWLTx5DZtGxBiTkHbu3En9+vUtYQQREerXr+/p2ZclDWNMwrKEUZLXx8SShjHGmHKzpGGMMXGiVq1aAKxZs4a+ffuWWfeJJ54gPz8/GmG5WNIwxhgPFRYW7vM2TZo0YebMmWXWsaRhjDEVIeLtowy5ubm0atWKK664grZt29K3b1/y8/PJzMxkzJgxnHDCCbz66qusWLGCM844g44dO/K3v/2NH3/8EYCVK1fStWtXOnfuzF133eXab5s2bQAn6QwfPpxjjjmGtm3b8uSTTzJhwgTWrFnDKaecwimnnOLdsQ3DutwaY8x+WLZsGVOmTKF79+4MGDCAf/3rX4AzXuLTTz8FoEePHkyePJmWLVsyf/58rrnmGubOncuwYcMYOnQol19+OZMmTQq7/6ysLFauXMnChQtJSUlh8+bN1KtXj8cee4x58+bRoEGDqP2uYEnDGGP2S7NmzejevTsAl156KRMmTADgoosuAmDbtm18/vnnXHDBBYFtCgoKAPjss8947bXXALjsssu4/fbbS+z/gw8+YMiQIaSkOB/X9erV8+6XKQdLGsYYsx9Cu7j6l2vWrAlAUVERdevWZdGiReXaPpSqxlXXYmvTMMYkNlVvH3uxatUqvvjiCwCmT5/OCSec4Fpfp04dWrRowauvvuoLV1m8eDEA3bt3Z8aMGQBkZ2eH3f/pp5/O5MmT2bNnDwCbN28GoHbt2mzdurUCB2z/WNIwxpj9cNRRR/HCCy/Qtm1bNm/ezNChQ0vUyc7OZsqUKbRr147WrVvz1ltvATB+/HgmTZpE586d2bJlS9j9Dxw4kObNm9O2bVvatWvHSy+9BMDgwYM588wzo94QLlqOTBpP7CZMxhiApUuXctRRR8U0htzcXHr27MmSJUtiGkeocMdGRBaoaugEsvvMzjSMMcaUmyUNY4ypoMzMzLg7y/CaJQ1jjDHlZknDGGNMuVnSMMYYU26eDu4TkVxgK1AI7AltuReRk4G3gJW+otdVdYyXMRljjKm4aJxpnKKq7cvo6vU/3/r2ljCMMYnizz//DMwzVZXY5SljjKmA0pJGRaZCTyReJw0F3heRBSIyuJQ6XUVksYi8JyKtPY7HGFNFZWdDZiYkJTk/S5m1o9xGjBjBihUraN++PZ07d+aUU07hkksu4ZhjjnFNbQ7wyCOPMHr0aIBSp0lPFF5PWNhdVdeIyEHAHBH5UVU/CVr/DZChqttE5CzgTaBl6E58CWcwQPPmzT0O2RhT2WRnw+DB4L9nUV6eswzQv3/F9vnAAw+wZMkSFi1axEcffcTZZ5/NkiVLaNGiBbm5uaVuN3jw4LDTpCcKT5OGqq7x/VwvIm8AXYBPgtb/FfT8PyLyLxFpoKobQ/aTBWSBM42IlzEbYyqfUaOKE4Zffr5TXtGkEapLly60aNGizDplTZOeKDxLGiJSE0hS1a2+56cDY0LqHAysU1UVkS44l8s2eRWTMaZqWrVq38orwj8VOkBKSgpFRUWB5Z07dwJ7nyY9EXjZptEI+FREFgNfAe+q6n9FZIiIDPHV6Qss8dWZAPTTRJtB0RgT90q7qr0/V7vLmpq8UaNGrF+/nk2bNlFQUMA777wDlD1NeqLw7ExDVX8B2oUpnxz0fCIw0asYjDEGYOxYd5sGQHq6U15R9evXp3v37rRp04YaNWrQqFGjwLrU1FTuvvtujjvuOFq0aEGrVq0C67Kzsxk6dCj3338/u3fvpl+/frRrV+KjMm7Z1OjGmIS0r1OjZ2c7bRirVjlnGGPHRq49I954OTW63e7VGFMl9O9feZNENNngPmOMMeVmScMYk7AS7fJ6NHh9TCxpGGMSUlpaGps2bbLEEURV2bRpE2lpaZ69hrVpGGMSUtOmTVm9ejUbNmyIdShxJS0tjaZNm3q2f0saxpiElJqautcR2Cby7PKUMcaYcrOkYYwxptwsaRhjjCk3SxrGGGPKzZKGMcaYcrOkYYwxptwsaRhjjCm3xEsahYWwY0esozDGmISQnQ2dm64FOnaMxP4SL2l89x1MmhTrKIwxJu5lZ8O0q+fx2W8ZEdtn4iWNwkIYN46Xn/6LzExISoLMTOfgGGOMKTbqDuXugjuoxu6I7TPxkgbA5s0sv+Yx8vJAFfLynLtyWeIwxphibVe9Q1e+jOg+E+/OfSKaA2ylFi1YySYaBNZlZEBubsxCM8aY+FFUxNK09hy1+zsAhI6o5sj+7tbTMw0RyRWR70RkkYiUuEerOCaIyHIR+VZEji3vvmuzjZGMc5WtWhWBoI0xpjKYMSOQMCIpGpenTlHV9qXcm/ZMoKXvMRh4al92fC2TOITVgeXmzfcnTGOMqSR274a77/Zk17Fu0+gNvKiOL4G6ItK4rA12kRp4nkYBd3EfAOnpzo3ijTGmynv2WVixong5JQVYsCASu/Y6aSjwvogsEJHBYdYfAvwatLzaV+YiIoNFJEdEctZS27XuaqZwUpOfycqym8YbY6qm7GwCvUmPbL6D/JFj3BUGDozYa3mdNLqr6rE4l6GuFZETQ9aHa5Qp0TKvqlmq2klVO20kk59oGViXQiEf/e0uSxjGmCopO9vpPervTdr71ydJ/2NNYP1OSeP1o++M2Ot5mjRUdY3v53rgDaBLSJXVQLOg5abAGsokPNkgJIu+/HKkzryMMSahjBoF+fnO87r8UaKD0ES9lstGHAI0qBeJ1/MsaYhITRGp7X8OnA4sCak2C7jc14vqeGCLqq4ta78dO8KT6y6EDh3cK0aOjFjsxhiTKIJ7jd7OgxzIn4HlLdRhHCN9SaVJiUv/FeHlmUYj4FMRWQx8Bbyrqv8VkSEiMsRX5z/AL8By4GngmnLtOSkJxrmzKXPmwIcfRih0Y4xJDP5eo034jWGMd617kNvZTH3fUmq1SLxe4g3u69RJc3JynIt3PXrAvHnBK+Grr0D2e/yKMcYkBH+bxuP5gxnM04HytRzM4Swnn5q+kna7VBdX39/Xi3WX24oTgQcecJfl5MDMmbGJxxhjYqB/f5g+ehkDeNZVfi/3BBJGejrAmt8i8XqJmzQAunSBPn1cRSsvuYOXXojc5FzGGBPven15BykUBpb/OrglHzS/GhFneqWsLICNmyPxWomdNIBZx41lD8mB5RZ7lvP1oCybvNAYUzV8/jm8/rqrqM6EsSzPS6WoyJmPL5JDEhI+adww6UimcLWrbOTuexk38q8YRWSMMVGiCrfe6i7r3Bn69vXsJRM+aaxaBaMZzXbSA2UHsYF+vz4cw6iMMSYK3nzTOdMI9tBDnnYGSvik0bw5/E5jHmG4q/xmHuW4pr/ZZSpjTOW0ezeMGOEu69kTTj7Z05dN+KQxdqzTM+ARhvM7jQLl6exg0G/32M2ZjDGV0zPPwE8/FS8nJcGDD3r+sgmfNPr3d3oG1M+ozWhGu9ZdxXO0yF/CqFGxic0YYzyxdSuMHu0uu/pqOPpoz1864ZMGOIkjNxee5Wp+5MhAeTJFPMJwuzmTMaZyeeABWL8+sJgv6bzednRUXrpSJA2/JhmpjMA94O8MZnOGzCYpyZk62C5VGWMS2q+/sufhx1xFj+gtXHZ7k6h8vlWqpDF2LMyp0ZuPcc/A/mDRcEQLycvD2jiMMYntjjtI2b0zsLiWg3mI28jPJyqX4itV0ujfH7KeFh45+FFX+TEsCQyxj9aBNcaYiMvJgWnTXEV3cR/bqQUQlUvxlSppgJM43l7bCS691FV+H3dRi61AdA6sMcZElCrccour6FuO4TmuCiz7Z7z1UqVLGgH//Cc7JS2weDDruI2HgOgcWGOMiaSPb3oTPvnEVTacRyjyTaOUnu5covda5U0azZqx/JybXUXDeYQM8sjLs0ZxY0zimP58AU0nuKcL+a+cwTf1T3dNShiN215X3qQBtJk2gh0HFA/4q8FOxuGMoLRGcWNMolh50wQO0xWB5UKSuEUfoVYtPJmUsCyVOmlQuzY1HnWfr13MDLrizNVijeLGmLi3bh3X/Xmfq2gyQ/iB1jFpn63cSQPgyitL3E/8CW5EKAKsUdwYE+fuvps6vk48AH9Ql3u4F4hN+6znSUNEkkVkoYi8E2bdlSKyQUQW+R4DIx5AcjI88YSrqAtfcylOtzVrFDfGxK3Fi505poLcyz1sokHUGr5DReNMYxiwtIz1L6tqe9/jmTLqVdyJJ5LXxT2//AOMoGGNbTE56MYYs1eqcOONTqOFz4qUI3iKa6La8B3K06QhIk2BswFvksE+yJjxEIUp1QLLTVjL3NP+GZODbowxe/Xaa/DRR66iX4c9SoFWi2rDdyivzzSeAG4Disqo00dEvhWRmSLSLFwFERksIjkikrNhw4aKRdKiBcm3ugfGtJn9KCxfXrH9GWOMV/Lz2T7E/Xk1m9M5+19nx7zHp2dJQ0R6AutVdUEZ1d4GMlW1LfAB8EK4SqqapaqdVLVTw4YNKx7UHXdAkybFy7t2lRhhaYwxMffww9TcVNxLZzcp3MgT5O+QmPf49PJMozvQS0RygRnAqSLimjRFVTepaoFv8Wmgo4fxQK1azq0Qg82aBbNne/qyxhhTbnl5ztTnQZ7ken7kKCD2PT49SxqqOlJVm6pqJtAPmKuqrgmhRKRx0GIvym4wj4xLLoFu3dxlw4Y5Zx3GGBNl2dnODBX+2zfkXXgr7CyexXYdB3Ev9wSWY93jM+rjNERkjIj08i3eICLfi8hi4AbgyigEAE8+iQbfeH3ZMr65coLnL22MMcGys52ZKfLynM5Sh+bNJeOrV111RjKOvzgAiN78UmURVY1tBPuoU6dOmpOTs1/7yM6GgisGM6Dw6UDZVmox58llnH9dkzK2NMaYyMnMdBIGQCq7WER7jg664LKpRSc6Fc4n79ckmjd3EkZFe02JyAJV7bS/MVf+EeFhjBoFtxeO5Q/qBspqs43k24fHMCpjTFUT3D5xAxNcCQNg4I4nuf+fSVGfX6osVTJprFoFG2nIndzvKu+dP71Ev2hjjPGKv32iMWsCU4P4TWEAb/5+fNxNrFolk4b/DzWZISykvXvlddfB7t3RD8oYU+WMHeu0UzzCcGqzLVD+B3UZgdODKt4mVq2SScP/hyoimWuZ5F75/fcwcWJsAjPGVCn9+8ObN33MJUx3ld/J/WykeExarLvZBquSSaN/f2felowM+FK6MbPmFe4Kd98Nv/0Wm+CMMVXHrl38/Y1rXEULac9khrjKYt3NNliVTBrgJI7cXGcusL4rHoQDDiheuW0b3HxzqdsaY0xEPP44/PCDq2h49YmBW7hCfHSzDVZlk4ZLo0Z8fW7IX+WVV+D992MTjzGm8svLgzFj3GUDBjBgSncyMoj6bVzLq0qO0wiVnQ1DBhUyb8dxdKJ4qqy/Gh1OndzvIC0toq9njDH07u1MY+RXrx4sWwYNGnjycjZOI4JGjYJtO5IZwmSKKB4pXmfd8hJzwBhjzH6bNcudMAAefNCzhBFJljQo7pmwgE48xVD3ynHj4Kefoh+UMaZy2r4dbrjBXda1KwwYEJt49pElDdw9E0YxlnUcVFywaxe/nzfEmRjGGGP21z33FM8dAuwhmXfPmezMWJgAEiNKj/nHbQBsoS4385hr/cE/zOPzoVNjEJkxplJZuJCix59wFY1nGBfe3zauRn2XxZIG7nEbAC9xCe/zd1edVk/fDBs3xiA6Y0ylUFgIgweTVFQYKMqjOfdwb9yN+i6LJQ0f/7gNZ8Z0YShPsYPiXlP1ijbBrbfGKjxjTIL7esC/IKTn57VMYju1gPga9V0WSxoh/O0bv3AYY7jbvfL552Hu3KjHZIxJbK9PWE2rF+9wlc2kD+/SM7AcT6O+y2JJI0Rw+8YjDOc72rgrDB4MO3ZEPzBjTGJSpc6Ioa4JCf+iNjdQfOO3eBv1XRZLGiGC2zcKJZV7Gv3bNXaDFSv4/sLRMYvPGJNgXnmF03a84yoayTjW4tzwLR5HfZfFRoTvRXY2bL3yOobsKZ4Ndw/JvH/fV5x157FRi8MYk4A2bYKjjoINGwJFn9OVE/gUJYmMDKctNRoSZkS4iCSLyEIReSfMuuoi8rKILBeR+SKS6XU8+2rUKLhtzz/5laaBshQKaX7fQNizJ4aRGWPi3i23uBJGAdUYyDMoSQl1SSpYNC5PDYOQexgWuxr4Q1UPBx4HHoxCPPtk1SrYSh2G8pSrvM2uhfDoozGKyhgT9+bMgRdecBVNOmAUP8rRCXdJKthek4aIXCciB1Zk5yLSFDgbeKaUKr0B/1GdCfQQESmlbkz4ezS8S0+m08+1rvCuezj1kGUkJTk3iE+UwTnGGG9kZzufBXVkK6vPHORe2bo1N68fEVf3+66I8pxpHAx8LSKviMgZ+/ih/gRwG1BUyvpDgF8BVHUPsAWoH1pJRAaLSI6I5GwIOtWLhuDeVMMYzybqBdYl7y7gvjUDEC0kL4+4u5evMSZ6srOdz4C8PPgnI2laWDxVSBHCfy94BqpVi2GEkbHXpKGqdwItgSnAlcDPIvJPETmsrO1EpCewXlUXlFUt3EuGiSFLVTupaqeGDRuG2cQ7wb2pNspB3FlrvGt9dz7nOpzbwybSqE5jTGSNGuV8BpzIx1wXchvp8Qyjz0PHV4ovleVq01Cni9Xvvsce4EBgpog8VMZm3YFeIpILzABOFZFpIXVWA80ARCQFOADYvC+/QDT4R4tPnQovFvbn7aABOQDjGMmhrAASZ1SnMWb/+S9HJSU5Zxg1yGcKV7vqLOcwRjG20nypLE+bxg0isgB4CPgMOEZVhwIdgT6lbaeqI1W1qapmAv2Auap6aUi1WYD/Bt19fXXitg/wqFGQv0MYwmT+pPj2sOnsYApXIxQlzKhOY8z+Cb4c5f/Uup87Odz3BdLvaqawA+cad2X4UlmeM40GwPmq+g9VfVVVdwOoahGEfOUuBxEZIyK9fItTgPoishy4GRixr/uLJv8ffA2HcBOPu9adzMdcl/QU27ZhDePGVAH+y1F+3fmUG3HPYDuRa/mEkwLLleFLpQ3u2weZmcHT4CvvcSZnMDuwfjvptGMxKzgccBrQE7VbnTGmbElJxWcY6WxnMe1cZxm5ZNCGJYEJCWP9eZAwg/sqk+CeVCAM4mm2UCewvib5PM+VJOFMfVxZrmEaY0oKPmt4kNtLXJZaPmIKDTJqIZJ4U4WUxZLGPgjuSSUCyRnN+GGQ+3T0BD5znaJWhmuYxpiS/F8iT+XDEr2luPZaThvXg9xcEn5cRii7PLW/VKFXL3ineJaUnVSnAwv5kaOiOreMMSa6Xn76L7oPPYamhUHfDg87DBYvhpo1YxdYGHZ5Kl6IQFYWBTWLB82nUcBULiOV3eTlWaO4MZXVRV/c6E4YIs59d+IsYUSSJY1IaNyY6lkTXUWdWMAo7gew0eLGVEZvvgnPPecuu/lmOOGE2MQTJXZ5KlJU4cILYebMQNEekjmBT5nP8QB2qcqYymLdOmjTBjZuLC47+mjndq41asQurjLY5al4IwKTJ0PjxoGiFAqZymWksx2wRnFjKgVVGDjQnTBSU2HatLhNGJFkSSOS6teHKVNcRS1ZzqPcAlSOgT3GVHnPPOPq+ALA6NHQoUNMwok2SxqRduaZ/NRjqKtoCP+mb7VZCXnDFWNMkGXL4MYb3WXdusFtt8UmnhiwpOGBI956mL8Obukqm1r9avqfujZGERlj9tuuXc5gi6C5Q7ZLTd7q8yKkpMQwsOiypOGFmjWpMyvb9UZK27oRrrjCGeljjIlrwbPXBrrM33UXLHDf6eEGHc8ldx1WpXpGWtLwSufOMGaMu2zOHG5JfoIGDaBBA5vY0Jh4FDp7bV4eZF89F334YVe9mfThWQZUuemCrMutlwoLoUcP+PjjQFEB1TieL1lEcaNZrCcyM8YUc09MCvXYxGLa0ZTfAmW/0pR2LOYP3508ReL/IoJ1uU0EyckwdSpbkuoGiqqzixn0oybbAmVV7ZuKMfHM3TVeeY6rXAmjCOEypgYSBlStnpGWNLzWrBmDirJcRUfyExO5zlVm040YEx+CE8D1PEkv3natf5Db+ZiTA8vp6VSpnpGWNKLgq4wLyGKQq+xKXuBSprrKbLoRY2LPP3ttB77hYW51rfuS47ib4rbKyjTleXlZm0YUZGfDsEH5fLyjM635IVC+jZocyzf8zBGu+jbdiDGx9fIzW+ky9Fha7FkeKPuTA+jAQnJpASRGO0Ywa9NIIP37w/in07mp8cvsIC1QXovtvMKFpLHDVd+mGzEmhlS5aN4QV8IAGMTTgYQBVasdI5hnSUNE0kTkKxFZLCLfi8i9YepcKSIbRGSR7zHQq3hirX9/eH9NG2r8e7yrvD2LeQL3CNOq+mY0Ji5kZcFLL7mKnkn5P2ZyQWC5qrVjBPPyTKMAOFVV2wHtgTNE5Pgw9V5W1fa+xzMexhMfBg1yZsMN8n9kcQlOQ0ZVfjMaE3MLF8KwYe6yNm2olfV44I6dVbEdI5hnY9/VaSzx9ytN9T0SqwHFCyLw9NPwzTewvPj099/8H7836ciAh1pV2TejMTG1ZQtccAEUFBSX1aoFM2fS78ga9LsqdqHFE0/bNEQkWUQWAeuBOao6P0y1PiLyrYjMFJFmpexnsIjkiEjOhg0bvAw5OurUgVdfherVA0W12M6HB/Yleef2ktMXGGO85Z/ufMUKd3lWFhx5ZGxiilOeJg1VLVTV9kBToIuItAmp8jaQqaptgQ+AF0rZT5aqdlLVTg0bNvQy5Ohp3x6efNJd9v33yP8NJi9PA9MXWBdcY6Lg8cddN1ADYMgQuPji2MQTx6LSe0pV/wQ+As4IKd+kqv5zwaeBjtGIJ24MHFjiwuhFhS9xLZMCyzZa3JjICTsR4SeflJzavEMHJ5GYErzsPdVQROr6ntcATgN+DKnTOGixF7DUq3jikv9uf61bu4of42aO54vAsnXBNWb/hZuI8O6Ba9jR60Jnnji/unWdy8dpaaXvrArz8kyjMTBPRL4FvsZp03hHRMaISC9fnRt83XEXAzcAV3oYT3yqVQtefx1q1w4UVWM3M+nLQawDrAuuMZEwapTrVhiksJsXdl5IjS3rXPXO+XMqmT2q1nTn+8LL3lPfAiXuf6iqdwc9HwmM9CqGhHHEEfD889CnT6DoENbwChfSq8YHjB2bGrvYjKkkQs/YH+NmTuAzV9l93Mk79ARfeyJU3a61pbER4fHi/PNLXFc9iU/46oSb7U1rTAQEn7FfxbNcz0TX+tmczmhGB5atPTE8SxrxZOxYOPVUV9GRcybCs8/GKCBjKg//RIRdmM9TDHWtyyWD/mRTRLKr3NoTS7KkEU9SUuDll50hp8GGDoX54Ya4GGPKq39/ePHBtbyVfD7V2RUoz6cG5/Imm2hQYhtrTyzJkka8adAA3nwTatQoLtu1C847D377rfTtjDFl27mTPtnnc3DhGlfxAJ5lMe1LVLcpfcKzpBGP2rcveUlq7Vo2/e1cd/cPY0z5qDot219+6Sp+POVWXqZfYFnE+VnV55cqiyWNOJVd2I/HU9w3gKm/MofcHgOcfwBjTPk9/DBMdd/0jNNPp9Gz41wTEU6d6vx75eZawiiN3YQpTmVmwq95hbxFb3ryrnvlmDFw110xicuYhDNrFpx7rvvL1hFHOO2EdevGLq4os5swVXKrVkERyVzCSyzBPWKcu++GV16JTWDGJJLFi51ThuCEUbcuvP12lUoYkWRJI075e21spQ69mMVG6rvWF156OXzxRZgtjTGA03Hk7LNh27bisuRkZ4qQI44ofTtTJksaccrfpxxgJYfSh9fYRfHI8OTdBew8ozf88kuMIjQmjm3bBuecU7LH4fjxcNppsYmpkrCkEaf693d6b/iHbHzCSQziaVedtL82wNln80rWn3YPDmN8XppayJyDLnHuwhdkAjeQ+fC19v+xnyxpxLH+/Z1eHP5ugC9yBfcTMq/Bjz/SaOh5rM0rsHtwmCrLP+W5iLL58hv5+463Xevfpic38Zj9f0SAJY0EEDwq9W7GMIOLXOtPKvqI57kSoQiwOXNM1RI85fmtPMx1IXNKLaQ9FzM9MEWI/X/sH0saCSC4fUNJ4kqe53Pp5qpzMTN4kNsDyzZnjqkq/FOeX8xLPBT0PwCwmkM4h7fZTi1Xuf1/VJwljQQQ3L4hArXqp9EnZRbLcPcAuZVHuIHxgM2ZY6qOVavgFObyfMjteLZQhzN5j99oWmIb+/+oOLa673MAABlNSURBVEsaCcLfvlFU5Ny36ffd9TmD//I7jVz1xnMjV1SbHpgzJ+ztLY1JQKW9l89s9A1vci7V2B2ou4tUzuVNlnBMif3YnFL7SVUT6tGxY0et6kRUndFKqh1YoH9Rq7gAdE9Sil5+0HsK7rqgmp6uOm1arH8DY/bNtGnOezf4vZyaqtql7jJdR0P3CtB+TFdQzchQHTrU+Sni/Kyq738gRyPwGWzTiCSgzEyn0c/vdGbzDj1JZU+gbDvpnMYHfEnXEttnZDhnLcYkitD3PEATfuMzupOJe8X9Bz5CiydvsbmjQsT9NCIikiYiX4nIYt99wO8NU6e6iLwsIstFZL6IZHoVT2US3DAO8D7/YFC1F1F/31ygJvm8y9m0ZkmJ7a0R0CSa0PdsPTYxm3+USBiT69zGnZstYXjJyzaNAuBUVW0HtAfOEJHjQ+pcDfyhqocDjwMPehhPpRHaMJ6RAX9/9mJkwgRXvXr8wQecxuH87Cq3RkCTaILfs3XYwmz+QRu+d9WZwgCu+euBKEdW9XiWNHyX0fyTvqT6HqHXwnoDL/iezwR6iAR9XTalCm4YD0zjfN11PHHAPa56B7OOD+lBc983MmsENInIf3adznbeoSedWOBa/wbn8n/8m+YZ9vHhNU97T4lIsogsAtYDc1Q19J6lhwC/AqjqHmALhMzM5+xnsIjkiEjOhg0bvAw54TWceA//SrneVdacX/mQHnQ6ZK3dWMYkpP794ZmJO3kv7Tz+xqeudR9yKpfwEtXTU+wLURR4mjRUtVBV2wNNgS4i0iakSrivBSVa5lU1S1U7qWqnhg0behFqpdH/UuGAZ5/glZpXucoPZwVf1+lB/9PWxSgyY/ZDQQEXv9aXE3fOcRUvqN6Vc3mLRhk17AtRlERlnIaq/gl8BJwRsmo10AxARFKAA4DN0YipMut/WRIXbnkaLnJPN8LSpXDqqbB+PWBjOEyC2LULLrgA3g25GVmHDnT8/T9s1Vp2p70o8rL3VEMRqet7XgM4DfgxpNos4Arf877AXE20PsDxKjnZuXflOee4y3/4AXr0YOZTGwLz9dhEhyZu7d7tfPl52z0BIUcfDbNn242UYsDLM43GwDwR+Rb4GqdN4x0RGSMivXx1pgD1RWQ5cDMwwsN4qp7UVOeGM2ee6S5fsoSW15xGer67fcgmcjNxZdcu6NcP3nzTXd6qFXz4Idil6piwwX1Vwc6drOlyLk2+m+0q/p6j6cGHrOPgQJmI0yPLmJjaudO5JPXOO+7yI46Ajz6Cxo1jElYii/vBfSaOpKVxyp9v8D5/dxW35gc+5iSaUHx3MxvDYWIuPx969y6ZMA4/HObOtYQRY5Y0qoifV9fgXN5kNqe7yo/kJz7hRDLIRcRp27BGcRMz27ZBz57w/vvu8pYtYd48OOSQ2MRlAixpVBHNm8MO0unNW7zD2a51h/ELn3ICR+pSwBrFTXT5e/HVl83kHHiakxyC/Jx6FE1+/pjME5raezIOWNKoIvwjagtI43xe53XOc61vym98wokc6xtpa43iJhr8d90ryFvLR5xEpz3u8b/fcgzdd3/EWhrbl5k4YUmjigier2qPVOO25i+Te3w/V52GbGQep3AiHwM2saHx3qhR0CjfOdM9JmRyzRw6cgrz2MBBgTL7MhN7ljSqkOD5qpbnpZL56TTnq1uQOmxlNv/gfF6zRnHjuXp5C/mcbhzGL67yjziJU5nL5pKzCtmXmRizpFGVJSfD5Ml839N9X+U0CniVC3j1pIkxCsxUCXPm8ImcyMG4p7Z5m56cyXtspU7YzezLTGxZ0qjqRGj99gMsvMg9pXQSSucXr+cBGUmLjCK7jmz2S+iUNZ9dkw1nnUWtwETYjmn053xeZyc1wu7HZmmOPUsaBoAOM26H555zzj6CjOABxq26hOsH7bTEYfaJP1GIwGWX+aesUS7Lu4/uT10Ke/a46j/KLdxU70UOqJ8auE/M0KHu+8bYpISxZyPCjdt775F/dl/SNd9V/Dldua7pW3zzq03dYPbO3ysqP+htVI0CshjMFbxYcoPHHoObbopegFWQjQg33jjzTE7Wj1iPOzl04wtmrj6Otx/6wWbGNXs1apQ7Yfhvz1oiYVSrBtOnW8JIIJY0TAnrMzpzPF/yA0e5yg9lJSfdfjxt8t6xmXFNmYJ7OLXhO76mMyf7unL7baIeJ+76gMwR/ew9lEAsaZgSxo6FdemH0o3P+YAernV12MosejGCcYBav3kTlr+H07m8wRd05VBWutb/REuO50v+x9/sy0eCsaRhSvAPBKybUZczeY9nGOhan4QyjjuYzsXUZJv1mzcljL2viPtTRvMG51OL7a51n3AiXfmC5bQMlNmXj8RhScOE5R8IeEhGKoPI4nomsAd3z6p+vMx8juPkxstiE6SJT5s20f+lsxm1596S64YM4e/MsUF7CcyShimT848sTOR6/sFsNnOga31rfuCttZ3pK69Zw7iBBQugY0f473/d5Skp8K9/wVNP0TijWthNbdBeYrCkYcoU/I88lx505mu+5RhXndq6lZn05aa8YVw3qMASR1WkChMnQrduTg+JYAcdBHPmOIMuKJ48M5gN2kscljRMmUL/wX/hMHrU+IKV3UqOsBrGBD7Y0Y2s25aXGAFsiaQS++MP6NMHrr/euUVrsK5d4Ztv4OSTA0XBk2faoL0EpKqePIBmwDxgKfA9MCxMnZOBLcAi3+Puve23Y8eOaqJr2jTVjAxVEefntGmqWlSk1zJRC0hVdb5nBh5/UUsHVJuqUBQoTk/3bWcql//9z3lThLwHFPTZ2tfrS88XxDpC4wPkaCQ+2yOxk7A7hsbAsb7ntYGfgKND6pwMvLMv+7WkET8yMlS78KX+QmbYD40ZXKgHsilQlJER64hNRYR+aRg6VPXw5gX6T0bqHpJK/N23UFsvZIZ9WYgzkUoanl2eUtW1qvqN7/lW3xmH3auxEhk7FpakH0cHFjKTPiXWX8QrfEtbevABYL1jEpF/OhBn3ijn57ynljJjVVdGMo5kilz1c+hIBxbyChcB1pW2MopKm4aIZAIdgPlhVncVkcUi8p6ItI5GPCYygsdzXMCrXMskdpDmqtOU3/iAv/MUQzi66V8xitRUVPB0IMns4TYeZCEd6Mg3Jeo+zo105zN+4TBXuX1ZqGQicbpS1gOoBSwAzg+zrg5Qy/f8LODnUvYxGMgBcpo3bx7JMzYTIf7L2kfxvS6gQ9jLVdvqN1OdPTvWoZpSBF+Gql/fefj/fEezROfTOezfdTVN9DTeD7fKLkvGEeK9TcOJkVRgNnBzOevnAg3KqmNtGvFJpPhDIpUCHctILSSoMOjxWs1L9dVJ68LuJ2yju/HctGlO+0PonyuNfL2PUWE7PIRrtwp9WJtG/Ij7pAEI8CLwRBl1DqZ4evYuwCr/cmkPSxrxKVwHmq58pstTjgj7abKJA/WLq59WLSwM7CPcB5d96HgnOEEnJ5f8M53G+/ozh4X9+22gvvbjJVcPOVBNTXXOUCzpx59ESBonAAp8S3GX2rOAIcAQX53rcLrjLga+BLrtbb+WNOJTaR/405/N16fq3Bq2l42C6vHHq371laqW2nPTLm94oLQzC1BtTq6+Qt/wK0EXHNpXOzb93XUZy5JE/Iv7pOHVw5JG/Crt0pKIamfm6yLalvpBpFddpY34PewqkVj+VpVTuARdg+16D/doPmlh/0a/JzdWffXVWIduKihSScNGhJuI8U9yWFTk/PSP8G3eHL6mC53IYTgPs530khs/9xzL5XBGcT/pIbOi2pxEkRfcoymJQq7kOX7iCEZzLzXY6apbhPBUynV8/NRS6Ns3ypGaeGNJw3jOPxXJHlJ5lOEczQ+8ndy7RL1auo37uYufackgskhhNyLO2ACbiiSynESsnMW7LKI9zzGApvxWot7XdOK8g7+kzvNPcuGgA6Iep4k/ljSM50LnGpKMDP564U14/3046qgS9Zuwliz+j6UcxWX6AsnsKXGjHpvbqmKysyEzQzki730+pxvv0pNjWFKy4kEHwZQpdC6cz1tru9i8UKZYJK5xRfNhbRqJL7jto1G9XXpT8njdQNCggJDHMlrq5TyvqRQE2kqsl1X5uMZe1CvSs1P+q59wQultS9Wrqw4frvrnn7EO3UQY1hBuElFpvXbq8KeOZWSpjbAKuoqmeiOP61HNtlb5Xlbh5oMK7YTgP9bJ7NaLmK7f0L70ZCGietllqrm5sf3FjGcilTT8YyQSRqdOnTQnJyfWYZgKyswsebuFYIewmru4jwE8Syp7wtb5g7o8w0AmcS15ZAbKRZxG+MrOPx+Uf3qPcNLToXH1zZz3xxSuZRKZlH7QZ3EOvRaOgfbtPYjWxAsRWaCqnfZ7P5Y0TDQlJTlfbfemfd1chm29n0sLnyeFwrB1Cknibc7h3/wf73M6zTKSyc2NbLzxqOzEq3Qih8Fk0Z9s0tlR6n7e5SxGM5oNGZ2rxHGr6iKVNKwh3ERVebrPpqfD8ImZpL7wDCc3+ZlJXMtOSStRL5kizuUt3uMscslkQN7d/O2QXyp9o3i4CQAbsIHrmcBi2vE1XRjEM2ETRhHCTPrQma/oybv8kN7Z7phn9k0krnFF82FtGoktXJtGuaaeWLdOv+s9Sjcn1Sv9urzv8WXS8fr1ZeNV165N+LmswsXvH5hXi7+0P1P1Xc7U3YSZByTokU+aZjFQj05ZZiO4qyisIdwkqop8kPuTTRr5ehVTdCHt9po8ikT0s6TuOpyHtCXLItbLKlqJKFyCbVFjrU47KUvfSzpLd1B9r8cgj2Z6Ow9oPTZakqjiIpU0rE3DJISS1/GVbnzOQJ7hQl6hJmW0Cvss5zDm8HcWNTydfy87GQ48cJ/jCNcInZ7uzT2uMzNhfV4+XfmC03mf03mfDiza63aFJPEuZzOFq3mXsykkhYwMrN2iirOGcFOllNWAXpu/6McMLmUaJ/K/8u+0dWs44QTo1g06doQjj4SUlDI3Ka0ROtyHcna2cxOjVauctpyxY8MnlkC9PKVD3ZW03fMNx2z7gm58RkcWlNqLrISjj2bUD/15nitYE3KTzKrSs8yUzpKGqVJK+7CuXx927Cj+5t+MVVyeOoObDnmZ+rkl7y5Xlp2SxmJtS17N1rQ8pxUdLm4Fhx3mfOLXrg2UnbwyMooTQ5lnJH12wq+/wsqV5Ez7kW+m/0jLPUtpzyIO5M99innrQYdSe8CFcPHFcMwxZLaQcic1U7VY0jBVSlkfwhD+G/0b41fxv1tncdbuN/kb/6M6uyr8+n/JAazSpmykIRtowCbqs41a5JNOPunsJhWAaqlwYZ9CPn4vn11b8qnJduqxmQa+LZuwhoPYUOE4ihAW0JG36M2bnMu25q3JzZPA+mhePjOJJVJJI+YN2/v6sIbwqqu8DdDhbltak216dtJ/9FFu0kW0LfWugvH4+JnD9Gmu1gt4WeuzocRA7ooeJ1O1YA3hxpRU1jftyy4rvrRUhy105Qu6+9oNOrKARqyPTdBBtlCHhXTgG47lc7rxGd2pntEYKH9bijHh2OUpY8Ioq6Eayh5J3Zi1tOVbjmQZrfiRdtWX0aggj6as3q9LW6EKSWINTVhFc37iCH6kFT/Siu9pzS8cSvBtboIvwdllJ7M/IpU0yu4qYkyCCTda2l8+dWpZczYJa2nCWpowmzNITYU6tWBTAQhFNGIdjVhHAzbSgI20rLeJ807P5z+v5VNt93aSg6Y6KSIp0Naxgxpspp5vqwas5yDW0ITCMP96IlCvnvN88+bwPa7K0xvLGC9Z0jCVSvPm4c8mmjcv/oAdNcqpI+LuCeVfrl8ftm6FTZucciWJ32nM7ziXidLTIWsCHNsflmYX7y8cf4+qvU0wWJ7LTP37W5IwsefZ3FMi0kxE5onIUhH5XkSGhakjIjJBRJaLyLcicqxX8ZiqwX+XwGDp6QTmV/LfklbVOfPw3xgqI8NZVoVatWBXKVejMjLcl4T8+5s2rfTXDb4JFTivV1p8xsS9SLSmh3sAjYFjfc9rAz8BR4fUOQt4DxDgeGD+3vZrvafM3uxv7yEppWNVuJ5KFXld691kYoFE6z0lIm8BE1V1TlDZv4GPVHW6b3kZcLKqri1tP9YQbry2L6O+jUkUCdUQLiKZQAdgfsiqQ4Bfg5ZX+8pcSUNEBgODfYsFIhLmpsZxpwGwMdZBlIPFWfKl6kHzDJCgy7dalJe3Kk9k4+a9bUz8H89EiBEszkg7MhI78TxpiEgt4DXgRlX9K3R1mE1KnPqoahaQ5dtfTiSypdcszsiyOCMnEWIEizPSRCQil2g8vQmTiKTiJIxsVX09TJXVQLOg5abAGi9jMsYYU3Fe9p4SYAqwVFUfK6XaLOByXy+q44EtZbVnGGOMiS0vL091By4DvhMR/00A7gCaA6jqZOA/OD2olgP5wFXl2G9W5EP1hMUZWRZn5CRCjGBxRlpE4ky4aUSMMcbEjqdtGsYYYyoXSxrGGGPKLS6Thohc4Jt6pEhESu3KJiJniMgy3zQkI4LKW4jIfBH5WUReFpFqHsVZT0Tm+F5njoiUuOm0iJwiIouCHjtF5FzfuudFZGXQuvaxitNXrzAolllB5fF0PNuLyBe+98e3InJR0DrPjmdp77Wg9dV9x2a571hlBq0b6StfJiL/iFRMFYzzZhH5wXfsPhSRjKB1Yf/+MYrzShHZEBTPwKB1V/jeIz+LyBUxjvPxoBh/EpE/g9ZF5XiKyLMisl5KGb/m62gUdrqmCh3LSAwrj/QDOApnIMpHQKdS6iQDK4BDgWrAYnzTlACvAP18zycDQz2K8yFghO/5CODBvdSvB2wG0n3LzwN9o3A8yxUnsK2U8rg5nsARQEvf8yY4A0Hrenk8y3qvBdW5Bpjse94PeNn3/Ghf/epAC99+kj06fuWJ85Sg999Qf5xl/f1jFOeVODNIhPsf+sX380Df8wNjFWdI/euBZ2NwPE8EjgWWlLI+7HRNFT2WcXmmoapLVXXZXqp1AZar6i+quguYAfQWEQFOBWb66r0AnOtRqL19+y/v6/QF3lPVMuY79cS+xhkQb8dTVX9S1Z99z9cA64GGHsXjF/a9FlInOPaZQA/fsesNzFDVAlVdidNTsEus4lTVeUHvvy9xxkZFW3mOZ2n+AcxR1c2q+gcwBzgjTuK8GJjuUSylUtVPcL6MlqY38KI6vgTqikhjKngs4zJplFNpU5DUB/5U1T0h5V5opL5xJb6fB+2lfj9KvqnG+k4ZHxeR6l4ESfnjTBORHBH50n8JjTg+niLSBecb4IqgYi+OZ2nvtbB1fMdqC86xK8+2kbKvr3U1zjdQv3B/fy+UN84+vr/lTBHxDwKOy+Ppu8zXApgbVByt47k3pf0eFTqWMbufhoh8ABwcZtUoVX2rPLsIU6ZllFdIWXHu434aA8cAs4OKRwK/43zwZQG3A2NiGGdzVV0jIocCc0XkOyB06heIn+M5FbhCVYt8xRE7nqEvF6Ys9BhE5f24F+V+LRG5FOgEnBRUXOLvr6orwm0fhTjfBqaraoGIDME5izu1nNtGyr68Vj9gpqoWBpVF63juTUTfmzFLGqp62n7uorQpSDbinH6l+L7x7dfUJGXFKSLrRKSxqq71fYiVdZPpC4E3VHV30L79o98LROQ5YHgs4/Rd7kFVfxGRj3AmmXyNODueIlIHeBe403e67d93xI5niPJMd+Ovs1pEUoADcC4ZRHOqnHK9loichpOkT1LVAn95KX9/Lz7k9hqnqm4KWnwaeDBo25NDtv0o4hEWv1Z5/3b9gGuDC6J4PPemtN+jQscykS9PfQ20FKdnTzWcP9osdVp45uG0HwBcAZTnzKUiZvn2X57XKXG90/fB6G83OBfwavbevcYpIgf6L+eISAOcEf0/xNvx9P2t38C5RvtqyDqvjmfY91oZsfcF5vqO3Sygnzi9q1oALYGvIhTXPscpIh2AfwO9VHV9UHnYv38M42wctNgLWOp7Phs43RfvgcDpuM/eoxqnL9YjcRqSvwgqi+bx3JvSpmuq2LGMRuv+vj6A83CyYAGwDpjtK28C/Ceo3lk4N3dagXNZy19+KM4/5nLgVaC6R3HWBz4Efvb9rOcr7wQ8E1QvE/gNSArZfi7wHc6H2zSgVqziBLr5Ylns+3l1PB5P4FJgN7Ao6NHe6+MZ7r2Gc+mrl+95mu/YLPcdq0ODth3l224ZcKbH/zt7i/MD3/+U/9jN2tvfP0ZxjgO+98UzD2gVtO0A33FeDlwVyzh9y6OBB0K2i9rxxPkyutb3f7Eap61qCDDEt16ASb7f4TuCeqRW5FjaNCLGGGPKLZEvTxljjIkySxrGGGPKzZKGMcaYcrOkYYwxptwsaRhjjCk3SxrGGGPKzZKGMcaYcrOkYcx+EpHOvon10kSkpjj3+mgT67iM8YIN7jMmAkTkfpxR4TWA1ao6LsYhGeMJSxrGRIBvbqKvgZ1AN3XPdmpMpWGXp4yJjHpALaA2zhmHMZWSnWkYEwHi3AN6Bs6NeBqr6nUxDskYT8TsfhrGVBYicjmwR1VfEpFk4HMROVVV5+5tW2MSjZ1pGGOMKTdr0zDGGFNuljSMMcaUmyUNY4wx5WZJwxhjTLlZ0jDGGFNuljSMMcaUmyUNY4wx5fb/1KfAEmTtp3wAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[2.9645]], requires_grad=True) tensor([[2.1146]], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "plt.plot(x.numpy(), y_pred.detach().numpy(),'r-',label='predict',linewidth=4)#predict\n",
    "plt.scatter(x.numpy(), y.numpy(),color='blue',marker='o',label='true') # true data\n",
    "plt.xlim(-1,1)\n",
    "plt.ylim(2,6)  \n",
    "plt.legend()\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.show()\n",
    "        \n",
    "print(w, b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.8 使用优化器（optimizer）和自动微分（autograd）实现机器学习\n",
    "使用PyTorch内置的损失函数，优化器和自动微分机制。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "torch.manual_seed(100) \n",
    "dtype = torch.float\n",
    "#生成x坐标数据，x为tenor，形状为100x1\n",
    "x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) \n",
    "#生成y坐标数据，y为tenor，形状为100x1，另加上一些噪音\n",
    "y = 3*x.pow(2) +2+ 0.2*torch.rand(x.size())                 \n",
    "\n",
    "# 画图，把tensor数据转换为numpy数据\n",
    "plt.scatter(x.numpy(), y.numpy())\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 随机初始化参数，参数w，b为需要学习的，故需requires_grad=True\n",
    "w = torch.randn(1,1, dtype=dtype,requires_grad=True)\n",
    "b = torch.zeros(1,1, dtype=dtype, requires_grad=True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义损失函数及优化器\n",
    "loss_func = nn.MSELoss()\n",
    "optimizer = torch.optim.SGD([w,b],lr = 0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ii in range(10000):\n",
    "    # forward：计算loss\n",
    "    y_pred = x.pow(2).mm(w) + b\n",
    "    loss=loss_func(y_pred,y)\n",
    "    \n",
    "    # backward：自动计算梯度\n",
    "    loss.backward()\n",
    "    \n",
    "    # 更新参数\n",
    "    optimizer.step()    \n",
    "    # 因通过autigrad计算的梯度，会累加到grad中，故每次循环需把梯度清零\n",
    "    optimizer.zero_grad()       \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[2.6369]], requires_grad=True) tensor([[2.2360]], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "plt.plot(x.numpy(), y_pred.detach().numpy(),'r-',label='predict',linewidth=4)#predict\n",
    "plt.scatter(x.numpy(), y.numpy(),color='blue',marker='o',label='true') # true data\n",
    "plt.xlim(-1,1)\n",
    "plt.ylim(2,6)  \n",
    "plt.legend()\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.show()\n",
    "        \n",
    "print(w, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.9 把数据集转换带批量的迭代器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "from torch import nn\n",
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "torch.manual_seed(100) \n",
    "dtype = torch.float\n",
    "#生成x坐标数据，x为tenor，形状为100x1\n",
    "x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) \n",
    "#生成y坐标数据，y为tenor，形状为100x1，另加上一些噪音\n",
    "y = 3*x.pow(2) +2+ 0.2*torch.rand(x.size())                 \n",
    "\n",
    "# 画图，把tensor数据转换为numpy数据\n",
    "plt.scatter(x.numpy(), y.numpy())\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 随机初始化参数，参数w，b为需要学习的，故需requires_grad=True\n",
    "w = torch.randn(1,1, dtype=dtype,requires_grad=True)\n",
    "b = torch.zeros(1,1, dtype=dtype, requires_grad=True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义损失函数及优化器\n",
    "loss_func = nn.MSELoss()\n",
    "optimizer = torch.optim.SGD([w,b],lr = 0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 构建数据管道迭代器\n",
    "def data_iter(features, labels, batch_size=4):\n",
    "    num_examples = len(features)\n",
    "    indices = list(range(num_examples))\n",
    "    np.random.shuffle(indices)  #样本的读取顺序是随机的\n",
    "    for i in range(0, num_examples, batch_size):\n",
    "        indexs = torch.LongTensor(indices[i: min(i + batch_size, num_examples)])\n",
    "        yield  features.index_select(0, indexs), labels.index_select(0, indexs)   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ii in range(1000):\n",
    "    for features, labels in data_iter(x,y,10):\n",
    "        # forward：计算loss\n",
    "        y_pred = features.pow(2).mm(w) + b\n",
    "        loss=loss_func(y_pred,labels)\n",
    "    \n",
    "        # backward：自动计算梯度\n",
    "        loss.backward()\n",
    "    \n",
    "        # 更新参数\n",
    "        optimizer.step()    \n",
    "        # 因通过autigrad计算的梯度，会累加到grad中，故每次循环需把梯度清零\n",
    "        optimizer.zero_grad()   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[2.6370]], requires_grad=True) tensor([[2.2360]], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "y_p=x.pow(2).mm(w).detach().numpy() + b.detach().numpy()\n",
    "plt.plot(x.numpy(), y_p,'r-',label='predict',linewidth=4)#predict\n",
    "plt.scatter(x.numpy(), y.numpy(),color='blue',marker='o',label='true') # true data\n",
    "plt.xlim(-1,1)\n",
    "plt.ylim(2,6)  \n",
    "plt.legend()\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.show()\n",
    "        \n",
    "print(w, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.10 使用TensorFlow架构实现机器学习"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "#生成训练数据\n",
    "np.random.seed(100) \n",
    "x = np.linspace(-1, 1, 100).reshape(100,1) \n",
    "y = 3*np.power(x, 2) +2+ 0.2*np.random.rand(x.size).reshape(100,1)  \n",
    "\n",
    "# 创建权重变量w和b，并用随机值初始化.\n",
    "# TensorFlow 的变量在整个计算图保存其值.\n",
    "w = tf.Variable(tf.random.uniform([1], 0, 1.0))\n",
    "b = tf.Variable(tf.zeros([1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义模型\n",
    "class CustNet:     \n",
    "    #正向传播\n",
    "    def __call__(self,x): \n",
    "        return np.power(x,2)*w + b\n",
    "\n",
    "    # 损失函数\n",
    "    def loss_func(self,y_true,y_pred):  \n",
    "        return tf.reduce_mean((y_true - y_pred)**2/2)\n",
    "    \n",
    "model=CustNet()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 训练模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs=14000\n",
    "\n",
    "for epoch in tf.range(1,epochs):\n",
    "        with tf.GradientTape() as tape:\n",
    "            predictions = model(x)\n",
    "            loss = model.loss_func(y, predictions)\n",
    "        # 反向传播求梯度\n",
    "        dw,db = tape.gradient(loss,[w,b])\n",
    "        # 梯度下降法更新参数\n",
    "        w.assign(w - 0.001*dw)\n",
    "        b.assign(b - 0.001*db)                 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'y')"
      ]
     },
     "execution_count": 59,
     "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",
    "plt.figure() \n",
    "plt.scatter(x,y,color='blue',marker='o',label='true')\n",
    "plt.plot (x, b + w*x**2,'r-',label='predict',linewidth=4)\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}