CNN_Transformer-V2_1.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9-LyAe4nxMVi",
        "colab_type": "text"
      },
      "source": [
        "# Image Captioning\n",
        "Task: Generate Image Captions<br>\n",
        "Dataset: VizWiz-Captions dataset<br>\n",
        "Challenge [Link](https://vizwiz.org/tasks-and-datasets/image-captioning/)\n",
        "\n",
        "It is a proposed approach for image captioning, on further improvements it might give best results on this dataset."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A-h6Hg6M97ZZ",
        "colab_type": "text"
      },
      "source": [
        "##Data Downloading"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rv3f62XyyAqu",
        "colab_type": "code",
        "outputId": "8e88ef0c-7b79-4595-f35b-e10835f4a3b0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 246
        }
      },
      "source": [
        "# Training data\n",
        "!wget --header=\"Host: ivc.ischool.utexas.edu\" --header=\"User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.122 Safari/537.36\" --header=\"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\" --header=\"Accept-Language: en-GB,en-US;q=0.9,en;q=0.8\" --header=\"Referer: https://vizwiz.org/tasks-and-datasets/image-captioning/\" \"https://ivc.ischool.utexas.edu/VizWiz_final/images/train.zip\" -c -O 'train.zip'"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2020-05-08 14:58:03--  https://ivc.ischool.utexas.edu/VizWiz_final/images/train.zip\n",
            "Resolving ivc.ischool.utexas.edu (ivc.ischool.utexas.edu)... 146.6.168.124\n",
            "Connecting to ivc.ischool.utexas.edu (ivc.ischool.utexas.edu)|146.6.168.124|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 11298421598 (11G) [application/zip]\n",
            "Saving to: ‘train.zip’\n",
            "\n",
            "train.zip           100%[===================>]  10.52G  37.9MB/s    in 4m 10s  \n",
            "\n",
            "2020-05-08 15:02:13 (43.2 MB/s) - ‘train.zip’ saved [11298421598/11298421598]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S8sze7k5yar7",
        "colab_type": "code",
        "outputId": "1689aa64-9f08-4557-a736-9eee25f02836",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        }
      },
      "source": [
        "# validation data\n",
        "!wget --header=\"Host: ivc.ischool.utexas.edu\" --header=\"User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.122 Safari/537.36\" --header=\"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\" --header=\"Accept-Language: en-GB,en-US;q=0.9,en;q=0.8\" --header=\"Referer: https://vizwiz.org/tasks-and-datasets/image-captioning/\" \"https://ivc.ischool.utexas.edu/VizWiz_final/images/val.zip\" -c -O 'val.zip'"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2020-05-08 13:05:36--  https://ivc.ischool.utexas.edu/VizWiz_final/images/val.zip\n",
            "Resolving ivc.ischool.utexas.edu (ivc.ischool.utexas.edu)... 146.6.168.124\n",
            "Connecting to ivc.ischool.utexas.edu (ivc.ischool.utexas.edu)|146.6.168.124|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 3488913457 (3.2G) [application/zip]\n",
            "Saving to: ‘val.zip’\n",
            "\n",
            "val.zip             100%[===================>]   3.25G  36.7MB/s    in 83s     \n",
            "\n",
            "2020-05-08 13:06:59 (40.3 MB/s) - ‘val.zip’ saved [3488913457/3488913457]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EPG0MfhxU9ZP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        },
        "outputId": "ba1b4beb-b0aa-44f8-cd06-28551b1fa875"
      },
      "source": [
        "# Annotations\n",
        "!wget --header=\"Host: ivc.ischool.utexas.edu\" --header=\"User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36\" --header=\"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\" --header=\"Accept-Language: en-GB,en-US;q=0.9,en;q=0.8\" \"https://ivc.ischool.utexas.edu/VizWiz_final/caption/annotations.zip\" -c -O 'annotations.zip'"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2020-05-08 13:07:08--  https://ivc.ischool.utexas.edu/VizWiz_final/caption/annotations.zip\n",
            "Resolving ivc.ischool.utexas.edu (ivc.ischool.utexas.edu)... 146.6.168.124\n",
            "Connecting to ivc.ischool.utexas.edu (ivc.ischool.utexas.edu)|146.6.168.124|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 4509069 (4.3M) [application/zip]\n",
            "Saving to: ‘annotations.zip’\n",
            "\n",
            "annotations.zip     100%[===================>]   4.30M  14.8MB/s    in 0.3s    \n",
            "\n",
            "2020-05-08 13:07:09 (14.8 MB/s) - ‘annotations.zip’ saved [4509069/4509069]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RuvTDzMiznE3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from zipfile import ZipFile\n",
        "\n",
        "# training data path\n",
        "train_zip = '/content/train.zip'\n",
        "with ZipFile( train_zip ) as z:\n",
        "  z.extractall()\n",
        "\n",
        "# validation data path\n",
        "valid_zip = '/content/val.zip'\n",
        "with ZipFile( valid_zip ) as z:\n",
        "  z.extractall()\n",
        "\n",
        "# annotation data path\n",
        "annotation_pth = '/content/annotations.zip'\n",
        "with ZipFile( annotation_pth ) as z:\n",
        "  z.extractall()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "paii7SFpGWEI",
        "colab_type": "code",
        "outputId": "f5b6e5d3-c318-439d-a53f-3d7cd1ec37b3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "import os\n",
        "import json\n",
        "import re\n",
        "import math\n",
        "import numpy as np\n",
        "import random\n",
        "import time\n",
        "import collections\n",
        "import warnings\n",
        "warnings.filterwarnings(action=\"ignore\")\n",
        "from collections import defaultdict\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch import optim\n",
        "from torch.nn import functional as F\n",
        "import torchvision\n",
        "from torchvision import models, transforms\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "\n",
        "from torchtext import vocab\n",
        "from keras.preprocessing.sequence import pad_sequences\n",
        "\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt\n",
        "from tqdm.notebook import tqdm"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using TensorFlow backend.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rNj1XKEQu5ht",
        "colab_type": "text"
      },
      "source": [
        "## Data Preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8ZXu344cniXX",
        "colab_type": "code",
        "cellView": "both",
        "colab": {}
      },
      "source": [
        "class VizWizDataset(Dataset):\n",
        "  \"\"\"\n",
        "     Custom class to create dataset of images and captions from json(annotation) file\n",
        "    Args:\n",
        "      annotation (str): path to the annotation of data\n",
        "      size (int, int): size of the image to be resized\n",
        "      path (str): path to the downloaded images\n",
        "      ignore_rejected (bool): [default:True] to reject, captions with is_rejected flag as true, in dataset\n",
        "      ignore_precanned (bool): [default:True] to reject, captions with is_precanned flag as true, in dataset\n",
        "      text_detected (bool): [default:True] to accept captions only with 'text_detected' flag as true\n",
        "    \"\"\"\n",
        "\n",
        "  def __init__(self, annotation, size, path, ignore_rejected = True, ignore_precanned = True, text_detected = True):\n",
        "    self.PATH = path\n",
        "    self.ignore_rejected = ignore_rejected\n",
        "    self.ignore_precanned = ignore_precanned\n",
        "    self.text_detected = text_detected\n",
        "\n",
        "    # dict with img_id as key and value is list containing caption, 'is_precanned', 'is_rejected', 'text_detected'\n",
        "    self.caps_dict = defaultdict(list)\n",
        "    self.caps_dict_final = defaultdict(list)\n",
        "\n",
        "    # list of images for which 'text_Detected' == True in image annotation\n",
        "    self.imgs = []\n",
        "    self.loadAnnotations(annotation)\n",
        "\n",
        "    # transforms for image data\n",
        "    self.tfms = transforms.Compose([transforms.Resize(size),\n",
        "                                    transforms.RandomHorizontalFlip(),\n",
        "                                    transforms.ToTensor(),\n",
        "                                    transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))])\n",
        "    \n",
        "    # word counter dictionary with key as word and value as no. of word occurance\n",
        "    self.count = collections.Counter()\n",
        "    # word vocabulary\n",
        "    self.word_vocab = None\n",
        "    self.tokenize()\n",
        "    \n",
        "  def loadAnnotations(self, annotation):\n",
        "    \"\"\"\n",
        "    function to load annotation data and update the captions of an image in dict\n",
        "    and update the imgs list\n",
        "    \"\"\"\n",
        "    # loading annotation file\n",
        "    with open(annotation) as file:\n",
        "      data = json.load(file)\n",
        "\n",
        "    # update captions of corresponding image\n",
        "    for annot in data['annotations']:\n",
        "      if not ((self.ignore_rejected and annot['is_rejected']) or (self.ignore_precanned and annot['is_precanned'])):\n",
        "        self.caps_dict[annot['image_id']].append(annot)\n",
        "\n",
        "    # update imgs list\n",
        "    for img in data['images']:\n",
        "      if self.caps_dict[img['id']] and (img['text_detected'] and self.text_detected):\n",
        "        self.imgs.append(img)\n",
        "\n",
        "  def tokenize(self):\n",
        "    \"\"\"\n",
        "    \"\"\"\n",
        "    PUNCTUATIONS = r'[!()\\-[\\]{};:\"\\,<>/?@#$%^&.*_~]'\n",
        "    # special tokens\n",
        "    START_TOKEN = '<sos>'\n",
        "    END_TOKEN = '<eos>'\n",
        "    PAD_TOKEN = '<pad>'\n",
        "    UNK_TOKEN = '<unk>'\n",
        "\n",
        "    # list of all captions in dataset for vocabulary\n",
        "    text_corpus = []\n",
        "    for key, value in self.caps_dict.items():\n",
        "      for item in value:\n",
        "        text = re.sub(PUNCTUATIONS, \"\", item['caption'])\n",
        "        tokens = (START_TOKEN + ' ' + text.lower() + ' ' + END_TOKEN)\n",
        "        self.caps_dict_final[str(key)].append(tokens)\n",
        "        text_corpus.append(tokens.split())\n",
        "\n",
        "    # counting words' frequency\n",
        "    for seq in text_corpus:\n",
        "      for word in seq:\n",
        "        self.count[word]+=1\n",
        "\n",
        "    # creating vocabulary of words\n",
        "    self.word_vocab = vocab.Vocab(self.count,\n",
        "                            max_size=7000,\n",
        "                            min_freq=2,\n",
        "                            specials=[PAD_TOKEN, START_TOKEN, END_TOKEN, UNK_TOKEN])\n",
        "    \n",
        "    \n",
        "  def __len__(self):\n",
        "    \"\"\"Returns length of dataset\"\"\"\n",
        "    # number of images\n",
        "    return len(self.imgs)\n",
        "\n",
        "  def __getitem__(self, idx):\n",
        "    img_dict = self.imgs[idx]\n",
        "    # image id\n",
        "    id = img_dict['id']\n",
        "    # load image from path\n",
        "    img = Image.open(os.path.join(self.PATH, img_dict['file_name']))\n",
        "    # applying transforms\n",
        "    img = self.tfms(img)\n",
        "    captions = [caption for caption in self.caps_dict_final[str(id)]]\n",
        "\n",
        "    return img, captions"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "64J999i5Giyd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "START_TOKEN = '<sos>'\n",
        "END_TOKEN = '<eos>'\n",
        "PAD_TOKEN = '<pad>'\n",
        "UNK_TOKEN = '<unk>'\n",
        "\n",
        "cnt = collections.Counter()\n",
        "# vocabulary of all the words present in the train, valid captions\n",
        "global global_vocab\n",
        "global_vocab = vocab.Vocab(cnt,\n",
        "                           max_size=10000,\n",
        "                           min_freq=2,\n",
        "                           specials=[PAD_TOKEN, START_TOKEN, END_TOKEN, UNK_TOKEN])\n",
        "\n",
        "if torch.cuda.is_available():\n",
        "  device='cuda'\n",
        "else:\n",
        "  device='cpu'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "06fwsc-aEmHB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# path to validation annotatations file\n",
        "valid_ann = '/content/annotations/val.json'\n",
        "\n",
        "# image size required for the model\n",
        "size = (224, 224)\n",
        "\n",
        "# path to validation images \n",
        "valid_path = '/content/val/'\n",
        "\n",
        "#path to training annotations file\n",
        "train_ann = '/content/annotations/train.json'\n",
        "# path to training images\n",
        "train_path = '/content/train/'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "McVXASheE6SQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def cap_collate_fn(batch):\n",
        "  '''\n",
        "  -> Custom collate function for torch DataLoader\n",
        "    \n",
        "    Returns batch (imgs, capts)\n",
        "  '''\n",
        "  imgs = [img for img,_ in batch]\n",
        "  captions = [cap for _,cap in batch]\n",
        "  # number of words in every sentence(caption) in a batch\n",
        "  lens = []\n",
        "  for item in captions:\n",
        "    for cap in item:\n",
        "      lens.append(len(cap.split(' ')))\n",
        "  # max length of any sequence(caption) in the batch\n",
        "  # max_len = np.percentile(lens, 100)\n",
        "  max_len = max(lens)\n",
        "\n",
        "  min_caps = min([len(caps) for _, caps in batch])\n",
        "  capts = []\n",
        "  # max_len = 128\n",
        "  for idx in range(min_caps):\n",
        "    items=[]\n",
        "    for cap in captions:\n",
        "      tokens = cap[idx].split(' ')\n",
        "      tok_ids = [global_vocab.stoi[token] if global_vocab.stoi[token] else global_vocab.stoi['<unk>'] for token in tokens]\n",
        "      items.append(tok_ids)\n",
        "    capts.append(pad_sequences(items, maxlen=max_len, padding='post', truncating='post', value=0))\n",
        "    # capts = pad_sequences(capts, maxlen=max_len, padding='post', truncating='post', value=0)\n",
        "  return torch.stack(imgs), torch.LongTensor(capts)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SVTVSH7XwEGZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "bs = 5\n",
        "\n",
        "train_d = VizWizDataset(train_ann, size, train_path)\n",
        "valid_d = VizWizDataset(valid_ann, size, valid_path)\n",
        "\n",
        "# update global vocab\n",
        "global_vocab.extend(train_d.word_vocab)\n",
        "global_vocab.extend(valid_d.word_vocab)\n",
        "\n",
        "trainloader = DataLoader(train_d, batch_size= bs, shuffle=True, collate_fn=cap_collate_fn)\n",
        "validloader = DataLoader(valid_d, batch_size=bs, shuffle=True, collate_fn = cap_collate_fn)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2wn76TRMw32E",
        "colab_type": "code",
        "outputId": "270496dc-c586-4938-c8f8-ada1bd969a95",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "print('number of unique words in trainset captions: {}'.format(len(train_d.word_vocab)))\n",
        "print('number of unique words in validset captions: {}'.format(len(valid_d.word_vocab)))"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "number of unique words in trainset captions: 7004\n",
            "number of unique words in validset captions: 7004\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M57ys7R4wtdr",
        "colab_type": "code",
        "outputId": "435335fc-076d-407b-c0da-3c17fc5f6d3e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "print('number of unique words in global vocab: {}'.format(len(global_vocab)))"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "number of unique words in global vocab: 8796\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HbPFB2xF3ZDM",
        "colab_type": "code",
        "outputId": "68554114-2d49-4840-8886-e39d05b870e4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Number of validation and training samples\n",
        "valid_d.__len__(), train_d.__len__()"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5010, 14684)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6PpDR6A9H-cG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def denorm(x):\n",
        "  \"\"\"Function to convert a tensor data \n",
        "    into a format accepted by imshow\n",
        "    Args:\n",
        "      x : Tensor image\n",
        "  \"\"\"\n",
        "  x = x.to('cpu')\n",
        "  # converting to numpy\n",
        "  # as dataloader appends an extra dimension of batch_size so squeeze\n",
        "  x = x.detach().numpy().squeeze()\n",
        "  # torch ToTensor changes the orientiation of Image data\n",
        "  x = np.transpose(x, (1, 2, 0))\n",
        "  # denormalizing\n",
        "  x = x*np.array((0.229, 0.224, 0.225)) + np.array((0.485, 0.456, 0.406));\n",
        "  x = x.clip(0, 1)\n",
        "  return x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cZMshJ_LyPUd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def show_batch(batch, row, column):\n",
        "  \"\"\"\n",
        "  Function to plot(show) a batch of data\n",
        "    Args:\n",
        "      batch : batch of data\n",
        "      row, column : image representation\n",
        "  \"\"\"\n",
        "  # images\n",
        "  fig = plt.figure(figsize=(25,10))\n",
        "  for i in range(len(batch[0])):\n",
        "    ax = fig.add_subplot(row, column, i+1, xticks=[], yticks=[])\n",
        "    plt.imshow(denorm(batch[0][i]))\n",
        "    ax.set_title('img' + str(i+1))\n",
        "  \n",
        "  # captions\n",
        "  for i in range(len(batch[1])):\n",
        "    for idx, caps in enumerate(batch[1][i]):\n",
        "      print('img'+str(idx+1), end=' ')\n",
        "      for  cap in caps:\n",
        "        if cap==0:\n",
        "          break\n",
        "        print(global_vocab.itos[cap], end=' ')\n",
        "      print('')\n",
        "    print('')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DJpZNWvvlpB3",
        "colab_type": "code",
        "outputId": "20abd454-be76-4165-8bde-ed4b7dca751e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 562
        }
      },
      "source": [
        "batch = iter(trainloader).next()\n",
        "show_batch(batch, 2, 5)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "img1 <sos> a green plastic package of wallingford decaffeinated coffee <eos> \n",
            "img2 <sos> food label facts with black fun lettering on it <eos> \n",
            "img3 <sos> a package of pills laying flat down on a counter <eos> \n",
            "img4 <sos> 1 percent low fat milk gallon sitting on table with blue lid <eos> \n",
            "img5 <sos> the front side of a book with a man smiling on it <eos> \n",
            "\n",
            "img1 <sos> bag of coffee lying or leaning on a wood grain surface <eos> \n",
            "img2 <sos> a white drug package with the drug facts panel showing <eos> \n",
            "img3 <sos> a bubble pack sheet of medication is sitting on a white tile surface <eos> \n",
            "img4 <sos> front of a mostly empty gallon jug of milk showing the nutritional information <eos> \n",
            "img5 <sos> appears to be a picture of a magazine <eos> \n",
            "\n",
            "img1 <sos> a green bag of wallingford brand decaffeinated coffee <eos> \n",
            "img2 <sos> a label showing the nutrition facts for a consumable <eos> \n",
            "img3 <sos> a blister pack of medication clear side down on a table <eos> \n",
            "img4 <sos> a gallon of milk is on top of the counter <eos> \n",
            "img5 <sos> someone's hand holding a book with the text you can win featured on its cover <eos> \n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1800x720 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SYsONpF_vGrO",
        "colab_type": "text"
      },
      "source": [
        "## Model Description"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dLn2FGO06ZSr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# class ResnetEncoder(nn.Module):\n",
        "#   def __init__(self, outsize=16):\n",
        "#     super(ResnetEncoder, self).__init__()\n",
        "#     # pretrained resnet model\n",
        "#     resnet = models.resnet34(pretrained = True)\n",
        "#     # removing classifier linear layer\n",
        "#     # as we require only the features of the images\n",
        "#     self.resnet = nn.Sequential(*list(resnet.children())[:-2])\n",
        "#     # for variable size input images -> fixed sized output\n",
        "#     self.avgPool = nn.AdaptiveAvgPool2d((outsize, outsize))\n",
        "\n",
        "#   def forward(self, x):\n",
        "#     x = self.resnet(x)\n",
        "#     # x -> bs x 2048 x 7 x 7\n",
        "#     x = F.relu(self.avgPool(x))\n",
        "#     # x -> bs x 2048 x outsize x outsize\n",
        "#     bs, feats= x.shape[0], x.shape[1]\n",
        "#     x = x.view(bs, feats, -1)\n",
        "#     return x.float()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jSci-2I03wN1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class ImageEncoder(nn.Module):\n",
        "  \"\"\"\n",
        "  Image encoder built using pretrained VGG19 net\n",
        "    Args: outsize(dimension of model)\n",
        "  \"\"\"\n",
        "  def __init__(self, outsize=256):\n",
        "    super(ImageEncoder, self).__init__()\n",
        "    # pretrained resnet model\n",
        "    net = models.vgg19_bn(pretrained = True)\n",
        "    # removing classifier linear layer\n",
        "    # as we require only the features of the images\n",
        "    self.net = nn.Sequential(*list(net.children())[:-2])\n",
        "    # for variable size input images -> fixed sized output\n",
        "    self.avgPool = nn.AdaptiveAvgPool2d((14, 14))\n",
        "    self.linear = nn.Linear(14*14, outsize)\n",
        "\n",
        "  def forward(self, x):\n",
        "    \"x: Image input\"\n",
        "    x = self.net(x)\n",
        "    # x -> bs x 512 x 7 x 7\n",
        "    x = self.avgPool(x)\n",
        "    # x -> bs x 512 x 14 x 14\n",
        "    bs, feats= x.shape[0], x.shape[1]\n",
        "    x = x.view(bs, feats, -1)\n",
        "    x = self.linear(x)\n",
        "    return x.float()    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N9j26yCA-JAa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class PositionalEncoding(nn.Module):\n",
        "  \"\"\"\n",
        "   -> Positional Encoding ...\n",
        "    Args:\n",
        "      dim (int): dimension of embedding\n",
        "  \"\"\"\n",
        "  def __init__(self, dim, max_len=250):\n",
        "    super(PositionalEncoding, self).__init__()\n",
        "    pe = torch.zeros(max_len, dim)\n",
        "    position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)\n",
        "    freq = 1/10000**(torch.arange(0., dim, 2.)/dim)\n",
        "    # aranging sine and cosine terms\n",
        "    pe[:, 0::2] = torch.sin(position*freq)\n",
        "    pe[:, 1::2] = torch.cos(position*freq)\n",
        "    self.register_buffer('pe', pe)\n",
        "    \n",
        "  def forward(self, sz):\n",
        "    \" sz: length of sequence\"\n",
        "    return self.pe[:sz, :]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4AKt8XwP4ssg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class TransformerEmbedding(nn.Module):\n",
        "  \"\"\"\n",
        "  ->Transformer embedding is built from a simple embedding\n",
        "    along with a positional encoding layer\n",
        "\n",
        "  Args:  \n",
        "    d_model : dimension of embedding\n",
        "    vocab_sz : size of vocabulary\n",
        "    drop_p : dropout probability\n",
        "    pretrained : load the weights of pretrained embedding(optional)\n",
        "  \"\"\"\n",
        "  def __init__(self, vocab_sz, d_model, device, drop_p = 0, pretrained=False):\n",
        "    self.device=device\n",
        "    super(TransformerEmbedding, self).__init__()\n",
        "    self.vocab_sz = vocab_sz\n",
        "    self.embed = nn.Embedding(vocab_sz, d_model)\n",
        "    self.pos_enc = PositionalEncoding(d_model)\n",
        "    self.dropout = nn.Dropout(drop_p)\n",
        "    \n",
        "  # TODO: load pretrained embedding\n",
        "  # def init_embed_weight(self):\n",
        "  #   \"\"\" \"\"\"\n",
        "  #   pass\n",
        "  \n",
        "  def forward(self, x):\n",
        "    \" x: input sequence \"    \n",
        "    x = x.to(self.device)\n",
        "    embed = self.embed(x)*math.sqrt(self.vocab_sz) + self.pos_enc(x.shape[1])\n",
        "    # embed = self.embed(x) + self.pos_enc\n",
        "    return self.dropout(embed)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bTo-cxc0iXsc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class TransformerModel(nn.Module):\n",
        "  \"\"\"\n",
        "   Transformer model for Image captioning\n",
        "  Args: \n",
        "    enc_vocab_sz : vocab size of encoder\n",
        "    d_model : model's dimension\n",
        "    device : cuda/cpu\n",
        "    enc_emb_drop : dropout probability in encoder embedding dropout layer\n",
        "    n_enc_layers: number of encoder_layers in transformer encoder block\n",
        "    n_dec_layers: number of decoder_layers in transformer decoder block\n",
        "    n_heads: number of heads in multi head attention layer\n",
        "  \"\"\"\n",
        "  def __init__(self, dec_vocab_sz, d_model, device, enc_emb_drop = 0.0,\n",
        "               n_enc_layers=6, n_dec_layers=6, nheads=8):\n",
        "    super(TransformerModel, self).__init__()\n",
        "\n",
        "    self.pad_idx=1\n",
        "    # input embedding\n",
        "    # self.enc_embed = TransformerEmbedding(vocab_sz=enc_vocab_sz, d_model=d_model, drop_p=enc_emb_drop, device=device)\n",
        "    # output embeddding\n",
        "    self.dec_embed = TransformerEmbedding(vocab_sz=dec_vocab_sz, d_model=d_model, drop_p=0.0, device=device)\n",
        "    \n",
        "    # transformer encoder layer\n",
        "    enc_layer = nn.TransformerEncoderLayer(d_model=d_model,\n",
        "                                           nhead=nheads,\n",
        "                                           dim_feedforward=2048)\n",
        "    # transformer decoder layer\n",
        "    dec_layer = nn.TransformerDecoderLayer(d_model=d_model,\n",
        "                                           nhead=nheads,\n",
        "                                           dim_feedforward=2048)\n",
        "\n",
        "    # transformer encoder\n",
        "    self.Transformer_enc = nn.TransformerEncoder(enc_layer, n_enc_layers)\n",
        "    # transformer Decoder\n",
        "    self.Transformer_dec = nn.TransformerDecoder(dec_layer, n_dec_layers)\n",
        "\n",
        "    # final linear layer\n",
        "    self.linear_out = nn.Linear(d_model, dec_vocab_sz)\n",
        "    # softmax layer\n",
        "    self.softmax = nn.Softmax(dim=-1)\n",
        "\n",
        "  def gen_mask(self, szx, szy):\n",
        "    \"\"\" \n",
        "    -> generate mask for attention layers\n",
        "    -> for square mask szx == szy == seq_length\n",
        "    -> for key_padding mask szx == batch_size and szy == seq_length\n",
        "\n",
        "      for key_padding_mask, function assumes the pad_idx in vocab is zero.\n",
        "\n",
        "      Args:\n",
        "        szx : num of rows\n",
        "        szy : num of columns\n",
        "\n",
        "      Returns:\n",
        "        mask (square mask / key_padding mask)\n",
        "    \"\"\"\n",
        "    mask = (torch.triu(torch.ones(szx, szy)) == 1).transpose(0, 1)\n",
        "    mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))\n",
        "    return mask\n",
        "\n",
        "  def forward(self, inp, target):    \n",
        "    \"\"\"\n",
        "      Args: \n",
        "        inp : input sequence(input to transformer encoder)\n",
        "        target : sequence input to trasformer decoder \n",
        "    \"\"\"\n",
        "    # enc_embed_out = self.enc_embed(inp)\n",
        "    enc_embed_out = inp\n",
        "    enc_embed_out = enc_embed_out.permute(1,0,2)\n",
        "    # enc_embed_out dim => (seq_length(512) x batch_size x num_features(d_model))\n",
        "    # print(enc_embed_out.shape)\n",
        "\n",
        "    dec_embed_out = self.dec_embed(target)\n",
        "    dec_embed_out = dec_embed_out.permute(1, 0, 2)\n",
        "    # dec_embed_out dim => (seq_length x batch_size x num_features)\n",
        "    # print(dec_embed_out.shape)\n",
        "\n",
        "    enc_out = self.Transformer_enc(src = enc_embed_out)\n",
        "    # print(enc_out.shape)\n",
        "\n",
        "    tgt_mask = self.gen_mask(dec_embed_out.shape[0], dec_embed_out.shape[0])\n",
        "    tgt_mask = tgt_mask.to(device)\n",
        "    # tgt_key_padding_mask = self.get_key_padding_mask\n",
        "\n",
        "    dec_out = self.Transformer_dec(tgt=dec_embed_out,\n",
        "                                   memory=enc_out,\n",
        "                                   tgt_mask= tgt_mask,\n",
        "                                   tgt_key_padding_mask=None)\n",
        "    # output shape => seq_length x batch_size x num_features\n",
        "    dec_out = dec_out.permute(1, 0, 2)\n",
        "    # print(dec_out.shape)\n",
        "\n",
        "    out = self.linear_out(dec_out)\n",
        "    # return out\n",
        "    # return self.softmax(out)\n",
        "    return out"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lcnslhj1q9Po",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Hyper parameters\n",
        "d_model = 256                       # dimension of model/embedding\n",
        "enc_vocab_sz = len(global_vocab)    # vocab size of encoder embedding\n",
        "dec_vocab_sz = len(global_vocab)    # vocab size of decoder embedding"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I2zLKx_iTssD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class CustomOptim:\n",
        "    \"\"\" schedular \n",
        "    Args:\n",
        "      d_model = model dimension\n",
        "    type factor: (int)\n",
        "    type warmup: (int)\n",
        "    type optimizer : torch.nn.optim class \n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, d_model, factor, warmup, optimizer):\n",
        "        self.optimizer = optimizer\n",
        "        self._step = 0\n",
        "        self.warmup = warmup\n",
        "        self.factor = factor\n",
        "        self.model_size = d_model\n",
        "        self._rate = 0\n",
        "        \n",
        "    def step(self):\n",
        "      \"Update parameters and rate\"\n",
        "      self._step += 1\n",
        "      rate = self.rate()\n",
        "      for p in self.optimizer.param_groups:\n",
        "          p['lr'] = rate\n",
        "      self._rate = rate\n",
        "      self.optimizer.step()\n",
        "        \n",
        "    def rate(self, step = None):\n",
        "      if step is None:\n",
        "        step = self._step\n",
        "      return self.factor * \\\n",
        "        (self.model_size**(-0.5)*min( step**(-0.5), step*self.warmup**(-1.5)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "unSH9wgUAIgP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Model intialization\n",
        "imgEncoder = ImageEncoder().to(device)\n",
        "transformerModel = TransformerModel(dec_vocab_sz=dec_vocab_sz,\n",
        "                                    d_model=d_model,\n",
        "                                    device=device,\n",
        "                                    enc_emb_drop=0.1).to(device)\n",
        "\n",
        "# for loss calculation, we'll not consider '<pad>' values in target\n",
        "criterion = nn.CrossEntropyLoss(ignore_index=global_vocab.stoi['<pad>'],\n",
        "                                reduction = 'sum')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sEojrA3g3Xvp",
        "colab_type": "code",
        "outputId": "24aa160a-f284-46f8-ef9c-842698187524",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "a=(sum(p.numel() for p in imgEncoder.parameters() if p.requires_grad))\n",
        "b=(sum(p.numel() for p in transformerModel.parameters() if p.requires_grad))\n",
        "num_params = a+b\n",
        "print(f'Total Number of Trainable parameters in complete model(imgEncoder + transformerModel): {num_params}')"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Total Number of Trainable parameters in complete model(imgEncoder + transformerModel): 41961116\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BVOeTpAaxE13",
        "colab_type": "text"
      },
      "source": [
        "##Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jkuu0IG-UZ_E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# total parameters in the model\n",
        "params = list(imgEncoder.parameters())+list(transformerModel.parameters())\n",
        "\n",
        "optimizer = CustomOptim(d_model, 1, 2000, optim.Adam(params, lr=0, betas=(0.9, 0.99)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DmblZZSYJq_T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def seed_all(seed_value):\n",
        "    \"\"\"\n",
        "     -> Function to random seed all the gpu and cpu variables to \n",
        "        regenerate the same results, at the testing time, as they were at training\n",
        "    Args:\n",
        "      seed_value\n",
        "    \"\"\"\n",
        "    random.seed(seed_value) # Python\n",
        "    torch.manual_seed(seed_value) # cpu vars\n",
        "    \n",
        "    if torch.cuda.is_available(): \n",
        "        torch.cuda.manual_seed(seed_value) # gpu variables"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6y9wGm_Kz5XY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from nltk.translate.bleu_score import sentence_bleu\n",
        "\n",
        "class BLEU:\n",
        "  \"\"\" to calculate bleu score\n",
        "      currenty gives result for BLEU-4 only\n",
        "  \"\"\"\n",
        "  def __init__(self, target):\n",
        "    self.target = self.get_ref(target)\n",
        "    # uniform weights for n(1,2,3,4) grams.\n",
        "    self.weights = [[1],\n",
        "                    [0.5, 0.5],\n",
        "                    [1./3, 1./3, 1./3],\n",
        "                    [0.25, 0.25, 0.25, 0.25]]\n",
        "\n",
        "  def get_ref(self, target):\n",
        "    \"\"\"rearrange target captions\"\"\"\n",
        "    # target sequences(reference sequences)\n",
        "    tgt_seqs = []\n",
        "    target = target.clone().detach()\n",
        "    for i in range(len(target[0])):\n",
        "      s1=[]\n",
        "      for b in target:\n",
        "        s2=[]\n",
        "        for id in b[i]:\n",
        "          if id == global_vocab.stoi['<eos>']: break\n",
        "          if id in [0,1,3]: continue\n",
        "          s2.append(global_vocab.itos[id])\n",
        "        s1.append(s2)\n",
        "      tgt_seqs.append(s1)\n",
        "\n",
        "    return tgt_seqs\n",
        "\n",
        "\n",
        "  def __call__(self, preds):\n",
        "    # using greedy method to get tokens\n",
        "    preds = F.softmax(preds.clone().detach(), dim=1).argmax(dim=-1)\n",
        "    # predicted tokens\n",
        "    pred_seqs = []\n",
        "    for seq in preds:\n",
        "      tokens = []\n",
        "      for id in seq:\n",
        "        if id == global_vocab.stoi['<eos>']:  break\n",
        "        tokens.append(global_vocab.itos[id])\n",
        "      pred_seqs.append(tokens)\n",
        "\n",
        "    bleu_score = []\n",
        "    for i in range(len(self.target)):\n",
        "      bleu_score.append(sentence_bleu(self.target[i], pred_seqs[i]))\n",
        "    return np.array(bleu_score)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YmhOZaJeBIuo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def printTime(clk, prc):\n",
        "  \"\"\"\n",
        "  function to convert seconds time into proper format\n",
        "  Args:\n",
        "    clk: time in seconds\n",
        "    prc: process type(train/valid)\n",
        "  \"\"\"\n",
        "  print(f'{prc} time: {time.strftime(\"%H:%M:%S\",time.gmtime(clk))}')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6pYXZdAtGko8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def saveModel(encoder, decoder, filepath, trn_loss, vld_loss):\n",
        "    \"\"\"\n",
        "    Function to save model parameters for further use\n",
        "    Args:\n",
        "        encoder: image encoder model\n",
        "        decoder: Decoder model\n",
        "        filepath: (optional) model parameters are saved at \"filepath\"\n",
        "        trn_loss: Training Loss\n",
        "        vld_loss: validation loss calculated using CrossEntropyLoss\n",
        "    \"\"\"\n",
        "    filepath = filepath+'_model.pth'\n",
        "        \n",
        "    torch.save({\n",
        "            'trn_loss': trn_loss,\n",
        "            'vld_loss': vld_loss,\n",
        "            'encoder_sd': encoder.state_dict(),\n",
        "            'decoder_sd': decoder.state_dict()\n",
        "            }, filepath)\n",
        "    print(\"Model saved at {}\".format(filepath))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "To Start the Training Process run the below cell. Also can change the EPOCHS and other hyperparameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jmyWhxi2JSyQ",
        "colab_type": "code",
        "outputId": "6720a37c-2fa8-462b-985f-203d05d5c8fd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 877,
          "referenced_widgets": [
            "920b6e3de6454b31a426c96b77b6e640",
            "bde4bd0f66644888842e8ca502ab0aa4",
            "54ff25b4750b4431941e32e5fcb22002",
            "7c432c7891c14def9479c03bee8570f8",
            "a3f2c007ba4c4e11b362541e4d3d6536",
            "c0805fc9479f4421bdb640ffc7cb15b6",
            "9fc74803d0ea44fea4d68a385efaf08e",
            "b1e689347afd4ddb8a8940a3cd948fb8",
            "7a0b9f1173af40e88855abb376b0c339",
            "71a27495803847bb851ec08182ff5da5",
            "b0fd5b7e506544229f20fce9ad00fb0b",
            "9b7e5c3e39994fc4968865d908e6d836",
            "6741f7b3f3cc491fb4f10496fda4f250",
            "8e6b8415121d42fe912c1e7bfbf1b2f9",
            "b9c5910ac68a48da9f2e6bce773c5a61",
            "246838ffac3a4a3cb3fba5ec80345c64",
            "326898d252d34ba8a9e8c39ff798dcd0",
            "9df6e080eee548a1a5a960f8ef84e325",
            "e72fb15389584131b98b10df9768cd4c",
            "469f9c7ac33248e2add0d120aa339084",
            "799e623b783841f0a16643016848b77f",
            "4e4d1a26668c424d908b7d4324f9f0ec",
            "55120930181c4be29b88eb00e3c1fd91",
            "a03fc5393ea244b39a7830b954235ac3",
            "416acc525e1d4ca5b9e2034cdf394fb2",
            "d3ee24c792344552bab576bcda88f327",
            "4af1b548e89b458994c8bf69053f6f07",
            "1c865959a5574cd1ad0bc322f62f9c4f",
            "d13dc1016e5e444f867c46ec92a526ec",
            "6b3d83db8f554e06bc5befb9aeb71da9",
            "b42c396236cf49be95d2ad675b9272a9",
            "891112437f0c47088115b99e10376583"
          ]
        }
      },
      "source": [
        "EPOCHS = 8\n",
        "clip = 1\n",
        "best_valid_loss = float('inf')\n",
        "seed=53\n",
        "\n",
        "seed_all(seed)\n",
        "\n",
        "# list to track the losses during training\n",
        "trn_loss=[]\n",
        "vld_loss=[]\n",
        "\n",
        "mbar = tqdm(range(EPOCHS), total = EPOCHS, leave=False)\n",
        "for epoch in mbar:\n",
        "  print(f'########## Epoch-{(epoch+1):2} ##########\\n')\n",
        "  ##################################\n",
        "  ##           Training           ##\n",
        "  ##################################\n",
        "  start_time = time.time()\n",
        "  imgEncoder.train()\n",
        "  transformerModel.train()\n",
        "\n",
        "  train_loss=0.\n",
        "\n",
        "  b_loss=0    # batch_loss\n",
        "  b_score=0   # bleu_score\n",
        "  pbar = tqdm(enumerate(trainloader), total=len(trainloader), leave = False)\n",
        "  for idx, batch in pbar:\n",
        "    pbar.set_description('Training...')\n",
        "\n",
        "    imgs = batch[0].to(device)        # images\n",
        "    captions = batch[1].to(device)    # captions\n",
        "    optimizer.optimizer.zero_grad()\n",
        "\n",
        "    # image features\n",
        "    img_feats = imgEncoder(imgs)\n",
        "    # every image has multiple captions\n",
        "    # So training for each caption seperately\n",
        "\n",
        "    cap_loss=0\n",
        "    # list of bleu_Scores\n",
        "    bleu_score=0\n",
        "    bleu_c = BLEU(captions)\n",
        "    for i in range(len(captions)):\n",
        "      # feed the captions(target), img_feats(inp) into transformer model\n",
        "      \n",
        "      # inout sequence is shifted by one time step\n",
        "      tgt_inp = captions[i][:,1:]\n",
        "      tgt_eval = captions[i][:,:-1]\n",
        "      output = transformerModel(inp = img_feats,\n",
        "                                target = tgt_inp)\n",
        "      # get bleu score for prediction\n",
        "      bleu_score = bleu_score + bleu_c(output)\n",
        "      \n",
        "      preds = output.view(-1, output.shape[-1])\n",
        "      tgt_eval = tgt_eval.contiguous().view(-1)\n",
        "      loss = criterion(input=preds, target=tgt_eval)\n",
        "      cap_loss+=loss\n",
        "\n",
        "    # bleu score of a batch prediction\n",
        "    bleu_score=(bleu_score/len(captions)).mean()\n",
        "    b_score+=bleu_score\n",
        "\n",
        "    # num of non zero tokens in all captions\n",
        "    num_tok = torch.sum(captions!=0)\n",
        "    cap_loss/=num_tok.item()\n",
        "    b_loss+=cap_loss  # update batch loss\n",
        "\n",
        "    # calculating gradients\n",
        "    cap_loss.backward()\n",
        "\n",
        "    # clipping gradients to prevent from gradient exploding problem\n",
        "    params = list(imgEncoder.parameters())+list(transformerModel.parameters())\n",
        "    torch.nn.utils.clip_grad_norm_(params, clip)      \n",
        "    \n",
        "    # updating model parameters\n",
        "    optimizer.step()\n",
        "\n",
        "    # print stats during training\n",
        "    if idx%700 == 0:\n",
        "      trn_loss.append(cap_loss.item())\n",
        "      print(f'trn_loss: {b_loss/(idx+1):.5f}  [BLEU_4: {b_score/(idx+1):.4f}]')\n",
        "\n",
        "  # mean batch loss\n",
        "  train_loss = b_loss/len(trainloader)\n",
        "  # mean training bleu score\n",
        "  trn_b_score = b_score/len(trainloader)\n",
        "  train_time = time.time() - start_time\n",
        "\n",
        "\n",
        "\n",
        "  # reset time for validation\n",
        "  start_time = time.time()\n",
        "  ################################\n",
        "  ##         Validation         ##\n",
        "  ################################\n",
        "  imgEncoder.eval()\n",
        "  transformerModel.eval()\n",
        "  valid_loss = 0.\n",
        "  b_loss=0   # batch_loss\n",
        "  b_score=0  # bleu_Score\n",
        "  with torch.no_grad():\n",
        "    pbar = tqdm(enumerate(validloader), total=len(validloader), leave=False)\n",
        "    for idx, batch in pbar:\n",
        "      pbar.set_description('Validation...')\n",
        "      imgs = batch[0].to(device)        # images\n",
        "      captions = batch[1].to(device)    # captions\n",
        "\n",
        "      cap_loss=0\n",
        "      bleu_c = BLEU(captions)\n",
        "\n",
        "      bleu_score = 0\n",
        "      # image features\n",
        "      img_feats = imgEncoder(imgs)\n",
        "      for i in range(len(captions)):\n",
        "        \n",
        "        tgt_inp = captions[i][:,1:]\n",
        "        tgt_eval = captions[i][:,:-1]\n",
        "        output = transformerModel(inp=img_feats,\n",
        "                                  target=tgt_inp)\n",
        "        # get bleu score of the predictions\n",
        "        bleu_score= bleu_score + bleu_c(output)\n",
        "\n",
        "        # calculate loss\n",
        "        preds = output.view(-1, output.shape[-1])\n",
        "        tgt_eval = tgt_eval.contiguous().view(-1)\n",
        "        loss = criterion(input=preds, target=tgt_eval)\n",
        "        cap_loss+=loss\n",
        "\n",
        "      # bleu score for batch\n",
        "      bleu_score=(bleu_score/len(captions)).mean()\n",
        "      b_score+=bleu_score\n",
        "\n",
        "      num_tokens = torch.sum(captions!=0)\n",
        "      cap_loss/=num_tokens.item()\n",
        "      b_loss+=cap_loss\n",
        "\n",
        "    # mean training loss\n",
        "    valid_loss = b_loss/(len(validloader))\n",
        "    # mean bleu_score of the predictions\n",
        "    vld_b_score = b_score/len(validloader)\n",
        "    vld_loss.append(valid_loss.item())\n",
        "\n",
        "  # eval time\n",
        "  eval_time = time.time()-start_time  \n",
        "  \n",
        "  # training stats\n",
        "  print(\"\\n --- Training --- \\n  Loss: {:.4f} \\n  BLEU_4: {:.4f}\".format(\n",
        "      train_loss, trn_b_score\n",
        "  ))\n",
        "\n",
        "  # validation stats\n",
        "  print(\"\\n --- Validation --- \\n  Loss: {:.4f} \\n  BLEU_4: {:.4f}\\n\".format(\n",
        "      valid_loss, vld_b_score\n",
        "  ))\n",
        "  # print('Training Loss: {:.4f} | Validation Loss: {:.4f} | train BLEU score: {:.4f} | valid BLEU score: {:.4f}'.format(train_loss, valid_loss, trn_b_score, vld_b_score))\n",
        "  # print('train BLEU score: {:.4f}')\n",
        "\n",
        "  # save best model\n",
        "  if valid_loss.item() < best_valid_loss:\n",
        "    best_valid_loss = valid_loss.item()\n",
        "    saveModel(imgEncoder, transformerModel, 'vizvizV01', trn_loss, vld_loss)\n",
        "\n",
        "  printTime(train_time, 'Training')\n",
        "  printTime(eval_time, 'Validation')\n",
        "  print('')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "920b6e3de6454b31a426c96b77b6e640",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "HBox(children=(IntProgress(value=0, max=8), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "########## Epoch- 1 ##########\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "7a0b9f1173af40e88855abb376b0c339",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "HBox(children=(IntProgress(value=0, max=2937), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "trn_loss: 9.19915  [BLEU_4: 0.0000]\n",
            "trn_loss: 4.26782  [BLEU_4: 0.3680]\n",
            "trn_loss: 3.09122  [BLEU_4: 0.3676]\n",
            "trn_loss: 2.49889  [BLEU_4: 0.3587]\n",
            "trn_loss: 2.12984  [BLEU_4: 0.3508]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "326898d252d34ba8a9e8c39ff798dcd0",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "HBox(children=(IntProgress(value=0, max=1002), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " --- Training --- \n",
            "  Loss: 2.0689 \n",
            "  BLEU_4: 0.3506\n",
            "\n",
            " --- Validation --- \n",
            "  Loss: 0.7180 \n",
            "  BLEU_4: 0.4740\n",
            "\n",
            "Model saved at vizvizV01_model.pth\n",
            "Training time: 01:08:57\n",
            "Validation time: 00:11:02\n",
            "\n",
            "########## Epoch- 2 ##########\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "416acc525e1d4ca5b9e2034cdf394fb2",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "HBox(children=(IntProgress(value=0, max=2937), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "trn_loss: 0.63760  [BLEU_4: 0.3913]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-29-4fa41dc0a563>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     25\u001b[0m   \u001b[0mb_score\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m   \u001b[0;31m# bleu_score\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     26\u001b[0m   \u001b[0mpbar\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrainloader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtotal\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrainloader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mleave\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 27\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpbar\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     28\u001b[0m     \u001b[0mpbar\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_description\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Training...'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tqdm/notebook.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    220\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__iter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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    221\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 222\u001b[0;31m             \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtqdm_notebook\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__iter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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    223\u001b[0m                 \u001b[0;31m# return super(tqdm...) will not catch exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    224\u001b[0m                 \u001b[0;32myield\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tqdm/std.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1089\u001b[0m             \"\"\"), fp_write=getattr(self.fp, 'write', sys.stderr.write))\n\u001b[1;32m   1090\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1091\u001b[0;31m         \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miterable\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   1092\u001b[0m             \u001b[0;32myield\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1093\u001b[0m             \u001b[0;31m# Update and possibly print the progressbar.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    343\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    344\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__next__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\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--> 345\u001b[0;31m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_data\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    346\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_num_yielded\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    347\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_kind\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0m_DatasetKind\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIterable\u001b[0m \u001b[0;32mand\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_next_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    383\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_next_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\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    384\u001b[0m         \u001b[0mindex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# may raise StopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 385\u001b[0;31m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_fetcher\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# may raise StopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    386\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pin_memory\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    387\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/utils/data/_utils/fetch.py\u001b[0m in \u001b[0;36mfetch\u001b[0;34m(self, possibly_batched_index)\u001b[0m\n\u001b[1;32m     42\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpossibly_batched_index\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     43\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mauto_collation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 44\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpossibly_batched_index\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     45\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torch/utils/data/_utils/fetch.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     42\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpossibly_batched_index\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     43\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mauto_collation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 44\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpossibly_batched_index\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     45\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-4-dd4ae3751345>\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, idx)\u001b[0m\n\u001b[1;32m     99\u001b[0m     \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mImage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPATH\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'file_name'\u001b[0m\u001b[0;34m]\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    100\u001b[0m     \u001b[0;31m# applying transforms\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 101\u001b[0;31m     \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtfms\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\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    102\u001b[0m     \u001b[0mcaptions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mcaption\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcaption\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcaps_dict_final\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m)\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    103\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torchvision/transforms/transforms.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, img)\u001b[0m\n\u001b[1;32m     59\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg\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     60\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransforms\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 61\u001b[0;31m             \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\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     62\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     63\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/torchvision/transforms/transforms.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, pic)\u001b[0m\n\u001b[1;32m     90\u001b[0m             \u001b[0mTensor\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mConverted\u001b[0m \u001b[0mimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     91\u001b[0m         \"\"\"\n\u001b[0;32m---> 92\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_tensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpic\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     93\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     94\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__repr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\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/usr/local/lib/python3.6/dist-packages/torchvision/transforms/functional.py\u001b[0m in \u001b[0;36mto_tensor\u001b[0;34m(pic)\u001b[0m\n\u001b[1;32m     78\u001b[0m     \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpermute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontiguous\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     79\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mByteTensor\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---> 80\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdiv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m255\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     81\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     82\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L8DogyOFETFZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def gen_cap(img, maxlen):\n",
        "  \"\"\" \n",
        "  Function to generate Captions\n",
        "  Not yet tested\n",
        "  Args:\n",
        "    img: image\n",
        "    maxlen: maximum length of the caption\n",
        "            to be genereted\n",
        "  Return:\n",
        "    caption: generated caption of the input image\n",
        "  \"\"\"\n",
        "  imgEncoder.eval()\n",
        "  transformerModel.eval()\n",
        "  with torch.no_grad():\n",
        "    image = img.unsqueeze(0).to(device)\n",
        "    # display image\n",
        "    plt.imshow(denorm(image.squeeze(0)))\n",
        "    dec_inp = torch.ones(maxlen, dtype=torch.long).to(device)\n",
        "\n",
        "    trgt = global_vocab.stoi['<sos>']\n",
        "    dec_inp[0] = trgt\n",
        "    \n",
        "    # image features\n",
        "    img_feats = imgEncoder(image)\n",
        "    for i in range(1, maxlen):\n",
        "      pred = transformerModel(inp=img_feats,\n",
        "                              target=dec_inp[:i].unsqueeze(0))\n",
        "      # picking the last word of the sequence generated\n",
        "      pred =(pred.argmax(dim=-1))[:, -1]\n",
        "      # generate word till the last <eos> word is generated\n",
        "      if pred.item()==global_vocab.stoi['<eos>']: break\n",
        "      dec_inp[i] = pred.item()\n",
        "\n",
        "    caption = \" \".join([global_vocab.itos[id] for id in dec_inp])\n",
        "  return caption"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "name": "version02_2.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU",
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "920b6e3de6454b31a426c96b77b6e640": {
          "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_bde4bd0f66644888842e8ca502ab0aa4",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_54ff25b4750b4431941e32e5fcb22002",
              "IPY_MODEL_7c432c7891c14def9479c03bee8570f8"
            ]
          }
        },
        "bde4bd0f66644888842e8ca502ab0aa4": {
          "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
          }
        },
        "54ff25b4750b4431941e32e5fcb22002": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "IntProgressModel",
          "state": {
            "_view_name": "ProgressView",
            "style": "IPY_MODEL_a3f2c007ba4c4e11b362541e4d3d6536",
            "_dom_classes": [],
            "description": " 12%",
            "_model_name": "IntProgressModel",
            "bar_style": "danger",
            "max": 8,
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": 1,
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "orientation": "horizontal",
            "min": 0,
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_c0805fc9479f4421bdb640ffc7cb15b6"
          }
        },
        "7c432c7891c14def9479c03bee8570f8": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_9fc74803d0ea44fea4d68a385efaf08e",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": " 1/8 [1:20:40&lt;9:20:04, 4800.71s/it]",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_b1e689347afd4ddb8a8940a3cd948fb8"
          }
        },
        "a3f2c007ba4c4e11b362541e4d3d6536": {
          "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"
          }
        },
        "c0805fc9479f4421bdb640ffc7cb15b6": {
          "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
          }
        },
        "9fc74803d0ea44fea4d68a385efaf08e": {
          "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"
          }
        },
        "b1e689347afd4ddb8a8940a3cd948fb8": {
          "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
          }
        },
        "7a0b9f1173af40e88855abb376b0c339": {
          "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_71a27495803847bb851ec08182ff5da5",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_b0fd5b7e506544229f20fce9ad00fb0b",
              "IPY_MODEL_9b7e5c3e39994fc4968865d908e6d836"
            ]
          }
        },
        "71a27495803847bb851ec08182ff5da5": {
          "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
          }
        },
        "b0fd5b7e506544229f20fce9ad00fb0b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "IntProgressModel",
          "state": {
            "_view_name": "ProgressView",
            "style": "IPY_MODEL_6741f7b3f3cc491fb4f10496fda4f250",
            "_dom_classes": [],
            "description": "Training...: 100%",
            "_model_name": "IntProgressModel",
            "bar_style": "",
            "max": 2937,
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": 2937,
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "orientation": "horizontal",
            "min": 0,
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_8e6b8415121d42fe912c1e7bfbf1b2f9"
          }
        },
        "9b7e5c3e39994fc4968865d908e6d836": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_b9c5910ac68a48da9f2e6bce773c5a61",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": " 2937/2937 [1:08:57&lt;00:00,  1.31s/it]",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_246838ffac3a4a3cb3fba5ec80345c64"
          }
        },
        "6741f7b3f3cc491fb4f10496fda4f250": {
          "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"
          }
        },
        "8e6b8415121d42fe912c1e7bfbf1b2f9": {
          "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
          }
        },
        "b9c5910ac68a48da9f2e6bce773c5a61": {
          "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"
          }
        },
        "246838ffac3a4a3cb3fba5ec80345c64": {
          "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
          }
        },
        "326898d252d34ba8a9e8c39ff798dcd0": {
          "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_9df6e080eee548a1a5a960f8ef84e325",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_e72fb15389584131b98b10df9768cd4c",
              "IPY_MODEL_469f9c7ac33248e2add0d120aa339084"
            ]
          }
        },
        "9df6e080eee548a1a5a960f8ef84e325": {
          "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
          }
        },
        "e72fb15389584131b98b10df9768cd4c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "IntProgressModel",
          "state": {
            "_view_name": "ProgressView",
            "style": "IPY_MODEL_799e623b783841f0a16643016848b77f",
            "_dom_classes": [],
            "description": "Validation...: 100%",
            "_model_name": "IntProgressModel",
            "bar_style": "",
            "max": 1002,
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": 1002,
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "orientation": "horizontal",
            "min": 0,
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_4e4d1a26668c424d908b7d4324f9f0ec"
          }
        },
        "469f9c7ac33248e2add0d120aa339084": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_55120930181c4be29b88eb00e3c1fd91",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": " 1002/1002 [11:02&lt;00:00,  1.42it/s]",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_a03fc5393ea244b39a7830b954235ac3"
          }
        },
        "799e623b783841f0a16643016848b77f": {
          "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"
          }
        },
        "4e4d1a26668c424d908b7d4324f9f0ec": {
          "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
          }
        },
        "55120930181c4be29b88eb00e3c1fd91": {
          "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"
          }
        },
        "a03fc5393ea244b39a7830b954235ac3": {
          "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
          }
        },
        "416acc525e1d4ca5b9e2034cdf394fb2": {
          "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_d3ee24c792344552bab576bcda88f327",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_4af1b548e89b458994c8bf69053f6f07",
              "IPY_MODEL_1c865959a5574cd1ad0bc322f62f9c4f"
            ]
          }
        },
        "d3ee24c792344552bab576bcda88f327": {
          "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
          }
        },
        "4af1b548e89b458994c8bf69053f6f07": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "IntProgressModel",
          "state": {
            "_view_name": "ProgressView",
            "style": "IPY_MODEL_d13dc1016e5e444f867c46ec92a526ec",
            "_dom_classes": [],
            "description": "Training...:   1%",
            "_model_name": "IntProgressModel",
            "bar_style": "danger",
            "max": 2937,
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": 24,
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "orientation": "horizontal",
            "min": 0,
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_6b3d83db8f554e06bc5befb9aeb71da9"
          }
        },
        "1c865959a5574cd1ad0bc322f62f9c4f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_b42c396236cf49be95d2ad675b9272a9",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": " 24/2937 [00:33&lt;1:09:04,  1.42s/it]",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_891112437f0c47088115b99e10376583"
          }
        },
        "d13dc1016e5e444f867c46ec92a526ec": {
          "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"
          }
        },
        "6b3d83db8f554e06bc5befb9aeb71da9": {
          "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
          }
        },
        "b42c396236cf49be95d2ad675b9272a9": {
          "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"
          }
        },
        "891112437f0c47088115b99e10376583": {
          "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
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}