13-train_HSGRNNOnlyNER_GATv2.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train HeterSUMGraph Only NER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import argparse\n",
    "from time import time\n",
    "import torch\n",
    "import numpy as np\n",
    "import random\n",
    "from sklearn.utils import shuffle\n",
    "import json\n",
    "import os\n",
    "import networkx as nx\n",
    "import torch_geometric\n",
    "from statistics import mean\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils.create_graph_dataset import create_graph_dataset\n",
    "from utils.EmbMgr import EmbMgr\n",
    "from utils.DataLoader import DataLoader\n",
    "from utils.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils.split_all_docs import split_all_docs\n",
    "from utils.threshold_probs import threshold_probs_by_nb, threshold_probs_by_prop\n",
    "from utils.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_notebook() -> bool:\n",
    "    try:\n",
    "        shell = get_ipython().__class__.__name__\n",
    "        if shell == 'ZMQInteractiveShell':\n",
    "            return True   # Jupyter notebook or qtconsole\n",
    "        elif shell == 'TerminalInteractiveShell':\n",
    "            return False  # Terminal running IPython\n",
    "        else:\n",
    "            return False  # Other type (?)\n",
    "    except NameError:\n",
    "        return False      # Probably standard Python interpreter"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse args if script mode\n",
    "parser = argparse.ArgumentParser(description='extractive summary')\n",
    "\n",
    "parser.add_argument('-is_graphic',type=int,default=1,choices=[0,1])\n",
    "parser.add_argument('-gpu_num',type=int,default=0)\n",
    "parser.add_argument('-batch_size',type=int,default=2)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "parser.add_argument('-dataset',type=str,default=\"data/wiki_geo_ratio_sc_0.5\")\n",
    "parser.add_argument('-dataset_tfidf',type=str,default=\"./data/wiki_geo_ratio_sc_0.5_dataset_tfidf.json\")\n",
    "parser.add_argument('-sent_tfidf',type=str,default=\"data/wiki_geo_ratio_sc_0.5_sent_tfidf.json\")\n",
    "parser.add_argument('-doc_column_name',type=str,default=\"flat_contents\")\n",
    "parser.add_argument('-labels_sum_column_name',type=str,default=\"labels_sentences\")\n",
    "parser.add_argument('-labels_ner_column_name',type=str,default=\"labels_entities\")\n",
    "parser.add_argument(\"-word_emb\",type=str,default=\"./data/cc.fr.300.vec\")\n",
    "\n",
    "args = None\n",
    "\n",
    "if is_notebook():\n",
    "    args = parser.parse_args(\"\")\n",
    "else:\n",
    "    args = parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 0\n",
      "epochs 100\n",
      "batch_size 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 = \"13-train_HSGRNNOnlyNER_GATv2\"\n",
    "sub_folder_name = \"model_name__{}__time__{}__embed_name__{}__lr__{}__batch_size__{}__vocab_size__{}__cuda_num__{}__early_stopping__{}\".format(model_name, time(), embed_name, learning_rate, batch_size, vocab_size, cuda_num, early_stopping)\n",
    "checkpoints_folder = \"./checkpoints/\" + sub_folder_name\n",
    "average_number_of_sentences_per_document = 3\n",
    "loss_sum_coef = 0.5\n",
    "loss_ner_coef = 0.5\n",
    "\n",
    "# print\n",
    "print(\"parse:\")\n",
    "print(\"is_graphic:\", is_graphic)\n",
    "print(\"cuda_num:\", cuda_num)\n",
    "print(\"epochs\", epochs)\n",
    "print(\"batch_size\", batch_size)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyTorch initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(0)\n",
    "random.seed(0)\n",
    "np.random.seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of available GPUs: 6\n",
      "GPU 0: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 1: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 2: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 3: NVIDIA GeForce GTX 1080\n",
      "GPU 4: NVIDIA GeForce GTX 1080\n",
      "GPU 5: NVIDIA GeForce GTX 1080\n"
     ]
    }
   ],
   "source": [
    "# Check if a GPU is available\n",
    "if torch.cuda.is_available():\n",
    "  # Display the number of available GPUs\n",
    "  print(f\"Number of available GPUs: {torch.cuda.device_count()}\")\n",
    "  # Display the name of each GPU\n",
    "  for i in range(torch.cuda.device_count()):\n",
    "    print(f\"GPU {i}: {torch.cuda.get_device_name(i)}\")\n",
    "elif torch.backends.mps.is_available():\n",
    "  print(\"MPS available.\")\n",
    "else:\n",
    "  print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "elif torch.backends.mps.is_available():\n",
    "  dev = torch.device(\"mps\")\n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "embmgr = EmbMgr(args.word_emb, vocab_size=vocab_size, header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_sent = pd.read_json(args.sent_tfidf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_dataset = json.load(open(args.dataset_tfidf))\n",
    "tfidfs_dataset_sorted = sorted(tfidfs_dataset, key=tfidfs_dataset.get)\n",
    "word_blacklist = set(tfidfs_dataset_sorted[:int(word_blacklist_proportion*len(tfidfs_dataset_sorted))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(args.dataset + \"/test.json\")\n",
    "df_val = pd.read_json(args.dataset + \"/val.json\")\n",
    "df_train = pd.read_json(args.dataset + \"/train.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = create_graph_dataset(df=df_train, tfidfs_sent=tfidfs_sent, embmgr=embmgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=args.doc_column_name, labels_sum_column_name=args.labels_sum_column_name, labels_ner_column_name=args.labels_ner_column_name, is_sep_n=False, remove_stop_word = True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)\n",
    "val_dataset = create_graph_dataset(df=df_val, tfidfs_sent=tfidfs_sent, embmgr=embmgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=args.doc_column_name, labels_sum_column_name=args.labels_sum_column_name, labels_ner_column_name=args.labels_ner_column_name, is_sep_n=False, remove_stop_word = True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)\n",
    "test_dataset = create_graph_dataset(df=df_test, tfidfs_sent=tfidfs_sent, embmgr=embmgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=args.doc_column_name, labels_sum_column_name=args.labels_sum_column_name, labels_ner_column_name=args.labels_ner_column_name, is_sep_n=False, remove_stop_word = True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, ner=True)\n",
    "val_loader =  DataLoader(val_dataset, batch_size=1, shuffle=False, ner=True)\n",
    "test_loader =  DataLoader(test_dataset, batch_size=1, shuffle=False, ner=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average number of distinct word per doc: 309.29\n"
     ]
    }
   ],
   "source": [
    "# Average number of distinct word per doc\n",
    "print(\"Average number of distinct word per doc:\", mean([len(t[\"docs\"].x[0]) for t in train_dataset]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average sentence len: 15.202316412025628\n"
     ]
    }
   ],
   "source": [
    "def sents_len(doc):\n",
    "  return [torch.sum(torch.sign(s),dim=0).item() for s in doc]\n",
    "\n",
    "# Average sentence length\n",
    "lens = []\n",
    "for t in train_dataset:\n",
    "  lens = lens + sents_len(t[\"docs\"].x[1])\n",
    "\n",
    "print(\"Average sentence len:\", mean(lens))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average density: 0.016426792711350446\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/raoufdine/anaconda3/lib/python3.9/site-packages/torch_geometric/data/storage.py:303: UserWarning: Unable to accurately infer 'num_nodes' from the attribute set '{'undirected', 'edge_index', 'x', 'edge_attr'}'. Please explicitly set 'num_nodes' as an attribute of 'data' to suppress this warning\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# Average density\n",
    "def density(g):\n",
    "  nb_edges = g.num_edges / 2\n",
    "  nb_nodes = g.num_nodes\n",
    "  nb_poss_edges = nb_nodes * (nb_nodes - 1) / 2\n",
    "  return nb_edges / nb_poss_edges\n",
    "\n",
    "print(\"Average density:\", mean([density(t[\"docs\"]) for t in train_dataset]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average clustering: 0.0\n"
     ]
    }
   ],
   "source": [
    "# Average clustering\n",
    "def average_clustering(g):\n",
    "  G = nx.Graph()\n",
    "  edge_list = g.edge_index.t().tolist()\n",
    "  G.add_edges_from(edge_list)\n",
    "  return nx.average_clustering(G)\n",
    "\n",
    "print(\"Average clustering:\", mean([average_clustering(t[\"docs\"]) for t in train_dataset]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "from torch_geometric.nn import GATv2Conv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SENT_RNN(nn.Module):\n",
    "  def __init__(self, device, dim_emb=128):\n",
    "    super(SENT_RNN, self).__init__()\n",
    "    self.device = device\n",
    "    self.dim_emb = dim_emb\n",
    "    self.sent_GRU = nn.GRU(input_size = dim_emb, hidden_size=dim_emb, batch_first = True, bidirectional = True)\n",
    "\n",
    "    # 10: relative position range size, with segment size = 10\n",
    "    self.rel_pos_emb = nn.Embedding(11, 100)\n",
    "    self.abs_pos_emb = nn.Embedding(100, 100)\n",
    "\n",
    "    self.Wdoc = nn.Linear(2*dim_emb,2*dim_emb,bias=True)\n",
    "\n",
    "    self.Wcontent = nn.Linear(2*dim_emb,1,bias=False)\n",
    "    self.Wsalience = nn.Bilinear(2*dim_emb,2*dim_emb,1,bias=False)\n",
    "    self.Wnovelty = nn.Bilinear(2*dim_emb,2*dim_emb,1,bias=False)\n",
    "    self.Wabs_pos = nn.Linear(100,1,bias=False)\n",
    "    self.Wrel_pos = nn.Linear(100,1,bias=False)\n",
    "    self.bias = nn.Parameter(torch.empty(1).uniform_(-0.1, 0.1))\n",
    "\n",
    "  def avg_pool1d(self,x,seq_lens):\n",
    "    out = []\n",
    "    for index,t in enumerate(x):\n",
    "      if seq_lens[index] == 0:\n",
    "        t = t[:1]\n",
    "      else:\n",
    "        t = t[:seq_lens[index],:]\n",
    "      t = torch.t(t).unsqueeze(0)\n",
    "      out.append(torch.avg_pool1d(t,t.size(2)))\n",
    "\n",
    "    out = torch.cat(out).squeeze(2)\n",
    "    return out\n",
    "\n",
    "  def pad_doc(self, x, doc_lens):\n",
    "    pad_dim = x.size(1)\n",
    "    max_doc_len = max(doc_lens)\n",
    "    result = []\n",
    "    start = 0\n",
    "    for doc_len in doc_lens:\n",
    "      stop = start + doc_len\n",
    "      doc = x[start:stop]\n",
    "      start = stop\n",
    "      if doc_len == max_doc_len:\n",
    "        result.append(doc.unsqueeze(0))\n",
    "      else:\n",
    "        pad = torch.zeros(max_doc_len-doc_len, pad_dim)\n",
    "        if self.device is not None:\n",
    "          pad = pad.to(self.device)\n",
    "        result.append(torch.cat([doc,pad]).unsqueeze(0))\n",
    "    result = torch.cat(result,dim=0)\n",
    "    return result\n",
    "\n",
    "  def forward(self, sents, doc_lens):\n",
    "    probs = []\n",
    "\n",
    "    max_doc_lens = max(doc_lens)\n",
    "\n",
    "    arr_x = self.pad_doc(sents, doc_lens)\n",
    "    arr_x = self.sent_GRU(arr_x)[0]\n",
    "    sents_all_docs = arr_x.reshape(len(doc_lens) * max_doc_lens, 2*self.dim_emb) # flat docs\n",
    "\n",
    "    docs = self.avg_pool1d(arr_x, doc_lens)\n",
    "    docs = torch.tanh(self.Wdoc(docs))\n",
    "    docs_for_each_sent = docs.repeat_interleave(max_doc_lens, dim=0) # repeat doc n times\n",
    "    \n",
    "    contents = self.Wcontent(sents_all_docs)\n",
    "    saliences = self.Wsalience(sents_all_docs, docs_for_each_sent)\n",
    "\n",
    "    # Compute position embedding\n",
    "    abs_poses = torch.tensor([[position] for position in range(max_doc_lens)], dtype=torch.long)\n",
    "    abs_poses = abs_poses.to(self.device)\n",
    "    abs_poses = self.abs_pos_emb(abs_poses).squeeze(1)\n",
    "    aps = self.Wabs_pos(abs_poses)\n",
    "\n",
    "    # Compute relative position embedding\n",
    "    rel_poses = torch.tensor([[int(round(position / 10))] for position in range(max_doc_lens)], dtype=torch.long)\n",
    "    rel_poses = rel_poses.to(self.device)\n",
    "    rel_poses = self.rel_pos_emb(rel_poses).squeeze(1)\n",
    "    rps = self.Wrel_pos(rel_poses)\n",
    "\n",
    "    # doc_len (number) s\n",
    "    ses = torch.zeros(len(doc_lens), 2*self.dim_emb)\n",
    "    ses = ses.to(self.device)\n",
    "\n",
    "    # for each document, compute probabilities\n",
    "    for position in range(max_doc_lens):\n",
    "      contents_for_position = contents[position::max_doc_lens]\n",
    "      saliences_for_position = saliences[position::max_doc_lens]\n",
    "      novelties_for_position = -1 * self.Wnovelty(sents_all_docs[position::max_doc_lens], torch.tanh(ses))\n",
    "      prob = contents_for_position + saliences_for_position + novelties_for_position + aps[position] + rps[position] + self.bias\n",
    "      prob = torch.sigmoid(prob)\n",
    "      probs.append(prob)\n",
    "\n",
    "      ses = ses + torch.mul(sents_all_docs[position::max_doc_lens], prob)\n",
    "    probs = torch.cat(probs).squeeze()\n",
    "    if len(probs.shape) == 0:\n",
    "      probs = probs.unsqueeze(0)\n",
    "    probs_filtered = []\n",
    "    for idx, doc_len in enumerate(doc_lens):\n",
    "      prob = probs[idx::len(doc_lens)]\n",
    "      prob = prob[:doc_len]\n",
    "      probs_filtered.append(prob)\n",
    "    probs_filtered = torch.cat(probs_filtered).squeeze()\n",
    "    if len(probs_filtered.shape) == 0:\n",
    "      probs_filtered = probs_filtered.unsqueeze(0)\n",
    "    #probs = probs.to(self.device)\n",
    "    return probs_filtered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Position Feed Forward\n",
    "class PositionwiseFeedForward(nn.Module):\n",
    "  def __init__(self, d_in, d_out, d_h, dropout=0.1) -> None:\n",
    "    super(PositionwiseFeedForward, self).__init__()\n",
    "    self.fc1 = nn.Linear(in_features=d_in, out_features=d_h)\n",
    "    self.fc2 = nn.Linear(in_features=d_h, out_features=d_out)\n",
    "    self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "  def forward(self, x):\n",
    "    x = torch.relu(self.fc1(x))\n",
    "    x = self.dropout(x)\n",
    "    return self.fc2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HSGRNN(torch.nn.Module):\n",
    "  def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 300, num_iter=3):\n",
    "    super(HSGRNN, self).__init__()\n",
    "    self.device = device\n",
    "    self.num_iter = num_iter\n",
    "\n",
    "    self.word_emb = nn.Embedding(vocab_size+2, dim_word_embed, padding_idx=0)\n",
    "\n",
    "    # Load word embedding if specified\n",
    "    if word_embed is not None:\n",
    "      self.word_embedding = torch.nn.Embedding.from_pretrained(torch.from_numpy(word_embed).float())\n",
    "\n",
    "    self.word_emb.weight.requires_grad = False\n",
    "\n",
    "    # edge_attr embed\n",
    "    self.edge_attr_embed = nn.Embedding(101, 50)\n",
    "\n",
    "    # sent CNN\n",
    "    dim_out_cnn = 64\n",
    "    self.convs = nn.Sequential(\n",
    "                            nn.Conv1d(in_channels=300,out_channels=100,kernel_size=3,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=100,kernel_size=4,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=dim_out_cnn,kernel_size=5,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=dim_out_cnn),\n",
    "                            nn.ReLU(inplace=True))\n",
    "\n",
    "    # sent LSTM\n",
    "    dim_out_lstm = 32\n",
    "    self.sent_LSTM = nn.LSTM(input_size=300, hidden_size=dim_out_lstm, batch_first=True, bidirectional=True)\n",
    "\n",
    "    # sent to word GAT\n",
    "    # TODO out_channels = 64\n",
    "    self.s2wGAT = GATv2Conv(in_channels=[128, 300], out_channels=300, heads=8, edge_dim=50, fill_value=0, share_weights=False)\n",
    "\n",
    "    # word to sen GAT\n",
    "    self.w2sGAT = GATv2Conv(in_channels=[300, 128], out_channels=128, heads=8, edge_dim=50, fill_value=0, share_weights=False)\n",
    "\n",
    "    # ffn sent to word\n",
    "    self.ffns2w = PositionwiseFeedForward(d_in=8*300, d_out=300, d_h=512)\n",
    "\n",
    "    # ffn word to sent\n",
    "    self.ffnw2s = PositionwiseFeedForward(d_in=8*128, d_out=128, d_h=512)\n",
    "\n",
    "    self.sent_rnn = SENT_RNN(device)\n",
    "    self.w_ner = nn.Linear(300, 1)\n",
    "\n",
    "  def max_pool1d(self, x, seq_lens):\n",
    "    out = []\n",
    "    for index,t in enumerate(x):\n",
    "      if seq_lens[index] == 0:\n",
    "        t = t[:1]\n",
    "      else:\n",
    "        t = t[:seq_lens[index],:]\n",
    "      t = torch.t(t).unsqueeze(0)\n",
    "      out.append(torch.avg_pool1d(t, t.size(2)))\n",
    "\n",
    "    out = torch.cat(out).squeeze(2)\n",
    "    return out\n",
    "\n",
    "  def forward(self, data, doc_lens):# In the real implémentation remove nb_sent\n",
    "    # edge attr embeddings\n",
    "    edge_attr = torch.floor(data.edge_attr * 100).int()\n",
    "    edge_attr = self.edge_attr_embed(edge_attr)\n",
    "\n",
    "    # features\n",
    "    Xw = data.x[0]\n",
    "    Xs = data.x[1]\n",
    "    sent_lens = torch.sum(torch.sign(Xs),dim=1).data\n",
    "    \n",
    "    # embeddings\n",
    "    Xw = self.word_emb(Xw)\n",
    "    Xs = self.word_emb(Xs)\n",
    "\n",
    "    # CNN\n",
    "    XsCNN = self.convs(Xs.permute(0,2,1))\n",
    "    XsCNN = torch.max_pool1d(XsCNN, XsCNN.size(2)).squeeze(2)\n",
    "\n",
    "    # LSTM\n",
    "    # TO DO: ask \n",
    "    XsLSTM, _ = self.sent_LSTM(Xs)\n",
    "    XsLSTM = self.max_pool1d(XsLSTM, sent_lens)\n",
    "    Xs = torch.cat((XsCNN, XsLSTM), dim=1)\n",
    "\n",
    "    Hw = Xw\n",
    "    Hs = Xs\n",
    "\n",
    "    edge_index_w_i = data.edge_index[1][data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_s_j = data.edge_index[0][data.edge_index[1] < len(data.x[0])] - Hw.shape[0]\n",
    "    edge_attr_w = edge_attr[data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_w = torch.stack([edge_index_s_j, edge_index_w_i])\n",
    "\n",
    "    edge_index_s_i = data.edge_index[1][data.edge_index[1] >= len(data.x[0])] - Hw.shape[0]\n",
    "    edge_index_w_j = data.edge_index[0][data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_attr_s = edge_attr[data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_index_s = torch.stack([edge_index_w_j, edge_index_s_i])\n",
    "\n",
    "    Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "    Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    for i in range(self.num_iter):\n",
    "      if i != 0: # H^1w = H^0w = Xw\n",
    "        Hw = self.s2wGAT(x=[Hs, Hw], edge_index=edge_index_w, edge_attr=edge_attr_w) + torch.cat([Hw] * 8, dim=1)\n",
    "        Hw = self.ffns2w(Hw)\n",
    "        Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "\n",
    "      Hs = self.w2sGAT(x=[Hw, Hs], edge_index=edge_index_s, edge_attr=edge_attr_s) + torch.cat([Hs] * 8, dim=1)\n",
    "      Hs = self.ffnw2s(Hs)\n",
    "      Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    o_sum = self.sent_rnn(Hs, doc_lens)\n",
    "\n",
    "    o_ner = self.w_ner(Hw)\n",
    "    o_ner = torch.sigmoid(o_ner).squeeze(-1)\n",
    "\n",
    "    return o_sum, o_ner\n",
    "\n",
    "  def save(self, fname):\n",
    "    torch.save(self.state_dict(), fname)\n",
    "\n",
    "  def load(self, fname):\n",
    "    self.load_state_dict(torch.load(fname))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HSGRNN(device=device, vocab_size=vocab_size, word_embed=embmgr.getEmbeddings(), dim_word_embed=300).to(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "  os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[args.doc_column_name])\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/50 [00:00<?, ?batch/s]/home/raoufdine/.local/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 50/50 [00:05<00:00,  8.72batch/s, accuracy_ner=0.904, loss=0.296, loss_ner=0.296]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.270, val loss ner = 0.270, val accuracy ner = 0.922\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 50/50 [00:05<00:00,  9.56batch/s, accuracy_ner=0.921, loss=0.256, loss_ner=0.256]\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "arr_train_loss = []\n",
    "arr_train_loss_ner = []\n",
    "arr_train_acc_sum = []\n",
    "arr_train_acc_ner = []\n",
    "arr_val_loss = []\n",
    "arr_val_acc_ner = []\n",
    "\n",
    "t1 = time()\n",
    "\n",
    "for epoch in range(1, epochs+1):\n",
    "  # Train\n",
    "  model.train()\n",
    "  nb_batch_train = 0\n",
    "  total_train_loss = 0\n",
    "  total_train_loss_ner = 0\n",
    "  total_train_acc_ner = 0\n",
    "  with tqdm(train_loader, unit=\"batch\", total=len(train_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "      tepoch.set_description(f\"Epoch {epoch}\")\n",
    "      #if dev != \"cpu\":\n",
    "      #  torch.cuda.empty_cache()\n",
    "      doc_lens = batch[\"doc_lens\"]\n",
    "      data = batch[\"docs\"].to(device)\n",
    "      targets_ner = torch.tensor(batch[\"labels_ner\"], dtype=torch.float).to(device)\n",
    "      \n",
    "      y_sum_pred, y_ner_pred = model(data, doc_lens)\n",
    "\n",
    "      #loss_sum = criterion(y_sum_pred, targets_sum)\n",
    "      loss_ner = criterion(y_ner_pred, targets_ner)\n",
    "      \n",
    "      loss = loss_ner # loss_sum_coef * loss_sum + loss_ner_coef * loss_ner\n",
    "      \n",
    "      optimizer.zero_grad()\n",
    "      loss.backward()\n",
    "      nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n",
    "      optimizer.step()\n",
    "      nb_batch_train += 1\n",
    "      total_train_loss += loss.item()\n",
    "      #total_train_loss_sum += loss_sum.item()\n",
    "      total_train_loss_ner += loss_ner.item()\n",
    "\n",
    "      total_train_acc_ner += torch.sum(((y_ner_pred > 0.5).float() == targets_ner).float()).item() / targets_ner.shape[0]\n",
    "\n",
    "      tepoch.set_postfix(loss=total_train_loss/nb_batch_train, loss_ner=total_train_loss_ner/nb_batch_train, accuracy_ner=total_train_acc_ner/nb_batch_train)\n",
    "\n",
    "  # Save model\n",
    "  model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "  # Eval\n",
    "  model.eval()\n",
    "  nb_batch_val = 0\n",
    "  total_val_loss = 0\n",
    "  total_val_loss_ner = 0\n",
    "  total_val_acc_ner = 0\n",
    "\n",
    "  del loss\n",
    "  del loss_ner\n",
    "  del y_ner_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  for i, batch in enumerate(val_loader):\n",
    "    #if dev != \"cpu\":\n",
    "    #  torch.cuda.empty_cache()\n",
    "    doc_lens = batch[\"doc_lens\"]\n",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets_ner = torch.tensor(batch[\"labels_ner\"], dtype=torch.float).to(device)\n",
    "\n",
    "    y_sum_pred, y_ner_pred = model(data, doc_lens)\n",
    "\n",
    "    loss_ner = criterion(y_ner_pred, targets_ner)\n",
    "    \n",
    "    loss = loss_ner # loss_sum_coef * loss_sum + loss_ner_coef * loss_ner\n",
    "\n",
    "    nb_batch_val += 1\n",
    "    total_val_loss += loss.item()\n",
    "    total_val_loss_ner += loss_ner.item()\n",
    "\n",
    "    total_val_acc_ner += torch.sum(((y_ner_pred > 0.5).float() == targets_ner).float()).item() / targets_ner.shape[0]\n",
    "\n",
    "  print(\"Epoch {} : val loss = {:.3f}, val loss ner = {:.3f}, val accuracy ner = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_loss_ner / nb_batch_val, total_val_acc_ner / nb_batch_val))\n",
    "\n",
    "  if len(arr_val_loss) >= early_stopping+1:\n",
    "    if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "      break\n",
    "\n",
    "  del loss\n",
    "  del loss_ner\n",
    "  del y_ner_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "  arr_train_acc_ner.append(total_train_acc_ner / nb_batch_train)\n",
    "\n",
    "  arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "  arr_val_acc_ner.append(total_val_acc_ner / nb_batch_val)\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_acc_ner\"]  = arr_train_acc_ner\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_acc_ner\"]    = arr_val_acc_ner\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "  json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Accuracies\n",
    "if is_graphic:\n",
    "  plt.plot(list(range(1, len(arr_train_acc_ner) + 1)), arr_train_acc_ner, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_acc_ner) + 1)), arr_val_acc_ner, label=\"val\")\n",
    "\n",
    "  plt.title(\"Accuracy NER\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"accuracy\")\n",
    "  plt.legend(loc=\"upper left\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "39"
      ]
     },
     "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:04<00:00, 21.71batch/s, accuracy_ner=0.903, loss=0.511, loss_ner=0.511]\n"
     ]
    }
   ],
   "source": [
    "arr_loss = []\n",
    "arr_loss_ner = []\n",
    "accuracy_ner = []\n",
    "\n",
    "idx = 0\n",
    "\n",
    "counter = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "  for batch in tepoch:\n",
    "    tepoch.set_description(\"Eval model\")\n",
    "    doc_lens = batch[\"doc_lens\"]\n",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets_ner = torch.tensor(batch[\"labels_ner\"], dtype=torch.float).to(device)\n",
    "\n",
    "    y_sum_pred, y_ner_pred = model(data, doc_lens)\n",
    "\n",
    "    loss_ner = criterion(y_ner_pred, targets_ner)\n",
    "    \n",
    "    loss = loss_ner # loss_sum_coef * loss_sum + loss_ner_coef * loss_ner\n",
    "\n",
    "    arr_loss.append(loss.item())\n",
    "    arr_loss_ner.append(loss_ner.item())\n",
    "\n",
    "    accuracy_ner.append(torch.sum(((y_ner_pred > 0.5).float() == targets_ner).float()).item() / targets_ner.shape[0])\n",
    "\n",
    "    tepoch.set_postfix(loss=np.mean(arr_loss), loss_ner=np.mean(arr_loss_ner), accuracy_ner=np.mean(accuracy_ner))\n",
    "    idx += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy_ner\"] = np.mean(accuracy_ner)\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": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:01<00:00, 64.83batch/s, rouge1=0.298, rouge2=0.0863, rougeL=0.189]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Lead-3\")\n",
    "        doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), 3)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[\"summaries\"].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        # assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].recall)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].recall)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:01<00:00, 59.72batch/s, rouge1=0.328, rouge2=0.0932, rougeL=0.201]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[\"summaries\"].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].recall)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].recall)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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
}