diff --git a/docs/tutorial/notebook/01_config_files.ipynb b/docs/tutorial/notebook/01_config_files.ipynb new file mode 100644 index 00000000..0920fd86 --- /dev/null +++ b/docs/tutorial/notebook/01_config_files.ipynb @@ -0,0 +1,910 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e9b3f3ad", + "metadata": {}, + "source": [ + "# Config files\n", + "\n", + "This tutorial shows basic usage of config files." + ] + }, + { + "cell_type": "markdown", + "id": "96bbfc12", + "metadata": {}, + "source": [ + "## Basic format\n", + "We use [YAML format](https://en.wikipedia.org/wiki/YAML) for defining our config files. A config file in Open3D-ML always has the following parameters:\n", + "\n", + "1. `dataset`: Contains key-value pairs related to training, validation and test dataset. \n", + "2. `model`: Contains key-value pairs realted to model architecture.\n", + "3. `pipeline`: Contains key-value pairs related to the training, testing and inference pipleine." + ] + }, + { + "cell_type": "markdown", + "id": "b79af95f", + "metadata": {}, + "source": [ + "For example, `randlanet_semantickitti.yml` config file uses RandLA-Net *model* architecture, SemanticKITTI *dataset* and semantic segmentation *pipeline*. Let us have a look at it's contents as a raw text file." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "40d8af8c", + "metadata": {}, + "outputs": [], + "source": [ + "cfg_file = \"../../../ml3d/configs/randlanet_semantickitti.yml\"\n", + "%pycat {cfg_file}" + ] + }, + { + "cell_type": "markdown", + "id": "31a57041", + "metadata": {}, + "source": [ + "
\n", + "**Note:** You may find such config files available at https://github.com/isl-org/Open3D-ML/tree/master/ml3d/configs\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "5a75070d", + "metadata": {}, + "source": [ + "### Reading a config file\n", + "\n", + "In order to access the key-value pairs we must load the file into memory as `Config` class object. `Config` class object's usage is very much similar to standard Python dictionary `dict`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8c60d9c0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jupyter environment detected. Enabling Open3D WebVisualizer.\n", + "[Open3D INFO] WebRTC GUI backend enabled.\n", + "[Open3D INFO] WebRTCWindowSystem: HTTP handshake server disabled.\n" + ] + } + ], + "source": [ + "import open3d.ml as _ml3d\n", + "\n", + "cfg = _ml3d.utils.Config.load_from_file(cfg_file)" + ] + }, + { + "cell_type": "markdown", + "id": "7fe103b0", + "metadata": {}, + "source": [ + "`_ml3d.utils.Config.load_from_file(cfg_file)` takes path to config file as input and returns `Config`. \n", + "\n", + "
\n", + "**Note:** To avoid `FileNotFoundError`, always make sure that the config file exists at the given location. The config file must be a valid YAML file!
" + ] + }, + { + "cell_type": "markdown", + "id": "00a48be1", + "metadata": {}, + "source": [ + "## Accessing parameters\n", + "\n", + "Built-in function `vars` grabs all the properties of the object as dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "da50bb7a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'_cfg_dict': {'dataset': {'name': 'SemanticKITTI',\n", + " 'dataset_path': None,\n", + " 'cache_dir': './logs/cache',\n", + " 'class_weights': [55437630,\n", + " 320797,\n", + " 541736,\n", + " 2578735,\n", + " 3274484,\n", + " 552662,\n", + " 184064,\n", + " 78858,\n", + " 240942562,\n", + " 17294618,\n", + " 170599734,\n", + " 6369672,\n", + " 230413074,\n", + " 101130274,\n", + " 476491114,\n", + " 9833174,\n", + " 129609852,\n", + " 4506626,\n", + " 1168181],\n", + " 'test_result_folder': './test',\n", + " 'test_split': ['11',\n", + " '12',\n", + " '13',\n", + " '14',\n", + " '15',\n", + " '16',\n", + " '17',\n", + " '18',\n", + " '19',\n", + " '20',\n", + " '21'],\n", + " 'training_split': ['00',\n", + " '01',\n", + " '02',\n", + " '03',\n", + " '04',\n", + " '05',\n", + " '06',\n", + " '07',\n", + " '09',\n", + " '10'],\n", + " 'all_split': ['00',\n", + " '01',\n", + " '02',\n", + " '03',\n", + " '04',\n", + " '05',\n", + " '06',\n", + " '07',\n", + " '09',\n", + " '08',\n", + " '10',\n", + " '11',\n", + " '12',\n", + " '13',\n", + " '14',\n", + " '15',\n", + " '16',\n", + " '17',\n", + " '18',\n", + " '19',\n", + " '20',\n", + " '21'],\n", + " 'validation_split': ['08'],\n", + " 'use_cache': True,\n", + " 'sampler': {'name': 'SemSegRandomSampler'}},\n", + " 'model': {'name': 'RandLANet',\n", + " 'batcher': 'DefaultBatcher',\n", + " 'ckpt_path': None,\n", + " 'num_neighbors': 16,\n", + " 'num_layers': 4,\n", + " 'num_points': 45056,\n", + " 'num_classes': 19,\n", + " 'ignored_label_inds': [0],\n", + " 'sub_sampling_ratio': [4, 4, 4, 4],\n", + " 'in_channels': 3,\n", + " 'dim_features': 8,\n", + " 'dim_output': [16, 64, 128, 256],\n", + " 'grid_size': 0.06,\n", + " 'augment': {'recenter': {'dim': [0, 1]}}},\n", + " 'pipeline': {'name': 'SemanticSegmentation',\n", + " 'optimizer': {'lr': 0.001},\n", + " 'batch_size': 4,\n", + " 'main_log_dir': './logs',\n", + " 'max_epoch': 100,\n", + " 'save_ckpt_freq': 5,\n", + " 'scheduler_gamma': 0.9886,\n", + " 'test_batch_size': 1,\n", + " 'train_sum_dir': 'train_log',\n", + " 'val_batch_size': 2,\n", + " 'summary': {'record_for': [],\n", + " 'max_pts': None,\n", + " 'use_reference': False,\n", + " 'max_outputs': 1}}},\n", + " 'cfg_dict': {'dataset': {'name': 'SemanticKITTI',\n", + " 'dataset_path': None,\n", + " 'cache_dir': './logs/cache',\n", + " 'class_weights': [55437630,\n", + " 320797,\n", + " 541736,\n", + " 2578735,\n", + " 3274484,\n", + " 552662,\n", + " 184064,\n", + " 78858,\n", + " 240942562,\n", + " 17294618,\n", + " 170599734,\n", + " 6369672,\n", + " 230413074,\n", + " 101130274,\n", + " 476491114,\n", + " 9833174,\n", + " 129609852,\n", + " 4506626,\n", + " 1168181],\n", + " 'test_result_folder': './test',\n", + " 'test_split': ['11',\n", + " '12',\n", + " '13',\n", + " '14',\n", + " '15',\n", + " '16',\n", + " '17',\n", + " '18',\n", + " '19',\n", + " '20',\n", + " '21'],\n", + " 'training_split': ['00',\n", + " '01',\n", + " '02',\n", + " '03',\n", + " '04',\n", + " '05',\n", + " '06',\n", + " '07',\n", + " '09',\n", + " '10'],\n", + " 'all_split': ['00',\n", + " '01',\n", + " '02',\n", + " '03',\n", + " '04',\n", + " '05',\n", + " '06',\n", + " '07',\n", + " '09',\n", + " '08',\n", + " '10',\n", + " '11',\n", + " '12',\n", + " '13',\n", + " '14',\n", + " '15',\n", + " '16',\n", + " '17',\n", + " '18',\n", + " '19',\n", + " '20',\n", + " '21'],\n", + " 'validation_split': ['08'],\n", + " 'use_cache': True,\n", + " 'sampler': {'name': 'SemSegRandomSampler'}},\n", + " 'model': {'name': 'RandLANet',\n", + " 'batcher': 'DefaultBatcher',\n", + " 'ckpt_path': None,\n", + " 'num_neighbors': 16,\n", + " 'num_layers': 4,\n", + " 'num_points': 45056,\n", + " 'num_classes': 19,\n", + " 'ignored_label_inds': [0],\n", + " 'sub_sampling_ratio': [4, 4, 4, 4],\n", + " 'in_channels': 3,\n", + " 'dim_features': 8,\n", + " 'dim_output': [16, 64, 128, 256],\n", + " 'grid_size': 0.06,\n", + " 'augment': {'recenter': {'dim': [0, 1]}}},\n", + " 'pipeline': {'name': 'SemanticSegmentation',\n", + " 'optimizer': {'lr': 0.001},\n", + " 'batch_size': 4,\n", + " 'main_log_dir': './logs',\n", + " 'max_epoch': 100,\n", + " 'save_ckpt_freq': 5,\n", + " 'scheduler_gamma': 0.9886,\n", + " 'test_batch_size': 1,\n", + " 'train_sum_dir': 'train_log',\n", + " 'val_batch_size': 2,\n", + " 'summary': {'record_for': [],\n", + " 'max_pts': None,\n", + " 'use_reference': False,\n", + " 'max_outputs': 1}}}}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vars(cfg)" + ] + }, + { + "cell_type": "markdown", + "id": "7af1de18", + "metadata": {}, + "source": [ + "You can list all the keys in the top most level using:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e003542b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['dataset', 'model', 'pipeline'])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg.keys()" + ] + }, + { + "cell_type": "markdown", + "id": "0a4923a4", + "metadata": {}, + "source": [ + "Here, you can see the three essential components." + ] + }, + { + "cell_type": "markdown", + "id": "1aa31b4e", + "metadata": {}, + "source": [ + "You can access configuration values as object attributes (`cfg.{property_name}`) or dictionary key values (`cfg['{property_name}']`).\n", + "\n", + "For example, `dataset` dictionary can be accessed using the following code (same can be done for `model` and `pipeline`)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ef76e079", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'name': 'SemanticKITTI',\n", + " 'dataset_path': None,\n", + " 'cache_dir': './logs/cache',\n", + " 'class_weights': [55437630,\n", + " 320797,\n", + " 541736,\n", + " 2578735,\n", + " 3274484,\n", + " 552662,\n", + " 184064,\n", + " 78858,\n", + " 240942562,\n", + " 17294618,\n", + " 170599734,\n", + " 6369672,\n", + " 230413074,\n", + " 101130274,\n", + " 476491114,\n", + " 9833174,\n", + " 129609852,\n", + " 4506626,\n", + " 1168181],\n", + " 'test_result_folder': './test',\n", + " 'test_split': ['11',\n", + " '12',\n", + " '13',\n", + " '14',\n", + " '15',\n", + " '16',\n", + " '17',\n", + " '18',\n", + " '19',\n", + " '20',\n", + " '21'],\n", + " 'training_split': ['00',\n", + " '01',\n", + " '02',\n", + " '03',\n", + " '04',\n", + " '05',\n", + " '06',\n", + " '07',\n", + " '09',\n", + " '10'],\n", + " 'all_split': ['00',\n", + " '01',\n", + " '02',\n", + " '03',\n", + " '04',\n", + " '05',\n", + " '06',\n", + " '07',\n", + " '09',\n", + " '08',\n", + " '10',\n", + " '11',\n", + " '12',\n", + " '13',\n", + " '14',\n", + " '15',\n", + " '16',\n", + " '17',\n", + " '18',\n", + " '19',\n", + " '20',\n", + " '21'],\n", + " 'validation_split': ['08'],\n", + " 'use_cache': True,\n", + " 'sampler': {'name': 'SemSegRandomSampler'}}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg.dataset" + ] + }, + { + "cell_type": "markdown", + "id": "a12fd14a", + "metadata": {}, + "source": [ + "One other way to access `dataset` parameters is accessing like a built-in `dict`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a0312122", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'name': 'SemanticKITTI',\n", + " 'dataset_path': None,\n", + " 'cache_dir': './logs/cache',\n", + " 'class_weights': [55437630,\n", + " 320797,\n", + " 541736,\n", + " 2578735,\n", + " 3274484,\n", + " 552662,\n", + " 184064,\n", + " 78858,\n", + " 240942562,\n", + " 17294618,\n", + " 170599734,\n", + " 6369672,\n", + " 230413074,\n", + " 101130274,\n", + " 476491114,\n", + " 9833174,\n", + " 129609852,\n", + " 4506626,\n", + " 1168181],\n", + " 'test_result_folder': './test',\n", + " 'test_split': ['11',\n", + " '12',\n", + " '13',\n", + " '14',\n", + " '15',\n", + " '16',\n", + " '17',\n", + " '18',\n", + " '19',\n", + " '20',\n", + " '21'],\n", + " 'training_split': ['00',\n", + " '01',\n", + " '02',\n", + " '03',\n", + " '04',\n", + " '05',\n", + " '06',\n", + " '07',\n", + " '09',\n", + " '10'],\n", + " 'all_split': ['00',\n", + " '01',\n", + " '02',\n", + " '03',\n", + " '04',\n", + " '05',\n", + " '06',\n", + " '07',\n", + " '09',\n", + " '08',\n", + " '10',\n", + " '11',\n", + " '12',\n", + " '13',\n", + " '14',\n", + " '15',\n", + " '16',\n", + " '17',\n", + " '18',\n", + " '19',\n", + " '20',\n", + " '21'],\n", + " 'validation_split': ['08'],\n", + " 'use_cache': True,\n", + " 'sampler': {'name': 'SemSegRandomSampler'}}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg['dataset']" + ] + }, + { + "cell_type": "markdown", + "id": "7116e971", + "metadata": {}, + "source": [ + "Accessing individual parameters can be done with either `cfg.{property_name}.{property_name}` or `cfg['{property_name}']['{property_name}']` syntax. Inner levels can be accessed using the same idea.\n", + "\n", + "Let's try to access `dataset -> sampler`:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ae8461fb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'name': 'SemSegRandomSampler'}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg.dataset.sampler" + ] + }, + { + "cell_type": "markdown", + "id": "3b58186c", + "metadata": {}, + "source": [ + "Another approach:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "39176453", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'name': 'SemSegRandomSampler'}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg['dataset']['sampler']" + ] + }, + { + "cell_type": "markdown", + "id": "ddbbcc07", + "metadata": {}, + "source": [ + "## Mutating Parameters\n", + "\n", + "If you want to change the keys or values in your config files, you may use dictionary synatx as shown below:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5706a884", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NewSampler\n" + ] + } + ], + "source": [ + "cfg['dataset']['sampler'] = \"NewSampler\"\n", + "\n", + "print(cfg['dataset']['sampler'])" + ] + }, + { + "cell_type": "markdown", + "id": "63b16241", + "metadata": {}, + "source": [ + "We may use object dot notation too. Let us change `dataset_path` using it." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "11006162", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "./SemanticKITTI\n" + ] + } + ], + "source": [ + "cfg.dataset.dataset_path = \"./SemanticKITTI\"\n", + "\n", + "print(cfg.dataset.dataset_path)" + ] + }, + { + "cell_type": "markdown", + "id": "25ab93fe", + "metadata": {}, + "source": [ + "
\n", + " **Note:** Original YAML file on disk remains unchanged!\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "32338adf", + "metadata": {}, + "source": [ + "## Building Dataset Component" + ] + }, + { + "cell_type": "markdown", + "id": "6181b4de", + "metadata": {}, + "source": [ + "Look at the code snippet below:\n", + "\n", + "```py\n", + "# Read a dataset by specifying the path, cache directory, training split etc.\n", + "dataset = ml3d.datasets.SemanticKITTI(dataset_path='SemanticKITTI/',\n", + " cache_dir='./logs/cache',\n", + " training_split=['00'],\n", + " validation_split=['01'],\n", + " test_split=['01'])\n", + "```\n", + "\n", + "The `dataset` object is created by explicitly passing **dataset-specific parameters** to the constructor of `ml3d.datasets.SemanticKITTI` class. Instead of passing these parameters one by one manually we may use config files as shown below:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "913f9c77", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------------\n", + "\n", + " Using the Open3D PyTorch ops with CUDA 11 may have stability issues!\n", + "\n", + " We recommend to compile PyTorch from source with compile flags\n", + " '-Xcompiler -fno-gnu-unique'\n", + "\n", + " or use the PyTorch wheels at\n", + " https://github.com/isl-org/open3d_downloads/releases/tag/torch1.8.2\n", + "\n", + "\n", + " Ignore this message if PyTorch has been compiled with the aforementioned\n", + " flags.\n", + "\n", + " See https://github.com/isl-org/Open3D/issues/3324 and\n", + " https://github.com/pytorch/pytorch/issues/52663 for more information on this\n", + " problem.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\n" + ] + } + ], + "source": [ + "import open3d.ml.torch as ml3d\n", + "\n", + "dataset = ml3d.datasets.SemanticKITTI(**cfg.dataset)" + ] + }, + { + "cell_type": "markdown", + "id": "35ca0ffb", + "metadata": {}, + "source": [ + "Look at what properties the newly-created `dataset` object exposes with the Python `vars()` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "8abcef5d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'cfg': ,\n", + " 'name': 'SemanticKITTI',\n", + " 'rng': Generator(PCG64) at 0x7FBBE9D225F0,\n", + " 'label_to_names': {0: 'unlabeled',\n", + " 1: 'car',\n", + " 2: 'bicycle',\n", + " 3: 'motorcycle',\n", + " 4: 'truck',\n", + " 5: 'other-vehicle',\n", + " 6: 'person',\n", + " 7: 'bicyclist',\n", + " 8: 'motorcyclist',\n", + " 9: 'road',\n", + " 10: 'parking',\n", + " 11: 'sidewalk',\n", + " 12: 'other-ground',\n", + " 13: 'building',\n", + " 14: 'fence',\n", + " 15: 'vegetation',\n", + " 16: 'trunk',\n", + " 17: 'terrain',\n", + " 18: 'pole',\n", + " 19: 'traffic-sign'},\n", + " 'num_classes': 20,\n", + " 'remap_lut_val': array([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 5, 0, 3, 5,\n", + " 0, 4, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 0,\n", + " 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 10, 0, 0, 0, 11, 12, 13,\n", + " 14, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 15, 16, 17, 0, 0, 0, 0, 0, 0, 0, 18, 19, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 7, 6,\n", + " 8, 5, 5, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0], dtype=int32),\n", + " 'remap_lut': array([ 0, 10, 11, 15, 18, 20, 30, 31, 32, 40, 44, 48, 49, 50, 51, 70, 71,\n", + " 72, 80, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " dtype=int32)}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vars(dataset)" + ] + }, + { + "cell_type": "markdown", + "id": "6a41b47a", + "metadata": {}, + "source": [ + "We may reference any property of the `dataset` using above syntax. For example, to find out what value the `num_classes` property holds, we use:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a05e5090", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 'unlabeled',\n", + " 1: 'car',\n", + " 2: 'bicycle',\n", + " 3: 'motorcycle',\n", + " 4: 'truck',\n", + " 5: 'other-vehicle',\n", + " 6: 'person',\n", + " 7: 'bicyclist',\n", + " 8: 'motorcyclist',\n", + " 9: 'road',\n", + " 10: 'parking',\n", + " 11: 'sidewalk',\n", + " 12: 'other-ground',\n", + " 13: 'building',\n", + " 14: 'fence',\n", + " 15: 'vegetation',\n", + " 16: 'trunk',\n", + " 17: 'terrain',\n", + " 18: 'pole',\n", + " 19: 'traffic-sign'}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset.label_to_names" + ] + }, + { + "cell_type": "markdown", + "id": "b89d87c8", + "metadata": {}, + "source": [ + "Similarly, we may bulild **model and pipeline components** using `cfg.model` and `cfg.pipeline` respectively. Have a look at training tutorials for code examples." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorial/notebook/02_datasets.ipynb b/docs/tutorial/notebook/02_datasets.ipynb new file mode 100644 index 00000000..be0724b3 --- /dev/null +++ b/docs/tutorial/notebook/02_datasets.ipynb @@ -0,0 +1,454 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e5b18a95", + "metadata": {}, + "source": [ + "# Datasets" + ] + }, + { + "cell_type": "markdown", + "id": "cc08bb58", + "metadata": {}, + "source": [ + "Open3D-ML provides many popular datasets out of the box. In this tutorial, we will see how to use them." + ] + }, + { + "cell_type": "markdown", + "id": "aece71cb", + "metadata": {}, + "source": [ + "## Available datasets\n", + "\n", + "You may use any dataset available in the `ml3d.datasets` namespace. Some datasets available in the namespace are: `Argoverse`, `InferenceDummySplit`, `KITTI`, `Lyft`, `MatterportObjects`, `NuScenes`, `ParisLille3D`, `S3DIS`, `Scannet`, `SemSegRandomSampler`, `SemSegSpatiallyRegularSampler`, `Semantic3D`, `SemanticKITTI`, `ShapeNet`, `SunRGBD`, `Toronto3D`, `Custom3D` and `Waymo`.\n", + " \n", + " For this example, we will use the `SemanticKITTI` dataset. \n", + " \n", + "
\n", + " **Note:** Config file parameters may vary for each dataset.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "39b3561f", + "metadata": {}, + "source": [ + "## Point cloud dataset" + ] + }, + { + "attachments": { + "image-12.png": { + "image/png": "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" + }, + "image-14.png": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIIAAALoCAIAAACLSMk9AAAAAXNSR0IArs4c6QAAIABJREFUeJzs3XlAVGX///9z2LdBYXBfIJWQMnG9hcDcCNFKlMI9UyulxY+pbbdripVZZtYdQlppipqlqbelIIkmiGYq6O2CKAJmqAioLMMyw/z+OL97vnMDDgMMZ8Cej79w5jrXeZ+ZQc7rXNe5RtRqtQIAAAAAQC4W5i4AAAAAAP5eiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAEwsLy8vODhY/F8eHh7jxo3bv39/WVmZrqVKpQoPDw8ODs7Ly5MeuXHjxiuvvKJUKp2dnX/88cfCwsL33nvPw8NDFMWVK1ea6YCEysrKAwcOpKSkGGiTmZm5detW2UoyucrKyp07d/r6+oqiOHr06IKCAtP2HxERoXujk5KSRFGMiYmRniorK/vpp58yMjLq3XOvXr3S0tIaWGF2dvby5cv79OkjiqJSqXzmmWe2bNlSXFzcwG7rJzc3d8WKFd27dxdFMTAwcMeOHfq/ODExMWI1fn5+y5cvz87OrrXztLS0Xr16iaIYHh6uUqmqNzhz5szDDz+s/x6Z6kUGAOhYmbsAAA8mb2/vsWPH2tvbS//My8vbs2fPiBEjZs+e/f777zs6OlbfpLy8fPXq1fv27fvggw+8vLx69OixcePGTz/99J133vH393/ooYfkPYL/Jzk5OSgoKDEx8X4N8vLywsPD/f395azKtM6cOTN37tzHH388IiKiVatWzs7Osu36xx9//Pjjj7///nvZ9liFWq2OiYmZO3duhw4dJk+e/PHHH5eWlu7bt2/WrFkbN25cs2ZN9+7d5azn5s2bM2fOvHjx4syZM3v27Hn48OFp06YtWLBg3rx5Vlb/76/25MmTe/ToIf2s0WhOnDixcuXKzZs3f/XVV0888YQxOzp27Fh2draXl1eVx5OTk9PT0011OACAGhHDADSKzp07z5o1S6lU6h5ZunTpypUr33vvvQ4dOsydO9fS0tLe3j4qKkrXQKVSZWRkPPnkk88//7yDg0N5eXlGRsaAAQNmzJjRqlUrcxzE30h2dnZWVtZ3331n5Bl8Q/j7+2u1WlP1tmjRokWLFtV7c61Wu3379lmzZr322mvz589XKBTS40899VR4ePhLL700derUTZs2eXp6mqje2uuJiYlJSUnZuHHjoEGDBEEYOnSoUqn86KOPhgwZ8o9//EPXMjg4eNKkSfrbnjx58rXXXnv77beNKXjAgAH5+fnnzp2rEsMKCwuTkpJ69+59+vRp0x0WAKAqJiUCkIm9vf2cOXOmTJny7bffXrx4sXoDtVpdWFhoaWkpiqIgCBqNpqSkxNLS0sKC/6kaXWFhoSAIlpaW5i5EbpmZmZ9//vn48eMXLlyoy2CSHj16fPTRRzdu3IiOjtafE9ioSkpKcnJyAgMD+/TpIz0iimK/fv1ycnJqHaHq27fvsmXLzp8/v2nTJo1GY7ixn5+fr69vYmJieXm5/uPZ2dnnz5+fMGFCQ44CAFArTm4AyMfZ2TkkJOTChQvSfVb694bFxMS4ubnFxsZGR0c7ODiMHj3awcEhOjo6NjbWzc1Nd1tRcXHx2rVrpVuYunfvvmLFivz8fF3/SUlJvXr1OnLkyIwZM5ydnceOHSvdKqN/p42vr29UVJT+LTERERHh4eFZWVkLFy708PCQNjx16pQ0YhMREREQECAIQkBAQI23xyQlJUmVL168WBTFzZs3L1++/OGHHz5z5ox+s5MnT7Zv337nzp3SUYeHhx89enTs2LHOzs7VD6TWmsvKynbs2BEYGCjdyDR27NjDhw8bGGLSarXJyckTJ06U7rsbM2ZMQkJCZWWl8N97+SZPniwdoyiKSUlJ1XvQf+U9PDxeeumls2fPSk8ZeUT6r5h035G04eTJk1NTU7t37y69y1qtNjU1dfr06UqlUhTFwYMHVzn2KvRvW5I+AGfPnt26datUqq+v79atWw2EqIMHDx4/fjwsLKzGibK+vr4hISHx8fGZmZnCf++q2rhx47Zt26T+AwMDd+7cqVar9bcy8N5JhxwREZGZmTljxgylUqlUKmfMmCH1LwiCo6Pjxx9/vH79ev1MePPmTUEQWrdufb+j0Onfv39gYOCJEydqvbvP1dW1d+/ex48fz8nJ0X/82LFjDz300COPPFLrvgAADUEMAyCrbt26eXp6njt3rsrV+oCAgD179gwYMGD06NGxsbFvvPHGvn37Ro8ePWDAgD179rz33ntOTk43b96cNm3awoULR44cGR8fP3PmzA0bNkyfPl06SZXcunVr3rx5LVq02L59+9NPP92mTZu0tLQxY8Zs2LBh5syZ8fHxI0eOXLBgwZtvvqm/+sKlS5emTp169+7ddevWffHFF5mZmaGhoSdPnhQE4bnnnouMjBQEITIy8l//+lf79u2rHJGXl5dU+csvv5yQkDBw4MCgoKCioqLk5GRdG61We/jw4c6dO/fu3Vt6JDExcfr06W3atNmxY8fUqVM//vjjl156KTc3V3rWcM0ajebzzz+fMWPGE088ER8fHx0dfe/evWeeeebAgQM1vuZarXbr1q3Dhw9Xq9Xr16/funWrvb19SEhIZGSkWq12cnJ67733lixZIh1jQkJC9ZuFVCrVu+++u2bNmnHjxiUkJCxduvTMmTPjxo3Tj5qGj6hGNjY24eHhS5Ys8fT03Lx5s/QuHz16NCQkpLS09LvvvouLi3vsscfefvvt5cuXV4k691NSUvLee+9t3LjxzTff3Lt3b5cuXSZOnBgVFVVjRi0tLT116tTjjz/+8MMP19ibra1t3759U1NT9eN3VFTU8uXLx40bFxcX16FDh2effXb16tW6z7Mxn7ejR49Onjy5Y8eO27dvX7hw4W+//TZ58mRdEtNXXl6+f//+ZcuWTZo0qV+/frUevpSBr1y58tdff9Xa+Iknnrh69eqlS5d0jxQXFycmJj7++OMtW7asdXMAQENwbxgAWdna2jo4OOTn51eZCuXu7u7k5NSyZcs2bdoMHDjQ3t5epVLt2rVLpVI9/vjjSqVSq9Vu27YtMTHxhx9+GDp0qCAIw4YNCw4OnjBhwpdffrlkyRJpQl1OTk5YWNjy5cttbW0FQSgrK1u3bl1RUdFPP/3k7e0tbRUQEDB58uQ+ffq8+OKL0t4TEhJWrFihWwLB29t79OjRR44c6devn7e3tzSq07NnzxoX4XBzc5NOWzt16jR48GBBEJydnX19fZOSkiZOnCiNady5c0c6u+3QoYN0vn7u3DndHp988sk+ffo899xze/bsefHFF2utOT8/Py4ubtasWYsWLZImcPr5+c2YMePEiRNDhgyxtrauUuH58+eXL1/+/PPPr1y5UhrzCQwMXLp06SeffOLr69uvXz9fX98rV64YOMasrKzDhw/Pnz9/ypQp0iO9e/d+5ZVXTp061bNnT+kRA0d0vw+DpaVlr169zp075+Dg0K9fPy8vL61We+DAAU9PzzVr1kg3BA4ZMqRFixaXLl26efNmhw4dDHy0JOnp6Y888sjGjRvbtGkjCMLjjz9eWlqamJg4derUFi1aVGlcXFx85coVhULh5OR0vw67du0qHd2oUaOkR3JycnQ3bg0ZMqRjx47ffvvtyJEjH330USM/b0lJSVFRURMmTBBFcdiwYe7u7s8+++yZM2c8PDz0dx0dHR0eHi4IQmho6Keffuri4lLr4Uu3XKanp0uzTA3r1q2bv79/QkLC0KFDpV+fzMzMs2fPvvLKKxUVFbVuDgBoCEbDAMjK1dW1futt5OXl7d+/f9SoUX5+froHH3744ZEjRx45ckR/QKxv375SBhMEITMzMz4+/rnnntNf7E6auHX48GHdqaqnp+eIESN0y9A99NBDjz76aFFRUT3qFATBxcVl4MCBx44du3r1qvRIenr6qVOnnnrqKRsbG+mRwYMHP//887o9+vn5jR49ev/+/Xfv3jWy5qysrNu3b0s/d+jQ4eeff16wYEH1DCYIQlxcnFqtnjlzpm7ena2t7fjx421sbO43gFajtLQ03ZBOz549k5KSpk6dqnvWwBEZvwtJbm5uRkaGNH5lZWW1fPny7du3G5PBJCNGjJAymCAILVu27NmzZ2FhoZGDafejv/nEiROleapSeePGjVOr1XFxcYLRn7e+ffsOHjxYitCCIDzyyCOPPfZY9eDUo0ePhISETz/99Ny5c6GhoUauF+/u7m7kQTk7O/v5+Z04ceLWrVvSIykpKZ07d5ZtPRIA+DsjhgGQVX5+vuGJaveTl5eXk5NTWVl5/PjxQ/915MgRlUp1/fp1XSARBKFdu3a6n2/fvp2amqpWqw8fPqzb6vfff1er1deuXdOd+LZq1Up/qMTCwsLS0rKgoKDKkJ3xhg0bJgiCNC9Rq9UmJiZ6enrq32/j5eWlP7ihUCg8PT2vXr2am5tba82urq5BQUEbNmzo2rXrmDFjNm3adO3atfvdGFZaWnr58mV3d3f9l0UQhA4dOnTp0iUrK8vAbVc67u7ugwYN+uCDDzp37jxlypQ9e/boTtyNOaLaX6//EkXxySefvHPnjq+vr5+f38qVK0+dOlXXBKV/pKIoWlpaFhYW1jtUS/RXin/00Uf11zKRXsnLly+XlpYa+Xlzc3PTvxVNFEULC4vqL6m/v//gwYPnzJmzZcuW/Pz8FStWGPM9ZllZWUYelCiKAQEB6enp58+fFwRBpVIdOXIkICCAGYkAIAMmJQKQVVlZWUlJSdu2be3s7EpLS43fUDrBTU1NXbduXfVn9UcSHBwcdD9L99ssXbp06dKlVTbx8fHRbVXjtLSSkpJal5u7n65du/r7+0vzEsvKyg4cODBo0KC2bdvqGkivQJWt1Gq1RqOpteb27dvPmTOnZ8+eUVFRv/76665duwRBePrpp6XFKqpsotVqNRpNAxectLe3X7ly5eOPP/71119v2rRp06ZNgiBMmTJl+fLlnTp1qvWI6rQvf39/aaWWnTt3vvPOO4IgeHl5LVmyJCwsTD8LGaD/NQmS4uLiGj9sjo6OXbt2TUlJKSoqqr6VRHo7unTpontEd8j6NBqNVqut9b2TkqpSqdSNi+oYCIo9evQIDg4+ePDgn3/+Wf3OvSplqFSqxx57TKlUqlSqOXPmREdH657dvHlzlTXuu3Tp4u3tnZycPHTo0OzsbGlxFN0wHQCg8TAaBkBWZ8+eTU9P9/T0rOupnlKpfOyxxz799FNtTe731cnSGfPu3burb5KSkmL4jLYhHB0dAwICpHmJaWlpFy5cCAoK0j/kGzdu6AcDKSw5Ojra2dkZU7OVldXw4cN/+umnnJycxMTE2bNnHz169K233qqy6p3w3+EgjUYjrYtYb/b29hMmTIiPj8/Pz4+NjZ0yZcpPP/20ePFi3fiMgSOq6768vLw+/fTTy5cvX7x48bPPPrOxsZk5c+bhw4cbUn+N7Ozs+vTpc/bs2cuXL9fYoKys7Pfff/f29tZ9UbIgCNeuXdNvU1lZqdFoHBwcLC0tG+nzZmNjY8yNYYIgFBQUnD59ukOHDm5ubsa0VyqV0vWCvLy8P/74o127dsxIBAB5EMMAyKegoGD37t0DBgx4/PHH67qts7OzUqlMS0vTn0Sn0WgWLFgQGhpa4ypzgiC0bNnS09PzzJkz+nP2CgsLp02b9vLLL9fjtiXjDR061NXVNTk5+fjx4/37969yCp6VlaU/wayoqCgjI6Nr166urq611nzy5Ek/P789e/YIguDo6Ojv77969eo5c+bk5ubeu3evShl2dnbdunU7d+6ctHa/zvXr1zMyMtzd3e3t7Ws9lt27d/v7+0tLR7q4uAQFBUVFRU2cODEnJ0cXvQwckZGvmCAIBQUF06dPf+utt8rLy62srLy8vGbPnr127VpBEG7cuGF8P8YbNmxYz549v/vuu+ovnSAIx44d271798iRI7t166Z78OrVq/pvTU5OTlZWlpeXl42NTcM/b9IqnQsWLNAfRZRm3rq4uFT5ZrPqkpKSkpKSnnzySaVSKX09un4UrDIUJgiCKIpDhgy5cOHC+fPnf//9d2YkAoBsiGEAZFJcXLxmzZoffvhhwoQJVVaEM0abNm2CgoL27NmTlJSkO8f9448/YmJiOnXqVOXGJx1PT8+hQ4f++OOP//nPf6RHpLX4duzY4e3t7ezsbHwBtU6uk6al6f7Zvn37AQMGxMXFJSQkBAYGVlmmLykpKS4uTmov3Ty2a9eu4cOHS7dUGa65ffv2Tk5Oe/fu1cUejUZTWFh4v6GnoKCgli1bfvPNN7r2ZWVl27ZtKyoqku5hq1W3bt0KCgr27dunu02rvLy8qKhIoVDoJgoaOKJa+6+srJQ2dHZ27tix44EDB6SVGyX37t0rLCw0pp96cHd3f/XVV3/66acPP/ywyiIZ//nPf9555522bdu++OKLukVfBEHYu3ev7vvHpVfSwcFBWiSz4Z+3du3aderU6eeff9ZfRz45OXnPnj1BQUG6pUeq02q1J06c+PDDD3v27BkaGmr8aLOXl5e3t/emTZvOnj0rfXGckRsCABqCe8MANIrs7OwvvvhCN9KSnZ3966+/pqWlzZ49+6WXXqrHqZ6lpeX06dOPHz8+bty42bNn+/v7nzlzJjo6um3btuHh4fpnyfrs7e1nz56dkpISFhY2c+ZMaX2/NWvWDB06dNKkSUaWIUWjjRs3arXaPn36VM8DNjY2rVu33r9/v4+PT58+faSl6mxtbYcNGxYSEuLt7a1bWE+/sDfffPPy5ct+fn7Jyclr1qx5/vnnR48ebUzNbdu2nTZtWnh4eFFR0aRJk2xsbPbs2bNx48aIiIjOnTtXr/+RRx5ZuHBheHh4bm7uhAkTbGxsYmJi9u7du2jRoj59+hjzCnh5eb3wwgvvv//+zZs3R40aVV5eLvWwadOmFi1aSOOTBo7IsNatW589e/a7774bNWpU7969J0yYEBcX98ILL7z22mvu7u6nT5+Ojo4OCwsbOHCgMaXWlSiK48ePt7a2fuutt37++efJkyf37du3tLR03759W7du9fb2jo6Olpae18nOzpbKc3Nzk16HqKgo6ZvHGv55s7W1DQ8PP378+JgxY/R7GDZs2PTp0/WXBtm/f/+ff/4p/VxeXn706NGkpKT27dt/9dVXdbrM4eLi0r9//4iIiODgYP1b4Kq4devWN998U2VsU1pyU/+mRwCAsWq8ywIA6u327dvDhw+v8l+Nl5fX1KlTDx06JA0ZSUpKSmbOnDl8+PDbt2/rNpw5c2ZJSUn1ZyVFRUWRkZEDBgwQBMHd3X3OnDnZ2dm6ZxMTEwVBSExMrFLSrVu3PvzwQ2laoJeX14cffpiXl6d7dtmyZVX2UqWSioqKqKgod3d3hUKRnJxc41EnJydLOeGDDz7QPXj9+vXBgwfr+tE/6pkzZyYlJYWFhSkUigEDBqxdu1a/Ta01azSaAwcOBAcHKxQKhUIxevTogwcP6r+2VVRWVh46dCgsLMzV1dXV1TUsLKxK+82bN9f40umUlpZu2bJF+rIsV1fXadOmpaSkSKNYxhyR/ossvU2bN2+WnioqKlqyZImrq2vfvn3T09O1Wu3Vq1dnzJghpdkBAwZERkYWFRXdr7Bly5b5+PhcvHhRe58PgH4DA7KysiIiIqTv15Zeoh07dlR5Uy5evOjj47Nhw4atW7cOGDBAeuUPHTokvQ46Bt473Wul37PU7bJly3SPXL9+ff78+VIP1V8B6c3Sp1Aohg0b9sknn9y6dcvwYda4u/j4eIVCERERoTuQKu/RsmXLajyFMOaFBQDUSNTeZ41jAEADZWVlTZw4cd68eaGhoboHpfXrBEFYvXq1MfdlNX0P3hHdT1pa2rhx4956663qN1kBAFAn3BsGAI1Cq9UeOXLEwcFB//umAQAABO4NAwCTu3Xr1rZt27KysjZs2LB48WLunAEAAFUQwwDAxKytrRMTE3/99ddZs2bVbz0SAADwYOPeMAAAAACQFfeGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsrIydwEPgk8++WTRokW2traNupfKykoLC0OxudYGxtBqtaIoNoVOGs4kL4ipyP+aaDQaS0tL4x+XZ+/NSFM+BPN+tpvIL7jxDBTcpP6XMKwZlVoParXayqqJnpA09gde5mNvdr+/cHFxOXfunIODg7kLgek10f/1mpekpKRWrVq98847jbqXK1eudO3a1UCDO3futGzZsoF7MclfepVKZW9vb7hNrYfTcDLswvi9l5WVNXZQr+L69esdOnSo/nhmZqaHh0dj7/2vv/5q3769kY1lOy2o00ciOzu7c+fOjVqPpB4f1IKCAhcXl0aqp1a1FmzeX73qDNTT1Eo14MaNG23btpV+bkZlS5rdZ0ZfYwdgmY+9vLzcxsZGtt0Z0PADb8oXy0zo9ddfN3cJaCyiVqs1dw3N3pgxY7Kzs0+ePGnuQgAAAPDgEEWxuLiY0bAH0gM7wwEAAAAAmiZiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAADQFImiWFFRYe4q0CiIYQAAAEBTpNVqra2tzV0FGgUxDAAAAABkRQwDAAAAAFkRwwAAAABAVsQwAAAAAJAVMQwAAAAAZEUMAwAAAABZEcMAAAAAQFbEMAAAAACQFTEMAAAAAGRFDAMAAAAAWRHDAAAAAEBWxDAAAAAAkBUxDAAAAABkRQwDAAAAAFkRwwAAAABAVsQwAAAAAJAVMQwAAAAAZEUMAwAAAABZEcMAAACApkgUxYqKCnNXgUZBDAMAmFhaWlqvXr3E/woODs7Ly6vSJikpSdQTHh6uUqnMUi0ANFlardba2trcVaBREMMAAFVJGUmKRjExMXWNSdbW1l5eXkFBQQMHDlQoFDW2sbOzCwoKCgoK8vX1NdxbRESEKIoxMTEqlSo8PFz6uW7HAwBAE2Nl7gIAAE1a69atBUGwtLQURdHITbp06fL9998LgpCWljZu3Lga2/Tt2zc2NlYQhKSkpICAAGO6tbGxcXV1FQTByoo/XgCA5o3RMACAIQ4ODoIgtG3b1s7OzryVWFpa2tvbC4LQsWNH81YCAEADEcMAADWr0whYY2MEDADwICGGAQCqsrOza9eunYERMN0CG0ql8plnnvn666+Li4sbqRgnJyeBETAAwIOFi4sAgKqcnJykW8LuR6VSBQUFCYJw7969vXv37t2799///nd0dHSbNm1MXozhSgAAaI6IYQCAqrp27ZqQkCCtkty/f//bt2/b2trqNwgMDAwMDJR+VqlUUVFRc+fOfeKJJ+bMmWPyeYyhoaG3b9+WVlycM2fOq6++er/VFwEAaC6YlAgAqMrKysrFxUWaDWhjY6NUKqWfa2SzwyVIAAAgAElEQVRvbz9y5EgfH59Lly6VlpaavBh7e3ulUmljYyMIgpOTk+5nAACaL2KYCWi1WnOXAACyyszMnDdvXp8+faQ7xMLCwjIyMsxdFAAAzQaTEk2g6awkBgAyuHDhwrRp09LT08PCwqSvBbt8+XJmZqa56wIAoNkghplAQUFB4y0RBgBNza5du86fP//jjz9Kq3QIgpCWlnbixInqLRUKhYuLi+HeFAqFp6en6asEAKAJY1KiCbi4uDg6Opq7CgCQiVqtdnJyatmypfTPysrKP/74o8a7whwdHd3c3M6cOZOamio9otFoNBqNfpsWLVq0atXq2LFjuvE0tVpdWVnZmEcAAICZMRoGAKibnj17FhUVjR07NiwszMXFJTk5uVOnTsHBwbt27SooKJg0adKoUaOkls7OzgEBAT/++OPo0aN79eplZWV169atLVu29OzZU9db27Zt/fz8Vq1aFRAQ4OPjo1arraysNm/e3L59ezMdHwAAjY7RMABA3TzzzDMxMTHdunX75JNPvvrqq+7duy9evFipVGZlZW3fvl038CUIgiiKM2bMWLNmTfv27Y8cOZKRkdG1a1dpHXwdW1vb+fPnL1iwQKFQJCQk3Lp166GHHpL9mAAAkJXIKn8NN2bMmOzs7JMnT5q7EAAAADw4RFEsLi52cHAwdyEwPUbDAAAAAEBWxDAAAAAAkBUxDAAAAABkRQwDAAAAmiJRFCsqKsxdBRoFMQwAAABoirRabZXVZfHAIIYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAAAsiKGAQAAAE0RKyU+wIhhAAAAQFPESokPMGIYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgAAAAAyIoYBgAAAACyIoYBAAAAgKyIYQAAAAAgK2IYAAAAAMiKGAYAAAA0RaIoVlRUmLsKNApiGAAAANAUabVaa2trc1eBRkEMAwAAAABZEcMAAAAAQFbEMAAAAACQFTEMAAAAAGRFDAMAAAAAWRHDAAAAAEBWxDAAAAAAkBUxDAAAAABkRQwDAAAAAFkRwwAAAABAVsQwAAAAAJAVMQwAAAAAZEUMAwAAAABZEcMAAAAAQFbEMAAAAACQFTEMAAAAAGRFDAMAAAAAWRHDAAAAAEBWxDAAAAAAkBUxDAAAAABkRQwDAAAAmiJRFCsqKsxdBRoFMQwAAABoirRarbW1tbmrQKMghgEAAACArKzMXcCDICsrKz8/39xVAAAAAGgeiGEm4O7uLoqiuasAAAAA0DwwKREAAAAAZEUMAwAAAABZEcNMIDc3t7Cw0NxVAAAAAGgeuDfMBFq1aqVSqcxdBQAAAIDmgdEwAAAAAJAVMQwAAAAAZEUMAwAAAABZEcMAAAAAQFbEMAAAAACQFTEMAAAAAGRFDAMAAAAAWRHDAAAAAEBWxDAAAAAAkBUxDAAAAABkZWXuAtDM5OTkjBgxwtrauh7b3r59283NzUCDyspKC4uaLw3k5eUplcp67FSiUqlKSkoa0oNOaWmpnZ2d/iMFBQUuLi716+3mzZtt2rSp8anc3NxWrVrVr9sqioqKnJycat1j/ZSUlDg4OAiCcO/ePWdn5wb2VlFRUb9PV5VORowY8eGHHzawn1pdu3YtNja2Hhuq1Worq/r/93vr1q3WrVvXb9uMjIwuXbrUe9eN15vug5SVleXu7m6SPmtk2lfAvHsx0ksvvWTuEgAAVRHDUDd79+49d+7cyJEjDbTRarU1Pq5Wq9u3b29gw8rKSlEUa3xKo9EY3tbAfgVBKCwsvHfvXq091NqPIAhFRUUKhaLKg/fr2XBXgiCUlJTcb9uKigrDBdfauU5+fr4ugqpUKiNfByP3oktf1tbWDc+NZWVltra2Ru76frKzs1evXi1DDBs5cuTFixerxHIZGLhgUStRFOv9wlan1Wrv9ztb764acnTGaOz+5dyLMUpKSvbu3btr1y5TdRgWFpaent7wyyUS/YtEOnfu3GnZsmU9etOFecOMvJBRY23GuN9FtAZeq6rxKlVhYWH1P0l1VWPB9Tt8Y+opLy+3sbExprd6vwUVFRX79u1r165dPbYFZEMMQ53Z29vv3r3b3FUA97Vu3bp58+bJsCMbG5unnnrKhCe4gMn17dvXtB3u2LEjICCgfjGpuvz8fFdX1yoPWlpa1m+818icU1ZWZswJer3TYHl5eY39W1lZNeRalf5VKh0bG5uGT/SoseD6Hb61tbXhaS9CTZNK7qfGj4cx9u7d++effxLD0MQRwwAAgLEsLCxWrVrVv39/cxcC3FdDZn0DsmkSUyYAAAAA4O+DGAYAAAA0USa8oRdNCjEMAAAAaKJMtRISmhpiGAAAAADIihgGAAAANEWiKFZUVJi7CjQKYhgAAADQFGm1WlN9TR+aGmIYAAAAAMiKGAYAAAAAsiKGAQAAAICsiGEAAAAAICtiGAAAAADIihgGAAAAALIihgEAAACArIhhAAAAACArYhgA1J8oiuYuAQAAND/EMAAAAACQFTEMAAAAAGRFDAMAAAAAWRHDAAAAAEBWxDCgGVCr1dHR0VOmTElPTzd3LfgfWq3W3CUAAIDmhxgGVJWWltarV6/g4OC8vLykpCRRFKWf9dtUVlYWFBQUFBSo1WoZSrpy5cratWs3bdq0bdu2emyuUqnCw8NFUUxKSsrLywsODpZ+Nnmdf0OslAgAAOqBGAYYolAoPD09raysLCz+55eloKBgwoQJQ4YMuXLligxldOzYcfDgwV5eXoMGDWpgVzY2Nq1bt1YoFJaWliapDX9z0qUKnfDwcJVKZaB9bm7u66+/HhERUVxcXGvnERERjXrJID09fcqUKdHR0fJcT0FzZ8wlLa1We/fu3by8vPLychnqycvLKyoqul8D6ddT+q2MiYkx5jcUgGyIYYAhtra2Dg4OHTt2tLOzM2MZjo6On3322cWLF5944okGdmVlZeXg4NClSxcXFxeT1IamTIoxMTExutPHmJgY0+7Czs4uKCgoKCjI19fXmPZxcXFffvnl4sWLU1JSTFuJjvGD1du2bdu0adPatWsb73qKDG8BzOJ+l7RKS0vfeecdNze3EydONHYNO3fudHNzW716tTGNW7duLQiCpaUlY/hAE2Fl7gKAJqr6CFhzxwhYY2gu94bZ2Ni4uroKgmBlZeL/9vv27RsbGysIQlJSUkBAQK3t+/Xr5+/v3759+27dupm2Ep2CgoJJkybduHHj+++/9/LyMtBy0KBBXl5egwcP7tixYyMVo9N4bwHMotld0nJwcBAEoW3btua9qghA54E6ywRMws7OztHR8X4jYNK8Djc3t9jY2NTU1O7du1efjiW1EUWxV69eaWlpx44dCwwMFEXR19d3165duhN36TK5KIrdu3efNm3a4cOHKysr9felm/SiU2X2i3R9/cknn8zMzFy6dKmHh4ezs/PYsWMvXryo38zS0rJ5nS7A5CwtLe3t7QVBkCFvGObl5ZWYmLh9+/Y2bdqYtxJBEJ544omLFy9+9tlnjo6Ojb2vpvMWoIGa3SUtRsCaNVEUKyoqzF0FGgUxDKjKyclJoVAYeDYoKGjIkCGurq4KhWLgwIFB/9WqVSvpT53Upnfv3hkZGWfPnl20aFFxcbGvr+/x48fnz59//vx5QRAqKiosLS2lDQVB2LBhw+DBgz/++GP9aVQWFhadOnWS2hi4qJ+bm7tu3bpvv/3W09Ozffv2P/zww0svvZSZmalrYGNjQwD7O2P4xex4Cx4Mhi9pSTdiOTg4REdHC4IQEBCgu4JWZZ2nsrKyHTt2SJfnlErl9OnTU1NT9YfWtVrthQsXFi1a5Ofnp+uke/fuJ0+eFPSu0E2ePFkQhMWLF9/vap2dnV27du0YAWvWtFqttbW1uatAoyCGoW7Ky8ubyyysenNxcdm6detHH31kZ2fXtWvXhIQE6Wfp2ZCQkNjY2B9++KF///5dunRZt25d7H9FRERIzaQ28+bNKywsPHv27IIFC44ePXrkyJGIiIgLFy5It8RYW1vPnz9f2vDixYvXrl0bP378mjVrTp06pV+Jrv9Jkybdr+DU1NSCgoKzZ88eOHDg5MmTL7/8clJS0vHjx/XbzJkzJyEhoWvXrnZ2dh999JH0c6O8fH8zTfwas5OTk3Cf4ReNRiOdvVW5VSkrK8vf39/f3z8rK0t6pNZhW2NUWcmj+uqjgiCoVKrPP/9cGmEODAw8duxY9X4MF2PMYLWgN15tYFkRtVq9c+dOAyfKUieHDx/etWuXr6+vNNy9c+fOKi+OgbcAzY7hS1rSfZKBgYHu7u6CIPj6+uou0nXq1Ek3y12lUr377rvPPffc6dOnhwwZ8vDDD3/77bchISG//fabrqv4+PiAgIDly5fn5OQEBgZKnTz00EPSKJzuCl3v3r0FQfDy8grSo5+4nJycpFvCADRBXJ9D3djY2DTx886Gs7Cw0P2htbKyauA40p07d6TLmVZWVoGBgdbW1jXmn44dOz799NPbtm1LT0//xz/+Ude9jB8/XhrBc3R0HDRo0Lp166osTiCdC0patGhR9+NAzZr4VQkDZ2CWlpZPP/30+vXrjxw5EhoaKs2XEwQhNTX16NGjixYtkpKDbthWEISsrKwNGzZs2LBhxYoV8+bNq9MIj3SGKnWYmppavUFZWdmiRYtWrVrl6uo6ZMiQ4uLipUuXdurUSb9NrcVIA9HSLioqKnr16qU7Lt1gta6ZIAgqlarGlULUavWqVaveffddacS7oqLi22+/PXjw4MaNG6usVrp///6EhAQbGxtfX99jx45NnTp106ZNISEhugacBD9g5syZ8/rrr0vzEj/66KPKykrd7AnpPkmVSjVnzpzo6OhPPvnE39+/eg9Hjx79+uuvp06dunLlylatWmm12oSEhOnTp2/YsKFfv36Ojo7l5eX79u3Lz8/fsGHD888/X/0uZekKnSAIMTExkydPnjRp0qJFi2qsVrqSKI2l9O/f//bt27a2tqZ8OQA0ADEMaFyPPPKI7s+er6+vbjW5ysrKw4cPR0VFHT9+PCsry9XVtd63yvj4+DSF22z+hoqKivLz881dhSGhoaG3b9+WThPnzJnz6quv6k+49fT0lMJDdna2NOu1vLz80KFDCoVi0KBB0nV3adh2/vz50iZ//vnnW2+9tWbNmiFDhtTpeoFuJY+8vLwah3ZTU1O3bNkyfPjwqKgoDw8P3bmpfptaiwkJCQkJCZF2cePGjXXr1tU4m1dqJghCWlrauHHjqjdIS0vbuHGjj4/Ppk2bHnvsscrKyi1btrz66qtr1qzp2bOn/qWZhISE9evX9+jRQ6vVxsTEPP/883FxccOHD9eNSBh+C9DsNPCSllarPXLkiJOT0yuvvNKqVStBEERRDAgICA0N/e2333JycvSXrrl69WpBQYGrq2u9r37qX0m0sbFRKpX16wdAY2BSItC49P9m62i12m3btoWEhFy4cGHy5MnS5fzOnTvLX94DKSMjQ54xWycnJ2ntuybL3t5eqVTa2NgIguDk5KT7WeLi4jJ8+PDU1NTExETpkZycnOPHj/v7+/v4+NTYoTRsm5OTk56ebtpSk5KScnJyxowZ4+HhIQiCKIp+fn7BwcEGNmm8Yk6ePHnhwoXnnnuuR48egiBYWFg89dRT0jzJjIwM/ZbBwcGPPvqoVHD//v19fHw0Go3+GKnhtwB/N6WlpTdu3BAEYceOHR/91+rVq9PS0tRqtUajEQTBxsZm4sSJ/fv3X7p0qZubm7e392uvvfbzzz8b81V7AJoRRsMAM7hz586WLVv69eu3adOmDh06SA+6u7tLwwVooC5dusg2V7C5z9ENCAjw9vZOTEwcP368o6PjpUuXjh49umrVKt1VcxMO2xomfQWtFHsk9vb2ut8OmYuR7ot76KGHdO+vnZ1d69atc3JySktL9Vt6eno2988A5JeTk7Ny5coqD+pf++jXr9/Ro0dPnz69f//+X3/9NTIyMjIy0t/f/+uvvzb8HQwAmhFGw4D6cHBw8PDwSE1NPXbsWD2WK6isrFSr1S1btpS+yEUQhMLCwt9//71du3amrhQwpFu3bk8++eTx48czMzM1Gk1CQkK7du0GDRokRYsmNWzbpIoB6sfOzq5jx44KhSI+Pl77v1JSUvQjlpWVVf/+/RctWnTo0KGioqKlS5cmJSXt3LnTjMUDMC1Gw4D6sLe3HzFixJYtW6ZOnbpmzZpWrVpVVlY6Ojp+/fXXjo6O77///u+//56bmysIwqpVq7777rvOnTuvXLlSN0ffycmpR48eq1atun379pNPPllWVrZnz55p06Z5eXmtWrXq6NGjb7zxhqen5xdffLF3715pE+ny/Jtvvuns7CwIwtNPPz1r1iwzHT3+fxUVFdVX2GtebG1tBw0a9Pnnnx87dszFxSU5OXn48OHdu3eXnq3TsK1CofD09Kx3JdL03czMzBpXNahrMQ0krXR39epVrVYrJdLS0tJbt261a9eOhb9hmBS0BEE4ePBgv379qiyJIYpiUFBQZGTkkiVLnJyc+vfvX30Fjurs7e2l+c9V1l7y8PBQKBTHjx//888/WY0TaHaIYUA9PfPMM7t37167du2vv/56+vRpQRCeeuqpu3fvOjg45ObmxsXFSc2kp4YPH64/aGZra7tkyZLWrVt/8803ixcvHjBgwBtvvBEcHBwbG3v69OnTp09PnDjR09Pzzp07un4kuiW8AwICZDpO3J+1tfUDcFLu6+s7ePDgw4cPt2jR4tChQ+vXr9d9l3Gdhm1btGjRqlWrY8eOZWZment7C4KgVqstLCyMOcsUBKFnz54KheKHH34YPHiwlLL+/PNP/e9dML4YabA6Njb22LFjnp6eRhagr2/fvt7e3j/++GNISIi0RMfPP/8cHx8fGBjYpUuXuvZmXhqNhu9+lZP0fQzr169fvHhxTEyMFOnLy8ujoqKkwa4+ffpIK834+vp6eXlJDXJzc994440pU6YIgiCttbh//37p01tZWZmenp6VleXu7j506FD9fT3yyCPBwcE//PCDj4+Pj4+PtbX1vXv3Xn/9dQNfcPI3YWVldevWLXNXAdSCGAbUk4WFxZAhQ4YMGVL9qaioqKioKMObKxSKt99+++2339Z/cP/+/fr/XLRo0f2WIZbY29tX39GkSZP4GwzjtWnTZuDAgZ999llsbKyPj49+wjdy2FZq3LZtWz8/v1WrVgUEBPj4+KjVaisrq82bN7dv376goODtt9/Ozs4W9BasDwsLk9bR/uCDD/r27evr6/v8889HRkYeOXJE2lyj0ejP0TK+GAOD1UqlMiMj45///OedO3cEQVCpVBkZGXfu3Lly5YqFhUXLli0//PDDLl26eHl5vfDCC++++66/v3+vXr0qKiqOHTvm7u4+e/bsZvdN6JaWlnz3q8z69u27e/fuL774Ij4+XrqU1rt3b+nuR0EQrKysXnvttYEDB37zzTexsbFSAy8vr7t370oN1Gq1tI5LfHy89Iivr++zzz770ksv6UaqJS4uLl9++WWfPn22b9+ekJAgCIK7u3v1b+T7G1Kr1XxXBJoBLRps9OjRffr0MXcVMvnqq68UCoW5qwAMke1T2qdPn5CQEBl21NiOHz8ujSn93//9X2lpqf5T9+7d++ijj6Q4NGDAgK+//vr69evDhw+X/oIkJibqN87Ly1uwYIF0dd/Ly2v69OnXr1/XarW3b9/WbVKdrpOioqLPPvtM2tewYcN+/fXXTZs26TcwvhiNRnPw4MGwsDDdUpZPPfXUlStXtFrtxYsX77cOpI+Pz8WLF6UeKioqduzYMWzYMEEQXF1dp02blpKSUllZqdvF5s2bBUHYvHmz7hGp55kzZ5aUlJjw3Wkgk39KLS0tf//9dxN2CJjcg/QpFQShuLjY3FWgUYjapv3do83CmDFjsrOzT548ae5C5LBu3bp58+bdu3fP3IUA9yXbp7Rv376dOnXatWtXY+8IqDeTf0qtrKySk5P79+9vqg4Bk3uQPqWiKBYXF+smY+NBwkqJJlBRUSF91wcAAAAA1IoYZgLW1taWlpbmrgIAAABA80AMAwAAAABZEcMAAAAAQFYsWG8CWVlZrA8LAAAAwEjEMBNwd3cXRdHcVQAAAABoHpiUCAAAAACyIoahbjIyMhj6AwAAABqCGIa66dKlC1/5jSZOo9HwKQUAAE0ZMQzAg8bS0pIxWwAA0JQRw0yA6+4AAAAAjEcMMwGuuwMAAAAwHjEMAAAAAGRFDDMBJiUCAAAAMB4xDAAAAABkRQwzAe4NAwAAgMmJolhRUWHuKtAoiGEAAABAU6TVaq2trc1dBRoFMcwEuDcMAPD3wV89AGg4YhgAAKgDpuIDQMMRw0yAP0gAAAAAjEcMAwAAAABZEcMAAAAAQFbEMAAAAACQFTEMAOqPW0MBAEA9EMMAoP5YuRsAANQDMQx1U1BQUFlZae4qAAAAgGaMGIa6cXFxsbDgY4MmTaVSMUgFAACaMs6nATxo7O3tuWULAAA0ZcQwAAAAAJCVlbkLAIDmKj8/39wlAACAZonRMACoJ1dX106dOpm7CgAA0PwQwwCg/rgJDQAA1AOTEgGg/liSEU1cbm6uWq02dxWA3AoLC81dgmmIolhRUWHuKtAoiGEAADywWrVqxdRZ/A0pFApzl2AaWq3W2tra3FWgUTApEQDqqbi4+M6dO+auApCVpaXlrVu3zF0FADR7jIbB/L799tudO3deunTp7t27Dg4ORk4kqKysNP6LpOvUWKPRWFpaGtlYn1qttrKq8++URqOxsLAwyS1G9SugRnV6xeqnrKysRYsWbdq0+cc//jF37txu3bo16u4ag6OjY8uWLU3e7ZYtW06fPn379u06fSoyMzM9PDyM//Rev369Q4cOgiCkp6d7enrW2t7IZrVuaHw/9d5jFVlZWe7u7tLPN2/ebNOmTf360b22pipMnyiKrVu37t+/f2hoqGl7NjmNRtO6dWtzVwEAzR4xDOa0bNmyTz75pKyszNvb28/P76GHHjI+RdTpTKjxGjd8w/T09M6dO9va2tZjjyYpoEaFhYWNPaPj3LlzHTp0uHDhwu7du9euXevj4xMfH+/m5taoO23Kdu3a9c9//jMtLc3GxsbV1dXR0bFOSbiwsPD69etardbI8FZcXJyZmSkIwr1794wZ3Lh79279xkCq9G/k7urU0rDCwsI///xT+lmlUl2+fLl+/eiuTZiqsCqdFxYWrlq1SqPR+Pj4REZG+vr6mnYXTdaJEyfWrl176tSp3NzcO3fuODg4NLzPiooKY+Zx1fr7YpJrWw3vxMjDMbx5XS+u1ftinJEXgzw9Pa9everi4uLt7T1x4sRnn322HvsCmjViGMzm6aef3r9//6xZs1avXm3uWmBmFy9eHD9+fKdOnX755ZchQ4aYuxwzeO6553bs2BEYGLhly5bevXubuxyYzcGDBxcsWODn5/fqq69++eWX5i6ncZ08eXL8+PGXL192d3fv3bv3iBEjTp8+PXDgwIb3fPnyZWMG2EtKSgynPpNc28rJyWnXrp3+I3UNZg0sIzs7u3PnzgUFBS4uLsZvVVxc7OjoWI/dGT/mXFZWduXKlZSUlHHjxrVs2fL999+fOXNmPfYINFPEMJjHnDlz4uLiDh48+MQTT5i7Fphf9+7dU1JSQkJCRo0a9cAsb2W8SZMm7d2799///vfTTz9t7lpgZkOHDk1OTo6MjJw1a5ZCoVixYoW5K2os69atCw8P9/f3P3HiRGNM7kXzMmXKlPDw8BMnTqxfv97ctQAyYYkOmEdkZOR7771HBoO+3bt3t2zZctSoUeYuRFYnTpzYsmXLhg0byGDQefXVV5cuXbpq1aoHdaHqrKysV1999eWXX/7tt9/IYBAE4bvvvtuwYcM333zzxRdfmLsWQCbEMJjBO++84+joOH/+fHMXgiZn8eLFcXFx5q5CVnPnzu3du/f48ePNXQialoULF7Zt23bKlCnmLqRRhIaG9ujRIyoqytyFoAl54YUXpk+fvnjxYnMXAsiEGAYz+OWXXwYNGmTuKtAUvfzyyxqN5pdffjF3IfL5448/Zs+ebe4q0BRNmjTp119/bWAnKpXq3r17JqnHVMrKyk6fPk0GQ3Xr168vKSn55ptvzF0IIAdiGMzg2rVrgYGB5q4CTZSbm1tCQoK5q5DJlStXSktLX3jhBXMXgqboxRdfvH37dgM7sbe3b9GihUnqMZU1a9YoFIoBAwaYuxA0RY899tj3339v7iqaEFEUH9TJySCGwQxKSkp8fHzMXQWaKKVSmZ2dbe4qZHLy5EmTfFcBHkjS4niXLl1qYD9ardYU5ZhMcnKyh4eHuatAE+Xr65uWlmbuKpoQrVbbkK8rQFNGDIMZqNXq69evm7sKNFHXrl377bffzF2FTJKTkxv7a7LRrImieOjQIXNXYWI3btxo3769uatAE+Xl5XX37l1zVwHIgT//MAMLC4suXbqYuwqjqFSq8PDw4ODgvLw8IzfJzMzcunVr/XaXlJQkimJSUlL9NjdGXl5ecHBwRESEMY0zMzMDAgIatZ7qunXr9veZrfTII480/MthZSN9PmNiYoxsX1lZeeDAgZSUlPrtLiIiok6/evWQlpbWq1cvY45Iq9WuWbMmPDxcpVI1Xj3ViaL44H2P3Pnz58+cOWPuKtBEnT59uqioqIGdWFpamvw71gGTI4YBppSXlxceHn758mVzF2ICxcXFH3/8scwZDA+S5OTkoKCg4uJicxdiAr/99lvz/aJ5URTNXcL/6NatW//+/c1dhbEiIiJ69epl/DS53NzcmJiY+sV16cJfY6d94y9wFBQUjB071vgrLybh5+dnb2/fwE40Gk3r1q1NUg/QeJrNVVjALOzt7f+eyzTKd5oAACAASURBVHkVFhZ+8MEHkZGR5i7kAVdQUFBZWWnuKozl7+/f1O4ykoFWqz169Ojs2bOzsrLk37uVlVXDL+r/Dd81c1GpVIsWLRIEITQ01Ny1NJRarf7qq69++OGHkJAQc9cCPJgYDQPwP7Ra7alTpyZOnLh169axY8eau5wHnIuLC/eGNWXFxcWfffbZqFGjOnXqxMJCf0+LFi1KSUnx8vIydyGyKisrW7t27fvvv2/uQoAHGX/+8SCTbvzYuHHjtm3bfH19RVEMDAzcuXOnWq3WtdFqtcnJyRMnTlQqlc7OzmPGjElISNANUFS5NywiIiI8PDwrK2vhwoUeHh7Ozs5jx449deqUdLE5KSnJzc0tNjZ28eLFBm6hqaysTEhIGDNmjLOzs4eHx9y5c69du3a/Q/jrr78WLFjQvXt3URR9fX3Xrl2rP8Wr+tyS6rd+Xbt2be7cuR4eHh4eHmvWrKl1rkt+fv78+fOvXbsWExPzzDPPGG7cGG7dunXlyhX59/vAkz4tKSkpM2bMUCqVNX721Gr1vn37RowY4ezsrFQqp0+fnpqaqhtL0b83TPrViIiIyMzMlDpUKpUzZszIzMzU7S4gIEAQhICAAANzuoqLi9euXSv9evr6+kZFRd3vI2r4V7XGu7xiYmKq7Prs2bPTp09XKpU9e/bctm2b/n8FNdq1a9fcuXNnzJjxxRdftG3b1nDjxqBWq5lbBZlJv9QLFiwwyzhYRkZGM5ojADQEMQx1k5eXZ5L/H+X8OtGoqKjly5ePGzcuLi6uQ4cOzz777OrVqzUajSAIWq1269atw4cPV6vV69ev37p1q729fUhISGRk5P3Ozy5dujR16tS7d++uW7fuiy++yMzMDA0NPXnypCAIXl5ee/bsGTBgwMsvv5yQkCCdg1ahVqs//vjjoUOH2tvbb926dcmSJQcPHpwyZUqN850uXLgQGhp64MCB2bNnx8fHjxw5cuHCha+88kpubq6Rx56enh4WFnbw4MElS5asW7fu1KlTCxcuLCkpMbCJhYXFiBEjDhw44O/vb5ZbSlq3bt21a1f592sWMk9KvHjx4tSpU4uKir777rt//vOfv/zyS1hYWHp6uvSsWq1etWrVuHHjPDw8tm7dGh0d/ddff4WEhPz000/3m9V29OjRyZMnd+zYcfv27QsXLvztt98mT54sJbHnnntOmtQaGRn5r3/9q8aV8W7evDlp0qSFCxeOHDkyLi4uKCjo7bffXrZsWVlZWZWW9fhVrS4pKemZZ565evVqdHT08uXLY2Ji/vWvfxl+/RUKxYEDB95//32FQmHkXtB06G61Onr06NixY52dnbt3775ixYr8/Hz9ZrVe7dKFeSntHzlyJD7+/2Pv3uOiKPv/j8+yCwgKKSCIohCJ4JGCFA95xFNWiqdMTVFL0bzLSDNvD1kaiqmZmQpqJXns9qt5d3f3NchTit5qnhNBlEBU5KAiR4Fd9vfH/L772HtBXJZlZsHX848esM5c816a2Z3PNTPX9Vv//v0VCoWfn9/atWvF5ZOSkrp16xYdHR0dHW1vb1/FSEjZ2dmRkZHiFit2Dup7+PDhF198ERAQIG4rMjJS//O/0lGdDLrniouLo6Kiunbt6ujoOGXKlCp6/XTLR0ZGHj169Jtvvpk2bVrVC9cGb29v7hHAU4Jnw1A9zs7OZvl8dHR0rHkjRsrIyIiJiendu7cgCH379vXw8Pjuu++GDBnSvn37hISEzz77bMKECZ9//nnDhg0FQejfv/+nn366atWqrl27vvjiixVbO3z4cGRk5OzZs8UB7tq2bRsSEnLs2LEXX3zRxcWle/fujRs3btmyZZ8+fSoNc+7cubVr1y5dunTevHliC4GBgW+88cbevXvDw8P1lywsLPz8888FQYiJiWnbtq0gCP369evcufOYMWMCAwPfe++9J9ZIGo1m27Ztjx492rVrl9hC3759IyMjY2JiBgwY8Li1mjRpMmvWrKpbhrlIfFNiWlraK6+8otvbu3Xr9sYbb2zbtm3x4sVKpfLo0aMRERELFizQ7d79+/d/7733xLPASid6io+Pj4qKGjt2rEKhCA4O9vT0HDly5KVLl7y8vNq2bSue7Hbq1KlHjx4V19VqtTt27Dh9+vSePXv69esnbq5ly5aLFy8ePnx4ly5d9Bc24VA1UFhYuGXLlg4dOmzZskW8rhUcHBweHn758uUq1ho6dOgTW65tDPhWQ8ePHz9y5MiAAQP27t179uzZlStXnj59Ojo6umnTpoIgXL16dfLkyeXl5bNmzWrTpk18fPzChQtPnjy5evVqcYGKNm3alJycPGPGjI8++uinn35atGhRenp6RERE8+bNV69e/fXXXwuCMGPGjJYtW1a6urjF3NzcsLCwDh06/Pjjj5MmTVq2bNnMmTMNlszMzAwLC0tMTJw8efLKlSsvXboUHR19+PDhr7/+WpxT7omKi4vnzp0bExPz/vvvR0REnDlz5u23337c+9Lp0KHDvHnzvLy8GKIJqFX0N6D+GzdunO7ClEqlGjNmjFqtjo2NFQQhNjZWrVaHhYWJJ3aCINja2r7xxhs2NjZxcXGVtubj4/Pyyy/rBhl/9tln27dvb/zougcPHnR1dR09erSuBR8fn759+6akpBg0kpiY+Ouvv06ePFmsoARBUCgUL730UkhISFxcXG5u7hO3lZmZeezYsSFDhrRp00b39ocOHWrk9zckkJKSIuUlRx8fH/29vX379iEhIQcPHrx161Zpaem///3vwMDACRMm6HbOxo0bT5gwIT4+/tSpU5U2GBgY2KdPH91baNeuXceOHfPz840Jk5ube+jQoaFDh3br1k18RaFQ9OrVy9fXNyEhwWBhEw5VAzdu3BCvhunuLWzYsOHo0aONWVdGSqVS7gjmV1RUJOXEUFeuXJk8efKaNWsGDBgwb968Xbt2/fbbbz/99JPw371dM2bMCA4OXrRo0fbt2/fv379z587HXQROTk7+7rvvQkNDBwwYsGrVqsmTJ588efLu3bsODg7du3d3c3Nzc3Pr2bOn7qNbX0lJSVRU1KNHj3788cfw8PABAwZ89dVX77777vbt23U39Io0Gs369esvXLgQHR390Ucfib0GO3fuTE9Pj46OrnjFuFInTpyIiYnZsGHDp59+GhwcPG/evI8++ujQoUNVrGJnZ/e3v/2N+bUBCVCGQQZmGfvLeO3bt9c/lWnRooW3t/f169dzc3OvX7/u6enp7u6uv7y4QFpaWqXPqDRt2vSZZ57R/WplZaVUKh88eFBaWvrEJMXFxWlpac2aNXNxcdG9aGdnt379+q+//trgrqfr169nZGQYfJE7ODj4+PjcunXLmD9gRkZGUlKSn59fxbf/xHUhDW9vbylHsfP29m7RooXuV6VS2b59+8uXL2dkZBQWFl67dq1169aNGzfWX6VVq1b+/v7Xrl2rtEEXFxddXSQIgkKhsLKyMvLozsrKunXrVosWLfQHp/b19T18+PCkSZP0l3z06JEJh6qB1NTU5ORkgwNKfHfGpJVLvRx3297eXv9TtLb16dNHv3OhW7duISEhBw4cePjwoWm9Xf369dP1bdna2gYGBhYWFj569MiYMOnp6fHx8aNGjfLz8xNfUalUQ4YMUavVBs/E3rp16+DBg/rdiIIg+Pv7h4SEHDly5In3FgqCoNFoDh48GBgY2K9fP11fSefOnfv3729MVLkcO3ZMfGoAqPcowyADiT9hK70zRKPRlJeXazQapVJZrbvCHBwcGjVqZPBiUVGR2d+U+KhATfrCHz16lJGRUed603Nycm7evCl3ColkZmZK+WxYy5YtK07Ik5+fLx4OarVaqVRW6+qcs7OzjY2NwYs1n3rVgFarNeFQNSBeo6tzh4PEnVb1kq+vb5MmTXS/ip1Zf/31V3Z2tmm9XU2bNtXfkcSZgo3c7TMzM8+ePfvss8/qH2g9evT4448/DKqjjIyMy5cvG/SjiV0nZ8+ezczMfOK2CgoKkpOTDfpWxHdnTFS59OzZs84dp4BpKMMgA61WK2X/rkGvoVh92dvbq1QqpVIpnoBKFsZ4Yt9tdau7kpIS3c0qDRo0cHd3r3Pdii4uLq1atapJCzk5OZb5/7QiNzc3KZ8NS09PN7hwpNFo3N3dGzRoYGVlpVKpNBqNBc4xpVAoTDtU9c+MxavNde5wMMtIiZY2fXNpaWmtTk9soFmzZg0aNDB4Ua1WazQa03q7Kv4fycjIMPJqmPE0Gk1+fn5NChK1Wi22YGk7AAARZRjqv7/++kv/zDIjIyMtLc3X19fR0bF169ZXrlwxuPZy+/btlJQUT0/PitcNaqhBgwYeHh53797NycnRvajVapcsWfL666/fvn1bf+HWrVu7u7uLYzDq5OfnJycne3h46M4D9OsuQRBycnJ07bi7u/v6+l64cEH/hsmcnJy7d++a931ZGhcXFwbaqpTBvqfRaBITE319fd3d3Rs2bNimTZuEhASDcThv3rx58eJF3S1YZuTs7Ozu7n779m39M/Ls7OzXXnstIiKirKxM92KDBg2MPFT16y6NRqM/AKmXl5ePj4/BAZWTk5OSkmLe92Ve4pUWuVOYmY2Njdk/Xatw9+5d/RpJvLjasGHDBg0amNbbJQ2lUung4FDdbBqNRndAqVQqsQUL7FsBIFCG4Wnw888/JyYmij+XlJTs3r3b3t5eHMlw4MCBjRs3/vbbb3XDE4sLFBQUBAcHm7zFx33tKRSKgQMHZmVl7d+/Xzc88Z07d44cOeLu7q7/wJggCH5+foMGDfrhhx+uXr0qvqLVao8fP75///5+/fqJN5m4uromJSXdunVLXECc9Ek3/ribm9vAgQP37dt38uRJ3QL79++/ePGiyW8NBmrYzZySkiLlGdLFixf19z3x14EDB7q5udnY2LzyyiuXL1/Wn00rNzd327ZtQUFBBuMWVsvjziOdnZ0HDBhw4MCB06dP6148f/780aNH27Zta21trb/wEw9VBweHJk2aJCQk6Holrl27pj8UgY+PT79+/fQPqMLCwp07dxo5oIhczPJs2FN+Fp6WlqY/AH1BQUFKSspzzz3n5ORkZG+XGbm4uPj7+xt0DiYmJvbq1Wvr1q36S7q7u3fs2NGgH02j0Vy5ciUwMNDNzU33ov4cJEVFRbpvhEaNGvn4+Bj0rRQXFxt0+VkaC+8ZAcyIAeshA+Mf4jeLmzdvhoaGzpw508XFZceOHT///HNUVJTYu9+uXbuFCxdOnz49Ozt77NixNjY24gKLFi0KCAgwYVs2Njaurq4HDhzw9/cPCAjw9PQ0WCAgIGDWrFkRERG3bt0aOnTonTt31q9fb2VlNX36dFtbW/0lGzZsOHfu3MmTJ4eGhk6ePFkcSXnt2rWDBw8eP368ePbfp0+fjRs3Tps2bdasWa6urmLB2bdvX7EFpVI5ZcqUU6dOhYWFiSMj//TTT3v37rXwGZAKCgr0J6S2cDU8wbW2tpby/kkHB4e1a9eK+96ff/4ZHR3t5+c3ZcoU8can3r17L1iwICIiIjU19dVXXy0uLt6yZcuZM2fWr19v2rBp4lMoMTExWq02ICDAYMdTKBTjx4///fffxf2zU6dO4h4+YcKEQYMGGTT1xENV7HSYP39+WVnZ8OHDr1+/HhMT4+PjoxuP3s7ObtasWeIBpfs0OHjwoIUfDqi5+Pj42NhYcVoFXWfWxo0bHRwcdL1dgwcPFp8Q0y3wySefGAxXY7wqLkB5eXn17t37559/HjlypG6Lx44du379ert27fSX9PDwCA4O/v7774cNGyZOuCL8X9fJgAEDxGeexUPs8uXL4iRmgiCcO3fu999/F8f/UCqVgwcP3rp16+7du3WzUJw+ffrAgQO6AUIsEINI4elBGQYZlJeXS/ls2PLly21tbb/88suEhITg4OB//etfvXr1Er+xFArF2LFjW7RosX79+rffflsQhODg4H/+85+9e/c27a42BweHd955Z+7cuSNGjFi2bNnf//53gwVUKtWHH34YGBi4evXqkSNHOjk5jRgxIjw8vNJxRNq2bbtnz54vv/xy7dq1SUlJvXv3/uyzzyZOnKgbm87X13fbtm2rVq2aNWuWk5PTm2++uW3bts8++0zXgpub27fffhsVFbV27dr79+8PHjz4+++/X7VqlQlvTTKNGjVydnauSQtSjntRw6thLVu2lPJh9O7du0dGRm7YsOGNN95o2rTppEmTpk2b5uTkJP6rSqWaPXu2j4/P5s2bx44d6+Tk1L9//xUrVnTq1Mm0t9muXbvZs2cvX758z549sbGxXbt2NVjAzc1tx44dW7ZsiYmJOX/+fFBQUERERGhoaMU71p54qCqVyvfff79JkyYbNmzYuHFjcHDwsmXLbG1t9ediEg+o1atXf/DBB4IgjBw5cvv27R9++KEJbw11iJ2d3Zw5c65fv96tW7eTJ0+KpX5ISIhgXG9XtdjY2Dg5Oe3cuXPPnj1dunSpOGa9ra3t9OnTT506JXYHNG/e/KeffoqJiVmwYEFAQID+vbhKpXLmzJmXLl0KCwubPHnyiy++KM4b5uLi8s4774jdduI13k8++SQ3N7dnz57nzp3bu3dvUFCQbj6A7t2763f8/fnnn998842UD+YBqIoWNRYSEhIQECB3Cols2rTJwcGhho0olcrTp0+bJU/VEhMT/f39t2/fLsG2YC4BAQHDhg2rSQtm2UuNUYeiarXaJUuWDBo0KCcnR5rNwSxq/mlZ873UgAVGepyioiLxWmt8fPzo0aMdHByCgoI2btxYVFSkv9jNmzc/+OADX19fQRB69+69YcOGgoIC3b8uWbLE398/MTFR+5jvlO3btwuCcPz4cfHXa9euDR8+XBCEd955p7i4uNJgWVlZixYtErcYHBy8d+/esrIy/cC6hPfu3Vu+fPkLL7wgCMILL7ywfPnyrKws/abu3bsXERHh6enp4OAwevTo8+fPb9++Xf9ILysr27t3b8+ePQVBCAoK2rVr18KFC438KDh+/LggCBJ/h9at0wwJCIJQWFgodwrUCq6GmcGNGzcePHggdwoAAFCJF1544R//+Mfj/rVly5arV69evXp1pf+6aNGiRYsWiT+Lgx4ZLDB+/Pjx48frfvXx8dm3b1/VeZo2bbpkyZIlS5YYvG5nZxcVFaX/ipOT07x58+bNm/e4ppycnObPnz9//nzdK88//7x+HpVKNWLEiBEjRlQdqVI9evTQPt0PFgK1iiE6zOC5556rf9NrPk5KSopZhr41ZrJjPJ3UarX+nTn12+HDh80+zjXqk/Ly8nPnzsmd4r/Uy8EbAUB6lGGoHm9v75r3jVlbW9+/f98seVD/FBUV1aF+jRr2Srz88svic/PA43Tr1k3uCP+l5oM36ibsAioqLS3lEhyeEnz9QwaNGzc+ceLEa6+9VtsbqvQGEli4rKys9u3by53CWDU8XWjfvr1kV8N0N1ahrsjNzdVqtZ06dZI7iJk1adLEwucJgIxyc3OlnFYOkBFXw8zgzp07ubm5cqeoSzp27Pjrr7/KnQKWqKCgIC8vb8yYMXIHkUhAQIBSqTx48KDcQWCJtm7dapbx9M1yJ7kZtW7d2mAm7loiPmoVFRXFaX0dcv78ef1Z0YB6jDLMDJo3b27y7CJPp+nTpzODMCo1ffr05s2bVzp8vwUqLi7Oy8urYSNt2rSx8CkEIJfvvvuuc+fOcqcwv1dffVU3xTBg4NSpUxUntwDqJcowyGDEiBGenp49evSQOwgsS1JS0u7du+vQPE52dnbPPPNMDRuZM2dObGzs7du3zRIJ9UZsbOylS5eWLVtW86Ys7UmbYcOG2draLl68WO4gsDgXLly4detWFSNDAvUJZRjk8csvv/zxxx9Dhw6VOwgsxZkzZ4KCgrp16/b+++/LnaUaan6CO3ny5ICAgC5dupglD+qH27dvv/7666+88kpQUFANm1Kr1RY4Mu2kSZMeN0A8nmZjxozp0qXLc889J3cQQAqUYZCHn5/fgQMHfv/9dxcXl7///e+MmvU0O3r06IABA4KCggIDA48dOyZ3nOoxy1M3Z86ccXBwcHBwWLFiRc1bQ103d+5cb2/vtm3b/vzzzzVvTaVS2djY1Lwd8/r6669btWrl4eGRk5MjdxZYiu7du9+9e/fUqVM1b0qlUjGtAiwfIyVCNn379s3NzX3rrbeio6MjIyNtbW3t7e0bN24s2Qha5eXlVlZWGo1GqVTWsCmTG9FqtRXP48Vg1W2qrKzM2tq69pY3PpWRS5aUlAiCUFRUJAiCn5/frl276uLIHOa63SsxMXHq1KmffPLJxx9//Nxzz7Vu3bpp06bGNJ6cnOzj41PdzcXHx5twV/CNGzcMeqlv377dokULI1ev4jApKSmxtbV9YgsV32x+fr4Jg1gkJyc7Ozs7OTlVa5WKf+cq/vjV/f+i1WozMzOTk5NTU1Pt7OzCw8MjIyONX70uSkhICAgIaNas2dChQz/++OPnn39e7kSQR05OzieffPL99983bNjw8uXLZmlTrVbXoYlP8NSiDIPMvvnmm2+++SYnJycuLi41NbW8vFyyTYvnSaadxRrIzMw0bWSn4uLiikN4mRapumulpqZ6eXkZv3xubq6RQ9EYmeT8+fO9evXq1KlTnz59jI9hacw4Bt3mzZs3b94cExPzyy+/3LhxIykpyZi18vLyTOj0zczMjI+Pr+5aeXl5d+/e1X+lqKgoNTXVyNWrqM+N7Mio+Gar25ugayc9Pd2Ywk/n4cOHFf/Olb74uKhVUygUzzzzTNeuXVesWDFixAjjV6zTzp07t379+jVr1gQGBlpZWTVs2LCsrMze3t6YdU3rrtL1fFV39cftaZV2pVWkVqtrOENgFYGNfy8m9xjqr2jaQVeRj49PYmJiYWFhaWmpm5vb22+//cUXX9S8WaAOoQyDRXBxcRk7dqzcKQD5hYaGhoaGyp0CkMjMmTNnzpwpCMKBAweuXr36888/9+vXz5gVTeuuKi0tFW/RrO511IqXgkVFRUXG1I3GpK26VCssLGzYsKHJjVe6pPFVmf6K169fb926dRULG1maCoIwbNiw5557bsiQIUbW3kA9QxkGACbKycmR8votUI8NHjx48ODB4eHhcgcBAIlQhgGAiVxcXOrKFGcAgLpIoVCUlZXJnQK1gpESAQCoz8z4BCMAiWm1WrM8jAcLRBkGAAAAAJKiDAMAoD4z17QKAAAzogwDAAAAAEkxRAcsxZ9//nnp0qVffvlF+lmkMjIy3N3d9V9JT0+XYOiFx83EVVBQ0KhRo9rb7hOnyk1JSfH29q69ADrW1tY+Pj7du3eXYFsAAACWgzIMMtuzZ09ERERCQoJarba1tS0vL//nP/8pcYaKc1+aNjFodT1uchXjJ12p0zp27HjhwoWSkhJBEFq1ajV16tT58+fLHUpmBQUFc+bMOXz4cEZGxqNHjzw8PNLT0yXbulKp1Gg0km3ucRuVIIaVlZWlzTRQXl5ubW3t6Ojo6+s7ceLEqVOnyp1IatnZ2SdOnLh7965p8wsbMLkvKS8vz9HRUfz54cOHzzzzTM3DPLHnS/S4zDXsFzNy9QcPHjRp0kT/lVu3bnl4eNTS5kRarbZFixa9evWq1Z5HwGJRhkFOvXr1On78eJ8+fX788cdXXnlF7jiQx/nz5z///PMlS5Zs2bIlISGhQYMGcieSx+jRo/ft2+fq6tq3b99+/fq1a9dOgr4AfZmZmW5ublJusdKNShBDlndatWvXrrm4uJw+fTouLu5vf/vbggULNm3aFBISIneuWpebmzthwoSjR4/m5+dbW1vb2NiYpRNKoVCY9kScfi+YxD1ij+sdqGGvgZFzNFd8sxJ0R2q12tLS0rKysiZNmgwaNGjXrl21ujnA0lCGQTYBAQHp6emXLl3q0KGD3FkgpxdeeEH89vX39/fw8MjJyZE7kQz8/f3T0tK2bds2btw4ubNABl27dhUEYciQIZ988okgCCNGjBgxYsQXX3zx/vvvyx2tFi1atGj58uVeXl6LFy+ePXu23HEgj6KiohUrVmzZssXOzm7NmjXTp0+XOxEgEYbogDzmzp2bkJBw48YNajDoXLx4sVGjRr169ZI7iNRGjRqVlpaWlZVFDQbRvn37Zs2a9eGHH965c6fmrVnmTc4LFy6MiIhYtGjR9evXqcGeZvb29p9++unt27cnTZo0Y8aMb7/9Vu5EgEQowyCP6Ojod999V3cLPiDatm3bsWPHMjIy5A4inby8vH379m3cuNHGxkbuLLAga9as8fPzGz16tNxBakVubm5kZOTixYsXL14sdxZYio0bN06ZMuW9996TOwggEcowyODAgQOFhYUrV66UOwgsTs+ePd3d3ZcuXSp3EOnMmTOnWbNmY8eOlTsILM7y5ctPnTold4paMWHCBPFeRLmDwLJ88803tra2f/vb3+QOAkiBMgwy2L9/f4sWLeROAQvVpUuXEydOyJ1COkeOHAkODpY7BSzRq6++qlQqd+/eLXcQ8zty5MiMGTPkTgFLNGrUKOkHTAZkQRkGGVy7ds3T01PuFLBQgYGBT9VNiRkZGX379pU7BSyUq6tr/euVyMrKKigo4HkwVGrq1KlP1VcAnmaUYZDBw4cPnZyc5E4BC9WiRYtHjx7JnUI6jx49at++vdwpYKGcnJxqPkqHaUO3154TJ07wJCQe58UXX9RoNGlpaXIHAWodZRjwBEuXLn3++eeTkpKMXD47O3vHjh3FxcUmbKu4uHj69OnTp083bXUjLV26dPDgwffu3XvcAnfu3FmwYIGfn59CofDz8/v444+zs7NrL48BjUZjaWeNtcrT01Pi+cFQh6hUKrVaLXcKM7t79y5lGKqgVCqlnLkekAvf/YA5FRcXL1q06NixY3IHMd3Vq1dHjBixd+/esLCww4cPh4WF/eMf/xg+QvKWWgAAIABJREFUfPj169fljlY/paamyh3BWGI3QdU1vIHU1FSTp2SNj49XKBTx8fGmrW6Me/fuDR48uOohYZKSksLCwry8vBQKRUBAwNq1awsLC2sv0tNAqVRa5hj6lRL3wx07dhi5fHl5eVxc3IULF0zb3BO7yWouKSnp+eefr+IdFRcXx8TE9OnTR6FQODs7jxs37ty5cxL3jtna2kq5OUAWlGGQwcOHD+/evSt3CmMtWrTowoULvr6+cgeRQmlp6datWx89evTjjz+Gh4f36dMnPDz8H//4x/3797///nuNRiN3QNQl9+7dmz59ep0u4I8ePTpo0KDz589/+umnv/32W0hIyJIlS9566y0prw+jbjl58uTAgQPrbq1eWFg4Z86cd999t2PHjrGxsdHR0ffv3x8wYMD//M//yB0NqG9UcgdAHZOZmVleXl7DRp555plmzZqZJQ/Mq7CwMD09vWvXrl5eXroXfXx8evXqdfr06dzcXGdn59rOkJKSUod6ymtOqVRmZWXJncIodnZ2UVFRcqeQTl5e3saNGzt06LBlyxbxIys4OLhr166jRo0aMGDAW2+9JXfAuiolJaXm3yOS6dGjx1N1m/SRI0e2bdu2YcOG8ePHix/FAwcOfPfddzdt2vTSSy+5u7vLHRCoP7gahupxc3Mzy3Ms0pxn6x61OnHixOuvv+7o6Ojn5xcZGXn//n39xfQfheratevGjRv1OzL1nw0T7+U4duzYb7/91r9/f/HRKd1NSklJSd26dYuOjo6Ojra3t6/iTqfs7OzIyEhxi/3799+3b9/jHv94+PDhF198ERAQIG4rMjJSvxu+0ru2DO5pKS4ujoqK6tq1q6Oj45QpU6q+4b5JkyY7d+6Mioqys7OrYrFa5e3t/VSd9Gg0GldXV7lToBI5OTn37t0LCgrS7zYKDAzs3r37mTNnavUBTp3y8vL6dxW6UaNGckfAYyUnJ/v5+XXu3Fn3Ne3o6Dhw4MDffvstJSVFmgz29vYJCQnSbKtOKCsrkzsCagVlGOQh5Xn28ePHp0yZ4ubmtnfv3kmTJq1cufLtt9/WFTPio1BxcXGzZs367bffhgwZsnDhwhkzZlRx09GmTZsWLlw4YcKE2NjYAQMGLFq0aPHixSUlJc2bN1+9enVISEhISMivv/46atSoSle/evXqa6+9tnXr1rCwsNjY2DZt2kyaNCkqKqri3yQzMzM0NHTTpk1jxoz57bffwsLCtm7d+uabbyYnJxv53ouLi+fOnTt37tyBAwf++OOPbdq0efvtt40fbkR09+7dCxcueHl52dvbV2tFWBSxEyEmJmb37t1du3attAtAq9WePHly3Lhxzs7Ojo6Ow4cPP3z4sO7ChcGzYUuXLp0+fXpaWtrChQu9vLwcHR1ff/113TMk8fHxLi4uv/7668cff1zFozXl5eWHDx8ePny4o6Ojl5fXBx98UEVPwRN7TAweqqn46Fd6evoHH3zg5eXl5eW1du3aqkspb2/vuLi4RYsWVf2HrVVWVlZKpVLGALXB1dVVsmFpxL3iwoUL06ZNc3Z2rnQfU6vV//u///vyyy87Ojo6OztPmTLl4sWLug9k/WfDxENg6dKlqampYoPOzs7Tpk3TPeG5dOnSl156SRCEl156qYqxnQoLCzdu3Cgehl27do2Kinrcrlj1IVnpU147duww2PTly5enTJni7OzcqVOn3bt3Vz3oy/vvv3/69Gl578MvKipq166djAEsjbW1tdwRUCsowyAPKe86u3LlyuTJk9esWTNgwIB58+bt2rXrt99+++mnnwRBKCws/PzzzwVBiImJmTFjRnBw8KJFi7Zv375///6dO3c+rlZMTk7+7rvvQkNDBwwYsGrVqsmTJ588efLu3bsODg7du3d3c3Nzc3Pr2bNn27ZtK65bUlISFRWle/hqwIABX3311bvvvrt9+3aDoRo0Gs369esvXLgQHR390UcfBQcHh4eH79y5Mz09PTo6uqSkxJj3fuLEiZiYmA0bNnz66afBwcHz5s376KOPDh06ZPxfT61W79ixIyEh4eWXX5bxEhnMJSoq6rPPPhszZkxsbGyLFi1Gjhy5Zs0a8XqLVqvdtWvXoEGD1Gr1li1bdu3aZWdnN2zYsA0bNjzuvO3atWuTJk16+PDh5s2b161bl5qaOmLEiLNnzwqC4Ovr+9NPPwUFBU2dOvXw4cPiuakBtVq9cuXKfv362dnZ7dq1a/HixYcOHZo4cWKlY1Wb0GNiIDk5efTo0YcOHVq8ePHmzZvPnTu3cOHCoqIiY/92giAIwo0bNy5duuTh4dGgQYNqrQi5JCYmTpo0qaCg4Pvvv//73//+yy+/jB49WteZpVarV69ePWbMGC8vr127dkVHR9+5c2fYsGE//vjj474CTpw48eabb3p4ePzjH/9YuHDh77///uabb4of4KNGjdqwYYMgCBs2bPj666+bN29ecfXMzMzx48cvXLhwyJAhsbGxAwcOnDt37pIlSyp+qptwSFYUHx//2muv/fXXX9HR0Z999tmOHTu+/vrrat0UWlJScvr0aX9/fxcXF+PXAvBEPBsGGWRlZZWWlkq2uT59+kyYMEGl+v97e7du3UJCQg4cODBq1Kjr16//+uuvixcv1pVMCoXipZdeCgkJiYuLmzhxYpMmTSo22K9fvzZt2og/29raBgYGHj161MiprtLT0+Pj40eNGuXn5ye+olKphgwZ8uuvv964cUP/3qdbt24dPHhw3Lhx+uev/v7+ISEhsbGx6enprVu3rnpbGo3m4MGDgYGB/fr109W9nTt37t+/v5EPI5WXl+/evfvzzz+fNm3a4MGDjVml5o4dO/ZUDeAu8bNhGRkZMTExvXv3FgShb9++Hh4e33333ZAhQ9q3b5+QkPDZZ59NmDDh888/b9iwoSAI/fv3//TTT1etWtW1a9cXX3yxYmuHDx+OjIycPXu2eHy1bds2JCTk2LFjL774oouLS/fu3Rs3btyyZcs+ffpUGubcuXNr165dunTpvHnzxBYCAwPfeOONvXv3hoeH6y+p32MiHq39+vXr3LnzmDFjAgMD33vvvSf27Gg0mm3btj169GjXrl1iC3379o2MjIyJiRkwYICRf73CwsItW7bY2NgMHjxYmr6ke/fuPVX36NaGtLS0V155RbdXd+vW7Y033ti2bdvixYuVSuXRo0cjIiIWLFig24379+//3nvviXeD6z8lqxMfHx8VFTV27FiFQhEcHOzp6Tly5MhLly55eXm1bdtWvOm9U6dOPXr0qLiuVqvdsWPH6dOn9+zZ069fP3FzLVu2XLx48fDhw7t06aK/sAmHpAFxjzV4vjE8PPzy5cvG/wHj4+P37Nkzbty4Sv8aAEz2FJ3rwHK4uro+99xzkm3O19dXv5pycHDw8fH566+/srOzr1+/npGRYXDZSlzg1q1bjzs5btq0qf5tQuJpdEFBgTFhMjMzz549++yzz+qfw/Xo0eOPP/7o37+//pIZGRmXL1/28/Mz2Fb79u3Pnj2bmZn5xG0VFBQkJye3bt26cePGBu/OmKhqtfq777575513JkyY8Omnn0o2fHDPnj3r0OP7dY5+Ya9SqcaMGaNWq2NjYwVBiI2NVavVYWFh4gmfIAi2trZvvPGGjY1NXFxcpa35+Pi8/PLLuj6OZ599tn379kYeC4IgHDx40NXVdfTo0boWfHx8+vbtm5KSYtBIYmLir7/+Onny5Ep7THJzc5+4rczMzGPHjg0ZMkTXh6JSqYYOHWrk4SAIQklJyVdffbV58+bw8PDAwEAj16qhZ555pv4NinDq1Ckpa0sfHx/9vbp9+/YhISEHDx68detWaWnpv//978DAQP2uusaNG0+YMCE+Pv7UqVOVNhgYGCgO5i7+2q5du44dO+bn5xsTJjc399ChQ0OHDu3WrZv4ikKh6NWrl6+vb8WnoUw4JA3cuHFDvBqm6+Nr2LDh6NGjjVlX9Oeff86fP9/b2/tvf/ubZN8Ctra2PBuGpwFlGGSg0WikfOi8WbNmFW8fUqvVGo1GvK+juo9eVBxQISMjw8irYcbTaDT5+fk1eSxErVaLLZjQbV9SUvLFF1+Eh4dPmjQpMjJSdxJQJ6jV6jp0AUHiITrat2+vv1O1aNHC29v7+vXrubm5169f9/T0NDjpFxdIS0ur9NmVpk2bPvPMM7pfxQeZHjx4YMzl7uLi4rS0tGbNmunf6WRnZ7d+/fqvv/7awcFBf2HTekz0ZWRkJCUlGfRriO/uieuKaSMjI+fPnx8ZGTlz5kzJbqtWqVT1b6bjoKAgKe9L9/b2btGihe5XsTPr8uXLGRkZhYWF165dM+irEgShVatW/v7+165dq7RBFxcX/Y9EhUJhZWVl5DXtrKysW7dutWjRQv8eb19f38OHD0+aNEl/yUePHplwSBpITU1NTk42OHDEd2dM2rNnz7799tuCIGzevFnKS2ElJSU8G4anAWUYZKBUKnX9jhK4e/eufo2k1Wo1Gk3Dhg0bNGggxrDMgciUSqWDg0N1s2k0Gt13s0qlEluobk1SWFi4ZMmSjz76aPbs2StWrDA4IbZ8KpXqqRryvlpatmxZ8UWNRiOOyKdUKqt1R6iDg0PFUe+KiorMfkyZ1mOi79GjRxkZGaa1kJ+f/9FHH61evXrFihXvv/++lB9fgrQDGtVLLVu2rPhca35+vrjbq9Xq6vZVOTs7V6yNjb8IbCTxq6q6h6QB8RqdCbu9Vqs9cuTI+PHjVSrVN998U+mjzgBqiDIM9V9aWpr+cGoFBQUpKSnPPfeck5NT69at3d3dxREFdPLz85OTkz08PGrjGoWLi4u/v/9ff/2lf2qVmJjYq1evrVu36i/p7u7esWPHCxcu6F9Y0Gg0V65cCQwMdHNz072oP8ZAUVHRrVu3xJ8bNWrk4+OTkJCgP4ZBcXHx7du3q0hYWFi4YMGCdevWrVixYt68edIPy/G0zRsmMYMx4sTqy97eXqVSKZVK8cRUrmxVMK3HpKSkRDfsQYMGDdzd3U2oD7Ozs2fOnLl169Y1a9Z88MEHkt2XBXNJT083uHCk0Wjc3d0bNGhgZWWlUqlM6KuSgEKhMO2Q1C8IxU606u72Wq32xx9/nDRpUuvWrXfs2NG+fftqrQ7ASJRhkMHDhw8zMjIk21x8fHxsbKz4LavVao8fP75///5BgwY5ODj4+fkNGjTohx9+uHr1qriwboF+/foZ3KZivCq+1L28vHr37v3zzz8nJibqtnjs2LHr168b3IPh4eERHBy8b9++kydP6l68ePHi/v37e/ToIV7TEG/Kunz5sm5z586d+/3338WflUrl4MGD//rrL/0Rik+fPn3gwIHHJddqtTt37ly7du2CBQvkOuN82uYNE/67kK5tBl0AGRkZaWlpvr6+jo6OrVu3vnLlys2bN/WXv337dkpKiqenp9kL8gYNGnh4eNy9ezcnJ0f3olarXbJkyeuvv27QWWBkj4l+3SUIQk5Ojq4dd3d3X19fg36NnJycu3fvVhEyMzNz5syZ//73v6OioiZPnizxdTBBEMrKyowcFhWPY7CPaTSaxMREX19fd3f3hg0btmnTxqCvShCEmzdvXrx4UfcYoRk5Ozu7u7vfvn1bvzLMzs5+7bXXIiIi9KeHatCggZGHpH7dpdFo9Aca9fLy8vHxMThwcnJyqpgBTKvV/vDDD1OnTu3SpUt0dLSnp6ep79V0SqWSZ8PwNKAMgwyeeeYZ/SEBa5udnd2cOXOWLl0aFxe3dOnSN998c8KECSEhIYIgNGzYcO7cuYIghIaGbty48eDBg+ICgwcPHj9+vAnXZGxsbJycnOLi4vbs2aMr7fTZ2tpOnz5d3GJMTExcXNx77703e/bsWbNmBQQE6C+pVCpnzpz5/PPPh4WFrVix4uDBg2vWrBk3bpyTk9M777wjFkg+Pj79+vX75JNPFi9eHBcXt2LFig8//DAoKEjXSPfu3WfNmhUREREeHh4XF7dmzZqZM2dW8URBenr6jh073N3d79+/L96CpRMVFWX2u25qSZ2r4qSckE2/C6CkpGT37t329vbiSIYDBw5s3Ljxt99+q7t6LC5QUFAQHBxs8hYf1yuhUCgGDhyYlZW1f/9+XTfBnTt3jhw54u7ubjA0tjE9Jq6urklJSbqrweJkULpxyd3c3AYOHKjfr6FWq/fv33/x4sXHJVer1V999dWBAwfWrVs3duxYWQbwtLa2rn/X344dOyblFW+x90q3j4m/Dhw40M3NzcbG5pVXXrl8+bJ+X1Vubu62bduCgoIMxi2slsddgHJ2dh4wYMCBAwdOnz6te/H8+fNHjx5t27atwfRQTzwkHRwcmjRpkpCQoKvVr127pj8lifgdoX/gFBYW7ty5s4oBRS5fvrxkyZKePXuuW7dO/5k6KWk0Gp4Nw9OAAeshDym/g4cPHz5x4sQvv/xy1apV7dq1i4iICA0N1fUjtm3bds+ePV9++eXatWuTkpJ69+792WefTZw40bRBKZRK5eTJk8Vpat55553Vq1dXHB2kbdu2//rXv9atW7d8+fKkpKTg4OCtW7cOHTpUpVLpd4UKguDm5vbtt99u2rTphx9+mDdv3gsvvDBp0qS33nqradOm4gJ2dnbLli1r1arVpk2bvvzyy8GDB2/atOnKlSvbtm0TF1CpVLNnz/bx8fnyyy+//vrroKCghQsXXrly5cyZM5XmT09PP3r0qCAI4uDg+gYNGjR69OiKDwJZICn3rjp3/+TNmzdDQ0Nnzpzp4uKyY8eOn3/+OSoqSuz1b9eu3cKFC6dPn56dnT127FgbGxtxgUWLFhn0ERjJxsbG1dX1wIED/v7+AQEBFbvVAwICxG6CW7duDR069M6dO+vXr7eyspo+fbpB7SH2mEyePDk0NHTy5Mlt2rSJj49fu3atfo9Jnz59Nm7cOG3atFmzZrm6uooFZ9++fcUWlErllClTTp06FRYWFhYW1qFDh59++mnv3r1VPPr4559/7tixw8PD49q1awZHRKtWrUaOHCnN4Bl1bh97op49e+7fv1+yzTk4OKxdu1bcx/7888/o6Gg/P78pU6aIT0z17t17wYIFERERqampr776anFx8ZYtW86cObN+/XrTBqUQb1KIiYnRarUBAQEGO5hCoRg/fvzvv/8u7oedOnUS9+QJEyYMGjTIoKknHpJi58L8+fPLysqGDx9+/fr1mJgY8RYJsQU7O7tZs2aJB47uqD948ODjdvvS0tIdO3ZcvXo1MDDQ4D55QRBGjBhh/MiiAJ5MixoLCQkJCAiQO4VE5s2b5+joWMNGAgICQkJCzJKnakVFReJXXVFRkQSbg1ls2rTJwcFB3haMFBAQMGzYsBo2olQqT58+bZY8VUtMTPT399+6deuuXbuCgoIcHBxCQkKOHDlSXl6uW6a8vPzIkSOjR492cnJycnISJzsWL2dp/++AGjRoUE5OjlarXbJkie5nUU5OzqBBg/SPuJMnT/bs2VMQhGXLllWaSqPRxMXFDR482MHBwdPTMzw8/ObNm+I/HT9+XBCE48eP6xa+efPmBx984OvrKwhC7969N2zYUFBQoN/apUuXJk6cKDa1YMGC9PT0sLCwJUuW6Ba4d+9eRESEp6eng4PD6NGj4+LiBg0apL+Avu3btz/uq1OyT5Wa72Nm2Uv11XyPlewI1f7fXnr+/PmpU6c6OTn5+vouX75cnI1Np6ysbO/evbqd8K233rpw4YLuuBD3w+3bt2sf850iHlm6vaisrCwqKkrcx06ePFlpqoKCgi+//PKFF14QBCEoKGjjxo26Bg0Oq6oPSTHSxo0bO3bsKAhCcHDwwYMHjx8/7u/vn5iYqFvm5s2bs2bNEluYOnVqbGysv7+/+I4MiIfw43Z7/YOxVtV8H5Psc1UCgiAUFhbKnQK1QqGta3fvWKDhw4ffvHnT4N7r+mrz5s2zZ8/Oy8urSSOBgYGtWrX68ccfzZXqcYqLi8VJYNesWSP9UBMwTc33MbPspcYIDAxs2bJlDfv1VSrVyZMnO3fubK5Uj5OUlDRmzJgPP/xw/Pjxtb0tmEvN9zGz7KX6ar7HSnaECoKwdOnS+Pj4HTt2ODs7S7A5mEXN9zHJPlclYGVl9eDBA/2pQVBv8GwYZFD/psGBeT1VA3PJ8sQRAKBO0Gq1Bg8Not7g6x8y0Gq1xszuiqdTaWmpbgwJy1fz53a0Wq304++hrigvL7e0Z8MUCoWRUxVX4anqakF11Y+rWMAT8d0PGbi5uRmMwFtL7OzsoqKiJNgQzCgpKcnR0VHuFEbJysqqeYeCtbX19evXxadEAAMPHz7UDcljIbRabQ3nVFSpVJcuXTJXHtQ/p0+fruFtAiqVquadBUBtowyDDLp06aKb2wowcPr06datW8udwiiurq7iBG414eLi8vvvv48ePdoskaogzppV21uBeWVlZT3//PNypzAzHx+fR48eSbOtRYsWSbMhmEt5eXl5eXkNr5eq1eoadhYAEuCmRMhg5syZubm5f/75p9xBYIkuXrw4cuRIuVNI58UXX4yLi5M7BSxRUlJSYWHhlClT5A5iZi+99JIgCFXM2Ian2bZt2+zs7CrO9QLUP5RhkEHjxo07dOgwdepUuYPA4rz//vvW1tbvvPOO3EGMVfPndubOnZuUlKSbZRjQee+999q0aVMvz0dbtmxZcXJCQBCELVu2dOjQQe4UgBQowyCP7du3nz59+qOPPpI7CCyIOKv1vHnz5A4iqa5duwYGBr766qtyB4Fl2bNnT2xs7IoVK+QOUivefvvtffv2yZ0CFic9PT0+Pn7u3LlyBwGkQBkGefj7+y9fvnzlypWvvfaa3FlgEd5///2QkJCRI0fOnz9f7izVYJapF//444+cnBx/f/+aN4X6Yd26dePGjRs3blxISIjcWWrFwoULmzVrVv8ee0MNvfTSSwEBAaNGjZI7CCAFhuiAbObOnSvemqhUKtu2bdu1a9cOHTr8+eefXbt2lSZAVlaWq6trSkqKt7d3zVszrZ1K18rOzjZtbLTqrpiXl+fo6Gh8ciOXfPDgQZMmTYxpsLS09Nq1a//5z38uXryoUqmWLFmyYMECY1a0EPfv3zfXYOIZGRkdOnSwtrbu37//tGnThg8fbpZmUbfcvn178+bN27ZtS01NnTZt2saNG+VOVIuuXLnSqlWrZ599dseOHd27d5c7DmS2b9++6dOn29vb//HHH3JnASRCGQY5DRky5Pbt2//85z+/++67I0eO7Nu3r7Cw8IcffpBm6+Xl5WacOde01hQKRcXLKVqt1rST++quKC5vZWVVXl5uxvaNXKxjx44JCQmOjo4+Pj6rV6+uQ8+D6Tg5OXl4eJilKRsbm2vXrm3cuHHDhg1jx44tKSmxsrLy9PRMT083S/vGUyqVGo2m0n8yfld5nKpbqPRw0GfyoWFMjCdu3ch2TFNeXi5uvUmTJr169frPf/5jaePUm529vX1OTk7Pnj179OjRvHnzLl26BAYGenh4qNXqWtpiRkaGu7v7Exd7Yn9TLXXeaTQapVJpwoomb9Hk180VzMrKKi0t7Y8//jh9+vT9+/dffvnln3/+2fjVgbqOMgzyGzZs2LBhw+ROAchvxowZM2bMEATh3r17165dM6bkyMzMdHNzq+6GqljLtH+q+XaNad/4C60mxDDh3dX8D6Jz7ty5Xr161ZWRCXJzc83V1LFjx27fvv3ZZ5+dOHEiPj7+0aNHZrnRt1Lm6nozV/ltcjsmdBlUvcXHdXBUN6EJy9vZ2bVo0WLixIkRERH1cjQaoAqUYQBgcZydnbt16yZ3CkhHspuxzaJx48ZmbK1Fixb1+/ZLAKgUQ3QAAAAAgKQowwAAAABAUpRhAAAAACApyjAAAAAAkBRlmBmUlZU9bnxnAABkVF5ebq5R9QEAZkQZZgbW1tZGzvUBAICUrKyszDhBIgDAXPhoBgAAAABJUYYBAAAAgKQow8wgKysrLy9P7hQAAAAA6gaV3AHqA1dX10ePHsmdAgAAAIIgCA8ePJA7AvAEXA0DAKA+UygUckcApNakSRO5IwBPQBkGAEB9ptVq5Y4AADBEGQYAAAAAkqIMAwAAAABJUYahelJSUjQajdwpAAAAgDqMMgzV4+3trVQq5U4BAAAA1GGUYQAAAAAgKcowADAdQ4EDAAATUIYBqG9SU1N5ghEAAFgyyjAA9Y2XlxdPMAIAAEtGGQYAAAAAkqIMAwDTabVauSMAAIC6hzIMAAAAACRFGQYApmOkRAAAYALKMAAAAMASKRSKsrIyuVOgVlCGAYDpeDYMAFB7tFqttbW13ClQKyjDANQ3KSkp3CsIAAAsGWUYgPrG29ubi1RA7SktLZU7AgDUeZRhqB6uMwDAU87GxkbuCABQ51GGoXq4zgAAdYharebiFZ42KpUqKytL7hTAE1CGAQBQb6lUKi5e4WmjVqtdXV3lTgE8AWUYAAAAAEiKMgwATMTtXgAAwDSUYQBgIpVKZWtrK3cK4AkYVwkALBBlGAAAAABIijIMAID6jOFtAcACUYYBgOk4wQUAACZQyR0AAOqq3Nxca2truVMAAOothUJRVlYmdwrUCq6GAYCJGjdu3KxZM7lTAADqLa1WS39ffUUZBgAAAACSogwDAAAAAElRhgEAAACApCjDAAAAAEBSlGEAANRnCoVC7ggAAEOUYQAAAAAgKcowAADqMyYZBwALRBkGAAAAAJKiDAMAoD7j2TAAsECUYQAAAAAgKcowAAAAAJAUZRgAAAAASIoyDACA+oyREgHAAlGGAQAAAICkKMNQPSkpKQy6ZRq1Wh0dHe3l5dWlS5dDhw7RPw0AAPDUogxD9Xh7e1M/mObo0aMffvhhWlramTNn5s+fn5qaKnciQDbZ2dnTpk1zdHQMDQ1NT0+XOw5Q67Ra7f79+zt16uTn57dr1y61Wi13IgCYngV4AAAP20lEQVQyowwDJHL27Nn8/Hzx51OnTt25c0fePIBcNBrNunXrNm/enJ+f//33369ataqkpETuUEDtSkhImD9//uXLl5OSkmbPnn3u3Dm5EwGQGWUYIJHAwEAHBwfx56CgoObNm8ubB5BLXl7epUuXdL8mJSUVFBTImAeQQGJi4tWrV8WfMzIykpOT5c0DQHaUYYBEevfuvXLlSk9Pz86dOy9btszLy0vuRIA8HB0dO3XqpPvV19e3UaNGMuYBJODn59e2bVvxZ3d3dx8fH3nzAJCdSu4AwNNCpVKFhYWFhYXJHQSQmVKpfPfdd+/evbt79+7hw4fPmTPH1tZW7lBA7WrXrt2yZcs+/vjj0tLSxYsXBwQEyJ0IgMwowwAAUmvatOmmTZs2bdokdxBAIgqFIiQkJCQkRO4gACwFNyUCAAAAgKQowwDAdEyjBwCoPQqFoqysTO4UqBWUYQBgOqbRAwDUHq1Wa21tLXcK1ArKMAD1TUpKCtURAACwZJRhAOobb29v7hUEAACWjDIMAExHvQcAAExAGQYApuPuRzyFsrKy5I4AAHUeZRgAmI6rYXgKubq6yh0BAOo8yjAAMB1XwwAAgAlUcgeoD9LS0u7duyd3CgD/X35+vmTVEVfDAACACSjDzMDT05NTMcByODg4cEgCAABLxk2JZqDVarkxCQAAAICRuBpmBgqFgq534OlEFwwsXFZWVmlpqdwpAKnl5eXJHQF4AsowVE9KSorcEQALQhcMLJyrq2vLli3lTgFIzdHRUe4IwBNwUyKqx9vbW+4IgAXhahgAADABZRgAmI6rYQAAwASUYYBE1Gp1dHS0l5dXly5dDh06xFWUeqCoqOjBgwdyp6iTsrOzp02b5ujoGBoamp6eLnccAACkRhkGSOTo0aMffvhhWlramTNn5s+fn5qaKnci1JS9vX2TJk3kTlH3aDSadevWbd68OT8///vvv1+1alVJSYncoYDapdVq9+/f36lTJz8/v127dqnVarkTAZAZZRggkbNnz+bn54s/nzp16s6dO/LmAeSSl5d36dIl3a9JSUkFBQUy5gEkkJCQMH/+/MuXLyclJc2ePfvcuXNyJwIgM8owQCKBgYEODg7iz0FBQc2bN5c3DyAXR0fHTp066X719fVt1KiRjHkACSQmJl69elX8OSMjIzk5Wd48AGRHGQZIpHfv3itXrvT09OzcufOyZcu8vLzkToSaUqvVzMhkAqVS+e67706dOtXBwWHixIlz5syxtbWVOxRQu/z8/Nq2bSv+7O7u7uPjI28eALJj3jBAIiqVKiwsLCwsTO4gMBuVSmVtbS13ijqpadOmmzZt2rRpk9xBUG0qlSorK0vuFHVPu3btli1b9vHHH5eWli5evDggIEDuRABkRhkGAACMpVarXV1d5U5R9ygUipCQkJCQELmDALAU3JQIAAAAAJKiDAMAAAAASVGGAQAAAICkKMMAAKi3SktLHz16JHcKAIAhyjAAAOotGxubBg0ayJ0CAGCIMgwAAAAAJEUZBgAAAACSogxD9RQVFWm1WrlTAAAAAHUYZRiqx97eXqFQyJ0CAAAAqMMowwAAAFB/qFSqrKwsuVMAT0AZBgAAgPpDrVa7urrKncI8FApFWVmZ3ClQKyjDAAAAAEuk1Wqtra3lToFaQRkGAAAAAJKiDAMAAAAASVGGAQAAAICkKMMAAAAAQFKUYYBE1Gp1dHS0l5dXly5dDh06xCzYeJplZ2dPmzbN0dExNDQ0PT1d7jionpycHLkjAECdRxkGSOTo0aMffvhhWlramTNn5s+fn5qaKnciQB4ajWbdunWbN2/Oz8///vvvV61aVVJSIncoVIOLi4vcEeoerVa7f//+Tp06+fn57dq1S61Wy50IgMwowwCJnD17Nj8/X/z51KlTd+7ckTcPzEKhUMgdoe7Jy8u7dOmS7tekpKSCggIZ8wASSEhImD9//uXLl5OSkmbPnn3u3Dm5EwGQGWUYIJHAwEAHBwfx56CgoObNm8ubB5CLo6Njp06ddL/6+vo2atRIxjyABBITE69evSr+nJGRkZycLG8eALKjDAMk0rt375UrV3p6enbu3HnZsmVeXl5yJwLkoVQq33333alTpzo4OEycOHHOnDm2trZyhwJql5+fX9u2bcWf3d3dfXx85M0DQHYquQMATwuVShUWFhYWFiZ3kPovJSWFewUtXNOmTTdt2rRp0ya5gwASadeu3bJlyz7++OPS0tLFixcHBATInQiAzCjDANQ33t7eDEQJwKIoFIqQkJCQkBC5g6COUSgUZWVlcqdAreCmRAAAAMASabVaa2truVOgVlCGAQAAAICkKMMA1DelpaXclAgAACwZZRiA+sbGxoYhOgAAgCWjDAMAAAAASVGGAQAAAICkKMMAAAAAQFKUYQAAAAAgKcowAAAAAJAUZRgAAPVWXl5eVlaW3CkAAIYowwDAdExQBgvn6Ojo6uoqdwpAUlZWVvQ+wPJRhgGA6ZigDAAsTXl5Ob0PsHyUYaiewsJCuv8BHQ4HAABgAsowVE/Dhg3p/gd0OBwAAIAJVHIHAIC6Kisrq6ysTO4UAACg7qEMAwATubq6tmrVSu4UAACg7qEMAwATZWVllZaWyp0CAADUPZRhAGAiV1fXli1byp0CAADUPQzRAQAAAACSogwDAAAAAElRhgEAAACApCjDAAAAAEBSlGGonoyMjPLycrlTAAAAAHUYZRiqx93d3cqK3QYAAAAwHefTAAAAACApyjAAAAAAkBRlGAAAAABIijIMAAAYS6VSZWVlyZ0CAOo8yjAAAGAstVrt6uoqdwoAqPNUcgeoD9LS0u7duyd3CgAAAAB1A2WYGXh6eioUCrlTAAAAAKgbuCkRAAAAACRFGQYAAAAAkqIMA1DflJWVabVauVMAAAA8FmUYgPrG2tqaxzUBAIAlowwDAAAAAElRhgEAAACApCjDAAAAAEBSlGEAAAAAICnKMAAAAACQFGUYAAAAAEiKMgwAAAAAJEUZBgAAAFgihUJRVlYmdwrUCsowAAAAwBJptVpra2u5U6BWUIYBAAAAloirYfUYZRgAAABgibgaVo9RhgEAAACApCjDAAAAAEBSlGEAAAAAICnKMAAAAACQFGUYAAAAAEiKMgwAAAAAJEUZBgAAAACSogwDANMpFAq5IwAAgLqHMgwATKfVauWOAAAA6h7KMAAwHVfDAACACSjDAMB0XA0DAAAmoAwDANNxNQwAAJhAJXcA1D1FRUWdO3eWO4UgCEJ5ebmV1X91JeTm5jZu3NiMm8jLy3N0dDRjg/oKCwsbNmxo9q3cvXu3WbNm5mpN/JOanLCoqMje3t60TRcUFDRq1MiEFbOzs0tLS03baLWUlpampaVt2bKlWmvdvHmzVatWNdnugwcPmjRpIgiCVqs1Sx2YkpLi7e2t+zU1NdXLy6vmzVZsWXT//n0nJycztlzpVmpC3OFzcnJcXFxMbsSYVE/cGWr+1nJyclq2bFmTFgAAtYEyDNUzderUf/3rX09cTKFQSHCzVsUyzMrKys3NreLWTc5jbW1d8TxMbE33X8HUO9N0J9OVbsVkRUVF7u7u5mpNoVC4u7vrEuqf9BvzrmtSYer+PsJ//x984v9Nd3f3adOmmbbRahk8ePBXX30VHh5erbUq7rfVZa7qS8fgT1rzhDpWVlbl5eUGL5olv37ISrdSE2LCGv4djEn1xE3U/K2Vlpaat+OsvLw8NDRU7EKSRaU9TcXFxXZ2dubaRHZ2dtOmTc3VWqXtazQaM/aXmaVrQ8fgj3nv3j1nZ+dqtVBaWmpjY1OTDDXsVNVoNDXZOiANKc6V673hw4ffvHnz7NmzcgcBAKB2hYaG5ubmyhjgxo0bzz33nMGL5r2nIC0tzdPT01ytVZSamqrRaCq+C5PdunXLw8PDXK0Z/DFNaLwm90GIMjMz3dzcatLCP//5z5qsbjkUCkVhYWEN/56wTFwNAwAAxoqJiZE7AgDUBwzRAQAAAACSogwDAAAAAElRhgEAAACApCjDAAAAAEBSlGEAAAAAICnKMAAAAACQFGUYAAAAAEiKMgwAAAAAJEUZBgAAAACSogwDAAAAAElRhgEAAACApCjDAAAAAEBSlGEAAAAAICnKMAAAAACQFGUYAAAAAEiKMgwAAAAAJEUZBgAAAACSogwDAAAAAElRhgEAAACApCjDAAAAAEBSlGEAAAAAICnKMAAAAACQFGUYAAAAAEiKMgwAAAAAJEUZBgAAAACSogwDAAAAAElRhgEAAACApCjDAAAAAEBSlGEAAAAAICnKMAAAAACQlEruAPVETk7Oli1b5E4hnZSUFG9v79pbvn7QvWu1Wq1SPS3HWs3/X2dmZrq5uZkrTw09ePCgSZMmcqcwj7y8PEdHxzp3MIqx5U5RFY1Go1QqxZ/v3bvn7Owsb56KysrKrK2t5U5RiUePHjVo0MCEFc21G8t+OMgSIC0tzdPTs7pr1SSqlG9Tsm3JvvOgHnhaTg1r1YsvvvjLL7+Eh4fLHUQ6CoVCq9XKncLSWVlZlZeXy51CajV/1+Xl5VZWlnKhXqvVKhQKuVOYRx19L3Urdt1KKzuT/1zm+nR9Or/LTPuMrSvfaJIdg5JtqFWrVhJsBbJ4Gj+AAAAAAEBGltLlDAAAAABPCcowAAAAAJAUZRgAAAAASIoyDAAAAAAkRRkGAAAAAJKiDAMAAAAASVGGAQAAAICkKMMAAAAAQFKUYQAAAAAgKcowAAAAAJAUZRgAAAAASIoyDAAAAAAkRRkGAAAAAJKiDAMAAAAASVGGAQAAAICkKMMAAAAAQFKUYQAAAAAgKcowAAAAAJAUZRgAAAAASIoyDAAAAAAkRRkGAAAAAJKiDAMAAAAASVGGAQAAAICkKMMAAAAAQFKUYQAAAAAgKcowAAAAAJAUZRgAAPh/7dexAAAAAMAgf+tZ7CqLAFhpGAAAwErDAAAAVhoGAACw0jAAAICVhgEAAKw0DAAAYKVhAAAAKw0DAABYaRgAAMBKwwAAAFYaBgAAsNIwAACAlYYBAACsNAwAAGClYQAAACsNAwAAWGkYAADASsMAAABWGgYAALDSMAAAgJWGAQAArDQMAABgpWEAAAArDQMAAFhpGAAAwErDAAAAVhoGAACw0jAAAICVhgEAAKw0DAAAYKVhAAAAKw0DAABYaRgAAMBKwwAAAFYaBgAAsNIwAACAlYYBAACsNAwAAGClYQAAACsNAwAAWGkYAADASsMAAABWGgYAALDSMAAAgJWGAQAArDQMAABgpWEAAAArDQMAAFhpGAAAwErDAAAAVhoGAACw0jAAAICVhgEAAKw0DAAAYKVhAAAAKw0DAABYaRgAAMBKwwAAAFYaBgAAsNIwAACAlYYBAACsNAwAAGClYQAAACsNAwAAWGkYAADAKgWmi53u4uieAAAAAElFTkSuQmCC" + } + }, + "cell_type": "markdown", + "id": "6a4b72c1", + "metadata": {}, + "source": [ + "**Point cloud:** A point cloud is a collection of points in 3D space. Every point point in point cloud may has multiple features associated with it. An individual point in point cloud has `(x, y, z)` values to indicate it's position in 3D space for x-axis, y-axis and z-axis respectively. And it may / may not have features associated with it; Most common features associalted with individual points are `(r, g, b, i)` values indicating red color, blue color, green color and intensity measure respectively.\n", + "\n", + "There are no hard and fast rules to decide what values go into features.\n", + "Datasets may instead use **r** (lidar reflectance) as feature, or no features at all.\n", + "\n", + "![image-12.png](attachment:image-12.png)\n", + "\n", + "Generally speaking, a dataset is a collection of train, validation and test splits where each split has multiple point clouds within them. Model interacts and learns from train and validation point clouds during training phase but never interacts with test point clouds. Test point clouds are considered as out of bag samples and used during evaluation phase only.\n", + "\n", + "![image-14.png](attachment:image-14.png)\n", + "\n", + "A dataset is partitioned into train(ing), valid(ation) and test(ing) splits. Models use data from the training split to update network weights and performance is measured on the validation split. Hyperparameters can be adjusted to optimize performance on the validation split. The test split is never used during the training step and is only used to report the final performance.\n", + "\n", + "Always make sure that no two point cloud splits share a common point cloud file! This may cause [data leakage](https://en.wikipedia.org/wiki/Leakage_(machine_learning)).\n", + "\n", + "
\n", + " **Note:** Datasets are built using `BaseDataset`\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "d22689b1", + "metadata": {}, + "source": [ + "## SemanticKITTI dataset\n", + "\n", + "The points (positions & features), point clouds & splits are essential components of any dataset. Point cloud files can be stored on disk in many possible ways in multiple formats; **To parse them, we need dataset-specific classes**. One such class is `ml3d.datasets.SemanticKITTI` which parses [SemanticKITTI dataset](http://www.semantic-kitti.org/dataset.html).\n", + "\n", + "You may download the dataset by running script available at [scripts/download_datasets/download_semantickitti.sh](https://github.com/isl-org/Open3D-ML/blob/master/scripts/download_datasets/download_semantickitti.sh)." + ] + }, + { + "attachments": { + "image.png": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMMAAACICAIAAADVgshSAAAgAElEQVR4nOy9d7xlZXU+vtZ62977tFumF/oMHREQRFC6KDAUHVCj0QjYgsaOvWBDMUZBExMlKhiN/iwoEUsCYgM1KHZE6W2Gqbecsvd+y1q/P87M5TIFNV/AYHj+OJ+999nlved97lrrXW2jcCp7A1E6dxn3q37bWO+NYLdc33Lzp3ygDFqKyrJEVg1s99QkbAsVgNOOY+IYrbUiAiwKSZQgqsqzEl04m3zyKRaF2zi1xuWFMi5GlpgUgRLmGJIWRASALT5FZJvPfRQPLmpJGSlMzIDGmEgSEznOy3yD8828zrkBqRr4Ioc66UGt2nZ4IW5MvhNBFIlSShKmMNDaTilssgrTYotYi772x/jdH8XVd/W7q1prutscQTQQ6rooipSS1jqEICIpRGUwpWSUIUQOUVsChX7QI8yUNQg6cgIWrRQAAwuA3nRHxIfnt3sU90dPFi6pspaMz1FHPpEPPhRarTzWlW1YlVKdfELMTAZRmKO2FMLwMpwIoak1RK+1FYgosaoBswzrfpz25gtfkG98UQaTWtuEBFCoELf5fAUYU9TWAlH0HgBYom00oDcAQAAA1KAQlIhIkqQFgRQIckqIiEoDCHCKfD/Z86goephRgTRYkXEJieIAx5rp+OPg1KcN2nNbMYJRfWczhkTRxuh1plIaXojs62AsxNoyVCk62wgUoDedfvgj85GP6em14NrcZ2oU7GvmxGrbU2sZ6lAro7Vzvt/TSOQ0WO27STEoawEgJa8yLQi97pRt5iKbeIKIiEgizGxUDpsJJDNnPIqHCwYCoAOFghWEStixaoEt9KtfBIcdDCELGQRMFMmIoBXAzdpNQh8gixq57tcVNBvNulpH//Zv9gtfSaSZVKRo5y+cOuAJ9+61R7Pdmsr0NkeQolG58TFADCpEiEmQ+9Gnom2D6JSUEnAEmqwmp40vMwAecggAmJmZBcmYGh5l0p8PxmdQ9sz0msZtv23/9BfuznUM4gl0lvVOeKp5+mmt8fkgIEPjQzHzpgsxyTT5ImlVUXDd0LOQfezT2Te+AqGChKKyVUc/adUxx0thuZwIXdYNu80REFrPqQxlluSXP7j2nt/fvGbdWlM4huBEsw9j8xfs+8TDFuy+nEEho+IKBUiBIRWFQ4yotDFmZmiPcujPghZClzhFo1sjTZla8u1vj33r+9V0L4MAqtV99ko+85ntMvMtkH5FrqXVpvnCKFWKoJMtNdjuho0/vnreez6NsRdynRbueOezTptYvFQm1iVbZEnHvAz1tmVSrkIZvTHq5uuuv+pzX15ctLPclrHKkQsy4nlDrM3i+bsc/Li5i3bsd0sxiCCagAgCJxZ0eaPRajnXhs1Lthngo9b3w4WoHW2YVqOWHaUpoaI5d/Xt87/8teaq3+sygDQn3/CC/MSTsOLKl845rTdrt5CiT1XBjW6v9nyX+9tzm1PTIRT9uTv9/pxjU3skm+bVOYayP5eySlyhaZsjoJiVsSoy+9kP/0t58535IEgKNXuVtbDfdxBNy/CohtECNUqImTIIrFAQxaeIpFujY6Pjc5Y/5XSYtfif4dCjZHp4gMkObM/6gaqNdw2tyWhfW7/fRy/p3LqhdpFTM33yvdTYrcplTJcxZsMLtcBGw6PTZT8Z3b70P+q1vTr3zpufPfcEFaxMsuSuI5icMS5zRAYJNs/xbJdPXZe5biqdrV+/oZiKMWG0NgMbe0GbTIgTx2YfR0hyB5RA9IRSaDQZBUoxSeQN62H9b2/ececnHXZyXfp1WW+uLjxwFqGngzaWpoGjteM4qGJHwSCAsclXqZdNjNULgpQ5FAlTdBGSKpFGq7yvp20/+Y5N3d5I3u4BDmSipZqJ0qCMi2RkrelljHnWnqYNql4CfI/Vi5Ndo6LuhTrPW3W3zyo0bNEnr9BhL+S0pKdvz2yua4wgVvqVMmAIvLasJsyaMT823TbtqYHWI32YRBGi+SncSarl3WCMx7uDfp67iSplBjxLqcuR2hTO9v2gocb62PdU5mQkYVl5LliFsXmVX5uTBtCq76lddCtpUd2XgfVzs9GNpW9ofgB+bI3tGQ8xRicdNq2UJcfMzDFqCuqGk1ce+sFLfH1vM8G9n76888KXUj0I0gAQIkJErb3ramITqbte/+cPE4lLrVtOPqjotHwMpJS1VhkjIkapLMuAZQuBMfx0uVXKaLAZKiOiEzsxHWV7rnKKVOIUOBJ3Uft2WzUyLntEZBQqBE2MICAJgAc3/Dx/6gpsueViu5QsOvGDhbighlqPT9Y+qgSuaHnFI8IYTG+kvwM8RmxAWF8nJKaFenR1LuOxlxXZuDV3jPfa3ua5AWXZ44i1CfNGpet2DakuelE1d7TQbcb5GXR7dkzBlKLCuqYOUxay5pymNwPd93Zi1c9/02888bCD3PpR2WFaNkxf8eKnvsc/7ZMfe8c+S2saBB0LTOPVbmVHDaSrC1D5yBhLAJfKWsbGTL8oTcGYj1tqSIeLNU07QrWvSmXHWiHUo1kHsunYHW82q4HPrdo41zZiZtnaaT8xr9uumqlSc9txPWYjVqZsa4csbOiDWezqOuUPCpNSSryJQJswPNJv5reddOiSr38N6nrsqmvjM/4qm9saAA5X4IioPeYqSqxKe821sGG1zl1/zsK7Dz3QKTLKGWeNtXmeW2tRAAWMs7CVAxoAiCgJs+c6epNrNoLWeEVUVykqUEp1WjinkxaObBxtDByaNAcRFQghEgApIAFExLtvL9wiq0vU9Xg3JWyWq7/07rd8/Bs/u+WOQT62yx7LD37+uR84/YhBKZ28LKvFOKKsjb4YjMR22UysCH0jptGUVYXWsTvuOzQeVU0YF410+tWg1srqolSsbKMxni2ehD6FdqOVBKkjpkdFEbQkrloLG6X0bDWSctMaX/e1v33G6xr/dPMRB2YtribnNOanpUfvsvPP9pxfBIujhSm9biCtHSFV+1FaSllvzcefcejr/IW3fupZHVtCW3e/+ebTz7py3tsv+ewL98AfvvuAM7515pd+8tLbznrSOd/eoG3e9mEjJABxCmrKn/7hT4y+8VkX94EikpBmqICNlVAc9r7vf/H0b7z4iW+8++1X/scLd0qrXb7UpPJPYtL2MKRRSimEEEKo67quaxGx4G7ff9+5v7je3HKvm76ne/1P3FFHhspnhRmSUtcpaqbU7+sf/9SP52rAa/bZNdoRxUxEguCcy11mlM6yzBnjOW1tuyCiSlKmIBmqdja+eFFW5GSNUxpCF7UhpQLSgHnAqT+Ivp8SbVrno4BCJCKFREQ+gMmQDeV1QaPS6//X+See++Ulzzr9/NcePne0uve661bPO8y0aZ7OAsPYfIfrJn3dKZqZjNWNvq2UBFiazw15PwbTskWGkJTqNqwNXchGtYkS6xqnRmVHJaWhFNrNhor1QGqls+Apa7Ty0AtTpEOB2mADXJp0NusYDNgxbW1ptDG/X3V3P/HvvnVywEGzHWjK+Iiqb80CcLFJcaJuk5nurkW3uNman2cZ3f2l1z/nVZcvedMVV7x6L1uZqS7oeml7dPH8A9/zuR02lAPjet9841kXhrM++4HnFDEkle+/y7zlV5xRsQ589Uf+5p23n/iRi569sw8Yx/ab1yocRdVqWuUbI3NVzeSKB4VJIjJkUkrJe6+1HiofV/KkHZ9evk9z1XpvM/nhtf1DDyUU5tYwlqWxHNRa1UnGut2qSolhepclubgf/OgH3/ve94osAxZgMcZorU864YQVp526BY2GcNqKBASOxHXblA4i1IK+MI4BmCRySClwYBU5F+AGiAgICkASAUIgAZJykLJmkfdcbGAigOu+c21Y9sT3/9OHjhGjOhUfd0aEBlivWXrXXfrq13zymzf8cu3I8qNPeO35737eHoUUxY2fO/1VF177y9+sWpd0e+zw57xp5fyfX/q5r/7ynooXHHDWO/71ohOX2sLMhxs++IzTLvje6v4Gah/wuNPO/8d/OGRXGMiGK9/2vPd/6dob7l3Xj52Fy495zvve9drDd9csCbOkvvacpe3EGhsrv3jXvz31qqftefq9L/rV91+7TDrVnLVXXfCuD33qP394z3Qx57FnfuDr558II+OSiibEtOry1518zmcWn33ll17+eG2juH7TOmytG+TT3Nz76KPToK9ksH6ksO6YAw7fZ05Szcao9r2FO+6ckKjuXV6623c74OijD9SiSuKGQkdxUFfNlnPI2GxCqh8UJiHikEnMbIxRSiGiUqqMg0Kb7qJlHv6rnsZi1Z0bEmdN5qHEEdFRBU6xFk1rNpjasON+p11Yd9zxT87z/Jrvf18Pz9P6lFNOOeWUUxi2o18Dg6HM2Ji8x1hVFTNrm3VjCiEwszHKWq0dYaYQRVgBDmWSICERDQ23hOh1yBvR9rQfRbfLnrvqj193yWU3HXLGLqOlkmaWI+CgV6779HNOePsdJ7/9Hz+wf+OXXzrvdS87XT/2hn88UPvpX/7mqrUHnfe5lx4/MnXtx9/wlle9bukpb3vDJ9+l/HVfe8O7X/6cvR7/vReMqcIuesKz3/QvL9trZLD2J5e88rwVr3zsr644a57acMcPr7p555df/A9Ht/r3/uyzr3zX6Wfv/Iv/OnMJroZqtDjhbVdecEyRoOosaVYKm8EQsQDU/WvedOqZnw5H/u17/v3oXdVdvy+WZMJtmGJwU7d99UXPfvEPFr7l6stf+jhrISFhaNBcF6ackZRzB2gyzwjtqtzbOJHrrKOb04PpTtasulOtTjOJLxWgL0Bb4rqBjgfTGlAnIOs4KgOglPqTGLM9O4lo09pcKTUUSMOD3lvFaXLBIpREseGm+snXLhohYWallAZtoFf5KLB2PTXalgM3W1pbIDj5pJPmjIx+8+vfIIAVp5zy1BNPCJKM2o6PWzgRgoCvygSJOUICTVChoKVCO6dIUgx1QAXW2oQKABA3yzYUQRQAXRQQjDBNFfUIGDP+Nxd8/LdnvOpFj9/j/QevfO6L/vqkpz1+KZB2P//XT3xn17/96T+/Yu/WRP24g//x3qsf85V/+Sl/9HFWsjZ29l1x4pMeS+aQXXuXfe75rdOf++ynzld83GNWffUrb7/qe9Xf/rWF2Nz3lOcdrLsoBx25812f+8qbfnhX78zlnYXEBS467JknP6kCPu7oqZ8te9XnvnnvmefsUlR6yreX7rHXssakR9eCrBdsSNNWVF73Ln3vR+7d653f/tKrH8O2DuXhKkMdp8Vo/4t3rPj+xKLXffdrr9+tKCGoKuvWvtVxvs6VpC5VzVTACETf74+WjcooxgIUt6kAodwoASHWdSONOJ0YknZYrmaVGHU/n86TmNSfpKpFI38Sk7bnVVFKzYQWENEYE2Nk5sK20mC6bjqNxC1L08HX/VCNot4kk6gYQMksKWFHh1CDj828XSvsdDrW2hOfesKKE088+eSTV6xYQVppa3E7sLnRSgNCSgkNJauSEo/SNioDSMEHid5gcGpgaIo4gSSQSByJo4pRcaAQKOipewmqAajMFRFKdO1dTrvw6ht/c+U/vWj3NZ/9m+MO3/+cL90U87uuu+b28LvzD96h6ZqL2/nix7zzRvp9vGOySkB+w1jSUjthmmiNLO/A4I4kLKBhQWcOVr4/RT6V8aZL33DGscv2n98ZXXDSu28JAmULYXIdwoTV2AOtgzXFHjs09MSaW2oZiPMQeqIxoGtJAQhBsavnuCxivPH7N6ZF+522XCyIj1RVIsBiUsZmyeOPGDc/+/A57/h6r5/3rcqiyTnU3WQFTRh1tlJlDRyNKvvFFHeDIQoxodfAoDLthYlyA9EU7FMMwAAL6zxXIioZ73XKGyOG6U/E9uYR7m/+Im5SF9q18sJ1QkQh9ANiAxLXwX2CUFcKJQhwGWrSEsQkJtXUChNblxlnT37aaUSktQYAZt6eVKzq0jknACVSqsAktLZhwHiOoEghiiBGsKitACZMKSilFBAICA9FqFZKdW1DdJYJSE90wwYTPcAIL9339Od/6PSXvfHLZx668txXP+mkD6qgise/54oPn5JvGHTG80EvG50H7bGGmbbENddRS+R6tGgE7SbjFMoYgx1pzC/jzTZJiP99/umvvmTR2W+79MInm/j7L559yiWVLyM0RgBdkGg5eaOKMKfZGdRmro2FJ0e6E6oqkyI1OErZxHxAg6gMmAARVGu9DZCsztRovwxiprJco1qy4mM/ftuKZz/17BMPvvPib3z2+XvVmS3q5DFIZqibK4qkdKIoSnOmOm2AWpNiV3t0qraZ0YxdHd1U6To6VJBjDkZiqkNGmWSAXHNqi/rT/Enbw3B+h+bR8Ii1FhHZhzpmZTPWUWkEyLs+0Ejy3uMmmTQkxww/ZtNwtgCUzdjeCLIsG5r91lqllLV2aLjBdgTpcKyzv9q0zXWGkaHPDaxrY4LWSddZabgZY5z7pMcfoNet/fVNC/faf7z61U+nFux8yBP23GOfvQ84eJfFC5aMM5cWqK4IMYHRGUgswEOm0RmmXsn9plf9VnDTv/nJjXTA899xzkH7LXv83o/bd6fU874OECMAkuKqThBj5G4/iPIhGWhlzRG7fmpSYT6pEom4kmqXx0bPg95jzz06d1x19Y0mCKcQJhtWlzwCpdcJKcc9nn7Jjy9/++h3/u7E53x+taQJoeTiwLoqNXo1hiQAQdukkzZ19KiYmZijlAnrfkwSDZJuEgobYol1pORM7iRyAvaJk3rIAwAzYmzT/lZ80MPpHx4diratxSBspurQUN/2o4YUVCqEkGVZVVUpJWMM3v8UmOV/2mKXiJRSTerAQCtVD+xUMxVrb3rve/9+co8nHrnrUlX11//3pRdcTvu85MkHmMfPPfMJn3jjc09c/LbXrNhnRHfv+lF3v1eecSA3bIjNTKhWnEgFn4YeeA4epVSggs2ilzR3yWN3tp/68Fsv3eHsvS2vvuXuzC4ryAAhkzImKaUz4qgYFGXQAgDcd/kyf9HF77lk4fN27t5w645nvOCQ2jdDo8pslDnPPPdZHzvh7aee1X73ScuzkYnuHUuPfdZ+0fgKK2EonZl/1Llf/ac7jn32C0/Zef6333UUM2ShK0WgzOQMTBWGipIG5bVIAFYqUCzYUsP7KKJKI4Jei4qoFQJkSekYa8JA1gFESA82d+4/ZbN1oggPmXRfJgCAni2TEBFw0xzPvnJ46h+Z48HM3vuZOzDfTyzNvtvMrlJqSCMiWl0OoOBQa4MNEM7ZUPWDD73zI6vuxqptd97rqHM/+9a3H2my7m5vuOyaJee/5oL3PfeidVTM3eXAs/7xJbbuVJmyKNJn6vMgA9VK2HI+F0xI8wMBqgmXokrH/92n3r3xtR9+80kfWWvayizcZ/8dFxYGQEk1WYmKDClGI7kVGaReI4Jf9pr3fuTmF771had8fs6SBUe+9cgXHNgYq8yGMnpN2fiRH77ia43XveVDL/631RNFZ//D/37/0w5ukXLSTvVkEQsozA4nvfeL5916xBtf+vKDr/rE8ZUuo7iY+dA1usFZYOPTIGidY18l16eGZQVxKlKurUq6G5GorCpjMlHkp6TfTSMdCEjglSTGP23ttj3MnuLZwYwZyTL7zNlMwrWrVnfrfn+6u/srX0vC2sgv339Rs9lsNos8z7Msm7mdiAwza7c5AoU0dEKceuqpCxYsGB0dHe4CbSO0gpvzsjdZc1rPjHLVb267+AufBpCp6BW7poVuDaykbQUHZbANEyRqBIxJixPwwAqUoK58lbEMsqrgQqMDD+IAU0iEAWtKDcUbFYwlA0ogVQHyGKocXXBQAbe6FVADLPQFGtoH0lKTVWGgVQFUQ52SFuUbKU6DzkPOplJKqb7uG25a6IE0ayqRFLBhQifQjdDGKFqYjYLAaEoGFXymLJgakgEkiYNkCy0V1Am0BWVYuCRyAJrLRDGllmUowRuFGnQiVJuGorSAlDUXLsVAyiA/OEJpODXDAMjQtxRCiDH6QTk5mO5Pd/d89euQk1bpZxdc2Ol02u1mlmXW2u2oqvvP/Ra2/fZARMystc6yjJkRMcY4+6rZZJqRSTPCbxjrqVtVj0qfoGFt7iBAv8ihw1UAAnSoeqBRlxVqAmBGsJ4HmFB6TYhllgOMlpQgeqCUyh6AiahtXSABqzFQEKsecKWsUexIQWLTE1XHOm+ArTkk0ByjMsASGSjZKNDvClijIK9pAi0qMjVQZF2GbgOUUuwVRqmjZDZprpPtSUpgFABq7NWJ6xANVVVDapUZCfWg7yBJxVBTruvuJCZIjSgmSR2ACggqQV1lSpzyUCNooxL1hFBVqQIMoIBr6HdD4SSASkFvOyP6/wlbz9o25/G+2d/ejbapyx6AScyMRNbanXfeWUTquk5pG3GV+x68GUPTW0S891VVtfV8k/pWJaqRAFLZENgAlFPsgdXAGiBKK0s9ryLWYJJkLXGE2Ybo8jK0a29iURsJRgLpKIAAILUEr4KAAEMmSkIv+gBWBQO+keLAOEgVhSCESNooBlQFAVpQivPcsRhmcsH0XeaBO2yMq7PCQMo5dG1oeOMaXNWK0WgqKl0FTX1BH3KONbGdBpP1tdGMSK7IfG0GViedEGyjBdYbEI4qOCHGxFFYCgFRkoGDCMCqNlEgmKSALIESJ4oEgCiQsfDgaLYtMVuabMmHrci0pSUE2+fQAwskROSUkOhxj3vcqlWrUkrbtM1nbqKUGhpG9xNIdX3sESsUzwHWyXX7HHWj6oeWmORVEzgksAkgSLKZ0VybBEpjirEPcdwZyA1EzPSUBsbITmckYAUgI7QmYjdBokwHnxtD2gBjDxWibndirSVTxmkkAGAIvX7NtQcKEslzlWQaBKpms2BDQJEgKMcSIAJh7iUqBkFwkBzCIKXSpD4XGJWoduFYQxswNEJZEqSMSx9q3yIog051ogRCELRJwKBDnZRiBsvAqR8R6ug5GSAyDDFZ9BJ9iQkwczFJkrpKkLYrEP6HeOC5njln9ml6OItDvUhEIAk2m8Cz1RBs1kTbe0YdgzEGEI465mgR+faVV951xx1FUXAdZivH2Uu2IWaCO4sXL95r/wMPOHLPmCrtMh1yCUE51zFUB++UiqgwsQDaRIAI2KSY2CACFWwZmRg4V8AtBNhECQUsAKIVCOgmABhmGIo2AJAOCTAwaMPAQGDYCjCCKZoGAIQ1EFtyAA40WwYAQAPAQ2HeZMsIWhMAsJATBkDOVAEKHAhr1MxMBpkZFag8YwYA53IHzFw4BEAG1qBBQIljAgcMZjg81bTMYDMABpUxsNMAoAgUA4NQjgJYKABgfrCKuraYdNiOLtuGF2B7d9zCgTQjrh5gEN57o/TChQtPPvnkQw89NIWQ5/lgMNja3gIASTyUmUMa1XWd5/n8+fNV7hQSiAxJJiKJExBRFUCR1hoQAAEERBBJsTw0y9//w9hi3h/AlTj7W731ebLZVTDEbErO7G6NzLqU0vDaRqPhnENEawzPWu3P3hguIEWEiJAoeJ9S0tYOi94QEbVGABEWYUTETANC4hSYN+lkQhSA+OD4dh/FEFus3WaYsLVk2YIneku6zTpj+DmzGoQHZFK329VaK6U4phgjABBRiDHMkhn3E4akZhwSm/zdinwMxJuEX6prRCStGCSkJIJJhAkSAiMoQA1I8Aest0fxpwLvXzi/PRoN8zjux6StQ2mzafTHazerDRGBgAAYY1ARM/sQtDWz73DfBiEhoVBKKXJSSpEiYeaYEJGHizuttNbMDCwgSRuFREk4hYiJLSqtdbWdLJdH8T/G1gpqhkbb+2qTdoOtpnlrbv3Bx2uitJmhqIjgfkoNZplyw43oAwAYYzSpGKMkBkBJjESAqBQBQIyxqipNKrO2VAIgIEkj2cwBS2IOnPAhWgH/38bWM76FxNnaKNpKu80yuLbpidqeNhm6qEVrEYmcmJm0cjbz1X25fPcjlkCMkQCNMQQIAsM8cVQkOBRtoLU2SrMP5XTPSw0iyOJFhJCsocySMyY8qt0efMysjbYwjLY47X5M+mPuCH+IRgAwbE6CiKiUiMQYOQallJJZvtHN9wSArNGo+n0QAWYYWt8AkhJoAgAfIwA4pbuTU9dd+6MfXftDtWHSai2Jq6oCq5fsvutBTzpsr/33kz8xV/BRPDC29gJsD7MNc0TUQwfPfcIK7/MbbbKktAaAocMat9/HSAgBUABAGACMuc88UlrHGIdpLmVZIqJSKqYYZJhux6gVIvoQlFasEiXMWGFmPckN1/z4+o9/dodW06myYVwsa1LRslp//Y9/vnFDVYfxOaPDvx8F7nPZC5XKL1i42LQ6nR4OXIgGmgAoXIsg5qXcq2RRM0mJJUHTmbg2rBrDMVZFHwed2iiwpakh2UpNjnJRgZZyXdYa3dhP4yMSS6jqJC2lK2IMDvLgECvlUy8rRErLOaZuwE6rChuyaBvQKnXFzmA1yGNrmiaaZFDnmNRUrIzWHCIBFrmTKAQoIjU8OHnZ/wPMUGT2wWF277BSwMzKlr7PTnp4RmaMKcsSAPI8TykN3dntdjulNMw/IaIh1XxMQ81aVVUi+MVPfs5lWj+9oTeYbGpnyFQpKOF2yzbk1hs//dHkHAAQiELQCAqEUABgdE5jYsmynU9+etFcIi63IUAkTyg0wBAzNRqDeNX3RjWr3sC4kXxx8IgYCwDMXX8wcFIS2pRcdFnkNQ27EMKUNFwVKgxF0aZB3UM1otQ0iWASrY01UoeMGo7LMhOv41RweaaKUgD7A6MzZYqBQCeNVnZjrKjOsM1oSFhTEAic6lBrbRlhOy1h/vfiIWeSiIQQhnIIEYdJwSKilBpWCgxzAYb0staSaOZoiJQkArrrljtaNfU21pS1MRBzIsg1KZjyinvjbDjrKRRFYpCtYoNiEFC4ur2+99a7cM6S0ScvQYWplOnkReeFtMTWGH2RS4/7v74tDXwAACAASURBVPzsB78QnnPh05Z3O9BOgEAxlrXWlBV1r4aRWnlFnlM2P5U+FflobT0Bt20Y9I3JSKBfq9hwuR+o2B+AFKnqs0YhlWclNMhv6PsAzhSZlCAeYDRJj3oxjXRoqhlGK91T0INEABkIK66dZMEH2XYjj/+9eLADNtt8BlFRFNbaYWqAMWaoQGdCb0NiGWPqutakAQhJjDEKhOtUlj4kFRRSpgP4wF2Vc5/k9lJuTa1VrSV3tRbf1Vx6Z2vpHY2ltzWX3tJaektnh97SXcmN3fqjX2aIXAUkER2U7jspXe1ZRkWDM3DDZy/+6JW3rs425l51B13P0z3b9FI5mFb5aBbzuObGb/7X91ZXU31YFULwYaA0+zRwqHzVFVOPUEP31wRU3bzB3JjKtJipRAMPhgQMjLcJILoyGVU2RkPoZqUiJxtvuPIb/3VLLVinjTjnNt2pTd8ml7dGp6grjUeeu/Uhl0nW2hBCWZZ1XQ+L5sqynFGxQ73mvReRoiiG9r1CYo5JIKVURi8KijkdrtdPVwOjSRvqh8kkaOctpZ2W3d1KiAi02fSjTatOHzfutLjYuGa9sqL6nNvMQkLxtaFeQeNhAmJR92DQr/I53ILxCFONkVwRiU82G+mVQAQ6lf0r3/m8l6p33vWJ57Z2GtB0x0qNzZHpAI6l2R70vVKulAamQUtLlSSjBgdvXZt6vemGbiXssSE3SNxuSX+Kep00v+srvPL8p5y95uN3H39mrjAGE/pGa08Ve61BD/q+sO6hnpoHFw85k8qytNZ679vt9jC+5pzrdrujo6NlWQ6JhYhFUXjv8zyvBp40IqsYa2Ndn+v5yxblrZYq5iXRbIyoZGOdaxqY7DbuSrcEAAYSJAFAVIwggIGUzblbd/tQaZdzgooRtYFEarqsXFtiIJsCldF3jQjlzV4pxleDlkLfHWfjE2hSefRdNIiYfD0H2oweuFfnma4HAY0JGRcwmuWTLMKWMhae4NpNR2yY2gwo2Aa6oLGT8dQAtcXxmru6MP3BhPJNXXRq6WoDVow1igOTxFaWgcYq+Id6ah5cPOTabbj0u/zyy88+++y//uu/Puuss84+++yXvexlz3zmMy+//PIQwrCCIKU0PT09GAxEAnMkIqUMGu0t6EXNwVzYkNF6HddiWKdpQ57fE9OawVTgksAQGAVKizKiNKNjsozjjIOq7E12QwhoqJIQk5RCWN313Xeu3Gfn0cULFu96yDMvvycDpdllUvevfvW+j91l8dL2+O57HveMi29c26AIvBZSrC578fxOe6xlFq/8IpTc+8EFT3vMgh12ao4u3O/Y086/Yt2kKA6ebrv6Ayv3Xjhn0bzxBQce9cLP3tvIXdGdvu2aj5zz5H0XL1yw165PfMF7v3WnpNxoqDUr/OqZTTWaL9CLnvWDqrE+rjNVIZJPyNQgbrvB8P9mPOQySWstImeccYa19rLLLpsxvVesWLFixYph7UCe5yGEOXPmpJQQYlUHVE5rXccQFa/1U+sG000czSghgq8pqEZOTYhVvzcVmxYAFGxyfBEAASBALQzOSdKODUqyKhVKlyH891tWvOjTjSNe8/GnPaHoX3f5x953jQ62P7hnxLSWrDjvwuN3LOZuuPvfLzjr3BWt/X/64QPsXCksPuYdV1/yVJuia81PhWouP/SZ5x3y8oUi/e9cdOZ5L37FY/770qe2e5dfdObbbj/mE5/71G4L1q+7Xu82F0WH1R958lM+NPdV77v4jcumf/fRt775uWc3rrzsOfuwq0nrw95x9UeeRJHt6HKXRswCjhGEm6lIvgLzUM/Mg4yHnElVVQ0ju6eeeiozf/3rXxeRU0455SlPeQoAeO+JqK7r4TYAAINRto61iBiisg6BVQdHgCCAQkAU4FQNuAaEPM9JNvdz2uyYFQBETBILj1N5cNwKVVmTJ3TN/tUXXvq7kXN+dMm5e0+Baz9xz/4VF78955ZaTFlv32NOiwmVxQOW4fM+/8zf/mQdPGF3r1KZ77rD3vsttSllusGDKdnxmKftGrJBiNnjFzz/8gP//cqb1j35sMbEzRMjY3sfesg+u9nIj82pp/oTX3j/x1c/8fVXvOPs5f3+uif/80W/OPjUr3/r7ufvu7jWgXjOvD2X75f36zhXLOB0nzoyVWHLtG0dw0M9MQ82HnImKaWGGQR1XZ966qkxRqXUcccd9wcv/GOC/Ns8Z7M7XnyItUitvCBaymPZnb7nNzfWux5zyFI0dv4gdlMLI0DsDRy4jWt++qm3v/7Sn6++Y1WZj6m6P1qvBbW3T33oNYJNhfR1HyvFY/0b/vW88z787Wt/fyvOnee8HXd1EbB5/Gte9vGnv+ZxR131vOe+8MznPXn/XPjuW342Lb9+096j55FWjUEaoA+73H5XkfaYBIO6DWKMpZwmuGTMMiDXlJ7q91A34M/nmfyf4eHwJw1X+81msyzL0047bbg7zDz54zE7CLhF6GZrPiEiAUeghJgoJoYCMgLu+ims7k2Dop6KbJW1A+Ma/dhSaXDnV19z6pt+fcgb3njBir0709e/7a9esoqX2l5l0BQull7DaLF+ys/R/a+87ikv+PIer/vIJRfvN967/vMvfeGXo0NN/UVPeNNXf/7Ub3/m3y++6LQD3nPse6767MsHCcGedNG3339sIwalteV6vR/Z12Z+p4Alb8yQQtUSY5NNlKpUR85HqhjbNkH1//zTP7x4OOyk4TrfOQebnQIPkOc0Q5SZsMzsEM3WccDZGzMAAERlrbHoFFOUlDjYLO8sOWjP+XTlD36OKw9NYYNjE4K2NqSUpq7/id/hb9786mfsbYJIvTRXt/Qno1pgW5ly/d69G5LN2wUGuud3N6R5K9/2hr86uBM6G/WVWkWcyC1zHc3Y+ONXvuLwY5973KufeNqHPnLdy96/xz44/aPbQ3PBru3MaMCU5jhd+XqkbDGZ7sS6Ku2o8+TXKz+alHHOVBUz98Q+HMGHBxUPx4BjjM65oac7hDCMnMwE5h4AWxAFHrBi5v40QkRnjbJR2WjQao6DYHM375i/e8muJ7379LPcBaceNa9Ja6/rFd1+X2m74657y71f/OQn93r2fruO8G9WqQZmzmdolu223+DD//zBzy07bX7397jo2U/ccTc9ceXf//2X33z8DlDcsaZvOqpd9aqpX//HZ25q7b/PvCUbb/7OjRth7s5zqXPYy/7usVecf+Yzs9e/+PBdxsKaX9/UOfGlx+wqmvc5/LH6XR94/6ULVu668Z7+4qcfe7RyVd0zHoCscgqqh6Dy6KHEQ86k2a8xGUbWUkpZlqX0B/Kvt6mz4I/QbsNdTQZR2AMmNEaHKGWdvBk5+DVXfXP+68/98CtedlG3m+kluz7ulGP3k4qz51/0+XvPefN7XvDFCdU3aWThfseOuzwG2ffcD3zgzpe85z0nfb43b4fjLjj8mGee9+9vftPrL33B0e+dknZjQbbTPjvMyYzp3Xb15W//wnl3TQ8acw5adsY/X/LS3Q20D3rdf3zZvvydX3jFiy+sBjKy/xPOPeKsE6A1GN/zhRe++fcvef9rn/H/FeOLDnntwYcdv7xFmirKIqDhHj7SFm947933TJXd/nR379e+gYQVxZ9dcGG73W40cmutc27oEJJZib1/0gNmLvTez1RUzi6F2wIEOPvC008/fccddxxmO8G2ZNKwFmpr7WY0AarVv7r5ny+9JDY1Daog7FE3HdaemzrW2PRm4CJaNIOaalId9j1DWc3Bssh0hgUB9ktqNSpgrFEHT+IcD2KWx8DWcT+pluhBjFTxoBVGtY4qz8qeVxmYqqyzXEc/iWnMFDEaI0BqY6jGvB6QD2DUQDVdnNQmL401A990FAd9UtlUSHn258mWwc3h/Zl8kGENbiirif5Ub2p679e+wRAqij997webzWar1fgDNbgP4shmy6Fh14DtlYTPXLLN7T/m2xmIpISExnrtyxQ0uIbTTndTkibaSS6YmXo5lG6DH2jXy6FPykYc1K5WHnPbVkEP2CkrZWpPVehUs5EJcbA2EkcXVAV9sD4PtoVFO3RsQ8j0ysGkdgQRpowl0WRlrnT6nFziqXJiQrVCPpkT5LbjFBmzNqfcE41GSCYOBlXIm6VVo53sf/p7/9mgZ4rdhi4ZmJXHPcxBkc0NdeABKwIeGDO+AEQcFn1v7z41JwVIRJJEmBcvXjwYDFqNhldbGtfD8zHxcEcRzbRBAICEG7PYyJsNryCv3UAHTUqFBhrtSYbdPZUTAGhBAxhIgYfYHH7jIEVIFiwAgAWQPG/4FAGcQQClBRw4djAfAvjh0zKKCQBGtAEAQEUNIABOKU8qZqK95oZuQQSAZkQAFQFsFseSgozBQ8rBQQYgoAB9EKI/j80tNvnJ1B5pTErMI1c1K5dhtTalTTRQSgmnmUqBmen4A8OdScMdXrN1AtSDDjOrO51S6ogjjvjMZz7TaDQoMm7LTtLDDoOAxEAAKILMiDhdNdavXXfMcU8yCjLN3pcAklgiP/LC7A8nJNhMq8HG9UWnwBDbee6VqUwbqqktzpyxdjZlus3+/559BmynTOBPtZP+VJBSuCldMzHzUUcd1e12v/vd7/Ymp2aGN/sz1xbuL6iGnzsuW/aYYw7Y5/D9QVEUUeCSeOVyJY847/HDir5EhQnzItYhV1bqShsOZU1b8QTub13oba6DtrkaenhQl9VwiVdVVafTkZaccNKJxxx3bOiX2x5hmtXCZ9Y4xcm4s7hoXpLMJ8i1Ew4ct/t+ukcxRM5JobArdIiDKIWF6Ad5oUM/bGGhbiGD9Nal/rg5j3uLvpZw/0XTQwQRqes6y7Isy0IIWuuiKNrttpp33+Jge2OYLS+rPG8mPxmrUUN1d/2gmAMCQWIBjzxj9uEEoip9t48wGrwyuh8qtKrv2W0lYrZYL2+l3TZ/MZtMMKtN80PNpGbRIKU4pU2dKoWb7dYDdADbnl/K1Uk7HIGMEHhkzlP/4ZqBgV7M8kdaPOthRpDChPUN2/j6yw9tajBe6n5vbtHsYr214sJZvd701mJqizMeZiYRqRSjUmqYB4eKCImROW6bMUjb9k9aAJCkmUFSU6naAjHkEB6OdONHMpSaZh189B2OkBIQZsXIVH+wBU9mdu9j0vbuuLVeg4dHu8WolKrrepgB52NgZtKaZnWSmK3FeMZOuv9/DAMlssZQGWqp/bQp8snuCMCkfYT5jh9mjNrm+jKVOAJaJ44DQkRRTeDJbadd3KfdhsJmJi1fOOCspd1sLwA8LG8UFUIQHnYTSCkpJACAxDL7D5ndSgy2zewym86lk5AL0Ek5O+jFopjm2JMqS+g8c/CMgEaTAozsTaZ0skRadM2qRDEQG5I2BmmZQlI9RTiHpqbiCAQ9ktk+9h/Kn+HPhonBQCFanKqTdyozIbH46LdRgDvEw1rv9mcB8bBGfFgLCoTIKeKgu3TdDWl6QJU3pBhSSFEp1cizNfN357Gx2hVlBcrHwiAr6klqFlqcKfupASpxZgvxvkQlGP8y9WRiRrqvqS3ippfK/MEL/2KZZFkTQERkFCJQgBISTqxbNnnrWKPZaWWYglJoXJ6iH3TX/3KN2hjnbMjHYiCKrAwpEomJpQJXkGTG2L5xVJexGmxIveZf6AufgxvBWeuYoS30x5g0f7FMUmIAgZlBERArBuZEE2uwLtZN9DbE6YbWhBJj0IRZlu3UvK2z7s45aAG1UgA6KgSTAAJgUtIcv5fwzjmP0QE7zYUVmKD/MteANEhKqRgCIsIWjYoeEH/BTCIGICEgBEkAlIBNb2MsgyGnDMbklYgmDSC9QdlqtZaq2KBYQERKXrHSnEG0hTHBSza4yafu9MiUnufzBRGJ0l/mT0calZYwDIuJiIAI/zEJrn+ZP8cQqAADCOCwFyErTb7EoANCACZABxoBySAZ6a2VYmFLjdo6xeQBjdMGK459FZpNLmI1SpCvWz29w8Ke9gXA9t5z90gHEg2LxhARhi2T8P+2TBJkICIFAAwckyAbQggN5oCJkTWxZqEYmIUNZuNz6vGsO5pXSTiiVpkBRZFrl5NWrrcxV95Xd4oi1Mpw9ae+wfiRApGIiJvsJJGhwf1/2k5KIgqAAAUEWBiAtQbkcrcdMFOUadLoUBSBh+QxxqSmRPUmUUVW6IMa9EWQsShDjaMRpe8UmYoEUjBTdS/LHpw3GP9vA6f7+n/C8EVFJET0BzsMP2KYhJtbLocQLrvssv/8z/8c1okPW8I3m83jjjtuxYoVwyNKqcCcUoXKpkCgnbHgfBmI6jEBiIipFJgWwE1+KvS+AgANgBoBEUApQlDQZXSqTKTFM0ueAhRSsrN1VXOWL99n8Vue0NrPtFRdXXf96lded8tkcPn40lccOXLc4uaY17+6a9X7f3DrLROdja0N+WDsoP3mvHC/hXuOB6fjuql8/S9vO/t30wHnfvnMBdd/478vujnrYizm7/aZZ/HXPvPbi1chStZasOQFRxYnL2iN+PqHd6776Pfvvr7G+dg87eRlp4zwkmaWFEzcctf7v3vLd7ptTrbi7tK9F71y14VHLLd1le769e9e/YNwOw/2XjL/1cfO37vZSFV1w09vefPvN6ip8XUZHHvIvBc9trOrst1eefl3bvyn28NUShklDZQwEfjAKtIfTsV5xDBpps9hjPGMM84gossuu2xYbCkixx133MqVK4cv3x1ie/cZXrJFCGkGW4vxLY7M9CtTko2Mj5z3xJH0szWvuGnVvYVeOtnHmFua+8Hn7rT72tsvuPy2XrbzS54y/216/XO+FuYMeIfjdrt4v+KG6zacf829GzL1zCfs9ITFUX4yYec0IpD2NMl9k5FPvbYsHZXx3PXA5G84ff7jVt3xjq/d2s9aL33SLu86bP3zvx5Wt5p770gbbvjdO36DrXljx+817/xTRp//yV/dgWVr+V7/emQn3n73eV/aMGHH5vV60yqOLtrxH85YNLjmnlfcdP2c5bu/8qi9z40/Ov8X3R2XL/v7PehbV9/2zolJm4/M2dgi2Ij3N4pIhv3P/wAeMUxCxGHiZZ7nALBy5UoA+OY3vzmsw1y5cqWIZFkGAES0xZt3hhgScYuXF85sbPFG4gemlIhIA6qsPR/sd29f/721AzfSuqvrRZt9D9vpoHTPa75621U912jcc8uP511x2JKjGnddlRa+ZO/i9p/99iU/rAYYSpFlB2aHi1bOJSWUMHEdUyzqpiXtRQQ3dhl223P5Cr/2nK9t/EHqi6rf0hz59CHF3vn6aR0bXqrf9G+6EcrbJn68Ph3xtKWHL2nduGritH2KhRvufto3p1YDI6zKkpoEfvrBi8dvuO3Zv+qW9Vx1ze0jc+e9decd3/+Tu3XRNs3pX900+dP1azqd4EVnf4wXclt4xDBp5k2/dV0Py8NXrlw5bOQ1pNEwSXxYXjd8D/DWNxnqx+H21mSaHWG8b/e+InGZCRkJSMun+u7pT92VvfzpBz3m5qlP3HDHFROkwCxpks0XXvT8cZ3rMjKTcYLLzC++O7rPMtu/5vbpUlmlyAhJzxMmHNhyzLIDEN2yrqZYaBV7falSVucHL+hUnfp958yJyTfU/9/el4dZWlZ3nnPe5VvuUlVd1Q3dTdPIIou4QQRcQIIyGkGaVoNxnCcxmjhJ1MnoJDoxLjH7ZqImThKXmDijiUsweYiTCFEUFRhFAZUdupGG7uqmqmu599ve5Zz546suiurqTmiRarB/Tz33uXXve7+q7/vOPe/7nuX3Sxt2XVhzgvFfK1xjTeikM52IddnMm/uHk2uSIpjOk49Otn3vwXsb19G+QFWL9Ezn1DXNyHHHXHW80QaIpdYg050npXTjPXs+d1r3za9/2rNvn7v8xslrBrVygPtckOABUlEr4XFjSYs2pLUO+4oFtm7dysx1XbddK603ijFmWbbMLEQWFkT7FzXgfhyd+1dGLP03WkuqtPZh6tOfGlxzbH7Z85/865c+/XXf/u5brq2srt3k3Ns/P3O/gjLGvvZReMd86vUQYI3SSQhzEGJUawEt8TDJsjiIZRMM60qBKD90TZqsk8RV+dheqdOa3/TZ78w4VaskSEio3tP4AiakiUkoVNoxNrVcUu94Ku4S7BgFEjylqhQ/BNXropfGGJq8cfd/v/HuGrppmjdFidzc44Oe3/mbn6DPPnnja844+g9fZa75l+2/eQ8TgOw3wf27C6XHTfKorQ5YzDTHGK21xpj2EQBaDnhEbOma4ABLnEXG+8Wa9qXrqhUd1YoTZY2BQqU7s3dO7v7Ip775umv2nvzMJz1D+xtmTZ73N4vctXtuarq5o6jvmA9FYBz4bbPq6eMRBRwl2jeZFYdQqmHmpLH6zPXdzuDBrh9XSVrpAeG4xT27B+xhcFSJt3J96wOz9+3d+Z3Jeq+JYxoQVCXYuEEV6jrEKQFlu00ob9sxOPnotccZjdjpBBX3avDJnbtxdH0VptWeabzzgbnvzO68vSQL4nwPGL55112/9nc3/+Gd3fPOPY4Y8JAiZY8bn9RyCopI29ELAIvzV+uNiKg1r0XCuMXPLgus/Uf6xJe8CMs+2664Te2SNWt/clP/ezvnS6rOGMuBJQ4Hu2+548qnnvS6yzY1X779u9XI2jVZb8f2z0axs7Ofuq/4X8896U/izKcfKMaPyl4wUTU7giqrXTz1b9vWvfvpJ/7SPNxc5nxUyEMTQ5EM+vfesPMrT9785i20/lvD63tNL9ukBru/sKsKyB3NqbEoGELT71LPz9yHA+X5898Zvv7FJ7z3gts+9t1ilscn9OBrd9dfvnryZ19z9O+9Ivnctx+8vVy3aePRc3dXXx3uWrNWvWRMb5vOqzw/YUPi43YCQHmYg0H4D9nW48aSWj/kvW+1dRZZnduepxCCMSbLslaC9yCRtAMtjw4+ctmVFJHUJa6XPOOctb+abS6Soph2H71y+z+x7T84+OV/2vGOs49+7YXnrMuq3fP6S8WD2azWaXn1F7a/djjxjh/b/IGz611NFZ3p0YZM3Ttu6e8/f9v4Sza//ILTfiqN4NyOSXdH1cxnQc/Pvvtz/Avn9l70gk0/E7mI5uqvT3/5XuDRtFZc1wGjySISabJjvbwx2C+2b3/1V+gNT3vSW16edjlO7r7//913/+Tcfa+/fP0bz5r4uUuOHTE8t2f6Q5PTfpBvXDd20Xkbnpx1oBhO7n7g7V/chdIhPBR5ZpzevWdR35SEicLNf/SBkZGRPE/TNG1vW3vD4Afod3vswSCoBURrJHTurPfdFEDUNz9x/LGjSmmlFACxiAgqpYi037enW1biF6Gy0I3oxxTccufee447Y23vxFlTZY+Qva8RQzQv0aY6UegjpFt/8sz/Ud5+zj/PrDi+VQJ67BEpxBiI4ca3/bhhCaSZuS5DaOZny/nh3Pxpv/I/kaOicNMffWBkZKTTydoe3JV90mKB22NfM/loQUJEFERBAIZW20tEG4QchEAUCpCIMCghIopQI+K+cqZ9P4heKwBNiqqmiobSTBEMLZfhEWoTJDii0c975xkJUmctpCqpIsHKydGwSj0wvgkiQQkyMwgAMpIsDQws7l1aPFQzufj2ssdlX004wNrzsAVKeyaRRUVBJo4CkPUdBALSIqQAWRAhABAg0kLfHAAsGpIAZIoTQC9qWMdaJ6RVVQ8AKhMfGWH2fH1rmnJKGboi+CZNcvPgsUXeV7M7Vv7/1epc55BaAEIABCUS5OFY8SMPs6SHsGQFumz0D+Hf/iFCExDoSK3ClxIFKMD9idliW2JsJ0tSSowhYInBMTNJd8EnIWKryAMAADZEHeOgicNShWQEqaeSJDW9Wj2ytcQm3LCrGfTtRMN1ZUo/xE/867ZP414/3l1xvDrEAOEPCutRwCsmpRRw2JcyWDjZ/fcui4bxkJbSUq+1vwHKD7+P+9EFEQFRm1dDIlSgRMHIWqzmh0U9PVW5Zi9EVoRWaa2Q1d5l83h7nEGgXjLqtO2Ortcj64AyjxSjI3lknQVNUjcYorgQG42+qzJucNBdow6w3iJeHUsiDYBEUYgAiRCZCJbFvZe6qEU7OeDstsyhPWYdAY8WhBAFBRhYIiEgk2juTsydMBJjBGYQIUBECIiRxUUNK23oNNcesIiOsn6d9tgFtEQUAjyyqpLcqT6J85UgmtCbs2gTl0vlpbPi+LBKsxvGgMTUqubtC+9rQ025gseBg3QELDUdWaJeuvTXx+SMflBEZM0SlUB0kU2UaCKz6bAopDYUiUAEgPu0OSMAyGLIGwAAELGRkUqaaNmBBaV7ir0RECX+kc1uFeC+ynJjHTkVIFQQGkwOrzonZkYBaVWxYgwQEaUlKtkfS2O8eumrK9raQ+8+JlwljxaCBIkqAkDkiMQhSohR25RdlLhgKaIFkRmYGe3K3eK5GMeOOjkMfAiux7puouOYPcJIcCYcIuRIdagFfW6S4OzU6MRYM7/ieHWAm/fDhkeNGAGAGTgEL0Ek+mYhB3CQuUu3iaqlZRiLKYU2vdVSsy9m1/9dVr/DBARKEKgGUWQgfvMNz350j8/SAKAiIxGUUj6yF1ZGk69SlRAllfe1sM5swoLB11KQyT2LFjQQkyRt6hBIKzm8+CQX55/gGzTGsvLeKxW88624GzMbIsQFC1ks43nc5N0ON2SqJ0EDGrBWSIUYE51kZHViG3ZVPWOk6qBLmsaygqh7yTiXkkkKHoVVNRxGX2l5vHElHxiPm2zJ4YYyRJ3YopwjQxDZVTVXpvbCWifdPGqF1ibacIy1r5voscg6Wa4UJCxMWEOq0tRFNvFxpnRzIByxpEMEgaqn5753/fXXf+VL9XAgjg0oCKCyQb5+wwWXvXLzKU+tBk3HKgPeZnGv8x2tfVMaYxBQEzTFQBGDepypbx0IRyzpEEE4ve3mr1/10b88YXSsozVpIoqgoM/ptju+f+3fgmqK6QAAF/NJREFU/n24eJiPr9teD7tjvWE5P5aOzwQuq8baxCTJxJoxY8VqdXitkn4AHLGkQ4RXI1/84o26Gr3v3r1re72qqTz7GP2o6SRrcqumvvGxj1BGmJjAkWzSKQdKKfYuzUw2OvrAMSec/qKXyfrjdHyCLJWOWNIhglDfu31HrxLtk0GjXTSCSFrNIeLs3gky42M6RU6cmCCpaOw1HJibcpSQp2Dbzu/tmFhz2sWvecLwpx6xpENEXlX9KGGuSJmaogbDSkuuyEZbOz+1J5a2Z/tdlWgLpIPYzJVOmW6nw+WIqSUJN990y4nnDXXnCXILjkQBFnDFFVeISKsS3kbODq6sMsj1XF0ye0gkWh/RK2FX+2k/VY5ROOmo+eM3TG3ctGvD5nvXH3vnxk039jfeNXbstt6am0ePvq5zyh1rn3rfrkF3JA1h3qU6DalLKwN7vvq+Vz7vhN66idOe/Yp3f/ruIioVQ+11OnPVb249+8njWffY57zsXV+6HxWDtaqwhDE17A4DPt8nyBfiB8fnPvc5ALjkkkustSLS1mfiQdQ1Gk950nvqcf014z5FUEAQEGEj6griAHlOQjmcizEiIzFgpjH4QMwYDARtsSyGdV1plbFvghI3Z+7/yOt/8rfvef5b//LdTxt+7rff/Zat4Zhr3/mcfsd/6x0Xv+ZPYMtb//Y9z/3eJ9/0+5e9NL/uhl89XmxXDZy3oUe5h9U2piOWtAAi+vznPw8AW7ZsAQBEbAP96gAVbUqpyopb25/qqQqiFoEQbWr21rUX9jE6bvOaqAkVoWOG1kDBA+hI4IIXERN0ERVkbiLe8Id/cVP3FX/63nddut7r8zbuuvGCD/7ZP7/tOZfxtR/6q2+nb/z6+99+ese+4rnvn3/epR9+77/+8p+/lGCGsolIgOUA9Cpz+h6Z3RZARN77yy+//PLLL1+s6TvIBEdE876el3rPYO/M1IPDvbPFzKAYlA/ODgbD2jesolggEo7R175udRoeqj0XYQSypknyPKti7Mzu/Nr13w9PeeEFRw0r8aZ/5qUvetLwq1+7HuT7119bTVz040+HlGI5N3LBT5yjqhu+ewvWqnI9gNLN22z1qaGPWNIhAqOEugEWZDFKa2saBTPCRmeajBalQWlApYy2JskW1H98jJE5gvgYnPcMgoaH0YbBXjM1Ox3hpIkO5SMdrouZNf2usTPVVHPXztn66I3dCkvxWRI4O+b4em73Ts5tsqEq69wmZTVY7etxZHbbB2Y2xlx00UVbtmxZzG977w80uxERBlYhGAVKKYNkyDSedZ4DAHJsqQxAuC1XWSiGainOFUmQwFEI7Tw5KvsjuqhQ+lnZFFAGj4R52TWmqEWMtdyTBpUFI+xjqVysXNEF3SCU2pSN19Gu+p1c7b9/2ICZL7rooksuuQQfLnB2oBV3RIkShNuSQqMFx2w3i6GsS93yxBChAhQFC0dDhQpRi0JrrAcnhKQUZ2HUjTsIfvPYuJ+bGSQiGAUEi/v3lP3zjs60G+1X5VQFaBTriLJ3cgo2HbNOvIE4otJC0IykUK9yhPPI7LaArVu3XnzxxUop51xrRsaYg9SI+hiFUDR4S6WWWXGlhKKpR1jnTFZQRQFGAULSaGyMUR7esbmgdmf9rI06+jVH/fhz18EXv3h1yEfQ2OzO667aYZ515omj+plnPWfd9mv+7YYqeBmQu+XLN82f8Mznn9I3s3UV7ZwdljasfoDziE9awEtf+lIAaEuy2lvu/cE21gqRrXGoFCus2Vob2ZkU3UIFnCAiAYAIAkIEBI3gUZEi7X2TqqQ0qRHli2IUVK1Ki0979VvP/NCbfvnnTh384snN3/zu22970q++79K89t0X/9efPeczH3zLL6a/89oztn3kV/5s+ylv/+szuYojnV7ViM4KcbzqPuGIJR0iWsHxlvHCOdcqq9R1bdOF7d6yVkEQVka7umn3bt28AyxNVXNfzXgBP0Fdd/JrP/mJHW/93T974wunxk579qv/+mNvObufUrD103/9by7Xb37zB3/m80PefPGbPvVb73rKxLSaZD+BLE2GIxHjanulI5Z0iPCNQwFXN2k/qUPs9HLvfWKsjwH2MyNETNO0rmujdYwxMTaE0M3z1FpphpHFxiRw4X324vd88Px3fjxL6rLOTFK7qk6osTImL/yFT9z866osbK4hclnv6lPO0Xd6GkI+G1RKqxyaXG2f+LhFr9drdehaxfqyLNv4Ex4A3vs0TZVSvU43hEAA0QcCjE6lEChzM7EvmDQhF/YlWQ/OBGGVl3rMwUwSOqMWlIGUJQ2qSLsmJLqn62FZNDWo1S8oOOKTDhHB+Y3rN7SsKU3T5HnuvSfAVj1s0RUtNhcYpb3zCilS7He7RVFkWUZEadabGnhK7Ug9QG0TX9Rk54uqG2tOj+pWEOPcUPUbnO967CS92eAgo7SKw1h0XF5LBxOtqwrsKndqHPFJh4gQwrnnnnv33XcXRaGUIqKWIgwCY5T2cekTjNxNM4UoMTrnJicnL3jhC6LwbFQTmeQla9QQ4gwE1lmXUrHr6tC4Zui0BlATSY4xcDXdc2VWVd2kE9I+NqGflkk9TXgkMvm4hdX6gvPPr4riqquummqaPM+HwyHiAX1SijpwTNPUpEm33/uJiy4688wzS9f0e77xBjEG5oSBe+NZA5AkwDAvEdNEo1N60Mz3lEkqOxn1mi5hXZYaxavMBKFenkZd+1We4I5Y0iFCRMbHx7du3Xr++ecjYtM0bfgAl2iIw9KlNwsgVk2ddvIoPLFuXZKlqIiqNPHDMsupiSHth9AMA2sYcux1SOarmPdr5UfZiNcF+tGEKgy5S3KpixxwHpkEXF3pVerZXYRu2T+XNn7jPtHS9i3YxzvbNrsdKHvwo4Y5BynaLF+TZiM2t7X3FpUl9KoGFgMquAiRBJUgWqvn6ypNU5HI0WutOURmzpTx5EEnBiJkGYBPhcASwKgiYFDdPgD0RbMG1pCAAQAVyOcCkNgInAFCADgAe9GhQZaQ1QDAoqpkm4QmIuZIKK2FrKA52TJ1LP11GeBxyFjyw0NuK62tRDE6ccEjSkBBJFUJK6wkmDwVEO99ok3dlN2eIYgxsDAoUmzJCwetwK92IOjhWMqMsOzuwxJHCw93urg/682yAy3q4B4xpmUg6AUfiahpotXKGvRVafIspKSUVgBeGCLnJuMQU5vXsUwoUWJALHhQDFGEPSt7eG16ELFtyF7RkvYfjPukcPXiS/s/LvNGBz/ojxwErdVN8GSBxQFwtB4RhDIE4tpZAdDaN06MAYLgWSnRBtulKQsgakLAA8sZrApWvOPL56WV5i694oj9LeaIAS0DKaiqSpOqho21tqidQwzgUhSjdCdJSKMEBmYNwsF3A0EIUYMoDCBIEYEjRA35ap/KcuBKlMDLBuw/R+23UltChb705ccRS8ljgxo4lPW3r/7qDV++ppgfgMLMJsE3tfG9dRMXbrnk1DN/rGQm0AaIwEJiY2QgVIgKBFkBh6YKsDJ90mpi6a1fxsm2v39ZzsS1/+y2jPVm/4P+iMNxcccN1/7Lhz/8pN7ohEWrSJXzJnAinQduv+fW+I9pWabrjyo9JCqtitr0NARviYxSgirtj/TWHKV6PTksuV+W0Wi1fuRArmRlJq4WS40JlpjeEUtaRJf637jyhjVxdPD9as7AIDSKwcSYqr26l0faddXH/jemmGQaYpToEyESzhMtSvmsM3Hq6Sc999y1m08iOew8/aLprPjusnXSQ/xJuI9fi5m1ImFefGXF1dYTdY5rVeHagNki+fhBOOzq6Lbdta0zXSaOm+hUhjolSKSslC2a7EHZMJJ1bESsFHljyRjlpeiWnkdsOuQdd35j10Rn3VGn1SZoiBoS7SGkQALgvVgDNask1myIvGXjVc2QWg5l2NWx60ASRiFBcNDEOclHzKPk2xbPd9ndX3QrcnAW5SPAfboDrXaFc+7gMVjUygFr8SDAIDqIqjmyU4FdwCmLNfU6vTG0hChIEMUpLX1RToe+jrUUe2687cyzCoMdcFXdM6GeTyO5xpBNtMwK9hyGVEyDPjqA0KgeOp+UtMlCNAgIoapDZjIFI4/ZVToIDq9gxiriM5/5TKsft3TbchDFwYyV8swgFcSGJGpkIkQVhbGb4oZ1zeaNe47dcO+Go+9Ye9StY2vvGF9717pjblt7/N0jJ946ccLkphPueWAP9gwkTZ1b04RUjzaKr/qL15296dhOfvIpP/XGK+7IQELClpUxWVfP3v3hV697yjnvmRwoZoiebYIuRKUZDgNGryM+aQFXXnmltXbr1q2tkg7uU0Q5oGcSDhmNnbIp6/WokyQGUwXBOTCqJigwPsiuGOyJMSZCVukaHZZq2ttM8jr1XXLuwQFHkWaQ5GsiIFRw70d/5j+/57pL3/m+Pzpu+Mk/fscrL8avfuf9z0YjeuYbn/3Au9/1+1ffUYcz8lIF5+vUdIUaShUKYNCr7hOOWNICjDGf/exnReRlL3tZS6pZlmWe5wfi1WSRRgOPd4te6gx632iIDmtt8hhj7RxwIMBECCNzUyRdG72jEJQgAFXMGo3YRJEOEbWfAtz+0T/913Uv+9Qfv/mCXLKzT9x7y/P+5PeueO8nLjPqhj/4b+/42mk/f+WHbvwvr9upgmqstRCgjkNrIDTa6ENT0no0ccSSFtA0DSL+wz/8AzNfdtllIYSF4rUDcPWLSFFVw6ZopKohcuM71jCyb4IC1IIiIEhsjRj0hjVYULXRxDUba8TjXFUEANIqcq2StXL/p66btE9/0YVjSBCNPvUlzzvud//pqm+pLc+hp737SzdlNvdf+KWd4d5hjOi9ThRo0pEr0lZQAFa5DfeIJS2gJSoRkTzP2+fe+1Z9cMXxXsFQmtqgWKVJCxJpAxx8dMomhgyHwBGQUaFSqKEB1MoAEGlqKIlq6IL2AVHpYCEZlNt377b5GRs7FUhioYx6/dhgz/T9znJfMlI1eJvxBkN1okhbig4UpUQJt5zQuMpxqdWeXQ8btAUSL3/5yy+88MJ202uMOUijUopae8a64dqhj5rBCKJQShaFfHReApsASYiqrsMccgHYVKHwCZbBRQHIU0Ee6JpTqmsrOJ/uTUqe6TUBEBBGLYAazFvQGEPlycksUGGaEXEpAET2dV0HF5EY1OrTnlIjTSqZ8NAa8F7QWcm1LofLgpBP+PRtURSXXnrpli1btNZVVTHzcDi09oCCSU1dNySqmymEBJE5DOsCgJkwCgOQUkahxUAUVabzmFiS1Jqe4qiUDDkiGNS2B5qaEtNENh/TS6dm73dlaqxvGL47N2P0sSeTLwLEzNgCGKIG8ZA0DYDShjRGJagaVT9qRWOLoq7LUhqBIPfGxXmkAGgFO6GuQD9kD6QiskUdSYaFUkoUk+d6ZGWBnycwXvWqV1188cXM7L3PsizG2Ol0DhLTb2dA2NdsSURpmq7IbbKYMGiLKtvW3nYmdd7VLDFJE4T++LnnbPRf/Nr1RFyoJLv79r/bhudeeDKRNcZUCvrUbWIbU0aJoBAs9RF1IRKzH/qCm1PjOEiSqSjMLJoTUNI85LMJUTEFskmjgIg8eKqbsN8y8wmfJ9myZQsiKqXSNBWRlo/rIPGkJElCCG1Zaav23JaVwkqVPYsx4naw1jpNU+ccEekaoAGMvklOfdMbXtx85Od/9nc+fs0X3v+LP/3b92x69S+95CjQhiNZaFAJADfKejKeHChmXxkB5RW7R80nLZt5Fu87BW4UqACIGAiAg+rnS9dmxJqwbnye+vG+iBCLrgaqCLAk7/aENyMAaL0RAHjv2ycHtyQkUkp576217TDnXBs+WD5yXw2r9z7GGEJoJ02ttVZaZ7YEB8BWjxz3hg/+82/8p3s/+paLL33PdfmrP3zFXzy/W3GIqIpQJ1LPWpP3uMkAE7QARFacH6bWa3qUI5PLjElEqPYIoBoHIojoEsOa2DxkwVpEwEtE4c44D/ZoUGZ6jz9m89Js8NKE7hN1qeScy7Js0XMs6n0fyJiC98aYuq7zPM/zvKqqhXwlEazklhQRRIkxjvT7HjHGYIyJHFWDI0pEpXWcS/Qxz3nb/7nm10KDyhCaJjouCBS6iCjKHv2cD9w7iUA0gy6LmAbOdbqgfnpIKsgrYPFe7/+WQkrnZlhARy57EzKoZPwhIShCH9kkOHRNfz1DBLL53XdBuvxAT3i3ZK1tdb3bzlrYl4k70PjFdG9rakS09IPLBrevtArVrUOy1jZNIyI+GzibYQ1ejTgPCYMO2EX0TSRQijIbkmC7nHhgrPUwlWA5NypFBJVACAMNlaYf7t0RESYES6M33RpNAppd/ygA0FWzOIYIhNNUC86ecpIi8Ui9m2/RO/fAj9js1jZlM/NiqgQOSleCRMcee2wIAQBaqgna543gAEXQLZOOc8573zTNhg0blFI4MNbXQxf70aWKQDm0Re0G3eAhAkvmVTNs6lRsrec6mDJpVkmk4MXFptIMIEaqR22iWPY1WLKDI5ycHfnWzZopIg9OO9UkVmjJ3o0SJaQwT2afehKhhIidu+/PbllZ5vcJjG63C0vWRiGEqqqy7IAyfjGEc845Z3p6GgDa7lvv/WI51/7jWx/mvWfmqqomJyfPOussZtZ5jpJ2M8UEUTcl2aHraJN7ayAJQQ3RJKOKQCDlEdtoBhAB5pBom+gMVDcC+Ue78HIFt0qUfPv76dRuHHh2bvac09MawvhDf1gHDdns/NAL9Xs7zj53/OavwwDW/e0nd556fLb5aFY6pURyZAlYost1KodXBfujhcWGinavTkRJkhykPin6+ILzXxCbcNVVVxXzA00qxpimaePdUm+02JyjcMG1J1l69MYN51149tPOepZFxcALiQbRKJACg0EAAAUMmHEOwEwWgAEAzEIoWaFlYUBo9TG1MDxK69eITgsCqEYHAArsitoZneIDt637x48DNJwn0+e+GNnMJ7imDipP21Y43Dkc0tTuvXtm5lGb4c5T/+DPMzcIktWbjom/9XY3vr5TDO268eBcKgAx82a1iZ8PD2gliDS3d+/uyUlrrSFVVRUAgFp5xc0OFugGCY0xWSfv9/vKWh8Or+tZwPwodGNUToEOdQSOAG6qGHnn78kt33Cjyptjvvu2n06769aNrol921cda22SJLhrfkhzMzPD+YFXYebB/u3fPuXjV5BpQBScfmL1c693pz9LN4VJo6heBDSHARHd4QCWYI0VkOB8S3YjkQGAl5SmLvVn1DK8AbQBZEBsvVU4zK6naLIeal1HsPmQfBrjbTeov/qkvusWL4OEx25/5cvnn/KMdXkuPdBp3slHjDHWWpzeO9l4O18VcW56rhjO1+UJX/nG8d+4dlhP9mG0ybL5l79YbXmlpGstF9rPSvYjF/5eGfsavEQkhCCR27lsaWnq0p0K4UIWAgi11m0ZHTMrPNxSn53KqGRQhdA4nO3836uTT16hw1wMDmz3/mc98/aLXpA0nfGRTtrVSZb2umMtsR3Ozu6sXDaYmfUyOythsG0uT3nT1dcdc/110gRDLNT4jceo559XnvEMtXYzja9Z7VM9LNA4bpMebaluFF64oPKwxozF8couLMUUUpsqaUOgiTlgam9VoOvh/GAvzEzl374p/fr1sHNXVTvBRFP3++c9a/K8M0uTkrFremsmTEZjqq+7C6T1xey0Y5menh5ajnsHTRXEh6KqJu686/Qv/ZspppzuqVpqUkKhKyWHJ4hG4g8IMgD7DMXH0CbUUGvwS7T/lkZPVBJDaBlwDS00HRyGjV9RoQ7IRJAaNyw5hnQ0cwp2vPAlO855RlIloRtGvfQ3Hk8Rx3OFebawGKz2DmIKc7N7i7J2LviiaCLPBsdl0xM59ZvXda+/WpWgVbeKlUHC1a/OOyzgmrJ1SAwC++LCjED8UBn40vFCBhcbxwRgX7pdmcOrREw1EjNyrjYagzVBjwyfetZ9z31G0Sfb5FXTqDVqQ2dEr1lrbDYhCJ1kIYQ2qJxxUriBH8zOeT9bRxzMh3pqoDrWBez1aH524313H7V9u9z9gG6iHk6v9skeFtBiwRjw3junjEa9EOyGuBBNAHhYx08A1z4hgYUvIxIghsNM5V3j2CCpZTTH8Y0zp54+c+LxswY9RhshZMmIzlOD/ZGRXtKpNZlut0MLpNP/H4thKItoktNzAAAAAElFTkSuQmCC" + } + }, + "cell_type": "markdown", + "id": "db59d1b0", + "metadata": {}, + "source": [ + "The dataset is organised as shown in this picture below:\n", + "\n", + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "id": "60ab883b", + "metadata": {}, + "source": [ + "Here, the sequence folders `00` and `01` contain point clouds. To read them we use `ml3d.datasets.SemanticKITTI` (More information available in [API docs](http://www.open3d.org/docs/release/python_api/open3d.ml.torch.datasets.SemanticKITTI.html))." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "618f253a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jupyter environment detected. Enabling Open3D WebVisualizer.\n", + "[Open3D INFO] WebRTC GUI backend enabled.\n", + "[Open3D INFO] WebRTCWindowSystem: HTTP handshake server disabled.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\n", + " Using the Open3D PyTorch ops with CUDA 11 may have stability issues!\n", + "\n", + " We recommend to compile PyTorch from source with compile flags\n", + " '-Xcompiler -fno-gnu-unique'\n", + "\n", + " or use the PyTorch wheels at\n", + " https://github.com/isl-org/open3d_downloads/releases/tag/torch1.8.2\n", + "\n", + "\n", + " Ignore this message if PyTorch has been compiled with the aforementioned\n", + " flags.\n", + "\n", + " See https://github.com/isl-org/Open3D/issues/3324 and\n", + " https://github.com/pytorch/pytorch/issues/52663 for more information on this\n", + " problem.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\n" + ] + } + ], + "source": [ + "import open3d.ml.torch as ml3d" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9739b5cf", + "metadata": {}, + "outputs": [], + "source": [ + "# Read a dataset by specifying the path. We are also providing the cache directory and splits.\n", + "dataset = ml3d.datasets.SemanticKITTI(dataset_path='SemanticKITTI/',\n", + " cache_dir='./logs/cache',\n", + " training_split=['00'],\n", + " validation_split=['01'],\n", + " test_split=['02'])" + ] + }, + { + "cell_type": "markdown", + "id": "8eb9c25e", + "metadata": {}, + "source": [ + "Here you may notice that point clouds of sequences mentioned in `training_split`, `validation_split` and `test_split` go into their respective split group. The three different split parameter variables instruct Open3D-ML subsystem to reference the following folder locations:\n", + "\n", + "- `training_split=['00']` points to `'SemanticKITTI/dataset/sequences/00/'`\n", + "- `validation_split=['01']` points to `'SemanticKITTI/dataset/sequences/01/'`\n", + "- `test_split=['02']` points to `'SemanticKITTI/dataset/sequences/02/'`\n" + ] + }, + { + "cell_type": "markdown", + "id": "f0e2077e", + "metadata": {}, + "source": [ + "## Accessing splits" + ] + }, + { + "cell_type": "markdown", + "id": "53999c8a", + "metadata": {}, + "source": [ + "Any split can be accessed using `dataset.get_split(split_name)` method where `split_name` can take any of the valued given below:\n", + "\n", + "- `training`: Returns train data split.\n", + "- `validation`: Returns validation data split.\n", + "- `test`: Returns test data split.\n", + "- `all`: Returs entire dataset by combining all three splits above." + ] + }, + { + "cell_type": "markdown", + "id": "f88db995", + "metadata": {}, + "source": [ + "Access train data split:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "83a166e2", + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: 'SemanticKITTI/dataset/sequences/00/velodyne'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_12788/3269926996.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtrain_split\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_split\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'training'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/pip-global/open3d/_ml3d/datasets/semantickitti.py\u001b[0m in \u001b[0;36mget_split\u001b[0;34m(self, split)\u001b[0m\n\u001b[1;32m 140\u001b[0m \u001b[0mA\u001b[0m \u001b[0mdataset\u001b[0m \u001b[0msplit\u001b[0m \u001b[0mobject\u001b[0m \u001b[0mproviding\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mrequested\u001b[0m \u001b[0msubset\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 141\u001b[0m \"\"\"\n\u001b[0;32m--> 142\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mSemanticKITTISplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msplit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 143\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 144\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mis_tested\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/pip-global/open3d/_ml3d/datasets/semantickitti.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, dataset, split)\u001b[0m\n\u001b[1;32m 258\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 259\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msplit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'training'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 260\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msplit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 261\u001b[0m log.info(\"Found {} pointclouds for {}\".format(len(self.path_list),\n\u001b[1;32m 262\u001b[0m split))\n", + "\u001b[0;32m/usr/local/pip-global/open3d/_ml3d/datasets/base_dataset.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, dataset, split)\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msplit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'training'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 121\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcfg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcfg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 122\u001b[0;31m \u001b[0mpath_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_split_list\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 123\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpath_list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 124\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msplit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/pip-global/open3d/_ml3d/datasets/semantickitti.py\u001b[0m in \u001b[0;36mget_split_list\u001b[0;34m(self, split)\u001b[0m\n\u001b[1;32m 248\u001b[0m 'velodyne')\n\u001b[1;32m 249\u001b[0m file_list.append(\n\u001b[0;32m--> 250\u001b[0;31m [join(pc_path, f) for f in np.sort(os.listdir(pc_path))])\n\u001b[0m\u001b[1;32m 251\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 252\u001b[0m \u001b[0mfile_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'SemanticKITTI/dataset/sequences/00/velodyne'" + ] + } + ], + "source": [ + "train_split = dataset.get_split('training')" + ] + }, + { + "cell_type": "markdown", + "id": "5c544b28", + "metadata": {}, + "source": [ + "Access validation data split:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c99b3932", + "metadata": {}, + "outputs": [], + "source": [ + "val_split = dataset.get_split('validation')" + ] + }, + { + "cell_type": "markdown", + "id": "1542853e", + "metadata": {}, + "source": [ + "Access test data split:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "95ee76c8", + "metadata": {}, + "outputs": [], + "source": [ + "test_split = dataset.get_split('test')" + ] + }, + { + "cell_type": "markdown", + "id": "3747192f", + "metadata": {}, + "source": [ + "Access all the splits:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a128832e", + "metadata": {}, + "outputs": [], + "source": [ + "all_split = dataset.get_split('all')" + ] + }, + { + "cell_type": "markdown", + "id": "6f41aeed", + "metadata": {}, + "source": [ + "Check the number of point clouds in each split:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65fffc53", + "metadata": {}, + "outputs": [], + "source": [ + "print(len(train_split))\n", + "print(len(val_split))\n", + "print(len(test_split))\n", + "print(len(all_split))" + ] + }, + { + "cell_type": "markdown", + "id": "c7c26d04", + "metadata": {}, + "source": [ + "These are same as number of point clouds present in their respective sequence directories." + ] + }, + { + "cell_type": "markdown", + "id": "2c70fa37", + "metadata": {}, + "source": [ + "
\n", + " **Note:** The returned split objects are built using `BaseDatasetSplit`\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "737a611f", + "metadata": {}, + "source": [ + "### Point clouds within splits" + ] + }, + { + "cell_type": "markdown", + "id": "a5870edf", + "metadata": {}, + "source": [ + "There are three important methods available for split objects.\n", + "\n", + "1. `__len__`: Returns total length i.e number of point clouds available in the split. This also is an upper limit for indices to be passed into `get_attr` and `get_data` methods.\n", + "\n", + "2. `get_attr`: Takes integer ID between `0` and `len(split)` (exclusive) as input and returns metadata (e.g. name, point cloud file path, split etc.) associated with the specific point cloud. Each integer ID is associated with a unique point cloud in the split.\n", + "\n", + "3. `get_data`: Takes integer ID between `0` and `len(split)` (exclusive) as input and returns point positions, features and labels associated with the specific point cloud. Each integer ID is associated with a unique point cloud in the split.\n", + "\n", + "Let us probe `validation` split as an example." + ] + }, + { + "cell_type": "markdown", + "id": "b484107b", + "metadata": {}, + "source": [ + "Maximum integer ID possible for `get_attr` and `get_data` can be calculated using `len(split)-1`." + ] + }, + { + "cell_type": "markdown", + "id": "818ac406", + "metadata": {}, + "source": [ + "Now, let us have a look at attributes i.e metadata associated with point cloud present at ID `0`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a8b35f8", + "metadata": {}, + "outputs": [], + "source": [ + "# Dictionary containing information about the data e.g. name, path, split, etc.\n", + "attr = val_split.get_attr(0)\n", + "\n", + "print(attr.keys())" + ] + }, + { + "cell_type": "markdown", + "id": "09af7cc6", + "metadata": {}, + "source": [ + "Atttributes returned are: `'idx'`(index ID), `'name'` (name of point cloud file), `'path'` (path of point cloud file), and `'split'` (split name of point cloud file)." + ] + }, + { + "cell_type": "markdown", + "id": "72d02c29", + "metadata": {}, + "source": [ + "Now, let us also have a look at actual point cloud data at ID `0`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e10fd476", + "metadata": {}, + "outputs": [], + "source": [ + "data = train_split.get_data(0) # Dictionary of `point`, `feat`, and `label`\n", + "print(data.keys())" + ] + }, + { + "cell_type": "markdown", + "id": "158a6796", + "metadata": {}, + "source": [ + "- The **`'point'`** key value contains a set of 3D point coordinates - X, Y, and Z:\n", + "\n", + "- The **`'feat'`** (features) key value contains RGB color information for each of the above points.\n", + "\n", + "- The **`'label'`** key value represents which class the dataset content belongs to, i.e.: *pedestrian, vehicle, traffic light*, etc.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c413c43c", + "metadata": {}, + "outputs": [], + "source": [ + "#support of Open3d-ML visualizer in Jupyter Notebooks is in progress\n", + "#view the frames using the visualizer\n", + "#vis = ml3d.vis.Visualizer()\n", + "#vis.visualize_dataset(dataset, 'training',indices=range(len(train_split)))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorial/notebook/03_train_model.ipynb b/docs/tutorial/notebook/03_train_model.ipynb new file mode 100644 index 00000000..d2b2728b --- /dev/null +++ b/docs/tutorial/notebook/03_train_model.ipynb @@ -0,0 +1,583 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e7cd83b2", + "metadata": {}, + "source": [ + "## Training a Semantic Segmentation Model" + ] + }, + { + "cell_type": "markdown", + "id": "626f62dc", + "metadata": {}, + "source": [ + "In this tutorial, we will learn how to train a semantic segmentation model using either PyTorch or Tensorflow. \n", + "\n", + "## Installing dependencies\n", + "\n", + "Before you start, chose either Pyorch or Tensorflow. You cannot chose both. The requirements text files are present in the main directory of Open3D-ML respoitory. Use them to ensure that you have the right dependencies installed in your enviroment. \n", + "\n", + "From Open3D-ML main directory,\n", + "\n", + "PyTorch users may run:\n", + "```sh\n", + "pip install -r requirements-torch-cuda.txt\n", + "```\n", + "\n", + "Tensorflow users may run:\n", + "```sh\n", + "pip install -r requirements-tensoflow.txt\n", + "```\n", + "\n", + "Create a folder where your dataset will be downloaded." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "af472b00", + "metadata": {}, + "outputs": [], + "source": [ + "!mkdir -p data" + ] + }, + { + "cell_type": "markdown", + "id": "c61cdb80", + "metadata": {}, + "source": [ + "### Downloading Toronto3D dataset" + ] + }, + { + "cell_type": "markdown", + "id": "15151b22", + "metadata": {}, + "source": [ + "Open3D-ML provides [scripts](https://github.com/isl-org/Open3D-ML/tree/master/scripts/download_datasets) to download datasets locally. Let us download Toronto3D dataset. (We chose this dataset becuase it is small in size compared to other datasets like SemanticKITTI).\n", + "\n", + "Let us use the Toronto3D dataset script to download point clouds. Let use write the downloading script locally first:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a7f719b8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Writing data/download_toronto3d.sh\n" + ] + } + ], + "source": [ + "%%writefile data/download_toronto3d.sh\n", + "#!/bin/bash\n", + " \n", + "if [ \"$#\" -ne 1 ]; then\n", + " echo \"Please, provide the base directory to store the dataset.\"\n", + " exit 1\n", + "fi\n", + "\n", + "if ! command -v unzip &> /dev/null\n", + "then\n", + " echo \"Error: unzip could not be found. Please, install it to continue.\"\n", + " exit\n", + "fi\n", + "\n", + "BASE_DIR=\"$1\"/Toronto3D\n", + "\n", + "export url=\"https://xx9lca.sn.files.1drv.com/y4mUm9-LiY3vULTW79zlB3xp0wzCPASzteId4wdUZYpzWiw6Jp4IFoIs6ADjLREEk1-IYH8KRGdwFZJrPlIebwytHBYVIidsCwkHhW39aQkh3Vh0OWWMAcLVxYwMTjXwDxHl-CDVDau420OG4iMiTzlsK_RTC_ypo3z-Adf-h0gp2O8j5bOq-2TZd9FD1jPLrkf3759rB-BWDGFskF3AsiB3g\"\n", + "\n", + "mkdir -p $BASE_DIR\n", + "\n", + "wget -c -N -O $BASE_DIR'/Toronto_3D.zip' $url\n", + "\n", + "cd $BASE_DIR\n", + "\n", + "unzip -j Toronto_3D.zip\n", + "\n", + "# cleanup\n", + "mkdir -p $BASE_DIR/zip_files\n", + "mv Toronto_3D.zip $BASE_DIR/zip_files" + ] + }, + { + "cell_type": "markdown", + "id": "610773c7", + "metadata": {}, + "source": [ + "The bash script takes path to output folder as input where dataset must be downloaded." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "775f199e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: timestamping does nothing in combination with -O. See the manual\n", + "for details.\n", + "\n", + "--2022-06-14 22:46:55-- https://xx9lca.sn.files.1drv.com/y4mUm9-LiY3vULTW79zlB3xp0wzCPASzteId4wdUZYpzWiw6Jp4IFoIs6ADjLREEk1-IYH8KRGdwFZJrPlIebwytHBYVIidsCwkHhW39aQkh3Vh0OWWMAcLVxYwMTjXwDxHl-CDVDau420OG4iMiTzlsK_RTC_ypo3z-Adf-h0gp2O8j5bOq-2TZd9FD1jPLrkf3759rB-BWDGFskF3AsiB3g\n", + "Resolving xx9lca.sn.files.1drv.com (xx9lca.sn.files.1drv.com)... 13.107.42.12\n", + "Connecting to xx9lca.sn.files.1drv.com (xx9lca.sn.files.1drv.com)|13.107.42.12|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 1143871417 (1.1G) [application/zip]\n", + "Saving to: ‘data/toronto3d_dataset/Toronto3D/Toronto_3D.zip’\n", + "\n", + "data/toronto3d_data 100%[===================>] 1.06G 20.0MB/s in 67s \n", + "\n", + "2022-06-14 22:48:03 (16.2 MB/s) - ‘data/toronto3d_dataset/Toronto3D/Toronto_3D.zip’ saved [1143871417/1143871417]\n", + "\n", + "Archive: Toronto_3D.zip\n", + " inflating: Colors.xml \n", + " inflating: L001.ply \n", + " inflating: L002.ply \n", + " inflating: L003.ply \n", + " inflating: L004.ply \n", + " inflating: Mavericks_classes_9.txt \n" + ] + } + ], + "source": [ + "!bash data/download_toronto3d.sh data/toronto3d_dataset" + ] + }, + { + "cell_type": "markdown", + "id": "78cd2f4b", + "metadata": {}, + "source": [ + "You may see downloaded point cloud files as shown below:\n", + "\n", + "```\n", + "/data/toronto3d\n", + "└── Toronto3D\n", + " ├── Colors.xml\n", + " ├── L001.ply\n", + " ├── L002.ply\n", + " ├── L003.ply\n", + " ├── L004.ply\n", + " ├── Mavericks_classes_9.txt\n", + " └── zip_files\n", + " └── Toronto_3D.zip\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "c1ec1929", + "metadata": {}, + "source": [ + "## Limiting memory usage (Tesorflow Users)\n", + "\n", + "TensorFlow maps nearly all of GPU memory by default. This may result in out_of_memory error if some of the ops allocate memory independent to tensorflow. You may want to limit memory usage as and when needed by the process. Use following code right after importing tensorflow:\n", + "\n", + "```python\n", + "import tensorflow as tf\n", + "gpus = tf.config.experimental.list_physical_devices('GPU')\n", + "if gpus:\n", + " try:\n", + " for gpu in gpus:\n", + " tf.config.experimental.set_memory_growth(gpu, True)\n", + " except RuntimeError as e:\n", + " print(e)\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "4b955f11", + "metadata": {}, + "source": [ + "## Building componets for training\n", + "\n", + "First, let us do some basic imports. Import statements are depend on what framework you are using - Pytorch or Tensorflow." + ] + }, + { + "cell_type": "markdown", + "id": "a4dfca8e", + "metadata": {}, + "source": [ + "Tesorflow users may run:\n", + "\n", + "```py\n", + "import open3d.ml.tf as ml3d\n", + "from open3d.ml.tf.models import RandLANet\n", + "from open3d.ml.tf.pipelines import SemanticSegmentation\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "720bd6ab", + "metadata": {}, + "source": [ + "Pytorch users may run:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8bcaac2a", + "metadata": {}, + "outputs": [], + "source": [ + "import open3d.ml.torch as ml3d\n", + "from open3d.ml.torch.models import RandLANet\n", + "from open3d.ml.torch.pipelines import SemanticSegmentation" + ] + }, + { + "cell_type": "markdown", + "id": "a2861200", + "metadata": {}, + "source": [ + "The goal was to create `ml3d`, `RandLANet` and `SemanticSegmentation` based on either PyTorch or Tensorflow framework." + ] + }, + { + "cell_type": "markdown", + "id": "9b941e6d", + "metadata": {}, + "source": [ + "Let us now define a config file with `dataset`, `model` and `pipeline`. Just add dataset path to the config file present in `Open3D-ML/ml3d/configs/randlanet_toronto3d.yml`" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "e8319720", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overwriting data/randlanet_toronto3d.yml\n" + ] + } + ], + "source": [ + "%%writefile data/randlanet_toronto3d.yml\n", + "dataset:\n", + " name: Toronto3D\n", + " cache_dir: ./logs/cache\n", + " dataset_path: data/toronto3d_dataset/Toronto3D # path/to/your/dataset\n", + " class_weights: [41697357, 1745448, 6572572, 19136493, 674897, 897825, 4634634, 374721]\n", + " ignored_label_inds:\n", + " - 0\n", + " num_classes: 8\n", + " num_points: 65536\n", + " test_files:\n", + " - L002.ply\n", + " test_result_folder: ./test\n", + " train_files:\n", + " - L001.ply\n", + " - L003.ply\n", + " - L004.ply\n", + " use_cache: true\n", + " val_files:\n", + " - L002.ply\n", + " steps_per_epoch_train: 100\n", + " steps_per_epoch_valid: 10\n", + "model:\n", + " name: RandLANet\n", + " batcher: DefaultBatcher\n", + " ckpt_path: # path/to/your/checkpoint\n", + " num_neighbors: 16\n", + " num_layers: 5\n", + " num_points: 65536\n", + " num_classes: 8\n", + " ignored_label_inds: [0]\n", + " sub_sampling_ratio: [4, 4, 4, 4, 2]\n", + " in_channels: 6\n", + " dim_features: 8\n", + " dim_output: [16, 64, 128, 256, 512]\n", + " grid_size: 0.05\n", + " augment:\n", + " recenter:\n", + " dim: [0, 1, 2]\n", + " normalize:\n", + " points:\n", + " method: linear\n", + "pipeline:\n", + " name: SemanticSegmentation\n", + " optimizer:\n", + " lr: 0.001\n", + " batch_size: 2\n", + " main_log_dir: ./logs\n", + " max_epoch: 200\n", + " save_ckpt_freq: 5\n", + " scheduler_gamma: 0.99\n", + " test_batch_size: 1\n", + " train_sum_dir: train_log\n", + " val_batch_size: 2\n", + " summary:\n", + " record_for: []\n", + " max_pts:\n", + " use_reference: false\n", + " max_outputs: 1" + ] + }, + { + "cell_type": "markdown", + "id": "2178391e", + "metadata": {}, + "source": [ + "Load the config file:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "031d8528", + "metadata": {}, + "outputs": [], + "source": [ + "from open3d.ml import utils\n", + "\n", + "cfg_file = \"data/randlanet_toronto3d.yml\"\n", + "cfg = utils.Config.load_from_file(cfg_file)" + ] + }, + { + "cell_type": "markdown", + "id": "3c71ada2", + "metadata": {}, + "source": [ + "Create dataset object from config file:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "beb9aa91", + "metadata": {}, + "outputs": [], + "source": [ + "dataset = ml3d.datasets.Toronto3D(**cfg.dataset)" + ] + }, + { + "cell_type": "markdown", + "id": "b576e86b", + "metadata": {}, + "source": [ + "Create model object from config file: " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "5f3d73b9", + "metadata": {}, + "outputs": [], + "source": [ + "model = RandLANet(**cfg.model)" + ] + }, + { + "cell_type": "markdown", + "id": "17b07e24", + "metadata": {}, + "source": [ + "Create a pipeline object from model, dataset and config file" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "6a965c22", + "metadata": {}, + "outputs": [], + "source": [ + "pipeline = SemanticSegmentation(model=model,\n", + " dataset=dataset,\n", + " **cfg.pipeline)" + ] + }, + { + "cell_type": "markdown", + "id": "352e623d", + "metadata": {}, + "source": [ + "### Training the model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c88c974d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO - 2022-06-14 23:01:41,840 - semantic_segmentation - DEVICE : cpu\n", + "INFO - 2022-06-14 23:01:41,842 - semantic_segmentation - Logging in file : ./logs/RandLANet_Toronto3D_torch/log_train_2022-06-14_23:01:41.txt\n", + "INFO - 2022-06-14 23:01:41,844 - toronto3d - Found 3 pointclouds for train\n", + "preprocess: 0%| | 0/3 [00:00\n", + "**Note:** You may replace `data` dictionary with custom point cloud data. \n", + "" + ] + }, + { + "cell_type": "markdown", + "id": "f99e7a15", + "metadata": {}, + "source": [ + "## Restoring from checkoints" + ] + }, + { + "cell_type": "markdown", + "id": "2e916d4c", + "metadata": {}, + "source": [ + "In the above example, you may notice that we are using latest trained model to make predictions. Latest trained models may not always be the best model so you may want to use model from previous checkpoints instead. \n", + "\n", + "`pipeline` provides `load_ckpt` method to restore model weights from training checkpoints." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f017247", + "metadata": {}, + "outputs": [], + "source": [ + "ckpt_path = \"path/to/trained/model\"\n", + "pipeline.load_ckpt(ckpt_path=ckpt_path)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorial/notebook/reading_a_config_file.ipynb b/docs/tutorial/notebook/reading_a_config_file.ipynb index 7789b0d3..85f21f86 100644 --- a/docs/tutorial/notebook/reading_a_config_file.ipynb +++ b/docs/tutorial/notebook/reading_a_config_file.ipynb @@ -1,290 +1,694 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Controlling training and inference with config files" - ] + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "HuZ6L7hOOn5k" + }, + "source": [ + "# Config Files & How to Use Them 🚀🌍💫\n", + "\n", + "Look at the code snippet below:\n", + "\n", + "```py\n", + "# Read a dataset by specifying the path. We can pass other arguments like cache directory and training split.\n", + "\n", + "dataset = ml3d.datasets.SemanticKITTI(dataset_path='SemanticKITTI/',\n", + " cache_dir='./logs/cache',\n", + " training_split=['00'],\n", + " validation_split=['01'],\n", + " test_split=['01'])\n", + "```\n", + "\n", + "The `dataset` object is created by explicitly passing dataset-specific parameters to the constructor of `ml3d.datasets.SemanticKITTI` class. Instead of passing these parameters one after another manually, we may use config files to automate our processes. Each config file in Open3D-ML contains parameters (i.e key-value pairs) for `dataset`, `model` and `pipeline` in general.\n", + "\n", + "\n", + "> 📝 **Note:** We use [YAML format](https://en.wikipedia.org/wiki/YAML) for defining our config files.\n", + "\n", + "\n", + "In this tutorial, we will learn how to:\n", + "\n", + "- Load a config file into `Config` class object.\n", + "- Parse data dictionaries from the loaded `Config` object.\n", + "- Access individual dictionaries in the `Config` object.\n", + "- Access individual elements within the dictionaries." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cUBl1Cr_Ox0X" + }, + "source": [ + "## ⏬ Necessary Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ovckaoW7L8Il" + }, + "outputs": [], + "source": [ + "from pprint import pprint\n", + "from open3d.ml import utils\n", + "import open3d.ml.torch as ml3d" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "X5tjQ_IbO2zv" + }, + "source": [ + "Here, we import two modules from Open3D:\n", + " \n", + " 1. `utils`: Open3D-ML utilities. Used for reading config file in this tutorial.\n", + " 2. `ml3d`: Open3D-ML PyTorch API library. Used for building multiple datasets, models and pipelines." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "l_mUk15iYs1M" + }, + "source": [ + "## 📖 Loading YAML Config File\n", + "\n", + "`cfg_file` contains relative or absolute path of our config file. First, let us have a look at the contents of our config file as a raw text document." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ps9uy8PdMP3n", + "outputId": "398b5617-ce7c-49d2-a0d7-559f6049bd63" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dataset:\n", + " name: SemanticKITTI\n", + " dataset_path: # path/to/your/dataset\n", + " cache_dir: ./logs/cache\n", + " class_weights: [55437630, 320797, 541736, 2578735, 3274484, 552662, 184064,\n", + " 78858, 240942562, 17294618, 170599734, 6369672, 230413074, 101130274,\n", + " 476491114, 9833174, 129609852, 4506626, 1168181]\n", + " test_result_folder: ./test\n", + " test_split: ['11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21']\n", + " training_split: ['00', '01', '02', '03', '04', '05', '06', '07', '09', '10']\n", + " all_split: ['00', '01', '02', '03', '04', '05', '06', '07', '09',\n", + " '08', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21']\n", + " validation_split: ['08']\n", + " use_cache: true\n", + " sampler:\n", + " name: 'SemSegRandomSampler'\n", + "model:\n", + " name: RandLANet\n", + " batcher: DefaultBatcher\n", + " ckpt_path: # path/to/your/checkpoint\n", + " num_neighbors: 16\n", + " num_layers: 4\n", + " num_points: 45056\n", + " num_classes: 19\n", + " ignored_label_inds: [0]\n", + " sub_sampling_ratio: [4, 4, 4, 4]\n", + " in_channels: 3\n", + " dim_features: 8\n", + " dim_output: [16, 64, 128, 256]\n", + " grid_size: 0.06\n", + " augment:\n", + " recenter:\n", + " dim: [0, 1]\n", + "pipeline:\n", + " name: SemanticSegmentation\n", + " optimizer:\n", + " lr: 0.001\n", + " batch_size: 4\n", + " main_log_dir: ./logs\n", + " max_epoch: 100\n", + " save_ckpt_freq: 5\n", + " scheduler_gamma: 0.9886\n", + " test_batch_size: 1\n", + " train_sum_dir: train_log\n", + " val_batch_size: 2\n", + " summary:\n", + " record_for: []\n", + " max_pts:\n", + " use_reference: false\n", + " max_outputs: 1\n" + ] + } + ], + "source": [ + "cfg_file = \"../../../ml3d/configs/randlanet_semantickitti.yml\"\n", + "!cat {cfg_file}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hKMexYybYkP-" + }, + "source": [ + "Here, we can see that the file is divided into three different parts - `dataset`, `model` and `pipeline`.\n", + "\n", + "Let us load the config file as `Config` class object. This can be done with the help of `utils.Config.load_from_file` which takes path of config file as input." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "5D_L3_83QOKn" + }, + "outputs": [], + "source": [ + "cfg = utils.Config.load_from_file(cfg_file)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MuX4CWK2bDSx" + }, + "source": [ + "## 🩺 Examining Dataset Dictionaries\n", + "\n", + "Let us try to access the contents of `cfg` object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "CQ0-UwSDnjE9" + }, + "outputs": [], + "source": [ + "pprint(vars(cfg))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zh2lMW9-a9uA", + "outputId": "96bf255e-6f32-4176-80a9-19c8bd35c91e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['dataset', 'model', 'pipeline'])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg.keys()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LFLfMDWZgAiF" + }, + "source": [ + "`cfg` has three dictionaries - `dataset`, `model` and `pipeline` (like we saw in the raw YAML file).\n", + "\n", + "Let us explore them.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FxF0zIk_gENP" + }, + "source": [ + "### 🔎 Accessing Individual Dictionaries" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jcXRnojldAg4" + }, + "source": [ + "The first one is `cfg.dataset` dictionary:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4RJAlyYXdFNE" + }, + "outputs": [], + "source": [ + "pprint(cfg.dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m6BwrYfefhXB" + }, + "source": [ + "Similary, let us access `model` and `pipeline` dictionaries:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8kS7MiWXe5WJ", + "outputId": "6f2fc220-f915-43eb-fe25-bf0d7e61af16" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'augment': {'recenter': {'dim': [0, 1]}},\n", + " 'batcher': 'DefaultBatcher',\n", + " 'ckpt_path': None,\n", + " 'dim_features': 8,\n", + " 'dim_output': [16, 64, 128, 256],\n", + " 'grid_size': 0.06,\n", + " 'ignored_label_inds': [0],\n", + " 'in_channels': 3,\n", + " 'name': 'RandLANet',\n", + " 'num_classes': 19,\n", + " 'num_layers': 4,\n", + " 'num_neighbors': 16,\n", + " 'num_points': 45056,\n", + " 'sub_sampling_ratio': [4, 4, 4, 4]}\n" + ] + } + ], + "source": [ + "pprint(cfg.model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "c5gA4AAbfz6T", + "outputId": "e8430591-3914-4e1f-f268-291aff5fa00b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'batch_size': 4,\n", + " 'main_log_dir': './logs',\n", + " 'max_epoch': 100,\n", + " 'name': 'SemanticSegmentation',\n", + " 'optimizer': {'lr': 0.001},\n", + " 'save_ckpt_freq': 5,\n", + " 'scheduler_gamma': 0.9886,\n", + " 'summary': {'max_outputs': 1,\n", + " 'max_pts': None,\n", + " 'record_for': [],\n", + " 'use_reference': False},\n", + " 'test_batch_size': 1,\n", + " 'train_sum_dir': 'train_log',\n", + " 'val_batch_size': 2}\n" + ] + } + ], + "source": [ + "pprint(cfg.pipeline)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0nsPOf9HhwEX" + }, + "source": [ + "### 🔭 Accessing Individual Elements within The Dictionaries\n", + "\n", + "> 📝 **Note:** The dictionary items within `Config` class object can be viewed & updated just like a standard Python dictionary. It is mutable.\n", + "\n", + "List all the keys available inside `dataset` dictionary (just like the built-in `dict` data type) using:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "m4uYJwpNf2NI", + "outputId": "d22bdd79-987a-4ad3-ca92-2221e24964be" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['name', 'dataset_path', 'cache_dir', 'class_weights', 'test_result_folder', 'test_split', 'training_split', 'all_split', 'validation_split', 'use_cache', 'sampler'])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg.dataset.keys()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HVSQdzSVkCvj" + }, + "source": [ + "We may access any of the available keys and even update their values as shown below:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "3b5kKjXqi49F", + "outputId": "d8c9805f-2c28-47f4-a790-4fcb5d93df08" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'./logs/cache'" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cfg.dataset['cache_dir'] # Access individual element" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "MzWyZOCzkcYm", + "outputId": "dfc5ac13-d665-4362-8327-19a936e54968" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'./logs/new_cache'" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Update individual element\n", + "cfg.dataset['cache_dir'] = './logs/new_cache'\n", + "cfg.dataset['cache_dir']" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_Tg6uATMlS2_" + }, + "source": [ + "We may do the same for any of the individual elements of `cfg.model` and `cfg.pipeline`. Try it yourselves!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "K3nfhHYOlMPT" + }, + "source": [ + "## 🏗️ Initializing Dataset From a Config File\n", + "\n", + "We saw how to load, probe and mutate config files in the above examples. \n", + "\n", + "Let us now explicitly create a `dataset` object which will hold all the information from the `cfg.dataset` dictionary\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "h6F0X4qUktSw" + }, + "outputs": [], + "source": [ + "dataset = ml3d.datasets.SemanticKITTI(cfg.dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kGS_BcrVoCly" + }, + "source": [ + "Properties exposed by the newly-created `dataset` can be accessed using the `vars` built-in function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ouh81Bl9nJ7n", + "outputId": "68a4379c-5e0c-45ab-aaf9-4338e91313b7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'cfg': ,\n", + " 'label_to_names': {0: 'unlabeled',\n", + " 1: 'car',\n", + " 2: 'bicycle',\n", + " 3: 'motorcycle',\n", + " 4: 'truck',\n", + " 5: 'other-vehicle',\n", + " 6: 'person',\n", + " 7: 'bicyclist',\n", + " 8: 'motorcyclist',\n", + " 9: 'road',\n", + " 10: 'parking',\n", + " 11: 'sidewalk',\n", + " 12: 'other-ground',\n", + " 13: 'building',\n", + " 14: 'fence',\n", + " 15: 'vegetation',\n", + " 16: 'trunk',\n", + " 17: 'terrain',\n", + " 18: 'pole',\n", + " 19: 'traffic-sign'},\n", + " 'name': 'SemanticKITTI',\n", + " 'num_classes': 20,\n", + " 'remap_lut': array([ 0, 10, 11, 15, 18, 20, 30, 31, 32, 40, 44, 48, 49, 50, 51, 70, 71,\n", + " 72, 80, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " dtype=int32),\n", + " 'remap_lut_val': array([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 5, 0, 3, 5,\n", + " 0, 4, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 0,\n", + " 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 10, 0, 0, 0, 11, 12, 13,\n", + " 14, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 15, 16, 17, 0, 0, 0, 0, 0, 0, 0, 18, 19, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 7, 6,\n", + " 8, 5, 5, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0], dtype=int32),\n", + " 'rng': Generator(PCG64) at 0x7F588A480410}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vars(dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qJnfIBMSozmI" + }, + "source": [ + "We may reference any `dataset` object property using `{object_name}.{property_name}` syntax. For example, `num_classes` property can be accessed using:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nNAPTS1KnM51", + "outputId": "d996d144-29b4-4949-acae-3e64619a34e9" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "20" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset.num_classes" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dFRA2m3XpUK_" + }, + "source": [ + "Likewise, to extract information from `label_to_names` property (which maps class label IDs to the class label names), we can call:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "G23BdpxopT1o", + "outputId": "4c4baae6-3f11-47a0-fe71-1dc5f7586f42" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 'unlabeled',\n", + " 1: 'car',\n", + " 2: 'bicycle',\n", + " 3: 'motorcycle',\n", + " 4: 'truck',\n", + " 5: 'other-vehicle',\n", + " 6: 'person',\n", + " 7: 'bicyclist',\n", + " 8: 'motorcyclist',\n", + " 9: 'road',\n", + " 10: 'parking',\n", + " 11: 'sidewalk',\n", + " 12: 'other-ground',\n", + " 13: 'building',\n", + " 14: 'fence',\n", + " 15: 'vegetation',\n", + " 16: 'trunk',\n", + " 17: 'terrain',\n", + " 18: 'pole',\n", + " 19: 'traffic-sign'}" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset.label_to_names" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mgH74x-4p7Yw" + }, + "source": [ + "Experiment with other `dataset` properties to see how convenient it is to reference them!" + ] + } + ], + "metadata": { + "colab": { + "authorship_tag": "ABX9TyMuXl08rXCzSMbxSTsTLHiQ", + "collapsed_sections": [], + "include_colab_link": true, + "name": "reading_a_config_file.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Look at the following snippet of code which creates a dataset:\n", - "\n", - "```py\n", - "# Read a dataset by specifying the path. We can pass other arguments like cache directory and training split.\n", - "\n", - "dataset = ml3d.datasets.SemanticKITTI(dataset_path='SemanticKITTI/',\n", - " cache_dir='./logs/cache',\n", - " training_split=['00'],\n", - " validation_split=['01'],\n", - " test_split=['01'])\n", - "```\n", - "\n", - "In the code above, the `dataset` object is created by explicitly passing dataset-specific parameters into `ml3d.datasets.SemanticKITTI()` method.\n", - "\n", - "Instead of passing a bunch of parameters to a function call, we can supply `dataset` information from a specific *config* file. Each *config* file contains parameters for a dataset, model and pipeline.\n", - "\n", - "\n", - ">***Config* files pass information into Open3D-ML in YAML format.**\n", - "\n", - "\n", - "In this example, we will:\n", - "\n", - "- Load a *config* `cfg_file` into a `Config` class object;\n", - "- Parse `dataset` dictionaries from the `Config` object;\n", - "- Access individual dictionaries in the `Config` object;\n", - "- Access individual elements from within dictionaries.\n", - "\n", - "\n", - "## Loading a *config* file" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from open3d.ml import utils\n", - "import open3d.ml.torch as ml3d" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here, we import two modules:\n", - " \n", - " 1. `utils` - Open3D-ML utilities\n", - " 2. `ml3d` - Open3D-ML PyTorch API library\n", - "\n", - "Now, we'll create *config* object:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cfg_file = \"../../../ml3d/configs/randlanet_semantickitti.yml\"\n", - "cfg = utils.Config.load_from_file(cfg_file)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `cfg_file` holds the full path to the particular *config* file - `randlanet_semantickitti.yml`.\n", - "The `cfg` object is initialized by the Open3D-ML `utils.Config.load_from_file()` method to hold parameters that are read from the `cfg_file`.\n", - "\n", - "## Examining dataset dictionaries in the `cfg` object\n", - "\n", - "Let's examine the contents of the `cfg` object:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "vars(cfg)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "`vars(cfg)` returns the three dictionaries: `dataset`, `model`, and `pipeline`.\n", - "\n", - "Now, let's explore them. The first one is the `cfg.dataset`:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cfg.dataset" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Accessing individual dictionary items\n", - "\n", - "These `cfg` dictionary items can be viewed as well as updated like in a standard Python dictionary. We can access individual items of the `cfg.dataset` dictionary like so: " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cfg.dataset['name']" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## `cfg.model` and `cfg.pipeline` dictionaries\n", - "\n", - "We'll later revisit the `cfg.dataset`. Next, let's look at the `cfg.model` dictionary:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "cfg.model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Just as in the case of `cfg.dataset`, we can access `cfg.model` dictionary items by referencing them individually:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cfg.model['sub_sampling_ratio']" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cfg.pipeline" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Likewise, individual dictionary items in `cfg.pipeline` can be accesed just like those of `cfg.model` and `cfg.dataset`:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cfg.pipeline['name']" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Initializing datasets from *config* files\n", - "\n", - "Next, we explicitly create the `dataset` object which will hold all information from the `cfg.dataset` dictionary:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "dataset = ml3d.datasets.SemanticKITTI(cfg.dataset)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, we'll look at what properties the newly-created `dataset` object exposes with the Python `vars()` function:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "vars(dataset)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can reference any property of the dataset by using *`object.property`* syntax. For example, to find out what value the `num_classes` property holds, we type in:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "dataset.num_classes" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Likewise, to extract information from a `label_to_names` property which maps labels to the object names, we call:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "dataset.label_to_names" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Experiment with other `dataset` properties to see how convenient it is to reference them." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 0 }