From 4f1e3da48cd5bd0777ebc576f6e864a30768f6c7 Mon Sep 17 00:00:00 2001 From: janfb Date: Wed, 5 Apr 2023 09:04:38 +0200 Subject: [PATCH 1/3] type fix: remove arviz inference data. --- sbi/inference/posteriors/mcmc_posterior.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/sbi/inference/posteriors/mcmc_posterior.py b/sbi/inference/posteriors/mcmc_posterior.py index 8668a956b..d15896ab3 100644 --- a/sbi/inference/posteriors/mcmc_posterior.py +++ b/sbi/inference/posteriors/mcmc_posterior.py @@ -2,7 +2,7 @@ # under the Affero General Public License v3, see . from functools import partial from math import ceil -from typing import Any, Callable, Dict, Optional, Tuple, Union +from typing import Any, Callable, Dict, Optional, Union from warnings import warn import arviz as az @@ -198,7 +198,7 @@ def sample( sample_with: Optional[str] = None, num_workers: Optional[int] = None, show_progress_bars: bool = True, - ) -> Union[Tensor, Tuple[Tensor, InferenceData]]: + ) -> Tensor: r"""Return samples from posterior distribution $p(\theta|x)$ with MCMC. Check the `__init__()` method for a description of all arguments as well as @@ -452,7 +452,6 @@ def _slice_np_mcmc( Returns: Tensor of shape (num_samples, shape_of_single_theta). - Arviz InferenceData object. """ num_chains, dim_samples = initial_params.shape @@ -516,7 +515,6 @@ def _pyro_mcmc( Returns: Tensor of shape (num_samples, shape_of_single_theta). - Arviz InferenceData object. """ num_chains = mp.cpu_count() - 1 if num_chains is None else num_chains From c6de647ff07507b91f00a02d08750212a7ed0123 Mon Sep 17 00:00:00 2001 From: janfb Date: Wed, 5 Apr 2023 15:28:57 +0200 Subject: [PATCH 2/3] refactor iid tutorial; separate mnle tutorial. --- .vscode/settings.json | 4 +- sbi/inference/snpe/snpe_c.py | 5 +- tests/mnle_test.py | 24 +- ...and_permutation_invariant_embeddings.ipynb | 898 ++++++++++++++++++ ...ulti-trial-data-and-mixed-data-types.ipynb | 843 ---------------- ...17_SBI_for_models_of_decision_making.ipynb | 815 ++++++++++++++++ 6 files changed, 1738 insertions(+), 851 deletions(-) create mode 100644 tutorials/14_iid_data_and_permutation_invariant_embeddings.ipynb delete mode 100644 tutorials/14_multi-trial-data-and-mixed-data-types.ipynb create mode 100644 tutorials/17_SBI_for_models_of_decision_making.ipynb diff --git a/.vscode/settings.json b/.vscode/settings.json index 953081efb..7c245a260 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -9,7 +9,7 @@ // Editor settings for python // "[python]": { - "editor.defaultFormatter": "ms-python.python", + "editor.defaultFormatter": "ms-python.black-formatter", "editor.formatOnSave": true, "editor.codeActionsOnSave": { "source.sortImports": true @@ -36,7 +36,7 @@ // Formatting // https://code.visualstudio.com/docs/python/editing#_formatting // - "python.formatting.provider": "black", + "python.formatting.provider": "none", "python.formatting.blackArgs": [ "--line-length=88" ], diff --git a/sbi/inference/snpe/snpe_c.py b/sbi/inference/snpe/snpe_c.py index 25d182dbd..28bcceb52 100644 --- a/sbi/inference/snpe/snpe_c.py +++ b/sbi/inference/snpe/snpe_c.py @@ -414,8 +414,9 @@ def _log_prob_proposal_posterior_mog( ) utils.assert_all_finite( log_prob_proposal_posterior, - """the evaluation of the MoG proposal posterior. This is likely due to a - numerical instability in the training procedure. Please create an issue on Github.""", + """the evaluation of the MoG proposal posterior. This is likely due to a + numerical instability in the training procedure. Please create an issue on + Github.""", ) return log_prob_proposal_posterior diff --git a/tests/mnle_test.py b/tests/mnle_test.py index 45ce555cb..71f1abf49 100644 --- a/tests/mnle_test.py +++ b/tests/mnle_test.py @@ -6,9 +6,17 @@ from pyro.distributions import InverseGamma from torch.distributions import Beta, Binomial, Gamma -from sbi.inference import MNLE, MCMCPosterior, likelihood_estimator_based_potential +from sbi.inference import ( + MNLE, + MCMCPosterior, + likelihood_estimator_based_potential, +) from sbi.inference.potentials.base_potential import BasePotential +from sbi.inference.potentials.likelihood_based_potential import ( + MixedLikelihoodBasedPotential, +) from sbi.utils import BoxUniform, likelihood_nn, mcmc_transform +from sbi.utils.conditional_density_utils import ConditionedPotential from sbi.utils.torchutils import atleast_2d from sbi.utils.user_input_checks_utils import MultipleIndependent from tests.test_utils import check_c2st @@ -21,7 +29,10 @@ def test_mnle_on_device(device): num_simulations = 100 theta = torch.rand(num_simulations, 2) x = torch.cat( - (torch.rand(num_simulations, 1), torch.randint(0, 2, (num_simulations, 1))), + ( + torch.rand(num_simulations, 1), + torch.randint(0, 2, (num_simulations, 1)), + ), dim=1, ).to(device) @@ -41,7 +52,10 @@ def test_mnle_api(sampler): num_simulations = 100 theta = torch.rand(num_simulations, 2) x = torch.cat( - (torch.rand(num_simulations, 1), torch.randint(0, 2, (num_simulations, 1))), + ( + torch.rand(num_simulations, 1), + torch.randint(0, 2, (num_simulations, 1)), + ), dim=1, ) @@ -89,7 +103,9 @@ def mixed_simulator(theta): # Sample choices and rts independently. choices = Binomial(probs=ps).sample() - rts = InverseGamma(concentration=2 * torch.ones_like(beta), rate=beta).sample() + rts = InverseGamma( + concentration=2 * torch.ones_like(beta), rate=beta + ).sample() return torch.cat((rts, choices), dim=1) diff --git a/tutorials/14_iid_data_and_permutation_invariant_embeddings.ipynb b/tutorials/14_iid_data_and_permutation_invariant_embeddings.ipynb new file mode 100644 index 000000000..9099f373e --- /dev/null +++ b/tutorials/14_iid_data_and_permutation_invariant_embeddings.ipynb @@ -0,0 +1,898 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SBI with iid data and permutation-invariant embeddings\n", + "\n", + "There are scenarios in which we observe multiple data points per experiment and we can assume that they are independent and identically distributed (iid, i.e., they are assumed to have the same underlying model parameters). \n", + "For example, in a decision-making experiments, the experiment is often repeated in trials with the same experimental settings and conditions. The corresponding set of trials is then assumed to be \"iid\". \n", + "In such a scenario, we may want to obtain the posterior given a set of observation $p(\\theta | X=\\{x_i\\}_i^N)$. \n", + "\n", + "### Amortization of neural network training: iid-inference with NLE / NRE\n", + "For some SBI variants the iid assumption can be exploited: when using a likelihood-based SBI method (`SNLE`, `SNRE`) one can train the density or ratio estimator on single-trial data, and then perform inference with `MCMC`. Crucially, because the data is iid and the estimator is trained on single-trial data, one can repeat the inference with a different `x_o` (a different set of trials, or different number of trials) without having to retrain the density estimator. One can interpet this as amortization of the SBI training: we can obtain a neural likelihood, or likelihood-ratio estimate for new `x_o`s without retraining, but we still have to run `MCMC` or `VI` to do inference. \n", + "\n", + "In addition, one can not only change the number of trials of a new `x_o`, but also the entire inference setting. \n", + "For example, one can apply hierarchical inference scenarios with changing hierarchical denpendencies between the model parameters--all without having to retrain the density estimator because that is based on estimating single-trail likelihoods.\n", + "\n", + "### Full amortization: iid-inference with NPE and permutation-invariant embedding nets\n", + "When performing neural posterior estimation (`SNPE`) we cannot exploit the iid assumption directly because we are learning a density estimator in `theta`. \n", + "Thus, the underlying neural network takes `x` as input and predicts the parameters of the density estimator. \n", + "As a consequence, if `x` is a set of iid observations $X=\\{x_i\\}_i^N$ then the neural network has to be invariant to permutations of this set, i.e., it has to be permutation invariant. \n", + "Overall, this means that we _can_ use `SNPE` for inference with iid data, however, we need to provide a corresponding embedding network that handles the iid-data and is permutation invariant. \n", + "This will likely require some hyperparameter tuning and more training data for the inference to work accurately. But once we have this, the inference is fully amortized, i.e., we can get new posterior samples basically instantly without retraining and without running `MCMC` or `VI`. \n", + "\n", + "Let us first have a look how trial-based inference works in `SBI` before we discuss models with \"mixed data types\"." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SBI with trial-based data\n", + "\n", + "For illustration we use a simple linear Gaussian simulator, as in previous tutorials. The simulator takes a single parameter (vector), the mean of the Gaussian, and its variance is set to one. \n", + "We define a Gaussian prior over the mean and perform inference. \n", + "The observed data is again a from a Gaussian with some fixed \"ground-truth\" parameter $\\theta_o$. \n", + "Crucially, the observed data `x_o` can consist of multiple samples given the same ground-truth parameters and these samples are then iid: \n", + "\n", + "$$ \n", + "\\theta \\sim \\mathcal{N}(\\mu_0,\\; \\Sigma_0) \\\\\n", + "x | \\theta \\sim \\mathcal{N}(\\theta,\\; \\Sigma=I) \\\\\n", + "\\mathbf{x_o} = \\{x_o^i\\}_{i=1}^N \\sim \\mathcal{N}(\\theta_o,\\; \\Sigma=I)\n", + "$$\n", + "\n", + "For this toy problem the ground-truth posterior is well defined, it is again a Gaussian, centered on the mean of $\\mathbf{x_o}$ and with variance scaled by the number of trials $N$, i.e., the more trials we observe, the more information about the underlying $\\theta_o$ we have and the more concentrated the posteriors becomes.\n", + "\n", + "We will illustrate this below:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from torch import zeros, ones, eye\n", + "from torch.distributions import MultivariateNormal\n", + "from sbi.inference import SNLE, SNPE, prepare_for_sbi, simulate_for_sbi\n", + "from sbi.analysis import pairplot\n", + "from sbi.utils.metrics import c2st\n", + "\n", + "from sbi.simulators.linear_gaussian import (\n", + " linear_gaussian,\n", + " true_posterior_linear_gaussian_mvn_prior,\n", + ")\n", + "\n", + "# Seeding\n", + "torch.manual_seed(1);" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Gaussian simulator\n", + "theta_dim = 2\n", + "x_dim = theta_dim\n", + "\n", + "# likelihood_mean will be likelihood_shift+theta\n", + "likelihood_shift = -1.0 * zeros(x_dim)\n", + "likelihood_cov = 0.3 * eye(x_dim)\n", + "\n", + "prior_mean = zeros(theta_dim)\n", + "prior_cov = eye(theta_dim)\n", + "prior = MultivariateNormal(loc=prior_mean, covariance_matrix=prior_cov)\n", + "\n", + "# Define Gaussian simulator\n", + "simulator, prior = prepare_for_sbi(\n", + " lambda theta: linear_gaussian(theta, likelihood_shift, likelihood_cov), prior\n", + ")\n", + "\n", + "\n", + "# Use built-in function to obtain ground-truth posterior given x_o\n", + "def get_true_posterior_samples(x_o, num_samples=1):\n", + " return true_posterior_linear_gaussian_mvn_prior(\n", + " x_o, likelihood_shift, likelihood_cov, prior_mean, prior_cov\n", + " ).sample((num_samples,))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The analytical posterior concentrates around true parameters with increasing number of IID trials " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "num_trials = [1, 5, 15, 20]\n", + "theta_o = zeros(1, theta_dim)\n", + "\n", + "# Generate multiple x_os with increasing number of trials.\n", + "xos = [theta_o.repeat(nt, 1) for nt in num_trials]\n", + "\n", + "# Obtain analytical posterior samples for each of them.\n", + "true_samples = [get_true_posterior_samples(xo, 5000) for xo in xos]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot them in one pairplot as contours (obtained via KDE on the samples).\n", + "fig, ax = pairplot(\n", + " true_samples,\n", + " points=theta_o,\n", + " diag=\"kde\",\n", + " upper=\"contour\",\n", + " kde_offdiag=dict(bins=50),\n", + " kde_diag=dict(bins=100),\n", + " contour_offdiag=dict(levels=[0.95]),\n", + " points_colors=[\"k\"],\n", + " points_offdiag=dict(marker=\"*\", markersize=10),\n", + ")\n", + "plt.sca(ax[1, 1])\n", + "plt.legend(\n", + " [f\"{nt} trials\" if nt > 1 else f\"{nt} trial\" for nt in num_trials]\n", + " + [r\"$\\theta_o$\"],\n", + " frameon=False,\n", + " fontsize=12,\n", + ");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Indeed, with increasing number of trials the posterior density concentrates around the true underlying parameter." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## IID inference with NLE\n", + "\n", + "(S)NLE can easily perform inference given multiple IID x because it is based on learning the likelihood. Once the likelihood is learned on single trials, i.e., a neural network that given a single observation and a parameter predicts the likelihood of that observation given the parameter, one can perform MCMC to obtain posterior samples. \n", + "\n", + "MCMC relies on evaluating ratios of likelihoods of candidate parameters to either accept or reject them to be posterior samples. When inferring the posterior given multiple IID observation, these likelihoods are just the joint likelihoods of each IID observation given the current parameter candidate. Thus, given a neural likelihood from SNLE, we can calculate these joint likelihoods and perform MCMC given IID data, we just have to multiply together (or add in log-space) the individual trial-likelihoods (`sbi` takes care of that)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5c4eac9f56954a598631db3ed5ad5b20", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 10000 simulations.: 0%| | 0/10000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot them in one pairplot as contours (obtained via KDE on the samples).\n", + "fig, ax = pairplot(\n", + " nle_samples,\n", + " points=theta_o,\n", + " diag=\"kde\",\n", + " upper=\"contour\",\n", + " kde_offdiag=dict(bins=50),\n", + " kde_diag=dict(bins=100),\n", + " contour_offdiag=dict(levels=[0.95]),\n", + " points_colors=[\"k\"],\n", + " points_offdiag=dict(marker=\"*\", markersize=10),\n", + ")\n", + "plt.sca(ax[1, 1])\n", + "plt.legend(\n", + " [f\"{nt} trials\" if nt > 1 else f\"{nt} trial\" for nt in num_trials]\n", + " + [r\"$\\theta_o$\"],\n", + " frameon=False,\n", + " fontsize=12,\n", + ");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The pairplot above already indicates that (S)NLE is well able to obtain accurate posterior samples also for increasing number of trials (note that we trained the single-round version of SNLE so that we did not have to re-train it for new $x_o$). \n", + "\n", + "Quantitatively we can measure the accuracy of SNLE by calculating the `c2st` score between SNLE and the true posterior samples, where the best accuracy is perfect for `0.5`:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "c2st score for num_trials=1: 0.50\n", + "c2st score for num_trials=5: 0.51\n", + "c2st score for num_trials=15: 0.51\n", + "c2st score for num_trials=20: 0.51\n" + ] + } + ], + "source": [ + "cs = [\n", + " c2st(torch.from_numpy(s1), torch.from_numpy(s2))\n", + " for s1, s2 in zip(true_samples, nle_samples)\n", + "]\n", + "\n", + "for _ in range(len(num_trials)):\n", + " print(f\"c2st score for num_trials={num_trials[_]}: {cs[_].item():.2f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## IID inference with NPE using permutation-invariant embedding nets\n", + "\n", + "For NPE we need to define an embedding net that handles the set-like structure of iid-data, i.e., that it permutation invariant and can handle different number of trials. \n", + "\n", + "We implemented several embedding net classes that allow to construct such a permutation- and number-of-trials invariant embedding net. \n", + "\n", + "To become permutation invariant, the neural net first learns embeddings for single trials and then performs a permutation invariant operation on those embeddings, e.g., by taking the sum or the mean (Chen et al. 2018, Radev et al. 2021).\n", + "\n", + "To become invariant w.r.t. the number-of-trials, we train the net with varying number of trials for each parameter setting. As it is difficult to handle tensors of varying lengths in the SBI training loop, we construct a training data set in which \"unobserved\" trials are mask by NaNs (and ignore the resulting SBI warning about NaNs in the training data).\n", + "\n", + "### Construct training data set." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# we need to fix the maximum number of trials.\n", + "max_num_trials = 20\n", + "\n", + "# construct training data set: we want to cover the full range of possible number of\n", + "# trials\n", + "num_training_samples = 5000\n", + "theta = prior.sample((num_training_samples,))\n", + "\n", + "# there are certainly smarter ways to construct the training data set, but we go with a\n", + "# for loop here for illustration purposes.\n", + "x = torch.ones(num_training_samples * max_num_trials, max_num_trials, x_dim) * float(\n", + " \"nan\"\n", + ")\n", + "for i in range(num_training_samples):\n", + " xi = simulator(theta[i].repeat(max_num_trials, 1))\n", + " for j in range(max_num_trials):\n", + " x[i * max_num_trials + j, : j + 1, :] = xi[: j + 1, :]\n", + "\n", + "theta = theta.repeat_interleave(max_num_trials, dim=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Build embedding net" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from sbi.neural_nets.embedding_nets import (\n", + " FCEmbedding,\n", + " PermutationInvariantEmbedding,\n", + ")\n", + "from sbi.utils import posterior_nn\n", + "\n", + "# embedding\n", + "latent_dim = 10\n", + "single_trial_net = FCEmbedding(\n", + " input_dim=theta_dim,\n", + " num_hiddens=40,\n", + " num_layers=2,\n", + " output_dim=latent_dim,\n", + ")\n", + "embedding_net = PermutationInvariantEmbedding(\n", + " single_trial_net,\n", + " trial_net_output_dim=latent_dim,\n", + " # NOTE: post-embedding is not needed really.\n", + " num_layers=1,\n", + " num_hiddens=10,\n", + " output_dim=10,\n", + ")\n", + "\n", + "# we choose a simple MDN as the density estimator.\n", + "# NOTE: we turn off z-scoring of the data, as we used NaNs for the missing trials.\n", + "density_estimator = posterior_nn(\"mdn\", embedding_net=embedding_net, z_score_x=\"none\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run training" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:Found 95000 NaN simulations and 0 Inf simulations. They are not excluded from training due to `exclude_invalid_x=False`.Training will likely fail, we strongly recommend `exclude_invalid_x=True` for Single-round NPE.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Neural network successfully converged after 168 epochs." + ] + } + ], + "source": [ + "inference = SNPE(prior, density_estimator=density_estimator)\n", + "# NOTE: we don't exclude invalid x because we used NaNs for the missing trials.\n", + "inference.append_simulations(\n", + " theta,\n", + " x,\n", + " exclude_invalid_x=False,\n", + ").train(training_batch_size=1000)\n", + "posterior = inference.build_posterior()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Amortized inference\n", + "Comparing runtimes, we see that the NPE training takes a bit longer than the training on single trials for `NLE` above. \n", + "\n", + "However, we trained the density estimator such that it can handle multiple and changing number of iid trials (up to 20). \n", + "\n", + "Thus, we can obtain posterior samples for different `x_o` with just a single forward pass instead of having to run `MCMC` for each new observation.\n", + "\n", + "As you can see below, the c2st score for increasing number of observed trials remains close to the ideal `0.5`. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7b2946f18f634a1f8670b59d01a35c8e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Drawing 5000 posterior samples: 0%| | 0/5000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_trials = [1, 5, 15, 20]\n", + "xos = [theta_o.repeat(nt, 1) for nt in num_trials]\n", + "\n", + "npe_samples = []\n", + "for xo in xos:\n", + " # we need to pad the x_os with NaNs to match the shape of the training data.\n", + " xoi = torch.ones(1, max_num_trials, x_dim) * float(\"nan\")\n", + " xoi[0, : len(xo), :] = xo\n", + " npe_samples.append(posterior.sample(sample_shape=(num_samples,), x=xoi))\n", + "\n", + "\n", + "# Plot them in one pairplot as contours (obtained via KDE on the samples).\n", + "fig, ax = pairplot(\n", + " npe_samples,\n", + " points=theta_o,\n", + " diag=\"kde\",\n", + " upper=\"contour\",\n", + " kde_offdiag=dict(bins=50),\n", + " kde_diag=dict(bins=100),\n", + " contour_offdiag=dict(levels=[0.95]),\n", + " points_colors=[\"k\"],\n", + " points_offdiag=dict(marker=\"*\", markersize=10),\n", + ")\n", + "plt.sca(ax[1, 1])\n", + "plt.legend(\n", + " [f\"{nt} trials\" if nt > 1 else f\"{nt} trial\" for nt in num_trials]\n", + " + [r\"$\\theta_o$\"],\n", + " frameon=False,\n", + " fontsize=12,\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c6f02b27bd2049cd92e81f12653a294c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Drawing 5000 posterior samples: 0%| | 0/5000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# We can easily obtain posteriors for many different x_os, instantly, because NPE is fully amortized:\n", + "num_trials = [2, 4, 6, 8, 12, 14, 18]\n", + "npe_samples = []\n", + "for xo in xos:\n", + " # we need to pad the x_os with NaNs to match the shape of the training data.\n", + " xoi = torch.ones(1, max_num_trials, x_dim) * float(\"nan\")\n", + " xoi[0, : len(xo), :] = xo\n", + " npe_samples.append(posterior.sample(sample_shape=(num_samples,), x=xoi))\n", + "\n", + "\n", + "# Plot them in one pairplot as contours (obtained via KDE on the samples).\n", + "fig, ax = pairplot(\n", + " npe_samples,\n", + " points=theta_o,\n", + " diag=\"kde\",\n", + " upper=\"contour\",\n", + " kde_offdiag=dict(bins=50),\n", + " kde_diag=dict(bins=100),\n", + " contour_offdiag=dict(levels=[0.95]),\n", + " points_colors=[\"k\"],\n", + " points_offdiag=dict(marker=\"*\", markersize=10),\n", + ")\n", + "plt.sca(ax[1, 1])\n", + "plt.legend(\n", + " [f\"{nt} trials\" if nt > 1 else f\"{nt} trial\" for nt in num_trials]\n", + " + [r\"$\\theta_o$\"],\n", + " frameon=False,\n", + " fontsize=12,\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.17" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "vscode": { + "interpreter": { + "hash": "9ef9b53a5ce850816b9705a866e49207a37a04a71269aa157d9f9ab944ea42bf" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorials/14_multi-trial-data-and-mixed-data-types.ipynb b/tutorials/14_multi-trial-data-and-mixed-data-types.ipynb deleted file mode 100644 index 31a50ad70..000000000 --- a/tutorials/14_multi-trial-data-and-mixed-data-types.ipynb +++ /dev/null @@ -1,843 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# SBI with trial-based data and models of mixed data types\n", - "\n", - "Trial-based data often has the property that the individual trials can be assumed to be independent and identically distributed (iid), i.e., they are assumed to have the same underlying model parameters. For example, in a decision-making experiments, the experiment is often repeated in trials with the same experimental settings and conditions. The corresponding set of trials is then assumed to be \"iid\". \n", - "\n", - "\n", - "### Amortization of neural network training with likelihood-based SBI\n", - "For some SBI variants the iid assumption can be exploited: when using a likelihood-based SBI method (`SNLE`, `SNRE`) one can train the density or ratio estimator on single-trial data, and then perform inference with `MCMC`. Crucially, because the data is iid and the estimator is trained on single-trial data, one can repeat the inference with a different `x_o` (a different set of trials, or different number of trials) without having to retrain the density estimator. One can interpet this as amortization of the SBI training: we can obtain a neural likelihood, or likelihood-ratio estimate for new `x_o`s without retraining, but we still have to run `MCMC` or `VI` to do inference. \n", - "\n", - "In addition, one can not only change the number of trials of a new `x_o`, but also the entire inference setting. For example, one can apply hierarchical inference scenarios with changing hierarchical denpendencies between the model parameters--all without having to retrain the density estimator because that is based on estimating single-trail likelihoods.\n", - "\n", - "Let us first have a look how trial-based inference works in `SBI` before we discuss models with \"mixed data types\"." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## SBI with trial-based data\n", - "\n", - "For illustration we use a simple linear Gaussian simulator, as in previous tutorials. The simulator takes a single parameter (vector), the mean of the Gaussian and its variance is set to one. We define a Gaussian prior over the mean and perform inference. The observed data is again a from a Gaussian with some fixed \"ground-truth\" parameter $\\theta_o$. Crucially, the observed data `x_o` can consist of multiple samples given the same ground-truth parameters and these samples are then iid: \n", - "\n", - "$$ \n", - "\\theta \\sim \\mathcal{N}(\\mu_0,\\; \\Sigma_0) \\\\\n", - "x | \\theta \\sim \\mathcal{N}(\\theta,\\; \\Sigma=I) \\\\\n", - "\\mathbf{x_o} = \\{x_o^i\\}_{i=1}^N \\sim \\mathcal{N}(\\theta_o,\\; \\Sigma=I)\n", - "$$\n", - "\n", - "For this toy problem the ground-truth posterior is well defined, it is again a Gaussian, centered on the mean of $\\mathbf{x_o}$ and with variance scaled by the number of trials $N$, i.e., the more trials we observe, the more information about the underlying $\\theta_o$ we have and the more concentrated the posteriors becomes.\n", - "\n", - "We will illustrate this below:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from torch import zeros, ones, eye\n", - "from torch.distributions import MultivariateNormal\n", - "from sbi.inference import SNLE, prepare_for_sbi, simulate_for_sbi\n", - "from sbi.analysis import pairplot\n", - "from sbi.utils.metrics import c2st\n", - "\n", - "from sbi.simulators.linear_gaussian import (\n", - " linear_gaussian,\n", - " true_posterior_linear_gaussian_mvn_prior,\n", - ")\n", - "\n", - "# Seeding\n", - "torch.manual_seed(1);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Gaussian simulator\n", - "theta_dim = 2\n", - "x_dim = theta_dim\n", - "\n", - "# likelihood_mean will be likelihood_shift+theta\n", - "likelihood_shift = -1.0 * zeros(x_dim)\n", - "likelihood_cov = 0.3 * eye(x_dim)\n", - "\n", - "prior_mean = zeros(theta_dim)\n", - "prior_cov = eye(theta_dim)\n", - "prior = MultivariateNormal(loc=prior_mean, covariance_matrix=prior_cov)\n", - "\n", - "# Define Gaussian simulator\n", - "simulator, prior = prepare_for_sbi(\n", - " lambda theta: linear_gaussian(theta, likelihood_shift, likelihood_cov), prior\n", - ")\n", - "\n", - "# Use built-in function to obtain ground-truth posterior given x_o\n", - "def get_true_posterior_samples(x_o, num_samples=1):\n", - " return true_posterior_linear_gaussian_mvn_prior(\n", - " x_o, likelihood_shift, likelihood_cov, prior_mean, prior_cov\n", - " ).sample((num_samples,))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### The analytical posterior concentrates around true parameters with increasing number of IID trials " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "num_trials = [1, 5, 15, 20]\n", - "theta_o = zeros(1, theta_dim)\n", - "\n", - "# Generate multiple x_os with increasing number of trials.\n", - "xos = [theta_o.repeat(nt, 1) for nt in num_trials]\n", - "\n", - "# Obtain analytical posterior samples for each of them.\n", - "ss = [get_true_posterior_samples(xo, 5000) for xo in xos]" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/janfb/qode/sbi/sbi/analysis/plot.py:425: UserWarning: No contour levels were found within the data range.\n", - " levels=opts[\"contour_offdiag\"][\"levels\"],\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Plot them in one pairplot as contours (obtained via KDE on the samples).\n", - "fig, ax = pairplot(\n", - " ss,\n", - " points=theta_o,\n", - " diag=\"kde\",\n", - " upper=\"contour\",\n", - " kde_offdiag=dict(bins=50),\n", - " kde_diag=dict(bins=100),\n", - " contour_offdiag=dict(levels=[0.95]),\n", - " points_colors=[\"k\"],\n", - " points_offdiag=dict(marker=\"*\", markersize=10),\n", - ")\n", - "plt.sca(ax[1, 1])\n", - "plt.legend(\n", - " [f\"{nt} trials\" if nt > 1 else f\"{nt} trial\" for nt in num_trials]\n", - " + [r\"$\\theta_o$\"],\n", - " frameon=False,\n", - " fontsize=12,\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Indeed, with increasing number of trials the posterior density concentrates around the true underlying parameter." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Trial-based inference with NLE\n", - "\n", - "(S)NLE can easily perform inference given multiple IID x because it is based on learning the likelihood. Once the likelihood is learned on single trials, i.e., a neural network that given a single observation and a parameter predicts the likelihood of that observation given the parameter, one can perform MCMC to obtain posterior samples. \n", - "\n", - "MCMC relies on evaluating ratios of likelihoods of candidate parameters to either accept or reject them to be posterior samples. When inferring the posterior given multiple IID observation, these likelihoods are just the joint likelihoods of each IID observation given the current parameter candidate. Thus, given a neural likelihood from SNLE, we can calculate these joint likelihoods and perform MCMC given IID data, we just have to multiply together (or add in log-space) the individual trial-likelihoods (`sbi` takes care of that)." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "fcf73f242a114380bab0acdb0e7ca78e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Running 10000 simulations.: 0%| | 0/10000 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Plot them in one pairplot as contours (obtained via KDE on the samples).\n", - "fig, ax = pairplot(\n", - " samples,\n", - " points=theta_o,\n", - " diag=\"kde\",\n", - " upper=\"contour\",\n", - " kde_offdiag=dict(bins=50),\n", - " kde_diag=dict(bins=100),\n", - " contour_offdiag=dict(levels=[0.95]),\n", - " points_colors=[\"k\"],\n", - " points_offdiag=dict(marker=\"*\", markersize=10),\n", - ")\n", - "plt.sca(ax[1, 1])\n", - "plt.legend(\n", - " [f\"{nt} trials\" if nt > 1 else f\"{nt} trial\" for nt in num_trials]\n", - " + [r\"$\\theta_o$\"],\n", - " frameon=False,\n", - " fontsize=12,\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The pairplot above already indicates that (S)NLE is well able to obtain accurate posterior samples also for increasing number of trials (note that we trained the single-round version of SNLE so that we did not have to re-train it for new $x_o$). \n", - "\n", - "Quantitatively we can measure the accuracy of SNLE by calculating the `c2st` score between SNLE and the true posterior samples, where the best accuracy is perfect for `0.5`:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "c2st score for num_trials=1: 0.51\n", - "c2st score for num_trials=5: 0.50\n", - "c2st score for num_trials=15: 0.53\n", - "c2st score for num_trials=20: 0.55\n" - ] - } - ], - "source": [ - "cs = [c2st(torch.from_numpy(s1), torch.from_numpy(s2)) for s1, s2 in zip(ss, samples)]\n", - "\n", - "for _ in range(len(num_trials)):\n", - " print(f\"c2st score for num_trials={num_trials[_]}: {cs[_].item():.2f}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This inference procedure would work similarly when using `SNRE`. However, note that it does not work for `SNPE` because in `SNPE` we are learning the posterior directly so that whenever `x_o` changes (in terms of the number of trials or the parameter dependencies) the posterior changes and `SNPE` needs to be trained again. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Trial-based SBI with mixed data types\n", - "\n", - "In some cases, models with trial-based data additionally return data with mixed data types, e.g., continous and discrete data. For example, most computational models of decision-making have continuous reaction times and discrete choices as output. \n", - "\n", - "This can induce a problem when performing trial-based SBI that relies on learning a neural likelihood. The problem is that it is challenging for most density estimators to handle both, continous and discrete data at the same time. There has been developed a method for solving this problem, it's called __Mixed Neural Likelihood Estimation__ (MNLE). It works just like NLE, but with mixed data types. The trick is that it learns two separate density estimators, one for the discrete part of the data, and one for the continuous part, and combines the two to obtain the final neural likelihood. Crucially, the continuous density estimator is trained conditioned on the output of the discrete one, such that statistical dependencies between the discrete and continous data (e.g., between choices and reaction times) are modeled as well. The interested reader is referred to the original paper available [here](https://www.biorxiv.org/content/10.1101/2021.12.22.473472v2).\n", - "\n", - "MNLE was recently added to `sbi` (see [PR](https://github.com/mackelab/sbi/pull/638)) and follow the same API as `SNLE`." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Toy problem for `MNLE`\n", - "\n", - "To illustrate `MNLE` we set up a toy simulator that outputs mixed data and for which we know the likelihood such we can obtain reference posterior samples via MCMC.\n", - "\n", - "__Simulator__: To simulate mixed data we do the following\n", - "\n", - "- Sample reaction time from `inverse Gamma`\n", - "- Sample choices from `Binomial`\n", - "- Return reaction time $rt \\in (0, \\infty$ and choice index $c \\in \\{0, 1\\}$\n", - "\n", - "$$\n", - "c \\sim \\text{Binomial}(\\rho) \\\\\n", - "rt \\sim \\text{InverseGamma}(\\alpha=2, \\beta) \\\\\n", - "$$\n", - "\n", - "\n", - "\n", - "\n", - "__Prior__: The priors of the two parameters $\\rho$ and $\\beta$ are independent. We define a `Beta` prior over the probabilty parameter of the `Binomial` used in the simulator and a `Gamma` prior over the shape-parameter of the `inverse Gamma` used in the simulator:\n", - "\n", - "$$\n", - "p(\\beta, \\rho) = p(\\beta) \\; p(\\rho) ; \\\\\n", - "p(\\beta) = \\text{Gamma}(1, 0.5) \\\\\n", - "p(\\text{probs}) = \\text{Beta}(2, 2) \n", - "$$\n", - "\n", - "Because the `InverseGamma` and the `Binomial` likelihoods are well-defined we can perform MCMC on this problem and obtain reference-posterior samples." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "from sbi.inference import MNLE\n", - "from pyro.distributions import InverseGamma\n", - "from torch.distributions import Beta, Binomial, Gamma\n", - "from sbi.utils import MultipleIndependent\n", - "\n", - "from sbi.inference import MCMCPosterior, VIPosterior, RejectionPosterior\n", - "from sbi.utils.torchutils import atleast_2d\n", - "\n", - "from sbi.utils import mcmc_transform\n", - "from sbi.inference.potentials.base_potential import BasePotential" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "# Toy simulator for mixed data\n", - "def mixed_simulator(theta):\n", - " beta, ps = theta[:, :1], theta[:, 1:]\n", - "\n", - " choices = Binomial(probs=ps).sample()\n", - " rts = InverseGamma(concentration=2 * torch.ones_like(beta), rate=beta).sample()\n", - "\n", - " return torch.cat((rts, choices), dim=1)\n", - "\n", - "\n", - "# Potential function to perform MCMC to obtain the reference posterior samples.\n", - "class PotentialFunctionProvider(BasePotential):\n", - " allow_iid_x = True # type: ignore\n", - "\n", - " def __init__(self, prior, x_o, device=\"cpu\"):\n", - " super().__init__(prior, x_o, device)\n", - "\n", - " def __call__(self, theta, track_gradients: bool = True):\n", - "\n", - " theta = atleast_2d(theta)\n", - "\n", - " with torch.set_grad_enabled(track_gradients):\n", - " iid_ll = self.iid_likelihood(theta)\n", - "\n", - " return iid_ll + self.prior.log_prob(theta)\n", - "\n", - " def iid_likelihood(self, theta):\n", - "\n", - " lp_choices = torch.stack(\n", - " [\n", - " Binomial(probs=th.reshape(1, -1)).log_prob(self.x_o[:, 1:])\n", - " for th in theta[:, 1:]\n", - " ],\n", - " dim=1,\n", - " )\n", - "\n", - " lp_rts = torch.stack(\n", - " [\n", - " InverseGamma(\n", - " concentration=2 * torch.ones_like(beta_i), rate=beta_i\n", - " ).log_prob(self.x_o[:, :1])\n", - " for beta_i in theta[:, :1]\n", - " ],\n", - " dim=1,\n", - " )\n", - "\n", - " joint_likelihood = (lp_choices + lp_rts).squeeze()\n", - "\n", - " assert joint_likelihood.shape == torch.Size([x_o.shape[0], theta.shape[0]])\n", - " return joint_likelihood.sum(0)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# Define independent prior.\n", - "prior = MultipleIndependent(\n", - " [\n", - " Gamma(torch.tensor([1.0]), torch.tensor([0.5])),\n", - " Beta(torch.tensor([2.0]), torch.tensor([2.0])),\n", - " ],\n", - " validate_args=False,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Obtain reference-posterior samples via analytical likelihood and MCMC" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "torch.manual_seed(42)\n", - "num_trials = 10\n", - "num_samples = 1000\n", - "theta_o = prior.sample((1,))\n", - "x_o = mixed_simulator(theta_o.repeat(num_trials, 1))" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/janfb/qode/sbi/sbi/utils/sbiutils.py:282: UserWarning: An x with a batch size of 10 was passed. It will be interpreted as a batch of independent and identically\n", - " distributed data X={x_1, ..., x_n}, i.e., data generated based on the\n", - " same underlying (unknown) parameter. The resulting posterior will be with\n", - " respect to entire batch, i.e,. p(theta | X).\n", - " respect to entire batch, i.e,. p(theta | X).\"\"\"\n", - "MCMC init with proposal: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:00<00:00, 4365.61it/s]\n", - "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35000/35000 [02:39<00:00, 219.06it/s]\n" - ] - } - ], - "source": [ - "true_posterior = MCMCPosterior(\n", - " potential_fn=PotentialFunctionProvider(prior, x_o),\n", - " proposal=prior,\n", - " method=\"slice_np_vectorized\",\n", - " theta_transform=mcmc_transform(prior, enable_transform=True),\n", - " **mcmc_parameters,\n", - ")\n", - "true_samples = true_posterior.sample((num_samples,))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Train MNLE and generate samples via MCMC" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Neural network successfully converged after 84 epochs." - ] - } - ], - "source": [ - "# Training data\n", - "num_simulations = 5000\n", - "theta = prior.sample((num_simulations,))\n", - "x = mixed_simulator(theta)\n", - "\n", - "# Train MNLE and obtain MCMC-based posterior.\n", - "trainer = MNLE()\n", - "estimator = trainer.append_simulations(theta, x).train()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "posterior = trainer.build_posterior(estimator, prior)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/janfb/qode/sbi/sbi/neural_nets/mnle.py:64: UserWarning: The mixed neural likelihood estimator assumes that x contains\n", - " continuous data in the first n-1 columns (e.g., reaction times) and\n", - " categorical data in the last column (e.g., corresponding choices). If\n", - " this is not the case for the passed `x` do not use this function.\n", - " this is not the case for the passed `x` do not use this function.\"\"\"\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Neural network successfully converged after 35 epochs." - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "MCMC init with proposal: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:00<00:00, 6125.93it/s]\n", - "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35000/35000 [01:26<00:00, 404.04it/s]\n" - ] - } - ], - "source": [ - "# Training data\n", - "num_simulations = 5000\n", - "theta = prior.sample((num_simulations,))\n", - "x = mixed_simulator(theta)\n", - "\n", - "# Train MNLE and obtain MCMC-based posterior.\n", - "trainer = MNLE(prior)\n", - "estimator = trainer.append_simulations(theta, x).train()\n", - "mnle_posterior = trainer.build_posterior(\n", - " mcmc_method=\"slice_np_vectorized\", mcmc_parameters=mcmc_parameters\n", - ")\n", - "mnle_samples = mnle_posterior.sample((num_samples,), x=x_o)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Compare MNLE and reference posterior" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/janfb/qode/sbi/sbi/analysis/plot.py:425: UserWarning: No contour levels were found within the data range.\n", - " levels=opts[\"contour_offdiag\"][\"levels\"],\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Plot them in one pairplot as contours (obtained via KDE on the samples).\n", - "fig, ax = pairplot(\n", - " [\n", - " prior.sample((1000,)),\n", - " true_samples,\n", - " mnle_samples,\n", - " ],\n", - " points=theta_o,\n", - " diag=\"kde\",\n", - " upper=\"contour\",\n", - " kde_offdiag=dict(bins=50),\n", - " kde_diag=dict(bins=100),\n", - " contour_offdiag=dict(levels=[0.95]),\n", - " points_colors=[\"k\"],\n", - " points_offdiag=dict(marker=\"*\", markersize=10),\n", - " labels=[r\"$\\beta$\", r\"$\\rho$\"],\n", - ")\n", - "\n", - "plt.sca(ax[1, 1])\n", - "plt.legend(\n", - " [\"Prior\", \"Reference\", \"MNLE\", r\"$\\theta_o$\"],\n", - " frameon=False,\n", - " fontsize=12,\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We see that the inferred `MNLE` posterior nicely matches the reference posterior, and how both inferred a posterior that is quite different from the prior.\n", - "\n", - "Because MNLE training is amortized we can obtain another posterior given a different observation with potentially a different number of trials, just by running MCMC again (without re-training `MNLE`):" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Repeat inference with different `x_o` that has more trials" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/janfb/qode/sbi/sbi/utils/sbiutils.py:282: UserWarning: An x with a batch size of 100 was passed. It will be interpreted as a batch of independent and identically\n", - " distributed data X={x_1, ..., x_n}, i.e., data generated based on the\n", - " same underlying (unknown) parameter. The resulting posterior will be with\n", - " respect to entire batch, i.e,. p(theta | X).\n", - " respect to entire batch, i.e,. p(theta | X).\"\"\"\n", - "MCMC init with proposal: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:00<00:00, 4685.01it/s]\n", - "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35000/35000 [02:47<00:00, 209.25it/s]\n", - "MCMC init with proposal: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50/50 [00:00<00:00, 6136.69it/s]\n", - "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35000/35000 [08:23<00:00, 69.57it/s]\n" - ] - } - ], - "source": [ - "num_trials = 100\n", - "x_o = mixed_simulator(theta_o.repeat(num_trials, 1))\n", - "true_samples = true_posterior.sample((num_samples,), x=x_o)\n", - "mnle_samples = mnle_posterior.sample((num_samples,), x=x_o)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/janfb/qode/sbi/sbi/analysis/plot.py:425: UserWarning: No contour levels were found within the data range.\n", - " levels=opts[\"contour_offdiag\"][\"levels\"],\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Plot them in one pairplot as contours (obtained via KDE on the samples).\n", - "fig, ax = pairplot(\n", - " [\n", - " prior.sample((1000,)),\n", - " true_samples,\n", - " mnle_samples,\n", - " ],\n", - " points=theta_o,\n", - " diag=\"kde\",\n", - " upper=\"contour\",\n", - " kde_offdiag=dict(bins=50),\n", - " kde_diag=dict(bins=100),\n", - " contour_offdiag=dict(levels=[0.95]),\n", - " points_colors=[\"k\"],\n", - " points_offdiag=dict(marker=\"*\", markersize=10),\n", - " labels=[r\"$\\beta$\", r\"$\\rho$\"],\n", - ")\n", - "\n", - "plt.sca(ax[1, 1])\n", - "plt.legend(\n", - " [\"Prior\", \"Reference\", \"MNLE\", r\"$\\theta_o$\"],\n", - " frameon=False,\n", - " fontsize=12,\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Again we can see that the posteriors match nicely. In addition, we observe that the posterior variance reduces as we increase the number of trials, similar to the illustration with the Gaussian example at the beginning of the tutorial. \n", - "\n", - "A final note: `MNLE` is trained on single-trial data. Theoretically, density estimation is perfectly accurate only in the limit of infinite training data. Thus, training with a finite amount of training data naturally induces a small bias in the density estimator. As we observed above, this bias is so small that we don't really notice it, e.g., the `c2st` scores were close to 0.5. However, when we increase the number of trials in `x_o` dramatically (on the order of 1000s) the small bias can accumulate over the trials and inference with `MNLE` can become less accurate." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.8.13 ('sbi')", - "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.8.13" - }, - "vscode": { - "interpreter": { - "hash": "9ef9b53a5ce850816b9705a866e49207a37a04a71269aa157d9f9ab944ea42bf" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/tutorials/17_SBI_for_models_of_decision_making.ipynb b/tutorials/17_SBI_for_models_of_decision_making.ipynb new file mode 100644 index 000000000..7cfdea0ad --- /dev/null +++ b/tutorials/17_SBI_for_models_of_decision_making.ipynb @@ -0,0 +1,815 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SBI with mixed data, iid data, and experimental conditions\n", + "\n", + "For a general tutorial on using SBI with trial-based iid data, see `tutorial 14`. Here, we cover the use-case often occurring in models of decision-making: trial-based data with mixed data types and varying experimental conditions. " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Trial-based SBI with mixed data types\n", + "\n", + "In some cases, models with trial-based data additionally return data with mixed data types, e.g., continous and discrete data. For example, most computational models of decision-making have continuous reaction times and discrete choices as output. \n", + "\n", + "This can induce a problem when performing trial-based SBI that relies on learning a neural likelihood: It is challenging for most density estimators to handle both, continuous and discrete data at the same time. \n", + "However, there is a recent SBI method for solving this problem, it's called __Mixed Neural Likelihood Estimation__ (MNLE). It works just like NLE, but with mixed data types. The trick is that it learns two separate density estimators, one for the discrete part of the data, and one for the continuous part, and combines the two to obtain the final neural likelihood. Crucially, the continuous density estimator is trained conditioned on the output of the discrete one, such that statistical dependencies between the discrete and continuous data (e.g., between choices and reaction times) are modeled as well. The interested reader is referred to the original paper available [here](https://elifesciences.org/articles/77220).\n", + "\n", + "MNLE was recently added to `sbi` (see this [PR](https://github.com/mackelab/sbi/pull/638) and also [issue](https://github.com/mackelab/sbi/issues/845)) and follow the same API as `SNLE`.\n", + "\n", + "In this tutorial we will show how to apply `MNLE` to mixed data, and how to deal with varying experimental conditions. " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Toy problem for `MNLE`\n", + "\n", + "To illustrate `MNLE` we set up a toy simulator that outputs mixed data and for which we know the likelihood such we can obtain reference posterior samples via MCMC.\n", + "\n", + "__Simulator__: To simulate mixed data we do the following\n", + "\n", + "- Sample reaction time from `inverse Gamma`\n", + "- Sample choices from `Binomial`\n", + "- Return reaction time $rt \\in (0, \\infty)$ and choice index $c \\in \\{0, 1\\}$\n", + "\n", + "$$\n", + "c \\sim \\text{Binomial}(\\rho) \\\\\n", + "rt \\sim \\text{InverseGamma}(\\alpha=2, \\beta) \\\\\n", + "$$\n", + "\n", + "\n", + "\n", + "\n", + "__Prior__: The priors of the two parameters $\\rho$ and $\\beta$ are independent. We define a `Beta` prior over the probabilty parameter of the `Binomial` used in the simulator and a `Gamma` prior over the shape-parameter of the `inverse Gamma` used in the simulator:\n", + "\n", + "$$\n", + "p(\\beta, \\rho) = p(\\beta) \\; p(\\rho) ; \\\\\n", + "p(\\beta) = \\text{Gamma}(1, 0.5) \\\\\n", + "p(\\text{probs}) = \\text{Beta}(2, 2) \n", + "$$\n", + "\n", + "Because the `InverseGamma` and the `Binomial` likelihoods are well-defined we can perform MCMC on this problem and obtain reference-posterior samples." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import torch\n", + "from torch import Tensor\n", + "\n", + "\n", + "from sbi.inference import MNLE\n", + "from pyro.distributions import InverseGamma\n", + "from torch.distributions import Beta, Binomial, Categorical, Gamma\n", + "from sbi.utils import MultipleIndependent\n", + "from sbi.utils.metrics import c2st\n", + "\n", + "from sbi.analysis import pairplot\n", + "from sbi.inference import MCMCPosterior\n", + "from sbi.utils.torchutils import atleast_2d\n", + "\n", + "from sbi.inference.potentials.likelihood_based_potential import (\n", + " MixedLikelihoodBasedPotential,\n", + ")\n", + "from sbi.utils.conditional_density_utils import ConditionedPotential\n", + "\n", + "from sbi.utils import mcmc_transform\n", + "from sbi.inference.potentials.base_potential import BasePotential" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Toy simulator for mixed data\n", + "def mixed_simulator(theta: Tensor, concentration_scaling: float = 1.0):\n", + " \"\"\"Returns a sample from a mixed distribution given parameters theta.\n", + "\n", + " Args:\n", + " theta: batch of parameters, shape (batch_size, 2)\n", + " concentration_scaling: scaling factor for the concentration parameter of the InverseGamma distribution, mimics an experimental condition.\n", + "\n", + " \"\"\"\n", + " beta, ps = theta[:, :1], theta[:, 1:]\n", + "\n", + " choices = Binomial(probs=ps).sample()\n", + " rts = InverseGamma(\n", + " concentration=concentration_scaling * torch.ones_like(beta), rate=beta\n", + " ).sample()\n", + "\n", + " return torch.cat((rts, choices), dim=1)\n", + "\n", + "\n", + "# The potential function defines the ground truth likelihood and allows us to obtain reference posterior samples via MCMC.\n", + "class PotentialFunctionProvider(BasePotential):\n", + " allow_iid_x = True # type: ignore\n", + "\n", + " def __init__(self, prior, x_o, concentration_scaling=1.0, device=\"cpu\"):\n", + " super().__init__(prior, x_o, device)\n", + " self.concentration_scaling = concentration_scaling\n", + "\n", + " def __call__(self, theta, track_gradients: bool = True):\n", + " theta = atleast_2d(theta)\n", + "\n", + " with torch.set_grad_enabled(track_gradients):\n", + " iid_ll = self.iid_likelihood(theta)\n", + "\n", + " return iid_ll + self.prior.log_prob(theta)\n", + "\n", + " def iid_likelihood(self, theta):\n", + " lp_choices = torch.stack(\n", + " [\n", + " Binomial(probs=th.reshape(1, -1)).log_prob(self.x_o[:, 1:])\n", + " for th in theta[:, 1:]\n", + " ],\n", + " dim=1,\n", + " )\n", + "\n", + " lp_rts = torch.stack(\n", + " [\n", + " InverseGamma(\n", + " concentration=self.concentration_scaling * torch.ones_like(beta_i),\n", + " rate=beta_i,\n", + " ).log_prob(self.x_o[:, :1])\n", + " for beta_i in theta[:, :1]\n", + " ],\n", + " dim=1,\n", + " )\n", + "\n", + " joint_likelihood = (lp_choices + lp_rts).squeeze()\n", + "\n", + " assert joint_likelihood.shape == torch.Size([self.x_o.shape[0], theta.shape[0]])\n", + " return joint_likelihood.sum(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Define independent prior.\n", + "prior = MultipleIndependent(\n", + " [\n", + " Gamma(torch.tensor([1.0]), torch.tensor([0.5])),\n", + " Beta(torch.tensor([2.0]), torch.tensor([2.0])),\n", + " ],\n", + " validate_args=False,\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Obtain reference-posterior samples via analytical likelihood and MCMC" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "torch.manual_seed(42)\n", + "num_trials = 10\n", + "num_samples = 1000\n", + "theta_o = prior.sample((1,))\n", + "x_o = mixed_simulator(theta_o.repeat(num_trials, 1))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/janbolts/qode/sbi/sbi/utils/sbiutils.py:342: UserWarning: An x with a batch size of 10 was passed. It will be interpreted as a batch of independent and identically\n", + " distributed data X={x_1, ..., x_n}, i.e., data generated based on the\n", + " same underlying (unknown) parameter. The resulting posterior will be with\n", + " respect to entire batch, i.e,. p(theta | X).\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bb1f53851d4a4dc0aeedd45fc0642c1e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running vectorized MCMC with 20 chains: 0%| | 0/20000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot them in one pairplot as contours (obtained via KDE on the samples).\n", + "fig, ax = pairplot(\n", + " [\n", + " prior.sample((1000,)),\n", + " true_samples,\n", + " mnle_samples,\n", + " ],\n", + " points=theta_o,\n", + " diag=\"kde\",\n", + " upper=\"contour\",\n", + " kde_offdiag=dict(bins=50),\n", + " kde_diag=dict(bins=100),\n", + " contour_offdiag=dict(levels=[0.95]),\n", + " points_colors=[\"k\"],\n", + " points_offdiag=dict(marker=\"*\", markersize=10),\n", + " labels=[r\"$\\beta$\", r\"$\\rho$\"],\n", + ")\n", + "\n", + "plt.sca(ax[1, 1])\n", + "plt.legend(\n", + " [\"Prior\", \"Reference\", \"MNLE\", r\"$\\theta_o$\"],\n", + " frameon=False,\n", + " fontsize=12,\n", + ");" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that the inferred `MNLE` posterior nicely matches the reference posterior, and how both inferred a posterior that is quite different from the prior.\n", + "\n", + "Because MNLE training is amortized we can obtain another posterior given a different observation with potentially a different number of trials, just by running MCMC again (without re-training `MNLE`):" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Repeat inference with different `x_o` that contains more trials" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/janbolts/qode/sbi/sbi/utils/sbiutils.py:342: UserWarning: An x with a batch size of 50 was passed. It will be interpreted as a batch of independent and identically\n", + " distributed data X={x_1, ..., x_n}, i.e., data generated based on the\n", + " same underlying (unknown) parameter. The resulting posterior will be with\n", + " respect to entire batch, i.e,. p(theta | X).\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "45ed8a0ba0244d3097b90da70d9dceb3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running vectorized MCMC with 20 chains: 0%| | 0/20000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot them in one pairplot as contours (obtained via KDE on the samples).\n", + "fig, ax = pairplot(\n", + " [\n", + " prior.sample((1000,)),\n", + " true_samples,\n", + " mnle_samples,\n", + " ],\n", + " points=theta_o,\n", + " diag=\"kde\",\n", + " upper=\"contour\",\n", + " kde_offdiag=dict(bins=50),\n", + " kde_diag=dict(bins=100),\n", + " contour_offdiag=dict(levels=[0.95]),\n", + " points_colors=[\"k\"],\n", + " points_offdiag=dict(marker=\"*\", markersize=10),\n", + " labels=[r\"$\\beta$\", r\"$\\rho$\"],\n", + ")\n", + "\n", + "plt.sca(ax[1, 1])\n", + "plt.legend(\n", + " [\"Prior\", \"Reference\", \"MNLE\", r\"$\\theta_o$\"],\n", + " frameon=False,\n", + " fontsize=12,\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0.5565)\n" + ] + } + ], + "source": [ + "print(c2st(true_samples, mnle_samples)[0])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again we can see that the posteriors match nicely. In addition, we observe that the posterior's (epistemic) uncertainty reduces as we increase the number of trials. \n", + "\n", + "Note: `MNLE` is trained on single-trial data. Theoretically, density estimation is perfectly accurate only in the limit of infinite training data. Thus, training with a finite amount of training data naturally induces a small bias in the density estimator. \n", + "As we observed above, this bias is so small that we don't really notice it, e.g., the `c2st` scores were close to 0.5. \n", + "However, when we increase the number of trials in `x_o` dramatically (on the order of 1000s) the small bias can accumulate over the trials and inference with `MNLE` can become less accurate." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## MNLE with experimental conditions\n", + "\n", + "In the perceptual decision-making research it is common to design experiments with varying experimental decisions, e.g., to vary the difficulty of the task. \n", + "During parameter inference, it can be beneficial to incorporate the experimental conditions. \n", + "In MNLE, we are learning an emulator that should be able to generate synthetic experimental data including reaction times and choices given different experimental conditions. \n", + "Thus, to make MNLE work with experimental conditions, we need to include them in the training process, i.e., treat them like auxiliary parameters of the simulator: " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# define a simulator wrapper in which the experimental condition are contained in theta and passed to the simulator.\n", + "def sim_wrapper(theta):\n", + " # simulate with experiment conditions\n", + " return mixed_simulator(\n", + " theta=theta[:, :2],\n", + " concentration_scaling=theta[:, 2:]\n", + " + 1, # add 1 to deal with 0 values from Categorical distribution\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Define a proposal that contains both, priors for the parameters and a discrte prior over experimental conditions.\n", + "proposal = MultipleIndependent(\n", + " [\n", + " Gamma(torch.tensor([1.0]), torch.tensor([0.5])),\n", + " Beta(torch.tensor([2.0]), torch.tensor([2.0])),\n", + " Categorical(probs=torch.ones(1, 3)),\n", + " ],\n", + " validate_args=False,\n", + ")\n", + "\n", + "# Simulated data\n", + "num_simulations = 10000\n", + "num_samples = 1000\n", + "theta = proposal.sample((num_simulations,))\n", + "x = sim_wrapper(theta)\n", + "assert x.shape == (num_simulations, 2)\n", + "\n", + "# simulate observed data and define ground truth parameters\n", + "num_trials = 10\n", + "theta_o = proposal.sample((1,))\n", + "theta_o[0, 2] = 2.0 # set condition to 2 as in original simulator.\n", + "x_o = sim_wrapper(theta_o.repeat(num_trials, 1))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Obtain ground truth posterior via MCMC\n", + "\n", + "We obtain a ground-truth posterior via MCMC by using the PotentialFunctionProvider.\n", + "\n", + "For that, we first the define the actual prior, i.e., the distribution over the parameter we want to infer (not the proposal).\n", + "\n", + "Thus, we leave out the discrete prior over experimental conditions." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/janbolts/qode/sbi/sbi/utils/sbiutils.py:342: UserWarning: An x with a batch size of 10 was passed. It will be interpreted as a batch of independent and identically\n", + " distributed data X={x_1, ..., x_n}, i.e., data generated based on the\n", + " same underlying (unknown) parameter. The resulting posterior will be with\n", + " respect to entire batch, i.e,. p(theta | X).\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "99b53f79862c4464a152a809161b0a26", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running vectorized MCMC with 20 chains: 0%| | 0/20000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Finally, we can compare the ground truth conditional posterior with the MNLE-conditional posterior.\n", + "fig, ax = pairplot(\n", + " [\n", + " prior.sample((1000,)),\n", + " true_posterior_samples,\n", + " conditional_samples,\n", + " ],\n", + " points=theta_o,\n", + " diag=\"kde\",\n", + " upper=\"contour\",\n", + " kde_offdiag=dict(bins=50),\n", + " kde_diag=dict(bins=100),\n", + " contour_offdiag=dict(levels=[0.95]),\n", + " points_colors=[\"k\"],\n", + " points_offdiag=dict(marker=\"*\", markersize=10),\n", + " labels=[r\"$\\beta$\", r\"$\\rho$\"],\n", + ")\n", + "\n", + "plt.sca(ax[1, 1])\n", + "plt.legend(\n", + " [\"Prior\", \"Reference\", \"MNLE\", r\"$\\theta_o$\"],\n", + " frameon=False,\n", + " fontsize=12,\n", + ");" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "They match accurately, showing that we can indeed post-hoc condition the trained MNLE likelihood on different experimental conditions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('sbi')", + "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.8.17" + }, + "vscode": { + "interpreter": { + "hash": "9ef9b53a5ce850816b9705a866e49207a37a04a71269aa157d9f9ab944ea42bf" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 436d54b7bfbda1b8ecb3ab777cef52c20d6c78e6 Mon Sep 17 00:00:00 2001 From: janfb Date: Wed, 5 Apr 2023 15:29:39 +0200 Subject: [PATCH 3/3] test: conditioning on experimental conditions with mnle. --- sbi/inference/snle/mnle.py | 28 ++++- tests/linearGaussian_snre_test.py | 6 +- tests/mnle_test.py | 165 ++++++++++++++++++++++-------- 3 files changed, 150 insertions(+), 49 deletions(-) diff --git a/sbi/inference/snle/mnle.py b/sbi/inference/snle/mnle.py index e4466c6ec..33b4ffe1e 100644 --- a/sbi/inference/snle/mnle.py +++ b/sbi/inference/snle/mnle.py @@ -64,6 +64,29 @@ def __init__( kwargs = del_entries(locals(), entries=("self", "__class__")) super().__init__(**kwargs) + def train( + self, + training_batch_size: int = 50, + learning_rate: float = 5e-4, + validation_fraction: float = 0.1, + stop_after_epochs: int = 20, + max_num_epochs: int = 2**31 - 1, + clip_max_norm: Optional[float] = 5.0, + resume_training: bool = False, + discard_prior_samples: bool = False, + retrain_from_scratch: bool = False, + show_train_summary: bool = False, + dataloader_kwargs: Optional[Dict] = None, + ) -> MixedDensityEstimator: + density_estimator = super().train( + **del_entries(locals(), entries=("self", "__class__")) + ) + assert isinstance( + density_estimator, MixedDensityEstimator + ), f"""Internal net must be of type + MixedDensityEstimator but is {type(density_estimator)}.""" + return density_estimator + def build_posterior( self, density_estimator: Optional[TorchModule] = None, @@ -128,7 +151,10 @@ def build_posterior( ), f"""net must be of type MixedDensityEstimator but is {type (likelihood_estimator)}.""" - potential_fn, theta_transform = mixed_likelihood_estimator_based_potential( + ( + potential_fn, + theta_transform, + ) = mixed_likelihood_estimator_based_potential( likelihood_estimator=likelihood_estimator, prior=prior, x_o=None ) diff --git a/tests/linearGaussian_snre_test.py b/tests/linearGaussian_snre_test.py index 376599910..f6e277f47 100644 --- a/tests/linearGaussian_snre_test.py +++ b/tests/linearGaussian_snre_test.py @@ -50,10 +50,7 @@ def test_api_sre_on_linearGaussian(num_dim: int, SNRE: RatioEstimator): prior = MultivariateNormal(loc=zeros(num_dim), covariance_matrix=eye(num_dim)) simulator, prior = prepare_for_sbi(diagonal_linear_gaussian, prior) - inference = SNRE( - classifier="resnet", - show_progress_bars=False, - ) + inference = SNRE(classifier="resnet", show_progress_bars=False) theta, x = simulate_for_sbi(simulator, prior, 1000, simulation_batch_size=50) ratio_estimator = inference.append_simulations(theta, x).train(max_num_epochs=5) @@ -70,6 +67,7 @@ def test_api_sre_on_linearGaussian(num_dim: int, SNRE: RatioEstimator): num_chains=2, ) posterior.sample(sample_shape=(10,)) + posterior.map(num_iter=1) @pytest.mark.parametrize("SNRE", (SNRE_B, SNRE_C)) diff --git a/tests/mnle_test.py b/tests/mnle_test.py index 71f1abf49..062182480 100644 --- a/tests/mnle_test.py +++ b/tests/mnle_test.py @@ -3,14 +3,13 @@ import pytest import torch +from numpy import isin from pyro.distributions import InverseGamma -from torch.distributions import Beta, Binomial, Gamma +from torch.distributions import Beta, Binomial, Categorical, Gamma -from sbi.inference import ( - MNLE, - MCMCPosterior, - likelihood_estimator_based_potential, -) +from sbi.inference import MNLE, MCMCPosterior, likelihood_estimator_based_potential +from sbi.inference.posteriors.rejection_posterior import RejectionPosterior +from sbi.inference.posteriors.vi_posterior import VIPosterior from sbi.inference.potentials.base_potential import BasePotential from sbi.inference.potentials.likelihood_based_potential import ( MixedLikelihoodBasedPotential, @@ -22,6 +21,28 @@ from tests.test_utils import check_c2st +# toy simulator for mixed data +def mixed_simulator(theta, stimulus_condition=2.0): + # Extract parameters + beta, ps = theta[:, :1], theta[:, 1:] + + # Sample choices and rts independently. + choices = Binomial(probs=ps).sample() + rts = InverseGamma( + concentration=stimulus_condition * torch.ones_like(beta), rate=beta + ).sample() + + return torch.cat((rts, choices), dim=1) + + +mcmc_kwargs = dict( + num_chains=10, + warmup_steps=100, + method="slice_np_vectorized", + init_strategy="proposal", +) + + @pytest.mark.gpu @pytest.mark.parametrize("device", ("cpu", "cuda")) def test_mnle_on_device(device): @@ -63,39 +84,30 @@ def test_mnle_api(sampler): prior = BoxUniform(torch.zeros(2), torch.ones(2)) x_o = x[0] # Build estimator manually. - density_estimator = likelihood_nn(model="mnle", **dict(tail_bound=2.0)) + density_estimator = likelihood_nn(model="mnle") trainer = MNLE(density_estimator=density_estimator) - mnle = trainer.append_simulations(theta, x).train(max_num_epochs=1) + trainer.append_simulations(theta, x).train(max_num_epochs=5) # Test different samplers. posterior = trainer.build_posterior(prior=prior, sample_with=sampler) posterior.set_default_x(x_o) - if sampler == "vi": - posterior.train() - posterior.sample((1,), show_progress_bars=False) - - # MNLE should work with the default potential as well. - potential_fn, parameter_transform = likelihood_estimator_based_potential( - mnle, prior, x_o - ) - posterior = MCMCPosterior( - potential_fn, - proposal=prior, - theta_transform=parameter_transform, - init_strategy="proposal", - ) - posterior.sample((1,), show_progress_bars=False) + if isinstance(posterior, VIPosterior): + posterior.train().sample((1,)) + elif isinstance(posterior, RejectionPosterior): + posterior.sample((1,)) + else: + posterior.sample( + (1,), + num_chains=2, + warmup_steps=1, + method="slice_np_vectorized", + init_strategy="proposal", + thin=1, + ) @pytest.mark.slow -@pytest.mark.parametrize( - "sampler", - ( - "mcmc", - "rejection", - # "vi", # Failing because of transformed space dimension mismatch. - ), -) +@pytest.mark.parametrize("sampler", ("mcmc", "rejection", "vi")) def test_mnle_accuracy(sampler): def mixed_simulator(theta): # Extract parameters @@ -103,9 +115,7 @@ def mixed_simulator(theta): # Sample choices and rts independently. choices = Binomial(probs=ps).sample() - rts = InverseGamma( - concentration=2 * torch.ones_like(beta), rate=beta - ).sample() + rts = InverseGamma(concentration=1 * torch.ones_like(beta), rate=beta).sample() return torch.cat((rts, choices), dim=1) @@ -127,13 +137,6 @@ def mixed_simulator(theta): trainer.append_simulations(theta, x).train() posterior = trainer.build_posterior() - mcmc_kwargs = dict( - num_chains=10, - warmup_steps=100, - method="slice_np_vectorized", - init_strategy="proposal", - ) - for num_trials in [10]: theta_o = prior.sample((1,)) x_o = mixed_simulator(theta_o.repeat(num_trials, 1)) @@ -154,7 +157,7 @@ def mixed_simulator(theta): mnle_posterior_samples = posterior.sample( sample_shape=(num_samples,), - show_progress_bars=False, + show_progress_bars=True, **mcmc_kwargs if sampler == "mcmc" else {}, ) @@ -170,9 +173,11 @@ class PotentialFunctionProvider(BasePotential): allow_iid_x = True # type: ignore - def __init__(self, prior, x_o, device="cpu"): + def __init__(self, prior, x_o, concentration_scaling=1.0, device="cpu"): super().__init__(prior, x_o, device) + self.concentration_scaling = concentration_scaling + def __call__(self, theta, track_gradients: bool = True): theta = atleast_2d(theta) @@ -195,7 +200,8 @@ def iid_likelihood(self, theta: torch.Tensor) -> torch.Tensor: lp_rts = torch.stack( [ InverseGamma( - concentration=2 * torch.ones_like(beta_i), rate=beta_i + concentration=self.concentration_scaling * torch.ones_like(beta_i), + rate=beta_i, ).log_prob(self.x_o[:, :1]) for beta_i in theta[:, :1] ], @@ -207,3 +213,74 @@ def iid_likelihood(self, theta: torch.Tensor) -> torch.Tensor: ) return joint_likelihood.sum(0) + + +@pytest.mark.slow +def test_mnle_with_experiment_conditions(): + def sim_wrapper(theta): + # simulate with experiment conditions + return mixed_simulator(theta[:, :2], theta[:, 2:] + 1) + + proposal = MultipleIndependent( + [ + Gamma(torch.tensor([1.0]), torch.tensor([0.5])), + Beta(torch.tensor([2.0]), torch.tensor([2.0])), + Categorical(probs=torch.ones(1, 3)), + ], + validate_args=False, + ) + + num_simulations = 10000 + num_samples = 1000 + theta = proposal.sample((num_simulations,)) + x = sim_wrapper(theta) + assert x.shape == (num_simulations, 2) + + num_trials = 10 + theta_o = proposal.sample((1,)) + theta_o[0, 2] = 2.0 # set condition to 2 as in original simulator. + x_o = sim_wrapper(theta_o.repeat(num_trials, 1)) + + # MNLE + trainer = MNLE(proposal) + estimator = trainer.append_simulations(theta, x).train(max_num_epochs=1) + + potential_fn = MixedLikelihoodBasedPotential(estimator, proposal, x_o) + + conditioned_potential_fn = ConditionedPotential( + potential_fn, condition=theta_o, dims_to_sample=[0, 1], allow_iid_x=True + ) + + # True posterior samples + prior = MultipleIndependent( + [ + Gamma(torch.tensor([1.0]), torch.tensor([0.5])), + Beta(torch.tensor([2.0]), torch.tensor([2.0])), + ], + validate_args=False, + ) + prior_transform = mcmc_transform(prior) + true_posterior_samples = MCMCPosterior( + PotentialFunctionProvider( + prior, + atleast_2d(x_o), + concentration_scaling=float(theta_o[0, 2]) + + 1.0, # add one because the sim_wrapper adds one (see above) + ), + theta_transform=prior_transform, + proposal=prior, + **mcmc_kwargs, + ).sample((num_samples,), x=x_o) + + mcmc_posterior = MCMCPosterior( + potential_fn=conditioned_potential_fn, + theta_transform=prior_transform, + proposal=prior, + ) + cond_samples = mcmc_posterior.sample((num_samples,), x=x_o) + + check_c2st( + cond_samples, + true_posterior_samples, + alg="MNLE with experiment conditions", + )