15-train_SIMPLE_CNN_RNN_content_only_fasttext_fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train 15-train_SIMPLE_CNN_RNN_content_only"
   ]
  },
  {
   "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 = \"15-train_SIMPLE_CNN_RNN_content_only_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.Wcontent = nn.Linear(2*200,1,bias=False)\n",
    "        self.bias = nn.Parameter(torch.empty(1).uniform_(-0.1, 0.1))\n",
    "\n",
    "    def avg_pool1d(self,x,seq_lens):\n",
    "        out = []\n",
    "        for index,t in enumerate(x):\n",
    "            if seq_lens[index] == 0:\n",
    "                t = t[:1]\n",
    "            else:\n",
    "                t = t[:seq_lens[index],:]\n",
    "            t = torch.t(t).unsqueeze(0)\n",
    "            out.append(torch.avg_pool1d(t,t.size(2)))\n",
    "        \n",
    "        out = torch.cat(out).squeeze(2)\n",
    "        return out\n",
    "\n",
    "    def forward(self, arr_x, doc_lens):\n",
    "        probs = []\n",
    "\n",
    "        max_doc_lens = max(doc_lens)\n",
    "        #sent_lens = torch.sum(torch.sign(arr_x),dim=1).data\n",
    "\n",
    "        arr_x = self.word_embedding(arr_x)\n",
    "        arr_x = self.word_convs(arr_x.permute(0,2,1))\n",
    "        arr_x = torch.avg_pool1d(arr_x, arr_x.size(2)).squeeze(2)\n",
    "\n",
    "        arr_x = self.pad_doc(arr_x, doc_lens)\n",
    "\n",
    "        arr_x = self.sent_GRU(arr_x)[0]\n",
    "        sents_all_docs = arr_x.reshape(len(doc_lens) * max_doc_lens, 2*200) # flat docs\n",
    "        \n",
    "        docs = self.avg_pool1d(arr_x, doc_lens)\n",
    "        docs = torch.tanh(self.Wdoc(docs))\n",
    "        docs_for_each_sent = docs.repeat_interleave(max_doc_lens, dim=0) # repeat doc n times\n",
    "        \n",
    "        contents = self.Wcontent(sents_all_docs)\n",
    "\n",
    "        # doc_len (number) s\n",
    "        ses = torch.zeros(len(doc_lens), 2*200)\n",
    "        ses = ses.to(self.device)\n",
    "\n",
    "        # for each document, compute probabilities\n",
    "        for position in range(max_doc_lens):\n",
    "            contents_for_position = contents[position::max_doc_lens]\n",
    "            prob = contents_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",
       ")"
      ]
     },
     "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:01<00:00, 15.33batch/s, accuracy=0.717, loss=0.521, mae=0.317]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.649, val mae = 0.476, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:01<00:00, 21.40batch/s, accuracy=0.752, loss=0.494, mae=0.332]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.566, val mae = 0.410, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:01<00:00, 20.48batch/s, accuracy=0.774, loss=0.456, mae=0.288]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.535, val mae = 0.357, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:01<00:00, 21.25batch/s, accuracy=0.76, loss=0.469, mae=0.297] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.529, val mae = 0.352, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:01<00:00, 21.83batch/s, accuracy=0.762, loss=0.467, mae=0.303]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.526, val mae = 0.350, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:01<00:00, 23.54batch/s, accuracy=0.766, loss=0.461, mae=0.3]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.524, val mae = 0.351, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:01<00:00, 21.46batch/s, accuracy=0.782, loss=0.434, mae=0.284]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.524, val mae = 0.349, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:01<00:00, 21.79batch/s, accuracy=0.775, loss=0.444, mae=0.288]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.524, val mae = 0.349, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:01<00:00, 21.88batch/s, accuracy=0.768, loss=0.454, mae=0.293]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.523, val mae = 0.349, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:01<00:00, 22.01batch/s, accuracy=0.778, loss=0.441, mae=0.286]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.523, val mae = 0.349, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:01<00:00, 21.66batch/s, accuracy=0.774, loss=0.444, mae=0.289]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.523, val mae = 0.349, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:01<00:00, 22.44batch/s, accuracy=0.766, loss=0.451, mae=0.293]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.523, val mae = 0.349, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:01<00:00, 22.25batch/s, accuracy=0.767, loss=0.456, mae=0.295]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.523, val mae = 0.349, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 25/25 [00:01<00:00, 22.94batch/s, accuracy=0.765, loss=0.46, mae=0.297] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.523, val mae = 0.349, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 25/25 [00:01<00:00, 22.45batch/s, accuracy=0.777, loss=0.452, mae=0.295]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.523, val mae = 0.349, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 25/25 [00:01<00:00, 21.58batch/s, accuracy=0.769, loss=0.449, mae=0.29] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16 : val loss = 0.523, val mae = 0.349, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n",
      "Training duration = 41.270877838134766\n"
     ]
    }
   ],
   "source": [
    "arr_train_loss = []\n",
    "arr_train_mae = []\n",
    "arr_train_acc = []\n",
    "arr_val_loss = []\n",
    "arr_val_mae = []\n",
    "arr_val_acc = []\n",
    "\n",
    "t1 = time()\n",
    "for epoch in range(1, epochs+1):\n",
    "    # train 1 epoch\n",
    "    model.train()\n",
    "    nb_batch_train = 0\n",
    "    total_train_loss = 0\n",
    "    total_train_mae = 0\n",
    "    total_train_acc = 0\n",
    "    with tqdm(train_iter, unit=\"batch\", total=len(train_iter)) as tepoch:\n",
    "        for batch in tepoch:\n",
    "            tepoch.set_description(f\"Epoch {epoch}\")\n",
    "            features = []\n",
    "            doc_lens = []\n",
    "\n",
    "            for j in range(batch_size):\n",
    "                doc_lens.append(len(batch[j][\"docs\"]))\n",
    "                features = features + batch[j][\"docs\"]\n",
    "            \n",
    "            features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "            targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(batch_size)]\n",
    "            targets = torch.cat(targets)\n",
    "            targets = targets.to(device)\n",
    "            \n",
    "            probs = model(features, doc_lens)\n",
    "            \n",
    "            loss = loss_fn(probs, targets)\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            clip_grad_norm_(model.parameters(), 1.0)\n",
    "            optimizer.step()\n",
    "            nb_batch_train += 1\n",
    "            total_train_loss += loss.item()\n",
    "            total_train_mae += mae_fn(probs, targets).item()\n",
    "            total_train_acc += accuracy_prop_sent_per_doc_fn(probs=probs.cpu().detach().numpy(), targets=targets.cpu().detach().numpy(), doc_lens=doc_lens)\n",
    "            tepoch.set_postfix(loss=total_train_loss/nb_batch_train, mae=total_train_mae/nb_batch_train, accuracy=total_train_acc/nb_batch_train)\n",
    "\n",
    "    # Save model\n",
    "    model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "    # Show train and val score\n",
    "    model.eval()\n",
    "    nb_batch_val = 0\n",
    "    total_val_loss = 0\n",
    "    total_val_mae = 0\n",
    "    total_val_acc = 0\n",
    "\n",
    "    total_r1 = 0\n",
    "    total_r2 = 0\n",
    "    total_rl = 0\n",
    "\n",
    "    for i, batch in enumerate(val_iter):\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "            \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "        \n",
    "        y_pred = model(features, doc_lens)\n",
    "\n",
    "        loss = loss_fn(y_pred, targets)\n",
    "\n",
    "        nb_batch_val += 1\n",
    "        total_val_loss += loss.item()\n",
    "\n",
    "        doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "        summaries = val_set[args.sum_col_name].iloc[i]\n",
    "\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        if indices.shape[0] > len(doc):\n",
    "            continue\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[j]]\n",
    "            y_pred_thresh.append(indices[j])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in y_pred_thresh:\n",
    "            txt = txt + \". \" + doc[j]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        total_r1 += scores[\"rouge1\"].fmeasure\n",
    "        total_r2 += scores[\"rouge2\"].fmeasure\n",
    "        total_rl += scores[\"rougeL\"].fmeasure\n",
    "\n",
    "        probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        total_val_mae += mae_fn(probs_tensor, targets).item()\n",
    "        total_val_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "    arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "    arr_train_mae.append(total_train_mae / nb_batch_train)\n",
    "    arr_train_acc.append(total_train_acc / nb_batch_train)\n",
    "\n",
    "    arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "    arr_val_mae.append(total_val_mae / nb_batch_val)\n",
    "    arr_val_acc.append(total_val_acc / nb_batch_val)\n",
    "    \n",
    "    print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "\n",
    "    if len(arr_val_loss) >= early_stopping+1:\n",
    "        if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "            break\n",
    "\n",
    "    # update lr\n",
    "    scheduler.step()\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2f39ceed",
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_mae\"]  = arr_train_mae\n",
    "training_metrics[\"train_acc\"]  = arr_train_acc\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_mae\"]    = arr_val_mae\n",
    "training_metrics[\"val_acc\"]    = arr_val_acc\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "    json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8cd8fbee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Losses\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_loss) + 1)), arr_train_loss, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_loss) + 1)), arr_val_loss, label=\"val\")\n",
    "\n",
    "    plt.title(\"Loss\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"loss\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8bda887e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw mae\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_mae) + 1)), arr_train_mae, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_mae) + 1)), arr_val_mae, label=\"val\")\n",
    "\n",
    "    plt.title(\"MAE\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"mae\")\n",
    "    plt.legend(loc=\"upper right\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1cc21154",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Accuracies\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_acc) + 1)), arr_train_acc, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_acc) + 1)), arr_val_acc, label=\"val\")\n",
    "\n",
    "    plt.title(\"Accuracy\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"accuracy\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0133ff45",
   "metadata": {},
   "source": [
    "# Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e095b271",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.split_all_docs import split_all_docs\n",
    "from rouge_score import rouge_scorer\n",
    "from utils.threshold_probs import threshold_probs_by_prop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "273c6eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SIMPLE_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4fc41994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_epoch = np.argmin(np.array(arr_val_loss)) + 1\n",
    "model.load(checkpoints_folder + \"/\" + model_name + \"-\" + str(best_epoch) + \".pt\")\n",
    "model.to(device)\n",
    "model.eval()\n",
    "best_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3edbae7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_set = df_test\n",
    "test_set[\"doc_splited\"] = split_all_docs(test_set[args.doc_col_name], False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bb8ab07a",
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "67659b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:01<00:00, 95.36batch/s, accuracy=0.742, mae=0.399, 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": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 152.08batch/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, 152.46batch/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
}