Chapter4/Chapter4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第四章 神经网络工具箱nn\n",
    "\n",
    "autograd实现了自动微分系统，然而对于深度学习来说过于底层，本章将介绍的nn模块，是构建于autograd之上的神经网络模块。除了nn之外，我们还会介绍神经网络中常用的工具，比如优化器optim、初始化init等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 nn.Module\n",
    "\n",
    "第三章中提到，使用autograd可实现深度学习模型，但其抽象程度较低，如果用其来实现深度学习模型，则需要编写的代码量极大。在这种情况下，torch.nn便应运而生，它是专门为深度学习而设计的模块。torch.nn的核心数据结构是`Module`，它是一个抽象的概念，既可以表示神经网络中的某个层（layer），也可以表示一个包含很多层的神经网络。在实际使用中，最常见的做法是继承`nn.Module`，从而编写自己的网络/层。下面先来看看如何用`nn.Module`实现自己的全连接层。全连接层，又名仿射层，输出$\\textbf{y}$和输入$\\textbf{x}$满足$\\textbf{y=Wx+b}$，其中$\\textbf{W}$和$\\textbf{b}$是可学习的参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6.0\n"
     ]
    }
   ],
   "source": [
    "import torch as t\n",
    "from torch import nn\n",
    "print(t.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Linear(nn.Module): # 继承nn.Module，必须重写构造函数（__init__)和前向传播函数（forward）\n",
    "    def __init__(self, in_features, out_features):\n",
    "        super().__init__() # 等价于nn.Module.__init__(self)，常用super方式\n",
    "        # nn.Parameter内的参数是网络可学习的参数\n",
    "        self.w = nn.Parameter(t.randn(in_features, out_features))\n",
    "        self.b = nn.Parameter(t.randn(out_features))\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = x.mm(self.w) # 矩阵乘法，等价于x.@(self.w)\n",
    "        return x + self.b.expand_as(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-1.0987, -0.2932, -3.5264],\n",
       "        [-0.0662, -5.5573, -8.1498]], grad_fn=<AddBackward0>)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "layer = Linear(4,3)\n",
    "input = t.randn(2,4)\n",
    "output = layer(input)\n",
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w Parameter containing:\n",
      "tensor([[ 0.5180,  1.4337,  0.4373],\n",
      "        [ 0.2299, -1.6198, -0.7570],\n",
      "        [ 0.0694, -1.7724, -0.2443],\n",
      "        [ 0.0258,  0.1944,  3.4072]], requires_grad=True)\n",
      "b Parameter containing:\n",
      "tensor([-0.4774,  1.4022, -1.4314], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "for name, parameter in layer.named_parameters():\n",
    "    print(name, parameter) # w and b "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从上面的例子中可以看出，全连接层的实现非常简单，其代码量不超过10行，但需注意以下几点：\n",
    "- 自定义层`Linear`必须继承`nn.Module`，并且在其构造函数中需调用`nn.Module`的构造函数，即`super().__init__()` 或`nn.Module.__init__(self)`，推荐使用第一种用法；\n",
    "- 在构造函数`__init__`中必须自行定义可学习的参数，并封装成`Parameter`，如在本例中我们把`w`和`b`封装成`Parameter`。`Parameter`是一种特殊的`Tensor`，但其默认需要求导（requires_grad = True），感兴趣的读者可以通过`nn.Parameter??`，查看`Parameter`类的源代码；\n",
    "- `forward`函数实现前向传播过程，其输入可以是一个或多个Tensor；\n",
    "- 无需写反向传播函数，`nn.Module`能够利用autograd自动实现反向传播，这点比Function简单许多；\n",
    "- 使用时，直观上可将layer看成数学概念中的函数，调用layer(input)即可得到input对应的结果。它等价于`layers.__call__(input)`，在`__call__`函数中，主要调用的是 `layer.forward(x)`，另外还对钩子（hook）做了一些处理。所以在实际使用中应尽量使用`layer(x)`而不是使用`layer.forward(x)`，关于钩子技术将在下文讲解；\n",
    "- `Module`中的可学习参数可以通过`named_parameters()`或者`parameters()`返回一个迭代器，前者会给每个parameter都附上名字，使其更具有辨识度。\n",
    "\n",
    "可见利用Module实现的全连接层，比利用`Function`实现的更为简单，这是因为我们不再需要编写反向传播函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Module能够自动检测到自己的`parameter`，并将其作为学习参数。除了`parameter`之外，Module还包含子`Module`，主Module能够递归查找子`Module`中的`Parameter`。下面再来看看稍微复杂一点的网络，多层感知机。\n",
    "\n",
    "多层感知机的网络结构如图4-1所示，它由两个全连接层组成，采用$sigmoid$函数作为激活函数（图中没有画出）。\n",
    "![图4-1；多层感知机](imgs/multi_perceptron.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Perceptron(nn.Module):\n",
    "    def __init__(self, in_features, hidden_features, out_features):\n",
    "        super(Perceptron, self).__init__()\n",
    "        # 此处的Linear是前面自定义的全连接层\n",
    "        self.layer1 = Linear(in_features, hidden_features) \n",
    "        self.layer2 = Linear(hidden_features, out_features)\n",
    "    def forward(self, x):\n",
    "        x = self.layer1(x)\n",
    "        x = t.sigmoid(x)\n",
    "        return self.layer2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer1.w torch.Size([3, 4])\n",
      "layer1.b torch.Size([4])\n",
      "layer2.w torch.Size([4, 1])\n",
      "layer2.b torch.Size([1])\n"
     ]
    }
   ],
   "source": [
    "perceptron = Perceptron(3,4,1)\n",
    "for name, param in perceptron.named_parameters():\n",
    "    print(name, param.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可见，即使是稍复杂的多层感知机，其实现依旧很简单。需要注意的是，在构造函数`__init__`中，可利用前面自定义的Linear层(module)，作为当前module对象的一个子module，它的可学习参数，也会成为当前module的可学习参数。而在`forward`函数中，可以加上各层之间的处理函数（激活、数学处理等），并决定层与层之间的关系。\n",
    "\n",
    "而在module中，parameter的全局命名规范如下：\n",
    "\n",
    "1. Parameter直接命名。例如`self.param_name = nn.Parameter(t.randn(3, 4))`，直接命名为`param_name`；\n",
    "2. 子Module中的parameter，会在其名字之前加上当前module的名字。例如`self.sub_module = SubModel()`，SubModel中有个parameter的名字叫做param_name，那么二者拼接而成的parameter name 就是`sub_module.param_name`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为方便用户使用，PyTorch内部实现了神经网络中绝大多数的layer，这些layer都继承于`nn.Module`，封装了可学习参数`parameter`，并实现了`forward`函数。同时，大部分layer都专门针对GPU运算进行了CuDNN优化，其速度和性能都十分优异。本书不准备对nn.Module中的所有层进行详细介绍，具体内容读者可参照官方文档或在IPython/Jupyter中使用nn.layer?来查看。读者在阅读文档时应主要关注以下几点：\n",
    "\n",
    "1. 构造函数的参数，如nn.Linear(in_features, out_features, bias)，需关注这三个参数的作用；\n",
    "2. 属性、可学习参数和子module。如nn.Linear中有`weight`和`bias`两个可学习参数，不包含子module；\n",
    "3. 输入输出的形状，如nn.linear的输入形状是(N, input_features)，输出为(N，output_features)，其中N是batch_size。\n",
    "\n",
    "这些自定义layer对输入形状都有假设：输入的不是单个数据，而是一个batch。当输入只有一个数据时，则必须调用`tensor.unsqueeze(0)`或`tensor[None]`将数据伪装成`batch_size=1`的一个batch。\n",
    "\n",
    "[^1]: http://pytorch.org/docs/nn.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面将从应用层面出发，对一些常用的layer做简单介绍，更详细的用法请查看官方文档。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 常用神经网络层\n",
    "\n",
    "本节将对神经网络中常用的神经网络层进行介绍，这部分内容在后续神经网络的构建中将发挥着重要的作用。\n",
    "\n",
    "### 4.2.1 图像相关层\n",
    "\n",
    "图像相关层主要包括卷积层（Conv）、池化层（Pool）等，这些层在实际使用中可分为一维（1D）、二维（2D）和三维（3D），池化方式又分为平均池化（AvgPool）、最大值池化（MaxPool）、自适应池化（AdaptiveAvgPool）等。而卷积层除了常用的前向卷积之外，还有逆卷积（TransposeConv）等等。下面将举例说明。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 卷积层\n",
    "\n",
    "在深度学习中，与图像处理相关的网络结构中最重要的便是卷积层(Conv)。卷积神经网络的本质就是卷积层、池化层、激活层以及其他层的叠加，所以理解卷积层的工作原理是极其重要的。本节将以最常见的二维卷积为例来对卷积层进行说明。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在torch.nn工具箱中，已经封装好了二维卷积类 ： \n",
    "```python\n",
    "torch.nn.Conv2d(in_channels: int,   \n",
    "                out_channels: int,  \n",
    "                kernel_size: Union[T, Tuple[T, T]], \n",
    "                stride: Union[T, Tuple[T, T]] = 1, \n",
    "                padding: Union[T, Tuple[T, T]] = 0, \n",
    "                dilation: Union[T, Tuple[T, T]] = 1, \n",
    "                groups: int = 1, bias: bool = True, \n",
    "                padding_mode: str = 'zeros')  \n",
    "```\n",
    "其中：  \n",
    "- in_channels：输入图像的维度（常见RGB彩色图像为3）；\n",
    "- out_channels：经过卷积操作后输出的维度；\n",
    "- kernel_size：卷积核大小，常见卷积核为2维方阵即维度为$[T\\times T]$，正方形卷积核可以写为$T(int)$；\n",
    "- stride：每次卷积操作移动的步长；\n",
    "- padding：卷积操作在边界是否有填充，默认为0；\n",
    "- bias：卷积操作加上偏置作为可学习参数，默认为True。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在卷积操作中，我们需要知道其输出结果的形状，以便对后续网络结构进行设计。假设输入的形状为$（N,C_{in},H_{in},W_{in})$，输出的形状为$（N,C_{out},H_{out},W_{out})$，则可以通过式(4.1)计算：\n",
    "$$ \\begin{array}{l}\n",
    "   H_{out} = \\lfloor {H_{in}+{2}\\times{padding[0]}-kernel\\_size[0] \\over stride[0]}+1 \\rfloor \\\\\n",
    "   W_{out} = \\lfloor {W_{in}+{2}\\times{padding[1]}-kernel\\_size[1] \\over stride[1]}+1 \\rfloor\n",
    "  \\end{array}\\tag{4.1}\n",
    "$$ \n",
    "下面将举例说明卷积操作的具体过程。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=L size=200x200 at 0x7F71A662F630>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from PIL import Image\n",
    "from torchvision.transforms import ToTensor, ToPILImage\n",
    "to_tensor = ToTensor() # img -> tensor\n",
    "to_pil = ToPILImage()\n",
    "lena = Image.open('imgs/lena.png')\n",
    "lena#将lena可视化输出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Size: torch.Size([1, 1, 200, 200])\n",
      "Output Size: torch.Size([1, 1, 198, 198])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=198x198 at 0x7F722540B278>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 输入是一个batch，batch_size＝1\n",
    "lena = to_tensor(lena).unsqueeze(0) \n",
    "print(\"Input Size:\",lena.size())#查看input纬度\n",
    "# 锐化卷积核\n",
    "kernel = t.ones(3, 3) / (-9.)\n",
    "kernel[1][1] = 1\n",
    "conv = nn.Conv2d(1, 1, (3, 3), 1, bias=False)\n",
    "conv.weight.data = kernel.view(1, 1, 3, 3)\n",
    "\n",
    "out = conv(lena)\n",
    "print(\"Output Size:\",out.size())\n",
    "to_pil(out.data.squeeze(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在上面的例子中，输入Tensor的大小为$200\\times 200$，卷积核大小为$3\\times 3$，步长为1，填充为0，则根据式(4.1)可以计算得到输出的形状为：\n",
    "$$\n",
    "H_{out}=W_{out} = \\lfloor {200+{2}\\times{0}-3 \\over 1 }+1\\rfloor=198\n",
    "$$\n",
    "这与程序输出的维度一致。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里我们以二维卷积为例对卷积层的输入输出进行了基本的介绍。除了二维卷积以外，图像的卷积操作还有各种变体，感兴趣的读者可以进一步查阅相关资料。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 池化层\n",
    "\n",
    "池化层可以看作是一种特殊的卷积层，其主要用于下采样，增加池化层可以在保留主要特征的同时降低参数量，从而一定程度上防止了过拟合。池化层没有可学习参数，它的weight是固定的。在`torch.nn`工具箱中封装好了各种池化层，常见的有最大池化（MaxPool）和平均池化（AvgPool)，下面将举例说明。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[[6, 8, 9, 2],\n",
      "          [0, 3, 1, 4],\n",
      "          [7, 0, 9, 9],\n",
      "          [9, 3, 2, 7]]]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[[[4, 4],\n",
       "          [4, 6]]]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input = t.randint(10,(1,1,4,4))\n",
    "print(input)\n",
    "pool = nn.AvgPool2d(2,2) # 平均池化，池化中的卷积核为2*2，步长默认等于卷积核长度，无填充\n",
    "pool(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(pool.parameters()) # 可以看到，池化层中并没有可学习参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=100x100 at 0x7F71A5B65940>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out = pool(lena)\n",
    "to_pil(out.data.squeeze(0))#输出池化后的lena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 其他层\n",
    "\n",
    "除了卷积层和池化层，深度学习中还将常用到以下几个层：\n",
    "- Linear：全连接层；\n",
    "- BatchNorm：批标准化层，分为1D、2D和3D。除了标准的BatchNorm之外，还有在风格迁移中常用到的InstanceNorm层；\n",
    "- Dropout：Dropout层，用来防止过拟合，同样分为1D、2D和3D。\n",
    "\n",
    "下面将举几个例子来说明它们的使用方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.2782, -0.7852,  0.0166, -0.1817],\n",
       "        [-0.1064, -0.5069, -0.2169, -0.0372]], grad_fn=<AddmmBackward>)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 输入 batch_size=2，维度3\n",
    "input = t.randn(2, 3)\n",
    "linear = nn.Linear(3, 4)\n",
    "h = linear(input)\n",
    "h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-3.9973, -3.9990,  3.9985, -3.9962],\n",
      "        [ 3.9973,  3.9990, -3.9985,  3.9962]],\n",
      "       grad_fn=<NativeBatchNormBackward>)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(tensor([ 0.0000e+00, -8.3447e-07,  0.0000e+00,  0.0000e+00],\n",
       "        grad_fn=<MeanBackward1>),\n",
       " tensor([3.9973, 3.9990, 3.9985, 3.9962], grad_fn=<StdBackward1>))"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 4 channel，初始化标准差为4，均值为0\n",
    "bn = nn.BatchNorm1d(4)\n",
    "bn.weight.data = t.ones(4) * 4\n",
    "bn.bias.data = t.zeros(4)\n",
    "\n",
    "bn_out = bn(h)\n",
    "print(bn_out)\n",
    "# 注意输出的均值和方差\n",
    "bn_out.mean(0),bn_out.std(0, unbiased=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-7.9946, -0.0000,  0.0000, -0.0000],\n",
       "        [ 0.0000,  0.0000, -7.9971,  7.9923]], grad_fn=<MulBackward0>)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 每个元素以0.5的概率随机舍弃\n",
    "dropout = nn.Dropout(0.5)\n",
    "o = dropout(bn_out)\n",
    "o # 有一半左右的数变为0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上很多例子中都对module的属性直接操作，其大多数是可学习参数，一般会随着学习的进行而不断改变。实际使用中除非需要使用特殊的初始化，否则应尽量不要直接修改这些参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.2 激活函数\n",
    "PyTorch实现了常见的激活函数，其具体的接口信息可参见官方文档，这些激活函数可作为独立的layer使用。这里将介绍最常用的激活函数ReLU，其数学表达式为：\n",
    "$$\n",
    "ReLU(x)=max(0,x) \\tag{4.2}\n",
    "$$\n",
    "\n",
    "下面来看如何在`torch.nn`中使用ReLU函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.1584,  1.3065,  0.6037],\n",
      "        [ 0.4320, -0.0310,  0.0563]])\n",
      "tensor([[0.1584, 1.3065, 0.6037],\n",
      "        [0.4320, 0.0000, 0.0563]])\n"
     ]
    }
   ],
   "source": [
    "relu = nn.ReLU(inplace=True)\n",
    "input = t.randn(2, 3)\n",
    "print(input)\n",
    "output = relu(input)\n",
    "print(output) # 小于0的都被截断为0\n",
    "# 等价于input.clamp(min=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ReLU函数有个inplace参数，如果设为True，它会把输出直接覆盖到输入中，这样可以节省内存/显存。这里之所以可以直接覆盖，是因为在计算ReLU的反向传播时，只需根据输出就能够推算出反向传播的梯度。但是只有少数的autograd操作支持inplace操作（如tensor.sigmoid_()），因此除非你明确地知道自己在做什么，否则一般不要使用inplace操作。除此以外，常见的激活函数还有$tanh={{e^x}-{e^{-x}} \\over {e^x}+{e^{-x}}}$和$sigmoid={1 \\over {1 + {e^{-x}}}}$。读者可以根据实际的网络结构、数据分布等灵活地选用各类激活函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.3 构建网络\n",
    "在以上的例子中，我们基本上都是将每一层的输出直接作为下一层的输入，这种网络称为前馈传播网络（Feedforward Neural Network）。对于此类网络如果每次都写复杂的`forward`函数会有些麻烦，这里有两种简化方式：ModuleList和Sequential。其中Sequential是一个特殊的module，它包含几个子Module，前向传播时会将输入一层接一层的传递下去。ModuleList也是一个特殊的Module，可以包含几个子module，我们可以像用list一样使用它，但不能直接把输入传给ModuleList，下面将举例说明。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "net1: Sequential(\n",
      "  (conv): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (batchnorm): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (activation_layer): ReLU()\n",
      ")\n",
      "net2: Sequential(\n",
      "  (0): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (1): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (2): ReLU()\n",
      ")\n",
      "net3: Sequential(\n",
      "  (conv1): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (bn1): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (relu1): ReLU()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# Sequential的三种写法\n",
    "net1 = nn.Sequential()\n",
    "net1.add_module('conv', nn.Conv2d(3, 3, 3))\n",
    "net1.add_module('batchnorm', nn.BatchNorm2d(3))\n",
    "net1.add_module('activation_layer', nn.ReLU())\n",
    "\n",
    "net2 = nn.Sequential(\n",
    "        nn.Conv2d(3, 3, 3),\n",
    "        nn.BatchNorm2d(3),\n",
    "        nn.ReLU()\n",
    "        )\n",
    "\n",
    "from collections import OrderedDict\n",
    "net3= nn.Sequential(OrderedDict([\n",
    "          ('conv1', nn.Conv2d(3, 3, 3)),\n",
    "          ('bn1', nn.BatchNorm2d(3)),\n",
    "          ('relu1', nn.ReLU())\n",
    "        ]))\n",
    "print('net1:', net1)\n",
    "print('net2:', net2)\n",
    "print('net3:', net3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1)),\n",
       " Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1)),\n",
       " Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1)))"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 可根据名字或序号取出子module\n",
    "net1.conv, net2[0], net3.conv1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 调用已构建的网络\n",
    "input = t.rand(1, 3, 4, 4)\n",
    "output = net1(input)\n",
    "output = net2(input)\n",
    "output = net3(input)\n",
    "output = net3.relu1(net1.batchnorm(net1.conv(input)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "modellist = nn.ModuleList([nn.Linear(3,4), nn.ReLU(), nn.Linear(4,2)])\n",
    "input = t.randn(1, 3)\n",
    "for model in modellist:\n",
    "    input = model(input)\n",
    "# 下面会报错,因为modellist没有实现forward方法\n",
    "# output = modelist(input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "看到这里，读者可能会问，为何不直接使用Python中自带的list，而非要多此一举呢？这是因为`ModuleList`是`Module`的子类，当在`Module`中使用它的时候，就能自动识别为子module，下面将举例说明。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MyModule(\n",
       "  (module_list): ModuleList(\n",
       "    (0): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (1): ReLU()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyModule(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MyModule, self).__init__()\n",
    "        self.list = [nn.Linear(3, 4), nn.ReLU()]\n",
    "        self.module_list = nn.ModuleList([nn.Conv2d(3, 3, 3), nn.ReLU()])\n",
    "    def forward(self):\n",
    "        pass\n",
    "model = MyModule()\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "module_list.0.weight torch.Size([3, 3, 3, 3])\n",
      "module_list.0.bias torch.Size([3])\n"
     ]
    }
   ],
   "source": [
    "for name, param in model.named_parameters():\n",
    "    print(name, param.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可见，list中的子module并不能被主module所识别，而`ModuleList`中的子module能够被主module所识别。这意味着如果用list保存子module，将无法调整其参数，因其未加入到主module的参数中。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除了`ModuleList`之外还有`ParameterList`，它是一个可以包含多个parameter的类list对象。在实际应用中，其使用方式与`ModuleList`类似。如果在构造函数`__init__`中用到list、tuple、dict等对象时，一定要思考是否应该用`ModuleList`或`ParameterList`代替。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.3 循环神经网络层(RNN)\n",
    "近年来，随着深度学习和自然语言处理领域的逐渐火热，RNN的使用也越来越多。PyTorch中实现了如今最常用的三种RNN：RNN（vanilla RNN）、LSTM和GRU。此外还有对应的三种RNNCell。\n",
    "\n",
    "RNN和RNNCell层的区别在于前者一次能够处理整个序列，而后者一次只处理序列中一个时间点的数据；同时，RNN的封装更完备更易于使用，相比之下RNNCell层更具灵活性。实际上RNN层的一种后端实现方式就是调用RNNCell来实现的。下面将举例说明这两种RNN层结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 3, 3])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.manual_seed(2021)\n",
    "# 输入：batch_size=3，序列长度都为2，序列中每个元素占4维\n",
    "input = t.randn(2, 3, 4).float()\n",
    "# lstm输入向量4维，3个隐藏元，1层\n",
    "lstm = nn.LSTM(4, 3, 1)\n",
    "# 初始状态：1层，batch_size=3，3个隐藏元\n",
    "h0 = t.randn(1, 3, 3)\n",
    "c0 = t.randn(1, 3, 3)\n",
    "out1, hn = lstm(input, (h0, c0))\n",
    "out1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 3, 3])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.manual_seed(2021)\n",
    "input = t.randn(2, 3, 4).float()\n",
    "# 一个LSTMCell对应的层数只能是一层\n",
    "lstm = nn.LSTMCell(4, 3)\n",
    "hx = t.randn(3, 3)\n",
    "cx = t.randn(3, 3)\n",
    "out = []\n",
    "for i_ in input:\n",
    "    hx, cx=lstm(i_, (hx, cx))\n",
    "    out.append(hx)\n",
    "out2=t.stack(out)\n",
    "out2.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其中，上述两种实现方式下LSTM的结果是完全一致的。读者可以对比一下这两种实现方式有何区别，并从中体会RNN和RNNCell层实现的不同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#受限于精度问题，这里使用allclose函数说明结果的一致性\n",
    "out1.allclose(out2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "词向量在自然语言中应用十分普及，PyTorch同样提供了Embedding层，下面将举例说明。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Embedding(4, 5)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 有4个词，每个词用5维的向量表示\n",
    "embedding = nn.Embedding(4, 5)\n",
    "# 可以用预训练好的词向量初始化embedding\n",
    "weight = t.arange(0,20).view(4,5).float()\n",
    "nn.Embedding.from_pretrained(weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.6590, -2.2046, -0.1831, -0.5673,  0.6770],\n",
       "        [ 1.8060,  1.0928,  0.6670,  0.4997,  0.1662],\n",
       "        [ 0.1592, -0.3728, -1.1482, -0.4520,  0.5914]],\n",
       "       grad_fn=<EmbeddingBackward>)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input = t.arange(3, 0, -1).long()\n",
    "output = embedding(input)\n",
    "output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.4 损失函数\n",
    "在深度学习中会经常使用各种各样的损失函数（loss function），这些损失函数可看作是一种特殊的layer，PyTorch也将这些损失函数实现为`nn.Module`的子类。然而在实际使用中通常将这些损失函数专门提取出来，作为独立的一部分。详细的loss使用请参照官方文档，这里以分类中最常用的交叉熵损失CrossEntropyloss为例进行讲解。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.5865)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# batch_size=3，计算对应每个类别的分数（只有两个类别）\n",
    "score = t.randn(3, 2)\n",
    "# 三个样本分别属于1，0，1类，label必须是LongTensor\n",
    "label = t.Tensor([1, 0, 1]).long()\n",
    "\n",
    "# loss与普通的layer无差异\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "loss = criterion(score, label)\n",
    "loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "本小节对nn中的常用模块进行了详细的介绍，利用这些模块读者便可以快速地搭建神经网络。读者在使用这些模块时应当注意每一个module所包含的参数和输入、输出的形状及含义，从而避免一些不必要的错误。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3 nn.functional\n",
    "\n",
    "`torch.nn`中还有一个很常用的模块：`nn.functional`。`torch.nn`中的大多数layer，在`functional`中都有一个与之相对应的函数。`nn.functional`中的函数和`nn.Module`的主要区别在于，用`nn.Module`实现的layers是一个特殊的类，都是由`class layer(nn.Module)`定义，会自动提取可学习的参数；而`nn.functional`中的函数更像是纯函数，由`def function(input)`定义。下面将举例说明functional的使用，并对比二者的不同之处。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.1与nn.module的区别"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[True, True, True, True],\n",
       "        [True, True, True, True]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input = t.randn(2, 3)\n",
    "model = nn.Linear(3, 4)\n",
    "output1 = model(input)\n",
    "output2 = nn.functional.linear(input, model.weight, model.bias)\n",
    "output1 == output2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[True, True, True],\n",
       "        [True, True, True]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = nn.functional.relu(input)\n",
    "b2 = nn.ReLU()(input)\n",
    "b == b2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此时读者可能会问，应该什么时候使用`nn.Module`，什么时候使用`nn.functional`呢？答案很简单，如果模型有可学习的参数，最好用`nn.Module`，否则既可以使用`nn.functional`也可以使用`nn.Module`，二者在性能上没有太大差异，具体的使用取决于个人的喜好。由于激活函数（`ReLU`、`sigmoid`、`tanh`）、池化（MaxPool）等层没有可学习参数，可以使用对应的functional函数代替；而卷积、全连接等具有可学习参数的网络建议使用`nn.Module`。另外虽然dropout操作也没有可学习操作，但建议还是使用`nn.Dropout`而不是`nn.functional.dropout`，因为dropout在训练和测试两个阶段的行为有所差别，使用`nn.Module`对象能够通过`model.eval`操作加以区分。下面将举例说明如何在模型中搭配使用`nn.Module`和`nn.functional`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.nn import functional as F\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.pool(F.relu(self.conv1(x)), 2)\n",
    "        x = F.pool(F.relu(self.conv2(x)), 2)\n",
    "        x = x.view(-1, 16 * 5 * 5)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于不具备可学习参数的层（激活层、池化层等），将它们用函数代替，这样可以不用放置在构造函数`__init__`中。而对于有可学习参数的模块，也可以用functional代替，只不过实现起来较为繁琐，这是因为我们需要手动定义参数parameter，如下文自定义实现的全连接层`MyLinear`，它需要将weight和bias两个参数单独拿出来，在构造函数中初始化为parameter。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyLinear(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MyLinear, self).__init__()\n",
    "        self.weight = nn.Parameter(t.randn(3, 4))\n",
    "        self.bias = nn.Parameter(t.zeros(3))\n",
    "    def forward(self):\n",
    "        return F.linear(input, weight, bias)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "关于nn.functional的设计初衷，以及它和nn.Module更多的比较说明，读者可参看PyTorch中论坛的相关讨论和说明。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.2 采样函数\n",
    "在`nn.functional`中还有一个常用的函数：采样函数`torch.nn.functional.grid_sample`，它的主要作用是对输入的Tensor进行双线性采样，并让输出变换为我们想要的形状。这里我们用lena来进行举例说明。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=200x200 at 0x7F71A5B93588>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "to_pil(lena.data.squeeze(0)) # 原始的lena数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lena的形状是1x1x200x200，（N,C,Hin,Win）\n",
    "w = 400 # 准备将图像放大至400\n",
    "# 得到400x400的介于[-1,1]之间的均匀分布张量\n",
    "h_out = t.linspace(-1, 1, w).view(-1, 1).repeat(1, w)\n",
    "w_out = t.linspace(-1, 1, w).repeat(w, 1)\n",
    "grid = t.cat((w_out.unsqueeze(2), h_out.unsqueeze(2)), dim = 2)\n",
    "# grid形状为（N,Hout,Wout,2）\n",
    "# grid最后一个维度大小为2，表示输入中pixel的位置信息，取值范围在（-1,1）\n",
    "grid = grid.unsqueeze(0) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=400x400 at 0x7F719C33D2E8>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "from torch.nn import functional as F\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "out = F.grid_sample(lena, grid=grid, mode='bilinear')\n",
    "to_pil(out.data.squeeze(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.4 初始化策略\n",
    "在深度学习中参数的初始化十分重要，良好的初始化能让模型更快地收敛，并达到更高水平，而糟糕的初始化则可能使得模型迅速崩溃。PyTorch中`nn.Module`的模块参数都采取了较为合理的初始化策略，因此一般不用我们考虑。当然我们也可以用自定义初始化来代替系统的默认初始化。而当我们在使用Parameter时，自定义初始化则尤为重要，这是因为torch.Tensor()返回的是内存中的随机数，很可能会有极大值，这在实际训练网络中会造成溢出或者梯度消失。PyTorch中`nn.init`模块就是专门为初始化而设计的一个模块，其中实现了常用的初始化策略。如果某种初始化策略`nn.init`不提供，用户也可以自己直接初始化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[ 1.2225,  0.3428, -0.4605],\n",
       "        [-0.1951, -0.3705,  0.4823],\n",
       "        [-1.4530, -0.7739,  0.3334],\n",
       "        [ 0.2577, -1.2324,  0.4905]], requires_grad=True)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 利用nn.init初始化\n",
    "from torch.nn import init\n",
    "linear = nn.Linear(3, 4)\n",
    "t.manual_seed(2021)\n",
    "\n",
    "init.xavier_normal_(linear.weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.2225,  0.3428, -0.4605],\n",
       "        [-0.1951, -0.3705,  0.4823],\n",
       "        [-1.4530, -0.7739,  0.3334],\n",
       "        [ 0.2577, -1.2324,  0.4905]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 利用公式，直接初始化\n",
    "import math\n",
    "t.manual_seed(2021)\n",
    "\n",
    "# xavier初始化的计算公式\n",
    "std = math.sqrt(2) / math.sqrt(7.)\n",
    "linear.weight.data.normal_(0,std)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 对模型的所有参数进行初始化\n",
    "net = Net()\n",
    "for name, params in net.named_parameters():\n",
    "    if name.find('linear') != -1:\n",
    "        # init linear\n",
    "        params[0] # weight\n",
    "        params[1] # bias\n",
    "    elif name.find('conv') != -1:\n",
    "        pass\n",
    "    elif name.find('norm') != -1:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.5 优化器\n",
    "\n",
    "PyTorch将深度学习中常用的优化方法全部封装在`torch.optim`中，其设计十分灵活，能够很方便地扩展成自定义的优化方法。\n",
    "\n",
    "所有的优化方法都是继承基类`optim.Optimizer`，并实现了自己的优化步骤。下面就以最基本的优化方法——随机梯度下降法（SGD）举例说明。这里需要重点掌握：\n",
    "\n",
    "1. 优化方法的基本使用方法；\n",
    "2. 如何对模型的不同部分设置不同的学习率；\n",
    "3. 如何调整学习率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 以本章4.1节的感知器为例\n",
    "class Perceptron(nn.Module):\n",
    "    def __init__(self, in_features, hidden_features, out_features):\n",
    "        super(Perceptron, self).__init__()\n",
    "        # 此处的Linear是前面自定义的全连接层\n",
    "        self.layer1 = Linear(in_features, hidden_features) \n",
    "        self.layer2 = Linear(hidden_features, out_features)\n",
    "    def forward(self, x):\n",
    "        x = self.layer1(x)\n",
    "        x = t.sigmoid(x)\n",
    "        return self.layer2(x)\n",
    "\n",
    "net=Perceptron(3,4,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch import optim\n",
    "optimizer = optim.SGD(params=net.parameters(), lr=1)\n",
    "optimizer.zero_grad() # 梯度清零，等价于net.zero_grad()\n",
    "\n",
    "input = t.randn(32, 3)\n",
    "output = net(input)\n",
    "output.backward(output) # fake backward\n",
    "\n",
    "optimizer.step() # 执行优化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SGD (\n",
       "Parameter Group 0\n",
       "    dampening: 0\n",
       "    lr: 1e-05\n",
       "    momentum: 0\n",
       "    nesterov: False\n",
       "    weight_decay: 0\n",
       "\n",
       "Parameter Group 1\n",
       "    dampening: 0\n",
       "    lr: 0.01\n",
       "    momentum: 0\n",
       "    nesterov: False\n",
       "    weight_decay: 0\n",
       ")"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weight_params = [param for name,param in net.named_parameters() if name.endswith('.w')]\n",
    "bias_params = [param for name,param in net.named_parameters() if name.endswith('.b')]\n",
    "\n",
    "optimizer =optim.SGD([\n",
    "                {'params':bias_params},\n",
    "                {'params': weight_params, 'lr': 1e-2}\n",
    "            ], lr=1e-5)\n",
    "optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SGD (\n",
       "Parameter Group 0\n",
       "    dampening: 0\n",
       "    lr: 0.001\n",
       "    momentum: 0\n",
       "    nesterov: False\n",
       "    weight_decay: 0\n",
       "\n",
       "Parameter Group 1\n",
       "    dampening: 0\n",
       "    lr: 0.01\n",
       "    momentum: 0\n",
       "    nesterov: False\n",
       "    weight_decay: 0\n",
       ")"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 只为第一个全连接层设置较大的学习率，其余层的学习率较小\n",
    "special_layers = nn.ModuleList([net.layer1])\n",
    "special_layers_params = list(map(id, special_layers.parameters()))\n",
    "base_params = [param for param in net.parameters() if id(param) not in special_layers_params]\n",
    "optimizer = t.optim.SGD([\n",
    "            {'params': base_params},\n",
    "            {'params': special_layers.parameters(), 'lr': 0.01}\n",
    "        ], lr=0.001 )\n",
    "optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "调整学习率主要有两种做法：\n",
    "1. 修改optimizer.param_groups中对应的学习率；\n",
    "2. 新建一个优化器。\n",
    "\n",
    "相比之下笔者更加推荐第二种做法，这是因为optimizer一般构建开销很小，故而可以构建新的optimizer。但是新建优化器会重新初始化动量等状态信息，这对于使用动量的优化器（如Adam），可能会造成损失函数在收敛过程中出现震荡等情况。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SGD (\n",
       "Parameter Group 0\n",
       "    dampening: 0\n",
       "    lr: 1e-05\n",
       "    momentum: 0\n",
       "    nesterov: False\n",
       "    weight_decay: 0\n",
       "\n",
       "Parameter Group 1\n",
       "    dampening: 0\n",
       "    lr: 0.010000000000000002\n",
       "    momentum: 0\n",
       "    nesterov: False\n",
       "    weight_decay: 0\n",
       ")"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 调整学习率，新建一个optimizer\n",
    "old_lr = 0.1\n",
    "optimizer1 =optim.SGD([\n",
    "                {'params': bias_params},\n",
    "                {'params': weight_params, 'lr': old_lr*0.1}\n",
    "            ], lr=1e-5)\n",
    "optimizer1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SGD (\n",
       "Parameter Group 0\n",
       "    dampening: 0\n",
       "    lr: 0.0001\n",
       "    momentum: 0\n",
       "    nesterov: False\n",
       "    weight_decay: 0\n",
       "\n",
       "Parameter Group 1\n",
       "    dampening: 0\n",
       "    lr: 0.001\n",
       "    momentum: 0\n",
       "    nesterov: False\n",
       "    weight_decay: 0\n",
       ")"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 调整学习率, 手动decay, 保存动量\n",
    "for param_group in optimizer.param_groups:\n",
    "    param_group['lr'] *= 0.1 # 学习率为之前的0.1倍\n",
    "optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.6 nn.Module深入分析\n",
    "\n",
    "如果想要更深入地理解nn.Module，研究其原理是很有必要的。首先来看看nn.Module基类的构造函数：\n",
    "```python\n",
    "def __init__(self):\n",
    "    self._parameters = OrderedDict()\n",
    "    self._modules = OrderedDict()\n",
    "    self._buffers = OrderedDict()\n",
    "    self._backward_hooks = OrderedDict()\n",
    "    self._forward_hooks = OrderedDict()\n",
    "    self.training = True\n",
    "```\n",
    "其中：\n",
    "\n",
    "- `_parameters`：字典，保存用户直接设置的parameter。例如`self.param1 = nn.Parameter(t.randn(3, 3))`会被检测到，在字典中加入一个key为param，value为对应parameter的item。而self.submodule = nn.Linear(3, 4)中的parameter则不会存于此；\n",
    "- `_modules`：子module，例如通过`self.submodel = nn.Linear(3, 4)`指定的子module会保存于此；\n",
    "- `_buffers`：缓存。例如BatchNorm使用Momentum机制，每次前向传播需用到上一次前向传播的结果；\n",
    "- `_backward_hooks`与`_forward_hooks`：钩子技术，用来提取中间变量；\n",
    "- `training`：BatchNorm与Dropout层在训练阶段和测试阶段中采取的策略不同，通过判断training值来决定前向传播策略。\n",
    "\n",
    "上述几个属性中，`_parameters`、`_modules`和`_buffers`这三个字典中的键值，都可以通过`self.key`方式获得，效果等价于`self._parameters['key']`，下面将举例说明。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Net(\n",
       "  (submodel1): Linear(in_features=3, out_features=4, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        # 等价与self.register_parameter('param1' ,nn.Parameter(t.randn(3, 3)))\n",
    "        self.param1 = nn.Parameter(t.rand(3, 3))\n",
    "        self.submodel1 = nn.Linear(3, 4) \n",
    "    def forward(self, input):\n",
    "        x = self.param1.mm(input)\n",
    "        x = self.submodel1(x)\n",
    "        return x\n",
    "net = Net()\n",
    "net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('submodel1', Linear(in_features=3, out_features=4, bias=True))])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net._modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('param1', Parameter containing:\n",
       "              tensor([[0.9518, 0.6976, 0.2651],\n",
       "                      [0.0453, 0.1703, 0.0534],\n",
       "                      [0.6597, 0.9927, 0.1376]], requires_grad=True))])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net._parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[0.9518, 0.6976, 0.2651],\n",
       "        [0.0453, 0.1703, 0.0534],\n",
       "        [0.6597, 0.9927, 0.1376]], requires_grad=True)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.param1 # 等价于net._parameters['param1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "param1 torch.Size([3, 3])\n",
      "submodel1.weight torch.Size([4, 3])\n",
      "submodel1.bias torch.Size([4])\n"
     ]
    }
   ],
   "source": [
    "for name, param in net.named_parameters():\n",
    "    print(name, param.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Net(\n",
      "  (submodel1): Linear(in_features=3, out_features=4, bias=True)\n",
      ")\n",
      "submodel1 Linear(in_features=3, out_features=4, bias=True)\n"
     ]
    }
   ],
   "source": [
    "for name, submodel in net.named_modules():\n",
    "    print(name, submodel) # 当前module和他的子module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('running_mean', tensor([0.0397, 0.0299])),\n",
       "             ('running_var', tensor([0.9065, 0.9008])),\n",
       "             ('num_batches_tracked', tensor(1))])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bn = nn.BatchNorm1d(2)\n",
    "input = t.rand(3, 2)\n",
    "output = bn(input)\n",
    "bn._buffers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从上面的示例中可以看出，`nn.Module`在实际使用中可能层层嵌套：一个module包含若干个子module，每一个子module又包含了更多的子module。为方便用户访问各个子module，`nn.Module`实现了很多方法，如函数`children`可以查看直接子module，函数`modules`可以查看所有的子module（包括当前module）。与之相对应的还有函数`named_childen`和`named_modules`，其能够在返回module列表的同时返回它们的名字。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.,  2.,  4.,  0.],\n",
       "        [ 8., 10.,  0.,  0.],\n",
       "        [ 0., 18., 20.,  0.]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input = t.arange(0, 12).view(3, 4).float()\n",
    "model = nn.Dropout()\n",
    "# 在训练阶段，会有一半左右的数被随机置为0\n",
    "model(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.,  1.,  2.,  3.],\n",
       "        [ 4.,  5.,  6.,  7.],\n",
       "        [ 8.,  9., 10., 11.]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.training  = False\n",
    "# 在测试阶段，dropout什么都不做\n",
    "model(input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于BatchNorm、Dropout、InstanceNorm等在训练和测试阶段行为差距较大的层，如果在测试时不将其training值设为False，则可能会有很大影响，这在实际使用中要格外注意。虽然可以通过直接设置`training`属性来将子module设为train和eval模式，但这种方式较为繁琐。因为，如果一个模型具有多个Dropout层，就需要为每个Dropout层指定training属性。笔者推荐的做法是调用`model.train()`函数，它会将当前module及其子module中的所有training属性都设为True，相应地，`model.eval()`函数会把training属性都设为False。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.training, net.submodel1.training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, False)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.eval() # eval()将所有的training属性设为False\n",
    "net.training, net.submodel1.training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('', Net(\n",
       "    (submodel1): Linear(in_features=3, out_features=4, bias=True)\n",
       "  )), ('submodel1', Linear(in_features=3, out_features=4, bias=True))]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(net.named_modules())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`register_forward_hook`和`register_backward_hook`函数可以在module前向传播或反向传播时注册钩子。每次前向传播执行结束后会执行钩子函数（hook）。前向传播的钩子函数具有如下形式：`hook(module, input, output) -> None`，而反向传播则具有如下形式：`hook(module, grad_input, grad_output) -> Tensor or None`。钩子函数不应修改输入和输出，并且在使用后应及时删除，以避免每次都运行钩子增加运行负载。钩子函数主要用在获取某些中间结果的情景，如中间某一层的输出或某一层的梯度。这些结果本应写在forward函数中，但如果在forward函数中专门加上这些处理，可能会使处理逻辑比较复杂，这时候使用钩子技术就更加合适。下面考虑一种场景，有一个预训练好的模型，需要提取模型的某一层（不是最后一层）的输出作为特征进行分类，但又不希望修改其原有的模型定义文件，这时就可以利用钩子函数。下面给出实现的伪代码。\n",
    "```python\n",
    "model = VGG()\n",
    "features = t.Tensor()\n",
    "def hook(module, input, output):\n",
    "    '''把这层的输出拷贝到features中'''\n",
    "    features.copy_(output.data)\n",
    "    \n",
    "handle = model.layer8.register_forward_hook(hook)\n",
    "_ = model(input)\n",
    "# 用完hook后删除\n",
    "handle.remove()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`nn.Module`对象在构造函数中的行为看起来有些怪异，如果想要真正掌握其原理，就需要看两个魔法方法`__getattr__`和`__setattr__`。在Python中有两个常用的buildin方法`getattr`和`setattr`。\n",
    "\n",
    "1. 对于`getattr(obj, 'attr1')`，其等价于`obj.attr`，如果`getattr`函数无法找到所需属性，Python会调用`obj.__getattr__('attr1')`方法，即`getattr`函数无法找到的交给`__getattr__`函数处理；如果这个对象没有实现`__getattr__`方法，或者遇到`__getattr__`方法也无法处理情况，程序就会抛出异常AttributeError。\n",
    "2. 对于`setattr(obj, 'name', value)`，其等价于`obj.name=value`，如果obj对象实现了`__setattr__`方法，`setattr`会直接调用`obj.__setattr__('name', value)`，否则调用buildin方法。\n",
    "\n",
    "总结如下：\n",
    "\n",
    "- result  = obj.name会调用buildin函数`getattr(obj, 'name')`，如果该属性找不到，则会调用`obj.__getattr__('name')`\n",
    "- obj.name = value会调用buildin函数`setattr(obj, 'name', value)`，如果obj对象实现了`__setattr__`方法，`setattr`会直接调用`obj.__setattr__('name', value)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nn.Module实现了自定义的`__setattr__`函数，当执行`module.name=value`时，会在`__setattr__`中判断value是否为`Parameter`或`nn.Module`对象，如果是则将这些对象加到`_parameters`和`_modules`两个字典中；而如果是其它类型的对象，如`list`、`dict`等，则调用默认的操作，将这个值保存在`__dict__`中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('param', Parameter containing:\n",
       "              tensor([[1., 1.],\n",
       "                      [1., 1.]], requires_grad=True))])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module = nn.Module()\n",
    "module.param = nn.Parameter(t.ones(2, 2))\n",
    "module._parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_modules:  OrderedDict()\n",
      "__dict__['submodules']: [Linear(in_features=2, out_features=2, bias=True), Linear(in_features=2, out_features=2, bias=True)]\n"
     ]
    }
   ],
   "source": [
    "submodule1 = nn.Linear(2, 2)\n",
    "submodule2 = nn.Linear(2, 2)\n",
    "module_list = [submodule1, submodule2]\n",
    "# 对于list对象，调用buildin函数，保存在__dict__中\n",
    "module.submodules = module_list\n",
    "print('_modules: ', module._modules)\n",
    "print(\"__dict__['submodules']:\",module.__dict__.get('submodules'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ModuleList is instance of nn.Module:  True\n",
      "_modules:  OrderedDict([('submodules', ModuleList(\n",
      "  (0): Linear(in_features=2, out_features=2, bias=True)\n",
      "  (1): Linear(in_features=2, out_features=2, bias=True)\n",
      "))])\n",
      "__dict__['submodules']: None\n"
     ]
    }
   ],
   "source": [
    "module_list = nn.ModuleList(module_list)\n",
    "module.submodules = module_list\n",
    "print('ModuleList is instance of nn.Module: ', isinstance(module_list, nn.Module))\n",
    "print('_modules: ', module._modules)\n",
    "print(\"__dict__['submodules']:\", module.__dict__.get('submodules'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因`_modules`和`_parameters`中的item未保存在`__dict__`中，所以默认的`getattr`方法无法获取它，因而`nn.Module`实现了自定义的`__getattr__`方法。如果默认的`getattr`无法处理，就调用自定义的`__getattr__`方法，尝试从`_modules`、`_parameters`和`_buffers`这三个字典中获取。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr(module, 'training') # 等价于module.training\n",
    "# error\n",
    "# module.__getattr__('training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module.attr1 = 2\n",
    "getattr(module, 'attr1')\n",
    "# 报错\n",
    "# module.__getattr__('attr1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[1., 1.],\n",
       "        [1., 1.]], requires_grad=True)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 即module.param, 会调用module.__getattr__('param')\n",
    "getattr(module, 'param')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在PyTorch中保存模型十分简单，所有的Module对象都具有state_dict()函数，返回当前Module所有的状态数据。将这些状态数据保存后，下次使用模型时即可利用`model.load_state_dict()`函数将状态加载进来。优化器（optimizer）也有类似的机制，不过一般并不需要保存优化器的运行状态。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 保存模型\n",
    "t.save(net.state_dict(), 'net.pth')\n",
    "\n",
    "# 加载已保存的模型\n",
    "net2 = Net()\n",
    "net2.load_state_dict(t.load('net.pth'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实际上还有另外一种保存方法，但因其严重依赖模型定义方式及文件路径结构等，很容易出问题，因而不建议使用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Net(\n",
       "  (submodel1): Linear(in_features=3, out_features=4, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.save(net, 'net_all.pth')\n",
    "net2 = t.load('net_all.pth')\n",
    "net2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将Module放在GPU上运行也十分简单，只需以下两步：\n",
    "- model = model.cuda()：将模型的所有参数转存到GPU；\n",
    "- input.cuda()：将输入数据放置到GPU上。\n",
    "\n",
    "至于如何在多个GPU上并行计算，PyTorch也提供了两个函数，可实现简单高效的并行GPU计算。\n",
    "\n",
    "- nn.parallel.data_parallel(module, inputs, device_ids=None, output_device=None, dim=0, module_kwargs=None)\n",
    "- class torch.nn.DataParallel(module, device_ids=None, output_device=None, dim=0)\n",
    "\n",
    "可见二者的参数十分相似，通过`device_ids`参数可以指定在哪些GPU上进行优化，而通过`output_device`参数可以指定输出到哪个GPU上。二者唯一的不同就在于前者直接利用多GPU并行计算得出结果，而后者则返回一个新的module，能够自动在多GPU上进行并行加速。\n",
    "\n",
    "```\n",
    "# method 1\n",
    "new_net = nn.DataParallel(net, device_ids=[0, 1])\n",
    "output = new_net(input)\n",
    "\n",
    "# method 2\n",
    "output = nn.parallel.data_parallel(new_net, input, device_ids=[0, 1])\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DataParallel并行的方式，是将输入一个batch的数据均分成多份，分别送到对应的GPU进行计算，各个GPU得到的梯度累加。与Module相关的所有数据也都会以浅复制的方式复制多份。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.7 小试牛刀：搭建ResNet\n",
    "Kaiming He提出的深度残差网络（ResNet）在深度学习的发展中起到了很重要的作用，ResNet不仅一举拿下了当年多个计算机视觉比赛项目的冠军，更重要的是这一结构解决了训练极深网络时的梯度消失问题。\n",
    "\n",
    "这里选取的是ResNet的一个变种ResNet34来讲解ResNet的网络结构。ResNet的网络结构如图4-2所示，除了最开始的卷积池化和最后的池化全连接之外，网络中有很多结构相似的单元，这些重复单元的共同点就是有个跨层直连的shortcut。ResNet中将一个跨层直连的单元称为Residual Block，其结构如图4-3所示，左边部分是普通的卷积网络结构，右边是直连，但如果输入和输出的通道数不一致，或其步长不为1，那么就需要有一个专门的单元将二者转成一致，使其可以相加。\n",
    "\n",
    "另外我们可以发现Residual Block的大小也是有规律的，在最开始的pool之后有连续的几个一模一样的Residual Block单元，这些单元的通道数一样，在这里我们将这几个拥有多个Residual Block单元的结构称之为layer。读者需要将这里的layer和之前讲的layer区分开来，这里的layer是几个层的集合。\n",
    "\n",
    "考虑到Residual Block和layer出现了多次，我们可以把它们实现为一个子Module或函数。这里我们将Residual Block实现为一个子module，而将layer实现为一个函数。下面是实现代码，规律总结如下：\n",
    "\n",
    "- 对于模型中的重复部分，实现为子module或用函数生成相应的module；\n",
    "- nn.Module和nn.Functional结合使用；\n",
    "- 尽量使用`nn.Seqential`。\n",
    "\n",
    "![图4-2: ResNet34网络结构](imgs/resnet1.png)\n",
    "\n",
    "![图4-3: Residual block 结构图](imgs/residual.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch import  nn\n",
    "import torch as t\n",
    "from torch.nn import  functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResidualBlock(nn.Module):\n",
    "    '''\n",
    "    实现子module: Residual Block\n",
    "    '''\n",
    "    def __init__(self, inchannel, outchannel, stride=1, shortcut=None):\n",
    "        super(ResidualBlock, self).__init__()\n",
    "        self.left = nn.Sequential(\n",
    "                nn.Conv2d(inchannel,outchannel,3,stride,1,bias=False),\n",
    "                nn.BatchNorm2d(outchannel),\n",
    "                nn.ReLU(inplace=True),\n",
    "                nn.Conv2d(outchannel,outchannel,3,1,1,bias=False),\n",
    "                nn.BatchNorm2d(outchannel) )\n",
    "        self.right = shortcut\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = self.left(x)\n",
    "        residual = x if self.right is None else self.right(x)\n",
    "        out += residual\n",
    "        return F.relu(out)\n",
    "\n",
    "class ResNet(nn.Module):\n",
    "    '''\n",
    "    实现主module：ResNet34\n",
    "    ResNet34 包含多个layer，每个layer又包含多个residual block\n",
    "    用子module来实现residual block，用_make_layer函数来实现layer\n",
    "    '''\n",
    "    def __init__(self, num_classes=1000):\n",
    "        super(ResNet, self).__init__()\n",
    "        # 前几层图像转换\n",
    "        self.pre = nn.Sequential(\n",
    "                nn.Conv2d(3, 64, 7, 2, 3, bias=False),\n",
    "                nn.BatchNorm2d(64),\n",
    "                nn.ReLU(inplace=True),\n",
    "                nn.MaxPool2d(3, 2, 1)\n",
    "        )\n",
    "        \n",
    "        # 重复的layer，分别有3，4，6，3个Residual Block\n",
    "        self.layer1 = self._make_layer(64, 64, 3, 1, is_shortcut=False)\n",
    "        self.layer2 = self._make_layer(64,  128, 4, 2)\n",
    "        self.layer3 = self._make_layer(128, 256, 6, 2)\n",
    "        self.layer4 = self._make_layer(256, 512, 3, 2)\n",
    "\n",
    "        # 分类用的全连接\n",
    "        self.classifier = nn.Linear(512, num_classes)\n",
    "    \n",
    "    def _make_layer(self, inchannel, outchannel, block_num, stride, is_shortcut=True):\n",
    "        '''\n",
    "        构建layer,包含多个residual block\n",
    "        '''\n",
    "        if is_shortcut:\n",
    "            shortcut = nn.Sequential(\n",
    "                    nn.Conv2d(inchannel,outchannel,1,stride, bias=False),\n",
    "                    nn.BatchNorm2d(outchannel))\n",
    "        else:\n",
    "            shortcut = None\n",
    "        \n",
    "        layers = []\n",
    "        layers.append(ResidualBlock(inchannel, outchannel, stride, shortcut))\n",
    "        \n",
    "        for i in range(1, block_num):\n",
    "            layers.append(ResidualBlock(outchannel, outchannel))\n",
    "        return nn.Sequential(*layers)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.pre(x)\n",
    "        \n",
    "        x = self.layer1(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "\n",
    "        x = F.avg_pool2d(x, 7)\n",
    "        x = x.view(x.size(0), -1)\n",
    "        return self.classifier(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = ResNet()\n",
    "input = t.randn(1, 3, 224, 224)\n",
    "out = model(input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "感兴趣的读者可以尝试实现一下Google的Inception网络结构或ResNet的其它变体，看看如何能够简洁明了地实现这些经典的网络结构。另外，与PyTorch配套的图像工具包`torchvision`已经实现了深度学习中大多数经典的模型，其中就包括ResNet34，读者可以通过下面两行代码使用：\n",
    "```python\n",
    "from torchvision import models\n",
    "model = models.resnet34()\n",
    "```\n",
    "关于`torchvision`的具体内容将在本书第五章进行讲解，通过torchvision我们便可以方便地使用深度学习中经典的网络模型了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 本章小结\n",
    "\n",
    "本章详细介绍了神经网络工具箱nn的使用。首先本章对神经网络中常用层结构进行了介绍，并举例说明了如何使用`nn.Module`模块来实现这些常用的层结构；其次，本章对`nn.Module`进行了深入剖析，并详细介绍了其构造函数与两种魔法方法；同时，本章还对神经网络中的初始化策略与优化器进行了详细讲解；最后，本章运用`nn.Module`模块实现了经典的ResNet网络结构。通过本章的学习，读者可以掌握神经网络工具箱中大部分类和函数的用法，并按照实际需要搭建自己的网络结构。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}