01-train_RNN_RNN_Glove300.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train RNN_RNN"
   ]
  },
  {
   "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 models.RNN_RNN import RNN_RNN\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=1)\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: 1\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 = \"01-train_RNN_RNN_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=1)"
      ]
     },
     "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": null,
   "id": "9683721f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "380f8ba1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = RNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2ae1a236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RNN_RNN(\n",
       "  (word_embedding): Embedding(150002, 300)\n",
       "  (word_GRU): GRU(300, 200, batch_first=True, bidirectional=True)\n",
       "  (sent_GRU): GRU(400, 200, batch_first=True, bidirectional=True)\n",
       "  (rel_pos_emb): Embedding(11, 100)\n",
       "  (abs_pos_emb): Embedding(100, 100)\n",
       "  (Wdoc): Linear(in_features=400, out_features=400, bias=True)\n",
       "  (Wcontent): Linear(in_features=400, out_features=1, bias=False)\n",
       "  (Wsalience): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       "  (Wnovelty): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       "  (Wabs_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       "  (Wrel_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": 15,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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": 17,
   "id": "0991d3c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1: 100%|██████████| 13/13 [00:02<00:00,  4.34batch/s, accuracy=0.759, loss=0.52, mae=0.292] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.440, val mae = 0.288, val accuracy = 0.828, r1 = 0.484, r2 = 0.282, rL = 0.369\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 13/13 [00:02<00:00,  4.65batch/s, accuracy=0.82, loss=0.338, mae=0.187] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.362, val mae = 0.222, val accuracy = 0.853, r1 = 0.495, r2 = 0.295, rL = 0.376\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 13/13 [00:02<00:00,  4.74batch/s, accuracy=0.824, loss=0.318, mae=0.191]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.354, val mae = 0.219, val accuracy = 0.853, r1 = 0.498, r2 = 0.298, rL = 0.380\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 13/13 [00:02<00:00,  4.83batch/s, accuracy=0.833, loss=0.308, mae=0.184]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.352, val mae = 0.216, val accuracy = 0.852, r1 = 0.501, r2 = 0.300, rL = 0.382\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 13/13 [00:02<00:00,  4.65batch/s, accuracy=0.834, loss=0.297, mae=0.183]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.356, val mae = 0.221, val accuracy = 0.854, r1 = 0.499, r2 = 0.299, rL = 0.381\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 13/13 [00:02<00:00,  4.71batch/s, accuracy=0.833, loss=0.298, mae=0.186]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.355, val mae = 0.219, val accuracy = 0.854, r1 = 0.499, r2 = 0.299, rL = 0.382\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 13/13 [00:02<00:00,  4.58batch/s, accuracy=0.831, loss=0.294, mae=0.182]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.354, val mae = 0.218, val accuracy = 0.854, r1 = 0.500, r2 = 0.300, rL = 0.383\n",
      "Training duration = 41.87908625602722\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": 18,
   "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": 19,
   "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": 20,
   "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": 21,
   "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": 22,
   "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": 23,
   "id": "273c6eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = RNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4fc41994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 24,
     "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": 25,
   "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": 26,
   "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": 27,
   "id": "67659b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:03<00:00, 28.99batch/s, accuracy=0.861, mae=0.2, rouge1=0.437, rouge2=0.243, rougeL=0.331] \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": 28,
   "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": 29,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:00<00:00, 149.29batch/s, rouge1=0.406, rouge2=0.225, rougeL=0.309]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Lead-3\")\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), 3)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a3c5d9",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a4c96c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 124.14batch/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": 31,
   "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
}