AlexNet_+CatsDogs (2) (1).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yWifem1U_CNc"
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from sklearn.datasets import load_digits\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "import torch.nn as nn\n",
    "import torch.utils.data as torch_data\n",
    "import sklearn\n",
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0_pxGCR6_CNj"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "import torch\n",
    "from   torch.autograd import Variable\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "from   torchvision import datasets, transforms\n",
    "from PIL import Image\n",
    "from torch.utils.data import random_split\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dir = \"./catsdogs/PetImages\"\n",
    "train_dogs_dir = f'{train_dir}/Dog'\n",
    "train_cats_dir = f'{train_dir}/Cat'\n",
    "val_dir = \"./Val\"\n",
    "val_dogs_dir = f'{val_dir}/Dog'\n",
    "val_cats_dir = f'{val_dir}/Cat'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing val cat dir\n",
      "5000.jpg\r\n",
      "5001.jpg\r\n",
      "5002.jpg\r\n",
      "5003.jpg\r\n",
      "5004.jpg\r\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import re\n",
    "import shutil\n",
    "files = os.listdir(train_cats_dir)\n",
    "for f in files:\n",
    "    validationCatsSearchObj = re.search(\"5\\d\\d\\d\", f)\n",
    "    if validationCatsSearchObj:\n",
    "        shutil.move(f'{train_cats_dir}/{f}', val_cats_dir)\n",
    "print(\"Printing val cat dir\")\n",
    "!ls {val_cats_dir} | head -n 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing val dog dir\n",
      "5000.jpg\r\n",
      "5001.jpg\r\n",
      "5002.jpg\r\n",
      "5003.jpg\r\n",
      "5004.jpg\r\n"
     ]
    }
   ],
   "source": [
    "files = os.listdir(train_dogs_dir)\n",
    "for f in files:\n",
    "    validationDogsSearchObj = re.search(\"5\\d\\d\\d\", f)\n",
    "    if validationDogsSearchObj:\n",
    "        shutil.move(f'{train_dogs_dir}/{f}', val_dogs_dir)\n",
    "print(\"Printing val dog dir\")\n",
    "!ls {val_dogs_dir} | head -n 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HmAh7XHl_geK"
   },
   "outputs": [],
   "source": [
    "train_transforms = transforms.Compose([\n",
    "                                transforms.RandomRotation(30),\n",
    "                                transforms.RandomResizedCrop(64),\n",
    "                                transforms.RandomHorizontalFlip(),\n",
    "                                transforms.ToTensor(),\n",
    "                                transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])\n",
    "test_transforms = transforms.Compose([transforms.Resize(65),\n",
    "                                      transforms.CenterCrop(64),\n",
    "                                      transforms.ToTensor(),\n",
    "                                      transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6afUwE7A_zIq"
   },
   "outputs": [],
   "source": [
    "#catsdogs_train = datasets.ImageFolder('./drive/My Drive/Data/PetImages',  \n",
    "                                    #transform=train_transforms)                                       \n",
    "catsdogs_val = datasets.ImageFolder('./Val', \n",
    "                                    transform=test_transforms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bScM-5tX_CNo"
   },
   "outputs": [],
   "source": [
    "#train_loader = torch_data.DataLoader(catsdogs_train, batch_size=100, shuffle=True) \n",
    "val_loader = torch_data.DataLoader(catsdogs_val, batch_size=100, shuffle=False) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lw-SaXHcRN-t"
   },
   "outputs": [],
   "source": [
    "def get_accuracy(net, val_dset):\n",
    "    test_loader = torch_data.DataLoader(val_dset,batch_size = len(val_dset)) \n",
    "    net.eval()\n",
    "    for X,y in test_loader:\n",
    "        X = X.to(device)\n",
    "        y = y.to(device)\n",
    "        nn_outputs = net(X).detach().cpu().argmax(axis = 1)\n",
    "    return accuracy_score(nn_outputs,y.detach().cpu())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4GGFlAZB_WWU"
   },
   "source": [
    "# POSLAYERS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OCzbGunD_S4D"
   },
   "outputs": [],
   "source": [
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from sklearn.datasets import load_digits\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "import torch.nn as nn\n",
    "import torch.utils.data as torch_data\n",
    "import sklearn\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "class Dense(nn.Linear):\n",
    "    def __init__(self, *args,**kwargs):\n",
    "        super(Dense, self).__init__(*args,**kwargs)\n",
    "    \n",
    "    def get_sparsity(self):\n",
    "        data = self.weight.data\n",
    "        return (data == 0).sum().item() / (data.shape[0] * data.shape[1])\n",
    "    \n",
    "    def l1reg(self, device='cpu'):\n",
    "        l1_reg = torch.tensor(0., requires_grad=True).to(device)\n",
    "        for name, W in self.named_parameters():\n",
    "            l1_reg = l1_reg + W.norm(1)\n",
    "        return l1_reg\n",
    "\n",
    "class PosDense(nn.Linear):\n",
    "    def __init__(self, *args,**kwargs):\n",
    "        super(PosDense, self).__init__(*args,**kwargs)\n",
    "    \n",
    "    def positivate(self):\n",
    "        self.weight.data = F.relu(self.weight.data)\n",
    "    \n",
    "    def get_sparsity(self):\n",
    "        data = self.weight.data\n",
    "        return (data == 0).sum().item() / (data.shape[0] * data.shape[1])\n",
    "    \n",
    "    def l1reg(self, device):\n",
    "        l1_reg = torch.tensor(0., requires_grad=True).to(device)\n",
    "        for name, W in self.named_parameters():\n",
    "            l1_reg = l1_reg + W.norm(1)\n",
    "        return l1_reg\n",
    "\n",
    "class PosConv2d(nn.Conv2d):\n",
    "    def __init__(self, *args,**kwargs):\n",
    "        super(PosConv2d, self).__init__(*args,**kwargs)\n",
    "    \n",
    "    def positivate(self):\n",
    "        self.weight.data = F.relu(self.weight.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bsXZXwPf_CNr"
   },
   "source": [
    "# Usual Alexnet without regularization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MC8Q-_Fy_CNr"
   },
   "outputs": [],
   "source": [
    "from tqdm.notebook import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ySejXEpI-yTf"
   },
   "outputs": [],
   "source": [
    "class ICAlexNet(nn.Module):\n",
    "    def __init__(self, num_classes=2):\n",
    "        super(ICAlexNet, self).__init__()\n",
    "        self.conv = PosConv2d(32, 64, kernel_size=3)\n",
    "        self.features = nn.Sequential(\n",
    "            nn.Conv2d(3, 32, kernel_size=3),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.BatchNorm2d(32), \n",
    "            self.conv,\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.BatchNorm2d(64)\n",
    "        )\n",
    "        \n",
    "        self.fc1 = PosDense(12544, 512)\n",
    "        self.fc2 = Dense(512, num_classes)\n",
    "\n",
    "        \n",
    "        self.fc_layers = nn.Sequential(\n",
    "            nn.Dropout(0.5),\n",
    "            self.fc1,\n",
    "            nn.ReLU(inplace=True),\n",
    "            self.fc2,\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        conv_features = self.features(x)\n",
    "        flatten = conv_features.view(conv_features.size(0), -1)\n",
    "        fc = self.fc_layers(flatten)\n",
    "        return fc\n",
    "    \n",
    "    def l1reg(self, device):\n",
    "        return self.fc1.l1reg(device) + self.fc2.l1reg(device)\n",
    "    \n",
    "    def get_sparsities(self):\n",
    "        return {\n",
    "                'fc1': self.fc1.get_sparsity(),\n",
    "                'fc2': self.fc2.get_sparsity()\n",
    "        }\n",
    "    \n",
    "    def positivate(self):\n",
    "      self.conv.positivate()\n",
    "      self.fc1.positivate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ICConvNet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ICConvNet(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (1): ReLU(inplace=True)\n",
       "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (4): PosConv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (5): ReLU(inplace=True)\n",
       "    (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (7): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  )\n",
       "  (fc_layers): Sequential(\n",
       "    (0): Dropout(p=0.5, inplace=False)\n",
       "    (1): PosDense(in_features=12544, out_features=512, bias=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "    (3): Dense(in_features=512, out_features=2, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9RYqTQ2m_CNu"
   },
   "outputs": [],
   "source": [
    "class AlexNet(nn.Module):\n",
    "    def __init__(self, num_classes=2):\n",
    "        super(AlexNet, self).__init__()\n",
    "        self.features = nn.Sequential(\n",
    "            nn.Conv2d(3, 32, kernel_size=3),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.BatchNorm2d(32), \n",
    "            nn.Conv2d(32, 64, kernel_size=3),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.BatchNorm2d(64)\n",
    "        )\n",
    "        \n",
    "        self.fc1 = Dense(12544, 512)\n",
    "        self.fc2 = Dense(512, num_classes)\n",
    "\n",
    "        \n",
    "        self.fc_layers = nn.Sequential(\n",
    "            nn.Dropout(0.5),\n",
    "            self.fc1,\n",
    "            nn.ReLU(inplace=True),\n",
    "            self.fc2,\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        conv_features = self.features(x)\n",
    "        flatten = conv_features.view(conv_features.size(0), -1)\n",
    "        fc = self.fc_layers(flatten)\n",
    "        return fc\n",
    "    \n",
    "    def l1reg(self, device):\n",
    "        return self.fc1.l1reg(device) + self.fc2.l1reg(device)\n",
    "    \n",
    "    def get_sparsities(self):\n",
    "        return {\n",
    "                'fc1': self.fc1.get_sparsity(),\n",
    "                'fc2': self.fc2.get_sparsity()\n",
    "        }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ConvNet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ConvNet(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (1): ReLU(inplace=True)\n",
       "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (4): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (5): ReLU(inplace=True)\n",
       "    (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (7): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  )\n",
       "  (fc_layers): Sequential(\n",
       "    (0): Dropout(p=0.5, inplace=False)\n",
       "    (1): Dense(in_features=12544, out_features=512, bias=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "    (3): Dense(in_features=512, out_features=2, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AlexNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "device='cpu'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = AlexNet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.load_state_dict(torch.load('alexnet/alexnet47+', map_location=torch.device('cpu')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8905"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_accuracy(net, catsdogs_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'fc1': 0.0, 'fc2': 0.0}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.get_sparsities()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "alexnet_val_losses = np.load('alexnet/val_loss_alexnet.npy')\n",
    "alexnet_val_losses = np.hstack((alexnet_val_losses, np.load('alexnet/val_loss_alexnet20+.npy')))\n",
    "alexnet_val_losses = np.hstack((alexnet_val_losses, np.load('alexnet/val_loss_alexnet40+.npy')))\n",
    "alexnet_val_losses = np.hstack((alexnet_val_losses, np.load('alexnet/val_loss_alexnet47+.npy')))[:50]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "alexnet_val_accs = np.load('alexnet/val_acc_alexnet.npy')\n",
    "alexnet_val_accs = np.hstack((alexnet_val_accs, np.load('alexnet/val_acc_alexnet20+.npy')))\n",
    "alexnet_val_accs = np.hstack((alexnet_val_accs, np.load('alexnet/val_acc_alexnet40+.npy')))\n",
    "alexnet_val_accs = np.hstack((alexnet_val_accs, np.load('alexnet/val_acc_alexnet47+.npy')))[:50]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PosAlexNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ICAlexNet(num_classes=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.load_state_dict(torch.load('alexnet/posalexnet', map_location=torch.device('cpu')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7885"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device='cpu'\n",
    "get_accuracy(net, catsdogs_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.06577778151402837"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(net.get_sparsities()['fc1'] * 12544 * 512) / (12544 * 512 + 512 * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "posalex_loss = np.load('alexnet/val_loss_posalexnet.npy')\n",
    "posalex_acc = np.load('alexnet/val_acc_posalexnet.npy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PosAlex + L1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = ICAlexNet(num_classes=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.load_state_dict(torch.load('alexnet/posalexnet_l1', map_location=torch.device('cpu')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7865"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_accuracy(net, catsdogs_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'fc1': 0.9819915148676658, 'fc2': 0.0}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.get_sparsities()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.981834972301929"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(net.get_sparsities()['fc1'] * 12544 * 512) / (12544 * 512 + 512 * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "posalexl1_loss = np.load('alexnet/val_loss_posalexnet_l1.npy')\n",
    "posalexl1_acc = np.load('alexnet/val_acc_posalexnet_l1.npy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AlexNet + L1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PosAlexNet(nn.Module):\n",
    "    def __init__(self, num_classes=2):\n",
    "        super(PosAlexNet, self).__init__()\n",
    "        self.conv = PosConv2d(32, 64, kernel_size=3)\n",
    "        self.features = nn.Sequential(\n",
    "            nn.Conv2d(3, 32, kernel_size=3),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.BatchNorm2d(32), \n",
    "            self.conv,\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.BatchNorm2d(64)\n",
    "        )\n",
    "        \n",
    "        self.fc1 = PosDense(12544, 512)\n",
    "        self.fc2 = Dense(512, num_classes)\n",
    "\n",
    "        \n",
    "        self.fc_layers = nn.Sequential(\n",
    "            nn.Dropout(0.5),\n",
    "            self.fc1,\n",
    "            nn.ReLU(inplace=True),\n",
    "            self.fc2,\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        conv_features = self.features(x)\n",
    "        flatten = conv_features.view(conv_features.size(0), -1)\n",
    "        fc = self.fc_layers(flatten)\n",
    "        return fc\n",
    "    \n",
    "    def l1reg(self, device):\n",
    "        return self.fc1.l1reg(device) + self.fc2.l1reg(device)\n",
    "    \n",
    "    def get_sparsities(self):\n",
    "        return {\n",
    "                'fc1': self.fc1.get_sparsity(),\n",
    "                'fc2': self.fc2.get_sparsity()\n",
    "        }\n",
    "    \n",
    "    def positivate(self):\n",
    "      self.conv.positivate()\n",
    "      self.fc1.positivate()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = PosAlexNet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.load_state_dict(torch.load('alexnet/alexnet_l1', map_location=torch.device('cpu')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.858"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_accuracy(net, catsdogs_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(net.get_sparsities()['fc1'] * 12544 * 512) / (12544 * 512 + 512 * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "alexl1_loss = np.load('alexnet/val_loss_alexnet_l1.npy')\n",
    "alexl1_acc = np.load('alexnet/val_acc_alexnet_l1.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(14, 7))\n",
    "axs[0].grid()\n",
    "axs[0].plot(alexnet_val_losses, label=\"AlexNet\")\n",
    "axs[0].plot(posalex_loss, label=\"ICAlexNet\")\n",
    "axs[0].plot(alexl1_loss, label=\"AlexNet + L1\")\n",
    "axs[0].plot(posalexl1_loss, label=\"ICAlexNet + L1\")\n",
    "axs[0].set_xlabel(\"Epoch\", fontsize=14)\n",
    "axs[0].set_ylabel(\"Loss\", fontsize=14)\n",
    "axs[0].legend(fontsize=14)\n",
    "\n",
    "axs[1].grid()\n",
    "axs[1].plot(alexnet_val_accs, label=\"AlexNet\")\n",
    "axs[1].plot(posalex_acc, label=\"ICAlexNet\")\n",
    "axs[1].plot(alexl1_acc, label=\"AlexNet + L1\")\n",
    "axs[1].plot(posalexl1_acc, label=\"ICAlexNet + L1\")\n",
    "axs[1].legend(fontsize=14)\n",
    "axs[1].set_xlabel(\"Epoch\", fontsize=14)\n",
    "axs[1].set_ylabel(\"Accuracy\", fontsize=14)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "AlexNet +CatsDogs.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "2c3506545c9948568b3069060ca46bee": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "2cc33e3d3f124787a140042a0ccbd85e": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "IntProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "IntProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "danger",
      "description": "  0%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_3ff5519e412e4d0c9f47a66e3fd0b2d1",
      "max": 230,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_98cd0958c47b4ccab88d0306afc7eac0",
      "value": 1
     }
    },
    "3d214b56bdad40b99d095529882cc56d": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "3ff5519e412e4d0c9f47a66e3fd0b2d1": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5bac60791eea4b4493a9191cb64d9b31": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_9d0c2302d44e457cb0eb1ed8feaa7e16",
      "placeholder": "​",
      "style": "IPY_MODEL_c85e702183184c8aa0f170bc26a6f0a7",
      "value": " 1/230 [00:36&lt;1:19:47, 20.91s/it]"
     }
    },
    "69b02f9a6e85455d959ef00b36345ac5": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "70e38b7aaa8349abaf1be5238f7f882c": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "9575c5eed98041c99357c36bdfb7256a": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "98cd0958c47b4ccab88d0306afc7eac0": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "9be2e343f7dd44068bf71b1c0cfe3e86": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_9575c5eed98041c99357c36bdfb7256a",
      "placeholder": "​",
      "style": "IPY_MODEL_70e38b7aaa8349abaf1be5238f7f882c",
      "value": " 1/230 [00:26&lt;1:20:57, 21.21s/it]"
     }
    },
    "9d0c2302d44e457cb0eb1ed8feaa7e16": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a3801b79bfc6484fbd3071961577256b": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_2cc33e3d3f124787a140042a0ccbd85e",
       "IPY_MODEL_5bac60791eea4b4493a9191cb64d9b31"
      ],
      "layout": "IPY_MODEL_fc11d38c3ef944ed9c315a82017a7eda"
     }
    },
    "ac4bbfb3946546f6a02f4f952fc00578": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "IntProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "IntProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "danger",
      "description": "  0%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_69b02f9a6e85455d959ef00b36345ac5",
      "max": 230,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_3d214b56bdad40b99d095529882cc56d",
      "value": 1
     }
    },
    "c85e702183184c8aa0f170bc26a6f0a7": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "f6ec2184144f4e18874ccf8214d50f95": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_ac4bbfb3946546f6a02f4f952fc00578",
       "IPY_MODEL_9be2e343f7dd44068bf71b1c0cfe3e86"
      ],
      "layout": "IPY_MODEL_2c3506545c9948568b3069060ca46bee"
     }
    },
    "fc11d38c3ef944ed9c315a82017a7eda": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}