OpenI
/
machinelearning_notebook

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# VGG\n",
    "\n",
    "计算机视觉是一直深度学习的主战场，从这里将学习近几年非常流行的卷积网络结构，网络结构由浅变深，参数越来越多，网络有着更多的跨层链接。\n",
    "\n",
    "VGG是Oxford的Visual Geometry Group的组提出的。该网络是在ILSVRC 2014上的相关工作，主要工作是证明了增加网络的深度能够在一定程度上影响网络最终的性能。VGG有两种结构，分别是VGG16和VGG19，两者并没有本质上的区别，只是网络深度不一样。当这个模型被提出时，由于它的简洁性和实用性，马上成为了当时最流行的卷积神经网络模型。它在图像分类和目标检测任务中都表现出非常好的结果。在2014年的ILSVRC比赛中，VGG 在Top-5中取得了92.3%的正确率。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CIFAR 10\n",
    "\n",
    "首先介绍一个数据集 CIFAR10，后续以此数据集为例介绍各种卷积网络的结构。\n",
    "\n",
    "CIFAR10 这个数据集一共有 50000 张训练集，10000 张测试集，两个数据集里面的图片都是 png 彩色图片，图片大小是 32 x 32 x 3，一共是 10 分类问题，分别为飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船和卡车。这个数据集是对网络性能测试一个非常重要的指标，可以说如果一个网络在这个数据集上超过另外一个网络，那么这个网络性能上一定要比另外一个网络好，目前这个数据集最好的结果是 95% 左右的测试集准确率。\n",
    "\n",
    "![](images/CIFAR10.png)\n",
    "\n",
    "\n",
    "CIFAR10 已经被 PyTorch 内置了，使用非常方便，只需要调用 `torchvision.datasets.CIFAR10` 就可以了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VGGNet\n",
    "VGGNet 是第一个真正意义上的深层网络结构，其是 ImageNet2014年的冠军，得益于 Python 的函数和循环，我们能够非常方便地构建重复结构的深层网络。\n",
    "\n",
    "VGG 的网络结构非常简单，就是不断地堆叠卷积层和池化层，下面是网络结构图：\n",
    "\n",
    "![](images/VGG_network.png)\n",
    "\n",
    "VGG整个结构只有3×3的卷积层，连续的卷积层后使用池化层隔开。虽然层数很多，但是很简洁。几乎全部使用 3 x 3 的卷积核以及 2 x 2 的池化层，使用小的卷积核进行多层的堆叠和一个大的卷积核的感受野是相同的，同时小的卷积核还能减少参数，同时可以有更深的结构。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "VGG网络的特点：\n",
    "* 小卷积核和连续的卷积层: VGG中使用的都是3×3卷积核，并且使用了连续多个卷积层。这样做的好处主要有，\n",
    "    - 使用连续的的多个小卷积核(3×3)，来代替一个大的卷积核，例如(5×5)。使用小的卷积核的问题是，其感受野必然变小。所以，VGG中就使用连续的3×3卷积核，来增大感受野。VGG认为2个连续的3×3卷积核能够替代一个5×5卷积核，三个连续的3×3能够代替一个7×7。\n",
    "    - 小卷积核的参数较少。3个3×3的卷积核参数为3×3×3=27，而一个7×7的卷积核参数为7×7=49\n",
    "    - 由于每个卷积层都有一个非线性的激活函数，多个卷积层增加了非线性映射。\n",
    "* 小池化核，使用的是2×2\n",
    "* 通道数更多，特征度更宽:  每个通道代表着一个FeatureMap，更多的通道数表示更丰富的图像特征。VGG网络第一层的通道数为64，后面每层都进行了翻倍，最多到512个通道，通道数的增加，使得更多的信息可以被提取出来。\n",
    "* 层数更深:  使用连续的小卷积核代替大的卷积核，网络的深度更深，并且对边缘进行填充，卷积的过程并不会降低图像尺寸。仅使用小的池化单元，降低图像的尺寸。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "VGG 的一个关键就是使用很多层 3 x 3 的卷积然后再使用一个最大池化层，这个模块被使用了很多次，下面照着这个结构把网络用PyTorch实现出来。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了代码的简洁和复用，可以定义一个 VGG 的 block，传入三个参数：\n",
    "* 第一个是模型层数\n",
    "* 第二个是输入的通道数\n",
    "* 第三个是输出的通道数\n",
    "\n",
    "第一层卷积接受的输入通道就是图片输入的通道数，然后输出最后的输出通道数，后面的卷积接受的通道数就是最后的输出通道数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-22T09:01:51.312500Z",
     "start_time": "2017-12-22T09:01:51.298777Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torch.autograd import Variable\n",
    "\n",
    "def VGG_Block(num_convs, in_channels, out_channels):\n",
    "    # 定义第一层\n",
    "    net = [nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), \n",
    "           nn.BatchNorm2d(out_channels),\n",
    "           nn.ReLU(True)] \n",
    "\n",
    "    for i in range(num_convs-1): # 定义后面的很多层\n",
    "        net.append(nn.Conv2d(out_channels, out_channels, \n",
    "                             kernel_size=3, padding=1))\n",
    "        net.append(nn.BatchNorm2d(out_channels))\n",
    "        net.append(nn.ReLU(True))\n",
    "        \n",
    "    net.append(nn.MaxPool2d(2, 2)) # 定义池化层\n",
    "    return nn.Sequential(*net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将模型打印出来，可以看到网络的具体结构"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-22T08:20:40.819497Z",
     "start_time": "2017-12-22T08:20:40.808853Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential(\n",
      "  (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (2): ReLU(inplace=True)\n",
      "  (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (5): ReLU(inplace=True)\n",
      "  (6): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (7): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (8): ReLU(inplace=True)\n",
      "  (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "block_demo = VGG_Block(3, 64, 128)\n",
    "print(block_demo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-22T07:52:04.632406Z",
     "start_time": "2017-12-22T07:52:02.381987Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 128, 150, 150])\n"
     ]
    }
   ],
   "source": [
    "# 首先定义输入为 (1, 64, 300, 300) (batch, channels, imgH, imgW)\n",
    "input_demo = Variable(torch.zeros(1, 64, 300, 300))\n",
    "output_demo = block_demo(input_demo)\n",
    "print(output_demo.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到输出就变为了 `(1, 128, 150, 150)` (batch, channels, imgH, imgW) ，可以看到经过了这一个 VGG block，输入大小被减半，通道数变成了 128\n",
    "\n",
    "下面我们定义一个函数对这个 VGG block 进行堆叠"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-22T09:01:54.497712Z",
     "start_time": "2017-12-22T09:01:54.489255Z"
    }
   },
   "outputs": [],
   "source": [
    "def VGG_Stack(num_convs, channels):\n",
    "    net = []\n",
    "    for n, c in zip(num_convs, channels):\n",
    "        in_c = c[0]\n",
    "        out_c = c[1]\n",
    "        net.append(VGG_Block(n, in_c, out_c))\n",
    "    return nn.Sequential(*net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "作为示例，我们定义一个稍微简单一点的 VGG 结构，其中有 8 个卷积层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-22T09:01:55.149378Z",
     "start_time": "2017-12-22T09:01:55.041923Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential(\n",
      "  (0): Sequential(\n",
      "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (2): ReLU(inplace=True)\n",
      "    (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (5): ReLU(inplace=True)\n",
      "    (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (1): Sequential(\n",
      "    (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (2): ReLU(inplace=True)\n",
      "    (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (5): ReLU(inplace=True)\n",
      "    (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (2): Sequential(\n",
      "    (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (2): ReLU(inplace=True)\n",
      "    (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (5): ReLU(inplace=True)\n",
      "    (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (3): Sequential(\n",
      "    (0): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (2): ReLU(inplace=True)\n",
      "    (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (5): ReLU(inplace=True)\n",
      "    (6): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (7): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (8): ReLU(inplace=True)\n",
      "    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "vgg_net_11 = VGG_Stack((2, 2, 3, 3, 3), \n",
    "                    ((3, 64), (64, 128), (128, 256), (256, 512), (512, 512)))\n",
    "vgg_net = VGG_Stack((2, 2, 2, 3), \n",
    "                    ((3, 64), (64, 128), (128, 256), (256, 512)))\n",
    "print(vgg_net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到网络结构中有个 5 个 最大池化，说明图片的大小会减少 5 倍。可以验证一下，输入一张 32 x 32 的图片看看结果是什么"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-22T08:52:44.049650Z",
     "start_time": "2017-12-22T08:52:43.431478Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 512, 2, 2])\n"
     ]
    }
   ],
   "source": [
    "test_x = Variable(torch.zeros(1, 3, 32, 32))\n",
    "test_y = vgg_net(test_x)\n",
    "print(test_y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到图片减小了 $2^5$ 倍，最后再加上几层全连接，就能够得到我们想要的分类输出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-22T09:01:57.323034Z",
     "start_time": "2017-12-22T09:01:57.306864Z"
    }
   },
   "outputs": [],
   "source": [
    "class VGG_Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(VGG_Net, self).__init__()\n",
    "        self.feature = VGG_Stack((2, 2, 2, 3), \n",
    "                ((3, 64), (64, 128), (128, 256), (256, 512)))\n",
    "        self.fc = nn.Sequential(\n",
    "                nn.Linear(2*2*512, 1024),\n",
    "                nn.ReLU(True),\n",
    "                nn.Dropout(),\n",
    "                nn.Linear(1024, 1024),\n",
    "                nn.ReLU(True),\n",
    "                nn.Dropout(),\n",
    "                nn.Linear(1024, 10)\n",
    "        )\n",
    "    def forward(self, x):\n",
    "        x = self.feature(x)\n",
    "        x = x.view(x.shape[0], -1)\n",
    "        x = self.fc(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后我们可以训练我们的模型看看在 CIFAR10 上的效果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-22T09:01:59.921373Z",
     "start_time": "2017-12-22T09:01:58.709531Z"
    }
   },
   "outputs": [],
   "source": [
    "from torchvision.datasets import CIFAR10\n",
    "from torchvision import transforms as tfs\n",
    "from utils import train\n",
    "\n",
    "# 使用数据变换\n",
    "def data_tf(x):\n",
    "    im_aug = tfs.Compose([\n",
    "        #tfs.Resize(224),\n",
    "        tfs.ToTensor(),\n",
    "        tfs.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])\n",
    "    ])\n",
    "    x = im_aug(x)\n",
    "    return x\n",
    "     \n",
    "train_set  = CIFAR10('../../data', train=True,  transform=data_tf)\n",
    "train_data = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)\n",
    "test_set   = CIFAR10('../../data', train=False, transform=data_tf)\n",
    "test_data  = torch.utils.data.DataLoader(test_set, batch_size=128, shuffle=False)\n",
    "\n",
    "net = VGG_Net()\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr=1e-3)\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-12-22T09:12:46.868967Z",
     "start_time": "2017-12-22T09:01:59.924086Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0] Train:(L=1.689224, Acc=0.340493), Valid:(L=1.514729, Acc=0.449664), T: 00:00:27\n",
      "[ 1] Train:(L=1.211734, Acc=0.572111), Valid:(L=1.043950, Acc=0.638944), T: 00:00:27\n",
      "[ 2] Train:(L=0.939749, Acc=0.680647), Valid:(L=0.795742, Acc=0.731408), T: 00:00:27\n",
      "[ 3] Train:(L=0.776414, Acc=0.742987), Valid:(L=0.773068, Acc=0.741792), T: 00:00:27\n",
      "[ 4] Train:(L=0.655303, Acc=0.784607), Valid:(L=0.697191, Acc=0.759296), T: 00:00:27\n",
      "[ 5] Train:(L=0.565006, Acc=0.816956), Valid:(L=0.634936, Acc=0.791436), T: 00:00:27\n",
      "[ 6] Train:(L=0.487787, Acc=0.842172), Valid:(L=0.643098, Acc=0.788766), T: 00:00:27\n",
      "[ 7] Train:(L=0.422939, Acc=0.866129), Valid:(L=0.539120, Acc=0.828323), T: 00:00:27\n",
      "[ 8] Train:(L=0.365580, Acc=0.882413), Valid:(L=0.598219, Acc=0.808248), T: 00:00:27\n",
      "[ 9] Train:(L=0.316299, Acc=0.899097), Valid:(L=0.601980, Acc=0.821005), T: 00:00:27\n",
      "[10] Train:(L=0.271955, Acc=0.914043), Valid:(L=0.664353, Acc=0.803402), T: 00:00:27\n",
      "[11] Train:(L=0.240455, Acc=0.923633), Valid:(L=0.555360, Acc=0.831191), T: 00:00:27\n",
      "[12] Train:(L=0.199894, Acc=0.937100), Valid:(L=0.514384, Acc=0.857793), T: 00:00:27\n",
      "[13] Train:(L=0.175543, Acc=0.944973), Valid:(L=0.641336, Acc=0.842860), T: 00:00:27\n",
      "[14] Train:(L=0.149222, Acc=0.953285), Valid:(L=0.600546, Acc=0.847706), T: 00:00:27\n",
      "[15] Train:(L=0.137142, Acc=0.957221), Valid:(L=0.597016, Acc=0.851958), T: 00:00:27\n",
      "[16] Train:(L=0.121605, Acc=0.962456), Valid:(L=0.638970, Acc=0.850870), T: 00:00:27\n",
      "[17] Train:(L=0.101306, Acc=0.970149), Valid:(L=0.602158, Acc=0.851760), T: 00:00:27\n",
      "[18] Train:(L=0.103552, Acc=0.970009), Valid:(L=0.619986, Acc=0.844640), T: 00:00:27\n",
      "[19] Train:(L=0.092559, Acc=0.972047), Valid:(L=0.692679, Acc=0.841772), T: 00:00:27\n"
     ]
    }
   ],
   "source": [
    "res = train(net, train_data, test_data, 20, optimizer, criterion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.plot(res[0], label='train')\n",
    "plt.plot(res[2], label='valid')\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend(loc='best')\n",
    "plt.savefig('fig-res-vgg-train-validate-loss.pdf')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(res[1], label='train')\n",
    "plt.plot(res[3], label='valid')\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('Acc')\n",
    "plt.legend(loc='best')\n",
    "plt.savefig('fig-res-vgg-train-validate-acc.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save raw data\n",
    "import numpy\n",
    "numpy.save('fig-res-vgg_data.npy', res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到，跑完 20 次，VGG 能在 CIFAR10 上取得 86% 左右的测试准确率"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 参考\n",
    "\n",
    "* [一文读懂VGG网络](https://zhuanlan.zhihu.com/p/41423739)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}