07-train_SIMPLE_CNN_RNN_without_position_Glove300.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train SIMPLE_CNN_RNN_without_position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a8a5bd39",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.utils import clip_grad_norm_\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils.GloveMgr import GloveMgr\n",
    "from utils.Dataset import Dataset\n",
    "from utils.DataLoader import DataLoader\n",
    "from utils.preprocess_df import preprocess_df\n",
    "from utils.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn\n",
    "from utils.split_all_docs import split_all_docs\n",
    "\n",
    "\n",
    "from time import time\n",
    "\n",
    "import json\n",
    "import argparse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "818410ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_notebook() -> bool:\n",
    "    try:\n",
    "        shell = get_ipython().__class__.__name__\n",
    "        if shell == 'ZMQInteractiveShell':\n",
    "            return True   # Jupyter notebook or qtconsole\n",
    "        elif shell == 'TerminalInteractiveShell':\n",
    "            return False  # Terminal running IPython\n",
    "        else:\n",
    "            return False  # Other type (?)\n",
    "    except NameError:\n",
    "        return False      # Probably standard Python interpreter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "690fa032",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "pd.set_option('display.max_rows', None)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b2636e0b",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6e7aad39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse args if script mode\n",
    "parser = argparse.ArgumentParser(description='extractive summary')\n",
    "\n",
    "parser.add_argument('-is_graphic',type=int,default=1,choices=[0,1])\n",
    "parser.add_argument('-gpu_num',type=int,default=5)\n",
    "parser.add_argument('-batch_size',type=int,default=8)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "parser.add_argument('-dataset',type=str,default=\"./data/nyt_corpus_LDC2008T19_50\")\n",
    "parser.add_argument('-doc_col_name',type=str,default=\"docs\")\n",
    "parser.add_argument('-label_col_name',type=str,default=\"labels\")\n",
    "parser.add_argument('-sum_col_name',type=str,default=\"summaries\")\n",
    "parser.add_argument('-max_doc_len',type=int,default=50)\n",
    "\n",
    "args = None\n",
    "\n",
    "if is_notebook():\n",
    "    args = parser.parse_args(\"\")\n",
    "else:\n",
    "    args = parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "824eacf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 5\n",
      "epochs 100\n",
      "batch_size 8\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 = 1e-3\n",
    "early_stopping = 3\n",
    "model_name = \"07-train_SIMPLE_CNN_RNN_without_position_Glove300\"\n",
    "sub_folder_name = \"model_name__{}__time__{}__embed_name__{}__lr__{}__batch_size__{}__vocab_size__{}__cuda_num__{}\".format(model_name, time(), embed_name, learning_rate, batch_size, vocab_size, cuda_num)\n",
    "checkpoints_folder = \"./checkpoints/\" + sub_folder_name\n",
    "average_number_of_sentences_per_document = 3\n",
    "\n",
    "# print\n",
    "print(\"parse:\")\n",
    "print(\"is_graphic:\", is_graphic)\n",
    "print(\"cuda_num:\", cuda_num)\n",
    "print(\"epochs\", epochs)\n",
    "print(\"batch_size\", batch_size)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c8ddd4d5",
   "metadata": {},
   "source": [
    "## PyTorch initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d09bc3ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of available GPUs: 6\n",
      "GPU 0: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 1: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 2: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 3: NVIDIA GeForce GTX 1080\n",
      "GPU 4: NVIDIA GeForce GTX 1080\n",
      "GPU 5: NVIDIA GeForce GTX 1080\n"
     ]
    }
   ],
   "source": [
    "# Check if a GPU is available\n",
    "if torch.cuda.is_available():\n",
    "    # Display the number of available GPUs\n",
    "    print(f\"Number of available GPUs: {torch.cuda.device_count()}\")\n",
    "    # Display the name of each GPU\n",
    "    for i in range(torch.cuda.device_count()):\n",
    "        print(f\"GPU {i}: {torch.cuda.get_device_name(i)}\")\n",
    "else:\n",
    "    print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b0c5786e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=5)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3393fe4e",
   "metadata": {},
   "source": [
    "## Chargement des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "97644745",
   "metadata": {},
   "outputs": [],
   "source": [
    "glovemgr = GloveMgr(\"./data/glove.6B/glove.6B.300d.txt\", vocab_size=vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fe745c8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_json(args.dataset + \"/train.json\")\n",
    "train_dataset = Dataset(preprocess_df(df_train, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "train_iter = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f8b39f3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val = pd.read_json(args.dataset + \"/val.json\")\n",
    "val_dataset = Dataset(preprocess_df(df_val, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "val_iter = DataLoader(dataset=val_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0f086978",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(args.dataset + \"/test.json\")\n",
    "test_dataset = Dataset(preprocess_df(df_test, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "test_iter = DataLoader(dataset=test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fc41eb07",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9683721f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from models.BasicModel import BasicModel\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "\n",
    "class SIMPLE_CNN_RNN(BasicModel):\n",
    "    def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 100):\n",
    "        super(SIMPLE_CNN_RNN, self).__init__(device)\n",
    "\n",
    "        self.device = device\n",
    "\n",
    "        self.word_embedding = nn.Embedding(vocab_size+2, dim_word_embed, padding_idx=0)\n",
    "        # Load word embedding if specified\n",
    "        if word_embed is not None:\n",
    "            self.word_embedding = torch.nn.Embedding.from_pretrained(torch.from_numpy(word_embed).float())\n",
    "\n",
    "        # 100 : word2vec embedding size\n",
    "        self.word_convs = nn.Sequential(\n",
    "                            nn.Conv1d(in_channels=dim_word_embed,out_channels=100,kernel_size=4,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True))\n",
    "        self.sent_GRU = nn.GRU(input_size = 100, hidden_size=200, batch_first = True, bidirectional = True)\n",
    "\n",
    "        self.Wdoc = nn.Linear(2*200,2*200,bias=True)\n",
    "\n",
    "        self.Wcontent = nn.Linear(2*200,1,bias=False)\n",
    "        self.Wsalience = nn.Bilinear(2*200,2*200,1,bias=False)\n",
    "        self.Wnovelty = nn.Bilinear(2*200,2*200,1,bias=False)\n",
    "        self.bias = nn.Parameter(torch.empty(1).uniform_(-0.1, 0.1))\n",
    "\n",
    "    def avg_pool1d(self,x,seq_lens):\n",
    "        out = []\n",
    "        for index,t in enumerate(x):\n",
    "            if seq_lens[index] == 0:\n",
    "                t = t[:1]\n",
    "            else:\n",
    "                t = t[:seq_lens[index],:]\n",
    "            t = torch.t(t).unsqueeze(0)\n",
    "            out.append(torch.avg_pool1d(t,t.size(2)))\n",
    "        \n",
    "        out = torch.cat(out).squeeze(2)\n",
    "        return out\n",
    "\n",
    "    def forward(self, arr_x, doc_lens):\n",
    "        probs = []\n",
    "\n",
    "        max_doc_lens = max(doc_lens)\n",
    "        #sent_lens = torch.sum(torch.sign(arr_x),dim=1).data\n",
    "\n",
    "        arr_x = self.word_embedding(arr_x)\n",
    "        arr_x = self.word_convs(arr_x.permute(0,2,1))\n",
    "        arr_x = torch.avg_pool1d(arr_x, arr_x.size(2)).squeeze(2)\n",
    "\n",
    "        arr_x = self.pad_doc(arr_x, doc_lens)\n",
    "\n",
    "        arr_x = self.sent_GRU(arr_x)[0]\n",
    "        sents_all_docs = arr_x.reshape(len(doc_lens) * max_doc_lens, 2*200) # flat docs\n",
    "        \n",
    "        docs = self.avg_pool1d(arr_x, doc_lens)\n",
    "        docs = torch.tanh(self.Wdoc(docs))\n",
    "        docs_for_each_sent = docs.repeat_interleave(max_doc_lens, dim=0) # repeat doc n times\n",
    "        \n",
    "        contents = self.Wcontent(sents_all_docs)\n",
    "        saliences = self.Wsalience(sents_all_docs, docs_for_each_sent)\n",
    "\n",
    "        # doc_len (number) s\n",
    "        ses = torch.zeros(len(doc_lens), 2*200)\n",
    "        ses = ses.to(self.device)\n",
    "\n",
    "        # for each document, compute probabilities\n",
    "        for position in range(max_doc_lens):\n",
    "            contents_for_position = contents[position::max_doc_lens]\n",
    "            saliences_for_position = saliences[position::max_doc_lens]\n",
    "            novelties_for_position = -1 * self.Wnovelty(sents_all_docs[position::max_doc_lens], torch.tanh(ses))\n",
    "            prob = contents_for_position + saliences_for_position + novelties_for_position + self.bias\n",
    "            prob = torch.sigmoid(prob)\n",
    "            probs.append(prob)\n",
    "\n",
    "            ses = ses + torch.mul(sents_all_docs[position::max_doc_lens], prob)\n",
    "        probs = torch.cat(probs).squeeze()\n",
    "        if len(probs.shape) == 0:\n",
    "            probs = probs.unsqueeze(0)\n",
    "        probs_filtered = []\n",
    "        for idx, doc_len in enumerate(doc_lens):\n",
    "            prob = probs[idx::len(doc_lens)]\n",
    "            prob = prob[:doc_len]\n",
    "            probs_filtered.append(prob)\n",
    "        probs_filtered = torch.cat(probs_filtered).squeeze()\n",
    "        if len(probs_filtered.shape) == 0:\n",
    "            probs_filtered = probs_filtered.unsqueeze(0)\n",
    "        #probs = probs.to(self.device)\n",
    "        return probs_filtered\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "380f8ba1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SIMPLE_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2ae1a236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SIMPLE_CNN_RNN(\n",
       "  (word_embedding): Embedding(150002, 300)\n",
       "  (word_convs): Sequential(\n",
       "    (0): Conv1d(300, 100, kernel_size=(4,), stride=(1,), padding=same)\n",
       "    (1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "  )\n",
       "  (sent_GRU): GRU(100, 200, batch_first=True, bidirectional=True)\n",
       "  (Wdoc): Linear(in_features=400, out_features=400, bias=True)\n",
       "  (Wcontent): Linear(in_features=400, out_features=1, bias=False)\n",
       "  (Wsalience): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       "  (Wnovelty): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4bc411ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.BCELoss()\n",
    "optimizer = torch.optim.Adamax(model.parameters(),lr=learning_rate)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.5)\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1852182a",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c6618af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[args.doc_col_name], is_sep_n = False)\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0991d3c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/13 [00:00<?, ?batch/s]/home/raoufdine/.local/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 13/13 [00:01<00:00,  8.48batch/s, accuracy=0.8, loss=0.48, mae=0.27]    \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.620, val mae = 0.460, val accuracy = 0.858, r1 = 0.506, r2 = 0.305, rL = 0.394\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 13/13 [00:00<00:00, 13.38batch/s, accuracy=0.828, loss=0.336, mae=0.206]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.498, val mae = 0.375, val accuracy = 0.861, r1 = 0.513, r2 = 0.315, rL = 0.402\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 13/13 [00:00<00:00, 13.80batch/s, accuracy=0.834, loss=0.317, mae=0.197]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.351, val mae = 0.248, val accuracy = 0.865, r1 = 0.514, r2 = 0.313, rL = 0.395\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 13/13 [00:00<00:00, 13.87batch/s, accuracy=0.843, loss=0.315, mae=0.19] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.353, val mae = 0.238, val accuracy = 0.865, r1 = 0.519, r2 = 0.319, rL = 0.403\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 13/13 [00:00<00:00, 13.03batch/s, accuracy=0.844, loss=0.304, mae=0.198]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.344, val mae = 0.224, val accuracy = 0.865, r1 = 0.518, r2 = 0.318, rL = 0.402\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 13/13 [00:00<00:00, 13.80batch/s, accuracy=0.842, loss=0.305, mae=0.197]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.337, val mae = 0.213, val accuracy = 0.865, r1 = 0.517, r2 = 0.316, rL = 0.400\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 13/13 [00:00<00:00, 14.05batch/s, accuracy=0.846, loss=0.297, mae=0.19] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.332, val mae = 0.206, val accuracy = 0.866, r1 = 0.517, r2 = 0.316, rL = 0.399\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 13/13 [00:00<00:00, 13.64batch/s, accuracy=0.849, loss=0.301, mae=0.191]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.334, val mae = 0.209, val accuracy = 0.865, r1 = 0.517, r2 = 0.315, rL = 0.399\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 13/13 [00:00<00:00, 13.71batch/s, accuracy=0.85, loss=0.298, mae=0.191] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.333, val mae = 0.207, val accuracy = 0.865, r1 = 0.517, r2 = 0.315, rL = 0.399\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 13/13 [00:00<00:00, 13.65batch/s, accuracy=0.849, loss=0.293, mae=0.188]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.334, val mae = 0.208, val accuracy = 0.865, r1 = 0.517, r2 = 0.315, rL = 0.399\n",
      "Training duration = 34.013564586639404\n"
     ]
    }
   ],
   "source": [
    "arr_train_loss = []\n",
    "arr_train_mae = []\n",
    "arr_train_acc = []\n",
    "arr_val_loss = []\n",
    "arr_val_mae = []\n",
    "arr_val_acc = []\n",
    "\n",
    "t1 = time()\n",
    "for epoch in range(1, epochs+1):\n",
    "    # train 1 epoch\n",
    "    model.train()\n",
    "    nb_batch_train = 0\n",
    "    total_train_loss = 0\n",
    "    total_train_mae = 0\n",
    "    total_train_acc = 0\n",
    "    with tqdm(train_iter, unit=\"batch\", total=len(train_iter)) as tepoch:\n",
    "        for batch in tepoch:\n",
    "            tepoch.set_description(f\"Epoch {epoch}\")\n",
    "            features = []\n",
    "            doc_lens = []\n",
    "\n",
    "            for j in range(batch_size):\n",
    "                doc_lens.append(len(batch[j][\"docs\"]))\n",
    "                features = features + batch[j][\"docs\"]\n",
    "            \n",
    "            features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "            targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(batch_size)]\n",
    "            targets = torch.cat(targets)\n",
    "            targets = targets.to(device)\n",
    "            \n",
    "            probs = model(features, doc_lens)\n",
    "            \n",
    "            loss = loss_fn(probs, targets)\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            clip_grad_norm_(model.parameters(), 1.0)\n",
    "            optimizer.step()\n",
    "            nb_batch_train += 1\n",
    "            total_train_loss += loss.item()\n",
    "            total_train_mae += mae_fn(probs, targets).item()\n",
    "            total_train_acc += accuracy_prop_sent_per_doc_fn(probs=probs.cpu().detach().numpy(), targets=targets.cpu().detach().numpy(), doc_lens=doc_lens)\n",
    "            tepoch.set_postfix(loss=total_train_loss/nb_batch_train, mae=total_train_mae/nb_batch_train, accuracy=total_train_acc/nb_batch_train)\n",
    "\n",
    "    # Save model\n",
    "    model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "    # Show train and val score\n",
    "    model.eval()\n",
    "    nb_batch_val = 0\n",
    "    total_val_loss = 0\n",
    "    total_val_mae = 0\n",
    "    total_val_acc = 0\n",
    "\n",
    "    total_r1 = 0\n",
    "    total_r2 = 0\n",
    "    total_rl = 0\n",
    "\n",
    "    for i, batch in enumerate(val_iter):\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "            \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "        \n",
    "        y_pred = model(features, doc_lens)\n",
    "\n",
    "        loss = loss_fn(y_pred, targets)\n",
    "\n",
    "        nb_batch_val += 1\n",
    "        total_val_loss += loss.item()\n",
    "\n",
    "        doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "        summaries = val_set[args.sum_col_name].iloc[i]\n",
    "\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[j]]\n",
    "            y_pred_thresh.append(indices[j])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in y_pred_thresh:\n",
    "            txt = txt + \". \" + doc[j]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        total_r1 += scores[\"rouge1\"].fmeasure\n",
    "        total_r2 += scores[\"rouge2\"].fmeasure\n",
    "        total_rl += scores[\"rougeL\"].fmeasure\n",
    "\n",
    "        probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        total_val_mae += mae_fn(probs_tensor, targets).item()\n",
    "        total_val_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "    arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "    arr_train_mae.append(total_train_mae / nb_batch_train)\n",
    "    arr_train_acc.append(total_train_acc / nb_batch_train)\n",
    "\n",
    "    arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "    arr_val_mae.append(total_val_mae / nb_batch_val)\n",
    "    arr_val_acc.append(total_val_acc / nb_batch_val)\n",
    "    \n",
    "    print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "\n",
    "    if len(arr_val_loss) >= early_stopping+1:\n",
    "        if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "            break\n",
    "\n",
    "    # update lr\n",
    "    scheduler.step()\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2f39ceed",
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_mae\"]  = arr_train_mae\n",
    "training_metrics[\"train_acc\"]  = arr_train_acc\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_mae\"]    = arr_val_mae\n",
    "training_metrics[\"val_acc\"]    = arr_val_acc\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "    json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8cd8fbee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHHCAYAAABXx+fLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAA9hAAAPYQGoP6dpAABWaklEQVR4nO3deXxU9b3/8dcsmZnsCyEbBAIE2SGySEFatURBAaGb2KooverjWm1VXK7oFatYU73VH9crFaW1aO1C64JUlKpRqFJkFUEI+xaEbEASkpBtZn5/TDLJkARDtpOZeT8fj/OYkzNnznwOqHn73Y7J7Xa7EREREQkiZqMLEBEREelqCkAiIiISdBSAREREJOgoAImIiEjQUQASERGRoKMAJCIiIkFHAUhERESCjgKQiIiIBB0FIBEREQk6CkAiIiISdBSARMSvLFu2DJPJxObNm40uRUT8mAKQiIiIBB0FIBEREQk6CkAiEnC++OILrr76aqKiooiIiGDy5Ml8/vnnPufU1NTw+OOPM3DgQBwOBz169GDSpEl8+OGH3nPy8vKYO3cuvXv3xm63k5yczMyZMzl8+HAX35GIdDSr0QWIiHSknTt38u1vf5uoqCgefPBBQkJCeOmll7j88stZu3Yt48ePB+CXv/wlWVlZ3HrrrVxyySWUlpayefNmtm7dypVXXgnAD37wA3bu3MnPf/5z0tLSKCgo4MMPP+To0aOkpaUZeJci0l4mt9vtNroIEZHWWrZsGXPnzmXTpk2MHTu2yfvf+973eO+998jJyaF///4AnDhxgkGDBnHxxRezdu1aADIyMujduzfvvvtus99TXFxMbGws//M//8P999/feTckIoZQF5iIBAyn08kHH3zArFmzvOEHIDk5mZ/85Cd89tlnlJaWAhATE8POnTvZt29fs9cKDQ3FZrOxZs0aTp8+3SX1i0jXUQASkYBRWFhIRUUFgwYNavLekCFDcLlc5ObmAvDEE09QXFzMRRddxIgRI3jggQfYvn2793y73c7TTz/N+++/T2JiIt/5znd45plnyMvL67L7EZHOowAkIkHpO9/5DgcOHOCVV15h+PDh/O53v2P06NH87ne/855zzz33sHfvXrKysnA4HDz66KMMGTKEL774wsDKRaQjKACJSMDo2bMnYWFh7Nmzp8l7u3fvxmw2k5qa6j0WFxfH3Llz+ctf/kJubi4jR47kl7/8pc/nBgwYwH333ccHH3zAV199RXV1Nc8++2xn34qIdDIFIBEJGBaLhauuuop33nnHZ6p6fn4+f/7zn5k0aRJRUVEAnDx50uezERERpKenU1VVBUBFRQWVlZU+5wwYMIDIyEjvOSLivzQNXkT80iuvvMLq1aubHP/lL3/Jhx9+yKRJk/jZz36G1WrlpZdeoqqqimeeecZ73tChQ7n88ssZM2YMcXFxbN68mTfeeIO77roLgL179zJ58mSuu+46hg4ditVq5e233yY/P5/rr7++y+5TRDqHpsGLiF+pnwbfktzcXAoLC5k/fz7r1q3D5XIxfvx4fvWrXzFhwgTveb/61a9YuXIle/fupaqqir59+3LTTTfxwAMPEBISwsmTJ3nsscfIzs4mNzcXq9XK4MGDue+++/jRj37UFbcqIp1IAUhERESCjsYAiYiISNBRABIREZGgowAkIiIiQUcBSERERIKOApCIiIgEHQUgERERCTpaCLEZLpeL48ePExkZiclkMrocERERaQW3282ZM2dISUnBbD5/G48CUDOOHz/u87wgERER8R+5ubn07t37vOcoADUjMjIS8PwB1j83SERERLq30tJSUlNTvb/Hz0cBqBn13V5RUVEKQCIiIn6mNcNXNAhaREREgo4CkIiIiAQdBSAREREJOhoD1A5Op5Oamhqjy/BLNpvtG6coioiIdBYFoDZwu93k5eVRXFxsdCl+y2w2069fP2w2m9GliIhIEFIAaoP68JOQkEBYWJgWS7xA9QtNnjhxgj59+ujPT0REupwC0AVyOp3e8NOjRw+jy/FbPXv25Pjx49TW1hISEmJ0OSIiEmQ0COMC1Y/5CQsLM7gS/1bf9eV0Og2uREREgpECUBup26Z99OcnIiJGUgASERGRoKMAJG2SlpbGokWLjC5DRESkTTQIOohcfvnlZGRkdEhw2bRpE+Hh4e0vSkRExAAKQF2t5iyYLWDpfuvfuN1unE4nVus3/2PRs2fPLqhIRESkc6gLrCuVfA2Fu6G8qMu/+pZbbmHt2rX87//+LyaTCZPJxLJlyzCZTLz//vuMGTMGu93OZ599xoEDB5g5cyaJiYlEREQwbtw4PvroI5/rndsFZjKZ+N3vfsf3vvc9wsLCGDhwICtXruziuxQREWkdBaAO4Ha7qaiu/eYNBxU1LipKCqmoqm7dZ86zud3uVtf4v//7v0yYMIHbbruNEydOcOLECVJTUwF46KGH+PWvf01OTg4jR46krKyMa665huzsbL744gumTp3KjBkzOHr06Hm/4/HHH+e6665j+/btXHPNNdxwww2cOnWqXX+2IiIinUFdYB3gbI2ToQv+eYGfOtbu7931xBTCbK37K4yOjsZmsxEWFkZSUhIAu3fvBuCJJ57gyiuv9J4bFxfHqFGjvD8vXLiQt99+m5UrV3LXXXe1+B233HILP/7xjwF46qmneP7559m4cSNTp0694HsTERHpTGoBEsaOHevzc1lZGffffz9DhgwhJiaGiIgIcnJyvrEFaOTIkd798PBwoqKiKCgo6JSaRURE2kMtQB0gNMTCriemtO7k2moozPHs9xwC1rYPhg4NsbT5s42dO5vr/vvv58MPP+Q3v/kN6enphIaG8sMf/pDq6urzXufcR1qYTCZcLleH1CgiItKRFIA6gMlkanVXFDYrRERD1RmoLYawlE6tzeerbbZWPXpi3bp13HLLLXzve98DPC1Chw8f7uTqREREuo66wIwQFu95rTgJ7q5rIUlLS2PDhg0cPnyYoqKiFltnBg4cyFtvvcW2bdv48ssv+clPfqKWHBERCSgKQEZwRIHZCq5aqCzpsq+9//77sVgsDB06lJ49e7Y4pue5554jNjaWiRMnMmPGDKZMmcLo0aO7rE4REZHOZnJfyFzqIFFaWkp0dDQlJSVERUX5vFdZWcmhQ4fo168fDoejHV9yHMrywRYJ8entrNj/dNifo4iISJ3z/f4+l1qAjBLWw/NafQZqK42tRUREJMgoABnFagd7pGe/4qSxtYiIiAQZBSAjeQdDn+rSwdAiIiLBTgHISI4oMId0+WBoERGRYKcAZCSTGcLiPPsGPCBVREQkWCkAGc07GLpMg6FFRES6iAKQ0ax2sNdN1dNgaBERkS6hANQd1LcCaTC0iIhIlzA8AC1evJi0tDQcDgfjx49n48aN5z2/uLiYO++8k+TkZOx2OxdddBHvvfdeu65pOEe0BkOLiIh0IUMD0PLly5k3bx6PPfYYW7duZdSoUUyZMoWCgoJmz6+urubKK6/k8OHDvPHGG+zZs4elS5fSq1evNl+zWzCZGlqBuvFg6LS0NBYtWmR0GSIiIu1maAB67rnnuO2225g7dy5Dhw5lyZIlhIWF8corrzR7/iuvvMKpU6dYsWIFl156KWlpaVx22WWMGjWqzdfsNupng2kwtIiISKczLABVV1ezZcsWMjMzG4oxm8nMzGT9+vXNfmblypVMmDCBO++8k8TERIYPH85TTz2F0+ls8zUBqqqqKC0t9dm6XOPB0OUaDC0iItKZDAtARUVFOJ1OEhMTfY4nJiaSl5fX7GcOHjzIG2+8gdPp5L333uPRRx/l2Wef5cknn2zzNQGysrKIjo72bqmpqe28uzaqXxn6bMcPhn755ZdJSUnB5fK97syZM/npT3/KgQMHmDlzJomJiURERDBu3Dg++uijDq1BRESkuzB8EPSFcLlcJCQk8PLLLzNmzBhmz57NI488wpIlS9p13fnz51NSUuLdcnNzL+wCbjdUl7d/M1vAWQtVZ6D0xDef73a3usQf/ehHnDx5kk8++cR77NSpU6xevZobbriBsrIyrrnmGrKzs/niiy+YOnUqM2bM4OjRoxf2ZyEiIuIHrEZ9cXx8PBaLhfz8fJ/j+fn5JCUlNfuZ5ORkQkJCsFgs3mNDhgwhLy+P6urqNl0TwG63Y7fb234zNRXwVErbP99WDx8HW3irTo2NjeXqq6/mz3/+M5MnTwbgjTfeID4+niuuuAKz2ewzlmrhwoW8/fbbrFy5krvuuqtTyhcRETGKYS1ANpuNMWPGkJ2d7T3mcrnIzs5mwoQJzX7m0ksvZf/+/T7dOHv37iU5ORmbzdamawaTG264gTfffJOqqioA/vSnP3H99ddjNpspKyvj/vvvZ8iQIcTExBAREUFOTo5agEREJCAZ1gIEMG/ePG6++WbGjh3LJZdcwqJFiygvL2fu3LkAzJkzh169epGVlQXAHXfcwQsvvMDdd9/Nz3/+c/bt28dTTz3FL37xi1Zfs1OEhHlaYzrKqUNQVQrhPSHqPC1LIWEXdNkZM2bgdrtZtWoV48aN49NPP+X//b//B8D999/Phx9+yG9+8xvS09MJDQ3lhz/8IdXV1e25ExERkW7J0AA0e/ZsCgsLWbBgAXl5eWRkZLB69WrvIOajR49iNjc0UqWmpvLPf/6Te++9l5EjR9KrVy/uvvtu/uu//qvV1+wUJlOru6JaJSYVTh30TIcPCfU8NLUDOBwOvv/97/OnP/2J/fv3M2jQIEaPHg3AunXruOWWW/je974HQFlZGYcPH+6Q7xUREeluDA1AAHfddVeLY0zWrFnT5NiECRP4/PPP23xNv2CPqlsZugbOFjesEdQBbrjhBqZPn87OnTu58cYbvccHDhzIW2+9xYwZMzCZTDz66KNNZoyJiIgECr+aBRY0Gq8M3cEPSP3ud79LXFwce/bs4Sc/+Yn3+HPPPUdsbCwTJ05kxowZTJkyxds6JCIiEmgMbwGSFoT1gLI8z8rQNZUQ4uiQy5rNZo4fbzpeKS0tjY8//tjn2J133unzs7rEREQkUKgFqLuy2hpWhu7gViAREZFgpwDUnYXXrQxdcRI0HkdERKTDKAB1Z/WDod1OqCw2uhoREZGAoQDUnZlMEN45g6FFRESCmQJQG7kv4Dlc7RJaF4DqB0MHiC778xMREWmGAtAFCgkJAaCioqJrvjBAB0PXrzDd+LluIiIiXUXT4C+QxWIhJiaGgoICAMLCwjCZTJ37pdYoKC+BkiIIiQWzf+dWl8tFYWEhYWFhWK36R1BERLqefvu0Qf2T5etDUKdzu+HMaXDVwumajn3shkHMZjN9+vTp/PAoIiLSDAWgNjCZTCQnJ5OQkEBNTU3XfOnGbNj4EqSMhu+/3DXf2YlsNpvPc95ERES6kgJQO1gslq4bwzLq+/DJAtibC2f+G3pe1DXfKyIiEoD0v+D+IroXXDTVs79lmaGliIiI+DsFIH8y5hbP65d/Dqgp8SIiIl1NAcifpGdCVG84expyVhpdjYiIiN9SAPInZguMnuPZ3/wHY2sRERHxYwpA/mb0TWCywNF/Q+Eeo6sRERHxSwpA/iYqRYOhRURE2kkByB/VD4bepsHQIiIibaEA5I/SJ0N0KlQWw653jK5GRETE7ygA+aPGg6G3aDC0iIjIhVIA8lcX1w+GXg8Fu42uRkRExK8oAPmrqGQYdLVnX4OhRURELogCkD/zrgz9F6g5a2gpIiIi/kQByJ8N+C5E99FgaBERkQukAOTPtDK0iIhImygA+buLb/QMhs79HApyjK5GRETELygA+TsNhhYREblgCkCBYMxcz6sGQ4uIiLSKAlAg8A6GLoGdK4yuRkREpNtTAAoEZjOMqV8ZepmhpYiIiPgDBaBAUb8ytAZDi4iIfCMFoEARmdQwGFpT4kVERM5LASiQjK0bDL39r1BdYWwtIiIi3ZgCUCDp/12IqRsMvWuF0dWIiIh0WwpAgcRshtE3e/Y1GFpERKRFCkCB5uKbwGyF3A2Qv8voakRERLolBaBAE5nYaGVoDYYWERFpjgJQIPKuDL1cg6FFRESaoQAUiPpfATF9oaoEdr5tdDUiIiLdjgJQIDKbYYwGQ4uIiLSkWwSgxYsXk5aWhsPhYPz48WzcuLHFc5ctW4bJZPLZHA6Hzzm33HJLk3OmTp3a2bfRvWTc6BkMfWwj5O80uhoREZFuxfAAtHz5cubNm8djjz3G1q1bGTVqFFOmTKGgoKDFz0RFRXHixAnvduTIkSbnTJ061eecv/zlL515G91PZCIMusazr1YgERERH4YHoOeee47bbruNuXPnMnToUJYsWUJYWBivvPJKi58xmUwkJSV5t8TExCbn2O12n3NiY2M78za6p7EaDC0iItIcQwNQdXU1W7ZsITMz03vMbDaTmZnJ+vXrW/xcWVkZffv2JTU1lZkzZ7JzZ9MunjVr1pCQkMCgQYO44447OHnyZIvXq6qqorS01GcLCP0uh9i0usHQbxlcjIiISPdhaAAqKirC6XQ2acFJTEwkLy+v2c8MGjSIV155hXfeeYfXX38dl8vFxIkTOXbsmPecqVOn8tprr5Gdnc3TTz/N2rVrufrqq3E6nc1eMysri+joaO+WmpracTdpJK0MLSIi0iyT2+12G/Xlx48fp1evXvz73/9mwoQJ3uMPPvgga9euZcOGDd94jZqaGoYMGcKPf/xjFi5c2Ow5Bw8eZMCAAXz00UdMnjy5yftVVVVUVVV5fy4tLSU1NZWSkhKioqLacGfdSFkBPDcEXLXwn+sgabjRFYmIiHSK0tJSoqOjW/X729AWoPj4eCwWC/n5+T7H8/PzSUpKatU1QkJCuPjii9m/f3+L5/Tv35/4+PgWz7Hb7URFRflsASMiAQZP8+yrFUhERAQwOADZbDbGjBlDdna295jL5SI7O9unReh8nE4nO3bsIDk5ucVzjh07xsmTJ897TkCrXxl6+3KoLje2FhERkW7A8Flg8+bNY+nSpbz66qvk5ORwxx13UF5ezty5nl/ac+bMYf78+d7zn3jiCT744AMOHjzI1q1bufHGGzly5Ai33nor4Bkg/cADD/D5559z+PBhsrOzmTlzJunp6UyZMsWQezRcv8vqBkOXwlcaDC0iImI1uoDZs2dTWFjIggULyMvLIyMjg9WrV3sHRh89ehSzuSGnnT59mttuu428vDxiY2MZM2YM//73vxk6dCgAFouF7du38+qrr1JcXExKSgpXXXUVCxcuxG63G3KPhjObYcwt8NEvPd1go28yuCARERFjGToIuru6kEFUfqOssG4wdA3852eQNMLoikRERDqU3wyCli4U0VODoUVEROooAAWT+pWht/9Ng6FFRCSoKQAFk7TvQGw/DYYWEZGgpwAUTOoHQwNs+YOhpYiIiBhJASjYZNwA5hD4eguc2G50NSIiIoZQAAo2ET1hyHTPvgZDi4hIkFIACkZjGg2GriozthYREREDKAAFo7RvQ1x/qD4DOzUYWkREgo8CUDBqPBh6swZDi4hI8FEAClb1g6GPb4UTXxpdjYiISJdSAApW4fEwZIZnX4OhRUQkyCgABTPvytB/12BoEREJKgpAwSzt2xA3wDMY+qs3ja5GRESkyygABTOTSStDi4hIUFIACnYZPwGLDY5/Ace3GV2NiIhIl1AACnYaDC0iIkFIAUgaVobe8XeoOmNsLSIiIl1AAUggbRL0SIfqMg2GFhGRoKAAJL6DobUytIiIBAEFIPEYVTcY+sQ2z4BoERGRAKYAJB7hPWDItZ59DYYWEZEApwAkDepXht7xhgZDi4hIQFMAkgZ9L4UeAz2DoXe8YXQ1IiIinUYBSBpoZWgREQkSCkDia9SP6wZDf6nB0CIiErAUgMRXeA8YOtOzrynxIiISoBSApKn6bjANhhYRkQClACRN9b0U4i+CmnLP4zFEREQCjAKQNHXuytBut6HliIiIdDQFIGneqB+DxQ552zUYWkREAo4CkDQvLK5hMLSmxIuISIBRAJKWeQdDvwmVpYaWIiIi0pEUgKRlfSdC/CANhhYRkYCjACQtO3dlaA2GFhGRAKEAJOc36vq6wdA74PhWo6sRERHpEApAcn5hcTBslmdfK0OLiEiAUACSb1bfDfaVBkOLiEhgUACSb9ZnQt1g6ArY8TejqxEREWk3BSD5ZiYTjJ3r2d+8TIOhRUTE7ykASeuMnO0ZDJ2/A77WYGgREfFv3SIALV68mLS0NBwOB+PHj2fjxo0tnrts2TJMJpPP5nA4fM5xu90sWLCA5ORkQkNDyczMZN++fZ19G4EtLA6Gfc+zv+UVY2sRERFpJ8MD0PLly5k3bx6PPfYYW7duZdSoUUyZMoWCgoIWPxMVFcWJEye825EjR3zef+aZZ3j++edZsmQJGzZsIDw8nClTplBZWdnZtxPYvIOh34LKEkNLERERaQ/DA9Bzzz3Hbbfdxty5cxk6dChLliwhLCyMV15puZXBZDKRlJTk3RITE73vud1uFi1axH//938zc+ZMRo4cyWuvvcbx48dZsWJFF9xRAOvzLeg52DMYersGQ4uIiP8yNABVV1ezZcsWMjMzvcfMZjOZmZmsX7++xc+VlZXRt29fUlNTmTlzJjt37vS+d+jQIfLy8nyuGR0dzfjx41u8ZlVVFaWlpT6bNMNnZehlGgwtIiJ+y9AAVFRUhNPp9GnBAUhMTCQvL6/ZzwwaNIhXXnmFd955h9dffx2Xy8XEiRM5duwYgPdzF3LNrKwsoqOjvVtqamp7by1wjboerA7I/wq+3mJ0NSIiIm1ieBfYhZowYQJz5swhIyODyy67jLfeeouePXvy0ksvtfma8+fPp6SkxLvl5uZ2YMUBJjS20WDoZYaWIiIi0laGBqD4+HgsFgv5+fk+x/Pz80lKSmrVNUJCQrj44ovZv38/gPdzF3JNu91OVFSUzybncfGNnteclVBbbWwtIiIibWBoALLZbIwZM4bs7GzvMZfLRXZ2NhMmTGjVNZxOJzt27CA5ORmAfv36kZSU5HPN0tJSNmzY0OpryjfoMwHCEzwzwQ79y+hqRERELpjhXWDz5s1j6dKlvPrqq+Tk5HDHHXdQXl7O3LmelYfnzJnD/Pnzvec/8cQTfPDBBxw8eJCtW7dy4403cuTIEW699VbAM0Psnnvu4cknn2TlypXs2LGDOXPmkJKSwqxZs4y4xcBjtsDQaz37u942thYREZE2sBpdwOzZsyksLGTBggXk5eWRkZHB6tWrvYOYjx49itnckNNOnz7NbbfdRl5eHrGxsYwZM4Z///vfDB061HvOgw8+SHl5ObfffjvFxcVMmjSJ1atXN1kwUdph6EzY9DvYvQqmLwJLiNEViYiItJrJ7dZc5nOVlpYSHR1NSUmJxgO1xOWE31wEFUVw41uQPtnoikREJMhdyO9vw7vAxE+ZLTBkhmd/1zvG1iIiInKBFICk7YbN8rzufhectYaWIiIiciEUgKTt+k6CsB5QcRKOfGZ0NSIiIq2mACRtZ7HC4Ome/Z0rDC1FRETkQigASfsMnel5zfmHZ2C0iIiIH1AAkvbp9x3P4zEqiuDIOqOrERERaRUFIGkfSwgMnubZ12wwERHxEwpA0n5D6x6OumulusFERMQvKABJ+/X7DjiiobwAjn5udDUiIiLfSAFI2s9qa5gNtmuFoaWIiIi0hgKQdIz62WC7VoLLZWwtIiIi30ABSDpG/8vBHg1leZC7wehqREREzksBqAuVnK3h75tz+errEqNL6XhWOwy62rOv2WAiItLNKQB1oadX7+aBN7bzpw1HjC6lc9Q/G2zXO+oGExGRbk0BqAtNG5EMwOqv8qhxBmBA6H8F2CLhzHH4erPR1YiIiLRIAagLje8XR3yEjdMVNfz7wEmjy+l4IY6GbjA9G0xERLoxBaAuZLWYmTo8CYBV248bXE0n8c4GewfcbmNrERERaYECUBebNiIFgH/uzKe6NgC7wdIngy0CSo/B11uMrkZERKRZCkBd7JJ+cfSMtFNytoZ1B4qMLqfjhYTCRVM8+1oUUUREuikFoC5mMZu4pq4b7N0vTxhcTScZOsvzulPdYCIi0j0pABlg2khPN9gHu/Koqg3Ah4emZ0JIGJQcheNfGF2NiIhIEwpABhjbN5bEKDtnKmv5bF8AdoPZwtQNJiIi3ZoCkAHMZhPX1K0J9O72QO0Gq5sNtnOFusFERKTbUQAyyPSRngD04a58KmsCsBts4FVgDYXiI3DiS6OrERER8aEAZJCLU2NJjnZQVlXLv/YWGl1Ox7OFw8ArPfvqBhMRkW5GAcggZrPJ+2iMVTsCtBus8bPB1A0mIiLdiAKQgabVdYN9FLDdYFPA6oBTByFvh9HViIiIeCkAGSgjNYZeMaGUVztZs6fA6HI6nj3CMyUePK1AIiIi3USbAtCrr77KqlWrvD8/+OCDxMTEMHHiRI4cOdJhxQU6k8nkbQUK3Nlgszyvu1aoG0xERLqNNgWgp556itDQUADWr1/P4sWLeeaZZ4iPj+fee+/t0AIDXf1ssOycAiqqaw2uphMMmgoWO5zcDwW7jK5GREQEaGMAys3NJT09HYAVK1bwgx/8gNtvv52srCw+/fTTDi0w0I3oFU1qXChna5x8sjsAZ4PZIxu6wXauMLQUERGRem0KQBEREZw8eRKADz74gCuv9Ex3djgcnD17tuOqCwImk8n7hPhVO44bXE0nqV8UUeOARESkm2hTALryyiu59dZbufXWW9m7dy/XXHMNADt37iQtLa0j6wsK9d1gH+8uoLwqULvBbFC0BwpyjK5GRESkbQFo8eLFTJgwgcLCQt5880169OgBwJYtW/jxj3/coQUGg2EpUaT1CKOyxkX27gCcDeaIhgHf9eyrFUhERLoBk9utqTnnKi0tJTo6mpKSEqKiorrkO//nn7tZ/MkBpgxL5KWbxnbJd3apbX+BFf8JPYfAnZ8bXY2IiASgC/n93aYWoNWrV/PZZ595f168eDEZGRn85Cc/4fTp0225ZNCrHwf0yZ5CygKyG+xqMIdAYQ4U7jG6GhERCXJtCkAPPPAApaWlAOzYsYP77ruPa665hkOHDjFv3rwOLTBYDEmOpH/PcKprXXy0K9/ocjpeaAwMuMKzr24wERExWJsC0KFDhxg6dCgAb775JtOnT+epp55i8eLFvP/++x1aYLAwmUxMHxHoiyJqNpiIiHQPbQpANpuNiooKAD766COuuuoqAOLi4rwtQ3Lhpo30dIP9a28hpZU1BlfTCQZdA2Yr5H8FRfuNrkZERIJYmwLQpEmTmDdvHgsXLmTjxo1MmzYNgL1799K7d+8OLTCYDEqKZGBCBNXOAO0GC4uDfpd59netMLQUEREJbm0KQC+88AJWq5U33niDF198kV69egHw/vvvM3Xq1Au+3uLFi0lLS8PhcDB+/Hg2btzYqs/99a9/xWQyMWvWLJ/jt9xyCyaTyWdrS11GCPhngw2b5XlVABIREQMZPg1++fLlzJkzhyVLljB+/HgWLVrE3//+d/bs2UNCQkKLnzt8+DCTJk2if//+xMXFsWLFCu97t9xyC/n5+fzhD3/wHrPb7cTGxraqJiOmwdfbX3CGzOf+RYjFxOZHriQ6LKRLv7/TlZ+E3wwEtxN+vhV6DDC6IhERCRCdPg0ewOl08uabb/Lkk0/y5JNP8vbbb+N0Oi/4Os899xy33XYbc+fOZejQoSxZsoSwsDBeeeWV8373DTfcwOOPP07//v2bPcdut5OUlOTdWht+jJaeEMngpEhqnG4+2JVndDkdL7wH9PuOZ1+DoUVExCBtCkD79+9nyJAhzJkzh7feeou33nqLG2+8kWHDhnHgwIFWX6e6upotW7aQmZnZUJDZTGZmJuvXr2/xc0888QQJCQn8x3/8R4vnrFmzhoSEBAYNGsQdd9zhfXaZP5im2WAiIiKdqk0B6Be/+AUDBgwgNzeXrVu3snXrVo4ePUq/fv34xS9+0errFBUV4XQ6SUxM9DmemJhIXl7zrR+fffYZv//971m6dGmL1506dSqvvfYa2dnZPP3006xdu5arr766xRaqqqoqSktLfTYjXVM3Dmjd/iJOl1cbWkunGDIDTGY4sQ1OHTK6GhERCUJtCkBr167lmWeeIS4uznusR48e/PrXv2bt2rUdVty5zpw5w0033cTSpUuJj49v8bzrr7+ea6+9lhEjRjBr1izeffddNm3axJo1a5o9Pysri+joaO+WmpraSXfQOgN6RjAkOYpaV6B2g8VD2iTPfs5KY2sREZGg1KYAZLfbOXPmTJPjZWVl2Gy2Vl8nPj4ei8VCfr7vlO/8/HySkpKanH/gwAEOHz7MjBkzsFqtWK1WXnvtNVauXInVam2x+61///7Ex8ezf3/za8/Mnz+fkpIS75abm9vqe+gs0wN9NtjQWZ7XnSuMrEJERIJUmwLQ9OnTuf3229mwYQNutxu3283nn3/Of/7nf3Lttde2+jo2m40xY8aQnZ3tPeZyucjOzmbChAlNzh88eDA7duxg27Zt3u3aa6/liiuuYNu2bS223Bw7doyTJ0+SnJzc7Pt2u52oqCifzWj144D+feAkJ8uqDK6mE9R3gx3fCsVHja5GRESCTJsC0PPPP8+AAQOYMGECDocDh8PBxIkTSU9PZ9GiRRd0rXnz5rF06VJeffVVcnJyuOOOOygvL2fu3LkAzJkzh/nz5wPgcDgYPny4zxYTE0NkZCTDhw/HZrNRVlbGAw88wOeff87hw4fJzs5m5syZpKenM2XKlLbcriHS4sMZ3isKp8vNP3cG4KKIEQnQ91LPvgZDi4hIF7O25UMxMTG888477N+/n5ycHACGDBlCenr6BV9r9uzZFBYWsmDBAvLy8sjIyGD16tXegdFHjx7FbG59TrNYLGzfvp1XX32V4uJiUlJSuOqqq1i4cCF2u/2C6zPS9JEpfPV1Kat2HOcn4/sYXU7HGzoTDn/qCUATf250NSIiEkRavRDihTzl/bnnnmtzQd2BkQshNpZ7qoJvP/MJZhNseDiTnpH+FeC+0Zk8eHYw4IZ7d0K0HqMiIiJtdyG/v1vdAvTFF1+06jyTydTaS8o3SI0LY1TvaL48VsLqnXnc9K2+RpfUsSKToM8EOPpv2LUSJvzM6IpERCRItDoAffLJJ51Zh7Rg2shkvjxWwqrtxwMvAIHn2WBH/+15NpgCkIiIdJE2PwpDusY1dbPBNhw6RcGZSoOr6QRDZnheczdA6XFjaxERkaChANTN9Y4N4+I+Mbjd8P6OAFwUMSoFUr/l2d+lRRFFRKRrKAD5gfo1gVYF7KKIejaYiIh0LQUgPzCtblXoTUdOkVcSgN1gQ+sWzzy63jMzTEREpJMpAPmB5OhQxvaNxe2G93YEYCtQdG/oPQ5wQ84/jK5GRESCgAKQn6hvBVoViAEI9GwwERHpUgpAfuKaEcmYTLDlyGmOF581upyOV98NdmQdlBUYW4uIiAQ8BSA/kRjlYFxaHBCg3WAxfaDXGDzdYJoNJiIinUsByI9Mr+sGe1ezwURERNpFAciPTB2ehNkE23KLyT1VYXQ5Ha8+AB3+DMoKja1FREQCmgKQH0mIdDC+Xw8A3v8qAFuBYtMgOQPcLtit2WAiItJ5FID8zLRA7wYbNsvzqm4wERHpRApAfqa+G2z7sRKOngzgbrBDn0L5SWNrERGRgKUA5GfiI+xMGODpBgvINYHi+kPSSHA7Yfe7RlcjIiIBSgHID00fmQLAqh0B+vR072ywFYaWISIigUsByA9NGZaExWziq69LOVxUbnQ5Ha9+VeiDa6HilKGliIhIYFIA8kNx4TYmBnI3WHw6JA6v6wZbZXQ1IiISgBSA/NSMum6wgJ0NVt8KpNlgIiLSCRSA/NRVwxKxmk3knCjlQGGZ0eV0vPpxQAfXwNnThpYiIiKBRwHIT8WE2Zg0MB6AVYHYCtTzIkgYCq4a2PO+0dWIiEiAUQDyY9NGeBZFDMgABA2tQDtXGFqGiIgEHgUgP3bVsCRCLCb25J9hX/4Zo8vpePXjgA58DJUlhpYiIiKBRQHIj0WHhvCdgT2BAB0MnTAY4gepG0xERDqcApCfq3822KodJ3C73QZX0wn0bDAREekECkB+7sqhidisZvYXlLE3P4Bng+3PhspSY2sREZGAoQDk5yIdIVx2UX03WAA+GiNhKPQYCM4q2PtPo6sREZEAoQAUAKaPbJgNFnDdYCaTng0mIiIdTgEoAEwekojdauZgUTk5JwJwNlj9OKB9H0JVAN6fiIh0OQWgABBht3LFoAQgQJ8Qnzgc4vqrG0xERDqMAlCAqJ8N9m7AdoPN8uxrNpiIiHQABaAA8d3BCThCzBw5WcHO4wE4W6p+HNC+D6G63NhaRETE7ykABYhwu5XJgxOBAF0UMXkUxKZB7VnY94HR1YiIiJ9TAAogDd1gxwO0G0zPBhMRkY6hABRArhiUQJjNwrHTZ9l+LACfnVU/DmjfB1BdYWgpIiLi3xSAAkiozcLkIZ5usFU7ArAbLOViiOkDNRWw/0OjqxERET+mABRgpo0IlkURNRtMRETaTgEowFw+qCfhNgtfF5/li9xio8vpePXdYHtWQ81ZQ0sRERH/pQAUYBwhFjKH1nWDBeJssF5jIKo31JR7HpAqIiLSBgpAAWj6yBQA3ttxApcrkLvBVhhaioiI+K9uEYAWL15MWloaDoeD8ePHs3HjxlZ97q9//Ssmk4lZs2b5HHe73SxYsIDk5GRCQ0PJzMxk3759nVB59/TtgfFE2q2cKKlk69HTRpfT8eqfDbZnNdRUGlqKiIj4J8MD0PLly5k3bx6PPfYYW7duZdSoUUyZMoWCgoLzfu7w4cPcf//9fPvb327y3jPPPMPzzz/PkiVL2LBhA+Hh4UyZMoXKyuD4ZekIsXDl0ABeFLHXWIhMgeozcOBjo6sRERE/ZHgAeu6557jtttuYO3cuQ4cOZcmSJYSFhfHKK6+0+Bmn08kNN9zA448/Tv/+/X3ec7vdLFq0iP/+7/9m5syZjBw5ktdee43jx4+zYsWKTr6b7mP6KM9ssIDsBjObNRtMRETaxdAAVF1dzZYtW8jMzPQeM5vNZGZmsn79+hY/98QTT5CQkMB//Md/NHnv0KFD5OXl+VwzOjqa8ePHt3jNqqoqSktLfTZ/Nym9J5EOKwVnqth8JAC7weoD0J73oLbK2FpERMTvGBqAioqKcDqdJCYm+hxPTEwkLy+v2c989tln/P73v2fp0qXNvl//uQu5ZlZWFtHR0d4tNTX1Qm+l27FZzUwZlgR4Ho0RcFLHQ2QyVJXCwTVGVyMiIn7G8C6wC3HmzBluuukmli5dSnx8fIddd/78+ZSUlHi33NzcDru2keqfDfbejjycgdgNNuRaz76eDSYiIhfIauSXx8fHY7FYyM/P9zmen59PUlJSk/MPHDjA4cOHmTFjhveYy+UCwGq1smfPHu/n8vPzSU5O9rlmRkZGs3XY7Xbsdnt7b6fbmZQeT3RoCEVlVWw8dIoJA3oYXVLHGjoTNr4Ee1ZBbTVYbUZXJCIifsLQFiCbzcaYMWPIzm5Y0M7lcpGdnc2ECROanD948GB27NjBtm3bvNu1117LFVdcwbZt20hNTaVfv34kJSX5XLO0tJQNGzY0e81AFmIxMzWQu8H6fAsiEqGyBA6tNboaERHxI4Z3gc2bN4+lS5fy6quvkpOTwx133EF5eTlz584FYM6cOcyfPx8Ah8PB8OHDfbaYmBgiIyMZPnw4NpsNk8nEPffcw5NPPsnKlSvZsWMHc+bMISUlpcl6QcGgvhts9Vd51DpdBlfTwcwWGFLXGqhFEUVE5AIY2gUGMHv2bAoLC1mwYAF5eXlkZGSwevVq7yDmo0ePYjZfWE578MEHKS8v5/bbb6e4uJhJkyaxevVqHA5HZ9xCtzZxQA9iw0I4WV7NhkOnuDS948ZOdQtDZ8Gm38HuVTB9EVhCjK5IRET8gMkdcI8Mb7/S0lKio6MpKSkhKirK6HLabf5bO/jLxqP8+JI+ZH1/hNHldCyXE54dBOWFcOObkJ75zZ8REZGAdCG/vw3vApPON93bDXaCmoDuBtOiiCIi0joKQEFgfL84eoTbOF1Rw/oDJ40up+PVL4qY8y44a4ytRURE/IICUBCwWsxcPcIzG2xVID4brO8kCOsBZ0/B4c+MrkZERPyAAlCQmDYiBYDVO/Oorg2wbjCLFQZP9+xrNpiIiLSCAlCQuKRfHD0j7ZScrWHdgSKjy+l4w2Z5XnPeBWetoaWIiEj3pwAUJCxmE9cMD+BusLRvQ2gsVBTBkXVGVyMiIt2cAlAQmTbS0w32z4DsBgtp1A2m2WAiInJ+CkBBZGzfWBIi7ZyprOXTfYVGl9Pxhs7yvOb8w7M+kIiISAsUgIKI2WzimhGeNYECshus/2XgiIHyAji63uhqRESkG1MACjIzRnkC0Ie78qmsCbBWEksIDJ7m2d+5wtBSRESke1MACjIXp8aSHO3gTFUt/9obyN1gK8EVYOOcRESkwygABRmfbrAdgdgNdjnYo6EsH3I/N7oaERHpphSAglD9s8E+CsRuMKsNBl/j2ddsMBERaYECUBDKSI2hV0wo5dVO1uwJxG6wumeD7XpH3WAiItIsBaAgZDKZmFbXCvTu9uMGV9MJBnwXbJFw5gQc22R0NSIi0g0pAAWpaXXjgLJzCjhbHWjdYHYYdLVnX88GExGRZigABamRvaNJjQvlbI2TT/YUGF1Ox6t/Npi6wUREpBkKQEHKZDJ5nxAfuN1gEVD6NXy9xehqRESkm1EACmL1s8E+3l1AeVWAPUE9JBQumurZVzeYiIicQwEoiA1LiSKtRxiVNS4+3h2A3WDe2WArwe02thYREelWFICCWOPZYAH5bLCBV0JIOJQcheNbja5GRES6EQWgIFc/DuiTPQWUBWQ32FWefT0bTEREGlEACnJDkiPpHx9OVa2L7Jx8o8vpePXPBtv1jrrBRETESwEoyJlMJu9g6HcDtRvMGgrFR+DENqOrERGRbkIBSJg20tMNtnZPIaWVNQZX08Fs4Q3dYHo2mIiI1FEAEi5KjCA9IYJqp4uPdgViN1jdbLCdK9QNJiIigAKQ4NsNFpizwaaA1QGnD0HeDqOrERGRbkABSICGZ4P9a18hJWcDrBvMHgHpmZ59LYooIiIoAEmdgYmRDEqMpMbp5oOdeUaX0/GGfc/zqm4wERFBAUga8XaD7QjAbrCLpoDFDqcOQP5Oo6sRERGDKQCJ1zV1AeizfUUUV1QbXE0Hs0c26gbTbDARkWCnACReA3pGMCQ5ilqXm38GYjeY99lgK9QNJiIS5BSAxEdAL4o4aCpYbFC0Fwp3G12NiIgYSAFIfNTPBvv3gZOcKg+wbjBHNAz4rmdfzwYTEQlqCkDiIy0+nOG9onAGbDfYLM+rxgGJiAQ1BSBpov4J8e9uP25wJZ1g0NVgDoHCHCjcY3Q1IiJiEAUgaaJ+HND6AycpKqsyuJoOFhoDA67w7KsVSEQkaCkASROpcWGM6h2Nyw2rvwrEbrBGzwYTEZGgpAAkzZrmnQ0WiN1g14DZCgU7oWif0dWIiIgBFICkWdfUzQbbcOgUBWcqDa6mg4XFQb/LPPt6NpiISFDqFgFo8eLFpKWl4XA4GD9+PBs3bmzx3LfeeouxY8cSExNDeHg4GRkZ/PGPf/Q555ZbbsFkMvlsU6dO7ezbCCi9Y8O4uE8M7kDtBhs2y/O60w/HATlroeoMlBXA6SNQsBuOfwHFR7XAo4hIK1mNLmD58uXMmzePJUuWMH78eBYtWsSUKVPYs2cPCQkJTc6Pi4vjkUceYfDgwdhsNt59913mzp1LQkICU6ZM8Z43depU/vCHP3h/ttvtXXI/gWTaiGS+OFrMu9tPMGdCmtHldKxB08B0D+TvgJMHoMeA9l3P7YbaSqg527DV1u9XQE1l3Wvj480dqz+3br+2sukxV03LddgiIWGIZ0scVrc/FMLj23d/IiIBxuR2G/u/jOPHj2fcuHG88MILALhcLlJTU/n5z3/OQw891KprjB49mmnTprFw4ULA0wJUXFzMihUr2lRTaWkp0dHRlJSUEBUV1aZrBILjxWeZ+OuPMZng8/mTSYxyGF1Sx3ptFhz8BEb9GPp8yze8eMPHOQGmtlFoOTfAGMEaCiGhYHVAeWHL4Sg8oSEMJQ71vPYcDPaIrq1XRKQTXcjvb0NbgKqrq9myZQvz58/3HjObzWRmZrJ+/fpv/Lzb7ebjjz9mz549PP300z7vrVmzhoSEBGJjY/nud7/Lk08+SY8ePTr8HgJZSkwoY/vGsvnIad7bcYK5l/YzuqSONXSmJwB9+RfP1lHMIZ5QUr/Vh5SQMAhxNOxbHY2OhTUEmfr9kNBmzm18XQeYTA3fW1vtedp9wS7I3wUFOZ7904ehvAAOFcChtb61xvT1DUUJQ6DHQLDaOu7PQ0SkGzI0ABUVFeF0OklMTPQ5npiYyO7dLT+rqaSkhF69elFVVYXFYuG3v/0tV155pff9qVOn8v3vf59+/fpx4MABHn74Ya6++mrWr1+PxWJpcr2qqiqqqhrWuyktLe2AuwsM00Yms/nIaVZtD8AANPI6OLLO03LSJGQ4Wg4ezYaa+nNDwRJizP1YbQ3dX8N/0HC8utzz7LOCnLpgVLeV5UPxEc+29/2G881WTwhKGOIbjGLSwNwthg2KiLSb4WOA2iIyMpJt27ZRVlZGdnY28+bNo3///lx++eUAXH/99d5zR4wYwciRIxkwYABr1qxh8uTJTa6XlZXF448/3lXl+5WrhyfzxLu72HzkNMeLz5ISE2p0SR3HFg4/+J3RVXQ+Wzj0GuPZGis/6VkR2xuK6lqMqkrrVsrOgZ1vNZwfEubpNvO2GA2BhGEQkeDbEiUi4gcMDUDx8fFYLBby8/N9jufn55OUlNTi58xmM+np6QBkZGSQk5NDVlaWNwCdq3///sTHx7N///5mA9D8+fOZN2+e9+fS0lJSU1PbcEeBJynawbi+cWw8fIr3dpzg1m/3N7ok6SjhPSB8EqRNajjmdkPp13WtRTsbQlHhHs94p+NbPVtjoXHnhKK6V0d0196PiMgFMDQA2Ww2xowZQ3Z2NrNmzQI8g6Czs7O56667Wn0dl8vl04V1rmPHjnHy5EmSk5Obfd9ut2uW2HlMH5XMxsOnWKUAFPhMJoju7dkGNnQr46yF04d8Q1HBLjh1EM6egiOfebbGono37UaLH+TpMhQRMZjhXWDz5s3j5ptvZuzYsVxyySUsWrSI8vJy5s6dC8CcOXPo1asXWVlZgKe7auzYsQwYMICqqiree+89/vjHP/Liiy8CUFZWxuOPP84PfvADkpKSOHDgAA8++CDp6ek+0+Sl9aYOT+KxlTv54mgxx05X0Ds2zOiSpKtZrBA/0LPVr6EEnhlwRXubdqOVfg2lxzzb/g8bzjeZIW6AbyhKGAZx/cDcdHyeiEhnMTwAzZ49m8LCQhYsWEBeXh4ZGRmsXr3aOzD66NGjmBsNvCwvL+dnP/sZx44dIzQ0lMGDB/P6668ze/ZsACwWC9u3b+fVV1+luLiYlJQUrrrqKhYuXKhWnjZKiHQwvl8cnx/0dIPd/p12rpkjgSMkFJJHebbGzhZ7Bl57W4xyPI8eOXsaTu7zbI0fRmt1QPxFnrWLeg7ytBTFXwSxfY0bVC4iAc3wdYC6I60D1NTrnx/hv1d8xaje0bxz16Rv/oDIudxuz8yzc0NRwe6W11Eyh0Bc/7rWp4sabekaYyQiTfjNOkDiP6YOT2LBO1/x5bESck9VkBqnbjC5QCYTRCZ5tvRGkxFcLig+3NCNVrS3btvnGXhdtMeznSsi6ZxgVLcf1UvT9UXkGykASavER9iZMKAH6/af5N3tJ7jjcnWDSQcxmz2tPHH9Ycj0huMuF5w53hCGivZ6ZqMV7YOyvIbt8Ke+1wsJgx7pTYNRjwGeLjsRERSA5AJMG5HCuv0nWbXjuAKQdD6zuWFG2oDv+r5XWQJF+xu1FtWFpFMHPa1Geds9mw8TxPRpGox6DoKwHlrLSCTIaAxQMzQGqHmnyqsZ96uPcLrcrLn/ctLiw40uScSXswZOH/ENRUV7PV1olSUtfy401jcU1W8xfT0z4ETEL2gMkHSKuHAbEwf04NN9RazacYI7r0g3uiQRX5YQzwDp+HTgmobjbjeUFzUTjPZC8VHP7LTcDZ6tMXOIp+vs3LFGPQaCQ/9zJOLPFIDkgkwfmcyn+4p4d7sCkPgRkwkienq2tEt936s5CycPNA1GJ/d7utMKd3u2c0UmtzwIW91pIt2eApBckCnDknjk7a/IOVHKgcIyBvSMMLokkfYJCYWk4Z6tMZfLs6DjucGofhD2mROe7dC/zrleuKcFKrafZ8ZbRAJEJNZtdfth8epaEzGY/g2UCxITZmPSwHjW7Clk8Sf7efiaIcRHaIFJCUBmM8Skerb0c54h2Owg7L11g7DL4cSXnq1FJgiP9w1FzQWliARwxKhFSaQTaBB0MzQI+vxWfnmcX/zlCwCsZhOThyQwe1wq3xnYE6tF669IEHPWwOnDdWOLcj0LP5YV1L3W7ZcXgNvV+mtabC0EpWYCk6b5+3LWQHW5pyvTWQ1mq2dclyXEs1//arYqZAaIC/n9rQDUDAWg83O73by19Wv++PkRtuUWe48nRtn54ZjeXDc2lb49NENMpFkuJ1Sc8g1FzQWlsnyoLL6wa9ujWheUuksXnNsNtZVQXeFpOfN5rWgIL+ceb+5Yc+e6alpfy/nCkSWk7r3G54R4nl/X0nsWa6NrXuh79TW08Dm3uy5Eu+v23XX7rvPvN/uZc4+7znMtWrjW+fZp4Vpu6DUG+k7siH+SvBSA2kkBqPX25J1h+aZc3v7iGKcrGv5jM6F/D2aPS2Xq8CQcIXrIpUib1FbVhaFmwtG5+7WVF3Dhb+qCaxSYbBGNQkcLgaS63DOYvDXhxed4BdAFv4JMFrDawVXraRXqiu+UbzZpHmQ+1qGXVABqJwWgC1dV6+SjXQUs35zLp/sKvf+zEOWwMjOjF7PHpTK8l57dJNIp3G6oOtNCOGpnF1xXsTo8q3jbwutewzwDym1hjY6Hnuecc88Na/jZYvPt4nI5G8KQqwactXWvNY2O1zbzXqOfXbVte89ZU/f9Lb1Xe/7aXLVgMgMmzz1592nhuLnu3s/dN7Vw/BvOb/Y7mtvnm8+5aCoM/36H/mOkANROCkDt83XxWf6+OZe/bz7G18UND7kcmhzF9ZekMnNUL6LD9IRvEUO0qguubmu8eKTJ3HzICAn9htDSUmAJ9T3XrJZiaT8FoHZSAOoYLpebdQeKWL4plw925lPt9Pxfp81q5urhScwem8q3+vfAbNbgQ5FuqabS000VEubpQtJAYenmFIDaSQGo450ur2bFtq9ZvimX3XlnvMf7xIXxozG9+eHY3iRHawaLiIi0nQJQOykAdR632832YyUs35zLP7Yd50xVLQBmE1x2UU9mj0vlu4MTsVk1nV5ERC6MAlA7KQB1jbPVTt7bcYLlm3PZeOiU93iPcBvfH+0ZOJ2eEGlghSIi4k8UgNpJAajrHSoq52+bc3ljyzEKz1R5j4/uE8PscalMH5lCuL0brFsiIiLdlgJQOykAGafW6eKTPYUs35TLJ3sKcLo8/3iG2yxMH5nCdeNSGd0nBpMGY4qIyDkUgNpJAah7KCit5M2tX/O3zbkcKir3Hk9PiGD22FS+N7qXnkMmIiJeCkDtpADUvbjdbjYeOsXyzbm8t+MElTWe6fRWs4nMIYme55Bd1BOLptOLiAQ1BaB2UgDqvkora/jHl8f526ZcvjzWsEhbUpSDH43tzY/GpNKnR5iBFYqIiFEUgNpJAcg/5JwoZfmmXFZs+5riRs8hmzjA8xyyKcP0HDIRkWCiANROCkD+pbLGyYe78vnb5lw+21/k8xyyWRf34rqxeg6ZiEgwUABqJwUg/5V7qoK/bznGG5tzOV7S8HTs4b2imD02lWszehEdqueQiYgEIgWgdlIA8n9Ol5vP9hfxt025fLArjxqn5x9ze91zyK4bl8q3+uk5ZCIigUQBqJ0UgALLqfJq3v7ia/62KZc9+b7PIbtubG8yUmMJtVkIs1kIt1m9+6EhFgUkERE/ogDUTgpAgcntdrMtt5i/bc7lH1+eoKzuOWTnExpSF4bqQlGYzVr3aiHUZiX8PO+FhVgIs/ser9+3W81azFFEpIMpALWTAlDgq6iuZdX2E6z88jgFpVVU1NRyttpJRd3W2cwmCDuntSncbvXuh9kshNnrQlR92LLXv+cbqEJtFsLtFuIj7IRY9BBZEQleCkDtpAAU3FwuN5W1niB0ttpJeXWtd98TkGq9QelsdS3l3vcajldU+waq+veqal2dVrcjxMzI3jGM6RvLmD6xjO4bS1y4rdO+T0Sku7mQ3996uqTIOcxmU10rS8f/6+F0uX3CUXkLQanZsFVTS3lV3Xs1dcerGs6prHGx8dApNh465f2+/vHhXNwn1hOK+sYyMCFC45pERFAAEulSFrOJSEcIkY6OnYrvcrk5WFTGliOn2XqkmC1HT7O/oIyDReUcLCrnza3HAIh0WLm4Tyyj+3haijJSYzq8FhERf6AusGaoC0wCQXFFNV8cLfaEoqOn2ZZb3GR8k8kEgxIjvS1Eo/vE0rdHmAZoi4hf0higdlIAkkBU63SxO+8MW4+e9oai3FNnm5zXI9zG6L4N3WYjekXrkSIi4hcUgNpJAUiCRUFppTcQbTlymq++LqXa6TtQO8RiYmhKNGMajSVKinYYVLGISMsUgNpJAUiCVVWtk6++LmVrXSDacvQ0hWeqmpzXKyaUi+vGEY3pG8uQ5ChNwRcRwykAtZMCkIiH2+3m2OmzPq1EOSdKcZ3zXw1HiJlRvRsC0cV9NAVfRLqeAlA7KQCJtKy8qpYvc4sbjSUqpuRsTZPz+seH+4wlSu+pKfgi0rkUgNpJAUik9RpPwa8PRPsLypqcVz8Fv34s0ajU6ICcgu9yual2urCaTVjVLSjSpRSA2kkBSKR9Gk/B33LkNF8eazoF32yCQUlR3jWJxvSNpU/cN0/Bd7vd1Lrc1DhdVNe6qK57rXG6615dVNW9Vjd69T3P6Xlt9F5N/blOF9W1bu+xamfL16xxupscr63rHwyxmOgXH87AhEjSEyIYmBjBwIRI0uLDsFs1q06kMygAtZMCkEjHOncK/pYjpzl2uukU/PgIG71iQhtChdNFTaMwUlUXRvz5v1oWs4m+PcIYmOAJRAMTI0hPiGBAzwgtNyDSTn4XgBYvXsz//M//kJeXx6hRo/i///s/LrnkkmbPfeutt3jqqafYv38/NTU1DBw4kPvuu4+bbrrJe47b7eaxxx5j6dKlFBcXc+mll/Liiy8ycODAVtWjACTS+VozBb81TCawWcyezWomxPtqwma1YLOYzjne+Fzf9+qvE2JteLVbzIRYTdgsFu/5Tb/LjL3utf6c4ooa9heWsT+/jH0FZ9hX4Nk/U1Xb4n30ifMEo/SESE9ASvQEo3C7Fu0XaQ2/CkDLly9nzpw5LFmyhPHjx7No0SL+/ve/s2fPHhISEpqcv2bNGk6fPs3gwYOx2Wy8++673HfffaxatYopU6YA8PTTT5OVlcWrr75Kv379ePTRR9mxYwe7du3C4fjm9UsUgES6Xv0U/OKK6qah5JxgY7dY6kKJGYvZ5DcrV7vdbvJLqzyBKL/ME4oKzrA3v6zZgeT1esWE1nWheVqN0utajaICcAyVSHv4VQAaP34848aN44UXXgDA5XKRmprKz3/+cx566KFWXWP06NFMmzaNhQsX4na7SUlJ4b777uP+++8HoKSkhMTERJYtW8b111//jddTABKRruR2uykqq2ZfwRn2F5TVhSPPflFZdYufS4pyeLvQ6rvTBiZEEBMWnEsQuFxuzlTVUlxRzemKGoorqimuqOF0RTUV1U5CQyyE2iyE2Sw4Qjyv9cdCQyyE2azefZtVA9j9kd88Db66upotW7Ywf/587zGz2UxmZibr16//xs+73W4+/vhj9uzZw9NPPw3AoUOHyMvLIzMz03tedHQ048ePZ/369c0GoKqqKqqqGhZ7Ky0tbc9tiYhcEJPJRM9IOz0j7UwcEO/z3qnyak8oqms1qt/PL60ir7SSvNJKPt1X5POZ+Ai7twvN26WWGEGPcJtftJa53W7O1jibhJjiup89x+v3qyk+6/m55GwNznMXqWojq9nUEI4aBSVPaPIEpbBz3m8crBr2rT7Xqf+M3Wr2i7+LQGZoACoqKsLpdJKYmOhzPDExkd27d7f4uZKSEnr16kVVVRUWi4Xf/va3XHnllQDk5eV5r3HuNevfO1dWVhaPP/54e25FRKRTxIXbuKRfHJf0i/M5XnK2hv11XWgN3WllfF18lqKyKorKqlh/8KTPZ2LDQrxdaI0HYSdE2jvtl3F1rYvis3Uhprw+rDQTYup+rg801bUXPh6sXpjNQkxoCDFhNmLDQ4gJtRFqs1BV6+JsdS0V1U7O1jg5W/daUe2kstpJRY3TG6Bq61qTWhqz1V5mE80ELCuhIWbf0FTfUlW3H263khBpJynaQVKUgx4RdixaX6tN/HJkXWRkJNu2baOsrIzs7GzmzZtH//79ufzyy9t0vfnz5zNv3jzvz6WlpaSmpnZQtSIiHS86NMS7fEBjZVW1HCjwBKJ9BWfqBmGXkXu6gtMVNWw8fIqNh0/5fCbSYW0yK21gYiQp0Q5vMHK63JSerWnU4lLN6fKaRoHmnBBTF27Kz1n+4EKEWEzEhNmICQ0hNsxGTFgIMWH1+7a6/ZBG+zaiQ0PaPJvO7XZT43Q3Cka13qDUbGiqP6faxdma2ibnNZzTcKx+oL/LDeXVznb9+YCnpSoh0k5iXSBKjHJ4w1Hj/VCbZhiey9AAFB8fj8ViIT8/3+d4fn4+SUlJLX7ObDaTnp4OQEZGBjk5OWRlZXH55Zd7P5efn09ycrLPNTMyMpq9nt1ux263t/NuRESMF2G3Mio1hlGpMT7Hz1Y7OVBY1qQ77fDJcs5U1rL1aDFbjxb7fCbcZiE+0k5xRQ2llTVtXn7AZPIEtvqAEvsNISam7udwm6VLu4lMJhM2q2cWXzSdM8C81unyhKHmWqDqWqE8+7WcrfG0WJ1tFKLOVNZSUNf1WXimilqXm+MllRwvqTzv90Y5rCRF14Wi+mB0TlCKC7MF1WrthgYgm83GmDFjyM7OZtasWYBnEHR2djZ33XVXq6/jcrm8Y3j69etHUlIS2dnZ3sBTWlrKhg0buOOOOzr6FkRE/EKozcLwXtEM7xXtc7yyxsnhk+U+s9L25ZdxqKjc00JxssLn/Ai71RNiwhsHGhuxYSFE173GhtmIDms4HukIUTdNHavFTKTF3CGroNc6XRSWVZFXUkl+aSV5JZXklVZ59/PrglJFtZPSylpKK8vYm990lfZ6IRYTCZHnBiO7T2hKjHIEzHpVhneBzZs3j5tvvpmxY8dyySWXsGjRIsrLy5k7dy4Ac+bMoVevXmRlZQGe8Tpjx45lwIABVFVV8d577/HHP/6RF198EfAk+HvuuYcnn3ySgQMHeqfBp6SkeEOWiIh4OEIsDE6KYnCS74yZGqeLIyfLOVVe4+16igm1aXZUN2K1mEmODiU5OrTFc9xuz1im/BJPGGocjPJKPGHpREklJ8urqHG6+br4LF8XN12ktLGYsJCGVqQWut1iw0K6/SBvwwPQ7NmzKSwsZMGCBeTl5ZGRkcHq1au9g5iPHj2K2dzwL1x5eTk/+9nPOHbsGKGhoQwePJjXX3+d2bNne8958MEHKS8v5/bbb6e4uJhJkyaxevXqVq0BJCIiEGIxk54QaXQZ0k4mk4koRwhRjhAGJrb891njdFFwxrc1qSEoNexX1ri8Y712551p8Xo2q5nEKHtDKGrUglQflhKi7IY+FsbwdYC6I60DJCIi4svtdlN6tta7/EJ+iaf1KK/UNzSdLG957arGbp7Ql8dnDu/QGv1mHSARERHxDyaTieiwEKLDQhiU1HJrUlWtk4L6sUg+LUhVDV1xpZUkRhvbK6MAJCIiIh3GbrWQGhdGalxYi+e43W5qO2jRyrZSABIREZEuZTKZCLEYO0haw/lFREQk6CgAiYiISNBRABIREZGgowAkIiIiQUcBSERERIKOApCIiIgEHQUgERERCToKQCIiIhJ0FIBEREQk6CgAiYiISNBRABIREZGgowAkIiIiQUcBSERERIKOngbfDLfbDUBpaanBlYiIiEhr1f/erv89fj4KQM04c+YMAKmpqQZXIiIiIhfqzJkzREdHn/cck7s1MSnIuFwujh8/TmRkJCaTyehyuqXS0lJSU1PJzc0lKirK6HKCnv4+uhf9fXQv+vvoXjrz78PtdnPmzBlSUlIwm88/ykctQM0wm8307t3b6DL8QlRUlP6D0o3o76N70d9H96K/j+6ls/4+vqnlp54GQYuIiEjQUQASERGRoKMAJG1it9t57LHHsNvtRpci6O+ju9HfR/eiv4/upbv8fWgQtIiIiAQdtQCJiIhI0FEAEhERkaCjACQiIiJBRwFIREREgo4CkLRaVlYW48aNIzIykoSEBGbNmsWePXuMLkvq/PrXv8ZkMnHPPfcYXUpQ+/rrr7nxxhvp0aMHoaGhjBgxgs2bNxtdVlByOp08+uij9OvXj9DQUAYMGMDChQtb9Zwoab9//etfzJgxg5SUFEwmEytWrPB53+12s2DBApKTkwkNDSUzM5N9+/Z1WX0KQNJqa9eu5c477+Tzzz/nww8/pKamhquuuory8nKjSwt6mzZt4qWXXmLkyJFGlxLUTp8+zaWXXkpISAjvv/8+u3bt4tlnnyU2Ntbo0oLS008/zYsvvsgLL7xATk4OTz/9NM888wz/93//Z3RpQaG8vJxRo0axePHiZt9/5plneP7551myZAkbNmwgPDycKVOmUFlZ2SX1aRq8tFlhYSEJCQmsXbuW73znO0aXE7TKysoYPXo0v/3tb3nyySfJyMhg0aJFRpcVlB566CHWrVvHp59+anQpAkyfPp3ExER+//vfe4/94Ac/IDQ0lNdff93AyoKPyWTi7bffZtasWYCn9SclJYX77ruP+++/H4CSkhISExNZtmwZ119/fafXpBYgabOSkhIA4uLiDK4kuN15551MmzaNzMxMo0sJeitXrmTs2LH86Ec/IiEhgYsvvpilS5caXVbQmjhxItnZ2ezduxeAL7/8ks8++4yrr77a4Mrk0KFD5OXl+fx3Kzo6mvHjx7N+/fouqUEPQ5U2cblc3HPPPVx66aUMHz7c6HKC1l//+le2bt3Kpk2bjC5FgIMHD/Liiy8yb948Hn74YTZt2sQvfvELbDYbN998s9HlBZ2HHnqI0tJSBg8ejMViwel08qtf/YobbrjB6NKCXl5eHgCJiYk+xxMTE73vdTYFIGmTO++8k6+++orPPvvM6FKCVm5uLnfffTcffvghDofD6HIEz/8YjB07lqeeegqAiy++mK+++oolS5YoABngb3/7G3/605/485//zLBhw9i2bRv33HMPKSkp+vsQdYHJhbvrrrt49913+eSTT+jdu7fR5QStLVu2UFBQwOjRo7FarVitVtauXcvzzz+P1WrF6XQaXWLQSU5OZujQoT7HhgwZwtGjRw2qKLg98MADPPTQQ1x//fWMGDGCm266iXvvvZesrCyjSwt6SUlJAOTn5/scz8/P977X2RSApNXcbjd33XUXb7/9Nh9//DH9+vUzuqSgNnnyZHbs2MG2bdu829ixY7nhhhvYtm0bFovF6BKDzqWXXtpkaYi9e/fSt29fgyoKbhUVFZjNvr/mLBYLLpfLoIqkXr9+/UhKSiI7O9t7rLS0lA0bNjBhwoQuqUFdYNJqd955J3/+85955513iIyM9PbTRkdHExoaanB1wScyMrLJ+Kvw8HB69OihcVkGuffee5k4cSJPPfUU1113HRs3buTll1/m5ZdfNrq0oDRjxgx+9atf0adPH4YNG8YXX3zBc889x09/+lOjSwsKZWVl7N+/3/vzoUOH2LZtG3FxcfTp04d77rmHJ598koEDB9KvXz8effRRUlJSvDPFOp1bpJWAZrc//OEPRpcmdS677DL33XffbXQZQe0f//iHe/jw4W673e4ePHiw++WXXza6pKBVWlrqvvvuu919+vRxOxwOd//+/d2PPPKIu6qqyujSgsInn3zS7O+Mm2++2e12u90ul8v96KOPuhMTE912u909efJk9549e7qsPq0DJCIiIkFHY4BEREQk6CgAiYiISNBRABIREZGgowAkIiIiQUcBSERERIKOApCIiIgEHQUgERERCToKQCIirbBmzRpMJhPFxcVGlyIiHUABSERERIKOApCIiIgEHQUgEfELLpeLrKws+vXrR2hoKKNGjeKNN94AGrqnVq1axciRI3E4HHzrW9/iq6++8rnGm2++ybBhw7Db7aSlpfHss8/6vF9VVcV//dd/kZqait1uJz09nd///vc+52zZsoWxY8cSFhbGxIkTmzz9XUT8gwKQiPiFrKwsXnvtNZYsWcLOnTu59957ufHGG1m7dq33nAceeIBnn32WTZs20bNnT2bMmEFNTQ3gCS7XXXcd119/PTt27OCXv/wljz76KMuWLfN+fs6cOfzlL3/h+eefJycnh5deeomIiAifOh555BGeffZZNm/ejNVq1ZPFRfyUHoYqIt1eVVUVcXFxfPTRR0yYMMF7/NZbb6WiooLbb7+dK664gr/+9a/Mnj0bgFOnTtG7d2+WLVvGddddxw033EBhYSEffPCB9/MPPvggq1atYufOnezdu5dBgwbx4YcfkpmZ2aSGNWvWcMUVV/DRRx8xefJkAN577z2mTZvG2bNncTgcnfynICIdSS1AItLt7d+/n4qKCq688koiIiK822uvvcaBAwe85zUOR3FxcQwaNIicnBwAcnJyuPTSS32ue+mll7Jv3z6cTifbtm3DYrFw2WWXnbeWkSNHeveTk5MBKCgoaPc9ikjXshpdgIjINykrKwNg1apV9OrVy+c9u93uE4LaKjQ0tFXnhYSEePdNJhPgGZ8kIv5FLUAi0u0NHToUu93O0aNHSU9P99lSU1O9533++efe/dOnT7N3716GDBkCwJAhQ1i3bp3PddetW8dFF12ExWJhxIgRuFwunzFFIhK41AIkIt1eZGQk999/P/feey8ul4tJkyZRUlLCunXriIqKom/fvgA88cQT9OjRg8TERB555BHi4+OZNWsWAPfddx/jxo1j4cKFzJ49m/Xr1/PCCy/w29/+FoC0tDRuvvlmfvrTn/L8888zatQojhw5QkFBAdddd51Rty4inUQBSET8wsKFC+nZsydZWVkcPHiQmJgYRo8ezcMPP+ztgvr1r3/N3Xffzb59+8jIyOAf//gHNpsNgNGjR/O3v/2NBQsWsHDhQpKTk3niiSe45ZZbvN/x4osv8vDDD/Ozn/2MkydP0qdPHx5++GEjbldEOplmgYmI36ufoXX69GliYmKMLkdE/IDGAImIiEjQUQASERGRoKMuMBEREQk6agESERGRoKMAJCIiIkFHAUhERESCjgKQiIiIBB0FIBEREQk6CkAiIiISdBSAREREJOgoAImIiEjQUQASERGRoPP/AXjvXGaK7nRLAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Losses\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_loss) + 1)), arr_train_loss, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_loss) + 1)), arr_val_loss, label=\"val\")\n",
    "\n",
    "    plt.title(\"Loss\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"loss\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8bda887e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAAHHCAYAAABQhTneAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAA9hAAAPYQGoP6dpAABT1klEQVR4nO3deXxU1f3/8dfMJJnsG5CEQCDsiwIBIgiIS42CKIqtBZQKYmu/P5cqRrQuX6GKNWorRUSlYv3iAohatRQriqkgIAKCCGrYl4CQhC072Wbm98clA0MSDNluJvN+Ph73MTd37r3zuYk6b88591yLy+VyISIiIuIjrGYXICIiItKUFH5ERETEpyj8iIiIiE9R+BERERGfovAjIiIiPkXhR0RERHyKwo+IiIj4FIUfERER8SkKPyIiIuJTFH5ERETEpyj8iIhXmT9/PhaLBYvFwurVq6u873K5SEhIwGKxcN1111V5Pzc3l8DAQCwWCxkZGdV+xm233eb+jLOXwMDABr8mEWlafmYXICJSF4GBgSxcuJBLLrnEY/vKlSs5ePAgdru92uPee+89LBYLcXFxLFiwgKeeeqra/ex2O6+99lqV7Tabrf7Fi4ipFH5ExCuNGjWK9957j9mzZ+Pnd/o/ZQsXLmTgwIEcPXq02uPefvttRo0aRceOHVm4cGGN4cfPz4/f/OY3jVK7iJhL3V4i4pVuvvlmjh07xvLly93bysrKeP/997nllluqPSYzM5NVq1Yxfvx4xo8fz969e/nqq6+aqmQRaSYUfkTEKyUmJjJkyBAWLVrk3vbJJ5+Ql5fH+PHjqz1m0aJFhISEcN111zFo0CC6dOnCggULavyMo0ePVlny8/Mb/FpEpGkp/IiI17rlllv46KOPOHnyJAALFizgsssuIz4+vtr9FyxYwA033EBQUBAA48aN491336WioqLKvkVFRbRp06bKMnbs2Ma7IBFpEgo/IuK1xo4dy8mTJ1m6dCkFBQUsXbq0xi6vLVu2sHXrVm6++Wb3tptvvpmjR4/y6aefVtk/MDCQ5cuXV1meeeaZRrseEWkaGvAsIl6rTZs2pKSksHDhQoqLi3E4HNx0003V7vv2228TEhJC586d2bVrF2AEnMTERBYsWMC1117rsb/NZiMlJaXRr0FEmp7Cj4h4tVtuuYU77riDrKwsrrnmGiIjI6vs43K5WLRoEUVFRfTu3bvK+zk5ORQWFhIaGtoEFYuI2RR+RMSr3XjjjfzP//wPX3/9NYsXL652n8q5f5588kl69erl8d6JEyf4/e9/z0cffaRb20V8hMKPiHi10NBQXnnlFfbt28fo0aOr3aeyy+vBBx+sdobmv/zlLyxYsEDhR8RHKPyIiNebNGlSje+Vlpbyz3/+k6uuuqrGR1Ncf/31vPDCC+Tk5BATEwNARUUFb7/9drX733jjjYSEhNS/cBExhcKPiLRoH3/8Mbm5uTW2CgGMHj2a559/nnfeeYd7770XMELTrbfeWu3+e/fuVfgR8WIWl8vlMrsIERERkaaieX5ERETEpyj8iIiIiE9R+BERERGfovAjIiIiPkXhR0RERHyKwo+IiIj4FM3zUw2n08mhQ4cICwvDYrGYXY6IiIjUgsvloqCggPj4eKzWmtt3FH6qcejQIRISEswuQ0REROrgwIEDtG/fvsb3FX6qERYWBhi/vPDwcJOrERERkdrIz88nISHB/T1eE4WfalR2dYWHhyv8iIiIeJmfG7KiAc8iIiLiUxR+RERExKco/IiIiIhP0ZgfERGRJuRwOCgvLze7DK/k7++PzWar93kUfkRERJqAy+UiKyuL3Nxcs0vxapGRkcTFxdVrHj6FHxERkSZQGXxiYmIIDg7WJLrnyeVyUVxcTE5ODgBt27at87kUfkRERBqZw+FwB59WrVqZXY7XCgoKAiAnJ4eYmJg6d4FpwLOIiEgjqxzjExwcbHIl3q/yd1ifcVMKPyIiIk1EXV311xC/Q4UfERER8SkKPyIiItIkEhMTmTVrltllaMCziIiI1Ozyyy8nKSmpQULLhg0bCAkJqX9R9aSWn6bkcsHeL6Gi1OxKREREGoTL5aKioqJW+7Zp06ZZDPpW+GlK706EN0bD5oVmVyIiIvKzbrvtNlauXMkLL7yAxWLBYrEwf/58LBYLn3zyCQMHDsRut7N69Wp2797NDTfcQGxsLKGhoVx00UV8/vnnHuc7u9vLYrHw2muvceONNxIcHEy3bt1YsmRJo1+Xwk9T6jjUeF0zCxy1S8kiItIyuVwuissqTFlcLletanzhhRcYMmQId9xxB4cPH+bw4cMkJCQA8PDDD/PMM8+QkZFB3759KSwsZNSoUaSnp/Ptt98ycuRIRo8eTWZm5jk/44knnmDs2LFs2bKFUaNGMWHCBI4fP17v3++5aMxPUxowEb78C5zYBz98CH1/bXZFIiJikpPlDnpP+9SUz/7xyREEB/x8BIiIiCAgIIDg4GDi4uIA2LZtGwBPPvkkV111lXvf6Oho+vXr5/55xowZfPjhhyxZsoR77rmnxs+47bbbuPnmmwF4+umnmT17NuvXr2fkyJF1urbaUMtPUwoIgYvvMtZXzwSn09x6RERE6ig5Odnj58LCQqZOnUqvXr2IjIwkNDSUjIyMn2356du3r3s9JCSE8PBw9yMsGotafpraRb+DNS9Azo+w4xPoea3ZFYmIiAmC/G38+OQI0z67vs6+a2vq1KksX76cv/71r3Tt2pWgoCBuuukmysrKznkef39/j58tFgvORm4cUPhpakGRRgBaPRNWPQ89RoFm/BQR8TkWi6VWXU9mCwgIwOFw/Ox+a9as4bbbbuPGG28EjJagffv2NXJ1daNuLzNcfBf4BcFPG2HvSrOrERERqVFiYiLr1q1j3759HD16tMZWmW7duvHBBx+wefNmvvvuO2655ZZGb8GpK4UfM4S2gYGTjPUv/2puLSIiIucwdepUbDYbvXv3pk2bNjWO4Zk5cyZRUVEMHTqU0aNHM2LECAYMGNDE1daOxVXb+90ayUsvvcRf/vIXsrKy6NevHy+++CKDBg362ePeeecdbr75Zm644QY++ugj9/bbbruNN954w2PfESNGsGzZslrXlJ+fT0REBHl5eYSHh9f6uPOSdxBe6AfOCvjtckj4+WsWERHvVFJSwt69e+nUqROBgYFml+PVzvW7rO33t6ktP4sXLyY1NZXp06ezadMm+vXrx4gRI352lPe+ffuYOnUqw4cPr/b9kSNHuucjOHz4MIsWLWqM8usnoj30G2+sr5ppbi0iIiI+xNTwM3PmTO644w4mT55M7969mTt3LsHBwbz++us1HuNwOJgwYQJPPPEEnTt3rnYfu91OXFyce4mKimqsS6ifS1LBYjXu+sr63uxqREREfIJp4aesrIyNGzeSkpJyuhirlZSUFNauXVvjcU8++SQxMTH89re/rXGfFStWEBMTQ48ePbjzzjs5duxYg9beYFp1gd5jjPXVav0RERFpCqaFn6NHj+JwOIiNjfXYHhsbS1ZWVrXHrF69mn/84x/MmzevxvOOHDmSN998k/T0dJ599llWrlzJNddcc87b9EpLS8nPz/dYmszwVOP1hw/h2O6m+1wREREf5TV3exUUFHDrrbcyb948WrduXeN+48eP5/rrr6dPnz6MGTOGpUuXsmHDBlasWFHjMWlpaURERLiXyueWNIm4PtBtBLicxjO/REREpFGZFn5at26NzWYjOzvbY3t2drb7+SFn2r17N/v27WP06NH4+fnh5+fHm2++yZIlS/Dz82P37upbTTp37kzr1q3ZtWtXjbU88sgj5OXluZcDBw7U7+LO16VTjdfNiyDvp6b9bBERER9jWvgJCAhg4MCBpKenu7c5nU7S09MZMmRIlf179uzJ1q1b2bx5s3u5/vrrueKKK9i8eXONrTUHDx7k2LFjtG3btsZa7HY74eHhHkuTShgEicPBWQ5fvdi0ny0iIuJjTJ1XOzU1lUmTJpGcnMygQYOYNWsWRUVFTJ48GYCJEyfSrl070tLSCAwM5MILL/Q4PjIyEsC9vbCwkCeeeIJf/epXxMXFsXv3bh566CG6du3KiBHmPD+l1oanwr5VsHG+0RIUUnPXnoiIiNSdqeFn3LhxHDlyhGnTppGVlUVSUhLLli1zD4LOzMzEaq1945TNZmPLli288cYb5ObmEh8fz9VXX82MGTOw2+2NdRkNo/MVEN8fDn0LX78CVz5udkUiIiItkukzPDdHTTLDc3UylsLiCWCPgPu3QmBE0322iIg0Gl+e4TkxMZEpU6YwZcqUBjmf18/wLGfpMQra9ITSPNjwmtnViIiItEgKP82J1WrM+gyw9mUoKza3HhERkRZI4ae5ufBXENkRio/Ct2+ZXY2IiPiwV199lfj4eJxOp8f2G264gdtvv53du3dzww03EBsbS2hoKBdddBGff/65SdXWnsJPc2Pzg0umGOtrXoCKMlPLERGRRuJyQVmROUsth/v++te/5tixY3zxxRfubcePH2fZsmVMmDCBwsJCRo0aRXp6Ot9++y0jR45k9OjRZGZmNtZvrUGYereX1KDfLbDiWcj/CbYshgG3ml2RiIg0tPJieDrenM9+9BAEhPzsblFRUVxzzTUsXLiQK6+8EoD333+f1q1bc8UVV2C1WunXr597/xkzZvDhhx+yZMkS7rnnnkYrv77U8tMc+QfC0FP/0Kz+Gzhrfi6ZiIhIY5owYQL//Oc/KS0tBWDBggWMHz8eq9VKYWEhU6dOpVevXkRGRhIaGkpGRoZafqSOBk6GVc/D8d3w47/gwl+aXZGIiDQk/2CjBcasz66l0aNH43K5+Pjjj7noootYtWoVf/vb3wCYOnUqy5cv569//Stdu3YlKCiIm266ibKy5j1kQ+GnubKHwuA7YcXTsGomXHAjWCxmVyUiIg3FYqlV15PZAgMD+eUvf8mCBQvYtWsXPXr0YMCAAQCsWbOG2267jRtvvBEwnrSwb98+E6utHXV7NWeD7oCAUMjeCjs/M7saERHxURMmTODjjz/m9ddfZ8KECe7t3bp144MPPmDz5s1899133HLLLVXuDGuOFH6as+BoSL7dWP/yr7UenS8iItKQfvGLXxAdHc327du55ZZb3NtnzpxJVFQUQ4cOZfTo0YwYMcLdKtSc6fEW1TDt8RbVKciGWX3AUQqTlkKn4ebWIyIi582XH2/R0PR4C18QFnv6VvdVz5tbi4iISAug8OMNht4LFhvs+QJ+2mh2NSIiIl5N4ccbRHWEvmON9VUzza1FRETEyyn8eItL7gcssG0p5GSYXY2IiIjXUvjxFm16QK/Rxvrqv5lbi4iI1InuMaq/hvgdKvx4k+GpxuvW9+H4XnNrERGRWvP39weguLjY5Eq8X+XvsPJ3Whea4dmbxPeHrimw63P4ajZcpxYgERFvYLPZiIyMJCcnB4Dg4GAsmrX/vLhcLoqLi8nJySEyMhKbzVbncyn8eJvhDxjh59u34dKHILyt2RWJiEgtxMXFAbgDkNRNZGSk+3dZVwo/3qbjUOgwBDLXwto5MOLPZlckIiK1YLFYaNu2LTExMZSXl5tdjlfy9/evV4tPJYUfbzT8AVhwE3zzf8Z6cLTZFYmISC3ZbLYG+QKXutOAZ2/UNQXi+kJ5Eayba3Y1IiIiXkXhxxtZLEaLDxjhp7TA3HpERES8iMKPt+o1Glp1g5I8+OZ1s6sRERHxGgo/3spqOzXrM/DVHCgvMbceERERL6Hw4836joWIBCjKgW/fMrsaERERr6Dw481s/jDsPmN9zWxw6NZJERGRn6Pw4+36/wZC2kBepvHYCxERETknhR9v5x8EQ+421lfPBKfT3HpERESaOYWfliD5txAYAUd3wLZ/m12NiIhIs6bw0xIEhsOg/zHWVz0PLpe59YiIiDRjCj8txeD/B/7BcPg72J1udjUiIiLNlsJPSxHSCpJvN9a/fN7cWkRERJoxhZ+WZMjdYAuAzK9g/1dmVyMiItIsKfy0JOHxkHSLsb5qprm1iIiINFMKPy3NsPvAYoVdy43xPyIiIuJB4aelie4MF95krK/S2B8REZGzKfy0RJUPPP1xCRzZYW4tIiIizYzCT0sU2xt6XAu4YM0ss6sRERFpVhR+WqrhDxivWxZDbqa5tYiIiDQjCj8tVfuB0PlycFYYT3wXERERQOGnZats/dn0JhRkm1uLiIhIM6Hw05IlDof2F4GjFL5+2exqREREmgWFn5bMYjnd+rPhH3DyhLn1iIiINAMKPy1d95EQeyGUFcD6eWZXIyIiYjqFn5bOYjk978/XL0Npobn1iIiImEzhxxdccKMx8/PJE7DpDbOrERERMZXCjy+w2k63/nz1IlSUmluPiIiIiRR+fEXf8RDeDgoOw+aFZlcjIiJiGoUfX+EXAEP/YKyvmQWOClPLERERMYvCjy8ZMBGCW8GJffDDB2ZXIyIiYgrTw89LL71EYmIigYGBDB48mPXr19fquHfeeQeLxcKYMWM8trtcLqZNm0bbtm0JCgoiJSWFnTt3NkLlXiggBC6+y1hfNROcTnPrERERMYGp4Wfx4sWkpqYyffp0Nm3aRL9+/RgxYgQ5OTnnPG7fvn1MnTqV4cOHV3nvueeeY/bs2cydO5d169YREhLCiBEjKCkpaazL8C4X/Q7s4XAkA3Z8YnY1IiIiTc7U8DNz5kzuuOMOJk+eTO/evZk7dy7BwcG8/vrrNR7jcDiYMGECTzzxBJ07d/Z4z+VyMWvWLP73f/+XG264gb59+/Lmm29y6NAhPvroo0a+Gi8RFGkEIIBVz4PLZWo5IiIiTc208FNWVsbGjRtJSUk5XYzVSkpKCmvXrq3xuCeffJKYmBh++9vfVnlv7969ZGVleZwzIiKCwYMHn/OcPufiu8AvCH7aCHtWmF2NiIhIkzIt/Bw9ehSHw0FsbKzH9tjYWLKysqo9ZvXq1fzjH/9g3rzqH9NQedz5nBOgtLSU/Px8j6VFC20DAycZ66ueN7cWERGRJmb6gOfaKigo4NZbb2XevHm0bt26Qc+dlpZGRESEe0lISGjQ8zdLQ/8AVj/YtwoO1G6QuYiISEtgWvhp3bo1NpuN7Oxsj+3Z2dnExcVV2X/37t3s27eP0aNH4+fnh5+fH2+++SZLlizBz8+P3bt3u4+r7TkrPfLII+Tl5bmXAwcONMAVNnMR7aHfeGN91UxzaxEREWlCpoWfgIAABg4cSHp6unub0+kkPT2dIUOGVNm/Z8+ebN26lc2bN7uX66+/niuuuILNmzeTkJBAp06diIuL8zhnfn4+69atq/aclex2O+Hh4R6LTxh2P1isxl1fWd+bXY2IiEiT8DPzw1NTU5k0aRLJyckMGjSIWbNmUVRUxOTJkwGYOHEi7dq1Iy0tjcDAQC688EKP4yMjIwE8tk+ZMoWnnnqKbt260alTJx5//HHi4+OrzAckQOuu0HuMMeHh6plwU8132YmIiLQUpoafcePGceTIEaZNm0ZWVhZJSUksW7bMPWA5MzMTq/X8GqceeughioqK+P3vf09ubi6XXHIJy5YtIzAwsDEuwfsNTzXCzw8fwhWPQasuZlckIiLSqCwulyZ6OVt+fj4RERHk5eX5RhfYgrGw81PofyvcMMfsakREROqktt/fXnO3lzSiS6car9+9A3kHza1FRESkkSn8CCQMgsTh4CyHr9TyIyIiLZvCjxiGpxqvG+dD0VFTSxEREWlMCj9i6HwFxPeHipPw9ctmVyMiItJoFH7EYLHA8FNjf9bPg5I8c+sRERFpJAo/clqPUdCmJ5Tmw4bXzK5GRESkUSj8yGlWK1xyauzP2pehrNjcekRERBqBwo94uvBXENkRio/CpjfNrkZERKTBKfyIJ5sfXDLFWP9qNlSUmVqOiIhIQ1P4kar63QKhcZD/E2xZbHY1IiIiDUrhR6ryD4Sh9xjrq/8GToe59YiIiDQghR+p3sDJEBQFx3fDjx+ZXY2IiEiDUfiR6tlDYfCdxvqqmaDn34qISAuh8CM1G3QHBIRC9vew8zOzqxEREWkQCj9Ss+BoSL7dWP/yr2r9ERGRFkHhR85tyD1gs8PB9bBvtdnViIiI1JvCj5xbWCwMuNVYX/W8ubWIiIg0AIUf+XlD7wWLDfZ8AT9tNLsaERGRelH4kZ8X1RH6jjXWV800txYREZF6UviR2rnkfsAC25ZCTobZ1YiIiNSZwo/UTpse0Gu0sb76b+bWIiIiUg8KP1J7w1ON163vw/G95tYiIiJSRwo/Unvx/aHLleBywJoXzK5GRESkThR+5PxcOtV43bwA8g+bW4uIiEgdKPzI+ek4FDoMAUcZrP+72dWIiIicN4UfOX+Dfm+8/vCRHnkhIiJeR+FHzl+3q41HXpzYC9k/mF2NiIjIeVH4kfNnD4WuVxrrGf82txYREZHzpPAjdVM554/Cj4iIeBmFH6mb7iON533l/ADHdptdjYiISK0p/EjdBEdDp+HG+ral5tYiIiJyHhR+pO56Xme8qutLRES8iMKP1F1l+Dm4AfIPmVuLiIhILSn8SN2Ft4X2g4z1bR+bW4uIiEgtKfxI/bjv+lpibh0iIiK1pPAj9dPrVNfXvjVQfNzcWkRERGpB4UfqJ7ozxPYxnvS+/ROzqxEREflZCj9Sf5rwUEREvIjCj9RfZdfX7v9CaYG5tYiIiPwMhR+pv5jeRveXoxR2Lje7GhERkXNS+JH6s1jU9SUiIl5D4UcaRq/rjdedn0F5ibm1iIiInIPCjzSM+AEQFg9lhbB3pdnViIiI1EjhRxqG1Xp64LMmPBQRkWZM4UcaTuWzvrb9BxwV5tYiIiJSA4UfaTgdh0FQFJw8DplfmV2NiIhItRR+pOHY/KDHtca67voSEZFmSuFHGpb7lvel4HSaW4uIiEg1FH6kYXW+HAJCoeAQHNpkdjUiIiJVKPxIw/IPhG5XG+vq+hIRkWZI4Ucanrvrawm4XObWIiIichbTw89LL71EYmIigYGBDB48mPXr19e47wcffEBycjKRkZGEhISQlJTEW2+95bHPbbfdhsVi8VhGjhzZ2JchZ+p2FdjscHwP5GSYXY2IiIgHU8PP4sWLSU1NZfr06WzatIl+/foxYsQIcnJyqt0/Ojqaxx57jLVr17JlyxYmT57M5MmT+fTTTz32GzlyJIcPH3YvixYtaorLkUr2MOhyhbGuri8REWlmTA0/M2fO5I477mDy5Mn07t2buXPnEhwczOuvv17t/pdffjk33ngjvXr1okuXLtx333307duX1atXe+xnt9uJi4tzL1FRUU1xOXImPehURESaKdPCT1lZGRs3biQlJeV0MVYrKSkprF279mePd7lcpKens337di699FKP91asWEFMTAw9evTgzjvv5NixY+c8V2lpKfn5+R6L1FP3a8Big+ytcHyv2dWIiIi4mRZ+jh49isPhIDY21mN7bGwsWVlZNR6Xl5dHaGgoAQEBXHvttbz44otcddVV7vdHjhzJm2++SXp6Os8++ywrV67kmmuuweFw1HjOtLQ0IiIi3EtCQkL9L9DXhbSCxGHG+ral5tYiIiJyBj+zCzhfYWFhbN68mcLCQtLT00lNTaVz585cfvnlAIwfP969b58+fejbty9dunRhxYoVXHnlldWe85FHHiE1NdX9c35+vgJQQ+h1Pez90uj6GvoHs6sREREBTAw/rVu3xmazkZ2d7bE9OzubuLi4Go+zWq107doVgKSkJDIyMkhLS3OHn7N17tyZ1q1bs2vXrhrDj91ux2631+1CpGY9r4X/TIUD66AgC8Jq/ruKiIg0FdO6vQICAhg4cCDp6enubU6nk/T0dIYMGVLr8zidTkpLS2t8/+DBgxw7doy2bdvWq16pg/B4aJdsrKvrS0REmglT7/ZKTU1l3rx5vPHGG2RkZHDnnXdSVFTE5MmTAZg4cSKPPPKIe/+0tDSWL1/Onj17yMjI4Pnnn+ett97iN7/5DQCFhYU8+OCDfP311+zbt4/09HRuuOEGunbtyogRI0y5Rp+nu75ERKSZMXXMz7hx4zhy5AjTpk0jKyuLpKQkli1b5h4EnZmZidV6Op8VFRVx1113cfDgQYKCgujZsydvv/0248aNA8Bms7FlyxbeeOMNcnNziY+P5+qrr2bGjBnq1jJLr9Hw+XTYuwqKj0NwtNkViYiIj7O4XHr+wNny8/OJiIggLy+P8PBws8vxfi8PhZwfYMwrkHSL2dWIiEgLVdvvb9MfbyE+wN31pXE/IiJiPoUfaXyV4Wd3OpQWmluLiIj4PIUfaXyxF0BUIlSUwK7Pza5GRER8nMKPND6LRXd9iYhIs6HwI02j1/XG645PoaLmeZlEREQam8KPNI12yRAaB2UFsGel2dWIiIgPU/iRpmG1Qq/rjPVt6voSERHzKPxI06kc97PtY3A6zK1FRER8lsKPNJ2OwyAwEoqPQeZas6sREREfpfAjTcfmDz1GGeu660tEREyi8CNN68xb3vVkFRERMYHCjzStLleAfwjk/wSHNpldjYiI+CCFH2la/kHQ7SpjXV1fIiJiAoUfaXrq+hIRERPVOfy89dZbDBs2jPj4ePbv3w/ArFmz+Ne//tVgxUkL1e1qsAXAsV1wZLvZ1YiIiI+pU/h55ZVXSE1NZdSoUeTm5uJwGHO2REZGMmvWrIasT1qiwHDofLmxrq4vERFpYnUKPy+++CLz5s3jsccew2azubcnJyezdevWBitOWjB319cSc+sQERGfU6fws3fvXvr3719lu91up6ioqN5FiQ/oMQosVsjaAif2mV2NiIj4kDqFn06dOrF58+Yq25ctW0avXr3qW5P4gpDWxozPABlLza1FRER8il9dDkpNTeXuu++mpKQEl8vF+vXrWbRoEWlpabz22msNXaO0VL1Gw75VsG0pDL3H7GpERMRH1Cn8/O53vyMoKIj//d//pbi4mFtuuYX4+HheeOEFxo8f39A1SkvV81r45CHI/BoKsiEs1uyKRETEB1hcrvpNtFJcXExhYSExMTENVZPp8vPziYiIIC8vj/DwcLPLadlevcKY6fm6v0Hy7WZXIyIiXqy239/1nuQwODi4RQUfaWJnTngoIiLSBOrU7QXw/vvv8+6775KZmUlZWZnHe5s26ZlNUku9rof0J2Dvl3DyBARFmV2RiIi0cHVq+Zk9ezaTJ08mNjaWb7/9lkGDBtGqVSv27NnDNddc09A1SkvWuiu06QXOCtjxqdnViIiID6hT+Hn55Zd59dVXefHFFwkICOChhx5i+fLl3HvvveTl5TV0jdLSqetLRESaUJ3CT2ZmJkOHDgUgKCiIgoICAG699VYWLVrUcNWJb6gMP7vSoUyTZIqISOOqU/iJi4vj+PHjAHTo0IGvv/4aMGZ+rufNY+KL4vpAZEeoOGkEIBERkUZUp/Dzi1/8giVLjGcyTZ48mfvvv5+rrrqKcePGceONNzZogeIDLBZ1fYmISJOp0zw/TqcTp9OJn59xs9jixYtZs2YN3bp14//9v/+Hv79/gxfalDTPjwkyv4bXR4A9HB7cDX4BZlckIiJeplHn+bFarVRUVLB+/XqWLl1KUFAQKSkpdOzYkWXLltW5aPFh7QdBaCyU5hu3vYuIiDSSOs3zs2zZMm699VaOHTtW5T2LxYLD4ah3YeJjrFbjcRffvA4ZS6BbitkViYhIC1Wnlp8//OEPjB07lsOHD7u7wCoXBR+ps8pxP9v/A079cyQiIo2jTuEnOzub1NRUYmP1IEppQInDITACio7AgXVmVyMiIi1UncLPTTfdxIoVKxq4FPF5Nn/ofmqGcN31JSIijaROd3sVFxfz61//mjZt2tCnT58qd3fde++9DVagGXS3l4kylsLiCRCRAFO2GrfBi4iI1EJtv7/rNOB50aJFfPbZZwQGBrJixQosZ3xBWSwWrw8/YqIuvwD/YMg7AIc3Q3x/sysSEZEWpk7dXo899hhPPPEEeXl57Nu3j71797qXPXv2NHSN4ksCgqHrqTu91PUlIiKNoE7hp6ysjHHjxmG11ulwkXPrdb3xmrHU3DpERKRFqlN6mTRpEosXL27oWkQM3a8Gqz8c3Q5HtptdjYiItDB1GvPjcDh47rnn+PTTT+nbt2+VAc8zZ85skOLERwVGQOfLYNfnRtdXmx5mVyQiIi1IncLP1q1b6d/fGIj6/fffe7xn0d050hB6jT4dfi6danY1IiLSgtQp/HzxxRcNXYeIpx7Xwr+nGHd85WZCZAezKxIRkRZCI5aleQptAx2HGusa+CwiIg1I4Uear8pnfemWdxERaUAKP9J89bzOeM1cC4U55tYiIiIthsKPNF+RCadmeHYZT3oXERFpAAo/0rxVtv6o60tERBqIwo80b5WzPe9ZCSdzTS1FRERaBoUfad7adIfWPcBZDjs/M7saERFpARR+pPlz3/W1xNw6RESkRTA9/Lz00kskJiYSGBjI4MGDWb9+fY37fvDBByQnJxMZGUlISAhJSUm89dZbHvu4XC6mTZtG27ZtCQoKIiUlhZ07dzb2ZUhjqgw/u9KhrNjcWkRExOuZGn4WL15Mamoq06dPZ9OmTfTr148RI0aQk1P9bc3R0dE89thjrF27li1btjB58mQmT57Mp59+6t7nueeeY/bs2cydO5d169YREhLCiBEjKCkpaarLkobWth9EdIDyYtj9X7OrERERL2dxuVwusz588ODBXHTRRcyZMwcAp9NJQkICf/jDH3j44YdrdY4BAwZw7bXXMmPGDFwuF/Hx8TzwwANMnWo8DyovL4/Y2Fjmz5/P+PHja3XO/Px8IiIiyMvLIzw8vG4XJw1r2SPw9cvQdzz88u9mVyMiIs1Qbb+/TWv5KSsrY+PGjaSkpJwuxmolJSWFtWvX/uzxLpeL9PR0tm/fzqWXXgrA3r17ycrK8jhnREQEgwcPPuc5S0tLyc/P91ikmans+trxCVSUmVuLiIh4NdPCz9GjR3E4HMTGxnpsj42NJSsrq8bj8vLyCA0NJSAggGuvvZYXX3yRq666CsB93PmeMy0tjYiICPeSkJBQ18uSxpIwGELaQEke7FtldjUiIuLFTB/wfL7CwsLYvHkzGzZs4M9//jOpqamsWLGiXud85JFHyMvLcy8HDhxomGKl4Vht0PNaY10THoqISD2YFn5at26NzWYjOzvbY3t2djZxcXE1Hme1WunatStJSUk88MAD3HTTTaSlpQG4jzvfc9rtdsLDwz0WaYYqu762fQxOh7m1iIiI1zIt/AQEBDBw4EDS09Pd25xOJ+np6QwZMqTW53E6nZSWlgLQqVMn4uLiPM6Zn5/PunXrzuuc0kwlXgr2CCjKgYMbzK5GRES8lJ+ZH56amsqkSZNITk5m0KBBzJo1i6KiIiZPngzAxIkTadeunbtlJy0tjeTkZLp06UJpaSn/+c9/eOutt3jllVcAsFgsTJkyhaeeeopu3brRqVMnHn/8ceLj4xkzZoxZlykNxS8AeoyELYuNrq8OF5tdkYiIeCFTw8+4ceM4cuQI06ZNIysri6SkJJYtW+YesJyZmYnVerpxqqioiLvuuouDBw8SFBREz549efvttxk3bpx7n4ceeoiioiJ+//vfk5ubyyWXXMKyZcsIDAxs8uuTRtDzulPhZwlc/RRYLGZXJCIiXsbUeX6aK83z04yVFcFzXaDiJPzPl8YEiCIiInjBPD8idRIQAl2vNNZ115eIiNSBwo94n17XG68KPyIiUgcKP+J9uo8Aqx8c2QZH9dBaERE5Pwo/4n2CIqHTZca6Wn9EROQ8KfyId+p1nfGq8CMiIudJ4Ue8U49rAQsc2gS5ehyJiIjUnsKPeKew2NOTHG772NxaRETEqyj8iPeqfNaXur5EROQ8KPyI9+p5atxP5ldQdNTcWkRExGso/Ij3iupozPDscsL2/5hdjYiIeAmFH/Fu6voSEZHzpPAj3q3nqfCzZwWU5JlaioiIeAeFH/FubXpAq27gKIOdy82uRkREvIDCj3g3i+WMrq8l5tYiIiJeQeFHvF9l+Nm5HMpPmluLiIg0ewo/4v3i+0N4eygvht1fmF2NiIg0cwo/4v08ur5015eIiJybwo+0DJUPOt3+H3CUm1uLiIg0awo/0jJ0GALBraEkF/atNrsaERFpxhR+pGWw2qDnKGNdXV8iInIOCj/ScvS63njdthScTnNrERGRZkvhR1qOTpeCPRwKs+HgBrOrERGRZkrhR1oOPzt0H2Gsb1PXl4iIVE/hR1qWM295d7nMrUVERJolhR9pWbqmgF8gnNgH2d+bXY2IiDRDCj/SsgSEQJcrjXXd9SUiItVQ+JGWR7M9i4jIOSj8SMvTfQRY/SDnRzi22+xqRESkmVH4aWKFpRVml9DyBUdD4nBjXa0/IiJyFoWfJvT21/sZkpbON/uOm11Ky6euLxERqYHCTxPacjCXgpIKHvlgK2UVmoG4UfW8FrDAT99A3k9mVyMiIs2Iwk8TenRUL1qFBLAzp5C5KzUWpVGFxUHCIGN928fm1iIiIs2Kwk8TigwOYNro3gDM+e8udh8pNLmiFs7d9bXE3DpERKRZUfhpYtf3i+fyHm0oczh55IOtOJ2ahbjR9LzOeN2/BoqOmVuLiIg0Gwo/TcxisTDjhgsJ8rexfu9x3tt4wOySWq7oThDXB1xO2P4fs6sREZFmQuHHBAnRwTxwdXcA/vxxBkcKSk2uqAXrdb3xum2puXWIiEizofBjktuGJnJhu3DySyp4cumPZpfTclWO+9n9XygtMLcWERFpFhR+TOJns/LML/titcC/vzvEF9tyzC6pZWrTE6K7gKMMdn5mdjUiItIMKPyY6MJ2Efz2kk4A/O9H31Ok2Z8bnsWiCQ9FRMSDwo/J7r+qO+0ig/gp9yR/W77D7HJapspxPzs+g/ISc2sRERHTKfyYLDjAj6duvBCA19fsZevBPJMraoHi+0N4Oygvgj1fmF2NiIiYTOGnGbiiRwzX94vH6YKHP9hChUOPvmhQVuvpOX8ydNeXiIivU/hpJh6/rjcRQf78cCif/1uzz+xyWp7KcT/bPwaHxlaJiPgyhZ9mok2YncdG9QJg5vIdHDhebHJFLUyHIRAUDSdPGDM+i4iIz1L4aUZ+ndyeiztHc7LcwWMffY/LpUdfNBibH/QcZazrri8REZ+m8NOMWCwWnr6xDwF+Vr7ccYQl3x0yu6SW5czZnp0aVyUi4qsUfpqZzm1CufcXXQF48t8/cqKozOSKWpBOl0FAGBQchp82ml2NiIiYROGnGfr9pV3oHhvKsaIynv5PhtnltBz+gdD9amM9Y4m5tYiIiGkUfpqhAD8rab/si8UC7208yFe7jppdUstRedfXtqWgMVUiIj5J4aeZGtgxit8M7gjAox9upaTcYXJFLUTXq8Bmh+N7IEcPlBUR8UUKP83YgyN7EBtuZ9+xYub8d5fZ5bQM9lDo8gtjXXd9iYj4JNPDz0svvURiYiKBgYEMHjyY9evX17jvvHnzGD58OFFRUURFRZGSklJl/9tuuw2LxeKxjBw5srEvo1GEB/rzxPXGoy/mrtzN9qwCkytqIfSgUxERn2Zq+Fm8eDGpqalMnz6dTZs20a9fP0aMGEFOTk61+69YsYKbb76ZL774grVr15KQkMDVV1/NTz/95LHfyJEjOXz4sHtZtGhRU1xOoxh5YRxX946lwuni4Q+24HRqnEq99bgGLDbI/h6O7Ta7GhERaWKmhp+ZM2dyxx13MHnyZHr37s3cuXMJDg7m9ddfr3b/BQsWcNddd5GUlETPnj157bXXcDqdpKene+xnt9uJi4tzL1FRUU1xOY3miRsuINTux7eZuSxYt9/scrxfcDQkXmKsb9OzvkREfI1p4aesrIyNGzeSkpJyuhirlZSUFNauXVurcxQXF1NeXk50dLTH9hUrVhATE0OPHj248847OXbs2DnPU1paSn5+vsfSnLSNCOKhkT0AeHbZdrLySkyuqAVwd30p/IiI+BrTws/Ro0dxOBzExsZ6bI+NjSUrK6tW5/jjH/9IfHy8R4AaOXIkb775Junp6Tz77LOsXLmSa665Boej5rul0tLSiIiIcC8JCQl1u6hGNGFwR/p3iKSwtILpS743uxzvV/mU94PrIf+wubWIiEiTMn3Ac10988wzvPPOO3z44YcEBga6t48fP57rr7+ePn36MGbMGJYuXcqGDRtYsWJFjed65JFHyMvLcy8HDhxogis4PzarhbRf9sHPauHTH7JZ9n3tAqLUILwttL/IWF87RwFIRMSHmBZ+Wrdujc1mIzs722N7dnY2cXFx5zz2r3/9K8888wyfffYZffv2Pee+nTt3pnXr1uzaVfOt4na7nfDwcI+lOeoZF87/XNYZgOlLvie/pNzkirxc5bO+1s6BmT3hhST46G74dgEc36tJEEVEWijTwk9AQAADBw70GKxcOXh5yJAhNR733HPPMWPGDJYtW0ZycvLPfs7Bgwc5duwYbdu2bZC6zfaHX3QjsVUw2fml/GXZdrPL8W7Jt8PQe6FtP7BY4cRe2Pw2/OsumJ0EM3vD+7+FDa9BToYehioi0kJYXC7z/vd28eLFTJo0ib///e8MGjSIWbNm8e6777Jt2zZiY2OZOHEi7dq1Iy0tDYBnn32WadOmsXDhQoYNG+Y+T2hoKKGhoRQWFvLEE0/wq1/9iri4OHbv3s1DDz1EQUEBW7duxW6316qu/Px8IiIiyMvLa5atQF/tPsot89ZhscD7/28IAztG//xBcm4leXBgPexfA/u/gp82gfOslrWgaOg49PQS2wdsfubUKyIiVdT2+9vU8AMwZ84c/vKXv5CVlUVSUhKzZ89m8ODBAFx++eUkJiYyf/58ABITE9m/v+qt3tOnT+dPf/oTJ0+eZMyYMXz77bfk5uYSHx/P1VdfzYwZM6oMrD6X5h5+AB587zve23iQ7rGhLP3DcAL8vHb4VvNUVmw8+X3/V0YgOrAeKk567hMQBgmDToWhYdBuAPjVLmCLiEjD85rw0xx5Q/g5UVRGysyVHCsqY+rV3bnnF93MLqllqyiDw9+dbhnK/BpK8zz3sdmNQdQdhxiBqP0g43EaIiLSJBR+6sEbwg/Avzb/xH3vbCbAz8qy+4bTuY2+aJuM02E8GLWyZWj/V1B0xHMfiw3ik063DCUMNiZYFBGRRqHwUw/eEn5cLheT/m8DX+44wsWdo1l0x8VYLBazy/JNLpfxqIzKILT/K8jLrLpfzAWe44bCzn1no4iI1J7CTz14S/gBOHC8mKv+tpKScifP3dSXscnNb4JGn5WbCfvXGoEocy0c3VF1n+gunmEosiMowIqI1InCTz14U/gBePXL3Tz9n21EBPmT/sBltA7VoNtmqTDHCEGVXWVZ3wNn/esX3u6MMDQMWndXGBIRqSWFn3rwtvBT4XBy/Zw1/Hg4nxuS4nlhfH+zS5LaOJkLB9ad6ipbC4c2gbPCc5/gVtBhiBGEOg6FuD5gtZlSrohIc6fwUw/eFn4AthzMZcxLa3C6YP7ki7i8R4zZJcn5KiuCg9+cbhk6+E3V2+vt4cbA6crWofj+ur1eROQUhZ968MbwAzBj6Y/8Y/Ve2kcF8dn9lxIcoAn4vFpFGRzefNbt9fme+/gFnrq9fih0G2HMNaRuMhHxUQo/9eCt4aeotIKr//YlP+We5I7hnXjs2t5mlyQNyemA7O/PuL1+LRQf9dynVVfoOx76joWojubUKSJiEoWfevDW8APwxbYcJs/fgNUCS+65hAvbRZhdkjQWlwuO7jSC0N6VsH2ZZzdZh6HQbxz0HgNBkWZVKSLSZBR+6sGbww/APQs3sXTLYS5sF85Hdw3Dz6ZHX/iEknzI+DdseQf2rsJ9J5nNDj1GGi1CXVPAL8DUMkVEGovCTz14e/g5UlDKlc+vIL+kgv+9the/G97Z7JKkqeUdhK3vwXeL4UjG6e1B0XDhr6DfeGg3UOODRKRFUfipB28PPwCLN2Tyx39uJcjfxmf3X0pCdLDZJYkZXC7I2mKEoK3vQVHO6fdadYW+406ND0o0rUQRkYai8FMPLSH8uFwuxr/6Nev2Huey7m2YP/kiPfrC1zkqYM8Ko1ssY+lZ44OGGEHogjEQFGVWhSIi9aLwUw8tIfwA7D5SyDWzVlHmcDL75v5c3y/e7JKkuSgtMMYHffcO7P2S0+ODAqDHNRofJCJeSeGnHlpK+AGYnb6Tmct30Do0gM9TLyMyWF9mcpa8n4wusS2LjSfVV9L4IBHxMgo/9dCSwk9ZhZNrZ69iZ04h45ITePamvmaXJM2VywVZW40QtOVdjQ8SEa+j8FMPLSn8AHyz7zg3zV0LwKI7LmZIl1YmVyTNnsYHiYgXUviph5YWfgAe+3ArC9Zl0rl1CP+5bziB/no4ptTSucYHdR9pdIt1vUrjg0TEdAo/9dASw0/eyXKumrmSnIJS7v1FV1Kv7mF2SeKNzjk+6JfGQOn2yRofJCKmUPiph5YYfgA+2XqYOxdswt9m4eN7h9M9NszsksRbnTk+aOt7UJh9+r3oLqfHB0V3Mq9GEfE5Cj/10FLDj8vl4o43N/J5RjYDOkTy/v8bitWq/0OXenJUwN4VxkSK25ZCefHp9xIuNp4vdsGNGh8kIo1O4aceWmr4ATiUe5KrZq6kqMzBjDEXcuvFevK3NKDSAmOA9JZ3YM9KPMcHjYB+N2t8kIg0GoWfemjJ4Qdg/pq9/OnfPxJm92N56mXERQSaXZK0RPmHTj9fLOeH09vd44PGQfuLND5IRBqMwk89tPTw43C6+NUrX7H5QC4jL4hj7q0DzS5JWrqsrcbdYlvfh8Ks09ujOxuDpDU+SEQagMJPPbT08AOQcTif0S+upsLp4u+3DmTEBXFmlyS+wOk4NX/QYuP2+erGB/W6HkJam1aiiHgvhZ968IXwA/Dcsm28vGI3ceGBLE+9lLBAf7NLEl9SWmgMkP5ukef4IICY3pB4CSQON16Do00rU0S8h8JPPfhK+CkpdzBi1pfsP1bMpCEdeeKGC80uSXxV/iGjS2zru0YX2dliLzwdhBKH6c4xEamWwk89+Er4AViz6ygTXluHxQL/vHMoAzroS0VMVnQU9q0+tayCI9vO2sECcX2MMNRpuPG4jaBIMyoVkWZG4acefCn8ADzw7nf8c9NBesSGsfTeS/C3Wc0uSeS0wpzTQWjfaji6w/N9ixXi+hqtQp0uNcJQYMv/91ZEqlL4qQdfCz/Hi8pImbmS40VlPDiiB3df0dXskkRqVpB1OgztXQXHd3u+b7FC2ySjVShxOHS4GOyazVzEFyj81IOvhR+AD789yP2LvyPAz8qnUy6lU+sQs0sSqZ38Q0YY2vul8Xpir+f7Fhu0G3B6AHWHiyFA/3yLtEQKP/Xgi+HH5XIx8fX1rNp5lKFdWrHgd4OxaPI58UZ5B0+FoVVG61Dufs/3rX7QbuDpAdQJgyEg2JxaRaRBKfzUgy+GH4DMY8VcPWslJeVO/nJTX36dnGB2SSL1d2K/5wDqvAOe71v9jSfRVw6gbn8R+AeZU6uI1IvCTz34avgBmLtyN898so3IYH8+T72M1qF2s0sSaTguF5zY5zlmqOCQ5z42uxGAEi8xwlC7ZPDXI2BEvIHCTz34cvgpdzi5fs4aMg7nMyYpnlnj+5tdkkjjcbng+J7Td5LtXeX5+A0Av0AjDHW61AhE7ZL1YFaRZkrhpx58OfwAfHcglxtfXoPTBW/cPojLurcxuySRpuFywbHdsO/LU2OGVkNRjuc+fkHQYfCpAdSXQnx/hSGRZkLhpx58PfwAPPnvH3l9zV7aRwXx2f2XEhzgZ3ZJIk3P5TLmFarsItu3GoqPeu7jH2zcQeYOQ0lg06NiRMyg8FMPCj9QVFrB1X/7kp9yT/I/l3bmkVG9zC5JxHwulzHjdOWdZPtWw8njnvsEhBphqP0giOllLFGdwKb/gRBpbAo/9aDwY/jvtmxun/8NNquFf909jAvbRZhdkkjz4nRCzo+eM1CX5FbdzxYArbtDm54Q09N4cGubnhCVCFZbU1ct0mIp/NSDws9pdy/cxMdbDtOnXQQf3T0Mm1Vz/4jUyOmE7O+NEJS1BXIy4Mh2qDhZ/f5+gUYoqmwhatPLCEcRHcCqx8yInC+Fn3pQ+Dktp6CEK59fSUFJBY9f15vfXtLJ7JJEvIvTaUy0eGSb0UqUsw2OZMCRHeAorf4Y/xBo0/1UGKoMRj0hoj1o8lGRGin81IPCj6dF6zN55IOtBAfY+Oz+S2kfpdlwRerN6TDmHMrJONVClGEEo2M7wVFW/TEBYdCmh2fXWUwvCGurUCSCwk+9KPx4cjpdjH/1a9bvO84vesbwj0nJevSFSGNxVBhzD1WGoZwfjVajY7vAWVH9MfYIIxC1ORWKYnoarUahMQpFjgoozQdHufEYE/8QdSm2YAo/9aDwU9WunAJGvbCaMoeTObf057q+8WaXJOJbKsqMJ9jnZHh2oR3fAy5H9ccERVXtOovpBSGtm7b2unI6oawASvKhJM8IMSX5p17zztiWd8b2s/YtL6p6Xv9gYwkIOb34Bxt36gWEGCEpILTqPgEhRng6cx/3sSEavN4MKPzUg8JP9WZ9voNZn++kdaid9NTLiAjWXCYipqsohaM7TwWiM7rQju8FavjPe3DrqoGoTU8Ijm64ulwuKC+uGkZKcqsJMdWtn3qt6RrOm6UBz1UDv8CaQ5I7SIWe2nbmPtWFsDP2qcs0CS6X0bXqrDhjOfvnCnA5f36fnz1PdT/XYp+km435sRqQwk89KPxUr7TCwagXVrH7SBHjL0rgmV/1NbskEalJ+UljgsbKAdaVwejsp9yfKTT2dBiqvPssuBWU5lUTYmrRElNTi9T5sgWAPRwCIyAw/Kz1iBq2hxuvgZFgDwOrH1SUQFmR51JeuV4MZYVGYCsrMtbLis/a58zjztjP5WyY66zx+u2nw5GfvXbhoqF+943pulmQPLlBT6nwUw8KPzVbv/c4Y/++FoC7Lu/CkC6t6N8hilC7JnAT8QplRcbt95UtRZWvZz/tvqFYrNWElVM/uwPK2etn7dOcHyzrchmtb/UOUmfs4w5VjRBgLFYjCFYuZ/9stdXxZ9v5H9PlSmjbsP8TrfBTDwo/5/boh1tZuC7T/bPVAj3iwknuGMXAU0v7qCANihbxJqUFRig6MxAd2Wa04JwrrLiDTUT1rTMBIRp0XRcul3HX39mtVBWlNQSKWoQOi63FD/ZW+KkHhZ9zK3c4+efGg3y95xjf7D/BwRNVJ3CLDbczsGMUAzpEkZwYzQXx4fjbWva/dCIiYi6Fn3pQ+Dk/2fklbNx/go37T/DN/hP88FMeFU7Pf6wC/a30bR/JwI5RJJ8KRVEhehK2iIg0HIWfelD4qZ+ScgffHchlY+YJNu47wcbME+QWl1fZr0ubkFNhKJoBHaPo0iZEXWUiIlJnXhN+XnrpJf7yl7+QlZVFv379ePHFFxk0aFC1+86bN48333yT77//HoCBAwfy9NNPe+zvcrmYPn068+bNIzc3l2HDhvHKK6/QrVu3Wtek8NOwXC4Xu48UsWn/Cb7Zf5yN+0+w+0jVuTeigv0Z0CGKgYlRDOwQRb+ESAL9NW+GiIjUjleEn8WLFzNx4kTmzp3L4MGDmTVrFu+99x7bt28nJiamyv4TJkxg2LBhDB06lMDAQJ599lk+/PBDfvjhB9q1awfAs88+S1paGm+88QadOnXi8ccfZ+vWrfz4448EBtbujgGFn8Z3vKiMbzONbrKN+0/w3YFcSis8bxf1s1q4oF2EeyB1cscoYsKb8V0fIiJiKq8IP4MHD+aiiy5izpw5ADidThISEvjDH/7Aww8//LPHOxwOoqKimDNnDhMnTsTlchEfH88DDzzA1KlTAcjLyyM2Npb58+czfvz4WtWl8NP0yiqc/Hg4n2/2HWdT5gm+2XeCnIKqD31sHxV0xl1l0fSIC9OT5kVEBKj997dpk7OUlZWxceNGHnnkEfc2q9VKSkoKa9eurdU5iouLKS8vJzramJV07969ZGVlkZKS4t4nIiKCwYMHs3bt2hrDT2lpKaWlp79o8/Pz63JJUg8BflaSEiJJSogEjK6ygydOegyk3p6Vz8ETJzl44iQfbT4EQKjdj/4dIk/dVRZFUkIkYYGaeVpERGpmWvg5evQoDoeD2NhYj+2xsbFs27atVuf44x//SHx8vDvsZGVluc9x9jkr36tOWloaTzzxxPmUL43MYrGQEB1MQnQwY/obXZoFJeVsPpDLN/tOsCnzBN9m5lJYWsGqnUdZtfMocHrOoYEdI0nuGK05h7yM0+nCYkF/LxFpVF47Le8zzzzDO++8w4oVK2o9lqcmjzzyCKmpqe6f8/PzSUhIqG+J0sDCAv0Z3q0Nw7u1AcDhdLE9q4CNpwZRV845lHE4n4zD+bz9tTERY0yY3T354sCOUVwQH0GAn+YcMpvL5eJQXgmbM3PZfOAEmw/ksvWnPErKndj9rAT62wjytxHob6wHnrEedNbPgf42Av1sBAVY3euBATYCK88TcGpbNefS/FMivse08NO6dWtsNhvZ2dke27Ozs4mLizvnsX/961955pln+Pzzz+nb9/TU2JXHZWdn07ZtW49zJiUl1Xg+u92O3W6vw1WImWxWC73jw+kdH86tQxKB6uccyiko5ZPvs/jke6P1z+5npV/7SPddZX3aRxATZldrQyMrLK1gy8FcNh/I5dtM4/VINeO6AEornJRWOMk7WXWKhIbmZ7VUDVL+VnfAsvtVhqczg5QV+1khzL3/qfU2YXbaRarVUaQ5Mi38BAQEMHDgQNLT0xkzZgxgDHhOT0/nnnvuqfG45557jj//+c98+umnJCcne7zXqVMn4uLiSE9Pd4ed/Px81q1bx5133tlYlyLNSGx4IKP6tGVUHyP81jTn0Pp9x1m/77j7uKhgf3rGhdOzbRi94sLpERdG99gwggJ0q31dOJwudmQXsPlA7qmWnVx25BRw9u0VNquFHrFhJHUwxnv1T4gkKiSAknLHqcVJSbmDk2etl576+eQZ+7m3Vzg4WXZq/1PrpRVnnsd4r1KF00VhaQWF1eewegkJsNE1NowesaF0jw2jW2wY3WNDiQsPVCgSMZGp3V6pqalMmjSJ5ORkBg0axKxZsygqKmLyZOMprxMnTqRdu3akpaUBxm3s06ZNY+HChSQmJrrH8YSGhhIaGorFYmHKlCk89dRTdOvWzX2re3x8vDtgiW8J9LcxuHMrBnduBVSdc2hTZi57jhRyorictXuOsXbPMfexFgt0ahVCz7ZhRjCKC6NX23DaRQZh1R1mHrLySth84ATfngo7W3/Ko7is6kMZ4yMC3UEnKSGKPu0iTAmYLpfrrEDkGY5KqwlWJafCVdX9nZRWBq6KU/uXOcjOL6GozAjf3x3I9fj8sEA/usV4BqLusWFqgRRpIqZPcjhnzhz3JIdJSUnMnj2bwYMHA3D55ZeTmJjI/PnzAUhMTGT//v1VzjF9+nT+9Kc/AacnOXz11VfJzc3lkksu4eWXX6Z79+61rkm3uvuWknIHu3IKyTicz7asArZl5ZNxuIDjRWXV7h9q96NHXBg9K5e2RktRuI/cZVZUWsHWn/I8WnWy8kuq7BcSYKNv+0iPVh1fmqep3OFk39EidmQXsiO7gJ05BWzPKmDfsWIczur/sxse6OcRiHqcWm8dGqBQJFILXjHPT3Ol8CMul4sjhaVsO2x8YWVk5bPtcAG7cgopczirPaZdZBC9KluJTr0mtgrGz4sH1DqcLnblFLoHJH+bmcuO7ALO/u62WqB7bBj9z2jV6RoTqjmYqlFa4WDvqVC0M7vACEbZhew7VlTl91opKtjfo4WoW4yx3ipUYxVFzqTwUw8KP1KTcoeTvUeLTrcSnXo9nFe15QOMwdXdYkM9us16xoU12y+tnPwSo+vqjO6rwtKKKvvFhQcaIedU2OnTLoIQu9fePNoslJQ72HOkiJ05RiCqDEf7jxdXGStVqVVIAN3OHE90qitNDw0WX6XwUw8KP3K+covL2JZltBJVdpttzyrgZHnVcS8AbcLsHmGoR1wYXWNCsfs13fiXk2WOU91XJ9xh51A1IS44wEafdhEkdTC6rpISooiL8J3uK7NVdsueGYh25BRw4PjJGo9pE2ane2zoqRYio5WoW2wYEUG+0TUrvkvhpx4UfqQhOJ0uMo8Xu8PQtiyjlWj/seJq9/ezWujcJsTjrrOebcMa5M4gp9PFnqOFfJuZ6x6UvD27oMrYE4sFuseEebTqdIsJ9equu5aquKziVCg63X22I7uQn3JrDkWx4XaPbrPKrjTNii4thcJPPSj8SGMqKq1gR3aBu9ss49RrfknV7iWAiCB/dytR5UDrHnFhBAfU3M10tLDUPRh584FcvjuYS0E1548Js3sEnb7tIwlV95VXKyytcLcU7TwViHZk19w1C9A2ItCjhcgISKEN1pXpdLpwuFw4nMZS4XThrHx1ef7sOHtxuXA4nTicUOF04nTisc3jPZeLCkf153TW8quutt+Itf3irP35arejn9VCeKA/EUHGEn7qNSLYnzC7n88PjFf4qQeFH2lqLpeLw3klZ7QSGYFoz9Giau8MsligY3Swu5WoW0wYh/NOusPOwRNV/+8/0N9Kn3YR9O8Q5X6OWtsIzTfjK/JLytnpbiUqdI8tys6veYKjdpFBxITb3eGlumBxdoipLrzoW6Zp2KwWwgP9qgajM5bI4OrfC20hwUnhpx4UfqS5KCl3sPtIIdvO6DbLOFzA0Z+Zkc9igS5tQt0hJykhkh5xYXqUg1SRV1x+KgidviV/R3ZhjbNvNzSb1WIsFgt+VgtW61mvFgt+NuN9975nLtVsP/M4q+X0z9Tyu91Syx1rmxVqGylqc75yh4v8k+XknbWUVlR/F2ptVQanyOCAs4KRX5UAFREU4G5tigjyJyTA1myCk8JPPSj8SHN3pKDUY3D1rpwC2lR2YSVE0TchwmfmHZLGcaKojB3ZBZwoLsfPasFmq3tA8bNajffO2seqh9g2mJJyh2cgKq4akGpayuoZnPysFndgCg/yJ7KaFqezW5sig/2JDgkg0L9hb/JQ+KkHhR8REfEVlcEpt4bAVNnSlFtcdsb2CvJPltc471ltTB/dm8nDOjXgldT++1sjG0VERHxY5QN9Y89zBnaXy0VJudMjKJ0ZkKrrnss9Y7uZUy8o/IiIiMh5s1gsBAXYCAqwnffcXy6TB8Ir/IiIiEiTslgstR4w3hh064eIiIj4FIUfERER8SkKPyIiIuJTFH5ERETEpyj8iIiIiE9R+BERERGfovAjIiIiPkXhR0RERHyKwo+IiIj4FIUfERER8SkKPyIiIuJTFH5ERETEpyj8iIiIiE/RU92r4XK5AMjPzze5EhEREamtyu/tyu/xmij8VKOgoACAhIQEkysRERGR81VQUEBERESN71tcPxePfJDT6eTQoUOEhYVhsVjMLqdZys/PJyEhgQMHDhAeHm52OT5Pf4/mRX+P5kV/j+alMf8eLpeLgoIC4uPjsVprHtmjlp9qWK1W2rdvb3YZXiE8PFz/MWlG9PdoXvT3aF7092heGuvvca4Wn0oa8CwiIiI+ReFHREREfIrCj9SJ3W5n+vTp2O12s0sR9PdobvT3aF7092hemsPfQwOeRURExKeo5UdERER8isKPiIiI+BSFHxEREfEpCj8iIiLiUxR+pNbS0tK46KKLCAsLIyYmhjFjxrB9+3azy5JTnnnmGSwWC1OmTDG7FJ/2008/8Zvf/IZWrVoRFBREnz59+Oabb8wuyyc5HA4ef/xxOnXqRFBQEF26dGHGjBk/+9wnaRhffvklo0ePJj4+HovFwkcffeTxvsvlYtq0abRt25agoCBSUlLYuXNnk9Sm8CO1tnLlSu6++26+/vprli9fTnl5OVdffTVFRUVml+bzNmzYwN///nf69u1rdik+7cSJEwwbNgx/f38++eQTfvzxR55//nmioqLMLs0nPfvss7zyyivMmTOHjIwMnn32WZ577jlefPFFs0vzCUVFRfTr14+XXnqp2vefe+45Zs+ezdy5c1m3bh0hISGMGDGCkpKSRq9Nt7pLnR05coSYmBhWrlzJpZdeanY5PquwsJABAwbw8ssv89RTT5GUlMSsWbPMLssnPfzww6xZs4ZVq1aZXYoA1113HbGxsfzjH/9wb/vVr35FUFAQb7/9tomV+R6LxcKHH37ImDFjAKPVJz4+ngceeICpU6cCkJeXR2xsLPPnz2f8+PGNWo9afqTO8vLyAIiOjja5Et929913c+2115KSkmJ2KT5vyZIlJCcn8+tf/5qYmBj69+/PvHnzzC7LZw0dOpT09HR27NgBwHfffcfq1au55pprTK5M9u7dS1ZWlsd/tyIiIhg8eDBr165t9M/Xg02lTpxOJ1OmTGHYsGFceOGFZpfjs9555x02bdrEhg0bzC5FgD179vDKK6+QmprKo48+yoYNG7j33nsJCAhg0qRJZpfncx5++GHy8/Pp2bMnNpsNh8PBn//8ZyZMmGB2aT4vKysLgNjYWI/tsbGx7vcak8KP1Mndd9/N999/z+rVq80uxWcdOHCA++67j+XLlxMYGGh2OYLxPwXJyck8/fTTAPTv35/vv/+euXPnKvyY4N1332XBggUsXLiQCy64gM2bNzNlyhTi4+P19/Bx6vaS83bPPfewdOlSvvjiC9q3b292OT5r48aN5OTkMGDAAPz8/PDz82PlypXMnj0bPz8/HA6H2SX6nLZt29K7d2+Pbb169SIzM9Okinzbgw8+yMMPP8z48ePp06cPt956K/fffz9paWlml+bz4uLiAMjOzvbYnp2d7X6vMSn8SK25XC7uuecePvzwQ/773//SqVMns0vyaVdeeSVbt25l8+bN7iU5OZkJEyawefNmbDab2SX6nGHDhlWZ/mHHjh107NjRpIp8W3FxMVar59eczWbD6XSaVJFU6tSpE3FxcaSnp7u35efns27dOoYMGdLon69uL6m1u+++m4ULF/Kvf/2LsLAwd79sREQEQUFBJlfne8LCwqqMtwoJCaFVq1Yah2WS+++/n6FDh/L0008zduxY1q9fz6uvvsqrr75qdmk+afTo0fz5z3+mQ4cOXHDBBXz77bfMnDmT22+/3ezSfEJhYSG7du1y/7x37142b95MdHQ0HTp0YMqUKTz11FN069aNTp068fjjjxMfH+++I6xRuURqCah2+b//+z+zS5NTLrvsMtd9991ndhk+7d///rfrwgsvdNntdlfPnj1dr776qtkl+az8/HzXfffd5+rQoYMrMDDQ1blzZ9djjz3mKi0tNbs0n/DFF19U+50xadIkl8vlcjmdTtfjjz/uio2NddntdteVV17p2r59e5PUpnl+RERExKdozI+IiIj4FIUfERER8SkKPyIiIuJTFH5ERETEpyj8iIiIiE9R+BERERGfovAjIiIiPkXhR0SkFlasWIHFYiE3N9fsUkSknhR+RERExKco/IiIiIhPUfgREa/gdDpJS0ujU6dOBAUF0a9fP95//33gdJfUxx9/TN++fQkMDOTiiy/m+++/9zjHP//5Ty644ALsdjuJiYk8//zzHu+Xlpbyxz/+kYSEBOx2O127duUf//iHxz4bN24kOTmZ4OBghg4dWuUp7iLS/Cn8iIhXSEtL480332Tu3Ln88MMP3H///fzmN79h5cqV7n0efPBBnn/+eTZs2ECbNm0YPXo05eXlgBFaxo4dy/jx49m6dSt/+tOfePzxx5k/f777+IkTJ7Jo0SJmz55NRkYGf//73wkNDfWo47HHHuP555/nm2++wc/PT08IF/FCerCpiDR7paWlREdH8/nnnzNkyBD39t/97ncUFxfz+9//niuuuIJ33nmHcePGAXD8+HHat2/P/PnzGTt2LBMmTODIkSN89tln7uMfeughPv74Y3744Qd27NhBjx49WL58OSkpKVVqWLFiBVdccQWff/45V155JQD/+c9/uPbaazl58iSBgYGN/FsQkYailh8RafZ27dpFcXExV111FaGhoe7lzTffZPfu3e79zgxG0dHR9OjRg4yMDAAyMjIYNmyYx3mHDRvGzp07cTgcbN68GZvNxmWXXXbOWvr27eteb9u2LQA5OTn1vkYRaTp+ZhcgIvJzCgsLAfj4449p166dx3t2u90jANVVUFBQrfbz9/d3r1ssFsAYjyQi3kMtPyLS7PXu3Ru73U5mZiZdu3b1WBISEtz7ff311+71EydOsGPHDnr16gVAr169WLNmjcd516xZQ/fu3bHZbPTp0wen0+kxhkhEWia1/IhIsxcWFsbUqVO5//77cTqdXHLJJeTl5bFmzRrCw8Pp2LEjAE8++SStWrUiNjaWxx57jNatWzNmzBgAHnjgAS666CJmzJjBuHHjWLt2LXPmzOHll18GIDExkUmTJnH77bcze/Zs+vXrx/79+8nJyWHs2LFmXbqINAKFHxHxCjNmzKBNmzakpaWxZ88eIiMjGTBgAI8++qi72+mZZ57hvvvuY+fOnSQlJfHvf/+bgIAAAAYMGMC7777LtGnTmDFjBm3btuXJJ5/ktttuc3/GK6+8wqOPPspdd93FsWPH6NChA48++qgZlysijUh3e4mI16u8E+vEiRNERkaaXY6INHMa8yMiIiI+ReFHREREfIq6vURERMSnqOVHREREfIrCj4iIiPgUhR8RERHxKQo/IiIi4lMUfkRERMSnKPyIiIiIT1H4EREREZ+i8CMiIiI+ReFHREREfMr/B+qZw9U1Zv1iAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw mae\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_mae) + 1)), arr_train_mae, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_mae) + 1)), arr_val_mae, label=\"val\")\n",
    "\n",
    "    plt.title(\"MAE\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"mae\")\n",
    "    plt.legend(loc=\"upper right\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1cc21154",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Accuracies\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_acc) + 1)), arr_train_acc, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_acc) + 1)), arr_val_acc, label=\"val\")\n",
    "\n",
    "    plt.title(\"Accuracy\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"accuracy\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0133ff45",
   "metadata": {},
   "source": [
    "# Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e095b271",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.split_all_docs import split_all_docs\n",
    "from rouge_score import rouge_scorer\n",
    "from utils.threshold_probs import threshold_probs_by_prop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "273c6eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SIMPLE_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4fc41994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_epoch = np.argmin(np.array(arr_val_loss)) + 1\n",
    "model.load(checkpoints_folder + \"/\" + model_name + \"-\" + str(best_epoch) + \".pt\")\n",
    "model.to(device)\n",
    "model.eval()\n",
    "best_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3edbae7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_set = df_test\n",
    "test_set[\"doc_splited\"] = split_all_docs(test_set[args.doc_col_name], False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bb8ab07a",
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "67659b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:02<00:00, 40.64batch/s, accuracy=0.863, mae=0.197, rouge1=0.438, rouge2=0.243, rougeL=0.332]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Eval model\")\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "                \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        y_pred = model(features, doc_lens)\n",
    "    \n",
    "        loss = criterion(y_pred, targets)\n",
    "\n",
    "        arr_loss.append(loss.item())\n",
    "\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "        #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[i]]\n",
    "            y_pred_thresh.append(indices[i])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[i]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        mae.append(mae_fn(probs_tensor, targets).item())\n",
    "\n",
    "        accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "        #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "        tepoch.set_postfix(accuracy = np.mean(accuracy), mae = np.mean(mae), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))\n",
    "        idx += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "5c1fd15f",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\n",
    "test_metrics[\"mae\"]      = np.mean(mae)\n",
    "test_metrics[\"rouge1\"]   = np.mean(arr_rouge1)\n",
    "test_metrics[\"rouge2\"]   = np.mean(arr_rouge2)\n",
    "test_metrics[\"rougeL\"]   = np.mean(arr_rougeL)\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/test_metrics.json\", 'w') as fp:\n",
    "    json.dump(test_metrics, fp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "496646f2",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:00<00:00, 142.52batch/s, rouge1=0.406, rouge2=0.225, rougeL=0.309]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Lead-3\")\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), 3)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a3c5d9",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a4c96c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 119.01batch/s, rouge1=0.435, rouge2=0.241, rougeL=0.325]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e4f4796c",
   "metadata": {},
   "outputs": [
    {
     "ename": "SystemExit",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/raoufdine/anaconda3/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3465: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "# Does not excute this cell if you want to execute the following cells.\n",
    "import sys\n",
    "sys.exit()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "4f810f0bde7d7b5dc90f9e6832822547e13e234c53731a97fc91254323942f40"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}