all_learn_process/codes/chapter2/快速入门.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PyTorch第一步\n",
    "\n",
    "PyTorch的简洁设计使得它入门很简单，在深入介绍PyTorch之前，本节将先介绍一些PyTorch的基础知识，使得读者能够对PyTorch有一个大致的了解，并能够用PyTorch搭建一个简单的神经网络。部分内容读者可能暂时不太理解，可先不予以深究，本书的第3章和第4章将会对此进行深入讲解。\n",
    "\n",
    "本节内容参考了PyTorch官方教程[^1]并做了相应的增删修改，使得内容更贴合新版本的PyTorch接口，同时也更适合新手快速入门。另外本书需要读者先掌握基础的Numpy使用，其他相关知识推荐读者参考CS231n的教程[^2]。\n",
    "\n",
    "[^1]: http://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html\n",
    "[^2]: http://cs231n.github.io/python-numpy-tutorial/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor\n",
    "\n",
    "Tensor是PyTorch中重要的数据结构，可认为是一个高维数组。它可以是一个数（标量）、一维数组（向量）、二维数组（矩阵）以及更高维的数组。Tensor和Numpy的ndarrays类似，但Tensor可以使用GPU进行加速。Tensor的使用和Numpy及Matlab的接口十分相似，下面通过几个例子来看看Tensor的基本使用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:15:57.552079Z",
     "start_time": "2020-12-07T03:15:57.249074Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.2.0'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch as t\n",
    "t.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:16:44.805184Z",
     "start_time": "2020-12-07T03:16:44.800169Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 2.],\n",
       "        [3., 4.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 构建 5x3 矩阵，只是分配了空间，未初始化\n",
    "x = t.Tensor(5, 3)\n",
    "x = t.Tensor([[1,2],[3,4]])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:16:46.022178Z",
     "start_time": "2020-12-07T03:16:46.017163Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.6566, 0.7417, 0.8705],\n",
       "        [0.9707, 0.5335, 0.1012],\n",
       "        [0.5994, 0.0968, 0.6672],\n",
       "        [0.9437, 0.7136, 0.0346],\n",
       "        [0.9988, 0.2133, 0.7664]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用[0,1]均匀分布随机初始化二维数组\n",
    "x = t.rand(5, 3)  \n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:17:04.373127Z",
     "start_time": "2020-12-07T03:17:04.367142Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([5, 3])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(x.size()) # 查看x的形状\n",
    "x.size()[1], x.size(1) # 查看列的个数, 两种写法等价"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`torch.Size` 是tuple对象的子类，因此它支持tuple的所有操作，如x.size()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:17:47.365836Z",
     "start_time": "2020-12-07T03:17:47.360815Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1.1168, 1.5233, 1.7790],\n",
       "        [1.6361, 1.0682, 0.3924],\n",
       "        [0.8189, 0.1837, 1.3398],\n",
       "        [1.4295, 1.5837, 0.3095],\n",
       "        [1.3128, 1.0312, 1.2567]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = t.rand(5, 3)\n",
    "# 加法的第一种写法\n",
    "x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:17:54.070477Z",
     "start_time": "2020-12-07T03:17:54.065461Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1.1168, 1.5233, 1.7790],\n",
       "        [1.6361, 1.0682, 0.3924],\n",
       "        [0.8189, 0.1837, 1.3398],\n",
       "        [1.4295, 1.5837, 0.3095],\n",
       "        [1.3128, 1.0312, 1.2567]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 加法的第二种写法\n",
    "t.add(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:18:11.924195Z",
     "start_time": "2020-12-07T03:18:11.919178Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1.1168, 1.5233, 1.7790],\n",
       "        [1.6361, 1.0682, 0.3924],\n",
       "        [0.8189, 0.1837, 1.3398],\n",
       "        [1.4295, 1.5837, 0.3095],\n",
       "        [1.3128, 1.0312, 1.2567]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 加法的第三种写法：指定加法结果的输出目标为result\n",
    "result = t.Tensor(5, 3) # 预先分配空间\n",
    "t.add(x, y, out=result) # 输入到result\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:18:20.775745Z",
     "start_time": "2020-12-07T03:18:20.769699Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最初y\n",
      "tensor([[0.4602, 0.7816, 0.9084],\n",
      "        [0.6654, 0.5347, 0.2912],\n",
      "        [0.2196, 0.0869, 0.6726],\n",
      "        [0.4858, 0.8701, 0.2749],\n",
      "        [0.3140, 0.8179, 0.4904]])\n",
      "第一种加法，y的结果\n",
      "tensor([[0.4602, 0.7816, 0.9084],\n",
      "        [0.6654, 0.5347, 0.2912],\n",
      "        [0.2196, 0.0869, 0.6726],\n",
      "        [0.4858, 0.8701, 0.2749],\n",
      "        [0.3140, 0.8179, 0.4904]])\n",
      "第二种加法，y的结果\n",
      "tensor([[1.1168, 1.5233, 1.7790],\n",
      "        [1.6361, 1.0682, 0.3924],\n",
      "        [0.8189, 0.1837, 1.3398],\n",
      "        [1.4295, 1.5837, 0.3095],\n",
      "        [1.3128, 1.0312, 1.2567]])\n"
     ]
    }
   ],
   "source": [
    "print('最初y')\n",
    "print(y)\n",
    "\n",
    "print('第一种加法，y的结果')\n",
    "y.add(x) # 普通加法，不改变y的内容\n",
    "print(y)\n",
    "\n",
    "print('第二种加法，y的结果')\n",
    "y.add_(x) # inplace 加法，y变了\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意，函数名后面带下划线**`_`** 的函数会修改Tensor本身。例如，`x.add_(y)`和`x.t_()`会改变 `x`，但`x.add(y)`和`x.t()`返回一个新的Tensor， 而`x`不变。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:18:50.483811Z",
     "start_time": "2020-12-07T03:18:50.478823Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.7417, 0.5335, 0.0968, 0.7136, 0.2133])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tensor的选取操作与Numpy类似\n",
    "x[:, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensor还支持很多操作，包括数学运算、线性代数、选择、切片等等，其接口设计与Numpy极为相似。更详细的使用方法，会在下一章系统讲解。\n",
    "\n",
    "Tensor和Numpy的数组之间的互操作非常容易且快速。对于Tensor不支持的操作，可以先转为Numpy数组处理，之后再转回Tensor。c\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:20:06.676248Z",
     "start_time": "2020-12-07T03:20:06.671262Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = t.ones(5) # 新建一个全1的Tensor\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:20:13.350416Z",
     "start_time": "2020-12-07T03:20:13.346397Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1.], dtype=float32)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a.numpy() # Tensor -> Numpy\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:20:27.302200Z",
     "start_time": "2020-12-07T03:20:27.297214Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 1. 1. 1. 1.]\n",
      "tensor([1., 1., 1., 1., 1.], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "a = np.ones(5)\n",
    "b = t.from_numpy(a) # Numpy->Tensor\n",
    "print(a)\n",
    "print(b) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensor和numpy对象共享内存，所以他们之间的转换很快，而且几乎不会消耗什么资源。但这也意味着，如果其中一个变了，另外一个也会随之改变。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:20:55.493697Z",
     "start_time": "2020-12-07T03:20:55.489679Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2. 2. 2. 2. 2.]\n",
      "tensor([2., 2., 2., 2., 2.], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "b.add_(1) # 以`_`结尾的函数会修改自身\n",
    "print(a)\n",
    "print(b) # Tensor和Numpy共享内存"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果你想获取某一个元素的值，可以使用`scalar.item`。 直接`tensor[idx]`得到的还是一个tensor: 一个0-dim 的tensor，一般称为scalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:21:21.315457Z",
     "start_time": "2020-12-07T03:21:21.311468Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(2., dtype=torch.float64)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scalar = b[0]\n",
    "scalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:21:28.805655Z",
     "start_time": "2020-12-07T03:21:28.800669Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scalar.size() #0-dim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:21:35.731020Z",
     "start_time": "2020-12-07T03:21:35.727032Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scalar.item() # 使用scalar.item()能从中取出python对象的数值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:21:43.028258Z",
     "start_time": "2020-12-07T03:21:43.023254Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([2]), tensor(2., dtype=torch.float64))"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor = t.tensor([2]) # 注意和scalar的区别\n",
    "tensor,scalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:22:06.694382Z",
     "start_time": "2020-12-07T03:22:06.689364Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([1]), torch.Size([]))"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor.size(),scalar.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:22:14.899252Z",
     "start_time": "2020-12-07T03:22:14.895234Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2.0)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 只有一个元素的tensor也可以调用`tensor.item()`\n",
    "tensor.item(), scalar.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外在pytorch中还有一个和`np.array` 很类似的接口: `torch.tensor`, 二者的使用十分类似。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:22:32.085122Z",
     "start_time": "2020-12-07T03:22:32.082096Z"
    }
   },
   "outputs": [],
   "source": [
    "tensor = t.tensor([3,4]) # 新建一个包含 3，4 两个元素的tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:24:35.575678Z",
     "start_time": "2020-12-07T03:24:35.570691Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([3, 4]), tensor([1111,    4]))"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "old_tensor = tensor\n",
    "new_tensor = old_tensor.clone()\n",
    "new_tensor[0] = 1111\n",
    "old_tensor, new_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要注意的是，`t.tensor()`或者`tensor.clone()`总是会进行数据拷贝，新tensor和原来的数据不再共享内存。所以如果你想共享内存的话，建议使用`torch.from_numpy()`或者`tensor.detach()`来新建一个tensor, 二者共享内存。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:25:30.276248Z",
     "start_time": "2020-12-07T03:25:30.270264Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([1111,    4]), tensor([1111,    4]))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_tensor = old_tensor.detach()\n",
    "new_tensor[0] = 1111\n",
    "old_tensor, new_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensor可通过`.cuda` 方法转为GPU的Tensor，从而享受GPU带来的加速运算。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:25:53.974401Z",
     "start_time": "2020-12-07T03:25:53.967420Z"
    }
   },
   "outputs": [],
   "source": [
    "# 在不支持CUDA的机器下，下一步还是在CPU上运行\n",
    "device = t.device(\"cuda:0\" if t.cuda.is_available() else \"cpu\")\n",
    "x = x.to(device)\n",
    "y = y.to(x.device)\n",
    "z = x+y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，还可以使用`tensor.cuda()` 的方式将tensor拷贝到gpu上，但是这种方式不太推荐。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:26:08.694782Z",
     "start_time": "2020-12-07T03:26:08.689795Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此处可能发现GPU运算的速度并未提升太多，这是因为x和y太小且运算也较为简单，而且将数据从内存转移到显存还需要花费额外的开销。GPU的优势需在大规模数据和复杂运算下才能体现出来。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## autograd: 自动微分\n",
    "深度学习的算法本质上是通过反向传播求导数，而PyTorch的**`autograd`**模块则实现了此功能。在Tensor上的所有操作，autograd都能为它们自动提供微分，避免了手动计算导数的复杂过程。\n",
    " \n",
    "~~`autograd.Variable`是Autograd中的核心类，它简单封装了Tensor，并支持几乎所有Tensor有的操作。Tensor在被封装为Variable之后，可以调用它的`.backward`实现反向传播，自动计算所有梯度~~ ~~Variable的数据结构如图2-6所示。~~\n",
    "\n",
    "\n",
    "![图2-6:Variable的数据结构](./imgs/autograd_Variable.svg)\n",
    "\n",
    "  *从0.4起, Variable 正式合并入Tensor, Variable 本来实现的自动微分功能，Tensor就能支持。读者还是可以使用Variable(tensor), 但是这个操作其实什么都没做。建议读者以后直接使用tensor*. \n",
    "  \n",
    "  要想使得Tensor使用autograd功能，只需要设置`tensor.requries_grad=True`. \n",
    "\n",
    "\n",
    "~~Variable主要包含三个属性。~~\n",
    "~~- `data`：保存Variable所包含的Tensor~~\n",
    "~~- `grad`：保存`data`对应的梯度，`grad`也是个Variable，而不是Tensor，它和`data`的形状一样。~~\n",
    "~~- `grad_fn`：指向一个`Function`对象，这个`Function`用来反向传播计算输入的梯度，具体细节会在下一章讲解。~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:29:51.044507Z",
     "start_time": "2020-12-07T03:29:51.039489Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 1.],\n",
       "        [1., 1.]], requires_grad=True)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 为tensor设置 requires_grad 标识，代表着需要求导数\n",
    "# pytorch 会自动调用autograd 记录操作\n",
    "x = t.ones(2, 2, requires_grad=True)\n",
    "\n",
    "# 上一步等价于\n",
    "# x = t.ones(2,2)\n",
    "# x.requires_grad = True\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:29:59.385141Z",
     "start_time": "2020-12-07T03:29:59.377162Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(4., grad_fn=<SumBackward0>)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = x.sum()\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:30:06.917579Z",
     "start_time": "2020-12-07T03:30:06.914558Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<SumBackward0 at 0x289ac2c1208>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.grad_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:30:13.446377Z",
     "start_time": "2020-12-07T03:30:13.442386Z"
    }
   },
   "outputs": [],
   "source": [
    "y.backward() # 反向传播,计算梯度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:30:20.342490Z",
     "start_time": "2020-12-07T03:30:20.338500Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 1.],\n",
       "        [1., 1.]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# y = x.sum() = (x[0][0] + x[0][1] + x[1][0] + x[1][1])\n",
    "# 每个值的梯度都为1\n",
    "x.grad "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意：`grad`在反向传播过程中是累加的(accumulated)，这意味着每一次运行反向传播，梯度都会累加之前的梯度，所以反向传播之前需把梯度清零。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-07T03:30:54.373952Z",
     "start_time": "2020-12-07T03:30:54.368995Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[2., 2.],\n",
       "        [2., 2.]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.backward()\n",
    "x.grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T10:51:21.925132Z",
     "start_time": "2020-12-08T10:51:21.910172Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[3., 3.],\n",
       "        [3., 3.]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.backward()\n",
    "x.grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T10:51:28.511896Z",
     "start_time": "2020-12-08T10:51:28.502920Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0., 0.],\n",
       "        [0., 0.]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 以下划线结束的函数是inplace操作，会修改自身的值，就像add_\n",
    "x.grad.data.zero_()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T10:51:53.961721Z",
     "start_time": "2020-12-08T10:51:53.957731Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 1.],\n",
       "        [1., 1.]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.backward()\n",
    "x.grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  神经网络\n",
    "\n",
    "Autograd实现了反向传播功能，但是直接用来写深度学习的代码在很多情况下还是稍显复杂，torch.nn是专门为神经网络设计的模块化接口。nn构建于 Autograd之上，可用来定义和运行神经网络。nn.Module是nn中最重要的类，可把它看成是一个网络的封装，包含网络各层定义以及forward方法，调用forward(input)方法，可返回前向传播的结果。下面就以最早的卷积神经网络：LeNet为例，来看看如何用`nn.Module`实现。LeNet的网络结构如图2-7所示。\n",
    "\n",
    "![图2-7:LeNet网络结构](imgs/nn_lenet.png)\n",
    "\n",
    "这是一个基础的前向传播(feed-forward)网络: 接收输入，经过层层传递运算，得到输出。\n",
    "\n",
    "### 定义网络\n",
    "\n",
    "定义网络时，需要继承`nn.Module`，并实现它的forward方法，把网络中具有可学习参数的层放在构造函数`__init__`中。如果某一层(如ReLU)不具有可学习的参数，则既可以放在构造函数中，也可以不放，但建议不放在其中，而在forward中使用`nn.functional`代替。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T10:54:08.783144Z",
     "start_time": "2020-12-08T10:54:08.756247Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
      "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
      "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        # nn.Module子类的函数必须在构造函数中执行父类的构造函数\n",
    "        # 下式等价于nn.Module.__init__(self)\n",
    "        super(Net, self).__init__()\n",
    "        \n",
    "        # 卷积层 '1'表示输入图片为单通道, '6'表示输出通道数，'5'表示卷积核为5*5\n",
    "        self.conv1 = nn.Conv2d(1, 6, 5) \n",
    "        # 卷积层\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5) \n",
    "        # 仿射层/全连接层，y = Wx + b\n",
    "        self.fc1   = nn.Linear(16*5*5, 120) \n",
    "        self.fc2   = nn.Linear(120, 84)\n",
    "        self.fc3   = nn.Linear(84, 10)\n",
    "\n",
    "    def forward(self, x): \n",
    "        # 卷积 -> 激活 -> 池化 \n",
    "        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n",
    "        x = F.max_pool2d(F.relu(self.conv2(x)), 2) \n",
    "        # reshape，‘-1’表示自适应\n",
    "        x = x.view(x.size()[0], -1) \n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)        \n",
    "        return x\n",
    "\n",
    "net = Net()\n",
    "print(net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:02:17.337869Z",
     "start_time": "2020-12-08T11:02:17.328891Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
      "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
      "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        #nn.Module子类的函数必须在构造函数中执行父类的构造函数\n",
    "        #下式等价于nn.Module.__init__()\n",
    "        super(Net,self).__init__()\n",
    "        \n",
    "        #卷积层 ‘1’ 表示输入图片为单通道，‘6’表示输出通道数，‘5’表示卷积核为5*5\n",
    "        self.conv1 = nn.Conv2d(1,6,5)\n",
    "        #卷积层\n",
    "        self.conv2 = nn.Conv2d(6,16,5)\n",
    "        #仿设层、全连接层，y = Wx + b\n",
    "        self.fc1 = nn.Linear(16*5*5,120)\n",
    "        self.fc2 = nn.Linear(120,84)\n",
    "        self.fc3 = nn.Linear(84,10)\n",
    "        \n",
    "    def forward(self,x):\n",
    "        #卷积 -> 激活 -> 池化\n",
    "        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2))\n",
    "        x = F.max_pool2d(F.relu(self.conv2(x)),2)\n",
    "        #reshape,'-1' 表述自适应\n",
    "        x = x.view(x.size()[0],-1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "net = Net()\n",
    "print(net)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:17:49.966120Z",
     "start_time": "2020-12-08T11:17:49.958110Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
      "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
      "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net,self).__init__()\n",
    "        \n",
    "        #卷积层，‘1’表示输入图片为单通道；‘6’表述输出通道；‘5’表示卷积核5*5\n",
    "        self.conv1 = nn.Conv2d(1,6,5)\n",
    "        self.conv2 = nn.Conv2d(6,16,5)\n",
    "        self.fc1 = nn.Linear(16*5*5,120)\n",
    "        self.fc2 = nn.Linear(120,84)\n",
    "        self.fc3 = nn.Linear(84,10)\n",
    "\n",
    "\n",
    "    def forward(self,x):\n",
    "    # 卷积 -> 激活 -> 池化\n",
    "        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2))\n",
    "        x = F.max_pool2d(F.relu(self.conv2(x)),2)\n",
    "        x = x.view(x.size()[0],-1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "net = Net()\n",
    "print(net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:20:47.551946Z",
     "start_time": "2020-12-08T11:20:47.543967Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
      "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
      "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net,self).__init__()\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(1,6,5)\n",
    "        self.conv2 = nn.Conv2d(6,16,5)\n",
    "        self.fc1 = nn.Linear(16*5*5,120)\n",
    "        self.fc2 = nn.Linear(120,84)\n",
    "        self.fc3 = nn.Linear(84,10)\n",
    "\n",
    "    def forward(self,x):\n",
    "        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2))\n",
    "        x = F.max_pool2d(F.relu(self.conv2(x)),2)\n",
    "        x = x.view(x.size()[0],-1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "net = Net()\n",
    "print(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "只要在nn.Module的子类中定义了forward函数，backward函数就会自动被实现(利用`autograd`)。在`forward` 函数中可使用任何tensor支持的函数，还可以使用if、for循环、print、log等Python语法，写法和标准的Python写法一致。\n",
    "\n",
    "网络的可学习参数通过`net.parameters()`返回，`net.named_parameters`可同时返回可学习的参数及名称。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:21:47.543057Z",
     "start_time": "2020-12-08T11:21:47.539038Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "params = list(net.parameters())\n",
    "print(len(params))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:23:23.127606Z",
     "start_time": "2020-12-08T11:23:23.122585Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conv1.weight : torch.Size([6, 1, 5, 5])\n",
      "conv1.bias : torch.Size([6])\n",
      "conv2.weight : torch.Size([16, 6, 5, 5])\n",
      "conv2.bias : torch.Size([16])\n",
      "fc1.weight : torch.Size([120, 400])\n",
      "fc1.bias : torch.Size([120])\n",
      "fc2.weight : torch.Size([84, 120])\n",
      "fc2.bias : torch.Size([84])\n",
      "fc3.weight : torch.Size([10, 84])\n",
      "fc3.bias : torch.Size([10])\n"
     ]
    }
   ],
   "source": [
    "for name,parameters in net.named_parameters():\n",
    "    print(name,':',parameters.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "forward函数的输入和输出都是Tensor。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:24:01.328529Z",
     "start_time": "2020-12-08T11:24:01.300605Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 10])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input = t.randn(1, 1, 32, 32)\n",
    "out = net(input)\n",
    "out.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:24:05.640160Z",
     "start_time": "2020-12-08T11:24:05.635149Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.0635,  0.0786,  0.0918, -0.0762, -0.1358, -0.0051,  0.1197,  0.0861,\n",
       "          0.0255, -0.0699]], grad_fn=<AddmmBackward>)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:24:21.022152Z",
     "start_time": "2020-12-08T11:24:21.010183Z"
    }
   },
   "outputs": [],
   "source": [
    "net.zero_grad() # 所有参数的梯度清零\n",
    "out.backward(t.ones(1,10)) # 反向传播"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要注意的是，torch.nn只支持mini-batches，不支持一次只输入一个样本，即一次必须是一个batch。但如果只想输入一个样本，则用 `input.unsqueeze(0)`将batch_size设为１。例如 `nn.Conv2d` 输入必须是4维的，形如$nSamples \\times nChannels \\times Height \\times Width$。可将nSample设为1，即$1 \\times nChannels \\times Height \\times Width$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 损失函数\n",
    "\n",
    "nn实现了神经网络中大多数的损失函数，例如nn.MSELoss用来计算均方误差，nn.CrossEntropyLoss用来计算交叉熵损失。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:25:40.211550Z",
     "start_time": "2020-12-08T11:25:40.196591Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(28.4349, grad_fn=<MseLossBackward>)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output = net(input)\n",
    "target = t.arange(0,10).view(1,10).float() \n",
    "criterion = nn.MSELoss()\n",
    "loss = criterion(output, target)\n",
    "loss # loss是个scalar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果对loss进行反向传播溯源(使用`gradfn`属性)，可看到它的计算图如下：\n",
    "\n",
    "```\n",
    "input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d  \n",
    "      -> view -> linear -> relu -> linear -> relu -> linear \n",
    "      -> MSELoss\n",
    "      -> loss\n",
    "```\n",
    "\n",
    "当调用`loss.backward()`时，该图会动态生成并自动微分，也即会自动计算图中参数(Parameter)的导数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:26:42.173368Z",
     "start_time": "2020-12-08T11:26:42.165390Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "反向传播之前 conv1.bias的梯度\n",
      "tensor([0., 0., 0., 0., 0., 0.])\n",
      "反向传播之后 conv1.bias的梯度\n",
      "tensor([-0.0311,  0.0454,  0.0455,  0.1411, -0.0455, -0.1129])\n"
     ]
    }
   ],
   "source": [
    "# 运行.backward，观察调用之前和调用之后的grad\n",
    "net.zero_grad() # 把net中所有可学习参数的梯度清零\n",
    "print('反向传播之前 conv1.bias的梯度')\n",
    "print(net.conv1.bias.grad)\n",
    "loss.backward()\n",
    "print('反向传播之后 conv1.bias的梯度')\n",
    "print(net.conv1.bias.grad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 优化器\n",
    "在反向传播计算完所有参数的梯度后，还需要使用优化方法来更新网络的权重和参数，例如随机梯度下降法(SGD)的更新策略如下：\n",
    "```\n",
    "weight = weight - learning_rate * gradient\n",
    "```\n",
    "\n",
    "手动实现如下：\n",
    "\n",
    "```python\n",
    "learning_rate = 0.01\n",
    "for f in net.parameters():\n",
    "    f.data.sub_(f.grad.data * learning_rate)# inplace 减法\n",
    "```\n",
    "\n",
    "`torch.optim`中实现了深度学习中绝大多数的优化方法，例如RMSProp、Adam、SGD等，更便于使用，因此大多数时候并不需要手动写上述代码。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:27:52.797665Z",
     "start_time": "2020-12-08T11:27:52.789688Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "#新建一个优化器，指定要调整的参数和学习率\n",
    "optimizer = optim.SGD(net.parameters(), lr = 0.01)\n",
    "\n",
    "# 在训练过程中\n",
    "# 先梯度清零(与net.zero_grad()效果一样)\n",
    "optimizer.zero_grad() \n",
    "\n",
    "# 计算损失\n",
    "output = net(input)\n",
    "loss = criterion(output, target)\n",
    "\n",
    "#反向传播\n",
    "loss.backward()\n",
    "\n",
    "#更新参数\n",
    "optimizer.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "###  数据加载与预处理\n",
    "\n",
    "在深度学习中数据加载及预处理是非常复杂繁琐的，但PyTorch提供了一些可极大简化和加快数据处理流程的工具。同时，对于常用的数据集，PyTorch也提供了封装好的接口供用户快速调用，这些数据集主要保存在torchvison中。\n",
    "\n",
    "`torchvision`实现了常用的图像数据加载功能，例如Imagenet、CIFAR10、MNIST等，以及常用的数据转换操作，这极大地方便了数据加载，并且代码具有可重用性。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 小试牛刀：CIFAR-10分类\n",
    "\n",
    "下面我们来尝试实现对CIFAR-10数据集的分类，步骤如下: \n",
    "\n",
    "1. 使用torchvision加载并预处理CIFAR-10数据集\n",
    "2. 定义网络\n",
    "3. 定义损失函数和优化器\n",
    "4. 训练网络并更新网络参数\n",
    "5. 测试网络\n",
    "\n",
    "###   CIFAR-10数据加载及预处理\n",
    "\n",
    "CIFAR-10[^3]是一个常用的彩色图片数据集，它有10个类别: 'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'。每张图片都是$3\\times32\\times32$，也即3-通道彩色图片，分辨率为$32\\times32$。\n",
    "\n",
    "[^3]: http://www.cs.toronto.edu/~kriz/cifar.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:29:25.827564Z",
     "start_time": "2020-12-08T11:29:25.683062Z"
    }
   },
   "outputs": [],
   "source": [
    "import torchvision as tv\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision.transforms import ToPILImage\n",
    "show = ToPILImage() # 可以把Tensor转成Image，方便可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:32:34.971665Z",
     "start_time": "2020-12-08T11:31:44.647354Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./cha2_data/cifar-10-python.tar.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100.0%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./cha2_data/cifar-10-python.tar.gz to ./cha2_data/\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "# 第一次运行程序torchvision会自动下载CIFAR-10数据集，\n",
    "# 大约100M，需花费一定的时间，\n",
    "# 如果已经下载有CIFAR-10，可通过root参数指定\n",
    "\n",
    "# 定义对数据的预处理\n",
    "transform = transforms.Compose([\n",
    "        transforms.ToTensor(), # 转为Tensor\n",
    "        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), # 归一化\n",
    "                             ])\n",
    "\n",
    "# 训练集\n",
    "trainset = tv.datasets.CIFAR10(\n",
    "                    root='./cha2_data/', \n",
    "                    train=True, \n",
    "                    download=True,\n",
    "                    transform=transform)\n",
    "\n",
    "trainloader = t.utils.data.DataLoader(\n",
    "                    trainset, \n",
    "                    batch_size=4,\n",
    "                    shuffle=True, \n",
    "                    num_workers=2)\n",
    "\n",
    "# 测试集\n",
    "testset = tv.datasets.CIFAR10(\n",
    "                    './cha2_data/',\n",
    "                    train=False, \n",
    "                    download=True, \n",
    "                    transform=transform)\n",
    "\n",
    "testloader = t.utils.data.DataLoader(\n",
    "                    testset,\n",
    "                    batch_size=4, \n",
    "                    shuffle=False,\n",
    "                    num_workers=2)\n",
    "\n",
    "classes = ('plane', 'car', 'bird', 'cat',\n",
    "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataset对象是一个数据集，可以按下标访问，返回形如(data, label)的数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:33:04.511535Z",
     "start_time": "2020-12-08T11:33:04.484610Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ship\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=100x100 at 0x289AD4D4E48>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(data, label) = trainset[100]\n",
    "print(classes[label])\n",
    "\n",
    "# (data + 1) / 2是为了还原被归一化的数据\n",
    "show((data + 1) / 2).resize((100, 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataloader是一个可迭代的对象，它将dataset返回的每一条数据拼接成一个batch，并提供多线程加速优化和数据打乱等操作。当程序对dataset的所有数据遍历完一遍之后，相应的对Dataloader也完成了一次迭代。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:34:34.537893Z",
     "start_time": "2020-12-08T11:34:31.446062Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        cat        deer         dog         dog\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=400x100 at 0x289AD562F28>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataiter = iter(trainloader)\n",
    "images, labels = dataiter.next() # 返回4张图片及标签\n",
    "print(' '.join('%11s'%classes[labels[j]] for j in range(4)))\n",
    "show(tv.utils.make_grid((images+1)/2)).resize((400,100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:35:30.746744Z",
     "start_time": "2020-12-08T11:35:30.742721Z"
    }
   },
   "source": [
    "###  定义网络\n",
    "\n",
    "拷贝上面的LeNet网络，修改self.conv1第一个参数为3通道，因CIFAR-10是3通道彩图。\n",
    "\n",
    "The CIFAR-10 dataset consists of 60000 32x32 colour images in 10 classes, with 6000 images per class. There are 50000 training images and 10000 test images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:36:14.686170Z",
     "start_time": "2020-12-08T11:36:14.678163Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
      "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
      "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 6, 5) \n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)  \n",
    "        self.fc1   = nn.Linear(16*5*5, 120)  \n",
    "        self.fc2   = nn.Linear(120, 84)\n",
    "        self.fc3   = nn.Linear(84, 10)\n",
    "\n",
    "    def forward(self, x): \n",
    "        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) \n",
    "        x = F.max_pool2d(F.relu(self.conv2(x)), 2) \n",
    "        x = x.view(x.size()[0], -1) \n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)        \n",
    "        return x\n",
    "\n",
    "\n",
    "net = Net()\n",
    "print(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  定义损失函数和优化器(loss和optimizer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:36:34.454890Z",
     "start_time": "2020-12-08T11:36:34.450901Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch import optim\n",
    "criterion = nn.CrossEntropyLoss() # 交叉熵损失函数\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   训练网络\n",
    "\n",
    "所有网络的训练流程都是类似的，不断地执行如下流程：\n",
    "\n",
    "- 输入数据\n",
    "- 前向传播+反向传播\n",
    "- 更新参数\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:38:13.897738Z",
     "start_time": "2020-12-08T11:37:03.027225Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,  2000] loss: 2.185\n",
      "[1,  4000] loss: 1.857\n",
      "[1,  6000] loss: 1.659\n",
      "[1,  8000] loss: 1.582\n",
      "[1, 10000] loss: 1.508\n",
      "[1, 12000] loss: 1.467\n",
      "[2,  2000] loss: 1.415\n",
      "[2,  4000] loss: 1.365\n",
      "[2,  6000] loss: 1.322\n",
      "[2,  8000] loss: 1.314\n",
      "[2, 10000] loss: 1.319\n",
      "[2, 12000] loss: 1.279\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "t.set_num_threads(8)\n",
    "for epoch in range(2):  \n",
    "    \n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        \n",
    "        # 输入数据\n",
    "        inputs, labels = data\n",
    "        \n",
    "        # 梯度清零\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        # forward + backward \n",
    "        outputs = net(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()   \n",
    "        \n",
    "        # 更新参数 \n",
    "        optimizer.step()\n",
    "        \n",
    "        # 打印log信息\n",
    "        # loss 是一个scalar,需要使用loss.item()来获取数值，不能使用loss[0]\n",
    "        running_loss += loss.item()\n",
    "        if i % 2000 == 1999: # 每2000个batch打印一下训练状态\n",
    "            print('[%d, %5d] loss: %.3f' \\\n",
    "                  % (epoch+1, i+1, running_loss / 2000))\n",
    "            running_loss = 0.0\n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此处仅训练了2个epoch（遍历完一遍数据集称为一个epoch），来看看网络有没有效果。将测试图片输入到网络中，计算它的label，然后与实际的label进行比较。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:38:40.235622Z",
     "start_time": "2020-12-08T11:38:38.822186Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "实际的label:\n",
      "       cat     ship     ship    plane\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=400x100 at 0x289AD5D4F28>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataiter = iter(testloader)\n",
    "images, labels = dataiter.next() # 一个batch返回4张图片\n",
    "print('实际的label:\\n ', ' '.join(\\\n",
    "            '%08s'%classes[labels[j]] for j in range(4)))\n",
    "show(tv.utils.make_grid(images / 2 - 0.5)).resize((400,100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接着计算网络预测的label："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:39:09.440885Z",
     "start_time": "2020-12-08T11:39:09.429914Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测结果:   ship  ship plane plane\n"
     ]
    }
   ],
   "source": [
    "# 计算图片在每个类别上的分数\n",
    "outputs = net(images)\n",
    "# 得分最高的那个类\n",
    "_, predicted = t.max(outputs.data, 1)\n",
    "\n",
    "print('预测结果: ', ' '.join('%5s'\\\n",
    "            % classes[predicted[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "已经可以看出效果，准确率50%，但这只是一部分的图片，再来看看在整个测试集上的效果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:39:55.834279Z",
     "start_time": "2020-12-08T11:39:51.973397Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000张测试集中的准确率为: 51 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0 # 预测正确的图片数\n",
    "total = 0 # 总共的图片数\n",
    "\n",
    "\n",
    "# 由于测试的时候不需要求导，可以暂时关闭autograd，提高速度，节约内存\n",
    "with t.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = net(images)\n",
    "        _, predicted = t.max(outputs, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum()\n",
    "\n",
    "print('10000张测试集中的准确率为: %d %%' % (100 * correct / total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练的准确率远比随机猜测(准确率10%)好，证明网络确实学到了东西。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  在GPU训练\n",
    "就像之前把Tensor从CPU转到GPU一样，模型也可以类似地从CPU转到GPU。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-08T11:41:07.742467Z",
     "start_time": "2020-12-08T11:41:07.730500Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.9241, grad_fn=<NllLossBackward>)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = t.device(\"cuda:0\" if t.cuda.is_available() else \"cpu\")\n",
    "\n",
    "net.to(device)\n",
    "images = images.to(device)\n",
    "labels = labels.to(device)\n",
    "output = net(images)\n",
    "loss= criterion(output,labels)\n",
    "\n",
    "loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对PyTorch的基础介绍至此结束。总结一下，本节主要包含以下内容。\n",
    "\n",
    "1. Tensor: 类似Numpy数组的数据结构，与Numpy接口类似，可方便地互相转换。\n",
    "2. autograd/: 为tensor提供自动求导功能。\n",
    "3. nn: 专门为神经网络设计的接口，提供了很多有用的功能(神经网络层，损失函数，优化器等)。\n",
    "4. 神经网络训练: 以CIFAR-10分类为例演示了神经网络的训练流程，包括数据加载、网络搭建、训练及测试。\n",
    "\n",
    "通过本节的学习，相信读者可以体会出PyTorch具有接口简单、使用灵活等特点。从下一章开始，本书将深入系统地讲解PyTorch的各部分知识。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:.conda-pytorch] *",
   "language": "python",
   "name": "conda-env-.conda-pytorch-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}