11-train_SIMPLE_CNN_RNN_without_position_and_salience_fasttext_fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train 11-train_SIMPLE_CNN_RNN_without_position_and_salience"
   ]
  },
  {
   "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=0)\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: 0\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 = \"11-train_SIMPLE_CNN_RNN_without_position_and_salience_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=0)"
      ]
     },
     "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.Wnovelty = 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",
    "\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",
    "            novelties_for_position = -1 * self.Wnovelty(sents_all_docs[position::max_doc_lens], torch.tanh(ses))\n",
    "            prob = contents_for_position + novelties_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(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",
       "  (Wnovelty): 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:02<00:00,  8.37batch/s, accuracy=0.756, loss=0.533, mae=0.307]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.552, val mae = 0.404, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:02<00:00, 10.67batch/s, accuracy=0.781, loss=0.432, mae=0.261]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.514, val mae = 0.366, val accuracy = 0.776, r1 = 0.326, r2 = 0.110, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:02<00:00, 11.47batch/s, accuracy=0.771, loss=0.432, mae=0.274]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.487, val mae = 0.323, val accuracy = 0.776, r1 = 0.326, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:02<00:00, 11.06batch/s, accuracy=0.794, loss=0.415, mae=0.26] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.473, val mae = 0.327, val accuracy = 0.773, r1 = 0.323, r2 = 0.108, rL = 0.213\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:02<00:00, 11.41batch/s, accuracy=0.784, loss=0.411, mae=0.271]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.470, val mae = 0.330, val accuracy = 0.774, r1 = 0.321, r2 = 0.107, rL = 0.213\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:02<00:00, 10.21batch/s, accuracy=0.787, loss=0.389, mae=0.253]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.467, val mae = 0.325, val accuracy = 0.774, r1 = 0.320, r2 = 0.109, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:02<00:00, 10.90batch/s, accuracy=0.789, loss=0.394, mae=0.26] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.466, val mae = 0.326, val accuracy = 0.774, r1 = 0.320, r2 = 0.108, rL = 0.213\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:02<00:00, 11.28batch/s, accuracy=0.771, loss=0.418, mae=0.273]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.466, val mae = 0.324, val accuracy = 0.774, r1 = 0.322, r2 = 0.109, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:02<00:00, 10.99batch/s, accuracy=0.789, loss=0.401, mae=0.264]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.465, val mae = 0.323, val accuracy = 0.774, r1 = 0.321, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:02<00:00, 10.07batch/s, accuracy=0.799, loss=0.387, mae=0.253]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.464, val mae = 0.324, val accuracy = 0.774, r1 = 0.320, r2 = 0.108, rL = 0.213\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:02<00:00, 10.68batch/s, accuracy=0.785, loss=0.393, mae=0.26] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.465, val mae = 0.325, val accuracy = 0.774, r1 = 0.320, r2 = 0.108, rL = 0.213\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:02<00:00, 11.15batch/s, accuracy=0.766, loss=0.407, mae=0.268]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.465, val mae = 0.325, val accuracy = 0.774, r1 = 0.320, r2 = 0.108, rL = 0.213\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:02<00:00, 10.60batch/s, accuracy=0.808, loss=0.378, mae=0.252]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.463, val mae = 0.323, val accuracy = 0.773, r1 = 0.320, r2 = 0.108, rL = 0.213\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 25/25 [00:02<00:00, 10.72batch/s, accuracy=0.794, loss=0.389, mae=0.257]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.466, val mae = 0.325, val accuracy = 0.774, r1 = 0.321, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 25/25 [00:02<00:00, 10.66batch/s, accuracy=0.785, loss=0.401, mae=0.262]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.466, val mae = 0.324, val accuracy = 0.774, r1 = 0.321, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 25/25 [00:02<00:00, 10.22batch/s, accuracy=0.803, loss=0.389, mae=0.256]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16 : val loss = 0.466, val mae = 0.326, val accuracy = 0.774, r1 = 0.320, r2 = 0.108, rL = 0.213\n",
      "Training duration = 73.54054188728333\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": [
       "13"
      ]
     },
     "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, 57.93batch/s, accuracy=0.748, mae=0.384, rouge1=0.34, rouge2=0.0993, rougeL=0.203]\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, 137.74batch/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, 138.37batch/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
}