02-train_HeterSUMGraph_NYT50.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train HeterSUMGraph_NYT50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import argparse\n",
    "from time import time\n",
    "import torch\n",
    "import numpy as np\n",
    "import random\n",
    "from sklearn.utils import shuffle\n",
    "import json\n",
    "import os\n",
    "import networkx as nx\n",
    "import torch_geometric\n",
    "from statistics import mean\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils.create_graph_dataset import create_graph_dataset\n",
    "from utils.GloveMgr import GloveMgr\n",
    "from utils.DataLoader import DataLoader\n",
    "from utils.MultiProcessusDataLoader import MultiProcessusDataLoader\n",
    "from utils.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils.split_all_docs import split_all_docs\n",
    "from utils.threshold_probs import threshold_probs_by_nb, threshold_probs_by_prop\n",
    "from utils.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_notebook() -> bool:\n",
    "    try:\n",
    "        shell = get_ipython().__class__.__name__\n",
    "        if shell == 'ZMQInteractiveShell':\n",
    "            return True   # Jupyter notebook or qtconsole\n",
    "        elif shell == 'TerminalInteractiveShell':\n",
    "            return False  # Terminal running IPython\n",
    "        else:\n",
    "            return False  # Other type (?)\n",
    "    except NameError:\n",
    "        return False      # Probably standard Python interpreter"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse args if script mode\n",
    "parser = argparse.ArgumentParser(description='extractive summary')\n",
    "\n",
    "parser.add_argument('-is_graphic',type=int,default=1,choices=[0,1])\n",
    "parser.add_argument('-gpu_num',type=int,default=0)\n",
    "parser.add_argument('-batch_size',type=int,default=4)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "\n",
    "args = None\n",
    "\n",
    "if is_notebook():\n",
    "    args = parser.parse_args(\"\")\n",
    "else:\n",
    "    args = parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 0\n",
      "epochs 100\n",
      "batch_size 4\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"glove.6B.300\"\n",
    "\n",
    "# hyper-parameters\n",
    "vocab_size = 150000\n",
    "batch_size = args.batch_size\n",
    "epochs = args.epochs\n",
    "learning_rate = 5e-4\n",
    "early_stopping = 3\n",
    "word_blacklist_proportion = 0.1\n",
    "model_name = \"02-train_HeterSUMGraph_NYT50\"\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# own HEADGAT\n",
    "class GAT(nn.Module):\n",
    "  def __init__(self, d_hi, d_hj, hidden_size = 64, d_e = 50, num_heads=8) -> None:\n",
    "    super(GAT, self).__init__()\n",
    "    self.Wq = nn.Parameter(torch.empty(num_heads, d_hi, hidden_size))#num_heads*nn.Linear(in_features=d_hi, out_features=hidden_size, bias=False)\n",
    "    nn.init.xavier_uniform_(self.Wq, gain=1.0)\n",
    "    self.Wk = nn.Parameter(torch.empty(num_heads, d_hj, hidden_size))#num_heads*nn.Linear(in_features=d_hj, out_features=hidden_size, bias=False)\n",
    "    nn.init.xavier_uniform_(self.Wk, gain=1.0)\n",
    "    self.Wa = nn.Parameter(torch.empty(num_heads, 2*hidden_size+d_e, 1))#num_heads*nn.Linear(in_features=2*hidden_size+d_e, out_features=1, bias=False)\n",
    "    nn.init.xavier_uniform_(self.Wa, gain=nn.init.calculate_gain('leaky_relu'))\n",
    "    self.leaky_relu = nn.LeakyReLU()\n",
    "    self.Wv = nn.Parameter(torch.empty(num_heads, d_hj, d_hi))#num_heads*nn.Linear(in_features=d_hj, out_features=d_hi, bias=False)\n",
    "    nn.init.xavier_uniform_(self.Wv, gain=nn.init.calculate_gain('relu'))\n",
    "    self.num_heads = num_heads\n",
    "\n",
    "  # hi <- hj (edges orientations)\n",
    "  def forward(self, Hi, Hj, edge_index_i, edge_index_j, first_i, first_j, edge_attr):\n",
    "    Q = torch.matmul(Hi.view(1, Hi.shape[0], Hi.shape[1]), self.Wq)\n",
    "    K = torch.matmul(Hj.view(1, Hj.shape[0], Hj.shape[1]), self.Wk)\n",
    "    U = []\n",
    "\n",
    "    # Compute N\n",
    "\n",
    "    v, c = torch.unique(edge_index_i, return_counts=True, sorted=True)\n",
    "\n",
    "    tmp_v = torch.arange(Hi.shape[0]).to(Hi.device) + first_i\n",
    "    tmp_c = torch.zeros(Hi.shape[0], dtype=torch.long).to(Hi.device)\n",
    "\n",
    "    tmp_c[v - first_i] = c\n",
    "    c = tmp_c\n",
    "\n",
    "    tmp_v[v - first_i] = v\n",
    "    v = tmp_v   \n",
    "\n",
    "    degree_max = torch.max(c).item()\n",
    "    \n",
    "    idxN = torch.zeros(Hi.shape[0] * degree_max, dtype=torch.long).to(Hi.device)\n",
    "    mask_idxN = torch.arange(degree_max).to(Hi.device).repeat(Hi.shape[0])\n",
    "    v_idx_sort = torch.argsort(v)\n",
    "    cn_idxN = torch.repeat_interleave(c[v_idx_sort], degree_max)\n",
    "    mask_idxN = mask_idxN < cn_idxN\n",
    "\n",
    "    edge_index_i_argsort = torch.argsort(edge_index_i)\n",
    "    idxN[mask_idxN] = edge_index_j[edge_index_i_argsort] - first_j\n",
    "\n",
    "    N = K[:,edge_index_j[edge_index_i_argsort] - first_j]\n",
    "\n",
    "    # Compute E\n",
    "\n",
    "    E = edge_attr[edge_index_i_argsort]\n",
    "    E = E.view(1, edge_attr.shape[0], edge_attr.shape[1])\n",
    "    E = E.repeat(self.num_heads, 1, 1)\n",
    "\n",
    "    # Compute T\n",
    "    c_v_idx_sort = c[v_idx_sort]\n",
    "    T = torch.repeat_interleave(Q, repeats=c_v_idx_sort, dim=1)\n",
    "\n",
    "    # Compute A\n",
    "    A = torch.cat([T, N, E], dim=2)\n",
    "    A = torch.matmul(A, self.Wa)\n",
    "    A = A.view(A.shape[0], A.shape[1])\n",
    "\n",
    "    # Compute Z\n",
    "    Z = self.leaky_relu(A)\n",
    "\n",
    "    # Compute alpha\n",
    "    alpha_1 = Z.clone()\n",
    "    alpha_2 = torch.full(size=(self.num_heads, Hi.shape[0] * degree_max), fill_value=float('-inf')).to(Hi.device)\n",
    "    alpha_2[:,mask_idxN] = alpha_1\n",
    "    alpha_3 = alpha_2.view(self.num_heads, Hi.shape[0], degree_max)\n",
    "    alpha_3 = torch.softmax(alpha_3, dim=2)\n",
    "    alpha_4 = alpha_3.view(self.num_heads, Hi.shape[0] * degree_max)\n",
    "    alpha = alpha_4.clone()\n",
    "    alpha[torch.isnan(alpha)] = torch.finfo(torch.float32).tiny\n",
    "\n",
    "    # Compute U\n",
    "    V = torch.matmul(Hj, self.Wv)\n",
    "    V = V[:,idxN]\n",
    "\n",
    "    alpha = alpha.unsqueeze(2)\n",
    "\n",
    "    U_ = alpha * V\n",
    "    U_ = U_.view(self.num_heads, Hi.shape[0], degree_max, U_.shape[2])\n",
    "    U = torch.sum(U_, dim=2)\n",
    "    U = torch.relu(U)\n",
    "    U = torch.cat([U[i] for i in range(self.num_heads)], dim=1)\n",
    "\n",
    "    return U\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "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",
    "    self.s2wGAT = GAT(d_hi=300, d_hj=128, hidden_size=64, d_e=50, num_heads=8)\n",
    "\n",
    "    # word to sen GAT\n",
    "    self.w2sGAT = GAT(d_hi=128, d_hj=300, hidden_size=64, d_e=50, num_heads=8)\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])]\n",
    "    edge_attr_w = edge_attr[data.edge_index[1] < len(data.x[0])]\n",
    "\n",
    "    edge_index_s_i = data.edge_index[1][data.edge_index[1] >= len(data.x[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",
    "\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(Hi=Hw, Hj=Hs, edge_index_i=edge_index_w_i, edge_index_j=edge_index_s_j, first_i=0, first_j=len(data.x[0]), 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(Hi=Hs, Hj=Hw, edge_index_i=edge_index_s_i, edge_index_j=edge_index_w_j, first_i=len(data.x[0]), first_j=0, 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": 19,
   "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": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "  os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/25 [00:00<?, ?batch/s]/home/rsaid/anaconda3/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 25/25 [00:04<00:00,  5.09batch/s, accuracy=0.776, loss=0.631, mae=0.362]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.535, val mae = 0.314, val accuracy = 0.740, r1 = 0.359, r2 = 0.128, rL = 0.226\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:04<00:00,  5.77batch/s, accuracy=0.775, loss=0.53, mae=0.333] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.529, val mae = 0.325, val accuracy = 0.747, r1 = 0.366, r2 = 0.142, rL = 0.237\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:04<00:00,  6.02batch/s, accuracy=0.769, loss=0.533, mae=0.347]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.537, val mae = 0.310, val accuracy = 0.744, r1 = 0.366, r2 = 0.139, rL = 0.235\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:04<00:00,  5.25batch/s, accuracy=0.772, loss=0.527, mae=0.339]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.526, val mae = 0.337, val accuracy = 0.746, r1 = 0.374, r2 = 0.149, rL = 0.242\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:04<00:00,  5.21batch/s, accuracy=0.771, loss=0.525, mae=0.34] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.531, val mae = 0.320, val accuracy = 0.751, r1 = 0.382, r2 = 0.155, rL = 0.248\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:04<00:00,  6.09batch/s, accuracy=0.776, loss=0.527, mae=0.336]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.524, val mae = 0.338, val accuracy = 0.750, r1 = 0.377, r2 = 0.150, rL = 0.246\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:04<00:00,  5.95batch/s, accuracy=0.783, loss=0.519, mae=0.338]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.527, val mae = 0.314, val accuracy = 0.734, r1 = 0.363, r2 = 0.136, rL = 0.238\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:04<00:00,  6.11batch/s, accuracy=0.797, loss=0.478, mae=0.307]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.539, val mae = 0.298, val accuracy = 0.744, r1 = 0.382, r2 = 0.155, rL = 0.253\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:03<00:00,  6.26batch/s, accuracy=0.804, loss=0.32, mae=0.189] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.656, val mae = 0.306, val accuracy = 0.744, r1 = 0.364, r2 = 0.137, rL = 0.235\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:04<00:00,  5.91batch/s, accuracy=0.803, loss=0.156, mae=0.0834]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.773, val mae = 0.285, val accuracy = 0.745, r1 = 0.367, r2 = 0.147, rL = 0.239\n",
      "Training duration = 69.71038150787354\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": 25,
   "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": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw 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": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAHFCAYAAADmGm0KAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABq1UlEQVR4nO3dd3gU5frG8e+mF1IIgdAChN6RGgIiKkXRw7FTVKr1HFSQY0FBDyI/UY+9gKAgohKCCpYDiqDSDh0BERFCDSUhBEghIXXn98eQhZgAISSZ3eT+XNdesrOTmWcTZO+888z72gzDMBARERGRAtysLkBERETEGSkkiYiIiBRBIUlERESkCApJIiIiIkVQSBIREREpgkKSiIiISBEUkkRERESKoJAkIiIiUgSFJBEREZEiKCSJSIU0e/ZsbDYbNpuN5cuXF3rdMAwaN26MzWbj2muvLfR6UlIS3t7e2Gw2Nm3aVOQ5hg8f7jhHUQ8RcW0eVhcgIlKWAgICmDlzZqEgtGLFCvbu3UtAQECRX/fpp5+SnZ0NwMyZM+nUqVOR+/n6+vLzzz+Xas0i4hwUkkSkQhs4cCCff/4577//PoGBgY7tM2fOJCoqitTU1CK/btasWdSoUYP69esTHR3NG2+8ga+vb6H93Nzc6Nq1a5nVLyLW0eU2EanQBg8eDEB0dLRjW0pKCl999RUjR44s8mvWr1/P77//zpAhQ3jggQcc+4tI5aKQJCIVWmBgIHfeeSezZs1ybIuOjsbNzY2BAwcW+TUzZ84EYOTIkQwaNAg/Pz/HtqLk5uYWetjt9tJ9IyJS7hSSRKTCGzlyJBs2bGDHjh2AeSntrrvuKrIfKSMjg5iYGLp27UrLli0JCAjgrrvucvQw/VV6ejqenp6FHn379i3z9yUiZUs9SSJS4fXs2ZNGjRoxa9Yshg8fzsaNG3n99deL3Hf+/PmkpqYWuBQ3cuRIPvnkEz7++GMmT55cYH9fX19WrlxZ6Djn9z+JiGtSSBKRCs9mszFixAjeeecdMjMzadq0KT169Chy35kzZ+Lj48ONN95IcnIyAG3btqVBgwbMnj2bF154AXd3d8f+bm5uF7zzTURcmy63iUilMHz4cJKSkvjggw8YMWJEkfvs3r2b1atXk5mZSb169ahatarjceDAAY4cOcKSJUvKuXIRsYpGkkSkUqhTpw5PPvkkf/75J8OGDStyn/zm7A8//JDGjRsXeO3MmTPccsstzJo1i5tuuqnM6xUR6ykkiUil8fLLL1/wtdzcXObMmUOLFi24//77i9ynf//+fPvttxw/fpzq1asDYLfbWbduXZH7t2/fHm9v7ysvXEQsoZAkIgIsWrSIhIQExo0bd8F9HnzwQRYsWMCnn37K2LFjAXOEKSoqqsj9Y2NjC41IiYjrsBmGYVhdhIiIiIizUeO2iIiISBEUkkRERESKoJAkIiIiUgSFJBEREZEiKCSJiIiIFEEhSURERKQImiephOx2O0ePHiUgIACbzWZ1OSIiIlIMhmGQlpZG7dq1cXO7+FiRQlIJHT16lPDwcKvLEBERkRI4dOgQdevWveg+CkklFBAQAJjf5MDAQIurERERkeJITU0lPDzc8Tl+MQpJJZR/iS0wMFAhSURExMUUp1VGjdsiIiIiRVBIEhERESmCQpKIiIhIEdSTJCIi4mTsdjvZ2dlWl+GSPD09cXd3L5VjKSSJiIg4kezsbPbv34/dbre6FJcVHBxMzZo1r3geQ4UkERERJ2EYBvHx8bi7uxMeHn7JyQ6lIMMwyMjIIDExEYBatWpd0fEUkkRERJxEbm4uGRkZ1K5dGz8/P6vLcUm+vr4AJCYmUqNGjSu69KaIKiIi4iTy8vIA8PLysrgS15YfMHNycq7oOApJIiIiTkZrgl6Z0vr+KSSJiIiIFEEhSURERJxKgwYNeOutt6wuQ43bIiIicuWuvfZarrrqqlIJNxs3bsTf3//Ki7pCGklyQit3HyczJ8/qMkREREqNYRjk5uYWa9/q1as7xd19CklOZuGWwwz7eAMPfrpZQUlERFzC8OHDWbFiBW+//TY2mw2bzcbs2bOx2WwsWbKETp064e3tzapVq9i7dy+33HILYWFhVKlShc6dO7Ns2bICx/vr5TabzcZHH33Ebbfdhp+fH02aNOHbb78t8/elkORkagf54uPhzsrdx3lIQUlEpFIzDIOM7FxLHoZhFLvOt99+m6ioKB544AHi4+OJj48nPDwcgKeeeoopU6awc+dO2rZty+nTp7nppptYtmwZW7Zs4YYbbqB///7ExcVd9BwvvPACAwYM4LfffuOmm27innvu4eTJk1f0/b0U9SQ5mciG1fh4RGdGfLyRFbuP8/Bnm/ng3o74eJbOOjQiIuI6zuTk0fL5JZac+49JN+DnVbyYEBQUhJeXF35+ftSsWROAP//8E4BJkybRp08fx77VqlWjXbt2jueTJ09m4cKFfPvttzzyyCMXPMfw4cMZPHgwAC+99BLvvvsuGzZs4MYbb7zs91ZcGklyQl0bVmPW8M74eLqxfNdx/vHZZrJyNaIkIiKup1OnTgWep6en89RTT9GyZUuCg4OpUqUKf/755yVHktq2bev4s7+/PwEBAY7lR8qKRpKcVFQjMyiNnL2RX3Yd5x+f/cq0ezvg7aERJRGRysLX050/Jt1g2blLw1/vUnvyySdZsmQJr732Go0bN8bX15c777yT7Ozsix7H09OzwHObzVbmiwArJDmxbo1CmTWsMyM/2cjPfybyz89+ZaqCkohIpWGz2Yp9yctqXl5ejmVVLmbVqlUMHz6c2267DYDTp09z4MCBMq6uZHS5zcl1axzKzGGd8fZw46c/Exn1+a9k55ZtchYREblcDRo0YP369Rw4cICkpKQLjvI0btyYBQsWsHXrVrZt28bdd99d5iNCJaWQ5AK6nxeUlu1M5J8KSiIi4mSeeOIJ3N3dadmyJdWrV79gj9Gbb75J1apV6datG/379+eGG26gQ4cO5Vxt8diMy7nHTxxSU1MJCgoiJSWFwMDAcjnnqtjj3PfJJrJz7fRpGcb7d3fAy0M5V0SkosjMzGT//v1ERETg4+NjdTku62Lfx8v5/NYnrAvp0aQ6Hw3thJeHG0v/OMaj0b+Sk6cRJRERkbKgkORirmlanQ/PBqUlO47x6NwtCkoiIiJlQCHJBfVsWp0ZQzri5e7GDzsSeCxaQUlERKS0KSS5qGub1WD6UDMoff97AqPnKSiJiIiUJoUkF3ZdsxpMPzuitHh7AmPmbSVXQUlERKRUKCS5uOua12DavR3wdLexaHs8o2MUlEREREqDQlIF0KtFGB/c29EMSr/FM0ZBSURE5IopJFUQvVqEMe0eMyj997d4Hp+/TUFJRETkCigkVSC9z04w6elu47ttR/nXFwpKIiIiJaWQVMH0bVWT9+/ugIebjW+2HuWJL7aRZ9ek6iIi4twaNGjAW2+9ZXUZBSgkVUB9W9XkvbNB6WsFJRERkRKxPCRNnTrVsbZKx44dWbVq1QX3Xb16Nd27d6datWr4+vrSvHlz3nzzzQL7zJ49G5vNVuiRmZlZ4vO6ohtb1+S9u9vj4WZj4ZYjPKmgJCIiclksDUkxMTGMGTOG8ePHs2XLFnr06EG/fv0uuHKwv78/jzzyCCtXrmTnzp1MmDCBCRMmMGPGjAL7BQYGEh8fX+Bx/gJ3l3teV3Vj61q8O7g97m42Fmw5wpNfKiiJiEjpmz59OnXq1MFuL9gH+/e//51hw4axd+9ebrnlFsLCwqhSpQqdO3dm2bJlFlVbfDbDMCz71IyMjKRDhw5MmzbNsa1FixbceuutTJkypVjHuP322/H39+fTTz8FzJGkMWPGkJycXKbnvZxVhK22eHs8j0ZvIc9ucGfHurxyR1vc3WxWlyUiIn9RaPV6w4CcDGuK8fQDW/E+K06ePEmtWrVYvHgxvXr1AuDUqVPUrFmT7777jrCwMNatW0e3bt3w8fHhk08+4fXXX2fXrl3Uq1cPMHuSxowZw5gxY6649ELfx/Nczue3xxVXUkLZ2dls3ryZcePGFdjet29f1qxZU6xjbNmyhTVr1jB58uQC20+fPk39+vXJy8vjqquu4sUXX6R9+/ZXdN6srCyysrIcz1NTU4tVozO4qU0tDAMem7eFLzcfxga8ckdb3BSUREScW04GvFTbmnM/exS8/Iu1a0hICDfeeCNz5851hKQvvviCkJAQevXqhbu7O+3atXPsP3nyZBYuXMi3337LI488UibllwbLLrclJSWRl5dHWFhYge1hYWEkJCRc9Gvr1q2Lt7c3nTp1YtSoUdx///2O15o3b87s2bP59ttviY6OxsfHh+7duxMbG3tF550yZQpBQUGOR3h4+OW+ZUvd3LYWbw+6Cnc3G19sPsy4Bb9h16U3EREpJffccw9fffWVY0Dh888/Z9CgQbi7u5Oens5TTz1Fy5YtCQ4OpkqVKvz5559O3+Zi2UhSPttfhvIMwyi07a9WrVrF6dOnWbduHePGjaNx48YMHjwYgK5du9K1a1fHvt27d6dDhw68++67vPPOOyU+7zPPPMPYsWMdz1NTU10uKP2tbW0MA0bP28L8TYexYWPK7W00oiQi4qw8/cwRHavOfRn69++P3W5n0aJFdO7cmVWrVvHGG28A8OSTT7JkyRJee+01GjdujK+vL3feeSfZ2dllUXmpsSwkhYaG4u7uXmj0JjExsdAoz19FREQA0KZNG44dO8bEiRMdIemv3Nzc6Ny5s2MkqaTn9fb2xtvb+5Lvy9n1b1cbAxgzbwsxmw5hs8FLtykoiYg4JZut2Je8rObr68vtt9/O559/zp49e2jatCkdO3YEzMGN4cOHc9tttwFmW8yBAwcsrLZ4LLvc5uXlRceOHVm6dGmB7UuXLqVbt27FPo5hGAV6hYp6fevWrdSqVatUz+vK/t6uNm8OvAo3G8zbeIjxX/+uS28iInLF7rnnHhYtWsSsWbO49957HdsbN27MggUL2Lp1K9u2bePuu+8udCecM7L0ctvYsWMZMmQInTp1IioqihkzZhAXF8fDDz8MmJe4jhw5wpw5cwB4//33qVevHs2bNwfMeZNee+01Hn30UccxX3jhBbp27UqTJk1ITU3lnXfeYevWrbz//vvFPm9lcMtVdTAMGDt/K9Eb4rDZYPItrTWiVAqOp2Xxa9wpWtQMpF61yxuuFhFxZddffz0hISHs2rWLu+++27H9zTffZOTIkXTr1o3Q0FCefvppl7gBytKQNHDgQE6cOMGkSZOIj4+ndevWLF68mPr16wMQHx9foKnLbrfzzDPPsH//fjw8PGjUqBEvv/wyDz30kGOf5ORkHnzwQRISEggKCqJ9+/asXLmSLl26FPu8lcWt7etgYDB2/jbmro/DzQYv3tL6kj1hUrTEtEymr9jH5+sPkplj/oZUL8SPq5uE0qNxKN0ahRLk52lxlSIiZcfd3Z2jRwv3UDVo0ICff/65wLZRo0YVeO6Ml98snSfJlbnSPEmXsuDXw/zri20YBtzbtZ6C0mU6lprJByv2Mnd9HFm5ZjgKD/ElPjmT3PMuY7rZoE3dYHo0DuXqJqF0qFcVLw/LJ70XESdysfl9pPhcfp4kcR63d6iLYcATX27js3VxuNlsvPD3VgpKl5CQksm05XuI3niI7LPhqEO9YEb3bso1TUJJz85j/b4TrIpNYvWeJPYknmbboWS2HUrmvV/24OflTmRECFc3qU6PJqE0qVFF33MRESeikCQA3NGxLgbw5JfbmLP2IDZgooJSkY4mn2Ha8r3EbDxEdp4ZjjrVr8ro3k24unGo43tWxduDXi3C6NXCvGsyPuUMq88Gpv/tSSLpdDa/7DrOL7uOAxAW6E33xqH0aBJK98ah1AjQb5EiIlZSSBKHOzvWxW4YPP3Vb3yy9iA2m41/92+poHTW4VMZTFu+l/mbDpGTZ15G6xIRwpheTYhqVO2S36daQb7c1SmcuzqFY7cb/JmQxuo9x1kVm8SG/Sc5lprFgl+PsODXIwA0rxnA1WcvzUVGVMPXy73M36OIiJyjkCQFDOgUDgY8veA3Zq85gM0Gz/+tcgelQyczmLp8D19uPuwIR10bhjC6V1OiGlUr0THd3Gy0rB1Iy9qBPHhNIzJz8th88NTZS3PH2XE0lT8T0vgzIY2PVu/Hy92NjvWrmk3gTUJpVTtI6++JVGBqF74ypfX9U0iSQgZ0DsfA4OmvtvPx/w5gw8Zzf2tR6YJS3IkM3v9lD1/9etjRgN2tUTVG92pCZMOShaML8fF0p3tj8zIbNOdkejb/25PkuDx3JPkMa/edYO2+E/xnyS6C/Tzp3sgcZbq6cSjhIZpqQKQicHc3R4yzs7Px9fW1uBrXlZFhLgrs6XlldxTr7rYSqkh3t13IvA1xjFuwHYD7ro5gws2VIygdPJHOez/vYcGWI+SdDUdXNw5ldO8mdG4QUu71GIbB/qR0Vu9JYlVsEuv2niAtK7fAPg2q+Z0NTNWJalSNIF9NNSDiigzDIC4ujpycHGrXro2bm+6AvRyGYZCRkUFiYiLBwcGOiaTPdzmf3wpJJVQZQhLA3PVxPLvQDEoP9Ijg2ZsqblDan2SGo6+3ngtH1zStzuhejelYv/zD0YXk5tnZdjjZvDQXm8SWQ8mOesGcaqBdeP5UA9VpXy8YT3f9QyviKrKzs9m/f79LzEjtrIKDg6lZs2aRn1cKSeWgsoQkgM/XH2T8wt8BePCahjzTr3mFCkp7j5/mvZ/38M3WI+RnjWubVeexXk3oUK+qtcUVQ1pmDuv2nWR17HFW7Uli3/H0Aq/7e7nTtWE1Rz9To+qaakDE2dntdqdf/NVZeXp6Oi5bFkUhqRxUppAE8Nm6g0z42gxKD13TkHEVICjtSUzj3Z/38N22o45wdH3zGjzWqwlXhQdbWtuVOJpsTjWw6uxUAyfTC/5DWzPQxxGYujcOJbSK6y/cLCJSXApJ5aCyhSSAT9cd5LmzQenhno14+sZmLhmUYo+l8c7Pe/jvb0fJ/9vfu4UZjtrWDba0ttJmtxv8EZ/K6rNN4BsOnHRMfJmvRa1AepxtAO8SEYKPp6YaEJGKSyGpHFTGkAQwZ+0Bnv9mBwD/uLYRT93gOkFpV0Ia7/wUy+Lf4x3hqG/LMB7r1YTWdYKsLa6cZObksfHASXOkKTaJP+ILLjDp5eFG5wZVubqxOQt4y1qBWvRYRCoUhaRyUFlDEhQMSqOua8QTfZ07KO2MT+Wdn2L5/vcEx7YbW9Xk0V6NaVW7coSjC0k6nVVgqoH4lMwCr4f4e9GtUTVzpKlJdeoE65ZkEXFtCknloDKHJIDZ/9vPxO/+AOCR6xrzr75NnS4o7Tiawjs/xbJkxzHHtpva1OTR65vQolbl+5ldimEY7D2ezurY46zek8TavSdIz84rsE/DUH/H3Ey1gnwxMDAMMM5+vflf4Ox2u1Fwu4G58/nPzf3MfThvW1HH/euxzt+H87bb7QW/lkL7n3/Ooo/v4+lO3aq+hIf4USfYV4sRi1QQCknloLKHJICP/7efF84GpUevb8zYPs4RlH4/ksLbP8Wy9A8zHNlscHObWjx6fROa1QywuDrXkZNnZ+uh/KkGjrPtcEqBqQYqE5vNbHgPr+pH3RBfwqv6ER7iR/jZEBUW6KMZ0EVchEJSOVBIMs1cvZ8X/2sGpcd6NWFsn6aW1fLb4WTeXhbLT38mAuYHW/+2tXn0+sY0CVM4ulKpmTms3XuC1bFJrNt3grTMXGw2sIEjHNts5sPNZnNstwGct58tfz9sZ/c/b9v5288e0IY599Nfv/bcMc99jZvN/C+FzvXX8xRVR8HjpmflcvjUGQ6dyiAz5+Lz1Xi626gTbAamulX9CP9LkArx93KKXyBERCGpXCgknfPRqn1MXrQTgDG9mzCmd/kGpa2Hknl72W5+2XUcMD9Q/96uNo9c34TGNaqUay1S8RiGQdLpbA6dyuDQyQwzOJ3MOPv8DEeTzziWrbkQPy/3s6HJ92yIOjcKFR7iRxVvrRAlUl4u5/Nb/2fKFbu/R0MAJi/ayVvLYrFhY3TvJmV+3l/jTvH2slhW7D4Xjm69qg6PXN+YhtUVjqR02Gw2qgd4Uz3Au8jJRXPz7CSkZnLopDnqdPhkBofOC1LHUrPIyM5j17E0dh1LK/IcVf08zwanwpfz6lT1xdujlKdlOLwZts+H9kOgZuvSPXYpy7MbpJ7JIeVMDsln/+t4ZGQ7/pyccW576pkcUjNz6dmsOq/f1U7TWkiJaSSphDSSVNiHK/fxf4vNEaWxfZryWK+yCUqbDpzk7Z9iWRWbBIC7m43b2tdh1HWNiQj1L5NzynkMAw6sgqBwCImwuhqnl5mTx5Hk/NB05myIynCEquSMnIt+vc0GYQE+jkt4df8yClXzcvqhMk7CT5Ng82zAAA9fuOU9aHPnFb/Pi7HbDdKycknJKBhyks9kFwg2yRl/DUE5hdYpvFzXNavO9CGd1HgvDrrcVg4Ukoo2fcVepnz/JwD/6tOUR0sxKG3Yf5K3f9rN//acAMDDzcbtHcxwVL+awlG5sNthyTOw/gNw84Sof8I1T4K3er5KKi0zxxGYirqcdyYn76Jf7+luo3aw7wUv51Xz98JmGLAtGpY+Bxnm/z+ENIKTe80/dx8Nvf4NbhcecTEMg/TsPJIzLhxsks/bfv7oTlpmDlfa81/F24MgX08CfT0J8vUg2NeLIF9Pgvw8zf+e9wj28yQxNYtHon8lM8fOTW1q8s6g9nhoDUNBIalcKCRd2Acr9vLy2aD05A3NGHVd4ys63rp9J3h7WSxr950LR3d2rMuo6xoTHuJ3xfVKMeXlwDej4LeYgturhEGfSdBmAGjF8lJlGAYn0rMdo1D5Ierw2UB1JPkMOXkX/ye8recR/s/rY9rkmTdYnPJvyO5OL+DTsDvVN7xC7R3TATgcEsU3jSaRkONXcDTnvOBzqd6rS/H1dC8YaPwKh5v8IBR83vZAX88SLdK8YvdxHvhkE9l5du7oUJf/3NlWk6OKQlJ5UEi6uGnL9/LKDyUPSoZhsPZsOFq//yRg/sZ8V6dw/tGzkcJRecs5A1+MgN3fg80dbp0GvsHwwzg4uc/cp24XuOlVqN3e0lIrkzy7wbHUzAIhyuyLOsOJkycYlDGXEe7f42Gzk2F481bu7czK60fuee2of3Nby6ueM/CzZXHQXoMHc8ayy6h3wXN6ubsVCDfB5wWZ84PO+cEn/7VS760qhh9+T2DU3F/JsxsMjarPC39vpTsNKzmFpHKgkHRp7/+yh/8s2QXAUzc245/XXjooGYbBmr1mONpwwAxHXu5uDOhcl39c21gzPlshMwXmDoK4NeDhA3d9As1uNF/LzYJ1U2HFfyAnHbBBh6HQ63nwD7W07ErLMOCPb+CHZyDtKADHw29gdaN/setMkKO5/FhqFn5e7gT6etLaPY7HT0ykWk4C2W6+rGw1iVP1+50XdLwcf/bxdHO5kLFwy2HGzt+GYbj2upNSOhSSyoFCUvGcH5TG9WvOwz0bFbmfYRisik3inZ9i2XTwFGCGo0Fdwnm4ZyNqKxxZ43QifHY7JGwH70AYPA8adC+8X2o8LPv3uUtx3kFw3bPQ+T5w9yzfmiuzE3th8ZOw9yfzedUG0O8/0LTvpb824yR8MRz2rzCf93jC/BlepE/JlcxdH8ezC7cD8ETfpjxyfdnfgSvOSSGpHCgkFd+7P8Xy+tLdADzTrzkPnReUDMNgxe7jvP1TLFvikgFzkdW7u9Tj4Z6NqBnkY0XJAnDqIHx6q3k5zb863LsAarW9+NfErTM/pBN+M59XbwH9XoGGPcu83Eot5wysftN85GWDuxdc/bj58LyMXzDycs2wu/Y983mTG+D2Geal1Qrg/Dtwn/9bS0ZerbszKyOFpHKgkHR53vkpljfOBqXxN7Xg/h4RLN9lhqOth5IB8PZw457I+jzUsyFhgQpHlkrcCZ/eBmnxEFQPhn4N1YoeBSzEnge/zjFvNT9jXjKlxd/hhv+D4Av3ukgJxS41g+mp/ebzRtfDTa8V/+dVlG0x8N1jkJsJ1RrDoLlQvVnp1Guxt5bt5q1lsQC8ckcbBnbW38nKRiGpHCgkXb63l8Xy5jIzKDWs7s++4+kA+Hi6cW9kfR7s2ZAaAQpHlju8CT6/E86cMkeChiyAwNqXf5wzp+CXKbDxQzDsZj/T1Y+bt5tfzuiGFC3lsNl3tPNb83lAbbhxCrS8BUqj3+boVph3D6QeBq8Ac0Sp+U1XflyLGYbBS4t38uGq/dhs8Pag9vy9XQn+fovLUkgqBwpJJfPm0t28/ZP5W5yvpztDourzQI+GVA/wtrgyAWDvzzDvXrMJu04nuOcL8Au5smMe2wHfP21OQAnmyNQNk83RJTXPXr68HFg3DZa/bP6cbO7Q9R9w7bjSn6/q9HGzT+ngavP5tc/ANU+5/FQPhmEw/uvfmbs+Dg83G9Pu7UiflmFWlyXlRCGpHCgklVzMxjiOpWZxd2Q9QqsoHDmNHQvhqwfAngMNr4OBn4F3KS3vYhjwx9ewZII5MgEQ0dPsV6rRonTOURkcXAP/HQvHzb4awrvC396AsFZld868HFgyHjaY8ynR7Ga47QPwce1/9+x2g399sY2FW47g5e7GrOGdubqJ7sisDBSSyoFCklQomz6G/z4OGNDyVvPSikcZBNjsDPjfW7D6LcjLMkdBujxojoJUkObgMnH6uDlb9rZo87lfNejzIrQbXH6jOls+N/+O5GVBaDOzTyn0yiaKtVpunp1Rc39lyY5j+Hq68+l9XejU4ApHTsXpKSSVA4UkqRAMA1a/YTZZA3QcATe/Xva3fZ86YI5O/Plf87lfqDm3Uvt7K8wt56XCngebPzZ/PpkpgA06Dje/V1d6GbQkDm+GmHvN+Ze8g+COj4o3vYATy8rN44E5m1m5+zgB3h7MfaArbeoGWV2WlCGFpHKgkCQuzzDgxwnnbvfu8S+4/rny7RPa+zN8Pw6SzLm0qHUV3PQfCO9SfjU4qyO/wqKxcHSL+bxmW/jbm1C3k7V1pR2D+UPh0DrABtdPMP/uuHB/2ZnsPIbN2sCGAyep6udJzENRNA3TeoQVlUJSOVBIEpeWl2ve4r31c/N53/+Dbo9YVEsObJhhNiJnpZrb2g2G3hMhoKY1NVnpTDL8/CJsnAkY5iSe1z9nTszpLKNsudnww9OwaZb5vOUtcMvU0uths0BaZg73frSebYdTqBHgzfyHomgQqoWzKyKFpHKgkCQuKycTvhwJuxaZPUF/fxfa32N1Vebs3j+9AFs+M597BUDPpyDyYfDwsra28mAY5ozlP06A9OPmtjYDoO9kCHDSO682z4ZFT5jN/jVawqDPIaSh1VWVWHJGNoNmrOPPhDTqBPvyxcNRmu2/AlJIKgcKSeKSMlNh3t3m7fju3nDXx9D8ZqurKujwZvj+STiy2XxerTHc+Ao06W1tXWUp8U9Y9K9zt9qHNjV7wyKusbau4ohbD/OHwOlj4BMMd86Cxr2srqrEjqdlMWD6WvYnpdMw1J+Yh6I0RUkFo5BUDhSSxOWkJ8Fnd0D8VnOUZnA0RPSwuqqi2e3mnVzLJkJ6ormtaT9z1u4rmUna2WSdhpWvwtr3wZ4LHr7m6FnUI641epYabzZ0H9kENjfzUmm3x1y2T+lI8hkGfLCWI8lnaF4zgHkPdiXYz4V+HnJRCknlQCFJXEryIXMdthN7zNvH7/0Kare3uqpLy0yBFa/C+g/MEOHuBd0ehavHunT/C4Zh3tn3/bhz80Y1uxn6vey6S7fkZpmN5vmXS1vfAX9/D7z8rK2rhA4kpXPX9LUcT8uiXd0gPrs/kgAfLdZcESgklQOFJHEZx3eZ67ClHoGgcBiyEEJdbAX047vNRuG9P5vPA2pD3xfND2JXG604uR++fwpifzSfB9eDfq9Cs37W1lUaDAM2fgQ/jDNDbc02MPBzqFrf6spKZPexNAZOX8upjBy6RITwyYgu+Ho5SfO8lNjlfH5bPrf81KlTiYiIwMfHh44dO7Jq1aoL7rt69Wq6d+9OtWrV8PX1pXnz5rz55psF9vnwww/p0aMHVatWpWrVqvTu3ZsNGzYU2GfixInYbLYCj5o1K+FdNFLxHdkMs240A1JoUxj5g+sFJIDqTeHeBeYEhsH1zXl6vroPPu4H8b9ZXV3x5GaZo2JTu5oByc0TejwB/1xfMQISmIG1ywMw9Ftz7quE7TDjWti3wurKSqRpWABzRkYS4O3Bhv0nefizzWTl5lldlpQjS0NSTEwMY8aMYfz48WzZsoUePXrQr18/4uLiitzf39+fRx55hJUrV7Jz504mTJjAhAkTmDFjhmOf5cuXM3jwYH755RfWrl1LvXr16Nu3L0eOHClwrFatWhEfH+94bN++vUzfq0i527ccPvk7nDkJtTvAiB8gqK7VVZWczWY2mY/aYM7N4+kHcWthRk9zqY6Mk1ZXeGF7f4apUfDL/0Fuprkkyz/XQq/nXPZy1EU16A4PrTDnvTpz0hzJXDvVHGlyMW3qBjFrRGd8Pd1Zsfs4j0VvITfPbnVZUk4svdwWGRlJhw4dmDZtmmNbixYtuPXWW5kyZUqxjnH77bfj7+/Pp59+WuTreXl5VK1alffee4+hQ4cC5kjS119/zdatW0tcuy63iVP741tzpCUv2/xAHvR56S9+arWUw/Djc7BjgfncJ9gMT51GOs98QqlHYcmz5rp4AFVqwo0vQavbXe8yYUnknIHvxsBv88znbQdB/7fA0/Vuq18dm8TI2RvJzrNze/s6vHZXO9zcKsHPsAJyictt2dnZbN68mb59C05p37dvX9asWVOsY2zZsoU1a9bQs2fPC+6TkZFBTk4OISEFp/CPjY2ldu3aREREMGjQIPbt23f5b0IuT3qSuWbXu53g3Y6w+RNzUkMpXb/OgS+GmQGpRX+454uKF5DAHBW762MYvghqtILMZFj8BEzvCQf+Z21tebnmHWvvdTYDks0Nuv4THtnomn1UJeXpay6Ge+PL5pxcv80zL/+mHLa6sst2dZNQ3ru7Pe5uNhZsOcJz3/yOWnorPstCUlJSEnl5eYSFFZwkLSwsjISEhIt+bd26dfH29qZTp06MGjWK+++//4L7jhs3jjp16tC797k5ViIjI5kzZw5Llizhww8/JCEhgW7dunHixIkLHicrK4vU1NQCDykGwzBXLv/qfnijBSz7N5yINe+y+u4xmBoJvy8wb/mWK/e/t+HbR8GwQ/shcNcnZbNQrTNpcDU8tBJues0cTTq2HWbfZE6YacWHcdw68xLgkmch+zTU7QIProAbp4BPJRx1ttmg6z/MGwZ8Q8wpKJwhyJZA31Y1eWNAO2w2+Hx9HFO+/1NBqYKzvHHb9pffqAzDKLTtr1atWsWmTZv44IMPeOutt4iOji5yv1dffZXo6GgWLFiAj4+PY3u/fv244447aNOmDb1792bRokUAfPLJJxc855QpUwgKCnI8wsPDi/sWK6fMFFg/w+zD+LgfbP/CHNmo3cG8LfiGl8xb0U/sgS9HmB8qsctcsmfBKRgGLH3efAB0H23OpO0sl53KmruH2TD82Bbzchs2+P0rcyRn5X/MWcbLWvoJ+GYUzLoBjv0OvlXNn8HIJVCrbdmf39k17AkPLoewNpCRBHP+Dhs+dLn/52+5qg5TbmsDwIyV+3jnpz0WVyRlybKepOzsbPz8/Pjiiy+47bbbHNtHjx7N1q1bWbGieHdDTJ48mU8//ZRdu3YV2P7aa68xefJkli1bRqdOl14Qsk+fPjRu3LhAf9T5srKyyMrKcjxPTU0lPDxcPUl/dXSLuebU719BToa5zdMP2txpfnidPzdPZiqsmwpr3oPsNHNb/e7Q699QL7L8a3dV9jz47xjzMhtA7xfg6jFWVmS9+G3w/dNmYzdA1QZwwxTzLrLSvtRlt8OWOebEl2dOmds6DIVeE8G/WumeqyLIzoBvHzH/jQBofy/c/IbLjXjOXL2fF//7BwATbm7B/T1cdzmWysYlepK8vLzo2LEjS5cuLbB96dKldOvWrdjHMQyjQHgB+M9//sOLL77IDz/8UKyAlJWVxc6dO6lVq9YF9/H29iYwMLDAQ87KTjc/oGdcaz62fGoGpOotoN9/4F9/mr9R/3XyQp9AuHYcjN5mzjDs7g0H/wez+sLcQZDwuxXvxrXkZpn9R7/OMfte+r+jgARQqx2M+B7umGnOqXTqAMwbbM44fnx36Z0nfhvM7APfjTYDUlgbuG+p+fddAaloXn7mz6XPi+bf2S2fwcc3mU3uLuS+qyP4V5+mAExetJO564u+K1tcm6V3t8XExDBkyBA++OADoqKimDFjBh9++CE7duygfv36PPPMMxw5coQ5c8zfkN9//33q1atH8+bNAXPepDFjxvDoo48yefJkwLzE9txzzzF37ly6d+/uOFeVKlWoUsWcofeJJ56gf//+1KtXj8TERCZPnsyKFSvYvn079esXb9Iz3d0GJO6ETR/DtnmQlWJuc/cyVwTvdB/U63p5v7WnHDZXgt/6udlTg80cgbruWZdeNLPMZKXBvHtg/wrz+37HR+b3XgrKOg2rXoe175mXfN08zEVzez5d8h6hzBT45SXYMMP8u+oVANePh84PmJf+pHj2/GT2jmUmQ5UwGPCpS40iG4bByz/8yfQV+7DZ4M0BV3Fr+zpWlyWX4FIzbk+dOpVXX32V+Ph4WrduzZtvvsk115iLOg4fPpwDBw6wfPlyAN59912mT5/O/v378fDwoFGjRjzwwAM89NBDuLmZg2INGjTg4MGDhc7z73//m4kTJwIwaNAgVq5cSVJSEtWrV6dr1668+OKLtGzZsth1V9qQlJsFO7+DTbPMUZ98VSOg0wi46h7wD72ycyTFws+T4Y+vzeduHtBhmLmmVYAm/QTM/pfP74Sjv4Knv3mLf6PrrK7KuZ3YC0vGw+7vzef+NaDPC+Zt6W7FHFQ3DPMy0ZJnzQVdwbxbre//QeCFR6LlIk7uM8N+4h/mBJs3/cf8t8RFGIbB89/s4NN1B3F3szH1ng7c0Er/TjkzlwpJrqrShaST+2HzbHNoPCPJ3GZzN3s8Oo2EhtcV/4OmuI5uhZ8mwd6fzOcevhD5kHk5ybdq6Z7LlaQcMSfnS9pl3i10z5dQt6PVVbmO2KXmshknzjbc1ukEN70KdS7xPTy+Gxb/C/avNJ9Xa2zeUadweuWyTsPX/4Cd35rPO44wl2pxkUV+7XaDJ77cxoJfj+Dl7sZHwzpxTdPqVpclF6CQVA4qRUjKy4XYJWYjdn5QAbPHo+Mwszk1sHbZ13FgNSx7AQ6fXV7GOwi6P2beVuzlX/bndyZJsWZASjlk/hyGfg3Vm1ldlevJzYb108xlQrJPm9va32veNFClRsF9szNg1Wvwv3fAngMePnDNE+Yq9y7WbOzUDMO8LPrzZMCA8K4wYA4EhF3yS51Bbp6dR6O38P3vCfh4ujFnZCRdIkIu/YVS7hSSykGFDkmpR81G4M2fmGtk5WvUyxw1anpj+fddGAbs/gF+ehESd5jb/GvANU9Cx+Eu8xvnFTm61Ww8zkgyRzGGLHTdFeOdRVqCeVfatrPTiHgHwrXPmNMJuHvCru9h8VOQcrYpt8kN5qhT1QZWVVzx7f7RnFctK8X8RWDgZy4zUpqda+fBTzexfNdxqnh78Pn9kbQLD7a6LPkLhaRyUOFCkt0O+34xe412fQ/G2UUc/aqZv2F3HO4czdN2O/z+pbkG1qkD5rbgenDts9B2QMWdF2j/KogebE6VUKsd3PMVVNFwfqk5tAEWP2lOdAgQ2swMQrFLzOdB4dDvFWh2U+WZLdtKSXtg3t3mJWV3L/jbm+a/Qy4gMyeP4R9vYN2+kwT7eRLzYBTNalbAGe9dmEJSOagwISk9ybybbNPHcGr/ue31ukHn+8xlLZzxkkJutjk3zYpXzzXQVm9hrt3V/OaK9UH25yL4YgTkZUH9q2FwdOWcubms2fPMnrufXoCMs7Pvu3lAt0fNEcvKdmnXapmpsPBh2GVO9kuXB81JaN09ra2rGE5n5XLvR+vZeiiZ0CrefPFwFBGh+vvjLBSSyoFLhyTDMJdO2DQT/vjGvC0azEsN7Qabd5bUaGFtjcWVnQEbpptrwmUmm9vqdIJez5sz/Lq6rXPhm0fMkb1mN8GdH4Onz6W/TkruTLLZg5R8yLz0VqO51RVVXnY7rHwVlp9d8Lx+d3OpHRcYRU3JyGHQh+vYGZ9K7SAf5j8cRd2qflaXJSgklQuXDEmZKfDbfPOSWuIf57bXbm/2GrW+w3V/Wz6TDGvegXXTzs303fBaMyxd6q4lZ7X2ffNWc4B2d5sTFGoOHqmM/lwECx4yLzcH1oVBnxWenNYJJZ3OYsD0tew7nk6Dan7MfyiKGoH6JcdqCknlwKVC0tGt5qjR9i/PBQgP33NLhdTpYGl5pSrtmDkKsOlj804kgBZ/Ny/DucpdYIZh3uGz6jXzeddR0Hdy6U+xIOJKju8y+/JO7jXvMOz/DrQbaHVVlxSfcoa7PljL4VNnaBpWhZgHo6jqXwluNHFiCknlwOlDUnaGOendplnmhIP5qjc3g1HbgeAbbFl5Ze7UAXP27m3zAMNc/qDd3XDt0859R5g9DxY/Yf7cAK5/Dnr8q2L1WImU1JlkWPDguYb6qEfMtQqdfIT14Il0Bkxfy7HULNrUCeLzByIJ9HH+3qqKSiGpHDhtSEr8EzZ/DFujzy0V4uZpLlfR+T6oF1W5PnATd5qjMn/+13zu7mWGxB5POF9fQ242LHwIdiwAbPC3N86uaC8iDna7eXdr/khrRE+zV8/J18rbk5jGgOnrOJmeTecGVflkZBf8vJw73FVUCknlwKlC0gWXCmlgzlx71T3OFwjK2+FN5nw4B1aZzz39IWoUdHsEfIIsLQ0wFwmOuRf2/myG2ttnQOvbra5KxHnt+Bq+/ifkpJujw4PmQs02Vld1Ub8fSWHwh+tIy8ylR5NQPhrWCW+PCjptiRNTSCoHThGSTh0we28KLBXiZt4F1WkENLxefSznMwxzLqifJsHRLeY236pw9Vhz8kBPX2vqyjgJcwfA4Y3g6QcDP4XGva2pRcSVHPsD5g02/y308IVb3zdvQHFimw+eZMjMDWRk59GnZRhT7+mAp7v+nS5PCknlwLKQlL9UyKZZ5granP3xBdQyF4HtMBSCtAr1RRmGuUbUz5Mhabe5LaC2uYBu+3vLdx6W1Hj47HbzbkOfYHMdtvDO5Xd+EVeXcRK+us8chQXoPtpcXsaJJ5ZdsyeJ4bM3kp1r55aravPGgKtwd6tEbRAWU0gqB+UeklLjzaVCfv0EUo+c297oeuh0nzVLhbi6vFz4bZ7Z4J1yyNwW0hCuGw+tbi/7UbgTe+HTWyE5DqrUNJcZCWtZtucUqYjseeYkoP9723zeqBfcOdOpF8L+aecxHvp0M7l2g8FdwnnptjbYKlO/qIUUkspBuYQkux32LzdHjf5c7LxLhbi63Czze7zytXOXLWu2geufhyZ9yqbRPWE7fHo7pCeaP8MhC7UemMiV2v6lOflq7hmoGgGDPoewVlZXdUHfbTvK6HlbsBtw39URTLi5hYJSOVBIKgdlGpLST5hLhWz+GE7uO7e9XpQ5atTy7865VIiry0ozJ6Nc8y5kpZrb6kWZQ/f1o0rvPAfXwNxB5t2HYW1gyILCK8+LSMnE/wbz7jEXJXbzgM73Q8+nwS/E6sqKNH/TIZ768jcAHuvVhLF9mlpcUcWnkFQOyiwkbZoF3z/9l6VCBpl3qelSTPnIOAmr34ANH0JuprmtSV9zzqJaba/s2LuXwPyh5nHrRcHgeRV7vioRK6SfgG8fPbfum0+QGZQ6PwAezjeR4+z/7Wfid+YqCM/0a85DPRtZXFHFppBUDsosJMWth1l9zZXeO91nzortqkuFuLrUo7DiFfj103OXOlvfYfYsVSvBP2K/zTcX7DTyoMkNcNds8NJaTiJlZt9yWDIejv1uPg9pCH0mQfO/Od18ce//sof/LNkFwIu3tmZI1/oWV1RxKSSVgzILSYZh/g/t5PN9VCon9pqT1/3+lfnc5m7eRdjzKQisXbxjrJ8O3z9l/rntQLjlfZdYzVzE5dnzzPaFnyfD6WPmtvrd4Yb/c7r131794U+mLt8LwBsD2nF7h7oWV1QxKSSVA6eYJ0nKV/xv8POLEPuj+dzDB7o8CFc/fuF+B8Mw755b8bL5PPJhuGGK5q8SKW9Zaebdb2vePXcZvd1g8zK6k0ybYhgGL3z3B7PXHMDNBu/f3YF+bWpZXVaFo5BUDhSSKrGDa8wJKePWms+9A6HbY9D1H+Bd5dx+djv88DRsmGE+v/ZZc/TJyYb5RSqVlMPm/7+/xZjPPXyh+2Pm/8Pn//9rEbvd4OmvfuOLzYfxdLcxY2gnrmumGztKk0JSOVBIquQMA2KXmv/YHttubvOvbq4J12mEOfP5wofh9y/N1/r9ByIftK5eESnoyGazXyn/l50qNaHXc+boksUTUebZDR6bt4VFv8Xj7eHGJyO70LWhc69N50oUksqBQpIA5mjRjgVmz1L+dA1B9SCoLsStMW9BvvUDaHuXtXWKSGH5s+8vfd5c2gTMftAbXoKIaywtLTvXzj8+28xPfybi7+XOZ/dH0r6e806O6UoUksqBQpIUkJdjrqG34hVIize3efjCgDnQtK+1tYnIxeVmmZfFV/zHnL8MzDUw+7wIoY0tKyszJ4+RszeyZu8Jgnw9mfdgV1rU0ufNlVJIKgcKSVKknDPmP7Z7f4Frx0G9rlZXJCLFlX7CvMli40xzqg4nmIwyPSuXITPX82tcMqFVvIh5KIpG1a3vnXJlCknlQCFJRKSCOr4blj4Hu38wn/sEn52M8n5LJqNMOZPD4Bnr+CM+lVpBPsx/KIrwEM2xVlKX8/mt+5BFRETOV70p3B0DQ76GsNaQmQxLnoGpkbDzv2YvUzkK8vXk0/u60LhGFeJTMrnno/UcS80s1xoqK4UkERGRojS6Dh5aCX9/F/xrmDdnxNwDs/8GR7eWaynVqnjz2X2RhIf4Encyg3s/Ws+J01nlWkNlpJAkIiJyIW5nZ9h/7Fe45klzEtmDq2HGtbDwH+byReWkZpAPc+/vSs1AH2ITTzN01gYyc/LK7fyVkUKSiIjIpXgHwPUT4NHN5tJCGLBtLrzTAX6ZAtnp5VJGeIgfn90fSYi/FzuOprJkR0K5nLfc5Waba+8l/G5pGQpJIiIixRVUF26fAQ/8DPWiIPeMeUfcOx1gy+fm3GllrHGNKtzW3lxKZf3+k2V+vnJzOtGcSiVmCLzaEObcAhumW1qSh6VnFxERcUV1OsKI7wtORvnNP2H9B+biuWU8GWVkRAgzV+9n/b4TZXqeMmW3Q8I22P2jeSfh0V8Lvu5fHXytnUBTIUlERKQkbDZoeQs0vfHcZJQJv8En/aHZzdBnUplNRtklIgSbDfYeT+d4WhbVA7zL5DylLuu0eRlt9w/m0k6n/3K5sNZV0PQG81GrveWLgSskiYiIXAkPb+j2KLS7+9xklLsWQeySMpuMMtjPi2ZhAfyZkMaG/Se5uW2tUj1+qTq5H2LPjhYdWA152ede8/Q37yJsegM06QsBNa2rswgKSSIiIqXBvxrc9B8zGP34nBmS1n8A2+aVyWSUXRtW48+ENNbvP+FcISkvBw6tN0PR7h8haVfB14Prm6NvTW+ABlebIdNJKSSJiIiUpurN4J75sPdnWDIBEneYk1Fu/NBcD675zealuivUJSKE2WsOsMEZmrfTT8CeZWYw2vsTZKace83mbja5519GC21aKu+/PCgkiYiIlIVG18PDq8w7tn6efG4yyvpXm83dta+6osN3iTAv4f2ZkMap9Gyq+pfjkimGAcd2nO0t+hEObQDOm4ncN8S8fNa0LzTqBb7B5VdbKVJIEhERKStu7tBxGLS+HVa/BWvfOzcZZbvB0Os5CKxdokOHVvGmcY0q7Ek8zYYDJ7mhVRn382RnwP6V5mXE3T9C6uGCr4e1PttbdAPU7WS+dxenkCQiIlLWvAPMQNRxOPw0CbbPNyej3LEQuo+G7o+Bl/9lHzYyIoQ9iadZv6+MQlLyobOhaIkZkHLPWzPOwwcaXnt2xOgGcw6pCsbyySSnTp1KREQEPj4+dOzYkVWrVl1w39WrV9O9e3eqVauGr68vzZs358033yy031dffUXLli3x9vamZcuWLFy48IrOKyIiUiqCw+GOD+H+nyG86xVPRhnZsBoA6/eX0nxJ9jyIWwfLXoCp3eCt1rDoX+YltdxMCKwLne6Du7+Apw+YCwF3vq9CBiSweCQpJiaGMWPGMHXqVLp378706dPp168ff/zxB/Xq1Su0v7+/P4888ght27bF39+f1atX89BDD+Hv78+DDz4IwNq1axk4cCAvvvgit912GwsXLmTAgAGsXr2ayMjIEp1XRESkVNXtCCN/uOLJKLue7Uv6Iz6VlDM5BPl6Xn4tZ07Bnp/M0aI9y+DMeY3gNjeo28XsLWp6I9Ro6TJN16XBZhiGcendykZkZCQdOnRg2rRpjm0tWrTg1ltvZcqUKcU6xu23346/vz+ffvopAAMHDiQ1NZXvv//esc+NN95I1apViY6OLrXzpqamEhQUREpKCoGBgcX6GhERkUJys85NRpl19q6wy5iM8rrXlrM/KZ2ZwzrRq0XYpc9nGHB817nLaHHrwDhvoVyfIGjc2wxFjXuX+hxPVrucz2/LLrdlZ2ezefNm+vbtW2B73759WbNmTbGOsWXLFtasWUPPnj0d29auXVvomDfccIPjmCU9b1ZWFqmpqQUeIiIiVyx/MsrHtkCXB81b5nctgqmR8P04yLj4Lf5dGpgh5qJTAeRkmqNEi5+Et9uZx176PBz8nxmQqjc3e6OGL4Yn98Gds6DtgAoXkC6XZZfbkpKSyMvLIyysYOoNCwsjIeHiqxrXrVuX48ePk5uby8SJE7n//vsdryUkJFz0mCU975QpU3jhhReK9d5EREQuW5GTUU6DbdEXnYwysmEIMZsOse6vISk1/tydaPt+gZyMc6+5e0GDHmcndewLVRuU7XtzUZbf3Wb7y7VNwzAKbfurVatWcfr0adatW8e4ceNo3LgxgwcPvqxjXu55n3nmGcaOHet4npqaSnh4+EXrFBERuWyXORllfvP2jiOnyNi/Hr/9y8xwFL+t4HEDap27Ey2iJ3hXKc935ZIsC0mhoaG4u7sXGr1JTEwsNMrzVxEREQC0adOGY8eOMXHiREdIqlmz5kWPWdLzent74+3tvFOni4hIBVOcySgzU6lz5Gfe9/+ELrmb8Pvk/FYQG9TpeG6m65ptK1XTdWmwrCfJy8uLjh07snTp0gLbly5dSrdu3Yp9HMMwyMrKcjyPiooqdMwff/zRcczSOq+IiEiZy5+M8rFfoccT5txE+ZNRTu8JrzaEL4Zxc97PVLelkuXuBy1vgVumwhO74YGfoOdTUKudAlIJWHq5bezYsQwZMoROnToRFRXFjBkziIuL4+GHHwbMS1xHjhxhzpw5ALz//vvUq1eP5s2bA+a8Sa+99hqPPvqo45ijR4/mmmuu4ZVXXuGWW27hm2++YdmyZaxevbrY5xUREXEqRU1GGb/VfK1aY3YFdmPirnDsdSOJGdDzYkeSy2BpSBo4cCAnTpxg0qRJxMfH07p1axYvXkz9+vUBiI+PJy4uzrG/3W7nmWeeYf/+/Xh4eNCoUSNefvllHnroIcc+3bp1Y968eUyYMIHnnnuORo0aERMT45gjqTjnFRERcUr5k1FGjYKE7ebCsaGN8T2Rwdqdv+B5JJ0z2Xn4ern+kiDOwNJ5klyZ5kkSERFnYRgGUVN+JiE1k7n3R9KtcajVJTktl5gnSUREREqHzWYjsqE5p1GhqQCkxBSSREREKoDIiLPruO0rpXXcRCFJRESkIsgfSdpyKJnMnLxL7C3FoZAkIiJSATQM9Se0ijfZuXa2HUq2upwKQSFJRESkAji/L2m9+pJKhUKSiIhIBdE1Ij8kqS+pNCgkiYiIVBBdzjZvbz54iuxcu8XVuD6FJBERkQqiSY0qVPXzJDPHzvYjKVaX4/IUkkRERCoINzcbXXTJrdQoJImIiFQg5+ZLUvP2lVJIEhERqUDy73DbdOAkuXnqS7oSCkkiIiIVSPOagQT6eJCenceOo6lWl+PSFJJEREQqEHc3G50bqC+pNCgkiYiIVDD5l9w2aFLJK6KQJCIiUsHkN29v2H+SPLthcTWuSyFJRESkgmlVO5Aq3h6kZubyZ4L6kkpKIUlERKSC8XB3o2P9qoCmArgSCkkiIiIV0LnFbtW8XVIKSSIiIhXQ+X1JdvUllYhCkoiISAXUpk4QPp5unMrIITbxtNXluCSFJBERkQrIy+NcX9IGXXIrEYUkERGRCir/kts6zZdUIgpJIiIiFVRkxNnm7X0nMQz1JV0uhSQREZEKql14MF4ebiSdzmJfUrrV5bgchSQREZEKysfTnfbhwYDmSyoJhSQREZEKLLKh2Zek+ZIun0KSiIhIBaa+pJJTSBIREanAOtSriqe7jYTUTA6dPGN1OS5FIUlERKQC8/Vyp23dYADW6ZLbZSlxSPr000/p3r07tWvX5uDBgwC89dZbfPPNN6VWnIiIiFy58y+5SfGVKCRNmzaNsWPHctNNN5GcnExeXh4AwcHBvPXWW6VZn4iIiFwhNW+XTIlC0rvvvsuHH37I+PHjcXd3d2zv1KkT27dvL7XiRERE5Mp1rF8Vdzcbh0+d4Uiy+pKKq0Qhaf/+/bRv377Qdm9vb9LTNVmViIiIM6ni7UHrOkEArN+n0aTiKlFIioiIYOvWrYW2f//997Rs2fJKaxIREZFSpr6ky+dRki968sknGTVqFJmZmRiGwYYNG4iOjmbKlCl89NFHpV2jiIiIXKHIiBBmrNzHhgMKScVVopA0YsQIcnNzeeqpp8jIyODuu++mTp06vP322wwaNKi0axQREZEr1KlBCDYb7E9KJzE1kxqBPlaX5PRKPAXAAw88wMGDB0lMTCQhIYFDhw5x3333lWZtIiIiUkqCfD1pWSsQgHX7NZpUHFc8mWRoaCg1atQo8ddPnTqViIgIfHx86NixI6tWrbrgvgsWLKBPnz5Ur16dwMBAoqKiWLJkSYF9rr32Wmw2W6HHzTff7Nhn4sSJhV6vWbNmid+DiIiIK4iMODsVgJq3i6VEl9sAvvzyS+bPn09cXBzZ2dkFXvv111+LdYyYmBjGjBnD1KlT6d69O9OnT6dfv3788ccf1KtXr9D+K1eupE+fPrz00ksEBwfz8ccf079/f9avX++4227BggUF6jlx4gTt2rXjrrvuKnCsVq1asWzZMsfz86cyEBERqYgiG4Yw63/7Wa+RpGIp0UjSO++8w4gRI6hRowZbtmyhS5cuVKtWjX379tGvX79iH+eNN97gvvvu4/7776dFixa89dZbhIeHM23atCL3f+utt3jqqafo3LkzTZo04aWXXqJJkyZ89913jn1CQkKoWbOm47F06VL8/PwKhSQPD48C+1WvXr0k3woRERGX0aWBeYfbnsTTJJ3Osrga51eikDR16lRmzJjBe++9h5eXF0899RRLly7lscceIyUlpVjHyM7OZvPmzfTt27fA9r59+7JmzZpiHcNut5OWlkZISMgF95k5cyaDBg3C39+/wPbY2Fhq165NREQEgwYNYt++fcU6p4iIiKuq6u9Fs7AAADZoNOmSShSS4uLi6NatGwC+vr6kpaUBMGTIEKKjo4t1jKSkJPLy8ggLCyuwPSwsjISEhGId4/XXXyc9PZ0BAwYU+fqGDRv4/fffuf/++wtsj4yMZM6cOSxZsoQPP/yQhIQEunXrxokTF75Gm5WVRWpqaoGHiIiIq4lsaA4sKCRdWolCUs2aNR2Bon79+qxbtw4wZ+I2DOOyjmWz2Qo8Nwyj0LaiREdHM3HiRGJiYi7YOD5z5kxat25Nly5dCmzv168fd9xxB23atKF3794sWrQIgE8++eSC55syZQpBQUGOR3h4+CVrFBERcTb5zdvr1Lx9SSUKSddff72jD+i+++7j8ccfp0+fPgwcOJDbbrutWMcIDQ3F3d290KhRYmJiodGlv4qJieG+++5j/vz59O7du8h9MjIymDdvXqFRpKL4+/vTpk0bYmNjL7jPM888Q0pKiuNx6NChSx5XRETE2XQ5O/P2rmNpJGdkX2Lvyq1Ed7fNmDEDu90OwMMPP0y1atVYtWoV/fv35x//+EexjuHl5UXHjh1ZunRpgWC1dOlSbrnllgt+XXR0NCNHjiQ6OrrAbf1/NX/+fLKysrj33nsvWUtWVhY7d+6kR48eF9zH29sbb2/vSx5LRETEmVUP8KZRdX/2Hk9nw/6T9G2lKXAupEQjSW5ubuTm5rJhwwb++9//4u3tTe/evWnQoAE//PBDsY8zduxYPvroI2bNmsXOnTt5/PHHiYuL4+GHHwbM0ZuhQ4c69o+Ojmbo0KG8/vrrdO3alYSEBBISEopsFp85cya33nor1apVK/TaE088wYoVK9i/fz/r16/nzjvvJDU1lWHDhpXguyEiIuJaIhuenS9JfUkXVaKRpB9++IEhQ4YU2ehss9nIy8sr1nEGDhzIiRMnmDRpEvHx8bRu3ZrFixdTv359AOLj44mLi3PsP336dHJzcxk1ahSjRo1ybB82bBizZ892PN+9ezerV6/mxx9/LPK8hw8fZvDgwSQlJVG9enW6du3KunXrHOcVERGpyCIjQpi7Po71+9WXdDE243I7rYHGjRtzww038Pzzz1+yf6iiSk1NJSgoiJSUFAIDA60uR0REpNgSUjLpOuUn3Gyw9d99CfTxtLqkcnM5n98lutyWmJjI2LFjK21AEhERcWU1g3yoX80PuwGbD5yyuhynVaKQdOedd7J8+fJSLkVERETKS+TZu9zW6ZLbBZWoJ+m9997jrrvuYtWqVbRp0wZPz4LDdI899lipFCciIiJlIzKiGvM3HWb9PjVvX0iJQtLcuXNZsmQJvr6+LF++vMDkjzabTSFJRETEyeXPvL39SArpWbn4e5d4zfsKq0TfkQkTJjBp0iTGjRuHm1uJrtiJiIiIhepW9aNOsC9Hks+w+eAprmmqhd7/qkQJJzs7m4EDByogiYiIuLD80SRNBVC0EqWcYcOGERMTU9q1iIiISDnKb95WX1LRSnS5LS8vj1dffZUlS5bQtm3bQo3bb7zxRqkUJyIiImUnf7HbbYeTyczJw8fT3eKKnEuJQtL27dtp3749AL///nuB185v4hYRERHnVb+aH2GB3hxLzeLXuFN0axRqdUlOpUQh6ZdffintOkRERKSc2Ww2IiOq8e22o6zfd1Ih6S/UeS0iIlKJqXn7whSSREREKrH8vqQtcclk5RZvgfrKQiFJRESkEmtU3Z/QKl5k5drZdijF6nKcikKSiIhIJWaz2ejimApAl9zOp5AkIiJSyeVfcttwQPMlnU8hSUREpJLLb97efPAUOXl2i6txHgpJIiIilVzTGgEE+3mSkZ3H9iPqS8qnkCQiIlLJubnZ6NJAS5T8lUKSiIiIENnQ7EvSfEnnKCSJiIiIY7HbTQdOkau+JEAhSURERIAWtQIJ8PHgdFYuf8SnWl2OU1BIEhEREdzdbHQ+25e0Yb/6kkAhSURERM7Kv+S2Ts3bgEKSiIiInJXfvL3xwEnsdsPiaqynkCQiIiIAtK4diL+XOylncvgzIc3qciynkCQiIiIAeLi70TF/viRNBaCQJCIiIudERmhSyXwKSSIiIuKQH5I2HDiJYVTuviSFJBEREXFoWzcYH083TqZnsyfxtNXlWEohSURERBy8PNzoUK8qAOsq+XxJCkkiIiJSQGTE2XXc9lXu5m2FJBERESkgsmH+HW6Vuy9JIUlEREQKuCo8GC8PN46nZbE/Kd3qciyjkCQiIiIF+Hi6c1V4MGCOJlVWCkkiIiJSyLn5kipvX5JCkoiIiBTiaN6uxH1JCkkiIiJSSIf6wXi42YhPyeTwqTNWl2MJhSQREREpxM/Lg7Z1gwBYV0kvuVkekqZOnUpERAQ+Pj507NiRVatWXXDfBQsW0KdPH6pXr05gYCBRUVEsWbKkwD6zZ8/GZrMVemRmZpb4vCIiIpVRZMNzl9wqI0tDUkxMDGPGjGH8+PFs2bKFHj160K9fP+Li4orcf+XKlfTp04fFixezefNmrrvuOvr378+WLVsK7BcYGEh8fHyBh4+PT4nPKyIiUhk5mrf3V86RJJthYTdWZGQkHTp0YNq0aY5tLVq04NZbb2XKlCnFOkarVq0YOHAgzz//PGCOJI0ZM4bk5OQyPW9qaipBQUGkpKQQGBhYrK8RERFxJaezcmk7cQl2A9aMu57awb5Wl3TFLufz27KRpOzsbDZv3kzfvn0LbO/bty9r1qwp1jHsdjtpaWmEhIQU2H769Gnq169P3bp1+dvf/lZgpKmk583KyiI1NbXAQ0REpCKr4u1B6zpmX1JlHE2yLCQlJSWRl5dHWFhYge1hYWEkJCQU6xivv/466enpDBgwwLGtefPmzJ49m2+//Zbo6Gh8fHzo3r07sbGxV3TeKVOmEBQU5HiEh4cX962KiIi4rPxLbhsqYV+S5Y3bNputwHPDMAptK0p0dDQTJ04kJiaGGjVqOLZ37dqVe++9l3bt2tGjRw/mz59P06ZNeffdd6/ovM888wwpKSmOx6FDh4rz9kRERFzaucVuK19I8rDqxKGhobi7uxcavUlMTCw0yvNXMTEx3HfffXzxxRf07t37ovu6ubnRuXNnx0hSSc/r7e2Nt7f3Rc8lIiJS0XSOCMFmg31J6SSmZlIj0OfSX1RBWDaS5OXlRceOHVm6dGmB7UuXLqVbt24X/Lro6GiGDx/O3Llzufnmmy95HsMw2Lp1K7Vq1bqi84qIiFRGQb6etKhpNjhXtqkALBtJAhg7dixDhgyhU6dOREVFMWPGDOLi4nj44YcB8xLXkSNHmDNnDmAGpKFDh/L222/TtWtXx2iQr68vQUFmY9kLL7xA165dadKkCampqbzzzjts3bqV999/v9jnFRERkXMiG4bwR3wq6/efoH+72laXU24sDUkDBw7kxIkTTJo0ifj4eFq3bs3ixYupX78+APHx8QXmLpo+fTq5ubmMGjWKUaNGObYPGzaM2bNnA5CcnMyDDz5IQkICQUFBtG/fnpUrV9KlS5din1dERETOiYyoxsf/O1Dp+pIsnSfJlWmeJBERqSxOpmfT4UWzTWXzhN5Uq+K6PbouMU+SiIiIuIYQfy+ahlUBYOOByjOapJAkIiIil5Q/FcC6SnTJTSFJRERELimyYf46bgpJIiIiIg5dzs68/WdCKikZORZXUz4UkkREROSSagT40LC6P4YBGypJX5JCkoiIiBTLuSVKKsditwpJIiIiUiz5i91Wlr4khSQREREplvzm7R1HU0jLrPh9SQpJIiIiUiy1gnypF+KH3YBNB09ZXU6ZU0gSERGRYnNccqsE8yUpJImIiEixRTY827y9v+I3byskiYiISLHljyRtP5xCRnauxdWULYUkERERKbbwED/qBPuSazfYXMH7khSSRERE5LJ0qSR9SQpJIiIiclnyL7ltqODzJSkkiYiIyGXJb97eeiiZzJw8i6spOwpJIiIiclkaVPOjRoA32Xl2tsQlW11OmVFIEhERkctis9kqxVQACkkiIiJy2SrDpJIKSSIiInLZup5dx+3XuFNk5VbMviSFJBEREblsjapXoZq/F1m5dn47nGJ1OWVCIUlEREQum81mc8yXVFGnAlBIEhERkRLJ70tat69iNm8rJImIiEiJ5N/htvngKXLy7BZXU/oUkkRERKREmoUFEOznSUZ2Hr8fqXh9SQpJIiIiUiJubjY6Nzg7FUAF7EtSSBIREZESOzdfUsXrS1JIEhERkRKLjDD7kjYdOEWe3bC4mtKlkCQiIiIl1rJ2IAHeHqRl5bIzPtXqckqVQpKIiIiUmLubjU4NqgIVbyoAhSQRERG5IucWu61YzdsKSSIiInJF8pu3Nx44ib0C9SUpJImIiMgVaV0nCD8vd5Izcth1LM3qckqNQpKIiIhcEU93NzrWN/uSKtJUAApJIiIicsUc8yVVoL4khSQRERG5YvnN2xv2n8QwKkZfkkKSiIiIXLG2dYPw9nDjRHo2e4+ftrqcUmF5SJo6dSoRERH4+PjQsWNHVq1adcF9FyxYQJ8+fahevTqBgYFERUWxZMmSAvt8+OGH9OjRg6pVq1K1alV69+7Nhg0bCuwzceJEbDZbgUfNmjXL5P2JiIhUBt4e7nSolz9fUsW45GZpSIqJiWHMmDGMHz+eLVu20KNHD/r160dcXFyR+69cuZI+ffqwePFiNm/ezHXXXUf//v3ZsmWLY5/ly5czePBgfvnlF9auXUu9evXo27cvR44cKXCsVq1aER8f73hs3769TN+riIhIRRfZsGL1JdkMCy8cRkZG0qFDB6ZNm+bY1qJFC2699VamTJlSrGO0atWKgQMH8vzzzxf5el5eHlWrVuW9995j6NChgDmS9PXXX7N169YS156amkpQUBApKSkEBgaW+DgiIiIVxdq9Jxj84TpqBHiz/tle2Gw2q0sq5HI+vy0bScrOzmbz5s307du3wPa+ffuyZs2aYh3DbreTlpZGSEjIBffJyMggJyen0D6xsbHUrl2biIgIBg0axL59+y7/TYiIiIhD+3rBeLm7kZiWxYETGVaXc8UsC0lJSUnk5eURFhZWYHtYWBgJCQnFOsbrr79Oeno6AwYMuOA+48aNo06dOvTu3duxLTIykjlz5rBkyRI+/PBDEhIS6NatGydOXHhuh6ysLFJTUws8RERE5BwfT3fahQcBFWO+JMsbt/86FGcYRrGG56Kjo5k4cSIxMTHUqFGjyH1effVVoqOjWbBgAT4+Po7t/fr144477qBNmzb07t2bRYsWAfDJJ59c8HxTpkwhKCjI8QgPDy/O2xMREalUIiPOTQXg6iwLSaGhobi7uxcaNUpMTCw0uvRXMTEx3HfffcyfP7/ACNH5XnvtNV566SV+/PFH2rZte9Hj+fv706ZNG2JjYy+4zzPPPENKSorjcejQoYseU0REpDKqSM3bloUkLy8vOnbsyNKlSwtsX7p0Kd26dbvg10VHRzN8+HDmzp3LzTffXOQ+//nPf3jxxRf54Ycf6NSp0yVrycrKYufOndSqVeuC+3h7exMYGFjgISIiIgV1rF8VDzcbR5LPcOika/clWXq5bezYsXz00UfMmjWLnTt38vjjjxMXF8fDDz8MmKM3+XekgRmQhg4dyuuvv07Xrl1JSEggISGBlJQUxz6vvvoqEyZMYNasWTRo0MCxz+nT5ya2euKJJ1ixYgX79+9n/fr13HnnnaSmpjJs2LDye/MiIiIVkJ+XB23qnu1LcvHRJEtD0sCBA3nrrbeYNGkSV111FStXrmTx4sXUr18fgPj4+AJzJk2fPp3c3FxGjRpFrVq1HI/Ro0c79pk6dSrZ2dnceeedBfZ57bXXHPscPnyYwYMH06xZM26//Xa8vLxYt26d47wiIiJScvl9Sa7evG3pPEmuTPMkiYiIFO2XPxMZMXsj9UL8WPnUdVaXU4BLzJMkIiIiFVOnBlVxs0HcyQziU85YXU6JKSSJiIhIqQrw8aRVbbMvyZWnAlBIEhERkVIXGWFOBeDKi90qJImIiEipi2x4tnl7v+s2byskiYiISKnr0iAEmw32HU8nMS3T6nJKRCFJRERESl2QnyfNa5p3j7lqX5JCkoiIiJSJ/L6k9S7al6SQJCIiImXCEZJctC9JIUlERETKRJezIWn3sdOcTM+2uJrLp5AkIiIiZaJaFW+a1KgCuGZfkkKSiIiIlJnIhq57yU0hSURERMrMucVuNZIkIiIi4pDfvL0zIZWUjByLq7k8CkkiIiJSZmoE+hAR6o9hwMYDrjWapJAkIiIiZcpVpwJQSBIREZEyld+87Wp3uCkkiYiISJnKb97+/Wgqp7NyLa6m+BSSREREpEzVDvYlPMSXPLvBJhfqS1JIEhERkTLnmArAhS65KSSJiIhImTu32K3rNG8rJImIiEiZyx9J+u1wChnZrtGXpJAkIiIiZS48xJdaQT7k2g1+PZhsdTnFopAkIiIiZc5mszkuuW1wkfmSFJJERESkXEQ2NC+5rXOR5m2FJBERESkX+SNJWw8lk5mTZ3E1l6aQJCIiIuUiItSf6gHeZOfa2Xoo2epyLkkhSURERMrF+X1J6/c5/yU3hSQREREpN6602K1CkoiIiJSb/ObtX+NOkZ1rt7iai1NIEhERkXLTpEYVQvy9yMyxs/1IstXlXJRCkoiIiJQbm81GlwbmJbd1Tt6XpJAkIiIi5SqyYX5fkkKSiIiIiEP+Om6bD5wkN895+5IUkkRERKRcNa8ZQKCPB+nZefx+NNXqci5IIUlERETKlZubjS6O+ZKcdyoAhSQREREpd/mX3Jy5L0khSURERMpdfvP2xgMnybMbFldTNIUkERERKXctawVSxduDtMxcdsY7Z1+S5SFp6tSpRERE4OPjQ8eOHVm1atUF912wYAF9+vShevXqBAYGEhUVxZIlSwrt99VXX9GyZUu8vb1p2bIlCxcuvKLzioiISOnycHejU4OqgPNecrM0JMXExDBmzBjGjx/Pli1b6NGjB/369SMuLq7I/VeuXEmfPn1YvHgxmzdv5rrrrqN///5s2bLFsc/atWsZOHAgQ4YMYdu2bQwZMoQBAwawfv36Ep9XRERESp+jL8lJm7dthmFYdiEwMjKSDh06MG3aNMe2Fi1acOuttzJlypRiHaNVq1YMHDiQ559/HoCBAweSmprK999/79jnxhtvpGrVqkRHR5faeVNTUwkKCiIlJYXAwMBifY2IiIic82vcKW6fuoZgP09+ndAHNzdbmZ/zcj6/LRtJys7OZvPmzfTt27fA9r59+7JmzZpiHcNut5OWlkZISIhj29q1awsd84YbbnAcs6TnzcrKIjU1tcBDRERESq5NnSB8Pd1Jzshhd2Ka1eUUYllISkpKIi8vj7CwsALbw8LCSEhIKNYxXn/9ddLT0xkwYIBjW0JCwkWPWdLzTpkyhaCgIMcjPDy8WDWKiIhI0Tzd3ehY/2xfkhOu42Z547bNVnBozTCMQtuKEh0dzcSJE4mJiaFGjRqXfczLPe8zzzxDSkqK43Ho0KFL1igiIiIXF3l2UskNTti87WHViUNDQ3F3dy80epOYmFholOevYmJiuO+++/jiiy/o3bt3gddq1qx50WOW9Lze3t54e3tf8n2JiIhI8UU2zJ9U8kSxB0rKi2UjSV5eXnTs2JGlS5cW2L506VK6det2wa+Ljo5m+PDhzJ07l5tvvrnQ61FRUYWO+eOPPzqOWdLzioiISOlrFx6Et4cbSaez2Xs83epyCrBsJAlg7NixDBkyhE6dOhEVFcWMGTOIi4vj4YcfBsxLXEeOHGHOnDmAGZCGDh3K22+/TdeuXR2jQb6+vgQFBQEwevRorrnmGl555RVuueUWvvnmG5YtW8bq1auLfV4REREpH94e7rSvF8y6fSdZv/8EjWtUsbokB0tD0sCBAzlx4gSTJk0iPj6e1q1bs3jxYurXrw9AfHx8gbmLpk+fTm5uLqNGjWLUqFGO7cOGDWP27NkAdOvWjXnz5jFhwgSee+45GjVqRExMDJGRkcU+r4iIiJSfyIhqZkjad5J7Ip3ns9jSeZJcmeZJEhERKR1r9iRx90frCQv0Zt0zvcq0L8kl5kkSERERAWhfryqe7jaOpWZx8ESG1eU4KCSJiIiIpXy93GlXNxhwrqkAFJJERETEcpENzfmS1u13nnXcFJJERETEcucWu9VIkoiIiIhDx/pVcXezcST5DIdPOUdfkkKSiIiIWM7f24M2dcw5D51lNEkhSURERJxC/jpu652kL0khSURERJxCfvP2eie5w00hSURERJxCpwYhuNng4IkMElIyrS5HIUlEREScQ6CPJy1rm7NgO8MlN4UkERERcRqOqQCc4JKbQpKIiIg4DUfz9j6NJImIiIg4dDkbkvYeT+d4WpaltSgkiYiIiNMI9vOiec0AwPp13BSSRERExKk4y3xJCkkiIiLiVCIbVsPDzcbprFxL67AZhmFYWoGLSk1NJSgoiJSUFAIDA60uR0REpMLIzMnDbhj4eXmU+rEv5/O79M8uIiIicgV8PN2tLgHQ5TYRERGRIikkiYiIiBRBIUlERESkCApJIiIiIkVQSBIREREpgkKSiIiISBEUkkRERESKoJAkIiIiUgSFJBEREZEiKCSJiIiIFEEhSURERKQICkkiIiIiRVBIEhERESmCh9UFuCrDMABITU21uBIREREprvzP7fzP8YtRSCqhtLQ0AMLDwy2uRERERC5XWloaQUFBF93HZhQnSkkhdrudo0ePEhAQgM1mK9Vjp6amEh4ezqFDhwgMDCzVYzsDvT/XV9HfY0V/f1Dx36Pen+srq/doGAZpaWnUrl0bN7eLdx1pJKmE3NzcqFu3bpmeIzAwsML+5Qe9v4qgor/Hiv7+oOK/R70/11cW7/FSI0j51LgtIiIiUgSFJBEREZEiKCQ5IW9vb/7973/j7e1tdSllQu/P9VX091jR3x9U/Peo9+f6nOE9qnFbREREpAgaSRIREREpgkKSiIiISBEUkkRERESKoJAkIiIiUgSFJCeycuVK+vfvT+3atbHZbHz99ddWl1SqpkyZQufOnQkICKBGjRrceuut7Nq1y+qySs20adNo27atY+KzqKgovv/+e6vLKjNTpkzBZrMxZswYq0spNRMnTsRmsxV41KxZ0+qyStWRI0e49957qVatGn5+flx11VVs3rzZ6rJKTYMGDQr9DG02G6NGjbK6tFKRm5vLhAkTiIiIwNfXl4YNGzJp0iTsdrvVpZWatLQ0xowZQ/369fH19aVbt25s3LjRklo047YTSU9Pp127dowYMYI77rjD6nJK3YoVKxg1ahSdO3cmNzeX8ePH07dvX/744w/8/f2tLu+K1a1bl5dffpnGjRsD8Mknn3DLLbewZcsWWrVqZXF1pWvjxo3MmDGDtm3bWl1KqWvVqhXLli1zPHd3d7ewmtJ16tQpunfvznXXXcf3339PjRo12Lt3L8HBwVaXVmo2btxIXl6e4/nvv/9Onz59uOuuuyysqvS88sorfPDBB3zyySe0atWKTZs2MWLECIKCghg9erTV5ZWK+++/n99//51PP/2U2rVr89lnn9G7d2/++OMP6tSpU77FGOKUAGPhwoVWl1GmEhMTDcBYsWKF1aWUmapVqxofffSR1WWUqrS0NKNJkybG0qVLjZ49exqjR4+2uqRS8+9//9to166d1WWUmaefftq4+uqrrS6jXI0ePdpo1KiRYbfbrS6lVNx8883GyJEjC2y7/fbbjXvvvdeiikpXRkaG4e7ubvz3v/8tsL1du3bG+PHjy70eXW4Ty6SkpAAQEhJicSWlLy8vj3nz5pGenk5UVJTV5ZSqUaNGcfPNN9O7d2+rSykTsbGx1K5dm4iICAYNGsS+ffusLqnUfPvtt3Tq1Im77rqLGjVq0L59ez788EOryyoz2dnZfPbZZ4wcObLUFyK3ytVXX81PP/3E7t27Adi2bRurV6/mpptusriy0pGbm0teXh4+Pj4Ftvv6+rJ69epyr0eX28QShmEwduxYrr76alq3bm11OaVm+/btREVFkZmZSZUqVVi4cCEtW7a0uqxSM2/ePH799VfL+gPKWmRkJHPmzKFp06YcO3aMyZMn061bN3bs2EG1atWsLu+K7du3j2nTpjF27FieffZZNmzYwGOPPYa3tzdDhw61urxS9/XXX5OcnMzw4cOtLqXUPP3006SkpNC8eXPc3d3Jy8vj//7v/xg8eLDVpZWKgIAAoqKiePHFF2nRogVhYWFER0ezfv16mjRpUv4FlfvYlRQLFfxy2z//+U+jfv36xqFDh6wupVRlZWUZsbGxxsaNG41x48YZoaGhxo4dO6wuq1TExcUZNWrUMLZu3erYVtEut/3V6dOnjbCwMOP111+3upRS4enpaURFRRXY9uijjxpdu3a1qKKy1bdvX+Nvf/ub1WWUqujoaKNu3bpGdHS08dtvvxlz5swxQkJCjNmzZ1tdWqnZs2ePcc011xiA4e7ubnTu3Nm45557jBYtWpR7LRpJknL36KOP8u2337Jy5Urq1q1rdTmlysvLy9G43alTJzZu3Mjbb7/N9OnTLa7sym3evJnExEQ6duzo2JaXl8fKlSt57733yMrKqlBNzgD+/v60adOG2NhYq0spFbVq1So0stmiRQu++uoriyoqOwcPHmTZsmUsWLDA6lJK1ZNPPsm4ceMYNGgQAG3atOHgwYNMmTKFYcOGWVxd6WjUqBErVqwgPT2d1NRUatWqxcCBA4mIiCj3WhSSpNwYhsGjjz7KwoULWb58uSV/4cubYRhkZWVZXUap6NWrF9u3by+wbcSIETRv3pynn366wgUkgKysLHbu3EmPHj2sLqVUdO/evdC0G7t376Z+/foWVVR2Pv74Y2rUqMHNN99sdSmlKiMjAze3gu3E7u7uFWoKgHz+/v74+/tz6tQplixZwquvvlruNSgkOZHTp0+zZ88ex/P9+/ezdetWQkJCqFevnoWVlY5Ro0Yxd+5cvvnmGwICAkhISAAgKCgIX19fi6u7cs8++yz9+vUjPDyctLQ05s2bx/Lly/nhhx+sLq1UBAQEFOof8/f3p1q1ahWmr+yJJ56gf//+1KtXj8TERCZPnkxqamqF+Q398ccfp1u3brz00ksMGDCADRs2MGPGDGbMmGF1aaXKbrfz8ccfM2zYMDw8KtbHXP/+/fm///s/6tWrR6tWrdiyZQtvvPEGI0eOtLq0UrNkyRIMw6BZs2bs2bOHJ598kmbNmjFixIjyL6bcL/DJBf3yyy8GUOgxbNgwq0srFUW9N8D4+OOPrS6tVIwcOdKoX7++4eXlZVSvXt3o1auX8eOPP1pdVpmqaD1JAwcONGrVqmV4enoatWvXNm6//fYK01OW77vvvjNat25teHt7G82bNzdmzJhhdUmlbsmSJQZg7Nq1y+pSSl1qaqoxevRoo169eoaPj4/RsGFDY/z48UZWVpbVpZWamJgYo2HDhoaXl5dRs2ZNY9SoUUZycrIltdgMwzDKP5qJiIiIODfNkyQiIiJSBIUkERERkSIoJImIiIgUQSFJREREpAgKSSIiIiJFUEgSERERKYJCkoiIiEgRFJJERErJ8uXLsdlsJCcnW12KiJQChSQRERGRIigkiYiIiBRBIUlEKgzDMHj11Vdp2LAhvr6+tGvXji+//BI4dyls0aJFtGvXDh8fHyIjI9m+fXuBY3z11Ve0atUKb29vGjRowOuvv17g9aysLJ566inCw8Px9vamSZMmzJw5s8A+mzdvplOnTvj5+dGtWzd27dpVtm9cRMqEQpKIVBgTJkzg448/Ztq0aezYsYPHH3+ce++9lxUrVjj2efLJJ3nttdfYuHEjNWrU4O9//zs5OTmAGW4GDBjAoEGD2L59OxMnTuS5555j9uzZjq8fOnQo8+bN45133mHnzp188MEHVKlSpUAd48eP5/XXX2fTpk14eHhUqBXaRSoTLXArIhVCeno6oaGh/Pzzz0RFRTm233///WRkZPDggw9y3XXXMW/ePAYOHAjAyZMnqVu3LrNnz2bAgAHcc889HD9+nB9//NHx9U899RSLFi1ix44d7N69m2bNmrF06VJ69+5dqIbly5dz3XXXsWzZMnr16gXA4sWLufnmmzlz5gw+Pj5l/F0QkdKkkSQRqRD++OMPMjMz6dOnD1WqVHE85syZw969ex37nR+gQkJCaNasGTt37gRg586ddO/evcBxu3fvTmxsLHl5eWzduhV3d3d69ux50Vratm3r+HOtWrUASExMvOL3KCLly8PqAkRESoPdbgdg0aJF1KlTp8Br3t7eBYLSX9lsNsDsacr/c77zB9t9fX2LVYunp2ehY+fXJyKuQyNJIlIhtGzZEm9vb+Li4mjcuHGBR3h4uGO/devWOf586tQpdu/eTfPmzR3HWL16dYHjrlmzhqZNm+Lu7k6bNm2w2+0FepxEpOLSSJKIVAgBAQE88cQTPP7449jtdq6++mpSU1NZs2YNVapUoX79+gBMmjSJatWqERYWxvjx4wkNDeXWW28F4F//+hedO3fmxRdfZODAgaxdu5b33nuPqVOnAtCgQQOGDRvGyJEjeeedd2jXrh0HDx4kMTGRAQMGWPXWRaSMKCSJSIXx4osvUqNGDaZMmcK+ffsIDg6mQ4cOPPvss47LXS+//DKjR48mNjaWdu3a8e233+Ll5QVAhw4dmD9/Ps8//zwvvvgitWrVYtKkSQwfPtxxjmnTpvHss8/yz3/+kxMnTlCvXj2effZZK96uiJQx3d0mIpVC/p1np06dIjg42OpyRMQFqCdJREREpAgKSSIiIiJF0OU2ERERkSJoJElERESkCApJIiIiIkVQSBIREREpgkKSiIiISBEUkkRERESKoJAkIiIiUgSFJBEREZEiKCSJiIiIFEEhSURERKQI/w8FBAp/b5W34wAAAABJRU5ErkJggg==",
      "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": 28,
   "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": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HeterSUMGraph(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 30,
     "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": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test[\"doc_splitted\"] = split_all_docs(df_test[\"docs\"], False)\n",
    "test_set = df_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "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": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model:   0%|          | 0/100 [00:00<?, ?batch/s, accuracy=0.776, loss=0.613, rouge1=0.403, rouge2=0.197, rougeL=0.247]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:02<00:00, 35.90batch/s, accuracy=0.765, loss=0.519, rouge1=0.338, rouge2=0.121, rougeL=0.221]\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": 34,
   "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": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:01<00:00, 92.10batch/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": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:01<00:00, 57.26batch/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": 38,
   "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",
    "del train_loader\n",
    "import sys\n",
    "sys.exit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}