02-train_HeterSUMGraphNER_GAT.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train HeterSUMGraph NER"
   ]
  },
  {
   "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.create_graph_dataset import create_graph_dataset\n",
    "from utils.EmbMgr import EmbMgr\n",
    "from utils.DataLoader import DataLoader\n",
    "from utils.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils.split_all_docs import split_all_docs\n",
    "from utils.threshold_probs import threshold_probs_by_nb, threshold_probs_by_prop\n",
    "from utils.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=4)\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 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 = 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 = \"02-train_HeterSUMGraphNER_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', 'edge_attr', 'x', 'edge_index'}'. 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",
    "    self.w_sum = nn.Linear(128, 1)\n",
    "    self.w_ner = nn.Linear(300, 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",
    "    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/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:03<00:00,  6.48batch/s, accuracy_ner=0.888, accuracy_sum=0.758, loss=0.466, loss_ner=0.333, loss_sum=0.598]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.458, val loss summary = 0.626, val loss ner = 0.290, val accuracy summary = 0.664, val accuracy ner = 0.914, r1 = 0.289, r2 = 0.082, rL = 0.182\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:03<00:00,  7.89batch/s, accuracy_ner=0.923, accuracy_sum=0.753, loss=0.412, loss_ner=0.263, loss_sum=0.561]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.459, val loss summary = 0.664, val loss ner = 0.254, val accuracy summary = 0.648, val accuracy ner = 0.924, r1 = 0.285, r2 = 0.093, rL = 0.183\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:03<00:00,  8.16batch/s, accuracy_ner=0.928, accuracy_sum=0.766, loss=0.386, loss_ner=0.237, loss_sum=0.534]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.448, val loss summary = 0.634, val loss ner = 0.263, val accuracy summary = 0.644, val accuracy ner = 0.924, r1 = 0.277, r2 = 0.081, rL = 0.173\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:03<00:00,  7.48batch/s, accuracy_ner=0.935, accuracy_sum=0.762, loss=0.378, loss_ner=0.21, loss_sum=0.547] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.422, val loss summary = 0.637, val loss ner = 0.208, val accuracy summary = 0.654, val accuracy ner = 0.928, r1 = 0.268, r2 = 0.074, rL = 0.164\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:03<00:00,  7.96batch/s, accuracy_ner=0.936, accuracy_sum=0.753, loss=0.366, loss_ner=0.181, loss_sum=0.551]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.402, val loss summary = 0.639, val loss ner = 0.166, val accuracy summary = 0.664, val accuracy ner = 0.934, r1 = 0.284, r2 = 0.086, rL = 0.177\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:03<00:00,  8.27batch/s, accuracy_ner=0.934, accuracy_sum=0.744, loss=0.364, loss_ner=0.173, loss_sum=0.556]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.411, val loss summary = 0.678, val loss ner = 0.145, val accuracy summary = 0.663, val accuracy ner = 0.939, r1 = 0.285, r2 = 0.087, rL = 0.182\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:03<00:00,  6.84batch/s, accuracy_ner=0.937, accuracy_sum=0.747, loss=0.361, loss_ner=0.151, loss_sum=0.572]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.383, val loss summary = 0.633, val loss ner = 0.132, val accuracy summary = 0.692, val accuracy ner = 0.941, r1 = 0.270, r2 = 0.084, rL = 0.178\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:03<00:00,  7.97batch/s, accuracy_ner=0.943, accuracy_sum=0.755, loss=0.347, loss_ner=0.136, loss_sum=0.558]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.380, val loss summary = 0.626, val loss ner = 0.134, val accuracy summary = 0.653, val accuracy ner = 0.942, r1 = 0.262, r2 = 0.072, rL = 0.166\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:03<00:00,  8.05batch/s, accuracy_ner=0.945, accuracy_sum=0.756, loss=0.345, loss_ner=0.129, loss_sum=0.561]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.397, val loss summary = 0.674, val loss ner = 0.119, val accuracy summary = 0.690, val accuracy ner = 0.946, r1 = 0.297, r2 = 0.100, rL = 0.196\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:03<00:00,  8.21batch/s, accuracy_ner=0.946, accuracy_sum=0.747, loss=0.34, loss_ner=0.122, loss_sum=0.558] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.388, val loss summary = 0.649, val loss ner = 0.128, val accuracy summary = 0.679, val accuracy ner = 0.946, r1 = 0.290, r2 = 0.097, rL = 0.191\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:03<00:00,  7.87batch/s, accuracy_ner=0.949, accuracy_sum=0.752, loss=0.336, loss_ner=0.121, loss_sum=0.551] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.380, val loss summary = 0.644, val loss ner = 0.117, val accuracy summary = 0.678, val accuracy ner = 0.949, r1 = 0.284, r2 = 0.090, rL = 0.185\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:03<00:00,  6.84batch/s, accuracy_ner=0.954, accuracy_sum=0.756, loss=0.33, loss_ner=0.11, loss_sum=0.55]   \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.412, val loss summary = 0.706, val loss ner = 0.118, val accuracy summary = 0.659, val accuracy ner = 0.951, r1 = 0.279, r2 = 0.086, rL = 0.177\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:03<00:00,  7.79batch/s, accuracy_ner=0.958, accuracy_sum=0.763, loss=0.326, loss_ner=0.1, loss_sum=0.552]   \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.367, val loss summary = 0.646, val loss ner = 0.087, val accuracy summary = 0.649, val accuracy ner = 0.963, r1 = 0.284, r2 = 0.085, rL = 0.180\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 25/25 [00:03<00:00,  8.16batch/s, accuracy_ner=0.962, accuracy_sum=0.762, loss=0.319, loss_ner=0.09, loss_sum=0.548]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.369, val loss summary = 0.646, val loss ner = 0.092, val accuracy summary = 0.636, val accuracy ner = 0.962, r1 = 0.273, r2 = 0.073, rL = 0.172\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 25/25 [00:03<00:00,  7.46batch/s, accuracy_ner=0.964, accuracy_sum=0.773, loss=0.308, loss_ner=0.0856, loss_sum=0.531]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.362, val loss summary = 0.643, val loss ner = 0.081, val accuracy summary = 0.647, val accuracy ner = 0.965, r1 = 0.267, r2 = 0.075, rL = 0.167\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 25/25 [00:03<00:00,  8.14batch/s, accuracy_ner=0.968, accuracy_sum=0.774, loss=0.303, loss_ner=0.0763, loss_sum=0.529]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16 : val loss = 0.361, val loss summary = 0.647, val loss ner = 0.076, val accuracy summary = 0.653, val accuracy ner = 0.966, r1 = 0.275, r2 = 0.079, rL = 0.173\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|██████████| 25/25 [00:03<00:00,  7.80batch/s, accuracy_ner=0.965, accuracy_sum=0.769, loss=0.308, loss_ner=0.0793, loss_sum=0.537]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17 : val loss = 0.363, val loss summary = 0.648, val loss ner = 0.077, val accuracy summary = 0.669, val accuracy ner = 0.969, r1 = 0.284, r2 = 0.083, rL = 0.176\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18: 100%|██████████| 25/25 [00:03<00:00,  7.15batch/s, accuracy_ner=0.967, accuracy_sum=0.754, loss=0.316, loss_ner=0.0825, loss_sum=0.55] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 18 : val loss = 0.358, val loss summary = 0.634, val loss ner = 0.082, val accuracy summary = 0.662, val accuracy ner = 0.965, r1 = 0.277, r2 = 0.073, rL = 0.166\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19: 100%|██████████| 25/25 [00:03<00:00,  7.05batch/s, accuracy_ner=0.963, accuracy_sum=0.743, loss=0.326, loss_ner=0.0835, loss_sum=0.568]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 19 : val loss = 0.378, val loss summary = 0.680, val loss ner = 0.076, val accuracy summary = 0.690, val accuracy ner = 0.968, r1 = 0.300, r2 = 0.092, rL = 0.190\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 20: 100%|██████████| 25/25 [00:03<00:00,  6.95batch/s, accuracy_ner=0.971, accuracy_sum=0.754, loss=0.311, loss_ner=0.0677, loss_sum=0.555]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 20 : val loss = 0.358, val loss summary = 0.646, val loss ner = 0.071, val accuracy summary = 0.675, val accuracy ner = 0.969, r1 = 0.283, r2 = 0.085, rL = 0.183\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 21: 100%|██████████| 25/25 [00:03<00:00,  8.14batch/s, accuracy_ner=0.969, accuracy_sum=0.756, loss=0.305, loss_ner=0.0675, loss_sum=0.542]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 21 : val loss = 0.355, val loss summary = 0.645, val loss ner = 0.065, val accuracy summary = 0.681, val accuracy ner = 0.973, r1 = 0.278, r2 = 0.079, rL = 0.176\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 22: 100%|██████████| 25/25 [00:03<00:00,  8.07batch/s, accuracy_ner=0.972, accuracy_sum=0.752, loss=0.309, loss_ner=0.07, loss_sum=0.549]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 22 : val loss = 0.351, val loss summary = 0.636, val loss ner = 0.066, val accuracy summary = 0.673, val accuracy ner = 0.971, r1 = 0.268, r2 = 0.076, rL = 0.171\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 23: 100%|██████████| 25/25 [00:03<00:00,  7.81batch/s, accuracy_ner=0.973, accuracy_sum=0.766, loss=0.298, loss_ner=0.0616, loss_sum=0.535]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 23 : val loss = 0.356, val loss summary = 0.646, val loss ner = 0.066, val accuracy summary = 0.667, val accuracy ner = 0.969, r1 = 0.273, r2 = 0.075, rL = 0.170\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 24: 100%|██████████| 25/25 [00:02<00:00,  8.36batch/s, accuracy_ner=0.97, accuracy_sum=0.747, loss=0.313, loss_ner=0.0687, loss_sum=0.556] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 24 : val loss = 0.360, val loss summary = 0.652, val loss ner = 0.067, val accuracy summary = 0.665, val accuracy ner = 0.971, r1 = 0.282, r2 = 0.079, rL = 0.178\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 25: 100%|██████████| 25/25 [00:03<00:00,  6.62batch/s, accuracy_ner=0.973, accuracy_sum=0.747, loss=0.313, loss_ner=0.066, loss_sum=0.56]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 25 : val loss = 0.360, val loss summary = 0.653, val loss ner = 0.067, val accuracy summary = 0.680, val accuracy ner = 0.971, r1 = 0.273, r2 = 0.074, rL = 0.172\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 26: 100%|██████████| 25/25 [00:03<00:00,  8.21batch/s, accuracy_ner=0.969, accuracy_sum=0.756, loss=0.312, loss_ner=0.0714, loss_sum=0.553]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 26 : val loss = 0.352, val loss summary = 0.637, val loss ner = 0.066, val accuracy summary = 0.673, val accuracy ner = 0.972, r1 = 0.292, r2 = 0.083, rL = 0.183\n",
      "Training duration = 168.1507978439331\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "arr_train_loss = []\n",
    "arr_train_loss_sum = []\n",
    "arr_train_loss_ner = []\n",
    "arr_train_acc_sum = []\n",
    "arr_train_acc_ner = []\n",
    "arr_val_loss = []\n",
    "arr_val_acc_sum = []\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_sum = 0\n",
    "  total_train_loss_ner = 0\n",
    "  total_train_acc_sum = 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_sum_coef * loss_sum + loss_ner_coef * 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_sum=total_train_loss_sum/nb_batch_train, loss_ner=total_train_loss_ner/nb_batch_train, accuracy_sum=total_train_acc_sum/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_sum = 0\n",
    "  total_val_loss_ner = 0\n",
    "  total_val_acc_sum = 0\n",
    "  total_val_acc_ner = 0\n",
    "  total_r1 = 0\n",
    "  total_r2 = 0\n",
    "  total_rl = 0\n",
    "\n",
    "  del loss\n",
    "  del loss_sum\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_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",
    "    doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "    summaries = val_set[\"summaries\"].iloc[i]\n",
    "\n",
    "    indices = torch.argsort(y_sum_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for j in range(min(len(doc), y_sum_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",
    "    scores = scorer.score(summaries, txt)\n",
    "    total_r1 += scores[\"rouge1\"].recall\n",
    "    total_r2 += scores[\"rouge2\"].recall\n",
    "    total_rl += scores[\"rougeL\"].recall\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_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 summary = {:.3f}, val loss ner = {:.3f}, val accuracy summary = {:.3f}, val accuracy ner = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_loss_sum / nb_batch_val, total_val_loss_ner / nb_batch_val, total_val_acc_sum / nb_batch_val, total_val_acc_ner / 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",
    "  del loss\n",
    "  del loss_sum\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_sum.append(total_train_acc_sum / nb_batch_train)\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_sum.append(total_val_acc_sum / 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_sum\"]  = arr_train_acc_sum\n",
    "training_metrics[\"train_acc_ner\"]  = arr_train_acc_ner\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_acc_sum\"]    = arr_val_acc_sum\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": [
    {
     "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_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": [
       "22"
      ]
     },
     "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, 29.19batch/s, accuracy_ner=0.914, accuracy_sum=0.668, loss=0.502, loss_ner=0.366, loss_sum=0.638, rouge1=0.26, rouge2=0.0642, rougeL=0.158]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "arr_loss_sum = []\n",
    "arr_loss_ner = []\n",
    "accuracy_sum = []\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_sum_coef * loss_sum + loss_ner_coef * loss_ner\n",
    "\n",
    "    arr_loss.append(loss.item())\n",
    "    arr_loss_sum.append(loss_sum.item())\n",
    "    arr_loss_ner.append(loss_ner.item())\n",
    "\n",
    "    doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "    summaries = test_set[\"summaries\"].iloc[idx]\n",
    "\n",
    "    probs = np.array(y_sum_pred.tolist()) # compute_probs(y_pred)\n",
    "    probs_tensor = y_sum_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_sum_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for i in range(min(len(doc), y_sum_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\"].recall)\n",
    "    arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "    arr_rougeL.append(scores[\"rougeL\"].recall)\n",
    "\n",
    "    accuracy_sum.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets_sum.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",
    "    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_sum=np.mean(arr_loss_sum), loss_ner=np.mean(arr_loss_ner), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL), accuracy_sum=np.mean(accuracy_sum), 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_sum\"] = np.mean(accuracy_sum)\n",
    "test_metrics[\"accuracy_ner\"] = np.mean(accuracy_ner)\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",
   "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, 63.82batch/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, 59.94batch/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
}