Transformers_HF/keras_hf_DistilBERT.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "virtual-optimum",
   "metadata": {
    "id": "virtual-optimum"
   },
   "outputs": [],
   "source": [
    "# GPU Reset if needed\n",
    "\n",
    "from numba import cuda \n",
    "device = cuda.get_current_device()\n",
    "device.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4c19ba3c",
   "metadata": {
    "id": "4c19ba3c"
   },
   "outputs": [],
   "source": [
    "# Disable CUDA for TF 2.x\n",
    "\n",
    "# import os\n",
    "# os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"-1\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "iA9Ipq-4zuPT",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "iA9Ipq-4zuPT",
    "outputId": "072f7aff-e198-4d95-cae9-60f8b10c233f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D:\\NLP_Last\\files\\UPLOAD\\Transformers_HF\n"
     ]
    }
   ],
   "source": [
    "# Mount Google Drive if running on Google Colab\n",
    "\n",
    "# from google.colab import drive\n",
    "import os\n",
    "\n",
    "# drive.mount('/content/drive')\n",
    "# os.chdir('/content/drive/My Drive/Colab Notebooks/hf/')\n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "MI6QgDjY2g7o",
   "metadata": {
    "id": "MI6QgDjY2g7o"
   },
   "outputs": [],
   "source": [
    "# List current directory\n",
    "\n",
    "#!dir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "wWbrBVZ7CoPF",
   "metadata": {
    "id": "wWbrBVZ7CoPF"
   },
   "outputs": [],
   "source": [
    "# Remove current logs\n",
    "\n",
    "#!rm -rf logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "distinct-breath",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "distinct-breath",
    "outputId": "9e5f5fe9-8e4d-40af-aa06-ac0161f8466a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensorflow precision mode : float32\n",
      "TensorFlow version : 2.9.0-dev20220102\n",
      "Numpy version : 1.22.0\n",
      "Pandas version : 1.3.4\n"
     ]
    }
   ],
   "source": [
    "# Import Tensorflow and related libraries\n",
    "\n",
    "import tensorflow\n",
    "\n",
    "print(\"Tensorflow precision mode : \" + tensorflow.keras.backend.floatx())\n",
    "\n",
    "# # Set Tensorflow precision mode to 'float16' to speedup with newer GPU\n",
    "# tensorflow.keras.backend.set_floatx('float32')\n",
    "\n",
    "# print(\"Tensorflow precision mode (after change) : \" + tensorflow.keras.backend.floatx())\n",
    "\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.layers import Flatten\n",
    "from tensorflow.keras.layers import Dropout\n",
    "\n",
    "from tensorflow.keras.layers import Input\n",
    "\n",
    "from tensorflow.keras.utils import plot_model\n",
    "\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "print(\"TensorFlow version : \" + tensorflow.__version__)\n",
    "\n",
    "import numpy as np\n",
    "print(\"Numpy version : \" + np.version.version)\n",
    "\n",
    "import pandas as pd\n",
    "print(\"Pandas version : \" + pd.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "circular-angle",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "circular-angle",
    "outputId": "87ac550c-1fe5-4f07-8087-478d257c7a09"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: /physical_device:GPU:0   Type: GPU\n"
     ]
    }
   ],
   "source": [
    "# Display available GPUs\n",
    "\n",
    "physical_devices = tensorflow.config.list_physical_devices(('GPU'))\n",
    "for gpu in physical_devices:\n",
    "    print(\"Name:\", gpu.name, \"  Type:\", gpu.device_type)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "618b9a2b",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "618b9a2b",
    "outputId": "d71ac05b-4b24-4743-dba5-42f0b1117631"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fri Feb 25 08:28:33 2022       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 496.13       Driver Version: 496.13       CUDA Version: 11.5     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name            TCC/WDDM | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                               |                      |               MIG M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  NVIDIA GeForce ... WDDM  | 00000000:0D:00.0  On |                  N/A |\n",
      "|  0%   46C    P2    42W / 170W |   2027MiB / 12288MiB |      3%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "|    0   N/A  N/A      1604    C+G   Insufficient Permissions        N/A      |\n",
      "|    0   N/A  N/A      5204    C+G   C:\\Windows\\explorer.exe         N/A      |\n",
      "|    0   N/A  N/A      5748      C   ...onda3\\envs\\tf2\\python.exe    N/A      |\n",
      "|    0   N/A  N/A      6308    C+G   ...2txyewy\\TextInputHost.exe    N/A      |\n",
      "|    0   N/A  N/A      7460    C+G   ...y\\ShellExperienceHost.exe    N/A      |\n",
      "|    0   N/A  N/A      7488    C+G   ...5n1h2txyewy\\SearchApp.exe    N/A      |\n",
      "|    0   N/A  N/A      7616    C+G   Insufficient Permissions        N/A      |\n",
      "|    0   N/A  N/A      9452    C+G   ...zilla Firefox\\firefox.exe    N/A      |\n",
      "|    0   N/A  N/A     13036    C+G   ... Download Manager\\fdm.exe    N/A      |\n",
      "|    0   N/A  N/A     13108    C+G   ...zilla Firefox\\firefox.exe    N/A      |\n",
      "|    0   N/A  N/A     13168      C   ...onda3\\envs\\tf2\\python.exe    N/A      |\n",
      "|    0   N/A  N/A     14216    C+G   ...5.0.3.0\\GoogleDriveFS.exe    N/A      |\n",
      "|    0   N/A  N/A     15260    C+G   ...enTabletDriver.UX.Wpf.exe    N/A      |\n",
      "|    0   N/A  N/A     15884    C+G   ...in7x64\\steamwebhelper.exe    N/A      |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "# Show GPU status\n",
    "\n",
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0f583e47",
   "metadata": {
    "id": "0f583e47"
   },
   "outputs": [],
   "source": [
    "# Fix for \"CUDA_ERROR_ILLEGAL_ADDRESS\"\n",
    "\n",
    "# Ref : https://github.com/tensorflow/tensorflow/issues/40814#issuecomment-663838196\n",
    "\n",
    "os.environ['TF_CUDNN_DETERMINISTIC']='1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "preceding-travel",
   "metadata": {
    "id": "preceding-travel"
   },
   "outputs": [],
   "source": [
    "# Enable Memory Growth\n",
    "\n",
    "try:\n",
    "    if physical_devices != []:\n",
    "        tensorflow.config.experimental.set_memory_growth(physical_devices[0], True)\n",
    "        physical_devices[0]\n",
    "except:\n",
    "    print(\"error\")      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "primary-bryan",
   "metadata": {
    "id": "primary-bryan"
   },
   "outputs": [],
   "source": [
    "# Global Parameters\n",
    "\n",
    "author_list = ['Charles Dickens','Jane Austen','Sir Arthur Conan Doyle','George Eliot','Jules Verne']\n",
    "seed_number = 18\n",
    "dataset_file  = \"dataset.csv\"\n",
    "validation_dataset_file  = \"validation_dataset.csv\"\n",
    "\n",
    "# For 3 GB VRAM : \n",
    "# batch_size = 2 when seq_length = 128, otherwise \"out of memory\"\n",
    "# Typical single epoch runtime = 20 mins\n",
    "\n",
    "batch_size = 64 # number of batch size\n",
    "epochs = 5 # number of maximum epochs to run\n",
    "seq_length = 100#300 # BERT Model sequence length\n",
    "dropout_value = 0.1 # Dropout layer value for Model\n",
    "init_lr = 3e-5 # Initial learning rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e41a7202",
   "metadata": {
    "id": "e41a7202"
   },
   "outputs": [],
   "source": [
    "# Reading validation data (from seperate books)\n",
    "\n",
    "validation_data = pd.read_csv(validation_dataset_file, usecols = ['author','text'])\n",
    "X_val_2 = validation_data.text\n",
    "y_val_2 = validation_data.author"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "attractive-oriental",
   "metadata": {
    "id": "attractive-oriental"
   },
   "outputs": [],
   "source": [
    "# Reading training/test/validation data\n",
    "\n",
    "data = pd.read_csv(dataset_file, usecols = ['author','text'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "dried-aerospace",
   "metadata": {
    "id": "dried-aerospace"
   },
   "outputs": [],
   "source": [
    "#data.sample(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "signal-football",
   "metadata": {
    "id": "signal-football"
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Train, Test, Validation Spit ratios 60%, 20%, 20% \n",
    "\n",
    "X_train, X_val, y_train, y_val = train_test_split(data[\"text\"], data[\"author\"], test_size=0.2, random_state=2000)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size=0.25, random_state=seed_number) # 0.25 x 0.8 = 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a34aaa20",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "a34aaa20",
    "outputId": "09490896-14fe-44b8-e72f-bbf9426f09dc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training data: 15000\n",
      "Number of test data: 5000\n",
      "Number of validation data (from same books): 5000\n",
      "Number of validation data (from seperate books): 4000\n",
      "Number of max characters in training dataset: 370\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of training data:\",len(X_train))\n",
    "print(\"Number of test data:\",len(X_test))\n",
    "print(\"Number of validation data (from same books):\",len(X_val))\n",
    "print(\"Number of validation data (from seperate books):\",len(X_val_2))\n",
    "print(\"Number of max characters in training dataset:\",max(X_train.apply(len)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "strong-ukraine",
   "metadata": {
    "id": "strong-ukraine"
   },
   "outputs": [],
   "source": [
    "# Encoding label text to integeres\n",
    "\n",
    "label_tokenizer = LabelEncoder()\n",
    "label_tokenizer.fit(author_list)\n",
    "label_index = label_tokenizer.classes_\n",
    "\n",
    "y_train_sequences = np.array(label_tokenizer.transform(y_train))\n",
    "y_test_sequences = np.array(label_tokenizer.transform(y_test))\n",
    "y_val_sequences = np.array(label_tokenizer.transform(y_val))\n",
    "y_val_sequences_2 = np.array(label_tokenizer.transform(y_val_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "informed-precipitation",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "informed-precipitation",
    "outputId": "65f62de5-c420-437b-aea8-d9275b1cce5f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Charles Dickens', 'George Eliot', 'Jane Austen', 'Jules Verne',\n",
       "       'Sir Arthur Conan Doyle'], dtype='<U22')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label_index"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "numeric-produce",
   "metadata": {
    "id": "numeric-produce"
   },
   "source": [
    "### DistilBERT Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6c978cf2",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6c978cf2",
    "outputId": "d3162be0-be89-41dc-ea4d-e59ba24b4eda"
   },
   "outputs": [],
   "source": [
    "# !pip install transformers==4.6.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5029e0df",
   "metadata": {
    "id": "5029e0df"
   },
   "outputs": [],
   "source": [
    "# Load Huggingface transformers\n",
    "from transformers import TFDistilBertModel, DistilBertConfig, DistilBertTokenizerFast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fb14f7a9",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fb14f7a9",
    "outputId": "3e260661-ccea-4f7f-cc9e-fdf28995732d"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "826efac82c744c0cad8c5b6a2afdc93d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading:   0%|          | 0.00/232k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6c25b9ed08014e93a1ec35cc26edc9f0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading:   0%|          | 0.00/466k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f54669f5c191433f906106eae693a9cd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading:   0%|          | 0.00/28.0 [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0c4c9fed735243b4801b3b720d43908e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading:   0%|          | 0.00/483 [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "facdaf6ea84e457ab2fed560b44cdfbc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading:   0%|          | 0.00/363M [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some layers from the model checkpoint at distilbert-base-uncased were not used when initializing TFDistilBertModel: ['vocab_layer_norm', 'vocab_transform', 'activation_13', 'vocab_projector']\n",
      "- This IS expected if you are initializing TFDistilBertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing TFDistilBertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "All the layers of TFDistilBertModel were initialized from the model checkpoint at distilbert-base-uncased.\n",
      "If your task is similar to the task the model of the checkpoint was trained on, you can already use TFDistilBertModel for predictions without further training.\n"
     ]
    }
   ],
   "source": [
    "#######################################\n",
    "### --------- Setup  ---------- ###\n",
    "\n",
    "# Ref: https://huggingface.co/transformers/model_doc/roberta.html\n",
    "\n",
    "\n",
    "# Name of the  model to use\n",
    "model_name = 'distilbert-base-uncased'\n",
    "\n",
    "# Max length of tokens\n",
    "max_length = seq_length #100\n",
    "\n",
    "# Load transformers config and set output_hidden_states to False\n",
    "# config = BertConfig.from_pretrained(model_name)\n",
    "# config.output_hidden_states = False\n",
    "\n",
    "# Load BERT tokenizer\n",
    "tokenizer = DistilBertTokenizerFast.from_pretrained(model_name)#BertTokenizerFast.from_pretrained(pretrained_model_name_or_path = model_name, config = config)\n",
    "\n",
    "# Load the Transformers BERT model\n",
    "transformer_model = TFDistilBertModel.from_pretrained(model_name) #TFBertModel.from_pretrained(model_name, config = config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d2676225",
   "metadata": {
    "id": "d2676225"
   },
   "outputs": [],
   "source": [
    "#######################################\n",
    "### ------- Build the model ------- ###\n",
    "\n",
    "# TF Keras documentation: https://www.tensorflow.org/api_docs/python/tf/keras/Model\n",
    "\n",
    "# Load the MainLayer\n",
    "bert = transformer_model.layers[0]\n",
    "\n",
    "# Build your model input\n",
    "input_ids = Input(shape=(max_length,), name='input_ids', dtype='int32')\n",
    "\n",
    "inputs = {'input_ids': input_ids}\n",
    "\n",
    "# Load the Transformers BERT model as a layer in a Keras model\n",
    "bert_model = bert(inputs)[0]\n",
    "dropout = Dropout(dropout_value, name='pooled_output')#Dropout(config.hidden_dropout_prob, name='pooled_output')\n",
    "pooled_output = dropout(bert_model, training=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "93802723",
   "metadata": {
    "id": "93802723"
   },
   "outputs": [],
   "source": [
    "def X_tokenizer(X_original):\n",
    "    X_original = tokenizer(\n",
    "    text=X_original.to_list(),\n",
    "    add_special_tokens=True,\n",
    "    max_length=max_length,\n",
    "    truncation=True,\n",
    "    padding='max_length', \n",
    "   # pad_to_max_length=\"right\",\n",
    "    return_tensors='tf',\n",
    "    return_token_type_ids = False,\n",
    "    return_attention_mask = False,\n",
    "    verbose = True)\n",
    "\n",
    "    X_original={'input_ids': X_original['input_ids']}\n",
    "    return X_original\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9be0308f",
   "metadata": {
    "id": "9be0308f"
   },
   "outputs": [],
   "source": [
    "X_train = X_tokenizer(X_train)\n",
    "X_test = X_tokenizer(X_test)\n",
    "X_val = X_tokenizer(X_val)\n",
    "X_val_2 = X_tokenizer(X_val_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "fced3bbc",
   "metadata": {
    "id": "fced3bbc"
   },
   "outputs": [],
   "source": [
    "#del model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "acting-midwest",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "acting-midwest",
    "outputId": "f5bee457-48b5-44a0-bfea-7665cece7cef"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"nlp_DistilBert_18\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_ids (InputLayer)      [(None, 100)]             0         \n",
      "                                                                 \n",
      " distilbert (TFDistilBertMai  TFBaseModelOutput(last_h  66362880 \n",
      " nLayer)                     idden_state=(None, 100,             \n",
      "                             768),                               \n",
      "                              hidden_states=None, att            \n",
      "                             entions=None)                       \n",
      "                                                                 \n",
      " pooled_output (Dropout)     (None, 100, 768)          0         \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 76800)             0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 5)                 384005    \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 66,746,885\n",
      "Trainable params: 66,746,885\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# define new model\n",
    "\n",
    "flatten = tensorflow.keras.layers.Flatten()(pooled_output) \n",
    "model_output = tensorflow.keras.layers.Dense(5, activation='softmax')(flatten)\n",
    "\n",
    "model = tensorflow.keras.Model(inputs, model_output)\n",
    "\n",
    "model._name = \"nlp_DistilBert_\" + str(seed_number) \n",
    "model.summary()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d206d079",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 466
    },
    "id": "d206d079",
    "outputId": "1eb73cd6-e189-40db-b240-09c6e6a00ac3"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Save the model as a png file\n",
    "plot_model(model, to_file=model._name +'.png', show_layer_names=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "stuck-dispatch",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "stuck-dispatch",
    "outputId": "1ea23758-1a58-425a-b0bd-888c41c4be6f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 input_ids True\n",
      "1 distilbert True\n",
      "2 pooled_output True\n",
      "3 flatten True\n",
      "4 dense True\n"
     ]
    }
   ],
   "source": [
    "# Show the trainable status of the layers\n",
    "\n",
    "for i, layer in enumerate(model.layers):\n",
    "    print(i, layer.name, layer.trainable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "13a91642",
   "metadata": {
    "id": "13a91642"
   },
   "outputs": [],
   "source": [
    "# Define Optimizer\n",
    "\n",
    "# steps_per_epoch = int(len(X_train)/batch_size) #tensorflow.data.experimental.cardinality(data_train).numpy()\n",
    "# num_train_steps = steps_per_epoch * epochs\n",
    "# num_warmup_steps = int(0.1*num_train_steps)\n",
    "# print(steps_per_epoch,num_train_steps,num_warmup_steps)\n",
    "\n",
    "# optimizer = optimization.create_optimizer(init_lr=init_lr,\n",
    "#                                           num_train_steps=num_train_steps,\n",
    "#                                           num_warmup_steps=num_warmup_steps,\n",
    "#                                           optimizer_type='adamw')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "c45b8d76",
   "metadata": {
    "id": "c45b8d76"
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.optimizers import Adam\n",
    "\n",
    "optimizer = Adam(\n",
    "    learning_rate=5e-05,\n",
    "    epsilon=1e-08,\n",
    "    decay=0.01,\n",
    "    clipnorm=1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "manufactured-niagara",
   "metadata": {
    "id": "manufactured-niagara"
   },
   "outputs": [],
   "source": [
    "# Compile the model\n",
    "\n",
    "model.compile(\n",
    "    #optimizer=tensorflow.keras.optimizers.Adam(learning_rate=3e-5),\n",
    "    #optimizer=tensorflow.keras.optimizers.RMSprop(learning_rate=0.0001),\n",
    "    optimizer=optimizer,\n",
    "    loss=\"sparse_categorical_crossentropy\",\n",
    "    metrics=[\"accuracy\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "passing-chambers",
   "metadata": {
    "id": "passing-chambers"
   },
   "outputs": [],
   "source": [
    "# Tensorboard parameters\n",
    "\n",
    "import datetime\n",
    "log_dir = \"logs/fit/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
    "tensorboard_callback = tensorflow.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "diagnostic-hydrogen",
   "metadata": {
    "id": "diagnostic-hydrogen"
   },
   "outputs": [],
   "source": [
    "# Use best weights for the model\n",
    "\n",
    "early_stopping_monitor = tensorflow.keras.callbacks.EarlyStopping(\n",
    "    monitor='val_accuracy',\n",
    "    min_delta=0,\n",
    "    patience=50,\n",
    "    verbose=0,\n",
    "    mode='max',\n",
    "    baseline=None,\n",
    "    restore_best_weights=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "unlike-ballot",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "unlike-ballot",
    "outputId": "fac25488-d129-4971-e471-99d549c7448a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "235/235 [==============================] - 97s 390ms/step - loss: 0.6394 - accuracy: 0.7505 - val_loss: 0.3572 - val_accuracy: 0.8670\n",
      "Epoch 2/5\n",
      "235/235 [==============================] - 91s 388ms/step - loss: 0.2306 - accuracy: 0.9179 - val_loss: 0.3133 - val_accuracy: 0.8862\n",
      "Epoch 3/5\n",
      "235/235 [==============================] - 91s 389ms/step - loss: 0.1292 - accuracy: 0.9567 - val_loss: 0.3365 - val_accuracy: 0.8914\n",
      "Epoch 4/5\n",
      "235/235 [==============================] - 91s 389ms/step - loss: 0.0782 - accuracy: 0.9754 - val_loss: 0.3445 - val_accuracy: 0.8954\n",
      "Epoch 5/5\n",
      "235/235 [==============================] - 91s 389ms/step - loss: 0.0524 - accuracy: 0.9849 - val_loss: 0.3638 - val_accuracy: 0.8960\n"
     ]
    }
   ],
   "source": [
    "# Training the model\n",
    "# callbacks are not used : early_stopping_monitor (to speed up), tensorboard_callback (has a bug with BERT)\n",
    "\n",
    "history = model.fit(X_train, y_train_sequences, epochs=epochs, batch_size = batch_size, shuffle = True, callbacks=[], validation_data=(X_test , y_test_sequences ),)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f6784583",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 441
    },
    "id": "f6784583",
    "outputId": "8a49872c-b6fa-4910-b09d-8c083bfcd129"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x2464cc150a0>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmcAAAGDCAYAAABuj7cYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAABgWElEQVR4nO3deXxU1f3/8deHsIQdWVUQQYuiCIQYEUEp7rjvFbQqYlXcd6W2VWrrr636rZa6FXetFrUWal0rKsW1soqyKSrWiLLKvgY+vz/ODRkmk2QSksxk5v18PO4jM/eee+dz5gL5cM6555i7IyIiIiLpoV6qAxARERGREkrORERERNKIkjMRERGRNKLkTERERCSNKDkTERERSSNKzkRERETSiJIzEamQmb1qZudVd9lUMrMFZnZEDVzXzexH0esHzexXyZStwuecbWb/rmqc5Vx3kJkVVvd1RSR59VMdgIjUDDNbE/O2CbAR2BK9v9jdn072Wu5+TE2UzXTuPqI6rmNmXYCvgAbuXhRd+2kg6XsoInWHkjORDOXuzYpfm9kC4GfuPiG+nJnVL/6FLyIiqaduTZEsU9xtZWY3mdn3wGNmtpOZvWRmS8zsh+h1p5hzJprZz6LXw8zsXTO7Kyr7lZkdU8WyXc1skpmtNrMJZnafmf21jLiTifE3ZvZedL1/m1nbmOPnmNnXZrbMzH5RzvfTz8y+N7OcmH2nmNnM6HVfM/vAzFaY2Xdmdq+ZNSzjWo+b2W9j3t8QnbPQzIbHlT3OzKab2Soz+8bMRsUcnhT9XGFma8zsoOLvNub8/mY22cxWRj/7J/vdlMfM9onOX2Fms8zsxJhjx5rZ7Oia35rZ9dH+ttH9WWFmy83sHTPT7xuRJOkvi0h22hloDewOXET4t+Cx6H1nYD1wbznnHwjMA9oCdwCPmJlVoewzwEdAG2AUcE45n5lMjGcB5wPtgYZAcbKwL/BAdP1do8/rRALu/iGwFjgs7rrPRK+3ANdE9TkIOBy4tJy4iWIYHMVzJNANiB/vthY4F2gFHAdcYmYnR8cGRj9buXszd/8g7tqtgZeB0VHd/gi8bGZt4upQ6rupIOYGwL+Af0fnXQE8bWZ7R0UeIXSRNwf2A96K9l8HFALtgA7AzYDWChRJkpIzkey0FbjV3Te6+3p3X+buL7j7OndfDdwO/Lic879294fcfQvwBLAL4Zdw0mXNrDNwAHCLu29y93eBF8v6wCRjfMzdP3P39cBzQF60/3TgJXef5O4bgV9F30FZ/gYMBTCz5sCx0T7cfaq7f+juRe6+APhLgjgS+UkU36fuvpaQjMbWb6K7f+LuW919ZvR5yVwXQjL3ubs/FcX1N2AucEJMmbK+m/L0A5oBv4/u0VvAS0TfDbAZ2NfMWrj7D+4+LWb/LsDu7r7Z3d9xLeQskjQlZyLZaYm7byh+Y2ZNzOwvUbffKkI3WqvYrr043xe/cPd10ctmlSy7K7A8Zh/AN2UFnGSM38e8XhcT066x146So2VlfRahlexUM2sEnApMc/evozj2irrsvo/i+H+EVrSKbBcD8HVc/Q40s7ejbtuVwIgkr1t87a/j9n0NdIx5X9Z3U2HM7h6byMZe9zRC4vq1mf3HzA6K9t8JzAf+bWZfmtnI5KohIqDkTCRbxbdiXAfsDRzo7i0o6UYrq6uyOnwHtDazJjH7diun/I7E+F3staPPbFNWYXefTUhCjmH7Lk0I3aNzgW5RHDdXJQZC12ysZwgth7u5e0vgwZjrVtTqtJDQ3RurM/BtEnFVdN3d4saLbbuuu09295MIXZ7jCS1yuPtqd7/O3fcgtN5da2aH72AsIllDyZmIADQnjOFaEY1furWmPzBqiZoCjDKzhlGrywnlnLIjMf4dON7MDo4G799Gxf/+PQNcSUgCn4+LYxWwxsy6A5ckGcNzwDAz2zdKDuPjb05oSdxgZn0JSWGxJYRu2D3KuPYrwF5mdpaZ1TezM4F9CV2QO+K/hLFwN5pZAzMbRLhHY6N7draZtXT3zYTvZAuAmR1vZj+KxhYW79+S8BNEpBQlZyICcA/QGFgKfAi8VkufezZhUP0y4LfAs4T52BK5hyrG6O6zgMsICdd3wA+EAevl+RswCHjL3ZfG7L+ekDitBh6KYk4mhlejOrxF6PJ7K67IpcBtZrYauIWoFSo6dx1hjN170ROQ/eKuvQw4ntC6uAy4ETg+Lu5Kc/dNwImEFsSlwP3Aue4+NypyDrAg6t4dAfw02t8NmACsAT4A7nf3iTsSi0g2MY3RFJF0YWbPAnPdvcZb7kRE0pVazkQkZczsADPb08zqRVNNnEQYuyQikrW0QoCIpNLOwD8Ig/MLgUvcfXpqQxIRSS11a4qIiIikEXVrioiIiKQRJWciIiIiaSSjxpy1bdvWu3TpkuowRERERCo0derUpe7eLn5/RiVnXbp0YcqUKakOQ0RERKRCZha/7Bqgbk0RERGRtKLkTERERCSNKDkTERERSSMZNeasxr30EnTuDL16pToSERHJYps3b6awsJANGzakOhRJQm5uLp06daJBgwZJlVdylqyiIrjuOvjf/+Cee+Cii8As1VGJiEgWKiwspHnz5nTp0gXT76K05u4sW7aMwsJCunbtmtQ56tZMVv36MGkSDBwII0bAkCGwcmWqoxIRkSy0YcMG2rRpo8SsDjAz2rRpU6lWTiVnldGhA7z6Kvzud/DCC5CfD5MnpzoqERHJQkrM6o7K3islZ5VVrx6MHBla0YqKYMAAuPtu0BqlIiKSJZYtW0ZeXh55eXnsvPPOdOzYcdv7TZs2lXvulClTuPLKKyv8jP79+1dLrBMnTuT444+vlmvVFo05q6r+/WH6dBg+HK69Ft5+Gx57DNq0SXVkIiIiNapNmzbMmDEDgFGjRtGsWTOuv/76bceLioqoXz9xilFQUEBBQUGFn/H+++9XS6x1kVrOdkTr1jBuHIweDa+/Dnl58O67qY5KRESk1g0bNoxrr72WQw89lJtuuomPPvqI/v3706dPH/r378+8efOA7VuyRo0axfDhwxk0aBB77LEHo0eP3na9Zs2abSs/aNAgTj/9dLp3787ZZ5+NR71Vr7zyCt27d+fggw/myiuvrLCFbPny5Zx88sn06tWLfv36MXPmTAD+85//bGv569OnD6tXr+a7775j4MCB5OXlsd9++/HOO+9U+3dWlpS0nJnZYOBPQA7wsLv/PkGZQcA9QANgqbv/uBZDTJ4ZXHFFaEk780wYNAh+/evQ9ZmTk+roREQk0119NUStWNUmLy/MTFBJn332GRMmTCAnJ4dVq1YxadIk6tevz4QJE7j55pt54YUXSp0zd+5c3n77bVavXs3ee+/NJZdcUmrKienTpzNr1ix23XVXBgwYwHvvvUdBQQEXX3wxkyZNomvXrgwdOrTC+G699Vb69OnD+PHjeeuttzj33HOZMWMGd911F/fddx8DBgxgzZo15ObmMmbMGI4++mh+8YtfsGXLFtatW1fp76Oqar3lzMxygPuAY4B9gaFmtm9cmVbA/cCJ7t4DOKO246y0/feHadPgjDPgl7+EwYPh++9THZWIiEitOeOMM8iJGiZWrlzJGWecwX777cc111zDrFmzEp5z3HHH0ahRI9q2bUv79u1ZtGhRqTJ9+/alU6dO1KtXj7y8PBYsWMDcuXPZY489tk1PkUxy9u6773LOOecAcNhhh7Fs2TJWrlzJgAEDuPbaaxk9ejQrVqygfv36HHDAATz22GOMGjWKTz75hObNm1f1a6m0VLSc9QXmu/uXAGY2FjgJmB1T5izgH+7+PwB3X1zrUVZFixbwzDNw+OFw5ZXQuzf89a9w5JGpjkxERDJVFVq4akrTpk23vf7Vr37FoYceyrhx41iwYAGDBg1KeE6jRo22vc7JyaGoqCipMl6FB/ESnWNmjBw5kuOOO45XXnmFfv36MWHCBAYOHMikSZN4+eWXOeecc7jhhhs499xzK/2ZVZGKMWcdgW9i3hdG+2LtBexkZhPNbKqZlfltmNlFZjbFzKYsWbKkBsKtJDP42c/go4+gbVs4+mj4xS/Ck50iIiJZYuXKlXTsGH69P/7449V+/e7du/Pll1+yYMECAJ599tkKzxk4cCBPP/00EMaytW3blhYtWvDFF1/Qs2dPbrrpJgoKCpg7dy5ff/017du358ILL+SCCy5g2rRp1V6HsqQiOUs02Ud8Klsf2B84Djga+JWZ7ZXoYu4+xt0L3L2gXbt21RvpjthvvzAH2vDh8P/+Hxx6KHzzTcXniYiIZIAbb7yRn//85wwYMIAtW7ZU+/UbN27M/fffz+DBgzn44IPp0KEDLVu2LPecUaNGMWXKFHr16sXIkSN54oknALjnnnvYb7/96N27N40bN+aYY45h4sSJ2x4QeOGFF7jqqquqvQ5lsao0C+7QB5odBIxy96Oj9z8HcPffxZQZCeS6+6jo/SPAa+7+fHnXLigo8ClTptRU6FX3zDNw8cXQsCE8/jiccEKqIxIRkTpszpw57LPPPqkOI+XWrFlDs2bNcHcuu+wyunXrxjXXXJPqsBJKdM/MbKq7l5pXJBUtZ5OBbmbW1cwaAkOAF+PK/BM4xMzqm1kT4EBgTi3HWX3OOis8LLD77nDiiXDNNVDBJH0iIiJSvoceeoi8vDx69OjBypUrufjii1MdUrWo9QcC3L3IzC4HXidMpfGou88ysxHR8QfdfY6ZvQbMBLYSptv4tLZjrVbdusEHH8ANN4TBm+++C2PHwp57pjoyERGROumaa65J25ayHZGSec7c/RXglbh9D8a9vxO4szbjqnGNGoUJaw89NIxF69MHHnoozI8mIiIiglYISI1TTgkTBvboAUOGhPFo69enOioRERFJA0rOUmX33cPi6TfdBGPGQN++MHt2xeeJiIhIRlNylkoNGsDvfw+vvgqLFsEBB4SnOWv5CVoRERFJH0rO0sHgwaGb88AD4fzz4dxzYfXqVEclIiKS0KBBg3j99de323fPPfdw6aWXlntO8XRXxx57LCtWrChVZtSoUdx1113lfvb48eOZHdPTdMsttzBhwoRKRJ9Y7ILsqabkLF3suiu88UZYNP2ZZ6CgoPoXshUREakGQ4cOZezYsdvtGzt2bFLrWwK88sortGrVqkqfHZ+c3XbbbRxxxBFVula6UnKWTnJy4JZb4K23YM0a6NcP7rtP3ZwiIpJWTj/9dF566SU2btwIwIIFC1i4cCEHH3wwl1xyCQUFBfTo0YNbb7014fldunRh6dKlANx+++3svffeHHHEEcybN29bmYceeogDDjiA3r17c9ppp7Fu3Tref/99XnzxRW644Qby8vL44osvGDZsGH//+98BePPNN+nTpw89e/Zk+PDh2+Lr0qULt956K/n5+fTs2ZO5c+eWW7/ly5dz8skn06tXL/r168fMmTMB+M9//kNeXt62lQNWr17Nd999x8CBA8nLy2O//fbjnXfe2bEvlxRNpSEV+PGPQ6vZeefB5ZeHZO2RR6CK/8sQEZHMdfXV1d/RkpdX/nrqbdq0oW/fvrz22mucdNJJjB07ljPPPBMz4/bbb6d169Zs2bKFww8/nJkzZ9KrV6+E15k6dSpjx45l+vTpFBUVkZ+fz/777w/AqaeeyoUXXgjAL3/5Sx555BGuuOIKTjzxRI4//nhOP/307a61YcMGhg0bxptvvslee+3FueeeywMPPMDVV18NQNu2bZk2bRr3338/d911Fw8//HCZ9bv11lvp06cP48eP56233uLcc89lxowZ3HXXXdx3330MGDCANWvWkJuby5gxYzj66KP5xS9+wZYtW1i3bl3S33NZ1HKWrtq1g5degjvvhBdfDH9TPvww1VGJiIgA23dtxnZpPvfcc+Tn59OnTx9mzZq1XRdkvHfeeYdTTjmFJk2a0KJFC0488cRtxz799FMOOeQQevbsydNPP82sWbPKjWfevHl07dqVvfYKS3Gfd955TJo0advxU089FYD9999/22LpZXn33Xc555xzADjssMNYtmwZK1euZMCAAVx77bWMHj2aFStWUL9+fQ444AAee+wxRo0axSeffELz5s3LvXYy1HKWzurVg+uvh0MOCfOhHXJIWET9uuvCMRERyXrltXDVpJNPPplrr72WadOmsX79evLz8/nqq6+46667mDx5MjvttBPDhg1jw4YN5V7HzBLuHzZsGOPHj6d37948/vjjTJw4sdzrVLRWeKNGjQDIycmhqKio0tcyM0aOHMlxxx3HK6+8Qr9+/ZgwYQIDBw5k0qRJvPzyy5xzzjnccMMNnHvuueVevyL6DV8XHHggTJ8OJ50EN94Ixx8PS5akOioREclizZo1Y9CgQQwfPnxbq9mqVato2rQpLVu2ZNGiRbz66qvlXmPgwIGMGzeO9evXs3r1av71r39tO7Z69Wp22WUXNm/ezNNPP71tf/PmzVmdYEaD7t27s2DBAubPnw/AU089xY9//OMq1W3gwIHbPnPixIm0bduWFi1a8MUXX9CzZ09uuukmCgoKmDt3Ll9//TXt27fnwgsv5IILLmDatGlV+sxYajmrK1q1guefhwcegGuvDd2czzwTxqeJiIikwNChQzn11FO3dW/27t2bPn360KNHD/bYYw8GDBhQ7vn5+fmceeaZ5OXlsfvuu3PIIYdsO/ab3/yGAw88kN13352ePXtuS8iGDBnChRdeyOjRo7c9CACQm5vLY489xhlnnEFRUREHHHAAI0aMqFK9Ro0axfnnn0+vXr1o0qQJTzzxBBCmC3n77bfJyclh33335ZhjjmHs2LHceeedNGjQgGbNmvHkk09W6TNjWUXNgHVJQUGBF8+hktFmzAjrcc6fH57u/OUvw5OeIiKSFebMmcM+++yT6jCkEhLdMzOb6u4F8WXVrVkX5eXB1Klw1lkwahQceSQsXJjqqERERKQaKDmrq5o1gyefhMceg//+NyRsr72W6qhERERkB6UkOTOzwWY2z8zmm9nIBMcHmdlKM5sRbbekIs60ZwbDhsGUKdChAxxzTFhIffPmVEcmIiIiVVTryZmZ5QD3AccA+wJDzWzfBEXfcfe8aLutVoOsa/bZBz76CC6+GO64AwYOhArmcBERkbotk8aMZ7rK3qtUtJz1Bea7+5fuvgkYC5yUgjgyS+PG8OCD8OyzMHs29OkD48alOioREakBubm5LFu2TAlaHeDuLFu2jNzc3KTPScVUGh2Bb2LeFwIHJih3kJl9DCwErnf3hFMDm9lFwEUAnTt3ruZQ66Cf/CQsmn7mmXDqqWH5pzvvhEr8oRARkfTWqVMnCgsLWaI5L+uE3NxcOnXqlHT5VCRniaYCjk/9pwG7u/saMzsWGA90S3Qxdx8DjIEwlUY1xll37bEHvPcejBwJd98dXj/7LHRL+BWKiEgd06BBA7p27ZrqMKSGpKJbsxDYLeZ9J0Lr2Dbuvsrd10SvXwEamFnb2gsxAzRsCH/8Y1iX8+uvIT8/TForIiIiaS0VydlkoJuZdTWzhsAQ4MXYAma2s0WLbZlZX0Kcy2o90kxwwglh0treveHss+GCC2Dt2lRHJSIiImWo9eTM3YuAy4HXgTnAc+4+y8xGmFnxOgunA59GY85GA0Ncox6rbrfdYOJE+MUvwrxoffvCp5+mOioRERFJQMs3ZZsJE+CnP4WVK2H0aPjZz8J8aSIiIlKrtHyTBEccEbo5Dz4YLrooLAG1alWqoxIREZGIkrNstPPO8PrrcPvt8Pzz4WGBqVNTHZWIiIig5Cx71asHN98cxqJt3AgHHRS6OTOom1tERKQuUnKW7Q4+OHRzDh4MV10Fp5wCy5enOioREZGspeRMoE0b+Oc/w4S1r7wCeXnw/vupjkpERCQrKTmTwAyuvjokZQ0ahMXTf/c72Lo11ZGJiIhkFSVnsr2CApg2DU47LYxJO+YYWLQo1VGJiIhkDSVnUlrLljB2LPzlLzBpUujmfPPNVEclIiKSFZScSWJmYR60jz6CVq3gyCPhllugqCjVkYmIiGQ0JWdSvp49YcoUGDYMfvMbOOwwKCxMdVQiIiIZS8mZVKxpU3j0UXjqqTAeLS8PXn451VGJiIhkJCVnkryf/jSsJNCpExx/PFx3HWzalOqoREREMoqSM6mcvfeGDz+ESy+FP/4xTGL75ZepjkpERCRjKDmTysvNhfvug7//HT77DPr0CWt0ioiIyA5LSXJmZoPNbJ6ZzTezkeWUO8DMtpjZ6bUZnyTptNNg+nTYZx/4yU/gkktg/fpURyUiIlKn1XpyZmY5wH3AMcC+wFAz27eMcn8AXq/dCKVSunaFd96BG26ABx+Efv1g7txURyUiIlJnpaLlrC8w392/dPdNwFjgpATlrgBeABbXZnBSBQ0awB13hHU5Fy4Mqww8+WSqoxIREamTUpGcdQS+iXlfGO3bxsw6AqcAD1Z0MTO7yMymmNmUJUuWVGugUknHHAMzZsD++8N554VtzZpURyUiIlKnpCI5swT7PO79PcBN7r6loou5+xh3L3D3gnbt2lVHfLIjOnYMSz3dckuYF62gAGbOTHVUIiIidUYqkrNCYLeY952AhXFlCoCxZrYAOB2438xOrpXoZMfVrw+//nVI0latgr59w3g0j8/BRUREJF4qkrPJQDcz62pmDYEhwIuxBdy9q7t3cfcuwN+BS919fK1HKjvm0ENDN+egQeFJzp/8BFasSHFQIiIi6W2HkzMza2pm9aLXe5nZiWbWoKzy7l4EXE54CnMO8Jy7zzKzEWY2YkfjkTTTvn14UOAPf4Bx48KcaB99lOqoRERE0pb5DnY1mdlU4BBgJ+BDYAqwzt3P3vHwKqegoMCnTJlS2x8ryfrgAxgyJDzR+Yc/wDXXgCUagigiIpL5zGyquxfE76+Obk1z93XAqcCf3f0UwvxlIts76KDQzXnCCWFdzhNOgKVLUx2ViIhIWqmW5MzMDgLOBl6O9tWvhutKJtppJ3jhBfjzn+GNNyAvL0xiKyIikkLuYZGb5cvhu+9SG0t1JFFXAz8HxkVjx/YA3q6G60qmMoPLL4f+/eHMM8MDA7/+Nfz855CTk+roREQkxdxh8+aQLMVvGzYk3l/ZLf46GzaUfH6TJrB2berqv8PJmbv/B/gPQPRgwFJ3v3JHr5uOfv97+OEHaNs2bO3abf+zRQsNoaqU/HyYNg1GjIBf/Qrefhv++lfYZZdURyYiIjG2bq3+ZKiibevWqsVqBo0bl721a1f+8caNQ3KWSjucnJnZM8AIYAswFWhpZn909zt39Nrp5rXXwpj2TZsSH2/QoCRxi03aEiVyxVujRrVbh7TTvHlIyA4/PLSm5eWFyWuPOirVkYmIpCV32Lix+pOh8q5T1u+9ZDRqVHYS1KJFeKi/omSpMluDBnW/oaQ6ntac4e55ZnY2sD9wEzDV3XtVR4CVURtPa7qHFYmWLoUlS8LPil4vX1729Zo3LzuRS5TUtWoF9VIxO11tmDUrdHPOmgUjR8Jtt4W/ZSIiaay4+62mutsSHa/qr+6cnB1LfHJzK18+Y39nVYOyntasjjFnDaJ5zU4G7nX3zWaWsVPBm4WEqnlz6No1uXOKikJ3aKIELnbf99/Dp5+G1+vWJb5WTg60aVN+Ihef1DVuXH31r1E9eoQ50K6+OvQhT5oEf/sbdO6c6shEZAe4hy6qoqKwbdlS8jr+fbLHauMaZY15it+2VLjQYNnKS3x22gl23bV6kyn9f7duqI7k7C/AAuBjYJKZ7Q6sqobrZoz69UOSVJmlP9etS65Vbs6ckvdl9c83aZJcIlf8unXrFI7Lb9IExoyBww6Diy4K3ZyPPQYnnZSigEQqxz38sq7tRCKdr7EjyUtNqF8//BtXv37p1/Hvi5Oapk3Dv5FVbUFKtDVqVPe736Rm7HC3ZsKLmtWPVgKoVdk8Ce3WrWFlpGS7WpcuhdWrE1/LLCRoybbOtW0LzZrVwD8y8+eHbs5p0+Cqq8LEtVk/SE8q4h7Gx6xdG/6Ts3ZtyVbZ98X7KpOMpGMiUplkpCrlavoa1Xn9evWUEEn6KKtbszrGnLUEbgUGRrv+A9zm7it36MJVkM3JWVVs3FiSsJXV1Rr7eunS0MyfSKNGlWuda9Mmyeb1jRvhxhth9OjwdOezz8KPflSt34PUvqKi5JKiqr6vbILUsGFotG3adPutSZOwNWxY9xIaJSIi6a8mk7MXgE+BJ6Jd5wC93f3UHbpwFSg5q1nusGpV5R6GKG+d85YtEz/FmvD1f1+m5eXnYFuKQrfnkCG1Vu9stGVLSbJTXa1Pse/LSvLLkpNTOmlKlEhV9X396hjgISJSSTWZnM1w97yK9tUGJWfpZ/NmWLYs+a7WJUtCY1ki9es7bW0Z7TYvpO0uDWl70I9ot3P9cpO6TO0FLZ7JekeTpLLex07GmAyzqidJyZTJhEfjRUTi1eTTmuvN7GB3fzf6oAHA+mq4rmSABg1g553Dlgz3kBwkTuCMpYtbs+SdRSz9bAmfvNSQJU06s3xl/TIfK2/WrOL55mJf77RT9Tz2XTwPUXV12cXvK+tp3vIUD2qOT4I6dNjxxCo3V8mTiEh1qY7kbATwZDT2DOAH4LxquK5kIbOQUDVrBl26JCpRD+gB//43nHMQrF7NljH38cNJw1iy1CpslZs9O7wua1mOevVKpiqJnzB469bKJVaVnd26UaPESVCbNrDbbjvWjde4seYaEhGpK6rtaU0zawHg7qvM7Gp3v6ecsoOBPwE5wMPu/vu44ycBvwG2AkXA1cUtc+VRt2aW+e47+OlP4a234Kyz4MEHwwR0SVi/vvIPQ9SrV3Pddo0ba9yTiEi2qbExZ2V82P/cPeHMoWaWA3wGHAkUApOBoe4+O6ZMM2Ctu7uZ9QKec/fuFX2ukrMstGUL/O53cOutsOee4WnOPn2q/WPc1W0nIiLVq6zkrKY6Osr7NdYXmO/uX7r7JmAssN0Mo+6+xkuyxqZAxq44IDsoJwd++cuwaPratdCvH9x7b9XXNimDEjMREaktNZWclfebsSPwTcz7wmjfdszsFDObC7wMDC/rYmZ2kZlNMbMpS5YsqWq8UtcNHAgffwxHHglXXAGnnRbWzBIREaljqpycmdlqM1uVYFsN7FreqQn2lUrm3H1c1JV5MmH8WULuPsbdC9y9oF1l1keSzNO2Lbz4Ivzf/8G//hW6Nz/4INVRiYiIVEqVkzN3b+7uLRJszd29vKHNhcBuMe87AQvL+ZxJwJ5m1raqsUoWqVcPrr0W3nsvvD7kELjjjso/OikiIpIiqXi4fjLQzcy6mllDYAjwYmwBM/uRWRjlY2b5QENgWa1HKnVX375hTc5TToGbboJjj4XFi1MdlYiISIVqPTmLFkS/HHgdmEN4EnOWmY0wsxFRsdOAT81sBnAfcKbXxGOlktlatYLnnoMHHoCJEyEvL/wUERFJYzUylUaqaCoNKdPHH8OZZ8Lnn8OvfhW2nJxURyUiIlmstqfSEEkvvXvDlClh0tpf/xoOPxy+/TbVUYmIiJSi5EyyR7Nm8MQT8PjjMHly6OZ89dVURyUiIrIdJWeSfc47D6ZOhV13DQ8K3HgjbN6c6qhEREQAJWeSrbp3hw8/hBEj4M47w5QbCxakOioRERElZ5LFGjcOT3I+9xzMmRO6OV94IdVRiYhIllNyJnLGGTB9Ouy1F5x+Olx+OWzYkOqoREQkSyk5EwHYYw94992wusB998FBB8Fnn6U6KhERyUJKzkSKNWxYsi7n//4H+fnw17+mOioREckySs5E4h1/fJi0Nj8fzjkHhg+HtWtTHZWIiGQJJWciiXTqBG+9Bb/8ZZgX7YAD4NFHwxQcGo8mIiI1qH6qAxBJW/Xrw29+A4MGwbnnwgUXhP05ObD33mHVgdht553BLKUhi4hI3afkTKQihx8O33wDX3wRujuLt/feg7/9raRcu3bbJ2u9esE++4SxbCIiIknSwuciO+KHH2DmzO2Ttk8/hY0bw/EGDUKCFt/K1q5dauMWEZGUK2vhcyVnItWtqChMwxGbsH38MXz3XUmZXXYpnbDttVfoShURkaxQVnKWkt8EZjYY+BOQAzzs7r+PO342cFP0dg1wibt/XLtRilRR/fqw775hGzq0ZP+SJaUTtjffLFnXMzcXevQonbS1apWSaoiISGrUesuZmeUAnwFHAoXAZGCou8+OKdMfmOPuP5jZMcAodz+womur5UzqnE2bwtJR8Unb0qUlZTp3Lp2w7bkn1NPD1iIidVk6tZz1Bea7+5cAZjYWOAnYlpy5+/sx5T8EOtVqhCK1pWHDkoSrmHvoAo1P2F5+GbZuDWWaNoWePbdP2Hr2hObNU1MPERGpNqlIzjoC38S8LwTKaxW7AHi1rINmdhFwEUDnzp2rIz6R1DKDXXcN2zHHlOxfvx5mzdo+YRs7Fv7yl5Iye+5ZupVt9901xYeISB2SiuQs0W+JhH2rZnYoITk7uKyLufsYYAyEbs3qCFAkLTVuDAUFYSvmHpaaim9lGzcuHANo2TJM6xGbsO23X7ieiIiknVQkZ4XAbjHvOwEL4wuZWS/gYeAYd19WS7GJ1C1moWVs993hxBNL9q9ZA598sv00H48/HvZDGK+2116lW9l23VWtbCIiKZaK5Gwy0M3MugLfAkOAs2ILmFln4B/AOe7+We2HKFLHNWsGBx0UtmJbt8JXX23fwvbf/8Kzz5aUadOmdMK2zz7QqFHt10FEJEvVenLm7kVmdjnwOmEqjUfdfZaZjYiOPwjcArQB7rfwv/iiRE8ziEgl1KsXxqTtuSecemrJ/pUrS0+k+8ADJWuI1q+feCLd9u1TUw8RkQynSWhFpLQtW+Dzz0uPZfv225IyO+9cOmHbe29NpCsikiStECAiO27p0tKtbLNnh/naIHR/xk+k26sXtG6d2rhFRNKQkjMRqRmbN8PcuaVb2RYvLinTqVPpVrYf/QhyclIXt4hIiik5E5Ha9f33pRO2uXNDlylAkyZhSo/4VrYWLVIbt4hILVFyJiKpt2FD6AaNT9p++KGkTNeupVvZunbVFB8iknHSafkmEclWubmQnx+2Yu5QWFg6YfvnP0sm0m3evPREuj17htY3EZEMo5YzEUlPa9eWXq7q449h9epw3Ay6dSvdytapk1rZRKROUMuZiNQtTZtC375hK+YOCxZsn6xNnQrPP19SpnXr0q1s++4bWu1EROoAJWciUneYhfFnXbvCySeX7F+1KixXFZu0PfQQrFsXjufkQPfupVvZdt45JdUQESmPkjMRqftatIABA8JWbMsW+OKL7RO2d96BZ54pKdO+femErXt3aNCg9usgIhLRmDMRyS7Ll5eeSHfWLNi4MRxv2DB0g8ZO77HbbtChQ0gCNZ5NRKqJptIQESlLURHMm1f64YPvv9++XG5u6Art0CH8LOt1hw5hzJyISDmUnImIVNbixfDpp/DddyFRW7Qo/Ix9vWRJyZQfsZo1Sz6Ra9So9usmIimnpzVFRCqrfXs47LDyyxQVhTVH45O22ERuzhx4++3QpZpIq1blJ2/F+9q103g4kSyg5ExEZEfUr1+SPFVk06bQGldeIjd9evi5alXia7Rtm1wi16aN1i4VqaNSkpyZ2WDgT0AO8LC7/z7ueHfgMSAf+IW731X7UYqIVLOGDcMkuZ06VVx2/frE3aix+z74IHS5rl9f+vx69ULLXzKJ3E476UEHkTRS68mZmeUA9wFHAoXAZDN70d1nxxRbDlwJnFzb8YmIpIXGjaFLl7CVxx3WrEmcyMW+njMn/Ny0qfQ1GjQonbSVNVaueXMlciI1LBUtZ32B+e7+JYCZjQVOArYlZ+6+GFhsZselID4RkbrDLCRMzZvDj35Ufll3WLGi/ERu4cLQtbpoUZgrLl7xE6sVJXJ6YlWkylKRnHUEvol5XwgcWNWLmdlFwEUAnTt33rHIREQymVnowtxppzDZbnm2boVly8pP5L78MnStVvTEajKJnJ5YFdkmFclZovbwKs/n4e5jgDEQptKo6nVERCRGvXrh6dB27WC//covW1QUErTyErnZs6v+xGrsaz2xKlkgFclZIbBbzPtOwMIUxCEiItWhfn3YZZewVWTjxvDEanmJ3LRp4WeiJ1bNwpOoySRyemJV6qhUJGeTgW5m1hX4FhgCnJWCOEREpLY1ahSWw9ptt4rLrlsXkrTyErn33w+vEz2xmpMTWtqSSeT0xKqkkVpPzty9yMwuB14nTKXxqLvPMrMR0fEHzWxnYArQAthqZlcD+7p7GRP/iIhIxmnSBLp2DVt5ip9YLetJ1diu1UWLkn9itX378KBFs2YVb02bhq5gkWqg5ZtERCR7FD+xWlEiV7w0V1FR8tdu0qT85C2ZJC9+a9iwxr4KST0t3yQiIhL7xOo++5Rf1j20sq1ZU/Vt1aowPUnsvg0bko+3QYOqJXXlJYNNmqgLN80pORMREUnELIyRa9QoPFxQXYqKYO3a8pO6io4XFpbel2xPmFnVW/LKSwTrK6WoLvomRUREalP9+tCyZdiqi3t4KGJHWvmWLYOvv94+OUw0Pq8sjRpVX8JXvDVqlJWtfErORERE6jqz0F3ZpEl4kKG6bNpUcSteRduSJdu/X7cu+c/PyamesXt17OENJWciIiKSWMOGYdtpp+q75pYtIUGrapdu8VqyX3xR8n716rCqRbLKe3ijWTNo0QL+/Ofqq3MlKTkTERGR2pOTU7IebHVxDxMc70gL38qVJQ9vgJIzERERkSozg9zcsLVtm+podlh6d7qKiIiIZBklZyIiIiJpRMmZiIiISBpRciYiIiKSRpSciYiIiKSRjFr43MyWAF/X8Me0BZbW8Gekq2yuO2R3/bO57pDd9Vfds1c217+26r67u7eL35lRyVltMLMpiVaQzwbZXHfI7vpnc90hu+uvumdn3SG765/quqtbU0RERCSNKDkTERERSSNKzipvTKoDSKFsrjtkd/2zue6Q3fVX3bNXNtc/pXXXmDMRERGRNKKWMxEREZE0ouQsATN71MwWm9mnZRw3MxttZvPNbKaZ5dd2jDUliboPMrOVZjYj2m6p7RhrkpntZmZvm9kcM5tlZlclKJOR9z/Jumfk/TezXDP7yMw+jur+6wRlMvK+Q9L1z8h7X8zMcsxsupm9lOBYxt57qLDumX7fF5jZJ1HdpiQ4npJ7X782PqQOehy4F3iyjOPHAN2i7UDggehnJnic8usO8I67H1874dS6IuA6d59mZs2BqWb2hrvPjimTqfc/mbpDZt7/jcBh7r7GzBoA75rZq+7+YUyZTL3vkFz9ITPvfbGrgDlAiwTHMvneQ/l1h8y+7wCHuntZc5ql5N6r5SwBd58ELC+nyEnAkx58CLQys11qJ7qalUTdM5q7f+fu06LXqwn/YHWMK5aR9z/Jumek6F6uid42iLb4AbkZed8h6fpnLDPrBBwHPFxGkYy990nUPdul5N4rOauajsA3Me8LyZJfYpGDou6PV82sR6qDqSlm1gXoA/w37lDG3/9y6g4Zev+jrp0ZwGLgDXfPqvueRP0hQ+89cA9wI7C1jOOZfO/vofy6Q+bedwj/Cfm3mU01s4sSHE/JvVdyVjWWYF+2/C9zGmG5id7An4HxqQ2nZphZM+AF4Gp3XxV/OMEpGXP/K6h7xt5/d9/i7nlAJ6Cvme0XVySj73sS9c/Ie29mxwOL3X1qecUS7Kvz9z7JumfkfY8xwN3zCd2Xl5nZwLjjKbn3Ss6qphDYLeZ9J2BhimKpVe6+qrj7w91fARqYWdsUh1WtojE3LwBPu/s/EhTJ2PtfUd2z4f67+wpgIjA47lDG3vdYZdU/g+/9AOBEM1sAjAUOM7O/xpXJ1HtfYd0z+L4D4O4Lo5+LgXFA37giKbn3Ss6q5kXg3Ogpjn7ASnf/LtVB1QYz29nMLHrdl/BnaFlqo6o+Ud0eAea4+x/LKJaR9z+Zumfq/TezdmbWKnrdGDgCmBtXLCPvOyRX/0y99+7+c3fv5O5dgCHAW+7+07hiGXnvk6l7pt53ADNrGj38hJk1BY4C4mcqSMm919OaCZjZ34BBQFszKwRuJQyQxd0fBF4BjgXmA+uA81MTafVLou6nA5eYWRGwHhjimTWT8QDgHOCTaPwNwM1AZ6jb99/MXgXGuvsTZRSJrfsq4AfgErave1rd/+h//D9z9wk7eKldgCfMLIfwy6cHcL6ZjQDOAt4AfkuC+25mDnRz9/lViP9s4Dx3P2oH499R8fV/zt1fiuqflve+psXVvU7+na+qLLrvHYBxUe5ZH3jG3V9Lh3uvFQJE0piZrYl524Qw5cGW6P3F7v507UeVPqoxOYu/btIJV7Jlo4csvgIauHtRtQQqIhlJLWciaczdmxW/Li8RMbP6+oUv6UJ/HkV2jMacidRBFmbtLjSzm8zse+AxM9vJzF4ysyVm9kP0ulPMORPN7GfR62Fm9q6Z3RWV/crMjqli2a5mNsnMVpvZBDO7L8GA6uKyycT4GzN7L7revy1m8LGZnWNmX5vZMjP7RTnfTz8z+z7qpived4qZzYxe9zWzD8xshZl9Z2b3mlnDMq71uJn9Nub9DdE5C81seFzZ4yzMtL7KzL4xs1ExhydFP1eY2RozO6j4u405v7+ZTbYwI/tkM+uf7HdTye+5tZk9FtXhBzMbH3PsJAuzpa8ysy/MbHC0f4GZHRFTblTxfTazLmbmZnaBmf0PeCva/3x0H1ZGf0Z6xJzf2Mz+L7qfK6M/Y43N7GUzuyKuPjPN7OREdRXJRErOROqunYHWwO7ARYS/z49F7zsTxofcW875BwLzgLbAHcAjZpbosfGKyj4DfAS0AUYRxq2VJZkYzyKM62gPNASuBzCzfQmzc58D7Bp9XicSiCaLXAscFnfdZ6LXW4BrovocBBwOXFpO3EQxDI7iOZIwY/gRcUXWAucCrQgTe14Sk1QUP6Lfyt2bufsHcdduDbwMjI7q9kfgZTNrE1eHUt9NAhV9z08Rusl7RNe6O4qhL2F1kBuiOgwEFpTxGYn8GNgHODp6/yrhe2pPmJIhthv+LmB/oD/hz3HxXFtPANsGpZtZb8K8Uq9UIg6ROk3JmUjdtRW41d03uvt6d1/m7i+4+7pohv/bCb8sy/K1uz/k7lsIvxB3IQyQTbqsmXUGDgBucfdN7v4u4emmhJKM8TF3/8zd1wPPAXnR/tOBl9x9krtvBH5F+RNn/g0YCmDhiaxjo324+1R3/9Ddi9x9AfCXBHEk8pMovk/dfS0hGY2t30R3/8Tdt7r7zOjzkrkuhGTuc3d/Korrb4QnJk+IKVPWd7Od8r5nC7ObHwOMcPcf3H2zu/8nOvUC4FF3fyOqw7fuHv/UanlGufvaKD7c/VF3Xx3dr1FAbzNraWb1gOHAVdFnbHH396Ny/wS6mVm36JrnAM+6+6ZKxCFSpyk5E6m7lrj7huI3ZtbEzP4SdROtInSjtYrt2ovzffELd18XvWxWybK7Astj9sH2s2lvJ8kYv495vS4mpl1jrx0lR+U90v8McKqZNQJOBaa5+9dRHHtFXX3fR3H8P0IrWkW2iwH4Oq5+B1pYPH6Jma0ERiR53eJrfx2372u2n428rO9mOxV8z7sR7tkPCU7dDfgiyXgT2fbdWFhx4PdR1+gqSlrg2kZbbqLPihK054CfRkncUEJLn0jWUHImUnfFP2p9HbA3cKC7t6CkG62srsrq8B3Q2syaxOzbrazC7FiM38VeO/rMNmUV9rBg+9eEVqLYLk0I3aNzCU9ZtiBMl1LpGIimGYnxDKHlcDd3bwk8GHPdih6NX0johozVGfg2ibjilfc9f0O4Z60SnPcNsGcZ11xL6AottnOCMrF1PIuwLuERQEugS0wMS4EN5XzWE8DZhO7mdfFdwCKZTsmZSOZoThhbtCIav3RrTX9g1BI1BRhlZg3N7CC274arzhj/DhxvZgdHg/dvo+J/w54BriQkJ8/HxbEKWGNm3QnzuSXjOWCYme0bJYfx8TcntEptiMZvnRVzbAmhG3aPMq79CrCXmZ1lZvXN7ExgX+ClJGOLjyPh9xxNoPkqcH/04EADK1my5hHC/G6Hm1k9M+sYfT8AM4AhUfkCQjdzRTFsJLRuNiG0ThbHsBV4FPijme0atbIdFLVyEiVjW4H/Q61mkoWUnIlkjnuAxoRWiQ+B12rpc88mDKpfRpio9VnCL+VE7qGKMbr7LOAyQsL1HWGS3MIKTiueVPktd18as/96QuK0GngoijmZGF6N6vAWYVLKt+KKXArcZmargVsIyVzxuesIY7/es/CUaL+4ay8Djie0ei0jDJA/Pi7uZN1D+d/zOcBmQuvhYuDqKIaPCA8c3A2sBP5DSWverwgtXT8Av2b7lshEniS0XH4LzI7iiHU98AkwGVgO/IHtfyc9CfQEEj75K5LJNAmtiFQrM3sWmOvuNd5yJ5nLzM4FLnL3g1Mdi0htU8uZiOwQMzvAzPaMusEGE8YZjU9xWFKHRV3GlwJjUh2LSCooORORHbUzMBFYQ5ij6xJ3n57SiKTOMrOjCePzFlFx16lIRlK3poiIiEgaUcuZiIiISBpRciYiIiKSRuqnOoDq1LZtW+/SpUuqwxARERGp0NSpU5e6e7v4/RmVnHXp0oUpU6akOgwRERGRCplZ/JJtgLo1RURERNKKkjMRERGRNKLkTERERCSNZNSYMxEREZGEtmyBdetg7dqKty1b4LrrUhaqkjMRERFJD5s2JZc8lbWVl3xt2JB8HA0bKjkTERGROsA9JDk7kkCVtxUVVS6e3Fxo2rT01r594v2V2VJIyZmIiEgm2bo1+e67qrRMbd2afCxm0KRJ4uSndesdS56aNIGcnJr7HlNIyZmIiEhtKyqqudan9esrF0tOTuLkp3lz2HnnHUugGjcOCZpUipIzERGRRDZuhDVrqr/lae3aMLaqMho2TJz8tGkDnTvvWALVsKESqDSj5ExERLLDpk2wZEnYFi8OW3mv16yp3PXL6r7r2HH7rriqJFD19es6m+hui4hI3VRUBMuWJZ9srViR+DoNGkC7dmEQefv28KMfhZ9t2oSuvWS77+pp6lCpHkrOREQkPWzdCj/8kHyytWxZeHowXr160LZtSbKVn1/yOjYJK37dsqW69SStKDkTEZGa4Q6rViWfbC1ZEib/TKR165Kkat99y0+2WrdWK5bUaUrOREQkeWvXJp9sLV5c9sD3li1Lkqk994R+/UonWcU/27QJXY8iWULJmYhINtu4sXLJ1rp1ia/TtGlJMtWxI+Tlld261a4dNGpUq9UUqUuUnImIZJKiIli6NPlka9WqxNdp2LAkoWrfHrp3Lz/ZSvGM6iKZRMmZiEg627oVli9PPtlavjzxdXJytk+qunQpf9xW8+YaJC+SIkrORERqkzusXJl8srV0aeLlcszCWKzipKpnz/KTrVatNEhepI5QciYisiPcwyD5ZJOtJUtg8+bE19ppp5Jkaq+9YMCA8gfJZ+i6giLZTsmZiEgi7lBYCLNnw/ffl594bdiQ+BrNm5ckU507w/77l9261bZtGOclIllPyZmIyIoV8Omn8Mkn228rV25fLjd3+0HyPXqUP0i+ceOUVEdE6rYaTc7MbDDwJyAHeNjdfx93fCfgUWBPYAMw3N0/jY4tAFYDW4Aidy+oyVhFJAts2gRz55ZOwr75pqRMy5Zh/NZZZ4Wf++0XpoZo3z48kahB8iJSw2osOTOzHOA+4EigEJhsZi+6++yYYjcDM9z9FDPrHpU/POb4oe6+tKZiFJEM5Q5ff106CZs3L0w1AWFS0332gYEDQxJWvHXqpARMRFKqJlvO+gLz3f1LADMbC5wExCZn+wK/A3D3uWbWxcw6uPuiGoxLRDLJ8uWlk7BPP4XVq0vKdOkSEq+TTipJwvbaS7POi0haqsnkrCMQ01dAIXBgXJmPgVOBd82sL7A70AlYBDjwbzNz4C/uPibRh5jZRcBFAJ07d67WCohIGtmwAebMKZ2ILVxYUmannaBXLzjvvJIkrEcPaNEidXGLiFRSTSZnifoFPO7974E/mdkM4BNgOhD1OTDA3ReaWXvgDTOb6+6TSl0wJG1jAAoKCuKvLyJ1zdatsGBBSfI1c2b4+fnnJYtiN2oUuiQPP3z7Lsldd1WXpIjUeTWZnBUCu8W87wQsjC3g7quA8wHMzICvog13Xxj9XGxm4wjdpKWSMxGpw5YuTdwluXZtSZk99giJ1+mnlyRh3bpBfT1sLiKZqSb/dZsMdDOzrsC3wBDgrNgCZtYKWOfum4CfAZPcfZWZNQXqufvq6PVRwG01GKuI1KT168N8YfGJ2Pffl5Rp2zYkXhdcsH2XZLNmqYtbRCQFaiw5c/ciM7sceJ0wlcaj7j7LzEZExx8E9gGeNLMthAcFLohO7wCMC41p1AeecffXaipWEakmW7bAl1+WTsLmzy9Zgig3NyRdgwdv3yXZoYO6JEVEAHPPnGFaBQUFPmXKlFSHIZIdFi0qnYTNmhVaySAkWnvuGQboxyZhe+6pZYdERAAzm5poHlcN2hCR8q1dG5Ku+ERsyZKSMsULb198cUkStu++YdJWERGpFCVnIhJs2RK6H2MTsJkzQzdlcQt7kyahS/KEE7ZvDWvfPrWxi4hkECVnItnGPQzEj28Jmz27ZAHvevXCE5F9+sC555YkYXvsEY6JiEiNUXImksnWrEm8oPeyZSVldtklJF6XXVaShO2zjxbtFhFJESVnIpmgqAg++6x0EvbVVyVlmjYNi3ifempJErbffmEKCxERSRtKzkTqEnf49tvSSdicObBpUyiTkxPWjTzgABg+vCQR69JFXZIiInWAkjORdLVqVeIuyR9+KCnTsWNIvI46qiQJ6949zCUmIiJ1kpIzkVTbvBnmzSudhH39dUmZ5s1D4vWTn2zfJdm6deriFhGRGqHkTKS2uMM335ROwubODQkahPUiu3eH/v23nzOsc2fNni8ikiWUnInUhBUrEi/ovXJlSZnddguJ17HHbt8l2bBhysIWEZHUU3ImsiM2bgwtX/GJWGFhSZmWLUPiddZZ23dJtmqVsrBFRCR9KTkTSYZ7GAM2c+b2Sdhnn4VpLAAaNAjzg/34x9vPnt+pk7okRUQkaUrORCryzjvw05/C//5Xsq9Ll5B4nXxySRK2114hQRMREdkBSs5EyrJ1K9x1F9x8c1i26MEHoVevsLZkixapjk5ERDKUkjORRJYvh/POg5degjPOgIcfVkImIiK1QsmZSLyPPgrziS1cCH/+c1hzUmPGRESklmgtF5Fi7iEZO/jg8P7dd+Hyy5WYiYhIrVJyJgJhqaQzz4Qrr4Sjj4Zp06Bv31RHJSIiWUjJmcjHH8P++8M//gF33AH//KeWRRIRkZRRcibZyx0eeQT69YN16+Dtt+GGG6Ce/lqIiEjq1OhvITMbbGbzzGy+mY1McHwnMxtnZjPN7CMz2y/Zc0V2yNq1MGwY/OxnYYzZ9OlwyCGpjkpERKTi5MzMjjezSidxZpYD3AccA+wLDDWzfeOK3QzMcPdewLnAnypxrkjVzJkDBx4ITz0Fo0bBa69B+/apjkpERARIruVsCPC5md1hZvtU4tp9gfnu/qW7bwLGAifFldkXeBPA3ecCXcysQ5LnilTeM8/AAQfA4sXw+utw662Qk5PqqERERLapMDlz958CfYAvgMfM7AMzu8jMmldwakfgm5j3hdG+WB8DpwKYWV9gd6BTkucSnXeRmU0xsylLliypqDqSrTZsgEsugbPPhj59QjfmkUemOioREZFSkpqE1t1XmdkLQGPgauAU4AYzG+3ufy7jtESTQ3nc+98DfzKzGcAnwHSgKMlzi2MbA4wBKCgoSFhGstwXX4RZ/qdPh5tugt/+Fupr/mURKduWLVBUFJ4bgvAz/nV5x3b0nFSVS4cY0iHWnJywpHKqVPgbysxOAIYDewJPAX3dfbGZNQHmAGUlZ4XAbjHvOwELYwu4+yrg/OhzDPgq2ppUdK5IUsaNg/PPD09gvvginHBCqiMSyQjuYfnZzZvDVlRU+nWifcm8Tofzin9ZS3Zq3DjNkzPgDOBud58Uu9Pd15nZ8HLOmwx0M7OuwLeEsWtnxRYws1bAumhc2c+ASVErXYXnipRr0yYYORLuvjuMMXvuOejSJdVRSZZxDy0w6ZZ4VNd5ta1+/bA1aBC24teJ9sW+zs2t2nn164cFQooXCanodbqXS4cY6kqdUj2jUjLJ2a3Ad8VvzKwx0MHdF7j7m2Wd5O5FZnY58DqQAzzq7rPMbER0/EFgH+BJM9sCzAYuKO/cKtVQss8334TZ/j/4AK64Au68Exo1SnVUsgOKk5xNm8rfNm6suExVtqokN8Wva1uyiUf869zcqp1X1c+r7HnFiZJINjCvoO3WzKYA/aPWLcysIfCeux9QC/FVSkFBgU+ZMiXVYUgqvfoqnHNO+I368MNhAXMpU3G3VHUlMTWVHG3aVDPdTGYhb2/YsOytOEGo6SSlOq6Rk6MERqQuMbOp7l4Qvz+ZlrP6xYkZgLtvihI0kfRRVBTmLLv9dujVC55/HvbaKyWhJNvKU91bVRKjmmrZqV+//IQnNiFq0qT8stW5xSdimkVFRNJRMsnZEjM70d1fBDCzk4ClNRuWSCV89x2cdRZMnBhm/B89OozmrISNG2HJkjD92eLFsGjR9q+XLAkrPCWbHNXUYOKKWnmKt8aNoWXLyicr1bE1aJD68RoiInVZMsnZCOBpM7uXMMXFN4TZ/EVS7+23YehQWLUKHn8czjsPCMnRypWlk6zi1/HvV6xIfPlGjaBDh7CAQLNm0KJF7bXqxG/qshIRyQ4VJmfu/gXQz8yaEcaora75sERK27SppHVr0XdbWfzoSyz+xzss2ul2Fh95KovH7sSiP5UkXGU9TdamTUi2OnSAvLyS1+3bl2yxCZkSIhERqU1JzcRpZscBPYBci35TufttNRiXZIHi1q1kWrYWLYpv3aoHnAicSKO1TocZRvv2sOuuJQlXfNLVoQO0bav5Z0VEJL0lMwntg4RJYQ8FHgZOBz6q4bikjtq8efsEK1GSFXts06bE1ylu3WrfPozv35ZkrfmCDo/8jvYrP6f9ry6m/VVDad7C1LolIiIZI5k2hP7u3svMZrr7r83s/4B/1HRgkh7cw3CuZFq2Fi+GH35IfJ1GjUpar3beOS7himvlats2DCovFcg998BtN8Juu8G//w75+TVdfRERkVqXTHK2Ifq5zsx2BZYBXWsuJKlpmzeX/2RifMvXxo2Jr9O6dUlS1atX2V2J7dtD8+Y7MHZrxQoYPjwsxXTyyfDYY9CqVRUvJiIikt6SSc7+FS2zdCcwjbAA+UM1GZRUjjusXp38k4nLlye+TsOGJclUhw7Qs2f5Y7dKtW7VhKlTw6Ll33wDf/wjXH21RuiLiEhGKzc5M7N6wJvuvgJ4wcxeAnLdfWVtBJfNNm+GpUvLb9mKfV1R61b79rDffolbtYq3Fi3SKO9xh7/8Ba66KgQ3aRIcdFCqoxIREalx5SZn7r41GmN2UPR+I1BGGiDlKW7dSvbJxPJat2ITq/iEK37sVsOGtVvParFmDVx8MTzzDAweDE89FSojIiKSBZLp1vy3mZ0G/MMrWogzyxQVbT92q6LxWxs2JL7OTjuVJFU9esChh5Y9diutWrdqwqefhm7Mzz6D3/4Wfv5zTTcvIiJZJZnk7FqgKVBkZhsIqwS4u7eo0cjS0FVXwcyZJUnXsmWJyxW3bhVvPXqU3ZXYrl0dbd2qCU8+CSNGhAx0woSQpYqIiGSZZFYIaF4bgdQFixaFBa333bekdStR0tWyZYa3blW39evhiivgkUdg0CD429/CfBsiIiJZKJlJaAcm2u/uk6o/nPQ2dmyqI8hAn30WujFnzoRf/AJGjdIU/iIiktWS+S14Q8zrXKAvMBU4rEYikuzx/PNwwQWhX/eVV+CYY1IdkYiISMol0615Qux7M9sNuKPGIpLMt3EjXH893Hsv9OsHzz0XZv0XERERqvIYXCGwX3UHIlliwQI45JCQmF1zDfznP0rMREREYiQz5uzPhFUBICRzecDHNRiTZKqXXoJzzw1PVfzjH3DKKamOSEREJO0k03I2hTDGbCrwAXCTu/80mYub2WAzm2dm881sZILjLc3sX2b2sZnNMrPzY44tMLNPzGyGmU1Jsj6SjjZvhptughNOgC5dYNo0JWYiIiJlSOaBgL8DG9x9C4CZ5ZhZE3dfV95JZpYD3AccSegKnWxmL7r77JhilwGz3f0EM2sHzDOzp919U3T8UHdfWtlKSRr59lsYMgTefTfMYXb33ZCbm+qoRERE0lYyLWdvAo1j3jcGJiRxXl9gvrt/GSVbY4GT4so40NzMDGgGLAeKkri21AVvvAF9+sD06fD00/DAA0rMREREKpBMcpbr7muK30SvmyRxXkfgm5j3hdG+WPcC+wALgU+Aq9x9a/FHEZaOmmpmFyXxeZIutmwJ85UdfXSYlXfyZDjrrFRHJSIiUickk5ytNbP84jdmtj+wPonzEs2RH78259HADGBXwoMG95pZ8bJQA9w9HzgGuKysyXDN7CIzm2JmU5YsWZJEWFKjFi8Oi5X/+tdwzjnw3//CPvukOioREZE6I5nk7GrgeTN7x8zeAZ4FLk/ivEIgdo6EToQWsljnEy2o7u7zga+A7gDuvjD6uRgYR+gmLcXdx7h7gbsXtGvXLomwpMa8807oxnz3XXj4YXj8cWjaNNVRiYiI1CkVJmfuPpmQMF0CXArs4+5Tk7j2ZKCbmXU1s4bAEODFuDL/Aw4HMLMOwN7Al2bW1MyaR/ubAkcBnyZXJal1W7fCHXeEBUebNoUPPwwz/2uBURERkUqrMDkzs8uApu7+qbt/AjQzs0srOs/diwgtbK8Dc4Dn3H2WmY0wsxFRsd8A/c3sE8KDBzdFT2d2AN41s4+Bj4CX3f21qlRQatjy5XDyyWGqjFNPhSlToHfvVEclIiJSZ5l7/DCwuAJmM9w9L27fdHfvU5OBVUVBQYFPmaIp0WrNRx/BT34CCxfCH/8Il12m1jIREZEkmdlUdy+I35/MmLN60VQXxRfKARpWZ3BSx7jDn/8MBx8c3r/7Llx+uRIzERGRapDMJLSvA8+Z2YOEpy1HAK/WaFSSvlatgp/9DJ5/Ho4/Hp54Alq3TnVUIiIiGSOZ5Owm4CLCAwEGTAd2qcmgJE19/DGccQZ8+SX84Q9w/fVQL5nGVxEREUlWMk9rbgU+BL4ECghPV86p4bgknbjDI49Av36wZg289RbceKMSMxERkRpQZsuZme1FmP5iKLCMML8Z7n5o7YQmaWHt2jDQ/4kn4IgjwjJM7dunOioREZGMVV635lzgHeCEaIJYzOyaWolK0sOcOaEbc/bssBzTL38JOTmpjkpERCSjldcvdRrwPfC2mT1kZoeTeEkmyUTPPAMHHBCWY3r9dbj1ViVmIiIitaDM5Mzdx7n7mYTVASYC1wAdzOwBMzuqluKT2rZhA1xyCZx9dliKafp0OPLIVEclIiKSNZJ5IGCtuz/t7scT1secAYys6cAkBb78EgYMgAcfDAP+33oLOnZMdVQiIiJZJZmpNLZx9+XAX6JNMsm4cXD++WEi2X/+E048MdURiYiIZCXNhZDtNm+G664L62LutVfoxlRiJiIikjKVajmTDPPNN3DmmfDBB3DFFXDnndCoUaqjEhERyWpKzrLVq6/COefApk3w7LNhAXMRERFJOXVrZpuiojBf2bHHhsH+U6YoMRMREUkjajnLJt9/D0OHwsSJcMEF8Oc/Q+PGqY5KREREYig5yxYTJ8KQIbBqFTz+OJx3XqojEhERkQTUrZnptm6F//f/4PDDoVUr+OgjJWYiIiJpTC1nmWzp0jDo/7XXQnfmmDHQrFmqoxIREZFyKDnLVB98EAb6L14MDzwAF18cJpgVERGRtKZuzUzjDnffDQMHQoMGIUkbMUKJmYiISB1Ro8mZmQ02s3lmNt/MSq3HaWYtzexfZvaxmc0ys/OTPVcSWLECTjsNrr0Wjj8epk2D/PxURyUiIiKVUGPdmmaWA9wHHAkUApPN7EV3nx1T7DJgtrufYGbtgHlm9jSwJYlzJda0aXDGGfC//8H//R9cc41ay0REssDmzZspLCxkw4YNqQ5FypCbm0unTp1o0KBBUuVrcsxZX2C+u38JYGZjgZOA2ATLgeZmZkAzYDlQBByYxLkCoRtzzBi46ipo1w7+8x/o3z/VUYmISC0pLCykefPmdOnSBdN/ytOOu7Ns2TIKCwvp2rVrUufUZLdmR+CbmPeF0b5Y9wL7AAuBT4Cr3H1rkufKmjXw05+GMWWHHhoWLVdiJiKSVTZs2ECbNm2UmKUpM6NNmzaVatmsyeQs0Z8Sj3t/NDAD2BXIA+41sxZJnhs+xOwiM5tiZlOWLFlS9Wjrmk8/hQMOgLFj4be/hZdfhrZtUx2ViIikgBKz9FbZ+1OTyVkhsFvM+06EFrJY5wP/8GA+8BXQPclzAXD3Me5e4O4F7dq1q7bg09qTT0LfvvDDDzBhAvziF1BPD96KiEjtW7ZsGXl5eeTl5bHzzjvTsWPHbe83bdpU7rlTpkzhyiuvrPAz+mdZr1BNjjmbDHQzs67At8AQ4Ky4Mv8DDgfeMbMOwN7Al8CKJM7NPuvXwxVXwCOPwI9/DH/7G+yyS6qjEhGRLNamTRtmzJgBwKhRo2jWrBnXX3/9tuNFRUXUr5843SgoKKCgoKDCz3j//ferJda6osaaW9y9CLgceB2YAzzn7rPMbISZjYiK/Qbob2afAG8CN7n70rLOralY64TPP4d+/UJidvPNocVMiZmIiKShYcOGce2113LooYdy00038dFHH9G/f3/69OlD//79mTdvHgATJ07k+OOPB0JiN3z4cAYNGsQee+zB6NGjt12vWbS6zcSJExk0aBCnn3463bt35+yzz8Y9jHp65ZVX6N69OwcffDBXXnnltuvGWrBgAYcccgj5+fnk5+dvl/Tdcccd9OzZk969ezNyZJjBa/78+RxxxBH07t2b/Px8vvjii5r5wuLU6AoB7v4K8ErcvgdjXi8Ejkr23Kz1/PNwwQVhUtlXXoFjjkl1RCIiko6uvhqiVqxqk5cH99xT6dM+++wzJkyYQE5ODqtWrWLSpEnUr1+fCRMmcPPNN/PCCy+UOmfu3Lm8/fbbrF69mr333ptLLrmk1PQT06dPZ9asWey6664MGDCA9957j4KCAi6++GImTZpE165dGTp0aMKY2rdvzxtvvEFubi6ff/45Q4cOZcqUKbz66quMHz+e//73vzRp0oTly5cDcPbZZzNy5EhOOeUUNmzYwNatWyv9PVSFlm9KZxs3wg03wJ//HFrNnn0WOndOdVQiIiIVOuOMM8jJyQFg5cqVnHfeeXz++eeYGZs3b054znHHHUejRo1o1KgR7du3Z9GiRXTq1Gm7Mn379t22Ly8vjwULFtCsWTP22GOPbVNVDB06lDFjxpS6/ubNm7n88suZMWMGOTk5fPbZZwBMmDCB888/nyZNmgDQunVrVq9ezbfffsspp5wChLnKaouSs3S1YEFYG3Py5DCh7O9/Dw0bpjoqERFJZ1Vo4aopTZs23fb6V7/6FYceeijjxo1jwYIFDBo0KOE5jRo12vY6JyeHoqKipMoUd21W5O6776ZDhw58/PHHbN26dVvC5e6lnqhM9po1QY/4paOXXgrLLs2bB//4B/zxj0rMRESkzlq5ciUdO4bpSh9//PFqv3737t358ssvWbBgAQDPPvtsmXHssssu1KtXj6eeeootW7YAcNRRR/Hoo4+ybt06AJYvX06LFi3o1KkT48ePB2Djxo3bjtc0JWfppKgIbroJTjgBunQJSzJFzakiIiJ11Y033sjPf/5zBgwYsC0hqk6NGzfm/vvvZ/DgwRx88MF06NCBli1blip36aWX8sQTT9CvXz8+++yzba17gwcP5sQTT6SgoIC8vDzuuusuAJ566ilGjx5Nr1696N+/P99//321x56IpbLZrroVFBT4lClTUh1G1Xz7LQwdCu+8AxdfHJqma7F/W0RE6qY5c+awzz77pDqMlFuzZg3NmjXD3bnsssvo1q0b11xzTarD2ibRfTKzqe5eai4RtZylgwkToE+f0FL217/Cgw8qMRMREamEhx56iLy8PHr06MHKlSu5+OKLUx1SlemBgFTasiUsvfTrX8O++4YpM/S/HxERkUq75ppr0qqlbEcoOUuVxYvh7LNDq9m558L990PMky0iIiKSnZScpcI778CQIbB8OTz8MAwfDlq0VkRERNCYs9q1dSvccQcceig0aQIffhhm/ldiJiIiIhG1nNWW5cth2DD417/g9NPDGpktWqQ6KhEREUkzajmrDZMnh0llX3sNRo+G555TYiYiIhlh0KBBvP7669vtu+eee7j00kvLPad46qtjjz2WFStWlCozatSobfONlWX8+PHMnj172/tbbrmFCRMmVCL69KTkrCa5w733woAB4f2778IVV6gbU0REMsbQoUMZO3bsdvvGjh1b5uLj8V555RVatWpVpc+OT85uu+02jjjiiCpdK50oOaspq1bBmWeGZOzoo8McZn37pjoqERGRanX66afz0ksvsXHjRgAWLFjAwoULOfjgg7nkkksoKCigR48e3HrrrQnP79KlC0uXLgXg9ttvZ++99+aII45g3rx528o89NBDHHDAAfTu3ZvTTjuNdevW8f777/Piiy9yww03kJeXxxdffMGwYcP4+9//DsCbb75Jnz596NmzJ8OHD98WX5cuXbj11lvJz8+nZ8+ezJ07t1RMCxYs4JBDDiE/P5/8/Hzef//9bcfuuOMOevbsSe/evRk5ciQA8+fP54gjjqB3797k5+fzxRdf7NB3qjFnNeHjj+GMM+DLL+EPf4Drr4d6yoNFRKRmXX01zJhRvdfMyyt/PfU2bdrQt29fXnvtNU466STGjh3LmWeeiZlx++2307p1a7Zs2cLhhx/OzJkz6dWrV8LrTJ06lbFjxzJ9+nSKiorIz89n//33B+DUU0/lwgsvBOCXv/wljzzyCFdccQUnnngixx9/PKeffvp219qwYQPDhg3jzTffZK+99uLcc8/lgQce4Oqrrwagbdu2TJs2jfvvv5+77rqLhx9+eLvz27dvzxtvvEFubi6ff/45Q4cOZcqUKbz66quMHz+e//73vzRp0oTly5cDcPbZZzNy5EhOOeUUNmzYwNatWyv/RcdQxlCd3MNA/379YM0aeOstuPFGJWYiIpLRYrs2Y7s0n3vuOfLz8+nTpw+zZs3argsy3jvvvMMpp5xCkyZNaNGiBSeeeOK2Y59++imHHHIIPXv25Omnn2bWrFnlxjNv3jy6du3KXnvtBcB5553HpEmTth0/9dRTAdh///23LZYea/PmzVx44YX07NmTM844Y1vcEyZM4Pzzz6dJkyYAtG7dmtWrV/Ptt99ySrQWdm5u7rbjVaWWs+qydi1cdhk88QQcfjg88wy0b5/qqEREJIuU18JVk04++WSuvfZapk2bxvr168nPz+err77irrvuYvLkyey0004MGzaMDRs2lHsdK2NM9rBhwxg/fjy9e/fm8ccfZ+LEieVep6J1wxs1agRATk4ORUVFpY7ffffddOjQgY8//pitW7eSGy2p6O6lYqyJNcrVpFMd5s6FAw+EJ5+EW2+F119XYiYiIlmjWbNmDBo0iOHDh29rNVu1ahVNmzalZcuWLFq0iFdffbXcawwcOJBx48axfv16Vq9ezb/+9a9tx1avXs0uu+zC5s2befrpp7ftb968OatXry51re7du7NgwQLmz58PwFNPPcWPf/zjpOuzcuVKdtllF+rVq8dTTz3Fli1bADjqqKN49NFHWbduHQDLly+nRYsWdOrUifHjxwOwcePGbcerSsnZjnrmGSgoCMsxvf46jBoFOTmpjkpERKRWDR06lI8//pghQ4YA0Lt3b/r06UOPHj0YPnw4A4pnLihDfn4+Z555Jnl5eZx22mkccsgh24795je/4cADD+TII4+ke/fu2/YPGTKEO++8kz59+mw3CD83N5fHHnuMM844g549e1KvXj1GjBiRdF0uvfRSnnjiCfr168dnn31G02h5xcGDB3PiiSdSUFBAXl7etqk+nnrqKUaPHk2vXr3o378/33//fdKflYjVRHNcqhQUFHjxvCk1bsMGuOYaePBBOPhgGDsWOnasnc8WERGJzJkzh3322SfVYUgFEt0nM5vq7gXxZWu05czMBpvZPDObb2YjExy/wcxmRNunZrbFzFpHxxaY2SfRsVrKuJL05Zdh7rIHHwwD/t96S4mZiIiIVIsaeyDAzHKA+4AjgUJgspm96O7bHtVw9zuBO6PyJwDXuPvymMsc6u5LayrGKhk3Ds4/P0wk+89/QszTJCIiIiI7qiZbzvoC8939S3ffBIwFTiqn/FDgbzUYz44pKoLrroNTT4Vu3WD6dCVmIiIiUu1qMjnrCHwT874w2leKmTUBBgMvxOx24N9mNtXMLirrQ8zsIjObYmZTlixZUg1hlyEnB77+Gi6/PCzD1KVLzX2WiIhIJWTS+PFMVNn7U5PznCWarKSs6E4A3ovr0hzg7gvNrD3whpnNdfdJ8Se6+xhgDIQHAnY06DKZhUH/9TU1nIiIpI/c3FyWLVtGmzZtypwnTFLH3Vm2bNm2udKSUZOZRiGwW8z7TsDCMsoOIa5L090XRj8Xm9k4QjdpqeSsVikxExGRNNOpUycKCwup0d4j2SG5ubl06tQp6fI1mW1MBrqZWVfgW0ICdlZ8ITNrCfwY+GnMvqZAPXdfHb0+CritBmMVERGpkxo0aEDXrl1THYZUoxpLzty9yMwuB14HcoBH3X2WmY2Ijj8YFT0F+Le7r405vQMwLmqerQ884+6v1VSsIiIiIulCk9CKiIiIpEBKJqEVERERkcrJqJYzM1sCfF3DH9MWSK+JcWtPNtcdsrv+2Vx3yO76q+7ZK5vrX1t1393d28XvzKjkrDaY2ZRETZDZIJvrDtld/2yuO2R3/VX37Kw7ZHf9U113dWuKiIiIpBElZyIiIiJpRMlZ5Y1JdQAplM11h+yufzbXHbK7/qp79srm+qe07hpzJiIiIpJG1HImIiIikkaUnCVgZo+a2WIz+7SM42Zmo81svpnNNLP82o6xpiRR90FmttLMZkTbLbUdY00ys93M7G0zm2Nms8zsqgRlMvL+J1n3jLz/ZpZrZh+Z2cdR3X+doExG3ndIuv4Zee+LmVmOmU03s5cSHMvYew8V1j3T7/sCM/skqlupWexTde+1kndijwP3Ak+WcfwYoFu0HQg8EP3MBI9Tft0B3nH342snnFpXBFzn7tPMrDkw1czecPfZMWUy9f4nU3fIzPu/ETjM3deYWQPgXTN71d0/jCmTqfcdkqs/ZOa9L3YVMAdokeBYJt97KL/ukNn3HeBQdy9rTrOU3Hu1nCXg7pOA5eUUOQl40oMPgVZmtkvtRFezkqh7RnP379x9WvR6NeEfrI5xxTLy/idZ94wU3cs10dsG0RY/IDcj7zskXf+MZWadgOOAh8sokrH3Pom6Z7uU3HslZ1XTEfgm5n0hWfJLLHJQ1P3xqpn1SHUwNcXMugB9gP/GHcr4+19O3SFD73/UtTMDWAy84e5Zdd+TqD9k6L0H7gFuBLaWcTyT7/09lF93yNz7DuE/If82s6lmdlGC4ym590rOqsYS7MuW/2VOIyw30Rv4MzA+teHUDDNrBrwAXO3uq+IPJzglY+5/BXXP2Pvv7lvcPQ/oBPQ1s/3iimT0fU+i/hl5783seGCxu08tr1iCfXX+3idZ94y87zEGuHs+ofvyMjMbGHc8JfdeyVnVFAK7xbzvBCxMUSy1yt1XFXd/uPsrQAMza5visKpVNObmBeBpd/9HgiIZe/8rqns23H93XwFMBAbHHcrY+x6rrPpn8L0fAJxoZguAscBhZvbXuDKZeu8rrHsG33cA3H1h9HMxMA7oG1ckJfdeyVnVvAicGz3F0Q9Y6e7fpTqo2mBmO5uZRa/7Ev4MLUttVNUnqtsjwBx3/2MZxTLy/idT90y9/2bWzsxaRa8bA0cAc+OKZeR9h+Tqn6n33t1/7u6d3L0LMAR4y91/GlcsI+99MnXP1PsOYGZNo4efMLOmwFFA/EwFKbn3elozATP7GzAIaGtmhcCthAGyuPuDwCvAscB8YB1wfmoirX5J1P104BIzKwLWA0M8s2YyHgCcA3wSjb8BuBnoDBl//5Ope6be/12AJ8wsh/DL5zl3f8nMRkDG33dIrv6Zeu8TyqJ7X0oW3fcOwLgo96wPPOPur6XDvdcKASIiIiJpRN2aIiIiImlEyZmIiIhIGlFyJiIiIpJGlJyJiIiIpBElZyIiIiJpRMmZiGQ0M9tiZjNitpHVeO0uZhY/L5KIyA7RPGcikunWR8sSiYjUCWo5E5GsZGYLzOwPZvZRtP0o2r+7mb1pZjOjn52j/R3MbFy0APTHZtY/ulSOmT1kZrPM7N/RDPuY2ZVmNju6ztgUVVNE6iAlZyKS6RrHdWueGXNslbv3Be4F7on23Qs86e69gKeB0dH+0cB/ogWg84FZ0f5uwH3u3gNYAZwW7R8J9ImuM6JmqiYimUgrBIhIRjOzNe7eLMH+BcBh7v5ltOD79+7exsyWAru4++Zo/3fu3tbMlgCd3H1jzDW6AG+4e7fo/U1AA3f/rZm9BqwBxgPjixePFhGpiFrORCSbeRmvyyqTyMaY11soGct7HHAfsD8w1cw0xldEkqLkTESy2ZkxPz+IXr8PDIlenw28G71+E7gEwMxyzKxFWRc1s3rAbu7+NnAj0Aoo1XonIpKI/icnIpmusZnNiHn/mrsXT6fRyMz+S/iP6tBo35XAo2Z2A7AEOD/afxUwxswuILSQXQJ8V8Zn5gB/NbOWgAF3u/uKaqqPiGQ4jTkTkawUjTkrcPelqY5FRCSWujVFRERE0ohazkRERETSiFrORERERNKIkjMRERGRNKLkTERERCSNKDkTERERSSNKzkRERETSiJIzERERkTTy/wE3OVE/T2JF8gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the accuracy and loss over time \n",
    "# Reusing sample code from : https://www.tensorflow.org/text/tutorials/classify_text_with_bert\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "history_dict = history.history\n",
    "print(history_dict.keys())\n",
    "\n",
    "acc = history_dict['accuracy']\n",
    "val_acc = history_dict['val_accuracy']\n",
    "loss = history_dict['loss']\n",
    "val_loss = history_dict['val_loss']\n",
    "\n",
    "#print(loss)\n",
    "\n",
    "epochs_number = range(1, (epochs) + 1)\n",
    "fig = plt.figure(figsize=(10, 6))\n",
    "fig.tight_layout()\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "# \"bo\" is for \"blue dot\"\n",
    "plt.plot(epochs_number, loss, 'r', label='Training loss')\n",
    "# b is for \"solid blue line\"\n",
    "plt.plot(epochs_number, val_loss, 'b', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "# plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(epochs_number, acc, 'r', label='Training acc')\n",
    "plt.plot(epochs_number, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend(loc='lower right')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "apart-christian",
   "metadata": {
    "id": "apart-christian"
   },
   "outputs": [],
   "source": [
    "# Show tensorboard\n",
    "\n",
    "# %load_ext tensorboard\n",
    "# %tensorboard --logdir logs/fit\n",
    "#%reload_ext tensorboard # just in case tensorboard didn't refresh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "5gMTwri775Ex",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5gMTwri775Ex",
    "outputId": "19a9e5b1-43b9-47c3-d743-bd293d598440"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'input_ids': <tf.Tensor: shape=(4000, 100), dtype=int32, numpy=\n",
       " array([[ 101, 1045, 2018, ...,    0,    0,    0],\n",
       "        [ 101, 2795, 2057, ...,    0,    0,    0],\n",
       "        [ 101, 1998, 2043, ...,    0,    0,    0],\n",
       "        ...,\n",
       "        [ 101, 2008, 4081, ...,    0,    0,    0],\n",
       "        [ 101, 1037, 6054, ...,    0,    0,    0],\n",
       "        [ 101, 2001, 2279, ...,    0,    0,    0]])>}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_val_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "axoHnl6t-Nzp",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "axoHnl6t-Nzp",
    "outputId": "716f5b21-1196-4310-c7e4-80077ad49a68"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'input_ids': <tf.Tensor: shape=(5000, 100), dtype=int32, numpy=\n",
       " array([[ 101, 3638, 2011, ...,    0,    0,    0],\n",
       "        [ 101, 7367, 7770, ...,    0,    0,    0],\n",
       "        [ 101, 1996, 9530, ...,    0,    0,    0],\n",
       "        ...,\n",
       "        [ 101, 6350, 1998, ...,    0,    0,    0],\n",
       "        [ 101, 2903, 2008, ...,    0,    0,    0],\n",
       "        [ 101, 4618, 2275, ...,    0,    0,    0]])>}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "jxu631dY7zqL",
   "metadata": {
    "id": "jxu631dY7zqL"
   },
   "outputs": [],
   "source": [
    "#model.predict([X_test])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "c0aeef60",
   "metadata": {
    "id": "c0aeef60"
   },
   "outputs": [],
   "source": [
    "# Function to generate accuracy report\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import ConfusionMatrixDisplay\n",
    "from sklearn.metrics import accuracy_score, f1_score\n",
    "\n",
    "def accuracy_report(X_val_seq,y_val_seq):\n",
    "    # Calculate preditions for the validation dataset\n",
    "\n",
    "    y_pred = []  # store predicted labels\n",
    "    y_true = []  # store true labels\n",
    "\n",
    "    y_pred = model.predict([X_val_seq])\n",
    "    y_pred = np.argmax(y_pred, axis=1)\n",
    "    #len(y_pred)\n",
    "\n",
    "    y_true= y_val_seq\n",
    "    #len(y_true)\n",
    "\n",
    "    # Convert the true and predicted labels into arrays\n",
    "    true_categories = label_tokenizer.inverse_transform(y_true)\n",
    "    predicted_categories = label_tokenizer.inverse_transform(y_pred)\n",
    "    # print(predicted_categories)\n",
    "\n",
    "    # Generate confusion matrix\n",
    "\n",
    "    cnf_matrix = confusion_matrix(true_categories,predicted_categories,  normalize='pred')\n",
    "\n",
    "    # Plot confusion matrix\n",
    "    disp = ConfusionMatrixDisplay(confusion_matrix=cnf_matrix,display_labels=label_index)\n",
    "    disp = disp.plot(cmap='Greens', xticks_rotation=45)\n",
    "    plt.show()\n",
    "\n",
    "    print(\"Accuracy for validation split: \" ,accuracy_score(y_true, y_pred))\n",
    "    print( \"F1_score: \" + str(f1_score(y_true, y_pred, average='micro')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "environmental-transcription",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 395
    },
    "id": "environmental-transcription",
    "outputId": "49e3eb49-f538-4adf-fa43-0bcb7c22b1f1"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for validation split:  0.8942\n",
      "F1_score: 0.8942\n"
     ]
    }
   ],
   "source": [
    "# accuracy_report for same books\n",
    "\n",
    "accuracy_report(X_val,y_val_sequences)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "fundamental-raising",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 395
    },
    "id": "fundamental-raising",
    "outputId": "6a7b45f3-245a-4819-9c64-50f60a84434f"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for validation split:  0.6545\n",
      "F1_score: 0.6545\n"
     ]
    }
   ],
   "source": [
    "# accuracy_report for seperate books\n",
    "\n",
    "accuracy_report(X_val_2,y_val_sequences_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "CPLiRurgZed_",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CPLiRurgZed_",
    "outputId": "a1541df3-9574-47c2-8a5e-a189f2e15365"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"nlp_DistilBert_18\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_ids (InputLayer)      [(None, 100)]             0         \n",
      "                                                                 \n",
      " distilbert (TFDistilBertMai  TFBaseModelOutput(last_h  66362880 \n",
      " nLayer)                     idden_state=(None, 100,             \n",
      "                             768),                               \n",
      "                              hidden_states=None, att            \n",
      "                             entions=None)                       \n",
      "                                                                 \n",
      " pooled_output (Dropout)     (None, 100, 768)          0         \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 76800)             0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 5)                 384005    \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 66,746,885\n",
      "Trainable params: 66,746,885\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "electoral-arrangement",
   "metadata": {
    "id": "electoral-arrangement"
   },
   "outputs": [],
   "source": [
    "# Saving final model for future use\n",
    "\n",
    "#model.save(\"bert_5.h5\", save_format='h5')\n",
    "#tensorflow.keras.models.save_model(model,model._name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "mk7Mp05XdxxU",
   "metadata": {
    "id": "mk7Mp05XdxxU"
   },
   "outputs": [],
   "source": [
    "#!tar czf bert_epoch5_adamw_compress.tar.gz bert_epoch5_adamw/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "VqWmI63N5AIy",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "VqWmI63N5AIy",
    "outputId": "3509d45a-0369-476c-b67a-f660f1c69582"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fri Feb 25 08:37:23 2022       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 496.13       Driver Version: 496.13       CUDA Version: 11.5     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name            TCC/WDDM | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                               |                      |               MIG M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  NVIDIA GeForce ... WDDM  | 00000000:0D:00.0  On |                  N/A |\n",
      "| 78%   70C    P2   121W / 170W |  10874MiB / 12288MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "|    0   N/A  N/A      1604    C+G   Insufficient Permissions        N/A      |\n",
      "|    0   N/A  N/A      5204    C+G   C:\\Windows\\explorer.exe         N/A      |\n",
      "|    0   N/A  N/A      5748      C   ...onda3\\envs\\tf2\\python.exe    N/A      |\n",
      "|    0   N/A  N/A      6308    C+G   ...2txyewy\\TextInputHost.exe    N/A      |\n",
      "|    0   N/A  N/A      7460    C+G   ...y\\ShellExperienceHost.exe    N/A      |\n",
      "|    0   N/A  N/A      7488    C+G   ...5n1h2txyewy\\SearchApp.exe    N/A      |\n",
      "|    0   N/A  N/A      7616    C+G   Insufficient Permissions        N/A      |\n",
      "|    0   N/A  N/A      9452    C+G   ...zilla Firefox\\firefox.exe    N/A      |\n",
      "|    0   N/A  N/A     13036    C+G   ... Download Manager\\fdm.exe    N/A      |\n",
      "|    0   N/A  N/A     13108    C+G   ...zilla Firefox\\firefox.exe    N/A      |\n",
      "|    0   N/A  N/A     13168      C   ...onda3\\envs\\tf2\\python.exe    N/A      |\n",
      "|    0   N/A  N/A     14216    C+G   ...5.0.3.0\\GoogleDriveFS.exe    N/A      |\n",
      "|    0   N/A  N/A     15260    C+G   ...enTabletDriver.UX.Wpf.exe    N/A      |\n",
      "|    0   N/A  N/A     15884    C+G   ...in7x64\\steamwebhelper.exe    N/A      |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "nZzulGEJnDSz",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nZzulGEJnDSz",
    "outputId": "46f769f1-cf9b-4d78-a359-cff1732a6c41"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Skipping full serialization of Keras layer <keras.layers.core.dropout.Dropout object at 0x00000245AFEA7D90>, because it is not built.\n",
      "WARNING:tensorflow:Skipping full serialization of Keras layer <keras.layers.core.dropout.Dropout object at 0x00000245C262D4C0>, because it is not built.\n",
      "WARNING:tensorflow:Skipping full serialization of Keras layer <keras.layers.core.dropout.Dropout object at 0x00000245B02F8BE0>, because it is not built.\n",
      "WARNING:tensorflow:Skipping full serialization of Keras layer <keras.layers.core.dropout.Dropout object at 0x00000245C2639340>, because it is not built.\n",
      "WARNING:tensorflow:Skipping full serialization of Keras layer <keras.layers.core.dropout.Dropout object at 0x00000245C2647A60>, because it is not built.\n",
      "WARNING:tensorflow:Skipping full serialization of Keras layer <keras.layers.core.dropout.Dropout object at 0x00000245CA6A71C0>, because it is not built.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as embeddings_layer_call_fn, embeddings_layer_call_and_return_conditional_losses, transformer_layer_call_fn, transformer_layer_call_and_return_conditional_losses, add_layer_call_fn while saving (showing 5 of 166). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: nlp_DistilBert_18\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: nlp_DistilBert_18\\assets\n"
     ]
    }
   ],
   "source": [
    "model.save(model._name, include_optimizer=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "JOr9fAJytC2a",
   "metadata": {
    "id": "JOr9fAJytC2a"
   },
   "outputs": [],
   "source": [
    "#!tar czf bert_no_optimizer.tar.gz bert_no_optimizer/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "X-QjGeq3qDFd",
   "metadata": {
    "id": "X-QjGeq3qDFd"
   },
   "outputs": [],
   "source": [
    "# Reloading model\n",
    "\n",
    "#reloaded_model = tensorflow.saved_model.load(\"bert_no_optimizer\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "qYa60UyQ1QA1",
   "metadata": {
    "id": "qYa60UyQ1QA1"
   },
   "outputs": [],
   "source": [
    "# Comparing results of model in memory and reloaded model\n",
    "\n",
    "#text_string = X_val.iloc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "ET2pOYH82gR7",
   "metadata": {
    "id": "ET2pOYH82gR7"
   },
   "outputs": [],
   "source": [
    "# Correct result\n",
    "\n",
    "#y_val.iloc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "C_aCtz1YwjOW",
   "metadata": {
    "id": "C_aCtz1YwjOW"
   },
   "outputs": [],
   "source": [
    "#model_result = model(tensorflow.constant([text_string]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "WS-j-7At1NfE",
   "metadata": {
    "id": "WS-j-7At1NfE"
   },
   "outputs": [],
   "source": [
    "#reloaded_model_result = reloaded_model(tensorflow.constant([text_string]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "0FRxvPjP1ttd",
   "metadata": {
    "id": "0FRxvPjP1ttd"
   },
   "outputs": [],
   "source": [
    "# Result from model in memory\n",
    "\n",
    "#label_index[np.argmax(model_result, axis=1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "wpirJtoY1uA8",
   "metadata": {
    "id": "wpirJtoY1uA8"
   },
   "outputs": [],
   "source": [
    "# Result from reloaded model\n",
    "\n",
    "#label_index[np.argmax(reloaded_model_result, axis=1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54On8BXI-Fwx",
   "metadata": {
    "id": "54On8BXI-Fwx"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "keras_hf_DistilBERT.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3.9 (Tensorflow 2.6)",
   "language": "python",
   "name": "tf2"
  },
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}