ResNet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from mxnet import nd, autograd, init, context, gluon\n",
    "from mxnet.gluon import nn\n",
    "from mxnet.gluon.data.vision import transforms\n",
    "import numpy as np\n",
    "from IPython import display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animator(object):\n",
    "    def __init__(self, xlabel=None, ylabel=None, legend=[], xlim=None,\n",
    "                 ylim=None, xscale='linear', yscale='linear', fmts=None,\n",
    "                 nrows=1, ncols=1, figsize=(3.5, 2.5)):\n",
    "        \"\"\"Incrementally plot multiple lines.\"\"\"\n",
    "        self.fig, self.axes = plt.subplots(nrows, ncols, figsize=figsize)\n",
    "        if nrows * ncols == 1: self.axes = [self.axes,]\n",
    "        # use a lambda to capture arguments\n",
    "        self.config_axes = lambda : Animator.set_axes(\n",
    "            self.axes[0], xlabel, ylabel, xlim, ylim, xscale, yscale, legend)\n",
    "        self.X, self.Y, self.fmts = None, None, fmts\n",
    "    \n",
    "    @staticmethod\n",
    "    def set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend):\n",
    "      \"\"\"A utility function to set matplotlib axes\"\"\"\n",
    "      axes.set_xlabel(xlabel)\n",
    "      axes.set_ylabel(ylabel)\n",
    "      axes.set_xscale(xscale)\n",
    "      axes.set_yscale(yscale)\n",
    "      axes.set_xlim(xlim)\n",
    "      axes.set_ylim(ylim)\n",
    "      if legend: axes.legend(legend)\n",
    "      axes.grid()\n",
    "    \n",
    "    def add(self, x, y):\n",
    "        \"\"\"Add multiple data points into the figure.\"\"\"\n",
    "        if not hasattr(y, \"__len__\"): y = [y]\n",
    "        n = len(y)\n",
    "        if not hasattr(x, \"__len__\"): x = [x] * n\n",
    "        if not self.X: self.X = [[] for _ in range(n)]\n",
    "        if not self.Y: self.Y = [[] for _ in range(n)]\n",
    "        if not self.fmts: self.fmts = ['-'] * n\n",
    "        for i, (a, b) in enumerate(zip(x, y)):\n",
    "            if a is not None and b is not None:\n",
    "                self.X[i].append(a)\n",
    "                self.Y[i].append(b)\n",
    "        self.axes[0].cla()\n",
    "        for x, y, fmt in zip(self.X, self.Y, self.fmts):\n",
    "            self.axes[0].plot(x, y, fmt)\n",
    "        self.config_axes()\n",
    "        display.display(self.fig)\n",
    "        display.clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_images(X, nrows, ncols):\n",
    "    _, axes = plt.subplots(nrows, ncols)\n",
    "    axes = axes.flatten()\n",
    "    for img, ax in zip(X, axes):\n",
    "        ax.imshow(img)\n",
    "        ax.get_xaxis().set_visible(False)\n",
    "        ax.get_yaxis().set_visible(False)\n",
    "    return axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_dataloader(batch_size, resize=None, shuffle=True):\n",
    "    transform_list = []\n",
    "    if resize is not None:\n",
    "        transform_list.append(transforms.Resize(resize))\n",
    "    transform_list.append(transforms.ToTensor())\n",
    "    transformer = transforms.Compose(transform_list)\n",
    "    \n",
    "    train = gluon.data.vision.datasets.FashionMNIST(train=True)\n",
    "    train = train.transform_first(transformer)\n",
    "    train_iter = gluon.data.DataLoader(train, batch_size, shuffle, num_workers=4)\n",
    "    \n",
    "    test = gluon.data.vision.datasets.FashionMNIST(train=False)\n",
    "    test = test.transform_first(transformer)\n",
    "    test_iter = gluon.data.DataLoader(test, batch_size, shuffle=False, num_workers=4)\n",
    "    \n",
    "    return train_iter, test_iter, train, test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Residual(nn.Block):\n",
    "    def __init__(self, num_channels, use_1x1=False, strides=1, **kwargs):\n",
    "        super(Residual, self).__init__(**kwargs)\n",
    "        self.conv1 = nn.Conv2D(num_channels, kernel_size=3, strides=strides, padding=1)\n",
    "        self.conv2 = nn.Conv2D(num_channels, kernel_size=3, padding=1)\n",
    "        if use_1x1:\n",
    "            self.conv3 = nn.Conv2D(num_channels, kernel_size=1, strides=strides)\n",
    "        else:\n",
    "            self.conv3 = None\n",
    "        self.bn1 = nn.BatchNorm()\n",
    "        self.bn2 = nn.BatchNorm()\n",
    "        \n",
    "    def forward(self, X):\n",
    "        Y = nd.relu(self.bn1(self.conv1(X)))\n",
    "        Y = self.bn2(self.conv2(Y))\n",
    "        if self.conv3:\n",
    "            X = self.conv3(X)\n",
    "        return nd.relu(X + Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResNet(nn.Block):\n",
    "    def __init__(self, num_classes, **kwargs):\n",
    "        super(ResNet, self).__init__(**kwargs)\n",
    "        self.num_classes = num_classes\n",
    "        self.network = self.get_network()\n",
    "    \n",
    "    def residual_block(self, num_channels, num_residuals, first_block=False):\n",
    "        resblk = nn.Sequential()\n",
    "        for i in range(num_residuals):\n",
    "            if i==0 and not first_block:\n",
    "                resblk.add(Residual(num_channels, use_1x1=True, strides=2))\n",
    "            else:\n",
    "                resblk.add(Residual(num_channels))\n",
    "        return resblk\n",
    "    \n",
    "    def get_network(self):\n",
    "        blk = nn.Sequential()\n",
    "        blk.add(nn.Conv2D(64, kernel_size=7, strides=2, padding=3))\n",
    "        blk.add(nn.BatchNorm())\n",
    "        blk.add(nn.Activation('relu'))\n",
    "        blk.add(nn.MaxPool2D(pool_size=3, strides=2, padding=1))\n",
    "        blk.add(self.residual_block(64, 2, first_block=True))\n",
    "        blk.add(self.residual_block(128, 2))\n",
    "        blk.add(self.residual_block(256, 2))\n",
    "        blk.add(self.residual_block(512, 2))\n",
    "        blk.add(nn.GlobalAvgPool2D())\n",
    "        blk.add(nn.Dense(self.num_classes))\n",
    "        return blk\n",
    "    def __getitem__(self, key):\n",
    "        return self.network[key]\n",
    "    def __len__(self):\n",
    "        return len(self.network)\n",
    "    def forward(self, X):\n",
    "        Y = self.network(X)\n",
    "        return Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 4\n",
    "train_iter, test_iter, train, test = get_dataloader(batch_size, resize=112, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 1, 112, 112)\n",
      "(4,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for X, y in train_iter:\n",
    "    print(X.shape)\n",
    "    print(y.shape)\n",
    "    show_images(X.squeeze(axis=1).asnumpy(), 2, 4)\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "trainX, trainY = train[:]\n",
    "unique, counts = np.unique(trainY, return_counts=True)\n",
    "_, ax = plt.subplots()\n",
    "ax.bar(unique, counts)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conv0 (1, 64, 56, 56)\n",
      "batchnorm0 (1, 64, 56, 56)\n",
      "relu0 (1, 64, 56, 56)\n",
      "pool0 (1, 64, 28, 28)\n",
      "sequential1 (1, 64, 28, 28)\n",
      "sequential2 (1, 128, 14, 14)\n",
      "sequential3 (1, 256, 7, 7)\n",
      "sequential4 (1, 512, 4, 4)\n",
      "pool1 (1, 512, 1, 1)\n",
      "dense0 (1, 10)\n"
     ]
    }
   ],
   "source": [
    "ctx = context.gpu()\n",
    "net = ResNet(10)\n",
    "net.initialize(init=init.Xavier(), ctx=ctx)\n",
    "\n",
    "x = nd.random.normal(shape=(1, 1, 112, 112), ctx=ctx)\n",
    "for i in range(len(net)):\n",
    "    layer = net[i]\n",
    "    x = layer(x)\n",
    "    print(layer.name, x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[[ 0.10520803  0.20311749 -0.13732214 -0.22264129 -0.05391912  0.01597009\n",
      "  -0.02008746  0.4184385   0.19534719  0.08831199]]\n",
      "<NDArray 1x10 @gpu(0)>\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[2.1745396]\n",
      "<NDArray 1 @gpu(0)>\n"
     ]
    }
   ],
   "source": [
    "loss = gluon.loss.SoftmaxCrossEntropyLoss()\n",
    "print(loss(x, nd.array([1]).as_in_context(ctx)).sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x180 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': 3e-4})\n",
    "epochs = 20\n",
    "animator = Animator(xlabel='epochs', xlim=[0, epochs], legend=['loss'])\n",
    "\n",
    "for i in range(epochs):\n",
    "    epoch_loss = 0\n",
    "    for X, y in train_iter:\n",
    "        X, y = X.as_in_context(ctx), y.as_in_context(ctx)\n",
    "        with autograd.record():\n",
    "            l = loss(net(X), y)\n",
    "        l.backward()\n",
    "        trainer.step(batch_size)\n",
    "        epoch_loss += l.sum().asscalar()\n",
    "    animator.add(i, (epoch_loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}