Inception.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from mxnet import autograd, nd, context, init, 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": 37,
   "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": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_acc(net, data_iter, ctx):\n",
    "    acc = 0\n",
    "    size = 0\n",
    "    for X, y in data_iter:\n",
    "        X, y = X.as_in_context(ctx), y.as_in_context(ctx)\n",
    "        result = net(X).softmax(axis=1).argmax(axis=1)\n",
    "        acc += (result==y.astype('float32')).sum().asscalar()\n",
    "        size += len(y)\n",
    "    return acc/size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_dataloader(batch_size, resize=None, shuffle=True):\n",
    "    transforms_list = []\n",
    "    if resize is not None:\n",
    "        transforms_list.append(transforms.Resize(resize))\n",
    "    transforms_list.append(transforms.ToTensor())\n",
    "    transformer = transforms.Compose(transforms_list)\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",
    "    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",
    "    return train_iter, test_iter, train, test"
   ]
  },
  {
   "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_xaxis().set_visible(False)\n",
    "    return axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class InceptionBlock(nn.Block):\n",
    "    def __init__(self, c1, c2, c3, c4, **kwargs):\n",
    "        super(InceptionBlock, self).__init__(**kwargs)\n",
    "        self.p1_1 = nn.Conv2D(c1, kernel_size=1, activation='relu')\n",
    "        \n",
    "        self.p2_1 = nn.Conv2D(c2[0], kernel_size=1, activation='relu')\n",
    "        self.p2_2 = nn.Conv2D(c2[1], kernel_size=3, padding=1, activation='relu')\n",
    "        \n",
    "        self.p3_1 = nn.Conv2D(c3[0], kernel_size=1, activation='relu')\n",
    "        self.p3_2 = nn.Conv2D(c3[1], kernel_size=5, padding=2, activation='relu')\n",
    "        \n",
    "        self.p4_1 = nn.MaxPool2D(pool_size=3, strides=1, padding=1)\n",
    "        self.p4_2 = nn.Conv2D(c4, kernel_size=1, activation='relu')\n",
    "        \n",
    "    def forward(self, x):\n",
    "        p1 = self.p1_1(x)\n",
    "        p2 = self.p2_2(self.p2_1(p1))\n",
    "        p3 = self.p3_2(self.p3_1(p2))\n",
    "        p4 = self.p4_2(self.p4_1(p3))\n",
    "        return nd.concat(p1, p2, p3, p4, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Inception(nn.Block):\n",
    "    def __init__(self, **kwargs):\n",
    "        super(Inception, self).__init__(**kwargs)\n",
    "        self.network = self.get_network()\n",
    "    def __getitem__(self, key):\n",
    "        return self.network[key]\n",
    "    def __len__(self):\n",
    "        return len(self.network)\n",
    "    def get_network(self):\n",
    "        blk = nn.Sequential()\n",
    "        \n",
    "        b1 = nn.Sequential()\n",
    "        b1.add(nn.Conv2D(64, kernel_size=7, strides=2, padding=3, activation='relu'))\n",
    "        b1.add(nn.MaxPool2D(pool_size=3, strides=2, padding=1))\n",
    "        \n",
    "        b2 = nn.Sequential()\n",
    "        b2.add(nn.Conv2D(64, kernel_size=1, activation='relu'))\n",
    "        b2.add(nn.Conv2D(192, kernel_size=3, padding=1, activation='relu'))\n",
    "        b2.add(nn.MaxPool2D(pool_size=3, strides=2, padding=1))\n",
    "        \n",
    "        b3 = nn.Sequential()\n",
    "        b3.add(InceptionBlock(64, (96, 128), (16, 32), 32))\n",
    "        b3.add(InceptionBlock(128, (128, 192), (32, 96), 64))\n",
    "        b3.add(nn.MaxPool2D(pool_size=3, strides=2, padding=1))\n",
    "        \n",
    "        b4 = nn.Sequential()\n",
    "        b4.add(InceptionBlock(192, (96, 208), (16, 48), 64))\n",
    "        b4.add(InceptionBlock(160, (112, 224), (24, 64), 64))\n",
    "        b4.add(InceptionBlock(128, (128, 256), (24, 64), 64))\n",
    "        b4.add(InceptionBlock(112, (144, 288), (32, 64), 64))\n",
    "        b4.add(InceptionBlock(256, (160, 320), (32, 128), 128))\n",
    "        b4.add(nn.MaxPool2D(pool_size=3, strides=2, padding=1))\n",
    "        \n",
    "        b5 = nn.Sequential()\n",
    "        b5.add(InceptionBlock(256, (160, 320), (32, 128), 128))\n",
    "        b5.add(InceptionBlock(384, (192, 384), (48, 128), 128))\n",
    "        b5.add(nn.GlobalAvgPool2D())\n",
    "        \n",
    "        blk.add(b1, b2, b3, b4, b5, nn.Dense(10))\n",
    "        \n",
    "        return blk\n",
    "    def forward(self, x):\n",
    "        out = self.network(x)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 4\n",
    "train_iter, test_iter, train, test = get_dataloader(batch_size, resize=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 1, 28, 28)\n",
      "(4,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 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, 2)\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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",
    "classes, class_dist = np.unique(trainY, return_counts=True)\n",
    "_, ax = plt.subplots()\n",
    "ax.bar(classes, class_dist)\n",
    "plt.show()\n",
    "testX, testY = test[:]\n",
    "classes, class_dist = np.unique(testY, return_counts=True)\n",
    "_, ax = plt.subplots()\n",
    "ax.bar(classes, class_dist)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sequential63 (1, 64, 24, 24)\n",
      "sequential64 (1, 192, 12, 12)\n",
      "sequential65 (1, 480, 6, 6)\n",
      "sequential66 (1, 832, 3, 3)\n",
      "sequential67 (1, 1024, 1, 1)\n",
      "dense9 (1, 10)\n"
     ]
    }
   ],
   "source": [
    "ctx = context.gpu()\n",
    "net = Inception()\n",
    "net.initialize(init=init.Xavier(), ctx=ctx)\n",
    "\n",
    "testX = nd.random.normal(shape=(1, 1, 96, 96), ctx=ctx)\n",
    "for i in range(len(net)):\n",
    "    layer = net[i]\n",
    "    testX = layer(testX)\n",
    "    print(layer.name, testX.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[2.3023837]\n",
      "<NDArray 1 @gpu(0)>\n"
     ]
    }
   ],
   "source": [
    "loss = gluon.loss.SoftmaxCrossEntropyLoss()\n",
    "print(loss(testX, nd.array([1]).as_in_context(ctx)).sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate':3e-5})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "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": [
    "epochs = 20\n",
    "animator = Animator(xlabel='epochs', xlim=[0, epochs], legend=['loss'])\n",
    "\n",
    "for epoch 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(epoch, (epoch_loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "acc = eval_acc(net, test_iter, ctx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9131\n"
     ]
    }
   ],
   "source": [
    "print(acc)"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}