04-train_HeterSUMGraph_NYT50_TG_GATConv.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train HeterSUMGraph_NYT50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import argparse\n",
    "from time import time\n",
    "import torch\n",
    "import numpy as np\n",
    "import random\n",
    "from sklearn.utils import shuffle\n",
    "import json\n",
    "import os\n",
    "import networkx as nx\n",
    "import torch_geometric\n",
    "from statistics import mean\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils.create_graph_dataset import create_graph_dataset\n",
    "from utils.GloveMgr import GloveMgr\n",
    "from utils.DataLoader import DataLoader\n",
    "from utils.MultiProcessusDataLoader import MultiProcessusDataLoader\n",
    "from utils.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils.split_all_docs import split_all_docs\n",
    "from utils.threshold_probs import threshold_probs_by_nb, threshold_probs_by_prop\n",
    "from utils.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_notebook() -> bool:\n",
    "    try:\n",
    "        shell = get_ipython().__class__.__name__\n",
    "        if shell == 'ZMQInteractiveShell':\n",
    "            return True   # Jupyter notebook or qtconsole\n",
    "        elif shell == 'TerminalInteractiveShell':\n",
    "            return False  # Terminal running IPython\n",
    "        else:\n",
    "            return False  # Other type (?)\n",
    "    except NameError:\n",
    "        return False      # Probably standard Python interpreter"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse args if script mode\n",
    "parser = argparse.ArgumentParser(description='extractive summary')\n",
    "\n",
    "parser.add_argument('-is_graphic',type=int,default=1,choices=[0,1])\n",
    "parser.add_argument('-gpu_num',type=int,default=0)\n",
    "parser.add_argument('-batch_size',type=int,default=1)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "\n",
    "args = None\n",
    "\n",
    "if is_notebook():\n",
    "    args = parser.parse_args(\"\")\n",
    "else:\n",
    "    args = parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 0\n",
      "epochs 100\n",
      "batch_size 1\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 = \"04-train_HeterSUMGraph_NYT50_TG_GATConv\"\n",
    "sub_folder_name = \"model_name__{}__time__{}__embed_name__{}__lr__{}__batch_size__{}__vocab_size__{}__cuda_num__{}__early_stopping__{}\".format(model_name, time(), embed_name, learning_rate, batch_size, vocab_size, cuda_num, early_stopping)\n",
    "checkpoints_folder = \"./checkpoints/\" + sub_folder_name\n",
    "average_number_of_sentences_per_document = 3\n",
    "\n",
    "# print\n",
    "print(\"parse:\")\n",
    "print(\"is_graphic:\", is_graphic)\n",
    "print(\"cuda_num:\", cuda_num)\n",
    "print(\"epochs\", epochs)\n",
    "print(\"batch_size\", batch_size)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyTorch initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(0)\n",
    "random.seed(0)\n",
    "np.random.seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of available GPUs: 1\n",
      "GPU 0: NVIDIA GeForce RTX 3060\n"
     ]
    }
   ],
   "source": [
    "# Check if a GPU is available\n",
    "if torch.cuda.is_available():\n",
    "    # Display the number of available GPUs\n",
    "    print(f\"Number of available GPUs: {torch.cuda.device_count()}\")\n",
    "    # Display the name of each GPU\n",
    "    for i in range(torch.cuda.device_count()):\n",
    "        print(f\"GPU {i}: {torch.cuda.get_device_name(i)}\")\n",
    "else:\n",
    "    print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(\"./data/nyt_corpus_LDC2008T19_50/test.json\")\n",
    "df_val = pd.read_json(\"./data/nyt_corpus_LDC2008T19_50/val.json\")\n",
    "df_train = pd.read_json(\"./data/nyt_corpus_LDC2008T19_50/train.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "glovemgr = GloveMgr(\"./data/glove.6B/glove.6B.300d.txt\", vocab_size=vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_sent = pd.read_json(\"data/nyt50_sent_tfidf.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_dataset = json.load(open(\"./data/nyt50_dataset_tfidf.json\"))\n",
    "tfidfs_dataset_sorted = sorted(tfidfs_dataset, key=tfidfs_dataset.get)\n",
    "word_blacklist = set(tfidfs_dataset_sorted[:int(word_blacklist_proportion*len(tfidfs_dataset_sorted))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = MultiProcessusDataLoader(buffer_size=30, dataset=df_train, batch_size=batch_size, shuffle=True, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"docs\", labels_column_name=\"labels\", is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_dataset = create_graph_dataset(df=df_val, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"docs\", labels_column_name=\"labels\", is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=50)\n",
    "val_loader =  DataLoader(val_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dataset = create_graph_dataset(df=df_test, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"docs\", labels_column_name=\"labels\", is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=50)\n",
    "test_loader =  DataLoader(test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "from torch_geometric.nn import GATConv"
   ]
  },
  {
   "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 = GATConv(in_channels=[128, 300], out_channels=300, heads=8, edge_dim=50, fill_value=0)\n",
    "\n",
    "    # word to sen GAT\n",
    "    self.w2sGAT = GATConv(in_channels=[300, 128], out_channels=128, heads=8, edge_dim=50, fill_value=0)\n",
    "\n",
    "    # ffn sent to word\n",
    "    self.ffns2w = PositionwiseFeedForward(d_in=8*300, d_out=300, d_h=512)\n",
    "\n",
    "    # ffn word to sent\n",
    "    self.ffnw2s = PositionwiseFeedForward(d_in=8*128, d_out=128, d_h=512)\n",
    "\n",
    "    self.wh = nn.Linear(128, 1)\n",
    "\n",
    "  def max_pool1d(self, x, seq_lens):\n",
    "    out = []\n",
    "    for index,t in enumerate(x):\n",
    "      if seq_lens[index] == 0:\n",
    "        t = t[:1]\n",
    "      else:\n",
    "        t = t[:seq_lens[index],:]\n",
    "      t = torch.t(t).unsqueeze(0)\n",
    "      out.append(torch.avg_pool1d(t, t.size(2)))\n",
    "\n",
    "    out = torch.cat(out).squeeze(2)\n",
    "    return out\n",
    "\n",
    "  def forward(self, data):# In the real implémentation remove nb_sent\n",
    "    # edge attr embeddings\n",
    "    edge_attr = torch.floor(data.edge_attr * 100).int()\n",
    "    edge_attr = self.edge_attr_embed(edge_attr)\n",
    "\n",
    "    # features\n",
    "    Xw = data.x[0]\n",
    "    Xs = data.x[1]\n",
    "    sent_lens = torch.sum(torch.sign(Xs),dim=1).data\n",
    "    \n",
    "    # embeddings\n",
    "    Xw = self.word_emb(Xw)\n",
    "    Xs = self.word_emb(Xs)\n",
    "\n",
    "    # CNN\n",
    "    XsCNN = self.convs(Xs.permute(0,2,1))\n",
    "    XsCNN = torch.max_pool1d(XsCNN, XsCNN.size(2)).squeeze(2)\n",
    "\n",
    "    # LSTM\n",
    "    # TO DO: ask \n",
    "    XsLSTM, _ = self.sent_LSTM(Xs)\n",
    "    XsLSTM = self.max_pool1d(XsLSTM, sent_lens)\n",
    "    Xs = torch.cat((XsCNN, XsLSTM), dim=1)\n",
    "\n",
    "    Hw = Xw\n",
    "    Hs = Xs\n",
    "\n",
    "    edge_index_w_i = data.edge_index[1][data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_s_j = data.edge_index[0][data.edge_index[1] < len(data.x[0])] - Hw.shape[0]\n",
    "    edge_attr_w = edge_attr[data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_w = torch.stack([edge_index_s_j, edge_index_w_i])\n",
    "\n",
    "    edge_index_s_i = data.edge_index[1][data.edge_index[1] >= len(data.x[0])] - Hw.shape[0]\n",
    "    edge_index_w_j = data.edge_index[0][data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_attr_s = edge_attr[data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_index_s = torch.stack([edge_index_w_j, edge_index_s_i])\n",
    "\n",
    "    Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "    Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    for i in range(self.num_iter):\n",
    "      if i != 0: # H^1w = H^0w = Xw\n",
    "        Hw = self.s2wGAT(x=[Hs, Hw], edge_index=edge_index_w, edge_attr=edge_attr_w) + torch.cat([Hw] * 8, dim=1)\n",
    "        Hw = self.ffns2w(Hw)\n",
    "        Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "\n",
    "      Hs = self.w2sGAT(x=[Hw, Hs], edge_index=edge_index_s, edge_attr=edge_attr_s) + torch.cat([Hs] * 8, dim=1)\n",
    "      Hs = self.ffnw2s(Hs)\n",
    "      Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    res = self.wh(Hs)\n",
    "\n",
    "    res = torch.sigmoid(res).squeeze(-1)\n",
    "\n",
    "    return res\n",
    "\n",
    "  def save(self, fname):\n",
    "    torch.save(self.state_dict(), fname)\n",
    "\n",
    "  def load(self, fname):\n",
    "    self.load_state_dict(torch.load(fname))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HeterSUMGraph(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300).to(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "  os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[\"docs\"])\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/100 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/100 [00:00<?, ?batch/s]/home/rsaid/anaconda3/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 100/100 [00:04<00:00, 20.00batch/s, accuracy=0.736, loss=0.551, mae=0.334]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.527, val mae = 0.331, val accuracy = 0.756, r1 = 0.392, r2 = 0.164, rL = 0.263\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 100/100 [00:04<00:00, 22.50batch/s, accuracy=0.74, loss=0.535, mae=0.338]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.530, val mae = 0.322, val accuracy = 0.778, r1 = 0.418, r2 = 0.197, rL = 0.299\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 100/100 [00:05<00:00, 19.25batch/s, accuracy=0.739, loss=0.533, mae=0.339]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.539, val mae = 0.308, val accuracy = 0.789, r1 = 0.427, r2 = 0.208, rL = 0.308\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 100/100 [00:03<00:00, 25.17batch/s, accuracy=0.74, loss=0.536, mae=0.337]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.526, val mae = 0.339, val accuracy = 0.795, r1 = 0.439, r2 = 0.223, rL = 0.323\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 100/100 [00:03<00:00, 27.51batch/s, accuracy=0.772, loss=0.527, mae=0.331]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.522, val mae = 0.294, val accuracy = 0.790, r1 = 0.420, r2 = 0.204, rL = 0.304\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 100/100 [00:03<00:00, 25.10batch/s, accuracy=0.776, loss=0.5, mae=0.308] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.474, val mae = 0.312, val accuracy = 0.778, r1 = 0.416, r2 = 0.195, rL = 0.294\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 100/100 [00:04<00:00, 21.85batch/s, accuracy=0.772, loss=0.49, mae=0.3]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.472, val mae = 0.289, val accuracy = 0.787, r1 = 0.424, r2 = 0.207, rL = 0.306\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 100/100 [00:04<00:00, 21.28batch/s, accuracy=0.783, loss=0.494, mae=0.303]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.472, val mae = 0.296, val accuracy = 0.802, r1 = 0.426, r2 = 0.210, rL = 0.309\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 100/100 [00:04<00:00, 22.95batch/s, accuracy=0.782, loss=0.49, mae=0.305]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.478, val mae = 0.273, val accuracy = 0.780, r1 = 0.416, r2 = 0.197, rL = 0.296\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 100/100 [00:04<00:00, 23.82batch/s, accuracy=0.782, loss=0.491, mae=0.304]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.476, val mae = 0.275, val accuracy = 0.788, r1 = 0.421, r2 = 0.203, rL = 0.300\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 100/100 [00:03<00:00, 25.02batch/s, accuracy=0.799, loss=0.488, mae=0.297]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.497, val mae = 0.362, val accuracy = 0.802, r1 = 0.449, r2 = 0.238, rL = 0.338\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 100/100 [00:04<00:00, 22.39batch/s, accuracy=0.805, loss=0.481, mae=0.301]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.467, val mae = 0.285, val accuracy = 0.795, r1 = 0.437, r2 = 0.224, rL = 0.322\n",
      "Training duration = 78.41065239906311\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "arr_train_loss = []\n",
    "arr_train_mae = []\n",
    "arr_train_acc = []\n",
    "arr_val_loss = []\n",
    "arr_val_mae = []\n",
    "arr_val_acc = []\n",
    "\n",
    "t1 = time()\n",
    "\n",
    "for epoch in range(1, epochs+1):\n",
    "  # Train\n",
    "  model.train()\n",
    "  nb_batch_train = 0\n",
    "  total_train_loss = 0\n",
    "  total_train_mae = 0\n",
    "  total_train_acc = 0\n",
    "  with tqdm(train_loader, unit=\"batch\", total=len(train_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "      tepoch.set_description(f\"Epoch {epoch}\")\n",
    "      #if dev != \"cpu\":\n",
    "      #  torch.cuda.empty_cache()\n",
    "      doc_lens = batch[\"doc_lens\"]\n",
    "      data = batch[\"docs\"].to(device)\n",
    "      targets = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "      y_pred = model(data)\n",
    "\n",
    "      loss = criterion(y_pred, targets)\n",
    "      optimizer.zero_grad()\n",
    "      loss.backward()\n",
    "      nn.utils.clip_grad_norm_(model.parameters(), 2.0)\n",
    "      optimizer.step()\n",
    "      nb_batch_train += 1\n",
    "      total_train_loss += loss.item()\n",
    "\n",
    "      probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "      probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "      total_train_mae += mae_fn(probs_tensor, targets).item()\n",
    "      total_train_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "      tepoch.set_postfix(loss=total_train_loss/nb_batch_train, mae=total_train_mae/nb_batch_train, accuracy=total_train_acc/nb_batch_train)\n",
    "\n",
    "  # Save model\n",
    "  model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "  # Eval\n",
    "  model.eval()\n",
    "  nb_batch_val = 0\n",
    "  total_val_loss = 0\n",
    "  total_val_mae = 0\n",
    "  total_val_acc = 0\n",
    "  total_r1 = 0\n",
    "  total_r2 = 0\n",
    "  total_rl = 0\n",
    "\n",
    "  del loss\n",
    "  del y_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  for i, batch in enumerate(val_loader):\n",
    "    #if dev != \"cpu\":\n",
    "    #  torch.cuda.empty_cache()\n",
    "    doc_lens = batch[\"doc_lens\"]\n",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "    y_pred = model(data)\n",
    "\n",
    "    loss = criterion(y_pred, targets)\n",
    "    nb_batch_val += 1\n",
    "    total_val_loss += loss.item()\n",
    "\n",
    "    doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "    summaries = val_set[\"summaries\"].iloc[i]\n",
    "\n",
    "    indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for j in range(min(len(doc), y_pred.shape[0])):\n",
    "      txt = txt + \". \" + doc[indices[j]]\n",
    "      y_pred_thresh.append(indices[j])\n",
    "      if len(txt) >= len(summaries):\n",
    "        break\n",
    "\n",
    "    y_pred_thresh.sort()\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for j in y_pred_thresh:\n",
    "      txt = txt + \". \" + doc[j]\n",
    "\n",
    "    n = min(len(txt), len(summaries))\n",
    "\n",
    "    while n < len(txt) and txt[n].isalnum():\n",
    "      n += 1\n",
    "\n",
    "    txt = txt[:n]\n",
    "\n",
    "    #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "    scores = scorer.score(summaries, txt)\n",
    "    total_r1 += scores[\"rouge1\"].recall\n",
    "    total_r2 += scores[\"rouge2\"].recall\n",
    "    total_rl += scores[\"rougeL\"].recall\n",
    "\n",
    "    probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "    probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "    total_val_mae += mae_fn(probs_tensor, targets).item()\n",
    "    total_val_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "  if len(arr_val_loss) >= early_stopping+1:\n",
    "    if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "      print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "      break\n",
    "\n",
    "  print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "\n",
    "  del loss\n",
    "  del y_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "  arr_train_mae.append(total_train_mae / nb_batch_train)\n",
    "  arr_train_acc.append(total_train_acc / nb_batch_train)\n",
    "\n",
    "  arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "  arr_val_mae.append(total_val_mae / nb_batch_val)\n",
    "  arr_val_acc.append(total_val_acc / nb_batch_val)\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_mae\"]  = arr_train_mae\n",
    "training_metrics[\"train_acc\"]  = arr_train_acc\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_mae\"]    = arr_val_mae\n",
    "training_metrics[\"val_acc\"]    = arr_val_acc\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "  json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Losses\n",
    "if is_graphic:\n",
    "  plt.plot(list(range(1, len(arr_train_loss) + 1)), arr_train_loss, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_loss) + 1)), arr_val_loss, label=\"val\")\n",
    "\n",
    "  plt.title(\"Loss\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"loss\")\n",
    "  plt.legend(loc=\"upper left\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABv9UlEQVR4nO3dd3hU1dbH8e9k0jsQEkoCCb13lV6kKVcUbKjY+xULYEUsiAULKjYQBGyvIl5FRUHpVUAQadJ7KAmhJSEJpM28f5wkEBIg/Uz5fZ4nT05OzpyzJiJZrL323ha73W5HRERExI14mB2AiIiISEVTAiQiIiJuRwmQiIiIuB0lQCIiIuJ2lACJiIiI21ECJCIiIm5HCZCIiIi4HSVAIiIi4naUAImIiIjbUQIkIk7niy++wGKxYLFYWLx4cYHv2+126tWrh8VioXv37gW+f+zYMXx8fLBYLPz999+FPuPuu+/Oe0ZhHyLi3DzNDkBEpKSCgoKYMmVKgSRnyZIl7N69m6CgoEJf9/XXX5ORkQHAlClTaNeuXaHX+fn5sXDhwjKNWUQcgxIgEXFagwYN4ptvvuGTTz4hODg47/yUKVPo0KEDycnJhb5u6tSphIeHU7t2baZNm8Z7772Hn59fges8PDxo3759ucUvIubREJiIOK1bb70VgGnTpuWdS0pK4scff+Tee+8t9DV//fUX//77L3fccQcPPPBA3vUi4l6UAImI0woODubGG29k6tSpeeemTZuGh4cHgwYNKvQ1U6ZMAeDee+/llltuwd/fP+9cYbKysgp82Gy2sn0jIlLhlACJiFO79957Wb16NZs3bwaM4a2bbrqp0P6ftLQ0pk+fTvv27WnSpAlBQUHcdNNNeT1D50tNTcXLy6vAR58+fcr9fYlI+VIPkIg4tW7dulG3bl2mTp3K3XffzZo1a3j33XcLvfb7778nOTk53/DYvffey5dffsnnn3/Oa6+9lu96Pz8/li5dWuA+5/YbiYhzUgIkIk7NYrFwzz338OGHH3LmzBkaNGhAly5dCr12ypQp+Pr6ctVVV5GYmAhAixYtiI6O5osvvuCVV17BarXmXe/h4XHBGWIi4tw0BCYiTu/uu+/m2LFjfPrpp9xzzz2FXrNjxw6WL1/OmTNnqFWrFpUqVcr72LdvH4cOHWLOnDkVHLmImEUVIBFxejVr1uTpp59m27Zt3HXXXYVek9vo/Nlnn1GvXr183zt9+jTXXXcdU6dOpV+/fuUer4iYTwmQiLiEN99884Lfy8rK4quvvqJx48bcf//9hV7Tv39/Zs6cydGjR6latSoANpuNVatWFXp969at8fHxKX3gImIKJUAi4vJmzZpFfHw8zz333AWvefDBB5kxYwZff/01w4cPB4zKUIcOHQq9fufOnQUqSSLiPCx2u91udhAiIiIiFUlN0CIiIuJ2lACJiIiI21ECJCIiIm5HCZCIiIi4HSVAIiIi4naUAImIiIjb0TpAhbDZbBw+fJigoCAsFovZ4YiIiEgR2O12Tp06RY0aNfDwuHiNRwlQIQ4fPkxUVJTZYYiIiEgJHDhwgMjIyIteowSoEEFBQYDxAwwODjY5GhERESmK5ORkoqKi8n6PX4wSoELkDnsFBwcrARIREXEyRWlfURO0iIiIuB0lQCIiIuJ2lACJiIiI21EPkIiISAXLzs4mMzPT7DCckre39yWnuBeFEiAREZEKYrfbiY+PJzEx0exQnJaHhwcxMTF4e3uX6j5KgERERCpIbvITHh6Ov7+/FtstptyFiuPi4qhVq1apfn5KgERERCpAdnZ2XvJTpUoVs8NxWlWrVuXw4cNkZWXh5eVV4vuoCVpERKQC5Pb8+Pv7mxyJc8sd+srOzi7VfZQAiYiIVCANe5VOWf38lACJiIiI21ECJCIiIhUmOjqacePGmR2GmqBFRETk4rp3706rVq3KJHFZs2YNAQEBpQ+qlFQBEhERkVKx2+1kZWUV6dqqVSrj72UBm62co7o4JUAiIiJyQXfffTdLlizhgw8+wGKxYLFY+OKLL7BYLMyZM4d27drh4+PDsmXL2L17N9dddx0REREEBgZy2WWXMX/+/Hz3i46pw7g3XoRj2wCjqXny5MkMHDgQf39/6tevz8yZM8v9fSkBEhERMYHdbictI8uUD7vdXuQ4P/jgAzp06MADDzxAXFwccXFxREVFAfDMM88wZswYtm7dSosWLUhJSaFfv37Mnz+fdevW0bdvX/r3709sbOy579z4ZPXJO/PKK69w8803s3HjRvr168fgwYM5ceJEWfyYL0g9QCIiIiY4nZlNk5fmmPLsLaP74u9dtBQgJCQEb29v/P39qVatGgDbthnVm9GjR9O7d++8a6tUqULLli3zvn7ttdf46aefmDlzJo8++qhxMjf58jybAN19993ceuutALzxxht89NFHrF69mquuuqrE7/FSVAESERGREmnXrl2+r1NTU3nmmWdo0qQJoaGhBAYGsm3btgtUgM7u5dWiRYu844CAAIKCgkhISCjP0M2vAI0fP5533nmHuLg4mjZtyrhx4+jSpUuh1y5fvpxnn32Wbdu2kZaWRu3atXnooYcYNmxYvusSExMZOXIkM2bM4OTJk8TExPDuu+/Sr1+/inhLIiIil+TnZWXL6L6mPbssnD+b6+mnn2bOnDmMHTuWevXq4efnx4033khGRsY5VxWsAJ2/pYXFYsFWzk3SpiZA06dPZ+jQoYwfP55OnToxceJErr76arZs2UKtWrUKXB8QEMCjjz5KixYtCAgIYPny5Tz00EMEBATw4IMPApCRkUHv3r0JDw/nhx9+IDIykgMHDhAUFFTRb09EROSCLBZLkYehzObt7V2krSeWLVvG3XffzcCBAwFISUlh3759Zy+w288OgZ3TA2QGU3/y7733Hvfddx/3338/AOPGjWPOnDlMmDCBMWPGFLi+devWtG7dOu/r6OhoZsyYwbJly/ISoKlTp3LixAlWrFiRl1HWrl27At6NiIiIa4qOjuavv/5i3759BAYGXrA6U69ePWbMmEH//v2xWCy8+OKL+a+1nTNV/pwhMDOY1gOUkZHB2rVr6dOnT77zffr0YcWKFUW6x7p161ixYgXdunXLOzdz5kw6dOjAkCFDiIiIoFmzZrzxxhsXzVzT09NJTk7O9yEiIiKGp556CqvVSpMmTahatep5PT1nvf/++1SqVImOHTvSv39/+vbtS5s2bc5ekJ0zFGaxgoe5bcimVYCOHTtGdnY2ERER+c5HREQQHx9/0ddGRkZy9OhRsrKyGDVqVF4FCWDPnj0sXLiQwYMHM3v2bHbu3MmQIUPIysripZdeKvR+Y8aM4ZVXXin9mxIREXFBDRo0YOXKlfnO3X333QWui46OZuHChfnODRky5OwXWens+2sWeAfmnSpsSn5iYmKp4i0K0wcfz9/V1W63X3Kn12XLlpGSksKqVat47rnnqFevXt70OZvNRnh4OJMmTcJqtdK2bVsOHz7MO++8c8EEaMSIEQwfPjzv6+Tk5Lw1DkRERKSMZKcbnz3NHf4CExOgsLAwrFZrgWpPQkJCgarQ+WJiYgBo3rw5R44cYdSoUXkJUPXq1fHy8sJqPdvh3rhxY+Lj48nIyMDbu+AP3cfHBx8fc5uxREREXF5WzhCYyQ3QYGIPkLe3N23btmXevHn5zs+bN4+OHTsW+T52u5309PS8rzt16sSuXbvyNV3t2LGD6tWrF5r8iIiISAXJyq0AuXECBDB8+HAmT57M1KlT2bp1K8OGDSM2NpaHH34YMIam7rzzzrzrP/nkE3799Vd27tzJzp07+fzzzxk7diy333573jX//e9/OX78OE888QQ7duxg1qxZvPHGG/nHIEVERKTi5Q6BmTwDDEzuARo0aBDHjx9n9OjRxMXF0axZM2bPnp03bT0uLi5fp7nNZmPEiBHs3bsXT09P6taty5tvvslDDz2Ud01UVBRz585l2LBhtGjRgpo1a/LEE0/w7LPPVvj7ExERkRy27LPT4B2gAmSxF2dHNDeRnJxMSEgISUlJBAcHmx2OiIi4gDNnzrB3715iYmLw9fU1O5yKl3kajm4zpsBXb3Hp6y/gYj/H4vz+1l5gIiIiUv4cqP8HlACJiIhIRXCg/h9QAiQiIiIVIXcKvCpAIiIi4g6io6MZ9/GnxhcOsAYQKAESERGRimDP2ZPTAVaBBiVAIiIiUhFyp8CrAiQiIiKObuLEidSsWTPfDgsA1157LXfddRe7d+/muuuuIyIigsDAQC677DLmz59/3l1yV9yxgNWrQuK+FCVAIiIiZrDbISPVnI9iLAF40003cezYMRYtWpR37uTJk8yZM4fBgweTkpJCv379mD9/PuvWraNv3770798/30LGefmPpw9cYsPzimL6bvAiIiJuKTMN3qhhzrOfPwzeAUW6tHLlylx11VV8++239OzZE4D//e9/VK5cmZ49e2K1WmnZsmXe9a+99ho//fQTM2fO5NFHH805m5MBOcgUeFAFSERERC5h8ODB/Pjjj3mbj3/zzTfccsstWK1WUlNTeeaZZ2jSpAmhoaEEBgaybdu28ypAOQmQg0yBB1WAREREzOHlb1RizHp2MfTv3x+bzcasWbO47LLLWLZsGe+99x4ATz/9NHPmzGHs2LHUq1cPPz8/brzxRjIyMs65Q24FSAmQiIiIe7NYijwMZTY/Pz+uv/56vvnmG3bt2kWDBg1o27YtAMuWLePuu+9m4MCBAKSkpLBv377z7pBbAXKcITAlQCIiInJJgwcPpn///mzevJnbb78973y9evWYMWMG/fv3x2Kx8OKLL+afMWa3nx0Cc6AKkHqARERE5JKuvPJKKleuzPbt27ntttvyzr///vtUqlSJjh070r9/f/r27UubNm3OvjB3/R9QBUhERESci9Vq5fDhgj1L0dHRLFy4MN+5IUOGnP0iK519f80CDy+wOE7dxXEiEREREdeT7ViboOZSAiQiIiLlJ8uYOq8ESERERNxHdk4C5ECLIIISIBERESlPWRoCExERcXv2YuzD5RLyKkBlkwCV1c9PCZCIiEgF8PIydkFPS0szOZIKZMs+Ow2+jKbA564wbbVaS3UfTYMXERGpAFarldDQUBISEgDw9/fH4iA7o5ebzNOQZQeskJEFZF3qFRdls9k4evQo/v7+eHqWLoVRAiQiIlJBqlWrBpCXBLm8zDRIPWYMf6XuLZNbenh4UKtWrVInj0qAREREKojFYqF69eqEh4eTmZlpdjjl75+vYMWHUL8PtHijTG7p7e2Nh0fpO3iUAImIiFQwq9Va6h4Wp3B8C6QcgMBK4OtrdjT5qAlaREREysfJnGGvyjHmxlEIJUAiIiJSPk7kJECVlACJiIiIO8jOhKSDxrEqQCIiIuIWEmPBng2evhBYzexoClACJCIiImUvt/+nUjSUwaytsuZ4EYmIiIjzc+D+H1ACJCIiIuXh5D7jswP2/4ASIBERESkPuQmQKkAiIiLiNk447hpAoARIREREyprdrgqQiIiIuJmUBMhMBYsHhNYyO5pCKQESERGRspU7BT44Ejy9zY3lApQAiYiISNnK6/+JNjWMi1ECJCIiImXrpGOvAQRKgERERKSsOfgMMFACJCIiImVNFSARERFxO6oAiYiIiFtJPwVpx4xjVYBERETELeRWf/yrgG+wubFchBIgERERKTtO0P8DSoBERESkLOVWgCpFmxrGpSgBEhERkbJz0vEboEEJkIiIiJSlExoCExEREXejCpCIiIi4lawMSDpoHKsCJCIiIm4h6QDYbeDpB0HVzI7mopQAiYiISNk4dwaYxWJqKJeiBEhERETKhpP0/4ASIBERESkrTjIDDJQAiYiISFlRBUhERETcjipAIiIi4lbsdji5zzhWBUhERETcwql4yDoNFg8IiTI7mktSAiQiIiKll9v/ExIJnt7mxlIESoBERESk9Jyo/weUAImIiEhZcKL+H1ACJCIiImXhpCpAIiIi4m5OOM8aQKAESERERMqCKkAiIiLiVs4kQ9px41gVoKIZP348MTEx+Pr60rZtW5YtW3bBa5cvX06nTp2oUqUKfn5+NGrUiPfff/+C13/33XdYLBYGDBhQDpGLiIgIcLb64x8GPkHmxlJEnmY+fPr06QwdOpTx48fTqVMnJk6cyNVXX82WLVuoVatWgesDAgJ49NFHadGiBQEBASxfvpyHHnqIgIAAHnzwwXzX7t+/n6eeeoouXbpU1NsRERFxT07W/wNgsdvtdrMefsUVV9CmTRsmTJiQd65x48YMGDCAMWPGFOke119/PQEBAXz99dd557Kzs+nWrRv33HMPy5YtIzExkZ9//rnIcSUnJxMSEkJSUhLBwcFFfp2IiIhbWv4+zB8FzW+GGz4zLYzi/P42bQgsIyODtWvX0qdPn3zn+/Tpw4oVK4p0j3Xr1rFixQq6deuW7/zo0aOpWrUq9913X5Huk56eTnJycr4PERERKSInrACZNgR27NgxsrOziYiIyHc+IiKC+Pj4i742MjKSo0ePkpWVxahRo7j//vvzvvfnn38yZcoU1q9fX+RYxowZwyuvvFKs+EVERCSHk80AAwdogrZYLPm+ttvtBc6db9myZfz99998+umnjBs3jmnTpgFw6tQpbr/9dj777DPCwsKKHMOIESNISkrK+zhw4EDx34g4hMxsG0eSz7D5cBK7Ek6RkWUzO6SiO7wOdi0wOwoRkeI7sc/4rArQpYWFhWG1WgtUexISEgpUhc4XE2P8gJs3b86RI0cYNWoUt956K7t372bfvn30798/71qbzfgF6Onpyfbt26lbt26B+/n4+ODj41PatyTlINtmJzEtg+OpGRxPyeB4arrxOSW94LnUDJJOZ+Z7vdXDQq3K/tQJC6BueCB1qwZQp2ogdasGUjnAgTbrS0+BL6+F9FPw2FqoUvDPqYiIQ8rKgOSDxrETVYBMS4C8vb1p27Yt8+bNY+DAgXnn582bx3XXXVfk+9jtdtLT0wFo1KgRmzZtyvf9F154gVOnTvHBBx8QFRVVNsFLidntdpLPZHEi1UhijuUkMCdyEphjKUYycyI153xqBrZitul7WKBygDenM7JJzchm77FU9h5LZcG2hHzXhfp7Ubdq/qSoTtUAalX2x8tawcXRLT9Dek7v2e6FSoBExHkkxoLdBl4BEBhudjRFZuo0+OHDh3PHHXfQrl07OnTowKRJk4iNjeXhhx8GjKGpQ4cO8dVXXwHwySefUKtWLRo1agQY6wKNHTuWxx57DABfX1+aNWuW7xmhoaEABc5L2UnLyMqrwBxPSc9/nJPUnDinWpOZXfyJh6H+XlQJ8KZKoE/OZ2+qBPgQFuhN5QAfqgR6E5ZzLsTPCw8PC3a7nYRT6exOSGH30RR2H01l99EU9hxN5VDiaRLTMlm7/yRr95/M9yxPDwu1qvjnJEdGUpSbKIX6l1PVaN03Z4/3LIbLHyif54iIlLW8/p9ouEQLiyMxNQEaNGgQx48fZ/To0cTFxdGsWTNmz55N7dq1AYiLiyM2NjbvepvNxogRI9i7dy+enp7UrVuXN998k4ceesist+Dy0rOyWb7zGHuPpRrVmtyhp3OSndOZ2cW+b6CPJ1UCvakccDaRqZKTzOQmMkaS402lAO8SVWQsFgsRwb5EBPvSsV7+nrDTOZUhIzEykqLcz6czs9lzNJU9R1OZx5F8r6sS4J0vKcr9HFnJD8+SVo2O74bYc2Y+7l0G2VlgNfV/TxGRonHCGWBg8jpAjsrd1wGy2eys2nucmesPM3tTHMlnsi75Gm9PD8JyKzTnJTBnz52t4Ph6WSvgnRSfzWYnPvlMgaRo99EU4pLOXPB1XlYL0VUCCiRHdaoGEuLndfGHLhgNy96FulfCobVwJgnuXwiRbcv43YmIlIM/RsCq8dDhUej7uqmhFOf3t/6JKYDRm7P5cDK/rD/ErxviiE8++8s+ItiHy2OqEBboTVhOAlM5J5kxKjc+BHhbLzl7zxl4eFioEepHjVA/utSvmu97qelZ51SNziZHe46mkJ5lY2dCCjsTUgrcs2qQT14Tdu7nelUDqRHqhxUbrDdmMdLmTvAOgK2/wp5FSoBExDmcOGcIzIkoAXJz+4+n8sv6w/yy/hC7j6bmnQ/y9aRfs+pc17oGV8RUwerh/MlNaQX4eNKsZgjNaobkO2+z2TmcdNpIihJS2HMshd0Jqew5lsKR5HSOnjI+/tp7It/rvD09uClkG6+nHua0ZzBzT7ekU/hhwrb+avQBdX2qAt+diEgJnXTOITAlQG7o6Kl0Zm08zC8bDrMuNjHvvLenB70ah3Nty5r0aFQVH0/HHKZyNB4eFiIr+RNZyZ9uDfJXjU6dyTxbNcpJinYnpLL3eCoZWTY6JP8BVph+pj2jfthKjMWHRT5gj/0LS0YaePub9K5ERIrAZoOT+4xjJ5oCD0qA3MapM5nM3XyEXzYc5s9dx8jOmVvuYYFO9cK4tmUN+jarRrDvJfpVpFiCfL1oERlKi8jQfOezbXbi4g5TY8pasEFy41u47FQl1uyzc8hehZq240yZNo1+A26jeoifOcGLiFxKSjxknQGLFUILbmLuyJQAubCMLBuLtyfwy4bDzN9yhPRzVkVuGRnCda1qck2L6oQH+5oYpXuyeliIPDQbbJkQ0ZzHB9/A48Dmw0ns/bYdNVPmkLlzEd3eqcGd7Wvz3+51qRKoxTpFxMHk9v+ERILVuf4BrQTIxdhsdlbvO8Ev6w8xe1N8vpWR64QFcF2rmlzbqgYxYQEmRikArPva+Nx6cN6ppjVCoM+NMGMOvf228eYpG5OX72Xa6lju61KHB7rEEKQqnYg4Cift/wElQC7BbrezJS6ZmesPM3PD4XzTtcODfOjfsgYDWtWkWc1gl5ip5RLi/4W4DeDhBc1vzv+9mG4A1MncxbeD6zNmcQKbDiXx4YKdfLVyH490r8udHaIddikBEXEjJ5xvE9RcSoCcWOzxNGZuOMTP6w+z65zp10G+nlzdrBoDWtXkijqaweWQ1ues/Nzwagiokv97QRFQtTGWo1vp6LGFmY9exx//xjN27nZ2H03ljdnbmLJ8L4/3rM/N7aIqftsOEZFcqgBJRTmWks6sjXH8sv4Q/5w3g6tno3Cua1WD7g3DVR1wZFkZsHG6cdz69sKvqdMdjm6FPYuxNB3A1c2r07tJBD+tO8S4+Ts5lHiakT/9y8QlexjeuwH9W9ZQoisiFU8VIClPKelZzN0czy/rD7P8vBlcHeuGcW2rGlylGVzOY8cfkHYcAqtB3Z6FX1OnO/w1AfYuyTvlafXgpnZRXNuqBt+tPsBHC3cReyKNodPXM2Hxbp7q25BejcM1zCkiFUcVIClrGVk2lu44ys/rDzF/6xHOZOafwXVtq5r01wwu55Q7/NXylgvv9xXdyZhWemIPnNwPlWrnfcvH08pdHaO5qV0kn/+5j4lLdrP9yCke+OpvWkWF8kzfhgX2PhMRKXOnE+F0zmbSTrYKNCgBcig2m501+07wc84eXOfO4IoJC+C6VjW4tmUN6lQNNDFKKZVT8bBznnF8oeEvAJ8giGwHB/4yqkCV7ixwib+3J0N61OP2K2ozadlupi7fx/oDidw2+S861wvjqb4NaRUVWj7vQ0Qkt/oTUNX4O8vJKAEymd1uZ2vcKX7ZcIhf1x/mcCEzuK5rVYPmNUM0tOEKNnwH9myIvBzC6l/82jrdjQRozxJjn7ALCPH34um+jbirYzTjF+3mm7/2s3zXMZbvOkafJhE82achDas5319OIuLgnHQF6FxKgExy4EQaMzcYe3DtOHLODC4fT65qVo0BrWvSXjO4XIvdfnb462LVn1x1usOSt4x9wWw28Lj4bK/wIF9GXduU+zrH8MGCncz45yBztxxh3tYjDGxVk6G9GlCrirbWEJEycsJ5+39ACVCFOpGawW8bD/PL+sOs3X8y77y31YMrG4UzoLVmcLm0g3/DsR3g6QdNB176+prtwMsf0o5Bwhao1qxIj4mq7M/Ym1rycLc6vDdvB7M3xTNj3SFmbjjMLZdH8fiV9dU7JiKld9J5Z4CBEqAK9fe+E7z0y2YALBboWLcK17WsSd9m1Qjx0wwul5e78nOT68A3+NLXe3pD7U6wa55RBSpiApSrXngQ4we3ZdPBJN6Zu52lO47yf6ti+WHtQe7qGM3DXetSKcC7+O9DRARUAZKi69awKh3qVKFn43D6t6xBhP4V7j4y0uDfGcZxUYa/ctXpbiRAe5dAx0dL9OjmkSF8de/lrNpznHfmbGft/pNMXLKHb1fF8mDXOtzTOYZAH/1VICLFpB4gKSofTyvTHmxvdhhihq2/QsYpCK1tVHWKqk534/O+P40FFD1LXrFpX6cKPzzcgUXbE3hnzg62xiXz7rwdfLFiH4/0qMfgK2pp+FVEiiYrHZIOGsdOWgHSGvoiFSF3+KvV4Es2M+cT3gT8wyAzFQ79XeowLBYLVzaKYNZjnfno1tbEhAVwPDWDV3/bwpVjFzN9TSxZ2bZL30hE3FtiLGAHrwBjGrwTUgIkUt5O7oN9ywALtLq1eK/18IA6xuao7Fly8WuLdVsL/VvWYO6wrrx5fXOqh/hyOOkMz/64iT7vL+XXDYex5aw4LiJSwLn9P066RIsSIJHytn6a8blONwitVfzX5w6D7VlcVhHl8bJ6cMvltVj0VHdevKYJlQO82XMslcemreOaj5azaFsCdrsSIRE5T94MsGhTwygNJUAi5clmg/XfGsetitH8fK6YnArQob8h/VTZxHUeXy8r93WOYekzPRjeuwFBPp5siUvmni/WcPPElazee6JcnisiTsrJZ4CBEiCR8rVvKSTFgk8INL6mZPeoVNuYZWHLgv0ryja+8wT6ePJ4z/osfaYHD3Wtg4+nB2v2neTmiSu5a+pq/j2UVK7PFxEn4eRrAIESIJHytS5n5efmN4CXX8nvU47DYIWpFODNiH6NWfpMD25vXwtPDwtLdhzlmo+W88g3a9mVkHLpm4iI61IFSIpt++/GDrri+s4kwdaZxnFJh79y5TVCLy7dfYopItiX1wY0Z8GT3RjYuiYWC8zeFE+f95fw9P82cPBkWoXGIyIOwGZz+jWAQAlQxYpdBdNvh0ndIW6j2dFIefv3R8g6A1UbQc02pbtXdFfAYmyJcepImYRXHLWrBPD+oFb88URX+jSJwGaH/609yJVjl/DG7K1ka8aYiPs4FQfZ6eDhCSFRZkdTYkqAKpKnLwTXMMZOp/Q+2xwrril3+KvV4NJPEw2oAtVbGMd7l5buXqXQsFoQk+5sx0+PdKRTvSpkZNuYtHQPP6w9YFpMIlLBcvt/QqLA6rzrKSsBqkg1WsGDS6Beb6My8PN/4dcnIPOM2ZFJWTu63Zi1ZbFCy1vK5p4V3Ad0Ma1rVeKb+9vzdN+GAHwwfyfpWdkmRyUiFcIF+n9ACVDF868Mt30PPUYCFlj7BXx+Vc6qmuIy1v2f8blBXwgML5t7xpzTB+Qga/Pc1zmGasHGIorf/qU/wyJuwQVmgIESIHN4eEC3Z+D2H8CvEhxeBxO7ws75ZkcmZSE7EzZ8Zxy3Glx2963VAazekHwQTuwpu/uWgq+Xlcd71gfgk0W7SMvIMjkiESl3qgBJqdXrBQ8thRqt4fRJ+OZGWPym0WEvzmvXfEhNMPbHadC37O7r7Q9RVxjHexaV3X1L6aZ2kdSu4s+xlAy+WLHP7HBEpLypAiRlIrQW3DsH2t0L2GHxGPj2JkjTyrtOK3f4q8UgsHqV7b1Nmg5/MV5WD4b2MqpAE5fsIel0pskRiUi5UgVIyoynD1zzPgz41Jgptms+TOxmDI2Jc0k5Cjv+MI7LcvgrV50exue9S8HmOE3H17asSf3wQJJOZzJ5mWMMz4lIOTh9Es4kGsehtU0NpbSUADmSVrfC/fONsmJSLEzpYzRJO0jDqxTBpu+NLStqtIaIJmV//+qtjG01ziRB3Iayv38JWT0sPNnHmBE2dflejqekmxyRiJSL3OpPQDj4BJobSykpAXI01ZrDg4uhYT/IzjCmyf8yBDJPmx2ZXIrdfnbtn9alXPn5QqyeENPFOHagYTCAvk0jaBEZQmpGNhMW7zY7HBEpDyddY/gLlAA5Jr9QGPQN9HwZLB6w/huY3NthZv7IBcSth4TNYPWBZjeU33NiHK8PCMBiOVsF+mrVfuKSlLSLuJwTrtEADUqAHJeHB3QZDnf8DP5hcGQTTOxu7CUmjim3+bnxNcbyBuUld0HE2FUOVxnsWj+My6Mrk5Fl46OFu8wOR0TKmipAUmHqdIOHl0Hk5ZCeBNNugQWjHaoBVjBW8970P+O4vIa/coXVh6Aaxl48B/4q32cVk8Vi4amc1aG/X3OA2OPaLFXEpZzYZ3xWBUgqRHANuHsWXP6Q8fWyd+HrgZB6zNy45Kzts4zG5ODIs0NU5cViccjp8Lkuj6lMtwZVybLZGTd/h9nhiEhZUgVIKpynN/R7G26YAl7+sHeJsXr0gTVmRyZwdvir1a3gYS3/5znQvmCFeSqnF+in9YfYceSUydGISJnIPAPJh41jVYCkwjW/ER5YCFXqQ/Ih+PxqWP2ZpsqbKekg7M5ZmbnVbRXzzNwq0+H1xrocDqZ5ZAhXNa2G3Q7vzVUVSMQlJMYCdvAOhIAws6MpNSVAzii8sZEENbkObJkw+ymY8QBkpJodmXvaMA2wQ+3OULlOxTwzuDqENTSeu3dZxTyzmIb3aYDFAn9sjmfTwSSzwxGR0jp3CwyLxdxYyoASIGflGww3fQl9XgeL1WjA/awnHNPMmwqVb+2fclj5+WIcfBisQUQQA1vVBGDs3O0mRyMipZa3BUa0qWGUFSVAzsxigY6Pwt2/QWAEHN0Kk7rDlplmR+Y+9q8w/lXkHWhU5CpSbgK0d0nFPrcYhvZqgKeHhSU7jrJ6r/a3E3FqLrIJai4lQK6gdkdjV/laHSHjFHx/B8x9AbKzzI7M9a3Pqf40HQjeARX77OhORvXv+C5IPFCxzy6iWlX8ufmyKADGztmOXb1qIs7LRTZBzaUEyFUEVYO7ZkLHx4yvV3wEX10Lp46YG5crSz8Fm382jst77Z/C+IZAzTbGsQNXgR67sh7enh6s3neCpTu1dIOI01IFSByW1Qv6vAY3fwXeQbD/T5jYxRimkbK3+WfITIUq9SDqCnNiyOsDctwEqHqIH3e2N3aNfneuqkAiTslmg5P7jWNVgMRhNbkOHlwEVRtByhH44hpY+Ymmype13OGvVoPNmxFxbiO0A//3/W/3ugR4W9l4MIk5m1WVFHE6pw4bq897eBoLvroAJUCuKqw+3L8Amt0I9myY8zz87y5j2EZK7/huiF1pbFbb8lbz4oi8DDz9IDUBEraaF8clVAn04d7Oxr8a3527nWyb4yZrIlKI3P6f0Fpg9TQ3ljKiBMiV+QTCDZPh6nfAwwu2/AKTekDCNrMjc3651Z+6PY01eczi6WM0wYPDTofPdX+XOgT7erIzIYWZGw6ZHY6IFIeL9f+AEiDXZ7HAFQ/CPbONDTSP74TProRNP5gdmfOyZcP6acZxRa/9UxgnmA4PEOLnxcPd6wLw/rydZGbbTI5IRIrMxWaAgRIg9xF1uTFVPqar0bj7433w+7OQlWF2ZM5n9yJjPNyvEjTsZ3Y0ZzdG3bccsjPNjeUS7u4YTVigD7En0vjf3wfNDkdEikoVIHFqgVXhjp+h83Dj678+hS+vObu5nRTN+pyNT5vfbAxBmS2iOfhVhowUOLTW7Gguyt/bkyE9jCrQhwt2ciYz2+SIRKRIVAESp+dhhV4vwy3TwCcEDvwFn3Zx6GnUDiXtBGybZRw7wvAXgIfH2SqQE/x3vO2KWtQI8SU++Qz/t2q/2eGISFGoAiQuo1E/eGixUT1IOwZfD4Dl7zv0VGqHsOkHyM6Aas2hekuzoznLwfcFO5ePp5UnetUHYMLi3aSma8VyEYeWdgLO5GxoXCna1FDKkhIgd1a5Dtw3F1reBnYbzB8F3w0++wddCsod/mplwsrPFxOTUwE6uBrSU8yNpQhuaBNJTFgAx1Mz+PzPvWaHIyIXk1v9CawG3v7mxlKGlAC5O29/GDAerhkHVm/YPsvYUDX+X7MjczzxmyBug7GkQPObzI4mv8oxEFobbFlOsfK3p9WDoTlVoIlL95CU5tjN2yJuzQX7f0AJkIAxVb7dPXDvHAipBSf2wOReZ6d6i2Fdzto/Da+GgCrmxlIYJ5kOn6t/ixo0qhbEqTNZTFy62+xwRORCXLD/B5QAyblqtoGHlhiL+2Wdhp8fht+GQVa62ZGZLysDNn1vHLe+w9xYLiSvEXqxqWEUlYeHhSf7NATg8z/3cfSU/pyJOKQT+4zPqgCJS/OvDIP/B92eAyzw91SYehUkxpodmbl2/AFpx40x8LpXmh1N4XL7gI78CylHzY2liHo1DqdlVCinM7MZv3iX2eGISGFUARK34WGFHiOMRMg3FA7/A5N7Q5Ibb1+wLqf5ueUtjrsPTkCYMTsNnGYYzGKx8HROFeibVbEcSjxtckQiUoB6gMTt1O9trB4d1hBS4mHaIKeYYVTmTsXDrnnGcWsHm/11PieaDp+rU70qtK9TmYxsGx8t2Gl2OCJyrszTxsr3oAqQuJlKtWHw9+AfZsyCmvEg2NxsD6cN3xnLBERdAWH1zY7m4mK6G5/3LHGaNZ0sFgtP9zWqQP9be5C9x1JNjkhE8pzMWazUJ9hokXAhSoDk0ipFwy3fnp0mv2CU2RFVHLv97M7vrRxk5eeLqd3BmKafFHt23N4JtK1dmSsbhZNtszNu/g6zwxGRXHn9P7WNGcMuRAmQFE2tK+C6T4zjPz+Af74yN56KcnANHNsBnn7QdKDZ0Vyad4BRqQKnGgYDeLJPAwBmbjjMtvhkk6MREeBs/4+LDX+BAyRA48ePJyYmBl9fX9q2bcuyZcsueO3y5cvp1KkTVapUwc/Pj0aNGvH+++/nu+azzz6jS5cuVKpUiUqVKtGrVy9Wr15d3m/DPbS4Gbo9axz/Ngz2Xvi/lcvIbX5uOgB8g00NpcicbDp8rqY1QvhP8+rY7fDuXFWBRBzCSddsgIZSJEBff/01nTp1okaNGuzfb4wRjhs3jl9++aXI95g+fTpDhw5l5MiRrFu3ji5dunD11VcTG1v4lOuAgAAeffRRli5dytatW3nhhRd44YUXmDRpUt41ixcv5tZbb2XRokWsXLmSWrVq0adPHw4dcuMZTGWp+whoer2x4vD02+G4Cy9gl5EG/84wjp1h+CtX3oKIS52uX2tY7wZ4WGDeliOsP5BodjgiogpQfhMmTGD48OH069ePxMREsrOzAQgNDWXcuHFFvs97773Hfffdx/3330/jxo0ZN24cUVFRTJgwodDrW7duza233krTpk2Jjo7m9ttvp2/fvvmqRt988w2PPPIIrVq1olGjRnz22WfYbDYWLFhQkrcq57NYjK0zaraFM4nw7c3GRnmuaOtMyDhlbDFRu5PZ0RRdjTbgHQSnT0L8RrOjKZZ64YFc3yYSgHfnbjc5GhHh5D7jsypAho8++ojPPvuMkSNHYrVa8863a9eOTZs2FekeGRkZrF27lj59+uQ736dPH1asKNpeRuvWrWPFihV069btgtekpaWRmZlJ5coX7l5PT08nOTk534dchJcf3DINQqLg+C74/k5jpWRXkzv81fp28DB9tLjorJ4Q3dk4drJhMIAnetbHy2ph2c5jrNx93OxwRNyXLRsSc2aBqQJk2Lt3L61bty5w3sfHh9TUok1hPXbsGNnZ2UREROQ7HxERQXx8/EVfGxkZiY+PD+3atWPIkCHcf//9F7z2ueeeo2bNmvTq1euC14wZM4aQkJC8j6ioqCK9B7cWFAG3fgfegbBvGcwa7jTTrovk5D7jfWGBlreaHU3xOeF6QLmiKvtzy2W1ABg7dzt2V/pzJeJMkg9DdoYxszQk0uxoylyJEqCYmBjWr19f4Pzvv/9OkyZNinUvy3nT6ux2e4Fz51u2bBl///03n376KePGjWPatMI37Xz77beZNm0aM2bMwNfX94L3GzFiBElJSXkfBw4cKNZ7cFvVmsGNU8HiAeu+hpUfmx1R2Vn/rfG5TjcIdcKEODcBil0FmWdMDaUkHr2yHj6eHqzdf5LF251jWw8Rl5PbAB1ay9ghwMWUaE3/p59+miFDhnDmzBnsdjurV69m2rRpjBkzhsmTJxfpHmFhYVit1gLVnoSEhAJVofPFxBiluObNm3PkyBFGjRrFrbfm/1f62LFjeeONN5g/fz4tWrS46P18fHzw8fEpUtxyngZ9oc/rMGcEzH0RKteFRv3Mjqp0bDZYn5NUt3LwlZ8vpGpDY9+ylHg4uBpiupodUbFEBPtyd8doJi7dw9i52+nWoCoeHq61BomIw3PRLTBylagCdM899/Dyyy/zzDPPkJaWxm233cann37KBx98wC233FKke3h7e9O2bVvmzZuX7/y8efPo2LFjkWOx2+2kp+ffRfqdd97h1Vdf5Y8//qBdu3ZFvpeUUPv/Qtt7ADv8eD/EOVfjbQH7lhoLCfqEQONrzI6mZCwWp50On+vhbnUJ9PFk8+Fkfv/34sPiIlIOXHQT1Fwl7ux84IEH2L9/PwkJCcTHx3PgwAHuu+++Yt1j+PDhTJ48malTp7J161aGDRtGbGwsDz/8MGAMTd15551513/yySf8+uuv7Ny5k507d/L5558zduxYbr/97L/S3377bV544QWmTp1KdHQ08fHxxMfHk5LihntYVRSLBfq9Ywy7ZKbCt4MgOc7sqEpuXc7Kz81vMBq+nZUT9wEBVArw5r7Oxl+8783bTrZNvUAiFcrFK0Cl3tY6LCysxK8dNGgQx48fZ/To0cTFxdGsWTNmz55N7dq1AYiLi8u3JpDNZmPEiBHs3bsXT09P6taty5tvvslDDz2Ud8348ePJyMjgxhtvzPesl19+mVGjRpU4VrkEqxfc9CVM6W2snPzdrXD3bPD2Nzuy4jmdaEx/B+cd/soVk1MBOrzOeF9+oWZGUyL3d4nhy5X72H00lZ/WHeLGtq7XiCnisFy8AmSxl3CKxQ8//MD3339PbGwsGRn5p0D/888/ZRKcWZKTkwkJCSEpKYngYCdZ/ddRnNgDn/WE0yegyXVw4xfONYX876nGKtdVG8MjK51/75uP2sHxnTDoG6cdzpu4ZDdjft9GZCU/Fj7ZHW9PJ/rzJOKs7HZ4szakJ8EjqyC8sdkRFUlxfn+X6G+SDz/8kHvuuYfw8HDWrVvH5ZdfTpUqVdizZw9XX311iYIWF1G5DtzyjTFtcssvsOg1syMqntzhr9aDnT/5AacfBgO4s0M0VYN8OHjyNNPXFL5KvIiUsdMnjeQHjA2xXVCJEqDx48czadIkPv74Y7y9vXnmmWeYN28ejz/+OElJSWUdozib2h3h2g+N42Xvnp1R5egStsGhv8FihRaDzI6mbORti7HE1DBKw8/bymNX1gPgo4W7OJ2RbXJEIm4gt/8nqLpz90JeRIkSoNjY2LyZWn5+fpw6dQqAO+6444Jr8oibaXUbdB5uHM98DPYXbXVvU63PWfm5QV8IDDc3lrIS3dlYp+nYDkhy3v3wbrmsFjVD/Ug4lc7Xq/aZHY6I63Px/h8oYQJUrVo1jh83lqivXbs2q1atAowVorVqq+S58kVofC3YMuG7wUZ/kKPKzoQN043j1k7e/Hwuv1CokbNquxNXgbw9PRjaqz4AExbv5tSZTJMjEnFxLj4DDEqYAF155ZX8+uuvANx3330MGzaM3r17M2jQIAYOHFimAYoT8/CAgROheiujKfrbQcZsJEe0az6kJkBAVajf59LXO5O8PiDnTYAABrauSZ2qAZxMy2TK8r1mhyPi2lQBKtykSZMYOXIkAA8//DBffvkljRs35pVXXuHTTz8t0wDFyXn7G3uGBdUwhmH+d7dRbXE0uRufthhkTOl3Jec2QjtxhdbT6sHw3g0AmLxsLydTXXADXhFHoQrQBV7k4UFWVharV6/mt99+w8fHh169ehEdHc0ff/xR1jGKswuuDrd9B17+sGcR/P6MY/0iTjkKO3L+3LYabG4s5SHycvD0NbbFOLrd7GhKpV+z6jSuHkxKehafLt1tdjgirssNKkAlWgjxjz/+4I477sjrAzqXxWIhO1uzNOQ81VvCDZONXqC/p0JYQ2j/sNlRGTZ9D7YsqNEGIoq3ma9T8PKFWh2M5HPPYghvZHZEJebhYeHpvg2494u/+XLFPu7rFEN48IU3OhaREsg8DadyVvNXBSi/Rx99lJtvvpm4uDhsNlu+DyU/ckGN/gO9RxvHc0bAjrnmxgNGJSp3+Ku1C1Z/crnAdPhcPRqG06ZWKGcybXy8aJfZ4Yi4npP7jM8+IeBXydRQylOJEqCEhASGDx9+yV3bRQro+Bi0vgPsNvjhXjiy2dx4Dq+DhC3GEFGzGy99vbPK3Rh17zLIzjI3llKyWCw81bchANNWx3LgRJrJEYm4mLz+n2jXWBD2AkqUAN14440sXry4jEMRt2CxwH/eg+gukHHKmBmWkmBePOtzVn5udI1T7pVVZNVaGP+SyzgFh517qxqAjnXD6FSvCpnZdj5csNPscERcixv0/0AJe4A+/vhjbrrpJpYtW0bz5s3x8so/a+bxxx8vk+DERXl6w81fweRecGI3fHcb3PVrxa82mnkGNv3POHbl4S8ADyvEdDW2J9mzBKIuNzuiUnuqT0P+3LWCH/85yMPd61K3aqDZIYm4BjeYAQYlTIC+/fZb5syZg5+fH4sXL8ZyTonMYrEoAZJL868Mt30Pk3vCwTXwyxC4YUrFllu3/QZnkiA48uzO6a6sTvecBGgxdHva7GhKrXWtSvRqHMH8rUd4b94OPrmtjdkhibgGN6kAlWgI7IUXXmD06NEkJSWxb98+9u7dm/exZ48Dr/YrjiWsHgz6Gjw84d8fYfGbFfv83OGvVrcZFRJXl5vkHfgLMlLNjaWMPNmnARYLzNoYx+bD2odQpEy4SQWoRAlQRkYGgwYNwsOjRC8XOSumq9ETBLDkTdj4v4p5btJB2L3IOG51W8U802yV60BILWNrkv0rzY6mTDSuHsw1LWoA8N7cHSZHI+ICbNmQGGscqwJU0F133cX06dPLOhZxV23vMmaHgTEUdmB1+T9z/TTADrU7u/y/cvJYLOfMBltsaihlaViv+lg9LCzYlsDa/SfNDkfEuSUdNP6RZPWG4BpmR1OuStQDlJ2dzdtvv82cOXNo0aJFgSbo9957r0yCEzfS6xU4vge2zzKaou9fAJVql8+z7Pazw1+utPFpUdTpDuu+NvqAXESdqoHc2CaS6X8fYOyc7Ux7sL3ZIYk4r9z+n9DaLt8aUKIK0KZNm2jdujUeHh78+++/rFu3Lu9j/fr1ZRyiuAUPK1w/Cao1h9SjMO0WOJNcPs/av8L4n9w7CJpcWz7PcFQxXY3P8Zsg9Zi5sZShx3vVx9vqwco9x/lzl+u8L5EK5yb9P1DCCtCiRYvKOg4R8AmEW6fDZ1caixP+cK+xkaq1RH9MLyy3+tN0AHgHlO29HV1gOEQ0gyP/wt6l0Ox6syMqEzVD/bjtilp8sWIf78zZTse6VfLNThWRIspdBbpStJlRVAh1MYtjCakJt04DTz/YNQ/mjizb+6efgs0/GcfuNvyVK3c2mAsNgwE80qMuvl4erD+QyIKtJi6uKeLM3GQKPCgBEkdUsw1cP9E4/utTWP1Z2d1788+QmQZV6kHUFWV3X2eSuy+YiyVA4UG+3NPJ+Et77Nzt2Gx2kyMScUJuNASmBEgcU5ProOdLxvHvz8Ku+WVz37y1fwa79B43F1W7o7H2UuL+s3/ZuYiHutYhyMeTbfGn+G1TnNnhiDgXu/2cITAlQCLm6TwcWt4G9mz43z2QsK109zu2C2JXgsUDWt5aNjE6I59AiMzZCsMFdoc/V6i/Nw90rQPAuHk7yMq2Fbxo5XiY3NuY7isiZ6WdgPScySflNQvXgSgBEsdlsUD/cVCro/E/5bc3l27mUm71p14vCK5eJiE6rTqu2QcEcG/nGCoHeLPnWCoz/jmU/5uxf8Gc5+HgaljwqjkBijiq3P6foBoVvzejCZQAiWPz9IFB/2fMSEjcD98Nhqz04t/Hlg0bvjOOW7n4xqdFkdcHtARshVRJnFigjyePdK8LwAcLdpKelW18IyMNfv4vkNMbtHE6JGw1J0gRR+RG/T+gBEicQUAVY+NUnxA4sApmPm6MVRfH7kVw6jD4VYKGV5dPnM6kZlvwDoTTJ4wp8S7m9va1iQj24VDiaab9lbOs/4LRcGK38a/ber0AOyx8zdQ4RRyKG80AAyVA4iyqNoSbvwSLFTZ+B8vGFu/16742Pje/2agquTurF9TuZBy74DCYr5eVx66sD8DHi3ZzZucS+GuC8c1rP4I+rxu9YNt+g4NrTYxUxIHkVYCiTQ2joigBEudRtwf0e8c4Xvja2fV8LiXtBGyfbRy769o/hXHR6fC5bm4XRVRlP9JSksj48b/GyTZ3Qv1eEN4IWtxinFs42rwgRRyJKkAiDuyy+6D9I8bxTw/DoSL8633TD5CdYWyzUb1F+cbnTHIToNiVJeurcnDenh4M69WA5zynEXzmELbgSKPyk6v7s+DhZSSAe1xrNpxIiagHSMTB9XkN6veFrDMw7dZLT2fOHf5qpepPPuGNISDcWBjy4BqzoykX1wXv4k7PeQD8GPkc+Aaf/WalaGh7t3G88NXi95WJuJKMNEiJN45VARJxUB5WuHEKhDeFlCPw7S2QnlL4tfGbIH4jWL2hxc0VG6ejs1hcejo8Z5Kx/vooAF9l9WbUv1U5nnJepavr08a2KwfXwPbfTQhSxEHkLoDoGwL+lU0NpaIoARLn5BMEt31nVDCObIIf7zemup9vXc7aPw2vdpv/qYvFlfuA5o6EpAPYK0UzM/xBUjOy+XTJ7vzXBEVA+4eN44WvutySACJF5mb9P6AESJxZaC1j41SrD+z4Hea9lP/7WRnGWi+g4a8Lyd0Y9dA/cCbJ3FjK0s558M9XgAXLdeN5tG8rAL5cuZ/4pDP5r+34uLHEQsIW+PfHCg9VxCG4Wf8PKAESZxfZDgbmTG9e+TGs/eLs93b8bqxzE1gN6l5pSngOLzQKKtc1thvZ96fZ0ZSN0ydh5mPGcfv/QnQnujWoymXRlcjIsvHRwp35r/evDJ1yrl/0OmRnVmy8Io5AFSARJ9TsBuj+vHE868mzwzm5w1+tbgWrpymhOQVXGwb7YwScijMSuytfBMBisfBUn4YATF9zgNjjaflfc8V/IaCq8Usgt2lexJ2oAiTipLo9A81vAlsWfH8n7F0Gu4zZPxr+uoTcBMgVNkbdNhs2TDMWORz4KXj7533rijpV6FI/jCybnXELduR/nU8gdHnKOF7yNmSersCgRRyAKkAiTspigWs/NnY5P5MEXw8Auw2iroCwemZH59iiOwMWOLoNkuPMjqbk0k7Ar08Yxx0ehajLC1zydF+jCvTTukP8vO4Q9nOnvre7B4IjjerRmskVEbGIY8jOgsScLWNUARJxQl6+cMu3RnO0Lcs4p5WfL82/MtRoZRw7cxVo9tOQmgBhDaHHyEIvaREZynWtamC3w9Dp63nkm3/OTo339IHuzxnHy96DM8kVFLiIyZIPGn9nWn2MvfLchBIgcS2BVeHW6casHv8waDrQ7Iicg7P3AW35Bf79wdgrbuAEIxm+gLE3tWR47wZ4elj4/d94+ry/lD/+zal8tbwVqtQ3mudXflJBwYuYLLf/p1Jt8HCftMB93qm4j4gm8NhaeGSlsV6QXFpeArTE+VZETjkKvw0zjjsPM3a6vwgvqweP96zPz0M60TAiiOOpGTz8f/8w9Lt1JKXb4cqc6tHKjyH1eDkHL+IA3LD/B5QAiasKrAqB4WZH4TyirjDK36cOw7Gdl77eUdjtMGs4pB03Vgbv9kyRX9qsZggzH+vEI93r4mGBn9cfps+4JSyydoBqLSAjBZa/V47BizgIN5wBBkqARATAyw9qtTeOnWkY7N8fYetM8PA0hr48fYr1ch9PK89c1Ygf/9uROmEBHElO554v1jLV9w7jgtWfQdKhcghcxIGoAiQibs3ZpsOfijfWfQJjT6/qLUt8q9a1KjHr8S7c2ykGiwVGb6vBeksTyE6HpW+XUcAiDurEPuOzKkAi4pZyN0bdu8yYFuvI7Hb4dSicSTQSny5PlvqWft5WXurfhO8eaE9UZX9eP3MjALa1X3M6fsclXi3ipOx2VYBExM1Vb2XsBJ2eBHHrzY7m4jZ8Z2x14uEFAz4Fq1eZ3fqKOlX444muNLi8D4uyW+JBNss/e5K1+0+U2TNEHEbqMaPfDYsxC8yNKAESEYOHFWK6GseO3AeUdAh+f9Y47jHCmPVXxgJ8PHl9YHOC/zMagJ5Zy3hh4nTGzN7KmczsMn+eiGlyqz/BNYvdQ+fslACJyFmOvh6Q3Q6/Pm5UqWq2hY5PlOvj2rbvTkaj6/Cw2Blu/Z6JS/fQ/6PlbDqYVK7PFakwJ/cZn92s/weUAInIuWK6G58P/AUZaRe70hz/fAW75htT9gdMqJBNbr17vQgWD3pb/6FHwD52JqQwYPyfvDdvBxlZtnJ/vki5ylsEMdrUMMygLbJF5KwqdY39sJIPQuxKqNfT7IjOSoyFOTmLFPZ8Eao2rJjnhtWHVrfBuv9jUo1ZDPN9ld82xfPhgp0s2HqEd29uSaNqwRUTi5SLE6kZbDqUxL+HktiVkIKvlweh/t6E+nkR6u9FiJ83of7GcSV/b0L8vPD1spoddtk46Z5rAIESIBE5l8ViDIOt/z9jOryjJEA2G/wyBDJOQVR7aP9IxT6/23Ow8Xu8DvzJx3ckc1Xz1rz4879sPpxM/4+WM7RXAx7qWgdPq4rqju7cZGfjwUT+PZTMocTTxb6Pr5cHoeckRrnHITnHlfwLJk+hft74eTtY4qQKkIhIjjrdjATIkfqA/p4Ce5eCpx8MGG80bFek0Chodx/8NQEWjOaaBxZyeUxlnp/xL/O3HuGdOduZt8WoBtWtGlixsckFFSfZiQkLoFnNEBpVCyIr207i6QyS0jJJPJ1JYlpGzmfj2GaHM5k24jPPEJ98plgx+Xh65CVDRrJkVJXOTZ5Cc86H+p9Nnvy8rFgslrL4seTnplPgQQmQiJwvJmc9oLiNkHbC2C3eTCf2wryXjONeo4xhOjN0GW70IB3+B7b9Rnjj/nx2Z1t+/OcQr/y6mfUHEun3wTKeuaoR93SMxsOjHH5ZyQWVJNlpXjOYZjVDaFYzhGDfoi2lYLPZScnIMpKjtEwST2dwMi2TpLSMnK+N80k55xPTMkjKOZdls5OeZeNIcjpHktOL9f68rR6E+HsZlaVzkqdQfy8qB/hwVbNqxIQFFOueZKRCyhHj2A2HwCx2u7PtfFj+kpOTCQkJISkpieBgje2LGxrfARK2wE1fQtMB5sVhs8GX18D+P6F2Z7jrV3N3q17wKiwbC1UbwX9X5FWi4pJO88wPG1m28xgAl8dUZuyNLalVxd+8WF1YRSU7Zclut5OakW1Uk85JnoxkyUiUTqadTZ4Sz6k+ZWZf+te0l9XCvZ1jeOzK+gT6FLG2cWQzTOgIvqHw3P7SvUEHUZzf36oAiUhBMd2MBGjPYnMToNUTjeTHKwCu+9jc5Aeg42OwZjIc3Qab/gctbwGgeogfX917Od+ujuX1WVtZvfcEV32wlJH/acxtl9cqn6ELN+GMyU5hLBYLgT6eBPp4Elmp6K+z2+2czsw+W006p8qUm0BtPpzEn7uOM3HJHmb8c4gRVzdiQKual65CuukmqLmUAIlIQXW6G/0uZvYBHdsF818xjvu86hh/SfuFQuehMH8ULHoDml4Pnt6A8Qtu8BW16VKvKk/9sIHVe08w8qd/+ePfeN66oQU1Qv3MjNwplDTZaV4zlKY1gx0m2SlLFosFf29P/L09qXmRP0MLtx1h9K9b2Hc8jeHfb+D/Vu3nlWub0Twy5MI3d+P+H9AQWKE0BCZuL/0UvFkb7NnwxMaKXyLflg1Tr4KDq41k7I6fjRlqjiAjFT5sbfRO9BsLlz9Q4BKbzc7nK/bx9h/bSM+yEeTrycv9m3JDm5qqBuVQslP20rOymbp8Hx8t3ElaRjYWC9xyWRRP9WlIlcBCVnn+bbgxwaDLk9DzpYoPuBwU5/e3EqBCKAESAab0hQOr4NqPoM2dFfvsPz8wGp99go1em9Coin3+paz+DGY/BYER8Ph68C6812f30RSe/H4D6w8kAtCrcQRvXN+M8CDfiovVASjZqVhHks/w5u/b+GndIQCCfD0Z3rsBt7evjde5SzV8PRB2L4RrP4Y2d5gUbdlSAlRKSoBEMIZ4lrwFzW6AG6dW3HMTtsHErpCd7rh/MWdlwMdtjcUZe71iDItd6NJsG5OW7eH9eTvIzLZTyd+LVwc045oWNSou3gqUlJbJxkOJbDyYxKaDSWw6lKRkxyR/7zvByzM3s/lwMgANIgIZ1b8pHeuFGRd80MoYBrt7FkR3Ni/QMqQEqJSUAIkA+1fA51eDfxg8tbNiGpCzs2BKLzi8Dur3gdu+d5yhr/OtnwY/P2zMoHlig9EfdBHb4pN58vsNeb+MrmlRnVeva0alAO/yj7WcpKRnsflQEhsPJrExp7qz/3jhW6go2TFHts3O9DUHeGfONk6mZQJwdbNqjLy6PpGfxIAtC4ZtgZCaJkdaNpQAlZISIBGMKsdb0ZCZCg//CdWalf8zl74DC18D3xB4ZBUEO3CVxJZtLBdwbDt0fRqufOGSL8nIsvHxol18smgX2TY7YYE+jLm+Ob2bRFRAwKVzJjObLXHJbDqYxIaDiWw6mMSuoykU9hukdhV/mtcMoUVkiJIdB5GUlsn783fw9ar9ZNvs1PU8ygLPJ7BbfbCMjDd/hmUZUQJUSkqARHL8342wax70eR06Plq+z4r/FyZ1B1smDJyYN8XcoW2ZCd/fYUzTf2IDBFYt0ss2Hkzkye83sDMhBYAb2kTyUv8mhPg5RpKQmW1je/wpNuVUdTYeTGJ7/CmybAV/XVQP8aV5zRBaRoXmJT2h/s5b1XJ12+KTGTVzM577lvB/3mPYa4lk2/XzuapZNZdo0FcCVEpKgERyrPgY5o6Eer3h9h/K7zlZGTD5SojfBA3/A7d847hDX+ey2+GzHsaQXftH4KoxRX7pmcxs3p+/g0lL92C3G4nEWze0oGuDoiVRZSXbZmfP0RQ2HExi08FENhxMYktccqE73VcJ8DaqOpGhtIwMoXlkiNs1dLsCu93O5pnjaLZuFPOzW3N/5tN0rFuFUdc2pUFEkNnhlYoWQhSRslGnu/F5/wojSfEsp3/ZL3vXSH78KsE17ztH8gNGnD1fMmbTrJlsJEFFnLHm62VlxNWN6dMkgie/38C+42ncOXU1g6+oxfP9GhNQ1NV8i8Fut7P/eJrRr3MgkY2Hkth8KInUjOwC1wb5etIiMoQWkaG0qBlCi6hQaoT4ukSVwN1ZLBaa+R0HoHJkQ7wPeLBi93Gu/mAZd7SvzbDeDRymGlmeVAEqhCpAIjlsNhhbH9KOwT2/Q+2OZf+Mw+thck+jGfPGqcasM2dit8OX/WHfMmh9h7FidTGlZWTx9h/b+WLFPgCiKvvxzo0taV+nSinCshOXdCZvCMv4SCT5TFaBa/29rTSrYVR0cpOe2pX9tZ+ZK/tuMGz7Da5+mwP17+D1WVv5Y3M8AJUDvHmmb0NuaheF1cn+DGgIrJSUAImc44d74d8foduz0OP5sr13VrrR95OwBZpcZ+w95owVhgOrYUpvsFhhyF8QVr9Et1mx6xhP/7CRQ4mnsVjgno4xPHNVQ3y9rJd87bGU9POSnSSOpRTccNPb6kHjGsHGEFZO707dqoFO94tOSmlCJzjyL9z2P2jQB4DlO48x6tfN7MrpTWteM4RR1zalbe1i7N1hMqdKgMaPH88777xDXFwcTZs2Zdy4cXTp0qXQa5cvX86zzz7Ltm3bSEtLo3bt2jz00EMMGzYs33U//vgjL774Irt376Zu3bq8/vrrDBw4sMgxKQESOcc/X8HMxyDqCrhvbtnee/4rsPw9Y6r9kL8gIKxs71+Rvr0FdvxubI9x0+clvs2pM5m8MXsr01YfAKBO1QDevaklrWud/SWUlJbJpkNnZ2NtPJjI4aQzBe5l9bDQICIor1+nZWQoDSKC8PZ0jRk/UkJ2O7xR05jh+ejf+RL2zGwbX63cz7h5OziVblQLr29dk+eubkR4sOP3ezlNAjR9+nTuuOMOxo8fT6dOnZg4cSKTJ09my5Yt1KpVq8D169atY9u2bbRo0YKAgACWL1/OQw89xPvvv8+DDz4IwMqVK+nSpQuvvvoqAwcO5KeffuKll15i+fLlXHHFFUWKSwmQyDkSY2Fcc6O68ew+8C2j/ycO/m1UTew2GPR/0Lh/2dzXLPH/wqedjOOHlkL1lqW63aLtCTz340aOJKfjYYFBl9UiJT2LTQcT2VfIWjsWC9StGmj06+Q0KjetEVyk6pG4mZQEY2gbC7xwBDwLbpNxLCWdd/7YzvdrD2C3Q4C3lcd71ueeTjEOnUA7TQJ0xRVX0KZNGyZMmJB3rnHjxgwYMIAxY4o2m+L6668nICCAr7/+GoBBgwaRnJzM77//nnfNVVddRaVKlZg2bVqR7qkESOQ8uSvG3jodGl5V+vtlnjZWez62A5rfBDdMLv09HcEP98G/PxiLOA7+X6lvl5SWyahfN+dtaXCuWpX9c/p1jJ6dpjWCCdJaO1IUsX/B1D4QEgXD/r3opRsOJPLyzM1527nUCQvgxf5N6NEwvAICLT6nmAWWkZHB2rVree655/Kd79OnDytWrCjSPdatW8eKFSt47bXX8s6tXLmywJBY3759GTdu3AXvk56eTnr62bHy5OTkIj1fxG3U6Q5r9xq7w5dFArTwNSP5CYyAq98u/f0cRY/nYfNPsHMu7F8JtTuU6nYh/l68P6gV/ZpXZ+7meKLDArTWjpRe3i7w0Ze8tGVUKDP+25Gf1h1izO/b2HMslXs+X0PPRuG8eE0TosMCyjfWcmRaHevYsWNkZ2cTEZF/BdSIiAji4+Mv+trIyEh8fHxo164dQ4YM4f7778/7Xnx8fLHvOWbMGEJCQvI+oqIcbONFEbPlToffu6T094pdBSs/MY77fwj+lUt/T0dRpe7ZvcsWjKbQZZJLoHeTCN65qSVDetSja4OqSn6kdE7kJECVY4p0uYeHhRvaRrLoqW482LUOnh4WFmxLoM/7S3nrj22kphecWegMTB/IO39NCbvdfsl1JpYtW8bff//Np59+yrhx4woMbRX3niNGjCApKSnv48CBA8V8FyIuLqYrYDFma506UvL7ZKTCz/8F7NBqcNlUkxxN12fA6gOxK2DXArOjESkorwJUtAQoV5CvF8/3a8wfQ7vStUFVMrJtTFi8myvfXcwv6w/hbJPKTUuAwsLCsFqtBSozCQkJBSo454uJiaF58+Y88MADDBs2jFGjRuV9r1q1asW+p4+PD8HBwfk+ROQc/pWhegvjuDRVoAWj4cQeCKoBfd8om9gcTUhNuPwB43jBK8ZaSiKOpJgVoPPVCw/ky3suY/Kd7ahV2Z8jyek88d16bp64kn8PJZVhoOXLtATI29ubtm3bMm/evHzn582bR8eORV9szW635+vf6dChQ4F7zp07t1j3FJFC5A6D7VlcstfvXQZ/fWocX/fRJXdPd2qdh4N3IMRvhK0zzY5GJL8SVoDOZbFY6NUkgrnDuvJ034b4eVlZs+8k/T9ezvM/beJEakYZBVt+TB0CGz58OJMnT2bq1Kls3bqVYcOGERsby8MPPwwYQ1N33nln3vWffPIJv/76Kzt37mTnzp18/vnnjB07lttvvz3vmieeeIK5c+fy1ltvsW3bNt566y3mz5/P0KFDK/rtibiWvARoSfF7W9JT4JdHjOM2d0G9XmUamsMJqAIdcjaPXfQ6ZDtnj4S4oPQUSD1qHJewAnQuXy8rQ3rUY+FT3bi2ZQ3sdvj2r1h6jF3MVyv3kZXtuBVQU/cCGzRoEMePH2f06NHExcXRrFkzZs+eTe3atQGIi4sjNjY273qbzcaIESPYu3cvnp6e1K1blzfffJOHHnoo75qOHTvy3Xff8cILL/Diiy9St25dpk+fXuQ1gETkAqLag9Ubkg/C8d0QVq/or533orGeUEgt6Pt6+cXoSDoMgdUTjdluG7+D1rdf+jUi5e3kPuOzX2XwDSmz21YP8ePDW1tze/vavDxzM1vjknnpl818+1csL/dvSoe6Jd/WpbyYvhK0I9I6QCIX8MU1xp5X/cae7XO5lN0Ljc1CAe6cCXW6lV98jubPD43kLyQKHltb6IJzIhVq668w/Xao2RYeWFguj8i22fl2dSzvzt1OYlomAP9pUZ3n+zWmZqhfuTwzV3F+f5s+C0xEnEhxp8OfSYJfHjOOL3vAvZIfMJLEoOqQdADWfmF2NCJnG6BL0f9zKVYPC3e0r82iJ7tzR/vaeFhg1sY4er67mA8X7ORMZna5Pbs4lACJSNHlJUBLwVaEv8TmPG8MmVWKht6vlGdkjsnLD7o9YxwvfcdYBkDETCdLNwOsOCoFePPqgGb89lgXLo+pzJlMG+/N20Hv95cwZ3O86dPmlQCJSNFVbwU+IUZlJ279xa/dMRfW/R9ggQETwNt5V4wtldZ3GAlg6lFYNeGSl4uUqwqoAJ2vSY1gpj/Yno9ubU31EF8OnDjNQ1+v5c6pq02tBikBEpGis3pCTBfjeM9FhsFOn4RfHzeO2z8Ctd14GQqrF/QYaRz/+aHxsxExSwVWgM5lsVjo37IGC57sxqM96uFt9SDY18vUzXqVAIlI8cTk9PFcbD2g35+DU3FQpR70fLFCwnJozW6E8KaQnmQkQSJmyM6ExJydDoqwD1h58Pf25Km+DZk3vCsvXNPYlBhyKQESkeLJ7QOKXWXs6n6+bbOMad8WDxjwqdEH4+48PODKF4zjvz4t3XYiIiWVdADs2eDpC4HVTA2ldpUAqoeY+3eDEiARKZ6w+sZWFtnpRhJ0rtTj8OsTxnHHxyDqsoqPz1E1vBpqtoPMNFg21uxoxB2dOGcXeA/9+tdPQESKx2K58HT42U8Zzb5VG0H35ys8NIdmsUDPl4zjvz+Hk/vNjae82WyQctTsKORcZbAFhitRAiQixVenkD6gzT/B5hlgsRqzvrx8TQnNodXpZiSPtkxY8pbZ0ZSf3QthUjcYWw/+nmp2NJKrlJuguholQCJSfLmN0IfXQ9oJSEmA34Yb57oMh5ptTAvN4V2ZUwXaMA2Objc3lrJ2eB18dZ2x8nf8RuPcglfhTLK5cYkhdxsMVYAAJUAiUhLB1Y1hLuzG1hi/DYPTJyCiGXR9xuzoHFtkW2h0DdhtxkapruDEHvjhXpjU3agKWr2N5Q/CGhh/LlZ+bHaEAqoAnUcJkIiUTG4VaP4rsO038PA0hr48vc2Nyxn0GAlYYMsvRtXEWaUkwKyn4OPL4N8fAQu0uAUe/RuuGgNX5iyBsOJj9QOZzW5XBeg8SoBEpGRyG6FP7DY+d3sWqrcwLRynEtEEWgwyjhe8am4sJZF+ChaNgQ9awZrPwJYF9XrDw8vg+olQqbZxXeP+UKMNZKbCsndNDdntpSQY/x0sHhBay+xoHIISIBEpmehORsMzGFtkdB5majhOp/tzRtVs9wLYt9zsaIomKwP+mmQkPkveNH6h1mgDd/0Kt/8A1Zrnv95igV4vG8d/T3H9mW+OLHcGWHCkqrQ5lACJSMn4hkDTAeBX2Rj6snqZHZFzqRwDbe4yjhe8agxROCqbDTb9AJ9cBr8/DWnHjFW+b/oSHlgIMV0v/No63Y2P7AxY/GZFRSzny+v/iTY1DEeiBEhESu7GqfDUDmNIR4qv69Pg6QcHVsHOuWZHU7jcKe0/3mf0kARGwDXvwyOrjATYYrn0PXqeM/MtYWt5RisXojWAClACJCKlo8pPyQVXhyseNI4XvGpUWhzF+VPavYOM7TweXwft7i3ef/eabaHxtYAdFr5WbiHLRWgGWAFKgEREzNRpKPgEw5FNsOUns6OB47vhf/ecN6V9CDyxwahYeQeU7L5Xvmg04G77DQ6sKcuIpShUASpACZCIiJn8Kxv7pgEsfB2ys8yJI3dK+yeXGyt655vS/gYEVCnd/as2gFaDjeMFrzh2z5MrUgWoACVAIiJma/9f8A8zlhRY/03FPruoU9rLQvfnwOpjLJ65e2HZ3VcuLv2U0bgOqgCdQwmQiIjZfIKgy5PG8ZK3IPNM+T8zKwP+mph/SnvNtnDXb4VPaS8LIZFw+QPG8YJXHKvnyZXlVn/8q4BvsLmxOBAlQCIijqDdvRBcE5IPle8GovmmtD9zdkr7zV/B/Qsgpkv5PRug83CjoTpuA2z5uXyfJQb1/xRKCZCIiCPw8jVW0wZj1eT0U2X/jItNaW9yXdGmtJdWQJVzep5eg+zM8n+mu1P/T6GUAImIOIpWg6FyXaMqs2pC2d338Dr48tqymdJeFjo8Yl7PkztSBahQSoBERByF1ROuHGkcr/gI0k6U7n7nTmnfu6TsprSXlk+Q8XwwVofOPG1OHO5CFaBCKQESEXEkTQZCRHNIT4Y/x5XsHuU9pb0stLsHQmrBqThYPcnsaFybdoEvlBIgERFH4uEBPV80jv+aBMlxRX9t+ilY9EbFTGkvLU8f6DHCOF72HpxONDUcl5WdCUkHjWNVgPJRAiQi4mjq94Go9pB1Gpa+c+nr801pf6tiprSXhRaDoGojOJNoDPlJ2UuMBXs2ePkbTe+SRwmQiIijsVjObiD6z5dnezjOZ/aU9tLysJ59n6vGw6kj5sbjivIaoKMrZpafE1ECJCLiiKI7Qd2exjDW4jcLft8RprSXhYb9IPIyyEwrWrVLiueEZoBdiBIgERFHldsLtHE6JGw1jg/9k39Ku0+wsdGoWVPaS8tigZ4vG8drv7hwtUtKJrcBWv0/BXiaHYCIiFxAjdZGNWfLL/DHc+BXOWdWF8aU9sseMLbQcIRZXaUR08Wodu1eAIvHwPWaFVZmTpwzBCb5qAIkIuLIeowEiwfsWey4U9rLQm4v0Mbv4chmc2NxJSe1BtCFKAESEXFkVRvCZfcbx446pb0s1GgFTQcCdljwqtnRuAa7XWsAXYQSIBERR3fVW/DULsee0l4WerwAFivs+B1iV5kdjfNLOWI0l1usEFrL7GgcjhIgERFH5+EBgVXNjqL8hdWD1rcbx/NHGRUMKbnc/p+QSOdrjq8ASoBERMRxdHsWPH0hdiXsnGd2NM7tpBqgL0YJkIiIOI6QmnD5g8bxgtHGYo9SMtoE9aKUAImIiGPpPAx8QuDIprPT/qX4TmoRxItRAiQiIo7FvzJ0esw4XviasaGnFJ8qQBelBEhERBzPFf+FgHCjivHPV2ZH45xUAbooJUAiIuJ4fAKh2zPG8ZK3ICPN3HiczZlkSDtuHKsCVCglQCIi4pja3AWhtY31bP761OxonEtu9cc/DHyCzI3FQSkBEhERx+TpbWwFAvDnODh90tRwnIr6fy5JCZCIiDiu5jdCeFM4kwR/fmB2NM5D/T+XpARIREQcl4cVer5oHK/6FJLjzI3HWagCdElKgERExLE1uAqiroCs07D0bbOjcQ6qAF2SEiAREXFsFgv0GmUc//MVHN9tajhO4cQ+47MqQBekBEhERBxf7Y5Qvw/YsmDRG2ZH49iyMiD5oHGsCtAFKQESERHncGVOL9C/P0DcRnNjcWSJsWC3gVcABIabHY3DUgIkIiLOoXoLaHajcbzwVXNjcWTn7gJvsZgaiiNTAiQiIs6jx/Pg4Qk758K+P82OxjFpBliRKAESERHnUaUutLnTOF7wCtjt5sbjiE7uMz5XijYzCoenBEhERJxL12fA0w8O/AU7/jA7GsdzUhWgolACJCIiziW4OrR/2DheMBps2ebG42hOaA2golACJCIizqfTE+AbAglbYNMPZkfjOOz2s0NgqgBdlBIgERFxPn6VoNNQ43jR68baNwKn4o0Vsy1WCIkyOxqHpgRIRESc0xUPQ2A1SNwP/3xpdjSOIbf/JzQKrF7mxuLglACJiIhz8vaHbk8bx0vehvQUc+NxBOr/KTIlQCIi4rza3GX8sk9NgL8mmB2N+TQDrMiUAImIiPOyesGVLxjHf34IaSfMjcdsqgAVmRIgERFxbk2vh4jmkJ4My983OxpzqQJUZEqARETEuXl4QM+XjOPVkyDpkLnxmEkVoCJTAiQiIs6vfm+o1RGyzsCSt8yOxhxnkuB0zhCgtsG4JCVAIiLi/CwW6PWycbzu/+DYLnPjMUNu9ScgHHwCzY3FCZieAI0fP56YmBh8fX1p27Yty5Ytu+C1M2bMoHfv3lStWpXg4GA6dOjAnDlzClw3btw4GjZsiJ+fH1FRUQwbNowzZ86U59sQERGz1WoPDa4CezYses3saCqe+n+KxdQEaPr06QwdOpSRI0eybt06unTpwtVXX01sbGyh1y9dupTevXsze/Zs1q5dS48ePejfvz/r1q3Lu+abb77hueee4+WXX2br1q1MmTKF6dOnM2LEiIp6WyIiYpYrXwQssPknOLzukpe7FPX/FIvFbrfbzXr4FVdcQZs2bZgw4ezaDY0bN2bAgAGMGTOmSPdo2rQpgwYN4qWXjAa4Rx99lK1bt7JgwYK8a5588klWr1590erSuZKTkwkJCSEpKYng4OBivCMRETHdjAdh43SoeyXc8ZPZ0VScmY/BP19Bt+egh3v+o784v79NqwBlZGSwdu1a+vTpk+98nz59WLFiRZHuYbPZOHXqFJUrV84717lzZ9auXcvq1asB2LNnD7Nnz+Y///nPBe+Tnp5OcnJyvg8REXFS3UeAhyfsXgh7l5odTcU5oSGw4jAtATp27BjZ2dlERETkOx8REUF8fHyR7vHuu++SmprKzTffnHfulltu4dVXX6Vz5854eXlRt25devTowXPPPXfB+4wZM4aQkJC8j6gobSAnIuK0KsdA23uM4/mvGDuku4PcXeA1BFYkpjdBWyyWfF/b7fYC5wozbdo0Ro0axfTp0wkPD887v3jxYl5//XXGjx/PP//8w4wZM/jtt9949dVXL3ivESNGkJSUlPdx4MCBkr8hERExX9enwcsfDv0N22aZHU35y0qHpIPGsSpAReJp1oPDwsKwWq0Fqj0JCQkFqkLnmz59Ovfddx//+9//6NWrV77vvfjii9xxxx3cf//9ADRv3pzU1FQefPBBRo4ciYdHwZzPx8cHHx+fUr4jERFxGEER0P4RWDYWFr4KDa8GD6vZUZWfxFjADl4BEFDV7GicgmkVIG9vb9q2bcu8efPynZ83bx4dO3a84OumTZvG3XffzbfffltoX09aWlqBJMdqtWK32zGx31tERCpax8fANxSObjOaol3Zuf0/RRhFEZOHwIYPH87kyZOZOnUqW7duZdiwYcTGxvLwww8DxtDUnXfemXf9tGnTuPPOO3n33Xdp37498fHxxMfHk5SUlHdN//79mTBhAt999x179+5l3rx5vPjii1x77bVYrS6c/YuISH5+odBluHG86A1jmMhV5a4BpBWgi8y0ITCAQYMGcfz4cUaPHk1cXBzNmjVj9uzZ1K5dG4C4uLh8awJNnDiRrKwshgwZwpAhQ/LO33XXXXzxxRcAvPDCC1gsFl544QUOHTpE1apV6d+/P6+//nqFvjcREXEAlz8IqyZA0gH4eyq0/6/ZEZUPzQArNlPXAXJUWgdIRMSF/P05/DYU/MPgifXgE2R2RGXv20Gw4w/4z3tw2X1mR2Map1gHSEREpEK0vh0q14W0Y7ByvNnRlA9VgIpNCZCIiLg2qxdc+YJxvOIjSD1ubjxlzWbTGkAloARIRERcX5MBUK0FZJyC5e+ZHU3ZOhUH2enG6tchWsi3qJQAiYiI6/PwgF4vG8erP4NEF1rwNncGWEgUWE2d2+RUlACJiIh7qNsTorsY1ZIlb5odTdnJHf5S/0+xKAESERH3YLFAz5wq0Ppv4eh2c+MpK7kN0Or/KRYlQCIi4j6iLoOG/wG7DRa+ZnY0ZeOkZoCVhBIgERFxLz1fBCywdSYcWmt2NKWnClCJKAESERH3Et4YWt5qHM9/xdxYyoIqQCWiBEhERNxP9+fAwwv2LoHdi8yOpuROJ8Lpk8ax9gErFiVAIiLifirVPrtlxIJXwFl3hcqt/gRGgHeAubE4GS0YICIi7qnLU/DP13B4ndEP1OQ6syMqnN1uVHlO7oPE/cbnk/uN46M7jGvU/1NsSoBERMQ9BVaFDkNg6duw4FVjdphZCwlmnobE2PzJzbnH6ckXf339XhURpUtRAiQiIu6r46OwZjIc3wkbpkGbO8rnObZsSD5UeHJzch+kHLn0PQIjILS20etTqfbZ48oxEBJZPnG7MCVAIiLivnxDoMuTMHckLB4DzW8CL9/i38duh7QTkLiv8CpO0kGwZV78Ht5BBZOb3OPQWuDtX/y45IKUAImIiHu77H5YNd6o0KyZbFSFCpORlpPUXKCKk5Fy8ed4eEFoVOFVnErR4FfJWK1aKoQSIBERcW9evsa0+JmPwbJ3IaIJJB06p+k4J8FJTbj0vQKrXbiKE1wDPKzl+16kyJQAiYiItLwN/vzQ6AX6euCFr/MJLli5yT0OjQIvvwoKWEpLCZCIiIjVE/q9AzMeBJ+L9OJomMplKAESEREBqNsDnt5pdhRSQbQStIiIiLgdJUAiIiLidpQAiYiIiNtRAiQiIiJuRwmQiIiIuB0lQCIiIuJ2lACJiIiI21ECJCIiIm5HCZCIiIi4HSVAIiIi4naUAImIiIjbUQIkIiIibkcJkIiIiLgdJUAiIiLidjzNDsAR2e12AJKTk02ORERERIoq9/d27u/xi1ECVIhTp04BEBUVZXIkIiIiUlynTp0iJCTkotdY7EVJk9yMzWbj8OHDBAUFYbFYzA7HdMnJyURFRXHgwAGCg4PNDsdl6edcMfRzrhj6OVcc/azPstvtnDp1iho1auDhcfEuH1WACuHh4UFkZKTZYTic4OBgt/+fqyLo51wx9HOuGPo5Vxz9rA2XqvzkUhO0iIiIuB0lQCIiIuJ2lADJJfn4+PDyyy/j4+NjdiguTT/niqGfc8XQz7ni6GddMmqCFhEREbejCpCIiIi4HSVAIiIi4naUAImIiIjbUQIkIiIibkcJkBRqzJgxXHbZZQQFBREeHs6AAQPYvn272WG5vDFjxmCxWBg6dKjZobikQ4cOcfvtt1OlShX8/f1p1aoVa9euNTssl5KVlcULL7xATEwMfn5+1KlTh9GjR2Oz2cwOzaktXbqU/v37U6NGDSwWCz///HO+79vtdkaNGkWNGjXw8/Oje/fubN682ZxgnYQSICnUkiVLGDJkCKtWrWLevHlkZWXRp08fUlNTzQ7NZa1Zs4ZJkybRokULs0NxSSdPnqRTp054eXnx+++/s2XLFt59911CQ0PNDs2lvPXWW3z66ad8/PHHbN26lbfffpt33nmHjz76yOzQnFpqaiotW7bk448/LvT7b7/9Nu+99x4ff/wxa9asoVq1avTu3Ttvb0spSNPgpUiOHj1KeHg4S5YsoWvXrmaH43JSUlJo06YN48eP57XXXqNVq1aMGzfO7LBcynPPPceff/7JsmXLzA7FpV1zzTVEREQwZcqUvHM33HAD/v7+fP311yZG5josFgs//fQTAwYMAIzqT40aNRg6dCjPPvssAOnp6URERPDWW2/x0EMPmRit41IFSIokKSkJgMqVK5sciWsaMmQI//nPf+jVq5fZobismTNn0q5dO2666SbCw8Np3bo1n332mdlhuZzOnTuzYMECduzYAcCGDRtYvnw5/fr1Mzky17V3717i4+Pp06dP3jkfHx+6devGihUrTIzMsWkzVLkku93O8OHD6dy5M82aNTM7HJfz3Xff8c8//7BmzRqzQ3Fpe/bsYcKECQwfPpznn3+e1atX8/jjj+Pj48Odd95pdngu49lnnyUpKYlGjRphtVrJzs7m9ddf59ZbbzU7NJcVHx8PQERERL7zERER7N+/34yQnIISILmkRx99lI0bN7J8+XKzQ3E5Bw4c4IknnmDu3Ln4+vqaHY5Ls9lstGvXjjfeeAOA1q1bs3nzZiZMmKAEqAxNnz6d//u//+Pbb7+ladOmrF+/nqFDh1KjRg3uuusus8NzaRaLJd/Xdru9wDk5SwmQXNRjjz3GzJkzWbp0KZGRkWaH43LWrl1LQkICbdu2zTuXnZ3N0qVL+fjjj0lPT8dqtZoYoeuoXr06TZo0yXeucePG/PjjjyZF5JqefvppnnvuOW655RYAmjdvzv79+xkzZowSoHJSrVo1wKgEVa9ePe98QkJCgaqQnKUeICmU3W7n0UcfZcaMGSxcuJCYmBizQ3JJPXv2ZNOmTaxfvz7vo127dgwePJj169cr+SlDnTp1KrCUw44dO6hdu7ZJEbmmtLQ0PDzy/2qxWq2aBl+OYmJiqFatGvPmzcs7l5GRwZIlS+jYsaOJkTk2VYCkUEOGDOHbb7/ll19+ISgoKG+MOSQkBD8/P5Ojcx1BQUEF+qoCAgKoUqWK+q3K2LBhw+jYsSNvvPEGN998M6tXr2bSpElMmjTJ7NBcSv/+/Xn99depVasWTZs2Zd26dbz33nvce++9Zofm1FJSUti1a1fe13v37mX9+vVUrlyZWrVqMXToUN544w3q169P/fr1eeONN/D39+e2224zMWoHZxcpBFDox+eff252aC6vW7du9ieeeMLsMFzSr7/+am/WrJndx8fH3qhRI/ukSZPMDsnlJCcn25944gl7rVq17L6+vvY6derYR44caU9PTzc7NKe2aNGiQv9Ovuuuu+x2u91us9nsL7/8sr1atWp2Hx8fe9euXe2bNm0yN2gHp3WARERExO2oB0hERETcjhIgERERcTtKgERERMTtKAESERERt6MESERERNyOEiARERFxO0qARERExO0oARIRKYLFixdjsVhITEw0OxQRKQNKgERERMTtKAESERERt6MESEScgt1u5+2336ZOnTr4+fnRsmVLfvjhB+Ds8NSsWbNo2bIlvr6+XHHFFWzatCnfPX788UeaNm2Kj48P0dHRvPvuu/m+n56ezjPPPENUVBQ+Pj7Ur1+fKVOm5Ltm7dq1tGvXDn9/fzp27Fhgh3kRcQ5KgETEKbzwwgt8/vnnTJgwgc2bNzNs2DBuv/12lixZknfN008/zdixY1mzZg3h4eFce+21ZGZmAkbicvPNN3PLLbewadMmRo0axYsvvsgXX3yR9/o777yT7777jg8//JCtW7fy6aefEhgYmC+OkSNH8u677/L333/j6empXc5FnJQ2QxURh5eamkpYWBgLFy6kQ4cOeefvv/9+0tLSePDBB+nRowffffcdgwYNAuDEiRNERkbyxRdfcPPNNzN48GCOHj3K3Llz817/zDPPMGvWLDZv3syOHTto2LAh8+bNo1evXgViWLx4MT169GD+/Pn07NkTgNmzZ/Of//yH06dP4+vrW84/BREpS6oAiYjD27JlC2fOnKF3794EBgbmfXz11Vfs3r0777pzk6PKlSvTsGFDtm7dCsDWrVvp1KlTvvt26tSJnTt3kp2dzfr167FarXTr1u2isbRo0SLvuHr16gAkJCSU+j2KSMXyNDsAEZFLsdlsAMyaNYuaNWvm+56Pj0++JOh8FosFMHqIco9znVsA9/PzK1IsXl5eBe6dG5+IOA9VgETE4TVp0gQfHx9iY2OpV69evo+oqKi861atWpV3fPLkSXbs2EGjRo3y7rF8+fJ8912xYgUNGjTAarXSvHlzbDZbvp4iEXFdqgCJiMMLCgriqaeeYtiwYdhsNjp37kxycjIrVqwgMDCQ2rVrAzB69GiqVKlCREQEI0eOJCwsjAEDBgDw5JNPctlll/Hqq68yaNAgVq5cyccff8z48eMBiI6O5q677uLee+/lww8/pGXLluzfv5+EhARuvvlms966iJQTJUAi4hReffVVwsPDGTNmDHv27CE0NJQ2bdrw/PPP5w1BvfnmmzzxxBPs3LmTli1bMnPmTLy9vQFo06YN33//PS+99BKvvvoq1atXZ/To0dx99915z5gwYQLPP/88jzzyCMePH6dWrVo8//zzZrxdESlnmgUmIk4vd4bWyZMnCQ0NNTscEXEC6gESERERt6MESERERNyOhsBERETE7agCJCIiIm5HCZCIiIi4HSVAIiIi4naUAImIiIjbUQIkIiIibkcJkIiIiLgdJUAiIiLidpQAiYiIiNtRAiQiIiJu5/8BbHuwYWAT5WkAAAAASUVORK5CYII=",
      "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": [
       "8"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_epoch = np.argmin(np.array(arr_val_loss)) + 1\n",
    "model.load(checkpoints_folder + \"/\" + model_name + \"-\" + str(best_epoch) + \".pt\")\n",
    "model.to(device)\n",
    "model.eval()\n",
    "best_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test[\"doc_splitted\"] = split_all_docs(df_test[\"docs\"], False)\n",
    "test_set = df_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:02<00:00, 34.00batch/s, accuracy=0.801, loss=0.473, rouge1=0.38, rouge2=0.168, rougeL=0.268]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "\n",
    "counter = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "  for batch in tepoch:\n",
    "    tepoch.set_description(\"Eval model\")\n",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "    y_pred = model(data)\n",
    "\n",
    "    loss = criterion(y_pred, targets)\n",
    "\n",
    "    arr_loss.append(loss.item())\n",
    "\n",
    "    doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "    summaries = test_set[\"summaries\"].iloc[idx]\n",
    "\n",
    "    probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "    probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "    #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "    #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "    indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for i in range(min(len(doc), y_pred.shape[0])):\n",
    "      txt = txt + \". \" + doc[indices[i]]\n",
    "      y_pred_thresh.append(indices[i])\n",
    "      if len(txt) >= len(summaries):\n",
    "        break\n",
    "\n",
    "    y_pred_thresh.sort()\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "      txt = txt + \". \" + doc[i]\n",
    "\n",
    "    n = min(len(txt), len(summaries))\n",
    "\n",
    "    while n < len(txt) and txt[n].isalnum():\n",
    "      n += 1\n",
    "\n",
    "    txt = txt[:n]\n",
    "\n",
    "    #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "    scores = scorer.score(summaries, txt)\n",
    "    arr_rouge1.append(scores[\"rouge1\"].recall)\n",
    "    arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "    arr_rougeL.append(scores[\"rougeL\"].recall)\n",
    "\n",
    "    mae.append(mae_fn(probs_tensor, targets).item())\n",
    "\n",
    "    accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "    #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "    tepoch.set_postfix(loss=np.mean(arr_loss), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL), accuracy=np.mean(accuracy))\n",
    "    idx += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\n",
    "test_metrics[\"mae\"]      = np.mean(mae)\n",
    "test_metrics[\"rouge1\"]   = np.mean(arr_rouge1)\n",
    "test_metrics[\"rouge2\"]   = np.mean(arr_rouge2)\n",
    "test_metrics[\"rougeL\"]   = np.mean(arr_rougeL)\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/test_metrics.json\", 'w') as fp:\n",
    "  json.dump(test_metrics, fp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:01<00:00, 95.15batch/s, rouge1=0.393, rouge2=0.217, rougeL=0.299]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Lead-3\")\n",
    "        doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), 3)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[\"summaries\"].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].recall)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].recall)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:01<00:00, 90.24batch/s, rouge1=0.453, rouge2=0.25, rougeL=0.338]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[\"summaries\"].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].recall)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].recall)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "SystemExit",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rsaid/.local/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3406: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "# Does not execute this cell if you want to execute the following cells.\n",
    "import sys\n",
    "sys.exit()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "6d7f428a150b92572ac46240b6d7ae68586908362b054f21341550673eeb77dc"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}