Vanilla_CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "import seaborn as sns\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unpickle(filepath):\n",
    "    import pickle\n",
    "    return pickle.load(open(filepath, 'rb'))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH_100 = \"./data/cifar-100-python/meta\"\n",
    "PATH_10 = \"./data/cifar-10-batches-py/batches.meta\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def class_extractor(dataset):\n",
    "    if dataset == 'CIFAR10':\n",
    "        dict_classes = unpickle(PATH_10)\n",
    "        return tuple(dict_classes['label_names'])\n",
    "    else:\n",
    "        dict_classes = unpickle(PATH_100)\n",
    "        return tuple(dict_classes['fine_label_names'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "save = True\n",
    "train = True\n",
    "batch_size = 128\n",
    "n_epochs = 164\n",
    "dataset = 'CIFAR100'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "\n",
    "train_load_set_args = {'root':'./data', 'train':True, 'download':True, 'transform':transform}\n",
    "test_load_set_args = {'root':'./data', 'train':False, 'download':True, 'transform':transform}\n",
    "if dataset == 'CIFAR10':\n",
    "    trainset = torchvision.datasets.CIFAR10(**train_load_set_args)\n",
    "    testset = torchvision.datasets.CIFAR10(**test_load_set_args)\n",
    "else:\n",
    "    trainset = torchvision.datasets.CIFAR100(**train_load_set_args)\n",
    "    testset = torchvision.datasets.CIFAR100(**test_load_set_args)\n",
    "\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n",
    "                                         shuffle=False, num_workers=2)\n",
    "\n",
    "classes = class_extractor(dataset)\n",
    "n_classes = len(classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50000"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(trainset.train_labels)\n",
    "trainset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN_vanilla(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        self.fc1 = nn.Linear(16 * 5 * 5, 256)\n",
    "        self.fc2 = nn.Linear(256, 256)\n",
    "        self.fc3 = nn.Linear(256, n_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        x = x.view(-1, 16 * 5 * 5)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = CNN_vanilla().to(device)\n",
    "loss_function = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 391] loss: 4.606\n",
      "[2, 391] loss: 4.605\n",
      "[3, 391] loss: 4.605\n",
      "[4, 391] loss: 4.604\n",
      "[5, 391] loss: 4.603\n",
      "[6, 391] loss: 4.602\n",
      "[7, 391] loss: 4.599\n",
      "[8, 391] loss: 4.590\n",
      "[9, 391] loss: 4.550\n",
      "[10, 391] loss: 4.430\n",
      "[11, 391] loss: 4.295\n",
      "[12, 391] loss: 4.182\n",
      "[13, 391] loss: 4.019\n",
      "[14, 391] loss: 3.894\n",
      "[15, 391] loss: 3.823\n",
      "[16, 391] loss: 3.763\n",
      "[17, 391] loss: 3.708\n",
      "[18, 391] loss: 3.652\n",
      "[19, 391] loss: 3.602\n",
      "[20, 391] loss: 3.554\n",
      "[21, 391] loss: 3.510\n",
      "[22, 391] loss: 3.463\n",
      "[23, 391] loss: 3.422\n",
      "[24, 391] loss: 3.379\n",
      "[25, 391] loss: 3.333\n",
      "[26, 391] loss: 3.291\n",
      "[27, 391] loss: 3.249\n",
      "[28, 391] loss: 3.210\n",
      "[29, 391] loss: 3.170\n",
      "[30, 391] loss: 3.133\n",
      "[31, 391] loss: 3.099\n",
      "[32, 391] loss: 3.064\n",
      "[33, 391] loss: 3.027\n",
      "[34, 391] loss: 2.996\n",
      "[35, 391] loss: 2.971\n",
      "[36, 391] loss: 2.936\n",
      "[37, 197] loss: 2.895\r"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-3adadc126688>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m             \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m             \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloss_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m             \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m             \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Diego/pytorch_mujoco_env/lib/python3.6/site-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m    100\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    101\u001b[0m         \"\"\"\n\u001b[0;32m--> 102\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    103\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    104\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Diego/pytorch_mujoco_env/lib/python3.6/site-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m     88\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[1;32m     89\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 90\u001b[0;31m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[1;32m     91\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     92\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "if train:\n",
    "    for epoch in range(n_epochs):    \n",
    "        avg_loss = 0.0\n",
    "        for i, data in enumerate(trainloader, 0):\n",
    "            inputs, labels = data[0].to(device), data[1].to(device)\n",
    "            optimizer.zero_grad()\n",
    "            outputs = net(inputs)\n",
    "            loss = loss_function(outputs, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            avg_loss += (loss.item() - avg_loss)/(i+1)\n",
    "            print('[%d, %3d] loss: %.3f' % (epoch + 1, i + 1, avg_loss), end=\"\\r\")            \n",
    "        print('')\n",
    "    print('Finished Training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "if save:\n",
    "    torch.save(net.state_dict(), './nets/'+dataset+'_net.pth')\n",
    "else:\n",
    "    net = CNN_vanilla().to(device)\n",
    "    net.load_state_dict(torch.load('./nets/'+dataset+'_net.pth'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 10000 test images: 25 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data[0].to(device), data[1].to(device)\n",
    "        outputs = net(images)\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": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of apple : 52 %\n",
      "Accuracy of aquarium_fish : 33 %\n",
      "Accuracy of  baby :  5 %\n",
      "Accuracy of  bear : 10 %\n",
      "Accuracy of beaver : 16 %\n",
      "Accuracy of   bed : 29 %\n",
      "Accuracy of   bee : 23 %\n",
      "Accuracy of beetle : 15 %\n",
      "Accuracy of bicycle : 24 %\n",
      "Accuracy of bottle : 28 %\n",
      "Accuracy of  bowl :  4 %\n",
      "Accuracy of   boy : 11 %\n",
      "Accuracy of bridge : 10 %\n",
      "Accuracy of   bus : 10 %\n",
      "Accuracy of butterfly : 29 %\n",
      "Accuracy of camel : 11 %\n",
      "Accuracy of   can : 32 %\n",
      "Accuracy of castle : 50 %\n",
      "Accuracy of caterpillar : 13 %\n",
      "Accuracy of cattle : 28 %\n",
      "Accuracy of chair : 57 %\n",
      "Accuracy of chimpanzee : 56 %\n",
      "Accuracy of clock : 27 %\n",
      "Accuracy of cloud : 47 %\n",
      "Accuracy of cockroach : 47 %\n",
      "Accuracy of couch :  5 %\n",
      "Accuracy of  crab : 12 %\n",
      "Accuracy of crocodile : 15 %\n",
      "Accuracy of   cup : 38 %\n",
      "Accuracy of dinosaur : 14 %\n",
      "Accuracy of dolphin : 33 %\n",
      "Accuracy of elephant : 16 %\n",
      "Accuracy of flatfish : 20 %\n",
      "Accuracy of forest : 25 %\n",
      "Accuracy of   fox :  4 %\n",
      "Accuracy of  girl : 24 %\n",
      "Accuracy of hamster : 25 %\n",
      "Accuracy of house : 18 %\n",
      "Accuracy of kangaroo :  7 %\n",
      "Accuracy of keyboard : 30 %\n",
      "Accuracy of  lamp : 16 %\n",
      "Accuracy of lawn_mower : 49 %\n",
      "Accuracy of leopard : 21 %\n",
      "Accuracy of  lion : 19 %\n",
      "Accuracy of lizard :  7 %\n",
      "Accuracy of lobster :  8 %\n",
      "Accuracy of   man :  6 %\n",
      "Accuracy of maple_tree : 39 %\n",
      "Accuracy of motorcycle : 44 %\n",
      "Accuracy of mountain : 22 %\n",
      "Accuracy of mouse :  5 %\n",
      "Accuracy of mushroom : 25 %\n",
      "Accuracy of oak_tree : 64 %\n",
      "Accuracy of orange : 47 %\n",
      "Accuracy of orchid : 35 %\n",
      "Accuracy of otter :  2 %\n",
      "Accuracy of palm_tree : 34 %\n",
      "Accuracy of  pear : 24 %\n",
      "Accuracy of pickup_truck : 31 %\n",
      "Accuracy of pine_tree : 34 %\n",
      "Accuracy of plain : 73 %\n",
      "Accuracy of plate : 23 %\n",
      "Accuracy of poppy : 56 %\n",
      "Accuracy of porcupine : 21 %\n",
      "Accuracy of possum :  7 %\n",
      "Accuracy of rabbit :  3 %\n",
      "Accuracy of raccoon :  9 %\n",
      "Accuracy of   ray : 25 %\n",
      "Accuracy of  road : 56 %\n",
      "Accuracy of rocket : 44 %\n",
      "Accuracy of  rose : 32 %\n",
      "Accuracy of   sea : 47 %\n",
      "Accuracy of  seal :  7 %\n",
      "Accuracy of shark : 25 %\n",
      "Accuracy of shrew : 21 %\n",
      "Accuracy of skunk : 54 %\n",
      "Accuracy of skyscraper : 54 %\n",
      "Accuracy of snail :  5 %\n",
      "Accuracy of snake : 11 %\n",
      "Accuracy of spider :  5 %\n",
      "Accuracy of squirrel :  5 %\n",
      "Accuracy of streetcar : 13 %\n",
      "Accuracy of sunflower : 56 %\n",
      "Accuracy of sweet_pepper : 16 %\n",
      "Accuracy of table :  8 %\n",
      "Accuracy of  tank : 30 %\n",
      "Accuracy of telephone : 27 %\n",
      "Accuracy of television : 21 %\n",
      "Accuracy of tiger :  8 %\n",
      "Accuracy of tractor : 36 %\n",
      "Accuracy of train : 16 %\n",
      "Accuracy of trout : 38 %\n",
      "Accuracy of tulip : 16 %\n",
      "Accuracy of turtle : 12 %\n",
      "Accuracy of wardrobe : 58 %\n",
      "Accuracy of whale : 37 %\n",
      "Accuracy of willow_tree : 13 %\n",
      "Accuracy of  wolf : 27 %\n",
      "Accuracy of woman :  4 %\n",
      "Accuracy of  worm : 28 %\n"
     ]
    }
   ],
   "source": [
    "n = len(classes)\n",
    "class_correct = list(0. for i in range(n))\n",
    "class_total = list(0. for i in range(n))\n",
    "confusion_matrix = np.zeros([n,n]).astype(int)\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data[0].to(device), data[1].to(device)\n",
    "        outputs = net(images)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        c = (predicted == labels).squeeze()\n",
    "        for i in range(len(labels)):\n",
    "            label = labels[i]\n",
    "            prediction = predicted[i]\n",
    "            class_correct[label] += c[i].item()\n",
    "            class_total[label] += 1\n",
    "            confusion_matrix[label, prediction] += 1\n",
    "\n",
    "for i in range(n):\n",
    "    print('Accuracy of %5s : %2d %%' % (\n",
    "        classes[i], 100 * class_correct[i] / max(class_total[i],1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(12,10))\n",
    "\n",
    "confusion_df = pd.DataFrame(data=confusion_matrix, index=classes,\n",
    "                           columns=classes)\n",
    "if dataset == 'CIFAR10':\n",
    "    hm = sns.heatmap(confusion_df, cmap=\"YlGnBu_r\",\n",
    "                annot=True, fmt=\"d\", linewidths=0.1, cbar=False)\n",
    "    hm.set_yticklabels(hm.get_yticklabels(), rotation = 0)\n",
    "else:\n",
    "    hm = sns.heatmap(confusion_matrix, cmap=\"YlGnBu_r\",\n",
    "                    annot=False, fmt=\"d\", linewidths=0, cbar=True,\n",
    "                    xticklabels=False, yticklabels=False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}