04-train_COMPLEX_CNN_RNN_max_pool_fasttext_fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train COMPLEX_CNN_RNN_max_pool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a8a5bd39",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.utils import clip_grad_norm_\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils_french.EmbMgr import EmbMgr\n",
    "from utils_french.Dataset import Dataset\n",
    "from utils_french.DataLoader import DataLoader\n",
    "from utils_french.preprocess_df import preprocess_df\n",
    "from utils_french.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils_french.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn\n",
    "from utils_french.split_all_docs import split_all_docs\n",
    "\n",
    "from time import time\n",
    "\n",
    "import json\n",
    "import argparse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "818410ea",
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "690fa032",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "pd.set_option('display.max_rows', None)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b2636e0b",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6e7aad39",
   "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=4)\n",
    "parser.add_argument('-batch_size',type=int,default=4)\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('-doc_col_name',type=str,default=\"flat_contents\")\n",
    "parser.add_argument('-label_col_name',type=str,default=\"labels_sentences\")\n",
    "parser.add_argument('-sum_col_name',type=str,default=\"summaries\")\n",
    "parser.add_argument('-max_doc_len',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": 5,
   "id": "824eacf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 4\n",
      "epochs 100\n",
      "batch_size 4\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"cc.fr.300.vec\"\n",
    "\n",
    "# hyper-parameters\n",
    "vocab_size = 150000\n",
    "batch_size = args.batch_size\n",
    "epochs = args.epochs\n",
    "learning_rate = 1e-3\n",
    "early_stopping = 3\n",
    "model_name = \"04-train_COMPLEX_CNN_RNN_max_pool_FastTextfr\"\n",
    "sub_folder_name = \"model_name__{}__time__{}__embed_name__{}__lr__{}__batch_size__{}__vocab_size__{}__cuda_num__{}\".format(model_name, time(), embed_name, learning_rate, batch_size, vocab_size, cuda_num)\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",
   "id": "c8ddd4d5",
   "metadata": {},
   "source": [
    "## PyTorch initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d09bc3ed",
   "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",
    "else:\n",
    "    print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b0c5786e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=4)"
      ]
     },
     "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",
   "id": "3393fe4e",
   "metadata": {},
   "source": [
    "## Chargement des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "97644745",
   "metadata": {},
   "outputs": [],
   "source": [
    "glovemgr = EmbMgr(\"./data/cc.fr.300.vec\", vocab_size=vocab_size, header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fe745c8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_json(args.dataset + \"/train.json\")\n",
    "train_dataset = Dataset(preprocess_df(df_train, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "train_iter = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f8b39f3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val = pd.read_json(args.dataset + \"/val.json\")\n",
    "val_dataset = Dataset(preprocess_df(df_val, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "val_iter = DataLoader(dataset=val_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0f086978",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(args.dataset + \"/test.json\")\n",
    "test_dataset = Dataset(preprocess_df(df_test, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "test_iter = DataLoader(dataset=test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fc41eb07",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9683721f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from models.BasicModel import BasicModel\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "\n",
    "class COMPLEX_CNN_RNN(BasicModel):\n",
    "    def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 100):\n",
    "        super(COMPLEX_CNN_RNN, self).__init__(device)\n",
    "\n",
    "        self.device = device\n",
    "\n",
    "        self.word_embedding = nn.Embedding(vocab_size+2, dim_word_embed, padding_idx=0)\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",
    "        # 100 : word2vec embedding size\n",
    "        self.word_convs = nn.Sequential(\n",
    "                            nn.Conv1d(in_channels=dim_word_embed,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=100,kernel_size=5,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True))\n",
    "        self.sent_GRU = nn.GRU(input_size = 100, hidden_size=200, 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*200,2*200,bias=True)\n",
    "\n",
    "        self.Wcontent = nn.Linear(2*200,1,bias=False)\n",
    "        self.Wsalience = nn.Bilinear(2*200,2*200,1,bias=False)\n",
    "        self.Wnovelty = nn.Bilinear(2*200,2*200,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 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.max_pool1d(t,t.size(2)))\n",
    "        \n",
    "        out = torch.cat(out).squeeze(2)\n",
    "        return out\n",
    "\n",
    "    def forward(self, arr_x, doc_lens):\n",
    "        probs = []\n",
    "\n",
    "        max_doc_lens = max(doc_lens)\n",
    "        #sent_lens = torch.sum(torch.sign(arr_x),dim=1).data\n",
    "\n",
    "        arr_x = self.word_embedding(arr_x)\n",
    "        arr_x = self.word_convs(arr_x.permute(0,2,1))\n",
    "        arr_x = torch.max_pool1d(arr_x, arr_x.size(2)).squeeze(2)\n",
    "\n",
    "        arr_x = self.pad_doc(arr_x, doc_lens)\n",
    "\n",
    "        arr_x = self.sent_GRU(arr_x)[0]\n",
    "        sents_all_docs = arr_x.reshape(len(doc_lens) * max_doc_lens, 2*200) # flat docs\n",
    "        \n",
    "        docs = self.max_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*200)\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": 13,
   "id": "380f8ba1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = COMPLEX_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2ae1a236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "COMPLEX_CNN_RNN(\n",
       "  (word_embedding): Embedding(150001, 300)\n",
       "  (word_convs): Sequential(\n",
       "    (0): Conv1d(300, 100, kernel_size=(3,), stride=(1,), padding=same)\n",
       "    (1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "    (3): Conv1d(100, 100, kernel_size=(4,), stride=(1,), padding=same)\n",
       "    (4): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (5): ReLU(inplace=True)\n",
       "    (6): Conv1d(100, 100, kernel_size=(5,), stride=(1,), padding=same)\n",
       "    (7): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (8): ReLU(inplace=True)\n",
       "  )\n",
       "  (sent_GRU): GRU(100, 200, batch_first=True, bidirectional=True)\n",
       "  (rel_pos_emb): Embedding(11, 100)\n",
       "  (abs_pos_emb): Embedding(100, 100)\n",
       "  (Wdoc): Linear(in_features=400, out_features=400, bias=True)\n",
       "  (Wcontent): Linear(in_features=400, out_features=1, bias=False)\n",
       "  (Wsalience): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       "  (Wnovelty): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       "  (Wabs_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       "  (Wrel_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4bc411ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.BCELoss()\n",
    "optimizer = torch.optim.Adamax(model.parameters(),lr=learning_rate)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.5)\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1852182a",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c6618af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[args.doc_col_name], is_sep_n = False)\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0991d3c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/25 [00:00<?, ?batch/s]/home/raoufdine/.local/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 25/25 [00:03<00:00,  7.27batch/s, accuracy=0.633, loss=73, mae=0.738]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 12.188, val mae = 0.722, val accuracy = 0.597, r1 = 0.244, r2 = 0.057, rL = 0.153\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:02<00:00,  8.39batch/s, accuracy=0.67, loss=76.7, mae=0.767] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 67.203, val mae = 0.681, val accuracy = 0.703, r1 = 0.261, r2 = 0.067, rL = 0.161\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:02<00:00,  8.34batch/s, accuracy=0.673, loss=76.3, mae=0.763]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 68.118, val mae = 0.681, val accuracy = 0.771, r1 = 0.294, r2 = 0.095, rL = 0.191\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:03<00:00,  7.98batch/s, accuracy=0.671, loss=76, mae=0.76]   \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 68.118, val mae = 0.681, val accuracy = 0.776, r1 = 0.296, r2 = 0.095, rL = 0.192\n",
      "Training duration = 23.085408210754395\n"
     ]
    }
   ],
   "source": [
    "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",
    "for epoch in range(1, epochs+1):\n",
    "    # train 1 epoch\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_iter, unit=\"batch\", total=len(train_iter)) as tepoch:\n",
    "        for batch in tepoch:\n",
    "            tepoch.set_description(f\"Epoch {epoch}\")\n",
    "            features = []\n",
    "            doc_lens = []\n",
    "\n",
    "            for j in range(batch_size):\n",
    "                doc_lens.append(len(batch[j][\"docs\"]))\n",
    "                features = features + batch[j][\"docs\"]\n",
    "            \n",
    "            features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "            targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(batch_size)]\n",
    "            targets = torch.cat(targets)\n",
    "            targets = targets.to(device)\n",
    "            \n",
    "            probs = model(features, doc_lens)\n",
    "            \n",
    "            loss = loss_fn(probs, targets)\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            clip_grad_norm_(model.parameters(), 1.0)\n",
    "            optimizer.step()\n",
    "            nb_batch_train += 1\n",
    "            total_train_loss += loss.item()\n",
    "            total_train_mae += mae_fn(probs, targets).item()\n",
    "            total_train_acc += accuracy_prop_sent_per_doc_fn(probs=probs.cpu().detach().numpy(), targets=targets.cpu().detach().numpy(), doc_lens=doc_lens)\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",
    "    # Show train and val score\n",
    "    model.eval()\n",
    "    nb_batch_val = 0\n",
    "    total_val_loss = 0\n",
    "    total_val_mae = 0\n",
    "    total_val_acc = 0\n",
    "\n",
    "    total_r1 = 0\n",
    "    total_r2 = 0\n",
    "    total_rl = 0\n",
    "\n",
    "    for i, batch in enumerate(val_iter):\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "            \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "        \n",
    "        y_pred = model(features, doc_lens)\n",
    "\n",
    "        loss = loss_fn(y_pred, targets)\n",
    "\n",
    "        nb_batch_val += 1\n",
    "        total_val_loss += loss.item()\n",
    "\n",
    "        doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "        summaries = val_set[args.sum_col_name].iloc[i]\n",
    "\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        if indices.shape[0] > len(doc):\n",
    "            continue\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\"].fmeasure\n",
    "        total_r2 += scores[\"rouge2\"].fmeasure\n",
    "        total_rl += scores[\"rougeL\"].fmeasure\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",
    "    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",
    "    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",
    "    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",
    "    # update lr\n",
    "    scheduler.step()\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2f39ceed",
   "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": 20,
   "id": "8cd8fbee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAHHCAYAAACle7JuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAA9hAAAPYQGoP6dpAABEWklEQVR4nO3deXhTZcL+8W/SHUpbWqAtUhYB2RTZFAooqyIqA4o746Do608HUEBQUEEFtYgLyqi4g74zjK8bjIqiWKAIFmQdAZFNpFVoQaQtWxea8/sjEJou0Ja2T5b7c1258vTk9OTOIZCbJ+ckNsuyLERERES8kN10ABEREZHKUpERERERr6UiIyIiIl5LRUZERES8loqMiIiIeC0VGREREfFaKjIiIiLitVRkRERExGupyIiIiIjXUpERERERr6UiIyLGzJ07F5vNxtq1a01HEREvpSIjIiIiXktFRkRERLyWioyIeLQNGzYwcOBAIiIiCA8Pp1+/fqxatcptnYKCAp588klatmxJaGgoMTEx9OzZk8WLF7vWycjI4M4776RRo0aEhIQQHx/P4MGD+fXXX2v4EYlIVQo0HUBEpCxbtmzhsssuIyIigoceeoigoCDeeOMNevfuTUpKCl27dgXgiSeeICkpibvvvptLL72UnJwc1q5dy/r167niiisAGDp0KFu2bGH06NE0bdqU/fv3s3jxYtLS0mjatKnBRyki58JmWZZlOoSI+Ke5c+dy5513smbNGrp06VLi9uuuu44vv/ySrVu3cv755wOwb98+WrVqRceOHUlJSQGgQ4cONGrUiC+++KLU+8nKyqJu3bo899xzjB8/vvoekIjUOL21JCIeqbCwkG+++YYhQ4a4SgxAfHw8t912GytWrCAnJweAqKgotmzZwo4dO0rdVlhYGMHBwSxbtoxDhw7VSH4RqRkqMiLikQ4cOMCxY8do1apVidvatGmDw+EgPT0dgKlTp5KVlcUFF1zARRddxIQJE/jxxx9d64eEhPDss8/y1VdfERsby+WXX86MGTPIyMiosccjItVDRUZEvN7ll1/Orl27ePfdd7nwwgt5++236dSpE2+//bZrnTFjxrB9+3aSkpIIDQ1l8uTJtGnThg0bNhhMLiLnSkVGRDxS/fr1qVWrFtu2bStx288//4zdbichIcG1LDo6mjvvvJN///vfpKen0759e5544gm332vevDkPPvgg33zzDZs3byY/P58XXnihuh+KiFQjFRkR8UgBAQFceeWV/Oc//3E7RTozM5N58+bRs2dPIiIiADh48KDb74aHh9OiRQvy8vIAOHbsGLm5uW7rNG/enDp16rjWERHvpNOvRcS4d999l0WLFpVY/sQTT7B48WJ69uzJ3//+dwIDA3njjTfIy8tjxowZrvXatm1L79696dy5M9HR0axdu5aPP/6YUaNGAbB9+3b69evHTTfdRNu2bQkMDGT+/PlkZmZyyy231NjjFJGqp9OvRcSYU6dflyU9PZ0DBw4wadIkVq5cicPhoGvXrjz99NMkJia61nv66af57LPP2L59O3l5eTRp0oTbb7+dCRMmEBQUxMGDB3n88cdJTk4mPT2dwMBAWrduzYMPPsiNN95YEw9VRKqJioyIiIh4LR0jIyIiIl5LRUZERES8loqMiIiIeC0VGREREfFaKjIiIiLitVRkRERExGv5/AfiORwO9u7dS506dbDZbKbjiIiISDlYlsXhw4dp2LAhdnvZ8y4+X2T27t3r9n0sIiIi4j3S09Np1KhRmbf7fJGpU6cO4NwRp76XRURERDxbTk4OCQkJrtfxsvh8kTn1dlJERISKjIiIiJc522EhOthXREREvJaKjIiIiHgtFRkRERHxWj5/jEx5FRYWUlBQYDqGVwoODj7jqXEiIiLVxe+LjGVZZGRkkJWVZTqK17Lb7TRr1ozg4GDTUURExM/4fZE5VWIaNGhArVq19KF5FXTqAwf37dtH48aNtf9ERKRG+XWRKSwsdJWYmJgY03G8Vv369dm7dy8nTpwgKCjIdBwREfEjfn1gw6ljYmrVqmU4iXc79ZZSYWGh4SQiIuJv/LrInKK3Q86N9p+IiJiiIiMiIiJeS0VGaNq0KS+99JLpGCIiIhXm1wf7erPevXvToUOHKikga9asoXbt2uceSkREpIapyPgoy7IoLCwkMPDsf8T169evgURSHg6HxR9H8ygotAiw2bDbcV7bbNjtNgLstlKXi4j4KxUZL3THHXeQkpJCSkoKL7/8MgBz5szhzjvv5Msvv+Sxxx5j06ZNfPPNNyQkJDBu3DhWrVrF0aNHadOmDUlJSfTv39+1vaZNmzJmzBjGjBkDOA/efeutt1i4cCFff/015513Hi+88AJ/+ctfTDxcn+JwWPxxJI/0Q8f57dAxfjt0/OTFOf790HHyCx0V3m5ZBSfA7hwHnFxus50sQ3Ybdhuu2+0nl9vtNgJOLrfZnNssz3L7qftx3S+usWvbtjMvL5mj4svtpWzftbzYYz213D1H2cvtNh3YLuKJVGSKsCyL4wVmTiEOCwoo9z+SL7/8Mtu3b+fCCy9k6tSpAGzZsgWAiRMn8vzzz3P++edTt25d0tPTufrqq3n66acJCQnh/fffZ9CgQWzbto3GjRuXeR9PPvkkM2bM4LnnnuMf//gHw4YNY8+ePURHR5/7g/VhlmVx4EheiYKS/ucxfj90nN+yjpN/4sxFxWaDILudQsui0GGV634LHRaFWKAz4KuV3cbpklik4LhKUtHlxUtlkZJXWqEqUSpPFb/i5fEsy0uUypPLbW73V1qRLVkO7bbixRC3+7SdvN2V5eT2bSe3fWr/FH1Mrn1xsgCf3kel7QOVRzk7FZkijhcU0nbK10bu+6epA6gVXL4/jsjISIKDg6lVqxZxcXEA/PzzzwBMnTqVK664wrVudHQ0F198sevnadOmMX/+fD777DNGjRpV5n3ccccd3HrrrQA888wzzJo1ix9++IGrrrqqwo/Nl1iWxR9H8t1mU9JdY2dZyTtLUbHbID4yjPPqhtGobhiN6tY6eR1GQt1axEWGEhRw+jh862ShKbQsHA6c15aFw1HKcofztkLXNcV+dl/uOPn7Z1tedPuFRe7bYZ3e/unlJ7dRbLnDopQcJ7dxlvs7Y46Ty8/l/k4tP5tTj7dcK0uVOFWWTpWdoiWt9FnFkuuULFLuhbT4DJxbsStWvM58/2WsU6wMlqcwFi+1pRVmVxks7XEWKYPlKYwl1ilSwj2dioyP6dKli9vPR44c4YknnmDhwoXs27ePEydOcPz4cdLS0s64nfbt27vGtWvXJiIigv3791dLZk9iWRYHj+a7ikn6n0XfAnJen62o2GwQHxHqVlBOj2sRH+VeVM7GZrMRGGDTX9YaUKI4nSpDxYvTqTJ0huJU0eWny19pxc6isHgBO7WNYsWueIEtbbnbfRYvwSfvx1HafiiW0bm+hXXy9kKH5SzeJ9c5PS6yjmW5ynl5+qBlwQnLAs04GlO0KJVafuw2Jg1szfWdGhnJp38biwgLCuCnqQOM3XdVKH720fjx41m8eDHPP/88LVq0ICwsjBtuuIH8/Pwzbqf4Vw3YbDYcjoofu+FpLMviz5NFJb1YQTk1zi04e1GJiwgtdTal0ckZleBAfbKBN7LbbdixUUV/HeUsrFMlqGjZsYoUIkdpRanYOsVm5NzKVhnls8Q6pczWFZ31LDrz6D4uWSirtjAWeWylFGCHVdo+KVkYS13Hquhb1wBlr3+2/+BVJxWZImw2W7nf3jEtODi4XF8JsHLlSu644w6uu+46wDlD8+uvv1ZzOnOKFhX3knK6rJztOCibDWLrhLrNpiREny4t8ZFhKioiVcB28ngalUdzSi2MloXlKFkYSy9KzqIVFxFq7DF4x6u2lNC0aVNWr17Nr7/+Snh4eJmzJS1btuTTTz9l0KBB2Gw2Jk+e7NUzK5ZlcehYQakF5dT4WP7ZC15sRIizoBR726dR3TDio0IJCdS/qiLi+3zhrWtvzu7Xxo8fz/Dhw2nbti3Hjx9nzpw5pa734osvMmLECLp37069evV4+OGHycnJqeG05WdZFlnHCkqdTUmvQFFpUCeEhOjSj1FpqKIiIuIzbJZl+fTh9zk5OURGRpKdnU1ERITbbbm5uezevZtmzZoRGmpuWszbVWQ/WpZF9vHiRcV5evKpZUfLWVSKF5RTpaVhVBihmqcWEfFqZ3r9LkozMlKlLMsi5/iJUg6kPV1ajuSdOOt26pcoKqfH56moiIjISSoyUmEnHA4KTjjIL7TIP+Hg+PFcDh7J4+n31vDfvcc4XI6iUi88pJS3fU6PVVRERKQ8VGSkhEKHg/wiRaWg8NTPznHxU/asE/kcL3Cw+4+jHM5zvi1ULzyY80opKAl1a3FeVBhhwSoqIiJy7lRk/JCzqFjOYnKyoLgKSylFpTSBdjvBgTaCAuzYHJBfK4hnrr+I82IiaBgV5jWnsYuIiHfTq40POlVUThWT4rMq5S0qQYE2ggPsBAfaCQ6wE3RyHBRgJ6DIx1bn5uZyNCSQi5rF6KBpERGpUSoyXqjQUcZsSoWKis1VTE6Vk+AyioqIiIinUpHxQIUOy/24lCKFpVJFJcBOUKCKioiI+B4VGQPOVFQKCh2cKEdRCbDb3IqJe2GxEWDXR+iLiIjvU5GpBiWKiltpsThRjq8IKLOoBDgPslVRERERUZGptPwTheQWOEo5oLZiRaX0t3+qv6g0bdqUMWPGMGbMmGq9HxERkeqkIlNJmTl5HDqWX+btATZbieNSThcWG4GaURERETlnKjKVFBJoJzQooJSi4iwwKioiIiLVT6+2ldQgIpQLYuvQtF5tGkaFUb9OCJFhQYQFB1Z7iXnzzTdp2LAhjmJvYQ0ePJgRI0awa9cuBg8eTGxsLOHh4VxyySV8++231ZpJRETEBBWZoiwL8o+auVTgS8hvvPFGDh48yNKlS13L/vzzTxYtWsSwYcM4cuQIV199NcnJyWzYsIGrrrqKQYMGkZaWVh17TURExBi9tVRUwTF4pqGZ+35kLwTXLteqdevWZeDAgcybN49+/foB8PHHH1OvXj369OmD3W7n4osvdq0/bdo05s+fz2effcaoUaOqJb6IiIgJmpHxUsOGDeOTTz4hLy8PgH/961/ccsst2O12jhw5wvjx42nTpg1RUVGEh4ezdetWzciIiIjP0YxMUUG1nDMjpu67AgYNGoRlWSxcuJBLLrmE7777jpkzZwIwfvx4Fi9ezPPPP0+LFi0ICwvjhhtuID+/7LOsREREvJGKTFE2W7nf3jEtNDSU66+/nn/961/s3LmTVq1a0alTJwBWrlzJHXfcwXXXXQfAkSNH+PXXXw2mFRERqR4qMl5s2LBhXHvttWzZsoW//vWvruUtW7bk008/ZdCgQdhsNiZPnlziDCcRERFfoGNkvFjfvn2Jjo5m27Zt3Hbbba7lL774InXr1qV79+4MGjSIAQMGuGZrREREfIlmZLyY3W5n796Sx/Q0bdqUJUuWuC0bOXKk2896q0lERHyBZmRERETEaxktMk2bNsVms5W4nJo9yM3NZeTIkcTExBAeHs7QoUPJzMw0GVlEREQ8iNEis2bNGvbt2+e6LF68GHB+ci3A2LFj+fzzz/noo49ISUlh7969XH/99SYji4iIiAcxeoxM/fr13X6ePn06zZs3p1evXmRnZ/POO+8wb948+vbtC8CcOXNo06YNq1atolu3biYii4iIiAfxmGNk8vPz+ec//8mIESOw2WysW7eOgoIC+vfv71qndevWNG7cmNTU1Cq9b6sC33MkJWn/iYiIKR5z1tKCBQvIysrijjvuACAjI4Pg4GCioqLc1ouNjSUjI6PM7eTl5bk+th8gJyenzHWDgoIAOHbsGGFhYZUP7+dOfWJwQECA4SQiIuJvPKbIvPPOOwwcOJCGDc/tSxuTkpJ48skny7VuQEAAUVFR7N+/H4BatWphs9nO6f79jcPh4MCBA9SqVYvAQI95OomIiJ/wiFeePXv28O233/Lpp5+6lsXFxZGfn09WVpbbrExmZiZxcXFlbmvSpEmMGzfO9XNOTg4JCQllrn9qW6fKjFSc3W6ncePGKoEiIlLjPKLIzJkzhwYNGnDNNde4lnXu3JmgoCCSk5MZOnQoANu2bSMtLY3ExMQytxUSEkJISEi579tmsxEfH0+DBg0oKCio/IPwY8HBwdjtHnO4lYiI+BHjRcbhcDBnzhyGDx/u9tZEZGQkd911F+PGjSM6OpqIiAhGjx5NYmJitZyxFBAQoGM8REREvIzxIvPtt9+SlpbGiBEjStw2c+ZM7HY7Q4cOJS8vjwEDBvDaa68ZSCkiIiKeyGb5+LmzOTk5REZGkp2dTUREhOk4IiIiUg7lff3WgQ0iIiLitVRkRERExGsZP0ZGRERKYVlQmA8ncuFEnvt1QW6x5cXXOV7yd07kgeOE6Uclvqrj7XB+LyN3rSIjIlIWR2HZhaFEmSh+fZayUVBG2Sh6jU8fwii+pEkPFRkRkRLONCtRogyUp0ycbWaj2LXDgz5bKjAMAkMgMLTkdVBo6cvdLiFg1z/5Uk0SLjV213pWi8iZnWlWolwzC2cpG2crE54yK2EPKqMsnK1MFC8VpSw/2+8GBIM+OVukVCoyIp7OsqCwoOzjHk4VhDMWgrOUjTOVEY+alThTIQiBoNJmLcpTJsoqIyfHASEQoH8uRTyR/maKeJLDGfDBMMj+zUNnJQIrWQiKXp+lbJT1u5qVEJFSqMiIeJKlz8Dva8+8zhkLQVmzExV5q6OM39WshIh4IP2rJOIpDu6CDf90jm+cCw3alZyd0KyEiIgbFRkRT7H0GbAKoeUAaHed6TQiIl5Bn+wr4gkyNsHmj53jvo+ZzSIi4kVUZEQ8wZKnndftrof49maziIh4ERUZEdPSVsP2r8AWAH0eNZ1GRMSrqMiImGRZkDzVOe44DOq1MJtHRMTLqMiImPTLUtizwnk2Uq+HTacREfE6KjIiphSdjbnkbohsZDaPiIgXUpERMeXnL2DvBgiqDT3HmU4jIuKVVGRETHAUwpKnnOPEv0N4fbN5RES8lIqMiAk/fggHfobQKOg+2nQaERGvpSIjUtNO5MOyZ5zjnmMhNNJsHhERL6YiI1LT1r8HWWkQHguX3mM6jYiIV1OREalJ+cdg+XPO8eUTILiW2TwiIl5ORUakJv3wJhzJhKgm0Gm46TQiIl5PRUakphzPghUzneM+j0BgsNE4IiK+QEVGpKakvgK5WVC/NVx0o+k0IiI+QUVGpCYcOQCprznHfR8De4DZPCIiPkJFRqQmrHgRCo5Cw47Q+lrTaUREfIaKjEh1y0qHNW87x/2mgM1mNo+IiA9RkRGpbstnQGE+NL0Mzu9jOo2IiE9RkRGpTn/shA3/co41GyMiUuVUZESq09KnwSqECwZCwqWm04iI+BwVGZHqsu9H2PKpc9z3MbNZRER8lIqMSHVZ8pTz+sIbIO5Cs1lERHyUioxIdUhbBTu+BluA81N8RUSkWqjIiFQ1y4Lkqc5xp9shprnZPCIiPkxFRqSq7UqGPSshIAQuf8h0GhERn6YiI1KVis7GXPo/EHme2TwiIj5ORUakKm39DPb9F4LDoedY02lERHyeioxIVXEUnj5TKXEk1K5nNo+IiB9QkRGpKv/9AP7YDmF1IXGU6TQiIn7BeJH5/fff+etf/0pMTAxhYWFcdNFFrF271nW7ZVlMmTKF+Ph4wsLC6N+/Pzt27DCYWKQUJ/Jg2XTnuOc4CI0wm0dExE8YLTKHDh2iR48eBAUF8dVXX/HTTz/xwgsvULduXdc6M2bMYNasWbz++uusXr2a2rVrM2DAAHJzcw0mFylm3XuQnQZ14p0H+YqISI0INHnnzz77LAkJCcyZM8e1rFmzZq6xZVm89NJLPPbYYwwePBiA999/n9jYWBYsWMAtt9xS45lFSsg/Csufc44vnwBBYWbziIj4EaMzMp999hldunThxhtvpEGDBnTs2JG33nrLdfvu3bvJyMigf//+rmWRkZF07dqV1NRUE5FFSlr9BhzdD3WbQsfbTacREfErRovML7/8wuzZs2nZsiVff/019913H/fffz/vvfceABkZGQDExsa6/V5sbKzrtuLy8vLIyclxu4hUm+NZsPIl57j3IxAYbDKNiIjfMfrWksPhoEuXLjzzzDMAdOzYkc2bN/P6668zfPjwSm0zKSmJJ598sipjipTt+1mQmw0N2sJFN5hOIyLid4zOyMTHx9O2bVu3ZW3atCEtLQ2AuLg4ADIzM93WyczMdN1W3KRJk8jOznZd0tPTqyG5CHBkP6ya7Rz3fQzsAWbziIj4IaNFpkePHmzbts1t2fbt22nSpAngPPA3Li6O5ORk1+05OTmsXr2axMTEUrcZEhJCRESE20WkWnz3AhQcg/M6Q6urTacREfFLRt9aGjt2LN27d+eZZ57hpptu4ocffuDNN9/kzTffBMBmszFmzBieeuopWrZsSbNmzZg8eTINGzZkyJAhJqOLv8tKg7XvOsf9poDNZjaPiIifMlpkLrnkEubPn8+kSZOYOnUqzZo146WXXmLYsGGudR566CGOHj3KPffcQ1ZWFj179mTRokWEhoYaTC5+L+VZKMyHZpfD+b1NpxER8Vs2y7Is0yGqU05ODpGRkWRnZ+ttJqkaB7bDa13BcsDdydCoi+lEIiI+p7yv38a/okDE6yx92lliWl2jEiMiYpiKjEhF7N0IPy0AbND3UcNhRERERUakIpY85by+6EaIbWc2i4iIqMiIlNue72HnYrAHQu+JptOIiAgqMiLlY1mQPNU57ng7xDQ3m0dERAAVGZHy2fktpKVCYCj0esh0GhEROUlFRuRsHI7TszGX/g9ENDSbR0REXFRkRM5m638g40cIrgM9xppOIyIiRajIiJxJ4QlY8rRz3H0U1I4xm0dERNyoyIicyY8fwMEdEBYN3f5uOo2IiBSjIiNSlhN5sGy6c3zZgxCqr7gQEfE0KjIiZVk7B7LToU5DuOQu02lERKQUKjIipck7At897xz3egiCwszmERGRUqnIiJRm9etw9ADUbQYd/2o6jYiIlEFFRqS444dg5SznuM+jEBBkNo+IiJRJRUakuJWzIC8bGrSDC4eaTiMiImegIiNS1OFM59tKAP0mg11/RUREPJn+lRYp6rvnoeAYNLoELrjKdBoRETkLFRmRUw7tcZ5yDdBvCthsZvOIiMhZqciInJLyLDgK4Pze0Oxy02lERKQcVGREAA5sg//+2znuO8VsFhERKTcVGRGAJU+B5YDW10KjzqbTiIhIOanIiPy+HrZ+Btig72Om04iISAWoyIgsecp53f5maNDGbBYREakQFRnxb7+ugF3JYA+E3hNNpxERkQpSkRH/ZVmQPM057jQcopuZzSMiIhWmIiP+a8c3kL4KAsPg8gmm04iISCWoyIh/cjhOz8Z0vQci4s3mERGRSlGREf/003zI3AQhEdBjjOk0IiJSSSoy4n8KT8CSp53j7qOhVrTZPCIiUmkqMuJ//jsP/twFtWKg232m04iIyDlQkRH/UpALy551ji97EELqmM0jIiLnREVG/MvadyHnN4g4D7rcZTqNiIicIxUZ8R95h+G7F5zjXg9DUKjZPCIics5UZMR/rHodjv0B0c2hw22m04iISBVQkRH/cOxP+H6Wc9znEQgIMptHRESqhIqM+IeVL0NeDsReCO2uN51GRESqiIqM+L7DGbD6Dee472Sw62kvIuIr9C+6+L7lz8GJ45DQFS4YYDqNiIhUIRUZ8W1/7oZ1c53jflPAZjMaR0REqpaKjPi2lGfBcQKa94WmPU2nERGRKqYiI75r/1b47wfOcd/JZrOIiEi1MFpknnjiCWw2m9uldevWrttzc3MZOXIkMTExhIeHM3ToUDIzMw0mFq+y9GnAgjaD4LxOptOIiEg1MD4j065dO/bt2+e6rFixwnXb2LFj+fzzz/noo49ISUlh7969XH+9Tp2Vcvh9HWz9HGx26POY6TQiIlJNAo0HCAwkLi6uxPLs7Gzeeecd5s2bR9++fQGYM2cObdq0YdWqVXTr1q2mo4o3SZ7mvG5/CzRofeZ1RUTEaxmfkdmxYwcNGzbk/PPPZ9iwYaSlpQGwbt06CgoK6N+/v2vd1q1b07hxY1JTU8vcXl5eHjk5OW4X8TO7l8MvS8EeBL0fNp1GRESqkdEi07VrV+bOncuiRYuYPXs2u3fv5rLLLuPw4cNkZGQQHBxMVFSU2+/ExsaSkZFR5jaTkpKIjIx0XRISEqr5UYhHsazTszGd74C6TU2mERGRamb0raWBAwe6xu3bt6dr1640adKEDz/8kLCwsEptc9KkSYwbN871c05OjsqMP9n+Nfz2AwSGweXjTacREZFqZvytpaKioqK44IIL2LlzJ3FxceTn55OVleW2TmZmZqnH1JwSEhJCRESE20X8hMMBS07OxnS7F+qU/TwRERHf4FFF5siRI+zatYv4+Hg6d+5MUFAQycnJrtu3bdtGWloaiYmJBlOKx9ryKWRuhpBI6H6/6TQiIlIDjL61NH78eAYNGkSTJk3Yu3cvjz/+OAEBAdx6661ERkZy1113MW7cOKKjo4mIiGD06NEkJibqjCUpqbDg5OfGAD1GQ61os3lERKRGGC0yv/32G7feeisHDx6kfv369OzZk1WrVlG/fn0AZs6cid1uZ+jQoeTl5TFgwABee+01k5HFU238F/z5C9SqB13vM51GRERqiM2yLMt0iOqUk5NDZGQk2dnZOl7GVxXkwqyOcHgvXDUduqnIiIh4u/K+fnvUMTIilbL2HWeJiWgEne80nUZERGqQiox4t7zD8N0LznHviRAUajaPiIjUKBUZ8W6pr8GxgxDTAi6+1XQaERGpYSoy4r2O/Qnf/8M57vMoBBj/6jAREalhKjLivVbMhPzDEHcRtB1iOo2IiBigIiPeKWcf/PCmc9x3Ctj1VBYR8Uf611+80/IZcCIXGidCyytMpxEREUNUZMT7/PkLrH/fOe43BWw2s3lERMQYFRnxPsumg+MEtOgPTbqbTiMiIgapyIh3yfwJfvzQOe77mNksIiJinIqMeJelTwMWtB0MDTuaTiMiIoapyIj3+G0t/PwF2OzOz40RERG/V6ki895777Fw4ULXzw899BBRUVF0796dPXv2VFk4ETfJU53XF98G9VuZzSIiIh6hUkXmmWeeISwsDIDU1FReffVVZsyYQb169Rg7dmyVBhQB4JdlsDsF7EHQ+2HTaURExENU6jPd09PTadGiBQALFixg6NCh3HPPPfTo0YPevXtXZT4RsCxInuYcdxkBUY3N5hEREY9RqRmZ8PBwDh48CMA333zDFVc4P5AsNDSU48ePV106EYBtX8HvayGoFlz2oOk0IiLiQSo1I3PFFVdw991307FjR7Zv387VV18NwJYtW2jatGlV5hN/53DAkpOzMV3vhTqxZvOIiIhHqdSMzKuvvkpiYiIHDhzgk08+ISYmBoB169Zx6623VmlA8XObP4b9P0FoJPS433QaERHxMDbLsizTIapTTk4OkZGRZGdnExERYTqOVERhAbzSBQ796vwqAr2tJCLiN8r7+l2pGZlFixaxYsUK18+vvvoqHTp04LbbbuPQoUOV2aRISRv+11liatd3vq0kIiJSTKWKzIQJE8jJyQFg06ZNPPjgg1x99dXs3r2bcePGVWlA8VMFxyFlhnN8+QQIrm02j4iIeKRKHey7e/du2rZtC8Ann3zCtddeyzPPPMP69etdB/6KnJM1b8PhfRCZAJ3vMJ1GREQ8VKVmZIKDgzl27BgA3377LVdeeSUA0dHRrpkakUrLzYHvXnSOe0+EwBCzeURExGNVakamZ8+ejBs3jh49evDDDz/wf//3fwBs376dRo0aVWlA8UOpr8LxP6HeBdD+FtNpRETEg1VqRuaVV14hMDCQjz/+mNmzZ3PeeecB8NVXX3HVVVdVaUDxM0cPQuorznGfRyGgUl1bRET8hE6/Fs/y9aPOIhN/MfzPMrDrC9pFRPxReV+/K/3f3cLCQhYsWMDWrVsBaNeuHX/5y18ICAio7CbF32X/Dj+85Rz3naISIyIiZ1WpIrNz506uvvpqfv/9d1q1agVAUlISCQkJLFy4kObNm1dpSPETy5+Dwjxo3B1a9DOdRkREvECl/st7//3307x5c9LT01m/fj3r168nLS2NZs2acf/9+hh5qYSDu5wfgAfOT/G12czmERERr1CpGZmUlBRWrVpFdHS0a1lMTAzTp0+nR48eVRZO/MiyJHCcgJZXQpNE02lERMRLVGpGJiQkhMOHD5dYfuTIEYKDg885lPiZjM2w6WPnuO9jZrOIiIhXqVSRufbaa7nnnntYvXo1lmVhWRarVq3i3nvv5S9/+UtVZxRft/RpwIJ21znPVhIRESmnShWZWbNm0bx5cxITEwkNDSU0NJTu3bvTokULXnrppSqOKD4tfQ1s+xJsdufnxoiIiFRApY6RiYqK4j//+Q87d+50nX7dpk0bWrRoUaXhxMdZFiQ/6Rx3uA3qtTSbR0REvE65i8zZvtV66dKlrvGLL75Y+UTiP35ZBr9+BwHB0Gui6TQiIuKFyl1kNmzYUK71bDptVsrDsiB5qnPc5S6ISjCbR0REvFK5i0zRGReRc/bzQti7HoJqw2Vnnu0TEREpiz4DXmqeoxCWPOUcd7sPwhuYzSMiIl5LRUZq3qaP4cBWCI2C7qNNpxERES+mIiM160T+yc+NAXqOgbAok2lERMTLqchIzdrwPmTtgfBYuPQe02lERMTLeUyRmT59OjabjTFjxriW5ebmMnLkSGJiYggPD2fo0KFkZmaaCynnJv8YpDznHF8+AYJrm80jIiJezyOKzJo1a3jjjTdo37692/KxY8fy+eef89FHH5GSksLevXu5/vrrDaWUc7bmLTiSAVGNodNw02lERMQHGC8yR44cYdiwYbz11lvUrVvXtTw7O5t33nmHF198kb59+9K5c2fmzJnD999/z6pVqwwmlkrJzYYVM53j3pMgUF8uKiIi5854kRk5ciTXXHMN/fv3d1u+bt06CgoK3Ja3bt2axo0bk5qaWub28vLyyMnJcbuIB/j+FTh+COq1gvY3m04jIiI+olLftVRVPvjgA9avX8+aNWtK3JaRkUFwcDBRUVFuy2NjY8nIyChzm0lJSTz55JNVHVXOxZEDkPqqc9z3MbAHmM0jIiI+w9iMTHp6Og888AD/+te/CA0NrbLtTpo0iezsbNclPT29yrYtlbRiJhQchfgO0GaQ6TQiIuJDjBWZdevWsX//fjp16kRgYCCBgYGkpKQwa9YsAgMDiY2NJT8/n6ysLLffy8zMJC4urszthoSEEBER4XYRg7J/gzVvO8f9poC+i0tERKqQsbeW+vXrx6ZNm9yW3XnnnbRu3ZqHH36YhIQEgoKCSE5OZujQoQBs27aNtLQ0EhMTTUSWykiZAYV50KQnNO9rOo2IiPgYY0WmTp06XHjhhW7LateuTUxMjGv5XXfdxbhx44iOjiYiIoLRo0eTmJhIt27dTESWijq4Czb80znWbIyIiFQDowf7ns3MmTOx2+0MHTqUvLw8BgwYwGuvvWY6lpTX0qfBKoQLroLGXU2nERERH2SzLMsyHaI65eTkEBkZSXZ2to6XqUkZm+D1ns7xvSsg7iKzeURExKuU9/Xb+OfIiI9a8pTz+sKhKjEiIlJtVGSk6qWthu2LwBYAvR8xnUZERHyYioxULcuC5KnOccdhUK+F2TwiIuLTVGSkau1aAntWQEAI9HrYdBoREfFxKjJSdYrOxlxyN0Q2MptHRER8noqMVJ2tn8O+jRAcDpeNM51GRET8gIqMVA1H4ekzlbr9HWrXM5tHRET8goqMVI0fP4Q/tkFoFHQfZTqNiIj4CRUZOXcn8mHZM85xz7EQGmk2j4iI+A0VGTl369+DrDQIj4NL7zGdRkRE/IiKjJyb/KPOb7gG6DUBgmuZzSMiIn5FRUbOzQ9vwtH9ENUEOv7NdBoREfEzKjJSecezYMVLznGfRyAw2GQaERHxQyoyUnmpr0BuFtRvAxfdaDqNiIj4IRUZqZwj+yH1Nee472NgDzCbR0RE/JKKjFTOdy9CwVFo2AlaX2M6jYiI+CkVGam4rHRY+45z3G8K2Gxm84iIiN9SkZGKS3kWCvOh6WVwfm/TaURExI+pyEjF/LEDNs5zjjUbIyIihqnISMUsfRqsQrhgICRcajqNiIj4ORUZKb99/4Ut8wGb80wlERERw1RkpPyWPOW8vugGiLvQbBYRERFUZKS89qTCjm/AFgC9J5lOIyIiAqjISHlYFiRPdY473Q4xzc3mEREROUlFRs5uVzKkfQ8BIXD5Q6bTiIiIuKjIyJk5HKdnYy79H4g8z2weERGRIlRk5My2fuY8Wyk4HHqOM51GRETEjYqMlK3whPNzYwASR0HtGLN5REREilGRkbL9+H/wx3YIqwuJI02nERERKUFFRkp3Ig+WTXeOe46D0AizeUREREqhIiOlWzcXstOgTrzzIF8REREPpCIjJeUfheXPOce9HoKgMLN5REREyqAiIyWtfh2OHoC6TaHj7abTiIiIlElFRtwdPwQrX3aO+zwKAUFm84iIiJyBioy4+/4fkJsNDdrChUNNpxERETkjFRk57ch+WDXbOe77GNgDzOYRERE5CxUZOW3581BwDM7rAq2uNp1GRETkrFRkxCkrDda+6xz3mwI2m9k8IiIi5aAiI07LngVHATTrBef3Mp1GRESkXFRkBA5sh//Oc477TTGbRUREpAJUZMT5xZCWA1pdA426mE4jIiJSbkaLzOzZs2nfvj0RERFERESQmJjIV1995bo9NzeXkSNHEhMTQ3h4OEOHDiUzM9NgYh+0dyP8tACwOc9UEhER8SJGi0yjRo2YPn0669atY+3atfTt25fBgwezZcsWAMaOHcvnn3/ORx99REpKCnv37uX66683Gdn3LJnmvG5/E8S2NZtFRESkgmyWZVmmQxQVHR3Nc889xw033ED9+vWZN28eN9xwAwA///wzbdq0ITU1lW7dupVrezk5OURGRpKdnU1EhL7B2c2vK2Hu1WAPhFFrIPp804lERESA8r9+e8wxMoWFhXzwwQccPXqUxMRE1q1bR0FBAf3793et07p1axo3bkxqamqZ28nLyyMnJ8ftIqWwrNOzMZ3+phIjIiJeyXiR2bRpE+Hh4YSEhHDvvfcyf/582rZtS0ZGBsHBwURFRbmtHxsbS0ZGRpnbS0pKIjIy0nVJSEio5kfgpXZ+C2mpEBgKl08wnUZERKRSjBeZVq1asXHjRlavXs19993H8OHD+emnnyq9vUmTJpGdne26pKenV2FaH+FwQPKTzvGl/wMRDc3mERERqaRA0wGCg4Np0aIFAJ07d2bNmjW8/PLL3HzzzeTn55OVleU2K5OZmUlcXFyZ2wsJCSEkJKS6Y3u3nxZAxiYIrgM9x5lOIyIiUmnGZ2SKczgc5OXl0blzZ4KCgkhOTnbdtm3bNtLS0khMTDSY0MsVnnB+bgxA99FQK9psHhERkXNgdEZm0qRJDBw4kMaNG3P48GHmzZvHsmXL+Prrr4mMjOSuu+5i3LhxREdHExERwejRo0lMTCz3GUtSiv/+Gw7uhFoxkPh302lERETOidEis3//fv72t7+xb98+IiMjad++PV9//TVXXHEFADNnzsRutzN06FDy8vIYMGAAr732msnI3u1EHiyb7hz3HAchdczmEREROUce9zkyVU2fI1PEqtdh0cNQpyHcvx6CwkwnEhERKZXXfY6MVLO8I7D8Oee498MqMSIi4hNUZPzF6tlw7A/nB991GGY6jYiISJVQkfEHx/6Elf9wjvs8CgFBZvOIiIhUERUZf/D9LMjLhgbtoJ2+dFNERHyHioyvO5zpPMgXoN9ksOuPXEREfIde1Xzd8ufgxHFodClccJXpNCIiIlVKRcaXHfoV1s11jvtNAZvNZBoREZEqpyLjy5Y9C44COL8PNLvMdBoREZEqpyLjq/b/DD9+4Bz3m2w2i4iISDVRkfFVS58GywGtr4XzOptOIyIiUi1UZHzR7+th62eADfo+ZjqNiIhItVGR8UVLpjmvL74FGrQxm0VERKQaqcj4mt3fwa4lYA+C3hNNpxEREalWKjK+xLJOz8Z0Hg51mxqNIyIiUt1UZHzJjm8gfTUEhsHlE0ynERERqXYqMr7C4YDkk7MxXe+BOnFm84iIiNQAFRlfseVTyNwEIRHQY4zpNCIiIjVCRcYXFBY4PzcGoPv9UCvabB4REZEaoiLjCzbOgz9/gVr1oNu9ptOIiIjUGBUZb1eQCynPOseXPQghdczmERERqUEqMt5u7buQ8ztEnAddRphOIyIiUqNUZLxZ3mH47gXnuNfDEBRqNo+IiEgNU5HxZqtmw7E/ILo5dBhmOo2IiEiNU5HxVsf+hO//4Rz3fRQCAs3mERERMUBFxlutfAnyciD2Imh7nek0IiIiRqjIeKOcfbD6Tee432Sw649RRET8k14BvdF3z8OJ45DQFVpeaTqNiIiIMSoy3ubP3bBurnPcbwrYbEbjiIiImKQi422WTQfHCWjeD5r2NJ1GRETEKBUZb7J/K/z4f85xv8lms4iIiHgAFRlvsuQpwII2f4GGHU2nERERMU5Fxlv8vg5+/gJsdujzqOk0IiIiHkFFxlskT3Vet78FGrQ2m0VERMRDqMh4g19S4JdlYA+C3hNNpxEREfEYKjKezrJgyTTnuMudULeJ2TwiIiIeREXG021fBL+tgcAwuGy86TQiIiIeRUXGkzkckHxyNqbbvVAn1mweERERD6Mi48m2fAr7t0BIJHS/33QaERERj6Mi46kKC05+bgzQYzTUijabR0RExAOpyHiqDf+EQ7uhdn3oep/pNCIiIh5JRcYTFRyHlBnO8WXjISTcbB4REREPZbTIJCUlcckll1CnTh0aNGjAkCFD2LZtm9s6ubm5jBw5kpiYGMLDwxk6dCiZmZmGEteQNe/A4b0Q0ch5yrWIiIiUymiRSUlJYeTIkaxatYrFixdTUFDAlVdeydGjR13rjB07ls8//5yPPvqIlJQU9u7dy/XXX28wdTXLzYHvXnCOe0+EwBCzeURERDyYzbIsy3SIUw4cOECDBg1ISUnh8ssvJzs7m/r16zNv3jxuuOEGAH7++WfatGlDamoq3bp1O+s2c3JyiIyMJDs7m4iIiOp+COdu2XRYlgQxLeHvqyAg0HQiERGRGlfe12+POkYmOzsbgOho5xk669ato6CggP79+7vWad26NY0bNyY1NbXUbeTl5ZGTk+N28RpHD8L3rzjHfR9ViRERETkLjykyDoeDMWPG0KNHDy688EIAMjIyCA4OJioqym3d2NhYMjIySt1OUlISkZGRrktCQkJ1R686K2dC/mGIaw9tBptOIyIi4vE8psiMHDmSzZs388EHH5zTdiZNmkR2drbrkp6eXkUJq1nOXvjhLee43xSwe8wfjYiIiMfyiPcuRo0axRdffMHy5ctp1KiRa3lcXBz5+flkZWW5zcpkZmYSFxdX6rZCQkIICfHCA2SXPwcncqFxIrTof/b1RURExOyMjGVZjBo1ivnz57NkyRKaNWvmdnvnzp0JCgoiOTnZtWzbtm2kpaWRmJhY03Grz5+/wPr3neN+U8BmM5tHRETESxidkRk5ciTz5s3jP//5D3Xq1HEd9xIZGUlYWBiRkZHcddddjBs3jujoaCIiIhg9ejSJiYnlOmPJayxNAscJ50xMk+6m04iIiHgNo0Vm9uzZAPTu3dtt+Zw5c7jjjjsAmDlzJna7naFDh5KXl8eAAQN47bXXajhpNcrcAps+co77TjabRURExMt41OfIVAeP/xyZf98G2xZC2yFw03um04iIiHgEr/wcGb/z21pnibHZoc+jptOIiIh4HRUZk5KnOq8vvg3qX2A2i4iIiBdSkTHll2WwOwUCgqH3w6bTiIiIeCUVGRMs6/RsTJcRENXYbB4REREvpSJjwrYv4fd1EFQLLnvQdBoRERGvpSJT0xyFsOQp57jbfRDewGweERERL6YiU9M2fwL7f4LQSOg+2nQaERERr6YiU5MKC2Dp085xjwcgrK7ZPCIiIl5ORaYmrX8fDv0KtRtA13tNpxEREfF6KjI1peA4pMxwji+fAMG1zeYRERHxASoyNeWHt+BIBkQ2hs7DTacRERHxCSoyNSE3B1a86Bz3ngiBIWbziIiI+AgVmZqQ+iocPwT1LoD2N5tOIyIi4jNUZKrb0T8g9RXnuM+jEBBoNo+IiIgPUZGpbitmQv4RiO8AbQebTiMiIuJTVGSqU/bvzoN8AfpNBpvNbB4REREfoyJTnZbPgMI8aNIDmvcznUZERMTnqMhUl4O7YP3/Osd9NRsjIiJSHVRkqsvSZ8AqhJZXQpNE02lERER8kopMdcjYBJs/do77TjabRURExIepyFSHJSe/GLLd9RDf3mwWERERH6YiU9XSf4DtX4EtwPm5MSIiIlJtVGSqkmVB8lTnuMNtUK+F2TwiIiI+TkWmKv2yDH79DgKCodfDptOIiIj4PBWZqlJ0NqbLXRCVYDaPiIiIH1CRqSo/fwF710NQbbjsQdNpRERE/IKKTFVwFMKSp5zjxL9DeH2zeURERPyEikxV2PQRHPgZQqMgcZTpNCIiIn5DReZcnch3foovQM8xEBZlMo2IiIhfUZE5V+vfg6w9EB4Ll/4/02lERET8iorMucg/Bsufc44vnwDBtczmERER8TMqMufihzfhSCZENYZOw02nERER8TsqMpWVmw0rZjrHvR+BwGCzeURERPyQikxlff8K5GZBvVbQ/ibTaURERPySikxlFRxzfjFk38fAHmA6jYiIiF8KNB3Aaw14Gi79H4hqYjqJiIiI31KRORd1m5pOICIi4tf01pKIiIh4LRUZERER8VoqMiIiIuK1VGRERETEaxktMsuXL2fQoEE0bNgQm83GggUL3G63LIspU6YQHx9PWFgY/fv3Z8eOHWbCioiIiMcxWmSOHj3KxRdfzKuvvlrq7TNmzGDWrFm8/vrrrF69mtq1azNgwAByc3NrOKmIiIh4IqOnXw8cOJCBAweWeptlWbz00ks89thjDB48GID333+f2NhYFixYwC233FKTUUVERMQDeewxMrt37yYjI4P+/fu7lkVGRtK1a1dSU1PL/L28vDxycnLcLiIiIuKbPLbIZGRkABAbG+u2PDY21nVbaZKSkoiMjHRdEhISqjWniIiImOOxRaayJk2aRHZ2tuuSnp5uOpKIiIhUE48tMnFxcQBkZma6Lc/MzHTdVpqQkBAiIiLcLiIiIuKbPLbINGvWjLi4OJKTk13LcnJyWL16NYmJiQaTiYiIiKcwetbSkSNH2Llzp+vn3bt3s3HjRqKjo2ncuDFjxozhqaeeomXLljRr1ozJkyfTsGFDhgwZYi60iIiIeAyjRWbt2rX06dPH9fO4ceMAGD58OHPnzuWhhx7i6NGj3HPPPWRlZdGzZ08WLVpEaGhoue/DsiwAnb0kIiLiRU69bp96HS+LzTrbGl7ut99+05lLIiIiXio9PZ1GjRqVebvPFxmHw8HevXupU6cONputyrabk5NDQkIC6enpOqC4HLS/yk/7qvy0r8pP+6r8tK/Krzr3lWVZHD58mIYNG2K3l31Ir9G3lmqC3W4/Y5M7VzozqmK0v8pP+6r8tK/KT/uq/LSvyq+69lVkZORZ1/HYs5ZEREREzkZFRkRERLyWikwlhYSE8PjjjxMSEmI6ilfQ/io/7avy074qP+2r8tO+Kj9P2Fc+f7CviIiI+C7NyIiIiIjXUpERERERr6UiIyIiIl5LRUZERES8lopMGZYvX86gQYNo2LAhNpuNBQsWnPV3li1bRqdOnQgJCaFFixbMnTu32nN6goruq2XLlmGz2UpcMjIyaiawQUlJSVxyySXUqVOHBg0aMGTIELZt23bW3/voo49o3bo1oaGhXHTRRXz55Zc1kNasyuyruXPnlnheVeS72bzV7Nmzad++vetDyRITE/nqq6/O+Dv++JyCiu8rf31OlWb69OnYbDbGjBlzxvVq+rmlIlOGo0ePcvHFF/Pqq6+Wa/3du3dzzTXX0KdPHzZu3MiYMWO4++67+frrr6s5qXkV3VenbNu2jX379rkuDRo0qKaEniMlJYWRI0eyatUqFi9eTEFBAVdeeSVHjx4t83e+//57br31Vu666y42bNjAkCFDGDJkCJs3b67B5DWvMvsKnJ8wWvR5tWfPnhpKbE6jRo2YPn0669atY+3atfTt25fBgwezZcuWUtf31+cUVHxfgX8+p4pbs2YNb7zxBu3btz/jekaeW5acFWDNnz//jOs89NBDVrt27dyW3XzzzdaAAQOqMZnnKc++Wrp0qQVYhw4dqpFMnmz//v0WYKWkpJS5zk033WRdc801bsu6du1q/b//9/+qO55HKc++mjNnjhUZGVlzoTxY3bp1rbfffrvU2/SccnemfaXnlGUdPnzYatmypbV48WKrV69e1gMPPFDmuiaeW5qRqSKpqan079/fbdmAAQNITU01lMjzdejQgfj4eK644gpWrlxpOo4R2dnZAERHR5e5jp5bTuXZVwBHjhyhSZMmJCQknPV/2r6osLCQDz74gKNHj5KYmFjqOnpOOZVnX4GeUyNHjuSaa64p8ZwpjYnnls9/aWRNycjIIDY21m1ZbGwsOTk5HD9+nLCwMEPJPE98fDyvv/46Xbp0IS8vj7fffpvevXuzevVqOnXqZDpejXE4HIwZM4YePXpw4YUXlrleWc8tfzim6JTy7qtWrVrx7rvv0r59e7Kzs3n++efp3r07W7ZsqdYvj/UEmzZtIjExkdzcXMLDw5k/fz5t27YtdV1/f05VZF/583MK4IMPPmD9+vWsWbOmXOubeG6pyEiNa9WqFa1atXL93L17d3bt2sXMmTP53//9X4PJatbIkSPZvHkzK1asMB3F45V3XyUmJrr9z7p79+60adOGN954g2nTplV3TKNatWrFxo0byc7O5uOPP2b48OGkpKSU+QLtzyqyr/z5OZWens4DDzzA4sWLPfoAZxWZKhIXF0dmZqbbsszMTCIiIjQbUw6XXnqpX72gjxo1ii+++ILly5ef9X91ZT234uLiqjOix6jIviouKCiIjh07snPnzmpK5zmCg4Np0aIFAJ07d2bNmjW8/PLLvPHGGyXW9ffnVEX2VXH+9Jxat24d+/fvd5spLywsZPny5bzyyivk5eUREBDg9jsmnls6RqaKJCYmkpyc7LZs8eLFZ3zfVU7buHEj8fHxpmNUO8uyGDVqFPPnz2fJkiU0a9bsrL/jr8+tyuyr4goLC9m0aZNfPLeKczgc5OXllXqbvz6nynKmfVWcPz2n+vXrx6ZNm9i4caPr0qVLF4YNG8bGjRtLlBgw9NyqtsOIvdzhw4etDRs2WBs2bLAA68UXX7Q2bNhg7dmzx7Isy5o4caJ1++23u9b/5ZdfrFq1alkTJkywtm7dar366qtWQECAtWjRIlMPocZUdF/NnDnTWrBggbVjxw5r06ZN1gMPPGDZ7Xbr22+/NfUQasx9991nRUZGWsuWLbP27dvnuhw7dsy1zu23325NnDjR9fPKlSutwMBA6/nnn7e2bt1qPf7441ZQUJC1adMmEw+hxlRmXz355JPW119/be3atctat26ddcstt1ihoaHWli1bTDyEGjNx4kQrJSXF2r17t/Xjjz9aEydOtGw2m/XNN99YlqXnVFEV3Vf++pwqS/GzljzhuaUiU4ZTpwgXvwwfPtyyLMsaPny41atXrxK/06FDBys4ONg6//zzrTlz5tR4bhMquq+effZZq3nz5lZoaKgVHR1t9e7d21qyZImZ8DWstP0EuD1XevXq5dp3p3z44YfWBRdcYAUHB1vt2rWzFi5cWLPBDajMvhozZozVuHFjKzg42IqNjbWuvvpqa/369TUfvoaNGDHCatKkiRUcHGzVr1/f6tevn+uF2bL0nCqqovvKX59TZSleZDzhuWWzLMuqvvkeERERkeqjY2RERETEa6nIiIiIiNdSkRERERGvpSIjIiIiXktFRkRERLyWioyIiIh4LRUZERER8VoqMiLid5YtW4bNZiMrK8t0FBE5RyoyIiIi4rVUZERERMRrqciISI1zOBwkJSXRrFkzwsLCuPjii/n444+B02/7LFy4kPbt2xMaGkq3bt3YvHmz2zY++eQT2rVrR0hICE2bNuWFF15wuz0vL4+HH36YhIQEQkJCaNGiBe+8847bOuvWraNLly7UqlWL7t27s23btup94CJS5VRkRKTGJSUl8f777/P666+zZcsWxo4dy1//+ldSUlJc60yYMIEXXniBNWvWUL9+fQYNGkRBQQHgLCA33XQTt9xyC5s2beKJJ55g8uTJzJ071/X7f/vb3/j3v//NrFmz2Lp1K2+88Qbh4eFuOR599FFeeOEF1q5dS2BgICNGjKiRxy8iVUdfGikiNSovL4/o6Gi+/fZbEhMTXcvvvvtujh07xj333EOfPn344IMPuPnmmwH4888/adSoEXPnzuWmm25i2LBhHDhwgG+++cb1+w899BALFy5ky5YtbN++nVatWrF48WL69+9fIsOyZcvo06cP3377Lf369QPgyy+/5JprruH48eOEhoZW814QkaqiGRkRqVE7d+7k2LFjXHHFFYSHh7su77//Prt27XKtV7TkREdH06pVK7Zu3QrA1q1b6dGjh9t2e/TowY4dOygsLGTjxo0EBATQq1evM2Zp3769axwfHw/A/v37z/kxikjNCTQdQET8y5EjRwBYuHAh5513ntttISEhbmWmssLCwsq1XlBQkGtss9kA5/E7IuI9NCMjIjWqbdu2hISEkJaWRosWLdwuCQkJrvVWrVrlGh86dIjt27fTpk0bANq0acPKlSvdtrty5UouuOACAgICuOiii3A4HG7H3IiIb9KMjIjUqDp16jB+/HjGjh2Lw+GgZ8+eZGdns3LlSiIiImjSpAkAU6dOJSYmhtjYWB599FHq1avHkCFDAHjwwQe55JJLmDZtGjfffDOpqam88sorvPbaawA0bdqU4cOHM2LECGbNmsXFF1/Mnj172L9/PzfddJOphy4i1UBFRkRq3LRp06hfvz5JSUn88ssvREVF0alTJx555BHXWzvTp0/ngQceYMeOHXTo0IHPP/+c4OBgADp16sSHH37IlClTmDZtGvHx8UydOpU77rjDdR+zZ8/mkUce4e9//zsHDx6kcePGPPLIIyYerohUI521JCIe5dQZRYcOHSIqKsp0HBHxcDpGRkRERLyWioyIiIh4Lb21JCIiIl5LMzIiIiLitVRkRERExGupyIiIiIjXUpERERERr6UiIyIiIl5LRUZERES8loqMiIiIeC0VGREREfFaKjIiIiLitf4/JuYehChyeYUAAAAASUVORK5CYII=",
      "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": 21,
   "id": "8bda887e",
   "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": 22,
   "id": "1cc21154",
   "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",
   "id": "0133ff45",
   "metadata": {},
   "source": [
    "# Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e095b271",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.split_all_docs import split_all_docs\n",
    "from rouge_score import rouge_scorer\n",
    "from utils.threshold_probs import threshold_probs_by_prop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "273c6eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = COMPLEX_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4fc41994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "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": 26,
   "id": "3edbae7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_set = df_test\n",
    "test_set[\"doc_splited\"] = split_all_docs(test_set[args.doc_col_name], False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bb8ab07a",
   "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": 28,
   "id": "67659b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model:  88%|████████▊ | 88/100 [00:02<00:00, 40.86batch/s, accuracy=0.589, mae=0.709, rouge1=0.241, rouge2=0.0466, rougeL=0.144]\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m~/tmp/ipykernel_3385865/2184299873.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     44\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdoc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 46\u001b[0;31m             \u001b[0mtxt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtxt\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\". \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mdoc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindices\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     47\u001b[0m             \u001b[0my_pred_thresh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindices\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     48\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtxt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msummaries\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Eval model\")\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "                \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        y_pred = model(features, doc_lens)\n",
    "    \n",
    "        loss = criterion(y_pred, targets)\n",
    "\n",
    "        arr_loss.append(loss.item())\n",
    "\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "        summaries = test_set[args.sum_col_name].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",
    "        if indices.shape[0] > len(doc):\n",
    "            continue\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\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\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(accuracy = np.mean(accuracy), mae = np.mean(mae), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))\n",
    "        idx += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c1fd15f",
   "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",
   "id": "496646f2",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:00<00:00, 148.95batch/s, rouge1=0.406, rouge2=0.225, rougeL=0.309]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Lead-3\")\n",
    "        doc = test_set[\"doc_splited\"].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[args.sum_col_name].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\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\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": "markdown",
   "id": "78a3c5d9",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4c96c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 127.06batch/s, rouge1=0.435, rouge2=0.241, rougeL=0.325]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[args.sum_col_name].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\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\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,
   "id": "e4f4796c",
   "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 excute 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"
  },
  "vscode": {
   "interpreter": {
    "hash": "4f810f0bde7d7b5dc90f9e6832822547e13e234c53731a97fc91254323942f40"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}