From 01e7cfcee80fd43d287a906f6af71fcb22edc576 Mon Sep 17 00:00:00 2001 From: Javier Date: Sun, 18 Aug 2024 19:34:47 +0200 Subject: [PATCH 01/14] removed support for FDS (feature distribution smoothing) and LDS (label distribution smoothing) --- docs/examples.rst | 1 - examples/notebooks/15_DIR-LDS_and_FDS.ipynb | 847 -- ...> 15_Self_Supervised_Pretraning_pt1.ipynb} | 0 ...> 15_Self_Supervised_Pretraning_pt2.ipynb} | 0 ...6_Usign_a_custom_hugging_face_model.ipynb} | 0 ...re_importance_via_attention_weights.ipynb} | 0 ... => 18_wide_and_deep_for_recsys_pt1.ipynb} | 0 ... => 18_wide_and_deep_for_recsys_pt2.ipynb} | 0 ...> 19_load_from_folder_functionality.ipynb} | 0 ...0_Using_huggingface_within_widedeep.ipynb} | 0 .../scripts/california_housing_fds_lds.py | 53 - mkdocs/mkdocs.yml | 17 +- mkdocs/site/404.html | 69 +- mkdocs/site/assets/_mkdocstrings.css | 12 +- mkdocs/site/contributing.html | 71 +- mkdocs/site/index.html | 72 +- mkdocs/site/installation.html | 69 +- mkdocs/site/objects.inv | Bin 1967 -> 1920 bytes .../pytorch-widedeep/bayesian_models.html | 629 +- .../pytorch-widedeep/bayesian_trainer.html | 821 +- mkdocs/site/pytorch-widedeep/callbacks.html | 554 +- mkdocs/site/pytorch-widedeep/dataloaders.html | 210 +- mkdocs/site/pytorch-widedeep/losses.html | 3659 +++-- mkdocs/site/pytorch-widedeep/metrics.html | 498 +- .../pytorch-widedeep/model_components.html | 11090 ++++++++-------- .../site/pytorch-widedeep/model_components.md | 6 - .../site/pytorch-widedeep/preprocessing.html | 3793 +++--- .../self_supervised_pretraining.html | 1147 +- mkdocs/site/pytorch-widedeep/tab2vec.html | 357 +- mkdocs/site/pytorch-widedeep/trainer.html | 1808 ++- .../utils/deeptabular_utils.html | 555 +- .../utils/fastai_transforms.html | 655 +- .../pytorch-widedeep/utils/image_utils.html | 348 +- mkdocs/site/pytorch-widedeep/utils/index.html | 69 +- .../pytorch-widedeep/utils/text_utils.html | 628 +- mkdocs/site/quick_start.html | 69 +- mkdocs/site/search/search_index.json | 2 +- mkdocs/site/sitemap.xml | 107 +- mkdocs/site/sitemap.xml.gz | Bin 825 -> 810 bytes .../sources/examples/15_DIR-LDS_and_FDS.ipynb | 847 -- ...> 15_Self_Supervised_Pretraning_pt1.ipynb} | 0 ...> 15_Self_Supervised_Pretraning_pt2.ipynb} | 0 ...6_Usign_a_custom_hugging_face_model.ipynb} | 0 ...re_importance_via_attention_weights.ipynb} | 0 ... => 18_wide_and_deep_for_recsys_pt1.ipynb} | 0 ... => 18_wide_and_deep_for_recsys_pt2.ipynb} | 0 ...> 19_load_from_folder_functionality.ipynb} | 0 ...0_Using_huggingface_within_widedeep.ipynb} | 0 .../pytorch-widedeep/model_components.md | 6 - pytorch_widedeep/dataloaders.py | 11 - pytorch_widedeep/losses.py | 131 +- pytorch_widedeep/models/fds_layer.py | 278 - pytorch_widedeep/models/wide_deep.py | 105 +- pytorch_widedeep/training/_base_trainer.py | 17 - .../training/_feature_importance.py | 2 +- pytorch_widedeep/training/_trainer_utils.py | 11 +- pytorch_widedeep/training/_wd_dataset.py | 103 +- pytorch_widedeep/training/trainer.py | 124 +- pytorch_widedeep/utils/deeptabular_utils.py | 101 +- tests/test_data_utils/test_du_tabular.py | 38 +- tests/test_losses/test_losses.py | 27 - .../test_model_components/test_mc_tab_mlp.py | 35 +- .../test_miscellaneous.py | 36 - 63 files changed, 12655 insertions(+), 17433 deletions(-) delete mode 100644 examples/notebooks/15_DIR-LDS_and_FDS.ipynb rename examples/notebooks/{16_Self_Supervised_Pretraning_pt1.ipynb => 15_Self_Supervised_Pretraning_pt1.ipynb} (100%) rename examples/notebooks/{16_Self_Supervised_Pretraning_pt2.ipynb => 15_Self_Supervised_Pretraning_pt2.ipynb} (100%) rename examples/notebooks/{17_Usign_a_custom_hugging_face_model.ipynb => 16_Usign_a_custom_hugging_face_model.ipynb} (100%) rename examples/notebooks/{18_feature_importance_via_attention_weights.ipynb => 17_feature_importance_via_attention_weights.ipynb} (100%) rename examples/notebooks/{19_wide_and_deep_for_recsys_pt1.ipynb => 18_wide_and_deep_for_recsys_pt1.ipynb} (100%) rename examples/notebooks/{19_wide_and_deep_for_recsys_pt2.ipynb => 18_wide_and_deep_for_recsys_pt2.ipynb} (100%) rename examples/notebooks/{20_load_from_folder_functionality.ipynb => 19_load_from_folder_functionality.ipynb} (100%) rename examples/notebooks/{21_Using_huggingface_within_widedeep.ipynb => 20_Using_huggingface_within_widedeep.ipynb} (100%) delete mode 100644 examples/scripts/california_housing_fds_lds.py delete mode 100644 mkdocs/sources/examples/15_DIR-LDS_and_FDS.ipynb rename mkdocs/sources/examples/{16_Self_Supervised_Pretraning_pt1.ipynb => 15_Self_Supervised_Pretraning_pt1.ipynb} (100%) rename mkdocs/sources/examples/{16_Self_Supervised_Pretraning_pt2.ipynb => 15_Self_Supervised_Pretraning_pt2.ipynb} (100%) rename mkdocs/sources/examples/{17_Usign_a_custom_hugging_face_model.ipynb => 16_Usign_a_custom_hugging_face_model.ipynb} (100%) rename mkdocs/sources/examples/{18_feature_importance_via_attention_weights.ipynb => 17_feature_importance_via_attention_weights.ipynb} (100%) rename mkdocs/sources/examples/{19_wide_and_deep_for_recsys_pt1.ipynb => 18_wide_and_deep_for_recsys_pt1.ipynb} (100%) rename mkdocs/sources/examples/{19_wide_and_deep_for_recsys_pt2.ipynb => 18_wide_and_deep_for_recsys_pt2.ipynb} (100%) rename mkdocs/sources/examples/{20_load_from_folder_functionality.ipynb => 19_load_from_folder_functionality.ipynb} (100%) rename mkdocs/sources/examples/{21_Using_huggingface_within_widedeep.ipynb => 20_Using_huggingface_within_widedeep.ipynb} (100%) delete mode 100644 pytorch_widedeep/models/fds_layer.py diff --git a/docs/examples.rst b/docs/examples.rst index b78fd394..489560fa 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -17,5 +17,4 @@ them to address different problems * `HyperParameter Tuning With RayTune `__ * `Model Uncertainty Prediction `__ * `Bayesian Models `__ -* `Deep Imbalanced Regression `__ diff --git a/examples/notebooks/15_DIR-LDS_and_FDS.ipynb b/examples/notebooks/15_DIR-LDS_and_FDS.ipynb deleted file mode 100644 index 09770d99..00000000 --- a/examples/notebooks/15_DIR-LDS_and_FDS.ipynb +++ /dev/null @@ -1,847 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "01a4f48f", - "metadata": {}, - "source": [ - "# Label and Feature Distribution Smoothing for Deep Imbalanced Regression " - ] - }, - { - "cell_type": "markdown", - "id": "92c81bca", - "metadata": {}, - "source": [ - "## Initial imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2e7b9854", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import torch\n", - "from torch.optim import SGD, lr_scheduler\n", - "\n", - "from pytorch_widedeep import Trainer\n", - "from pytorch_widedeep.preprocessing import TabPreprocessor\n", - "from pytorch_widedeep.models import TabMlp, WideDeep\n", - "from sklearn.metrics import mean_squared_error\n", - "from pytorch_widedeep.initializers import XavierNormal\n", - "from pytorch_widedeep.datasets import load_california_housing\n", - "\n", - "from sklearn.model_selection import train_test_split\n", - "\n", - "import matplotlib.pyplot as plt\n", - "from scipy.ndimage import convolve1d\n", - "from scipy.ndimage import gaussian_filter1d\n", - "from scipy.signal.windows import triang\n", - "from pytorch_widedeep.utils.deeptabular_utils import get_kernel_window, find_bin\n", - "from pytorch_widedeep.models import fds_layer\n", - "\n", - "# increase displayed columns in jupyter notebook\n", - "pd.set_option(\"display.max_columns\", 200)\n", - "pd.set_option(\"display.max_rows\", 300)" - ] - }, - { - "cell_type": "markdown", - "id": "3c0fc233", - "metadata": {}, - "source": [ - "# Load dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "934cca51", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
MedIncHouseAgeAveRoomsAveBedrmsPopulationAveOccupLatitudeLongitudeMedHouseVal
08.325241.06.9841271.023810322.02.55555637.88-122.234.526
18.301421.06.2381370.9718802401.02.10984237.86-122.223.585
27.257452.08.2881361.073446496.02.80226037.85-122.243.521
35.643152.05.8173521.073059558.02.54794537.85-122.253.413
43.846252.06.2818531.081081565.02.18146737.85-122.253.422
\n", - "
" - ], - "text/plain": [ - " MedInc HouseAge AveRooms AveBedrms Population AveOccup Latitude \\\n", - "0 8.3252 41.0 6.984127 1.023810 322.0 2.555556 37.88 \n", - "1 8.3014 21.0 6.238137 0.971880 2401.0 2.109842 37.86 \n", - "2 7.2574 52.0 8.288136 1.073446 496.0 2.802260 37.85 \n", - "3 5.6431 52.0 5.817352 1.073059 558.0 2.547945 37.85 \n", - "4 3.8462 52.0 6.281853 1.081081 565.0 2.181467 37.85 \n", - "\n", - " Longitude MedHouseVal \n", - "0 -122.23 4.526 \n", - "1 -122.22 3.585 \n", - "2 -122.24 3.521 \n", - "3 -122.25 3.413 \n", - "4 -122.25 3.422 " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = load_california_housing(as_frame=True)\n", - "df.head()" - ] - }, - { - "cell_type": "markdown", - "id": "753c111d", - "metadata": {}, - "source": [ - "# Effects of ks and sigma paramaters on kernel function" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "38837284", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ks = 5\n", - "sigma = 2\n", - "half_ks = (ks - 1) // 2\n", - "base_kernel = [0.0] * half_ks + [1.0] + [0.0] * half_ks\n", - "kernel_window = gaussian_filter1d(base_kernel, sigma=sigma)\n", - "plt.plot(kernel_window)" - ] - }, - { - "cell_type": "markdown", - "id": "8e6444b1", - "metadata": {}, - "source": [ - "# Label Distribution Smoothing - visualization\n", - "* visualization of pytorch_widedeep.training._wd_dataset.WideDeepDataset._prepare_weights(...)\n", - "\n", - "**Assign weight to each sample by following procedure:**\n", - "1. creating histogram from label values with nuber of bins = granularity\n", - "2.[OPTIONAL] reweighting label frequencies by sqrt\n", - "3.[OPTIONAL] smoothing label frequencies by convolution of kernel function window with frequencies list\n", - "4. inverting values by n_samples / (n_classes * np.bincount(y)), [see](https://scikit-learn.org/stable/modules/generated/sklearn.utils.class_weight.compute_sample_weight.html)\n", - "5. assigning weight to each sample from closest bin value " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "45de4c6b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "lds = True\n", - "kernel = \"gaussian\"\n", - "ks = 5\n", - "sigma = 2\n", - "reweight = \"sqrt\"\n", - "Y = df[\"MedHouseVal\"].values\n", - "lds_y_max = None\n", - "lds_y_min = None\n", - "granularity = 100\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1)\n", - "\n", - "y_max = max(Y) if lds_y_max is None else lds_y_max\n", - "y_min = min(Y) if lds_y_min is None else lds_y_min\n", - "bin_edges = np.linspace(y_min, y_max, num=granularity, endpoint=True)\n", - "value_dict = dict(zip(bin_edges[:-1], np.histogram(Y, bin_edges)[0]))\n", - "\n", - "ax1.set_title(\"Histogram of values in the Y\")\n", - "ax1.bar(\n", - " value_dict.keys(),\n", - " value_dict.values(),\n", - " width=list(value_dict.keys())[1] - list(value_dict.keys())[0],\n", - ")\n", - "\n", - "if reweight:\n", - " value_dict = dict(zip(value_dict.keys(), np.sqrt(list(value_dict.values()))))\n", - "\n", - "if kernel is not None:\n", - " lds_kernel_window = get_kernel_window(kernel, ks, sigma)\n", - " smoothed_values = convolve1d(\n", - " list(value_dict.values()), weights=lds_kernel_window, mode=\"constant\"\n", - " )\n", - " weigths = sum(smoothed_values) / (len(smoothed_values) * smoothed_values)\n", - "else:\n", - " values = list(value_dict.values())\n", - " weigths = sum(values) / (len(values) * values) # type: ignore[operator]\n", - "value_dict = dict(zip(value_dict.keys(), weigths))\n", - "\n", - "left_bin_edges = find_bin(bin_edges, Y)\n", - "weights = np.array([value_dict[edge] for edge in left_bin_edges], dtype=\"float32\")\n", - "\n", - "\n", - "ax2.set_title(\"Bar plot with inverse-balanced weights for each bin from histogram\")\n", - "ax2.bar(\n", - " value_dict.keys(),\n", - " value_dict.values(),\n", - " width=list(value_dict.keys())[1] - list(value_dict.keys())[0],\n", - ")\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "id": "b472dec0", - "metadata": {}, - "source": [ - "# Feature Distribution Smoothing\n", - "We use dataset feature values in this example, but during the training process features tensors are the ouput of last layer before FDS layer.\n", - "* labels are np.vstack-ed to reflect normal training scenario" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "36fe33d0", - "metadata": {}, - "outputs": [], - "source": [ - "features = torch.tensor(df.drop(columns=[\"MedHouseVal\"]).values)\n", - "labels = torch.tensor(np.vstack(df[\"MedHouseVal\"].values))\n", - "FDS = fds_layer.FDSLayer(feature_dim=features.size(1))" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "ec0310c7", - "metadata": {}, - "outputs": [], - "source": [ - "for epoch in range(3):\n", - " FDS.update_last_epoch_stats(epoch)\n", - " FDS.update_running_stats(torch.clone(features).detach(), labels, epoch)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "802278aa", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pd.DataFrame(FDS.running_mean_last_epoch.numpy()).iloc[:, 7].plot(\n", - " title=\"Running mean bina values for 'Longitude' feature\"\n", - ");" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "24a898df", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkEAAAGzCAYAAAAotsMiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACJcElEQVR4nO3dd3xT5f4H8M9J2iSd6R60pRMou6WsMgQEAQUFB4oXlSFw8YJ7XFAvyFVEREQFEdcFRH8KKG7Zy0FlFyjQQqF075Hupk2e3x/JOW1ouiDJSZrv+/XK69WenJzz5LRJvnme7/N9OMYYAyGEEEKInZGI3QBCCCGEEDFQEEQIIYQQu0RBECGEEELsEgVBhBBCCLFLFAQRQgghxC5REEQIIYQQu0RBECGEEELsEgVBhBBCCLFLFAQRQgghxC5REERExXEcFi1aZPbzHD58GBzH4fDhw2Y/lzW5fv06OI7DO++80+a+r732GjiOs0CrzI/jOLz22mtiN6NFW7duRXR0NBwdHeHh4SF2c6zO6NGjMXr0aIucy1LvDbt370ZMTAwUCgU4jkNZWZlZz0fah4IgG3L+/Hk88MADCA0NhUKhQFBQEO644w6sW7dO7Ka16ujRo3jttdfoRU8IgOTkZMyaNQuRkZH49NNP8cknn5j1fK+99hrCwsIMtoWFhWHy5MlmPa8p5eTk4LXXXkNiYqLYTTGwefPmdn1xKC4uxoMPPggnJyd8+OGH2Lp1K1xcXEzenosXL+K1117D9evXTX7szspB7AaQ9jl69CjGjBmDrl27Yt68eQgICEBmZib+/vtvvP/++3jyySfFbmKLjh49iuXLl2PWrFn0rdeKvfrqq1i8eLHYzej0Dh8+DK1Wi/fffx9RUVFiN8cq7d271+D3nJwcLF++HGFhYYiJiRGnUbfgxIkTqKiowOuvv45x48aZ7TwXL17E8uXLMXr06GaBLzGOgiAbsWLFCiiVSpw4caJZIFFQUCBOo0in4uDgAAcHekswN/71asovBNXV1XB2djbZ8cQmk8nEboJJmeNvbklVVVVm6bmyBjQcZiOuXr2K3r17G30R+fn5GfzO59ns2LEDvXr1gpOTE+Lj43H+/HkAwMcff4yoqCgoFAqMHj3aaNfpjh07EBcXBycnJ/j4+OCRRx5BdnZ2s/0OHjyIkSNHwsXFBR4eHpgyZQouXbok3P/aa6/hxRdfBACEh4eD4zhwHNfsnD/88AP69OkDuVyO3r17Y/fu3c3OlZ2djTlz5sDf31/Y73//+1+z/bKysjB16lS4uLjAz88Pzz77LOrq6prtZwyfF3P58mU88sgjUCqV8PX1xX/+8x8wxpCZmYkpU6bA3d0dAQEBWLNmTbNj1NXVYdmyZYiKioJcLkdISAheeumlZm3YtGkTbr/9dvj5+UEul6NXr1746KOPmh2PH7r4888/MXjwYCgUCkREROCLL75o13PirV27FqGhoXBycsKoUaOQlJRk9Lk3xf8vtfX3SU9Px7/+9S/06NEDTk5O8Pb2xrRp09rslq+vr4eXlxdmz57d7L7y8nIoFAq88MILAAC1Wo2lS5ciLi4OSqUSLi4uGDlyJA4dOtTmc581a5bRb8Yt5UF9+eWXwv+/l5cXpk+fjszMTIN9rly5gvvvvx8BAQFQKBQIDg7G9OnToVKpWmxHWFgYli1bBgDw9fVtlru0YcMG9O7dG3K5HF26dMHChQubDSOPHj0affr0walTp3DbbbfB2dkZL7/8cpvXoKMaGhrw+uuvIzIyEnK5HGFhYXj55Zeb/R935P/z3LlzGDVqFJycnBAcHIw33ngDmzZtavae0DQn6PDhwxg0aBAAYPbs2cJ7yObNm4Xzz5o1q9m5jOUVdeS94dixY5g4cSKUSiWcnZ0xatQo/PXXX+27eDe0Y+bMmQCAQYMGgeM4g/a25zzteX1t3rwZ06ZNAwCMGTNGuE58rlNLeXI3Xj9+iO/IkSP417/+BT8/PwQHBwv379q1S3jPd3Nzw6RJk3DhwoUOXxerwYhNGD9+PHNzc2Pnz59vc18ArF+/fiwkJIS99dZb7K233mJKpZJ17dqVrV+/nvXq1YutWbOGvfrqq0wmk7ExY8YYPH7Tpk0MABs0aBBbu3YtW7x4MXNycmJhYWGstLRU2G/fvn3MwcGBde/enb399tts+fLlzMfHh3l6erK0tDTGGGNnz55lDz/8MAPA1q5dy7Zu3cq2bt3KKisrhbb279+fBQYGstdff5299957LCIigjk7O7OioiLhXHl5eSw4OJiFhISw//73v+yjjz5i99xzj3BcXnV1NevevTtTKBTspZdeYu+99x6Li4tj/fr1YwDYoUOHWr12y5YtYwBYTEwMe/jhh9mGDRvYpEmTGAD27rvvsh49erAnnniCbdiwgQ0fPpwBYEeOHBEer9Fo2Pjx45mzszN75pln2Mcff8wWLVrEHBwc2JQpUwzONWjQIDZr1iy2du1atm7dOjZ+/HgGgK1fv95gv9DQUNajRw/m7+/PXn75ZbZ+/Xo2YMAAxnEcS0pKavX5pKWlMQCsb9++LCwsjK1atYotX76ceXl5MV9fX5aXl9fsuTfV3r/Pjh07WP/+/dnSpUvZJ598wl5++WXm6enJQkNDWVVVVattnDNnDvPw8GB1dXUG27ds2cIAsBMnTjDGGCssLGSBgYHsueeeYx999BF7++23WY8ePZijoyM7c+ZMs3YvW7ZM+H3mzJksNDS02bmNPec33niDcRzHHnroIbZhwwbh/7rp/39dXR0LDw9nXbp0YW+88Qb77LPP2PLly9mgQYPY9evXW3yu33//Pbv33nsZAPbRRx+xrVu3srNnzxq0Zdy4cWzdunVs0aJFTCqVskGDBjG1Wi0cY9SoUSwgIID5+vqyJ598kn388cfshx9+aPGcy5Yta/bcQ0ND2aRJk1p8DH/NALAHHniAffjhh+yxxx5jANjUqVObHas9/59ZWVnMy8uLeXt7s+XLl7N33nmHRUdHs/79+zMAwnsG/xxHjRrFGNO99v/73/8yAGz+/PnCe8jVq1eF88+cObNZ+5seg7GOvTccOHCAyWQyFh8fz9asWcPWrl3L+vXrx2QyGTt27JiwH/9e2Zq9e/ey+fPnMwDsv//9L9u6dSs7evRoh87TntfX1atX2VNPPcUAsJdfflm4Tvxr/MbXRNO/X9Prxz+nXr16sVGjRrF169axt956izHG2BdffME4jmMTJ05k69atY6tWrWJhYWHMw8PD4O9nSygIshF79+5lUqmUSaVSFh8fz1566SW2Z88egzdHHgAml8sN/ik//vhjBoAFBASw8vJyYfuSJUsM3oDUajXz8/Njffr0YTU1NcJ+v/zyCwPAli5dKmyLiYlhfn5+rLi4WNh29uxZJpFI2GOPPSZsW716dbM3uaZtlclkLDU11eAYANi6deuEbY8//jgLDAw0+OBljLHp06czpVLJqqurGWOMvffeewwA2759u7BPVVUVi4qK6lAQNH/+fGFbQ0MDCw4OZhzHCW8GjDFWWlrKnJycDN5Atm7dyiQSCfvjjz8Mjrtx40YGgP3111/CNr7NTU2YMIFFREQYbAsNDWUA2O+//y5sKygoYHK5nD3//POtPh8+CHJycmJZWVnC9mPHjjEA7Nlnn2323Jtq79/H2HNJSEhgANgXX3zRahv37NnDALCff/7ZYPtdd91lcC0aGhqaBUqlpaXM39+fzZkzp1m7byYIun79OpNKpWzFihUG+50/f545ODgI28+cOcMAsB07drT63Izhz1lYWChsKygoYDKZjI0fP55pNBph+/r16xkA9r///U/YNmrUKAaAbdy4scPn5rUVBCUmJjIAbO7cuQbbX3jhBQaAHTx40OBY7fn/fPLJJxnHcQYBa3FxMfPy8mo1CGKMsRMnTjAAbNOmTUafS3uCoPa+N2i1WtatWzc2YcIEptVqhX2rq6tZeHg4u+OOO5qdqy18YMEH9B09T3tfXzt27Gjxfa6jQdCIESNYQ0ODsL2iooJ5eHiwefPmGTw+Ly+PKZXKZtttBQ2H2Yg77rgDCQkJuOeee3D27Fm8/fbbmDBhAoKCgvDTTz8123/s2LEG3f9DhgwBANx///1wc3Nrtv3atWsAgJMnT6KgoAD/+te/oFAohP0mTZqE6Oho/PrrrwCA3NxcJCYmYtasWfDy8hL269evH+644w789ttv7X5u48aNQ2RkpMEx3N3dhTYxxvDdd9/h7rvvBmMMRUVFwm3ChAlQqVQ4ffo0AOC3335DYGAgHnjgAeF4zs7OmD9/frvbAwBz584VfpZKpRg4cCAYY3j88ceF7R4eHujRo4fQTkA3jNizZ09ER0cbtPP2228HAIOhGycnJ+FnlUqFoqIijBo1CteuXWs2pNKrVy+MHDlS+N3X17fZuVszdepUBAUFCb8PHjwYQ4YMadffqa2/z43Ppb6+HsXFxYiKioKHh4fwt2nJ7bffDh8fH2zbtk3YVlpain379uGhhx4StkmlUiFXRKvVoqSkBA0NDRg4cGCb52ivnTt3QqvV4sEHHzT4+wUEBKBbt27C30+pVAIA9uzZg+rq6ls+7/79+6FWq/HMM89AIml8W543bx7c3d2F1x1PLpcbHUI0Ff7/4rnnnjPY/vzzzwNAs/a05/9z9+7diI+PN0hs9vLywowZM0zdfKPa+96QmJiIK1eu4B//+AeKi4uF/4GqqiqMHTsWv//+O7Ra7S23pyPnuZXX182aN28epFKp8Pu+fftQVlaGhx9+2OC1IZVKMWTIkHYNS1sjyoK0IYMGDcLOnTuhVqtx9uxZfP/991i7di0eeOABJCYmolevXsK+Xbt2NXgs/6YdEhJidHtpaSkA3dgzAPTo0aPZ+aOjo/Hnn3+2uV/Pnj2xZ8+edifT3dhWAPD09BTaVFhYiLKyMnzyySctTifmEw/T09MRFRXVLM/DWDs70ialUgmFQgEfH59m24uLi4Xfr1y5gkuXLsHX17fVdgLAX3/9hWXLliEhIaHZB6lKpRL+NsbaAxheo7Z069at2bbu3btj+/btbT62PeeuqanBypUrsWnTJmRnZ4MxJtzXWo4MoEvIvv/++/F///d/qKurg1wux86dO1FfX28QBAHAli1bsGbNGiQnJ6O+vl7YHh4e3ubzaI8rV66AMWb0egGAo6OjcL7nnnsO7777Lr766iuMHDkS99xzj5BH1lEtvZ5kMhkiIiKE+3lBQUFmTR5OT0+HRCJpNnstICAAHh4ezdrTnv+R9PR0xMfHN9vPUjPk2vvecOXKFQAQ8niMUalU8PT0vKX2dOQ8t/L6ulk3vqb49vJf6G7k7u5ulnaYGwVBNkgmk2HQoEEYNGgQunfvjtmzZ2PHjh1CwiUAgwi+qZa2N31RWVpbbeK/DT3yyCMtvmH069fP7G1qz7XTarXo27cv3n33XaP78kHo1atXMXbsWERHR+Pdd99FSEgIZDIZfvvtN6xdu7bZN00x/27tOfeTTz6JTZs24ZlnnkF8fDyUSiU4jsP06dPb9a15+vTp+Pjjj7Fr1y5MnToV27dvR3R0NPr37y/s8+WXX2LWrFmYOnUqXnzxRfj5+UEqlWLlypW4evVqq8dvqZaLRqMx+F2r1YLjOOzatcvo83Z1dRV+XrNmDWbNmoUff/wRe/fuxVNPPYWVK1fi77//NkgkNYemPQPm1N7imWL+f7b2t22pXa3h/19Xr17d4nT8pv8HN6sj57nV11drbnwN8G78H+PPs3XrVgQEBDTb31Znltpmq4lg4MCBAHTDU6YQGhoKAEhJSWkW8aekpAj3N93vRsnJyfDx8RF6gW61CrGvry/c3Nyg0WjarLERGhqKpKQkMMYMzmusneYQGRmJs2fPYuzYsa0+759//hl1dXX46aefDL5Fm6tLmf8W19Tly5dNVkvk22+/xcyZMw1my9XW1ra7QOZtt92GwMBAbNu2DSNGjMDBgwfxyiuvNDtHREQEdu7caXBtmwb/LfH09DTalht7NCIjI8EYQ3h4OLp3797mcfv27Yu+ffvi1VdfxdGjRzF8+HBs3LgRb7zxRpuPbarp6ykiIkLYrlarkZaWZtbaMi21R6vV4sqVK+jZs6ewPT8/H2VlZUJ7O3rM1NTUZtuNbbtRa6+l1v62Ta9le98b+KFfd3d3s173jpynva+vjl4ntVrd7s8Ovr1+fn4W/380J8oJshGHDh0y+q2KH7vv6HBPSwYOHAg/Pz9s3LjRYOrorl27cOnSJUyaNAkAEBgYiJiYGGzZssXghZWUlIS9e/firrvuErbxwdDNVoyWSqW4//778d133zWb1g3ohst4d911F3JycvDtt98K26qrq81elZf34IMPIjs7G59++mmz+2pqalBVVQWg8Zvzjd3amzZtMku7fvjhB4MSB8ePH8exY8dw5513muT4Uqm02f/nunXrWvyWeSOJRIIHHngAP//8M7Zu3YqGhoZmQ2HGrtmxY8eQkJDQ5vEjIyOhUqlw7tw5YVtubi6+//57g/3uu+8+SKVSLF++vNnzYYwJQ5/l5eVoaGgwuL9v376QSCTtLsfQ1Lhx4yCTyfDBBx8YnPfzzz+HSqUSXneWwr9+33vvPYPtfA/nzbRnwoQJSEhIMKj6XFJSgq+++qrNx7b2HhIZGYm///4barVa2PbLL780K2nQ3veGuLg4REZG4p133kFlZWWz8zV9v7kVHTlPe19fbV2n33//3WDbJ5980u7X6IQJE+Du7o4333zTYCjaWHttCfUE2Ygnn3wS1dXVuPfeexEdHQ21Wo2jR49i27ZtCAsLM1mSpKOjI1atWoXZs2dj1KhRePjhh5Gfn4/3338fYWFhePbZZ4V9V69ejTvvvBPx8fF4/PHHUVNTg3Xr1kGpVBrUo4iLiwMAvPLKK5g+fTocHR1x9913d6j41ltvvYVDhw5hyJAhmDdvHnr16oWSkhKcPn0a+/fvR0lJCQBdMt/69evx2GOP4dSpUwgMDMTWrVstVkju0Ucfxfbt27FgwQIcOnQIw4cPh0ajQXJyMrZv3449e/Zg4MCBGD9+PGQyGe6++27885//RGVlJT799FP4+fmZrFevqaioKIwYMQJPPPEE6urq8N5778Hb2xsvvfSSSY4/efJkbN26FUqlEr169UJCQgL2798Pb2/vdh/joYcewrp167Bs2TL07dvXoAeCP8fOnTtx7733YtKkSUhLS8PGjRvRq1cvox8iTU2fPh3//ve/ce+99+Kpp55CdXU1PvroI3Tv3t0gsTQyMhJvvPEGlixZguvXr2Pq1Klwc3NDWloavv/+e8yfPx8vvPACDh48iEWLFmHatGno3r07GhoasHXrViFg7yhfX18sWbIEy5cvx8SJE3HPPfcgJSUFGzZswKBBg/DII490+JhtSU1NNdpjFRsbi0mTJmHmzJn45JNPUFZWhlGjRuH48ePYsmULpk6dijFjxnT4fC+99BK+/PJL3HHHHXjyySfh4uKCzz77DF27dkVJSUmrvRiRkZHw8PDAxo0b4ebmBhcXFwwZMgTh4eGYO3cuvv32W0ycOBEPPvggrl69ii+//NIgmR9o/3uDRCLBZ599hjvvvBO9e/fG7NmzERQUhOzsbBw6dAju7u74+eefO/z8b9SR87T39RUTEwOpVIpVq1ZBpVJBLpcLtcjmzp2LBQsW4P7778cdd9yBs2fPYs+ePc3yHFvi7u6Ojz76CI8++igGDBiA6dOnw9fXFxkZGfj1118xfPhwrF+//pavi8VZcCYauQW7du1ic+bMYdHR0czV1ZXJZDIWFRXFnnzySZafn2+wLwC2cOFCg238VOnVq1cbbD906JDRqb7btm1jsbGxTC6XMy8vLzZjxgyDKda8/fv3s+HDhzMnJyfm7u7O7r77bnbx4sVm+73++ussKCiISSQSg+mwxtrKmPFpr/n5+WzhwoUsJCSEOTo6soCAADZ27Fj2ySefGOyXnp7O7rnnHubs7Mx8fHzY008/zXbv3t2hKfJNpy8zppti7eLi0mz/UaNGsd69extsU6vVbNWqVax3795MLpczT09PFhcXx5YvX85UKpWw308//cT69evHFAqFUMPnf//7X7Ppwi1NZ75xCrAxTf/ua9asYSEhIUwul7ORI0cK9WlufO5NtffvU1paymbPns18fHyYq6srmzBhAktOTm5x+rIxWq2WhYSEMADsjTfeMHr/m2++yUJDQ5lcLmexsbHsl19+MTr9HUamA+/du5f16dOHyWQy1qNHD/bll18afc6MMfbdd9+xESNGMBcXF+bi4sKio6PZwoULWUpKCmOMsWvXrrE5c+awyMhIplAomJeXFxszZgzbv39/m8+zpf8xxnRT4qOjo5mjoyPz9/dnTzzxhEFtLsaM/891FD+t3djt8ccfZ4wxVl9fz5YvX87Cw8OZo6MjCwkJYUuWLGG1tbXNjtXe/88zZ86wkSNHMrlczoKDg9nKlSvZBx98wAAY1Kwy9tgff/yR9erVizk4ODSbLr9mzRoWFBTE5HI5Gz58ODt58qTRY3TkveHMmTPsvvvuY97e3kwul7PQ0FD24IMPsgMHDrTvIjdhbIp8R87TkdfXp59+yiIiIphUKjV4XhqNhv373/9mPj4+zNnZmU2YMIGlpqa2OEXeWFsZ031mTJgwgSmVSqZQKFhkZCSbNWsWO3nyZIevizXgGBMxI5YQQohde+aZZ/Dxxx+jsrLyphKZCbkVlBNECCHEImpqagx+Ly4uxtatWzFixAgKgIgoKCeIEEKIRcTHx2P06NHo2bMn8vPz8fnnn6O8vBz/+c9/xG4asVMUBBFCCLGIu+66C99++y0++eQTcByHAQMG4PPPP8dtt90mdtOInaKcIEIIIYTYJcoJIoQQQohdMlsQtGLFCgwbNgzOzs7w8PAwus9TTz2FuLg4yOXyFsuG79mzB0OHDoWbmxt8fX1x//334/r1662e+/Lly5gyZQp8fHzg7u6OESNG2OziboQQQggxD7PlBKnVakybNg3x8fH4/PPPW9xvzpw5OHbsmEElV15aWhqmTJmC5557Dl999RVUKhWeffZZ3Hfffa2unDt58mR069YNBw8ehJOTE9577z1MnjwZV69eNbrmiTFarRY5OTlwc3O75WUfCCGEEGIZjDFUVFSgS5cukEja6OsxdyGiTZs2MaVS2eo+y5YtY/3792+2fceOHczBwYFpNBph208//cQ4jmNqtdrosQoLCxkA9vvvvwvbysvLGQC2b9++drc7MzOzxWJidKMb3ehGN7rRzbpvmZmZbX7WW/XssLi4OEgkEmzatAmzZs1CZWUltm7dinHjxsHR0dHoY7y9vdGjRw988cUXGDBgAORyOT7++GP4+fkJyzcYU1dXZ7DmD9Pni2dmZsLd3d20T4wQQgghZlFeXo6QkBC4ubm1ua9VB0Hh4eHYu3cvHnzwQfzzn/+ERqNBfHy8sGioMRzHYf/+/cKaPxKJBH5+fti9ezc8PT1bfNzKlSuxfPnyZtvd3d0pCCKEEEJsTHtSWTqUGL148WJwHNfqLTk5+aYbfKO8vDzMmzcPM2fOxIkTJ3DkyBHIZDI88MADRldUB3Q9OAsXLoSfnx/++OMPHD9+HFOnTsXdd9/d6sKUS5YsgUqlEm43rkBMCCGEkM6lQz1Bzz//PGbNmtXqPhEREbfSHgMffvghlEol3n77bWHbl19+iZCQEBw7dgxDhw5t9piDBw/il19+QWlpqdCDs2HDBuzbtw9btmzB4sWLjZ5LLpdDLpebrO2EEEIIsW4dCoJ8fX3h6+trrrY0U11d3Syzm19fRqvVtvgYAM0eJ5FIWnwMIYQQQuyP2eoEZWRkIDExERkZGdBoNEhMTERiYiIqKyuFfVJTU5GYmIi8vDzU1NQI+6jVagDApEmTcOLECfz3v//FlStXcPr0acyePRuhoaGIjY0FABw/fhzR0dHIzs4GoFubxtPTEzNnzsTZs2dx+fJlvPjii0hLS8OkSZPM9XQJIYQQYmvaPWe8g2bOnGl0ytqhQ4eEfUaNGmV0n7S0NGGfr7/+msXGxjIXFxfm6+vL7rnnHnbp0iXh/kOHDjV7zIkTJ9j48eOZl5cXc3NzY0OHDmW//fZbh9qvUqkYAKZSqW72EhBCCCHEwjry+U1rh7WgvLwcSqUSKpWKZocRQgghNqIjn9+0dhghhBBC7BIFQYQQQgixSxQEEUIIIcQuURBECCGEELtEQRAhhBBC7BIFQYQQQgixS1a9gGpndDm/AttPZMLHTY4FoyLFbg4hhBBit6gnyMJyVbX47M80/JiYI3ZTCCGEELtGQZCFeTg5AgBU1WqRW0IIIYTYNwqCLMzDWRcEldXUi9wSQgghxL5REGRhHs4yAEC1WoO6Bo3IrSGEEELsFwVBFuYmd4CE0/2sot4gQgghRDQUBFmYRMJBKeQFURBECCGEiIWCIBHwQ2KUF0QIIYSIh4IgEfA9QWXUE0QIIYSIhoIgEQgzxGiaPCGEECIaCoJE4EE9QYQQQojoKAgSQWNOEPUEEUIIIWKhIEgElBNECCGEiI+CIBFQ1WhCCCFEfBQEiYAPgqhOECGEECIeCoJE4OFEOUGEEEKI2CgIEoHSmXKCCCGEELFRECQCD1o2gxBCCBEdBUEi4KfIV9Q1oF6jFbk1hBBCiH2iIEgE7goH4edymiFGCCGEiIKCIBE4SCVCIETT5AkhhBBxUBAkEqFqNOUFEUIIIaKgIEgkQq0gmiZPCCGEiIKCIJHQ0hmEEEKIuCgIEgkNhxFCCCHioiBIJHytIEqMJoQQQsRBQZBIGtcPo5wgQgghRAwUBImEzwkqpeEwQgghRBQUBIlEyAmi4TBCCCFEFBQEiaRx/TAaDiOEEELEQEGQSPicIOoJIoQQQsRBQZBIhCCIcoIIIYQQUVAQJBKlky4nqLy2HhotE7k1hBBCiP2hIEgk/OwwxoCKWuoNIoQQQiyNgiCRyBwkcJFJAdCQGCGEECIGswZBK1aswLBhw+Ds7AwPDw+j+zz11FOIi4uDXC5HTEyM0X22b9+OmJgYODs7IzQ0FKtXr27z3CUlJZgxYwbc3d3h4eGBxx9/HJWVlbfwbEyPpskTQggh4jFrEKRWqzFt2jQ88cQTre43Z84cPPTQQ0bv27VrF2bMmIEFCxYgKSkJGzZswNq1a7F+/fpWjzljxgxcuHAB+/btwy+//ILff/8d8+fPv+nnYg6NydE0TZ4QQgixNAdzHnz58uUAgM2bN7e4zwcffAAAKCwsxLlz55rdv3XrVkydOhULFiwAAERERGDJkiVYtWoVFi5cCI7jmj3m0qVL2L17N06cOIGBAwcCANatW4e77roL77zzDrp06XKrT80khKUzqCeIEEIIsTirzwmqq6uDQqEw2Obk5ISsrCykp6cbfUxCQgI8PDyEAAgAxo0bB4lEgmPHjrV4nvLycoObuXk40UryhBBCiFisPgiaMGECdu7ciQMHDkCr1eLy5ctYs2YNACA3N9foY/Ly8uDn52ewzcHBAV5eXsjLyzP6mJUrV0KpVAq3kJAQ0z4RI5RUK4gQQggRTYeDoMWLF4PjuFZvycnJJmvgvHnzsGjRIkyePBkymQxDhw7F9OnTdY2XmC6GW7JkCVQqlXDLzMw02bFbwi+dUVZDOUGEEEKIpXU4J+j555/HrFmzWt0nIiLiZtvTDMdxWLVqFd58803k5eXB19cXBw4caPU8AQEBKCgoMNjW0NCAkpISBAQEGH2MXC6HXC43WbvbQ8gJop4gQgghxOI6HAT5+vrC19fXHG1plVQqRVBQEADg66+/Rnx8fIvtiI+PR1lZGU6dOoW4uDgAwMGDB6HVajFkyBCLtbktQk4QJUYTQgghFmfW2WEZGRkoKSlBRkYGNBoNEhMTAQBRUVFwdXUFAKSmpqKyshJ5eXmoqakR9unVqxdkMhmKiorw7bffYvTo0aitrcWmTZuwY8cOHDlyRDjP8ePH8dhjj+HAgQMICgpCz549MXHiRMybNw8bN25EfX09Fi1ahOnTp1vNzDCgMSeolKbIE0IIIRZn1iBo6dKl2LJli/B7bGwsAODQoUMYPXo0AGDu3LkGAQ2/T1paGsLCwgAAW7ZswQsvvADGGOLj43H48GEMHjxYeEx1dTVSUlJQX9/Yo/LVV19h0aJFGDt2LCQSCe6//35hOr614HOCaDiMEEIIsTyOMUardxpRXl4OpVIJlUoFd3d3s5wjJa8CE977HV4uMpz+zx1mOQchhBBiTzry+W31U+Q7s6YVo7W0kjwhhBBiURQEiYhfSV7LgEp1g8itIYQQQuwLBUEiUjhKoXDU/QkoL4gQQgixLAqCREZLZxBCCCHioCBIZEJeEFWNJoQQQiyKgiCR8XlB1BNECCGEWBYFQSLzdKaq0YQQQogYKAgSWeP6YTQcRgghhFgSBUEiUzrTcBghhBAiBgqCREaLqBJCCCHioCBIZB7UE0QIIYSIgoIgkQmLqNIUeUIIIcSiKAgSGeUEEUIIIeKgIEhklBNECCGEiIOCIJE1XUmeMVpJnhBCCLEUCoJExgdB9RqGarVG5NYQQggh9oOCIJE5OUohk+r+DDQkRgghhFgOBUEi4ziuSXI0zRAjhBBCLIWCICsgTJOnGWKEEEKIxVAQZAWE5GgaDiOEEEIshoIgK6DUT5MvqaLhMEIIIcRSKAiyAv7ucgBAfnmtyC0hhBBC7IeD2A0gQBcPJwBAThkFQUQnv7wWa/ddRk29Bj0D3REd4IZege7wdZOD4zixm0cIIZ0CBUFWoIuHAgCQq6oRuSXEGpzJKMU/t55CQUUdAODHxBzhviAPJ3z0yAD0C/YQqXWEENJ50HCYFeii5HuCKAiyd9+dysJDn/yNgoo6dPNzxQvju2Nyv0BE+rpAwgHZZTV46dtzaNBoxW4qIYTYPOoJsgLCcJiqFowxGu6wQw0aLVbtTsanf6QBAMb19MPah2LgpnAU9imurMO4d48gOa8CW/9Ox+zh4WI1lxBCOgXqCbIC/u4KcBygbtCimGaI2aVXf0gSAqBFY6LwyaMDDQIgAPB2lePFCdEAgHf3XkahfriMEELIzaEgyArIHCTwddXNEMul5Gi7U1Fbj+9OZwEA3p8egxcm9IBEYrw38KFBIegbpERFXQNW7U62ZDMJIaTToSDISgTqh8SyKS/I7vx+uQj1GoYIHxdMiQlqdV+phMPyKb0BAN+eysKp9FJLNJEQQjolCoKsRBDNELNb+y/lAwDG9fJv1/4DunriwYHBAIBlPyVBo2VmaxshhHRmFARZiUD9DLFclfHhsMKKOrzy/Xlczq+wZLOImTVotDiUUgAAGBvt1+7HvTQxGu4KByRll+Pr4xnmah4hhHRqFARZiUClrieopeGwL/9Ox1fHMvDk/52hb/6dyKn0UpRV18PD2RFxoZ7tfpyPqxzPj+8BAFjx6yVs+iuN/i8IIaSDKAiyEkH6nKDcFoKg1IJKAEBKfgV26pNoie3jh8Ju7+EHB2nHXo4zhnTFyG4+qKnXYPnPF3H/R0eRnFdujmYSQkinREGQlQhsY+mMq4WVws/v7ruM2nqNRdpFzOvAJd1QWHvzgZpykEqwZfZgvD61D1zlDkjMLMPkD/7E27uT6f+DEELagYIgK8EvnVFQUYv6G6oBa7QM14qqAABuCgfkqmqx5eh1SzeRmNjVwkpcK6qCo5TDyG4+N3UMiYTDo0NDsf+5URjfyx8NWoYNh6/ivf1XTNxaQgjpfCgIshI+LnI4SjloWfPV5LNLa6Bu0ELuIMGrk3oCAD48lApVdb0YTSUmsv+ibihsaIR3s8KIHRWgVOCTxwYK/x+H9cnWhBBCWkZBkJWQSDgEKPlp8oZBED8UFu7jggfiQtDD3w3ltQ3YcDjV4u0kpsMPhd1xE0NhLZnULxAAcKWgEjVqGhIjhJDWUBBkRVpaSJVPio70c4VUwuHfd+pmBW06ep0WXbVRJVVqnEwvAQCM7Wm6ICjAXQFfNzk0WoYLOSqTHZcQQjojCoKsSJcWkqP5nqBIX1cAwJgefhgc7gV1gxbv7rts2UYSkziUXAAtA3oGugszA02B4zj0D1YCAM5mURBECCGtoSDIinRpoWp0YxDkAkD3QbfkTt1Cmt+dzqKlNmzQgWRdPtAdPdtfILG9+gV7AADOZZWZ/NiEENKZUBBkRQJbGA67WqibGcb3BAFAbFdPRPi4gDEgs6Taco0kt6yuQYMjKYUAbm5qfFv66nuCzlNPECGEtMqsQdCKFSswbNgwODs7w8PDw+g+Tz31FOLi4iCXyxETE2N0n+3btyMmJgbOzs4IDQ3F6tWrWz3v9evX8fjjjyM8PBxOTk6IjIzEsmXLoFarb/EZmVeQkeGwkio1Sqp07Y7Q9wTx3BQOAICqugYLtZCYwtGrxahSa+DvLkefLkqTH7+/vifoWlEVVDU0g5AQQlpi1iBIrVZj2rRpeOKJJ1rdb86cOXjooYeM3rdr1y7MmDEDCxYsQFJSEjZs2IC1a9di/fr1LR4vOTkZWq0WH3/8MS5cuIC1a9di48aNePnll2/p+ZhboH44LKfJcNg1/VBYkIcTnGUOBvu7yHW/V1IQZDMaNFqs3p0CAJjYOwASCWfyc3i5yBDsqQuok7KpN4gQQlri0PYuN2/58uUAgM2bN7e4zwcffAAAKCwsxLlz55rdv3XrVkydOhULFiwAAERERGDJkiVYtWoVFi5cCI5r/iEyceJETJw4Ufg9IiICKSkp+Oijj/DOO+8YbUddXR3q6uqE38vLLb/8AD8cVlZdjxq1Bk4yaWM+kJ9rs/1dKQiyOZv+uo6LueVQOjniybHdzHae/sEeyCqtwdmsMgyPurlCjIQQ0tlZfU5QXV0dFAqFwTYnJydkZWUhPT293cdRqVTw8vJq8f6VK1dCqVQKt5CQkJtu881yVzgIgQ3fG9SYD+TSbH9+XxoOsw2ZJdXCbL6X74qGj6vcbOfqp88LOpdJPUGEENISqw+CJkyYgJ07d+LAgQPQarW4fPky1qxZAwDIzc1t1zFSU1Oxbt06/POf/2xxnyVLlkClUgm3zMxMk7S/IziOE1aT55OjhRpBvs17goThsFoKgqwdYwxLf0xCTb0Gg8O98OBA8wbZNEOMEELa1uEgaPHixeA4rtVbcnKyyRo4b948LFq0CJMnT4ZMJsPQoUMxffp0XeMlbTc/OzsbEydOxLRp0zBv3rwW95PL5XB3dze4iaGLsJq8Ljn6xhpBTbkq+OEwqgxs7X49n4tDKYWQSSV4896+RodxTalvsBIcB+SoalFYUdf2AwghxA51OCfo+eefx6xZs1rdJyIi4mbb0wzHcVi1ahXefPNN5OXlwdfXFwcOHGjXeXJycjBmzBgMGzYMn3zyicnaZE58raDsshrU1muE6e+RfjQcZqtUNfVY/vNFAMAToyMRZSS/y9Rc5Q6I9HVFakElzmWVmbQqNSGEdBYdDoJ8fX3h6+trjra0SiqVIigoCADw9ddfIz4+vtV2ZGdnY8yYMYiLi8OmTZva1WtkDfjk6FxVDdKLq6FluqnwvkbyR1xkUgCUGG3t3t6djMKKOkT4uuBfYyItdt5+wUqkFlTibJaKgiBCCDHCrLPDMjIyUFJSgoyMDGg0GiQmJgIAoqKi4Oqq+zacmpqKyspK5OXloaamRtinV69ekMlkKCoqwrfffovRo0ejtrYWmzZtwo4dO3DkyBHhPMePH8djjz2GAwcOICgoCNnZ2Rg9ejRCQ0PxzjvvoLCwUNg3ICDAnE/5lgnDYapag6EwY8MnrvqVxykIsl5ZpdX4v+MZAIA37+0LuYPUYufuH+yBnaezcZ7yggghxCizBkFLly7Fli1bhN9jY2MBAIcOHcLo0aMBAHPnzjUIaPh90tLSEBYWBgDYsmULXnjhBTDGEB8fj8OHD2Pw4MHCY6qrq5GSkoL6el1huH379iE1NRWpqakIDg42aBNjzOTP05S6KBuHw662khQNAK5y3QcqDYdZr29PZYExYFikN4ZGeFv03Hzl6HNZKjDGzJ6HRAghtsasQdDmzZtbrREEAIcPH271fh8fHyQkJLS6z+jRow2Cm1mzZrWZt2StmiZGpwo1gprnAwFULNHaabUMO05mAQAeGmT5kgu9At3hIOFQXKVGdlkNgj2dLd4GQgixZraRKGNHAvQ9QTX1GpxKLwUARLXYE0RBkDX762oRsstq4K5wwITelh+GVThK0SPADYCuN4gQQoghCoKsjMJRCm8XGQAgq1RXK8hYtWiAZodZu20ndLWmpsYGQeFouVygpvh6QWcpL4gQQpqhIMgK8UNiAOAg4dDVy/gwBg2HWa/SKjX2XsgHALMXRmxNf6ocTQghLaIgyArxVaMBINTbGY5S438mvlhivYahroEKJlqTHxKzodZo0buLO/oEmX6l+Pbie4KSslXQaq17UgAhhFgaBUFWqGlPUEszwwDApcmq8lVUNdpqMMaEoTAxe4EAoLu/KxSOElTUNeBiruUXBSaEEGtGQZAV4qtGAy3nAwGAVMLBSZ9rQuuHWY+k7HIk51VA5iDB1JggUdviIJVgZDddUdHFO89RjyEhhDRBQZAVam9PENB0/TAKgqzFtpO64ogTewdA6ewocmuA/07pDQ9nRyRll2P17hSxm0MIIVaDgiArxC+dAQCRvsZrBPGEGWJqCoKsQW29Bj8m5gAQpzaQMYFKJ6x+oD8A4LM/03AopUDkFhFCiHWgIMgKBXs2BkERbfQEuchpOMya7ErKRUVtA0K8nBBv4QrRrbmjlz9mxocCAF7YfhYF5bUit4gQQsRHQZAV8ndX4InRkXhxQg8onVofTqGCidbl57O5AIAHBoRAIrGuZSqW3NUTPQPdUVylxrPbE2m2GCHE7lEQZKX+PTEaC8dEtbkfFUy0HrX1Ghy9WgQAmNjH+hbqVThKse7hWDg5SvFXajE+OnJV7CYRQoioKAiycVQw0Xr8fa0YtfVadFEq0N2/9WFMsUT5ueK1e3oBANbuu4xzVEmaEGLHKAiycTQcZj0OpxQCAEZH+1n1iu0PDgzBnX0C0KBleGZbImrUNG2eEGKfKAiycTQcZh0YYziYrJt1NaaHn8itaR3HcXjz3r7wc5PjWmEVVu66JHaTCCFEFBQE2TgaDrMO14qqkFFSDZlUgmGR1jMrrCWeLjKsnqabNv9FQjoO07R5QogdoiDIxjUOh9GQhpgO6XuBhkR4CYGptRvV3VeYNv/it+dQUqUWuUWEEGJZFATZOBoOsw5CPpCVD4XdaPGdPRHp64LCijq8vPM8GKNp84QQ+0FBkI0ThsOoWKJoquoacCytGAAwpoevyK3pGCeZFO9Pj4WDhMPuC3n45Vyu2E0ihBCLoSDIxgkVo6knSDR/pRahXsMQ6u2McJ/WlzmxRn2ClEJNqrX7LqNBoxW5RYQQYhkUBNk4NwWtHSa2Q/qhsDE9rHtqfGvmjgyHh7MjrhVV4aezOWI3hxBCLIKCIBtHw2HiYowJM6tG29hQWFNuCkfMvy0CAPDBgSvUG0QIsQsUBNk4FxlNkRdTSn4FclW1UDhKMNSKFky9GTPjw+DlIsP14mr8kEi9QYSQzo+CIBvHD4fVNWhRT9/eLe5Qsm4obFikDxSOUpFbc2tc5A4GvUH0/0QI6ewoCLJxTWvS0DR5yzuUwleJtt2hsKYeiw+Ft4sMGSXV+P50ttjNIYQQs6IgyMY5SiWQOej+jDQkZlmlVWqcSi8FYHv1gVriLHPAglGRAIAPDlJvECGkc6MgqBNwEwomUtVoSymvrcecLSeg0TJEB7ghxMtZ7CaZzCNDQ+HjKkdWaQ2+PZXV6r4/nMnGy9+fR0FFrYVaRwghpkNBUCfQuH5YvcgtsQ+qmno8+vlxnMkog9LJEe/o1+DqLJxkUiwY1ZgbVFBuPMD56WwOntmWiP87loEp6//C+SyVJZtJCCG3jIKgTsCF1g+zmLJqNR757BjOZpbB09kR/zdvCPoEKcVulsk9MjQUIV5OyFXVYvonfyNPZRgIHbtWjBe2nwWg64nMVdXigY1H8WMi5RERQmwHBUGdgButH2YRpVVqzPjsGM5nq+DlIsP/zRuK3l06XwAEAApHKb56fCiCPJxwragKD32SgJyyGgBAakEl5m89BbVGi4m9A/DHv8dgTA9f1DVo8fQ3iVi1OxkaLa1BRgixfhQEdQLC0hlUMNFsGGP455encCGnHD6uMnw9byh6BrqL3Syz6urtjG/mD0WIlxPSi6vx0CcJSMwsw6xNx6GqqUdsVw+8Nz0GHs4yfDZzEJ4YrUuo/ujwVbz07TmRW08IIW2jIKgTaBwOoyDIXA5cKsDxtBIoHCX4et5Q9AhwE7tJFhHi5Yxt8+MR6u2MzJIaTP3wL2SV1iDM2xmfPTZQqI0klXD498RovD89BhIO+O50Fs5llYnbeEIIaQMFQZ2AsH4YBUFmodUyvLM3BQAwe3g4uvnbRwDE6+LhhG3z44XFYb1cZNg8ezC8XeXN9p0SE4SpsUEAdIuxEkKINaMgqBOgpTPM66ezOUjOq4C7wgELbosUuzmiCFAqsO2fQ/HU2G74Zv5QhOkDImOeur0bpBIOh1IKcTqj1IKtJISQjqEgqBOg4bBbV61uQLW6+fVTN2jxrr5H45+jIqF0drR006yGn5sCz93RHd3b6AkL83HB/QOoN4gQYv0oCOoEaDjs1tQ1aDB2zREMe+sg/kotMrhv28lMZJRUw8dVjtnDw8RpoA168vZucJBw+ONKEU5cLxG7OYQQYhQFQZ0A9QTdmlPppchV1aKsuh6P/e84Nv+VBsYYatQarDtwBQDw5O1RcJY5tHEkwgvxcsa0gSEAgHf3Um8QIcQ60bt6J0BB0K05mloMQNejVlHbgNd+vojkvAp08XBCQUUdgj2d8PDgriK30vYsuj0K357KRMK1Yhy9WoRhkT5iN4kQQgxQT1AnQGuH3Zo/9UNg/5ncC6/c1RMSDvjmRKaQC/TsuO7CIrWk/YI8nDB9kC54fG/fFTBGBRQJIdaF3tk7AeoJunnltfVCPZsRUT6Yd1sE/jdrkJBn1d3fVZjyTTruX2MiIXOQ4Pj1Ehy5XCh2cwghxAAFQZ2AUDGagqAO+/tqMbQMiPBxQRcPJwDA6B5++HHhcMwZHo4P/zEAUgkncittV6DSCY8ODQUAvPpDEiXvE0KsilmDoBUrVmDYsGFwdnaGh4eH0X2eeuopxMXFQS6XIyYmxug+27dvR0xMDJydnREaGorVq1e3uw11dXWIiYkBx3FITEzs+JOwAW5y3bRt+oDpuKNXdflAw6K8DbZH+Lpi6d297K4wojk8e0d3BHk4Iau0Bm/vTha7OYQQIjBrEKRWqzFt2jQ88cQTre43Z84cPPTQQ0bv27VrF2bMmIEFCxYgKSkJGzZswNq1a7F+/fp2teGll15Cly5dOtx2W8L3BFWrNbRwZQfxU+KHU9Ku2bjKHbDq/n4AgC0J6fj7WrHILSKEEB2zBkHLly/Hs88+i759+7a4zwcffICFCxciIiLC6P1bt27F1KlTsWDBAkRERGDSpElYsmQJVq1a1Wai5a5du7B371688847t/Q8rB2fEwQAVUYK/hHj8strcaWgEhwHxEd6t/0ActNGdPPBw4N1U+Zf+vac0cKUhBBiaVafE1RXVweFQmGwzcnJCVlZWUhPT2/xcfn5+Zg3bx62bt0KZ2fndp2nvLzc4GYr5A4SOEp1eSs0JNZ+R6/qeoH6dFHCw1kmcms6v5fv6okuSgUySqqxek+K2M0hhBDrD4ImTJiAnTt34sCBA9Bqtbh8+TLWrFkDAMjNzTX6GMYYZs2ahQULFmDgwIHtOs/KlSuhVCqFW0hIiMmeg7lxHNc4Q6yWgqD2+vOK8XwgYh5uCkes1A+LbT56HcfTqJI0IURcHQ6CFi9eDI7jWr0lJ5su+XHevHlYtGgRJk+eDJlMhqFDh2L69Om6xkuMN3/dunWoqKjAkiVL2n2eJUuWQKVSCbfMzEyTtN9SaBHVjmGMCT1BI6IoH8hSRnX3xYMDg8EY8O/vzlEOGyFEVB2uGP38889j1qxZre7TUn7PzeA4DqtWrcKbb76JvLw8+Pr64sCBA62e5+DBg0hISIBcLjfYPnDgQMyYMQNbtmxp9hi5XN5sf1vSuH4YFUxsj7SiKuSqaiGTSjAw1Evs5tiVVyb1wq/ncpFWVIXL+RXoGegudpMIIXaqw0GQr68vfH19zdGWVkmlUgQF6YrWff3114iPj2+xHR988AHeeOMN4fecnBxMmDAB27Ztw5AhQyzSXkujgokdw88KGxDqASeZVOTW2BelkyNiunrgr9RinEovpSCIECIas64dlpGRgZKSEmRkZECj0Qh1eqKiouDq6goASE1NRWVlJfLy8lBTUyPs06tXL8hkMhQVFeHbb7/F6NGjUVtbi02bNmHHjh04cuSIcJ7jx4/jsccew4EDBxAUFISuXQ3XeeLPFRkZieDgYHM+ZdFQENQxf+nXC6OhMHHEdfXEX6nFOJ1eikf0xRQJIcTSzBoELV261GDoKTY2FgBw6NAhjB49GgAwd+5cg4CG3yctLQ1hYWEAgC1btuCFF14AYwzx8fE4fPgwBg8eLDymuroaKSkpqK+vN+fTsWqN64dRENQWjZYh4RqfFE1BkBgGhHoCAE5llIrcEkKIPTNrELR582Zs3ry51X0OHz7c6v0+Pj5ISEhodZ/Ro0e3WjMoLCys0y/eSEtntN+FHBVUNfVwkzugX5BS7ObYpdiuuiAovbgahRV18HWz3Xw8QuwZYwwfHkpFkKcT7o21vZEWq58iT9qHhsPajx8KGxLhDQcpvQTEoHRyRHd/3TD1aeoNIsRmJWWX4529l/HstrP47I9rYjenw+gToJNwpeGwdimpUuPzP9MAAKO601CYmOL0Q2IUBBFiuy7mqoSf3/j1Er5IuC5eY24CBUGdhCv1BLWJMYZXvj+Poso6dPNzxbSBtlMQszMaoB8SO51OQRAhtupSbgUAwN9dN6S99McL+Pp4hphN6hAKgjoJqhjdth8Ss7ErKQ8OEg5rH4qBwpGmxouJ7wk6m6WCukErcmsIITcjJU8XBD0/vgfmjggHALz8/Xl8eypLzGa1GwVBnYQwHEYLUxqVU1aDpT9eAAA8PbYb+lBCtOjCfVzg6ewIdYMWF3JUbT+AEGJVGGNIztOts9kr0B2vTOqJmfGhYAx46duzOKqvx2bNKAjqJBqHw6hi9I20WoYXdpxFRW0DYkI88MToSLGbRKCrBs8PiZ2iITFCbE5BRR1Kq+sh4YAoP1dwHIdld/fGpH6B0DLg53M5YjexTRQEdRKNw2H2WyupJVsSruPo1WIoHCV498H+NCPMigyg5GhCbFayfigs3MdFSC+QSDhM7B1gcL81o0+DTqJxdhj1BDWVU1aDt3bpFvR95a6eiPB1FblFpCk+L+hUemmnr+VFSGeTnKsbCou+Yemb6AA3ALp8Ia2VL5JMQVAn4aqgKfLGHLlciLoGLfoFK2l5BivUP9gDUgmH/PI65KhqxW4OIaQD+KToaH83g+3hPi6QSSWoVmuQVVojRtPajYKgTkKoGK1uoG/UTZy4XgIAuK2bLziOE7k15EZOMil6d9F9i6S8IEJsyyU+CLqhJ8hBKkGUn67XnU+ctlYUBHUS/HAYY0C1mobEePwHa1yYp8gtIS2hekGE2J56jRapBfogKMCt2f3Rgbpt1p4XREFQJ+HkKIVE39FBQ2I6BRW1SC+uBsc1ftAS6zMglGaIEWJr0oqqUK9hcJU7INjTqdn9TfOCrBkFQZ0Ex3HCDLEKCoIAAKeu6z5Ue/i7QenkKHJrSEv45OiLueWopjpXhNiES/qk6B4BbkZTDXoE6IbILtFwGLEUWj/M0Al9EDSQhsKsWhelAgHuCmi0DGczqWgiIbaAH+YyNhQGAD31268XVaG23npTNCgI6kRo/TBDp9J1SdEDQ71EbglpDcdxtJgqITYmpY0gyNdNDk9nR2gZkFpQacmmdQgFQZ0IrR/WqFrdgAs5um5Y/gOWWK/Yrh4AgDMZZaK2gxDSPi3VCOJxHIdofkgs13qHxCgI6kRo/bBGiZllaNAyBLgrjCbtEevCr+VmzW+WhNij0ip1s4KHqup6oa5XjxZ6gpreZ83J0RQEdSK0flgjPik6LsyT6gPZgF76WkHZZTUoq1aL3BpCCACczSxD7Ov7sHjnOYPtKfm6oCbIwwnuipYnnfS0gWnyFAR1IjQc1uiEfrr1IBoKswnuCkeEeOl67C7mUG8QIdbgjD5Hb/vJLIN8Pb4AYkv5QDx+hhgFQcQiXPVVo+19dphGy3AmnZ8ZRknRtqKXPrfgIg2JEWIVSqoae2Xf/PWSsBrBpVy+UnTrQVB3f1dwHFBUWYeiyjrzNfQWUBDUifDrh9n77LCUvApU1DXARSZt85sKsR69u+jygqgniBDrUNJkaPpkein2XMgHAKTk8TWCjCdF85xlDgj1ctY/xjp7gygI6kRcaIo8gMap8bFdPeEgpX9xW0E9QYRYl9KqegBAoFIBAFi1Oxl1DRohoOnZji+Z0VY+JEafEJ0IFUvUOZlORRJtEZ8cfaWg0qqLqxFiL4qrdENYT43tBh9XGdKKqrB6dwqq1BrIpBKE+7i0eQx+hliylX65oSCoE6FiiTon+UrRVCTRpgQqFfBwdoRGy3Al33qLqxFiL/ieoBBPZzwzrjsA4LM/0wAAUX6u7eppF9YQy6eeIGJmNBwG5JTVILusBlIJhxh9AT5iGziOQ+8u/JAYLZ9BiNj4nCBPF0dMHxSCSN/Gnp+2kqIb99O9plPyKqC5od6QNaAgqBPx0C8SWlxpv3VW+KGwnoFuQs8YsR18XtAFSo4mRFSMMZTqZ4d5u8jhIJVgyZ09hft7tpEUzevq5QyFowR1DVqkF1eZpa23goKgTiRMPz6bVVqNugb7zKk4dZ3WC7NlfF4QzRAjRFzltQ1o0PfceDjrvmCP7emH0T18wXFAfKR3u44jlXDo4W+9RRMpCOpE/NzkcJFJoWVAenG12M0RxbE0fRBESdE2qVdg4/IZN5bqJ4RYDt8L5CKTQuGoq0HHcRw+eXQg/vr37cJSN+0hJEdTEETMieM4RPq5AgCuFdpfYmlmSTWS8yog4YChEe37lkKsS6SvC2QOElSpNcgosc9AnhBrwOcDebnKDLbLHCTo4tGx9Rj5afJ8fSFrQkFQJxOhHxK7Wmh9Y6/mtudCHgBgUJgXfFzlIreG3AwHqUSYTUJ5QYSIp0SfW+rlLGtjz7ZFU08QsZQIX74nyP6CoL36aqYT+wSI3BJyKxqLJtIMMULE0jgz7NaDIH44LKOk2urq2FEQ1MlE6KcwXiuyr+Gwwoo6nNBXih7fm4IgW9abkqMJER2fE+RlgiDI21UOLxcZGIPVDXNTENTJRPg09gTxi93Zg30X88EY0C9YiaAOjlcT6yLMELPSCrOE2AN+8VRTDIcBQLCn7n05q7TGJMczFQqCOplwHxdwHKCqqTdYAbiz4/OBJlAvkM3rEeAOjgPyy6135WlCOjv+88MUw2EAhC+nWaXUE0TMyEkmRRel7p/NXpKjVTX1OHq1CAAFQZ2Bq9wBYd66YV0aEiNEHKXVfKFE0/YEZVNPEDE3IS/ITqbJH0ouQL2GIcrPFVH6EgHEttGQGCHiKjZxT1CwpzMAGg4jFhDJzxArso+eIH4obCL1AnUatHwGIeIyZWI00CQnqIyGw4iZ2VNPUI1ag8MphQBoKKwzaVw+g6bJEyIGISfIRInRQZQYTSwl0o5qBf1+pRA19RoEeTihT1D7FvQj1q+3vifoWlEVqtXWVVeEkM6uXqNFea3udWeqnCA+Mbqsuh6VVlQriIKgTojvCcooqUa9Ritya8xrT1LjrDCO40RuDTEVP3cFfFzlYAy4lGt9VWYJ6cz4pGgJB7g7OZrkmG4KR2EhVmtKjqYgqBMKcFfAWSZFg5YZXUj157M52KvPo7Fl9Rot9l/SVYme0Ntf5NYQU+sXrFugMTGzTNyGEGJnSqvqAQAezjJIJab7cmmN0+TNFgStWLECw4YNg7OzMzw8PIzu89RTTyEuLg5yuRwxMTFG99m+fTtiYmLg7OyM0NBQrF69ul3n//XXXzFkyBA4OTnB09MTU6dOvbknYoM4jkO4j/G8oOtFVXjy6zNY+H+nbX6Y4e9rxSivbYC3iwwDw7zEbg4xsQFdPQAApzNKxW0IIXamxMRJ0TxhmnyZHfQEqdVqTJs2DU888USr+82ZMwcPPfSQ0ft27dqFGTNmYMGCBUhKSsKGDRuwdu1arF+/vtVjfvfdd3j00Ucxe/ZsnD17Fn/99Rf+8Y9/3PRzsUURLcwQ+/V8LgCgXsOsrnx5R+3WD4Xd0cvfpN9WiHUY0NUTAHAmnYIgQizJ1NWiedY4Td7BXAdevnw5AGDz5s0t7vPBBx8AAAoLC3Hu3Llm92/duhVTp07FggULAAARERFYsmQJVq1ahYULFxrNAWloaMDTTz+N1atX4/HHHxe29+rV61aejs2JbGGG2G/6IAgArhdVIzrANpOJtVqGvRf1Q2G0YGqn1D/EAxIOyFHVIldVg0AlLYdCiCU0Lp5qmnwgnl0Nh5lCXV0dFAqFwTYnJydkZWUhPT3d6GNOnz6N7OxsSCQSxMbGIjAwEHfeeSeSkpLaPFd5ebnBzZYZW00+vbjKoO5KerHtzh47k1mKwoo6uMkdMCzSW+zmEDNwkTsIQfrp9DJxG0OIHWmsESQ36XGtcf0wqw6CJkyYgJ07d+LAgQPQarW4fPky1qxZAwDIzc01+phr164BAF577TW8+uqr+OWXX+Dp6YnRo0ejpKSkxXOtXLkSSqVSuIWEhJj+CVlQBJ8T1GQ47NfzhtfsupGkaVux54KuF2hMtB/kDlKRW0PMZUCoBwDKCyLEkhpzgkzbE8QPh9ns7LDFixeD47hWb8nJySZr3Lx587Bo0SJMnjwZMpkMQ4cOxfTp03UNlxhvularmxL+yiuv4P7770dcXBw2bdoEjuOwY8eOFs+1ZMkSqFQq4ZaZmWmy5yEGfpp8SZVaiOp3ndfl0AwM1eVa2GpPEGOssUo0DYV1anxeEAVBhFiOqQsl8viCicVVaquZmNOhnKDnn38es2bNanWfiIiIW2mPAY7jsGrVKrz55pvIy8uDr68vDhw40Op5AgMDARjmAMnlckRERCAjI6PFc8nlcsjlpu36E5OzzAGBSgVyVbW4VlQJ31oFzmerIOGA+bdF4OTWU0anz9uC5LwKpBdXQ+YgwajuvmI3h5hRnD5gv5Bdjtp6DRSO1OtHiLkJi6e6mjYIUjo5wk3hgIraBmSX1qCbv5tJj38zOhQE+fr6wtfX8h86UqkUQUFBAICvv/4a8fHxLbaDn3KfkpKCESNGAADq6+tx/fp1hIaGWqzN1iDC1wW5qlpcLazCieu6b9JDI7yFD5YcVY1NfrDwvUC3dfOFi9xsuf3ECnT1coa3iwzFVWpcyFEhLpRKIRBibsWV5ukJAnRDYpdyy5FlJUGQ2XKCMjIykJiYiIyMDGg0GiQmJiIxMRGVlY2zlVJTU5GYmIi8vDzU1NQI+6jVuj9AUVERNm7ciOTkZCQmJuLpp5/Gjh078N577wnHOH78OKKjo5GdnQ0AcHd3x4IFC7Bs2TLs3bsXKSkpwjT9adOmmevpWqWmy2fws8Lu6hsILxcZ3OQOYMy6svTba7dQJZoKJHZ2HMchlh8So+RoQiyC7wkydZ0goOlCqtaRF2S2r9FLly7Fli1bhN9jY2MBAIcOHcLo0aMBAHPnzsWRI0ea7ZOWloawsDAAwJYtW/DCCy+AMYb4+HgcPnwYgwcPFh5TXV2NlJQU1NfXC9tWr14NBwcHPProo6ipqcGQIUNw8OBBeHp6muvpWiU+Ofr3y4W4mFsOCde4vESojzOSsstxvagaUX7iR+PtlV5cheS8CkglHMb1pCDIHgwI9cD+S/mUF0SIBTDGzFYsEbC+afJmC4I2b97cao0gADh8+HCr9/v4+CAhIaHVfUaPHg3GmME2R0dHvPPOO3jnnXfa09ROi58mfzFXNy1+cLgXfN10eU+h3i66IMjGkqP5obAh4V7wNMMLlFifuCbJ0YwxWiOOEDOqVmtQ16CbYGTWniArmSFm1VPkya3hZ4jxJvUNFH4O89ZNVbS15Gh+ajzNCrMf/YI94CDhkF9ehxxVrdjNIaRT43uB5A4SOJkhX9TaqkZTENSJdVE6QeGo+xNznGFl5VBvXYBkSz1BBeW1OKVfQmF8LwqC7IWTTIqegbqiiadoCQ1CzEqYGeYiM0uvq7B+GAVBxNwkEg7hProhsUFhXvBza6y+HWaDQRC/TEZMiAcClIo29iadibCYKgVBhJhVMV8jyEzpBnwQVFRZh9p6jVnO0REUBHVyMSEeAID7YoMMtvPDYdmlNVDrx3+tHRVItF8D9GUdzlByNCFmVWrGpGhAVyvIVV/axBqGxCgI6uQW3xmNrY8PxkODDJcB8XWTw8lRCq2NTJO/VliJhKvFAHQz3Ih94StHX8gpt4pvj4R0VuaqFs3jOK5xSMwKpslTENTJKZ0cMbKbb7OxXY7jEGojydGMMbz6QxIatAyje/gi3Mel7QeRTiXY0wm+bnI0aBnOZ6vEbg4hnZY5awTxrGmaPAVBdsxW8oK+P5ONo1eLoXCU4PUpfcRuDhEBx3FCXhAlRxNiPuasEcSzpmnyFATZsVAf6+8JKq1S441fLwEAnhrbDSFeziK3iIiFX+6FkqMJMZ8SMydGA9Y1TZ6CIDtmCz1Bb+1KRkmVGj383TBvpOkW5yW2h88LOpNZ1qxAKiHENEqrdKsveJtzOEyYJi/+F3AKguyYtecEHU8rwbaTmQCAN+/rA0cp/bvas95dlJBKOBRW1CGvnIomEmIOxVV1AMyXGA3QcBixEnxPUGZJNRo01jVNXt2gxcvfnwcAPDy4K60eTuAkk6K7ftXps5mUHE2IOZRW63qCzJsTpPsCXlAhfq0gCoLsWIC7AjIHCRq0DDll1vXNevPRNKQWVMLHVYbFE6PFbg6xEv2DlQCAs1ll4jaEkE5Io2Uos8DsME9nR2FJjhyRp8lTEGTHJBIOofpEY2vLC9qnrw799NhuUDo7itwaYi3664t/nqMgiBCTU9XUQ6tPt/Mw4/uuNdUKoiDIzvFriKVbURCk1TJcyCkHAAyJ8Ba5NcSa9NP3BJ3LUkGrpeRoQkyJnxnmrnAwew6mteQFURBk5/jlM65bUXL0taIqVKs1UDhKEOnrKnZziBXp7u8GuYMEFbUNVtd7SYitExZPdZWb/VyN0+TF/eyhIMjOhfpYX0/QhRxd0muvQHdIJaZfxZjYLkepBL276FaUp7wgQkyruJJfMsP8KQhB1BNErIE19gSdz9IFQX2DlCK3hFgjPi+IZogRYlqWWDKDJ+QEiRwEOYh6diI6fpp8RnE1NFpmFT0vSfqeoN4UBBEj+gd7AKDkaEJMzRJLZvDiI7yxbf5QdPUWdxUACoLsXKBSAUcpB7VGi7zyWmFhO7FotQwXsnVJ0dQTRIzhk6Mv5JSjXqOlIpqEmEipBZbM4Hm7yi2Se9QWevewcw5SCUL0CWrpReLnBWWUVKOirgEyBwmi/CgpmjQX5u0Cd4UD6hq0SMmrELs5hHQaQk+QGatFWxsKgoiwfIY15AWdz9YNhfUMdKdv+MQoiYRDP2FIjPKCCDGVEgvmBFkL+pQhQq0ga5hyzOcD9dHPACLEmMZ6QWXiNoSQTqTUgjlB1oKCIIJIX10QdCVf/KGFpGyaGUbaxvcEJWaWidoOQjqTYgvmBFkLCoIIogN1vS6XcsUNghhjSNInRfehIIi0IkY/Tf5KQSVq1OIuwEhIZ0E5QcQuRQfoVubOK68VukPFkFVaA1VNPRylnLBaOCHGBCgV8HOTQ6NlQnFNQsjNU1XXo1r/hSJAqRC5NZZDQRCBm8IRIV66qfGXcstFawc/FNYjwA0yB/rXJK3jh8TOUnI0IbcsU798hY+rHAr9Cu/2gD5pCACgZ4B+SEzEKcfnKR+IdEB/fXL0WTvKC8osqcbeC3liN4N0QvzyFXwlZ3tBQRABoJuSDojcE6RfOb53FwqCSNv45TPsZYZYbb0G0z/5G/O3nsJfqUViN4d0MvxCpiFe4lZwtjQKgggA8YMgXVI09QSR9uOnyV8vroaqul7k1pjfFwnXkV2m+7Z+MLlA5NaQzoZ6gohd66UPgq7kV6Jeo7X4+XNVtSipUsNBwqFHACVFk7Z5OMuEQp/nssvEbUwH/X65EA98dBSn0kvbtX9ZtRrrD6YKv/95hXqCiGllluh6gigIInYp2NMJrnIHqDVaXCu0fNFEPh+om7+bXSXlkVvDL6ba3mDCWnz2ZxpOppfin1tPIk9V2+b+Hx5KRXltAyJ8XMBxQEp+BQrK234cIe3F9wTxyyjZCwqCCADdUgT8VHkxhsQuZFOlaNJxQyK8AABHrxaL3JL202gZTuuDtqJKNZ746hTqGlqudZRZUo0tR9MBAEvv7oU++py5PykviJgIY0zICaKeIGK3xMwLEmaGBVM+EGm/4ZE+AIAzGaWoVjeI3Jr2Sc4rR2VdA5xlUrgrHHAmowz//flii/uv2ZsCtUaL4VHeGNXdFyO66Z4zBUHEVEqr61GlrxHUxYOCIGKnogP1PUEiTJOnmWHkZoR6OyPIwwn1GoYT121jSIwfuosL9cT7D8eC44CvjmVg+4nMZvsmZavwQ2IOAGDJnT3BcRxGROmDoCtFYIxZruHEZnx3Kgtzt5xAeW37JgzwvUD+7vZVIwigIIg0IVZPUH55LQor6iDhGhO0CWkPjuMwLNIbAHDURnpG+GBtUJgXxvTww3PjugMAXv0hCafSS1CtbhBub/52CQAwNaaLsJRMXKgn5A4SFFTU4UpBpThPglitanUDXvvpAvZfKsCu87ntekzjzDD7ygcCAAexG0CsR3SAGzgOKKyoQ1FlHXxc5RY5b7K+5ynC1xVOMvv6FkJu3fAoH+w4lYW/rlp/EMQYw4m0EgDAwDBPAMDCMVE4l63Cvov5uP+jhGaPkUkleH58D+F3haMUg8O98MeVIvxxpYiWmCEGfj6bg4o63dDwhZz2faG115lhAPUEkSacZQ4I89atKG/J3qAM/Qsw3MfFYucknQffE3Qhp1zUte/aI7usBnnltZBKOGERWImEw5oH+2NgqKfRxyy6PapZAbuRfF7QlUKztpfYnq+OZQg/87XX2mKvM8MA6gkiN+gZ6Ia0oipcyi3HyG6+Fjkn/y2kq51VKiWm4eeuQHd/V1zOr0TCtWLc1TdQ7Ca1iM8H6tPFHc6yxrdfd4UjdiyIR229YY0ujoPRHI0RUb4AknEsrQTqBi2ttUcA6Kqnn2uylt7F3HJotAxSCdfq4zLtdGYYQD1B5AbCGmK5lkuOziimIIjcmmH6WWLWvpzEiev8UJhXs/s4joOTTGpwaylJNTrADd4uMlSrNTiTYRsJ4cT8vvpb1ws0uV8gnGVS1NZrca2w7bwxe84JoiCIGBAjOTqDeoLILRqunzFl7fWCTgpJ0caHvtpLIuGE50xT5QkAqGrq8dNZ3UzCx+LDhEkmSTmtD4k1rREU4kU9QcTO9dQXK0wtqIS6wfzLZzDGhOEwe1u4j5jOkAgvSDggragKOfr1tayNqroeKfm6Hta40OY9QR3F1wv6g5bQIAB+OJONmnoNuvu7YlCYpzCbMCm79S+0RZVq1NZrwXFAoJKCIJNZsWIFhg0bBmdnZ3h4eBjd56mnnkJcXBzkcjliYmKM7rN9+3bExMTA2dkZoaGhWL16dZvnvnz5MqZMmQIfHx+4u7tjxIgROHTo0C08G/vRRamAu8IBDVqGVAtMvy2rrhdmMtjjeDQxDXeFI/rpl9Cw1iGx0xmlYAwI83aGr9utz7zkk6PPZZV1ygVkGWNY+H+nMeOzvy3yhcyWMcbw1TFdVfEZQ0LBcRx667/QtpUczfcCBbgr7DK3zGzPWK1WY9q0aXjiiSda3W/OnDl46KGHjN63a9cuzJgxAwsWLEBSUhI2bNiAtWvXYv369a0ec/LkyWhoaMDBgwdx6tQp9O/fH5MnT0ZeXt5NPx97wXGcRYfE+KEweyzSRUxreJS+XpCVDomdTG85H+hmBCqdEOnrAi0DEq5Z53O+FbmqWvx6Lhd/pRbj7074/EzpZHopLudXwslRinsHBAGA0BN0MaccWm3LRTUz7XhmGGDGIGj58uV49tln0bdv3xb3+eCDD7Bw4UJEREQYvX/r1q2YOnUqFixYgIiICEyaNAlLlizBqlWrWqyUWlRUhCtXrmDx4sXo168funXrhrfeegvV1dVISkoyyXPr7MQIgigfiNyq4U2So62xkvIJE+UDNSVUj07tfFPlz2WVCT/vvUhfYHmpBZXYdzEfGcXVwv/5V3/reoHu6d8F7gpHAECUnytkDhJU1DUIs7+Msdc1w3hWPUW+rq4Ozs6GH45OTk7IyspCeno6wsLCmj3G29sbPXr0wBdffIEBAwZALpfj448/hp+fH+Li4lo9V11dnfB7ebnl18+yFnxC3aU8ywVBlA9EbtWAJpWUrxZWIsrPeooI1jVocDazDIDpeoIAYEQ3X2xJSMfBSwVouFsLB2nnGc5IzGwcxtl/sQCvT2HguNanend2qpp63LfhL5TX6lIIXOUO6BnohrP6azVjaFdhX0epBD0D3HA2S4Wk7HKEehuvwybMDLPT92CrfsVMmDABO3fuxIEDB6DVanH58mWsWbMGAJCba7wcOMdx2L9/P86cOQM3NzcoFAq8++672L17Nzw9W/4GtnLlSiiVSuEWEhJiludkCxp7girM/o2aagQRU1E4SoUqzH9aWbJwUnY56hq08HKRIcKERUFHdvOBl4sMOapa7L7QuXpLmvYE5ZXXCoss27NvjmegvFa3+K5MKkFlXQNOXC+FWqNFv2ClkBfH680nR7cyQ8yeq0UDHQyCFi9eDI7jWr0lJyebrHHz5s3DokWLMHnyZMhkMgwdOhTTp0/XNVxivOmMMSxcuBB+fn74448/cPz4cUydOhV33313i4ETACxZsgQqlUq4ZWY2X8zQXnTzd4WEA0qq1CioqGv7AbeAhsOIKQn1gqwsL+iUPh8oLtTTpL0ZCkcpHosPBQB8+vs1qxwGvBlaLcN5fdG/CF9d0LjvYr6YTRJdvUaLzUevAwBeu7s3Lvx3AnY/MxJrH+qPZ8Z1w7sPxjR7TJ8u/AyxloOgbKFGEAVBbXr++edx6dKlVm8t5ffcDI7jsGrVKlRWViI9PR15eXkYPHgwALR4noMHD+KXX37BN998g+HDh2PAgAHYsGEDnJycsGXLlhbPJZfL4e7ubnCzVwpHqbCERYqZV5SnIIiYEl875+9rxWjQWM+MInPkA/EeHRoKuYMEZ7NUOKZfl8zWXSuqQkVdAxSOEjwxKhIABUG/nstFrqoWPq5yTIntAkepBNEB7rg3NhjPjOuOKD/XZo/pE6T7HLuQU240QNZqGbLK7DsxukM5Qb6+vvD1tcxSCk1JpVIEBeky3r/++mvEx8e32I7qat2H6o09RRKJBFqt9bwpWrsoP1dcLazCtcJK3NbdPH/zeo1WqOlCQRAxhb5BSng4O6Ksuh4n00sxNMJb7CaBMYaTrVSKvlXernI8EBeMr45l4NPfr1nFc75V/FBY7y5K3NHLH1IJh+S8CmQUV6Ort/29VzDG8Okf1wAAM+NDIXdo30za7v5ucJBwKKlSI1dViy4ehr09hZV1UDdoIZVwCFQqTN5uW2C2nKCMjAwkJiYiIyMDGo0GiYmJSExMRGVlY+2Z1NRUJCYmIi8vDzU1NcI+arVuEcSioiJs3LgRycnJSExMxNNPP40dO3bgvffeE45x/PhxREdHIzs7GwAQHx8PT09PzJw5E2fPnsXly5fx4osvIi0tDZMmTTLX0+10Inx13yquFVWZ7Rw5ZTXQMkDuIDFJ3RRCpBIOY6P9AQB7L1hHz8HVwkqUVtdD7iARhidMbe7ICHAccCC5AKkFllvypr2+SLiORz8/1u56RnwSef9gD3g4yzBYHzza6yyxhGvFuJBTDoWjBI8MDW334xSOUqGHyNiQWNMaQZ0pqb4jzPasly5ditjYWCxbtgyVlZWIjY1FbGwsTp48Kewzd+5cxMbG4uOPP8bly5eFfXJycoR9tmzZgoEDB2L48OG4cOECDh8+LAyJAbqen5SUFNTX615cPj4+2L17NyorK3H77bdj4MCB+PPPP/Hjjz+if//+5nq6nU6kPgi62o51Z25WZkljL5C9z/ogpnNHL10QtO9SnlXkyPAVneNCPc1WjC7cxwXj9c/7sz/SzHKOm1VUWYcVv17CH1eK8OPZ7HY95qw+H6h/iC5oFP6mdjokxv9NH4gLhqeLrEOPFSpH5zSf7cu/B9vjchk8s02R37x5MzZv3tzqPocPH271fh8fHyQkJLS6z+jRo5u90Q0cOBB79uxpTzNJC/hkxGuF5usJonwgYg63dfeB3EGCzJIaJOdVCLMdxXLksq6GzygzDSvz5t8WgT0X8rHzdDaeG98dfm7WMbyxNSEddfqKz0dSCvFYfFir+6sbtLior1HWXz/b6Y5e/vjvLxdx4noJSqvUHQ4EbFlqQQUOJheA44A5w8M7/Pg+Xdzx7SngQis9Qfa4cCrPPvu/SJsifXQ9QbmqWlTpl7UwNaoRRMzBWeaAkd10AYfYQ2K19Rqh2vGoHuYNguJCvTCgqwfUGi2+OJpu1nO1V41ag61/N7bl6NVi1NZrWn1MSl4F1A1aKJ0cEarP/wnxckbPQHdoGXAwucCsbbY2n/95HQAwNtpfSFPoiD6tTJPPsvOZYQAFQaQFSmdH+Ljqvm2lmSkviGoEEXMZ31ufFyRyDsmJ6yWordfC312OHv7mL944/zbdTKqtf6ejWm2eLy8d8d3pLJRUqRHi5QR/dzlq6jU4qZ8p15Kz+qTofsFKg2FyfkhM7L+pJRVX1mHn6SwAwLyRHe8FAnR13zgOyC+vQ+ENJU/4StL2OjMMoCCItCLCzHlB1BNEzGVstB8knG5qcFYrSwaY25EU3VDYbd18LZL3dkcvf4R5O0NVU4+tCeL2Bmm0DJ//qctleXx4uDAceDil9Z6cpknRTfE5T79fLmqzN6mz+OZEJuoadIUQB4ff3MxCF7mDUKDzwg29QdQTREEQaUWkPi/oqpnygigniJiLt6tcmI4uZjLt71f0+UBmHgrjSSUc/jUmCgDwwYEryFPVWuS8xuy/lI+0oioonRwxbWAIRnX3A9CYI9WSc0JStIfB9t5d3NFFqUBNvQZ/pVpXRXBz4YdSp8UF31IQzQ+JXWiSHK3RMqFEib0umQFQEERaYc4ZYqrqeqhqdDP67HlmAjEfvudArLygnLIaXM6vhIRrXOjUEh4YEIzYrh6oUmuw4rdLFjvvjT79XVfX5pGhXeEid8CIKB9IOOBKQSWy9R++N6qqa8AV/RT//sGG5QQ4jsM4O5olxhgTlgqJCbm1IpvGKkfnl9eiXsPgIOEQ4G4dSfRioCCItIifIXa1wPRBED8W7eMqh7PMqtfxJTZqfK8AAMBx/YwiS/td3+PRP0RX68ZSJBIOr0/pAwkH/Hw2R5Rek1PppTiZXgqZVIKZ+tlgSmdHDOiq+zDnhwlvlJStgpYBgUoF/Ix8MI+J1vUmHW1jWRSNlllFeYRbkVFSjbLqesikEvQIuLV8st76ytEHkgvw9u5kqKrrhaGwLh5OkErst0QJBUGkRXxPUFpRFbRa076hNA6FUS8QMY+u3s6IDnCDRstEmVEkDIWZeWq8MX2ClEJRvaU/JkHdYNlq+Z/pqxtPje1iEMzw1+LIZeN/D34orF+w8aKSA0M9IeF07x+5KuO9SUWVdRi68gD+ufXUTbffGvDXomeg2y3XlxoU5oWR3XygbtBiw+GrGPn2QWw4nArAvvOBAAqCSCuCPZ0hk0pQ16Btsfv6ZlE+ELGE8SLNKGrQaIUiiWIEQQDw/Pge8HaR4WphlZCgbAnpxVXCivZzRxqu8Ti6h64n56/UYqOBGT8z7MZ8IJ6bwlHIbzl2zfg6afsv5qOwog4HkgtQ12C7CdT80iF9WwgIO8JRKsEXcwbjk0fj0N3fFeW1DTis742z55lhAAVBpBVSCYcwH90LxNTLZ1AQRCxhfG/dkJilZxSdzSpDRW0DPJwd0e+GWU6WonRyxJK7egLQJUnnmPiLTEt+PZ8LxoCR3XzQ/YayAL27uMPbRYbKugaczmg+VV4Iglq5ZkP0s6SOpRkfEuODT42WmbXYq7k19op5mOR4HMdhfO8A7Hr6Nqx9qL+Qi9nHBEGWLaMgiLQqQl800dR5QZk0PZ5YQNMZRX9esVxuDJ/zMiLKR9R8i/sHBGFQmCdq6jV4/ZeLFjknXwdojL7XpymJhBMWZD58Q15QSZVaWMaB7+0xZki4boFYYz1BGi3Dn01yoC7nW986au2h0TIhibmlocGbJZVwuDc2GAeeG43fnhqJR4Z0NenxbQ0FQaRVkX765TOKTBsEUU8QsQT+2y+gK9xnKZZaKqMtHMfhv1P6QCrhsCspz+gimqak1TKcvK4LTgaFGa9rM7oHnxdkGATxvUARvi5QOjm2eI5B4V7gOF3vdEG5YQmAc1llwqxTQFd92halFVWiSq2Bk6MUUTdRJbo9ZA4S9OribvfrNlIQRFrV2BNkum5ljZYhWz8zoas3BUHEvB4cGAKOA3Yl5SGhjVlFNyO1oAIVtY0fvCVVapzTBxu3iRwEAbqKwZP6BgIA/mfm3KArBZUor22As0yKnoHGZzSNiPIBxwGXcsuRrw9iclU1+FJf3LG1oTBAN8zXM0A32+lYmmFv0O+Xdb1ADvreN1vtCTqbqfv/6d3F3W5Xd7cUurqkVZF+pq8VlKuqQYOWQSaVwN9KFnkknVevLu6Yoe/yf+2nC6jXmG6m1I+J2Rj37u+Ie2M/5m45ie/PZGFXki4nJjrADf5WUn9lzgjdkgs/n8tp1ntiSif0vUADunq2+OHt7SpHP/1w17ensvDaTxcw6u3DOKCfwccHbK0ZEmE8L+gP/Yy8yf10x0i20Z6g89mmzQciLaMgiLSKrxVUUFFn8G33VvBDYcFeTpDYcX0KYjkvjO8BT2dHpORX4AsTLSfBGMNHh68C0K18vv9SPp7ddhavfJ8EwHJVotsjJsQDcaGeqNcwgwVNTY0fChsY1npxv1H6fKHVe1Kw+eh1qDVaDA73wjfzhwoFEVtjLC+ovLYeZ/RLbvCz0rJKa1BppgWgzalxlpx9Jy1bAgVBpFXuCkf4uskBwGQzLYSkaDufmkksx8NZhpcmRgMA3tt3GQUVt94bciytBMl5FVA4SrBjQTyeuj1KWGoGaCzWaC3mDNf1Bn11LMNsM+VO6JOiW8oH4o3r2Zg0PTDUE/83dwi2zR+KoRHe7ToPv47WlYJKFFfqFgU9mloMjZYhwtcFfYKUwvvWFRsbEqvXaHFRv7xF31YSxIlpUBBE2sS/sZsqOZqSookYHhoYgv7BSlTUNeCtXcm3fLzNf10HANw3IBiDwrzw3Pge2P/cKOx55jZ8/69hiAu9taUOTG1Cb38EeTihpEqNHxOzTX78nLIaZJfVQCrhENNCnR9ev2APbJo1CF/PG4odC+IxLMqnQwm6Xi4y9NBPvz+uzwvii1Pe1k3XAxetr7Jsa3lBl/MrUNeghZvCAWHeLm0/gNwSCoJIm4TV5E2UHJ2hnwZLQRCxJImEw/IpfcBxwM7T2cLQzc3IKq0WCjDOGhYmbOc4Dj0C3BDb1boCIABwkEowc5iuivTnf6aZfFmJk+m6XqDeXdzhIm97KZwx0X6Ij/S+6dlJjXlBJWCMCcuU3NZdt04bX6MoJc/0y/6Y03l9faC+QUpKF7AACoJIm/jlM0zWE1SsC6aoRhCxtJgQDzw0MAQA8J8fL6DhJpOkt/6dDi0Dhkd5NysIaM0eGtQVzjIpLudX4q9U086UE/KBQlsfCjMVfkjs72vFuF5cjazSGjhKOWFIje8pSskvb/EY1uisiYskktZREETa1LiQ6q33BOWqaoSZD9G3uCggITfjxQk9oHRyxKXc8ptaU6xGrcG2E5kAICwOaiuUTo6YFhcMAPj8z2smPXZjPpBlesH4ICglvwI/JeYA0AVg/ILM3QNssyeIXy7D1EUSiXEUBJE28cW60oqroLnFhVS/PpYBLdOVvg/zofFuYnnernLcP0AXCOxK6viaYj8mZqOsuh7Bnk4Y27PtmUzWZtbwcHAccCilsM3SF+0dMiuvrUdynq7HJc5CQZCfmwIRvi5gDPhMH9A1rcvUTV/eo6iyTkietna19RqhwCMFQZZBQRBpUxcPJ8gcJFA3aIUihzejXqPFN/pv0PwK14SIYVI/3cyt/RfzO7TIJmMMm49eB6DrBRJzSYybFe7jgrHRutlZ7+693GKgcyW/AiNWHcJz2xPbPObp9FIwBoR5O8PPgrW/+KnyFbW6afAju/kI97nIHYS8w8v5ttEbdCm3HA1aBi8XGYI87Ht1d0uhIIi0SSrhEKHvtbmVoon7LuajoKIOPq5yTOhtXdOHiX2JDfFEgLsCFXUNHVpT7O9rumnxTo5SPKjPLbJF/xoTBamEw6/nc7HuYGqz+wsr6jB78wlkl9Xg+zPZKGqjJ4VfL2xgG1PjTW1oROP5fFxl6BXobnA/n69lKzPEzjdZL8zel7OwFAqCSLsIeUG3EAR9qS/S9tCgYMgc6F+PiEci4TCxjy4Q/+18+4fENh/VLTtx34AgKJ1bXt/K2g3o6on/TukNAHh332WDKfM1ag3mbjmBLH2vL2PAoTZyp04I64VZdlYc3xME6JbjuHE2VY8A3ZBYio0EQfxyGZQUbTn0SUTahZ8hdvUmCyZeLazE0avF4Djg4cH2vWoxsQ536Zdn2HcxD+qGtmeJXcwpx96L+QAMp8XbqhlDQjFXv5zGi9+ew6n0Emi0DM9sO4OzWSp4ODvi3tggAMCBSy0HQeoGLRL1lZot3RMUoFQgXN9LbWydtsZp8rYRBJ3PLgMAYVkRYn5tF3MgBI09QXzyY0d99XcGAOD2Hn4IpkrRxAoMDPWEn5scBRV1+OtqEcb08GtxX8YY3vj1IhgDJvULRDcbmhbfmiV39cT14mrsv5SP+V+cwphoP+y5kA+ZVIJPHxsIhYMU35/Jxh9XClHXoIHcQdrsGEk5KtQ1aOHlIhOGzS1p5X198VdqEe7u36XZfT34gol5FWCMWfUQU1VdA1ILdD3tlBRtOdQTRNplYKgXpBIOZzLKhKJk7VWj1uDbU5QQTayLwZDYudxW991/qQBHrxZD5iDBYv3yG52BVMLhg4dj0LuLO4qr1Pj2VBYA4J0H+2NQmBf6BLnD312OKrUGf18zXlyysT6QpyhBxtAIbzw/vgccjSzYGuHjCgcJh4q6BuSqzLdwrCkkZaugZUCAuwJ+VrLwrj2gIIi0S4iXs1AT5bWfL7Rr+ID389kclNc2IMTLyWiXNSFi4YfE9l7Mb3F1eXWDFm/+dgmAbv2tzlbk01nmgM9nDkKA/oP3xQk9cI++V4XjONwerSsDcOBSvtHHH09r33phYpA5SIRebGvPC+IXf43t6iFqO+wNBUGk3Z65oxt8XGW4VlglJIi2x5fHdAnR/xgcapNTiknnNSjMCz6uMqhq6nH0qvEKylv/TkdaURV8XGVYOCbSwi20jAClAr89PRI7FsTjX6MNnyO/2OmBSwXNptPX1mtwMr19K8eLRZghZuV5QYkZZQDQ5rprxLQoCCLt5q5wFFbifn//FRSUt929fPJ6Cc5lqSCTSvDgwGBzN5GQDpFKOKFcw67zzYfEyqrV+ODAFQDAc3f0gJvCdmeEtcXLRYZBYV7NhrSGR/lA4ShBdlkNkm8IJLYcvY6y6noEKhXoY6XJvI3LZ1hvEMQYw+kMXY+aNa4715lREEQ65IEBwYgJ8UCVWtPmStyn0kvw+JaTAHTJpN6ucks0kZAOmaQfEttzIa/ZWmLv7b8CVU09ogPc8NAg260LdCsUjlKMiNIVIWw6JFZapcb6Q7oaQy3l5FiDxuUzrDcIylXVoqCiDlIJh75WGkx2Vtb5X0uslkTCYfk9vXUrcZ9peSXufRfz8Y9Pj0FVU4/Yrh5YOrmXhVtKSPsMDveCl4sMpdX1QvJvaZUa+y7mC7WtXp3Uy66HcvnlQfY3mSq/7mAqKmob0DPQXZhKb434nqArBZW3vOyPufAlBqID3OAkaz4Dj5gPTZEnHdZfvxL3NycysfTHC9j6+GB4uciEbvRvjmfg5e/PQ8uAsdF+WP+PAfTCJlbLQSrBhN4B+Pp4BhbvPIcGDUNek6HesdF+GNFkOQZ7xC+zcTarDAUVtahRa7D17+sAgJfvirbqALGrlzMUjhLU1muRXlyFCH3NM2tyRj8URvlAlkdBELkpL07ogd/O5+Jibjni3tgPd4UDwn1c4OUiw6EU3RT6BwcG4817+8LBSrvJCeFN7heIr49nCFWSAd2H54CuHnj5rp4itsw6+Lkr0C9YiXNZKhxKLsDvl4tQr2G4rbsvRnaz7hmfEgmH7v5uOJelwuX8CqsMghKFmWGUD2RpFASRm+LtKse7D8Zg+S8XkFlSg/LaBpzNUgn3LxoThefHd7fq4mSE8IZFeuOdaf1RrdYN70QHuHXqJOibMa6nP85lqfDx79dwrbAKHAcsudM2aiZ189MFQVfyKzGxj9itMVSv0eKc/r2TeoIsj4IgctPG9fLHuF7+qK3XIL24GmlFlbheXI3oADeMbqX6LiHWhuM4PBBHsxdbM7anH97ddxnX9EvnPDAgGD1vWLDUWgUqdTWQCipaXwhWDCl5Fahr0MJd4SBKxW17R0EQuWUKRyl6BLgJJeoJIZ1Pr0B3dFEqkKOqhcJRgufH9xC7Se3m4yoDABRVWl8QxOcD9Q/xaLYALDE/StYghBDSJo7jMFlfSXr+bZEIUNrO0g6+brq2WmUQRPlAoqKeIEIIIe3y3B3dMa6nPwZZaXXoljT2BKlFbklzfKXoWMoHEgUFQYQQQtpF4SjF4HDrWyOsLT5uukKtRVaWE1RWrca1Il2OFSVFi4OGwwghhHRqPvpq9RV1Dait14jcmkb81Pgwb2d4usjEbYydMmsQtGLFCgwbNgzOzs7w8PBodv/Zs2fx8MMPIyQkBE5OTujZsyfef//9ZvsdPnwYAwYMgFwuR1RUFDZv3tzmuc+dO4eRI0dCoVAgJCQEb7/9tgmeESGEEFvjrnCATF+vzJrygqg+kPjMGgSp1WpMmzYNTzzxhNH7T506BT8/P3z55Ze4cOECXnnlFSxZsgTr168X9klLS8OkSZMwZswYJCYm4plnnsHcuXOxZ8+eFs9bXl6O8ePHIzQ0FKdOncLq1avx2muv4ZNPPjH5cySEEGLdOI4T8oIKrWhI7AytHC86s+YELV++HABa7LmZM2eOwe8RERFISEjAzp07sWjRIgDAxo0bER4ejjVr1gAAevbsiT///BNr167FhAkTjB73q6++glqtxv/+9z/IZDL07t0biYmJePfddzF//nwTPTtCCCG2wsdNjhxVrdUkRzPGmvQEeYjaFntmdTlBKpUKXl6NiXcJCQkYN26cwT4TJkxAQkJCi8dISEjAbbfdBplMZvCYlJQUlJaWGn1MXV0dysvLDW6EEEI6B199XpAlhsO+OZ6Bj49cbXWftKIqqGrqIXOQIDrANopOdkZWFQQdPXoU27ZtM+itycvLg7+/v8F+/v7+KC8vR01NzY2HaPUx/H3GrFy5EkqlUriFhITcylMhhBBiRfjkaHPPECupUmPJ9+exclcyMoqrW9yP7wXqG6SEzMGqPortSoev/OLFi8FxXKu35OTkDjckKSkJU6ZMwbJlyzB+/PgOP/5WLVmyBCqVSrhlZmZavA2EEELMw8fNMlWjj14tAmO6n1MLK1rc7wzVB7IKHc4Jev755zFr1qxW94mIiOjQMS9evIixY8di/vz5ePXVVw3uCwgIQH5+vsG2/Px8uLu7w8nJyejxWnoMf58xcrkccrm8Q+0mhBBiG4SeIDPnBP15pUj4+WpBFW5vYY3Zc1llAHTLZRDxdDgI8vX1ha+vr8kacOHCBdx+++2YOXMmVqxY0ez++Ph4/Pbbbwbb9u3bh/j4+BaPGR8fj1deeQX19fVwdHQUHtOjRw94etJUREIIsTd8EGTO2WGMMfzRNAgqrDS6n1bLcDlfd5+tLELbWZl1IDIjIwOJiYnIyMiARqNBYmIiEhMTUVmp++MnJSVhzJgxGD9+PJ577jnk5eUhLy8PhYWFwjEWLFiAa9eu4aWXXkJycjI2bNiA7du349lnnxX2Wb9+PcaOHSv8/o9//AMymQyPP/44Lly4gG3btuH999/Hc889Z86nSwghxEr5WCAxOr24GtlljbmqLQVB2WU1qKnXQCaVIMzb2WztIW0z6xT5pUuXYsuWLcLvsbGxAIBDhw5h9OjR+Pbbb1FYWIgvv/wSX375pbBfaGgorl+/DgAIDw/Hr7/+imeffRbvv/8+goOD8dlnnxlMjy8qKsLVq42Z+EqlEnv37sXChQsRFxcHHx8fLF26lKbHE0KInfLV5wQVmjEI+jNV1wvk5SJDSZUaVwurjO53OV+XKxTh6wIHKSVFi4ljjE/hIk2Vl5dDqVRCpVLB3Z26KwkhxJapquvR/797AQDJr0+EwlFq8nMs2HoKuy/k4YnRkfjosO6L+Zn/3NFsSYyPDl/Fqt3JuLt/F6x7ONbk7bB3Hfn8phCUEEJIp+fu1Lh0RnGV6ZOjNVqGo1d1PUF39PJHF6UCAHCtqPmQ2BV9T1B3P1eTt4N0DAVBhBBCOj2O4+CtXzrDHLWCzmerUF7bADeFA/oFKRGpD3CuFjQfErtcoAuCuvm7mbwdpGMoCCKEEGIXzJkc/Zc+Hyg+whsOUgkiffVB0A3J0VotQ2qBblt3f+oJEhsFQYQQQuyCORdR/eOKblbzyG4+AIBIXxcAzYOgzNJq1NZrIXOQINTbxeTtIB1DQRAhhBC7YK6eoGp1A06nlwEARnTT1dFr7AkyHA7j6wNF+rpCKuFM2g7ScRQEEUIIsQs+buapGn08rQRqjRZBHk5C3Z8IfRCUUVINdYNW2JefHt+DhsKsAgVBhBBC7AK/krypawXxS2WMiPIBx+l6d/zd5XCRSaHRMmSUNPYG8UEQJUVbBwqCCCGE2AWhJ8jEOUF8kcTh+nwgQDcbjZ8hllrQNAjik6IpCLIGFAQRQgixC3xitClzggor6pCcp+vdGR7pbXDfjTPENFom/Ewzw6wDBUGEEELsgq8ZFlHlCyT2CnSHt/74vBtniKUXV0HdoIXCUYIQT1ozzBpQEEQIIcQu8LPDymsbUNegMckxhXygJkNhvBtniPFDYVF+rpDQzDCrQEEQIYQQu6B0coSDPvgoNsEMMcYYjl4tBgAMj2oeBPEzxK4VVoIx1mS5DMoHshYUBBFCCLELEkmTpTNuyAtSN2ix8chVXC8yvvK7MRkl1cguq4GjlMOgMM9m94d6O0PCARW1DSisrMNlfaVomhlmPSgIIoQQYjd83YwXTNx+MhNv7UrGP7eeglbL2nWsv1J1vUCxIZ5wljk0u1/hKEWIly7352pBVWNPECVFWw0KggghhNgNoWp0heFw2LG0EgBASn4Fdl/Ia9ex+KToYVHeLe7D5wVdzq/ANX1uEE2Ptx4UBBFCCLEbPi0UTDx1vUT4+YMDV9rsDdJqGRL0+UDDIpvnA/H4GWIHkgug1mjh5ChFkIfTTbWdmB4FQYQQQuyGj5Fp8jllNchR1UIq4eAmd0ByXgX2tNEbdLmgAsVVajg5ShET4tHifnxP0FF9QcVu/jQzzJpQEEQIIcRuGCuYeDK9FICu1s/sEeEAgPfb6A3i84EGhXtB5tDyRyk/Q6xBf6xuNDPMqlAQRAghxG4YS4zmh8LiQj3x+PBwoTdo78WWe4MS9PlAN1aJvhE/HMbrEUBJ0daEgiBCCCF2Q0iMblIn6FSGricoLtQTSmdHzB4eBgB4b7/x3qAGjRbHrukCJ2P1gZrycpHBw9lR+J2mx1sXCoIIIYTYjRt7gqrqGnApVzd1faC+1s+cEa33Bp3LVqGirgFKJ0f0DHRv9Xwcxwl5QQDNDLM2FAQRQgixG3xPUFl1PdQNWiRmlkGjZQjycEKgUjdry8NZhln63qD3D6Q26w3iZ4XFR3hD2o4kZ35IzFXugC5KhameCjEBCoIIIYTYDQ8nRyFwKa6qw8nrjUNhTT0+Ihyucgdcyi3H//5KM7jvr9S26wM1xSdHR/m5guNoZpg1oSCIEEKI3ZBIOHi76GeIVahxMl2X2zPwhmUvPJxleHFCDwDAm79dwsHkfABAbb1GmE3WWn2gpib0DkA3P1f8Y3BXkzwHYjoUBBFCCLEr/JBYQUUtzmSUAWjeEwQAj8WH4uHBIdAy4KmvE5GSV4HT6aVQN2jh7y5vNvOrJeE+Ltj33Cg8OCjEZM+BmAYFQYQQQuyKjz45+q/UYlTWNcBV7oDogOYJzhzHYfk9fTA0wguVdQ14fMsJ/HwuF4CuF4iGtmwfBUGEEELsCl8wka8KHdvVo8UEZ5mDBB/NiEOotzOySmvw9fEMAMCwNuoDEdtAQRAhhBC7wk+Tzy6rAQAM6Np8KKwpTxcZPp85CG6KxpXih7VRH4jYBgqCCCGE2BVffU4Q78akaGOi/Fzx4T8GwEHCoW+QkhZB7SQc2t6FEEII6Tx8mgRBEg6IbaMniHdbd18ceWmMQY8QsW30lySEEGJXmgZB0QHucJW3/6OQeoA6FxoOI4QQYld83GTCz+0ZCiOdFwVBhBBC7ErTniBj9YGI/aAgiBBCiF3xdJbBRSYFxwGDwrzEbg4REeUEEUIIsStSCYePHx2IKnUDulCOj12jIIgQQojdGdGN6vwQGg4jhBBCiJ2iIIgQQgghdomCIEIIIYTYJQqCCCGEEGKXKAgihBBCiF0yaxC0YsUKDBs2DM7OzvDw8Gh2/9mzZ/Hwww8jJCQETk5O6NmzJ95///1m+x0+fBgDBgyAXC5HVFQUNm/e3Op5Dx8+jClTpiAwMBAuLi6IiYnBV199ZaJnRQghhJDOwKxBkFqtxrRp0/DEE08Yvf/UqVPw8/PDl19+iQsXLuCVV17BkiVLsH79emGftLQ0TJo0CWPGjEFiYiKeeeYZzJ07F3v27GnxvEePHkW/fv3w3Xff4dy5c5g9ezYee+wx/PLLLyZ/joQQQgixTRxjjJn7JJs3b8YzzzyDsrKyNvdduHAhLl26hIMHDwIA/v3vf+PXX39FUlKSsM/06dNRVlaG3bt3t7sNkyZNgr+/P/73v/+1a//y8nIolUqoVCq4u7u3+zyEEEIIEU9HPr+tLidIpVLBy6uxjHlCQgLGjRtnsM+ECROQkJBwS8e9UV1dHcrLyw1uhBBCCOm8rCoIOnr0KLZt24b58+cL2/Ly8uDv72+wn7+/P8rLy1FTU9Ou427fvh0nTpzA7NmzW9xn5cqVUCqVwi0kJOTmngQhhBBCbEKHg6DFixeD47hWb8nJyR1uSFJSEqZMmYJly5Zh/PjxHX58Sw4dOoTZs2fj008/Re/evVvcb8mSJVCpVMItMzPTZG0ghBBCiPXp8Nphzz//PGbNmtXqPhERER065sWLFzF27FjMnz8fr776qsF9AQEByM/PN9iWn58Pd3d3ODm1vvDdkSNHcPfdd2Pt2rV47LHHWt1XLpdDLpd3qN2EEEIIsV0dDoJ8fX3h6+trsgZcuHABt99+O2bOnIkVK1Y0uz8+Ph6//fabwbZ9+/YhPj6+1eMePnwYkydPxqpVqwyG1wghhBBCADOvIp+RkYGSkhJkZGRAo9EgMTERABAVFQVXV1ckJSXh9ttvx4QJE/Dcc88hLy8PACCVSoVAa8GCBVi/fj1eeuklzJkzBwcPHsT27dvx66+/CudZv349vv/+exw4cACAbghs8uTJePrpp3H//fcLx5XJZK0mRzfFT5qjBGlCCCHEdvCf2+2a/M7MaObMmQxAs9uhQ4cYY4wtW7bM6P2hoaEGxzl06BCLiYlhMpmMRUREsE2bNhncv2zZMoPHtHTeUaNGtbvtmZmZRo9BN7rRjW50oxvdrP+WmZnZ5me9ReoE2SKtVoucnBy4ubmB4ziTHru8vBwhISHIzMykGkQWQNfbsuh6WxZdb8ui621ZN3O9GWOoqKhAly5dIJG0Pv/LrMNhtkwikSA4ONis53B3d6cXkQXR9bYsut6WRdfbsuh6W1ZHr7dSqWzXflZVJ4gQQgghxFIoCCKEEEKIXaIgSARyuRzLli2jukQWQtfbsuh6WxZdb8ui621Z5r7elBhNCCGEELtEPUGEEEIIsUsUBBFCCCHELlEQRAghhBC7REEQIYQQQuwSBUGEEEIIsUsUBFnYhx9+iLCwMCgUCgwZMgTHjx8Xu0mdwsqVKzFo0CC4ubnBz88PU6dORUpKisE+tbW1WLhwIby9veHq6or7778f+fn5IrW4c3nrrbfAcRyeeeYZYRtdb9PKzs7GI488Am9vbzg5OaFv3744efKkcD9jDEuXLkVgYCCcnJwwbtw4XLlyRcQW2y6NRoP//Oc/CA8Ph5OTEyIjI/H6668bLMhJ1/vm/f7777j77rvRpUsXcByHH374weD+9lzbkpISzJgxA+7u7vDw8MDjjz+OysrKDreFgiAL2rZtG5577jksW7YMp0+fRv/+/TFhwgQUFBSI3TSbd+TIESxcuBB///039u3bh/r6eowfPx5VVVXCPs8++yx+/vln7NixA0eOHEFOTg7uu+8+EVvdOZw4cQIff/wx+vXrZ7CdrrfplJaWYvjw4XB0dMSuXbtw8eJFrFmzBp6ensI+b7/9Nj744ANs3LgRx44dg4uLCyZMmIDa2loRW26bVq1ahY8++gjr16/HpUuXsGrVKrz99ttYt26dsA9d75tXVVWF/v3748MPPzR6f3uu7YwZM3DhwgXs27cPv/zyC37//XfMnz+/441p97Lq5JYNHjyYLVy4UPhdo9GwLl26sJUrV4rYqs6poKCAAWBHjhxhjDFWVlbGHB0d2Y4dO4R9Ll26xACwhIQEsZpp8yoqKli3bt3Yvn372KhRo9jTTz/NGKPrbWr//ve/2YgRI1q8X6vVsoCAALZ69WphW1lZGZPL5ezrr7+2RBM7lUmTJrE5c+YYbLvvvvvYjBkzGGN0vU0JAPv++++F39tzbS9evMgAsBMnTgj77Nq1i3Ecx7Kzszt0fuoJshC1Wo1Tp05h3LhxwjaJRIJx48YhISFBxJZ1TiqVCgDg5eUFADh16hTq6+sNrn90dDS6du1K1/8WLFy4EJMmTTK4rgBdb1P76aefMHDgQEybNg1+fn6IjY3Fp59+KtyflpaGvLw8g+utVCoxZMgQut43YdiwYThw4AAuX74MADh79iz+/PNP3HnnnQDoeptTe65tQkICPDw8MHDgQGGfcePGQSKR4NixYx06H60ibyFFRUXQaDTw9/c32O7v74/k5GSRWtU5abVaPPPMMxg+fDj69OkDAMjLy4NMJoOHh4fBvv7+/sjLyxOhlbbvm2++wenTp3HixIlm99H1Nq1r167ho48+wnPPPYeXX34ZJ06cwFNPPQWZTIaZM2cK19TY+wtd745bvHgxysvLER0dDalUCo1GgxUrVmDGjBkAQNfbjNpzbfPy8uDn52dwv4ODA7y8vDp8/SkIIp3OwoULkZSUhD///FPspnRamZmZePrpp7Fv3z4oFAqxm9PpabVaDBw4EG+++SYAIDY2FklJSdi4cSNmzpwpcus6n+3bt+Orr77C//3f/6F3795ITEzEM888gy5dutD17mRoOMxCfHx8IJVKm82Oyc/PR0BAgEit6nwWLVqEX375BYcOHUJwcLCwPSAgAGq1GmVlZQb70/W/OadOnUJBQQEGDBgABwcHODg44MiRI/jggw/g4OAAf39/ut4mFBgYiF69ehls69mzJzIyMgBAuKb0/mIaL774IhYvXozp06ejb9++ePTRR/Hss89i5cqVAOh6m1N7rm1AQECzCUUNDQ0oKSnp8PWnIMhCZDIZ4uLicODAAWGbVqvFgQMHEB8fL2LLOgfGGBYtWoTvv/8eBw8eRHh4uMH9cXFxcHR0NLj+KSkpyMjIoOt/E8aOHYvz588jMTFRuA0cOBAzZswQfqbrbTrDhw9vVvLh8uXLCA0NBQCEh4cjICDA4HqXl5fj2LFjdL1vQnV1NSQSw49HqVQKrVYLgK63ObXn2sbHx6OsrAynTp0S9jl48CC0Wi2GDBnSsRPeUlo36ZBvvvmGyeVytnnzZnbx4kU2f/585uHhwfLy8sRums174oknmFKpZIcPH2a5ubnCrbq6WthnwYIFrGvXruzgwYPs5MmTLD4+nsXHx4vY6s6l6ewwxuh6m9Lx48eZg4MDW7FiBbty5Qr76quvmLOzM/vyyy+Ffd566y3m4eHBfvzxR3bu3Dk2ZcoUFh4ezmpqakRsuW2aOXMmCwoKYr/88gtLS0tjO3fuZD4+Puyll14S9qHrffMqKirYmTNn2JkzZxgA9u6777IzZ86w9PR0xlj7ru3EiRNZbGwsO3bsGPvzzz9Zt27d2MMPP9zhtlAQZGHr1q1jXbt2ZTKZjA0ePJj9/fffYjepUwBg9LZp0yZhn5qaGvavf/2LeXp6MmdnZ3bvvfey3Nxc8RrdydwYBNH1Nq2ff/6Z9enTh8nlchYdHc0++eQTg/u1Wi37z3/+w/z9/ZlcLmdjx45lKSkpIrXWtpWXl7Onn36ade3alSkUChYREcFeeeUVVldXJ+xD1/vmHTp0yOj79cyZMxlj7bu2xcXF7OGHH2aurq7M3d2dzZ49m1VUVHS4LRxjTUpgEkIIIYTYCcoJIoQQQohdoiCIEEIIIXaJgiBCCCGE2CUKggghhBBilygIIoQQQohdoiCIEEIIIXaJgiBCCCGE2CUKggghhBBilygIIoQQQohdoiCIEEIIIXaJgiBCCCGE2KX/B2Vy3yv7CIOEAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pd.DataFrame(FDS.smoothed_mean_last_epoch.numpy()).iloc[:, 7].plot(\n", - " title=\"Smoothed mean bina values for 'Longitude' feature\"\n", - ");" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "7afc8719", - "metadata": {}, - "outputs": [], - "source": [ - "smoothed_features = FDS._smooth(torch.clone(features).detach(), labels, epoch).numpy()\n", - "left_bin_edges_indices = find_bin(\n", - " FDS.bin_edges, labels.squeeze(), ret_value=False\n", - ").numpy()\n", - "continuous_cols = df.drop(columns=[\"MedHouseVal\"]).columns.values.tolist()\n", - "\n", - "df_w_bins = df.copy()\n", - "df_w_bins[\"MedHouseVal_bins\"] = left_bin_edges_indices\n", - "df_smoothed_w_bins = df_w_bins.copy()\n", - "df_smoothed_w_bins[continuous_cols] = smoothed_features" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "d3e732b1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGzCAYAAADaCpaHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABvIElEQVR4nO3dd3xUVfo/8M/MJDPpk95DINQAoSuCgEAQRFRsgOz+VljF7lrXgq4CrlhQV113bbsKlq/SxLKKItKbCEgChIQSEpIQ0ntPZs7vj8m9mUkmlUzmzuTzfr3yIty5c+fc3CnPnPOc56iEEAJEREREDkpt7wYQERERXQoGM0REROTQGMwQERGRQ2MwQ0RERA6NwQwRERE5NAYzRERE5NAYzBAREZFDYzBDREREDo3BDBERETk0BjOkaDt37oRKpcLOnTt75PGmTp2KqVOndusxP/vsMwwZMgSurq7w9fXt1mP3RmvWrIFKpUJ6erq9m9JCeno6VCoVXn/99W497pkzZzBz5kzo9XqoVCp888033Xp8JVCpVFi+fLn8f2vXuW/fvrjuuut6vnHN2OJ9gi4Ng5leTnrDOHz4sL2b0mFffPEF3nrrLXs3o0NSUlKwePFi9O/fH//5z3/w4Ycf2uRx9u/fj+XLl6OkpMQmxyf7WrRoEY4fP46VK1fis88+w7hx4+zdJKd38uRJLF++XJFBM7XkYu8GELVlypQpqK6uhlarlbd98cUXOHHiBB555BH7NayDdu7cCaPRiLfffhsDBgyw2ePs378fK1aswOLFi9n742Sqq6tx4MABPPvss3jwwQft3Zwe86c//Qm33XYbdDqdXR7/5MmTWLFiBaZOnYq+ffta3Pbzzz/bpU3UOvbMkKKp1Wq4ublBrXbMp2peXh4AOGyAUVlZae8m9Hr5+fkAuvc55AjXVaPRwM3NDSqVqluO153nrNVqLb5gkf055icE9bijR49i9uzZ8PHxgZeXF+Lj4/Hrr79a7CMNWe3btw+PPfYYgoKC4OnpiZtuukl+Q5YYjUYsX74c4eHh8PDwwLRp03Dy5En07dsXixcvlvdrnjMzdepU/PDDDzh//jxUKhVUKpX8ram1XIrW8m4+/PBD9O/fH+7u7rj88suxZ88eq+deW1uLZcuWYcCAAdDpdIiKisKTTz6J2traNv9mffv2xbJlywAAQUFBLXICfvzxR0yePBmenp7w9vbGnDlzkJSUZHGMY8eOYfHixYiJiYGbmxtCQ0Nxxx13oLCwUN5n+fLleOKJJwAA/fr1k/8u6enpcg7HmjVrWrSveXuWL18OlUqFkydP4g9/+AP8/PwwadIk+fbPP/8cY8eOhbu7O/z9/XHbbbchMzOzzb/Bxo0boVKpsGvXrha3ffDBB1CpVDhx4kSHz7U1zc9F0vz5BAAlJSV45JFHEBUVBZ1OhwEDBuDVV1+F0Wi02G/t2rUYO3YsvL294ePjg7i4OLz99tvttkXy5ptvIjo6Gu7u7rjqqqvk8zSXkpKCW2+9Ff7+/nBzc8O4cePw3XffybcvX74c0dHRAIAnnnjC4vkOdO51uWvXLtx///0IDg5GZGSkfHtHnoetKSkpwaOPPoq+fftCp9MhMjISt99+OwoKCgAAdXV1eP755zF27Fjo9Xp4enpi8uTJ2LFjR7vHbis36ueff8aoUaPg5uaGoUOHYtOmTR0+5/Pnz+P+++/H4MGD4e7ujoCAAMybN8/icdasWYN58+YBAKZNmya/pszfh5rnzOTl5eHOO+9ESEgI3NzcMHLkSHzyyScW+5jnVEnvPzqdDpdddhkOHTrU7t+EWsdhJmpXUlISJk+eDB8fHzz55JNwdXXFBx98gKlTp2LXrl0YP368xf5/+ctf4Ofnh2XLliE9PR1vvfUWHnzwQaxbt07eZ+nSpVi1ahWuv/56zJo1C4mJiZg1axZqamrabMuzzz6L0tJSZGVl4c033wQAeHl5dfqcPvroI9xzzz2YOHEiHnnkEZw7dw433HAD/P39ERUVJe9nNBpxww03YO/evbj77rsRGxuL48eP480338Tp06fbTMR866238Omnn+Lrr7/Ge++9By8vL4wYMQKAKSl40aJFmDVrFl599VVUVVXhvffew6RJk3D06FH5A2vr1q04d+4c/vznPyM0NBRJSUn48MMPkZSUhF9//RUqlQo333wzTp8+jS+//BJvvvkmAgMDAZgCqOZBZEfMmzcPAwcOxEsvvQQhBABg5cqVeO655zB//nwsWbIE+fn5eOeddzBlyhQcPXq01V6DOXPmwMvLC+vXr8dVV11lcdu6deswbNgwDB8+vMPneqmqqqpw1VVX4cKFC7jnnnvQp08f7N+/H0uXLsXFixflXKytW7di4cKFiI+Px6uvvgoASE5Oxr59+/Dwww+3+ziffvopysvL8cADD6CmpgZvv/02pk+fjuPHjyMkJASA6XV15ZVXIiIiAk8//TQ8PT2xfv163Hjjjfjqq69w00034eabb4avry8effRRLFy4ENdee638fO/s6/L+++9HUFAQnn/+ebmXoqPPQ2sqKiowefJkJCcn44477sCYMWNQUFCA7777DllZWQgMDERZWRn++9//YuHChbjrrrtQXl6Ojz76CLNmzcJvv/2GUaNGdfIKmpKhFyxYgHvvvReLFi3C6tWrMW/ePPz000+4+uqr2z3nQ4cOYf/+/bjtttsQGRmJ9PR0vPfee5g6dSpOnjwJDw8PTJkyBQ899BD++c9/4plnnkFsbCwAyP82V11djalTp+Ls2bN48MEH0a9fP2zYsAGLFy9GSUlJi+fMF198gfLyctxzzz1QqVRYtWoVbr75Zpw7dw6urq6d/psQAEG92urVqwUAcejQoVb3ufHGG4VWqxWpqanytuzsbOHt7S2mTJnS4lgzZswQRqNR3v7oo48KjUYjSkpKhBBC5OTkCBcXF3HjjTdaPM7y5csFALFo0SJ5244dOwQAsWPHDnnbnDlzRHR0dKvnkpaWZrG9+THq6upEcHCwGDVqlKitrZX3+/DDDwUAcdVVV8nbPvvsM6FWq8WePXssjvn+++8LAGLfvn1W/2aSZcuWCQAiPz9f3lZeXi58fX3FXXfdZbFvTk6O0Ov1FturqqpaHPPLL78UAMTu3bvlba+99prVc09LSxMAxOrVq1scB4BYtmxZi7YuXLjQYr/09HSh0WjEypUrLbYfP35cuLi4tNje3MKFC0VwcLBoaGiQt128eFGo1WrxwgsvdPpcrV3n5uciiY6Otng+/f3vfxeenp7i9OnTFvs9/fTTQqPRiIyMDCGEEA8//LDw8fGxaHNHSH9vd3d3kZWVJW8/ePCgACAeffRReVt8fLyIi4sTNTU18jaj0SgmTpwoBg4c2OKYr732msVjdfZ1OWnSJIvz6czz0Jrnn39eABCbNm1qcZv0+m9oaLB4jQkhRHFxsQgJCRF33HGHxfbm19DadY6OjhYAxFdffSVvKy0tFWFhYWL06NHtnrMQ1p9nBw4cEADEp59+Km/bsGFDi/ceyVVXXWXxPvHWW28JAOLzzz+Xt9XV1YkJEyYILy8vUVZWJoRoupYBAQGiqKhI3vfbb78VAMT//ve/Fo9FHcNhJmqTwWDAzz//jBtvvBExMTHy9rCwMPzhD3/A3r17UVZWZnGfu+++2+Jb9OTJk2EwGHD+/HkAwLZt29DQ0ID777/f4n5/+ctfbHgmTQ4fPoy8vDzce++9FuPeixcvhl6vt9h3w4YNiI2NxZAhQ1BQUCD/TJ8+HQA61F3e3NatW1FSUoKFCxdaHFOj0WD8+PEWx3R3d5d/r6mpQUFBAa644goAwO+//97px+6Ie++91+L/mzZtgtFoxPz58y3aGxoaioEDB7b7N1iwYAHy8vIshvk2btwIo9GIBQsWyNt64lw3bNiAyZMnw8/Pz+JcZsyYAYPBgN27dwMw5adUVlZi69atXXqcG2+8EREREfL/L7/8cowfPx6bN28GABQVFWH79u2YP38+ysvL5XYUFhZi1qxZOHPmDC5cuNDq8bvyurzrrrug0Wjk/3fmeWjNV199hZEjR+Kmm25qcZv0+tdoNPJrzGg0oqioCA0NDRg3blyXr2l4eLjFY/r4+OD222/H0aNHkZOT0+Y5A5bPs/r6ehQWFmLAgAHw9fXtcps2b96M0NBQLFy4UN7m6uqKhx56CBUVFS2GWRcsWAA/Pz/5/5MnTwYAnDt3rkuPTxxmonbk5+ejqqoKgwcPbnFbbGwsjEYjMjMzMWzYMHl7nz59LPaTXrTFxcUAIAc1zWf3+Pv7W7zAbUV6/IEDB1psd3V1tfhgAExd2snJyQgKCrJ6LCnBtzPOnDkDAHJA1JyPj4/8e1FREVasWIG1a9e2eKzS0tJOP3ZH9OvXz+L/Z86cgRCixd9L0l63+DXXXAO9Xo9169YhPj4egGmIadSoURg0aJC8X0+c65kzZ3Ds2LF2r+f999+P9evXY/bs2YiIiMDMmTMxf/58XHPNNR16HGt/q0GDBmH9+vUAgLNnz0IIgeeeew7PPfdcq20xD4jMdeV1ae26Ah17HlqTmpqKW265pc19AOCTTz7BG2+8gZSUFNTX17fano4aMGBAiyFH6XmUnp6O0NDQNh+juroaL7/8MlavXo0LFy7IQ6lA159n58+fx8CBA1tMVJCGpaT3HEl775HUeQxmqNs1/yYkMX/TsIXWcioMBkOXj2k0GhEXF4d//OMfVm83z6/pzDEBU76C+RuvxMWl6WU5f/587N+/H0888QRGjRoFLy8vGI1GXHPNNS0SVq3pyt/E/Jur1F6VSoUff/zR6rVtL2dJp9PhxhtvxNdff413330Xubm52LdvH1566SWL/S71XK1pfp5GoxFXX301nnzySav7Sx+KwcHBSEhIwJYtW/Djjz/ixx9/xOrVq3H77be3SOrsCul8/vrXv2LWrFlW9+nuqfzWrivQsedhV33++edYvHgxbrzxRjzxxBMIDg6GRqPByy+/jNTU1Es+fnuanzNg6gFevXo1HnnkEUyYMEEuRHjbbbd1+XnWWfZ6j3RmDGaoTUFBQfDw8MCpU6da3JaSkgK1Wt3pD3RpdsbZs2ctvjkVFhZ26JtJax/Q0reb5oXjmn8rkh7/zJkzFt9K6+vrkZaWhpEjR8rb+vfvj8TERMTHx3fbFNH+/fsDMH1gzpgxo9X9iouLsW3bNqxYsQLPP/+8vF36Rm3uUv8m7bVXCIF+/fpZ9KR0xoIFC/DJJ59g27ZtSE5OhhDCYoipM+dqjZ+fX4tzrKurw8WLF1ucS0VFRZt/d4lWq8X111+P66+/HkajEffffz8++OADPPfcc+0GGtbaffr0aTmhVuoBdHV17VBbmuuO12VHn4dt3d/aDC1zGzduRExMDDZt2mTxHJVm+XWF1KtlfrzTp08DQJsJy+ZtWrRoEd544w15W01NTYvnT2de79HR0Th27BiMRqNF70xKSop8O9kWc2aoTRqNBjNnzsS3335rMXUxNzcXX3zxBSZNmtRud3Rz8fHxcHFxwXvvvWex/V//+leH7u/p6Wm1O1h6c5byHgDTN/PmVXfHjRuHoKAgvP/++6irq5O3r1mzpsUb2vz583HhwgX85z//afF41dXVXapdMWvWLPj4+OCll16y6HaXSDOQpG9vzb+tWat+7OnpCaBl0OLj44PAwECLvwkAvPvuux1u78033wyNRoMVK1a0aIsQokNTp2fMmAF/f3+sW7cO69atw+WXX24RyHbmXK3p379/i3P88MMPW/TMzJ8/HwcOHMCWLVtaHKOkpAQNDQ0A0OKc1Gq1PBOtvSn5APDNN99Y5Lz89ttvOHjwIGbPng3AFEBMnToVH3zwQYuAC0C7s9C643XZ0edha2655RYkJibi66+/bnGbdB2tXdeDBw/iwIEDbR67LdnZ2RaPWVZWhk8//RSjRo2y2sPUnEajafE8e+edd1o8V1p7TVlz7bXXIicnx2LGZkNDA9555x14eXm1mMlH3Y89MwQA+Pjjj/HTTz+12P7www/jxRdfxNatWzFp0iTcf//9cHFxwQcffIDa2lqsWrWq048VEhKChx9+GG+88QZuuOEGXHPNNUhMTMSPP/6IwMDAdr8RjR07FuvWrcNjjz2Gyy67DF5eXrj++usxbNgwXHHFFVi6dCmKiorg7++PtWvXyh9QEldXV7z44ou45557MH36dCxYsABpaWlYvXp1i5yZP/3pT1i/fj3uvfde7NixA1deeSUMBgNSUlKwfv16bNmypdOl5X18fPDee+/hT3/6E8aMGYPbbrsNQUFByMjIwA8//IArr7wS//rXv+Dj44MpU6Zg1apVqK+vR0REBH7++WekpaVZ/ZsApqnrt912G1xdXXH99dfD09MTS5YswSuvvIIlS5Zg3Lhx2L17t/xNtiP69++PF198EUuXLkV6ejpuvPFGeHt7Iy0tDV9//TXuvvtu/PWvf23zGK6urrj55puxdu1aVFZWtli7qDPnas2SJUtw77334pZbbsHVV1+NxMREbNmyRZ6mLnniiSfw3Xff4brrrsPixYsxduxYVFZW4vjx49i4cSPS09MRGBiIJUuWoKioCNOnT0dkZCTOnz+Pd955B6NGjWp1eq65AQMGYNKkSbjvvvtQW1uLt956CwEBARbDW//+978xadIkxMXF4a677kJMTAxyc3Nx4MABZGVlITExsc3HuNTXZUefh6154oknsHHjRsybNw933HEHxo4di6KiInz33Xd4//33MXLkSFx33XXYtGkTbrrpJsyZMwdpaWl4//33MXToUFRUVLTbRmsGDRqEO++8E4cOHUJISAg+/vhj5ObmYvXq1R26/3XXXYfPPvsMer0eQ4cOxYEDB/DLL78gICDAYr9Ro0ZBo9Hg1VdfRWlpKXQ6HaZPn47g4OAWx7z77rvxwQcfYPHixThy5Aj69u2LjRs3Yt++fXjrrbfg7e3dpXOlTrDDDCpSEGkKY2s/mZmZQgghfv/9dzFr1izh5eUlPDw8xLRp08T+/futHqv5NG9r06sbGhrEc889J0JDQ4W7u7uYPn26SE5OFgEBAeLee+9t874VFRXiD3/4g/D19RUALKZpp6amihkzZgidTidCQkLEM888I7Zu3Wp1iuW7774r+vXrJ3Q6nRg3bpzYvXt3iymXQpimWL766qti2LBhQqfTCT8/PzF27FixYsUKUVpa2ubf19rUbPNzmzVrltDr9cLNzU30799fLF68WBw+fFjeJysrS9x0003C19dX6PV6MW/ePJGdnW11KvLf//53ERERIdRqtcWU1qqqKnHnnXcKvV4vvL29xfz580VeXl6rU7OttVUIIb766isxadIk4enpKTw9PcWQIUPEAw88IE6dOtXm30AiXQeVSiU/r8x19FytTdk1GAziqaeeEoGBgcLDw0PMmjVLnD17tsXUbCFMU5KXLl0qBgwYILRarQgMDBQTJ04Ur7/+uqirqxNCCLFx40Yxc+ZMERwcLLRarejTp4+45557xMWLF9s8R/Np1G+88YaIiooSOp1OTJ48WSQmJrbYPzU1Vdx+++0iNDRUuLq6ioiICHHdddeJjRs3Wj1mc5fyupR05HnYmsLCQvHggw+KiIgIodVqRWRkpFi0aJEoKCgQQpimaL/00ksiOjpa6HQ6MXr0aPH999+LRYsWtSiv0JHrHB0dLebMmSO2bNkiRowYIXQ6nRgyZIjYsGFDh8+5uLhY/PnPfxaBgYHCy8tLzJo1S6SkpFh9rvznP/8RMTExQqPRWLyHWHufyM3NlY+r1WpFXFxci5IIbV1La69p6jiVEMw4ImUoKSmBn58fXnzxRTz77LP2bg4RETkI5syQXVRXV7fYJuVHNC8TTkRE1BbmzJBdrFu3DmvWrJHLs+/duxdffvklZs6ciSuvvNLezSMiIgfCYIbsYsSIEXBxccGqVatQVlYmJwW/+OKL9m4aERE5GObMEBERkUNjzgwRERE5NAYzRERE5NB6Rc6M0WhEdnY2vL29u60kPREREdmWEALl5eUIDw9vsZCnuV4RzGRnZ3dpQUAiIiKyv8zMTERGRrZ6e68IZqRS0pmZmZ1eR4iIiIjso6ysDFFRUe0uCdErghlpaMnHx4fBDBERkYNpL0WECcBERETk0BjMEBERkUNjMENEREQOjcEMEREROTQGM0REROTQGMwQERGRQ2MwQ0RERA6NwQwRERE5NAYzRERE5NAYzBAREZFDYzBDREREDo3BDBERETk0BjNOav3hTOw7W2DvZhAREdlcr1g1u7c5mV2GJzceAwCkvzLHzq0hIiKyLfbMOKGcsmp7N4GIiKjHMJhxQiqVyt5NICIi6jEMZpyQmsEMERH1IgxmnJDaLJYRQtivIURERD2AwYwTMu+ZMTKWISIiJ8dgxgmZjzI1GI32awgREVEPYDDjhMx7ZhoM7JohIiLnxmDGCVkEMxxnIiIiJ8dgxgmZDzMZGMwQEZGTYzDj5JgzQ0REzo7BjBMymvXGsGeGiIicHYMZJ2QevzABmIiInB2DGSdkXiiPPTNEROTsGMw4IYueGQYzRETk5BjMOCEje2aIiKgXYTDjhMyDmXoDZzMREZFzYzDjhMzXlmTPDBEROTsGM07IPIBhzgwRETk7BjNOiDkzRETUmzCYcUKWs5mYM0NERM6NwYwTYp0ZIiLqTRjMOCHWmSEiot6EwYwTssiZ4XIGRETk5BjMOCHzYIY9M0RE5OwYzDghwQRgIiLqRRjMOCFOzSYiot6EwYwTsiiax5wZIiJycgxmnBCXMyAiot6EwYwTYgIwERH1Ji72bgB1H4NRoLKuwaLOjIEJwERE5OTYM+NEbn5vP0Ys/xl55TXyNvbMEBGRs2Mw40QSM0sAADtS8uRtzJkhIiJnx2DGSdTUG+Tffdxd5d/rOZuJiKw4mV2GKat2YM2+NHs3heiSMZhxEoWVdfLvdQ1NeTLMmSEia6795x5kFFVh+f9O2rspRJeMwYyTKCivlX+/UFIt/86cGSJqjsPP5GwYzDiJgoqmYOZiaVMCMN+0iKi52gZD+zsRORAGM07CPJixqADMYIaImqmptxx+FoLvE+TYGMw4iXyzYSZz7JkhoubMJwwAnChAjo/BjJMoqKizup1rMxFRc7UNlj0zdQZOFCDHxmDGSeRXtNYzwzcpIrLUvGemroHvE+TYGMw4iYJWhpmYM0NEzTUPZpgQTI6OwYyTaK1nhsNMRNRc8wRg9syQo2Mw4ySknpkIX3eL7eyZIaLmahqa98wwmCHHxmDGCdQ2GFBW0wAAGBGpt7iNOTNE1Fwtc2bIyTCYcQKFjTOZXDUqxIb5WNzGnhkiaq55TwxzZsjRMZhxAlLBvABPXYthJtaZIaLmWiYAs2eGHBuDGScgFcwL9NYiwo85M0TUNiYAk7NhMOMEpJ6ZIC/2zBBR+9gzQ87GZsHMypUrMXHiRHh4eMDX19fqPg899BDGjh0LnU6HUaNGWd1HCIHXX38dgwYNgk6nQ0REBFauXGmrZjskqfpvoJcOIT5uUKmabmPPDBE1x54ZcjYutjpwXV0d5s2bhwkTJuCjjz5qdb877rgDBw8exLFjx6ze/vDDD+Pnn3/G66+/jri4OBQVFaGoqMhWzXZITcNMOmhd1Aj21iG3zLSNs5mIqDlOzSZnY7NgZsWKFQCANWvWtLrPP//5TwBAfn6+1WAmOTkZ7733Hk6cOIHBgwcDAPr169f9jXVw0jBToJcOABDu6y4HM1xAjoiaq2XPDDkZRefM/O9//0NMTAy+//579OvXD3379sWSJUva7Zmpra1FWVmZxY8zk3tmvLQATMGMhDkzRNRc856ZOk7NJgen6GDm3LlzOH/+PDZs2IBPP/0Ua9aswZEjR3Drrbe2eb+XX34Zer1e/omKiuqhFtuHnADsbeqZmTwgUL6NOTNE1BwTgMnZdCqYefrpp6FSqdr8SUlJ6bbGGY1G1NbW4tNPP8XkyZMxdepUfPTRR9ixYwdOnTrV6v2WLl2K0tJS+SczM7Pb2qREUgJwUOMw022X98H7/28MAObMEFFLHGYiZ9OpnJnHH38cixcvbnOfmJiYS2mPhbCwMLi4uGDQoEHyttjYWABARkaGnEfTnE6ng06n67Z2KFldgxGl1fUAmnJmAMBL5wqAC00SUUvsmSFn06lgJigoCEFBQbZqSwtXXnklGhoakJqaiv79+wMATp8+DQCIjo7usXYoWWGlaYjJRa2C3t1V3q5Rm+ZnM2eGiJprkTNjYDBDjs1ms5kyMjJQVFSEjIwMGAwGJCQkAAAGDBgALy8vAMDZs2dRUVGBnJwcVFdXy/sMHToUWq0WM2bMwJgxY3DHHXfgrbfegtFoxAMPPICrr77aoremN5OSfwO8tFCrmwrMuGgYzBCRdc3rzDRfeJLI0dgsmHn++efxySefyP8fPXo0AGDHjh2YOnUqAGDJkiXYtWtXi33S0tLQt29fqNVq/O9//8Nf/vIXTJkyBZ6enpg9ezbeeOMNWzXb4TRP/pVIPTNMACai5povLMmeGXJ0Ngtm1qxZ02aNGQDYuXNnu8cJDw/HV1991T2NckIF5U3Vf825SMEM36SIqJkWPTPMmSEHp+ip2dS+/GYF8yTsmSGi1jABmJwNgxkH17z6r8RFbbq0zJkhoua4NhM5GwYzDq559V+JlADMnhkiaq55wi97ZsjRMZhxcK0lALtwajYRtUKamv3MtUMAcDkDcnwMZhxc8+q/kqacGX7jIqImBqOQF6D1cTPVpuIwEzk6BjMOTs6ZadEzw5wZImrJfFq2VGiTw0zk6BjMOLC6BiNKqlouZQBwNhMRWWee/OvNnhlyEgxmHJi0lIFGrYKv2VIGQFPOjBCAkQENETWSpmW7alRw15o+AtgzQ46OwYwDkwrmBXhaLmUAABpN0//rmTdDRI2kYMbNRQOtRgOAPTPk+BjMOLDWZjIBTT0zAPNmiKiJNMykc9VA5yr1zHA2Ezk2BjMOrLXqv0BTzgzAvBkiaiJNy3ZzVUOrMX0EsGeGHB2DGQfWWvVfAHBVN11ag4HBDBGZ1Db2zLiZ9cxwoUlydAxmHJhc/ddb2+I2tVoFVWPnDHtmiEhirWem3iA4UYAcGoMZB9ZawTwJqwATUXO15gnALk0fAeydIUfGYMaBFZS3ngAMsAowEbXUlACshs5FI2+vref7BDkuBjMOrK2cGYBVgImoJfOp2a5mJRxqDZzRRI6LwYwDay+YkXpm6pkATESN5GDGVQOVSgWdC2c0keNjMOOg6g1GFMtLGbRMAAaYM0NELUnVfqWZTFLeDKsAkyNjMOOgChuTfzVqFfw8rAczzJkhouZqzKZmA2DPDDkFBjMOShpisraUgYQ9M0TUnDw120UKZkz/smeGHBmDGQfVVvVfiUtjDQnWmSEiiZQz03yYiT0z5MgYzDioArlgXhvBDHtmiKgZeZjJxXKYieszkSNjMOOgmnpmrOfLAGY5M5zNRESN5KJ5zXpmqusYzJDjYjDjoArK267+CzQFM+yZISJJ03IGpp6ZfoGeAIDfM0rs1SSiS8ZgxkFJCcCtVf8FABcNZzMRkaWmhSZNb//ThwQDALan5NqtTUSXisGMg2qvYB4AaBorAHOYiYgkzXtmpg4KhkatwuncCmQWVdmzaURdxmDGQXUkmHGR68wwmCEiE3ltpsYEYL2HK8ZF+wEAtiWzd4YcE4MZB5Uvz2ZqPwGYOTNEJGk+NRsAZsSGAAC2peTZpU1El4rBjAOyXMqgIz0zzJkhIhPzhSYl02NNeTO/nitERW2DXdpFdCkYzDigosr2lzIAmormsWeGiCQ1zRKAAaB/kBf6BXqi3iCw53S+vZpG1GUMZhyQNMTk76mVh5KsYc4Mkf0IIRRZiE5atkBKAJZIs5o41ESOiMGMA+pI8i/AnBkie7rv898R+9xPuO3DA/h4bxqyipUxU6ipaJ5lMBPfONS0IyWP7xnkcFzs3QDqPDn5t43qvwB7ZojsJb2gEj8l5QAAfj1XhF/PFeGF709iWLgPZg4NxazhIRgc4g2VqvWeVVtpmppt+V32sr7+8HZzQWFlHRKzSjCmj1+Pt42oqxjMOKCCivar/wJmPTMGJgAT9aRNv2cBAC7v649Zw0OxJSkHh9OLkJRdhqTsMrz5y2n08ffArGEhmDksFGP6+LU5ZNxdDEaB+sa6UzoXy54ZV40aVw0KwvfHLmJbci6DGXIoDGYcUEeq/wLsmSGyB6NR4KvfLwAA/t+EaNwwMhx3TuqHwopabEvOw88nc7D7TAEyiqrwnz1p+M+eNAR6aTEjNgQzh4VgYv/AFkNA3UWayQS07JkBTENNpmAmD0/MGmKTNhDZAoMZB9TxnJnGCsAMZoh6zK9phbhQUg1vNxfMHBoibw/w0mH+ZVGYf1kUKmsbsPt0Pn4+mYttybkoqKjD2kOZWHsoE55aDaYODsbMYSGYNiQYPm6u3dY2i2DGpWXANHVQMNQqICWnHFnFVYj08+i2xyayJQYzDkgOZtoomAc09cwwmY+o52w8Yhpium5EeKs9LJ46F8yOC8PsuDDUG4w4eK4IW5Jy8PPJHOSW1eKH4xfxw/GLcNWocEVMAGYNC8XVQ0MQ4uN2SW2raZzJpNWoobYyrOXnqcXYaD8cSi/GjpQ8/GlC30t6PKKewmDGATUlALczzCQtNMm1mYh6RGVtA346YUr8vXVsZIfu46pRY9LAQEwaGIgVNwzD8QuljYFNLs7mVWDPmQLsOVOAv31zAqOifDFrWChmDQtBTJBXp9tXa6X6b3PTh4TgUHoxfklmMEOOg8GMA5ISgNsNZuSeGSYAE/WEzccvoqrOgH6BnhjTx7fT91erVRgZ5YuRUb548pohSM2vwM9Jufj5ZA6OZpQgIdP08+pPKRgQ7IWZQ0Mwa1goRkTqOzQzqqlgXus5OTNig/HqTyk4kFqIytoGeOr4MUHKx2epg2kwGFFc1TibqZ0EYObMEPWsrxpnMd06NrJbpl33D/LCfVO9cN/U/sgtq8HWk7nYkpSDA6mFOJtXgbN5FXh3ZypCfdwwc1gIZg4NxfgYf7hqrPe8tDYt29yAYC9E+bsjs6gae88WYNaw0Es+DyJbYzDjYIoq6yAEoFahzaUMgKZhJubMENleZlEVfj1XBJUKuGl0RLcfP8THDf/vimj8vyuiUVpdj52n8vBzUi52nMpDTlkNPj1wHp8eOA8fNxfEx4Zg5tAQXDU4CB7aprd5eZFJK8m/EpVKhfghIVizPx3bk/MYzJBDYDDjYPIrpKUMdO3WpdBwajZRj9nUOB37yv6BCPd1t+lj6d1dMXdUBOaOikBNvQH7Uwuw5UQufknORWFlHb4+egFfH70AnYsakwcGYuawUMQPCUatlXWZrImPDcaa/enYlpIHo1FYTRYmUhIGMw6mo9V/AbM6MyyaR2RTQgh5iOmWsd3fK9MWN1cNpg8JwfQhITAYBX7PKMaWEznYcjIHmUXV+CU5D78k50GtgjzV2tq0bHPj+wXAU6tBQUUtjl8oxcgo3x44E6KuYzDjYOTqv+3kywDsmSHqKYfSi5FRVAUvnYtdh2U0ahUu6+uPy/r649k5sUjJKZcTiJOyy5BRZFofqr2kXq2LGlMGBeHHEznYlpzLYIYUj8GMg5Gr/7YzkwlgnRminrLxSCYA4Nq4UIscFXtSqVSIDfNBbJgPHp4xEJlFVdh6Mhe/ZxTjj+Oj271/fGyIKZhJycNjMwf3QIuJuk4ZrzrqsAJpmKlDPTOczURka1V1Dfjh2EUAwK1jo+zcmtZF+Xvgjkn9cAf6dWj/qYODoFIBSdlluFhajTC9bfOAiC5F21lgpDhNSxm0nzPjytlMRDa3JSkHlXUG9PH3wGV9nWdxxkAvHUY3Di9tT8mzb2OI2sFgxsHkd3BdJoA5M0Q9QVq+4JYx3VNbRkniY01rS21LZjBDysZgxsEUlHes+i/ACsBEtnahpBr7UwsBADeP6dlZTD0hPjYYALDvbAGq6wzt7E1kPwxmHIycANyZnBmuzURkE1//ngUhgCti/BHl73wrTA8O8UaErztqG4zYn1pg7+YQtYrBjANpMBhRVNWVnhkGM0TdzVRbxlQoT8mJv5dCpVLJvTO/cKiJFIzBjAMpqmpaysDfs/0EYClnpp7BDFG3+z2jGGkFlfDQajB7uPOW/J8+xBTMbE/JhRB8LyFlYjDjQKTqv/6e2naXMgDM12ZizgxRd9t4xNQrM3t4mFOvLH1FTAA8tBrkltUiKbvM3s0hsorBjAORqv92ZIgJMJvNxJwZom5VU2/A94nZAHp++YKe5uaqwaQBgQA4q4mUi8GMA5EK5nUk+RdgzgyRrfx8MhfltQ2I8HXHFf0C7N0cm5shTdFOybVzS4isYzDjQAo6UWMGAFxYAZjIJppqy0T0ihWlpw4JAgAcyypFXlmNnVtD1BKDGQfSmeq/AKBpowJwXYMR2SXV3dc4ol4ip7QGe8/kAwBuGRtp59b0jGBvN3mxSVYDJiViMONApATgjvfMWK8AvPdMAca/9AsmvrIdu0/nd28jiZzc10cvwCiAy/r6ITrA097N6THxjbOatjGYIQViMONAupoA3Hw207rDmSiuqgcApBVUdmMLiZybqbaMaYjp1l7SKyOR6s3sPVOAmnpWAyZlYTDjQDpT/RdoPWemuLJO/p35NEQdl5hVirN5FXBzVePauDB7N6dHDQ3zQZjeDdX1Bhw4V2jv5hBZYDDjQDqbANza1OziqqZghjVoiDpu45FMAMA1w0Lh7eZq59b0LJVKJRfQ25bMWU2kLAxmHITBKFDU2KMS6N2xBODWpmaXNA4xAUA9a9AQdUhNvQH/S7wIoPck/jYnDTVtT85jNWBSFAYzDqKwshZGAahUgL9HB2czyQnAlr0vlj0zfEMi6ohtyXkora5HmN4NE/sH2rs5djGxfyDcXNXILq1B8sVyezeHSMZgxkEUlJsCEH8PLVw0HbtsLlamZtc2GFBV15S8x5wZoo6REn9vGh3RoeVEnJF5NeDtLKBHCsJgxkF0NvkXsJ4AbD7EBJhW4iaituWV12DX6d5VW6Y18Y3VgLmKNikJgxkH0dnkX8AsZ8YsL8Z8iAngMBNRR3x7NBsGo8CYPr7oH+Rl7+bYlZQEnJhVIte+IrI3BjMOorPVfwHznBmzYKayWc8MgxmiNgkhmpYv6OW9MgAQ4uOGuAg9hAB2nGLvDCkDgxkH0dnqv4D1nJnmPTMcZiJqW1J2GU7llkProsZ1I8Lt3RxFkHpntnOoiRTCZsHMypUrMXHiRHh4eMDX19fqPg899BDGjh0LnU6HUaNGWd1ny5YtuOKKK+Dt7Y2goCDccsstSE9Pt1WzFUuu/tuJnBmpZ6bebDZTi2CGPTNEbZJ6ZWYODYHevXfVlmmNtIr2njP5qG1gNWCyP5sFM3V1dZg3bx7uu+++Nve74447sGDBAqu3paWlYe7cuZg+fToSEhKwZcsWFBQU4Oabb7ZFkxVNTgDuVM6M6fIKARgbg5bmCcDMmSFqXV2DEd8mXADQ+5YvaMuwcB8Ee+tQWWfAwXNF9m4OEVxsdeAVK1YAANasWdPqPv/85z8BAPn5+Th27FiL248cOQKDwYAXX3wR6sYP5r/+9a+YO3cu6uvr4erae74lycNMXeiZAUw9MFq1ymIpA2k7EVm3PSUPxVX1CPbWYfLAIHs3RzHUahXiY4Px5W+Z2JaciymD+Lch+1J0zszYsWOhVquxevVqGAwGlJaW4rPPPsOMGTPaDGRqa2tRVlZm8ePomhaZ7HgCsItZMCP1wEgLTErHYc4MUevk2jJjem9tmdZMH2IaatqWwmrAZH+KDmb69euHn3/+Gc888wx0Oh18fX2RlZWF9evXt3m/l19+GXq9Xv6JiorqoRbbhmkpgy4MM2nMe2ZMQUtJleXK2+yZIbKusKIWO1JMCa63juEQU3OTBgRC56JGVnE1TudW2Ls51Mt1Kph5+umnoVKp2vxJSUnptsbl5OTgrrvuwqJFi3Do0CHs2rULWq0Wt956a5vfBJYuXYrS0lL5JzMzs9vaZA9FlXVNSxl4dqZnpunyNvXMWAYzzJkhsu7bhGw0GAVGRuoxMMTb3s1RHHetBhP7BwAAtrEaMNlZp3JmHn/8cSxevLjNfWJiYi6lPRb+/e9/Q6/XY9WqVfK2zz//HFFRUTh48CCuuOIKq/fT6XTQ6Treg6F0UvJvZ5YyAADzXvGGZgnAUiVhLjRJZB1ry7QvPjYEO07lY1tyHu6fOsDezaFerFPBTFBQEIKCei7Rq6qqSk78lWg0GgCA0dh7cj26Uv0XAFQqFVzUKjQYhdwDU9TYMyMFM4Ze9Hck6qiT2WU4ebEMWo0a17O2TKukejO/ZxSjqLKuUz3HRN3JZjkzGRkZSEhIQEZGBgwGAxISEpCQkICKiqax1bNnzyIhIQE5OTmorq6W96mrM33gzpkzB4cOHcILL7yAM2fO4Pfff8ef//xnREdHY/To0bZquuI0zWTq/BuFeRVgg1GgtLpZAjCHmYhakBJ/42OD4ccP6FaF+7pjaJiPqRpwCgvokf3YbGr2888/j08++UT+vxR87NixA1OnTgUALFmyBLt27WqxT1paGvr27Yvp06fjiy++wKpVq7Bq1Sp4eHhgwoQJ+Omnn+Du7m6rpitOV3tmANOMplqYZi2VVddDSjWSE4A5zERkod5gxDdHWVumo+Jjg3HyYhm2p+RxSI7sxmbBzJo1a9qsMQMAO3fubPc4t912G2677bbuaZSDapqW3flgxrxnRkr+9dK5wN3VNFzHBGAiS7tO5aOwsg6BXjrWT+mA+NgQvLP9LHadzkddgxFaF0VPkiUnxWedAyhoHGYK6kTBPImUMGwwCrnGjK+Hq1mQw5wZInNS4u+No8Lh2omE+95qRIQegV5aVNQ24FA6qwGTffCV6gDyL2GYSQ5aDEKuMePnoZVr0DBnhqhJcWWdPM2YQyYdo1arMG2wKRH4l2RO0Sb7YDDjAJpWzO58IqKrumnlbPOeGakGDXNmiJp8l5iNeoPAsHAfxIb52Ls5DiO+ceHJbcmsBkz2wWDGAVxSzoymaTjJomfGLMghIhNpFhMTfztn8sBAaDVqZBRVITWf1YCp5zGYUTiLpQy6kjOjbsqZKaqUgpmmnJl65swQAQBO55bjWFYpXNQq3DCStWU6w1PngiukasDJnKJNPY/BjMIVV3VtKQOJ5Wwm0zCTn6fWIjGYiICvGhN/pw8JRkAXekF7u/jGAnoMZsgeGMwonFRjxs9D26WZFebDSdaGmZgzQ2Sqw7SpsbYME3+7RqoGfPh8kfxeQ9RTGMwo3KUk/wJNPTP1BqNcZ4ZTs4ks7TlbgPzyWvh7auWZOdQ5Uf4eGBziDaMAdp7Kt3dzqJdhMKNwl1L9F2jeM9M4zGTWy8NhJqKm2jI3jAxn0bdLEB/bONTEpQ2oh/FVq3AF5V2fyQRYrwDs56G12E7Um5VW1WNrkqk+CmcxXRopmNl5Kg/1Bvb6Us9hMKNwUs9MV2YyAbCoJ2NZZ4Y5M0QA8L9j2agzGDEk1BvDwllb5lKMivKDv6cW5TUNOJxebO/mUC/CYEbhLqX6LwC50m9FbT3qGkzflPw8tcyZIWokDTHdOjYSKpXKzq1xbBq1ClMHm9az2sZqwNSDGMwoXHclAEvHcdWo4KnVMGeGCMDZvAokZJZAo1Zh7qgIezfHKcxorAa8nXkz1IMYzCicXP23y8NMKovj+HpooVKpzGY5CZYfp15Lqvg7dVBQl4dyydLkgYFw1ahwrqAS51gNmHoIgxmFk3NmupwAbLrE0nCVv4eph0cKcgCAnTPUGxmMAl//bqotw8Tf7uPt5orx/UzVgNk7Qz2FwYyCGc2WIOh6AnBjz0zjMJOvh6tpu6YpmGHeDPVG+84WIKesBnp3V0yPZW2Z7iQV0OMq2tRTGMwoWHFVnZzT0pWlDICmhSbzzSoJA02znADOaKLeSRpimjsqHDoXjZ1b41ykKdqH0otRWl1v59ZQb8BgRsGaAhDXLi1lALTsmfHzNPXMaNTmPTMMZqh3Kaupx08ncgAAt4zhEFN3iw7wxIBgLxiMArtOsxow2R6DGQW71IJ5QFPQUlbTAMCUAAxY5sxwRhP1NpuPXURtgxEDg70wIlJv7+Y4Jal3ZjuHmqgHMJhRsEtdygCwDFoAUy8PAKjVKkg3NbBSJ/UyUm2ZW1hbxmbih5imaO84lc/3GLI5BjMKdqnVfwHApdnwlNQzA5hVB2bPDPUi6QWVOHy+GGoVcNNo1paxlTF9fOHr4YrS6nr8nlFi7+aQk2Mwo2CXWv0XsNYzYxbMaJoWoSTqLaTE38kDgxDi42bn1jgvF40aUwexGjD1DAYzCiZX//Xu2kwmwDLRF2gaZjK/jQvCUW9hNApsYm2ZHhPfWA2Yq2iTrTGYUTC5+m939sx4alvcxp4Z6i1+PVeICyXV8HZzwdVDQ+zdHKc3ZVAQXNQqnM2rwPnCSns3h5wYgxkFk6ZTd7X6L9BUAVhiOczEnBnqXaTE3+tHhsPNlbVlbE3v7orL+voDALYls3eGbIfBjIJ1SwKwWc+MSmV6c2l+G4vmUW9QUduAHxtry3CIqedIU7S3pTBvhmyHwYxCGY0ChZXdV2cGAHzcXC3+L/3O5QyoN9h8/CKq6w2ICfTE6Chfezen15DyZg6eK0J5DasBk20wmFEo86UMAry6ngBs3jNjnvwLQK4qzJwZ6g2+Ym0Zu+gX6ImYQE80GAV2ny6wd3PISTGYUSgp+df3EpYyACzrzJjXmAHMe2YYzJBzyyyqwsG0IqhUwM1jWFump3GoiWyNwYxCdUf1X6DtnhnmzFBvIdWWmTQgEGF6dzu3pveZ3lgNeOepfPYEk00wmFEoOfn3EoMZnWvTJTZP/gWaiuYxZ4acmdEo5GCGi0rax7i+fvBxc0FRZR0SMovt3RzqZt8lZsvDuPbCYEahmgrmXVowIyXfAYC/p+WxpGnb/KZEzuxQehEyi6rhpXPBrGGh9m5Or+SqUeOqwY1DTZyi7VSq6hrw0JdH8fiGRJRU1dmtHQxmFKppKYOuJ/8CQISvO96+bRRGROox/zLLb6UucgVgBjPkvKTaMnPiwuCuZW0Ze5kRy2DGGV0orpZ/L66y32w1F7s9MrWpoPzSp2VL5o6KwNxRLZMeWQGYnF1VXQM2H78IALh1HIeY7OmqQUHQqFU4lVuOzKIqRPl72LtJ1A2yzIIZey6Nw54ZhequnJm2MGeGnN1PJ3JQWWdAdIAHxkX72bs5vZqvhxZjG6/Bdq7V5DQyi6vk343Cfl+MGcwoVHdU/22PlDPD2UzkrMwTf1lbxv7ih0hTtBnMOIuMwqZgxp69/AxmFKq7pma3xZXDTOTELpRUY39qIQDgptGsLaME0oSEX1MLUVHbYOfWUHf47940+Xd7dvIzmFEgo1E0rZjtfWkJwG1h0TxyZl//ngUhgAkxAczPUIj+QZ6IDvBAncGIvWdYDdjZGDjMROZKquubljLwZM4MUWcJIeRZTLdwUUnFUKlUiG8soLctmdWAnYFZXVa79vJzNpMCSUNMendXaF1sF2+6MGeGnNSR88VIL6yCh1aD2cNZW0ZJ4mOD8fG+NOw4lQejUUCtZi6To9l9Oh8PrT2K6joDzOMXJgCThYJy2yf/ApyaTc5LSvy9Ni4Mnjp+Z1OSy/r6w1vngoKKOiRmldi7OdQFb2w9jZKqetQ2WPbqG5kATOa6q2Bee6ScmXoOM5ETqak34PtEU20ZLl+gPFoXNaYMCgLAKdqOKCGzBImZJdBq1PjpkcnY9/R0+TZ7Xk8GMwokL2Vgw5lMQNOK2gYOM5ET2ZKUg/LaBkT6uWN8P397N4eskFbR/oXVgB3OpwfSAQDXjQjDkFAfRPg2LdyalF1mp1YxmFEkeSaTrYMZzmYiJyQl/t48JpL5GAo1dXAwVCog+WIZskuq278DKcZvaUUAgFutJNbbs5QTgxkF6omCeYD51GwOM5FzyCmtwb6zpim/t4xhbRml8vfUYkwfUzVgFtBzLEWVpi/bEX7u7ezZsxjMKFBPLGUAAK4a9syQc9l0NAtGAVze1x/RAZ72bg61QRpq2s4p2g6jpt6AqjoDAMDPs2VOpz2rbDOYUSC5+q8NC+YBTcsZMGeGnIEQAl81DjFZ6wInZZHqzexLLURVHasBO4LCxl4ZV40K3lZmCdpzVJfBjAL1WAIwc2bIiSRkliA1vxJurmrMjmNtGaUbFOKFSD931DUYse9sob2bQx1Q1JjP6e+ptdoLo2bPDEmMRoHCnkoAZgVgciJSbZnZw8Pg7eZq59ZQe0zVgBsXnuRQk0MoqpKCGeufTfZMt2cwozCl1fVyT0mAjevMsGgeOYuaegO+S8gGwNoyjkRaeHJ7Sp5dC65Rx1Q1Lg7qpdNYvd3DjgUqGcwojPlSBjoX60+Y7iLlzNQzZ4Yc3LbkPJTVNCBc74YJ/QPs3RzqoPEx/vDUapBXXosT2aX2bg61Q/qkUDXrg3nl5jjEhvngmWuH9HyjGjGYUZieqv4LsGeGnMfGI5kAgJvGRMglB0j5dC4aTB5oqga8jQX0HEezl9htl/fBjw9PRpjeftO1GcwoTE8l/wJNOTMZRVWoqTfY/PGIbCGvrAa7TucD4BCTI5reOEV7WwrzZpTOjutItovBjMLI1X9tXDAPaOqZOXK+GLd/9JvNH4/IFr5JuACjAMZG+yEmyMvezaFOmtZYDfjEhTLklNbYuznUBtE40KTEvk8GMwrTUwXzgKacGQD4Lb3I5o9H1N2EEPLyBeyVcUxB3jqMjPQFwIUnHYU9ly1oDYMZhSko75mlDICmYSYiR3XiQhlO51ZA56LGnBFh9m4OddEMqRowh5oUjcNM1GEFdkgAJnJUUuLvzGGh0Luztoyjmt5YDXjv2QLm7ylYa7OZlIDBjMI0zWbqiWEm5T0hiTqqtsGAbxNNtWW4fIFjiw3zRrjeDTX1RuxPLbB3c6gdHGaidhWU90z1XwBypWEiR7QjJQ8lVfUI8dFh0oBAezeHLoFKpZJnNf3CKdqKJRQ8zsRgRkGEECislBaZtH0wc1lff/l3rYZPBXIsG49cAADcNDqSvYxOQK4GnJyn6A9NYs8MtaO0ul6uxtsTOTNxkXr85/ZxAAAD3zzIgRRU1GLnKdM3+FvHRti5NdQdJsQEwN1Vg5yyGiRll9m7OdQG5sxQm74+avqm6ePmYvOlDCSjonwBmKoA89sQOYpvE7LRYBQYGeWLAcHe9m4OdQM3Vw0mDTQNF3KKtjIp+SOCwYxC1DUYseJ/JwEAZTUNPfa45jOauKoBOQqptsytY9gr40y4irayyUXzlNcxw2BGKQ6ft0/ROrVZMNNgNNqlDUSdkZRdiuSLZdBq1Lh+ZLi9m0PdaHpjMJOYVYq8clYDpo5jMKMQ0toyALD+ngk99rgWPTOMZcgBfNWY+DtjaDB8PWyfW0Y9J9jHDSMi9QBMs9VIWTjMRO3adcoUzLx92yhc3s+/nb27j4Y9M+RA6g1GfJtgCmZYW8Y5xTcW0OMq2sojBTMqBY4zMZhRgNyyGqTklEOlAiYPDOrRx9awZ4YcyM5T+SisrEOglw5Tevi1Qj0jvrHezJ4zrAasVMoLZWwczKxcuRITJ06Eh4cHfH19W9yemJiIhQsXIioqCu7u7oiNjcXbb7/dYr+dO3dizJgx0Ol0GDBgANasWWPLZve43Y1DTCMi9PD37Nluc42KPTPkOKTlC24aHQ4X1kZySsPCfRDio0N1vQG/niu0d3PIjIJHmWwbzNTV1WHevHm47777rN5+5MgRBAcH4/PPP0dSUhKeffZZLF26FP/617/kfdLS0jBnzhxMmzYNCQkJeOSRR7BkyRJs2bLFlk3vUVK+zFWDev6bplqtkjPTWWuGlKyosk6esnsLh5iclkqlktdq4lCTskjlOxQ4ygQXWx58xYoVANBqT8odd9xh8f+YmBgcOHAAmzZtwoMPPggAeP/999GvXz+88cYbAIDY2Fjs3bsXb775JmbNmmW7xvcQg1FgzxnTWiRXDbZPt7lGpUKDEDBwbjYp2HcJF1BvEBge4YMhoT72bg7Z0IzYYHz5Wwa2p+ThBSEUmaPRmynxaiiun7a0tBT+/k0JsAcOHMCMGTMs9pk1axYOHDjQ6jFqa2tRVlZm8aNUx7JKUFpdDx83F4yM9LVLG6S8GQYzpGRf/d6Y+DuGvTLObmL/QOhc1LhQUo2UnHJ7N4caKfkTQlHBzP79+7Fu3Trcfffd8racnByEhIRY7BcSEoKysjJUV1dbPc7LL78MvV4v/0RFRdm03ZdCGmKaNDDQbjkAUjDDlBlSqlM55Th+oRSuGhVuGMVCec7OXauRFw9lNWAFcabZTE8//TRUKlWbPykpKZ1uyIkTJzB37lwsW7YMM2fO7PT9zS1duhSlpaXyT2Zm5iUdz5bsmS8jkYIZJgCTUn31u6ni7/QhwT2eJE/20bSKNqsBK43yQpku5Mw8/vjjWLx4cZv7xMTEdOqYJ0+eRHx8PO6++2787W9/s7gtNDQUubmWT+bc3Fz4+PjA3d3d6vF0Oh10OtuvOn2pSqrqkJhZAgCYooBgxsgEYFKgBoMRmxqHmG7hEFOvET8kBM/iBBIyS1BQUYtAL+W/pzs7oeCBpk4HM0FBQQgK6r4P3qSkJEyfPh2LFi3CypUrW9w+YcIEbN682WLb1q1bMWFCz1XJtZW9ZwtgFMCgEC+E6a0HZj3BRe6ZUe4TlXqvPWcKUFBRiwBPLaY1lrsn5xeqd8OwcB8kZZdhR0oe5o1TbrpAb9FUNM++7bDGpkkaGRkZSEhIQEZGBgwGAxISEpCQkICKigoApqGladOmYebMmXjssceQk5ODnJwc5Oc3lfa/9957ce7cOTz55JNISUnBu+++i/Xr1+PRRx+1ZdN7hFT1155DTACgVjEBmJRLWlTyhlHhcGVtmV4lPtaUL8m8GaVRXjRj03eG559/HqNHj8ayZctQUVGB0aNHY/To0Th8+DAAYOPGjcjPz8fnn3+OsLAw+eeyyy6Tj9GvXz/88MMP2Lp1K0aOHIk33ngD//3vfx1+WrYQArvPSMGMfb9tal1MT4PKWlbbJGUprarH1pOmYWYuX9D7SKto7z6dj9oGvj/Zm5K/7to0mFmzZg2EEC1+pk6dCgBYvny51dvT09MtjjN16lQcPXoUtbW1SE1NbTdnxxGcyi1Hblkt3F01GNfXz65tGRLqDQBIyCy2azuImvvuWDbqDEYMCfXGsHC9vZtDPSwuQo8gbx0q6wz4La3I3s3p9XrtMBO1ThpiuiLGH26uGru2RVrY8rc0BjOkLF81DjGxV6Z3UqtVmD7Y1DvDasDKocBYhsGMvShhSrbksr6mYObw+SIYmTdDCnE2rwIJmSVwUatw42jWlumtpIUnt6XkyuX0yT6UPJuJwYwdVNY24HC6qRfkqsH2n50xPEIPd1cNSqrqcTa/wt7NIQLQVFtm6uAgTsvtxSYNDITWRY3MomqcyeP7kz1xmIks/HquEHUGI6L83dE3wMPezYGrRo3RfXwBgOPSpAgGo8Cm3znERICH1gUT+wcA4FCTUqgUONDEYMYOzIeYlFIWWhpqOpTOYIbsb+/ZAuSW1cLXw5W1ZUie1bSN1YDtSrmDTAxm7KIpmFHOm7SUBHyIPTOkAFLi79yR4dC52DdBnuxvemO9md8zilFUWWfn1vRijeNMCvkOboHBTA9LL6jE+cIquGpUmNDYdaoEo/v4wkWtQnZpDbKKq+zdHOrFymrqsSUpBwBwC4eYCECErzuGhHrDKICdpzjUZG8MZkgulDc22g9euk6vJmEzHloXDIsw1fH4w38O4tF1Cfh4bxoOpxehqq7Bzq2j3uSHYxdR22DEoBAvxEWwtgyZzGjsndnGasB2o+RhJuV8mvYSTUsYKGeISXLLmAgkZpYgo6gKGUVV+PqoaXE/tQoYGOyNuEg9RkTqERehR2yYj93r45BzkpYvuGVMpGJyysj+pscG4187zmL3qXzUNRjlyuXUc+TZTApMAGYw04NqGwzYn1oIQBn1ZZq7fUJfXBsXhuMXSnE8qxTHskpx/EIJcstqcSq3HKdyy+UPGhe1CoNCvE3BTaQeIyJ8MTjUm28wdEnSCipx5Hwx1CrgJtaWITMjI30R4KlFYWUdDqcXYeKAQHs3qfdSXizDYKYnHUkvRnW9AUHeOsSGedu7OVYFeukwbXAwppnVv8ktqzEFNxdKcTyrBMeySlFYWYeTF8tw8mIZ1h7KBABoNWoMCfNGXITUg+OLgSFeXByQOkxK/J0yKAjBPm52bg0piUatwrQhwdh4JAvbUvIYzNiBkosWMpjpQdIspikDlTMluyNCfNwQMtQNM4aaxqyFELhYWiP33Jj+LUVJVT2ONfbo/N9B0311LmoMDffBiAg94iJ9MSJSj/5BXtCoHef8qWcYWVuG2hEvBTPJufjbnFiHeh91BlIoo8S/OoOZHiRPyR6svCGmzlCpVAj3dUe4rzuuGR4KwBTgZBVXm4KZCyU4nmUaqiqvbcDRjBIczSgBcB4A4O6qwfAIH8RF+MrDVP0CPKFmgNOrHThXiOzSGvi4ucjJnkTmJg8KgqtGhfTCKpwrqET/IC97N4kUgsFMD8ktq0FKTjlUKmCyE3aPqlQqRPl7IMrfA3NGhAEwfdNOL6zE8QuN+TdZpTiRXYqqOgMOpRfjUHrTwpZeOhcMj/DBiEhfeZiqj78Hv3n1ItIQ0/Ujw5lcTlZ56VxwRUwA9pwpwLbkXAYzPaxpOQPlvS8zmOkhUq/MiEhf+Hlq7dyanqFWqxAT5IWYIC/MHWVK5jQYBc7lV8hDU8eySpCUXYaK2gb8eq4Iv55rKtqnd3dFXISUYGz6N8LXXZEvJLo0FbUN+PEEa8tQ++KHBDcGM3m4e0p/ezenV+EwEylqlWx70qhVGBjijYEh3vKHVoPBiDN5FY1JxqYhquSL5SitrsfeswXYe7ZAvr+/p9YswViPEZG+CPHRMcBxcJuPX0R1vQExQZ4YHeVr7+aQgsXHhmD5/07i8PlilFbVQ+/hau8mkQIwmOkBBqPA3jOmD+TeHsxY46JRIzbMB7FhPph/WRQAoK7BiNO55RZJxqdyylFUWYddp/Pl4BAAgrx1cs+NNIsqyJurLDsSacr/rWNZW4baFuXvgUEhXjidW4Gdp/PkXl+yPaHg5QwYzPSAxKwSlFbXw8fNBSMjWdG0I7QuagyP0GN4hB5AHwBATb0BKTnl8vTw4xdKcTq3HPnltdiWkmdRGTRM79bUg9OYh+PfS4b3HE1GYRV+SyuCirVlqIOmDwnB6dwKbEtmMGMPCoxlGMz0BKnq7+SBQXBhzZUuc3PVYFSUL0aZDUNU1xlw8mJTgvGxC6VIza/AxdIaXCytwc8nm1bZjfRzl3tuRkSaAiW9O7uo7e2rxunYkwYEIkzvbufWkCOYERuM93elYuepPDQYjHxfJQYzPYH5MrbjrtVgbLQ/xkb7y9sqahuQdKG0aRbVhVKkFVQiq7gaWcXV2Hw8R963b4AHRjTWv4mL0GNYhF5Ra2Y5O6NRyMEMa8tQR43u4wc/D1cUV9Xj8PliXBHT9UV7k7JL8cym43hg2gDMHBbaja10PpzN1IsVV9bhWFYJAGDyIOebkq1EXjoXjI8JwHizN7jS6nokXZCqGJsSjTOLqpFeWIX0wip8l5gNwDQW3D/IyyIHZ2iYHu5aThW2hd/Si5BVXA1vnQtmDuUHCXWMRq3CtMHB2HT0Aran5F1SMPPKjylIzCrFY+sT8dMjPoj08+jGljoX0TifSXmhDIMZm9t7tgBGAQwO8WYXuh3p3V0xcUCgRQn04so60zpUjVPEj2eVIru0BmfzKnA2rwKbzBbaHBTibZGDMyTUm7VQuoGU+DtnRBgDRuqU6bGmYOaX5Fw8c21sl46RfLEMexonZ1TUNuCJDcfwf0vGs4CnA2IwY2POUvXXGfl5ajFlUBCmmA3/5ZfX4sSFpkU2E7NKkV9ei5SccqTklGOD2UKbg0O9LXJwBoVwoc3OqKxtwObjFwFwiIk6b8qgILioVTiXX4m0gkr0C/Ts9DH+uycNAHBZXz+cuFCGA+cK8emBdCy+sl93N9cpCAUXmmEwY0NCCOxmvoxDCfLWYdqQYEwbYrnQpinBuATHGgOdoso6JGWXISm7DF+iaaHN2DBveRXxuEg9BgZ7MTmxFT+dyEFVnQF9AzwwNtrP3s0hB+Pj5orL+/ljf2ohtiXnYsnkmE7dP7esBt8lmnpfn7k2FiculOK5b5Pwyk8pmDIoCDGsLtwqlQKjGQYzNpSSU4688lq4u2owri/frB1ViI8brh7qhqvNFtrMLq2xmCJ+LKsUpdX1SMwqRWJWKYAMAKaFNoeFWy7TEMOFNgE0zWK6ZQxry1DXxMeGYH9qIban5HU6mPlkfzrqDQLjov0wuo8fRkX54ueTudhzpgCPrU/Exnsn8ItIM8pdM5vBjE1JQ0wT+gdA58J8AGehUqkQ4euOCF93XDPctA6VEAKZRdVyBeNjWaU4ccG00ObvGSX4PaNEvr+HVoPh4eZF/vTo28sW2swqrsL+1EIAwE1jWCeEuiZ+SDD+/v1J/JZWhLKaevi4dazUQlVdA/7voOkLhxQEqVQqrLp1BGa+uRsJmSX4YPc5PDBtgM3a7oiaZjPZtx3WMJixIam+DIeYnJ9KpUKfAA/0CfDAdSPCAbS90OZv6UX4Lb1pHSpvnQuGywnGpmGqKH/nXYfq699N3fsT+wdw9gh1Wd9AT/QP8kRqfiV2n86XX3vt2XA4C6XV9YgO8JB7XAEgTO+OFTcMw2PrE/HWL6cxbXAwhob72Kr5DkuJ70oMZmyksrYBh8+bPqymMJjplTqz0GZ5bQMOnCvEgXOF8v317q5ma1CZZlGF690cPsARQlgMMRFdivjYEKTmn8O25LwOBTMGo8BHe02Jv3dO6tdiyPem0RHYkpSDLUm5eGx9Ar598Er2rDcSCh5oYjBjIwdSC1FvEOjj74G+AfzmSSadXWhzz5kCeeooAAR4as1WETfNogrxcbPX6XTJkfPFSC+sgqdWg9lxrC1DlyZ+SDA+3H0OO07lwWAU7eajbT2Zg4yiKvh6uFqdRadSqbDypjgcTi9GSk453vrlDJ66Zoitmu9QOMzUC5lX/XX0b9JkW51ZaLOwsg47T+Vj56mmhTaDvXUWU8TjIvUI9FLuQptSbZlr48LgoeVbEF2asdF+0Lu7oqSqHr9nFOOyvv5t7v/h7nMAgP83PrrV51+glw4rb4rDvZ8fwQe7UjEjNtiiynhvx9lMvQiXMKBL0ZmFNvPKa/FLch5+SW5aaDNc79aYYGyaRRUXoYefAhbarK4z4Idjptoyt7C2DHUDF40aUwcH4duEbGxLzmszmDlyvhi/Z5RAq1Hj9onRbR73muGhuHl0BDYdvYDH1ydi88OTGXwrGK+MDaQXVCKjqAquGhUm9O96mW0ic9YW2qyqa0DyxbIWC21ml9Ygu7QGW5KaFtqM8neX69+MaFyHqqcX2vz5ZA7KaxsQ5e+Oy9v5Bk3UUdOHBDcGM7l4enbrQ0L/3WPqlZk7KhzB3u0Pzy67YRgOnCtEemEVXvkxBS/MHd5tbXZEonGcSYmDDQxmbEDqlRkX7Q9PLlpINuShdenwQpuZRdXILKrGD41VdwGgX6BnU4JxDyy0KQ0x3Tw6sldNRSfbmjooGBq1CmfyKpBRWIU+VvIUMwqrsCXJtMjsXVM6VpNG7+6KVbeOwJ8++g2fHjiPmUNDMWkg19hjMNNLcAkDsqfOLLSZVmAqBd8TC21eLK3G3rOmZGbOYqLupPdwxbhoPxxMK8K2lFz82cpyBB/vS4NRmIb+B4V4d/jYkwcG4U9XROOzX8/jiY2J+OmRKT3eo6kUQrmTmRjMdLfaBgMONBYDmzKQwQwpw6UstKlRqzAw2OuSF9rc9PsFCAFc3s/f6jdnoksxIzYEB9OKsD0lr0UwU1JVh/WHTcuO3NXJSsEAsPTaIdhzJh/phVVY8b8k/GP+qO5ossNpimWU1zXDYKabHU4vRnW9AUHeOsSGdTz6J+pp7S20eaxxLaq2F9r0lYeo2lpo07y2DBeVJFuYHhuMlZuT8eu5QpTX1MPbrBrw/x3MQFWdAUNCvXHlgM7nMXpoXfDG/JGY9/4BbPr9AmYNC8WsYb23rACHmXoBTskmR9Z8oU0hBHLLak09N2Y5OBYLbf5muq/WxTTF3HyIakCQaaHNo5klOJdfCXdXDa6NC7PjGZKz6h/khX6BnkgrqMTeMwWY3fg8q2sw4pP96QBMvTJdfV8eG+2Pu6f0x/u7UvHMpuMYG+2n6BIItsBhpl6ESxiQM1GpVAjVuyFUH4qZjd9EhRC4UFItz5463tiLU1bTgMTMEiRmlsj3d3NVY1i4HrUNBgDA7OGhNk0wpt5t+pBgfLQ3Db8k58nBzHeJ2cgrr0WIjw7Xj+zYcgetefTqgdh5Kg8pOeV49uvjeP//je1VX1qlCsBKPGO+q3SjnNIanMoth0oFTBrAjHdyTiqVCpF+Hoj085A/MIQQyCiqslim4cSFMlTUNuDI+WL5vqwtQ7YUH2sKZnY2VgNWq5qmYy+e2K/VYdCO0rlo8Mb8kbjx3/uwJSkXXx+9gJt7YTK7EuM3BjPdaHfjENPISF9FFCgj6ikqlQrRAZ6IDvCUv/0ajQJphZXyKuIBXlpMZN0lsqHL+vrD280FhZV1SMgsQVVdA1JyyuGh1eAPl/fplscYFq7Hw/ED8frPp7HsuyRcEROAcF/3bjm20il5mOnSwlSywKq/RE3UahX6B3nhxtEReP76oXhg2oBe1SVPPc9Vo5bff7en5OI/e0wLSs4fFwW9R/dNp773qv4YFeWL8poGPPXVMbmYnLOTzlKJyxkwmOkmDQYj9pwxBTNcJZuIyD7iY03J6+/uTMXu0/lQq0yrY3cnF40ab8wfCTdXNfacKcDnBzO69fhKp8TvJAxmukliVinKahqgd3fFyEi9vZtDRNQrTR0UDLWqaUhk9vAwRPl3f12j/kFe8mraL/2QjPSCym5/DMVRcA8Ug5luIg0xTRoYCBcN/6xERPbg56m1CF6WTO7eXhlziyb0xYSYAFTXG/DXDYkwGJX7Yd8dmoaZlIefut2E+TJERMqgM5u1NLqPn80eR61W4bV5I+Clc8Hh88X4T+PMKWenxNw3BjPdoLiyDseySgBwCQMiInt7ds5QDAn1xqb7J9r8sSL9PPD8dUMBAP/4+TRScsps/pj2ouBRJgYz3WHP2QIIAQwJ9Uaovv1l5YmIyHauGhSEnx6ZgjE27JUxN29cJOKHBKPOYMRj6xJR12DskcftaQLKjWYYzHQDVv0lIuq9VCoVXr4lDn4erjh5sQzvbD9j7ybZlAJHmRjMXCohBHZzSjYRUa8W7O2GF2+MA2CaFp5gtqyHs+AwkxNLvliO/PJauLtqMK5vz3RpEhGR8swZEYYbRobDYBR4bH0CauoN9m5St2LRPCcmzWKa2D8AOheNnVtDRET29MLcYQj21uFcfiVe/SnF3s2xCQ4zOaFdp/MAAFcN5hATEVFv5+uhxau3jgAArN6Xjv2pBXZuUffhMJOTqqhtwOF004rAnJJNREQAMG1wMBY2Lmz5xIZjKK+pt3OLuoc0m0mBHTMMZi7Fr6mFaDAKRAd4oG+gp72bQ0RECvHsnFhE+bvjQkk1/v79SXs3p1txmMnJSIXyLu/rb9+GEBGRonjpXPDGvFFQqYD1h7Pwy8lcezfp0nGYyTmF6N0wLtoPY6I5i4mIiCxd3s8fSxpX7H5603EUVdbZ/DGTL5bhfKFtFr2UZzMpsGuGwcwl+OP4aGy8b6I8NkpERGTu8ZmDMTDYCwUVtXjumxMQNsyi3Zaci2v/uQcLP/zVZo8BMGeGiIioV3Fz1eAf80fBRa3CD8cv4rvEbJs8zsnsMvzly6MQAsivqLXJY9gyELtUDGaIiIhsKC5SjwenDwAAPP9tEnLLarr1+HllNVjyySFU1ZmK9Nkq5hBNVfMUh8EMERGRjT0wbQDiIvQora7HkxuPdVsvR3WdAXd9ehjZpTUI8tZ1yzHbwwrAREREvZCrRo1/zB8JrYsau07nY+2hzEs+ptEo8PiGBCRmlcLXwxX/WjgagO0mHSl3kInBDBERUY8YGOKNJ2YOBgC8+P1JZBZVXdLx/rH1NDYfz4GrRoUP/t9Ym9c7kzqTFDiZicEMERFRT7ljUj9c3tcflXUGPL4hEUZj1/o7vjqShX/tOAsAePnmERgfEyAP/tg6UVeBsQyDGSIiop6iUavw+ryR8NBq8FtaET7el9bpY/yWVoSnNx0DANw/tT9uHRvZ3c20Sih4oInBDBERUQ/qE+CBv80ZCgBYteUUzuSWd/i+5wsrcc9nh1FvEJg9PBR/bRy2AiB3mdgsZ4bDTERERCRZeHkUpg4OQl2DEY+tT0S9wdjufUqr63HHmkMorqrHiEg9/jF/FNTqno8sOJuJiIiIoFKp8OotI6B3d8XxC6X4d2P+S2vqDUY88H+/IzW/EmF6N/z39nFw12osj9kYZCi4tp3NMJghIiKygxAfN7wwdxgA4F/bz+J4VqnV/YQQWPZdEvaeLYCHVoP/LhqHYB+3FvvZevhHSizudcNMK1euxMSJE+Hh4QFfX98WtycmJmLhwoWIioqCu7s7YmNj8fbbb1vss2nTJlx99dUICgqCj48PJkyYgC1bttiy2URERD3ihpHhmBMXhgajwGPrE1BTb2ixz0d70/DFwQyoVMA/bxuNYeF6q8cyjzGsHceZ2TSYqaurw7x583DfffdZvf3IkSMIDg7G559/jqSkJDz77LNYunQp/vWvf8n77N69G1dffTU2b96MI0eOYNq0abj++utx9OhRWzadiIjI5lQqFf5+43AEeulwJq8Cb/x8yuL2X07mYuXmZADAs9fGYsbQkFaP5eehRaSfOwBg45Gsbm+rglczgEr0wMpRa9aswSOPPIKSkpJ2933ggQeQnJyM7du3t7rPsGHDsGDBAjz//PMdevyysjLo9XqUlpbCx8eno80mIiLqEduSc3HnJ4ehUgFr77oC42MCcDK7DLe+vx9VdQYsvDwKL90UB1U7Yzyf7E/Hsu+SEB3gge2PT4WmGxOEn/vmBD779Tweih+Ix64e1G3HbUtHP78VlzNTWloKf3//Vm83Go0oLy9vc5/a2lqUlZVZ/BARESlVfGwI5o+LhBDAXzcmIq2gUl488soBAXhh7vB2AxkAmDcuEn4erjhfWIWfTuT0QMuVQVHBzP79+7Fu3Trcfffdre7z+uuvo6KiAvPnz291n5dffhl6vV7+iYqKskVziYiIus1z1w1FhK87MouqMfvt3cgurUFMkCfe/cNYuGo69nHtoXXB7RP6AgDe35XardWApaJ5Shxm6nQw8/TTT0OlUrX5k5KS0umGnDhxAnPnzsWyZcswc+ZMq/t88cUXWLFiBdavX4/g4OBWj7V06VKUlpbKP5mZl76gFxERkS15u7nitXkjAAA19Ub4erji40WXQe/h2qnjLJrYF26uahy/UIoD5wq7rX1KLprn0tk7PP7441i8eHGb+8TExHTqmCdPnkR8fDzuvvtu/O1vf7O6z9q1a7FkyRJs2LABM2bMaPN4Op0OOl3PLIVORETUXSb2D8RT1wzBhsOZeOWWEV1aPNLfU4sF46LwyYHz+GDXOUzsH2iDlipLp4OZoKAgBAUFdVsDkpKSMH36dCxatAgrV660us+XX36JO+64A2vXrsWcOXO67bGJiIiU5r6p/XHf1P6XdIwlk2Pw2a/nset0Pk5ml2Fo+KVPfmmazaS8rhmb5sxkZGQgISEBGRkZMBgMSEhIQEJCAioqKgCYhpamTZuGmTNn4rHHHkNOTg5ycnKQn58vH+OLL77A7bffjjfeeAPjx4+X9ykttV5ciIiIqLeL8vfAnBHhAIAPd6d2yzGVPMxk02Dm+eefx+jRo7Fs2TJUVFRg9OjRGD16NA4fPgwA2LhxI/Lz8/H5558jLCxM/rnsssvkY3z44YdoaGjAAw88YLHPww8/bMumExERObR7pphSPv537CKyiqvs3Brbsmkws2bNGgghWvxMnToVALB8+XKrt6enp8vH2Llzp9V91qxZY8umExERObThEXpMGhAIg1Hgo71p3XBEJ5rNRERERI7hnqtMvTNrf8tEcWXdJR2r1w4zERERkf1MGhCIYeE+qK434LNfz9u7OTbDYIaIiMhJqVQq3HOVaWbUmv3pl7QAZVPPjPK6ZhjMEBERObFrh4ci0s8dRZV12HAJC1AK2Hwpxy5jMENEROTEXDRq3DXZlDvzn93nYDAqNyjpKgYzRERETk5agDKjqAo/nrjYpWMwAZiIiIjsxkPrgkUT+wIAPth17pIWoOx1FYCJiIhIGW6fYLYAZWrnF6BU8uAUgxkiIqJeQFqAEgDe332u0/fnMBMRERHZ3ZLJMVCrgN2NC1B2hQJjGQYzREREvYX5ApQfdHIBSk7NJiIiIkWQFqD8/thFZBZ1YgFKDjMRERGREgyP0GPywK4vQMnZTERERGR390wxLXGw7lDHF6BU7iATgxkiIqJe58oBAZ1egFKqTcNhJiIiIrK75gtQVtd1fQFKJWAwQ0RE1AuZL0C58Uhmu/tzmImIiIgUxWIByj1paDAY29y/qWie8saZGMwQERH1UvPHRckLUP6UlNOh+ygvlGEwQ0RE1Gu5azUdXoCSw0xERESkSOYLUO5vYwFKzmYiIiIiRbJYgHJX+0scKDCWYTBDRETU2y2ZHAONWoU9ZwqQlF1qdR8OMxEREZFiRfl7YE5cGADgw93nrO/E2UxERESkZHd3cAFKBcYyDGaIiIio/QUohYIHmhjMEBEREYCmBSjXHspAUbMFKOWieT3dqA5gMENEREQAmhagrKk34rMDrSxAqcBxJgYzREREBMByAcpPDlguQNlGPT27YzBDREREsmuHhyLKv+UClFLOjPL6ZRjMEBERkRnzBSg/3HOuxQKUChxlYjBDREREluaNNS1AmVlUjR9PmBag5DATEREROQyLBSh3p0KIponZKgUONDGYISIiohakBShPXCizWICSw0xERETkEJovQMlhJiIiInI45gtQpuSUAeBsJiIiInIg5gtQZhVXA+AwExERETkYaQFKJWMwQ0RERK2SFqCUcDYTERERORxpAUoAikyaYTBDREREbbpyQACGR/gAAHzcXO3cmpZc7N0AIiIiUjaVSoX/3n4ZtqfkIT422N7NaYHBDBEREbUrVO+GP4zvY+9mWMVhJiIiInJoDGaIiIjIoTGYISIiIofGYIaIiIgcGoMZIiIicmgMZoiIiMihMZghIiIih8ZghoiIiBwagxkiIiJyaAxmiIiIyKExmCEiIiKHxmCGiIiIHBqDGSIiInJovWLVbCEEAKCsrMzOLSEiIqKOkj63pc/x1vSKYKa8vBwAEBUVZeeWEBERUWeVl5dDr9e3ertKtBfuOAGj0Yjs7Gx4e3tDpVLZuzndpqysDFFRUcjMzISPj4+9m2NzPF/n1ZvOFeD5OrPedK6A7c9XCIHy8nKEh4dDrW49M6ZX9Myo1WpERkbauxk24+Pj0yteNBKer/PqTecK8HydWW86V8C259tWj4yECcBERETk0BjMEBERkUNjMOPAdDodli1bBp1OZ++m9Aier/PqTecK8HydWW86V0A559srEoCJiIjIebFnhoiIiBwagxkiIiJyaAxmiIiIyKExmCEiIiKHxmCGiIiIHBqDGTt7+eWXcdlll8Hb2xvBwcG48cYbcerUKYt9pk6dCpVKZfFz7733WuyTkZGBOXPmwMPDA8HBwXjiiSfQ0NBgsc/OnTsxZswY6HQ6DBgwAGvWrLH16VlYvnx5i/MYMmSIfHtNTQ0eeOABBAQEwMvLC7fccgtyc3MtjuEI5ynp27dvi/NVqVR44IEHADj+dd29ezeuv/56hIeHQ6VS4ZtvvrG4XQiB559/HmFhYXB3d8eMGTNw5swZi32Kiorwxz/+ET4+PvD19cWdd96JiooKi32OHTuGyZMnw83NDVFRUVi1alWLtmzYsAFDhgyBm5sb4uLisHnz5h493/r6ejz11FOIi4uDp6cnwsPDcfvttyM7O9viGNaeE6+88orizre9a7t48eIW53HNNddY7OMs1xaA1dexSqXCa6+9Ju/jKNe2I585Pfle/O9//xt9+/aFm5sbxo8fj99++61rJybIrmbNmiVWr14tTpw4IRISEsS1114r+vTpIyoqKuR9rrrqKnHXXXeJixcvyj+lpaXy7Q0NDWL48OFixowZ4ujRo2Lz5s0iMDBQLF26VN7n3LlzwsPDQzz22GPi5MmT4p133hEajUb89NNPPXauy5YtE8OGDbM4j/z8fPn2e++9V0RFRYlt27aJw4cPiyuuuEJMnDjR4c5TkpeXZ3GuW7duFQDEjh07hBCOf103b94snn32WbFp0yYBQHz99dcWt7/yyitCr9eLb775RiQmJoobbrhB9OvXT1RXV8v7XHPNNWLkyJHi119/FXv27BEDBgwQCxculG8vLS0VISEh4o9//KM4ceKE+PLLL4W7u7v44IMP5H327dsnNBqNWLVqlTh58qT429/+JlxdXcXx48d77HxLSkrEjBkzxLp160RKSoo4cOCAuPzyy8XYsWMtjhEdHS1eeOEFi2tu/lpXyvm2d20XLVokrrnmGovzKCoqstjHWa6tEMLiPC9evCg+/vhjoVKpRGpqqryPo1zbjnzm9NR78dq1a4VWqxUff/yxSEpKEnfddZfw9fUVubm5nT4vBjMKk5eXJwCIXbt2yduuuuoq8fDDD7d6n82bNwu1Wi1ycnLkbe+9957w8fERtbW1QgghnnzySTFs2DCL+y1YsEDMmjWre0+gDcuWLRMjR460eltJSYlwdXUVGzZskLclJycLAOLAgQNCCMc5z9Y8/PDDon///sJoNAohnOe6CiFafAAYjUYRGhoqXnvtNXlbSUmJ0Ol04ssvvxRCCHHy5EkBQBw6dEje58cffxQqlUpcuHBBCCHEu+++K/z8/OTzFUKIp556SgwePFj+//z588WcOXMs2jN+/Hhxzz33dOs5mrP2gdfcb7/9JgCI8+fPy9uio6PFm2++2ep9lHi+rQUzc+fObfU+zn5t586dK6ZPn26xzRGvrRAtP3N68r348ssvFw888ID8f4PBIMLDw8XLL7/c6fPgMJPClJaWAgD8/f0ttv/f//0fAgMDMXz4cCxduhRVVVXybQcOHEBcXBxCQkLkbbNmzUJZWRmSkpLkfWbMmGFxzFmzZuHAgQO2OhWrzpw5g/DwcMTExOCPf/wjMjIyAABHjhxBfX29RRuHDBmCPn36yG10pPNsrq6uDp9//jnuuOMOi5XbneW6NpeWloacnByLtun1eowfP97ievr6+mLcuHHyPjNmzIBarcbBgwflfaZMmQKtVivvM2vWLJw6dQrFxcXyPkr8G5SWlkKlUsHX19di+yuvvIKAgACMHj0ar732mkXXvCOd786dOxEcHIzBgwfjvvvuQ2FhoXybM1/b3Nxc/PDDD7jzzjtb3OaI17b5Z05PvRfX1dXhyJEjFvuo1WrMmDGjS+fbK1bNdhRGoxGPPPIIrrzySgwfPlze/oc//AHR0dEIDw/HsWPH8NRTT+HUqVPYtGkTACAnJ8fiSQVA/n9OTk6b+5SVlaG6uhru7u62PDUAwPjx47FmzRoMHjwYFy9exIoVKzB58mScOHECOTk50Gq1Ld74Q0JC2j0H6ba29unJ87Tmm2++QUlJCRYvXixvc5brao3UPmttM297cHCwxe0uLi7w9/e32Kdfv34tjiHd5ufn1+rfQDqGPdTU1OCpp57CwoULLVYSfuihhzBmzBj4+/tj//79WLp0KS5evIh//OMfABznfK+55hrcfPPN6NevH1JTU/HMM89g9uzZOHDgADQajVNf208++QTe3t64+eabLbY74rW19pnTU+/FxcXFMBgMVvdJSUnp9LkwmFGQBx54ACdOnMDevXsttt99993y73FxcQgLC0N8fDxSU1PRv3//nm5ml82ePVv+fcSIERg/fjyio6Oxfv16u33o9pSPPvoIs2fPRnh4uLzNWa4rWaqvr8f8+fMhhMB7771ncdtjjz0m/z5ixAhotVrcc889ePnll+2+tk1n3HbbbfLvcXFxGDFiBPr374+dO3ciPj7eji2zvY8//hh//OMf4ebmZrHdEa9ta585jojDTArx4IMP4vvvv8eOHTsQGRnZ5r7jx48HAJw9exYAEBoa2iLTXPp/aGhom/v4+PjYLZDw9fXFoEGDcPbsWYSGhqKurg4lJSUt2tjeOUi3tbWPPc/z/Pnz+OWXX7BkyZI293OW6wo0tc9a28zbnpeXZ3F7Q0MDioqKuuWaS7f3JCmQOX/+PLZu3WrRK2PN+PHj0dDQgPT0dACOd76SmJgYBAYGWjx3ne3aAsCePXtw6tSpdl/LgPKvbWufOT31XhwYGAiNRtNt58tgxs6EEHjwwQfx9ddfY/v27S26Ia1JSEgAAISFhQEAJkyYgOPHj1u8eUhvpEOHDpX32bZtm8Vxtm7digkTJnTTmXReRUUFUlNTERYWhrFjx8LV1dWijadOnUJGRobcRkc9z9WrVyM4OBhz5sxpcz9nua4A0K9fP4SGhlq0raysDAcPHrS4niUlJThy5Ii8z/bt22E0GuXAbsKECdi9ezfq6+vlfbZu3YrBgwfDz89P3kcJfwMpkDlz5gx++eUXBAQEtHufhIQEqNVqeUjGkc7XXFZWFgoLCy2eu850bSUfffQRxo4di5EjR7a7r1KvbXufOT31XqzVajF27FiLfYxGI7Zt29a18+10yjB1q/vuu0/o9Xqxc+dOiyl9VVVVQgghzp49K1544QVx+PBhkZaWJr799lsRExMjpkyZIh9DmiY3c+ZMkZCQIH766ScRFBRkdZrcE088IZKTk8W///3vHp+y/Pjjj4udO3eKtLQ0sW/fPjFjxgwRGBgo8vLyhBCm6YB9+vQR27dvF4cPHxYTJkwQEyZMcLjzNGcwGESfPn3EU089ZbHdGa5reXm5OHr0qDh69KgAIP7xj3+Io0ePyrN3XnnlFeHr6yu+/fZbcezYMTF37lyrU7NHjx4tDh48KPbu3SsGDhxoMX23pKREhISEiD/96U/ixIkTYu3atcLDw6PFdFYXFxfx+uuvi+TkZLFs2TKbTN9t63zr6urEDTfcICIjI0VCQoLFa1ma3bF//37x5ptvioSEBJGamio+//xzERQUJG6//XbFnW9b51peXi7++te/igMHDoi0tDTxyy+/iDFjxoiBAweKmpoa+RjOcm0lpaWlwsPDQ7z33nst7u9I17a9zxwheu69eO3atUKn04k1a9aIkydPirvvvlv4+vpazJLqKAYzdgbA6s/q1auFEEJkZGSIKVOmCH9/f6HT6cSAAQPEE088YVGPRAgh0tPTxezZs4W7u7sIDAwUjz/+uKivr7fYZ8eOHWLUqFFCq9WKmJgY+TF6yoIFC0RYWJjQarUiIiJCLFiwQJw9e1a+vbq6Wtx///3Cz89PeHh4iJtuuklcvHjR4hiOcJ7mtmzZIgCIU6dOWWx3huu6Y8cOq8/dRYsWCSFM07Ofe+45ERISInQ6nYiPj2/xdygsLBQLFy4UXl5ewsfHR/z5z38W5eXlFvskJiaKSZMmCZ1OJyIiIsQrr7zSoi3r168XgwYNElqtVgwbNkz88MMPPXq+aWlprb6WpbpCR44cEePHjxd6vV64ubmJ2NhY8dJLL1kEAEo537bOtaqqSsycOVMEBQUJV1dXER0dLe66664WH0DOcm0lH3zwgXB3dxclJSUt7u9I17a9zxwheva9+J133hF9+vQRWq1WXH755eLXX3/t0nmpGk+OiIiIyCExZ4aIiIgcGoMZIiIicmgMZoiIiMihMZghIiIih8ZghoiIiBwagxkiIiJyaAxmiIiIyKExmCEiIiKHxmCGiIiIHBqDGSIiInJoDGaIiIjIof1/tZeLyNQSjWMAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df_w_bins[df_w_bins[\"MedHouseVal_bins\"] == 5][\"Longitude\"].plot(\n", - " title=\"Longitude feature values before calibration\"\n", - ");" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "144a8779", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df_smoothed_w_bins[df_w_bins[\"MedHouseVal_bins\"] == 5][\"Longitude\"].plot(\n", - " title=\"Longitude feature values after calibration\\n(only slight change in values)\"\n", - ");" - ] - }, - { - "cell_type": "markdown", - "id": "771a9011", - "metadata": {}, - "source": [ - "# Data preparation" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "6d1a2d52", - "metadata": {}, - "outputs": [], - "source": [ - "df_train, df_valid = train_test_split(df, test_size=0.2, random_state=1)\n", - "df_valid, df_test = train_test_split(df_valid, test_size=0.5, random_state=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "78a5061f", - "metadata": {}, - "outputs": [], - "source": [ - "continuous_cols = df.drop(columns=[\"MedHouseVal\"]).columns.values.tolist()" - ] - }, - { - "cell_type": "markdown", - "id": "61ef884d", - "metadata": {}, - "source": [ - "# Model with LDS & FDS" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "368867f4", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/javierrodriguezzaurin/Projects/pytorch-widedeep/pytorch_widedeep/preprocessing/tab_preprocessor.py:295: DeprecationWarning: 'scale' and 'already_standard' will be deprecated in the next release. Please use 'cols_to_scale' instead\n", - " self._check_inputs(cat_embed_cols)\n" - ] - } - ], - "source": [ - "# deeptabular\n", - "tab_preprocessor = TabPreprocessor(continuous_cols=continuous_cols, scale=True)\n", - "X_tab_train = tab_preprocessor.fit_transform(df_train)\n", - "X_tab_valid = tab_preprocessor.transform(df_valid)\n", - "X_tab_test = tab_preprocessor.transform(df_test)\n", - "\n", - "# target\n", - "y_train = df_train[\"MedHouseVal\"].values\n", - "y_valid = df_valid[\"MedHouseVal\"].values\n", - "y_test = df_test[\"MedHouseVal\"].values\n", - "\n", - "X_train = {\"X_tab\": X_tab_train, \"target\": y_train}\n", - "X_val = {\"X_tab\": X_tab_valid, \"target\": y_valid}" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "1329d458", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "WideDeep(\n", - " (deeptabular): TabMlp(\n", - " (cont_norm): Identity()\n", - " (encoder): MLP(\n", - " (mlp): Sequential(\n", - " (dense_layer_0): Sequential(\n", - " (0): Linear(in_features=8, out_features=200, bias=True)\n", - " (1): ReLU(inplace=True)\n", - " (2): Dropout(p=0.1, inplace=False)\n", - " )\n", - " (dense_layer_1): Sequential(\n", - " (0): Linear(in_features=200, out_features=100, bias=True)\n", - " (1): ReLU(inplace=True)\n", - " (2): Dropout(p=0.1, inplace=False)\n", - " )\n", - " )\n", - " )\n", - " )\n", - " (fds_layer): FDSLayer(\n", - " (pred_layer): Linear(in_features=100, out_features=1, bias=True)\n", - " )\n", - ")" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "deeptabular = TabMlp(\n", - " column_idx=tab_preprocessor.column_idx,\n", - " continuous_cols=tab_preprocessor.continuous_cols,\n", - ")\n", - "model = WideDeep(deeptabular=deeptabular, with_fds=True)\n", - "model" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "2b42ad10", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "epoch 1: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 165.40it/s, loss=0.591, metrics={}]\n", - "valid: 100%|██████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 218.64it/s, loss=0.479, metrics={}]\n", - "FDS update: 100%|███████████████████████████████████████████████████████████████████████████████████████████| 331/331 [00:00<00:00, 366.86it/s]\n", - "epoch 2: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:01<00:00, 182.78it/s, loss=0.497, metrics={}]\n", - "valid: 100%|███████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 214.30it/s, loss=0.47, metrics={}]\n", - "FDS update: 100%|███████████████████████████████████████████████████████████████████████████████████████████| 331/331 [00:00<00:00, 350.68it/s]\n", - "epoch 3: 100%|████████████████████████████████████████████████████████████████████████| 331/331 [00:04<00:00, 81.28it/s, loss=0.52, metrics={}]\n", - "valid: 100%|██████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 146.50it/s, loss=0.452, metrics={}]\n", - "FDS update: 100%|███████████████████████████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 122.88it/s]\n", - "epoch 4: 100%|███████████████████████████████████████████████████████████████████████| 331/331 [00:03<00:00, 99.77it/s, loss=0.508, metrics={}]\n", - "valid: 100%|███████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 157.48it/s, loss=0.45, metrics={}]\n", - "FDS update: 100%|███████████████████████████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 147.92it/s]\n", - "epoch 5: 100%|███████████████████████████████████████████████████████████████████████| 331/331 [00:03<00:00, 93.21it/s, loss=0.591, metrics={}]\n", - "valid: 100%|███████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 154.60it/s, loss=0.45, metrics={}]\n", - "FDS update: 100%|███████████████████████████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 145.73it/s]\n", - "predict: 100%|████████████████████████████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 243.46it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "test RMSE: 0.7417540528440087\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "# Optimizers\n", - "deep_opt = SGD(model.deeptabular.parameters(), lr=0.1)\n", - "# LR Scheduler\n", - "deep_sch = lr_scheduler.StepLR(deep_opt, step_size=3)\n", - "# Hyperparameters\n", - "trainer = Trainer(\n", - " model,\n", - " objective=\"huber\",\n", - " lr_schedulers={\"deeptabular\": deep_sch},\n", - " initializers={\n", - " \"deeptabular\": XavierNormal,\n", - " \"fds_layer\": XavierNormal,\n", - " # \"FDS_dropout\": XavierNormal,\n", - " # \"pred_layer\": XavierNormal,\n", - " },\n", - " optimizers={\"deeptabular\": deep_opt},\n", - " metrics=[],\n", - " with_lds=True,\n", - " lds_kernel=\"gaussian\",\n", - " lds_ks=5,\n", - " lds_sigma=2,\n", - " lds_granularity=100,\n", - " lds_reweight=False,\n", - " lds_y_max=None,\n", - " lds_y_min=None,\n", - ")\n", - "\n", - "trainer.fit(X_train=X_train, X_val=X_val, n_epochs=5, batch_size=50)\n", - "\n", - "print(\n", - " f\"test RMSE: {mean_squared_error(y_test, trainer.predict(X_tab=X_tab_test), squared=False)}\"\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "29f977db", - "metadata": {}, - "source": [ - "# Model with LDS only" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "51ec337d", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "epoch 1: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 135.40it/s, loss=0.449, metrics={}]\n", - "valid: 100%|██████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 158.01it/s, loss=0.386, metrics={}]\n", - "epoch 2: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 137.79it/s, loss=0.377, metrics={}]\n", - "valid: 100%|██████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 156.84it/s, loss=0.399, metrics={}]\n", - "epoch 3: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 138.69it/s, loss=0.358, metrics={}]\n", - "valid: 100%|███████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 150.62it/s, loss=0.41, metrics={}]\n", - "epoch 4: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 131.96it/s, loss=0.339, metrics={}]\n", - "valid: 100%|██████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 146.01it/s, loss=0.321, metrics={}]\n", - "epoch 5: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 136.04it/s, loss=0.331, metrics={}]\n", - "valid: 100%|███████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 173.22it/s, loss=0.32, metrics={}]\n", - "predict: 100%|████████████████████████████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 296.77it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "test RMSE: 0.6000006967500053\n" - ] - } - ], - "source": [ - "deeptabular = TabMlp(\n", - " column_idx=tab_preprocessor.column_idx,\n", - " continuous_cols=tab_preprocessor.continuous_cols,\n", - ")\n", - "model = WideDeep(deeptabular=deeptabular, fds=False)\n", - "\n", - "# Optimizers\n", - "deep_opt = SGD(model.deeptabular.parameters(), lr=0.1)\n", - "# LR Scheduler\n", - "deep_sch = lr_scheduler.StepLR(deep_opt, step_size=3)\n", - "# Hyperparameters\n", - "trainer = Trainer(\n", - " model,\n", - " objective=\"huber\",\n", - " lr_schedulers={\"deeptabular\": deep_sch},\n", - " initializers={\"deeptabular\": XavierNormal},\n", - " optimizers={\"deeptabular\": deep_opt},\n", - " metrics=[],\n", - " with_lds=True,\n", - " lds_kernel=\"gaussian\",\n", - " lds_ks=5,\n", - " lds_sigma=2,\n", - " lds_granularity=100,\n", - " lds_reweight=False,\n", - " lds_y_max=None,\n", - " lds_y_min=None,\n", - ")\n", - "\n", - "trainer.fit(X_train=X_train, X_val=X_val, n_epochs=5, batch_size=50)\n", - "\n", - "print(\n", - " f\"test RMSE: {mean_squared_error(y_test, trainer.predict(X_tab=X_tab_test), squared=False)}\"\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "8ee72521", - "metadata": {}, - "source": [ - "# Model without FDS or LDS" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "0836c4e9", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "epoch 1: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 129.54it/s, loss=0.445, metrics={}]\n", - "valid: 100%|██████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 137.64it/s, loss=0.427, metrics={}]\n", - "epoch 2: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 135.98it/s, loss=0.374, metrics={}]\n", - "valid: 100%|██████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 148.50it/s, loss=0.389, metrics={}]\n", - "epoch 3: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 127.72it/s, loss=0.359, metrics={}]\n", - "valid: 100%|██████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 147.63it/s, loss=0.383, metrics={}]\n", - "epoch 4: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 136.54it/s, loss=0.339, metrics={}]\n", - "valid: 100%|██████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 146.55it/s, loss=0.323, metrics={}]\n", - "epoch 5: 100%|██████████████████████████████████████████████████████████████████████| 331/331 [00:02<00:00, 131.18it/s, loss=0.331, metrics={}]\n", - "valid: 100%|██████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 174.87it/s, loss=0.318, metrics={}]\n", - "predict: 100%|████████████████████████████████████████████████████████████████████████████████████████████████| 42/42 [00:00<00:00, 287.25it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "test RMSE: 0.6014019159826868\n" - ] - } - ], - "source": [ - "deeptabular = TabMlp(\n", - " column_idx=tab_preprocessor.column_idx,\n", - " continuous_cols=tab_preprocessor.continuous_cols,\n", - ")\n", - "model = WideDeep(deeptabular=deeptabular, fds=False)\n", - "\n", - "# Optimizers\n", - "deep_opt = SGD(model.deeptabular.parameters(), lr=0.1)\n", - "# LR Scheduler\n", - "deep_sch = lr_scheduler.StepLR(deep_opt, step_size=3)\n", - "# Hyperparameters\n", - "trainer = Trainer(\n", - " model,\n", - " objective=\"huber\",\n", - " lr_schedulers={\"deeptabular\": deep_sch},\n", - " initializers={\"deeptabular\": XavierNormal},\n", - " optimizers={\"deeptabular\": deep_opt},\n", - " metrics=[],\n", - " with_lds=False,\n", - ")\n", - "\n", - "trainer.fit(X_train=X_train, X_val=X_val, n_epochs=5, batch_size=50)\n", - "\n", - "print(\n", - " f\"test RMSE: {mean_squared_error(y_test, trainer.predict(X_tab=X_tab_test), squared=False)}\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "09055e82-c289-4e5d-a697-fd32bb68d018", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.13" - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": false, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": false - }, - "vscode": { - "interpreter": { - "hash": "bee110fa72fc220f84be99700c69baf478c6696e63cfda5b1944123ebc470d26" - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/notebooks/16_Self_Supervised_Pretraning_pt1.ipynb b/examples/notebooks/15_Self_Supervised_Pretraning_pt1.ipynb similarity index 100% rename from examples/notebooks/16_Self_Supervised_Pretraning_pt1.ipynb rename to examples/notebooks/15_Self_Supervised_Pretraning_pt1.ipynb diff --git a/examples/notebooks/16_Self_Supervised_Pretraning_pt2.ipynb b/examples/notebooks/15_Self_Supervised_Pretraning_pt2.ipynb similarity index 100% rename from examples/notebooks/16_Self_Supervised_Pretraning_pt2.ipynb rename to examples/notebooks/15_Self_Supervised_Pretraning_pt2.ipynb diff --git a/examples/notebooks/17_Usign_a_custom_hugging_face_model.ipynb b/examples/notebooks/16_Usign_a_custom_hugging_face_model.ipynb similarity index 100% rename from examples/notebooks/17_Usign_a_custom_hugging_face_model.ipynb rename to examples/notebooks/16_Usign_a_custom_hugging_face_model.ipynb diff --git a/examples/notebooks/18_feature_importance_via_attention_weights.ipynb b/examples/notebooks/17_feature_importance_via_attention_weights.ipynb similarity index 100% rename from examples/notebooks/18_feature_importance_via_attention_weights.ipynb rename to examples/notebooks/17_feature_importance_via_attention_weights.ipynb diff --git a/examples/notebooks/19_wide_and_deep_for_recsys_pt1.ipynb b/examples/notebooks/18_wide_and_deep_for_recsys_pt1.ipynb similarity index 100% rename from examples/notebooks/19_wide_and_deep_for_recsys_pt1.ipynb rename to examples/notebooks/18_wide_and_deep_for_recsys_pt1.ipynb diff --git a/examples/notebooks/19_wide_and_deep_for_recsys_pt2.ipynb b/examples/notebooks/18_wide_and_deep_for_recsys_pt2.ipynb similarity index 100% rename from examples/notebooks/19_wide_and_deep_for_recsys_pt2.ipynb rename to examples/notebooks/18_wide_and_deep_for_recsys_pt2.ipynb diff --git a/examples/notebooks/20_load_from_folder_functionality.ipynb b/examples/notebooks/19_load_from_folder_functionality.ipynb similarity index 100% rename from examples/notebooks/20_load_from_folder_functionality.ipynb rename to examples/notebooks/19_load_from_folder_functionality.ipynb diff --git a/examples/notebooks/21_Using_huggingface_within_widedeep.ipynb b/examples/notebooks/20_Using_huggingface_within_widedeep.ipynb similarity index 100% rename from examples/notebooks/21_Using_huggingface_within_widedeep.ipynb rename to examples/notebooks/20_Using_huggingface_within_widedeep.ipynb diff --git a/examples/scripts/california_housing_fds_lds.py b/examples/scripts/california_housing_fds_lds.py deleted file mode 100644 index 7fd002e7..00000000 --- a/examples/scripts/california_housing_fds_lds.py +++ /dev/null @@ -1,53 +0,0 @@ -import torch -import pandas as pd - -from pytorch_widedeep import Trainer -from pytorch_widedeep.models import TabMlp, WideDeep -from pytorch_widedeep.datasets import load_california_housing -from pytorch_widedeep.callbacks import EarlyStopping, ModelCheckpoint -from pytorch_widedeep.preprocessing import TabPreprocessor - -use_cuda = torch.cuda.is_available() - -if __name__ == "__main__": - df: pd.DataFrame = load_california_housing(as_frame=True) - - target = df.MedHouseVal.values - df = df.drop("MedHouseVal", axis=1) - - continuous_cols = df.columns.tolist() - tab_preprocessor = TabPreprocessor(continuous_cols=continuous_cols, scale=True) - X_tab = tab_preprocessor.fit_transform(df) - - tab_mlp = TabMlp( - column_idx=tab_preprocessor.column_idx, - continuous_cols=continuous_cols, - mlp_hidden_dims=[200, 100], - mlp_dropout=[0.2, 0.2], - ) - model = WideDeep(deeptabular=tab_mlp, with_fds=True, enforce_positive=True) - - model_checkpoint = ModelCheckpoint( - filepath="model_weights/wd_out", - save_best_only=True, - max_save=1, - ) - early_stopping = EarlyStopping(patience=5) - callbacks = [early_stopping, model_checkpoint] - - trainer = Trainer( - model, - objective="regression", - callbacks=callbacks, - ) - - trainer.fit( - X_tab=X_tab, - target=target, - n_epochs=2, - batch_size=256, - val_split=0.2, - with_lds=True, - lds_kernel="triang", - lds_granularity=200, - ) diff --git a/mkdocs/mkdocs.yml b/mkdocs/mkdocs.yml index 0f4165b5..3f8347cf 100644 --- a/mkdocs/mkdocs.yml +++ b/mkdocs/mkdocs.yml @@ -52,15 +52,14 @@ nav: - 12_ZILNLoss_origkeras_vs_pytorch_widedeep: examples/12_ZILNLoss_origkeras_vs_pytorch_widedeep.ipynb - 13_model_uncertainty_prediction: examples/13_model_uncertainty_prediction.ipynb - 14_bayesian_models: examples/14_bayesian_models.ipynb - - 15_DIR-LDS_and_FDS: examples/15_DIR-LDS_and_FDS.ipynb - - 16_Self-Supervised Pre-Training pt 1: examples/16_Self_Supervised_Pretraning_pt1.ipynb - - 16_Self-Supervised Pre-Training pt 2: examples/16_Self_Supervised_Pretraning_pt2.ipynb - - 17_Usign-a-custom-hugging-face-model: examples/17_Usign_a_custom_hugging_face_model.ipynb - - 18_feature_importance_via_attention_weights: examples/18_feature_importance_via_attention_weights.ipynb - - 19_wide_and_deep_for_recsys_pt1: examples/19_wide_and_deep_for_recsys_pt1.ipynb - - 19_wide_and_deep_for_recsys_pt2: examples/19_wide_and_deep_for_recsys_pt2.ipynb - - 20_load_from_folder_functionality: examples/20_load_from_folder_functionality.ipynb - - 21-Using-huggingface-within-widedeep: examples/21_Using_huggingface_within_widedeep.ipynb + - 15_Self-Supervised Pre-Training pt 1: examples/16_Self_Supervised_Pretraning_pt1.ipynb + - 15_Self-Supervised Pre-Training pt 2: examples/16_Self_Supervised_Pretraning_pt2.ipynb + - 16_Usign-a-custom-hugging-face-model: examples/17_Usign_a_custom_hugging_face_model.ipynb + - 17_feature_importance_via_attention_weights: examples/18_feature_importance_via_attention_weights.ipynb + - 18_wide_and_deep_for_recsys_pt1: examples/19_wide_and_deep_for_recsys_pt1.ipynb + - 18_wide_and_deep_for_recsys_pt2: examples/19_wide_and_deep_for_recsys_pt2.ipynb + - 19_load_from_folder_functionality: examples/20_load_from_folder_functionality.ipynb + - 20-Using-huggingface-within-widedeep: examples/21_Using_huggingface_within_widedeep.ipynb - Contributing: contributing.md theme: diff --git a/mkdocs/site/404.html b/mkdocs/site/404.html index c1f720b7..fe1eed8b 100644 --- a/mkdocs/site/404.html +++ b/mkdocs/site/404.html @@ -12,7 +12,7 @@ - + @@ -20,7 +20,7 @@ - + @@ -165,7 +165,7 @@
-
+
Initializing search @@ -182,7 +182,7 @@
- +
pytorch_widedeep @@ -357,7 +357,7 @@
- +
pytorch_widedeep @@ -960,8 +960,6 @@ - - @@ -1299,32 +1297,11 @@
  • - - - - - 15_DIR-LDS_and_FDS - - - - -
    • - - - - - - - - - - -
  • - + - 16_Self-Supervised Pre-Training pt 1 + 15_Self-Supervised Pre-Training pt 1 @@ -1341,11 +1318,11 @@
  • - + - 16_Self-Supervised Pre-Training pt 2 + 15_Self-Supervised Pre-Training pt 2 @@ -1362,11 +1339,11 @@
  • - + - 17_Usign-a-custom-hugging-face-model + 16_Usign-a-custom-hugging-face-model @@ -1383,11 +1360,11 @@
  • - + - 18_feature_importance_via_attention_weights + 17_feature_importance_via_attention_weights @@ -1404,11 +1381,11 @@
  • - + - 19_wide_and_deep_for_recsys_pt1 + 18_wide_and_deep_for_recsys_pt1 @@ -1425,11 +1402,11 @@
  • - + - 19_wide_and_deep_for_recsys_pt2 + 18_wide_and_deep_for_recsys_pt2 @@ -1446,11 +1423,11 @@
  • - + - 20_load_from_folder_functionality + 19_load_from_folder_functionality @@ -1467,11 +1444,11 @@
  • - + - 21-Using-huggingface-within-widedeep + 20-Using-huggingface-within-widedeep @@ -1559,7 +1536,7 @@

    404 - Not found

     - +
    • @@ -1577,7 +1554,7 @@

    404 - Not found

    - + diff --git a/mkdocs/site/assets/_mkdocstrings.css b/mkdocs/site/assets/_mkdocstrings.css index 4b7d98b8..85449ec7 100644 --- a/mkdocs/site/assets/_mkdocstrings.css +++ b/mkdocs/site/assets/_mkdocstrings.css @@ -26,6 +26,11 @@ float: right; } +/* Backward-compatibility: docstring section titles in bold. */ +.doc-section-title { + font-weight: bold; +} + /* Symbols in Navigation and ToC. */ :root, [data-md-color-scheme="default"] { @@ -106,4 +111,9 @@ code.doc-symbol-module { code.doc-symbol-module::after { content: "mod"; -} \ No newline at end of file +} + +.doc-signature .autorefs { + color: inherit; + border-bottom: 1px dotted currentcolor; +} diff --git a/mkdocs/site/contributing.html b/mkdocs/site/contributing.html index 57210de3..0f6e3785 100644 --- a/mkdocs/site/contributing.html +++ b/mkdocs/site/contributing.html @@ -11,12 +11,12 @@ - + - + @@ -24,7 +24,7 @@ - + @@ -169,7 +169,7 @@
    -
    +
    Initializing search @@ -186,7 +186,7 @@
    - +
    pytorch_widedeep @@ -363,7 +363,7 @@
    - +
    pytorch_widedeep @@ -966,8 +966,6 @@ - - @@ -1305,32 +1303,11 @@
  • - - - - - 15_DIR-LDS_and_FDS - - - - -
    • - - - - - - - - - - -
  • - + - 16_Self-Supervised Pre-Training pt 1 + 15_Self-Supervised Pre-Training pt 1 @@ -1347,11 +1324,11 @@
  • - + - 16_Self-Supervised Pre-Training pt 2 + 15_Self-Supervised Pre-Training pt 2 @@ -1368,11 +1345,11 @@
  • - + - 17_Usign-a-custom-hugging-face-model + 16_Usign-a-custom-hugging-face-model @@ -1389,11 +1366,11 @@
  • - + - 18_feature_importance_via_attention_weights + 17_feature_importance_via_attention_weights @@ -1410,11 +1387,11 @@
  • - + - 19_wide_and_deep_for_recsys_pt1 + 18_wide_and_deep_for_recsys_pt1 @@ -1431,11 +1408,11 @@
  • - + - 19_wide_and_deep_for_recsys_pt2 + 18_wide_and_deep_for_recsys_pt2 @@ -1452,11 +1429,11 @@
  • - + - 20_load_from_folder_functionality + 19_load_from_folder_functionality @@ -1473,11 +1450,11 @@
  • - + - 21-Using-huggingface-within-widedeep + 20-Using-huggingface-within-widedeep @@ -1622,7 +1599,7 @@

    Contributing

     - +
    • @@ -1640,7 +1617,7 @@

    Contributing

    - + diff --git a/mkdocs/site/index.html b/mkdocs/site/index.html index 95163aff..78bf4577 100644 --- a/mkdocs/site/index.html +++ b/mkdocs/site/index.html @@ -16,7 +16,7 @@ - + @@ -24,7 +24,7 @@ - + @@ -174,7 +174,7 @@
    -
    +
    Initializing search @@ -191,7 +191,7 @@
    - +
    pytorch_widedeep @@ -368,7 +368,7 @@
    - +
    pytorch_widedeep @@ -981,8 +981,6 @@ - - @@ -1320,32 +1318,11 @@
  • - - - - - 15_DIR-LDS_and_FDS - - - - -
    • - - - - - - - - - - -
  • - + - 16_Self-Supervised Pre-Training pt 1 + 15_Self-Supervised Pre-Training pt 1 @@ -1362,11 +1339,11 @@
  • - + - 16_Self-Supervised Pre-Training pt 2 + 15_Self-Supervised Pre-Training pt 2 @@ -1383,11 +1360,11 @@
  • - + - 17_Usign-a-custom-hugging-face-model + 16_Usign-a-custom-hugging-face-model @@ -1404,11 +1381,11 @@
  • - + - 18_feature_importance_via_attention_weights + 17_feature_importance_via_attention_weights @@ -1425,11 +1402,11 @@
  • - + - 19_wide_and_deep_for_recsys_pt1 + 18_wide_and_deep_for_recsys_pt1 @@ -1446,11 +1423,11 @@
  • - + - 19_wide_and_deep_for_recsys_pt2 + 18_wide_and_deep_for_recsys_pt2 @@ -1467,11 +1444,11 @@
  • - + - 20_load_from_folder_functionality + 19_load_from_folder_functionality @@ -1488,11 +1465,11 @@
  • - + - 21-Using-huggingface-within-widedeep + 20-Using-huggingface-within-widedeep @@ -2270,8 +2247,7 @@

    APA¶< Javier, Pavol Mulinka, - Javier Rodriguez Zaurin, - Not Committed Yet + Javier Rodriguez Zaurin @@ -2321,7 +2297,7 @@

    APA¶< - +

    • @@ -2339,7 +2315,7 @@

    APA¶< - + diff --git a/mkdocs/site/installation.html b/mkdocs/site/installation.html index 58627b83..0cc41b2a 100644 --- a/mkdocs/site/installation.html +++ b/mkdocs/site/installation.html @@ -18,7 +18,7 @@ - + @@ -26,7 +26,7 @@ - + @@ -176,7 +176,7 @@
    -
    +
    Initializing search @@ -193,7 +193,7 @@
    - +
    pytorch_widedeep @@ -370,7 +370,7 @@
    - +
    pytorch_widedeep @@ -1022,8 +1022,6 @@ - - @@ -1361,32 +1359,11 @@
  • - - - - - 15_DIR-LDS_and_FDS - - - - -
    • - - - - - - - - - - -
  • - + - 16_Self-Supervised Pre-Training pt 1 + 15_Self-Supervised Pre-Training pt 1 @@ -1403,11 +1380,11 @@
  • - + - 16_Self-Supervised Pre-Training pt 2 + 15_Self-Supervised Pre-Training pt 2 @@ -1424,11 +1401,11 @@
  • - + - 17_Usign-a-custom-hugging-face-model + 16_Usign-a-custom-hugging-face-model @@ -1445,11 +1422,11 @@
  • - + - 18_feature_importance_via_attention_weights + 17_feature_importance_via_attention_weights @@ -1466,11 +1443,11 @@
  • - + - 19_wide_and_deep_for_recsys_pt1 + 18_wide_and_deep_for_recsys_pt1 @@ -1487,11 +1464,11 @@
  • - + - 19_wide_and_deep_for_recsys_pt2 + 18_wide_and_deep_for_recsys_pt2 @@ -1508,11 +1485,11 @@
  • - + - 20_load_from_folder_functionality + 19_load_from_folder_functionality @@ -1529,11 +1506,11 @@
  • - + - 21-Using-huggingface-within-widedeep + 20-Using-huggingface-within-widedeep @@ -1699,7 +1676,7 @@

    Dependencies - +

    • @@ -1717,7 +1694,7 @@

    Dependencies{"base": ".", "features": ["navigation.tabs", "navigation.tabs.sticky", "navigation.indexes", "navigation.expand", "toc.integrate"], "search": "assets/javascripts/workers/search.b8dbb3d2.min.js", "translations": {"clipboard.copied": "Copied to clipboard", "clipboard.copy": "Copy to clipboard", "search.result.more.one": "1 more on this page", "search.result.more.other": "# more on this page", "search.result.none": "No matching documents", "search.result.one": "1 matching document", "search.result.other": "# matching documents", "search.result.placeholder": "Type to start searching", "search.result.term.missing": "Missing", "select.version": "Select version"}} - + diff --git a/mkdocs/site/objects.inv b/mkdocs/site/objects.inv index f82a2a58f183bbb4eacf62da325c9dceb9033274..a976c4c7c94d02edd681689db2a29d7af5c6c6ff 100644 GIT binary patch delta 1808 zcmV+r2k-c=4}cGlg?~|V;x-V+-}@vr!iz4NKq{6SM9<)<%t)0+QWoB#dT{90w{uYbRN`ut1L8zf5`2kCEZ zLk%(~i|4fPghEN0E(m>-(KjN}%}nJ*!T9Q;_5C?6b|=$ECiS-)k2ar;TlZ_AZ$-|y zy4i9<6iIWEfRNFH-k#X)r))t|!YL#d1)3+HmoP`fOOa>sGEeof5zEL5s=o*APo`z8 z8^(73qIAn>4}bkS>9(H--{}+^n7~w92n6_{?4LvTbwdF0k0ds^BSE!Xf6ym9RNrBM zNC|Q`p3J^YbVG-6dqz)_(J~hwMA+(CmYgb<^INPx0MD7!qmwt@1Bvc@R8jPl1<37a- z{QLtTVgBOYu;&}~@2AO&H_qCaXUI4!Q^gb!D^St1*`C|&d&A3?j1nW@%ZqbrQ&Jj3_1iXjNw{ODke$EPuzP?3l&zrV`q#s1W%-K)Z9Hw_rU> zxSgE0bMl>Y@&067Zx60lG;{kj=XMrS$4Q^8CG3pI+&2pVUI{+LNltohk^I`bwRdMcAc^8~f3CKHu*R ztsiQDb_YVwh9-$5jH_ridU~0Mh(tqfkdANa2kmE5drKnKHpXT>U+;~BmB1zaK_YPx zD0pZJ5ER&Z1@c<&gbK`Q^})h&1}At>ntwy2CJB7exJ)oua4sOB1<1UUvo2RF##c*1 zAwGawFRPc@qQ|kFeefNdUgE8=AoN7WB!x639P&~|3nCdkj0#?!8hOFFtlfNvSno!o zdT;vjGJqs{E$kSo&NljA%@(G+Z7JOPvZ7KE`UXjS*w?eFHAs}53Bm>49SJKyW`94n z4fU&lzWToqP>7tG^*X*XquIV87t#H?-Cw;1Az)nJT}l|3;wMp$CCQ2uDFv%{+YdPG%k9YZ?jjo^51lxW8SL{_Ym7I~ zS-3H1=~i!p{RctB2Jr7l5^sEUQGbp@XVo!7pfR?S16$v$Or9t&-He@oE#;p=6fy0c zwBz6bZ&8Fw{ce(}B+Ddg z>$vRxk%+_azyB{J+wk?b?|;(oK4f%aC5(oY(#4T4NC-hm-T_0$B?bDMbE>rdRviO; zy=Av}-e6x_1)B9wx&WKLYI2#iFB@f%n!_EWH#&n4py~H$O6*sgT=+W7JK;bZ3E{od@hnM zcQ$y+?hhJB48124kvMwHXCo1y_kej>ov?jR%V?gz0q47PI9hxGZ*G zSFbx&+ap;3Rih6g+}8jr-KG@}ij7q&H@~mdpE0w*9mv_X7^Lmmhf*0`py_tNZQcFeF?*LO6-4pNQ#XyC5JNr delta 1855 zcmV-F2f+A%53di9g@503;x-V+-}_hGO#6E7Tps(zCC4N)B$EPjo#~55$ZJqz%dR9R zNB{atG6sYBA%j-FmtYIL-_L4yg)A$SYgGukia%Ha2|yVw$QmRgJkE;*G8rkds4^mU z?HS|HJ~vlJUpHre>61_8`VX2BDL;MDht~Y(#{BPx=2t4uet-S#)8}8x-XM9_`jCFt zHZ&k}vUtu)PbidR*@DnF8GR!nThCNcmW(gYTHjscVs|oqWKzGo_Gt6jxOKk*`c@W< ztD7w+M3Jl@2?!ZI=;Mh!e##dlBb-8VR-k?HX$kX*I2A=6r$wee8?l@$q5iwq{$yIl zx?yb3&q{ZU_J7cCl5X?5_nuC%feB2tg+PEG%Kq7RUpE90|43q!I}%jK^#^^yL;W5G zh?F3=WIwBl5;g5P5O0eHcr9-X}L?pgGW`;AjQOo<1u zFW#8DW_^Q?3q59fa>cS~2pV^6&mCv(@PsRxf;A-Z&d$o+0DB$`n&XEI~!j=6G(8?+q_Y86`%*mlvnhrmz&C z_0W`bWq%(kjd-^(-Mf3207Thj#>Nx3(wS;}7a9_8M zn#SkJE0Wi}7^2-LK7cJ(O8QN)>!7d_zD*+`OAkeL>ES48jKGupV_tX~`9jp_?p2Orf!@7klP$ek(( zm-?GJH&1y}6}Qf#@qE5J8(Kfq0PPNho(*jhNf=krZ1nUp4-tu$+#ns_)(_gxruI@I z)h5Pf!+<^;2P=Vd`h!H`EKu;!lprXu_kSAXwK)kDnB(e$h2;cJ@SwDZNKF#>OXEDj zV8J1S0fmy9n{LLuIRTBY@_x#)3hS08-Grk8jpEC@Z3Gf5%K2#2DQ(Sk@u z_oITBr$%0IE*m%BA=anSs5zUyybK_TUJF}>y0eY`S965vZdVGozO1NJguX!%?|=98 ztZoewWoLqLL3c;O3XnOEZ9}uy&{zML0!mR(^FWX<&1kl3C`5F>s`%UE__ft`R`|f$ zm8t^^Mv1*Ky|lcGA`N^n>6EFVba&rggAg#TXO|KNrua$JV@dKdLrTGV^ZXu%-93+7 z?=G?-^3aI`nZe#)b;fvepM@KPj(={w-RwUIA~t}32atBZ0RI;##D0*$d3Ik5H3 zlgT6HrJJ$yucQ1^h$5!FlXe_D;2nxksehT|Cn7+dX4u=MZWWq)C**=~RK}|cSAdcT z#Yh$h1R13JhwS-d+SsFj14W?m$brN=f!%;2s}jUJlaLq}88?@h?LmS_vwu#r{TITy zdGo^b^U$CM+1m7r5jCbS^+iA=N!}qa&i+434iKWF07C`mILrWHp}Q=JlO|2-w>6Mc zb=_S7>8HShIC?xq26K9c6UO^aP7dd}Md{;pz33|9dfiuS{kdgo0x2Wo5x{> zvHM}4P3ZdDcjBCdOmQjKJB*_U8=^B!KFwJWL;{apZdiTI3#e)_?{Fl34VgaEuXLBaY)}&RHwcq z{IRta`VhL*Q%|H*J_K8SFC>Rs!$t$0vuJ(qR!`&#`OGg~?WIolOO_0#TcsW=Z870Z$s@&zP`p2o>I tCrYp%ZkjDSJtUW)?8q-MMM{#y68^0~&x}!pqzzr%H(bZW{s-CH)@LSuo*MuF diff --git a/mkdocs/site/pytorch-widedeep/bayesian_models.html b/mkdocs/site/pytorch-widedeep/bayesian_models.html index aecb23bd..5c3b989d 100644 --- a/mkdocs/site/pytorch-widedeep/bayesian_models.html +++ b/mkdocs/site/pytorch-widedeep/bayesian_models.html @@ -18,7 +18,7 @@ - + @@ -26,7 +26,7 @@ - + @@ -176,7 +176,7 @@
    -
    +
    Initializing search @@ -193,7 +193,7 @@
    - +
    pytorch_widedeep @@ -372,7 +372,7 @@
    - +
    pytorch_widedeep @@ -1036,8 +1036,6 @@ - - @@ -1375,11 +1373,11 @@
  • - + - 15_DIR-LDS_and_FDS + 15_Self-Supervised Pre-Training pt 1 @@ -1396,11 +1394,11 @@
  • - + - 16_Self-Supervised Pre-Training pt 1 + 15_Self-Supervised Pre-Training pt 2 @@ -1417,11 +1415,11 @@
  • - + - 16_Self-Supervised Pre-Training pt 2 + 16_Usign-a-custom-hugging-face-model @@ -1438,11 +1436,11 @@
  • - + - 17_Usign-a-custom-hugging-face-model + 17_feature_importance_via_attention_weights @@ -1459,11 +1457,11 @@
  • - + - 18_feature_importance_via_attention_weights + 18_wide_and_deep_for_recsys_pt1 @@ -1480,11 +1478,11 @@
  • - + - 19_wide_and_deep_for_recsys_pt1 + 18_wide_and_deep_for_recsys_pt2 @@ -1501,11 +1499,11 @@
  • - + - 19_wide_and_deep_for_recsys_pt2 + 19_load_from_folder_functionality @@ -1522,32 +1520,11 @@
  • - + - 20_load_from_folder_functionality - - - - -
    • - - - - - - - - - - -
  • - - - - - 21-Using-huggingface-within-widedeep + 20-Using-huggingface-within-widedeep @@ -1616,11 +1593,11 @@

    The bayesian models module - BayesianWide + BayesianWide

    -
    BayesianWide(
+
    BayesianWide(
     input_dim,
     pred_dim=1,
     prior_sigma_1=1.0,
@@ -1631,47 +1608,46 @@ 
    )
 
    
 
-  
    
-          
    
-            Bases: BaseBayesianModel
    
+    
    
+            
    
+              Bases: BaseBayesianModel
    
+
 
-  
       
    Defines a Wide model. This is a linear model where the
 non-linearlities are captured via crossed-columns
    
 
 
-
-  
    Parameters:
    
-  
      
-      
    • 
-        input_dim
-            (int)
-        –
-        
      
-          
      size of the Embedding layer. input_dim is the summation of all the
+
      Parameters:
      
+    
        
+        
      • 
+          input_dim
+              (int)
+          –
+          
        
+            
        size of the Embedding layer. input_dim is the summation of all the
 individual values for all the features that go through the wide
 component. For example, if the wide component receives 2 features with
 5 individual values each, input_dim = 10
        
-        
        
-      
        • 
-      
      • 
-        pred_dim
-            (int, default:
-                1
+          
      
+        
      • 
+        
    • 
+          pred_dim
+              (int, default:
+                  1
 )
-        –
-        
      
-          
      size of the ouput tensor containing the predictions
      
-        
      
-      
      • 
-      
    • 
-        prior_sigma_1
-            (float, default:
-                1.0
+          –
+          
      
+            
      size of the ouput tensor containing the predictions
      
+          
      
+        
      • 
+        
    • 
+          prior_sigma_1
+              (float, default:
+                  1.0
 )
-        –
-        
      
-          
      The prior weight distribution is a scaled mixture of two Gaussian
+          –
+          
      
+            
      The prior weight distribution is a scaled mixture of two Gaussian
 densities:
      
 
      \[
    \begin{aligned}
@@ -1681,39 +1657,39 @@ 
      
-        prior_sigma_2
-            (float, default:
-                0.002
+          
      
+        
      • 
+        
    • 
+          prior_sigma_2
+              (float, default:
+                  0.002
 )
-        –
-        
      
-          
      Prior of the sigma parameter for the second of the two Gaussian
+          –
+          
      
+            
      Prior of the sigma parameter for the second of the two Gaussian
 distributions that will be mixed to produce the prior weight
 distribution
      
-        
      
-      
      • 
-      
    • 
-        prior_pi
-            (float, default:
-                0.8
+          
    
+
    • +
  • + prior_pi + (float, default: + 0.8 ) - – -
    -

    Scaling factor that will be used to mix the Gaussians to produce the + – +

    +

    Scaling factor that will be used to mix the Gaussians to produce the prior weight distribution

    -
    -
    • -
  • - posterior_mu_init - (float, default: - 0.0 +
    • + +
  • + posterior_mu_init + (float, default: + 0.0 ) - – -
    -

    The posterior sample of the weights is defined as:

    + – +
    +

    The posterior sample of the weights is defined as:

    \[ \begin{aligned} \mathbf{w} &= \mu + log(1 + exp(\rho)) @@ -1728,39 +1704,37 @@

    \(\mu\) is initialised using a normal distributtion with mean posterior_mu_init and std equal to 0.1.

    -

    -
    • -
  • - posterior_rho_init - (float, default: - -7.0 +
    • + +
  • + posterior_rho_init + (float, default: + -7.0 ) - – -
    -

    As in the case of \(\mu\), \(\rho\) is initialised using a + – +

    +

    As in the case of \(\mu\), \(\rho\) is initialised using a normal distributtion with mean posterior_rho_init and std equal to 0.1.

    -
    -
    • - - - +
    + + -

    Attributes:

    -
      -
    • - bayesian_wide_linear - (Module) - – -
      -

      the linear layer that comprises the wide branch of the model

      -
      -
      • -
    +

    Attributes:

    +
      +
    • + bayesian_wide_linear + (Module) + – +
      +

      the linear layer that comprises the wide branch of the model

      +
      +
      • +
    -

    Examples:

    +

    Examples:

    >>> import torch
 >>> from pytorch_widedeep.bayesian_models import BayesianWide
 >>> X = torch.empty(4, 4).random_(6)
@@ -1768,9 +1742,9 @@ 
    >>> out = wide(X)
    -
    - Source code in pytorch_widedeep/bayesian_models/tabular/bayesian_linear/bayesian_wide.py - 
     83
+                  
    
+                    Source code in pytorch_widedeep/bayesian_models/tabular/bayesian_linear/bayesian_wide.py
+                    
     83
  84
  85
  86
@@ -1816,12 +1790,11 @@ 
    )
     self.bias = nn.Parameter(torch.zeros(pred_dim))
 
    
-                
    
+                  
 
-  
 
-  
    
 
+  
    
 
 
 
@@ -1832,10 +1805,10 @@ 
    
-          BayesianTabMlp
+            BayesianTabMlp
 
 
 
    
-
    BayesianTabMlp(
+
    BayesianTabMlp(
     column_idx,
     *,
     cat_embed_input=None,
@@ -1871,154 +1844,153 @@ 
    )
 
    
 
-  
    
-          
    
-            Bases: BaseBayesianModel
    
+    
    
+            
    
+              Bases: BaseBayesianModel
    
+
 
-  
       
    Defines a BayesianTabMlp model.
    
 
    This class combines embedding representations of the categorical features
 with numerical (aka continuous) features, embedded or not. These are then
 passed through a series of probabilistic dense layers (i.e. a MLP).
    
 
 
-
-  
    Parameters:
    
-  
      
-      
    • 
-        column_idx
-            (Dict[str, int])
-        –
-        
      
-          
      Dict containing the index of the columns that will be passed through
+
      Parameters:
      
+    
        
+        
      • 
+          column_idx
+              (Dict[str, int])
+          –
+          
        
+            
        Dict containing the index of the columns that will be passed through
 the TabMlp model. Required to slice the tensors. e.g. {'education':
 0, 'relationship': 1, 'workclass': 2, ...}
        
-        
        
-      
        • 
-      
      • 
-        cat_embed_input
-            (Optional[List[Tuple[str, int, int]]], default:
-                None
+          
      
+        
      • 
+        
    • 
+          cat_embed_input
+              (Optional[List[Tuple[str, int, int]]], default:
+                  None
 )
-        –
-        
      
-          
      List of Tuples with the column name, number of unique values and
+          –
+          
      
+            
      List of Tuples with the column name, number of unique values and
 embedding dimension. e.g. [(education, 11, 32), ...]
      
-        
      
-      
      • 
-      
    • 
-        cat_embed_activation
-            (Optional[str], default:
-                None
+          
    
+        
+        
  • 
+          cat_embed_activation
+              (Optional[str], default:
+                  None
 )
-        –
-        
    
-          
    Activation function for the categorical embeddings, if any. Currently
+          –
+          
    
+            
    Activation function for the categorical embeddings, if any. Currently
 'tanh', 'relu', 'leaky_relu' and 'gelu' are supported
    
-        
    
-      
    • 
-      
  • 
-        continuous_cols
-            (Optional[List[str]], default:
-                None
+          
    • 
+        
+        
  • 
+          continuous_cols
+              (Optional[List[str]], default:
+                  None
 )
-        –
-        
    
-          
    List with the name of the numeric (aka continuous) columns
    
-        
    
-      
    • 
-      
  • 
-        cont_norm_layer
-            (Optional[Literal[batchnorm, layernorm]], default:
-                None
+          –
+          
    
+            
    List with the name of the numeric (aka continuous) columns
    
+          
    
+        
    • 
+        
  • 
+          cont_norm_layer
+              (Optional[Literal[batchnorm, layernorm]], default:
+                  None
 )
-        –
-        
    
-          
    Type of normalization layer applied to the continuous features. Options
+          –
+          
    
+            
    Type of normalization layer applied to the continuous features. Options
 are: 'layernorm', 'batchnorm' or None.
    
-        
    
-      
    • 
-      
  • 
-        embed_continuous
-            (Optional[bool], default:
-                None
+          
    • 
+        
+        
  • 
+          embed_continuous
+              (Optional[bool], default:
+                  None
 )
-        –
-        
    
-          
    Boolean indicating if the continuous columns will be embedded
+          –
+          
    
+            
    Boolean indicating if the continuous columns will be embedded
 (i.e. passed each through a linear layer with or without activation)
    
-        
    
-      
    • 
-      
  • 
-        cont_embed_dim
-            (Optional[int], default:
-                None
+          
    • 
+        
+        
  • 
+          cont_embed_dim
+              (Optional[int], default:
+                  None
 )
-        –
-        
    
-          
    Size of the continuous embeddings
    
-        
    
-      
    • 
-      
  • 
-        cont_embed_dropout
-            (Optional[float], default:
-                None
+          –
+          
    
+            
    Size of the continuous embeddings
    
+          
    
+        
    • 
+        
  • 
+          cont_embed_dropout
+              (Optional[float], default:
+                  None
 )
-        –
-        
    
-          
    Dropout for the continuous embeddings
    
-        
    
-      
    • 
-      
  • 
-        use_cont_bias
-            (Optional[bool], default:
-                None
+          –
+          
    
+            
    Dropout for the continuous embeddings
    
+          
    
+        
    • 
+        
  • 
+          use_cont_bias
+              (Optional[bool], default:
+                  None
 )
-        –
-        
    
-          
    Boolean indicating if bias will be used for the continuous embeddings
    
-        
    
-      
    • 
-      
  • 
-        cont_embed_activation
-            (Optional[str], default:
-                None
+          –
+          
    
+            
    Boolean indicating if bias will be used for the continuous embeddings
    
+          
    
+        
    • 
+        
  • 
+          cont_embed_activation
+              (Optional[str], default:
+                  None
 )
-        –
-        
    
-          
    Activation function for the continuous embeddings if any. Currently
+          –
+          
    
+            
    Activation function for the continuous embeddings if any. Currently
 'tanh', 'relu', 'leaky_relu' and 'gelu' are supported
    
-        
    
-      
    • 
-      
  • 
-        mlp_hidden_dims
-            (List[int], default:
-                [200, 100]
+          
    • 
+        
+        
  • 
+          mlp_hidden_dims
+              (List[int], default:
+                  [200, 100]
 )
-        –
-        
    
-          
    List with the number of neurons per dense layer in the mlp.
    
-        
    
-      
    • 
-      
  • 
-        mlp_activation
-            (str, default:
-                'leaky_relu'
+          –
+          
    
+            
    List with the number of neurons per dense layer in the mlp.
    
+          
    
+        
    • 
+        
  • 
+          mlp_activation
+              (str, default:
+                  'leaky_relu'
 )
-        –
-        
    
-          
    Activation function for the dense layers of the MLP. Currently
+          –
+          
    
+            
    Activation function for the dense layers of the MLP. Currently
 'tanh', 'relu', 'leaky_relu' and 'gelu' are supported
    
-        
    
-      
    • 
-      
  • 
-        prior_sigma_1
-            (float, default:
-                1
+
    • + +
  • + prior_sigma_1 + (float, default: + 1 ) - – -
    -

    The prior weight distribution is a scaled mixture of two Gaussian + – +

    +

    The prior weight distribution is a scaled mixture of two Gaussian densities:

    \[ \begin{aligned} @@ -2028,40 +2000,40 @@

    - prior_sigma_2 - (float, default: - 0.002 +

    +
    • +
  • + prior_sigma_2 + (float, default: + 0.002 ) - – -
    -

    Prior of the sigma parameter for the second of the two Gaussian + – +

    +

    Prior of the sigma parameter for the second of the two Gaussian distributions that will be mixed to produce the prior weight distribution for each Bayesian linear and embedding layer

    -
    -
    • -
  • - prior_pi - (float, default: - 0.8 + +
    • +
  • + prior_pi + (float, default: + 0.8 ) - – -
    -

    Scaling factor that will be used to mix the Gaussians to produce the + – +

    +

    Scaling factor that will be used to mix the Gaussians to produce the prior weight distribution ffor each Bayesian linear and embedding layer

    -
    -
    • -
  • - posterior_mu_init - (float, default: - 0.0 + +
    • +
  • + posterior_mu_init + (float, default: + 0.0 ) - – -
    -

    The posterior sample of the weights is defined as:

    + – +
    +

    The posterior sample of the weights is defined as:

    $$ \begin{aligned} \mathbf{w} &= \mu + log(1 + exp(\rho)) @@ -2076,48 +2048,46 @@

    \(\mu\) is initialised using a normal distributtion with mean posterior_mu_init and std equal to 0.1.

    -

    -
    • -
  • - posterior_rho_init - (float, default: - -7.0 + +
    • +
  • + posterior_rho_init + (float, default: + -7.0 ) - – -
    -

    As in the case of \(\mu\), \(\rho\) is initialised using a + – +

    +

    As in the case of \(\mu\), \(\rho\) is initialised using a normal distributtion with mean posterior_rho_init and std equal to 0.1.

    -
    -
    • - - + + + -

    Attributes:

    -
      -
    • - bayesian_cat_and_cont_embed - (Module) - – -
      -

      This is the module that processes the categorical and continuous columns

      -
      -
      • -
    • - bayesian_tab_mlp - (Sequential) - – -
      -

      mlp model that will receive the concatenation of the embeddings and +

      Attributes:

      +
        +
      • + bayesian_cat_and_cont_embed + (Module) + – +
        +

        This is the module that processes the categorical and continuous columns

        +
        +
        • +
      • + bayesian_tab_mlp + (Sequential) + – +
        +

        mlp model that will receive the concatenation of the embeddings and the continuous columns

        -
        -
        • -
      - +
      +
      • +
    -

    Examples:

    +

    Examples:

    >>> import torch
 >>> from pytorch_widedeep.bayesian_models import BayesianTabMlp
 >>> X_tab = torch.cat((torch.empty(5, 4).random_(4), torch.rand(5, 1)), axis=1)
@@ -2129,9 +2099,9 @@ 
    >>> out = model(X_tab)
    -
    - Source code in pytorch_widedeep/bayesian_models/tabular/bayesian_mlp/bayesian_tab_mlp.py - 
    134
+                  
    
+                    Source code in pytorch_widedeep/bayesian_models/tabular/bayesian_mlp/bayesian_tab_mlp.py
+                    
    134
 135
 136
 137
@@ -2369,12 +2339,11 @@ 
    posterior_rho_init,
     )
 
    
-                
    
+                  
 
-  
 
-  
    
 
+  
    
 
 
 
@@ -2385,10 +2354,10 @@ 
    
-      
+      
     
   
 
    
@@ -2482,7 +2451,7 @@ 
    {"base": "..", "features": ["navigation.tabs", "navigation.tabs.sticky", "navigation.indexes", "navigation.expand", "toc.integrate"], "search": "../assets/javascripts/workers/search.b8dbb3d2.min.js", "translations": {"clipboard.copied": "Copied to clipboard", "clipboard.copy": "Copy to clipboard", "search.result.more.one": "1 more on this page", "search.result.more.other": "# more on this page", "search.result.none": "No matching documents", "search.result.one": "1 matching document", "search.result.other": "# matching documents", "search.result.placeholder": "Type to start searching", "search.result.term.missing": "Missing", "select.version": "Select version"}}
     
     
-      
+      
       
         
       
diff --git a/mkdocs/site/pytorch-widedeep/bayesian_trainer.html b/mkdocs/site/pytorch-widedeep/bayesian_trainer.html
index f716a54e..fbaa3b6e 100644
--- a/mkdocs/site/pytorch-widedeep/bayesian_trainer.html
+++ b/mkdocs/site/pytorch-widedeep/bayesian_trainer.html
@@ -18,7 +18,7 @@
       
       
       
-      
+      
     
     
       
@@ -26,7 +26,7 @@
       
     
     
-      
+      
       
         
         
@@ -176,7 +176,7 @@
       
     
     
    
-      
    
+      
    
         
    
           
    
             Initializing search
@@ -193,7 +193,7 @@
         
   
    
     
-    
+    
   
    
   
    
     pytorch_widedeep
@@ -372,7 +372,7 @@
       
   
    
     
-    
+    
   
    
   
    
     pytorch_widedeep
@@ -1027,8 +1027,6 @@
         
       
         
-      
-        
       
         
       
@@ -1366,11 +1364,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    15_DIR-LDS_and_FDS
+    15_Self-Supervised Pre-Training pt 1
   
   
 
@@ -1387,11 +1385,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    16_Self-Supervised Pre-Training pt 1
+    15_Self-Supervised Pre-Training pt 2
   
   
 
@@ -1408,11 +1406,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    16_Self-Supervised Pre-Training pt 2
+    16_Usign-a-custom-hugging-face-model
   
   
 
@@ -1429,11 +1427,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    17_Usign-a-custom-hugging-face-model
+    17_feature_importance_via_attention_weights
   
   
 
@@ -1450,11 +1448,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    18_feature_importance_via_attention_weights
+    18_wide_and_deep_for_recsys_pt1
   
   
 
@@ -1471,11 +1469,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    19_wide_and_deep_for_recsys_pt1
+    18_wide_and_deep_for_recsys_pt2
   
   
 
@@ -1492,11 +1490,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    19_wide_and_deep_for_recsys_pt2
+    19_load_from_folder_functionality
   
   
 
@@ -1513,32 +1511,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    20_load_from_folder_functionality
-  
-  
-
-      
-    
    • 
-  
-
-              
-            
-              
-                
-  
-  
-  
-  
-    
  • 
-      
-        
-  
-  
-    21-Using-huggingface-within-widedeep
+    20-Using-huggingface-within-widedeep
   
   
 
@@ -1601,11 +1578,11 @@ 
    Training Deep Learning Prob
 
 
 
    
-          BayesianTrainer
+            BayesianTrainer
 
 
 
    
-
    BayesianTrainer(
+
    BayesianTrainer(
     model,
     objective,
     custom_loss_function=None,
@@ -1619,97 +1596,96 @@ 
    
 )
 
    
 
-  
    
-          
    
-            Bases: BaseBayesianTrainer
    
+    
    
+            
    
+              Bases: BaseBayesianTrainer
    
+
 
-  
       
    Class to set the of attributes that will be used during the
 training process.
    
 
    Both the Bayesian models and the Trainer in this repo are based on the paper:
 Weight Uncertainty in Neural Networks.
    
 
 
-
-  
    Parameters:
    
-  
      
-      
    • 
-        model
-            (BaseBayesianModel)
-        –
-        
      
-          
      An object of class BaseBayesianModel. See the Model Components
+
      Parameters:
      
+    
        
+        
      • 
+          model
+              (BaseBayesianModel)
+          –
+          
        
+            
        An object of class BaseBayesianModel. See the Model Components
 section here in the docs.
        
-        
        
-      
        • 
-      
      • 
-        objective
-            (str)
-        –
-        
        
-          
        Defines the objective, loss or cost function.
        
+          
        
+        
        • 
+        
      • 
+          objective
+              (str)
+          –
+          
        
+            
        Defines the objective, loss or cost function.
        
 Param aliases: loss_function, loss_fn, loss,
 cost_function, cost_fn, cost
        
 Possible values are: 'binary', 'multiclass', 'regression'
        
-        
        
-      
        • 
-      
      • 
-        custom_loss_function
-            (Optional[Module], default:
-                None
+          
      
+        
      • 
+        
    • 
+          custom_loss_function
+              (Optional[Module], default:
+                  None
 )
-        –
-        
      
-          
      If none of the loss functions available suits the user, it is possible
+          –
+          
      
+            
      If none of the loss functions available suits the user, it is possible
 to pass a custom loss function. See for example
 pytorch_widedeep.losses.FocalLoss for the required structure of the
 object or the Examples folder in the repo.
      
-        
      
-      
      • 
-      
    • 
-        optimizer
-            (Optional[Optimizer], default:
-                None
+          
    
+        
    • 
+        
  • 
+          optimizer
+              (Optional[Optimizer], default:
+                  None
 )
-        –
-        
    
-          
    An instance of Pytorch's Optimizer object(e.g. torch.optim.Adam
+          –
+          
    
+            
    An instance of Pytorch's Optimizer object(e.g. torch.optim.Adam
 ()). if no optimizer is passed it will default to AdamW.
    
-        
    
-      
    • 
-      
  • 
-        lr_scheduler
-            (Optional[LRScheduler], default:
-                None
+          
    • 
+        
+        
  • 
+          lr_scheduler
+              (Optional[LRScheduler], default:
+                  None
 )
-        –
-        
    
-          
    An instance of Pytorch's LRScheduler object
+          –
+          
    
+            
    An instance of Pytorch's LRScheduler object
 (e.g torch.optim.lr_scheduler.StepLR(opt, step_size=5)).
    
-        
    
-      
    • 
-      
  • 
-        callbacks
-            (Optional[List[Callback]], default:
-                None
+          
    • 
+        
+        
  • 
+          callbacks
+              (Optional[List[Callback]], default:
+                  None
 )
-        –
-        
    
-          
    List with Callback objects. The three callbacks available in
+          –
+          
    
+            
    List with Callback objects. The three callbacks available in
 pytorch-widedeep are: LRHistory, ModelCheckpoint and
 EarlyStopping. This can also be a custom callback. See
 pytorch_widedeep.callbacks.Callback or the Examples folder in the
 repo.
    
-        
    
-      
    • 
-      
  • 
-        metrics
-            (Optional[Union[List[Metric], List[Metric]]], default:
-                None
+          
    • 
+        
+        
  • 
+          metrics
+              (Optional[Union[List[Metric], List[Metric]]], default:
+                  None
 )
-        –
-        
    
-          
      
+          –
+          
      
+            
        
 
      • List of objects of type Metric. Metrics available are:
   Accuracy, Precision, Recall, FBetaScore,
   F1Score and R2Score. This can also be a custom metric as
@@ -1721,39 +1697,38 @@ 
        
   long as it is an object of typeMetric.
   Seethe instructions
        • 
 
      
-        
      
-      
-      
    • 
-        verbose
-            (int, default:
-                1
+          
    
+        
    • 
+        
  • 
+          verbose
+              (int, default:
+                  1
 )
-        –
-        
    
-          
    Setting it to 0 will print nothing during training.
    
-        
    
-      
    • 
-      
  • 
-        seed
-            (int, default:
-                1
+          –
+          
    
+            
    Setting it to 0 will print nothing during training.
    
+          
    
+        
    • 
+        
  • 
+          seed
+              (int, default:
+                  1
 )
-        –
-        
    
-          
    Random seed to be used internally for train_test_split
    
-        
    
-      
    • 
-  
-
+          –
+          
    
+            
    Random seed to be used internally for train_test_split
    
+          
    
+        
+    
 
 
-  
    Other Parameters:
    
-  
      
-      
    • 
-        **kwargs
-        –
-        
      
-          
      Other infrequently used arguments that can also be passed as kwargs are:
      
+
      Other Parameters:
      
+    
        
+        
      • 
+          **kwargs
+          –
+          
        
+            
        Other infrequently used arguments that can also be passed as kwargs are:
        
 
          
 
        • 
 
          device: str
          
@@ -1775,29 +1750,28 @@ 
          
     learning rate is a bit particular.
          
 
          • 
 
        
-        
        
-      
        • 
-  
      
-
+          
      
+        
      • 
+    
    
 
 
-  
    Attributes:
    
-  
      
-      
    • 
-        cyclic_lr
-            (bool)
-        –
-        
      
-          
      Attribute that indicates if  the lr_scheduler is cyclic_lr
+
      Attributes:
      
+    
        
+        
      • 
+          cyclic_lr
+              (bool)
+          –
+          
        
+            
        Attribute that indicates if  the lr_scheduler is cyclic_lr
 (i.e. CyclicLR or OneCycleLR). See Pytorch schedulers
 <https://pytorch.org/docs/stable/optim.html>_.
        
-        
        
-      
        • 
-  
      
+          
      
+        
      • 
+    
    
 
-                
    
-                  Source code in pytorch_widedeep/training/bayesian_trainer.py
-                  
    115
+                  
    
+                    Source code in pytorch_widedeep/training/bayesian_trainer.py
+                    
    115
 116
 117
 118
@@ -1855,12 +1829,11 @@ 
    
         **kwargs,
     )
 
    
-                
    
+                  
 
-  
 
-  
    
 
+  
    
 
 
 
@@ -1873,13 +1846,12 @@ 
    
 
    
 
 
-
 
    
-          fit
+            fit
 
 
 
    
-
    fit(
+
    fit(
     X_tab,
     target,
     X_tab_val=None,
@@ -1893,118 +1865,117 @@ 
    
 )
 
    
 
-  
    
-  
-      
    Fit method.
    
+    
    
 
+      
    Fit method.
    
 
 
-  
    Parameters:
    
-  
      
-      
    • 
-        X_tab
-            (ndarray)
-        –
-        
      
-          
      tabular dataset
      
-        
      
-      
      • 
-      
    • 
-        target
-            (ndarray)
-        –
-        
      
-          
      target values
      
-        
      
-      
      • 
-      
    • 
-        X_tab_val
-            (Optional[ndarray], default:
-                None
+
      Parameters:
      
+    
        
+        
      • 
+          X_tab
+              (ndarray)
+          –
+          
        
+            
        tabular dataset
        
+          
        
+        
        • 
+        
      • 
+          target
+              (ndarray)
+          –
+          
        
+            
        target values
        
+          
        
+        
        • 
+        
      • 
+          X_tab_val
+              (Optional[ndarray], default:
+                  None
 )
-        –
-        
        
-          
        validation data
        
-        
        
-      
        • 
-      
      • 
-        target_val
-            (Optional[ndarray], default:
-                None
+          –
+          
        
+            
        validation data
        
+          
        
+        
        • 
+        
      • 
+          target_val
+              (Optional[ndarray], default:
+                  None
 )
-        –
-        
        
-          
        validation target values
        
-        
        
-      
        • 
-      
      • 
-        val_split
-            (Optional[float], default:
-                None
+          –
+          
        
+            
        validation target values
        
+          
        
+        
        • 
+        
      • 
+          val_split
+              (Optional[float], default:
+                  None
 )
-        –
-        
        
-          
        An alterative to passing the validation set is to use a train/val
+          –
+          
        
+            
        An alterative to passing the validation set is to use a train/val
 split fraction via val_split
        
-        
        
-      
        • 
-      
      • 
-        n_epochs
-            (int, default:
-                1
+          
    
+        
+        
  • 
+          n_epochs
+              (int, default:
+                  1
 )
-        –
-        
    
-          
    number of epochs
    
-        
    
-      
    • 
-      
  • 
-        validation_freq
-            (int, default:
-                1
+          –
+          
    
+            
    number of epochs
    
+          
    
+        
    • 
+        
  • 
+          validation_freq
+              (int, default:
+                  1
 )
-        –
-        
    
-          
    epochs validation frequency
    
-        
    
-      
    • 
-      
  • 
-        batch_size
-            (int, default:
-                32
+          –
+          
    
+            
    epochs validation frequency
    
+          
    
+        
    • 
+        
  • 
+          batch_size
+              (int, default:
+                  32
 )
-        –
-        
    
-          
    batch size
    
-        
    
-      
    • 
-      
  • 
-        n_train_samples
-            (int, default:
-                2
+          –
+          
    
+            
    batch size
    
+          
    
+        
    • 
+        
  • 
+          n_train_samples
+              (int, default:
+                  2
 )
-        –
-        
    
-          
    number of samples to average over during the training process.
+          –
+          
    
+            
    number of samples to average over during the training process.
 See Weight Uncertainty in Neural Networks for details.
    
-        
    
-      
    • 
-      
  • 
-        n_val_samples
-            (int, default:
-                2
+          
    • 
+        
+        
  • 
+          n_val_samples
+              (int, default:
+                  2
 )
-        –
-        
    
-          
    number of samples to average over during the validation process.
+          –
+          
    
+            
    number of samples to average over during the validation process.
 See Weight Uncertainty in Neural Networks for details.
    
-        
    
-      
    • 
-  
+          
    
+        
+    
 
-          
    
-            Source code in pytorch_widedeep/training/bayesian_trainer.py
-            
    145
+            
    
+              Source code in pytorch_widedeep/training/bayesian_trainer.py
+              
    145
 146
 147
 148
@@ -2234,91 +2205,87 @@ 
    
     self._restore_best_weights()
     self.model.train()
 
    
-          
    
-  
    
+            
+    
 
 
 
-
 
    
 
 
-
 
    
-          predict
+            predict
 
 
 
    
-
    predict(
+
    predict(
     X_tab, n_samples=5, return_samples=False, batch_size=256
 )
 
    
 
-  
    
-  
-      
    Returns the predictions
    
+    
    
 
+      
    Returns the predictions
    
 
 
-  
    Parameters:
    
-  
      
-      
    • 
-        X_tab
-            (ndarray)
-        –
-        
      
-          
      tabular dataset
      
-        
      
-      
      • 
-      
    • 
-        n_samples
-            (int, default:
-                5
+
      Parameters:
      
+    
        
+        
      • 
+          X_tab
+              (ndarray)
+          –
+          
        
+            
        tabular dataset
        
+          
        
+        
        • 
+        
      • 
+          n_samples
+              (int, default:
+                  5
 )
-        –
-        
        
-          
        number of samples that will be either returned or averaged to
+          –
+          
        
+            
        number of samples that will be either returned or averaged to
 produce an overal prediction
        
-        
        
-      
        • 
-      
      • 
-        return_samples
-            (bool, default:
-                False
+          
    
+        
+        
  • 
+          return_samples
+              (bool, default:
+                  False
 )
-        –
-        
    
-          
    Boolean indicating whether the n samples will be averaged or directly returned
    
-        
    
-      
    • 
-      
  • 
-        batch_size
-            (int, default:
-                256
+          –
+          
    
+            
    Boolean indicating whether the n samples will be averaged or directly returned
    
+          
    
+        
    • 
+        
  • 
+          batch_size
+              (int, default:
+                  256
 )
-        –
-        
    
-          
    batch size
    
-        
    
-      
    • 
-  
-
+          –
+          
    
+            
    batch size
    
+          
    
+        
+    
 
 
-  
    Returns:
    
-  
      
-      
    • 
-            np.ndarray:
-        –
-        
      
-          
      array with the predictions
      
-      
      
-      
      • 
-  
    
+
    Returns:
    
+    
      
+        
    • 
+              np.ndarray:
+          –
+          
      
+            
      array with the predictions
      
+          
      
+        
      • 
+    
    
 
-          
    
-            Source code in pytorch_widedeep/training/bayesian_trainer.py
-            
    261
+            
    
+              Source code in pytorch_widedeep/training/bayesian_trainer.py
+              
    261
 262
 263
 264
@@ -2392,91 +2359,87 @@ 
    if self.objective == "multiclass":
         return np.argmax(preds, axis)
 
    
-          
    
-  
    
+            
+    
 
 
 
-
 
    
 
 
-
 
    
-          predict_proba
+            predict_proba
 
 
 
    
-
    predict_proba(
+
    predict_proba(
     X_tab, n_samples=5, return_samples=False, batch_size=256
 )
 
    
 
-  
    
-  
-      
    Returns the predicted probabilities
    
+    
    
 
+      
    Returns the predicted probabilities
    
 
 
-  
    Parameters:
    
-  
      
-      
    • 
-        X_tab
-            (ndarray)
-        –
-        
      
-          
      tabular dataset
      
-        
      
-      
      • 
-      
    • 
-        n_samples
-            (int, default:
-                5
+
      Parameters:
      
+    
        
+        
      • 
+          X_tab
+              (ndarray)
+          –
+          
        
+            
        tabular dataset
        
+          
        
+        
        • 
+        
      • 
+          n_samples
+              (int, default:
+                  5
 )
-        –
-        
        
-          
        number of samples that will be either returned or averaged to
+          –
+          
        
+            
        number of samples that will be either returned or averaged to
 produce an overal prediction
        
-        
        
-      
        • 
-      
      • 
-        return_samples
-            (bool, default:
-                False
+          
    
+        
+        
  • 
+          return_samples
+              (bool, default:
+                  False
 )
-        –
-        
    
-          
    Boolean indicating whether the n samples will be averaged or directly returned
    
-        
    
-      
    • 
-      
  • 
-        batch_size
-            (int, default:
-                256
+          –
+          
    
+            
    Boolean indicating whether the n samples will be averaged or directly returned
    
+          
    
+        
    • 
+        
  • 
+          batch_size
+              (int, default:
+                  256
 )
-        –
-        
    
-          
    batch size
    
-        
    
-      
    • 
-  
-
+          –
+          
    
+            
    batch size
    
+          
    
+        
+    
 
 
-  
    Returns:
    
-  
      
-      
    • 
-            ndarray
-        –
-        
      
-          
      array with the probabilities per class
      
-      
      
-      
      • 
-  
    
+
    Returns:
    
+    
      
+        
    • 
+              ndarray
+          –
+          
      
+            
      array with the probabilities per class
      
+          
      
+        
      • 
+    
    
 
-          
    
-            Source code in pytorch_widedeep/training/bayesian_trainer.py
-            
    299
+            
    
+              Source code in pytorch_widedeep/training/bayesian_trainer.py
+              
    299
 300
 301
 302
@@ -2564,30 +2527,28 @@ 
    if self.objective == "multiclass":
         return preds
 
    
-          
    
-  
    
+            
+    
 
 
 
-
 
    
 
 
-
 
    
-          save
+            save
 
 
 
    
-
    save(
+
    save(
     path,
     save_state_dict=False,
     model_filename="bayesian_model.pt",
 )
 
    
 
-  
    
-  
+    
    
+
       
    Saves the model, training and evaluation history to disk
    
 
    The Trainer class is built so that it 'just' trains a model. With
 that in mind, all the torch related parameters (such as optimizers or
@@ -2598,44 +2559,43 @@ 
    
 any other torch model (e.g. torch.save(model, path)).
    
 
 
-
-  
    Parameters:
    
-  
      
-      
    • 
-        path
-            (str)
-        –
-        
      
-          
      path to the directory where the model and the feature importance
+
      Parameters:
      
+    
        
+        
      • 
+          path
+              (str)
+          –
+          
        
+            
        path to the directory where the model and the feature importance
 attribute will be saved.
        
-        
        
-      
        • 
-      
      • 
-        save_state_dict
-            (bool, default:
-                False
+          
      
+        
      • 
+        
    • 
+          save_state_dict
+              (bool, default:
+                  False
 )
-        –
-        
      
-          
      Boolean indicating whether to save directly the model or the
+          –
+          
      
+            
      Boolean indicating whether to save directly the model or the
 model's state dictionary
      
-        
      
-      
      • 
-      
    • 
-        model_filename
-            (str, default:
-                'bayesian_model.pt'
+          
    
+        
+        
  • 
+          model_filename
+              (str, default:
+                  'bayesian_model.pt'
 )
-        –
-        
    
-          
    filename where the model weights will be store
    
-        
    
-      
    • 
-  
+          –
+          
    
+            
    filename where the model weights will be store
    
+          
    
+        
+    
 
-          
    
-            Source code in pytorch_widedeep/training/bayesian_trainer.py
-            
    344
+            
    
+              Source code in pytorch_widedeep/training/bayesian_trainer.py
+              
    344
 345
 346
 347
@@ -2731,8 +2691,8 @@ 
    
     else:
         torch.save(self.model, model_path)
 
    
-          
    
-  
    
+            
+    
 
 
 
@@ -2740,8 +2700,7 @@ 
    
 
   
 
-  
-
+    
 
 
 
@@ -2816,7 +2775,7 @@ 
    
       
     
     
-      
+      
     
   
 
@@ -2834,7 +2793,7 @@ 
    
     
     
     
-      
+      
       
         
       
diff --git a/mkdocs/site/pytorch-widedeep/callbacks.html b/mkdocs/site/pytorch-widedeep/callbacks.html
index 7360d40a..bc9f877b 100644
--- a/mkdocs/site/pytorch-widedeep/callbacks.html
+++ b/mkdocs/site/pytorch-widedeep/callbacks.html
@@ -18,7 +18,7 @@
       
       
       
-      
+      
     
     
       
@@ -26,7 +26,7 @@
       
     
     
-      
+      
       
         
         
@@ -176,7 +176,7 @@
       
     
     
    
-      
    
+      
    
         
    
           
    
             Initializing search
@@ -193,7 +193,7 @@
         
   
    
     
-    
+    
   
    
   
    
     pytorch_widedeep
@@ -372,7 +372,7 @@
       
   
    
     
-    
+    
   
    
   
    
     pytorch_widedeep
@@ -1045,8 +1045,6 @@
         
       
         
-      
-        
       
         
       
@@ -1384,11 +1382,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    15_DIR-LDS_and_FDS
+    15_Self-Supervised Pre-Training pt 1
   
   
 
@@ -1405,11 +1403,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    16_Self-Supervised Pre-Training pt 1
+    15_Self-Supervised Pre-Training pt 2
   
   
 
@@ -1426,11 +1424,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    16_Self-Supervised Pre-Training pt 2
+    16_Usign-a-custom-hugging-face-model
   
   
 
@@ -1447,11 +1445,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    17_Usign-a-custom-hugging-face-model
+    17_feature_importance_via_attention_weights
   
   
 
@@ -1468,11 +1466,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    18_feature_importance_via_attention_weights
+    18_wide_and_deep_for_recsys_pt1
   
   
 
@@ -1489,11 +1487,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    19_wide_and_deep_for_recsys_pt1
+    18_wide_and_deep_for_recsys_pt2
   
   
 
@@ -1510,11 +1508,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    19_wide_and_deep_for_recsys_pt2
+    19_load_from_folder_functionality
   
   
 
@@ -1531,32 +1529,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    20_load_from_folder_functionality
-  
-  
-
-      
-    
    • 
-  
-
-              
-            
-              
-                
-  
-  
-  
-  
-    
  • 
-      
-        
-  
-  
-    21-Using-huggingface-within-widedeep
+    20-Using-huggingface-within-widedeep
   
   
 
@@ -1624,40 +1601,38 @@ 
    Callbacks
-          LRHistory
+            LRHistory
 
 
 
    
-
    LRHistory(n_epochs)
+
    LRHistory(n_epochs)
 
    
 
-  
    
-          
    
-            Bases: Callback
    
+    
    
+            
    
+              Bases: Callback
    
+
 
-  
       
    Saves the learning rates during training in the lr_history attribute
 of the Trainer.
    
 
    Callbacks are passed as input parameters to the Trainer class. See
 pytorch_widedeep.trainer.Trainer
    
 
 
-
-  
    Parameters:
    
-  
      
-      
    • 
-        n_epochs
-            (int)
-        –
-        
      
-          
      number of training epochs
      
-        
      
-      
      • 
-  
    
-
+
    Parameters:
    
+    
      
+        
    • 
+          n_epochs
+              (int)
+          –
+          
      
+            
      number of training epochs
      
+          
      
+        
      • 
+    
    
 
 
-
    Examples:
    
+
    Examples:
    
     
    >>> from pytorch_widedeep.callbacks import LRHistory
 >>> from pytorch_widedeep.models import TabMlp, Wide, WideDeep
 >>> from pytorch_widedeep.training import Trainer
@@ -1670,20 +1645,19 @@ 
    
 >>> trainer = Trainer(model, objective="regression", callbacks=[LRHistory(n_epochs=10)])
 
    
 
-                
    
-                  Source code in pytorch_widedeep/callbacks.py
-                  
    277
+                  
    
+                    Source code in pytorch_widedeep/callbacks.py
+                    
    277
 278
 279
    def __init__(self, n_epochs: int):
     super(LRHistory, self).__init__()
     self.n_epochs = n_epochs
 
    
-                
    
+                  
 
-  
 
-  
    
 
+  
    
 
 
 
@@ -1694,10 +1668,10 @@ 
    
 
 
 
-  
    
 
   
    
 
+    
    
 
 
 
@@ -1706,11 +1680,11 @@ 
    
 
 
 
    
-          ModelCheckpoint
+            ModelCheckpoint
 
 
 
    
-
    ModelCheckpoint(
+
    ModelCheckpoint(
     filepath=None,
     monitor="val_loss",
     min_delta=0.0,
@@ -1722,11 +1696,11 @@ 
    
 )
 
    
 
-  
    
-          
    
-            Bases: Callback
    
+    
    
+            
    
+              Bases: Callback
    
+
 
-  
       
    Saves the model after every epoch.
    
 
    This class is almost identical to the corresponding keras class.
 Therefore, credit to the Keras Team.
    
@@ -1734,142 +1708,139 @@ 
    
 pytorch_widedeep.trainer.Trainer
    
 
 
-
-  
    Parameters:
    
-  
      
-      
    • 
-        filepath
-            (Optional[str], default:
-                None
+
      Parameters:
      
+    
        
+        
      • 
+          filepath
+              (Optional[str], default:
+                  None
 )
-        –
-        
        
-          
        Full path to save the output weights. It must contain only the root of
+          –
+          
        
+            
        Full path to save the output weights. It must contain only the root of
 the filenames. Epoch number and .pt extension (for pytorch) will be
 added. e.g. filepath="path/to/output_weights/weights_out" And the
 saved files in that directory will be named:
 'weights_out_1.pt', 'weights_out_2.pt', .... If set to None the
 class just report best metric and best_epoch.
        
-        
        
-      
        • 
-      
      • 
-        monitor
-            (str, default:
-                'val_loss'
+          
    
+        
+        
  • 
+          monitor
+              (str, default:
+                  'val_loss'
 )
-        –
-        
    
-          
    quantity to monitor. Typically 'val_loss' or metric name
+          –
+          
    
+            
    quantity to monitor. Typically 'val_loss' or metric name
 (e.g. 'val_acc')
    
-        
    
-      
    • 
-      
  • 
-        min_delta
-            (float, default:
-                0.0
+          
    • 
+        
+        
  • 
+          min_delta
+              (float, default:
+                  0.0
 )
-        –
-        
    
-          
    minimum change in the monitored quantity to qualify as an
+          –
+          
    
+            
    minimum change in the monitored quantity to qualify as an
 improvement, i.e. an absolute change of less than min_delta, will
 count as no improvement.
    
-        
    
-      
    • 
-      
  • 
-        verbose
-            (int, default:
-                0
+          
    • 
+        
+        
  • 
+          verbose
+              (int, default:
+                  0
 )
-        –
-        
    
-          
    verbosity mode
    
-        
    
-      
    • 
-      
  • 
-        save_best_only
-            (bool, default:
-                False
+          –
+          
    
+            
    verbosity mode
    
+          
    
+        
    • 
+        
  • 
+          save_best_only
+              (bool, default:
+                  False
 )
-        –
-        
    
-          
    the latest best model according to the quantity monitored will not be
+          –
+          
    
+            
    the latest best model according to the quantity monitored will not be
 overwritten.
    
-        
    
-      
    • 
-      
  • 
-        mode
-            (str, default:
-                'auto'
+          
+        
    • 
+        
  • 
+          mode
+              (str, default:
+                  'auto'
 )
-        –
-        
    
-          
    If save_best_only=True, the decision to overwrite the current save
+          –
+          
    
+            
    If save_best_only=True, the decision to overwrite the current save
 file is made based on either the maximization or the minimization of
 the monitored quantity. For 'acc', this should be 'max', for
 'loss' this should be 'min', etc. In 'auto' mode, the
 direction is automatically inferred from the name of the monitored
 quantity.
    
-        
    
-      
    • 
-      
  • 
-        period
-            (int, default:
-                1
+          
+        
    • 
+        
  • 
+          period
+              (int, default:
+                  1
 )
-        –
-        
    
-          
    Interval (number of epochs) between checkpoints.
    
-        
    
-      
    • 
-      
  • 
-        max_save
-            (int, default:
-                -1
+          –
+          
    
+            
    Interval (number of epochs) between checkpoints.
    
+          
    
+        
    • 
+        
  • 
+          max_save
+              (int, default:
+                  -1
 )
-        –
-        
    
-          
    Maximum number of outputs to save. If -1 will save all outputs
    
-        
    
-      
    • 
-  
-
+          –
+          
    
+            
    Maximum number of outputs to save. If -1 will save all outputs
    
+          
    
+        
+    
 
 
-  
    Attributes:
    
-  
      
-      
    • 
-        best
-            (float)
-        –
-        
      
-          
      best metric
      
-        
      
-      
      • 
-      
    • 
-        best_epoch
-            (int)
-        –
-        
      
-          
      best epoch
      
-        
      
-      
      • 
-      
    • 
-        best_state_dict
-            (dict)
-        –
-        
      
-          
      best model state dictionary.
      
+
      Attributes:
      
+    
        
+        
      • 
+          best
+              (float)
+          –
+          
        
+            
        best metric
        
+          
        
+        
        • 
+        
      • 
+          best_epoch
+              (int)
+          –
+          
        
+            
        best epoch
        
+          
        
+        
        • 
+        
      • 
+          best_state_dict
+              (dict)
+          –
+          
        
+            
        best model state dictionary.
        
 To restore model to its best state use Trainer.model.load_state_dict
 (model_checkpoint.best_state_dict) where model_checkpoint is an
 instance of the class ModelCheckpoint. See the Examples folder in
 the repo or the Examples section in this documentation for details
        
-        
        
-      
        • 
-  
      
-
+          
      
+        
      • 
+    
    
 
 
-
    Examples:
    
+
    Examples:
    
     
    >>> from pytorch_widedeep.callbacks import ModelCheckpoint
 >>> from pytorch_widedeep.models import TabMlp, Wide, WideDeep
 >>> from pytorch_widedeep.training import Trainer
@@ -1882,9 +1853,9 @@ 
    
 >>> trainer = Trainer(model, objective="regression", callbacks=[ModelCheckpoint(filepath='checkpoints/weights_out')])
 
    
 
-                
    
-                  Source code in pytorch_widedeep/callbacks.py
-                  
    446
+                  
    
+                    Source code in pytorch_widedeep/callbacks.py
+                    
    446
 447
 448
 449
@@ -2010,12 +1981,11 @@ 
    
     else:
         self.min_delta *= -1
 
    
-                
    
+                  
 
-  
 
-  
    
 
+  
    
 
 
 
@@ -2026,10 +1996,10 @@ 
    
 
 
 
-  
    
 
   
    
 
+    
    
 
 
 
@@ -2038,11 +2008,11 @@ 
    
 
 
 
    
-          EarlyStopping
+            EarlyStopping
 
 
 
    
-
    EarlyStopping(
+
    EarlyStopping(
     monitor="val_loss",
     min_delta=0.0,
     patience=10,
@@ -2053,11 +2023,11 @@ 
    
 )
 
    
 
-  
    
-          
    
-            Bases: Callback
    
+    
    
+            
    
+              Bases: Callback
    
+
 
-  
       
    Stop training when a monitored quantity has stopped improving.
    
 
    This class is almost identical to the corresponding keras class.
 Therefore, credit to the Keras Team.
    
@@ -2065,117 +2035,114 @@ 
    
 pytorch_widedeep.trainer.Trainer
    
 
 
-
-  
    Parameters:
    
-  
      
-      
    • 
-        monitor
-            (str, default:
-                'val_loss'
+
      Parameters:
      
+    
        
+        
      • 
+          monitor
+              (str, default:
+                  'val_loss'
 )
-        –
-        
        
-          
        Quantity to monitor. Typically 'val_loss' or metric name
+          –
+          
        
+            
        Quantity to monitor. Typically 'val_loss' or metric name
 (e.g. 'val_acc')
        
-        
        
-      
        • 
-      
      • 
-        min_delta
-            (float, default:
-                0.0
+          
    
+        
+        
  • 
+          min_delta
+              (float, default:
+                  0.0
 )
-        –
-        
    
-          
    minimum change in the monitored quantity to qualify as an
+          –
+          
    
+            
    minimum change in the monitored quantity to qualify as an
 improvement, i.e. an absolute change of less than min_delta, will
 count as no improvement.
    
-        
    
-      
    • 
-      
  • 
-        patience
-            (int, default:
-                10
+          
    • 
+        
+        
  • 
+          patience
+              (int, default:
+                  10
 )
-        –
-        
    
-          
    Number of epochs that produced the monitored quantity with no
+          –
+          
    
+            
    Number of epochs that produced the monitored quantity with no
 improvement after which training will be stopped.
    
-        
    
-      
    • 
-      
  • 
-        verbose
-            (int, default:
-                0
+          
    • 
+        
+        
  • 
+          verbose
+              (int, default:
+                  0
 )
-        –
-        
    
-          
    verbosity mode.
    
-        
    
-      
    • 
-      
  • 
-        mode
-            (str, default:
-                'auto'
+          –
+          
    
+            
    verbosity mode.
    
+          
    
+        
    • 
+        
  • 
+          mode
+              (str, default:
+                  'auto'
 )
-        –
-        
    
-          
    one of {'auto', 'min', 'max'}. In 'min' mode, training will
+          –
+          
    
+            
    one of {'auto', 'min', 'max'}. In 'min' mode, training will
 stop when the quantity monitored has stopped decreasing; in 'max'
 mode it will stop when the quantity monitored has stopped increasing;
 in 'auto' mode, the direction is automatically inferred from the
 name of the monitored quantity.
    
-        
    
-      
    • 
-      
  • 
-        baseline
-            (Optional[float], default:
-                None
+          
+        
    • 
+        
  • 
+          baseline
+              (Optional[float], default:
+                  None
 )
-        –
-        
    
-          
    Baseline value for the monitored quantity to reach. Training will
+          –
+          
    
+            
    Baseline value for the monitored quantity to reach. Training will
 stop if the model does not show improvement over the baseline.
    
-        
    
-      
    • 
-      
  • 
-        restore_best_weights
-            (bool, default:
-                False
+          
+        
    • 
+        
  • 
+          restore_best_weights
+              (bool, default:
+                  False
 )
-        –
-        
    
-          
    Whether to restore model weights from the epoch with the best
+          –
+          
    
+            
    Whether to restore model weights from the epoch with the best
 value of the monitored quantity. If False, the model weights
 obtained at the last step of training are used.
    
-        
    
-      
    • 
-  
-
-
+          
+        
+    
 
-  
    Attributes:
    
-  
      
-      
    • 
-        best
-            (float)
-        –
-        
      
-          
      best metric
      
-        
      
-      
      • 
-      
    • 
-        stopped_epoch
-            (int)
-        –
-        
      
-          
      epoch when the training stopped
      
-        
      
-      
      • 
-  
    
 
+
    Attributes:
    
+    
      
+        
    • 
+          best
+              (float)
+          –
+          
      
+            
      best metric
      
+          
      
+        
      • 
+        
    • 
+          stopped_epoch
+              (int)
+          –
+          
      
+            
      epoch when the training stopped
      
+          
      
+        
      • 
+    
    
 
 
-
    Examples:
    
+
    Examples:
    
     
    >>> from pytorch_widedeep.callbacks import EarlyStopping
 >>> from pytorch_widedeep.models import TabMlp, Wide, WideDeep
 >>> from pytorch_widedeep.training import Trainer
@@ -2188,9 +2155,9 @@ 
    
 >>> trainer = Trainer(model, objective="regression", callbacks=[EarlyStopping(patience=10)])
 
    
 
-                
    
-                  Source code in pytorch_widedeep/callbacks.py
-                  
    638
+                  
    
+                    Source code in pytorch_widedeep/callbacks.py
+                    
    638
 639
 640
 641
@@ -2282,12 +2249,11 @@ 
    
     else:
         self.min_delta *= -1
 
    
-                
    
+                  
 
-  
 
-  
    
 
+  
    
 
 
 
@@ -2298,10 +2264,10 @@ 
    
 
 
 
-  
    
 
   
    
 
+    
    
 
 
 
@@ -2377,7 +2343,7 @@ 
    
       
     
     
-      
+      
     
   
 
@@ -2395,7 +2361,7 @@ 
    
     
     
     
-      
+      
       
         
       
diff --git a/mkdocs/site/pytorch-widedeep/dataloaders.html b/mkdocs/site/pytorch-widedeep/dataloaders.html
index f2d76eaa..97ae5a1c 100644
--- a/mkdocs/site/pytorch-widedeep/dataloaders.html
+++ b/mkdocs/site/pytorch-widedeep/dataloaders.html
@@ -18,7 +18,7 @@
       
       
       
-      
+      
     
     
       
@@ -26,7 +26,7 @@
       
     
     
-      
+      
       
         
         
@@ -176,7 +176,7 @@
       
     
     
    
-      
    
+      
    
         
    
           
    
             Initializing search
@@ -193,7 +193,7 @@
         
   
    
     
-    
+    
   
    
   
    
     pytorch_widedeep
@@ -372,7 +372,7 @@
       
   
    
     
-    
+    
   
    
   
    
     pytorch_widedeep
@@ -1027,8 +1027,6 @@
         
       
         
-      
-        
       
         
       
@@ -1366,11 +1364,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    15_DIR-LDS_and_FDS
+    15_Self-Supervised Pre-Training pt 1
   
   
 
@@ -1387,11 +1385,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    16_Self-Supervised Pre-Training pt 1
+    15_Self-Supervised Pre-Training pt 2
   
   
 
@@ -1408,11 +1406,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    16_Self-Supervised Pre-Training pt 2
+    16_Usign-a-custom-hugging-face-model
   
   
 
@@ -1429,11 +1427,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    17_Usign-a-custom-hugging-face-model
+    17_feature_importance_via_attention_weights
   
   
 
@@ -1450,11 +1448,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    18_feature_importance_via_attention_weights
+    18_wide_and_deep_for_recsys_pt1
   
   
 
@@ -1471,11 +1469,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    19_wide_and_deep_for_recsys_pt1
+    18_wide_and_deep_for_recsys_pt2
   
   
 
@@ -1492,11 +1490,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    19_wide_and_deep_for_recsys_pt2
+    19_load_from_folder_functionality
   
   
 
@@ -1513,32 +1511,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    20_load_from_folder_functionality
-  
-  
-
-      
-    
    • 
-  
-
-              
-            
-              
-                
-  
-  
-  
-  
-    
  • 
-      
-        
-  
-  
-    21-Using-huggingface-within-widedeep
+    20-Using-huggingface-within-widedeep
   
   
 
@@ -1606,63 +1583,61 @@ 
    Dataloaders
-          DataLoaderImbalanced
+            DataLoaderImbalanced
 
 
 
    
-
    DataLoaderImbalanced(
+
    DataLoaderImbalanced(
     dataset, batch_size, num_workers, **kwargs
 )
 
    
 
-  
    
-          
    
-            Bases: DataLoader
    
+    
    
+            
    
+              Bases: DataLoader
    
+
 
-  
       
    Class to load and shuffle batches with adjusted weights for imbalanced
 datasets. If the classes do not begin from 0 remapping is necessary. See
 here.
    
 
 
-
-  
    Parameters:
    
-  
      
-      
    • 
-        dataset
-            (WideDeepDataset)
-        –
-        
      
-          
      see pytorch_widedeep.training._wd_dataset
      
-        
      
-      
      • 
-      
    • 
-        batch_size
-            (int)
-        –
-        
      
-          
      size of batch
      
-        
      
-      
      • 
-      
    • 
-        num_workers
-            (int)
-        –
-        
      
-          
      number of workers
      
-        
      
-      
      • 
-  
    
-
+
    Parameters:
    
+    
      
+        
    • 
+          dataset
+              (WideDeepDataset)
+          –
+          
      
+            
      see pytorch_widedeep.training._wd_dataset
      
+          
      
+        
      • 
+        
    • 
+          batch_size
+              (int)
+          –
+          
      
+            
      size of batch
      
+          
      
+        
      • 
+        
    • 
+          num_workers
+              (int)
+          –
+          
      
+            
      number of workers
      
+          
      
+        
      • 
+    
    
 
 
-  
    Other Parameters:
    
-  
      
-      
    • 
-        **kwargs
-        –
-        
      
-          
      This can include any parameter that can be passed to the 'standard'
+
      Other Parameters:
      
+    
        
+        
      • 
+          **kwargs
+          –
+          
        
+            
        This can include any parameter that can be passed to the 'standard'
 pytorch
 DataLoader
 and that is not already explicitely passed to the class. In addition,
@@ -1673,33 +1648,32 @@ 
        \[
 minority \space class \space count \times number \space of \space classes \times oversample\_mul
 \]
        
-        
      
-      
      • 
-  
    
+          
    
+        
    • 
+    
 
-                
    
-                  Source code in pytorch_widedeep/dataloaders.py
-                  
     82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
-100
-101
-102
    def __init__(
+                  
    
+                    Source code in pytorch_widedeep/dataloaders.py
+                    
    72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
    def __init__(
     self, dataset: WideDeepDataset, batch_size: int, num_workers: int, **kwargs
 ):
     assert dataset.Y is not None, (
@@ -1707,7 +1681,6 @@ 
    "target array 'Y'"
     )
 
-    self.with_lds = dataset.with_lds
     if "oversample_mul" in kwargs:
         oversample_mul = kwargs["oversample_mul"]
         del kwargs["oversample_mul"]
@@ -1721,9 +1694,9 @@ 
    dataset, batch_size, num_workers=num_workers, sampler=sampler, **kwargs
     )
 
    
-                
    
+                  
+
 
-  
 
   
    
 
@@ -1739,8 +1712,7 @@ 
    
-      
+      
     
   
 
    
@@ -1834,7 +1806,7 @@ 
    {"base": "..", "features": ["navigation.tabs", "navigation.tabs.sticky", "navigation.indexes", "navigation.expand", "toc.integrate"], "search": "../assets/javascripts/workers/search.b8dbb3d2.min.js", "translations": {"clipboard.copied": "Copied to clipboard", "clipboard.copy": "Copy to clipboard", "search.result.more.one": "1 more on this page", "search.result.more.other": "# more on this page", "search.result.none": "No matching documents", "search.result.one": "1 matching document", "search.result.other": "# matching documents", "search.result.placeholder": "Type to start searching", "search.result.term.missing": "Missing", "select.version": "Select version"}}
     
     
-      
+      
       
         
       
diff --git a/mkdocs/site/pytorch-widedeep/losses.html b/mkdocs/site/pytorch-widedeep/losses.html
index bf88a090..60bebe62 100644
--- a/mkdocs/site/pytorch-widedeep/losses.html
+++ b/mkdocs/site/pytorch-widedeep/losses.html
@@ -18,7 +18,7 @@
       
       
       
-      
+      
     
     
       
@@ -26,7 +26,7 @@
       
     
     
-      
+      
       
         
         
@@ -176,7 +176,7 @@
       
     
     
    
-      
    
+      
    
         
    
           
    
             Initializing search
@@ -193,7 +193,7 @@
         
   
    
     
-    
+    
   
    
   
    
     pytorch_widedeep
@@ -372,7 +372,7 @@
       
   
    
     
-    
+    
   
    
   
    
     pytorch_widedeep
@@ -1198,8 +1198,6 @@
         
       
         
-      
-        
       
         
       
@@ -1537,32 +1535,11 @@
   
   
     
  • 
-      
-        
-  
-  
-    15_DIR-LDS_and_FDS
-  
-  
-
-      
-    
    • 
-  
-
-              
-            
-              
-                
-  
-  
-  
-  
-    
  • 
-      
+      
         
   
   
-    16_Self-Supervised Pre-Training pt 1
+    15_Self-Supervised Pre-Training pt 1
   
   
 
@@ -1579,11 +1556,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    16_Self-Supervised Pre-Training pt 2
+    15_Self-Supervised Pre-Training pt 2
   
   
 
@@ -1600,11 +1577,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    17_Usign-a-custom-hugging-face-model
+    16_Usign-a-custom-hugging-face-model
   
   
 
@@ -1621,11 +1598,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    18_feature_importance_via_attention_weights
+    17_feature_importance_via_attention_weights
   
   
 
@@ -1642,11 +1619,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    19_wide_and_deep_for_recsys_pt1
+    18_wide_and_deep_for_recsys_pt1
   
   
 
@@ -1663,11 +1640,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    19_wide_and_deep_for_recsys_pt2
+    18_wide_and_deep_for_recsys_pt2
   
   
 
@@ -1684,11 +1661,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    20_load_from_folder_functionality
+    19_load_from_folder_functionality
   
   
 
@@ -1705,11 +1682,11 @@
   
   
     
  • 
-      
+      
         
   
   
-    21-Using-huggingface-within-widedeep
+    20-Using-huggingface-within-widedeep
   
   
 
@@ -1789,35 +1766,31 @@ 
    Losses
-          MSELoss
+            MSELoss
 
 
 
    
-
    MSELoss()
+
    MSELoss()
 
    
 
-  
    
-          
    
-            Bases: Module
    
+    
    
+            
    
+              Bases: Module
    
 
-  
-      
    Mean square error loss with the option of using Label Smooth
-Distribution (LDS)
    
-
    LDS is based on
-Delving into Deep Imbalanced Regression.
    
 
-                
    
-                  Source code in pytorch_widedeep/losses.py
-                  
    25
-26
    def __init__(self):
+      
    Mean square error loss
    
+
+                  
    
+                    Source code in pytorch_widedeep/losses.py
+                    
    23
+24
    def __init__(self):
     super().__init__()
 
    
-                
    
+                  
 
-  
 
-  
    
 
+  
    
 
 
 
@@ -1830,65 +1803,53 @@ 
    
 
    
 
 
-
 
    
-          forward
+            forward
 
 
 
    
-
    forward(input, target, lds_weight=None)
+
    forward(input, target)
 
    
 
-  
    
-  
-
+    
    
 
 
-  
    Parameters:
    
-  
      
-      
    • 
-        input
-            (Tensor)
-        –
-        
      
-          
      Input tensor with predictions
      
-        
      
-      
      • 
-      
    • 
-        target
-            (Tensor)
-        –
-        
      
-          
      Target tensor with the actual values
      
-        
      
-      
      • 
-      
    • 
-        lds_weight
-            (Optional[Tensor], default:
-                None
-)
-        –
-        
      
-          
      Tensor of weights that will multiply the loss value.
      
-        
      
-      
      • 
-  
    
 
+
    Parameters:
    
+    
      
+        
    • 
+          input
+              (Tensor)
+          –
+          
      
+            
      Input tensor with predictions
      
+          
      
+        
      • 
+        
    • 
+          target
+              (Tensor)
+          –
+          
      
+            
      Target tensor with the actual values
      
+          
      
+        
      • 
+    
    
 
 
-
    Examples:
    
+
    Examples:
    
     
    >>> import torch
 >>> from pytorch_widedeep.losses import MSELoss
 >>>
 >>> target = torch.tensor([1, 1.2, 0, 2]).view(-1, 1)
 >>> input = torch.tensor([0.6, 0.7, 0.3, 0.8]).view(-1, 1)
->>> lds_weight = torch.tensor([0.1, 0.2, 0.3, 0.4]).view(-1, 1)
->>> loss = MSELoss()(input, target, lds_weight)
+>>> loss = MSELoss()(input, target)
 
    
 
-          
    
-            Source code in pytorch_widedeep/losses.py
-            
    28
+            
    
+              Source code in pytorch_widedeep/losses.py
+              
    26
+27
+28
 29
 30
 31
@@ -1909,13 +1870,10 @@ 
    
 46
 47
 48
-49
-50
-51
-52
-53
-54
    def forward(
-    self, input: Tensor, target: Tensor, lds_weight: Optional[Tensor] = None
+49
    def forward(
+    self,
+    input: Tensor,
+    target: Tensor,
 ) -> Tensor:
     r"""
     Parameters
@@ -1924,8 +1882,6 @@ 
    
         Input tensor with predictions
     target: Tensor
         Target tensor with the actual values
-    lds_weight: Tensor, Optional
-        Tensor of weights that will multiply the loss value.
 
     Examples
     --------
@@ -1934,16 +1890,13 @@ 
    
     >>>
     >>> target = torch.tensor([1, 1.2, 0, 2]).view(-1, 1)
     >>> input = torch.tensor([0.6, 0.7, 0.3, 0.8]).view(-1, 1)
-    >>> lds_weight = torch.tensor([0.1, 0.2, 0.3, 0.4]).view(-1, 1)
-    >>> loss = MSELoss()(input, target, lds_weight)
+    >>> loss = MSELoss()(input, target)
     """
     loss = (input - target) ** 2
-    if lds_weight is not None:
-        loss *= lds_weight
     return torch.mean(loss)
 
    
-          
    
-  
    
+            
+    
 
 
 
@@ -1951,8 +1904,7 @@ 
    
 
   
 
-  
-
+    
 
 
 
@@ -1961,35 +1913,31 @@ 
    
 
 
 
    
-          MSLELoss
+            MSLELoss
 
 
 
    
-
    MSLELoss()
+
    MSLELoss()
 
    
 
-  
    
-          
    
-            Bases: Module
    
+    
    
+            
    
+              Bases: Module
    
 
-  
-      
    Mean square log error loss with the option of using Label Smooth
-Distribution (LDS)
    
-
    LDS is based on
-Delving into Deep Imbalanced Regression.
    
 
-                
    
-                  Source code in pytorch_widedeep/losses.py
-                  
    65
-66
    def __init__(self):
+      
    Mean square log error loss
    
+
+                  
    
+                    Source code in pytorch_widedeep/losses.py
+                    
    55
+56
    def __init__(self):
     super().__init__()
 
    
-                
    
+                  
 
-  
 
-  
    
 
+  
    
 
 
 
@@ -2002,99 +1950,84 @@ 
    
 
    
 
 
-
 
    
-          forward
+            forward
 
 
 
    
-
    forward(input, target, lds_weight=None)
+
    forward(input, target)
 
    
 
-  
    
-  
-
+    
    
 
 
-  
    Parameters:
    
-  
      
-      
    • 
-        input
-            (Tensor)
-        –
-        
      
-          
      Input tensor with predictions (not probabilities)
      
-        
      
-      
      • 
-      
    • 
-        target
-            (Tensor)
-        –
-        
      
-          
      Target tensor with the actual classes
      
-        
      
-      
      • 
-      
    • 
-        lds_weight
-            (Optional[Tensor], default:
-                None
-)
-        –
-        
      
-          
      Tensor of weights that will multiply the loss value.
      
-        
      
-      
      • 
-  
    
 
+
    Parameters:
    
+    
      
+        
    • 
+          input
+              (Tensor)
+          –
+          
      
+            
      Input tensor with predictions (not probabilities)
      
+          
      
+        
      • 
+        
    • 
+          target
+              (Tensor)
+          –
+          
      
+            
      Target tensor with the actual classes
      
+          
      
+        
      • 
+    
    
 
 
-
    Examples:
    
+
    Examples:
    
     
    >>> import torch
 >>> from pytorch_widedeep.losses import MSLELoss
 >>>
 >>> target = torch.tensor([1, 1.2, 0, 2]).view(-1, 1)
 >>> input = torch.tensor([0.6, 0.7, 0.3, 0.8]).view(-1, 1)
->>> lds_weight = torch.tensor([0.1, 0.2, 0.3, 0.4]).view(-1, 1)
->>> loss = MSLELoss()(input, target, lds_weight)
+>>> loss = MSLELoss()(input, target)
 
    
 
-          
    
-            Source code in pytorch_widedeep/losses.py
-            
     68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
-100
-101
    def forward(
-    self, input: Tensor, target: Tensor, lds_weight: Optional[Tensor] = None
+            
    
+              Source code in pytorch_widedeep/losses.py
+              
    58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
    def forward(
+    self,
+    input: Tensor,
+    target: Tensor,
 ) -> Tensor:
     r"""
     Parameters
@@ -2103,8 +2036,6 @@ 
    
         Input tensor with predictions (not probabilities)
     target: Tensor
         Target tensor with the actual classes
-    lds_weight: Tensor, Optional
-        Tensor of weights that will multiply the loss value.
 
     Examples
     --------
@@ -2113,8 +2044,7 @@ 
    
     >>>
     >>> target = torch.tensor([1, 1.2, 0, 2]).view(-1, 1)
     >>> input = torch.tensor([0.6, 0.7, 0.3, 0.8]).view(-1, 1)
-    >>> lds_weight = torch.tensor([0.1, 0.2, 0.3, 0.4]).view(-1, 1)
-    >>> loss = MSLELoss()(input, target, lds_weight)
+    >>> loss = MSLELoss()(input, target)
     """
     assert (
         input.min() >= 0
@@ -2124,12 +2054,10 @@ 
    
     assert target.min() >= 0, "All target values must be >=0"
 
     loss = (torch.log(input + 1) - torch.log(target + 1)) ** 2
-    if lds_weight is not None:
-        loss *= lds_weight
     return torch.mean(loss)
 
    
-          
    
-  
    
+            
+    
 
 
 
@@ -2137,8 +2065,7 @@ 
    
 
   
 
-  
-
+    
 
 
 
@@ -2147,35 +2074,31 @@ 
    
 
 
 
    
-          RMSELoss
+            RMSELoss
 
 
 
    
-
    RMSELoss()
+
    RMSELoss()
 
    
 
-  
    
-          
    
-            Bases: Module
    
+    
    
+            
    
+              Bases: Module
    
 
-  
-      
    Root mean square error loss adjusted for the possibility of using Label
-Smooth Distribution (LDS)
    
-
    LDS is based on
-Delving into Deep Imbalanced Regression.
    
 
-                
    
-                  Source code in pytorch_widedeep/losses.py
-                  
    112
-113
    def __init__(self):
+      
    Root mean square error loss
    
+
+                  
    
+                    Source code in pytorch_widedeep/losses.py
+                    
    97
+98
    def __init__(self):
     super().__init__()
 
    
-                
    
+                  
 
-  
 
-  
    
 
+  
    
 
 
 
@@ -2188,93 +2111,70 @@ 
    
 
    
 
 
-
 
    
-          forward
+            forward
 
 
 
    
-
    forward(input, target, lds_weight=None)
+
    forward(input, target)
 
    
 
-  
    
-  
-
+    
    
 
 
-  
    Parameters:
    
-  
      
-      
    • 
-        input
-            (Tensor)
-        –
-        
      
-          
      Input tensor with predictions (not probabilities)
      
-        
      
-      
      • 
-      
    • 
-        target
-            (Tensor)
-        –
-        
      
-          
      Target tensor with the actual classes
      
-        
      
-      
      • 
-      
    • 
-        lds_weight
-            (Optional[Tensor], default:
-                None
-)
-        –
-        
      
-          
      Tensor of weights that will multiply the loss value.
      
-        
      
-      
      • 
-  
    
 
+
    Parameters:
    
+    
      
+        
    • 
+          input
+              (Tensor)
+          –
+          
      
+            
      Input tensor with predictions (not probabilities)
      
+          
      
+        
      • 
+        
    • 
+          target
+              (Tensor)
+          –
+          
      
+            
      Target tensor with the actual classes
      
+          
      
+        
      • 
+    
    
 
 
-
    Examples:
    
+
    Examples:
    
     
    >>> import torch
 >>> from pytorch_widedeep.losses import RMSELoss
 >>>
 >>> target = torch.tensor([1, 1.2, 0, 2]).view(-1, 1)
 >>> input = torch.tensor([0.6, 0.7, 0.3, 0.8]).view(-1, 1)
->>> lds_weight = torch.tensor([0.1, 0.2, 0.3, 0.4]).view(-1, 1)
->>> loss = RMSELoss()(input, target, lds_weight)
+>>> loss = RMSELoss()(input, target)
 
    
 
-          
    
-            Source code in pytorch_widedeep/losses.py
-            
    115
+            
    
+              Source code in pytorch_widedeep/losses.py
+              
    100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
 116
 117
 118
-119
-120
-121
-122
-123
-124
-125
-126
-127
-128
-129
-130
-131
-132
-133
-134
-135
-136
-137
-138
-139
-140
-141
    def forward(
-    self, input: Tensor, target: Tensor, lds_weight: Optional[Tensor] = None
-) -> Tensor:
+119
    def forward(self, input: Tensor, target: Tensor) -> Tensor:
     r"""
     Parameters
     ----------
@@ -2282,8 +2182,6 @@ 
    
         Input tensor with predictions (not probabilities)
     target: Tensor
         Target tensor with the actual classes
-    lds_weight: Tensor, Optional
-        Tensor of weights that will multiply the loss value.
 
     Examples
     --------
@@ -2292,16 +2190,13 @@ 
    
     >>>
     >>> target = torch.tensor([1, 1.2, 0, 2]).view(-1, 1)
     >>> input = torch.tensor([0.6, 0.7, 0.3, 0.8]).view(-1, 1)
-    >>> lds_weight = torch.tensor([0.1, 0.2, 0.3, 0.4]).view(-1, 1)
-    >>> loss = RMSELoss()(input, target, lds_weight)
+    >>> loss = RMSELoss()(input, target)
     """
     loss = (input - target) ** 2
-    if lds_weight is not None:
-        loss *= lds_weight
     return torch.sqrt(torch.mean(loss))
 
    
-          
    
-  
    
+            
+    
 
 
 
@@ -2309,8 +2204,7 @@ 
    
 
   
 
-  
-
+    
 
 
 
@@ -2319,35 +2213,31 @@ 
    
 
 
 
    
-          RMSLELoss
+            RMSLELoss
 
 
 
    
-
    RMSLELoss()
+
    RMSLELoss()
 
    
 
-  
    
-          
    
-            Bases: Module
    
+    
    
+            
    
+              Bases: Module
    
 
-  
-      
    Root mean square log error loss adjusted for the possibility of using Label
-Smooth Distribution (LDS)
    
-
    LDS is based on
-Delving into Deep Imbalanced Regression.
    
 
-                
    
-                  Source code in pytorch_widedeep/losses.py
-                  
    152
-153
    def __init__(self):
+      
    Root mean square log error loss
    
+
+                  
    
+                    Source code in pytorch_widedeep/losses.py
+                    
    125
+126
    def __init__(self):
     super().__init__()
 
    
-                
    
+                  
 
-  
 
-  
    
 
+  
    
 
 
 
@@ -2360,100 +2250,77 @@ 
    
 
    
 
 
-
 
    
-          forward
+            forward
 
 
 
    
-
    forward(input, target, lds_weight=None)
+
    forward(input, target)
 
    
 
-  
    
-  
-
+    
    
 
 
-  
    Parameters:
    
-  
      
-      
    • 
-        input
-            (Tensor)
-        –
-        
      
-          
      Input tensor with predictions (not probabilities)
      
-        
      
-      
      • 
-      
    • 
-        target
-            (Tensor)
-        –
-        
      
-          
      Target tensor with the actual classes
      
-        
      
-      
      • 
-      
    • 
-        lds_weight
-            (Optional[Tensor], default:
-                None
-)
-        –
-        
      
-          
      Tensor of weights that will multiply the loss value.
      
-        
      
-      
      • 
-  
    
 
+
    Parameters:
    
+    
      
+        
    • 
+          input
+              (Tensor)
+          –
+          
      
+            
      Input tensor with predictions (not probabilities)
      
+          
      
+        
      • 
+        
    • 
+          target
+              (Tensor)
+          –
+          
      
+            
      Target tensor with the actual classes
      
+          
      
+        
      • 
+    
    
 
 
-
    Examples:
    
+
    Examples:
    
     
    >>> import torch
 >>> from pytorch_widedeep.losses import RMSLELoss
 >>>
 >>> target = torch.tensor([1, 1.2, 0, 2]).view(-1, 1)
 >>> input = torch.tensor([0.6, 0.7, 0.3, 0.8]).view(-1, 1)
->>> lds_weight = torch.tensor([0.1, 0.2, 0.3, 0.4]).view(-1, 1)
->>> loss = RMSLELoss()(input, target, lds_weight)
+>>> loss = RMSLELoss()(input, target)
 
    
 
-          
    
-            Source code in pytorch_widedeep/losses.py
-            
    155
-156
-157
-158
-159
-160
-161
-162
-163
-164
-165
-166
-167
-168
-169
-170
-171
-172
-173
-174
-175
-176
-177
-178
-179
-180
-181
-182
-183
-184
-185
-186
-187
-188
    def forward(
-    self, input: Tensor, target: Tensor, lds_weight: Optional[Tensor] = None
-) -> Tensor:
+            
    
+              Source code in pytorch_widedeep/losses.py
+              
    128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
    def forward(self, input: Tensor, target: Tensor) -> Tensor:
     r"""
     Parameters
     ----------
@@ -2461,8 +2328,6 @@ 
    
         Input tensor with predictions (not probabilities)
     target: Tensor
         Target tensor with the actual classes
-    lds_weight: Tensor, Optional
-        Tensor of weights that will multiply the loss value.
 
     Examples
     --------
@@ -2471,8 +2336,7 @@ 
    
     >>>
     >>> target = torch.tensor([1, 1.2, 0, 2]).view(-1, 1)
     >>> input = torch.tensor([0.6, 0.7, 0.3, 0.8]).view(-1, 1)
-    >>> lds_weight = torch.tensor([0.1, 0.2, 0.3, 0.4]).view(-1, 1)
-    >>> loss = RMSLELoss()(input, target, lds_weight)
+    >>> loss = RMSLELoss()(input, target)
     """
     assert (
         input.min() >= 0
@@ -2482,12 +2346,10 @@ 
    
     assert target.min() >= 0, "All target values must be >=0"
 
     loss = (torch.log(input + 1) - torch.log(target + 1)) ** 2
-    if lds_weight is not None:
-        loss *= lds_weight
     return torch.sqrt(torch.mean(loss))
 
    
-          
    
-  
    
+            
+    
 
 
 
@@ -2495,8 +2357,7 @@ 
    
 
   
 
-  
-
+    
 
 
 
@@ -2505,20 +2366,20 @@ 
    
 
 
 
    
-          QuantileLoss
+            QuantileLoss
 
 
 
    
-
    QuantileLoss(
+
    QuantileLoss(
     quantiles=[0.02, 0.1, 0.25, 0.5, 0.75, 0.9, 0.98]
 )
 
    
 
-  
    
-          
    
-            Bases: Module
    
+    
    
+            
    
+              Bases: Module
    
+
 
-  
       
    Quantile loss defined as:
    
 
    \[
 Loss = max(q \times (y-y_{pred}), (1-q) \times (y_{pred}-y))
@@ -2527,41 +2388,39 @@ 
    
 pytorch-forecasting.
    
 
 
-
-  
    Parameters:
    
-  
      
-      
    • 
-        quantiles
-            (List[float], default:
-                [0.02, 0.1, 0.25, 0.5, 0.75, 0.9, 0.98]
+
      Parameters:
      
+    
        
+        
      • 
+          quantiles
+              (List[float], default:
+                  [0.02, 0.1, 0.25, 0.5, 0.75, 0.9, 0.98]
 )
-        –
-        
        
-          
        List of quantiles
        
-        
        
-      
        • 
-  
      
+          –
+          
      
+            
      List of quantiles
      
+          
      
+        
      • 
+    
    
 
-                
    
-                  Source code in pytorch_widedeep/losses.py
-                  
    207
-208
-209
-210
-211
-212
    def __init__(
+                  
    
+                    Source code in pytorch_widedeep/losses.py
+                    
    173
+174
+175
+176
+177
+178
    def __init__(
     self,
     quantiles: List[float] = [0.02, 0.1, 0.25, 0.5, 0.75, 0.9, 0.98],
 ):
     super().__init__()
     self.quantiles = quantiles
 
    
-                
    
+                  
 
-  
 
-  
    
 
+  
    
 
 
 
@@ -2574,43 +2433,40 @@ 
    
 
    
 
 
-
 
    
-          forward
+            forward
 
 
 
    
-
    forward(input, target)
+
    forward(input, target)
 
    
 
-  
    
-  
-
+    
    
 
 
-  
    Parameters:
    
-  
      
-      
    • 
-        input
-            (Tensor)
-        –
-        
      
-          
      Input tensor with predictions
      
-        
      
-      
      • 
-      
    • 
-        target
-            (Tensor)
-        –
-        
      
-          
      Target tensor with the actual values
      
-        
      
-      
      • 
-  
    
 
+
    Parameters:
    
+    
      
+        
    • 
+          input
+              (Tensor)
+          –
+          
      
+            
      Input tensor with predictions
      
+          
      
+        
      • 
+        
    • 
+          target
+              (Tensor)
+          –
+          
      
+            
      Target tensor with the actual values
      
+          
      
+        
      • 
+    
    
 
 
-
    Examples:
    
+
    Examples:
    
     
    >>> import torch
 >>>
 >>> from pytorch_widedeep.losses import QuantileLoss
@@ -2622,44 +2478,44 @@ 
    
 >>> loss = qloss(input, target)
 
    
 
-          
    
-            Source code in pytorch_widedeep/losses.py
-            
    214
-215
-216
-217
-218
-219
-220
-221
-222
-223
-224
-225
-226
-227
-228
-229
-230
-231
-232
-233
-234
-235
-236
-237
-238
-239
-240
-241
-242
-243
-244
-245
-246
-247
-248
-249
    def forward(self, input: Tensor, target: Tensor) -> Tensor:
+            
    
+              Source code in pytorch_widedeep/losses.py
+              
    180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
    def forward(self, input: Tensor, target: Tensor) -> Tensor:
     r"""
     Parameters
     ----------
@@ -2696,8 +2552,8 @@ 
    
 
     return torch.mean(loss)
 
    
-          
    
-  
    
+            
+    
 
 
 
@@ -2705,8 +2561,7 @@ 
    
 
   
 
-  
-
+    
 
 
 
@@ -2715,18 +2570,18 @@ 
    
 
 
 
    
-          FocalLoss
+            FocalLoss
 
 
 
    
-
    FocalLoss(alpha=0.25, gamma=1.0)
+
    FocalLoss(alpha=0.25, gamma=1.0)
 
    
 
-  
    
-          
    
-            Bases: Module
    
+    
    
+            
    
+              Bases: Module
    
+
 
-  
       
    Implementation of the Focal loss
 for both binary and multiclass classification:
    
 
    \[
@@ -2738,47 +2593,45 @@ 
    
 \]
    
 
 
-
-  
    Parameters:
    
-