06-train_HeterSUMGraph_NYT50_TG_GATv2Conv.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train HeterSUMGraph_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=4)\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 4\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 = \"06-train_HeterSUMGraph_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": [
    "# 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": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HeterSUMGraph(torch.nn.Module):\n",
    "  def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 300, num_iter=3):\n",
    "    super(HeterSUMGraph, self).__init__()\n",
    "    self.device = device\n",
    "    self.num_iter = num_iter\n",
    "\n",
    "    self.word_emb = nn.Embedding(vocab_size+2, dim_word_embed, padding_idx=0)\n",
    "\n",
    "    # Load word embedding if specified\n",
    "    if word_embed is not None:\n",
    "      self.word_embedding = torch.nn.Embedding.from_pretrained(torch.from_numpy(word_embed).float())\n",
    "\n",
    "    self.word_emb.weight.requires_grad = False\n",
    "\n",
    "    # edge_attr embed\n",
    "    self.edge_attr_embed = nn.Embedding(101, 50)\n",
    "\n",
    "    # sent CNN\n",
    "    dim_out_cnn = 64\n",
    "    self.convs = nn.Sequential(\n",
    "                            nn.Conv1d(in_channels=300,out_channels=100,kernel_size=3,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=100,kernel_size=4,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=dim_out_cnn,kernel_size=5,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=dim_out_cnn),\n",
    "                            nn.ReLU(inplace=True))\n",
    "\n",
    "    # sent LSTM\n",
    "    dim_out_lstm = 32\n",
    "    self.sent_LSTM = nn.LSTM(input_size=300, hidden_size=dim_out_lstm, batch_first=True, bidirectional=True)\n",
    "\n",
    "    # sent to word GAT\n",
    "    # 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",
    "\n",
    "  def max_pool1d(self, x, seq_lens):\n",
    "    out = []\n",
    "    for index,t in enumerate(x):\n",
    "      if seq_lens[index] == 0:\n",
    "        t = t[:1]\n",
    "      else:\n",
    "        t = t[:seq_lens[index],:]\n",
    "      t = torch.t(t).unsqueeze(0)\n",
    "      out.append(torch.avg_pool1d(t, t.size(2)))\n",
    "\n",
    "    out = torch.cat(out).squeeze(2)\n",
    "    return out\n",
    "\n",
    "  def forward(self, data):# In the real implémentation remove nb_sent\n",
    "    # edge attr embeddings\n",
    "    edge_attr = torch.floor(data.edge_attr * 100).int()\n",
    "    edge_attr = self.edge_attr_embed(edge_attr)\n",
    "\n",
    "    # features\n",
    "    Xw = data.x[0]\n",
    "    Xs = data.x[1]\n",
    "    sent_lens = torch.sum(torch.sign(Xs),dim=1).data\n",
    "    \n",
    "    # embeddings\n",
    "    Xw = self.word_emb(Xw)\n",
    "    Xs = self.word_emb(Xs)\n",
    "\n",
    "    # CNN\n",
    "    XsCNN = self.convs(Xs.permute(0,2,1))\n",
    "    XsCNN = torch.max_pool1d(XsCNN, XsCNN.size(2)).squeeze(2)\n",
    "\n",
    "    # LSTM\n",
    "    # TO DO: ask \n",
    "    XsLSTM, _ = self.sent_LSTM(Xs)\n",
    "    XsLSTM = self.max_pool1d(XsLSTM, sent_lens)\n",
    "    Xs = torch.cat((XsCNN, XsLSTM), dim=1)\n",
    "\n",
    "    Hw = Xw\n",
    "    Hs = Xs\n",
    "\n",
    "    edge_index_w_i = data.edge_index[1][data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_s_j = data.edge_index[0][data.edge_index[1] < len(data.x[0])] - Hw.shape[0]\n",
    "    edge_attr_w = edge_attr[data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_w = torch.stack([edge_index_s_j, edge_index_w_i])\n",
    "\n",
    "    edge_index_s_i = data.edge_index[1][data.edge_index[1] >= len(data.x[0])] - Hw.shape[0]\n",
    "    edge_index_w_j = data.edge_index[0][data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_attr_s = edge_attr[data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_index_s = torch.stack([edge_index_w_j, edge_index_s_i])\n",
    "\n",
    "    Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "    Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    for i in range(self.num_iter):\n",
    "      if i != 0: # H^1w = H^0w = Xw\n",
    "        Hw = self.s2wGAT(x=[Hs, Hw], edge_index=edge_index_w, edge_attr=edge_attr_w) + torch.cat([Hw] * 8, dim=1)\n",
    "        Hw = self.ffns2w(Hw)\n",
    "        Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "\n",
    "      Hs = self.w2sGAT(x=[Hw, Hs], edge_index=edge_index_s, edge_attr=edge_attr_s) + torch.cat([Hs] * 8, dim=1)\n",
    "      Hs = self.ffnw2s(Hs)\n",
    "      Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    res = self.wh(Hs)\n",
    "\n",
    "    res = torch.sigmoid(res).squeeze(-1)\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": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HeterSUMGraph(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300).to(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "  os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/25 [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%|██████████| 25/25 [00:02<00:00,  8.67batch/s, accuracy=0.776, loss=0.552, mae=0.346]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.526, val mae = 0.338, val accuracy = 0.734, r1 = 0.345, r2 = 0.123, rL = 0.213\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:02<00:00, 11.19batch/s, accuracy=0.773, loss=0.529, mae=0.335]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.527, val mae = 0.333, val accuracy = 0.736, r1 = 0.347, r2 = 0.122, rL = 0.213\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:02<00:00, 12.41batch/s, accuracy=0.766, loss=0.535, mae=0.347]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.535, val mae = 0.314, val accuracy = 0.739, r1 = 0.351, r2 = 0.131, rL = 0.223\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:03<00:00,  7.61batch/s, accuracy=0.771, loss=0.528, mae=0.338]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.526, val mae = 0.341, val accuracy = 0.733, r1 = 0.344, r2 = 0.122, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:02<00:00,  8.42batch/s, accuracy=0.771, loss=0.524, mae=0.339]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.530, val mae = 0.323, val accuracy = 0.734, r1 = 0.343, r2 = 0.122, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:02<00:00, 11.77batch/s, accuracy=0.772, loss=0.528, mae=0.337]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.527, val mae = 0.334, val accuracy = 0.729, r1 = 0.348, r2 = 0.125, rL = 0.217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:01<00:00, 13.93batch/s, accuracy=0.77, loss=0.532, mae=0.339] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.532, val mae = 0.319, val accuracy = 0.729, r1 = 0.344, r2 = 0.123, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:02<00:00, 11.00batch/s, accuracy=0.773, loss=0.523, mae=0.341]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.526, val mae = 0.344, val accuracy = 0.729, r1 = 0.346, r2 = 0.125, rL = 0.218\n",
      "Training duration = 37.20764374732971\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)\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)\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": 24,
   "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": 25,
   "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": 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 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": 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 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": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HeterSUMGraph(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 29,
     "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": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test[\"doc_splitted\"] = split_all_docs(df_test[\"docs\"], False)\n",
    "test_set = df_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:02<00:00, 43.11batch/s, accuracy=0.748, loss=0.521, rouge1=0.331, rouge2=0.116, rougeL=0.209]\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",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "    y_pred = model(data)\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": 33,
   "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": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:01<00:00, 99.47batch/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": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:01<00:00, 92.08batch/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": 36,
   "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"
     ]
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "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
}