demo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/alex/anaconda3/envs/vilbert-mt/lib/python3.6/site-packages/tensorpack/callbacks/hooks.py:17: The name tf.train.SessionRunHook is deprecated. Please use tf.estimator.SessionRunHook instead.\n",
      "\n",
      "WARNING:tensorflow:From /home/alex/anaconda3/envs/vilbert-mt/lib/python3.6/site-packages/tensorpack/tfutils/optimizer.py:18: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
      "\n",
      "WARNING:tensorflow:From /home/alex/anaconda3/envs/vilbert-mt/lib/python3.6/site-packages/tensorpack/tfutils/sesscreate.py:20: The name tf.train.SessionCreator is deprecated. Please use tf.compat.v1.train.SessionCreator instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import os\n",
    "import torch\n",
    "import yaml\n",
    "\n",
    "sys.path.append('vilbert-multi-task/')\n",
    "\n",
    "from easydict import EasyDict as edict\n",
    "from pytorch_transformers.tokenization_bert import BertTokenizer\n",
    "from vilbert.datasets import ConceptCapLoaderTrain, ConceptCapLoaderVal\n",
    "from vilbert.vilbert import VILBertForVLTasks, BertConfig, BertForMultiModalPreTraining\n",
    "from vilbert.task_utils import LoadDatasetEval\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import PIL\n",
    "\n",
    "from maskrcnn_benchmark.config import cfg\n",
    "from maskrcnn_benchmark.layers import nms\n",
    "from maskrcnn_benchmark.modeling.detector import build_detection_model\n",
    "from maskrcnn_benchmark.structures.image_list import to_image_list\n",
    "from maskrcnn_benchmark.utils.model_serialization import load_state_dict\n",
    "from PIL import Image\n",
    "import cv2\n",
    "import argparse\n",
    "import glob\n",
    "from types import SimpleNamespace\n",
    "import pdb\n",
    "\n",
    "%matplotlib inline  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FeatureExtractor:\n",
    "    MAX_SIZE = 1333\n",
    "    MIN_SIZE = 800\n",
    "\n",
    "    def __init__(self):\n",
    "        self.args = self.get_parser()\n",
    "        self.detection_model = self._build_detection_model()\n",
    "\n",
    "    def get_parser(self):\n",
    "        parser = SimpleNamespace(model_file= 'vilbert-multi-task/data/detectron_model.pth',\n",
    "                                config_file='vilbert-multi-task/data/detectron_config.yaml',\n",
    "                                batch_size=1,\n",
    "                                num_features=100,\n",
    "                                feature_name=\"fc6\",\n",
    "                                confidence_threshold=0,\n",
    "                                background=False,\n",
    "                                partition=0)\n",
    "        return parser\n",
    "    \n",
    "    def _build_detection_model(self):\n",
    "        cfg.merge_from_file(self.args.config_file)\n",
    "        cfg.freeze()\n",
    "\n",
    "        model = build_detection_model(cfg)\n",
    "        checkpoint = torch.load(self.args.model_file, map_location=torch.device(\"cpu\"))\n",
    "\n",
    "        load_state_dict(model, checkpoint.pop(\"model\"))\n",
    "\n",
    "        model.to(\"cuda\")\n",
    "        model.eval()\n",
    "        return model\n",
    "\n",
    "    def _image_transform(self, path):\n",
    "        img = Image.open(path)\n",
    "        im = np.array(img).astype(np.float32)\n",
    "        # IndexError: too many indices for array, grayscale images\n",
    "        if len(im.shape) < 3:\n",
    "            im = np.repeat(im[:, :, np.newaxis], 3, axis=2)\n",
    "        im = im[:, :, ::-1]\n",
    "        im -= np.array([102.9801, 115.9465, 122.7717])\n",
    "        im_shape = im.shape\n",
    "        im_height = im_shape[0]\n",
    "        im_width = im_shape[1]\n",
    "        im_size_min = np.min(im_shape[0:2])\n",
    "        im_size_max = np.max(im_shape[0:2])\n",
    "\n",
    "        # Scale based on minimum size\n",
    "        im_scale = self.MIN_SIZE / im_size_min\n",
    "\n",
    "        # Prevent the biggest axis from being more than max_size\n",
    "        # If bigger, scale it down\n",
    "        if np.round(im_scale * im_size_max) > self.MAX_SIZE:\n",
    "            im_scale = self.MAX_SIZE / im_size_max\n",
    "\n",
    "        im = cv2.resize(\n",
    "            im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR\n",
    "        )\n",
    "        img = torch.from_numpy(im).permute(2, 0, 1)\n",
    "\n",
    "        im_info = {\"width\": im_width, \"height\": im_height}\n",
    "\n",
    "        return img, im_scale, im_info\n",
    "\n",
    "    def _process_feature_extraction(\n",
    "        self, output, im_scales, im_infos, feature_name=\"fc6\", conf_thresh=0\n",
    "    ):\n",
    "        batch_size = len(output[0][\"proposals\"])\n",
    "        n_boxes_per_image = [len(boxes) for boxes in output[0][\"proposals\"]]\n",
    "        score_list = output[0][\"scores\"].split(n_boxes_per_image)\n",
    "        score_list = [torch.nn.functional.softmax(x, -1) for x in score_list]\n",
    "        feats = output[0][feature_name].split(n_boxes_per_image)\n",
    "        cur_device = score_list[0].device\n",
    "\n",
    "        feat_list = []\n",
    "        info_list = []\n",
    "\n",
    "        for i in range(batch_size):\n",
    "            dets = output[0][\"proposals\"][i].bbox / im_scales[i]\n",
    "            scores = score_list[i]\n",
    "            max_conf = torch.zeros((scores.shape[0])).to(cur_device)\n",
    "            conf_thresh_tensor = torch.full_like(max_conf, conf_thresh)\n",
    "            start_index = 1\n",
    "            # Column 0 of the scores matrix is for the background class\n",
    "            if self.args.background:\n",
    "                start_index = 0\n",
    "            for cls_ind in range(start_index, scores.shape[1]):\n",
    "                cls_scores = scores[:, cls_ind]\n",
    "                keep = nms(dets, cls_scores, 0.5)\n",
    "                max_conf[keep] = torch.where(\n",
    "                    # Better than max one till now and minimally greater than conf_thresh\n",
    "                    (cls_scores[keep] > max_conf[keep])\n",
    "                    & (cls_scores[keep] > conf_thresh_tensor[keep]),\n",
    "                    cls_scores[keep],\n",
    "                    max_conf[keep],\n",
    "                )\n",
    "\n",
    "            sorted_scores, sorted_indices = torch.sort(max_conf, descending=True)\n",
    "            num_boxes = (sorted_scores[: self.args.num_features] != 0).sum()\n",
    "            keep_boxes = sorted_indices[: self.args.num_features]\n",
    "            feat_list.append(feats[i][keep_boxes])\n",
    "            bbox = output[0][\"proposals\"][i][keep_boxes].bbox / im_scales[i]\n",
    "            # Predict the class label using the scores\n",
    "            objects = torch.argmax(scores[keep_boxes][start_index:], dim=1)\n",
    "            cls_prob = torch.max(scores[keep_boxes][start_index:], dim=1)\n",
    "\n",
    "            info_list.append(\n",
    "                {\n",
    "                    \"bbox\": bbox.cpu().numpy(),\n",
    "                    \"num_boxes\": num_boxes.item(),\n",
    "                    \"objects\": objects.cpu().numpy(),\n",
    "                    \"image_width\": im_infos[i][\"width\"],\n",
    "                    \"image_height\": im_infos[i][\"height\"],\n",
    "                    \"cls_prob\": scores[keep_boxes].cpu().numpy(),\n",
    "                }\n",
    "            )\n",
    "\n",
    "        return feat_list, info_list\n",
    "\n",
    "    def get_detectron_features(self, image_paths):\n",
    "        img_tensor, im_scales, im_infos = [], [], []\n",
    "\n",
    "        for image_path in image_paths:\n",
    "            im, im_scale, im_info = self._image_transform(image_path)\n",
    "            img_tensor.append(im)\n",
    "            im_scales.append(im_scale)\n",
    "            im_infos.append(im_info)\n",
    "\n",
    "        # Image dimensions should be divisible by 32, to allow convolutions\n",
    "        # in detector to work\n",
    "        current_img_list = to_image_list(img_tensor, size_divisible=32)\n",
    "        current_img_list = current_img_list.to(\"cuda\")\n",
    "\n",
    "        with torch.no_grad():\n",
    "            output = self.detection_model(current_img_list)\n",
    "\n",
    "        feat_list = self._process_feature_extraction(\n",
    "            output,\n",
    "            im_scales,\n",
    "            im_infos,\n",
    "            self.args.feature_name,\n",
    "            self.args.confidence_threshold,\n",
    "        )\n",
    "\n",
    "        return feat_list\n",
    "\n",
    "    def _chunks(self, array, chunk_size):\n",
    "        for i in range(0, len(array), chunk_size):\n",
    "            yield array[i : i + chunk_size]\n",
    "\n",
    "    def _save_feature(self, file_name, feature, info):\n",
    "        file_base_name = os.path.basename(file_name)\n",
    "        file_base_name = file_base_name.split(\".\")[0]\n",
    "        info[\"image_id\"] = file_base_name\n",
    "        info[\"features\"] = feature.cpu().numpy()\n",
    "        file_base_name = file_base_name + \".npy\"\n",
    "\n",
    "        np.save(os.path.join(self.args.output_folder, file_base_name), info)\n",
    "\n",
    "    def extract_features(self, image_path):\n",
    "\n",
    "        features, infos = self.get_detectron_features([image_path])\n",
    "\n",
    "        return features, infos\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize_batch(batch):\n",
    "    return [tokenizer.convert_tokens_to_ids(sent) for sent in batch]\n",
    "\n",
    "def untokenize_batch(batch):\n",
    "    return [tokenizer.convert_ids_to_tokens(sent) for sent in batch]\n",
    "\n",
    "def detokenize(sent):\n",
    "    \"\"\" Roughly detokenizes (mainly undoes wordpiece) \"\"\"\n",
    "    new_sent = []\n",
    "    for i, tok in enumerate(sent):\n",
    "        if tok.startswith(\"##\"):\n",
    "            new_sent[len(new_sent) - 1] = new_sent[len(new_sent) - 1] + tok[2:]\n",
    "        else:\n",
    "            new_sent.append(tok)\n",
    "    return new_sent\n",
    "\n",
    "def printer(sent, should_detokenize=True):\n",
    "    if should_detokenize:\n",
    "        sent = detokenize(sent)[1:-1]\n",
    "    print(\" \".join(sent))\n",
    "\n",
    "\n",
    "# write arbitary string for given sentense. \n",
    "import _pickle as cPickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prediction(question, features, spatials, segment_ids, input_mask, image_mask, co_attention_mask, task_tokens, ):\n",
    "\n",
    "    (\n",
    "        vil_prediction, \n",
    "        vil_prediction_gqa, \n",
    "        vil_logit, \n",
    "        vil_binary_prediction,\n",
    "        vil_tri_prediction, \n",
    "        vision_prediction, \n",
    "        vision_logit, \n",
    "        linguisic_prediction, \n",
    "        linguisic_logit, \n",
    "        attn_data_list\n",
    "    ) = model(\n",
    "        question, \n",
    "        features, \n",
    "        spatials, \n",
    "        segment_ids, \n",
    "        input_mask, \n",
    "        image_mask, \n",
    "        co_attention_mask, \n",
    "        task_tokens, \n",
    "        output_all_attention_masks=True\n",
    "    )\n",
    "    \n",
    "    height, width = img.shape[0], img.shape[1]\n",
    "\n",
    "    \n",
    "    logits = torch.max(vil_prediction, 1)[1].data  # argmax\n",
    "    # Load VQA label to answers:\n",
    "    label2ans_path = os.path.join('vilbert-multi-task', 'data', \"datasets\", \"VQA\" ,\"cache\", \"trainval_label2ans.pkl\")\n",
    "    vqa_label2ans = cPickle.load(open(label2ans_path, \"rb\"))\n",
    "    answer = vqa_label2ans[logits[0].item()]\n",
    "    print(\"VQA: \" + answer)\n",
    "\n",
    "    # grounding: \n",
    "    logits_vision = torch.max(vision_logit, 1)[1].data\n",
    "    grounding_val, grounding_idx = torch.sort(vision_logit.view(-1), 0, True)\n",
    "\n",
    "    examples_per_row = 5\n",
    "    ncols = examples_per_row \n",
    "    nrows = 1\n",
    "    figsize = [12, ncols*20]     # figure size, inches\n",
    "    fig, ax = plt.subplots(nrows=nrows, ncols=ncols, figsize=figsize)\n",
    "\n",
    "    for i, axi in enumerate(ax.flat):\n",
    "        idx = grounding_idx[i]\n",
    "        val = grounding_val[i]\n",
    "        box = spatials[0][idx][:4].tolist()\n",
    "        y1 = int(box[1] * height)\n",
    "        y2 = int(box[3] * height)\n",
    "        x1 = int(box[0] * width)\n",
    "        x2 = int(box[2] * width)\n",
    "        patch = img[y1:y2,x1:x2]\n",
    "        axi.imshow(patch)\n",
    "        axi.axis('off')\n",
    "        axi.set_title(str(i) + \": \" + str(val.item()))\n",
    "\n",
    "    plt.axis('off')\n",
    "    plt.tight_layout(True)\n",
    "    plt.show()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def custom_prediction(query, task, features, infos):\n",
    "\n",
    "    tokens = tokenizer.encode(query)\n",
    "    tokens = tokenizer.add_special_tokens_single_sentence(tokens)\n",
    "\n",
    "    segment_ids = [0] * len(tokens)\n",
    "    input_mask = [1] * len(tokens)\n",
    "\n",
    "    max_length = 37\n",
    "    if len(tokens) < max_length:\n",
    "        # Note here we pad in front of the sentence\n",
    "        padding = [0] * (max_length - len(tokens))\n",
    "        tokens = tokens + padding\n",
    "        input_mask += padding\n",
    "        segment_ids += padding\n",
    "\n",
    "    text = torch.from_numpy(np.array(tokens)).cuda().unsqueeze(0)\n",
    "    input_mask = torch.from_numpy(np.array(input_mask)).cuda().unsqueeze(0)\n",
    "    segment_ids = torch.from_numpy(np.array(segment_ids)).cuda().unsqueeze(0)\n",
    "    task = torch.from_numpy(np.array(task)).cuda().unsqueeze(0)\n",
    "\n",
    "    num_image = len(infos)\n",
    "\n",
    "    feature_list = []\n",
    "    image_location_list = []\n",
    "    image_mask_list = []\n",
    "    for i in range(num_image):\n",
    "        image_w = infos[i]['image_width']\n",
    "        image_h = infos[i]['image_height']\n",
    "        feature = features[i]\n",
    "        num_boxes = feature.shape[0]\n",
    "\n",
    "        g_feat = torch.sum(feature, dim=0) / num_boxes\n",
    "        num_boxes = num_boxes + 1\n",
    "        feature = torch.cat([g_feat.view(1,-1), feature], dim=0)\n",
    "        boxes = infos[i]['bbox']\n",
    "        image_location = np.zeros((boxes.shape[0], 5), dtype=np.float32)\n",
    "        image_location[:,:4] = boxes\n",
    "        image_location[:,4] = (image_location[:,3] - image_location[:,1]) * (image_location[:,2] - image_location[:,0]) / (float(image_w) * float(image_h))\n",
    "        image_location[:,0] = image_location[:,0] / float(image_w)\n",
    "        image_location[:,1] = image_location[:,1] / float(image_h)\n",
    "        image_location[:,2] = image_location[:,2] / float(image_w)\n",
    "        image_location[:,3] = image_location[:,3] / float(image_h)\n",
    "        g_location = np.array([0,0,1,1,1])\n",
    "        image_location = np.concatenate([np.expand_dims(g_location, axis=0), image_location], axis=0)\n",
    "        image_mask = [1] * (int(num_boxes))\n",
    "\n",
    "        feature_list.append(feature)\n",
    "        image_location_list.append(torch.tensor(image_location))\n",
    "        image_mask_list.append(torch.tensor(image_mask))\n",
    "\n",
    "    features = torch.stack(feature_list, dim=0).float().cuda()\n",
    "    spatials = torch.stack(image_location_list, dim=0).float().cuda()\n",
    "    image_mask = torch.stack(image_mask_list, dim=0).byte().cuda()\n",
    "    co_attention_mask = torch.zeros((num_image, num_boxes, max_length)).cuda()\n",
    "\n",
    "    prediction(text, features, spatials, segment_ids, input_mask, image_mask, co_attention_mask, task)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": [
     "outputPrepend"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "         loaded from backbone.body.layer3.9.bn3.bias                  of shape (1024,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer3.9.bn3.running_mean          loaded from backbone.body.layer3.9.bn3.running_mean          of shape (1024,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer3.9.bn3.running_var           loaded from backbone.body.layer3.9.bn3.running_var           of shape (1024,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer3.9.bn3.weight                loaded from backbone.body.layer3.9.bn3.weight                of shape (1024,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer3.9.conv1.weight              loaded from backbone.body.layer3.9.conv1.weight              of shape (1024, 1024, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer3.9.conv2.weight              loaded from backbone.body.layer3.9.conv2.weight              of shape (1024, 32, 3, 3)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer3.9.conv3.weight              loaded from backbone.body.layer3.9.conv3.weight              of shape (1024, 1024, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn1.bias                  loaded from backbone.body.layer4.0.bn1.bias                  of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn1.running_mean          loaded from backbone.body.layer4.0.bn1.running_mean          of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn1.running_var           loaded from backbone.body.layer4.0.bn1.running_var           of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn1.weight                loaded from backbone.body.layer4.0.bn1.weight                of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn2.bias                  loaded from backbone.body.layer4.0.bn2.bias                  of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn2.running_mean          loaded from backbone.body.layer4.0.bn2.running_mean          of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn2.running_var           loaded from backbone.body.layer4.0.bn2.running_var           of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn2.weight                loaded from backbone.body.layer4.0.bn2.weight                of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn3.bias                  loaded from backbone.body.layer4.0.bn3.bias                  of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn3.running_mean          loaded from backbone.body.layer4.0.bn3.running_mean          of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn3.running_var           loaded from backbone.body.layer4.0.bn3.running_var           of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.bn3.weight                loaded from backbone.body.layer4.0.bn3.weight                of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.conv1.weight              loaded from backbone.body.layer4.0.conv1.weight              of shape (2048, 1024, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.conv2.weight              loaded from backbone.body.layer4.0.conv2.weight              of shape (2048, 64, 3, 3)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.conv3.weight              loaded from backbone.body.layer4.0.conv3.weight              of shape (2048, 2048, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.downsample.0.weight       loaded from backbone.body.layer4.0.downsample.0.weight       of shape (2048, 1024, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.downsample.1.bias         loaded from backbone.body.layer4.0.downsample.1.bias         of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.downsample.1.running_mean loaded from backbone.body.layer4.0.downsample.1.running_mean of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.downsample.1.running_var  loaded from backbone.body.layer4.0.downsample.1.running_var  of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.0.downsample.1.weight       loaded from backbone.body.layer4.0.downsample.1.weight       of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn1.bias                  loaded from backbone.body.layer4.1.bn1.bias                  of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn1.running_mean          loaded from backbone.body.layer4.1.bn1.running_mean          of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn1.running_var           loaded from backbone.body.layer4.1.bn1.running_var           of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn1.weight                loaded from backbone.body.layer4.1.bn1.weight                of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn2.bias                  loaded from backbone.body.layer4.1.bn2.bias                  of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn2.running_mean          loaded from backbone.body.layer4.1.bn2.running_mean          of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn2.running_var           loaded from backbone.body.layer4.1.bn2.running_var           of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn2.weight                loaded from backbone.body.layer4.1.bn2.weight                of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn3.bias                  loaded from backbone.body.layer4.1.bn3.bias                  of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn3.running_mean          loaded from backbone.body.layer4.1.bn3.running_mean          of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn3.running_var           loaded from backbone.body.layer4.1.bn3.running_var           of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.bn3.weight                loaded from backbone.body.layer4.1.bn3.weight                of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.conv1.weight              loaded from backbone.body.layer4.1.conv1.weight              of shape (2048, 2048, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.conv2.weight              loaded from backbone.body.layer4.1.conv2.weight              of shape (2048, 64, 3, 3)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.1.conv3.weight              loaded from backbone.body.layer4.1.conv3.weight              of shape (2048, 2048, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn1.bias                  loaded from backbone.body.layer4.2.bn1.bias                  of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn1.running_mean          loaded from backbone.body.layer4.2.bn1.running_mean          of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn1.running_var           loaded from backbone.body.layer4.2.bn1.running_var           of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn1.weight                loaded from backbone.body.layer4.2.bn1.weight                of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn2.bias                  loaded from backbone.body.layer4.2.bn2.bias                  of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn2.running_mean          loaded from backbone.body.layer4.2.bn2.running_mean          of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn2.running_var           loaded from backbone.body.layer4.2.bn2.running_var           of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn2.weight                loaded from backbone.body.layer4.2.bn2.weight                of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn3.bias                  loaded from backbone.body.layer4.2.bn3.bias                  of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn3.running_mean          loaded from backbone.body.layer4.2.bn3.running_mean          of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn3.running_var           loaded from backbone.body.layer4.2.bn3.running_var           of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.bn3.weight                loaded from backbone.body.layer4.2.bn3.weight                of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.conv1.weight              loaded from backbone.body.layer4.2.conv1.weight              of shape (2048, 2048, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.conv2.weight              loaded from backbone.body.layer4.2.conv2.weight              of shape (2048, 64, 3, 3)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.layer4.2.conv3.weight              loaded from backbone.body.layer4.2.conv3.weight              of shape (2048, 2048, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.stem.bn1.bias                      loaded from backbone.body.stem.bn1.bias                      of shape (64,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.stem.bn1.running_mean              loaded from backbone.body.stem.bn1.running_mean              of shape (64,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.stem.bn1.running_var               loaded from backbone.body.stem.bn1.running_var               of shape (64,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.stem.bn1.weight                    loaded from backbone.body.stem.bn1.weight                    of shape (64,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.body.stem.conv1.weight                  loaded from backbone.body.stem.conv1.weight                  of shape (64, 3, 7, 7)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_inner1.bias                     loaded from backbone.fpn.fpn_inner1.bias                     of shape (512,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_inner1.weight                   loaded from backbone.fpn.fpn_inner1.weight                   of shape (512, 256, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_inner2.bias                     loaded from backbone.fpn.fpn_inner2.bias                     of shape (512,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_inner2.weight                   loaded from backbone.fpn.fpn_inner2.weight                   of shape (512, 512, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_inner3.bias                     loaded from backbone.fpn.fpn_inner3.bias                     of shape (512,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_inner3.weight                   loaded from backbone.fpn.fpn_inner3.weight                   of shape (512, 1024, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_inner4.bias                     loaded from backbone.fpn.fpn_inner4.bias                     of shape (512,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_inner4.weight                   loaded from backbone.fpn.fpn_inner4.weight                   of shape (512, 2048, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_layer1.bias                     loaded from backbone.fpn.fpn_layer1.bias                     of shape (512,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_layer1.weight                   loaded from backbone.fpn.fpn_layer1.weight                   of shape (512, 512, 3, 3)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_layer2.bias                     loaded from backbone.fpn.fpn_layer2.bias                     of shape (512,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_layer2.weight                   loaded from backbone.fpn.fpn_layer2.weight                   of shape (512, 512, 3, 3)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_layer3.bias                     loaded from backbone.fpn.fpn_layer3.bias                     of shape (512,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_layer3.weight                   loaded from backbone.fpn.fpn_layer3.weight                   of shape (512, 512, 3, 3)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_layer4.bias                     loaded from backbone.fpn.fpn_layer4.bias                     of shape (512,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   backbone.fpn.fpn_layer4.weight                   loaded from backbone.fpn.fpn_layer4.weight                   of shape (512, 512, 3, 3)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   roi_heads.box.feature_extractor.fc6.bias         loaded from roi_heads.box.feature_extractor.fc6.bias         of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   roi_heads.box.feature_extractor.fc6.weight       loaded from roi_heads.box.feature_extractor.fc6.weight       of shape (2048, 25088)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   roi_heads.box.feature_extractor.fc7.bias         loaded from roi_heads.box.feature_extractor.fc7.bias         of shape (2048,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   roi_heads.box.feature_extractor.fc7.weight       loaded from roi_heads.box.feature_extractor.fc7.weight       of shape (2048, 2048)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   roi_heads.box.predictor.bbox_pred.bias           loaded from roi_heads.box.predictor.bbox_pred.bias           of shape (6404,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   roi_heads.box.predictor.bbox_pred.weight         loaded from roi_heads.box.predictor.bbox_pred.weight         of shape (6404, 2048)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   roi_heads.box.predictor.cls_score.bias           loaded from roi_heads.box.predictor.cls_score.bias           of shape (1601,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   roi_heads.box.predictor.cls_score.weight         loaded from roi_heads.box.predictor.cls_score.weight         of shape (1601, 2048)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   rpn.anchor_generator.cell_anchors.0              loaded from rpn.anchor_generator.cell_anchors.0              of shape (3, 4)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   rpn.anchor_generator.cell_anchors.1              loaded from rpn.anchor_generator.cell_anchors.1              of shape (3, 4)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   rpn.anchor_generator.cell_anchors.2              loaded from rpn.anchor_generator.cell_anchors.2              of shape (3, 4)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   rpn.anchor_generator.cell_anchors.3              loaded from rpn.anchor_generator.cell_anchors.3              of shape (3, 4)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   rpn.anchor_generator.cell_anchors.4              loaded from rpn.anchor_generator.cell_anchors.4              of shape (3, 4)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   rpn.head.bbox_pred.bias                          loaded from rpn.head.bbox_pred.bias                          of shape (12,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   rpn.head.bbox_pred.weight                        loaded from rpn.head.bbox_pred.weight                        of shape (12, 512, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   rpn.head.cls_logits.bias                         loaded from rpn.head.cls_logits.bias                         of shape (3,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   rpn.head.cls_logits.weight                       loaded from rpn.head.cls_logits.weight                       of shape (3, 512, 1, 1)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   rpn.head.conv.bias                               loaded from rpn.head.conv.bias                               of shape (512,)\n",
      "12/26/2020 23:51:46 - INFO - maskrcnn_benchmark.utils.model_serialization -   rpn.head.conv.weight                             loaded from rpn.head.conv.weight                             of shape (512, 512, 3, 3)\n"
     ]
    },
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: './multi-task-vilbert/vilbert_tasks.yml'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-21b269ca8c73>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m \u001b[0mconfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBertConfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_json_file\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig_file\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'./multi-task-vilbert/vilbert_tasks.yml'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'r'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\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     33\u001b[0m     \u001b[0mtask_cfg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0medict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0myaml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msafe_load\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\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     34\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: './multi-task-vilbert/vilbert_tasks.yml'"
     ]
    }
   ],
   "source": [
    "\n",
    "# =============================\n",
    "# ViLBERT part\n",
    "# =============================\n",
    "feature_extractor = FeatureExtractor()\n",
    "\n",
    "args = SimpleNamespace(from_pretrained= \"vilbert-multi-task/multi_task_model.bin\",\n",
    "                       bert_model=\"bert-base-uncased\",\n",
    "                       config_file=\"vilbert-multi-task/config/bert_base_6layer_6conect.json\",\n",
    "                       max_seq_length=101,\n",
    "                       train_batch_size=1,\n",
    "                       do_lower_case=True,\n",
    "                       predict_feature=False,\n",
    "                       seed=42,\n",
    "                       num_workers=0,\n",
    "                       baseline=False,\n",
    "                       img_weight=1,\n",
    "                       distributed=False,\n",
    "                       objective=1,\n",
    "                       visual_target=0,\n",
    "                       dynamic_attention=False,\n",
    "                       task_specific_tokens=True,\n",
    "                       tasks='1',\n",
    "                       save_name='',\n",
    "                       in_memory=False,\n",
    "                       batch_size=1,\n",
    "                       local_rank=-1,\n",
    "                       split='mteval',\n",
    "                       clean_train_sets=True\n",
    "                      )\n",
    "\n",
    "config = BertConfig.from_json_file(args.config_file)\n",
    "with open('./vilbert-multi-task/vilbert_tasks.yml', 'r') as f:\n",
    "    task_cfg = edict(yaml.safe_load(f))\n",
    "\n",
    "task_names = []\n",
    "for i, task_id in enumerate(args.tasks.split('-')):\n",
    "    task = 'TASK' + task_id\n",
    "    name = task_cfg[task]['name']\n",
    "    task_names.append(name)\n",
    "\n",
    "timeStamp = args.from_pretrained.split('/')[-1] + '-' + args.save_name\n",
    "config = BertConfig.from_json_file(args.config_file)\n",
    "default_gpu=True\n",
    "\n",
    "if args.predict_feature:\n",
    "    config.v_target_size = 2048\n",
    "    config.predict_feature = True\n",
    "else:\n",
    "    config.v_target_size = 1601\n",
    "    config.predict_feature = False\n",
    "\n",
    "if args.task_specific_tokens:\n",
    "    config.task_specific_tokens = True    \n",
    "\n",
    "if args.dynamic_attention:\n",
    "    config.dynamic_attention = True\n",
    "\n",
    "config.visualization = True\n",
    "num_labels = 3129\n",
    "\n",
    "if args.baseline:\n",
    "    model = BaseBertForVLTasks.from_pretrained(\n",
    "        args.from_pretrained, config=config, num_labels=num_labels, default_gpu=default_gpu\n",
    "        )\n",
    "else:\n",
    "    model = VILBertForVLTasks.from_pretrained(\n",
    "        args.from_pretrained, config=config, num_labels=num_labels, default_gpu=default_gpu\n",
    "        )\n",
    "    \n",
    "model.eval()\n",
    "cuda = torch.cuda.is_available()\n",
    "if cuda: model = model.cuda(0)\n",
    "tokenizer = BertTokenizer.from_pretrained(\n",
    "    args.bert_model, do_lower_case=args.do_lower_case\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       "  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Created with matplotlib (https://matplotlib.org/) -->\n",
       "<svg height=\"231.84pt\" version=\"1.1\" viewBox=\"0 0 231.84 231.84\" width=\"231.84pt\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       " <metadata>\n",
       "  <rdf:RDF xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n",
       "   <cc:Work>\n",
       "    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n",
       "    <dc:date>2020-12-26T23:50:19.981232</dc:date>\n",
       "    <dc:format>image/svg+xml</dc:format>\n",
       "    <dc:creator>\n",
       "     <cc:Agent>\n",
       "      <dc:title>Matplotlib v3.3.3, https://matplotlib.org/</dc:title>\n",
       "     </cc:Agent>\n",
       "    </dc:creator>\n",
       "   </cc:Work>\n",
       "  </rdf:RDF>\n",
       " </metadata>\n",
       " <defs>\n",
       "  <style type=\"text/css\">*{stroke-linecap:butt;stroke-linejoin:round;}</style>\n",
       " </defs>\n",
       " <g id=\"figure_1\">\n",
       "  <g id=\"patch_1\">\n",
       "   <path d=\"M 0 231.84 \n",
       "L 231.84 231.84 \n",
       "L 231.84 0 \n",
       "L 0 0 \n",
       "z\n",
       "\" style=\"fill:none;\"/>\n",
       "  </g>\n",
       "  <g id=\"axes_1\">\n",
       "   <g clip-path=\"url(#p50182ff628)\">\n",
       "    <image height=\"218\" id=\"image52e3fdce95\" transform=\"scale(1 -1)translate(0 -218)\" width=\"218\" x=\"7.2\" xlink:href=\"data:image/png;base64,\n",
       "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\" y=\"-6.64\"/>\n",
       "   </g>\n",
       "  </g>\n",
       " </g>\n",
       " <defs>\n",
       "  <clipPath id=\"p50182ff628\">\n",
       "   <rect height=\"217.44\" width=\"217.44\" x=\"7.2\" y=\"7.2\"/>\n",
       "  </clipPath>\n",
       " </defs>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "NameError",
     "evalue": "name 'tokenizer' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-33656cdf9ba6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0mquery\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"what color is the left wall\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0mtask\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0mcustom_prediction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mquery\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeatures\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minfos\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-5-ec662d86cedd>\u001b[0m in \u001b[0;36mcustom_prediction\u001b[0;34m(query, task, features, infos)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mcustom_prediction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mquery\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeatures\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minfos\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      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mtokens\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtokenizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mquery\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      4\u001b[0m     \u001b[0mtokens\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtokenizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_special_tokens_single_sentence\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtokens\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;31m#tokens = tokenizer.build_inputs_with_special_tokens(tokens)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'tokenizer' is not defined"
     ]
    }
   ],
   "source": [
    "# 1: VQA, 2: GenomeQA, 4: Visual7w, 7: Retrieval COCO, 8: Retrieval Flickr30k \n",
    "# 9: refcoco, 10: refcoco+ 11: refcocog, 12: NLVR2, 13: VisualEntailment, 15: GQA, 16: GuessWhat, \n",
    "\n",
    "\n",
    "#image_path = 'demo/1.jpg'\n",
    "image_path='renders/out_ref.png'\n",
    "features, infos = feature_extractor.extract_features(image_path)\n",
    "\n",
    "img = PIL.Image.open(image_path).convert('RGB')\n",
    "img = torch.tensor(np.array(img))\n",
    "\n",
    "plt.axis('off')\n",
    "plt.imshow(img)\n",
    "plt.show()\n",
    "    \n",
    "#query = \"swimming elephant\"\n",
    "query = \"what color is the left wall\"\n",
    "task = [1]\n",
    "custom_prediction(query, task, features, infos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6.12 64-bit ('vilbert-mt': conda)",
   "language": "python",
   "name": "python361264bitvilbertmtcondac8f0b983c7b54a8c933562d3550e3cf5"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}