diff --git a/sbi/inference/nspe/nspe.py b/sbi/inference/nspe/nspe.py index 8bc790bc6..fdcd557ca 100644 --- a/sbi/inference/nspe/nspe.py +++ b/sbi/inference/nspe/nspe.py @@ -38,7 +38,7 @@ def __init__( self, prior: Optional[Distribution] = None, score_estimator: Union[str, Callable] = "mlp", - sde_type: str = "vp", + sde_type: str = "ve", device: str = "cpu", logging_level: Union[int, str] = "WARNING", summary_writer: Optional[SummaryWriter] = None, @@ -49,7 +49,8 @@ def __init__( Instead of performing conditonal *density* estimation, NSPE methods perform conditional *score* estimation i.e. they estimate the gradient of the log - density. + density using denoising score matching loss. We not only estimate the score + of the posterior, but a family of distributions analogous to diffusion models. NOTE: Single-round NSPE is currently the only supported mode. @@ -200,7 +201,7 @@ def append_simulations( def train( self, - training_batch_size: int = 50, + training_batch_size: int = 200, learning_rate: float = 5e-4, validation_fraction: float = 0.1, stop_after_epochs: int = 200, @@ -444,23 +445,30 @@ def default_calibration_kernel(x): return deepcopy(self._neural_net) def _converged(self, epoch: int, stop_after_epochs: int) -> bool: + """Check if training has converged. + + Args: + epoch: Current epoch. + stop_after_epochs: Number of epochs to wait for improvement on the + validation set before terminating training. + + Returns: + Whether training has converged. + """ converged = False - assert self._neural_net is not None - neural_net = self._neural_net + # No checkpointing, just check if the validation loss has improved. # (Re)-start the epoch count with the first epoch or any improvement. if epoch == 0 or self._val_loss < self._best_val_loss: self._best_val_loss = self._val_loss self._epochs_since_last_improvement = 0 - self._best_model_state_dict = deepcopy(neural_net.state_dict()) else: self._epochs_since_last_improvement += 1 - # # If no validation improvement over many epochs, stop training. - if self._epochs_since_last_improvement > stop_after_epochs - 1: - # neural_net.load_state_dict(self._best_model_state_dict) - converged = True + # If no validation improvement over many epochs, stop training. + if self._epochs_since_last_improvement > stop_after_epochs - 1: + converged = True return converged @@ -516,7 +524,7 @@ def build_posterior( if score_estimator is None: score_estimator = self._neural_net # If internal net is used device is defined. - # device = self._device + device = self._device else: assert score_estimator is not None, ( "You did not pass a score estimator. You have to pass the score " @@ -525,15 +533,17 @@ def build_posterior( ) score_estimator = score_estimator # Otherwise, infer it from the device of the net parameters. - # device = next(score_estimator.parameters()).device.type + device = next(score_estimator.parameters()).device.type if sample_with == "ode": + # NOTE: Build similar to Flow matching stuff raise NotImplementedError("ODE-based sampling is not yet implemented.") elif sample_with == "sde": posterior = ScorePosterior( score_estimator, # type: ignore prior, - x_shape=self._x_shape, # type: ignore + x_shape=self._x_shape, # type: ignore # NOTE: Deprectated (not used) + device=device, ) self._posterior = posterior diff --git a/sbi/inference/posteriors/base_posterior.py b/sbi/inference/posteriors/base_posterior.py index 1119fdbc3..8cb82fe61 100644 --- a/sbi/inference/posteriors/base_posterior.py +++ b/sbi/inference/posteriors/base_posterior.py @@ -126,7 +126,6 @@ def _x_else_default_x(self, x: Optional[Array]) -> Tensor: else: return self.default_x - @abstractmethod def map( self, x: Optional[Tensor] = None, @@ -139,6 +138,50 @@ def map( show_progress_bars: bool = False, force_update: bool = False, ) -> Tensor: + """Returns stored maximum-a-posterior estimate (MAP), otherwise calculates it. + + See child classes for docstring. + """ + + if x is not None: + raise ValueError( + "Passing `x` directly to `.map()` has been deprecated." + "Use `.self_default_x()` to set `x`, and then run `.map()` " + ) + + if self.default_x is None: + raise ValueError( + "Default `x` has not been set." + "To set the default, use the `.set_default_x()` method." + ) + + if self._map is None or force_update: + self._map = self._calculate_map( + num_iter=num_iter, + num_to_optimize=num_to_optimize, + learning_rate=learning_rate, + init_method=init_method, + num_init_samples=num_init_samples, + save_best_every=save_best_every, + show_progress_bars=show_progress_bars, + ) + return self._map + + @abstractmethod + def _calculate_map( + self, + num_iter: int = 1_000, + num_to_optimize: int = 100, + learning_rate: float = 0.01, + init_method: Union[str, Tensor] = "posterior", + num_init_samples: int = 1_000, + save_best_every: int = 10, + show_progress_bars: bool = False, + ) -> Tensor: + """Calculates the maximum-a-posteriori estimate (MAP). + + See `map()` method of child classes for docstring. + """ pass def __repr__(self): @@ -303,6 +346,31 @@ def _x_else_default_x(self, x: Optional[Array]) -> Tensor: else: return self.default_x + def map( + self, + x: Optional[Tensor] = None, + num_iter: int = 1000, + num_to_optimize: int = 100, + learning_rate: float = 0.01, + init_method: Union[str, Tensor] = "posterior", + num_init_samples: int = 1000, + save_best_every: int = 10, + show_progress_bars: bool = False, + force_update: bool = False, + ) -> Tensor: + self.potential_fn.set_x(self.default_x) + return super().map( + x, + num_iter, + num_to_optimize, + learning_rate, + init_method, + num_init_samples, + save_best_every, + show_progress_bars, + force_update, + ) + def _calculate_map( self, num_iter: int = 1_000, @@ -338,48 +406,6 @@ def _calculate_map( show_progress_bars=show_progress_bars, )[0] - def map( - self, - x: Optional[Tensor] = None, - num_iter: int = 1_000, - num_to_optimize: int = 100, - learning_rate: float = 0.01, - init_method: Union[str, Tensor] = "posterior", - num_init_samples: int = 1_000, - save_best_every: int = 10, - show_progress_bars: bool = False, - force_update: bool = False, - ) -> Tensor: - """Returns stored maximum-a-posterior estimate (MAP), otherwise calculates it. - - See child classes for docstring. - """ - - if x is not None: - raise ValueError( - "Passing `x` directly to `.map()` has been deprecated." - "Use `.self_default_x()` to set `x`, and then run `.map()` " - ) - - if self.default_x is None: - raise ValueError( - "Default `x` has not been set." - "To set the default, use the `.set_default_x()` method." - ) - - if self._map is None or force_update: - self.potential_fn.set_x(self.default_x) - self._map = self._calculate_map( - num_iter=num_iter, - num_to_optimize=num_to_optimize, - learning_rate=learning_rate, - init_method=init_method, - num_init_samples=num_init_samples, - save_best_every=save_best_every, - show_progress_bars=show_progress_bars, - ) - return self._map - def __repr__(self): desc = f"""{self.__class__.__name__} sampler for potential_fn=<{ self.potential_fn.__class__.__name__ diff --git a/sbi/inference/posteriors/score_posterior.py b/sbi/inference/posteriors/score_posterior.py index 3a6b05ecd..1d1356a9a 100644 --- a/sbi/inference/posteriors/score_posterior.py +++ b/sbi/inference/posteriors/score_posterior.py @@ -1,22 +1,29 @@ # This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed # under the Affero General Public License v3, see . +from functools import partial from typing import Dict, Optional, Union import torch from torch import Tensor from torch.distributions import Distribution +from zuko.transforms import FreeFormJacobianTransform from sbi.inference.posteriors.base_posterior import NeuralPosterior from sbi.inference.potentials.score_based_potential import ( score_estimator_based_potential_gradient, ) from sbi.neural_nets.estimators.score_estimator import ConditionalScoreEstimator -from sbi.neural_nets.estimators.shape_handling import reshape_to_batch_event +from sbi.neural_nets.estimators.shape_handling import ( + reshape_to_batch_event, + reshape_to_sample_batch_event, +) from sbi.samplers.score.correctors import Corrector from sbi.samplers.score.predictors import Predictor from sbi.samplers.score.score import Diffuser from sbi.sbi_types import Shape from sbi.utils import check_prior +from sbi.utils.sbiutils import within_support +from sbi.utils.torchutils import ensure_theta_batched class ScorePosterior(NeuralPosterior): @@ -162,36 +169,73 @@ def log_prob( self, theta: Tensor, x: Optional[Tensor] = None, - norm_posterior: bool = True, track_gradients: bool = False, - leakage_correction_params: Optional[dict] = None, + atol: float = 1e-5, + rtol: float = 1e-6, + exact: bool = True, ) -> Tensor: r"""Returns the log-probability of the posterior $p(\theta|x)$. Args: theta: Parameters $\theta$. - norm_posterior: Whether to enforce a normalized posterior density. - Renormalization of the posterior is useful when some - probability falls out or leaks out of the prescribed prior support. - The normalizing factor is calculated via rejection sampling, so if you - need speedier but unnormalized log posterior estimates set here - `norm_posterior=False`. The returned log posterior is set to - -∞ outside of the prior support regardless of this setting. + x: Observed data $x_o$. If None, the default $x_o$ is used. track_gradients: Whether the returned tensor supports tracking gradients. This can be helpful for e.g. sensitivity analysis, but increases memory consumption. - leakage_correction_params: A `dict` of keyword arguments to override the - default values of `leakage_correction()`. Possible options are: - `num_rejection_samples`, `force_update`, `show_progress_bars`, and - `rejection_sampling_batch_size`. - These parameters only have an effect if `norm_posterior=True`. + atol: Absolute tolerance for the ODE solver. + rtol: Relative tolerance for the ODE solver. + exact: Whether to use the exact Jacobian of the transformation or an + stochastic approximation, which is faster but less accurate. Returns: `(len(θ),)`-shaped log posterior probability $\log p(\theta|x)$ for θ in the support of the prior, -∞ (corresponding to 0 probability) outside. """ - raise NotImplementedError("log_prob() is not implemented yet.") + x = self._x_else_default_x(x) + + theta = ensure_theta_batched(torch.as_tensor(theta)) + theta_density_estimator = reshape_to_sample_batch_event( + theta, theta.shape[1:], leading_is_sample=True + ) + x_density_estimator = reshape_to_batch_event( + x, event_shape=self.score_estimator.condition_shape + ) + assert ( + x_density_estimator.shape[0] == 1 + ), ".log_prob() supports only `batchsize == 1`." + + self.score_estimator.eval() + + # Compute the base density + mean_T = self.score_estimator.mean_T + std_T = self.score_estimator.std_T + base_density = torch.distributions.Normal(mean_T, std_T) + for _ in range(len(self.score_estimator.input_shape)): + base_density = torch.distributions.Independent(base_density, 1) + # Build the freeform jacobian transformation by probability flow ODEs + transform = self.build_freeform_jacobian_transform( + x_density_estimator, atol=atol, rtol=rtol, exact=exact + ) + + with torch.set_grad_enabled(track_gradients): + eps_samples, logabsdet = transform.inv.call_and_ladj( # type: ignore + theta_density_estimator + ) + base_log_prob = base_density.log_prob(eps_samples) + log_probs = base_log_prob - logabsdet + log_probs = log_probs.squeeze(-1) + + # Force probability to be zero outside prior support. + in_prior_support = within_support(self.prior, theta) + + masked_log_prob = torch.where( + in_prior_support, + log_probs, + torch.tensor(float("-inf"), dtype=torch.float32, device=self._device), + ) + + return masked_log_prob def sample_batched( self, @@ -207,63 +251,143 @@ def sample_batched( def map( self, x: Optional[Tensor] = None, - num_iter: int = 1_000, + num_iter: int = 1000, num_to_optimize: int = 100, - learning_rate: float = 0.01, + learning_rate: float = 1e54, init_method: Union[str, Tensor] = "posterior", - num_init_samples: int = 1_000, + num_init_samples: int = 1000, save_best_every: int = 10, show_progress_bars: bool = False, force_update: bool = False, - ) -> Optional[Tensor]: + ) -> Tensor: r"""Returns the maximum-a-posteriori estimate (MAP). - The method can be interrupted (Ctrl-C) when the user sees that the - log-probability converges. The best estimate will be saved in `self._map` and - can be accessed with `self.map()`. The MAP is obtained by running gradient + The MAP is obtained by running gradient ascent from a given number of starting positions (samples from the posterior with the highest log-probability). After the optimization is done, we select the parameter set that has the highest log-probability after the optimization. - Warning: The default values used by this function are not well-tested. They - might require hand-tuning for the problem at hand. + Args: + x: Deprecated - use `.set_default_x()` prior to `.map()`. + num_iter: Number of optimization steps that the algorithm takes + to find the MAP. + learning_rate: Learning rate of the optimizer. + init_method: How to select the starting parameters for the optimization. If + it is a string, it can be either [`posterior`, `prior`], which samples + the respective distribution `num_init_samples` times. If it is a + tensor, the tensor will be used as init locations. + num_init_samples: Draw this number of samples from the posterior and + evaluate the log-probability of all of them. + num_to_optimize: From the drawn `num_init_samples`, use the + `num_to_optimize` with highest log-probability as the initial points + for the optimization. + save_best_every: The best log-probability is computed, saved in the + `map`-attribute, and printed every `save_best_every`-th iteration. + Computing the best log-probability creates a significant overhead + (thus, the default is `10`.) + show_progress_bars: Whether to show a progressbar during sampling from the + posterior. + force_update: Whether to re-calculate the MAP when x is unchanged and + have a cached value. + log_prob_kwargs: Will be empty for SNLE and SNRE. Will contain + {'norm_posterior': True} for SNPE. + + Returns: + The MAP estimate. + """ + return super().map( + x, + num_iter, + num_to_optimize, + learning_rate, + init_method, + num_init_samples, + save_best_every, + show_progress_bars, + force_update, + ) - For developers: if the prior is a `BoxUniform`, we carry out the optimization - in unbounded space and transform the result back into bounded space. + def _calculate_map( + self, + num_iter: int = 1000, + num_to_optimize: int = 100, + learning_rate: float = 1e-5, + init_method: Union[str, Tensor] = "posterior", + num_init_samples: int = 1000, + save_best_every: int = 10, + show_progress_bars: bool = False, + ) -> Tensor: + """Calculate the maximum a posteriori (MAP) estimate of the posterior. + + Uses gradient ascent to find the MAP estimate of the posterior. The gradient is + calculated using the score estimator. Args: - x: Deprecated - use `.set_default_x()` prior to `.map()`. - num_iter: Number of optimization steps that the algorithm takes - to find the MAP. - learning_rate: Learning rate of the optimizer. - init_method: How to select the starting parameters for the optimization. If - it is a string, it can be either [`posterior`, `prior`], which samples - the respective distribution `num_init_samples` times. If it is a - tensor, the tensor will be used as init locations. - num_init_samples: Draw this number of samples from the posterior and - evaluate the log-probability of all of them. - num_to_optimize: From the drawn `num_init_samples`, use the - `num_to_optimize` with highest log-probability as the initial points - for the optimization. - save_best_every: The best log-probability is computed, saved in the - `map`-attribute, and printed every `save_best_every`-th iteration. - Computing the best log-probability creates a significant overhead - (thus, the default is `10`.) - show_progress_bars: Whether to show a progressbar during sampling from the - posterior. - force_update: Whether to re-calculate the MAP when x is unchanged and - have a cached value. - log_prob_kwargs: Will be empty for SNLE and SNRE. Will contain - {'norm_posterior': True} for SNPE. + num_iter: Number of interations. Defaults to 1000. + num_to_optimize : Note used (API), just for interface. Defaults to 100. + learning_rate: Learning rate. Defaults to 1e-5. + init_method: Initialization of particles. Defaults to "posterior". + num_init_samples: Not used (API). Defaults to 1000. + save_best_evey: Not used (API). Defaults to 10. + show_progress_bars (bool, optional): _description_. Defaults to False. + + Raises: + ValueError: Invalid init method Returns: - The MAP estimate. + Tensor: MAP """ - # TODO: Implement MAP optimization using the score estimator directly! + with torch.no_grad(): + if init_method == "posterior": + inits = self.sample( + (num_init_samples,), show_progress_bars=show_progress_bars + ) + elif init_method == "proposal": + inits = self.proposal.sample((num_init_samples,)) # type: ignore + elif isinstance(init_method, Tensor): + inits = init_method + else: + raise ValueError + + self.potential_fn_gradient.set_x(self.default_x) + gradient_fn = partial( + self.potential_fn_gradient, + time=torch.tensor([self.score_estimator.T_min]), + ) + + # Run MAP optimization + xs = inits.clone() + for _ in range(num_iter): + gradient = gradient_fn(xs) + xs = xs + learning_rate * gradient - # init_method: Just sample from the posterior - # iteratively: Use score at T_min to update theta via gradient ascent - # Choose the best theta after num_iter iterations (would need log_prob...) + log_prob = self.log_prob(xs) + best_idx = torch.argmax(log_prob) + best_theta = xs[best_idx] + return best_theta + + def build_freeform_jacobian_transform( + self, x_o: Tensor, atol: float = 1e-5, rtol: float = 1e-6, exact: bool = True + ): + # Create a freeform jacobian transformation + phi = self.score_estimator.parameters() + + def f(t, x): + score = self.score_estimator(input=x, condition=x_o, time=t) + f = self.score_estimator.drift_fn(x, t) + g = self.score_estimator.diffusion_fn(x, t) + v = f - 0.5 * g**2 * score + return v + + transform = FreeFormJacobianTransform( + f=f, + t0=self.score_estimator.T_min, + t1=self.score_estimator.T_max, + phi=phi, + atol=atol, + rtol=rtol, + exact=exact, + ) - raise NotImplementedError("MAP optimization is not implemented yet.") + return transform diff --git a/sbi/neural_nets/estimators/score_estimator.py b/sbi/neural_nets/estimators/score_estimator.py index 63cbc94f4..ac194c194 100644 --- a/sbi/neural_nets/estimators/score_estimator.py +++ b/sbi/neural_nets/estimators/score_estimator.py @@ -69,12 +69,19 @@ def __init__( # Starting mean and std of the target distribution (otherwise assumes 0,1). # This will be used to precondition the score network to improve training. - self.mean_0 = mean_0 - self.std_0 = std_0 + if not isinstance(mean_0, Tensor): + mean_0 = torch.tensor([mean_0]) + if not isinstance(std_0, Tensor): + std_0 = torch.tensor([std_0]) + + self.register_buffer("mean_0", mean_0.clone().detach()) + self.register_buffer("std_0", std_0.clone().detach()) # We estimate the mean and std of the source distribution at time T_max. - self.mean_T = self.approx_marginal_mean(torch.tensor([T_max])) - self.std_T = self.approx_marginal_std(torch.tensor([T_max])) + mean_T = self.approx_marginal_mean(torch.tensor([T_max])) + std_T = self.approx_marginal_std(torch.tensor([T_max])) + self.register_buffer("mean_T", mean_T) + self.register_buffer("std_T", std_T) def forward(self, input: Tensor, condition: Tensor, time: Tensor) -> Tensor: r"""Forward pass of the score estimator network to compute the conditional score @@ -153,7 +160,11 @@ def loss( """ # Sample diffusion times. if times is None: - times = torch.rand(input.shape[0]) * (self.T_max - self.T_min) + self.T_min + times = ( + torch.rand(input.shape[0], device=input.device) + * (self.T_max - self.T_min) + + self.T_min + ) # Sample noise. eps = torch.randn_like(input) @@ -323,7 +334,10 @@ def _set_weight_fn(self, weight_fn: Union[str, Callable]): self.weight_fn = lambda times: 1 elif weight_fn == "max_likelihood": self.weight_fn = ( - lambda times: self.diffusion_fn(torch.ones((1,)), times) ** 2 + lambda times: self.diffusion_fn( + torch.ones((1,), device=times.device), times + ) + ** 2 ) elif weight_fn == "variance": self.weight_fn = lambda times: self.std_fn(times) ** 2 @@ -370,11 +384,13 @@ def mean_t_fn(self, times: Tensor) -> Tensor: Returns: Conditional mean at a given time. """ - a = torch.exp( + phi = torch.exp( -0.25 * times**2.0 * (self.beta_max - self.beta_min) - 0.5 * times * self.beta_min ) - return a.unsqueeze(-1) + for _ in range(len(self.input_shape)): + phi = phi.unsqueeze(-1) + return phi def std_fn(self, times: Tensor) -> Tensor: """Standard deviation function for variance preserving SDEs. @@ -387,7 +403,9 @@ def std_fn(self, times: Tensor) -> Tensor: std = 1.0 - torch.exp( -0.5 * times**2.0 * (self.beta_max - self.beta_min) - times * self.beta_min ) - return torch.sqrt(std.unsqueeze(-1)) + for _ in range(len(self.input_shape)): + std = std.unsqueeze(-1) + return torch.sqrt(std) def _beta_schedule(self, times: Tensor) -> Tensor: """Linear beta schedule for mean scaling in variance preserving SDEs. @@ -468,11 +486,13 @@ def mean_t_fn(self, times: Tensor) -> Tensor: Returns: Conditional mean at a given time. """ - a = torch.exp( + phi = torch.exp( -0.25 * times**2.0 * (self.beta_max - self.beta_min) - 0.5 * times * self.beta_min ) - return a.unsqueeze(-1) + for _ in range(len(self.input_shape)): + phi = phi.unsqueeze(-1) + return phi def std_fn(self, times: Tensor) -> Tensor: """Standard deviation function for variance preserving SDEs. @@ -485,7 +505,9 @@ def std_fn(self, times: Tensor) -> Tensor: std = 1.0 - torch.exp( -0.5 * times**2.0 * (self.beta_max - self.beta_min) - times * self.beta_min ) - return std.unsqueeze(-1) + for _ in range(len(self.input_shape)): + std = std.unsqueeze(-1) + return std def _beta_schedule(self, times: Tensor) -> Tensor: """Linear beta schedule for mean scaling in sub-variance preserving SDEs. @@ -527,12 +549,14 @@ def diffusion_fn(self, input: Tensor, times: Tensor) -> Tensor: Diffusion function at a given time. """ g = torch.sqrt( - self._beta_schedule(times) - * ( - 1 - - torch.exp( - -2 * self.beta_min * times - - (self.beta_max - self.beta_min) * times**2 + torch.abs( + self._beta_schedule(times) + * ( + 1 + - torch.exp( + -2 * self.beta_min * times + - (self.beta_max - self.beta_min) * times**2 + ) ) ) ) @@ -577,7 +601,10 @@ def mean_t_fn(self, times: Tensor) -> Tensor: Returns: Conditional mean at a given time. """ - return torch.ones_like(times).unsqueeze(-1) + phi = torch.ones_like(times, device=times.device) + for _ in range(len(self.input_shape)): + phi = phi.unsqueeze(-1) + return phi def std_fn(self, times: Tensor) -> Tensor: """Standard deviation function for variance exploding SDEs. @@ -589,7 +616,9 @@ def std_fn(self, times: Tensor) -> Tensor: Standard deviation at a given time. """ std = self.sigma_min * (self.sigma_max / self.sigma_min) ** times - return std.unsqueeze(-1) + for _ in range(len(self.input_shape)): + std = std.unsqueeze(-1) + return std def _sigma_schedule(self, times: Tensor) -> Tensor: """Geometric sigma schedule for variance exploding SDEs. @@ -625,7 +654,7 @@ def diffusion_fn(self, input: Tensor, times: Tensor) -> Tensor: Diffusion function at a given time. """ g = self._sigma_schedule(times) * math.sqrt( - 2 * math.log(self.sigma_max / self.sigma_min) + (2 * math.log(self.sigma_max / self.sigma_min)) ) while len(g.shape) < len(input.shape): diff --git a/sbi/simulators/linear_gaussian.py b/sbi/simulators/linear_gaussian.py index 985fa0eae..251b807b0 100644 --- a/sbi/simulators/linear_gaussian.py +++ b/sbi/simulators/linear_gaussian.py @@ -50,7 +50,7 @@ def linear_gaussian( Returns: Simulated data. """ - + theta = torch.as_tensor(theta) # Must be a tensor if num_discarded_dims: theta = theta[:, :-num_discarded_dims] diff --git a/tests/linearGaussian_nspe_test.py b/tests/linearGaussian_nspe_test.py index 15ba2b75e..a1d3d150e 100644 --- a/tests/linearGaussian_nspe_test.py +++ b/tests/linearGaussian_nspe_test.py @@ -13,9 +13,7 @@ ) from sbi.utils.user_input_checks import prepare_for_sbi -from .test_utils import ( - check_c2st, -) +from .test_utils import check_c2st @pytest.mark.slow @@ -74,11 +72,12 @@ def test_c2st_snpe_on_linearGaussian(sde_type, num_dim: int, prior_str: str): check_c2st(samples, target_samples, alg="nspe") # map_ = posterior.map(num_init_samples=1_000, show_progress_bars=False) + # assert ((map_ - gt_posterior.mean) ** 2).sum() < 0.5 # Checks for log_prob() # if prior_str == "gaussian": # # For the Gaussian prior, we compute the KLd between ground truth and - # posterior. + # # posterior. # dkl = get_dkl_gaussian_prior( # posterior, # x_o[0], @@ -93,32 +92,3 @@ def test_c2st_snpe_on_linearGaussian(sde_type, num_dim: int, prior_str: str): # assert ( # dkl < max_dkl # ), f"D-KL={dkl} is more than 2 stds above the average performance." - - # assert ((map_ - gt_posterior.mean) ** 2).sum() < 0.5 - - # elif prior_str == "uniform": - # # Check whether the returned probability outside of the support is zero. - # posterior_prob = get_prob_outside_uniform_prior(posterior, prior, num_dim) - # assert ( - # posterior_prob == 0.0 - # ), "The posterior probability outside of the prior support is not zero" - - # # Check whether normalization (i.e. scaling up the density due - # # to leakage into regions without prior support) scales up the density by the - # # correct factor. - # ( - # posterior_likelihood_unnorm, - # posterior_likelihood_norm, - # acceptance_prob, - # ) = get_normalization_uniform_prior(posterior, prior, x=x_o) - # # The acceptance probability should be *exactly* the ratio of the unnormalized - # # and the normalized likelihood. However, we allow for an error margin of 1%, - # # since the estimation of the acceptance probability is random (based on - # # rejection sampling). - # assert ( - # acceptance_prob * 0.99 - # < posterior_likelihood_unnorm / posterior_likelihood_norm - # < acceptance_prob * 1.01 - # ), "Normalizing the posterior density using the acceptance probability failed" - - # assert ((map_ - ones(num_dim)) ** 2).sum() < 0.5 diff --git a/tests/score_estimator_test.py b/tests/score_estimator_test.py index d955d37d6..be5057f39 100644 --- a/tests/score_estimator_test.py +++ b/tests/score_estimator_test.py @@ -8,6 +8,7 @@ import pytest import torch +from sbi.neural_nets.embedding_nets import CNNEmbedding from sbi.neural_nets.score_nets import build_score_estimator # TODO: Test different build options for score estimators! @@ -22,7 +23,13 @@ ], ) @pytest.mark.parametrize("input_sample_dim", (1, 2)) -@pytest.mark.parametrize("input_event_shape", ((1,), (4,))) +@pytest.mark.parametrize( + "input_event_shape", + ( + (1,), + (4,), + ), +) @pytest.mark.parametrize("condition_event_shape", ((1,), (7,))) @pytest.mark.parametrize("batch_dim", (1, 10)) def test_score_estimator_loss_shapes( @@ -45,6 +52,29 @@ def test_score_estimator_loss_shapes( assert losses.shape == (batch_dim,) +@pytest.mark.gpu +@pytest.mark.parametrize("sde_type", ["vp", "ve", "subvp"]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_score_estimator_on_device(sde_type, device): + """Test whether DensityEstimators can be moved to the device.""" + score_estimator = build_score_estimator( + torch.randn(100, 1), torch.randn(100, 1), sde_type=sde_type + ) + score_estimator.to(device) + + # Test forward + inputs = torch.randn(100, 1, device=device) + condition = torch.randn(100, 1, device=device) + time = torch.randn(1, device=device) + out = score_estimator(inputs, condition, time) + + assert str(out.device).split(":")[0] == device, "Output device mismatch." + + # Test loss + loss = score_estimator.loss(inputs, condition) + assert str(loss.device).split(":")[0] == device, "Loss device mismatch." + + @pytest.mark.parametrize( "sde_type", [ @@ -99,22 +129,33 @@ def _build_score_estimator_and_tensors( ) building_xs = torch.randn((1000, *condition_event_shape)) - # TODO Test other build options! - # if len(condition_event_shape) > 1: - # embedding_net = CNNEmbedding(condition_event_shape, kernel_size=1) - # else: - # embedding_net = torch.nn.Identity() + if len(condition_event_shape) > 1: + embedding_net_y = CNNEmbedding(condition_event_shape, kernel_size=1) + else: + embedding_net_y = torch.nn.Identity() + + if len(input_event_shape) > 1: + embedding_net_x = CNNEmbedding(input_event_shape, kernel_size=1) + else: + embedding_net_x = torch.nn.Identity() score_estimator = build_score_estimator( torch.randn_like(building_thetas), torch.randn_like(building_xs), sde_type=sde_type, + embedding_net_x=embedding_net_x, + embedding_net_y=embedding_net_y, ) inputs = building_thetas[:batch_dim] condition = building_xs[:batch_dim] inputs = inputs.unsqueeze(0) - inputs = inputs.expand(input_sample_dim, -1, -1) + inputs = inputs.expand( + [ + input_sample_dim, + ] + + [-1] * (1 + len(input_event_shape)) + ) condition = condition return score_estimator, inputs, condition diff --git a/tests/score_samplers_test.py b/tests/score_samplers_test.py index e638b16c0..b1e508f6d 100644 --- a/tests/score_samplers_test.py +++ b/tests/score_samplers_test.py @@ -25,18 +25,19 @@ ], ) @pytest.mark.parametrize("predictor", ("euler_maruyama", "ddim")) +@pytest.mark.parametrize("corrector", (None, "langevin", "gibbs")) @pytest.mark.parametrize("input_event_shape", ((1,), (4,))) @pytest.mark.parametrize("mu", (-1.0, 0.0, 1.0)) @pytest.mark.parametrize("std", (1.0, 0.1)) def test_score_estimator_forward_shapes( - sde_type, predictor, input_event_shape, mu, std + sde_type, predictor, corrector, input_event_shape, mu, std ): mean0 = mu * torch.ones(input_event_shape) std0 = std * torch.ones(input_event_shape) score_fn = _build_gaussian_score_estimator(sde_type, input_event_shape, mean0, std0) - sampler = Diffuser(score_fn, predictor, None) + sampler = Diffuser(score_fn, predictor, corrector) T_min = score_fn.score_estimator.T_min T_max = score_fn.score_estimator.T_max diff --git a/tests/test_utils.py b/tests/test_utils.py index a1cea1e07..83741bb16 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -9,7 +9,10 @@ from torch import Tensor from torch.distributions import Distribution -from sbi.inference.posteriors.base_posterior import NeuralPosterior +from sbi.inference.posteriors.base_posterior import ( + NeuralPosterior, + NeuralPotentialPosterior, +) from sbi.inference.posteriors.direct_posterior import DirectPosterior from sbi.inference.potentials.base_potential import BasePotential from sbi.sbi_types import Shape, TorchTransform @@ -89,7 +92,7 @@ def get_dkl_gaussian_prior( def get_prob_outside_uniform_prior( - posterior: NeuralPosterior, prior: BoxUniform, num_dim: int + posterior: NeuralPotentialPosterior, prior: BoxUniform, num_dim: int ) -> Tensor: """ Return posterior probability for a parameter set outside of the prior support. @@ -211,7 +214,7 @@ def __call__(self, theta: Tensor, track_gradients: bool = True) -> Tensor: return posterior_log_prob -class TractablePosterior(NeuralPosterior): +class TractablePosterior(NeuralPotentialPosterior): r"""Posterior $p(\theta|x_o)$ with `log_prob()` and `sample()` methods, built from a potential function with tractable posterior distribution.

""" diff --git a/tutorials/20_nspe.ipynb b/tutorials/20_nspe.ipynb index 0feb8c388..acff1bd55 100644 --- a/tutorials/20_nspe.ipynb +++ b/tutorials/20_nspe.ipynb @@ -42,7 +42,7 @@ "metadata": {}, "outputs": [], "source": [ - "num_dim = 3\n", + "num_dim = 2\n", "prior = utils.BoxUniform(low=-2 * torch.ones(num_dim), high=2 * torch.ones(num_dim))\n", "\n", "def simulator(theta):\n", @@ -63,12 +63,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a9c85f9950444eba8caf71ffe634dc53", + "model_id": "85fd3b25770a47c4a7f0ed0d0fbbbeb1", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Running 5000 simulations.: 0%| | 0/5000 [00:00" ] @@ -149,16 +149,25 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/root/sbi/sbi/inference/posteriors/score_posterior.py:71: UserWarning: x_shape is not None. However, passing x_shape to the `Posterior` is deprecated and will be removed in a future release of `sbi`.\n", + " super().__init__(\n" + ] + } + ], "source": [ "posterior = inference.build_posterior(score_estimator)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -169,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -178,18 +187,18 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0b0c98e4415d48d09b0b3c2053769842", + "model_id": "58be28c0254f48b5888cd6caf7b88b37", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Drawing 1000 posterior samples: 0%| | 0/99 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "samples = posterior.sample((10000,), x=x_obs)\n", + "#samples = x.detach()\n", + "_ = pairplot(samples, points=theta_true, limits=[[-2, 2], [-2, 2], [-2, 2]], figsize=(6, 6), labels=[r\"$\\theta_1$\", r\"$\\theta_2$\", r\"$\\theta_3$\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [], + "source": [ + "from zuko.transforms import FreeFormJacobianTransform\n", + "\n", + "def build_freeform_jacobian_transform(x_o, atol=1e-5, rtol=1e-6, exact=True):\n", + " # Create a freeform jacobian transformation\n", + " phi = score_estimator.parameters()\n", + " def f(t,x):\n", + " score = score_estimator(input=x, condition=x_o, time=t)\n", + " f = score_estimator.drift_fn(x,t)\n", + " g = score_estimator.diffusion_fn(x,t)\n", + " v = f - 0.5*g**2 * score\n", + " return v\n", + "\n", + " transform = FreeFormJacobianTransform(\n", + " f=f, t0= score_estimator.T_min, t1=score_estimator.T_max, phi=phi, atol=atol, rtol=rtol, exact=exact\n", + " )\n", + " return transform" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [], + "source": [ + "x_o=x_obs\n", + "\n", + "def f(t,x):\n", + " t = torch.atleast_1d(t)\n", + " score = score_estimator(input=x, condition=x_o, time=t)\n", + " f = score_estimator.drift_fn(x, t)\n", + " g = score_estimator.diffusion_fn(x,t)\n", + "\n", + "\n", + " v = f - 0.5*g**2*score\n", + " return v" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [], + "source": [ + "t = build_freeform_jacobian_transform(x_o=x_obs)" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [], + "source": [ + "x = t.inv(torch.randn(1000,3)*5)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([[0.4764, 0.9005, 1.3979],\n", + " [0.4118, 0.9998, 1.4809],\n", + " [0.5809, 0.8338, 1.3564],\n", + " ...,\n", + " [0.3680, 1.0214, 1.5462],\n", + " [0.6494, 1.1714, 1.4905],\n", + " [0.5129, 1.1883, 1.2057]], grad_fn=),\n", + " tensor([-11.3393, -12.0696, -10.5322, -12.1473, -12.1653, -12.2359, -11.8778,\n", + " -11.6856, -11.8938, -11.1525, -9.0558, -10.2876, -12.0738, -11.3915,\n", + " -12.1080, -11.6055, -11.9665, -8.4153, -12.2185, -11.0578, -12.2458,\n", + " -12.0770, -10.7388, -11.6835, -11.6357, -11.9408, -12.1403, -11.0899,\n", + " -10.1723, -10.7194, -11.8543, -11.5425, -12.0460, -11.5787, -11.5684,\n", + " -11.6898, -11.1879, -12.0430, -11.0693, -10.4514, -11.0364, -10.2239,\n", + " -12.0736, -12.0802, -10.6735, -12.2166, -10.8613, -10.8449, -11.2762,\n", + " -11.7612, -12.1454, -11.5049, -11.1811, -8.7299, -8.8875, -11.3936,\n", + " -11.8494, -12.2083, -11.5453, -11.3342, -10.7157, -11.8605, -10.3503,\n", + " -11.5887, -11.5263, -11.9895, -10.3473, -10.2000, -11.5172, -11.4734,\n", + " -11.5580, -11.8126, -11.0949, -12.2756, -11.9354, -12.0373, -10.9943,\n", + " -12.2972, -12.0911, -11.4819, -11.7943, -11.8345, -11.7430, -11.3659,\n", + " -11.9333, -11.6820, -11.7331, -11.4487, -11.0010, -12.0436, -8.8357,\n", + " -11.9164, -12.2018, -9.9901, -12.0173, -11.8535, -10.3261, -11.9813,\n", + " -12.2867, -11.8779, -11.3429, -11.8682, -11.7222, -11.9387, -10.4539,\n", + " -10.2567, -10.1816, -11.0302, -12.0856, -11.7544, -12.2059, -11.1074,\n", + " -12.2368, -11.2366, -12.0981, -12.0567, -11.3155, -11.8828, -11.7166,\n", + " -11.3314, -10.7698, -12.0243, -11.0390, -12.1846, -10.6419, -12.0907,\n", + " -12.0464, -11.0945, -12.2707, -12.2411, -10.7072, -11.7487, -12.2097,\n", + " -10.6541, -11.7804, -12.2444, -12.1120, -11.9754, -10.5040, -11.2219,\n", + " -11.7314, -11.3113, -10.9229, -9.4074, -11.9282, -12.0602, -12.0106,\n", + " -9.7947, -11.8990, -9.0603, -12.1299, -10.3487, -11.3325, -10.3819,\n", + " -11.8672, -10.3769, -11.4640, -11.8487, -11.0983, -11.0729, -11.2004,\n", + " -11.5717, -11.7843, -11.8835, -11.5155, -10.0490, -11.8216, -11.8460,\n", + " -11.5093, -11.5119, -10.9687, -10.9781, -12.0823, -11.0982, -12.0875,\n", + " -11.7735, -12.0524, -12.1935, -12.0329, -7.7109, -10.1076, -12.2651,\n", + " -11.8003, -11.2685, -11.2568, -10.2104, -12.1095, -11.4000, -11.6327,\n", + " -11.4993, -11.4609, -11.1832, -11.8741, -11.0600, -9.7319, -11.8355,\n", + " -12.1074, -11.4329, -10.3614, -10.4161, -9.2759, -11.4816, -11.8890,\n", + " -11.8843, -11.2903, -11.2146, -10.8234, -11.6301, -11.9705, -11.9870,\n", + " -11.5445, -11.8127, -11.2832, -12.0703, -11.8974, -12.1573, -11.6865,\n", + " -9.1256, -11.6495, -9.8298, -11.9823, -12.0451, -12.0935, -11.6645,\n", + " -10.9018, -12.2215, -11.8386, -12.2197, -12.1248, -10.3160, -11.5612,\n", + " -11.1463, -11.3039, -12.2922, -12.0505, -11.3986, -11.4819, -11.6421,\n", + " -12.1357, -11.3879, -12.2783, -12.1159, -12.3114, -10.5426, -11.5908,\n", + " -12.0573, -12.0877, -11.6396, -11.1775, -11.8710, -12.0969, -11.8314,\n", + " -12.2104, -11.6995, -11.7752, -9.6288, -12.0768, -11.4646, -11.3546,\n", + " -11.2389, -12.3060, -11.9305, -10.9398, -12.2057, -11.1257, -9.5186,\n", + " -11.5742, -10.9909, -12.1083, -12.1648, -11.2504, -12.0422, -11.9215,\n", + " -11.7890, -12.2458, -11.2751, -12.2933, -11.1555, -11.4328, -10.7888,\n", + " -11.8607, -12.1718, -11.6756, -12.1999, -12.2340, -10.9812, -11.1456,\n", + " -11.9560, -11.7475, -10.8417, -10.0725, -11.6100, -12.1305, -12.2358,\n", + " -11.3882, -11.4427, -11.7337, -11.8268, -11.2699, -11.5778, -11.7995,\n", + " -11.8425, -12.1651, -11.8954, -11.2419, -10.8600, -11.3762, -11.0404,\n", + " -12.0280, -11.2040, -11.5530, -9.3302, -12.0481, -11.5463, -10.2053,\n", + " -11.3655, -12.0397, -11.7155, -11.1963, -12.0276, -11.8611, -11.6250,\n", + " -10.4754, -11.7213, -11.6704, -11.5179, -12.0262, -12.0378, -12.1878,\n", + " -11.6087, -11.9918, -11.2099, -12.2812, -12.1546, -12.0474, -7.8446,\n", + " -11.1891, -8.5890, -11.1992, -9.9350, -11.0254, -11.2566, -10.7976,\n", + " -11.9100, -10.5724, -11.9817, -11.8200, -12.2481, -12.1213, -11.0340,\n", + " -12.0441, -11.7919, -11.7532, -12.1006, -11.9880, -12.1053, -10.0877,\n", + " -11.1893, -12.1676, -12.0852, -12.2076, -12.0384, -11.5550, -10.6232,\n", + " -10.9109, -11.7317, -10.8197, -12.1748, -11.1977, -12.0573, -11.7632,\n", + " -12.0037, -10.5893, -12.2178, -11.3430, -11.8767, -11.7259, -10.7653,\n", + " -11.8737, -10.0069, -11.4856, -11.8800, -11.7148, -11.6921, -11.4475,\n", + " -11.7718, -12.3201, -11.1549, -11.4445, -10.4085, -12.2442, -11.4332,\n", + " -11.3358, -11.4865, -10.1661, -11.7500, -9.4124, -10.9049, -12.1683,\n", + " -11.5349, -9.8241, -10.2910, -11.4961, -12.1179, -12.0195, -11.5523,\n", + " -11.9330, -11.8468, -10.4839, -10.4984, -12.0573, -11.2255, -11.8214,\n", + " -10.9392, -11.6993, -12.1175, -12.0495, -10.0370, -12.0808, -12.1901,\n", + " -11.9910, -11.1805, -11.2265, -11.8685, -11.7389, -11.0050, -11.3509,\n", + " -10.9413, -10.9746, -12.1048, -11.6963, -11.8192, -11.8919, -11.7672,\n", + " -10.8658, -11.6988, -12.1085, -11.8408, -11.7247, -10.9258, -11.0908,\n", + " -11.9170, -12.2726, -12.2800, -12.3137, -9.8852, -12.2697, -12.1758,\n", + " -11.7955, -12.2614, -12.3191, -10.9832, -11.4527, -11.5018, -11.4599,\n", + " -11.0322, -12.2282, -11.7237, -11.7519, -11.8541, -9.5949, -11.4039,\n", + " -11.8602, -11.7956, -12.1084, -11.9488, -10.8463, -11.4429, -10.5114,\n", + " -12.3317, -11.4291, -11.6067, -10.8961, -11.9421, -10.9811, -12.1834,\n", + " -11.8468, -11.8343, -11.4281, -11.2753, -11.6537, -11.1929, -11.6059,\n", + " -10.1103, -12.1663, -11.8285, -11.7828, -12.2505, -12.1411, -12.1794,\n", + " -12.0593, -11.9400, -11.7581, -10.5855, -11.7010, -9.9196, -11.7080,\n", + " -9.7849, -12.2759, -11.9039, -12.0197, -10.4179, -11.1942, -11.7790,\n", + " -11.9450, -11.5530, -11.5463, -12.1205, -11.8815, -11.6144, -11.8572,\n", + " -11.6931, -11.9639, -12.0825, -11.8951, -11.6722, -10.7654, -11.5711,\n", + " -11.2707, -11.1637, -10.2477, -10.9823, -11.5708, -10.2684, -12.2125,\n", + " -11.1502, -12.0975, -11.6406, -9.2930, -11.3084, -12.0031, -11.9707,\n", + " -11.0800, -11.4615, -11.8847, -12.3027, -9.7530, -11.5245, -11.9549,\n", + " -12.0659, -11.5513, -11.9031, -11.4378, -10.6816, -11.4369, -11.9344,\n", + " -11.9746, -11.9046, -11.0397, -12.1171, -11.9921, -12.0645, -10.4652,\n", + " -11.9461, -12.2946, -12.2521, -12.0696, -11.1348, -11.2929, -11.8026,\n", + " -11.9491, -11.1220, -12.1505, -11.9491, -11.3055, -11.9518, -10.9067,\n", + " -11.7897, -11.8965, -12.2702, -11.8093, -9.9063, -12.2621, -11.3763,\n", + " -11.5708, -11.6599, -10.7153, -12.2531, -11.4650, -12.0229, -12.2397,\n", + " -12.0022, -10.2920, -11.1637, -12.1740, -12.1975, -12.2902, -11.7795,\n", + " -11.5661, -11.2701, -12.1071, -10.6045, -12.1280, -12.1338, -11.6048,\n", + " -12.1681, -11.7593, -11.4082, -12.2153, -12.1406, -11.3058, -11.8445,\n", + " -12.2964, -11.3847, -10.8039, -11.9475, -11.4605, -10.7361, -12.1613,\n", + " -11.7142, -11.4070, -9.7585, -12.0837, -11.5540, -11.7387, -11.8598,\n", + " -11.9654, -11.7081, -12.0946, -11.9053, -12.2847, -11.8607, -10.5086,\n", + " -11.0968, -11.8770, -11.9803, -10.7891, -11.2400, -12.2323, -12.1171,\n", + " -10.9411, -12.2252, -12.0418, -12.1167, -11.9127, -12.2902, -11.1653,\n", + " -10.0486, -11.8977, -11.8599, -10.1873, -10.6580, -11.9795, -11.9050,\n", + " -11.8987, -11.9752, -12.1722, -11.6678, -11.6585, -11.7419, -11.9028,\n", + " -9.4190, -12.1834, -10.8111, -12.0086, -12.1775, -11.5304, -11.5112,\n", + " -12.0334, -12.1528, -11.6381, -11.6752, -12.1919, -11.9974, -11.5342,\n", + " -11.7224, -12.0660, -11.8456, -12.0267, -11.9817, -12.0181, -12.1688,\n", + " -10.6881, -11.6489, -11.5894, -10.3761, -10.0797, -10.8868, -12.0839,\n", + " -11.6248, -10.4268, -11.8379, -10.9256, -10.8650, -10.4378, -11.0339,\n", + " -7.7219, -11.5060, -11.4607, -10.8196, -8.5400, -12.1210, -11.8207,\n", + " -11.3063, -12.1389, -11.9366, -11.4075, -11.8726, -11.0578, -11.9696,\n", + " -12.1740, -11.9265, -12.0340, -11.9072, -12.2753, -10.0218, -10.7439,\n", + " -11.7574, -12.0352, -12.0054, -10.1867, -11.3067, -11.9795, -12.0706,\n", + " -11.7789, -11.3037, -9.3154, -11.6751, -12.2087, -11.8665, -12.2650,\n", + " -11.5454, -10.8514, -10.9100, -11.0988, -11.4273, -10.9355, -11.3235,\n", + " -11.1513, -11.9007, -10.8496, -10.7962, -11.2364, -11.9275, -10.0676,\n", + " -11.4195, -12.1524, -12.0381, -11.8797, -12.2429, -12.1951, -11.4312,\n", + " -11.6432, -10.8628, -12.1054, -12.2371, -9.5694, -11.8495, -11.7812,\n", + " -11.0480, -11.9885, -11.3442, -11.0065, -11.5084, -6.5185, -11.6789,\n", + " -11.0985, -11.7754, -12.1364, -10.8364, -11.9801, -11.9902, -11.9467,\n", + " -11.1003, -10.9826, -11.4826, -11.9385, -10.3341, -12.2573, -10.7436,\n", + " -11.4261, -11.6060, -12.2237, -11.8393, -8.0914, -12.2701, -11.9639,\n", + " -10.8403, -11.3149, -10.9970, -10.0628, -11.8406, -12.1371, -9.6974,\n", + " -11.1144, -12.0869, -11.1852, -10.8872, -12.0870, -7.7013, -10.4896,\n", + " -11.4899, -11.8649, -12.2523, -11.8160, -11.7129, -9.9433, -12.0977,\n", + " -12.0277, -11.7494, -11.9488, -12.0313, -11.8412, -11.4485, -12.2430,\n", + " -12.0888, -12.1654, -11.4062, -12.1045, -9.4150, -11.0754, -11.5400,\n", + " -11.5493, -11.4941, -10.8519, -12.2357, -11.7312, -11.7801, -12.1006,\n", + " -12.0945, -11.6957, -12.1885, -11.7263, -11.7398, -11.4212, -12.0946,\n", + " -11.6427, -11.1928, -11.6304, -12.1939, -12.2938, -11.8502, -11.5212,\n", + " -10.7969, -11.9130, -11.2254, -12.1520, -11.6663, -11.4851, -11.7064,\n", + " -11.5721, -9.8780, -11.3847, -12.1477, -10.1196, -10.7292, -10.6729,\n", + " -10.8113, -11.3692, -9.8551, -12.1765, -12.1939, -11.4078, -11.7075,\n", + " -10.8863, -12.0823, -11.1686, -12.1246, -11.2344, -11.9334, -12.1153,\n", + " -10.6855, -12.0415, -12.1144, -12.3097, -11.5281, -11.4091, -11.7386,\n", + " -9.7435, -12.1329, -11.7483, -11.6986, -11.9039, -12.1008, -12.2294,\n", + " -11.9037, -11.1631, -11.1923, -12.0500, -12.1665, -10.1869, -12.1305,\n", + " -12.2400, -10.1329, -11.1620, -10.9900, -11.6403, -12.1358, -12.0491,\n", + " -11.5200, -11.1327, -12.0240, -11.8793, -10.9920, -11.5503, -11.2901,\n", + " -11.9100, -12.3266, -11.7816, -11.4918, -11.1450, -10.8831, -11.1306,\n", + " -11.1600, -11.2553, -11.0231, -11.1108, -11.9908, -11.7031, -12.1105,\n", + " -12.0946, -11.6505, -11.9798, -11.3958, -12.0688, -11.8705, -11.8723,\n", + " -11.1863, -11.1097, -11.8088, -11.9162, -11.4883, -11.9308, -10.5261,\n", + " -11.9909, -11.8067, -10.5097, -12.2662, -12.1418, -11.3248, -12.2752,\n", + " -11.7540, -11.5158, -12.0604, -11.3229, -11.4578, -10.8770, -11.6109,\n", + " -12.2402, -9.4754, -12.2727, -11.2516, -11.2047, -12.0643, -10.4960,\n", + " -12.1528, -11.8986, -11.7469, -12.0473, -11.2501, -11.8298, -11.9539,\n", + " -11.2626, -11.4433, -10.8938, -11.1906, -12.0505, -9.3127, -12.1797,\n", + " -12.1870, -11.3561, -11.3167, -11.6003, -11.3559, -12.2800, -10.6347,\n", + " -11.7428, -12.3284, -11.2002, -11.9797, -11.4396, -11.8593, -11.3731,\n", + " -11.2978, -11.1464, -11.0969, -12.0078, -12.1232, -11.1050, -11.7479,\n", + " -10.3174, -10.2531, -10.6393, -11.3818, -11.5734, -11.7713, -11.6673,\n", + " -10.7120, -12.0819, -11.8713, -11.3048, -10.2552, -12.3384, -11.1683,\n", + " -11.6492, -11.0256, -12.1111, -11.7238, -11.4050, -10.2685],\n", + " grad_fn=))" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.inv.call_and_ladj(torch.randn(1000,3)*5)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "ts = torch.linspace(1,1e-5,1000)\n", + "x0s = torch.randn(100,3)*5.\n", + "x = x0s\n", + "for i in range(1000):\n", + " x -= f(ts[i],x) * 1e-3\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -217,7 +565,9 @@ } ], "source": [ - "#samples = posterior.sample((10000,), x=x_obs)\n", + "samples = x.detach()\n", + "\n", + "\n", "_ = pairplot(samples, points=theta_true, limits=[[-2, 2], [-2, 2], [-2, 2]], figsize=(6, 6), labels=[r\"$\\theta_1$\", r\"$\\theta_2$\", r\"$\\theta_3$\"])" ] }, @@ -242,39 +592,51 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 95, "metadata": {}, "outputs": [], "source": [ "from sbibm.tasks import get_task\n", "\n", - "task = get_task(\"two_moons\")\n", + "task = get_task(\"slcp\")\n", "\n", "prior = task.get_prior_dist()\n", "simulator = task.get_simulator()\n", "\n", - "thetas = prior.sample((10_000,))\n", + "thetas = prior.sample((100_000,))\n", "xs = simulator(thetas)\n" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 96, "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - " Neural network successfully converged after 2673 epochs." + "/root/sbi/sbi/neural_nets/estimators/score_estimator.py:72: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " self.register_buffer(\"mean_0\", torch.tensor(mean_0))\n", + "/root/sbi/sbi/neural_nets/estimators/score_estimator.py:73: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " self.register_buffer(\"std_0\", torch.tensor(std_0))\n" ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "/root/sbi/sbi/inference/posteriors/score_posterior.py:62: UserWarning: x_shape is not None. However, passing x_shape to the `Posterior` is deprecated and will be removed in a future release of `sbi`.\n", - " super().__init__(\n" + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[96], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m inference \u001b[38;5;241m=\u001b[39m inference\u001b[38;5;241m.\u001b[39mappend_simulations(thetas, xs)\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# train the density estimator and build the posterior\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m score_estimator \u001b[38;5;241m=\u001b[39m \u001b[43minference\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstop_after_epochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m50\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtraining_batch_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m100\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 7\u001b[0m posterior \u001b[38;5;241m=\u001b[39m inference\u001b[38;5;241m.\u001b[39mbuild_posterior(score_estimator)\n", + "File \u001b[0;32m~/sbi/sbi/inference/nspe/nspe.py:348\u001b[0m, in \u001b[0;36mNSPE.train\u001b[0;34m(self, training_batch_size, learning_rate, validation_fraction, stop_after_epochs, max_num_epochs, clip_max_norm, calibration_kernel, ema_loss_decay, resume_training, force_first_round_loss, discard_prior_samples, retrain_from_scratch, show_train_summary, dataloader_kwargs)\u001b[0m\n\u001b[1;32m 341\u001b[0m \u001b[38;5;66;03m# Get batches on current device.\u001b[39;00m\n\u001b[1;32m 342\u001b[0m theta_batch, x_batch, masks_batch \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 343\u001b[0m batch[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_device),\n\u001b[1;32m 344\u001b[0m batch[\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_device),\n\u001b[1;32m 345\u001b[0m batch[\u001b[38;5;241m2\u001b[39m]\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_device),\n\u001b[1;32m 346\u001b[0m )\n\u001b[0;32m--> 348\u001b[0m train_losses \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_loss\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 349\u001b[0m \u001b[43m \u001b[49m\u001b[43mtheta_batch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 350\u001b[0m \u001b[43m \u001b[49m\u001b[43mx_batch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 351\u001b[0m \u001b[43m \u001b[49m\u001b[43mmasks_batch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 352\u001b[0m \u001b[43m \u001b[49m\u001b[43mproposal\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 353\u001b[0m \u001b[43m \u001b[49m\u001b[43mcalibration_kernel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 354\u001b[0m \u001b[43m \u001b[49m\u001b[43mforce_first_round_loss\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mforce_first_round_loss\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 355\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 357\u001b[0m train_loss \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mmean(train_losses)\n\u001b[1;32m 359\u001b[0m train_loss_sum \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m train_losses\u001b[38;5;241m.\u001b[39msum()\u001b[38;5;241m.\u001b[39mitem()\n", + "File \u001b[0;32m~/sbi/sbi/inference/nspe/nspe.py:558\u001b[0m, in \u001b[0;36mNSPE._loss\u001b[0;34m(self, theta, x, masks, proposal, calibration_kernel, force_first_round_loss)\u001b[0m\n\u001b[1;32m 545\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Return loss with proposal correction (`round_>0`) or without it (`round_=0`).\u001b[39;00m\n\u001b[1;32m 546\u001b[0m \n\u001b[1;32m 547\u001b[0m \u001b[38;5;124;03mThe loss is the negative log prob. Irrespective of the round or SNPE method\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 554\u001b[0m \u001b[38;5;124;03m distribution different from the prior.\u001b[39;00m\n\u001b[1;32m 555\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 556\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_round \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m force_first_round_loss:\n\u001b[1;32m 557\u001b[0m \u001b[38;5;66;03m# First round loss.\u001b[39;00m\n\u001b[0;32m--> 558\u001b[0m loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_neural_net\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloss\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtheta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 559\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 560\u001b[0m \u001b[38;5;66;03m# TODO: Implement proposal correction for multi-round SNSPE.\u001b[39;00m\n\u001b[1;32m 561\u001b[0m loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_loss_proposal_posterior(theta, x, masks, proposal)\n", + "File \u001b[0;32m~/sbi/sbi/neural_nets/estimators/score_estimator.py:178\u001b[0m, in \u001b[0;36mConditionalScoreEstimator.loss\u001b[0;34m(self, input, condition, times, control_variate, control_variate_threshold)\u001b[0m\n\u001b[1;32m 175\u001b[0m score_target \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39meps \u001b[38;5;241m/\u001b[39m std\n\u001b[1;32m 177\u001b[0m \u001b[38;5;66;03m# Predict score from noised input and diffusion time.\u001b[39;00m\n\u001b[0;32m--> 178\u001b[0m score_pred \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mforward\u001b[49m\u001b[43m(\u001b[49m\u001b[43minput_noised\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcondition\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimes\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 180\u001b[0m \u001b[38;5;66;03m# Compute weights over time.\u001b[39;00m\n\u001b[1;32m 181\u001b[0m weights \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mweight_fn(times)\n", + "File \u001b[0;32m~/sbi/sbi/neural_nets/estimators/score_estimator.py:104\u001b[0m, in \u001b[0;36mConditionalScoreEstimator.forward\u001b[0;34m(self, input, condition, time)\u001b[0m\n\u001b[1;32m 100\u001b[0m time \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mbroadcast_to(time, batch_shape)\n\u001b[1;32m 102\u001b[0m \u001b[38;5;66;03m# Time dependent mean and std of the target distribution to z-score the input\u001b[39;00m\n\u001b[1;32m 103\u001b[0m \u001b[38;5;66;03m# and to approximate the score at the end of the diffusion.\u001b[39;00m\n\u001b[0;32m--> 104\u001b[0m mean \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapprox_marginal_mean\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtime\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 105\u001b[0m std \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mapprox_marginal_std(time)\n\u001b[1;32m 107\u001b[0m \u001b[38;5;66;03m# As input to the neural net we want to have something that changes proportianl\u001b[39;00m\n\u001b[1;32m 108\u001b[0m \u001b[38;5;66;03m# to how the scores change\u001b[39;00m\n", + "File \u001b[0;32m~/sbi/sbi/neural_nets/estimators/score_estimator.py:234\u001b[0m, in \u001b[0;36mConditionalScoreEstimator.approx_marginal_mean\u001b[0;34m(self, times)\u001b[0m\n\u001b[1;32m 225\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mapprox_marginal_mean\u001b[39m(\u001b[38;5;28mself\u001b[39m, times: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[1;32m 226\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Approximate the marginal mean of the target distribution at a given time.\u001b[39;00m\n\u001b[1;32m 227\u001b[0m \n\u001b[1;32m 228\u001b[0m \u001b[38;5;124;03m Args:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 232\u001b[0m \u001b[38;5;124;03m Approximate marginal mean at a given time.\u001b[39;00m\n\u001b[1;32m 233\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 234\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmean_t_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtimes\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmean_0\n", + "File \u001b[0;32m~/sbi/sbi/neural_nets/estimators/score_estimator.py:489\u001b[0m, in \u001b[0;36msubVPScoreEstimator.mean_t_fn\u001b[0;34m(self, times)\u001b[0m\n\u001b[1;32m 484\u001b[0m phi \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mexp(\n\u001b[1;32m 485\u001b[0m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m0.25\u001b[39m \u001b[38;5;241m*\u001b[39m times\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2.0\u001b[39m \u001b[38;5;241m*\u001b[39m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbeta_max \u001b[38;5;241m-\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbeta_min)\n\u001b[1;32m 486\u001b[0m \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m0.5\u001b[39m \u001b[38;5;241m*\u001b[39m times \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbeta_min\n\u001b[1;32m 487\u001b[0m )\n\u001b[1;32m 488\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_shape)):\n\u001b[0;32m--> 489\u001b[0m phi \u001b[38;5;241m=\u001b[39m \u001b[43mphi\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43munsqueeze\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 490\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m phi\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], @@ -284,118 +646,27 @@ "inference = inference.append_simulations(thetas, xs)\n", "\n", "# train the density estimator and build the posterior\n", - "score_estimator = inference.train(stop_after_epochs=500, training_batch_size=100)\n", + "score_estimator = inference.train(stop_after_epochs=50, training_batch_size=100)\n", "posterior = inference.build_posterior(score_estimator)" ] }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed\n", - "# under the Apache License Version 2.0, see \n", - "\n", - "from __future__ import annotations\n", - "\n", - "from typing import Tuple\n", - "\n", - "import pytest\n", - "import torch\n", - "from torch import Tensor\n", - "\n", - "from sbi.neural_nets.score_nets import build_score_estimator\n", - "from sbi.inference.potentials.score_based_potential import (\n", - " score_estimator_based_potential_gradient,\n", - ")\n", - "from sbi.samplers.score.score import Diffuser\n", - "\n", - "\n", - "@pytest.mark.parametrize(\n", - " \"sde_type\",\n", - " [\n", - " \"vp\",\n", - " \"ve\",\n", - " \"subvp\",\n", - " ],\n", - ")\n", - "@pytest.mark.parametrize(\"input_event_shape\", ((1,), (4,)))\n", - "@pytest.mark.parametrize(\"std\", (1.0, 0.1))\n", - "def test_score_estimator_forward_shapes(sde_type, input_event_shape, std):\n", - "\n", - " mean0 = torch.zeros(input_event_shape)\n", - " std0 = std * torch.ones(input_event_shape)\n", - "\n", - " score_fn = _build_gaussian_score_estimator(sde_type, input_event_shape, mean0, std0)\n", - "\n", - " sampler = Diffuser(score_fn, \"euler_maruyama\", None)\n", - "\n", - " T_min = score_fn.score_estimator.T_min\n", - " T_max = score_fn.score_estimator.T_max\n", - " ts = torch.linspace(T_max, T_min, 1000)\n", - " samples = sampler.run(10_000, ts)\n", - "\n", - " mean_est = samples[0].mean(0)\n", - " std_est = samples[0].std(0)\n", - "\n", - " # TODO: Fix this\n", - "\n", - " # print(mean_est, std_est)\n", - " # assert torch.allclose(mean_est, torch.zeros_like(mean_est), rtol=1e-3)\n", - " # assert torch.allclose(std_est, torch.ones_like(mean_est) * std, rtol=1e-3)\n", - "\n", - "\n", - "def _build_gaussian_score_estimator(\n", - " sde_type: str,\n", - " input_event_shape: Tuple[int],\n", - " mean0: Tensor,\n", - " std0: Tensor,\n", - "):\n", - " \"\"\"Helper function for all tests that deal with shapes of density estimators.\"\"\"\n", - "\n", - " # Use discrete thetas such that categorical density esitmators can also use them.\n", - " building_thetas = (\n", - " torch.randint(0, 4, (1000, *input_event_shape), dtype=torch.float32) * std0\n", - " + mean0\n", - " )\n", - " building_xs = torch.ones((1000, 1))\n", - "\n", - " class DummyNet(torch.nn.Module):\n", - " def forward(self, x):\n", - " return torch.zeros((x.shape[0], *input_event_shape))\n", - "\n", - " score_estimator = build_score_estimator(\n", - " building_thetas,\n", - " building_xs,\n", - " sde_type=sde_type,\n", - " score_net=DummyNet(),\n", - " )\n", - "\n", - " score_fn, _ = score_estimator_based_potential_gradient(\n", - " score_estimator, prior=None, x_o=torch.ones((1,))\n", - " )\n", - "\n", - " return score_fn\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "For an interactive, detailed view of the summary, launch tensorboard with 'tensorboard --logdir=/root/sbi/tutorials/sbi-logs/NSPE/2024-07-21T18_13_17.003344' from a terminal on your machine, visit http://127.0.0.1:6006 afterwards. Requires port forwarding if tensorboard runs on a remote machine, as e.g. https://stackoverflow.com/a/42445070/7770835 explains.\n", + "WARNING:sbi.analysis.tensorboard_output:For an interactive, detailed view of the summary, launch tensorboard with 'tensorboard --logdir=/root/sbi/tutorials/sbi-logs/NSPE/2024-07-28T18_02_27.270391' from a terminal on your machine, visit http://127.0.0.1:6006 afterwards. Requires port forwarding if tensorboard runs on a remote machine, as e.g. https://stackoverflow.com/a/42445070/7770835 explains.\n", "\n", - "Valid tags are: ['best_validation_loss', 'epoch_durations_sec', 'epochs_trained', 'training_loss', 'validation_loss'].\n" + "WARNING:sbi.analysis.tensorboard_output:Valid tags are: ['best_validation_loss', 'epoch_durations_sec', 'epochs_trained', 'training_loss', 'validation_loss'].\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -412,7 +683,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -421,7 +692,7 @@ "tensor([[0.0006]])" ] }, - "execution_count": 13, + "execution_count": 337, "metadata": {}, "output_type": "execute_result" } @@ -432,37 +703,13 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e70044b3b7364db3a1db61b70f4b29b6", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Drawing 10000 posterior samples: 0%| | 0/999 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2fce9bd780f64fe5ba8dc04ad5bb87c5", + "model_id": "0647f2dd9c8c470f9dd9b415b5579f8e", "version_major": 2, "version_minor": 0 }, @@ -474,214 +721,32 @@ "output_type": "display_data" }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "5a5d4968a6614200bcaed0676e8ff991", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Drawing 10000 posterior samples: 0%| | 0/999 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2835ff4967264ea6be43b4986d0657ae", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Drawing 10000 posterior samples: 0%| | 0/999 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "080dfc54e16a42ab97534b2cd3143796", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Drawing 10000 posterior samples: 0%| | 0/999 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9cbc8fa311ea43fdaed4205fcb8db0fe", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Drawing 10000 posterior samples: 0%| | 0/999 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "85a877cd2b8f462bb3f785834feb6b16", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Drawing 10000 posterior samples: 0%| | 0/999 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "cfba2b4550a745a8bc85871a548ba4ee", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Drawing 10000 posterior samples: 0%| | 0/999 [00:00" ] }, "metadata": {}, "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6862a036e6fd471787895bce8fef61d8", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Drawing 10000 posterior samples: 0%| | 0/999 [00:00 7\u001b[0m samples \u001b[38;5;241m=\u001b[39m \u001b[43mposterior\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msample\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m10000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mx_obs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msteps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1000\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 8\u001b[0m \u001b[38;5;66;03m#print(c2st(ref_samples, samples))\u001b[39;00m\n\u001b[1;32m 9\u001b[0m plt\u001b[38;5;241m.\u001b[39mscatter(samples[:,\u001b[38;5;241m0\u001b[39m], samples[:,\u001b[38;5;241m1\u001b[39m],s\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n", - "File \u001b[0;32m~/sbi/sbi/inference/posteriors/score_posterior.py:151\u001b[0m, in \u001b[0;36mScorePosterior.sample\u001b[0;34m(self, sample_shape, x, predictor, corrector, predictor_params, corrector_params, steps, ts, max_sampling_batch_size, sample_with, show_progress_bars)\u001b[0m\n\u001b[1;32m 146\u001b[0m num_iter \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 147\u001b[0m num_iter \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (num_samples \u001b[38;5;241m%\u001b[39m max_sampling_batch_size) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m num_iter\n\u001b[1;32m 148\u001b[0m )\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(num_iter):\n\u001b[1;32m 150\u001b[0m samples\u001b[38;5;241m.\u001b[39mappend(\n\u001b[0;32m--> 151\u001b[0m \u001b[43mdiffuser\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 152\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_sampling_batch_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 153\u001b[0m \u001b[43m \u001b[49m\u001b[43mts\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mts\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 154\u001b[0m \u001b[43m \u001b[49m\u001b[43mshow_progress_bars\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshow_progress_bars\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 155\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 156\u001b[0m )\n\u001b[1;32m 157\u001b[0m samples \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mcat(samples, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)[:num_samples]\n\u001b[1;32m 159\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m samples\u001b[38;5;241m.\u001b[39mreshape(sample_shape \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscore_estimator\u001b[38;5;241m.\u001b[39minput_shape)\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/utils/_contextlib.py:115\u001b[0m, in \u001b[0;36mcontext_decorator..decorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 114\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[0;32m--> 115\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/sbi/sbi/samplers/score/score.py:135\u001b[0m, in \u001b[0;36mDiffuser.run\u001b[0;34m(self, num_samples, ts, show_progress_bars, save_intermediate)\u001b[0m\n\u001b[1;32m 133\u001b[0m t1 \u001b[38;5;241m=\u001b[39m ts[i \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m]\n\u001b[1;32m 134\u001b[0m t0 \u001b[38;5;241m=\u001b[39m ts[i]\n\u001b[0;32m--> 135\u001b[0m samples \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredictor\u001b[49m\u001b[43m(\u001b[49m\u001b[43msamples\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt0\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 136\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcorrector \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 137\u001b[0m samples \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcorrector(samples, t0, t1)\n", - "File \u001b[0;32m~/sbi/sbi/samplers/score/predictors.py:60\u001b[0m, in \u001b[0;36mPredictor.__call__\u001b[0;34m(self, theta, t1, t0)\u001b[0m\n\u001b[1;32m 59\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, theta: Tensor, t1: Tensor, t0: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m---> 60\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtheta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt0\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/sbi/sbi/samplers/score/predictors.py:93\u001b[0m, in \u001b[0;36mEulerMaruyama.predict\u001b[0;34m(self, theta, t1, t0)\u001b[0m\n\u001b[1;32m 91\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdrift(theta, t1)\n\u001b[1;32m 92\u001b[0m g \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdiffusion(theta, t1)\n\u001b[0;32m---> 93\u001b[0m score \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscore_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtheta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt1\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 94\u001b[0m f_backward \u001b[38;5;241m=\u001b[39m f \u001b[38;5;241m-\u001b[39m (\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39meta\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m) \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m g\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m score\n\u001b[1;32m 95\u001b[0m g_backward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39meta \u001b[38;5;241m*\u001b[39m g\n", - "File \u001b[0;32m~/sbi/sbi/inference/potentials/score_based_potential.py:101\u001b[0m, in \u001b[0;36mScoreFunction.__call__\u001b[0;34m(self, theta, time, track_gradients)\u001b[0m\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mset_grad_enabled(track_gradients):\n\u001b[1;32m 100\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minterpret_as_iid:\n\u001b[0;32m--> 101\u001b[0m score \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscore_estimator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mforward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 102\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtheta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcondition\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mx_o\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtime\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtime\u001b[49m\n\u001b[1;32m 103\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 104\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 105\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprior \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m~/sbi/sbi/neural_nets/estimators/score_estimator.py:116\u001b[0m, in \u001b[0;36mConditionalScoreEstimator.forward\u001b[0;34m(self, input, condition, time)\u001b[0m\n\u001b[1;32m 113\u001b[0m score_gaussian \u001b[38;5;241m=\u001b[39m (\u001b[38;5;28minput\u001b[39m \u001b[38;5;241m-\u001b[39m mean) \u001b[38;5;241m/\u001b[39m std\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m\n\u001b[1;32m 115\u001b[0m \u001b[38;5;66;03m# Score prediction by the network\u001b[39;00m\n\u001b[0;32m--> 116\u001b[0m score_pred \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnet\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43minput_enc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcondition\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtime_enc\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 118\u001b[0m \u001b[38;5;66;03m# Output pre-conditioned score\u001b[39;00m\n\u001b[1;32m 119\u001b[0m \u001b[38;5;66;03m# The learnable part will be largly scaled at the beginning of the diffusion\u001b[39;00m\n\u001b[1;32m 120\u001b[0m \u001b[38;5;66;03m# and the gaussian part (where it should end up) will dominate at the end of\u001b[39;00m\n\u001b[1;32m 121\u001b[0m \u001b[38;5;66;03m# the diffusion.\u001b[39;00m\n\u001b[1;32m 122\u001b[0m scale \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmean_t_fn(time) \u001b[38;5;241m/\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstd_fn(time)\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/modules/container.py:217\u001b[0m, in \u001b[0;36mSequential.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m):\n\u001b[1;32m 216\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m--> 217\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 218\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28minput\u001b[39m\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/sbi/sbi/neural_nets/score_nets.py:249\u001b[0m, in \u001b[0;36mMLP.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 247\u001b[0m \u001b[38;5;66;03m# Forward pass through hidden layers\u001b[39;00m\n\u001b[1;32m 248\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_layers \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m):\n\u001b[0;32m--> 249\u001b[0m h_new \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlayers\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[43mh\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 250\u001b[0m h \u001b[38;5;241m=\u001b[39m (h \u001b[38;5;241m+\u001b[39m h_new) \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mskip_connection \u001b[38;5;28;01melse\u001b[39;00m h_new\n\u001b[1;32m 252\u001b[0m \u001b[38;5;66;03m# Output layer\u001b[39;00m\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/modules/container.py:217\u001b[0m, in \u001b[0;36mSequential.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m):\n\u001b[1;32m 216\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m--> 217\u001b[0m \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 218\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28minput\u001b[39m\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/modules/normalization.py:201\u001b[0m, in \u001b[0;36mLayerNorm.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m 200\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m--> 201\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlayer_norm\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 202\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnormalized_shape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbias\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43meps\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniconda3/envs/sbi3/lib/python3.11/site-packages/torch/nn/functional.py:2546\u001b[0m, in \u001b[0;36mlayer_norm\u001b[0;34m(input, normalized_shape, weight, bias, eps)\u001b[0m\n\u001b[1;32m 2542\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_variadic(\u001b[38;5;28minput\u001b[39m, weight, bias):\n\u001b[1;32m 2543\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[1;32m 2544\u001b[0m layer_norm, (\u001b[38;5;28minput\u001b[39m, weight, bias), \u001b[38;5;28minput\u001b[39m, normalized_shape, weight\u001b[38;5;241m=\u001b[39mweight, bias\u001b[38;5;241m=\u001b[39mbias, eps\u001b[38;5;241m=\u001b[39meps\n\u001b[1;32m 2545\u001b[0m )\n\u001b[0;32m-> 2546\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlayer_norm\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnormalized_shape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbias\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43meps\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackends\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcudnn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menabled\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] } ], "source": [ "from sbi.utils.metrics import c2st \n", "import matplotlib.pyplot as plt\n", "\n", - "for i in range(1,11):\n", + "for i in range(1,2):\n", " ref_samples = task.get_reference_posterior_samples(i)\n", " x_obs = task.get_observation(i)\n", " samples = posterior.sample((10000,), x=x_obs, steps=1000)\n", - " #print(c2st(ref_samples, samples))\n", + " print(c2st(ref_samples, samples))\n", " plt.scatter(samples[:,0], samples[:,1],s=1)\n", " plt.scatter(ref_samples[:,0], ref_samples[:,1], s=1)\n", " plt.xlim(-1,1)\n", @@ -691,9 +756,26 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ImportError", + "evalue": "cannot import name 'build_linear_classifier' from partially initialized module 'sbi.neural_nets.classifier' (most likely due to a circular import) (/root/sbi/sbi/neural_nets/classifier.py)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[2], line 12\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mtorch\u001b[39;00m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtorch\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Tensor\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneural_nets\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mscore_nets\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m build_score_estimator\n\u001b[1;32m 13\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01minference\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpotentials\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mscore_based_potential\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m 14\u001b[0m score_estimator_based_potential_gradient,\n\u001b[1;32m 15\u001b[0m )\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01msamplers\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mscore\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mscore\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Diffuser\n", + "File \u001b[0;32m~/sbi/sbi/neural_nets/__init__.py:1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneural_nets\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mclassifier\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m 2\u001b[0m build_linear_classifier,\n\u001b[1;32m 3\u001b[0m build_mlp_classifier,\n\u001b[1;32m 4\u001b[0m build_resnet_classifier,\n\u001b[1;32m 5\u001b[0m )\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneural_nets\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01membedding_nets\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m 7\u001b[0m CNNEmbedding,\n\u001b[1;32m 8\u001b[0m FCEmbedding,\n\u001b[1;32m 9\u001b[0m PermutationInvariantEmbedding,\n\u001b[1;32m 10\u001b[0m )\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneural_nets\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mestimators\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m ConditionalDensityEstimator, NFlowsFlow\n", + "File \u001b[0;32m~/sbi/sbi/neural_nets/classifier.py:12\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtorch\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Tensor, nn, relu\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneural_nets\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mratio_estimators\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m RatioEstimator\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mutils\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mnn_utils\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m get_numel\n\u001b[1;32m 13\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mutils\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01msbiutils\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m standardizing_net, z_score_parser\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mutils\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01muser_input_checks\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m check_data_device\n", + "File \u001b[0;32m~/sbi/sbi/utils/__init__.py:72\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mutils\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01muser_input_checks\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m 64\u001b[0m check_estimator_arg,\n\u001b[1;32m 65\u001b[0m check_prior,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 69\u001b[0m validate_theta_and_x,\n\u001b[1;32m 70\u001b[0m )\n\u001b[1;32m 71\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mutils\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01muser_input_checks_utils\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m MultipleIndependent\n\u001b[0;32m---> 72\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mutils\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mget_nn_models\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m posterior_nn, likelihood_nn, classifier_nn\n", + "File \u001b[0;32m~/sbi/sbi/utils/get_nn_models.py:9\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mwarnings\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m warn\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtorch\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m nn\n\u001b[0;32m----> 9\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneural_nets\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mfactory\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m classifier_nn \u001b[38;5;28;01mas\u001b[39;00m classifier_nn_moved_to_neural_nets\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneural_nets\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mfactory\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m likelihood_nn \u001b[38;5;28;01mas\u001b[39;00m likelihood_nn_moved_to_neural_nets\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneural_nets\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mfactory\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m posterior_nn \u001b[38;5;28;01mas\u001b[39;00m posterior_nn_moved_to_neural_nets\n", + "File \u001b[0;32m~/sbi/sbi/neural_nets/factory.py:9\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtyping\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Any, Callable, Optional, Union\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtorch\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m nn\n\u001b[0;32m----> 9\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneural_nets\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mclassifier\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m 10\u001b[0m build_linear_classifier,\n\u001b[1;32m 11\u001b[0m build_mlp_classifier,\n\u001b[1;32m 12\u001b[0m build_resnet_classifier,\n\u001b[1;32m 13\u001b[0m )\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneural_nets\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mflow\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[1;32m 15\u001b[0m build_made,\n\u001b[1;32m 16\u001b[0m build_maf,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 27\u001b[0m build_zuko_unaf,\n\u001b[1;32m 28\u001b[0m )\n\u001b[1;32m 29\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msbi\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mneural_nets\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmdn\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m build_mdn\n", + "\u001b[0;31mImportError\u001b[0m: cannot import name 'build_linear_classifier' from partially initialized module 'sbi.neural_nets.classifier' (most likely due to a circular import) (/root/sbi/sbi/neural_nets/classifier.py)" + ] + } + ], "source": [ "# This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed\n", "# under the Apache License Version 2.0, see \n",