12-train_HSGRNNNER_GATv2.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"
   ]
  },
  {
   "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 = \"12-train_HSGRNNNER_GATv2\"\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 '{'edge_index', 'x', 'undirected', '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 GATv2Conv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SENT_RNN(nn.Module):\n",
    "  def __init__(self, device, dim_emb=128):\n",
    "    super(SENT_RNN, self).__init__()\n",
    "    self.device = device\n",
    "    self.dim_emb = dim_emb\n",
    "    self.sent_GRU = nn.GRU(input_size = dim_emb, hidden_size=dim_emb, batch_first = True, bidirectional = True)\n",
    "\n",
    "    # 10: relative position range size, with segment size = 10\n",
    "    self.rel_pos_emb = nn.Embedding(11, 100)\n",
    "    self.abs_pos_emb = nn.Embedding(100, 100)\n",
    "\n",
    "    self.Wdoc = nn.Linear(2*dim_emb,2*dim_emb,bias=True)\n",
    "\n",
    "    self.Wcontent = nn.Linear(2*dim_emb,1,bias=False)\n",
    "    self.Wsalience = nn.Bilinear(2*dim_emb,2*dim_emb,1,bias=False)\n",
    "    self.Wnovelty = nn.Bilinear(2*dim_emb,2*dim_emb,1,bias=False)\n",
    "    self.Wabs_pos = nn.Linear(100,1,bias=False)\n",
    "    self.Wrel_pos = nn.Linear(100,1,bias=False)\n",
    "    self.bias = nn.Parameter(torch.empty(1).uniform_(-0.1, 0.1))\n",
    "\n",
    "  def avg_pool1d(self,x,seq_lens):\n",
    "    out = []\n",
    "    for index,t in enumerate(x):\n",
    "      if seq_lens[index] == 0:\n",
    "        t = t[:1]\n",
    "      else:\n",
    "        t = t[:seq_lens[index],:]\n",
    "      t = torch.t(t).unsqueeze(0)\n",
    "      out.append(torch.avg_pool1d(t,t.size(2)))\n",
    "\n",
    "    out = torch.cat(out).squeeze(2)\n",
    "    return out\n",
    "\n",
    "  def pad_doc(self, x, doc_lens):\n",
    "    pad_dim = x.size(1)\n",
    "    max_doc_len = max(doc_lens)\n",
    "    result = []\n",
    "    start = 0\n",
    "    for doc_len in doc_lens:\n",
    "      stop = start + doc_len\n",
    "      doc = x[start:stop]\n",
    "      start = stop\n",
    "      if doc_len == max_doc_len:\n",
    "        result.append(doc.unsqueeze(0))\n",
    "      else:\n",
    "        pad = torch.zeros(max_doc_len-doc_len, pad_dim)\n",
    "        if self.device is not None:\n",
    "          pad = pad.to(self.device)\n",
    "        result.append(torch.cat([doc,pad]).unsqueeze(0))\n",
    "    result = torch.cat(result,dim=0)\n",
    "    return result\n",
    "\n",
    "  def forward(self, sents, doc_lens):\n",
    "    probs = []\n",
    "\n",
    "    max_doc_lens = max(doc_lens)\n",
    "\n",
    "    arr_x = self.pad_doc(sents, doc_lens)\n",
    "    arr_x = self.sent_GRU(arr_x)[0]\n",
    "    sents_all_docs = arr_x.reshape(len(doc_lens) * max_doc_lens, 2*self.dim_emb) # flat docs\n",
    "\n",
    "    docs = self.avg_pool1d(arr_x, doc_lens)\n",
    "    docs = torch.tanh(self.Wdoc(docs))\n",
    "    docs_for_each_sent = docs.repeat_interleave(max_doc_lens, dim=0) # repeat doc n times\n",
    "    \n",
    "    contents = self.Wcontent(sents_all_docs)\n",
    "    saliences = self.Wsalience(sents_all_docs, docs_for_each_sent)\n",
    "\n",
    "    # Compute position embedding\n",
    "    abs_poses = torch.tensor([[position] for position in range(max_doc_lens)], dtype=torch.long)\n",
    "    abs_poses = abs_poses.to(self.device)\n",
    "    abs_poses = self.abs_pos_emb(abs_poses).squeeze(1)\n",
    "    aps = self.Wabs_pos(abs_poses)\n",
    "\n",
    "    # Compute relative position embedding\n",
    "    rel_poses = torch.tensor([[int(round(position / 10))] for position in range(max_doc_lens)], dtype=torch.long)\n",
    "    rel_poses = rel_poses.to(self.device)\n",
    "    rel_poses = self.rel_pos_emb(rel_poses).squeeze(1)\n",
    "    rps = self.Wrel_pos(rel_poses)\n",
    "\n",
    "    # doc_len (number) s\n",
    "    ses = torch.zeros(len(doc_lens), 2*self.dim_emb)\n",
    "    ses = ses.to(self.device)\n",
    "\n",
    "    # for each document, compute probabilities\n",
    "    for position in range(max_doc_lens):\n",
    "      contents_for_position = contents[position::max_doc_lens]\n",
    "      saliences_for_position = saliences[position::max_doc_lens]\n",
    "      novelties_for_position = -1 * self.Wnovelty(sents_all_docs[position::max_doc_lens], torch.tanh(ses))\n",
    "      prob = contents_for_position + saliences_for_position + novelties_for_position + aps[position] + rps[position] + self.bias\n",
    "      prob = torch.sigmoid(prob)\n",
    "      probs.append(prob)\n",
    "\n",
    "      ses = ses + torch.mul(sents_all_docs[position::max_doc_lens], prob)\n",
    "    probs = torch.cat(probs).squeeze()\n",
    "    if len(probs.shape) == 0:\n",
    "      probs = probs.unsqueeze(0)\n",
    "    probs_filtered = []\n",
    "    for idx, doc_len in enumerate(doc_lens):\n",
    "      prob = probs[idx::len(doc_lens)]\n",
    "      prob = prob[:doc_len]\n",
    "      probs_filtered.append(prob)\n",
    "    probs_filtered = torch.cat(probs_filtered).squeeze()\n",
    "    if len(probs_filtered.shape) == 0:\n",
    "      probs_filtered = probs_filtered.unsqueeze(0)\n",
    "    #probs = probs.to(self.device)\n",
    "    return probs_filtered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HSGRNN(torch.nn.Module):\n",
    "  def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 300, num_iter=3):\n",
    "    super(HSGRNN, 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",
    "    # TODO out_channels = 64\n",
    "    self.s2wGAT = GATv2Conv(in_channels=[128, 300], out_channels=300, heads=8, edge_dim=50, fill_value=0, share_weights=False)\n",
    "\n",
    "    # word to sen GAT\n",
    "    self.w2sGAT = GATv2Conv(in_channels=[300, 128], out_channels=128, heads=8, edge_dim=50, fill_value=0, share_weights=False)\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.sent_rnn = SENT_RNN(device)\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, doc_lens):# 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.sent_rnn(Hs, doc_lens)\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": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HSGRNN(device=device, vocab_size=vocab_size, word_embed=embmgr.getEmbeddings(), dim_word_embed=300).to(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "  os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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": 27,
   "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:05<00:00,  4.30batch/s, accuracy_ner=0.885, accuracy_sum=0.769, loss=0.861, loss_ner=0.369, loss_sum=1.35]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.429, val loss summary = 0.510, val loss ner = 0.347, val accuracy summary = 0.772, val accuracy ner = 0.914, r1 = 0.325, r2 = 0.108, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:05<00:00,  4.73batch/s, accuracy_ner=0.921, accuracy_sum=0.78, loss=0.677, loss_ner=0.286, loss_sum=1.07] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.665, val loss summary = 1.037, val loss ner = 0.293, val accuracy summary = 0.776, val accuracy ner = 0.914, r1 = 0.325, r2 = 0.108, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:05<00:00,  4.75batch/s, accuracy_ner=0.92, accuracy_sum=0.792, loss=0.595, loss_ner=0.29, loss_sum=0.899]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.394, val loss summary = 0.490, val loss ner = 0.299, val accuracy summary = 0.776, val accuracy ner = 0.914, r1 = 0.326, r2 = 0.108, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:06<00:00,  3.92batch/s, accuracy_ner=0.924, accuracy_sum=0.791, loss=0.411, loss_ner=0.282, loss_sum=0.541]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.410, val loss summary = 0.529, val loss ner = 0.292, val accuracy summary = 0.776, val accuracy ner = 0.914, r1 = 0.326, r2 = 0.108, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:06<00:00,  3.79batch/s, accuracy_ner=0.921, accuracy_sum=0.786, loss=0.557, loss_ner=0.278, loss_sum=0.836]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.395, val loss summary = 0.498, val loss ner = 0.292, val accuracy summary = 0.761, val accuracy ner = 0.914, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:06<00:00,  3.73batch/s, accuracy_ner=0.916, accuracy_sum=0.781, loss=0.469, loss_ner=0.286, loss_sum=0.652]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.442, val loss summary = 0.612, val loss ner = 0.271, val accuracy summary = 0.776, val accuracy ner = 0.921, r1 = 0.325, r2 = 0.108, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:06<00:00,  3.60batch/s, accuracy_ner=0.922, accuracy_sum=0.776, loss=0.401, loss_ner=0.262, loss_sum=0.54] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.378, val loss summary = 0.498, val loss ner = 0.258, val accuracy summary = 0.776, val accuracy ner = 0.924, r1 = 0.326, r2 = 0.108, rL = 0.215\n",
      "Training duration = 80.38847470283508\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, doc_lens)\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, doc_lens)\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": 28,
   "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": 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 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": 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_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": 31,
   "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": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HSGRNN(device=device, vocab_size=vocab_size, word_embed=embmgr.getEmbeddings(), dim_word_embed=300).to(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 33,
     "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": 34,
   "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": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:05<00:00, 17.50batch/s, accuracy_ner=0.915, accuracy_sum=0.791, loss=0.401, loss_ner=0.297, loss_sum=0.504, rouge1=0.324, rouge2=0.0926, rougeL=0.2] \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",
    "    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, doc_lens)\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": 37,
   "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": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:01<00:00, 72.50batch/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": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:01<00:00, 63.14batch/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": 40,
   "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
}