train_image_classifier.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "train_image_classifier.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "cH4wqN1oLG9M",
        "3-yt9aksMZX_",
        "vFhrbLVlQbYo",
        "3qfFc2bDNQ6F",
        "Yd1qtwYpN5Ic",
        "lvhEClKhbZ1-"
      ],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU",
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "88f17beb2bc54186a3c8adb25c79b2c8": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "state": {
            "_view_name": "HBoxView",
            "_dom_classes": [],
            "_model_name": "HBoxModel",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "box_style": "",
            "layout": "IPY_MODEL_8dbfa20097594f9882b68e813acefcaa",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_f9c31784e6854a8a96b394ffc640f6cb",
              "IPY_MODEL_e084468383804305a062c7c03a00f6ac"
            ]
          }
        },
        "8dbfa20097594f9882b68e813acefcaa": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "f9c31784e6854a8a96b394ffc640f6cb": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "state": {
            "_view_name": "ProgressView",
            "style": "IPY_MODEL_4353add07e944112ab7c1f580cec6b4e",
            "_dom_classes": [],
            "description": "100%",
            "_model_name": "FloatProgressModel",
            "bar_style": "success",
            "max": 46827520,
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": 46827520,
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "orientation": "horizontal",
            "min": 0,
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_ca13f01eea2445469dc0aee4d9a63fbe"
          }
        },
        "e084468383804305a062c7c03a00f6ac": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_b2b5d1083353476dba0a3010f54605c8",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": " 44.7M/44.7M [00:00&lt;00:00, 168MB/s]",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_6d0603e986ca43c6908fe70102778468"
          }
        },
        "4353add07e944112ab7c1f580cec6b4e": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "ProgressStyleModel",
            "description_width": "initial",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "bar_color": null,
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "ca13f01eea2445469dc0aee4d9a63fbe": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "b2b5d1083353476dba0a3010f54605c8": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "DescriptionStyleModel",
            "description_width": "",
            "_view_module": "@jupyter-widgets/base",
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.2.0",
            "_model_module": "@jupyter-widgets/controls"
          }
        },
        "6d0603e986ca43c6908fe70102778468": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        }
      }
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OSxJ-F2USGwl"
      },
      "source": [
        "##### Training the model "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TIh1fvQLNWan",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 731,
          "referenced_widgets": [
            "88f17beb2bc54186a3c8adb25c79b2c8",
            "8dbfa20097594f9882b68e813acefcaa",
            "f9c31784e6854a8a96b394ffc640f6cb",
            "e084468383804305a062c7c03a00f6ac",
            "4353add07e944112ab7c1f580cec6b4e",
            "ca13f01eea2445469dc0aee4d9a63fbe",
            "b2b5d1083353476dba0a3010f54605c8",
            "6d0603e986ca43c6908fe70102778468"
          ]
        },
        "outputId": "290b831c-3a71-4420-c628-d354cdb2c5f9"
      },
      "source": [
        "!wget -nc http://www.cs.virginia.edu/~vicente/vislang/mmimdb-256.tar.gz\n",
        "!tar xf mmimdb-256.tar.gz\n",
        "!pip install livelossplot --quiet\n",
        "!pip -q install transformers\n",
        "import torch, os, json\n",
        "import matplotlib.pyplot as plt\n",
        "from PIL import Image\n",
        "\n",
        "from transformers import get_linear_schedule_with_warmup \n",
        "\n",
        "def top5_accuracy(predicted, labels):\n",
        "    sorted_vals, sorted_ids = \\\n",
        "        predicted.data.sigmoid().sort(dim = 1, descending = True)\n",
        "    pred_vals = sorted_vals[:, :5] > 0.5 # Anything with sigmoid > 0.5 is 1.\n",
        "    true_vals = labels.data.gather(1, sorted_ids[:, :5]) # Find true values.\n",
        "    return (pred_vals == true_vals).sum(dim = 1) / 5.0\n",
        "\n",
        "\n",
        "class MovieDataset(torch.utils.data.Dataset):\n",
        "    def __init__(self, folder = 'dataset-resized-256max', split = 'dev',\n",
        "                 image_transform = None):\n",
        "        self.json_dir = os.path.join(folder, split, 'metadata')\n",
        "        self.image_dir = os.path.join(folder, split, 'images')\n",
        "        self.image_transform = image_transform\n",
        "\n",
        "        # Category definitions of movies.\n",
        "        self.categories = ['Action', 'Adult', 'Adventure', 'Animation', 'Biography', \n",
        "                           'Comedy', 'Crime', 'Documentary', 'Drama', \n",
        "                           'Family', 'Fantasy', 'Film-Noir', 'History', \n",
        "                           'Horror', 'Music', 'Musical', 'Mystery', 'News', \n",
        "                           'Reality-TV', 'Romance', 'Sci-Fi', 'Short', \n",
        "                           'Sport', 'Talk-Show', 'Thriller', 'War', 'Western']\n",
        "        self.categories2ids = {category: id for (id, category) \n",
        "                               in enumerate(self.categories)}\n",
        "\n",
        "        # Load JSON files.\n",
        "        print('Loading %s ...' % self.json_dir, end = '')\n",
        "        fdir = os.listdir(self.json_dir)\n",
        "        self.metadata = [(fname[:-5], json.load(open(os.path.join(self.json_dir, fname)))) \n",
        "                     for fname in sorted(fdir) if not fname.startswith('.')]\n",
        "        print(' finished')\n",
        "\n",
        "\n",
        "            \n",
        "    def __getitem__(self, index: int):\n",
        "        # Load images on the fly.\n",
        "        filename, movie_data = self.metadata[index]\n",
        "        img_path = os.path.join(self.image_dir, filename + '.jpeg')\n",
        "        image = Image.open(img_path).convert('RGB')\n",
        "        genres = movie_data['genres']\n",
        "\n",
        "        if self.image_transform: image = self.image_transform(image)\n",
        "\n",
        "        # Encode labels in a binary vector.\n",
        "        label_vector = torch.zeros((len(self.categories)), dtype=torch.float32)\n",
        "        label_ids = [self.categories2ids[cat] for cat in genres]\n",
        "        label_vector[label_ids] = 1\n",
        "\n",
        "        return image, label_vector\n",
        "\n",
        "    def load_image_only(self, index: int):\n",
        "        filename, movie_data = self.metadata[index]\n",
        "        img_path = os.path.join(self.image_dir, filename + '.jpeg')\n",
        "        image = Image.open(img_path).convert('RGB')\n",
        "        return image\n",
        "\n",
        "    def get_metadata(self, index: int):\n",
        "        _, movie_data = self.metadata[index]\n",
        "        return movie_data\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.metadata)\n",
        "\n",
        "val_data = MovieDataset(split = 'dev')\n",
        "print('Data size: %d samples' % len(val_data))\n",
        "\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "# Batch size is a liming factor on constrained resources.\n",
        "# only GPUs with a large memory can hold large batches.\n",
        "batch_size = 10\n",
        "\n",
        "image_transform = transforms.Compose([\n",
        "        transforms.Resize(256),\n",
        "        transforms.CenterCrop((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",
        "trainset = MovieDataset(split = 'train', image_transform = image_transform)\n",
        "valset = MovieDataset(split = 'dev', image_transform = image_transform)\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(trainset, \n",
        "                                           batch_size = batch_size, \n",
        "                                           shuffle = True, \n",
        "                                           pin_memory = True,\n",
        "                                           num_workers = 4)\n",
        "val_loader = torch.utils.data.DataLoader(valset, \n",
        "                                         batch_size = batch_size, \n",
        "                                         shuffle = False)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "_, (imgs, labels) = next(enumerate(val_loader))\n",
        "print(imgs.shape, labels.shape)\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np \n",
        "from torchvision import models\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.optim import lr_scheduler\n",
        "import time\n",
        "import os\n",
        "import copy \n",
        "from livelossplot import PlotLosses\n",
        "\n",
        "dataset_sizes = {}\n",
        "\n",
        "dataset_sizes['train'] = len(trainset)\n",
        "dataset_sizes['val'] = len(valset)\n",
        "# randomly selecting batches of 4 from training data \n",
        "\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "\n",
        "\n",
        "# creating dictionary of dataloaders \n",
        "dataloaders = {}\n",
        "dataloaders['train'] = train_loader\n",
        "dataloaders['val'] = val_loader\n",
        "\n",
        "\n",
        "def train_model(model, criterion, optimizer, scheduler, num_epochs=25):\n",
        "    \n",
        "    since = time.time()\n",
        "    plotlosses = PlotLosses()\n",
        "    best_model_weights = copy.deepcopy(model.state_dict())\n",
        "    best_acc = 0.0\n",
        "\n",
        "    index = 0\n",
        "    for epoch in range(num_epochs):\n",
        "        logs = {}\n",
        "        # Each epoch has a training and validation phase\n",
        "        cum_loss = 0.0\n",
        "        cum_acc = 0.0\n",
        "        correct = 0\n",
        "        num_samples = 0 \n",
        "\n",
        "        for phase in ['train', 'val']:\n",
        "            if phase == 'train':\n",
        "                model.train()  # Setting model to appropriate mode (train/evaluate)\n",
        "            else:\n",
        "                model.eval()  \n",
        "\n",
        "            \n",
        "\n",
        "            for inputs, labels in dataloaders[phase]: # sending to GPU/CPU\n",
        "                inputs = inputs.to(device)\n",
        "                labels = labels.to(device)\n",
        "\n",
        "                # clearing the old gradients from the previous step \n",
        "                optimizer.zero_grad()\n",
        "\n",
        "                with torch.set_grad_enabled(phase == 'train'): \n",
        "                    outputs = model(inputs) # computing predictions \n",
        "                    \n",
        "                    loss = criterion(outputs, labels) # calculating loss \n",
        "\n",
        "                    # computing gradients and updating weights if in training mode\n",
        "                    if phase == 'train':\n",
        "                        loss.mean().backward() # computing derivative w.r.t loss\n",
        "                        optimizer.step() \n",
        "                #cum_loss += loss.sum().item() \n",
        "                cum_acc += top5_accuracy(outputs, labels).sum().item()\n",
        "                num_samples += inputs.size(0)\n",
        "                cum_loss += loss.data.sum().item()\n",
        "            if phase == 'train':\n",
        "                scheduler.step() # adjusting based on gradient\n",
        "\n",
        "            curr_loss = cum_loss / num_samples\n",
        "            curr_acc = cum_acc / num_samples\n",
        "            \n",
        "            if phase == 'train':\n",
        "              logs['loss'] = curr_loss\n",
        "              logs['acc'] = curr_acc\n",
        "            else:\n",
        "              logs['val_loss'] = curr_loss\n",
        "              logs['val_acc'] = curr_acc\n",
        "            \n",
        "            plotlosses.update(logs)\n",
        "            plotlosses.send() \n",
        "\n",
        "            # keeping track of best weights \n",
        "            if phase == 'val' and curr_acc > best_acc:\n",
        "                best_acc = curr_acc\n",
        "                best_model_weights = copy.deepcopy(model.state_dict())\n",
        "\n",
        "\n",
        "\n",
        "        print()\n",
        "        print(f'epoch {epoch+1}/{num_epochs}')\n",
        "\n",
        "    if scheduler != -1:\n",
        "        scheduler.step()\n",
        "\n",
        "    print('Best val Acc: {:4f}'.format(best_acc))\n",
        "\n",
        "    model.load_state_dict(best_model_weights)\n",
        "\n",
        "    torch.save(model.state_dict(), 'best_model_so_far-rohan4.pth') \n",
        "\n",
        "    return model\n",
        "\n",
        "\n",
        "\n",
        "cnn_model = models.resnet18(pretrained=True) # weights optimized for ImageNet data\n",
        "\n",
        "\n",
        "for param in cnn_model.parameters(): # freezing parameters \n",
        "  param.requires_grad = False\n",
        "\n",
        "num_ftrs = cnn_model.fc.in_features # getting number of input features from last layer\n",
        "cnn_model.fc = nn.Linear(num_ftrs, len(trainset.categories)) # creating new fully connected layer\n",
        "\n",
        "cnn_model = cnn_model.to(device) # sending model to device\n",
        "criterion = nn.BCEWithLogitsLoss(reduction = 'none') # using BCEWithLogitsLoss for multi-class prediction \n",
        "\n",
        "\n",
        "optimizer = optim.AdamW(cnn_model.parameters(), lr = 1e-5, eps = 1e-8)\n",
        "\n",
        "num_epochs = 12\n",
        "\n",
        "total_steps = len(train_loader) * num_epochs\n",
        "\n",
        "scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps = 0, num_training_steps = total_steps) \n",
        "\n",
        "\n",
        "cnn_model = train_model(cnn_model, criterion, optimizer, scheduler, num_epochs)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Accuracy\n",
            "\ttraining         \t (min:    0.677, max:    0.733, cur:    0.726)\n",
            "\tvalidation       \t (min:    0.685, max:    0.732, cur:    0.726)\n",
            "Loss\n",
            "\ttraining         \t (min:    6.251, max:    8.999, cur:    6.251)\n",
            "\tvalidation       \t (min:    6.254, max:    8.716, cur:    6.254)\n",
            "\n",
            "epoch 12/12\n",
            "Best val Acc: 0.732346\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}