From c383d7f95b29067a885ba250cfac8104c38583ba Mon Sep 17 00:00:00 2001 From: Peter Steinbach Date: Mon, 25 Mar 2024 11:30:57 +0100 Subject: [PATCH] Review Tutorial 13 on SBC based diagnostic methods (#1051) * fix: import statement for sbc_rank_plot * fix: explanation of c2st in this tutorial * fix: torch UserWarning when calculating std on one value * add: demonstration of nD SBC mapped to 1D finished removed metadata from notebook * reformatted tutorial * fix: formatting of sbc module * fix: formatting issue * fix: trimmed down multi-dimensional SBC discussion * fix: copy and paste error denominating the wrong number of dimensions * fix: reworded hard-to-understand explanation of reduce_fns * fix: avoid confusion about single dimension Co-authored-by: Jan --------- Co-authored-by: Jan --- sbi/diagnostics/sbc.py | 3 +- ...nostics_simulation_based_calibration.ipynb | 844 ++++++++++++++---- 2 files changed, 670 insertions(+), 177 deletions(-) diff --git a/sbi/diagnostics/sbc.py b/sbi/diagnostics/sbc.py index 91bfa587c..740894fae 100644 --- a/sbi/diagnostics/sbc.py +++ b/sbi/diagnostics/sbc.py @@ -361,7 +361,8 @@ def check_uniformity_c2st( ]) # Use variance over repetitions to estimate robustness of c2st. - if (c2st_scores.std(0) > 0.05).any(): + c2st_std = c2st_scores.std(0, correction=0 if num_repetitions == 1 else 1) + if (c2st_std > 0.05).any(): warnings.warn( f"""C2ST score variability is larger than {0.05}: std={c2st_scores.std(0)}, result may be unreliable. Consider increasing the number of samples. diff --git a/tutorials/13_diagnostics_simulation_based_calibration.ipynb b/tutorials/13_diagnostics_simulation_based_calibration.ipynb index b893f1aac..528acdb5e 100644 --- a/tutorials/13_diagnostics_simulation_based_calibration.ipynb +++ b/tutorials/13_diagnostics_simulation_based_calibration.ipynb @@ -2,17 +2,19 @@ "cells": [ { "cell_type": "markdown", + "id": "0b29e299-a762-49ff-be34-94ec82652f0c", "metadata": {}, "source": [ "# Simulation-based Calibration in SBI\n", "\n", - "After a density estimator has been trained with simulated data to obtain a posterior, the estimator should be made subject to several diagnostic tests, before being used for inference given the actual observed data. _Posterior Predictive Checks_ (see [previous tutorial](https://sbi-dev.github.io/sbi/tutorial/12_diagnostics_posterior_predictive_check/)) provide one way to \"critique\" a trained estimator via its predictive performance. Another important approach to such diagnostics is simulation-based calibration as developed by [Cook et al, 2006](https://www.tandfonline.com/doi/abs/10.1198/106186006X136976) and [Talts et al, 2018](https://arxiv.org/abs/1804.06788).\n", + "After a density estimator has been trained with simulated data to obtain a posterior, the estimator should be made subject to several **diagnostic tests**. This needs to be performed before being used for inference given the actual observed data. _Posterior Predictive Checks_ (see [previous tutorial](https://sbi-dev.github.io/sbi/tutorial/12_diagnostics_posterior_predictive_check/)) provide one way to \"critique\" a trained estimator based on its predictive performance. Another important approach to such diagnostics is simulation-based calibration as developed by [Cook et al, 2006](https://www.tandfonline.com/doi/abs/10.1198/106186006X136976) and [Talts et al, 2018](https://arxiv.org/abs/1804.06788). This tutorial will demonstrate and teach you this technique with sbi.\n", "\n", - "**Simulation-based calibration** (SBC) provides a (qualitative) view and a quantitive measure to check, whether the uncertainties of the posterior are balanced, i.e., neither over-confident nor under-confident. As such, SBC can be viewed as a necessary condition (but not sufficient) for a valid inference algorithm: If SBC checks fail, this tells you that your inference is invalid. If SBC checks pass, this is no guarantee that the posterior estimation is working.\n" + "**Simulation-based calibration** (SBC) provides a (qualitative) view and a quantitive measure to check, whether the variances of the posterior are balanced, i.e., neither over-confident nor under-confident. As such, SBC can be viewed as a necessary condition (but not sufficient) for a valid inference algorithm: If SBC checks fail, this tells you that your inference is invalid. If SBC checks pass, this is no guarantee that the posterior estimation is working.\n" ] }, { "cell_type": "markdown", + "id": "7ce235c3-9c70-4d10-845f-70add68576b5", "metadata": {}, "source": [ "## In a nutshell\n", @@ -23,7 +25,7 @@ "2. we simulate \"observations\" from these parameters: `x_o_i = simulator(theta_o_i)`\n", "3. we perform inference given each observation `x_o_i`.\n", "\n", - "This produces a separate posterior $p_i(\\theta | x_{o,i})$ for each of `x_o_i`. The key step for SBC is to generate a set of posterior samples $\\{\\theta\\}_i$ from each posterior (let's call this `theta_i_s`, referring to `s` samples from posterior $p_i(\\theta | x_{o,i})$), and to rank the corresponding `theta_o_i` under this set of samples. A rank is computed by counting how many samples `theta_i_s` fall below their corresponding `theta_o_i` (see section 4.1 in Talts et al.). These ranks are then used to perform the SBC check.\n", + "This produces a separate posterior $p_i(\\theta | x_{o,i})$ for each of `x_o_i`. The key step for SBC is to generate a set of posterior samples $\\{\\theta\\}_i$ from each posterior. We call this `theta_i_s`, referring to `s` samples from posterior $p_i(\\theta | x_{o,i})$). Next, we rank the corresponding `theta_o_i` under this set of samples. A rank is computed by counting how many samples `theta_i_s` fall below their corresponding `theta_o_i` value (see section 4.1 in Talts et al.). These ranks are then used to perform the SBC check itself.\n", "\n", "### Key ideas behind SBC\n", "\n", @@ -36,49 +38,49 @@ "\n", "### What can SBC diagnose?\n", "\n", - "**SBC can inform us whether we are not wrong.** However, it cannot tell us whether we are right, i.e., SBC checks a necessary condition. For example, imagine you run SBC using the prior as a posterior. The ranks would be perfectly uniform. But the inference would be wrong.\n", + "**SBC can inform us whether we are not wrong.** However, it cannot tell us whether we are right, i.e., SBC checks a necessary condition. For example, imagine you run SBC using the prior as a posterior. The ranks would be perfectly uniform. But the inference would be wrong as this scenario would only occur if the posterior is uninformative.\n", "\n", - "**The Posterior Predictive Checks (see tutorial 12) can be seen as the complementary sufficient check** for the posterior (only as a methaphor, no theoretical guarantees here). Using the prior as a posterior and then doing predictive checks would clearly show that inference failed.\n", + "**The Posterior Predictive Checks (see [tutorial 12](https://sbi-dev.github.io/sbi/tutorial/12_diagnostics_posterior_predictive_check/)) can be seen as the complementary sufficient check** for the posterior (only as a methaphor, no theoretical guarantees here). Using the prior as a posterior and then doing predictive checks would clearly show that inference failed.\n", "\n", - "To summarize SBC can:\n", + "To summarize, SBC can:\n", "\n", "- tell us whether the SBI method applied to the problem at hand produces posteriors that have well-calibrated uncertainties,\n", - "- and if not, what kind of systematic bias it has: negative or positive bias (shift in the mean of the predictions) or over- or underdispersion (too large or too small variance)\n" + "- and if the posteriors have uncalibrated uncertainties, SBC surfaces what kind of systematic bias is present: negative or positive bias (shift in the mean of the predictions) or over- or underdispersion (too large or too small variance)\n" ] }, { "cell_type": "markdown", + "id": "53f22ccc-e2bc-4a70-a422-e0cac6944648", "metadata": {}, "source": [ "## A healthy posterior\n", "\n", "Let's take the gaussian linear simulator from the previous tutorials and run inference with NPE on it.\n", "\n", - "**Note:** SBC requires running inference several times. Using SBC with amortized methods like NPE is hence a justified endavour: repeated inference is cheap and SBC can be performed with little runtime penalty. This does not hold for sequential methods or anything relying on MCMC or VI (here, parallelization is your friend, `num_workers>1`).\n" + "**Note:** SBC requires running inference several times. Using SBC with amortized methods like NPE is hence a justified endavour: repeated inference is cheap and SBC can be performed with little runtime penalty. This does not hold for sequential methods or anything relying on MCMC or VI. Should you require methods of MCMC or VI, consider exploiting parallelization and set `num_workers>1` in the sbc functions.\n" ] }, { "cell_type": "code", - "execution_count": 2, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "b79cd0b8-8161-47b9-a008-510ea1b857ea", + "metadata": {}, "outputs": [], "source": [ "import torch\n", "from torch import eye, ones\n", "from torch.distributions import MultivariateNormal\n", "\n", - "from sbi.diagnostics import check_sbc, run_sbc, sbc_rank_plot\n", + "from sbi.analysis.plot import sbc_rank_plot\n", + "from sbi.diagnostics import check_sbc, run_sbc\n", "from sbi.inference import SNPE, simulate_for_sbi" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "ae48dbd9-084c-4753-8feb-731a7f99075d", + "metadata": {}, "outputs": [], "source": [ "num_dim = 2\n", @@ -93,6 +95,7 @@ }, { "cell_type": "markdown", + "id": "4efea93e-d93b-47ab-a1ef-487ee06ec2e0", "metadata": {}, "source": [ "## An ideal case\n", @@ -102,15 +105,14 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "a8907ec4-8439-41aa-af69-c96c295748ea", + "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d331e41bad914672aff58cdbe77b9fba", + "model_id": "10491c1b8b0740219c669de52237e413", "version_major": 2, "version_minor": 0 }, @@ -148,10 +150,9 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "73b47ac1-2588-44dd-ba45-9616dee3caab", + "metadata": {}, "outputs": [ { "name": "stdout", @@ -165,7 +166,8 @@ "source": [ "_ = torch.manual_seed(1)\n", "\n", - "# let's obtain an observation\n", + "# let's sample an observation from the parameters we\n", + "# just produced\n", "theta_o = prior.sample((1,))\n", "x_o = simulator(theta_o)\n", "print(\"theta:\", theta_o.numpy())\n", @@ -174,23 +176,472 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "3254e3d4-e5f1-4e1f-bb1c-fa9e9b3adcaf", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " Neural network successfully converged after 91 epochs." + "\r", + " Training neural network. Epochs trained: 1" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 2" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 3" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 4" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 5" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 6" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 7" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 8" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 9" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 10" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 11" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 12" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 13" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 14" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 15" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 16" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 17" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 18" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 19" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 20" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 21" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 22" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 23" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 24" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 25" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 26" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 27" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 28" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 29" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 30" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 31" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 32" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 33" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 34" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 35" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 36" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 37" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 38" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 39" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 40" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 41" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 42" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 43" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 44" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 45" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 46" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 47" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 48" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 49" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 50" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 51" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 52" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 53" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 54" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 55" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 56" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Training neural network. Epochs trained: 57\r", + " Neural network successfully converged after 57 epochs." ] } ], "source": [ "_ = torch.manual_seed(2)\n", "\n", - "# we use a mdn model to have a fast turnaround with training.\n", + "# we use a mdn model to have a fast turnaround with training the NPE\n", "inferer = SNPE(prior, density_estimator=\"mdn\")\n", "# append simulations and run training.\n", "inferer.append_simulations(theta, x).train();" @@ -198,15 +649,14 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "0d6cf039-1dd8-44f8-bfed-3a3e027a84b4", + "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f59ae5f08277406eb85aeaa25653c191", + "model_id": "2dfa0f8dfa4e4ff2be08efe5a06e4c46", "version_major": 2, "version_minor": 0 }, @@ -227,14 +677,13 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "f5e79734-08e8-4818-8402-798d5d01cbef", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAHRCAYAAACmZ/R8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAzh0lEQVR4nO3deXCc933f8c+zJ67FDZAESJAEL5G6aEoUJSumLOuoFY8jObGVuG5jO2maaWlnXLeTejh1lHZGcds47WRUJzOJJctpbTVWUtmObCuSHVMyrTCSTEsmKR7iTYIAiYMAFgtgz6d/LJ49HpG49tl9ngXerxnOANjrC0rcz/5+39/v9ximaZoCAMBBPrcLAAAsPYQLAMBxhAsAwHGECwDAcYQLAMBxhAsAwHGECwDAcYQLAMBxAbcLAJabB3wfc7sEoCQvZZ6d8z6MXAAAjiNcAACOI1wAAI4jXAAAjiNcAACOI1wAAI5jKbLbTFNKTma/DtZJhuFuPQDgAEYubktOSn/Ulf1jhQwAVDnCBQDgOMIFAOA4wgUA4DjCBQDgOMIFAOA4wsVDMhlTmYzpdhkAUDLCxUNuf/yH+s2nXiNgAFQ9wsVFJy5H9dtPv577fiqZ1v6TQ/rB4QEXqwKA0hEuLjFNU3u+cVCvnh7O/ewj7+mWJH35xeNKpjNulQYAJSNcXHKob0zvXJlQOJD/T7D3l7eqrT6kM0MxPfvGRRerA4DSEC4u+X8H+yRJ929dkftZQzigz3xgoyTpT390QlOJtCu1AUCpCBcXJNMZ/d1blyRJH97eVXTbP9/Vo9Uttbo8HtfTr551oToAKB3h4oJXTgxqOJZQe0NYd/e2Fd0WDvj1+Qc2S5L+fN9JjU0m3SgRAEpCuLjAmhJ7eHuXAv53/yd4eHu3tqyIaHw6pW+9caHS5QFAyQiXChubSuqlo5clSb+6o/ua9/H7DP3KzHTZ0f7xitUGAE4hXCrs+4f6lUhltGVFRNtWNV73fr3t9ZKkU0OxSpUGAI4hXCrsuZkpsV/d0S1jlqtO9nY0SJLODE7INNmxD6C6EC4VdGFkUq+dHZFhZPsqs1nbVifDkManUxqOJSpUIQA4g3CpoH0nBiVJd65v08qmmlnvWxP0q7u5VpJ0epCpMQDVhXCpoLcvZZvzO9Y2z+v+1tTY6cGJcpUEAGVBuFTQ2zMrv7bO0sgvZDX1T9PUB1BlCJcKSWdMHR9YWLhs6JgJF0YuAKoM4VIhZ4Zimk5mVBv0a11b/bwes759ZlqMkQuAKkO4VIi1GXLLyoj8vusvQS7UOzNyOT88yRH8AKoK4VIhVrhs65rflJgkrWysUW3Qr1TG1IWRyXKVBgCOI1wqZKHNfEny+Qytt5r6LEcGUEUIlwrJjVxWRRb0OGtq7PQQTX0A1YNwqYDhibguj8dlGNKWlfMfuUgFy5EZuQCoIoRLBRztj0qS1rbWqSEcWNBjcxspWTEGoIoQLhXwdv+YpIU18y25aTFGLgCqCOFSAdbIZesCp8Qk5Rr6QxNxjU9zVUoA1YFwqYCji1gpZonUBNUZCUti9AKgehAuZRZPpXXySnal12KmxSQVLEdmxRiA6kC4lNk7lyeUyphqqg1q1RzH7F9P/nRkRi4AqgPhUmZv5/a3NM565cnZbGCvC4AqQ7iUWSn9FgsrxgBUG8KlzPLhsrCd+YV6Z05HPjscUyZjOlIXAJQT4VJGpmnmlyGXMHJZ3VKroN/QdDKjS2NTTpUHAGVDuJTR0ERCY1NJGYa0sbNh0c8T8Pu0pqVOUvb4faCqGcb1//j8+T+z3c/+Z77Pv9jnxIIRLmVkLR1e3VKrmqC/pOfqacuGyzmO3gdQBQiXMjo104C3eialsK5eeXaYpj4A71vYKYpYEGvkYq32KkVPK9NiWIIMn+3bwumo+Y/2zYKFLob9Sq/GLJ+hzYzt28IFM7arv5osplkIRi5lZJ1kvKHDgZFLezZczhIuAKoA4VJGzo5css9xfjgmk09QADyOcCmTeCqt8zPNdydGLmtaa2UYUiyR1tBEouTnA4ByoudSJueHJ5UxpYZwIHeqcSnCAb+6mmrVNzqlc8MxdTjwnEBFvGupsK/gy1lu89s++/qu/1l4QQuHM/leimkWP9JQOn9bWigBI5cyya0U66hf9Jlidmut5cj0XQB4HOFSJqesfkt76f0Wy9qZ5cjnWI4MwOMIlzKxDpl0ot9iWctGSgBVgp5LmVjH4/c6GC7r2liOjCpRMBVs+G37VWbZd2IE829JRihYfGOg4O3K/pyF0rZmSTpz/dvtKy+T17+UuGl/3qIbWcFpx8ilDEzT1Kkrzi1DtljTYueZFgPgcYRLGQzHEhqfTskw8pcodoK1S//qZFJjk9f/hAUAbmNarAysfkt3c+kHVhaqDwfUEQlrMBrXuZGYbqlrduy5gZLMstz4XUe8FCwxNkKh4seFwwW32abFCqbMzIDt31XhMmX7bclU8etPF+wTm44X37dw+XPS9jypguexTZGZs021LVOMXMogvzPfuX6LZW0ry5EBeB/hUgblWIZsYTkygGpAuJRBbhlyCRcIu551bKQEUAXouZRB7jTkMoxceggXeNBsy40LlxdLxb0Uo7a26DazMf+BLFNT3HMxC/qXZqD4c3Gm4LZMsPg2/3Rxz8U/nu+z+OxHzMQLfo+AbdHM1HT+9WVTeFQ/58ZIYuTiuEQqkzuwshw9F+uiYedGmBYD4F2Ei8POj8SUzpiqD/m1otH5wyWtXfqXx+OaTKTmuDcAuINpMYflD6xscOzAykLNdSE11QY1NpXU+ZFJ3bCy0fHXAOZllv+/i5YbB2xvM4VTaOHipciZxvw0WaKp+LZUQ/5xqZriz8WpmuvXEowVv34okp9uC40Vv4Z/PD/1ZYzbZgcS+WkyM2Vb3lxwurP9pOXlujSZkYvDTjl4gbDr4XRkAF5HuDjMWinW2+58v8XCcmQAXke4OOzkzJliG8uwDNnCcmQAXkfPxUGFB1aWM1x62KUPLyjsJdhPOi7sq9iOcTHq63JfZ5qL/53E22pyX8dWFL89TXXmexmJxuI+RqbgJfy2q4AHo8XLpMOj+VrrBovrrinonQTspykXnJhs2HouhdXYuz/L9WgYRi4OGozGFY2n5DOkde11cz9gkda1sxwZgLcRLg6ypsR6WusUth+e5yDrfLG+q1NKpDJz3BsAKo9wcdDJwfJPiUlSRySs2qBfGVPqG50q62sBwGLQc3GQ1W8px5lihQzD0Nq2Oh0biOrccMzRa8YA8zbbPpfCK0o2FP//mW7P782Ktxcf/zKxKv+4WFfx80+tzvc5atqLP1TVhfL9kMnp4r0rE8M1Rd+nLhfUli6eYfAlQwVfF88K+OMFzRxbz6VoD0zC1vQpPBpGtpmGJdyDYeTiIGvksqEMx77Y0dQH4GWEi4NOXck22Ms9LSYVNPUJFwAexLSYQ6LTSQ3MHB1R2ZELK8ZQIbNcbdJ+1cjC047N+uKpr2TBmXvxpuJpqcmV+deYWl88vbSy+2ru6w1Nw0W3raoZyz8uXTwt9mZTd9H3fYG23Ne+hK3uTP4t0Rcvfp6ayfzvYdiublk09ZW0naZceDTMMjowmZGLQ6wzxToiYTXVBue4d+nypyMzcgHgPYSLQ3KbJyswapHy54udH5lUJrN0m4IAqhPh4pBcM7+zMiu3VjXVKOAzlEhlctNxAOAV9FwccrLCI5eA36c1rXU6MxTTueFJdTXXzv0gYCFm6bFIxVeffNeVKAuO0s/YpolTdfn7JhqLXyPenl+q29IZLbptZ8f53NfvjZwsuu3WcF/u6wuppqLb6gPxou9fKuizjE22FN3mj+d/x/C47aj+guP5/bZj/FV4WQHfLJ/Z7cfkLOEmDCMXh5zKbaCMVOw1aeoD8CrCxQGJVCa3JLhS02JSwenINPUBeAzTYg4ovLTxysaauR/gkB6u64Jysu8en+XCqkUn/8q2VNf2PGbBDFo6VPykmWB+Wqxw170krakZyX1dOA0mSVtDddJoSsbxaXWPXlYi4tPVTUElmnzaXDNQdN93mjtyX7/ZYjs94PIs/34Lfw/7300m//vb/y7M2Rbc2Kcel9COfcLFAScLjn0px6WNr4frugAzjk3JeDnbo7E6Lh2HErr4SzXSavfKWs6YFnNApZv5ltxy5OFJmUvoEw+wEKGxjIyXozJMFf2RKa3eP63GaHzO54DzCBcHWBsoy31gpd3qljoZhhSNpzQSS8z9AGAJan4nec2fW3MIW06NXPN2lBfTYg7ITYtVeORSE/RrVWONLo1N69zIpNoawnM/CFgs03air6/gdGH7UuSCvoNhu+aQL5UfZRvp4hG3kbr+tLK/4HqPyYLPxYHo7KP2hlk+eJlp2/Lq2Z6qcMp7tuXG9ocVHv+yjDY8M3IpUSZjFixDrmy4SFJPG8uRsbwlIrO/jU3Uh2a9HeVBuJRoYHxak4m0Aj4j1wOppNwZYzT1sUwNb8puirSPCazvj29orWg9yCJcSmSNWta21Snor/xfZw8rxrDMJZr8iu4OSYZkFvyRIZ27u1bjEaaL3UDPpUSnZ5r5vRXut1jWsdcFXuCb5aqUSdsemIKei892cr0vmX+esaniPSeHJvJH59f5ileAne25qvpfSWrtyQkFJqRofVAnNrQoGgnr1FRn0X1HpvN7W4yJ4l6Rv+CYvkzAvgcn/+HRb99yUNhLsfVViva9LKNVnYRLiayRS2+HO5cato6AOc8ufSxzscag3t7RopG0Ox/0UIxpsRJZI5dKrxSzWH2eoYmEJuKpOe4NAJXByKVEp62j9l0auURqgmqrD2k4ltC54Zhu7Gqa+0HAYtindNKFR57YlimnCj7o2K7aGJzIfx8eK56WCo3mv5+4XPyB7dXE+tzX/R2NRbd1143pevomi/9NXBrJPzYYLf58HSxY1uyPF/9ORUuq7Ue8FP6+9iXbyxQjlxJMJlK6NJadpO1td28obo1ezgzRdwHgDYRLCawpsdb6kFpcXEtvTcmdukK4APAGwqUEp2dGCr3t7kyJWazNm9bVMAHAbfRcSnDKpWNf7HLhcoVwgYPmOOG78CgTI2k736tgz5cxVbxsODA6lfu6NlT8+bZwt30mWPz2lJjKb1I+MVV8dctTofwx+j5/cc8jGS9+Hv9Aft9LfX/x7xiO5h8bnCjuq/gLj5GJz3KWn/1qk4VnyizhK0/aMXIpQW7k4lIz32KF2+nBCaWX0dlFALyLcCmBV0Yua1rrFAr4FE9ldKngUyEAuIVpsUXKZMzc6iy3Ry5+n6He9nodG4jq5JUJrWmt/BlnWN7edT2hwqXJ9imkRH4KLTBRPJ1WN5h/S8oEi5cp+5L5z8KpmG0BTcHslmGbeaqJ26a+rha+XvGdawfz9QRHp4tuM2L5D26mfRowU/D7zrYUeQlfedKOkcsiDYxPayqZPbDSC2/mG+i7APAQwmWR3D6w0i63HJkVYwA8wP13xSrl9oGVdqwYA+Al9FwW6dSgN5r5lo0d+b0upmnKmGMZKTAnez9gtv+nbMehqLAnYRvZG5P5XobP9pzhgpOHjXRxXyVccDRMsq74cWbBO5nP1uIJTGeu+31orPhomtBgfiOyMRotfo3Jgp7LVPHCmcLjb5bT1SZnw8hlkfIjF3eb+ZbejnoZhjQ6mdTILJd1BYBKIFwWye0DK+1qgn6tbqmVxNQYAPcRLovglQMr7QqnxgDATfRcFsErB1babeho0I+PD3KAJcrjXXsyCvsMts+phftcErY9IUa+X2HYejWFb0j+ieIjXmpC+VuTjcWXLk6HC64SaTsq3z9d3FfxJfKv6Zsqrs0Yz//bKeyxSMV9lqIj9kWf5VoYuSyCdeyLV6bELBxgCcArCJdFsI598dKUmJQPl1P0XAC4jGmxRfDKgZV21rLovtEpxeIp1Yf5z4syKpomsx15YuaXCpu2K1GaBVNhRqJ4ZWPh0mQjXjwtpoKpJ99Y8XS0Gc5/b9in71LFU29G4TSdbcrOnM4vkzbjxac5z7rceL5Xn1zCx73YMXJZhOMD45KkTSu8NXJpqQ+pbaYHxFUpAbiJcFmgyUQqt9T3Jg9er54zxgB4AeGyQEf7x5Uxpc5IWJ2NNW6X8y4cAwPAC5iUX6DDfdkpsZu6vTdqkTjAEt5j2o+GSRX0J2y3ZcbzXxuhWZb5T04WfWsE8m9lhs/2mdnW5zALLgFgX1JcWM9svSJlls8VJReLkcsCHeobk+TdcLFGLu8wcgHgIsJlgQ5b4dLV6HIl13bjTF2nBic0Npmc494AUB5Miy3AdDKdGxHcvNqbI5f2hrB62+t1eiimn50f0QduWOF2SVgO7FNPhVNIsyy/fdeUWcHyX/uUVdFJ3/apr4LbTPttmeJlwkXPO8uS4kUvN4YkRi4LcrR/XOmMqfaGkFZ6sJlvuX1diyTp9bNX57gnAJQH4bIA1pTYjV1Nnr5eys51rZKk18+MuFwJgOWKcFkAa6XYzR5t5luscPnFxTFNJ1nVAqDy6LksQH6lmDeb+Za1bXXqiIQ1GI3rFxfHdMf6VrdLwnIz32NOZuvV2Psxfr/mxZj9M3NxP2iWPsoyOqqlHBi5zFM8ldaJy9nLnnp1GbLFMAztzPVdmBoDUHmEyzwdH4gqlTHVUhdUd3Ot2+XMKdd3IVwAuIBwmafCzZNebuZbrHD52dmrSnMhIwAVRs9lnrx+7IvdDSsjaggHFI2ndHwgqm0e3fQJFJnvnphZ+ypzLGKhz1IRjFzmKb8zvzrCJeD36T09zZKYGgNQeYTLPCRSGR0fyDbzvb4MudAd9F0AuIRpsXk4cTmqRDqjxpqA1rR6v5lvub0gXEzTrIpeEZAz2/+vpRzFwtRXRTBymYfXZna637K6uareoLevaVbQb+jyeFwXr065XQ6AZYRwmYeX3r4sSXr/lg6XK1mY2pA/twDhnzgKBkAFES5zGJ1M6LWZnsUD26rvhOG7etskSfuOX3G5EgDLCeEyhx8fv6J0xtTmFQ1a21bvdjkLdv9MIL58fFCJFEeGo4qYZnn+oCIIlzlYU2LVOGqRpO2rm9URCSsaT+nA6WG3ywGwTBAus4in0nr5+KAk6YFtK12uZnF8PkP3b80G44tvD7hcDYDlgnCZxT+eGlYskVZnJKxbqmh/i92DM6OuH759RRmOggFQAYTLLKwpsfu3rZDPVz1LkO3u2tCm+pBfA+PTuTPSAKCcCJfryGRM/fDoTL9la3X2Wyw1Qb/umVlGbQUmAJQT4XIdh/rGdHk8rrqQX3dtaHO7nJJZCxLouwCoBMLlOqxP+Pds7lBNcJ5XwPOwD2xZIb/P0InLEzo3HHO7HABLHOFyDaZp5j7hV+sSZLumuqB2zVzumKkxAOVGuFzDWxfHdOLyhEIBnz5wQ6fb5TjGWjX24hHCBUB5ES7X8I0D5yRJH7p5lZrrQi5X45wHbszu1Xnj3Ij6RjnIEkD5EC42Y5NJ/d0vLkmS/sWdPS5X46zu5lq9d0ObMqb09E/PuF0OgCWMcLH524MXNZ3M6IaVEe3oaXG7HMf9zu5eSdIzr13Q+HTS5WoALFWESwHTNPWNf8pOiX3izrVVde2W+Xr/5g5t6mzQRDyl//vaebfLAbBEES4FDpwe0anBmOpCfj2yvcvtcsrCMAz9zvuyo5en9p/lpGQAZUG4FPg/M6OWR97TrUhN0OVqyufh93SpvSGsgfFpfe/QJbfLAbAEES4zBqNx/f3h7N6WT+xaWo18u3DAr0/fvU6S9BevnJHJNS4AOIxwmfHVn5xWKmPqPT3NurGrek9Anq9P7OpRbdCvo/3j+ulJrvMCwFmEi7JH6//FT05Lkv7t+ze6XE1lNNeF9OjtqyVJf/Cdw7oaS7hcEYClZNmHy+hkQp//1psyTenXb1+zZI57mY/PfGCTuptrdXoopt/5qzc0nUy7XRKAJWJZh4tpmtr73CH1j01rfXu9/uDD29wuqaI6ImF97dM7FakJ6I1zV/X5b73JxcQAOGJZh8uzb1zU9w8NKOAz9Ke/sV314YDbJVXc5hUR/cW/vF1Bv6HvHxrQ498/SoMfQMmWbbg89/OL+oPvHpYk/fsHt+iW1c3uFuSiuza06csfu1WS9OT+M3rkz17VP52myQ9g8ZZduEwn09r73CH9u79+S9PJjO7fukK/O3MkynL28PZuPf6Rm1QX8uutC6P69b84oH/19dd1tH/c7dIAVKFlMQ9kmqYuj8d1tH9c/+OlEzrUNybDkH7vA5v0e/dtks+39I55WYxP7FqrB7et1J/+6ISeee2Cfnj0in549Ip2b+7Qv35fr+7e2LYkj8QB4DzDXAIT7Ml0RueGYzp5ZUInr0zo0ti0JqZTmoinND6V1KnBCV2dzB/S2FIX1P/89e16/xYPXKslEZP+aOaomb2XpFC9u/XMODU4of/x0gn94FC/rB7/lhURvXdjm27ubtJN3U1a316voH/ZDX5L9oDvY26XAJTkpcyzc95n3iOX33769ZKKmQ9T2VFGxsx/nUqbSmdMZUxTfp+R+zOdTGskltDoZFKjU0ml51jl5DOk3o4G3bq6WZ9/cLO6m2vL/vtUsw0dDfrKP9+h88OTeuqnZ/TXr1/Q8ctRHb8cLbpfU21QbfUhtdSH5DcMmcr+9zMk+X2GAn5Dfp9PPiP7Myl7vlmlxz9PfmpnhV8RWN7mHS4/OnalnHWUrC7k16bOBm3obNCaljpFagKK1ARUHw5obWu9Nq1oUE3Q73aZVaenrU5/+Cs36nP3b9KPjl7R4UtjOtI3riOXxhRLpDU2ldTYVFIairldKgAPmXe4/Pdfu6WcdeTNfMI1DEN+n+T3+RTwGfIZUjojpU1TqXRGNUG/WupCaqkPqrUupI5ImH5AGTXXhfRrt63Wr92W3dWfyZganUpqJBbX0ERCo5OJ3IjFMCTTzP63SmdMJdOmTNNUbmxZ9ROxAOYy73B5dOeactaBKuPzGWqtD6m1PqSNHmhdAfAWurEAAMcRLgAAxxEuAADHES4AAMcRLgAAxxEuAADHLYuzxTwtWJc99sX6GgCWAMLFbYbhmfPEAMApTIsBABxHuAAAHEe4AAAcR7gAABxHuAAAHLckrkQJAPAWRi4AAMcRLgAAxxEuAADHES4AAMcRLgAAx83rbDHTNBWNRstdC1BWkUhEhmG4XQawLMwrXKLRqJqamspdC1BWY2NjamxsdLsMYFmY1z6Xa41cxsfHtWbNGl24cIF/sGXA36/zGLkAlTOvkYthGNd9g2tsbOTNr4z4+wVQjWjoAwAcR7gAABy36HAJh8N67LHHFA6HnawHM/j7BVDNOLgSAOA4psUAAI4jXAAAjiNcAACOI1wAAI5bcLi88sor+vCHP6yuri4ZhqFvf/vbZShr+frSl76knTt3KhKJqLOzU4888oiOHz/udlkAsCALDpdYLKZbb71VX/nKV8pRz7L38ssva8+ePTpw4IBeeuklJZNJPfjgg4rFYm6XBgDzVtJSZMMw9Nxzz+mRRx5xsCQUGhwcVGdnp15++WXt3r3b7XIAYF7ouXjc2NiYJKm1tdXlSgBg/ggXD8tkMvrc5z6nu+++WzfddJPb5QDAvM3rVGS4Y8+ePTp8+LD279/vdikAsCCEi0d95jOf0fPPP69XXnlFq1evdrscAFgQwsVjTNPUZz/7WT333HPat2+f1q9f73ZJALBgCw6XiYkJnTx5Mvf9mTNn9Oabb6q1tVU9PT2OFrcc7dmzR9/85jf1ne98R5FIRAMDA5KkpqYm1dbWulwdAMzPgpci79u3T/fee++7fv7JT35STz/9tFN1LVvXuwzv1772NX3qU5+qbDEAsEgcuQ8AcBxLkQEAjiNcAACOI1wAAI4jXAAAjiNcAACOI1wAAI4jXAAAjiNcAACOI1wAAI4jXCrsmWeeUW1trfr7+3M/+/SnP61bbrkld2EwAKh2HP9SYaZpavv27dq9e7eeeOIJPfbYY3rqqad04MABdXd3u10eADiCkUuFGYahxx9/XH/5l3+pxx9/XE888YReeOGFXLA8//zz2rJlizZt2qSvfvWrLlcLAIvDyMUlO3bs0JEjR/Tiiy/qnnvukSSlUilt27ZNP/7xj9XU1KTbbrtNr776qtra2lyuFgAWhpGLC1544QUdO3ZM6XRaK1asyP38tdde04033qju7m41NDTooYce0osvvuhipUAVMU0pEcv+4TOz6wiXCjt48KAeffRRPfnkk7rvvvv0xS9+MXfbpUuXivou3d3d6uvrc6NMoPokJ6U/6sr+SU66Xc2yx2WOK+js2bP60Ic+pL179+rjH/+4ent7ddddd+ngwYPasWOH2+UBgGMYuVTIyMiIPvjBD+rhhx/WF77wBUnSrl279NBDD2nv3r2SpK6urqKRSl9fn7q6ulypFwBKQUPfQ1KplLZu3ap9+/bR0AcWKhHLTolJ0t5LUqje3XqWOabFPCQQCOhP/uRPdO+99yqTyej3f//3CRYAVYmRC4ClgZGLp9BzAQA4jnABUPWi00l9+e+Pu10GChAuAKren+87pSd/esbtMlCAcAFQ1ZLpjL71xsWin9FKdh/hAqCq/ejoZQ1NxNVYk1/8+r1D/bM8ApVAuACoat987YIk6Td29uR+9l+ef1uXRqfcKgkiXABUsQsjk/rJO4OSpI/etib38+h0Sv/h2beUyTA95hbCBUDV+uvXL8g0pfdtatea1trcz2uDfr16alj7Tw65WN3yRrgAqErZRn52Suzjd/QU3fbLN6+SJL1yYrDidSGLcAFQlX509IquRONqbwjp/q0rim5774bssUmMXNxDuACoSs+8dl5SttcSChS/ld3Zmw2XYwNRXYlOV7w2EC4AqlB0Oplr5P/GzjXvur21PqQbuxolSa+eHK5obcgiXABUnUN9Y8qYUndzrda1X/uAyl/a1C6JqTG3EC4Aqs6bF0YlSdvXNF/3Pr+0cSZc3hlix74LCBcAVeetmXC5dU3Tde+zc12rQgGfBsandWpwokKVwUK4AKg6b10YkyRtX9Ny3fvUBP26Y12rpOzoBZVFuACoKgNj0xoYn5bPkG7qbpz1vndvpO/iFsIFQFWx+i2bV0RUF5r9Su3vm2nqHzg9omQ6U+7SUIBwAVBV3ro4Kmn2Zr5l26pGtdQFNRFP5fo0qAzCBUBVyTfzm+e8r89n6L0zU2M/oe9SUYQLgKqRyZj6xUWrmd88r8e8byZcfkrfpaIIFwBV49TghCbiKdUG/drU2TCvx+xcn10xdvjSmNIcwV8xhAuAqmE182/ublLAP7+3r3Vt9QoFfJpOZnRhZLKM1aEQ4QKgaljN/Nk2T9r5fUZulHP8crQcZeEaCBcAVcPaPDmfZn6hLSsikqQTA4RLpRAuAKrCdDKto/3jkubfzLdsWZkNl2OMXCqGcAFQFY5cGlcqY6q9IaTu5tq5H1Bg80pGLpVGuACoCrn9LaubZRjGgh5rTYudGYopnko7XRqugXABUBUO9WX7Lbesbl7wY1c11SgSDiiVMXVmKOZwZbgWwgVAVbD6Ldu6Zj+s8loMw8hNjR1naqwiCBcAnpdIZXLXZNm6KrKo59hCuFQU4QLA804NTiiZNhUJBxbczLfkliOzYqwiCBcAnndsIDsldsOqyIKb+ZbNM+HCRsrKIFwAeN7R/mwgbF218H6LZfOK7C79CyNTisVTjtSF6yNcAHie1cy/YeXiw6WtIaz2hrAkpsYqgXAB4HnHBqyRy+Ka+ZYbVtJ3qRTCBYCnDU3ENRiNyzDyfZPFyvVdBiacKA2zIFwAeNqxmX7L2tY61YcDJT3XlpXZvgsjl/IjXAB4mtVvKaWZb2HFWOUQLgA87ehA6c18y6aZcBmMxjUSS5T8fLg+wgWAp1nTYjeU2MyXpIZwQGtas5sw2alfXoQLAM9KpjM6eSXbfN/mwLSYxE79SiFcAHjW6cGYEumMGko49sWutyPb1D83POnI8+HaCBcAnmUd+7JlZUQ+3+KOfbFb01onSTo/QriUE+ECwLPezq0UK73fYumZCZcLhEtZES4APCvXzHdgpZilp2DkYpqmY8+LYoQLAM+ypsWc2ONi6WqukWFIU8m0hiZYjlwuhAsATxqJJXR5PC4pf6EvJ4QDfq1qrJFE36WcCBcAnvTOzFLh1S21aijx2Be7NfRdyo5wAeBJZ4djkqT17fWOP3cPK8bKjnAB4ElnZ/ahEC7ViXAB4Elnh7Ijl7VtZQiXNsKl3AgXAJ50ZsiaFqtz/LnpuZQf4QLAc0zTzB3Psq4cI5eZcBkYn9Z0Mu3484NwAeBBV6JxTSXT8hnS6hbnRy5t9SHVhfwyTalvdMrx5wfhAsCDrCmx1S11CgWcf5syDIOmfpkRLgA859zMMuR1ZVgpZqHvUl6ECwDPOTNk9VucnxKz5EYuHL1fFoQLAM+xliGXo5lvyZ2OfJVwKQfCBYDnlHN3viXfc6GhXw6ECwBPKVyGvLaM02KFPReO3nce4QLAUy6PZ5ch+31GLgDKYXVL9rLJE/GUrk4my/Y6yxXhAsBTrCmx1S21CvrL9xZVE/RrJUfvlw3hAsBTynmmmB17XcqHcAHgKWesZn4Z+y0W9rqUD+ECwFPOWXtcyrhSzMJel/IhXAB4itVzKeceF0tPW7apz7SY8wgXAJ6RyZj5cKnkyIVwcRzhAsAzrkTjmk5m5PcZuaXC5WT1XPrHppRIZcr+essJ4QLAM/KnIZd3GbKloyGs+pBfGVM6PxIr++stJ4QLAM+oZL9Fyh69v6GzQZJ08spERV5zuSBcAHhGJc4Us9vYQbiUA+ECwDPyGyjLv8fFYo1cTg0yLeYkwgWAZ1gHVlZqWkySNjByKQvCBYAnmKapvqvZ4+/XtJZ/pZhlY27kMqFMhtORnUK4APCE8amUovGUJKm7uXLTYmvb6hTwGZpMpNU/Pl2x113qCBcAnmBdEbK9IaTakL9irxv0+3IbNk8xNeYYwgWAJ/SNZqfEupsrNyVmYcWY8wgXAJ5wcabfsrqlclNilg2d2ZHLyUHCxSmECwBPuDgzLVaJY1/sNrKR0nGECwBPyI9c3JgWi0iSTjNycQzhAsAT3JwW6+3ITosNTSQ0Opmo+OsvRYQLAE9wc1qsPhxQV1ONJKbGnEK4AHDd2FRS0emZPS4uhIskDrB0GOECwHXWzvzW+pDqQgFXaijcqY/SES4AXOfmlJiFFWPOIlwAuM7NlWKW3EZKRi6OIFwAuM7NlWIWq+dy8eqUppNp1+pYKggXAK7zwrRYW31IzXVBmaZ0mmu7lIxwAeA661wxN8PFMAymxhxEuABwnRemxSSa+k4iXAC4anw6qbGppCR3TkQulA+XqKt1LAWECwBXWXtcWuqCqg+7s8fFcsPKRknS0X7CpVSECwBXeWVKTJK2rsoeYHl2OKaJmatiYnEIFwCu8sJKMUtbQ1grG2tkmtLxgXG3y6lqhAsAV/V5YANloW1d2amxty8RLqUgXAC4ykvTYlJ+auztfsKlFIQLAFddHPXOtJgkbVvVJEl6m6Z+SQgXAK6yRi5uHbVvZ02LHesfVyqdcbma6kW4AHBNdDqp0Ulv7HGxrG2tU13Ir3gqo7PDHAOzWIQLANdYx7401wUVqQm6XE2Wz2do66rs6OUITf1FI1wAuMZrK8UsNPVLR7gAcM3RmTfvdW31LldSzGrqs1N/8QgXAK45cHpEkrRrfavLlRRjr0vpCBcAroin0nrjXDZc7uxtc7maYltWROQzpKGJuK5Ep90upyoRLgBc8YuLY5pOZtRWH8qdRuwVtSG/1rdnp+oYvSwO4QLAFQdODUvKjloMw3C5mnfb1mVtpiRcFoNwAeCKA2dmwmWDt6bELNtWcfx+KQgXABUXT6X1xtmrkqS7er3VzLfkm/pjLldSnQgXABX31oUxxVMZtTeEtKHDW/0WizVyOT0U02SCa7ssFOECoOIOnM5Oie3yaL9FkjoiYbU3hGWaTI0tBuECoOKscLnLY0uQ7bavyTb1f37+qsuVVB/CBUBFxVNp/exc9s3aa/tb7HasbZGkXL2YP8IFQEW9eX50pt8S1oYObx37Ynf72uxigzfOXZVpmi5XU10IFwAVZR35cmdvq2f7LZZbVjcp6Dc0GI3nrjuD+SFcAFRUrt/i0f0thWqCft04s5mSqbGFIVwAVMx0Mq2fzTTHd633frhI0m0zfRfrHDTMD+ECoGJ+du6qEqmMVjR6v99iuT3X1B91t5AqQ7gAqJj9J4ckSXdvbPd8v8VijVyOD4wrOp10uZrqQbgAqJifzoTLL21sd7mS+etsrNGa1lplTOnNC6Nul1M1CBcAFTE2mdShvuw5XXdXUbhI0m097HdZKMIFQEX84+khmaa0qbNBKxpr3C5nQW5bl93vQrjMH+ECoCIK+y3Vxhq5/Pz8qNIZNlPOB+ECoCJ+ejK7v6Uaw2XLyogawgFNxFM6PsAhlvNBuAAou4tXJ3VmKCa/z9Auj16/ZTZ+n6H39DRLUm6fDmZHuAAou1dnRi23rm5SY03Q5WoWZ4fV1D/LZsr5IFwAlN3+KlyCbLdzpqn/6qlhZei7zIlwAVBWpmnq1VPZcHlvNYfL+hZFwgFdicb18wtMjc2FcAFQVscvRzU0kVBt0J/rW1SjcMCv+7etkCR9/9CAy9V4H+ECoKz2v5MdtdyxvlXhgN/lakrz0E0rJUk/ONTP1NgcCBcAZfXdty5Jku7Z3OFyJaXbvblD9SG/Lo1N662Lo26X42mEC4CyOdo/rl9cHFPQb+jh7V1ul1OymqBf923NTo394DBTY7MhXACUzV+/fkGSdP/WFWprCLtcjTN++ebs1Nj3D/Vz6eNZEC4AymI6mda33+yTJD26c43L1Tjnns2dqg36dfHqlA73jbtdjmcRLgDK4sW3L2t0MqlVTTXavan6+y2W2pBfH7ihU5L0vUP9LlfjXYQLgLL41syU2MduWy2/rzouDDZfD81Mjf3gMFNj10O4AHDchZHJ3K78j92+dKbELPdu6VQ44NO54UkducTU2LUQLgAc9+zPLkqS7t7YpjWtdS5X47z6cED3bslOjf3Pl04werkGwgWAo9IZU3/zRnZK7NElOGqx/LsHNivoN/SjY1dye3mQR7gAcNRT+8/o0ti0mmqD+mc3rnS7nLLZsjKiz35gkyTpse8e0WA07nJF3kK4AHDM8YGo/vjvj0uS/uMHb1BNsLqPe5nLv3n/Bm1d1ajRyaT+8LtH3C7HUwgXAI5IpDL6/LfeVCKd0b1bOvTxO5bulJgl6Pfpjz96i/w+Q9871K8fsDQ5h3AB4Ign/uEdHbk0rpa6oP7br90iw1hay4+v56buJv3u7l5J0n/69mFdGp1yuSJvIFwAlOzn56/qKz8+KUl6/CM3q7OxxuWKKuv37tukG1ZGNBxL6Hf/9880lUi7XZLrCBcAJbk0OqV/+42DypjSI9u79Ms3r3K7pIqrCfr1l795u1rrQzrUN6bf/9tfLPvlyYQLgEW7GkvoN596Tf1j09rY2aD//Cs3uV2Sa9a01unPPrFDAZ+hv3vrkv5s3ym3S3IV4QJgUSYTKf3W11/XySsTWtVUo7/6rTvUVBd0uyxX3dnbpv/88I2SpC+/eFz/6x/e0dhU0uWq3EG4AFiwvtEp7fnGQf38/KiaaoP6+m/doa7mWrfL8oRP7Fqrf3nnWpmm9OUXT+iuL/1If/jdIzo1OLGspsoMczn9tgAWzDRNDU7EdX54UgdOD+vvj1zWob4xSVJN0Kdv/Ktdum1tq8tVSkrEpD+auSDZ3ktSqN61UjIZU3978KKe3H9GxwaiuZ831QZ1Y1ejbuxq1I6eFt2xvnXJXOfGjnABKuzA6eGKv6ZpSqZm/qmbUto0lcqYSqdNpW1vAUMTcZ0bntTZoZjODU/q/MikppLFq58MQ9q5tlWfe2CT3ruhvVK/xuw8FC4W0zS1/+SQvvqTM3r11JCS6Xe/3W5e0aAdPS1qqguqNuhXXcivgM8nc+bxhmGoNuhXQ01ADWG/agJ+yZAMZZd6V3rF9529bfO6H+ECVNi6L3zP7RIWzDCkrqZabVkZ0QPbVuj+rSvUEfHYJ24PhkuheCqtdy5P6MilMR3uG9frZ0eKRjXV4ux//dC87hcocx0AbDZ0uPOmZxjZz7qGIfl9PgV8hvw+Qz5DuQ2PpmmquS6ktW11WtdWr562Oq1trVN3S63CgaV9lEu5hQN+3dTdpJu6m/TrO7M/G4kl9NqZYb3dH9VkPKWpZFpTibRSmexnfsPIjjonE2nF4ilNxFOKp9IzI1F5uofDyAXA0uDxkctyw2oxAIDjCBcAgOMIFwCA4wgXAIDjCBcAgOMIFwCA41iKDGBpME0pOZn9OlhX+a3rKEK4AAAcx7QYAMBxhAsAwHGECwDAcYQLAMBxhAsAwHGECwDAcYQLAMBxhAsAwHGECwDAcYQLAMBxhAsAwHEBtwsAlhPTNBWNRt0uAyhJJBKRMcfBoIQLUEHRaFRNTU1ulwGUZGxsTI2NjbPeh1ORgQpaKiOX8fFxrVmzRhcuXJjzTQYL5/W/X0YugMcYhuHJN4vFamxsXFK/j9dU898vDX0AgOMIFwCA4wgXAAsWDof12GOPKRwOu13KkrQU/n5p6AMAHMfIBQDgOMIFAOA4wgUA4DjCBQDgOMIFAOA4wgXAvL3yyiv68Ic/rK6uLhmGoW9/+9tul7RkfOlLX9LOnTsViUTU2dmpRx55RMePH3e7rEUjXADMWywW06233qqvfOUrbpey5Lz88svas2ePDhw4oJdeeknJZFIPPvigYrGY26UtCvtcACyKYRh67rnn9Mgjj7hdypI0ODiozs5Ovfzyy9q9e7fb5SwYIxcA8KCxsTFJUmtrq8uVLA7hAgAek8lk9LnPfU533323brrpJrfLWRSO3AcAj9mzZ48OHz6s/fv3u13KohEuAOAhn/nMZ/T888/rlVde0erVq90uZ9EIFwDwANM09dnPflbPPfec9u3bp/Xr17tdUkkIFwDzNjExoZMnT+a+P3PmjN588021traqp6fHxcqq3549e/TNb35T3/nOdxSJRDQwMCBJampqUm1trcvVLRxLkQHM2759+3Tvvfe+6+ef/OQn9fTTT1e+oCXketek/9rXvqZPfepTlS3GAYQLAMBxLEUGADiOcAEAOI5wAQA4jnABADiOcAEAOI5wAQA4jnABADiOcAEAOI5wAQA4jnABULWeeeYZ1dbWqr+/P/ezT3/607rllltyF9uCOzj+BUDVMk1T27dv1+7du/XEE0/oscce01NPPaUDBw6ou7vb7fKWNU5FBlC1DMPQ448/ro9+9KNauXKlnnjiCf3kJz/JBctHPvIR7du3T/fdd5/+5m/+xuVqlxdGLgCq3o4dO3TkyBG9+OKLuueee3I/37dvn6LRqL7+9a8TLhVGzwVAVXvhhRd07NgxpdNprVixoui297///YpEIi5VtrwRLgCq1sGDB/Xoo4/qySef1H333acvfvGLbpeEGfRcAFSls2fP6kMf+pD27t2rj3/84+rt7dVdd92lgwcPaseOHW6Xt+wxcgFQdUZGRvTBD35QDz/8sL7whS9Iknbt2qWHHnpIe/fudbk6SIxcAFSh1tZWHTt27F0//973vudCNbgWVosBWLLuv/9+vfXWW4rFYmptbdWzzz6ru+66y+2ylgXCBQDgOHouAADHES4AAMcRLgAAxxEuAADHES4AAMcRLgAAxxEuAADHES4AAMcRLgAAxxEuAADHES4AAMf9f2lbgJM4gKb2AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -261,6 +710,7 @@ }, { "cell_type": "markdown", + "id": "ff831073-5d73-4301-8b50-6a853d0a3acd", "metadata": {}, "source": [ "The observation `x_o` falls into the support of the predicted posterior samples, i.e. it is within `simulator(posterior_samples)`. Given the simulator, this is indicative that our posterior estimates the data well.\n" @@ -268,6 +718,7 @@ }, { "cell_type": "markdown", + "id": "20763237-c51c-443f-9063-979c2b3e1a24", "metadata": {}, "source": [ "### Running SBC\n", @@ -277,20 +728,20 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "a81aee59-5cc8-497f-8a2c-5a7a0212df97", + "metadata": {}, "outputs": [], "source": [ - "num_sbc_runs = 1_000 # choose a number of sbc runs, should be ~100s or ideally 1000\n", + "num_simulations = 1_000 # choose a number of sbc runs, should be ~100s or ideally 1000\n", "# generate ground truth parameters and corresponding simulated observations for SBC.\n", - "thetas = prior.sample((num_sbc_runs,))\n", + "thetas = prior.sample((num_simulations,))\n", "xs = simulator(thetas)" ] }, { "cell_type": "markdown", + "id": "0de8cfe9-e7e9-445e-aced-346af8eac3cd", "metadata": {}, "source": [ "SBC is implemented in `sbi` for your use on any `sbi` posterior. To run it, we only need to call `run_sbc` with appropriate parameters.\n", @@ -300,15 +751,14 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "50930e69-f837-4bb6-8637-a1ef70cdef11", + "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "84a1972b87db48d5967775f7840aaeb6", + "model_id": "08c34e6421504274a99671f4808f65f5", "version_major": 2, "version_minor": 0 }, @@ -330,6 +780,7 @@ }, { "cell_type": "markdown", + "id": "95b19252-b39b-45d8-87e2-52d019bc974b", "metadata": {}, "source": [ "`sbi` establishes two methods to do simulation-based calibration:\n", @@ -344,20 +795,10 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/janteusen/qode/sbi/sbi/analysis/sbc.py:359: UserWarning: std(): degrees of freedom is <= 0. Correction should be strictly less than the reduction factor (input numel divided by output numel). (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/native/ReduceOps.cpp:1760.)\n", - " if (c2st_scores.std(0) > 0.05).any():\n" - ] - } - ], + "execution_count": null, + "id": "88b23176-28c5-4925-88f5-6c153d09e674", + "metadata": {}, + "outputs": [], "source": [ "check_stats = check_sbc(\n", " ranks, thetas, dap_samples, num_posterior_samples=num_posterior_samples\n", @@ -366,6 +807,7 @@ }, { "cell_type": "markdown", + "id": "fe168784-354f-48aa-a24d-bd60abe9f863", "metadata": {}, "source": [ "The `check_stats` variable created contains a dictionary with 3 metrics that help to judge our posterior. The \"first\" two compare the ranks to a uniform distribution.\n" @@ -373,6 +815,7 @@ }, { "cell_type": "markdown", + "id": "cac382ac-ecf8-4ca3-b441-a8fcd904a14d", "metadata": {}, "source": [ "### Ranks versus Uniform distribution\n" @@ -380,10 +823,9 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "ca62ad37-5004-43b0-b94c-02ec167e888e", + "metadata": {}, "outputs": [ { "name": "stdout", @@ -391,7 +833,7 @@ "text": [ "kolmogorov-smirnov p-values \n", "\n", - " check_stats['ks_pvals'] = [0.14610633 0.03378298]\n" + " check_stats['ks_pvals'] = [0.0793394 0.12618521]\n" ] } ], @@ -404,26 +846,26 @@ }, { "cell_type": "markdown", + "id": "5eac9e63-3760-4f1f-a89e-c98d15a273fd", "metadata": {}, "source": [ "The Kolmogorov-Smirnov (KS test, see also [here](https://en.wikipedia.org/wiki/Kolmogorov%E2%80%93Smirnov_test#Two-sample_Kolmogorov%E2%80%93Smirnov_test)) as used by `check_sbc` provides p-values `pvals` on the null hypothesis that the samples from `ranks` are drawn from a uniform distribution (in other words `H_0: PDF(ranks) == PDF(uniform)`). We are provided two values as our problem is two-dimensional - one p-value for each dimension.\n", "\n", - "The null hypothesis (of both distributions being equal) is rejected if the p-values fall below a significance threshold (usually `< 0.05`). Therefor, vanishing p-values (`ks_pvals=0`) are interpreted to indicate a vanishing false positive rate to (mistakenly) consider both distrubtions being \"equal\". Both values are above `0.05` and we, therefore, cannot claim that inference clearly went wrong. Nonetheless, we can add additional checks:\n" + "The null hypothesis (of both distributions being equal) is rejected if the p-values fall below a significance threshold (usually `< 0.05`). Therefor, vanishing p-values (`ks_pvals=0`) are interpreted to indicate a vanishing false positive rate to (mistakenly) consider both distrubtions being \"equal\". In this case, both values are above `0.05` (`0.0793394` and `0.12618521`) and we, therefore, cannot claim that inference clearly went wrong. Nonetheless, we can add additional checks:\n" ] }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "4967cb17-6728-44b7-bfb0-d71fee30e4d9", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c2st accuracies \n", - "check_stats['c2st_ranks'] = [0.568 0.5845]\n" + "check_stats['c2st_ranks'] = [0.5725 0.578 ]\n" ] } ], @@ -435,13 +877,15 @@ }, { "cell_type": "markdown", + "id": "644ae333-f5d6-4118-99c1-f986e6a1a4d9", "metadata": {}, "source": [ - "The second tier of metrics comparing `ranks` with a uniform distributions is a `c2st` test (see [here](http://arxiv.org/abs/1610.06545) for details). This is a nonparametric two sample test based on training a classifier to differented one of the ensembles (`ranks` versus samples from a uniform distribution) by being trained on the other. The values reported are the accuracies from cross-validation. If you see values around `0.5`, the classifier was unable to differentiate both ensembles, i.e. `ranks` are very uniform. If the values are high towards `1`, this matches the case where `ranks` is very unlike a uniform distribution.\n" + "The second tier of metrics comparing `ranks` with a uniform distributions is a `c2st` test (see [here](http://arxiv.org/abs/1610.06545) for details). This is a nonparametric two sample test based on training a classifier to differentiate two ensembles. Here, these two ensembles are the observed `ranks` and samples from a uniform distribution. The values reported are the accuracies from n-fold cross-validation. If you see values around `0.5`, the classifier was unable to differentiate both ensembles, i.e. `ranks` are very uniform. If the values are high towards `1`, this matches the case where `ranks` is very unlike a uniform distribution.\n" ] }, { "cell_type": "markdown", + "id": "bc0ad068-e9d1-4ec1-9667-44fb98ecbea6", "metadata": {}, "source": [ "### Data averaged posterior (DAP) versus prior\n" @@ -449,16 +893,15 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "c4cb8611-763b-4318-a0ad-430266c46ac9", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "- c2st accuracies check_stats['c2st_dap'] = [0.5125 0.4975]\n" + "- c2st accuracies check_stats['c2st_dap'] = [0.491 0.48 ]\n" ] } ], @@ -468,6 +911,7 @@ }, { "cell_type": "markdown", + "id": "4707dfa8-e8fd-44e1-bb4f-6bc6ed7744c5", "metadata": {}, "source": [ "The last metric reported is again based on `c2st` computed per dimension of `theta`. If you see values around `0.5`, the `c2st` classifier was unable to differentiate both ensembles for each dimension of `theta`, i.e. `dap` are much like (if not identical to) the prior. If the values are very high towards `1`, this represents the case where `dap` is very unlike the prior distribution.\n" @@ -475,6 +919,7 @@ }, { "cell_type": "markdown", + "id": "229d6390-b05f-4b94-b016-6672f5b19069", "metadata": {}, "source": [ "### Visual Inspection\n" @@ -482,14 +927,13 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "0bc29b66-1b11-494e-8b91-7e3a99d0adac", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -499,7 +943,6 @@ } ], "source": [ - "\n", "f, ax = sbc_rank_plot(\n", " ranks=ranks,\n", " num_posterior_samples=num_posterior_samples,\n", @@ -510,23 +953,23 @@ }, { "cell_type": "markdown", + "id": "53592f75-a204-4b5f-abc1-8bbdc8538297", "metadata": {}, "source": [ - "The two plots visualize the distribution of `ranks` (here depicted in red) in each dimension. Highlighted in grey you see the 99% confidence interval of a uniform distribution given the number of samples provided. In plain english: for a uniform distribution, we would expect 1 out of 100 (red) bars to lie outside the grey area.\n", + "The two plots visualize the distribution of `ranks` (here depicted in red) in each dimension. Highlighted in grey, you see the 99% confidence interval of a uniform distribution given the number of samples provided. In plain english: for a uniform distribution, we would expect 1 out of 100 (red) bars to lie outside the grey area.\n", "\n", - "We also observe, that the entries fluctuate to some degree. This can be considered a hint that `sbc` should be conducted with a lot more samples than 1000. A good rule of thumb is that given the number of bins `B` and the number of SBC samples `N` (chosed to be `1_000` here) should amount to `N / B ~ 20`.\n" + "We also observe, that the entries fluctuate to some degree. This can be considered a hint that `sbc` should be conducted with a lot more samples than `1000`. A good rule of thumb is that given the number of bins `B` and the number of SBC samples `N` (chosed to be `1_000` here) should amount to `N / B ~ 20`.\n" ] }, { "cell_type": "code", - "execution_count": 16, - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "d76b5936-286f-468e-82ad-0a65194f9a43", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -541,6 +984,7 @@ }, { "cell_type": "markdown", + "id": "c2b021c4-c1aa-433d-95c4-e09e926f172f", "metadata": {}, "source": [ "The above provides a visual representation of the cumulative density function (CDF) of `ranks` (blue and orange for each dimension of `theta`) with respect to the 95% confidence interval of a uniform distribution (grey).\n" @@ -548,6 +992,70 @@ }, { "cell_type": "markdown", + "id": "b3f1a0cc-d83f-4f0c-b174-ca367aab7699", + "metadata": {}, + "source": [ + "## multi dimensional SBC\n", + "\n", + "So far, we have performed the SBC checks for each dimension of our parameters $\\theta$ separately. SBI offers a way to perform this check for all dimensions at once." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8c4de299-54a2-4ebd-beb0-344e90767c9f", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c56e48670ecb47309f927ff55fd6df2b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 1000 sbc samples.: 0%| | 0/1000 [00:00 0.05).any():\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "{'ks_pvals': tensor([0., 0.]), 'c2st_ranks': tensor([0.6775, 0.6900]), 'c2st_dap': tensor([0.5160, 0.4925])}\n" + "{'ks_pvals': tensor([0., 0.]), 'c2st_ranks': tensor([0.6550, 0.6655]), 'c2st_dap': tensor([0.5215, 0.4915])}\n" ] } ], @@ -619,19 +1122,21 @@ }, { "cell_type": "markdown", + "id": "8fc2acca-03a0-42b1-a964-b0951b5c8f8d", "metadata": {}, "source": [ - "We can see that the Kolmogorv-Smirnov p-values vanish (`'ks_pvals': tensor([0., 0.])`). Thus, we can reject the hypothesis that the `ranks` PDF is the uniform PDF. The `c2st` accuracies show values higher than `0.5`. This is indicative that the `ranks` distribution is not a uniform PDF as well.\n" + "We can see that the Kolmogorov-Smirnov p-values vanish (`'ks_pvals': tensor([0., 0.])`). Thus, we can reject the hypothesis that the `ranks` PDF is a uniform PDF. The `c2st` accuracies show values higher than `0.5`. This is supports as well that the `ranks` distribution is not a uniform PDF.\n" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, + "id": "4ef7deb0-d73f-4c64-a6bb-71e388427036", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -646,6 +1151,7 @@ }, { "cell_type": "markdown", + "id": "23ec9d31-d9fc-4469-9e7d-217d32bf70b9", "metadata": {}, "source": [ "Inspecting the histograms for both dimenions, the rank distribution is clearly tilted to low rank values for both dimensions. Because we have shifted the expected value of the posterior to higher values (by `0.1`), we see more entries at low rank values.\n" @@ -653,6 +1159,7 @@ }, { "cell_type": "markdown", + "id": "34f95fb3-b195-44e1-b1bc-44d2dce1f6e7", "metadata": {}, "source": [ "Let's try to shift all posterior samples in the opposite direction. We shift the expectation value by `-0.1`:\n" @@ -660,7 +1167,8 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, + "id": "43a45b10-aaac-4e66-a502-440d2ac1a948", "metadata": {}, "outputs": [], "source": [ @@ -669,13 +1177,14 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, + "id": "98cbfd58-5bfc-414f-9fa3-ba766dad0638", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "aa27f852ae164295950130e2963967ca", + "model_id": "a6c98007dcf84e7ba0e1c2402498c3df", "version_major": 2, "version_minor": 0 }, @@ -686,24 +1195,16 @@ "metadata": {}, "output_type": "display_data" }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/janteusen/qode/sbi/sbi/analysis/sbc.py:359: UserWarning: std(): degrees of freedom is <= 0. Correction should be strictly less than the reduction factor (input numel divided by output numel). (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/native/ReduceOps.cpp:1760.)\n", - " if (c2st_scores.std(0) > 0.05).any():\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "{'ks_pvals': tensor([0., 0.]), 'c2st_ranks': tensor([0.6700, 0.6815]), 'c2st_dap': tensor([0.4790, 0.4940])}\n" + "{'ks_pvals': tensor([0., 0.]), 'c2st_ranks': tensor([0.6890, 0.6880]), 'c2st_dap': tensor([0.5100, 0.5065])}\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHACAYAAAAyfdnSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAk6ElEQVR4nO3deXCV9b0/8E8gJCwSgqAsioiKgFQRN0rduLcoUrVovS3Xceoy9metMNa6tmNd2kpxQVt1XLpcxettVbRVqyJqi8qASpWKOyiIYAsUqyIgQkjy/f3RempkX5KT5Pt6zWTGc57v85zPOQ/5+M73WU5JSikFAADZaFHsAgAAaFgCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkJnSTRlUW1sbCxcujPbt20dJSUl91wRkKKUUy5cvj+7du0eLFs3vb1N9FKhvm9NHNykALly4MHr06LFNigPYkHfffTd23nnnYpexzemjQEPZlD66SQGwffv2hQ1WVFRsfWUAn7Ns2bLo0aNHod80N/ooUN82p49uUgD89HBFRUWFxgXUq+Z6eFQfBRrKpvTR5neiDQAAGyQAAgBkRgAEAMjMJp0DCE1RTU1NrFmzpthl8C8tW7aM0tLSZnuOH0BTIgDSLK1YsSL++te/Rkqp2KXwGW3bto1u3bpFWVlZsUsByJoASLNTU1MTf/3rX6Nt27axww47mHFqBFJKUVVVFe+9917Mmzcvevfu3Sxv9gzQVAiANDtr1qyJlFLssMMO0aZNm2KXw7+0adMmWrVqFfPnz4+qqqpo3bp1sUsCyJY/wWm2zPw1Pmb9ABoH3RgAIDMCIABAZgRAaOROPfXUOO6444pdBgDNiItAyMaUESM2eexhDz5Yj5U0bpdffnk88MADMXPmzA2Oe+211+LSSy+NGTNmxPz58+NnP/tZnHPOOQ1SIwBbxwwg1IOqqqpil1DvVq5cGbvttltceeWV0bVr12KXA8BmEABhGxgyZEiMHj06zjnnnOjcuXMMGzYsIiKuu+662HvvvaNdu3bRo0ePOOuss2LFihWF9caPHx+VlZXx2GOPRb9+/WK77baLo446KhYtWrTe13r++edjhx12iKuuumqdy6uqqmL06NHRrVu3aN26dfTs2TPGjh1bWL506dL41re+FTvssENUVFTEf/7nf8ZLL71UqOdHP/pRvPTSS1FSUhIlJSUxfvz4db7OgQceGNdcc03893//d5SXl2/uRwZAEQmAsI3ccccdUVZWFtOmTYtbb701Iv5525MbbrghXnvttbjjjjti8uTJceGFF9ZZb+XKlTFu3Li48847Y8qUKbFgwYI4//zz1/kakydPjiOOOCLGjBkTF1100TrH3HDDDfGHP/whJkyYELNnz47f/OY3seuuuxaWf/3rX48lS5bEo48+GjNmzIj99tsvvvzlL8cHH3wQI0eOjPPOOy/69+8fixYtikWLFsXIkSO3zQcEQKPhHEDYRnr37h1XX311nec+e07crrvuGldccUWceeaZcfPNNxeeX7NmTdx6662x++67R0TE6NGj48c//vFa27///vvj5JNPjl//+tcbDGULFiyI3r17xyGHHBIlJSXRs2fPwrKpU6fGn//851iyZElh1m7cuHHxwAMPxH333RdnnHFGtKqqihY1NdHuXzOV1StWxPJ/rd9+jz026zMByNHGzjlvDOeZC4Cwjey///5rPffHP/4xxo4dG7NmzYply5ZFdXV1rFq1KlauXBlt27aNiH9+P+6n4S8iolu3brFkyZI625k+fXo8/PDDcd999230iuBTTz01jjjiiOjTp08cddRRccwxx8SRRx4ZEREvvfRSrFixIjp16lRnnU8++STmzp27JW8bgCZIAIRtpF27dnUev/POO3HMMcfEd77znRgzZkxsv/32MXXq1Dj99NOjqqqqEABbtWpVZ72SkpJIKdV5bvfdd49OnTrFbbfdFkcfffRa63zWfvvtF/PmzYtHH300/vjHP8Y3vvGNGDp0aNx3332xYsWK6NatWzz11FNrrVdZWbllbxyAJkcAhHoyY8aMqK2tjWuvvbbwFWgTJkzYom117tw5fv/738eQIUPiG9/4RkyYMGGDIbCioiJGjhwZI0eOjP/6r/+Ko446Kj744IPYb7/9YvHixVFaWlrnvMDPKmvVKmpqa7eoTgCaBheBQD3ZY489Ys2aNXHjjTfG22+/HXfeeWfh4pAtseOOO8bkyZNj1qxZceKJJ0Z1dfU6x1133XVx1113xaxZs+LNN9+Me++9N7p27RqVlZUxdOjQGDx4cBx33HHx+OOPxzvvvBPPPPNMXHzxxfHCCy9ERMQuO+0U8//613j59dfj/Q8+iNWrV6/zdaqqqmLmzJkxc+bMqKqqir/97W8xc+bMmDNnzha/RwAahhlAstHQJ90OGDAgrrvuurjqqqviBz/4QRx22GExduzYOPnkk7d4m127do3JkyfHkCFD4qSTTorf/va30bJlyzpj2rdvH1dffXW89dZb0bJlyzjwwANj4sSJhVnIiRMnxsUXXxynnXZavPfee9G1a9c47LDDokuXLhERMWLYsHjo8cfjmG9+M5YuWxa3XHllnHTCCWvVsnDhwhg4cGDh8bhx42LcuHFx+OGHr/MQMwCNR0n6/MlG67Bs2bLo0KFDfPTRR1FRUdEQdcEWW7VqVcybNy969eoVrVu3LnY5Tc7yDczgbe1VwBvaN829zzT39wf8W7GuAt6cPuMQMABAZgRAAIDMCIAAAJkRAAEAMiMA0mxtwvVNNDD7BKBxEABpdj69LUpVVVWRK+HzVq5cGRFrf/sJAA3LfQBpdkpLS6Nt27bx3nvvRatWrQr3v2PTVNXUrHfZqlWrtmibKaVYuXJlLFmyJCorK9e6dyEADUsApNkpKSmJbt26xbx582L+/PnFLqfJWbVkyXqXtd7Kr4irrKyMrl27btU2ANh6AiDNUllZWfTu3dth4C3w/DXXrHdZv5tv3uLttmrVyswfQCMhANJstWjRwjeBbIH0/vvrXebzBGgenBwFAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZKa02AUAADQlU0aMKHYJW80MIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZKa02AUADWvKiBHFLgGAIjMDCACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkpLXYBAACNyZQRI4pdQr0zAwgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADITGmxCwAA2FxTRoxY77LDHnywAStpmswAAgBkRgAEAMiMAAgAkBnnAAIAWdnQ+YO5MAMIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMuM2MNDMuL0BABtjBhAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMz4LmAAoFnxnegbZwYQACAzAiAAQGYEQACAzAiAAACZEQABADLjKmCAZqKqqipqa2uLXQY0iOoWTXcOq6qqKsrKyopagwAI0AxUVVXFrFmzYvXq1cUuBRrE3zt2LHYJW2zWrFnRt2/fooZAARCgGaitrY3Vq1dHaWlplJZq7TR/pU10tru2pCRWr15d9Nl6XQKgGSktLS36oSXYFK+NGbNV67fcRnU0uEZy6LpxVAEAQIMRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMy4ETTUgykjRmxw+WEPPthAlQDA2swAAgBkRgAEAMiMAAgAkBnnAEIj4/xBAOqbAAhNzMYCIgBsjEPAAACZEQABADIjAAIAZKZRnANYVVUVtbW1xS4DtpnqFhv+22rVqlVbvG4xVVVVRVlZWbHLAGArFT0AVlVVxaxZs2L16tXFLgW2mb937LjB5a+88soWr1tMs2bNir59+wqBQLw2ZswGl/e/+OIGqoQtUfQAWFtbG6tXr47S0tIoLS16ObBNlG5kRrt169ZbvG6x1JaUxOrVq83WAzQDjSZxlZaWmlWg2Wi5kZC0oX/rG1u3aBrxoWkANo+ODgCQmUYzAwgNbUPnrzh3BYDmzAwgAEBmBEAAgMw4BAxFsLHbJwBAfTIDCACQGQEQACAzDgHDFnAIF4CmzAwgAEBmBEAAgMwIgAAAmREAAQAy4yIQAGCbc7Fc42YGEAAgMwIgAEBmBEAAgMw4BxAAWCfn8TVfZgABADJjBhAAimhDs2z9L764ASshJ2YAAQAyIwACAGTGIWBYByc+A9CcCYAA0ERt7I/VjZ1D6I/dfDkEDACQGQEQACAzDgEDQDPlEC/rYwYQACAzAiAAQGYEQACAzAiAAACZEQABADLjKmC2ytbehLQ+XxtgU9T3zZTrsw/CljIDCACQGQEQACAzDgHTaDnEC5uvurq62CU0OTUtNjwXUlVVVbT1t/a1aXxqS0qKXUJECIAAzUKLFi2ivLw8Vq9eLQRupuqNhKhVq1Zt1fqv/uxnGy5gA+tvzbo0XuXl5dGiyPtOAARoBsrKyqJv375RW1tb7FKanOUffrjB5XvvvfdWrQ+f17dv3ygrKytqDQIgQDNR7P+hNFWlGwnNrVu33qr14fMaw++quWMAgMwIgAAAmREAAQAyIwACAGTGRSDUK/fyA5q6KSNGFLsE2OYaTQB036qmyU1I89FYbl4KwNYregB089KmbWM3QKV5aQw3LwVg6xU9ALp5adPmBqh5aQw3LwVg6xU9AEY0jhsismXcADUvflepLxs7z+6wBx/cqvWBuhzLAQDITKOYAQSgadvaGTygYZkBBADIjAAIAJAZh4CbOYdlAIDPEwC3kQ0Fra0NWcW8us2VdQDQ/DgEDACQGTOAAERE457xb8y1QVNkBhAAIDNmAP/FxRIAQC4EwE20NYcfhEsAoDFxCBgAIDMCIABAZgRAAIDMOAcwc26tAAD5EQAbASEMAGhIDgEDAGRGAAQAyIxDwADNRGO+56hTXaBxMQMIAJAZARAAIDMCIABAZprUOYDOIQEA2HpmAAEAMtOkZgAB2HKOogCfalQBUHMCAKh/DgEDAGRGAAQAyMwmHQJOKUVExLJly+q1mI/XrKnX7QNbpz57wKfb/rTfNDcN0Uf1UGga6qsPbE4f3aQAuHz58oiI6NGjx1aUBTR5HTrU+0ssX748OjTA6zQ0fRQoqOcetyl9tCRtQkysra2NhQsXRvv27aOkpGSbFRjxz7Tao0ePePfdd6OiomKbbpvisV+bn/repymlWL58eXTv3j1atGh+Z6fUZx+N8DvXHNmnzVN97tfN6aObNAPYokWL2HnnnbdJcetTUVHhH3gzZL82P/W5T5vjzN+nGqKPRvida47s0+apvvbrpvbR5vdnNgAAGyQAAgBkpugBsLy8PC677LIoLy8vdilsQ/Zr82OfNm72T/NjnzZPjWW/btJFIAAANB9FnwEEAKBhCYAAAJkRAAEAMiMAAgBkpugB8Kabbopdd901WrduHYMGDYo///nPxS6J9bj88sujpKSkzk/fvn0Ly1etWhWjRo2KTp06xXbbbRcnnHBC/P3vf6+zjQULFsTRRx8dbdu2jR133DEuuOCCqK6ubui3kq0pU6bEscceG927d4+SkpJ44IEH6ixPKcWll14a3bp1izZt2sTQoUPjrbfeqjPmgw8+iJNOOikqKiqisrIyTj/99FixYkWdMS+//HIceuih0bp16+jRo0dcffXV9f3WsqaPNh36aPPQHHppUQPgPffcE+eee25cdtll8Ze//CUGDBgQw4YNiyVLlhSzLDagf//+sWjRosLP1KlTC8u+973vxUMPPRT33ntvPP3007Fw4cL42te+VlheU1MTRx99dFRVVcUzzzwTd9xxR4wfPz4uvfTSYryVLH388ccxYMCAuOmmm9a5/Oqrr44bbrghbr311pg+fXq0a9cuhg0bFqtWrSqMOemkk+K1116LJ554Ih5++OGYMmVKnHHGGYXly5YtiyOPPDJ69uwZM2bMiGuuuSYuv/zy+OUvf1nv7y9H+mjTo482fc2il6YiOuigg9KoUaMKj2tqalL37t3T2LFji1gV63PZZZelAQMGrHPZ0qVLU6tWrdK9995beO6NN95IEZGeffbZlFJKEydOTC1atEiLFy8ujLnllltSRUVFWr16db3WztoiIt1///2Fx7W1talr167pmmuuKTy3dOnSVF5enu66666UUkqvv/56ioj0/PPPF8Y8+uijqaSkJP3tb39LKaV08803p44dO9bZpxdddFHq06dPPb+jPOmjTYs+2vw01V5atBnAqqqqmDFjRgwdOrTwXIsWLWLo0KHx7LPPFqssNuKtt96K7t27x2677RYnnXRSLFiwICIiZsyYEWvWrKmzP/v27Ru77LJLYX8+++yzsffee0eXLl0KY4YNGxbLli2L1157rWHfCGuZN29eLF68uM4+7NChQwwaNKjOPqysrIwDDjigMGbo0KHRokWLmD59emHMYYcdFmVlZYUxw4YNi9mzZ8eHH37YQO8mD/po06SPNm9NpZcWLQD+4x//iJqamjr/iCMiunTpEosXLy5SVWzIoEGDYvz48TFp0qS45ZZbYt68eXHooYfG8uXLY/HixVFWVhaVlZV11vns/ly8ePE69/enyyiuT/fBhn4nFy9eHDvuuGOd5aWlpbH99tvbz0WgjzY9+mjz11R6aelWb4FsDB8+vPDf++yzTwwaNCh69uwZEyZMiDZt2hSxMoCmQR+lsSjaDGDnzp2jZcuWa13d9Pe//z26du1apKrYHJWVlbHnnnvGnDlzomvXrlFVVRVLly6tM+az+7Nr167r3N+fLqO4Pt0HG/qd7Nq161oXF1RXV8cHH3xgPxeBPtr06aPNT1PppUULgGVlZbH//vvHn/70p8JztbW18ac//SkGDx5crLLYDCtWrIi5c+dGt27dYv/9949WrVrV2Z+zZ8+OBQsWFPbn4MGD45VXXqnzj/6JJ56IioqK2GuvvRq8furq1atXdO3atc4+XLZsWUyfPr3OPly6dGnMmDGjMGby5MlRW1sbgwYNKoyZMmVKrFmzpjDmiSeeiD59+kTHjh0b6N3kQR9t+vTR5qfJ9NJtcinJFrr77rtTeXl5Gj9+fHr99dfTGWeckSorK+tc3UTjcd5556WnnnoqzZs3L02bNi0NHTo0de7cOS1ZsiSllNKZZ56ZdtlllzR58uT0wgsvpMGDB6fBgwcX1q+urk5f+MIX0pFHHplmzpyZJk2alHbYYYf0gx/8oFhvKTvLly9PL774YnrxxRdTRKTrrrsuvfjii2n+/PkppZSuvPLKVFlZmR588MH08ssvpxEjRqRevXqlTz75pLCNo446Kg0cODBNnz49TZ06NfXu3TudeOKJheVLly5NXbp0Sd/85jfTq6++mu6+++7Utm3b9Itf/KLB328O9NGmRR9tHppDLy1qAEwppRtvvDHtsssuqaysLB100EHpueeeK3ZJrMfIkSNTt27dUllZWdppp53SyJEj05w5cwrLP/nkk3TWWWeljh07prZt26bjjz8+LVq0qM423nnnnTR8+PDUpk2b1Llz53TeeeelNWvWNPRbydaTTz6ZImKtn1NOOSWl9M/bF1xyySWpS5cuqby8PH35y19Os2fPrrON999/P5144olpu+22SxUVFem0005Ly5cvrzPmpZdeSoccckgqLy9PO+20U7ryyisb6i1mSR9tOvTR5qE59NKSlFLa+nlEAACaiqJ/FRwAAA1LAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQAzdPnll8e+++5b7DI226677ho///nPt2ob48ePj8rKysLjpvpZAMXVVHuHPsqnBMAm4KmnnoqSkpK1viB8S51//vl1vqMwZ/X1WUyZMiWOPfbY6N69e5SUlMQDDzywzV8D2HT6aP2pr89i7NixceCBB0b79u1jxx13jOOOOy5mz569zV8nVwJgRlJKUV1dHdttt1106tRpq7b12S+n3hbjimVbfBbr8vHHH8eAAQPipptu2ubbBopHH11bffXRp59+OkaNGhXPPfdcPPHEE7FmzZo48sgj4+OPP97mr5UjAXAbGDJkSIwePTpGjx4dHTp0iM6dO8cll1wSn/2WvQ8//DBOPvnk6NixY7Rt2zaGDx8eb731VmH5/Pnz49hjj42OHTtGu3bton///jFx4sR455134j/+4z8iIqJjx45RUlISp556akRE1NbWxtixY6NXr17Rpk2bGDBgQNx3332FbX76F++jjz4a+++/f5SXl8fUqVPXmq6vra2NH//4x7HzzjtHeXl57LvvvjFp0qTC8nfeeSdKSkrinnvuicMPPzxat24dv/nNb9b5WZSUlMQtt9wSX/3qV6Ndu3YxZsyYqKmpidNPP71QZ58+feL666+vs96pp54axx13XIwbNy66desWnTp1ilGjRm2w8f3617+OysrKDf7lOX78+Nhll12ibdu2cfzxx8f7779fZ/nnP4tP6/jpT38aXbp0icrKyvjxj38c1dXVccEFF8T2228fO++8c9x+++3rfc2IiOHDh8cVV1wRxx9//AbHAf+kj/6bPvpPkyZNilNPPTX69+8fAwYMiPHjx8eCBQtixowZG1yPTbTNvlU4Y4cffnjabrvt0ne/+900a9as9H//93+pbdu26Ze//GVhzFe/+tXUr1+/NGXKlDRz5sw0bNiwtMcee6SqqqqUUkpHH310OuKII9LLL7+c5s6dmx566KH09NNPp+rq6vS73/0uRUSaPXt2WrRoUVq6dGlKKaUrrrgi9e3bN02aNCnNnTs33X777am8vDw99dRTKaV/f1n1Pvvskx5//PE0Z86c9P7776fLLrssDRgwoFDbddddlyoqKtJdd92VZs2alS688MLUqlWr9Oabb6aUUpo3b16KiLTrrrum3/3ud+ntt99OCxcuXOdnERFpxx13TLfddluaO3dumj9/fqqqqkqXXnppev7559Pbb79d+HzuueeewnqnnHJKqqioSGeeeWZ644030kMPPbTWZ9izZ8/0s5/9LKWU0lVXXZU6deqUpk+fvt798txzz6UWLVqkq666Ks2ePTtdf/31qbKyMnXo0KEw5vOfxSmnnJLat2+fRo0alWbNmpX+53/+J0VEGjZsWBozZkx68803009+8pPUqlWr9O67727gX0Xdz+T+++/fpLGQK3303/TRdXvrrbdSRKRXXnllk9dh/QTAbeDwww9P/fr1S7W1tYXnLrrootSvX7+UUkpvvvlmiog0bdq0wvJ//OMfqU2bNmnChAkppZT23nvvdPnll69z+582oA8//LDw3KpVq1Lbtm3TM888U2fs6aefnk488cQ66z3wwAN1xnz+l7V79+5pzJgxdcYceOCB6ayzzkop/btx/fznP9/oZxER6ZxzztnouFGjRqUTTjih8PiUU05JPXv2TNXV1YXnvv71r6eRI0cWHn/auC688MLUrVu39Oqrr27wNU488cT0la98pc5zI0eO3Gjj6tmzZ6qpqSk816dPn3TooYcWHldXV6d27dqlu+66a6PvMyUBEDaFPvpv+ujaampq0tFHH50OPvjgTRrPxpU24GRjs/bFL34xSkpKCo8HDx4c1157bdTU1MQbb7wRpaWlMWjQoMLyTp06RZ8+feKNN96IiIizzz47vvOd78Tjjz8eQ4cOjRNOOCH22Wef9b7enDlzYuXKlXHEEUfUeb6qqioGDhxY57kDDjhgvdtZtmxZLFy4MA4++OA6zx988MHx0ksvbfJ2Njbupptuittuuy0WLFgQn3zySVRVVa111Vj//v2jZcuWhcfdunWLV155pc6Ya6+9Nj7++ON44YUXYrfddttgHW+88cZah2AHDx5c57DMuvTv3z9atPj32RFdunSJL3zhC4XHLVu2jE6dOsWSJUs2uB1g8+ijGx6Xcx8dNWpUvPrqqzF16tRNGs/GOQewkfjWt74Vb7/9dnzzm9+MV155JQ444IC48cYb1zt+xYoVERHxyCOPxMyZMws/r7/+ep3zVyIi2rVrt01q3NTtfH7c3XffHeeff36cfvrp8fjjj8fMmTPjtNNOi6qqqjrjWrVqVedxSUlJ1NbW1nnu0EMPjZqampgwYcIWvINNs646NqU2oLj00ebZR0ePHh0PP/xwPPnkk7Hzzjtv0zpzJgBuI9OnT6/z+LnnnovevXtHy5Yto1+/flFdXV1nzPvvvx+zZ8+Ovfbaq/Bcjx494swzz4zf//73cd5558WvfvWriIgoKyuLiIiamprC2L322ivKy8tjwYIFsccee9T56dGjxybXXVFREd27d49p06bVeX7atGl1atsa06ZNiy996Utx1llnxcCBA2OPPfaIuXPnbtG2DjrooHj00Ufjpz/9aYwbN26DY/v167fO/QI0Tvro+uXYR1NKMXr06Lj//vtj8uTJ0atXrwZ53Vw4BLyNLFiwIM4999z49re/HX/5y1/ixhtvjGuvvTYiInr37h0jRoyI//f//l/84he/iPbt28f3v//92GmnnWLEiBEREXHOOefE8OHDY88994wPP/wwnnzyyejXr19ERPTs2TNKSkri4Ycfjq985SvRpk2baN++fZx//vnxve99L2pra+OQQw6Jjz76KKZNmxYVFRVxyimnbHLtF1xwQVx22WWx++67x7777hu33357zJw5c71XqG2u3r17x//+7//GY489Fr169Yo777wznn/++S3+Zf7Sl74UEydOjOHDh0dpaWmcc8456xx39tlnx8EHHxzjxo2LESNGxGOPPbbRwxbbyooVK2LOnDmFx/PmzYuZM2fG9ttvH7vsskuD1ABNjT66fjn20VGjRsVvf/vbePDBB6N9+/axePHiiIjo0KFDtGnTpkFqaM7MAG4jJ598cnzyySdx0EEHxahRo+K73/1unHHGGYXlt99+e+y///5xzDHHxODBgyOlFBMnTixMidfU1MSoUaOiX79+cdRRR8Wee+4ZN998c0RE7LTTTvGjH/0ovv/970eXLl1i9OjRERHxk5/8JC655JIYO3ZsYb1HHnlksxvC2WefHeeee26cd955sffee8ekSZPiD3/4Q/Tu3XubfDbf/va342tf+1qMHDkyBg0aFO+//36cddZZW7XNQw45JB555JH44Q9/uN5DPF/84hfjV7/6VVx//fUxYMCAePzxx+OHP/zhVr3upnrhhRdi4MCBhfOIzj333Bg4cGBceumlDfL60BTpo+uXYx+95ZZb4qOPPoohQ4ZEt27dCj/33HNPg7x+c1eS0mdussQWGTJkSOy7775b/fU6ALnSR6FhmQEEAMiMAAgAkBmHgAEAMmMGEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAz/x9SXO+MQ2TrkwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -721,11 +1222,12 @@ }, { "cell_type": "markdown", + "id": "794893d9-ec44-46fc-9234-9975327e62b7", "metadata": {}, "source": [ - "A similar behavior is observed, but this time we see an upshot of ranks to higher values. Because we have shifted the expected value of the posterior to smaller values, we see an upshot in high rank counts.\n", + "A similar behavior is observed, but this time we see an upshot of ranks to higher values of posterior rank. Because we have shifted the expected value of the posterior to smaller values, we see an upshot in high rank counts.\n", "\n", - "It is interesting to see that the historgams obtained provide very convincing evidence that this is not a uniform distribution.\n", + "The historgams above provide convincing evidence that this is not a uniform distribution.\n", "\n", "To conlude at this point, **the rank distribution is capable of identifying pathologies of the estimated posterior**:\n", "\n", @@ -737,16 +1239,18 @@ }, { "cell_type": "markdown", + "id": "88bce62e-63b9-46b8-a3c5-a013e13e9cd0", "metadata": {}, "source": [ "## A dispersed posterior\n", "\n", - "In this scenario we emulate the situation if our posterior estimates incorrectly with a dispersion, i.e. the posterior is too wide or too thin. We reuse our trained NPE posterior from above and wrap it so that all samples return a dispersion by 100% more wide (`2`), i.e. the variance is overestimated by a factor of 2.\n" + "In this scenario we emulate the situation if our posterior estimates incorrectly with a dispersion, i.e. the posterior is too wide or too thin. We reuse our trained NPE posterior from above and wrap it so that all samples return a dispersion by 100% more wide (`dispersion=2.0`), i.e. the variance is overestimated by a factor of 2.\n" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, + "id": "f12d3bde-920c-4811-997d-49b30202560c", "metadata": {}, "outputs": [], "source": [ @@ -758,13 +1262,14 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, + "id": "20f63dba-afd6-4614-9f77-5b6a2dccf63d", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8b09d915906348fea7a1f7fb73fe4564", + "model_id": "d2cacb7822124557b78852164d45cb72", "version_major": 2, "version_minor": 0 }, @@ -775,24 +1280,16 @@ "metadata": {}, "output_type": "display_data" }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/janteusen/qode/sbi/sbi/analysis/sbc.py:359: UserWarning: std(): degrees of freedom is <= 0. Correction should be strictly less than the reduction factor (input numel divided by output numel). (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/native/ReduceOps.cpp:1760.)\n", - " if (c2st_scores.std(0) > 0.05).any():\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "{'ks_pvals': tensor([8.1346e-08, 1.3010e-10]), 'c2st_ranks': tensor([0.6115, 0.6020]), 'c2st_dap': tensor([0.4990, 0.4785])}\n" + "{'ks_pvals': tensor([1.0876e-09, 1.3724e-12]), 'c2st_ranks': tensor([0.6015, 0.6150]), 'c2st_dap': tensor([0.5055, 0.5005])}\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -810,6 +1307,7 @@ }, { "cell_type": "markdown", + "id": "3d21c7f4-477d-452f-951a-d78ae14912b2", "metadata": {}, "source": [ "The rank histograms now look more like a very wide gaussian distribution centered in the middle. The KS p-values again vanish unsurprisingly (we must reject the hypothesis that both distributions are from the same uniform PDF) and the c2st_ranks indicate that the rank histogram is not uniform too. As our posterior samples are distributed too broad now, we obtain more \"medium\" range ranks and hence produce the peak of ranks in the center of the histogram.\n" @@ -817,14 +1315,16 @@ }, { "cell_type": "markdown", + "id": "6b8127d6-0952-4684-800b-2e4b371c276d", "metadata": {}, "source": [ - "We can repeat this exercise by making our posterior too thin, i.e. the variance of the posterior is too small. Let's cut it by half.\n" + "We can repeat this exercise by making our posterior too thin, i.e. the variance of the posterior is too small. Let's cut it by half (`dispersion=0.5`).\n" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, + "id": "e893993d-b644-4da8-a0fe-5d4399683d1a", "metadata": {}, "outputs": [], "source": [ @@ -833,13 +1333,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, + "id": "11201c39-773a-4175-b301-ad5b6404e1c6", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d17647acd7174190b4930c21b2c8dd5c", + "model_id": "f00b847ef5b245c291a68fb16fb3bbb8", "version_major": 2, "version_minor": 0 }, @@ -850,24 +1351,16 @@ "metadata": {}, "output_type": "display_data" }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/janteusen/qode/sbi/sbi/analysis/sbc.py:359: UserWarning: std(): degrees of freedom is <= 0. Correction should be strictly less than the reduction factor (input numel divided by output numel). (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/native/ReduceOps.cpp:1760.)\n", - " if (c2st_scores.std(0) > 0.05).any():\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "{'ks_pvals': tensor([3.2357e-13, 7.3539e-14]), 'c2st_ranks': tensor([0.6035, 0.5755]), 'c2st_dap': tensor([0.5070, 0.5155])}\n" + "{'ks_pvals': tensor([8.4049e-11, 3.0791e-10]), 'c2st_ranks': tensor([0.6150, 0.6190]), 'c2st_dap': tensor([0.5125, 0.4925])}\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHACAYAAAAyfdnSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAlGklEQVR4nO3deZCU9ZkH8GcGmOGQYRAUBkVERUSiiBchXuwGRaIGjZuwlhWPMmuMUMZ4JmU8YjR4oIlaHjlWcd1ERRM1KqImqBSoRIl4g4IIJkgwKAIiDsz89o+sHSfAgDAzPTO/z6dqqux+j376fenHb//eo0tSSikAAMhGabELAACgaQmAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZtpuyky1tbWxaNGi6Ny5c5SUlDR2TUCGUkqxYsWK6NWrV5SWtr7vpvoo0Ng+Tx/dpAC4aNGi6N27d4MUB1Cfd955J7bffvtil9Hg9FGgqWxKH92kANi5c+fCCisqKra8MoB/sXz58ujdu3eh37Q2+ijQ2D5PH92kAPjp4YqKigqNC2hUrfXwqD4KNJVN6aOt70QbAADqJQACAGRGAAQAyMwmnQMILVFNTU2sWbOm2GXw/9q0aRNt27Zttef4AbQkAiCt0sqVK+Mvf/lLpJSKXQqf0bFjx6iqqoqysrJilwKQNQGQVqempib+8pe/RMeOHWObbbYx4tQMpJSiuro63nvvvZg/f37069evVd7sGaClEABpddasWRMppdhmm22iQ4cOxS6H/9ehQ4do165dLFiwIKqrq6N9+/bFLgkgW76C02oZ+Wt+jPoBNA+6MQBAZgRAAIDMCIDQzJ100klx9NFHF7sMAFoRF4GQjamjRm3yvAc/8EAjVtK8XXLJJXH//ffHrFmz6p3v1VdfjYsuuihmzpwZCxYsiJ/+9Kdx5plnNkmNAGwZI4DQCKqrq4tdQqNbtWpV7LTTTnHFFVdEz549i10OAJ+DAAgNYNiwYTF27Ng488wzo3v37jFixIiIiLj22mtjjz32iE6dOkXv3r3j9NNPj5UrVxaWmzBhQlRWVsajjz4aAwYMiK222ioOP/zwePfddzf4Ws8991xss802ceWVV653enV1dYwdOzaqqqqiffv20adPnxg3blxh+rJly+Jb3/pWbLPNNlFRURH//u//Hi+++GKhnh/96Efx4osvRklJSZSUlMSECRPW+zr77bdfXH311fGf//mfUV5e/nk3GQBFJABCA7n99tujrKwspk+fHrfccktE/OO2J9dff328+uqrcfvtt8eUKVPivPPOq7PcqlWrYvz48XHHHXfE1KlTY+HChXHOOees9zWmTJkShx56aFx++eVx/vnnr3ee66+/Pn7/+9/HxIkTY86cOfHrX/86dtxxx8L0r3/967FkyZJ45JFHYubMmbH33nvHl7/85Xj//fdj9OjRcfbZZ8fAgQPj3XffjXfffTdGjx7dMBsIgGbDOYDQQPr16xdXXXVVnec+e07cjjvuGJdddlmcdtppcdNNNxWeX7NmTdxyyy2x8847R0TE2LFj49JLL11n/ffdd1+ccMIJ8atf/areULZw4cLo169fHHjggVFSUhJ9+vQpTJs2bVr86U9/iiVLlhRG7caPHx/3339/3HvvvXHqqadGu+rqKK2piU7/P1K5duXKWPH/y3feZZfPtU1oWvWd55rzea3AugRAaCD77LPPOs/94Q9/iHHjxsXs2bNj+fLlsXbt2li9enWsWrUqOnbsGBH/+H3cT8NfRERVVVUsWbKkznpmzJgRDz30UNx7770bvSL4pJNOikMPPTT69+8fhx9+eBx55JFx2GGHRUTEiy++GCtXroxu3brVWebjjz+OefPmbc7bBqAFEgChgXTq1KnO47fffjuOPPLI+M53vhOXX355bL311jFt2rQ45ZRTorq6uhAA27VrV2e5kpKSSCnVeW7nnXeObt26xa233hpHHHHEOst81t577x3z58+PRx55JP7whz/EN77xjRg+fHjce++9sXLlyqiqqoonn3xyneUqKys3740D0OIIgNBIZs6cGbW1tXHNNdcUfgJt4sSJm7Wu7t27x+9+97sYNmxYfOMb34iJEyfWGwIrKipi9OjRMXr06PiP//iPOPzww+P999+PvffeOxYvXhxt27atc17gZ5W1axc1tbWbVScALYOLQKCR7LLLLrFmzZq44YYb4q233oo77rijcHHI5th2221jypQpMXv27DjuuONi7dq1653v2muvjTvvvDNmz54db7zxRtxzzz3Rs2fPqKysjOHDh8fQoUPj6KOPjsceeyzefvvtePrpp+OCCy6I559/PiIidthuu1jwl7/ES6+9Fkvffz8++eST9b5OdXV1zJo1K2bNmhXV1dXx17/+NWbNmhVz587d7PcIQNMwAkg2mvok+EGDBsW1114bV155ZfzgBz+Igw8+OMaNGxcnnHDCZq+zZ8+eMWXKlBg2bFgcf/zx8Zvf/CbatGlTZ57OnTvHVVddFW+++Wa0adMm9ttvv5g0aVJhFHLSpElxwQUXxMknnxzvvfde9OzZMw4++ODo0aNHRESMGjEiHnzssTjym9+MZcuXx81XXBHHH3vsOrUsWrQoBg8eXHg8fvz4GD9+fBxyyCHrPcQMQPNRkv71ZKP1WL58eXTp0iU+/PDDqKioaIq6YLOtXr065s+fH3379o327dsXu5wWZ0U9I3hbehVwffumtfeZpnh/rgKGvH2ePuMQMABAZgRAAIDMCIAAAJkRAAEAMiMA0mptwvVNNDH7BKB5EABpdT69LUp1dXWRK+FfrVq1KiLW/fUTAJqW+wDS6rRt2zY6duwY7733XrRr165w/zs2TXVNzQanrV69erPWmVKKVatWxZIlS6KysnKdexcC0LQEQFqdkpKSqKqqivnz58eCBQuKXU6Ls3rJkg1Oa7+FPxFXWVkZPXv23KJ1ALDlBEBapbKysujXr5/DwJvhuauv3uC0ATfdtNnrbdeunZE/gGZCAKTVKi0t9UsgmyEtXbrBabYnQOvg5CgAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzDSLXwKZOmpUvdMPfuCBJqoEAKD1MwIIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzbYtdAABAazJ11Kh6px/8wANNVMmGGQEEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJlpW+wCAGh8U0eNqnf6wQ880ESVAM2BEUAAgMwIgAAAmREAAQAyIwACAGTGRSCQmY1dDABA62cEEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJCZtsUuoCFMHTWq3ukHP/BAE1UCAND8GQEEAMhMsxgBrCktjVTP9NWrV9e7/NrS+nPsxpaHnGzs81Kf6urqKCsra8BqACiGogfA6urqeK9Ll6ip539KL7/8cr3r+FvXrvVO39jykJONfV7qM3v27Nhtt92EQIAWrugBsLa2NmpKS6M0pShN6x8HbN++fb3raFtbW+/0jS0POdnY52VDaktK4pNPPonazVwegOaj6AHwU6UpRZsN/I9lY6MNG1puU5eHnGzs87JBW3DoGIDmRUcHAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMw0m6uAAdgyG7upfn3cMB8azsZuuN8cbqovAAK0AptyU/36uGE+NJyN3XC/OdxUXwAEaAU25ab69XHDfGg49d1wv7ncVF8ABGhF6rupfn2KfTgKWpN6P4PN5Kb6zaMKAACajAAIAJAZARAAIDMCIABAZlwEAq3Mq5dfXuwSAGjmjAACAGRGAAQAyIwACACQGQEQACAzLgIBAPiMjV1MN/CCC5qoksZjBBAAIDNGAKGZyeGbJwDFZQQQACAzAiAAQGYcAoYWxi99ALClBEAAnHsKmXEIGAAgMwIgAEBmBEAAgMwIgAAAmREAAQAy4yrgRubKOgCguREAAQA+h9ZwP1aHgAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIzfAt4E9f3m38ALLmjCSgAAtpwRQACAzAiAAACZcQgYAOpR32lAEU4F2ly2a3EZAQQAyIwACACQGQEQACAzAiAAQGYEQACAzLgKGIAWzdWk8Pm1iAC4sQ/3li7fnJtDS64dAGieHAIGAMhMixgBBABoKFt6ZLE1MAIIAJAZARAAIDMCIABAZgRAAIDMCIAAAJlxFTAAW6wx71nakq/YzPlersXcby3530xTEQBbufo+BK258QAAG+YQMABAZowAArBROf8kJ7RGRgABADJjBHALFftE02K/fkvV2KMRzr0EoDkzAggAkBkjgADQQjm3ks1lBBAAIDMCIABAZhwCBoBMNecL1hzeblwCII2mmD8NpTEAwIY5BAwAkBkBEAAgMw4Bh5spN1fNeb8059oAYGOMAAIAZMYIIAA0U4420FiMAAIAZMYIYMbcSgUA8iQAAgCfW7EPTxf79Vs6h4ABADJjBJCiac7f3ppzbQCwpQRAAIrOly5oWg4BAwBkxgggNDEjHQAUmwAIAFvAlzpaIoeAAQAy02xGAGtLSiJK88uj1dXV9U6vKeI22VhtG9Ocay9mbS1VbUlJsUsAoIEUPQCWlpZGm9raqCktzfJ/MKtXr653+toiBpWN1bYxzbn2YtbWkpWXl0epbQcNpjkfPm7OtbHlih4Ay8rKYpsPP4xU7EKKZI899qh3+ooPPmiiSta1sdo2pjnXXszaWrLddtstysrKil0GAFuo6AEwIqJNbW2xSyia9u3b1zu9bRG3zcZq25jmXHsxa2vJhL/mL9fTaerTkk9n2VJOh2l+msvRzmYRAHM2ddSoYpew2Zpz7c25NmgMuZ9OU59XfvrTeqfv8p3v1Du9JZ8ysrH37stCcTSH02kEQIBWIPfTabaEU0Zoas3hdBoBEKCVyPl0mi3hlBGaWrHDX4T7AAIAZEcABADIjAAIAJAZ5wCyQa6kBXKg15EjI4AAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkRgAEAMiMAAgAkBkBEAAgMwIgAEBmBEAAgMwIgAAAmREAAQAyIwACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJkRAAEAMiMAAgBkpu2mzJRSioiI5cuXN0oRH61Z0yjrBRpWY/WAz677037T2jR2H43QS6GlaKw+8Hn66CYFwBUrVkRERO/evbegLKDF69Kl0V9ixYoV0aUJXqep6aNAQSP3uE3poyVpE2JibW1tLFq0KDp37hwlJSUNVmDEP9Jq796945133omKiooGXTfFY7+2Po29T1NKsWLFiujVq1eUlra+s1Mas49G+My1RvZp69SY+/Xz9NFNGgEsLS2N7bffvkGK25CKigr/wFsh+7X1acx92hpH/j7VFH00wmeuNbJPW6fG2q+b2kdb39dsAADqJQACAGSm6AGwvLw8Lr744igvLy92KTQg+7X1sU+bN/un9bFPW6fmsl836SIQAABaj6KPAAIA0LQEQACAzAiAAACZEQABADJT9AB44403xo477hjt27ePIUOGxJ/+9Kdil8QGXHLJJVFSUlLnb7fdditMX716dYwZMya6desWW221VRx77LHxt7/9rc46Fi5cGEcccUR07Ngxtt122zj33HNj7dq1Tf1WsjV16tQ46qijolevXlFSUhL3339/nekppbjooouiqqoqOnToEMOHD48333yzzjzvv/9+HH/88VFRURGVlZVxyimnxMqVK+vM89JLL8VBBx0U7du3j969e8dVV13V2G8ta/poy6GPtg6toZcWNQDefffdcdZZZ8XFF18cf/7zn2PQoEExYsSIWLJkSTHLoh4DBw6Md999t/A3bdq0wrTvfe978eCDD8Y999wTTz31VCxatCi+9rWvFabX1NTEEUccEdXV1fH000/H7bffHhMmTIiLLrqoGG8lSx999FEMGjQobrzxxvVOv+qqq+L666+PW265JWbMmBGdOnWKESNGxOrVqwvzHH/88fHqq6/G448/Hg899FBMnTo1Tj311ML05cuXx2GHHRZ9+vSJmTNnxtVXXx2XXHJJ/OIXv2j095cjfbTl0UdbvlbRS1MR7b///mnMmDGFxzU1NalXr15p3LhxRayKDbn44ovToEGD1jtt2bJlqV27dumee+4pPPf666+niEjPPPNMSimlSZMmpdLS0rR48eLCPDfffHOqqKhIn3zySaPWzroiIt13332Fx7W1talnz57p6quvLjy3bNmyVF5enu68886UUkqvvfZaioj03HPPFeZ55JFHUklJSfrrX/+aUkrppptuSl27dq2zT88///zUv3//Rn5HedJHWxZ9tPVpqb20aCOA1dXVMXPmzBg+fHjhudLS0hg+fHg888wzxSqLjXjzzTejV69esdNOO8Xxxx8fCxcujIiImTNnxpo1a+rsz9122y122GGHwv585plnYo899ogePXoU5hkxYkQsX748Xn311aZ9I6xj/vz5sXjx4jr7sEuXLjFkyJA6+7CysjL23XffwjzDhw+P0tLSmDFjRmGegw8+OMrKygrzjBgxIubMmRMffPBBE72bPOijLZM+2rq1lF5atAD497//PWpqaur8I46I6NGjRyxevLhIVVGfIUOGxIQJE2Ly5Mlx8803x/z58+Oggw6KFStWxOLFi6OsrCwqKyvrLPPZ/bl48eL17u9Pp1Fcn+6D+j6Tixcvjm233bbO9LZt28bWW29tPxeBPtry6KOtX0vppW23eA1kY+TIkYX/3nPPPWPIkCHRp0+fmDhxYnTo0KGIlQG0DPoozUXRRgC7d+8ebdq0Wefqpr/97W/Rs2fPIlXF51FZWRm77rprzJ07N3r27BnV1dWxbNmyOvN8dn/27Nlzvfv702kU16f7oL7PZM+ePde5uGDt2rXx/vvv289FoI+2fPpo69NSemnRAmBZWVnss88+8cc//rHwXG1tbfzxj3+MoUOHFqssPoeVK1fGvHnzoqqqKvbZZ59o165dnf05Z86cWLhwYWF/Dh06NF5++eU6/+gff/zxqKioiN13373J66euvn37Rs+ePevsw+XLl8eMGTPq7MNly5bFzJkzC/NMmTIlamtrY8iQIYV5pk6dGmvWrCnM8/jjj0f//v2ja9euTfRu8qCPtnz6aOvTYnppg1xKspnuuuuuVF5eniZMmJBee+21dOqpp6bKyso6VzfRfJx99tnpySefTPPnz0/Tp09Pw4cPT927d09LlixJKaV02mmnpR122CFNmTIlPf/882no0KFp6NChheXXrl2bvvCFL6TDDjsszZo1K02ePDlts8026Qc/+EGx3lJ2VqxYkV544YX0wgsvpIhI1157bXrhhRfSggULUkopXXHFFamysjI98MAD6aWXXkqjRo1Kffv2TR9//HFhHYcffngaPHhwmjFjRpo2bVrq169fOu644wrTly1blnr06JG++c1vpldeeSXdddddqWPHjunnP/95k7/fHOijLYs+2jq0hl5a1ACYUko33HBD2mGHHVJZWVnaf//907PPPlvsktiA0aNHp6qqqlRWVpa22267NHr06DR37tzC9I8//jidfvrpqWvXrqljx47pmGOOSe+++26ddbz99ttp5MiRqUOHDql79+7p7LPPTmvWrGnqt5KtJ554IkXEOn8nnnhiSukfty+48MILU48ePVJ5eXn68pe/nObMmVNnHUuXLk3HHXdc2mqrrVJFRUU6+eST04oVK+rM8+KLL6YDDzwwlZeXp+222y5dccUVTfUWs6SPthz6aOvQGnppSUopbfk4IgAALUXRfwoOAICmJQACAGRGAAQAyIwACACQGQEQACAzAiAAQGYEQACAzAiAGbrkkktir732KnYZn9uOO+4YP/vZz7ZoHRMmTIjKysrC45a6LYDiaqm9Qx/lUwJgC/Dkk09GSUnJOj8QvrnOOeecOr9RmLPG2hZTp06No446Knr16hUlJSVx//33N/hrAJtOH208jbUtxo0bF/vtt1907tw5tt122zj66KNjzpw5Df46uRIAM5JSirVr18ZWW20V3bp126J1ffbHqRtivmJpiG2xPh999FEMGjQobrzxxgZfN1A8+ui6GquPPvXUUzFmzJh49tln4/HHH481a9bEYYcdFh999FGDv1aOBMAGMGzYsBg7dmyMHTs2unTpEt27d48LL7wwPvsrex988EGccMIJ0bVr1+jYsWOMHDky3nzzzcL0BQsWxFFHHRVdu3aNTp06xcCBA2PSpEnx9ttvx7/9279FRETXrl2jpKQkTjrppIiIqK2tjXHjxkXfvn2jQ4cOMWjQoLj33nsL6/z0G+8jjzwS++yzT5SXl8e0adPWGa6vra2NSy+9NLbffvsoLy+PvfbaKyZPnlyY/vbbb0dJSUncfffdccghh0T79u3j17/+9Xq3RUlJSdx8883x1a9+NTp16hSXX3551NTUxCmnnFKos3///nHdddfVWe6kk06Ko48+OsaPHx9VVVXRrVu3GDNmTL2N71e/+lVUVlbW+81zwoQJscMOO0THjh3jmGOOiaVLl9aZ/q/b4tM6fvKTn0SPHj2isrIyLr300li7dm2ce+65sfXWW8f2228ft9122wZfMyJi5MiRcdlll8UxxxxT73zAP+ij/6SP/sPkyZPjpJNOioEDB8agQYNiwoQJsXDhwpg5c2a9y7GJGuxXhTN2yCGHpK222ip997vfTbNnz07/+7//mzp27Jh+8YtfFOb56le/mgYMGJCmTp2aZs2alUaMGJF22WWXVF1dnVJK6YgjjkiHHnpoeumll9K8efPSgw8+mJ566qm0du3a9Nvf/jZFRJozZ056991307Jly1JKKV122WVpt912S5MnT07z5s1Lt912WyovL09PPvlkSumfP1a95557psceeyzNnTs3LV26NF188cVp0KBBhdquvfbaVFFRke688840e/bsdN5556V27dqlN954I6WU0vz581NEpB133DH99re/TW+99VZatGjRerdFRKRtt9023XrrrWnevHlpwYIFqbq6Ol100UXpueeeS2+99VZh+9x9992F5U488cRUUVGRTjvttPT666+nBx98cJ1t2KdPn/TTn/40pZTSlVdembp165ZmzJixwf3y7LPPptLS0nTllVemOXPmpOuuuy5VVlamLl26FOb5121x4oknps6dO6cxY8ak2bNnp//+7/9OEZFGjBiRLr/88vTGG2+kH//4x6ldu3bpnXfeqedfRd1tct99923SvJArffSf9NH1e/PNN1NEpJdffnmTl2HDBMAGcMghh6QBAwak2trawnPnn39+GjBgQEoppTfeeCNFRJo+fXph+t///vfUoUOHNHHixJRSSnvssUe65JJL1rv+TxvQBx98UHhu9erVqWPHjunpp5+uM+8pp5ySjjvuuDrL3X///XXm+dcPa69evdLll19eZ5799tsvnX766Smlfzaun/3sZxvdFhGRzjzzzI3ON2bMmHTssccWHp944ompT58+ae3atYXnvv71r6fRo0cXHn/auM4777xUVVWVXnnllXpf47jjjktf+cpX6jw3evTojTauPn36pJqamsJz/fv3TwcddFDh8dq1a1OnTp3SnXfeudH3mZIACJtCH/0nfXRdNTU16YgjjkgHHHDAJs3PxrVtwsHGVu2LX/xilJSUFB4PHTo0rrnmmqipqYnXX3892rZtG0OGDClM79atW/Tv3z9ef/31iIg444wz4jvf+U489thjMXz48Dj22GNjzz333ODrzZ07N1atWhWHHnponeerq6tj8ODBdZ7bd999N7ie5cuXx6JFi+KAAw6o8/wBBxwQL7744iavZ2Pz3XjjjXHrrbfGwoUL4+OPP47q6up1rhobOHBgtGnTpvC4qqoqXn755TrzXHPNNfHRRx/F888/HzvttFO9dbz++uvrHIIdOnRoncMy6zNw4MAoLf3n2RE9evSIL3zhC4XHbdq0iW7dusWSJUvqXQ/w+eij9c+Xcx8dM2ZMvPLKKzFt2rRNmp+Ncw5gM/Gtb30r3nrrrfjmN78ZL7/8cuy7775xww03bHD+lStXRkTEww8/HLNmzSr8vfbaa3XOX4mI6NSpU4PUuKnr+df57rrrrjjnnHPilFNOicceeyxmzZoVJ598clRXV9eZr127dnUel5SURG1tbZ3nDjrooKipqYmJEyduxjvYNOurY1NqA4pLH22dfXTs2LHx0EMPxRNPPBHbb799g9aZMwGwgcyYMaPO42effTb69esXbdq0iQEDBsTatWvrzLN06dKYM2dO7L777oXnevfuHaeddlr87ne/i7PPPjt++ctfRkREWVlZRETU1NQU5t19992jvLw8Fi5cGLvsskudv969e29y3RUVFdGrV6+YPn16neenT59ep7YtMX369PjSl74Up59+egwePDh22WWXmDdv3mata//9949HHnkkfvKTn8T48ePrnXfAgAHr3S9A86SPbliOfTSlFGPHjo377rsvpkyZEn379m2S182FQ8ANZOHChXHWWWfFt7/97fjzn/8cN9xwQ1xzzTUREdGvX78YNWpU/Nd//Vf8/Oc/j86dO8f3v//92G677WLUqFEREXHmmWfGyJEjY9ddd40PPvggnnjiiRgwYEBERPTp0ydKSkrioYceiq985SvRoUOH6Ny5c5xzzjnxve99L2pra+PAAw+MDz/8MKZPnx4VFRVx4oknbnLt5557blx88cWx8847x1577RW33XZbzJo1a4NXqH1e/fr1i//5n/+JRx99NPr27Rt33HFHPPfcc5v9Yf7Sl74UkyZNipEjR0bbtm3jzDPPXO98Z5xxRhxwwAExfvz4GDVqVDz66KMbPWzRUFauXBlz584tPJ4/f37MmjUrtt5669hhhx2apAZoafTRDcuxj44ZMyZ+85vfxAMPPBCdO3eOxYsXR0REly5dokOHDk1SQ2tmBLCBnHDCCfHxxx/H/vvvH2PGjInvfve7ceqppxam33bbbbHPPvvEkUceGUOHDo2UUkyaNKkwJF5TUxNjxoyJAQMGxOGHHx677rpr3HTTTRERsd1228WPfvSj+P73vx89evSIsWPHRkTEj3/847jwwgtj3LhxheUefvjhz90QzjjjjDjrrLPi7LPPjj322CMmT54cv//976Nfv34Nsm2+/e1vx9e+9rUYPXp0DBkyJJYuXRqnn376Fq3zwAMPjIcffjh++MMfbvAQzxe/+MX45S9/Gdddd10MGjQoHnvssfjhD3+4Ra+7qZ5//vkYPHhw4Tyis846KwYPHhwXXXRRk7w+tET66Ibl2Edvvvnm+PDDD2PYsGFRVVVV+Lv77rub5PVbu5KUPnOTJTbLsGHDYq+99trin9cByJU+Ck3LCCAAQGYEQACAzDgEDACQGSOAAACZEQABADIjAAIAZEYABADIjAAIAJAZARAAIDMCIABAZgRAAIDMCIAAAJn5PzzEKUAMuo0OAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -885,13 +1378,15 @@ }, { "cell_type": "markdown", + "id": "31fb7dce-be10-4584-8cde-dc7a6ba0c292", "metadata": {}, "source": [ - "The histogram of ranks now shoots above the allowed (greyed) area for a uniform distributed around the extrema. We made the posterior samples too thin, so we received more extreme counts of ranks. The KS p-values vanish again and the `c2st` metric of the ranks is also larger than `.5` which underlines that our rank distribution is not uniformly distributed.\n" + "The histogram of ranks now shoots above the allowed (greyed) area for a uniform distributed around the extrema. We made the posterior samples too thin, so we received more extreme counts of ranks. The KS p-values vanish again and the `c2st` metric of the ranks is also larger than `0.5` which underlines that our rank distribution is not uniformly distributed.\n" ] }, { "cell_type": "markdown", + "id": "66359a36-6a22-4b1b-8c5a-a9ce4d6425af", "metadata": {}, "source": [ "We again see, **the rank distribution is capable of identifying pathologies of the estimated posterior**:\n", @@ -904,6 +1399,7 @@ }, { "cell_type": "markdown", + "id": "ab0fc2e9-fdef-4f45-8c5c-147c0ad3910a", "metadata": {}, "source": [ "Simulation-based calibration offers a direct handle on which pathology an estimated posterior examines. Outside of this tutorial, you may very well encounter situations with mixtures of effects (a shifted mean and over-estimated variance). Moreover, uncovering a malignant posterior is only the first step to fix your analysis.\n" @@ -911,27 +1407,23 @@ } ], "metadata": { - "interpreter": { - "hash": "2193897e41726b46f35b9de052100742a934a9183b8a000ae8eb69e12e860d83" - }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "argv": [ + "python", + "-m", + "ipykernel_launcher", + "-f", + "{connection_file}" + ], + "display_name": "python3", + "env": null, + "interrupt_mode": "signal", "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 + "metadata": { + "debugger": true }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.18" - }, - "name": "13_diagnosis_sbc.ipynb" + "name": "python3" + } }, "nbformat": 4, "nbformat_minor": 4