From 3c1e7250192041d995d8fda368d421919400a499 Mon Sep 17 00:00:00 2001 From: Julia Linhart <44973138+JuliaLinhart@users.noreply.github.com> Date: Fri, 17 May 2024 12:35:19 +0200 Subject: [PATCH] feat: local c2st metric (#1109) * lc2st class - first imp * null hypothesis * start of notebook * LC2ST class and notebook version 2 * notebook with graphical diagnostics on GaussianMixture * missing text in notebook and final fixes * move gaussian_mixture model from utils to sbi.simulators * ruff fix * ruff fix * typing fix and small doc changes * fix bug in return `statistic_data`, no prepare_for_sbi in notebook * bug fix in args of `statistics_data` * fixes suggested by reviewer @agramfort, doc and typing * changes simulator gaussian_mixture * variable name changes pep8 and sbi convention * more explicit method names and custom clf_kwargs * remove pandas dependency * tutorial results description and other fixes for PR * clarifications lc2st-nf * ruff check fix * 10 --> 100 test runs * negatif --> negativ * rebase changes + pytest fix * ensembling * ruff fix * add reference for pp-plot Co-authored-by: Peter Steinbach * tutorial changes and ruff * change the default n_ensemble back to 1, explain in tutorial and lc2st doc * change the default n_ensemble back to 1, explain in tutorial and lc2st doc * ensembling, clf-choice in tutorial, lc2st-nf description in doc * pyright fix --------- Co-authored-by: Peter Steinbach Co-authored-by: Jan --- sbi/analysis/__init__.py | 3 + sbi/analysis/plot.py | 240 ++++- sbi/diagnostics/lc2st.py | 779 +++++++++++++++ sbi/simulators/gaussian_mixture.py | 167 ++++ sbi/utils/analysis_utils.py | 51 +- tests/lc2st_test.py | 266 +++++ tutorials/00_getting_started_flexible.ipynb | 2 +- .../17_importance_sampled_posteriors.ipynb | 28 +- tutorials/18_diagnostics_lc2st.ipynb | 907 ++++++++++++++++++ 9 files changed, 2426 insertions(+), 17 deletions(-) create mode 100644 sbi/diagnostics/lc2st.py create mode 100644 sbi/simulators/gaussian_mixture.py create mode 100644 tests/lc2st_test.py create mode 100644 tutorials/18_diagnostics_lc2st.ipynb diff --git a/sbi/analysis/__init__.py b/sbi/analysis/__init__.py index d54971c44..dc18f5819 100644 --- a/sbi/analysis/__init__.py +++ b/sbi/analysis/__init__.py @@ -9,7 +9,10 @@ conditional_marginal_plot, conditional_pairplot, marginal_plot, + marginal_plot_with_probs_intensity, pairplot, + pp_plot, + pp_plot_lc2st, sbc_rank_plot, ) from sbi.analysis.sensitivity_analysis import ActiveSubspace diff --git a/sbi/analysis/plot.py b/sbi/analysis/plot.py index 300038f1a..47458ed79 100644 --- a/sbi/analysis/plot.py +++ b/sbi/analysis/plot.py @@ -2,20 +2,24 @@ # under the Apache License Version 2.0, see import collections -from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from typing import Any, Callable, Dict, List, Optional, Tuple, Union, cast from warnings import warn import matplotlib as mpl import numpy as np import six import torch +from matplotlib import cm from matplotlib import pyplot as plt from matplotlib.axes import Axes +from matplotlib.colors import Normalize from matplotlib.figure import Figure, FigureBase +from matplotlib.patches import Rectangle from scipy.stats import binom, gaussian_kde, iqr from torch import Tensor from sbi.analysis import eval_conditional_density +from sbi.utils.analysis_utils import pp_vals try: collectionsAbc = collections.abc # type: ignore @@ -1832,6 +1836,240 @@ def _plot_hist_region_expected_under_uniformity( ) +# Diagnostics for hypothesis tests + + +def pp_plot( + scores: Union[List[np.ndarray], Dict[Any, np.ndarray]], + scores_null: Union[List[np.ndarray], Dict[Any, np.ndarray]], + true_scores_null: np.ndarray, + conf_alpha: float, + n_alphas: int = 100, + labels: Optional[List[str]] = None, + colors: Optional[List[str]] = None, + ax: Optional[Axes] = None, + **kwargs: Any, +) -> Axes: + """Probability - Probability (P-P) plot for hypothesis tests + to assess the validity of one (or several) estimator(s). + + See [here](https://en.wikipedia.org/wiki/P%E2%80%93P_plot) for more details. + + Args: + scores: test scores estimated on observed data and evaluated on the test set, + of shape (n_eval,). One array per estimator. + scores_null: test scores estimated under the null hypothesis and evaluated on + the test set, of shape (n_eval,). One array per null trial. + true_scores_null: theoretical true scores under the null hypothesis, + of shape (n_eval,). + labels: labels for the estimators, defaults to None. + colors: colors for the estimators, defaults to None. + conf_alpha: significanecee level of the hypothesis test. + n_alphas: number of cdf-values to compute the P-P plot, defaults to 100. + ax: axis to plot on, defaults to None. + kwargs: additional arguments for matplotlib plotting. + + Returns: + ax: axes with the P-P plot. + """ + if ax is None: + ax = plt.gca() + ax_: Axes = cast(Axes, ax) # cast to fix pyright error + + alphas = np.linspace(0, 1, n_alphas) + + # pp_vals for the true null hypothesis + pp_vals_true = pp_vals(true_scores_null, alphas) + ax_.plot(alphas, pp_vals_true, "--", color="black", label="True Null (H0)") + + # pp_vals for the estimated null hypothesis over the multiple trials + pp_vals_null = [] + for t in range(len(scores_null)): + pp_vals_null.append(pp_vals(scores_null[t], alphas)) + pp_vals_null = np.array(pp_vals_null) + + # confidence region + quantiles = np.quantile(pp_vals_null, [conf_alpha / 2, 1 - conf_alpha / 2], axis=0) + ax_.fill_between( + alphas, + quantiles[0], + quantiles[1], + color="grey", + alpha=0.2, + label=f"{(1 - conf_alpha) * 100}% confidence region", + ) + + # pp_vals for the observed data + for i, p_ in enumerate(scores): + pp_vals_o = pp_vals(p_, alphas) + if labels is not None: + kwargs["label"] = labels[i] + if colors is not None: + kwargs["color"] = colors[i] + ax_.plot(alphas, pp_vals_o, **kwargs) + return ax_ + + +def marginal_plot_with_probs_intensity( + probs_per_marginal: dict, + marginal_dim: int, + n_bins: int = 20, + vmin: float = 0.0, + vmax: float = 1.0, + cmap_name: str = "Spectral_r", + show_colorbar: bool = True, + label: Optional[str] = None, + ax: Optional[Axes] = None, +) -> Axes: + """Plot 1d or 2d marginal histogram of samples of the density estimator + with probabilities as color intensity. + + Args: + probs_per_marginal: dataframe with predicted class probabilities + as obtained from `sbi.utils.analysis_utils.get_probs_per_marginal`. + marginal_dim: dimension of the marginal histogram to plot. + n_bins: number of bins for the histogram, defaults to 20. + vmin: minimum value for the color intensity, defaults to 0. + vmax: maximum value for the color intensity, defaults to 1. + cmap: colormap for the color intensity, defaults to "Spectral_r". + show_colorbar: whether to show the colorbar, defaults to True. + label: label for the colorbar, defaults to None. + ax (matplotlib.axes.Axes): axes to plot on, defaults to None. + + Returns: + ax (matplotlib.axes.Axes): axes with the plot. + """ + assert marginal_dim in [1, 2], "Only 1d or 2d marginals are supported." + + if ax is None: + ax = plt.gca() + ax_: Axes = cast(Axes, ax) # cast to fix pyright error + + if label is None: + label = "probability" + + # get colormap + cmap = cm.get_cmap(cmap_name) + + # case of 1d marginal + if marginal_dim == 1: + # extract bins and patches + _, bins, patches = ax_.hist( + probs_per_marginal['s'], n_bins, density=True, color="green" + ) + # create bins: all samples between bin edges are assigned to the same bin + probs_per_marginal["bins"] = np.searchsorted(bins, probs_per_marginal['s']) - 1 + probs_per_marginal["bins"][probs_per_marginal["bins"] < 0] = 0 + # get mean prob for each bin (same as pandas groupy method) + array_probs = np.concatenate( + [probs_per_marginal['bins'][:, None], probs_per_marginal['probs'][:, None]], + axis=1, + ) + array_probs = array_probs[array_probs[:, 0].argsort()] + weights = np.split( + array_probs[:, 1], np.unique(array_probs[:, 0], return_index=True)[1][1:] + ) + weights = np.array([np.mean(w) for w in weights]) + # remove empty bins + id = list(set(range(n_bins)) - set(probs_per_marginal['bins'])) + patches = np.delete(patches, id) + bins = np.delete(bins, id) + + # normalize color intensity + norm = Normalize(vmin=vmin, vmax=vmax) + # set color intensity + for w, p in zip(weights, patches): + p.set_facecolor(cmap(w)) + if show_colorbar: + plt.colorbar(cm.ScalarMappable(norm=norm, cmap=cmap), ax=ax_, label=label) + + if marginal_dim == 2: + # extract bin edges + _, x, y = np.histogram2d( + probs_per_marginal['s_1'], probs_per_marginal['s_2'], bins=n_bins + ) + # create bins: all samples between bin edges are assigned to the same bin + probs_per_marginal["bins_x"] = np.searchsorted(x, probs_per_marginal['s_1']) - 1 + probs_per_marginal["bins_y"] = np.searchsorted(y, probs_per_marginal['s_2']) - 1 + probs_per_marginal["bins_x"][probs_per_marginal["bins_x"] < 0] = 0 + probs_per_marginal["bins_y"][probs_per_marginal["bins_y"] < 0] = 0 + + # extract unique bin pairs + group_idx = np.concatenate( + [ + probs_per_marginal['bins_x'][:, None], + probs_per_marginal['bins_y'][:, None], + ], + axis=1, + ) + unique_bins = np.unique(group_idx, return_counts=True, axis=0)[0] + + # get mean prob for each bin (same as pandas groupy method) + mean_probs = np.zeros((len(unique_bins),)) + for i in range(len(unique_bins)): + idx = np.where((group_idx == unique_bins[i]).all(axis=1)) + mean_probs[i] = np.mean(probs_per_marginal['probs'][idx]) + + # create weight matrix with nan values for non-existing bins + weights = np.zeros((n_bins, n_bins)) + weights[:] = np.nan + weights[unique_bins[:, 0], unique_bins[:, 1]] = mean_probs + + # set color intensity + norm = Normalize(vmin=vmin, vmax=vmax) + for i in range(len(x) - 1): + for j in range(len(y) - 1): + facecolor = cmap(norm(weights.T[j, i])) + # if no sample in bin, set color to white + if weights.T[j, i] == np.nan: + facecolor = "white" + rect = Rectangle( + (x[i], y[j]), + x[i + 1] - x[i], + y[j + 1] - y[j], + facecolor=facecolor, + edgecolor="none", + ) + ax_.add_patch(rect) + if show_colorbar: + plt.colorbar(cm.ScalarMappable(norm=norm, cmap=cmap), ax=ax_, label=label) + + return ax_ + + +# Customized plotting functions for LC2ST + + +def pp_plot_lc2st( + probs: Union[List[np.ndarray], Dict[Any, np.ndarray]], + probs_null: Union[List[np.ndarray], Dict[Any, np.ndarray]], + conf_alpha: float, + **kwargs: Any, +) -> Axes: + """Probability - Probability (P-P) plot for LC2ST. + + Args: + probs: predicted probability on observed data and evaluated on the test set, + of shape (n_eval,). One array per estimator. + probs_null: predicted probability under the null hypothesis and evaluated on + the test set, of shape (n_eval,). One array per null trial. + conf_alpha: significanecee level of the hypothesis test. + kwargs: additional arguments for `pp_plot`. + + Returns: + ax: axes with the P-P plot. + """ + # probability at chance level (under the null) is 0.5 + true_probs_null = np.array([0.5] * len(probs)) + return pp_plot( + scores=probs, + scores_null=probs_null, + true_scores_null=true_probs_null, + conf_alpha=conf_alpha, + **kwargs, + ) + + # TO BE DEPRECATED # ---------------- def pairplot_dep( diff --git a/sbi/diagnostics/lc2st.py b/sbi/diagnostics/lc2st.py new file mode 100644 index 000000000..0fc16de4b --- /dev/null +++ b/sbi/diagnostics/lc2st.py @@ -0,0 +1,779 @@ +from typing import Any, Callable, Dict, List, Optional, Tuple, Union + +import numpy as np +import torch +from sklearn.base import BaseEstimator, clone +from sklearn.ensemble import RandomForestClassifier +from sklearn.model_selection import KFold +from sklearn.neural_network import MLPClassifier +from torch import Tensor +from tqdm import tqdm + + +class LC2ST: + def __init__( + self, + thetas: Tensor, + xs: Tensor, + posterior_samples: Tensor, + seed: int = 1, + num_folds: int = 1, + num_ensemble: int = 1, + classifier: str = "mlp", + z_score: bool = False, + clf_class: Optional[Any] = None, + clf_kwargs: Optional[Dict[str, Any]] = None, + num_trials_null: int = 100, + permutation: bool = True, + ) -> None: + """ + L-C2ST: Local Classifier Two-Sample Test + ----------------------------------------- + Implementation based on the official code from [1] and the exisiting C2ST + metric [2], using scikit-learn classifiers. + + L-C2ST tests the local consistency of a posterior estimator q w.r.t. to the true + posterior p, at fixed observation `x_o`, i.e. whether the following null + hypothesis holds: $H_0(x_o) := q(\theta | x_o) = p(\theta | x_o)$. + + 1. Trains a classifier to distinguish between samples from two joint + distributions [theta_p, x_p] and [theta_q, x_q] and evaluates the L-C2ST + statistic at a given observation `x_o`. + 2. The L-C2ST statistic is the mean squared error between the predicted + probabilities of being in p (class 0) and a Dirac at 0.5, which corresponds to + the chance level of the classifier, unable to distinguish between p and q. + - If `num_ensemble`>1, the average prediction over all classifiers is used. + - If `num_folds`>1 the average statistic over all cv-folds is used. + + To evaluate the test, steps 1 and 2 are performed over multiple trials under the + null hypothesis (H0). If the null distribution is not known, it is estimated + using the permutation method, i.e. by training the classifier on the permuted + data. The statistics obtained under (H0) is then compared to the one obtained + on observed data to compute the p-value, used to decide whether to reject (H0) + or not. + + + Args: + thetas: Samples from the prior, of shape (sample_size, dim). + xs: Corresponding simulated data, of shape (sample_size, dim_x). + posterior_samples: Samples from the estiamted posterior, + of shape (sample_size, dim) + seed: Seed for the sklearn classifier and the KFold cross validation, + defaults to 1. + num_folds: Number of folds for the cross-validation, + defaults to 1 (no cross-validation). + This is useful to reduce variance coming from the data. + num_ensemble: Number of classifiers for ensembling, defaults to 1. + This is useful to reduce variance coming from the classifier. + z_score: Whether to z-score to normalize the data, defaults to False. + classifier: Classification architecture to use, + possible values: "random_forest" or "mlp", defaults to "mlp". + clf_class: Custom sklearn classifier class, defaults to None. + clf_kwargs: Custom kwargs for the sklearn classifier, defaults to None. + num_trials_null: Number of trials to estimate the null distribution, + defaults to 100. + permutation: Whether to use the permutation method for the null hypothesis, + defaults to True. + + References: + [1] : https://arxiv.org/abs/2306.03580, https://github.com/JuliaLinhart/lc2st + [2] : https://github.com/sbi-dev/sbi/blob/main/sbi/utils/metrics.py + """ + + assert ( + thetas.shape[0] == xs.shape[0] == posterior_samples.shape[0] + ), "Number of samples must match" + + # set observed data for classification + self.theta_p = posterior_samples + self.x_p = xs + self.theta_q = thetas + self.x_q = xs + + # z-score normalization parameters + self.z_score = z_score + self.theta_p_mean = torch.mean(self.theta_p, dim=0) + self.theta_p_std = torch.std(self.theta_p, dim=0) + self.x_p_mean = torch.mean(self.x_p, dim=0) + self.x_p_std = torch.std(self.x_p, dim=0) + + # set parameters for classifier training + self.seed = seed + self.num_folds = num_folds + self.num_ensemble = num_ensemble + + # initialize classifier + if "mlp" in classifier.lower(): + ndim = thetas.shape[-1] + self.clf_class = MLPClassifier + if clf_kwargs is None: + self.clf_kwargs = { + "activation": "relu", + "hidden_layer_sizes": (10 * ndim, 10 * ndim), + "max_iter": 1000, + "solver": "adam", + "early_stopping": True, + "n_iter_no_change": 50, + } + elif "random_forest" in classifier.lower(): + self.clf_class = RandomForestClassifier + if clf_kwargs is None: + self.clf_kwargs = {} + elif "custom": + if clf_class is None or clf_kwargs is None: + raise ValueError( + "Please provide a valid sklearn classifier class and kwargs." + ) + self.clf_class = clf_class + self.clf_kwargs = clf_kwargs + else: + raise NotImplementedError + + # initialize classifiers, will be set after training + self.trained_clfs = None + self.trained_clfs_null = None + + # parameters for the null hypothesis testing + self.num_trials_null = num_trials_null + self.permutation = permutation + # can be specified if known and independent of x (see `LC2ST-NF`) + self.null_distribution = None + + def _train( + self, + theta_p: Tensor, + theta_q: Tensor, + x_p: Tensor, + x_q: Tensor, + verbosity: int = 0, + ) -> List[Any]: + """Returns the classifiers trained on observed data. + + Args: + theta_p: Samples from P, of shape (sample_size, dim). + theta_q: Samples from Q, of shape (sample_size, dim). + x_p: Observations corresponding to P, of shape (sample_size, dim_x). + x_q: Observations corresponding to Q, of shape (sample_size, dim_x). + verbosity: Verbosity level, defaults to 0. + + Returns: + List of trained classifiers for each cv fold. + """ + + # prepare data + + if self.z_score: + theta_p = (theta_p - self.theta_p_mean) / self.theta_p_std + theta_q = (theta_q - self.theta_p_mean) / self.theta_p_std + x_p = (x_p - self.x_p_mean) / self.x_p_std + x_q = (x_q - self.x_p_mean) / self.x_p_std + + # initialize classifier + clf = self.clf_class(**self.clf_kwargs or {}) + + if self.num_ensemble > 1: + clf = EnsembleClassifier(clf, self.num_ensemble, verbosity=verbosity) + + # cross-validation + if self.num_folds > 1: + trained_clfs = [] + kf = KFold(n_splits=self.num_folds, shuffle=True, random_state=self.seed) + cv_splits = kf.split(theta_p.numpy()) + for train_idx, _ in tqdm( + cv_splits, desc="Cross-validation", disable=verbosity < 1 + ): + # get train split + theta_p_train, theta_q_train = theta_p[train_idx], theta_q[train_idx] + x_p_train, x_q_train = x_p[train_idx], x_q[train_idx] + + # train classifier + clf_n = train_lc2st( + theta_p_train, theta_q_train, x_p_train, x_q_train, clf + ) + + trained_clfs.append(clf_n) + else: + # train single classifier + clf = train_lc2st(theta_p, theta_q, x_p, x_q, clf) + trained_clfs = [clf] + + return trained_clfs + + def get_scores( + self, + theta_o: Tensor, + x_o: Tensor, + trained_clfs: List[Any], + return_probs: bool = False, + ) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]: + """Computes the L-C2ST scores given the trained classifiers: + Mean squared error (MSE) between 0.5 and the predicted probabilities + of being in class 0 over the dataset (`theta_o`, `x_o`). + + Args: + theta_o: Samples from the posterior conditioned on the observation `x_o`, + of shape (sample_size, dim). + x_o: The observation, of shape (,dim_x). + trained_clfs: List of trained classifiers, of length `num_folds`. + return_probs: Whether to return the predicted probabilities of being in P, + defaults to False. + + Returns: one of + scores: L-C2ST scores at `x_o`, of shape (`num_folds`,). + (probs, scores): Predicted probabilities and L-C2ST scores at `x_o`, + each of shape (`num_folds`,). + """ + # prepare data + if self.z_score: + theta_o = (theta_o - self.theta_p_mean) / self.theta_p_std + x_o = (x_o - self.x_p_mean) / self.x_p_std + + probs, scores = [], [] + + # evaluate classifiers + for clf in trained_clfs: + proba, score = eval_lc2st(theta_o, x_o, clf, return_proba=True) + probs.append(proba) + scores.append(score) + probs, scores = np.array(probs), np.array(scores) + + if return_probs: + return probs, scores + else: + return scores + + def train_on_observed_data( + self, seed: Optional[int] = None, verbosity: int = 1 + ) -> Union[None, List[Any]]: + """Trains the classifier on the observed data. + Saves the trained classifier(s) as a list of length `num_folds`. + + Args: + seed: random state of the classifier, defaults to None. + verbosity: Verbosity level, defaults to 1. + """ + # set random state + if seed is not None: + if "random_state" in self.clf_kwargs: + print("WARNING: changing the random state of the classifier.") + self.clf_kwargs["random_state"] = seed # type: ignore + + # train the classifier + trained_clfs = self._train( + self.theta_p, self.theta_q, self.x_p, self.x_q, verbosity=verbosity + ) + self.trained_clfs = trained_clfs + + def get_statistic_on_observed_data( + self, + theta_o: Tensor, + x_o: Tensor, + ) -> float: + """Computes the L-C2ST statistics for the observed data: + Mean over all cv-scores. + + Args: + theta_o: Samples from the posterior conditioned on the observation `x_o`, + of shape (sample_size, dim). + x_o: The observation, of shape (, dim_x) + + Returns: + L-C2ST statistic at `x_o`. + """ + assert ( + self.trained_clfs is not None + ), "No trained classifiers found. Run `train_on_observed_data` first." + _, scores = self.get_scores( + theta_o=theta_o, + x_o=x_o, + trained_clfs=self.trained_clfs, + return_probs=True, + ) + return scores.mean() + + def p_value( + self, + theta_o: Tensor, + x_o: Tensor, + ) -> float: + r"""Computes the p-value for L-C2ST. + + The p-value is the proportion of times the L-C2ST statistic under the null + hypothesis is greater than the L-C2ST statistic at the observation `x_o`. + It is computed by taking the empirical mean over statistics computed on + several trials under the null hypothesis: $1/H \sum_{h=1}^{H} I(T_h < T_o)$. + + Args: + theta_o: Samples from the posterior conditioned on the observation `x_o`, + of dhape (sample_size, dim). + x_o: The observation, of shape (, dim_x). + + Returns: + p-value for L-C2ST at `x_o`. + """ + stat_data = self.get_statistic_on_observed_data(theta_o=theta_o, x_o=x_o) + _, stats_null = self.get_statistics_under_null_hypothesis( + theta_o=theta_o, x_o=x_o, return_probs=True, verbosity=0 + ) + return (stat_data < stats_null).mean() + + def reject_test( + self, + theta_o: Tensor, + x_o: Tensor, + alpha: float = 0.05, + ) -> bool: + """Computes the test result for L-C2ST at a given significance level. + + Args: + theta_o: Samples from the posterior conditioned on the observation `x_o`, + of shape (sample_size, dim). + x_o: The observation, of shape (, dim_x). + alpha: Significance level, defaults to 0.05. + + Returns: + The L-C2ST result: True if rejected, False otherwise. + """ + return self.p_value(theta_o=theta_o, x_o=x_o) < alpha + + def train_under_null_hypothesis( + self, + verbosity: int = 1, + ) -> None: + """Computes the L-C2ST scores under the null hypothesis (H0). + Saves the trained classifiers for each null trial. + + Args: + verbosity: Verbosity level, defaults to 1. + """ + + trained_clfs_null = {} + for t in tqdm( + range(self.num_trials_null), + desc=f"Training the classifiers under H0, permutation = {self.permutation}", + disable=verbosity < 1, + ): + # prepare data + if self.permutation: + joint_p = torch.cat([self.theta_p, self.x_p], dim=1) + joint_q = torch.cat([self.theta_q, self.x_q], dim=1) + # permute data (same as permuting the labels) + joint_p_perm, joint_q_perm = permute_data(joint_p, joint_q, seed=t) + # extract the permuted P and Q and x + theta_p_t, x_p_t = ( + joint_p_perm[:, : self.theta_p.shape[-1]], + joint_p_perm[:, self.theta_p.shape[1] :], + ) + theta_q_t, x_q_t = ( + joint_q_perm[:, : self.theta_q.shape[-1]], + joint_q_perm[:, self.theta_q.shape[1] :], + ) + else: + assert ( + self.null_distribution is not None + ), "You need to provide a null distribution" + theta_p_t = self.null_distribution.sample((self.theta_p.shape[0],)) + theta_q_t = self.null_distribution.sample((self.theta_p.shape[0],)) + x_p_t, x_q_t = self.x_p, self.x_q + + if self.z_score: + theta_p_t = (theta_p_t - self.theta_p_mean) / self.theta_p_std + theta_q_t = (theta_q_t - self.theta_p_mean) / self.theta_p_std + x_p_t = (x_p_t - self.x_p_mean) / self.x_p_std + x_q_t = (x_q_t - self.x_p_mean) / self.x_p_std + + # train + clf_t = self._train(theta_p_t, theta_q_t, x_p_t, x_q_t, verbosity=0) + trained_clfs_null[t] = clf_t + + self.trained_clfs_null = trained_clfs_null + + def get_statistics_under_null_hypothesis( + self, + theta_o: Tensor, + x_o: Tensor, + return_probs: bool = False, + verbosity: int = 0, + ) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]: + """Computes the L-C2ST scores under the null hypothesis. + + Args: + theta_o: Samples from the posterior conditioned on the observation `x_o`, + of shape (sample_size, dim). + x_o: The observation, of shape (, dim_x). + return_probs: Whether to return the predicted probabilities of being in P, + defaults to False. + verbosity: Verbosity level, defaults to 1. + + Returns: one of + scores: L-C2ST scores under (H0). + (probs, scores): Predicted probabilities and L-C2ST scores under (H0). + """ + + if self.trained_clfs_null is None: + raise ValueError( + "You need to train the classifiers under (H0). \ + Run `train_under_null_hypothesis`." + ) + else: + assert ( + len(self.trained_clfs_null) == self.num_trials_null + ), "You need one classifier per trial." + + probs_null, stats_null = [], [] + for t in tqdm( + range(self.num_trials_null), + desc=f"Computing T under (H0) - permutation = {self.permutation}", + disable=verbosity < 1, + ): + # prepare data + if self.permutation: + theta_o_t = theta_o + else: + assert ( + self.null_distribution is not None + ), "You need to provide a null distribution" + + theta_o_t = self.null_distribution.sample((theta_o.shape[0],)) + + if self.z_score: + theta_o_t = (theta_o_t - self.theta_p_mean) / self.theta_p_std + x_o = (x_o - self.x_p_mean) / self.x_p_std + + # evaluate + clf_t = self.trained_clfs_null[t] + probs, scores = self.get_scores( + theta_o=theta_o_t, x_o=x_o, trained_clfs=clf_t, return_probs=True + ) + probs_null.append(probs) + stats_null.append(scores.mean()) + + probs_null, stats_null = np.array(probs_null), np.array(stats_null) + + if return_probs: + return probs_null, stats_null + else: + return stats_null + + +class LC2ST_NF(LC2ST): + def __init__( + self, + thetas: Tensor, + xs: Tensor, + posterior_samples: Tensor, + flow_inverse_transform: Callable[[Tensor, Tensor], Tensor], + flow_base_dist: torch.distributions.Distribution, + num_eval: int = 10_000, + trained_clfs_null: Optional[Dict[str, List[Any]]] = None, + **kwargs: Any, + ) -> None: + """ + L-C2ST for Normalizing Flows. + + LC2ST_NF is a subclass of LC2ST that performs the test in the space of the + base distribution of a normalizing flow. It uses the inverse transform of the + normalizing flow $T_\\phi^{-1}$ to map the samples from the prior and the + posterior to the base distribution space. Following Theorem 4, Eq. 17 from [1], + the new null hypothesis for a Gaussian base distribution is: + + $H_0(x_o) := p(T_\\phi^{-1}(\theta ; x_o) | x_o) = N(0, I_m)$. + + This is because a sample from the NF is a sample from the base distribution + pushed through the flow: + + $z = T_\\phi^{-1}(\\theta) \\sim N(0, I_m) \\iff theta = T_\\phi(z)$. + + This defines the two classes P and Q for the L-C2ST test, one of which is + the Gaussion distribution that can be easily be sampled from and is independent + of the observation `x_o` and the estimator q. + + Important features are: + - no `theta_o` is passed to the evaluation functions (e.g. `get_scores`), + as the base distribution is known, samples are drawn at initialization. + - no permutation method is used, as the null distribution is known, + samples are drawn during `train_under_null_hypothesis`. + - the classifiers can be pre-trained under the null and `trained_clfs_null` + passed as an argument at initialization. They do not depend on the + observed data (i.e. `posterior_samples` and `xs`). + + Args: + thetas: Samples from the prior, of shape (sample_size, dim). + xs: Corresponding simulated data, of shape (sample_size, dim_x). + posterior_samples: Samples from the estiamted posterior, + of shape (sample_size, dim). + flow_inverse_transform: Inverse transform of the normalizing flow. + Takes thetas and xs as input and returns noise. + flow_base_dist: Base distribution of the normalizing flow. + num_eval: Number of samples to evaluate the L-C2ST. + trained_clfs_null: Pre-trained classifiers under the null. + kwargs: Additional arguments for the LC2ST class. + + References: + [1] : https://arxiv.org/abs/2306.03580, https://github.com/JuliaLinhart/lc2st + """ + # Aplly the inverse transform to the thetas and the posterior samples + self.flow_inverse_transform = flow_inverse_transform + inverse_thetas = flow_inverse_transform(thetas, xs).detach() + inverse_posterior_samples = flow_inverse_transform( + posterior_samples, xs + ).detach() + + # Initialize the LC2ST class with the inverse transformed samples + super().__init__(inverse_thetas, xs, inverse_posterior_samples, **kwargs) + + # Set the parameters for the null hypothesis testing + self.null_distribution = flow_base_dist + self.permutation = False + self.trained_clfs_null = trained_clfs_null + + # Draw samples from the base distribution for evaluation + self.theta_o = flow_base_dist.sample(torch.Size([num_eval])) + + def get_scores( + self, + x_o: Tensor, + trained_clfs: List[Any], + return_probs: bool = False, + **kwargs: Any, + ) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]: + """Computes the L-C2ST scores given the trained classifiers. + + Args: + x_o: The observation, of shape (,dim_x). + trained_clfs: Trained classifiers. + return_probs: Whether to return the predicted probabilities of being in P, + defaults to False. + kwargs: Additional arguments used in the parent class. + + Returns: one of + scores: L-C2ST scores at `x_o`. + (probs, scores): Predicted probabilities and L-C2ST scores at `x_o`. + """ + return super().get_scores( + theta_o=self.theta_o, + x_o=x_o, + trained_clfs=trained_clfs, + return_probs=return_probs, + ) + + def get_statistic_on_observed_data( + self, + x_o: Tensor, + **kwargs: Any, + ) -> float: + """Computes the L-C2ST statistics for the observed data: + Mean over all cv-scores. + + Args: + x_o: The observation, of shape (, dim_x). + kwargs: Additional arguments used in the parent class. + + Returns: + L-C2ST statistic at `x_o`. + """ + return super().get_statistic_on_observed_data(theta_o=self.theta_o, x_o=x_o) + + def p_value( + self, + x_o: Tensor, + **kwargs: Any, + ) -> float: + r"""Computes the p-value for L-C2ST. + + The p-value is the proportion of times the L-C2ST statistic under the null + hypothesis is greater than the L-C2ST statistic at the observation `x_o`. + It is computed by taking the empirical mean over statistics computed on + several trials under the null hypothesis: $1/H \sum_{h=1}^{H} I(T_h < T_o)$. + + Args: + x_o: The observation, of shape (, dim_x). + kwargs: Additional arguments used in the parent class. + + Returns: + p-value for L-C2ST at `x_o`. + """ + return super().p_value(theta_o=self.theta_o, x_o=x_o) + + def reject_test( + self, + x_o: Tensor, + alpha: float = 0.05, + **kwargs: Any, + ) -> bool: + """Computes the test result for L-C2ST at a given significance level. + + Args: + x_o: The observation, of shape (, dim_x). + alpha: Significance level, defaults to 0.05. + kwargs: Additional arguments used in the parent class. + + Returns: + L-C2ST result: True if rejected, False otherwise. + """ + return super().reject_test(theta_o=self.theta_o, x_o=x_o, alpha=alpha) + + def train_under_null_hypothesis( + self, + verbosity: int = 1, + ) -> None: + """Computes the L-C2ST scores under the null hypothesis. + Saves the trained classifiers for the null distribution. + + Args: + verbosity: Verbosity level, defaults to 1. + """ + if self.trained_clfs_null is not None: + raise ValueError( + "Classifiers have already been trained under the null \ + and can be used to evaluate any new estimator." + ) + return super().train_under_null_hypothesis(verbosity=verbosity) + + def get_statistics_under_null_hypothesis( + self, + x_o: Tensor, + return_probs: bool = False, + verbosity: int = 0, + **kwargs: Any, + ) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]: + """Computes the L-C2ST scores under the null hypothesis. + + Args: + x_o: The observation. + Shape (, dim_x) + return_probs: Whether to return the predicted probabilities of being in P. + Defaults to False. + verbosity: Verbosity level, defaults to 1. + kwargs: Additional arguments used in the parent class. + """ + return super().get_statistics_under_null_hypothesis( + theta_o=self.theta_o, + x_o=x_o, + return_probs=return_probs, + verbosity=verbosity, + ) + + +def train_lc2st( + theta_p: Tensor, theta_q: Tensor, x_p: Tensor, x_q: Tensor, clf: BaseEstimator +) -> Any: + """Trains the classifier on the joint data for the L-C2ST. + + Args: + theta_p: Samples from P, of shape (sample_size, dim). + theta_q: Samples from Q, of shape (sample_size, dim). + x_p: Observations corresponding to P, of shape (sample_size, dim_x). + x_q: Observations corresponding to Q, of shape (sample_size, dim_x). + clf: Classifier to train. + + Returns: + Trained classifier. + """ + # cpu and numpy + theta_p = theta_p.cpu().numpy() + theta_q = theta_q.cpu().numpy() + x_p = x_p.cpu().numpy() + x_q = x_q.cpu().numpy() + + # concatenate to get joint data + joint_p = np.concatenate([theta_p, x_p], axis=1) + joint_q = np.concatenate([theta_q, x_q], axis=1) + + # prepare data + data = np.concatenate((joint_p, joint_q)) + # labels + target = np.concatenate(( + np.zeros((joint_p.shape[0],)), + np.ones((joint_q.shape[0],)), + )) + + # train classifier + clf_ = clone(clf) + clf_.fit(data, target) # type: ignore + + return clf_ + + +def eval_lc2st( + theta_p: Tensor, x_o: Tensor, clf: BaseEstimator, return_proba: bool = False +) -> Union[float, Tuple[np.ndarray, float]]: + """Evaluates the classifier returned by `train_lc2st` for one observation + `x_o` and over the samples `P`. + + Args: + theta_p: Samples from p (class 0), of shape (sample_size, dim). + x_o: The observation, of shape (, dim_x). + clf: Trained classifier. + return_proba: Whether to return the predicted probabilities of being in P, + defaults to False. + + Returns: + L-C2ST score at `x_o`: MSE between 0.5 and the predicted classifier + probability for class 0 on `theta_p`. + """ + # concatenate to get joint data + joint_p = np.concatenate( + [theta_p.cpu().numpy(), x_o.repeat(len(theta_p), 1).cpu().numpy()], axis=1 + ) + + # evaluate classifier + # probability of being in P (class 0) + proba = clf.predict_proba(joint_p)[:, 0] # type: ignore + # mean squared error between proba and dirac at 0.5 + score = ((proba - [0.5] * len(proba)) ** 2).mean() + + if return_proba: + return proba, score + else: + return score + + +def permute_data( + theta_p: Tensor, theta_q: Tensor, seed: int = 1 +) -> Tuple[Tensor, Tensor]: + """Permutes the concatenated data [P,Q] to create null samples. + + Args: + theta_p: samples from P, of shape (sample_size, dim). + theta_q: samples from Q, of shape (sample_size, dim). + seed: random seed, defaults to 1. + + Returns: + Permuted data [theta_p,theta_qss] + """ + # set seed + torch.manual_seed(seed) + # check inputs + assert theta_p.shape[0] == theta_q.shape[0] + + sample_size = theta_p.shape[0] + X = torch.cat([theta_p, theta_q], dim=0) + x_perm = X[torch.randperm(sample_size * 2)] + return x_perm[:sample_size], x_perm[sample_size:] + + +class EnsembleClassifier(BaseEstimator): + def __init__(self, clf, num_ensemble=1, verbosity=1): + self.clf = clf + self.num_ensemble = num_ensemble + self.trained_clfs = [] + self.verbosity = verbosity + + def fit(self, X, y): + for n in tqdm( + range(self.num_ensemble), + desc="Ensemble training", + disable=self.verbosity < 1, + ): + clf = clone(self.clf) + if clf.random_state is not None: # type: ignore + clf.random_state += n # type: ignore + else: + clf.random_state = n + 1 # type: ignore + clf.fit(X, y) # type: ignore + self.trained_clfs.append(clf) + + def predict_proba(self, X): + probas = [clf.predict_proba(X) for clf in self.trained_clfs] + return np.mean(probas, axis=0) diff --git a/sbi/simulators/gaussian_mixture.py b/sbi/simulators/gaussian_mixture.py new file mode 100644 index 000000000..809d425df --- /dev/null +++ b/sbi/simulators/gaussian_mixture.py @@ -0,0 +1,167 @@ +import logging + +import pyro +import torch +from pyro import distributions as pdist +from torch import Tensor + +SIM_PARAMS = { + "mixture_locs_factor": [1.0, 1.0], + "mixture_scales": [1.0, 0.1], + "mixture_weights": [0.5, 0.5], +} + +PRIOR_PARAMS = { + "bound": 10.0, +} + + +def uniform_prior_gaussian_mixture(dim: int, bound: float = 10.0) -> pdist.Uniform: + """ + Prior distribution for Gaussian Mixture, as implemented in [1]. + + Args: + dim: Dimensionality of parameters and data. + bound: Prior is uniform in [-bound, +bound], defaults to 10.0. + + Returns: Prior distribution. + """ + return pdist.Uniform( + low=-bound * torch.ones((dim,)), + high=+bound * torch.ones((dim,)), + ).to_event(1) + + +def gaussian_mixture( + theta: Tensor, + mixture_locs_factor: list = SIM_PARAMS["mixture_locs_factor"], + mixture_scales: list = SIM_PARAMS["mixture_scales"], + mixture_weights: list = SIM_PARAMS["mixture_weights"], +) -> Tensor: + """ + Simulator for Gaussian Mixture, as implemented in [1]. + + The mixture components are Gaussians with scaled theta as mean and fixed scale: + `num_components = dim_theta`, default is 2. + + The dimensionality of the data can be changed, but the mixture parameters + (locs, scales, weights) need to be adjusted accordingly. + + References: + [1]: https://github.com/sbi-benchmark/sbibm/blob/main/sbibm/tasks/gaussian_mixture/task.py + + Args: + theta: Parameter sets to be simulated, of shape (num_samples, dim_theta). + mixture_locs_factor: Factor for the mean of the Gaussian mixture components, + of length (dim_theta). + mixture_scales: Scales of the Gaussian mixture components, + of length (dim_theta). + mixture_weights: Weights of the Gaussian mixture components, + of length (dim_theta). + + Returns: Simulated data, of shape (num_samples, dim_theta). + """ + + # Check dimensions + assert ( + theta.shape[-1] + == len(mixture_locs_factor) + == len(mixture_scales) + == len(mixture_weights) + ), "Mismatch in dimensions." + + # Sample mixture index for each parameter in batch + idx = pyro.sample( + "mixture_idx", + pdist.Categorical(probs=torch.tensor(mixture_weights)).expand_by([ + theta.shape[0] + ]), + ).unsqueeze(1) + + # Select loc and scales according to mixture index + loc = torch.tensor(mixture_locs_factor)[idx] * theta + scale = torch.tensor(mixture_scales)[idx] + + return pyro.sample("data", pdist.Normal(loc=loc, scale=scale).to_event(1)) + + +def samples_true_posterior_gaussian_mixture_uniform_prior( + x_o: Tensor, + mixture_locs_factor: list = SIM_PARAMS["mixture_locs_factor"], + mixture_scales: list = SIM_PARAMS["mixture_scales"], + mixture_weights: list = SIM_PARAMS["mixture_weights"], + prior_bound: float = 10.0, + num_samples: int = 1, +) -> torch.Tensor: + """Samples the true posterior for a given observation x_o when + the likelihood is a Gaussian Mixture and the prior is uniform. + + The dimensionality of the data is 2 by default, but can be changed if + the mixture parameters (locs, scales, weights) are adjusted accordingly. + + Uses closed form solution with rejection sampling, as implemented in [1]. + + References: + [1]: https://github.com/sbi-benchmark/sbibm/blob/main/sbibm/tasks/gaussian_mixture/task.py + + Args: + x_o: The observation, of shape (,dim_x). + mixture_locs_factor: Factor for the mean of the Gaussian mixture components, + of length (dim_x). + mixture_scales: Scales of the Gaussian mixture components, + of length (dim_x). + mixture_weights: Weights of the Gaussian mixture components, + of length (dim_x). + prior_bound: Prior is uniform in [-prior_bound, +prior_bound], + defaults to 10.0, as in [1]. + num_samples: Desired number of samples, defaults to 1. + + Returns: + Samples from the true posterior, of shape (num_samples, dim_x). + """ + + log = logging.getLogger(__name__) + + dim = x_o.shape[-1] + + # Check dimensions + assert ( + dim == len(mixture_locs_factor) == len(mixture_scales) == len(mixture_weights) + ), "Mismatch in dimensions." + + # Define prior distribution + prior_dist = uniform_prior_gaussian_mixture(dim, prior_bound) + + posterior_samples = [] + + # Reject samples outside of prior bounds + counter = 0 + while len(posterior_samples) < num_samples: + counter += 1 + idx = pyro.sample( + "mixture_idx", + pdist.Categorical(torch.tensor(mixture_weights)), + ) + sample = pyro.sample( + "posterior_sample", + pdist.Normal( + loc=torch.tensor(mixture_locs_factor)[idx] * x_o, + scale=torch.tensor(mixture_scales)[idx], + ), + ) + is_outside_prior = torch.isinf(prior_dist.log_prob(sample).sum()) + + if len(posterior_samples) > 0: + is_duplicate = sample in torch.cat(posterior_samples) + else: + is_duplicate = False + + if not is_outside_prior and not is_duplicate: + posterior_samples.append(sample) + + posterior_samples = torch.cat(posterior_samples) + acceptance_rate = float(num_samples / counter) + + log.info(f"Acceptance rate: {acceptance_rate}") + + return posterior_samples diff --git a/sbi/utils/analysis_utils.py b/sbi/utils/analysis_utils.py index 3b907d673..aa4ab0797 100644 --- a/sbi/utils/analysis_utils.py +++ b/sbi/utils/analysis_utils.py @@ -1,8 +1,9 @@ # This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed # under the Apache License Version 2.0, see -from typing import Callable, Optional, Union +from typing import Callable, List, Optional, Union +import numpy as np import torch from joblib import Parallel, delayed from scipy.stats import gaussian_kde @@ -55,3 +56,51 @@ def get_max(s): peaks = Parallel(n_jobs=num_workers)(delayed(get_max)(s) for s in samples.T) return torch.tensor(peaks, dtype=torch.float32) + + +def get_probs_per_marginal(probs: np.ndarray, samples: np.ndarray) -> dict: + """Associates the given probabilities with each marginal dimension + of the samples. + Used for customized pairplots of the `samples` with `probs` + as weights for the colormap. + + Args: + probs: weights to associate with the samples, of shape (n_samples,). + samples: samples to extract the marginals, of shape (n_samples, dim). + + Returns: + dicts: dictionary with keys as the marginal dimensions and values as + dictionaries with items: + - "s" (resp. "s_1", "s_2"): 1D (resp. 2D) marginal samples. + - "probs": weights associated with the samples. + """ + dim = samples.shape[-1] + dicts = {} + for i in range(dim): + samples_i = samples[:, i].reshape(-1, 1) + dict_i = {"probs": probs} + dict_i["s"] = samples_i[:, 0] + dicts[f"{i}"] = dict_i + + for j in range(i + 1, dim): + samples_ij = samples[:, [i, j]] + dict_ij = {"probs": probs} + dict_ij["s_1"] = samples_ij[:, 0] + dict_ij["s_2"] = samples_ij[:, 1] + dicts[f"{i}_{j}"] = dict_ij + return dicts + + +def pp_vals(samples: np.ndarray, alphas: Union[List, np.ndarray]) -> np.ndarray: + """Computes the PP-values: empirical c.d.f. of a random variable. + Used for Probability - Probabiity (P-P) plots. + + Args: + samples: samples from the random variable, of shape (n_samples, dim). + alphas: alpha values to evaluate the c.d.f, of shape (n_alphas,). + + Returns: + pp_vals: empirical c.d.f. values for each alpha, of shape (n_alphas,). + """ + pp_vals = [(samples <= alpha).mean() for alpha in alphas] + return np.array(pp_vals) diff --git a/tests/lc2st_test.py b/tests/lc2st_test.py new file mode 100644 index 000000000..e676f1c25 --- /dev/null +++ b/tests/lc2st_test.py @@ -0,0 +1,266 @@ +# This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed +# under the Affero General Public License v3, see . + +from __future__ import annotations + +import pytest +import torch +from sklearn.neural_network import MLPClassifier + +from sbi.diagnostics.lc2st import LC2ST, LC2ST_NF +from sbi.inference import SNPE +from sbi.simulators.gaussian_mixture import ( + gaussian_mixture, + uniform_prior_gaussian_mixture, +) + + +@pytest.mark.parametrize("method", (LC2ST, LC2ST_NF)) +@pytest.mark.parametrize("classifier", ('mlp', 'random_forest', 'custom')) +@pytest.mark.parametrize("cv_folds", (1, 2)) +@pytest.mark.parametrize("num_ensemble", (1, 3)) +@pytest.mark.parametrize("z_score", (True, False)) +def test_running_lc2st(method, classifier, cv_folds, num_ensemble, z_score): + """Tests running inference, LC2ST-(NF) and then getting test quantities.""" + + num_train = 100 + num_cal = 100 + num_eval = 100 + num_trials_null = 2 + + # task + dim = 2 + prior = uniform_prior_gaussian_mixture(dim=dim) + simulator = gaussian_mixture + + # training data for the density estimator + theta_train = prior.sample((num_train,)) + x_train = simulator(theta_train) + + # Train the neural posterior estimators + inference = SNPE(prior, density_estimator='maf') + inference = inference.append_simulations(theta=theta_train, x=x_train) + npe = inference.train(training_batch_size=100, max_num_epochs=1) + + # calibration data for the test + thetas = prior.sample((num_cal,)) + xs = simulator(thetas) + posterior_samples = ( + npe.sample((1,), condition=xs).reshape(-1, thetas.shape[-1]).detach() + ) + assert posterior_samples.shape == thetas.shape + + if method == LC2ST: + theta_o = ( + npe.sample((num_eval,), condition=xs[0][None, :]) + .reshape(-1, thetas.shape[-1]) + .detach() + ) + assert theta_o.shape == thetas.shape + kwargs_test = {} + kwargs_eval = {"theta_o": theta_o} + else: + flow_inverse_transform = lambda theta, x: npe.net._transform(theta, context=x)[ + 0 + ] + flow_base_dist = torch.distributions.MultivariateNormal( + torch.zeros(2), torch.eye(2) + ) + kwargs_test = { + "flow_inverse_transform": flow_inverse_transform, + "flow_base_dist": flow_base_dist, + "num_eval": num_eval, + } + kwargs_eval = {} + if classifier == "custom": + kwargs_test["clf_class"] = MLPClassifier + kwargs_test["clf_kwargs"] = {"alpha": 0.0, "max_iter": 2500} + kwargs_test["classifier"] = classifier + + lc2st = method( + thetas, + xs, + posterior_samples, + num_folds=cv_folds, + num_trials_null=num_trials_null, + num_ensemble=num_ensemble, + z_score=z_score, + **kwargs_test, + ) + _ = lc2st.train_under_null_hypothesis() + _ = lc2st.train_on_observed_data() + + _ = lc2st.get_scores( + x_o=xs[0], trained_clfs=lc2st.trained_clfs, return_probs=True, **kwargs_eval + ) + _ = lc2st.get_scores( + x_o=xs[0], trained_clfs=lc2st.trained_clfs, return_probs=False, **kwargs_eval + ) + _ = lc2st.get_statistic_on_observed_data(x_o=xs[0], **kwargs_eval) + + _ = lc2st.get_statistics_under_null_hypothesis( + x_o=xs[0], return_probs=True, **kwargs_eval + ) + _ = lc2st.get_statistics_under_null_hypothesis( + x_o=xs[0], return_probs=False, **kwargs_eval + ) + _ = lc2st.p_value(x_o=xs[0], **kwargs_eval) + _ = lc2st.reject_test(x_o=xs[0], **kwargs_eval) + + +@pytest.mark.slow +@pytest.mark.parametrize("method", (LC2ST, LC2ST_NF)) +def test_lc2st_true_negativ_rate(method): + """Tests the true negative rate of the LC2ST-(NF) test: + for a "bad" estimator, the LC2ST-(NF) should reject the null hypothesis.""" + num_runs = 100 + confidence_level = 0.95 + + # bad estimator :small training and num_epochs + # (no convergence to the true posterior) + num_train = 1_000 + num_epochs = 5 + + num_cal = 1_000 + num_eval = 10_000 + + # task + dim = 2 + prior = uniform_prior_gaussian_mixture(dim=dim) + simulator = gaussian_mixture + + # training data for the density estimator + theta_train = prior.sample((num_train,)) + x_train = simulator(theta_train) + + # Train the neural posterior estimators + inference = SNPE(prior, density_estimator='maf') + inference = inference.append_simulations(theta=theta_train, x=x_train) + npe = inference.train(training_batch_size=100, max_num_epochs=num_epochs) + + thetas = prior.sample((num_cal,)) + xs = simulator(thetas) + posterior_samples = npe.sample((1,), xs).reshape(-1, thetas.shape[-1]).detach() + + if method == LC2ST: + kwargs_test = {} + else: + flow_inverse_transform = lambda theta, x: npe.net._transform(theta, context=x)[ + 0 + ] + flow_base_dist = torch.distributions.MultivariateNormal( + torch.zeros(2), torch.eye(2) + ) + kwargs_test = { + "flow_inverse_transform": flow_inverse_transform, + "flow_base_dist": flow_base_dist, + "num_eval": num_eval, + } + + lc2st = method(thetas, xs, posterior_samples, **kwargs_test) + + _ = lc2st.train_under_null_hypothesis() + _ = lc2st.train_on_observed_data() + + results = [] + for _ in range(num_runs): + x = simulator(prior.sample((1,))) + if method == LC2ST: + theta_o = ( + npe.sample((num_eval,), condition=x) + .reshape(-1, thetas.shape[-1]) + .detach() + ) + kwargs_eval = {"theta_o": theta_o} + else: + kwargs_eval = {} + results.append( + lc2st.reject_test(x_o=x, alpha=1 - confidence_level, **kwargs_eval) + ) + + proportion_rejected = torch.tensor(results).float().mean() + + assert ( + proportion_rejected > confidence_level + ), f"LC2ST p-values too big, test should be rejected \ + at least {confidence_level * 100}% of the time, but was rejected \ + only {proportion_rejected * 100}% of the time." + + +@pytest.mark.slow +@pytest.mark.parametrize("method", (LC2ST, LC2ST_NF)) +def test_lc2st_true_positiv_rate(method): + """Tests the true negative rate of the LC2ST-(NF) test: + for a "good" estimator, the LC2ST-(NF) should accept the null hypothesis.""" + num_runs = 100 + confidence_level = 0.95 + + # good estimator: big training and num_epochs = accept + # (convergence of the estimator) + num_train = 10_000 + num_epochs = 200 + + num_cal = 1_000 + num_eval = 10_000 + + # task + dim = 2 + prior = uniform_prior_gaussian_mixture(dim=dim) + simulator = gaussian_mixture + + # training data for the density estimator + theta_train = prior.sample((num_train,)) + x_train = simulator(theta_train) + + # Train the neural posterior estimators + inference = SNPE(prior, density_estimator='maf') + inference = inference.append_simulations(theta=theta_train, x=x_train) + npe = inference.train(training_batch_size=100, max_num_epochs=num_epochs) + + thetas = prior.sample((num_cal,)) + xs = simulator(thetas) + posterior_samples = npe.sample((1,), xs).reshape(-1, thetas.shape[-1]).detach() + + if method == LC2ST: + kwargs_test = {} + else: + flow_inverse_transform = lambda theta, x: npe.net._transform(theta, context=x)[ + 0 + ] + flow_base_dist = torch.distributions.MultivariateNormal( + torch.zeros(2), torch.eye(2) + ) + kwargs_test = { + "flow_inverse_transform": flow_inverse_transform, + "flow_base_dist": flow_base_dist, + "num_eval": num_eval, + } + + lc2st = method(thetas, xs, posterior_samples, **kwargs_test) + + _ = lc2st.train_under_null_hypothesis() + _ = lc2st.train_on_observed_data() + + results = [] + for _ in range(num_runs): + x = simulator(prior.sample((1,))) + if method == LC2ST: + theta_o = ( + npe.sample((num_eval,), condition=x) + .reshape(-1, thetas.shape[-1]) + .detach() + ) + kwargs_eval = {"theta_o": theta_o} + else: + kwargs_eval = {} + results.append( + lc2st.reject_test(x_o=x, alpha=1 - confidence_level, **kwargs_eval) + ) + + proportion_rejected = torch.tensor(results).float().mean() + + assert ( + proportion_rejected < 1 - confidence_level + ), f"LC2ST p-values too small, test should be accepted \ + at least {confidence_level * 100}% of the time, but was accepted \ + only {(1 - proportion_rejected) * 100}% of the time." diff --git a/tutorials/00_getting_started_flexible.ipynb b/tutorials/00_getting_started_flexible.ipynb index 0350eb1fb..a5f6a773a 100644 --- a/tutorials/00_getting_started_flexible.ipynb +++ b/tutorials/00_getting_started_flexible.ipynb @@ -34,8 +34,8 @@ "import torch\n", "\n", "from sbi.analysis import pairplot\n", - "from sbi.utils import BoxUniform\n", "from sbi.inference import SNPE, simulate_for_sbi\n", + "from sbi.utils import BoxUniform\n", "from sbi.utils.user_input_checks import (\n", " check_sbi_inputs,\n", " process_prior,\n", diff --git a/tutorials/17_importance_sampled_posteriors.ipynb b/tutorials/17_importance_sampled_posteriors.ipynb index f23f92d8d..7c17ebf5b 100644 --- a/tutorials/17_importance_sampled_posteriors.ipynb +++ b/tutorials/17_importance_sampled_posteriors.ipynb @@ -162,7 +162,7 @@ "class Simulator:\n", " def __init__(self):\n", " pass\n", - " \n", + "\n", " def log_likelihood(self, theta, x):\n", " return MultivariateNormal(theta, eye(2)).log_prob(x)\n", "\n", @@ -312,7 +312,7 @@ "source": [ "# get weighted samples\n", "theta_inferred_is = theta_inferred[torch.where(w > torch.rand(len(w)) * torch.max(w))]\n", - "# *Note*: we here perform rejection sampling, as the plotting function \n", + "# *Note*: we here perform rejection sampling, as the plotting function\n", "# used below does not support weighted samples. In general, with rejection\n", "# sampling the number of samples will be smaller than the effective sample\n", "# size unless we allow for duplicate samples.\n", @@ -323,8 +323,8 @@ "\n", "# plot\n", "fig, ax = marginal_plot(\n", - " [theta_inferred, theta_inferred_is, gt_samples], \n", - " limits=[[-5, 5], [-5, 5]], \n", + " [theta_inferred, theta_inferred_is, gt_samples],\n", + " limits=[[-5, 5], [-5, 5]],\n", " figsize=(5, 1.5),\n", " diag=\"kde\", # smooth histogram\n", ")\n", @@ -22243,8 +22243,8 @@ ], "source": [ "fig, ax = marginal_plot(\n", - " [theta_inferred_sir_2, theta_inferred_sir_32, gt_samples], \n", - " limits=[[-5, 5], [-5, 5]], \n", + " [theta_inferred_sir_2, theta_inferred_sir_32, gt_samples],\n", + " limits=[[-5, 5], [-5, 5]],\n", " figsize=(5, 1.5),\n", " diag=\"kde\", # smooth histogram\n", ")\n", @@ -22280,8 +22280,8 @@ ], "source": [ "fig, ax = marginal_plot(\n", - " [gt_samples, theta_inferred], \n", - " limits=[[-5, 5], [-5, 5]], \n", + " [gt_samples, theta_inferred],\n", + " limits=[[-5, 5], [-5, 5]],\n", " weights=[None, w],\n", " figsize=(5, 1.5),\n", " diag=\"kde\", # smooth histogram\n", @@ -22400,9 +22400,9 @@ "\n", "for i in range(len(observations)):\n", " fig, ax = marginal_plot(\n", - " [non_corrected_samples_for_all_observations[i], corrected_samples_for_all_observations[i], true_samples[i]], \n", - " limits=[[-5, 5], [-5, 5]], \n", - " points=theta_gt[i], \n", + " [non_corrected_samples_for_all_observations[i], corrected_samples_for_all_observations[i], true_samples[i]],\n", + " limits=[[-5, 5], [-5, 5]],\n", + " points=theta_gt[i],\n", " figsize=(5, 1.5),\n", " diag=\"kde\", # smooth histogram\n", " )\n", @@ -23967,9 +23967,9 @@ "\n", "for i in range(len(observations)):\n", " fig, ax = marginal_plot(\n", - " [non_corrected_samples_for_all_observations[i], corrected_samples_for_all_observations[i], true_samples[i]], \n", - " limits=[[-5, 5], [-5, 5]], \n", - " points=theta_gt[i], \n", + " [non_corrected_samples_for_all_observations[i], corrected_samples_for_all_observations[i], true_samples[i]],\n", + " limits=[[-5, 5], [-5, 5]],\n", + " points=theta_gt[i],\n", " figsize=(5, 1.5),\n", " diag=\"kde\", # smooth histogram\n", " )\n", diff --git a/tutorials/18_diagnostics_lc2st.ipynb b/tutorials/18_diagnostics_lc2st.ipynb new file mode 100644 index 000000000..bcf96caf2 --- /dev/null +++ b/tutorials/18_diagnostics_lc2st.ipynb @@ -0,0 +1,907 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Local Classifier Two-Sample Tests ($\\ell$-C2ST)\n", + "\n", + "\n", + " After a density estimator has been trained with simulated data to obtain a posterior, the estimator should be made subject to several diagnostic tests. This diagnostic should be performed before the posterior is used for inference given the actual observed data. \n", + " \n", + "*Posterior Predictive Checks* (see [previous tutorial](https://sbi-dev.github.io/sbi/tutorial/12_diagnostics_posterior_predictive_check/)) provide one way to \"critique\" a trained estimator via its predictive performance. \n", + " \n", + "Another approach is *Simulation-Based Calibration* (SBC, see [previous tutorial](https://sbi-dev.github.io/sbi/tutorial/13_diagnostics_simulation_based_calibration/)). SBC evaluates whether the estimated posterior is balanced, i.e., neither over-confident nor under-confident. These checks are performed ***in expectation (on average) over the observation space***, i.e. they are performed on a set of $(\\theta,x)$ pairs sampled from the joint distribution over simulator parameters $\\theta$ and corresponding observations $x$. As such, SBC is a ***global validation method*** that can be viewed as a necessary condition (but not sufficient) for a valid inference algorithm: If SBC checks fail, this tells you that your inference is invalid. If SBC checks pass, *this is no guarantee that the posterior estimation is working*.\n", + "\n", + "**Local Classifier Two-Sample Tests** ($\\ell$-C2ST) as developed by [Linhart et al, 2023](https://arxiv.org/abs/2306.03580) present a new ***local validation method*** that allows to evaluate the correctness of the posterior estimator ***at a fixed observation***, i.e. they work on a single $(\\theta,x)$ pair. They provide necessary *and sufficient* conditions for the validity of the SBI algorithm, as well as easy-to-interpret qualitative and quantitative diagnostics. \n", + " \n", + "If global checks (like SBC) fail, $\\ell$-C2ST allows to further investigate where (for which observation) and why (bias, overdispersion, etc.) the posterior estimator fails. If global validation checks pass, $\\ell$-C2ST allows to guarantee whether the inference is correct for a specific observation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## In a nutshell\n", + "\n", + "Suppose you have an \"amortized\" posterior estimator $q_\\phi(\\theta\\mid x)$, meaning that we can quickly get samples for any new observation $x$. The goal is to test the *local consistency* of our estimator at a fixed observation $x_\\mathrm{o}$, i.e. whether the following null hypothesis holds about $q_\\phi(\\theta\\mid x)$ and the true posterior $p(\\theta\\mid x)$:\n", + "\n", + "$$\\mathcal{H}_0(x_\\mathrm{o}) := q_\\phi(\\theta\\mid x_\\mathrm{o}) = p(\\theta \\mid x_\\mathrm{o}), \\quad \\forall \\theta \\in \\mathbb{R}^m$$\n", + "\n", + "To run $\\ell$-C2ST, \n", + "\n", + "1. we sample **new** parameters from the prior of the problem at hand: $\\Theta_i \\sim p(\\theta)$\n", + "2. we simulate corresponding \"observations\": $X_i = \\mathrm{Simulator}(\\Theta_i) \\sim p(x\\mid \\Theta_i)$\n", + "3. we sample the estimated posterior at each observation: $Q_i \\sim q_\\phi(\\theta \\mid X_i)$\n", + "\n", + "This creates a calibration dataset of samples from the \"estimated\" and true joint distributions on which we train a binary classifier $d(\\theta, x)$ to distinguish between the estimated joint $q(\\theta \\mid x)p(x)$ (class $C=0$) and the true joint distribution $p(\\theta)p(x\\mid\\theta)$ (class $C=1$):\n", + "\n", + "$$\\mathcal{D}_\\mathrm{cal} = \\left \\{\\underbrace{(Q_i, X_i)}_{(C=0)} \\cup \\underbrace{(\\Theta_i, X_i)}_{(C=1)} \\right \\}_{i=1}^{N_\\mathrm{cal}}$$\n", + "\n", + "> Note: $D_\\mathrm{cal}$ contains data from the joint distribution (over prior and simulator) that have to be **different from the data used to train the posterior estimator**. $N_\\mathrm{cal}$ is typically smaller than $N_\\mathrm{train}$, the number of training samples for the posterior estimator, but has to be sufficiently large to allow the convergence of the classifier. For a fixed simulation budget, a rule of thumb is to use $90\\%$ for the posterior estimation and $10\\%$ for the calibration.\n", + "\n", + "Once the classifier is trained, we evaluate it for a given observation $x^\\star$ and multiple samples $Q^\\star_i \\sim q_\\phi(\\theta \\mid x^\\star)$. This gives us a set of predicted probabilities $\\left\\{d(Q^\\star_i, x^\\star)\\right\\}_{i=1}^{N_\\mathrm{eval}}$ that are then used to compute the different diagnostics. This proceedure can be repeated for several different observations, without having to retrain the classifiers, which allows to perform an efficient and thorough analysis of the failure modes of the posterior estimator.\n", + "\n", + "> Note: The number of evaluation samples can be arbitrarily large (typically we use $N_\\mathrm{eval} = 10\\,000$), because we suppose our posterior estimator to be amortized. \n", + "\n", + "### Key ideas behind $\\ell$-C2ST\n", + "\n", + "$\\ell$-C2ST allows to evaluate the correctness your posterior estimator *without requiring access to samples from the true posterior*. It is built on the following two key ideas:\n", + "\n", + "1. **Train the classifier on the joint:** this allows to implicitly learn the distance between the true and estimated posterior for any observation (we could call this step \"amortized\" C2ST training). \n", + "\n", + "2. **Local evaluation on data from one class only:** we use a metric that, as opposed to the accuracy (used in C2ST) does not require samples from the true posterior, only the estimator. It consists in the Mean Squared Error (MSE) between the predicted probabilities for samples from the estimator evaluated at the given observation and one half.\n", + "\n", + "> Note: A predicted probability of one half corresponds to the chance level or total uncertainty of the classifier, that is unable to distinguish between the two data classes.\n", + "\n", + "The MSE metric is used as a test statistic for a hypothesis test that gives us theoretical guarantees on the correctness of the posterior estimator (at the considered observation), as well as easy-to-interpret diagnostics that allow to investigate its failure modes.\n", + "\n", + ">**Quick reminder on hypothesis tests.** Additionaly to the observed test statistic $T^\\star$, evaluating the test requires to\n", + ">1. compute the test statistics $T_h$ under the null hyposthesis (H0) of equal (true and estimated) distributions over multiple trials $h$.\n", + ">2. compute the p-value $p_v = \\frac{1}{H}\\sum_{h=1}^H \\mathbb{I}(T_h > T^\\star)$: *\"How many times is the observed test statistic \"better\" (i.e. below) the test statistic computed under H0?\"*\n", + ">3. choose a significance level $\\alpha$ (typically $0.05$) that defines the rejection threshold and evaluate the test:\n", + ">- **quantitatively:** a p-value below this level indicates the rejection of the null hypothesis, meaning the detection of significant differences between the true and the estimated posterior. \n", + ">- **qualitatively:** P-P plots: visually check whether the distribution of $T^\\star$ falls into the $1-\\alpha$ confidence region, computed by taking the corresponding quantiles of $(T_1,\\dots, T_H)$.\n", + "\n", + "### What can $\\ell$-C2ST diagnose?\n", + "\n", + "- **Quantitatively:** the MSE metric (or test statistic) gives us a distance measure between the estimated and true posterior that can be quickly evaluated for any new observation $x^\\star$. Comparing it to the values of the null-distribution gives us the p-values that are used to check how significant their differences are. If the check passes (no significant differences), this tells us that we can be confident about the correctness of the estimator, but only upto to a certain confidence level (typically $95\\%$). \n", + "\n", + "- **Qualitatively:** we can choose to look at the predicted probabilities used to compute the MSE metric. P-P plots allow to evaluate a general trend of over or under confidence, by comparing theire distribution to the confidence region (obtained for probabilities predicted under H0). We can go further and map these predicted probabilities to a pairplot of the samples they were evaluated on, shows us the regions of over and underconfidence of the estimator. This allows us to investigate the nature of the inconsistencies, such as positive/negative bias or under/over dispersion.\n", + "\n", + "> Note: High (resp. low) predicted probability indicates that the classifier is confident about the fact that the sample belongs to the estimated posterior (resp. to the true posterior). This means that the estimator associates too much (resp. not enough) mass to this sample. In other words it is \"over-confident\" (resp. \"under-confident\"). \n", + "\n", + "\n", + "\n", + "To summarize $\\ell$-C2ST can:\n", + "\n", + "- tell you whether your posterior estimator is valid for a given observation (with a guaranteed confidence)\n", + "- show you where (for which observation) and why (bais, overdispersion, etc.) it fails " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Illustration on a benchmark SBI example\n", + "\n", + "We consider the Gaussian Mixture SBI task from [Lueckmann et al, 2021](https://arxiv.org/abs/2101.04653). It consists of inferring the common mean of a mixture of two 2D Gaussian distributions, one with much broader covariance than the other:\n", + "- Prior: $p(\\theta) = \\mathcal{U}(-10,10)$\n", + "- Simulator: $p(x|\\theta) = 0.5 \\mathcal{N}(\\theta, \\mathbf{I}_2)+ 0.5 \\mathcal{N}(\\theta, 0.1 \\times \\mathbf{I}_2)$\n", + "- Dimensionality: $\\theta \\in \\mathbb{R}^2$, $x \\in \\mathbb{R}^2$" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SBI Task" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from sbi.simulators.gaussian_mixture import (\n", + " gaussian_mixture,\n", + " uniform_prior_gaussian_mixture,\n", + ")\n", + "\n", + "# SBI task: prior and simualtor\n", + "dim = 2\n", + "prior = uniform_prior_gaussian_mixture(dim=dim)\n", + "simulator = gaussian_mixture\n", + "\n", + "# Number of samples for training, calibration and evaluation\n", + "NUM_TRAIN = 10_000\n", + "NUM_CAL = int(0.1 * NUM_TRAIN) # 10% of the training data\n", + "NUM_EVAL = 10_000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Posterior Inference\n", + "\n", + "We use neural posterior estimation as our SBI-algorithm with a MAF as underlying density estimator. \n", + "\n", + "> Note: Here you could use any other SBI algorithm of your own choosing (e.g. NRE, NLE, etc.). IMPORTANT: make sure it is amortized (which corresponds to sequential methods with a signle round), so sampling the posterior can be performed quickly.\n", + "\n", + "We train the estimator on a small training set (`small_num_train=1000`) over a small number of epochs (`max_num_epochs=10`), which means that it doesn't converge. Therefore the diagnostics should detect major differences between the estimated and the true posterior, i.e. the null hypothesis is rejected.\n", + "\n", + "> Note: You can play with the number of training samples or epochs to see whether this influences the quality of the posterior estimator and how it is reflected in the diagnostics." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Training neural network. Epochs trained: 11" + ] + } + ], + "source": [ + "from sbi.inference import SNPE\n", + "\n", + "torch.manual_seed(42) # seed for reproducibility\n", + "\n", + "# Sample training data for the density estimator\n", + "small_num_train = 1000\n", + "theta_train = prior.sample((NUM_TRAIN,))[:small_num_train]\n", + "x_train = simulator(theta_train)[:small_num_train]\n", + "\n", + "# Train the neural posterior estimators\n", + "torch.manual_seed(42) # seed for reproducibility\n", + "inference = SNPE(prior, density_estimator='maf', device='cpu')\n", + "inference = inference.append_simulations(theta=theta_train, x=x_train)\n", + "npe = inference.train(training_batch_size=256, max_num_epochs=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluate the posterior estimator\n", + "\n", + "We choose to evaluate the posterior estimator at three different observations, simulated from parameters independently sampled from the prior: \n", + "$$\\theta^\\star_i \\sim p(\\theta) \\quad \\rightarrow \\quad x^\\star_i \\sim p(x\\mid \\theta_i), \\quad i=1,2,3~.$$" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from sbi.simulators.gaussian_mixture import (\n", + " samples_true_posterior_gaussian_mixture_uniform_prior,\n", + ")\n", + "\n", + "# get reference observations\n", + "torch.manual_seed(0) # seed for reproducibility\n", + "thetas_star = prior.sample((3,))\n", + "xs_star = simulator(thetas_star)\n", + "\n", + "# Sample from the true and estimated posterior\n", + "post_samples_star = {}\n", + "ref_samples_star = {}\n", + "for i,x in enumerate(xs_star):\n", + " post_samples_star[i] = npe.sample(\n", + " (NUM_EVAL,), condition=x[None,:]\n", + " ).reshape(-1, thetas_star.shape[-1]).detach()\n", + " ref_samples_star[i] = samples_true_posterior_gaussian_mixture_uniform_prior(\n", + " x_o=x[None,:],\n", + " num_samples=1000,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Set-up $\\ell$-C2ST\n", + "\n", + "To setup the hypothesis test, we train the classifiers on the calibration dataset in two settings:\n", + "- `train_under_null_hypothesis`: uses the permutation method to train the classifiers under the nulll hypothesis over several trials\n", + "- `train_on_observed_data`: train the the classifier once on the observed data.\n", + "\n", + "For any new observation `x_o`, this allows to quickly compute (without having to retrain the classifiers) the test statistics `T_null` under the null hypothesis and `T_data` on the observed data. They will be used to compute the diagnostics (p-value or P-P plots).\n", + "\n", + ">Note: we choose the default configuration with a MLP classifier (`classifier='mlp'`). You can also choose to use the default Random Forest classifier (`classifier='random_forest'`) or use your own custom `sklearn` classifier by specifying `clf_class` and `clf_kwargs` during the initialization of the `LC2ST` class. You can also use an ensemble classifier by setting `num_ensemble` > 1 for more stable classifier predictions (see the `EnsembleClassifier` class in `sbi/diagnostics/lc2st.py`)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training the classifiers under H0, permutation = True: 100%|██████████| 100/100 [00:24<00:00, 4.06it/s]\n" + ] + } + ], + "source": [ + "from sbi.diagnostics.lc2st import LC2ST\n", + "\n", + "torch.manual_seed(42) # seed for reproducibility\n", + "\n", + "# sample calibration data\n", + "theta_cal = prior.sample((NUM_CAL,))\n", + "x_cal = simulator(theta_cal)\n", + "post_samples_cal = npe.sample((1,), x_cal).reshape(-1, theta_cal.shape[-1]).detach()\n", + "\n", + "# set up the LC2ST: train the classifiers\n", + "lc2st = LC2ST(\n", + " thetas=theta_cal,\n", + " xs=x_cal,\n", + " posterior_samples=post_samples_cal,\n", + " classifier=\"mlp\",\n", + " num_ensemble=1, # number of classifiers for the ensemble\n", + ")\n", + "_ = lc2st.train_under_null_hypothesis() # over 100 trials under (H0)\n", + "_ = lc2st.train_on_observed_data() # on observed data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Define significance level for diagnostics\n", + "conf_alpha = 0.05" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Quantitative diagnostics\n", + "We here compute the test statistics and p-values for three different observations `x_o` (as mentioned above, this is done in an amortized way without having to retrain the classifiers). \n", + "\n", + "> Note: The p-value associated to the test corresponds to the proportion of times the L-C2ST statistic under the null hypothesis $\\{T_h\\}_{h=1}^H$ is greater than the L-C2ST statistic $T_\\mathrm{o}$ at the observation `x_o`. It is computed by taking the empirical mean over statistics computed on several trials under the null hypothesis: $$\\text{p-value}(x_\\mathrm{o}) = \\frac{1}{H} \\sum_{h=1}^{H} I(T_h < T_o)~.$$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1,len(thetas_star), figsize=(12,3))\n", + "for i in range(len(thetas_star)):\n", + " probs, scores = lc2st.get_scores(\n", + " theta_o=post_samples_star[i],\n", + " x_o=xs_star[i],\n", + " return_probs=True,\n", + " trained_clfs=lc2st.trained_clfs\n", + " )\n", + " T_data = lc2st.get_statistic_on_observed_data(\n", + " theta_o=post_samples_star[i],\n", + " x_o=xs_star[i]\n", + " )\n", + " T_null = lc2st.get_statistics_under_null_hypothesis(\n", + " theta_o=post_samples_star[i],\n", + " x_o=xs_star[i]\n", + " )\n", + " p_value = lc2st.p_value(post_samples_star[i], xs_star[i])\n", + " reject = lc2st.reject_test(post_samples_star[i], xs_star[i], alpha=conf_alpha)\n", + "\n", + " # plot 95% confidence interval\n", + " quantiles = np.quantile(T_null, [0, 1-conf_alpha])\n", + " axes[i].hist(T_null, bins=50, density=True, alpha=0.5, label=\"Null\")\n", + " axes[i].axvline(T_data, color=\"red\", label=\"Observed\")\n", + " axes[i].axvline(quantiles[0], color=\"black\", linestyle=\"--\", label=\"95% CI\")\n", + " axes[i].axvline(quantiles[1], color=\"black\", linestyle=\"--\")\n", + " axes[i].set_xlabel(\"Test statistic\")\n", + " axes[i].set_ylabel(\"Density\")\n", + " axes[i].set_xlim(-0.01,0.25)\n", + " axes[i].set_title(\n", + " f\"observation {i+1} \\n p-value = {p_value:.3f}, reject = {reject}\"\n", + " )\n", + "axes[-1].legend(bbox_to_anchor=(1.1, .5), loc='center left')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Results:** the plots show the test statistics under the null hypothesis `T_null` (in blue) defining the $95\\%$ (`1 - conf_alpha`) confidence region (black dotted lines). The test statistic correponding to the observed data `T_data` (red) is outside of the confidence region, indicating the **rejection of the null hypothesis** and therefore a **\"bad\" posterior estimator**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Qualitative diagnostics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### P-P plots\n", + "\n", + "P-P plots allow to evaluate a general trend of over- or under- confidence, by comparing the predicted probabilities of belonging to the estimated posterior (class 0). If the red curve is not fully contained in the gray confidence region, this means that the test rejects the null hypothesis and that a significant discrepancy from the true posterior is detected. Here two scenarios are possible:\n", + "- **over-confidence**: the red curve is mostly on the **right side** of the gray CR (high probabilities are predominant)\n", + "- **under-confidence**: the red curve is mostly on the **left side** of the gray CR (low probabilities are predominant)\n", + "\n", + "> Note: The predominance of high (resp. low) probabilities indicates a classifier that is mostly confident about predicting the class corresponding to the estimated (resp. true) posterior. This in turn means that the estimator associates too much (resp. not enough) mass to the evaluation space, i.e. is overall over confident (resp. under confident)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# P-P plots\n", + "from sbi.analysis.plot import pp_plot_lc2st\n", + "\n", + "fig, axes = plt.subplots(1,len(thetas_star), figsize=(12,3))\n", + "for i in range(len(thetas_star)):\n", + " probs_data, _ = lc2st.get_scores(\n", + " theta_o=post_samples_star[i],\n", + " x_o=xs_star[i],\n", + " return_probs=True,\n", + " trained_clfs=lc2st.trained_clfs\n", + " )\n", + " probs_null, _ = lc2st.get_statistics_under_null_hypothesis(\n", + " theta_o=post_samples_star[i],\n", + " x_o=xs_star[i],\n", + " return_probs=True\n", + " )\n", + "\n", + " pp_plot_lc2st(\n", + " probs=[probs_data],\n", + " probs_null=probs_null,\n", + " conf_alpha=conf_alpha,\n", + " labels=[\"Classifier probabilities \\n on observed data\"],\n", + " colors=[\"red\"],\n", + " ax=axes[i],\n", + " )\n", + " axes[i].set_title(f\"PP-plot for observation {i+1}\")\n", + "axes[-1].legend(bbox_to_anchor=(1.1, .5), loc='center left')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Results:** the plots below show a general trend of overconfident behavior (red curves on the right side of the black dots)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Pairplot with heatmap of classifier probabilities\n", + "\n", + "We can go further and map these predicted probabilities to a pairplot of the samples they were evaluated on, which shows us the regions of over and underconfidence of the estimator. This allows us to investigate the nature of the inconsistencies, such as positive/negative bias or under/over dispersion.\n", + "\n", + "> Note: High (resp. low) predicted probability indicates that the classifier is confident about the fact that the sample belongs to the estimated posterior (resp. to the true posterior). This means that the estimator associates too much (resp. not enough) mass to this sample. In other words it is \"over-confident\" (resp. \"under-confident\"). " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sbi.analysis.plot import marginal_plot_with_probs_intensity\n", + "from sbi.utils.analysis_utils import get_probs_per_marginal\n", + "\n", + "label = \"Probabilities (class 0)\"\n", + "# label = r\"$\\hat{p}(\\Theta\\sim q_{\\phi}(\\theta \\mid x_0) \\mid x_0)$\"\n", + "\n", + "fig, axes = plt.subplots(len(thetas_star), 3, figsize=(9,6), constrained_layout=True)\n", + "for i in range(len(thetas_star)):\n", + " probs_data, _ = lc2st.get_scores(\n", + " theta_o=post_samples_star[i][:1000],\n", + " x_o=xs_star[i],\n", + " return_probs=True,\n", + " trained_clfs=lc2st.trained_clfs\n", + " )\n", + " dict_probs_marginals = get_probs_per_marginal(\n", + " probs_data[0],\n", + " post_samples_star[i][:1000].numpy()\n", + " )\n", + " # 2d histogram\n", + " marginal_plot_with_probs_intensity(\n", + " dict_probs_marginals['0_1'],\n", + " marginal_dim=2,\n", + " ax=axes[i][0],\n", + " n_bins=50,\n", + " label=label\n", + " )\n", + " axes[i][0].scatter(\n", + " ref_samples_star[i][:,0],\n", + " ref_samples_star[i][:,1],\n", + " alpha=0.2,\n", + " color=\"gray\",\n", + " label=\"True posterior\"\n", + " )\n", + "\n", + " # marginal 1\n", + " marginal_plot_with_probs_intensity(\n", + " dict_probs_marginals['0'],\n", + " marginal_dim=1,\n", + " ax=axes[i][1],\n", + " n_bins=50,\n", + " label=label,\n", + " )\n", + " axes[i][1].hist(\n", + " ref_samples_star[i][:,0],\n", + " density=True,\n", + " bins=10,\n", + " alpha=0.5,\n", + " label=\"True Posterior\",\n", + " color=\"gray\"\n", + " )\n", + "\n", + " # marginal 2\n", + " marginal_plot_with_probs_intensity(\n", + " dict_probs_marginals['1'],\n", + " marginal_dim=1,\n", + " ax=axes[i][2],\n", + " n_bins=50,\n", + " label=label,\n", + " )\n", + " axes[i][2].hist(\n", + " ref_samples_star[i][:,1],\n", + " density=True,\n", + " bins=10,\n", + " alpha=0.5,\n", + " label=\"True posterior\",\n", + " color=\"gray\"\n", + " )\n", + "\n", + "axes[0][1].set_title(\"marginal 1\")\n", + "axes[0][2].set_title(\"marginal 2\")\n", + "\n", + "for j in range(3):\n", + " axes[j][0].set_ylabel(f\"observation {j + 1}\")\n", + "axes[0][2].legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Results**: the plots below indicate **over dispersion** of our estimator at all three considered observations. Indeed, the 2D histograms display a small blue-green region at the center where the estimator is \"underconfident\", surrounded by a yellow region of \"equal probability\", and the rest of the estimated posterior samlpes correspond to the red regions of \"overconfidence\". \n", + "\n", + "**Validation** of the diagnostic tool: we verify the statement of over dispersion by plotting the true posterior samples (in grey) and are happy to see that they fall into the underconfident region of the estimator. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Classifier choice and calibration data size: how to ensure meaningful test results\n", + "\n", + "### Choice of the classifier\n", + "If you are not sure about which classifier architecture is best for your data, you can do a quick check by looking at the variance of the results over different random state initializations of the classifier: For `i=1,2,...` \n", + "1. train the ith classifier: run `lc2st.train_on_observed_data(seed=i)` \n", + "2. compute the corresponding test statistic for a dataset `theta_o, x_o`: `T_i = lc2st.get_statistic_on_observed_data(theta_o, x_o)`\n", + "\n", + "For different classifier architectures, you should choose the one with the smallest variance. \n", + "\n", + "### Number of calibration samples\n", + "A similar check can also be performed via cross-validation: set the `num_folds` parameter of your `LC2ST` object, train on observed data and call `lc2st.get_scores(theta_o, x_o, lc2st.trained_clfs)`. This outputs the test statistics obtained for each cv-fold. You should choose the smallest calibration set size that gives you a small enough variance over the test statistics. \n", + "\n", + "> Note: Ideally, these checks should be performed in a **separable data setting**, i.e. for a dataset `theta_o, x_o` coming from a sub-optimal estimator: the classifier is supposed to be able to discriminate between the two classes; the test is supposed to be rejected; the variance is supposed to be small. In other words, we are ensuring a **high statistical power** (our true positive rate) of our test. If you want to be really rigurous, you should also check the type I error (or false positive rate), that should be controlled by the significance level of your test (cf. Figure 2 in [[Linhart et al., 2023]](https://arxiv.org/abs/2306.03580)).\n", + "\n", + "### Reducing the variance of the test results\n", + "To ensure more stable results, you can play with the following `LC2ST` parameters:\n", + "- `num_ensemble`: number of classifiers used for ensembling. An ensemble classifier is a set of classifiers initialized with different `random_state`s and whose predicted class probalility is the mean probability over all classifiers. It reduces the variance coming from the classifier itself.\n", + "- `num_folds`: number of folds used for cross-validation. It reduces the variance coming from the data.\n", + "\n", + "As these numbers increase the results become more stable (less variance) and the test becomes more disciminative (smaller confidence region).\n", + "Both can be combined (i.e. you can perform cross-validation on an ensemble classifier). \n", + "\n", + "> Note: Be careful, you don't want your test to be too discriminative!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The case of Normalizing Flows ($\\ell$-C2ST-NF)\n", + "\n", + "$\\ell$-C2ST can also be specialized for normalizing flows,leading to improved test performance. The idea is to train and evaluate the classifiers in the space of the base distribution of the normalizing flow, instead of the parameter space that can be highly structured. \n", + "Following Theorem 4 of [[Linhart et al., 2023]](https://arxiv.org/abs/2306.03580), the null hypothesis $\\mathcal{H}_0(x_\\mathrm{o}) := q_\\phi(\\theta\\mid x_\\mathrm{o}) = p(\\theta \\mid x_\\mathrm{o})$ of *local consistency* holds if, and only if, the inverse flow transformation applied to the target distribution recovers the base distribution. This gives us the following new null hypothesis for posterior estimators based on normalizing flows (cf. Eq. 17 in [[Linhart et al., 2023]](https://arxiv.org/abs/2306.03580)):\n", + "\n", + "$$\\mathcal{H}_0(x_\\mathrm{o}) := p(T_\\phi^{-1}(\\theta ; x_\\mathrm{o}) \\mid x_\\mathrm{o}) = \\mathcal{N}(0, \\mathbf{I}_m), \\quad \\forall \\theta \\in \\mathbb{R}^m~,$$\n", + "\n", + "which leads to a new binary classification framework to discriminate between the joint distributions $\\mathcal{N}(0, \\mathbf{I}_m)p(x)$ (class $C=0$) and $p(T_\\phi^{-1}(\\theta ; x_\\mathrm{o}), x_\\mathrm{o})$ (class $C=1$).\n", + "\n", + "This results in two main advantages leading to a statistically more performant and flexible test: \n", + "- **easier classification task:** it is easier to discriminate samples w.r.t. a simple Gaussian than a complex (e.g. multimodal) posterior. \n", + "- **an analytically known null distribution:** it consists of the base distribution of the flow, which is **independant of $x$ and the posterior estimator**. This also allows to pre-compute the null distribution and re-use it for any new posterior estimator you whish to evaluate. \n", + "\n", + ">Remember that the original $\\ell$-C2ST relies on a permutation method to approximate the null distribution.\n", + "\n", + "The new method is implemented within the `LC2ST_NF` class, built on the `LC2ST` class with following major changes:\n", + "- no evaluation samples `theta_o` have to be passed to the evaluation methods (e.g. `get_scores_on_observed_data`, `get_statistic_on_observed_data`, `p_value`, etc.)\n", + "- the precomputed `trained_clfs_null` can be passed at initialization\n", + "- no permutation method is used inside `train_under_null_hypothesis`\n", + "\n", + "\n", + "> Note: **Quick reminder on Normalizing Flows.** We consider a **conditional Normalizing Flow** $q_{\\phi}(\\theta \\mid x)$ with base distribution $p(z) = \\mathcal{N}(0,\\mathbf{1}_m)$ and bijective transormation $T_{\\phi}(.; x)$ defined on $\\mathbb{R}^2$ and for all $x \\in \\mathbb{R}^2$ for our example problem in 2D. Sampling from the normalizing flow consists of applying the forward transformation $T_\\phi$:\n", + ">$$\\theta = T_{\\phi}(z; x) \\sim q_{\\phi}(\\theta \\mid x), \\quad z\\sim p(z)~.$$\n", + ">**Characterization of the null hypothesis.** Comparing the estimated and true posterior distributions is equivalent to comparing the base distribution to the inversely transformed prior samples: \n", + ">$$ p(\\theta \\mid x) = q_{\\phi}(\\theta \\mid x) \\iff p(T_{\\phi}^{-1}(\\theta; x)\\mid x) = p(T_{\\phi}^{-1}(T_{\\phi}(z; x); x)) = p(z) = \\mathcal{N}(0,\\mathbf{1}_m)$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up $\\ell$-C2ST-NF\n", + "\n", + "The setup of the NF version is the same as for the original $\\ell$-C2ST, but the trained classifiers can be used to compute test results and diagnostics for any new observation **and new posterior estimator**." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training the classifiers under H0, permutation = False: 0%| | 0/100 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1,len(thetas_star), figsize=(12,3))\n", + "for i in range(len(thetas_star)):\n", + " probs, scores = lc2st_nf.get_scores(\n", + " x_o=xs_star[i],\n", + " return_probs=True,\n", + " trained_clfs=lc2st_nf.trained_clfs\n", + " )\n", + " T_data = lc2st_nf.get_statistic_on_observed_data(x_o=xs_star[i])\n", + " T_null = lc2st_nf.get_statistics_under_null_hypothesis(x_o=xs_star[i])\n", + " p_value = lc2st_nf.p_value(xs_star[i])\n", + " reject = lc2st_nf.reject_test(xs_star[i], alpha=conf_alpha)\n", + "\n", + " # plot 95% confidence interval\n", + " quantiles = np.quantile(T_null, [0, 1-conf_alpha])\n", + " axes[i].hist(T_null, bins=50, density=True, alpha=0.5, label=\"Null\")\n", + " axes[i].axvline(T_data, color=\"red\", label=\"Observed\")\n", + " axes[i].axvline(quantiles[0], color=\"black\", linestyle=\"--\", label=\"95% CI\")\n", + " axes[i].axvline(quantiles[1], color=\"black\", linestyle=\"--\")\n", + " axes[i].set_xlabel(\"Test statistic\")\n", + " axes[i].set_ylabel(\"Density\")\n", + " axes[i].set_xlim(-0.01,0.25)\n", + " axes[i].set_title(\n", + " f\"observation {i+1} \\n p-value = {p_value:.3f}, reject = {reject}\"\n", + " )\n", + "axes[-1].legend(bbox_to_anchor=(1.1, .5), loc='center left')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Results:** Again the test hypothesis is rejected for all three observations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Qualitative diagnostics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### P-P plots\n", + "\n", + "**Results:** As before, the plots below show a general trend of overconfident behavior (red curves on the right side of the black dots)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# P-P plots\n", + "from sbi.analysis.plot import pp_plot_lc2st\n", + "\n", + "fig, axes = plt.subplots(1,len(thetas_star), figsize=(12,3))\n", + "for i in range(len(thetas_star)):\n", + " probs_data, _ = lc2st_nf.get_scores(\n", + " x_o=xs_star[i],\n", + " return_probs=True,\n", + " trained_clfs=lc2st_nf.trained_clfs\n", + " )\n", + " probs_null, _ = lc2st_nf.get_statistics_under_null_hypothesis(\n", + " x_o=xs_star[i],\n", + " return_probs=True\n", + " )\n", + "\n", + " pp_plot_lc2st(\n", + " probs=[probs_data],\n", + " probs_null=probs_null,\n", + " conf_alpha=conf_alpha,\n", + " labels=[\"Classifier probabilities \\n on observed data\"],\n", + " colors=[\"red\"],\n", + " ax=axes[i],\n", + " )\n", + " axes[i].set_title(f\"PP-plot for observation {i+1}\")\n", + "axes[-1].legend(bbox_to_anchor=(1.1, .5), loc='center left')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Heatmap of classifier probabilities\n", + "\n", + "For the NF case and as displayed in the plots below, we can choose to plot the heatmap of predicted classifier probabilities in the base distribution space, instead of the parameter space, which can be easier to interpret if the posterior space is highly structured." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sbi.analysis.plot import marginal_plot_with_probs_intensity\n", + "from sbi.utils.analysis_utils import get_probs_per_marginal\n", + "\n", + "label = \"Probabilities (class 0)\"\n", + "# label = r\"$\\hat{p}(Z\\sim\\mathcal{N}(0,1)\\mid x_0)$\"\n", + "\n", + "fig, axes = plt.subplots(len(thetas_star), 3, figsize=(9,6), constrained_layout=True)\n", + "for i in range(len(thetas_star)):\n", + " inv_ref_samples = lc2st_nf.flow_inverse_transform(\n", + " ref_samples_star[i], xs_star[i]\n", + " ).detach()\n", + " probs_data, _ = lc2st_nf.get_scores(\n", + " x_o=xs_star[i],\n", + " return_probs=True,\n", + " trained_clfs=lc2st_nf.trained_clfs\n", + " )\n", + " marginal_probs = get_probs_per_marginal(\n", + " probs_data[0],\n", + " lc2st_nf.theta_o.numpy()\n", + " )\n", + " # 2d histogram\n", + " marginal_plot_with_probs_intensity(\n", + " marginal_probs['0_1'],\n", + " marginal_dim=2,\n", + " ax=axes[i][0],\n", + " n_bins=50,\n", + " label=label\n", + " )\n", + " axes[i][0].scatter(\n", + " inv_ref_samples[:,0],\n", + " inv_ref_samples[:,1],\n", + " alpha=0.2, color=\"gray\",\n", + " label=\"True posterior\"\n", + " )\n", + "\n", + " # marginal 1\n", + " marginal_plot_with_probs_intensity(\n", + " marginal_probs['0'],\n", + " marginal_dim=1,\n", + " ax=axes[i][1],\n", + " n_bins=50,\n", + " label=label\n", + " )\n", + " axes[i][1].hist(\n", + " inv_ref_samples[:,0],\n", + " density=True,\n", + " bins=10,\n", + " alpha=0.5,\n", + " label=\"True Posterior\",\n", + " color=\"gray\"\n", + " )\n", + "\n", + " # marginal 2\n", + " marginal_plot_with_probs_intensity(\n", + " marginal_probs['1'],\n", + " marginal_dim=1,\n", + " ax=axes[i][2],\n", + " n_bins=50,\n", + " label=label\n", + " )\n", + " axes[i][2].hist(\n", + " inv_ref_samples[:,1],\n", + " density=True,\n", + " bins=10,\n", + " alpha=0.5,\n", + " label=\"True posterior\",\n", + " color=\"gray\"\n", + " )\n", + "\n", + "axes[0][1].set_title(\"marginal 1\")\n", + "axes[0][2].set_title(\"marginal 2\")\n", + "\n", + "for j in range(3):\n", + " axes[j][0].set_ylabel(f\"observation {j + 1}\")\n", + "axes[0][2].legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Results:** Again, the plots below confirm that the true posterior samples (in grey) correspond to regions of \"underconfidence\" (blue-green) or \"equal probability\" (yellow), indicating over dispersion of our posterior esimator." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sbi_dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}