12-train_SIMPLE_CNN_RNN_without_position_and_novelty_fasttext_fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train 12-train_SIMPLE_CNN_RNN_without_position_and_novelty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a8a5bd39",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.utils import clip_grad_norm_\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils_french.EmbMgr import EmbMgr\n",
    "from utils_french.Dataset import Dataset\n",
    "from utils_french.DataLoader import DataLoader\n",
    "from utils_french.preprocess_df import preprocess_df\n",
    "from utils_french.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils_french.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn\n",
    "from utils_french.split_all_docs import split_all_docs\n",
    "\n",
    "from time import time\n",
    "\n",
    "import json\n",
    "import argparse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "818410ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_notebook() -> bool:\n",
    "    try:\n",
    "        shell = get_ipython().__class__.__name__\n",
    "        if shell == 'ZMQInteractiveShell':\n",
    "            return True   # Jupyter notebook or qtconsole\n",
    "        elif shell == 'TerminalInteractiveShell':\n",
    "            return False  # Terminal running IPython\n",
    "        else:\n",
    "            return False  # Other type (?)\n",
    "    except NameError:\n",
    "        return False      # Probably standard Python interpreter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "690fa032",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "pd.set_option('display.max_rows', None)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b2636e0b",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6e7aad39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse args if script mode\n",
    "parser = argparse.ArgumentParser(description='extractive summary')\n",
    "\n",
    "parser.add_argument('-is_graphic',type=int,default=1,choices=[0,1])\n",
    "parser.add_argument('-gpu_num',type=int,default=1)\n",
    "parser.add_argument('-batch_size',type=int,default=4)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "parser.add_argument('-dataset',type=str,default=\"./data/wiki_geo_ratio_sc_0.5/\")\n",
    "parser.add_argument('-doc_col_name',type=str,default=\"flat_contents\")\n",
    "parser.add_argument('-label_col_name',type=str,default=\"labels_sentences\")\n",
    "parser.add_argument('-sum_col_name',type=str,default=\"summaries\")\n",
    "parser.add_argument('-max_doc_len',type=int,default=100)\n",
    "\n",
    "args = None\n",
    "\n",
    "if is_notebook():\n",
    "    args = parser.parse_args(\"\")\n",
    "else:\n",
    "    args = parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "824eacf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 1\n",
      "epochs 100\n",
      "batch_size 4\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"cc.fr.300.vec\"\n",
    "\n",
    "# hyper-parameters\n",
    "vocab_size = 150000\n",
    "batch_size = args.batch_size\n",
    "epochs = args.epochs\n",
    "learning_rate = 1e-3\n",
    "early_stopping = 3\n",
    "model_name = \"12-train_SIMPLE_CNN_RNN_without_position_and_novelty_FastTextfr\"\n",
    "sub_folder_name = \"model_name__{}__time__{}__embed_name__{}__lr__{}__batch_size__{}__vocab_size__{}__cuda_num__{}\".format(model_name, time(), embed_name, learning_rate, batch_size, vocab_size, cuda_num)\n",
    "checkpoints_folder = \"./checkpoints/\" + sub_folder_name\n",
    "average_number_of_sentences_per_document = 3\n",
    "\n",
    "# print\n",
    "print(\"parse:\")\n",
    "print(\"is_graphic:\", is_graphic)\n",
    "print(\"cuda_num:\", cuda_num)\n",
    "print(\"epochs\", epochs)\n",
    "print(\"batch_size\", batch_size)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c8ddd4d5",
   "metadata": {},
   "source": [
    "## PyTorch initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d09bc3ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of available GPUs: 6\n",
      "GPU 0: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 1: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 2: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 3: NVIDIA GeForce GTX 1080\n",
      "GPU 4: NVIDIA GeForce GTX 1080\n",
      "GPU 5: NVIDIA GeForce GTX 1080\n"
     ]
    }
   ],
   "source": [
    "# Check if a GPU is available\n",
    "if torch.cuda.is_available():\n",
    "    # Display the number of available GPUs\n",
    "    print(f\"Number of available GPUs: {torch.cuda.device_count()}\")\n",
    "    # Display the name of each GPU\n",
    "    for i in range(torch.cuda.device_count()):\n",
    "        print(f\"GPU {i}: {torch.cuda.get_device_name(i)}\")\n",
    "else:\n",
    "    print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b0c5786e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=1)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3393fe4e",
   "metadata": {},
   "source": [
    "## Chargement des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "97644745",
   "metadata": {},
   "outputs": [],
   "source": [
    "glovemgr = EmbMgr(\"./data/cc.fr.300.vec\", vocab_size=vocab_size, header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fe745c8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_json(args.dataset + \"/train.json\")\n",
    "train_dataset = Dataset(preprocess_df(df_train, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "train_iter = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f8b39f3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val = pd.read_json(args.dataset + \"/val.json\")\n",
    "val_dataset = Dataset(preprocess_df(df_val, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "val_iter = DataLoader(dataset=val_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0f086978",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(args.dataset + \"/test.json\")\n",
    "test_dataset = Dataset(preprocess_df(df_test, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "test_iter = DataLoader(dataset=test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fc41eb07",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9683721f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from models.BasicModel import BasicModel\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "\n",
    "class SIMPLE_CNN_RNN(BasicModel):\n",
    "    def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 100):\n",
    "        super(SIMPLE_CNN_RNN, self).__init__(device)\n",
    "\n",
    "        self.device = device\n",
    "\n",
    "        self.word_embedding = nn.Embedding(vocab_size+2, dim_word_embed, padding_idx=0)\n",
    "        # Load word embedding if specified\n",
    "        if word_embed is not None:\n",
    "            self.word_embedding = torch.nn.Embedding.from_pretrained(torch.from_numpy(word_embed).float())\n",
    "\n",
    "        # 100 : word2vec embedding size\n",
    "        self.word_convs = nn.Sequential(\n",
    "                            nn.Conv1d(in_channels=dim_word_embed,out_channels=100,kernel_size=4,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True))\n",
    "        self.sent_GRU = nn.GRU(input_size = 100, hidden_size=200, batch_first = True, bidirectional = True)\n",
    "\n",
    "        self.Wdoc = nn.Linear(2*200,2*200,bias=True)\n",
    "\n",
    "        self.Wcontent = nn.Linear(2*200,1,bias=False)\n",
    "        self.Wsalience = nn.Bilinear(2*200,2*200,1,bias=False)\n",
    "        self.bias = nn.Parameter(torch.empty(1).uniform_(-0.1, 0.1))\n",
    "\n",
    "    def avg_pool1d(self,x,seq_lens):\n",
    "        out = []\n",
    "        for index,t in enumerate(x):\n",
    "            if seq_lens[index] == 0:\n",
    "                t = t[:1]\n",
    "            else:\n",
    "                t = t[:seq_lens[index],:]\n",
    "            t = torch.t(t).unsqueeze(0)\n",
    "            out.append(torch.avg_pool1d(t,t.size(2)))\n",
    "        \n",
    "        out = torch.cat(out).squeeze(2)\n",
    "        return out\n",
    "\n",
    "    def forward(self, arr_x, doc_lens):\n",
    "        probs = []\n",
    "\n",
    "        max_doc_lens = max(doc_lens)\n",
    "        #sent_lens = torch.sum(torch.sign(arr_x),dim=1).data\n",
    "\n",
    "        arr_x = self.word_embedding(arr_x)\n",
    "        arr_x = self.word_convs(arr_x.permute(0,2,1))\n",
    "        arr_x = torch.avg_pool1d(arr_x, arr_x.size(2)).squeeze(2)\n",
    "\n",
    "        arr_x = self.pad_doc(arr_x, doc_lens)\n",
    "\n",
    "        arr_x = self.sent_GRU(arr_x)[0]\n",
    "        sents_all_docs = arr_x.reshape(len(doc_lens) * max_doc_lens, 2*200) # flat docs\n",
    "        \n",
    "        docs = self.avg_pool1d(arr_x, doc_lens)\n",
    "        docs = torch.tanh(self.Wdoc(docs))\n",
    "        docs_for_each_sent = docs.repeat_interleave(max_doc_lens, dim=0) # repeat doc n times\n",
    "        \n",
    "        contents = self.Wcontent(sents_all_docs)\n",
    "        saliences = self.Wsalience(sents_all_docs, docs_for_each_sent)\n",
    "\n",
    "        # doc_len (number) s\n",
    "        ses = torch.zeros(len(doc_lens), 2*200)\n",
    "        ses = ses.to(self.device)\n",
    "\n",
    "        # for each document, compute probabilities\n",
    "        for position in range(max_doc_lens):\n",
    "            contents_for_position = contents[position::max_doc_lens]\n",
    "            saliences_for_position = saliences[position::max_doc_lens]\n",
    "            prob = contents_for_position + saliences_for_position + self.bias\n",
    "            prob = torch.sigmoid(prob)\n",
    "            probs.append(prob)\n",
    "\n",
    "            ses = ses + torch.mul(sents_all_docs[position::max_doc_lens], prob)\n",
    "        probs = torch.cat(probs).squeeze()\n",
    "        if len(probs.shape) == 0:\n",
    "            probs = probs.unsqueeze(0)\n",
    "        probs_filtered = []\n",
    "        for idx, doc_len in enumerate(doc_lens):\n",
    "            prob = probs[idx::len(doc_lens)]\n",
    "            prob = prob[:doc_len]\n",
    "            probs_filtered.append(prob)\n",
    "        probs_filtered = torch.cat(probs_filtered).squeeze()\n",
    "        if len(probs_filtered.shape) == 0:\n",
    "            probs_filtered = probs_filtered.unsqueeze(0)\n",
    "        #probs = probs.to(self.device)\n",
    "        return probs_filtered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "380f8ba1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SIMPLE_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2ae1a236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SIMPLE_CNN_RNN(\n",
       "  (word_embedding): Embedding(150001, 300)\n",
       "  (word_convs): Sequential(\n",
       "    (0): Conv1d(300, 100, kernel_size=(4,), stride=(1,), padding=same)\n",
       "    (1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "  )\n",
       "  (sent_GRU): GRU(100, 200, batch_first=True, bidirectional=True)\n",
       "  (Wdoc): Linear(in_features=400, out_features=400, bias=True)\n",
       "  (Wcontent): Linear(in_features=400, out_features=1, bias=False)\n",
       "  (Wsalience): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4bc411ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.BCELoss()\n",
    "optimizer = torch.optim.Adamax(model.parameters(),lr=learning_rate)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.5)\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1852182a",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c6618af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[args.doc_col_name], is_sep_n = False)\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0991d3c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/25 [00:00<?, ?batch/s]/home/raoufdine/.local/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 25/25 [00:01<00:00, 13.24batch/s, accuracy=0.705, loss=0.568, mae=0.355]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.633, val mae = 0.463, val accuracy = 0.776, r1 = 0.323, r2 = 0.107, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:01<00:00, 16.53batch/s, accuracy=0.757, loss=0.471, mae=0.308]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.568, val mae = 0.414, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:01<00:00, 16.97batch/s, accuracy=0.768, loss=0.449, mae=0.271]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.495, val mae = 0.330, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:01<00:00, 16.13batch/s, accuracy=0.777, loss=0.416, mae=0.268]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.478, val mae = 0.308, val accuracy = 0.776, r1 = 0.326, r2 = 0.110, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:01<00:00, 16.60batch/s, accuracy=0.779, loss=0.401, mae=0.244]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.474, val mae = 0.308, val accuracy = 0.776, r1 = 0.326, r2 = 0.110, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:01<00:00, 17.01batch/s, accuracy=0.783, loss=0.404, mae=0.246]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.475, val mae = 0.304, val accuracy = 0.776, r1 = 0.326, r2 = 0.110, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:01<00:00, 17.21batch/s, accuracy=0.78, loss=0.403, mae=0.253] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.474, val mae = 0.303, val accuracy = 0.776, r1 = 0.326, r2 = 0.110, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:01<00:00, 17.01batch/s, accuracy=0.776, loss=0.416, mae=0.252]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.473, val mae = 0.305, val accuracy = 0.776, r1 = 0.326, r2 = 0.110, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:01<00:00, 17.18batch/s, accuracy=0.755, loss=0.433, mae=0.267]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.473, val mae = 0.307, val accuracy = 0.776, r1 = 0.326, r2 = 0.110, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:01<00:00, 17.21batch/s, accuracy=0.783, loss=0.411, mae=0.256]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.473, val mae = 0.307, val accuracy = 0.776, r1 = 0.326, r2 = 0.110, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:01<00:00, 17.37batch/s, accuracy=0.769, loss=0.417, mae=0.263]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.473, val mae = 0.305, val accuracy = 0.776, r1 = 0.326, r2 = 0.110, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:01<00:00, 17.31batch/s, accuracy=0.768, loss=0.425, mae=0.263]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.473, val mae = 0.306, val accuracy = 0.776, r1 = 0.326, r2 = 0.110, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:01<00:00, 17.06batch/s, accuracy=0.769, loss=0.408, mae=0.252]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.473, val mae = 0.308, val accuracy = 0.776, r1 = 0.326, r2 = 0.110, rL = 0.216\n",
      "Training duration = 39.42684531211853\n"
     ]
    }
   ],
   "source": [
    "arr_train_loss = []\n",
    "arr_train_mae = []\n",
    "arr_train_acc = []\n",
    "arr_val_loss = []\n",
    "arr_val_mae = []\n",
    "arr_val_acc = []\n",
    "\n",
    "t1 = time()\n",
    "for epoch in range(1, epochs+1):\n",
    "    # train 1 epoch\n",
    "    model.train()\n",
    "    nb_batch_train = 0\n",
    "    total_train_loss = 0\n",
    "    total_train_mae = 0\n",
    "    total_train_acc = 0\n",
    "    with tqdm(train_iter, unit=\"batch\", total=len(train_iter)) as tepoch:\n",
    "        for batch in tepoch:\n",
    "            tepoch.set_description(f\"Epoch {epoch}\")\n",
    "            features = []\n",
    "            doc_lens = []\n",
    "\n",
    "            for j in range(batch_size):\n",
    "                doc_lens.append(len(batch[j][\"docs\"]))\n",
    "                features = features + batch[j][\"docs\"]\n",
    "            \n",
    "            features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "            targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(batch_size)]\n",
    "            targets = torch.cat(targets)\n",
    "            targets = targets.to(device)\n",
    "            \n",
    "            probs = model(features, doc_lens)\n",
    "            \n",
    "            loss = loss_fn(probs, targets)\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            clip_grad_norm_(model.parameters(), 1.0)\n",
    "            optimizer.step()\n",
    "            nb_batch_train += 1\n",
    "            total_train_loss += loss.item()\n",
    "            total_train_mae += mae_fn(probs, targets).item()\n",
    "            total_train_acc += accuracy_prop_sent_per_doc_fn(probs=probs.cpu().detach().numpy(), targets=targets.cpu().detach().numpy(), doc_lens=doc_lens)\n",
    "            tepoch.set_postfix(loss=total_train_loss/nb_batch_train, mae=total_train_mae/nb_batch_train, accuracy=total_train_acc/nb_batch_train)\n",
    "\n",
    "    # Save model\n",
    "    model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "    # Show train and val score\n",
    "    model.eval()\n",
    "    nb_batch_val = 0\n",
    "    total_val_loss = 0\n",
    "    total_val_mae = 0\n",
    "    total_val_acc = 0\n",
    "\n",
    "    total_r1 = 0\n",
    "    total_r2 = 0\n",
    "    total_rl = 0\n",
    "\n",
    "    for i, batch in enumerate(val_iter):\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "            \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "        \n",
    "        y_pred = model(features, doc_lens)\n",
    "\n",
    "        loss = loss_fn(y_pred, targets)\n",
    "\n",
    "        nb_batch_val += 1\n",
    "        total_val_loss += loss.item()\n",
    "\n",
    "        doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "        summaries = val_set[args.sum_col_name].iloc[i]\n",
    "\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        if indices.shape[0] > len(doc):\n",
    "            continue\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[j]]\n",
    "            y_pred_thresh.append(indices[j])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in y_pred_thresh:\n",
    "            txt = txt + \". \" + doc[j]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        total_r1 += scores[\"rouge1\"].fmeasure\n",
    "        total_r2 += scores[\"rouge2\"].fmeasure\n",
    "        total_rl += scores[\"rougeL\"].fmeasure\n",
    "\n",
    "        probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        total_val_mae += mae_fn(probs_tensor, targets).item()\n",
    "        total_val_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "    arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "    arr_train_mae.append(total_train_mae / nb_batch_train)\n",
    "    arr_train_acc.append(total_train_acc / nb_batch_train)\n",
    "\n",
    "    arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "    arr_val_mae.append(total_val_mae / nb_batch_val)\n",
    "    arr_val_acc.append(total_val_acc / nb_batch_val)\n",
    "    \n",
    "    print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "\n",
    "    if len(arr_val_loss) >= early_stopping+1:\n",
    "        if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "            break\n",
    "\n",
    "    # update lr\n",
    "    scheduler.step()\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2f39ceed",
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_mae\"]  = arr_train_mae\n",
    "training_metrics[\"train_acc\"]  = arr_train_acc\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_mae\"]    = arr_val_mae\n",
    "training_metrics[\"val_acc\"]    = arr_val_acc\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "    json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8cd8fbee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Losses\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_loss) + 1)), arr_train_loss, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_loss) + 1)), arr_val_loss, label=\"val\")\n",
    "\n",
    "    plt.title(\"Loss\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"loss\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8bda887e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw mae\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_mae) + 1)), arr_train_mae, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_mae) + 1)), arr_val_mae, label=\"val\")\n",
    "\n",
    "    plt.title(\"MAE\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"mae\")\n",
    "    plt.legend(loc=\"upper right\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1cc21154",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Accuracies\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_acc) + 1)), arr_train_acc, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_acc) + 1)), arr_val_acc, label=\"val\")\n",
    "\n",
    "    plt.title(\"Accuracy\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"accuracy\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0133ff45",
   "metadata": {},
   "source": [
    "# Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e095b271",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.split_all_docs import split_all_docs\n",
    "from rouge_score import rouge_scorer\n",
    "from utils.threshold_probs import threshold_probs_by_prop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "273c6eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SIMPLE_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4fc41994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_epoch = np.argmin(np.array(arr_val_loss)) + 1\n",
    "model.load(checkpoints_folder + \"/\" + model_name + \"-\" + str(best_epoch) + \".pt\")\n",
    "model.to(device)\n",
    "model.eval()\n",
    "best_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3edbae7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_set = df_test\n",
    "test_set[\"doc_splited\"] = split_all_docs(test_set[args.doc_col_name], False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bb8ab07a",
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "67659b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model:   0%|          | 0/100 [00:00<?, ?batch/s, accuracy=0.62, mae=0.405, rouge1=0.446, rouge2=0.0852, rougeL=0.177]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:01<00:00, 94.67batch/s, accuracy=0.748, mae=0.358, rouge1=0.347, rouge2=0.105, rougeL=0.206]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Eval model\")\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "                \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        y_pred = model(features, doc_lens)\n",
    "    \n",
    "        loss = criterion(y_pred, targets)\n",
    "\n",
    "        arr_loss.append(loss.item())\n",
    "\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "        #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        if indices.shape[0] > len(doc):\n",
    "            continue\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[i]]\n",
    "            y_pred_thresh.append(indices[i])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[i]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        mae.append(mae_fn(probs_tensor, targets).item())\n",
    "\n",
    "        accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "        #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "        tepoch.set_postfix(accuracy = np.mean(accuracy), mae = np.mean(mae), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))\n",
    "        idx += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "5c1fd15f",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\n",
    "test_metrics[\"mae\"]      = np.mean(mae)\n",
    "test_metrics[\"rouge1\"]   = np.mean(arr_rouge1)\n",
    "test_metrics[\"rouge2\"]   = np.mean(arr_rouge2)\n",
    "test_metrics[\"rougeL\"]   = np.mean(arr_rougeL)\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/test_metrics.json\", 'w') as fp:\n",
    "    json.dump(test_metrics, fp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "496646f2",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 126.19batch/s, rouge1=0.325, rouge2=0.0923, rougeL=0.199]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a3c5d9",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a4c96c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 125.82batch/s, rouge1=0.325, rouge2=0.0923, rougeL=0.199]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e4f4796c",
   "metadata": {},
   "outputs": [
    {
     "ename": "SystemExit",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/raoufdine/anaconda3/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3465: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "# Does not excute this cell if you want to execute the following cells.\n",
    "import sys\n",
    "sys.exit()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "4f810f0bde7d7b5dc90f9e6832822547e13e234c53731a97fc91254323942f40"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}