example_image_subset.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "current_file_path = os.path.abspath(os.getcwd())\n",
    "ImageExplainer_path = os.path.join(os.path.join(current_file_path, \"Examples\"),\"ImageExplainer\")\n",
    "sys.path.append(ImageExplainer_path)\n",
    "\n",
    "\n",
    "from missingDataTrainingModule import *\n",
    "from torch.distributions import *\n",
    "from torch.optim import *\n",
    "from datasets import *\n",
    "from missingDataTrainingModule.EpochsScheduler import classic_train_epoch\n",
    "\n",
    "from multiple_experiment_launcher import get_dataset\n",
    "from default_parameter import get_default\n",
    "\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Choose Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "args = get_default()\n",
    "\n",
    "args.args_dataset.dataset = \"MNIST_and_FASHIONMNIST\"\n",
    "args.args_dataset.args_dataset_parameters.train_seed = 0\n",
    "args.args_dataset.args_dataset_parameters.test_seed = 1\n",
    "\n",
    "dataset, loader = get_dataset(args)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building blocks"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choose networks :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Choose the kernel for the creation of patches for the selection :\n",
    "kernel_size = (1,1)\n",
    "kernel_stride = (1,1)\n",
    "add_mask = False\n",
    "dim_output = dataset.get_dim_output()\n",
    "\n",
    "\n",
    "# Choose the network for prediction :\n",
    "input_size_classifier = dataset.get_dim_input()\n",
    "if add_mask :\n",
    "    init_shape = dataset.get_dim_input()\n",
    "    input_size_classifier = torch.Size((init_shape[0]+1,)) + torch.Size((init_shape[1:]))\n",
    "\n",
    "\n",
    "# Choose network for selection :\n",
    "classifier = ConvClassifier2(input_size=input_size_classifier, output_size=dim_output,)\n",
    "input_size_selector = dataset.get_dim_input()\n",
    "output_size_selector = calculate_blocks_patch(input_size_selector, kernel_size, kernel_stride)\n",
    "selector = SelectorUNET(input_size=input_size_selector, output_size=output_size_selector,)\n",
    "\n",
    "# Reshape the patch to the original shape :\n",
    "reshape_mask_function = KernelReshape2D(input_size_classifier = input_size_classifier,\n",
    "                                                                    output_size_selector = output_size_selector,\n",
    "                                                                    kernel_size = kernel_size,\n",
    "                                                                    kernel_stride = kernel_stride)\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imputation method :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TRAINING FROM MODEL DIR None\n",
      "Learning rate : 0.0001\n",
      "type of training : sgd\n",
      "Repartition after kmeans : tensor([0.0210, 0.0582, 0.0208, 0.0547, 0.0669, 0.0598, 0.0432, 0.0841, 0.0432,\n",
      "        0.0813, 0.0436, 0.0477, 0.0682, 0.0514, 0.0209, 0.0570, 0.0793, 0.0213,\n",
      "        0.0585, 0.0187])\n",
      "Weights after kmeans : [0.02097917 0.05822916 0.02083334 0.05474999 0.066875   0.05977083\n",
      " 0.04325    0.08414582 0.04320833 0.08131249 0.043625   0.04775\n",
      " 0.06820834 0.05139584 0.02091667 0.05704166 0.07925    0.02125\n",
      " 0.05852083 0.01868751]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "16it [00:00, 570.13it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch -1 / 10\n",
      "Validation Loss : 3829.645263671875\n",
      "Repartition centers : tensor([ 25., 101.,  20.,  21.,  83.,  71.,  48.,  74.,  35.,  90.,  60.,  47.,\n",
      "         84.,  57.,  24.,  44.,  40.,  19.,  36.,  21.], device='cuda:0')\n",
      "=========================================\n",
      "Epoch 0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "750it [00:04, 179.38it/s]\n",
      "16it [00:00, 494.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch 0 / 10\n",
      "Validation Loss : 3784.876708984375\n",
      "Repartition centers : tensor([ 22., 100.,  20.,  22.,  83.,  70.,  39.,  74.,  37.,  90.,  63.,  46.,\n",
      "         85.,  56.,  24.,  44.,  50.,  19.,  36.,  20.], device='cuda:0')\n",
      "=========================================\n",
      "Epoch 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "750it [00:04, 175.96it/s]\n",
      "16it [00:00, 466.89it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch 1 / 10\n",
      "Validation Loss : 3765.67724609375\n",
      "Repartition centers : tensor([ 23., 100.,  20.,  22.,  83.,  70.,  39.,  76.,  39.,  90.,  63.,  46.,\n",
      "         83.,  56.,  24.,  42.,  49.,  19.,  36.,  20.], device='cuda:0')\n",
      "=========================================\n",
      "Epoch 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "750it [00:04, 169.61it/s]\n",
      "16it [00:00, 474.63it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch 2 / 10\n",
      "Validation Loss : 3751.8720703125\n",
      "Repartition centers : tensor([ 23., 100.,  20.,  22.,  83.,  70.,  37.,  76.,  38.,  89.,  65.,  46.,\n",
      "         83.,  56.,  24.,  42.,  50.,  19.,  37.,  20.], device='cuda:0')\n",
      "=========================================\n",
      "Epoch 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "750it [00:04, 177.96it/s]\n",
      "16it [00:00, 511.93it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch 3 / 10\n",
      "Validation Loss : 3740.9912109375\n",
      "Repartition centers : tensor([24., 99., 20., 22., 83., 70., 36., 76., 40., 87., 66., 47., 81., 56.,\n",
      "        24., 41., 52., 19., 37., 20.], device='cuda:0')\n",
      "=========================================\n",
      "Epoch 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "750it [00:04, 171.56it/s]\n",
      "16it [00:00, 511.75it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch 4 / 10\n",
      "Validation Loss : 3731.99072265625\n",
      "Repartition centers : tensor([24., 99., 19., 23., 83., 70., 36., 76., 40., 87., 66., 46., 80., 56.,\n",
      "        24., 41., 53., 19., 38., 20.], device='cuda:0')\n",
      "=========================================\n",
      "Epoch 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "750it [00:04, 176.02it/s]\n",
      "16it [00:00, 519.66it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch 5 / 10\n",
      "Validation Loss : 3724.40380859375\n",
      "Repartition centers : tensor([24., 98., 19., 23., 82., 70., 36., 76., 40., 87., 66., 47., 80., 56.,\n",
      "        24., 41., 53., 19., 39., 20.], device='cuda:0')\n",
      "=========================================\n",
      "Epoch 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "750it [00:04, 172.59it/s]\n",
      "16it [00:00, 534.03it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch 6 / 10\n",
      "Validation Loss : 3717.9736328125\n",
      "Repartition centers : tensor([27., 98., 19., 23., 82., 70., 34., 75., 40., 85., 66., 47., 80., 56.,\n",
      "        23., 42., 55., 19., 39., 20.], device='cuda:0')\n",
      "=========================================\n",
      "Epoch 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "750it [00:04, 171.09it/s]\n",
      "16it [00:00, 461.04it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch 7 / 10\n",
      "Validation Loss : 3712.444580078125\n",
      "Repartition centers : tensor([27., 97., 19., 23., 84., 67., 34., 75., 41., 85., 66., 48., 80., 56.,\n",
      "        23., 42., 55., 19., 39., 20.], device='cuda:0')\n",
      "=========================================\n",
      "Epoch 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "750it [00:04, 177.96it/s]\n",
      "16it [00:00, 428.87it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch 8 / 10\n",
      "Validation Loss : 3707.639404296875\n",
      "Repartition centers : tensor([27., 97., 19., 24., 84., 67., 33., 73., 41., 85., 65., 47., 80., 56.,\n",
      "        23., 43., 58., 19., 39., 20.], device='cuda:0')\n",
      "=========================================\n",
      "Epoch 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "750it [00:04, 169.09it/s]\n",
      "16it [00:00, 489.71it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Epoch 9 / 10\n",
      "Validation Loss : 3703.4296875\n",
      "Repartition centers : tensor([27., 97., 19., 26., 84., 67., 33., 72., 40., 85., 66., 45., 80., 56.,\n",
      "        23., 41., 60., 19., 40., 20.], device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Choose the model for the imputation :\n",
    "mixture_of_logistics = train_MixtureOfLogistics(loader, # Dataset loader\n",
    "                                        model_dir=None,\n",
    "                                        nb_component = 20, # Number of component for the mixture\n",
    "                                        epochs = 10,\n",
    "                                        transform_mean = 0, # Parameters to reconstruct the data\n",
    "                                        transform_std = 255,\n",
    "                                        batch_size = 64,\n",
    "                                        lr = 1e-4,\n",
    "                                        verbose=False)\n",
    "\n",
    "\n",
    "multiple_imputation_module = MixtureOfLogisticsImputation(mixture=mixture_of_logistics, mean_imputation=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ModuleImputation(\n",
       "  (module): MixtureOfLogisticsImputation(\n",
       "    (mixture): MixtureOfLogistics()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imputation = ModuleImputation(\n",
    "                module=multiple_imputation_module,\n",
    "                add_mask = add_mask,\n",
    "            )\n",
    "imputation.requires_grad_(False)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regularization (if any)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "regularization = None\n",
    "# In case of subset sampling, regularization = None."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Distribution for the selection module (associated with the MC gradient estimator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "rate = 0.1\n",
    "nb_dim = np.prod(next(iter(loader.train_loader))[0][0].shape)\n",
    "from missingDataTrainingModule import PytorchDistributionUtils\n",
    "distribution = partial(PytorchDistributionUtils.distribution.RelaxedSubsetSampling_STE, k = int(rate * nb_dim))\n",
    "distribution_module = PytorchDistributionUtils.wrappers.DistributionWithTemperatureParameter(distribution=distribution,)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Larger modules "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "prediction_module = PredictionModule(classifier, imputation=imputation, input_size=dataset.get_dim_input(),)\n",
    "selection_module = SelectionModule(selector, regularization=regularization, activation=torch.nn.LogSigmoid())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "interpretable_module = COUPLED_SELECTION(prediction_module,\n",
    "                                selection_module,\n",
    "                                distribution_module,\n",
    "                                reshape_mask_function)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trainer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_function = NLLLossAugmented(reduction='none')  # We need to use a wrapper around the loss function to be able\n",
    "                                                    # to handle the importance samples.\n",
    "monte_carlo_gradient_estimator = PytorchDistributionUtils.gradientestimator.PathWise\n",
    "\n",
    "\n",
    "trainer = SINGLE_LOSS(interpretable_module = interpretable_module,\n",
    "            monte_carlo_gradient_estimator= monte_carlo_gradient_estimator,\n",
    "            loss_function = loss_function,\n",
    "            nb_sample_z_monte_carlo = 1,\n",
    "            nb_sample_z_iwae = 10)\n",
    "if torch.cuda.is_available():\n",
    "    trainer.cuda()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "optim_prediction = Adam(prediction_module.parameters(), lr=1e-4)\n",
    "scheduler_prediction = None\n",
    "optim_selection = Adam(selection_module.parameters(), lr=1e-4)\n",
    "scheduler_selection = None\n",
    "nb_epoch = 40\n",
    "\n",
    "trainer.compile(\n",
    "            optim_classification = optim_prediction,\n",
    "            optim_selection = optim_selection,\n",
    "            scheduler_classification = scheduler_prediction,\n",
    "            scheduler_selection = scheduler_selection,\n",
    "            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "epoch_scheduler = classic_train_epoch(save_dic = False, verbose=True,)\n",
    "\n",
    "\n",
    "best_train_loss_in_test = float(\"inf\")\n",
    "total_dic_train = {}\n",
    "total_dic_test = {}\n",
    "for epoch in range(nb_epoch):\n",
    "    dic_train = epoch_scheduler(epoch, loader, trainer)\n",
    "    total_dic_train = fill_dic(total_dic_train, dic_train)\n",
    "    with torch.no_grad():\n",
    "        dic_test = test_epoch(interpretable_module, epoch, loader, liste_mc = [(1,1,1,1)], trainer = trainer, use_cuda=True)\n",
    "        total_dic_test = fill_dic(total_dic_test, dic_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "from interpretation_image import get_enough_data_per_target\n",
    "indexes, data, target, quadrant = get_enough_data_per_target(loader, 1)\n",
    "target, indices = torch.sort(target)\n",
    "data = data[indices]\n",
    "quadrant = quadrant[indices]\n",
    "wanted_shape = data.shape[1:]\n",
    "\n",
    "with torch.no_grad():\n",
    "    log_pi_list,_ = interpretable_module.selection_module(data.cuda())\n",
    "    pi_list = torch.exp(log_pi_list)\n",
    "    pi_list_selected = get_sel_pred(interpretable_module, pi_list, rate = None)\n",
    "    pz = interpretable_module.distribution_module(torch.exp(log_pi_list))\n",
    "\n",
    "\n",
    "    pi_list_selected = interpretable_module.reshape(pi_list_selected)\n",
    "    pi_list = interpretable_module.reshape(pi_list)\n",
    "\n",
    "    z = interpretable_module.distribution_module.sample((100,))\n",
    "    pi_list_sampled = z.mean(dim=0).detach().cpu()\n",
    "    pi_list_sampled = interpretable_module.reshape(pi_list_sampled)\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Explanations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x2000 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "fig, ax = plt.subplots(10,2, figsize=(8,20))\n",
    "for k in range(10) :\n",
    "    ax[k,0].imshow(data[k].reshape((28,56)), cmap = \"gray\")\n",
    "    ax[k,1].imshow(pi_list_sampled[k].reshape((28,56)), cmap = \"gray\")\n",
    "    ax[k,0].set_title(\"Target : {}\".format(target[k]))\n",
    "    ax[k,1].set_title(\"Sampled mask\")\n",
    "    ax[k,0].axis(\"off\")\n",
    "    ax[k,1].axis(\"off\")\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py38",
   "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.8.16"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "7c8e5dd2c6bc67dba6fc1db740e13d84ecd7ffddd42c23cce7e54c07b35a0531"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}