05-train_RES_CNN_RNN.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train RES_CNN_RNN"
   ]
  },
  {
   "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",
    "from models.RES_CNN_RNN import RES_CNN_RNN\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=0)\n",
    "parser.add_argument('-batch_size',type=int,default=32)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "\n",
    "args = None\n",
    "\n",
    "if is_notebook():\n",
    "    args = parser.parse_args(\"\")\n",
    "else:\n",
    "    args = parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "824eacf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 0\n",
      "epochs 100\n",
      "batch_size 32\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"glove.6B.100\"\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 = \"05-train_RES_CNN_RNN\"\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=0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "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.100d.txt\", vocab_size=vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fe745c8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_json(\"./data/cnn_dailymail/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=100, doc_column_name=\"article\", labels_column_name=\"labels\"))\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(\"./data/cnn_dailymail/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=100, doc_column_name=\"article\", labels_column_name=\"labels\"))\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(\"./data/cnn_dailymail/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=100, doc_column_name=\"article\", labels_column_name=\"labels\"))\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": null,
   "id": "9683721f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "380f8ba1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = RES_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2ae1a236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RES_CNN_RNN(\n",
       "  (word_embedding): Embedding(150002, 100)\n",
       "  (word_convs): ModuleList(\n",
       "    (0): Sequential(\n",
       "      (0): Conv1d(100, 100, kernel_size=(3,), 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",
       "    (1): Sequential(\n",
       "      (0): Conv1d(100, 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",
       "    (2): Sequential(\n",
       "      (0): Conv1d(100, 100, kernel_size=(5,), 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",
       "  )\n",
       "  (sent_GRU): GRU(100, 200, batch_first=True, bidirectional=True)\n",
       "  (rel_pos_emb): Embedding(11, 100)\n",
       "  (abs_pos_emb): Embedding(100, 100)\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",
       "  (Wabs_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       "  (Wrel_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": 15,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c6618af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[\"article\"], 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": 17,
   "id": "0991d3c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/4 [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%|██████████| 4/4 [00:01<00:00,  2.90batch/s, accuracy=0.638, loss=1.48, mae=0.33] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.527, val mae = 0.345, val accuracy = 0.750, r1 = 0.362, r2 = 0.141, rL = 0.236\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 4/4 [00:00<00:00,  4.97batch/s, accuracy=0.719, loss=1.41, mae=0.486] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.639, val mae = 0.433, val accuracy = 0.711, r1 = 0.299, r2 = 0.093, rL = 0.188\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 4/4 [00:00<00:00,  5.07batch/s, accuracy=0.772, loss=0.472, mae=0.231]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.567, val mae = 0.383, val accuracy = 0.748, r1 = 0.353, r2 = 0.130, rL = 0.228\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 4/4 [00:00<00:00,  5.34batch/s, accuracy=0.77, loss=0.451, mae=0.241] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.560, val mae = 0.380, val accuracy = 0.754, r1 = 0.357, r2 = 0.136, rL = 0.234\n",
      "Training duration = 11.4800124168396\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[\"highlights\"].iloc[i]\n",
    "\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[j]]\n",
    "            y_pred_thresh.append(indices[j])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in y_pred_thresh:\n",
    "            txt = txt + \". \" + doc[j]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        total_r1 += scores[\"rouge1\"].fmeasure\n",
    "        total_r2 += scores[\"rouge2\"].fmeasure\n",
    "        total_rl += scores[\"rougeL\"].fmeasure\n",
    "\n",
    "        probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        total_val_mae += mae_fn(probs_tensor, targets).item()\n",
    "        total_val_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "    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": 18,
   "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": 19,
   "id": "8cd8fbee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAA9hAAAPYQGoP6dpAABQg0lEQVR4nO3dd3gUdf4H8PdsT9uE9EAqCSA1BKQEULqccJx456HCCeKhp1LFBhYQ/GnubKcgCB4i591ZOA7QOxClI01qFBBIL0AaJT3ZJLvz+2M3m2wSIAm7O1ver+fZB3Z2Zvez4zzum8985zuCKIoiiIiIiFyETOoCiIiIiKyJ4YaIiIhcCsMNERERuRSGGyIiInIpDDdERETkUhhuiIiIyKUw3BAREZFLYbghIiIil8JwQ0RERC6F4YaIiIhcCsMNETmU9evXQxAEHD9+XOpSiMhJMdwQERGRS2G4ISIiIpfCcENETufUqVO49957odVq4e3tjdGjR+PIkSMW69TW1mLp0qXo0qULNBoNAgICMGzYMOzYscO8Tn5+PmbMmIHw8HCo1WqEhYXhvvvuQ1ZWlp2/ERFZk0LqAoiI2uLs2bO46667oNVq8cILL0CpVGLNmjUYMWIE9u3bh0GDBgEAXnvtNSQlJWHmzJkYOHAgSktLcfz4cZw8eRJjx44FAPzud7/D2bNnMWfOHERHR6OwsBA7duxATk4OoqOjJfyWRHQ7BFEURamLICKqt379esyYMQPHjh3DnXfe2ez1+++/H9u2bcO5c+fQuXNnAEBeXh66deuGhIQE7Nu3DwDQt29fhIeH43//+1+Ln1NcXIwOHTrg7bffxnPPPWe7L0REdsfTUkTkNPR6Pb7//ntMmjTJHGwAICwsDFOmTMGBAwdQWloKAPDz88PZs2eRmpra4nt5eHhApVJh7969uH79ul3qJyL7YLghIqdRVFSEyspKdOvWrdlr3bt3h8FgQG5uLgBg2bJlKC4uRteuXdG7d288//zz+Pnnn83rq9Vq/OUvf8G3336LkJAQ3H333XjrrbeQn59vt+9DRLbBcENELunuu+9Geno61q1bh169emHt2rXo168f1q5da15n/vz5SElJQVJSEjQaDV599VV0794dp06dkrByIrpdDDdE5DSCgoLg6emJCxcuNHvt/PnzkMlkiIiIMC/z9/fHjBkz8MUXXyA3Nxd9+vTBa6+9ZrFdbGwsnn32WXz//fc4c+YMampq8O6779r6qxCRDTHcEJHTkMvluOeee/D1119bXK5dUFCAzz//HMOGDYNWqwUAXL161WJbb29vxMXFQafTAQAqKytRXV1tsU5sbCx8fHzM6xCRc+Kl4ETkkNatW4ft27c3W/7aa69hx44dGDZsGJ5++mkoFAqsWbMGOp0Ob731lnm9Hj16YMSIEejfvz/8/f1x/PhxbNy4EbNnzwYApKSkYPTo0Zg8eTJ69OgBhUKBzZs3o6CgAA899JDdvicRWR8vBScih1J/KfiN5ObmoqioCIsWLcLBgwdhMBgwaNAgvPHGG0hMTDSv98Ybb+Cbb75BSkoKdDodoqKi8Mgjj+D555+HUqnE1atXsWTJEuzatQu5ublQKBS444478Oyzz+L3v/+9Pb4qEdkIww0RERG5FI65ISIiIpfCcENEREQuheGGiIiIXArDDREREbkUhhsiIiJyKQw3RERE5FLcbhI/g8GAy5cvw8fHB4IgSF0OERERtYIoiigrK0PHjh0hk928N+N24eby5csW954hIiIi55Gbm4vw8PCbruN24cbHxweAcefU34OGiIiIHFtpaSkiIiLMv+M343bhpv5UlFarZbghIiJyMq0ZUsIBxURERORSGG6IiIjIpTDcEBERkUtxuzE3raXX61FbWyt1GU5JqVRCLpdLXQYREbkphpsmRFFEfn4+iouLpS7Fqfn5+SE0NJRzCRERkd0x3DRRH2yCg4Ph6enJH+c2EkURlZWVKCwsBACEhYVJXBEREbkbhptG9Hq9OdgEBARIXY7T8vDwAAAUFhYiODiYp6iIiMiuOKC4kfoxNp6enhJX4vzq9yHHLRERkb0x3LSAp6JuH/chERFJheGGiIiIXArDDTUTHR2N999/X+oyiIiI2oUDil3EiBEj0LdvX6uEkmPHjsHLy+v2iyIiIpIAw42VGEQRulo91Ao5ZDLHG28iiiL0ej0Uilv/Jw8KCrJDRURERLbB01JWUlNnQGphOc5cLsH5/FJkXalAXkkVrlfUoLKmDnqDaLPPfvTRR7Fv3z588MEHEAQBgiBg/fr1EAQB3377Lfr37w+1Wo0DBw4gPT0d9913H0JCQuDt7Y0BAwZg586dFu/X9LSUIAhYu3Yt7r//fnh6eqJLly745ptvbPZ9iIiIbgc7N7cgiiKqavW3XK+8uha1egP0BhHVtXqUovkl0Cq5DCqFHBqlDGqFHGqlALVCDvkNOj0eSnmrrjr64IMPkJKSgl69emHZsmUAgLNnzwIAFi5ciHfeeQedO3dGhw4dkJubi/Hjx+ONN96AWq3GZ599hokTJ+LChQuIjIy84WcsXboUb731Ft5++22sWLECU6dORXZ2Nvz9/W9ZHxERkT0x3NxCVa0ePRZ/J8ln/7JsHDxVt/5P5OvrC5VKBU9PT4SGhgIAzp8/DwBYtmwZxo4da17X398f8fHx5uevv/46Nm/ejG+++QazZ8++4Wc8+uijePjhhwEAb775JpYvX46jR4/iV7/6Vbu+GxERka0w3DiwC/ll8PVQQqOUQ62Qmf9UyFt/NvHOO++0eF5eXo7XXnsNW7duRV5eHurq6lBVVYWcnJybvk+fPn3Mf/fy8oJWqzXfYoGIiMiRMNzcgodSjl+WjbPZ+9fpDdDVGVBTZ0B1rQHVdXrU1BlQqzdAJgDlujqU6+ostlHIZFArjWFHozCe4hJF4ym0pppe9fTcc89hx44deOeddxAXFwcPDw888MADqKmpuWmdSqXS4rkgCDAYDO381kRERLbDcHMLgiC06tSQtekNBuhqDaiuM0BXp0d1rQG6Wj1q9AbUGQyo0xlQ0Sj01IgyXCmrQnphOdRKGUqqjGGlVm+AKIrmsTsHDx7Eo48+ivvvvx+AsZOTlZVl9+9HRERkKww3Dkouk8FTLYOn2nK53iBCV6c3BZ+GPztFROKnkyeQkp4BTy8vFJZWAzCe2irUyaE2DWSOjInFxv/8B7+6dwKUChkWL17MDgwREbkUXgruZOQyYyepg5cKYb4eiA70wh2hWvzfq4vgpVHid6MHY0R8HEoK8wAAAoyBqLKmDtcqajB70TKovbS4+65huHfCRPQbMgI9+/RFVU0dSqtqUVN36yvDiIiIHJkgtjRQw4WVlpbC19cXJSUl0Gq1Fq9VV1cjMzMTMTEx0Gg0ElVoXQaDCJ3eeEqrurbhFFdNnQEiWv5PLxOEhgHMShk0CuOfKrms1TfEdMV9SURE0rnZ73dTPC3l4mQyAR4yOTyUcovlBlFETZ0p9NQZUF2rh67OOLjZYJrbp+n8PvWhR10/kNn0p0rR+tBDRERkaww3bkomCMarrZRy+DZaLoqiOeTUBx+dKfjcKPQI9Z2eRoEHen2LV28RERHZGsMNWRAahR54NFz+LdZ3euoaDWRuFHqqa/WortUDVcaZmcW6GhQVV+P/Pj0KP60X4oJ90CXYG11CvBET6AW1Qn6jEoiIiG4Lww21iiAIUCvlUCvl0MIy9NTqDRbjeXR1BlTqayECyL5WiUPZZQDyzdvIZQKiAjyNYSfYB11CvBEX7I3YIG9jqCIiIroNDDd0WwRBgEohh0ohBxqFnqoqOWTlGiT9tg9SrlQjtaAcqYVlSC0sR1l1HTKKKpBRVIHvzhY0ei8g0t8UekJ8zOEnNthLkrmGiIjIOfEXg2xCEATIZQIGxvjj7u4NV0uJoojCMp1F2EkrKEdKYRmKK2uRfbUS2VcrsfOc5a0dwjt4mENPXLC3+e/eah7CRERkib8MZFeCICBEq0GIVoNhXQLNy0VRxJXyGqQWliGtsNwcftIKy3GlvAYXr1fh4vUq7LlQZPF+HX01iDN3ebxNp7h84OuhbPrRRETkJhhuyCEIgoAgHzWCfNQYEhto8dq1ihqkFpi6PIWmjk9BOQrLdLhcUo3LJdXYn2IZekK0anQJNnV5Qkxje4K90cFLZc+vRUREEmC4IYfn76XCoM4BGNQ5wGJ5SWUt0oqMQSelUacnr6QaBaU6FJTqcCDtisU2gd4qxAV7o6up2xNnGtAc4KXiXD1ERC6C4YYAANHR0Zg/fz7mz58vdSmt5uupRP8of/SP8rdYXlZda+rwGDs9KQXGAHSpuApXymtwpfwajmRcs9img6fS2OkJ8TYPZO4a4o0gHzVDDxGRk2G4IZfjo1EiIbIDEiI7WCyv0NUhvah+PE850kwDmnOuVeJ6ZS2OZl3D0SzL0KPVKMxXbsU1uoorzFfD0ENE5KAYbshteKkV6BPuhz7hfhbLq2v1SGsynietsBxZVytQWl2HE9nXcSL7usU23mpFo6u2vM3jezr5eUAmY+ghIpISw40L+Pjjj/Haa6/h4sWLkMkabvR+3333ISAgAC+//DIWLFiAI0eOoKKiAt27d0dSUhLGjBkjYdWOQ6OUo1cnX/Tq5GuxvLpWj6yrFUgpKEeaaUBzamE5sq5UoFxXh+TcYiTnFlts46GUNxvE3CXEG+EdPCFn6CEisguGm1sRRaC2UprPVnoaZ7a7hd///veYM2cO9uzZg9GjRwMArl27hu3bt2Pbtm0oLy/H+PHj8cYbb0CtVuOzzz7DxIkTceHCBURGRtr6WzgtjVKOO0K1uCPU8u6zNXUGZF+tMIYd0xw9aQXlyLhSjqpaPU5fKsHpSyUW26gVMsQG1YeehtNbkf6eUMhlICIi62G4uZXaSuDNjtJ89kuXAZXXLVfr0KED7r33Xnz++efmcLNx40YEBgZi5MiRkMlkiI+PN6//+uuvY/Pmzfjmm28we/Zsm5XvqlQKmTGchPgAvRuW1+kNyL5WaTqtZez0pBSUI72oHLo6A37JK8UveaWW7yWXoXOQl+kUl485/EQHekHJ0ENE1C6Shpv9+/fj7bffxokTJ5CXl4fNmzdj0qRJrdr24MGDGD58OHr16oXk5GSb1ukMpk6discffxyrVq2CWq3Gv/71Lzz00EOQyWQoLy/Ha6+9hq1btyIvLw91dXWoqqpCTk6O1GW7FIXc2J2JDfIGEGperjeIyL1WaTqtZezy1F/JVVWrx/n8MpzPLwOQ1/BeMgExgV7mSQkHx/hjSFxg8w8lIqJmJA03FRUViI+Px2OPPYbf/va3rd6uuLgY06ZNw+jRo1FQUHDrDW6H0tPYQZGC0rPVq06cOBGiKGLr1q0YMGAAfvjhB/z1r38FADz33HPYsWMH3nnnHcTFxcHDwwMPPPAAampqbFU5NSKXCYgO9EJ0oBfG9ggxLzcYRFwqrjIPYq4f05NWUIaKGr35OZCP5QC2zBqKvhF+Un0NIiKnIWm4uffee3Hvvfe2ebsnn3wSU6ZMgVwux5YtW6xfWGOC0KpTQ1LTaDT47W9/i3/9619IS0tDt27d0K9fPwDGLtejjz6K+++/HwBQXl6OrKwsCaslAJDJBET4eyLC3xOj7mgIPaIoIq+k2jSmpwzbTufhZE4xlu9KxbpHB0hYMRGRc3C6k/qffvopMjIysGTJklatr9PpUFpaavFwVVOnTsXWrVuxbt06TJ061by8S5cu2LRpE5KTk/HTTz9hypQpMBgMElZKNyMIAjr6eWB41yDMvKsz3p3cFzIB2H2+EKcvltz6DYiI3JxThZvU1FQsXLgQ//znP6FQtK7plJSUBF9fX/MjIiLCxlVKZ9SoUfD398eFCxcwZcoU8/L33nsPHTp0wJAhQzBx4kSMGzfO3NUhxxcT6IVJfTsBAJbvTpW4GiIix+c0V0vp9XpMmTIFS5cuRdeuXVu93aJFi7BgwQLz89LSUpcNODKZDJcvNx8fFB0djd27d1ssmzVrlsVznqZybLNGxWFL8iXs+KUAZy+XoGdH31tvRETkppymc1NWVobjx49j9uzZUCgUUCgUWLZsGX766ScoFIpmP9711Go1tFqtxYPI2cQGeWNivHFKghW70iSuhojIsTlN50ar1eL06dMWy1atWoXdu3dj48aNiImJkagyIvuYPTIO3/x0GdvP5uNcXim6hzGoExG1RNJwU15ejrS0hn+FZmZmIjk5Gf7+/oiMjMSiRYtw6dIlfPbZZ5DJZOjVq5fF9sHBwdBoNM2WE7miLiE+GN87DFt/zsOHu9OwcirHTRERtUTS01LHjx9HQkICEhISAAALFixAQkICFi9eDADIy8vjRHNEjcwd1QUAsO1MHlIKyiSuhojIMQmiKIpSF2FPpaWl8PX1RUlJSbPxN9XV1cjMzER0dDQ8PDwkqtA1VFVVISsrCzExMdBoNFKX41Ke+ucJfHsmHxPjO2LFwwlSl0NEZBc3+/1uymkGFNuDUqkEAFRWSnSjTBdSvw/r9ylZzxxT9+Z/P19GWmG5xNUQETkepxlQbA9yuRx+fn4oLCwEAHh6ekJoxV25qYEoiqisrERhYSH8/Pwgl8ulLsnl9OioxT09QvD9LwX4cHcq3n+I3RsiosYYbpoIDTXe8LA+4FD7+Pn5mfclWd/c0V3w/S8F+Oany5g7ugs6B3lLXRIRkcNguGlCEASEhYUhODgYtbW1UpfjlJRKJTs2Ntarky/GdA/GznOF+HBPGt6b3FfqkoiIHAbDzQ3I5XL+QJNDmzu6C3aeK8TXyZcxd1QXRAc6/g1eiYjsgQOKiZxUn3A/jOwWBL1BxKq9nLWYiKgeww2RE5s72njl1KaTl5B7jVf5EREBDDdETi0hsgPu7hqEOnZviIjMGG6InNy80XEAgH8fv4iL19m9ISJiuCFycv2j/DE0LgB1BhEf7U2XuhwiIskx3BC5gHmjuwIANhzPxeXiKomrISKSFsMNkQsYGOOPwZ39UasXsXofuzdE5N4YbohcRH335sujucgvqZa4GiIi6TDcELmIwZ39MTDaHzV6A7s3ROTWGG6IXIQgCJg3xjjvzRdHc1BYyu4NEbknhhsiFzIkNgD9ozpAV2fAmv0ZUpdDRCQJhhsiFyIIgnnW4n/9mI2iMp3EFRER2R/DDZGLubtLIPpG+KG61oC1P7B7Q0Tuh+GGyMUIgoB5pu7NZ4ezcbWc3Rsici8MN0QuaES3IPQJ90VVrR5rD2RKXQ4RkV0x3BC5IEEQMHeUqXtzKAvXK2okroiIyH4Ybohc1OjuwejZUYuKGj0+YfeGiNwIww2Ri2p85dT6Q1kormT3hojcA8MNkQsb2z0Ed4T6oFxXh3UHs6Quh4jILhhuiFyYTNZw5dSnBzNRUlUrcUVERLbHcEPk4sb1DEW3EB+UVddhPbs3ROQGGG6IXJxMJmDO6DgAwCcHMlBWze4NEbk2hhsiN3BvrzDEBXujtLoOfz+UJXU5REQ2xXBD5AbkMgFzRhm7N2sPZKJcVydxRUREtsNwQ+Qmft2nIzoHeqG4shb/OJwtdTlERDbDcEPkJuQyAbNN3Zu//ZCBCnZviMhFMdwQuZHfxHdEdIAnrlXU4F8/sntDRK6J4YbIjSjkMswaaezefLw/A1U1eokrIiKyPoYbIjczKaETIvw9cKWc3Rsick0MN0RuRimXYbape7Nmfwaqa9m9ISLXwnBD5IbuTwhHJz8PFJXp8MXRHKnLISKyKoYbIjekUjSMvVm9L53dGyJyKQw3RG7qgf7h6OirQUGpDhuO50pdDhGR1TDcELkplUKGp0zdm4/2pkNXx+4NEbkGhhsiNzb5znCEajXIK6nGv49flLocIiKrYLghcmNqhRxPDu8MwNi9qakzSFwREdHtY7ghcnMPDYxEsI8al4qrsOkkuzdE5PwYbojcnEYpx5+GxwIAPtyThlo9uzdE5NwYbogIUwZGItBbjYvXq7D51CWpyyEiui0MN0QED5Ucf7rbOPZm5Z401LF7Q0ROjOGGiAAAUwdHIsBLheyrlfg6+bLU5RARtRvDDREBADxVCjxu6t58yO4NETkxhhsiMntkcBQ6eCqReaUC//s5T+pyiIjaheGGiMy81ArMvMvYvVmxOxV6gyhxRUREbcdwQ0QWpiVGwddDifSiCmw9ze4NETkfhhsisuCjUWLmsBgAwIpdqTCwe0NETobhhoiamT40Gj4aBVILy/HtmXypyyEiahOGGyJqRqtR4rGhpu7NbnZviMi5MNwQUYseGxoDH7UC5/PL8P0vBVKXQ0TUapKGm/3792PixIno2LEjBEHAli1bbrr+pk2bMHbsWAQFBUGr1SIxMRHfffedfYolcjO+nko8OjQaALB8VypEkd0bInIOkoabiooKxMfHY+XKla1af//+/Rg7diy2bduGEydOYOTIkZg4cSJOnTpl40qJ3NMfh8XASyXHL3ml2HmuUOpyiIhaRRAd5J9jgiBg8+bNmDRpUpu269mzJx588EEsXry4VeuXlpbC19cXJSUl0Gq17aiUyL28tf08Vu1NR69OWvx39jAIgiB1SUTkhtry++3UY24MBgPKysrg7+9/w3V0Oh1KS0stHkTUejPv6gxPlRxnLpVizwV2b4jI8Tl1uHnnnXdQXl6OyZMn33CdpKQk+Pr6mh8RERF2rJDI+fl7qfBIYhQA4IOdHHtDRI7PacPN559/jqVLl2LDhg0IDg6+4XqLFi1CSUmJ+ZGbm2vHKolcw+N3dYaHUo6fLpZgX0qR1OUQEd2UU4abL7/8EjNnzsSGDRswZsyYm66rVquh1WotHkTUNoHeavxhcCQA4ANeOUVEDs7pws0XX3yBGTNm4IsvvsCECROkLofIbTx+d2eoFTKcyinGgbQrUpdDRHRDkoab8vJyJCcnIzk5GQCQmZmJ5ORk5OTkADCeUpo2bZp5/c8//xzTpk3Du+++i0GDBiE/Px/5+fkoKSmRonwitxLso8HUQRx7Q0SOT9Jwc/z4cSQkJCAhIQEAsGDBAiQkJJgv687LyzMHHQD4+OOPUVdXh1mzZiEsLMz8mDdvniT1E7mbPw3vDJVChuPZ13E4/arU5RARtchh5rmxF85zQ3R7lnx9Bn8/nI1BMf746k+JUpdDRG7Cbea5ISL7e3JELFRyGX7MvIYjGezeEJHjYbghojYJ8/XA5AHhAIz3nCIicjQMN0TUZk+NiINSLuBQ+lUcy7omdTlERBYYboiozTr5eeCB/sbZvtm9ISJHw3BDRO3y9IhYKGQCfki9ghPZ16Uuh4jIjOGGiNolwt8Tv+vHsTdE5HgYboio3WaNjINcJmBfShGSc4ulLoeICADDDRHdhsgAT9yf0AkAsILdGyJyEAw3RHRbZo2Mg0wAdp0vxOmLvBUKEUmP4YaIbktMoBcm9TV2b5bvZveGiKTHcENEt23WqDgIArDjlwKcvczuDRFJi+GGiG5bbJA3JvbpCABYsStN4mqIyN0x3BCRVcwxdW+2n83H+fxSqcshIjfGcENEVtElxAfje4cBYPeGiKTFcENEVjN3VBcAwLYzeUgpKJO4GiJyVww3RGQ13UJ9cG+vUIgisGI3uzdEJA2GGyKyqjmm7s3/fr6MtMJyiashInfEcENEVtWjoxb39AiBKAIfct4bIpIAww0RWd3c0cbuzTc/XUZGEbs3RGRfDDdEZHW9OvliTPdgGERg5Z50qcshIjfDcENENlHfvdmSfAnZVyskroaI3AnDDRHZRJ9wP4zsFgS9QcTKPbxyiojsh+GGiGxmjql7s+nkJeReq5S4GiJyFww3RGQz/SI74K4ugagziFi1l90bIrIPhhsisqn5Y4zdm40nLuLidXZviMj2GG6IyKb6R/ljaFwAavUiPtrLK6eIyPYYbojI5uaN7goA2HA8F5eLqySuhohcHcMNEdncwBh/DO7sj1q9iNX72L0hIttiuCEiu6if9+bLo7nIL6mWuBoicmUMN0RkF4mdAzAw2h81egO7N0RkUww3RGQXgiCYuzdfHM1BYSm7N0RkGww3RGQ3Q+MC0D+qA3R1Bny8P0PqcojIRTHcEJHdNO7e/PPHbBSV6SSuiIhcEcMNEdnV3V0C0TfCD9W1Bqz9gd0bIrI+hhsisitBEDDP1L357HA2rpaze0NE1sVwQ0R2N6JbEPqE+6KqVo+1BzKlLoeIXAzDDRHZnSAImDvK1L05lIXrFTUSV0REroThhogkMbp7MHp21KKiRo9P2L0hIitiuCEiSTS+cmr9oSyUVNZKXBERuQqGGyKSzNjuIbgj1Aflujp8cpDdGyKyDoYbIpKMTNZw5dSnBzNRUsXuDRHdPoYbIpLUuJ6h6BrijbLqOqw/mCV1OUTkAhhuiEhSMpmAOaYrpz45kIGyanZviOj2MNwQkeTG9w5DXLA3Sqvr8NnhbKnLISInx3BDRJKTywTMGRUHAPjbDxko19VJXBEROTOGGyJyCL/u0xGdA71QXFmLf7B7Q0S3geGGiByCXCZgdqPuTQW7N0TUTgw3ROQwfhPfEdEBnrhWUYN//cjuDRG1D8MNETkMhVyGWSON3ZuP92egqkYvcUVE5IwYbojIoUxK6IQIfw9cKWf3hojah+GGiByKUi7DbFP3Zs3+DFTXsntDRG3DcENEDuf+hHB08vNAUZkOXxzNkbocInIyDDdE5HBUioaxN6v3pbN7Q0RtwnBDRA7pd/07oaOvBgWlOmw4nit1OUTkRCQNN/v378fEiRPRsWNHCIKALVu23HKbvXv3ol+/flCr1YiLi8P69ettXicR2Z9aIcdTI2IBAB/tTYeujt0bImodScNNRUUF4uPjsXLlylatn5mZiQkTJmDkyJFITk7G/PnzMXPmTHz33Xc2rpSIpDB5QARCtRrklVRj44mLUpdDRE5CEEVRlLoIABAEAZs3b8akSZNuuM6LL76IrVu34syZM+ZlDz30EIqLi7F9+/ZWfU5paSl8fX1RUlICrVZ7u2UTkY2tP5iJ1/77Czr5eWDPcyOgUvBsOpE7asvvt1P9X+Lw4cMYM2aMxbJx48bh8OHDN9xGp9OhtLTU4kFEzuOhgZEI9lHjUnEVNp1k94aIbs2pwk1+fj5CQkIsloWEhKC0tBRVVVUtbpOUlARfX1/zIyIiwh6lEpGVaJRy/Gm4cezNh3vSUKs3SFwRETm6doWbv//979i6dav5+QsvvAA/Pz8MGTIE2dmONaPookWLUFJSYn7k5vKqCyJnM2VgJAK91bh4vQqbT12SuhwicnDtCjdvvvkmPDw8ABhPFa1cuRJvvfUWAgMD8cwzz1i1wMZCQ0NRUFBgsaygoABardZcT1NqtRpardbiQUTOxUMlx5/u7gwAWLknDXXs3hDRTbQr3OTm5iIuzjjB1pYtW/C73/0OTzzxBJKSkvDDDz9YtcDGEhMTsWvXLotlO3bsQGJios0+k4gcw9TBkQjwUiH7aiW+Tr4sdTlE5MDaFW68vb1x9epVAMD333+PsWPHAgA0Gs0Nx760pLy8HMnJyUhOTgZgvNQ7OTkZOTnG6dYXLVqEadOmmdd/8sknkZGRgRdeeAHnz5/HqlWrsGHDBpt2i4jIMXiqFHjc1L35cE8a9AaHuNCTiBxQu8LN2LFjMXPmTMycORMpKSkYP348AODs2bOIjo5u9fscP34cCQkJSEhIAAAsWLAACQkJWLx4MQAgLy/PHHQAICYmBlu3bsWOHTsQHx+Pd999F2vXrsW4cePa8zWIyMk8MjgKHTyVyLxSgf/+xO4NEbWsXfPcFBcX45VXXkFubi6eeuop/OpXvwIALFmyBCqVCi+//LLVC7UWznND5NxW7knD299dQGyQF75/ZjjkMkHqkojIDtry++0wk/jZC8MNkXMrq67FsL/sQUlVLZY/nIDfxHeUuiQisgObT+K3fft2HDhwwPx85cqV6Nu3L6ZMmYLr16+35y2JiFrFR6PEH4fFAABW7EqFgWNviKiJdoWb559/3jzT7+nTp/Hss89i/PjxyMzMxIIFC6xaIBFRU48OjYaPRoHUwnJsP5svdTlE5GDaFW4yMzPRo0cPAMB//vMf/PrXv8abb76JlStX4ttvv7VqgURETWk1Sjw21Ni9Wc7uDRE10a5wo1KpUFlZCQDYuXMn7rnnHgCAv78/791ERHbx2NAY+KgVOJ9fhu9/Kbj1BkTkNtoVboYNG4YFCxbg9ddfx9GjRzFhwgQAQEpKCsLDw61aIBFRS3w9lXh0aDQAY/fGza6NIKKbaFe4+fDDD6FQKLBx40Z89NFH6NSpEwDg22+/NV8WTkRka48NjYGXSo5f8kqx81yh1OUQkYPgpeBE5NTe2n4eq/amo3cnX3wzeygEgfPeELmitvx+K9r7IXq9Hlu2bMG5c+cAAD179sRvfvMbyOXy9r4lEVGbzbyrM9YfysLpSyXYc6EQo+4IkbokIpJYu05LpaWloXv37pg2bRo2bdqETZs24Q9/+AN69uyJ9PR0a9dIRHRD/l4qPJIYBQD4YFcax94QUfvCzdy5cxEbG4vc3FycPHkSJ0+eRE5ODmJiYjB37lxr10hEdFOP39UZHko5fsotxr6UIqnLISKJtSvc7Nu3D2+99Rb8/f3NywICAvDnP/8Z+/bts1pxREStEeitxh8GRwIAPuCVU0Rur13hRq1Wo6ysrNny8vJyqFSq2y6KiKitHr+7M9QKGU7lFONA2hWpyyEiCbUr3Pz617/GE088gR9//BGiKEIURRw5cgRPPvkkfvOb31i7RiKiWwr20WDKIFP3Zie7N0TurF3hZvny5YiNjUViYiI0Gg00Gg2GDBmCuLg4vP/++1YukYiodZ4cHguVQobj2ddxOOOq1OUQkUTadSm4n58fvv76a6SlpZkvBe/evTvi4uKsWhwRUVuEaDV4eEAE/n44Gx/sTMWQ2ECpSyIiCbQ63Nzqbt979uwx//29995rf0VERLfhyRGx+OJoLn7MvIYjGVcxuHOA1CURkZ21OtycOnWqVetxdlAiklKYrwcmDwjHP4/kYPmuVIYbIjfU6nDTuDNDROTInhoRh6+O5eJQ+lUcy7qGAdH+t96IiFxGuwYUExE5sk5+HnigfwQA4x3Dici9MNwQkUt6ekQsFDIBP6RewYns61KXQ0R2xHBDRC4pwt8Tv+sXDgBYsZvdGyJ3wnBDRC5r1sg4yGUC9l4oQnJusdTlEJGdMNwQkcuKDPDE/QmdAAArOPaGyG0w3BCRS5s1Mg4yAdh1vhCnL5ZIXQ4R2QHDDRG5tJhAL9zX19i9Wc6xN0RugeGGiFze7FFxEARgxy8FOHuZ3RsiV8dwQ0QuLzbIGxP7dAQArNiVJnE1RGRrDDdE5BbmmLo328/m43x+qdTlEJENMdwQkVvoEuKD8b3DALB7Q+TqGG6IyG3MGRUHANh2Jg8pBWUSV0NEtsJwQ0Ru445QLe7tFQpRBFbsZveGyFUx3BCRW5kzqgsA4H8/X0ZaYbnE1RCRLTDcEJFb6dFRi3t6hEAUgZV72L0hckUMN0TkduaONnZvvk6+hIwidm+IXA3DDRG5nV6dfDGmezAMIrByT7rU5RCRlTHcEJFbqh97syX5ErKvVkhcDRFZE8MNEbml+Ag/jOgWBL1B5NgbIhfDcENEbqt+7M2mk5eQe61S4mqIyFoYbojIbfWL7IC7ugSiziBi1V52b4hcBcMNEbm1+WOM3ZuNJy7i4nV2b4hcAcMNEbm1/lH+GBoXgFq9iI/28sopIlfAcENEbm+u6cqpDcdzcbm4SuJqiOh2MdwQkdsb1DkAgzv7o1YvYvU+dm+InB3DDRERGq6c+vJoLvJLqiWuhohuB8MNERGAxM4BGBjtjxq9AWv2s3tD5MwYboiIAAiCYO7efP5jDgpL2b0hclYMN0REJkPjAtA/qgN0dQZ8vD9D6nKIqJ0YboiITBp3b/75YzaKynQSV0RE7cFwQ0TUyN1dAhEf4YfqWgPW/sDuDZEzYrghImpEEATMN3VvPjucjavl7N4QORuGGyKiJkZ0C0KfcF9U1eqx9kCm1OUQURsx3BARNSEIgnnW4s8OZeF6RY3EFRFRWzDcEBG1YHT3YPQI06KiRo9P2L0hciqSh5uVK1ciOjoaGo0GgwYNwtGjR2+6/vvvv49u3brBw8MDEREReOaZZ1BdzfkoiMi6Gl85tf5QFkoqayWuiIhaS9Jw89VXX2HBggVYsmQJTp48ifj4eIwbNw6FhYUtrv/5559j4cKFWLJkCc6dO4dPPvkEX331FV566SU7V05E7uCeHiG4I9QH5bo6fHKQ3RsiZyFpuHnvvffw+OOPY8aMGejRowdWr14NT09PrFu3rsX1Dx06hKFDh2LKlCmIjo7GPffcg4cffviW3R4iovaQyRq6N58ezERJFbs3RM5AsnBTU1ODEydOYMyYMQ3FyGQYM2YMDh8+3OI2Q4YMwYkTJ8xhJiMjA9u2bcP48eNv+Dk6nQ6lpaUWDyKi1vpVz1B0DfFGWXUd/n4oS+pyiKgVJAs3V65cgV6vR0hIiMXykJAQ5Ofnt7jNlClTsGzZMgwbNgxKpRKxsbEYMWLETU9LJSUlwdfX1/yIiIiw6vcgItcmkwmYY7py6pMDmSirZveGyNFJPqC4Lfbu3Ys333wTq1atwsmTJ7Fp0yZs3boVr7/++g23WbRoEUpKSsyP3NxcO1ZMRK5gfO8wxAV7o6SqFp8dzpa6HCK6BcnCTWBgIORyOQoKCiyWFxQUIDQ0tMVtXn31VTzyyCOYOXMmevfujfvvvx9vvvkmkpKSYDAYWtxGrVZDq9VaPIiI2kIuEzBnVBwA4G8/ZKBcVydxRUR0M5KFG5VKhf79+2PXrl3mZQaDAbt27UJiYmKL21RWVkImsyxZLpcDAERRtF2xROT2ft2nIzoHeqG4shb/YPeGyKFJelpqwYIF+Nvf/oa///3vOHfuHJ566ilUVFRgxowZAIBp06Zh0aJF5vUnTpyIjz76CF9++SUyMzOxY8cOvPrqq5g4caI55BAR2YJcJmB2o+5NZQ27N0SOSiHlhz/44IMoKirC4sWLkZ+fj759+2L79u3mQcY5OTkWnZpXXnkFgiDglVdewaVLlxAUFISJEyfijTfekOorEJEb+U18RyzflYqsq5X455FsPHF3rNQlEVELBNHNzueUlpbC19cXJSUlHH9DRG327+O5eH7jzwj0VuGHF0bBQ8WuMZE9tOX326muliIiktqkhE6I8PfAlfIa/OtHjr0hckQMN0REbaCUyzBrhHHszZr9Gaiu1UtcERE1xXBDRNRGv+0Xjk5+Higq0+GLozlSl0NETTDcEBG1kUohw9MjjYOJV+9LZ/eGyMEw3BARtcMD/cPR0VeDglId/n2cM58TORKGGyKidlAr5HhqhLF7s2pvOnR17N4QOQqGGyKidpo8IAKhWg3ySqqx8cRFqcshIhOGGyKidlIr5HhyeGcAwKo96aipa/ked0RkXww3RES34aGBkQjyUeNScRU2nWT3hsgRMNwQEd0GjVKOJ4cbx96s3JuGWj27N0RSY7ghIrpNUwZGItBbjdxrVdh86pLU5RC5PYYbIqLb5KGS4093G8ferNyThjp2b4gkxXBDRGQFUwdHwt9Lheyrlfg6+bLU5RC5NYYbIiIr8FQp8Phdxu7Nh3vSoDeIEldE5L4YboiIrGRaYhQ6eCqReaUC//2J3RsiqTDcEBFZiZdagZmm7s2K3ans3hBJhOGGiMiKpiVGwddDifSiCmw7nSd1OURuieGGiMiKfDRK/HFYDABj98bA7g2R3THcEBFZ2aNDo+GjUSCloBzbz+ZLXQ6R22G4ISKyMq1GiceGGrs3y3exe0Nkbww3REQ28NjQGPioFTifX4bvfymQuhwit8JwQ0RkA76eSjw6NBqAsXsjiuzeENkLww0RkY08NjQGXio5fskrxc5zhVKXQ+Q2GG6IiGykg5cK04dEA2D3hsieGG6IiGxo5l2d4amS4/SlEuy5wO4NkT0w3BAR2ZC/lwqPDI4CAHywK43dGyI7YLghIrKxx+/uDI1Shp9yi7EvpUjqcohcHsMNEZGNBXqr8YdB9d0bjr0hsjWGGyIiO3hieGeoFTKcyinGwbSrUpdD5NIYboiI7CDYR4MpgyIBAB/sSmH3hsiGGG6IiOzkyeGxUClkOJZ1HYcz2L0hshWGGyIiOwnRavDwgAgAwAc7UyWuhsh1MdwQEdnRkyNioZLL8GPmNRxh94bIJhhuiIjsKMzXA5MHhAMAVuxm94bIFhhuiIjs7KkRcVDKBRxMu4rjWdekLofI5TDcEBHZWSc/DzzQ3zT2Zhe7N0TWxnBDRCSBp0fEQiET8EPqFZzMuS51OUQuheGGiEgCEf6e+G2/TgCMdwwnIuthuCEiksiskXGQywTsvVCE5NxiqcshchkMN0REEokK8MKkvsbuzQp2b4ishuGGiEhCs0fFQSYAu84X4sylEqnLIXIJDDdERBKKCfTCfabuDa+cIrIOhhsiIonNHhUHQQB2/FKAs5fZvSG6XQw3REQSiw3yxsQ+HQEAK3alSVwNkfNjuCFyZGUFwJlNwPF1QOZ+oCwfEEWpqyIbmGPq3mw/m4/z+aVSl0Pk1BRSF0BEjRTnANmHgOyDxj+vtvCveLUWCOwCBHa1fPjHAHKl/Wsmq+gS4oPxvcOw9ec8rNidhpVT+kldEpHTYrghkoooAtcygKwDpkBzCCjJabKSAIT2AnzCjEHnehagKwUunTA+GpMpgA4xprBjCj9B3YCAOMDDz05fim7HnFFx2PpzHradzkNqQRm6hPhIXRKRU2K4IbIXgwEoOm/qypg6M+UFlusIcqBjXyBqqPEROQjw6NDwep3OGIiupJgeqUDRBeOftRXA1VTj40KTz/YOsQw99X9qwwEZz047ijtCtbi3Vyi+PZOPFbvTsPzhBKlLInJKgii61wn80tJS+Pr6oqSkBFqtVupyyJXp64CC08YQk3UQyDkEVDW5h5BcBXS6E4gaAkQPBcIHAmrvtn+WKAKllxsCT+PwU3b5xtspPY2dHfPpLVPoCYgFlB5tr4Nu29nLJZiw/IDx6qlnhiMuuB3HA5ELasvvN8MNkbXU1QCXTzV0ZXKOADVllusoPYGIgQ2dmU79AaXGtnVVlxq7OU1Dz9V0wFB7g40EwC+yIfQENRrb4xkACIJta3Zzj392HDt+KcD9CZ3w1wf7Sl0OkUNguLkJhhuymtoq4OKxhgHAuceAuirLddRaIDLR2JmJGmo85eQog371dUBxtjHs1J/aupICXLkAVN9krhWPDk1OcZkeflGAnGe6reHMpRL8esUByARg54Lh6BzE7g0Rw81NMNxQu+nKgNwfjaeYsg8ZB/Q27Xx4BjQEmaghQEgvQCaXpt72EkWg4opll6f+78U5AG7wvwy5CvCPbRJ6uhgfag6Mbas/rj+GXecL8bt+4Xh3crzU5RBJjuHmJhhuqNUqrxlPLdUPAM77CRANlut4hxrHytSfZgrq5tqnbGoqgWvpLYztSWvetWrMp6Mx5AR1s+z6+IS59v66DT/lFuO+lQchlwnY/exwRAV4SV0SkaTa8vvNHjJRvbIC46Df+gHAhWebr+MXZQwx0abOTIcY9/pxVnkCob2Nj8YMBqAkt/m4nispQEWhcVBz2WUgc1+T9/NucgWXKfz4dwYUKvt9LwcUH+GHEd2CsPdCEVbuScNbD7B7Q9RaknduVq5cibfffhv5+fmIj4/HihUrMHDgwBuuX1xcjJdffhmbNm3CtWvXEBUVhffffx/jx49v1eexc0NmxblNJsxr4aaFgV0tTzP5htu/TmdXdd3Y2TGHHtPjWiYg6lveRpADHaJbGNvTBfD0t2v5UjqZcx2/XXUICpmAPc+NQIS/p9QlEUnGaTo3X331FRYsWIDVq1dj0KBBeP/99zFu3DhcuHABwcHBzdavqanB2LFjERwcjI0bN6JTp07Izs6Gn5+f/Ysn51I/YV59kMk+aBo/0phgHCMTNaTh4d38OKQ28ugARAwwPhqrqwGuZzbv9BSlGK8yu5ZufKR8a7mdZ6Dp9FaT0OMb4Xzjm26hX2QH3NUlED+kXsGqvWlI+m0fqUsicgqSdm4GDRqEAQMG4MMPPwQAGAwGREREYM6cOVi4cGGz9VevXo23334b58+fh1LZvitO2LlxEwaD8aqf7IMNA4DL8y3XEeRAWHzDmJmIQW7VFXBYomi8h1azAc2pQOnFG2+n0Jjm7GlyFVdAnPF0mpM6nnUND6w+DKXc2L0J7+C834XodjjFgOKamhp4enpi48aNmDRpknn59OnTUVxcjK+//rrZNuPHj4e/vz88PT3x9ddfIygoCFOmTMGLL74Iubzlf7HpdDrodDrz89LSUkRERDDcuBqDHsg/bXmaqeqa5TpylXFemfrTTBEDeRWPs9GVG29DYXGKK9W4TF9z4+18I5vPzhzY1diZc4IxU1PXHsHBtKv4w+BI/N+k3rfegMgFOcVpqStXrkCv1yMkJMRieUhICM6fP9/iNhkZGdi9ezemTp2Kbdu2IS0tDU8//TRqa2uxZMmSFrdJSkrC0qVLrV4/SUxf23zCPF2TOykrPBomzIuunzCPs+46NbW3ca6gjn0tlxv0pjl7Gg1oLjLN2VN13XjPrpIcIH2X5XYa3+azMwd2NY73cZT5iADMHdUFB9OuYsOxi5g1Mg5hvjyOiW7Gqa6WMhgMCA4Oxscffwy5XI7+/fvj0qVLePvtt28YbhYtWoQFCxaYn9d3bsjJ1FYZ55XJMl2WffEYUFtpuY5aC0QObujMhPV1+ytu3IZMbrzCyr8z0HWc5WsVV5t3eq6kGMNQdYnxWLp4rMn7KYzv1fTO64FxxkBkZ4M6B2BwZ38cybiG1XvTsfS+XnavgciZSBZuAgMDIZfLUVBgeePAgoIChIaGtrhNWFgYlEqlxSmo7t27Iz8/HzU1NVCpmv+QqdVqqNVq6xZPtqcrA3KPNnRmLp1oftrBw9/ySqbQ3i43oJSswCsA8EoEohItl9dW32DOnlRjcK5/3pR3qGWXp/7WFNpONj3FNXd0FxzJ+BFfHMvF0yPjEKK18W07iJyYZOFGpVKhf//+2LVrl3nMjcFgwK5duzB79uwWtxk6dCg+//xzGAwGyEx3Mk5JSUFYWFiLwYacSNX1hgnzsuonzGtymbB3aMMNJqOGGudE4R2tqb2UGiCkp/HRmMFgnJPHfGqrUegpz294ZP3Q5P28jJ2dpqe5/GOtcv+wxM4BGBjtj6NZ17B6XzqWTOx5642I3JSkV0t99dVXmD59OtasWYOBAwfi/fffx4YNG3D+/HmEhIRg2rRp6NSpE5KSkgAAubm56NmzJ6ZPn445c+YgNTUVjz32GObOnYuXX365VZ/Jq6UcRHmhafCv6VFwBs2m9feLbJj5N2qI8TSBEwz+JBdWXXKDOXsyAEPdDTYSgA5RpgkKm1zJ5RXQpo8/kHoFf/jkR6gVMvzwwkgEs3tDbsQpBhQDwIMPPoiioiIsXrwY+fn56Nu3L7Zv324eZJyTk2Pu0ABAREQEvvvuOzzzzDPo06cPOnXqhHnz5uHFF1+U6itQa5VcariNQfahltv9AV0sTzP5cWwUORiNLxDe3/hoTF8LXM9qec4eXYnxtetZQOp3ltt5+Ft2eern7/GLavEU69C4APSL9MPJnGJ8vD8Dr/y6h62+KZFTk3yGYntj58YORNE4OVv9bQyyDxoHbzbVeMK8yCGAT0jzdYicmSgCFUWmu643mbOnpOkkko3IVS3M2dMFCOiCfdlVmL7uKDRKGQ68OAqB3hxTSO7BKea5kQrDjQ2IovF/3o07M2V5lusIMuOEefWnmSIHc8I8cm81FcDVxgOaLzTM2VNXfcPNRG04kquCkFwVjI6xvTFu+N2mm5CG8rQtuTSGm5tguLECg944RqbxhHmVVy3XkSmN88rU32AyYhAnzCNqDYP+JjchLbrxdiqfRndebzxnTwynRCCXwHBzEww37aCvNV69lHWg0YR5JZbrKDyM9w6q78yE38kJ84isrfIacCUV4pUL2PT9XmgrMtHfqwj+ukuAaGh5G0EO+Mc0maiwm/HKLo8O9q2f6DY4zYBiclC11cZ5ZepPM+UebT5hnsrHcsK8jgn81yGRrXn6A5GDIEQOglYzDo9/dhxelXIceHYoOugumbo8FyzH9tSYbllxNQ240OT9PDoY/2EiUxgHMMsUjR6yJs+bvC40fb3xOk3/bPK6IL/x+8rkN97OYts2bldfM0/duQWGGzLer+fi0YYBwJeOtzBhXoeGq5iihgAhvQE5Dx8iqYzpHoweYVr8kleKdT9exrP33AEE32G5kigax79ZXMFlCj9ll43zS+G6JPVLRrhRAGptIGtnqGpzEDQtu2kQvEUIvVnNLh7yeFrKHVUVN0yYl30IyEtuPkeHd0ijy7KHAkF3cMI8Igez/Uw+nvznCfioFTjw4ij4erbhfli6MqA4x3ja2aA3/j9ANP1pqGtYZvG8pWV1Tba90To3et20rE2f3cLrYpNldHNC01B2q0DWhlAnyI1X+42w7jQtPC1FliquNASZ7INAfgsT5vlGWs7+ywnziBzePT1CcEeoD87nl2HdwUw8M7Zr6zdW+zSfndlViKJxDNINA1aT5bcT6gx1TT6rpXVu8h7WDnVN17nhPtIDen3zLr21RAyyerhpC4YbV1R62XSKyTQA+ErTE+0wpmqLCfMi7V8nEd0WmUzA3NFd8PS/TmLdwUw8NiwGvh6OczdzyQhCQ2cCbj4PkOEWwUtsKXi1Jli1FOoareMt7bxlDDfOThSNM5+aL8s+aHzeVHDPhvEyUUM5YR6Ri/hVz1B0DfFGSkE5/n4oC3NHd5G6JHIkMhkgUwFwrws+GG6cjSgaBwXWn2bKOmgcGNiYIANC+wDRw0yz/yZywjwiFyWTCZgzqgvmfHEKnxzIxIyh0fDRsHtD7o3hxtEZ9EDB2SYT5l2xXEemBDr1axj8GzEQ0LjpYGkiNzS+dxje35mC9KIKfHY4G7NGxkldEpGkGG4cjb4WyPsZyK6fMO+w8U7EjSk0QLhpwrzooUCnOwGVpzT1EpHk5KaxN/O+TMbffsjA9CHR8Fbzf+/kvnj0S622Grh8suEGk7lHgdoKy3VU3i1MmOfmg+SIyMKv+3TEBztTkXGlAv84nI2nRsRKXRKRZBhu7K2mwhhg6k8zXTwO6HWW62j8LCfMC+3DCfOI6KbkMgGzR8VhwYafTN2bKHiq+P8Nck888m2tusRywrzLp5rPPeAVbJpjxjQAOKg7J8wjojb7TXxHfLArFdlXK/HPI9l44m52b8g9MdxYW8VVIOdQw2mm/NNoNmGeNrxhsryooUBALCfMI6LbppDLMGtkHF7Y+DM+3p+BRwZHw0Mll7osIrtjuLGWrIPA1gVA0fnmr/nHNoyXiR7KCfOIyGbuT+iEFbtTkXutCp8fzcEfh8VIXRKR3THcWIunf0OwCe7RZMK8UGlrIyK3oZTLMGtEHBZuOo3V+9IxdVAkNEp2b8i9MNxYS2A34KHPgYjBgFeA1NUQkRv7bb9wrNidhkvFVfjyaA4eHcruDbkXjlq1FpkMuGMCgw0RSU6lkOHpkcbBxB/tS0d1rV7iiojsi+GGiMgFPdA/HB19NSgo1eHfx3OlLofIrhhuiIhckFohN0/kt2pvOnR17N6Q+2C4ISJyUb+/MwIhWjXySqqx8cRFqcshshuGGyIiF6VRyvHUcFP3Zk86auoMEldEZB8MN0RELuyhgZEI8lHjUnEVNp1k94bcA8MNEZEL0yjleNLUvVm5Nw21enZvyPUx3BARubgpAyMR6K1C7rUqbD51SepyiGyO4YaIyMV5qOR44u7OAICVe9JQx+4NuTiGGyIiN/CHwVHw91Ih+2olvvnpstTlENkUww0RkRvwVCnw+F3G7s2Hu9OgN4gSV0RkOww3RERuYlpiFDp4KpFxpQL/+5ndG3JdDDdERG7CS63ATFP3ZvmuVHZvyGUx3BARuZFpiVHw9VAivagC207nSV0OkU0w3BARuREfjRJ/HBYDAFixOxUGdm/IBQmiKLrVkV1aWgpfX1+UlJRAq9VKXQ4Rkd2VVNVi2F92o6y6DiqFDF4qOTxVCniq5PBUKyyee6mNf/dSyeGhUjR5LoeX2rReo+09lXLIZILUX5NcTFt+vxV2qomIiByEr4cS80Z3wf9tPYeaOgNq6gy4Xllr1c/wUMpNYadR8DEHpvrnpqCkNgWnRs/Nr6kU8DQ991DKIQgMTXRr7NwQEbmp0upalFXXoVJXh8oaPSpq6lCpM/5ZVaNHRY0elbo6VNToUVVj/LOypg4VOr3pddN2ujrzc1ue5RIEwFNp6g6pGjpI9d0ic5BSy+GpbNRlUhuDkbnLpFZYPFcrZAxNToCdGyIiuiWtRgmtRmm19xNFEbo6AypMYak+MFWZApDlc1NQMgWk+lBVv119iKo0LTO+P1BhCl3WJBNgDkVeKoXxdFuz5w2n7DwahSrz6blGp+zqg5dKwWGtUmG4ISIiqxAEARqlHBqlHAFWfF+DQUR1nd4i7DQNPy12mczPW+pK1aG61ngbCoMIlOnqUKarA6CzWt1KudAo7DQ+HddonJLFKTjTa01P5Vl0pORQyBmaboXhhoiIHJpMVh8SFADUVntfvUFEZaNTcA0dp4bTbTfqJDV/3hCgakz37qrViyipqkVJlXXHM3EQ+K0x3BARkVuSywT4aJTwseKpOQCo1RssAlDD+KSWxyuZ1zV1m5qGpfrX6iddtNcgcI9GAchL3ej0XCsGgftoFOjgpbJqfW3BcENERGRFSrkMvh4y+HpYdzxTjd5gDDu1DafcLAaDWwzubhSuahu6TMbnlmOg6i8rqqo1vna14vbr7RPui29mD7v9N2onhhsiIiIHJwgC1Ao51Ao5OljxfZsOAm8+wLulAd91zQaANz2F56mSW7HKtmO4ISIiclO2GgQu9SwzHHJNREREViX1vEEMN0RERORSGG6IiIjIpTDcEBERkUthuCEiIiKXwnBDRERELoXhhoiIiFwKww0RERG5FIYbIiIicikMN0RERORSHCLcrFy5EtHR0dBoNBg0aBCOHj3aqu2+/PJLCIKASZMm2bZAIiIichqSh5uvvvoKCxYswJIlS3Dy5EnEx8dj3LhxKCwsvOl2WVlZeO6553DXXXfZqVIiIiJyBpKHm/feew+PP/44ZsyYgR49emD16tXw9PTEunXrbriNXq/H1KlTsXTpUnTu3NmO1RIREZGjkzTc1NTU4MSJExgzZox5mUwmw5gxY3D48OEbbrds2TIEBwfjj3/84y0/Q6fTobS01OJBRERErksh5YdfuXIFer0eISEhFstDQkJw/vz5Frc5cOAAPvnkEyQnJ7fqM5KSkrB06dJmyxlyiIiInEf977YoirdcV9Jw01ZlZWV45JFH8Le//Q2BgYGt2mbRokVYsGCB+fmlS5fQo0cPRERE2KpMIiIispGysjL4+vredB1Jw01gYCDkcjkKCgoslhcUFCA0NLTZ+unp6cjKysLEiRPNywwGAwBAoVDgwoULiI2NtdhGrVZDrVabn3t7eyM3Nxc+Pj4QBMGaXwelpaWIiIhAbm4utFqtVd/b1XBftR73VetxX7Ue91XbcH+1nq32lSiKKCsrQ8eOHW+5rqThRqVSoX///ti1a5f5cm6DwYBdu3Zh9uzZzda/4447cPr0aYtlr7zyCsrKyvDBBx+0qhsjk8kQHh5ulfpvRKvV8uBvJe6r1uO+aj3uq9bjvmob7q/Ws8W+ulXHpp7kp6UWLFiA6dOn484778TAgQPx/vvvo6KiAjNmzAAATJs2DZ06dUJSUhI0Gg169eplsb2fnx8ANFtORERE7knycPPggw+iqKgIixcvRn5+Pvr27Yvt27ebBxnn5ORAJpP8inUiIiJyEpKHGwCYPXt2i6ehAGDv3r033Xb9+vXWL6id1Go1lixZYjHGh1rGfdV63Fetx33VetxXbcP91XqOsK8EsTXXVBERERE5CZ7vISIiIpfCcENEREQuheGGiIiIXArDDREREbkUhptW2r9/PyZOnIiOHTtCEARs2bLlltvs3bsX/fr1g1qtRlxcnENd2WVrbd1fe/fuhSAIzR75+fn2KVgiSUlJGDBgAHx8fBAcHIxJkybhwoULt9zu3//+N+644w5oNBr07t0b27Zts0O10mrPvlq/fn2zY0qj0dipYml99NFH6NOnj3kitcTERHz77bc33cYdjyug7fvKnY+rxv785z9DEATMnz//putJcVwx3LRSRUUF4uPjsXLlylatn5mZiQkTJmDkyJFITk7G/PnzMXPmTHz33Xc2rtQxtHV/1btw4QLy8vLMj+DgYBtV6Bj27duHWbNm4ciRI9ixYwdqa2txzz33oKKi4obbHDp0CA8//DD++Mc/4tSpU5g0aRImTZqEM2fO2LFy+2vPvgKMs6Q2Pqays7PtVLG0wsPD8ec//xknTpzA8ePHMWrUKNx33304e/Zsi+u763EFtH1fAe57XNU7duwY1qxZgz59+tx0PcmOK5HaDIC4efPmm67zwgsviD179rRY9uCDD4rjxo2zYWWOqTX7a8+ePSIA8fr163apyVEVFhaKAMR9+/bdcJ3JkyeLEyZMsFg2aNAg8U9/+pOty3MordlXn376qejr62u/ohxchw4dxLVr17b4Go8rSzfbV+5+XJWVlYldunQRd+zYIQ4fPlycN2/eDdeV6rhi58ZGDh8+jDFjxlgsGzduHA4fPixRRc6hb9++CAsLw9ixY3Hw4EGpy7G7kpISAIC/v/8N1+GxZdSafQUA5eXliIqKQkRExC3/Ne6q9Ho9vvzyS1RUVCAxMbHFdXhcGbVmXwHufVzNmjULEyZMaHa8tESq48ohZih2Rfn5+eZbSNQLCQlBaWkpqqqq4OHhIVFljiksLAyrV6/GnXfeCZ1Oh7Vr12LEiBH48ccf0a9fP6nLswuDwYD58+dj6NChN71X2o2OLVcfn9RYa/dVt27dsG7dOvTp0wclJSV45513MGTIEJw9e9bmN9B1BKdPn0ZiYiKqq6vh7e2NzZs3o0ePHi2u6+7HVVv2lTsfV19++SVOnjyJY8eOtWp9qY4rhhtyCN26dUO3bt3Mz4cMGYL09HT89a9/xT/+8Q8JK7OfWbNm4cyZMzhw4IDUpTi81u6rxMREi399DxkyBN27d8eaNWvw+uuv27pMyXXr1g3JyckoKSnBxo0bMX36dOzbt++GP9rurC37yl2Pq9zcXMybNw87duxw+AHUDDc2EhoaioKCAotlBQUF0Gq17Nq00sCBA93mh3727Nn43//+h/3799/yX343OrZCQ0NtWaLDaMu+akqpVCIhIQFpaWk2qs6xqFQqxMXFAQD69++PY8eO4YMPPsCaNWuarevux1Vb9lVT7nJcnThxAoWFhRbddL1ej/379+PDDz+ETqeDXC632Eaq44pjbmwkMTERu3btsli2Y8eOm57DJUvJyckICwuTugybEkURs2fPxubNm7F7927ExMTccht3Pbbas6+a0uv1OH36tMsfVzdiMBig0+lafM1dj6sbudm+aspdjqvRo0fj9OnTSE5ONj/uvPNOTJ06FcnJyc2CDSDhcWXT4coupKysTDx16pR46tQpEYD43nvviadOnRKzs7NFURTFhQsXio888oh5/YyMDNHT01N8/vnnxXPnzokrV64U5XK5uH37dqm+gl21dX/99a9/Fbds2SKmpqaKp0+fFufNmyfKZDJx586dUn0Fu3jqqadEX19fce/evWJeXp75UVlZaV7nkUceERcuXGh+fvDgQVGhUIjvvPOOeO7cOXHJkiWiUqkUT58+LcVXsJv27KulS5eK3333nZieni6eOHFCfOihh0SNRiOePXtWiq9gVwsXLhT37dsnZmZmij///LO4cOFCURAE8fvvvxdFkcdVY23dV+58XDXV9GopRzmuGG5aqf5S5aaP6dOni6IoitOnTxeHDx/ebJu+ffuKKpVK7Ny5s/jpp5/avW6ptHV//eUvfxFjY2NFjUYj+vv7iyNGjBB3794tTfF21NI+AmBxrAwfPty83+pt2LBB7Nq1q6hSqcSePXuKW7dutW/hEmjPvpo/f74YGRkpqlQqMSQkRBw/frx48uRJ+xcvgccee0yMiooSVSqVGBQUJI4ePdr8Yy2KPK4aa+u+cufjqqmm4cZRjitBFEXRtr0hIiIiIvvhmBsiIiJyKQw3RERE5FIYboiIiMilMNwQERGRS2G4ISIiIpfCcENEREQuheGGiIiIXArDDRG5vb1790IQBBQXF0tdChFZAcMNERERuRSGGyIiInIpDDdEJDmDwYCkpCTExMTAw8MD8fHx2LhxI4CGU0Zbt25Fnz59oNFoMHjwYJw5c8biPf7zn/+gZ8+eUKvViI6Oxrvvvmvxuk6nw4svvoiIiAio1WrExcXhk08+sVjnxIkTuPPOO+Hp6YkhQ4bgwoULtv3iRGQTDDdEJLmkpCR89tlnWL16Nc6ePYtnnnkGf/jDH7Bv3z7zOs8//zzeffddHDt2DEFBQZg4cSJqa2sBGEPJ5MmT8dBDD+H06dN47bXX8Oqrr2L9+vXm7adNm4YvvvgCy5cvx7lz57BmzRp4e3tb1PHyyy/j3XffxfHjx6FQKPDYY4/Z5fsTkXXxxplEJCmdTgd/f3/s3LkTiYmJ5uUzZ85EZWUlnnjiCYwcORJffvklHnzwQQDAtWvXEB4ejvXr12Py5MmYOnUqioqK8P3335u3f+GFF7B161acPXsWKSkp6NatG3bs2IExY8Y0q2Hv3r0YOXIkdu7cidGjRwMAtm3bhgkTJqCqqgoajcbGe4GIrImdGyKSVFpaGiorKzF27Fh4e3ubH5999hnS09PN6zUOPv7+/ujWrRvOnTsHADh37hyGDh1q8b5Dhw5Famoq9Ho9kpOTIZfLMXz48JvW0qdPH/Pfw8LCAACFhYW3/R2JyL4UUhdARO6tvLwcALB161Z06tTJ4jW1Wm0RcNrLw8OjVesplUrz3wVBAGAcD0REzoWdGyKSVI8ePaBWq5GTk4O4uDiLR0REhHm9I0eOmP9+/fp1pKSkoHv37gCA7t274+DBgxbve/DgQXTt2hVyuRy9e/eGwWCwGMNDRK6LnRsikpSPjw+ee+45PPPMMzAYDBg2bBhKSkpw8OBBaLVaREVFAQCWLVuGgIAAhISE4OWXX0ZgYCAmTZoEAHj22WcxYMAAvP7663jwwQdx+PBhfPjhh1i1ahUAIDo6GtOnT8djjz2G5cuXIz4+HtnZ2SgsLMTkyZOl+upEZCMMN0Qkuddffx1BQUFISkpCRkYG/Pz80K9fP7z00kvm00J//vOfMW/ePKSmpqJv377473//C5VKBQDo168fNmzYgMWLF+P1119HWFgYli1bhkcffdT8GR999BFeeuklPP3007h69SoiIyPx0ksvSfF1icjGeLUUETm0+iuZrl+/Dj8/P6nLISInwDE3RERE5FIYboiIiMil8LQUERERuRR2boiIiMilMNwQERGRS2G4ISIiIpfCcENEREQuheGGiIiIXArDDREREbkUhhsiIiJyKQw3RERE5FIYboiIiMil/D/VZZfV2ZvN0AAAAABJRU5ErkJggg==",
      "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": 20,
   "id": "8bda887e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "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": 21,
   "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": 22,
   "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": 23,
   "id": "273c6eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = RES_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4fc41994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "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": 25,
   "id": "3edbae7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_set = df_test\n",
    "test_set[\"doc_splited\"] = split_all_docs(test_set[\"article\"], False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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": 27,
   "id": "67659b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:02<00:00, 42.17batch/s, accuracy=0.717, mae=0.368, rouge1=0.333, rouge2=0.115, rougeL=0.225]\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[\"highlights\"].iloc[idx]\n",
    "\n",
    "        probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "        #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[i]]\n",
    "            y_pred_thresh.append(indices[i])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[i]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        mae.append(mae_fn(probs_tensor, targets).item())\n",
    "\n",
    "        accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "        #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "        tepoch.set_postfix(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": 28,
   "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": 29,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:00<00:00, 204.00batch/s, rouge1=0.4, rouge2=0.165, rougeL=0.249] \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[\"highlights\"].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a3c5d9",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a4c96c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 188.77batch/s, rouge1=0.406, rouge2=0.168, rougeL=0.252]\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[\"highlights\"].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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
}