03-train_COMPLEX_CNN_RNN_fasttext_fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train COMPLEX_CNN_RNN"
   ]
  },
  {
   "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 models.COMPLEX_CNN_RNN import COMPLEX_CNN_RNN\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=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: 3\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 = \"03-train_COMPLEX_CNN_RNN_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=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 = 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": null,
   "id": "9683721f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "380f8ba1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = COMPLEX_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2ae1a236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "COMPLEX_CNN_RNN(\n",
       "  (word_embedding): Embedding(150001, 300)\n",
       "  (word_convs): Sequential(\n",
       "    (0): Conv1d(300, 100, kernel_size=(3,), 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",
       "    (3): Conv1d(100, 100, kernel_size=(4,), stride=(1,), padding=same)\n",
       "    (4): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (5): ReLU(inplace=True)\n",
       "    (6): Conv1d(100, 100, kernel_size=(5,), stride=(1,), padding=same)\n",
       "    (7): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (8): ReLU(inplace=True)\n",
       "  )\n",
       "  (sent_GRU): GRU(100, 200, batch_first=True, bidirectional=True)\n",
       "  (rel_pos_emb): Embedding(11, 100)\n",
       "  (abs_pos_emb): Embedding(100, 100)\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",
       "  (Wnovelty): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       "  (Wabs_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       "  (Wrel_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": 15,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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": 17,
   "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:03<00:00,  6.76batch/s, accuracy=0.737, loss=0.603, mae=0.303]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.531, val mae = 0.335, val accuracy = 0.776, r1 = 0.276, r2 = 0.084, rL = 0.174\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:03<00:00,  8.19batch/s, accuracy=0.763, loss=0.456, mae=0.273]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.514, val mae = 0.343, val accuracy = 0.776, r1 = 0.280, r2 = 0.090, rL = 0.177\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:03<00:00,  7.96batch/s, accuracy=0.777, loss=0.429, mae=0.241]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.486, val mae = 0.320, val accuracy = 0.776, r1 = 0.308, r2 = 0.097, rL = 0.199\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:03<00:00,  8.33batch/s, accuracy=0.785, loss=0.404, mae=0.253]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.470, val mae = 0.304, val accuracy = 0.777, r1 = 0.326, r2 = 0.111, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:03<00:00,  7.54batch/s, accuracy=0.782, loss=0.402, mae=0.24] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.473, val mae = 0.319, val accuracy = 0.776, r1 = 0.321, r2 = 0.108, rL = 0.212\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:03<00:00,  8.29batch/s, accuracy=0.785, loss=0.398, mae=0.252]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.465, val mae = 0.312, val accuracy = 0.777, r1 = 0.329, r2 = 0.112, rL = 0.219\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:02<00:00,  8.75batch/s, accuracy=0.778, loss=0.406, mae=0.255]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.463, val mae = 0.309, val accuracy = 0.776, r1 = 0.330, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:02<00:00,  8.51batch/s, accuracy=0.794, loss=0.393, mae=0.248]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.462, val mae = 0.308, val accuracy = 0.776, r1 = 0.330, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:02<00:00,  8.89batch/s, accuracy=0.784, loss=0.399, mae=0.252]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.462, val mae = 0.309, val accuracy = 0.776, r1 = 0.330, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:02<00:00,  8.92batch/s, accuracy=0.776, loss=0.422, mae=0.262]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.462, val mae = 0.308, val accuracy = 0.777, r1 = 0.330, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:03<00:00,  7.78batch/s, accuracy=0.776, loss=0.393, mae=0.247]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.462, val mae = 0.308, val accuracy = 0.777, r1 = 0.329, r2 = 0.112, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:02<00:00,  9.44batch/s, accuracy=0.784, loss=0.396, mae=0.249]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.461, val mae = 0.308, val accuracy = 0.776, r1 = 0.330, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:02<00:00,  8.58batch/s, accuracy=0.797, loss=0.381, mae=0.237]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.462, val mae = 0.309, val accuracy = 0.777, r1 = 0.330, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 25/25 [00:02<00:00,  8.52batch/s, accuracy=0.79, loss=0.393, mae=0.244] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.461, val mae = 0.308, val accuracy = 0.776, r1 = 0.329, r2 = 0.112, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 25/25 [00:02<00:00,  9.25batch/s, accuracy=0.761, loss=0.422, mae=0.26] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.462, val mae = 0.309, val accuracy = 0.777, r1 = 0.330, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 25/25 [00:02<00:00,  8.60batch/s, accuracy=0.783, loss=0.41, mae=0.252] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16 : val loss = 0.461, val mae = 0.307, val accuracy = 0.777, r1 = 0.329, r2 = 0.112, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|██████████| 25/25 [00:02<00:00,  8.96batch/s, accuracy=0.786, loss=0.395, mae=0.25] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17 : val loss = 0.463, val mae = 0.310, val accuracy = 0.776, r1 = 0.330, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18: 100%|██████████| 25/25 [00:02<00:00,  9.03batch/s, accuracy=0.782, loss=0.41, mae=0.254] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 18 : val loss = 0.463, val mae = 0.310, val accuracy = 0.776, r1 = 0.330, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19: 100%|██████████| 25/25 [00:02<00:00,  9.06batch/s, accuracy=0.786, loss=0.412, mae=0.258]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 19 : val loss = 0.460, val mae = 0.306, val accuracy = 0.777, r1 = 0.329, r2 = 0.112, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 25/25 [00:03<00:00,  7.64batch/s, accuracy=0.797, loss=0.379, mae=0.234]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 20 : val loss = 0.464, val mae = 0.312, val accuracy = 0.777, r1 = 0.329, r2 = 0.112, rL = 0.219\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 21: 100%|██████████| 25/25 [00:03<00:00,  8.15batch/s, accuracy=0.794, loss=0.388, mae=0.242]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 21 : val loss = 0.463, val mae = 0.310, val accuracy = 0.777, r1 = 0.329, r2 = 0.113, rL = 0.219\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 22: 100%|██████████| 25/25 [00:03<00:00,  8.06batch/s, accuracy=0.795, loss=0.379, mae=0.244]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 22 : val loss = 0.462, val mae = 0.309, val accuracy = 0.776, r1 = 0.330, r2 = 0.113, rL = 0.220\n",
      "Training duration = 125.89437651634216\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": 18,
   "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": 19,
   "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": 20,
   "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": 21,
   "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": 22,
   "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": 23,
   "id": "273c6eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = COMPLEX_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4fc41994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 24,
     "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": 25,
   "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": 26,
   "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": 27,
   "id": "67659b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:02<00:00, 34.90batch/s, accuracy=0.789, mae=0.322, rouge1=0.315, rouge2=0.0868, rougeL=0.192]\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": 28,
   "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": 29,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:00<00:00, 195.42batch/s, rouge1=0.309, rouge2=0.0904, rougeL=0.195]\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(\"Lead-3\")\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), 3)):\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": 30,
   "id": "a4c96c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 137.26batch/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": 31,
   "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
}