15-train_SIMPLE_CNN_RNN_content_only.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.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=0)\n",
    "parser.add_argument('-batch_size',type=int,default=32)\n",
    "parser.add_argument('-epochs',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: 0\n",
      "epochs 100\n",
      "batch_size 32\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"glove.6B.100\"\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\"\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.100d.txt\", vocab_size=vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fe745c8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_json(\"./data/cnn_dailymail/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=100, doc_column_name=\"article\", labels_column_name=\"labels\"))\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(\"./data/cnn_dailymail/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=100, doc_column_name=\"article\", labels_column_name=\"labels\"))\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(\"./data/cnn_dailymail/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=100, doc_column_name=\"article\", labels_column_name=\"labels\"))\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=100,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())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2ae1a236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SIMPLE_CNN_RNN(\n",
       "  (abs_pos_emb): Embedding(100, 100)\n",
       "  (Wabs_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[\"article\"], 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: 100%|██████████| 4/4 [00:00<00:00,  6.03batch/s, accuracy=0.679, loss=0.687, mae=0.476]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.677, val mae = 0.471, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 4/4 [00:00<00:00, 13.81batch/s, accuracy=0.676, loss=0.678, mae=0.473]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.669, val mae = 0.468, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 4/4 [00:00<00:00, 13.99batch/s, accuracy=0.675, loss=0.672, mae=0.47]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.665, val mae = 0.467, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 4/4 [00:00<00:00, 13.36batch/s, accuracy=0.677, loss=0.668, mae=0.468]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.664, val mae = 0.466, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 4/4 [00:00<00:00, 15.35batch/s, accuracy=0.684, loss=0.667, mae=0.467]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.663, val mae = 0.466, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 4/4 [00:00<00:00, 15.92batch/s, accuracy=0.676, loss=0.667, mae=0.468]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 4/4 [00:00<00:00, 16.33batch/s, accuracy=0.679, loss=0.664, mae=0.466]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 4/4 [00:00<00:00, 16.32batch/s, accuracy=0.678, loss=0.665, mae=0.467]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 4/4 [00:00<00:00, 16.30batch/s, accuracy=0.677, loss=0.665, mae=0.467]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 4/4 [00:00<00:00, 16.43batch/s, accuracy=0.675, loss=0.665, mae=0.467]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 4/4 [00:00<00:00, 15.92batch/s, accuracy=0.675, loss=0.668, mae=0.468]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 4/4 [00:00<00:00, 16.41batch/s, accuracy=0.672, loss=0.668, mae=0.468]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 4/4 [00:00<00:00, 16.27batch/s, accuracy=0.676, loss=0.668, mae=0.468]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 4/4 [00:00<00:00, 16.70batch/s, accuracy=0.678, loss=0.665, mae=0.467]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 4/4 [00:00<00:00, 16.12batch/s, accuracy=0.676, loss=0.666, mae=0.467]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 4/4 [00:00<00:00, 16.77batch/s, accuracy=0.676, loss=0.668, mae=0.468]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|██████████| 4/4 [00:00<00:00, 16.07batch/s, accuracy=0.677, loss=0.667, mae=0.468]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18: 100%|██████████| 4/4 [00:00<00:00, 16.01batch/s, accuracy=0.682, loss=0.665, mae=0.467]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 18 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19: 100%|██████████| 4/4 [00:00<00:00, 16.26batch/s, accuracy=0.676, loss=0.665, mae=0.467]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 19 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 4/4 [00:00<00:00, 15.83batch/s, accuracy=0.676, loss=0.666, mae=0.467]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 20 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 21: 100%|██████████| 4/4 [00:00<00:00, 15.47batch/s, accuracy=0.677, loss=0.666, mae=0.467]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 21 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 22: 100%|██████████| 4/4 [00:00<00:00, 15.93batch/s, accuracy=0.674, loss=0.667, mae=0.468]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 22 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 23: 100%|██████████| 4/4 [00:00<00:00, 16.18batch/s, accuracy=0.68, loss=0.666, mae=0.467] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 23 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 24: 100%|██████████| 4/4 [00:00<00:00, 16.18batch/s, accuracy=0.678, loss=0.665, mae=0.467]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 24 : val loss = 0.662, val mae = 0.465, val accuracy = 0.755, r1 = 0.356, r2 = 0.125, rL = 0.221\n",
      "Training duration = 20.553306818008423\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[\"highlights\"].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())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4fc41994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "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[\"article\"], 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:00<00:00, 125.80batch/s, accuracy=0.721, mae=0.469, rouge1=0.341, rouge2=0.113, rougeL=0.211]\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[\"highlights\"].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, 210.14batch/s, rouge1=0.4, rouge2=0.165, rougeL=0.249] \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[\"highlights\"].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, 200.72batch/s, rouge1=0.406, rouge2=0.168, rougeL=0.252]\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[\"highlights\"].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
}