filter_visualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feature Visualization\n",
    "======"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# install pytorch (http://pytorch.org/) if run from Google Colaboratory\n",
    "import sys\n",
    "if 'google.colab' in sys.modules and 'torch' not in sys.modules:\n",
    "    from os.path import exists\n",
    "    from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag\n",
    "    platform = '{}{}-{}'.format(get_abbr_impl(), get_impl_ver(), get_abi_tag())\n",
    "    cuda_output = !ldconfig -p|grep cudart.so|sed -e 's/.*\\.\\([0-9]*\\)\\.\\([0-9]*\\)$/cu\\1\\2/'\n",
    "    accelerator = cuda_output[0] if exists('/dev/nvidia0') else 'cpu'\n",
    "\n",
    "    !pip3 install https://download.pytorch.org/whl/{accelerator}/torch-1.1.0-{platform}-linux_x86_64.whl\n",
    "    !pip3 install https://download.pytorch.org/whl/{accelerator}/torchvision-0.3.0-{platform}-linux_x86_64.whl\n",
    "\n",
    "%matplotlib inline\n",
    "import os\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parameter Settings\n",
    "-------------------\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 150\n",
    "batch_size = 256\n",
    "learning_rate = 1e-3\n",
    "use_gpu = True\n",
    "nfilters = 25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CIFAR Data Loading\n",
    "-------------------\n",
    "\n",
    "The CIFAR dataset contains 60000 32x32 colour images, split into 50000 training images and 10000 test images. Each image is labeled as one of either 10 (CIFAR10) or 100 (CIFAR100) classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from skimage import color\n",
    "\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision.datasets import CIFAR10\n",
    "\n",
    "# augment the dataset by doing random crops and horizontal mirroring\n",
    "# this is done to prevent overfitting\n",
    "transform_train = transforms.Compose([\n",
    "    transforms.RandomCrop(32, padding=4),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
    "])\n",
    "\n",
    "transform_test = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
    "])\n",
    "\n",
    "\n",
    "train_dataset = CIFAR10('./data/CIFAR10', train=True, transform=transform_train, target_transform=None, download=True)\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "\n",
    "test_dataset = CIFAR10('./data/CIFAR10', train=False, transform=transform_test, target_transform=None, download=True)\n",
    "test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ConvNet Definition\n",
    "-----------------------\n",
    "In this convolutional net, we choose a large kernel size to have a more detailed visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of parameters: 250666\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "class ConvNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(ConvNet, self).__init__()\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(3, 16, kernel_size=9, stride=1, padding=4) # out: 48 x 32 x 32\n",
    "        self.conv1_bn = nn.BatchNorm2d(16)\n",
    "        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=2, padding=1) # out: 48 x 16 x 16\n",
    "        self.conv2_bn = nn.BatchNorm2d(32)\n",
    "        self.conv3 = nn.Conv2d(32, 32, kernel_size=9, stride=1, padding=4) # out: 96 x 16 x 16\n",
    "        self.conv3_bn = nn.BatchNorm2d(32)\n",
    "        self.conv4 = nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1) # out: 96 x 8 x 8\n",
    "        self.conv4_bn = nn.BatchNorm2d(64)\n",
    "        self.conv5 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1) # out: 96 x 8 x 8\n",
    "        self.conv5_bn = nn.BatchNorm2d(64)\n",
    "        self.conv6 = nn.Conv2d(64, 64, kernel_size=3, stride=2, padding=1) # out: 96 x 4 x 4\n",
    "        self.conv6_bn = nn.BatchNorm2d(64)\n",
    "        self.conv7 = nn.Conv2d(64, 64, kernel_size=4, stride=2, padding=0) # out: 96 x 1 x 1\n",
    "        self.do1 = nn.Dropout2d(p=0.5)\n",
    "        self.fc1 = nn.Linear(64, 10) # 10 outputs: probability for each CIFAR10 class\n",
    "\n",
    "    def forward(self, x):\n",
    "        # convolutional part\n",
    "        x = F.relu(self.conv1_bn(self.conv1(x)))\n",
    "        x = F.relu(self.conv2_bn(self.conv2(x)))\n",
    "        x = F.relu(self.conv3_bn(self.conv3(x)))\n",
    "        x = F.relu(self.conv4_bn(self.conv4(x)))\n",
    "        x = F.relu(self.conv5_bn(self.conv5(x)))\n",
    "        x = F.relu(self.conv6_bn(self.conv6(x)))\n",
    "        x = F.relu(self.conv7(x))\n",
    "        x = self.do1(x)\n",
    "        x = x.view(x.size(0), -1) # flatten batch of multi-channel feature maps to a batch of feature vectors\n",
    "        \n",
    "        # fully connected part\n",
    "        x = F.log_softmax(self.fc1(x), dim=1) # last activation is log softmax to get log class probabilities\n",
    "        \n",
    "        return x\n",
    "\n",
    "convnet = ConvNet()\n",
    "\n",
    "device = torch.device(\"cuda:0\" if use_gpu and torch.cuda.is_available() else \"cpu\")\n",
    "convnet = convnet.to(device)\n",
    "    \n",
    "# pick a subset of filters\n",
    "filter_inds = []\n",
    "for conv in [convnet.conv1, convnet.conv2, convnet.conv3, convnet.conv4]:\n",
    "    weights = conv.weight.data.view(-1, 1, conv.weight.size(2), conv.weight.size(3))\n",
    "    filter_inds.append(np.random.choice(weights.size(0), min(nfilters, weights.size(0)), replace=False))\n",
    "\n",
    "num_params = sum(p.numel() for p in convnet.parameters() if p.requires_grad)\n",
    "print('Number of parameters: %d' % num_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train ConvNet\n",
    "--------\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training ...\n",
      "Epoch [1 / 150] average loss: 1.800384\n",
      "Epoch [2 / 150] average loss: 1.506838\n",
      "Epoch [3 / 150] average loss: 1.355435\n",
      "Epoch [4 / 150] average loss: 1.253215\n",
      "Epoch [5 / 150] average loss: 1.172255\n",
      "Epoch [6 / 150] average loss: 1.112579\n",
      "Epoch [7 / 150] average loss: 1.058659\n",
      "Epoch [8 / 150] average loss: 1.012831\n",
      "Epoch [9 / 150] average loss: 0.972379\n",
      "Epoch [10 / 150] average loss: 0.935343\n",
      "Epoch [11 / 150] average loss: 0.902290\n",
      "Epoch [12 / 150] average loss: 0.872317\n",
      "Epoch [13 / 150] average loss: 0.841865\n",
      "Epoch [14 / 150] average loss: 0.825446\n",
      "Epoch [15 / 150] average loss: 0.798933\n",
      "Epoch [16 / 150] average loss: 0.780626\n",
      "Epoch [17 / 150] average loss: 0.758626\n",
      "Epoch [18 / 150] average loss: 0.745468\n",
      "Epoch [19 / 150] average loss: 0.729974\n",
      "Epoch [20 / 150] average loss: 0.711058\n",
      "Epoch [21 / 150] average loss: 0.699637\n",
      "Epoch [22 / 150] average loss: 0.684781\n",
      "Epoch [23 / 150] average loss: 0.676827\n",
      "Epoch [24 / 150] average loss: 0.661745\n",
      "Epoch [25 / 150] average loss: 0.657367\n",
      "Epoch [26 / 150] average loss: 0.649593\n",
      "Epoch [27 / 150] average loss: 0.636176\n",
      "Epoch [28 / 150] average loss: 0.627248\n",
      "Epoch [29 / 150] average loss: 0.617938\n",
      "Epoch [30 / 150] average loss: 0.615330\n",
      "Epoch [31 / 150] average loss: 0.601528\n",
      "Epoch [32 / 150] average loss: 0.589395\n",
      "Epoch [33 / 150] average loss: 0.588763\n",
      "Epoch [34 / 150] average loss: 0.579213\n",
      "Epoch [35 / 150] average loss: 0.570223\n",
      "Epoch [36 / 150] average loss: 0.567608\n",
      "Epoch [37 / 150] average loss: 0.553015\n",
      "Epoch [38 / 150] average loss: 0.551360\n",
      "Epoch [39 / 150] average loss: 0.544469\n",
      "Epoch [40 / 150] average loss: 0.538379\n",
      "Epoch [41 / 150] average loss: 0.530557\n",
      "Epoch [42 / 150] average loss: 0.530796\n",
      "Epoch [43 / 150] average loss: 0.517685\n",
      "Epoch [44 / 150] average loss: 0.515464\n",
      "Epoch [45 / 150] average loss: 0.514242\n",
      "Epoch [46 / 150] average loss: 0.509034\n",
      "Epoch [47 / 150] average loss: 0.502509\n",
      "Epoch [48 / 150] average loss: 0.496977\n",
      "Epoch [49 / 150] average loss: 0.488219\n",
      "Epoch [50 / 150] average loss: 0.497592\n",
      "Epoch [51 / 150] average loss: 0.485768\n",
      "Epoch [52 / 150] average loss: 0.483673\n",
      "Epoch [53 / 150] average loss: 0.480113\n",
      "Epoch [54 / 150] average loss: 0.473848\n",
      "Epoch [55 / 150] average loss: 0.471389\n",
      "Epoch [56 / 150] average loss: 0.470178\n",
      "Epoch [57 / 150] average loss: 0.466626\n",
      "Epoch [58 / 150] average loss: 0.467533\n",
      "Epoch [59 / 150] average loss: 0.456649\n",
      "Epoch [60 / 150] average loss: 0.455246\n",
      "Epoch [61 / 150] average loss: 0.450602\n",
      "Epoch [62 / 150] average loss: 0.447368\n",
      "Epoch [63 / 150] average loss: 0.443970\n",
      "Epoch [64 / 150] average loss: 0.445088\n",
      "Epoch [65 / 150] average loss: 0.439120\n",
      "Epoch [66 / 150] average loss: 0.432394\n",
      "Epoch [67 / 150] average loss: 0.433210\n",
      "Epoch [68 / 150] average loss: 0.429165\n",
      "Epoch [69 / 150] average loss: 0.426095\n",
      "Epoch [70 / 150] average loss: 0.424260\n",
      "Epoch [71 / 150] average loss: 0.418922\n",
      "Epoch [72 / 150] average loss: 0.413899\n",
      "Epoch [73 / 150] average loss: 0.416719\n",
      "Epoch [74 / 150] average loss: 0.413292\n",
      "Epoch [75 / 150] average loss: 0.409664\n",
      "Epoch [76 / 150] average loss: 0.410875\n",
      "Epoch [77 / 150] average loss: 0.408690\n",
      "Epoch [78 / 150] average loss: 0.402239\n",
      "Epoch [79 / 150] average loss: 0.402697\n",
      "Epoch [80 / 150] average loss: 0.400259\n",
      "Epoch [81 / 150] average loss: 0.396963\n",
      "Epoch [82 / 150] average loss: 0.394202\n",
      "Epoch [83 / 150] average loss: 0.395644\n",
      "Epoch [84 / 150] average loss: 0.393933\n",
      "Epoch [85 / 150] average loss: 0.389374\n",
      "Epoch [86 / 150] average loss: 0.383015\n",
      "Epoch [87 / 150] average loss: 0.383983\n",
      "Epoch [88 / 150] average loss: 0.379606\n",
      "Epoch [89 / 150] average loss: 0.382140\n",
      "Epoch [90 / 150] average loss: 0.378405\n",
      "Epoch [91 / 150] average loss: 0.373138\n",
      "Epoch [92 / 150] average loss: 0.364451\n",
      "Epoch [93 / 150] average loss: 0.378790\n",
      "Epoch [94 / 150] average loss: 0.370779\n",
      "Epoch [95 / 150] average loss: 0.366476\n",
      "Epoch [96 / 150] average loss: 0.365097\n",
      "Epoch [97 / 150] average loss: 0.358615\n",
      "Epoch [98 / 150] average loss: 0.358399\n",
      "Epoch [99 / 150] average loss: 0.362799\n",
      "Epoch [100 / 150] average loss: 0.365193\n",
      "Epoch [101 / 150] average loss: 0.356643\n",
      "Epoch [102 / 150] average loss: 0.355321\n",
      "Epoch [103 / 150] average loss: 0.354253\n",
      "Epoch [104 / 150] average loss: 0.352256\n",
      "Epoch [105 / 150] average loss: 0.353466\n",
      "Epoch [106 / 150] average loss: 0.349055\n",
      "Epoch [107 / 150] average loss: 0.350001\n",
      "Epoch [108 / 150] average loss: 0.347163\n",
      "Epoch [109 / 150] average loss: 0.348171\n",
      "Epoch [110 / 150] average loss: 0.339027\n",
      "Epoch [111 / 150] average loss: 0.344751\n",
      "Epoch [112 / 150] average loss: 0.336114\n",
      "Epoch [113 / 150] average loss: 0.342565\n",
      "Epoch [114 / 150] average loss: 0.341502\n",
      "Epoch [115 / 150] average loss: 0.333718\n",
      "Epoch [116 / 150] average loss: 0.336252\n",
      "Epoch [117 / 150] average loss: 0.331880\n",
      "Epoch [118 / 150] average loss: 0.336344\n",
      "Epoch [119 / 150] average loss: 0.331049\n",
      "Epoch [120 / 150] average loss: 0.328401\n",
      "Epoch [121 / 150] average loss: 0.324935\n",
      "Epoch [122 / 150] average loss: 0.329239\n",
      "Epoch [123 / 150] average loss: 0.326370\n",
      "Epoch [124 / 150] average loss: 0.324937\n",
      "Epoch [125 / 150] average loss: 0.323781\n",
      "Epoch [126 / 150] average loss: 0.328894\n",
      "Epoch [127 / 150] average loss: 0.324006\n",
      "Epoch [128 / 150] average loss: 0.320220\n",
      "Epoch [129 / 150] average loss: 0.319003\n",
      "Epoch [130 / 150] average loss: 0.316344\n",
      "Epoch [131 / 150] average loss: 0.319678\n",
      "Epoch [132 / 150] average loss: 0.316764\n",
      "Epoch [133 / 150] average loss: 0.318914\n",
      "Epoch [134 / 150] average loss: 0.316838\n",
      "Epoch [135 / 150] average loss: 0.315587\n",
      "Epoch [136 / 150] average loss: 0.313424\n",
      "Epoch [137 / 150] average loss: 0.314342\n",
      "Epoch [138 / 150] average loss: 0.312701\n",
      "Epoch [139 / 150] average loss: 0.305915\n",
      "Epoch [140 / 150] average loss: 0.307934\n",
      "Epoch [141 / 150] average loss: 0.304676\n",
      "Epoch [142 / 150] average loss: 0.302637\n",
      "Epoch [143 / 150] average loss: 0.298790\n",
      "Epoch [144 / 150] average loss: 0.304981\n",
      "Epoch [145 / 150] average loss: 0.303558\n",
      "Epoch [146 / 150] average loss: 0.304831\n",
      "Epoch [147 / 150] average loss: 0.296911\n",
      "Epoch [148 / 150] average loss: 0.304102\n",
      "Epoch [149 / 150] average loss: 0.298742\n",
      "Epoch [150 / 150] average loss: 0.298426\n"
     ]
    }
   ],
   "source": [
    "optimizer = torch.optim.Adam(params=convnet.parameters(), lr=learning_rate)\n",
    "\n",
    "# set to training mode\n",
    "convnet.train()\n",
    "\n",
    "train_loss_avg = []\n",
    "\n",
    "filters = []\n",
    "\n",
    "print('Training ...')\n",
    "for epoch in range(num_epochs):\n",
    "    train_loss_avg.append(0)\n",
    "    num_batches = 0\n",
    "    filters.append([])\n",
    "    \n",
    "    for image_batch, label_batch in train_dataloader:\n",
    "        \n",
    "        image_batch = image_batch.to(device)\n",
    "        label_batch = label_batch.to(device)\n",
    "        \n",
    "        # class predictions\n",
    "        prediction_batch = convnet(image_batch)\n",
    "        \n",
    "        # The cross-entropy loss.\n",
    "        # The first input are the predicted log class probabilities.\n",
    "        # The ground truth probabilites for each image are expected to be\n",
    "        # 1 for a single class and 0 for all other classes.\n",
    "        # This function expects as second input the index of the class with probability 1.\n",
    "        # (this function is not called cross-entropy, since this function assumes\n",
    "        # that the inputs are log probabilities, not probabilities).\n",
    "        loss = F.nll_loss(prediction_batch, label_batch)\n",
    "        \n",
    "        # backpropagation\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        \n",
    "        # one step of the optmizer (using the gradients from backpropagation)\n",
    "        optimizer.step()\n",
    "        \n",
    "        train_loss_avg[-1] += loss.item()\n",
    "        num_batches += 1\n",
    "        \n",
    "    # store filters learned in this epoch\n",
    "    for i, conv in enumerate([convnet.conv1, convnet.conv2, convnet.conv3, convnet.conv4]):\n",
    "        weights = conv.weight.data.view(-1, 1, conv.weight.size(2), conv.weight.size(3))\n",
    "        filters[-1].append(weights[filter_inds[i], :, :, :].cpu())\n",
    "        \n",
    "    train_loss_avg[-1] /= num_batches\n",
    "    print('Epoch [%d / %d] average loss: %f' % (epoch+1, num_epochs, train_loss_avg[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot Training Curve\n",
    "--------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.ion()\n",
    "\n",
    "fig = plt.figure()\n",
    "plt.plot(train_loss_avg)\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Cross-entropy loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively: Load Pre-Trained Model\n",
    "-----------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'filter_vis_convnet.pth'\n",
    "import urllib\n",
    "if not os.path.isdir('./pretrained'):\n",
    "    os.makedirs('./pretrained')\n",
    "print('downloading ...')\n",
    "urllib.request.urlretrieve (\"http://geometry.cs.ucl.ac.uk/creativeai/pretrained/\"+filename, \"./pretrained/\"+filename)\n",
    "convnet.load_state_dict(torch.load('./pretrained/'+filename))\n",
    "print('done')\n",
    "\n",
    "# this is how the model parameters can be saved:\n",
    "# torch.save(convnet.state_dict(), './pretrained/my_filter_vis_convnet.pth')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate on the Test Set\n",
    "-------------------------\n",
    "\n",
    "The best current methods achieve a classification error percentage of around 3.47%. See [here](http://rodrigob.github.io/are_we_there_yet/build/classification_datasets_results.html#43494641522d3130) for a leaderboard."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average loss: 0.608837\n",
      "classification error: 16.390000%\n"
     ]
    }
   ],
   "source": [
    "# set to evaluation mode\n",
    "convnet.eval()\n",
    "\n",
    "num_incorrect = 0\n",
    "test_loss_avg = 0\n",
    "num_batches = 0\n",
    "num_instances = 0\n",
    "for image_batch, label_batch in test_dataloader:\n",
    "    \n",
    "    with torch.no_grad():\n",
    "\n",
    "        image_batch = image_batch.to(device)\n",
    "        label_batch = label_batch.to(device)\n",
    "\n",
    "        # class predictions\n",
    "        prediction_batch = convnet(image_batch)\n",
    "\n",
    "        # get number of correct and incorrect class predictions\n",
    "        _, predicted_label = prediction_batch.max(dim=1)\n",
    "        num_incorrect += (predicted_label != label_batch).sum().item()\n",
    "\n",
    "        # cross-entropy loss\n",
    "        loss = F.nll_loss(prediction_batch, label_batch)\n",
    "\n",
    "        test_loss_avg += loss.item()\n",
    "        num_batches += 1\n",
    "        num_instances += image_batch.size(0)\n",
    "    \n",
    "test_loss_avg /= num_batches\n",
    "print('average loss: %f' % (test_loss_avg))\n",
    "print('classification error: %f%%' % ((num_incorrect / num_instances)*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Filter Visualizations\n",
    "-------------------------\n",
    "Filters that compute useful features are usually smooth. Visualizing these filters can give an indication if the network learned something useful or rather just overfitted to the data. In our model there is some overfitting (some filters are still noisy), but most filters look relatively smooth, indicating a successful training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "plt.ion()\n",
    "import torchvision.utils\n",
    "\n",
    "with torch.no_grad():\n",
    "\n",
    "    def filter_collage(filter_weights, nrow):\n",
    "        filter_max = filter_weights.view(filter_weights.size(0), 1, -1).max(dim=2)[0].view(filter_weights.size(0), 1, 1, 1)\n",
    "        filter_min = filter_weights.view(filter_weights.size(0), 1, -1).min(dim=2)[0].view(filter_weights.size(0), 1, 1, 1)\n",
    "        filter_weights = (filter_weights - filter_min) / (filter_max - filter_min)\n",
    "        return torchvision.utils.make_grid(filter_weights, nrow=nrow)\n",
    "\n",
    "    def show_tensor(tensor):\n",
    "        fig, ax = plt.subplots(figsize=(7, 7), nrows=1, ncols=1)\n",
    "        ax.imshow(np.transpose(tensor.numpy(), (1, 2, 0)))\n",
    "        plt.show()\n",
    "\n",
    "    show_tensor(filter_collage(filters[-1][0], nrow=10))\n",
    "    show_tensor(filter_collage(filters[-1][1], nrow=10))\n",
    "    show_tensor(filter_collage(filters[-1][2], nrow=10))\n",
    "    show_tensor(filter_collage(filters[-1][3], nrow=10))"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}