prune.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import zipfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define a model which would be trained for images in CIFAR10 dataset. Images have 3 channels, RGB."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CNN, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 128, 3)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(128, 512, 3)\n",
    "        self.conv3 = nn.Conv2d(512, 1024, 3)\n",
    "        self.fc1 = nn.Linear(1024 * 2 * 2, 1024)\n",
    "        self.fc2 = nn.Linear(1024, 500)\n",
    "        self.fc3 = nn.Linear(500, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.pool(x)\n",
    "        x = self.conv2(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.pool(x)\n",
    "        x = self.conv3(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.pool(x)\n",
    "        x = x.view(-1, 1024 * 2 * 2)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below function downloads the data and devides it into train and test dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_data(download, transform, batch_size, num_workers):\n",
    "    if transform:\n",
    "        trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=download, transform=transform)\n",
    "        testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=download, transform=transform)\n",
    "    else:\n",
    "        trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=download)\n",
    "        testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=download)\n",
    "    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers)\n",
    "    testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=num_workers)\n",
    "    class_names = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
    "    return trainloader, testloader, class_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normalizing the inputs. Instantiating the CNN object for training. Defined SGD optimizer and cost function as cross entropy loss. Define the epochs for training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "train_loader, test_loader, classes = prepare_data(download=False, transform=transform, batch_size=4, num_workers=2)\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "net = CNN()\n",
    "net.to(device)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n",
    "epochs=2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train it for epochs and save the trained model for later use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,  2000] loss: 2.091\n",
      "[1,  4000] loss: 1.764\n",
      "[1,  6000] loss: 1.573\n",
      "[1,  8000] loss: 1.437\n",
      "[1, 10000] loss: 1.359\n",
      "[1, 12000] loss: 1.273\n",
      "[2,  2000] loss: 1.166\n",
      "[2,  4000] loss: 1.114\n",
      "[2,  6000] loss: 1.053\n",
      "[2,  8000] loss: 1.002\n",
      "[2, 10000] loss: 0.993\n",
      "[2, 12000] loss: 0.949\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(epochs):\n",
    "\n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(train_loader, 0):\n",
    "\n",
    "        inputs, labels = data[0].to(device), data[1].to(device)\n",
    "        optimizer.zero_grad()\n",
    "        outputs = net(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        running_loss += loss.item()\n",
    "        if i % 2000 == 1999:\n",
    "            print('[%d, %5d] loss: %.3f' %\n",
    "                  (epoch + 1, i + 1, running_loss / 2000))\n",
    "            running_loss = 0.0\n",
    "\n",
    "print('Finished Training')\n",
    "PATH = './cifar_net_'+str(epochs)+'.pth'\n",
    "torch.save(net.state_dict(), PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the saved model above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net = CNN()\n",
    "net.load_state_dict(torch.load(PATH))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accuracy on the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 10000 test images: 68 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for data in test_loader:\n",
    "        inputs, labels = data[0].to(device), data[1].to(device)\n",
    "        outputs = net(inputs)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print('Accuracy of the network on the 10000 test images: %d %%' % (\n",
    "        100 * correct / total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prune the conv1 layer with unstructured l1 pruning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "sparsity = [0.1, 0.3, 0.5, 0.6, 0.7, 0.9]\n",
    "module = net.conv1\n",
    "for s in sparsity:\n",
    "    prune.l1_unstructured(module, name='weight', amount=s)\n",
    "    prune.remove(module, 'weight')\n",
    "    PATH = f'./cifar_net_conv1p_{s}.pth'\n",
    "    torch.save(net.state_dict(), PATH)\n",
    "    with ZipFile(f'pruned_conv1_{s}.zip', 'w', compression=zipfile.ZIP_DEFLATED) as z:\n",
    "        z.write(PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PATH = './cifar_net_'+str(epochs)+'.pth'\n",
    "net = CNN()\n",
    "net.load_state_dict(torch.load(PATH))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prune the fc2 layer with unstructured l1 pruning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "sparsity = [0.1, 0.3, 0.5, 0.6, 0.7, 0.9]\n",
    "module = net.fc2\n",
    "for s in sparsity:\n",
    "    prune.l1_unstructured(module, name='weight', amount=s)\n",
    "    prune.remove(module, 'weight')\n",
    "    PATH = f'./cifar_net_fc2p_{s}.pth'\n",
    "    torch.save(net.state_dict(), PATH)\n",
    "    with ZipFile(f'pruned_fc2_{s}.zip', 'w', compression=zipfile.ZIP_DEFLATED) as z:\n",
    "        z.write(PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PATH = './cifar_net_'+str(epochs)+'.pth'\n",
    "net = CNN()\n",
    "net.load_state_dict(torch.load(PATH))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prune all the layers with unstructured l1 pruning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "sparsity = [0.1, 0.3, 0.5, 0.6, 0.7, 0.9]\n",
    "for s in sparsity:\n",
    "    for name, module in net.named_modules():\n",
    "        if isinstance(module, torch.nn.Conv2d):\n",
    "            prune.l1_unstructured(module, name='weight', amount=s)\n",
    "        elif isinstance(module, torch.nn.Linear):\n",
    "            prune.l1_unstructured(module, name='weight', amount=s)\n",
    "    for name, module in net.named_modules():\n",
    "        if isinstance(module, torch.nn.Conv2d) or isinstance(module, torch.nn.Linear):\n",
    "            prune.remove(module, 'weight')\n",
    "    PATH = f'./cifar_net_allp_{s}.pth'\n",
    "    torch.save(net.state_dict(), PATH)\n",
    "    with ZipFile(f'pruned_all_{s}.zip', 'w', compression=zipfile.ZIP_DEFLATED) as z:\n",
    "        z.write(PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check the effect on the size of the saved networks in compressed formats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "conv1_pruned_siz = []\n",
    "fc2_pruned_siz = []\n",
    "all_pruned_siz = []\n",
    "for s in sparsity:\n",
    "    PATH = f'pruned_conv1_{s}.zip'\n",
    "    stats = os.stat(PATH)\n",
    "    conv1_pruned_siz.append(stats.st_size/1024)\n",
    "    PATH = f'pruned_fc2_{s}.zip'\n",
    "    stats = os.stat(PATH)\n",
    "    fc2_pruned_siz.append(stats.st_size/1024)\n",
    "    PATH = f'pruned_all_{s}.zip'\n",
    "    stats = os.stat(PATH)\n",
    "    all_pruned_siz.append(stats.st_size/1024)\n",
    "fig = plt.figure()\n",
    "ax1 = fig.add_subplot(xlabel='sparsity', ylabel='sizes in multiple of 1024 bytes')\n",
    "ax1.plot(sparsity, conv1_pruned_siz, c='b', label='conv2 pruning')\n",
    "ax1.plot(sparsity, fc2_pruned_siz, c='r', label='fc2 pruning')\n",
    "ax1.plot(sparsity, all_pruned_siz, c='g', label='all pruning')\n",
    "plt.legend(loc='lower left');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the original size of the NN without pruning is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compressed size of the unpruned NN in multiple of 1024 bytes is 36204.93359375\n"
     ]
    }
   ],
   "source": [
    "PATH = './cifar_net_'+str(epochs)+'.pth'\n",
    "with ZipFile(f'{PATH}.zip', 'w', compression=zipfile.ZIP_DEFLATED) as z:\n",
    "        z.write(PATH)\n",
    "PATH = f'{PATH}.zip'\n",
    "print(f'Compressed size of the unpruned NN in multiple of 1024 bytes is {(os.stat(PATH).st_size/1024)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pruned NN's sizes with different parts pruned to different extent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of compressed conv1 10.0% sparsed network in multiple of 1024 bytes is 36199.15234375\n",
      "Size of compressed fc2 10.0% sparsed network in multiple of 1024 bytes is 36092.18359375\n",
      "Size of compressed all 10.0% sparsed network in multiple of 1024 bytes is 33953.4580078125\n",
      "Size of compressed conv1 30.0% sparsed network in multiple of 1024 bytes is 36199.1533203125\n",
      "Size of compressed fc2 30.0% sparsed network in multiple of 1024 bytes is 35797.5654296875\n",
      "Size of compressed all 30.0% sparsed network in multiple of 1024 bytes is 28274.7353515625\n",
      "Size of compressed conv1 50.0% sparsed network in multiple of 1024 bytes is 36199.15234375\n",
      "Size of compressed fc2 50.0% sparsed network in multiple of 1024 bytes is 35478.5869140625\n",
      "Size of compressed all 50.0% sparsed network in multiple of 1024 bytes is 21730.3271484375\n",
      "Size of compressed conv1 60.0% sparsed network in multiple of 1024 bytes is 36199.169921875\n",
      "Size of compressed fc2 60.0% sparsed network in multiple of 1024 bytes is 35310.8251953125\n",
      "Size of compressed all 60.0% sparsed network in multiple of 1024 bytes is 18421.533203125\n",
      "Size of compressed conv1 70.0% sparsed network in multiple of 1024 bytes is 36197.966796875\n",
      "Size of compressed fc2 70.0% sparsed network in multiple of 1024 bytes is 35132.701171875\n",
      "Size of compressed all 70.0% sparsed network in multiple of 1024 bytes is 14971.3662109375\n",
      "Size of compressed conv1 90.0% sparsed network in multiple of 1024 bytes is 36195.2861328125\n",
      "Size of compressed fc2 90.0% sparsed network in multiple of 1024 bytes is 34744.4130859375\n",
      "Size of compressed all 90.0% sparsed network in multiple of 1024 bytes is 7390.8291015625\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(sparsity)):\n",
    "    print(f'Size of compressed conv1 {sparsity[i]*100}% sparsed network in multiple of 1024 bytes is {conv1_pruned_siz[i]}')\n",
    "    print(f'Size of compressed fc2 {sparsity[i]*100}% sparsed network in multiple of 1024 bytes is {fc2_pruned_siz[i]}')\n",
    "    print(f'Size of compressed all {sparsity[i]*100}% sparsed network in multiple of 1024 bytes is {all_pruned_siz[i]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So it can be seen that with increase in sparsity we see reduced model size, also for any amount of pruning we see that what is being pruned also matters and compression follows the order all > fc2 > conv1. It is expected when all the layers are pruned but interestingly fc2 gives greater compression than conv1 layer. Oh! it could be because conv1 does not have that much parameters to start with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check the effect of pruning on accuracy. But let's load the pruned models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv1_pruned_nets = []\n",
    "fc2_pruned_nets = []\n",
    "all_pruned_nets = []\n",
    "for s in sparsity:\n",
    "    net = CNN()\n",
    "    PATH = f'./cifar_net_conv1p_{s}.pth'\n",
    "    net.load_state_dict(torch.load(PATH))\n",
    "    conv1_pruned_nets.append(net)\n",
    "    net = CNN()\n",
    "    PATH = f'./cifar_net_fc2p_{s}.pth'\n",
    "    net.load_state_dict(torch.load(PATH))\n",
    "    fc2_pruned_nets.append(net)\n",
    "    net = CNN()\n",
    "    PATH = f'./cifar_net_allp_{s}.pth'\n",
    "    net.load_state_dict(torch.load(PATH))\n",
    "    all_pruned_nets.append(net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating accuracy for Sparsity 0.1\n",
      "Calculating accuracy for Sparsity 0.3\n",
      "Calculating accuracy for Sparsity 0.5\n",
      "Calculating accuracy for Sparsity 0.6\n",
      "Calculating accuracy for Sparsity 0.7\n",
      "Calculating accuracy for Sparsity 0.9\n"
     ]
    }
   ],
   "source": [
    "conv1_pruned_accr = []\n",
    "fc2_pruned_accr = []\n",
    "all_pruned_accr = []\n",
    "conv1_pruned_t = []\n",
    "fc2_pruned_t = []\n",
    "all_pruned_t = []\n",
    "\n",
    "for i in range(len(sparsity)):\n",
    "    print(f'Calculating accuracy for Sparsity {sparsity[i]}')\n",
    "    cnv1_correct = 0\n",
    "    cnv1_total = 0\n",
    "    fc2_correct = 0\n",
    "    fc2_total = 0\n",
    "    all_correct = 0\n",
    "    all_total = 0\n",
    "    conv1_t_tot = 0\n",
    "    fc2_t_tot = 0\n",
    "    all_t_tot = 0\n",
    "    with torch.no_grad():\n",
    "        for data in test_loader:\n",
    "            inputs, labels = data[0].to(device), data[1].to(device)\n",
    "            \n",
    "            start = time.time()\n",
    "            outputs = conv1_pruned_nets[i](inputs)\n",
    "            conv1_t_tot += (time.time() - start)\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            cnv1_total += labels.size(0)\n",
    "            cnv1_correct += (predicted == labels).sum().item()\n",
    "            \n",
    "            start = time.time()\n",
    "            outputs = fc2_pruned_nets[i](inputs)\n",
    "            fc2_t_tot += (time.time() - start)\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            fc2_total += labels.size(0)\n",
    "            fc2_correct += (predicted == labels).sum().item()\n",
    "            \n",
    "            start = time.time()\n",
    "            outputs = all_pruned_nets[i](inputs)\n",
    "            all_t_tot += (time.time() - start)\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            all_total += labels.size(0)\n",
    "            all_correct += (predicted == labels).sum().item()\n",
    "\n",
    "    conv1_pruned_accr.append(100 * cnv1_correct / cnv1_total)\n",
    "    fc2_pruned_accr.append(100 * fc2_correct / fc2_total)\n",
    "    all_pruned_accr.append(100 * all_correct / all_total)\n",
    "    conv1_pruned_t.append(conv1_t_tot)\n",
    "    fc2_pruned_t.append(fc2_t_tot)\n",
    "    all_pruned_t.append(all_t_tot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check the effect on the accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax1 = fig.add_subplot(xlabel='sparsity', ylabel='% accuracy')\n",
    "ax1.plot(sparsity, conv1_pruned_accr, c='b', label='conv2 pruning')\n",
    "ax1.plot(sparsity, fc2_pruned_accr, c='r', label='fc2 pruning')\n",
    "ax1.plot(sparsity, all_pruned_accr, c='g', label='all pruning')\n",
    "plt.legend(loc='lower left');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[57.74, 57.74, 57.74, 57.74, 48.65, 22.9]\n",
      "[68.07, 68.21, 68.16, 68.1, 68.13, 67.77]\n",
      "[67.98, 67.46, 63.14, 54.83, 40.17, 11.39]\n"
     ]
    }
   ],
   "source": [
    "print(conv1_pruned_accr)\n",
    "print(fc2_pruned_accr)\n",
    "print(all_pruned_accr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So accuracy decreases with increase in sparsity which is expected. But interestingly, for the amount of compression achieved by fc2 pruning, there is not much loss in the accuracy. Where as, conv1 does least compression with increase in sparsity, but still accuracy is least."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check the effect on performance.I have assumed prediction time as performance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax1 = fig.add_subplot(xlabel='sparsity', ylabel='time in seconds')\n",
    "ax1.plot(sparsity, conv1_pruned_t, c='b', label='conv2 pruning')\n",
    "ax1.plot(sparsity, fc2_pruned_t, c='r', label='fc2 pruning')\n",
    "ax1.plot(sparsity, all_pruned_t, c='g', label='all pruning')\n",
    "plt.legend(loc='upper left');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Actually, I think it would make more sense to check the performance if it would have been structured pruning, as it gurantees removal of some type of parts of NN as compared to unstructured pruning which zeroes out the weights mostly."
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}