11-train_HSGRNN_GATv2.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train HeterSUMGraph"
   ]
  },
  {
   "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=3)\n",
    "parser.add_argument('-batch_size',type=int,default=2)\n",
    "parser.add_argument('-epochs',type=int,default=10)\n",
    "parser.add_argument('-dataset',type=str,default=\"data/wiki_geo_ratio_sc_0.5\")\n",
    "parser.add_argument('-dataset_tfidf',type=str,default=\"./data/wiki_geo_ratio_sc_0.5_dataset_tfidf.json\")\n",
    "parser.add_argument('-sent_tfidf',type=str,default=\"data/wiki_geo_ratio_sc_0.5_sent_tfidf.json\")\n",
    "parser.add_argument('-doc_column_name',type=str,default=\"flat_contents\")\n",
    "parser.add_argument('-labels_column_name',type=str,default=\"labels_sentences\")\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: 3\n",
      "epochs 100\n",
      "batch_size 2\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"cc.fr.300.vec\"\n",
    "\n",
    "# hyper-parameters\n",
    "vocab_size = 50000\n",
    "batch_size = args.batch_size\n",
    "epochs = args.epochs\n",
    "learning_rate = 5e-4\n",
    "early_stopping = 3\n",
    "word_blacklist_proportion = 0.1\n",
    "model_name = \"11-train_HSGRNN_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",
    "\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=3)"
      ]
     },
     "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_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_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_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)\n",
    "val_loader =  DataLoader(val_dataset, batch_size=1, shuffle=False)\n",
    "test_loader =  DataLoader(test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "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: 35.23\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: 14.165876777251185\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.12510346157363167\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', 'edge_attr', 'undirected', 'x'}'. 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.wh = nn.Linear(128, 1)\n",
    "    self.sent_rnn = SENT_RNN(device)\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",
    "    res = self.sent_rnn(Hs, doc_lens)\n",
    "\n",
    "    return res\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/50 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/raoufdine/.local/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 50/50 [00:03<00:00, 13.50batch/s, accuracy=0.578, loss=1.01]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.998, val accuracy = 0.783, r1 = 0.235, r2 = 0.064, rL = 0.148\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 50/50 [00:03<00:00, 14.61batch/s, accuracy=0.629, loss=1.09]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.736, val accuracy = 0.781, r1 = 0.235, r2 = 0.065, rL = 0.149\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 50/50 [00:03<00:00, 15.65batch/s, accuracy=0.577, loss=0.73] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.463, val accuracy = 0.768, r1 = 0.233, r2 = 0.065, rL = 0.148\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 50/50 [00:03<00:00, 15.39batch/s, accuracy=0.597, loss=0.558]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.483, val accuracy = 0.783, r1 = 0.235, r2 = 0.065, rL = 0.150\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 50/50 [00:03<00:00, 14.79batch/s, accuracy=0.613, loss=0.643]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.256, val accuracy = 0.798, r1 = 0.235, r2 = 0.066, rL = 0.149\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 50/50 [00:03<00:00, 14.26batch/s, accuracy=0.572, loss=3.09] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 14.170, val accuracy = 0.783, r1 = 0.228, r2 = 0.064, rL = 0.146\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 50/50 [00:03<00:00, 14.49batch/s, accuracy=0.509, loss=11.5]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 1.182, val accuracy = 0.739, r1 = 0.230, r2 = 0.064, rL = 0.145\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 50/50 [00:03<00:00, 14.45batch/s, accuracy=0.544, loss=2.05] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 1.037, val accuracy = 0.712, r1 = 0.219, r2 = 0.060, rL = 0.139\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 50/50 [00:02<00:00, 17.54batch/s, accuracy=0.626, loss=0.568]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.471, val accuracy = 0.783, r1 = 0.234, r2 = 0.063, rL = 0.149\n",
      "Training duration = 51.94163417816162\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "arr_train_loss = []\n",
    "arr_train_acc = []\n",
    "arr_val_loss = []\n",
    "arr_val_acc = []\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_acc = 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 = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "      y_pred = model(data, doc_lens)\n",
    "\n",
    "      loss = criterion(y_pred, targets)\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",
    "\n",
    "      probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "      probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "      total_train_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "      tepoch.set_postfix(loss=total_train_loss/nb_batch_train, accuracy=total_train_acc/nb_batch_train)\n",
    "\n",
    "  # Save model\n",
    "  model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "  # Eval\n",
    "  model.eval()\n",
    "  nb_batch_val = 0\n",
    "  total_val_loss = 0\n",
    "  total_val_acc = 0\n",
    "  total_r1 = 0\n",
    "  total_r2 = 0\n",
    "  total_rl = 0\n",
    "\n",
    "  del loss\n",
    "  del y_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 = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "    y_pred = model(data, doc_lens)\n",
    "\n",
    "    loss = criterion(y_pred, targets)\n",
    "    nb_batch_val += 1\n",
    "    total_val_loss += loss.item()\n",
    "\n",
    "    doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "    summaries = val_set[\"summaries\"].iloc[i]\n",
    "\n",
    "    indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for j in range(min(len(doc), y_pred.shape[0])):\n",
    "      txt = txt + \". \" + doc[indices[j]]\n",
    "      y_pred_thresh.append(indices[j])\n",
    "      if len(txt) >= len(summaries):\n",
    "        break\n",
    "\n",
    "    y_pred_thresh.sort()\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for j in y_pred_thresh:\n",
    "      txt = txt + \". \" + doc[j]\n",
    "\n",
    "    n = min(len(txt), len(summaries))\n",
    "\n",
    "    while n < len(txt) and txt[n].isalnum():\n",
    "      n += 1\n",
    "\n",
    "    txt = txt[:n]\n",
    "\n",
    "    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_pred.tolist() # compute_probs(y_pred)\n",
    "    probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "    total_val_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "  print(\"Epoch {} : val loss = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "\n",
    "  if len(arr_val_loss) >= early_stopping+1:\n",
    "    if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "      break\n",
    "\n",
    "  del loss\n",
    "  del y_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "  arr_train_acc.append(total_train_acc / nb_batch_train)\n",
    "\n",
    "  arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "  arr_val_acc.append(total_val_acc / 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\"]  = arr_train_acc\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_acc\"]    = arr_val_acc\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "  json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 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) + 1)), arr_train_acc, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_acc) + 1)), arr_val_acc, label=\"val\")\n",
    "\n",
    "  plt.title(\"Accuracy\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"accuracy\")\n",
    "  plt.legend(loc=\"upper left\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "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:02<00:00, 41.22batch/s, accuracy=0.774, loss=0.461, nb_nvalid_doc=0, rouge1=0.248, rouge2=0.0756, rougeL=0.159]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "\n",
    "counter = 0\n",
    "nb_invalid_doc = 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 = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "    y_pred = model(data, doc_lens)\n",
    "\n",
    "    loss = criterion(y_pred, targets)\n",
    "\n",
    "    arr_loss.append(loss.item())\n",
    "\n",
    "    doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "    summaries = test_set[\"summaries\"].iloc[idx]\n",
    "\n",
    "    probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "    probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "    #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "    #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "    indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    if len(doc) < y_pred.shape[0]:\n",
    "      nb_invalid_doc += 1\n",
    "    else:\n",
    "      for i in range(min(len(doc), y_pred.shape[0])):\n",
    "        txt = txt + \". \" + doc[indices[i]]\n",
    "        y_pred_thresh.append(indices[i])\n",
    "        if len(txt) >= len(summaries):\n",
    "          break\n",
    "\n",
    "      y_pred_thresh.sort()\n",
    "\n",
    "      txt = \"\"\n",
    "\n",
    "      for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "        txt = txt + \". \" + doc[i]\n",
    "\n",
    "      n = min(len(txt), len(summaries))\n",
    "\n",
    "      while n < len(txt) and txt[n].isalnum():\n",
    "        n += 1\n",
    "\n",
    "      txt = txt[:n]\n",
    "\n",
    "      # assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "      scores = scorer.score(summaries, txt)\n",
    "      arr_rouge1.append(scores[\"rouge1\"].recall)\n",
    "      arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "      arr_rougeL.append(scores[\"rougeL\"].recall)\n",
    "\n",
    "      accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "      #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "    tepoch.set_postfix(nb_nvalid_doc=nb_invalid_doc, loss=np.mean(arr_loss), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL), accuracy=np.mean(accuracy))\n",
    "    idx += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\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:00<00:00, 129.62batch/s, rouge1=0.22, rouge2=0.0693, rougeL=0.149]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\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:00<00:00, 103.29batch/s, rouge1=0.246, rouge2=0.0751, rougeL=0.158]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\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
}