CLEVRTask2MultipleChoice.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from source.trainutil import *\n",
    "from source.datautil import *\n",
    "from source.model import *\n",
    "from source.mathutil import *\n",
    "from tqdm import tqdm_notebook\n",
    "DEVICE = \"cpu\" # or \"cuda:0\"\n",
    "# torch.cuda.set_device(DEVICE) # uncomment this for CUDA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Choice Task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# After first ipython notebook, we'll get an autoencoder doing information map seperation\n",
    "# and preprocessed json file with information map seperation representations\n",
    "# In this notbook, we'll going perform the multiple choice task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH_TO_IMAGES_TRAIN = \"/storage/hezq17/CLEVR_v1.0/images/train\" # change this to where you download the images\n",
    "data_path_images_train = PATH_TO_IMAGES_TRAIN\n",
    "PATH_TO_IMAGES_VAL = \"/storage/hezq17/CLEVR_v1.0/images/val\" # change this to where you download the images\n",
    "data_path_images_val = PATH_TO_IMAGES_VAL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data load from  dataset/json_clevr_train_with_maskautocode_PCM_10p53_h64reg0p5_pgnoise2e-3_focusMode_posiIncld.data\n",
      "Parsing dataset ...\n",
      "Data load from  dataset/json_clevr_val_with_maskautocode_PCM_10p53_h64reg0p5_pgnoise2e-3_focusMode_posiIncld.data\n",
      "Parsing dataset ...\n"
     ]
    }
   ],
   "source": [
    "data_path_json_train = \"dataset/json_clevr_train_with_maskautocode_PCM_10p53_h64reg0p5_pgnoise2e-3_focusMode_posiIncld.data\"\n",
    "data_path_json_val = \"dataset/json_clevr_val_with_maskautocode_PCM_10p53_h64reg0p5_pgnoise2e-3_focusMode_posiIncld.data\"\n",
    "\n",
    "mulcDataset = MultipleChoiceClevrDataset(data_path_json_train, data_path_images_train, epoch_len = 100000, question_mode=\"exist_sizecolor\")\n",
    "mulcDataset_val = MultipleChoiceClevrDataset(data_path_json_val, data_path_images_val, epoch_len = 20000, question_mode=\"exist_sizecolor\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_loader = torch.utils.data.DataLoader(\n",
    "    mulcDataset, batch_size=128, shuffle=True, num_workers=4, collate_fn=mulcDataset.collate_fn)\n",
    "\n",
    "data_loader_val = torch.utils.data.DataLoader(\n",
    "    mulcDataset_val, batch_size=128, shuffle=True, num_workers=4, collate_fn=mulcDataset_val.collate_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_para={\n",
    "    \"input_size\": 2+8+2+128,\n",
    "    \"input_divide\":[2,8,2,128],\n",
    "    \"output_size\":8+8+8+16,\n",
    "    \"output_divide\":[8,8,8,16],\n",
    "    \"mlp_layer_para\": [[16,16],[16,16],[16,16],[32,32]],\n",
    "    \"infobn_model\": [{\"gs_head_dim\":2,\"gs_head_num\":4},{\"gs_head_dim\":2,\"gs_head_num\":4},\n",
    "                   {\"gs_head_dim\":2,\"gs_head_num\":4},{\"gs_head_dim\":2,\"gs_head_num\":8}]\n",
    "}\n",
    "\n",
    "misc_para={\n",
    "    \"infobn_para\":{\"temp_scan_num\":4,\"reg_lamda\":0.0,\"scale_factor\":1.0},\n",
    "    \"sample_mode\":False,\n",
    "    \"sample_size\":1\n",
    "}\n",
    "mltitubeff = Multitube_FF_MLP_CLEVR(model_para, para=misc_para)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_para_h={\n",
    "    \"input_size\": 8+8+8+16, \n",
    "    \"output_size\":1,\n",
    "    \"mlp_layer_para\": [32,16,8]\n",
    "}\n",
    "model_para_ob={\n",
    "    \"input_size\": 10, \n",
    "    \"output_size\":1,\n",
    "    \"mlp_layer_para\": [5]\n",
    "}\n",
    "# model_para_out={\n",
    "#     \"input_size\": 4, \n",
    "#     \"output_size\":4,\n",
    "#     \"mlp_layer_para\": [16]\n",
    "# }\n",
    "model_para = {\n",
    "    \"HiddenConvFF\":model_para_h,\n",
    "    \"ObjConvFF\":model_para_ob\n",
    "#     \"OutFF\":model_para_out\n",
    "}\n",
    "misc_para = {}\n",
    "\n",
    "convff = ConvFF_MLP_CLEVR(model_para,para=misc_para)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "misc_para = {\n",
    "    \"seq1_coop_train_flag\": True\n",
    "}\n",
    "mltube_convff = ABS_CNN_SEQ(mltitubeff, convff, para=misc_para)\n",
    "\n",
    "misc_para={\n",
    "    \"loss_flag\":\"cross_entropy\",\n",
    "    \"sample_mode\":False,\n",
    "    \"sample_size\":1\n",
    "}\n",
    "loss = CAL_LOSS(mltube_convff, para = misc_para)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data_dict={\"train\":data_loader,\"val\":data_loader_val}\n",
    "mulcDataset_val.checkmode=False\n",
    "mulcDataset_val.singlecheckmode=False\n",
    "run_para={\"loss_exp_flag\":False, \"loss_clip\":4}\n",
    "ptM = PyTrain_Main(loss, data_dict, device=DEVICE, para=run_para)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First using low reg_lamda helps training\n",
    "for ii in range(len(mltitubeff.infobnl)):\n",
    "    mltitubeff.infobnl[ii].reg_lamda=0.0\n",
    "    mltitubeff.infobnl[ii].scale_factor=1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ptM.run_training(epoch=20, lr=1.0e-4, optimizer_label=\"adam\", print_step=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_region = 4\n",
    "num_dimtot = 20\n",
    "reg_lamda_scale = num_dimtot/num_region # scale constant between lamda in paper and lamda in code\n",
    "for ii in range(len(mltitubeff.infobnl)):\n",
    "    mltitubeff.infobnl[ii].reg_lamda=0.04 * reg_lamda_scale\n",
    "    mltitubeff.infobnl[ii].scale_factor=1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ptM.run_training(epoch=100, lr=1.0e-4, optimizer_label=\"adam\", print_step=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model load from  pretrained_models/Mltube_Convff_InfoB_PCM_10p53_h64reg0p5_pgnoise2e-3_focusMode_posiIncld_smallyellow.model\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "ABS_CNN_SEQ(\n",
       "  (seq1_coop): Multitube_FF_MLP_CLEVR(\n",
       "    (ff_tubes): ModuleList(\n",
       "      (0): FF_MLP(\n",
       "        (linear_layer_stack): ModuleList(\n",
       "          (0): Sequential(\n",
       "            (0): Linear(in_features=2, out_features=16, bias=True)\n",
       "            (1): LayerNorm((16,), eps=1e-05, elementwise_affine=True)\n",
       "            (2): ReLU()\n",
       "          )\n",
       "          (1): Sequential(\n",
       "            (0): Linear(in_features=16, out_features=16, bias=True)\n",
       "            (1): LayerNorm((16,), eps=1e-05, elementwise_affine=True)\n",
       "            (2): ReLU()\n",
       "          )\n",
       "        )\n",
       "        (h2o): Linear(in_features=16, out_features=8, bias=True)\n",
       "        (dropout): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "      (1): FF_MLP(\n",
       "        (linear_layer_stack): ModuleList(\n",
       "          (0): Sequential(\n",
       "            (0): Linear(in_features=8, out_features=16, bias=True)\n",
       "            (1): LayerNorm((16,), eps=1e-05, elementwise_affine=True)\n",
       "            (2): ReLU()\n",
       "          )\n",
       "          (1): Sequential(\n",
       "            (0): Linear(in_features=16, out_features=16, bias=True)\n",
       "            (1): LayerNorm((16,), eps=1e-05, elementwise_affine=True)\n",
       "            (2): ReLU()\n",
       "          )\n",
       "        )\n",
       "        (h2o): Linear(in_features=16, out_features=8, bias=True)\n",
       "        (dropout): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "      (2): FF_MLP(\n",
       "        (linear_layer_stack): ModuleList(\n",
       "          (0): Sequential(\n",
       "            (0): Linear(in_features=2, out_features=16, bias=True)\n",
       "            (1): LayerNorm((16,), eps=1e-05, elementwise_affine=True)\n",
       "            (2): ReLU()\n",
       "          )\n",
       "          (1): Sequential(\n",
       "            (0): Linear(in_features=16, out_features=16, bias=True)\n",
       "            (1): LayerNorm((16,), eps=1e-05, elementwise_affine=True)\n",
       "            (2): ReLU()\n",
       "          )\n",
       "        )\n",
       "        (h2o): Linear(in_features=16, out_features=8, bias=True)\n",
       "        (dropout): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "      (3): FF_MLP(\n",
       "        (linear_layer_stack): ModuleList(\n",
       "          (0): Sequential(\n",
       "            (0): Linear(in_features=128, out_features=32, bias=True)\n",
       "            (1): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "            (2): ReLU()\n",
       "          )\n",
       "          (1): Sequential(\n",
       "            (0): Linear(in_features=32, out_features=32, bias=True)\n",
       "            (1): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "            (2): ReLU()\n",
       "          )\n",
       "        )\n",
       "        (h2o): Linear(in_features=32, out_features=16, bias=True)\n",
       "        (dropout): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (infobnl): ModuleList(\n",
       "      (0): GSVIB_InfoBottleNeck(\n",
       "        (softmax): LogSoftmax()\n",
       "        (gsoftmax): Gumbel_Softmax()\n",
       "      )\n",
       "      (1): GSVIB_InfoBottleNeck(\n",
       "        (softmax): LogSoftmax()\n",
       "        (gsoftmax): Gumbel_Softmax()\n",
       "      )\n",
       "      (2): GSVIB_InfoBottleNeck(\n",
       "        (softmax): LogSoftmax()\n",
       "        (gsoftmax): Gumbel_Softmax()\n",
       "      )\n",
       "      (3): GSVIB_InfoBottleNeck(\n",
       "        (softmax): LogSoftmax()\n",
       "        (gsoftmax): Gumbel_Softmax()\n",
       "      )\n",
       "    )\n",
       "    (layer_norm0): LayerNorm((140,), eps=1e-05, elementwise_affine=True)\n",
       "    (layer_norm1): LayerNorm((40,), eps=1e-05, elementwise_affine=True)\n",
       "    (gsoftmax): Gumbel_Softmax()\n",
       "    (gauss_noise): GaussNoise()\n",
       "  )\n",
       "  (seq2_train): ConvFF_MLP_CLEVR(\n",
       "    (HiddenConvFF): FF_MLP(\n",
       "      (linear_layer_stack): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Linear(in_features=40, out_features=32, bias=True)\n",
       "          (1): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "          (2): ReLU()\n",
       "        )\n",
       "        (1): Sequential(\n",
       "          (0): Linear(in_features=32, out_features=16, bias=True)\n",
       "          (1): LayerNorm((16,), eps=1e-05, elementwise_affine=True)\n",
       "          (2): ReLU()\n",
       "        )\n",
       "        (2): Sequential(\n",
       "          (0): Linear(in_features=16, out_features=8, bias=True)\n",
       "          (1): LayerNorm((8,), eps=1e-05, elementwise_affine=True)\n",
       "          (2): ReLU()\n",
       "        )\n",
       "      )\n",
       "      (h2o): Linear(in_features=8, out_features=1, bias=True)\n",
       "      (dropout): Dropout(p=0.0, inplace=False)\n",
       "    )\n",
       "    (ObjConvFF): FF_MLP(\n",
       "      (linear_layer_stack): ModuleList(\n",
       "        (0): Sequential(\n",
       "          (0): Linear(in_features=10, out_features=5, bias=True)\n",
       "          (1): LayerNorm((5,), eps=1e-05, elementwise_affine=True)\n",
       "          (2): ReLU()\n",
       "        )\n",
       "      )\n",
       "      (h2o): Linear(in_features=5, out_features=1, bias=True)\n",
       "      (dropout): Dropout(p=0.0, inplace=False)\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load_model(mltube_convff,\"pretrained_models/Mltube_Convff_InfoB_PCM_10p53_h64reg0p5_pgnoise2e-3_focusMode_posiIncld_smallyellow.model\",\n",
    "          map_location=DEVICE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start evaluation ... 157\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "157it [00:13, 11.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Perplexity:  0.01624394078201123\n",
      "Time used in evaluation:  14.05709958076477\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "mulcDataset_val.checkmode=False\n",
    "mulcDataset_val.singlecheckmode=False\n",
    "ptM.evalmem=None\n",
    "ptM.mem_eval_mode=\"task2\"\n",
    "ptM.do_eval(eval_mem_flag=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start testing ...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "157it [00:14, 11.20it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct rate:  0.99165\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.99165"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ptM.do_test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(509900, 40) (509900, 40)\n"
     ]
    }
   ],
   "source": [
    "# Interpretation as meta-information of mutual information flow pattern\n",
    "evalmatr = np.concatenate(ptM.evalmem[0],axis=0).reshape(-1,40)\n",
    "evalcontr = np.concatenate(ptM.evalmem[1],axis=0).reshape(-1,40)\n",
    "evalmat=[]\n",
    "evalcont=[]\n",
    "for ii in range(len(evalmatr)):\n",
    "    if (evalmatr[ii]!=0).any():\n",
    "        evalmat.append(evalmatr[ii])\n",
    "        evalcont.append(evalcontr[ii])\n",
    "evalmat=np.array(evalmat)\n",
    "evalcont=np.array(evalcont)\n",
    "print(evalmat.shape, evalcont.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.23708420451567547, 0.5253658509953114, 0.23551462188628036, 1.1169105328889426]\n"
     ]
    }
   ],
   "source": [
    "evalmatl=[]\n",
    "sep=[[0,8],[8,16],[16,24],[24,40]]\n",
    "lenl=[4,4,4,8]\n",
    "for ii in range(4):\n",
    "    evalmatp=evalmat[:,sep[ii][0]:sep[ii][1]].reshape(-1,lenl[ii],2)[:,:,0]\n",
    "    entp = cal_entropy_raw_ND_discrete(np.round(evalmatp))\n",
    "    evalmatl.append(entp)\n",
    "print(evalmatl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.23528927504832955, 0.18164258676814177, 0.23498793953784933, 0.4287884571665727]\n"
     ]
    }
   ],
   "source": [
    "evalcontl=[]\n",
    "for ii in range(4):\n",
    "    evalcontp=evalcont[:,sep[ii][0]:sep[ii][1]].reshape(-1,2)\n",
    "    entp = np.mean(cal_entropy(evalcontp,log_flag=True))*lenl[ii]\n",
    "    evalcontl.append(entp)\n",
    "print(evalcontl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mutual information flow in each information map:\n",
      "[1.79492947e-03 3.43723264e-01 5.26682348e-04 6.88122076e-01]\n"
     ]
    }
   ],
   "source": [
    "print(\"Mutual information flow in each information map:\")\n",
    "print(np.array(evalmatl) - np.array(evalcontl))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Single Example Explanation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image getting ...\n",
      "Image getting ...\n",
      "Image getting ...\n",
      "Image getting ...\n",
      "torch.Size([16, 4, 10, 140]) 3\n"
     ]
    }
   ],
   "source": [
    "mulcDataset_val.checkmode=True\n",
    "mulcDataset_val.singlecheckmode=False\n",
    "datax, Nobjl, ans = mulcDataset_val[int(np.random.rand()*len(mulcDataset_val))]\n",
    "datax=datax.view(1,4,10,140).expand(16,4,10,140)\n",
    "print(datax.shape,ans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dimension by dimension check of GSVIB for each region"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0.06004513749530355 0.05895072266925102 mutual information flow: 0.0010944148260525269\n",
      "1 0.05966455220936807 0.05865763204770557 mutual information flow: 0.0010069201616624973\n",
      "2 0.05734001984383708 0.05735004134670223 mutual information flow: -1.0021502865144305e-05\n",
      "3 0.06005398043948707 0.060330878984670905 mutual information flow: -0.0002768985451838332\n"
     ]
    }
   ],
   "source": [
    "outmat = np.concatenate(ptM.evalmem[0],axis=0).reshape(-1,40)\n",
    "contmat = np.concatenate(ptM.evalmem[1],axis=0).reshape(-1,40)\n",
    "maskmat = np.concatenate(ptM.evalmem[2],axis=0).reshape(-1)\n",
    "\n",
    "outmat=outmat[maskmat==1,:]\n",
    "contmat=contmat[maskmat==1,:]\n",
    "\n",
    "outmatsub = outmat[:,0:8].reshape(-1,4,2)\n",
    "contmatsub = contmat[:,0:8].reshape(-1,4,2)\n",
    "for ii in range(4):\n",
    "    ent0 = cal_entropy_raw_ND_discrete(np.round(outmatsub[:,ii,:]))\n",
    "    ent1 = np.mean(cal_entropy(contmatsub[:,ii,:],log_flag=True))\n",
    "    print(ii, ent0, ent1, \"mutual information flow:\", ent0-ent1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0.059185664733317774 0.05883602081390016 mutual information flow: 0.00034964391941761513\n",
      "1 0.060504498528426945 0.061176023931669675 mutual information flow: -0.0006715254032427301\n",
      "2 0.3444190609015721 0.0004032642496271082 mutual information flow: 0.344015796651945\n",
      "3 0.061376413640621436 0.06122727777294488 mutual information flow: 0.00014913586767655723\n"
     ]
    }
   ],
   "source": [
    "outmat = np.concatenate(ptM.evalmem[0],axis=0).reshape(-1,40)\n",
    "contmat = np.concatenate(ptM.evalmem[1],axis=0).reshape(-1,40)\n",
    "maskmat = np.concatenate(ptM.evalmem[2],axis=0).reshape(-1)\n",
    "\n",
    "outmat=outmat[maskmat==1,:]\n",
    "contmat=contmat[maskmat==1,:]\n",
    "\n",
    "outmatsub = outmat[:,8:16].reshape(-1,4,2)\n",
    "contmatsub= contmat[:,8:16].reshape(-1,4,2)\n",
    "for ii in range(4):\n",
    "    ent0 = cal_entropy_raw_ND_discrete(np.round(outmatsub[:,ii,:]))\n",
    "    ent1 = np.mean(cal_entropy(contmatsub[:,ii,:],log_flag=True))\n",
    "    print(ii, ent0, ent1,\"mutual information flow:\",ent0-ent1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0.057742601925536347 0.05941484546776931 mutual information flow: -0.0016722435422329637\n",
      "1 0.06298793143570611 0.06144576333462355 mutual information flow: 0.0015421681010825555\n",
      "2 0.05828711502825765 0.057963106623653844 mutual information flow: 0.0003240084046038025\n",
      "3 0.05650558650988223 0.056164224111802774 mutual information flow: 0.0003413623980794561\n"
     ]
    }
   ],
   "source": [
    "outmat = np.concatenate(ptM.evalmem[0],axis=0).reshape(-1,40)\n",
    "contmat = np.concatenate(ptM.evalmem[1],axis=0).reshape(-1,40)\n",
    "maskmat = np.concatenate(ptM.evalmem[2],axis=0).reshape(-1)\n",
    "\n",
    "outmat=outmat[maskmat==1,:]\n",
    "contmat=contmat[maskmat==1,:]\n",
    "\n",
    "outmatsub = outmat[:,16:24].reshape(-1,4,2)\n",
    "contmatsub= contmat[:,16:24].reshape(-1,4,2)\n",
    "for ii in range(4):\n",
    "    ent0 = cal_entropy_raw_ND_discrete(np.round(outmatsub[:,ii,:]))\n",
    "    ent1 = np.mean(cal_entropy(contmatsub[:,ii,:],log_flag=True))\n",
    "    print(ii, ent0, ent1,\"mutual information flow:\",ent0-ent1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0.6924593461545704 0.005934205881447717 mutual information flow: 0.6865251402731227\n",
      "1 0.05994784152502615 0.0596539874050433 mutual information flow: 0.0002938541199828462\n",
      "2 0.05847425083726841 0.05856033412737665 mutual information flow: -8.608329010823673e-05\n",
      "3 0.059637974974925054 0.06001833413579463 mutual information flow: -0.00038035916086957833\n",
      "4 0.05701740396608719 0.05543237567531436 mutual information flow: 0.0015850282907728316\n",
      "5 0.062297448534541194 0.06198230695028866 mutual information flow: 0.0003151415842525332\n",
      "6 0.059283301495277545 0.05929303167065953 mutual information flow: -9.730175381986172e-06\n",
      "7 0.06797752898244477 0.06791388132064763 mutual information flow: 6.364766179714487e-05\n"
     ]
    }
   ],
   "source": [
    "outmat = np.concatenate(ptM.evalmem[0],axis=0).reshape(-1,40)\n",
    "contmat = np.concatenate(ptM.evalmem[1],axis=0).reshape(-1,40)\n",
    "maskmat = np.concatenate(ptM.evalmem[2],axis=0).reshape(-1)\n",
    "\n",
    "outmat=outmat[maskmat==1,:]\n",
    "contmat=contmat[maskmat==1,:]\n",
    "\n",
    "outmatsub = outmat[:,24:].reshape(-1,8,2)\n",
    "contmatsub = contmat[:,24:].reshape(-1,8,2)\n",
    "for ii in range(8):\n",
    "    ent0 = cal_entropy_raw_ND_discrete(np.round(outmatsub[:,ii,:]))\n",
    "    ent1 = np.mean(cal_entropy(contmatsub[:,ii,:],log_flag=True))\n",
    "    print(ii, ent0, ent1,\"mutual information flow:\",ent0-ent1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building single explanation matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "    yout = mltube_convff((datax.to(DEVICE),Nobjl.to(DEVICE)), schedule=1.0)\n",
    "singleout = mltube_convff.seq1_coop.output.cpu().numpy()\n",
    "resmatl=[]\n",
    "for ii in range(4):\n",
    "    nobj = int(torch.sum(Nobjl[ii]).item())\n",
    "    resmat = np.zeros((4,10))\n",
    "    for iio in range(nobj):\n",
    "        posiout = singleout[0,ii,iio,8:16]\n",
    "        headpick_color = 4 # Determine head pick id in last step\n",
    "        resmat[0,iio]=0\n",
    "        resmat[1,iio]=posiout[headpick_color]\n",
    "        resmat[2,iio]=0\n",
    "        unkout = singleout[0,ii,iio,24:]\n",
    "        headpick_unknown = 1\n",
    "        resmat[3,iio]=unkout[headpick_unknown]\n",
    "    resmatl.append(resmat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.colors import ListedColormap\n",
    "seismic = plt.get_cmap('seismic', 11)\n",
    "newcolors = seismic(np.linspace(0, 1, 11))\n",
    "grey = np.array([0.8, 0.8, 0.8, 1])\n",
    "newcolors[0, :] = grey\n",
    "newcmp = ListedColormap(newcolors)\n",
    "\n",
    "twocolors = seismic(np.linspace(0, 1, 2))\n",
    "white = np.array([1, 1, 1, 1])\n",
    "twocolors[0, :] = white\n",
    "twocolorsmp = ListedColormap(twocolors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "idpickmat=(mulcDataset_val.mask_tl[0]==1).astype(int)\n",
    "idpickmat.shape\n",
    "xlsp = np.linspace(0,479,480)\n",
    "ylsp = np.linspace(0,319,320)\n",
    "x = np.sum(idpickmat*xlsp.reshape(1,480))/np.sum(idpickmat)\n",
    "y = np.sum(idpickmat*ylsp.reshape(320,1))/np.sum(idpickmat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(nrows=4, ncols=3)\n",
    "for iis in range(4):\n",
    "    axes[iis][0].imshow(mulcDataset_val.imgl[iis])\n",
    "    im = axes[iis][1].imshow(mulcDataset_val.mask_tl[iis], cmap=newcmp, clim=(0, 10))\n",
    "    for iiob in range(1,11): ### Mask labeling\n",
    "        if (mulcDataset_val.mask_tl[iis]==iiob).any():\n",
    "            idpickmat=(mulcDataset_val.mask_tl[iis]==iiob).astype(int)\n",
    "            xlsp = np.linspace(0,479,480)\n",
    "            ylsp = np.linspace(0,319,320)\n",
    "            x = np.sum(idpickmat*xlsp.reshape(1,480))/np.sum(idpickmat)\n",
    "            y = np.sum(idpickmat*ylsp.reshape(320,1))/np.sum(idpickmat)\n",
    "            if iiob==10:\n",
    "                shift=20\n",
    "            else:\n",
    "                shift=10\n",
    "            axes[iis][1].text(x-shift,y+10,iiob,fontsize=12,color=[0.2,0.9,0.9])\n",
    "    fig.colorbar(im, ax=axes[iis][1])\n",
    "    axes[iis][2].imshow(resmatl[iis], cmap=twocolorsmp, clim=(0, 1))\n",
    "    axes[iis][2].set_xticks(list(range(10)))\n",
    "    axes[iis][2].set_xticklabels(list(range(1,11)))\n",
    "    axes[iis][2].set_yticks(list(range(4)))\n",
    "    axes[iis][2].set_yticklabels([\"posi\",\"color\",\"material\",\"else\"])\n",
    "    axes[iis][2].set_xlabel(\"object #\")\n",
    "fig.text(0.38, 0.95, \"Exist small yellow object\", fontsize=20,\n",
    "        verticalalignment='top')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unconceptualized Region Crosscheck via Mutual information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/hezq17/anaconda3/envs/tensorflow/lib/python3.7/site-packages/ipykernel_launcher.py:9: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  if __name__ == '__main__':\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c40dc4316e1446578dddbb5067024fbc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=157.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "batchcheckmatl=[]\n",
    "singleoutl=[]\n",
    "Nobjll=[]\n",
    "\n",
    "mulcDataset_val.checkmode=False\n",
    "mulcDataset_val.singlecheckmode=True\n",
    "data_loader_val = torch.utils.data.DataLoader(\n",
    "    mulcDataset_val, batch_size=128, shuffle=True, num_workers=4, collate_fn=mulcDataset_val.collate_fn)\n",
    "for databatch in tqdm_notebook(data_loader_val):\n",
    "    (datax, Nobjl), answ, batchcheckmat = databatch\n",
    "    with torch.no_grad():\n",
    "        yout = mltube_convff((datax.to(DEVICE),Nobjl.to(DEVICE)), schedule=1.0)\n",
    "    singleout = mltube_convff.seq1_coop.output.cpu()\n",
    "    contextout = torch.exp(mltube_convff.seq1_coop.contextl.cpu())\n",
    "    Nobjll.append(Nobjl)\n",
    "    batchcheckmatl.append(batchcheckmat)\n",
    "    singleoutl.append(singleout)\n",
    "\n",
    "Nobjll = torch.cat(Nobjll,dim=0).view(800000)\n",
    "batchcheckmatl = torch.cat(batchcheckmatl,dim=0).view(800000,4)\n",
    "singleoutl = torch.cat(singleoutl,dim=0).view(800000,40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/hezq17/anaconda3/envs/tensorflow/lib/python3.7/site-packages/ipykernel_launcher.py:5: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  \"\"\"\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "692b720e1d3c449e802341e82315326c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=800000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "colorl = []\n",
    "sizel = []\n",
    "color_repl = []\n",
    "size_repl = []\n",
    "for ii in tqdm_notebook(range(len(Nobjll))):\n",
    "    if Nobjll[ii]==1:\n",
    "        colorl.append(batchcheckmatl[ii,1])\n",
    "        sizel.append(batchcheckmatl[ii,3])\n",
    "        color_repl.append(np.round(singleoutl[ii,8:16].numpy()))\n",
    "        size_repl.append(np.round(singleoutl[ii,24:].numpy()))\n",
    "colorl=np.array(colorl)\n",
    "sizel=np.array(sizel)\n",
    "color_repl = np.array(color_repl)\n",
    "size_repl = np.array(size_repl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.34362705357327306"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cal_entropy_raw_ND_discrete(colorl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3369461125507023"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cal_muinfo_raw_ND_discrete(colorl,color_repl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.692512182057459"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cal_entropy_raw_ND_discrete(sizel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6593431584799283"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cal_muinfo_raw_ND_discrete(sizel,size_repl)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.7.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "625px",
    "left": "1313.67px",
    "top": "110.433px",
    "width": "158.333px"
   },
   "toc_section_display": false,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}