04-train_COMPLEX_CNN_RNN_max_pool_Glove300.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train COMPLEX_CNN_RNN_max_pool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a8a5bd39",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.utils import clip_grad_norm_\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils.GloveMgr import GloveMgr\n",
    "from utils.Dataset import Dataset\n",
    "from utils.DataLoader import DataLoader\n",
    "from utils.preprocess_df import preprocess_df\n",
    "from utils.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn\n",
    "from utils.split_all_docs import split_all_docs\n",
    "\n",
    "from time import time\n",
    "\n",
    "import json\n",
    "import argparse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "818410ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_notebook() -> bool:\n",
    "    try:\n",
    "        shell = get_ipython().__class__.__name__\n",
    "        if shell == 'ZMQInteractiveShell':\n",
    "            return True   # Jupyter notebook or qtconsole\n",
    "        elif shell == 'TerminalInteractiveShell':\n",
    "            return False  # Terminal running IPython\n",
    "        else:\n",
    "            return False  # Other type (?)\n",
    "    except NameError:\n",
    "        return False      # Probably standard Python interpreter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "690fa032",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "pd.set_option('display.max_rows', None)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b2636e0b",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6e7aad39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse args if script mode\n",
    "parser = argparse.ArgumentParser(description='extractive summary')\n",
    "\n",
    "parser.add_argument('-is_graphic',type=int,default=1,choices=[0,1])\n",
    "parser.add_argument('-gpu_num',type=int,default=5)\n",
    "parser.add_argument('-batch_size',type=int,default=8)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "parser.add_argument('-dataset',type=str,default=\"./data/nyt_corpus_LDC2008T19_50\")\n",
    "parser.add_argument('-doc_col_name',type=str,default=\"docs\")\n",
    "parser.add_argument('-label_col_name',type=str,default=\"labels\")\n",
    "parser.add_argument('-sum_col_name',type=str,default=\"summaries\")\n",
    "parser.add_argument('-max_doc_len',type=int,default=50)\n",
    "\n",
    "args = None\n",
    "\n",
    "if is_notebook():\n",
    "    args = parser.parse_args(\"\")\n",
    "else:\n",
    "    args = parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "824eacf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 5\n",
      "epochs 100\n",
      "batch_size 8\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"glove.6B.300\"\n",
    "\n",
    "# hyper-parameters\n",
    "vocab_size = 150000\n",
    "batch_size = args.batch_size\n",
    "epochs = args.epochs\n",
    "learning_rate = 1e-3\n",
    "early_stopping = 3\n",
    "model_name = \"04-train_COMPLEX_CNN_RNN_max_pool_Glove300\"\n",
    "sub_folder_name = \"model_name__{}__time__{}__embed_name__{}__lr__{}__batch_size__{}__vocab_size__{}__cuda_num__{}\".format(model_name, time(), embed_name, learning_rate, batch_size, vocab_size, cuda_num)\n",
    "checkpoints_folder = \"./checkpoints/\" + sub_folder_name\n",
    "average_number_of_sentences_per_document = 3\n",
    "\n",
    "# print\n",
    "print(\"parse:\")\n",
    "print(\"is_graphic:\", is_graphic)\n",
    "print(\"cuda_num:\", cuda_num)\n",
    "print(\"epochs\", epochs)\n",
    "print(\"batch_size\", batch_size)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c8ddd4d5",
   "metadata": {},
   "source": [
    "## PyTorch initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d09bc3ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of available GPUs: 6\n",
      "GPU 0: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 1: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 2: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 3: NVIDIA GeForce GTX 1080\n",
      "GPU 4: NVIDIA GeForce GTX 1080\n",
      "GPU 5: NVIDIA GeForce GTX 1080\n"
     ]
    }
   ],
   "source": [
    "# Check if a GPU is available\n",
    "if torch.cuda.is_available():\n",
    "    # Display the number of available GPUs\n",
    "    print(f\"Number of available GPUs: {torch.cuda.device_count()}\")\n",
    "    # Display the name of each GPU\n",
    "    for i in range(torch.cuda.device_count()):\n",
    "        print(f\"GPU {i}: {torch.cuda.get_device_name(i)}\")\n",
    "else:\n",
    "    print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b0c5786e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=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 = GloveMgr(\"./data/glove.6B/glove.6B.300d.txt\", vocab_size=vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fe745c8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_json(args.dataset + \"/train.json\")\n",
    "train_dataset = Dataset(preprocess_df(df_train, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "train_iter = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f8b39f3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val = pd.read_json(args.dataset + \"/val.json\")\n",
    "val_dataset = Dataset(preprocess_df(df_val, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "val_iter = DataLoader(dataset=val_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0f086978",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(args.dataset + \"/test.json\")\n",
    "test_dataset = Dataset(preprocess_df(df_test, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "test_iter = DataLoader(dataset=test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fc41eb07",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9683721f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from models.BasicModel import BasicModel\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "\n",
    "class COMPLEX_CNN_RNN(BasicModel):\n",
    "    def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 100):\n",
    "        super(COMPLEX_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=3,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=100,kernel_size=4,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=100,kernel_size=5,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",
    "        # 10: relative position range size, with segment size = 10\n",
    "        self.rel_pos_emb = nn.Embedding(11, 100)\n",
    "        self.abs_pos_emb = nn.Embedding(100, 100)\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.Wabs_pos = nn.Linear(100,1,bias=False)\n",
    "        self.Wrel_pos = nn.Linear(100,1,bias=False)\n",
    "        self.bias = nn.Parameter(torch.empty(1).uniform_(-0.1, 0.1))\n",
    "\n",
    "    def max_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.max_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.max_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.max_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",
    "        # Compute position embedding\n",
    "        abs_poses = torch.tensor([[position] for position in range(max_doc_lens)], dtype=torch.long)\n",
    "        abs_poses = abs_poses.to(self.device)\n",
    "        abs_poses = self.abs_pos_emb(abs_poses).squeeze(1)\n",
    "        aps = self.Wabs_pos(abs_poses)\n",
    "\n",
    "        # Compute relative position embedding\n",
    "        rel_poses = torch.tensor([[int(round(position / 10))] for position in range(max_doc_lens)], dtype=torch.long)\n",
    "        rel_poses = rel_poses.to(self.device)\n",
    "        rel_poses = self.rel_pos_emb(rel_poses).squeeze(1)\n",
    "        rps = self.Wrel_pos(rel_poses)\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 + aps[position] + rps[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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "380f8ba1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = COMPLEX_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2ae1a236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "COMPLEX_CNN_RNN(\n",
       "  (word_embedding): Embedding(150002, 300)\n",
       "  (word_convs): Sequential(\n",
       "    (0): Conv1d(300, 100, kernel_size=(3,), stride=(1,), padding=same)\n",
       "    (1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "    (3): Conv1d(100, 100, kernel_size=(4,), stride=(1,), padding=same)\n",
       "    (4): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (5): ReLU(inplace=True)\n",
       "    (6): Conv1d(100, 100, kernel_size=(5,), stride=(1,), padding=same)\n",
       "    (7): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (8): ReLU(inplace=True)\n",
       "  )\n",
       "  (sent_GRU): GRU(100, 200, batch_first=True, bidirectional=True)\n",
       "  (rel_pos_emb): Embedding(11, 100)\n",
       "  (abs_pos_emb): Embedding(100, 100)\n",
       "  (Wdoc): Linear(in_features=400, out_features=400, bias=True)\n",
       "  (Wcontent): Linear(in_features=400, out_features=1, bias=False)\n",
       "  (Wsalience): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       "  (Wnovelty): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       "  (Wabs_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       "  (Wrel_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4bc411ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.BCELoss()\n",
    "optimizer = torch.optim.Adamax(model.parameters(),lr=learning_rate)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.5)\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1852182a",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c6618af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[args.doc_col_name], is_sep_n = False)\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0991d3c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/13 [00:00<?, ?batch/s]/home/raoufdine/.local/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 13/13 [00:01<00:00,  8.00batch/s, accuracy=0.653, loss=49, mae=0.609]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.553, val mae = 0.286, val accuracy = 0.729, r1 = 0.348, r2 = 0.127, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 13/13 [00:01<00:00, 11.79batch/s, accuracy=0.71, loss=1.94, mae=0.248] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.646, val mae = 0.219, val accuracy = 0.843, r1 = 0.489, r2 = 0.288, rL = 0.382\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 13/13 [00:01<00:00, 11.90batch/s, accuracy=0.755, loss=0.845, mae=0.274]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.514, val mae = 0.270, val accuracy = 0.788, r1 = 0.418, r2 = 0.211, rL = 0.296\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 13/13 [00:01<00:00, 11.80batch/s, accuracy=0.787, loss=0.482, mae=0.217]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.444, val mae = 0.195, val accuracy = 0.858, r1 = 0.494, r2 = 0.295, rL = 0.374\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 13/13 [00:01<00:00, 11.12batch/s, accuracy=0.828, loss=0.373, mae=0.178]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.423, val mae = 0.207, val accuracy = 0.859, r1 = 0.503, r2 = 0.305, rL = 0.386\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 13/13 [00:01<00:00, 11.86batch/s, accuracy=0.829, loss=0.345, mae=0.187]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.426, val mae = 0.223, val accuracy = 0.858, r1 = 0.501, r2 = 0.304, rL = 0.386\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 13/13 [00:01<00:00, 12.15batch/s, accuracy=0.828, loss=0.334, mae=0.191]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.419, val mae = 0.219, val accuracy = 0.859, r1 = 0.500, r2 = 0.302, rL = 0.386\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 13/13 [00:01<00:00, 11.63batch/s, accuracy=0.841, loss=0.316, mae=0.182]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.421, val mae = 0.220, val accuracy = 0.859, r1 = 0.502, r2 = 0.304, rL = 0.388\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 13/13 [00:01<00:00, 11.56batch/s, accuracy=0.834, loss=0.324, mae=0.185]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.420, val mae = 0.221, val accuracy = 0.859, r1 = 0.504, r2 = 0.307, rL = 0.390\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 13/13 [00:01<00:00, 11.75batch/s, accuracy=0.835, loss=0.328, mae=0.187]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.419, val mae = 0.220, val accuracy = 0.859, r1 = 0.501, r2 = 0.304, rL = 0.387\n",
      "Training duration = 35.809818506240845\n"
     ]
    }
   ],
   "source": [
    "arr_train_loss = []\n",
    "arr_train_mae = []\n",
    "arr_train_acc = []\n",
    "arr_val_loss = []\n",
    "arr_val_mae = []\n",
    "arr_val_acc = []\n",
    "\n",
    "t1 = time()\n",
    "for epoch in range(1, epochs+1):\n",
    "    # train 1 epoch\n",
    "    model.train()\n",
    "    nb_batch_train = 0\n",
    "    total_train_loss = 0\n",
    "    total_train_mae = 0\n",
    "    total_train_acc = 0\n",
    "    with tqdm(train_iter, unit=\"batch\", total=len(train_iter)) as tepoch:\n",
    "        for batch in tepoch:\n",
    "            tepoch.set_description(f\"Epoch {epoch}\")\n",
    "            features = []\n",
    "            doc_lens = []\n",
    "\n",
    "            for j in range(batch_size):\n",
    "                doc_lens.append(len(batch[j][\"docs\"]))\n",
    "                features = features + batch[j][\"docs\"]\n",
    "            \n",
    "            features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "            targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(batch_size)]\n",
    "            targets = torch.cat(targets)\n",
    "            targets = targets.to(device)\n",
    "            \n",
    "            probs = model(features, doc_lens)\n",
    "            \n",
    "            loss = loss_fn(probs, targets)\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            clip_grad_norm_(model.parameters(), 1.0)\n",
    "            optimizer.step()\n",
    "            nb_batch_train += 1\n",
    "            total_train_loss += loss.item()\n",
    "            total_train_mae += mae_fn(probs, targets).item()\n",
    "            total_train_acc += accuracy_prop_sent_per_doc_fn(probs=probs.cpu().detach().numpy(), targets=targets.cpu().detach().numpy(), doc_lens=doc_lens)\n",
    "            tepoch.set_postfix(loss=total_train_loss/nb_batch_train, mae=total_train_mae/nb_batch_train, accuracy=total_train_acc/nb_batch_train)\n",
    "\n",
    "    # Save model\n",
    "    model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "    # Show train and val score\n",
    "    model.eval()\n",
    "    nb_batch_val = 0\n",
    "    total_val_loss = 0\n",
    "    total_val_mae = 0\n",
    "    total_val_acc = 0\n",
    "\n",
    "    total_r1 = 0\n",
    "    total_r2 = 0\n",
    "    total_rl = 0\n",
    "\n",
    "    for i, batch in enumerate(val_iter):\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "            \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "        \n",
    "        y_pred = model(features, doc_lens)\n",
    "\n",
    "        loss = loss_fn(y_pred, targets)\n",
    "\n",
    "        nb_batch_val += 1\n",
    "        total_val_loss += loss.item()\n",
    "\n",
    "        doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "        summaries = val_set[args.sum_col_name].iloc[i]\n",
    "\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[j]]\n",
    "            y_pred_thresh.append(indices[j])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in y_pred_thresh:\n",
    "            txt = txt + \". \" + doc[j]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        total_r1 += scores[\"rouge1\"].fmeasure\n",
    "        total_r2 += scores[\"rouge2\"].fmeasure\n",
    "        total_rl += scores[\"rougeL\"].fmeasure\n",
    "\n",
    "        probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        total_val_mae += mae_fn(probs_tensor, targets).item()\n",
    "        total_val_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "    arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "    arr_train_mae.append(total_train_mae / nb_batch_train)\n",
    "    arr_train_acc.append(total_train_acc / nb_batch_train)\n",
    "\n",
    "    arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "    arr_val_mae.append(total_val_mae / nb_batch_val)\n",
    "    arr_val_acc.append(total_val_acc / nb_batch_val)\n",
    "    \n",
    "    print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "\n",
    "    if len(arr_val_loss) >= early_stopping+1:\n",
    "        if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "            break\n",
    "\n",
    "    # update lr\n",
    "    scheduler.step()\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2f39ceed",
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_mae\"]  = arr_train_mae\n",
    "training_metrics[\"train_acc\"]  = arr_train_acc\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_mae\"]    = arr_val_mae\n",
    "training_metrics[\"val_acc\"]    = arr_val_acc\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "    json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8cd8fbee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Losses\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_loss) + 1)), arr_train_loss, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_loss) + 1)), arr_val_loss, label=\"val\")\n",
    "\n",
    "    plt.title(\"Loss\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"loss\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8bda887e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw mae\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_mae) + 1)), arr_train_mae, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_mae) + 1)), arr_val_mae, label=\"val\")\n",
    "\n",
    "    plt.title(\"MAE\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"mae\")\n",
    "    plt.legend(loc=\"upper right\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1cc21154",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Accuracies\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_acc) + 1)), arr_train_acc, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_acc) + 1)), arr_val_acc, label=\"val\")\n",
    "\n",
    "    plt.title(\"Accuracy\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"accuracy\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0133ff45",
   "metadata": {},
   "source": [
    "# Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e095b271",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.split_all_docs import split_all_docs\n",
    "from rouge_score import rouge_scorer\n",
    "from utils.threshold_probs import threshold_probs_by_prop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "273c6eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = COMPLEX_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": [
       "7"
      ]
     },
     "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": 34,
   "id": "67659b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:02<00:00, 34.66batch/s, accuracy=0.861, mae=0.198, rouge1=0.43, rouge2=0.235, rougeL=0.323]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Eval model\")\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "                \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        y_pred = model(features, doc_lens)\n",
    "    \n",
    "        loss = criterion(y_pred, targets)\n",
    "\n",
    "        arr_loss.append(loss.item())\n",
    "\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "        #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[i]]\n",
    "            y_pred_thresh.append(indices[i])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[i]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        mae.append(mae_fn(probs_tensor, targets).item())\n",
    "\n",
    "        accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "        #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "        tepoch.set_postfix(accuracy = np.mean(accuracy), mae = np.mean(mae), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))\n",
    "        idx += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "5c1fd15f",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\n",
    "test_metrics[\"mae\"]      = np.mean(mae)\n",
    "test_metrics[\"rouge1\"]   = np.mean(arr_rouge1)\n",
    "test_metrics[\"rouge2\"]   = np.mean(arr_rouge2)\n",
    "test_metrics[\"rougeL\"]   = np.mean(arr_rougeL)\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/test_metrics.json\", 'w') as fp:\n",
    "    json.dump(test_metrics, fp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "496646f2",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:00<00:00, 148.95batch/s, rouge1=0.406, rouge2=0.225, rougeL=0.309]\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, 127.06batch/s, rouge1=0.435, rouge2=0.241, rougeL=0.325]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e4f4796c",
   "metadata": {},
   "outputs": [
    {
     "ename": "SystemExit",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/raoufdine/anaconda3/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3465: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "# Does not excute this cell if you want to execute the following cells.\n",
    "import sys\n",
    "sys.exit()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "4f810f0bde7d7b5dc90f9e6832822547e13e234c53731a97fc91254323942f40"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}