07-train_SIMPLE_CNN_RNN_without_position_fasttext_fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train SIMPLE_CNN_RNN_without_position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a8a5bd39",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.utils import clip_grad_norm_\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils_french.EmbMgr import EmbMgr\n",
    "from utils_french.Dataset import Dataset\n",
    "from utils_french.DataLoader import DataLoader\n",
    "from utils_french.preprocess_df import preprocess_df\n",
    "from utils_french.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils_french.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn\n",
    "from utils_french.split_all_docs import split_all_docs\n",
    "\n",
    "from time import time\n",
    "\n",
    "import json\n",
    "import argparse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "818410ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_notebook() -> bool:\n",
    "    try:\n",
    "        shell = get_ipython().__class__.__name__\n",
    "        if shell == 'ZMQInteractiveShell':\n",
    "            return True   # Jupyter notebook or qtconsole\n",
    "        elif shell == 'TerminalInteractiveShell':\n",
    "            return False  # Terminal running IPython\n",
    "        else:\n",
    "            return False  # Other type (?)\n",
    "    except NameError:\n",
    "        return False      # Probably standard Python interpreter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "690fa032",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "pd.set_option('display.max_rows', None)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b2636e0b",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6e7aad39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse args if script mode\n",
    "parser = argparse.ArgumentParser(description='extractive summary')\n",
    "\n",
    "parser.add_argument('-is_graphic',type=int,default=1,choices=[0,1])\n",
    "parser.add_argument('-gpu_num',type=int,default=1)\n",
    "parser.add_argument('-batch_size',type=int,default=4)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "parser.add_argument('-dataset',type=str,default=\"./data/wiki_geo_ratio_sc_0.5/\")\n",
    "parser.add_argument('-doc_col_name',type=str,default=\"flat_contents\")\n",
    "parser.add_argument('-label_col_name',type=str,default=\"labels_sentences\")\n",
    "parser.add_argument('-sum_col_name',type=str,default=\"summaries\")\n",
    "parser.add_argument('-max_doc_len',type=int,default=100)\n",
    "\n",
    "args = None\n",
    "\n",
    "if is_notebook():\n",
    "    args = parser.parse_args(\"\")\n",
    "else:\n",
    "    args = parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "824eacf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 1\n",
      "epochs 100\n",
      "batch_size 4\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"cc.fr.300.vec\"\n",
    "\n",
    "# hyper-parameters\n",
    "vocab_size = 150000\n",
    "batch_size = args.batch_size\n",
    "epochs = args.epochs\n",
    "learning_rate = 1e-3\n",
    "early_stopping = 3\n",
    "model_name = \"07-train_SIMPLE_CNN_RNN_without_position_FastTextfr\"\n",
    "sub_folder_name = \"model_name__{}__time__{}__embed_name__{}__lr__{}__batch_size__{}__vocab_size__{}__cuda_num__{}\".format(model_name, time(), embed_name, learning_rate, batch_size, vocab_size, cuda_num)\n",
    "checkpoints_folder = \"./checkpoints/\" + sub_folder_name\n",
    "average_number_of_sentences_per_document = 3\n",
    "\n",
    "# print\n",
    "print(\"parse:\")\n",
    "print(\"is_graphic:\", is_graphic)\n",
    "print(\"cuda_num:\", cuda_num)\n",
    "print(\"epochs\", epochs)\n",
    "print(\"batch_size\", batch_size)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c8ddd4d5",
   "metadata": {},
   "source": [
    "## PyTorch initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d09bc3ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of available GPUs: 6\n",
      "GPU 0: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 1: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 2: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 3: NVIDIA GeForce GTX 1080\n",
      "GPU 4: NVIDIA GeForce GTX 1080\n",
      "GPU 5: NVIDIA GeForce GTX 1080\n"
     ]
    }
   ],
   "source": [
    "# Check if a GPU is available\n",
    "if torch.cuda.is_available():\n",
    "    # Display the number of available GPUs\n",
    "    print(f\"Number of available GPUs: {torch.cuda.device_count()}\")\n",
    "    # Display the name of each GPU\n",
    "    for i in range(torch.cuda.device_count()):\n",
    "        print(f\"GPU {i}: {torch.cuda.get_device_name(i)}\")\n",
    "else:\n",
    "    print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b0c5786e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=1)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3393fe4e",
   "metadata": {},
   "source": [
    "## Chargement des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "97644745",
   "metadata": {},
   "outputs": [],
   "source": [
    "glovemgr = EmbMgr(\"./data/cc.fr.300.vec\", vocab_size=vocab_size, header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fe745c8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_json(args.dataset + \"/train.json\")\n",
    "train_dataset = Dataset(preprocess_df(df_train, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "train_iter = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f8b39f3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val = pd.read_json(args.dataset + \"/val.json\")\n",
    "val_dataset = Dataset(preprocess_df(df_val, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "val_iter = DataLoader(dataset=val_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0f086978",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(args.dataset + \"/test.json\")\n",
    "test_dataset = Dataset(preprocess_df(df_test, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "test_iter = DataLoader(dataset=test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fc41eb07",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9683721f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from models.BasicModel import BasicModel\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "\n",
    "class SIMPLE_CNN_RNN(BasicModel):\n",
    "    def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 100):\n",
    "        super(SIMPLE_CNN_RNN, self).__init__(device)\n",
    "\n",
    "        self.device = device\n",
    "\n",
    "        self.word_embedding = nn.Embedding(vocab_size+2, dim_word_embed, padding_idx=0)\n",
    "        # Load word embedding if specified\n",
    "        if word_embed is not None:\n",
    "            self.word_embedding = torch.nn.Embedding.from_pretrained(torch.from_numpy(word_embed).float())\n",
    "\n",
    "        # 100 : word2vec embedding size\n",
    "        self.word_convs = nn.Sequential(\n",
    "                            nn.Conv1d(in_channels=dim_word_embed,out_channels=100,kernel_size=4,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True))\n",
    "        self.sent_GRU = nn.GRU(input_size = 100, hidden_size=200, batch_first = True, bidirectional = True)\n",
    "\n",
    "        self.Wdoc = nn.Linear(2*200,2*200,bias=True)\n",
    "\n",
    "        self.Wcontent = nn.Linear(2*200,1,bias=False)\n",
    "        self.Wsalience = nn.Bilinear(2*200,2*200,1,bias=False)\n",
    "        self.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",
    "        saliences = self.Wsalience(sents_all_docs, docs_for_each_sent)\n",
    "\n",
    "        # doc_len (number) s\n",
    "        ses = torch.zeros(len(doc_lens), 2*200)\n",
    "        ses = ses.to(self.device)\n",
    "\n",
    "        # for each document, compute probabilities\n",
    "        for position in range(max_doc_lens):\n",
    "            contents_for_position = contents[position::max_doc_lens]\n",
    "            saliences_for_position = saliences[position::max_doc_lens]\n",
    "            novelties_for_position = -1 * self.Wnovelty(sents_all_docs[position::max_doc_lens], torch.tanh(ses))\n",
    "            prob = contents_for_position + 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",
    "        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",
       "  (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.59batch/s, accuracy=0.736, loss=0.714, mae=0.344]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.599, val mae = 0.443, val accuracy = 0.776, r1 = 0.308, r2 = 0.095, rL = 0.201\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:02<00:00,  9.96batch/s, accuracy=0.771, loss=0.441, mae=0.267]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.529, val mae = 0.386, val accuracy = 0.776, r1 = 0.307, r2 = 0.094, rL = 0.199\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:02<00:00, 10.42batch/s, accuracy=0.773, loss=0.42, mae=0.251] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.483, val mae = 0.342, val accuracy = 0.776, r1 = 0.314, r2 = 0.099, rL = 0.204\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:02<00:00,  9.97batch/s, accuracy=0.78, loss=0.396, mae=0.261] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.459, val mae = 0.310, val accuracy = 0.777, r1 = 0.315, r2 = 0.100, rL = 0.205\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:02<00:00,  9.70batch/s, accuracy=0.792, loss=0.385, mae=0.239]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.455, val mae = 0.297, val accuracy = 0.777, r1 = 0.326, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:02<00:00,  9.70batch/s, accuracy=0.788, loss=0.384, mae=0.235]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.454, val mae = 0.305, val accuracy = 0.778, r1 = 0.327, r2 = 0.112, rL = 0.218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:02<00:00, 10.26batch/s, accuracy=0.801, loss=0.387, mae=0.244]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.454, val mae = 0.307, val accuracy = 0.778, r1 = 0.327, r2 = 0.112, rL = 0.218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:02<00:00, 10.56batch/s, accuracy=0.791, loss=0.401, mae=0.253]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.454, val mae = 0.308, val accuracy = 0.777, r1 = 0.327, r2 = 0.112, rL = 0.218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:02<00:00, 10.13batch/s, accuracy=0.808, loss=0.377, mae=0.243]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.454, val mae = 0.308, val accuracy = 0.777, r1 = 0.327, r2 = 0.112, rL = 0.218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:02<00:00,  9.64batch/s, accuracy=0.789, loss=0.389, mae=0.242]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.453, val mae = 0.307, val accuracy = 0.778, r1 = 0.327, r2 = 0.112, rL = 0.218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:02<00:00,  9.95batch/s, accuracy=0.794, loss=0.39, mae=0.248] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.453, val mae = 0.306, val accuracy = 0.778, r1 = 0.327, r2 = 0.112, rL = 0.218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:02<00:00,  9.98batch/s, accuracy=0.789, loss=0.39, mae=0.248] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.452, val mae = 0.305, val accuracy = 0.778, r1 = 0.327, r2 = 0.112, rL = 0.218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:02<00:00, 10.19batch/s, accuracy=0.793, loss=0.393, mae=0.251]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.453, val mae = 0.306, val accuracy = 0.778, r1 = 0.327, r2 = 0.112, rL = 0.218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 25/25 [00:02<00:00,  8.57batch/s, accuracy=0.796, loss=0.386, mae=0.246]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.453, val mae = 0.306, val accuracy = 0.778, r1 = 0.327, r2 = 0.112, rL = 0.218\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 25/25 [00:03<00:00,  8.18batch/s, accuracy=0.805, loss=0.374, mae=0.238]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.453, val mae = 0.306, val accuracy = 0.778, r1 = 0.327, r2 = 0.112, rL = 0.218\n",
      "Training duration = 74.28435754776001\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: 100%|██████████| 100/100 [00:01<00:00, 59.11batch/s, accuracy=0.748, mae=0.359, rouge1=0.347, rouge2=0.105, rougeL=0.206]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Eval model\")\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "                \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        y_pred = model(features, doc_lens)\n",
    "    \n",
    "        loss = criterion(y_pred, targets)\n",
    "\n",
    "        arr_loss.append(loss.item())\n",
    "\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "        #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        if indices.shape[0] > len(doc):\n",
    "            continue\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[i]]\n",
    "            y_pred_thresh.append(indices[i])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[i]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        mae.append(mae_fn(probs_tensor, targets).item())\n",
    "\n",
    "        accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "        #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "        tepoch.set_postfix(accuracy = np.mean(accuracy), mae = np.mean(mae), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))\n",
    "        idx += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "5c1fd15f",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\n",
    "test_metrics[\"mae\"]      = np.mean(mae)\n",
    "test_metrics[\"rouge1\"]   = np.mean(arr_rouge1)\n",
    "test_metrics[\"rouge2\"]   = np.mean(arr_rouge2)\n",
    "test_metrics[\"rougeL\"]   = np.mean(arr_rougeL)\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/test_metrics.json\", 'w') as fp:\n",
    "    json.dump(test_metrics, fp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "496646f2",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:00<00:00, 197.95batch/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": 31,
   "id": "a4c96c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 144.22batch/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
}