05-train_HeterSUMGraphOnlyNERPOL_GAT.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train HeterSUMGraph NER POL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import argparse\n",
    "from time import time\n",
    "import torch\n",
    "import numpy as np\n",
    "import random\n",
    "from sklearn.utils import shuffle\n",
    "import json\n",
    "import os\n",
    "import networkx as nx\n",
    "import torch_geometric\n",
    "from statistics import mean\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils_pol.create_graph_dataset import create_graph_dataset\n",
    "from utils_pol.EmbMgr import EmbMgr\n",
    "from utils_pol.DataLoader import DataLoader\n",
    "from utils_pol.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils_pol.split_all_docs import split_all_docs\n",
    "from utils_pol.threshold_probs import threshold_probs_by_nb, threshold_probs_by_prop\n",
    "from utils_pol.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn\n",
    "from torch import nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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=0)\n",
    "parser.add_argument('-batch_size',type=int,default=2)\n",
    "parser.add_argument('-epochs',type=int,default=10)\n",
    "parser.add_argument('-dataset',type=str,default=\"data/wiki_geo_ratio_sc_0.5\")\n",
    "parser.add_argument('-dataset_tfidf',type=str,default=\"./data/wiki_geo_ratio_sc_0.5_dataset_tfidf.json\")\n",
    "parser.add_argument('-sent_tfidf',type=str,default=\"data/wiki_geo_ratio_sc_0.5_sent_tfidf.json\")\n",
    "parser.add_argument('-doc_column_name',type=str,default=\"flat_contents\")\n",
    "parser.add_argument('-labels_sum_column_name',type=str,default=\"labels_sentences\")\n",
    "parser.add_argument('-labels_ner_column_name',type=str,default=\"labels_entities\")\n",
    "parser.add_argument(\"-word_emb\",type=str,default=\"./data/cc.fr.300.vec\")\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": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 0\n",
      "epochs 100\n",
      "batch_size 2\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 = 50000\n",
    "batch_size = args.batch_size\n",
    "epochs = args.epochs\n",
    "learning_rate = 5e-4\n",
    "early_stopping = 3\n",
    "word_blacklist_proportion = 0.1\n",
    "model_name = \"05-train_HeterSUMGraphOnlyNERPOL_GAT\"\n",
    "sub_folder_name = \"model_name__{}__time__{}__embed_name__{}__lr__{}__batch_size__{}__vocab_size__{}__cuda_num__{}__early_stopping__{}\".format(model_name, time(), embed_name, learning_rate, batch_size, vocab_size, cuda_num, early_stopping)\n",
    "checkpoints_folder = \"./checkpoints/\" + sub_folder_name\n",
    "average_number_of_sentences_per_document = 3\n",
    "loss_sum_coef = 0.5\n",
    "loss_ner_coef = 0.5\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",
   "metadata": {},
   "source": [
    "## PyTorch initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(0)\n",
    "random.seed(0)\n",
    "np.random.seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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",
    "elif torch.backends.mps.is_available():\n",
    "  print(\"MPS available.\")\n",
    "else:\n",
    "  print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "elif torch.backends.mps.is_available():\n",
    "  dev = torch.device(\"mps\")\n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "embmgr = EmbMgr(args.word_emb, vocab_size=vocab_size, header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_sent = pd.read_json(args.sent_tfidf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_dataset = json.load(open(args.dataset_tfidf))\n",
    "tfidfs_dataset_sorted = sorted(tfidfs_dataset, key=tfidfs_dataset.get)\n",
    "word_blacklist = set(tfidfs_dataset_sorted[:int(word_blacklist_proportion*len(tfidfs_dataset_sorted))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(args.dataset + \"/test.json\")\n",
    "df_val = pd.read_json(args.dataset + \"/val.json\")\n",
    "df_train = pd.read_json(args.dataset + \"/train.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = create_graph_dataset(df=df_train, tfidfs_sent=tfidfs_sent, embmgr=embmgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=args.doc_column_name, labels_sum_column_name=args.labels_sum_column_name, labels_ner_column_name=args.labels_ner_column_name, is_sep_n=False, remove_stop_word = True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)\n",
    "val_dataset = create_graph_dataset(df=df_val, tfidfs_sent=tfidfs_sent, embmgr=embmgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=args.doc_column_name, labels_sum_column_name=args.labels_sum_column_name, labels_ner_column_name=args.labels_ner_column_name, is_sep_n=False, remove_stop_word = True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)\n",
    "test_dataset = create_graph_dataset(df=df_test, tfidfs_sent=tfidfs_sent, embmgr=embmgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=args.doc_column_name, labels_sum_column_name=args.labels_sum_column_name, labels_ner_column_name=args.labels_ner_column_name, is_sep_n=False, remove_stop_word = True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, ner=True)\n",
    "val_loader =  DataLoader(val_dataset, batch_size=1, shuffle=False, ner=True)\n",
    "test_loader =  DataLoader(test_dataset, batch_size=1, shuffle=False, ner=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average number of distinct word per doc: 309.29\n"
     ]
    }
   ],
   "source": [
    "# Average number of distinct word per doc\n",
    "print(\"Average number of distinct word per doc:\", mean([len(t[\"docs\"].x[0]) for t in train_dataset]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average sentence len: 15.202316412025628\n"
     ]
    }
   ],
   "source": [
    "def sents_len(doc):\n",
    "  return [torch.sum(torch.sign(s),dim=0).item() for s in doc]\n",
    "\n",
    "# Average sentence length\n",
    "lens = []\n",
    "for t in train_dataset:\n",
    "  lens = lens + sents_len(t[\"docs\"].x[1])\n",
    "\n",
    "print(\"Average sentence len:\", mean(lens))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average density: 0.016426792711350446\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/raoufdine/anaconda3/lib/python3.9/site-packages/torch_geometric/data/storage.py:303: UserWarning: Unable to accurately infer 'num_nodes' from the attribute set '{'undirected', 'x', 'edge_index', 'edge_attr'}'. Please explicitly set 'num_nodes' as an attribute of 'data' to suppress this warning\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# Average density\n",
    "def density(g):\n",
    "  nb_edges = g.num_edges / 2\n",
    "  nb_nodes = g.num_nodes\n",
    "  nb_poss_edges = nb_nodes * (nb_nodes - 1) / 2\n",
    "  return nb_edges / nb_poss_edges\n",
    "\n",
    "print(\"Average density:\", mean([density(t[\"docs\"]) for t in train_dataset]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average clustering: 0.0\n"
     ]
    }
   ],
   "source": [
    "# Average clustering\n",
    "def average_clustering(g):\n",
    "  G = nx.Graph()\n",
    "  edge_list = g.edge_index.t().tolist()\n",
    "  G.add_edges_from(edge_list)\n",
    "  return nx.average_clustering(G)\n",
    "\n",
    "print(\"Average clustering:\", mean([average_clustering(t[\"docs\"]) for t in train_dataset]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "from torch_geometric.nn import GATConv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Position Feed Forward\n",
    "class PositionwiseFeedForward(nn.Module):\n",
    "  def __init__(self, d_in, d_out, d_h, dropout=0.1) -> None:\n",
    "    super(PositionwiseFeedForward, self).__init__()\n",
    "    self.fc1 = nn.Linear(in_features=d_in, out_features=d_h)\n",
    "    self.fc2 = nn.Linear(in_features=d_h, out_features=d_out)\n",
    "    self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "  def forward(self, x):\n",
    "    x = torch.relu(self.fc1(x))\n",
    "    x = self.dropout(x)\n",
    "    return self.fc2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HeterSUMGraph(torch.nn.Module):\n",
    "  def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 300, num_iter=3):\n",
    "    super(HeterSUMGraph, self).__init__()\n",
    "    self.device = device\n",
    "    self.num_iter = num_iter\n",
    "\n",
    "    self.word_emb = nn.Embedding(vocab_size+2, dim_word_embed, padding_idx=0)\n",
    "\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",
    "    self.word_emb.weight.requires_grad = False\n",
    "\n",
    "    # edge_attr embed\n",
    "    self.edge_attr_embed = nn.Embedding(101, 50)\n",
    "\n",
    "    # sent CNN\n",
    "    dim_out_cnn = 64\n",
    "    self.convs = nn.Sequential(\n",
    "                            nn.Conv1d(in_channels=300,out_channels=100,kernel_size=3,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=100,kernel_size=4,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=dim_out_cnn,kernel_size=5,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=dim_out_cnn),\n",
    "                            nn.ReLU(inplace=True))\n",
    "\n",
    "    # sent LSTM\n",
    "    dim_out_lstm = 32\n",
    "    self.sent_LSTM = nn.LSTM(input_size=300, hidden_size=dim_out_lstm, batch_first=True, bidirectional=True)\n",
    "\n",
    "    # sent to word GAT\n",
    "    self.s2wGAT = GATConv(in_channels=[128, 300], out_channels=300, heads=8, edge_dim=50, fill_value=0)\n",
    "\n",
    "    # word to sen GAT\n",
    "    self.w2sGAT = GATConv(in_channels=[300, 128], out_channels=128, heads=8, edge_dim=50, fill_value=0)\n",
    "\n",
    "    # ffn sent to word\n",
    "    self.ffns2w = PositionwiseFeedForward(d_in=8*300, d_out=300, d_h=512)\n",
    "\n",
    "    # ffn word to sent\n",
    "    self.ffnw2s = PositionwiseFeedForward(d_in=8*128, d_out=128, d_h=512)\n",
    "\n",
    "    # predict summary\n",
    "    self.w_sum = nn.Linear(128, 1)\n",
    "    \n",
    "    # NER\n",
    "    self.w_ner = nn.Linear(300 + 50, 1)\n",
    "\n",
    "  def max_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, data):# In the real implémentation remove nb_sent\n",
    "    # edge attr embeddings\n",
    "    edge_attr = torch.floor(data.edge_attr * 100).int()\n",
    "    edge_attr = self.edge_attr_embed(edge_attr)\n",
    "\n",
    "    # features\n",
    "    Xw = data.x[0]\n",
    "    Xs = data.x[1]\n",
    "    sent_lens = torch.sum(torch.sign(Xs),dim=1).data\n",
    "    \n",
    "    # embeddings\n",
    "    Xw = self.word_emb(Xw)\n",
    "    Xs = self.word_emb(Xs)\n",
    "\n",
    "    # CNN\n",
    "    XsCNN = self.convs(Xs.permute(0,2,1))\n",
    "    XsCNN = torch.max_pool1d(XsCNN, XsCNN.size(2)).squeeze(2)\n",
    "\n",
    "    # LSTM\n",
    "    # TO DO: ask \n",
    "    XsLSTM, _ = self.sent_LSTM(Xs)\n",
    "    XsLSTM = self.max_pool1d(XsLSTM, sent_lens)\n",
    "    Xs = torch.cat((XsCNN, XsLSTM), dim=1)\n",
    "\n",
    "    Hw = Xw\n",
    "    Hs = Xs\n",
    "\n",
    "    edge_index_w_i = data.edge_index[1][data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_s_j = data.edge_index[0][data.edge_index[1] < len(data.x[0])] - Hw.shape[0]\n",
    "    edge_attr_w = edge_attr[data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_w = torch.stack([edge_index_s_j, edge_index_w_i])\n",
    "\n",
    "    edge_index_s_i = data.edge_index[1][data.edge_index[1] >= len(data.x[0])] - Hw.shape[0]\n",
    "    edge_index_w_j = data.edge_index[0][data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_attr_s = edge_attr[data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_index_s = torch.stack([edge_index_w_j, edge_index_s_i])\n",
    "\n",
    "    Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "    Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    for i in range(self.num_iter):\n",
    "      if i != 0: # H^1w = H^0w = Xw\n",
    "        Hw = self.s2wGAT(x=[Hs, Hw], edge_index=edge_index_w, edge_attr=edge_attr_w) + torch.cat([Hw] * 8, dim=1)\n",
    "        Hw = self.ffns2w(Hw)\n",
    "        Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "\n",
    "      Hs = self.w2sGAT(x=[Hw, Hs], edge_index=edge_index_s, edge_attr=edge_attr_s) + torch.cat([Hs] * 8, dim=1)\n",
    "      Hs = self.ffnw2s(Hs)\n",
    "      Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    # get indexes and attr list\n",
    "    edge_index_w = edge_index_w_i\n",
    "    edge_index_s = edge_index_s_j\n",
    "    edge_attr = edge_attr_w\n",
    "\n",
    "    # Duplicate Hw as many times as there is a sentence that contains it\n",
    "    v, c = torch.unique(edge_index_w, return_counts=True, sorted=True)\n",
    "\n",
    "    tmp_c = torch.zeros(Hw.shape[0], dtype=torch.long).to(Hw.device)\n",
    "    tmp_c[v] = c\n",
    "    c = tmp_c\n",
    "\n",
    "    Hw = Hw.repeat_interleave(c, 0)\n",
    "\n",
    "    # Get attr list\n",
    "    eiw_sorted = torch.argsort(edge_index_w)\n",
    "    attrs = edge_attr[eiw_sorted]\n",
    "\n",
    "    # Concat\n",
    "    Hw = torch.cat((Hw, attrs), dim=1)\n",
    "\n",
    "    o_sum = self.w_sum(Hs)\n",
    "    o_sum = torch.sigmoid(o_sum).squeeze(-1)\n",
    "\n",
    "    o_ner = self.w_ner(Hw)\n",
    "    o_ner = torch.sigmoid(o_ner).squeeze(-1)\n",
    "\n",
    "    return o_sum, o_ner\n",
    "\n",
    "  def save(self, fname):\n",
    "    torch.save(self.state_dict(), fname)\n",
    "\n",
    "  def load(self, fname):\n",
    "    self.load_state_dict(torch.load(fname))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HeterSUMGraph(device=device, vocab_size=vocab_size, word_embed=embmgr.getEmbeddings(), dim_word_embed=300).to(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "  os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[args.doc_column_name])\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/50 [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%|██████████| 50/50 [00:04<00:00, 10.26batch/s, accuracy_ner=0.874, loss=0.328, loss_ner=0.328]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.292, val loss ner = 0.292, val accuracy ner = 0.895\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 50/50 [00:04<00:00, 10.35batch/s, accuracy_ner=0.89, loss=0.287, loss_ner=0.287] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.274, val loss ner = 0.274, val accuracy ner = 0.893\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 50/50 [00:04<00:00, 11.83batch/s, accuracy_ner=0.894, loss=0.261, loss_ner=0.261]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.224, val loss ner = 0.224, val accuracy ner = 0.897\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 50/50 [00:04<00:00, 11.80batch/s, accuracy_ner=0.901, loss=0.226, loss_ner=0.226]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.215, val loss ner = 0.215, val accuracy ner = 0.898\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 50/50 [00:04<00:00, 11.53batch/s, accuracy_ner=0.904, loss=0.213, loss_ner=0.213]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.189, val loss ner = 0.189, val accuracy ner = 0.907\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 50/50 [00:04<00:00, 10.97batch/s, accuracy_ner=0.907, loss=0.202, loss_ner=0.202]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.189, val loss ner = 0.189, val accuracy ner = 0.908\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 50/50 [00:04<00:00, 11.44batch/s, accuracy_ner=0.907, loss=0.192, loss_ner=0.192]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.171, val loss ner = 0.171, val accuracy ner = 0.916\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 50/50 [00:04<00:00, 11.49batch/s, accuracy_ner=0.915, loss=0.177, loss_ner=0.177]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.186, val loss ner = 0.186, val accuracy ner = 0.895\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 50/50 [00:04<00:00, 11.23batch/s, accuracy_ner=0.914, loss=0.173, loss_ner=0.173]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.170, val loss ner = 0.170, val accuracy ner = 0.918\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 50/50 [00:04<00:00, 11.65batch/s, accuracy_ner=0.916, loss=0.171, loss_ner=0.171]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.158, val loss ner = 0.158, val accuracy ner = 0.924\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 50/50 [00:04<00:00, 11.68batch/s, accuracy_ner=0.923, loss=0.157, loss_ner=0.157]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.152, val loss ner = 0.152, val accuracy ner = 0.925\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 50/50 [00:04<00:00, 11.65batch/s, accuracy_ner=0.919, loss=0.163, loss_ner=0.163] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.151, val loss ner = 0.151, val accuracy ner = 0.928\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 50/50 [00:04<00:00, 10.00batch/s, accuracy_ner=0.93, loss=0.145, loss_ner=0.145] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.137, val loss ner = 0.137, val accuracy ner = 0.931\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 50/50 [00:04<00:00, 10.43batch/s, accuracy_ner=0.928, loss=0.146, loss_ner=0.146]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.137, val loss ner = 0.137, val accuracy ner = 0.934\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 50/50 [00:04<00:00, 11.23batch/s, accuracy_ner=0.929, loss=0.144, loss_ner=0.144]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.130, val loss ner = 0.130, val accuracy ner = 0.937\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 50/50 [00:04<00:00, 11.03batch/s, accuracy_ner=0.932, loss=0.137, loss_ner=0.137]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16 : val loss = 0.121, val loss ner = 0.121, val accuracy ner = 0.943\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|██████████| 50/50 [00:04<00:00, 11.71batch/s, accuracy_ner=0.936, loss=0.13, loss_ner=0.13]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17 : val loss = 0.123, val loss ner = 0.123, val accuracy ner = 0.942\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18: 100%|██████████| 50/50 [00:04<00:00, 11.66batch/s, accuracy_ner=0.935, loss=0.133, loss_ner=0.133]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 18 : val loss = 0.120, val loss ner = 0.120, val accuracy ner = 0.942\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19: 100%|██████████| 50/50 [00:04<00:00, 11.92batch/s, accuracy_ner=0.94, loss=0.126, loss_ner=0.126] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 19 : val loss = 0.112, val loss ner = 0.112, val accuracy ner = 0.948\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 50/50 [00:04<00:00, 11.14batch/s, accuracy_ner=0.944, loss=0.12, loss_ner=0.12]   \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 20 : val loss = 0.110, val loss ner = 0.110, val accuracy ner = 0.946\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 21: 100%|██████████| 50/50 [00:04<00:00, 10.29batch/s, accuracy_ner=0.943, loss=0.12, loss_ner=0.12]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 21 : val loss = 0.112, val loss ner = 0.112, val accuracy ner = 0.947\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 22: 100%|██████████| 50/50 [00:04<00:00, 11.76batch/s, accuracy_ner=0.943, loss=0.127, loss_ner=0.127] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 22 : val loss = 0.121, val loss ner = 0.121, val accuracy ner = 0.940\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 23: 100%|██████████| 50/50 [00:04<00:00, 11.16batch/s, accuracy_ner=0.942, loss=0.123, loss_ner=0.123] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 23 : val loss = 0.106, val loss ner = 0.106, val accuracy ner = 0.950\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 24: 100%|██████████| 50/50 [00:04<00:00, 11.55batch/s, accuracy_ner=0.944, loss=0.116, loss_ner=0.116]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 24 : val loss = 0.112, val loss ner = 0.112, val accuracy ner = 0.948\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 25: 100%|██████████| 50/50 [00:04<00:00, 10.06batch/s, accuracy_ner=0.947, loss=0.11, loss_ner=0.11]    \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 25 : val loss = 0.101, val loss ner = 0.101, val accuracy ner = 0.953\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 26: 100%|██████████| 50/50 [00:04<00:00, 11.70batch/s, accuracy_ner=0.947, loss=0.112, loss_ner=0.112] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 26 : val loss = 0.103, val loss ner = 0.103, val accuracy ner = 0.951\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 27: 100%|██████████| 50/50 [00:04<00:00, 10.56batch/s, accuracy_ner=0.95, loss=0.107, loss_ner=0.107]   \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 27 : val loss = 0.100, val loss ner = 0.100, val accuracy ner = 0.952\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 28: 100%|██████████| 50/50 [00:04<00:00, 11.50batch/s, accuracy_ner=0.951, loss=0.105, loss_ner=0.105]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 28 : val loss = 0.098, val loss ner = 0.098, val accuracy ner = 0.955\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 29: 100%|██████████| 50/50 [00:04<00:00, 11.76batch/s, accuracy_ner=0.952, loss=0.102, loss_ner=0.102]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 29 : val loss = 0.095, val loss ner = 0.095, val accuracy ner = 0.956\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 30: 100%|██████████| 50/50 [00:04<00:00, 11.67batch/s, accuracy_ner=0.951, loss=0.101, loss_ner=0.101]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 30 : val loss = 0.096, val loss ner = 0.096, val accuracy ner = 0.955\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 31: 100%|██████████| 50/50 [00:04<00:00, 11.99batch/s, accuracy_ner=0.952, loss=0.1, loss_ner=0.1]      \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 31 : val loss = 0.094, val loss ner = 0.094, val accuracy ner = 0.955\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 32: 100%|██████████| 50/50 [00:04<00:00, 11.98batch/s, accuracy_ner=0.953, loss=0.0976, loss_ner=0.0976]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 32 : val loss = 0.094, val loss ner = 0.094, val accuracy ner = 0.954\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 33: 100%|██████████| 50/50 [00:04<00:00, 11.62batch/s, accuracy_ner=0.954, loss=0.098, loss_ner=0.098]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 33 : val loss = 0.086, val loss ner = 0.086, val accuracy ner = 0.958\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 34: 100%|██████████| 50/50 [00:04<00:00, 11.37batch/s, accuracy_ner=0.952, loss=0.102, loss_ner=0.102]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 34 : val loss = 0.096, val loss ner = 0.096, val accuracy ner = 0.954\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 35: 100%|██████████| 50/50 [00:04<00:00, 11.06batch/s, accuracy_ner=0.952, loss=0.101, loss_ner=0.101]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 35 : val loss = 0.091, val loss ner = 0.091, val accuracy ner = 0.957\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 36: 100%|██████████| 50/50 [00:04<00:00, 11.55batch/s, accuracy_ner=0.955, loss=0.0952, loss_ner=0.0952]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 36 : val loss = 0.088, val loss ner = 0.088, val accuracy ner = 0.958\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 37: 100%|██████████| 50/50 [00:04<00:00, 11.64batch/s, accuracy_ner=0.955, loss=0.0944, loss_ner=0.0944]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 37 : val loss = 0.090, val loss ner = 0.090, val accuracy ner = 0.956\n",
      "Training duration = 272.95371174812317\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "arr_train_loss = []\n",
    "arr_train_loss_ner = []\n",
    "arr_train_acc_ner = []\n",
    "arr_val_loss = []\n",
    "arr_val_acc_ner = []\n",
    "\n",
    "t1 = time()\n",
    "\n",
    "for epoch in range(1, epochs+1):\n",
    "  # Train\n",
    "  model.train()\n",
    "  nb_batch_train = 0\n",
    "  total_train_loss = 0\n",
    "  total_train_loss_ner = 0\n",
    "  total_train_acc_ner = 0\n",
    "  with tqdm(train_loader, unit=\"batch\", total=len(train_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "      tepoch.set_description(f\"Epoch {epoch}\")\n",
    "      #if dev != \"cpu\":\n",
    "      #  torch.cuda.empty_cache()\n",
    "      doc_lens = batch[\"doc_lens\"]\n",
    "      data = batch[\"docs\"].to(device)\n",
    "      targets_sum = torch.tensor(batch[\"labels_sum\"], dtype=torch.float).to(device)\n",
    "      targets_ner = torch.tensor(batch[\"labels_ner\"], dtype=torch.float).to(device)\n",
    "      \n",
    "      y_sum_pred, y_ner_pred = model(data)\n",
    "\n",
    "      #loss_sum = criterion(y_sum_pred, targets_sum)\n",
    "      loss_ner = criterion(y_ner_pred, targets_ner)\n",
    "      \n",
    "      loss = loss_ner\n",
    "      \n",
    "      optimizer.zero_grad()\n",
    "      loss.backward()\n",
    "      nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n",
    "      optimizer.step()\n",
    "      nb_batch_train += 1\n",
    "      total_train_loss += loss.item()\n",
    "      #total_train_loss_sum += loss_sum.item()\n",
    "      total_train_loss_ner += loss_ner.item()\n",
    "\n",
    "      probs = y_sum_pred.tolist() # compute_probs(y_pred)\n",
    "      probs_tensor = y_sum_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "      #total_train_acc_sum += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets_sum.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "      total_train_acc_ner += torch.sum(((y_ner_pred > 0.5).float() == targets_ner).float()).item() / targets_ner.shape[0]\n",
    "\n",
    "      tepoch.set_postfix(loss=total_train_loss/nb_batch_train, loss_ner=total_train_loss_ner/nb_batch_train, accuracy_ner=total_train_acc_ner/nb_batch_train)\n",
    "\n",
    "  # Save model\n",
    "  model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "  # Eval\n",
    "  model.eval()\n",
    "  nb_batch_val = 0\n",
    "  total_val_loss = 0\n",
    "  total_val_loss_ner = 0\n",
    "  total_val_acc_ner = 0\n",
    "\n",
    "  del loss\n",
    "  del loss_ner\n",
    "  del y_sum_pred\n",
    "  del y_ner_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  for i, batch in enumerate(val_loader):\n",
    "    #if dev != \"cpu\":\n",
    "    #  torch.cuda.empty_cache()\n",
    "    doc_lens = batch[\"doc_lens\"]\n",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets_sum = torch.tensor(batch[\"labels_sum\"], dtype=torch.float).to(device)\n",
    "    targets_ner = torch.tensor(batch[\"labels_ner\"], dtype=torch.float).to(device)\n",
    "\n",
    "    y_sum_pred, y_ner_pred = model(data)\n",
    "\n",
    "    #loss_sum = criterion(y_sum_pred, targets_sum)\n",
    "    loss_ner = criterion(y_ner_pred, targets_ner)\n",
    "\n",
    "    loss = loss_ner    \n",
    "    #loss = loss_sum_coef * loss_sum + loss_ner_coef * loss_ner\n",
    "\n",
    "    nb_batch_val += 1\n",
    "    total_val_loss += loss.item()\n",
    "    #total_val_loss_sum += loss_sum.item()\n",
    "    total_val_loss_ner += loss_ner.item()\n",
    "\n",
    "    #total_val_acc_sum += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets_sum.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "    total_val_acc_ner += torch.sum(((y_ner_pred > 0.5).float() == targets_ner).float()).item() / targets_ner.shape[0]\n",
    "\n",
    "  print(\"Epoch {} : val loss = {:.3f}, val loss ner = {:.3f}, val accuracy ner = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_loss_ner / nb_batch_val, total_val_acc_ner / 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",
    "  del loss\n",
    "  del loss_ner\n",
    "  del y_sum_pred\n",
    "  del y_ner_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "  \n",
    "  arr_train_acc_ner.append(total_train_acc_ner / nb_batch_train)\n",
    "\n",
    "  arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "  arr_val_acc_ner.append(total_val_acc_ner / nb_batch_val)\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_acc_ner\"]  = arr_train_acc_ner\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_acc_ner\"]    = arr_val_acc_ner\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": 28,
   "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": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# draw Accuracies\n",
    "if False and is_graphic:\n",
    "  plt.plot(list(range(1, len(arr_train_acc_sum) + 1)), arr_train_acc_sum, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_acc_sum) + 1)), arr_val_acc_sum, label=\"val\")\n",
    "\n",
    "  plt.title(\"Accuracy Summary\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"accuracy\")\n",
    "  plt.legend(loc=\"upper left\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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_ner) + 1)), arr_train_acc_ner, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_acc_ner) + 1)), arr_val_acc_ner, label=\"val\")\n",
    "\n",
    "  plt.title(\"Accuracy NER\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"accuracy\")\n",
    "  plt.legend(loc=\"upper left\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HeterSUMGraph(device=device, vocab_size=vocab_size, word_embed=embmgr.getEmbeddings())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 32,
     "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": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test[\"doc_splitted\"] = split_all_docs(df_test[args.doc_column_name], False)\n",
    "test_set = df_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:03<00:00, 30.65batch/s, accuracy_ner=0.88, loss=0.483, loss_ner=0.483]\n"
     ]
    }
   ],
   "source": [
    "arr_loss = []\n",
    "arr_loss_ner = []\n",
    "accuracy_ner = []\n",
    "\n",
    "idx = 0\n",
    "\n",
    "counter = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "  for batch in tepoch:\n",
    "    tepoch.set_description(\"Eval model\")\n",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets_sum = torch.tensor(batch[\"labels_sum\"], dtype=torch.float).to(device)\n",
    "    targets_ner = torch.tensor(batch[\"labels_ner\"], dtype=torch.float).to(device)\n",
    "\n",
    "    y_sum_pred, y_ner_pred = model(data)\n",
    "\n",
    "    #loss_sum = criterion(y_sum_pred, targets_sum)\n",
    "    loss_ner = criterion(y_ner_pred, targets_ner)\n",
    "    \n",
    "    loss = loss_ner\n",
    "\n",
    "    arr_loss.append(loss.item())\n",
    "    arr_loss_ner.append(loss_ner.item())\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",
    "    accuracy_ner.append(torch.sum(((y_ner_pred > 0.5).float() == targets_ner).float()).item() / targets_ner.shape[0])\n",
    "\n",
    "    tepoch.set_postfix(loss=np.mean(arr_loss), loss_ner=np.mean(arr_loss_ner), accuracy_ner=np.mean(accuracy_ner))\n",
    "    idx += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy_ner\"] = np.mean(accuracy_ner)\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",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:01<00:00, 65.13batch/s, rouge1=0.298, rouge2=0.0863, rougeL=0.189]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Lead-3\")\n",
    "        doc = test_set[\"doc_splitted\"].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[\"summaries\"].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",
    "        # assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].recall)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].recall)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:01<00:00, 57.78batch/s, rouge1=0.328, rouge2=0.0932, rougeL=0.201]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[\"summaries\"].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\"].recall)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].recall)\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": 39,
   "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 execute 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"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "4f810f0bde7d7b5dc90f9e6832822547e13e234c53731a97fc91254323942f40"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}