04_Spatial_Transformer_Networks.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torchvision import datasets, transforms\n",
    "\n",
    "\n",
    "def load_data():\n",
    "    \"\"\"loads MNIST datasets with 'RTS' (rotation, translation, scale)\n",
    "    transformation\n",
    "\n",
    "    Returns:\n",
    "        train_dataset (torch dataset): training dataset\n",
    "        test_dataset (torch dataset): test dataset\n",
    "    \"\"\"\n",
    "    def place_digit_randomly(img):\n",
    "        new_img = torch.zeros([42, 42])\n",
    "        x_pos, y_pos = torch.randint(0, 42-28, (2,))\n",
    "        new_img[y_pos:y_pos+28, x_pos:x_pos+28] = img\n",
    "        return new_img\n",
    "        \n",
    "    transform = transforms.Compose([\n",
    "        transforms.RandomAffine(degrees=(-45, 45), \n",
    "                                scale=(0.7, 1.2)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Lambda(lambda img: place_digit_randomly(img)),\n",
    "        transforms.Lambda(lambda img: img.unsqueeze(0))\n",
    "    ])\n",
    "    train_dataset = datasets.MNIST('./data', transform=transform, \n",
    "                                   train=True, download=True)\n",
    "    test_dataset = datasets.MNIST('./data', transform=transform, \n",
    "                                   train=True, download=True)\n",
    "    return train_dataset, test_dataset\n",
    "\n",
    "\n",
    "train_dataset, test_dataset = load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA94AAACaCAYAAABfTJDMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAa3klEQVR4nO3de7jVY97H8c9NbIQKIyJ6ZiJlnBtjnK5iHhJpqJnpIB4ZxiQjFOlwTVfJcRJNhjAzxiM0gwymyGGGkBEmJufEQ6WjsAud3M8fa6+ve7fXbu/9a9/rtw7v13V1+Vz3+u21vtfMvdda9/59f/fPee8FAAAAAADi2CLtAgAAAAAAKGUsvAEAAAAAiIiFNwAAAAAAEbHwBgAAAAAgIhbeAAAAAABExMIbAAAAAICImmzqQecc9xorYd57F+u5mTuljbmDpJg7SIq5g6SYO0iKuYOkcs0dzngDAAAAABARC28AAAAAACJi4Q0AAAAAQEQsvAEAAAAAiIiFNwAAAAAAEbHwBgAAAAAgIhbeAAAAAABExMIbAAAAAICIWHgDAAAAABARC28AAAAAACJi4Q0AAAAAQEQsvAEAAAAAiIiFNwAAAAAAEbHwBgAAAAAgIhbeAAAAAABE1CTtAsrFFVdcYXnEiBGWDzvsMEnS22+/nfeaAAAAAADxccYbAAAAAICIWHgDAAAAABCR897X/qBztT+IOu25556WX3vtNcstWrSw/Lvf/U6SdNFFF+WvsCreexfruZk7pY25g6SYO0iKuYOkmDtIirmDpHLNHc54AwAAAAAQEQtvAAAAAAAiotU8orDV/KOPPrK8Zs0ay8ccc0yNn3v55ZfjFlaF9hkkxdxBUswdJMXcQVLMHSTF3EFStJoDAAAAAJBnLLwBAAAAAIioSdoFlLLmzZvnHF++fLnlqVOnSpJat26dl5oAAAAAAPnFGW8AAAAAACJi4Q0AAAAAQERl02q+6667Wl66dGmKlUh77LGH5YULF6ZYCQAAAAAgNs54AwAAAAAQUcmf8e7du7ckaeLEiTZ200035Tx29OjRjfra3bp1szx8+HDLY8eOtbxq1apGfU0AAAAAQGHhjDcAAAAAABGx8AYAAAAAIKKSbzXv0KGDJKlFixY2NmrUKMvjxo2L9tpXX3215QcffDDa6wAAAAAAChdnvAEAAAAAiIiFNwAAAAAAEZV8q/nIkSMlSfvvv7+N/eQnP8nLa++2226WjznmmJzHPProo3mpBUDh2GabbSx3797d8pQpUywPHDjQcnhXBgAANrZ+/XrLnTp1snz55Zdb7tOnj+XKysoaz/HMM89YvueeeyxPmjSpscoEGmzo0KGWw0t3d9llF8uLFy/O+bPz58+PV1gCnPEGAAAAACAiFt4AAAAAAETkvPe1P+hc7Q8WmWXLllneeeedLXfp0sXyjBkzGvU1O3bsaPmll17KecyAAQMkSbfeemujvnZ9eO9drOcupbmDmpg7DffDH/7Qcq9evSwPGjTI8oIFCyy3atXK8tSpUyVJ2223nY117do1Sp2xMXeQFHMHSZXa3Mn13X1T3+dzWb58ueW33npLUvXLIsPvzS1btmxoiSWj1OZOsejWrZvl8DK8ioqKBj3PkiVLJFX/TpUvueYOZ7wBAAAAAIiIhTcAAAAAABGV/K7mbdq0qTG2cOFCy7NmzYr22k2a1P0/73/+8x9J0rbbbpvz8a+++qpRawKQP9kWcan67uWvvvqq5fbt21v+6U9/ajncXfa+++6r8dzTpk2z/Pzzz1seO3bsZlQMAChEdbWXjxs3zvKll15qecyYMZaHDRtmOdwROtedd8LLMoGYTjnlFMvZ3fSbNm3aoOd4+OGHLZ966qmWr7jiis2srnFxxhsAAAAAgIhYeAMAAAAAEFHJ72o+YcIESdLAgQNtLGw1b926dbTX/utf/2q5R48e9f65OXPmWD700EMbtaYQOzUiKeZO/cyePdvyYYcdZvmcc86x/Kc//anO59ljjz0kVX/vGjVqlOXddtvN8ujRoy0vWrSoYQXnAXMHSTF3kFQxzZ3avpfnGu/QoUPOYz/44APLa9asyXlMOL7VVltJkj788EMbu/baay1PmjSp9oJLXDHNnWIyfPhwy4MHD7a84447SpIOOeQQG7vwwgst9+/f33Lfvn0tP/TQQ5ZXr15t+d1335VU/bK+fGFXcwAAAAAA8oyFNwAAAAAAEZXkruZh2+UZZ5xR4/HHHnssn+XUS1jTWWedlWIlAJJo27at5RNPPFFS9fby8LKR8HKSI4880vILL7yQ87nDFvOssNU8dNlll1m+7rrrch6TfY9cvHhxzsdR3Pbbbz/Lb7/9doqVAKhNq1atLIffVWtrNc/VVt7Q3+/TTjvNcq9evSw/8MADkqrvDP3EE0806LmBuoQt4Ntss03OY3bddVdJ0ooVK2zs3HPPzZnr48svv2zQ8bFxxhsAAAAAgIhK8oz3vvvua7l58+Y1Hr///vsb9fWyf52Rqm9s1LNnT8u1/QXz3nvvlST169fPxr755ptGrQ9A4wnPIs+bN89y+Lv/4osv1vi5P/7xj5Zbtmxpeffdd7f8y1/+0vKxxx5r+YILLpBU/YxH+BrZjXE2ri98nblz51oeMmSIJOnOO++sUSeKUzg3wnu8ZzcQ3WKLb//O/uMf/9jyU089lYfqAGzs0UcftXzwwQdbDjePCt/nk3avhL/72TPbG7vllltqjM2fPz/R6wHhd4/f/OY3lsOz3E8//bTln/3sZ5ZXrlyZ6DU3bNiQc5wz3gAAAAAAlBEW3gAAAAAARFSSreY///nPa4wtWLDActi606xZM8uff/55zufL3kNXks4///waY+HrbbvttpZray8PNxfItqfSXh5f2F4ZbmJVWxvKzjvvLKn6Bg8obUcccYTlGTNmWG7S5Nu3ygkTJljOvh9I0gEHHGC5Xbt2kqQvvvjCxnJt9ChJAwYMsBzeKzVst/r0008lVW8Z/Mtf/mL5qKOOsjxw4EDLV155peXwfSd7DK3mpWOvvfaynG0vD4WfMV26dLFMq3n5CO+FO2LECMthWyjyJ/x8+Oyzzyw3xvtyeAnT0KFD6zz+qquukiR98sknm/3aKE/h50q4Sd+SJUssh5fmrl271nJlZWWj1jJ58mTL4SV8hYAz3gAAAAAARMTCGwAAAACAiEqy1Ty8j3fW448/bvm3v/2t5frcDy7cSbJp06Y1Hn/nnXcsv/vuuzmfo1u3bjnHw59F4/j73/9uOdsuLtW+2/2aNWssV1RU1Hi+m2++2XLYqofSc80111jefvvtLYdtSx988IHlzp07W95zzz0t/+tf/5IkDRs2LOfrhDuWh619u+yyi+Vse7kknXrqqZKkJ5980sbCeX7ppZdanjhxouXsbuiS1L59e8vXXnttzrpQXMId7BvSIhq2+6F8jB8/Puf4bbfdZjl8f7v66quj14SM4447rlGfL7zTRXiZXXjJ0TnnnGN54cKFjfr6KB/HH3+8pOrfSULhJW+NcelmuDP6V199ZTm8nOrf//53zmMKAWe8AQAAAACIiIU3AAAAAAARlWSreadOnWqMhS01I0eOtBzuQt6vXz/Ll1xySc7nzu4Ae8cdd9jYI488kvPY7I7lGwtbudB47rrrLknSSSed1KCfC3eyHjdunOXsPArbddu2bWu5oa+Dwhe2d0+fPt1y3759c+brr78+5/M888wzkqrv8lmb999/v85jwh1Cs8LWxPAOCuFu53U9B4rDlltuaXnDhg2Ww8+S8BKDXMKdXcPPL5S2xx57rM5j+vfvv8nHaTlvPK1atbL80UcfWQ53fg6FLePr1q2r9+u88sorlsNL7sLvq3Pnzq338wGh8DNp0KBBNR7v0aOH5YceeqhRX/vggw+2HLaXT5s2zXJtl9UUAs54AwAAAAAQEQtvAAAAAAAiKslW87Ct5r333pMkfe9737OxIUOGWA53qW7ITq9Tpkyp85iwjR3xnXnmmZKkU045xcbC3ctDkyZNsjxq1CjLP/jBDyxvsUXNv0uFO3+G//8W2q6JSOb000/POR7u1jlnzhzL4W7i4Y7ov/rVryR9u9unJH388ceW582bt9m1hu3lKD3bbbed5bA9dPbs2ZYvvvhiy+F8eOCBByz36dNHUvUWdZSPe++917JzznL43lSbESNGSKLVvDGFd8tYv3695VmzZlkOv5+Ed9UJZe/ec8stt9hY7969Ld95552Ww8+p8L3hzTffrFHXqlWrbCycLyE+e3DZZZdZ7tq1a43HG6O9PFzL3XfffZbDy+zC36FiuVsLZ7wBAAAAAIiIhTcAAAAAABG5TbWMOOeKvp8k22q+11572Vi4S2Ro+fLllmfOnGn5hhtuqHFs2G66evXqnM938803W862nkrVd5I88MADa609Nu997j6iRlAocye8lGDw4MGWJ0yYYHngwIGW995770Sv0717d8u17XJfSsph7tRHmzZtLH/44YeW27VrJ0l655138lxR4WPu1E94N4Xw/Wrt2rWWw7bzY4891nK4c/KiRYtilZh3zJ3G8/jjj1uuq+08bDmurKy0XNulXIWo0OfOsmXLLIcttqGlS5da3mGHHSRJv/jFL2xs8uTJDXrNlStXWs7eDaN9+/Y2Fr6nNGvWLGd94edeqSr0uZOG8I4u2btAjRkzxsbCSzhD4XtGeGegcKfyl19+WVL1Sy7CXdSPPPJIy2+88UZDS8+rXHOHM94AAAAAAETEwhsAAAAAgIhKvtU8uyvnyJEjbey6666zHO7g+Oc//9ny4sWLN/u1s23uUvVd1Wk1L1yHH3645ezu9+HuwmFrTOi8886zfMcdd0SqrnAwd5AUc2fTxo4dK0kaOnRozsevvPJKy2F76sSJE+MWVgCYO3GEbeehbAt62GoefmcMvz+FCrEFvdDnTtgyftttt1m+//77Lffs2dNytu28IXfjiaFt27aW58+fn2Il8RT63ElD9lIHSfrss8/q/XPh5Q0tWrTIeUz28t1hw4bZWHhHoalTp9b79dJGqzkAAAAAAHlW8me8s8KL8cOzluGZ8Ma2YsUKy+Ffdl599dUax3bs2DFaHbXhr3g1HXTQQZafe+45SVLTpk1zHltRUWF53bp1cQsrMMwdJMXcqenkk0+2fPvtt0uSWrZsmfPYs88+2/Jdd90Vt7ACw9zJrxkzZkiqfpa7Pvf/vuiiiyyfcMIJlsNNSPOtmOZO2GUXbgYcbnaW7Ta48cYbbeyAAw7I+XwbNmyw/Le//c1y2FWTvS/zW2+9ZWPjxo2rs1bOeG+eUnrfmT59uuXw9z7sqAk3+ww3Aww7N6ZMmRKrxLzjjDcAAAAAAHnGwhsAAAAAgIjKptU8DbW1moeyre7ZDXXyifaZjPA+lOH93rPCe2eGbXZvvvmm5U39HpUi5g6SYu5kjB492nL4vnLEEUfUOHannXay/Pnnn8ctrIAxd9L3xRdfWA5bomsTboq09957R6mpPsph7vTr189yuFnwhAkTLA8aNMhy+F4ze/ZsSdU30gt9/PHHlsPLYMLNssJL9RYsWNCg2gtZOcydxtamTRvL4dwJL3soB7SaAwAAAACQZyy8AQAAAACIqEnaBZSL8B6rrVu3thzuAojN06tXL0nS/vvvb2Nh61O4s324U3m4O/n48eMtZ3cLDdtkACCpsP0u3J28VatWlrP3MD333HNtrEmTbz+qL774YsvhLsLhbsVAY8heItelSxcbCz8P27Vrl/eaULujjjrKcngv8F//+tc5j3/66actZ9vOv/76axurrb081KNHD8ul1F6OzRNewonqOOMNAAAAAEBELLwBAAAAAIiIXc3zJNxVsra2n3wr1p0at9ji278XffPNN5ZnzpwpSTr66KNtrLb5He7M2rt37xrPIUmrVq3a/GJLVLHOHaSv3ObO4YcfbnnWrFl1Hv/KK69Ikrbaaisb69Chg+Ww7Tx8fxsyZIjlwYMHW86+X+6+++4NKbsgldvcienEE0+0PG3aNMtr1661HM7BhiiUncxD5TZ3unXrZjm8DCX8LnryySdbfv311yVVv8NCaPvtt7cc3rGnthb0UlJucweNh13NAQAAAADIMxbeAAAAAABERKt5GSum9plwF/LKysp6/1zHjh0tZ1upJGn9+vWNU1iZKqa5g8JSbnMnfO8KL3Gpze233y6p+l0YwvbfQw45JFEdc+fOtdy9e3fLxbT7bLnNnaSaNWtm+e6777YctguH3/06d+5secOGDYle8/TTT7f88MMPJ3qOmMp57tx6662WzzvvPMtLliyxXFfL+IABA3I+Xzko57mDzUOrOQAAAAAAecbCGwAAAACAiJrUfQiQvtWrV1sOdzXv2bOn5eyOwYsWLcp5bNIWOgBIKnzvuueeeyz36dMn5/H77ruvJKlNmzY29uWXX252HVtvvbXldevWbfbzofAsX75cktS8efM6j3Xu2w7I8LMxHM+aN29ezmO7du1quZguWSg38+fPt5ydI1LDdiQfPny45XJrNQcaE2e8AQAAAACIiIU3AAAAAAARsat5GWOnRiTF3EFS5TZ3sq3jkvTss89a/s53vpPXOqZMmWJ50KBBlpcuXZrXOjZHuc2d+pgxY4bl4447rt4/F7aU1/Y9sKKiQlJpXKbF3Knp0EMPtZydD5dccomN9e3bN+81FSLmDpJiV3MAAAAAAPKMM95ljL/iISnmDpJi7mQkPYv43nvvWd5nn30sz5kzx3L//v0td+rUSZI0efJkGws3WComzJ2MxjjLHZ7ZnD59uuXKykrLn3zySdISCw5zB0kxd5AUZ7wBAAAAAMgzFt4AAAAAAETEfbwBAMizLbfccpOPDxw40HLYJr527VrL48aNsxzeZ3fFihWWX3vttc2qE8Vt2bJlllu3bm15/fr1aZQDAGWNM94AAAAAAETEwhsAAAAAgIjY1byMsVMjkmLuICnmDpJi7mS8/vrrljt06GD5wgsvlCTNnDnTxubOnZu/wgoYcwdJMXeQFLuaAwAAAACQZyy8AQAAAACIiFbzMkb7DJJi7iAp5g6SYu4gKeYOkmLuIClazQEAAAAAyDMW3gAAAAAARMTCGwAAAACAiFh4AwAAAAAQEQtvAAAAAAAiYuENAAAAAEBELLwBAAAAAIiIhTcAAAAAABGx8AYAAAAAICIW3gAAAAAARMTCGwAAAACAiFh4AwAAAAAQEQtvAAAAAAAiYuENAAAAAEBELLwBAAAAAIiIhTcAAAAAABGx8AYAAAAAICIW3gAAAAAARMTCGwAAAACAiJz3Pu0aAAAAAAAoWZzxBgAAAAAgIhbeAAAAAABExMIbAAAAAICIWHgDAAAAABARC28AAAAAACJi4R1wzj3mnPPOuSvTrgWFzznX2Tn3nHPuK+fcp865/3XOtUy7LhQ+59xRzrkZzrmlzrlK59yrzrn+adeF4uCc6+qce9Y5t8o594Vz7mXn3HFp14XC5Zz7Z9X3m1z/Hku7PhQuPq+QlHOutXPufufc51WfVQ865/ZKu640NUm7gELhnOst6aC060BxcM4dI2mGpMcl9ZC0s6QrJT3lnDvMe78mzfpQuJxzB0p6UtKLks6V9KWknpL+4Jyr8N7fkmZ9KGzOuV9Kmlj1b4wyf0A/WNJ2adaFgjdA0o4bjf1I0g2SHs5/OSgGfF4hKefcdpKelrRG0lmSvDLfk//hnDvQe786zfrSwn28JTnnWkh6S9LFku6RNNZ7PyLdqlDInHNPSmojaT/v/fqqsY6SZku6wHv/+xTLQwFzzl0labCknbz3q4LxWZLkvf9RWrWhsDnn2ijzWXWF9/7GdKtBsXPO/UHSGZJ2995/mnY9KDx8XiEp59xFyvxhr533fl7V2H9Jek/SZd77G9KsLy20mmdcK2mu9/7etAtB0ThC0hPZRbckee9flrRC0mmpVYVisLWkdZK+2mj8c/GejE3rL+kbSbemXQiKW9XZqJ9KeoRFNzaBzyskdaqkF7OLbkny3n8g6XlJ3VOrKmVl/0vjnDta0pmSLki7FhSVDZLW5hhfI+n7ea4FxeXOqv9OcM61cs41d86dK+l4SePTKwtF4GhJb0vq5Zx73zm33jk3zznH5xca6jRJO0j6c9qFoKDdWfVfPq/QUPtLmptj/A1JHfJcS8Eo62u8nXNbS5ok6bfe+3fSrgdF5R1lznob59zeknZX5q/DQE7e+7nOuU6Spipz3aWUmTPne+/vS60wFINWVf+ulzRM0vvKnLWc6Jxr4r2/Kc3iUFTOlLRU0vS0C0Hh4vMKm2EnSStzjH8qqUWeaykYZb3wlnSZpG0ljU27EBSdmyTdXbUD/gRl3mBuU6YN9Js0C0Nhc87tI+kBZf7qe74yLXzdJd3qnPvaez85zfpQ0LZQ5izl/3jvH6wae7rq2u8rnHMTPBu3oA7OuVaSfizppvByKWBjfF4BjatsF95V29kPl/QLSRXOuYrg4QrnXHNJld77DakUiILmvZ/snNtPmU1HhiuzW+MUSdNEqzk27Splzhic4r3Pdkc85ZzbWdJNzrl7vff88Qa5rJC0j6QnNhqfIamLMh03i/JdFIrOGcr8EYc2c9SFzysktVK5z2zXdia8LJTzNd7flbSNpLuVmQDZf1JmMbVS0gHplIZi4L0fKWkXSQcqsytsb2W+FD+XamEodAdIei34EpP1kjK3pds1/yWhSLxRx+N8AUZ9nKXMe9BraReCgsfnFZJ6Q5nrvDfWQdKbea6lYJTzwnuOpM45/kmZxXhnSfNy/yiQ4b1f7b3/j/d+iXOui6T9xI7D2LTFkg6u2mMi9ENJXytz/ROQy9Sq/5640XgXSQu894vzXA+KTNVtLzuIs92oHz6vkNTDko5wzn03O1B1WdRRVY+VpbJtNffefybpnxuPO+ck6f+89zUeA7Kcc4dIOknSq1VDR0saIuk67/0LqRWGYjBR0l8lPeKc+70y18ydKqm3pPHe+1y75QNS5lKWf0ia5JzbRdJ8ZTZXO0HS2WkWhqJxpqT1krg2F/XB5xWSul3SQEl/c86NUOaSzDGSPlZmY+uy5NiHpTrnnJc01ns/Iu1aULicc/sr88bxfUkVkt6S9Dvv/Z9SLQxFwTl3kqTLlWnD2kaZ3alvkzSJfSWwKc65HSVdLamnMtfPvS3pGu/9PakWhoLnnNtKmT0AXvTed0u7HhQHPq+QVNV+WuMl/bckJ+kpSYO89x+mWVeaWHgDAAAAABBROV/jDQAAAABAdCy8AQAAAACIiIU3AAAAAAARsfAGAAAAACAiFt4AAAAAAETEwhsAAAAAgIhYeAMAAAAAEBELbwAAAAAAImLhDQAAAABARP8PZAGwzdtVOIgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1260x180 with 7 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "train_dataset, test_dataset = load_data()\n",
    "\n",
    "n_samples = 7\n",
    "fig = plt.figure(figsize=(n_samples*2.5, 2.5))\n",
    "i_samples = np.random.choice(range(len(train_dataset)), \n",
    "                             n_samples, replace=False)\n",
    "for counter, i_sample in enumerate(i_samples):\n",
    "    img, label = train_dataset[i_sample]\n",
    "    \n",
    "    plt.subplot(1, n_samples, counter + 1)\n",
    "    plt.imshow(transforms.ToPILImage()(img), cmap='gray')\n",
    "    plt.axis('off')\n",
    "    plt.title(str(label), fontsize=16, y=-0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CNN has 112052 trainable parameters\n",
      "ST-CNN Affine has 110478 trainable parameters\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "def get_number_of_trainable_parameters(model):\n",
    "    \"\"\"taken from\n",
    "    discuss.pytorch.org/t/how-do-i-check-the-number-of-parameters-of-a-model/4325\n",
    "    \"\"\"\n",
    "    model_parameters = filter(lambda p: p.requires_grad, model.parameters())\n",
    "    params = sum([np.prod(p.size()) for p in model_parameters])\n",
    "    return params\n",
    "\n",
    "\n",
    "class CNN(nn.Module):\n",
    "    \n",
    "    def __init__(self, img_size=42, include_ST=False):\n",
    "        super(CNN, self).__init__()\n",
    "        self.ST = include_ST\n",
    "        self.name = 'ST-CNN Affine' if include_ST else 'CNN'\n",
    "        c_dim = 32 if include_ST else 36\n",
    "        self.convs = nn.Sequential(\n",
    "            nn.Conv2d(1, c_dim, kernel_size=9, stride=1, padding=0),\n",
    "            nn.MaxPool2d(kernel_size=(2,2), stride=2),\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(c_dim, c_dim, kernel_size=7, stride=1, padding=0),\n",
    "            nn.MaxPool2d(kernel_size=(2,2), stride=2),\n",
    "            nn.ReLU(True),\n",
    "        )\n",
    "        out_conv = int((int((img_size - 8)/2) - 6)/2)\n",
    "        self.classification = nn.Sequential(\n",
    "            nn.Linear(out_conv**2*c_dim, 50),\n",
    "            nn.ReLU(True),\n",
    "            nn.Linear(50, 10),\n",
    "            nn.LogSoftmax(dim=1),            \n",
    "        )\n",
    "        if include_ST:\n",
    "            loc_conv_out_dim = int((int(img_size/2) - 4)/2) - 4\n",
    "            loc_regression_layer = nn.Linear(20, 6)\n",
    "            # initalize final regression layer to identity transform\n",
    "            loc_regression_layer.weight.data.fill_(0)\n",
    "            loc_regression_layer.bias = nn.Parameter(\n",
    "                torch.tensor([1., 0., 0., 0., 1., 0.]))\n",
    "            self.localisation_net = nn.Sequential(\n",
    "                nn.Conv2d(1, 20, kernel_size=5, stride=1, padding=0),\n",
    "                nn.MaxPool2d(kernel_size=(2,2), stride=2),\n",
    "                nn.ReLU(True),\n",
    "                nn.Conv2d(20, 20, kernel_size=5, stride=1, padding=0),\n",
    "                nn.ReLU(True),\n",
    "                nn.Flatten(),\n",
    "                nn.Linear(loc_conv_out_dim**2*20, 20),\n",
    "                nn.ReLU(True),\n",
    "                loc_regression_layer\n",
    "            ) \n",
    "        return\n",
    "    \n",
    "    def forward(self, img):\n",
    "        batch_size = img.shape[0]\n",
    "        if self.ST:\n",
    "            out_ST = self.ST_module(img)\n",
    "            img = out_ST\n",
    "        out_conv = self.convs(img)\n",
    "        out_classification = self.classification(out_conv.view(batch_size, -1))\n",
    "        return out_classification\n",
    "      \n",
    "    def ST_module(self, inp):\n",
    "        # act on twice downsampled inp\n",
    "        down_inp = F.interpolate(inp, scale_factor=0.5, mode='bilinear',\n",
    "                                 recompute_scale_factor=False, align_corners=False)\n",
    "        theta_vector = self.localisation_net(down_inp)\n",
    "        # affine transformation\n",
    "        theta_matrix = theta_vector.view(-1, 2, 3)\n",
    "        # grid generator\n",
    "        grid = F.affine_grid(theta_matrix, inp.size(), align_corners=False)\n",
    "        # sampler\n",
    "        out = F.grid_sample(inp, grid, align_corners=False)\n",
    "        return out\n",
    "    \n",
    "    def get_attention_rectangle(self, inp):\n",
    "        assert inp.shape[0] == 1, 'batch size has to be one'\n",
    "        # act on twice downsampled inp\n",
    "        down_inp = F.interpolate(inp, scale_factor=0.5, mode='bilinear',\n",
    "                                 recompute_scale_factor=False, align_corners=False)\n",
    "        theta_vector = self.localisation_net(down_inp)\n",
    "        # affine transformation matrix\n",
    "        theta_matrix = theta_vector.view(2, 3).detach()\n",
    "        # create normalized target rectangle input image\n",
    "        target_rectangle = torch.tensor([\n",
    "            [-1., -1., 1., 1., -1], \n",
    "            [-1., 1., 1., -1, -1.], \n",
    "            [1, 1, 1, 1, 1]]\n",
    "        ).to(inp.device)\n",
    "        # get source rectangle by transformation\n",
    "        source_rectangle = torch.matmul(theta_matrix, target_rectangle)        \n",
    "        return source_rectangle\n",
    "    \n",
    "    \n",
    "# instantiate models\n",
    "cnn = CNN(img_size=42, include_ST=False)\n",
    "st_cnn = CNN(img_size=42, include_ST=True)\n",
    "# print trainable parameters\n",
    "for model in [cnn, st_cnn]:\n",
    "    num_trainable_params = get_number_of_trainable_parameters(model)\n",
    "    print(f'{model.name} has {num_trainable_params} trainable parameters')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from livelossplot import PlotLosses\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "\n",
    "def train(model, dataset):\n",
    "    # fix hyperparameters\n",
    "    epochs = 50\n",
    "    learning_rate = 0.01\n",
    "    batch_size = 256\n",
    "    step_size_scheduler = 50000\n",
    "    gamma_scheduler = 0.1\n",
    "    # set device    \n",
    "    device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "    print(f'Device: {device}')\n",
    "    \n",
    "    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True,\n",
    "                             num_workers=4)\n",
    "    \n",
    "    model.to(device)\n",
    "    optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
    "    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, gamma=gamma_scheduler,\n",
    "                                                step_size=step_size_scheduler)\n",
    "    \n",
    "    losses_plot = PlotLosses()\n",
    "    print(f'Start training with {model.name}')\n",
    "    for epoch in range(1, epochs+1):\n",
    "        avg_loss = 0\n",
    "        for data, label in data_loader:\n",
    "            model.zero_grad()\n",
    "            \n",
    "            log_prop_pred = model(data.to(device))\n",
    "            # multinomial cross entropy loss\n",
    "            loss = F.nll_loss(log_prop_pred, label.to(device))\n",
    "            \n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            scheduler.step()\n",
    "            \n",
    "            avg_loss += loss.item() / len(data_loader)\n",
    "        \n",
    "        losses_plot.update({'log loss': np.log(avg_loss)})\n",
    "        losses_plot.send()\n",
    "    trained_model = model\n",
    "    return trained_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(trained_model, test_dataset):\n",
    "    device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "    test_loader = DataLoader(test_dataset, batch_size=256, shuffle=True,\n",
    "                            num_workers=4)\n",
    "    with torch.no_grad():\n",
    "        trained_model.eval()\n",
    "        test_loss = 0\n",
    "        correct = 0\n",
    "        for data, label in test_loader:\n",
    "            data, label = data.to(device), label.to(device)\n",
    "\n",
    "            log_prop_pred = trained_model(data)\n",
    "            class_pred = log_prop_pred.max(1, keepdim=True)[1]\n",
    "\n",
    "            test_loss += F.nll_loss(log_prop_pred, label).item()/len(test_loader)\n",
    "            correct += class_pred.eq(label.view_as(class_pred)).sum().item()\n",
    "\n",
    "        print(f'{trained_model.name}: avg loss: {np.round(test_loss, 2)},  ' +\n",
    "              f'avg acc {np.round(100*correct/len(test_dataset), 2)}%')\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "log loss\n",
      "\tlog loss         \t (min:   -1.366, max:    0.834, cur:   -1.366)\n"
     ]
    }
   ],
   "source": [
    "trained_cnn = train(cnn, train_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "log loss\n",
      "\tlog loss         \t (min:   -2.451, max:    0.834, cur:   -2.451)\n"
     ]
    }
   ],
   "source": [
    "trained_st_cnn = train(st_cnn, train_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CNN: avg loss: 0.27,  avg acc 91.76%\n",
      "ST-CNN Affine: avg loss: 0.09,  avg acc 97.22%\n"
     ]
    }
   ],
   "source": [
    "for trained_model in [trained_cnn, trained_st_cnn]:\n",
    "    test(trained_model, test_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x720 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import ConnectionPatch\n",
    "\n",
    "\n",
    "def visualize_learned_transformations(trained_st_cnn, test_dataset, digit_class=8):\n",
    "    device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "    trained_st_cnn.to(device)\n",
    "    n_samples = 5\n",
    "    \n",
    "    data_loader = DataLoader(test_dataset, batch_size=256, shuffle=True)\n",
    "    batch_img, batch_label = next(iter(data_loader))\n",
    "    i_samples = np.where(batch_label.numpy() == digit_class)[0][0:n_samples]\n",
    "    \n",
    "    fig = plt.figure(figsize=(n_samples*2.5, 2.5*4))\n",
    "    for counter, i_sample in enumerate(i_samples):\n",
    "        img = batch_img[i_sample]\n",
    "        label = batch_label[i_sample]\n",
    "        \n",
    "        # input image\n",
    "        ax1 = plt.subplot(4, n_samples, 1 + counter)\n",
    "        plt.imshow(transforms.ToPILImage()(img), cmap='gray')\n",
    "        plt.axis('off')\n",
    "        if counter == 0:\n",
    "            ax1.annotate('Input', xy=(-0.3, 0.5), xycoords='axes fraction',\n",
    "                         fontsize=14, va='center', ha='right')\n",
    "        \n",
    "        # image including border of affine transformation\n",
    "        img_inp = img.unsqueeze(0).to(device)\n",
    "        source_normalized = trained_st_cnn.get_attention_rectangle(img_inp)\n",
    "        # remap into absolute values\n",
    "        source_absolute = 0 + 20.5*(source_normalized.cpu() + 1)\n",
    "        ax2 = plt.subplot(4, n_samples, 1 + counter + n_samples)\n",
    "        x = np.arange(42)\n",
    "        y = np.arange(42)\n",
    "        X, Y = np.meshgrid(x, y)\n",
    "        plt.pcolor(X, Y, img.squeeze(0), cmap='gray')\n",
    "        plt.plot(source_absolute[0], source_absolute[1], color='red')\n",
    "        plt.axis('off')\n",
    "        ax2.axes.set_aspect('equal')\n",
    "        ax2.set_ylim(41, 0)\n",
    "        ax2.set_xlim(0, 41)\n",
    "        if counter == 0:\n",
    "            ax2.annotate('ST', xy=(-0.3, 0.5), xycoords='axes fraction',\n",
    "                         fontsize=14, va='center', ha='right')\n",
    "        # add arrow between\n",
    "        con = ConnectionPatch(xyA=(21, 41), xyB=(21, 0), coordsA='data', \n",
    "                              coordsB='data', axesA=ax1, axesB=ax2, \n",
    "                              arrowstyle=\"-|>\", shrinkB=5)\n",
    "        ax2.add_artist(con)\n",
    "        \n",
    "        # ST module output\n",
    "        st_img = trained_st_cnn.ST_module(img.unsqueeze(0).to(device))\n",
    "        \n",
    "        ax3 = plt.subplot(4, n_samples, 1 + counter + 2*n_samples)\n",
    "        plt.imshow(transforms.ToPILImage()(st_img.squeeze(0).cpu()), cmap='gray')\n",
    "        plt.axis('off')\n",
    "        if counter == 0:\n",
    "            ax3.annotate('ST Output', xy=(-0.3, 0.5), xycoords='axes fraction',\n",
    "                         fontsize=14, va='center', ha='right')\n",
    "        # add arrow between\n",
    "        con = ConnectionPatch(xyA=(21, 41), xyB=(21, 0), coordsA='data', \n",
    "                              coordsB='data', axesA=ax2, axesB=ax3,\n",
    "                              arrowstyle=\"-|>\", shrinkB=5)\n",
    "        ax3.add_artist(con)\n",
    "        \n",
    "        # predicted label\n",
    "        log_pred = trained_st_cnn(img.unsqueeze(0).to(device))\n",
    "        pred_label = log_pred.max(1)[1].item()\n",
    "        \n",
    "        ax4 = plt.subplot(4, n_samples, 1 + counter + 3*n_samples)\n",
    "        plt.text(0.45, 0.43, str(pred_label), fontsize=22)\n",
    "        plt.axis('off')\n",
    "        #plt.title(f'Ground Truth {label.item()}', y=-0.1, fontsize=14)\n",
    "        if counter == 0:\n",
    "            ax4.annotate('Prediction', xy=(-0.3, 0.5), xycoords='axes fraction',\n",
    "                         fontsize=14, va='center', ha='right')\n",
    "        # add arrow between\n",
    "        con = ConnectionPatch(xyA=(21, 41), xyB=(0.5, 0.65), coordsA='data', \n",
    "                              coordsB='data', axesA=ax3, axesB=ax4, \n",
    "                              arrowstyle=\"-|>\", shrinkB=5)\n",
    "        ax4.add_artist(con)\n",
    "    return\n",
    "            \n",
    "        \n",
    "visualize_learned_transformations(st_cnn, test_dataset, 2)"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}