11-train_SIMPLE_CNN_RNN_without_position_and_salience_Glove300.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train 11-train_SIMPLE_CNN_RNN_without_position_and_salience"
   ]
  },
  {
   "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=4)\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: 4\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 = \"11-train_SIMPLE_CNN_RNN_without_position_and_salience_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=4)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3393fe4e",
   "metadata": {},
   "source": [
    "## Chargement des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "97644745",
   "metadata": {},
   "outputs": [],
   "source": [
    "glovemgr = 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.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",
    "\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",
    "            novelties_for_position = -1 * self.Wnovelty(sents_all_docs[position::max_doc_lens], torch.tanh(ses))\n",
    "            prob = contents_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",
       "  (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.72batch/s, accuracy=0.803, loss=0.455, mae=0.241]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.480, val mae = 0.364, val accuracy = 0.868, r1 = 0.502, r2 = 0.305, rL = 0.387\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 13/13 [00:00<00:00, 14.55batch/s, accuracy=0.825, loss=0.365, mae=0.219]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.473, val mae = 0.356, val accuracy = 0.852, r1 = 0.493, r2 = 0.288, rL = 0.372\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 13/13 [00:00<00:00, 14.58batch/s, accuracy=0.832, loss=0.338, mae=0.201]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.470, val mae = 0.333, val accuracy = 0.814, r1 = 0.454, r2 = 0.250, rL = 0.340\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 13/13 [00:00<00:00, 14.78batch/s, accuracy=0.842, loss=0.336, mae=0.208]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.368, val mae = 0.247, val accuracy = 0.855, r1 = 0.497, r2 = 0.296, rL = 0.381\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 13/13 [00:00<00:00, 14.60batch/s, accuracy=0.835, loss=0.327, mae=0.207]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.369, val mae = 0.241, val accuracy = 0.852, r1 = 0.489, r2 = 0.287, rL = 0.371\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 13/13 [00:00<00:00, 14.32batch/s, accuracy=0.842, loss=0.31, mae=0.2]   \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.361, val mae = 0.230, val accuracy = 0.855, r1 = 0.493, r2 = 0.293, rL = 0.377\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 13/13 [00:00<00:00, 15.07batch/s, accuracy=0.842, loss=0.315, mae=0.2]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.360, val mae = 0.227, val accuracy = 0.855, r1 = 0.493, r2 = 0.293, rL = 0.377\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 13/13 [00:00<00:00, 14.61batch/s, accuracy=0.848, loss=0.309, mae=0.198]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.361, val mae = 0.228, val accuracy = 0.855, r1 = 0.493, r2 = 0.293, rL = 0.377\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 13/13 [00:00<00:00, 14.48batch/s, accuracy=0.839, loss=0.32, mae=0.202] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.361, val mae = 0.228, val accuracy = 0.855, r1 = 0.493, r2 = 0.293, rL = 0.377\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 13/13 [00:00<00:00, 14.84batch/s, accuracy=0.847, loss=0.307, mae=0.197]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.361, val mae = 0.229, val accuracy = 0.855, r1 = 0.494, r2 = 0.293, rL = 0.377\n",
      "Training duration = 31.960495710372925\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": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Losses\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_loss) + 1)), arr_train_loss, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_loss) + 1)), arr_val_loss, label=\"val\")\n",
    "\n",
    "    plt.title(\"Loss\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"loss\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8bda887e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAHHCAYAAABEEKc/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAA9hAAAPYQGoP6dpAABfX0lEQVR4nO3deVxU9f7H8dfMAMO+iYAoivtSKilKaoslplm23LxpWZatt7JFqpvebqu3sLJ+ppaW91ZWmrbXbbEMl8xLappp5r5vgBsgINvM/P4YGB1EJWQ8DLyfj8d5zHDOd858Bu513n2/3/M9JofD4UBEREREXMxGFyAiIiJS1yggiYiIiFSigCQiIiJSiQKSiIiISCUKSCIiIiKVKCCJiIiIVKKAJCIiIlKJApKIiIhIJQpIIiIiIpUoIImIiIhUooAkIvXOO++8g8lkwmQy8dNPP51w3OFwEB8fj8lk4sorrzzheE5ODv7+/phMJtatW1fle9x6662u96i8+fv71/pnEpGzy8foAkREPMXf359Zs2ZxwQUXuO1ftGgRu3fvxmq1Vvm6jz76CJPJRGxsLDNnzuRf//pXle2sViv//ve/T9hvsVjOvHgRMZQCkojUW4MGDeKjjz5i0qRJ+Pgc++du1qxZdO/enQMHDlT5uvfff59BgwbRokULZs2addKA5OPjw0033eSR2kXEWBpiE5F664YbbuDgwYPMmzfPta+kpISPP/6YG2+8scrX7Ny5k8WLFzNs2DCGDRvGtm3b+N///ne2ShaROkIBSUTqrYSEBHr16sUHH3zg2vftt9+Sm5vLsGHDqnzNBx98QFBQEFdeeSU9e/akdevWzJw586TvceDAgRO2vLy8Wv8sInJ2KSCJSL1244038vnnn3P06FEAZs6cycUXX0xcXFyV7WfOnMnVV19NQEAAAEOHDuXDDz+krKzshLYFBQU0btz4hO3666/33AcSkbNCAUlE6rXrr7+eo0eP8tVXX3HkyBG++uqrkw6vrV69mjVr1nDDDTe49t1www0cOHCA77777oT2/v7+zJs374Rt/PjxHvs8InJ2aJK2iNRrjRs3JiUlhVmzZlFYWIjNZmPIkCFVtn3//fcJCgqiVatWbN68GXCGoISEBGbOnMkVV1zh1t5isZCSkuLxzyAiZ58CkojUezfeeCN33nknmZmZXH755YSHh5/QxuFw8MEHH1BQUECnTp1OOJ6dnU1+fj7BwcFnoWIRMZoCkojUe9deey133303P//8M3PmzKmyTcXaSM8++ywdO3Z0O3b48GHuuusuPv/8c13WL9JAKCCJSL0XHBzM1KlT2b59O4MHD66yTcXw2qOPPlrlStgvvfQSM2fOVEASaSAUkESkQbjllltOeqy4uJhPPvmE/v37n/Q2IVdddRWvvvoq2dnZREdHA1BWVsb7779fZftrr72WoKCgMy9cRAyhgCQiDd7XX39NTk7OSXuXAAYPHszLL7/M7NmzeeCBBwBnsLr55purbL9t2zYFJBEvZnI4HA6jixARERGpS7QOkoiIiEglCkgiIiIilSggiYiIiFSigCQiIiJSiQKSiIiISCUKSCIiIiKVaB2kGrLb7ezdu5eQkBBMJpPR5YiIiEg1OBwOjhw5QlxcHGbzyfuJFJBqaO/evcTHxxtdhoiIiNTArl27aNas2UmPKyDVUEhICOD8BYeGhhpcjYiIiFRHXl4e8fHxru/xk1FAqqGKYbXQ0FAFJBERES9zuukxmqQtIiIiUokCkoiIiEglCkgiIiIilWgOkoiISB1js9koLS01ugyv5Ovri8ViOePzKCCJiIjUEQ6Hg8zMTHJycowuxauFh4cTGxt7RusUKiCJiIjUERXhKDo6msDAQC1E/Cc5HA4KCwvJzs4GoEmTJjU+lwKSiIhIHWCz2VzhqFGjRkaX47UCAgIAyM7OJjo6usbDbZqkLSIiUgdUzDkKDAw0uBLvV/E7PJN5XApIIiIidYiG1c5cbfwOFZBEREREKlFAEhERkTojISGBiRMnGl2GJmmLiIjImenbty+JiYm1EmyWL19OUFDQmRd1htSDVNdk/QH5+42uQkREpNY4HA7Kysqq1bZx48Z1YqK6AlJd89VomNAW/jMAlrwKBzYbXZGIiMhJ3XrrrSxatIhXX30Vk8mEyWTinXfewWQy8e2339K9e3esVis//fQTW7Zs4eqrryYmJobg4GB69OjBDz/84Ha+ykNsJpOJf//731x77bUEBgbStm1bvvzyS49/Lg2x1SVlJWAvBRyw62fnNu9JiGoH7QdBhyugaRKYlWtFRBoCh8PB0VKbIe8d4Gup1tVgr776Khs3buTcc8/l2WefBWDt2rUAjBkzhgkTJtCqVSsiIiLYtWsXgwYN4rnnnsNqtfLuu+8yePBgNmzYQPPmzU/6Hs888wwvvvgiL730EpMnT2b48OHs2LGDyMjI2vmwVVBAqkt8/ODO+ZC7BzZ8A+u/hu2L4cBG57ZkIgTHQLuBzrDU8mLw9Te6ahER8ZCjpTY6PfmdIe/9x7MDCPQ7fUwICwvDz8+PwMBAYmNjAVi/fj0Azz77LP3793e1jYyMpGvXrq6fx40bx2effcaXX37JqFGjTvoet956KzfccAMAzz//PJMmTWLZsmUMHDiwRp+tOhSQ6qKwptDzTudWlAub5jkD06Z5kJ8FK2c4N98gaHMpdLgS2l4GgZ5L0iIiIn9WUlKS28/5+fk8/fTTfP311+zbt4+ysjKOHj3Kzp07T3meLl26uJ4HBQURGhrqup2Ipygg1XX+YdB5iHMrK4EdPzl7ljZ8C3l7YN1/nZvJAi16lw/FDYKIBKMrFxGRMxTga+GPZwcY9t5nqvLVaI888gjz5s1jwoQJtGnThoCAAIYMGUJJSckpz+Pr6+v2s8lkwm63n3F9p6KA5E18/KD1pc5t0ATYtwrWf+PsXcr63Tkct30xfDcWos9xDsN1GARNEkErs4qIeB2TyVStYS6j+fn5YbOdfq7UkiVLuPXWW7n22msBZ4/S9u3bPVxdzdT937pUzWSCuPOc26WPw+Htx8LSjv9B9lrn9uOLENoU2l/u7F1KuNAZtERERGpJQkICS5cuZfv27QQHB5+0d6dt27Z8+umnDB48GJPJxBNPPOHxnqCa0uVQ9UVEAvS6F279Ch7dDNe+AR0HO+cp5e2B5f+G9/8CL7WGj0bCmo+d85tERETO0COPPILFYqFTp040btz4pHOKXnnlFSIiIujduzeDBw9mwIABdOvW7SxXWz0mh8PhMLoIb5SXl0dYWBi5ubmEhoYaXc7JlRbBtkXH5i0VHDepzewLCRc4h+LaXw5hzYyrU0SkgSsqKmLbtm20bNkSf39doXwmTvW7rO73t4bY6jtff2g3wLnZ7bDnl/Kw9I1z6YCtC5zbN4845yp1uMI5FBdzjuYtiYhIg6WA1JCYzRDf07n1f8a5SveGr51zl3YtdU763rcKFjwH4c2hffkk7+a9waL/qYiISMOhb72GLKoNRD0IfR6E/GzYONcZlrYugJydsHSqcwuIgLYDnGGpdT+wBhtduYiIiEcpIIlTcDR0G+HcSgpgywLnMNyGb+HoIVg927lZrNDqYucwXPtBEBJjdOUiIiK1TgFJTuQXBB2vdG62MufwW8WtTw5vg03fO7evHoJmPY7dJy6qneYtiYhIvaCAJKdm8YGEPs7tsn9B9rpj85b2roTdy51b+jMQ2do5DNfhSmdwMp/5KqwiIiJGUECS6jOZIKaTc7voUcjb6xyC2/ANbF0Eh7bA/yY7t8Ao5zpM/Z7UPeJERMTrKCBJzYXGQY/bnVtRHmz+wRmWNn4PhQdgxdvO4bmbP4OQWKOrFRERqTatpC21wz8Uzv0LXPdv+PsWGP4JBMdA9h/w1kDnrVBERES8hAKS1D6LL7RNgdvmQngL58TutwZC9nqjKxMRkTooISGBiRMnGl2GGwUk8ZzIVs6Q1LgDHNkHb18Oe1YaXZWIiMhpKSCJZ4XGwchvIa6bcz2lGVfBtsVGVyUiInJKCkjieYGRcMuXkHAhlByB969zXv0mIiJe78033yQuLg673e62/+qrr+a2225jy5YtXH311cTExBAcHEyPHj344YcfDKq2+hSQ5OywhsDwj52LStqKYfZwWP2h0VWJiNRtDofz7gZGbA5HtUr861//ysGDB1mwYIFr36FDh5g7dy7Dhw8nPz+fQYMGkZ6ezq+//srAgQMZPHgwO3fu9NRvrVboMn85e3z94fp34Yv7YPUc+PQuKMqFnncaXZmISN1UWgjPxxnz3v/Y67yzwmlERERw+eWXM2vWLPr16wfAxx9/TFRUFJdccglms5muXbu62o8bN47PPvuML7/8klGjRnms/DNleA/Sa6+9RkJCAv7+/iQnJ7Ns2bKTtv30009JSkoiPDycoKAgEhMTee+999za3HrrrZhMJrdt4MCBbm0OHTrE8OHDCQ0NJTw8nNtvv538/HyPfD6pxOIL10yDHncCDvjmEfhxQrX/S0VEROqe4cOH88knn1BcXAzAzJkzGTZsGGazmfz8fB555BE6duxIeHg4wcHBrFu3Tj1IpzJnzhxSU1OZNm0aycnJTJw4kQEDBrBhwwaio6NPaB8ZGcnjjz9Ohw4d8PPz46uvvmLkyJFER0czYMAAV7uBAwfy9ttvu362Wq1u5xk+fDj79u1j3rx5lJaWMnLkSO666y5mzZrluQ8rx5jNMOglCAiHH1+C+eOgKAf6j9O93EREjucb6OzJMeq9q2nw4ME4HA6+/vprevToweLFi/m///s/AB555BHmzZvHhAkTaNOmDQEBAQwZMoSSkhJPVV4rDA1Ir7zyCnfeeScjR44EYNq0aXz99de89dZbjBkz5oT2ffv2dfv5wQcfZMaMGfz0009uAclqtRIbW/XKzevWrWPu3LksX76cpKQkACZPnsygQYOYMGECcXEGdWU2NCYTXPpP8A+H7x933p6kKBeunKh7uImIVDCZqjXMZTR/f3/+8pe/MHPmTDZv3kz79u3p1q0bAEuWLOHWW2/l2muvBSA/P5/t27cbWG31GDbEVlJSwooVK0hJSTlWjNlMSkoKGRkZp329w+EgPT2dDRs2cNFFF7kdW7hwIdHR0bRv35577rmHgwcPuo5lZGQQHh7uCkcAKSkpmM1mli5detL3Ky4uJi8vz22TWtB7FFw1BUxmWPkufHwblNXt/6oQEZETDR8+3NXJMXz4cNf+tm3b8umnn7Jq1Sp+++03brzxxhOueKuLDAtIBw4cwGazERMT47Y/JiaGzMzMk74uNzeX4OBg/Pz8uOKKK5g8eTL9+/d3HR84cCDvvvsu6enpvPDCCyxatIjLL78cm80GQGZm5gnDdz4+PkRGRp7yfdPS0ggLC3Nt8fHxNfnYUpVuN8OQt8HsC398Dh8Mc15BISIiXuPSSy8lMjKSDRs2cOONN7r2v/LKK0RERNC7d28GDx7MgAEDXL1LdZnXXcUWEhLCqlWryM/PJz09ndTUVFq1auUafhs2bJirbefOnenSpQutW7dm4cKFrtn1NTF27FhSU1NdP+fl5Skk1aZzrgFrMMy5Gbakw3t/gRvnOOcpiYhInWc2m9m798T5UgkJCcyfP99t33333ef2c10ccjOsBykqKgqLxUJWVpbb/qysrJPOHwLnH6BNmzYkJiby8MMPM2TIENLS0k7avlWrVkRFRbF582YAYmNjyc7OdmtTVlbGoUOHTvm+VquV0NBQt01qWZsUuPlzsIbBrp9hxpWQn33al4mIiNQ2wwKSn58f3bt3Jz093bXPbreTnp5Or169qn0eu93uuqywKrt37+bgwYM0adIEgF69epGTk8OKFStcbebPn4/dbic5ObkGn0RqVfNkGPk1BDWGzDXOm9zm7DK6KhERaWAMXQcpNTWV6dOnM2PGDNatW8c999xDQUGB66q2ESNGMHbsWFf7tLQ05s2bx9atW1m3bh0vv/wy7733HjfddBPgnBn/6KOP8vPPP7N9+3bS09O5+uqradOmjesqt44dOzJw4EDuvPNOli1bxpIlSxg1ahTDhg3TFWx1RWxnuO07CIuHQ1vgrQGwf6PRVYmISANi6BykoUOHsn//fp588kkyMzNJTExk7ty5ronbO3fuxGw+luEKCgq499572b17NwEBAXTo0IH333+foUOHAmCxWFi9ejUzZswgJyeHuLg4LrvsMsaNG+e2FtLMmTMZNWoU/fr1w2w2c9111zFp0qSz++Hl1Bq1htvmwrvXwMFN8PZAuOlTiEs0ujIREWkATA6HljCuiby8PMLCwsjNzdV8JE8qOADv/wX2/QbWUOfE7Ra9ja5KRKTWFRUVsW3bNhISEggICDC6HK929OhRtm/fTsuWLfH393c7Vt3vb8NvNSJySkFRcMt/oXlvKM6D966FTfOMrkpEpNb5+voCUFhYaHAl3q/id1jxO60Jr7vMXxog/zC46RP46BbY9L1znaS/vAnnXmd0ZSIitcZisRAeHu660jowMBCTbr/0pzgcDgoLC8nOziY8PByLpeZ3ZlBAEu/gFwhDZ8Lnf4PfP4GPb4fiI9D9VqMrExGpNRXLzVRejkb+nPDw8FMu3VMdCkjiPXz84C/TnXORVrwN/30QjubABQ8ZXZmISK0wmUw0adKE6OhoSktLjS7HK/n6+p5Rz1EFBSTxLmYLXPl/zhW2f/o/+OEpKMqBfk85b+ooIlIPWCyWWvmSl5rTJG3xPiYTpDzt3MAZlL5OBS+4+aGIiHgHBSTxXheMdvYmYYJf3oJP7wSbuqRFROTMKSCJd0u6Da77N5h94PePYfZwKD1qdFUiIuLlFJDE+3UeAsM+AB9/2PQdvH8dFOUZXZWIiHgxBSSpH9pdBjd/5rzCbccSmHGlcxVuERGRGlBAkvqjRW/nqtuBjZy3Jnn7csjdY3RVIiLihRSQpH6JS4SRcyG0KRzYCG8NhINbjK5KRES8jAKS1D+N28FtcyGyNeTudIakzDVGVyUiIl5EAUnqp/DmzpAU0xkKsuGdK2DnUqOrEhERL6GAJPVXcDTc+hXEnw9FufDeNbA53eiqRETECyggSf0WEA43fwqt+0FpIcwaCms/N7oqERGp4xSQpP7zC4IbZkOna8BeCh+PhJXvGV2ViIjUYQpI0jD4+MGQt+C8m8Fhhy9HQcZrRlclIiJ1lAKSNBxmC1w1GXrf7/z5u3/A/OfA4TC2LhERqXMUkKRhMZmg/zi49Annzz++CN8+Bna7sXWJiEidooAkDY/JBBc9AoMmOH9e9gZ8fg/YyoytS0RE6gwFJGm4et4J174JJgusng0fjoDSIqOrEhGROkABSRq2rkNh6PtgscKGr2HWX6H4iNFViYiIwRSQRDoMgps+Br9g2PYjvHs1FB4yuioRETGQApIIQMuL4JYvISAC9qyAtwdB3j6jqxIREYMoIIlUaNodRn4LIU1g/zp4awAc2mZ0VSIiYgAFJJHjRXd03uQ2IgFydsBbAyHrD6OrEhGRs0wBSaSyiAS47TuI7gT5mfD25XBgk9FViYjIWaSAJFKVkFi49WuIOw+KcuCXt4yuSEREziIFJJGTCYyEC1Kdzzd9b2wtIiJyVikgiZxKq75g9oGDm+HgFqOrERGRs0QBSeRU/EOheS/n880/GFuLiIicNQpIIqfT9jLno4bZREQaDAUkkdOpCEjbFkNJgbG1iIjIWaGAJHI6jdtDWHOwFTtDkoiI1HsKSCKnYzJB2/7O5xpmExFpEBSQRKrDNQ9pHjgcxtYiIiIep4AkUh0tLwSLFXJ3wv4NRlcjIiIepoAkUh1+QZBwgfO5htlEROo9wwPSa6+9RkJCAv7+/iQnJ7Ns2bKTtv30009JSkoiPDycoKAgEhMTee+991zHS0tLeeyxx+jcuTNBQUHExcUxYsQI9u7d63aehIQETCaT2zZ+/HiPfUapJ3S5v4hIg2FoQJozZw6pqak89dRTrFy5kq5duzJgwACys7OrbB8ZGcnjjz9ORkYGq1evZuTIkYwcOZLvvvsOgMLCQlauXMkTTzzBypUr+fTTT9mwYQNXXXXVCed69tln2bdvn2u7//77PfpZpR6omKi9MwOK8oytRUREPMrkcBg34zQ5OZkePXowZcoUAOx2O/Hx8dx///2MGTOmWufo1q0bV1xxBePGjavy+PLly+nZsyc7duygefPmgLMH6aGHHuKhhx6qce15eXmEhYWRm5tLaGhojc8jXmZSNzi0Ba5/DzqdGLxFRKRuq+73t2E9SCUlJaxYsYKUlJRjxZjNpKSkkJGRcdrXOxwO0tPT2bBhAxdddNFJ2+Xm5mIymQgPD3fbP378eBo1asR5553HSy+9RFlZWY0/izQg7QY4HzXMJiJSr/kY9cYHDhzAZrMRExPjtj8mJob169ef9HW5ubk0bdqU4uJiLBYLr7/+Ov3796+ybVFREY899hg33HCDW0p84IEH6NatG5GRkfzvf/9j7Nix7Nu3j1deeeWk71tcXExxcbHr57w8DbE0SG37w8+vH7vc32QyuiIREfEAwwJSTYWEhLBq1Sry8/NJT08nNTWVVq1a0bdvX7d2paWlXH/99TgcDqZOnep2LDU11fW8S5cu+Pn5cffdd5OWlobVaq3yfdPS0njmmWdq/fOIl2nRB3wDIT8TMtdAky5GVyQiIh5g2BBbVFQUFouFrKwst/1ZWVnExsae9HVms5k2bdqQmJjIww8/zJAhQ0hLS3NrUxGOduzYwbx58047Ryg5OZmysjK2b99+0jZjx44lNzfXte3atev0H1LqHx8rtOrrfK5hNhGResuwgOTn50f37t1JT0937bPb7aSnp9OrV69qn8dut7sNfVWEo02bNvHDDz/QqFGj055j1apVmM1moqOjT9rGarUSGhrqtkkD5brtyDxj6xAREY8xdIgtNTWVW265haSkJHr27MnEiRMpKChg5MiRAIwYMYKmTZu6eojS0tJISkqidevWFBcX88033/Dee++5htBKS0sZMmQIK1eu5KuvvsJms5GZmQk4lwjw8/MjIyODpUuXcskllxASEkJGRgajR4/mpptuIiIiwphfhHiXNuUBafcyKDwEgZHG1iMiIrXO0IA0dOhQ9u/fz5NPPklmZiaJiYnMnTvXNXF7586dmM3HOrkKCgq499572b17NwEBAXTo0IH333+foUOHArBnzx6+/PJLABITE93ea8GCBfTt2xer1crs2bN5+umnKS4upmXLlowePdptXpLIKYXHQ3QnyP4DtsyHzkOMrkhERGqZoesgeTOtg9TAzXsSlrwKXYbBX94wuhoREammOr8OkohXq7jtyOZ5YLcbW4uIiNQ6BSSRmohPBmsoFB6Evb8aXY2IiNQyBSSRmrD4QutLnM91ub+ISL2jgCRSUxXDbApIIiL1jgKSSE21Kb+P4N6VkJ9tbC0iIlKrFJBEaiokFpp0dT7f/IOxtYiISK1SQBI5ExpmExGplxSQRM6E63L/+WArM7YWERGpNQpIImeiaXcIiIDiXOetR0REpF5QQBI5E2bLscnaGmYTEak3FJBEzpRrHtI8Y+sQEZFao4AkcqZa9wNMkPU75O4xuhoREakFCkgiZyqoETRLcj7frF4kEZH6QAFJpDZomE1EpF5RQBKpDRUBaetCKCs2tBQRETlzCkgitSG2CwTHQEk+7MwwuhoRETlDCkgitcFshjb9nc81zCYi4vUUkERqS9uKgKT1kEREvJ0CkkhtaX0JmCxwYCMc2mZ0NSIicgYUkERqi38YNO/lfL75B2NrERGRM6KAJFKbNMwmIlIvKCCJ1KaKy/23/QilR42tRUREakwBSaQ2RXeE0GZQVgTbfzK6GhERqSEFJJHaZDJpmE1EpB5QQBKpba7bjnwPDoextYiISI0oIInUtpYXgcUPDm+HA5uMrkZERGpAAUmktlmDoUUf53MNs4mIeCUFJBFPOH6YTUREvI4CkognVASkHf+D4iPG1iIiIn+aApKIJzRqDREtwV4KWxcZXY2IiPxJCkginmAyaZhNRMSLKSCJeIorIM3T5f4iIl5GAUnEUxL6gE8AHNkLWWuNrkZERP4EBSQRT/ENcK6JBBpmExHxMgpIIp7kuu3IPGPrEBGRP0UBScSTKgLSrqVw9LCxtYiISLUpIIl4UkQCRLUHhw22LDC6GhERqSYFJBFPa3fc1WwiIuIVFJBEPK3icv/N88BuN7YWERGpFgUkEU+LPx/8QqBgP+xbZXQ1IiJSDYYHpNdee42EhAT8/f1JTk5m2bJlJ2376aefkpSURHh4OEFBQSQmJvLee++5tXE4HDz55JM0adKEgIAAUlJS2LRpk1ubQ4cOMXz4cEJDQwkPD+f2228nPz/fI59PBB8/aN3X+VzDbCIiXsHQgDRnzhxSU1N56qmnWLlyJV27dmXAgAFkZ2dX2T4yMpLHH3+cjIwMVq9ezciRIxk5ciTfffedq82LL77IpEmTmDZtGkuXLiUoKIgBAwZQVFTkajN8+HDWrl3LvHnz+Oqrr/jxxx+56667PP55pQHTbUdERLyKyeEw7h4IycnJ9OjRgylTpgBgt9uJj4/n/vvvZ8yYMdU6R7du3bjiiisYN24cDoeDuLg4Hn74YR555BEAcnNziYmJ4Z133mHYsGGsW7eOTp06sXz5cpKSkgCYO3cugwYNYvfu3cTFxVXrffPy8ggLCyM3N5fQ0NAafHppUPL2wSsdABM8uhmCooyuSESkQaru97dhPUglJSWsWLGClJSUY8WYzaSkpJCRkXHa1zscDtLT09mwYQMXXeRcrXjbtm1kZma6nTMsLIzk5GTXOTMyMggPD3eFI4CUlBTMZjNLly496fsVFxeTl5fntolUW2gTiO0MOGBzutHViIjIaRgWkA4cOIDNZiMmJsZtf0xMDJmZmSd9XW5uLsHBwfj5+XHFFVcwefJk+vd3LsZX8bpTnTMzM5Po6Gi34z4+PkRGRp7yfdPS0ggLC3Nt8fHx1f+wIqBhNhERL2L4JO0/KyQkhFWrVrF8+XKee+45UlNTWbhwocffd+zYseTm5rq2Xbt2efw9pZ5xXe7/A9htxtYiIiKn5GPUG0dFRWGxWMjKynLbn5WVRWxs7ElfZzabadOmDQCJiYmsW7eOtLQ0+vbt63pdVlYWTZo0cTtnYmIiALGxsSdMAi8rK+PQoUOnfF+r1YrVav1Tn1HETdMk8A+HohzYvRyan290RSIichKG9SD5+fnRvXt30tOPzcew2+2kp6fTq1evap/HbrdTXFwMQMuWLYmNjXU7Z15eHkuXLnWds1evXuTk5LBixQpXm/nz52O320lOTj7TjyVychYfaNPP+VzDbCIidZqhQ2ypqalMnz6dGTNmsG7dOu655x4KCgoYOXIkACNGjGDs2LGu9mlpacybN4+tW7eybt06Xn75Zd577z1uuukmAEwmEw899BD/+te/+PLLL1mzZg0jRowgLi6Oa665BoCOHTsycOBA7rzzTpYtW8aSJUsYNWoUw4YNq/YVbCI1pnlIIiJewbAhNoChQ4eyf/9+nnzySTIzM0lMTGTu3LmuSdY7d+7EbD6W4QoKCrj33nvZvXs3AQEBdOjQgffff5+hQ4e62vz973+noKCAu+66i5ycHC644ALmzp2Lv7+/q83MmTMZNWoU/fr1w2w2c9111zFp0qSz98Gl4WrdDzBB5hrI2wuhCuUiInWRoesgeTOtgyQ1Nv1S2LMCrpoM3UYYXY2ISINS59dBEmmwNMwmIlLnKSCJnG1tnet2sWUhlJUYWoqIiFRNAUnkbGtyHgRGQckR2PWz0dWIiEgVFJBEzjaz+VgvkobZRETqJAUkESO4AtI8Y+sQEZEqKSCJGKH1pWAyw/71cHiH0dWIiEglCkgiRgiIgPjylds3qxdJRKSuUUASMYqG2URE6iwFJBGjVKyHtHURlBYZW4uIiLhRQBIxSsy5EBIHZUdhx09GVyMiIsdRQBIxismkYTYRkTpKAUnESLrtiIhInaSAJGKkVheD2RcObYWDW4yuRkREyikgiRjJGgItejufqxdJRKTOUEASMZqG2URE6hwFJBGjVQSk7T9BSYGxtYiICKCAJGK8qLYQ3gJsJc41kURExHAKSCJGM5k0zCYiUscoIInUBa6ANA8cDmNrERERBSSROiHhAvDxh7zdkL3O6GpERBo8BSSRusAvEBIudD7XMJuIiOFqHJDee+89+vTpQ1xcHDt27ABg4sSJfPHFF7VWnEiDcvwwm4iIGKpGAWnq1KmkpqYyaNAgcnJysNlsAISHhzNx4sTarE+k4ai4L9vODCjKNbYWEZEGrkYBafLkyUyfPp3HH38ci8Xi2p+UlMSaNWtqrTiRBiWyJTRqCw4bbFlgdDUiIg1ajQLStm3bOO+8807Yb7VaKSjQQnciNaZhNhGROqFGAally5asWrXqhP1z586lY8eOZ1qTSMNVMcy2eR7Y7cbWIiLSgPnU5EWpqancd999FBUV4XA4WLZsGR988AFpaWn8+9//ru0aRRqOFr3BNwjysyBzNcQlGl2RiEiDVKOAdMcddxAQEMA///lPCgsLufHGG4mLi+PVV19l2LBhtV2jSMPhY4VWfWHD185hNgUkERFDmByOM1u2t7CwkPz8fKKjo2urJq+Ql5dHWFgYubm5hIaGGl2O1Ce/vA1fPQTNesIdmoskIlKbqvv9XaMepOMFBgYSGBh4pqcRkQoV85B2L4eCgxDUyNh6REQaoBoHpI8//pgPP/yQnTt3UlJS4nZs5cqVZ1yYSIMV1gyiz4HstbBlPnT5q9EViYg0ODW6im3SpEmMHDmSmJgYfv31V3r27EmjRo3YunUrl19+eW3XKNLwtKu43F+3HRERMUKNAtLrr7/Om2++yeTJk/Hz8+Pvf/878+bN44EHHiA3VysAi5yxivWQNv8AdpuxtYiINEA1Ckg7d+6kd+/eAAQEBHDkyBEAbr75Zj744IPaq06koWrWE6xhcPQQ7NGQtYjI2VajgBQbG8uhQ4cAaN68OT///DPgXGH7DC+KExEAiw+0udT5XMNsIiJnXY0C0qWXXsqXX34JwMiRIxk9ejT9+/dn6NChXHvttbVaoEiD1VbzkEREjFKjdZDsdjt2ux0fH+dFcHPmzGHJkiW0bduWv/3tb/j6+tZ6oXWN1kESj8vPhgltnc8f3gghMcbWIyJSD1T3+7tGPUhms5mysjKWLVvGV199RUBAACkpKbRo0YK5c+fWuGgROU5wNMSV3xR6sxaMFBE5m2q0DtLcuXO5+eabOXjw4AnHTCYTNpuuuhGpFW0vg72/OofZzrvJ6GpERBqMGvUg3X///Vx//fXs27fPNdxWsf3ZcPTaa6+RkJCAv78/ycnJLFu27KRtp0+fzoUXXkhERAQRERGkpKSc0N5kMlW5vfTSS642CQkJJxwfP378n/sliJwNFfOQtiwAW6mxtYiINCA1CkhZWVmkpqYSE3NmcyLmzJlDamoqTz31FCtXrqRr164MGDCA7OzsKtsvXLiQG264gQULFpCRkUF8fDyXXXYZe/bscbXZt2+f2/bWW29hMpm47rrr3M717LPPurW7//77z+iziHhE3HkQ2AiK82DXUqOrERFpMGoUkIYMGcLChQvP+M1feeUV7rzzTkaOHEmnTp2YNm0agYGBvPXWW1W2nzlzJvfeey+JiYl06NCBf//739jtdtLT011tYmNj3bYvvviCSy65hFatWrmdKyQkxK1dUFDQGX8ekVpntkCbFOdzXc0mInLW1GgO0pQpU/jrX//K4sWL6dy58wlXrT3wwAOnPUdJSQkrVqxg7Nixrn1ms5mUlBQyMjKqVUdhYSGlpaVERkZWeTwrK4uvv/6aGTNmnHBs/PjxjBs3jubNm3PjjTcyevRo11V5VSkuLqa4uNj1c15eXrVqFDljbS+D1XNg0zzo/6zR1YiINAg1CkgffPAB33//Pf7+/ixcuBCTyeQ6ZjKZqhWQDhw4gM1mO2GYLiYmhvXr11erjscee4y4uDhSUlKqPD5jxgxCQkL4y1/+4rb/gQceoFu3bkRGRvK///2PsWPHsm/fPl555ZWTvldaWhrPPPNMteoSqVWtLwWTGbL/gJxdEB5vdEUiIvVejQLS448/zjPPPMOYMWMwm2s0SnfGxo8fz+zZs1m4cCH+/v5VtnnrrbcYPnz4CcdTU1Ndz7t06YKfnx933303aWlpWK3WKs81duxYt9fl5eURH68vKjkLAiOhWQ/nHKTN8yDpNqMrEhGp92qUbkpKShg6dOgZhaOoqCgsFgtZWVlu+7OysoiNjT3laydMmMD48eP5/vvv6dKlS5VtFi9ezIYNG7jjjjtOW0tycjJlZWVs3779pG2sViuhoaFum8hZ07a/83GT1kMSETkbapRwbrnlFubMmXNGb+zn50f37t3dJlhXTLju1avXSV/34osvMm7cOObOnUtSUtJJ2/3nP/+he/fudO3a9bS1rFq1CrPZTHR09J/7ECJnS8Xl/lsXQlnxKZuKiMiZq9EQm81m48UXX+S7776jS5cuJ0zSPtVcnuOlpqZyyy23kJSURM+ePZk4cSIFBQWMHDkSgBEjRtC0aVPS0tIAeOGFF3jyySeZNWsWCQkJZGZmAhAcHExwcLDrvHl5eXz00Ue8/PLLJ7xnRkYGS5cu5ZJLLiEkJISMjAxGjx7NTTfdRERERE1+HSKeF9sFgmMhPxN2LHHOSxIREY+pUUBas2YN553nvAXC77//7nbs+AnbpzN06FD279/Pk08+SWZmJomJicydO9c1cXvnzp1uw3hTp06lpKSEIUOGuJ3nqaee4umnn3b9PHv2bBwOBzfccMMJ72m1Wpk9ezZPP/00xcXFtGzZktGjR7vNLxKpc0wmaJsCv77vHGZTQBIR8aga3axWdLNaMcAfX8CHI6BRG7h/hdHViIh4JY/erFZEDNCqL5h94OBmOLjF6GpEROo1BSQRb+EfBs3LL2DY/IOxtYiI1HMKSCLexHW5v247IiLiSQpIIt6k4nL/bYuhpNDYWkRE6jEFJBFv0rgDhDUHWzFsX2x0NSIi9ZYCkog3MZk0zCYichYoIIl4m4phtk3fg1bpEBHxCAUkEW/T8kKwWCFnJxzYaHQ1IiL1kgKSiLfxC4KEC5zPN35nbC0iIvWUApKINzp+mE1ERGqdApKIN6qYqL0zA4ryjK1FRKQeUkAS8UaNWkNka7CXwdaFRlcjIlLvKCCJeCsNs4mIeIwCkoi3cq2HNE+X+4uI1DIFJBFv1aIP+AZCfiZkrjG6GhGRekUBScRb+fpDy4udzzXMJiJSqxSQRLzZ8cNsIiJSaxSQRLxZRUDavQwKDxlbi4hIPaKAJOLNwptD447gsMOW+UZXIyJSbyggiXg7DbOJiNQ6BSQRb1exHtLmeWC3G1uLiEg9oYAk4u2anw9+IVB4EPb+anQ1IiL1ggKSiLez+ELrS5zPdbm/iEitUEASqQ902xERkVqlgCRSH7RJcT7uXQn52cbWIiJSDyggidQHoU0gtovz+eZ0Y2sREakHFJBE6gsNs4mI1BoFJJH6ot0A5+OWdLCVGVuLiIiXU0ASqS+adoeACCjKhd3Lja5GRMSrKSCJ1Bdmy7HJ2pu+M7YWEREvp4AkUp+45iHptiMiImdCAUmkPmndDzBB1u+Qu8foakREvJYCkkh9EtQImiU5n29WL5KISE0pIInUNxpmExE5YwpIIvVN2/7Ox60LoazY0FJERLyVApJIfRPbFYKioSQfdmYYXY2IiFdSQBKpb8zmY71IGmYTEakRBSSR+sgVkHTbERGRmlBAEqmPWl0CJgsc2AiHthldjYiI11FAEqmPAsKh+fnO55t/MLQUERFvZHhAeu2110hISMDf35/k5GSWLVt20rbTp0/nwgsvJCIigoiICFJSUk5of+utt2Iymdy2gQMHurU5dOgQw4cPJzQ0lPDwcG6//Xby8/M98vlEDKNhNhGRGjM0IM2ZM4fU1FSeeuopVq5cSdeuXRkwYADZ2dlVtl+4cCE33HADCxYsICMjg/j4eC677DL27HFfMXjgwIHs27fPtX3wwQdux4cPH87atWuZN28eX331FT/++CN33XWXxz6niCEq1kPa9iOUHjW2FhERL2NyOBwOo948OTmZHj16MGXKFADsdjvx8fHcf//9jBkz5rSvt9lsREREMGXKFEaMGAE4e5BycnL4/PPPq3zNunXr6NSpE8uXLycpybni8Ny5cxk0aBC7d+8mLi6uWrXn5eURFhZGbm4uoaGh1XqNyFnlcMD/nQN5e2D4x8d6lEREGrDqfn8b1oNUUlLCihUrSElJOVaM2UxKSgoZGdVbu6WwsJDS0lIiIyPd9i9cuJDo6Gjat2/PPffcw8GDB13HMjIyCA8Pd4UjgJSUFMxmM0uXLj3pexUXF5OXl+e2idRpJpOG2UREasiwgHTgwAFsNhsxMTFu+2NiYsjMzKzWOR577DHi4uLcQtbAgQN59913SU9P54UXXmDRokVcfvnl2Gw2ADIzM4mOjnY7j4+PD5GRkad837S0NMLCwlxbfHx8dT+qiHFctx353tmjJCIi1eJjdAE1NX78eGbPns3ChQvx9/d37R82bJjreefOnenSpQutW7dm4cKF9OvXr8bvN3bsWFJTU10/5+XlKSRJ3dfyYjD7wuHtcHAzRLU1uiIREa9gWA9SVFQUFouFrKwst/1ZWVnExsae8rUTJkxg/PjxfP/993Tp0uWUbVu1akVUVBSbN28GIDY29oRJ4GVlZRw6dOiU72u1WgkNDXXbROo8azAk9HE+1zCbiEi1GRaQ/Pz86N69O+np6a59drud9PR0evXqddLXvfjii4wbN465c+e6zSM6md27d3Pw4EGaNGkCQK9evcjJyWHFihWuNvPnz8dut5OcnHwGn0ikjjp+mE1ERKrF0Mv8U1NTmT59OjNmzGDdunXcc889FBQUMHLkSABGjBjB2LFjXe1feOEFnnjiCd566y0SEhLIzMwkMzPTtYZRfn4+jz76KD///DPbt28nPT2dq6++mjZt2jBgwAAAOnbsyMCBA7nzzjtZtmwZS5YsYdSoUQwbNqzaV7CJeJWKgLR9CRRrvS8RkeowNCANHTqUCRMm8OSTT5KYmMiqVauYO3eua+L2zp072bdvn6v91KlTKSkpYciQITRp0sS1TZgwAQCLxcLq1au56qqraNeuHbfffjvdu3dn8eLFWK1W13lmzpxJhw4d6NevH4MGDeKCCy7gzTffPLsfXuRsadQGIlqCvRSWTIRDWzVhW0TkNAxdB8mbaR0k8SrfjoGlU4/9HBLnnJvUonyLautcFkBEpJ6r7ve3117FJiJ/wsV/B78g2L4Y9qyEI3thzUfODSAoGlr0hoQLnI+NO4LZ8DsRiYgYRj1INaQeJPFaJYWwexns+J9zXtLu5WArdm8TEOkMSi36OB9jO4PZYky9IiK1qLrf3wpINaSAJPVGaRHsWeEMTDt+gl3LoLTQvY01DJqff2xYrklXsPgaU6+IyBlQQPIwBSSpt8pKYN8q2LHE2cO082coOeLexjcImieX9zJdAE27gY+1ytOJiNQlCkgepoAkDYatDDJXl/cwLXE+FuW4t/Hxh2Y9nL1LCX2cz30DDClXRORUFJA8TAFJGiy7HbL/KO9h+skZmAoPuLex+EHT7sfmMcUnO1f1FhExmAKShykgiZRzOGD/hvLepfJhufxKN342+0CTxGNXyjU/H/zDDClXRBo2BSQPU0ASOQmHw7kYZUVY2rEEcne5tzGZnVfGVazD1KI3BEYaU6+INCgKSB7mqYBUUmZnf34xTcM1f0PqkZyd5WHpJ+fj4W0ntok+p7yHqTw0BUef/TpFpN5TQPIwTwQkm93Bg7N/Zem2Q7x7W086NlHPlNRTeXvL12Eqn8N0YMOJbaLaHethSugDobpXooicOQUkD/NEQMopLGHYmz+zPvMIof4+vHVrD5ISNOwgDUD+fvc5TNlrT2wT0fJYWGp/OQREnP06RcTrKSB5mKeG2HKPlnLHjOUs334Yf18zU4d355IOGmqQBqbwEOzMODaHKXM1OOzHjvsGQtcbIPlv0LidcXWKiNdRQPIwT07SPlpi475ZK5m/Phsfs4kJf+3KNec1rdX3EPEqRbmwc6lzDtPG72H/umPHWl8KyfdAmxTdP05ETksBycM8fRVbqc3O3z9ezWe/7gHgqcGdGNmnZa2/j4jXcTicN939eRps+AYo/yesURvoeTck3gDWEENLFJG6SwHJw87GZf52u4Nnv/qDd/63HYAH+rVldEpbTCaTR95PxOsc2gbLpsOv70FxnnOfNRTOuwl63gWR+o8KEXGngORhZ2sdJIfDwZT5m3l53kYAbj6/Bc9cdQ5ms0KSiEtxPvz2ASydBgc3l+80OSdzJ/8NWl4E+g8LEUEByePO9kKR7/28gye/+B2HAwZ3jePlv3bFz0fzLUTc2O2wJR1+nup8rBDdCZLvhi5DdY84kQZOAcnDjFhJ+7+/7SX1w1WU2hxc1K4x027qRqCfz1l5bxGvs38jLHsDVs2C0kLnvoAI6H4r9LgDwpoZWp6IGEMBycOMutXIoo37+dt7KzhaauO85uG8fWsPwgP9ztr7i3idoznOOUrL3nSu6A1gskCnq5zDb/HJGn4TaUAUkDzMyHuxrdx5mJFvLyf3aCntYoJ597ZkYsP8z2oNIl7HbnNe9bb0DedVcBWaJML598A514KP1bDyROTsUEDyMKNvVrsx6wg3/2cpWXnFNIsI4L3bk2kZFXTW6xDxSplrnBO6V38EtmLnvqBo6HE7dB8JITHG1iciHqOA5GFGBySAXYcKGfHWMrYdKCAq2I93Rvbk3KZhhtQi4pUKDsCKt2H5f+DIPuc+ix+c8xc4/28Qd56x9YlIrVNA8rC6EJAADuQXc8tby1i7N48Qqw/Tb0ni/FaNDKtHxCvZSuGPL5y9SruXH9sff74zKHUYDBZdECFSHyggeVhdCUgAeUWl3DnjF5ZuO4Sfj5nXbuxG/04aIhCpkd0rYOlUWPsZ2Muc+0KbOq98634rBOoG0iLeTAHJw+pSQAIoKrVx/we/Mu+PLCxmEy9c14Uh3XUZs0iN5e2DX95yboUHnPt8AqDL9c6r32I6GVufiNSIApKH1bWABFBmszPm0zV8vGI3AP+8oiN3XNjK4KpEvFxpEfz+ibNXKXPNsf0tL3LeJLfdADBbjKtPRP4UBSQPq4sBCZy3Jkn7dj1v/rgVgHv7tubRAe11/zaRM+VwwM4M5yrd678Ch925PyLBeZPc84aDvy6SEKnrFJA8rK4GpApTF27hhbnrAbihZzz/uqYzFt2/TaR25Ox03iR35QwoynXu8wuGxOHOW5o0am1sfSJyUgpIHlbXAxLAB8t28vhna7A74PJzY5k4LBGrj4YCRGpNSQGsnuNcfHL/+mP7217mnKfU+lKt0i1SxyggeZg3BCSAb9fs48HZqyix2enTphFv3JxEsFWXK4vUKocDti6An6fBpu+O7Y9q7+xR6joM/LSQq0hdoIDkYd4SkAD+t/kAd777CwUlNro2C+PtkT2JDNL920Q84uAW533ffp0JJUec+/zDoNsI6HkXhDc3tj6RBk4BycO8KSABrN6dw61vL+dQQQmtGwfx3u3JxIUHGF2WSP1VlAerZjqH3w5vc+4zmaHDFc6r31r01vCbiAEUkDzM2wISwObsfEb8Zyl7c4uIC/Pn3duTaRMdbHRZIvWb3Qab5jmXCdi68Nj+2M6QcCEEx0BIrPtjQITCk4iHKCB5mDcGJIC9OUe5+T9L2bK/gIhAX94Z2ZOu8eFGlyXSMGSvc97O5Lc5UHb05O0sVucNc4Njq3g8LkwFRoHZfPbqF6kHFJA8zFsDEsChghJGvr2M33bnEuRn4c0RSfRpE2V0WSINR+Eh561McnbAkUznlp/lfCzKqf55TBYIjq66Fyok9rhgFQMWX499HBEA7HawFUNZEZSVOB9tJVBW7NyOP2YrPrbf1a6KY5c8DkG1e39RBSQP8+aABJBfXMbd7/3Cks0H8bOYmXRDIgPPbWJ0WSJSWuQMSxWByfWYCUeyjj0W7Af+xD/fgY1O0iNV6dEv0GMf7axwOJxftqVHnV+41X4sci7+aTKDifLHU22mY88xnb7NSfefrI250vlP1+644/ayKoJJFc9dP1eEmVMdqwgwxe5h5vhjFfcurE2jVkBUm1o9pQKSh3l7QAIoLrPx0OxVfPt7JmYTPH9tZ4b11BU2Il7BVuYMSZWD0wmPWWAvrf55raGn6JGKgZAmzjBlDa3ePCm7vfzL9DQhpfSoc9ixtKgaj6c5158JjuIhJvCxOoeLfY7bLFbw8QMff7D4Vdrv7zx2/Gt63AnBjWu1MgUkD6sPAQnAZnfwz8/X8MGyXQA8NrADf7u4lW5NIlJf2O1w9HB5YMqsomcqC47sc4apU82Lqswn4Fivk8l88jBjK/bcZzsdk9lZp69/FY/+4Bvg/mi2OHuRHI5Kj6faHMCp2lV1rPK+07wPjmrUctxxk7k8YFQVQqp67ncsnPj4VxFijg8uVYSYqs5t8a2zFxooIHlYfQlI4Lx/20vfbeD1hVsAuPPClvxjUEeFJJGGxOGA4rwqeqEqh6ksKM6t2XuYfcA3sDyUVBVaTvdYRahxPQae+Jo6/CUtxqnu97fhSyq/9tprvPTSS2RmZtK1a1cmT55Mz549q2w7ffp03n33XX7//XcAunfvzvPPP+9qX1payj//+U+++eYbtm7dSlhYGCkpKYwfP564uDjXeRISEtixY4fbudPS0hgzZoyHPmXdZjKZ+PvADkQE+vHcN+uYvngbhwtLGf+XzvhYdIWMSINgMjkXtPQPg8btTt229OixwJSf5ey1qE7IsRj+lSNSbYb2IM2ZM4cRI0Ywbdo0kpOTmThxIh999BEbNmwgOjr6hPbDhw+nT58+9O7dG39/f1544QU+++wz1q5dS9OmTcnNzWXIkCHceeeddO3alcOHD/Pggw9is9n45ZdfXOdJSEjg9ttv584773TtCwkJISio+rcCqE89SMf7eMVuHvtkNTa7g/6dYph8w3n4++r+bSIiUj94xRBbcnIyPXr0YMqUKQDY7Xbi4+O5//77q9WbY7PZiIiIYMqUKYwYMaLKNsuXL6dnz57s2LGD5s2dE5ATEhJ46KGHeOihh2pce30NSADz/sjivlkrKSmzk9wykum3JBHqr0uERUTE+1X3+9uw8ZOSkhJWrFhBSkrKsWLMZlJSUsjIyKjWOQoLCyktLSUyMvKkbXJzczGZTISHh7vtHz9+PI0aNeK8887jpZdeoqzs1JcnFhcXk5eX57bVV/07xfDubT0JsfqwdNshbnjzZw7kGzjRUkRE5CwzLCAdOHAAm81GTEyM2/6YmBgyMzOrdY7HHnuMuLg4t5B1vKKiIh577DFuuOEGt5T4wAMPMHv2bBYsWMDdd9/N888/z9///vdTvldaWhphYWGuLT4+vlo1eqvzWzXig7vOJyrYj7V78/jrtAx2HSo0uiwREZGzwmtn4I4fP57Zs2fz2Wef4e/vf8Lx0tJSrr/+ehwOB1OnTnU7lpqaSt++fenSpQt/+9vfePnll5k8eTLFxSfvJRk7diy5ubmubdeuXbX+meqac5uG8dHfetM0PIBtBwoYMu1/bMw6YnRZIiIiHmdYQIqKisJisZCVleW2Pysri9jY2FO+dsKECYwfP57vv/+eLl26nHC8Ihzt2LGDefPmnXaOUHJyMmVlZWzfvv2kbaxWK6GhoW5bQ9AyKohP7ulNu5hgsvKK+eu0DFbuPGx0WSIiIh5lWEDy8/Oje/fupKenu/bZ7XbS09Pp1avXSV/34osvMm7cOObOnUtSUtIJxyvC0aZNm/jhhx9o1Oj093BZtWoVZrO5yivnBGLD/Pnw7l6c1zyc3KOlDJ++lEUb9xtdloiIiMcYOsSWmprK9OnTmTFjBuvWreOee+6hoKCAkSNHAjBixAjGjh3rav/CCy/wxBNP8NZbb5GQkEBmZiaZmZnk5+cDznA0ZMgQfvnlF2bOnInNZnO1KSkpASAjI4OJEyfy22+/sXXrVmbOnMno0aO56aabiIiIOPu/BC8RHujHzDuSuahdY46W2rhjxnL++9teo8sSERHxCMNX0p4yZYprocjExEQmTZpEcnIyAH379iUhIYF33nkHqHqBR4CnnnqKp59+mu3bt9OyZcsq32fBggX07duXlStXcu+997J+/XqKi4tp2bIlN998M6mpqVit1mrXXZ8v8z+VkjI7qR+u4qvV+zCZ4Nmrz+Xm81sYXZaIiEi1eMU6SN6soQYkcN6/7ekv1/Lez86wmtq/Hfdf2ka3JhERkTqvzq+DJN7LYjbx7NXn8EC/tgC8Mm8jz371B3a7sraIiNQPCkhSIyaTidT+7Xh6cCcA3l6ynYc/+o1Sm93gykRERM6cApKckVv7tGTi0ER8zCY++3UPd7+3gqMlNqPLEhEROSMKSHLGrjmvKdNHJOHva2b++mxu/s9Sco+WGl2WiIhIjSkgSa24pEM079+eTKi/D7/sOMzQNzLIzisyuiwREZEaUUCSWpOUEMmcu3vROMTK+swjDJmWwR976+9NfUVEpP5SQJJa1bFJKJ/8rTfNIwPZeaiQq1/7iWmLtmDTFW4iIuJFFJCk1jVvFMhn9/amf6cYSm0Oxn+7nhum/8zuw4VGlyYiIlItCkjiEY2Crbx5c3devK4LQX4Wlm07xOUTF/PJit1obVIREanrFJDEY0wmE9f3iOfbBy+ie4sIjhSX8fBHv3HfrJUcLigxujwREZGTUkASj2veKJA5d53PI5e1w8ds4ps1mQyY+COLNu43ujQREZEqKSDJWeFjMTPq0rZ8dm8fWjcOIvtIMbe8tYynvvhdC0uKiEido4AkZ1XnZmF8df+F3NKrBQAzMnZw5eTFrNmda3BlIiIixyggyVkX4GfhmavPZcZtPYkOsbJlfwHXvr6EKfM3aTkAERGpExSQxDAXt2vMdw9dxKDOsZTZHUz4fiPXv5HBzoNaDkBERIylgCSGigjy47Ubu/HyX7sSbPVhxY7DXP7qj3y4fJeWAxAREcMoIInhTCYT13VvxrcPXkjPhEgKSmz8/ZPV3P3eCg7mFxtdnoiINEAKSFJnxEcG8sFd5zPm8g74Wkx8/0cWAyYuZv76LKNLExGRBkYBSeoUi9nE3y5uzef39aFdTDAH8ou57Z1fePyzNRSWlBldnoiINBAKSFInnRMXxpejLuD2C1oCMHPpTq6Y9BOrduUYW5iIiDQICkhSZ/n7Wnjiyk7MvCOZ2FB/th0o4Lqp/2PiDxsps9mNLk9EROoxBSSp8/q0ieK7hy5icNc4bHYHE3/YxHXTMth2oMDo0kREpJ5SQBKvEBboy+QbzuPVYYmE+Pvw264cBr26mJlLd2g5ABERqXUKSOJVrk5syncPXUSvVo04Wmrj8c9+544Zv7D/iJYDEBGR2qOAJF4nLjyAmXck888rOuLnYyZ9fTYDJv7I92szjS5NRETqCQUk8Upms4k7LmzFf0ddQIfYEA4VlHDXeyt47OPV5BdrOYDKymx2NmYdYev+fLLziigoLsOu+96JiJyUyaEJHDWSl5dHWFgYubm5hIaGGl1Og1ZcZuOV7zfy5uKtOBzQPDKQ/xvale4tIo0uzVD7jxSzaON+FmzIZvHG/eQVuQdHkwkCfS0EWX0ItvoQaLUQ5Od8HmT1Iaj8Z9fz8nZBfs62Fe2CrT4E+jnbms0mgz6tiEj1VPf7WwGphhSQ6p6ftx7k4Q9/Y0/OUcwmuLdvGx5MaYuvpWF0lNrsDlbtymHRhmwWbNjPmj25bseD/CyYTSbyS8rw1P/rA/2cQSqo4vG458GVfj4+XB0LZcfCWJCfDxYFLhGpZQpIHqaAVDflFZXy9Bdr+fTXPQB0bhrG/w1NpE10sMGVecbB/GJ+3LSfhRv2s2jjfnIKS92Od2kWRt92jenbIZquzcKxmE04HA6OltooKLZRUFxGfnEZhSXHnhcUl1FQ/vPxx092rKC4DE+N1gX4WtwCU5DVQoi/L92ah9OvYwwdYkMwmRSiRKT6FJA8TAGpbvt69T7+8dkaco+WYvUx849BHRnRq4XXf5na7Q5W78llYXkv0erdOW69QaH+PlzUrjF920dzcbvGNA6xerwmh8NBcZn9WIAqtlFQUh6siv9E8DrueFk1E1dcmD+XdoymX8cYerVqhL+vxcOfVkS8nQKShykg1X2ZuUU8+vFvLN50AICL2jXmpSFdiAn1N7iyP+dwQQk/btrPovJeooMFJW7Hz4kLpW/7xlzSPprE+HB8vHxIsSJwnaxXa/+RYhZv2s9Pmw9QVHpsRfUAXwt92kSR0jGaSzpEe93fWUTODgUkD1NA8g52u4N3M7aT9u16isvshAf68vy1nRnUuYnRpZ2U3e7gj315LFifzYIN2azaleM2hBVi9eHCdlH0bRfNxe0bN9ggUFRqI2PLQX5Yl8X89dnsyy1yO965aRiXdogmpWMM58SFagK5iAAKSB6ngORdNmcf4cHZq1i7Nw+Av3RrytNXnUOov6/BlTnlHi1lcflcooUb9nMg333hyw6xIfRtH80l7RvTrUVEg5l4Xl0Oh4N1+46Qvi6L9PXZ/FZp6DE6xMqlHZxDcX3aNCLQz8e4YkXEUApIHqaA5H1Kyuy8mr6RqQu3YHdA0/AAXrm+K8mtGp31Wiq+0BdsyGbRhv2s2HkY23HdREF+Fi5oG0Xf9tH0bd+YJmEBZ71Gb7b/SDELNmQzf102izftp6DE5jrm52Omd+tG9OsQzaUdY2gart+tSEOigORhCkje65fthxj94Sp2HTqKyQR3XdSK1P7tsPp4doLvkaJSlmw+wIL1+1m4MZusPPdeorbRwVzSIZq+7RqTlBCJn496iWpDcZmNZdsOkb4umx/WZbH78FG34x1iQ+jXMZpLO8SQGB+upQVE6jkFJA9TQPJu+cVlPPvftXz4y24AOjYJ5dVhibSLCam193A4HGzMymfBhmwWbsjml+2H3a7Ock4qbuTqJWoWEVhr7y1VczgcbM7O54d12cxfn8WKHYfd5nc1CvKjb/to+nWM5sK2UYTUkSFYEak9CkgepoBUP8z9PZN/fLaGQwUl+PmYeWxgB0b2TqjxhN6C4jJnL9GG/SzakM3eShOHWzUO4pLyQNSzZaTHe63k1A4XlLBwYzbp67JZtHE/R45bbdzXYiK5ZaPyuUvRtGgUZGClIlJbFJA8TAGp/sg+UsRjH69mwYb9APRp04gJf+1arXk/DoeDLfvzXcNmy7YdotR27P9S/r5merVqVD50Fk3zRuolqqtKbXaWbz/E/HXZzF+fzdYDBW7H20QHO+ctdYime4sIr19OQaShUkDyMAWk+sXhcDBz6U7+9fUfFJXaCfX34V/XduaqrnEntC0sKSNjy8HyobP9J8xpadEo0NVLdL4WL/RaW/fnM3+9s3dp+fZDbsOjYQG+9G3fmEvLg29YoIbixHh2u4M9Oc65lU3DA7x+YVxP8ZqA9Nprr/HSSy+RmZlJ165dmTx5Mj179qyy7fTp03n33Xf5/fffAejevTvPP/+8W3uHw8FTTz3F9OnTycnJoU+fPkydOpW2bdu62hw6dIj777+f//73v5jNZq677jpeffVVgoOrfzsKBaT6aev+fEbPWcVvu533Mbs6MY5nrzqXgwXFLNzgvPHr0m2HKCk7tkChn4+Z81s14pL2zhWsW0ZpKKa+yT1ayo8b9zO/fG2q42/pYjGbSGoR4Zro3bpxkL6YxKMcDmcQ2pSVz8asI2zIOsKmrHw2Z+dztNR5xWZEoC/nNg2jS7MwOjcNo3OzcOLC/PW/TbwkIM2ZM4cRI0Ywbdo0kpOTmThxIh999BEbNmwgOjr6hPbDhw+nT58+9O7dG39/f1544QU+++wz1q5dS9OmTQF44YUXSEtLY8aMGbRs2ZInnniCNWvW8Mcff+Dv71xQ7/LLL2ffvn288cYblJaWMnLkSHr06MGsWbOqXbsCUv1VarMzZf5mpizYjM3uwM/H7BaIAJpFBHBJ+2gu6eDsJdK6Og2Hze5g5c7DpJdP9N6Yle92PKFRIJd2iKFfx2h66GpEOQMOh4N9uUVsLA9AG7OOsDE7n81ZR9yWrjien8WM3eGo8nY9kUF+zrDUNIzO5cGpSQMMTV4RkJKTk+nRowdTpkwBwG63Ex8fz/3338+YMWNO+3qbzUZERARTpkxhxIgROBwO4uLiePjhh3nkkUcAyM3NJSYmhnfeeYdhw4axbt06OnXqxPLly0lKSgJg7ty5DBo0iN27dxMXd+KQSlUUkOq/X3ceZvScVWw/WOiasNu3vJdIvQRSYefBQuavdy5Q+fPWg25z0EKsznvjXdrBOeTaKNjz98arTXa7gxKbneIyO8VlNopLnc9LKn4ufx4a4EuTMH+igq1aJqEGHA4H2UeKnb1BmeVhKPsIm7PyOVJcVuVrfC0mWkUF0zYmmHYxIbSLCaZtTAgtIgMpszvYkHmENXtyWbM7lzV7ctmYdaTK0BQV7OfsaWoaVt7jFE5MqLVe//tW5wNSSUkJgYGBfPzxx1xzzTWu/bfccgs5OTl88cUXpz3HkSNHiI6O5qOPPuLKK69k69attG7dml9//ZXExERXu4svvpjExEReffVV3nrrLR5++GEOHz7sOl5WVoa/vz8fffQR1157bbXqV0BqGIpKbWzMOkLrxsEEWdVLJKeWX1zGT5v2k77OORR3IP/YffNMJujWPMJ1VVz7mJBTfgnZ7Y4TwsixRzvFpXZneCk9ts+tbamdElvVoabqtieeq8RmP2l9VbGYTcSEWIkN86dJeABNQv2dz8MCyh/9iQ6xNtgJ7g6Hg/35xcd6g7Ly2ZR1hI1ZR8grqjoI+ZhNJEQFOQNQdIgrDCVEBf2pFfWLSm2szzzCmt05rNmTy+rduWzKzndboLZCVLCVLs3CXMGpc7OwenVLo+p+fxv2L/6BAwew2WzExMS47Y+JiWH9+vXVOsdjjz1GXFwcKSkpAGRmZrrOUfmcFccyMzNPGL7z8fEhMjLS1aYqxcXFFBcfW9gvLy+vWjWKd/P3tdClWbjRZYiXCLb6MPDcJgw8twl2u4Pfdue4Jnr/sS+PFTsOs2LHYV76bgNNwwOIDPI7aXA5vieqLjCZwOpjxs9ixuprwepjxupjxtdiJu9oKVlHirHZHezNLXIub7Ezp8rzmE0QHeLvCkwVj03CAlw/x4T6e/3tdA7mF7vmBrmGyLKPuM1fO57FbKJFo0DaRR/rDWoXE0LLqKBaGab197WQGB9OYny4a19RqY0/9uXxe3lg+r28p+lAfjHz1zuv5qwQHWJ1G5rr3CyM6JD6E5qq4rX/STx+/Hhmz57NwoULXXOLPCktLY1nnnnG4+8jIvWD2WzivOYRnNc8gocva8/enKOuL50lmw+wJ+coe3KOnv5EHAsnVp/yYOJbHlR8LFh9nUHFz+dYaPGr1NZaKdRUPu5nOXYeq4+l/Lh7W1+L6ZQ9XmU2OwfyS9iXe5TM3CL25RaRmVfE3pxjP2flFVFmd5CZ5zy2atfJP29UsLU8OLn3QMWGOn+OCbPWiXXEDheUuOYGVfQGbcrK52BBSZXtTSZoERlYHoAqhsdCaNU46Kx/Hn9fC92aR9CteYRr39ESZ2hy9jTlsWZPDpuz88k+Ukz6+mzSjwtNMaFWOjcNp3P5ZPBzm4bROMS7hpFPxbCAFBUVhcViISsry21/VlYWsbGxp3zthAkTGD9+PD/88ANdunRx7a94XVZWFk2aHLtbe1ZWlmvILTY2luzsbLfzlZWVcejQoVO+79ixY0lNTXX9nJeXR3x8/Kk/pIhIubjwAG46vwU3nd+CoyU2ftlxiFKb/VhQOT6Y+Lr31PiYTx1O6gIfi5nY8h6gk7HbHRwoKCYzt4i9OUVk5h5lX17RsUBVvpXY7Ow/Usz+I8WsLr+itCpRwX7O9ww91vsUF+7+c20ts5FbWMrG7CPuE6az8k+4sXQFkwniIwKP6w1yDpG1iQ6u00t/BPhZ6N4igu4tjoWmwpIy/tib5zanafP+fLLyisnKy+KHdce+x5uE+R+b01Te2xTlZXPvKhgWkPz8/OjevTvp6emuOUh2u5309HRGjRp10te9+OKLPPfcc3z33XeuSdYVWrZsSWxsLOnp6a5AlJeXx9KlS7nnnnsA6NWrFzk5OaxYsYLu3bsDMH/+fOx2O8nJySd9X6vVitXqnX9kEalbAvwsXNi2sdFlnHVms4noEH+iQ/zp0qzqNna7g0OFJceFpqPsK39+fO9UcZmzx+pAfgm/7zn5lIeIQF9iwwKICzt+WC/AbXjv+KtQ84pK2eSaG5TPpvJQVPneicdrGh7g7A2KDSkfIguhdXRQvbm6NdDPh6SESJISIl37CorL+GNfnmtobvXuHLYeKHD9reb9cSw0xYX5Hzc05+xxigzyM+Kj/CmGX+Z/yy238MYbb9CzZ08mTpzIhx9+yPr164mJiWHEiBE0bdqUtLQ0wHkJ/5NPPsmsWbPo06eP6zzBwcGuNYxeeOEFxo8f73aZ/+rVq0+4zD8rK4tp06a5LvNPSkrSZf4iIl7A4XCQU1haPox3tLw3qsj1877cIvblFLnWBDqdsABfYkP9yStynvNk4sL8j/UGlQ+NtY3WBRwV8ovLWLvH2cNUsW3dX1Bl26bhAe5zmpqGEXGWQlOdv4qtwpQpU1wLRSYmJjJp0iRXT07fvn1JSEjgnXfeASAhIYEdO3accI6nnnqKp59+Gji2UOSbb75JTk4OF1xwAa+//jrt2rVztT906BCjRo1yWyhy0qRJWihSRKSecDgc5B0tY195YKqyRyrnaJXrCcWEWl1zgyrCUNvoYN28uAaOFJWydm+ea2huzZ5cth2oOjQ1iwg47uo5Z0+TJ1ap95qA5K0UkEREvN+RolJXeAr0s9A2JoSwAAUhT8orKuX3PbluV89tP1hYZduP/9bLbWivVt6/rl/mLyIiYrQQf19C/H1pGxNidCkNRqi/L71bR9G7dZRrX+7RUtbuyWV1xfDc7lx2HS6kXaxxfxcFJBERETFUWIAvvdtE0bvNsdCUV1RKqIHDmt69EpeIiIjUS0aGI1BAEhERETmBApKIiIhIJQpIIiIiIpUoIImIiIhUooAkIiIiUokCkoiIiEglCkgiIiIilSggiYiIiFSigCQiIiJSiQKSiIiISCUKSCIiIiKVKCCJiIiIVKKAJCIiIlKJj9EFeCuHwwFAXl6ewZWIiIhIdVV8b1d8j5+MAlINHTlyBID4+HiDKxEREZE/68iRI4SFhZ30uMlxugglVbLb7ezdu5eQkBBMJpPR5dQ5eXl5xMfHs2vXLkJDQ40uR9DfpK7R36Nu0d+jbvHk38PhcHDkyBHi4uIwm08+00g9SDVkNptp1qyZ0WXUeaGhofrHpo7R36Ru0d+jbtHfo27x1N/jVD1HFTRJW0RERKQSBSQRERGRShSQxCOsVitPPfUUVqvV6FKknP4mdYv+HnWL/h51S134e2iStoiIiEgl6kESERERqUQBSURERKQSBSQRERGRShSQRERERCpRQJJalZaWRo8ePQgJCSE6OpprrrmGDRs2GF2WlBs/fjwmk4mHHnrI6FIarD179nDTTTfRqFEjAgIC6Ny5M7/88ovRZTVINpuNJ554gpYtWxIQEEDr1q0ZN27cae/RJbXnxx9/ZPDgwcTFxWEymfj888/djjscDp588kmaNGlCQEAAKSkpbNq06azUpoAktWrRokXcd999/Pzzz8ybN4/S0lIuu+wyCgoKjC6twVu+fDlvvPEGXbp0MbqUBuvw4cP06dMHX19fvv32W/744w9efvllIiIijC6tQXrhhReYOnUqU6ZMYd26dbzwwgu8+OKLTJ482ejSGoyCggK6du3Ka6+9VuXxF198kUmTJjFt2jSWLl1KUFAQAwYMoKioyOO16TJ/8aj9+/cTHR3NokWLuOiii4wup8HKz8+nW7duvP766/zrX/8iMTGRiRMnGl1WgzNmzBiWLFnC4sWLjS5FgCuvvJKYmBj+85//uPZdd911BAQE8P777xtYWcNkMpn47LPPuOaaawBn71FcXBwPP/wwjzzyCAC5ubnExMTwzjvvMGzYMI/Wox4k8ajc3FwAIiMjDa6kYbvvvvu44oorSElJMbqUBu3LL78kKSmJv/71r0RHR3Peeecxffp0o8tqsHr37k16ejobN24E4LfffuOnn37i8ssvN7gyAdi2bRuZmZlu/26FhYWRnJxMRkaGx99fN6sVj7Hb7Tz00EP06dOHc8891+hyGqzZs2ezcuVKli9fbnQpDd7WrVuZOnUqqamp/OMf/2D58uU88MAD+Pn5ccsttxhdXoMzZswY8vLy6NChAxaLBZvNxnPPPcfw4cONLk2AzMxMAGJiYtz2x8TEuI55kgKSeMx9993H77//zk8//WR0KQ3Wrl27ePDBB5k3bx7+/v5Gl9Pg2e12kpKSeP755wE477zz+P3335k2bZoCkgE+/PBDZs6cyaxZszjnnHNYtWoVDz30EHFxcfp7iIbYxDNGjRrFV199xYIFC2jWrJnR5TRYK1asIDs7m27duuHj44OPjw+LFi1i0qRJ+Pj4YLPZjC6xQWnSpAmdOnVy29exY0d27txpUEUN26OPPsqYMWMYNmwYnTt35uabb2b06NGkpaUZXZoAsbGxAGRlZbntz8rKch3zJAUkqVUOh4NRo0bx2WefMX/+fFq2bGl0SQ1av379WLNmDatWrXJtSUlJDB8+nFWrVmGxWIwusUHp06fPCctebNy4kRYtWhhUUcNWWFiI2ez+NWixWLDb7QZVJMdr2bIlsbGxpKenu/bl5eWxdOlSevXq5fH31xCb1Kr77ruPWbNm8cUXXxASEuIaJw4LCyMgIMDg6hqekJCQE+Z/BQUF0ahRI80LM8Do0aPp3bs3zz//PNdffz3Lli3jzTff5M033zS6tAZp8ODBPPfcczRv3pxzzjmHX3/9lVdeeYXbbrvN6NIajPz8fDZv3uz6edu2baxatYrIyEiaN2/OQw89xL/+9S/atm1Ly5YteeKJJ4iLi3Nd6eZRDpFaBFS5vf3220aXJuUuvvhix4MPPmh0GQ3Wf//7X8e5557rsFqtjg4dOjjefPNNo0tqsPLy8hwPPvigo3nz5g5/f39Hq1atHI8//rijuLjY6NIajAULFlT5nXHLLbc4HA6Hw263O5544glHTEyMw2q1Ovr16+fYsGHDWalN6yCJiIiIVKI5SCIiIiKVKCCJiIiIVKKAJCIiIlKJApKIiIhIJQpIIiIiIpUoIImIiIhUooAkIiIiUokCkohILVi4cCEmk4mcnByjSxGRWqCAJCIiIlKJApKIiIhIJQpIIlIv2O120tLSaNmyJQEBAXTt2pWPP/4YODb89fXXX9OlSxf8/f05//zz+f33393O8cknn3DOOedgtVpJSEjg5ZdfdjteXFzMY489Rnx8PFarlTZt2vCf//zHrc2KFStISkoiMDCQ3r17s2HDBs9+cBHxCAUkEakX0tLSePfdd5k2bRpr165l9OjR3HTTTSxatMjV5tFHH+Xll19m+fLlNG7cmMGDB1NaWgo4g83111/PsGHDWLNmDU8//TRPPPEE77zzjuv1I0aM4IMPPmDSpEmsW7eON954g+DgYLc6Hn/8cV5++WV++eUXfHx8dGd4ES+lm9WKiNcrLi4mMjKSH374gV69ern233HHHRQWFnLXXXdxySWXMHv2bIYOHQrAoUOHaNasGe+88w7XX389w4cPZ//+/Xz//feu1//973/n66+/Zu3atWzcuJH27dszb948UlJSTqhh4cKFXHLJJfzwww/069cPgG+++YYrrriCo0eP4u/v7+HfgojUJvUgiYjX27x5M4WFhfTv35/g4GDX9u6777JlyxZXu+PDU2RkJO3bt2fdunUArFu3jj59+ridt0+fPmzatAmbzcaqVauwWCxcfPHFp6ylS5curudNmjQBIDs7+4w/o4icXT5GFyAicqby8/MB+Prrr2natKnbMavV6haSaiogIKBa7Xx9fV3PTSYT4JwfJSLeRT1IIuL1OnXqhNVqZefOnbRp08Zti4+Pd7X7+eefXc8PHz7Mxo0b6dixIwAdO3ZkyZIlbuddsmQJ7dq1w2Kx0LlzZ+x2u9ucJhGpv9SDJCJeLyQkhEceeYTRo0djt9u54IILyM3NZcmSJYSGhtKiRQsAnn32WRo1akRMTAyPP/44UVFRXHPNNQA8/PDD9OjRg3HjxjF06FAyMjKYMmUKr7/+OgAJCQnccsst3HbbbUyaNImuXbuyY8cOsrOzuf7664366CLiIQpIIlIvjBs3jsaNG5OWlsbWrVsJDw+nW7du/OMf/3ANcY0fP54HH3yQTZs2kZiYyH//+1/8/PwA6NatGx9++CFPPvkk48aNo0mTJjz77LPceuutrveYOnUq//jHP7j33ns5ePAgzZs35x//+IcRH1dEPExXsYlIvVdxhdnhw4cJDw83uhwR8QKagyQiIiJSiQKSiIiISCUaYhMRERGpRD1IIiIiIpUoIImIiIhUooAkIiIiUokCkoiIiEglCkgiIiIilSggiYiIiFSigCQiIiJSiQKSiIiISCUKSCIiIiKV/D9KHKNDnJLqSQAAAABJRU5ErkJggg==",
      "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, 42.83batch/s, accuracy=0.847, mae=0.213, rouge1=0.44, rouge2=0.241, rougeL=0.33] \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": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 116.96batch/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": "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':   0%|          | 0/100 [00:00<?, ?batch/s, rouge1=0.457, rouge2=0.274, rougeL=0.351]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 114.93batch/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
}