diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4c590e9df..7c759cb2a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,11 +1,19 @@
# Changelog
+# Version 2.7b0+mea (2021-06-27)
+## Fix
+* Update `AnnotationGroup` to expect labelId to be a cuid instead of uuid.
+* Update `datarow_miou` to support masks with multiple classes in them.
+
+
+# Version 2.7.0 (2021-06-27)
+## Added
+* Added `dataset.export_data_rows()` which returns all `DataRows` for a `Dataset`.
# Version 2.6b2+mea (2021-06-16)
## Added
* `ModelRun.annotation_groups()` to fetch data rows and label information for a model run
-
# Version 2.6.0 (2021-06-11)
## Fix
* Upated `create_mask_ndjson` helper function in `image_mal.ipynb` to use the color arg
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 3bf52ce7a..5533aa06e 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -21,7 +21,7 @@
copyright = '2021, Labelbox'
author = 'Labelbox'
-release = '2.5.6'
+release = '2.6.0'
# -- General configuration ---------------------------------------------------
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 4bf477382..7182df876 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -14,6 +14,13 @@ Client
:exclude-members: upload_data, upload_file
:show-inheritance:
+AssetAttachment
+--------------------------------------
+
+.. automodule:: labelbox.schema.asset_attachment
+ :members:
+ :show-inheritance:
+
AssetMetadata
--------------------------------------
diff --git a/examples/integrations/tlt/README.md b/examples/integrations/tlt/README.md
new file mode 100644
index 000000000..593c4e6d9
--- /dev/null
+++ b/examples/integrations/tlt/README.md
@@ -0,0 +1,20 @@
+# NVIDIA + Labelbox
+
+##### Turn any Labelbox bounding box project into a deployed service by following these tutorials
+
+--------
+
+
+#### labelbox_upload.ipynb
+* Download images and prelabels
+* Setup a labelbox project
+* Upload prelabels to labelbox using MAL
+* Clean up the data in labelbox
+
+#### detectnet_v2_bounding_box.ipynb
+* Plug in training data from previous step (or bring your own labelbox project)
+* Train a model using TLT. Compare with a non-pretrained model
+* Prune the model for more efficient deployment
+* Convert the model to a TRT engine
+* Deploy the model using Triton Inference Server
+
diff --git a/examples/integrations/tlt/detectnet_v2_bounding_box.ipynb b/examples/integrations/tlt/detectnet_v2_bounding_box.ipynb
new file mode 100755
index 000000000..4672411fc
--- /dev/null
+++ b/examples/integrations/tlt/detectnet_v2_bounding_box.ipynb
@@ -0,0 +1,1688 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# NVIDIA + Labelbox\n",
+ "\n",
+ "### Learn how to train and deploy a bounding box model using Labelbox, TLT, TRT, and Triton Inference Server\n",
+ "\n",
+ "* Based on https://ngc.nvidia.com/catalog/resources/nvidia:tlt_cv_samples/version/v1.0.2/files/detectnet_v2/detectnet_v2.ipynb\n",
+ "\n",
+ "##### Turn any labelbox bounding box project into a deployed service by following this notebook"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Contents:\n",
+ " 1. Configure environment\n",
+ " * Setup environment\n",
+ " * Install dependencies\n",
+ " 2. ETL\n",
+ " * Export data from labelbox and convert into tfrecords\n",
+ " 3. Train\n",
+ " * Create a trained model\n",
+ " 4. Prune and Retrain\n",
+ " 5. Evaluate\n",
+ " * Compute metrics\n",
+ " * Visualize\n",
+ " 6. Deploy\n",
+ " * Deploy tensorrt server\n",
+ " * Client code to test server\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "##### Requirements:\n",
+ "\n",
+ "* python >=3.6.9 < 3.8.x\n",
+ "* docker-ce > 19.03.5\n",
+ "* docker-API 1.40\n",
+ "* nvidia-container-toolkit > 1.3.0-1\n",
+ "* nvidia-container-runtime > 3.4.0-1\n",
+ "* nvidia-docker2 > 2.5.0-1\n",
+ "* nvidia-driver > 455+\n",
+ "* \\>= 1 nvidia gpu"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Configure environment"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import json\n",
+ "import shutil"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Set these for your data\n",
+ "\n",
+ "* This is the only cell that needs to be updated\n",
+ "* Everything else in the notebook is dynamically configured based on these params"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Which classes to grab from a project.\n",
+ "#The model will ignore classes not listed here.\n",
+ "class_mappings = {\n",
+ " 'animal' : 'animal',\n",
+ " 'person' : 'person'\n",
+ "}\n",
+ "\n",
+ "#grab this from the url of your project.\n",
+ "#You can also search using the sdk\n",
+ "LABELBOX_PROJECT_ID = \"ckq778m4g0edr0yao004l41l7\"\n",
+ "#If you are using your own bbox project, set this to true\n",
+ "USE_RANDOM_PARTITIONING = False \n",
+ "#Format of your labelbox data\n",
+ "IMAGE_FORMAT = \".jpg\" \n",
+ "#TLT Does not support dynamic resizing.\n",
+ "#Image must be resized prior to training (and labels must be scaled accordingly)\n",
+ "#This code in this notebook will handle this, but the desired size must be set here.\n",
+ "IMAGE_W = 1024 // 2\n",
+ "IMAGE_H = 768 // 2\n",
+ "#Number of epochs for training\n",
+ "TRAINING_EPOCHS = 140\n",
+ "#Number of epochs for training the pruned model\n",
+ "RETRAIN_EPOCHS = 80\n",
+ "#Number of gpus available\n",
+ "%env NUM_GPUS=1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "MODEL_NAME = os.environ['MODEL_NAME'] = \"resnet\"\n",
+ "NUM_LAYERS = os.environ['NUM_LAYERS'] = str(18)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Root of your project:\n",
+ "#This should be where you are running your notebook from.\n",
+ "LOCAL_ROOT = os.environ[\"LOCAL_ROOT\"] = os.getcwd()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "### Login to ngc\n",
+ "\n",
+ "docker_config_path = os.path.join(os.path.expanduser(\"~\"), '.docker', 'config.json')\n",
+ "docker_config = json.load(open(docker_config_path))\n",
+ "\n",
+ "if \"nvcr.io\" not in docker_config['auths']: \n",
+ " if os.environ.get('NGC_TOKEN') is None:\n",
+ " print(\"Please set $NGC_TOKEN\")\n",
+ " print(\"If you do not have a token you can sign up for one here: https://ngc.nvidia.com/signin\")\n",
+ " else:\n",
+ " #Note that #oauthtoken isn't something that should be set.\n",
+ " !echo $NGC_TOKEN | docker login --username \"\\$oauthtoken\" --password-stdin nvcr.io "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#None of this needs to be modified.\n",
+ "\n",
+ "%env KEY=tlt_encode\n",
+ "colors = [[255,0,0], [0,255,0], [0,0,255], [255,255,0], [0,255,255]]\n",
+ "DOCKER_ROOT = os.environ[\"DOCKER_ROOT\"] = \"/workspace/tlt-experiments\"\n",
+ "EXPERIMENT_DIR = os.environ[\"EXPERIMENT_DIR\"] = \"detectnet_v2\"\n",
+ "DATA_DIR = os.environ[\"DATA_DIR\"] = \"data\"\n",
+ "SPECS_DIR = os.environ[\"SPECS_DIR\"] = \"resources\"\n",
+ "IMAGE_DIR = os.environ[\"IMAGE_DIR\"] = \"image_2\"\n",
+ "LABEL_DIR = os.environ[\"LABEL_DIR\"] = \"label_2\"\n",
+ "TRAINING_DIR = os.environ[\"TRAINING_DIR\"] = os.path.join(DATA_DIR, \"training\")\n",
+ "TESTING_DIR = os.environ[\"TESTING_DIR\"] = os.path.join(DATA_DIR, \"testing\")\n",
+ "\n",
+ "TRAIN_IMAGE_DIR = os.environ['TRAIN_IMAGE_DIR'] = os.path.join(LOCAL_ROOT, TRAINING_DIR,IMAGE_DIR )\n",
+ "TRAIN_LABEL_DIR = os.environ['TRAIN_LABEL_DIR'] = os.path.join(LOCAL_ROOT,TRAINING_DIR, LABEL_DIR)\n",
+ "TEST_IMAGE_DIR = os.environ['TEST_IMAGE_DIR'] = os.path.join(LOCAL_ROOT, TESTING_DIR, IMAGE_DIR)\n",
+ "TEST_LABEL_DIR = os.environ['TEST_LABEL_DIR'] = os.path.join(LOCAL_ROOT,TESTING_DIR, LABEL_DIR)\n",
+ "\n",
+ "TF_RECORD_PROTO = os.environ['TF_RECORD_PROTO'] = f\"detectnet_v2_tfrecords_kitti_trainval.txt\"\n",
+ "BASIC_TRAIN_PROTO = os.environ['BASIC_TRAIN_PROTO'] = f\"detectnet_v2_train_{MODEL_NAME}{NUM_LAYERS}_kitti.txt\"\n",
+ "TRAIN_RANDOM_INIT_PROTO = os.environ['TRAIN_RANDOM_INIT_PROTO'] = f\"detectnet_v2_not_pretrained_{MODEL_NAME}{NUM_LAYERS}_kitti.txt\"\n",
+ "TLT_INFERENCE_PROTO = os.environ['TLT_INFERENCE_PROTO'] = f\"detectnet_v2_inference_{MODEL_NAME}{NUM_LAYERS}_kitti_tlt.txt\"\n",
+ "TRT_INFERENCE_PROTO = os.environ['TRT_INFERENCE_PROTO'] = f\"detectnet_v2_inference_{MODEL_NAME}{NUM_LAYERS}_kitti_trt.txt\"\n",
+ "RETRAIN_PROTO = os.environ['RETRAIN_PROTO'] = f\"detectnet_v2_retrain_{MODEL_NAME}{NUM_LAYERS}_kitti.txt\"\n",
+ "\n",
+ "os.environ['IMAGE_H'] = str(IMAGE_H)\n",
+ "os.environ['IMAGE_W'] = str(IMAGE_W)\n",
+ "\n",
+ "!mkdir -p $TRAIN_IMAGE_DIR\n",
+ "!mkdir -p $TRAIN_LABEL_DIR\n",
+ "!mkdir -p $TEST_IMAGE_DIR\n",
+ "!mkdir -p $TEST_LABEL_DIR\n",
+ "!mkdir -p $EXPERIMENT_DIR"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#TLT works by running all commands in docker containers.\n",
+ "# Here we map local directories to the TLT docker.\n",
+ "mounts_file = os.path.expanduser(\"~/.tlt_mounts.json\")\n",
+ "# Define the dictionary with the mapped drives\n",
+ "drive_map = {\n",
+ " \"Mounts\": [\n",
+ " # Mapping the data directory\n",
+ " {\n",
+ " \"source\": os.environ[\"LOCAL_ROOT\"],\n",
+ " \"destination\": os.environ[\"DOCKER_ROOT\"]\n",
+ " },\n",
+ " # Mapping the specs directory.\n",
+ " {\n",
+ " \"source\": os.path.join(os.environ[\"LOCAL_ROOT\"], os.environ[\"SPECS_DIR\"] ),\n",
+ " \"destination\": os.path.join(os.environ[\"DOCKER_ROOT\"], os.environ[\"SPECS_DIR\"] )\n",
+ " },\n",
+ " ]\n",
+ "}\n",
+ "\n",
+ "# Writing the mounts file.\n",
+ "with open(mounts_file, \"w\") as mfile:\n",
+ " json.dump(drive_map, mfile, indent=4)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!cat ~/.tlt_mounts.json"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Install dependencies "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Installing NGC CLI on the local machine.\n",
+ "## Download and install\n",
+ "\n",
+ "!pip install nvidia-pyindex\n",
+ "!pip install nvidia-tlt --upgrade\n",
+ "!pip install labelbox\n",
+ "!pip install nvidia-pyindex\n",
+ "!pip install nvidia-tlt\n",
+ "!pip install matplotlib==3.3.3\n",
+ "!pip install PILLOW\n",
+ "!pip install requests\n",
+ "!pip install tqdm\n",
+ "!pip install numpy\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if shutil.which(\"ngc\") is None:\n",
+ " %env CLI=ngccli_reg_linux.zip\n",
+ " !mkdir -p $LOCAL_ROOT/ngccli\n",
+ " # Remove any previously existing CLI installations\n",
+ " !rm -rf $LOCAL_ROOT/ngccli/*\n",
+ " !wget \"https://ngc.nvidia.com/downloads/$CLI\" -P $LOCAL_ROOT/ngccli\n",
+ " !unzip -u \"$LOCAL_ROOT/ngccli/$CLI\" -d $LOCAL_ROOT/ngccli/\n",
+ " !rm $LOCAL_ROOT/ngccli/*.zip \n",
+ " os.environ[\"PATH\"]=\"{}/ngccli:{}\".format(os.getenv(\"LOCAL_ROOT\", \"\"), os.getenv(\"PATH\", \"\"))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import requests\n",
+ "from multiprocessing.pool import ThreadPool as Pool\n",
+ "from tqdm import tqdm\n",
+ "from io import BytesIO\n",
+ "import random\n",
+ "import os\n",
+ "import time\n",
+ "import cv2\n",
+ "import numpy as np\n",
+ "from PIL import Image\n",
+ "from math import ceil\n",
+ "import matplotlib.pyplot as plt\n",
+ "from collections import defaultdict\n",
+ "\n",
+ "from labelbox import Client, Project\n",
+ "\n",
+ "from google.protobuf import text_format\n",
+ "from google.protobuf.text_format import Merge, MessageToString\n",
+ "from google.protobuf.json_format import ParseDict\n",
+ "\n",
+ "from tritonclient import http as tritonhttpclient\n",
+ "from tritonclient.grpc import model_config_pb2 as mc\n",
+ "from tritonclient.utils import triton_to_np_dtype\n",
+ "from tritonclient.utils import InferenceServerException\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import sys\n",
+ "sys.path.insert(0, 'resources/proto')\n",
+ "from proto import (\n",
+ " dataset_export_config_pb2,\n",
+ " experiment_pb2, \n",
+ " inference_pb2\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Helper functions for later\n",
+ "def load_proto(filename, proto):\n",
+ " return Merge(str(open(filename).read()), proto)\n",
+ "\n",
+ "def load_reference_proto(filename, proto):\n",
+ " parts = filename.split(\"/\")\n",
+ " path = os.path.join(*parts[:-1])\n",
+ " filename = os.path.join(path, \"reference_specs\", parts[-1])\n",
+ " return load_proto(f\"/{filename}\", proto) \n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## ETL\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Data overview\n",
+ "\n",
+ "- Data is set based on the LABELBOX_PROJECT_ID configured above.\n",
+ "- The data used for testing this notebook in the demo here is from https://beerys.github.io/CaltechCameraTraps/\n",
+ " * We sampled a small subset and mapped all of the classes to animal.\n",
+ " * Then we went through the subset and labeled the humans using labelbox\n",
+ " * See the mal notebook (`labelbox_upload.ipynb`) for setting up the labeling task\n",
+ "------\n",
+ "The ETL process has the following steps:\n",
+ "1. Export labels from labelbox\n",
+ "2. Convert the data into the kitti format\n",
+ "3. Serialize to tfrecords"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "client = Client()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "project = client.get_project(LABELBOX_PROJECT_ID)\n",
+ "labels = project.export_labels()\n",
+ "data = requests.get(labels).json()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def bbox_to_kitti(label, scale_w, scale_h):\n",
+ " \"\"\"\n",
+ " - Reformat labelbox bounding box labels to kitti\n",
+ " - Scales bbox coordinates to match the resizing applied to the image.\n",
+ " \"\"\"\n",
+ " \n",
+ " class_name = label['name']\n",
+ " bbox = label['bbox']\n",
+ " return ' '.join([str(x) for x in \n",
+ " [class_name, # object name\n",
+ " 0.0, # truncated - unused\n",
+ " 0, # occluded - unused\n",
+ " 0.0, # alpha - unused\n",
+ " bbox['left'] * scale_w, # left \n",
+ " bbox['top'] * scale_h, # top\n",
+ " (bbox['left'] + bbox['width']) * scale_w, # right\n",
+ " (bbox['top'] + bbox['height']) * scale_h, # bottom \n",
+ " 0.0, # dims - unused\n",
+ " 0.0, # dims - unused\n",
+ " 0.0, # dims - unused\n",
+ " 0.0, # location - unused\n",
+ " 0.0, # location - unused\n",
+ " 0.0, # location - unused\n",
+ " 0.0, # rotation_y - unused\n",
+ " ]])\n",
+ " \n",
+ "\n",
+ "def filter_labels(row):\n",
+ " \"\"\"\n",
+ " Reads a sinlge label from a labelbox export and extracts only bounding box annotations\n",
+ " \"\"\"\n",
+ " labels = [\n",
+ " {\n",
+ " 'bbox' : obj.get('bbox'),\n",
+ " 'name' : obj.get('title')\n",
+ " } \n",
+ " for obj in row['Label'].get('objects',[]) if (\n",
+ " obj.get('bbox') is not None and obj.get('title') in class_mappings\n",
+ " )\n",
+ " ]\n",
+ " return labels\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib\n",
+ "\n",
+ "\n",
+ "def get_unique_locations(row, labels_path):\n",
+ " if not hasattr(get_unique_locations, 'unique_locations'): \n",
+ " unique_locations = {json.load(open(os.path.join(labels_path,f)))['location'] for f in os.listdir(labels_path)}\n",
+ " get_unique_locations.unique_locations = list(unique_locations)\n",
+ " return get_unique_locations.unique_locations\n",
+ "\n",
+ " \n",
+ "def partition_sequential_data(row):\n",
+ " \"\"\"\n",
+ " - The animal data comes from video frames \n",
+ " we don't want the train and test data to come from the same camera locations.\n",
+ " \"\"\"\n",
+ " labels_path = os.path.join(os.environ.get('LOCAL_ROOT'), 'labels')\n",
+ " location_file = row['External ID'].split('/')[-1].replace('.jpg', '.json') \n",
+ " location = json.load(open(os.path.join(labels_path, location_file)))['location']\n",
+ " unique_locations = get_unique_locations(row, labels_path)\n",
+ " random.seed(1)\n",
+ " random.shuffle(unique_locations)\n",
+ " train_locations = unique_locations[:int(len(unique_locations)*0.7)]\n",
+ " test_locations = unique_locations[int(len(unique_locations)*0.7):]\n",
+ " if location in train_locations:\n",
+ " return \"train\"\n",
+ " elif location in test_locations:\n",
+ " return \"test\"\n",
+ " else:\n",
+ " raise ValueError(f\"location `{location}` not found in test or train locations\")\n",
+ " \n",
+ "def partition_function(row, test_percentage = 0.15):\n",
+ " \"\"\"\n",
+ " If not using sequential data then the random partitioning is fine.\n",
+ " \"\"\"\n",
+ " if USE_RANDOM_PARTITIONING:\n",
+ " if random.random() < test_percentage:\n",
+ " return 'test'\n",
+ " else:\n",
+ " return 'train'\n",
+ " return partition_sequential_data(row)\n",
+ " \n",
+ "def labels_to_kitti(labels, scale_w, scale_h):\n",
+ " kitti = []\n",
+ " for label in labels:\n",
+ " kitti.append(bbox_to_kitti(label, scale_w, scale_h))\n",
+ " return '\\n'.join(kitti)\n",
+ "\n",
+ "def serialize_example(image, labels, file_name, image_dir, label_dir):\n",
+ " image = image.convert('RGB')\n",
+ " image.save(os.path.join(image_dir, f\"{file_name}.jpg\"))\n",
+ " with open(os.path.join(label_dir, f\"{file_name}.txt\"), 'w') as file:\n",
+ " file.write(labels)\n",
+ " \n",
+ "def run_row(row):\n",
+ " idx, row = row\n",
+ " labels = filter_labels(row)\n",
+ " if not len(labels):\n",
+ " return\n",
+ " \n",
+ " image = row['Labeled Data']\n",
+ " image_data = Image.open(BytesIO(requests.get(image).content))\n",
+ " orig_w, orig_h = image_data.size\n",
+ " image_data = image_data.resize((IMAGE_W, IMAGE_H))\n",
+ " file_name = str(idx).zfill(5)\n",
+ " image = requests.get(data[1]['Labeled Data']) \n",
+ " labels = labels_to_kitti(labels, IMAGE_W / orig_w, IMAGE_H /orig_h )\n",
+ " dataset = partition_function(row)\n",
+ "\n",
+ " if dataset == 'train':\n",
+ " serialize_example(image_data, labels, file_name, TRAIN_IMAGE_DIR, TRAIN_LABEL_DIR)\n",
+ " elif dataset == 'test':\n",
+ " serialize_example(image_data, labels, file_name, TEST_IMAGE_DIR, TEST_LABEL_DIR)\n",
+ " else:\n",
+ " raise ValueError(f\"Partition function returned `{dataset}`. Expected `train` or `test\")\n",
+ " \n",
+ "\n",
+ " \n",
+ "with Pool(12) as pool:\n",
+ " list(tqdm(pool.imap(run_row, [[idx,r] for idx, r in enumerate(data)]), total = len(data)))\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# verify\n",
+ "num_training_images = len(os.listdir(TRAIN_IMAGE_DIR))\n",
+ "num_training_labels = len(os.listdir(TRAIN_LABEL_DIR))\n",
+ "num_testing_images = len(os.listdir(TEST_IMAGE_DIR))\n",
+ "num_testing_labels = len(os.listdir(TEST_LABEL_DIR))\n",
+ "print(\"Number of images in the train/val set. {}\".format(num_training_images))\n",
+ "print(\"Number of labels in the train/val set. {}\".format(num_training_labels))\n",
+ "print(\"Number of images in the test set. {}\".format(num_testing_images))\n",
+ "print(\"Number of labels in the test set. {}\".format(num_testing_labels))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Sample kitti label.\n",
+ "!cat $TRAIN_LABEL_DIR/00001.txt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Convert Kitti data to tfrecords"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Configure tf records\n",
+ "tf_record_proto = load_reference_proto(os.path.join(LOCAL_ROOT, SPECS_DIR, TF_RECORD_PROTO), dataset_export_config_pb2.DatasetExportConfig())\n",
+ "tf_record_proto.kitti_config.image_dir_name = os.environ['IMAGE_DIR']\n",
+ "tf_record_proto.kitti_config.label_dir_name = os.environ['LABEL_DIR']\n",
+ "tf_record_proto.kitti_config.image_extension = IMAGE_FORMAT\n",
+ "tf_record_proto.kitti_config.root_directory_path = os.path.join(DOCKER_ROOT, TRAINING_DIR)\n",
+ "tf_record_proto.image_directory_path = os.path.join(DOCKER_ROOT, TRAINING_DIR)\n",
+ "tf_record_proto.kitti_config.num_partitions = 2\n",
+ "tf_record_proto.kitti_config.num_shards = 2\n",
+ "\n",
+ "with open(os.path.join(LOCAL_ROOT, SPECS_DIR, TF_RECORD_PROTO), 'w') as file:\n",
+ " file.write(str(tf_record_proto))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"TFrecords conversion spec file for kitti training\")\n",
+ "!cat $LOCAL_ROOT/$SPECS_DIR/$TF_RECORD_PROTO"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Converting Tfrecords for kitti trainval dataset\")\n",
+ "!/usr/local/bin/tlt detectnet_v2 dataset_convert \\\n",
+ " -d $DOCKER_ROOT/$SPECS_DIR/$TF_RECORD_PROTO \\\n",
+ " -o $DOCKER_ROOT/$DATA_DIR/tfrecords/kitti_trainval/\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!ls -rlt $LOCAL_ROOT/$DATA_DIR/tfrecords/kitti_trainval/"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Training"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Download pre-trained model "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# There are a lot of different models available from ngc. In this demo we only use resnet18\n",
+ "# The following command lists models available in the model registry.\n",
+ "#!ngc registry model list nvidia/tlt_pretrained_detectnet_v2:*"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Create the target destination to download the model.\n",
+ "!mkdir -p $LOCAL_ROOT/$EXPERIMENT_DIR/pretrained_$MODEL_NAME$NUM_LAYERS/"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Download the pretrained model from NGC\n",
+ "\n",
+ "!ngc registry model download-version \\\n",
+ " nvidia/tlt_pretrained_detectnet_v2:$MODEL_NAME$NUM_LAYERS \\\n",
+ " --dest $LOCAL_ROOT/$EXPERIMENT_DIR/pretrained_$MODEL_NAME$NUM_LAYERS\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Check that the file exists\n",
+ "PRETRAINED_WEIGHTS_DIR = os.listdir(os.path.join(EXPERIMENT_DIR,f\"pretrained_{MODEL_NAME}{NUM_LAYERS}\"))\n",
+ "assert len(PRETRAINED_WEIGHTS_DIR), \"Pretrained model weights did not download properly\"\n",
+ "PRETRAINED_WEIGHTS = os.listdir(os.path.join(EXPERIMENT_DIR,f\"pretrained_{MODEL_NAME}{NUM_LAYERS}\", PRETRAINED_WEIGHTS_DIR[0]))\n",
+ "assert len(PRETRAINED_WEIGHTS), \"Pretrained model weights did not download properly\"\n",
+ "PRETRAINED_WEIGHTS = os.path.join(PRETRAINED_WEIGHTS_DIR[0], PRETRAINED_WEIGHTS[0])\n",
+ "PRETRAINED_WEIGHTS = os.environ[\"PRETRAINED_WEIGHTS\"] = PRETRAINED_WEIGHTS\n",
+ "\n",
+ "#Make sure file exists..\n",
+ "!ls -rlt $LOCAL_ROOT/$EXPERIMENT_DIR/pretrained_$MODEL_NAME$NUM_LAYERS/$PRETRAINED_WEIGHTS"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Configure Training Params"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Overwrite protos with information set at the top of the notebook and sensible defaults.\n",
+ "\n",
+ "tf_train_proto = load_reference_proto(os.path.join(LOCAL_ROOT, SPECS_DIR, BASIC_TRAIN_PROTO), experiment_pb2.Experiment())\n",
+ "\n",
+ "default_postprocessing_params = {\n",
+ " \"coverage_threshold\": 0.00499999988824,\n",
+ " \"minimum_bounding_box_height\": 10,\n",
+ " \"dbscan_eps\": 0.20000000298,\n",
+ " \"dbscan_min_samples\": 0.0500000007451,\n",
+ " \"dbscan_confidence_threshold\": 0.9\n",
+ "}\n",
+ "\n",
+ "default_eval_config = {\n",
+ " 'default_eval_box' :{\n",
+ " \"minimum_height\" : 10,\n",
+ " \"maximum_height\" : 9999,\n",
+ " \"minimum_width\" : 10,\n",
+ " \"maximum_width\" : 9999\n",
+ " },\n",
+ " 'default_eval_overlap' : 0.5\n",
+ "}\n",
+ "\n",
+ "default_cost_function_config = {\n",
+ " \"class_weight\" : 1.0,\n",
+ " \"coverage_foreground_weight\" : 0.0500000007451,\n",
+ "}\n",
+ "\n",
+ "default_rasterizer_config = {\n",
+ " \"cov_center_x\": 0.5,\n",
+ " \"cov_center_y\": 0.5,\n",
+ " \"cov_radius_x\": 0.40000000596,\n",
+ " \"cov_radius_y\": 0.40000000596,\n",
+ " \"bbox_min_radius\": 1.0\n",
+ "}\n",
+ "\n",
+ "#Set paths\n",
+ "tf_train_proto.dataset_config.data_sources[0].tfrecords_path = os.path.join(DOCKER_ROOT, DATA_DIR, \"tfrecords/kitti_trainval\", \"*\")\n",
+ "tf_train_proto.dataset_config.data_sources[0].image_directory_path = os.path.join(DOCKER_ROOT,TRAINING_DIR)\n",
+ "tf_train_proto.dataset_config.image_extension = IMAGE_FORMAT.replace('.', '')\n",
+ "#Set classes\n",
+ "tf_train_proto.dataset_config.target_class_mapping.clear()\n",
+ "tf_train_proto.dataset_config.target_class_mapping.update(class_mappings)\n",
+ "#Set image information\n",
+ "tf_train_proto.augmentation_config.preprocessing.output_image_width = IMAGE_W\n",
+ "tf_train_proto.augmentation_config.preprocessing.output_image_height = IMAGE_H\n",
+ "\n",
+ "tf_train_proto.postprocessing_config.target_class_config.clear()\n",
+ "tf_train_proto.bbox_rasterizer_config.target_class_config.clear()\n",
+ "tf_train_proto.evaluation_config.minimum_detection_ground_truth_overlap.clear()\n",
+ "tf_train_proto.evaluation_config.evaluation_box_config.clear()\n",
+ "target_class = tf_train_proto.cost_function_config.target_classes[0]\n",
+ "tf_train_proto.cost_function_config.ClearField(\"target_classes\")\n",
+ "tf_train_proto.evaluation_config.evaluation_box_config.clear()\n",
+ "\n",
+ "for idx, value in enumerate(set(class_mappings.values())):\n",
+ " tf_train_proto.evaluation_config.minimum_detection_ground_truth_overlap.update({value: default_eval_config['default_eval_overlap']})\n",
+ "\n",
+ " for k,v in default_postprocessing_params.items():\n",
+ " setattr(tf_train_proto.postprocessing_config.target_class_config[value].clustering_config, k, v)\n",
+ " \n",
+ " for k,v in default_rasterizer_config.items():\n",
+ " setattr(tf_train_proto.bbox_rasterizer_config.target_class_config[value], k, v)\n",
+ " \n",
+ " for k,v in default_eval_config['default_eval_box'].items():\n",
+ " setattr(tf_train_proto.evaluation_config.evaluation_box_config[value], k, v)\n",
+ "\n",
+ " current_class = target_class.__deepcopy__() \n",
+ " for k,v in default_cost_function_config.items():\n",
+ " setattr(current_class, k, v)\n",
+ " current_class.name = value\n",
+ " tf_train_proto.cost_function_config.target_classes.append(current_class)\n",
+ "\n",
+ "\n",
+ "tf_train_proto.evaluation_config.validation_period_during_training = 10\n",
+ "tf_train_proto.evaluation_config.first_validation_epoch = 10\n",
+ "tf_train_proto.training_config.batch_size_per_gpu = 12 \n",
+ "tf_train_proto.training_config.num_epochs = TRAINING_EPOCHS\n",
+ "\n",
+ "#Could be interesting for an experiment:\n",
+ "#Interesting: tf_train_proto.model_config.freeze_pretrained_layers = False \n",
+ "\n",
+ "\n",
+ "#Configure the model\n",
+ "if NUM_LAYERS == 34:\n",
+ " tf_train_proto.model_config.all_projections = False\n",
+ "tf_train_proto.model_config.arch = MODEL_NAME\n",
+ "tf_train_proto.model_config.num_layers = int(NUM_LAYERS)\n",
+ "\n",
+ "ABSPATH_PRETRAINED_WEIGHTS = os.path.join(DOCKER_ROOT,EXPERIMENT_DIR, f\"pretrained_{MODEL_NAME}{NUM_LAYERS}\",PRETRAINED_WEIGHTS) \n",
+ "tf_train_proto.model_config.pretrained_model_file = ABSPATH_PRETRAINED_WEIGHTS\n",
+ "\n",
+ "with open(os.path.join(LOCAL_ROOT, SPECS_DIR, BASIC_TRAIN_PROTO), 'w') as file:\n",
+ " file.write(str(tf_train_proto))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!cat $LOCAL_ROOT/$SPECS_DIR/$BASIC_TRAIN_PROTO"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Train the model\n",
+ "\n",
+ "##### We are going to train two models\n",
+ "1. A model with pretrained weights (transfer learning)\n",
+ "2. A model with randomly initialized weights\n",
+ "\n",
+ "* The goal is to see if the transfer learning impaces the model performance or time to convergence\n",
+ "* If you are using to make your own model you can skip the randomly initialized training\n",
+ " - TLDR; transfer learning helps\n",
+ "* Takes about 5 minutes for roughly 250 images on a titan v\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!ls $LOCAL_ROOT/$EXPERIMENT_DIR/experiment_dir_unpruned/weights\n",
+ "MODEL_FILE_NAME = os.environ['MODEL_FILE_NAME'] = f\"{MODEL_NAME}{NUM_LAYERS}_detector\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!rm -f pretrained.out\n",
+ "!tlt detectnet_v2 train -e $DOCKER_ROOT/$SPECS_DIR/$BASIC_TRAIN_PROTO \\\n",
+ " -r $DOCKER_ROOT/$EXPERIMENT_DIR/experiment_dir_unpruned \\\n",
+ " -k $KEY \\\n",
+ " -n $MODEL_FILE_NAME \\\n",
+ " --gpus $NUM_GPUS | tee pretrained.out\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "##### Configure randomly initialized model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Exact same config without pretrained weights\n",
+ "tf_train_proto = load_proto(os.path.join(LOCAL_ROOT, SPECS_DIR, BASIC_TRAIN_PROTO), experiment_pb2.Experiment())\n",
+ "tf_train_proto.model_config.ClearField(\"pretrained_model_file\")\n",
+ "with open(os.path.join(LOCAL_ROOT, SPECS_DIR, TRAIN_RANDOM_INIT_PROTO), 'w') as file:\n",
+ " file.write(str(tf_train_proto))\n",
+ "!mkdir -p $LOCAL_ROOT/$EXPERIMENT_DIR/experiment_dir_unpruned_not_pretrained"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!cat $LOCAL_ROOT/$SPECS_DIR/$TRAIN_RANDOM_INIT_PROTO"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Train randomly initialized model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "!mkdir -p $LOCAL_ROOT/$EXPERIMENT_DIR/experiment_dir_unpruned_not_pretrained\n",
+ "!rm -f not_pretrained.out\n",
+ "\n",
+ "!tlt detectnet_v2 train -e $DOCKER_ROOT/$SPECS_DIR/$TRAIN_RANDOM_INIT_PROTO \\\n",
+ " -r $DOCKER_ROOT/$EXPERIMENT_DIR/experiment_dir_unpruned_not_pretrained \\\n",
+ " -k $KEY \\\n",
+ " -n $MODEL_FILE_NAME \\\n",
+ " --gpus $NUM_GPUS | tee not_pretrained.out\n",
+ "#\n",
+ "#Let's not use pretrained weights.."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Compare performance\n",
+ "* Model trained with transfer learning should train much faster and be more performant"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABvtUlEQVR4nO2dd3gUVReH30kIvRcB6SDSmyCgIE0UkK4goiiogIKKWLB8CoIVFRXEriBgo3ekg4KoAaRIlyogvRMIpOzv++NmQ4CU3WS2hMybZ55sZuaee3aye+bOueeeY0nCwcHBwSHjEBJoBRwcHBwc/Itj+B0cHBwyGI7hd3BwcMhgOIbfwcHBIYPhGH4HBweHDEamQCvgCQULFlTp0qUDrYaDg4NDuuKvv/46JqnQlfvTheEvXbo0q1evDrQaDg4ODukKy7L+TWy/4+pxcHBwyGA4ht/BwcEhg+EYfgcHB4cMhmP4HRwcHDIYjuF3cHBwyGA4ht/BwcEhg+EYfgcHB4cMhmP4HRzcREfDuHEQERFoTTIOEixYAJMmBVqT1LFsGSxfHmgtvMYx/A4ObsaNg+7doVs3cLkCrc21TVQUjB0LNWpAixZw773m+qcnfvsN7rgDmjc3r9MRjuF3cHDzzTeQIwfMmAFDhgRam2uTU6fg3XehTBno0cPsGzMGmjWDXr3SjwHdvRs6doRSpaB0aejQAXbsCLRWHuMYfgcHgE2b4M8/jcHv0QNefx2mTg20VtcO//4Lzz4LJUrASy9B5cowfz6sX2+esiZPNga0Y0fYtSvQ2ibP6dPQpg3ExsLs2TBnjtnfujWcOBFY3TzEMfwODgCjRkFYGDz0EHz+OdSrZ15v2BBozdI3a9bA/fdDuXIwcqQZGa9dCwsXwp13gmWZ8/LlM0Y0NhbatjXGNRiJiYH77oN//jE3qxtvhBtugOnTYc8euPtu48YKdiQF/Va7dm05OPiMixelggWlTp0u7fvvP6loUalMGenYscDplh5xuaSff5aaNZNAypVLev55ae/elNsuWSJlyiS1bClFR/teV2/p18+8p6++uvrYDz+YYw89ZK5BEACsViI2NeBG3ZPNMfwOPmXSJPNVmDv38v1//illzizdfntwGqFg48IFafRoqXJlcz2LFZPef186dco7OV99Zdr36+cbPVPLZ58ZvZ55Julzhgwx57zxhv/0SgbH8Ds4JEWLFlKJElJMzNXHRo82X5P+/f2vV3rhxAnp7belIkXMtapeXRo3zjxJpZZnnzWyPvvMPj3TwoIFUmio1Lp14p8TNy6X9OCDRvcff/SffkngGH4Hh8T491/JsqRBg5I+x/14P2aM//RKD+zeLT39tJQjh7k+d95pDKQdbo6YGKlNG2NsFyxIu7y0sGWLlCePVK2adOZMyudfuCA1amSeFpcv97l6yeEYfgeHxBg82Bj+3buTPicqyvirs2SRwsP9plrQsmqV1KWLFBJi/PEPPiitW2d/P2fOGGObJ48xvoHg2DGpXDnpuuukPXu8a1e+vFSggLR9u+/0S4GkDL8T1eOQcYmNhdGjzQKc5Ep7hoXBxIlw/fUm3PDgQb+pGDS4XCbqpkkTuPlmmDsXnnvOxLOPG2cWYtlNrlwwaxZkyWLCJ48ft7+P5IiKMlE6+/ebqJ1SpTxvW6AA/PyzeR2EYZ6O4XfIuCxeDHv3wqOPpnxugQLmy3/qlDEGFy/6WrvAcuSIibMfOhS6dIGyZU2Y5a5d8MEHsG8fvPceFC/uWz1KlTIL6vbv92+opAR9+piUDKNHwy23eC8jmMM8E3sMCLbNcfU4+IR775Xy5zc+WU+ZPNl4SB95JGhC9tKEyyXt2iVNmSK9+qqZvLz+evMe3Vvp0lLHjtJ33xm3VyBwh0r667q//77pb+DAtMv6/nsFKsyTJFw96aLYuoOD7Rw7BtOmQd++xpXgKffcA6++Cm++CbVqwZNP+k5Hu4mJgS1bzAIq97Zu3aXFUqGhULGiSZ9Qq5bZatY0i6sCzf33w9at8MYbRscBA3zX18yZ8MIL0LkzDB6cdnkPPAA7d8Jrr0H58ubzE2Acw++QMfn+e5ON0xM3z5UMGWJSDfTvD1WqQNOmtquXZs6fh7//vtzIb9hwyUWVLRtUrw5duxrjXqsWVKtm9gcrgwfDtm3w4otQoQK0a2d/H+vWmZtMnTomh1CITd7wgQNNLp+BA80q5q5d7ZGbSizzNBDc1KlTR6tXrw60Gg7XCpIxcjlyQHh46mScOQP16xtf+OrVyU8O+4NDh+CHH0yKhLVrjYF0ZxjNl+/SCN693XgjZEqH477ISGjcGDZvNgndata0T/ahQ1C3rvl8rFwJRYvaJxvMTffOO01OqCVLoEEDe+UngmVZf0mqc9V+x/A7ZDjCw43R/uorkxEytWzfbgxFyZLw++/mRuJvoqNNDpzBg+HsWTPZeqWRL1nyUk6ca4GDB811tyzzv7TDQEdGmoiljRvNDaVWrbTLTIzjx81E8YkT5gZwww2+6SeOpAx/wCduPdmcyV0HW+nVS8qeXTp9Ou2y5s0z8eydO/t/snfBAqliRTNx2KqVtHWrf/sPJGvWmP9h3brS+fNpk+VymXUJliVNm2aLesnyzz8mqODGG6Xjx33aFU4cv4NfiI01aXc3bgy0JokTEQE//WRCFHPnTru8Fi1MyOOkSfDOO2mX5wnuXPB33mlG/LNmmZjxChX8038wUKuWcW2tWgUPP2zcM6llyBCYMMH8Hzt0sE3FJClfPvBhnondDYJtc0b86Qh32N0ttwRnuKM7985vv9kn0+WS7r/fjBhnzbJP7pWcO2fCC7NkMaPdt9/2LhT1WuTdd83/87XXUtf+xx9N+4cf9v/n1Q9hnjgpGxx8TkyMVKGCMUpgsl4GG7featwjdn/Rzp+XbrrJpCDevNle2S6XuZYlS5rr2rWrtG+fvX2kV1wuY7RTkxTtjz/MTfS229KWUC4tDB4sX2bzdAy/g+9xj57Gj5eqVjU5TgL1hUqMzZuNfu+/7xv5e/eanC7ly0snT9ojc8OGS3nta9SQli2zR+61xMWLJilalizGmHvCv/9KhQtLZctKR4/6Vr/kcLmkbt1Sd+PyAMfwO/iWmBgzkq5aVYqNNYU4QBo+PNCaXeK550xSscOHfdfH8uVSWJiZbL0ife8wDdM4jfNMzsmTJitoaKiZCPzsM6cmQHIcPWqMuCfJ1M6cMamj8+Sx/+ksNSTM5mmnC1KO4XfwNe7R/sSJ5m+XyxQwyZ/fvtFvWrh4USpUSLr7bt/39cUX5lq8+GL8rkhFKpuyqZAK6aKSeQqKjZW+/tpUBAsJkfr0cSqAecrmzSmnT06Y7nn+fL+qlyw+yuYZEMMPPANsAjYCPwFZgTJAOLADmABkTkmOY/iDnJgYqVIlqUoVY7jcrF1rJjwHDAiYavG4c+zMmeOf/h5/XAkf3+drvoj7maiJibf54w+pTh3TrmFDE7Lo4B3z5xuj3qZN4gVTnnvOXN9PPvG/binhgzBPvxt+oBiwG8gW9/dEoEfc7/vi9n0B9ElJlmP4g5yffrp8tJ+Qhx4yvldvcpn7glatTCnA5Kon2cnFi8Z4Z8sm/fWXntEzyqIsKqESaq7ml5978KDUvbu5htdfbyKjgjEiKr3w6afmWj733OX7v/7a7H/yycDo5QnLlhmXT5MmtsyPBcrw7wPyY3ICzQZaAMeATHHn3ALMT0mWY/iDmKRG+2727pWyZpUeeMD/uiXUISTEZJ/0J4cOmZKOJUqoYnR5tVALvaE3hNAO7TBf7GHDTCRQWJj00kueVXhySJknnzTm7euvzd/uIu4tWgT/XIk7zLN79zQPAALl6nkaiACOAj8ABYEdCY6XADamJMcx/EHM+PHmYzRhQtLnvPSSOWf1av/plZDXXzf979rl/77/+ku7b8wshD6Kfl/7tV8hCtFLO7tcWnV7113mMd/BPqKjjZHPlMkY/3z5zADF28LvgcKmMM9AjPjzAUuAQkAYMB3o5qnhB3oDq4HVJUuWTNObd/ARMTFS5cpmS2y07+bUKTNZ2aSJ/10YsbEmn/ztt/u33wR8vvIRIbT1tfukXbvULryIrjuELlYqJ82eHTC9vGG2ZusP/SGX0pEL6tQp89kEM2m6c2egNfKchGGenoaoJkIgDH9nYFSCvx8CPndcPdcQnoz23Ywcac715crWxFi40PT700/+7TcB7dVepY/nkQuksDDNvjuLEJocFTidvGGTNsk9MV1ZlTVMw3RYPgyJtZOdO6WWLW0Pk/QLFy5I48alabCUlOH3Za6evUB9y7KyW5ZlAbcDm4GlQKe4c7oDM3yog4OvcLng9dehcmXo1Cnl8x97zOQoeeEFUxDEX4waZdIS+yMHSyJEEcViFtMqb1esHj2ga1dafvwPxSnOV2HfBkQnbxnOcLKSlU/4hDzk4XmepxjFuJu7mc1sYvDj/9NbypY19YH9kALZblZkWc3XD17gouWDXD6J3Q3s2oAhwFZMOOd3QBagLLASE845CciSkhxnxB+ETJig+FW6njJ1qmnz5Ze+0yshx46ZCImnnvJPf4mwREuE0AzNuGz/YA0WQrsUgHkHLziiI8qiLHpMj8Xv26zNel7P6zpdJ4SKqqhe0kv6R848hZ08rIeVT/kUo9RHouEs4HKwjdhYE8VTubJ34ZEul9SggVkq74/olREjzEd8/Xrf95UEAzRAYQrTWZ29bP9e7VWIQvQ//S9AmnmG+wa1RVuuOhalKE3TNLVVW4UqVAjdpts0RmMUoYgAaHvt4JJLJVRC9+ieNMlJyvA7aZkdvGfKFNi0yZSRCw31vJ1lwbBhcPiw+e1LJPjmG1NCr3p13/aVDPOYx23cRk5yXra/BCW4i7sYzWiiiQ6QdslzgQt8yqe0pjUVqXjV8TDC6EAHZjKTvexlKEM5xCF60IOiFKU3vfmTPxHBX+wp2NjOdvaxjzu4wyfyHcPv4B0ul8lfXqmSKUbtLfXrm3bDhsGBA/br52b1alNjtmdP3/WRAv/xHxvYQEtaJnq8N705xCFmM9vPmnnGD/zAUY7yLM+meO71XM+LvMg2trGMZdzDPfzAD9zCLVSlKh/wAUc44getrw0WshCA5jT3iXzH8Dt4h3u0P2iQd6P9hLzzjikgMmiQvbol5JtvTOHw++7zXR8pMI95ALSiVaLHW9GKYhTjK77yp1oeIcSHfEgNatAUz4vJW1jcxm18y7cc5CBf8zW5yZ2+JoSDgJu4iZd4ibKU9U0Hifl/gm1zfPxBQmysyb5ZsWLaUx/0729W027YYI9uCYmIMKthu3e3X7YXdFInFVOxZGPfB2mQLFnaoz1+1Cxl5mmeEBqrsbbI26RNek7PqZAKORPCfgTHx++QZqZONSUV0zLad/Pqq5ArlwnvtJvJk03h8UcftV+2h8QQw0IW0opWWCRd6PxRjI6jGOUv1TziQz6kKEW5D3uemCpTmWEM4z/+YypTqU1t3uM9buRGGtGIyUy2pZ9rgf3sZw1rcOHyWR+O4XfwDLdvv2JFuPfetMsrUMAY/7lzYdGitMtLyDffwI03QsOG9sr1gj/5k9OcTtK/76YkJWlFK0YxKmjcHxvZyAIW8BRPkZnMtsoOI4yOdGQWs9jHPt7hHQ5ykM505imeCpprEEjGMpba1OYEJ3zWh2P4HTxj2jQz2vc2kic5nnwSSpWCAQPMjcUOtm2D334zo30r6ZG2r5nLXEIJ9Whyrje9OcABfuZnP2iWMh/yIdnJzmM85tN+rud6XuIltrCFZ3mWT/iElrT0qcFLDyxkIbWoRUEK+qwPx/A7pIx7tF+hAnTpYp/crFnh7bdh3Tr4/nt7ZI4aZW5MDz1kj7xUMo953Mqt5CFPiue2pjVFKRoUk7yHOMQP/EAPepCf/H7pMxOZ+IAPGM1olrOcutRlM5v90newcY5z/M7vPovmceMYfoeUmTbNhEba4du/kvvug9q1jdsnMjJtsqKjYexYaNsWihSxR79UcIhDrGFNktE8V5KJTDzKo8xlLnvZ62PtkuczPiOaaJ7mab/3/TAPs5SlRBBBfeoHbZirL1nOcqKJ9ln8vhvH8Dskjzsnj92jfTchISamf98+GDEibbJmz4YjRwI6qQuwgAUAKfr3E/IojyLEaEb7Sq0UiSSSz/iMtrTlRm4MiA63ciurWEV5ytOOdrzLuxlqAdgiFpGFLDTEx/NTiYX6BNvmhHMGkClTTNqD77/3bT9t25oQzCNHUi+jdWtTwSrAhTbu030qrMKKVTKpqhOhhVqouIorWoHR/0t9KYR+1a8B6T8h53RO9+peIfSAHtB5nQ+0Sn4hQhH6U3/aJg8nnNPBa9y+/Rtv9P1CqHffhfPnzdNFavjvPxMh1KMHZMpkq2reEEssC1hAS1oS4uXXqze92c/++IVf/sSFi4/4iNrU5jZu83v/V5Kd7IxnPG/yJj/wA41pzAF8uNI7CBDibNzPcIbTk57Upz5HOWp7X4H7hjgEP9Onw99/w3ff2e/bv5JKlaBXL/jiC3jqKXOz8YYxY8yN6pFHfKKep6xmNSc44ZWbx01b2lKYwnzFV7ShjQ+0S5q5zGUrW/mBH5Jdd+BPLCxe4RWqUIVudKMOdZjOdOpSN9CqpZkTnGATm9gY97OJTaxhDWc5G39OQQpSjWqc4hSFKGRr/5Z5Gghu6tSpo9WrVwdajYyFywU33WQmXDdt8s8o+vBhuOEGuOMOs1jMU1wuk+u/VClYssR3+nnAYAbzBm9whCMUoIDX7f/H/3iXd/mXfylOcR9omDi3czvb2MZudhNGmN/69ZQNbKAd7TjIQUYxigd4INAqeUQEEWxm82VGfiMbL3t6yUUuqlKV4xxnP/uZznRqUIPruC7N/VuW9ZekOlfud0b8DokzYwasX29G+/5ynRQubFbyDhpkYvETWYB1jGOc5SxlKHNp5y+/wK5d8MYb/tEzGeYxj7rUTZXRB+hJT97hHUYzmkH4MJdRAtaxjiUs4V3eDUqjD1CNaqxkJZ3oRDe6sYENvMVbhOLjJ1EPuchFtrHtMuO+kY3sZnf8OVnJSmUq05zmVI37qUIVSlACgFKUohWtfB7RAziTuw6JEBsr1agh3Xij/ydKIyKkokWl+vUTLTnXVm1VWIV1QRcu7bz/filvXul8YCcAj+qoLFkaoiFpknOH7lAJlUhTAQ5veEgPKYdy6IRO+KW/tHBRF/WYHhNCrdVap3U6IHrEKla/6lf1VE9VUqX4egQIZVImVVEVdVEXva7XNVVT9Y/+Sfb/uU3bhNDn+txWPXEKsTh4zLRp5qMxblxg+h81yvQ/ceJlu4/ruDIpkxD6UT+anSdOSFmySE88EQBFL+dH/SiEwhWeJjmTNEkI/ayfbdIsaf7TfwpTmPqpn8/7spNP9alCFapKqqTt2u63frdqq17RKyqlUkIoh3KondrpFb2in/STNmiDLuqi13I/1adC2P5eHMPv4Bkul1SzplS+fODCImNipGrVpLJlTcHpOL7W10Ior/LqNt1mdrqLuK9dGxhdE/CgHlRBFfQ6jPNKLuqirtN16qAONmmWNP/T/2TJ0k7t9HlfdrNYi5Vf+ZVP+bRIi3zWz1Ed1UiNVF3VFUIhClELtdD3+t62SmNv6A1VUZVkM7mmBsfwO3hGoEf7bubONXp89FH8rtt1u8qrvN7Vu0Joo2uDcUnddFPA1HQTq1hdp+t0v+63Rd6LelGhCtV/+s8WeYkRoQjlV37drbt91oev2aEdqqzKClWoRmqkbYYzUpGapElqp3bxT5k1VEPDNEwHdMCWPq7EbqMvOYbfwRPco/0bbgj4Iii5XNIdd0j580snT+qgDipEIRqogTqiI8qszHry8L3mI/zZZ4HVVdJqrRZC42TPDXO7tguhN/WmLfISw+1e+E2/+awPf3Bap9VWbYVQL/VKlatFMoZ3uZart3orr/LKXTfgeT2v9fJd3WZfGHw3juF3SJnp081HYqw9xTfSzLp1kmVJAwZopEYKoU3aJEl6QA8o9/nMOlsgi3TyZGD1lPSm3hRCh3XYNpm363aVUqk0u44SI1axukE3qK7q+tTw+ItYxeplvSx3wfcj8nwF+D/6RwM1UGVURghlV3Z1UzfN13y/TLC/rbd1k266PGDBJhzD75A8LpdUq1ZwjPYT0r27lDmzGkTWUTVVi9/9W+QiIfT1N/UDp1sCGqiBasvez+kETRBC8zTPVrmSNEMzhNB4jbdddiD5UT8qq7KqlEppndYled4xHdOn+lT1VV8IWbLUXM01VmN1Vmf9qLHURE1UUzV9Itsx/A7JM2OG+TiMGRNoTS5n3z7tvSGLEHpLb8Xvdo0do6p/o5vO3BjwEesJnVCIQvSqXrVV7kVdVCEV8okPvrEaq6RKBiwvkC9ZqZW6Xtcrh3JoiqbE77+gC5qiKeqgDgpTmBCqqqp6V+9qn/YFRNcIRSizMmuABvhEvmP4HZLGPdovVy64RvtxDJtzuxDa8fe0SzsbNdKng0z91rSGT6aViZooX/nKB2iAMimTrROK7vmID/SBbTKDjQM6oHqqJ4QGaIAe1+PKp3xCqLAK6xk9o7VaG/BBg7u28XzN94l8x/A7JE2wjvbjqBNTS3XWZJIaNzY3qW3bJNDpD15TDuXQw3o4oPo9okeUV3l9Mnp2L+x5W2/bJvMBPaBcyqVTOmWbzGAkUpF6UA8KoWzKpq7qqrmaG1RPOc/pOWVWZp3TOZ/Idwy/Q+K4XCYcMkhH++7olmG/dTQf15kzpRdflEJDpQMH1Fu9lU3ZArbq1CWXrtf16qzOPuujqZqqjMrYMsm7T/uUSZn0jJ6xQbPgxyWX1mptwFb4psQUTdFres1n8pMy/E5a5ozO7NmwZo2pgBXAdMZJMYEJANxbd5jJ2PnCC6bKVuvWULQoj/M4kUQyjnEB0W8DGzjAAY+rbaWGXvRiN7tZzOI0yxrJSFy46Ec/GzQLfiwsalKT3OQOtCqJcjd3M5jBfu/XMfzByrp1sHgxnDzpuz4kGDwYypWDbt18108aGM94GtKQEmFlTc7+rVvh0KH4Klu1qEU96vEFXwSkUpM7d34LWvisj450pAAF0lyTN4IIvuRL7uEeSlPaHuXSAVFEBVqFRNnFLvaxLyB9O4Y/GJGgRQto3hzy54eyZaFzZxg6FBYuhBMn7Olnzhwz2n/llaAc7btT2d5HXBGY9u2hUSMoVgzuuiv+vD70YStb+YVf/K7jXOZSgxpcz/U+6yMrWelOd6YzncMcTrWcb/mW05zmOZ6zUbvgZj7zyUe+oKzf+xZvUYMauHD5v/PE/D/BtmU4H//27caf/fTT0jvvSJ07m7w15pZgttKlpXvukd5+W5o3Tzp61Ls+XC6pdm0jNyrKJ28jrQzUQIUoRId06NLOkyel/fsvO++8ziuf8ule3etX/c7ojDIpk17Uiz7va4u2CKGhGpqq9jGKUVmV1a26NdXt0xt7tEf5lV8INVbjQKtzGS65VEIldI/u8Wk/JOHjD75hngOEh5vfjzwC1atf2n/ypBmh//XXpW3KlEvHS5aE2rUvbTfdBNclUcxhzhzTfvRoCAu+HOxCjGc8TWlKYQpfOpA3r9kSkI1s9KAHIxnJIQ5RhCJ+0XExi4khJlXVtrylIhVpRCO+4RsGMMDrso4zmckudvEe73nddzTRlKUsd3EXX/Kl1+0DwUUu0olOxBDDN3xDYxoHWqXL2M529rGP//G/wCiQ2N0g2LYMN+J/6ikpRw6TpTIlTp6UliyR3n9fuu8+k1Uz4ZNB8eJS+/bS669Lc+ZIhw7pT9cfemxyIcWUKx20o/2/9JcQ+lpfe3S+O+zRl7ltruQxPaZcypXq3DDe8r2+F0KLtdjrtg3VUGVUJlUjd5dcekAPyBf54n3Ff/pPtVRL0zQt0KokijtP0g7t8Gk/OOGc6Yi6dU3Memo5dUpaulQaNswUKalQweS8ibsZdJphVsJOWtzHLo1tx71w6biOe9zmdt2ukirpF7eESy6VVEm/pE52E6lI5VM+dVEXr9qFK1wIDdfwVPcdoxi1VmuFKjRVN55AkPBzsFZr1UVd/J6OISk6qqNKq7TPF5A5hj+9cOGClDmz9MIL9so9c0b69VedHzFUOSJNmtm6sTcHfOViYriNamu19qqdu4DJLM3ykWaX2KzNQuhLfenzvhLSX/0VpjCvkpB1URflUR6d0ZlU9fmlvtRUTdVpnVYVVVE+5dM/+idVsnzNeq1XN3W76r2u0IqA/L+S4j/9p9/1u8/7Scrw+zSqx7KsvJZlTbYsa6tlWVssy7rFsqz8lmUttCxre9zvfL7UId2xbh1ERUG9evbKzZULGjViYb9KnMsaQwc6sDJkFStYYW8/NvAnf7KXvXShi1ft2tOeIhThcz73kWaXmMtcAL/49xPSi15EE81Yxnp0/r/8y2Qm05ve5CKX1/0JMYQhTGISucnNTGZSnvJEE+21LF9zilPczd0sYQnnOX/ZsVu4hRrU4DM+C0jY75Vcz/Xcwi0B69/X4ZwjgHmSKgI1gC3AS8BiSeWBxXF/O7hxT+zabfjjmMpU8pKXMYyhAAUYxjCf9JMWxjOeLGShPe29ahdGGD3pyVzmsoc9vlEujnnMozKVKUlJn/ZzJZWpTEMa8hVfeWTARjISgKd4KlX9/cu/HOAADWgAQFnK8id/UpnKCAUmFDERXLjoTnf+5V8mMvHygADMQq6+9GU96/mTPwOkpWEKUwJ/A0rsMcCODcgD7AasK/ZvA4rGvS4KbEtJVoZy9TzwgFSsmE9ERylK+ZVfD+pBSSZc0pKlrdrqk/5SQ4xiVERFUp2Rcq/2KkQhelkv26zZJdwZFZ/Vs16126d9Oiovw24TYZzGCaGlWprsead1WrmVW13VNdV9uSeU12jNZftjFate6hU0tXrf0TspzmOc1VnlUi51Uzc/anY1vkzDfCUEwNVTBjgKfGtZ1lrLsr6xLCsHUFjSwbhzDsEVt+Y4LMvqbVnWasuyVh89etSHagYZ4eE+G+0vYxknOMHd3A3AEzxBZjLzER/5pL/UsIxlHOLQpUVbXlKCErShDaMY5bMVm7/wC1FEeZWmQYgSlKA61VM+OQU60Ym85E1xJe9oRnOGMzzLs6nuawUryElOqlHtsv0hhJCDHHzMx2leUZxWznKW4QynC12STUWRk5wMYABVqOJH7S7nHOf4nd+5gzsCpgPg0xF/HSAGqBf39wjgDeDUFeedTElWhhnxHztm5tuHpm6RTkr0VV9lU7bLMgH2Ui9lVVavJgt9SW/1Vg7lSFO2wp/1s3xZZORJPansyq5IRXrcxr0Ay65w037qp8zKnOQTRLSiVUqlLhWlTyVt1EbN1TzJPlqqpTIpk5ZoSZr6SSt7tTdoInaSY67mypdpmK+EAIz49wP7JcU5rZkM3AQctiyrKEDc7yM+1CF9sXKl+e2DEb8LF9OZTitakZ3s8fuf5VkucIHP+Mz2Pr0lmmimMIX2tL9MR29pQQvKUMZnk7xzmUtTmpKVrB63mcMcAB7kQVt06EUvoohKMjndNKbxL/+mabQPMCvuJzEykYnxjKc85elEJ3ayM019eUsUUYxiFC5clKAEOcnpUbtoopnJzIDMTyxiEZnJTEMa+r3vhPjM8Es6BOyzLKtC3K7bgc3ATKB73L7uwAxf6ZDuCA+HkBCoU8d20StZyQEOxLt53FSkIm1pyyd8QiSRtvfrDYtZzHGOex3NcyUhhPAYj/Erv7KFLTZpZ9jBDnay0+tsnHOYQxWq8CM/MpWpadajKlW5lVuTnOT9kA+5gRtoS9s095XcDS4PeZjFLHKRi13sSnNf3jCAAfSkJ7/yq1ftZjCD9rRnPvN9pFnSHOIQt3FbmgY2tpDYY4BdG1ATWA38DUwH8gEFMNE824FFQP6U5GQYV0/LllK1aimflwrcC6JO6uRVx37Vr0LoC33hk749pbu6K4/y2FJ0+rAOK0xhtk8+fqyP5e2Ky3M6pyzKohf1osqrvNqojS26jNEYIfSrfr1s/+/6XQh9ok/SJP8jfaTO6uxRHQB/rV5286N+FEL91d/rthd1UYVV2Lb/g7f4sxAMzgKuIMflkvLnl3r2tF+0XLpBN6iFWiR5/GbdrPIqb0uxj9QQqUjlVm5bq2l1VVflUR5FKMI2mXfpLpVXea/bHdVRHdIh9VRP5VEeW1YXn9M55VEePaAHLtvfSZ2UT/nS/L5v1+1eR5+M1Eif1Y91s1EblV3Z1UANFKXUpRx5Va/KkqXd2m2vckFGUobfScscLOzYYdIt+8C/v5GN7GDHVW4eNxYWz/M829mepD/X18xjHmc4k+ponsToQx9Oczq+mEtaucAFlrI0VYu2ClKQwhSmMY05zWn+5u8065Od7HSjG5OZzAlMqu7d7GYqU3mMx8hBjlTLjiGGcMK5lVu9ared7bzP+4xiVKr7Tg4XLu7jPnKSk4lMJIzUJRjsTW8sLL9GJD3FU2l2Y9qFY/iDBR8u3JrGNCysZBdE3c3dlKZ0wBZ0TWACBSlIM5rZJrMhDalCFdsmeZexjEgivfLvu3BxL/fGF2xxZ4n01i+dFL3oxUUu8h3fAfAxHxNCCE/yZJrkbmADEUTEL9zylA/4gDu5kz70YRnL0qRDYoQQwud8ziQmpakGQglK0Ja2PtExMYSYwQxiiPFLfynhGP5gITwccuaEypVtFz2VqTSgwVWrGROSiUz0pz+/8ZvfVzae4xwzmUknOpHJxkzhFhaP8zir437SylzmkoUsXqX4XcMaJjGJo5i1KCUoQSUqccSmYLYa1KAe9fiKrzjFKb7hG+7jPopRLE1y3ak8vDX8mcjEBCZQlrLcwz3sZnea9EiIezV2QxrSiEZplvct3/rN8O9gB/vYF/j4/Tgcwx8shIebaJ7QUFvF7mIX61mfpJsnIY/wCHnJywd8YKsOKTGb2ZznvK1uHjcP8iDZyc4XfJFmWfOYRxOaeBWRMYc5WFiXuYc2sIG3eTvN+rjpTW82s5lHeIQIItIcwgkmWucu7kpVSoq85GUWsxBiCUvSrAvAcpZTnvL8wA+2yAPIRz5CCOEiF22TmRSLWARAc5r7vC+PSMzxH2zbNT+5GxkphYVJL9pfyWmYhgnh8STWS3pJIQrxeZ7whHRQB12v632WTrmneiqbsiUa0eQpu7VbCH2kj7xqd7NuVn3VT3W/nhChCOVSLiHUVE192pc3eJNSOzkO6qCKqIjKq7xO6ZQtMt0s1VLlV379rb9tlXslHdVRpVTK79lwcSZ3g5j16yE62if+/alMpRa1PC6u/RRPEUoowxluuy6JcZrT/MzP3Mu9hGLv046bx3mcSCKTXOzkCW4fvTcTu4c5zCpW0ZrWl+0/y1lu5VZbnkIAcpCDbnQDsGW0f5GLtmTfzE9+AJawhNd5PVUyYoihC104zWmmMIU85EmzXgmpRjXOcc7nGV0b0YgneRILy6f9eExid4Ng2675Ef+IERJcVUs2rRzQASH0ht7wql0P9VB2ZdcxHbNVn8Rwx6L/qT992s/NulmVVCnVI672au914YwN2qAGaqC1WnvVsZIqaWu91QM6oBEaYUs47k/6SdmUzbbkff3UTwh9q2+9bvu8nhdC3+k7W3RJjIf0kHIqZ6rrFQQzOCP+ICY8HIoVM5uNzIhbFN2Rjl61e47nOM9520akyTGBCZSmNHWp69N++tCHLWxJ1WReFFEsZjEtaenViK0qVfmN36hJzauONaYxy1hmW2reohSlH/28rsWbGL/zOxYWZSlrg2Ym0qc5zelNb37jN6/aVqACz/BM/BONL+hLXyKI4Hu+94n8nezkLGd9Iju1OIY/GPBRRs6pTOVGbqQy3kUKVaUqLWnJSEZygQu26+XmGMdYyEK60MXnj8Bd6EJe8qbqZraCFUQQ4VUYZwwxyX7ZG9OYoxy1PaWEHaxgBfWol+oY+SvJRCYmMpHSlKYjHT2qleDOo9OTnnzIh7bokRR1qUstavE5n/skR34vetGUprbLTQuO4Q80x47Bzp22G/6TnGQpS+lIx1QZ1ed5nsMctjWK4kqmMpUYYnwSzXMl2clOd7ozhSkc5rBXbecylzDCvPryrmAFBSiQ5BOG3fH8dhFBBOtZ73UYZ0rkIx+zmEUMMXzN18mee45zNKABk5lsqw5JYWHxIR+mqFdqOM95VrDCMfwOV+CjjJyzmU0MMR6FcSZGM5pRk5p8wAc+y2I4nvFUoAI1qOET+VfyOI8TTTSjGe1Vu3nM4zZu86p0oTsbZy1qJXq8HOXoRjdKUMIrXXxNOOHEEmu74QfjtlnNat7kzSTPEeIxHiOccNsncpOjCU2oRz3bnzyXs5woooInjDMOx/AHGndGztq1bRU7lakUpzh1SF2mT3cahy1sia8vaycHOcgv/MJ93Oe3SIeKVKQpTfmKr4gl1qM2+9nPBjZ4naZhDnNoRKMkbxYWFt/xHW1o45VcX1OGMrzO6z6rB1uOclhY7GQnH/PxVcc/4zN+4Ade53W/L3bawx4e53GvnwiTw52G+TZus02mHTiGP9CEh0PVqmbVrk2c4xzzmEcHOqRpsu9e7qU4xX2SxmEykxHye+6Sx3mcPezxOCWv+zxv/Pt72MNmNl8VxpkYRznKGc54LNvXlKUsAxno89H2F3zB0zx9WYjtn/zJMzxDa1rzP/7n0/4T4wIX+JIvvX4iTI5FLKIBDQKfhvkKHMMfSCTj6rHZzTOf+VzgQqrdPG7CCKM//fmFX/iLvzxqc57z3MZtfMInyZ43nvHUoAaVqJQmHb2lAx0oTGGP47bnMpdiFPOqXJ/bzXMXdyV73i52cR3XMZGJHsv2JbHEMp/5frkRvc3bNKMZvejF7/wOmM9tcYrzHd/ZEp3kLe4nwi/50uMnwpQYwxje4R1bZNlKYjGe7g2YhSmc4t5mAKOAbsm1s3u7ZuP4t20z8fvffGOr2Af0gAqogC15v70t2D1N00Tcz0iNTPScPdojhN7W22nWLzX8T/+TJUt7tCfZ86IUpdzKrUf1qFfyt2u7RmpkijH/LrlUWIUDXvzbzXqtF0LjNM4v/R3Xcd2gG3Sdrov/X6RldbUdTNIkITRLswKqh12Qyjj+YcAHCbYPgdlAR8uyhvrmVpSB8EFGziiimM1s2tHOloRnuclNb3ozkYn8y78pnj+d6eQlL/dwDwUokOg57hFuoFLU9qY3QIpRHH/yJ2c443W1rRu4waNVmhYWjWjEr/zqkzBCb0ltYrbUkp/8zGIWZznLbGYDJs9PIGlPe4pS1JaVvGMZG7A05ymRrOGX9Gsi2zTgXkhFUnKHy1m50vj2K9nn7ljKUk5zOs1unoT0ox8WFiMYkeK5RzhCW9oyiUl0pSsA//HfZeeMZzx1qWvbAiFvKUUpWtOab/iGKKKSPG8e8wgllNu53WPZ61jHZCYnKzchjWnMPvZ5FNvua1awgiIUoQxl/NZnRSqylKVB4wMPI4xneIaylE1TNJsQAxnIGMbYp5ydJPYY4MkGrEttW2+3a9bVc/PNUpMmtorsrd7KqZyKVKStcrupm3Iqp0eP4gldTMu0TFmURWM0RpL0j/4RQh/qQ1v185bZmi2EJmpikufUUi3dptu8kttHfZRDOTwuH7lBG4TQaI32qh9fUFqlbU0jkZFxf84/1+cB1YPUuHosy8qfyFbOsqwhwCZ/3JiuWS5cgHXrbHXzxBLLdKZzF3clWyA7NTzHc0QQkWzFIveEWEIXUx3qcBu38TAP8yM/MoEJWFjcy7226uctLWlJKUol+Uh/iEOsZa1XYZxCzGEOzWlOFrJ41KYylRnFqIDnaT/AAfawx29unmBHiOUsT/XK9YUsBIIoDfMVpOTj/wtTLP2vBK/HA9mAPr5V7Rpn3TrbM3L+wR8c4Yitbh43NalJc5ozghGJujGEqEKVqxbnZCMbM5hBYxrzIA/yJV/SkIZpLhSSVkIJ5TEeYylL2crWq44vYAHgXRjnJjaxl70ehXG6CSGER3iE4hT3uI0vKExh1rLWL6uo0wO/8RuNaJTq1cOLWEQpSlGOcjZrZg8p+fjLSCob99v9+mZJL0gKnuDj9IgPJnanMpXMZE4xjDC1PM/zHOAA4xl/1bF1rGMb2xI16NnJzixmUZOa7Ge/13VcfcUjPEIYYXzJl1cdm8tcClPYq1XFnoZxXslxjjOa0RzikFft7CSUUGpSk6IUDZgOwUQDGlCe8qma5BViF7toTvPgScN8BSkGy1qWdZ1lWUMsy5octw2xLOs6fyh3TRMeDsWLw/WprxuaECGmMY07uMOr1ALecCd3UpWqDGPYVVEo05lOCCFJrkTNSU6a0QwLi2d4xif6eUthCnM3dzOGMZznfPz+WGJZwAJa0tKrePI1rKEGNbx+mtnHPh7l0Xj3QCAYytD4KlEO5kmsD334nd9Zz3qv2lpYrGUtIxnpI+3STko+/gbAqrg/x8VtACvjjjmkFpszcq5jHXvY4xM3jxsLi+d4jg1suMpITWc6DWlIIQol2tZ9Y2pOcwpTmB3siHenBJI+9OEUpy5bRLWKVZzghNdpGsYzPlWlBqtRjbzkDVjCtvOcZyADbSuTeK3Qne5kJWuqRv0WFtnI5gOt7CGl4cwHQAdJr0maGbe9BnQAH+dKvZY5ehR27bLdzRNCCO1oZ5vMxOhKV4pS9LI0DrvYxd/8TQc6JNnuL/5iJzvjfcjP8iztaBdw49+IRlSi0mVf7nnMI4QQrydcLaz4qlPeEEpofDx/IFjJSmKIcSZ2ryA/+elKV+Yz36uVvF3pyiAG+VCztJOS4c8tae2VOyWtAx/5EzICPsjIOY1pNKIRBSlom8zEyEIW+tGPhSyMfwTOTnaGMCTZp40JTCCMsPiiMN/yLRWpSHvaB3SkaWHxOI+zkpWsYQ1g/Pt1qZvkArTEeJZn6U//VOvRmMbsYAcHOJBqGanFvXDLV4nZ0jPv8R5b2epxWdDznGcqU4kk0seapY2UDL9lWVa+RHbm96CtQ1LYnJFzG9vYxCafunkS8hiPkYMcfMAHABShCIMYRClKJXq+CxcTmEALWpAP83EqQAEWspBylKMtbVNVGcsuHuIhspGNL/iCYxxjFau8cvO4cPE933OUo6nWwZ2ff1W8Z9V/rGAFlamcqqeVa52CFCQLWYgl1qPV1cGahvlKUjLeHwELLMtqbFlWrritCTA37phDanBn5MyRwxZx05gGkKyrxU7ykY+e9OQnfmIDG5jO9GRHOH/wB/vYd1WoYCEKsZjFlKQkb/N2wNIW5CUvXenKD/zAJCYh5FUY5ypWcZSjXoVxXklNanKQg7SnfaplpJb/+M9x8yTDBjZQnvIsZ3mK5wZrGuarSGxVV8INaAMsA47HbcuAtim1s3O7plbuulxS3rxSr162iayrurpZN9smzxN2a7dCFKIWaiGE1mldkuc+qSeVVVmTLGZ9UAcDXuh6lVYJodzKrQIqoBjFeNx2kAYpRCE6ruM+1NC3eLrSOCNyTueUV3nVRV1SPLemaqqpmvpBK88gtcXWJc2W1EhSgbitkaTgzDyUHti+HU6dss2/v499rGSl39w8bkpTms50jh+xV6d6oufFEsskJtGGNkmGmRahCLnIRQQRdKQjq1ntS9UTpQ51qE1tznCGFrTw2KcLJn7/Fm5Js6tkNavpQIeAxPN7utI4I5Kd7DzMw0xlarL/GxcuGtGI+7nfj9qljpTCOUdalvVxUpu/lLymsHnh1nSmA8RPmvqTvvQlhhhKUzrJhSq/8iuHOezRitBTnGId67iTO1nLVTEFPqdP3GJ0b/37DWlId7qnuf9YYpnBDL/Od7zACzzJk37rL73iLts5ilFJnhNCCCMYQU96+lGz1JHSiD9huobEtgxLLLH8zu/eZ/ALD7c1I+c0plGZylSggi3yvOEIRwDYwhaiiU70nPGMJyc5PVrNWpziLGUpOcnJHdzBBjbYqm9KPMRDjGWsV+miQwhhOMPpRa80938TN5GDHH4N65zK1KuypzpczY3cSHOaJ1ukZQ97iCHGz5qljpRSNoxNbvOXksHI27xNAxowFC/LEoSHw803Q6jnroSkOMYxfuVXv7t53PzCL+QmN0c5mmhOkyiimMIU2tPe48UspSnNUpaSlazczu1s8mMuwDDCeIiHyExmj9v8wz+2VWsKI4wGNPCb4T/MYXay05nY9ZDXeC3JynJCNKaxLU9+/iAlV8/M5DZ/KRls7GQnb/EWOcjBQAZ6/kW9cAHWr7fNzTOTmbhwBcTNAzCSkfzN31SkYqJpHBaxiBOc8DrxVznKsYQllKBEQErweUoUUdShDs/yrG0yG9OYTWziGMdsk5kU/i68kt5pSEPa0S7R+Z8d7GAve2lIwwBo5j0pfatuAYoDy7m6GtcHvlUtOBGiH/0II4zVrOYGbqArXTnM4ZQbr11ra0bOaUyjFKWoRS1b5HmLhUUpSvEcz7GGNfzCL5cdH8948pKXO7nTa9k3ciOrWU0lKiGUphh5X7Gc5ZzlrFeFWlKiGc2oS12/TPCuYAVZyMJN3OTzvq4VjnGMV3mVney8bL87z1Gwx++7ScnwFwH+B1QFRgB3AMcUV43Lkw4sywq1LGutZVmz4/4uY1lWuGVZOyzLmmBZlufP1UHAdKbzMz/zOq9TkYpMYhInOUk3uqX8yG/jxO5ZzrKABdzN3QHJADiIQfErVbvRjeu47rI0Dhe4wHSmcw/3eOU6SYj7fQ1hCDdxE7vYlWa97eRnfiYLWWw1/PWpTzjhVKWqbTKTohjFuJ/7nYgeL4giiqEM5Qu+uGz/IhZRkpLcwA0B0sxLEovxTGwDsgA9gKPAk160exb4EZgd9/dE4L64118AfVKSESxx/Gd1ViVUQtVV/bIqU9/oGyE0WIOTF3DffVKJErboMl7jhdAyLbNFnjfEKlbFVEx36+74fW/oDSG0URslSVM1VQgt1MI097dO65Rf+VVSJVMskO5PKqiCWqiFT2RHKconch3STid1Un7l13mdlyTFKEZ5lVeP6tEAa3Y1JBHH76nBvxuYhMnUORAollK7uLbFgcVAM0yRdgs4BmSKO34LMD8lOcFi+F/QC0LoN/122X6XXHpQD8qSpUValLSAMmWkTp1s0aWLuug6XefVQiO7WKmVQmicxsXvO6ZjyqZsekSPSJLu1b0qpEKX3SDTwl/6S3mVV2VURvu0zxaZaWGHdgihERphu+wxGqPsyq4TOmG7bDfndC4gn51rgcVaLITGaqwkY/gXaqHWam1gFUuEVBl+TBrmNcCbQNXkzk2i/WSgNtAkzvAXBHYkOF4C2JhE296YcNLVJUuW9MMlSp6N2qhMyhRv2K4kQhGqpEq6TtfpgA5cfcKRI+Zyv/demnWJVKRyKqd6q3eaZaWGl/WyQhV61UrVJ/SEMiuztmu7simb+qqvrf2u1ErlVm5VURXbbiip5aIuaqEWJv6/TiO/6BchNEMzbJft5h29o1zKFfAV0+kRl1yqoAqqp3qBViVFkjL8Kfn4uwHlgaeB3y3LOhO3nbUsK9kKXJZltQGOSEpVvL+kryTVkVSnUKHEc7z7CyH60pfc5OZd3k30nBzkYDKTiSCCrnS9Op7Xxoyci1gUv8o1EExnOk1octVK1Wd4hmii6UhHIom0vYzfzdzMVKbyHu9dVtc3EGQmM81p7pOKVfWoRxay+DSscwUruJ7rfVa051rGwqIf/ShBCSKJ5Bu+CUhyvTSR2N3Ajg14B9gP7AEOAeeBH0iHrp5xGieEvtJXKZ47VmOF0Ct65fIDAwdKoaFSRESa9XlEjyi3cuuiLqZZlrdc1EX1UZ/L3DwJuUf3CKFiKqZYxfpUF1/LT4oIRehlvazt2u6zPhqpkWrLN5/7WMUqv/In+fTq4DnndE6ZlVnP6blAq5IopNbHb8dGnKsn7vUkLp/c7ZtS+0Aa/pM6qet0neqpnseG5hE9IkuW5mnepZ133inVqJFmfaIVrQIqoAf0QJpl+YI/9IcQekbP+LSf9/W+mqppQIz/DM0QIvn5nDQyUAMVohCd0inbZW/WZiE0SqNsl53RGKERQlz+XQ8ikjL8gVgd8yLwrGVZO4ACkEzyiyDgVV7lGMf4nM89Xkw0kpFUoQrd6MZ+9oPLZVw9Nrh5fuM3jnM8YG6eDWxINk1Ffeoznem8yqs+1aMQhVjKUr7ma5/2kxhzmEMucvk09W5HOvI6r9u2Kjgh7oVbwVL0Pr3yD//wNE8DpJuFW/EkdjcIti1QI/7VWi1Llvqpn9dtt2qrciqnGqqhorduNA9Xo9I+wnpKTymrsipCaXcZecsBHRBC7yntE9RpxSWXmqmZciu3/tN/fu23uIpfFsqa3liv9Xpdr8slV6BVSfcUV3HdpJsCrUaSEEQj/nRBLLH0oQ+FKczrvO51+wpU4Cu+4jd+49XoF83ONI74FVewvCUtyYE9RVy8YSYmS4c3RUp8hYXFl3xJFFH0o5/f+t3ABvaz36Okc2nlFKc8Kv7hLdWpzkAGBmTh37XGP/wT/wSVnnAMfxJ8zdesYhUf8iF5yJMqGV3pymM8xrtV5zC7czaoWDFNOq1mNfvZHzA3zzSmUY5yVKFKQPq/khu4gdd4jRnMYCtb/dLndraTm9x+Mfzv8R5NaUoEEbbJPM1pFrOY85y3TWZGJhvZyErWQKvhNY7hT4QjHOFlXqYZzdIckjic4dTclo3u30SzNzRt6W+nMpVMZKINbdIkJzWc5jRLWEJHOgbVSPE5nmMd66hI2m6qnnIP93Cc4z4J47ySxjSOT/9tF7/wC81pHl9Y3iFj4hj+RHiBFzjHOT7l0zQbuayRYlL7KKIzh9CFLkQRlSo5QkxlaqLx8/5gLnOJJtpvdX09JYyw+CeQbWzzaV+Kyz7qrzUEDWhAKKG2xvOvYAWZyUwd6tgm0yH94Rj+K1jGMsYylud53p5R5Nq13LAtllF/9+NP/uRlXk6VmC1s4R/+CVju/Q504Gd+pj71A9J/SnzP91SiEn/wh8/6GM94qlLVb4VLcpKTOtSx3fDXpna6dE842Idj+BMQTTR96UspStkXjhiXkbNziWd5kif5kA+ZwQyvxUxlKhZWwEbcWclKK1p5VYvWn7SnPcUoRm96p/qpKiXmMIcjHPGLm8dNYxqzkpW2+OQvcIHVrHbCOB0cw5+QEYxgE5v4mI/JTnZ7hIaHQ4kSULQowxhGHerQne7sZrdXYqYylfrU96vRcfMbvzGQgZzmtN/79pRc5OIzPmMjG3mf922XH0ss85hHK1r5tThMH/rwF3/ZMkL/i7+IIsopvOLgGH43+9jHYAbTlra0o519ghMs3MpCFiYyEYB7uZeLXPRIxB72sJa1AXPzfMd3DGd40Odtb0tbOtOZN3iDf/jHVtnhhHOc436J5klIaUpTjWq23GzqUpdVrLK1foBD+sQx/HE8wzO4cDGCEfYJPXoUdu++LH6/DGUYwxhWs5oBDPBIzDSmAQQkjDOWWGYwg1a0Shd+4RGMoAhFbJ/oncMcQgmlBS1slesJ85lvy1NMGGHUoQ65yW2DVg7pGcfwYyJWpjCFV3mVMpSxT3ASFbc60IFneIaRjEy0SPmVTGUq1alOOcrZp5uHhBPOYQ4HbO2AtxSlKNvZTlva2ir3Vm7lFV4hL3ltlesJC1jAQAZygQupliHES7zESlbaqJlDeiXDG/5IInmSJ6lABZ7jOXuFh4dDaCjUrn3VoaEMpR71eIRH2MGOJEUc5jArWBEwN890phNGmN9dHGkhjDBcuBjFKNtq17amNUMYYossb2lMYy5ykXDCUy1jO9t5l3dZz3obNXNIr2R4w/8u77KLXXzKp/b7sMPDoVo1yH71RHFmMjOBCWQiE53pnORobgYzEAqY4Y8iita0TvXq5UDxL//Sl748wzNplrWJTQGt93sbt2FhpSms051WwJnYdYAMbvi3s52hDKUrXe2f8PIgI2cpSjGOcaxjXZIGaipTKUc5vxTfTozhDGcqUwPSd1ooQxle5VXGM56f+TlNsl7hFZrSNH4Bl7/JRz6qUz3Nhj8vef22wtkhuMmwhl+Ip3iKzGTmAz6wv4N//oHTp1NMzNaGNrzAC3zBF/zET5cdO8UplrCEu7k7IGkS3LHjwZSiwRte5EUqU5k+9El1vpuLXGQRi2hN64Beh8Y05hCHkk2JnRwrWMGt3OrXUFSH4CXDfgqmMIX5zOdN3vRNbLx7Yrdu3RRPfZM3aUADetP7smiUOcwhmuiAuXka05ge9AhI33aQmcx8xVfsZS+DGJQqGctYxjnO0ZrWNmvnHe/zPpvYlCrDfZ7znOKU4+ZxiCdDGv6znKU//alJTfrS1zedhIdDrlweZeQMI4zxjCcrWelM5/iR9jSmUZSi1CXlm4fd7GMfq1md7l0DDWjA67zOndyZqvZzmENWstKUpjZr5h2ZyZzqttnJzgEO8DzP26iRTURFwQcfQP/+5rWDXwhsxeoAMYQh/Md/TGay7xJuhYfDzTebqB4PKE5xvuM7WtGKfvTjYz5mLnPpQY+APJ6700qklzDO5BjIwFS3ncc8mtLUvpXcaeAlXuI//uM7vvO6rYWVppuHT5g/H/r1M25RgD17YOJEyBxkel6DZDjDv4ENDGc4vejlu4RjkZHw998wwLMFWm5a0pKXeImhDOUkJznPeYpT3Dc6psB0plORilSgQkD6t5tYYhnMYPKT36tIn+Us5yQnfaiZ50QQwTSmEU00YYR53K4b3ahAhTTdAH3CJ5+YIIg5c2DXLvjwQzh2DK6/PtCaXfNYpjpXcFOnTh2tXr06zXJcuGhEI7aylW1sowAFbNAuEX7/HRo0gOnToX17j5sJ0Zve/MiPnOc8oYSSk5yEE+5XA3ySkxSiEAMYwDu847d+fU1HOjKf+WxgQ0AWwyUkOjqa/fv3c+GC54uyznGOYxyjCEU8Dj0WYh/7yEnOgKTzvgyXC86cgRw5ICwMYmMhJAQs69LxkBBw2yQrfQYVBIKsWbNSvHhxwsIuHxBYlvWXpKtycGeoEf84xrGCFYxilO+MPiS5Yjc5hHiRF/mGb3iSJ5nMZJrSlEUsoh3tCCfcb6tGwwjjS77kFm7xS3/+4hM+oRKVeJzHWcCCFKN0XuZlqlOdrnS1XZf9+/eTK1cuSpcujeWhgYsmmvWsp0jcjydEEMF5zlOWsoEz/BKcOgX79hmDX7iw2ZI6999/ISYGypY1NwKHZJHE8ePH2b9/P2XKeJZ5IMNc1ROcYAADuJVbfR+pEh4OJUtCEc++nABv8zbv8z596cvHfMw2tjGGMUxhCrvZzX3cRyyxPlT6EjnJyaM8SmUq+6U/f1GMYgxlKItYlKKf/Cxn+YAPWMtan+hy4cIFChQo4LHRB3NDzkpWznLW4zbuMNac5PRaR1uIjDQ+/J07zXxXhQpJG30wo/xs2cyNYtcu8xTgkCyWZVGgQAGvnh4zjOH/H//jJCf5nM99P1kaHu7VaP9bvuVVXuVBHmQkI7GwyE1uMpOZ27iNz/iMtaz1OpVzaogkks/4jCMc8XlfgeBxHudWbuVFXkw2O+oiFhFNtE9TVXhj9N0UoIBXE80RRJCFLIGb2D16FM6fNwOhypVNpFtKFC5sUpk7xt9jvP0sZQjDv5KVfMVX9KMf1anu286OHDHRCV4Y/pa05HmeZzSjE70p9aQnW9nKDdxgo6KJs4hFPMETrGOdz/sKBCGEMJrRzGd+sn7yOcwhD3mCLva9KEUpRjGPz89KVv+6eCQzQRsRt2Du+uuhalW47jrvfPYJjf+ePb7QNENzzfv4Y4mlD30oSlEGM9j3HXrh31/JSm7iJopSNMW0u/nIhwsXgxlMK1r5zP8+nenkIQ9NaOIT+cFAwony05y+Kg+RED/zM3dyp1fRM/5CiBhiPNLNr1Fh587B3r3md8GCkDMnZEqDiSlc2NwssgZ/OvD0xjU/4v+CL1jDGj7iI//kIXdn5LzppmRPm898GtKQ13ndY9FnOcuP/EhHOrKf/WnV9CpiiWUmM2lN6+CL+fYBAxnITdx0VVnD4xynLGXtLchjI5vZzL/8m+J5scT6NL/Q8OHDOX/+PERHm1H5li1mEVbp0lCqVJLtBg0axKJFizzr5LrrIHfc9/bMmavcPk2aNMGOiD83M2fOZOjQobbIsls3W5EU9Fvt2rWVGg7qoPIoj+7QHXLJlSoZXtO8uVSzZrKnLNdyZVM21VANndRJr8Rv1EblUi7VVm2d07k0KHo1y7RMCE3URFvlBiu/6BchNEAD/N735s2bU912t3Zrjdak+Jneoz1ar/Vp+uzHxMQkeaxUqVI6evSodOiQtHq1tHevFB2dYrtUcf68tGqVtGOHFBsbv7tx48ZatWqVvX3ZhL91S+wzBaxWIjb1mnb1DGAAkUTyCZ/4J8GWOyNn16TD/9awhta0piQlWcACr0M0q1CFH/mRdrTjUR7lR3607b25a7u2pKUt8oKdxjSmJz35kA/pSldqUQswE9zZyOY/Rfr3h3XrPD69GNEU4AIuchCa1EN7zZpEDO9FVrIm+fnYs2cPLVu2pHbt2qxZs4YqVaowbtw4KleuTJcuXVi4cCEvvPAC+fPn57XXXuPixYuUK1eOb7/9ltGffcaBAwdo2rQpBQsWZOnPP5OzUCEee+wxFi1axKeffsqSJUuYNWsWkZGR3HrrrXz55ZdYlkWPHj1o06YNnTp1onTp0nTv3p1Zs2YRHR3NpEmTqFixIufOneOpp55i48aNREdHM3jwYNrXr0/k9u08/PTTrN+5k4oVKxIZGZnsterTpw+rVq0iMjKSTp06MWSIqamQVL9jxoxh9erVfPLJJ/To0YNs2bKxdu1ajhw5wujRoxk3bhx//PEH9erVY8yYMcn2kWZi46L4PFz97w3XtKvndm7nLd7iRm70T4fbtpnH0ST8+9FE04lO5CUvC1nIdVyXqm7a0IZ3eIcpTLG1sEZ/+nOQg+TCg8iLa4T3eI+CFKQXvYgllqMcJT/5GcvYQKuWJKEYQxBLTJLnuHARSWSKYZzbtm2jb9++bNmyhdy5c/PZZ58BUKBAAdasWUPz5s158803WbRoEWvWrKFOrVp8OHAg/Zo14/pChVi6ZAlLly6FbNk4d+4c9erVY/369TRs2JAnn3ySVatWsXHjRiIjI5k9e3aiOhQsWJA1a9bQp08fhg0bBsBbb71Fs2bNWLlyJUuXLmXAgAGcy5mTzxcvJntICFtmz2bIa6/x119/Jfv+3nrrLVavXs3ff//Nr7/+yt9//51sv1dy8uRJ/vjjDz766CPatWvHM888w6ZNm9iwYQPr4m7WyfWRJkJDTUSUD7imR/x+zyyZwsRuGGH8xE/kJz8lKJGmrl7gBdrT3vYkaoEoLRhI8pGPj/mYXvRiE5tYz3oucIEqVPGfEsOHe3V6CLCbv8lO9iQjvc5yGtieouEvUaIEDRqYyKVu3brx8ccfA9ClSxcA/vzzTzZv3mzOiY4mKjKSW6pVg6JFzWKsBJE6oaGh3HPPPfF/L126lPfee4/z589z4sQJqlSpQtu2V5fEvPtuk322du3aTJ1qaj8sWLCAmTNnxhvkCxcusHfvXpatXUu/7t3h5EmqlytH9erJR+lNnDiRr776ipiYGA4ePMjmzZvj2yTW75W0bdsWy7KoVq0ahQsXplq1agBUqVKFPXv2ULNmzWT78Jrz580EeenSZlLbk/DXVHBNG36/s3KlmYi6IiPnAQ4wn/k8zMPUw/Mwz+SwsOKN/kQmUpnKaSrWMpShrGAF05jmu8R1QUpnOtOMZhSkIG/zNoUpzE0kPzkfaEpQItn/k3vhVg5yJCvnyvhv9985cph2krjjjjv46YsvYPt2yJvXhFlmuToUNmvWrITGuSUuXLhA3759Wb16NSVKlGDw4MFJLjDKEicrNDSUmJiY+H6nTJlChQqJpCrJlw8qVTKpH5Jh9+7dDBs2jFWrVpEvXz569OhxmQ6J9ZuUbiEhIfGv3X/HxMSk2IfHxMbCwYNw6JC5oUZF+TSa6Zp29fgdd0bOBMvMj3OcO7mTfvTjIAdt7zKCCPrTn3a04xjHUi1nAhM4yckMZ/TB3EQLUpBoopnABFrRKugLluQjX7IuuTzkoQQl4t1CSbF3717++OMPAH788UcaNmx46eDZs9S/4QZWrFjBjiNHoGJFzhUtyj//moiiXLlycfZs4quI3cavYMGCREREMHnyZG/eHi1atGDkyJEoLm/P2rVmBXWjRo348ccfIUcONm7caNwqBw4kusjrzJkz5MiRgzx58nD48GHmzp3rlQ6eYEsfZ87A5s3G6BcsCFWqXIpk8hHB/elOT7gzciZw85zhDC1pyQ52MItZPin4kpOcTGMaBzhAZzoTTbTXMvawh3WsuyZSMKeFMYwBSBeT20Kc4UySlcVykpPCJJMaIY4KFSrw6aefUqlSJU6ePEmfPn3MIqydO2HbNgrFxjLm22/pev/9VL/1Vm655Ra2bt0KQO/evWnZsiVNm15dqyBv3rz06tWLqlWr0qJFC26++Wav3t/AgQOJjo6mevXqVKlShYEDTWbRPn36EBERQaVKlRg0aBC1q1c3i7x2776U3C2OGjVqUKtWLSpWrMj9998f79KyE1v6OHXKuMwqVDAunrSsffCUxEJ9gm1LbTinX/ntNwmkGTMkSed0To3USJmUSbM0y+fdj9M4IdRXfb1uO1zDhdB2bfeBZumHWMXqF/2iWMWmfHIaSUs4pyS55NJ6rdcO7bjq2EVd1BmdSfF97N69W1WqVEnQ8KK0a5cJm1yzRjp48LLQyaDl4MFLoZ4uP4VtpwWXSzp2TDp71vwdE2PLdfYmnNMZ8dvFFRO7C1jAb/zGd3xHG9r4vPsHeZABDOAzPmMFK7xqO53pVKWqX1JCBDMhhNCYxkHv5gHjnspJTs5y9qpFWic5yTa2EZNM1E+ixMTAyZNmxWy1aibJYHrIjlmkCBQvbnTfteuqkX9QcfGimSvZvdvkMQITvePn6+yzZwrLskoA44DCgICvJI2wLCs/MAEoDewB7pUUHJUu0kJ4uFmtGJd5sAMd2MpWylPebyq8wzs0palX+WWEaEEL36apdvAJucjFCU5wgQuXrTuIIILMcT/JUbpkSTYuWmSiSEqWhOzZoXp1/7gabKZe+/ZcPHfOTJLGTcJ+99138VE4AUeCw4fNfASY612oUMDU8eV/OAZ4TtIay7JyAX9ZlrUQ6AEsljTUsqyXgJeAF32oh38ID0d1b6Y/T9ORjjShiV+NPpj47la0AmAta8lLXsqQfH5uC4uXeMkf6jnYjHtyN4KIeMMvRAQRya/FkOD4cWOEoqIgT55LRVDSodEHCHc/cUvGXx4T45OFT6nm+HHYv99ERZUsGfDykj77L0s6CCaMRdJZy7K2AMWA9hCfAWws8Avp3fAfPoz+/Zdnp5TkYyZTgAIBTXJ2kYu0pS35yMfv/J6sEfiDP6hO9RTD/hyCjyxkIYwwIoigEGb0GEUU0UQnHb9//rxxM0RGmhF+6dI+jyDxK5ZlbmLbtpm8/mXKBK6SV2wsXLhgwk4LFDBhmrlzB0VlMb84lizLKg3UAsKBwnE3BYBDkHjogWVZvS3LWm1Z1uqjbl9YsBIezpDXYHjt5fSjX8Brm2YhC2MYwxa28CAP4iLxfObnOEczmvEKr/hZQwc7cK/lKE3p+H1JFl5xhzu6S/OVLWti4a8lo+8mJMQY2hMnEo328QunT5sQze3bzQ3AssyTVRAYffCD4bcsKycwBegv6UzCY3Gzzon+VyR9JamOpDqFAugL84SPQkcyZDD0iOnGR3zkn7xAKdCc5nzIh8xgBoMYlOg5C1jABS7QHs/rAjsEF1nIctnnLR/5qEjFSz7/CxdMaOY//xgDGBZmCqLkzx80RsgnuCd8T5wwE74Xky66YyvR0aa/7dvN9S1XLrhcTnH41KFnWVYYxuj/IMm9JvqwZVlFJR20LKsopO9ST0KsybyRexbl5evm3wZVRMhTPMXf/M1bvEUTmtCc5pcdn8508pGP27gtQBo6pJVYYvmP/8hNbvKSlxBCzGg/OtqsBD161BigwoUv+b+vZYOfEHfp0/37zQ2vZEnz5LN5s/GxJ9xy5DCuobQQFWVkx8aalBZFiwZtVJTPtLLM2u9RwBZJHyY4NBPoHve6OzDDVzr4mhhisFxibOdz/Di9c9CterWw+IzPGM7wq+YcYohhFrNoS9ug09vBc0II4QQnOMlJYollH/uIPH8cNmww1eAKFjQVsIoVs90Ixefj9xKv8vGnQIo574sUMU84bq+By2VSIcTGGnfMgQOmlsDp0+b4xYuwdi1s2mRG7f/+a26g7iygLtfVq4TdWTQzZzb9VK7sk+ttJ778xjcAHgQ2WJa1Lm7f/4ChwETLsh4F/gXu9aEOPuMP/qAnPZm3cyQlTp8lc51bA61SomQmM0/zNACHOQxAYQrzO79zkpN0oEMAtXNIKxYWuZSLs5whIvokhzMfJk/WG8iWP78xemnM9xIbGxuff+dKhg8fTrdu3cie/eoawMm1e/11z4sP2UJC/TJlghsSrFdxuczTkdtIW5aZH4iKIub8eTKdO2cihDJnNk8E586ZieNMmcy+sDCzr2JFc62LeV4WM5D4MqrnN0jS2X27r/r1B9FE05venOUsuVea5eve1NgNBDHE0IQm5CMfS1nKbdzGWtb6L2W1Q5L0p79nNY7FpW9UdDTExILLRXRoLBeyQphlES2RMyQntUrXYjjDkxWXpnz8o0dfno9/6VJy5szp23z87dsTGRnJww8/zPr16z3Kx58zZ0569erFggULKFKkCOPHj6dQoULs3LmTJ554gqNHj5I9e3a+/vprKlasSI/evcmaNStr166lQYMGtG/fnqefNgMny7JYtnAhOa+/nheGDGHu0qVYwKtPPkmXypX55ZdfGDx4MAULFmTjxo3Url2b77//3utC6P4geJ9FgpgRjGAjGxnJSPL8tsHM1ieWRTCIyEQm3uAN/uAPHudxAGpSk+xcPVpzCAJiXRAVDRcuwvlIiDhnCpi7QyFiY+OjRUItE6kTHSZCCfUquMDrfPx16vDhhx/Sr18/rr/+epYuXWry8YPv8/GfO8fnn39O9uzZ2bJlC0OGDEkxH/+5c+eoU6cOmzZtonHjxvFFUnr37s3IkSP566+/GDZsGH379o1vs3//fn7//Xc+/PBDhg0bxqeffsq6detYvnw52fLmZeoff7Bu1y7Wb9nCouXLGTBsGAePHwdMMrnhw4ezefNmdu3axYoV3q2i9xeOc9dL9rKXwQymLW1NNEz4kKsycgYrnejEa7zGEIYwhjHsZW+a6wI4pBLJ+I0jIxl+8UUTfXPhApQvb9wIh/4zvuWQEONCyJLFuBpyFAErBLIIshoDL8QmNnGBC1xnXUdJSnqshlf5+IGoqChuueWWRGX5JR//smX069cPgOrVq6eY9z4kJCT+vXTr1o27776biIgIfv/9dzp37hx/3sUEUT+dO3eOd1M1aNCAZ599lgceeIC7776b4sWL89tvv9G1a1dCQ0MpXLgwjRs3ZtWqVeTOnZu6detSvLgpcF+zZk327NlzecbTIMEx/F4ynOG4cPExH5vFMH//DS+mn/VngxjEEpawnOX+LS+Y0YmOhpEjoUMHE0MfEWEmEN1kznxp0jFTJlNkvGBBsz8xV0GCfRYW5SnPFrZ4vRDP43z8P/2Uoiy/5eNPA5Zl4XK5yJs3b3wFrSvJkSDP/0svvUTr1q35+eefadCgAfPnz09WfsKc/cnl+Q80wT9MDTLe4z1+5VezaGbNGvNFDXL/fkJCCOEXfuEQhyhIwUCrkzHYsAHq14fnnoO4lMZky2ZuAJUrQ61aJkfOjTdeKnASFmZee+gfzkIWalCD/OT3SrVk8/ED9evXN/n4d+wAjOvkn3/+AQKcjx8u5eNPBpfLFd+3+/3lzp2bMmXKMGnSJMDcZNavT7yE6c6dO6lWrRovvvgiN998M1u3buW2225jwoQJxMbGcvToUZYtW0bdunW9en+BxjH8HnKe85ziFJnIxM3E5RZPodRisBJCiEe52h3SSHQ0vPkm1K4N+/bBpElw113mWKZMZhFV9uy2LfCx4n68IdF8/AkoVKgQY8aMoWvXrlSvXj348vHXrp2snBw5crBy5UqqVq3KkiVLGDTILGb84YcfGDVqFDVq1KBKlSrMmJF4VPnw4cOpWrUq1atXJywsjFatWtGxY0eqV69OjRo1aNasGe+99x5F3GsG0guJ5WoOti0Y8vG/pJdUREV0Qicu7ezcWSpVKmA6OQQ5ffqYGg333ScdPXrZobTm47eDq/LxX4PkyJEj0Cr4DW/y8Ts+fg/YxCaGMYxudCMf+S4dCA83j/AODm6io01cd968xrVz++2QYMLTwSEYcAx/CgjRl77kIhfv8d6lA4cOmTzmcTG+Dg78/Tf06GGKkU+fbvK0lCsXaK2SpHTp0mzcuDHQathCvXr1LovMAZOPPyIi8dKUGR3H8KfAOMaxjGV8zdfxqW+RYOhQ8/rW4Fyx6+BHoqPhnXfgjTfMqs9BgzJOPpwgIT4fv4NHOIY/BZaylFu4hUd45NLOgQNhxAh48sl0N7HrYDM7dkDnzrBuHdx/P3z8sTH+Dg5BjGP4U+BbvuUsZy9l3XzzTXjrLejVyxh/Z2SXscmXzzwBTptmYvQdHNIBTjhnEvzN3+xiFxYWuYkrVjFsmBntP/ggfPFFulit6+AD1q2Dhx82ybsKFDDZHB2j75COcCxXIsQQw4M8SCtaXape9cknMGAAdOkCo0c7Rj8jEhUFr71mUnTMm2cKnIDz1OeQ7nCsVyJ8zMf8zd8MZahx8Xz9NTz1lBnVffddui1I7ZAG1q41Bv/11+G++0y6hSBPzGc3Y8aM4cCBAz7tY/r06WzevNnrdjNnzmSoO+AijQwePDg+R5AdHDhwgE6dOtkiyy7dHAt2BfvYxyAG0ZrWJlf9uHHw2GPQqhWMH3+pZqlDxsHlgu7dTTWrGTOgXTv7+2jS5Op9994LffuanFDuFb8J6dHDbMeOwZWG5ZdfbFdxzJgxVK1aleuvvz5NcmJiYsiUxOBp+vTptGnThsqVK3vVrl27drTzxf/FBq6//nqvU1b4GmfEfwX96Y8LFyMZiTVhovHlNmsGU6ZcyqPikDFYu9YkUwsJgYkTzSg/SI1LatizZw+VKlWiV69eVKlShTvvvJPIyEjWrVtH/fr1qV69Oh07duTkyZNMnjyZ1atX88ADD1CzZs0k8+CXLl2aF154gWrVqlG3bt34HD89evTg8ccfp169erzwwgvs3LkzvhbAbbfdxtatW/n999+ZOXMmAwYMoGbNmuzcuZMmTZrQv39/6tSpw4gRI5g1axb16tWjVq1aNG/enMOHTXGhMWPG8OSTT8b31a9fP2699VbKli17mdF9//33ufnmm6levTqvvfZa/P633nqLG2+8kYYNG7Jt27Zkr9vXX3/NzTffTI0aNbjnnnviq5Al1e+ePXuoWrVqvJ4dOnTgjjvuoHTp0nzyySd8+OGH1KpVi/r163PixIlk+7CNxJbzBtvmr5QN0YrWE3pCQzVUmjZNCg2VbrtNiojwS/8OQcKFC9Krr5r//4sv+qSLYEnZEBoaqrVr10qSOnfurO+++07VqlXTL7/8IkkaOHCgnn76aUlS48aNtWrVqmRllipVSm+++aYkaezYsWrdurUkqXv37mrdurViYmIkSc2aNdM///wjSfrzzz/VtGnT+PMmTZoUL69x48bq06dP/N8nTpyQy+WSJH399dd69tlnJUnffvutnnjiiXgZnTp1UmxsrDZt2qRy5cpJkubPn69evXrJ5XIpNjZWrVu31q+//qrVq1eratWqOnfunE6fPq1y5crp/fffT/I9Hjt2LP71K6+8oo8//jjZfhOmxvj2229Vrlw5nTlzRkeOHFHu3Ln1+eefS5L69++vjz76KNk+XnvttSR1c1I2pJJMZOITPoGff4Z7Oxif7pw5phCzQ8bgr7+M+2TjRuPeSUcpt1NDmTJlqFmzJmDy4e/cuZNTp07RuHFjALp3735Z3npP6Nq1a/zvZ555Jn6/O899Svnwr8SdTx9MkZQuXbpw8OBBoqKiKFOmTKJtOnToQEhICJUrV45/KliwYAELFiygVq1aAERERLB9+3bOnj1Lx44d40tIpuQy2rhxI6+++iqnTp0iIiKCFi1aJNvvlTRt2pRcuXKRK1cu8uTJE1+joFq1avHZRpPrww4cwx/H53xODWpw6+JIuPtuqFYN5s6FXLkCrZqDv/j6a+jTBwoXhtmzoXXrQGvkc67MH3/q1Kk0y0yY4z/ha3ee+5Ty4V9Jwvz4Tz31FM8++yzt2rWLL3WYGAnfl+JSO0vi5Zdf5rHHHrvs3OHDh3ukh5sePXowffp0atSowZgxY/glwXxKYv0mp1tISEj83yEhIfH5+5Prww4cHz+whS08zdN8efh1aNvW5EVfsMAk2nK4tjlwAP7917xu1Misxt64MUMY/cTIkycP+fLlY/ny5YDJd+Me/SeXfz8hEyZMiP+dWLWu5PLhp9TH6dOnKRZX0Hzs2LFevDOT43/06NHx+Xv+++8/jhw5QqNGjZg+fTqRkZGcPXuWWbNmJSvn7NmzFC1alOjoaH744QevdPAUX/eR4Uf87iRsOWOy8n795VCqFCxa5Cy7v9Y5ehTefRc+/RTatDG58itUAC9Hf9ciY8eO5fHHH+f8+fOULVuWb7/9Frg0QZstWzb++OMPsmVLvILbyZMnqV69OlmyZEmyctcPP/xAnz59ePPNN4mOjua+++6jRo0a3HffffTq1YuPP/440UiYwYMH07lzZ/Lly0ezZs3YvXu3x+/rzjvvZMuWLfE3o5w5c/L9999z00030aVLF2rUqMF1112XYu2AN954g3r16lGoUCHq1avn0c3QW3zeR2KO/2DbfDm5O07jhNCX/bJJ5cpJ//3ns74cgoCTJ83Ebc6cUkiI1L27tHOn39UIhsldX1CqVCkdvaL2gIN/8GZyN0O7ek5ykudinqb+qlB6ziwES5ZAGmOUHYKcYcNMvqW77jLhmWPGmBKIDg4ZiAzt6sm5ZR8vjo/i9j/yE7J4KZQsGWiVHOwmMhI++wxq1jRFUZ55xmTTrFEj0Jqlazp27HiVm+Xdd99lz549gVHIBzzxxBOsWLHisn1PP/00Dz/8cIA0so+Ma/h37CDs9pY858oJy5Y5o75rjYsX4ZtvTCbVgwehf39j+AsUcOZvbGDatGmBVsHnfPrpp4FWwWdkSFdPzJ4dtNpXjRm3R8DixSaKx+HaYdIk8z998km44Qb49Vf46KNAa+XgEDRkPMO/fz+ffFePeU0vEP3GIKhSJdAaOdhBbKxJkwxw5AgUKQLz5xuj36hRYHVzcAgyMpbhP3SI/fc3YmD/E7Q6dSv3lH4u0Bo5pBUJpk41PvtRo8y+xx+HP/+EO+90UiY7OCRCxjH8R4/C7bfzzDN7icmemU/yfoeFYxTSLZJZWV2nDtxzjxntxy3sITTUMfgODsmQMQz/iRNw552szL+DyR1jeTV0EGVxJnPTNY89ZkIyT540IZkbN5qFWA4+w8nHf+1w7Uf1nD4NLVvC5s3cPGsms4jmDu4ItFYOnnLhAqxfDytXwqpV8L//QcWKJld97dombXbmzIHWMs00oclV++7lXvrSl/Oc5y6uzsffI+7nGMfoxOX5+H/hF9t1dPLxp53k3oM/ubZH/BERZlS4di0R07/HurMFbWhDFpy8+kFJbKwpOgKwebNx4+TODfXrQ79+JpXG3r3mePPmZtR/DRj9QOHk409dPv4mTZrw9NNPU7NmTapWrcrKlSsBOHfuHI888gh169alVq1azJgxI163du3a0axZM26//XYOHjxIo0aN4tu78yL99NNPVKtWjapVq/JigqywOXPm5JVXXqFGjRrUr18/yayfXpHYct5g21KVssHlklq0kEJDtXXeCOVVXs3UTO/lOPgGl0vavVuaMEF6/nmpUSMpRw7prbfM8WPHpNtvl15+WZo6Vdq/P6Dq2k0wpGxw8vGnLh9/48aN1bNnT0nSr7/+Gp9r/+WXX9Z3330nSTp58qTKly+viIgIffvttypWrJiOHz8uSRo2bFj8NYqJidGZM2f033//qUSJEjpy5Iiio6PVtGlTTZs2TZIEaOZMY7sGDBigN954I1G9nHz8YCb3nnkGdX+Ivi1GIURd6gZaq4zL0aPGVRMSYlxvMTHGZXPxoqlsVrMmPPII3HqrOb9AATPCd/ApTj5+7/PxJ3yPjRo14syZM5w6dYoFCxYwc+bM+PmBCxcusDfuCfWOO+4gf/78ANx888088sgjREdH06FDB2rWrMmSJUto0qQJhQoVAuCBBx5g2bJldOjQgcyZM9Mmbv6qdu3aLFy4MEX9UiIght+yrJbACCAU+EaSPbMyV9KiBT/yA0tYwmd8RmEK+6SbVBMbC2fOmHkI9+/Tp42Lo0gRs+L0998hf37Il+/S75w5gzdqRbqk2zffwMKFxj/vXsp/yy3G8IeFwfffQ5kypvaB47IJCE4+fu/z8cPl78v9tySmTJlChQoVLjsWHh5+2Xto1KgRy5YtY86cOfTo0YNnn32WPHnyJNlXWFhYfH+hoaHxOfvTgt99/JZlhQKfAq2AykBXy7KunsmxgZOc5FmepS516U3vpE+UTEHtmBiIirq0EEiCs2eNUT51ykSQHD9+yQ8dHQ3bthnDtnChqcs7erSJMAHjj+7Z0+SGadHC+KorVTIFuwGWLzfGvEwZE4feqJGpB/Dnn+b4ypWmiHazZlCrlkkZnTv3pULac+caQ9q6NXTrBk89Ba+9Zm4YAPv2wYoVxl9+6JAZXSeGy2Xe4/79sGWLed8Aa9bA2LHwySfwzjvw8svwXIK1D2+/DfXqmfdUvDjkyWN+u5k1C8LDTSWz994zes+ff+l4p05mgtYx+kGDk48/5Xz8Cd/jb7/9Rp48eciTJw8tWrRg5MiR8TeatWvXJtr233//pXDhwvTq1YuePXuyZs0a6taty6+//sqxY8eIjY3lp59+ir/uviAQI/66wA5JuwAsyxoPtAe8j+FKgQUs4GTUEeY1PUvoutyXDHzPnsaYxcZCYjPszz8P779vjGFixViGDIFBg0wRj4oVrz7+wQdQtaqJSJk71xhE91aypPkNJv/7Rx9dOpY7t/ldvrw53qyZKfh98qTZTpwwv90jitBQM/o/fBi2bjXHT5+Grl2haFGYPBmeffZy3bJnN+eWKGGM+Vtvwblzl59z7pw5b9w4GDHi0v6wMKPfsGFmVJ8pk7lxlSplKpXlzg0FC146f+JEp0B9OsTJx598Pn6ArFmzUqtWLaKjoxk9ejQAAwcOpH///lSvXh2Xy0WZMmWYPXv2VW1/+eUX3n//fcLCwsiZMyfjxo2jaNGiDB06lKZNmyKJ1q1b0759e4/fm7dY7ruTv7AsqxPQUlLPuL8fBOpJevKK83qDGaaXLFmy9r/uKklesv/tvhQ/ns0YqpAQs9WrBx07mhvBa69d2u/e6tc3RvfiRRg50uy7sn3dusawT516teEuVMgYzkAQG3tJ1/37zWjffcNw/x4yxNQRnjvX+NHdRjtXLrPdfbcZhR86ZJ5u3McdI24bW7ZsoVKlSoFWw3ZKly7N6tWrKZhwAHCN0aRJE4YNG0adOnUCrcplJPaZsizrL0lXKRq0k7uSvgK+AqhTp06q707F//dZ0gctC15/PenjWbKY0X9SZM0K99+fWtV8Q2jopdfFi1/uermSVq3MlhRFitinl4ODQ9AQCMP/H1Aiwd/F4/Y5ODikEzJyPn67C58HgkAY/lVAecuyymAM/n1AkA2bHRx8j6SrokPSC04+/uDCW5e936N6JMUATwLzgS3AREmb/K2Hg0MgyZo1K8ePH/f6C+vgcCWSOH78OFmzZvW4TUB8/JJ+Bn4ORN8ODsFA8eLF2b9/P0ePHg20Kg7XAFmzZqV4cvN5VxC0k7sODtcyYWFhSa46dXDwNdd2kjYHBwcHh6twDL+Dg4NDBsMx/A4ODg4ZDL+v3E0NlmUdBVK3dBcKAsdsVMefOLoHhvSqe3rVGxzdfUUpSYWu3JkuDH9asCxrdWJLltMDju6BIb3qnl71Bkd3f+O4ehwcHBwyGI7hd3BwcMhgZATD/1WgFUgDju6BIb3qnl71Bkd3v3LN+/gdHBwcHC4nI4z4HRwcHBwS4Bh+BwcHhwzGNW34LctqaVnWNsuydliW9VKg9UkKy7JKWJa11LKszZZlbbIs6+m4/fkty1poWdb2uN/5Aq1rUliWFWpZ1lrLsmbH/V3GsqzwuGs/wbKsoCysa1lWXsuyJluWtdWyrC2WZd2SXq67ZVnPxH1eNlqW9ZNlWVmD9bpbljXasqwjlmVtTLAv0etsGT6Oew9/W5Z1U+A0T1L39+M+M39bljXNsqy8CY69HKf7NsuyWgRE6RS4Zg2/P4u620AM8JykykB94Ik4XV8CFksqDyyO+ztYeRqTZtvNu8BHkm4ATgKPBkSrlBkBzJNUEaiBeQ9Bf90tyyoG9APqSKoKhGJqWwTrdR8DtLxiX1LXuRVQPm7rDXzuJx2TYgxX674QqCqpOvAP8DJA3Pf2PqBKXJvP4mxRUHHNGn4SFHWXFAW4i7oHHZIOSloT9/osxvgUw+g7Nu60sUCHgCiYApZlFQdaA9/E/W0BzQB3teyg1N2yrDxAI2AUgKQoSadIJ9cdk103m2VZmYDswEGC9LpLWgacuGJ3Ute5PTBOhj+BvJZlFfWLoomQmO6SFsTVFgH4E1NJEIzu4yVdlLQb2IGxRUHFtWz4iwH7Evy9P25fUGNZVmmgFhAOFJZ0MO7QIaBwoPRKgeHAC4Ar7u8CwKkEX4xgvfZlgKPAt3Fuqm8sy8pBOrjukv4DhgF7MQb/NPAX6eO6u0nqOqe37+4jwNy41+lC92vZ8Kc7LMvKCUwB+ks6k/CYTNxt0MXeWpbVBjgi6a9A65IKMgE3AZ9LqgWc4wq3ThBf93yY0WUZ4HogB1e7I9INwXqdU8KyrFcwrtofAq2LN1zLhj9dFXW3LCsMY/R/kDQ1bvdh9yNu3O8jgdIvGRoA7SzL2oNxpzXD+M3zxrkgIHiv/X5gv6TwuL8nY24E6eG6Nwd2SzoqKRqYivlfpIfr7iap65wuvruWZfUA2gAP6NKCqHSh+7Vs+OOLusdFNtwHzAywTokS5xMfBWyR9GGCQzOB7nGvuwMz/K1bSkh6WVJxSaUx13iJpAeApUCnuNOCVfdDwD7LsirE7bod2Ew6uO4YF099y7Kyx31+3LoH/XVPQFLXeSbwUFx0T33gdAKXUFBgWVZLjHuznaTzCQ7NBO6zLCuLZVllMBPUKwOhY7JIumY34C7MjPtO4JVA65OMng0xj7l/A+vitrswvvLFwHZgEZA/0Lqm8D6aALPjXpfFfOB3AJOALIHWLwmdawKr4679dCBfernuwBBgK7AR+A7IEqzXHfgJMxcRjXnSejSp6wxYmIi8ncAGTORSsOm+A+PLd39fv0hw/itxum8DWgX62ie2OSkbHBwcHDIY17Krx8HBwcEhERzD7+Dg4JDBcAy/g4ODQwbDMfwODg4OGQzH8Ds4ODhkMBzD75BhsSwr1rKsdQk225KxWZZVOmE2RweHYCJTyqc4OFyzREqqGWglHBz8jTPid3C4Asuy9liW9Z5lWRssy1ppWdYNcftLW5a1JC4H+2LLskrG7S8cl5N9fdx2a5yoUMuyvo7Lmb/Asqxscef3s0zthb8tyxofoLfpkIFxDL9DRibbFa6eLgmOnZZUDfgEk30UYCQwViYH+w/Ax3H7PwZ+lVQDk+tnU9z+8sCnkqoAp4B74va/BNSKk/O4b96ag0PSOCt3HTIslmVFSMqZyP49QDNJu+KS5x2SVMCyrGNAUUnRcfsPSipoWdZRoLikiwlklAYWyhQZwbKsF4EwSW9aljUPiMCkiJguKcLHb9XB4TKcEb+DQ+IoidfecDHB61guzam1xuSiuQlYlSCbpoODX3AMv4ND4nRJ8PuPuNe/YzKQAjwALI97vRjoA/G1h/MkJdSyrBCghKSlwItAHuCqpw4HB1/ijDQcMjLZLMtal+DveZLcIZ35LMv6GzNq7xq37ylMta4BmMpdD8ftfxr4yrKsRzEj+z6YbI6JEQp8H3dzsICPZco9Ojj4DcfH7+BwBXE+/jqSjgVaFwcHX+C4ehwcHBwyGM6I38HBwSGD4Yz4HRwcHDIYjuF3cHBwyGA4ht/BwcEhg+EYfgcHB4cMhmP4HRwcHDIY/wdDz+3lv8OQggAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%matplotlib inline\n",
+ "def parse_val_performance(file_name):\n",
+ " with open(file_name, 'r') as file:\n",
+ " data = file.readlines()\n",
+ " scores = defaultdict(list)\n",
+ " for class_name in class_mappings.values():\n",
+ " for line in data:\n",
+ " if line.startswith(class_name):\n",
+ " scores[class_name].append(float(line.replace(class_name, '').replace(' ','')))\n",
+ " return scores\n",
+ " \n",
+ "fig = plt.figure()\n",
+ "ax = fig.add_subplot(111) \n",
+ "for file_name, linestyle in [['pretrained.out', 'solid'],['not_pretrained.out', 'dashed'] ]:\n",
+ " scores = parse_val_performance(file_name)\n",
+ " for class_idx, (k, v) in enumerate(scores.items()):\n",
+ " name= f\"{file_name.replace('.out','')}_{k}\"\n",
+ " color = [x/255. for x in colors[class_idx % len(colors)]]\n",
+ " epochs_per_eval = tf_train_proto.evaluation_config.validation_period_during_training\n",
+ " ax.plot([x * epochs_per_eval for x in range(len(v))], v ,color = color, linestyle = linestyle, label = name)\n",
+ " \n",
+ " ax.legend(loc=\"lower right\") \n",
+ " ax.set_xlabel(\"Epochs\")\n",
+ " ax.set_ylabel(\"MIOU\") \n",
+ "fig.show()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!ls -lh $LOCAL_ROOT/$EXPERIMENT_DIR/experiment_dir_unpruned/weights"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Prune the trained model\n",
+ "* Note that this is just one of the compression techniques that nvidia-offers.\n",
+ "* Quantize aware training is explained in the original notebook. It can plug right in here.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "From the original nvidia notebook:\n",
+ "* Usually, you just need to adjust `-pth` (threshold) for accuracy and model size trade off. Higher `pth` gives you smaller model (and thus higher inference speed) but worse accuracy. The threshold to use is dependent on the dataset. A pth value `5.2e-6` is just a start point. If the retrain accuracy is good, you can increase this value to get smaller models. Otherwise, lower this value to get better accuracy.*\n",
+ "\n",
+ "* For some internal studies, we have noticed that a pth value of 0.01 is a good starting point for detectnet_v2 models.*"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Create an output directory if it doesn't exist.\n",
+ "PRUNED_MODEL_FILE_NAME = os.environ['PRUNED_MODEL_FILE_NAME'] = f\"{MODEL_NAME}{NUM_LAYERS}_pruned\"\n",
+ "!mkdir -p $LOCAL_ROOT/$EXPERIMENT_DIR/experiment_dir_pruned\n",
+ "!tlt detectnet_v2 prune \\\n",
+ " -m $DOCKER_ROOT/$EXPERIMENT_DIR/experiment_dir_unpruned/weights/$MODEL_FILE_NAME.tlt \\\n",
+ " -o $DOCKER_ROOT/$EXPERIMENT_DIR/experiment_dir_pruned/$PRUNED_MODEL_FILE_NAME.tlt \\\n",
+ " -eq union \\\n",
+ " -pth 0.01 \\\n",
+ " -k $KEY"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!ls -rlt $LOCAL_ROOT/$EXPERIMENT_DIR/experiment_dir_pruned"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "##### Retrain the pruned model\n",
+ "* Model needs to be re-trained to bring back accuracy after pruning\n",
+ "* Specify re-training specification with pretrained weights as pruned model.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Configure Retraining params \n",
+ "tf_train_proto = load_proto(os.path.join(LOCAL_ROOT, SPECS_DIR, BASIC_TRAIN_PROTO), experiment_pb2.Experiment())\n",
+ "tf_train_proto.model_config.pretrained_model_file = os.path.join(DOCKER_ROOT,EXPERIMENT_DIR, f\"experiment_dir_pruned/{PRUNED_MODEL_FILE_NAME}.tlt\")\n",
+ "tf_train_proto.training_config.num_epochs = RETRAIN_EPOCHS\n",
+ "tf_train_proto.model_config.load_graph = True # Required for retraining\n",
+ "with open(os.path.join(LOCAL_ROOT, SPECS_DIR, RETRAIN_PROTO), 'w') as file:\n",
+ " file.write(str(tf_train_proto))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!cat $LOCAL_ROOT/$SPECS_DIR/$RETRAIN_PROTO"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Retraining using the pruned model as pretrained weights \n",
+ "!tlt detectnet_v2 train -e $DOCKER_ROOT/$SPECS_DIR/$RETRAIN_PROTO \\\n",
+ " -r $DOCKER_ROOT/$EXPERIMENT_DIR/experiment_dir_retrain \\\n",
+ " -k $KEY \\\n",
+ " -n $PRUNED_MODEL_FILE_NAME \\\n",
+ " --gpus $NUM_GPUS"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Listing the newly retrained model.\n",
+ "!ls -rlt $LOCAL_ROOT/$EXPERIMENT_DIR/experiment_dir_retrain/weights"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Visualize inferences\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Configure inference params"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "tf_infer_proto = load_reference_proto(os.path.join(LOCAL_ROOT, SPECS_DIR, TLT_INFERENCE_PROTO), inference_pb2.Inference())\n",
+ "tf_infer_proto.inferencer_config.ClearField(\"target_classes\")\n",
+ "tf_infer_proto.bbox_handler_config.ClearField(\"classwise_bbox_handler_config\")\n",
+ "#We need to set a few things here...\n",
+ "\n",
+ "\n",
+ "if len(colors) <