From c5ec3747b990eeea056e3f00f496eeaf1f1355c2 Mon Sep 17 00:00:00 2001 From: arrjon Date: Mon, 25 Nov 2024 18:45:45 +0100 Subject: [PATCH 01/20] ecdf with random points --- bayesflow/diagnostics/plot_sbc_ecdf.py | 30 ++++++++++++++++++++++++-- 1 file changed, 28 insertions(+), 2 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index da6c8b8db..07866c885 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -12,6 +12,7 @@ def plot_sbc_ecdf( variable_names: Sequence[str] = None, difference: bool = False, stacked: bool = False, + random_reference: bool = False, figsize: Sequence[float] = None, label_fontsize: int = 16, legend_fontsize: int = 14, @@ -32,11 +33,16 @@ def plot_sbc_ecdf( For models with many parameters, use `stacked=True` to obtain an idea of the overall calibration of a posterior approximator. + To compute ranks based on the Euclidean distance instead, you can use 'use_random_refs=True'. + This is motivated by [2]. + [1] Säilynoja, T., Bürkner, P. C., & Vehtari, A. (2022). Graphical test for discrete uniformity and its applications in goodness-of-fit evaluation and multiple sample comparison. Statistics and Computing, 32(2), 1-21. https://arxiv.org/abs/2103.10522 + [2] Tarp .... + Parameters ---------- post_samples : np.ndarray of shape (n_data_sets, n_post_draws, n_params) @@ -50,6 +56,9 @@ def plot_sbc_ecdf( If `True`, all ECDFs will be plotted on the same plot. If `False`, each ECDF will have its own subplot, similar to the behavior of `plot_sbc_histograms`. + random_reference : bool, optional, default: False + If `True`, random reference points are used to compute ranks based on the distance to these points + (wrt. the distance of the prior samples). This is motivated by [2]. variable_names : list or None, optional, default: None The parameter names for nice plot titles. Inferred if None. Only relevant if `stacked=False`. @@ -96,8 +105,25 @@ def plot_sbc_ecdf( plot_data["post_samples"] = plot_data.pop("post_variables") plot_data["prior_samples"] = plot_data.pop("prior_variables") - # Compute fractional ranks (using broadcasting) - ranks = np.mean(plot_data["post_samples"] < plot_data["prior_samples"][:, np.newaxis, :], axis=1) + if not random_reference: + # Compute fractional ranks (using broadcasting) + ranks = np.mean(plot_data["post_samples"] < plot_data["prior_samples"][:, np.newaxis, :], axis=1) + else: + if stacked: + random_samples = np.random.uniform(low=-1, high=1, size=(prior_samples.shape[0], prior_samples.shape[-1])) + references = np.array([prior_samples[:, 0]] * prior_samples.shape[-1]).T + random_samples + + samples_distances = np.sqrt(np.sum((references[:, np.newaxis, :] - post_samples) ** 2, axis=-1)) + theta_distances = np.sqrt(np.sum((references - prior_samples) ** 2, axis=-1)) + ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1)[:, np.newaxis] + else: + references = prior_samples + np.random.uniform( + low=-1, high=1, size=(prior_samples.shape[0], prior_samples.shape[-1]) + ) + + samples_distances = np.sqrt((references[:, np.newaxis, :] - post_samples) ** 2) + theta_distances = np.sqrt((references - prior_samples) ** 2) + ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1) # Plot individual ecdf of parameters for j in range(ranks.shape[-1]): From 8672abe009e5626378bd07eaeb490621352f840f Mon Sep 17 00:00:00 2001 From: arrjon Date: Mon, 25 Nov 2024 18:55:01 +0100 Subject: [PATCH 02/20] single axis --- bayesflow/diagnostics/plot_sbc_ecdf.py | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 07866c885..29fabd370 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -110,19 +110,25 @@ def plot_sbc_ecdf( ranks = np.mean(plot_data["post_samples"] < plot_data["prior_samples"][:, np.newaxis, :], axis=1) else: if stacked: - random_samples = np.random.uniform(low=-1, high=1, size=(prior_samples.shape[0], prior_samples.shape[-1])) - references = np.array([prior_samples[:, 0]] * prior_samples.shape[-1]).T + random_samples + random_samples = np.random.uniform( + low=-1, high=1, size=(plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[-1]) + ) + references = ( + np.array([plot_data["prior_samples"][:, 0]] * plot_data["prior_samples"].shape[-1]).T + random_samples + ) - samples_distances = np.sqrt(np.sum((references[:, np.newaxis, :] - post_samples) ** 2, axis=-1)) - theta_distances = np.sqrt(np.sum((references - prior_samples) ** 2, axis=-1)) + samples_distances = np.sqrt( + np.sum((references[:, np.newaxis, :] - plot_data["post_samples"]) ** 2, axis=-1) + ) + theta_distances = np.sqrt(np.sum((references - plot_data["prior_samples"]) ** 2, axis=-1)) ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1)[:, np.newaxis] else: - references = prior_samples + np.random.uniform( - low=-1, high=1, size=(prior_samples.shape[0], prior_samples.shape[-1]) + references = plot_data["prior_samples"] + np.random.uniform( + low=-1, high=1, size=(plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[-1]) ) - samples_distances = np.sqrt((references[:, np.newaxis, :] - post_samples) ** 2) - theta_distances = np.sqrt((references - prior_samples) ** 2) + samples_distances = np.sqrt((references[:, np.newaxis, :] - plot_data["post_samples"]) ** 2) + theta_distances = np.sqrt((references - plot_data["prior_samples"]) ** 2) ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1) # Plot individual ecdf of parameters @@ -137,6 +143,8 @@ def plot_sbc_ecdf( if stacked: if j == 0: + if not isinstance(plot_data["axes"], list): + plot_data["axes"] = [plot_data["axes"]] # in case of single axis plot_data["axes"][0].plot(xx, yy, color=rank_ecdf_color, alpha=0.95, label="Rank ECDFs") else: plot_data["axes"][0].plot(xx, yy, color=rank_ecdf_color, alpha=0.95) From bcb7b5a529c5f48bb67e98769f10fc0c770b3241 Mon Sep 17 00:00:00 2001 From: arrjon Date: Mon, 25 Nov 2024 18:57:54 +0100 Subject: [PATCH 03/20] single axis --- bayesflow/diagnostics/plot_sbc_ecdf.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 29fabd370..4c3c93c5f 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -143,8 +143,8 @@ def plot_sbc_ecdf( if stacked: if j == 0: - if not isinstance(plot_data["axes"], list): - plot_data["axes"] = [plot_data["axes"]] # in case of single axis + if not isinstance(plot_data["axes"], np.ndarray): + plot_data["axes"] = np.array([plot_data["axes"]]) # in case of single axis plot_data["axes"][0].plot(xx, yy, color=rank_ecdf_color, alpha=0.95, label="Rank ECDFs") else: plot_data["axes"][0].plot(xx, yy, color=rank_ecdf_color, alpha=0.95) From abcdf3cce508a8065e4d665b136ccf356497c217 Mon Sep 17 00:00:00 2001 From: arrjon Date: Mon, 25 Nov 2024 19:02:57 +0100 Subject: [PATCH 04/20] add comments --- bayesflow/diagnostics/plot_sbc_ecdf.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 4c3c93c5f..519f18826 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -41,7 +41,9 @@ def plot_sbc_ecdf( and multiple sample comparison. Statistics and Computing, 32(2), 1-21. https://arxiv.org/abs/2103.10522 - [2] Tarp .... + [2] Lemos, Pablo, et al. "Sampling-based accuracy testing of posterior estimators + for general inference." International Conference on Machine Learning. PMLR, 2023. + https://proceedings.mlr.press/v202/lemos23a.html Parameters ---------- @@ -110,6 +112,8 @@ def plot_sbc_ecdf( ranks = np.mean(plot_data["post_samples"] < plot_data["prior_samples"][:, np.newaxis, :], axis=1) else: if stacked: + # for all parameters, compute random reference points with + # minor dependence only on the first prior parameter random_samples = np.random.uniform( low=-1, high=1, size=(plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[-1]) ) @@ -123,6 +127,7 @@ def plot_sbc_ecdf( theta_distances = np.sqrt(np.sum((references - plot_data["prior_samples"]) ** 2, axis=-1)) ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1)[:, np.newaxis] else: + # for each parameter, compute random reference points with dependence on the prior parameter references = plot_data["prior_samples"] + np.random.uniform( low=-1, high=1, size=(plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[-1]) ) @@ -176,7 +181,7 @@ def plot_sbc_ecdf( plot_data["axes"], plot_data["num_row"], plot_data["num_col"], - xlabel="Fractional rank statistic", + xlabel="Fractional rank statistic" if not random_reference else "Distance rank statistic", ylabel=ylab, label_fontsize=label_fontsize, ) From ac2e2393013784b523d5b92f96ef0a65edd229a7 Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 12:43:38 +0100 Subject: [PATCH 05/20] clean --- bayesflow/diagnostics/plot_sbc_ecdf.py | 44 ++++++++++++++++---------- 1 file changed, 27 insertions(+), 17 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 519f18826..84e99717d 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -12,7 +12,7 @@ def plot_sbc_ecdf( variable_names: Sequence[str] = None, difference: bool = False, stacked: bool = False, - random_reference: bool = False, + rank_type: str = "fractional", figsize: Sequence[float] = None, label_fontsize: int = 16, legend_fontsize: int = 14, @@ -58,9 +58,11 @@ def plot_sbc_ecdf( If `True`, all ECDFs will be plotted on the same plot. If `False`, each ECDF will have its own subplot, similar to the behavior of `plot_sbc_histograms`. - random_reference : bool, optional, default: False - If `True`, random reference points are used to compute ranks based on the distance to these points - (wrt. the distance of the prior samples). This is motivated by [2]. + rank_type : str, optional, default: 'fractional' + If `fractional` (default), the ranks are computed as the fraction of posterior samples that are smaller than + the prior. If `distance`, the ranks are computed as the fraction of posterior samples that are closer to 0. + If `random_reference`, the ranks are computed as the fraction of posterior samples that are closer to a random + reference (which has a small dependence on the true parameter value) as in [2]. variable_names : list or None, optional, default: None The parameter names for nice plot titles. Inferred if None. Only relevant if `stacked=False`. @@ -100,6 +102,8 @@ def plot_sbc_ecdf( ShapeError If there is a deviation form the expected shapes of `post_samples` and `prior_samples`. + ValueError + If an unknown `rank_type` is passed. """ # Preprocessing @@ -107,34 +111,40 @@ def plot_sbc_ecdf( plot_data["post_samples"] = plot_data.pop("post_variables") plot_data["prior_samples"] = plot_data.pop("prior_variables") - if not random_reference: + if rank_type == "fractional": # Compute fractional ranks (using broadcasting) ranks = np.mean(plot_data["post_samples"] < plot_data["prior_samples"][:, np.newaxis, :], axis=1) - else: - if stacked: - # for all parameters, compute random reference points with - # minor dependence only on the first prior parameter - random_samples = np.random.uniform( + elif rank_type == "distance" or rank_type == "random_reference": + if rank_type == "distance": + # reference is the origin + references = np.zeros((plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[1])) + else: + random_ref = np.random.uniform( low=-1, high=1, size=(plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[-1]) ) + # we muss have a dependency on the true parameter otherwise potential biases will not be detected references = ( - np.array([plot_data["prior_samples"][:, 0]] * plot_data["prior_samples"].shape[-1]).T + random_samples + np.array( + [plot_data["prior_samples"][:, np.random.randint(plot_data["prior_samples"].shape[-1])]] + * plot_data["prior_samples"].shape[-1] + ).T + + random_ref ) + if stacked: + # compute ranks for all parameters jointly samples_distances = np.sqrt( np.sum((references[:, np.newaxis, :] - plot_data["post_samples"]) ** 2, axis=-1) ) theta_distances = np.sqrt(np.sum((references - plot_data["prior_samples"]) ** 2, axis=-1)) ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1)[:, np.newaxis] else: - # for each parameter, compute random reference points with dependence on the prior parameter - references = plot_data["prior_samples"] + np.random.uniform( - low=-1, high=1, size=(plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[-1]) - ) - + # compute marginal ranks for each parameter samples_distances = np.sqrt((references[:, np.newaxis, :] - plot_data["post_samples"]) ** 2) theta_distances = np.sqrt((references - plot_data["prior_samples"]) ** 2) ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1) + else: + raise ValueError(f"Unknown rank type: {rank_type}") # Plot individual ecdf of parameters for j in range(ranks.shape[-1]): @@ -181,7 +191,7 @@ def plot_sbc_ecdf( plot_data["axes"], plot_data["num_row"], plot_data["num_col"], - xlabel="Fractional rank statistic" if not random_reference else "Distance rank statistic", + xlabel=f"{rank_type.capitalize()} rank statistic", ylabel=ylab, label_fontsize=label_fontsize, ) From 55823e3f4e5cf4603a7115777744fe29cbb62677 Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 12:45:05 +0100 Subject: [PATCH 06/20] clean --- bayesflow/diagnostics/plot_sbc_ecdf.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 84e99717d..207cfb9b0 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -61,7 +61,7 @@ def plot_sbc_ecdf( rank_type : str, optional, default: 'fractional' If `fractional` (default), the ranks are computed as the fraction of posterior samples that are smaller than the prior. If `distance`, the ranks are computed as the fraction of posterior samples that are closer to 0. - If `random_reference`, the ranks are computed as the fraction of posterior samples that are closer to a random + If `random`, the ranks are computed as the fraction of posterior samples that are closer to a random reference (which has a small dependence on the true parameter value) as in [2]. variable_names : list or None, optional, default: None The parameter names for nice plot titles. @@ -114,7 +114,7 @@ def plot_sbc_ecdf( if rank_type == "fractional": # Compute fractional ranks (using broadcasting) ranks = np.mean(plot_data["post_samples"] < plot_data["prior_samples"][:, np.newaxis, :], axis=1) - elif rank_type == "distance" or rank_type == "random_reference": + elif rank_type == "distance" or rank_type == "random": if rank_type == "distance": # reference is the origin references = np.zeros((plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[1])) @@ -144,7 +144,7 @@ def plot_sbc_ecdf( theta_distances = np.sqrt((references - plot_data["prior_samples"]) ** 2) ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1) else: - raise ValueError(f"Unknown rank type: {rank_type}") + raise ValueError(f"Unknown rank type: {rank_type}. Use 'fractional', 'distance', or 'random'.") # Plot individual ecdf of parameters for j in range(ranks.shape[-1]): From 22e13a8d4f3d238e53a3634b9db53b42201bfa15 Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 12:49:28 +0100 Subject: [PATCH 07/20] title fix --- bayesflow/diagnostics/plot_sbc_ecdf.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 207cfb9b0..9379c0f9d 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -114,7 +114,7 @@ def plot_sbc_ecdf( if rank_type == "fractional": # Compute fractional ranks (using broadcasting) ranks = np.mean(plot_data["post_samples"] < plot_data["prior_samples"][:, np.newaxis, :], axis=1) - elif rank_type == "distance" or rank_type == "random": + elif rank_type in ["distance", "random"]: if rank_type == "distance": # reference is the origin references = np.zeros((plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[1])) @@ -178,7 +178,12 @@ def plot_sbc_ecdf( ylab = "ECDF" # Add simultaneous bounds - titles = plot_data["names"] if not stacked else ["Stacked ECDFs"] + if not stacked: + titles = plot_data["names"] + elif rank_type in ["distance", "random"]: + titles = ["Joint ECDFs"] + else: + titles = ["Stacked ECDFs"] for ax, title in zip(plot_data["axes"].flat, titles): ax.fill_between(z, L, H, color=fill_color, alpha=0.2, label=rf"{int((1-alpha) * 100)}$\%$ Confidence Bands") ax.legend(fontsize=legend_fontsize) From f1519c8ff2ecedd6f2a616f9efc8f691f95dc5cb Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 12:54:20 +0100 Subject: [PATCH 08/20] docstring --- bayesflow/diagnostics/plot_sbc_ecdf.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 9379c0f9d..49311563a 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -33,7 +33,9 @@ def plot_sbc_ecdf( For models with many parameters, use `stacked=True` to obtain an idea of the overall calibration of a posterior approximator. - To compute ranks based on the Euclidean distance instead, you can use 'use_random_refs=True'. + To compute ranks based on the Euclidean distance to the origin or a random reference, use `rank_type='distance'` or + `rank_type='random'`, respectively. Both can be used to check the joint calibration of the posterior approximator + and might show potential biases in the posterior approximation which are not detected by the fractional ranks. This is motivated by [2]. [1] Säilynoja, T., Bürkner, P. C., & Vehtari, A. (2022). Graphical test @@ -61,8 +63,8 @@ def plot_sbc_ecdf( rank_type : str, optional, default: 'fractional' If `fractional` (default), the ranks are computed as the fraction of posterior samples that are smaller than the prior. If `distance`, the ranks are computed as the fraction of posterior samples that are closer to 0. - If `random`, the ranks are computed as the fraction of posterior samples that are closer to a random - reference (which has a small dependence on the true parameter value) as in [2]. + If `random`, the ranks are computed as the fraction of posterior samples that are closer to a random reference + (which has a small dependence on the true parameter value) as in [2]. variable_names : list or None, optional, default: None The parameter names for nice plot titles. Inferred if None. Only relevant if `stacked=False`. From 83e6ed09561f7ea77d13f195ffba5fa5e7f57420 Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 13:09:39 +0100 Subject: [PATCH 09/20] posterior 2d --- bayesflow/diagnostics/plot_posterior_2d.py | 63 +++++++++++++--------- 1 file changed, 38 insertions(+), 25 deletions(-) diff --git a/bayesflow/diagnostics/plot_posterior_2d.py b/bayesflow/diagnostics/plot_posterior_2d.py index 272bf71e7..9c5908c94 100644 --- a/bayesflow/diagnostics/plot_posterior_2d.py +++ b/bayesflow/diagnostics/plot_posterior_2d.py @@ -8,10 +8,11 @@ def plot_posterior_2d( - post_samples: dict[str, np.ndarray] | np.ndarray, - prior_samples: dict[str, np.ndarray] | np.ndarray, + post_samples: np.ndarray, + prior_samples: np.ndarray, prior=None, - param_names: list = None, + variable_names: list = None, + true_params: np.ndarray = None, height: int = 3, label_fontsize: int = 14, legend_fontsize: int = 16, @@ -24,14 +25,14 @@ def plot_posterior_2d( ) -> sns.PairGrid: """Generates a bivariate pairplot given posterior draws and optional prior or prior draws. - posterior_draws : np.ndarray of shape (n_post_draws, n_params) + post_samples : np.ndarray of shape (n_post_draws, n_params) The posterior draws obtained for a SINGLE observed data set. - prior : bayesflow.forward_inference.Prior instance or None, optional, default: None - The optional prior object having an input-output signature as given by ayesflow.forward_inference.Prior - prior_draws : np.ndarray of shape (n_prior_draws, n_params) or None, optonal (default: None) - The optional prior draws obtained from the prior. If both prior and prior_draws are provided, prior_draws + prior_samples : np.ndarray of shape (n_prior_draws, n_params) or None, optional (default: None) + The optional prior samples obtained from the prior. If both prior and prior_samples are provided, prior_samples will be used. - param_names : list or None, optional, default: None + prior : bayesflow.forward_inference.Prior instance or None, optional, default: None + The optional prior object having an input-output signature as given by bayesflow.forward_inference.Prior + variable_names : list or None, optional, default: None The parameter names for nice plot titles. Inferred if None height : float, optional, default: 3 The height of the pairplot @@ -41,7 +42,7 @@ def plot_posterior_2d( The font size of the legend text tick_fontsize : int, optional, default: 12 The font size of the axis ticklabels - post_color : str, optional, default: '#8f2727' + post_color : str, optional, default: '#132a70' The color for the posterior histograms and KDEs priors_color : str, optional, default: gray The color for the optional prior histograms and KDEs @@ -64,7 +65,9 @@ def plot_posterior_2d( assert (len(post_samples.shape)) == 2, "Shape of `posterior_samples` for a single data set should be 2 dimensional!" # Plot posterior first - g = plot_samples_2d(post_samples, context="\\theta", param_names=param_names, render=False, height=height, **kwargs) + g = plot_samples_2d( + post_samples, context="\\theta", variable_names=variable_names, render=False, height=height, **kwargs + ) # Obtain n_draws and n_params n_draws, n_params = post_samples.shape @@ -73,34 +76,44 @@ def plot_posterior_2d( if prior is not None and prior_samples is None: draws = prior(n_draws) if isinstance(draws, dict): - prior_draws = draws["prior_draws"] + prior_samples = draws["prior_draws"] else: - prior_draws = draws + prior_samples = draws # Attempt to determine parameter names - if param_names is None: + if variable_names is None: if hasattr(prior, "param_names"): - if prior.param_names is not None: - param_names = prior.param_names + if prior.variable_names is not None: + variable_names = prior.variable_names else: - param_names = [f"$\\theta_{{{i}}}$" for i in range(1, n_params + 1)] + variable_names = [f"$\\theta_{{{i}}}$" for i in range(1, n_params + 1)] else: - param_names = [f"$\\theta_{{{i}}}$" for i in range(1, n_params + 1)] + variable_names = [f"$\\theta_{{{i}}}$" for i in range(1, n_params + 1)] # Add prior, if given - if prior_draws is not None: - prior_draws_df = pd.DataFrame(prior_draws, columns=param_names) - g.data = prior_draws_df + if prior_samples is not None: + prior_samples_df = pd.DataFrame(prior_samples, columns=variable_names) + g.data = prior_samples_df g.map_diag(sns.histplot, fill=True, color=prior_color, alpha=prior_alpha, kde=True, zorder=-1) g.map_lower(sns.kdeplot, fill=True, color=prior_color, alpha=prior_alpha, zorder=-1) + # Add true parameters + if true_params is not None: + # only plot on the diagonal + for i, ax in enumerate(np.diag(g.axes)): + ax.axvline(true_params[i], color="black", linestyle="--", label="True parameter") + # Add legend, if prior also given - if prior_draws is not None or prior is not None: + if prior_samples is not None or prior is not None: handles = [ Line2D(xdata=[], ydata=[], color=post_color, lw=3, alpha=post_alpha), Line2D(xdata=[], ydata=[], color=prior_color, lw=3, alpha=prior_alpha), ] - g.legend(handles, ["Posterior", "Prior"], fontsize=legend_fontsize, loc="center right") + handles_names = ["Posterior", "Prior"] + if true_params is not None: + handles.append(Line2D(xdata=[], ydata=[], color="black", lw=3, linestyle="--", label="True parameter")) + handles_names.append("True parameter") + g.legend(handles, handles_names, fontsize=legend_fontsize, loc="center right") n_row, n_col = g.axes.shape @@ -115,9 +128,9 @@ def plot_posterior_2d( g.axes[i, j].tick_params(axis="both", which="minor", labelsize=tick_fontsize) # Add nice labels - for i, param_name in enumerate(param_names): + for i, param_name in enumerate(variable_names): g.axes[i, 0].set_ylabel(param_name, fontsize=label_fontsize) - g.axes[len(param_names) - 1, i].set_xlabel(param_name, fontsize=label_fontsize) + g.axes[len(variable_names) - 1, i].set_xlabel(param_name, fontsize=label_fontsize) # Add grids for i in range(n_params): From d3f50e8e4ee3e28fa74881978c800169d51dc9e8 Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 13:43:56 +0100 Subject: [PATCH 10/20] posterior 2d fix --- bayesflow/diagnostics/plot_posterior_2d.py | 30 ++++++++++++++-------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/bayesflow/diagnostics/plot_posterior_2d.py b/bayesflow/diagnostics/plot_posterior_2d.py index 9c5908c94..737cc02ff 100644 --- a/bayesflow/diagnostics/plot_posterior_2d.py +++ b/bayesflow/diagnostics/plot_posterior_2d.py @@ -1,3 +1,5 @@ +import matplotlib.pyplot as plt + import numpy as np import pandas as pd import seaborn as sns @@ -9,7 +11,7 @@ def plot_posterior_2d( post_samples: np.ndarray, - prior_samples: np.ndarray, + prior_samples: np.ndarray = None, prior=None, variable_names: list = None, true_params: np.ndarray = None, @@ -65,8 +67,9 @@ def plot_posterior_2d( assert (len(post_samples.shape)) == 2, "Shape of `posterior_samples` for a single data set should be 2 dimensional!" # Plot posterior first + context = "" g = plot_samples_2d( - post_samples, context="\\theta", variable_names=variable_names, render=False, height=height, **kwargs + post_samples, context=context, variable_names=variable_names, render=False, height=height, **kwargs ) # Obtain n_draws and n_params @@ -86,9 +89,11 @@ def plot_posterior_2d( if prior.variable_names is not None: variable_names = prior.variable_names else: - variable_names = [f"$\\theta_{{{i}}}$" for i in range(1, n_params + 1)] + variable_names = [f"{context} $\\theta_{{{i}}}$" for i in range(1, n_params + 1)] else: - variable_names = [f"$\\theta_{{{i}}}$" for i in range(1, n_params + 1)] + variable_names = [f"{context} $\\theta_{{{i}}}$" for i in range(1, n_params + 1)] + else: + variable_names = [f"{context} {p}" for p in variable_names] # Add prior, if given if prior_samples is not None: @@ -99,9 +104,14 @@ def plot_posterior_2d( # Add true parameters if true_params is not None: - # only plot on the diagonal - for i, ax in enumerate(np.diag(g.axes)): - ax.axvline(true_params[i], color="black", linestyle="--", label="True parameter") + # Custom function to plot true_params on the diagonal + def plot_true_params(x, **kwargs): + param = x.iloc[0] # Get the single true value for the diagonal + plt.axvline(param, color="black", linestyle="--") # Add vertical line + + # only plot on the diagonal a vertical line for the true parameter + g.data = pd.DataFrame(true_params[np.newaxis], columns=variable_names) + g.map_diag(plot_true_params) # Add legend, if prior also given if prior_samples is not None or prior is not None: @@ -111,9 +121,9 @@ def plot_posterior_2d( ] handles_names = ["Posterior", "Prior"] if true_params is not None: - handles.append(Line2D(xdata=[], ydata=[], color="black", lw=3, linestyle="--", label="True parameter")) - handles_names.append("True parameter") - g.legend(handles, handles_names, fontsize=legend_fontsize, loc="center right") + handles.append(Line2D(xdata=[], ydata=[], color="black", lw=3, linestyle="--")) + handles_names.append("True Parameter") + plt.legend(handles=handles, labels=handles_names, fontsize=legend_fontsize, loc="center right") n_row, n_col = g.axes.shape From 3bb2250e16bafc0786efb3462e4c806814764139 Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 13:44:33 +0100 Subject: [PATCH 11/20] posterior 2d fix --- bayesflow/diagnostics/plot_posterior_2d.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/bayesflow/diagnostics/plot_posterior_2d.py b/bayesflow/diagnostics/plot_posterior_2d.py index 737cc02ff..323f3ded4 100644 --- a/bayesflow/diagnostics/plot_posterior_2d.py +++ b/bayesflow/diagnostics/plot_posterior_2d.py @@ -36,6 +36,8 @@ def plot_posterior_2d( The optional prior object having an input-output signature as given by bayesflow.forward_inference.Prior variable_names : list or None, optional, default: None The parameter names for nice plot titles. Inferred if None + true_params : np.ndarray of shape (n_params,) or None, optional, default: None + The true parameter values to be plotted on the diagonal. height : float, optional, default: 3 The height of the pairplot label_fontsize : int, optional, default: 14 From 6c71e899d84b1d5590e1f850143240ebcc9100fd Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 13:47:42 +0100 Subject: [PATCH 12/20] posterior 2d fix --- bayesflow/diagnostics/plot_posterior_2d.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/bayesflow/diagnostics/plot_posterior_2d.py b/bayesflow/diagnostics/plot_posterior_2d.py index 323f3ded4..872be60eb 100644 --- a/bayesflow/diagnostics/plot_posterior_2d.py +++ b/bayesflow/diagnostics/plot_posterior_2d.py @@ -84,6 +84,9 @@ def plot_posterior_2d( prior_samples = draws["prior_draws"] else: prior_samples = draws + elif prior_samples is not None: + # trim to the same number of draws as posterior + prior_samples = prior_samples[:n_draws] # Attempt to determine parameter names if variable_names is None: From 3c922a32e13e22f546018a23b481138f2ea12124 Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 17:45:41 +0100 Subject: [PATCH 13/20] fix reference --- bayesflow/diagnostics/plot_sbc_ecdf.py | 28 ++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 49311563a..5f1c6ca2c 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -118,21 +118,33 @@ def plot_sbc_ecdf( ranks = np.mean(plot_data["post_samples"] < plot_data["prior_samples"][:, np.newaxis, :], axis=1) elif rank_type in ["distance", "random"]: if rank_type == "distance": - # reference is the origin + # Reference is the origin references = np.zeros((plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[1])) else: random_ref = np.random.uniform( low=-1, high=1, size=(plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[-1]) ) - # we muss have a dependency on the true parameter otherwise potential biases will not be detected - references = ( - np.array( - [plot_data["prior_samples"][:, np.random.randint(plot_data["prior_samples"].shape[-1])]] - * plot_data["prior_samples"].shape[-1] - ).T - + random_ref + half_size = random_ref.shape[0] // 2 + # We muss have a dependency on the true parameter otherwise potential biases will not be detected + # the dependency of the first half of the references is on the one parameter, then on another + references_1 = ( + np.tile( + plot_data["prior_samples"][:, np.random.randint(plot_data["prior_samples"].shape[-1])], + (plot_data["prior_samples"].shape[-1], 1), + ).T[:half_size] + + random_ref[:half_size] ) + # Create references for the second half + references_2 = ( + np.tile( + plot_data["prior_samples"][:, np.random.randint(plot_data["prior_samples"].shape[-1])], + (plot_data["prior_samples"].shape[-1], 1), + ).T[half_size:] + + random_ref[half_size:] + ) + references = np.concatenate([references_1, references_2], axis=0) + if stacked: # compute ranks for all parameters jointly samples_distances = np.sqrt( From 29cedf018e4864b9101bdcb4e67b559e24fc667a Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 17:58:07 +0100 Subject: [PATCH 14/20] clean up --- bayesflow/diagnostics/plot_sbc_ecdf.py | 52 ++++--------------- bayesflow/utils/__init__.py | 2 +- bayesflow/utils/ecdf/__init__.py | 1 + bayesflow/utils/ecdf/ranks.py | 71 ++++++++++++++++++++++++++ 4 files changed, 82 insertions(+), 44 deletions(-) create mode 100644 bayesflow/utils/ecdf/ranks.py diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 5f1c6ca2c..0cb2beb83 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -4,6 +4,7 @@ from typing import Sequence from ..utils.plot_utils import preprocess, add_titles_and_labels, prettify_subplots from ..utils.ecdf import simultaneous_ecdf_bands +from ..utils.ecdf.ranks import fractional_ranks, distance_ranks, random_ranks def plot_sbc_ecdf( @@ -114,49 +115,14 @@ def plot_sbc_ecdf( plot_data["prior_samples"] = plot_data.pop("prior_variables") if rank_type == "fractional": - # Compute fractional ranks (using broadcasting) - ranks = np.mean(plot_data["post_samples"] < plot_data["prior_samples"][:, np.newaxis, :], axis=1) - elif rank_type in ["distance", "random"]: - if rank_type == "distance": - # Reference is the origin - references = np.zeros((plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[1])) - else: - random_ref = np.random.uniform( - low=-1, high=1, size=(plot_data["prior_samples"].shape[0], plot_data["prior_samples"].shape[-1]) - ) - half_size = random_ref.shape[0] // 2 - # We muss have a dependency on the true parameter otherwise potential biases will not be detected - # the dependency of the first half of the references is on the one parameter, then on another - references_1 = ( - np.tile( - plot_data["prior_samples"][:, np.random.randint(plot_data["prior_samples"].shape[-1])], - (plot_data["prior_samples"].shape[-1], 1), - ).T[:half_size] - + random_ref[:half_size] - ) - - # Create references for the second half - references_2 = ( - np.tile( - plot_data["prior_samples"][:, np.random.randint(plot_data["prior_samples"].shape[-1])], - (plot_data["prior_samples"].shape[-1], 1), - ).T[half_size:] - + random_ref[half_size:] - ) - references = np.concatenate([references_1, references_2], axis=0) - - if stacked: - # compute ranks for all parameters jointly - samples_distances = np.sqrt( - np.sum((references[:, np.newaxis, :] - plot_data["post_samples"]) ** 2, axis=-1) - ) - theta_distances = np.sqrt(np.sum((references - plot_data["prior_samples"]) ** 2, axis=-1)) - ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1)[:, np.newaxis] - else: - # compute marginal ranks for each parameter - samples_distances = np.sqrt((references[:, np.newaxis, :] - plot_data["post_samples"]) ** 2) - theta_distances = np.sqrt((references - plot_data["prior_samples"]) ** 2) - ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1) + # Compute fractional ranks + ranks = fractional_ranks(plot_data["post_samples"], plot_data["prior_samples"]) + elif rank_type == "distance": + # Compute ranks based on distance to the origin + ranks = distance_ranks(plot_data["post_samples"], plot_data["prior_samples"], stacked=stacked) + elif rank_type == "random": + # Compute ranks based on distance to a random reference (with dependency on the true parameter) + ranks = random_ranks(plot_data["post_samples"], plot_data["prior_samples"], stacked=stacked) else: raise ValueError(f"Unknown rank type: {rank_type}. Use 'fractional', 'distance', or 'random'.") diff --git a/bayesflow/utils/__init__.py b/bayesflow/utils/__init__.py index 669ad33de..173129927 100644 --- a/bayesflow/utils/__init__.py +++ b/bayesflow/utils/__init__.py @@ -11,7 +11,7 @@ split_tensors, ) from .dispatch import find_distribution, find_network, find_permutation, find_pooling, find_recurrent_net -from .ecdf import simultaneous_ecdf_bands +from .ecdf import simultaneous_ecdf_bands, ranks from .functional import batched_call from .git import ( issue_url, diff --git a/bayesflow/utils/ecdf/__init__.py b/bayesflow/utils/ecdf/__init__.py index 64ca50442..fdb20c21d 100644 --- a/bayesflow/utils/ecdf/__init__.py +++ b/bayesflow/utils/ecdf/__init__.py @@ -1 +1,2 @@ from .simultaneous_ecdf_bands import simultaneous_ecdf_bands +from .ranks import fractional_ranks, distance_ranks, random_ranks diff --git a/bayesflow/utils/ecdf/ranks.py b/bayesflow/utils/ecdf/ranks.py new file mode 100644 index 000000000..b9538ec92 --- /dev/null +++ b/bayesflow/utils/ecdf/ranks.py @@ -0,0 +1,71 @@ +import numpy as np + + +def fractional_ranks(post_samples: np.ndarray, prior_samples: np.ndarray) -> np.ndarray: + """Compute fractional ranks (using broadcasting)""" + return np.mean(post_samples < prior_samples[:, np.newaxis, :], axis=1) + + +def _helper_distance_ranks( + post_samples: np.ndarray, prior_samples: np.ndarray, references: np.ndarray, stacked: bool +) -> np.ndarray: + """ + Helper function to compute ranks of true parameter wrt posterior samples + based on distances between samples and a given references. + + """ + if stacked: + # compute ranks for all parameters jointly + samples_distances = np.sqrt(np.sum((references[:, np.newaxis, :] - post_samples) ** 2, axis=-1)) + theta_distances = np.sqrt(np.sum((references - prior_samples) ** 2, axis=-1)) + ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1)[:, np.newaxis] + else: + # compute marginal ranks for each parameter + samples_distances = np.sqrt((references[:, np.newaxis, :] - post_samples) ** 2) + theta_distances = np.sqrt((references - prior_samples) ** 2) + ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1) + return ranks + + +def distance_ranks(post_samples: np.ndarray, prior_samples: np.ndarray, stacked: bool) -> np.ndarray: + """ + Compute ranks of true parameter wrt posterior samples based on distances between samples and the origin. + """ + # Reference is the origin + references = np.zeros((prior_samples.shape[0], prior_samples.shape[1])) + ranks = _helper_distance_ranks( + post_samples=post_samples, prior_samples=prior_samples, references=references, stacked=stacked + ) + return ranks + + +def random_ranks(post_samples: np.ndarray, prior_samples: np.ndarray, stacked: bool) -> np.ndarray: + """ + Compute ranks of true parameter wrt posterior samples based on distances between samples and random references. + """ + # Create random references + random_ref = np.random.uniform(low=-1, high=1, size=(prior_samples.shape[0], prior_samples.shape[-1])) + half_size = random_ref.shape[0] // 2 + # We muss have a dependency on the true parameter otherwise potential biases will not be detected + # the dependency of the first half of the references is on the one parameter, then on another + references_1 = ( + np.tile( + prior_samples[:, np.random.randint(prior_samples.shape[-1])], + (prior_samples.shape[-1], 1), + ).T[:half_size] + + random_ref[:half_size] + ) + + # Create references for the second half + references_2 = ( + np.tile( + prior_samples[:, np.random.randint(prior_samples.shape[-1])], + (prior_samples.shape[-1], 1), + ).T[half_size:] + + random_ref[half_size:] + ) + references = np.concatenate((references_1, references_2), axis=0) + ranks = _helper_distance_ranks( + post_samples=post_samples, prior_samples=prior_samples, references=references, stacked=stacked + ) + return ranks From 47b6d184b39d28798bf61a560dfd7b2b82df22b0 Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 18:31:54 +0100 Subject: [PATCH 15/20] add comment --- bayesflow/diagnostics/plot_sbc_ecdf.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 0cb2beb83..2401ed8df 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -36,8 +36,9 @@ def plot_sbc_ecdf( To compute ranks based on the Euclidean distance to the origin or a random reference, use `rank_type='distance'` or `rank_type='random'`, respectively. Both can be used to check the joint calibration of the posterior approximator - and might show potential biases in the posterior approximation which are not detected by the fractional ranks. - This is motivated by [2]. + and might show potential biases in the posterior approximation which are not detected by the fractional ranks (e.g., + when the prior equals the posterior). However, for multi-modal posteriors, the random reference might indicate a + bias by focusing on the wrong mode. This is motivated by [2]. [1] Säilynoja, T., Bürkner, P. C., & Vehtari, A. (2022). Graphical test for discrete uniformity and its applications in goodness-of-fit evaluation From 74f510ae33eafc7d829c8cbb4da642a81755e1fd Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 18:40:50 +0100 Subject: [PATCH 16/20] add tests --- tests/utils/__init__.py | 1 + tests/utils/ecdf.py | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+) create mode 100644 tests/utils/ecdf.py diff --git a/tests/utils/__init__.py b/tests/utils/__init__.py index 7787f00bc..d507ae921 100644 --- a/tests/utils/__init__.py +++ b/tests/utils/__init__.py @@ -1,3 +1,4 @@ from .assertions import * from .callbacks import * from .ops import * +from .ecdf import * diff --git a/tests/utils/ecdf.py b/tests/utils/ecdf.py new file mode 100644 index 000000000..4720c67b5 --- /dev/null +++ b/tests/utils/ecdf.py @@ -0,0 +1,35 @@ +import numpy as np +import pytest +from bayesflow.utils.ecdf import fractional_ranks, distance_ranks, random_ranks + + +@pytest.fixture +def test_data(): + # Provide sample data for testing + np.random.seed(42) # Set seed for reproducibility + post_samples = np.array([[[0.1, 0.2], [0.3, 0.4]], [[0.5, 0.6], [0.7, 0.8]]]) + prior_samples = np.array([[0.2, 0.3], [0.6, 0.7]]) + references = np.array([[0.0, 0.0], [0.0, 0.0]]) + return post_samples, prior_samples, references + + +def test_fractional_ranks(test_data): + post_samples, prior_samples, _ = test_data + # Compute expected result manually + expected = np.mean(post_samples < prior_samples[:, np.newaxis, :], axis=1) + result = fractional_ranks(post_samples, prior_samples) + np.testing.assert_almost_equal(result, expected, decimal=6) + + +@pytest.mark.parametrize("stacked, expected_shape", [(True, (2, 1)), (False, (2, 2))]) +def test_distance_ranks(test_data, stacked, expected_shape): + post_samples, prior_samples, _ = test_data + result = distance_ranks(post_samples=post_samples, prior_samples=prior_samples, stacked=stacked) + assert result.shape == expected_shape + + +@pytest.mark.parametrize("stacked, expected_shape", [(True, (2, 1)), (False, (2, 2))]) +def test_random_ranks(test_data, stacked, expected_shape): + post_samples, prior_samples, _ = test_data + result = random_ranks(post_samples=post_samples, prior_samples=prior_samples, stacked=stacked) + assert result.shape == expected_shape From a5cee6d0a47edd039630ccff4d53e6f5a66d05b5 Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 22:34:46 +0100 Subject: [PATCH 17/20] pass kwargs --- bayesflow/diagnostics/plot_sbc_ecdf.py | 49 ++++++++++++++-------- bayesflow/utils/ecdf/__init__.py | 2 +- bayesflow/utils/ecdf/ranks.py | 58 ++++++++++---------------- tests/utils/ecdf.py | 8 ++-- 4 files changed, 60 insertions(+), 57 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 2401ed8df..10a86eeab 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -4,7 +4,7 @@ from typing import Sequence from ..utils.plot_utils import preprocess, add_titles_and_labels, prettify_subplots from ..utils.ecdf import simultaneous_ecdf_bands -from ..utils.ecdf.ranks import fractional_ranks, distance_ranks, random_ranks +from ..utils.ecdf.ranks import fractional_ranks, distance_ranks, reference_ranks def plot_sbc_ecdf( @@ -13,7 +13,7 @@ def plot_sbc_ecdf( variable_names: Sequence[str] = None, difference: bool = False, stacked: bool = False, - rank_type: str = "fractional", + rank_type: str | np.ndarray = "fractional", figsize: Sequence[float] = None, label_fontsize: int = 16, legend_fontsize: int = 14, @@ -35,10 +35,9 @@ def plot_sbc_ecdf( of the overall calibration of a posterior approximator. To compute ranks based on the Euclidean distance to the origin or a random reference, use `rank_type='distance'` or - `rank_type='random'`, respectively. Both can be used to check the joint calibration of the posterior approximator + pass a reference array, respectively. Both can be used to check the joint calibration of the posterior approximator and might show potential biases in the posterior approximation which are not detected by the fractional ranks (e.g., - when the prior equals the posterior). However, for multi-modal posteriors, the random reference might indicate a - bias by focusing on the wrong mode. This is motivated by [2]. + when the prior equals the posterior). This is motivated by [2]. [1] Säilynoja, T., Bürkner, P. C., & Vehtari, A. (2022). Graphical test for discrete uniformity and its applications in goodness-of-fit evaluation @@ -62,11 +61,12 @@ def plot_sbc_ecdf( If `True`, all ECDFs will be plotted on the same plot. If `False`, each ECDF will have its own subplot, similar to the behavior of `plot_sbc_histograms`. - rank_type : str, optional, default: 'fractional' + rank_type : str | np.ndarray, optional, default: 'fractional' If `fractional` (default), the ranks are computed as the fraction of posterior samples that are smaller than the prior. If `distance`, the ranks are computed as the fraction of posterior samples that are closer to 0. - If `random`, the ranks are computed as the fraction of posterior samples that are closer to a random reference - (which has a small dependence on the true parameter value) as in [2]. + If `rank_type` is an array, it should have the same shape as the `prior_samples` arrays, the distance to this + array will be used to compute the ranks (consider to make this reference dependent on the observation, + not the samples itself). This is motivated by [2]. variable_names : list or None, optional, default: None The parameter names for nice plot titles. Inferred if None. Only relevant if `stacked=False`. @@ -95,7 +95,9 @@ def plot_sbc_ecdf( **kwargs : dict, optional, default: {} Keyword arguments can be passed to control the behavior of ECDF simultaneous band computation through the ``ecdf_bands_kwargs`` - dictionary. See `simultaneous_ecdf_bands` for keyword arguments + dictionary. See `simultaneous_ecdf_bands` for keyword arguments. + Moreover, additional keyword arguments can be passed to control the behavior of + the rank computation through the ``ranks_kwargs`` dictionary. Returns ------- @@ -115,17 +117,28 @@ def plot_sbc_ecdf( plot_data["post_samples"] = plot_data.pop("post_variables") plot_data["prior_samples"] = plot_data.pop("prior_variables") - if rank_type == "fractional": - # Compute fractional ranks - ranks = fractional_ranks(plot_data["post_samples"], plot_data["prior_samples"]) - elif rank_type == "distance": - # Compute ranks based on distance to the origin - ranks = distance_ranks(plot_data["post_samples"], plot_data["prior_samples"], stacked=stacked) - elif rank_type == "random": + if isinstance(rank_type, str): + if rank_type == "fractional": + # Compute fractional ranks + ranks = fractional_ranks(plot_data["post_samples"], plot_data["prior_samples"]) + elif rank_type == "distance": + # Compute ranks based on distance to the origin + ranks = distance_ranks( + plot_data["post_samples"], plot_data["prior_samples"], stacked=stacked, **kwargs.pop("ranks_kwargs", {}) + ) + else: + raise ValueError(f"Unknown rank type: {rank_type}. Use 'fractional' or 'distance'.") + elif isinstance(rank_type, np.ndarray): # Compute ranks based on distance to a random reference (with dependency on the true parameter) - ranks = random_ranks(plot_data["post_samples"], plot_data["prior_samples"], stacked=stacked) + ranks = reference_ranks( + plot_data["post_samples"], + plot_data["prior_samples"], + references=rank_type, + stacked=stacked, + **kwargs.pop("ranks_kwargs", {}), + ) else: - raise ValueError(f"Unknown rank type: {rank_type}. Use 'fractional', 'distance', or 'random'.") + raise ValueError("Unknown rank type.") # Plot individual ecdf of parameters for j in range(ranks.shape[-1]): diff --git a/bayesflow/utils/ecdf/__init__.py b/bayesflow/utils/ecdf/__init__.py index fdb20c21d..22d68fa03 100644 --- a/bayesflow/utils/ecdf/__init__.py +++ b/bayesflow/utils/ecdf/__init__.py @@ -1,2 +1,2 @@ from .simultaneous_ecdf_bands import simultaneous_ecdf_bands -from .ranks import fractional_ranks, distance_ranks, random_ranks +from .ranks import fractional_ranks, distance_ranks, reference_ranks diff --git a/bayesflow/utils/ecdf/ranks.py b/bayesflow/utils/ecdf/ranks.py index b9538ec92..6f125a8f1 100644 --- a/bayesflow/utils/ecdf/ranks.py +++ b/bayesflow/utils/ecdf/ranks.py @@ -7,65 +7,53 @@ def fractional_ranks(post_samples: np.ndarray, prior_samples: np.ndarray) -> np. def _helper_distance_ranks( - post_samples: np.ndarray, prior_samples: np.ndarray, references: np.ndarray, stacked: bool + post_samples: np.ndarray, prior_samples: np.ndarray, references: np.ndarray, stacked: bool, p_norm: int ) -> np.ndarray: """ Helper function to compute ranks of true parameter wrt posterior samples - based on distances between samples and a given references. - + based on distances (defined on the p_norm) between samples and a given references. """ + # compute distances to references + dist_post = np.abs((references[:, np.newaxis, :] - post_samples)) + dist_prior = np.abs(references - prior_samples) + if stacked: # compute ranks for all parameters jointly - samples_distances = np.sqrt(np.sum((references[:, np.newaxis, :] - post_samples) ** 2, axis=-1)) - theta_distances = np.sqrt(np.sum((references - prior_samples) ** 2, axis=-1)) + samples_distances = np.sum(dist_post**p_norm, axis=-1) ** (1 / p_norm) + theta_distances = np.sum(dist_prior**p_norm, axis=-1) ** (1 / p_norm) + ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1)[:, np.newaxis] else: # compute marginal ranks for each parameter - samples_distances = np.sqrt((references[:, np.newaxis, :] - post_samples) ** 2) - theta_distances = np.sqrt((references - prior_samples) ** 2) - ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1) + ranks = np.mean((dist_post < dist_prior[:, np.newaxis]), axis=1) return ranks -def distance_ranks(post_samples: np.ndarray, prior_samples: np.ndarray, stacked: bool) -> np.ndarray: +def distance_ranks(post_samples: np.ndarray, prior_samples: np.ndarray, stacked: bool, p_norm: int = 2) -> np.ndarray: """ Compute ranks of true parameter wrt posterior samples based on distances between samples and the origin. """ # Reference is the origin references = np.zeros((prior_samples.shape[0], prior_samples.shape[1])) ranks = _helper_distance_ranks( - post_samples=post_samples, prior_samples=prior_samples, references=references, stacked=stacked + post_samples=post_samples, prior_samples=prior_samples, references=references, stacked=stacked, p_norm=p_norm ) return ranks -def random_ranks(post_samples: np.ndarray, prior_samples: np.ndarray, stacked: bool) -> np.ndarray: +def reference_ranks( + post_samples: np.ndarray, prior_samples: np.ndarray, references: np.ndarray, stacked: bool, p_norm: int = 2 +) -> np.ndarray: """ - Compute ranks of true parameter wrt posterior samples based on distances between samples and random references. + Compute ranks of true parameter wrt posterior samples based on distances between samples and references. """ - # Create random references - random_ref = np.random.uniform(low=-1, high=1, size=(prior_samples.shape[0], prior_samples.shape[-1])) - half_size = random_ref.shape[0] // 2 - # We muss have a dependency on the true parameter otherwise potential biases will not be detected - # the dependency of the first half of the references is on the one parameter, then on another - references_1 = ( - np.tile( - prior_samples[:, np.random.randint(prior_samples.shape[-1])], - (prior_samples.shape[-1], 1), - ).T[:half_size] - + random_ref[:half_size] - ) - - # Create references for the second half - references_2 = ( - np.tile( - prior_samples[:, np.random.randint(prior_samples.shape[-1])], - (prior_samples.shape[-1], 1), - ).T[half_size:] - + random_ref[half_size:] - ) - references = np.concatenate((references_1, references_2), axis=0) + # Validate reference + if references.shape[0] != prior_samples.shape[0]: + raise ValueError("The number of references must match the number of prior samples.") + if references.shape[1] != prior_samples.shape[1]: + raise ValueError("The dimension of references must match the dimension of the parameters.") + # Compute ranks ranks = _helper_distance_ranks( - post_samples=post_samples, prior_samples=prior_samples, references=references, stacked=stacked + post_samples=post_samples, prior_samples=prior_samples, references=references, stacked=stacked, p_norm=p_norm ) return ranks diff --git a/tests/utils/ecdf.py b/tests/utils/ecdf.py index 4720c67b5..e46aed27d 100644 --- a/tests/utils/ecdf.py +++ b/tests/utils/ecdf.py @@ -1,6 +1,6 @@ import numpy as np import pytest -from bayesflow.utils.ecdf import fractional_ranks, distance_ranks, random_ranks +from bayesflow.utils.ecdf import fractional_ranks, distance_ranks, reference_ranks @pytest.fixture @@ -30,6 +30,8 @@ def test_distance_ranks(test_data, stacked, expected_shape): @pytest.mark.parametrize("stacked, expected_shape", [(True, (2, 1)), (False, (2, 2))]) def test_random_ranks(test_data, stacked, expected_shape): - post_samples, prior_samples, _ = test_data - result = random_ranks(post_samples=post_samples, prior_samples=prior_samples, stacked=stacked) + post_samples, prior_samples, references = test_data + result = reference_ranks( + post_samples=post_samples, prior_samples=prior_samples, references=references, stacked=stacked + ) assert result.shape == expected_shape From 948378217ded42d6973b2321fcaedff1c4156a5c Mon Sep 17 00:00:00 2001 From: arrjon Date: Tue, 26 Nov 2024 23:22:23 +0100 Subject: [PATCH 18/20] fix title --- bayesflow/diagnostics/plot_sbc_ecdf.py | 1 + 1 file changed, 1 insertion(+) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 10a86eeab..64798c8ff 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -137,6 +137,7 @@ def plot_sbc_ecdf( stacked=stacked, **kwargs.pop("ranks_kwargs", {}), ) + rank_type = "reference" else: raise ValueError("Unknown rank type.") From 0b09c097df92f9be59fcf82301606521211ee352 Mon Sep 17 00:00:00 2001 From: arrjon Date: Wed, 27 Nov 2024 14:17:38 +0100 Subject: [PATCH 19/20] make more customizable --- bayesflow/diagnostics/plot_sbc_ecdf.py | 44 ++++------ bayesflow/utils/ecdf/__init__.py | 2 +- bayesflow/utils/ecdf/ranks.py | 107 +++++++++++++++++-------- tests/utils/ecdf.py | 22 +++-- 4 files changed, 107 insertions(+), 68 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 64798c8ff..5ab1e9ccc 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -4,7 +4,7 @@ from typing import Sequence from ..utils.plot_utils import preprocess, add_titles_and_labels, prettify_subplots from ..utils.ecdf import simultaneous_ecdf_bands -from ..utils.ecdf.ranks import fractional_ranks, distance_ranks, reference_ranks +from ..utils.ecdf.ranks import fractional_ranks, distance_ranks def plot_sbc_ecdf( @@ -34,8 +34,8 @@ def plot_sbc_ecdf( For models with many parameters, use `stacked=True` to obtain an idea of the overall calibration of a posterior approximator. - To compute ranks based on the Euclidean distance to the origin or a random reference, use `rank_type='distance'` or - pass a reference array, respectively. Both can be used to check the joint calibration of the posterior approximator + To compute ranks based on the Euclidean distance to the origin or a reference, use `rank_type='distance'` (and + pass a reference array, respectively). This can be used to check the joint calibration of the posterior approximator and might show potential biases in the posterior approximation which are not detected by the fractional ranks (e.g., when the prior equals the posterior). This is motivated by [2]. @@ -61,12 +61,11 @@ def plot_sbc_ecdf( If `True`, all ECDFs will be plotted on the same plot. If `False`, each ECDF will have its own subplot, similar to the behavior of `plot_sbc_histograms`. - rank_type : str | np.ndarray, optional, default: 'fractional' + rank_type : str, optional, default: 'fractional' If `fractional` (default), the ranks are computed as the fraction of posterior samples that are smaller than - the prior. If `distance`, the ranks are computed as the fraction of posterior samples that are closer to 0. - If `rank_type` is an array, it should have the same shape as the `prior_samples` arrays, the distance to this - array will be used to compute the ranks (consider to make this reference dependent on the observation, - not the samples itself). This is motivated by [2]. + the prior. If `distance`, the ranks are computed as the fraction of posterior samples that are closer to + a reference points (default here is the origin). You can pass a reference array in the same shape as the + `prior_samples` array by setting `references` in the ``ranks_kwargs``. This is motivated by [2]. variable_names : list or None, optional, default: None The parameter names for nice plot titles. Inferred if None. Only relevant if `stacked=False`. @@ -117,29 +116,16 @@ def plot_sbc_ecdf( plot_data["post_samples"] = plot_data.pop("post_variables") plot_data["prior_samples"] = plot_data.pop("prior_variables") - if isinstance(rank_type, str): - if rank_type == "fractional": - # Compute fractional ranks - ranks = fractional_ranks(plot_data["post_samples"], plot_data["prior_samples"]) - elif rank_type == "distance": - # Compute ranks based on distance to the origin - ranks = distance_ranks( - plot_data["post_samples"], plot_data["prior_samples"], stacked=stacked, **kwargs.pop("ranks_kwargs", {}) - ) - else: - raise ValueError(f"Unknown rank type: {rank_type}. Use 'fractional' or 'distance'.") - elif isinstance(rank_type, np.ndarray): - # Compute ranks based on distance to a random reference (with dependency on the true parameter) - ranks = reference_ranks( - plot_data["post_samples"], - plot_data["prior_samples"], - references=rank_type, - stacked=stacked, - **kwargs.pop("ranks_kwargs", {}), + if rank_type == "fractional": + # Compute fractional ranks + ranks = fractional_ranks(plot_data["post_samples"], plot_data["prior_samples"]) + elif rank_type == "distance": + # Compute ranks based on distance to the origin + ranks = distance_ranks( + plot_data["post_samples"], plot_data["prior_samples"], stacked=stacked, **kwargs.pop("ranks_kwargs", {}) ) - rank_type = "reference" else: - raise ValueError("Unknown rank type.") + raise ValueError(f"Unknown rank type: {rank_type}. Use 'fractional' or 'distance'.") # Plot individual ecdf of parameters for j in range(ranks.shape[-1]): diff --git a/bayesflow/utils/ecdf/__init__.py b/bayesflow/utils/ecdf/__init__.py index 22d68fa03..499e2d144 100644 --- a/bayesflow/utils/ecdf/__init__.py +++ b/bayesflow/utils/ecdf/__init__.py @@ -1,2 +1,2 @@ from .simultaneous_ecdf_bands import simultaneous_ecdf_bands -from .ranks import fractional_ranks, distance_ranks, reference_ranks +from .ranks import fractional_ranks, distance_ranks diff --git a/bayesflow/utils/ecdf/ranks.py b/bayesflow/utils/ecdf/ranks.py index 6f125a8f1..c402d9182 100644 --- a/bayesflow/utils/ecdf/ranks.py +++ b/bayesflow/utils/ecdf/ranks.py @@ -7,53 +7,96 @@ def fractional_ranks(post_samples: np.ndarray, prior_samples: np.ndarray) -> np. def _helper_distance_ranks( - post_samples: np.ndarray, prior_samples: np.ndarray, references: np.ndarray, stacked: bool, p_norm: int + post_samples: np.ndarray, + prior_samples: np.ndarray, + stacked: bool, + references: np.ndarray, + distance: callable, + p_norm: int, ) -> np.ndarray: """ Helper function to compute ranks of true parameter wrt posterior samples based on distances (defined on the p_norm) between samples and a given references. """ - # compute distances to references - dist_post = np.abs((references[:, np.newaxis, :] - post_samples)) - dist_prior = np.abs(references - prior_samples) + if distance is None: + # compute distances to references + dist_post = np.abs((references[:, np.newaxis, :] - post_samples)) + dist_prior = np.abs(references - prior_samples) - if stacked: - # compute ranks for all parameters jointly - samples_distances = np.sum(dist_post**p_norm, axis=-1) ** (1 / p_norm) - theta_distances = np.sum(dist_prior**p_norm, axis=-1) ** (1 / p_norm) + if stacked: + # compute ranks for all parameters jointly + samples_distances = np.sum(dist_post**p_norm, axis=-1) ** (1 / p_norm) + theta_distances = np.sum(dist_prior**p_norm, axis=-1) ** (1 / p_norm) - ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1)[:, np.newaxis] - else: - # compute marginal ranks for each parameter - ranks = np.mean((dist_post < dist_prior[:, np.newaxis]), axis=1) - return ranks + ranks = np.mean((samples_distances < theta_distances[:, np.newaxis]), axis=1)[:, np.newaxis] + else: + # compute marginal ranks for each parameter + ranks = np.mean((dist_post < dist_prior[:, np.newaxis]), axis=1) + else: + # compute distances using the given distance function + if stacked: + # compute distance over joint parameters + dist_post = np.array([distance(post_samples[i], references[i]) for i in range(references.shape[0])]) + dist_prior = np.array([distance(prior_samples[i], references[i]) for i in range(references.shape[0])]) + ranks = np.mean((dist_post < dist_prior[:, np.newaxis]), axis=1)[:, np.newaxis] + else: + # compute distances per parameter + dist_post = np.zeros_like(post_samples) + dist_prior = np.zeros_like(prior_samples) + for i in range(references.shape[0]): # Iterate over samples + for j in range(references.shape[1]): # Iterate over parameters + dist_post[i, :, j] = distance(post_samples[i, :, j], references[i, j]) + dist_prior[i, j] = distance(prior_samples[i, j], references[i, j]) -def distance_ranks(post_samples: np.ndarray, prior_samples: np.ndarray, stacked: bool, p_norm: int = 2) -> np.ndarray: - """ - Compute ranks of true parameter wrt posterior samples based on distances between samples and the origin. - """ - # Reference is the origin - references = np.zeros((prior_samples.shape[0], prior_samples.shape[1])) - ranks = _helper_distance_ranks( - post_samples=post_samples, prior_samples=prior_samples, references=references, stacked=stacked, p_norm=p_norm - ) + ranks = np.mean((dist_post < dist_prior[:, np.newaxis]), axis=1) return ranks -def reference_ranks( - post_samples: np.ndarray, prior_samples: np.ndarray, references: np.ndarray, stacked: bool, p_norm: int = 2 +def distance_ranks( + post_samples: np.ndarray, + prior_samples: np.ndarray, + stacked: bool, + references: np.ndarray = None, + distance: callable = None, + p_norm: int = 2, ) -> np.ndarray: """ - Compute ranks of true parameter wrt posterior samples based on distances between samples and references. + Compute ranks of true parameter wrt posterior samples based on distances between samples and optional references. + + Parameters + ---------- + post_samples : np.ndarray + The posterior samples. + prior_samples : np.ndarray + The prior samples. + references : np.ndarray, optional + The references to compute the ranks. + stacked : bool + If True, compute ranks for all parameters jointly. Otherwise, compute marginal ranks. + distance : callable, optional + The distance function to compute the ranks. If None, the distance defined by the p_norm is used. Must be + a function that takes two arrays (if stacked, it gets the full parameter vectors, if not only the single + parameters) and returns an array with the distances. This could be based on the log-posterior, for example. + p_norm : int, optional + The norm to compute the distance if no distance is passed. Default is L2-norm. """ - # Validate reference - if references.shape[0] != prior_samples.shape[0]: - raise ValueError("The number of references must match the number of prior samples.") - if references.shape[1] != prior_samples.shape[1]: - raise ValueError("The dimension of references must match the dimension of the parameters.") - # Compute ranks + # Reference is the origin + if references is None: + references = np.zeros((prior_samples.shape[0], prior_samples.shape[1])) + else: + # Validate reference + if references.shape[0] != prior_samples.shape[0]: + raise ValueError("The number of references must match the number of prior samples.") + if references.shape[1] != prior_samples.shape[1]: + raise ValueError("The dimension of references must match the dimension of the parameters.") + ranks = _helper_distance_ranks( - post_samples=post_samples, prior_samples=prior_samples, references=references, stacked=stacked, p_norm=p_norm + post_samples=post_samples, + prior_samples=prior_samples, + stacked=stacked, + references=references, + distance=distance, + p_norm=p_norm, ) return ranks diff --git a/tests/utils/ecdf.py b/tests/utils/ecdf.py index e46aed27d..f5e7faf6e 100644 --- a/tests/utils/ecdf.py +++ b/tests/utils/ecdf.py @@ -1,6 +1,6 @@ import numpy as np import pytest -from bayesflow.utils.ecdf import fractional_ranks, distance_ranks, reference_ranks +from bayesflow.utils.ecdf import fractional_ranks, distance_ranks @pytest.fixture @@ -23,15 +23,25 @@ def test_fractional_ranks(test_data): @pytest.mark.parametrize("stacked, expected_shape", [(True, (2, 1)), (False, (2, 2))]) def test_distance_ranks(test_data, stacked, expected_shape): - post_samples, prior_samples, _ = test_data - result = distance_ranks(post_samples=post_samples, prior_samples=prior_samples, stacked=stacked) + post_samples, prior_samples, references = test_data + result = distance_ranks( + post_samples=post_samples, prior_samples=prior_samples, stacked=stacked, references=references + ) assert result.shape == expected_shape @pytest.mark.parametrize("stacked, expected_shape", [(True, (2, 1)), (False, (2, 2))]) -def test_random_ranks(test_data, stacked, expected_shape): +def test_distance_ranks_function(test_data, stacked, expected_shape): post_samples, prior_samples, references = test_data - result = reference_ranks( - post_samples=post_samples, prior_samples=prior_samples, references=references, stacked=stacked + + def test_distance(x, y): + return np.linalg.norm(x - y) + + result = distance_ranks( + post_samples=post_samples, + prior_samples=prior_samples, + stacked=stacked, + references=references, + distance=test_distance, ) assert result.shape == expected_shape From 9f23593238f45093c693fe60d6ef579a6c81ec1f Mon Sep 17 00:00:00 2001 From: Jerry Date: Sun, 1 Dec 2024 23:41:32 -0500 Subject: [PATCH 20/20] fix conflict --- bayesflow/diagnostics/plot_sbc_ecdf.py | 8 ++++++-- examples/Linear_Regression.ipynb | 17 +++++++++-------- 2 files changed, 15 insertions(+), 10 deletions(-) diff --git a/bayesflow/diagnostics/plot_sbc_ecdf.py b/bayesflow/diagnostics/plot_sbc_ecdf.py index 5ab1e9ccc..8e5d4e172 100644 --- a/bayesflow/diagnostics/plot_sbc_ecdf.py +++ b/bayesflow/diagnostics/plot_sbc_ecdf.py @@ -10,6 +10,7 @@ def plot_sbc_ecdf( post_samples: dict[str, np.ndarray] | np.ndarray, prior_samples: dict[str, np.ndarray] | np.ndarray, + filter_keys: Sequence[str] = None, variable_names: Sequence[str] = None, difference: bool = False, stacked: bool = False, @@ -112,7 +113,9 @@ def plot_sbc_ecdf( """ # Preprocessing - plot_data = preprocess(post_samples, prior_samples, variable_names, num_col, num_row, figsize, stacked=stacked) + plot_data = preprocess( + post_samples, prior_samples, filter_keys, variable_names, num_col, num_row, figsize, stacked=stacked + ) plot_data["post_samples"] = plot_data.pop("post_variables") plot_data["prior_samples"] = plot_data.pop("prior_variables") @@ -160,11 +163,12 @@ def plot_sbc_ecdf( # Add simultaneous bounds if not stacked: - titles = plot_data["names"] + titles = plot_data["variable_names"] elif rank_type in ["distance", "random"]: titles = ["Joint ECDFs"] else: titles = ["Stacked ECDFs"] + for ax, title in zip(plot_data["axes"].flat, titles): ax.fill_between(z, L, H, color=fill_color, alpha=0.2, label=rf"{int((1-alpha) * 100)}$\%$ Confidence Bands") ax.legend(fontsize=legend_fontsize) diff --git a/examples/Linear_Regression.ipynb b/examples/Linear_Regression.ipynb index 03f61fc2c..604c4cae2 100644 --- a/examples/Linear_Regression.ipynb +++ b/examples/Linear_Regression.ipynb @@ -874,8 +874,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2024-12-01T23:42:03.608696Z", - "start_time": "2024-12-01T23:42:02.828676Z" + "end_time": "2024-12-02T04:35:56.281716Z", + "start_time": "2024-12-02T04:35:54.820210Z" } }, "source": [ @@ -905,7 +905,7 @@ "output_type": "display_data" } ], - "execution_count": 35 + "execution_count": 40 }, { "cell_type": "markdown", @@ -918,8 +918,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2024-12-01T23:42:08.336799Z", - "start_time": "2024-12-01T23:42:07.170780Z" + "end_time": "2024-12-02T04:40:20.576188Z", + "start_time": "2024-12-02T04:40:18.523569Z" } }, "source": [ @@ -928,7 +928,8 @@ " prior_samples=val_sims,\n", " filter_keys=filter_keys,\n", " variable_names=variable_names, \n", - " difference=True\n", + " difference=True,\n", + " rank_type=\"distance\"\n", ")" ], "outputs": [ @@ -937,13 +938,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 36 + "execution_count": 44 }, { "cell_type": "markdown",