From d84d07caad8e778dc8e034911f1a47acdf51f4e6 Mon Sep 17 00:00:00 2001 From: Richard Stanton Date: Thu, 14 Dec 2023 18:07:16 +0000 Subject: [PATCH] classifier uncertainty notebook --- .../exploration.ipynb | 2853 +++++++++++++++++ 1 file changed, 2853 insertions(+) create mode 100644 neural_networks/unfinished-dirichlet_distributions/exploration.ipynb diff --git a/neural_networks/unfinished-dirichlet_distributions/exploration.ipynb b/neural_networks/unfinished-dirichlet_distributions/exploration.ipynb new file mode 100644 index 0000000..445181b --- /dev/null +++ b/neural_networks/unfinished-dirichlet_distributions/exploration.ipynb @@ -0,0 +1,2853 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Modelling uncertainty in classification neural networks\n", + "\n", + "Classification neural networks are typically over confident. Particularly when the class predictionsare close to 0 or 1 [ref].\n", + "Measuring confidence is represented by measuring the prediction uncertainty.\n", + "We can build neural networks to model uncertainty as well.\n", + "\n", + "Ref:\n", + "* https://arxiv.org/pdf/2107.03342.pdf\n", + "* https://arxiv.org/pdf/2011.06225.pdf\n", + "* https://en.wikipedia.org/wiki/Dirichlet_distribution\n", + "* Pytorch distributions - https://pytorch.org/docs/stable/distributions.html\n", + "* https://www.youtube.com/watch?v=p1EnIbDItTc" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy.stats\n", + "\n", + "plt.style.use(\"seaborn-v0_8-whitegrid\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Non-contextual version\n", + "We can fit a Beta distribution to random binary data with pytorch.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate data\n", + "\n", + "We need data for a classification problem.\n", + "\n", + "We will first make a non-contextual version.\n", + "We generate data from Bernouli trials with a known success probability.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 1, 1, 1, 0, 0, 1, 0, 1, 0])" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average: 0.6999\n" + ] + } + ], + "source": [ + "# true distribution parameters\n", + "p_success = 0.7\n", + "n_samples = 10000\n", + "\n", + "rand_gen = np.random.default_rng(seed=0)\n", + "\n", + "rand_samples = rand_gen.binomial(n=1, p=p_success, size=(n_samples, 1))\n", + "\n", + "display(rand_samples[:10].flatten())\n", + "print(f\"Average: {rand_samples.mean()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fit pytorch model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The uninformed prior distribution for a Beta is commonly parameterised as [0.5, 0.5].\n", + "Within a pytorch model we need to ensure the parameters remain in the correct domain.\n", + "Beta parameters must be positive, therefore we use the soft plus function to convert them.\n", + "\n", + "\n", + "> Notes\n", + "* How do we fit the loglikelihood of the beta? Common for the PDF to be 0 (logloss of -inf) at 0 and 1.\n", + "* Truncate outcomes to 0.01 and 0.99 for a hack?\n", + "* Conceptually it makes sense?\n", + " * data generating only 1s. beta concentrating at 1 will give higher prob of success than one less certain\n", + " * find log loss of mean outcome? should work. we find the average success and find the log loss of that given our beta" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/_v/nlh4h1yx2n1gd6f3szjlgxt40000gr/T/ipykernel_42343/90226784.py:9: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 4))\n", + "x = torch.linspace(-10, 10, 100)\n", + "y = torch.nn.functional.softplus(x)\n", + "ax.plot(x, y)\n", + "ax.set(xlabel=\"x\", ylabel=\"y\", title=\"\")\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get the equivalent uninformed prior distributino parameters we can find the inverse soft plus, [ref](https://github.com/pytorch/pytorch/issues/72759)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(-0.4328)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def inv_softplus(x):\n", + " return x + torch.log(-torch.expm1(-x))\n", + "\n", + "\n", + "torch.nn.functional.softplus(inv_softplus(torch.tensor(0.5)))\n", + "inv_softplus(torch.tensor(0.5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now construct our Beta distribution in pytorch." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import pytorch_lightning as pl\n", + "import torch\n", + "import torch.distributions\n", + "from typing import List\n", + "\n", + "\n", + "class BetaModel(pl.LightningModule):\n", + " def __init__(self, learning_rate=1e-3, prior_parameters: List[float] = None):\n", + " super().__init__()\n", + "\n", + " if prior_parameters is None:\n", + " prior_parameters = [0.5, 0.5]\n", + " else:\n", + " assert len(prior_parameters) == 2\n", + " assert prior_parameters[0] > 0\n", + " assert prior_parameters[1] > 0\n", + "\n", + " prior_parameters_invsp = inv_softplus(torch.tensor(prior_parameters))\n", + " self.beta_params_invsp = torch.nn.Parameter(prior_parameters_invsp)\n", + "\n", + " self.train_log_error = []\n", + " self.val_log_error = []\n", + " self.beta_params_log = []\n", + " self.learning_rate = learning_rate\n", + "\n", + " def forward(self):\n", + " beta_params_pos = torch.nn.functional.softplus(self.beta_params_invsp)\n", + " dist = torch.distributions.beta.Beta(beta_params_pos[0], beta_params_pos[1])\n", + " return dist\n", + "\n", + " def training_step(self, batch, batch_idx):\n", + " y = batch[0]\n", + "\n", + " # find loglikelihood of y given our current distribution estimate\n", + " dist = self.forward()\n", + " negloglik = -dist.log_prob(y.mean())\n", + " loss = torch.mean(negloglik)\n", + "\n", + " # log training results\n", + " self.train_log_error.append(loss.detach().numpy())\n", + " self.beta_params_log.append(\n", + " torch.nn.functional.softplus(self.beta_params_invsp).detach().numpy()\n", + " )\n", + " return loss\n", + "\n", + " def validation_step(self, batch, batch_idx):\n", + " y = batch[0]\n", + "\n", + " # find loglikelihood of y given our current distribution estimate\n", + " dist = self.forward()\n", + " negloglik = -dist.log_prob(y)\n", + " loss = torch.mean(negloglik)\n", + "\n", + " # log training results\n", + " self.val_log_error.append(loss.detach().numpy())\n", + " return loss\n", + "\n", + " def configure_optimizers(self):\n", + " optimizer = torch.optim.Adam(\n", + " self.parameters(),\n", + " lr=self.learning_rate,\n", + " )\n", + " return optimizer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets create the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "torch.manual_seed(1)\n", + "model = BetaModel(learning_rate=1e1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can generate distribution objects from the model by calling the forward pass method.\n", + "We see the model does not yet know anything about the true success probability." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/_v/nlh4h1yx2n1gd6f3szjlgxt40000gr/T/ipykernel_42343/4198434410.py:10: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(0, 1, 1000)\n", + "output_dist = model()\n", + "y = scipy.stats.beta(output_dist.concentration0.detach().numpy(), output_dist.concentration1.detach().numpy()).pdf(x)\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 4))\n", + "ax.plot(x, y, label=\"Prior distribution\")\n", + "ax.axvline(x=p_success, linestyle=\"--\", color=\"b\", alpha=0.5, label=\"True P(success)\")\n", + "ax.legend()\n", + "ax.set(xlabel=\"P(success)\", ylabel=\"PDF\", title=\"Prior distribution\")\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fitting the model distribution\n", + "To train the model with our random sample data created above, we need to setup a dataloader to pass to the trainer." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([10000, 1])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# training on the whole dataset each batch\n", + "from torch.utils.data import TensorDataset, DataLoader\n", + "\n", + "rand_samples_t = torch.Tensor(rand_samples)\n", + "dataset_train = TensorDataset(rand_samples_t)\n", + "dataloader_train = DataLoader(dataset_train, batch_size=len(rand_samples))\n", + "\n", + "# test loading a batch\n", + "rand_samples_batch = next(iter(dataloader_train))\n", + "rand_samples_batch[0].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can train the model via PyTorch Lightning's Trainer object." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/Users/stantoon/miniconda3/envs/pytorch_env/lib/python3.12/site-packages/pytorch_lightning/trainer/setup.py:187: GPU available but not used. You can set it by doing `Trainer(accelerator='gpu')`.\n", + "/Users/stantoon/miniconda3/envs/pytorch_env/lib/python3.12/site-packages/pytorch_lightning/trainer/connectors/logger_connector/logger_connector.py:67: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `pytorch_lightning` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n", + "/Users/stantoon/miniconda3/envs/pytorch_env/lib/python3.12/site-packages/pytorch_lightning/trainer/configuration_validator.py:74: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + " | other params | n/a | 2 \n", + "--------------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n", + "/Users/stantoon/miniconda3/envs/pytorch_env/lib/python3.12/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=7` in the `DataLoader` to improve performance.\n", + "/Users/stantoon/miniconda3/envs/pytorch_env/lib/python3.12/site-packages/pytorch_lightning/loops/fit_loop.py:293: The number of training batches (1) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 49: 100%|██████████| 1/1 [00:00<00:00, 57.75it/s, v_num=10]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=50` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 49: 100%|██████████| 1/1 [00:00<00:00, 51.30it/s, v_num=10]\n" + ] + } + ], + "source": [ + "# fit network\n", + "trainer = pl.Trainer(max_epochs=50, accelerator=\"cpu\")\n", + "trainer.fit(model, dataloader_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see the training loss has converged ok." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/_v/nlh4h1yx2n1gd6f3szjlgxt40000gr/T/ipykernel_42343/2207435402.py:10: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def moving_average(a, n=10):\n", + " ret = np.cumsum(a, dtype=float)\n", + " ret[n:] = ret[n:] - ret[:-n]\n", + " return ret[n - 1 :] / n\n", + "\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 4))\n", + "ax.plot(moving_average(np.array(model.train_log_error)))\n", + "ax.set(ylabel=\"Loss\",xlabel=\"Training iteration\", title='Training loss')\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The beta parameters are moving towards appropriate values." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/_v/nlh4h1yx2n1gd6f3szjlgxt40000gr/T/ipykernel_42343/4205145043.py:8: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgoAAAF+CAYAAADjmjIfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABpNElEQVR4nO3dd3hTZf/H8XfSvfdgr9KyCpRR9ioiMpWhgMgDqKAMcfxYCqg8MlVEEBkKiAIPKMMBslVAhFL2EihlltG9d5uc3x8pgQKFliZNx/d1Xb2anJyc881NaD455z73rVIURUEIIYQQ4hHUpi5ACCGEECWXBAUhhBBC5EuCghBCCCHyJUFBCCGEEPmSoCCEEEKIfElQEEIIIUS+JCgIIYQQIl8SFIQQQgiRLwkKwqRKwnhfJaGGsszU7Wvq/ZtKeX3dwvAkKIh8DRkyBD8/P/1PnTp1CAgIoG/fvqxevRqNRpNn/aCgICZPnlzg7f/xxx9MmjTpietNnjyZoKCgp95PfrKyspg9ezZbtmzJd1+iaJYsWcKKFStMtv9jx47xxhtv6O/fvHkTPz8/Nm/ebLKaCmrz5s34+flx8+bNQj0vIiKCN954g1u3bhmkDj8/P7766iujP0eUXOamLkCUbPXq1eOjjz4CQKPRkJiYyL59+5g1axbHjh1j/vz5qFQqABYtWoS9vX2Bt71q1aoCrTd69Gj+85//FLr2J4mKimLVqlXMnj3b6Psqr7788kvGjh1rsv1v2LCBsLAwk+3fFA4ePMjevXuZNm2aQbb3448/4u3tbfTniJJLgoJ4LHt7exo3bpxnWVBQEDVq1GD27NkEBQXRu3dvQBcqjKFq1apG2a6p9yVEafDg/39jPUeUXHLqQTyVIUOG4Onpyfr16/XLHjwlsG3bNnr37k3Dhg1p2bIl48ePJyoqSv/8kJAQQkJC8PPz4/Dhwxw+fBg/Pz/Wr19Pp06daN26NQcOHHjk6YDs7GxmzJhB8+bNad68OZMmTSIuLk7/+KOec/9h55s3b9K5c2cA3n//ff26Dz5Po9Gwdu1aevXqRcOGDenYsSOff/45mZmZefY1bNgwNm3aRNeuXWnQoAG9e/dm3759T2zDyZMns2zZMtq0aUOTJk0YNWoU4eHhedbbs2cPL7/8MgEBATRo0IDnnnuONWvW6B/Pr91A9426b9++NG7cmIYNG/L888+zbds2/XM3b96Mv78/x44do1+/fvj7+9O1a1f+/PNPrly5wtChQ2nUqBFdunTh999/z1PX7du3ee+99wgMDKRRo0YMHTqUf//9V/+4n58foDvSdPc2QGhoKG+88QZNmjShSZMmjBkzJs9rzu/1xMXFMX78eNq0aYO/vz/PP/88v/zyS77tO3nyZH7++Wdu3br10OmG6Ohoxo0bR0BAAIGBgUybNo20tDT940FBQcyaNYuhQ4fSpEkTPvzwQ0B3FOr999+nQ4cONGzYkP79+/PHH3/k2e+jDrt/9dVXedoA4Oeff6Z79+74+/vTu3dvDh06RL169R46LXLq1CkGDhyIv78/HTt2fOypnM2bN/P+++8D0LlzZ/3/x/xez4ULFxg7diwtW7akfv36tGvXjhkzZpCRkfHI13P33+bQoUO8+uqrNGrUiNatWzN37lxycnKK9JyUlBQ+/PBDWrVqRUBAAO+++y6rVq16qN1E8ZOgIJ6KmZkZrVq14vTp03n+s9917Ngxxo8fz7PPPsu3337L+++/T3BwMP/3f/8HwEcffUS9evWoV68eP/74I/Xr19c/d/78+UyaNIlJkybl+81k+/btnD17ljlz5jBx4kT27t3L6NGjC1y/p6cnixYtAmDUqFH62w/68MMPmTVrFkFBQSxZsoTBgwezZs0aRo8enaez2NmzZ1mxYgXjxo3j66+/xtzcnHHjxpGYmPjYOv744w82bdrElClT+O9//8uFCxf4z3/+o//Q2rt3L2PGjKF+/fosXryYr776ikqVKvHJJ59w/PjxPNt6sN3Wrl3Lhx9+SOfOnVm2bBmfffYZFhYWTJgwgdu3b+ufl5OTw3vvvcfAgQNZvHgxVlZWjB8/njfffJOOHTuyYMECPDw8mDRpEhEREQDExcUxcOBAzp07x7Rp05g3bx5arZbBgwdz+fJlQHf4GaB///7621evXmXgwIHExsYyZ84cZs6cSXh4OIMGDSI2Nvaxr2fChAmEhYUxffp0vvnmG+rVq8ekSZM4fPjwI9t29OjRdOjQAQ8PD3788Uc6duyof2zBggVUqFCBxYsX85///IeffvrpoQ/3tWvX6j/wnn/+eWJiYujfvz8hISG8++67+n+LMWPG8Ntvvz323/lBv/zyC5MnT6ZJkyYsXryYrl27Mnr06If6/QB8/PHH9OzZk2XLltGwYUM+/fRT/vrrr0dut2PHjowaNQrQBbT7/088+HqioqIYPHgw6enpzJkzh2+//ZZu3bqxevXqJ54WHD9+PE2bNmXp0qX06tWLlStXsnHjxiI9Z8yYMWzfvp233nqL+fPnk5qayrx58x67TVE85NSDeGru7u5kZ2eTkJCAu7t7nseOHTuGlZUVI0aMwMrKCgBnZ2fOnDmDoij4+Pjo+zM8GAYGDhzIc88999h9Ozo6snz5cv02XFxcGDNmDAcOHKBt27ZPrN3S0pK6desCutMNjzptEhYWxsaNG3nnnXf0f3zbtGmDp6cnEydOZP/+/XTo0AGA5ORkNm/erD91YWtryyuvvEJwcDBdu3bNt460tDQ2bdqkf17NmjXp06cPP//8M4MHDyYsLIwXXniBKVOm6J8TEBBAixYtOHLkCE2aNMm33cLDw3n11VcZM2aMflnlypXp27cvx48fp2LFigBotVrefPNNXnzxRQCSkpJ47733GDp0KMOHDwd0/9b9+vXj7NmzeHt78/3335OQkMC6deuoVKkSAO3bt6d79+4sWLCAhQsX6v9dvb299bcXLVqEtbU1q1at0v/btWrVimeeeYbly5fn6dz64OsJCQlh9OjRPPPMMwC0aNECZ2dnzMzMHtm2VatWxdXVFUtLS/3+7wawrl276r95t2rVin/++Yfg4OA8z/f09GTy5Mmo1brvU5999hlxcXFs376dKlWqANChQweGDRvGp59+Ss+ePfXrPsmCBQvo1KkTM2bMAKBdu3ZYWFg88oPxvffeY9CgQYDu/8qff/5JcHAwnTp1emhdV1dX/Xupbt26VK5cOd/Xc+DAAerWrcuCBQv0/xatW7fm0KFDHDlyhDfffDPf+l988UX9+6pVq1bs2bOHvXv3MnDgwKd6zqFDhwgODuarr77i2WefBXTvp169epW7PiYlkRxREEV2tzPj/Zo3b05GRga9evVi/vz5HDt2jLZt2zJ27NhHrn+/ghxq7NChQ56Ok0FBQVhYWHDw4MHCv4B8hISEANCrV688y3v06IGZmVmeb7L3/4EG9B250tPTH7uPgICAPM+rV68eVapU4ejRowC8/vrrzJ07l7S0NC5cuMD27dv55ptvAN3pl/s92G6TJ09mwoQJJCcnc+bMGbZs2cLatWsf+dyAgAD97buh7/4A5+zsDOhCBMChQ4eoW7cuXl5e5OTkkJOTg1qtpn379o/9NwgODqZFixZYW1vrn2dvb0+zZs0eet6Dr6dFixZ89dVXvP3222zevJm4uDgmTZpEs2bN8t1ffh58TpUqVfSv7a5atWrl+eAPCQkhICBAHxLu6t27N9HR0Vy5cqVA+75+/Tq3b99+KAz36NHjibXa2tri7u7+UK0F8eDradu2LWvWrMHKyoqrV6/y119/sXTpUuLi4sjKynrstu5/v4Du/X7/qZvCPic4OBgLCwt9CARQq9V069atQK9NGJccURBPLTIyEmtra/2HyP0CAgL45ptvWLVqFStWrGDp0qV4eHgwYsQIhg4d+tjturm5PXHfDx7BUKvVODs7P9Uf0PzcPW3g4eGRZ7m5uTkuLi4kJyfrl9nY2ORZ524Y0mq1j92Hp6fnQ8vc3Nz0ryMuLo6PPvqIPXv2oFKpqFatGk2bNgUevk7+wXa7ceMGH374IcHBwZibm1OzZk39h++Dz33U1SrW1tb51p2QkMD169fznDK6X3p6+kNtcvd527Zty9NP4i5XV9fHvp758+ezdOlStm/fzo4dO1Cr1bRu3ZqPP/74oQ/vJ3mwNrVa/VCbPPgeS0xMzPMN/cH1Cvreu9uX5sHX9+D7rDC1FsSDr0er1fLFF1+wdu1a0tLSqFChAg0bNtQfAXycB98bBanpcc+Jj4/H2dn5oSMyD9YsTEOCgngqGo2GkJAQmjRpku+h33bt2tGuXTvS09MJDg7mhx9+YNasWTRu3JhGjRoVaf8P/lHWaDTEx8fr//iqVKqHzvc+6RvPg5ycnABdx7f7PyCys7OJj4/HxcXlaUrPIyEh4aFlMTEx+qMM48eP5/Lly3z33Xc0adIES0tL0tPT2bBhw2O3q9VqGTlyJBYWFvz000/Uq1cPc3NzwsLCCn0+/VEcHBwIDAxk4sSJj3zc0tIy3+e1bt1af0rjfubmj/9z5ODgwIQJE5gwYQJXrlzhjz/+YPHixUyfPp3ly5cX/kUUkpOTEzExMQ8tj46OBsjzfnjce+/u0aYH+2Q8eN/Y7gb5jz/+mK5du+Lg4ADo+pQUNy8vL+Lj49FqtXnCQnG3iXg0OfUgnsr69euJiorSnzt90Ny5c+nfvz+KomBjY0OnTp3055/v3LkDUODzuY9y8ODBPJ0od+7cSU5ODi1atADAzs6O+Pj4PFcnPNj5L7+Ac1dgYCBAngGZAH7//Xc0Go3+m31RnDhxIs/VGufOnePmzZu0atUK0PX16Nq1Ky1bttR/+O7fvx94/NGK+Ph4rl69Sv/+/WnYsKH+Q7ggzy2IwMBArl69So0aNfD399f//Pbbb2zYsEHftg/+GwcGBhIWFkbdunX1z2nQoAGrVq1i9+7d+e7v1q1bdOjQgR07dgC6vhwjRoygdevW+g6Wj1KU99iDmjdvzokTJx66KuW3337Dw8ODatWqAbqjMw/WdP97z9vbm6pVqz70enfu3GmQOgv6mo8dO4aPjw/9+/fXh4TIyEhCQ0OL/P4orMDAQHJycvjzzz/zLN+zZ0+x1iEeTY4oiMdKSUnh5MmTgO7DJT4+ngMHDvDjjz/Su3dvfcejB7Vq1YrvvvuOyZMn07t3b7Kzs1m+fDnOzs60bNkS0HVIPHHihP6ysMKIiYnhrbfeYsiQIVy7do0vvviCNm3a6D9gO3XqxOrVq/nggw948cUXuXTpEitXrswTDu7+cTx06BC1atV66CiHj48Pffr0YdGiRWRkZNCiRQvOnz/PokWLaNGiBe3atStUzY+Snp7OiBEjGDVqFKmpqcyfPx9fX1969uwJQMOGDdmyZQv169fH29ubEydOsGzZMlQq1WP7P7i5uVGpUiXWrl2Lt7c3jo6OHDhwgO+//16/36IYNmwYv/76K8OGDePVV1/FxcWFbdu28dNPP+k7CcK9f+MjR47QrFkzRo8ezcCBA3njjTcYNGgQVlZW/Pjjj+zZs4eFCxfmu79KlSrh7e3NjBkzSElJoWrVqpw9e5Z9+/blGXnxQY6OjsTExLBv3z5959WnNXz4cH777TeGDx/O2LFjcXFx4ZdffiE4OJhZs2bpP6A7duzI77//TsOGDalRowY///wz169f129HpVIxbtw4xo8fz0cffUSXLl24cOECX3/9NVD0cOPo6AjA7t27ad++PbVq1Xrkeg0bNmTx4sV88803NG7cmOvXr7Ns2TKysrKK/P4orObNm9OmTRumTJlCTEwMFStWZOPGjVy4cOGJfZqE8UlQEI/177//MmDAAED3B8zNzY0aNWowZ86chzr53a99+/Z8/vnnrFy5Ut+BsWnTpvzwww/6Pg2DBw/m7NmzjBgxgtmzZz/yfH1+XnrpJTIyMhgzZgyWlpb06tWLCRMm6P+otGnThkmTJrF69Wp27dpF/fr1WbRoUZ5e2fb29gwfPpwff/yRvXv38s8//zy0n5kzZ1KtWjU2bdrEihUr8PT0ZMiQIYwZM8Yg31abNWtGy5Yt9Vc1BAUFMXHiRP3Rgzlz5vDJJ5/wySefAFC9enWmT5/Ob7/9pu/wmJ/Fixczc+ZMJk+ejKWlJT4+PixZsoRZs2Zx9OhRhgwZ8tR1e3l5sX79eubNm8fHH39MZmYm1atXZ+bMmXkOXb/55pssXryYESNGsG3bNurUqcPatWuZP38+EydORFEUfH19+frrr/XjWuRn0aJFfPHFFyxYsID4+HgqVKjA2LFjGTlyZL7P6du3L/v27WPMmDGMGzeO7t27P/Vr9vDwYN26dcybN4+ZM2eSnZ1NnTp1WLx4cZ7a33//fXJycvjss88wNzene/fu/N///R9Tp07Vr9OrVy/S0tJYsWIFmzZtonbt2kyZMoUpU6Zga2v71DWCrtNn69atmTdvHocOHdJ3fn3QG2+8QXx8PD/88ANff/01FSpU4Pnnn0elUrFs2TISExP1p9+Kw/z585kzZw7z5s0jJyeHzp07M2jQoMeOlSGKh0qRmUOEMIm7H9SrV682cSWiuG3dupV69epRs2ZN/bK9e/fyxhtv8Ouvv1KnTh0TVlf8bt26xcmTJ+ncuXOeTo/jxo0jPDycn3/+2YTVCTmiIIQQxey3335j/vz5vPPOO1SoUIFr166xcOFCAgMDy11IAN3RysmTJ9O5c2f69++PmZkZ+/fvZ9euXXnmYhGmIUcUhDAROaJQfsXHxzNv3jz2799PXFwc7u7udO3alXHjxmFnZ2fq8kwiODiYr7/+mvPnz5OTk0OtWrUYPny4vr+OMB0JCkIIIYTIl1weKYQQQoh8SVAQQgghRL4kKAghhBAiX6X6qoecnBwSExOxsrIy6AhsQgghRFmn1WrJzMzEycnpsUOol+qgkJiYyLVr10xdhhBCCFFqVa9e/bGT8ZXqoHB3lrPq1as/cqa6p6HRaAgNDcXX1/eJcwGIgpN2NR5pW+OQdjUOaVfjeJp2TU9P59q1a0+cMbRUB4W7pxtsbGyKPOzpXXdnfbO1tZU3sQFJuxqPtK1xSLsah7SrcRSlXZ906l5O7AshhBAiXxIUhBBCCJEvCQpCCCGEyJcEBSGEEELkS4KCEEIIIfIlQUEIIYQQ+ZKgIIQQQoh8SVAQQgghRL4kKAghhBAiX6V6ZEYhhBCirNJqFW4npnM5OpWb8Wm0qeVOdXe7Yq9DgoIQQghhQmlZOVyOSuVKTAqXo1K4HJPKlehUrsakkJGt1a/XwdeD718NLPb6JCiIAtNoNHz++ef8+uuvpKen07JlS6ZPn46np6epSxNCiBIvPUtDWFQKoZHJhEYlcylSd/tmfHq+z7EwU1HdzY6aHnYMb1OjGKu9p1wFBUVRSM/WPHYdjUZDRo6WtKwczMyUIu/TxsIMlUpV5O2UBEuWLOGff/5h06ZNODg4MG3aNKZOnco333xj6tKEEKLEUBSFWwnpnL2VxL+3E/n3TjKhkcmEx6eh5POx4m5vSU0Pe2p52FHT3Z5anrrflV1sMDczbXfCchMUFEWh/9JDHLseX7An/LzHIPttVs2FDW+2KnBYuHnzJp07d2bq1KksXbqUjIwMgoKC+Oijj7C0tGT+/Pns3buXiIgIrK2t6d69O1OnTkWlUjFkyBAqVarE4cOHURSFrVu3EhISwjfffMP169dJS0vD39+fGTNmUL16dTZv3szGjRtp1KgRmzZtQq1WM2bMGKysrFiyZAlJSUn06NGD//73vwBs2LCB8ePHU6FCBQCmTJlC27ZtCQ8Pp0qVKgZpLyGEKE00WoUr0Smcu53EuduJub+TSEzPfuT6rnaW1Pa0x8/bgdpeDvh62uPr5YCLnWUxV15w5SYoAJSm7/W7du1iy5YtaDQaxowZw/Tp0/H19eXvv//m+++/x9PTkxMnTvDKK6/wzDPP0KpVKwAOHjzIhg0bsLGxISUlhbfffpsFCxYQFBREfHw8Y8eO5euvv+azzz4D4NixYzz77LMEBwezfv16ZsyYQbdu3di2bRthYWEMGDCAXr16UadOHSIiIvD19dXX6O7ujpOTExcvXpSgIIQoF+JSszh+PZ7jN+I5cSOBUzcTSMt6+Ei1hZmK2p4O1K/oSL2Kjvh5O+Dr5YC7vZUJqi6achMUVCoVG95sVaBTD6dPn6Zhw4YGmSv9aU89vP/++7i6ugIwbtw4Ro0axaRJk+jTpw9ubm5ERUWRkZGBnZ0dkZGR+ue1b98eLy8vAKytrfn999+pWrUqKSkpRERE4OLikmd9W1tbhg4dikqlom3btmg0Gl577TVsbGzw9/fH09OTW7du6YOAra1tnjqtra1JTU0t9OsTQoiSTqNVuBCRxPEbCZzIDQfXYtMeWs/W0oy6FRypX9GRBhWdqFfRkdpe9liZF/0zpCQoN0EBdGHB1vLxL1mjUWFtrsbW0twgQeFpVatWTX+7QoUKZGVlkZ2dzSeffMKRI0fw9vamXr16KIqCVnuvV+z9HQstLCzYunUr69evR6VS4evrS0pKCubm99rA2dlZH2TUat15MEdHR/3jarUarVaLjY0NAOnpeTvd3A0rQghR2mm1Chcjkzl4OZZDl2M5fDWW5Iych9bz8bSnSVVnmlR1IaCqCz6e9pipS9Mx68IpV0GhNImMjKRmzZqArt+CjY0N06ZNw8nJiQMHDmBlZYVWq6V58+Z5nnf/0Yvt27ezZs0a1q1bpw8en3zyCaGhoY9c/3GcnJzw8vIiLCxMf/ohOjqahISEPKcjhBCitFAUhcvRKRy6HMuhK7pwEJ+Wt2+Bg5U5jas6E1DVhSZVnQmo4oKTrYWJKjYNCQol1Lx585g7dy6pqaksXLiQ559/nosXL+Lp6YlarSYlJYVFixaRkpJCdvajO80kJyejVquxtrZGURT+/vtvfvnlF2rXrv1UNfXt25clS5bg7++Pi4sLs2bNIjAwkKpVqxblpQohRLFJTMvm77Bo9l6MZn9oNFHJmXket7U0o3l1V1rXcqNVLTfqV3Qq00cLCkKCQglVtWpVevbsSXp6Or169WLChAlcunSJDz/8kMDAQOzs7OjYsSPt2rXLc4Tgfn369OHYsWP06NEDMzMzatasydChQ1m7di1ZWVmFrmnMmDHk5OQwePBgUlNTadGiBV9++WURX6kQQhiPoiicu53EvtBo9l6M4viNBDTae9coWpmraVbdhVY1dcGgYWVnLEx8OWJJo1KU/K7qLPnS0tI4f/48devWfaiT3dPSaDScPHmSxo0bm6SPwt3LI//44w8qV65c7Ps3FlO3a1kmbWsc0q7GURztmpqZw/7QaP68EMW+Rxw1qO1pT0c/Dzr6edKsukuZ6HT4NO1a0M9QOaIghBCi1ItKzuCP81Hs/jeSA2ExZOXc6+Rta2lG61ruueHAg8ouhvliWV5IUBBCCFEqXYlOYde/kew6F8GJ8IQ8ox5Wc7PlmbpedPLzpHmNsnHUwFQkKJQwlStX5uLFi6YuQwghSpy7/Q22n73DjrMRXI7OO4ZLw8pOPFvPi2fre1Pb077MDJ9vahIUhBBClFharcKJ8AR2nL3D9rMReSZQMleraFXLjWfrefFMPS8qONmYsNKyS4KCEEKIEkWjVQi5GseOs3fYeS6SiKQM/WPWFmo6+nrSzd+bjn6eONmUrzENTEGCghBCCJPL1mg5eDmWHWfvsOtcJLGp9y7htrcyJ6iOJ90aeNPBz+OJI+wKw5LWFkIIYRIZ2Rr+vhTD9rN32PNvJEn3DZfsZGNBl3pedGvgTRsfd6wtpDOiqUhQEEIIUWzSsnI4dDODlRdOsvdiNKn3zbzobm9Jl3redGvgTatabjLwUQkhQUEIIYRRxaRk8sf5SHad041xkHnfGAfejtY818Cb5xp407y6a7kfLrkkkqAgCk2j0fD222/j5+fHW2+9ZepyhBAl0NWYVHadi2D3v5EcuxGfZ4wDTzszegdUoXvDijSu7IxawkGJJkFBFMrt27eZNm0aBw4cwM/Pz9TlCCFKiByNlpPhCfx5QTc64qWolDyP+1dyoks9L56p40HanTACAurI0NilRPkKCooC2WmPX0ejQZ2TDlmpYIg3sYUtFGLQj7tzPUydOpWlS5eSkZFBUFAQH330EZaWlsyfP5+9e/cSERGBtbU13bt3Z+rUqahUKoYMGUKlSpU4fPgwiqKwdetWQkJC+Oabb7h+/TppaWn4+/szY8YMqlevzubNm9m4cSONGjVi06ZNqNVqxowZg5WVFUuWLCEpKYkePXrw3//+F4CrV68ycOBA/aRQQojyLSopg72h0ey7GM3fl6LzdEY0V6toWdONZ+t78UxdLyo668Y40Gg0nIyQIwilSfkJCooCK7tC+OHHrmYGBABsN9B+q7SEV3cUKiwA7Nq1iy1btqDRaBgzZgzTp0/H19eXv//+m++//x5PT09OnDjBK6+8wjPPPEOrVq0AOHjwIBs2bMDGxoaUlBTefvttFixYQFBQEPHx8YwdO5avv/6azz77DIBjx47x7LPPEhwczPr165kxYwbdunVj27ZthIWFMWDAAHr16kXz5s3x8PBgz549ODg4cOTIEQM1kBCitMjWaDl+PZ69obppms/fScrzuLOtBe1qe/BMXU8Z46AMMUlQOHfuHLNmzeLixYtYW1vz3HPPMXHiRCwtLTl16hQzZswgLCwMFxcXRo0axYsvvmigPZeeFPv+++/j6uoKwLhx4xg1ahSTJk2iT58+uLm5ERUVRUZGBnZ2dkRGRuqf1759e7y8vACwtrbm999/p2rVqqSkpBAREYGLi0ue9W1tbRk6dCgqlYq2bdui0Wh47bXXsLGxwd/fH09PT27dukXz5s2xt7cv3kYQQphUtkbL2VuJBF+JI/hKLEevxeW5SkGlgoaVnOjg50lHPw8aVXaWzohlULEHBa1WyxtvvMHIkSNZvXo1UVFRDBs2DBcXF1555RVGjhzJuHHjGDBgAEeOHGHMmDH4+fnRsGHDou1YpdJ9s3/CqQeNRsPp06dp2LChYc6fFfLUw13VqlXT365QoQJZWVlkZ2fzySefcOTIEby9valXrx6KoqDV3utB7OnpeW/XFhZs3bqV9evXo1Kp8PX1JSUlBXPze//szs7O+vHQ1WrdpUiOjo76x9VqdZ7tCyHKrmyNljO3Egm+EkvwlTiOPRAMAFztLGlf252Ofp60q+2Om72ViaoVxaXYg0JiYiLR0dFotVqU3G6warUaGxsbdu3ahbOzM4MHDwagVatW9OrVi7Vr1xY9KIDuA9vS7vHraDRozW1065mwo01kZCQ1a9YEdP0WbGxsmDZtGk5OThw4cAArKyu0Wi3NmzfP87z7J0HZvn07a9asYd26dfrg8cknnxAaGvrI9YUQ5UtEYgYnwxM4dTOBU+EJnAxPIO2BYOBkY0GLGq60rOlGy5pu1PF2kKsUypliDwouLi4MGzaMuXPn8umnn6LRaOjcuTPDhg1jzpw5+Pr65lnfx8eHjRs3PnabGo0GjUbz2HUK6u52DLW9wrr77f3zzz9n9uzZpKWlsXDhQnr37s3Fixfx8PBAURSSkpJYtGgRKSkpZGZmotFo9EcX7taemJiIWq3GwsKCnJwcDhw4wC+//IKPjw8ajUYf1u6uf3ff92/jwW3eld/y/Ji6XcsyaVvjKGvtmpyRw5lbiZy+mcipm4mcvplARFLmQ+s521gQWMOVFjVcaFnTDV9P+zzBQFG0FKVJylq7lhRP064FXdckpx6sra2ZNm0a/fv35/r164wdO5aFCxeSmpqKjU3e2b+sra1JS3v86YL7vyEbypkzZwy+zYKIjo4GdK+7W7duZGZm0qZNG7p164a/vz/Lly8nMDAQGxsbAgICaNSoEQcPHtSfVoiIiODkyZMA1KhRAz8/P3r06IFaraZixYo8++yz7Nq1i6NHj3Ljxg2ysrL069/d97///qu/nZWVxY0bN/Tr3PXgvgrKVO1aHkjbGkdpa1eNohCRouF6Qg7XE7O5npjDjcQcIlMf/lBQA1WczKntaqH7cbOgiqM5apUKSCAjIoHTEcaps7S1a2lhjHZVKcr9w2AY386dO5k/fz47duzQL/vtt9+YOXMmvXr1IioqioULF+ofW716NZs2beKXX355aFtpaWmcP38eX19fbG1tDVKfRqPhzJkz+Pv7m+Qa31u3btGlSxd2795NpUqVin3/xmLqdi3LpG2No6S3q0arcDM+nSvRKVyOSeVSZAoXIpK5FJWSZ+TD+1VytqZRZWcaVnaicRUn6ld0LPYJlkp6u5ZWT9OuaWlphIaGUrdu3cd+hhb7EYU7d+6QlZWVZ5m5uTkWFhb4+vryzz//5HksLCyM2rVrP3abZmZmBn/DGWObBXG3Q6FarS6T/4lM1a7lgbStcZi6XZMysrkancrl6BSu5P6+HJ3CtZg0sjSPDgQ2Fmb4etlTx9sRP28H6lRwoI63I652lsVcff5M3a5lVWHataDrFXtQaNu2LfPmzWPp0qWMGDGC27dvs2TJEnr16kWXLl347LPPWLVqFYMHD+bYsWNs2bKFxYsXF3eZQghRbDJzNNyITeNKTCpXY1K5Gq37fSUmlZiUh/sR3GVlrqaGux21PO3x8bCnbgUH/LwdqepqK5cpCoMp9qDg4+PDsmXL+PLLL1m+fDkODg707t2bMWPGYGlpycqVK5k5cyYLFy7E1dWVqVOn0rJly+Iu02QqV67MxYsXTV2GEMIIkjKyCYtK0f9cikwmLDqFm/HpPO4ksIeDFbU87KjlYU9ND3v97UrONnIFgjA6kwy41Lp1a1q3bv3Ix/z9/Vm/fn0xVySEEIaTlaMlNDKZs7cSuRCRrAsFUclEPuIqg7scrMyp4WFHDfd7PzXd7anubouDtYxwKEyn/AzhLIQQRpCZo+FiRDJnbiVy9lYSZ28lcjEiOd/+A16OVtT2dMDH017/U8vDHnd7SxnXRJRIEhSEEKIQ4lOzOHxVN6TxkWtxXIxIJkf78HkDR2tz/Cs7UdfbEV8vB3y8dIFA5j8QpY0EBSGEeIzE9GyOXo/mUO6wxhcikh7qT+Bia0GDSk40qOSEfyUnGlR0ooqrjRwhEGWCBAUhhLiPVqtwIjye7Wfu8MfZGK5t/OOhYFDb014/pHHjqs5UdLKWUCDKLAkKQohyL1uj5fCVOHacu8POc5FEJ+ftdFjLw46WNd1oVcuNFjXc8HCQiZBE+SFBQQhRLmVka/j7Ugw7zkaw53wkienZ+sccrMwJquNBDes0BnQMoILLEyaTE6IMk6AghCg3FEXhyLV41oXcYOe5iDwzJbrZWfJsfS+61vemdS13zFQKJ0+exNPR2oQVC2F6EhSEEGVeXGoWm47dZP2RG1yOTtUvr+BkTdf63nRr4E2z6q55RjOU2Q2F0JGgIIQok7RahUNXYvVHD7I1uh6JtpZm9GpYkZeaV6FJVWfphCjEE0hQEEKUKfGpWaw7coMfj4RzPfbeFPX+lZwYFFiVXo0qyEiHQhSCBAUhRJlwOyGd5X9fZf2RG/q+Bw5W5jwfUJGBzavSoJKTiSsUonSSoCCEKNUuRSazdN8Vfj15Sz9CYr0KjgxrU52eDStgayl/5oQoCvkfJIQolY5dj2PJ3ivsOR+pX9aqphtvdqxF+9ru0vdACAORoCCEKDUURWFvaDRL/rpMyLU4AFQq6FrPmzc71qJxFWfTFihEGSRBQQhRKoRcjeOznRc4ci0eAAszFX0DKjOyQ01qedibuDohyi4JCkKIEu3srUQ+33WRvRejAbAyV/NKy2qMaFcTbycZDEkIY5OgIIQoka5EpzBvdyi/n74DgJlaxYDmVRgXVFsCghDFSIKCEKJEuZ2QzsI/LrHh2E00WgWVCno3qsi7z/hS3V3mXBCiuElQEEKUCEkZ2Xz9ZxjfHbxGVo4WgM51PBnf1Y+6FRxNXJ0Q5ZcEBSGESeVotKwLucH8PZeIS80CoEUNVyY+50fTaq4mrk4IIUFBCGEyf12MYubv5wmLSgGglocdU3rUpZOfp4yDIEQJIUFBCFHsLkYkM3PbefaH6q5kcLG14N0uvgwKrIqFmdrE1Qkh7idBQQhRbGJSMpm/O5R1ITfQKrqxEIa1rs7YoNo42chETUKURBIUhBBGl5mjYdU/11j0ZxjJmTkAPFffm/e716Gam1zJIERJJkFBCGE0iqKw53wUM3//l2u5Uz43qOTItB71aFHTzcTVCSEKQoKCEMIoLkYk88nWfzkQFgOAh4MVE7r60b9JZdRq6agoRGkhQUEIYVDxqVnM3xPK2sM30GgVLM3UvNauBmM6+WBvJX9yhCht5H+tEMIgsjVa1gZfZ/6eSySmZwPQtb4XU7rXo6qbrYmrE0I8LQkKQogiURSFvy5GMWvbBf14CHW8HfiwVz1a13I3cXVCiKKSoCCEeGrnbicya9t5/gmLBcDVzpL/e9aXgc2rYib9EIQoEyQoCCEKLSIxg893XWTT8ZsoCliaqRnetjpjOvngaC3jIQhRlkhQEEIUWGpmDsv2X+Hb/VdIz9YA0KtRRSZ29aOKq/RDEKIskqAghHgijVZh47Fw5u0KJSo5E4Cm1VyY2qMuAVVdTFydEMKYJCgIIfKl1SpsPxvB/D2h+o6KVV1tmdytDt0aeMvETUKUAxIUhBAPURSFP85HMW93KOfvJAHgZGPBW0E+DGlVDStzMxNXKIQoLhIUhBB6iqLw96UY5u0O5VR4AgD2Vua83q4Gr7atIR0VhSiHJCgIIQA4fCWWebtCCbkWB4CNhRnD2lRnZLuauNhZmrg6IYSpSFAQohxTFIV/wmJZuu+yfk4GS3M1r7SoxqiOtfBwsDJxhUIIU5OgIEQ5lK3RsvX0bb7Zf1XfB8FcrWJgYBXGdPKhgpONiSsUQpQUEhSEKEeSM7JZHxLOyn+ucicxA9CdYhjQvAqvta0hYyEIIR4iQUGIcuB2QjqrDl5j3eEbJGfmAOBub8XwNtUZ3KIqzrbSB0EI8WgSFIQoozRahX/CYvjxaDg7z0aQo1UA8PG0Z2S7mvRuXBFrC7nMUQjxeBIUhChjwuPS2HDsJpuO3eRWQrp+ecuarrzRvhYdfD1Qy4RNQogCkqAgRBmQqVH47dRtNh6/pZ/JEXSDJL3QuCIvNqtCg0pOJqxQCFFaSVAQopTSaBWOXotjy6nb/Hw8itTsSP1jbX3ceal5FZ6t5yWnF4QQRSJBQYhSJFuj5dDlWLafjWD3vxHEpGTpH6vobM2LTavQv2lluXpBCGEwEhSEKOEysjX8fSmG7WfvsOffSJIycvSPOdlYEFTHA3+HdIZ0CcTCQv5LCyEMS/6qCFECRSZlsC80mn0Xo9l7MYrULI3+MXd7S56t781z9b1pVcsNNQonT56UDopCCKOQoCBECZCt0XLsejz7QqPZezFaP1riXRWdrOnaQBcOmlV3xey+UKDRaB7cnBBCGIwEBSFM5HZCem4wiOKfsFhSMu+dUlCpoGFlZzr4ehBUx5NGlZ1QqeSIgRCi+ElQEKKYZGRrOHotnn2hUewLjSY0MiXP4252lrT39aCDrwftarvjZi8TMgkhTE+CghBGdC0mVdfXIDSaQ5djSc++d5pArYLGVZzp6OdJB18P/Cs5ST8DIUSJI0FBCANSFIVTNxPZfvYOO89GcC02Lc/jXo5WdPD1oIOvJ2193HGytTBRpUIIUTASFIQoIq1W4UR4PNvORLDjbESeYZMtzFQ0r+6qCwd+Hvh5OUhfAyFEqWKSoJCQkMCsWbPYt28fWq2W5s2b8/HHH+Pp6cmpU6eYMWMGYWFhuLi4MGrUKF588UVTlClEvu6Oirj9bATbz94hMilT/5itpRlBdTzp7l+B9r4e2FtJHhdClF4m+Qv21ltv4eTkxO7du1Gr1bz//vtMmzaNTz/9lJEjRzJu3DgGDBjAkSNHGDNmDH5+fjRs2NAUpQqRR1xqFuuP3GBt8I08Rw7srcx5pq4n3fwr0MHXQ4ZNFkKUGcUeFM6ePcupU6c4ePAg9vb2AHzyySdER0eza9cunJ2dGTx4MACtWrWiV69erF279rFBQaPRGOxa8rvbkWvTDau0t+u/t5P4Ifg6v526Q2aOFgBH69xw0MCbNj7uWJmr9esX5+ss7W1bUkm7Goe0q3E8TbsWdN1CB4WsrCz27dvHrVu3GDBgANevX6dOnToFfv7p06fx8fHhp59+Yt26daSnp9OuXTsmTZrEpUuX8PX1zbO+j48PGzdufOw2Q0NDC/synujMmTMG36YoXe2ao1U4fCuD7WFpnI/J1i+v6WxOt9q2tK1ig6WZFjJuc/7sbRNWqlOa2rY0kXY1DmlX4zBGuxYqKNy4cYNXX32V7OxskpKS6NChA/369WPRokV06tSpQNtITEzk4sWLNGjQgJ9//pmMjAwmTpzIpEmTcHd3x8bGJs/61tbWpKWl5bM1HV9fX2xtDTMJjkaj4cyZM/j7+2NmJoePDaU0tWtSejarg2/wv5AbROT2PTBXq3iugRf/aVmNJlWdS1SHxNLUtqWJtKtxSLsax9O0a1paWoG+aBcqKMycOZO+ffsyatQoAgMDqVGjBjNmzGDhwoUFDgqWlpYATJkyBSsrK+zt7XnnnXd46aWX6Nu3LxkZGXnWz8jIwM7O7rHbNDMzM/gbzhjbFCW7XTVahXUhN/hidyhxqbpZGd3tLXk5sCqDW1bDy9HaxBU+Xklu29JM2tU4pF2NozDtWtD1ChUUTp48yVdffYVKpdJ/o3r++eeZOXNmgbfh4+ODVqslOzsbKyvdyHNare6cb926dfnf//6XZ/2wsDBq165dmDKFKLSDYTH8d+u/XIhIBsDH054xnWrR3b8CVubyx0wIUX6pn7zKPQ4ODsTExORZFh0djZOTU4G30bp1a6pUqcIHH3xAamoqcXFxzJ8/n2eeeYaePXsSExPDqlWryM7OJjg4mC1bttCvX7/ClClEgd2ITeON1Ud5eflhLkQk42Rjwce96rH97Xb0CagsIUEIUe4VKij06tWLsWPH8s8//6DVajl9+jTjx4+nR48eBd6GhYUFq1evxszMjK5du9K1a1e8vb2ZNWsWLi4urFy5kh07dtCiRQumTp3K1KlTadmyZaFfmBCPk5KZw9wdF3jmi33sPBeJmVrF0FbV2Du+I8Pa1MDCrFD/NYQQoswq1KmH0aNHk5GRwdixY0lPT2fIkCH079+fsWPHFmqnXl5ezJ8//5GP+fv7s379+kJtT4iCUhSFTcdvMXfHBaKTdR0V29V2Z1rPevh6OZi4OiGEKHkKFRQsLCyYNGkSkyZNIi4uDhcXlxLV+1uIx0nJzGHyptNsPX0HgOputkzpUY9n6nrK+1gIIfJRqKDwyy+/5PvYCy+8UMRShDCeixHJjFp7jCvRqZirVbzbxZfX29WQPghCCPEEhQoKCxcuzHM/MTGR9PR0mjZtKkFBlFibjt1kyi9nyMjWUsHJmkUvN6FpNRdTlyWEEKVCoYLCn3/+mee+oih8++23JCQkGLImIQwiI1vD9C3nWBcSDuj6IiwYGICrnaWJKxNCiNKjSF27VSoVr732Gr/++quh6hHCIK7HptJ38UHWhYSjUsG7z/iyanighAQhhCikIk8KdfXqVekIJkqUHWcjmLDhFMmZObjZWfLlwMa0q+1h6rKEEKJUKlRQGDJkSJ5QkJ2dzcWLF+ndu7fBCxOisBRF4fNdF/n6r8sANKvmwqKXm+DtVLKHXhZCiJKsUEGhRYsWee6r1WqGDRvGM888Y9CihCgsrVbh4y3n+OHQdQBGtKvBxOfqyMBJQghRRIUKCoUdWEmI4qDVKnzw8xnWH9H1R5j5gj8vt6hq6rKEEKJMKFBQeP/995+4zuzZs4tcjBCFlaPRMnHjaTafuIVaBZ/1b0S/ppVNXZYQQpQZRe7MKISpZGu0vPvjSbaevoOZWsWXAxrTq1FFU5clhBBlSoGCghwtECVNZo6Gt/53gl3/RmJhpuKrQU14roG3qcsSQogyp1BHFLKystiyZQuRkZFotVpAd+VDaGgoS5YsMUqBQjwoI1vDqDXH+OtiNJbmapa+0oSgOl6mLksIIcqkQgWFDz74gL///hsXFxeys7OxtbXl0qVLMnyzKDZpWTmM/OEYB8JisLZQ8+1/mskYCUIIYUSFCgp///0369atIy4ujnXr1jFv3jxWrlzJ6dOnjVWfEHqpmTkMX3WEkKtx2FqasXJYc1rWdDN1WUIIUaYV6iJzrVZLzZo1qVmzJufPnwdg8ODBHD161CjFCXFXjkbL2P8dJ+RqHA5W5qx+LVBCghBCFINCBQVvb2/Cw8NxdXUlNjaWtLQ0FEUhNTXVWPUJgaIoTN/yL39djMbaQs33rwXStJqrqcsSQohyoVCnHnr16sXLL7/Mxo0b6dixI6NGjcLKyooGDRoYqz4hWPnPNVYHX0elgi8HBNCkqkwRLYQQxaVQQWHkyJFUqVIFBwcHpk2bxmeffUZKSgrTpk0zVn2inNt1LoIZv/8LwAfd6solkEIIUcwKFRR27txJly5dMDfXPW369OlGKUoIgDM3E3l7/UkUBV5uUZXX29UwdUlCCFHuFKqPwsyZM2nXrh1z5szh8uXLxqpJCG4lpPPq90dIz9bQ3teD//auL9OZCyGECRQqKOzdu5c5c+YQGRlJ3759GThwIBs3biQtLc1Y9YlyKDkjm9dWHSE6OZM63g58/XIA5jILpBBCmESh/vqq1Wo6dOjA/PnzOXDgAH369GHx4sW0bdvWWPWJckZ3GeQJLkQk4+FgxYphzXGwtjB1WUIIUW491aRQ4eHh/Prrr2zZsoXs7GyGDBli6LpEOaQoCh/9do59obrLIFcMbUYlZxtTlyWEEOVaoYLChg0b+Pnnnzl9+jRt27ZlwoQJdOrUCTMzM2PVJ8qRFQeusvbwDVQqWDAwgIaVnU1dkhBClHuFCgpLly6lX79+zJ8/Hy8vmYRHGM6BSzHM3KYb7XNK97p0rS+XQQohRElQqKCwZ88e6XkuDC4yKYO3159AUeClZpV5ra1cBimEECVFoTozSkgQhpaj0fLW/04Qm5pFHW8H/vt8A3mfCSFECSLXnAmTmrc7lJBrcdhbmbN4cBOsLaS/ixBClCQSFITJ/HkhkiV7dQN3zennT00PexNXJIQQ4kGFCgozZsx45PKJEycapBhRftyMT+PdH08BMLRVNXo2rGjiioQQQjzKEzszRkZGcujQIUB3eeSDM0UmJyeze/du41QnyqSsHN2gSonp2TSs7MQHPeqauiQhhBD5eGJQcHFxYc2aNcTFxZGVlcXChQvzPG5lZcXYsWONVqAoe+Zsv8DJ8AQcrc35+uUmWJlLvwQhhCipnhgULC0t2bhxIwCvvfYaK1asMHpRouzaeS6Clf9cBWDeS42p4mpr4oqEEEI8TqHGUZCQIIoiIiWHSX+eBeCN9jXpUk8G7RJCiJKuUEEhJCSEjz/+mGvXrqEoSp7Hzp8/b9DCRNmSma3h80MJpGTm0KyaC+O7+pm6JCGEEAVQqKAwe/ZsGjVqxNSpUzE3f6r5pEQ5NXPbBa4m5OBqa8FXLwdgIdNGCyFEqVCoT/tr166xfv16rKysjFWPKIN2/xvJ2pBwAOa91JAKTjIjpBBClBaF+lpXvXp1oqKijFWLKIOikjKYtOk0AL19bWlf28PEFQkhhCiMQh1R6NatG6+//jr9+/fHwyPvH/wXXnjBkHWJMkCrVfi/DaeIS82iXgUHXm4gVzgIIURpU6igsH79egDWrVuXZ7lKpZKgIB6y8p+r/H0pBmsLNfNfakTK7TBTlySEEKKQChUU/vzzT2PVIcqYc7cT+XTHRQCm9qiHj6c9J2+buCghhBCFVuiu53FxcaxatYpZs2aRkpLCX3/9ZYy6RCmWnqXh7fUnydJoeaauF4NbVDV1SUIIIZ5SoYLCuXPneO6559ixYwcbNmwgPj6et99+m02bNhmrPlEKzdp2nrCoFDwcrJjbzx+VSmXqkoQQQjylQgWF2bNnM3nyZNavX4+5uTlVqlTh66+/lhEbhd4f5yNZHXwdgHkvNsLNXi6lFUKI0qxQQSE0NJTnn38eQP8tsV27dkRGRhq+MlHqRCVnMGGj7lLI19rWoL2vXAophBClXaGCgqurK1euXMmz7MqVK7i7uxu0KFH6aLUK4zecJi41izreDkx8ToZoFkKIsqBQQeHll1/mjTfe4KeffiInJ4dt27bx9ttvM2DAAGPVJ0qJVQevsT80GitzNV8NCpCpo4UQoowo1OWR//nPfzAzM+P7779Hq9WyYMECBgwYwLBhw4xUnigNzt9JYs6OCwBM7VGX2l4OJq5ICCGEoRR6ZqfBgwczePBgY9QiSqGMbA3j1p0gK0dL5zqevNKymqlLEkIIYUAFCgrffPMNI0eOZNGiRfmuM3bsWIMVJUqPWdvOcykqBXd7K+b2byiXQgohRBlToKBw5MgRRo4cyeHDhx/5uHw4lE9/nI/kh0O5l0K+1Ah3uRRSCCHKnAIFhW+//RaA1atXoygKWq0WMzMzoqOjcXV1xcxMOq6VN1FJeS+F7CCXQgohRJlUqKseLly4QFBQEOfOnQNg+fLlPPvss1y9evWpdq7RaBgyZAiTJ0/WLzt16hQvvvgiAQEBBAUFsWHDhqfatjCe+2eFrFvBUS6FFEKIMqxQQWHmzJn06dOHevXqATBhwgT69OnDJ5988lQ7X7RoEUePHtXfT0xMZOTIkbzwwgscOXKEmTNnMnv2bE6fPv1U2xfGcXdWSCtzNQsHNpZLIYUQogwrVFA4f/48b731FubmujMW5ubmjBo1ijNnzhR6x4cOHWLXrl08++yz+mW7du3C2dmZwYMHY25uTqtWrejVqxdr164t9PaFceSZFbJnPbkUUgghyrhCXR5pb2/P1atXqVmzpn5ZeHg4jo6OhdppbGwsU6ZMYfHixaxatUq//NKlS/j6+uZZ18fHh40bNz52exqNBo1GU6gaHret+3+Le9KzNLy97oRuVsg6ngxqVqnA7STtajzStsYh7Woc0q7G8TTtWtB1CxUU+vTpw6hRo3j99depWLEit2/fZsWKFfTt27fA29BqtUyYMIHhw4dTp06dPI+lpqZiY2OTZ5m1tTVpaWmP3WZoaGjBX0QBPc1RkrLum+OJhEWn42KtZrCvrj9JYUm7Go+0rXFIuxqHtKtxGKNdCxUUxo4di1qtZunSpURHR1OhQgX69u3L66+/XuBtLFu2DEtLS4YMGfLQYzY2NiQnJ+dZlpGRgZ2d3WO36evri62tbYFreByNRsOZM2fw9/eXqznus+d8FDsvRwDw5aAmtPUp3Pwe0q7GI21rHNKuxiHtahxP065paWkF+qJdqKBgZmbGW2+9xVtvvVWYp+Xx66+/EhUVRbNmzQBdEADYs2cPEydO5J9//smzflhYGLVr135iXYZ+wxljm6VVZFIGkzfrUuqIdjXo4Of11NuSdjUeaVvjkHY1DmlX4yhMuxZ0vWIfmXHHjh157t+9NHLOnDnEx8fz2WefsWrVKgYPHsyxY8fYsmULixcvLtC2heFptAr/99Mp4tOyqVfBkfFd5VJIIYQoTwoUFI4ePVosIzO6uLiwcuVKZs6cycKFC3F1dWXq1Km0bNnSINsXhbfwj0scCIvB2kLNQpkVUgghyp0CBQVnZ2cARo8eTatWrQxawJw5c/Lc9/f3Z/369Qbdh3g6ey9GsfDPSwDM6uOPj6e9iSsSQohyIDMFYi5C1AWIPq/7HX8VmgyFNuOKvZwCBYXdu3eTnZ3NmDFjOH78uLFrEiXArYR03vnxJIoCL7eoSt8mlU1dkhBClC3p8RATBjGheYNBwo1Hrx95tnjry1WgoFCrVi06duxIeno6nTt3fuQ6f/zxh0ELE6aTmaNh9NrjJKRl41/JiQ971jN1SUIIUTrlZEFiOMRcgthLuaEgTHc7NTr/59l5gEcd8Kx773flwOKr+z4FCgpLlizh0KFDTJs2TaaTLgdm/n6eU+EJONlYsHhwE6wtpF+CEEI8kiYHkm9D/HXdkYCE3N/x13W3k24DSv7Pd6gI7j7g7ntfMKgLdm7F9hKepEBBYdCgQezZs4cZM2bQp08fY9ckTOjXk7f0U0fPH9CIKq6GGZ9CCCFKhZwsyEyGzETd7/QESImClEhIjbp3W78shscGAQBzG3Dz0QUCt9q6UODuo1tmVfKHwS9QUIiNjeX8+fNkZ2dz584dFOXhRqlYsaLBixPF61JkMu/njpcwtpMPQXWefrwEIUQZoyi6c+ppsZCRpPsgzUiCjETITMpdlqT7cNVkgTYHNNmg1YA2W39brcnCLzUF9Ql7UKnv+1Hl/ty9bwZqc1Cb6X4edV+lAlT5/1a099WSpatBk51bT+79rJTc2pNza88sfNuoLcC5CjhXBedq4FJN9/vubTuP3JpKpwIFhaCgIPr06YNKpSIoKCjPY4qioFKpOH/+vFEKFMUjNTOHUWuPk5aloY2PG+928X3yk4QQZUdWKsRdhaRbup/EWw/cvg056UXejQqwB4gv8qaMy8JO923f2gnsPcHeK/f3fbftcm/buevCSxlVoKAwb948Jk6cyHPPPcfWrVuNXZMoZoqiMHnzGcKiUvB2tGbBwADM1KU3/QohHiM7Q9ehLvoCRP17r6d9/HWeeAgdwMpR92PtBNaPuG3lAOZWud/+zcHMIve2BZiZo0HN1WvXqVG9OmYqdPtUtLk/Su6PRndfm5P7o8n9yb2v5N5XlNznP+o3um/xZpa6Gswsc2uwuO++ua5e/U9u/Zb2YFaogYvLtAK3hJeXF//73/+oVKmSMesRJvDDoetsOXUbc7WKrwcH4G5vZeqShBCGkJ0Ot09AeAjcOqYLBnFXdB/Cj2LtrDuE7lhJ9+NUCRwrg2NF3W2HimBhXbSaNBoSM05CncYgQziXCoWKTHXr1uWnn35i9erVREVF8fPPPzNnzhxmz579xImbRMl0/EY8M37/F4D3u9elaTVXE1ckhHgqiqLrZX/zqC4Y3AyBiDO6b+APsna+77K7euBZR9fT3t6j2MsWJV+hgsKqVatYt24dr732Gp9++il2dnZERkYye/ZsZsyYYawahZFci0nl9e+Pkq1R6O7vzattqpu6JCFEQSmK7ujAlb1wdR/cCNb1wn+QvTdUaQ6Vm4O3vy4Y2HuV6s51ongVKiisW7eOxYsXU6tWLT7//HOcnJz46quv5JLJUigmJZOh34UQl5pFg0qOfNq/kcHm7BBCGElyJFzdfy8cJIbnfVxtDt4NoUqgLhhUCQSnKhIKRJEUKijEx8dTo0YNAP0lkm5ubuTkPOLQliix0rJyeG3VEa7HplHF1YaVw5pjbyUdd4QocbLT4doBCPtDFwyi/s37uNoCqrSAmh2heluo2BgsbExRqSjDCvXpUKdOHX788UcGDRqk//a5bds2ateubZTihOHlaLSMWXucUzcTcbG14PvhgXg6FLFzkhDCcGIvw6XdELZbFxJyMu57UKU7fVCzI9TsAFVbgaX0DxPGVaigMGnSJIYNG8avv/5KWloaI0aM4OTJkyxfvtxY9QkDUhSFKT+f5a+L0VhbqFkxrDk1PWRGSCFMKist96jBbl1AiL+a93HHSuDTGWoFQfX2JWpoX1E+FCoo1K9fn61bt7Jlyxbq1q2Lt7c306dPl1EZS4kv91zix6PhqFXw1aAmNKnqYuqShCh/FAViw3KPGuyB6//kPWqgtoCqLaF2F/Dpors6QfoYCBMq9IlpDw8PAgMDuXnzJp6ennh7exujLmFg60NusOCPSwB88kIDutST4ZmFKDaZKbpOiGG54eDBaYQdK0PtZ3TBoGaHUjH+vyg/ChUUoqOjefPNN7lw4QLOzs7Ex8dTvXp1Vq5cKYGhBPvzQiRTftHNY/5WkA+DW1QzcUVClHGaHLhzCq7th8t/wvVDuvkF7jKzhGqtwSc3HHj4yVEDUWIVKijMnTuX6tWr88MPP2BnZ0dycjIff/wxs2fPZsGCBcaqURTByfAExqw9gUar0L9pZd6TORyEMDytFiLP6I4aXP0bbhzSTZB0P+dq904nVG8LVtI/SJQOhQoKwcHB7NixQz8Ko4ODAx9//DGdO3c2SnGiaM7fSeLVVUdIz9bQ3teD2X39ZawEIQwhOwMiz8HNI3Dtb11nxIyEvOtYOUH1NlCjvS4cuNWSowaiVCpUUNBqtQ990KhUKiwsLAxalCi6Y9fjGP7dEZIycvCv5MSSwU2wMFObuiwhSp+cTIi4oJsz4c5J3e+o8w8PjWzpANVaQfV2UKOdbuCjMjyjoCg/ChUUWrRowccff8z06dOxtbUlNTWVjz/+mMDAQGPVJ57C3otRvLnmGBnZWppVc2HFsObYyYBKIj8ZSbpvx8m3IS0u9yf23k967rKMRN36KrXuA1ClBpVZ7m0z3bdlc2uwcc6dTTD394P3bd10P3buYONSMj5MFQXS43WXJsZdhfhrqOKuUOfqEdS/X83bv+AuW3eoGKDra1CjPVRoLDMOijKpUO/qCRMmMHz4cAIDA3F2diYhIQEfHx+WLVtmrPpEIf126jbv/XiSHK1CRz8Plgxuio1lCfhDLEqG5Ai4cxoicn/unH74uv1ipdKFBTv3ewHC1u3etMXWznmnMbZ20t23sLkvsJg9fFulgqwUyEzWBaHMpNzfibm/kyE1GuKv6V5//PWH+hSoAf1QRjYuulBQMUAXCCoGgFNlOZUgyoVCBYWKFSvy+++/c/ToUWJjY6lUqRL+/v6YyVShJcKa4OtM+/UsigK9G1Xk8xcbYWkupxvKtZhLcH6L7lr9O6chNerR6zlWApcaYOuS9wP77o+Nq+7IAOimKNZqQNHc91urW56TDukJuqMPGbm/77+fnqA7QpEak3tOX9HdT48zflsUhEMFcKkOLtXROlXlaqoV1Vv1wcythoQCUW4VOCgoikJ4eDhVq1alZcuWgG74Zn9/f6MVJwpGURQW773MZzsvAjCkZTWm966PWi1/2ModRdGdRz+/Bc5vhZiLeR9XqcGttm4Y4AoNdefRvRuaZrQ/TbbucH9qTO5pjpjc23G5RwAS7/3OeOC+Jqtg+1CZ6Y5EWDnm/na6d9/GRR8KdD/V8syToGg0JJw8qVsuIUGUYwUKCmlpabz66qu4u7uzaNEiAGJjY5k8eTJr1qxh+fLl2NraGrVQ8WiKojDz9/MsP6A7fPxWkA/vdfGVqxvKE20O9jEnUe1cDxe3551RUG2uO3/u+xxUbAJe9UrO3ABmFmDvqfspLEV54KiG9oHbWt3rtLCVD3khiqhAQWHJkiVYWFgwffp0/TI3Nzf++usvRo0axbJly3j33XeNVqR4tByNlvc3n2HDsZsATOtZj9fa1jBxVaLYJN6CI9+iPr4av7SYe8stbHUD+dTtBbWfvXfKoCxRqXI7DkrnQSGMrUD/y3bu3Mm3336Lm1vew5Nubm5Mnz6dd955R4JCMUvJzOGd9SfYcz4KM7WKuf0a0r9pZVOXJYrDzWMQvBj+/QW0OaiAHAtH1PV6oK7bG2p1kqmGhRAGU6CgEBsbS7Vqjx72t27dukRHRxu0KPF44XFpjPjhKBcikrE0V/PVoAC61pchtMs0TQ5c2ALBSyD88L3l1dqiCXyDU2neNG7SFKRjsRDCwAoUFOzt7YmPj8fF5eHZBhMSErCxkW8vxeXwlVhGrT1OXGoWHg5WfDOkKQEyC2TZlZ4Ax3+AkG/u9T1QW4B/f2g5Cio0Ao0GTp40ZZVCiDKsQEGhVatWrF27lrFjxz702P/+9z8aN25s6LrEI/x45AZTfzlLtkahQSVHvv1PMyo4SUgrk7LS4PASOPDlvev7bd2g2WvQ/HVwkNk/hRDFo0BB4Y033qBv377Ex8fTvXt3PDw8iIqKYvv27WzatIk1a9YYu85yLUejZea283z3zzUAejSswOf9G8lASmWRJgdOroG/ZkNKhG6ZR11oNRr8XwILa9PWJ4QodwoUFGrUqMGKFSv46KOPWLt2LSqVCkVR8PX15dtvv6VBgwbGrrPcSkzPZuz/jvP3JV2v9ve6+PJWkI9c/ljWKApc2Ap7pkPsJd0y56oQNA0a9Ae1DJwlhDCNAl9b1KRJE7Zs2UJ4eDhxcXF4eHhQsWJFY9ZW7l2JTuH1H45yJToVGwszvnipEd38K5i6LGFo1w/C7g91MxGCbhTEDhOh2atgbmXa2oQQ5V6hL0KuUqUKVapUMUYt4j5HrsXx2ird7I8Vnaz55j/NaFDJydRlCUOKvqgLCKE7dPctbKHVWGj9lm70QCGEKAFktJIS6PiNeIatDCE1S0OTqs4sHdIUTwc5N11mZCbD3jlweKluqmKVGTQdpjuK4CCXuQohShYJCiXM2VuJDM0NCa1quvHd8OZYW0inxTJBUeDsJtg55V5HRb/u0OUTcPcxbW1CCJEPCQolyIWIJF5ZcZjkjByaV3dhxbBmEhLKish/YdsEuH5Ad9+lBnT7FHyfNW1dQgjxBBIUSoiwqGQGf3uYhLRsGlVxZuWw5thayj9PqZeRdO80g6IBcxto93+6fghyqaMQohSQT6IS4GpMKi9/e5jY1CzqV3Tkh+GBOFhbmLosURSKAqd/gt3TICVSt6xOT+g6SzdtsRBClBISFEwsPC6Nl78NJio5kzreDqx5rQVOthISSrXIf2HbeLj+j+6+a03o9hnUfsa0dQkhxFOQoGBCtxPSeXl5MHcSM6jlYcfq11rgYmdp6rLE08pIgn1zdRM33T3N0P7/oPU4GQ9BCFFqSVAwkaikDAYvP0x4XDrV3Wz534iWeDjIh0mp9KirGer0hOdm60ZXFEKIUkyCgglkZGt4ZcVhrsakUtnFhv+NaImXo3RsK5WiLuhOM1z7W3ffpQZ0/wxqdzFtXUIIYSASFEzg+4PXCI1MwcPBinUjWlLRWWaALHUyU2D/p3Doa92gSebWuVczjJOrGYQQZYoEhWKWmJbN13+FATDpuTpUcbU1cUWiUB41u6Nfd91pBpfqJi1NCCGMQYJCMVu8N4ykjBzqeDvQJ6CSqcsRBaUocHEb7PkYYkJ1y1yqw3Nzwe85U1YmhBBGJUGhGN1OSOe7g9cA3dEEM7VMFV0qhIfArmkQHqy7L7M7CiHKEQkKxeiL3aFk5WhpUcOVjn4epi5HPEnMJd0RhAtbdffNbaDlKGj7DljLTJ5CiPJBgkIxuRCRxKbjNwF4v3tdVCo5mlBiJdyAA/Ph2Pe68RBUamg8GDp9AI4VTV2dEEIUKwkKxeSzHRdRFOju703jKs6mLkc8SFHg6j4I+VbXF0HR6pb7doNnPgLPuqatTwghTESCQjE4fCWWPy5EYaZWMf5ZP1OXI+6XmQyn1usCQszFe8trdIAOk6B6G9PVJoQQJYAEBSNTFIXZ2y8AMCiwCjU97E1ckYEpim4cAU02WNhAaTmlEnNJFw5O/g+yknXLLO2h0SAIHAEeEuiEEAIkKBjdjrMRnAxPwMbCjHGda5u6nMJJCIeL23WH4uOv6sKAJiv3d+5tbfa99S3twbma7rJBl7u/q+uWOZr4UlCtBu6chKv7IeyPeyMpArj5QOBIXUiwdjRZiUIIURJJUDCibI2Wz3bqDmePaFcDT4cSPmKfosCdU7nh4HeIOFO452elQNQ53c8DzAB/KzfUZ+qBu6/uG7t7bd1tx0qGPxKh1UL0eV0wuLofrv0DmYn3raAC3+egxUio0RHUasPuXwghygiTBIULFy4wd+5czp07h4WFBW3atGHy5Mm4urpy6tQpZsyYQVhYGC4uLowaNYoXX3zRFGUW2Y9HwrkSk4qbnSUj2tc0dTmPptXoOvFd2KYLCEk37z2mUkOVluDXDaoE6oYpNrMAM0vdb/V9t1VqSImE+Ou6ow/x1yDhuu53/HXITMIyM1b3Tf7+b/MAFnb3QoNzVbB1A1vXvL9tXMHK4V6gyEqDtFjdT3ocpMXl3o/T9TW4+jekxeTdj7UTVGsLNdrrBkmSkRSFEOKJij0oZGRk8Prrr/PSSy+xbNkyUlNTmTRpEh988AFz585l5MiRjBs3jgEDBnDkyBHGjBmDn58fDRs2LO5SiyQ1M4cv91wC4K0gHxysLUxc0SMk3IDNb8CNg/eWWdhCrSDdsMS+XcHOveDbs3bUfeA/SFHQpMYSGrwDP1cV6rgw3eiGMaEQdwWyU3WnBe6cfPz21Ra6D/usFMjJeHI9FrZQrbUuGNRoD94NQW1W8NcjhBCi+IPC7du3qVOnDmPGjMHMzAxLS0sGDBjAxIkT2bVrF87OzgwePBiAVq1a0atXL9auXVvqgsLKA1eJScmkqqstL7eoZupyHnZmI2x9T3c43tIeGvTThYOaHXSdEg1JpQIbF9Jc6qI0agxm931Ya7Ih7mpucLgIyRH3jgzc/zsnXdcf4v6jBGaW94422LreO/rgWBGqt4OKTcDc0rCvRQghypliDwo1a9Zk+fLleZbt3LmT+vXrc+nSJXx9ffM85uPjw8aNGx+7TY1Gg0ajMUh9d7dTlO3FpmaxbP9lAN7rUhszlWKw+oosMwnV9kmoz/wIgFK5OdoXluU9DG+EWvNvVzW41tL9+HbLfwPZabrQkJGoOwVh46ILOE/q21BS2t2IDPGeFQ+TdjUOaVfjeJp2Lei6Ju3MqCgKX375JX/99Rdr1qzhhx9+wMYm77dZa2tr0tLSHrud0NBQg9d25kwhO/Ld57uTSaRkaqjlYk4lTQQnT0YasLKnZxd3lhonZmOVdgcFNXd8X+FO7SFwPQGunyyWGorSrvfE5f6I+xmmbcWDpF2NQ9rVOIzRriYLCikpKbz//vucO3eONWvW4Ofnh42NDcnJyXnWy8jIwM7O7rHb8vX1xdbWMNM1azQazpw5g7+/P2ZmhT+frSgKR3fuBWBSj4Y0qetpkLqKRJuD6u95qA5+jkrRoDhXRfvCUryqtMSrmEooaruK/EnbGoe0q3FIuxrH07RrWlpagb5omyQo3LhxgxEjRlCxYkU2btyIq6sroPvA/+eff/KsGxYWRu3ajx9/wMzMzOBvuKfd5qXIZCKSMrE0V9Pez9P0/xHir8GmEXAzRHe/4QBU3T/DzESTGhnj30roSNsah7SrcUi7Gkdh2rWg6xX7xeOJiYkMHTqUJk2asGLFCn1IAOjSpQsxMTGsWrWK7OxsgoOD2bJlC/369SvuMp/a/ku6znYtarhibWHi/wR3TsPS9rqQYOUIfZdD329k5kMhhBAFVuxHFDZv3szt27fZvn07O3bsyPPYiRMnWLlyJTNnzmThwoW4uroydepUWrZsWdxlPrUDl6IBaFe7EJcVGkNyBKwbqLuqoVIz6L9SN1qiEEIIUQjFHhSGDx/O8OHD833c39+f9evXF2NFhpOZoyH4iq6TXVsfD9MVkp0O6wZB0i3dIEavbAIbZ9PVI4QQotSScWsN6Nj1eNKzNbjbW1HH28E0RWi18MsouH1cdwnhoPUSEoQQQjw1CQoGdCC3f0K72u6o1SaaRXHfHDj3s24UwwFrwK2WaeoQQghRJkhQMKC/7wsKJnF6A+ybq7vd60uo3tY0dQghhCgzJCgYSGxKJmdv62YnbOtjgqAQHgK/jtHdbj0OAl4p/hqEEEKUORIUDOSfy7EoCtTxdsDTsZink064AetfBk2mbr6GZz4u3v0LIYQosyQoGIjJLovMTIb/DYDUaPDyh77fygyJQgghDEaCggEoinJf/4RivCxSq4GNr0HUv2DvBS+vByv74tu/EEKIMk+CggFcjk7hTmIGluZqAmu4PvkJhrLnY7i0E8ytYeA6cKpcfPsWQghRLkhQMID9obqjCYHVi3HY5pvH4OBXutsvLIbKTYtnv0IIIcoVCQoGcCCsmC+L1OTA1rcBBRoOgAalZy4MIYQQpYsEhSLKzNFw6HIsUIz9E0KWQcQZsHaGZ2cWzz6FEEKUSxIUiuj49YTcYZsti2fY5sSb8GduOOgyHexNOKeEEEKIMk+CQhEdCNNdFtnWp5iGbd4+CbJToUpLCPiP8fcnhBCiXJOgUETFelnkhW1wYSuozaHnF6CWfz4hhBDGJZ80RRCXmsWZW7phm43ekTErFbZP1N1uNQa86ht3f0IIIQQSFIrkn7AYFAX8vIph2Oa9syExHJyqQodJxt2XEEIIkUuCQhEcKK7ZIiPOwKHFuts9PgdLO+PuTwghhMglQeEp6YZtzp3fwdeI/RO0Wtj6LigaqNsbfLsab19CCCHEAyQoPKXL0ancTszA0kxNYHUjDtt8fBXcPAKWDtBtrvH2I4QQQjyCBIWndPdoQvMaLthYGmnY5pQo3XwOAEFTwbGicfYjhBBC5EOCwlM6UByXRe78ADISoUIjCBxhvP0IIYQQ+ZCg8BSycrQcunJ32GYjdWS8shfObACVGnp+CepimmxKCCGEuI8Ehadw/EY8aVka3OwsqevtaPgdaHJg+2Td7eavQ6Umht+HEEIIUQASFJ7C3dMObWsbadjmY99B9HmwcYVOHxh++0IIIUQBSVB4CvrLIo3RPyEtDv7KnfSp0wdg42L4fQghhBAFJEGhkOJTs8i+fRprMo3TP2HfXEiPB8960HS44bcvhBBCFIK5qQsobUIPbGab5fv8bd4aL8e+ht149EUI+VZ3u+ssMJN/HiGEEKYlRxQKyezcRgDa5RyE2MuG3fjOD3QjMPp1h1qdDLttIYQQ4ilIUCgETU4OPkmH7i24++3fEEJ3QdgeUFvAszMMt10hhBCiCCQoFELosT9wJgUNuVc6nFwLmclF37AmW3c0AaDlm+BWq+jbFEIIIQxAgkIhJJzcCsBJxyBwqw2ZSXBqfdE3HPItxF4CW3doP6Ho2xNCCCEMRIJCIVSI/AsAxa8btHhDt/DwMt0Mj08rNRb2zdHd7vwhWDsVsUohhBDCcCQoFNCtK+eprg0nR1FTu9UL0GigbkbH2Etw5a+n3/BfM3XzOXj7Q8ArBqtXCCGEMAQJCgUUfngzABetGuDk6gFWDvc+2A8ve7qNRp7TjcII8Nxcmc9BCCFEiSNBoYDsru0GILlq53sLA0cAKri0q/CXSioK7HgfFC3Uex6qtzFcsUIIIYSBSFAogOTEOPwyTgNQqUWfew+41YLaXQAFjiwv3EYvboOr+8DMCrp8YrhihRBCCAOSoFAAlw7+iqVKww1VRarUbpT3wbudGk+sgcyUgm0wIwl2TtHdbj0WXKoZrlghhBDCgCQoFIDmwnYAbnt2ePjBmkHg5pN7qeS6J28sJwt+GgLxV8GhArR9z8DVCiGEEIYjQeEJNDk5+CTqRmN0aNjr4RXUagjMPaoQ8o2u70F+FAV+ewuu7AULOxi0DqzsDV+0EEIIYSASFJ7g0vG/cCGJJGzxbf7Mo1dqPEh3qWRM6OMvlfzjv3B6PajM4KXvoWKAcYoWQgghDESCwhPEn9wCwCWHllhYWj16JSsHCBisu53fpZIh38KBL3S3ey/M7QQphBBClGwSFJ7AO2IvAIrvc49fsfkI3e/QnRB3Je9j57fCttyhmTtNkYGVhBBClBoSFB7j9rWL1NBe143G2PqFx6/s7gM+uZdKhtx3qeSNw7DpNd3yJkNlLgchhBCligSFxwgP1o3GGGpVHyc3ryc/QX+p5GrdpZIxl2DdAMjJAN/noMcXoFIZsWIhhBDCsMxNXUBJZpM7GmNSlaCCPaFWZ3CtBXGX4eBC3eWS6fFQqSn0Xwlm0txCCCFKFzmikI+UpATqpJ8CoEJg34I9Sa2+d1Rh31xIuAGuNeHln8DSzkiVCiGEEMYjQSEfYcFbsFTlcFNVgaq1Gxb8iY0GgWXu2Ai27vDKJrBzN06RQgghhJFJUMiH5uIOAG56tEelLkQzWTvqrmzwqAuDf9IdURBCCCFKKTlp/gharYZaCQcBsG/Ys/AbaDVa9yOEEEKUcnJE4RHib5zFjUSSFRt8mz9r6nKEEEIIk5Gg8AiqG7qjCaEOLbC0sjZxNUIIIYTpSFB4hBpJIQBoaz9hNEYhhBCijJOg8IDI8DB8lOtoFBW12/QxdTlCCCGESUlQeMCN4J8BCLWsh7O7t4mrEUIIIUyrRAaF2NhYRo8eTbNmzWjRogUzZ84kJyenWPZ9dzTGhMqdimV/QgghRElWIoPCO++8g62tLX///TcbN27k0KFDrFq1qlj2XTnjEgBezV8olv0JIYQQJVmJG0fh+vXrhISEsH//fmxsbKhSpQqjR4/ms88+4/XXX3/kczQaDRqNxiD7vxzwPiGRt+js08hg2xTo21La1PCkbY1D2tU4pF2N42nataDrlrigcOnSJZydnfHyujdbY61atbh9+zZJSUk4Ojo+9JzQ0FCD7d+sciCeleHMmTMG26a4R9rVeKRtjUPa1TikXY3DGO1a4oJCamoqNjY2eZbdvZ+WlvbIoODr64utra1B9q/RaDhz5gz+/v6YmZkZZJtC2tWYpG2NQ9rVOKRdjeNp2jUtLa1AX7RLXFCwtbUlPT09z7K79+3sHj0Do5mZmcHfcMbYppB2NSZpW+OQdjUOaVfjKEy7FnS9EteZsXbt2iQkJBATE6NfdvnyZby9vXFwcDBhZUIIIUT5U+KCQvXq1WnatCmzZs0iJSWF8PBwFi9eTP/+/U1dmhBCCFHulLigALBw4UJycnLo3LkzL730Eu3atWP0aJmNUQghhChuJa6PAoC7uzsLFy40dRlCCCFEuVcijygIIYQQomSQoCCEEEKIfElQEEIIIUS+JCgIIYQQIl8SFIQQQgiRrxJ51UNBabVagIdGciyKu5NkpKWlyahhBiTtajzStsYh7Woc0q7G8TTtevez8+5naX5UiqIoRSvPdGJjY7l27ZqpyxBCCCFKrerVq+Pm5pbv46U6KOTk5JCYmIiVlRVqtZxFEUIIIQpKq9WSmZmJk5MT5ub5n2Ao1UFBCCGEEMYlX8OFEEIIkS8JCkIIIYTIlwSF+8TGxjJ69GiaNWtGixYtmDlzJjk5OaYuq9SKi4ujS5cuHD58WL/s1KlTvPjiiwQEBBAUFMSGDRtMWGHpcuHCBYYPH05gYCBt2rRh4sSJxMXFAdKuRXXo0CFefPFFmjRpQps2bfjkk0/IyMgApG0NQaPRMGTIECZPnqxfJu369LZt20a9evUICAjQ/0yYMAEwUrsqQu+VV15R/u///k9JS0tTbty4ofTo0UP59ttvTV1WqXT06FHlmWeeUXx9fZXg4GBFURQlISFBCQwMVNasWaNkZ2crBw8eVAICApRTp06ZuNqSLz09XWnTpo2yYMECJTMzU4mLi1NGjBihvPHGG9KuRRQbG6v4+/srmzZtUjQajRIZGan07NlTWbBggbStgXz55ZdKnTp1lEmTJimKIn8LimrOnDnK5MmTH1purHaVIwq5rl+/TkhICBMmTMDGxoYqVaowevRo1q5da+rSSp2ff/6Z8ePH8+677+ZZvmvXLpydnRk8eDDm5ua0atWKXr16SRsXwO3bt6lTpw5jxozB0tISFxcXBgwYwJEjR6Rdi8jV1ZWDBw/St29fVCoVCQkJZGZm4urqKm1rAIcOHWLXrl08++yz+mXSrkVz5swZGjRo8NByY7WrBIVcly5dwtnZGS8vL/2yWrVqcfv2bZKSkkxYWenTtm1bdu/eTffu3fMsv3TpEr6+vnmW+fj4cOHCheIsr1SqWbMmy5cvzzOQys6dO6lfv760qwHY29sD0KFDB3r16oWHhwd9+/aVti2i2NhYpkyZwrx587CxsdEvl3Z9elqtlnPnzrF37146depE+/btmTZtGomJiUZrVwkKuVJTU/O8kQH9/bS0NFOUVGp5eHg88prcR7WxtbW1tG8hKYrC/Pnz+euvv5gyZYq0qwHt2rWL/fv3o1arGTdunLRtEWi1WiZMmMDw4cOpU6dOnsekXZ9eXFwc9erVo2vXrmzbto3169dz7do1JkyYYLR2laCQy9bW9qGhoO/et7OzM0VJZY6NjY2+g9hdGRkZ0r6FkJKSwrhx49iyZQtr1qzBz89P2tWArK2t8fLyYsKECfz999/StkWwbNkyLC0tGTJkyEOPSbs+PXd3d9auXUv//v2xsbGhYsWKTJgwgf3796MoilHaVYJCrtq1a5OQkEBMTIx+2eXLl/H29sbBwcGElZUdvr6+XLp0Kc+ysLAwateubaKKSpcbN27Qr18/UlJS2LhxI35+foC0a1EdP36c5557jqysLP2yrKwsLCws8PHxkbZ9Sr/++ishISE0a9aMZs2asXXrVrZu3UqzZs3kPVsEFy5c4PPPP0e5b6zErKws1Go1DRs2NEq7SlDIVb16dZo2bcqsWbNISUkhPDycxYsX079/f1OXVmZ06dKFmJgYVq1aRXZ2NsHBwWzZsoV+/fqZurQSLzExkaFDh9KkSRNWrFiBq6ur/jFp16Lx8/MjIyODefPmkZWVxa1bt5g7dy79+/ena9eu0rZPaceOHRw/fpyjR49y9OhRevbsSc+ePTl69Ki8Z4vA2dmZtWvXsnz5cnJycrh9+zafffYZffr0Mdr7VYZwvk9MTAz//e9/OXz4MGq1mhdeeIHx48fLDGdF4Ofnxw8//ECLFi0AXW/dmTNnEhoaiqurK6NHj6Zv374mrrLk++6775gzZw42NjaoVKo8j504cULatYjCwsKYNWsWZ86cwcHBgV69eumvMJG2NYy7YyjMmTMHkL8FRRESEsIXX3xBaGgoVlZW9OjRgwkTJmBlZWWUdpWgIIQQQoh8yakHIYQQQuRLgoIQQggh8iVBQQghhBD5kqAghBBCiHxJUBBCCCFEviQoCCGEECJfEhSEEEIIkS8JCkIIvaioKKNOzGPs7QshDE+CghDl3JAhQ/jqq6+IiYmha9euxMXFGWU/D25/6dKlvP7660bZlxDCcB6eC1gIUS5lZGQY9dv+g9t/8803jbYvIYThyBEFIQQajYaePXsC0LNnT7Zt2wbA77//Tq9evWjatCl9+/blwIED+ucMGTKEyZMn06lTJzp27EhKSgp//vknAwcOpFWrVjRq1IhXXnmFa9euPXL7X331VZ4piPfs2UPfvn1p0qQJXbt2ZdWqVWi1WkA3T8CHH37Im2++SUBAAJ07d+aHH34oruYRolyToCCEwMzMjK1btwKwdetWunfvzr59+/joo4/48MMPCQkJ4a233uKtt97KM43twYMHWb9+Pb/99hspKSm8/fbbjBw5kkOHDrF3714UReHrr79+5PbvFxwczDvvvMPrr7+un/Dmu+++yxMGNm/ezJAhQzhy5AgjRoxgzpw5REZGFkPrCFG+SVAQQjzSmjVrGDRoEM2bN8fMzIxOnToRFBTE+vXr9eu0b98eLy8vHB0dcXV15ffffycoKIiUlBQiIiJwcXEp0If55s2b6dy5M927d8fc3Jz69eszcuTIPPtq0aIFbdq0wdzcnH79+qHRaLhx44ZRXrsQ4h7poyCEeKRbt24REhLCunXr9Ms0Gg0tW7bU3/f09NTftrCwYOvWraxfvx6VSoWvry8pKSmYmz/5z0xsbCx169bNs6xy5crcunVLf9/DwyPPvgD9qQkhhPFIUBBCPJK3tzcvvPACI0eO1C+7ffs21tbW+vsqlUp/e/v27axZs4Z169ZRrVo1AD755BNCQ0OfuK9KlSo9dHQgPDw8TzgQQpiGnHoQQgBgZWUFQEpKCgAvvfQSP/zwA6dPnwbgzJkz9O3bV9/X4EHJycmo1Wqsra1RFIX9+/fzyy+/kJ2d/cjt369fv378+eefbN++HY1Gw7///su3335Lv379DP46hRCFI0cUhBAAuLu706VLFwYMGMDkyZMZNGgQaWlpfPDBB9y+fRtnZ2eGDRuW50qF+/Xp04djx47Ro0cPzMzMqFmzJkOHDmXt2rVkZWU9tP37NWrUiAULFvD111/zwQcf4OLiwqBBgxgxYkRxvHQhxGOoFEVRTF2EEEIIIUomOfUghBBCiHxJUBBCCCFEviQoCCGEECJfEhSEEEIIkS8JCkIIIYTIlwQFIYQQQuRLgoIQQggh8iVBQQghhBD5kqAghBBCiHxJUBBCCCFEviQoCCGEECJf/w/PAqVcXmMV1wAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "beta_params_log = np.array(model.beta_params_log)\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 4))\n", + "ax.plot(beta_params_log[:, 0], label=\"param0\")\n", + "ax.plot(beta_params_log[:, 1], label=\"param1\")\n", + "ax.legend()\n", + "ax.set(xlabel=\"Iteration\", ylabel=\"Coefficient value\", title='Distribution parameters through training')\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting distribution against interation" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/_v/nlh4h1yx2n1gd6f3szjlgxt40000gr/T/ipykernel_42343/1794095813.py:13: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "beta_params_log = np.array(model.beta_params_log)\n", + "x = np.linspace(0, 1, 1000)\n", + "iterations = range(0, beta_params_log.shape[0], 10)\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 4))\n", + "for idx in iterations:\n", + " y = scipy.stats.beta(*beta_params_log[idx, :]).pdf(x)\n", + " ax.plot(x, y, alpha=0.5, label=idx)\n", + "\n", + "ax.axvline(x=p_success, linestyle=\"--\", color=\"b\", alpha=0.5, label=\"True P(success)\")\n", + "ax.legend()\n", + "ax.set(xlabel=\"P(success)\", ylabel=\"PDF\", title=\"Distributions through training\")\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparison with maximum likelihood estimation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "The true beta parameters for this data can be calculated as the sum of the successes and the sum of the failures." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MLE parameters\n", + "6999\n", + "3001\n" + ] + } + ], + "source": [ + "print(\"MLE parameters\")\n", + "print((rand_samples == 1).sum())\n", + "print((rand_samples == 0).sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The MLE distribution is a very tight fit around the true success probability." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/_v/nlh4h1yx2n1gd6f3szjlgxt40000gr/T/ipykernel_42343/2078173807.py:9: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(0, 1, 1000)\n", + "y = scipy.stats.beta((rand_samples == 1).sum(), (rand_samples == 0).sum()).pdf(x)\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 4))\n", + "ax.plot(x, y, label=\"MLE distribution\")\n", + "ax.axvline(x=p_success, linestyle=\"--\", color=\"b\", alpha=0.5, label=\"True P(success)\")\n", + "ax.set(xlabel=\"P(success)\", ylabel=\"PDF\", title=\"MLE distribution\")\n", + "ax.legend()\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is shown also in the log likelihood of observing the data given the distribution.\n", + "The MLE LL is expectedly better (higher):" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MLE LL: 4.47\n", + "NN LL: 2.28\n" + ] + } + ], + "source": [ + "print(\n", + " f\"MLE LL: {scipy.stats.beta((rand_samples==1).sum(), (rand_samples==0).sum()).logpdf(rand_samples.mean()):.2f}\"\n", + ")\n", + "print(\n", + " f\"NN LL: {scipy.stats.beta(*beta_params_log[-1,:]).logpdf(rand_samples.mean()):.2f}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, when we want to make the distribution a function of various features we cannot use the MLE approach in the same way.\n", + "Gradient descent however can still be used." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Appendix\n", + "\n", + "TODO:\n", + "\n", + "* Quantile regression from a multi head NN\n", + "* " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exploring distributions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[7.9465e-01],\n", + " [9.8314e-02],\n", + " [5.3686e-01],\n", + " [1.2176e-01],\n", + " [4.7895e-01],\n", + " [1.8919e-02],\n", + " [7.2673e-01],\n", + " [6.2900e-01],\n", + " [5.8163e-01],\n", + " [7.8585e-01],\n", + " [1.1850e-01],\n", + " [1.4547e-01],\n", + " [2.6722e-01],\n", + " [9.9544e-01],\n", + " [9.9937e-01],\n", + " [9.6382e-01],\n", + " [9.8782e-01],\n", + " [9.0896e-01],\n", + " [3.3455e-02],\n", + " [9.9977e-01],\n", + " [1.7100e-02],\n", + " [7.8972e-01],\n", + " [5.8074e-02],\n", + " [9.1087e-01],\n", + " [4.7398e-01],\n", + " [7.3772e-01],\n", + " [9.8253e-01],\n", + " [6.9342e-01],\n", + " [9.6179e-01],\n", + " [5.5020e-01],\n", + " [6.0733e-01],\n", + " [3.9311e-01],\n", + " [6.2002e-04],\n", + " [3.0071e-01],\n", + " [5.8508e-01],\n", + " [2.9016e-01],\n", + " [3.4136e-01],\n", + " [5.7220e-01],\n", + " [4.2474e-01],\n", + " [9.9973e-01],\n", + " [9.4924e-01],\n", + " [5.2341e-01],\n", + " [4.3132e-01],\n", + " [9.4580e-01],\n", + " [9.0959e-01],\n", + " [9.9789e-01],\n", + " [9.9586e-01],\n", + " [1.1715e-01],\n", + " [5.0077e-01],\n", + " [1.5136e-01],\n", + " [8.9403e-01],\n", + " [2.2254e-01],\n", + " [5.7264e-01],\n", + " [6.9465e-01],\n", + " [9.4916e-01],\n", + " [9.9788e-01],\n", + " [5.1308e-01],\n", + " [9.2236e-01],\n", + " [9.8785e-01],\n", + " [6.4955e-01],\n", + " [8.3602e-02],\n", + " [3.9582e-01],\n", + " [3.2508e-01],\n", + " [1.7559e-01],\n", + " [9.3873e-01],\n", + " [8.8563e-01],\n", + " [9.6166e-01],\n", + " [6.7665e-02],\n", + " [7.5508e-01],\n", + " [4.6497e-01],\n", + " [9.4712e-01],\n", + " [6.6969e-02],\n", + " [2.7491e-01],\n", + " [5.3678e-01],\n", + " [6.1143e-02],\n", + " [2.5732e-01],\n", + " [8.5025e-01],\n", + " [1.2072e-01],\n", + " [5.2869e-01],\n", + " [2.0114e-01],\n", + " [4.7868e-01],\n", + " [1.2813e-01],\n", + " [9.9808e-01],\n", + " [4.4948e-01],\n", + " [2.7319e-01],\n", + " [9.9187e-01],\n", + " [9.0806e-01],\n", + " [6.3824e-01],\n", + " [7.9136e-01],\n", + " [9.0642e-01],\n", + " [1.7599e-02],\n", + " [1.1454e-01],\n", + " [9.8142e-01],\n", + " [2.5868e-01],\n", + " [9.0499e-01],\n", + " [9.5528e-01],\n", + " [2.2938e-02],\n", + " [4.8639e-01],\n", + " [9.7827e-01],\n", + " [8.2148e-01]])\n", + "tensor([0.5669, 0.3317, 0.1014])\n", + "tensor([0.4172, 0.2689, 0.3139])\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.distributions\n", + "\n", + "dist = torch.distributions.beta.Beta(torch.tensor([0.5]), torch.tensor([0.5]))\n", + "print(dist.sample(sample_shape=torch.Size([100])))\n", + "\n", + "dist = torch.distributions.dirichlet.Dirichlet(torch.tensor([0.5, 0.5, 0.5]))\n", + "print(dist.sample())\n", + "\n", + "dist = torch.distributions.dirichlet.Dirichlet(torch.tensor([15.0, 15.0, 15.0]))\n", + "print(dist.sample())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate random data\n", + "\n", + "I'll make random data from two beta distributions and then select from them randomly to get two peaks.\n", + "I'll deliberately make the distributions fairly distinct to make the initial analysis easier to visualise." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "ename": "OSError", + "evalue": "'seaborn-whitegrid' is not a valid package style, path of style file, URL of style file, or library style name (library styles are listed in `style.available`)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/miniconda3/envs/pytorch_env/lib/python3.12/site-packages/matplotlib/style/core.py:137\u001b[0m, in \u001b[0;36muse\u001b[0;34m(style)\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 137\u001b[0m style \u001b[39m=\u001b[39m _rc_params_in_file(style)\n\u001b[1;32m 138\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mOSError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n", + "File \u001b[0;32m~/miniconda3/envs/pytorch_env/lib/python3.12/site-packages/matplotlib/__init__.py:866\u001b[0m, in \u001b[0;36m_rc_params_in_file\u001b[0;34m(fname, transform, fail_on_error)\u001b[0m\n\u001b[1;32m 865\u001b[0m rc_temp \u001b[39m=\u001b[39m {}\n\u001b[0;32m--> 866\u001b[0m \u001b[39mwith\u001b[39;49;00m _open_file_or_url(fname) \u001b[39mas\u001b[39;49;00m fd:\n\u001b[1;32m 867\u001b[0m \u001b[39mtry\u001b[39;49;00m:\n", + "File \u001b[0;32m~/miniconda3/envs/pytorch_env/lib/python3.12/contextlib.py:137\u001b[0m, in \u001b[0;36m_GeneratorContextManager.__enter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 137\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mnext\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mgen)\n\u001b[1;32m 138\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mStopIteration\u001b[39;00m:\n", + "File \u001b[0;32m~/miniconda3/envs/pytorch_env/lib/python3.12/site-packages/matplotlib/__init__.py:843\u001b[0m, in \u001b[0;36m_open_file_or_url\u001b[0;34m(fname)\u001b[0m\n\u001b[1;32m 842\u001b[0m fname \u001b[39m=\u001b[39m os\u001b[39m.\u001b[39mpath\u001b[39m.\u001b[39mexpanduser(fname)\n\u001b[0;32m--> 843\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mopen\u001b[39;49m(fname, encoding\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39mutf-8\u001b[39;49m\u001b[39m'\u001b[39;49m) \u001b[39mas\u001b[39;00m f:\n\u001b[1;32m 844\u001b[0m \u001b[39myield\u001b[39;00m f\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'seaborn-whitegrid'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/stantoon/Documents/VariousProjects/github/data-analysis/neural_networks/unfinished-dirichlet_distributions/exploration.ipynb Cell 38\u001b[0m line \u001b[0;36m4\n\u001b[1;32m 1\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mnumpy\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mnp\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mmatplotlib\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpyplot\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mplt\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m plt\u001b[39m.\u001b[39;49mstyle\u001b[39m.\u001b[39;49muse(\u001b[39m\"\u001b[39;49m\u001b[39mseaborn-whitegrid\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n\u001b[1;32m 6\u001b[0m \u001b[39m# true distribution parameters\u001b[39;00m\n\u001b[1;32m 7\u001b[0m p_d1 \u001b[39m=\u001b[39m \u001b[39m0.5\u001b[39m\n", + "File \u001b[0;32m~/miniconda3/envs/pytorch_env/lib/python3.12/site-packages/matplotlib/style/core.py:139\u001b[0m, in \u001b[0;36muse\u001b[0;34m(style)\u001b[0m\n\u001b[1;32m 137\u001b[0m style \u001b[39m=\u001b[39m _rc_params_in_file(style)\n\u001b[1;32m 138\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mOSError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n\u001b[0;32m--> 139\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mOSError\u001b[39;00m(\n\u001b[1;32m 140\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m{\u001b[39;00mstyle\u001b[39m!r}\u001b[39;00m\u001b[39m is not a valid package style, path of style \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 141\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mfile, URL of style file, or library style name (library \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 142\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mstyles are listed in `style.available`)\u001b[39m\u001b[39m\"\u001b[39m) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n\u001b[1;32m 143\u001b[0m filtered \u001b[39m=\u001b[39m {}\n\u001b[1;32m 144\u001b[0m \u001b[39mfor\u001b[39;00m k \u001b[39min\u001b[39;00m style: \u001b[39m# don't trigger RcParams.__getitem__('backend')\u001b[39;00m\n", + "\u001b[0;31mOSError\u001b[0m: 'seaborn-whitegrid' is not a valid package style, path of style file, URL of style file, or library style name (library styles are listed in `style.available`)" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.style.use(\"seaborn-whitegrid\")\n", + "\n", + "# true distribution parameters\n", + "p_d1 = 0.5\n", + "p_lambda = 5\n", + "\n", + "n = 10000\n", + "rand_gen = np.random.default_rng(seed=0)\n", + "\n", + "poisson_samples = rand_gen.poisson(lam=p_lambda, size=(n, 1))\n", + "mix_samples = rand_gen.binomial(n=1, p=p_d1, size=(n, 1))\n", + "rand_samples = mix_samples * poisson_samples\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "ax.hist(rand_samples, bins=50)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating a PyTorch model\n", + "\n", + "Assuming we know the underlying generating model (...strong assumption...?), we can construct a network that builds the equivalent distribution objects in PyTorch.\n", + "\n", + "We are fitting the distribution parameters.\n", + "As such we have no input features for the forward pass, only the output values.\n", + "We use negative log likelihood as the loss function to optimise." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pytorch_lightning as pl\n", + "import torch\n", + "\n", + "\n", + "class ZIPModel(pl.LightningModule):\n", + " def __init__(\n", + " self,\n", + " learning_rate=1e-3,\n", + " init_mix_parameter: float = 0.5,\n", + " init_poisson_lambda: float = 1.0,\n", + " ):\n", + " super().__init__()\n", + " self.mixture_prob = torch.nn.Parameter(torch.tensor([init_mix_parameter]))\n", + " self.poisson_lambda = torch.nn.Parameter(torch.tensor([init_poisson_lambda]))\n", + "\n", + " self.train_log_error = []\n", + " self.val_log_error = []\n", + " self.mixture_prob_log = []\n", + " self.poisson_lambda_log = []\n", + " self.learning_rate = learning_rate\n", + "\n", + " def forward(self):\n", + " # ensure correct domain for params\n", + " mixture_prob_norm = torch.sigmoid(self.mixture_prob)\n", + " poisson_lambda_norm = torch.nn.functional.softplus(self.poisson_lambda)\n", + " poisson_lambda_norm = torch.concat(\n", + " (torch.tensor([0.0]), poisson_lambda_norm)\n", + " ) # maintains grad\n", + "\n", + " mix = torch.distributions.Categorical(\n", + " torch.concat((mixture_prob_norm, 1 - mixture_prob_norm))\n", + " )\n", + " poissons = torch.distributions.Poisson(poisson_lambda_norm)\n", + "\n", + " mixture_dist = torch.distributions.MixtureSameFamily(mix, poissons)\n", + " return mixture_dist\n", + "\n", + " def configure_optimizers(self):\n", + " optimizer = torch.optim.Adam(\n", + " self.parameters(),\n", + " lr=self.learning_rate,\n", + " )\n", + " return optimizer\n", + "\n", + " def training_step(self, batch, batch_idx):\n", + " y = batch[0]\n", + "\n", + " mixture_dist = self.forward()\n", + "\n", + " negloglik = -mixture_dist.log_prob(y)\n", + " loss = torch.mean(negloglik)\n", + "\n", + " self.train_log_error.append(loss.detach().numpy())\n", + " self.poisson_lambda_log.append(\n", + " torch.nn.functional.softplus(self.poisson_lambda).detach().numpy()\n", + " )\n", + " self.mixture_prob_log.append(torch.sigmoid(self.mixture_prob).detach().numpy())\n", + " return loss\n", + "\n", + " def validation_step(self, batch, batch_idx):\n", + " y = batch[0]\n", + "\n", + " mixture_dist = self.forward()\n", + "\n", + " negloglik = -mixture_dist.log_prob(y)\n", + " loss = torch.mean(negloglik)\n", + "\n", + " self.train_log_error.append(loss.detach().numpy())\n", + " return loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets create the model:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create model\n", + "torch.manual_seed(1)\n", + "model = ZIPModel(learning_rate=1e-0, init_mix_parameter=0.5, init_poisson_lambda=4.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can generate distribution objects from the model by calling the forward pass method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get some samples\n", + "output_dist = model()\n", + "output_samples = output_dist.sample((n, 1)).numpy().squeeze()\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "ax.hist(output_samples, bins=50)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fitting the model distribution\n", + "To train the model with our random sample data created above, we need to setup a dataloader to pass to the trainer." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([10000, 1])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# training on the whole dataset each batch\n", + "from torch.utils.data import TensorDataset, DataLoader\n", + "\n", + "rand_samples_t = torch.Tensor(rand_samples)\n", + "dataset_train = TensorDataset(rand_samples_t)\n", + "dataloader_train = DataLoader(dataset_train, batch_size=len(rand_samples))\n", + "\n", + "# test loading a batch\n", + "rand_samples_batch = next(iter(dataloader_train))\n", + "rand_samples_batch[0].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can train the model via PyTorch Lightning's Trainer object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:1789: UserWarning: MPS available but not used. Set `accelerator` and `devices` using `Trainer(accelerator='mps', devices=1)`.\n", + " rank_zero_warn(\n", + "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/trainer/configuration_validator.py:107: PossibleUserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + " rank_zero_warn(\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n", + "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:236: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " rank_zero_warn(\n", + "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:1892: PossibleUserWarning: The number of training batches (1) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n", + " rank_zero_warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "02d579ea152f40efa80d4e61b7c925ef", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + } + ], + "source": [ + "# fit network\n", + "trainer = pl.Trainer(\n", + " max_epochs=100,\n", + ")\n", + "trainer.fit(model, dataloader_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see the training loss has converged ok." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/ky/4qby95090jbbq38_mh94x72r0000gn/T/ipykernel_82119/2590399248.py:11: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def moving_average(a, n=10):\n", + " ret = np.cumsum(a, dtype=float)\n", + " ret[n:] = ret[n:] - ret[:-n]\n", + " return ret[n - 1 :] / n\n", + "\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "ax.plot(moving_average(np.array(model.train_log_error)))\n", + "ax.set_ylabel(\"Loss\")\n", + "ax.set_xlabel(\"Training iteration\")\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/ky/4qby95090jbbq38_mh94x72r0000gn/T/ipykernel_82119/2571154232.py:9: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "ax.plot(model.poisson_lambda_log, color=\"b\", label=\"lambda\")\n", + "ax.plot(model.mixture_prob_log, color=\"orange\", label=\"p\")\n", + "ax.axhline(y=p_lambda, linestyle=\"--\", color=\"b\", alpha=0.5)\n", + "ax.axhline(y=p_d1, linestyle=\"--\", color=\"orange\", alpha=0.5)\n", + "ax.legend()\n", + "ax.set_xlabel(\"Iteration\")\n", + "ax.set_ylabel(\"Coefficient value\")\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Checking results\n", + "Now we can check the resulting distribution that comes out of our model and compare that directly to the random samples." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot pdf\n", + "output_dist = model()\n", + "x = torch.arange(0, 20)\n", + "y = torch.exp(output_dist.log_prob(x))\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "ax.hist(\n", + " rand_samples,\n", + " bins=rand_samples.max() - rand_samples.min(),\n", + " density=True,\n", + " label=\"raw data\",\n", + ")\n", + "ax.plot(x.detach().numpy(), y.detach().numpy(), label=\"model pdf\")\n", + "fig.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the trained distribution parameters now are close to the underlying parameters." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Final mix: 0.5104645\n", + "Final lambda: 5.013678\n", + "True mix: 0.5\n", + "True lambda: 5\n" + ] + } + ], + "source": [ + "print(\"Final mix:\", model.mixture_prob_log[-1][0])\n", + "print(\"Final lambda:\", model.poisson_lambda_log[-1][0])\n", + "\n", + "print(\"True mix:\", p_d1)\n", + "print(\"True lambda:\", p_lambda)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Random seeding\n", + "We can start the training from different random initialisations to see how smooth the objective function surface is." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "605a1889cc094909a5f7e54c8e482ae1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7d3c515e6aae4ae18a6e9070581b2de6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84aae68403154d368f0642658647bbd8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "14b3b745289d41abab2188420f79accd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d6c47f4ffd714f1aac9f216cab5c0b99", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d77e5dfd2c5e441588e97d77aa8b0e98", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9f988731de19470daf91d8290febfeb3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "de8f04d053d043109eff2f5520321ab6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6292a6facca84d3ba87b3f1cf08ff16d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9ab3e9840e744a7585c16126e561638d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "seed_model_params = []\n", + "for _idx in range(10):\n", + " print(_idx)\n", + " init_params = [random.random(), random.random() * 10]\n", + " model = ZIPModel(\n", + " learning_rate=1e-0,\n", + " init_mix_parameter=init_params[0],\n", + " init_poisson_lambda=init_params[1],\n", + " )\n", + "\n", + " # fit network\n", + " trainer = pl.Trainer(\n", + " max_epochs=100,\n", + " )\n", + " trainer.fit(model, dataloader_train)\n", + "\n", + " seed_model_params.append(\n", + " {\n", + " \"err\": model.train_log_error[-1],\n", + " \"mixture\": model.mixture_prob_log[-1],\n", + " \"lambda\": model.poisson_lambda_log[-1],\n", + " \"mixture_init\": init_params[0],\n", + " \"lambda_init\": init_params[1],\n", + " }\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
errmixturelambdamixture_initlambda_init
01.7549713[0.5084596][4.990373]0.2061261.271737
11.7549436[0.5095606][5.0154147]0.9573755.609975
21.75495[0.50945556][5.0249567]0.1133689.019589
31.7549486[0.51113284][5.019183]0.0243602.504726
41.7549453[0.50945634][5.0075474]0.4229566.300903
51.7549646[0.5087664][4.992894]0.3170831.335294
61.7549437[0.50981426][5.016553]0.5690973.339710
71.7549523[0.51095116][5.002224]0.1460558.153884
81.7549479[0.50936157][5.022941]0.5381953.024650
91.7549556[0.50825804][5.0001493]0.0753639.901132
\n", + "
" + ], + "text/plain": [ + " err mixture lambda mixture_init lambda_init\n", + "0 1.7549713 [0.5084596] [4.990373] 0.206126 1.271737\n", + "1 1.7549436 [0.5095606] [5.0154147] 0.957375 5.609975\n", + "2 1.75495 [0.50945556] [5.0249567] 0.113368 9.019589\n", + "3 1.7549486 [0.51113284] [5.019183] 0.024360 2.504726\n", + "4 1.7549453 [0.50945634] [5.0075474] 0.422956 6.300903\n", + "5 1.7549646 [0.5087664] [4.992894] 0.317083 1.335294\n", + "6 1.7549437 [0.50981426] [5.016553] 0.569097 3.339710\n", + "7 1.7549523 [0.51095116] [5.002224] 0.146055 8.153884\n", + "8 1.7549479 [0.50936157] [5.022941] 0.538195 3.024650\n", + "9 1.7549556 [0.50825804] [5.0001493] 0.075363 9.901132" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "pd.DataFrame(seed_model_params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compared with the true parameters, it looks like we're converging well in each case.\n", + "\n", + "So seems successful overall! This approach makes it quite easy to train fairly complex distributions without having to understand the particular methods for fitting that distribution type (if they even exist)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating a PyTorch distribution object\n", + "\n", + "The solution is a bit hacky - we need to define the mixture of two of the same types, so we used a Poisson distribution with a $\\lambda$ of 0.\n", + "Can we reformulate this is a pytorch distribution class instead?\n", + "\n", + "The poisson class in PyTorch is based around the following (simplified) form:\n", + "```python\n", + "class Poisson(ExponentialFamily):\n", + " def __init__(self, rate, validate_args=None):\n", + " self.rate = rate\n", + " super(Poisson, self).__init__(batch_shape, validate_args=validate_args)\n", + "\n", + " def sample(self, sample_shape=torch.Size()):\n", + " with torch.no_grad():\n", + " return torch.poisson(self.rate.expand(shape))\n", + "\n", + " def log_prob(self, value):\n", + " return value.xlogy(self.rate) - self.rate - (value + 1).lgamma()\n", + "\n", + " ...\n", + "```\n", + "\n", + "Can we build the equivalent zero-inflated Poisson distribution?\n", + "\n", + "We need to specify a `sample` and `log-prob` method. For both of those we need to find an expression for the product mass function (PMF).\n", + "\n", + "### PMF\n", + "Poisson PMF:\n", + "$$\\mathrm{P_{s}}(Y=k | \\lambda) = \\frac{\\lambda^{k} e^{-\\lambda }} {k!}$$\n", + "\n", + "Bernoulli PMF:\n", + "$$\n", + "\\begin{align*}\n", + "\\mathrm{P_{d}}(Y=0) &= \\pi\\\\\n", + "\\mathrm{P_{d}}(Y!=0) &= 1-\\pi\n", + "\\end{align*}\n", + "$$\n", + "\n", + "Mixture distribution:\n", + "$$\\mathrm{P}(Y) = \\mathrm{P_{d}}(Y) \\mathrm{P_{s}}(Y)$$\n", + "\n", + "This is the expression we implement to create the `sample` method.\n", + "\n", + "\n", + "We need to dig further to get the full expression.\n", + "The zero case:\n", + "$$\n", + "\\begin{align*}\n", + "\\mathrm{P}(Y=0) &= \\mathrm{P_{d}}(Y=0) + \\mathrm{P_{d}}(Y=1) \\mathrm{P_{s}}(Y=0 | \\lambda)\\\\\n", + " &= \\pi + (1-\\pi) \\frac{\\lambda^{0} e^{-\\lambda }} {0!}\\\\\n", + " &= \\pi + (1-\\pi) e^{-\\lambda }\n", + "\\end{align*}\n", + "$$\n", + "\n", + "The non-zero case:\n", + "$$\\mathrm{P}(Y=k) = (1-\\pi) \\frac{\\lambda^{k} e^{-\\lambda }} {k!}$$\n", + "\n", + "### Log probs\n", + "Log of the above:\n", + "$$\\log{\\mathrm{P}(Y=0)} = \\log(\\pi + (1-\\pi) e^{-\\lambda })$$\n", + "\n", + "Non zero case:\n", + "$$\n", + "\\begin{align*}\n", + "\\log{\\mathrm{P}(Y=k)} &= \\log((1-\\pi) \\frac{\\lambda^{k} e^{-\\lambda }} {k!})\\\\\n", + " &= \\log(1-\\pi) + \\log(\\frac{\\lambda^{k} e^{-\\lambda }} {k!})\\\\\n", + " &= \\log(1-\\pi) + \\log(\\lambda^{k} e^{-\\lambda }) -\\log(k!)\\\\\n", + " &= \\log(1-\\pi) + k\\log(\\lambda) -\\lambda -\\log(\\Gamma(k+1))\n", + "\\end{align*}\n", + "$$\n", + "\n", + "\n", + "We can create those expression inside a new class:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from numbers import Number\n", + "\n", + "import torch\n", + "from torch.distributions import constraints\n", + "from torch.distributions.exp_family import ExponentialFamily\n", + "from torch.distributions.utils import broadcast_all\n", + "\n", + "\n", + "class ZeroInflatedPoisson(ExponentialFamily):\n", + " arg_constraints = {\"p\": constraints.unit_interval, \"rate\": constraints.nonnegative}\n", + " support = constraints.nonnegative_integer\n", + "\n", + " def __init__(self, p, rate, validate_args=None):\n", + " self.p, self.rate = broadcast_all(p, rate)\n", + " if isinstance(rate, Number):\n", + " batch_shape = torch.Size()\n", + " else:\n", + " batch_shape = self.rate.size()\n", + " super(ZeroInflatedPoisson, self).__init__(\n", + " batch_shape, validate_args=validate_args\n", + " )\n", + "\n", + " def sample(self, sample_shape=torch.Size()):\n", + " shape = self._extended_shape(sample_shape)\n", + " with torch.no_grad():\n", + " zero = torch.bernoulli(self.p.expand(shape))\n", + " poisson = torch.poisson(self.rate.expand(shape))\n", + " return zero * poisson\n", + "\n", + " def log_prob(self, value):\n", + " if self._validate_args:\n", + " self._validate_sample(value)\n", + " rate, p, value = broadcast_all(self.rate, self.p, value)\n", + " poisson_log_prob = value.xlogy(rate) - rate - (value + 1).lgamma()\n", + " poisson_log_prob[torch.where(value == 0.0)] = torch.log(\n", + " p + (1 - p) * torch.exp(-rate)\n", + " )[torch.where(value == 0.0)]\n", + " poisson_log_prob[value > 0.0] = (\n", + " torch.log(1 - p)[value > 0.0] + poisson_log_prob[value > 0.0]\n", + " )\n", + " return poisson_log_prob" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can sample from the distribution object and it looks good:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dist = ZeroInflatedPoisson(p=0.5, rate=10.0)\n", + "samples = dist.sample(sample_shape=(10000,))\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "ax.hist(\n", + " samples, bins=int(samples.max() - samples.min()), density=True, label=\"raw data\"\n", + ")\n", + "\n", + "# plot pdf\n", + "x = torch.arange(0, 20)\n", + "y = torch.exp(dist.log_prob(x))\n", + "\n", + "ax.plot(x.detach().numpy(), y.detach().numpy(), label=\"model pdf\")\n", + "fig.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can we fit the same model with the output as a `ZeroInflatedPoisson`?\n", + "\n", + "We can build the model class with the new distribution object as the output:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class DistZIPModel(ZIPModel):\n", + " def __init__(self, **kwargs):\n", + " super().__init__(**kwargs)\n", + "\n", + " def forward(self):\n", + " # ensure correct domain for params\n", + " mixture_prob_norm = torch.sigmoid(self.mixture_prob)\n", + " poisson_lambda_norm = torch.nn.functional.softplus(self.poisson_lambda)\n", + "\n", + " zip_dist = ZeroInflatedPoisson(p=mixture_prob_norm, rate=poisson_lambda_norm)\n", + " return zip_dist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly to before, we can then fit the model multiple times from random starting seeds." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:1789: UserWarning: MPS available but not used. Set `accelerator` and `devices` using `Trainer(accelerator='mps', devices=1)`.\n", + " rank_zero_warn(\n", + "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/trainer/configuration_validator.py:107: PossibleUserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + " rank_zero_warn(\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n", + "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:236: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", + " rank_zero_warn(\n", + "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:1892: PossibleUserWarning: The number of training batches (1) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n", + " rank_zero_warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2f75aeb222b94cbdab78dee8d6789180", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d17ead5b225e4a0c88d6f7b0e845159c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d798af0ee7f547faac29030d3397a256", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6882e4d50091428b9b7e677c5cbf8a33", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ad50ee6e37054b11b0c2a1d56410f6e9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b6910ac0d21f47bbb7cb5f9e47e7b07c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "01e7d1a92d2a4abc9297c24caec6e4d9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f6feedbe320f45e1b21e565dec839ef7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6600e6dc4f5e414686f0c67c78086900", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (mps), used: False\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params\n", + "------------------------------\n", + "------------------------------\n", + "2 Trainable params\n", + "0 Non-trainable params\n", + "2 Total params\n", + "0.000 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a565ffe920614df0b79e28adc5eb56bf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=100` reached.\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "seed_model_params = []\n", + "for _idx in range(10):\n", + " print(_idx)\n", + " init_params = [random.random(), random.random() * 10]\n", + " model = DistZIPModel(\n", + " learning_rate=1e-0,\n", + " init_mix_parameter=init_params[0],\n", + " init_poisson_lambda=init_params[1],\n", + " )\n", + "\n", + " # fit network\n", + " trainer = pl.Trainer(\n", + " max_epochs=100,\n", + " )\n", + " trainer.fit(model, dataloader_train)\n", + "\n", + " seed_model_params.append(\n", + " {\n", + " \"err\": model.train_log_error[-1],\n", + " \"mixture\": model.mixture_prob_log[-1][0],\n", + " \"lambda\": model.poisson_lambda_log[-1][0],\n", + " \"mixture_init\": init_params[0],\n", + " \"lambda_init\": init_params[1],\n", + " }\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We get similar results to last time, so the training is working:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
errmixturelambdamixture_initlambda_init
01.75495620.5091874.9969970.9036352.128501
11.754950.5102705.0023540.4655128.292895
21.75494430.5090345.0136550.5271305.674198
31.75494950.5107385.0042870.9605277.272479
41.75494850.5103415.0229510.5437477.638310
51.75496140.5092035.0323930.3782670.567890
61.75494520.5098375.0078500.2416341.943764
71.7549770.5081375.0377240.5975360.653239
81.75494650.5105585.0194300.8072176.436518
91.7549440.5092885.0110040.8718268.402232
\n", + "
" + ], + "text/plain": [ + " err mixture lambda mixture_init lambda_init\n", + "0 1.7549562 0.509187 4.996997 0.903635 2.128501\n", + "1 1.75495 0.510270 5.002354 0.465512 8.292895\n", + "2 1.7549443 0.509034 5.013655 0.527130 5.674198\n", + "3 1.7549495 0.510738 5.004287 0.960527 7.272479\n", + "4 1.7549485 0.510341 5.022951 0.543747 7.638310\n", + "5 1.7549614 0.509203 5.032393 0.378267 0.567890\n", + "6 1.7549452 0.509837 5.007850 0.241634 1.943764\n", + "7 1.754977 0.508137 5.037724 0.597536 0.653239\n", + "8 1.7549465 0.510558 5.019430 0.807217 6.436518\n", + "9 1.754944 0.509288 5.011004 0.871826 8.402232" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "pd.DataFrame(seed_model_params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So in summary, we can create a PyTorch distribution class by constructing the `log_prob` of the distribution product mass function. We can then fit that distribution to data via gradient descent without needing to know any particular fitting proceedure for that distribution." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit ('pytorch_env')", + "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.12.0" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "155ead7e3e7cc87f1c8ac5b93741665d5692c3c80ccfbc75b55ba980f115c04c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}