06-convnet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Outline\n",
    "\n",
    "* Today we will show how to train a ConvNet using PyTorch\n",
    "* We will also illustrate how the ConvNet makes use of specific assumptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# To perform well, we need to incorporate some prior knowledge about the problem\n",
    "\n",
    "* Assumptions helps us when they are true\n",
    "* They hurt us when they are not\n",
    "* We want to make just the right amount of assumptions, not more than that\n",
    "\n",
    "## In Deep Learning\n",
    "\n",
    "* Many layers: compositionality\n",
    "* Convolutions: locality + stationarity of images\n",
    "* Pooling: Invariance of object class to translations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Matplotlib is building the font cache; this may take a moment.\n"
     ]
    }
   ],
   "source": [
    "from res.plot_lib import plot_data, plot_model, set_default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_default()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy\n",
    "\n",
    "# function to count number of parameters\n",
    "def get_n_params(model):\n",
    "    np=0\n",
    "    for p in list(model.parameters()):\n",
    "        np += p.nelement()\n",
    "    return np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load the Dataset (MNIST)\n",
    "\n",
    "\n",
    "We can use some PyTorch DataLoader utilities for this. This will download, shuffle, normalize data and arrange it in batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ../data\\MNIST\\raw\\train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100.1%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../data\\MNIST\\raw\\train-images-idx3-ubyte.gz to ../data\\MNIST\\raw\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ../data\\MNIST\\raw\\train-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "113.5%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../data\\MNIST\\raw\\train-labels-idx1-ubyte.gz to ../data\\MNIST\\raw\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ../data\\MNIST\\raw\\t10k-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100.4%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../data\\MNIST\\raw\\t10k-images-idx3-ubyte.gz to ../data\\MNIST\\raw\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ../data\\MNIST\\raw\\t10k-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "180.4%C:\\anaconda3\\envs\\pytorch\\lib\\site-packages\\torchvision\\datasets\\mnist.py:469: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at  ..\\torch\\csrc\\utils\\tensor_numpy.cpp:141.)\n",
      "  return torch.from_numpy(parsed.astype(m[2], copy=False)).view(*s)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../data\\MNIST\\raw\\t10k-labels-idx1-ubyte.gz to ../data\\MNIST\\raw\n",
      "Processing...\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "input_size  = 28*28   # images are 28x28 pixels\n",
    "output_size = 10      # there are 10 classes\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    datasets.MNIST('../data', train=True, download=True,\n",
    "                   transform=transforms.Compose([\n",
    "                       transforms.ToTensor(),\n",
    "                       transforms.Normalize((0.1307,), (0.3081,))\n",
    "                   ])),\n",
    "    batch_size=64, shuffle=True)\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    datasets.MNIST('../data', train=False, transform=transforms.Compose([\n",
    "                       transforms.ToTensor(),\n",
    "                       transforms.Normalize((0.1307,), (0.3081,))\n",
    "                   ])),\n",
    "    batch_size=1000, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABOQAAAHYCAYAAADtQTdtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAr4ElEQVR4nO3daZhcZZk38FPp6nQWEiAJCYsJW2gCYQkQlkQgAhFxXgURMKK8Iq7syoAwojOOIzowOiq7igIuM+gICowLKAoMYxb2PRtLwhYCBBIC2bqr6v3gfHjn0vtpctL9VKf79/v6z3Ofm5A6Vf3vc11VKYqiUQAAAAAAWQxo9gIAAAAA0J8o5AAAAAAgI4UcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyKj6Vv/g9MqxPbkH9Em3Na5v9grdxj0A1l9fuQd4/cP66yuv/6JwD4Ay+so9wOsf1t9bff17Qg4AAAAAMlLIAQAAAEBGCjkAAAAAyEghBwAAAAAZKeQAAAAAICOFHAAAAABkpJADAAAAgIwUcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABkp5AAAAAAgI4UcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyEghBwAAAAAZVZu9AAA9p/PQfZL5klPXhtlDU34YZnvOOjE5d+vLB4ZZy+33J88CAAD0dZ6QAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABkp5AAAAAAgo2qzF+DPKtX0/4qWLUb1yHXnn7NdmNWG1MNs2x1fSs4dcmolzF785sAwu3/yz5JzX6m9GWb7//zs5Nnxfzs7mcPGqj5trzC75OrLkmfHt8b3nvgOUBQPTLkmOXf+5FqYfW67A5Jngb7rzWP3D7OL/uXK5NmvfOAjYda499HSOwHr58mvT0nmcz8Uf/ZorbSE2cGnfio5d/CNd6cXA9jIeEIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZFRt9gK9UcsuO4VZo601efaFaZuF2eoD3gyzEZvGWVEUxV17/iyZ5/bbVcOS+UWXHRFmc3b/9zB7umN1cu6FS98ZZlvf1UiehY1Zx+GTw+zcK34cZu2tA5Nz60U9zJ7q6AizFfW25Ny9EvHad+8bZoNvfyQ5t75mTTKn71h91H7pfGRLmI24elZ3r0M3eWly/Lvgryx6b8ZNgJQXz5oaZnfM+Jfk2Y5G+rNHyEd5oJ/xhBwAAAAAZKSQAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADIqNrsBZqh9o69k/k3r708zNpbS36N90aoo1ELs3+49KPJs9U34+8tn/Lz08Ns2POdybltr6wOsyH3zkmehWZrGT48zN48eELy7Fnf+vcwO2TwG4mT5X/vcu1rU8PsD1dMSZ790z9eEma///53wmzXn8T3h6Ioih3Om5XM6TteODj9b3fIjsvj8Oru3YX1NKAljBrj4vfxw0bPS479QyW+JwHd642x9TAbMaD//DwEPW3duyYn88Ufjl+Lp+x9Z5h9dvMFpXfa/ftnhNmQJfHP+UVRFMunrg2zbf8t/mw38NZ7u16sD/KEHAAAAABkpJADAAAAgIwUcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGVWbvUAztM1/IZnft2ZsmLW3Lu3udTbY2UsOCLOn3hiVPHvtjteH2Yp6I8zGXDKz68V6QLwR9H7P/WibMLtn38szbvLW/NPoe8Lslk2mJs+etOjwMPvhdreF2fBdl3W9GP3Cl9/z82R+0dz43xjN1bLjtmE2b9rVYTbp7hOSc7e+55HSOwF/6Y3j9g+zG46+OHGykpz7neUTwuy2D0wOs6GLH0vOrSdT6L1ePnlKmF16bvpngMlttTAbkHi+6sRF05Nz99r0mTB76BOp139aaqepI44PsxG3lr7kRs0TcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACCjarMXaIbOJS8m80svOi7MvnrEm8mzLQ9vEmYPnXpperGEC17ZI8yemD4kzGrLlyTnfmjKqWG26Mz43PbFQ8m50F91HrpPmF036bIwG1AMLH3NkxYfFmb33rZL8uwjH493un31oDAbfe/q5NwnXpsQZq1fuz3MBlSSY+lHWiudzV6BkqrfX1Xq3Oonh3fzJtC/rXnPfsn8S/98dZi1t5Z/Q/7hVUeE2ZaPzyw9F5qp0pr+rL5m+p5hdsPnvx5mW1fbknM/vvidYbb4GzuH2dBfP5ice/uQcWF25y/bw+yGnW5Ozk15/cGRYTai9NSNmyfkAAAAACAjhRwAAAAAZKSQAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADIqNrsBXqjEdfMCrMt/nNk8mxt2athNnG3j4XZYwdfnZx78/emhdno5TOTZ1Mqsx4Ks+3jvwbot+rT9krml1x9WZiNb41vufWinpx75Lyjw6zl2DfDbLP/00jO3fXHp4dZ++XPhtmAZx9Izt38rjjr+GotzG7YI30v/NghZ4ZZy+33J8/S+9QPnBRmBw3673yL0K22G7qs1Lmxt8X3BmD9LTlhTTI/ZHAqbwmTExdNT87d8uLyP5tAb7Xk9MnJ/O5zLk6kbWFy3BPvTc7tPKYjzIa8MifM0j8BFMULn9onzObslPpvSfvtqmFhNv678c8WnaWvuHHzhBwAAAAAZKSQAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADIqNrsBTY2tVeWlT7b8frA0mcnfvjxMHv5yvhryYt6rfQ1ob+q7DMxzF7529XJs+2t8ev8vrXxuT++sWty7rKfjg2zka/NCrNNfzI7OXfTRNaMrx8f0xJ/LXxRFMWyz64Ks9G3d/c29LTF7xkcZqNbhmTchPVR3W5cMj92xM2l5g5++rVk7hMN/KXq27YJs8cOuiZ5tqMRv6rmdsTnnvlme3Lu0GJOMofeauGl+4fZ/PdfmjxbT2S7/P7kMJtwzqLk3A3pH1JOPuWmHpl7wVdPDLPNn41/ZumvPCEHAAAAABkp5AAAAAAgI4UcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMqo2e4H+ZJfzFoTZSbsfljx7zbZ/CLNpx50WZsN+NrvrxaCfGTBkSDLv/JfXw2z2hF8kzz7duS7M/vb8s8Ns87ueSc4dPfSlMKslT/Yt+221OMwW5VuDblIdv7L02TXzNuu+RVgvz357aDJ/e1s9zH7w+tvig8vjey/0Zy0Tdw6zyf/+aI9cc8YvzgyzHW/w8wUbpyf/9YBkPv/9l4fZivqa5Nnj5n0ozHY+I+4BaivLfxYaMDR+P1527B7Js0dt8vV4bjE4zCb8PO4eiqIoxl87K5nzv3lCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABkp5AAAAAAgI4UcAAAAAGSkkAMAAACAjKrNXqA/qS1fEWbLTtklefaZm1eH2d9d8KMw+/wHjk7ObTywaZiN/eqsxMFGci70ZqunTUzmt064ovTsT3zmrDAbduPsMOssfUXon0bfW2/2Cr1ey6iRyXzpMe1hNuIDz4XZne0/6OLKg8LkysvfF2ajl87sYi70T4uPjF/L1498IHGyJTn3Q0++N8zaL3wyzGrJqdBcLWNGh9kPj05/xq8X8WeL4+Z9KHl24DsXJ+aWN2DSrmG229Vzw+yCMZd0MbktTN7+4AfDbOd/jK9ZFO4P68sTcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACCjarMX4M/qD6W/PviDX/5cmP3bl74RZg8e8KP0hQ+Io4lDTw+zna5akhzb+dSi9HWhifb4yoPJfEDidxUnLT4seXbwjXeXWalfaa20hFlHI322pdLFH6DfWD0ifp0O7aFr1g/aK5k3Wiph9uz0tjBbt3VHcu6AgbUw+91Bl4ZZa7xOURRF8WIt3unvnzo6zF6t15NzhwyI9x0zZ2WYeXXTX7160pRk/suTv55IW8Pk5GenJed2nBjfA2ovP5M8C71VZVD873pyW/z+1JXBZw5MX3fbsWG28OS3hdnh0+9Pzj1r9PfCbFx1cJil36mLotaI33UrPxsVn1u+sIvJrA9PyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMqs1egLdmxNWzwuz0+aeF2fALn0vOvW6HW8PssY9cFmYTxn4iOXfnL8ddb23hU8mz0B2W/98pYfbFMd9Inq0X8dea3/e7XZNnxxUz04tRdDTir5yvd/El7bfMjf/+dyrSXxtP77N2TWuY1YtG8uw1538rzG4+fVLZlZLOG/n9ZD6gqITZ6sa6MHuhFr8miqIoLnv5HWE2/bbPhtlmD8T3sqIoiq1+tzTMKovjzw8vzx2cnDumpSPMGvc8kjwLfVXLxJ3DbOYF8WfuPxtU6pqzntsumY9d9GipudCbNdasDbM5a+PPHUVRFPu3xe9fN9320+TZrj7DlnXb6lFhtrAj/qx0yOA3knPvXRd/RtjsR3H3QPfyhBwAAAAAZKSQAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABlVm70AG67ypwfDbNWxo5Nn951xRpjNOe/iMJt3yPeTcz+83eFhtuLA5FHoFp2D42zTAQOTZ2etaQuzHX70Qvq6ybTvGDBkSDKf943dEul9YfLhp96dnDvhM0+HWS15kt5o/AkPhNnEfz49eXbsvs939zpduv2l9mT+8m/fFmYjH+sIs4G33NPFleOz7cW9XZyNpV4zz583Ncz2bZuVnPvTN7YpuRH0XQvOj983Oxo98w427sJ03uiRq0Jz1Za+FGZfOuUTybPf+M4VYbZH+seH4ievjw2zC+48Mszar12TnFtduiLMRl/3apgdMvaPybkn3h7/XWzIZwvWjyfkAAAAACAjhRwAAAAAZKSQAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEbVZi9Az0p97XNRFMWYS+J8zbmdYTakkv7e56u2+1WYvefoz8ZzfzknORdyWFbbJMw6n1qUb5EmGzBkSJjNv3D35Nl5R10WZr9dtWmYvXD5+OTcYa/NTub0Hdt/flazV1hvWxXPNHuFbjPk4JdLn/3i7ceEWXtxd+m50NvVp+0VZhdMvrFHrvnORz8YZpvc+2iPXBM2VgNvvTeZn7/9fj1y3Q1571t5VLzTr8fdFGYdjfSzV4MXpX+eJw9PyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMqs1egA1XP3BSmD153KDk2d0mLQqzIZXyX4V86avx174PuSn9ddPQbOf86bgway/uy7hJz6tPi1+rL/3t6jCbO/my5NzDHpkRZkOPeCrMhhWzk3OB3m/bmxrNXgGa4qvXfi/Mdmst/7o4Z8nBYbbp8a+FWa30FYHeonNw/AxVRyN+ldeLenLu9tc+E1+z67XoJp6QAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABkp5AAAAAAgo2qzF+DPKpN3S+YLzhwYZle9/YdhdvCgdaV3Slnb6Ejms1/dPg7rS7p5G/grKnE0oIvfRVx84HVhdnnRXnajplj8T1OS+Q0f+WaYtbfG95297z4xOXfrox9PLwYAfcxeA+PPFx2NWum5s67ZO8xGvzaz9Fyg9xv209lx+K/59qBneEIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZFRt9gJ9TXX7bcPsyZO2DrN/nPHT5NxjNnml9E5lnb90cpjdefEBybOb/3BWd68D66cRR/Winjw6bfCyMPvstfskz+54TTy79cWVYbZ02hbJuSNmPBdmZ4z7Q5i9e8h9ybk3vzkmzD7yyBFhNuq7Q5Nzgb6rpZL+fe5r7a1htuVvu3sbyOfZ63dL5q2VB3vkulvdEf8cUOuRKwK9xcoPpn7uTn/Op/fzhBwAAAAAZKSQAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADIqNrsBXqj6nbjwmzFPlslz874p1vC7OTNflF6p7LOXpL6muSimHXF5DAbce3dYbZ5fVbpnaC3G1SJb41z3/md5Nn/PmhQmC1cu2WYnbTpoi73KuMzLxyUzG+ZOSnMdvrM7G7eBugLao16+g/4dS8bsfq0vcLs25N+kjzb0aiF2Yr6mjDb97efTc6dsPjxZA70XSt28Kbal/m/CwAAAAAZKeQAAAAAICOFHAAAAABkpJADAAAAgIwUcgAAAACQkUIOAAAAADJSyAEAAABARtVmL9BTqlttGWavXj00efaU7e8Ms+OHLS2904Y4/fkDw+z+KyeF2ajrH03OHbFyVtmVoFcbc8dLYXbep6ckz160ZfnXxcGD1oXZgYMWlZ77wNr49yfH3/mpMGs/6b7k3J2K2aV3AvhrVu27qtkrQGlrRgwMswMHvdnF6ZYwuXXVuDBr/9Q9yan1Lq4K9F3b3Bm/p7aeHt9zOho9sQ3dzRNyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyEghBwAAAAAZKeQAAAAAIKNqsxdIWfeuyen8rFfD7Pzxvwmzwwd39ZXlPWNpbXWYHXzz2cmzE744L8xGLJ8VZr4mnf6qtuDJMFt43HbJs7uecUaYPf6BS8uulDThN6cm852viL/yvP2B+7p7HYBQS8XvcwEgh8qfHgyza18fHWbHD3s+OXfVxK3CbOCzz3W5F93DJyoAAAAAyEghBwAAAAAZKeQAAAAAICOFHAAAAABkpJADAAAAgIwUcgAAAACQkUIOAAAAADKqNnuBlEXvS/eFC3b/eY9c9/LlO4bZxXcenjxbqVXCbMIFT4fZTkvnJOfWkimwPjqfWpTMx58V50eetW/3LvM/2ot7knmjR64K8NetvW2LMKtNqmfcBPIa/uCLYXbGc4cmz35n7J3dvQ5A6FvfPTbMjj/n4uTZrf7+iTBbtnyP+ODsh7vci7fOE3IAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABkp5AAAAAAgo0pRFI238genV+Kv1AX+utsa1zd7hW7jHgDrr6/cA7z+Yf31ldd/UbgHQBl95R7g9d97tYwaGWYDb6gmz/5s/K/CbNpDx4fZiA+9nJxbW74imfcXb/X17wk5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMFHIAAAAAkFH6u3ABAAAA6FVqrywLs3XHjEye3eVfPx1mc6d/N8yOnPDx9FKzH07n/C+ekAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyEghBwAAAAAZKeQAAAAAIKNqsxcAAAAAoHvUXlmWzHc6Mc6PLPZNnHy45Eb8NZ6QAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABlViqJoNHsJAAAAAOgvPCEHAAAAABkp5AAAAAAgI4UcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyEghBwAAAAAZKeQAAAAAICOFHAAAAABkpJADAAAAgIwUcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABkp5AAAAAAgI4UcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyEghBwAAAAAZKeQAAAAAICOFHAAAAABkpJADAAAAgIwUcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMio+lb/4PTKsT25B/RJtzWub/YK3cY9ANZfX7kHeP3D+usrr/+icA+AMvrKPcDrH9bfW339e0IOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABkp5AAAAAAgI4UcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyEghBwAAAAAZKeQAAAAAICOFHAAAAABkpJADAAAAgIwUcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGVWbvQAARbHgmn2S+dPv+kGYffPVHcLstg9MTs6tPb4gvRgAAEATjfzT5mE2oNJInn156vJu3qb7eEIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMqs1egJ7VMnJEMq9sOjzMnjlm6zBbM6qRnDv+yw+FWX3VquRZ6KtaJu4cZjcdcnnybEejNcxO23x+mF2/x+HJucMeT8ZAN6nsMzHM6gPTH8eef8fQMHvsjCvCrKNR63qxzA579NgwG3rUkuTZ+po13b0O9AqVtrZkvurde4bZHl+IP3Mv3Hdt6Z0Aclrwg8nJ/J5xF4fZlLtOS57doXiwzEpZeEIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZFRt9gK8NQN2mxBmCz8/OMw+tvvM5NyzR95aeqeUXcacHGY7ffS+Hrkm9HrPvxhGZy74YPLo7yfe0N3bAOupMWXPZL7wowPD7FuHXhdmrZXO5Nzpg1eGWUcj/t1qvagn5zbD73f7jzCb9OOPJc9uf8oLYVZ7ZVnpnaDZWrYYlcxvv/w7YXbXmvjHua9v/97k3M6nF6cXA+hGC67cL8zuOfxbybMr640wG35n3If0dp6QAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABnF35NNt6vsu3uYPXFWS/LsHQdeFmZbtLSF2YAuOtdfr9o8zJ5aOzrMTtt8fnLujw++Ksy+su+JYda455HkXNiY1ZavCLPFz+2UPjyxm5cB1lvjgleT+bwJv8i0Sd/04NSrk/m79j81zNp+vay714GNwkGDOsPsq+NGJM8OeHpxd68DEHrHXnPDbNiAgcmzpy4+IsxGfXdW6Z2azRNyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyEghBwAAAAAZKeQAAAAAICOFHAAAAABkVG32Ahubli22SOYLLt4mzP5z6hVhtkNraxdXbusi/+uueX1sMr/xmAPDrN4W73Tar+Yn505uq4XZ6jGDw2xQcips3FrGjA6zg3ZZkHEToIzn70i/pxYTys2dtSb9Hv+x33wyDiuJg41y+xRFURywd3xPuma735UfDHSrlornK2Bjtvqo/ZL5qLOfDrO1M1rCrHPJi6V32hAvnTo1zC4a860w+8nr2ybnvvb5cWE2oFjW9WK9lDs4AAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyKja7AU2Ns+fsFMyf2zaxYm0tXuX+R8/eX1smN34vvhrh4uiKGrzF4RZZa+JpXcC/ophQ8Pob0bc0yOXfGmfSjLf7OH2MKs9Ht8foD8ad+G9yfzo/zi+1NzKuo5kvtPTc0rN3RDLR40Ms9tmD0uenT54ZalrHvrIjGQ+/PbHwqxe6oqw8as14n/9HUPSP+q1dfcywHo74cJfJfOThj8bZtP3OSXMBv3qxdI7bYgTT/tNmE1qi+86n/zK0cm5I+6aVXqn3swTcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZFRt9gIbm22OXNQjc69/Y8tk/s0Fh4XZmHMbYVabv7D0Tq/tPrz0WeAv1Z54Osy++J8zkmePOf7yUtd87EOXJPO9VnwmzMY+vqDUNaGvanSsS+a1+U9k2qTnLX1/e5jtPvCmLk63lbrmCy+MSOabrHqq1Fzor17apzWZj/1tpkWA0JJ1myXzerE4zDoHV7p5m67Vp+2VzI/a5NIw62gMDrPOQfn/W3oDT8gBAAAAQEYKOQAAAADISCEHAAAAABkp5AAAAAAgI4UcAAAAAGSkkAMAAACAjKrNXmCj88m2ZLzraWeE2djf18Js6GMvJueOWrwgzOKpG2bVmP751cPQDDueMzv9B47PswfQf7x8ypQwm3DCvDAb05L+LFTWLuc+ncx76vMONFujoyOZL+hYE2btrYPCbPX260rvBHSfhZfsH2a/HHlp8uyVy9vDbLPZz4dZZ9drhVo22zTMXjnnzeTZravxZ4SzXpgaZmN+cF9ybiOZbrw8IQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMFHIAAAAAkJFCDgAAAAAyqjZ7gY1N7Ymnk/n4s9J5ZEO+lrindOy7stkrAP+jtdISZh199XvAgS69dPrUMDvxlN8kz54w/BthNmzAwNI7pXzl5b3DrLF2XY9cE3q72tKXkvmZT84Is1sm3NTd6wAltOw8Psx+/J4rw2xVoyM59xdfODzMBj97d9eLlbDwiu3D7NG9r0qevW31sHjuvmtL79RXeUIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMqs1egLfmmX+YGmadQxrxwUoXgxNH37/TrC4Ox05/7h1hNviW+8usA/1aR6MWZvWinnET6L9aJu6czBectHmYTTvw0e5epyiKovjV2EvDrOt7w8BS13yiozOZz7jy7DAb98ulYVZf+WSpfQCgpzXePimZf/AHvwqzyW3x5/gJt3wmObf9xruTeVmLLpgSZvce/M3EyXSFdN73PxZm2xQzu1qr3/GEHAAAAABkpJADAAAAgIwUcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMgo/Z21rLeW4cPDbM1+O4VZ6+eXJuc+POHSUvu0VlqSeUcj/grmlNtXD0nmz31qXJg1OueWuiYA9LTG2yeF2Uev+WXy7FFDX+nmbd6K/L9bPfOJGcl8m4tmhlm5Tx1AGZuMWNXsFaBXqbQOTOZLTp8cZveek/55PPVzd0cjfq9+/6T7k3NvvmhKmI3/8kNhNmDL0cm5R/7N7DBrKSphNmnmx5Jzx10YfwbgL3lCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABkp5AAAAAAgI4UcAAAAAGRUbfYCvVGlrS3M1k3bPXn2rCt+HGaHDP5DmC2trU3OvX315mH2DwuOCrPrJl6bnLt1Nf5vTRk0oCOZP/WBzcJsh/mDwqy+Zk2pfQCgp7UUjWQ+oAm/52yttIRZR3rd0m7Z5ZfJ/KAPnxZmm/7b7O5eBwjcsPdVyfyM4u2ZNoHe4cWTJyfzu8+5OMzqXcxOvef+6PVtwuxrW85Jzv3aCXF+/vT9w+ydm/42OfeQwW+E2Zy18c/r4457JDmX9eMJOQAAAADISCEHAAAAABkp5AAAAAAgI4UcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMqo2e4FmGDBoUDJfNmOvMLvra5eUvu7E684Is7fdXkuebfv1PWE2cqs3wuy6W/dJzj175KPJPLJ/W0cyf/ij8d/TlGfPDLMxP3ooObe+alV6MeijWistYdbRKD93+NSXyh+GPqjypwfD7AfvOyJ59u8+OjLMxt26LsxaVnd2uVdPWPjx1jCbd8SVGTcBUp7977FxOCHfHrAxePnkKWE287xvJ8+urMc/4z7eMTR59gvnfDrMBi2LPwP84WuLknOv2e53Yfa1LeeE2YAunr2qJ7LJA+N9z3pibnLuxce8P77mQ+mz/ZEn5AAAAAAgI4UcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBG1WYv0FMqbW1hNu+beyTPzjvqktLXPWr++8Ks/etPhVlt6UvJudWxbwuzPW9+Jsw+N/Lx5NwV9fgrjfe/4eww22pCet8/7P6zMJv19/Hf74zj35Oc+8olu4fZoGXx11R3peWO+0ufhRw6GrUwqye/uDztzj2vC7MjD/h4fHD2w6WvCRur2uMLkvkO52ZapJvssnCLODwi3x5A2ibPNkqdG1ZJn2vZtT3MurrfQW+160fmhtnNb45Jnv3a944Ps63+dWby7JBiTnqxwLKz093EWZceFGbf2vquUtfsSkulEmafe+SY5NmtH0r3D/xvnpADAAAAgIwUcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGVWbvcCGqFTj9ed/e88wm3fk5cm5z3WuDbMjv3tu8ux2Vz8ZZp1LXwqzjun7JOfudtEDYfal0feF2TWvb5uc++MvvDfMxv9idpi1jBqZnPuOd54RZm/OWBFmv9zrquTct13SlsxTfvVmvPP32ncoPRdymPDHT4TZ44d+r0euueBTA8OsPb49ABuJpe8f3+wVgLdgQGe5cy2VSjKvD24tNxh6sftu3TXMXv3pqOTZrebP7O51urR6zKBkfsYWf0yk8Wv4gH86PTl31ENvJvPI2CeeT+a1UlP7L0/IAQAAAEBGCjkAAAAAyEghBwAAAAAZKeQAAAAAICOFHAAAAABkpJADAAAAgIwUcgAAAACQUbXZC2yIZz+3X5jNO/LiMHuhc21y7nEXfi7MtrvxqeTZVw/dPswaJwwLs+t3i/ctiqLYoqUtzCb+9Iwwa//eK8m5Q+bPSeaR2ivLkvnw6+J8+HXxuWNPPTc5d8yxi5N50tmbJcLHys+FDNoWDI7DQ/PtARuDSlv8nrn8uL2SZze/KX4/qK9cWXqnZlhy9tRkftOZ/5JI479DIK/Nr50VZt85d9swO3nT9OfmhWcNDLPxJ3S9F/RG4748M8xqGff4/7VssUWYPXdMZ/Ls+Nb4/fjfVm4VZqO+G983NkSz/g77Kk/IAQAAAEBGCjkAAAAAyEghBwAAAAAZKeQAAAAAICOFHAAAAABkpJADAAAAgIyqzV5gQ1z5yStKnRtUSefvPfm/wmybM19Lnj1x+H+WWakoivjrjIuiKCb++5lhNv7z94RZrTP9Ncq9zegr4q+pLoqiaJT7X/4/nt+Qw9BUY78Svzau+/A2YfbhYUtKX/PpI74fZu/e8/jk2fpDc0tfF96KNe/dL8w2PeeZMLtz/KXJuUffk/i3PX9ll3v1hOpWW4bZ88fuEGY/O+MbyblbV9OfPSJLa2uTeevqRqm5wPr7xux3hdkRh307ebb90wvCrF52IeAvLDx7fJjNPeyS5NlZa1vD7D+OPChx8smu1qIX8IQcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyKja7AU2xH+9MSHM9m97JMxGtLQl554/6sGyKxXvmff+MHtm1tvCbIfrVyTnjn/svjBrdHZ2vRjQZ137zNQwO37iz0vP7WiUPgo97l1fvTPMzh75aOm5884fHodv7F967ob44NRZYXbj6F+HWb1oLX3NExe9K8yeuGbn5NmRv4j3BfKpFZVkXl+9JtMm0Pe17NoeZl85+qdhVmukP3CfdPPJYTZ+weyuF6NX84QcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyEghBwAAAAAZVZu9wIaYecjWYbb/hw8NsxV7rkvOrb7cGmbt33k+ffbFl8JsuzXPhlk9ORUgtvbaLePw6/n2gL5g7vTvNnuF9RT/bnXWmrbkyU/O+UiYjf/kwjAb+easrtcCmm7H6uBkvuyk/cJs5A+8zmF9fOAXd4TZ0ZvEHcHes09Kzh3/2dllV2Ij4Ak5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMFHIAAAAAkFG12QtsiNqyV8NszCUz42wDrtm5AWcBesLmD8b3wstf2zl59rTN53f3OpDFH898e5j96NT9wuyht1/dE+tskJ+8PjaZL+nYLMyuvj/+exh/VS05d4c/PRhm9eRJoLe4Zlp8T3utvjp5dtTDb4RZo/RG0D999aZjwuz4Ey4Js8G/Gd4T67CR8IQcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyEghBwAAAAAZVZu9AAAbpvb4gjC7dbfhybO3FvuWvOrckuege7TccX+YbX/3kDDb58zPJOf+8NPfDrPdBlaSZw99ZEaYrbhjyzDb9mfPJ+d2Pr04zHYq7kueBfq2z809NsyO3faB5NkBb64Ns1rpjaB/2uG8WWF25Hnx5+2RRXyOvs8TcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACCjarMXAADoTvVVq8JsmwtnJs+ef+F+pa+7SfFUqayz9BWB/m7EexaE2R+LoV2cjs8C0PM8IQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMFHIAAAAAkJFCDgAAAAAyUsgBAAAAQEYKOQAAAADISCEHAAAAABkp5AAAAAAgI4UcAAAAAGSkkAMAAACAjBRyAAAAAJCRQg4AAAAAMlLIAQAAAEBGCjkAAAAAyEghBwAAAAAZKeQAAAAAICOFHAAAAABkpJADAAAAgIwUcgAAAACQUaUoikazlwAAAACA/sITcgAAAACQkUIOAAAAADJSyAEAAABARgo5AAAAAMhIIQcAAAAAGSnkAAAAACAjhRwAAAAAZKSQAwAAAICMFHIAAAAAkNH/AzaviwhhvCcIAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1600x600 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# show some images\n",
    "plt.figure(figsize=(16, 6))\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    image, _ = train_loader.dataset.__getitem__(i)\n",
    "    plt.imshow(image.squeeze().numpy())\n",
    "    plt.axis('off');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create the model classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FC2Layer(nn.Module):\n",
    "    def __init__(self, input_size, n_hidden, output_size):\n",
    "        super(FC2Layer, self).__init__()\n",
    "        self.input_size = input_size\n",
    "        self.network = nn.Sequential(\n",
    "            nn.Linear(input_size, n_hidden), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(n_hidden, n_hidden), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(n_hidden, output_size), \n",
    "            nn.LogSoftmax(dim=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, self.input_size)\n",
    "        return self.network(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self, input_size, n_feature, output_size):\n",
    "        super(CNN, self).__init__()\n",
    "        self.n_feature = n_feature\n",
    "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=n_feature, kernel_size=5)\n",
    "        self.conv2 = nn.Conv2d(n_feature, n_feature, kernel_size=5)\n",
    "        self.fc1 = nn.Linear(n_feature*4*4, 50)\n",
    "        self.fc2 = nn.Linear(50, 10)\n",
    "        \n",
    "    def forward(self, x, verbose=False):\n",
    "        x = self.conv1(x)\n",
    "        x = F.relu(x)\n",
    "        x = F.max_pool2d(x, kernel_size=2)\n",
    "        x = self.conv2(x)\n",
    "        x = F.relu(x)\n",
    "        x = F.max_pool2d(x, kernel_size=2)\n",
    "        x = x.view(-1, self.n_feature*4*4)\n",
    "        x = self.fc1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = F.log_softmax(x, dim=1)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running on a GPU: device string\n",
    "\n",
    "Switching between CPU and GPU in PyTorch is controlled via a device string, which will seemlessly determine whether GPU is available, falling back to CPU if not:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy_list = []\n",
    "\n",
    "def train(epoch, model, perm=torch.arange(0, 784).long()):\n",
    "    model.train()\n",
    "    for batch_idx, (data, target) in enumerate(train_loader):\n",
    "        # send to device\n",
    "        data, target = data.to(device), target.to(device)\n",
    "        \n",
    "        # permute pixels\n",
    "        data = data.view(-1, 28*28)\n",
    "        data = data[:, perm]\n",
    "        data = data.view(-1, 1, 28, 28)\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 % 100 == 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()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(model, perm=torch.arange(0, 784).long()):\n",
    "    model.eval()\n",
    "    test_loss = 0\n",
    "    correct = 0\n",
    "    for data, target in test_loader:\n",
    "        # send to device\n",
    "        data, target = data.to(device), target.to(device)\n",
    "        \n",
    "        # permute pixels\n",
    "        data = data.view(-1, 28*28)\n",
    "        data = data[:, perm]\n",
    "        data = data.view(-1, 1, 28, 28)\n",
    "        output = model(data)\n",
    "        test_loss += F.nll_loss(output, target, reduction='sum').item() # sum up batch loss                                                               \n",
    "        pred = output.data.max(1, keepdim=True)[1] # get the index of the max log-probability                                                                 \n",
    "        correct += pred.eq(target.data.view_as(pred)).cpu().sum().item()\n",
    "\n",
    "    test_loss /= len(test_loader.dataset)\n",
    "    accuracy = 100. * correct / len(test_loader.dataset)\n",
    "    accuracy_list.append(accuracy)\n",
    "    print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
    "        test_loss, correct, len(test_loader.dataset),\n",
    "        accuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a small fully-connected network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of parameters: 6442\n",
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.269911\n",
      "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 1.352506\n",
      "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 1.106997\n",
      "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 0.759408\n",
      "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 0.610653\n",
      "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 0.387975\n",
      "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 0.402717\n",
      "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 0.434486\n",
      "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 0.316160\n",
      "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 0.495853\n",
      "\n",
      "Test set: Average loss: 0.3908, Accuracy: 8851/10000 (89%)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "n_hidden = 8 # number of hidden units\n",
    "\n",
    "model_fnn = FC2Layer(input_size, n_hidden, output_size)\n",
    "model_fnn.to(device)\n",
    "optimizer = optim.SGD(model_fnn.parameters(), lr=0.01, momentum=0.5)\n",
    "print('Number of parameters: {}'.format(get_n_params(model_fnn)))\n",
    "\n",
    "for epoch in range(0, 1):\n",
    "    train(epoch, model_fnn)\n",
    "    test(model_fnn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a ConvNet with the same number of parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of parameters: 6422\n",
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.337125\n",
      "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 2.184543\n",
      "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 0.762358\n",
      "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 0.333433\n",
      "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 0.401248\n",
      "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 0.239791\n",
      "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 0.212107\n",
      "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 0.192531\n",
      "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 0.166679\n",
      "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 0.214294\n",
      "\n",
      "Test set: Average loss: 0.1923, Accuracy: 9399/10000 (94%)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Training settings \n",
    "n_features = 6 # number of feature maps\n",
    "\n",
    "model_cnn = CNN(input_size, n_features, output_size)\n",
    "model_cnn.to(device)\n",
    "optimizer = optim.SGD(model_cnn.parameters(), lr=0.01, momentum=0.5)\n",
    "print('Number of parameters: {}'.format(get_n_params(model_cnn)))\n",
    "\n",
    "for epoch in range(0, 1):\n",
    "    train(epoch, model_cnn)\n",
    "    test(model_cnn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The ConvNet performs better with the same number of parameters, thanks to its use of prior knowledge about images\n",
    "\n",
    "* Use of convolution: Locality and stationarity in images\n",
    "* Pooling: builds in some translation invariance\n",
    "\n",
    "# What happens if the assumptions are no longer true?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x1200 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "perm = torch.randperm(784)\n",
    "plt.figure(figsize=(16, 12))\n",
    "for i in range(10):\n",
    "    image, _ = train_loader.dataset.__getitem__(i)\n",
    "    # permute pixels\n",
    "    image_perm = image.view(-1, 28*28).clone()\n",
    "    image_perm = image_perm[:, perm]\n",
    "    image_perm = image_perm.view(-1, 1, 28, 28)\n",
    "    plt.subplot(4, 5, i + 1)\n",
    "    plt.imshow(image.squeeze().numpy())\n",
    "    plt.axis('off')\n",
    "    plt.subplot(4, 5, i + 11)\n",
    "    plt.imshow(image_perm.squeeze().numpy())\n",
    "    plt.axis('off')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ConvNet with permuted pixels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of parameters: 6422\n",
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.300045\n",
      "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 2.254695\n",
      "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 2.100211\n",
      "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 1.598876\n",
      "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 1.255521\n",
      "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 1.014393\n",
      "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 0.808915\n",
      "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 0.420731\n",
      "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 0.464442\n",
      "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 0.321081\n",
      "\n",
      "Test set: Average loss: 0.5008, Accuracy: 8478/10000 (85%)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Training settings \n",
    "n_features = 6 # number of feature maps\n",
    "\n",
    "model_cnn = CNN(input_size, n_features, output_size)\n",
    "model_cnn.to(device)\n",
    "optimizer = optim.SGD(model_cnn.parameters(), lr=0.01, momentum=0.5)\n",
    "print('Number of parameters: {}'.format(get_n_params(model_cnn)))\n",
    "\n",
    "for epoch in range(0, 1):\n",
    "    train(epoch, model_cnn, perm)\n",
    "    test(model_cnn, perm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fully-Connected with Permuted Pixels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of parameters: 6442\n",
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.338355\n",
      "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 2.123003\n",
      "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 1.741064\n",
      "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 1.119402\n",
      "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 0.787697\n",
      "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 0.681574\n",
      "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 0.494548\n",
      "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 0.506040\n",
      "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 0.639432\n",
      "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 0.371452\n",
      "\n",
      "Test set: Average loss: 0.4585, Accuracy: 8657/10000 (87%)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "n_hidden = 8    # number of hidden units\n",
    "\n",
    "model_fnn = FC2Layer(input_size, n_hidden, output_size)\n",
    "model_fnn.to(device)\n",
    "optimizer = optim.SGD(model_fnn.parameters(), lr=0.01, momentum=0.5)\n",
    "print('Number of parameters: {}'.format(get_n_params(model_fnn)))\n",
    "\n",
    "for epoch in range(0, 1):\n",
    "    train(epoch, model_fnn, perm)\n",
    "    test(model_fnn, perm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The ConvNet's performance drops when we permute the pixels, but the Fully-Connected Network's performance stays the same\n",
    "\n",
    "* ConvNet makes the assumption that pixels lie on a grid and are stationary/local\n",
    "* It loses performance when this assumption is wrong\n",
    "* The fully-connected network does not make this assumption\n",
    "* It does less well when it is true, since it doesn't take advantage of this prior knowledge\n",
    "* But it doesn't suffer when the assumption is wrong"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(('NN image', 'CNN image',\n",
    "         'CNN scrambled', 'NN scrambled'),\n",
    "        accuracy_list, width=0.4)\n",
    "plt.ylim((min(accuracy_list)-5, 96))\n",
    "plt.ylabel('Accuracy [%]')\n",
    "for tick in plt.gca().xaxis.get_major_ticks():\n",
    "    tick.label.set_fontsize(20)\n",
    "plt.title('Performance comparison');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking Model Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['T_destination', '__annotations__', '__call__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattr__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_apply', '_backward_hooks', '_buffers', '_call_impl', '_forward_hooks', '_forward_pre_hooks', '_forward_unimplemented', '_get_name', '_load_from_state_dict', '_load_state_dict_pre_hooks', '_modules', '_named_members', '_non_persistent_buffers_set', '_parameters', '_register_load_state_dict_pre_hook', '_register_state_dict_hook', '_replicate_for_data_parallel', '_save_to_state_dict', '_slow_forward', '_state_dict_hooks', '_version', 'add_module', 'apply', 'bfloat16', 'buffers', 'children', 'conv1', 'conv2', 'cpu', 'cuda', 'double', 'dump_patches', 'eval', 'extra_repr', 'fc1', 'fc2', 'float', 'forward', 'half', 'load_state_dict', 'modules', 'n_feature', 'named_buffers', 'named_children', 'named_modules', 'named_parameters', 'parameters', 'register_backward_hook', 'register_buffer', 'register_forward_hook', 'register_forward_pre_hook', 'register_parameter', 'requires_grad_', 'share_memory', 'state_dict', 'to', 'train', 'training', 'type', 'zero_grad']\n"
     ]
    }
   ],
   "source": [
    "print(dir(model_cnn))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['T_destination', '__annotations__', '__call__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattr__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_apply', '_backward_hooks', '_buffers', '_call_impl', '_forward_hooks', '_forward_pre_hooks', '_forward_unimplemented', '_get_name', '_load_from_state_dict', '_load_state_dict_pre_hooks', '_modules', '_named_members', '_non_persistent_buffers_set', '_parameters', '_register_load_state_dict_pre_hook', '_register_state_dict_hook', '_replicate_for_data_parallel', '_save_to_state_dict', '_slow_forward', '_state_dict_hooks', '_version', 'add_module', 'apply', 'bfloat16', 'buffers', 'children', 'cpu', 'cuda', 'double', 'dump_patches', 'eval', 'extra_repr', 'float', 'forward', 'half', 'input_size', 'load_state_dict', 'modules', 'named_buffers', 'named_children', 'named_modules', 'named_parameters', 'network', 'parameters', 'register_backward_hook', 'register_buffer', 'register_forward_hook', 'register_forward_pre_hook', 'register_parameter', 'requires_grad_', 'share_memory', 'state_dict', 'to', 'train', 'training', 'type', 'zero_grad']\n"
     ]
    }
   ],
   "source": [
    "print(dir(model_fnn))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}