gradcam_demo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "d11b145c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from pytorch_grad_cam import GradCAM\n",
    "from torchvision import transforms, datasets\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "b860c516",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.conv = nn.Sequential(\n",
    "                        nn.Conv2d(3, 32, (3,3)),\n",
    "                        nn.MaxPool2d((2,2)),\n",
    "                        nn.ReLU(),\n",
    "                        nn.Conv2d(32, 64, (3,3)),\n",
    "                        nn.MaxPool2d((2,2)),\n",
    "                        nn.ReLU()\n",
    "                    )\n",
    "        \n",
    "        self.fc = nn.Sequential(\n",
    "                        nn.Linear(64, 512),\n",
    "                        nn.ReLU(),\n",
    "                        nn.Linear(512, 128),\n",
    "                        nn.ReLU(),\n",
    "                        nn.Linear(128, 10)\n",
    "                    )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.conv(x)\n",
    "        x = x.view(x.shape[0], 64, 6*6).mean(2)\n",
    "        x = self.fc(x)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "bd854149",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([100, 10])\n"
     ]
    }
   ],
   "source": [
    "x = torch.rand(100, 3, 32, 32)\n",
    "net = CNN()\n",
    "y = net(x)\n",
    "print (y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "bf7fdb11",
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_dataset(dataset):\n",
    "    X = []\n",
    "    y = []\n",
    "    for i, (k, v) in enumerate(dataset.items()):\n",
    "        X.append(v)\n",
    "        y.append([i] * v.shape[0])\n",
    "    X = np.concatenate(X)\n",
    "    y = np.concatenate(y)\n",
    "    X = torch.from_numpy(X).type(torch.float32)\n",
    "    y = torch.from_numpy(y).type(torch.int64)\n",
    "    dataset = TensorDataset(X, y)\n",
    "    dataloader = DataLoader(dataset, batch_size=32, shuffle=True)\n",
    "    return dataset, dataloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7caa8071",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "T = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5,0.5,0.5), (0.5,0.5,0.5))\n",
    "])\n",
    "\n",
    "cifar_train = datasets.CIFAR10(\"./dataset/\", train=True, download=True, transform=T)\n",
    "cifar_test = datasets.CIFAR10(\"./dataset/\", train=False, download=True, transform=T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "63418590",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = torch.utils.data.DataLoader(cifar_train, batch_size=256, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(cifar_test, batch_size=256)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1d43659d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(dataloader, model, loss_fn, optimizer):\n",
    "    size = len(dataloader.dataset)\n",
    "    model.train()\n",
    "    losses = []\n",
    "    for batch, (X, y) in enumerate(dataloader):\n",
    "        pred = model(X)\n",
    "        loss = loss_fn(pred, y)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        if batch % 100 == 0:\n",
    "            loss, current = loss.item(), batch * len(X)\n",
    "            # print(f\"Loss: {loss:>7f}  [{current:>5d}/{size:>5d}]\")\n",
    "            losses.append(loss)\n",
    "    return losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "89655acb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(dataloader, model, loss_fn):\n",
    "    size = len(dataloader.dataset)\n",
    "    num_batches = len(dataloader)\n",
    "    model.eval()\n",
    "    test_loss, correct = 0, 0\n",
    "    with torch.no_grad():\n",
    "        for X, y in dataloader:\n",
    "            pred = model(X)\n",
    "            test_loss += loss_fn(pred, y).item()\n",
    "            correct += (pred.argmax(1) == y).type(torch.float).sum().item()\n",
    "    test_loss /= num_batches\n",
    "    correct /= size\n",
    "    print(f\"Test Error: \\n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \\n\")\n",
    "    return correct * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "ac5b9fdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = CNN()\n",
    "optimizer = torch.optim.AdamW(model.parameters())\n",
    "loss_fn = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "f891c2cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 - Test Error: \n",
      " Accuracy: 35.7%, Avg loss: 1.704811 \n",
      "\n",
      "Epoch 2 - Test Error: \n",
      " Accuracy: 38.8%, Avg loss: 1.616205 \n",
      "\n",
      "Epoch 3 - Test Error: \n",
      " Accuracy: 44.4%, Avg loss: 1.499332 \n",
      "\n",
      "Epoch 4 - Test Error: \n",
      " Accuracy: 48.1%, Avg loss: 1.412171 \n",
      "\n",
      "Epoch 5 - Test Error: \n",
      " Accuracy: 48.7%, Avg loss: 1.383509 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "epochs = 5\n",
    "training_losses = []\n",
    "test_accuracy = []\n",
    "for t in range(epochs):\n",
    "    print(f\"Epoch {t+1} - \", end=\"\")\n",
    "    train_losses = train(train_loader, model, loss_fn, optimizer)\n",
    "    test_acc = test(test_loader, model, loss_fn)\n",
    "    training_losses += train_losses\n",
    "    test_accuracy.append(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "6400fdf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_CAM(feature_map, weight, class_idx):\n",
    "    size_upsample = (32, 32)\n",
    "    bz, nc, h, w = feature_map.shape\n",
    "\n",
    "    before_dot = feature_map.reshape((nc, h*w))\n",
    "    cam = weight[class_idx].unsqueeze(0) @ before_dot\n",
    "\n",
    "    cam = cam.squeeze(0)\n",
    "    cam = cam.reshape(h, w)\n",
    "    cam = cam - torch.min(cam)\n",
    "    cam = cam / torch.max(cam)\n",
    "    cam = torch.clip(cam, 0, 1)\n",
    "    \n",
    "    img = transforms.Resize(size_upsample)(cam.unsqueeze(0))\n",
    "    \n",
    "    return img.detach().numpy(), cam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "b6bfa688",
   "metadata": {},
   "outputs": [],
   "source": [
    "cifar10_classes = [\n",
    "    \"airplane\",\n",
    "    \"automobile\",\n",
    "    \"bird\",\n",
    "    \"cat\",\n",
    "    \"deer\",\n",
    "    \"dog\",\n",
    "    \"frog\",\n",
    "    \"horse\",\n",
    "    \"ship\",\n",
    "    \"truck\",\n",
    "]\n",
    "\n",
    "def plot_cam(img, cam):\n",
    "    ''' Visualization function '''\n",
    "    img = img.permute(1, 2, 0)\n",
    "    fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(10,7))\n",
    "    ax1.imshow(img)\n",
    "    ax1.set_title(f\"Input image\\nLabel: {cifar10_classes[y]}\")\n",
    "\n",
    "    ax2.imshow(cam.reshape(32, 32), cmap=\"jet\")\n",
    "    ax2.set_title(\"Raw CAM.\")\n",
    "\n",
    "    ax3.imshow(img)\n",
    "    ax3.imshow(cam.reshape(32, 32), cmap=\"jet\", alpha=0.2)\n",
    "    ax3.set_title(f\"Overlayed CAM.\\nPrediction: {cifar10_classes[idx[0]]}\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "b6259403",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true class:  bird\n",
      "predicated class:  bird\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rand_idx = torch.randint(0, 10000, size=[1]) # pick a random index from the test set\n",
    "\n",
    "x = cifar_test[rand_idx][0] # test image\n",
    "y = cifar_test[rand_idx][1] # associated test label\n",
    "\n",
    "model.eval()\n",
    "scores = model(x.unsqueeze(0)) # get the soft labels\n",
    "probs = scores.data.squeeze()\n",
    "probs, idx = probs.sort(0, True)\n",
    "\n",
    "print('true class: ', cifar10_classes[y])\n",
    "print('predicated class: ', cifar10_classes[idx[0]])\n",
    "\n",
    "params = list(model.fc.parameters())\n",
    "weight = params[0].data\n",
    "\n",
    "feature_maps = model.conv(x.unsqueeze(0))\n",
    "heatmap, _ = get_CAM(feature_maps, weight, idx[0])\n",
    "    \n",
    "plot_cam(x, heatmap)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}