14-train_SIMPLE_CNN_RNN_sailence_only_Glove300.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train 14-train_SIMPLE_CNN_RNN_sailence_only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a8a5bd39",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.utils import clip_grad_norm_\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils.GloveMgr import GloveMgr\n",
    "from utils.Dataset import Dataset\n",
    "from utils.DataLoader import DataLoader\n",
    "from utils.preprocess_df import preprocess_df\n",
    "from utils.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn\n",
    "from utils.split_all_docs import split_all_docs\n",
    "\n",
    "\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 = \"14-train_SIMPLE_CNN_RNN_sailence_only_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": 12,
   "id": "9683721f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from models.BasicModel import BasicModel\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "\n",
    "class SIMPLE_CNN_RNN(BasicModel):\n",
    "    def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 100):\n",
    "        super(SIMPLE_CNN_RNN, self).__init__(device)\n",
    "\n",
    "        self.device = device\n",
    "\n",
    "        self.word_embedding = nn.Embedding(vocab_size+2, dim_word_embed, padding_idx=0)\n",
    "        # Load word embedding if specified\n",
    "        if word_embed is not None:\n",
    "            self.word_embedding = torch.nn.Embedding.from_pretrained(torch.from_numpy(word_embed).float())\n",
    "\n",
    "        # 100 : word2vec embedding size\n",
    "        self.word_convs = nn.Sequential(\n",
    "                            nn.Conv1d(in_channels=dim_word_embed,out_channels=100,kernel_size=4,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True))\n",
    "        self.sent_GRU = nn.GRU(input_size = 100, hidden_size=200, batch_first = True, bidirectional = True)\n",
    "\n",
    "        self.Wdoc = nn.Linear(2*200,2*200,bias=True)\n",
    "\n",
    "        self.Wsalience = nn.Bilinear(2*200,2*200,1,bias=False)\n",
    "        self.bias = nn.Parameter(torch.empty(1).uniform_(-0.1, 0.1))\n",
    "\n",
    "    def avg_pool1d(self,x,seq_lens):\n",
    "        out = []\n",
    "        for index,t in enumerate(x):\n",
    "            if seq_lens[index] == 0:\n",
    "                t = t[:1]\n",
    "            else:\n",
    "                t = t[:seq_lens[index],:]\n",
    "            t = torch.t(t).unsqueeze(0)\n",
    "            out.append(torch.avg_pool1d(t,t.size(2)))\n",
    "        \n",
    "        out = torch.cat(out).squeeze(2)\n",
    "        return out\n",
    "\n",
    "    def forward(self, arr_x, doc_lens):\n",
    "        probs = []\n",
    "\n",
    "        max_doc_lens = max(doc_lens)\n",
    "        #sent_lens = torch.sum(torch.sign(arr_x),dim=1).data\n",
    "\n",
    "        arr_x = self.word_embedding(arr_x)\n",
    "        arr_x = self.word_convs(arr_x.permute(0,2,1))\n",
    "        arr_x = torch.avg_pool1d(arr_x, arr_x.size(2)).squeeze(2)\n",
    "\n",
    "        arr_x = self.pad_doc(arr_x, doc_lens)\n",
    "\n",
    "        arr_x = self.sent_GRU(arr_x)[0]\n",
    "        sents_all_docs = arr_x.reshape(len(doc_lens) * max_doc_lens, 2*200) # flat docs\n",
    "        \n",
    "        docs = self.avg_pool1d(arr_x, doc_lens)\n",
    "        docs = torch.tanh(self.Wdoc(docs))\n",
    "        docs_for_each_sent = docs.repeat_interleave(max_doc_lens, dim=0) # repeat doc n times\n",
    "\n",
    "        saliences = self.Wsalience(sents_all_docs, docs_for_each_sent)\n",
    "\n",
    "        # doc_len (number) s\n",
    "        ses = torch.zeros(len(doc_lens), 2*200)\n",
    "        ses = ses.to(self.device)\n",
    "\n",
    "        # for each document, compute probabilities\n",
    "        for position in range(max_doc_lens):\n",
    "            saliences_for_position = saliences[position::max_doc_lens]\n",
    "            prob = saliences_for_position + self.bias\n",
    "            prob = torch.sigmoid(prob)\n",
    "            probs.append(prob)\n",
    "\n",
    "            ses = ses + torch.mul(sents_all_docs[position::max_doc_lens], prob)\n",
    "        probs = torch.cat(probs).squeeze()\n",
    "        if len(probs.shape) == 0:\n",
    "            probs = probs.unsqueeze(0)\n",
    "        probs_filtered = []\n",
    "        for idx, doc_len in enumerate(doc_lens):\n",
    "            prob = probs[idx::len(doc_lens)]\n",
    "            prob = prob[:doc_len]\n",
    "            probs_filtered.append(prob)\n",
    "        probs_filtered = torch.cat(probs_filtered).squeeze()\n",
    "        if len(probs_filtered.shape) == 0:\n",
    "            probs_filtered = probs_filtered.unsqueeze(0)\n",
    "        #probs = probs.to(self.device)\n",
    "        return probs_filtered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "380f8ba1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SIMPLE_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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",
       "  (Wdoc): Linear(in_features=400, out_features=400, bias=True)\n",
       "  (Wsalience): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4bc411ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.BCELoss()\n",
    "optimizer = torch.optim.Adamax(model.parameters(),lr=learning_rate)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.5)\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1852182a",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c6618af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[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:01<00:00, 10.47batch/s, accuracy=0.742, loss=0.492, mae=0.31] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.597, val mae = 0.446, val accuracy = 0.867, r1 = 0.507, r2 = 0.310, rL = 0.392\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 13/13 [00:00<00:00, 20.77batch/s, accuracy=0.807, loss=0.411, mae=0.261]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.456, val mae = 0.349, val accuracy = 0.867, r1 = 0.509, r2 = 0.311, rL = 0.392\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 13/13 [00:00<00:00, 22.61batch/s, accuracy=0.822, loss=0.355, mae=0.211]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.357, val mae = 0.252, val accuracy = 0.867, r1 = 0.508, r2 = 0.311, rL = 0.392\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 13/13 [00:00<00:00, 24.43batch/s, accuracy=0.821, loss=0.357, mae=0.212]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.334, val mae = 0.212, val accuracy = 0.867, r1 = 0.508, r2 = 0.311, rL = 0.392\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 13/13 [00:00<00:00, 22.42batch/s, accuracy=0.823, loss=0.341, mae=0.204]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.333, val mae = 0.201, val accuracy = 0.867, r1 = 0.508, r2 = 0.311, rL = 0.392\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 13/13 [00:00<00:00, 23.74batch/s, accuracy=0.83, loss=0.34, mae=0.206]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.334, val mae = 0.199, val accuracy = 0.867, r1 = 0.508, r2 = 0.311, rL = 0.392\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 13/13 [00:00<00:00, 23.40batch/s, accuracy=0.831, loss=0.331, mae=0.203]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.333, val mae = 0.197, val accuracy = 0.867, r1 = 0.508, r2 = 0.311, rL = 0.392\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 13/13 [00:00<00:00, 22.00batch/s, accuracy=0.824, loss=0.348, mae=0.206]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.333, val mae = 0.196, val accuracy = 0.867, r1 = 0.508, r2 = 0.311, rL = 0.392\n",
      "Training duration = 21.7118558883667\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": [
       "5"
      ]
     },
     "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:   6%|▌         | 6/100 [00:00<00:01, 56.48batch/s, accuracy=0.895, mae=0.174, rouge1=0.455, rouge2=0.271, rougeL=0.352]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:02<00:00, 49.97batch/s, accuracy=0.864, mae=0.201, rouge1=0.436, rouge2=0.241, rougeL=0.327]\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": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 118.55batch/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": "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, 121.70batch/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
}