diff --git a/sbi/inference/potentials/likelihood_based_potential.py b/sbi/inference/potentials/likelihood_based_potential.py index f382968cd..8066d3dd1 100644 --- a/sbi/inference/potentials/likelihood_based_potential.py +++ b/sbi/inference/potentials/likelihood_based_potential.py @@ -1,7 +1,8 @@ # This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed # under the Apache License Version 2.0, see -from typing import Callable, Optional, Tuple +import warnings +from typing import Callable, List, Optional, Tuple import torch from torch import Tensor @@ -115,6 +116,54 @@ def __call__(self, theta: Tensor, track_gradients: bool = True) -> Tensor: ) return log_likelihood_batches + self.prior.log_prob(theta) # type: ignore + def condition_on_theta( + self, local_theta: Tensor, dims_global_theta: List[int] + ) -> Callable: + r"""Returns a potential function conditioned on a subset of theta dimensions. + + The goal of this function is to divide the original `theta` into a + `global_theta` we do inference over, and a `local_theta` we condition on (in + addition to conditioning on `x_o`). Thus, the returned potential function will + calculate $\prod_{i=1}^{N}p(x_i | local_theta_i, \global_theta)$, where `x_i` + and `local_theta_i` are fixed and `global_theta` varies at inference time. + + Args: + local_theta: The condition values to be conditioned. + dims_global_theta: The indices of the columns in `theta` that will be + sampled, i.e., that *not* conditioned. For example, if original theta + has shape `(batch_dim, 3)`, and `dims_global_theta=[0, 1]`, then the + potential will set `theta[:, 3] = local_theta` at inference time. + + Returns: + A potential function conditioned on the `local_theta`. + """ + + assert self.x_is_iid, "Conditioning is only supported for iid data." + + def conditioned_potential( + theta: Tensor, x_o: Optional[Tensor] = None, track_gradients: bool = True + ) -> Tensor: + assert ( + len(dims_global_theta) == theta.shape[1] + ), "dims_global_theta must match the number of parameters to sample." + global_theta = theta[:, dims_global_theta] + x_o = x_o if x_o is not None else self.x_o + # x needs shape (sample_dim (iid), batch_dim (xs), *event_shape) + if x_o.dim() < 3: + x_o = reshape_to_sample_batch_event( + x_o, event_shape=x_o.shape[1:], leading_is_sample=self.x_is_iid + ) + + return _log_likelihood_over_iid_trials_and_local_theta( + x=x_o, + global_theta=global_theta, + local_theta=local_theta, + estimator=self.likelihood_estimator, + track_gradients=track_gradients, + ) + + return conditioned_potential + def _log_likelihoods_over_trials( x: Tensor, @@ -172,6 +221,77 @@ def _log_likelihoods_over_trials( return log_likelihood_trial_sum +def _log_likelihood_over_iid_trials_and_local_theta( + x: Tensor, + global_theta: Tensor, + local_theta: Tensor, + estimator: ConditionalDensityEstimator, + track_gradients: bool = False, +) -> Tensor: + """Returns $\\prod_{i=1}^N \\log(p(x_i|\theta, local_theta_i)$. + + `x` is a batch of iid data, and `local_theta` is a matching batch of condition + values that were part of `theta` but are treated as local iid variables at inference + time. + + This function is different from `_log_likelihoods_over_trials` in that it moves the + iid batch dimension of `x` onto the batch dimension of `theta`. This is needed when + the likelihood estimator is conditioned on a batch of conditions that are iid with + the batch of `x`. It avoids the evaluation of the likelihood for every combination + of `x` and `local_theta`. + + Args: + x: data with shape `(sample_dim, x_batch_dim, *x_event_shape)`, where sample_dim + holds the i.i.d. trials and batch_dim holds a batch of xs, e.g., non-iid + observations. + global_theta: Batch of parameters `(theta_batch_dim, + num_parameters)`. + local_theta: Batch of conditions of shape `(sample_dim, num_local_thetas)`, must + match x's `sample_dim`. + estimator: DensityEstimator. + track_gradients: Whether to track gradients. + + Returns: + log_likelihood: log likelihood for each x in x_batch_dim, for each theta in + theta_batch_dim, summed over all iid trials. Shape `(x_batch_dim, + theta_batch_dim)`. + """ + assert x.dim() > 2, "x must have shape (sample_dim, batch_dim, *event_shape)." + assert ( + local_theta.dim() == 2 + ), "condition must have shape (sample_dim, num_conditions)." + assert global_theta.dim() == 2, "theta must have shape (batch_dim, num_parameters)." + num_trials, num_xs = x.shape[:2] + num_thetas = global_theta.shape[0] + assert ( + local_theta.shape[0] == num_trials + ), "Condition batch size must match the number of iid trials in x." + + # move the iid batch dimension onto the batch dimension of theta and repeat it there + x_repeated = torch.transpose(x, 0, 1).repeat_interleave(num_thetas, dim=1) + + # construct theta and condition to cover all trial-theta combinations + theta_with_condition = torch.cat( + [ + global_theta.repeat(num_trials, 1), # repeat ABAB + local_theta.repeat_interleave(num_thetas, dim=0), # repeat AABB + ], + dim=-1, + ) + + with torch.set_grad_enabled(track_gradients): + # Calculate likelihood in one batch. Returns (1, num_trials * num_theta) + log_likelihood_trial_batch = estimator.log_prob( + x_repeated, condition=theta_with_condition + ) + # Reshape to (x-trials x parameters), sum over trial-log likelihoods. + log_likelihood_trial_sum = log_likelihood_trial_batch.reshape( + num_xs, num_trials, num_thetas + ).sum(1) + + return log_likelihood_trial_sum + + def mixed_likelihood_estimator_based_potential( likelihood_estimator: MixedDensityEstimator, prior: Distribution, @@ -192,6 +312,13 @@ def mixed_likelihood_estimator_based_potential( to unconstrained space. """ + warnings.warn( + "This function is deprecated and will be removed in a future release. Use " + "`likelihood_estimator_based_potential` instead.", + DeprecationWarning, + stacklevel=2, + ) + device = str(next(likelihood_estimator.discrete_net.parameters()).device) potential_fn = MixedLikelihoodBasedPotential( @@ -212,6 +339,13 @@ def __init__( ): super().__init__(likelihood_estimator, prior, x_o, device) + warnings.warn( + "This function is deprecated and will be removed in a future release. Use " + "`LikelihoodBasedPotential` instead.", + DeprecationWarning, + stacklevel=2, + ) + def __call__(self, theta: Tensor, track_gradients: bool = True) -> Tensor: prior_log_prob = self.prior.log_prob(theta) # type: ignore @@ -231,7 +365,6 @@ def __call__(self, theta: Tensor, track_gradients: bool = True) -> Tensor: with torch.set_grad_enabled(track_gradients): # Call the specific log prob method of the mixed likelihood estimator as # this optimizes the evaluation of the discrete data part. - # TODO log_prob_iid log_likelihood_trial_batch = self.likelihood_estimator.log_prob( input=x, condition=theta.to(self.device), diff --git a/sbi/inference/trainers/nle/mnle.py b/sbi/inference/trainers/nle/mnle.py index d01ce1e91..83622eaea 100644 --- a/sbi/inference/trainers/nle/mnle.py +++ b/sbi/inference/trainers/nle/mnle.py @@ -7,7 +7,7 @@ from torch.distributions import Distribution from sbi.inference.posteriors import MCMCPosterior, RejectionPosterior, VIPosterior -from sbi.inference.potentials import mixed_likelihood_estimator_based_potential +from sbi.inference.potentials import likelihood_estimator_based_potential from sbi.inference.trainers.nle.nle_base import LikelihoodEstimator from sbi.neural_nets.estimators import MixedDensityEstimator from sbi.sbi_types import TensorboardSummaryWriter, TorchModule @@ -155,9 +155,7 @@ def build_posterior( ( potential_fn, theta_transform, - ) = mixed_likelihood_estimator_based_potential( - likelihood_estimator=likelihood_estimator, prior=prior, x_o=None - ) + ) = likelihood_estimator_based_potential(likelihood_estimator, prior, x_o=None) if sample_with == "mcmc": self._posterior = MCMCPosterior( diff --git a/sbi/utils/conditional_density_utils.py b/sbi/utils/conditional_density_utils.py index d6c73b7c9..829f5e1df 100644 --- a/sbi/utils/conditional_density_utils.py +++ b/sbi/utils/conditional_density_utils.py @@ -293,7 +293,7 @@ def __init__( masked outside of prior. """ condition = torch.atleast_2d(condition) - if condition.shape[0] != 1: + if condition.shape[0] > 1: raise ValueError("Condition with batch size > 1 not supported.") self.potential_fn = potential_fn diff --git a/sbi/utils/sbiutils.py b/sbi/utils/sbiutils.py index fcb5953d9..fc01d4dbd 100644 --- a/sbi/utils/sbiutils.py +++ b/sbi/utils/sbiutils.py @@ -60,8 +60,8 @@ def warn_if_zscoring_changes_data(x: Tensor, duplicate_tolerance: float = 0.1) - if num_unique_z < num_unique * (1 - duplicate_tolerance): warnings.warn( - "Z-scoring these simulation outputs resulted in {num_unique_z} unique " - "datapoints. Before z-scoring, it had been {num_unique}. This can " + f"Z-scoring these simulation outputs resulted in {num_unique_z} unique " + f"datapoints. Before z-scoring, it had been {num_unique}. This can " "occur due to numerical inaccuracies when the data covers a large " "range of values. Consider either setting `z_score_x=False` (but " "beware that this can be problematic for training the NN) or exclude " diff --git a/tests/mnle_test.py b/tests/mnle_test.py index a95a2a6ac..099876a3e 100644 --- a/tests/mnle_test.py +++ b/tests/mnle_test.py @@ -1,29 +1,32 @@ # This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed # under the Apache License Version 2.0, see +from typing import Union + import pytest import torch from pyro.distributions import InverseGamma -from torch.distributions import Beta, Binomial, Categorical, Gamma +from torch import Tensor +from torch.distributions import Beta, Binomial, Distribution, Gamma from sbi.inference import MNLE, MCMCPosterior 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, + _log_likelihood_over_iid_trials_and_local_theta, + likelihood_estimator_based_potential, ) from sbi.neural_nets import likelihood_nn from sbi.neural_nets.embedding_nets import FCEmbedding from sbi.utils import BoxUniform, mcmc_transform -from sbi.utils.conditional_density_utils import ConditionedPotential from sbi.utils.torchutils import atleast_2d, process_device from sbi.utils.user_input_checks_utils import MultipleIndependent from tests.test_utils import check_c2st # toy simulator for mixed data -def mixed_simulator(theta, stimulus_condition=2.0): +def mixed_simulator(theta: Tensor, stimulus_condition: Union[Tensor, float] = 2.0): """Simulator for mixed data.""" # Extract parameters beta, ps = theta[:, :1], theta[:, 1:] @@ -37,6 +40,15 @@ def mixed_simulator(theta, stimulus_condition=2.0): return torch.cat((rts, choices), dim=1) +def wrapped_simulator( + theta_and_condition: Tensor, last_idx_parameters: int = 2 +) -> Tensor: + # simulate with experiment conditions + theta = theta_and_condition[:, :last_idx_parameters] + condition = theta_and_condition[:, last_idx_parameters:] + return mixed_simulator(theta, condition) + + @pytest.mark.mcmc @pytest.mark.gpu @pytest.mark.parametrize("device", ("cpu", "gpu")) @@ -190,11 +202,28 @@ def test_mnle_accuracy_with_different_samplers_and_trials( class BinomialGammaPotential(BasePotential): - def __init__(self, prior, x_o, concentration_scaling=1.0, device="cpu"): + """Binomial-Gamma potential for mixed data.""" + + def __init__( + self, + prior: Distribution, + x_o: Tensor, + concentration_scaling: Union[Tensor, float] = 1.0, + device="cpu", + ): super().__init__(prior, x_o, device) + + # concentration_scaling needs to be a float or match the batch size + if isinstance(concentration_scaling, Tensor): + num_trials = x_o.shape[0] + assert concentration_scaling.shape[0] == num_trials + + # Reshape to match convention (batch_size, num_trials, *event_shape) + concentration_scaling = concentration_scaling.reshape(1, num_trials, -1) + self.concentration_scaling = concentration_scaling - def __call__(self, theta, track_gradients: bool = True): + def __call__(self, theta: Tensor, track_gradients: bool = True) -> Tensor: theta = atleast_2d(theta) with torch.set_grad_enabled(track_gradients): @@ -202,11 +231,12 @@ def __call__(self, theta, track_gradients: bool = True): return iid_ll + self.prior.log_prob(theta) - def iid_likelihood(self, theta): + def iid_likelihood(self, theta: Tensor) -> Tensor: batch_size = theta.shape[0] num_trials = self.x_o.shape[0] theta = theta.reshape(batch_size, 1, -1) beta, rho = theta[:, :, :1], theta[:, :, 1:] + # vectorized logprob_choices = Binomial(probs=rho).log_prob( self.x_o[:, 1:].reshape(1, num_trials, -1) @@ -233,43 +263,44 @@ def test_mnle_with_experimental_conditions(mcmc_params_accurate: dict): categorical parameter is set to a fixed value (conditioned posterior), and the accuracy of the conditioned posterior is tested against the true posterior. """ - num_simulations = 6000 - num_samples = 500 - - def sim_wrapper(theta): - # simulate with experiment conditions - return mixed_simulator(theta[:, :2], theta[:, 2:] + 1) + num_simulations = 10000 + num_samples = 1000 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)), + BoxUniform(torch.tensor([0.0]), torch.tensor([1.0])), ], validate_args=False, ) theta = proposal.sample((num_simulations,)) - x = sim_wrapper(theta) + x = wrapped_simulator(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)) + theta_and_condition = proposal.sample((num_trials,)) + # use only a single parameter (iid trials) + theta_o = theta_and_condition[:1, :2].repeat(num_trials, 1) + # but different conditions + condition_o = theta_and_condition[:, 2:] + theta_and_conditions_o = torch.cat((theta_o, condition_o), dim=1) + + x_o = wrapped_simulator(theta_and_conditions_o) mcmc_kwargs = dict( method="slice_np_vectorized", init_strategy="proposal", **mcmc_params_accurate ) # MNLE - trainer = MNLE(proposal) - estimator = trainer.append_simulations(theta, x).train(training_batch_size=1000) - - potential_fn = MixedLikelihoodBasedPotential(estimator, proposal, x_o) + estimator_fun = likelihood_nn(model="mnle", z_score_x=None) + trainer = MNLE(proposal, estimator_fun) + estimator = trainer.append_simulations(theta, x).train() - conditioned_potential_fn = ConditionedPotential( - potential_fn, condition=theta_o, dims_to_sample=[0, 1] + potential_fn, _ = likelihood_estimator_based_potential(estimator, proposal, x_o) + conditioned_potential_fn = potential_fn.condition_on_theta( + condition_o, dims_global_theta=[0, 1] ) # True posterior samples @@ -283,10 +314,7 @@ def sim_wrapper(theta): prior_transform = mcmc_transform(prior) true_posterior_samples = MCMCPosterior( BinomialGammaPotential( - prior, - atleast_2d(x_o), - concentration_scaling=float(theta_o[0, 2]) - + 1.0, # add one because the sim_wrapper adds one (see above) + prior, atleast_2d(x_o), concentration_scaling=condition_o ), theta_transform=prior_transform, proposal=prior, @@ -303,5 +331,86 @@ def sim_wrapper(theta): check_c2st( cond_samples, true_posterior_samples, - alg=f"MNLE trained with {num_simulations}", + alg=f"MNLE trained with {num_simulations} simulations", + ) + + +@pytest.mark.parametrize("num_thetas", [1, 10]) +@pytest.mark.parametrize("num_trials", [1, 5]) +@pytest.mark.parametrize("num_xs", [1, 3]) +@pytest.mark.parametrize( + "num_conditions", + [ + 1, + pytest.param( + 2, + marks=pytest.mark.xfail( + reason="Batched theta_condition is not " "supported" + ), + ), + ], +) +def test_log_likelihood_over_local_iid_theta( + num_thetas, num_trials, num_xs, num_conditions +): + """Test log likelihood over iid conditions using MNLE. + + Args: + num_thetas: batch of theta to condition on. + num_trials: number of i.i.d. trials in x + num_xs: batch of x, e.g., different subjects in a study. + num_conditions: number of batches of conditions, e.g., different conditions + for each x (not implemented yet). + """ + + # train mnle on mixed data + trainer = MNLE( + density_estimator=likelihood_nn(model="mnle", z_score_x=None), ) + proposal = MultipleIndependent( + [ + Gamma(torch.tensor([1.0]), torch.tensor([0.5])), + Beta(torch.tensor([2.0]), torch.tensor([2.0])), + BoxUniform(torch.tensor([0.0]), torch.tensor([1.0])), + ], + validate_args=False, + ) + + num_simulations = 100 + theta = proposal.sample((num_simulations,)) + x = wrapped_simulator(theta) + estimator = trainer.append_simulations(theta, x).train(max_num_epochs=1) + + # condition on multiple conditions + theta_o = proposal.sample((num_xs,))[:, :2] + + x_o = torch.zeros(num_trials, num_xs, 2) + condition_o = proposal.sample(( + num_conditions, + num_trials, + ))[:, 2:].reshape(num_trials, 1) + for i in range(num_xs): + # simulate with same iid theta but different conditions + x_o[:, i, :] = mixed_simulator(theta_o[i].repeat(num_trials, 1), condition_o) + + # batched conditioning + theta = proposal.sample((num_thetas,))[:, :2] + # x_o has shape (iid, batch, *event) + # condition_o has shape (iid, num_conditions) + ll_batched = _log_likelihood_over_iid_trials_and_local_theta( + x_o, theta, condition_o, estimator + ) + + # looped conditioning + ll_single = [] + for i in range(num_trials): + theta_and_condition = torch.cat( + (theta, condition_o[i].repeat(num_thetas, 1)), dim=1 + ) + x_i = x_o[i].reshape(num_xs, 1, -1).repeat(1, num_thetas, 1) + ll_single.append(estimator.log_prob(input=x_i, condition=theta_and_condition)) + ll_single = torch.stack(ll_single).sum(0) # sum over trials + + assert ll_batched.shape == torch.Size([num_xs, num_thetas]) + assert ll_batched.shape == ll_single.shape + assert torch.allclose(ll_batched, ll_single, atol=1e-5) diff --git a/tutorials/Example_01_DecisionMakingModel.ipynb b/tutorials/Example_01_DecisionMakingModel.ipynb index fcfa10ced..eb16182c2 100644 --- a/tutorials/Example_01_DecisionMakingModel.ipynb +++ b/tutorials/Example_01_DecisionMakingModel.ipynb @@ -73,32 +73,23 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING (pytensor.tensor.blas): Using NumPy C-API based implementation for BLAS functions.\n" - ] - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import torch\n", "from pyro.distributions import InverseGamma\n", "from torch import Tensor\n", - "from torch.distributions import Beta, Binomial, Categorical, Gamma\n", + "from torch.distributions import Beta, Binomial, Gamma\n", "\n", "from sbi.analysis import pairplot\n", "from sbi.inference import MNLE, MCMCPosterior\n", - "from sbi.inference.potentials.base_potential import BasePotential\n", - "from sbi.inference.potentials.likelihood_based_potential import (\n", - " MixedLikelihoodBasedPotential,\n", - ")\n", - "from sbi.utils import MultipleIndependent, mcmc_transform\n", - "from sbi.utils.conditional_density_utils import ConditionedPotential\n", + "from sbi.inference.potentials.likelihood_based_potential import LikelihoodBasedPotential\n", + "from sbi.neural_nets import likelihood_nn\n", + "from sbi.utils import BoxUniform, MultipleIndependent, mcmc_transform\n", "from sbi.utils.metrics import c2st\n", - "from sbi.utils.torchutils import atleast_2d" + "\n", + "\n", + "from example_01_utils import BinomialGammaPotential" ] }, { @@ -124,44 +115,7 @@ " 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\n", - "# obtain reference posterior samples via MCMC.\n", - "class BinomialGammaPotential(BasePotential):\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", - " batch_size = theta.shape[0]\n", - " num_trials = self.x_o.shape[0]\n", - " theta = theta.reshape(batch_size, 1, -1)\n", - " beta, rho = theta[:, :, :1], theta[:, :, 1:]\n", - " # vectorized\n", - " logprob_choices = Binomial(probs=rho).log_prob(\n", - " self.x_o[:, 1:].reshape(1, num_trials, -1)\n", - " )\n", - "\n", - " logprob_rts = InverseGamma(\n", - " concentration=self.concentration_scaling * torch.ones_like(beta),\n", - " rate=beta,\n", - " ).log_prob(self.x_o[:, :1].reshape(1, num_trials, -1))\n", - "\n", - " joint_likelihood = (logprob_choices + logprob_rts).squeeze()\n", - "\n", - " assert joint_likelihood.shape == torch.Size([theta.shape[0], self.x_o.shape[0]])\n", - " return joint_likelihood.sum(1)" + " return torch.cat((rts, choices), dim=1)" ] }, { @@ -205,18 +159,10 @@ "execution_count": 5, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/janteusen/qode/sbi/sbi/inference/posteriors/mcmc_posterior.py:115: UserWarning: The default value for thinning in MCMC sampling has been changed from 10 to 1. This might cause the results differ from the last benchmark.\n", - " thin = _process_thin_default(thin)\n" - ] - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8070275b9eac45d1991d5be41935c145", + "model_id": "92513794bbd148b29b5d60d566338bf6", "version_major": 2, "version_minor": 0 }, @@ -234,6 +180,7 @@ " warmup_steps=50,\n", " method=\"slice_np_vectorized\",\n", " init_strategy=\"proposal\",\n", + " thin=1,\n", ")\n", "\n", "true_posterior = MCMCPosterior(\n", @@ -269,13 +216,13 @@ "name": "stdout", "output_type": "stream", "text": [ - " Neural network successfully converged after 65 epochs." + " Neural network successfully converged after 75 epochs." ] } ], "source": [ "# Training data\n", - "num_simulations = 20000\n", + "num_simulations = 10000\n", "# For training the MNLE emulator we need to define a proposal distribution, the prior is\n", "# a good choice.\n", "proposal = prior\n", @@ -284,7 +231,7 @@ "\n", "# Train MNLE and obtain MCMC-based posterior.\n", "trainer = MNLE()\n", - "estimator = trainer.append_simulations(theta, x).train(training_batch_size=1000)" + "estimator = trainer.append_simulations(theta, x).train()" ] }, { @@ -292,10 +239,18 @@ "execution_count": 7, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/janteusen/qode/sbi/sbi/inference/posteriors/mcmc_posterior.py:115: UserWarning: The default value for thinning in MCMC sampling has been changed from 10 to 1. This might cause the results differ from the last benchmark.\n", + " thin = _process_thin_default(thin)\n" + ] + }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1a7792c605404a11a586681fcd3c0a32", + "model_id": "548e67900bd3494481dc61d0f11db250", "version_major": 2, "version_minor": 0 }, @@ -328,7 +283,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -390,7 +345,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fb02120c58a54d029953b4c589f24eca", + "model_id": "21f980fc4f794fe1ab2090ad53a0e323", "version_major": 2, "version_minor": 0 }, @@ -404,7 +359,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1cd3bc58ca8e4a21b1df2812fad8bf45", + "model_id": "418d47f1f4864c089bf68e1a119ebb7d", "version_major": 2, "version_minor": 0 }, @@ -430,7 +385,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -477,7 +432,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "c2st between true and MNLE posterior: 0.593\n" + "c2st between true and MNLE posterior: 0.5155000000000001\n" ] } ], @@ -515,16 +470,26 @@ "metadata": {}, "outputs": [], "source": [ + "# Define a proposal that contains both, priors for the parameters and a discrte\n", + "# 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", + " BoxUniform(torch.tensor([0.0]), torch.tensor([1.0])),\n", + " ],\n", + " validate_args=False,\n", + ")\n", + "\n", "# define a simulator wrapper in which the experimental condition are contained\n", "# in theta and passed to the simulator.\n", - "def sim_wrapper(theta):\n", + "def sim_wrapper(theta_and_conditions):\n", " # simulate with experiment conditions\n", " return mixed_simulator(\n", " # we assume the first two parameters are beta and rho\n", - " theta=theta[:, :2],\n", + " theta=theta_and_conditions[:, :2],\n", " # we treat the third concentration parameter as an experimental condition\n", - " # add 1 to deal with 0 values from Categorical distribution\n", - " concentration_scaling=theta[:, 2:] + 1,\n", + " concentration_scaling=theta_and_conditions[:, 2:],\n", " )" ] }, @@ -534,17 +499,6 @@ "metadata": {}, "outputs": [], "source": [ - "# Define a proposal that contains both, priors for the parameters and a discrte\n", - "# 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)), # 3 discrete conditions\n", - " ],\n", - " validate_args=False,\n", - ")\n", - "\n", "# Simulated data\n", "num_simulations = 10000\n", "num_samples = 1000\n", @@ -554,10 +508,13 @@ "\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", - "# NOTE: we use the same experimental condition for all trials.\n", - "x_o = sim_wrapper(theta_o.repeat(num_trials, 1))" + "# draw one ground truth parameter\n", + "theta_o = proposal.sample((1,))[:, :2]\n", + "# draw num_trials many different conditions\n", + "conditions = proposal.sample((num_trials,))[:, 2:]\n", + "# Theta is repeated for each trial, conditions are different for each trial.\n", + "theta_and_conditions_o = torch.cat((theta_o.repeat(num_trials, 1), conditions), dim=1)\n", + "x_o = sim_wrapper(theta_and_conditions_o)" ] }, { @@ -566,11 +523,15 @@ "source": [ "#### Obtain ground truth posterior via MCMC\n", "\n", - "We obtain a ground-truth posterior via MCMC by using the PotentialFunctionProvider.\n", + "We obtain a ground-truth posterior via MCMC by using the analytical Binomial-Gamma\n", + "likelihood as before. \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", + "For that, we first the define the actual prior, i.e., the distribution over the\n", + "parameter we want to infer (not the proposal). (dropping the uniform prior over\n", + "experimental conditions).\n", "\n", - "Thus, we leave out the discrete prior over experimental conditions.\n" + "Additionally, we pass the entire batch of i.i.d. data `x_o` and matching batch of i.i.d.\n", + "`conditions`.\n" ] }, { @@ -578,18 +539,10 @@ "execution_count": 14, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/janteusen/qode/sbi/sbi/inference/posteriors/mcmc_posterior.py:115: UserWarning: The default value for thinning in MCMC sampling has been changed from 10 to 1. This might cause the results differ from the last benchmark.\n", - " thin = _process_thin_default(thin)\n" - ] - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ad169fdca3da40649e6e1c329460e355", + "model_id": "ee7db79e47674ed3b2574c26b09eb0b2", "version_major": 2, "version_minor": 0 }, @@ -617,8 +570,7 @@ " BinomialGammaPotential(\n", " prior,\n", " x_o,\n", - " concentration_scaling=float(theta_o[0, 2])\n", - " + 1.0, # add one because the sim_wrapper adds one (see above)\n", + " concentration_scaling=conditions,\n", " ),\n", " theta_transform=prior_transform,\n", " proposal=prior,\n", @@ -630,7 +582,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Train MNLE including experimental conditions\n" + "### Train MNLE including experimental conditions\n", + "\n", + "Next, we use the combined parameters and conditions (`theta`) and the corresponding\n", + "simulated data to train `MNLE`.\n" ] }, { @@ -642,6 +597,8 @@ "name": "stderr", "output_type": "stream", "text": [ + "/Users/janteusen/qode/sbi/sbi/inference/trainers/base.py:271: UserWarning: Z-scoring these simulation outputs resulted in 4 unique datapoints. Before z-scoring, it had been 19872. This can occur due to numerical inaccuracies when the data covers a large range of values. Consider either setting `z_score_x=False` (but beware that this can be problematic for training the NN) or exclude outliers from your dataset. Note: if you have already set `z_score_x=False`, this warning will still be displayed, but you can ignore it.\n", + " warn_if_zscoring_changes_data(x)\n", "/Users/janteusen/qode/sbi/sbi/neural_nets/factory.py:205: UserWarning: The mixed neural likelihood estimator assumes that x contains continuous data in the first n-1 columns (e.g., reaction times) and categorical data in the last column (e.g., corresponding choices). If this is not the case for the passed `x` do not use this function.\n", " return model_builders[model](batch_x=batch_x, batch_y=batch_theta, **kwargs)\n" ] @@ -650,12 +607,13 @@ "name": "stdout", "output_type": "stream", "text": [ - " Neural network successfully converged after 60 epochs." + " Neural network successfully converged after 75 epochs." ] } ], "source": [ - "trainer = MNLE(proposal)\n", + "estimator_builder = likelihood_nn(model=\"mnle\", z_score_x=None) # we don't want to z-score the binary data.\n", + "trainer = MNLE(proposal, estimator_builder)\n", "estimator = trainer.append_simulations(theta, x).train()" ] }, @@ -681,28 +639,147 @@ "outputs": [ { "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4f887f2ba37a4782964e838895cfc39e", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "torch.Size([1, 3])" + "Running vectorized MCMC with 20 chains: 0%| | 0/3000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Finally, we can compare the ground truth conditional posterior with the\n", + "# 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", + " diag_kwargs=dict(bins=100),\n", + " upper_kwargs=dict(levels=[0.95]),\n", + " fig_kwargs=dict(\n", + " points_offdiag=dict(marker=\"*\", markersize=10),\n", + " points_colors=[\"k\"],\n", + "\n", + " ),\n", + " labels=[r\"$\\beta$\", r\"$\\rho$\"],\n", + " figsize=(6, 6),\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", + ");\n", + "print(\"c2st between true and MNLE posterior:\", c2st(true_posterior_samples, conditional_samples).item())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "They match accurately, showing that we can indeed post-hoc condition the trained MNLE likelihood on different experimental conditions.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference with multiple subjects, trials, and conditions\n", + "\n", + "Note that we can also do inference for multiple `x_os` (e.g., subjects) with varying\n", + "numbers of trails and experimental conditions - all without retraining the MNLE.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "54115a1a0f534028b377fa5aa4661dc4", + "model_id": "ed79d139f3804547ab14ea8dcdea856e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running vectorized MCMC with 20 chains: 0%| | 0/3000 [00:00" ] @@ -754,15 +845,11 @@ } ], "source": [ - "# Finally, we can compare the ground truth conditional posterior with the\n", - "# MNLE-conditional posterior.\n", + "# Plotting all three posteriors in one pairplot.\n", + "\n", "fig, ax = pairplot(\n", - " [\n", - " prior.sample((1000,)),\n", - " true_posterior_samples,\n", - " conditional_samples,\n", - " ],\n", - " points=theta_o,\n", + " [prior.sample((1000,))] + posterior_samples,\n", + " # points=theta_o,\n", " diag=\"kde\",\n", " upper=\"contour\",\n", " diag_kwargs=dict(bins=100),\n", @@ -770,13 +857,15 @@ " fig_kwargs=dict(\n", " points_offdiag=dict(marker=\"*\", markersize=10),\n", " points_colors=[\"k\"],\n", + "\n", " ),\n", " labels=[r\"$\\beta$\", r\"$\\rho$\"],\n", + " figsize=(10, 10),\n", ")\n", "\n", "plt.sca(ax[1, 1])\n", "plt.legend(\n", - " [\"Prior\", \"Reference\", \"MNLE\", r\"$\\theta_o$\"],\n", + " [\"prior\"] + [f\"Subject {idx+1}\" for idx in range(num_subjects)],\n", " frameon=False,\n", " fontsize=12,\n", ");" @@ -786,13 +875,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "They match accurately, showing that we can indeed post-hoc condition the trained MNLE likelihood on different experimental conditions.\n" + "Note how the posteriors are becoming more narrow with increasing number of trials\n", + "(subject 1: 10 trials vs. subject 3: 30 trials)." ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('sbi')", + "display_name": "sbi_env", "language": "python", "name": "python3" }, @@ -806,12 +896,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.4" - }, - "vscode": { - "interpreter": { - "hash": "9ef9b53a5ce850816b9705a866e49207a37a04a71269aa157d9f9ab944ea42bf" - } + "version": "3.10.13" } }, "nbformat": 4, diff --git a/tutorials/example_01_utils.py b/tutorials/example_01_utils.py new file mode 100644 index 000000000..620058d05 --- /dev/null +++ b/tutorials/example_01_utils.py @@ -0,0 +1,60 @@ +from typing import Union + +import torch +from torch import Tensor +from torch.distributions import Binomial, Distribution, InverseGamma + +from sbi.inference.potentials.base_potential import BasePotential +from sbi.utils.torchutils import atleast_2d + + +class BinomialGammaPotential(BasePotential): + """Binomial-Gamma potential for mixed data.""" + + def __init__( + self, + prior: Distribution, + x_o: Tensor, + concentration_scaling: Union[Tensor, float] = 1.0, + device="cpu", + ): + super().__init__(prior, x_o, device) + + # concentration_scaling needs to be a float or match the batch size + if isinstance(concentration_scaling, Tensor): + num_trials = x_o.shape[0] + assert concentration_scaling.shape[0] == num_trials + + # Reshape to match convention (batch_size, num_trials, *event_shape) + concentration_scaling = concentration_scaling.reshape(1, num_trials, -1) + + self.concentration_scaling = concentration_scaling + + def __call__(self, theta: Tensor, track_gradients: bool = True) -> Tensor: + theta = atleast_2d(theta) + + with torch.set_grad_enabled(track_gradients): + iid_ll = self.iid_likelihood(theta) + + return iid_ll + self.prior.log_prob(theta) + + def iid_likelihood(self, theta: Tensor) -> Tensor: + batch_size = theta.shape[0] + num_trials = self.x_o.shape[0] + theta = theta.reshape(batch_size, 1, -1) + beta, rho = theta[:, :, :1], theta[:, :, 1:] + + # vectorized + logprob_choices = Binomial(probs=rho).log_prob( + self.x_o[:, 1:].reshape(1, num_trials, -1) + ) + + logprob_rts = InverseGamma( + concentration=self.concentration_scaling * torch.ones_like(beta), + rate=beta, + ).log_prob(self.x_o[:, :1].reshape(1, num_trials, -1)) + + joint_likelihood = (logprob_choices + logprob_rts).squeeze() + + assert joint_likelihood.shape == torch.Size([theta.shape[0], self.x_o.shape[0]]) + return joint_likelihood.sum(1)