02-train_SIMPLE_CNN_RNN_Glove300.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train SIMPLE_CNN_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.SIMPLE_CNN_RNN import SIMPLE_CNN_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=4)\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: 4\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 = \"02-train_SIMPLE_CNN_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=4)"
      ]
     },
     "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 = SIMPLE_CNN_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": [
       "SIMPLE_CNN_RNN(\n",
       "  (word_embedding): Embedding(150002, 300)\n",
       "  (word_convs): Sequential(\n",
       "    (0): Conv1d(300, 100, kernel_size=(4,), stride=(1,), padding=same)\n",
       "    (1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "  )\n",
       "  (sent_GRU): GRU(100, 200, batch_first=True, bidirectional=True)\n",
       "  (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": 17,
   "id": "c6618af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[args.doc_col_name], is_sep_n = False)\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0991d3c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/13 [00:00<?, ?batch/s]/home/raoufdine/.local/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 13/13 [00:02<00:00,  5.53batch/s, accuracy=0.797, loss=0.402, mae=0.211]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.458, val mae = 0.340, val accuracy = 0.874, r1 = 0.494, r2 = 0.294, rL = 0.380\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 13/13 [00:01<00:00,  7.91batch/s, accuracy=0.822, loss=0.335, mae=0.194]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.435, val mae = 0.319, val accuracy = 0.875, r1 = 0.499, r2 = 0.300, rL = 0.385\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 13/13 [00:01<00:00,  8.11batch/s, accuracy=0.825, loss=0.305, mae=0.175]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.395, val mae = 0.275, val accuracy = 0.873, r1 = 0.504, r2 = 0.303, rL = 0.388\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 13/13 [00:01<00:00,  8.23batch/s, accuracy=0.831, loss=0.303, mae=0.181]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.332, val mae = 0.213, val accuracy = 0.873, r1 = 0.511, r2 = 0.311, rL = 0.396\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 13/13 [00:01<00:00,  8.34batch/s, accuracy=0.836, loss=0.289, mae=0.175]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.328, val mae = 0.203, val accuracy = 0.872, r1 = 0.510, r2 = 0.310, rL = 0.395\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 13/13 [00:01<00:00,  7.83batch/s, accuracy=0.839, loss=0.285, mae=0.175]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.328, val mae = 0.199, val accuracy = 0.872, r1 = 0.510, r2 = 0.310, rL = 0.395\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 13/13 [00:01<00:00,  8.03batch/s, accuracy=0.836, loss=0.292, mae=0.179]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.326, val mae = 0.197, val accuracy = 0.872, r1 = 0.510, r2 = 0.310, rL = 0.395\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 13/13 [00:01<00:00,  8.10batch/s, accuracy=0.84, loss=0.289, mae=0.176] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.326, val mae = 0.197, val accuracy = 0.872, r1 = 0.510, r2 = 0.310, rL = 0.395\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 13/13 [00:01<00:00,  7.76batch/s, accuracy=0.839, loss=0.275, mae=0.17] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.326, val mae = 0.197, val accuracy = 0.872, r1 = 0.510, r2 = 0.310, rL = 0.395\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 13/13 [00:01<00:00,  8.12batch/s, accuracy=0.837, loss=0.283, mae=0.174]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.328, val mae = 0.198, val accuracy = 0.872, r1 = 0.510, r2 = 0.310, rL = 0.395\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 13/13 [00:01<00:00,  8.62batch/s, accuracy=0.837, loss=0.28, mae=0.172] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.328, val mae = 0.199, val accuracy = 0.872, r1 = 0.510, r2 = 0.310, rL = 0.395\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 13/13 [00:01<00:00,  8.01batch/s, accuracy=0.842, loss=0.287, mae=0.175]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.326, val mae = 0.197, val accuracy = 0.872, r1 = 0.510, r2 = 0.310, rL = 0.395\n",
      "Training duration = 52.155029296875\n"
     ]
    }
   ],
   "source": [
    "arr_train_loss = []\n",
    "arr_train_mae = []\n",
    "arr_train_acc = []\n",
    "arr_val_loss = []\n",
    "arr_val_mae = []\n",
    "arr_val_acc = []\n",
    "\n",
    "t1 = time()\n",
    "for epoch in range(1, epochs+1):\n",
    "    # train 1 epoch\n",
    "    model.train()\n",
    "    nb_batch_train = 0\n",
    "    total_train_loss = 0\n",
    "    total_train_mae = 0\n",
    "    total_train_acc = 0\n",
    "    with tqdm(train_iter, unit=\"batch\", total=len(train_iter)) as tepoch:\n",
    "        for batch in tepoch:\n",
    "            tepoch.set_description(f\"Epoch {epoch}\")\n",
    "            features = []\n",
    "            doc_lens = []\n",
    "\n",
    "            for j in range(batch_size):\n",
    "                doc_lens.append(len(batch[j][\"docs\"]))\n",
    "                features = features + batch[j][\"docs\"]\n",
    "            \n",
    "            features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "            targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(batch_size)]\n",
    "            targets = torch.cat(targets)\n",
    "            targets = targets.to(device)\n",
    "            \n",
    "            probs = model(features, doc_lens)\n",
    "            \n",
    "            loss = loss_fn(probs, targets)\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            clip_grad_norm_(model.parameters(), 1.0)\n",
    "            optimizer.step()\n",
    "            nb_batch_train += 1\n",
    "            total_train_loss += loss.item()\n",
    "            total_train_mae += mae_fn(probs, targets).item()\n",
    "            total_train_acc += accuracy_prop_sent_per_doc_fn(probs=probs.cpu().detach().numpy(), targets=targets.cpu().detach().numpy(), doc_lens=doc_lens)\n",
    "            tepoch.set_postfix(loss=total_train_loss/nb_batch_train, mae=total_train_mae/nb_batch_train, accuracy=total_train_acc/nb_batch_train)\n",
    "\n",
    "    # Save model\n",
    "    model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "    # Show train and val score\n",
    "    model.eval()\n",
    "    nb_batch_val = 0\n",
    "    total_val_loss = 0\n",
    "    total_val_mae = 0\n",
    "    total_val_acc = 0\n",
    "\n",
    "    total_r1 = 0\n",
    "    total_r2 = 0\n",
    "    total_rl = 0\n",
    "\n",
    "    for i, batch in enumerate(val_iter):\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "            \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "        \n",
    "        y_pred = model(features, doc_lens)\n",
    "\n",
    "        loss = loss_fn(y_pred, targets)\n",
    "\n",
    "        nb_batch_val += 1\n",
    "        total_val_loss += loss.item()\n",
    "\n",
    "        doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "        summaries = val_set[args.sum_col_name].iloc[i]\n",
    "\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[j]]\n",
    "            y_pred_thresh.append(indices[j])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in y_pred_thresh:\n",
    "            txt = txt + \". \" + doc[j]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        total_r1 += scores[\"rouge1\"].fmeasure\n",
    "        total_r2 += scores[\"rouge2\"].fmeasure\n",
    "        total_rl += scores[\"rougeL\"].fmeasure\n",
    "\n",
    "        probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        total_val_mae += mae_fn(probs_tensor, targets).item()\n",
    "        total_val_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "    arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "    arr_train_mae.append(total_train_mae / nb_batch_train)\n",
    "    arr_train_acc.append(total_train_acc / nb_batch_train)\n",
    "\n",
    "    arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "    arr_val_mae.append(total_val_mae / nb_batch_val)\n",
    "    arr_val_acc.append(total_val_acc / nb_batch_val)\n",
    "    \n",
    "    print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "\n",
    "    if len(arr_val_loss) >= early_stopping+1:\n",
    "        if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "            break\n",
    "\n",
    "    # update lr\n",
    "    scheduler.step()\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2f39ceed",
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_mae\"]  = arr_train_mae\n",
    "training_metrics[\"train_acc\"]  = arr_train_acc\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_mae\"]    = arr_val_mae\n",
    "training_metrics[\"val_acc\"]    = arr_val_acc\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "    json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8cd8fbee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Losses\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_loss) + 1)), arr_train_loss, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_loss) + 1)), arr_val_loss, label=\"val\")\n",
    "\n",
    "    plt.title(\"Loss\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"loss\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8bda887e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw mae\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_mae) + 1)), arr_train_mae, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_mae) + 1)), arr_val_mae, label=\"val\")\n",
    "\n",
    "    plt.title(\"MAE\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"mae\")\n",
    "    plt.legend(loc=\"upper right\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1cc21154",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Accuracies\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_acc) + 1)), arr_train_acc, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_acc) + 1)), arr_val_acc, label=\"val\")\n",
    "\n",
    "    plt.title(\"Accuracy\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"accuracy\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0133ff45",
   "metadata": {},
   "source": [
    "# Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e095b271",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.split_all_docs import split_all_docs\n",
    "from rouge_score import rouge_scorer\n",
    "from utils.threshold_probs import threshold_probs_by_prop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "273c6eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SIMPLE_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4fc41994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_epoch = np.argmin(np.array(arr_val_loss)) + 1\n",
    "model.load(checkpoints_folder + \"/\" + model_name + \"-\" + str(best_epoch) + \".pt\")\n",
    "model.to(device)\n",
    "model.eval()\n",
    "best_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3edbae7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_set = df_test\n",
    "test_set[\"doc_splited\"] = split_all_docs(test_set[args.doc_col_name], False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bb8ab07a",
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "67659b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:02<00:00, 35.12batch/s, accuracy=0.874, mae=0.188, rouge1=0.437, rouge2=0.243, rougeL=0.328]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Eval model\")\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "                \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        y_pred = model(features, doc_lens)\n",
    "    \n",
    "        loss = criterion(y_pred, targets)\n",
    "\n",
    "        arr_loss.append(loss.item())\n",
    "\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "        #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[i]]\n",
    "            y_pred_thresh.append(indices[i])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[i]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        mae.append(mae_fn(probs_tensor, targets).item())\n",
    "\n",
    "        accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "        #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "        tepoch.set_postfix(accuracy = np.mean(accuracy), mae = np.mean(mae), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))\n",
    "        idx += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "5c1fd15f",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\n",
    "test_metrics[\"mae\"]      = np.mean(mae)\n",
    "test_metrics[\"rouge1\"]   = np.mean(arr_rouge1)\n",
    "test_metrics[\"rouge2\"]   = np.mean(arr_rouge2)\n",
    "test_metrics[\"rougeL\"]   = np.mean(arr_rougeL)\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/test_metrics.json\", 'w') as fp:\n",
    "    json.dump(test_metrics, fp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "496646f2",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:00<00:00, 136.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": 31,
   "id": "a4c96c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 116.79batch/s, rouge1=0.435, rouge2=0.241, rougeL=0.325]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e4f4796c",
   "metadata": {},
   "outputs": [
    {
     "ename": "SystemExit",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/raoufdine/anaconda3/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3465: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "# Does not excute this cell if you want to execute the following cells.\n",
    "import sys\n",
    "sys.exit()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "4f810f0bde7d7b5dc90f9e6832822547e13e234c53731a97fc91254323942f40"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}