spatial_transformer_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T21:45:10.738330Z",
     "start_time": "2018-10-09T21:45:10.246532Z"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Spatial Transformer Networks Tutorial\n",
    "=====================================\n",
    "https://arxiv.org/abs/1506.02025\n",
    "\n",
    "**Author**: `Ghassen HAMROUNI <https://github.com/GHamrouni>`_\n",
    "\n",
    ".. figure:: /_static/img/stn/FSeq.png\n",
    "\n",
    "In this tutorial, you will learn how to augment your network using\n",
    "a visual attention mechanism called spatial transformer\n",
    "networks. You can read more about the spatial transformer\n",
    "networks in the `DeepMind paper <https://arxiv.org/abs/1506.02025>`__\n",
    "\n",
    "Spatial transformer networks are a generalization of differentiable\n",
    "attention to any spatial transformation. Spatial transformer networks\n",
    "(STN for short) allow a neural network to learn how to perform spatial\n",
    "transformations on the input image in order to enhance the geometric\n",
    "invariance of the model.\n",
    "For example, it can crop a region of interest, scale and correct\n",
    "the orientation of an image. It can be a useful mechanism because CNNs\n",
    "are not invariant to rotation and scale and more general affine\n",
    "transformations.\n",
    "\n",
    "One of the best things about STN is the ability to simply plug it into\n",
    "any existing CNN with very little modification.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T21:45:41.385032Z",
     "start_time": "2018-10-09T21:45:40.730823Z"
    }
   },
   "outputs": [],
   "source": [
    "# License: BSD\n",
    "# Author: Ghassen Hamrouni\n",
    "\n",
    "from __future__ import print_function\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "from torchvision import datasets, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "plt.ion()   # interactive mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loading the data\n",
    "----------------\n",
    "\n",
    "In this post we experiment with the classic MNIST dataset. Using a\n",
    "standard convolutional network augmented with a spatial transformer\n",
    "network.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T21:51:53.964501Z",
     "start_time": "2018-10-09T21:51:53.961328Z"
    }
   },
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "PATH = Path(\"data/mnist\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T21:52:47.145000Z",
     "start_time": "2018-10-09T21:52:41.462491Z"
    }
   },
   "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": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Training dataset\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    datasets.MNIST(root=PATH, train=True, download=True,\n",
    "                   transform=transforms.Compose([\n",
    "                       transforms.ToTensor(),\n",
    "                       transforms.Normalize((0.1307,), (0.3081,))\n",
    "                   ])), batch_size=64, shuffle=True, num_workers=4)\n",
    "# Test dataset\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    datasets.MNIST(root=PATH, train=False, transform=transforms.Compose([\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize((0.1307,), (0.3081,))\n",
    "    ])), batch_size=64, shuffle=True, num_workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depicting spatial transformer networks\n",
    "--------------------------------------\n",
    "\n",
    "Spatial transformer networks boils down to three main components :\n",
    "\n",
    "-  The localization network is a regular CNN which regresses the\n",
    "   transformation parameters. The transformation is never learned\n",
    "   explicitly from this dataset, instead the network learns automatically\n",
    "   the spatial transformations that enhances the global accuracy.\n",
    "-  The grid generator generates a grid of coordinates in the input\n",
    "   image corresponding to each pixel from the output image.\n",
    "-  The sampler uses the parameters of the transformation and applies\n",
    "   it to the input image.\n",
    "\n",
    ".. figure:: /_static/img/stn/stn-arch.png\n",
    "\n",
    ".. Note::\n",
    "   We need the latest version of PyTorch that contains\n",
    "   affine_grid and grid_sample modules.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T21:53:03.400004Z",
     "start_time": "2018-10-09T21:53:03.381165Z"
    }
   },
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)\n",
    "        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)\n",
    "        self.conv2_drop = nn.Dropout2d()\n",
    "        self.fc1 = nn.Linear(320, 50)\n",
    "        self.fc2 = nn.Linear(50, 10)\n",
    "\n",
    "        # Spatial transformer localization-network\n",
    "        self.localization = nn.Sequential(\n",
    "            nn.Conv2d(1, 8, kernel_size=7),\n",
    "            nn.MaxPool2d(2, stride=2),\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(8, 10, kernel_size=5),\n",
    "            nn.MaxPool2d(2, stride=2),\n",
    "            nn.ReLU(True)\n",
    "        )\n",
    "\n",
    "        # Regressor for the 3 * 2 affine matrix\n",
    "        self.fc_loc = nn.Sequential(\n",
    "            nn.Linear(10 * 3 * 3, 32),\n",
    "            nn.ReLU(True),\n",
    "            nn.Linear(32, 3 * 2)\n",
    "        )\n",
    "\n",
    "        # Initialize the weights/bias with identity transformation\n",
    "        self.fc_loc[2].weight.data.zero_()\n",
    "        self.fc_loc[2].bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float))\n",
    "\n",
    "    # Spatial transformer network forward function\n",
    "    def stn(self, x):\n",
    "        xs = self.localization(x)\n",
    "        xs = xs.view(-1, 10 * 3 * 3)\n",
    "        theta = self.fc_loc(xs)\n",
    "        theta = theta.view(-1, 2, 3)\n",
    "\n",
    "        grid = F.affine_grid(theta, x.size())\n",
    "        x = F.grid_sample(x, grid)\n",
    "\n",
    "        return x\n",
    "\n",
    "    def forward(self, x):\n",
    "        # transform the input\n",
    "        x = self.stn(x)\n",
    "\n",
    "        # Perform the usual forward pass\n",
    "        x = F.relu(F.max_pool2d(self.conv1(x), 2))\n",
    "        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))\n",
    "        x = x.view(-1, 320)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.dropout(x, training=self.training)\n",
    "        x = self.fc2(x)\n",
    "        return F.log_softmax(x, dim=1)\n",
    "\n",
    "\n",
    "model = Net().to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training the model\n",
    "------------------\n",
    "\n",
    "Now, let's use the SGD algorithm to train the model. The network is\n",
    "learning the classification task in a supervised way. In the same time\n",
    "the model is learning STN automatically in an end-to-end fashion.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T21:59:51.202719Z",
     "start_time": "2018-10-09T21:59:51.191801Z"
    }
   },
   "outputs": [],
   "source": [
    "optimizer = optim.SGD(model.parameters(), lr=0.01)\n",
    "\n",
    "\n",
    "def train(epoch):\n",
    "    model.train()\n",
    "    for batch_idx, (data, target) in enumerate(train_loader):\n",
    "        data, target = data.to(device), target.to(device)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        output = model(data)\n",
    "        loss = F.nll_loss(output, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        if batch_idx % 500 == 0:\n",
    "            print('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}'.format(\n",
    "                epoch, batch_idx * len(data), len(train_loader.dataset),\n",
    "                100. * batch_idx / len(train_loader), loss.item()))\n",
    "#\n",
    "# A simple test procedure to measure STN the performances on MNIST.\n",
    "#\n",
    "\n",
    "\n",
    "def test():\n",
    "    with torch.no_grad():\n",
    "        model.eval()\n",
    "        test_loss = 0\n",
    "        correct = 0\n",
    "        for data, target in test_loader:\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            output = model(data)\n",
    "\n",
    "            # sum up batch loss\n",
    "            test_loss += F.nll_loss(output, target, reduction='sum').item()\n",
    "            # get the index of the max log-probability\n",
    "            pred = output.max(1, keepdim=True)[1]\n",
    "            correct += pred.eq(target.view_as(pred)).sum().item()\n",
    "\n",
    "        test_loss /= len(test_loader.dataset)\n",
    "        print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'\n",
    "              .format(test_loss, correct, len(test_loader.dataset),\n",
    "                      100. * correct / len(test_loader.dataset)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualizing the STN results\n",
    "---------------------------\n",
    "\n",
    "Now, we will inspect the results of our learned visual attention\n",
    "mechanism.\n",
    "\n",
    "We define a small helper function in order to visualize the\n",
    "transformations while training.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-09T22:04:13.923502Z",
     "start_time": "2018-10-09T21:59:55.382950Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 1 [0/60000 (0%)]\tLoss: 0.035717\n",
      "Train Epoch: 1 [32000/60000 (53%)]\tLoss: 0.109540\n",
      "\n",
      "Test set: Average loss: 0.0517, Accuracy: 9832/10000 (98%)\n",
      "\n",
      "Train Epoch: 2 [0/60000 (0%)]\tLoss: 0.080898\n",
      "Train Epoch: 2 [32000/60000 (53%)]\tLoss: 0.204540\n",
      "\n",
      "Test set: Average loss: 0.0426, Accuracy: 9864/10000 (99%)\n",
      "\n",
      "Train Epoch: 3 [0/60000 (0%)]\tLoss: 0.097305\n",
      "Train Epoch: 3 [32000/60000 (53%)]\tLoss: 0.265147\n",
      "\n",
      "Test set: Average loss: 0.0413, Accuracy: 9871/10000 (99%)\n",
      "\n",
      "Train Epoch: 4 [0/60000 (0%)]\tLoss: 0.065420\n",
      "Train Epoch: 4 [32000/60000 (53%)]\tLoss: 0.072670\n",
      "\n",
      "Test set: Average loss: 0.0412, Accuracy: 9876/10000 (99%)\n",
      "\n",
      "Train Epoch: 5 [0/60000 (0%)]\tLoss: 0.036897\n",
      "Train Epoch: 5 [32000/60000 (53%)]\tLoss: 0.021485\n",
      "\n",
      "Test set: Average loss: 0.1098, Accuracy: 9683/10000 (97%)\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def convert_image_np(inp):\n",
    "    \"\"\"Convert a Tensor to numpy image.\"\"\"\n",
    "    inp = inp.numpy().transpose((1, 2, 0))\n",
    "    mean = np.array([0.485, 0.456, 0.406])\n",
    "    std = np.array([0.229, 0.224, 0.225])\n",
    "    inp = std * inp + mean\n",
    "    inp = np.clip(inp, 0, 1)\n",
    "    return inp\n",
    "\n",
    "# We want to visualize the output of the spatial transformers layer\n",
    "# after the training, we visualize a batch of input images and\n",
    "# the corresponding transformed batch using STN.\n",
    "\n",
    "\n",
    "def visualize_stn():\n",
    "    with torch.no_grad():\n",
    "        # Get a batch of training data\n",
    "        data = next(iter(test_loader))[0].to(device)\n",
    "\n",
    "        input_tensor = data.cpu()\n",
    "        transformed_input_tensor = model.stn(data).cpu()\n",
    "\n",
    "        in_grid = convert_image_np(\n",
    "            torchvision.utils.make_grid(input_tensor))\n",
    "\n",
    "        out_grid = convert_image_np(\n",
    "            torchvision.utils.make_grid(transformed_input_tensor))\n",
    "\n",
    "        # Plot the results side-by-side\n",
    "        f, axarr = plt.subplots(1, 2)\n",
    "        axarr[0].imshow(in_grid)\n",
    "        axarr[0].set_title('Dataset Images')\n",
    "\n",
    "        axarr[1].imshow(out_grid)\n",
    "        axarr[1].set_title('Transformed Images')\n",
    "\n",
    "\n",
    "for epoch in range(1, 5 + 1):\n",
    "    train(epoch)\n",
    "    test()\n",
    "\n",
    "# Visualize the STN transformation on some input batch\n",
    "visualize_stn()\n",
    "\n",
    "plt.ioff()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OCR Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SpatialTransformer(nn.Module):\n",
    "    def __init__(self, n_in, n_out, k1, k2, h, w=None):\n",
    "        super(SpatialTransformer, self).__init__()\n",
    "        if not w: w = h\n",
    "        \n",
    "        # Spatial transformer localization-network\n",
    "        self.localization = nn.Sequential(\n",
    "            nn.Conv2d(n_in, n_out, kernel_size=k1, padding=k1//2),\n",
    "            nn.MaxPool2d(2, stride=2),\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(n_out, n_out, kernel_size=k2, padding=k2//2),\n",
    "            nn.MaxPool2d(2, stride=2),\n",
    "            nn.ReLU(True)\n",
    "        )\n",
    "\n",
    "        # Regressor for the 3 * 2 affine matrix\n",
    "        self.fc_loc = nn.Sequential(\n",
    "            nn.Linear(n_out * w * h, n_out),\n",
    "            nn.ReLU(True),\n",
    "            nn.Linear(n_out, 6)\n",
    "        )\n",
    "        # Attention: only need 3 outputs\n",
    "        # [[s,0,tx],\n",
    "        #  [0,s,ty]]\n",
    "\n",
    "        # Initialize the weights/bias with identity transformation\n",
    "        self.fc_loc[2].weight.data.zero_()\n",
    "        self.fc_loc[2].bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float))\n",
    "\n",
    "    # Spatial transformer network forward function\n",
    "    def forward(self, x):\n",
    "        xs = self.localization(x)\n",
    "        xs = xs.flatten(1,-1)\n",
    "        theta = self.fc_loc(xs)\n",
    "        theta = theta.view(-1, 2, 3)\n",
    "        \n",
    "        grid = F.affine_grid(theta, x.size())\n",
    "        x = F.grid_sample(x, grid)\n",
    "\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "self.stn = SpatialTransformer(3,32,7,5,32)\n",
    "x = self.stn(x)"
   ]
  }
 ],
 "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.5"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}