15-train_SIMPLE_CNN_RNN_content_only_Glove300.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train 15-train_SIMPLE_CNN_RNN_content_only"
   ]
  },
  {
   "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.GloveMgr import GloveMgr\n",
    "from utils.Dataset import Dataset\n",
    "from utils.DataLoader import DataLoader\n",
    "from utils.preprocess_df import preprocess_df\n",
    "from utils.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn\n",
    "from utils.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=3)\n",
    "parser.add_argument('-batch_size',type=int,default=8)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "parser.add_argument('-dataset',type=str,default=\"./data/nyt_corpus_LDC2008T19_50\")\n",
    "parser.add_argument('-doc_col_name',type=str,default=\"docs\")\n",
    "parser.add_argument('-label_col_name',type=str,default=\"labels\")\n",
    "parser.add_argument('-sum_col_name',type=str,default=\"summaries\")\n",
    "parser.add_argument('-max_doc_len',type=int,default=50)\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: 3\n",
      "epochs 100\n",
      "batch_size 8\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"glove.6B.300\"\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 = \"15-train_SIMPLE_CNN_RNN_content_only_Glove300\"\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=3)"
      ]
     },
     "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 = GloveMgr(\"./data/glove.6B/glove.6B.300d.txt\", vocab_size=vocab_size)"
   ]
  },
  {
   "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.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",
    "\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",
    "            prob = contents_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\n"
   ]
  },
  {
   "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(150002, 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",
       ")"
      ]
     },
     "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/13 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/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%|██████████| 13/13 [00:01<00:00, 12.43batch/s, accuracy=0.718, loss=0.516, mae=0.333]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.539, val mae = 0.404, val accuracy = 0.866, r1 = 0.503, r2 = 0.306, rL = 0.387\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 13/13 [00:00<00:00, 25.46batch/s, accuracy=0.821, loss=0.451, mae=0.274]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.471, val mae = 0.351, val accuracy = 0.866, r1 = 0.505, r2 = 0.308, rL = 0.388\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 13/13 [00:00<00:00, 25.63batch/s, accuracy=0.817, loss=0.42, mae=0.279]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.409, val mae = 0.287, val accuracy = 0.866, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 13/13 [00:00<00:00, 25.05batch/s, accuracy=0.819, loss=0.406, mae=0.26] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.394, val mae = 0.269, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 13/13 [00:00<00:00, 25.92batch/s, accuracy=0.815, loss=0.402, mae=0.258]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.391, val mae = 0.269, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 13/13 [00:00<00:00, 25.71batch/s, accuracy=0.819, loss=0.401, mae=0.258]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.389, val mae = 0.267, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 13/13 [00:00<00:00, 25.73batch/s, accuracy=0.815, loss=0.405, mae=0.261]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.388, val mae = 0.268, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 13/13 [00:00<00:00, 25.80batch/s, accuracy=0.818, loss=0.398, mae=0.258]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.388, val mae = 0.268, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 13/13 [00:00<00:00, 25.35batch/s, accuracy=0.811, loss=0.403, mae=0.26]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.388, val mae = 0.267, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 13/13 [00:00<00:00, 24.51batch/s, accuracy=0.821, loss=0.398, mae=0.258]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.388, val mae = 0.267, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 13/13 [00:00<00:00, 25.98batch/s, accuracy=0.814, loss=0.405, mae=0.261]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.388, val mae = 0.268, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 13/13 [00:00<00:00, 27.31batch/s, accuracy=0.815, loss=0.406, mae=0.261]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.388, val mae = 0.267, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 13/13 [00:00<00:00, 25.93batch/s, accuracy=0.819, loss=0.395, mae=0.257]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.388, val mae = 0.268, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 13/13 [00:00<00:00, 25.42batch/s, accuracy=0.816, loss=0.398, mae=0.259]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.388, val mae = 0.268, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 13/13 [00:00<00:00, 25.62batch/s, accuracy=0.809, loss=0.405, mae=0.261]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.388, val mae = 0.268, val accuracy = 0.867, r1 = 0.506, r2 = 0.310, rL = 0.391\n",
      "Training duration = 31.557021379470825\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",
    "        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": [
       "12"
      ]
     },
     "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: 100%|██████████| 100/100 [00:01<00:00, 64.83batch/s, accuracy=0.864, mae=0.259, rouge1=0.43, rouge2=0.234, rougeL=0.319]\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",
    "        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, 111.03batch/s, rouge1=0.435, rouge2=0.241, rougeL=0.325]\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, 120.25batch/s, rouge1=0.435, rouge2=0.241, rougeL=0.325]\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
}