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, ?it/s]"
]
},
- "execution_count": 16,
"metadata": {},
- "output_type": "execute_result"
+ "output_type": "display_data"
}
],
"source": [
- "theta_o.shape"
+ "# First, we define the potential function for the complete, unconditional MNLE-likelihood\n",
+ "potential_fn = LikelihoodBasedPotential(estimator, proposal)\n",
+ "# Then, we condition on the experimental conditions.\n",
+ "conditioned_potential_fn = potential_fn.condition_on_theta(\n",
+ " conditions, # pass only the conditions, must match the batch of iid data in x_o\n",
+ " dims_global_theta=[0, 1] # pass the dimensions in the original theta that correspond to beta and rho\n",
+ ")\n",
+ "\n",
+ "# Using this potential function, we can now obtain conditional samples.\n",
+ "mnle_posterior = MCMCPosterior(\n",
+ " potential_fn=conditioned_potential_fn, # pass the conditioned potential function\n",
+ " theta_transform=prior_transform,\n",
+ " proposal=prior, # pass the prior, not the proposal.\n",
+ " **mcmc_kwargs\n",
+ ")\n",
+ "conditional_samples = mnle_posterior.sample((num_samples,), x=x_o)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "c2st between true and MNLE posterior: 0.551\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "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, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "b821d7229001426f9d541c3dd4fdcead",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Running vectorized MCMC with 20 chains: 0%| | 0/3000 [00:00, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "abb52c1815e14845acf1ec9c50b91000",
"version_major": 2,
"version_minor": 0
},
@@ -715,36 +792,50 @@
}
],
"source": [
- "# We define the potential function for the complete, unconditional MNLE-likelihood\n",
- "potential_fn = MixedLikelihoodBasedPotential(estimator, proposal, x_o)\n",
"\n",
- "# Then we use the potential to construct the conditional potential function.\n",
- "# Here, we tell the constructor to condition on the last dimension (index 2) by\n",
- "# passing dims_to_sample=[0, 1].\n",
- "conditioned_potential_fn = ConditionedPotential(\n",
- " potential_fn,\n",
- " condition=theta_o,\n",
- " dims_to_sample=[0, 1],\n",
- ")\n",
- "\n",
- "# Using this potential function, we can now obtain conditional samples.\n",
- "mnle_posterior = MCMCPosterior(\n",
- " potential_fn=conditioned_potential_fn,\n",
- " theta_transform=prior_transform,\n",
- " proposal=prior,\n",
- " **mcmc_kwargs\n",
- ")\n",
- "conditional_samples = mnle_posterior.sample((num_samples,), x=x_o)"
+ "torch.manual_seed(42)\n",
+ "num_subjects = 3\n",
+ "num_trials = [10, 20, 30]\n",
+ "# draw one ground truth parameter\n",
+ "theta_o = proposal.sample((num_subjects,))[:, :2]\n",
+ "# Note that the trial conditions need to be the same for all subjects.\n",
+ "\n",
+ "# Simulate observed data for all subjects and trials.\n",
+ "x_os = []\n",
+ "conditions = []\n",
+ "for i in range(num_subjects):\n",
+ " conditions.append(proposal.sample((num_trials[i],))[:, 2:])\n",
+ " # Theta is repeated for each trial, conditions are different for each trial.\n",
+ " theta_and_condition = torch.cat((theta_o[i].repeat(num_trials[i], 1), conditions[i]), dim=-1)\n",
+ " x_os.append(sim_wrapper(theta_and_condition))\n",
+ "\n",
+ "# loop over subjects (vectorized batched x and batched conditions is not supported yet)\n",
+ "posterior_samples = []\n",
+ "for idx in range(num_subjects):\n",
+ " # condition the potential\n",
+ " conditioned_potential_fn = potential_fn.condition_on_theta(\n",
+ " conditions[idx],\n",
+ " dims_global_theta=[0, 1]\n",
+ " )\n",
+ "\n",
+ " # pass potential to sampler\n",
+ " mnle_posterior = MCMCPosterior(\n",
+ " potential_fn=conditioned_potential_fn, # pass the conditioned potential function\n",
+ " theta_transform=prior_transform,\n",
+ " proposal=prior, # pass the prior, not the proposal.\n",
+ " **mcmc_kwargs\n",
+ " )\n",
+ " posterior_samples.append(mnle_posterior.sample((num_samples,), x=x_os[idx], show_progress_bars=True))"
]
},
{
"cell_type": "code",
- "execution_count": 18,
+ "execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "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",
+ "image/png": "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",
"text/plain": [
""
]
@@ -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)