10-train_SIMPLE_CNN_RNN_without_position_and_content_fasttext_fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train 10-train_SIMPLE_CNN_RNN_without_position_and_content"
   ]
  },
  {
   "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=5)\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: 5\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 = \"10-train_SIMPLE_CNN_RNN_without_position_and_content_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=5)"
      ]
     },
     "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.Wsalience = nn.Bilinear(2*200,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",
    "        saliences = self.Wsalience(sents_all_docs, docs_for_each_sent)\n",
    "\n",
    "        # doc_len (number) s\n",
    "        ses = torch.zeros(len(doc_lens), 2*200)\n",
    "        ses = ses.to(self.device)\n",
    "\n",
    "        # for each document, compute probabilities\n",
    "        for position in range(max_doc_lens):\n",
    "            saliences_for_position = saliences[position::max_doc_lens]\n",
    "            novelties_for_position = -1 * self.Wnovelty(sents_all_docs[position::max_doc_lens], torch.tanh(ses))\n",
    "            prob = saliences_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",
    "\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",
       "  (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",
       ")"
      ]
     },
     "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:03<00:00,  7.96batch/s, accuracy=0.753, loss=0.507, mae=0.286]\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,  9.93batch/s, accuracy=0.788, loss=0.416, mae=0.251]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.516, val mae = 0.372, val accuracy = 0.776, r1 = 0.314, r2 = 0.099, rL = 0.205\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:02<00:00,  9.82batch/s, accuracy=0.782, loss=0.411, mae=0.259]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.473, val mae = 0.335, val accuracy = 0.776, r1 = 0.328, r2 = 0.113, rL = 0.218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:02<00:00,  9.72batch/s, accuracy=0.792, loss=0.383, mae=0.238]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.455, val mae = 0.316, val accuracy = 0.775, r1 = 0.326, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:02<00:00, 10.18batch/s, accuracy=0.799, loss=0.387, mae=0.249]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.446, val mae = 0.302, val accuracy = 0.776, r1 = 0.327, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:02<00:00, 10.08batch/s, accuracy=0.79, loss=0.392, mae=0.254] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.449, val mae = 0.312, val accuracy = 0.776, r1 = 0.327, r2 = 0.112, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:02<00:00,  9.67batch/s, accuracy=0.784, loss=0.397, mae=0.254]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.443, val mae = 0.299, val accuracy = 0.776, r1 = 0.327, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:02<00:00,  9.56batch/s, accuracy=0.801, loss=0.38, mae=0.243] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.444, val mae = 0.302, val accuracy = 0.776, r1 = 0.327, r2 = 0.112, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:02<00:00, 10.30batch/s, accuracy=0.812, loss=0.37, mae=0.239] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.444, val mae = 0.302, val accuracy = 0.776, r1 = 0.327, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:02<00:00,  9.93batch/s, accuracy=0.799, loss=0.389, mae=0.252]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.443, val mae = 0.301, val accuracy = 0.776, r1 = 0.327, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:02<00:00,  9.58batch/s, accuracy=0.808, loss=0.364, mae=0.234]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.443, val mae = 0.301, val accuracy = 0.776, r1 = 0.327, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:02<00:00,  9.89batch/s, accuracy=0.796, loss=0.391, mae=0.251]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.443, val mae = 0.299, val accuracy = 0.776, r1 = 0.327, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:02<00:00, 11.11batch/s, accuracy=0.791, loss=0.391, mae=0.251]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.444, val mae = 0.301, val accuracy = 0.776, r1 = 0.327, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 25/25 [00:02<00:00, 10.65batch/s, accuracy=0.784, loss=0.392, mae=0.25] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.443, val mae = 0.300, val accuracy = 0.776, r1 = 0.327, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 25/25 [00:02<00:00,  9.91batch/s, accuracy=0.794, loss=0.383, mae=0.245]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.443, val mae = 0.299, val accuracy = 0.776, r1 = 0.327, r2 = 0.111, rL = 0.216\n",
      "Training duration = 73.10694718360901\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": [
       "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:   0%|          | 0/100 [00:00<?, ?batch/s, accuracy=0.62, mae=0.357, rouge1=0.436, rouge2=0.0839, rougeL=0.178]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:01<00:00, 55.56batch/s, accuracy=0.748, mae=0.353, rouge1=0.347, rouge2=0.106, rougeL=0.206]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Eval model\")\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "                \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        y_pred = model(features, doc_lens)\n",
    "    \n",
    "        loss = criterion(y_pred, targets)\n",
    "\n",
    "        arr_loss.append(loss.item())\n",
    "\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "        #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        if indices.shape[0] > len(doc):\n",
    "            continue\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[i]]\n",
    "            y_pred_thresh.append(indices[i])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[i]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        mae.append(mae_fn(probs_tensor, targets).item())\n",
    "\n",
    "        accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "        #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "        tepoch.set_postfix(accuracy = np.mean(accuracy), mae = np.mean(mae), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))\n",
    "        idx += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "5c1fd15f",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\n",
    "test_metrics[\"mae\"]      = np.mean(mae)\n",
    "test_metrics[\"rouge1\"]   = np.mean(arr_rouge1)\n",
    "test_metrics[\"rouge2\"]   = np.mean(arr_rouge2)\n",
    "test_metrics[\"rougeL\"]   = np.mean(arr_rougeL)\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/test_metrics.json\", 'w') as fp:\n",
    "    json.dump(test_metrics, fp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "496646f2",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 134.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, 130.71batch/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
}