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": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from res.plot_lib import plot_data, plot_model, set_default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_default()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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": 4,
   "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": 5,
   "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-images-idx3-ubyte.gz to ../data/MNIST/raw/train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7dc92f0d989840e3920667bdeb959d90",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/9912422 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../data/MNIST/raw/train-images-idx3-ubyte.gz to ../data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ../data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9cf62178a7614f96bb76e2996957b562",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/28881 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../data/MNIST/raw/train-labels-idx1-ubyte.gz to ../data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ../data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "709cb7ce723b445ba6301bf6b2abad71",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1648877 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../data/MNIST/raw/t10k-images-idx3-ubyte.gz to ../data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ../data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c97e9a47ce2c47aaaccbb14cc3f88f0c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4542 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ../data/MNIST/raw\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/gianlucafugante/anaconda3/lib/python3.8/site-packages/torchvision/datasets/mnist.py:498: 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  /Users/distiller/project/conda/conda-bld/pytorch_1623459044803/work/torch/csrc/utils/tensor_numpy.cpp:180.)\n",
      "  return torch.from_numpy(parsed.astype(m[2], copy=False)).view(*s)\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": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\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": 7,
   "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)\n",
    "    \n",
    "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": 8,
   "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()))\n",
    "            \n",
    "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": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of parameters: 6442\n",
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.336407\n",
      "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 1.882180\n",
      "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 1.326993\n",
      "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 0.870265\n",
      "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 0.657273\n",
      "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 0.588209\n",
      "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 0.466729\n",
      "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 0.406393\n",
      "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 0.602311\n",
      "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 0.433476\n",
      "\n",
      "Test set: Average loss: 0.4728, Accuracy: 8621/10000 (86%)\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": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of parameters: 6422\n",
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.345583\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/gianlucafugante/anaconda3/lib/python3.8/site-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at  /Users/distiller/project/conda/conda-bld/pytorch_1623459044803/work/c10/core/TensorImpl.h:1156.)\n",
      "  return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 2.022345\n",
      "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 0.495846\n",
      "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 0.383164\n",
      "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 0.309855\n",
      "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 0.258979\n",
      "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 0.218614\n",
      "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 0.200137\n",
      "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 0.264919\n",
      "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 0.188983\n",
      "\n",
      "Test set: Average loss: 0.1779, Accuracy: 9482/10000 (95%)\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": 11,
   "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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of parameters: 6422\n",
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.297082\n",
      "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 2.220612\n",
      "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 1.981453\n",
      "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 1.436582\n",
      "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 1.222117\n",
      "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 0.891434\n",
      "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 0.678470\n",
      "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 0.668990\n",
      "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 0.619010\n",
      "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 0.602069\n",
      "\n",
      "Test set: Average loss: 0.5603, Accuracy: 8293/10000 (83%)\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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of parameters: 6442\n",
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.315578\n",
      "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 1.905392\n",
      "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 1.367520\n",
      "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 0.984999\n",
      "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 0.703857\n",
      "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 0.706068\n",
      "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 0.447431\n",
      "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 0.670024\n",
      "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 0.302243\n",
      "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 0.271566\n",
      "\n",
      "Test set: Average loss: 0.4213, Accuracy: 8732/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": 14,
   "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": 15,
   "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', '_get_backward_hooks', '_get_name', '_is_full_backward_hook', '_load_from_state_dict', '_load_state_dict_pre_hooks', '_maybe_warn_non_full_backward_hook', '_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', 'get_buffer', 'get_parameter', 'get_submodule', '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_full_backward_hook', 'register_parameter', 'requires_grad_', 'share_memory', 'state_dict', 'to', 'to_empty', 'train', 'training', 'type', 'xpu', 'zero_grad']\n"
     ]
    }
   ],
   "source": [
    "print(dir(model_cnn))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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', '_get_backward_hooks', '_get_name', '_is_full_backward_hook', '_load_from_state_dict', '_load_state_dict_pre_hooks', '_maybe_warn_non_full_backward_hook', '_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', 'get_buffer', 'get_parameter', 'get_submodule', '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_full_backward_hook', 'register_parameter', 'requires_grad_', 'share_memory', 'state_dict', 'to', 'to_empty', 'train', 'training', 'type', 'xpu', 'zero_grad']\n"
     ]
    }
   ],
   "source": [
    "print(dir(model_fnn))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  },
  "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": 4
}