13-train_SIMPLE_CNN_RNN_novelty_only_fasttext_fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train 13-train_SIMPLE_CNN_RNN_novelty_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_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 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=3)\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: 3\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 = \"13-train_SIMPLE_CNN_RNN_novelty_only_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=3)"
      ]
     },
     "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": 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.Wnovelty = nn.Bilinear(2*200,2*200,1,bias=False)\n",
    "        self.bias = nn.Parameter(torch.empty(1).uniform_(-0.1, 0.1))\n",
    "\n",
    "    def avg_pool1d(self,x,seq_lens):\n",
    "        out = []\n",
    "        for index,t in enumerate(x):\n",
    "            if seq_lens[index] == 0:\n",
    "                t = t[:1]\n",
    "            else:\n",
    "                t = t[:seq_lens[index],:]\n",
    "            t = torch.t(t).unsqueeze(0)\n",
    "            out.append(torch.avg_pool1d(t,t.size(2)))\n",
    "        \n",
    "        out = torch.cat(out).squeeze(2)\n",
    "        return out\n",
    "\n",
    "    def forward(self, arr_x, doc_lens):\n",
    "        probs = []\n",
    "\n",
    "        max_doc_lens = max(doc_lens)\n",
    "        #sent_lens = torch.sum(torch.sign(arr_x),dim=1).data\n",
    "\n",
    "        arr_x = self.word_embedding(arr_x)\n",
    "        arr_x = self.word_convs(arr_x.permute(0,2,1))\n",
    "        arr_x = torch.avg_pool1d(arr_x, arr_x.size(2)).squeeze(2)\n",
    "\n",
    "        arr_x = self.pad_doc(arr_x, doc_lens)\n",
    "\n",
    "        arr_x = self.sent_GRU(arr_x)[0]\n",
    "        sents_all_docs = arr_x.reshape(len(doc_lens) * max_doc_lens, 2*200) # flat docs\n",
    "        \n",
    "        docs = self.avg_pool1d(arr_x, doc_lens)\n",
    "        docs = torch.tanh(self.Wdoc(docs))\n",
    "        docs_for_each_sent = docs.repeat_interleave(max_doc_lens, dim=0) # repeat doc n times\n",
    "\n",
    "        # 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",
    "            novelties_for_position = -1 * self.Wnovelty(sents_all_docs[position::max_doc_lens], torch.tanh(ses))\n",
    "            prob = novelties_for_position + self.bias\n",
    "            prob = torch.sigmoid(prob)\n",
    "            probs.append(prob)\n",
    "\n",
    "            ses = ses + torch.mul(sents_all_docs[position::max_doc_lens], prob)\n",
    "        probs = torch.cat(probs).squeeze()\n",
    "        if len(probs.shape) == 0:\n",
    "            probs = probs.unsqueeze(0)\n",
    "        probs_filtered = []\n",
    "        for idx, doc_len in enumerate(doc_lens):\n",
    "            prob = probs[idx::len(doc_lens)]\n",
    "            prob = prob[:doc_len]\n",
    "            probs_filtered.append(prob)\n",
    "        probs_filtered = torch.cat(probs_filtered).squeeze()\n",
    "        if len(probs_filtered.shape) == 0:\n",
    "            probs_filtered = probs_filtered.unsqueeze(0)\n",
    "        #probs = probs.to(self.device)\n",
    "        return probs_filtered"
   ]
  },
  {
   "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(150001, 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",
       "  (Wnovelty): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4bc411ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.BCELoss()\n",
    "optimizer = torch.optim.Adamax(model.parameters(),lr=learning_rate)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.5)\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1852182a",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c6618af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[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/25 [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%|██████████| 25/25 [00:02<00:00,  9.28batch/s, accuracy=0.744, loss=0.517, mae=0.3]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.616, val mae = 0.456, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:02<00:00, 11.07batch/s, accuracy=0.77, loss=0.441, mae=0.277] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.545, val mae = 0.400, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:02<00:00, 11.00batch/s, accuracy=0.787, loss=0.414, mae=0.269]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.508, val mae = 0.368, val accuracy = 0.771, r1 = 0.330, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:02<00:00, 10.89batch/s, accuracy=0.806, loss=0.402, mae=0.261]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.488, val mae = 0.334, val accuracy = 0.777, r1 = 0.328, r2 = 0.113, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:02<00:00, 10.70batch/s, accuracy=0.791, loss=0.411, mae=0.268]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.487, val mae = 0.344, val accuracy = 0.766, r1 = 0.329, r2 = 0.114, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:02<00:00, 11.78batch/s, accuracy=0.797, loss=0.399, mae=0.265]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.485, val mae = 0.339, val accuracy = 0.767, r1 = 0.329, r2 = 0.113, rL = 0.219\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:02<00:00, 11.12batch/s, accuracy=0.787, loss=0.408, mae=0.269]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.484, val mae = 0.338, val accuracy = 0.769, r1 = 0.329, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:02<00:00, 11.90batch/s, accuracy=0.796, loss=0.407, mae=0.272]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.484, val mae = 0.337, val accuracy = 0.769, r1 = 0.329, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:02<00:00, 10.80batch/s, accuracy=0.795, loss=0.397, mae=0.263]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.484, val mae = 0.338, val accuracy = 0.769, r1 = 0.329, r2 = 0.113, rL = 0.220\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:02<00:00, 11.84batch/s, accuracy=0.786, loss=0.421, mae=0.281]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.483, val mae = 0.335, val accuracy = 0.771, r1 = 0.328, r2 = 0.113, rL = 0.219\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:02<00:00, 10.63batch/s, accuracy=0.798, loss=0.393, mae=0.258]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.484, val mae = 0.338, val accuracy = 0.769, r1 = 0.329, r2 = 0.113, rL = 0.219\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:02<00:00, 10.95batch/s, accuracy=0.798, loss=0.384, mae=0.256]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.484, val mae = 0.338, val accuracy = 0.769, r1 = 0.329, r2 = 0.113, rL = 0.219\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:02<00:00, 10.60batch/s, accuracy=0.792, loss=0.403, mae=0.264]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.483, val mae = 0.337, val accuracy = 0.769, r1 = 0.329, r2 = 0.113, rL = 0.220\n",
      "Training duration = 57.60897421836853\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": 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": [
       "10"
      ]
     },
     "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:01<00:00, 59.71batch/s, accuracy=0.742, mae=0.403, rouge1=0.343, rouge2=0.105, rougeL=0.205]\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": 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':   0%|          | 0/100 [00:00<?, ?batch/s, rouge1=0.437, rouge2=0.154, rougeL=0.253] "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 135.17batch/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": "markdown",
   "id": "78a3c5d9",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a4c96c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/100 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 131.38batch/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": 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
}