Testing Modified Model FashionMNIST.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch \n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "from sklearn.metrics import precision_score,recall_score,f1_score,accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "USE_CUDA =  True if torch.cuda.is_available() else False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize((0.1307,), (0.3081,))])\n",
    "\n",
    "trainset = torchvision.datasets.FashionMNIST('/fashion-mnist/', train=True,download=True, transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset,shuffle=True, num_workers=2, batch_size = 10)\n",
    "\n",
    "testset = torchvision.datasets.FashionMNIST('/fashion-mnist/', train=False,download=True, transform=transform)\n",
    "testloader = torch.utils.data.DataLoader(testset,shuffle=False, num_workers=2, batch_size = 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "fashion_labels = [\"T-shirt/top\", \"Trouser\", \"Pullover\", \"Dress\", \"Coat\",\n",
    "          \"Sandal\", \"Shirt\", \"Sneaker\", \"Bag\", \"Ankle boot\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvLayer(nn.Module):\n",
    "    def __init__(self, in_channels=1, out_channels=256, kernel_size=9):\n",
    "        super(ConvLayer, self).__init__()\n",
    "\n",
    "        self.conv = nn.Conv2d(in_channels=in_channels,\n",
    "                              out_channels=out_channels,\n",
    "                              kernel_size=kernel_size,\n",
    "                              stride=1\n",
    "                              )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return F.relu(self.conv(x))\n",
    "\n",
    "\n",
    "class PrimaryCaps(nn.Module):\n",
    "    def __init__(self, num_capsules=8, in_channels=256, out_channels=32, kernel_size=9, num_routes=32 * 6 * 6):\n",
    "        super(PrimaryCaps, self).__init__()\n",
    "        self.num_routes = num_routes\n",
    "        self.capsules = nn.ModuleList([\n",
    "            nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=2, padding=0)\n",
    "            for _ in range(num_capsules)])\n",
    "\n",
    "    def forward(self, x):\n",
    "        u = [capsule(x) for capsule in self.capsules]\n",
    "        u = torch.stack(u, dim=1)\n",
    "\n",
    "        u = u.view(x.size(0), self.num_routes, -1)\n",
    "        return self.squash(u)\n",
    "\n",
    "    def squash(self, input_tensor):\n",
    "        squared_norm = (input_tensor ** 2).sum(-1, keepdim=True)\n",
    "        output_tensor = squared_norm * input_tensor / ((1. + squared_norm) * torch.sqrt(squared_norm))\n",
    "        return output_tensor\n",
    "\n",
    "\n",
    "class DigitCaps(nn.Module):\n",
    "    def __init__(self, num_capsules=10, num_routes=32 * 6 * 6, in_channels=8, out_channels=16):\n",
    "        super(DigitCaps, self).__init__()\n",
    "\n",
    "        self.in_channels = in_channels\n",
    "        self.num_routes = num_routes\n",
    "        self.num_capsules = num_capsules\n",
    "\n",
    "        self.W = nn.Parameter(torch.randn(1, num_routes, num_capsules, out_channels, in_channels))\n",
    "\n",
    "    def forward(self, x):\n",
    "        batch_size = x.size(0)\n",
    "        x = torch.stack([x] * self.num_capsules, dim=2).unsqueeze(4)\n",
    "\n",
    "        W = torch.cat([self.W] * batch_size, dim=0)\n",
    "        u_hat = torch.matmul(W, x)\n",
    "\n",
    "        b_ij = torch.zeros(1, self.num_routes, self.num_capsules, 1)\n",
    "        if USE_CUDA:\n",
    "            b_ij = b_ij.cuda()\n",
    "\n",
    "        num_iterations = 3\n",
    "        for iteration in range(num_iterations):\n",
    "            c_ij = F.softmax(b_ij, dim=1)\n",
    "            c_ij = torch.cat([c_ij] * batch_size, dim=0).unsqueeze(4)\n",
    "\n",
    "            s_j = (c_ij * u_hat).sum(dim=1, keepdim=True)\n",
    "            v_j = self.squash(s_j)\n",
    "\n",
    "            if iteration < num_iterations - 1:\n",
    "                a_ij = torch.matmul(u_hat.transpose(3, 4), torch.cat([v_j] * self.num_routes, dim=1))\n",
    "                b_ij = b_ij + a_ij.squeeze(4).mean(dim=0, keepdim=True)\n",
    "\n",
    "        return v_j.squeeze(1)\n",
    "\n",
    "    def squash(self, input_tensor):\n",
    "        squared_norm = (input_tensor ** 2).sum(-1, keepdim=True)\n",
    "        output_tensor = squared_norm * input_tensor / ((1. + squared_norm) * torch.sqrt(squared_norm))\n",
    "        return output_tensor\n",
    "\n",
    "\n",
    "class CapsNet(nn.Module):\n",
    "    def __init__(self, config=None):\n",
    "        super(CapsNet, self).__init__()\n",
    "        if config:\n",
    "            self.conv_layer = ConvLayer(config.cnn_in_channels, config.cnn_out_channels, config.cnn_kernel_size)\n",
    "            self.primary_capsules = PrimaryCaps(config.pc_num_capsules, config.pc_in_channels, config.pc_out_channels,\n",
    "                                                config.pc_kernel_size, config.pc_num_routes)\n",
    "            self.digit_capsules = DigitCaps(config.dc_num_capsules, config.dc_num_routes, config.dc_in_channels,\n",
    "                                            config.dc_out_channels)\n",
    "            #self.decoder = Decoder(config.input_width, config.input_height, config.cnn_in_channels)\n",
    "        else:\n",
    "            self.conv_layer = ConvLayer()\n",
    "            self.primary_capsules = PrimaryCaps()\n",
    "            self.digit_capsules = DigitCaps()\n",
    "            #self.decoder = Decoder()\n",
    "\n",
    "        self.mse_loss = nn.MSELoss()\n",
    "\n",
    "    def forward(self, data):\n",
    "        output = self.digit_capsules(self.primary_capsules(self.conv_layer(data)))\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config_1:\n",
    "    def __init__(self, in_channels):\n",
    "            # CNN (cnn)\n",
    "            self.cnn_in_channels = in_channels\n",
    "            self.cnn_out_channels = 256\n",
    "            self.cnn_kernel_size = 3\n",
    "\n",
    "            # Primary Capsule (pc)\n",
    "            self.pc_num_capsules = 8\n",
    "            self.pc_in_channels = 256\n",
    "            self.pc_out_channels = 32\n",
    "            self.pc_kernel_size = 3\n",
    "            self.pc_num_routes = 32 * 6 * 6\n",
    "\n",
    "            # Digit Capsule (dc)\n",
    "            self.dc_num_capsules = 10\n",
    "            self.dc_num_routes = 32 * 6 * 6\n",
    "            self.dc_in_channels = 18\n",
    "            self.dc_out_channels = 6\n",
    "\n",
    "class Config_2:\n",
    "    def __init__(self, in_channels):\n",
    "            # CNN (cnn)\n",
    "            self.cnn_in_channels = in_channels\n",
    "            self.cnn_out_channels = 256\n",
    "            self.cnn_kernel_size = 3\n",
    "\n",
    "            # Primary Capsule (pc)\n",
    "            self.pc_num_capsules = 8\n",
    "            self.pc_in_channels = 256\n",
    "            self.pc_out_channels = 32\n",
    "            self.pc_kernel_size = 3\n",
    "            self.pc_num_routes = 32 * 6 * 6\n",
    "\n",
    "            # Digit Capsule (dc)\n",
    "            self.dc_num_capsules = 10\n",
    "            self.dc_num_routes = 32 * 6 * 6\n",
    "            self.dc_in_channels = 8\n",
    "            self.dc_out_channels = 6\n",
    "\n",
    "class Config_3:\n",
    "    def __init__(self, in_channels):\n",
    "            # CNN (cnn)\n",
    "            self.cnn_in_channels = in_channels\n",
    "            self.cnn_out_channels = 256\n",
    "            self.cnn_kernel_size = 3\n",
    "\n",
    "            # Primary Capsule (pc)\n",
    "            self.pc_num_capsules = 8\n",
    "            self.pc_in_channels = 256\n",
    "            self.pc_out_channels = 32\n",
    "            self.pc_kernel_size = 3\n",
    "            self.pc_num_routes = 32 * 6 * 6\n",
    "\n",
    "            # Digit Capsule (dc)\n",
    "            self.dc_num_capsules = 10\n",
    "            self.dc_num_routes = 32 * 6 * 6\n",
    "            self.dc_in_channels = 2\n",
    "            self.dc_out_channels = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net,self).__init__()\n",
    "        self.conv1 = nn.Conv2d(1,32,kernel_size = (3,3))\n",
    "        self.conv2 = nn.Conv2d(32,48,kernel_size = (3,3))\n",
    "        self.conv3 = nn.Conv2d(48,64,kernel_size = (3,3))\n",
    "        self.conv4 = nn.Conv2d(64,80,kernel_size = (3,3))\n",
    "        self.conv5 = nn.Conv2d(80,96,kernel_size = (3,3))\n",
    "        self.conv6 = nn.Conv2d(96,112,kernel_size = (3,3))\n",
    "        self.conv7 = nn.Conv2d(112,128,kernel_size = (3,3))\n",
    "        self.conv8 = nn.Conv2d(128,144,kernel_size = (3,3))\n",
    "        self.conv9 = nn.Conv2d(144,160,kernel_size = (3,3))\n",
    "        self.caps_a = CapsNet(Config_1(64))\n",
    "        self.caps_b = CapsNet(Config_2(112))\n",
    "        self.caps_c = CapsNet(Config_3(160))\n",
    "        self.merge_weight1= nn.Parameter(torch.randn(1))\n",
    "        self.merge_weight2= nn.Parameter(torch.randn(1))\n",
    "        self.merge_weight3= nn.Parameter(torch.randn(1))\n",
    "        self.relu = nn.ReLU()\n",
    "        self.batchnorm_branch1 = nn.BatchNorm2d(64)\n",
    "        self.batchnorm_branch2 = nn.BatchNorm2d(112)\n",
    "        self.batchnorm_branch3 = nn.BatchNorm2d(160)\n",
    "        self.upsample_conv1 = nn.Conv2d(1,1,kernel_size=(5,5))\n",
    "        self.upsample_conv2 = nn.Conv2d(48,80,kernel_size=(5,5))\n",
    "        self.upsample_conv3 = nn.Conv2d(80,112,kernel_size=(5,5))\n",
    "        self.upsample_conv4 = nn.Conv2d(112,144,kernel_size=(5,5))\n",
    "\n",
    "        self.k1= nn.Parameter(torch.randn(1))\n",
    "        self.k2= nn.Parameter(torch.randn(1))\n",
    "        self.k3= nn.Parameter(torch.randn(1))\n",
    "        self.k4= nn.Parameter(torch.randn(1))\n",
    "        \n",
    "    def forward(self,x):\n",
    "        branch1 = self.conv1(x)\n",
    "        branch1 = self.relu(branch1)\n",
    "        branch1 = self.conv2(branch1)\n",
    "        branch1 = self.relu(branch1)\n",
    "\n",
    "        branch1 += self.k1 * self.upsample_conv1(x)\n",
    "        x1 = branch1.clone()\n",
    "        \n",
    "        branch1 = self.conv3(branch1)\n",
    "        branch1 = self.relu(branch1)\n",
    "        branch2 = self.conv4(branch1)\n",
    "        branch2 = self.relu(branch2)\n",
    "\n",
    "        branch2 += self.k2 * self.upsample_conv2(x1)\n",
    "        x1 = branch2.clone()\n",
    "\n",
    "        branch2 = self.conv5(branch2)\n",
    "        branch2 = self.relu(branch2)\n",
    "        branch2 = self.conv6(branch2)\n",
    "        branch2 = self.relu(branch2)\n",
    "\n",
    "        branch2 += self.k3 * self.upsample_conv3(x1)\n",
    "        x1 = branch2.clone()\n",
    "\n",
    "        branch3 = self.conv7(branch2)\n",
    "        branch3 = self.relu(branch3)\n",
    "        branch3 = self.conv8(branch3)\n",
    "        branch3 = self.relu(branch3)\n",
    "\n",
    "        branch3 += self.k4 * self.upsample_conv4(x1)\n",
    "\n",
    "        branch3 = self.conv9(branch3)\n",
    "        branch3 = self.relu(branch3)\n",
    "\n",
    "        #Batch Normalizing \n",
    "        branch1 = self.batchnorm_branch1(branch1)\n",
    "        branch2 = self.batchnorm_branch2(branch2)\n",
    "        branch3 = self.batchnorm_branch3(branch3)\n",
    "\n",
    "        branch1_out = self.caps_a(branch1)\n",
    "        branch2_out = self.caps_b(branch2)\n",
    "        branch3_out = self.caps_c(branch3)\n",
    "\n",
    "        branch1_out = torch.sqrt((branch1_out ** 2).sum(dim=2, keepdim=True)).view(-1,10)\n",
    "        branch2_out = torch.sqrt((branch2_out ** 2).sum(dim=2, keepdim=True)).view(-1,10)\n",
    "        branch3_out = torch.sqrt((branch3_out ** 2).sum(dim=2, keepdim=True)).view(-1,10)\n",
    "        \n",
    "        out1 = self.merge_weight1 * branch1_out\n",
    "        out2 = self.merge_weight1 * branch2_out\n",
    "        out3 = self.merge_weight1 * branch3_out\n",
    "        stack = torch.stack([out1,out3,out3],dim = 0)\n",
    "        summed = torch.sum(stack,dim = 0)\n",
    "        return summed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "F:\\Anaconda\\Anaconda3\\envs\\deep\\lib\\site-packages\\torch\\serialization.py:593: SourceChangeWarning: source code of class 'torch.nn.modules.conv.Conv2d' has changed. you can retrieve the original source code by accessing the object's source attribute or set `torch.nn.Module.dump_patches = True` and use the patch tool to revert the changes.\n",
      "  warnings.warn(msg, SourceChangeWarning)\n",
      "F:\\Anaconda\\Anaconda3\\envs\\deep\\lib\\site-packages\\torch\\serialization.py:593: SourceChangeWarning: source code of class 'torch.nn.modules.container.ModuleList' has changed. you can retrieve the original source code by accessing the object's source attribute or set `torch.nn.Module.dump_patches = True` and use the patch tool to revert the changes.\n",
      "  warnings.warn(msg, SourceChangeWarning)\n",
      "F:\\Anaconda\\Anaconda3\\envs\\deep\\lib\\site-packages\\torch\\serialization.py:593: SourceChangeWarning: source code of class 'torch.nn.modules.loss.MSELoss' has changed. you can retrieve the original source code by accessing the object's source attribute or set `torch.nn.Module.dump_patches = True` and use the patch tool to revert the changes.\n",
      "  warnings.warn(msg, SourceChangeWarning)\n",
      "F:\\Anaconda\\Anaconda3\\envs\\deep\\lib\\site-packages\\torch\\serialization.py:593: SourceChangeWarning: source code of class 'torch.nn.modules.activation.ReLU' has changed. you can retrieve the original source code by accessing the object's source attribute or set `torch.nn.Module.dump_patches = True` and use the patch tool to revert the changes.\n",
      "  warnings.warn(msg, SourceChangeWarning)\n"
     ]
    }
   ],
   "source": [
    "net = torch.load('modified_capsnet_fashion.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "predict = []\n",
    "true = []\n",
    "if USE_CUDA:\n",
    "    net = net.cuda()\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        if USE_CUDA:\n",
    "            images = images.cuda()\n",
    "            net = net.cuda()\n",
    "        outputs = net(images)\n",
    "        predicted = torch.argmax(outputs.data, 1)\n",
    "        predict.extend(predicted.tolist())\n",
    "        true.extend(labels.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy :  0.916\n",
      "Precision Score 0.9165823579745856\n",
      "Recall Score 0.9159999999999998\n",
      "F1 Score 0.9158978603839701\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy : \",accuracy_score(true,predict))\n",
    "print(\"Precision Score\",np.mean(precision_score(true,predict,average=None)))\n",
    "print(\"Recall Score\",np.mean(recall_score(true,predict,average=None)))\n",
    "print(\"F1 Score\",np.mean(f1_score(true,predict,average=None)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "F:\\Anaconda\\Anaconda3\\envs\\deep\\lib\\site-packages\\ipykernel_launcher.py:11: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "testloader = torch.utils.data.DataLoader(testset,shuffle=False, num_workers=2, batch_size = 1)\n",
    "USE_CUDA = True\n",
    "wrong = 0\n",
    "row = 2\n",
    "col = 5\n",
    "device = 'cuda:0'\n",
    "figure = plt.figure(figsize=(15, 15))\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        image,label = data\n",
    "        image = torch.tensor(image,device = device)\n",
    "        net = net.cuda()\n",
    "        pred = net(image)\n",
    "        pred = torch.argmax(pred.data, 1)\n",
    "        if pred.item() != label.item():\n",
    "            wrong += 1\n",
    "            plt.subplot(row,col,wrong)\n",
    "            plt.title(\"Predicted: {}  True: {}\".format(fashion_labels[pred.item()],fashion_labels[label.item()]))\n",
    "            plt.imshow(image[0][0].cpu())\n",
    "            if wrong > 9:\n",
    "                break\n",
    "figure.tight_layout(pad=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum(p.numel() for p in net.parameters() if p.requires_grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5961617"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "deep",
   "language": "python",
   "name": "deep"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}