├── README.md ├── assets ├── results_resnet.png └── results_vgg11_vgg16bn.png ├── data └── valprep.sh ├── resnets.ipynb ├── vgg11.ipynb └── vgg16_bn.ipynb /README.md: -------------------------------------------------------------------------------- 1 | ### Overview 2 | Very simple replication of the Figure A2 (b) shown in the paper, On the importance of single directions for generalization(Morcos et al, ICLR 2018), which demonstrates that class selectivity increases with depth.
3 | The original paper used resnet-50 but this code uses vgg11. Please refer to the original paper for the details. 4 | 5 |

6 | 7 | 8 |

9 |
10 | 11 | This code is tested on NVIDIA GTX 1080 Ti(11GB), i7-8700, 32GB RAM, and will occupy ~29GB and ~22GB for vgg11 and vgg16_bn respectively if save_outputs is set to True. 12 | 13 | ### Dependencies 14 | ``` 15 | python 3.6.4 16 | pytorch 0.4.0 17 | tqdm 18 | ``` 19 | 20 | ### File Structure 21 | ``` 22 | . 23 | └── README.md 24 | ├── vgg11.ipynb 25 | ├── vgg16_bn.ipynb 26 | ├── assets 27 | └── results_vgg11_vgg16bn.png 28 | ├── data 29 | └── ILSVRC2012_img_val 30 | └── n01440764 31 | ├── n01443537 32 | ├── n01484850 33 | ├── ... 34 | └── n15075141 35 | ├── outputs 36 | └── vgg11 37 | ├── classifier_1_activations.pth 38 | ├── classifier_1_selectivity_results.pth 39 | ├── ... 40 | └── features_9_selectivity_results.pth 41 | └── ... 42 | ``` 43 | 44 | ### Dataset Setting 45 | ``` 46 | cd data 47 | wget http://www.image-net.org/challenges/LSVRC/2012/nnoupb/ILSVRC2012_img_val.tar 48 | mkdir ILSVRC2012_img_val 49 | mv ILSVRC2012_img_val.tar ILSVRC2012_img_val 50 | mv valprep.sh ILSVRC2012_img_val 51 | cd ILSVRC2012_img_val 52 | tar -xvf ILSVRC2012_img_val.tar 53 | sh valprep.sh 54 | ``` 55 | 56 | ### Reference 57 | 1. On the importance of single directions for generalization, Morcos et al, ICLR, 2018 58 | -------------------------------------------------------------------------------- /assets/results_resnet.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1Konny/class_selectivity_index/3242adb830951f3c71a6fb768a3e44ca365eee10/assets/results_resnet.png -------------------------------------------------------------------------------- /assets/results_vgg11_vgg16bn.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/1Konny/class_selectivity_index/3242adb830951f3c71a6fb768a3e44ca365eee10/assets/results_vgg11_vgg16bn.png -------------------------------------------------------------------------------- /resnets.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Module Import" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "import os\n", 17 | "import numpy as np\n", 18 | "\n", 19 | "import torch\n", 20 | "from torch.utils.data import DataLoader\n", 21 | "\n", 22 | "import torchvision.models as models\n", 23 | "from torchvision import transforms\n", 24 | "from torchvision.datasets import ImageFolder\n", 25 | "\n", 26 | "from tqdm import tqdm_notebook\n", 27 | "\n", 28 | "save_outputs = True \n", 29 | "output_dir = 'outputs/resnet50/'\n", 30 | "os.makedirs(output_dir, exist_ok=True)" 31 | ] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "metadata": {}, 36 | "source": [ 37 | "## Initialize resnet" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 2, 43 | "metadata": {}, 44 | "outputs": [ 45 | { 46 | "data": { 47 | "text/plain": [ 48 | "ResNet(\n", 49 | " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", 50 | " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 51 | " (relu): ReLU(inplace)\n", 52 | " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", 53 | " (layer1): Sequential(\n", 54 | " (0): Bottleneck(\n", 55 | " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 56 | " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 57 | " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 58 | " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 59 | " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 60 | " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 61 | " (relu): ReLU(inplace)\n", 62 | " (downsample): Sequential(\n", 63 | " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 64 | " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 65 | " )\n", 66 | " )\n", 67 | " (1): Bottleneck(\n", 68 | " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 69 | " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 70 | " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 71 | " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 72 | " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 73 | " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 74 | " (relu): ReLU(inplace)\n", 75 | " )\n", 76 | " (2): Bottleneck(\n", 77 | " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 78 | " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 79 | " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 80 | " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 81 | " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 82 | " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 83 | " (relu): ReLU(inplace)\n", 84 | " )\n", 85 | " )\n", 86 | " (layer2): Sequential(\n", 87 | " (0): Bottleneck(\n", 88 | " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 89 | " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 90 | " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", 91 | " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 92 | " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 93 | " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 94 | " (relu): ReLU(inplace)\n", 95 | " (downsample): Sequential(\n", 96 | " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", 97 | " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 98 | " )\n", 99 | " )\n", 100 | " (1): Bottleneck(\n", 101 | " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 102 | " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 103 | " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 104 | " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 105 | " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 106 | " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 107 | " (relu): ReLU(inplace)\n", 108 | " )\n", 109 | " (2): Bottleneck(\n", 110 | " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 111 | " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 112 | " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 113 | " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 114 | " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 115 | " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 116 | " (relu): ReLU(inplace)\n", 117 | " )\n", 118 | " (3): Bottleneck(\n", 119 | " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 120 | " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 121 | " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 122 | " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 123 | " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 124 | " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 125 | " (relu): ReLU(inplace)\n", 126 | " )\n", 127 | " )\n", 128 | " (layer3): Sequential(\n", 129 | " (0): Bottleneck(\n", 130 | " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 131 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 132 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", 133 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 134 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 135 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 136 | " (relu): ReLU(inplace)\n", 137 | " (downsample): Sequential(\n", 138 | " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", 139 | " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 140 | " )\n", 141 | " )\n", 142 | " (1): Bottleneck(\n", 143 | " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 144 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 145 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 146 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 147 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 148 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 149 | " (relu): ReLU(inplace)\n", 150 | " )\n", 151 | " (2): Bottleneck(\n", 152 | " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 153 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 154 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 155 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 156 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 157 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 158 | " (relu): ReLU(inplace)\n", 159 | " )\n", 160 | " (3): Bottleneck(\n", 161 | " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 162 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 163 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 164 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 165 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 166 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 167 | " (relu): ReLU(inplace)\n", 168 | " )\n", 169 | " (4): Bottleneck(\n", 170 | " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 171 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 172 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 173 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 174 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 175 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 176 | " (relu): ReLU(inplace)\n", 177 | " )\n", 178 | " (5): Bottleneck(\n", 179 | " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 180 | " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 181 | " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 182 | " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 183 | " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 184 | " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 185 | " (relu): ReLU(inplace)\n", 186 | " )\n", 187 | " )\n", 188 | " (layer4): Sequential(\n", 189 | " (0): Bottleneck(\n", 190 | " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 191 | " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 192 | " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", 193 | " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 194 | " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 195 | " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 196 | " (relu): ReLU(inplace)\n", 197 | " (downsample): Sequential(\n", 198 | " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", 199 | " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 200 | " )\n", 201 | " )\n", 202 | " (1): Bottleneck(\n", 203 | " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 204 | " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 205 | " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 206 | " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 207 | " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 208 | " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 209 | " (relu): ReLU(inplace)\n", 210 | " )\n", 211 | " (2): Bottleneck(\n", 212 | " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 213 | " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 214 | " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", 215 | " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 216 | " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", 217 | " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", 218 | " (relu): ReLU(inplace)\n", 219 | " )\n", 220 | " )\n", 221 | " (avgpool): AvgPool2d(kernel_size=7, stride=1, padding=0)\n", 222 | " (fc): Linear(in_features=2048, out_features=1000, bias=True)\n", 223 | ")" 224 | ] 225 | }, 226 | "execution_count": 2, 227 | "metadata": {}, 228 | "output_type": "execute_result" 229 | } 230 | ], 231 | "source": [ 232 | "net = models.resnet50(pretrained=True)\n", 233 | "net.eval()\n", 234 | "net.cuda()" 235 | ] 236 | }, 237 | { 238 | "cell_type": "markdown", 239 | "metadata": {}, 240 | "source": [ 241 | "## and set hooks to extract hidden activations across layers" 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": 3, 247 | "metadata": {}, 248 | "outputs": [ 249 | { 250 | "name": "stdout", 251 | "output_type": "stream", 252 | "text": [ 253 | "layer1 are registered\n", 254 | "layer2 are registered\n", 255 | "layer3 are registered\n", 256 | "layer4 are registered\n", 257 | "avgpool are registered\n" 258 | ] 259 | } 260 | ], 261 | "source": [ 262 | "hidden_outputs = {}\n", 263 | "def named_hook(name):\n", 264 | " def hook(module, input, output):\n", 265 | " hidden_outputs[name] = output\n", 266 | " return hook\n", 267 | "\n", 268 | "activations = dict(layer1=[], layer2=[], layer3=[], layer4=[],\n", 269 | " avgpool=[])\n", 270 | "\n", 271 | "for name in activations.keys():\n", 272 | " if 'layer' in name:\n", 273 | " net._modules[name][-1].relu.register_forward_hook(named_hook(name))\n", 274 | " elif 'avgpool' == name:\n", 275 | " net.avgpool.register_forward_hook(named_hook(name))\n", 276 | " \n", 277 | " print('{} are registered'.format(name))" 278 | ] 279 | }, 280 | { 281 | "cell_type": "markdown", 282 | "metadata": {}, 283 | "source": [ 284 | "## Initialize dataset & data loader" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": 4, 290 | "metadata": {}, 291 | "outputs": [ 292 | { 293 | "name": "stdout", 294 | "output_type": "stream", 295 | "text": [ 296 | "# of images : 50000\n" 297 | ] 298 | } 299 | ], 300 | "source": [ 301 | "img_root = './data/ILSVRC2012_img_val/'\n", 302 | "transform = transforms.Compose([\n", 303 | " transforms.Resize((224, 224)),\n", 304 | " transforms.ToTensor(),\n", 305 | " transforms.Normalize(mean=(0.485, 0.456, 0.406),\n", 306 | " std=(0.229, 0.224, 0.225))\n", 307 | "])\n", 308 | "\n", 309 | "num_class = 1000\n", 310 | "imgs_per_class = 50\n", 311 | "batch_size = 25\n", 312 | "iters_per_class = imgs_per_class//batch_size\n", 313 | "assert imgs_per_class/batch_size == float(iters_per_class)\n", 314 | "\n", 315 | "num_workers = 6\n", 316 | "dset = ImageFolder(img_root, transform=transform)\n", 317 | "dloader = DataLoader(dset, batch_size=batch_size, drop_last=False, shuffle=False, num_workers=num_workers)\n", 318 | "print('# of images :', len(dset))" 319 | ] 320 | }, 321 | { 322 | "cell_type": "markdown", 323 | "metadata": {}, 324 | "source": [ 325 | "## Extract hidden activations" 326 | ] 327 | }, 328 | { 329 | "cell_type": "code", 330 | "execution_count": 5, 331 | "metadata": {}, 332 | "outputs": [ 333 | { 334 | "name": "stdout", 335 | "output_type": "stream", 336 | "text": [ 337 | "start extracting class-conditional hidden activations.\n" 338 | ] 339 | }, 340 | { 341 | "data": { 342 | "application/vnd.jupyter.widget-view+json": { 343 | "model_id": "0a526c3e3bda484da43fa9f005a972cc", 344 | "version_major": 2, 345 | "version_minor": 0 346 | }, 347 | "text/plain": [ 348 | "HBox(children=(IntProgress(value=0, max=1000), HTML(value='')))" 349 | ] 350 | }, 351 | "metadata": {}, 352 | "output_type": "display_data" 353 | }, 354 | { 355 | "name": "stdout", 356 | "output_type": "stream", 357 | "text": [ 358 | "\n", 359 | "merge activations. this takes time if save_outputs==True\n", 360 | "outputs/resnet50/layer1_activations.pth is saved\n", 361 | "outputs/resnet50/layer2_activations.pth is saved\n", 362 | "outputs/resnet50/layer3_activations.pth is saved\n", 363 | "outputs/resnet50/layer4_activations.pth is saved\n", 364 | "outputs/resnet50/avgpool_activations.pth is saved\n" 365 | ] 366 | } 367 | ], 368 | "source": [ 369 | "print('start extracting class-conditional hidden activations.')\n", 370 | "loader = iter(dloader)\n", 371 | "for i in tqdm_notebook(range(num_class)):\n", 372 | " \n", 373 | " class_conditional_activations = dict()\n", 374 | " for name in activations:\n", 375 | " class_conditional_activations[name] = 0.\n", 376 | " \n", 377 | " for k in range(iters_per_class):\n", 378 | " img, label = loader.next()\n", 379 | " img = img.cuda()\n", 380 | " net(img)\n", 381 | "\n", 382 | " for name in activations:\n", 383 | " output_name = name\n", 384 | " class_conditional_activations[name] += hidden_outputs[output_name].view(batch_size, -1).sum(0).div(imgs_per_class).data.cpu()\n", 385 | " \n", 386 | " for name in activations:\n", 387 | " activations[name].append(class_conditional_activations[name])\n", 388 | " \n", 389 | "print('merge activations. this takes time if save_outputs==True')\n", 390 | "for name in activations:\n", 391 | " activations[name] = torch.stack(activations[name], dim=0)\n", 392 | " \n", 393 | " if save_outputs:\n", 394 | " activations_path = os.path.join(output_dir, name+'_activations.pth')\n", 395 | " with open(activations_path, 'wb+') as f:\n", 396 | " torch.save(activations[name], activations_path)\n", 397 | " print('{} is saved'.format(activations_path))" 398 | ] 399 | }, 400 | { 401 | "cell_type": "markdown", 402 | "metadata": {}, 403 | "source": [ 404 | "## Calculate Class Selectivity Index" 405 | ] 406 | }, 407 | { 408 | "cell_type": "code", 409 | "execution_count": 6, 410 | "metadata": {}, 411 | "outputs": [ 412 | { 413 | "name": "stdout", 414 | "output_type": "stream", 415 | "text": [ 416 | "start calculating class selectivity index\n" 417 | ] 418 | }, 419 | { 420 | "data": { 421 | "application/vnd.jupyter.widget-view+json": { 422 | "model_id": "37745678e20a4f348ea64dfb92889a65", 423 | "version_major": 2, 424 | "version_minor": 0 425 | }, 426 | "text/plain": [ 427 | "HBox(children=(IntProgress(value=0, max=802816), HTML(value='')))" 428 | ] 429 | }, 430 | "metadata": {}, 431 | "output_type": "display_data" 432 | }, 433 | { 434 | "name": "stdout", 435 | "output_type": "stream", 436 | "text": [ 437 | "\n", 438 | "outputs/resnet50/layer1_selectivity_results.pth is saved\n" 439 | ] 440 | }, 441 | { 442 | "data": { 443 | "application/vnd.jupyter.widget-view+json": { 444 | "model_id": "be731948904d4bf898c6d039fbd5a038", 445 | "version_major": 2, 446 | "version_minor": 0 447 | }, 448 | "text/plain": [ 449 | "HBox(children=(IntProgress(value=0, max=401408), HTML(value='')))" 450 | ] 451 | }, 452 | "metadata": {}, 453 | "output_type": "display_data" 454 | }, 455 | { 456 | "name": "stdout", 457 | "output_type": "stream", 458 | "text": [ 459 | "\n", 460 | "outputs/resnet50/layer2_selectivity_results.pth is saved\n" 461 | ] 462 | }, 463 | { 464 | "data": { 465 | "application/vnd.jupyter.widget-view+json": { 466 | "model_id": "2e8bc6009ab34d9ba85e19314f59d74c", 467 | "version_major": 2, 468 | "version_minor": 0 469 | }, 470 | "text/plain": [ 471 | "HBox(children=(IntProgress(value=0, max=200704), HTML(value='')))" 472 | ] 473 | }, 474 | "metadata": {}, 475 | "output_type": "display_data" 476 | }, 477 | { 478 | "name": "stdout", 479 | "output_type": "stream", 480 | "text": [ 481 | "\n", 482 | "outputs/resnet50/layer3_selectivity_results.pth is saved\n" 483 | ] 484 | }, 485 | { 486 | "data": { 487 | "application/vnd.jupyter.widget-view+json": { 488 | "model_id": "0d16969812f14717965150dec2ca4284", 489 | "version_major": 2, 490 | "version_minor": 0 491 | }, 492 | "text/plain": [ 493 | "HBox(children=(IntProgress(value=0, max=100352), HTML(value='')))" 494 | ] 495 | }, 496 | "metadata": {}, 497 | "output_type": "display_data" 498 | }, 499 | { 500 | "name": "stdout", 501 | "output_type": "stream", 502 | "text": [ 503 | "\n", 504 | "outputs/resnet50/layer4_selectivity_results.pth is saved\n" 505 | ] 506 | }, 507 | { 508 | "data": { 509 | "application/vnd.jupyter.widget-view+json": { 510 | "model_id": "669b5d75cb804f9ea0fcaa58e21c800c", 511 | "version_major": 2, 512 | "version_minor": 0 513 | }, 514 | "text/plain": [ 515 | "HBox(children=(IntProgress(value=0, max=2048), HTML(value='')))" 516 | ] 517 | }, 518 | "metadata": {}, 519 | "output_type": "display_data" 520 | }, 521 | { 522 | "name": "stdout", 523 | "output_type": "stream", 524 | "text": [ 525 | "\n", 526 | "outputs/resnet50/avgpool_selectivity_results.pth is saved\n" 527 | ] 528 | } 529 | ], 530 | "source": [ 531 | "print('start calculating class selectivity index')\n", 532 | "result = {}\n", 533 | "for name in activations:\n", 534 | " layer_act = activations[name]\n", 535 | "\n", 536 | " num_class, num_neuron = layer_act.size()\n", 537 | " dead_neuron_class = torch.tensor(num_class)\n", 538 | " dead_neuron_confidence = torch.tensor(0.)\n", 539 | "\n", 540 | " selected_class = []\n", 541 | " selectivity_index = []\n", 542 | " for neuron_idx in tqdm_notebook(range(num_neuron)):\n", 543 | " neuron_act = layer_act[:, neuron_idx]\n", 544 | "\n", 545 | " # In the case of mean activations of a neuron are all zero across whole classes\n", 546 | " # Simply consider that neuron as dead neuron.\n", 547 | " if neuron_act.nonzero().size(0) == 0: \n", 548 | " class_selected = dead_neuron_class\n", 549 | " class_confidence = dead_neuron_confidence\n", 550 | " else:\n", 551 | " class_selected = neuron_act.argmax()\n", 552 | " mu_max = neuron_act[class_selected]\n", 553 | " mu_mmax = (neuron_act.sum()-mu_max).div(num_class-1)\n", 554 | " class_confidence = (mu_max-mu_mmax).div(mu_max+mu_mmax)\n", 555 | "\n", 556 | " selected_class.append(class_selected) \n", 557 | " selectivity_index.append(class_confidence)\n", 558 | "\n", 559 | " selected_class = torch.stack(selected_class, 0)\n", 560 | " selectivity_index = torch.stack(selectivity_index, 0)\n", 561 | " \n", 562 | " result[name] = dict()\n", 563 | " result[name]['selected_class'] = selected_class\n", 564 | " result[name]['selectivity_index'] = selectivity_index\n", 565 | " \n", 566 | " if save_outputs:\n", 567 | " result_path = os.path.join(output_dir, name+'_selectivity_results.pth')\n", 568 | " with open(result_path, 'wb+') as f:\n", 569 | " torch.save(result[name], result_path)\n", 570 | " print('{} is saved'.format(result_path))" 571 | ] 572 | }, 573 | { 574 | "cell_type": "markdown", 575 | "metadata": {}, 576 | "source": [ 577 | "## Plot class selectivity distributions as a function of depth" 578 | ] 579 | }, 580 | { 581 | "cell_type": "code", 582 | "execution_count": 7, 583 | "metadata": {}, 584 | "outputs": [ 585 | { 586 | "name": "stderr", 587 | "output_type": "stream", 588 | "text": [ 589 | "/home/wonkonge/anaconda3/envs/kongda_py36_torch40/lib/python3.6/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: The set_color_cycle function was deprecated in version 1.5. Use `.set_prop_cycle` instead.\n", 590 | " import sys\n" 591 | ] 592 | }, 593 | { 594 | "data": { 595 | "image/png": "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\n", 596 | "text/plain": [ 597 | "
" 598 | ] 599 | }, 600 | "metadata": {}, 601 | "output_type": "display_data" 602 | } 603 | ], 604 | "source": [ 605 | "import matplotlib.pyplot as plt\n", 606 | "%matplotlib inline\n", 607 | "\n", 608 | "num_plots = len(result)\n", 609 | "colormap = plt.cm.jet\n", 610 | "plt.figure(figsize=(10,10))\n", 611 | "plt.gca().set_color_cycle([colormap(i) for i in np.linspace(0, 0.9, num_plots)]);\n", 612 | "\n", 613 | "labels = []\n", 614 | "for name in result:\n", 615 | " selectivity_index = result[name]['selectivity_index']\n", 616 | " selectivity_index_hist = np.histogram(selectivity_index*100, bins=100, normed=True)\n", 617 | " x = np.arange(len(selectivity_index_hist[0]))/len(selectivity_index_hist[0])\n", 618 | " y = selectivity_index_hist[0]\n", 619 | " plt.fill_between(x, y, step=\"pre\", alpha=0.6)\n", 620 | " plt.plot(x, y)\n", 621 | " labels.append(name)\n", 622 | "\n", 623 | "plt.legend(labels, ncol=1, loc='upper right', \n", 624 | " columnspacing=2.0, labelspacing=1,\n", 625 | " handletextpad=0.5, handlelength=1.5,\n", 626 | " fancybox=True, shadow=True)\n", 627 | "plt.ylabel('PDF', fontsize=15, labelpad=15)\n", 628 | "plt.xlabel('Selectivity Index', fontsize=15, labelpad=15)\n", 629 | "\n", 630 | "figname = os.path.join(output_dir, 'histogram.png')\n", 631 | "plt.savefig(figname)\n", 632 | "plt.show()" 633 | ] 634 | } 635 | ], 636 | "metadata": { 637 | "kernelspec": { 638 | "display_name": "Python 3", 639 | "language": "python", 640 | "name": "python3" 641 | }, 642 | "language_info": { 643 | "codemirror_mode": { 644 | "name": "ipython", 645 | "version": 3 646 | }, 647 | "file_extension": ".py", 648 | "mimetype": "text/x-python", 649 | "name": "python", 650 | "nbconvert_exporter": "python", 651 | "pygments_lexer": "ipython3", 652 | "version": "3.6.5" 653 | } 654 | }, 655 | "nbformat": 4, 656 | "nbformat_minor": 2 657 | } 658 | -------------------------------------------------------------------------------- /vgg11.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Module Import" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "import os\n", 17 | "import numpy as np\n", 18 | "\n", 19 | "import torch\n", 20 | "from torch.utils.data import DataLoader\n", 21 | "\n", 22 | "import torchvision.models as models\n", 23 | "from torchvision import transforms\n", 24 | "from torchvision.datasets import ImageFolder\n", 25 | "\n", 26 | "from tqdm import tqdm_notebook\n", 27 | "\n", 28 | "save_outputs = False # whether to save intermediate outputs for later reuse.\n", 29 | "output_dir = 'outputs/vgg11/'\n", 30 | "os.makedirs(output_dir, exist_ok=True)" 31 | ] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "metadata": {}, 36 | "source": [ 37 | "## Initialize vgg11 and set hooks to extract hidden activations across layers" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 2, 43 | "metadata": {}, 44 | "outputs": [ 45 | { 46 | "name": "stdout", 47 | "output_type": "stream", 48 | "text": [ 49 | "features_1 activations are registered\n", 50 | "features_4 activations are registered\n", 51 | "features_7 activations are registered\n", 52 | "features_9 activations are registered\n", 53 | "features_12 activations are registered\n", 54 | "features_14 activations are registered\n", 55 | "features_17 activations are registered\n", 56 | "features_19 activations are registered\n", 57 | "classifier_1 activations are registered\n", 58 | "classifier_4 activations are registered\n" 59 | ] 60 | } 61 | ], 62 | "source": [ 63 | "net = models.vgg11(pretrained=True)\n", 64 | "net.eval()\n", 65 | "net.cuda()\n", 66 | "\n", 67 | "hidden_outputs = {}\n", 68 | "def named_hook(name):\n", 69 | " def hook(module, input, output):\n", 70 | " hidden_outputs[name] = output\n", 71 | " return hook\n", 72 | "\n", 73 | "activations = dict(features_1=[], features_4=[], features_7=[],\n", 74 | " features_9=[], features_12=[], features_14=[],\n", 75 | " features_17=[], features_19=[], classifier_1=[],\n", 76 | " classifier_4=[])\n", 77 | "\n", 78 | "for name in activations.keys():\n", 79 | " meta_arch_name, layer_idx = name.split('_')\n", 80 | " layer_idx = int(layer_idx)\n", 81 | " if meta_arch_name == 'features':\n", 82 | " net.features[layer_idx].register_forward_hook(named_hook(meta_arch_name+'_'+str(layer_idx)))\n", 83 | " elif meta_arch_name == 'classifier':\n", 84 | " net.classifier[layer_idx].register_forward_hook(named_hook(meta_arch_name+'_'+str(layer_idx)))\n", 85 | " \n", 86 | " print('{}_{} activations are registered'.format(meta_arch_name, layer_idx))" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "## Initialize dataset & data loader" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 3, 99 | "metadata": {}, 100 | "outputs": [ 101 | { 102 | "name": "stdout", 103 | "output_type": "stream", 104 | "text": [ 105 | "# of images : 50000\n" 106 | ] 107 | } 108 | ], 109 | "source": [ 110 | "img_root = './data/ILSVRC2012_img_val/'\n", 111 | "transform = transforms.Compose([\n", 112 | " transforms.Resize((224, 224)),\n", 113 | " transforms.ToTensor(),\n", 114 | " transforms.Normalize(mean=(0.485, 0.456, 0.406),\n", 115 | " std=(0.229, 0.224, 0.225))\n", 116 | "])\n", 117 | "\n", 118 | "num_class = 1000\n", 119 | "imgs_per_class = 50\n", 120 | "batch_size = 25\n", 121 | "iters_per_class = imgs_per_class//batch_size\n", 122 | "assert imgs_per_class/batch_size == float(iters_per_class)\n", 123 | "\n", 124 | "num_workers = 6\n", 125 | "dset = ImageFolder(img_root, transform=transform)\n", 126 | "dloader = DataLoader(dset, batch_size=batch_size, drop_last=False, shuffle=False, num_workers=num_workers)\n", 127 | "print('# of images :', len(dset))" 128 | ] 129 | }, 130 | { 131 | "cell_type": "markdown", 132 | "metadata": {}, 133 | "source": [ 134 | "## Extract hidden activations" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 4, 140 | "metadata": {}, 141 | "outputs": [ 142 | { 143 | "name": "stdout", 144 | "output_type": "stream", 145 | "text": [ 146 | "start extracting class-conditional hidden activations.\n" 147 | ] 148 | }, 149 | { 150 | "data": { 151 | "application/vnd.jupyter.widget-view+json": { 152 | "model_id": "80ec74eff7cc49e7916984000e2ab3b1", 153 | "version_major": 2, 154 | "version_minor": 0 155 | }, 156 | "text/plain": [ 157 | "HBox(children=(IntProgress(value=0, max=1000), HTML(value='')))" 158 | ] 159 | }, 160 | "metadata": {}, 161 | "output_type": "display_data" 162 | }, 163 | { 164 | "name": "stdout", 165 | "output_type": "stream", 166 | "text": [ 167 | "\n", 168 | "merge activations. this will take a long time if save_outputs==True\n" 169 | ] 170 | } 171 | ], 172 | "source": [ 173 | "print('start extracting class-conditional hidden activations.')\n", 174 | "loader = iter(dloader)\n", 175 | "for i in tqdm_notebook(range(num_class)):\n", 176 | " \n", 177 | " class_conditional_activations = dict()\n", 178 | " for name in activations:\n", 179 | " class_conditional_activations[name] = 0.\n", 180 | " \n", 181 | " for k in range(iters_per_class):\n", 182 | " img, label = loader.next()\n", 183 | " img = img.cuda()\n", 184 | " net(img)\n", 185 | "\n", 186 | " for name in activations:\n", 187 | " meta_arch_name, layer_idx = name.split('_')\n", 188 | " layer_idx = int(layer_idx)\n", 189 | " output_name = meta_arch_name+'_'+str(layer_idx)\n", 190 | " class_conditional_activations[name] += hidden_outputs[output_name].view(batch_size, -1).sum(0).div(imgs_per_class).data.cpu()\n", 191 | " \n", 192 | " for name in activations:\n", 193 | " activations[name].append(class_conditional_activations[name])\n", 194 | " \n", 195 | "print('merge activations. this takes time if save_outputs==True')\n", 196 | "for name in activations:\n", 197 | " activations[name] = torch.stack(activations[name], dim=0)\n", 198 | " \n", 199 | " if save_outputs:\n", 200 | " activations_path = os.path.join(output_dir, name+'_activations.pth')\n", 201 | " with open(activations_path, 'wb+') as f:\n", 202 | " torch.save(activations[name], activations_path)\n", 203 | " print('{} is saved'.format(activations_path))" 204 | ] 205 | }, 206 | { 207 | "cell_type": "markdown", 208 | "metadata": {}, 209 | "source": [ 210 | "## Calculate Class Selectivity Index" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 5, 216 | "metadata": {}, 217 | "outputs": [ 218 | { 219 | "name": "stdout", 220 | "output_type": "stream", 221 | "text": [ 222 | "start calculating class selectivity index\n" 223 | ] 224 | }, 225 | { 226 | "data": { 227 | "application/vnd.jupyter.widget-view+json": { 228 | "model_id": "6fb425274fc94523bbbdc9bc9f9b4e7e", 229 | "version_major": 2, 230 | "version_minor": 0 231 | }, 232 | "text/plain": [ 233 | "HBox(children=(IntProgress(value=0, max=3211264), HTML(value='')))" 234 | ] 235 | }, 236 | "metadata": {}, 237 | "output_type": "display_data" 238 | }, 239 | { 240 | "name": "stdout", 241 | "output_type": "stream", 242 | "text": [ 243 | "\n" 244 | ] 245 | }, 246 | { 247 | "data": { 248 | "application/vnd.jupyter.widget-view+json": { 249 | "model_id": "de8a67f486694fec9d353fa96c8bb881", 250 | "version_major": 2, 251 | "version_minor": 0 252 | }, 253 | "text/plain": [ 254 | "HBox(children=(IntProgress(value=0, max=1605632), HTML(value='')))" 255 | ] 256 | }, 257 | "metadata": {}, 258 | "output_type": "display_data" 259 | }, 260 | { 261 | "name": "stdout", 262 | "output_type": "stream", 263 | "text": [ 264 | "\n" 265 | ] 266 | }, 267 | { 268 | "data": { 269 | "application/vnd.jupyter.widget-view+json": { 270 | "model_id": "ced71cd15b3245e4952d116849266332", 271 | "version_major": 2, 272 | "version_minor": 0 273 | }, 274 | "text/plain": [ 275 | "HBox(children=(IntProgress(value=0, max=802816), HTML(value='')))" 276 | ] 277 | }, 278 | "metadata": {}, 279 | "output_type": "display_data" 280 | }, 281 | { 282 | "name": "stdout", 283 | "output_type": "stream", 284 | "text": [ 285 | "\n" 286 | ] 287 | }, 288 | { 289 | "data": { 290 | "application/vnd.jupyter.widget-view+json": { 291 | "model_id": "c39841c5b49b4fb5be85becf95e1f390", 292 | "version_major": 2, 293 | "version_minor": 0 294 | }, 295 | "text/plain": [ 296 | "HBox(children=(IntProgress(value=0, max=802816), HTML(value='')))" 297 | ] 298 | }, 299 | "metadata": {}, 300 | "output_type": "display_data" 301 | }, 302 | { 303 | "name": "stdout", 304 | "output_type": "stream", 305 | "text": [ 306 | "\n" 307 | ] 308 | }, 309 | { 310 | "data": { 311 | "application/vnd.jupyter.widget-view+json": { 312 | "model_id": "00906f0b4ebb4ce4a6e17ad04859d7f8", 313 | "version_major": 2, 314 | "version_minor": 0 315 | }, 316 | "text/plain": [ 317 | "HBox(children=(IntProgress(value=0, max=401408), HTML(value='')))" 318 | ] 319 | }, 320 | "metadata": {}, 321 | "output_type": "display_data" 322 | }, 323 | { 324 | "name": "stdout", 325 | "output_type": "stream", 326 | "text": [ 327 | "\n" 328 | ] 329 | }, 330 | { 331 | "data": { 332 | "application/vnd.jupyter.widget-view+json": { 333 | "model_id": "94596785a65a43059cb470a1ba5b675f", 334 | "version_major": 2, 335 | "version_minor": 0 336 | }, 337 | "text/plain": [ 338 | "HBox(children=(IntProgress(value=0, max=401408), HTML(value='')))" 339 | ] 340 | }, 341 | "metadata": {}, 342 | "output_type": "display_data" 343 | }, 344 | { 345 | "name": "stdout", 346 | "output_type": "stream", 347 | "text": [ 348 | "\n" 349 | ] 350 | }, 351 | { 352 | "data": { 353 | "application/vnd.jupyter.widget-view+json": { 354 | "model_id": "cdf23491537747c48cab37eb5c2572d2", 355 | "version_major": 2, 356 | "version_minor": 0 357 | }, 358 | "text/plain": [ 359 | "HBox(children=(IntProgress(value=0, max=100352), HTML(value='')))" 360 | ] 361 | }, 362 | "metadata": {}, 363 | "output_type": "display_data" 364 | }, 365 | { 366 | "name": "stdout", 367 | "output_type": "stream", 368 | "text": [ 369 | "\n" 370 | ] 371 | }, 372 | { 373 | "data": { 374 | "application/vnd.jupyter.widget-view+json": { 375 | "model_id": "206e2e051f0d4ab79c0538d95552a5a3", 376 | "version_major": 2, 377 | "version_minor": 0 378 | }, 379 | "text/plain": [ 380 | "HBox(children=(IntProgress(value=0, max=100352), HTML(value='')))" 381 | ] 382 | }, 383 | "metadata": {}, 384 | "output_type": "display_data" 385 | }, 386 | { 387 | "name": "stdout", 388 | "output_type": "stream", 389 | "text": [ 390 | "\n" 391 | ] 392 | }, 393 | { 394 | "data": { 395 | "application/vnd.jupyter.widget-view+json": { 396 | "model_id": "ffa2b72a963a4eea958e366279f97c98", 397 | "version_major": 2, 398 | "version_minor": 0 399 | }, 400 | "text/plain": [ 401 | "HBox(children=(IntProgress(value=0, max=4096), HTML(value='')))" 402 | ] 403 | }, 404 | "metadata": {}, 405 | "output_type": "display_data" 406 | }, 407 | { 408 | "name": "stdout", 409 | "output_type": "stream", 410 | "text": [ 411 | "\n" 412 | ] 413 | }, 414 | { 415 | "data": { 416 | "application/vnd.jupyter.widget-view+json": { 417 | "model_id": "6b4ab1ae817d43a6ae0d6ebb5aa41a4f", 418 | "version_major": 2, 419 | "version_minor": 0 420 | }, 421 | "text/plain": [ 422 | "HBox(children=(IntProgress(value=0, max=4096), HTML(value='')))" 423 | ] 424 | }, 425 | "metadata": {}, 426 | "output_type": "display_data" 427 | }, 428 | { 429 | "name": "stdout", 430 | "output_type": "stream", 431 | "text": [ 432 | "\n" 433 | ] 434 | } 435 | ], 436 | "source": [ 437 | "print('start calculating class selectivity index')\n", 438 | "result = {}\n", 439 | "for name in activations:\n", 440 | " layer_act = activations[name]\n", 441 | "\n", 442 | " num_class, num_neuron = layer_act.size()\n", 443 | " dead_neuron_class = torch.tensor(num_class)\n", 444 | " dead_neuron_confidence = torch.tensor(0.)\n", 445 | "\n", 446 | " selected_class = []\n", 447 | " selectivity_index = []\n", 448 | " for neuron_idx in tqdm_notebook(range(num_neuron)):\n", 449 | " neuron_act = layer_act[:, neuron_idx]\n", 450 | "\n", 451 | " # In the case of mean activations of a neuron are all zero across whole classes\n", 452 | " # Simply consider that neuron as dead neuron.\n", 453 | " if neuron_act.nonzero().size(0) == 0: \n", 454 | " class_selected = dead_neuron_class\n", 455 | " class_confidence = dead_neuron_confidence\n", 456 | " else:\n", 457 | " class_selected = neuron_act.argmax()\n", 458 | " mu_max = neuron_act[class_selected]\n", 459 | " mu_mmax = (neuron_act.sum()-mu_max).div(num_class-1)\n", 460 | " class_confidence = (mu_max-mu_mmax).div(mu_max+mu_mmax)\n", 461 | "\n", 462 | " selected_class.append(class_selected) \n", 463 | " selectivity_index.append(class_confidence)\n", 464 | "\n", 465 | " selected_class = torch.stack(selected_class, 0)\n", 466 | " selectivity_index = torch.stack(selectivity_index, 0)\n", 467 | " \n", 468 | " result[name] = dict()\n", 469 | " result[name]['selected_class'] = selected_class\n", 470 | " result[name]['selectivity_index'] = selectivity_index\n", 471 | " \n", 472 | " if save_outputs:\n", 473 | " result_path = os.path.join(output_dir, name+'_selectivity_results.pth')\n", 474 | " with open(result_path, 'wb+') as f:\n", 475 | " torch.save(result[name], result_path)\n", 476 | " print('{} is saved'.format(result_path))" 477 | ] 478 | }, 479 | { 480 | "cell_type": "markdown", 481 | "metadata": {}, 482 | "source": [ 483 | "## Plot class selectivity distributions as a function of depth" 484 | ] 485 | }, 486 | { 487 | "cell_type": "code", 488 | "execution_count": 6, 489 | "metadata": {}, 490 | "outputs": [ 491 | { 492 | "name": "stderr", 493 | "output_type": "stream", 494 | "text": [ 495 | "/home/wonkonge/anaconda3/envs/kongda_py36_torch40/lib/python3.6/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: The set_color_cycle function was deprecated in version 1.5. Use `.set_prop_cycle` instead.\n", 496 | " import sys\n" 497 | ] 498 | }, 499 | { 500 | "data": { 501 | "image/png": "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\n", 502 | "text/plain": [ 503 | "
" 504 | ] 505 | }, 506 | "metadata": {}, 507 | "output_type": "display_data" 508 | } 509 | ], 510 | "source": [ 511 | "import matplotlib.pyplot as plt\n", 512 | "%matplotlib inline\n", 513 | "\n", 514 | "num_plots = len(result)\n", 515 | "colormap = plt.cm.jet\n", 516 | "plt.figure(figsize=(10,10))\n", 517 | "plt.gca().set_color_cycle([colormap(i) for i in np.linspace(0, 0.9, num_plots)]);\n", 518 | "\n", 519 | "labels = []\n", 520 | "for name in result:\n", 521 | " selectivity_index = result[name]['selectivity_index']\n", 522 | " selectivity_index_hist = np.histogram(selectivity_index*100, bins=100, normed=True)\n", 523 | " x = np.arange(len(selectivity_index_hist[0]))/len(selectivity_index_hist[0])\n", 524 | " y = selectivity_index_hist[0]\n", 525 | " plt.fill_between(x, y, step=\"pre\", alpha=0.6)\n", 526 | " plt.plot(x, y)\n", 527 | " labels.append(name)\n", 528 | "\n", 529 | "plt.legend(labels, ncol=1, loc='upper right', \n", 530 | " columnspacing=2.0, labelspacing=1,\n", 531 | " handletextpad=0.5, handlelength=1.5,\n", 532 | " fancybox=True, shadow=True)\n", 533 | "plt.ylabel('PDF', fontsize=15, labelpad=15)\n", 534 | "plt.xlabel('Selectivity Index', fontsize=15, labelpad=15)\n", 535 | "\n", 536 | "figname = os.path.join(output_dir, 'histogram.png')\n", 537 | "plt.savefig(figname)\n", 538 | "plt.show()" 539 | ] 540 | } 541 | ], 542 | "metadata": { 543 | "kernelspec": { 544 | "display_name": "Python 3", 545 | "language": "python", 546 | "name": "python3" 547 | }, 548 | "language_info": { 549 | "codemirror_mode": { 550 | "name": "ipython", 551 | "version": 3 552 | }, 553 | "file_extension": ".py", 554 | "mimetype": "text/x-python", 555 | "name": "python", 556 | "nbconvert_exporter": "python", 557 | "pygments_lexer": "ipython3", 558 | "version": "3.6.5" 559 | } 560 | }, 561 | "nbformat": 4, 562 | "nbformat_minor": 2 563 | } 564 | --------------------------------------------------------------------------------