cam.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn, optim\n",
    "from torch.nn import Module\n",
    "import torch.nn.functional as F\n",
    "import os\n",
    "# TO COMPLETE\n",
    "import os\n",
    "import torch\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "from torch import Generator\n",
    "from torch.utils.data import Dataset, random_split\n",
    "import copy\n",
    "from natsort import natsorted\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "device = torch.device(\"mps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "class CNNModel(Module):\n",
    "    def __init__(self):\n",
    "        super(CNNModel,self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 6, 5, 1, 2)\n",
    "        self.conv2 = nn.Conv2d(6, 12, 5, 1, 2)\n",
    "        self.pooling = nn.MaxPool2d(2)\n",
    "        self.linear1 = nn.Linear(12*16*16,512)\n",
    "        self.dropout = nn.Dropout(p=0.3)\n",
    "        self.linear2 = nn.Linear(512, 128)\n",
    "        self.linear3 = nn.Linear(128, 30)\n",
    "\n",
    "\n",
    "    def forward(self,x):\n",
    "        x = F.relu(self.pooling(self.conv1(x)))\n",
    "        x = F.relu(self.pooling(self.conv2(x)))\n",
    "        x = x.view(x.size(0),-1)\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = self.dropout(x)\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x\n",
    "\n",
    "def nn_train(model, train_dataloader, val_dataloader, loss_fn, optimizer, epochs=1):\n",
    "    train_loss, val_loss, train_acc, val_acc = [], [], [], []\n",
    "    statsrec = np.zeros((4,epochs))\n",
    "    best_acc = 0\n",
    "\n",
    "    for e in range(epochs):\n",
    "        # training\n",
    "        # model.to(device)\n",
    "        model.train()\n",
    "        tmp_loss, tmp_correct = 0, 0\n",
    "        for batch, (X, y) in enumerate(train_dataloader):\n",
    "            # X, y = X.to(device), y.to(device) # Setup inputs to gpu\n",
    "            y_pred = model(X) # predict the input data\n",
    "            loss = loss_fn(y_pred, y) # check loss\n",
    "            optimizer.zero_grad() # reset the gradiant\n",
    "            loss.backward() # back propagation\n",
    "            optimizer.step() # forward propagation\n",
    "\n",
    "            tmp_correct += (torch.argmax(y_pred, dim=1) == y).sum()\n",
    "            tmp_loss += loss\n",
    "        train_loss.append(tmp_loss / len(train_dataloader))\n",
    "        train_acc.append(tmp_correct / 10800)\n",
    "\n",
    "        # validation\n",
    "        tmp_loss, tmp_correct = 0, 0\n",
    "        model.eval()\n",
    "        with torch.no_grad():\n",
    "            for X, y in val_dataloader:\n",
    "                # X, y = X.to(device), y.to(device)\n",
    "                y_pred = model(X)\n",
    "                loss = loss_fn(y_pred, y)\n",
    "\n",
    "                tmp_correct += (torch.argmax(y_pred, dim=1) == y).sum()\n",
    "                tmp_loss += loss\n",
    "            val_loss.append(tmp_loss / len(val_dataloader))\n",
    "            val_acc.append(tmp_correct / 2700)\n",
    "\n",
    "        statsrec[:,e] = (\n",
    "            train_loss[-1].cpu().detach().numpy(),\n",
    "            train_acc[-1].cpu().detach().numpy(),\n",
    "            val_loss[-1].cpu().detach().numpy(),\n",
    "            val_acc[-1].cpu().detach().numpy())\n",
    "\n",
    "        if val_acc[-1] > best_acc:\n",
    "            best_model_wgh = copy.deepcopy(model.state_dict())\n",
    "        print(f'epoch:{e+1}---train loss:{train_loss[-1]:.4f}---train accuracy:{train_acc[-1]:.4f}---val loss:{val_loss[-1]:.4f}---val accuracy:{val_acc[-1]:.4f}')\n",
    "\n",
    "    return best_model_wgh, statsrec\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "class_map = {}\n",
    "for line in open('TinyImageNet30/class.txt', 'r'):\n",
    "    class_map[line.split()[1]] = int(line.split()[0])"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "train_path='TinyImageNet30/train_set/train_set/'\n",
    "image_file_map = {}\n",
    "for key, value in class_map.items():\n",
    "    for i in os.listdir(train_path + key):\n",
    "        image_file_map[os.path.join(train_path + key + '/' + i)] = value"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "class ImageDataset(Dataset):\n",
    "    def __init__(self,ids,label_mapping,transform=None):\n",
    "        self.ids=ids\n",
    "        self.label_mapping=label_mapping\n",
    "        self.transform=transform\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.ids)\n",
    "\n",
    "    def __getitem__(self,index):\n",
    "        image=Image.open(self.ids[index]).convert(\"RGB\")\n",
    "        #convert_tensor = transforms.ToTensor()\n",
    "        #img=convert_tensor(img).permute(1,2,0)\n",
    "        if self.transform:\n",
    "            image = self.transform(image)\n",
    "\n",
    "        label=self.label_mapping[self.ids[index]]\n",
    "\n",
    "        return image, label"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "def imageDataLoader(image_file_map, batch_size=64, train_test_split=0.3, seed=0, transform=transforms.ToTensor()):\n",
    "\n",
    "    dataset=ImageDataset(list(image_file_map.keys()), image_file_map, transform=transform)\n",
    "    len_train= int(len(image_file_map) * (1 - train_test_split))\n",
    "    len_vald = int(len(image_file_map) * train_test_split)\n",
    "\n",
    "    #splitting data\n",
    "    train_set, vald_set = random_split(dataset, [len_train, len_vald], generator=Generator().manual_seed(seed))\n",
    "\n",
    "    #DataLoaders\n",
    "    train_loader= DataLoader(dataset=train_set, batch_size=batch_size, shuffle=True)\n",
    "    vald_loader= DataLoader(dataset=vald_set, batch_size=batch_size, shuffle=True)\n",
    "\n",
    "    return train_loader,vald_loader"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:1---train loss:3.1663---train accuracy:0.1019---val loss:2.9535---val accuracy:0.1552\n",
      "epoch:2---train loss:2.7932---train accuracy:0.2013---val loss:2.6240---val accuracy:0.2496\n",
      "epoch:3---train loss:2.5524---train accuracy:0.2644---val loss:2.4739---val accuracy:0.3011\n",
      "epoch:4---train loss:2.3919---train accuracy:0.3128---val loss:2.3346---val accuracy:0.3285\n",
      "epoch:5---train loss:2.2574---train accuracy:0.3461---val loss:2.2929---val accuracy:0.3504\n",
      "epoch:6---train loss:2.1290---train accuracy:0.3817---val loss:2.2162---val accuracy:0.3559\n",
      "epoch:7---train loss:2.0281---train accuracy:0.4092---val loss:2.1444---val accuracy:0.3767\n",
      "epoch:8---train loss:1.9374---train accuracy:0.4292---val loss:2.1550---val accuracy:0.3770\n",
      "epoch:9---train loss:1.8393---train accuracy:0.4600---val loss:2.1362---val accuracy:0.3841\n",
      "epoch:10---train loss:1.7581---train accuracy:0.4803---val loss:2.1687---val accuracy:0.3867\n"
     ]
    }
   ],
   "source": [
    "transform = transforms.Compose(\n",
    "    [transforms.RandomHorizontalFlip(),\n",
    "     transforms.RandomGrayscale(),\n",
    "     transforms.ToTensor(),\n",
    "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]\n",
    ")\n",
    "\n",
    "batch_size = 64\n",
    "seed = 0\n",
    "\n",
    "train_loader,val_loader=imageDataLoader(\n",
    "    image_file_map,\n",
    "    batch_size=batch_size,\n",
    "    train_test_split=0.2,\n",
    "    seed=0,\n",
    "    transform=transform\n",
    ")\n",
    "\n",
    "cnn = CNNModel()\n",
    "cnn_loss_func = nn.CrossEntropyLoss()\n",
    "cnn_optimizer = optim.Adam(cnn.parameters(), lr=0.001)\n",
    "#TO COMPLETE --> Running you CNN model class\n",
    "epochs = 10\n",
    "\n",
    "state_dict, statsrec = nn_train(\n",
    "    cnn,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    cnn_loss_func,\n",
    "    cnn_optimizer,\n",
    "    epochs = epochs\n",
    ")\n",
    "\n",
    "torch.save(state_dict, 'best-cnn-kagggle-param.pt')"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [
    {
     "data": {
      "text/plain": "<All keys matched successfully>"
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cnn = CNNModel()\n",
    "cnn.load_state_dict(torch.load('best-cnn-kagggle-param.pt'))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "outputs": [],
   "source": [
    "# Your code here!\n",
    "from torchcam.methods import SmoothGradCAMpp\n",
    "import matplotlib.pyplot as plt\n",
    "from torchcam.utils import overlay_mask\n",
    "from torchvision.io.image import read_image\n",
    "from torchvision.transforms.functional import normalize, resize, to_pil_image\n",
    "\n",
    "img_path = list(image_file_map.keys())[0]\n",
    "cam_extractor = SmoothGradCAMpp(cnn, input_shape=(3, 64, 64), target_layer='conv2')"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [],
   "source": [
    "transform = transforms.Compose(\n",
    "    [transforms.RandomHorizontalFlip(),\n",
    "     transforms.RandomGrayscale(),\n",
    "     transforms.ToTensor(),\n",
    "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]\n",
    ")\n",
    "\n",
    "batch_size = 1\n",
    "seed = 0\n",
    "\n",
    "train_loader,val_loader=imageDataLoader(\n",
    "    image_file_map,\n",
    "    batch_size=batch_size,\n",
    "    train_test_split=0.2,\n",
    "    seed=0,\n",
    "    transform=transform\n",
    ")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "outputs": [],
   "source": [
    "img = read_image(img_path)\n",
    "# Preprocess it for your chosen model\n",
    "input_tensor = normalize(resize(img, (64, 64)) / 255., [0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "\n",
    "out = cnn(input_tensor.unsqueeze(0))\n",
    "cams = cam_extractor(out.squeeze(0).argmax().item(), out.cpu())"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The raw CAM\n",
    "for name, cam in zip(cam_extractor.target_names, cams):\n",
    "    plt.imshow(cam.squeeze(0).numpy()); plt.axis('off'); plt.title(name); plt.show()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Overlayed on the image\n",
    "for name, cam in zip(cam_extractor.target_names, cams):\n",
    "    result = overlay_mask(to_pil_image(img), to_pil_image(cam.squeeze(0), mode='F'), alpha=0.5)\n",
    "    plt.imshow(result); plt.axis('off'); plt.title(name); plt.show()"
   ],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}