capsule-network-model-pytorch-notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "from torchvision import datasets, transforms\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "from matplotlib import pyplot as plt\n",
    "import random\n",
    "import pickle\n",
    "import csv\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.3.1'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model parameters\n",
    "\n",
    "image_dim_size = 28\n",
    "\n",
    "# Conv layer\n",
    "cl_filter_size = 9\n",
    "cl_num_filters = 256\n",
    "cl_input_channels = 1\n",
    "cl_stride = 1\n",
    "cl_output_dim = int((image_dim_size - cl_filter_size + 1) / cl_stride) # added for pedagogical purpose\n",
    "\n",
    "# Primary caps\n",
    "\n",
    "# Primary Caps are equivalent to runnning 256 conv filters (pc_caps_dim x pc_num_caps_channels) \n",
    "# of size 9x9 (pc_filter_size), with stride 2, each one with 256 input channels (pc_input_channels). \n",
    "# This leads to a 6x6x256 output volume.\n",
    "# Then each capsule comes from stacking 8 (pc_capas_dim) of these consecutive filters \n",
    "# on each pixel location. Hence, we will end with 6 x 6 x pc_num_caps_channels \n",
    "# capsules of dimension 8.\n",
    "\n",
    "pc_input_size = cl_output_dim # added for pedagogical purpose\n",
    "pc_filter_size = 9\n",
    "pc_stride = 2\n",
    "pc_caps_dim = 8\n",
    "pc_input_channels = cl_num_filters # added for pedagogical purpose\n",
    "pc_num_caps_channels = 32 \n",
    "pc_output_dim = int((pc_input_size - pc_filter_size + 1) / pc_stride) # added for pedagogical purpose\n",
    "\n",
    "# Digit caps\n",
    "dc_num_caps = 10\n",
    "dc_caps_dim = 16\n",
    "\n",
    "# Routing parameters\n",
    "iterations = 3\n",
    "\n",
    "# Regularisation\n",
    "reconst_loss_scale = 0.0005 * image_dim_size**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Capsule model\n",
    "class CapsModel(nn.Module):\n",
    "    def __init__(self, \n",
    "                 cl_input_channels, \n",
    "                 cl_num_filters, \n",
    "                 cl_filter_size, \n",
    "                 cl_stride,\n",
    "                 pc_input_channels,\n",
    "                 pc_num_caps_channels,\n",
    "                 pc_caps_dim,\n",
    "                 pc_filter_size,\n",
    "                 pc_stride,\n",
    "                 image_dim_size,\n",
    "                 dc_num_caps,\n",
    "                 dc_caps_dim,\n",
    "                 iterations,\n",
    "                 reconst_loss_scale):\n",
    "        \n",
    "        super(CapsModel, self).__init__()\n",
    "        \n",
    "        self.iterations = iterations\n",
    "        self.pc_caps_dim = pc_caps_dim \n",
    "        self.reconst_loss_scale = reconst_loss_scale\n",
    "        \n",
    "        self.conv_layer_1 = nn.Conv2d(in_channels=cl_input_channels,\n",
    "                              out_channels=cl_num_filters,\n",
    "                              kernel_size=cl_filter_size, \n",
    "                              stride=cl_stride)\n",
    "        \n",
    "        self.conv_layer_2 = nn.Conv2d(in_channels=pc_input_channels,\n",
    "                                     out_channels=pc_num_caps_channels * pc_caps_dim,\n",
    "                                     kernel_size=pc_filter_size,\n",
    "                                     stride=pc_stride)\n",
    "        \n",
    "        cl_output_dim = int((image_dim_size - cl_filter_size + 1) / cl_stride)\n",
    "        pc_output_dim = int((cl_output_dim - pc_filter_size + 1) / pc_stride)\n",
    "        self.pc_num_caps = pc_output_dim*pc_output_dim*pc_num_caps_channels\n",
    "        self.W = nn.Parameter(0.01 * torch.randn(1,\n",
    "                                            self.pc_num_caps, # We have one weight matrix for each pair of capsules in\n",
    "                                            dc_num_caps,      # primary capsules layer and digit caps layer.\n",
    "                                            dc_caps_dim,      # Each such matrix has a dimension of \n",
    "                                            pc_caps_dim))\n",
    "        \n",
    "        self.reconst_loss = nn.MSELoss()\n",
    "        \n",
    "    def forward(self, x):\n",
    "        c = F.relu(self.conv_layer_1(x))\n",
    "        u = self.conv_layer_2(c)\n",
    "        u_sliced = self.squash( u.permute(0,2,3,1).contiguous()\\\n",
    "                               .view(c.shape[0], -1, self.pc_caps_dim)).unsqueeze(-1).unsqueeze(2)\n",
    "        u_hat = torch.matmul(self.W, u_sliced).squeeze(4)  # Removing last dummy dimension, not needed anymore\n",
    "        v = self.routing(u_hat).squeeze(1)\n",
    "        return v\n",
    "    \n",
    "    def routing(self, u_hat):\n",
    "        b = torch.zeros_like( u_hat )  #b_ij parameters have the same dimension as u_hat\n",
    "        u_hat_routing = u_hat.detach()\n",
    "        for i in range(self.iterations):\n",
    "            c = F.softmax(b, dim=2)   \n",
    "            if i==(self.iterations-1):\n",
    "                s = (c*u_hat).sum(1, keepdim=True)\n",
    "            else:\n",
    "                s = (c*u_hat_routing).sum(1, keepdim=True)\n",
    "            v = self.squash(s)\n",
    "            if i < self.iterations - 1: b = (b + (u_hat_routing*v).sum(3, keepdim=True))\n",
    "        return v\n",
    "            \n",
    "    def squash(self, s):\n",
    "        s_norm = s.norm(dim=-1, keepdim=True)\n",
    "        v = s_norm / (1. + s_norm**2) * s\n",
    "        return v    \n",
    "    \n",
    "    # Defining loss function\n",
    "    def loss(self, T, v, x_true, x_reconstructed, lambda_param=0.5, m_plus=0.9, m_minus=0.1):     \n",
    "        v_norm = v.norm(dim=2, keepdim=False)\n",
    "        return (T*F.relu(m_plus - v_norm)**2 + lambda_param * (1-T)*F.relu(v_norm - m_minus)**2).sum(1).mean() \\\n",
    "                +self.reconst_loss_scale * self.reconst_loss(x_reconstructed, x_true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "    def __init__(self, dc_caps_dim, dc_num_caps, image_dim_size):\n",
    "        super(Decoder, self).__init__()\n",
    "        self.dc_num_caps = dc_num_caps\n",
    "        self.network = nn.Sequential(\n",
    "            nn.Linear(dc_caps_dim * dc_num_caps, 512),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(512, 1024),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(1024, image_dim_size**2),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "\n",
    "        \n",
    "    def forward(self, v, y_ohe):       \n",
    "        return self.network( (y_ohe[:,:,None] * v).view(v.shape[0], -1) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = CapsModel(cl_input_channels, \n",
    "                 cl_num_filters, \n",
    "                 cl_filter_size, \n",
    "                 cl_stride,\n",
    "                 pc_input_channels,\n",
    "                 pc_num_caps_channels,\n",
    "                 pc_caps_dim,\n",
    "                 pc_filter_size,\n",
    "                 pc_stride,\n",
    "                 image_dim_size,\n",
    "                 dc_num_caps,\n",
    "                 dc_caps_dim, \n",
    "                 iterations,\n",
    "                 reconst_loss_scale).cuda()\n",
    "\n",
    "decoder = Decoder(dc_caps_dim, dc_num_caps, image_dim_size,).cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CapsModel(\n",
      "  (conv_layer_1): Conv2d(1, 256, kernel_size=(9, 9), stride=(1, 1))\n",
      "  (conv_layer_2): Conv2d(256, 256, kernel_size=(9, 9), stride=(2, 2))\n",
      "  (reconst_loss): MSELoss(\n",
      "  )\n",
      ")\n",
      "Decoder(\n",
      "  (network): Sequential(\n",
      "    (0): Linear(in_features=160, out_features=512, bias=True)\n",
      "    (1): ReLU(inplace)\n",
      "    (2): Linear(in_features=512, out_features=1024, bias=True)\n",
      "    (3): ReLU(inplace)\n",
      "    (4): Linear(in_features=1024, out_features=784, bias=True)\n",
      "    (5): Sigmoid()\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "optimiser = torch.optim.Adam(list(model.parameters()) + list(decoder.parameters()), lr=0.001)\n",
    "lr_decay = torch.optim.lr_scheduler.ExponentialLR(optimiser, gamma=0.96**(1/2000.))\n",
    "\n",
    "print(model)\n",
    "print(decoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8215568"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "count_parameters(model) + count_parameters(decoder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "\n",
    "loss_train = 10     # Initialize with arbitrary high value\n",
    "epoch=0\n",
    "\n",
    "losses_train = []\n",
    "losses_val = []\n",
    "\n",
    "errors_train = []\n",
    "errors_val = []\n",
    "\n",
    "min_error = np.inf\n",
    "error_rate_batch = 1.\n",
    "\n",
    "train_sample_built = False\n",
    "\n",
    "logfile = open('log_'+version+'.csv', 'w')\n",
    "logwriter = csv.DictWriter(logfile, fieldnames=['epoch', 'train_loss', 'val_loss', 'val_error'])\n",
    "logwriter.writeheader()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
      "Processing...\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "def error_rate_calc(v_list, y_labels_list):\n",
    "    v = torch.cat(v_list)\n",
    "    y_labels = torch.cat(y_labels_list).cuda()\n",
    "    _, y_pred = v.norm(p=2, dim=2).max(dim=1)\n",
    "    return float( 1 - (y_pred == y_labels).float().mean() )\n",
    "\n",
    "def load_mnist(path='./data', download=True, batch_size=100, shift_pixels=2):\n",
    "    \"\"\"\n",
    "    Construct dataloaders for training and test data. Data augmentation is also done here.\n",
    "    :param path: file path of the dataset\n",
    "    :param download: whether to download the original data\n",
    "    :param batch_size: batch size\n",
    "    :param shift_pixels: maximum number of pixels to shift in each direction\n",
    "    :return: train_loader, test_loader\n",
    "    \"\"\"\n",
    "    kwargs = {'num_workers': 1, 'pin_memory': True}\n",
    "\n",
    "    train_loader = torch.utils.data.DataLoader(\n",
    "        datasets.MNIST(path, train=True, download=download,\n",
    "                       transform=transforms.Compose([transforms.RandomCrop(size=28, padding=shift_pixels),\n",
    "                                                     transforms.ToTensor()])),\n",
    "        batch_size=batch_size, shuffle=True, **kwargs)\n",
    "    \n",
    "    \n",
    "    test_loader = torch.utils.data.DataLoader(\n",
    "        datasets.MNIST(path, train=False, download=download,\n",
    "                       transform=transforms.ToTensor()),\n",
    "        batch_size=batch_size, shuffle=True, **kwargs)\n",
    "\n",
    "    return train_loader, test_loader\n",
    "\n",
    "train_loader, test_loader = load_mnist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 600/600 [03:30<00:00,  2.85it/s, error_rate_batch=1.74e-08]\n",
      "  0%|          | 0/600 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "104 0.0028000413991200426 0.0061471401806920765 0.0037999749183654785 0.003099977970123291 0.000272143549523252\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 600/600 [03:30<00:00,  2.86it/s, error_rate_batch=3.38e-06]\n",
      "  0%|          | 0/600 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "105 0.0027929642136829596 0.006037308797240257 0.0031999945640563965 0.003099977970123291 0.0002688310416542582\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 600/600 [03:30<00:00,  2.85it/s, error_rate_batch=8.73e-06]\n",
      "  0%|          | 0/600 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "106 0.002793144050131862 0.00596951135667041 0.0034000277519226074 0.003099977970123291 0.00026555885334603066\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 600/600 [03:30<00:00,  2.83it/s, error_rate_batch=7.78e-07]\n",
      "  0%|          | 0/600 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "107 0.0027723364140062284 0.005925637022592127 0.0034000277519226074 0.003099977970123291 0.0002623264938323448\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 79%|███████▊  | 472/600 [02:45<00:44,  2.85it/s, error_rate_batch=0.000109]"
     ]
    }
   ],
   "source": [
    "# Training loop\n",
    "while True:\n",
    "    loss_train = 0\n",
    "    with tqdm(total=len(train_loader)) as pbar:\n",
    "        for x_train, y_train in train_loader:\n",
    "          \n",
    "            # Model training\n",
    "            x_train = Variable(x_train.cuda())\n",
    "            y_train_ohe = Variable( torch.eye(10).index(y_train).cuda() )\n",
    "            \n",
    "            v = model(x_train) \n",
    "            \n",
    "            # Calculate loss and do backward step\n",
    "            loss = model.loss(y_train_ohe, v, x_train, decoder(v, y_train_ohe ) ) \n",
    "            model.zero_grad()\n",
    "            decoder.zero_grad()\n",
    "            loss.backward()\n",
    "            optimiser.step()  \n",
    "            \n",
    "            # Calculates error rate on batch\n",
    "            _, y_pred_batch = v.norm(p=2, dim=2).max(dim=1)\n",
    "            error_rate_batch = error_rate_batch*0.9 + float( 1 - (y_pred_batch.data == y_train.cuda()).float().mean() ) * 0.1\n",
    "            \n",
    "            # Performance reporting \n",
    "            loss_train += loss.data[0] \n",
    "            pbar.set_postfix(error_rate_batch=error_rate_batch)\n",
    "            pbar.update(1)\n",
    "            lr_decay.step()\n",
    "    \n",
    "    loss_train /= len(train_loader)\n",
    "    \n",
    "    # Calculates error rate and loss funciton on validation set\n",
    "    v_val_list = []\n",
    "    loss_test_list = []\n",
    "    y_test_list = []\n",
    "    for x_test, y_test in test_loader:\n",
    "        x_test = Variable(x_test.cuda())\n",
    "        y_test_ohe = Variable( torch.eye(10).index(y_test).cuda() )\n",
    "        \n",
    "        v_val_batch = model(x_test)\n",
    "        v_val_list.append(v_val_batch.data)\n",
    "        loss_test_list.append( model.loss(y_test_ohe, v_val_batch, x_test, decoder(v_val_batch, y_test_ohe)).data[0])\n",
    "        y_test_list.append(y_test)\n",
    "    \n",
    "    # Error rate: \n",
    "    v_val = torch.cat(v_val_list)\n",
    "    y_test_labels = torch.cat(y_test_list).cuda()\n",
    "    _, y_pred_test = v_val.norm(p=2, dim=2).max(dim=1)\n",
    "    error_rate = float( 1 - (y_pred_test == y_test_labels).float().mean() )\n",
    "    \n",
    "    # Calculates loss function on validation set\n",
    "    loss_val = np.mean(loss_test_list)\n",
    " \n",
    "    # Stores loss values for train and validation\n",
    "    losses_train.append(loss_train)\n",
    "    errors_train.append(error_rate_batch)\n",
    "    losses_val.append(loss_val)\n",
    "    errors_val.append(error_rate)\n",
    "    \n",
    "    # Stores model\n",
    "    if error_rate<min_error: \n",
    "        torch.save(model.state_dict(), 'model_'+version+'.pickle')\n",
    "        torch.save(decoder.state_dict(), 'decode_'+version+'.pickle')\n",
    "        min_error = error_rate\n",
    "        \n",
    "    # Print and log some results\n",
    "    print(epoch, loss_train, loss_val, error_rate, min_error, lr_decay.get_lr()[0])\n",
    "    logwriter.writerow(dict(epoch=epoch, train_loss=loss_train,\n",
    "                                val_loss=loss_val, val_error=error_rate))\n",
    "    \n",
    "    epoch += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f407f2afda0>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f407da67c18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,7))\n",
    "plt.plot(errors_val, label='Error rate test')\n",
    "plt.plot(errors_train, label='Error rate train')\n",
    "plt.plot(losses_val, label='Loss test')\n",
    "plt.plot(losses_train, label='Loss train')\n",
    "plt.ylabel('Error rate / Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylim((0,0.03))\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.00279998779296875"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Best performance in test set:\n",
    "min(errors_val)"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}