13-train_SIMPLE_CNN_RNN_novelty_only_Glove300.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train 13-train_SIMPLE_CNN_RNN_novelty_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.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",
    "\n",
    "from time import time\n",
    "\n",
    "import json\n",
    "import argparse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "818410ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_notebook() -> bool:\n",
    "    try:\n",
    "        shell = get_ipython().__class__.__name__\n",
    "        if shell == 'ZMQInteractiveShell':\n",
    "            return True   # Jupyter notebook or qtconsole\n",
    "        elif shell == 'TerminalInteractiveShell':\n",
    "            return False  # Terminal running IPython\n",
    "        else:\n",
    "            return False  # Other type (?)\n",
    "    except NameError:\n",
    "        return False      # Probably standard Python interpreter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "690fa032",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "pd.set_option('display.max_rows', None)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b2636e0b",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6e7aad39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse args if script mode\n",
    "parser = argparse.ArgumentParser(description='extractive summary')\n",
    "\n",
    "parser.add_argument('-is_graphic',type=int,default=1,choices=[0,1])\n",
    "parser.add_argument('-gpu_num',type=int,default=0)\n",
    "parser.add_argument('-batch_size',type=int,default=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: 0\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 = \"13-train_SIMPLE_CNN_RNN_novelty_only_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=0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3393fe4e",
   "metadata": {},
   "source": [
    "## Chargement des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "97644745",
   "metadata": {},
   "outputs": [],
   "source": [
    "glovemgr = 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 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.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",
    "        # 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",
    "            novelties_for_position = -1 * self.Wnovelty(sents_all_docs[position::max_doc_lens], torch.tanh(ses))\n",
    "            prob = 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"
   ]
  },
  {
   "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(150002, 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",
       "  (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/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.14batch/s, accuracy=0.791, loss=0.501, mae=0.292]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.643, val mae = 0.473, val accuracy = 0.785, r1 = 0.405, r2 = 0.196, rL = 0.285\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 13/13 [00:01<00:00, 12.77batch/s, accuracy=0.825, loss=0.387, mae=0.249]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.542, val mae = 0.407, val accuracy = 0.819, r1 = 0.454, r2 = 0.247, rL = 0.341\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 13/13 [00:00<00:00, 14.25batch/s, accuracy=0.836, loss=0.348, mae=0.234]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.414, val mae = 0.302, val accuracy = 0.829, r1 = 0.465, r2 = 0.262, rL = 0.351\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 13/13 [00:00<00:00, 14.50batch/s, accuracy=0.833, loss=0.345, mae=0.216]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.390, val mae = 0.269, val accuracy = 0.824, r1 = 0.460, r2 = 0.256, rL = 0.346\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 13/13 [00:01<00:00, 12.80batch/s, accuracy=0.84, loss=0.338, mae=0.217] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.375, val mae = 0.250, val accuracy = 0.826, r1 = 0.471, r2 = 0.269, rL = 0.356\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 13/13 [00:00<00:00, 13.14batch/s, accuracy=0.836, loss=0.338, mae=0.218]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.372, val mae = 0.246, val accuracy = 0.831, r1 = 0.470, r2 = 0.267, rL = 0.354\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 13/13 [00:00<00:00, 14.79batch/s, accuracy=0.839, loss=0.339, mae=0.218]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.370, val mae = 0.243, val accuracy = 0.832, r1 = 0.473, r2 = 0.271, rL = 0.357\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 13/13 [00:00<00:00, 14.65batch/s, accuracy=0.839, loss=0.33, mae=0.213] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.370, val mae = 0.242, val accuracy = 0.832, r1 = 0.473, r2 = 0.271, rL = 0.356\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 13/13 [00:00<00:00, 15.69batch/s, accuracy=0.845, loss=0.33, mae=0.212] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.370, val mae = 0.243, val accuracy = 0.832, r1 = 0.472, r2 = 0.270, rL = 0.355\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 13/13 [00:00<00:00, 16.15batch/s, accuracy=0.835, loss=0.336, mae=0.215]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.369, val mae = 0.241, val accuracy = 0.833, r1 = 0.473, r2 = 0.270, rL = 0.356\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 13/13 [00:00<00:00, 14.22batch/s, accuracy=0.837, loss=0.327, mae=0.212]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.370, val mae = 0.242, val accuracy = 0.833, r1 = 0.472, r2 = 0.270, rL = 0.356\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 13/13 [00:00<00:00, 14.54batch/s, accuracy=0.84, loss=0.331, mae=0.214] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.370, val mae = 0.242, val accuracy = 0.833, r1 = 0.472, r2 = 0.270, rL = 0.356\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 13/13 [00:00<00:00, 14.03batch/s, accuracy=0.839, loss=0.329, mae=0.211]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.370, val mae = 0.242, val accuracy = 0.833, r1 = 0.472, r2 = 0.270, rL = 0.356\n",
      "Training duration = 48.886313676834106\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 = 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": [
       "10"
      ]
     },
     "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:02<00:00, 34.45batch/s, accuracy=0.836, mae=0.228, rouge1=0.437, rouge2=0.237, 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": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 103.65batch/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": "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:01<00:00, 94.61batch/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
}