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": [
"