BE1_Image_Captioning (2).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XEabPxztBtkt"
      },
      "source": [
        "<h1>MSO 3.4 - Apprentissage automatique</h1>\n",
        "\n",
        "<h2>BE1 - Image captioning</h2>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IwaxMBtOMSPr",
        "outputId": "f9045064-eea0-4f41-b0aa-44e7642acbab"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "id": "R4aHBZFH1zD5",
        "outputId": "831bd0a4-b755-4e9c-a35f-328f87b695ba"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/MyDrive/GGColab/BE1_Image_Captionning\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'/content/drive/MyDrive/GGColab/BE1_Image_Captionning'"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "%cd /content/drive/MyDrive/GGColab/BE1_Image_Captionning/\n",
        "%pwd"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3dHl_WNNVrcI"
      },
      "outputs": [],
      "source": [
        "###################################\n",
        "# Content of utils.py\n",
        "###################################\n",
        "\n",
        "import os\n",
        "import numpy as np\n",
        "import h5py\n",
        "import json\n",
        "import torch\n",
        "from imageio import imread\n",
        "from PIL import Image\n",
        "from tqdm import tqdm\n",
        "from collections import Counter\n",
        "from random import seed, choice, sample\n",
        "\n",
        "\n",
        "def create_input_files(dataset, karpathy_json_path, image_folder, captions_per_image, min_word_freq, output_folder,\n",
        "                       max_len=100):\n",
        "    \"\"\"\n",
        "    Creates input files for training, validation, and test data.\n",
        "\n",
        "    :param dataset: name of dataset, one of 'coco', 'flickr8k', 'flickr30k'\n",
        "    :param karpathy_json_path: path of Karpathy JSON file with splits and captions\n",
        "    :param image_folder: \n",
        "    folder with downloaded images\n",
        "    :param captions_per_image: number of captions to sample per image\n",
        "    :param min_word_freq: words occuring less frequently than this threshold are binned as <unk>s\n",
        "    :param output_folder: folder to save files\n",
        "    :param max_len: don't sample captions longer than this length\n",
        "    \"\"\"\n",
        "\n",
        "    assert dataset in {'coco', 'flickr8k', 'flickr30k'}\n",
        "\n",
        "    # Read Karpathy JSON\n",
        "    with open(karpathy_json_path, 'r') as j:\n",
        "        data = json.load(j)\n",
        "\n",
        "    # Read image paths and captions for each image\n",
        "    train_image_paths = []\n",
        "    train_image_captions = []\n",
        "    val_image_paths = []\n",
        "    val_image_captions = []\n",
        "    test_image_paths = []\n",
        "    test_image_captions = []\n",
        "    word_freq = Counter()\n",
        "\n",
        "    for img in data['images']:\n",
        "        captions = []\n",
        "        for c in img['sentences']:\n",
        "            # Update word frequency\n",
        "            word_freq.update(c['tokens'])\n",
        "            if len(c['tokens']) <= max_len:\n",
        "                captions.append(c['tokens'])\n",
        "\n",
        "        if len(captions) == 0:\n",
        "            continue\n",
        "\n",
        "        path = os.path.join(image_folder, img['filepath'], img['filename']) if dataset == 'coco' else os.path.join(\n",
        "            image_folder, img['filename'])\n",
        "\n",
        "        if img['split'] in {'train', 'restval'}:\n",
        "            train_image_paths.append(path)\n",
        "            train_image_captions.append(captions)\n",
        "        elif img['split'] in {'val'}:\n",
        "            val_image_paths.append(path)\n",
        "            val_image_captions.append(captions)\n",
        "        elif img['split'] in {'test'}:\n",
        "            test_image_paths.append(path)\n",
        "            test_image_captions.append(captions)\n",
        "\n",
        "    # Sanity check\n",
        "    assert len(train_image_paths) == len(train_image_captions)\n",
        "    assert len(val_image_paths) == len(val_image_captions)\n",
        "    assert len(test_image_paths) == len(test_image_captions)\n",
        "\n",
        "    # Create word map\n",
        "    words = [w for w in word_freq.keys() if word_freq[w] > min_word_freq]\n",
        "    word_map = {k: v + 1 for v, k in enumerate(words)}\n",
        "    word_map['<unk>'] = len(word_map) + 1\n",
        "    word_map['<start>'] = len(word_map) + 1\n",
        "    word_map['<end>'] = len(word_map) + 1\n",
        "    word_map['<pad>'] = 0\n",
        "\n",
        "    # Create a base/root name for all output files\n",
        "    base_filename = dataset + '_' + str(captions_per_image) + '_cap_per_img_' + str(min_word_freq) + '_min_word_freq'\n",
        "\n",
        "    if not os.path.exists(output_folder):\n",
        "        os.makedirs(output_folder)\n",
        "\n",
        "    # Save word map to a JSON\n",
        "    with open(os.path.join(output_folder, 'WORDMAP_' + base_filename + '.json'), 'w') as j:\n",
        "        json.dump(word_map, j)\n",
        "\n",
        "    # Sample captions for each image, save images to HDF5 file, and captions and their lengths to JSON files\n",
        "    seed(123)\n",
        "    for impaths, imcaps, split in [(train_image_paths, train_image_captions, 'TRAIN'),\n",
        "                                   (val_image_paths, val_image_captions, 'VAL'),\n",
        "                                   (test_image_paths, test_image_captions, 'TEST')]:\n",
        "\n",
        "        with h5py.File(os.path.join(output_folder, split + '_IMAGES_' + base_filename + '.hdf5'), 'a') as h:\n",
        "            # Make a note of the number of captions we are sampling per image\n",
        "            h.attrs['captions_per_image'] = captions_per_image\n",
        "\n",
        "            # Create dataset inside HDF5 file to store images\n",
        "            images = h.create_dataset('images', (len(impaths), 3, 256, 256), dtype='uint8')\n",
        "\n",
        "            print(\"\\nReading %s images and captions, storing to file...\\n\" % split)\n",
        "\n",
        "            enc_captions = []\n",
        "            caplens = []\n",
        "\n",
        "            for i, path in enumerate(tqdm(impaths)):\n",
        "\n",
        "                # Sample captions\n",
        "                if len(imcaps[i]) < captions_per_image:\n",
        "                    captions = imcaps[i] + [choice(imcaps[i]) for _ in range(captions_per_image - len(imcaps[i]))]\n",
        "                else:\n",
        "                    captions = sample(imcaps[i], k=captions_per_image)\n",
        "\n",
        "                # Sanity check\n",
        "                assert len(captions) == captions_per_image\n",
        "\n",
        "                # Read images\n",
        "                img = imread(impaths[i])\n",
        "                if len(img.shape) == 2:\n",
        "                    img = img[:, :, np.newaxis]\n",
        "                    img = np.concatenate([img, img, img], axis=2)\n",
        "                #img = imresize(img, (256, 256))                \n",
        "                img = np.array(Image.fromarray(img).resize((256, 256)))\n",
        "                img = img.transpose(2, 0, 1)\n",
        "                assert img.shape == (3, 256, 256)\n",
        "                assert np.max(img) <= 255\n",
        "\n",
        "                # Save image to HDF5 file\n",
        "                images[i] = img\n",
        "\n",
        "                for j, c in enumerate(captions):\n",
        "                    # Encode captions\n",
        "                    enc_c = [word_map['<start>']] + [word_map.get(word, word_map['<unk>']) for word in c] + [\n",
        "                        word_map['<end>']] + [word_map['<pad>']] * (max_len - len(c))\n",
        "\n",
        "                    # Find caption lengths\n",
        "                    c_len = len(c) + 2\n",
        "\n",
        "                    enc_captions.append(enc_c)\n",
        "                    caplens.append(c_len)\n",
        "\n",
        "            # Sanity check\n",
        "            assert images.shape[0] * captions_per_image == len(enc_captions) == len(caplens)\n",
        "\n",
        "            # Save encoded captions and their lengths to JSON files\n",
        "            with open(os.path.join(output_folder, split + '_CAPTIONS_' + base_filename + '.json'), 'w') as j:\n",
        "                json.dump(enc_captions, j)\n",
        "\n",
        "            with open(os.path.join(output_folder, split + '_CAPLENS_' + base_filename + '.json'), 'w') as j:\n",
        "                json.dump(caplens, j)\n",
        "\n",
        "\n",
        "def init_embedding(embeddings):\n",
        "    \"\"\"\n",
        "    Fills embedding tensor with values from the uniform distribution.\n",
        "\n",
        "    :param embeddings: embedding tensor\n",
        "    \"\"\"\n",
        "    bias = np.sqrt(3.0 / embeddings.size(1))\n",
        "    torch.nn.init.uniform_(embeddings, -bias, bias)\n",
        "\n",
        "\n",
        "def load_embeddings(emb_file, word_map):\n",
        "    \"\"\"\n",
        "    Creates an embedding tensor for the specified word map, for loading into the model.\n",
        "\n",
        "    :param emb_file: file containing embeddings (stored in GloVe format)\n",
        "    :param word_map: word map\n",
        "    :return: embeddings in the same order as the words in the word map, dimension of embeddings\n",
        "    \"\"\"\n",
        "\n",
        "    # Find embedding dimension\n",
        "    with open(emb_file, 'r') as f:\n",
        "        emb_dim = len(f.readline().split(' ')) - 1\n",
        "\n",
        "    vocab = set(word_map.keys())\n",
        "\n",
        "    # Create tensor to hold embeddings, initialize\n",
        "    embeddings = torch.FloatTensor(len(vocab), emb_dim)\n",
        "    init_embedding(embeddings)\n",
        "\n",
        "    # Read embedding file\n",
        "    print(\"\\nLoading embeddings...\")\n",
        "    for line in open(emb_file, 'r'):\n",
        "        line = line.split(' ')\n",
        "\n",
        "        emb_word = line[0]\n",
        "        embedding = list(map(lambda t: float(t), filter(lambda n: n and not n.isspace(), line[1:])))\n",
        "\n",
        "        # Ignore word if not in train_vocab\n",
        "        if emb_word not in vocab:\n",
        "            continue\n",
        "\n",
        "        embeddings[word_map[emb_word]] = torch.FloatTensor(embedding)\n",
        "\n",
        "    return embeddings, emb_dim\n",
        "\n",
        "\n",
        "def clip_gradient(optimizer, grad_clip):\n",
        "    \"\"\"\n",
        "    Clips gradients computed during backpropagation to avoid explosion of gradients.\n",
        "\n",
        "    :param optimizer: optimizer with the gradients to be clipped\n",
        "    :param grad_clip: clip value\n",
        "    \"\"\"\n",
        "    for group in optimizer.param_groups:\n",
        "        for param in group['params']:\n",
        "            if param.grad is not None:\n",
        "                param.grad.data.clamp_(-grad_clip, grad_clip)\n",
        "\n",
        "\n",
        "def save_checkpoint(data_name, cnn_rnn_structure, epoch, epochs_since_improvement, encoder, decoder, encoder_optimizer, decoder_optimizer,\n",
        "                    bleu4, is_best):\n",
        "    \"\"\"\n",
        "    Saves model checkpoint.\n",
        "\n",
        "    :param data_name: base name of processed dataset\n",
        "    :param epoch: epoch number\n",
        "    :param epochs_since_improvement: number of epochs since last improvement in BLEU-4 score\n",
        "    :param encoder: encoder model\n",
        "    :param decoder: decoder model\n",
        "    :param encoder_optimizer: optimizer to update encoder's weights, if fine-tuning\n",
        "    :param decoder_optimizer: optimizer to update decoder's weights\n",
        "    :param bleu4: validation BLEU-4 score for this epoch\n",
        "    :param is_best: is this checkpoint the best so far?\n",
        "    \"\"\"\n",
        "    state = {'epoch': epoch,\n",
        "             'epochs_since_improvement': epochs_since_improvement,\n",
        "             'bleu-4': bleu4,\n",
        "             'encoder': encoder,\n",
        "             'decoder': decoder,\n",
        "             'encoder_optimizer': encoder_optimizer,\n",
        "             'decoder_optimizer': decoder_optimizer}\n",
        "    filename = cnn_rnn_structure[0] + \"_\" + cnn_rnn_structure[1] + \"_\" + str(cnn_rnn_structure[2]) + '_checkpoint_' + data_name + '.pth.tar'\n",
        "    torch.save(state, filename)\n",
        "    # If this checkpoint is the best so far, store a copy so it doesn't get overwritten by a worse checkpoint\n",
        "    if is_best:\n",
        "        torch.save(state, 'BEST_' + filename)  # rajouter le type de model\n",
        "\n",
        "\n",
        "class AverageMeter(object):\n",
        "    \"\"\"\n",
        "    Keeps track of most recent, average, sum, and count of a metric.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self):\n",
        "        self.reset()\n",
        "\n",
        "    def reset(self):\n",
        "        self.val = 0\n",
        "        self.avg = 0\n",
        "        self.sum = 0\n",
        "        self.count = 0\n",
        "\n",
        "    def update(self, val, n=1):\n",
        "        self.val = val\n",
        "        self.sum += val * n\n",
        "        self.count += n\n",
        "        self.avg = self.sum / self.count\n",
        "\n",
        "\n",
        "def adjust_learning_rate(optimizer, shrink_factor):\n",
        "    \"\"\"\n",
        "    Shrinks learning rate by a specified factor.\n",
        "\n",
        "    :param optimizer: optimizer whose learning rate must be shrunk.\n",
        "    :param shrink_factor: factor in interval (0, 1) to multiply learning rate with.\n",
        "    \"\"\"\n",
        "\n",
        "    print(\"\\nDECAYING learning rate.\")\n",
        "    for param_group in optimizer.param_groups:\n",
        "        param_group['lr'] = param_group['lr'] * shrink_factor\n",
        "    print(\"The new learning rate is %f\\n\" % (optimizer.param_groups[0]['lr'],))\n",
        "\n",
        "\n",
        "def accuracy(scores, targets, k):\n",
        "    \"\"\"\n",
        "    Computes top-k accuracy, from predicted and true labels.\n",
        "\n",
        "    :param scores: scores from the model\n",
        "    :param targets: true labels\n",
        "    :param k: k in top-k accuracy\n",
        "    :return: top-k accuracy\n",
        "    \"\"\"\n",
        "\n",
        "    batch_size = targets.size(0)\n",
        "    _, ind = scores.topk(k, 1, True, True)\n",
        "    correct = ind.eq(targets.view(-1, 1).expand_as(ind))\n",
        "    correct_total = correct.view(-1).float().sum()  # 0D tensor\n",
        "    return correct_total.item() * (100.0 / batch_size)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 396
        },
        "id": "XBpw2me6VdjZ",
        "outputId": "1ab3a8b6-e630-49b2-c9e5-f091684c48ae"
      },
      "outputs": [
        {
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-4-e3379c4e2584>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     53\u001b[0m         \u001b[0mdownload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_Dataset.zip\"\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     54\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mzipfile\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mZipFile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Flickr8k_Dataset.zip\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'r'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mzip_ref\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m         \u001b[0mzip_ref\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextractall\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[0m\u001b[1;32m     56\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     57\u001b[0m     \u001b[0;31m# Create input files (along with word map)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/zipfile.py\u001b[0m in \u001b[0;36mextractall\u001b[0;34m(self, path, members, pwd)\u001b[0m\n\u001b[1;32m   1634\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1635\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mzipinfo\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmembers\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1636\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_extract_member\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzipinfo\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpath\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpwd\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   1637\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1638\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mclassmethod\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/zipfile.py\u001b[0m in \u001b[0;36m_extract_member\u001b[0;34m(self, member, targetpath, pwd)\u001b[0m\n\u001b[1;32m   1688\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1689\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmember\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpwd\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpwd\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0msource\u001b[0m\u001b[0;34m,\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-> 1690\u001b[0;31m              \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtargetpath\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"wb\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mtarget\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   1691\u001b[0m             \u001b[0mshutil\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopyfileobj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msource\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1692\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "###################################\n",
        "# Content of create_input_files.py\n",
        "###################################\n",
        "\n",
        "import urllib.request\n",
        "from tqdm import tqdm\n",
        "import os\n",
        "import zipfile\n",
        "\n",
        "def download_hook(t):\n",
        "    \"\"\"Wraps tqdm instance.\n",
        "    Don't forget to close() or __exit__()\n",
        "    the tqdm instance once you're done with it (easiest using `with` syntax).\n",
        "    Example\n",
        "    -------\n",
        "    >>> with tqdm(...) as t:\n",
        "    ...     reporthook = my_hook(t)\n",
        "    ...     urllib.request.urlretrieve(..., reporthook=reporthook)\n",
        "    \"\"\"\n",
        "    last_b = [0]\n",
        "\n",
        "    def update_to(b=1, bsize=1, tsize=None):\n",
        "        \"\"\"\n",
        "        b  : int, optional\n",
        "            Number of blocks transferred so far [default: 1].\n",
        "        bsize  : int, optional\n",
        "            Size of each block (in tqdm units) [default: 1].\n",
        "        tsize  : int, optional\n",
        "            Total size (in tqdm units). If [default: None] remains unchanged.\n",
        "        \"\"\"\n",
        "        if tsize is not None:\n",
        "            t.total = tsize\n",
        "        t.update((b - last_b[0]) * bsize)\n",
        "        last_b[0] = b\n",
        "\n",
        "    return update_to\n",
        "\n",
        "def download(url, save_dir):\n",
        "    filename = url.split('/')[-1]\n",
        "    with tqdm(unit = 'B', unit_scale = True, unit_divisor = 1024, miniters = 1, desc = filename) as t:\n",
        "        urllib.request.urlretrieve(url, filename = os.path.join(save_dir, filename), reporthook = download_hook(t), data = None)\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    # Download ground truth\n",
        "    if not os.path.exists(\"caption_datasets.zip\"):\n",
        "        download(\"http://cs.stanford.edu/people/karpathy/deepimagesent/caption_datasets.zip\", \"./\")\n",
        "    # Extract in the correct folder\n",
        "    with zipfile.ZipFile(\"caption_datasets.zip\", 'r') as zip_ref:\n",
        "        zip_ref.extractall(\"./captions\")\n",
        "\n",
        "    # Download and extract dataset images\n",
        "    if not os.path.exists(\"Flickr8k_Dataset.zip\"):\n",
        "        download(\"https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_Dataset.zip\", \"./\")\n",
        "    with zipfile.ZipFile(\"Flickr8k_Dataset.zip\", 'r') as zip_ref:\n",
        "        zip_ref.extractall(\"./\")\n",
        "\n",
        "    # Create input files (along with word map)\n",
        "    create_input_files(dataset='flickr8k',\n",
        "                       karpathy_json_path='captions/dataset_flickr8k.json',\n",
        "                       image_folder='Flicker8k_Dataset/',\n",
        "                       captions_per_image=5,\n",
        "                       min_word_freq=5,\n",
        "                       output_folder='prepared_data/',\n",
        "                       max_len=50)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ODeWijBbVu2M"
      },
      "outputs": [],
      "source": [
        "###################################\n",
        "# Content of datasets.py\n",
        "###################################\n",
        "\n",
        "import torch\n",
        "from torch.utils.data import Dataset\n",
        "import h5py\n",
        "import json\n",
        "import os\n",
        "\n",
        "\n",
        "class CaptionDataset(Dataset):\n",
        "    \"\"\"\n",
        "    A PyTorch Dataset class to be used in a PyTorch DataLoader to create batches.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, data_folder, data_name, split, transform=None):\n",
        "        \"\"\"\n",
        "        :param data_folder: folder where data files are stored\n",
        "        :param data_name: base name of processed datasets\n",
        "        :param split: split, one of 'TRAIN', 'VAL', or 'TEST'\n",
        "        :param transform: image transform pipeline\n",
        "        \"\"\"\n",
        "        self.split = split\n",
        "        assert self.split in {'TRAIN', 'VAL', 'TEST'}\n",
        "\n",
        "        # Open hdf5 file where images are stored\n",
        "        self.h = h5py.File(os.path.join(data_folder, self.split + '_IMAGES_' + data_name + '.hdf5'), 'r')\n",
        "        self.imgs = self.h['images']\n",
        "\n",
        "        # Captions per image\n",
        "        self.cpi = self.h.attrs['captions_per_image']\n",
        "\n",
        "        # Load encoded captions (completely into memory)\n",
        "        with open(os.path.join(data_folder, self.split + '_CAPTIONS_' + data_name + '.json'), 'r') as j:\n",
        "            self.captions = json.load(j)\n",
        "\n",
        "        # Load caption lengths (completely into memory)\n",
        "        with open(os.path.join(data_folder, self.split + '_CAPLENS_' + data_name + '.json'), 'r') as j:\n",
        "            self.caplens = json.load(j)\n",
        "\n",
        "        # PyTorch transformation pipeline for the image (normalizing, etc.)\n",
        "        self.transform = transform\n",
        "\n",
        "        # Total number of datapoints\n",
        "        self.dataset_size = len(self.captions)\n",
        "\n",
        "    def __getitem__(self, i):\n",
        "        # Remember, the Nth caption corresponds to the (N // captions_per_image)th image\n",
        "        img = torch.FloatTensor(self.imgs[i // self.cpi] / 255.)\n",
        "        if self.transform is not None:\n",
        "            img = self.transform(img)\n",
        "\n",
        "        caption = torch.LongTensor(self.captions[i])\n",
        "\n",
        "        caplen = torch.LongTensor([self.caplens[i]])\n",
        "\n",
        "        if self.split is 'TRAIN':\n",
        "            return img, caption, caplen\n",
        "        else:\n",
        "            # For validation of testing, also return all 'captions_per_image' captions to find BLEU-4 score\n",
        "            all_captions = torch.LongTensor(\n",
        "                self.captions[((i // self.cpi) * self.cpi):(((i // self.cpi) * self.cpi) + self.cpi)])\n",
        "            return img, caption, caplen, all_captions\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.dataset_size\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "72fxHjvrWBT_"
      },
      "outputs": [],
      "source": [
        "###################################\n",
        "# Content of models.py\n",
        "###################################\n",
        "\n",
        "import torch\n",
        "from torch import nn\n",
        "import torchvision\n",
        "import random\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "\n",
        "class Encoder(nn.Module):\n",
        "    \"\"\"\n",
        "    Encoder.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, encoded_image_size=14, cnn='resnet'):\n",
        "        super(Encoder, self).__init__()\n",
        "        self.enc_image_size = encoded_image_size\n",
        "        if cnn=='resnet':\n",
        "          transfer_model = torchvision.models.resnet101(pretrained=True)  # pretrained ImageNet ResNet-101\n",
        "        elif cnn=='vgg':\n",
        "          transfer_model = torchvision.models.vgg19(pretrained=True) # pretrained ImageNetVGG19\n",
        "        else:\n",
        "          return(\"Enter a supported CNN architecture\")\n",
        "        # Remove linear and pool layers (since we're not doing classification)\n",
        "        modules = list(transfer_model.children())[:-2]\n",
        "        self.cnn = nn.Sequential(*modules)  # Resnet or VGG model\n",
        "        # Resize image to fixed size to allow input images of variable size\n",
        "        self.adaptive_pool = nn.AdaptiveAvgPool2d((encoded_image_size, encoded_image_size))\n",
        "\n",
        "        self.fine_tune()\n",
        "\n",
        "    def forward(self, images):\n",
        "        \"\"\"\n",
        "        Forward propagation.\n",
        "\n",
        "        :param images: images, a tensor of dimensions (batch_size, 3, image_size, image_size)\n",
        "        :return: encoded images\n",
        "        \"\"\"\n",
        "        out = self.cnn(images)  # (batch_size, 2048, image_size/32, image_size/32)\n",
        "        out = self.adaptive_pool(out)  # (batch_size, 2048, encoded_image_size, encoded_image_size)\n",
        "        out = out.permute(0, 2, 3, 1)  # (batch_size, encoded_image_size, encoded_image_size, 2048)\n",
        "        return out\n",
        "\n",
        "    def fine_tune(self, fine_tune=True):\n",
        "        \"\"\"\n",
        "        Allow or prevent the computation of gradients for convolutional blocks 2 through 4 of the encoder.\n",
        "\n",
        "        :param fine_tune: Allow?\n",
        "        \"\"\"\n",
        "        for p in self.cnn.parameters():\n",
        "            p.requires_grad = False\n",
        "        # If fine-tuning, only fine-tune convolutional blocks 2 through 4  # WHY ?\n",
        "        for c in list(self.cnn.children())[5:]:\n",
        "            for p in c.parameters():\n",
        "                p.requires_grad = fine_tune\n",
        "\n",
        "\n",
        "class Attention(nn.Module):\n",
        "    \"\"\"\n",
        "    Attention Network.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, encoder_dim, decoder_dim, attention_dim):\n",
        "        \"\"\"\n",
        "        :param encoder_dim: feature size of encoded images\n",
        "        :param decoder_dim: size of decoder's RNN\n",
        "        :param attention_dim: size of the attention network\n",
        "        \"\"\"\n",
        "        super(Attention, self).__init__()\n",
        "        self.encoder_att = nn.Linear(encoder_dim, attention_dim)  # linear layer to transform encoded image\n",
        "        self.decoder_att = nn.Linear(decoder_dim, attention_dim)  # linear layer to transform decoder's output\n",
        "        self.full_att = nn.Linear(attention_dim, 1)  # linear layer to calculate values to be softmax-ed\n",
        "        self.relu = nn.ReLU()\n",
        "        self.softmax = nn.Softmax(dim=1)  # softmax layer to calculate weights\n",
        "\n",
        "    def forward(self, encoder_out, decoder_hidden):\n",
        "        \"\"\"\n",
        "        Forward propagation.\n",
        "\n",
        "        :param encoder_out: encoded images, a tensor of dimension (batch_size, num_pixels, encoder_dim)\n",
        "        :param decoder_hidden: previous decoder output, a tensor of dimension (batch_size, decoder_dim)\n",
        "        :return: attention weighted encoding, weights\n",
        "        \"\"\"\n",
        "        att1 = self.encoder_att(encoder_out)  # (batch_size, num_pixels, attention_dim)\n",
        "        att2 = self.decoder_att(decoder_hidden)  # (batch_size, attention_dim)\n",
        "        att = self.full_att(self.relu(att1 + att2.unsqueeze(1))).squeeze(2)  # (batch_size, num_pixels)\n",
        "        alpha = self.softmax(att)  # (batch_size, num_pixels)\n",
        "        attention_weighted_encoding = (encoder_out * alpha.unsqueeze(2)).sum(dim=1)  # (batch_size, encoder_dim) (Understand : Within a channel of the encoded image, each pixel is weighted equally)\n",
        "\n",
        "        return attention_weighted_encoding, alpha\n",
        "\n",
        "\n",
        "class DecoderWithAttention(nn.Module):\n",
        "    \"\"\"\n",
        "    Decoder.\n",
        "    \"\"\"\n",
        "    def __init__(self, attention_dim, embed_dim, decoder_dim, vocab_size, encoder_dim=2048, dropout=0.5, cell_type='LSTM', scheduled_sampling=False):\n",
        "        \"\"\"\n",
        "        :param attention_dim: size of attention network\n",
        "        :param embed_dim: embedding size\n",
        "        :param decoder_dim: size of decoder's RNN\n",
        "        :param vocab_size: size of vocabulary\n",
        "        :param encoder_dim: feature size of encoded images\n",
        "        :param dropout: dropout\n",
        "        \"\"\"\n",
        "        super(DecoderWithAttention, self).__init__()\n",
        "\n",
        "        self.encoder_dim = encoder_dim\n",
        "        self.attention_dim = attention_dim\n",
        "        self.embed_dim = embed_dim\n",
        "        self.decoder_dim = decoder_dim\n",
        "        self.vocab_size = vocab_size\n",
        "        self.dropout = dropout\n",
        "        self.scheduled_sampling = scheduled_sampling\n",
        "\n",
        "        self.attention = Attention(encoder_dim, decoder_dim, attention_dim)  # attention network\n",
        "\n",
        "        self.embedding = nn.Embedding(vocab_size, embed_dim)  # embedding layer\n",
        "        self.dropout = nn.Dropout(p=self.dropout)\n",
        "        self.cell_type = cell_type\n",
        "        if cell_type=='LSTM':\n",
        "            self.decode_step = nn.LSTMCell(embed_dim + encoder_dim, decoder_dim, bias=True)  # decoding LSTMCell  #WHY decoder_dim while passing h AND c, which are both of decoder_dim size ? Peephole connection by default ?\n",
        "        elif cell_type=='GRU':\n",
        "            self.decode_step = nn.GRUCell(embed_dim + encoder_dim, decoder_dim, bias=True)  # decoding GRUCell\n",
        "        else:\n",
        "            return(\"Enter a supported RNN architecture\")\n",
        "        self.init_h = nn.Linear(encoder_dim, decoder_dim)  # linear layer to find initial hidden state of LSTMCell # Why not initialize to 0 or smthing predefined ?\n",
        "        self.init_c = nn.Linear(encoder_dim, decoder_dim)  # linear layer to find initial cell state of LSTMCell # Why not initialize to 0 or smthing predefined ?\n",
        "        self.f_beta = nn.Linear(decoder_dim, encoder_dim)  # linear layer to create a sigmoid-activated gate  #WHY ? Kind of update gate within the attention mechanism ? Isn't LSTM supposed to manage that ?\n",
        "        self.sigmoid = nn.Sigmoid()\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.fc = nn.Linear(decoder_dim, vocab_size)  # linear layer to find scores over vocabulary\n",
        "        self.init_weights()  # initialize some layers with the uniform distribution\n",
        "\n",
        "    def init_weights(self):\n",
        "        \"\"\"\n",
        "        Initializes some parameters with values from the uniform distribution, for easier convergence.\n",
        "        \"\"\"\n",
        "        self.embedding.weight.data.uniform_(-0.1, 0.1)\n",
        "        self.fc.bias.data.fill_(0)\n",
        "        self.fc.weight.data.uniform_(-0.1, 0.1)\n",
        "\n",
        "    def load_pretrained_embeddings(self, embeddings):\n",
        "        \"\"\"\n",
        "        Loads embedding layer with pre-trained embeddings.\n",
        "        :param embeddings: pre-trained embeddings\n",
        "        \"\"\"\n",
        "        self.embedding.weight = nn.Parameter(embeddings)\n",
        "\n",
        "    def fine_tune_embeddings(self, fine_tune=True):\n",
        "        \"\"\"\n",
        "        Allow fine-tuning of embedding layer? (Only makes sense to not-allow if using pre-trained embeddings).\n",
        "\n",
        "        :param fine_tune: Allow?\n",
        "        \"\"\"\n",
        "        for p in self.embedding.parameters():\n",
        "            p.requires_grad = fine_tune\n",
        "\n",
        "    def init_hidden_state(self, encoder_out):\n",
        "        \"\"\"\n",
        "        Creates the initial hidden and cell states for the decoder's LSTM based on the encoded images.\n",
        "\n",
        "        :param encoder_out: encoded images, a tensor of dimension (batch_size, num_pixels, encoder_dim)\n",
        "        :return: hidden state, cell state\n",
        "        \"\"\"\n",
        "        mean_encoder_out = encoder_out.mean(dim=1)\n",
        "        h = self.init_h(mean_encoder_out)  # (batch_size, decoder_dim)\n",
        "        c = self.init_c(mean_encoder_out)\n",
        "        return h, c\n",
        "\n",
        "    def forward(self, encoder_out, encoded_captions, caption_lengths, current_epoch= None, epochs_number=None):\n",
        "        \"\"\"\n",
        "        Forward propagation.\n",
        "\n",
        "        :param encoder_out: encoded images, a tensor of dimension (batch_size, enc_image_size, enc_image_size, encoder_dim)\n",
        "        :param encoded_captions: encoded captions, a tensor of dimension (batch_size, max_caption_length)\n",
        "        :param caption_lengths: caption lengths, a tensor of dimension (batch_size, 1)\n",
        "        :return: scores for vocabulary, sorted encoded captions, decode lengths, weights, sort indices\n",
        "        \"\"\"\n",
        "\n",
        "        batch_size = encoder_out.size(0)\n",
        "        encoder_dim = encoder_out.size(-1)\n",
        "        vocab_size = self.vocab_size\n",
        "        scheduled_sampling_param = 1\n",
        "        if self.scheduled_sampling and current_epoch is not None and epochs_number is not None:\n",
        "          scheduled_sampling_param = 1 - (current_epoch/epochs_number) # Parameter for scheduled sampling (if activated)\n",
        "        \n",
        "        # Flatten image\n",
        "        encoder_out = encoder_out.view(batch_size, -1, encoder_dim)  # (batch_size, num_pixels, encoder_dim)\n",
        "        num_pixels = encoder_out.size(1)\n",
        "\n",
        "        # Sort input data by decreasing lengths; why? apparent below\n",
        "        caption_lengths, sort_ind = caption_lengths.squeeze(1).sort(dim=0, descending=True)\n",
        "        encoder_out = encoder_out[sort_ind]\n",
        "        encoded_captions = encoded_captions[sort_ind]\n",
        "\n",
        "        # Embedding\n",
        "        embeddings = self.embedding(encoded_captions)  # (batch_size, max_caption_length, embed_dim)  # WHY No initialization w. a pre-trained embedding ?\n",
        "\n",
        "        # Initialize LSTM state (Or GRU)\n",
        "        h, c = self.init_hidden_state(encoder_out)  # (batch_size, decoder_dim)\n",
        "\n",
        "        # We won't decode at the <end> position, since we've finished generating as soon as we generate <end>\n",
        "        # So, decoding lengths are actual lengths - 1\n",
        "        decode_lengths = (caption_lengths - 1).tolist()\n",
        "\n",
        "        # Create tensors to hold word prediction scores and alphas\n",
        "        predictions = torch.zeros(batch_size, max(decode_lengths), vocab_size).to(device)\n",
        "        alphas = torch.zeros(batch_size, max(decode_lengths), num_pixels).to(device)\n",
        "\n",
        "        # At each time-step, decode by\n",
        "        # attention-weighting the encoder's output based on the decoder's previous hidden state output\n",
        "        # then generate a new word in the decoder with the previous word and the attention weighted encoding\n",
        "        for t in range(max(decode_lengths)):\n",
        "            batch_size_t = sum([l > t for l in decode_lengths])\n",
        "            attention_weighted_encoding, alpha = self.attention(encoder_out[:batch_size_t],\n",
        "                                                                h[:batch_size_t])\n",
        "            gate = self.sigmoid(self.f_beta(h[:batch_size_t]))  # gating scalar, (batch_size_t, encoder_dim)\n",
        "            attention_weighted_encoding = gate * attention_weighted_encoding  # WHY IS THERE A GATE ? Is it a variation of the classis attention mechanism (Kind of update gate ?)\n",
        "            \n",
        "            if self.scheduled_sampling and t>0 and random.random() > scheduled_sampling_param:\n",
        "                h, c = self.decode_step(torch.cat([previous_word_embedding[:batch_size_t, :], attention_weighted_encoding], dim=1),\n",
        "                    (h[:batch_size_t], c[:batch_size_t]))  # (batch_size_t, decoder_dim)\n",
        "            else:\n",
        "              if self.cell_type =='LSTM':\n",
        "                  h, c = self.decode_step(\n",
        "                      torch.cat([embeddings[:batch_size_t, t, :], attention_weighted_encoding], dim=1),\n",
        "                      (h[:batch_size_t], c[:batch_size_t]))  # (batch_size_t, decoder_dim)\n",
        "              else:\n",
        "                  h = self.decode_step(\n",
        "                      torch.cat([embeddings[:batch_size_t, t, :], attention_weighted_encoding], dim=1),\n",
        "                      h[:batch_size_t])  # (batch_size_t, decoder_dim)\n",
        "            preds = self.fc(self.dropout(h))  # (batch_size_t, vocab_size)\n",
        "            predictions[:batch_size_t, t, :] = preds\n",
        "            if self.scheduled_sampling:\n",
        "              scores = self.softmax(preds) # (batch_size_t, vocab_size) # We compute the score to choose the best word\n",
        "              words = torch.argmax(scores, dim=1).squeeze() # (batch_size_t,)\n",
        "              previous_word_embedding = self.embedding(words) # (batch_size_t, embed_dim)\n",
        "              alphas[:batch_size_t, t, :] = alpha\n",
        "\n",
        "        return predictions, encoded_captions, decode_lengths, alphas, sort_ind\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "  # Tentative infructueuse d'effectuer un toss vectorisé pour varier au sein d'une même step de batch\n",
        "  # toss = torch.rand(batch_size_t)\n",
        "  #  print(\"Toss computation :\", toss)\n",
        "  #  bool_col = toss > scheduled_sampling_param # If TRUE We take as input the sample from the previous prediction, else classic method, ground-truth values\n",
        "  #  print('Ratio de samples : ', int(sum(bool_col).unsqueeze/batch_size_t*100), \" %\")\n",
        "\n",
        "  #  h[:batch_size_t][bool_col], c[:batch_size_t][bool_col] = self.decode_step(torch.cat([embeddings[:batch_size_t, t, :][bool_col], attention_weighted_encoding[bool_col]], dim=1),\n",
        "  # (h[:batch_size_t][bool_col], c[:batch_size_t][bool_col]))  # (batch_size_t, decoder_dim)\n",
        "\n",
        "  #h[:batch_size_t][~bool_col], c[:batch_size_t][~bool_col] = self.decode_step(torch.cat([embeddings[:batch_size_t, t, :][~bool_col], attention_weighted_encoding[~bool_col]], dim=1),\n",
        "  # (h[:batch_size_t][~bool_col], c[:batch_size_t][~bool_col]))  # (batch_size_t, decoder_dim)\n",
        "    \n",
        "    # h, c = h[:batch_size_t], c[:batch_size_t]\n",
        "  # RuntimeError: CUDA error: invalid configuration argument\n",
        "  # CUDA kernel errors might be asynchronously reported at some other API call,so the stacktrace below might be incorrect.\n",
        "  # For debugging consider passing CUDA_LAUNCH_BLOCKING=1"
      ],
      "metadata": {
        "id": "7hNCcYx938wN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000,
          "referenced_widgets": [
            "bedae02060dc4630873c027ac613647a",
            "09de16e8cf264ad7a8ab1624694cbd4e",
            "b0a0f54fbaa547008042688df45c7a16",
            "e885959fb3184173817f272e40767fbc",
            "847e79bcb8264a79855be0ba061767a4",
            "bce47f9cab4f47a195a150a19f1a569e",
            "acd84c650f314498ae3071c80c3dbdcb",
            "ef32eaa2f4b1490488444d0a8a741375",
            "c802e73a01d34b60bf80e365e7dd3862",
            "6af21699a3434258b268c62698fc044d",
            "4d0cc1d1fce04db2ba176849f722cc4c"
          ]
        },
        "id": "6xMxbTjCWOez",
        "outputId": "4f9a7e0d-757f-4880-e8f8-c5b0bb25d9b0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "We are training a model with resnet as a CNN-encoder architecture and LSTM as the RNN-encoder architecture\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading: \"https://download.pytorch.org/models/resnet101-63fe2227.pth\" to /root/.cache/torch/hub/checkpoints/resnet101-63fe2227.pth\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "bedae02060dc4630873c027ac613647a",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "  0%|          | 0.00/171M [00:00<?, ?B/s]"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: [0][0/938]\tBatch Time 6.376 (6.376)\tData Load Time 4.951 (4.951)\tLoss 8.9352 (8.9352)\tTop-5 Accuracy 0.000 (0.000)\n",
            "Epoch: [0][100/938]\tBatch Time 0.393 (0.480)\tData Load Time 0.060 (0.139)\tLoss 5.6716 (6.2529)\tTop-5 Accuracy 42.340 (35.240)\n",
            "Epoch: [0][200/938]\tBatch Time 0.383 (0.432)\tData Load Time 0.050 (0.096)\tLoss 5.3016 (5.8859)\tTop-5 Accuracy 46.719 (39.731)\n",
            "Epoch: [0][300/938]\tBatch Time 0.396 (0.417)\tData Load Time 0.049 (0.080)\tLoss 5.0424 (5.6303)\tTop-5 Accuracy 52.261 (43.415)\n",
            "Epoch: [0][400/938]\tBatch Time 0.401 (0.410)\tData Load Time 0.046 (0.072)\tLoss 4.6049 (5.4495)\tTop-5 Accuracy 56.220 (45.989)\n",
            "Epoch: [0][500/938]\tBatch Time 0.405 (0.407)\tData Load Time 0.046 (0.067)\tLoss 4.5064 (5.3176)\tTop-5 Accuracy 57.108 (47.832)\n",
            "Epoch: [0][600/938]\tBatch Time 0.380 (0.405)\tData Load Time 0.046 (0.064)\tLoss 4.7570 (5.2105)\tTop-5 Accuracy 56.395 (49.342)\n",
            "Epoch: [0][700/938]\tBatch Time 0.386 (0.403)\tData Load Time 0.048 (0.062)\tLoss 4.6653 (5.1230)\tTop-5 Accuracy 54.891 (50.523)\n",
            "Epoch: [0][800/938]\tBatch Time 0.390 (0.402)\tData Load Time 0.046 (0.060)\tLoss 4.5072 (5.0510)\tTop-5 Accuracy 55.647 (51.503)\n",
            "Epoch: [0][900/938]\tBatch Time 0.396 (0.401)\tData Load Time 0.047 (0.058)\tLoss 4.3658 (4.9850)\tTop-5 Accuracy 59.481 (52.385)\n",
            "Validation: [0/157]\tBatch Time 0.325 (0.325)\tLoss 4.3450 (4.3450)\tTop-5 Accuracy 62.304 (62.304)\t\n",
            "Validation: [100/157]\tBatch Time 0.309 (0.317)\tLoss 4.2048 (4.3601)\tTop-5 Accuracy 59.887 (60.359)\t\n",
            "\n",
            " * LOSS - 4.338, TOP-5 ACCURACY - 60.820, BLEU-4 - 0.11316184348409077\n",
            "\n",
            "Epoch: [1][0/938]\tBatch Time 0.470 (0.470)\tData Load Time 0.063 (0.063)\tLoss 4.5855 (4.5855)\tTop-5 Accuracy 56.300 (56.300)\n",
            "Epoch: [1][100/938]\tBatch Time 0.400 (0.397)\tData Load Time 0.047 (0.049)\tLoss 3.9760 (4.3169)\tTop-5 Accuracy 66.414 (61.047)\n",
            "Epoch: [1][200/938]\tBatch Time 0.412 (0.396)\tData Load Time 0.051 (0.048)\tLoss 4.4714 (4.3023)\tTop-5 Accuracy 59.901 (61.207)\n",
            "Epoch: [1][300/938]\tBatch Time 0.393 (0.396)\tData Load Time 0.048 (0.048)\tLoss 4.3910 (4.2941)\tTop-5 Accuracy 59.259 (61.311)\n",
            "Epoch: [1][400/938]\tBatch Time 0.408 (0.396)\tData Load Time 0.046 (0.047)\tLoss 4.3489 (4.2776)\tTop-5 Accuracy 61.917 (61.543)\n",
            "Epoch: [1][500/938]\tBatch Time 0.406 (0.396)\tData Load Time 0.049 (0.047)\tLoss 4.1890 (4.2670)\tTop-5 Accuracy 59.701 (61.672)\n",
            "Epoch: [1][600/938]\tBatch Time 0.382 (0.396)\tData Load Time 0.046 (0.047)\tLoss 4.1139 (4.2529)\tTop-5 Accuracy 65.230 (61.852)\n",
            "Epoch: [1][700/938]\tBatch Time 0.392 (0.396)\tData Load Time 0.052 (0.047)\tLoss 4.2369 (4.2405)\tTop-5 Accuracy 60.504 (62.049)\n",
            "Epoch: [1][800/938]\tBatch Time 0.413 (0.397)\tData Load Time 0.049 (0.047)\tLoss 4.0838 (4.2272)\tTop-5 Accuracy 62.982 (62.212)\n",
            "Epoch: [1][900/938]\tBatch Time 0.412 (0.398)\tData Load Time 0.050 (0.047)\tLoss 4.1222 (4.2127)\tTop-5 Accuracy 65.239 (62.392)\n",
            "Validation: [0/157]\tBatch Time 0.329 (0.329)\tLoss 3.8335 (3.8335)\tTop-5 Accuracy 66.491 (66.491)\t\n",
            "Validation: [100/157]\tBatch Time 0.322 (0.322)\tLoss 4.3024 (4.0598)\tTop-5 Accuracy 58.462 (64.654)\t\n",
            "\n",
            " * LOSS - 4.056, TOP-5 ACCURACY - 64.653, BLEU-4 - 0.13258266975587996\n",
            "\n",
            "Epoch: [2][0/938]\tBatch Time 0.446 (0.446)\tData Load Time 0.055 (0.055)\tLoss 3.9582 (3.9582)\tTop-5 Accuracy 66.227 (66.227)\n",
            "Epoch: [2][100/938]\tBatch Time 0.413 (0.407)\tData Load Time 0.048 (0.050)\tLoss 3.8959 (4.0240)\tTop-5 Accuracy 66.000 (64.867)\n",
            "Epoch: [2][200/938]\tBatch Time 0.401 (0.406)\tData Load Time 0.049 (0.049)\tLoss 4.2783 (4.0003)\tTop-5 Accuracy 58.696 (65.174)\n",
            "Epoch: [2][300/938]\tBatch Time 0.419 (0.406)\tData Load Time 0.048 (0.050)\tLoss 4.0567 (3.9865)\tTop-5 Accuracy 62.740 (65.389)\n",
            "Epoch: [2][400/938]\tBatch Time 0.412 (0.406)\tData Load Time 0.050 (0.050)\tLoss 3.9416 (3.9737)\tTop-5 Accuracy 65.699 (65.545)\n",
            "Epoch: [2][500/938]\tBatch Time 0.412 (0.406)\tData Load Time 0.048 (0.049)\tLoss 4.2646 (3.9668)\tTop-5 Accuracy 61.614 (65.643)\n",
            "Epoch: [2][600/938]\tBatch Time 0.399 (0.405)\tData Load Time 0.048 (0.049)\tLoss 3.6720 (3.9649)\tTop-5 Accuracy 70.811 (65.697)\n",
            "Epoch: [2][700/938]\tBatch Time 0.416 (0.405)\tData Load Time 0.049 (0.049)\tLoss 3.9588 (3.9586)\tTop-5 Accuracy 65.281 (65.826)\n",
            "Epoch: [2][800/938]\tBatch Time 0.415 (0.405)\tData Load Time 0.048 (0.049)\tLoss 3.7732 (3.9505)\tTop-5 Accuracy 69.438 (65.935)\n",
            "Epoch: [2][900/938]\tBatch Time 0.407 (0.405)\tData Load Time 0.047 (0.049)\tLoss 3.6906 (3.9469)\tTop-5 Accuracy 72.911 (65.966)\n",
            "Validation: [0/157]\tBatch Time 0.312 (0.312)\tLoss 3.7073 (3.7073)\tTop-5 Accuracy 72.941 (72.941)\t\n",
            "Validation: [100/157]\tBatch Time 0.329 (0.321)\tLoss 3.9411 (3.9224)\tTop-5 Accuracy 64.792 (66.663)\t\n",
            "\n",
            " * LOSS - 3.929, TOP-5 ACCURACY - 66.531, BLEU-4 - 0.1425865213486918\n",
            "\n",
            "Epoch: [3][0/938]\tBatch Time 0.476 (0.476)\tData Load Time 0.055 (0.055)\tLoss 3.6510 (3.6510)\tTop-5 Accuracy 69.553 (69.553)\n",
            "Epoch: [3][100/938]\tBatch Time 0.399 (0.408)\tData Load Time 0.049 (0.051)\tLoss 3.6790 (3.7974)\tTop-5 Accuracy 70.930 (67.758)\n",
            "Epoch: [3][200/938]\tBatch Time 0.422 (0.405)\tData Load Time 0.051 (0.050)\tLoss 4.0714 (3.8008)\tTop-5 Accuracy 64.039 (67.745)\n",
            "Epoch: [3][300/938]\tBatch Time 0.415 (0.406)\tData Load Time 0.048 (0.049)\tLoss 3.8573 (3.7967)\tTop-5 Accuracy 65.441 (67.884)\n",
            "Epoch: [3][400/938]\tBatch Time 0.403 (0.406)\tData Load Time 0.048 (0.049)\tLoss 3.6757 (3.7931)\tTop-5 Accuracy 69.565 (68.034)\n",
            "Epoch: [3][500/938]\tBatch Time 0.396 (0.405)\tData Load Time 0.047 (0.049)\tLoss 3.5079 (3.7869)\tTop-5 Accuracy 70.950 (68.128)\n",
            "Epoch: [3][600/938]\tBatch Time 0.406 (0.405)\tData Load Time 0.049 (0.049)\tLoss 4.0279 (3.7828)\tTop-5 Accuracy 64.377 (68.168)\n",
            "Epoch: [3][700/938]\tBatch Time 0.396 (0.405)\tData Load Time 0.047 (0.048)\tLoss 3.7361 (3.7831)\tTop-5 Accuracy 68.802 (68.151)\n",
            "Epoch: [3][800/938]\tBatch Time 0.397 (0.405)\tData Load Time 0.046 (0.048)\tLoss 3.8246 (3.7773)\tTop-5 Accuracy 67.385 (68.196)\n",
            "Epoch: [3][900/938]\tBatch Time 0.420 (0.404)\tData Load Time 0.049 (0.048)\tLoss 3.5354 (3.7702)\tTop-5 Accuracy 72.048 (68.323)\n",
            "Validation: [0/157]\tBatch Time 0.326 (0.326)\tLoss 3.7635 (3.7635)\tTop-5 Accuracy 67.500 (67.500)\t\n",
            "Validation: [100/157]\tBatch Time 0.311 (0.319)\tLoss 3.8267 (3.8550)\tTop-5 Accuracy 68.661 (67.784)\t\n",
            "\n",
            " * LOSS - 3.854, TOP-5 ACCURACY - 67.613, BLEU-4 - 0.15027869260525378\n",
            "\n",
            "Epoch: [4][0/938]\tBatch Time 0.454 (0.454)\tData Load Time 0.052 (0.052)\tLoss 3.6872 (3.6872)\tTop-5 Accuracy 70.670 (70.670)\n",
            "Epoch: [4][100/938]\tBatch Time 0.396 (0.408)\tData Load Time 0.046 (0.049)\tLoss 3.8496 (3.6418)\tTop-5 Accuracy 69.399 (70.267)\n",
            "Epoch: [4][200/938]\tBatch Time 0.410 (0.405)\tData Load Time 0.047 (0.048)\tLoss 3.6594 (3.6388)\tTop-5 Accuracy 69.091 (70.245)\n",
            "Epoch: [4][300/938]\tBatch Time 0.395 (0.405)\tData Load Time 0.047 (0.048)\tLoss 3.9495 (3.6371)\tTop-5 Accuracy 66.393 (70.305)\n",
            "Epoch: [4][400/938]\tBatch Time 0.417 (0.404)\tData Load Time 0.048 (0.047)\tLoss 3.8524 (3.6369)\tTop-5 Accuracy 65.854 (70.287)\n",
            "Epoch: [4][500/938]\tBatch Time 0.413 (0.404)\tData Load Time 0.047 (0.047)\tLoss 3.3827 (3.6392)\tTop-5 Accuracy 74.638 (70.234)\n",
            "Epoch: [4][600/938]\tBatch Time 0.393 (0.404)\tData Load Time 0.045 (0.047)\tLoss 3.5159 (3.6381)\tTop-5 Accuracy 72.829 (70.211)\n",
            "Epoch: [4][700/938]\tBatch Time 0.413 (0.403)\tData Load Time 0.047 (0.047)\tLoss 3.6763 (3.6340)\tTop-5 Accuracy 68.299 (70.295)\n",
            "Epoch: [4][800/938]\tBatch Time 0.394 (0.403)\tData Load Time 0.046 (0.047)\tLoss 3.6092 (3.6316)\tTop-5 Accuracy 70.081 (70.356)\n",
            "Epoch: [4][900/938]\tBatch Time 0.389 (0.403)\tData Load Time 0.050 (0.047)\tLoss 3.4227 (3.6318)\tTop-5 Accuracy 73.089 (70.340)\n",
            "Validation: [0/157]\tBatch Time 0.317 (0.317)\tLoss 3.7608 (3.7608)\tTop-5 Accuracy 69.010 (69.010)\t\n",
            "Validation: [100/157]\tBatch Time 0.320 (0.319)\tLoss 3.9228 (3.8176)\tTop-5 Accuracy 67.647 (68.208)\t\n",
            "\n",
            " * LOSS - 3.801, TOP-5 ACCURACY - 68.468, BLEU-4 - 0.1540339418223628\n",
            "\n",
            "Epoch: [5][0/938]\tBatch Time 0.435 (0.435)\tData Load Time 0.051 (0.051)\tLoss 3.6114 (3.6114)\tTop-5 Accuracy 72.423 (72.423)\n",
            "Epoch: [5][100/938]\tBatch Time 0.407 (0.407)\tData Load Time 0.048 (0.049)\tLoss 3.5613 (3.5161)\tTop-5 Accuracy 71.059 (72.178)\n",
            "Epoch: [5][200/938]\tBatch Time 0.407 (0.407)\tData Load Time 0.048 (0.050)\tLoss 3.5607 (3.5232)\tTop-5 Accuracy 69.705 (72.011)\n",
            "Epoch: [5][300/938]\tBatch Time 0.399 (0.407)\tData Load Time 0.048 (0.050)\tLoss 3.5260 (3.5257)\tTop-5 Accuracy 71.552 (71.959)\n",
            "Epoch: [5][400/938]\tBatch Time 0.402 (0.406)\tData Load Time 0.049 (0.049)\tLoss 3.7066 (3.5167)\tTop-5 Accuracy 69.188 (72.044)\n",
            "Epoch: [5][500/938]\tBatch Time 0.391 (0.405)\tData Load Time 0.048 (0.049)\tLoss 3.3845 (3.5177)\tTop-5 Accuracy 72.989 (72.039)\n",
            "Epoch: [5][600/938]\tBatch Time 0.398 (0.405)\tData Load Time 0.048 (0.049)\tLoss 3.3848 (3.5174)\tTop-5 Accuracy 72.629 (72.029)\n",
            "Epoch: [5][700/938]\tBatch Time 0.401 (0.405)\tData Load Time 0.047 (0.049)\tLoss 3.2521 (3.5180)\tTop-5 Accuracy 75.521 (72.019)\n",
            "Epoch: [5][800/938]\tBatch Time 0.419 (0.405)\tData Load Time 0.050 (0.049)\tLoss 3.7396 (3.5214)\tTop-5 Accuracy 68.434 (71.955)\n",
            "Epoch: [5][900/938]\tBatch Time 0.413 (0.405)\tData Load Time 0.047 (0.049)\tLoss 3.5188 (3.5221)\tTop-5 Accuracy 70.960 (71.941)\n",
            "Validation: [0/157]\tBatch Time 0.322 (0.322)\tLoss 3.8399 (3.8399)\tTop-5 Accuracy 68.293 (68.293)\t\n",
            "Validation: [100/157]\tBatch Time 0.325 (0.321)\tLoss 3.7855 (3.7888)\tTop-5 Accuracy 68.448 (68.462)\t\n",
            "\n",
            " * LOSS - 3.779, TOP-5 ACCURACY - 68.569, BLEU-4 - 0.15487486945919204\n",
            "\n",
            "Epoch: [6][0/938]\tBatch Time 0.447 (0.447)\tData Load Time 0.057 (0.057)\tLoss 3.2603 (3.2603)\tTop-5 Accuracy 73.995 (73.995)\n",
            "Epoch: [6][100/938]\tBatch Time 0.409 (0.409)\tData Load Time 0.045 (0.051)\tLoss 3.6634 (3.3904)\tTop-5 Accuracy 72.772 (73.902)\n",
            "Epoch: [6][200/938]\tBatch Time 0.399 (0.405)\tData Load Time 0.045 (0.049)\tLoss 3.4988 (3.4131)\tTop-5 Accuracy 73.404 (73.573)\n",
            "Epoch: [6][300/938]\tBatch Time 0.387 (0.404)\tData Load Time 0.049 (0.048)\tLoss 3.4441 (3.4109)\tTop-5 Accuracy 72.727 (73.551)\n",
            "Epoch: [6][400/938]\tBatch Time 0.410 (0.404)\tData Load Time 0.049 (0.048)\tLoss 3.7387 (3.4201)\tTop-5 Accuracy 69.898 (73.428)\n",
            "Epoch: [6][500/938]\tBatch Time 0.400 (0.404)\tData Load Time 0.047 (0.048)\tLoss 3.1936 (3.4251)\tTop-5 Accuracy 75.871 (73.318)\n",
            "Epoch: [6][600/938]\tBatch Time 0.415 (0.404)\tData Load Time 0.047 (0.048)\tLoss 3.4878 (3.4252)\tTop-5 Accuracy 75.845 (73.320)\n",
            "Epoch: [6][700/938]\tBatch Time 0.394 (0.404)\tData Load Time 0.047 (0.048)\tLoss 3.4171 (3.4222)\tTop-5 Accuracy 74.863 (73.386)\n",
            "Epoch: [6][800/938]\tBatch Time 0.396 (0.404)\tData Load Time 0.046 (0.048)\tLoss 3.3721 (3.4244)\tTop-5 Accuracy 75.354 (73.380)\n",
            "Epoch: [6][900/938]\tBatch Time 0.399 (0.404)\tData Load Time 0.049 (0.048)\tLoss 3.5326 (3.4256)\tTop-5 Accuracy 72.452 (73.380)\n",
            "Validation: [0/157]\tBatch Time 0.322 (0.322)\tLoss 3.8141 (3.8141)\tTop-5 Accuracy 67.183 (67.183)\t\n",
            "Validation: [100/157]\tBatch Time 0.318 (0.321)\tLoss 4.0547 (3.7579)\tTop-5 Accuracy 67.624 (68.801)\t\n",
            "\n",
            " * LOSS - 3.764, TOP-5 ACCURACY - 68.901, BLEU-4 - 0.15593531428242108\n",
            "\n",
            "Epoch: [7][0/938]\tBatch Time 0.438 (0.438)\tData Load Time 0.051 (0.051)\tLoss 3.3265 (3.3265)\tTop-5 Accuracy 76.323 (76.323)\n",
            "Epoch: [7][100/938]\tBatch Time 0.404 (0.406)\tData Load Time 0.046 (0.049)\tLoss 3.3504 (3.3169)\tTop-5 Accuracy 73.618 (75.198)\n",
            "Epoch: [7][200/938]\tBatch Time 0.438 (0.404)\tData Load Time 0.049 (0.048)\tLoss 3.4682 (3.3208)\tTop-5 Accuracy 74.419 (75.057)\n",
            "Epoch: [7][300/938]\tBatch Time 0.390 (0.403)\tData Load Time 0.045 (0.048)\tLoss 3.3849 (3.3245)\tTop-5 Accuracy 75.141 (74.944)\n",
            "Epoch: [7][400/938]\tBatch Time 0.412 (0.404)\tData Load Time 0.048 (0.048)\tLoss 3.3588 (3.3263)\tTop-5 Accuracy 74.627 (74.931)\n",
            "Epoch: [7][500/938]\tBatch Time 0.404 (0.404)\tData Load Time 0.047 (0.048)\tLoss 3.2515 (3.3264)\tTop-5 Accuracy 76.800 (74.981)\n",
            "Epoch: [7][600/938]\tBatch Time 0.394 (0.404)\tData Load Time 0.049 (0.048)\tLoss 3.1748 (3.3291)\tTop-5 Accuracy 76.374 (74.923)\n",
            "Epoch: [7][700/938]\tBatch Time 0.393 (0.404)\tData Load Time 0.044 (0.048)\tLoss 3.5699 (3.3320)\tTop-5 Accuracy 70.523 (74.880)\n",
            "Epoch: [7][800/938]\tBatch Time 0.412 (0.404)\tData Load Time 0.047 (0.048)\tLoss 3.3872 (3.3347)\tTop-5 Accuracy 73.750 (74.820)\n",
            "Epoch: [7][900/938]\tBatch Time 0.405 (0.404)\tData Load Time 0.051 (0.048)\tLoss 3.1480 (3.3363)\tTop-5 Accuracy 78.608 (74.806)\n",
            "Validation: [0/157]\tBatch Time 0.319 (0.319)\tLoss 3.7079 (3.7079)\tTop-5 Accuracy 70.077 (70.077)\t\n",
            "Validation: [100/157]\tBatch Time 0.320 (0.319)\tLoss 3.8352 (3.7528)\tTop-5 Accuracy 66.410 (69.064)\t\n",
            "\n",
            " * LOSS - 3.746, TOP-5 ACCURACY - 69.194, BLEU-4 - 0.15538725036310155\n",
            "\n",
            "\n",
            "Epochs since last improvement: 1\n",
            "\n",
            "Epoch: [8][0/938]\tBatch Time 0.476 (0.476)\tData Load Time 0.052 (0.052)\tLoss 3.3153 (3.3153)\tTop-5 Accuracy 74.865 (74.865)\n",
            "Epoch: [8][100/938]\tBatch Time 0.411 (0.405)\tData Load Time 0.049 (0.047)\tLoss 3.1374 (3.2440)\tTop-5 Accuracy 77.926 (76.029)\n",
            "Epoch: [8][200/938]\tBatch Time 0.413 (0.404)\tData Load Time 0.045 (0.047)\tLoss 3.3566 (3.2371)\tTop-5 Accuracy 72.530 (76.055)\n",
            "Epoch: [8][300/938]\tBatch Time 0.387 (0.404)\tData Load Time 0.046 (0.047)\tLoss 3.3365 (3.2337)\tTop-5 Accuracy 75.652 (76.121)\n",
            "Epoch: [8][400/938]\tBatch Time 0.413 (0.403)\tData Load Time 0.048 (0.047)\tLoss 3.1056 (3.2360)\tTop-5 Accuracy 78.351 (76.138)\n",
            "Epoch: [8][500/938]\tBatch Time 0.398 (0.403)\tData Load Time 0.049 (0.047)\tLoss 3.2081 (3.2378)\tTop-5 Accuracy 77.429 (76.126)\n",
            "Epoch: [8][600/938]\tBatch Time 0.395 (0.403)\tData Load Time 0.045 (0.047)\tLoss 3.1825 (3.2394)\tTop-5 Accuracy 75.630 (76.134)\n",
            "Epoch: [8][700/938]\tBatch Time 0.411 (0.403)\tData Load Time 0.046 (0.047)\tLoss 3.2482 (3.2441)\tTop-5 Accuracy 76.574 (76.054)\n",
            "Epoch: [8][800/938]\tBatch Time 0.402 (0.403)\tData Load Time 0.047 (0.047)\tLoss 3.4325 (3.2477)\tTop-5 Accuracy 73.810 (76.031)\n",
            "Epoch: [8][900/938]\tBatch Time 0.391 (0.403)\tData Load Time 0.045 (0.047)\tLoss 3.1707 (3.2518)\tTop-5 Accuracy 78.873 (75.980)\n",
            "Validation: [0/157]\tBatch Time 0.318 (0.318)\tLoss 4.1326 (4.1326)\tTop-5 Accuracy 65.591 (65.591)\t\n",
            "Validation: [100/157]\tBatch Time 0.320 (0.320)\tLoss 3.7877 (3.7308)\tTop-5 Accuracy 68.241 (69.674)\t\n",
            "\n",
            " * LOSS - 3.745, TOP-5 ACCURACY - 69.345, BLEU-4 - 0.15678422485228782\n",
            "\n",
            "Epoch: [9][0/938]\tBatch Time 0.442 (0.442)\tData Load Time 0.054 (0.054)\tLoss 3.0454 (3.0454)\tTop-5 Accuracy 82.462 (82.462)\n",
            "Epoch: [9][100/938]\tBatch Time 0.405 (0.405)\tData Load Time 0.045 (0.049)\tLoss 2.9419 (3.1440)\tTop-5 Accuracy 79.434 (77.577)\n",
            "Epoch: [9][200/938]\tBatch Time 0.392 (0.403)\tData Load Time 0.045 (0.048)\tLoss 3.2244 (3.1410)\tTop-5 Accuracy 78.771 (77.613)\n",
            "Epoch: [9][300/938]\tBatch Time 0.408 (0.402)\tData Load Time 0.046 (0.047)\tLoss 3.1744 (3.1502)\tTop-5 Accuracy 76.757 (77.570)\n",
            "Epoch: [9][400/938]\tBatch Time 0.420 (0.402)\tData Load Time 0.047 (0.047)\tLoss 3.3721 (3.1518)\tTop-5 Accuracy 75.635 (77.582)\n",
            "Epoch: [9][500/938]\tBatch Time 0.400 (0.403)\tData Load Time 0.048 (0.047)\tLoss 3.1069 (3.1582)\tTop-5 Accuracy 77.273 (77.432)\n",
            "Epoch: [9][600/938]\tBatch Time 0.419 (0.403)\tData Load Time 0.047 (0.047)\tLoss 3.4077 (3.1597)\tTop-5 Accuracy 74.878 (77.405)\n",
            "Epoch: [9][700/938]\tBatch Time 0.395 (0.403)\tData Load Time 0.048 (0.047)\tLoss 3.2171 (3.1658)\tTop-5 Accuracy 75.942 (77.279)\n",
            "Epoch: [9][800/938]\tBatch Time 0.393 (0.404)\tData Load Time 0.048 (0.047)\tLoss 3.0729 (3.1706)\tTop-5 Accuracy 77.198 (77.221)\n",
            "Epoch: [9][900/938]\tBatch Time 0.405 (0.403)\tData Load Time 0.046 (0.047)\tLoss 3.1845 (3.1747)\tTop-5 Accuracy 74.462 (77.141)\n",
            "Validation: [0/157]\tBatch Time 0.315 (0.315)\tLoss 3.8552 (3.8552)\tTop-5 Accuracy 67.448 (67.448)\t\n",
            "Validation: [100/157]\tBatch Time 0.316 (0.318)\tLoss 3.5016 (3.7587)\tTop-5 Accuracy 73.913 (69.384)\t\n",
            "\n",
            " * LOSS - 3.753, TOP-5 ACCURACY - 69.510, BLEU-4 - 0.15496279439770866\n",
            "\n",
            "\n",
            "Epochs since last improvement: 1\n",
            "\n",
            "Epoch: [10][0/938]\tBatch Time 0.447 (0.447)\tData Load Time 0.053 (0.053)\tLoss 2.9094 (2.9094)\tTop-5 Accuracy 83.954 (83.954)\n",
            "Epoch: [10][100/938]\tBatch Time 0.418 (0.405)\tData Load Time 0.046 (0.048)\tLoss 3.2500 (3.0655)\tTop-5 Accuracy 74.940 (78.922)\n",
            "Epoch: [10][200/938]\tBatch Time 0.404 (0.404)\tData Load Time 0.045 (0.047)\tLoss 3.0800 (3.0783)\tTop-5 Accuracy 79.345 (78.657)\n",
            "Epoch: [10][300/938]\tBatch Time 0.399 (0.403)\tData Load Time 0.047 (0.047)\tLoss 3.0901 (3.0835)\tTop-5 Accuracy 78.571 (78.626)\n",
            "Epoch: [10][400/938]\tBatch Time 0.413 (0.403)\tData Load Time 0.047 (0.047)\tLoss 3.2493 (3.0853)\tTop-5 Accuracy 76.276 (78.597)\n",
            "Epoch: [10][500/938]\tBatch Time 0.403 (0.403)\tData Load Time 0.046 (0.047)\tLoss 3.1397 (3.0858)\tTop-5 Accuracy 77.428 (78.571)\n",
            "Epoch: [10][600/938]\tBatch Time 0.394 (0.403)\tData Load Time 0.046 (0.047)\tLoss 3.1691 (3.0924)\tTop-5 Accuracy 78.470 (78.455)\n",
            "Epoch: [10][700/938]\tBatch Time 0.415 (0.403)\tData Load Time 0.047 (0.047)\tLoss 3.0818 (3.0964)\tTop-5 Accuracy 76.296 (78.383)\n",
            "Epoch: [10][800/938]\tBatch Time 0.402 (0.403)\tData Load Time 0.046 (0.047)\tLoss 3.0554 (3.1009)\tTop-5 Accuracy 79.897 (78.326)\n",
            "Epoch: [10][900/938]\tBatch Time 0.400 (0.403)\tData Load Time 0.046 (0.047)\tLoss 3.1517 (3.1033)\tTop-5 Accuracy 76.359 (78.284)\n",
            "Validation: [0/157]\tBatch Time 0.319 (0.319)\tLoss 3.7448 (3.7448)\tTop-5 Accuracy 70.604 (70.604)\t\n",
            "Validation: [100/157]\tBatch Time 0.322 (0.320)\tLoss 3.7659 (3.7588)\tTop-5 Accuracy 68.407 (69.451)\t\n",
            "\n",
            " * LOSS - 3.761, TOP-5 ACCURACY - 69.370, BLEU-4 - 0.15670692211091003\n",
            "\n",
            "\n",
            "Epochs since last improvement: 2\n",
            "\n",
            "Epoch: [11][0/938]\tBatch Time 0.495 (0.495)\tData Load Time 0.088 (0.088)\tLoss 2.9935 (2.9935)\tTop-5 Accuracy 79.420 (79.420)\n",
            "Epoch: [11][100/938]\tBatch Time 0.414 (0.406)\tData Load Time 0.053 (0.048)\tLoss 2.8191 (2.9880)\tTop-5 Accuracy 81.389 (79.975)\n",
            "Epoch: [11][200/938]\tBatch Time 0.389 (0.404)\tData Load Time 0.045 (0.047)\tLoss 3.0823 (2.9952)\tTop-5 Accuracy 76.435 (79.878)\n",
            "Epoch: [11][300/938]\tBatch Time 0.412 (0.403)\tData Load Time 0.052 (0.047)\tLoss 3.0282 (2.9984)\tTop-5 Accuracy 80.840 (79.864)\n",
            "Epoch: [11][400/938]\tBatch Time 0.413 (0.403)\tData Load Time 0.048 (0.047)\tLoss 2.8670 (3.0059)\tTop-5 Accuracy 81.429 (79.714)\n",
            "Epoch: [11][500/938]\tBatch Time 0.400 (0.403)\tData Load Time 0.045 (0.047)\tLoss 3.2787 (3.0142)\tTop-5 Accuracy 74.133 (79.580)\n",
            "Epoch: [11][600/938]\tBatch Time 0.424 (0.403)\tData Load Time 0.046 (0.047)\tLoss 2.9980 (3.0176)\tTop-5 Accuracy 81.716 (79.559)\n",
            "Epoch: [11][700/938]\tBatch Time 0.399 (0.403)\tData Load Time 0.047 (0.047)\tLoss 3.1243 (3.0244)\tTop-5 Accuracy 77.212 (79.455)\n",
            "Epoch: [11][800/938]\tBatch Time 0.411 (0.403)\tData Load Time 0.046 (0.047)\tLoss 2.9992 (3.0247)\tTop-5 Accuracy 77.475 (79.474)\n",
            "Epoch: [11][900/938]\tBatch Time 0.396 (0.403)\tData Load Time 0.046 (0.047)\tLoss 3.0657 (3.0286)\tTop-5 Accuracy 79.945 (79.407)\n",
            "Validation: [0/157]\tBatch Time 0.314 (0.314)\tLoss 3.7699 (3.7699)\tTop-5 Accuracy 68.617 (68.617)\t\n",
            "Validation: [100/157]\tBatch Time 0.320 (0.319)\tLoss 3.6908 (3.7673)\tTop-5 Accuracy 70.649 (69.453)\t\n",
            "\n",
            " * LOSS - 3.771, TOP-5 ACCURACY - 69.345, BLEU-4 - 0.16228286937921116\n",
            "\n",
            "Epoch: [12][0/938]\tBatch Time 0.445 (0.445)\tData Load Time 0.051 (0.051)\tLoss 2.8945 (2.8945)\tTop-5 Accuracy 80.645 (80.645)\n",
            "Epoch: [12][100/938]\tBatch Time 0.403 (0.406)\tData Load Time 0.046 (0.048)\tLoss 2.8872 (2.9116)\tTop-5 Accuracy 81.330 (81.229)\n",
            "Epoch: [12][200/938]\tBatch Time 0.399 (0.404)\tData Load Time 0.046 (0.047)\tLoss 3.1446 (2.9297)\tTop-5 Accuracy 78.571 (81.059)\n",
            "Epoch: [12][300/938]\tBatch Time 0.395 (0.404)\tData Load Time 0.045 (0.047)\tLoss 3.1326 (2.9283)\tTop-5 Accuracy 76.966 (81.013)\n",
            "Epoch: [12][400/938]\tBatch Time 0.399 (0.404)\tData Load Time 0.049 (0.047)\tLoss 2.9087 (2.9348)\tTop-5 Accuracy 81.818 (80.914)\n",
            "Epoch: [12][500/938]\tBatch Time 0.433 (0.403)\tData Load Time 0.047 (0.047)\tLoss 2.8965 (2.9424)\tTop-5 Accuracy 82.009 (80.818)\n",
            "Epoch: [12][600/938]\tBatch Time 0.410 (0.403)\tData Load Time 0.046 (0.047)\tLoss 3.0540 (2.9508)\tTop-5 Accuracy 78.765 (80.672)\n",
            "Epoch: [12][700/938]\tBatch Time 0.425 (0.403)\tData Load Time 0.046 (0.047)\tLoss 3.1402 (2.9583)\tTop-5 Accuracy 78.133 (80.557)\n",
            "Epoch: [12][800/938]\tBatch Time 0.423 (0.403)\tData Load Time 0.057 (0.047)\tLoss 3.0178 (2.9632)\tTop-5 Accuracy 81.796 (80.486)\n",
            "Epoch: [12][900/938]\tBatch Time 0.414 (0.403)\tData Load Time 0.047 (0.047)\tLoss 3.0831 (2.9653)\tTop-5 Accuracy 77.094 (80.449)\n",
            "Validation: [0/157]\tBatch Time 0.323 (0.323)\tLoss 3.7511 (3.7511)\tTop-5 Accuracy 69.853 (69.853)\t\n",
            "Validation: [100/157]\tBatch Time 0.316 (0.320)\tLoss 3.9077 (3.7715)\tTop-5 Accuracy 66.048 (69.392)\t\n",
            "\n",
            " * LOSS - 3.780, TOP-5 ACCURACY - 69.196, BLEU-4 - 0.15552608084592975\n",
            "\n",
            "\n",
            "Epochs since last improvement: 1\n",
            "\n",
            "Epoch: [13][0/938]\tBatch Time 0.479 (0.479)\tData Load Time 0.051 (0.051)\tLoss 3.0545 (3.0545)\tTop-5 Accuracy 80.430 (80.430)\n",
            "Epoch: [13][100/938]\tBatch Time 0.393 (0.406)\tData Load Time 0.048 (0.048)\tLoss 2.9728 (2.8643)\tTop-5 Accuracy 80.286 (82.174)\n",
            "Epoch: [13][200/938]\tBatch Time 0.395 (0.404)\tData Load Time 0.048 (0.047)\tLoss 2.7982 (2.8577)\tTop-5 Accuracy 83.844 (82.165)\n",
            "Epoch: [13][300/938]\tBatch Time 0.411 (0.403)\tData Load Time 0.046 (0.047)\tLoss 2.8986 (2.8668)\tTop-5 Accuracy 83.292 (82.030)\n",
            "Epoch: [13][400/938]\tBatch Time 0.398 (0.403)\tData Load Time 0.050 (0.047)\tLoss 2.9935 (2.8780)\tTop-5 Accuracy 80.415 (81.895)\n",
            "Epoch: [13][500/938]\tBatch Time 0.397 (0.403)\tData Load Time 0.047 (0.047)\tLoss 2.8987 (2.8796)\tTop-5 Accuracy 80.874 (81.838)\n",
            "Epoch: [13][600/938]\tBatch Time 0.397 (0.403)\tData Load Time 0.045 (0.047)\tLoss 3.0683 (2.8853)\tTop-5 Accuracy 78.100 (81.761)\n",
            "Epoch: [13][700/938]\tBatch Time 0.396 (0.403)\tData Load Time 0.047 (0.047)\tLoss 2.8044 (2.8934)\tTop-5 Accuracy 85.095 (81.632)\n",
            "Epoch: [13][800/938]\tBatch Time 0.404 (0.403)\tData Load Time 0.046 (0.047)\tLoss 3.0486 (2.8983)\tTop-5 Accuracy 80.556 (81.538)\n",
            "Epoch: [13][900/938]\tBatch Time 0.412 (0.403)\tData Load Time 0.046 (0.047)\tLoss 2.8206 (2.9020)\tTop-5 Accuracy 80.440 (81.457)\n",
            "Validation: [0/157]\tBatch Time 0.315 (0.315)\tLoss 3.7252 (3.7252)\tTop-5 Accuracy 66.578 (66.578)\t\n",
            "Validation: [100/157]\tBatch Time 0.318 (0.319)\tLoss 3.7905 (3.8184)\tTop-5 Accuracy 67.116 (68.984)\t\n",
            "\n",
            " * LOSS - 3.814, TOP-5 ACCURACY - 68.996, BLEU-4 - 0.15917783481475317\n",
            "\n",
            "\n",
            "Epochs since last improvement: 2\n",
            "\n",
            "Epoch: [14][0/938]\tBatch Time 0.461 (0.461)\tData Load Time 0.049 (0.049)\tLoss 2.6882 (2.6882)\tTop-5 Accuracy 85.445 (85.445)\n",
            "Epoch: [14][100/938]\tBatch Time 0.405 (0.404)\tData Load Time 0.047 (0.048)\tLoss 2.8176 (2.7979)\tTop-5 Accuracy 83.684 (82.948)\n",
            "Epoch: [14][200/938]\tBatch Time 0.400 (0.403)\tData Load Time 0.050 (0.047)\tLoss 2.8182 (2.8009)\tTop-5 Accuracy 84.419 (82.997)\n",
            "Epoch: [14][300/938]\tBatch Time 0.403 (0.403)\tData Load Time 0.049 (0.047)\tLoss 2.8196 (2.8086)\tTop-5 Accuracy 85.333 (82.849)\n",
            "Epoch: [14][400/938]\tBatch Time 0.393 (0.403)\tData Load Time 0.045 (0.047)\tLoss 2.7370 (2.8122)\tTop-5 Accuracy 83.799 (82.793)\n",
            "Epoch: [14][500/938]\tBatch Time 0.403 (0.403)\tData Load Time 0.046 (0.047)\tLoss 2.7787 (2.8216)\tTop-5 Accuracy 83.289 (82.692)\n",
            "Epoch: [14][600/938]\tBatch Time 0.399 (0.402)\tData Load Time 0.047 (0.047)\tLoss 3.0423 (2.8282)\tTop-5 Accuracy 78.820 (82.599)\n",
            "Epoch: [14][700/938]\tBatch Time 0.394 (0.403)\tData Load Time 0.048 (0.047)\tLoss 2.6440 (2.8336)\tTop-5 Accuracy 85.638 (82.526)\n",
            "Epoch: [14][800/938]\tBatch Time 0.398 (0.403)\tData Load Time 0.046 (0.047)\tLoss 2.8499 (2.8390)\tTop-5 Accuracy 84.127 (82.440)\n",
            "Epoch: [14][900/938]\tBatch Time 0.413 (0.403)\tData Load Time 0.052 (0.047)\tLoss 2.9253 (2.8434)\tTop-5 Accuracy 80.206 (82.355)\n",
            "Validation: [0/157]\tBatch Time 0.313 (0.313)\tLoss 3.8153 (3.8153)\tTop-5 Accuracy 67.705 (67.705)\t\n",
            "Validation: [100/157]\tBatch Time 0.318 (0.319)\tLoss 3.6922 (3.8191)\tTop-5 Accuracy 67.717 (69.199)\t\n",
            "\n",
            " * LOSS - 3.823, TOP-5 ACCURACY - 69.139, BLEU-4 - 0.15559552082453515\n",
            "\n",
            "\n",
            "Epochs since last improvement: 3\n",
            "\n",
            "Epoch: [15][0/938]\tBatch Time 0.464 (0.464)\tData Load Time 0.051 (0.051)\tLoss 2.7928 (2.7928)\tTop-5 Accuracy 82.558 (82.558)\n",
            "Epoch: [15][100/938]\tBatch Time 0.408 (0.406)\tData Load Time 0.045 (0.047)\tLoss 3.0647 (2.7442)\tTop-5 Accuracy 79.200 (83.728)\n",
            "Epoch: [15][200/938]\tBatch Time 0.416 (0.404)\tData Load Time 0.047 (0.047)\tLoss 2.5922 (2.7432)\tTop-5 Accuracy 88.148 (83.838)\n",
            "Epoch: [15][300/938]\tBatch Time 0.411 (0.404)\tData Load Time 0.050 (0.048)\tLoss 2.6363 (2.7480)\tTop-5 Accuracy 85.224 (83.743)\n",
            "Epoch: [15][400/938]\tBatch Time 0.398 (0.404)\tData Load Time 0.047 (0.048)\tLoss 2.8031 (2.7589)\tTop-5 Accuracy 85.366 (83.576)\n",
            "Epoch: [15][500/938]\tBatch Time 0.401 (0.404)\tData Load Time 0.048 (0.048)\tLoss 2.8324 (2.7666)\tTop-5 Accuracy 82.275 (83.514)\n",
            "Epoch: [15][600/938]\tBatch Time 0.408 (0.404)\tData Load Time 0.046 (0.048)\tLoss 2.7402 (2.7728)\tTop-5 Accuracy 84.865 (83.459)\n",
            "Epoch: [15][700/938]\tBatch Time 0.398 (0.404)\tData Load Time 0.046 (0.047)\tLoss 2.5803 (2.7751)\tTop-5 Accuracy 85.372 (83.426)\n",
            "Epoch: [15][800/938]\tBatch Time 0.405 (0.404)\tData Load Time 0.046 (0.047)\tLoss 2.8952 (2.7825)\tTop-5 Accuracy 80.585 (83.282)\n",
            "Epoch: [15][900/938]\tBatch Time 0.392 (0.404)\tData Load Time 0.045 (0.047)\tLoss 2.8584 (2.7859)\tTop-5 Accuracy 81.972 (83.241)\n",
            "Validation: [0/157]\tBatch Time 0.313 (0.313)\tLoss 3.4991 (3.4991)\tTop-5 Accuracy 73.178 (73.178)\t\n",
            "Validation: [100/157]\tBatch Time 0.328 (0.319)\tLoss 3.9074 (3.8281)\tTop-5 Accuracy 67.213 (69.222)\t\n",
            "\n",
            " * LOSS - 3.827, TOP-5 ACCURACY - 69.115, BLEU-4 - 0.15869167338965806\n",
            "\n",
            "\n",
            "Epochs since last improvement: 4\n",
            "\n",
            "Epoch: [16][0/938]\tBatch Time 0.435 (0.435)\tData Load Time 0.059 (0.059)\tLoss 2.6459 (2.6459)\tTop-5 Accuracy 85.260 (85.260)\n",
            "Epoch: [16][100/938]\tBatch Time 0.399 (0.406)\tData Load Time 0.047 (0.048)\tLoss 2.7984 (2.6795)\tTop-5 Accuracy 82.979 (84.902)\n",
            "Epoch: [16][200/938]\tBatch Time 0.393 (0.404)\tData Load Time 0.045 (0.048)\tLoss 2.6917 (2.6933)\tTop-5 Accuracy 84.571 (84.680)\n",
            "Epoch: [16][300/938]\tBatch Time 0.396 (0.403)\tData Load Time 0.045 (0.047)\tLoss 2.7349 (2.6955)\tTop-5 Accuracy 82.834 (84.657)\n",
            "Epoch: [16][400/938]\tBatch Time 0.409 (0.403)\tData Load Time 0.048 (0.047)\tLoss 2.6578 (2.6978)\tTop-5 Accuracy 83.582 (84.580)\n",
            "Epoch: [16][500/938]\tBatch Time 0.395 (0.403)\tData Load Time 0.045 (0.047)\tLoss 2.6574 (2.7074)\tTop-5 Accuracy 84.324 (84.422)\n",
            "Epoch: [16][600/938]\tBatch Time 0.406 (0.403)\tData Load Time 0.047 (0.047)\tLoss 2.6995 (2.7128)\tTop-5 Accuracy 85.025 (84.342)\n",
            "Epoch: [16][700/938]\tBatch Time 0.406 (0.403)\tData Load Time 0.045 (0.047)\tLoss 2.6909 (2.7185)\tTop-5 Accuracy 84.040 (84.265)\n",
            "Epoch: [16][800/938]\tBatch Time 0.389 (0.403)\tData Load Time 0.047 (0.047)\tLoss 2.6986 (2.7238)\tTop-5 Accuracy 84.831 (84.187)\n",
            "Epoch: [16][900/938]\tBatch Time 0.418 (0.403)\tData Load Time 0.053 (0.047)\tLoss 2.9645 (2.7303)\tTop-5 Accuracy 81.170 (84.074)\n",
            "Validation: [0/157]\tBatch Time 0.317 (0.317)\tLoss 3.5899 (3.5899)\tTop-5 Accuracy 70.866 (70.866)\t\n",
            "Validation: [100/157]\tBatch Time 0.313 (0.320)\tLoss 3.7737 (3.8546)\tTop-5 Accuracy 68.876 (68.808)\t\n",
            "\n",
            " * LOSS - 3.862, TOP-5 ACCURACY - 68.867, BLEU-4 - 0.15154685764776177\n",
            "\n",
            "\n",
            "Epochs since last improvement: 5\n",
            "\n",
            "Epoch: [17][0/938]\tBatch Time 0.465 (0.465)\tData Load Time 0.049 (0.049)\tLoss 2.6641 (2.6641)\tTop-5 Accuracy 85.864 (85.864)\n"
          ]
        }
      ],
      "source": [
        "###################################\n",
        "# Content of train.py\n",
        "###################################\n",
        "\n",
        "import time\n",
        "import torch.backends.cudnn as cudnn\n",
        "import torch.optim\n",
        "import torch.utils.data\n",
        "import torchvision.transforms as transforms\n",
        "from torch import nn\n",
        "from torch.nn.utils.rnn import pack_padded_sequence\n",
        "from nltk.translate.bleu_score import corpus_bleu\n",
        "\n",
        "# Data parameters\n",
        "data_folder = 'prepared_data/'  # folder with data files saved by create_input_files.py\n",
        "data_name = 'flickr8k_5_cap_per_img_5_min_word_freq'  # base name shared by data files\n",
        "\n",
        "# Model parameters\n",
        "emb_dim = 512  # dimension of word embeddings\n",
        "attention_dim = 512  # dimension of attention linear layers\n",
        "decoder_dim = 512  # dimension of decoder RNN\n",
        "dropout = 0.5\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")  # sets device for model and PyTorch tensors\n",
        "cudnn.benchmark = True  # set to true only if inputs to model are fixed size; otherwise lot of computational overhead\n",
        "\n",
        "# Training parameters\n",
        "start_epoch = 0\n",
        "epochs = 20  # number of epochs to train for (if early stopping is not triggered)\n",
        "epochs_since_improvement = 0  # keeps track of number of epochs since there's been an improvement in validation BLEU\n",
        "batch_size = 32\n",
        "workers = 0  # for data-loading; right now, only 1 works with h5py\n",
        "encoder_lr = 1e-4  # learning rate for encoder if fine-tuning\n",
        "decoder_lr = 4e-4  # learning rate for decoder\n",
        "grad_clip = 5.  # clip gradients at an absolute value of\n",
        "alpha_c = 1.  # regularization parameter for 'doubly stochastic attention', as in the paper\n",
        "best_bleu4 = 0.  # BLEU-4 score right now\n",
        "print_freq = 100  # print training/validation stats every __ batches\n",
        "fine_tune_encoder = False  # fine-tune encoder?\n",
        "checkpoint = None  # path to checkpoint, None if none\n",
        "\n",
        "# Working models : ['resnet', 'LSTM', False, 2048], ['resnet', 'GRU', False, 2048], ['vgg', 'LSTM', False, 512], ['resnet', 'LSTM', True, 2048]\n",
        "models_to_train = [['resnet', 'GRU', False, 2048], ['vgg', 'LSTM', False, 512], ['resnet', 'LSTM', True, 2048]]\n",
        "\n",
        "def main():\n",
        "    \"\"\"\n",
        "    Training and validation.\n",
        "    \"\"\"\n",
        "\n",
        "    for cnn_rnn_structure in models_to_train:\n",
        "      print(\"We are training a model with {} as a CNN-encoder architecture and {} as the RNN-encoder architecture\".format(cnn_rnn_structure[0], cnn_rnn_structure[1]))\n",
        "      global best_bleu4, epochs_since_improvement, checkpoint, start_epoch, fine_tune_encoder, data_name, word_map\n",
        "\n",
        "      # Read word map\n",
        "      word_map_file = os.path.join(data_folder, 'WORDMAP_' + data_name + '.json')\n",
        "      with open(word_map_file, 'r') as j:\n",
        "          word_map = json.load(j)\n",
        "\n",
        "      # Initialize / load checkpoint\n",
        "      if checkpoint is None:\n",
        "          decoder = DecoderWithAttention(attention_dim=attention_dim,\n",
        "                                        embed_dim=emb_dim,\n",
        "                                        decoder_dim=decoder_dim,\n",
        "                                        encoder_dim= cnn_rnn_structure[3],\n",
        "                                        vocab_size=len(word_map),\n",
        "                                        dropout=dropout,\n",
        "                                        cell_type=cnn_rnn_structure[1],\n",
        "                                        scheduled_sampling=cnn_rnn_structure[2])  # Choice of the RNN Cell Type, GRU or LSTM\n",
        "          decoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, decoder.parameters()),\n",
        "                                              lr=decoder_lr)\n",
        "          encoder = Encoder(cnn=cnn_rnn_structure[0]) # cnn = 'resnet' or cnn = 'vgg' ==> Choice of the CNN model for encoder Transfer Learning\n",
        "          encoder.fine_tune(fine_tune_encoder)\n",
        "          encoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, encoder.parameters()),\n",
        "                                              lr=encoder_lr) if fine_tune_encoder else None\n",
        "\n",
        "      else:\n",
        "          checkpoint = torch.load(checkpoint)\n",
        "          start_epoch = checkpoint['epoch'] + 1\n",
        "          epochs_since_improvement = checkpoint['epochs_since_improvement']\n",
        "          best_bleu4 = checkpoint['bleu-4']\n",
        "          decoder = checkpoint['decoder']\n",
        "          decoder_optimizer = checkpoint['decoder_optimizer']\n",
        "          encoder = checkpoint['encoder']\n",
        "          encoder_optimizer = checkpoint['encoder_optimizer']\n",
        "          if fine_tune_encoder is True and encoder_optimizer is None:\n",
        "              encoder.fine_tune(fine_tune_encoder)\n",
        "              encoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, encoder.parameters()),\n",
        "                                                  lr=encoder_lr)\n",
        "\n",
        "      # Move to GPU, if available\n",
        "      decoder = decoder.to(device)\n",
        "      encoder = encoder.to(device)\n",
        "\n",
        "      # Loss function\n",
        "      criterion = nn.CrossEntropyLoss().to(device)\n",
        "\n",
        "      # Custom dataloaders\n",
        "      normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
        "                                      std=[0.229, 0.224, 0.225])\n",
        "      train_loader = torch.utils.data.DataLoader(\n",
        "          CaptionDataset(data_folder, data_name, 'TRAIN', transform=transforms.Compose([normalize])),\n",
        "          batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True)\n",
        "      val_loader = torch.utils.data.DataLoader(\n",
        "          CaptionDataset(data_folder, data_name, 'VAL', transform=transforms.Compose([normalize])),\n",
        "          batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True)\n",
        "\n",
        "      # Epochs\n",
        "      for epoch in range(start_epoch, epochs):\n",
        "\n",
        "          # Decay learning rate if there is no improvement for 8 consecutive epochs, and terminate training after 20\n",
        "          if epochs_since_improvement == 20:\n",
        "              break\n",
        "          if epochs_since_improvement > 0 and epochs_since_improvement % 8 == 0:\n",
        "              adjust_learning_rate(decoder_optimizer, 0.8)\n",
        "              if fine_tune_encoder:\n",
        "                  adjust_learning_rate(encoder_optimizer, 0.8)\n",
        "\n",
        "          # One epoch's training\n",
        "          train(train_loader=train_loader,\n",
        "                encoder=encoder,\n",
        "                decoder=decoder,\n",
        "                criterion=criterion,\n",
        "                encoder_optimizer=encoder_optimizer,\n",
        "                decoder_optimizer=decoder_optimizer,\n",
        "                epoch=epoch,\n",
        "                epochs = epochs)\n",
        "\n",
        "          # One epoch's validation\n",
        "          recent_bleu4 = validate(val_loader=val_loader,\n",
        "                                  encoder=encoder,\n",
        "                                  decoder=decoder,\n",
        "                                  criterion=criterion)\n",
        "\n",
        "          # Check if there was an improvement\n",
        "          is_best = recent_bleu4 > best_bleu4\n",
        "          best_bleu4 = max(recent_bleu4, best_bleu4)\n",
        "          if not is_best:\n",
        "              epochs_since_improvement += 1\n",
        "              print(\"\\nEpochs since last improvement: %d\\n\" % (epochs_since_improvement,))\n",
        "          else:\n",
        "              epochs_since_improvement = 0\n",
        "\n",
        "          # Save checkpoint\n",
        "          save_checkpoint(data_name, cnn_rnn_structure, epoch, epochs_since_improvement, encoder, decoder, encoder_optimizer,\n",
        "                          decoder_optimizer, recent_bleu4, is_best)\n",
        "\n",
        "\n",
        "def train(train_loader, encoder, decoder, criterion, encoder_optimizer, decoder_optimizer, epoch, epochs):\n",
        "    \"\"\"\n",
        "    Performs one epoch's training.\n",
        "\n",
        "    :param train_loader: DataLoader for training data\n",
        "    :param encoder: encoder model\n",
        "    :param decoder: decoder model\n",
        "    :param criterion: loss layer\n",
        "    :param encoder_optimizer: optimizer to update encoder's weights (if fine-tuning)\n",
        "    :param decoder_optimizer: optimizer to update decoder's weights\n",
        "    :param epoch: epoch number\n",
        "    :param epochs: termination epoch\n",
        "    \"\"\"\n",
        "\n",
        "    decoder.train()  # train mode (dropout and batchnorm is used)\n",
        "    encoder.train()\n",
        "\n",
        "    batch_time = AverageMeter()  # forward prop. + back prop. time\n",
        "    data_time = AverageMeter()  # data loading time\n",
        "    losses = AverageMeter()  # loss (per word decoded)\n",
        "    top5accs = AverageMeter()  # top5 accuracy\n",
        "\n",
        "    start = time.time()\n",
        "\n",
        "    # Batches\n",
        "    for i, (imgs, caps, caplens) in enumerate(train_loader):\n",
        "        data_time.update(time.time() - start)\n",
        "\n",
        "        # Move to GPU, if available\n",
        "        imgs = imgs.to(device)\n",
        "        caps = caps.to(device)\n",
        "        caplens = caplens.to(device)\n",
        "\n",
        "        # Forward prop.\n",
        "        imgs = encoder(imgs)\n",
        "        scores, caps_sorted, decode_lengths, alphas, sort_ind = decoder(imgs, caps, caplens, epoch, epochs)\n",
        "\n",
        "        # Since we decoded starting with <start>, the targets are all words after <start>, up to <end>\n",
        "        targets = caps_sorted[:, 1:]\n",
        "\n",
        "        # Remove timesteps that we didn't decode at, or are pads\n",
        "        # pack_padded_sequence is an easy trick to do this\n",
        "        scores = pack_padded_sequence(scores, decode_lengths, batch_first=True).data\n",
        "        targets = pack_padded_sequence(targets, decode_lengths, batch_first=True).data\n",
        "\n",
        "        # Calculate loss\n",
        "        loss = criterion(scores, targets)\n",
        "\n",
        "        # Add doubly stochastic attention regularization\n",
        "        loss += alpha_c * ((1. - alphas.sum(dim=1)) ** 2).mean()\n",
        "\n",
        "        # Back prop.\n",
        "        decoder_optimizer.zero_grad()\n",
        "        if encoder_optimizer is not None:\n",
        "            encoder_optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "\n",
        "        # Clip gradients\n",
        "        if grad_clip is not None:\n",
        "            clip_gradient(decoder_optimizer, grad_clip)\n",
        "            if encoder_optimizer is not None:\n",
        "                clip_gradient(encoder_optimizer, grad_clip)\n",
        "\n",
        "        # Update weights\n",
        "        decoder_optimizer.step()\n",
        "        if encoder_optimizer is not None:\n",
        "            encoder_optimizer.step()\n",
        "\n",
        "        # Keep track of metrics\n",
        "        top5 = accuracy(scores, targets, 5)\n",
        "        losses.update(loss.item(), sum(decode_lengths))\n",
        "        top5accs.update(top5, sum(decode_lengths))\n",
        "        batch_time.update(time.time() - start)\n",
        "\n",
        "        start = time.time()\n",
        "\n",
        "        # Print status\n",
        "        if i % print_freq == 0:\n",
        "            print('Epoch: [{0}][{1}/{2}]\\t'\n",
        "                  'Batch Time {batch_time.val:.3f} ({batch_time.avg:.3f})\\t'\n",
        "                  'Data Load Time {data_time.val:.3f} ({data_time.avg:.3f})\\t'\n",
        "                  'Loss {loss.val:.4f} ({loss.avg:.4f})\\t'\n",
        "                  'Top-5 Accuracy {top5.val:.3f} ({top5.avg:.3f})'.format(epoch, i, len(train_loader),\n",
        "                                                                          batch_time=batch_time,\n",
        "                                                                          data_time=data_time, loss=losses,\n",
        "                                                                          top5=top5accs))\n",
        "\n",
        "\n",
        "def validate(val_loader, encoder, decoder, criterion):\n",
        "    \"\"\"\n",
        "    Performs one epoch's validation.\n",
        "\n",
        "    :param val_loader: DataLoader for validation data.\n",
        "    :param encoder: encoder model\n",
        "    :param decoder: decoder model\n",
        "    :param criterion: loss layer\n",
        "    :return: BLEU-4 score\n",
        "    \"\"\"\n",
        "    decoder.eval()  # eval mode (no dropout or batchnorm)\n",
        "    if encoder is not None:\n",
        "        encoder.eval()\n",
        "\n",
        "    batch_time = AverageMeter()\n",
        "    losses = AverageMeter()\n",
        "    top5accs = AverageMeter()\n",
        "\n",
        "    start = time.time()\n",
        "\n",
        "    references = list()  # references (true captions) for calculating BLEU-4 score\n",
        "    hypotheses = list()  # hypotheses (predictions)\n",
        "\n",
        "    # explicitly disable gradient calculation to avoid CUDA memory error\n",
        "    # solves the issue #57\n",
        "    with torch.no_grad():\n",
        "        # Batches\n",
        "        for i, (imgs, caps, caplens, allcaps) in enumerate(val_loader):\n",
        "\n",
        "            # Move to device, if available\n",
        "            imgs = imgs.to(device)\n",
        "            caps = caps.to(device)\n",
        "            caplens = caplens.to(device)\n",
        "\n",
        "            # Forward prop.\n",
        "            if encoder is not None:\n",
        "                imgs = encoder(imgs)\n",
        "            scores, caps_sorted, decode_lengths, alphas, sort_ind = decoder(imgs, caps, caplens)\n",
        "\n",
        "            # Since we decoded starting with <start>, the targets are all words after <start>, up to <end>\n",
        "            targets = caps_sorted[:, 1:]\n",
        "\n",
        "            # Remove timesteps that we didn't decode at, or are pads\n",
        "            # pack_padded_sequence is an easy trick to do this\n",
        "            scores_copy = scores.clone()\n",
        "            scores = pack_padded_sequence(scores, decode_lengths, batch_first=True).data\n",
        "            targets = pack_padded_sequence(targets, decode_lengths, batch_first=True).data\n",
        "\n",
        "            # Calculate loss\n",
        "            loss = criterion(scores, targets)\n",
        "\n",
        "            # Add doubly stochastic attention regularization\n",
        "            loss += alpha_c * ((1. - alphas.sum(dim=1)) ** 2).mean()\n",
        "\n",
        "            # Keep track of metrics\n",
        "            losses.update(loss.item(), sum(decode_lengths))\n",
        "            top5 = accuracy(scores, targets, 5)\n",
        "            top5accs.update(top5, sum(decode_lengths))\n",
        "            batch_time.update(time.time() - start)\n",
        "\n",
        "            start = time.time()\n",
        "\n",
        "            if i % print_freq == 0:\n",
        "                print('Validation: [{0}/{1}]\\t'\n",
        "                      'Batch Time {batch_time.val:.3f} ({batch_time.avg:.3f})\\t'\n",
        "                      'Loss {loss.val:.4f} ({loss.avg:.4f})\\t'\n",
        "                      'Top-5 Accuracy {top5.val:.3f} ({top5.avg:.3f})\\t'.format(i, len(val_loader), batch_time=batch_time,\n",
        "                                                                                loss=losses, top5=top5accs))\n",
        "\n",
        "            # Store references (true captions), and hypothesis (prediction) for each image\n",
        "            # If for n images, we have n hypotheses, and references a, b, c... for each image, we need -\n",
        "            # references = [[ref1a, ref1b, ref1c], [ref2a, ref2b], ...], hypotheses = [hyp1, hyp2, ...]\n",
        "\n",
        "            # References\n",
        "            allcaps = allcaps[sort_ind]  # because images were sorted in the decoder\n",
        "            for j in range(allcaps.shape[0]):\n",
        "                img_caps = allcaps[j].tolist()\n",
        "                img_captions = list(\n",
        "                    map(lambda c: [w for w in c if w not in {word_map['<start>'], word_map['<pad>']}],\n",
        "                        img_caps))  # remove <start> and pads\n",
        "                references.append(img_captions)\n",
        "\n",
        "            # Hypotheses\n",
        "            _, preds = torch.max(scores_copy, dim=2)\n",
        "            preds = preds.tolist()\n",
        "            temp_preds = list()\n",
        "            for j, p in enumerate(preds):\n",
        "                temp_preds.append(preds[j][:decode_lengths[j]])  # remove pads\n",
        "            preds = temp_preds\n",
        "            hypotheses.extend(preds)\n",
        "\n",
        "            assert len(references) == len(hypotheses)\n",
        "\n",
        "        # Calculate BLEU-4 scores\n",
        "        bleu4 = corpus_bleu(references, hypotheses)\n",
        "\n",
        "        print(\n",
        "            '\\n * LOSS - {loss.avg:.3f}, TOP-5 ACCURACY - {top5.avg:.3f}, BLEU-4 - {bleu}\\n'.format(\n",
        "                loss=losses,\n",
        "                top5=top5accs,\n",
        "                bleu=bleu4))\n",
        "\n",
        "    return bleu4\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    main()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "fYdyTiGRV4zX",
        "outputId": "92a98619-b1d5-4e23-fd16-32965f1abaa4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:118: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 10 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 13 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-13-9a64aefa99da>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m    214\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    215\u001b[0m         \u001b[0;31m# Load model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 216\u001b[0;31m         \u001b[0mcheckpoint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmap_location\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# Replace 'load' by 'as_tensor'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    217\u001b[0m         \u001b[0mdecoder\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheckpoint\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'decoder'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    218\u001b[0m         \u001b[0mdecoder\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdecoder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\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.7/dist-packages/torch/serialization.py\u001b[0m in \u001b[0;36mload\u001b[0;34m(f, map_location, pickle_module, **pickle_load_args)\u001b[0m\n\u001b[1;32m    592\u001b[0m         \u001b[0mpickle_load_args\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'encoding'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'utf-8'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    593\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 594\u001b[0;31m     \u001b[0;32mwith\u001b[0m \u001b[0m_open_file_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'rb'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mopened_file\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    595\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0m_is_zipfile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mopened_file\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    596\u001b[0m             \u001b[0;31m# The zipfile reader is going to advance the current file position.\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.7/dist-packages/torch/serialization.py\u001b[0m in \u001b[0;36m_open_file_like\u001b[0;34m(name_or_buffer, mode)\u001b[0m\n\u001b[1;32m    228\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_open_file_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\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    229\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0m_is_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname_or_buffer\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--> 230\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0m_open_file\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\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    231\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    232\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;34m'w'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmode\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.7/dist-packages/torch/serialization.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, name, mode)\u001b[0m\n\u001b[1;32m    209\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0m_open_file\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_opener\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    210\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\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--> 211\u001b[0;31m         \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_open_file\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\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    212\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    213\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__exit__\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[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/content/drive/MyDrive/GGColab/BE1_Image_Captionning/BEST_vgg_LSTM_False_checkpoint_flickr8k_5_cap_per_img_5_min_word_freq.pth.tar'"
          ]
        }
      ],
      "source": [
        "###################################\n",
        "# Content of caption.py\n",
        "###################################\n",
        "\n",
        "import torch\n",
        "import torch.nn.functional as F\n",
        "import numpy as np\n",
        "import json\n",
        "import torchvision.transforms as transforms\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.cm as cm\n",
        "import skimage.transform\n",
        "import easydict\n",
        "import argparse\n",
        "#from scipy.misc import imresize  # suppression de scipy.misc.imread qui n'existe plus\n",
        "from PIL import Image\n",
        "from imageio import imread\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "\n",
        "def caption_image_beam_search(encoder, decoder, image_path, word_map, cell_type, beam_size=3):\n",
        "    \"\"\"\n",
        "    Reads an image and captions it with beam search.\n",
        "\n",
        "    :param encoder: encoder model\n",
        "    :param decoder: decoder model\n",
        "    :param image_path: path to image\n",
        "    :param word_map: word map\n",
        "    :param beam_size: number of sequences to consider at each decode-step\n",
        "    :return: caption, weights for visualization\n",
        "    \"\"\"\n",
        "\n",
        "    k = beam_size\n",
        "    vocab_size = len(word_map)\n",
        "\n",
        "    # Read image and process\n",
        "    img = imread(image_path)  # Provient de imageio, remplacé car scipy.misc.imread n'existe plus\n",
        "    if len(img.shape) == 2:\n",
        "        img = img[:, :, np.newaxis]\n",
        "        img = np.concatenate([img, img, img], axis=2)\n",
        "    img = np.array(Image.fromarray(img).resize(size=(256, 256)))   # Previously imresize(img, (256, 256)) with scipy.misc. Here shape (256, 256, 3)\n",
        "    img = np.transpose(img,[2, 0, 1]) # Then shape (3, 256, 256)\n",
        "    img = img / 255.  # Normalisation\n",
        "    img = torch.FloatTensor(img).to(device)  # Torch Tensor format, to use GPU\n",
        "    normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
        "                                     std=[0.229, 0.224, 0.225])\n",
        "    transform = transforms.Compose([normalize])\n",
        "    image = transform(img)  # (3, 256, 256)\n",
        "\n",
        "    # Encode\n",
        "    image = image.unsqueeze(0)  # (1, 3, 256, 256)\n",
        "    encoder_out = encoder(image)  # (1, enc_image_size, enc_image_size, encoder_dim)\n",
        "    enc_image_size = encoder_out.size(1)  # 14 pr ResNet\n",
        "    encoder_dim = encoder_out.size(3)  # 2048 pr ResNet\n",
        "    # encoder_out.shape : (1, 14, 14, 2048)\n",
        "\n",
        "    # Flatten encoding\n",
        "    encoder_out = encoder_out.view(1, -1, encoder_dim)  # (1, num_pixels, encoder_dim), 14x14 et 2048 pr ResNet\n",
        "    num_pixels = encoder_out.size(1)  # 14x14\n",
        "\n",
        "    # We'll treat the problem as having a batch size of k\n",
        "    encoder_out = encoder_out.expand(k, num_pixels, encoder_dim)  # (k, num_pixels, encoder_dim)   # On répète donc k x la sortie de l'encoder précédamment calculé. On rappelle : k = beam_size\n",
        "\n",
        "    # Tensor to store top k previous words at each step; now they're just <start>\n",
        "    k_prev_words = torch.LongTensor([[word_map['<start>']]] * k).to(device)  # (k, 1), chaque phrase commence par un <SOS> (Start of sentence)\n",
        "    # Tensor to store top k sequences; now they're just <start>\n",
        "    seqs = k_prev_words  # (k, 1)\n",
        "\n",
        "    # Tensor to store top k sequences' scores; now they're just 0\n",
        "    top_k_scores = torch.zeros(k, 1).to(device)  # (k, 1)\n",
        "\n",
        "    # Tensor to store top k sequences' alphas; now they're just 1s\n",
        "    seqs_alpha = torch.ones(k, 1, enc_image_size, enc_image_size).to(device)  # (k, 1, enc_image_size, enc_image_size)\n",
        "\n",
        "    # Lists to store completed sequences, their alphas and scores\n",
        "    complete_seqs = list()\n",
        "    complete_seqs_alpha = list()\n",
        "    complete_seqs_scores = list()\n",
        "\n",
        "    # Start decoding\n",
        "    step = 1\n",
        "    h, c = decoder.init_hidden_state(encoder_out)\n",
        "\n",
        "    # s is a number less than or equal to k, because sequences are removed from this process once they hit <end>\n",
        "    while True:\n",
        "        # We have to find the k best words for the k previously selected words (Concept of Beam Search)\n",
        "        embeddings = decoder.embedding(k_prev_words).squeeze(1)  # (s, embed_dim)\n",
        "\n",
        "        awe, alpha = decoder.attention(encoder_out, h)  # (s, encoder_dim), (s, num_pixels)\n",
        "\n",
        "        alpha = alpha.view(-1, enc_image_size, enc_image_size)  # (s, enc_image_size, enc_image_size)  # This is just a resize, to visualise the attention on the image\n",
        "\n",
        "        gate = decoder.sigmoid(decoder.f_beta(h))  # gating scalar, (s, encoder_dim)  # WHAT THE FUCK IS f_beta ?! Sure a gate but I haven't seen it in any course\n",
        "        awe = gate * awe\n",
        "\n",
        "        if cell_type=='LSTM':\n",
        "          h, c = decoder.decode_step(torch.cat([embeddings, awe], dim=1), (h, c))  # (s, decoder_dim)  # On passe à travers la cell LSTM\n",
        "        elif cell_type=='GRU':\n",
        "          h = decoder.decode_step(torch.cat([embeddings, awe], dim=1), h)  # (s, decoder_dim)  # On passe à travers la cell GRU\n",
        "        else:\n",
        "          return('Enter a valid RNN Cell name')\n",
        "\n",
        "        scores = decoder.fc(h)  # (s, vocab_size)   \n",
        "        scores = F.log_softmax(scores, dim=1)  # We compute the score to choose the k best words for this current-previously-selected word\n",
        "\n",
        "        # Add\n",
        "        scores = top_k_scores.expand_as(scores) + scores  # (s, vocab_size) # For the k current Beam-sentences, we compute the scores to select the next words\n",
        "\n",
        "        # For the first step, all k points will have the same scores (since same k previous words, h, c)\n",
        "        if step == 1:\n",
        "            top_k_scores, top_k_words = scores[0].topk(k, 0, True, True)  # (s)\n",
        "        else:\n",
        "            # Unroll and find top scores, and their unrolled indices\n",
        "            top_k_scores, top_k_words = scores.view(-1).topk(k, 0, True, True)  # (s)  # And among the k*vocab_size possibilities, we choose the best k sentences.\n",
        "\n",
        "        # Convert unrolled indices to actual indices of scores\"\n",
        "        prev_word_inds =  top_k_words // vocab_size # Error previously because the division wasn't floored like now (top_k_words / vocab_size  # (s))\n",
        "        next_word_inds = top_k_words % vocab_size  # (s)\n",
        "        print()\n",
        "        # Add new words to sequences, alphas\n",
        "        seqs = torch.cat([seqs[prev_word_inds], next_word_inds.unsqueeze(1)], dim=1)  # (s, step+1)\n",
        "        seqs_alpha = torch.cat([seqs_alpha[prev_word_inds], alpha[prev_word_inds].unsqueeze(1)],\n",
        "                               dim=1)  # (s, step+1, enc_image_size, enc_image_size)\n",
        "\n",
        "        # Which sequences are incomplete (didn't reach <end>)?\n",
        "        incomplete_inds = [ind for ind, next_word in enumerate(next_word_inds) if\n",
        "                           next_word != word_map['<end>']]\n",
        "        complete_inds = list(set(range(len(next_word_inds))) - set(incomplete_inds))\n",
        "\n",
        "        # Set aside complete sequences\n",
        "        if len(complete_inds) > 0:\n",
        "            complete_seqs.extend(seqs[complete_inds].tolist())\n",
        "            complete_seqs_alpha.extend(seqs_alpha[complete_inds].tolist())\n",
        "            complete_seqs_scores.extend(top_k_scores[complete_inds])\n",
        "        k -= len(complete_inds)  # reduce beam length accordingly\n",
        "\n",
        "        # Proceed with incomplete sequences\n",
        "        if k == 0:\n",
        "            break\n",
        "        seqs = seqs[incomplete_inds]\n",
        "        seqs_alpha = seqs_alpha[incomplete_inds]\n",
        "        h = h[prev_word_inds[incomplete_inds]]\n",
        "        c = c[prev_word_inds[incomplete_inds]]\n",
        "        encoder_out = encoder_out[prev_word_inds[incomplete_inds]]\n",
        "        top_k_scores = top_k_scores[incomplete_inds].unsqueeze(1)\n",
        "        k_prev_words = next_word_inds[incomplete_inds].unsqueeze(1)\n",
        "\n",
        "        # Break if things have been going on too long\n",
        "        if step > 50:\n",
        "            break\n",
        "        step += 1\n",
        "\n",
        "    i = complete_seqs_scores.index(max(complete_seqs_scores))\n",
        "    seq = complete_seqs[i]\n",
        "    alphas = complete_seqs_alpha[i]\n",
        "\n",
        "    return seq, alphas\n",
        "\n",
        "\n",
        "def visualize_att(image_path, seq, alphas, rev_word_map, smooth=True):\n",
        "    \"\"\"\n",
        "    Visualizes caption with weights at every word.\n",
        "\n",
        "    Adapted from paper authors' repo: https://github.com/kelvinxu/arctic-captions/blob/master/alpha_visualization.ipynb\n",
        "\n",
        "    :param image_path: path to image that has been captioned\n",
        "    :param seq: caption\n",
        "    :param alphas: weights\n",
        "    :param rev_word_map: reverse word mapping, i.e. ix2word\n",
        "    :param smooth: smooth weights?\n",
        "    \"\"\"\n",
        "    image = Image.open(image_path)\n",
        "    image = image.resize([14 * 24, 14 * 24], Image.LANCZOS)\n",
        "\n",
        "    words = [rev_word_map[ind] for ind in seq]\n",
        "\n",
        "    for t in range(len(words)):\n",
        "        if t > 50:\n",
        "            break\n",
        "        plt.subplot(np.ceil(len(words) / 5.), 5, t + 1)\n",
        "\n",
        "        plt.text(0, 1, '%s' % (words[t]), color='black', backgroundcolor='white', fontsize=12)\n",
        "        plt.imshow(image)\n",
        "        current_alpha = alphas[t, :]\n",
        "        if smooth:\n",
        "            alpha = skimage.transform.pyramid_expand(current_alpha.numpy(), upscale=24, sigma=8)\n",
        "        else:\n",
        "            alpha = skimage.transform.resize(current_alpha.numpy(), [14 * 24, 14 * 24])\n",
        "        if t == 0:\n",
        "            plt.imshow(alpha, alpha=0)\n",
        "        else:\n",
        "            plt.imshow(alpha, alpha=0.8)\n",
        "        plt.set_cmap(cm.Greys_r)\n",
        "        plt.axis('off')\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    models_to_train = [['resnet', 'LSTM', False, 2048], ['resnet', 'GRU', False, 2048], ['vgg', 'LSTM', False, 512], ['resnet', 'LSTM', True, 2048]]\n",
        "    for cnn_rnn_structure in models_to_train:\n",
        "        #cnn_rnn_structure = models_to_train[0]\n",
        "        cell_type = cnn_rnn_structure[1]\n",
        "        image_number = '102351840_323e3de834'\n",
        "\n",
        "        parser = argparse.ArgumentParser(description='Show, Attend, and Tell - Tutorial - Generate Caption')\n",
        "        parser.add_argument('--img', '-i', default=r'/content/drive/MyDrive/GGColab/BE1_Image_Captionning/Flicker8k_Dataset/{}.jpg'.format(image_number), help='path to image')  # img 667626_18933d713e.jpg\n",
        "        parser.add_argument('--word_map', '-wm', default=r'/content/drive/MyDrive/GGColab/BE1_Image_Captionning/prepared_data/WORDMAP_flickr8k_5_cap_per_img_5_min_word_freq.json', help='path to word map JSON')\n",
        "        parser.add_argument('--beam_size', '-b', default=5, type=int, help='beam size for beam search')\n",
        "        parser.add_argument('--dont_smooth', dest='smooth', action='store_false', help='do not smooth alpha overlay')\n",
        "        parser.add_argument('--model', '-m', default=r'/content/drive/MyDrive/GGColab/BE1_Image_Captionning/BEST_{}_{}_{}_checkpoint_flickr8k_5_cap_per_img_5_min_word_freq.pth.tar'.format(cnn_rnn_structure[0], cnn_rnn_structure[1], cnn_rnn_structure[2]) , help='path to model')\n",
        "        parser.add_argument(\"-f\", \"--fff\", help=\"a dummy argument to fool ipython\", default=\"1\")\n",
        "        args = parser.parse_args()\n",
        "        \n",
        "        # Load model\n",
        "        checkpoint = torch.load(args.model, map_location=str(device))  # Replace 'load' by 'as_tensor'\n",
        "        decoder = checkpoint['decoder']\n",
        "        decoder = decoder.to(device)\n",
        "        decoder.eval()\n",
        "        encoder = checkpoint['encoder']\n",
        "        encoder = encoder.to(device)\n",
        "        encoder.eval()\n",
        "\n",
        "        # Load word map (word2ix)\n",
        "        with open(args.word_map, 'r') as j:\n",
        "            word_map = json.load(j)\n",
        "        rev_word_map = {v: k for k, v in word_map.items()}  # ix2word\n",
        "\n",
        "        # Encode, decode with attention and beam search\n",
        "        seq, alphas = caption_image_beam_search(encoder, decoder, args.img, word_map, cell_type,args.beam_size)\n",
        "        alphas = torch.FloatTensor(alphas)\n",
        "\n",
        "        # Visualize caption and attention of best sequence\n",
        "        visualize_att(args.img, seq, alphas, rev_word_map, args.smooth)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sMbDvrfDWVw-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8dc5f6a8-3290-44f2-da7a-c64f02365062"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "We are evaluating a model with resnet as a CNN-encoder architecture and LSTM as the RNN-encoder architecture\n",
            "We are evaluating a model with resnet as a CNN-encoder architecture and GRU as the RNN-encoder architecture\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "EVALUATING AT BEAM SIZE 1:   0%|          | 0/5000 [00:00<?, ?it/s]/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:123: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "EVALUATING AT BEAM SIZE 1: 100%|██████████| 5000/5000 [55:40<00:00,  1.50it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "BLEU-4 score @ beam size of 1 is 0.0955.\n"
          ]
        }
      ],
      "source": [
        "###################################\n",
        "# Content of eval.py\n",
        "###################################\n",
        "\n",
        "import torch.backends.cudnn as cudnn\n",
        "import torch.optim\n",
        "import torch.utils.data\n",
        "import torchvision.transforms as transforms\n",
        "# from datasets import * # dataset already in the notebook\n",
        "# from utils import * # utils already in the notebook\n",
        "from nltk.translate.bleu_score import corpus_bleu\n",
        "import torch.nn.functional as F\n",
        "from tqdm import tqdm\n",
        "\n",
        "# Parameters\n",
        "data_folder = r'/content/drive/MyDrive/GGColab/BE1_Image_Captionning/prepared_data'  # folder with data files saved by create_input_files.py\n",
        "data_name = 'flickr8k_5_cap_per_img_5_min_word_freq'  # base name shared by data files \n",
        "word_map_file = r'/content/drive/MyDrive/GGColab/BE1_Image_Captionning/prepared_data/WORDMAP_flickr8k_5_cap_per_img_5_min_word_freq.json'  # word map, ensure it's the same the data was encoded with and the model was trained with\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")  # sets device for model and PyTorch tensors\n",
        "cudnn.benchmark = True  # set to true only if inputs to model are fixed size; otherwise lot of computational overhead\n",
        "\n",
        "# Load word map (word2ix)\n",
        "with open(word_map_file, 'r') as j:\n",
        "    word_map = json.load(j)\n",
        "rev_word_map = {v: k for k, v in word_map.items()}\n",
        "vocab_size = len(word_map)\n",
        "\n",
        "# Normalization transform\n",
        "normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
        "                                std=[0.229, 0.224, 0.225])\n",
        "\n",
        "\n",
        "def evaluate(beam_size, cell_type):\n",
        "    \"\"\"\n",
        "    Evaluation\n",
        "\n",
        "    :param beam_size: beam size at which to generate captions for evaluation\n",
        "    :return: BLEU-4 score\n",
        "    \"\"\"\n",
        "    # DataLoader\n",
        "    loader = torch.utils.data.DataLoader(\n",
        "        CaptionDataset(data_folder, data_name, 'TEST', transform=transforms.Compose([normalize])),\n",
        "        batch_size=1, shuffle=True, num_workers=1, pin_memory=True)\n",
        "    \n",
        "    # TODO: Batched Beam Search\n",
        "    # Therefore, do not use a batch_size greater than 1 - IMPORTANT!\n",
        "\n",
        "    # Lists to store references (true captions), and hypothesis (prediction) for each image\n",
        "    # If for n images, we have n hypotheses, and references a, b, c... for each image, we need -\n",
        "    # references = [[ref1a, ref1b, ref1c], [ref2a, ref2b], ...], hypotheses = [hyp1, hyp2, ...]\n",
        "    references = list()\n",
        "    hypotheses = list()\n",
        "\n",
        "    # For each image\n",
        "    for i, (image, caps, caplens, allcaps) in enumerate(\n",
        "            tqdm(loader, desc=\"EVALUATING AT BEAM SIZE \" + str(beam_size))):\n",
        "\n",
        "        k = beam_size\n",
        "\n",
        "        # Move to GPU device, if available\n",
        "        image = image.to(device)  # (1, 3, 256, 256)\n",
        "\n",
        "        # Encode\n",
        "        encoder_out = encoder(image)  # (1, enc_image_size, enc_image_size, encoder_dim)\n",
        "        enc_image_size = encoder_out.size(1)\n",
        "        encoder_dim = encoder_out.size(3)\n",
        "\n",
        "        # Flatten encoding\n",
        "        encoder_out = encoder_out.view(1, -1, encoder_dim)  # (1, num_pixels, encoder_dim)\n",
        "        num_pixels = encoder_out.size(1)\n",
        "\n",
        "        # We'll treat the problem as having a batch size of k\n",
        "        encoder_out = encoder_out.expand(k, num_pixels, encoder_dim)  # (k, num_pixels, encoder_dim)\n",
        "\n",
        "        # Tensor to store top k previous words at each step; now they're just <start>\n",
        "        k_prev_words = torch.LongTensor([[word_map['<start>']]] * k).to(device)  # (k, 1)\n",
        "\n",
        "        # Tensor to store top k sequences; now they're just <start>\n",
        "        seqs = k_prev_words  # (k, 1)\n",
        "\n",
        "        # Tensor to store top k sequences' scores; now they're just 0\n",
        "        top_k_scores = torch.zeros(k, 1).to(device)  # (k, 1)\n",
        "\n",
        "        # Lists to store completed sequences and scores\n",
        "        complete_seqs = list()\n",
        "        complete_seqs_scores = list()\n",
        "\n",
        "        # Start decoding\n",
        "        step = 1\n",
        "        h, c = decoder.init_hidden_state(encoder_out)\n",
        "\n",
        "        # s is a number less than or equal to k, because sequences are removed from this process once they hit <end>\n",
        "        while True:\n",
        "\n",
        "            embeddings = decoder.embedding(k_prev_words).squeeze(1)  # (s, embed_dim)\n",
        "\n",
        "            awe, _ = decoder.attention(encoder_out, h)  # (s, encoder_dim), (s, num_pixels)\n",
        "\n",
        "            gate = decoder.sigmoid(decoder.f_beta(h))  # gating scalar, (s, encoder_dim)\n",
        "            awe = gate * awe\n",
        "\n",
        "            if cell_type=='LSTM':\n",
        "              h, c = decoder.decode_step(torch.cat([embeddings, awe], dim=1), (h, c))  # (s, decoder_dim)  # On passe à travers la cell LSTM\n",
        "            elif cell_type=='GRU':\n",
        "              h = decoder.decode_step(torch.cat([embeddings, awe], dim=1), h)  # (s, decoder_dim)  # On passe à travers la cell GRU\n",
        "            else:\n",
        "              return('Enter a valid RNN Cell name')\n",
        "\n",
        "            scores = decoder.fc(h)  # (s, vocab_size)\n",
        "            scores = F.log_softmax(scores, dim=1)\n",
        "\n",
        "            # Add\n",
        "            scores = top_k_scores.expand_as(scores) + scores  # (s, vocab_size)\n",
        "\n",
        "            # For the first step, all k points will have the same scores (since same k previous words, h, c)\n",
        "            if step == 1:\n",
        "                top_k_scores, top_k_words = scores[0].topk(k, 0, True, True)  # (s)\n",
        "            else:\n",
        "                # Unroll and find top scores, and their unrolled indices\n",
        "                top_k_scores, top_k_words = scores.view(-1).topk(k, 0, True, True)  # (s)\n",
        "\n",
        "            # Convert unrolled indices to actual indices of scores\n",
        "            prev_word_inds = top_k_words // vocab_size  # (s)  # Same error as in the previous part of the program\n",
        "            next_word_inds = top_k_words % vocab_size  # (s)\n",
        "\n",
        "            # Add new words to sequences\n",
        "            seqs = torch.cat([seqs[prev_word_inds], next_word_inds.unsqueeze(1)], dim=1)  # (s, step+1)\n",
        "\n",
        "            # Which sequences are incomplete (didn't reach <end>)?\n",
        "            incomplete_inds = [ind for ind, next_word in enumerate(next_word_inds) if\n",
        "                               next_word != word_map['<end>']]\n",
        "            complete_inds = list(set(range(len(next_word_inds))) - set(incomplete_inds))\n",
        "\n",
        "            # Set aside complete sequences\n",
        "            if len(complete_inds) > 0:\n",
        "                complete_seqs.extend(seqs[complete_inds].tolist())\n",
        "                complete_seqs_scores.extend(top_k_scores[complete_inds])\n",
        "            k -= len(complete_inds)  # reduce beam length accordingly\n",
        "\n",
        "            # Proceed with incomplete sequences\n",
        "            if k == 0:\n",
        "                break\n",
        "            seqs = seqs[incomplete_inds]\n",
        "            h = h[prev_word_inds[incomplete_inds]]\n",
        "            c = c[prev_word_inds[incomplete_inds]]\n",
        "            encoder_out = encoder_out[prev_word_inds[incomplete_inds]]\n",
        "            top_k_scores = top_k_scores[incomplete_inds].unsqueeze(1)\n",
        "            k_prev_words = next_word_inds[incomplete_inds].unsqueeze(1)\n",
        "\n",
        "            # Break if things have been going on too long\n",
        "            if step > 50:\n",
        "                break\n",
        "            step += 1\n",
        "        \n",
        "        if step<=50:\n",
        "          i = complete_seqs_scores.index(max(complete_seqs_scores))\n",
        "          seq = complete_seqs[i]\n",
        "\n",
        "        # References\n",
        "        img_caps = allcaps[0].tolist()\n",
        "        img_captions = list(\n",
        "            map(lambda c: [w for w in c if w not in {word_map['<start>'], word_map['<end>'], word_map['<pad>']}],\n",
        "                img_caps))  # remove <start> and pads\n",
        "        references.append(img_captions)\n",
        "\n",
        "        # Hypotheses\n",
        "        hypotheses.append([w for w in seq if w not in {word_map['<start>'], word_map['<end>'], word_map['<pad>']}])\n",
        "\n",
        "        assert len(references) == len(hypotheses)\n",
        "\n",
        "    # Calculate BLEU-4 scores\n",
        "    bleu4 = corpus_bleu(references, hypotheses)\n",
        "\n",
        "    return bleu4\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    # ['vgg', 'LSTM', False, 512], ['resnet', 'LSTM', True, 2048]\n",
        "    models_to_train = [['resnet', 'LSTM', False, 2048], ['resnet', 'GRU', False, 2048]]\n",
        "\n",
        "    for cnn_rnn_structure in models_to_train:\n",
        "      cell_type = cnn_rnn_structure[1]\n",
        "      print(\"We are evaluating a model with {} as a CNN-encoder architecture and {} as the RNN-encoder architecture\".format(cnn_rnn_structure[0], cnn_rnn_structure[1]))\n",
        "      checkpoint = r'/content/drive/MyDrive/GGColab/BE1_Image_Captionning/BEST_{}_{}_{}_checkpoint_flickr8k_5_cap_per_img_5_min_word_freq.pth.tar'.format(cnn_rnn_structure[0], cnn_rnn_structure[1], cnn_rnn_structure[2])  # model checkpoint  \n",
        "      # Load model\n",
        "      checkpoint = torch.load(checkpoint, map_location=str(device))\n",
        "      decoder = checkpoint['decoder']\n",
        "      decoder = decoder.to(device)\n",
        "      decoder.eval()\n",
        "      encoder = checkpoint['encoder']\n",
        "      encoder = encoder.to(device)\n",
        "      encoder.eval()\n",
        "    beam_size = 1\n",
        "    print(\"\\nBLEU-4 score @ beam size of %d is %.4f.\" % (beam_size, evaluate(beam_size, cell_type)))\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "name": "Copie de BE1_Image_Captioning.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "bedae02060dc4630873c027ac613647a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "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_09de16e8cf264ad7a8ab1624694cbd4e",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_b0a0f54fbaa547008042688df45c7a16",
              "IPY_MODEL_e885959fb3184173817f272e40767fbc",
              "IPY_MODEL_847e79bcb8264a79855be0ba061767a4"
            ]
          }
        },
        "09de16e8cf264ad7a8ab1624694cbd4e": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "b0a0f54fbaa547008042688df45c7a16": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_bce47f9cab4f47a195a150a19f1a569e",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": "100%",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_acd84c650f314498ae3071c80c3dbdcb"
          }
        },
        "e885959fb3184173817f272e40767fbc": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_view_name": "ProgressView",
            "style": "IPY_MODEL_ef32eaa2f4b1490488444d0a8a741375",
            "_dom_classes": [],
            "description": "",
            "_model_name": "FloatProgressModel",
            "bar_style": "success",
            "max": 178793939,
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": 178793939,
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "orientation": "horizontal",
            "min": 0,
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_c802e73a01d34b60bf80e365e7dd3862"
          }
        },
        "847e79bcb8264a79855be0ba061767a4": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_view_name": "HTMLView",
            "style": "IPY_MODEL_6af21699a3434258b268c62698fc044d",
            "_dom_classes": [],
            "description": "",
            "_model_name": "HTMLModel",
            "placeholder": "​",
            "_view_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "value": " 171M/171M [00:00&lt;00:00, 210MB/s]",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "description_tooltip": null,
            "_model_module": "@jupyter-widgets/controls",
            "layout": "IPY_MODEL_4d0cc1d1fce04db2ba176849f722cc4c"
          }
        },
        "bce47f9cab4f47a195a150a19f1a569e": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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"
          }
        },
        "acd84c650f314498ae3071c80c3dbdcb": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "ef32eaa2f4b1490488444d0a8a741375": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_view_name": "StyleView",
            "_model_name": "ProgressStyleModel",
            "description_width": "",
            "_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"
          }
        },
        "c802e73a01d34b60bf80e365e7dd3862": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "6af21699a3434258b268c62698fc044d": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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"
          }
        },
        "4d0cc1d1fce04db2ba176849f722cc4c": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
}