05-train_RES_CNN_RNN_fasttext_fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train RES_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_french.EmbMgr import EmbMgr\n",
    "from utils_french.Dataset import Dataset\n",
    "from utils_french.DataLoader import DataLoader\n",
    "from utils_french.preprocess_df import preprocess_df\n",
    "from utils_french.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils_french.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn\n",
    "from utils_french.split_all_docs import split_all_docs\n",
    "\n",
    "from models.RES_CNN_RNN import RES_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=5)\n",
    "parser.add_argument('-batch_size',type=int,default=4)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "parser.add_argument('-dataset',type=str,default=\"./data/wiki_geo_ratio_sc_0.5/\")\n",
    "parser.add_argument('-doc_col_name',type=str,default=\"flat_contents\")\n",
    "parser.add_argument('-label_col_name',type=str,default=\"labels_sentences\")\n",
    "parser.add_argument('-sum_col_name',type=str,default=\"summaries\")\n",
    "parser.add_argument('-max_doc_len',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: 5\n",
      "epochs 100\n",
      "batch_size 4\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"cc.fr.300.vec\"\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 = \"05-train_RES_CNN_RNN_FastTextfr\"\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=5)"
      ]
     },
     "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 = EmbMgr(\"./data/cc.fr.300.vec\", vocab_size=vocab_size, header=True)"
   ]
  },
  {
   "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 = RES_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": [
       "RES_CNN_RNN(\n",
       "  (word_embedding): Embedding(150001, 300)\n",
       "  (word_convs): ModuleList(\n",
       "    (0): Sequential(\n",
       "      (0): Conv1d(300, 100, kernel_size=(3,), 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",
       "    (1): 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",
       "    (2): Sequential(\n",
       "      (0): Conv1d(100, 100, kernel_size=(5,), 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",
       "  )\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": 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:   0%|          | 0/25 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/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%|██████████| 25/25 [00:03<00:00,  7.16batch/s, accuracy=0.708, loss=7.08, mae=0.353]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 1.445, val mae = 0.657, val accuracy = 0.599, r1 = 0.243, r2 = 0.054, rL = 0.154\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:02<00:00,  8.74batch/s, accuracy=0.745, loss=0.518, mae=0.27] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.502, val mae = 0.325, val accuracy = 0.777, r1 = 0.327, r2 = 0.110, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:02<00:00,  8.58batch/s, accuracy=0.771, loss=0.443, mae=0.239]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.478, val mae = 0.313, val accuracy = 0.774, r1 = 0.324, r2 = 0.106, rL = 0.213\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:03<00:00,  7.89batch/s, accuracy=0.786, loss=0.4, mae=0.229]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.464, val mae = 0.308, val accuracy = 0.773, r1 = 0.326, r2 = 0.109, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:02<00:00,  8.39batch/s, accuracy=0.787, loss=0.406, mae=0.25] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.467, val mae = 0.290, val accuracy = 0.775, r1 = 0.328, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:02<00:00,  8.71batch/s, accuracy=0.775, loss=0.403, mae=0.239]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.456, val mae = 0.308, val accuracy = 0.772, r1 = 0.328, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:02<00:00,  8.46batch/s, accuracy=0.777, loss=0.411, mae=0.251]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.452, val mae = 0.302, val accuracy = 0.771, r1 = 0.327, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:03<00:00,  8.06batch/s, accuracy=0.79, loss=0.382, mae=0.239] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.454, val mae = 0.307, val accuracy = 0.770, r1 = 0.328, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:02<00:00,  9.14batch/s, accuracy=0.781, loss=0.396, mae=0.252]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.452, val mae = 0.304, val accuracy = 0.775, r1 = 0.327, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:02<00:00,  9.01batch/s, accuracy=0.783, loss=0.382, mae=0.244]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.451, val mae = 0.303, val accuracy = 0.770, r1 = 0.327, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:02<00:00,  9.11batch/s, accuracy=0.774, loss=0.4, mae=0.252]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.451, val mae = 0.302, val accuracy = 0.775, r1 = 0.327, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:03<00:00,  8.03batch/s, accuracy=0.782, loss=0.385, mae=0.24] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.452, val mae = 0.305, val accuracy = 0.775, r1 = 0.327, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:02<00:00,  8.90batch/s, accuracy=0.775, loss=0.402, mae=0.249]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.450, val mae = 0.302, val accuracy = 0.775, r1 = 0.327, r2 = 0.111, rL = 0.216\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 25/25 [00:03<00:00,  7.85batch/s, accuracy=0.795, loss=0.378, mae=0.237]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.451, val mae = 0.302, val accuracy = 0.775, r1 = 0.327, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 25/25 [00:02<00:00,  9.31batch/s, accuracy=0.775, loss=0.399, mae=0.255]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.449, val mae = 0.300, val accuracy = 0.775, r1 = 0.328, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 25/25 [00:02<00:00,  8.40batch/s, accuracy=0.799, loss=0.383, mae=0.24] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16 : val loss = 0.452, val mae = 0.304, val accuracy = 0.775, r1 = 0.327, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|██████████| 25/25 [00:02<00:00,  8.69batch/s, accuracy=0.79, loss=0.389, mae=0.24]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17 : val loss = 0.452, val mae = 0.304, val accuracy = 0.775, r1 = 0.327, r2 = 0.111, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18: 100%|██████████| 25/25 [00:03<00:00,  8.12batch/s, accuracy=0.787, loss=0.387, mae=0.24] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 18 : val loss = 0.452, val mae = 0.304, val accuracy = 0.775, r1 = 0.327, r2 = 0.111, rL = 0.217\n",
      "Training duration = 99.18915510177612\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",
    "        if indices.shape[0] > len(doc):\n",
    "            continue\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 = RES_CNN_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": [
       "15"
      ]
     },
     "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:02<00:00, 40.53batch/s, accuracy=0.783, mae=0.323, rouge1=0.324, rouge2=0.0904, rougeL=0.198]\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",
    "        if indices.shape[0] > len(doc):\n",
    "            continue\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, 173.05batch/s, rouge1=0.309, rouge2=0.0904, rougeL=0.195]\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, 140.59batch/s, rouge1=0.325, rouge2=0.0923, rougeL=0.199]\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
}