08-train_HSGRNN_NYT50_TG_GATv2Conv.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train HSGRNN_NYT50"
   ]
  },
  {
   "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.GloveMgr import GloveMgr\n",
    "from utils.DataLoader import DataLoader\n",
    "from utils.MultiProcessusDataLoader import MultiProcessusDataLoader\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=2)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "\n",
    "args = None\n",
    "\n",
    "if is_notebook():\n",
    "    args = parser.parse_args(\"\")\n",
    "else:\n",
    "    args = parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 0\n",
      "epochs 100\n",
      "batch_size 2\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"glove.6B.300\"\n",
    "\n",
    "# hyper-parameters\n",
    "vocab_size = 150000\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 = \"08-train_HSGRNN_NYT50_TG_GATv2Conv\"\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: 1\n",
      "GPU 0: NVIDIA GeForce RTX 3060\n"
     ]
    }
   ],
   "source": [
    "# Check if a GPU is available\n",
    "if torch.cuda.is_available():\n",
    "    # Display the number of available GPUs\n",
    "    print(f\"Number of available GPUs: {torch.cuda.device_count()}\")\n",
    "    # Display the name of each GPU\n",
    "    for i in range(torch.cuda.device_count()):\n",
    "        print(f\"GPU {i}: {torch.cuda.get_device_name(i)}\")\n",
    "else:\n",
    "    print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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",
    "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": [
    "df_test = pd.read_json(\"./data/nyt_corpus_LDC2008T19_50/test.json\")\n",
    "df_val = pd.read_json(\"./data/nyt_corpus_LDC2008T19_50/val.json\")\n",
    "df_train = pd.read_json(\"./data/nyt_corpus_LDC2008T19_50/train.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "glovemgr = GloveMgr(\"./data/glove.6B/glove.6B.300d.txt\", vocab_size=vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_sent = pd.read_json(\"data/nyt50_sent_tfidf.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_dataset = json.load(open(\"./data/nyt50_dataset_tfidf.json\"))\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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = MultiProcessusDataLoader(buffer_size=30, dataset=df_train, batch_size=batch_size, shuffle=True, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"docs\", labels_column_name=\"labels\", is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_dataset = create_graph_dataset(df=df_val, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"docs\", labels_column_name=\"labels\", is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=50)\n",
    "val_loader =  DataLoader(val_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dataset = create_graph_dataset(df=df_test, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"docs\", labels_column_name=\"labels\", is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=50)\n",
    "test_loader =  DataLoader(test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "from torch_geometric.nn import GATv2Conv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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": 17,
   "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": 18,
   "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": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HSGRNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300).to(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "  os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[\"docs\"])\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/50 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/50 [00:00<?, ?batch/s]/home/rsaid/anaconda3/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:06<00:00,  8.21batch/s, accuracy=0.803, loss=38.3, mae=0.57] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 1.803, val mae = 0.568, val accuracy = 0.779, r1 = 0.440, r2 = 0.229, rL = 0.316\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 50/50 [00:04<00:00, 10.38batch/s, accuracy=0.806, loss=0.679, mae=0.278]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 4.190, val mae = 0.772, val accuracy = 0.779, r1 = 0.432, r2 = 0.220, rL = 0.306\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 50/50 [00:05<00:00,  8.93batch/s, accuracy=0.807, loss=0.708, mae=0.286]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.361, val mae = 0.223, val accuracy = 0.866, r1 = 0.518, r2 = 0.315, rL = 0.398\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 50/50 [00:05<00:00,  8.85batch/s, accuracy=0.815, loss=0.442, mae=0.239]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.359, val mae = 0.208, val accuracy = 0.867, r1 = 0.521, r2 = 0.317, rL = 0.400\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 50/50 [00:04<00:00, 10.14batch/s, accuracy=0.815, loss=0.361, mae=0.197]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.384, val mae = 0.221, val accuracy = 0.850, r1 = 0.523, r2 = 0.318, rL = 0.402\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 50/50 [00:04<00:00, 10.16batch/s, accuracy=0.819, loss=0.295, mae=0.14] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.963, val mae = 0.364, val accuracy = 0.802, r1 = 0.448, r2 = 0.235, rL = 0.323\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 50/50 [00:05<00:00,  9.04batch/s, accuracy=0.819, loss=0.216, mae=0.107]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.404, val mae = 0.210, val accuracy = 0.862, r1 = 0.518, r2 = 0.312, rL = 0.396\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 50/50 [00:04<00:00, 10.62batch/s, accuracy=0.826, loss=0.151, mae=0.0637]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.735, val mae = 0.200, val accuracy = 0.831, r1 = 0.495, r2 = 0.287, rL = 0.374\n",
      "Training duration = 65.99581980705261\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "arr_train_loss = []\n",
    "arr_train_mae = []\n",
    "arr_train_acc = []\n",
    "arr_val_loss = []\n",
    "arr_val_mae = []\n",
    "arr_val_acc = []\n",
    "\n",
    "t1 = time()\n",
    "\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_mae = 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(), 2.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_mae += mae_fn(probs_tensor, targets).item()\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, mae=total_train_mae/nb_batch_train, accuracy=total_train_acc/nb_batch_train)\n",
    "\n",
    "  # Save model\n",
    "  model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "  # Eval\n",
    "  model.eval()\n",
    "  nb_batch_val = 0\n",
    "  total_val_loss = 0\n",
    "  total_val_mae = 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",
    "    #assert len(txt) - len(summaries) <= 20\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_mae += mae_fn(probs_tensor, targets).item()\n",
    "    total_val_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "  if len(arr_val_loss) >= early_stopping+1:\n",
    "    if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "      print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "      break\n",
    "\n",
    "  print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "\n",
    "  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_mae.append(total_train_mae / nb_batch_train)\n",
    "  arr_train_acc.append(total_train_acc / nb_batch_train)\n",
    "\n",
    "  arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "  arr_val_mae.append(total_val_mae / nb_batch_val)\n",
    "  arr_val_acc.append(total_val_acc / nb_batch_val)\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_mae\"]  = arr_train_mae\n",
    "training_metrics[\"train_acc\"]  = arr_train_acc\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_mae\"]    = arr_val_mae\n",
    "training_metrics[\"val_acc\"]    = arr_val_acc\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "  json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw mae\n",
    "if is_graphic:\n",
    "  plt.plot(list(range(1, len(arr_train_mae) + 1)), arr_train_mae, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_mae) + 1)), arr_val_mae, label=\"val\")\n",
    "\n",
    "  plt.title(\"MAE\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"mae\")\n",
    "  plt.legend(loc=\"upper right\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw 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": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HSGRNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 30,
     "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": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test[\"doc_splitted\"] = split_all_docs(df_test[\"docs\"], False)\n",
    "test_set = df_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:03<00:00, 31.95batch/s, accuracy=0.863, loss=0.348, rouge1=0.45, rouge2=0.245, rougeL=0.337]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\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 = 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",
    "    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",
    "    mae.append(mae_fn(probs_tensor, targets).item())\n",
    "\n",
    "    accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "    #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "    tepoch.set_postfix(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": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\n",
    "test_metrics[\"mae\"]      = np.mean(mae)\n",
    "test_metrics[\"rouge1\"]   = np.mean(arr_rouge1)\n",
    "test_metrics[\"rouge2\"]   = np.mean(arr_rouge2)\n",
    "test_metrics[\"rougeL\"]   = np.mean(arr_rougeL)\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/test_metrics.json\", 'w') as fp:\n",
    "  json.dump(test_metrics, fp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:01<00:00, 96.53batch/s, rouge1=0.393, rouge2=0.217, rougeL=0.299]\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",
    "        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": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:01<00:00, 90.57batch/s, rouge1=0.453, rouge2=0.25, rougeL=0.338]\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": 37,
   "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/rsaid/.local/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3406: 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": "6d7f428a150b92572ac46240b6d7ae68586908362b054f21341550673eeb77dc"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}