07-train_SIMPLE_CNN_RNN_without_position.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train SIMPLE_CNN_RNN_without_position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a8a5bd39",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.utils import clip_grad_norm_\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils.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=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 = \"07-train_SIMPLE_CNN_RNN_without_position\"\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.Wsalience = nn.Bilinear(2*200,2*200,1,bias=False)\n",
    "        self.Wnovelty = nn.Bilinear(2*200,2*200,1,bias=False)\n",
    "        self.bias = nn.Parameter(torch.empty(1).uniform_(-0.1, 0.1))\n",
    "\n",
    "    def avg_pool1d(self,x,seq_lens):\n",
    "        out = []\n",
    "        for index,t in enumerate(x):\n",
    "            if seq_lens[index] == 0:\n",
    "                t = t[:1]\n",
    "            else:\n",
    "                t = t[:seq_lens[index],:]\n",
    "            t = torch.t(t).unsqueeze(0)\n",
    "            out.append(torch.avg_pool1d(t,t.size(2)))\n",
    "        \n",
    "        out = torch.cat(out).squeeze(2)\n",
    "        return out\n",
    "\n",
    "    def forward(self, arr_x, doc_lens):\n",
    "        probs = []\n",
    "\n",
    "        max_doc_lens = max(doc_lens)\n",
    "        #sent_lens = torch.sum(torch.sign(arr_x),dim=1).data\n",
    "\n",
    "        arr_x = self.word_embedding(arr_x)\n",
    "        arr_x = self.word_convs(arr_x.permute(0,2,1))\n",
    "        arr_x = torch.avg_pool1d(arr_x, arr_x.size(2)).squeeze(2)\n",
    "\n",
    "        arr_x = self.pad_doc(arr_x, doc_lens)\n",
    "\n",
    "        arr_x = self.sent_GRU(arr_x)[0]\n",
    "        sents_all_docs = arr_x.reshape(len(doc_lens) * max_doc_lens, 2*200) # flat docs\n",
    "        \n",
    "        docs = self.avg_pool1d(arr_x, doc_lens)\n",
    "        docs = torch.tanh(self.Wdoc(docs))\n",
    "        docs_for_each_sent = docs.repeat_interleave(max_doc_lens, dim=0) # repeat doc n times\n",
    "        \n",
    "        contents = self.Wcontent(sents_all_docs)\n",
    "        saliences = self.Wsalience(sents_all_docs, docs_for_each_sent)\n",
    "\n",
    "        # doc_len (number) s\n",
    "        ses = torch.zeros(len(doc_lens), 2*200)\n",
    "        ses = ses.to(self.device)\n",
    "\n",
    "        # for each document, compute probabilities\n",
    "        for position in range(max_doc_lens):\n",
    "            contents_for_position = contents[position::max_doc_lens]\n",
    "            saliences_for_position = saliences[position::max_doc_lens]\n",
    "            novelties_for_position = -1 * self.Wnovelty(sents_all_docs[position::max_doc_lens], torch.tanh(ses))\n",
    "            prob = contents_for_position + saliences_for_position + novelties_for_position + self.bias\n",
    "            prob = torch.sigmoid(prob)\n",
    "            probs.append(prob)\n",
    "\n",
    "            ses = ses + torch.mul(sents_all_docs[position::max_doc_lens], prob)\n",
    "        probs = torch.cat(probs).squeeze()\n",
    "        if len(probs.shape) == 0:\n",
    "            probs = probs.unsqueeze(0)\n",
    "        probs_filtered = []\n",
    "        for idx, doc_len in enumerate(doc_lens):\n",
    "            prob = probs[idx::len(doc_lens)]\n",
    "            prob = prob[:doc_len]\n",
    "            probs_filtered.append(prob)\n",
    "        probs_filtered = torch.cat(probs_filtered).squeeze()\n",
    "        if len(probs_filtered.shape) == 0:\n",
    "            probs_filtered = probs_filtered.unsqueeze(0)\n",
    "        #probs = probs.to(self.device)\n",
    "        return probs_filtered\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "380f8ba1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SIMPLE_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2ae1a236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SIMPLE_CNN_RNN(\n",
       "  (word_embedding): Embedding(150002, 100)\n",
       "  (word_convs): Sequential(\n",
       "    (0): Conv1d(100, 100, kernel_size=(4,), stride=(1,), padding=same)\n",
       "    (1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "  )\n",
       "  (sent_GRU): GRU(100, 200, batch_first=True, bidirectional=True)\n",
       "  (Wdoc): Linear(in_features=400, out_features=400, bias=True)\n",
       "  (Wcontent): Linear(in_features=400, out_features=1, bias=False)\n",
       "  (Wsalience): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       "  (Wnovelty): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4bc411ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.BCELoss()\n",
    "optimizer = torch.optim.Adamax(model.parameters(),lr=learning_rate)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.5)\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1852182a",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c6618af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[\"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:   0%|          | 0/4 [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%|██████████| 4/4 [00:01<00:00,  3.18batch/s, accuracy=0.709, loss=0.639, mae=0.299]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.553, val mae = 0.417, val accuracy = 0.851, r1 = 0.428, r2 = 0.189, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 4/4 [00:00<00:00,  5.91batch/s, accuracy=0.729, loss=0.675, mae=0.414]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.516, val mae = 0.389, val accuracy = 0.851, r1 = 0.428, r2 = 0.189, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 4/4 [00:00<00:00,  6.05batch/s, accuracy=0.771, loss=0.436, mae=0.249]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.497, val mae = 0.372, val accuracy = 0.851, r1 = 0.428, r2 = 0.189, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 4/4 [00:00<00:00,  6.09batch/s, accuracy=0.776, loss=0.418, mae=0.244]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.490, val mae = 0.367, val accuracy = 0.851, r1 = 0.428, r2 = 0.189, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 4/4 [00:00<00:00,  6.19batch/s, accuracy=0.773, loss=0.414, mae=0.249]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.481, val mae = 0.359, val accuracy = 0.852, r1 = 0.424, r2 = 0.189, rL = 0.263\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 4/4 [00:00<00:00,  6.09batch/s, accuracy=0.779, loss=0.415, mae=0.253]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.470, val mae = 0.349, val accuracy = 0.852, r1 = 0.425, r2 = 0.189, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 4/4 [00:00<00:00,  6.14batch/s, accuracy=0.777, loss=0.413, mae=0.257]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.457, val mae = 0.338, val accuracy = 0.850, r1 = 0.426, r2 = 0.190, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 4/4 [00:00<00:00,  6.17batch/s, accuracy=0.779, loss=0.402, mae=0.255]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.445, val mae = 0.326, val accuracy = 0.850, r1 = 0.425, r2 = 0.189, rL = 0.263\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 4/4 [00:00<00:00,  5.86batch/s, accuracy=0.775, loss=0.412, mae=0.255]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.434, val mae = 0.314, val accuracy = 0.850, r1 = 0.425, r2 = 0.188, rL = 0.263\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 4/4 [00:00<00:00,  5.96batch/s, accuracy=0.777, loss=0.403, mae=0.253]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.424, val mae = 0.304, val accuracy = 0.850, r1 = 0.426, r2 = 0.188, rL = 0.266\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 4/4 [00:00<00:00,  6.10batch/s, accuracy=0.777, loss=0.399, mae=0.251]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.416, val mae = 0.295, val accuracy = 0.850, r1 = 0.426, r2 = 0.188, rL = 0.266\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 4/4 [00:00<00:00,  5.82batch/s, accuracy=0.777, loss=0.407, mae=0.253]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.410, val mae = 0.288, val accuracy = 0.850, r1 = 0.426, r2 = 0.188, rL = 0.266\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 4/4 [00:00<00:00,  6.00batch/s, accuracy=0.78, loss=0.394, mae=0.25]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.406, val mae = 0.282, val accuracy = 0.850, r1 = 0.426, r2 = 0.188, rL = 0.266\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 4/4 [00:00<00:00,  5.96batch/s, accuracy=0.779, loss=0.403, mae=0.253]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.403, val mae = 0.278, val accuracy = 0.850, r1 = 0.426, r2 = 0.188, rL = 0.266\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 4/4 [00:00<00:00,  5.98batch/s, accuracy=0.778, loss=0.406, mae=0.255]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.401, val mae = 0.275, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 4/4 [00:00<00:00,  6.18batch/s, accuracy=0.776, loss=0.41, mae=0.256] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16 : val loss = 0.400, val mae = 0.273, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|██████████| 4/4 [00:00<00:00,  5.99batch/s, accuracy=0.78, loss=0.399, mae=0.252] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17 : val loss = 0.399, val mae = 0.272, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18: 100%|██████████| 4/4 [00:00<00:00,  6.17batch/s, accuracy=0.78, loss=0.395, mae=0.249] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 18 : val loss = 0.399, val mae = 0.271, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19: 100%|██████████| 4/4 [00:00<00:00,  6.17batch/s, accuracy=0.773, loss=0.413, mae=0.258]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 19 : val loss = 0.398, val mae = 0.271, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 4/4 [00:00<00:00,  6.07batch/s, accuracy=0.778, loss=0.402, mae=0.253]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 20 : val loss = 0.398, val mae = 0.270, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 21: 100%|██████████| 4/4 [00:00<00:00,  5.97batch/s, accuracy=0.777, loss=0.404, mae=0.255]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 21 : val loss = 0.398, val mae = 0.270, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 22: 100%|██████████| 4/4 [00:00<00:00,  5.82batch/s, accuracy=0.781, loss=0.395, mae=0.249]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 22 : val loss = 0.398, val mae = 0.270, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 23: 100%|██████████| 4/4 [00:00<00:00,  5.90batch/s, accuracy=0.777, loss=0.403, mae=0.253]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 23 : val loss = 0.398, val mae = 0.270, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 24: 100%|██████████| 4/4 [00:00<00:00,  5.79batch/s, accuracy=0.78, loss=0.407, mae=0.255] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 24 : val loss = 0.398, val mae = 0.270, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 25: 100%|██████████| 4/4 [00:00<00:00,  5.93batch/s, accuracy=0.78, loss=0.406, mae=0.253] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 25 : val loss = 0.398, val mae = 0.270, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 26: 100%|██████████| 4/4 [00:00<00:00,  5.82batch/s, accuracy=0.775, loss=0.413, mae=0.257]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 26 : val loss = 0.398, val mae = 0.270, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 27: 100%|██████████| 4/4 [00:00<00:00,  6.06batch/s, accuracy=0.772, loss=0.412, mae=0.257]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 27 : val loss = 0.398, val mae = 0.269, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 28: 100%|██████████| 4/4 [00:00<00:00,  6.12batch/s, accuracy=0.778, loss=0.406, mae=0.256]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 28 : val loss = 0.398, val mae = 0.270, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 29: 100%|██████████| 4/4 [00:00<00:00,  6.02batch/s, accuracy=0.776, loss=0.415, mae=0.259]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 29 : val loss = 0.398, val mae = 0.270, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 30: 100%|██████████| 4/4 [00:00<00:00,  6.14batch/s, accuracy=0.776, loss=0.408, mae=0.255]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 30 : val loss = 0.398, val mae = 0.270, val accuracy = 0.850, r1 = 0.425, r2 = 0.187, rL = 0.264\n",
      "Training duration = 72.81064105033875\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": [
       "27"
      ]
     },
     "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:01<00:00, 56.53batch/s, accuracy=0.82, mae=0.296, rouge1=0.399, rouge2=0.165, rougeL=0.248]\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, 208.85batch/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':   0%|          | 0/100 [00:00<?, ?batch/s, rouge1=0.468, rouge2=0.242, rougeL=0.335]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 203.74batch/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
}