22_downsample_cust.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8816b366-5be4-4748-b769-4dc6f7d1735f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modify the file 00_setup.py to define input/output file paths on your system\n",
    "# The information in 00_setup.py will be used across notebooks\n",
    "from importlib.machinery import SourceFileLoader\n",
    "setup = SourceFileLoader(\"setup\", \"./00_setup.py\").load_module()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a945de0c-f042-46b2-9d06-ab064af6c05b",
   "metadata": {},
   "source": [
    "## NN, Downsample train, NAICS only, Data Generator Randomize\n",
    "In the downsampled data, use the custom data generator to inject 20% random cases for each batch.  This is to help the model learn to handle unseen codes.  But downsample the training data to examine the "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e6fba8f-d564-466c-8e50-7773b095157f",
   "metadata": {},
   "source": [
    "Use only the base NAICS in the model. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32221be3-556a-441d-a30c-1f22f5dd664f",
   "metadata": {},
   "source": [
    "Custom data generators are used to retrieve data at each batch or epoch, and can be used to modify data for every batch or epoch.  In future scripts, I modify at the batch level, injecting random \"1\" values.   See also  https://www.tensorflow.org/versions/r2.1/api_docs/python/tf/keras/utils/Sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e169c2e8-ba0f-488f-acf6-87d419bd4e99",
   "metadata": {},
   "source": [
    "Use the dataset with no missing values. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d47a7ec9-7d7b-47df-a902-b2f1e54f1135",
   "metadata": {},
   "source": [
    "*This script takes about 15 minutes on my MacBook Air*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fb42f9b4-99a8-4753-aacf-8722469be4c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bf51170a-4487-4d10-b63d-c88f41b529f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "import importlib, pickle\n",
    "from sklearn import model_selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "09dd973b-60a0-434b-9193-8c5fcec27dd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import re\n",
    "\n",
    "import keras\n",
    "from tensorflow.keras import layers, optimizers, losses, metrics, Model\n",
    "from sklearn import preprocessing, feature_extraction, model_selection\n",
    "from IPython.display import display, HTML\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5dedd82d-1901-4327-8b7f-f00026a84f18",
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.callbacks import EarlyStopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9f1e4f2e-0e45-4e28-8e9c-212e0bb51199",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sba_nn.sba_nn import sbnn_metrics, sbnn_model\n",
    "from sba_nn.sba_nn.sbnn_model import CatInjectGenerator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cbc00d2-bc83-42d9-83eb-65fcf306dccd",
   "metadata": {},
   "source": [
    "## Input Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e014cd31-0f8d-42e3-82f9-b529eec8a3cc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sba_loans = pd.read_parquet(Path(setup.temp_path).joinpath('20_DATA_downsamp_train.parquet'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8e65cb7c-792c-46ff-a530-0d5c64240d60",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(Path(setup.temp_path).joinpath('01_DATA_features.pkl'), 'rb') as fin:\n",
    "    imputer_features = pickle.load(fin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6f0ce28e-a80c-415b-b068-5c4d49370da8",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(Path(setup.temp_path).joinpath('01_DATA_naics_max_encodings.pkl'), 'rb') as fin:\n",
    "    naics_max_levels= pickle.load(fin)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d4116da-d689-478a-9c5d-a330f231e615",
   "metadata": {},
   "source": [
    "##### Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f98c6e41-38d0-4d5f-b821-e3837b8c2068",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['NoEmp', 'CreateJob', 'LowDoc', 'DisbursementGross', 'new_business', 'urban_flag', 'franchise_flag', 'missingindicator_LowDoc', 'missingindicator_new_business', 'missingindicator_urban_flag']\n"
     ]
    }
   ],
   "source": [
    "# Numeric features\n",
    "features_numeric = [f for f in imputer_features if 'NAICS' not in f]\n",
    "features_numeric_len = len(features_numeric)\n",
    "print(features_numeric)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a74fa386-4011-45ee-bdb5-d671db9ffa91",
   "metadata": {},
   "outputs": [],
   "source": [
    "# NAICS feature\n",
    "features_naics = ['NAICS']\n",
    "features_naics_max_levels  = [naics_max_levels[n] for n in features_naics]\n",
    "features_naics_emb_dim = [setup.nn_naics_embed_size_dict[n] for n in features_naics]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "867031ee-8b6e-424d-b497-8e19409ba1d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1170]\n",
      "[8]\n"
     ]
    }
   ],
   "source": [
    "print(features_naics_max_levels)\n",
    "print(features_naics_emb_dim)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b979396c-c822-4940-a292-6e07f1b54f58",
   "metadata": {},
   "source": [
    "##### Datasets for train, validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "43bca011-a59d-4496-9f03-87f4e350a253",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = sba_loans[['dset', 'LoanNr_ChkDgt'] + features_numeric + features_naics].set_index('LoanNr_ChkDgt').sort_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "aa162d01-ed73-4ae3-832e-4aeea09b70f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training X: (44684, 11), y:(44684,)\n"
     ]
    }
   ],
   "source": [
    "X_train = X[X['dset'] == 'train'].drop(columns='dset')\n",
    "y_train = sba_loans[sba_loans['dset'] == 'train'].set_index('LoanNr_ChkDgt').sort_index()['target']\n",
    "print(f'training X: {X_train.shape}, y:{y_train.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b32b5fd3-6f6e-4aec-8e20-0e2b71a4814c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val X: (95604, 11), y:(95604,)\n"
     ]
    }
   ],
   "source": [
    "X_val = X[X['dset'] == 'val'].drop(columns='dset')\n",
    "y_val = sba_loans[sba_loans['dset'] == 'val'].set_index('LoanNr_ChkDgt').sort_index()['target']\n",
    "print(f'val X: {X_val.shape}, y:{y_val.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "01b8ff96-159b-4283-b5fb-c4b5dbd277d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.20295855339718916\n"
     ]
    }
   ],
   "source": [
    "base_thresh = y_train.mean()\n",
    "print(base_thresh)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3db4ea1c-77b2-4721-b106-1e66fc502139",
   "metadata": {},
   "source": [
    "## Create, fit model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4d48ddfa-580c-4321-9917-0bd176b67d87",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-05-20 13:47:53.624760: I metal_plugin/src/device/metal_device.cc:1154] Metal device set to: Apple M1\n",
      "2024-05-20 13:47:53.624833: I metal_plugin/src/device/metal_device.cc:296] systemMemory: 16.00 GB\n",
      "2024-05-20 13:47:53.624849: I metal_plugin/src/device/metal_device.cc:313] maxCacheSize: 5.33 GB\n",
      "2024-05-20 13:47:53.624911: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:303] Could not identify NUMA node of platform GPU ID 0, defaulting to 0. Your kernel may not have been built with NUMA support.\n",
      "2024-05-20 13:47:53.624944: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:269] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 0 MB memory) -> physical PluggableDevice (device: 0, name: METAL, pci bus id: <undefined>)\n"
     ]
    }
   ],
   "source": [
    "this_model = sbnn_model.create_emb_model(features_numeric_len,\n",
    "                                         features_naics_max_levels,\n",
    "                                         features_naics_emb_dim,\n",
    "                                         naics_embedding_names = features_naics,\n",
    "                                         hidden_size = setup.nn_layer_sizes,\n",
    "                                         activation='tanh',\n",
    "                                         lr=setup.nn_learning_rate,\n",
    "                                         opt_func = setup.nn_optimizer,\n",
    "                                         dropout = setup.nn_dropout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "47036621-ef13-4957-997b-f8ef86016f7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
      "==================================================================================================\n",
      " input_naics_00 (InputLayer  [(None, 1)]                  0         []                            \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " emb_naics_00 (Embedding)    (None, 1, 8)                 9360      ['input_naics_00[0][0]']      \n",
      "                                                                                                  \n",
      " NAICS (Flatten)             (None, 8)                    0         ['emb_naics_00[0][0]']        \n",
      "                                                                                                  \n",
      " input_numeric (InputLayer)  [(None, 10)]                 0         []                            \n",
      "                                                                                                  \n",
      " input_concat (Concatenate)  (None, 18)                   0         ['NAICS[0][0]',               \n",
      "                                                                     'input_numeric[0][0]']       \n",
      "                                                                                                  \n",
      " layer_00 (Dense)            (None, 128)                  2432      ['input_concat[0][0]']        \n",
      "                                                                                                  \n",
      " dropout_00 (Dropout)        (None, 128)                  0         ['layer_00[0][0]']            \n",
      "                                                                                                  \n",
      " layer_01 (Dense)            (None, 64)                   8256      ['dropout_00[0][0]']          \n",
      "                                                                                                  \n",
      " dropout_01 (Dropout)        (None, 64)                   0         ['layer_01[0][0]']            \n",
      "                                                                                                  \n",
      " output (Dense)              (None, 1)                    65        ['dropout_01[0][0]']          \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 20113 (78.57 KB)\n",
      "Trainable params: 20113 (78.57 KB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "this_model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ed7408d-99ce-413e-aef8-23743b5601cd",
   "metadata": {},
   "source": [
    "##### Use data generator to inject 1 values into training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f1dfde86-af9b-4110-aae9-30f3d59404af",
   "metadata": {},
   "outputs": [],
   "source": [
    "generator = CatInjectGenerator(X_train, y_train,\n",
    "                               categorical_columns=features_naics,\n",
    "                               batch_size = setup.nn_batch_size,\n",
    "                               injection_rate = 0.2,\n",
    "                               injection_value = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "dceea363-56c3-4ef7-a0fa-f9ff3e6845a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "callback = keras.callbacks.EarlyStopping(patience=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fd9ebbdb-daae-45c7-bbe2-751f8c245c31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-05-20 13:47:54.638834: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1396/1397 [============================>.] - ETA: 0s - loss: 0.4826 - auc: 0.2904 - auc_1: 0.6559"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-05-20 13:48:25.460335: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1397/1397 [==============================] - 62s 43ms/step - loss: 0.4825 - auc: 0.2903 - auc_1: 0.6560 - val_loss: 0.4640 - val_auc: 0.3356 - val_auc_1: 0.7012\n",
      "Epoch 2/20\n",
      "1397/1397 [==============================] - 61s 43ms/step - loss: 0.4681 - auc: 0.3273 - auc_1: 0.6899 - val_loss: 0.4635 - val_auc: 0.3435 - val_auc_1: 0.7052\n",
      "Epoch 3/20\n",
      "1397/1397 [==============================] - 71s 51ms/step - loss: 0.4625 - auc: 0.3378 - auc_1: 0.7022 - val_loss: 0.4623 - val_auc: 0.3507 - val_auc_1: 0.7075\n",
      "Epoch 4/20\n",
      "1397/1397 [==============================] - 73s 52ms/step - loss: 0.4601 - auc: 0.3489 - auc_1: 0.7070 - val_loss: 0.4603 - val_auc: 0.3503 - val_auc_1: 0.7074\n",
      "Epoch 5/20\n",
      "1397/1397 [==============================] - 72s 51ms/step - loss: 0.4574 - auc: 0.3508 - auc_1: 0.7114 - val_loss: 0.4635 - val_auc: 0.3526 - val_auc_1: 0.7089\n",
      "Epoch 6/20\n",
      "1397/1397 [==============================] - 70s 50ms/step - loss: 0.4564 - auc: 0.3538 - auc_1: 0.7143 - val_loss: 0.4600 - val_auc: 0.3542 - val_auc_1: 0.7094\n",
      "Epoch 7/20\n",
      "1397/1397 [==============================] - 74s 53ms/step - loss: 0.4560 - auc: 0.3557 - auc_1: 0.7146 - val_loss: 0.4642 - val_auc: 0.3551 - val_auc_1: 0.7103\n",
      "Epoch 8/20\n",
      "1397/1397 [==============================] - 57s 41ms/step - loss: 0.4535 - auc: 0.3623 - auc_1: 0.7190 - val_loss: 0.4625 - val_auc: 0.3538 - val_auc_1: 0.7106\n",
      "Epoch 9/20\n",
      "1397/1397 [==============================] - 45s 33ms/step - loss: 0.4529 - auc: 0.3633 - auc_1: 0.7204 - val_loss: 0.4611 - val_auc: 0.3517 - val_auc_1: 0.7092\n"
     ]
    }
   ],
   "source": [
    "this_history = this_model.fit(generator,\n",
    "                              batch_size=setup.nn_batch_size,\n",
    "                              epochs = setup.nn_epochs,\n",
    "                              validation_data=([X_val[features_numeric]] + [X_val[f] for f in features_naics], \n",
    "                                               y_val),\n",
    "                              shuffle=True,\n",
    "                             callbacks=[callback])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "460c4b43-c673-4ee1-b070-d2d596ac4561",
   "metadata": {},
   "outputs": [],
   "source": [
    "this_history_df = sbnn_model.process_history(this_history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ad4783f2-8d0b-4850-a45a-3a4be8e63318",
   "metadata": {},
   "outputs": [],
   "source": [
    "this_history_df.to_csv(Path(setup.temp_path).joinpath('22_REPORT_fit_history.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "73e89efd-75a9-4b27-81a8-13e12d5482be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "this_history_df[['loss', 'val_loss']].plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2342a31f-4891-4834-851a-b90b8b729c3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAABXHklEQVR4nO3deXRU9f3/8Wdmksm+kD2BsC9hjxCIuFDUICLFqq3F1gpGu1gVtakbtYIWMWKrxQJCta6oX+mvxaXKIkZxRUAwAgphJ2zZgOzJJJm5vz8mCYQ1A0luMnk9zrmHzM29N+9LIPPKZ7tehmEYiIiIiLRhFrMLEBERETkbBRYRERFp8xRYREREpM1TYBEREZE2T4FFRERE2jwFFhEREWnzFFhERESkzVNgERERkTbP2+wCmoPT6eTgwYMEBwfj5eVldjkiIiLSBIZhUFpaSnx8PBbLmdtQPCKwHDx4kISEBLPLEBERkXOwb98+unTpcsZjPCKwBAcHA64bDgkJMbkaERERaYqSkhISEhIa3sfPxCMCS303UEhIiAKLiIhIO9OU4RwadCsiIiJtngKLiIiItHkKLCIiItLmecQYlqYwDIPa2locDofZpQhgtVrx9vbWNHQREWmSDhFYqqurOXToEBUVFWaXIscJCAggLi4Om81mdikiItLGeXxgcTqd7N69G6vVSnx8PDabTb/Vm8wwDKqrqykoKGD37t306dPnrAsGiYhIx+bxgaW6uhqn00lCQgIBAQFmlyN1/P398fHxYe/evVRXV+Pn52d2SSIi0oZ1mF9r9Rt826PviYiINJXeMURERKTNU2ARERGRNk+BRURERNo8BRYRERFp8zx+lpCIiIicXa3DSVFlDUfLqzlaUcPRimqKKqo5Ul5DUUU1tU6DR348wLT6OmRgMQyDyhpzVrz197G6tQ7M8uXLefzxx9m8eTNWq5VRo0bx7LPP0qtXL1atWsVll13G0aNHCQsLAyArK4sLLriA3bt30717dwC+/PJLHn74YdauXYuvry8jR47krbfeolOnTi1whyIiYraqGgdFdaHj+ABS/3FRRTVHKo77uLya0qraM17TZrXw5wn9TVvLrEMGlsoaBwOmrzDla//wl3EE2Jr+115eXk56ejpDhgyhrKyM6dOnc91115GVldWk87Oysrjiiiu49dZbefbZZ/H29uaTTz7RIwpERNoBwzAor3ZwtLz6WAA5MYQcFzrqj6moPvef8aH+PnQK8CEswEZ4oI2wAB861X3sNMBq0tqrHTKwtCc//elPG71+6aWXiIqK4ocffmjS+U899RTJyck899xzDfsGDhzYrDWKiMjZOZ0GpVW1dS0bjbtbjp7w8dHy+i6ZGqodznP6elaLV0Pw6FQXOjoF2AgL9CG8/uMAn7pQ4jom1N8Hb2vbHN7aIQOLv4+VH/4yzrSv7Y7t27czffp01qxZQ2FhIU6n6x9uTk5Ok1buzcrK4oYbbjinWkVE5Oyqa518ubOQ/JKq0weQulYQp3FuX8PmbSE8oHFrR/3HnQKPCyR1H4cF2Ajx86wHzHbIwOLl5eVWt4yZJk6cSLdu3XjhhReIj4/H6XQyaNAgqqurCQoKAlxNhvVqamoane/v79+q9YqIdBSGYfDBpkP8dUU2ew83/eG6Qb7eDWGjvoXjVK0dxwcQd8c/eqL28a7dQR0+fJjs7GxeeOEFLr30UgC++OKLhs9HRUUBcOjQoYYBtCeObRkyZAiZmZk89thjrVO0iEgHsHrnYZ5ctoXv9hcDEBlkY0iXsLpuF5+6oGFrNBakU4APoQE++Hq719IuLgosbVinTp2IiIjg+eefJy4ujpycHB566KGGz/fu3ZuEhAQeffRRZs2axbZt23j66acbXWPatGkMHjyYO+64g9tvvx2bzcYnn3zCDTfcQGRkZGvfkohIu5adW8rs5Vv5eGs+AIE2K7/7US9uu6QHgb56S21JbXNkjQCuhwO+9dZbrF+/nkGDBvGHP/yBv/71rw2f9/Hx4f/+7//YunUrQ4YMYfbs2Tz++OONrtG3b18+/PBDvvvuO0aOHMmoUaN499138fbWfywRkaY6VFzJA//5jvHPfsbHW/PxtngxeVQ3Pn3gMu6+oo/CSivwMo4fANFOlZSUEBoaSnFxMSEhIY0+V1VVxe7du+nRowd+fn4mVSinou+NiLR1xZU1LPx0Jy99sRt7rWvSw9WDY7l/XCI9IgNNrq79O9P794kUCUVERE5gr3Xw+tc5zP14O0UVrskMI3uEM218Ihd01aKbZlBgERERqeN0Gvxv40H+uiKb/UcrAegTHcSDVyVyRf/oDj9Tx0znNIZl/vz5dO/eHT8/P1JSUli7du1pj12yZAnJycmEhYURGBhIUlISixYtOum4LVu2cM011xAaGkpgYCAjRowgJyfnXMoTERFx25c7Crlm/hfc81YW+49WEhPiy+yfDmbZPZeSOiBGYcVkbrewLF68mPT0dBYuXEhKSgpz5sxh3LhxZGdnEx0dfdLx4eHhPPzwwyQmJmKz2Xj//fdJS0sjOjqaceNci7ft3LmTSy65hNtuu43HHnuMkJAQvv/+e41rEBGRFvfDwRKeXL6Vz7YVAK51Un4/phe3XtwDf5umILcVbg+6TUlJYcSIEcybNw8Ap9NJQkICU6dObTTl9kyGDRvGhAkTmDlzJgA33ngjPj4+p2x5aQoNum2f9L0RETMdKKrk6Q+zefvbAxgG+Fi9uCmlG1Mv701EkK/Z5XUI7gy6datLqLq6mvXr15OamnrsAhYLqamprF69+qznG4ZBZmYm2dnZjB49GnAFng8++IC+ffsybtw4oqOjSUlJ4Z133jntdex2OyUlJY02ERGRpiiuqOGJpVu47G+rWLLBFVYmDo0nM30Mj14zUGGljXIrsBQWFuJwOIiJiWm0PyYmhtzc3NOeV1xcTFBQEDabjQkTJjB37lzGjh0LQH5+PmVlZTz55JNcddVVfPjhh1x33XVcf/31fPrpp6e8XkZGBqGhoQ1bQkKCO7chIiIdUFWNg+c/28mlT33M85/torrWyaieEbx318XM/cUFdI04+/PZxDytMksoODiYrKwsysrKyMzMJD09nZ49ezJmzJiGh/n95Cc/4Q9/+AMASUlJfPXVVyxcuJAf/ehHJ11v2rRppKenN7wuKSlRaBERkVNyOA3e+fYAz6zcxoEi18yfxNhgHhyfyJi+URpM2064FVgiIyOxWq3k5eU12p+Xl0dsbOxpz7NYLPTu3RtwhZEtW7aQkZHBmDFjiIyMxNvbmwEDBjQ6p3///o2em3M8X19ffH3VZCciIqdnGAafbS/kyWVb2XLINXQgLtSP9LF9uX5YF6wWBZX2xK0uIZvNxvDhw8nMzGzY53Q6yczMZNSoUU2+jtPpxG63N1xzxIgRZGdnNzpm27ZtdOvWzZ3y5ATdu3dnzpw5ZpchItLqNh8o5lcvrmHKS2vZcqiEYD9vHhqfyCf3jeGG5ASFlXbI7S6h9PR0pkyZQnJyMiNHjmTOnDmUl5eTlpYGwOTJk+ncuTMZGRmAa7xJcnIyvXr1wm63s3TpUhYtWsSCBQsarnn//fczadIkRo8ezWWXXcby5cv53//+x6pVq5rnLkVEpEPYd6SCv32YzbtZBwGwWS1MHtWNOy/rTadAm8nVyflwO7BMmjSJgoICpk+fTm5uLklJSSxfvrxhIG5OTg4Wy7GGm/Lycu644w7279+Pv78/iYmJvP7660yaNKnhmOuuu46FCxeSkZHB3XffTb9+/fjvf//LJZdc0gy3KCIinu5oeTVzP97B61/vpdrhGht5bVI8f7yyHwnhGkzrEQwPUFxcbABGcXHxSZ+rrKw0fvjhB6OysvLYTqfTMOxl5mxOZ5Pu6Z///KcRFxdnOByORvuvueYaIy0tzdixY4dxzTXXGNHR0UZgYKCRnJxsrFy5stGx3bp1M/7+97836es9/fTTxqBBg4yAgACjS5cuxu9//3ujtLS04fMzZswwhg4d2uicv//970a3bt0a7XvxxReNAQMGGDabzYiNjTXuvPPO037NU35vRETcUFlda8z/ZLsxaPpyo9uD7xvdHnzf+NW/vjY27S8yuzRpgjO9f5+oYz5LqKYCnog352v/6SDYzv6EzxtuuIGpU6fyySefcMUVVwBw5MgRli9fztKlSykrK+Pqq69m1qxZ+Pr68tprrzFx4kSys7Pp2rWr22VZLBb+8Y9/0KNHD3bt2sUdd9zBAw88wHPPPdfkayxYsID09HSefPJJxo8fT3FxMV9++aXbtYiInI3DafDf9ft5ZuU2ckuqABgQF8JD4xMZ3TfK5OqkJXTMwNIOdOrUifHjx/Pmm282BJb//Oc/REZGctlll2GxWBg6dGjD8TNnzuTtt9/mvffe46677nL76917770NH3fv3p3HH3+c22+/3a3A8vjjj/PHP/6Re+65p2HfiBEj3K5FROR0DMPgk+x8nly2lW15ZQB0DvPnvnF9+cnQzlg0mNZjdczA4hPgaukw62s30U033cRvfvMbnnvuOXx9fXnjjTe48cYbsVgslJWV8eijj/LBBx9w6NAhamtrqaysPOcHRn700UdkZGSwdetWSkpKqK2tpaqqioqKCgICzl5zfn4+Bw8ebAhXIiLNLWtfERlLt7Bm9xEAQv19uOuy3tw8qht+Pnrmj6frmIHFy6tJ3TJmmzhxIoZh8MEHHzBixAg+//xz/v73vwNw3333sXLlSv72t7/Ru3dv/P39+dnPfkZ1dbXbX2fPnj38+Mc/5ve//z2zZs0iPDycL774gttuu43q6moCAgKwWCwYJzx2qqampuFjf3//87tZEZHT2FNYzl8/zOaDjYcAsHlbSLu4O3f8qDehAT4mVyetpWMGlnbCz8+P66+/njfeeIMdO3bQr18/hg0bBsCXX37JLbfcwnXXXQdAWVkZe/bsOaevs379epxOJ08//XTDDK9///vfjY6JiooiNzcXwzAaVoXMyspq+HxwcDDdu3cnMzOTyy677JzqEBE5XmGZnbmZ23ljTQ61TgMvL7j+gi6kX9mXzmH6JamjUWBp42666SZ+/OMf8/333/OrX/2qYX+fPn1YsmQJEydOxMvLi0ceeaThMQfu6t27NzU1NcydO5eJEyfy5ZdfsnDhwkbHjBkzhoKCAp566il+9rOfsXz5cpYtW9bo6ZqPPvoot99+O9HR0YwfP57S0lK+/PJLpk6dem43LyIdUkV1LS9+vpt/fraLMnstAD/qG8VD4xPpH3fmJ/qK53JrpVtpfZdffjnh4eFkZ2fzy1/+smH/M888Q6dOnbjooouYOHEi48aNa2h9cdfQoUN55plnmD17NoMGDeKNN95oWPivXv/+/XnuueeYP38+Q4cOZe3atdx3332NjpkyZQpz5szhueeeY+DAgfz4xz9m+/bt51STiHQ8tQ4nb67JYcxfV/H0ym2U2WsZ3DmUN3+dwqu3jlRY6eC8jBMHJrRDJSUlhIaGUlxc3Og3foCqqip2795Njx498PPzM6lCORV9b0QEXDN/Vv6Qx+zlW9lZUA5AQrg/913Zj4lD4jXzx4Od6f37ROoSEhER06zfe5SMpVv4Zu9RADoF+DD18j7cdGFXfL0180eOUWDpAN544w1+97vfnfJz3bp14/vvv2/likSko9tZUMZfl2ez/PtcAPx8LNx6cQ9uH9OLED/N/JGTKbB0ANdccw0pKSmn/JyPj34wiEjryS+t4tmPtvPWun04nAYWL7hheAJ/GNuX2FB1DcvpKbB0AMHBwQQHB5tdhoh0YGX2Wl74bBcvfL6LimoHAFckRvPg+ET6xujnk5xdhwksHjC22OPoeyLimQzDoKDUzs6CcnYVlrEzv5z3vjtAYZlrYcuhCWH8aXwiKT0jTK5U2hOPDyz1XR4VFRVajbWNqaioANQtJdJeVdU42F1Yzq6CcnYVlLGrsJydBWXsLiintG79lON1jwjg/nGJXD04tmEBSpGm8vjAYrVaCQsLIz8/H4CAgAD9RzGZYRhUVFSQn59PWFgYVqtmAoi0VYZhcKi4yhVKCsvYVeAKJbsKyjlYXMnpGkotXpAQHkDPyEB6RgUxqHMIEwbHY/PW8l9ybjw+sADExsYCNIQWaRvCwsIavjciYq5yey2761pIdta3mBSUs7uwnMoaxwlHG/hjJ44yEvwq6R9WQ+/Aarr6VxHvU06ktYxgZynWqiNQcQS2HYGttbA2BoLjjm0h9R/HQnA8BIS7nvUmcgodIrB4eXkRFxdHdHR0owf2iXl8fHzUsiLSyhxOg4NFlQ0tJLsKy9iVX0ZuwWGqywroRBnhXqWEUUqUVyl9vMoIp5RwnzLibBVEWssJM0oIcJTg7bQfu3BR3XY2Zblw6LvTf95qqwsvx4Wa4FgIiT8WaoJjwTfo/P4ipF3qEIGlntVq1ZukiHguwwB7CaVH8jh46ACFeYcoOpJLRVE+NaWH8ao8QohRQjhlXORVygSvUjpRis3LAb5nubajbjue1Qb+4RAQ4WodCQg/4XXEsdcWK5TlQclBKM2F0ro/Sw5B6SGoKARHNRTluLYzsQXXtc4cF2IaQk1d0AmKAW/befxlSlvToQKLiEi74XSCvdjVpVJxBCoOu7ZK18fO8iNUFudTXVoIFYfxthfhX1uMNw6CgX51WyNnGD5iePvh1RAwwk8OHKcKJLag5uvCqa12tcCU5p4cakoP1QWbXKgudW2FpVC47czXDIw6ucUmJK7x64AIsGhcTXugwCIi0pqcTtcbc1EOFO2Dor1QvA/KChrCCBVHXB8bp38CuwUIrNtOVG74UuIVTKVPGA7fTlgCI/ANiSKoUwwh4dFYAk9uAfGyBbTUHTeNtw3Curq2M7GXnhBqDh3b6kNN6SFw1kB5gWvL3XT661l86kJN7OnH1gTHgp8evGg2BRYRkebkdLjeTItyXEGkvoujfis54Or6aKJSw5+jRhBHCeaoEcxRglx/GkGUWkOwBUcR2CmaThExRMd0pnN8PN1jI4jz1OXtfYNdW2Sf0x/jdLoCX0OIOTHU1AWb8gJXsCne59rOxBZ0QmvNCWNrQuIgpItaa1qQAouIiDscNa7Q0dBCknNcONnrCivOk9cgOZ7hZcUeGE+BNZqd1eFsKg/hkCOMI0YwRQRxpC6QFBFMDd50DvOnZ1RgwxThPlGuP+NC/PQk41OxWCAw0rXFDj79cY6aunE1J4SaE1tw7CVQXQaHd7i20/H2h+hEiB4A0f3rtgGugKPZT+dNgUVE5Hi1dijef4oWkrqPSw+esasGcHUzhCVAaAKEdaUmJIE9teF8WxzCqnw/PjlopbKw8RtYoM1Kz6ggekYFMirS9WfPqEB6RAYSYNOP6hZh9YHQLq7tTOxlpxkwfEK3VG0lHPzWtR3PL/S4EHPcnwHhLXdvHkj/C0SkY6mprAske0/RQpLjegPiLI+NsPrWjbdwBRJXMOnWsK/KL4oNOcV8veswX+8+QtbaIqodjUNOdLAvF/aMIKVnOBf2jKBnZKAWtWyrfINcW0Sv0x/jdMCR3ZD/A+RvOfbn4R1QVQw5q13b8YJiTg4xUf1cXV5yEi/DAx7oUlJSQmhoKMXFxYSEaGCUSIdWXX4siBTnnNxCUt6EBSR9AhpaRxoFk7Burv2BUY3GKlRWO1i/9yhrdh/m612H+W5f8UkBJSbEFVDqt+4RWnW7Q6i1Q+H2xiEm/wdXYD6dsK7HhZiBrj8j+4D32eaetz/uvH+rhUVE2peqkuO6aurGjRzfQlJx+OzXsAUdF0a6nhBOurpmz5whTFRU17J+ryucrNl1hO/2F1HjaPy7X2yIH6N6RZDSw9WC0k0BpWPy9oXYQa7tePZSKMg+uUWmLO9YyN62/NjxXlaI6H1yi0x4D9caNx2AWlhEpO0xDFcQyd3k2vK+P/ZDvKro7Of7hUJo11O0kNSFE/9Obg2CLLfXsn7vUVcXz67DbNxfTK2z8Y/O+FC/htaTlJ7hdA1XQJFzUH4YCrac3CJTVXzq4739ILLvyWNkQru0i4G+amERkfaj1g4FW4+Fk/rNXnL6c/zDT+6mqQ8moQngH3ZeJZXZa/lmzxHW7D7C17sOs+kUAaVzmH/D+JNRPSPo0slfAUXOX2AEBF4C3S85ts8wXIN6GwJMfZjZ6hrom7vRtR3PFtx4plL9n0FRrXs/zUgtLCLSeiqOQN7mxsGkYOuppwFbba4fsrGDIWYQhPesCyYJzT4osbSqhm/qWlDW7DrCpgPFOE4IKF06+btaT+q6eBLCTV5oTcTpcLVENmqN2eJaAfh0U+sDIk8OMdGJrlZJE7jz/q3AIiLN78QunfrtdItz+YVB3BCIHeIKKLGDXc3c1pZZ/Ky0qoZv9hzr4tl8sOSkgJIQ7s+FPY518XTppIAi7URttWt20oktMkf3cNoZcCFdXAEmZsCxMBPZF3z8W7RUdQmJSOuprT5Nl85p+tzDurkCSdzQY+EkpHOL9reXVNWwbvexLp7NB4o5IZ/QLSKgofUkpWcEncNa9ge1SIvxtrmCR8yAxvury+sG+p7QIlN6EEr2u7YdK48d72VxtWwe3yLT72rTZiuphUVEmq7yKOSeqkun5uRjLT51XTrHtZrEDDzv8SVNUVzpCihf7zrMmt1H+P7gyQGle0RAQ+tJSo8I4hVQpKOqPOoaD9OoReZ71/7jWbzhT4ea9SnYamERkfNjGK4ZOSd16eSc+ni/sLpQckKXTjP+YDuT4ooa1u450tDF88OhEk78VaxHZCAX1g2STekRQWyoX6vUJtLm+XeCbqNcWz3DgLL8xjOVaipa7f/0qSiwiHR0tdVQmO0KJIc21k0j3nT6aZT1XTrHh5NWnkJZVFHNmt1HWLPLFVK25J4cUHpGBZLSI6IhpMSEKKCINJmXFwTHuLZel5ldDaDAItKxVBadMEtno6sp+LRdOonHBZMhrdalc6Kj5dUN40/W7D7C1lMElF5RgcfWQekRTrQCiohHOafAMn/+fP7617+Sm5vL0KFDmTt3LiNHjjzlsUuWLOGJJ55gx44d1NTU0KdPH/74xz9y8803Nxxzyy238OqrrzY6b9y4cSxfvvzEy4m4p/IorH/VtdiY1dc168Tb1zVl1mo7xcc+dcfZXE2fZzqnLa8uaRiuGTmNunQ2urp5TsUvtHGLSexgiOzXqs2/DqfB/qMV7CooZ2dBGbsKy9ldUM6uwjLySuwnHd8nOqhhHZSRPcKJDlZAEfFkbgeWxYsXk56ezsKFC0lJSWHOnDmMGzeO7OxsoqOjTzo+PDychx9+mMTERGw2G++//z5paWlER0czbty4huOuuuoqXn755YbXvr6e98wEaUVOB3y7CDL/0rSl2s+Fl9XNkHOm49w55xTnVxypWzzquHBy2i6drieHk9CEVuvSOVJeza66QLKroLzh45zDFSc9f+d4fWOCGsafjOwRTlSwfkaIdCRuzxJKSUlhxIgRzJs3DwCn00lCQgJTp07loYceatI1hg0bxoQJE5g5cybgamEpKirinXfeca/6OpolJI3krIFlD8ChLNfrqETodblrRVVH9bGtthoc9hM+rml8XG3dvvrj2pOTunTqZ+l0avEvXVXjIOdIBbsKythZ4AomuwtdwaSo4hTdT3V8vS30iAykZ1QgPSOD6BkVWPc6iFD/llmTRUTM02KzhKqrq1m/fj3Tpk1r2GexWEhNTWX16tVnONPFMAw+/vhjsrOzmT17dqPPrVq1iujoaDp16sTll1/O448/TkREhDvlSUdXmgsrZ8DGt1yvfUPhsmkw4tfNswCZYRwXXuqDzVlCzomBpynBqNE5p/o6pzjOJ7Bxi0nsYFdQa8EuHcMwyC2patRKsquuC+fA0cqTphEfr3OY/7EwUhdIekYFEh/qj8Wi5e1F5GRuBZbCwkIcDgcxMTGN9sfExLB169bTnldcXEznzp2x2+1YrVaee+45xo4d2/D5q666iuuvv54ePXqwc+dO/vSnPzF+/HhWr16N1XryOAG73Y7dfqxPu6TkDM8cEc9XWw1rFsCnT0F1GeAFF/wKrpjRvM/N8PJyBQATp/WZocxe2zCWZGddONldWM7uwnIqqh2nPS/Y19vVUhIVRM/IQHrUtZr0iAzE39aGx/+ISJvUKrOEgoODycrKoqysjMzMTNLT0+nZsydjxowB4MYbb2w4dvDgwQwZMoRevXqxatUqrrjiipOul5GRwWOPPdYapUtbt30lLH/ItQw1QJcRMH42dB5ubl3tTK3Dyf6jlewqLKtrJalrNSkoJ7/05AGv9awWL7qFBxzrxjkunEQF+ephgCLSbNwKLJGRkVitVvLy8hrtz8vLIzY29rTnWSwWevfuDUBSUhJbtmwhIyOjIbCcqGfPnkRGRrJjx45TBpZp06aRnp7e8LqkpISEhAR3bkXau8M7YcWfYFvdTLLAaBj7FxgyCSwWc2trowzDcA14rZt9s7M+nBSUkXOkghrH6ftwIoNsJ40p6RkVSNfwAHys+vsWkZbnVmCx2WwMHz6czMxMrr32WsA16DYzM5O77rqryddxOp2NunROtH//fg4fPkxcXNwpP+/r66tZRB2VvQw+/xusnu8a+2Hxhgt/D6MfAD8NuAbXgNe9hytOGleyq6Cc4kr3Brz2jHJ14WjAq4iYze0uofT0dKZMmUJycjIjR45kzpw5lJeXk5aWBsDkyZPp3LkzGRkZgKv7Jjk5mV69emG321m6dCmLFi1iwYIFAJSVlfHYY4/x05/+lNjYWHbu3MkDDzxA7969G017lg7OMGDTf2DlI1B6yLWv1xVw1ZMQ1dfc2ky2Ztdhlm3ObejGOVBUedKiasfTgFcRaY/cDiyTJk2ioKCA6dOnk5ubS1JSEsuXL28YiJuTk4PluCb58vJy7rjjDvbv34+/vz+JiYm8/vrrTJo0CQCr1crGjRt59dVXKSoqIj4+niuvvJKZM2eqFUVcDm10TVPOqZuJ1qk7jMuAfuNbdTn4tujNNTn8+Z1NJ83IOXHAa31LiQa8ikh7pac1S9tVcQQ+ngnrXwHDCT4BcOkfYdRd4NOxVzU1DIO5H+/gmZXbABg/KJbRfaMawklkkE0DXkWkzdPTmqV9c9TC+pfh48ddS+oDDPqZa1BtaGdTS2sLHE6Dx/73Pa+t3gvA3Zf35g9j+yqgiIhHU2CRtmXPF7DsQdcD+gBiBsH4p6D7xebW1UbYax2kL/6ODzYdwssLHp04kCkXdTe7LBGRFqfAIm1D8X748BH4fonrtX8nuPzPMOwWsOqfKUBpVQ2/W7Ser3Yexsfqxd8nJfHjIfFmlyUi0ir0TiDmqqmC1XPh82egpgK8LDA8zRVWAsLNrq7NKCi1c8vLa/n+YAmBNivPT07m4t6RZpclItJqFFjEHIYB2Uth+TQoco3FoOtFrlVq44aYW1sbs/dwOZNfWsvewxVEBtl4JW0kgzqHml2WiEirUmCR1lewzbWc/s5M1+vgeLhyJgz6aYefpnyizQeKueXldRSW2ekaHsBrt46ke2Sg2WWJiLQ6BRZpPVUl8OlsWLMQnLVgtbmmKF/6R/ANMru6NuernYX89rX1lNlr6R8Xwqu3jiA6uGNP5xaRjkuBRVqe0wnf/R989CiU57v29R0P42ZBRC9TS2urlm46xL1vZVHtcHJhz3Cen5xMiJ+WxxeRjkuBRVrWgfWw9AE48I3rdURv13L6fcaaW1cb9vrXe3nk3c0YhmtBuL9PSsLPR6vTikjHpsAiLaMsHzIfg29fd722BcGPHoCU34O3zdza2ijDMJjz0XaezdwOwE0pXfnLTwZh1fN9REQUWKSZOWpg7QuwKgPsJa59Q38BqY9CcKyppbVlDqfB9Hc388aaHADuTe3DPVf00eq1IiJ1FFik+ez8xLVKbWG263VcElz9V0gYaWpZbV1VjYN738pi+fe5eHnBzJ8M4lcXdjO7LBGRNkWBRc7f0T2w4mHY+r7rdUAEXDEDLvgVWDT24kxKqmr47Wvf8PWuI9isFubcmMTVg+PMLktEpM1RYJFzV10BX86BL5+F2irwssLI38KYB11L68sZ5ZdUMeXldWw5VEKQrzfPTx7ORb20eq2IyKkosIj7DAN+eAdW/BlK9rv29RjtekhhdH9TS2sv9hSWc/NLa9h3pJLIIF9eSRuh1WtFRM5AgUXck/e9a5zKns9dr0MTXOup9L9Gq9Q20ab9xdzy8loOl1fTLcK1em23CK1eKyJyJgos0jSVR+GTDFj3LzAc4O0HF98LF98DtgCzq2s3vtheyO8WfUN5tYOB8SG8kjaSqGBfs8sSEWnzFFjkzJwO2PAaZP4FKo+49vW/Bq58HDppJos73t94kD8szqLGYXBRrwj+efNwgrV6rYhIkyiwyOnlrIFl98Oh71yvoxJdq9T2uszcutqhV7/aw6P/+x7DgAmD43hm0lB8vTWDSkSkqRRY5GQlh+CjGbBxseu1byhcNg1G/BqsahFwh2EYPLNyG3M/3gHA5FHdmDFxoFavFRFxkwKLHFNrh68XwGd/heoywAuG3QyXT4egKLOra3dqHU7+/M5m3lq3D4A/ju3LXZf31uq1IiLnQIFFXLZ9CMsfgiM7Xa+7jIDxs6HzcHPraqeqahzc/X/f8uEPeVi8YNZ1g/nFyK5mlyUi0m4psHR0R3a7pilvX+F6HRgNY/8CQyaBxWJube1UcWUNv3n1G9buOYLN28I/bryAqwbpOUoiIudDgaWjctTC18/BJ09AbSVYvOHC38PoB8AvxOzq2q28kiqmvLSWrbmlBPt688KUZC7sGWF2WSIi7Z4CS0d0aCO8NxUOZbled78UJjwDUX1NLau921VQxuSX1rL/aCVRwb68mjaSAfEKfyIizUGBpSOpqYRPZ8OX/3At/uYXClfOcj2kUANBz8t3+4pIe2UdR8qr6R4RwKLbUkgI14J6IiLNRYGlo9jzBbx397FBtQN+4nr2T7DGVpyvz7cX8LtF66modjC4cygvp40gMkir14qINCcFFk9XWeRaU2X9K67XQbEw4Wno/2Mzq/IY72Yd4L7/9x01DoNLekey8ObhBPnqv5WISHPTT1ZPtuV9+OCPUJbrej08DVIfBf8wM6vyGC99sZu/vP8DABOHxvP0DUOxeWtmlYhIS1Bg8USlebD0Ptjynut1eC+45h/Q/RJz6/IQhmHw1xXZPLfK1b12y0Xdmf7jAVi0eq2ISItRYPEkhgHfLoIP/wxVxeBldT1N+UcPgI+/2dV5hFqHkz+9vYl/f7MfgPvH9eOOMb20eq2ISAtTYPEUh3fC+/fC7s9cr+OS4Jq5EDfEzKo8SmW1g6n/t4GPtuRj8YKM6wczaYRWrxURaQ0KLO2doxa+nl+3AFwVePvDZX+CC+8Aq769zaW4oobbXl3HN3uP4uttYd4vhzF2QIzZZYmIdBh6R2vPDm2E9+6CQ9+5XvcYDROfhfCe5tblYXKLq5j80hq25ZUR4ufNv6aMYGSPcLPLEhHpUBRY2qNTLQA37glIukkLwDWzHfllTHlpLQeKKokJ8eXVW0eSGKvVa0VEWts5zcGcP38+3bt3x8/Pj5SUFNauXXvaY5csWUJycjJhYWEEBgaSlJTEokWLTnv87bffjpeXF3PmzDmX0jzf7s9hwUXwxd9dYWXAtXDnOq1W2wK+zTnKDQu/4kBRJT0jA/nP7RcprIiImMTtFpbFixeTnp7OwoULSUlJYc6cOYwbN47s7Gyio6NPOj48PJyHH36YxMREbDYb77//PmlpaURHRzNu3LhGx7799tt8/fXXxMfHn/sdearKIlg5HTa86nodHOdaAC5xgqlleapV2fn8/vUNVNY4GNollJduGUGEVq8VETGN2y0szzzzDL/5zW9IS0tjwIABLFy4kICAAF566aVTHj9mzBiuu+46+vfvT69evbjnnnsYMmQIX3zxRaPjDhw4wNSpU3njjTfw8fE5t7vxVFv+B/NTjoWV4Wlw5xqFlRbyzrcH+PWr31BZ4+DSPpG8+ZsLFVZEREzmVmCprq5m/fr1pKamHruAxUJqaiqrV68+6/mGYZCZmUl2djajR49u2O90Orn55pu5//77GThwoDslebbSXFj8K9dWlgsRveGWpTBxjmvcijS7f32+i3sXZ1HrNPhJUjwvThlBoJbaFxExnVs/iQsLC3E4HMTENJ7OGRMTw9atW097XnFxMZ07d8Zut2O1WnnuuecYO3Zsw+dnz56Nt7c3d999d5PqsNvt2O32htclJSXu3Ebbd+ICcBZv1wJwox8AHz+zq/NIhmHw5PKt/PPTXQDcenEP/jyhv1avFRFpI1rlV8fg4GCysrIoKysjMzOT9PR0evbsyZgxY1i/fj3PPvssGzZsaPJqoRkZGTz22GMtXLVJDu+E/90Dez53vY5Lgp/Mg9jBppblyWocTh767yb+u8G1eu2DVyVy+496avVaEZE2xMswDKOpB1dXVxMQEMB//vMfrr322ob9U6ZMoaioiHfffbdJ1/n1r3/Nvn37WLFiBXPmzCE9PR2L5VjvlMPhwGKxkJCQwJ49e046/1QtLAkJCRQXFxMS0k5ncThqYfU8WJVxbAG4yx+GlN9rAbgWVFnt4M43N/Dx1nysFi8yrh/Mz5MTzC5LRKRDKCkpITQ0tEnv3269E9psNoYPH05mZmZDYHE6nWRmZnLXXXc1+TpOp7MhcNx8882NxsQAjBs3jptvvpm0tLRTnu/r64uvrwcNgjz0Hbx7F+RudL3uOQZ+PAfCe5hZlccrqqjm1lfWsSGnCD8fC/N/OYwr+mv1WhGRtsjtX93T09OZMmUKycnJjBw5kjlz5lBeXt4QLiZPnkznzp3JyMgAXN03ycnJ9OrVC7vdztKlS1m0aBELFiwAICIigoiIiEZfw8fHh9jYWPr163e+99e21VTCqifhq7l1C8CF1S0A90utqdLCDhZVMvmltezILyPU34eXbklmeDetXisi0la5HVgmTZpEQUEB06dPJzc3l6SkJJYvX94wEDcnJ6dR9055eTl33HEH+/fvx9/fn8TERF5//XUmTZrUfHfRHu3+HP53NxxxDfJkwLUw/ikI1m/4LW1Hfik3v7iWQ8VVxIb48dptI+kbE2x2WSIicgZujWFpq9zpAzNdZRGsfAQ2vOZ6rQXgWtX6vUe57dV1FFXU0CsqkNduS6FzmL/ZZYmIdEgtNoZFztOW/8EH97nWVAFIvhVSH9WaKq3k46153PHGBqpqnCQlhPHSLSMID7SZXZaIiDSBAktrKM2Fpfe5Agu4FoCb+A/ofrG5dXUg/12/nwf+uxGH02BMvyieu2kYATb98xcRaS/0E7slGYar6+fDR8BevwDcvTD6fi0A10oMw+D5z3aRscy1sOF1F3TmqZ8Nwcd6Ts/9FBERkyiwtJQTF4CLvwCumasF4FpRrcPJX97/gddW7wXgN5f2YNp4rV4rItIeKbA0N0ctrJ7rmq7csADcnyHldi0A14pKq2qY+n/fsiq7AC8v+NP4/vxmdE+zyxIRkXOkd9DmdDAL3puqBeBMdrCokltfWcfW3FL8fCzMmZTEVYPizC5LRETOgwJLc6iugE+fhK/maQE4k23cX8Rtr35DQamdqGBf/jU5maEJYWaXJSIi50mB5Xzt/gzeuxuO7na9Hng9jJ8NQdHm1tUBrfg+l3ve+paqGif9YoJ5KW2E1lgREfEQCiznqvIorJx+3AJw8XULwF1tbl0dkGEY/Ovz3TyxbAuGAaP7RjH/lxcQ7OdjdmkiItJMFFjOxQ/vwtL7oSzP9Tr5NkidoQXgTFDjcDLjve95c00OAL+6sCuPThyIt6Yti4h4FAUWd5Qcci0At/V91+uIPnDNP6DbRebW1UGVVNVw5xsb+Hx7IV5e8PDV/bntkh54adyQiIjHUWBpCsOADa/Ch9O1AFwbse9IBbe9uo5teWX4+1h59sYkrhwYa3ZZIiLSQhRYzuakBeCG1S0AN8jcujqwrH1F/PrVdRSWVRMd7MuLU0YwuIu640REPJkCy5kc+g5evNK1AJxPwLEF4CxWsyvrsJZuOsQfFmdhr3XSPy6El25JJi5UM4FERDydAsuZxAyGuKGusDJxDnTqbnZFHZZhGCz8dBezl7ueCXR5YjT/+MUFBPnqn7CISEegn/ZnYrHAL//tmv2jgZymqXE4+fPbm1n8zT4AbrmoO3+e0F8zgUREOhAFlrPxDzO7gg6tuLKG37++nq92HsbiBdN/PIBbLtajDkREOhoFFmmzcg5XkPbKWnYWlBNoszL3lxdweWKM2WWJiIgJFFikTVq/9yi/fe0bDpdXExvix0u3jGBAfIjZZYmIiEkUWKTN+d93B/nj//uO6longzqH8OKUEcSEaL0bEZGOTIFF2gzDMJj/yQ7+9uE2AFL7x/CPXyQRYNM/UxGRjk7vBNImVNc6mbZkE//dsB+AX1/Sg2lX98dq0ewsERFRYJE2oKiimt8tWs+a3UewWrx49JqB3HxhN7PLEhGRNkSBRUy1p7CcW19Zx67CcoJ8vZn3ywsY0y/a7LJERKSNUWAR06zbc4TfvvYNRytq6Bzmz4u3JJMYq5lAIiJyMgUWMcU73x7ggf9spNrhZGiXUF6Ykkx0sGYCiYjIqSmwSKsyDIM5H23n2cztAFw1MJa/T0rC36YHSoqIyOkpsEirsdc6ePA/G3kn6yAAvxvdkwevSsSimUAiInIWCizSKo6UV/O7Rd+wbs9RrBYvHr92EL8Y2dXsskREpJ1QYJEWt7OgjFtfWcfewxUE+3qz4FfDuaRPpNlliYhIO6LAIi1q9c7D3P76eoora+jSyZ+XbxlBn5hgs8sSEZF2RoFFWsx/1u9n2pKN1DgMkhLCeGFyMlHBvmaXJSIi7ZACizQ7p9PgmZXbmPfJDgAmDI7j6Z8Pxc9HM4FEROTcKLBIs6qqcXDf//uO9zceAuDOy3rxx7H9NBNIRETOiwKLNJvDZXZ+89o3bMgpwtvixRPXD+bnyQlmlyUiIh5AgUWaxY78UtJeWce+I5WE+Hmz8ObhXNRLM4FERKR5WM7lpPnz59O9e3f8/PxISUlh7dq1pz12yZIlJCcnExYWRmBgIElJSSxatKjRMY8++iiJiYkEBgbSqVMnUlNTWbNmzbmUJib4ckch1z33FfuOVNI1PIAld1yssCIiIs3K7cCyePFi0tPTmTFjBhs2bGDo0KGMGzeO/Pz8Ux4fHh7Oww8/zOrVq9m4cSNpaWmkpaWxYsWKhmP69u3LvHnz2LRpE1988QXdu3fnyiuvpKCg4NzvTFrF4nU5THlpLaVVtQzv1om377iI3tFBZpclIiIexsswDMOdE1JSUhgxYgTz5s0DwOl0kpCQwNSpU3nooYeadI1hw4YxYcIEZs6cecrPl5SUEBoaykcffcQVV1xx1uvVH19cXExIiJ722xqcToOnVmSz8NOdAFwzNJ6nfjZEM4FERKTJ3Hn/dquFpbq6mvXr15OamnrsAhYLqamprF69+qznG4ZBZmYm2dnZjB49+rRf4/nnnyc0NJShQ4ee8hi73U5JSUmjTVpPZbWDO9/c0BBW7r6iD8/emKSwIiIiLcatQbeFhYU4HA5iYmIa7Y+JiWHr1q2nPa+4uJjOnTtjt9uxWq0899xzjB07ttEx77//PjfeeCMVFRXExcWxcuVKIiNPPQ4iIyODxx57zJ3SpZnkl1bxm9fW892+InysXsz+6RCuH9bF7LJERMTDndOgW3cFBweTlZXFunXrmDVrFunp6axatarRMZdddhlZWVl89dVXXHXVVfz85z8/7biYadOmUVxc3LDt27evFe5CsnNLuW7+V3y3r4iwAB9evy1FYUVERFqFWy0skZGRWK1W8vLyGu3Py8sjNjb2tOdZLBZ69+4NQFJSElu2bCEjI4MxY8Y0HBMYGEjv3r3p3bs3F154IX369OHFF19k2rRpJ13P19cXX18t8d6aPttWwJ1vbKDUXkuPyEBeumUEPSIDzS5LREQ6CLdaWGw2G8OHDyczM7Nhn9PpJDMzk1GjRjX5Ok6nE7vdft7HSOt4Y81e0l5ZR6m9lpE9wlny+4sUVkREpFW5vXBceno6U6ZMITk5mZEjRzJnzhzKy8tJS0sDYPLkyXTu3JmMjAzANd4kOTmZXr16YbfbWbp0KYsWLWLBggUAlJeXM2vWLK655hri4uIoLCxk/vz5HDhwgBtuuKEZb1Xc5XAaPLlsCy98vhuA6y/oTMZPB+PrrcG1IiLSutwOLJMmTaKgoIDp06eTm5tLUlISy5cvbxiIm5OTg8VyrOGmvLycO+64g/379+Pv709iYiKvv/46kyZNAsBqtbJ161ZeffVVCgsLiYiIYMSIEXz++ecMHDiwmW5T3FVRXcu9b2Xx4Q+u7r/0sX2ZenlvvLz0TCAREWl9bq/D0hZpHZbmlVdSxa9f/YZNB4qxWS389YYh/CSps9lliYiIh3Hn/VvPEpJGfjhYwm2vruNQcRXhgTaev3k4yd3DzS5LREQ6OAUWafDJ1nzuenMD5dUOekYF8vItI+gWocG1IiJiPgUWAeC11Xt49L3vcRowqmcEC381nNAAH7PLEhERARRYOjyH02Dm+z/wyld7ALhheBdmXTcYm3errCkoIiLSJAosHdwzK7Mbwsr94/pxx5hemgkkIiJtjgJLB+ZwGixetx+AJ64bzC9TuppckYiIyKmp3b8D+2bPEQrL7IT4efOz4XomkIiItF0KLB3Y0k2HALhyYKzGrIiISJumd6kOyuk0WLY5F4CrB5/+wZUiIiJtgQJLB7U+5yj5pXaC/by5pHeU2eWIiIickQJLB/XBRld30NgBMeoOEhGRNk/vVB2Q02mwvL47aFCcydWIiIicnQJLB/TtvqPkllQR5OvNpX0jzS5HRETkrBRYOqAPNrpaV1L7R+PrbTW5GhERkbNTYOlgXLODXONXrh6s7iAREWkfFFg6mKz9RRwqriLQZmV0X80OEhGR9kGBpYNZVrdY3BX9Y/DzUXeQiIi0DwosHYhhGCzdVL9YnLqDRESk/VBg6UA27i/mQFElATYrY/qpO0hERNoPBZYOpP7ZQZcnRqs7SERE2hUFlg7CMAw+2KTZQSIi0j4psHQQmw+UsP9oJf4+Vi7rF212OSIiIm5RYOkgPjiuO8jfpu4gERFpXxRYOgDDOLZY3PjBsSZXIyIi4j4Flg7g+4Ml7D1cgZ+PRd1BIiLSLimwdAD1s4PG9I0m0Nfb5GpERETcp8Di4VyLxdXNDhqi2UEiItI+KbB4uC2HStlzuAJfbwuXJ6o7SERE2icFFg9XP9j2R32jCFJ3kIiItFMKLB7s+MXiJqg7SERE2jEFFg+WnVfKroJybOoOEhGRdk6BxYPVP5l5dJ8ogv18TK5GRETk3CmweLClDd1BWixORETaNwUWD7U9r5Qd+WXYrBau6B9jdjkiIiLnRYHFQ9UPtr20TyQh6g4SEZF27pwCy/z58+nevTt+fn6kpKSwdu3a0x67ZMkSkpOTCQsLIzAwkKSkJBYtWtTw+ZqaGh588EEGDx5MYGAg8fHxTJ48mYMHD55LaVKnvjto/GDNDhIRkfbP7cCyePFi0tPTmTFjBhs2bGDo0KGMGzeO/Pz8Ux4fHh7Oww8/zOrVq9m4cSNpaWmkpaWxYsUKACoqKtiwYQOPPPIIGzZsYMmSJWRnZ3PNNdec3511YDvyS9mWV4aP1YuxA9QdJCIi7Z+XYRiGOyekpKQwYsQI5s2bB4DT6SQhIYGpU6fy0EMPNekaw4YNY8KECcycOfOUn1+3bh0jR45k7969dO3a9azXKykpITQ0lOLiYkJCQpp+Mx7qH5nbeWblNi7rF8XLaSPNLkdEROSU3Hn/dquFpbq6mvXr15OamnrsAhYLqamprF69+qznG4ZBZmYm2dnZjB49+rTHFRcX4+XlRVhY2Ck/b7fbKSkpabTJMeoOEhERT+NWYCksLMThcBAT07ibISYmhtzc3NOeV1xcTFBQEDabjQkTJjB37lzGjh17ymOrqqp48MEH+cUvfnHatJWRkUFoaGjDlpCQ4M5teLRdBWVszS3F2+LFleoOEhERD9Eqs4SCg4PJyspi3bp1zJo1i/T0dFatWnXScTU1Nfz85z/HMAwWLFhw2utNmzaN4uLihm3fvn0tWH37Ut+6clHvSMICbCZXIyIi0jzcehpeZGQkVquVvLy8Rvvz8vKIjT394mQWi4XevXsDkJSUxJYtW8jIyGDMmDENx9SHlb179/Lxxx+fsS/L19cXX19fd0rvMOpXt50wWIvFiYiI53CrhcVmszF8+HAyMzMb9jmdTjIzMxk1alSTr+N0OrHb7Q2v68PK9u3b+eijj4iIiHCnLKmzp7CcHw6VYLV4ceUABRYREfEcbrWwAKSnpzNlyhSSk5MZOXIkc+bMoby8nLS0NAAmT55M586dycjIAFzjTZKTk+nVqxd2u52lS5eyaNGihi6fmpoafvazn7Fhwwbef/99HA5Hw3iY8PBwbDZ1azTV0s113UG9IugUqL83ERHxHG4HlkmTJlFQUMD06dPJzc0lKSmJ5cuXNwzEzcnJwWI51nBTXl7OHXfcwf79+/H39ycxMZHXX3+dSZMmAXDgwAHee+89wNVddLxPPvmkUbeRnFn9+JWrNTtIREQ8jNvrsLRFWocFcg5XMPqvn2C1eLH2T1cQEaQxPiIi0ra12Dos0nbVdwdd2DNcYUVERDyOAouHUHeQiIh4MgUWD7DvSAUb9xdj8YJxAzU7SEREPI8CiwdYVtcdlNIjgkh1B4mIiAdSYPEA9YvFXa3F4kRExEMpsLRzB4oqydpXhJcXjBukwCIiIp5JgaWdW1Y32HZk93Cig/1MrkZERKRlKLC0c5odJCIiHYECSzt2sKiSDTmu7qCr1B0kIiIeTIGlHVu+2TXYNrlbJ2JC1B0kIiKeS4GlHVN3kIiIdBQKLO1UbnEV3+w9CsD4QQosIiLi2RRY2qnldYvFDe/WidhQdQeJiIhnU2Bpp44tFqfWFRER8XwKLO1QfkkV6/YeAWC8ZgeJiEgHoMDSDi3/PhfDgAu6hhEf5m92OSIiIi1OgaUd+mCja/zKBHUHiYhIB6HA0s4UlNpZu8fVHaTF4kREpKNQYGln6ruDhiaE0aVTgNnliIiItAoFlnam/mGHV6t1RUREOhAFlnaksMzO17sOA5rOLCIiHYsCSzuy4vtcnAYM7hxKQri6g0REpONQYGlHlmmxOBER6aAUWNqJI+XVrG7oDtL4FRER6VgUWNqJD7/PxeE0GBgfQreIQLPLERERaVUKLO3EB/Wzg9QdJCIiHZACSztwtLyar3ZqdpCIiHRcCiztwMof8nA4DfrHhdAjUt1BIiLS8SiwtAP13UETNNhWREQ6KAWWNq64ooYvdxQCMF7dQSIi0kEpsLRxH/6QS63TIDE2mF5RQWaXIyIiYgoFljZu2WbXYnHjB6l1RUREOi4FljasuLKGz7cXADBhiMaviIhIx6XA0oZ99EMeNQ6DvjFB9I4ONrscERER0yiwtGHLNrtmB6k7SEREOrpzCizz58+ne/fu+Pn5kZKSwtq1a0977JIlS0hOTiYsLIzAwECSkpJYtGjRScdceeWVRERE4OXlRVZW1rmU5VFKqmr4bJtrdtCEIQosIiLSsbkdWBYvXkx6ejozZsxgw4YNDB06lHHjxpGfn3/K48PDw3n44YdZvXo1GzduJC0tjbS0NFasWNFwTHl5OZdccgmzZ88+9zvxMB9vyafa4aRXVCB9ojU7SEREOjYvwzAMd05ISUlhxIgRzJs3DwCn00lCQgJTp07loYceatI1hg0bxoQJE5g5c2aj/Xv27KFHjx58++23JCUlNbmmkpISQkNDKS4uJiQkpMnntWW/ee0bVv6Qx92X9yb9yn5mlyMiItLs3Hn/dquFpbq6mvXr15OamnrsAhYLqamprF69+qznG4ZBZmYm2dnZjB492p0v3YjdbqekpKTR5klKq2r4dJtrdtDV6g4SERFxL7AUFhbicDiIiYlptD8mJobc3NzTnldcXExQUBA2m40JEyYwd+5cxo4de24VAxkZGYSGhjZsCQkJ53yttujjrflU1zrpGRlIvxjNDhIREWmVWULBwcFkZWWxbt06Zs2aRXp6OqtWrTrn602bNo3i4uKGbd++fc1XbBuwtO7ZQVcPjsPLy8vkakRERMzn7c7BkZGRWK1W8vLyGu3Py8sjNvb0C5tZLBZ69+4NQFJSElu2bCEjI4MxY8a4XzHg6+uLr6/vOZ3b1pXba1mV7eoOGq+HHYqIiAButrDYbDaGDx9OZmZmwz6n00lmZiajRo1q8nWcTid2u92dL91hfLw1H3utk+4RAQyI84wBxCIiIufLrRYWgPT0dKZMmUJycjIjR45kzpw5lJeXk5aWBsDkyZPp3LkzGRkZgGu8SXJyMr169cJut7N06VIWLVrEggULGq555MgRcnJyOHjwIADZ2dkAxMbGnrHlxhOpO0hERORkbgeWSZMmUVBQwPTp08nNzSUpKYnly5c3DMTNycnBYjnWcFNeXs4dd9zB/v378ff3JzExkddff51JkyY1HPPee+81BB6AG2+8EYAZM2bw6KOPnuu9tTsV1bV8ku1az+bqwZodJCIiUs/tdVjaIk9Zh+WDjYe4880NdA0P4NP7x6iFRUREPFqLrcMiLWtp/bODBscqrIiIiBxHgaWNqKx28PEWV3fQBHUHiYiINKLA0kasys6nssZBl07+DO4canY5IiIibYoCSxuxdLNrpWDNDhIRETmZAksbUFXjIHOLazE+zQ4SERE5mQJLG/DptgIqqh10DvNnaBd1B4mIiJxIgaUNqF8sbvwgzQ4SERE5FQUWk7m6g+oWixui7iAREZFTUWAx2efbCymz1xIX6kdSlzCzyxEREWmTFFhMdqw7KA6LRd1BIiIip6LAYiJ7rYOPfqifHdSxHvIoIiLiDgUWE32xvZBSey2xIX4M69rJ7HJERETaLAUWEy3d5Fos7qpBseoOEhEROQMFFpNU1zpZ+cOx1W1FRETk9BRYTPLljkJKqmqJDvYluZu6g0RERM5EgcUk9bOD1B0kIiJydgosJqhxOPnwBz07SEREpKkUWEzw1c7DFFfWEBnky4ju4WaXIyIi0uYpsJhg6cb67qAYrOoOEhEROSsFllZW43CyQrODRERE3KLA0sq+3nWYoooaIgJtjFR3kIiISJMosLSy+tlB4wbF4m3VX7+IiEhT6B2zFdU6nKz4vm520CB1B4mIiDSVAksrWrP7CEfKqwkPtHFhT3UHiYiINJUCSyv6oL47aGCMuoNERETcoHfNVuJwGqzY7JodNF7dQSIiIm5RYGkla3Yf5nB5NWEBPozqFWF2OSIiIu2KAksrWbbJ1bpy5YAYfNQdJCIi4ha9c7YCh9Ng2WYtFiciInKuFFhawbo9RygssxPq78PFvSPNLkdERKTdUWBpBcvqZgeNVXeQiIjIOdG7ZwtzHtcdNEHdQSIiIudEgaWFrc85Sn6pnWA/b3UHiYiInCMFlhb2wcZj3UE2b/11i4iInAu9g7YgV3eQK7CoO0hEROTcnVNgmT9/Pt27d8fPz4+UlBTWrl172mOXLFlCcnIyYWFhBAYGkpSUxKJFixodYxgG06dPJy4uDn9/f1JTU9m+ffu5lNamfLvvKHkldoJ9vbmkj7qDREREzpXbgWXx4sWkp6czY8YMNmzYwNChQxk3bhz5+fmnPD48PJyHH36Y1atXs3HjRtLS0khLS2PFihUNxzz11FP84x//YOHChaxZs4bAwEDGjRtHVVXVud9ZG/DBRtdg29QBMfh6W02uRkREpP3yMgzDcOeElJQURowYwbx58wBwOp0kJCQwdepUHnrooSZdY9iwYUyYMIGZM2diGAbx8fH88Y9/5L777gOguLiYmJgYXnnlFW688cazXq+kpITQ0FCKi4sJCQlx53ZajNNpcPHsjzlUXMXzNw/nyoGxZpckIiLSprjz/u1WC0t1dTXr168nNTX12AUsFlJTU1m9evVZzzcMg8zMTLKzsxk9ejQAu3fvJjc3t9E1Q0NDSUlJOe017XY7JSUljba2Jmt/EYeKqwjy9WZ03yizyxEREWnX3AoshYWFOBwOYmJiGu2PiYkhNzf3tOcVFxcTFBSEzWZjwoQJzJ07l7FjxwI0nOfONTMyMggNDW3YEhIS3LmNVrG0bnbQFf2j8fNRd5CIiMj5aJVZQsHBwWRlZbFu3TpmzZpFeno6q1atOufrTZs2jeLi4oZt3759zVdsMzCMY4vFjR+k2UEiIiLny9udgyMjI7FareTl5TXan5eXR2zs6cdoWCwWevfuDUBSUhJbtmwhIyODMWPGNJyXl5dHXNyxN/e8vDySkpJOeT1fX198fX3dKb1Vfbe/mANFlQTYrIzpp+4gERGR8+VWC4vNZmP48OFkZmY27HM6nWRmZjJq1KgmX8fpdGK32wHo0aMHsbGxja5ZUlLCmjVr3LpmW1L/7KDLE9UdJCIi0hzcamEBSE9PZ8qUKSQnJzNy5EjmzJlDeXk5aWlpAEyePJnOnTuTkZEBuMabJCcn06tXL+x2O0uXLmXRokUsWLAAAC8vL+69914ef/xx+vTpQ48ePXjkkUeIj4/n2muvbb47bSWGYfDBJi0WJyIi0pzcDiyTJk2ioKCA6dOnk5ubS1JSEsuXL28YNJuTk4PFcqzhpry8nDvuuIP9+/fj7+9PYmIir7/+OpMmTWo45oEHHqC8vJzf/va3FBUVcckll7B8+XL8/Pya4RZb1+YDJew/Wom/j5Ux/aLNLkdERMQjuL0OS1vUltZheXLZVhZ+upMJg+OYf9MwU2sRERFpy1psHRY5M8MwWFrXHXS1uoNERESajQJLM/r+YAk5Ryrw87FwWaJmB4mIiDQXBZZmVN+6clm/aAJsbg8PEhERkdNQYGkm6g4SERFpOQoszWTLoVL2HK7A19vC5YmaHSQiItKcFFiaSX3ryph+UQT6qjtIRESkOSmwNAN1B4mIiLQsBZZmkJ1Xyq7CcmzeFq7oH3P2E0RERMQtCizNYOkm15OZf9Q3iiB1B4mIiDQ7BZZmcKw76PRPrBYREZFzp8BynrbllbIjvwybVd1BIiIiLUWB5TzVt65c2ieSED8fk6sRERHxTAos50mzg0RERFqeAst52JFfyra8MnysXqQOUHeQiIhIS1FgOQ/1s4Mu6R1JqL+6g0RERFqKAst5UHeQiIhI61BgOUc7C8rYmluKt8WLseoOEhERaVEKLOdoWV3rysW9IwkLsJlcjYiIiGdTYDlH9eNXJqg7SEREpMUpsJyDPYXl/HCoBKu6g0RERFqFAss5+KCuO+iiXhF0ClR3kIiISEtTYDkHyzZrdpCIiEhrUmBxU87hCjYfcHUHjRuohx2KiIi0BgUWNy2ta125sGc44eoOEhERaRUKLG7SYnEiIiKtT4HFDfuOVLBxfzEWL9QdJCIi0ooUWNxQP9g2pUcEkUG+JlcjIiLScSiwuOGDusXirh6i7iAREZHWpMDSRPuPVvDdviK8vGDcQC0WJyIi0poUWJpo+WZX68rI7uFEB/uZXI2IiEjHosDSRPWzgyaoO0hERKTVKbA0wcGiSjbkuLqDrtLsIBERkVanwNIEy+q6g0Z0Cyc6RN1BIiIirU2BpQmW1XUHjR+s1hUREREzKLCcRW5xFd/sPQrA+EEavyIiImKGcwos8+fPp3v37vj5+ZGSksLatWtPe+wLL7zApZdeSqdOnejUqROpqaknHZ+Xl8ctt9xCfHw8AQEBXHXVVWzfvv1cSmt2y+sWi0vu1onYUHUHiYiImMHtwLJ48WLS09OZMWMGGzZsYOjQoYwbN478/PxTHr9q1Sp+8Ytf8Mknn7B69WoSEhK48sorOXDgAACGYXDttdeya9cu3n33Xb799lu6detGamoq5eXl53d3zWBp3WJx4/XsIBEREdN4GYZhuHNCSkoKI0aMYN68eQA4nU4SEhKYOnUqDz300FnPdzgcdOrUiXnz5jF58mS2bdtGv3792Lx5MwMHDmy4ZmxsLE888QS//vWvz3rNkpISQkNDKS4uJiQkxJ3bOaP8kipSMjIxDPjqocuJD/NvtmuLiIh0dO68f7vVwlJdXc369etJTU09dgGLhdTUVFavXt2ka1RUVFBTU0N4eDgAdrsdAD+/Y90tFosFX19fvvjii1New263U1JS0mhrCf42K49fO4hbLuqusCIiImIitwJLYWEhDoeDmJjGS9PHxMSQm5vbpGs8+OCDxMfHN4SexMREunbtyrRp0zh69CjV1dXMnj2b/fv3c+jQoVNeIyMjg9DQ0IYtISHBndtosmA/H25K6caj1wxskeuLiIhI07TqLKEnn3ySt956i7fffruhRcXHx4clS5awbds2wsPDCQgI4JNPPmH8+PFYLKcub9q0aRQXFzds+/bta83bEBERkVbm7c7BkZGRWK1W8vLyGu3Py8sjNvbMa5T87W9/48knn+Sjjz5iyJAhjT43fPhwsrKyKC4uprq6mqioKFJSUkhOTj7ltXx9ffH19XWndBEREWnH3GphsdlsDB8+nMzMzIZ9TqeTzMxMRo0addrznnrqKWbOnMny5ctPG0IAQkNDiYqKYvv27XzzzTf85Cc/cac8ERER8VButbAApKenM2XKFJKTkxk5ciRz5syhvLyctLQ0ACZPnkznzp3JyMgAYPbs2UyfPp0333yT7t27N4x1CQoKIigoCID/9//+H1FRUXTt2pVNmzZxzz33cO2113LllVc2132KiIhIO+Z2YJk0aRIFBQVMnz6d3NxckpKSWL58ecNA3JycnEZjTxYsWEB1dTU/+9nPGl1nxowZPProowAcOnSI9PR08vLyiIuLY/LkyTzyyCPncVsiIiLiSdxeh6Utaql1WERERKTltNg6LCIiIiJmUGARERGRNk+BRURERNo8BRYRERFp8xRYREREpM1TYBEREZE2T4FFRERE2jy3F45ri+qXkikpKTG5EhEREWmq+vftpiwJ5xGBpbS0FICEhASTKxERERF3lZaWEhoaesZjPGKlW6fTycGDBwkODsbLy6tZr11SUkJCQgL79u3zyFV0Pf3+wPPvUffX/nn6PXr6/YHn32NL3Z9hGJSWlhIfH9/osT6n4hEtLBaLhS5durTo1wgJCfHIf4T1PP3+wPPvUffX/nn6PXr6/YHn32NL3N/ZWlbqadCtiIiItHkKLCIiItLmKbCcha+vLzNmzMDX19fsUlqEp98feP496v7aP0+/R0+/P/D8e2wL9+cRg25FRETEs6mFRURERNo8BRYRERFp8xRYREREpM1TYBEREZE2T4HlLObPn0/37t3x8/MjJSWFtWvXml1Ss/nss8+YOHEi8fHxeHl58c4775hdUrPJyMhgxIgRBAcHEx0dzbXXXkt2drbZZTWrBQsWMGTIkIaFnEaNGsWyZcvMLqvFPPnkk3h5eXHvvfeaXUqzefTRR/Hy8mq0JSYmml1Wszpw4AC/+tWviIiIwN/fn8GDB/PNN9+YXVaz6N69+0nfPy8vL+68806zS2sWDoeDRx55hB49euDv70+vXr2YOXNmk5770xIUWM5g8eLFpKenM2PGDDZs2MDQoUMZN24c+fn5ZpfWLMrLyxk6dCjz5883u5Rm9+mnn3LnnXfy9ddfs3LlSmpqarjyyispLy83u7Rm06VLF5588knWr1/PN998w+WXX85PfvITvv/+e7NLa3br1q3jn//8J0OGDDG7lGY3cOBADh061LB98cUXZpfUbI4ePcrFF1+Mj48Py5Yt44cffuDpp5+mU6dOZpfWLNatW9foe7dy5UoAbrjhBpMrax6zZ89mwYIFzJs3jy1btjB79myeeuop5s6da05BhpzWyJEjjTvvvLPhtcPhMOLj442MjAwTq2oZgPH222+bXUaLyc/PNwDj008/NbuUFtWpUyfjX//6l9llNKvS0lKjT58+xsqVK40f/ehHxj333GN2Sc1mxowZxtChQ80uo8U8+OCDxiWXXGJ2Ga3mnnvuMXr16mU4nU6zS2kWEyZMMG699dZG+66//nrjpptuMqUetbCcRnV1NevXryc1NbVhn8ViITU1ldWrV5tYmZyL4uJiAMLDw02upGU4HA7eeustysvLGTVqlNnlNKs777yTCRMmNPq/6Em2b99OfHw8PXv25KabbiInJ8fskprNe++9R3JyMjfccAPR0dFccMEFvPDCC2aX1SKqq6t5/fXXufXWW5v9Ibxmueiii8jMzGTbtm0AfPfdd3zxxReMHz/elHo84uGHLaGwsBCHw0FMTEyj/TExMWzdutWkquRcOJ1O7r33Xi6++GIGDRpkdjnNatOmTYwaNYqqqiqCgoJ4++23GTBggNllNZu33nqLDRs2sG7dOrNLaREpKSm88sor9OvXj0OHDvHYY49x6aWXsnnzZoKDg80u77zt2rWLBQsWkJ6ezp/+9CfWrVvH3Xffjc1mY8qUKWaX16zeeecdioqKuOWWW8wupdk89NBDlJSUkJiYiNVqxeFwMGvWLG666SZT6lFgEY935513snnzZo8aG1CvX79+ZGVlUVxczH/+8x+mTJnCp59+6hGhZd++fdxzzz2sXLkSPz8/s8tpEcf/pjpkyBBSUlLo1q0b//73v7nttttMrKx5OJ1OkpOTeeKJJwC44IIL2Lx5MwsXLvS4wPLiiy8yfvx44uPjzS6l2fz73//mjTfe4M0332TgwIFkZWVx7733Eh8fb8r3T4HlNCIjI7FareTl5TXan5eXR2xsrElVibvuuusu3n//fT777DO6dOlidjnNzmaz0bt3bwCGDx/OunXrePbZZ/nnP/9pcmXnb/369eTn5zNs2LCGfQ6Hg88++4x58+Zht9uxWq0mVtj8wsLC6Nu3Lzt27DC7lGYRFxd3Unju378///3vf02qqGXs3buXjz76iCVLlphdSrO6//77eeihh7jxxhsBGDx4MHv37iUjI8OUwKIxLKdhs9kYPnw4mZmZDfucTieZmZkeN0bAExmGwV133cXbb7/Nxx9/TI8ePcwuqVU4nU7sdrvZZTSLK664gk2bNpGVldWwJScnc9NNN5GVleVxYQWgrKyMnTt3EhcXZ3YpzeLiiy8+aTmBbdu20a1bN5Mqahkvv/wy0dHRTJgwwexSmlVFRQUWS+OYYLVacTqdptSjFpYzSE9PZ8qUKSQnJzNy5EjmzJlDeXk5aWlpZpfWLMrKyhr9Jrd7926ysrIIDw+na9euJlZ2/u68807efPNN3n33XYKDg8nNzQUgNDQUf39/k6trHtOmTWP8+PF07dqV0tJS3nzzTVatWsWKFSvMLq1ZBAcHnzTmKDAwkIiICI8Zi3TfffcxceJEunXrxsGDB5kxYwZWq5Vf/OIXZpfWLP7whz9w0UUX8cQTT/Dzn/+ctWvX8vzzz/P888+bXVqzcTqdvPzyy0yZMgVvb896S504cSKzZs2ia9euDBw4kG+//ZZnnnmGW2+91ZyCTJmb1I7MnTvX6Nq1q2Gz2YyRI0caX3/9tdklNZtPPvnEAE7apkyZYnZp5+1U9wUYL7/8stmlNZtbb73V6Natm2Gz2YyoqCjjiiuuMD788EOzy2pRnjatedKkSUZcXJxhs9mMzp07G5MmTTJ27NhhdlnN6n//+58xaNAgw9fX10hMTDSef/55s0tqVitWrDAAIzs72+xSml1JSYlxzz33GF27djX8/PyMnj17Gg8//LBht9tNqcfLMExask5ERESkiTSGRURERNo8BRYRERFp8xRYREREpM1TYBEREZE2T4FFRERE2jwFFhEREWnzFFhERESkzVNgERERkTZPgUVERETaPAUWERERafMUWERERKTNU2ARERGRNu//A7rZqqkav4FYAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "this_history_df[['auc', 'val_auc']].plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "cee80637-cabf-4974-b476-08c5fba165ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "this_history_df[['auc_roc', 'val_auc_roc']].plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e184b0ca-1d31-4798-88a0-4e590b67062e",
   "metadata": {},
   "outputs": [],
   "source": [
    "this_model.save(Path(setup.temp_path).joinpath('22_DATA_model.keras'),save_format='tf')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d326c9ea-4759-4418-a64d-56c151049c25",
   "metadata": {},
   "source": [
    "## Predictions on all data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "cd6910ee-5ffe-4def-9aa8-7dba76446b08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  75/9167 [..............................] - ETA: 18s"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-05-20 13:57:40.192202: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9167/9167 [==============================] - 20s 2ms/step\n"
     ]
    }
   ],
   "source": [
    "all_predictions = this_model.predict([X[features_numeric]]+ [X[f] for f in features_naics])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "98a2cce1-b7d3-4ebc-8869-80705297e145",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_predictions_df = pd.DataFrame(all_predictions, index=X.index) \\\n",
    "    .set_axis(['predict_prob'], axis=1) \\\n",
    "    .reset_index() \\\n",
    "    .merge(sba_loans[['target', 'LoanNr_ChkDgt', 'dset', 'dset_naics_holdout', 'NAICS']], \n",
    "           on='LoanNr_ChkDgt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "3fc7da9c-6bd2-4d1b-b77f-b62679825d5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>predict_prob</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>predict_prob</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.296102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>target</th>\n",
       "      <td>0.296102</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              predict_prob    target\n",
       "predict_prob      1.000000  0.296102\n",
       "target            0.296102  1.000000"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_predictions_df[['predict_prob', 'target']].corr(method='spearman')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e79afc4e-cb67-4064-9b19-dc52500baef2",
   "metadata": {},
   "source": [
    "##### Threshold Tune & Binary Predictions\n",
    "Using training probability predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ccd0bc23-fbc0-40d0-8d8b-f2302405a875",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_pred_train = all_predictions_df[all_predictions_df['dset'] == 'train']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "df36d9e9-f35e-46b3-a5be-08081f998319",
   "metadata": {},
   "outputs": [],
   "source": [
    "thresh_tune_data = sbnn_metrics.get_f1_frame(all_pred_train['target'], \n",
    "                                        all_pred_train['predict_prob'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "de634156-caf6-4a52-b5d7-44b8e986aa1d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>thresh</th>\n",
       "      <th>f1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>0.24</td>\n",
       "      <td>0.458146</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>0.26</td>\n",
       "      <td>0.457759</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0.22</td>\n",
       "      <td>0.457019</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    thresh        f1\n",
       "12    0.24  0.458146\n",
       "13    0.26  0.457759\n",
       "11    0.22  0.457019"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "thresh_tune_data.sort_values('f1', ascending=False, inplace=True)\n",
    "thresh_tune_data.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "c746b880-d781-4bc1-9df2-89211127c22a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.24"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_thresh = thresh_tune_data['thresh'].iloc[0]\n",
    "best_thresh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c0ac5e2-be0d-42f0-960d-1f81b4a5d4e2",
   "metadata": {},
   "source": [
    "##### Append binary predictions to probability predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "641da72e-1bca-4fe7-96c4-6c029b521bd7",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_predictions_df['predict_bin'] = sbnn_metrics.get_binary_predictions(all_predictions_df['predict_prob'], best_thresh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "9f6ecdf4-ac01-4c39-8315-e8583daa337e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "predict_bin\n",
       "0    0.541321\n",
       "1    0.458679\n",
       "Name: proportion, dtype: float64"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_predictions_df['predict_bin'].value_counts(normalize=True, dropna=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "cbfed830-7ff8-40f6-a691-6b894b26d6bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_predictions_df.to_parquet(Path(setup.temp_path).joinpath('22_DATA_predictions.parquet'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb0ecbd2-abff-46d8-8c70-f7bccd363b69",
   "metadata": {},
   "source": [
    "## Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "be4ceefe-c7a8-45bd-8573-2daefe99a1c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>dset</th>\n",
       "      <th>accuracy_score</th>\n",
       "      <th>f1_score</th>\n",
       "      <th>precision_score</th>\n",
       "      <th>recall_score</th>\n",
       "      <th>average_precision_score</th>\n",
       "      <th>roc_auc_score</th>\n",
       "      <th>dset_naics_holdout</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>test</td>\n",
       "      <td>0.623295</td>\n",
       "      <td>0.432662</td>\n",
       "      <td>0.310728</td>\n",
       "      <td>0.712102</td>\n",
       "      <td>0.343205</td>\n",
       "      <td>0.706757</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>train</td>\n",
       "      <td>0.644213</td>\n",
       "      <td>0.458146</td>\n",
       "      <td>0.331557</td>\n",
       "      <td>0.741096</td>\n",
       "      <td>0.392524</td>\n",
       "      <td>0.740170</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>val</td>\n",
       "      <td>0.628164</td>\n",
       "      <td>0.435847</td>\n",
       "      <td>0.315490</td>\n",
       "      <td>0.704675</td>\n",
       "      <td>0.351842</td>\n",
       "      <td>0.709251</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>test</td>\n",
       "      <td>0.628149</td>\n",
       "      <td>0.433710</td>\n",
       "      <td>0.314017</td>\n",
       "      <td>0.700850</td>\n",
       "      <td>0.349950</td>\n",
       "      <td>0.706464</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>test</td>\n",
       "      <td>0.615227</td>\n",
       "      <td>0.430971</td>\n",
       "      <td>0.305529</td>\n",
       "      <td>0.731169</td>\n",
       "      <td>0.339131</td>\n",
       "      <td>0.710802</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    dset  accuracy_score  f1_score  precision_score  recall_score  \\\n",
       "0   test        0.623295  0.432662         0.310728      0.712102   \n",
       "1  train        0.644213  0.458146         0.331557      0.741096   \n",
       "2    val        0.628164  0.435847         0.315490      0.704675   \n",
       "0   test        0.628149  0.433710         0.314017      0.700850   \n",
       "1   test        0.615227  0.430971         0.305529      0.731169   \n",
       "\n",
       "   average_precision_score  roc_auc_score  dset_naics_holdout  \n",
       "0                 0.343205       0.706757                 NaN  \n",
       "1                 0.392524       0.740170                 NaN  \n",
       "2                 0.351842       0.709251                 NaN  \n",
       "0                 0.349950       0.706464                 0.0  \n",
       "1                 0.339131       0.710802                 1.0  "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics_dset_df = all_predictions_df.groupby('dset') \\\n",
    "    .apply(lambda x: sbnn_metrics.dset_metrics(x.target, x.predict_bin, x.predict_prob)) \\\n",
    "    .reset_index()\n",
    "metrics_test_df = all_predictions_df[all_predictions_df['dset'] == 'test'] \\\n",
    "    .groupby(['dset', 'dset_naics_holdout']) \\\n",
    "    .apply(lambda x: sbnn_metrics.dset_metrics(x.target, x.predict_bin, x.predict_prob)) \\\n",
    "    .reset_index()\n",
    "metrics_df = pd.concat([metrics_dset_df, metrics_test_df])\n",
    "metrics_df.to_csv(Path(setup.temp_path).joinpath('22_REPORT_metrics.csv'), index=True)\n",
    "metrics_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52e382b5-e9dc-47a1-9bf4-6d0b6b4a0c61",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf_p39",
   "language": "python",
   "name": "tf_p39"
  },
  "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.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}