IntelImageClassification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "IntelImageClassification.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "48AiePu-fUqd",
        "colab_type": "text"
      },
      "source": [
        "# Mount Drive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wojsjYKXoRIi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Mount Google drive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6A6WVx7I30O1",
        "colab_type": "text"
      },
      "source": [
        "# Getting the data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5PG7LVHpfOVV",
        "colab_type": "text"
      },
      "source": [
        "## Raw data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qtEXtaORFBSX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!curl --header 'Host: storage.googleapis.com' --user-agent 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0' --header 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8' --header 'Accept-Language: en-US,en;q=0.5' --header 'Upgrade-Insecure-Requests: 1' 'https://storage.googleapis.com/kaggle-datasets/111880/269359/intel-image-classification.zip?GoogleAccessId=web-data@kaggle-161607.iam.gserviceaccount.com&Expires=1567087455&Signature=eCAN7FIF6NvpwmwaHqzJZWoeeGFLy5i4YzkXnWw3uAjtdySnAlc7edZlfQ24k0KakZeIOEO5N3mIqHluaZPpMNNOvi7dfO6iF08w%2BdauuBj3naHqoG2iApCIzd9aBiRU9vM1727EuMSOjrsW4IUT8Tg9Hf43DzG38qom9WmHCsjfnmSTiQJlS6JnAIXScX5BkA67hRcYPoLHRLLyzMX5FSuzHxVZDX0vw0aD8kivx2nHC%2BztYVYRfmeJdKiou5K4yicdLcO4a574P27%2BwsCRNKNHW%2FiD3%2FlahkLlHbuut5SZtYDGTOlFMFzUli2wwTYT7EbwF8%2FwBHD5K9YVC4vxCw%3D%3D' --output 'intel-image-classification.zip'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A8Kn4HgeFmSR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!unzip intel-image-classification.zip"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m1AybNPi2_jC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!unzip seg_pred.zip\n",
        "!unzip seg_test.zip\n",
        "!unzip seg_train.zip"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3sraPaLzYxok",
        "colab_type": "text"
      },
      "source": [
        "## Data from drive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WgSMj_scY-EU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!cp drive/My\\ Drive/datasetintel.tar ."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JgI_Hsw-ZMn7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!tar -xvf datasetintel.tar"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jitirk6t33s_",
        "colab_type": "text"
      },
      "source": [
        "# Imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9PGkJW8qF7Ww",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import os\n",
        "import math\n",
        "from tqdm.autonotebook import tqdm\n",
        "from google.colab import files\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as img\n",
        "import torch\n",
        "from torch import nn, optim\n",
        "from torchvision import datasets, transforms, models\n",
        "from torch.utils.data.sampler import SubsetRandomSampler\n",
        "%matplotlib inline"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LxV69UYq3zSl",
        "colab_type": "text"
      },
      "source": [
        "# Exploring data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "weTojMmn4SBi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print('Classes:')\n",
        "!ls seg_train/"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AmPVodSgGNTJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "fig, ax = plt.subplots(1, 3, figsize=(10, 5))\n",
        "img_pred = plt.imread('seg_pred/19527.jpg')\n",
        "print(f'dimensions of photo: {img_pred.shape}')\n",
        "img_train = plt.imread('seg_train/buildings/1231.jpg')\n",
        "img_test = plt.imread('seg_test/buildings/22812.jpg')\n",
        "ax[0].imshow(img_pred)\n",
        "ax[1].imshow(img_train)\n",
        "ax[2].imshow(img_test)\n",
        "ax[0].set_title('Image pred')\n",
        "ax[1].set_title('Image train')\n",
        "ax[2].set_title('Image test')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aSmTDgKU5nm3",
        "colab_type": "text"
      },
      "source": [
        "# DataLoader"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ie3TtMS2EaEI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class MyDataset(datasets.ImageFolder):\n",
        "    def __getitem__(self, index):\n",
        "        \"\"\"\n",
        "        Args:\n",
        "            index (int): Index\n",
        "\n",
        "        Returns:\n",
        "            tuple: (sample, target) where target is class_index of the target class.\n",
        "        \"\"\"\n",
        "        path, target = self.samples[index]\n",
        "        sample = self.loader(path)\n",
        "        if self.transform is not None:\n",
        "            sample = self.transform(sample)\n",
        "        if self.target_transform is not None:\n",
        "            target = self.target_transform(target)\n",
        "\n",
        "        return sample, target, path"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ffl6AmEaGX0b",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train_transforms = transforms.Compose([\n",
        "                                       transforms.RandomHorizontalFlip(),\n",
        "                                       transforms.Resize((224, 224)),\n",
        "                                       transforms.RandomRotation(20),\n",
        "                                       transforms.ToTensor(),\n",
        "                                       transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
        "                                                            std=[0.229, 0.224, 0.225])\n",
        "])\n",
        "test_transforms = transforms.Compose([\n",
        "                                      transforms.Resize((224, 224)),\n",
        "                                      transforms.ToTensor(),\n",
        "                                      transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
        "                                                            std=[0.229, 0.224, 0.225])\n",
        "])\n",
        "\n",
        "valid_size = 0.2\n",
        "\n",
        "trainset = MyDataset('seg_train', transform=train_transforms)\n",
        "testset = MyDataset('seg_test', transform=test_transforms)\n",
        "\n",
        "num_test = len(testset)\n",
        "indices = list(range(num_test))\n",
        "np.random.shuffle(indices)\n",
        "split = int(np.floor(valid_size * num_test))\n",
        "test_idx, valid_idx = indices[split:], indices[:split]\n",
        "\n",
        "test_sampler = SubsetRandomSampler(test_idx)\n",
        "valid_sampler = SubsetRandomSampler(valid_idx)\n",
        "\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True, num_workers=12)\n",
        "validloader = torch.utils.data.DataLoader(testset, batch_size=32, num_workers=12, sampler=valid_sampler)\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=32, sampler=test_sampler, num_workers=12)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ksBp__R-LdN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "images, labels, path = next(iter(trainloader))\n",
        "ind = 0\n",
        "print(f'Length of training dataset: {len(trainset)}')\n",
        "print(f'Length of validation dataset: {valid_size*len(testset)}')\n",
        "print(f'Length of test dataset: {(1-valid_size)*len(testset)}')\n",
        "print(f'Size of images batch: {images.shape}')\n",
        "\n",
        "image = np.transpose(images[0].numpy(), (1, 2, 0))\n",
        "plt.imshow(image)\n",
        "print(labels[ind])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d4ee_8WN-DbN",
        "colab_type": "text"
      },
      "source": [
        "# [1] Refining Model (ResNet50)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lwv4eabZf2b9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = models.resnet50(pretrained=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jSWsR_VbZWyk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Freeze layers here\n",
        "for param in model.parameters():\n",
        "    param.requires_grad = False"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fPYcd9BUYCa_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model.fc = nn.Sequential(nn.Linear(2048, 1024),\n",
        "                          nn.ReLU(),\n",
        "                          nn.Linear(1024, 6),\n",
        "                         nn.LogSoftmax(dim=1))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vnhRZDKDGsZI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "criterion = nn.NLLLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=1e-3)\n",
        "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=2, factor=0.5)\n",
        "model.cuda()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kXOeW3IZ-JFi",
        "colab_type": "text"
      },
      "source": [
        "## Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PdJK6jNt9_E7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def train(model, dataloaders, criterion, optimizer, scheduler, use_gpu=True, epochs=30, min_loss=np.Inf, saveto='model.pt'):\n",
        "    best_weights = model.state_dict()\n",
        "    min_loss = min_loss\n",
        "\n",
        "    for epoch in range(epochs):\n",
        "        print(f'\\nEpoch{epoch+1}/{epochs}')\n",
        "        print('--------------------')\n",
        "        for phase in ['train', 'eval']:\n",
        "            if(phase=='train'):\n",
        "                model.train()\n",
        "            else:\n",
        "                model.eval()\n",
        "            running_loss = 0.0\n",
        "\n",
        "            for data, target, _ in tqdm(dataloaders[phase]):\n",
        "                torch.cuda.empty_cache()\n",
        "                data, target = data.cuda(), target.cuda()\n",
        "                optimizer.zero_grad()\n",
        "                output = model(data)\n",
        "                if(type(output)==tuple):\n",
        "                    output, _ = output\n",
        "                loss = criterion(output, target)\n",
        "\n",
        "                if(phase=='train'):\n",
        "                    loss.backward()\n",
        "                    optimizer.step()\n",
        "                \n",
        "                running_loss += loss.item() * data.size(0)\n",
        "            \n",
        "            if(phase=='eval'):\n",
        "                epoch_loss = running_loss/(valid_size*len(testset))\n",
        "            else:\n",
        "                epoch_loss = running_loss/len(trainset)\n",
        "\n",
        "            print(f'\\nLoss in {phase} phase: {epoch_loss}')\n",
        "\n",
        "            if(phase=='eval' and min_loss>epoch_loss):\n",
        "                print('\\nSaving new model...')\n",
        "                min_loss = epoch_loss\n",
        "                best_weights = model.state_dict()\n",
        "                torch.save(model, saveto)\n",
        "        scheduler.step(epoch_loss)\n",
        "        for param in optimizer.param_groups:\n",
        "            print('Learning rate:', param['lr'])\n",
        "        \n",
        "    print(f'\\nTraining Complete!\\nMinimum Loss: {min_loss}')\n",
        "\n",
        "    model.load_state_dict(best_weights)\n",
        "    return model"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u6v88FiHgDnz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = train(model, {'train': trainloader, 'eval': validloader}, criterion, optimizer, scheduler, saveto='resnet50.pt')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7ELt1CrG4RV9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# model = torch.load('resnet50.pt')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EjBwxU3e8GBu",
        "colab_type": "text"
      },
      "source": [
        "## Inference"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "itei6PMq4A9Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def getAccuracy(dataloader):\n",
        "    model.eval()\n",
        "    test_loss = 0\n",
        "    running_corrects = 0\n",
        "    for data, target, path in tqdm(dataloader):\n",
        "        data, target = data.cuda(), target.cuda()\n",
        "        output = model(data)\n",
        "\n",
        "        _, preds = torch.max(output.data, 1)\n",
        "\n",
        "        loss = criterion(output, target)\n",
        "        test_loss += loss.item() * data.size(0)\n",
        "        running_corrects += torch.sum(preds == target.data).item()\n",
        "\n",
        "    print(test_loss/len(dataloader.dataset))\n",
        "    print('Correct labels:', running_corrects, '/', len(dataloader.dataset))\n",
        "    print('Correctness score:', running_corrects/len(dataloader.dataset))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9ZSb95oe8HY-",
        "colab_type": "text"
      },
      "source": [
        "### Making a dataloader with whole test dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qhXdLOgZ4BA8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "fulltestloader = torch.utils.data.DataLoader(testset, batch_size=32, num_workers=12)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nUq0OHQ5B1Rl",
        "colab_type": "text"
      },
      "source": [
        "### Getting accuracies"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K5x26TY6BH4o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print('Accuracy for valid+test set')\n",
        "getAccuracy(fulltestloader)\n",
        "print('Accuracy for test set')\n",
        "getAccuracy(testloader)\n",
        "print('Accuracy for train set')\n",
        "getAccuracy(trainloader)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PDLcRHpw8ib0",
        "colab_type": "text"
      },
      "source": [
        "# Removing confusing and mislabeled images from dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zO2icpHFZ8VV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def get_confusing(model, dataloader, conf_images, mislabeled):\n",
        "    model.eval()\n",
        "    test_loss = 0\n",
        "    running_corrects = 0\n",
        "    for data, target, path in tqdm(dataloader):\n",
        "        torch.cuda.empty_cache()\n",
        "        data, target = data.cuda(), target.cuda()\n",
        "        output = model(data)\n",
        "\n",
        "        _, preds = torch.max(output.data, 1)\n",
        "        probs = []\n",
        "        for out in output:\n",
        "            prob = torch.exp(out)\n",
        "            prob = torch.div(prob, torch.sum(prob))\n",
        "            prob = torch.max(prob)\n",
        "            probs.append(prob)\n",
        "        for i in range(len(probs)):\n",
        "            if(probs[i]<0.5):\n",
        "                conf_images.append([data[i].cpu().numpy(), path[i]])\n",
        "            elif(probs[i]>0.999999 and target[i]!=preds[i]):\n",
        "                mislabeled.append([data[i].cpu().numpy(), preds[i], target[i], path[i]])\n",
        "\n",
        "        loss = criterion(output, target)\n",
        "        test_loss += loss.item() * data.size(0)\n",
        "        running_corrects += torch.sum(preds == target.data)\n",
        "\n",
        "    print(test_loss/len(dataloader.dataset))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RHdRzQyIxw5l",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "conf_images = []\n",
        "mislabeled = []\n",
        "\n",
        "get_confusing(model, trainloader, conf_images, mislabeled)\n",
        "print(f'Length of confusing images: {len(conf_images)}\\tLength of mis-labeled images: {len(mislabeled)}')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t1xBmz4TBjJy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "id2class = {x:y for y, x in trainset.class_to_idx.items()}"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TTFO7gzTsaFz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "invTrans = transforms.Compose([ transforms.Normalize(mean = [ 0., 0., 0. ],\n",
        "                                                     std = [ 1/0.229, 1/0.224, 1/0.225 ]),\n",
        "                                transforms.Normalize(mean = [ -0.485, -0.456, -0.406 ],\n",
        "                                                     std = [ 1., 1., 1. ]),\n",
        "                               ])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NIDAPNC4Wurc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ind = 4\n",
        "\n",
        "photo = invTrans(torch.from_numpy(conf_images[ind][0]))\n",
        "photo = np.transpose(photo.numpy(), (1, 2, 0))\n",
        "plt.imshow(photo)\n",
        "print(f'Path: {conf_images[ind][1]}')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Aks11Fr8rj3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ind = 0\n",
        "\n",
        "photo = invTrans(torch.from_numpy(mislabeled[ind][0]))\n",
        "photo = np.transpose(photo.numpy(), (1, 2, 0))\n",
        "print(f'Prediction: {mislabeled[ind][1]}\\tTarget: {mislabeled[ind][2]}')\n",
        "plt.imshow(photo)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xNdgOwFaEGpL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for _, path in conf_images:\n",
        "    os.remove(path)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "grs2EaTdqtBY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for _, _, _, path in mislabeled:\n",
        "    os.remove(path)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YHs9TxJBCJqu",
        "colab_type": "text"
      },
      "source": [
        "# [2] Driving model (DenseNet-161)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k45jsg1qCV1H",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = models.densenet161(pretrained=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HorlTmJ6Cqvb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for param in model.parameters():\n",
        "  param.requires_grad = False"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RzkJh9KxCxg6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for param in (model.features.denseblock3).parameters():\n",
        "  param.requires_grad = True\n",
        "for param in (model.features.denseblock4).parameters():\n",
        "  param.requires_grad = True"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GmFr5NASCy7e",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model.classifier = nn.Sequential(nn.Linear(2208, 1024),\n",
        "                                nn.ReLU(),\n",
        "                                nn.Dropout(),\n",
        "                                nn.Linear(1024, 6),\n",
        "                                nn.LogSoftmax(dim=1))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rQWHskbNC6ys",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "criterion = nn.NLLLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=1e-3)\n",
        "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=2, factor=0.5)\n",
        "model.cuda()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s0ehnBwvDEOc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = train(model, {'train': trainloader, 'eval': validloader}, criterion, optimizer, scheduler, saveto='densenet161.pt')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kGZ-lS6Y71V1",
        "colab_type": "text"
      },
      "source": [
        "# Save model to Drive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9-aes-YxUQSj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!cp densenet161.pt /content/drive/My\\ Drive/intelmodel.pt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3_17Ckoo94Re",
        "colab_type": "text"
      },
      "source": [
        "# Try out your own image (Demo)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BY9wuqLGDkVW",
        "colab_type": "text"
      },
      "source": [
        "## Dependencies"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ppgctgAZ958L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import torch\n",
        "from PIL import Image\n",
        "from torchvision import transforms, models\n",
        "%matplotlib inline"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PxFbmY2TDl8e",
        "colab_type": "text"
      },
      "source": [
        "## Upload model weights and image"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oSMNXH1CDJD2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from google.colab import files\n",
        "files.upload()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LT3XESPL-rr1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "transform = transforms.Compose([\n",
        "                                      transforms.Resize((224, 224)),\n",
        "                                      transforms.ToTensor(),\n",
        "                                      transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
        "                                                            std=[0.229, 0.224, 0.225])\n",
        "])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PZEJ-LVEdT6J",
        "colab_type": "text"
      },
      "source": [
        "## Evaluate results"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "90hwBuCm9_hz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class GetProbs:\n",
        "    def __init__(self, modelpath):\n",
        "        self.model = torch.load(modelpath).cpu()\n",
        "    \n",
        "    def __call__(self, imgpath, plot=True):\n",
        "        self.model.eval()\n",
        "        img = Image.open(imgpath)\n",
        "        preds = self.model(torch.unsqueeze(transform(img), 0))\n",
        "        x = ['buildings', 'forest', 'glacier', 'mountain', 'sea', 'street']\n",
        "        if(plot):\n",
        "            fig, ax = plt.subplots(1, 2, figsize=(12, 6))\n",
        "            ax[0].imshow(img)\n",
        "            ax[0].set_title('Original image')\n",
        "            ax[1].set_title('Predictions')\n",
        "            ax[1].set_ylabel('Percentage')\n",
        "            ax[1].set_xlabel('Labels')\n",
        "            prob = torch.exp(preds)\n",
        "            prob = torch.div(prob, torch.sum(prob))\n",
        "            prob = prob.detach().numpy()[0]\n",
        "            sns.barplot(x=x, y=prob*100, ax=ax[1])\n",
        "        else:\n",
        "            pred = x[(torch.max(preds, dim=1))[1].item()]\n",
        "            return pred"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Eu39L9sQfsj0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "get_probs = GetProbs('drive/My Drive/intelmodel.pt')\n",
        "get_probs('seg_pred/1003.jpg')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iZzbm4JAOsWt",
        "colab_type": "text"
      },
      "source": [
        "# To get csv for seg_pred folder"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v4Opjz9eyMLq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "preds = []\n",
        "\n",
        "for f in tqdm(os.listdir('seg_pred')):\n",
        "    preds.append([f[:-4], get_probs('seg_pred/'+f, plot=False)])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JzBoAZmV8A1K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "df = pd.DataFrame(data=preds, columns=['ID', 'Class'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9pV18UwBBnM9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "df = df.sort_values('ID')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u9BxVgvrBnZS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "df.to_csv('preds.csv', index=False)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bURhH3nGC6Wm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}