05-train_HeterSUMGraph_CNN_DailyMail_TG_GATv2Conv.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train HeterSUMGraph_CNN_DailyMail"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import argparse\n",
    "from time import time\n",
    "import torch\n",
    "import numpy as np\n",
    "import random\n",
    "from sklearn.utils import shuffle\n",
    "import json\n",
    "import os\n",
    "import networkx as nx\n",
    "import torch_geometric\n",
    "from statistics import mean\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils.create_graph_dataset import create_graph_dataset\n",
    "from utils.GloveMgr import GloveMgr\n",
    "from utils.DataLoader import DataLoader\n",
    "from utils.MultiProcessusDataLoader import MultiProcessusDataLoader\n",
    "from utils.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils.split_all_docs import split_all_docs\n",
    "from utils.threshold_probs import threshold_probs_by_nb, threshold_probs_by_prop\n",
    "from utils.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_notebook() -> bool:\n",
    "    try:\n",
    "        shell = get_ipython().__class__.__name__\n",
    "        if shell == 'ZMQInteractiveShell':\n",
    "            return True   # Jupyter notebook or qtconsole\n",
    "        elif shell == 'TerminalInteractiveShell':\n",
    "            return False  # Terminal running IPython\n",
    "        else:\n",
    "            return False  # Other type (?)\n",
    "    except NameError:\n",
    "        return False      # Probably standard Python interpreter"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse args if script mode\n",
    "parser = argparse.ArgumentParser(description='extractive summary')\n",
    "\n",
    "parser.add_argument('-is_graphic',type=int,default=1,choices=[0,1])\n",
    "parser.add_argument('-gpu_num',type=int,default=0)\n",
    "parser.add_argument('-batch_size',type=int,default=4)\n",
    "parser.add_argument('-epochs',type=int,default=10)\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 10\n",
      "batch_size 4\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"glove.6B.300\"\n",
    "\n",
    "# hyper-parameters\n",
    "vocab_size = 150000\n",
    "batch_size = args.batch_size\n",
    "epochs = args.epochs\n",
    "learning_rate = 5e-4\n",
    "early_stopping = 3\n",
    "word_blacklist_proportion = 0.1\n",
    "model_name = \"05-train_HeterSUMGraph_CNN_DailyMail_TG_GATv2Conv\"\n",
    "sub_folder_name = \"model_name__{}__time__{}__embed_name__{}__lr__{}__batch_size__{}__vocab_size__{}__cuda_num__{}__early_stopping__{}\".format(model_name, time(), embed_name, learning_rate, batch_size, vocab_size, cuda_num, early_stopping)\n",
    "checkpoints_folder = \"./checkpoints/\" + sub_folder_name\n",
    "average_number_of_sentences_per_document = 3\n",
    "\n",
    "# print\n",
    "print(\"parse:\")\n",
    "print(\"is_graphic:\", is_graphic)\n",
    "print(\"cuda_num:\", cuda_num)\n",
    "print(\"epochs\", epochs)\n",
    "print(\"batch_size\", batch_size)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyTorch initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(0)\n",
    "random.seed(0)\n",
    "np.random.seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of available GPUs: 1\n",
      "GPU 0: NVIDIA GeForce RTX 3060\n"
     ]
    }
   ],
   "source": [
    "# Check if a GPU is available\n",
    "if torch.cuda.is_available():\n",
    "    # Display the number of available GPUs\n",
    "    print(f\"Number of available GPUs: {torch.cuda.device_count()}\")\n",
    "    # Display the name of each GPU\n",
    "    for i in range(torch.cuda.device_count()):\n",
    "        print(f\"GPU {i}: {torch.cuda.get_device_name(i)}\")\n",
    "else:\n",
    "    print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(\"./data/cnn_dailymail/test.json\")\n",
    "df_val = pd.read_json(\"./data/cnn_dailymail/val.json\")\n",
    "df_train = pd.read_json(\"./data/cnn_dailymail/train.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "glovemgr = GloveMgr(\"./data/glove.6B/glove.6B.300d.txt\", vocab_size=vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_sent = pd.read_json(\"data/cnn_dailymail_sent_tfidf.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_dataset = json.load(open(\"./data/cnn_dailymail_dataset_tfidf.json\"))\n",
    "tfidfs_dataset_sorted = sorted(tfidfs_dataset, key=tfidfs_dataset.get)\n",
    "word_blacklist = set(tfidfs_dataset_sorted[:int(word_blacklist_proportion*len(tfidfs_dataset_sorted))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = MultiProcessusDataLoader(buffer_size=30, dataset=df_train, batch_size=batch_size, shuffle=True, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"article\", labels_column_name=\"labels\", 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": [
    "val_dataset = create_graph_dataset(df=df_val, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"article\", labels_column_name=\"labels\", is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)\n",
    "val_loader =  DataLoader(val_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dataset = create_graph_dataset(df=df_test, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"article\", labels_column_name=\"labels\", is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)\n",
    "test_loader =  DataLoader(test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "from torch_geometric.nn.conv import GATv2Conv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Position Feed Forward\n",
    "class PositionwiseFeedForward(nn.Module):\n",
    "  def __init__(self, d_in, d_out, d_h, dropout=0.1) -> None:\n",
    "    super(PositionwiseFeedForward, self).__init__()\n",
    "    self.fc1 = nn.Linear(in_features=d_in, out_features=d_h)\n",
    "    self.fc2 = nn.Linear(in_features=d_h, out_features=d_out)\n",
    "    self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "  def forward(self, x):\n",
    "    x = torch.relu(self.fc1(x))\n",
    "    x = self.dropout(x)\n",
    "    return self.fc2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HeterSUMGraph(torch.nn.Module):\n",
    "  def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 300, num_iter=3):\n",
    "    super(HeterSUMGraph, self).__init__()\n",
    "    self.device = device\n",
    "    self.num_iter = num_iter\n",
    "\n",
    "    self.word_emb = nn.Embedding(vocab_size+2, dim_word_embed, padding_idx=0)\n",
    "\n",
    "    # Load word embedding if specified\n",
    "    if word_embed is not None:\n",
    "      self.word_embedding = torch.nn.Embedding.from_pretrained(torch.from_numpy(word_embed).float())\n",
    "\n",
    "    self.word_emb.weight.requires_grad = False\n",
    "\n",
    "    # edge_attr embed\n",
    "    self.edge_attr_embed = nn.Embedding(101, 50)\n",
    "\n",
    "    # sent CNN\n",
    "    dim_out_cnn = 64\n",
    "    self.convs = nn.Sequential(\n",
    "                            nn.Conv1d(in_channels=300,out_channels=100,kernel_size=3,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=100,kernel_size=4,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=dim_out_cnn,kernel_size=5,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=dim_out_cnn),\n",
    "                            nn.ReLU(inplace=True))\n",
    "\n",
    "    # sent LSTM\n",
    "    dim_out_lstm = 32\n",
    "    self.sent_LSTM = nn.LSTM(input_size=300, hidden_size=dim_out_lstm, batch_first=True, bidirectional=True)\n",
    "\n",
    "    # sent to word GAT\n",
    "    # TODO out_channels = 64\n",
    "    self.s2wGAT = GATv2Conv(in_channels=[128, 300], out_channels=300, heads=8, edge_dim=50, fill_value=0, share_weights=False)\n",
    "\n",
    "    # word to sen GAT\n",
    "    self.w2sGAT = GATv2Conv(in_channels=[300, 128], out_channels=128, heads=8, edge_dim=50, fill_value=0, share_weights=False)\n",
    "\n",
    "    # ffn sent to word\n",
    "    self.ffns2w = PositionwiseFeedForward(d_in=8*300, d_out=300, d_h=512)\n",
    "\n",
    "    # ffn word to sent\n",
    "    self.ffnw2s = PositionwiseFeedForward(d_in=8*128, d_out=128, d_h=512)\n",
    "\n",
    "    self.wh = nn.Linear(128, 1)\n",
    "\n",
    "  def max_pool1d(self, x, seq_lens):\n",
    "    out = []\n",
    "    for index,t in enumerate(x):\n",
    "      if seq_lens[index] == 0:\n",
    "        t = t[:1]\n",
    "      else:\n",
    "        t = t[:seq_lens[index],:]\n",
    "      t = torch.t(t).unsqueeze(0)\n",
    "      out.append(torch.avg_pool1d(t, t.size(2)))\n",
    "\n",
    "    out = torch.cat(out).squeeze(2)\n",
    "    return out\n",
    "\n",
    "  def forward(self, data):# In the real implémentation remove nb_sent\n",
    "    # edge attr embeddings\n",
    "    edge_attr = torch.floor(data.edge_attr * 100).int()\n",
    "    edge_attr = self.edge_attr_embed(edge_attr)\n",
    "\n",
    "    # features\n",
    "    Xw = data.x[0]\n",
    "    Xs = data.x[1]\n",
    "    sent_lens = torch.sum(torch.sign(Xs),dim=1).data\n",
    "    \n",
    "    # embeddings\n",
    "    Xw = self.word_emb(Xw)\n",
    "    Xs = self.word_emb(Xs)\n",
    "\n",
    "    # CNN\n",
    "    XsCNN = self.convs(Xs.permute(0,2,1))\n",
    "    XsCNN = torch.max_pool1d(XsCNN, XsCNN.size(2)).squeeze(2)\n",
    "\n",
    "    # LSTM\n",
    "    # TO DO: ask \n",
    "    XsLSTM, _ = self.sent_LSTM(Xs)\n",
    "    XsLSTM = self.max_pool1d(XsLSTM, sent_lens)\n",
    "    Xs = torch.cat((XsCNN, XsLSTM), dim=1)\n",
    "\n",
    "    Hw = Xw\n",
    "    Hs = Xs\n",
    "\n",
    "    edge_index_w_i = data.edge_index[1][data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_s_j = data.edge_index[0][data.edge_index[1] < len(data.x[0])] - Hw.shape[0]\n",
    "    edge_attr_w = edge_attr[data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_w = torch.stack([edge_index_s_j, edge_index_w_i])\n",
    "\n",
    "    edge_index_s_i = data.edge_index[1][data.edge_index[1] >= len(data.x[0])] - Hw.shape[0]\n",
    "    edge_index_w_j = data.edge_index[0][data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_attr_s = edge_attr[data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_index_s = torch.stack([edge_index_w_j, edge_index_s_i])\n",
    "\n",
    "    Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "    Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    for i in range(self.num_iter):\n",
    "      if i != 0: # H^1w = H^0w = Xw\n",
    "        Hw = self.s2wGAT(x=[Hs, Hw], edge_index=edge_index_w, edge_attr=edge_attr_w) + torch.cat([Hw] * 8, dim=1)\n",
    "        Hw = self.ffns2w(Hw)\n",
    "        Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "\n",
    "      Hs = self.w2sGAT(x=[Hw, Hs], edge_index=edge_index_s, edge_attr=edge_attr_s) + torch.cat([Hs] * 8, dim=1)\n",
    "      Hs = self.ffnw2s(Hs)\n",
    "      Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    res = self.wh(Hs)\n",
    "\n",
    "    res = torch.sigmoid(res).squeeze(-1)\n",
    "\n",
    "    return res\n",
    "\n",
    "  def save(self, fname):\n",
    "    torch.save(self.state_dict(), fname)\n",
    "\n",
    "  def load(self, fname):\n",
    "    self.load_state_dict(torch.load(fname))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HeterSUMGraph(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300).to(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "  os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[\"article\"])\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/25 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rsaid/anaconda3/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 25/25 [00:12<00:00,  2.07batch/s, accuracy=0.779, loss=0.543, mae=0.332]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.538, val mae = 0.319, val accuracy = 0.722, r1 = 0.303, r2 = 0.087, rL = 0.185\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:02<00:00, 12.13batch/s, accuracy=0.774, loss=0.525, mae=0.343]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.530, val mae = 0.347, val accuracy = 0.721, r1 = 0.299, r2 = 0.085, rL = 0.184\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:02<00:00, 11.86batch/s, accuracy=0.779, loss=0.521, mae=0.328]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.536, val mae = 0.323, val accuracy = 0.722, r1 = 0.303, r2 = 0.086, rL = 0.185\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:02<00:00, 12.13batch/s, accuracy=0.777, loss=0.524, mae=0.335]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.531, val mae = 0.355, val accuracy = 0.720, r1 = 0.311, r2 = 0.096, rL = 0.195\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:02<00:00, 12.28batch/s, accuracy=0.784, loss=0.53, mae=0.342] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.595, val mae = 0.275, val accuracy = 0.725, r1 = 0.290, r2 = 0.085, rL = 0.183\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:01<00:00, 12.53batch/s, accuracy=0.805, loss=0.429, mae=0.247]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.557, val mae = 0.363, val accuracy = 0.725, r1 = 0.317, r2 = 0.095, rL = 0.200\n",
      "Training duration = 32.81891059875488\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "arr_train_loss = []\n",
    "arr_train_mae = []\n",
    "arr_train_acc = []\n",
    "arr_val_loss = []\n",
    "arr_val_mae = []\n",
    "arr_val_acc = []\n",
    "\n",
    "t1 = time()\n",
    "\n",
    "for epoch in range(1, epochs+1):\n",
    "  # Train\n",
    "  model.train()\n",
    "  nb_batch_train = 0\n",
    "  total_train_loss = 0\n",
    "  total_train_mae = 0\n",
    "  total_train_acc = 0\n",
    "  with tqdm(train_loader, unit=\"batch\", total=len(train_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "      tepoch.set_description(f\"Epoch {epoch}\")\n",
    "      #if dev != \"cpu\":\n",
    "      #  torch.cuda.empty_cache()\n",
    "      doc_lens = batch[\"doc_lens\"]\n",
    "      data = batch[\"docs\"].to(device)\n",
    "      targets = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "      y_pred = model(data)\n",
    "\n",
    "      loss = criterion(y_pred, targets)\n",
    "      optimizer.zero_grad()\n",
    "      loss.backward()\n",
    "      nn.utils.clip_grad_norm_(model.parameters(), 2.0)\n",
    "      optimizer.step()\n",
    "      nb_batch_train += 1\n",
    "      total_train_loss += loss.item()\n",
    "\n",
    "      probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "      probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "      total_train_mae += mae_fn(probs_tensor, targets).item()\n",
    "      total_train_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "      tepoch.set_postfix(loss=total_train_loss/nb_batch_train, mae=total_train_mae/nb_batch_train, accuracy=total_train_acc/nb_batch_train)\n",
    "\n",
    "  # Save model\n",
    "  model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "  # Eval\n",
    "  model.eval()\n",
    "  nb_batch_val = 0\n",
    "  total_val_loss = 0\n",
    "  total_val_mae = 0\n",
    "  total_val_acc = 0\n",
    "  total_r1 = 0\n",
    "  total_r2 = 0\n",
    "  total_rl = 0\n",
    "\n",
    "  del loss\n",
    "  del y_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  for i, batch in enumerate(val_loader):\n",
    "    #if dev != \"cpu\":\n",
    "    #  torch.cuda.empty_cache()\n",
    "    doc_lens = batch[\"doc_lens\"]\n",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "    y_pred = model(data)\n",
    "\n",
    "    loss = criterion(y_pred, targets)\n",
    "    nb_batch_val += 1\n",
    "    total_val_loss += loss.item()\n",
    "\n",
    "    doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "    summaries = val_set[\"highlights\"].iloc[i]\n",
    "\n",
    "    indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for j in range(min(len(doc), y_pred.shape[0])):\n",
    "      txt = txt + \". \" + doc[indices[j]]\n",
    "      y_pred_thresh.append(indices[j])\n",
    "      if len(txt) >= len(summaries):\n",
    "        break\n",
    "\n",
    "    y_pred_thresh.sort()\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for j in y_pred_thresh:\n",
    "      txt = txt + \". \" + doc[j]\n",
    "\n",
    "    n = min(len(txt), len(summaries))\n",
    "\n",
    "    while n < len(txt) and txt[n].isalnum():\n",
    "      n += 1\n",
    "\n",
    "    txt = txt[:n]\n",
    "\n",
    "    #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "    scores = scorer.score(summaries, txt)\n",
    "    total_r1 += scores[\"rouge1\"].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",
    "  if len(arr_val_loss) >= early_stopping+1:\n",
    "    if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "      print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "      break\n",
    "\n",
    "  print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "\n",
    "  del loss\n",
    "  del y_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "  arr_train_mae.append(total_train_mae / nb_batch_train)\n",
    "  arr_train_acc.append(total_train_acc / nb_batch_train)\n",
    "\n",
    "  arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "  arr_val_mae.append(total_val_mae / nb_batch_val)\n",
    "  arr_val_acc.append(total_val_acc / nb_batch_val)\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_mae\"]  = arr_train_mae\n",
    "training_metrics[\"train_acc\"]  = arr_train_acc\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_mae\"]    = arr_val_mae\n",
    "training_metrics[\"val_acc\"]    = arr_val_acc\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "  json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Losses\n",
    "if is_graphic:\n",
    "  plt.plot(list(range(1, len(arr_train_loss) + 1)), arr_train_loss, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_loss) + 1)), arr_val_loss, label=\"val\")\n",
    "\n",
    "  plt.title(\"Loss\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"loss\")\n",
    "  plt.legend(loc=\"upper left\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAByZUlEQVR4nO3deVhV5drH8e9mRgQUBxxAQBxwTsEMzWxwyMoxh6wsK8vKOpWdOll2jlnvsVNWNmmZTVqOOTRoGZUDpuYQljnPIKKIAygo43r/WLoNRWVebPbvc137crP2s9e+l0vh5hnux2YYhoGIiIiIE3GxOgARERGR8qYESERERJyOEiARERFxOkqARERExOkoARIRERGnowRIREREnI4SIBEREXE6SoBERETE6SgBEhEREaejBEhEHM5nn32GzWbDZrOxbNmyi143DINGjRphs9m4/vrrL3o9JSUFT09PbDYb69evL/Azhg0bZv+Mgh4i4tjcrA5ARKS4fH19+fjjjy9KcpYvX87u3bvx9fUt8H3Tp08nKysLgI8//pioqKgC23l7e/PLL7+UaswiUjEoARIRhzV48GC+/PJL3n//ffz8/OzHP/74Y6Kjo0lLSyvwfZ988gm1a9cmJCSEmTNn8uabb+Lt7X1ROxcXF6655poyi19ErKMhMBFxWEOGDAFg5syZ9mOpqanMmzeP+++/v8D3/Pbbb/z1118MHTqUBx980N5eRJyLEiARcVh+fn4MGDCATz75xH5s5syZuLi4MHjw4ALf8/HHHwNw//33c8cdd1ClShX7sYLk5ORc9MjLyyvdCxGRcqcESEQc2v3338/atWvZvHkzYA5vDRw4sMD5PxkZGcyePZtrrrmG5s2b4+vry8CBA+1zhi6Unp6Ou7v7RY/u3buX+XWJSNnSHCARcWhdunQhPDycTz75hGHDhrFu3TreeOONAtvOmTOHtLS0fMNj999/P59//jmffvopr7zySr723t7erFix4qLz/H2+kYg4JiVAIuLQbDYb9913H++88w5nzpyhSZMmdO7cucC2H3/8MV5eXtx8882cOHECgNatWxMaGspnn33GSy+9hKurq729i4vLJVeIiYhj0xCYiDi8YcOGkZKSwgcffMB9991XYJsdO3awcuVKzpw5Q4MGDahevbr9sW/fPhITE1myZEk5Ry4iVlEPkIg4vPr16/PMM8+wbds27r333gLbnJvo/NFHH9GoUaN8r50+fZo+ffrwySefcMstt5R5vCJiPSVAIlIpvPrqq5d8LScnh2nTptGsWTOGDx9eYJtevXrxzTffcOTIEWrVqgVAXl4ea9asKbB927Zt8fT0LHngImIJJUAiUuktWrSIQ4cO8dxzz12yzUMPPcT8+fOZPn06o0aNAsyeoejo6ALb79y586KeJBFxHDbDMAyrgxAREREpT5oELSIiIk5HCZCIiIg4HSVAIiIi4nSUAImIiIjTUQIkIiIiTkcJkIiIiDgd1QEqQF5eHgcPHsTX1xebzWZ1OCIiIlIIhmFw8uRJ6tWrh4vL5ft4lAAV4ODBgwQHB1sdhoiIiBRDQkICQUFBl22jBKgAvr6+gPkX6OfnZ3E0IiIiUhhpaWkEBwfbf45fjhKgApwb9vLz81MCJCIi4mAKM31Fk6BFRETE6SgBEhEREaejBEhEREScjuYAiYiIlLPc3Fyys7OtDsMheXh4XHGJe2EoARIRESknhmFw6NAhTpw4YXUoDsvFxYWwsDA8PDxKdB4lQCIiIuXkXPJTu3ZtqlSpomK7RXSuUHFSUhINGjQo0d+fEiAREZFykJuba09+atSoYXU4DqtWrVocPHiQnJwc3N3di30eTYIWEREpB+fm/FSpUsXiSBzbuaGv3NzcEp1HCZCIiEg50rBXyZTW358SIBEREXE6SoBERESk3ISGhjJx4kSrw9AkaBEREbm866+/nquuuqpUEpd169bh4+NT8qBKSAmQiIg4lpxMsLmCq36EVRSGYZCbm4ub25XvSa1atcohoivTEJiIiDiO1ER4rz28395MhKTMDRs2jOXLl/P2229js9mw2Wx89tln2Gw2lixZQlRUFJ6ensTGxrJ792769OlDYGAgVatWpX379vz000/5znfhEJjNZmPq1Kn069ePKlWq0LhxY7755psyvy4lQCIi4hiy0mHWEDixH47tgd1LrY6oRAzDICMrx5KHYRiFjvPtt98mOjqaBx98kKSkJJKSkggODgbg2WefZfz48WzdupXWrVtz6tQpbrnlFn766Sfi4uLo0aMHvXr1Ij4+/rKf8dJLLzFo0CD+/PNPbrnlFu666y6OHTtWor/fK1H/oYiIVHx5ebBgBCT9cf7Y5gXQ9GbrYiqh09m5NP/3Eks+e8u4HlTxKFwK4O/vj4eHB1WqVKFOnToAbNu2DYBx48bRrVs3e9saNWrQpk0b+9evvPIKCxYs4JtvvuGxxx675GcMGzaMIUOGAPDf//6Xd999l7Vr13LzzWV3f9UDJCIiFd/SV2Drt+DqAV1fMo9tX6xhMItFRUXl+zo9PZ1nn32W5s2bU61aNapWrcq2bduu2APUunVr+3MfHx98fX1JTk4uk5jPUQ+QiIhUbH/Mgtg3zOe934VWg+C3D+HkQdj9CzTtaW18xeTt7sqWcT0s++zScOFqrmeeeYYlS5YwYcIEGjVqhLe3NwMGDCArK+uy57lwSwubzUZeXl6pxHgpSoBERKTiil8D3zxuPr92FLS5w3zeoi+smXR2GMwxEyCbzVboYSireXh4FGrridjYWIYNG0a/fv0AOHXqFPv27Svj6IpHQ2AiIlIxHd8Ps+6C3CyIuA1ufPH8ay3MH7BsWwzZZ6yJz4mEhoby22+/sW/fPlJSUi7ZO9OoUSPmz5/Pxo0b+eOPP7jzzjvLvCenuJQAiYhIxXMmDWbeARkpUKc19J8CLn/7kVU/CvyCIOsk7P7ZujidxD//+U9cXV1p3rw5tWrVuuScnrfeeovq1avTsWNHevXqRY8ePWjXrl05R1s4NqMoa+GcRFpaGv7+/qSmpuLn52d1OCIiziUvF2YOgZ1LoGodePAX8K9/cbsfnoc170OrgXD71PKPs4jOnDnD3r17CQsLw8vLy+pwHNbl/h6L8vNbPUAiIlKx/Piimfy4ecGQGQUnP3B+GGz795B9uvzik0pBCZCIiFQcGz4ze3UA+k6G+pGXbhsUBf7BkHUKdv106XYiBVACJCIiFcPeFbDoafP59c9Dy/6Xb2+zQfM+5vPNC8o2Nql0lACJiIj1ju6G2UMhLwdaDoAuzxbufS3OJknbf9AwmBSJEiAREbHW6eMwYxCcOWGu7urzntm7Uxj124F/A8hOh50xZRqmVC5KgERExDq52TDnXji6y1zWfscMcPcu/PttNrMoImgYTIpECZCIiFjDMOD7f8He5eDuA3fOAt/Aop/n3GqwHT9AVkbpxiiVlhIgERGxxtopsP5jwGbW8anTqnjnqdcWqoVAdgbs/LFUQ5TKy/IEaNKkSfZiRpGRkcTGxl6y7cqVK+nUqRM1atTA29ubiIgI3nrrrXxtPvvsM2w220WPM2dUKl1EpMLY+RP88Jz5vNtLEHFL8c+lYTApBksToNmzZ/Pkk0/ywgsvEBcXR+fOnenZs+clS2z7+Pjw2GOPsWLFCrZu3cqYMWMYM2YMU6ZMydfOz8+PpKSkfA9V3RQRqSCSt8FX94GRB1fdDR3/UfJz2ofBlkBWesnPJ6UqNDSUiRMnWh1GPpYmQG+++SYPPPAAw4cPp1mzZkycOJHg4GAmT55cYPu2bdsyZMgQWrRoQWhoKHfffTc9evS4qNfIZrNRp06dfA8REakA0o+aK74y06BBR7jtrcKv+LqculdB9VDIOW0mQSJXYFkClJWVxYYNG+jevXu+4927d2fVqlWFOkdcXByrVq2iS5cu+Y6fOnWKkJAQgoKCuO2224iLi7vseTIzM0lLS8v3EBGRUpaTCbPvhhP7zWRl8Bfg5lE657bZzvcCaRhMCsGyBCglJYXc3FwCA/PP+A8MDOTQoUOXfW9QUBCenp5ERUUxcuRIhg8fbn8tIiKCzz77jG+++YaZM2fi5eVFp06d2Llz5yXPN378ePz9/e2P4ODgkl2ciIjkZxjw3VMQvwo8/WDIbPCpUbqfcS4B2hkDmadK99xO7MMPP6R+/frk5eXlO967d2/uvfdedu/eTZ8+fQgMDKRq1aq0b9+en36q+FuTWD4J2nZB16dhGBcdu1BsbCzr16/ngw8+YOLEicycOdP+2jXXXMPdd99NmzZt6Ny5M3PmzKFJkya8++67lzzf6NGjSU1NtT8SEhJKdlEiIpLfr2/Dxi/B5gIDP4XaEaX/GXVaQ0BDcxhspwMMgxmGOV/JiodhFDrMgQMHkpKSwtKlS+3Hjh8/zpIlS7jrrrs4deoUt9xyCz/99BNxcXH06NGDXr16XXI+b0XhZtUH16xZE1dX14t6e5KTky/qFbpQWFgYAK1ateLw4cOMHTuWIUOGFNjWxcWF9u3bX7YHyNPTE09PzyJegYiIFMq2RfDTWPP5za9Co65l8znnhsFi3zCHwVreXjafU1qyM+C/9az57OcPgodPoZoGBARw8803M2PGDG666SYA5s6dS0BAADfddBOurq60adPG3v6VV15hwYIFfPPNNzz22GNlEn5psKwHyMPDg8jISGJi8pcuj4mJoWPHjoU+j2EYZGZmXvb1jRs3Urdu3WLHKiIixZT0J8x7EDAg6gG4+qGy/bx8w2Any/aznMhdd93FvHnz7D9vv/zyS+644w5cXV1JT0/n2WefpXnz5lSrVo2qVauybds29QBdzqhRoxg6dChRUVFER0czZcoU4uPjefjhhwFzaCoxMZFp06YB8P7779OgQQMiIsyu05UrVzJhwgQef/xx+zlfeuklrrnmGho3bkxaWhrvvPMOGzdu5P333y//CxQRcWYnD8PMIeY+XQ2vh57/K50VX5cT2BJqNDK31tixBFoNKNvPKwn3KmZPjFWfXQS9evUiLy+PRYsW0b59e2JjY3nzzTcBeOaZZ1iyZAkTJkygUaNGeHt7M2DAALKyssoi8lJjaQI0ePBgjh49yrhx40hKSqJly5YsXryYkJAQAJKSkvJlkHl5eYwePZq9e/fi5uZGeHg4r776KiNGjLC3OXHiBA899BCHDh3C39+ftm3bsmLFCq6++upyvz4REaeVfRpmDYG0A1CjMQz8HFzdy/5zbTZo3hdiJ5jDYBU5AbLZCj0MZTVvb2/69+/Pl19+ya5du2jSpAmRkZGAOS932LBh9Otn9r6dOnWKffv2WRht4ViaAAE8+uijPProowW+9tlnn+X7+vHHH8/X21OQt95666Lq0CIiUo4MA74eCYkbwKsa3DkbvKuV3+e36GcmQDtj4EwaePmV32dXYnfddRe9evVi8+bN3H333fbjjRo1Yv78+fTq1QubzcaLL7540YqxisjyVWAiIlLJLH8N/poHLm5mrZ8a4eX7+YEtzF6n3Exzg1QpFTfeeCMBAQFs376dO++80378rbfeonr16nTs2JFevXrRo0cP2rVrZ2GkhWN5D5CIiFQif82HZf81n9/6JoR1Lv8Yzq0GW/GaOQzWelD5x1AJubq6cvDgxXOWQkND+eWXX/IdGzlyZL6vK+KQmHqARESkdBzYAAsfMZ9HPwaR91oXy7nVYLt+MofBRC6gBEhEREouNdGc9JxzBhr3gG7jrI2ndjOo2RRys2D799bGIhWSEiARESmZrHSYeQecOgy1m8PtU8HF1dqYtDeYXIESIJGiSj9qdQQiFUdeHsx/CA79CVVqwpBZFWfVVYu+5p+7f4bTJ6yMRCogJUAihWUYEPNveL0hzLkHss9YHZGI9X4ZB9u+A1cPuGMGVA+xOqLzajeDWhEVbhjMKMI+XHKx0vr7UwIkUlhL/2tu6Aiw5WuY3g9OH7c2JhErbZwBK8/WXev9HjToYG08BalAw2Du7mYhyIyMDIsjcWznKky7upZsmFXL4EUKI/YNc0ktwNUj4I9ZEL8KPrkZ7voKqgVbG59Iedu/Gr75h/m889PQZrC18VxK876wbDzs/sX8hcW7umWhuLq6Uq1aNZKTkwGoUqUKtrLeGqSSycvL48iRI1SpUgU3t5KlMEqARK5k9ST4+eyKlm7joNMTEDkMvrgdjmyDj7uZSVCdlpaGKVJuju+D2XdBXjY06w03jLE6okurHWFOzE7eAtsWQ9u7LA2nTp06APYkSIrOxcWFBg0alDh5VAIkcjnrPoYlo83n1z9vJj8Agc1heAx8MQCObIVPe8IdX0LYddbFKlIezqTBjDsg4yjUbQP9PgCXCj6bokU/MwHavMDyBMhms1G3bl1q165Ndna2pbE4Kg8PD1xK4d+czdBsrIukpaXh7+9Pamoqfn4VZDWDlL+NM84Xdbv2KbjpPxfvZH36BMy6E/b/ak4C7Tu5Ym++KFISuTnmcvddMVC1Djy0FPzqWR3VlR3ZAe+3N7fmeGaXpcNgUraK8vO7gqftIhb5a565mSNAh4cLTn7A3ODx7vnmPIPcLJj3AKx6rzwjFSk/MS+ayY+bNwyZ6RjJD0CtJhDYEvJyYNsiq6ORCkIJkMiFtn4H8x4EI8+c63PzqwUnP+e4e8GAT6HD2d6iH1+AH54366OIVBbrP4U1k8zn/T6A+hV/s8t8ztUEqgCrwaRiUAIk8nc7f4K5w8DIhdZ3wK1vXT75OcfFBW4eD91eNr9e877ZG5STWabhipSLPcth8T/N5zeMOZ9MOJLmZ5fD71kGGccsDUUqBiVAIufsWX5+ZUvzvtDn/aJN7rTZoNM/oP9UcHGHzfPNlWKqQCuOLGUXzBlqDh+1GgTX/dPqiIqnZiMIbHV2GOw7q6ORCkAJkAhA/BpzcmfOGWh6i7mXkWsxF0m2Hgh3zwMPX9gXa64QS00s3XhFysPp4zBjEJxJhaD20PvdwvWIVlQaBpO/UQIkkrjBXM6enQHhN8HAz8DVvWTnbNgF7v/eXCmTvMWsFZS8tVTCFSkXudnmli/HdoN/sLnNhbuX1VGVzLmq0HuWa08/UQIkTu7QJpjeH7JOQmhnGPwFuHmWzrnrtDJrBdVsAmmJ8EkP2L+qdM4tUpYMAxY/A3tXgEdVc4PTqrWtjqrkaoRDndbmHL9t31odjVhMCZA4r+RtMK0vnDkBQVeb3+Q9qpTuZ1RrAPcvgeBrzGGEaX1h88LS/QyR0vbbB7DhU8BmDgdXpirnFWhvMLGWEiBxTkd3w7Q+kJECda+Cu78Cz6pl81lVAuCehRBxG+RmmqvMfvuwbD5LpKR2xsCS583n3V+Gpj2tjae0nZsHtDcW0lMsDUWspQRInM/x/fB5bzh1CGq3gKELwMu/bD/T3RsGTYP2wwEDvn8WYv6tWkFSsSRvhbn3mTWw2t4N0Y9ZHVHpC2ho/tJj5MJWDYM5MyVA4lzSDsK03pB2wJybc8/XZg9NeXBxhVsmmFWlAX59GxaMgJys8vl8kctJT4EZg835cCHXFr4GliPSMJigBEicyalks+fn+D6oHmomP1VrFfrt6Zk5zF2fwHPz/mTRn0nk5RVjGz2bDTqPgr4fmPsSbZoDXw4wN5gUsUpOJsy6C07sh+phMHg6uHlYHVXZOTcMti8WTh2xNBSxjnaDF+eQccycgHx0p7mk995vC7WPkWEYbNh/nDnrE1j0ZxLpWbkAzFqXQKv6/jzToymdG9fEVtTflK8aYq6qmXMP7F0On95izkPyrVOMixMpAcOAb5+AhDXg6Q93zim/XlGrVA+Fem3hYBxs/QbaP2B1RGIB9QBJ5Xf6BEzvC8mbzbo893xtrs66jEOpZ3h/6S5uemM5Az5YzZz1B0jPyiW0RhWGXB2Mj4crmxJTueeTtdz50W/ExR8velyNboJhi8CnNhzeBFO7mbtWi5SnXyfCHzPB5goDPzU3DnUGGgZzejbDMIrRj1+5paWl4e/vT2pqKn5+flaHIyWRedKs83NgLVSpCfcthlpNC26ak8vPW5OZsz6BFTuOcG6Eq4qHK7e2qsvAqGDah1bHZrNx9FQmk5btZvrq/WTlmhOZe7QI5J/dm9I40LdoMR7ba26ZcWw3eFeHIbOhQYeSXLVI4Wz9DmbfDRjm/LSrH7Q6ovJzfD+83RpsLjBqG/gGWh2RU0nNyCbtTDbBAaVbeqQoP7+VABVACVAlkZUBXw6E/SvBqxoM+84sTniBzQdTmbv+AAs3JnIiI9t+/OrQAAZEBXFrq7r4eBY8Wpx44jQTY3Yw7/cD5BngYoP+7YJ4smtjgqoX4T92+lFzy4HE9eDmBbd/DM1uK+oVixRe0h/wyc1mBfT2D8KtE6yOqPx9dKNZCd7Zkj8LnM7KZf3+Y/y66yirdqfwV2IqNzUL5KN7okr1c5QAlZASoEog+wzMGgK7fwFPP3PYq347+8vH07P4emMiczccYPPB8xOQ6/h5cXtkfQZEBhNW06fQH7cr+SQTluzgh82HAPBwdeHua0IYeUM4NaoWsrJ0VgZ8dT/s+N78rfSW188umxcpZScPmT/80xIh/Ea4c27x975zZKvehR/HmKve7ltkdTSVSk5uHn8cSGXVrhR+3Z3C7/tP2HvLz2nboBrzH+lY9DmUl6EEqISUADm43GyYPdRMJNx9zDo/DTqQm2ewYucRvlp/gJgth+3/GT1cXejWIpCBkUF0blwLV5fi/2fcmHCC137Yxqrd5j5DPh6uDO/ckOGdw/D1KsT+Yrk5sGgU/P65+XXnp+HGFyvvcmQpf9mnzUn3B383S0E8EAPe1ayOyhon4mFiK8AGT2/XMFgJ5OUZbD98kl93pbBq91HW7j3GqcycfG3q+nvRMbwmnRrVoGN4Ter4l/7eckqASkgJkAPLzYF5D8CWheZQ0l1z2esbydz1Ccz/PZFDaWfsTVvU82NQVDC929Sjuk/pLvlduTOF//2wjU2JqQAE+Hgw8oZG3NWhAV7urpd/s2HAitdh6f+ZX7e5E3q/U/INWkUMw+xl3DzfnG82/GdzfyxnNrUrHFinYbBiiD+awa+7U/h1Vwqrdx/laHr+mmbVqrgT3bAGHRvVpFN4DcJq+pRqb09BHCoBmjRpEq+//jpJSUm0aNGCiRMn0rlz5wLbrly5kn/9619s27aNjIwMQkJCGDFiBE899VSB7WfNmsWQIUPo06cPCxcuLHRMSoAcVF4eLHwE/pyF4epBbOQ7vBsfwrp951doVa/iTp+r6jMwKogW9cq2+rNhGPzw1yFe/3E7e46kA1DP34snuzWhf9v6uLleYRHm79PN5clGrrlL/aBpZbddhziHpeNh+avg4m5uzxJ6rdURWW/1++bWHyGdzEUScklHTmayancKq3Yd5dfdKRw4fjrf697urrQPC6BTeA06NapJ87p+uJSgR704HCYBmj17NkOHDmXSpEl06tSJDz/8kKlTp7JlyxYaNLh4mXJcXBzbtm2jdevW+Pj4sHLlSkaMGMFbb73FQw89lK/t/v376dSpEw0bNiQgIEAJUGVnGBjfPoHt98/JxZUn8p7iuyxzzo+LDbo0qcXAqGBualYbT7cr9MCUspzcPOb9foCJP+0kKdXsgWpUuyr/7N6EHi3qXP43oh0/wtx7zYmqda+Cu+ZWjl25pfxt+srsHQXo/R60G2ptPBVF6gF4qwVgg1Fbwa+u1RFVGGlnsvltzzF7D8/2wyfzve7mYqNtg2pnh7VqclVwNTzcrK2u4zAJUIcOHWjXrh2TJ0+2H2vWrBl9+/Zl/PjxhTpH//798fHxYfr06fZjubm5dOnShfvuu4/Y2FhOnDihBKgSSzqRQfLcp2iTOItcw8YT2Y/xXV40DWv6MCAqiP5tg8pkrLmozmTn8sWa/by3dJd9tVmb4Gr8q0dTOjaqeek3Jm6ALweZG7dWCzHnNDn7sIUUzYH15ryf3Ezo+Dh0f8XqiCqWqd3MUhk9X4MOI6yOxjJnsnP5ff/xs8NaR9mUmEruBRXvm9f1M+fwNKrJ1aEBl1wha5Wi/Py2LPKsrCw2bNjAc889l+949+7dWbVqVaHOERcXx6pVq3jllfz/mceNG0etWrV44IEHiI2NveJ5MjMzyczMtH+dlqZtCSq6zJxcYrYcZu66BKL3vsvDbuamhi8aj+DTbhBfRQURGVK9zMebi8LL3ZwQPah9MFNX7GHqyr38kXCCO6f+RufGNXmmR1NaB1W7+I31I+GBH81aQcf3wsfdzGq9QaW7fFQqqdQDMHOImfw0uRm6vmR1RBVPi35mArR5gVMlQLl5BpsSU89OXE5h/b7jZObkX6kVWqPK2Tk8NYkOr0FAKc+XtJJlCVBKSgq5ubkEBuafdR8YGMihQ4cu+96goCCOHDlCTk4OY8eOZfjw80uFf/31Vz7++GM2btxY6FjGjx/PSy/pm4Ij+CsxlbnrE1i48SCpp7N5wnUeD7ubyc+GVv9hTK9/UMWjYv1GciE/L3dGdW/K0OhQ3l+6iy9/20/szhRid6ZwS6s6PN29KeG1LpjrUyPcXK0zY6BZvv+z22DgZ9D0ZkuuQRxE5imYcQekJ0NgS7h9qrkpr+TXvA8sGQ3xq80NkwuxTY4jMgyDncmnzi5NP8qaPUc5eSb/Sq3avp50alSTjuFmL0/9at4WRVv2LP9JceFv6IZhXPG39tjYWE6dOsWaNWt47rnnaNSoEUOGDOHkyZPcfffdfPTRR9SseZkhhQuMHj2aUaNG2b9OS0sjODi4aBciZeZYehYL48yaPVuTzvfO/dPnex7LnWd+0WM8kdGPWhRh8dTy9WRs7xY8cG0Yb/20gwVxiSzedIglmw8zMDKIJ7o2pq7/3775VK0F934Hc4fBrhizztFtb0HkMKsuQSqyvDyY/5C5zYpPLRgyEzyLWKXcWfjXh+BrzP3QtnwN1zxidUSl5sDxDPuk5VW7j3LkZGa+1/283LimoTlpuVOjGoTXqlqhes7LkmUJUM2aNXF1db2otyc5OfmiXqELhYWFAdCqVSsOHz7M2LFjGTJkCLt372bfvn306tXL3jYvz+zOc3NzY/v27YSHXzx3wtPTE0/PQhark3KRk5tH7M4U5qxP4Keth8nONcehPdxc6N48kCd9l9Jow9l5Xzf9Gxws+fm74IAqvDnoKkZcF86EH7cTs+Uws9YlMD8ukXujQ3j0+kbnl+l7VjV/kH33JMR9Ya4SS0uC659TrSDJ7+eXYPsicPWEO2Zccf87p9ein5kAbV7g0AnQ0VOZrN5z1F5xef/RjHyve7q5cHVYANHhNegUXpOW9f1LVPvMkVmWAHl4eBAZGUlMTAz9+vWzH4+JiaFPnz6FPo9hGPb5OxEREWzatCnf62PGjOHkyZO8/fbb6tVxAHuOnGLuhgPM23CA5L/9ptKqvj8Do4Lo3aYe1bbOgG/HmS9c96xZLLASaFrHl4/uiWLD/uO89sM2ftt7jI9i9zJrbQIPXteQB64NMyccurqbq3h868GK18xlzWmJcNtE56zmKxeL+9Lc5BSgz3sQfLWl4TiE5r3hh+cg4TdITTR7hRzAqcwc1u01V2r9uvtovl5yAFcXG22C/M8Oa9WkXUi1cl8JW1FZ+t1y1KhRDB06lKioKKKjo5kyZQrx8fE8/PDDgDk0lZiYyLRp0wB4//33adCgAREREYBZF2jChAk8/vjjAHh5edGyZct8n1GtWjWAi45LxXEqM4dFfx5kzvoDbNh/vmZPgI8Hfc/W7GlW9+xs/j9mw7dPms87Pg43PF/+AZexyJDqzHroGlbsTOG1H7ax+WAab8bsYNrqfTx2QyOGdGhgfgO78QVzye6ipyFuOpxKNnfz9ij8Fh5SCe1fZfYMAlz3DLQeZG08jsKvHjSIhvhV5jBYBe1VzszJJS7+hH0ezx8JJ8i5YKVWRB1fe8Xlq8MCCleF3glZmgANHjyYo0ePMm7cOJKSkmjZsiWLFy8mJCQEgKSkJOLj4+3t8/LyGD16NHv37sXNzY3w8HBeffVVRoxwnln7lYVhGPy29xhz1x9g8aYkTmfnAmbNnhua1mZgVBA3RgTmrymxeQEsfBgwzM0bu71caYd9bDYbXZrUonOjmizalMQbP25n39EMxn67hY9i9zKqWxP6tq2Pa9T9ULWOWd135xJzcvRdc8Gn8HPgpBI5thdm3QV52ebE3usr3y8IZapFPzMB2rygwiRAuXkGWw6m2Ssur9t3jDPZ+VdqNQioYp+03DG8BjULu/+gk7O8EnRFpDpAZefgidPM23CAr34/kG9sOryWDwOjgunftj61/Qqo2bP9e5h9N+TlQNuh0OsdcLG24FZ5ys7NY+76A7z98w4Op5lDg00Cq/LP7k3p1jwQ24F1MGMwnD4GAQ3h7nnmn+I8zqSa9WxStptFM+/7HjyqWB2VYzl5CN6IAAx48i+oVv7TJgzDYE9KutnDs+soq/ccJfV0dr42Nat65NtTKzhA9/kchymEWFEpASpdZ7Jz+XHLYeauT2DlrhTO/Yur6ulGrzZ1GRAZTLsG1S698mDXzzDzDsjNglYDod+HTruU93RWLp+v3sfkZbvt3xTbNqjGv26O4Bq/Y/BFf3ODR59aZq2g+u0sjljKRW4OzBgEu38G37rw4C+Vdil3mfv0Ftj/K3T/P+j4WLl8ZFLqaXPS8tmNRP++ZyGAr6cbHRoG2CsuNwl0npVaRaUEqISUAJWcYRj8lZjGnPUJfL0xkbS/1Zq4pmEAg6KCubllnSvX7Nm3Er4YADmnoVlvGPCpJvoCqaezmbJiN5+s3GcfPuzSpBajO1cn4uf74dCf4O4Dgz6Hxt0sjlbK3Pf/gt8+ADdvuP97qNfW6ogc19qPYPE/oX4UPPhzmXzEiYwsVu8+uzR911H2pKTne93DzYXIBtXtFZdb1/e/8t6BAigBKjElQMV39FQmCzceZO76BLYdOr9vTP1q3tzerj4DIoNpUKOQ3bUJa2FaX8hOh8Y9YPAX4FZ5qpCWhuS0M7z7yy5mro23T4S8vaU/L2e+RpWE5WBzhd7vQtu7LI5Uysy6j2HR2Tpmg6abq5mk+E4ehjeaAgY88SdUDynxKTOycli37/jZicspbD6Yxt9/8rrYoFVQNfsmopEh1fFyd85e7pJSAlRCSoCKJic3j+U7jjBnfQK/bEvOV7Pn5hZ1GBQVTMfwGkXbFfjgRvi8N2SmQsPrYchscLd+P6+Kav/RdN6K2cHXfxzEMMDLJZcZgV/Q7vgSs8GNY6DzPyvtpHGntXupuUWKkQs3vgjX/dPqiCqHz26DfbHmQotO/yjy27Nz89iYcOLsFhNHiYs/bv++eE7j2lXtFZc7NKyBv7dWapUGJUAlpASocHYln2LuhgTm/56Yr7pomyB/BkQF07t1PfyrFOM/9eHN8NmtcPo4NOgId3+lpd2FtDUpjQlLtvPztmTA4DmPOTzs8rX5YtT9cMsEp50/Vemk7ISpN5mTn1sPNufGKcEtHeummuUl6kea86muIC/PYOuhNHvF5bV7j5GRlZuvTf1q3nQ828PTMbxGwYs9pMSUAJWQEqBLO3kmm+/+TGLu+gR+jz9hP17Dx4N+beszMCqYpnVKUG7/yA747BZIP2KOwd+zUOX7i2HdvmP87/ttrN9/nKGuP/KS++e4YJDTpCduAz7R6iBHl3EMpnaFY7shuAPc8416SEvTqWRzGMzIK3AYzDAM9h/NsM/hWb3nKMfSs/K1CfDxsFdb7tSoBg0CqmjicjlQAlRCSoDyy8szWLP3KF+tP8Div5LsNShcXWz2mj03NK2dv2ZPcRzbY67AOJkEdVrBvd+Cd/VSuALnZBgGS7cn89oP2wlJ/oV33N/D05ZNcrU2VLt/Ph5+qhXkkHKzYXo/c4jGv4HZQ1G1ltVRVT6f94K9K6DbOOj0BMlpZ+wJz6rdR0k8cTpfcx8PV64OC7BXXI6o41u0YX8pFUX5+a3lNHJJB45nMG9DIl/9nkDCsfP/2RvVrsqgqCD6tq1Pbd9S+q3zRAJ83sdMfmo1g6FfK/kpIZvNxo0RgVzfpDbf/hnOqO9r8X9n/o/aJ/5g/1vXsb3rZ3SNbq9v0o7EMMyhmX2x4FEV7pyl5KeMnG7SG++9K0j8dQb3/nYVu5JP5Xvd3dVGuwbV7fV42gRXw10rtRyKEiDJ50x2Lks2H2Lu+gP8uvt8zR5fTzdua1OPQVFBXBV8mZo9xZGWBNN6Q2o81GgE93wNPjVK7/xOzsXFRp+r6tOz5SN8v7QZV//6ICFGIt4/DuTx1WO5/bZbuKFpbXXPO4I1k+H3zwEbDPgEAltYHVGlcSY7l/X7jp/t5UnhYKIPazxs1M/YRmbmbmy2QFrW86djI3NYq31oAN4emk/nyDQEVgBnGwIzDIM/D6Qyd0MCX288yMm/1ezpGF6DQVHB9GhRp2z+s6enmMNeKduhWohZvdZBNiF0VKePJpD+ST9qpu/kpOHNI9lPktngOp69OYL2oQFWhyeXsuNHmDnYnJdSjkX6Kquc3Dz+OJBqX5r++/4TZOXm32Jins+rROb+yfaWTxN4y3NUq6IyHBWd5gCVkLMkQCmnMlkYl8ic9QnsOHy+e7d+NW8GRAYxIDKobEusZxwzl7of3gR+9eG+xVA9tOw+T847k0r2jDtxj19JtuHKM9kjWJh3LTdG1OaZHk3Pbz4rFcPhLfBxd8g6Ce3uMbeCUY9dkRiGwfbDJ+0Vl3/be4xTmTn52tTx87L38HRqVJM6O2fCd09C3TYwYoU1gUuRKAEqocqcAGXn5rFs+xHmnq3Zc654nqebCz1b1mFgVDDRDYtYs6c4zqSaRQ4P/g5VA2HYYqjZqGw/U/LLyYSFj8JfXwHwv5whTM65DZvNRp829RjVrWnhi1ZK2Tl1BD660RwiDu0Md89XQdBCSjiWwa9nd01fvTuFlFP5V2pVq+JOdEOz2nKn8BqE1fTJPxScngITmph1lh7/HWqEl/MVSFFpErRcZOfhk8zdcID5vyeScupvNXuCqzEoKojbWtcrv0Jcmafgy0Fm8uMdYM75UfJT/tw8of9H4FcXVr3Lv9xm0qFmJvcf6s/CjQf57s8khlzdgMdvbKSaJVbJyYTZd5nJT0BDGDRNyc9lHDmZyapzK7X2pORbvAHg7e5K+7AAe8Xl5nX9Lv/Lnk9NCLsO9iyFLQuh89NlewFSrtQDVIDK0gOUdiabb/84yNz1B9iYcMJ+vGZVD/q3M4e4mgSWc42d7NPmpo17V4CXv7nUvW6b8o1BLrZ6Eix5HjBIDevJ0zmP8dPOVMD8oXFfp1BGdAlXtdryZBiw4GH4cxZ4+sPwn6BWE6ujqlBOnsnmtz3H7MvTtx8+me91NxcbVwVXs/fwtG1QvejlOjZ8Dt/+A+q0hodjSzF6KQsaAishR06A8vIM1uw5ypz1CXz/1yEyc8xJfW4uNm6IqM2gqGCub1rLmuWaOZkw6y7YFQMevmaRw6Co8o9DCvbXfFgwAnKzoEFH1kW/x/ilh+wFL/293Xnk+nDujQ7V6pfyEPsG/DzO3M/t7nkQfoPVEVku7Uw2G/YfZ93eY6zec5Q/D6SSm5f/R1jzun72TUSvDg3Ax7OEAx0Zx+D1RhoGcxBKgErIEROghGMZzPv9AF9tOMCB4+e7fZsEVmVQVDB929anZlVP6wLMzYa5w2Dbd+BexfyGHtLRunikYPtWwsw7zT3YajbFuPsrfjroyetLttknytf29eSJro0ZFBWsuidlZcs3MGeo+fzWN6D9cGvjscjhtDOs3XuM9fuOsXbfcbYdyr+JKEBojSpne3hqEh1egwCfMhginN4fdv+s/dYcgBKgEnKUBOhMdi4//HWIOesTWLX7qP24r5cbvdvUY1BUMK2D/K2v75KXC/MfhL/mgasn3Dlbv81WZIe3mBtsnjwIvnXhrq/Ird2Crzcm8mbMDnuCHVqjCqO6N+W2VnVVTLE0HdwIn/aE7Ay4egTc8prVEZULwzDYfST9bLJzjHX7jl00hwfMf3dRoQH2qsv1q3mXfXC/T4dvHoPAVvDIyrL/PCk2JUAlVJETIMMw2JhwgrkbDvDtxoOcPLuM02aDTuE1GRgVRI8WdfByryBDFHl55jeOjV+Cizvc8SU06WF1VHIlqQfgiwFwZCt4+pn3Lew6MnNymflbPO/+soujZ/c+al7Xj2dvbkqXJrWsT7YdXVqSueLr5EEIvwnunAOulXOtSnZuHpsPppkJz95jrN9//KL9tFxs0LyeH1EhZsITFVLdmgn5GcdgQmPIy4HH1kPNxuUfgxSKEqASqogJ0JGTmSyIO8Dc9QfY+beS7MEB3gxoF8ztkfUJql7BliyfK9u//mNzHsPAz6B5b6ujksI6fQJm3Qn7fzWT134fQKsBAKRn5vDJyr1MWbHHnoR3CAvg2ZsjiAzRFibFkpVhbgR8MA5qNoXhMeZCgUoiIyuHuPgTZ5OdY/y+/wSns/PvmO7p5sJVwdXMZCc0gHYNquHrVUEm3n9xO+z6CW4YA12esToauQQlQCVUURKg7Nw8ftmWzNz1B1i6Pdk+2c/L3YVbWtZlQFQQ14SVQ82e4jAMWPICrHkfsJnLrVsPtDoqKarsM+bE6C0Lza8vqEB8LD2Lyct28fnq/WSdnXDftVkgz/RoStM65bzC0JHl5cFX95l/z94B8ODP5rJ3B3b0VCbr9h1n/dnhrL8Opl00Ydnf2532odWJCg2gfWgArer7l3xT5bIS9wV8PRJqt4BHV1kdjVyCEqASsjoB2n7oJHPXJ7BwY2K+wl1tG1RjUFQwt7aui19F+a3oUn4eZ65iAej9HrQbam08Unx5eeYS+d8mm19fMxK6vwIu539QHTxxmnd+3smc9QnkGeaQbL+29Xmqa5OyrSZeWfzyf7DiNbOn7d5vHG6BgGEYJBw7zbqzyc7afcfYcyT9onb1q3nbE56rwwJoVKtqxfwFriCnj8PrjSEvG0auhVpNrY5ICqAEqISsSIBST5+r2ZPAHwdS7cdr+XrSv219BkYF0ai2g/xGveJ1+OUV8/ktE+DqB62NR0rOMGDVuxDzovl1i37Q70OzmOLf7Eo+xZsx21m86RBg7ph9V4cQRt7QiFq+Fq5CrMj+nAvzz67y6jMJ2t5lbTyFkJtnsO1QGuv3HWftPnOV1uG0zIvaNQ30JSq0un1Iq1wmLJelLwfCzh/h+ufh+n9ZHY0UQAlQCZVXApSXZ7Bqt1mzZ8nm/DV7bmpm1uzp0qQWbo601HjVe/DjC+bz7q9Ax8etjUdK159zYeEj5m/BoZ1h8BfgXe3iZgdO8PqS7cTuTAGgiocrD1wbxoPXNaz4vZflKWEdfHYr5GZCx39A95etjqhAZ7Jz+fNAqr2HZ8O+4/a5X+e4u9poVd+f9mEBtA8JICq0euXbPHTjDPPff+3m8Ohqq6ORAigBKqGyToASjmUwd8MB5m04QOKJ88s8I+r4MiAyyPqaPcW19iNYfLZGhiYKVl57lsGsu82NOWs3h7u+Av/6BTb9dVcKr/2wzd6rWa2KOyOvb8TQ6JCKs1LRKicSzBVf6cnQ9BYzmXSpGH8nqRnZbIg/xtq95hyePw+kXrRTelVPN9qFVKd9SHXahwVwVXC1yn9PT58wiyLmZcOjv0HtCKsjkgsoASqhskqA4uKP89oP21m953zNHj8vN/pcZQ5xtapfAWr2FNe5CYIA146Cm/6t3aors0ObzGXypw6BX32zsGXtZgU2NQyDJZsPM+HH7ew6u4Kxrr8XT9zUmAGRQY7Vw1laMk/CJzfD4b/M2jL3/wCeVS0LJyn19NmCg8dZt+8Y2w+fvKjgYC1fT64ONXt22ocGEFHH1znv3YzBsOMHuH40XP+c1dHIBZQAlVBZJUCbDqTS672V2GxwbaOaDIwKpnvzQMf/rWnTVzBvOGDANY9Cj/8q+XEGJ+LNpcEpO8zl2kNmXXbybk5uHvPjEpkYs4ODqWcAaFjLh392b0rPlnUcN/kvqrxcmH03bF8MPrXhwV+gWnC5fbxhGOxKPsW6s8nO2r3H8vVEn9Owpo892WkfGkBIjSrOc48uZ+NMWPgw1IqAkb9ZHY1cQAlQCZVVAmQYBl+s2c+NzQIdfzLgOVu+Mbe4MHIh6n649U0lP84k4xjMHAIJa8wq3/2nQIu+l33LmexcvvwtnveX7rIXvmsd5M+zPSK4tnHNcgjaYj++CKveMf++hi2C4PZl+nFZOXlsPph6Ntk5zob9xziekZ2vjYsNWtTzp31oAFeHVScyJECT1i/l9AmzKGJuFjy65pI9n2INJUAlZPUyeIex40ezUF5eNrS5E/q8n29ptDiJ7NNmD+C27wAb9PwfdBhxxbedPJPN1Ni9TI3dQ3qWWRCvY3gNnr05gquCq5VtzFb5+1Dx7R/bC0uWplOZOcTFmxuGrtt3nLiE45zJzj9/x8vdhbbB5tyd9qHVadugOlVLummoM5lxB+z4Hrr8C2543upo5G+UAJWQEqBC2LMMvhxkrl5p0R9un1phJnCKBfJy4ftnYd1U8+tOT8BNYwuVEB89lcn7S3fzxZr99om2N7eowz97NHGc0g+FsW8lTOtr/sJQij84j5zMPFts0BzS2pJ0ccHB6lXczxYbNIe0WtSrwAUHHcEfs2HBQ1CziVkTSL3eFYYSoBJSAnQF+1eZcz+yMyDiNnOLC1ctbXZ6hgEr3zSLYAK0GmT2CroVbin0geMZTPxpJ/N/P0CeYQ7L3N4uiCe7NXH8IeNje+Cjm+D0MbOG0u2fFKu31DAM9h/NsNfeWbfvOHtTLi44GFTd2z535+qw6jSs6UAFBx3BmTRzNVhuJjyyCgJbWB2RnKUEqISUAF3GgQ0wrY+5BLpRV7hjxkXF8MTJbZxpboCblwNhXczl3V6F/3+08/BJJvy4nSWbDwPg4erC3deEMPKGcGo4YnmIM6kwtRukbId6bWHYYvAoXHXs3DyDrUlp9vo76/Yd58jJ/AUHbTaz4GD70AD7kFZdfwdPGB3BzDth+yK47hm4cYzV0chZDpUATZo0iddff52kpCRatGjBxIkT6dy5c4FtV65cyb/+9S+2bdtGRkYGISEhjBgxgqeeesreZv78+fz3v/9l165dZGdn07hxY55++mmGDi38VgxKgC4h6Q/4vJf5DT20M9w1F9z1jVYKsOsnmH0PZKeby7zv/gp86xTpFBeWjfDxcOXB6xoyvHNDx5mvkpsDMwbC7l/Atx48tPSyfw9nsnPZmHCCdXvN7STi4k9w6oKCgx6uLrQO8rcnO5ENAvCvoh7YcneugneNxvDYOg2DVRAOkwDNnj2boUOHMmnSJDp16sSHH37I1KlT2bJlCw0aNLiofVxcHNu2baN169b4+PiwcuVKRowYwVtvvcVDDz0EwLJlyzh+/DgRERF4eHjw3Xff8fTTT7No0SJ69OhRqLiUABUgeatZsTbjKARfY9Z9sbBuiTiAg3HmPLH0ZPBvYP6bqdWkSKcwDIOVu1J47YftbEo0iykG+Hgw8oZG3NWhQcUvIbH4GVg7BdyrmLV+6rbJ9/KJjCx77Z11+46xKTGV7Nz835J9Pd2I/Nty9NZB/hX/up1B5kl4LdwcBnv4V6jT0uqIBAdKgDp06EC7du2YPHmy/VizZs3o27cv48ePL9Q5+vfvj4+PD9OnT79km3bt2nHrrbfy8suFKzOvBOgCR3fDpz3h1GGzC/+er826LyJXcmyvOV/s2G7wrg5DZkODDkU+jWEYfP/XISYs2c6es3Ne6lfz5smujenfLgjXiji/5e+V0Qd/Ac16kXji9NnVWeZjx+FTF70t0M/Tnuy0Dw2gaR3finl9ArPuMlc/dv4n3PSi1dEIRfv5bVk/clZWFhs2bOC55/JX0uzevTurVq0q1Dni4uJYtWoVr7zySoGvG4bBL7/8wvbt2/nf//53yfNkZmaSmXl+XD0tLa1Qn+8Uju8zh71OHYbAlnD3fCU/UngBYfBADMwYBInrYVpvc/l3s9uKdBqbzcYtrerSvXkgX204wMSfdpJ44jTPfPUnU1bs4enuTenRIrDiFOrb/QvG9//CBsQ1eYLP/ghi3cKf7QUg/65hLR+u/lvCExzgXXGuQy6vRT8zAdq8wJwHpPvmUCxLgFJSUsjNzSUwMDDf8cDAQA4dOnTZ9wYFBXHkyBFycnIYO3Ysw4cPz/d6amoq9evXJzMzE1dXVyZNmkS3bt0ueb7x48fz0ksvFf9iKqvURPi8N6QlQs2mMHQhVAmwOipxND414N5v4av7zdopc4bCLa9D++FXfu8F3FxduOPqBvRtW59pq/cxadludiaf4uEvNtAmuBr/urkpHcOtKaaYlZPHpsQT7Nz8O73X3UMVI5d5uZ15+s+rgYMAuLrYaFnPj/ahAfZl6Q45sVtMTXqAm5fZw3loE9RtbXVEUgSWzyS88DcdwzCu+NtPbGwsp06dYs2aNTz33HM0atSIIUOG2F/39fVl48aNnDp1ip9//plRo0bRsGFDrr/++gLPN3r0aEaNGmX/Oi0tjeDg8itNXyGdPGz+tn5iP1QPM4e9qtayOipxVB5VzGGgRaPg989h0dOQdhBufLFYvzV7ubvy0HXh3HF1Az5asYepsXv5I+EEd370G50b1+TZHhG0CirbnsqTZ7L5Pf6EfUhrY8IJvHNSWejxb6q4pLMurwkvMYJOjWoSFRLA1WEBtG1QjSoeln/bldLi6QuNu8HWb81eICVADsWyOUBZWVlUqVKFuXPn0q9fP/vxJ554go0bN7J8+fJCneeVV15h+vTpbN++/ZJthg8fTkJCAkuWLCnUOZ1+DlD6UXPC85Gt5uTV+xaX615FUokZBqx4HZb+n/l1mzuh9zslriN15GQm7y/dxZe/7bdPIr61VV1GdW9CeK3SmayfnHbGXmxw3b5jbE1K4+/1Bt3JYabXq0SxhZNe9djf/zuahofh7owbhjqTv+aZvZvVw+AfcRoGs5hDzAHy8PAgMjKSmJiYfAlQTEwMffr0KfR5DMPIN3+nuG3krNPHYXpfM/nxrQv3fq3kR0qPzQZdnjX/bX37BPwxw5xfNuhz87fpYqrl68nY3i144Now3orZwYKNiSzalMQPmw8xMDKIJ7o2LlJtHMMw2JuSbq+9s27fMfYfzbioXYOAKkSFVufqkOr03Dce/61bwMMX3/vm0TIwvNjXIw6kcQ9w84bje81SIfWusjoiKSRL+2JHjRrF0KFDiYqKIjo6milTphAfH8/DDz8MmENTiYmJTJs2DYD333+fBg0aEBERAZh1gSZMmMDjjz9uP+f48eOJiooiPDycrKwsFi9ezLRp0/KtNJNLyDwJXwyAQ3+CTy245xsIaGh1VFIZtRsKVQNh7r2w+2f47DazrlTV2iU6bXBAFd4cfBUPdWnIhCU7+GnrYWatS2B+XCL3Rofw6PWNqO5zcWXqnNw8tiSlmcnO3mOs33+MlFNZ+drYbBBRx4+rQ6ufnb8TQB1/L/PFVe/B1plgc4EBn0Bg8xJdhzgQz6rQpDts+docBlMC5DAsTYAGDx7M0aNHGTduHElJSbRs2ZLFixcTEhICQFJSEvHx8fb2eXl5jB49mr179+Lm5kZ4eDivvvoqI0ac33gxPT2dRx99lAMHDuDt7U1ERARffPEFgwcPLvfrcyhZGTBjsLlSx7u6OeeniDVbRIqkSXcY9p1ZKyhpI0ztaq4yrNmoxKeOqOPH1Huj2LD/GP/7YTtr9x7jo9i9zFqbwEPXNWRIhwbsOHySdXvN3p3f44+TcXZD1nM83Fy4Kqga7cPMhCcypDp+XgUM1W3/AX48Wwm4+/+Z1yXOpUU/MwHashC6jtUwmIOwvBJ0ReR0c4Cyz8DMweYGp57+5rBXvbZWRyXO4uhus1bQ8b1QpQbcOQeCokrt9IZhsHzHEV77YTtbki5d4sLPy42o0ABzSCs0gFZB/ni6XaHg4KG/4JMekHUKIofBbRP1w88ZZaWbe4NlZ8BDy/T900IOMQdIKoicLJhzj5n8uPuYWxboP6+UpxrhZ2sFDTSrR392doPdpjeXyultNhvXN63NdY1r8d2mJN74cTv7j2ZQx8+L9mEBXB1anfZhATSp7Vu0DUNPJcPMO8zkJ+w6uGWCkh9n5eFjLonfvODsMJi+hzoC9QAVwGl6gHJz4Kv7YOs3Zi2Lu76CsIL3YRMpc5mnYO4w2BVjzqW57S2zV6WU5eYZpJ7OpnoV9+IXHMw+YxYIPbAWAsJh+E+qkeXsNi8057RVawBP/Klk2CJF+fmt9ZnOKi8XFj5iJj+uHuau7kp+xEqeVWHITGh7Nxh55iqxpePNpfOlyNXFRoCPR/GTH8OAbx43kx8vf3PITsmPNO5u7vl2Ih4O/m51NFIISoCcUd7ZHy6b5oCLGwyaBo1usjoqEbMeUO/34Lpnza+Xv2omG7k5l39feYqdYP7fsbma/3dKYdK2VAIeVaDJ2WHbzQusjUUKRQmQszEM+P5ZiJtuDjPcPhWa9rQ6KpHzbDa48QVzCMzmYv5bnXWnOdHUalu+hl/O7j146wRoeL2l4UgF0+JsTbvNC0u951JKnxIgZ2IYEPMirPsIsEHfyef/w4pUNFH3w+AvzSJzO5eYk6PTU6yL52AczD9bcqPDw2Z8In/XuJu5mCQ1ARI3WB2NXIESIGeybDysetd83msitLnD0nBErijiFrj3G/AOMOdVfNwNju0p/zjSDsLMIZBzGhp1Nev9iFzI3ft8j7qGwSo8JUDOIvZNWP4/8/nN/yuT1TUiZSL4anjgR3N1zbE98HF3SCzHSaZZGWbyczIJakWYlZ5dVUFELkHDYA5DCZAzWDMZfn7JfN51LFzzsKXhiBRZzcbwwE9QpzWkHzGHw3bGlP3n5uXBghFmpeoqNeDO2ebKL5FLadQVPKpC2gE4sN7qaOQylABVdus/hR+eM593eQ6ufcraeESKyzcQ7lsMDW+A7HRz65a4L8v2M5f91ywV4eJuzkeqHlq2nyeOz91Lw2AOQglQZbZxJnx3NuHp9ARc/5y18YiUlKevWXen9R1g5MLXj8KK18tmqOHPOea5AXq/AyHRpf8ZUjmdGwbbstDsRZQKSQlQZfXXPPOHAwZcPQK6vqTKpFI5uHlAvw/g2lHm17+8AotGmcU9S0vCWvj6MfN5pyfhqjtL79xS+YXfBB6+kJYIB9ZZHY1cghKgymjbIpj/kFlNt909cPOrSn6kcrHZoOt/oOfrgA3WfwKzh5oTlkvqRLxZdyg3EyJug5v+U/JzinNx9zJXMIKGwSowJUCVza6fzP2U8nKg9WBzd2oX3WappDo8ZFZjdvWE7YtgWh/IOFb882WehBl3mBOt67SCfh/q/48Uj4bBKjz9z65M9q6AWXdBbhY07wN9JoGLq9VRiZSt5r3hnq/Bq5q5P9fH3eH4/qKfJy8X5g2H5M1QNRCGzDL3JxMpjvAbwdPPLJ+Q8JvV0UgBlABVFvFrzN9cc85Ak57Qf6pqlYjzCImG+5eAXxAc3WkWTEz6o2jniPk37PgB3LzgjpngH1Q2sYpzcPOEiFvN5xoGq5CUAFUGib/DlwPNpcENb4CBn5kTRUWcSe0IGB4DgS3h1GH49BbY/Uvh3vv7NFj9nvm87yQIiiy7OMV52IfBvtYwWAWkBMjRHfoLpveDzDQIuRbumGFOwBNxRn71zFpBoZ0h65T5i8Efsy//nr2x58tFXD8aWt5e9nGKc2h4A3j6w6lDkLDG6mjkAkqAHNmR7eakzzMnIKg93DkLPKpYHZWItbz84e550HKAuRhgwUOw8q2CawUd3Q1zhprtWvSHLv8q/3il8nLz0DBYBaYEyFEd3Q2f94aMFKjbBu76yiwSJyLm/Iv+H0HHx82vfxoL3z+bv1bQ6RMw8w44fRzqR5pDXyoXIaUt3zBYKdaqkhJTAuSITsSbPT+nDkHt5jB0IXhXszoqkYrFxQW6vwI9xgM2WDvFLBGRfQZyc8znKTvAr/7ZoWNviwOWSqnh9Wav5KnDEL/a6mjkb5QAOZq0g2bPT2oC1GhkLv+tEmB1VCIVV/SjZ3dw9zD39ZreF757EvYsBXcfc7m7bx2ro5TKys0DInqZzzUMVqEoAXIkp46YPT/H90K1ELjnG6ha2+qoRCq+lv3h7vnmhNT41RA3HbBB/ylQt7XV0Ullp2GwCkkJkKPIOGYmPyk7zFon934L/vWtjkrEcYR1hvt/AN965tdd/wPNbrM2JnEODbuYhTrTj8D+X62ORs5SAuQIzqSaS92TN0PVOnDvN1A9xOqoRBxPYHN4dBU8+Atc+5TV0YizcHWHZhoGq2iUAFV0mWdrmSRthCo1zDk/NcKtjkrEcXlXN1d9iZSnc8NgW781J+GL5ZQAVWRZGeYy3YTfzFUEQxea1W5FRMSxhF0H3gEaBqtAlABVVDmZMPtu2BcLHr4wdIEma4qIOCpX9/NzzjQMViEoAaqIcrNh7n2w+2dwrwJ3zVWXvYiIo7MPg32jYbAKQAlQRZObA/MfhO2LwNXTrFESEm11VCIiUlKhZ4fBMo6avftiKSVAFUleHnw90uwedXGHO740l0+KiIjjc3WD5r3N5xoGs5zlCdCkSZMICwvDy8uLyMhIYmMvnRWvXLmSTp06UaNGDby9vYmIiOCtt97K1+ajjz6ic+fOVK9enerVq9O1a1fWrl1b1pdRcoYBi56CP2eBzRUGfgqNu1kdlYiIlKZ8q8GyrY3FyVmaAM2ePZsnn3ySF154gbi4ODp37kzPnj2Jj48vsL2Pjw+PPfYYK1asYOvWrYwZM4YxY8YwZcoUe5tly5YxZMgQli5dyurVq2nQoAHdu3cnMTGxvC6r6AwDfhgNGz7DXp32XM0IERGpPEKuhSo14fQx2LvC6micms0wDMOqD+/QoQPt2rVj8uTJ9mPNmjWjb9++jB8/vlDn6N+/Pz4+PkyfPr3A13Nzc6levTrvvfce99xzT6HOmZaWhr+/P6mpqfj5+RXqPcVmGPDzS7DybE9Wn0nQ9q6y/UwREbHOd0/B+k+g3T3Q+12ro6lUivLz27IeoKysLDZs2ED37t3zHe/evTurVq0q1Dni4uJYtWoVXbpcep5MRkYG2dnZBARcesPQzMxM0tLS8j3KzfLXzic/t76h5EdEpLLTMFiFYFkClJKSQm5uLoGBgfmOBwYGcujQocu+NygoCE9PT6Kiohg5ciTDhw+/ZNvnnnuO+vXr07Vr10u2GT9+PP7+/vZHcHBw0S6muH59G5b913ze47/Q/tLXISIilURIJ/CpBaePw97lVkfjtCyfBG2z2fJ9bRjGRccuFBsby/r16/nggw+YOHEiM2fOLLDda6+9xsyZM5k/fz5eXl6XPN/o0aNJTU21PxISEop+IUX12xSI+bf5/MYXIXpk2X+miIhYz8UVmmk1mNXcrPrgmjVr4urqelFvT3Jy8kW9QhcKCwsDoFWrVhw+fJixY8cyZMiQfG0mTJjAf//7X3766Sdat758BWVPT088PT2LcRXFtOFz+P4Z83nnf8J1/yy/zxYREeu16AfrP4at38Gtb4Gbh9UROR3LeoA8PDyIjIwkJiYm3/GYmBg6duxY6PMYhkFmZma+Y6+//jovv/wyP/zwA1FRUaUSb6n5cw58+4T5PPoxuHGMtfGIiEj5C+kIPrXhzAkNg1nEsh4ggFGjRjF06FCioqKIjo5mypQpxMfH8/DDDwPm0FRiYiLTpk0D4P3336dBgwZERJgbgq5cuZIJEybw+OOP28/52muv8eKLLzJjxgxCQ0PtPUxVq1alatWq5XyFF9i2GBY8DBjmfJ/ur8AVhvtERKQScnGF5n1g3UfmMJjqvpU7SxOgwYMHc/ToUcaNG0dSUhItW7Zk8eLFhISEAJCUlJSvJlBeXh6jR49m7969uLm5ER4ezquvvsqIESPsbSZNmkRWVhYDBgzI91n/+c9/GDt2bLlc1yXVaQnVgs06ED1fV/IjIuLMWvQzE6Ct38FtEzUMVs4srQNUUZVpHaD0FPCubmb/IiLivPJy4c3mcOoQ3DkHmvSwOiKH5xB1gJyWT00lPyIicn4YDGDzQktDcUZKgERERKxyrijitkWQk3n5tlKqlACJiIhYJbgD+NaFzFTYvdTqaJxKsROg6dOn06lTJ+rVq8f+/fsBmDhxIl9//XWpBSciIlKpubj8bRhMRRHLU7ESoMmTJzNq1ChuueUWTpw4QW5uLgDVqlVj4sSJpRmfiIhI5XZuGGz7Ysg+Y20sTqRYCdC7777LRx99xAsvvICr6/kJvVFRUWzatKnUghMREan0gq4G33qQmQa7f7E6GqdRrARo7969tG3b9qLjnp6epKenlzgoERERp+HiAi36ms81DFZuipUAhYWFsXHjxouOf//99zRv3rykMYmIiDiXfMNgp62NxUkUqxL0M888w8iRIzlz5gyGYbB27VpmzpzJ+PHjmTp1amnHKCIiUrnVjwK/IEg7ALt+hma3WR1RpVesBOi+++4jJyeHZ599loyMDO68807q16/P22+/zR133FHaMYqIiFRu54bBVr8HWxYqASoHJd4KIyUlhby8PGrXrl1aMVmuTLfCEBERKciB9TD1JvCoCs/sAndvqyNyOOW6FUbNmjUrVfIjIiJiifqR4B8MWadg109WR1PpFXs3+K+++oo5c+YQHx9PVlZWvtd+//33EgcmIiLiVGw2syji6vfM1WDNelkdUaVWrB6gd955h/vuu4/atWsTFxfH1VdfTY0aNdizZw89e/Ys7RhFREScQ4v+5p/bf4CsDGtjqeSKlQBNmjSJKVOm8N577+Hh4cGzzz5LTEwM//jHP0hNTS3tGEVERJxD/Xbg3wCy02FXjNXRVGrFSoDi4+Pp2LEjAN7e3pw8eRKAoUOHMnPmzNKLTkRExJnYbCqKWE6KlQDVqVOHo0ePAhASEsKaNWsAs0J0CReViYiIOLdzRRF3LIEs7a5QVoqVAN144418++23ADzwwAM89dRTdOvWjcGDB9OvX79SDVBERMSp1GsL1UIgOwN2/mh1NJVWseoA5eXlkZeXh5ubuYhs7ty5xMbG0qhRIx555BHc3d1LPdDypDpAIiJiqZj/wK8ToXlfGPS51dE4jDKvA+Ti4kJOTg5r167lu+++w9PTk65duxIaGsoPP/xQrKBFRETkLA2Dlbli1QH64YcfGDp0qH0e0N/ZbDZyc3NLHJiIiIjTqtsGqofC8X1mEtSyv9URVTrF6gF67LHHGDRoEElJSfbhsHMPJT8iIiIlZLOd7wXSarAyUawEKDk5mVGjRhEYGFja8YiIiAicT4B2/giZp6yNpRIqVgI0YMAAli1bVsqhiIiIiF2d1hDQEHLOwA7Nry1txZoD9N577zFw4EBiY2Np1arVRau+/vGPf5RKcCIiIk7r3DBY7BvmMFirAVZHVKkUKwGaMWMGS5Yswdvbm2XLlmGz2eyv2Ww2JUAiIiKl4VwCtDMGMk+Cp6/VEVUaxRoCGzNmDOPGjSM1NZV9+/axd+9e+2PPnj2lHaOIiIhzCmwJNRpBbqa5QaqUmmIlQFlZWQwePBgXl2K9XURERArj76vBtiy0NJTKplgZzL333svs2bNLOxYRERG5UPO+5p87Y+BMmqWhVCbFmgOUm5vLa6+9xpIlS2jduvVFk6DffPPNUglORETE6QW2gBqN4ehOczVY60FWR1QpFCsB2rRpE23btgXgr7/+yvfa3ydEi4iISAmdGwZb8Zq5GkwJUKko1hDY0qVLL/n45ZdfinSuSZMmERYWhpeXF5GRkcTGxl6y7cqVK+nUqRM1atTA29ubiIgI3nrrrXxtNm/ezO23305oaCg2m42JEycW5xJFREQqjnPzgHb9BGdSrY2lkrB0FvPs2bN58skneeGFF4iLi6Nz58707NmT+Pj4Atv7+Pjw2GOPsWLFCrZu3cqYMWMYM2YMU6ZMsbfJyMigYcOGvPrqq9SpU6e8LkVERKTs1G4GNZtCbhZs/97qaCoFm2EYhlUf3qFDB9q1a8fkyZPtx5o1a0bfvn0ZP358oc7Rv39/fHx8mD59+kWvhYaG8uSTT/Lkk08WKa60tDT8/f1JTU3Fz8+vSO8VEREpE0vHw/JXocnNcKcWIhWkKD+/LesBysrKYsOGDXTv3j3f8e7du7Nq1apCnSMuLo5Vq1bRpUuXsghRRESk4mjR1/xz189w+oSVkVQKliVAKSkp5ObmXrShamBgIIcOHbrse4OCgvD09CQqKoqRI0cyfPjwEsWSmZlJWlpavoeIiEiFUrsZ1GoGedmwfbHV0Tg8yysZXrhqzDCMK64ki42NZf369XzwwQdMnDiRmTNnliiG8ePH4+/vb38EBweX6HwiIiJl4txk6M0LLQ2jMrAsAapZsyaurq4X9fYkJydf1Ct0obCwMFq1asWDDz7IU089xdixY0sUy+jRo0lNTbU/EhISSnQ+ERGRMnFuGGz3L3D6uKWhODrLEiAPDw8iIyOJiYnJdzwmJoaOHTsW+jyGYZCZmVmiWDw9PfHz88v3EBERqXBqNYXazc1hsG0aBiuJYhVCLC2jRo1i6NChREVFER0dzZQpU4iPj+fhhx8GzJ6ZxMREpk2bBsD7779PgwYNiIiIAMy6QBMmTODxxx+3nzMrK4stW7bYnycmJrJx40aqVq1Ko0aNyvkKRURESlmLfpC8xSyK2PYuq6NxWJYmQIMHD+bo0aOMGzeOpKQkWrZsyeLFiwkJCQEgKSkpX02gvLw8Ro8ezd69e3FzcyM8PJxXX32VESNG2NscPHjQXqUaYMKECUyYMIEuXbqwbNmycrs2ERGRMtG8Lyz9P9izFDKOQZUAqyNySJbWAaqoVAdIREQqtMmd4PBf0Ps9aDfU6mgqDIeoAyQiIiLFdG4y9OYFlobhyJQAiYiIOJrmZ5fD71lmDoNJkSkBEhERcTQ1G0GdVmDkwtZvrY7GISkBEhERcUTniiJuWWhpGI5KCZCIiIgjat7X/HPPckg/amkojkgJkIiIiCOqEQ51WpvDYNs0DFZUSoBEREQclX1vMK0GKyolQCIiIo7q3HL4vSsgPcXSUByNEiARERFHFdAQ6l4FRh5s/cbqaByKEiARERFHpmGwYlECJCIi4sjODYPtWwmnki0NxZEoARIREXFk1UOhXjsNgxWREiARERFHZx8GW2hpGI5ECZCIiIija97H/HP/r3DysLWxOAglQCIiIo6uegjUj9QwWBEoARIREakMNAxWJEqAREREKoN8w2CHrI3FASgBEhERqQyqNYCg9oABWzQMdiVKgERERCoLFUUsNCVAIiIilcW5YbD41ZCWZG0sFZwSIBERkcrCPwiCOwCGVoNdgRIgERGRyqR5X/NPDYNdlhIgERGRyiTfMNhBa2OpwJQAiYiIVCb+9SH4GvP5lq+tjaUCUwIkIiJS2Wg12BUpARIREalsmvcGbJDwG6QesDqaCkkJkIiISGXjVw8aRJvPNQxWICVAIiIilZGGwS5LCZCIiEhldG4Y7MA6OJFgdTQVjhIgERGRysi3DoR0Mp9rGOwiSoBEREQqqxZ9zT81DHYRyxOgSZMmERYWhpeXF5GRkcTGxl6y7cqVK+nUqRM1atTA29ubiIgI3nrrrYvazZs3j+bNm+Pp6Unz5s1ZsEA3XkREnFCzs8Ngievh+H6ro6lQLE2AZs+ezZNPPskLL7xAXFwcnTt3pmfPnsTHxxfY3sfHh8cee4wVK1awdetWxowZw5gxY5gyZYq9zerVqxk8eDBDhw7ljz/+YOjQoQwaNIjffvutvC5LRESkYvANhNBrzecaBsvHZhiGYdWHd+jQgXbt2jF58mT7sWbNmtG3b1/Gjx9fqHP0798fHx8fpk+fDsDgwYNJS0vj+++/t7e5+eabqV69OjNnzizUOdPS0vD39yc1NRU/P78iXJGIiEgFs24qLHoa6rWDh5ZaHU2ZKsrPb8t6gLKystiwYQPdu3fPd7x79+6sWrWqUOeIi4tj1apVdOnSxX5s9erVF52zR48ehT6niIhIpdKsN9hc4ODvcHyf1dFUGJYlQCkpKeTm5hIYGJjveGBgIIcOHbrse4OCgvD09CQqKoqRI0cyfPhw+2uHDh0q8jkzMzNJS0vL9xAREakUqtY+Pwy2eaGloVQklk+Cttls+b42DOOiYxeKjY1l/fr1fPDBB0ycOPGioa2innP8+PH4+/vbH8HBwUW8ChERkQpMRREvYlkCVLNmTVxdXS/qmUlOTr6oB+dCYWFhtGrVigcffJCnnnqKsWPH2l+rU6dOkc85evRoUlNT7Y+EBBWMEhGRSuTcMFjSRji21+poKgTLEiAPDw8iIyOJiYnJdzwmJoaOHTsW+jyGYZCZmWn/Ojo6+qJz/vjjj5c9p6enJ35+fvkeIiIilYZPTQi7zny+ZaGloVQUblZ++KhRoxg6dChRUVFER0czZcoU4uPjefjhhwGzZyYxMZFp06YB8P7779OgQQMiIiIAsy7QhAkTePzxx+3nfOKJJ7juuuv43//+R58+ffj666/56aefWLlyZflfoIiISEXRvC/sWWYOg137lNXRWM7SBGjw4MEcPXqUcePGkZSURMuWLVm8eDEhISEAJCUl5asJlJeXx+jRo9m7dy9ubm6Eh4fz6quvMmLECHubjh07MmvWLMaMGcOLL75IeHg4s2fPpkOHDuV+fSIiIhVGs17mcvikP+DobqgRbnVElrK0DlBFpTpAIiJSKU3rC3uWwk3/hs5PWx1NqXOIOkAiIiJSzrQazE4JkIiIiLNo1gtsrnBoE6TssjoaSykBEhERcRZVAqDh9ebzLc7dC6QESERExJnYh8EWWhqG1ZQAiYiIOJOIW8HFDQ7/BSk7rY7GMkqAREREnMnfh8GcuBdICZCIiIiz0WowJUAiIiJOJ+JWcHGH5M1wZLvV0VhCCZCIiIiz8a4O4TeYz510GEwJkIiIiDNy8mEwJUAiIiLOqOkt5jDYka2QvNXqaMqdEiARERFn5F0NGt1kPnfCYTAlQCIiIs7q78NgTrY3uhIgERERZ9W0J7h6QMp2pxsGUwIkIiLirLz8IfzsMNiWhZaGUt6UAImIiDgzJx0GUwIkIiLizJr2BFdPSNkByVusjqbcKAESERFxZl5+0Kir+dyJagIpARIREXF2TjgMpgRIRETE2TW92RwGO7oLDv9ldTTlQgmQiIiIs/P0hcbdzOdOMgymBEhEREScbhhMCZCIiIhAk5vBzQuO7YFDf1odTZlTAiQiIiLgWfVvw2ALLQ2lPCgBEhEREZMTDYMpARIRERFT4x7g5g3H90LSH1ZHU6aUAImIiIjJsyo06W4+r+SrwZQAiYiIyHlOMgymBEhERETOa9wd3KvAif1wMM7qaMqMEiARERE5z8MHmvQwn1fiYTAlQCIiIpKffRhsYaUdBrM8AZo0aRJhYWF4eXkRGRlJbGzsJdvOnz+fbt26UatWLfz8/IiOjmbJkiX52mRnZzNu3DjCw8Px8vKiTZs2/PDDD2V9GSIiIpVHo27g7gOp8ZD4u9XRlAlLE6DZs2fz5JNP8sILLxAXF0fnzp3p2bMn8fHxBbZfsWIF3bp1Y/HixWzYsIEbbriBXr16ERd3foxyzJgxfPjhh7z77rts2bKFhx9+mH79+uVrIyIiIpfhUeX8MNiWyjkMZjMM6/q2OnToQLt27Zg8ebL9WLNmzejbty/jx48v1DlatGjB4MGD+fe//w1AvXr1eOGFFxg5cqS9Td++falatSpffPFFoc6ZlpaGv78/qamp+Pn5FeGKREREKokt38CcoeAfDE9uApvN6oiuqCg/vy3rAcrKymLDhg1079493/Hu3buzatWqQp0jLy+PkydPEhAQYD+WmZmJl5dXvnbe3t6sXLmy5EGLiIg4i8bnhsESIHGD1dGUOssSoJSUFHJzcwkMDMx3PDAwkEOHDhXqHG+88Qbp6ekMGjTIfqxHjx68+eab7Ny5k7y8PGJiYvj6669JSkq65HkyMzNJS0vL9xAREXFq7t7QtKf5vBKuBrN8ErTtgi41wzAuOlaQmTNnMnbsWGbPnk3t2rXtx99++20aN25MREQEHh4ePPbYY9x33324urpe8lzjx4/H39/f/ggODi7+BYmIiFQWf18NlpdnaSilzbIEqGbNmri6ul7U25OcnHxRr9CFZs+ezQMPPMCcOXPo2rVrvtdq1arFwoULSU9PZ//+/Wzbto2qVasSFhZ2yfONHj2a1NRU+yMhIaH4FyYiIlJZNOoKHlUh7QAkrrc6mlJlWQLk4eFBZGQkMTEx+Y7HxMTQsWPHS75v5syZDBs2jBkzZnDrrbdesp2Xlxf169cnJyeHefPm0adPn0u29fT0xM/PL99DRETE6bl7QdNbzOeVbBjM0iGwUaNGMXXqVD755BO2bt3KU089RXx8PA8//DBg9szcc8899vYzZ87knnvu4Y033uCaa67h0KFDHDp0iNTUVHub3377jfnz57Nnzx5iY2O5+eabycvL49lnny336xMREXF4lXQYzNIEaPDgwUycOJFx48Zx1VVXsWLFChYvXkxISAgASUlJ+WoCffjhh+Tk5DBy5Ejq1q1rfzzxxBP2NmfOnGHMmDE0b96cfv36Ub9+fVauXEm1atXK+/JEREQcX/iN4OELJw/CgXVWR1NqLK0DVFGpDpCIiMjfzH8I/pwNHR6Bnq9aHc0lOUQdIBEREXEQ54bBtiysNMNgSoBERETk8sJvBE8/OJkECb9ZHU2pUAIkIiIil+fmCRFnV15XktVgSoBERETkyuzDYF9DXq61sZQCJUAiIiJyZQ1vAE9/OHUI4tdYHU2JKQESERGRK3PzgGa3mc8rwTCYEiAREREpnEo0DKYESERERAonrAt4+UN6MsSvtjqaElECJCIiIoXj5gERvcznDj4MpgRIRERECq+SDIMpARIREZHCa9gFvKpB+hHY/6vV0RSbEiAREREpPFd3aOb4w2BKgERERKRo7MNg30BujrWxFJMSIBERESmasOvAOwAyUmD/SqujKRYlQCIiIlI0lWAYTAmQiIiIFN25YbCt3zrkMJgSIBERESm60M5QpQZkHIV9sVZHU2RKgERERKToXN0cehhMCZCIiIgUT75hsGxrYykiJUAiIiJSPCHXQpWacPoY7F1hdTRFogRIREREisfVDZr3Np872DCYEiAREREpPgcdBlMCJCIiIsUX0gl8asGZE7BnudXRFJoSIBERESk+F1do3sd87kDDYEqAREREpGSa9zX/3PYt5GRZGkphKQESERGRkgnpCD614Uwq7HWMYTAlQCIiIlIyDjgMpgRIRERESs6+Guw7hxgGUwIkIiIiJdfgGqhaBzJTYc9Sq6O5IiVAIiIiUnIONgymBEhERERKx7lhsG2LICfT2liuwPIEaNKkSYSFheHl5UVkZCSxsbGXbDt//ny6detGrVq18PPzIzo6miVLllzUbuLEiTRt2hRvb2+Cg4N56qmnOHPmTFlehoiIiAR3AN+6kJkGu3+xOprLsjQBmj17Nk8++SQvvPACcXFxdO7cmZ49exIfH19g+xUrVtCtWzcWL17Mhg0buOGGG+jVqxdxcXH2Nl9++SXPPfcc//nPf9i6dSsff/wxs2fPZvTo0eV1WSIiIs7JxeV8TaAKPgxmMwzDsOrDO3ToQLt27Zg8ebL9WLNmzejbty/jx48v1DlatGjB4MGD+fe//w3AY489xtatW/n555/tbZ5++mnWrl172d6lv0tLS8Pf35/U1FT8/PyKcEUiIiJOLn4NfNIDPHzhmV3g7lVuH12Un9+W9QBlZWWxYcMGunfvnu949+7dWbVqVaHOkZeXx8mTJwkICLAfu/baa9mwYQNr164FYM+ePSxevJhbb7219IIXERGRggVdDb71IOtkhR4Gc7Pqg1NSUsjNzSUwMDDf8cDAQA4dOlSoc7zxxhukp6czaNAg+7E77riDI0eOcO2112IYBjk5OTzyyCM899xzlzxPZmYmmZnnJ2ulpaUV8WpEREQEMIfBWvSFNZPMYbCIW6yOqECWT4K22Wz5vjYM46JjBZk5cyZjx45l9uzZ1K5d23582bJl/N///R+TJk3i999/Z/78+Xz33Xe8/PLLlzzX+PHj8ff3tz+Cg4OLf0EiIiLO7txqsO2LIfu0tbFcgmUJUM2aNXF1db2otyc5OfmiXqELzZ49mwceeIA5c+bQtWvXfK+9+OKLDB06lOHDh9OqVSv69evHf//7X8aPH09eXl6B5xs9ejSpqan2R0JCQskuTkRExJnVjwK/IMg6Bbt+vnJ7C1iWAHl4eBAZGUlMTEy+4zExMXTs2PGS75s5cybDhg1jxowZBc7rycjIwMUl/2W5urpiGAaXmu/t6emJn59fvoeIiIgU07lhMKiwq8EsmwMEMGrUKIYOHUpUVBTR0dFMmTKF+Ph4Hn74YcDsmUlMTGTatGmAmfzcc889vP3221xzzTX23iNvb2/8/f0B6NWrF2+++SZt27alQ4cO7Nq1ixdffJHevXvj6upqzYWKiIg4mxb9YPV7sP17cxjM3dvqiPKxNAEaPHgwR48eZdy4cSQlJdGyZUsWL15MSEgIAElJSflqAn344Yfk5OQwcuRIRo4caT9+77338tlnnwEwZswYbDYbY8aMITExkVq1atGrVy/+7//+r1yvTURExKnVjwT/YEhNgJ0x0Ly31RHlY2kdoIpKdYBERERKwY9jYNW70KI/DPy0zD/OIeoAiYiISCXX/OxqsB0/QFaGtbFcQAmQiIiIlI367cC/AWRnwK6YK7cvR0qAREREpGzYbBV2NZgSIBERESk754oi7lgCWenWxvI3SoBERESk7NRrC9VCzGGwnT9aHY2dEiAREREpOzbb+V6gCjQMpgRIREREypZ9GOxHyDxlbSxnKQESERGRslW3DVQPg5zTsHOJ1dEASoBERESkrFXAYTAlQCIiIlL2zi2H3xlTIYbBlACJiIhI2avTGgIaQs4ZszK0xZQAiYiISNmrYMNgSoBERESkfJxLgHbGQOZJS0NRAiQiIiLlI7Al1GgEuZmw3dphMCVAIiIiUj4q0DCYEiAREREpP+cSoKxTkJdnWRhuln2yiIiIOJ/azeHp7eBbx9Iw1AMkIiIi5cdmszz5ASVAIiIi4oSUAImIiIjTUQIkIiIiTkcJkIiIiDgdJUAiIiLidJQAiYiIiNNRAiQiIiJORwmQiIiIOB0lQCIiIuJ0lACJiIiI01ECJCIiIk5HCZCIiIg4HSVAIiIi4nTcrA6gIjIMA4C0tDSLIxEREZHCOvdz+9zP8ctRAlSAkydPAhAcHGxxJCIiIlJUJ0+exN/f/7JtbEZh0iQnk5eXx8GDB/H19cVms5XqudPS0ggODiYhIQE/P79SPXdFUNmvDyr/Ner6HF9lv0Zdn+Mrq2s0DIOTJ09Sr149XFwuP8tHPUAFcHFxISgoqEw/w8/Pr9L+w4bKf31Q+a9R1+f4Kvs16vocX1lc45V6fs7RJGgRERFxOkqARERExOkoASpnnp6e/Oc//8HT09PqUMpEZb8+qPzXqOtzfJX9GnV9jq8iXKMmQYuIiIjTUQ+QiIiIOB0lQCIiIuJ0lACJiIiI01ECJCIiIk5HCVApWrFiBb169aJevXrYbDYWLlx4xfcsX76cyMhIvLy8aNiwIR988EHZB1oCRb3GZcuWYbPZLnps27atfAIugvHjx9O+fXt8fX2pXbs2ffv2Zfv27Vd8nyPdw+JcoyPdw8mTJ9O6dWt7cbXo6Gi+//77y77Hke4fFP0aHen+FWT8+PHYbDaefPLJy7ZztPt4TmGuz9Hu4dixYy+KtU6dOpd9jxX3TwlQKUpPT6dNmza89957hWq/d+9ebrnlFjp37kxcXBzPP/88//jHP5g3b14ZR1p8Rb3Gc7Zv305SUpL90bhx4zKKsPiWL1/OyJEjWbNmDTExMeTk5NC9e3fS09Mv+R5Hu4fFucZzHOEeBgUF8eqrr7J+/XrWr1/PjTfeSJ8+fdi8eXOB7R3t/kHRr/EcR7h/F1q3bh1TpkyhdevWl23niPcRCn995zjSPWzRokW+WDdt2nTJtpbdP0PKBGAsWLDgsm2effZZIyIiIt+xESNGGNdcc00ZRlZ6CnONS5cuNQDj+PHj5RJTaUpOTjYAY/ny5Zds4+j3sDDX6Mj30DAMo3r16sbUqVMLfM3R7985l7tGR71/J0+eNBo3bmzExMQYXbp0MZ544olLtnXE+1iU63O0e/if//zHaNOmTaHbW3X/1ANkodWrV9O9e/d8x3r06MH69evJzs62KKqy0bZtW+rWrctNN93E0qVLrQ6nUFJTUwEICAi4ZBtHv4eFucZzHO0e5ubmMmvWLNLT04mOji6wjaPfv8Jc4zmOdv9GjhzJrbfeSteuXa/Y1hHvY1Gu7xxHuoc7d+6kXr16hIWFcccdd7Bnz55LtrXq/mkzVAsdOnSIwMDAfMcCAwPJyckhJSWFunXrWhRZ6albty5TpkwhMjKSzMxMpk+fzk033cSyZcu47rrrrA7vkgzDYNSoUVx77bW0bNnyku0c+R4W9hod7R5u2rSJ6Ohozpw5Q9WqVVmwYAHNmzcvsK2j3r+iXKOj3T+AWbNm8fvvv7Nu3bpCtXe0+1jU63O0e9ihQwemTZtGkyZNOHz4MK+88godO3Zk8+bN1KhR46L2Vt0/JUAWs9ls+b42zhbmvvC4o2ratClNmza1fx0dHU1CQgITJkyokP9xz3nsscf4888/Wbly5RXbOuo9LOw1Oto9bNq0KRs3buTEiRPMmzePe++9l+XLl18yQXDE+1eUa3S0+5eQkMATTzzBjz/+iJeXV6Hf5yj3sTjX52j3sGfPnvbnrVq1Ijo6mvDwcD7//HNGjRpV4HusuH8aArNQnTp1OHToUL5jycnJuLm5FZglVxbXXHMNO3futDqMS3r88cf55ptvWLp0KUFBQZdt66j3sCjXWJCKfA89PDxo1KgRUVFRjB8/njZt2vD2228X2NZR719RrrEgFfn+bdiwgeTkZCIjI3Fzc8PNzY3ly5fzzjvv4ObmRm5u7kXvcaT7WJzrK0hFvocX8vHxoVWrVpeM16r7px4gC0VHR/Ptt9/mO/bjjz8SFRWFu7u7RVGVvbi4uArXJQ3mbxyPP/44CxYsYNmyZYSFhV3xPY52D4tzjQWpqPewIIZhkJmZWeBrjnb/LuVy11iQinz/brrppotWDN13331ERETwr3/9C1dX14ve40j3sTjXV5CKfA8vlJmZydatW+ncuXOBr1t2/8p0irWTOXnypBEXF2fExcUZgPHmm28acXFxxv79+w3DMIznnnvOGDp0qL39nj17jCpVqhhPPfWUsWXLFuPjjz823N3dja+++sqqS7iiol7jW2+9ZSxYsMDYsWOH8ddffxnPPfecARjz5s2z6hIu6ZFHHjH8/f2NZcuWGUlJSfZHRkaGvY2j38PiXKMj3cPRo0cbK1asMPbu3Wv8+eefxvPPP2+4uLgYP/74o2EYjn//DKPo1+hI9+9SLlwlVRnu499d6foc7R4+/fTTxrJly4w9e/YYa9asMW677TbD19fX2Ldvn2EYFef+KQEqReeWKl74uPfeew3DMIx7773X6NKlS773LFu2zGjbtq3h4eFhhIaGGpMnTy7/wIugqNf4v//9zwgPDze8vLyM6tWrG9dee62xaNEia4K/goKuCzA+/fRTextHv4fFuUZHuof333+/ERISYnh4eBi1atUybrrpJntiYBiOf/8Mo+jX6Ej371IuTBAqw338uytdn6Pdw8GDBxt169Y13N3djXr16hn9+/c3Nm/ebH+9otw/m2GcnWkkIiIi4iQ0CVpEREScjhIgERERcTpKgERERMTpKAESERERp6MESERERJyOEiARERFxOkqARERExOkoARIRKYRly5Zhs9k4ceKE1aGISClQAiQiIiJORwmQiIiIOB0lQCLiEAzD4LXXXqNhw4Z4e3vTpk0bvvrqK+D88NSiRYto06YNXl5edOjQ4aJdt+fNm0eLFi3w9PQkNDSUN954I9/rmZmZPPvsswQHB+Pp6Unjxo35+OOP87XZsGEDUVFRVKlShY4dO7J9+/ayvXARKRNKgETEIYwZM4ZPP/2UyZMns3nzZp566inuvvtuli9fbm/zzDPPMGHCBNatW0ft2rXp3bs32dnZgJm4DBo0iDvuuINNmzYxduxYXnzxRT777DP7+++55x5mzZrFO++8w9atW/nggw+oWrVqvjheeOEF3njjDdavX4+bmxv3339/uVy/iJQubYYqIhVeeno6NWvW5JdffiE6Otp+fPjw4WRkZPDQQw9xww03MGvWLAYPHgzAsWPHCAoK4rPPPmPQoEHcddddHDlyhB9//NH+/meffZZFixaxefNmduzYQdOmTYmJiaFr164XxbBs2TJuuOEGfvrpJ2666SYAFi9ezK233srp06fx8vIq478FESlN6gESkQpvy5YtnDlzhm7dulG1alX7Y9q0aezevdve7u/JUUBAAE2bNmXr1q0AbN26lU6dOuU7b6dOndi5cye5ubls3LgRV1dXunTpctlYWrdubX9et25dAJKTk0t8jSJSvtysDkBE5Ery8vIAWLRoEfXr18/3mqenZ74k6EI2mw0w5xCde37O3zvAvb29CxWLu7v7Rec+F5+IOA71AIlIhde8eXM8PT2Jj4+nUaNG+R7BwcH2dmvWrLE/P378ODt27CAiIsJ+jpUrV+Y776pVq2jSpAmurq60atWKvLy8fHOKRKTyUg+QiFR4vr6+/POf/+Spp54iLy+Pa6+9lrS0NFatWkXVqlUJCQkBYNy4cdSoUYPAwEBeeOEFatasSd++fQF4+umnad++PS+//DKDBw9m9erVvPfee0yaNAmA0NBQ7r33Xu6//37eeecd2rRpw/79+0lOTmbQoEFWXbqIlBElQCLiEF5++WVq167N+PHj2bNnD9WqVaNdu3Y8//zz9iGoV199lSeeeIKdO3fSpk0bvvnmGzw8PABo164dc+bM4d///jcvv/wydevWZdy4cQwbNsz+GZMnT+b555/n0Ucf5ejRozRo0IDnn3/eissVkTKmVWAi4vDOrdA6fvw41apVszocEXEAmgMkIiIiTkcJkIiIiDgdDYGJiIiI01EPkIiIiDgdJUAiIiLidJQAiYiIiNNRAiQiIiJORwmQiIiIOB0lQCIiIuJ0lACJiIiI01ECJCIiIk5HCZCIiIg4nf8H/TiOcVMcJZMAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw mae\n",
    "if is_graphic:\n",
    "  plt.plot(list(range(1, len(arr_train_mae) + 1)), arr_train_mae, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_mae) + 1)), arr_val_mae, label=\"val\")\n",
    "\n",
    "  plt.title(\"MAE\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"mae\")\n",
    "  plt.legend(loc=\"upper right\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Accuracies\n",
    "if is_graphic:\n",
    "  plt.plot(list(range(1, len(arr_train_acc) + 1)), arr_train_acc, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_acc) + 1)), arr_val_acc, label=\"val\")\n",
    "\n",
    "  plt.title(\"Accuracy\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"accuracy\")\n",
    "  plt.legend(loc=\"upper left\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HeterSUMGraph(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_epoch = np.argmin(np.array(arr_val_loss)) + 1\n",
    "model.load(checkpoints_folder + \"/\" + model_name + \"-\" + str(best_epoch) + \".pt\")\n",
    "model.to(device)\n",
    "model.eval()\n",
    "best_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test[\"doc_splitted\"] = split_all_docs(df_test[\"article\"], False)\n",
    "test_set = df_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:03<00:00, 28.49batch/s, accuracy=0.707, loss=0.575, rouge1=0.289, rouge2=0.0778, rougeL=0.175]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "\n",
    "counter = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "  for batch in tepoch:\n",
    "    tepoch.set_description(\"Eval model\")\n",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "    y_pred = model(data)\n",
    "\n",
    "    loss = criterion(y_pred, targets)\n",
    "\n",
    "    arr_loss.append(loss.item())\n",
    "\n",
    "    doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "    summaries = test_set[\"highlights\"].iloc[idx]\n",
    "\n",
    "    probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "    probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "    #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "    #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "    indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for i in range(min(len(doc), y_pred.shape[0])):\n",
    "      txt = txt + \". \" + doc[indices[i]]\n",
    "      y_pred_thresh.append(indices[i])\n",
    "      if len(txt) >= len(summaries):\n",
    "        break\n",
    "\n",
    "    y_pred_thresh.sort()\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "      txt = txt + \". \" + doc[i]\n",
    "\n",
    "    n = min(len(txt), len(summaries))\n",
    "\n",
    "    while n < len(txt) and txt[n].isalnum():\n",
    "      n += 1\n",
    "\n",
    "    txt = txt[:n]\n",
    "\n",
    "    #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "    scores = scorer.score(summaries, txt)\n",
    "    arr_rouge1.append(scores[\"rouge1\"].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(loss=np.mean(arr_loss), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL), accuracy=np.mean(accuracy))\n",
    "    idx += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\n",
    "test_metrics[\"mae\"]      = np.mean(mae)\n",
    "test_metrics[\"rouge1\"]   = np.mean(arr_rouge1)\n",
    "test_metrics[\"rouge2\"]   = np.mean(arr_rouge2)\n",
    "test_metrics[\"rougeL\"]   = np.mean(arr_rougeL)\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/test_metrics.json\", 'w') as fp:\n",
    "  json.dump(test_metrics, fp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:00<00:00, 145.40batch/s, rouge1=0.394, rouge2=0.163, rougeL=0.245]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Lead-3\")\n",
    "        doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), 3)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[\"highlights\"].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))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 138.02batch/s, rouge1=0.396, rouge2=0.164, rougeL=0.246]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[\"highlights\"].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": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "SystemExit",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rsaid/.local/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3406: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "# Does not execute this cell if you want to execute the following cells.\n",
    "import sys\n",
    "sys.exit()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "6d7f428a150b92572ac46240b6d7ae68586908362b054f21341550673eeb77dc"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}