From 996674f25fd5eea5cb0805140fdf1dfa80a8dfd4 Mon Sep 17 00:00:00 2001 From: Simon Dirmeier Date: Thu, 30 May 2024 15:39:00 +0200 Subject: [PATCH] Major refactor of codebase --- .DS_Store | Bin 0 -> 6148 bytes .pre-commit-config.yaml | 11 - Makefile | 6 +- README.md | 66 +- docs/appendix.ipynb | 1527 +++++++++++ docs/example.ipynb | 2316 +++++++++++++++++ docs/index.rst | 50 +- docs/introduction.ipynb | 41 + examples/bivariate_gaussian-sabc.py | 42 + examples/bivariate_gaussian-smcabc.py | 56 + examples/bivariate_gaussian_cfmpe.py | 85 - examples/bivariate_gaussian_sfmpe.py | 77 - examples/bivariate_gaussian_smcabc.py | 60 - examples/bivariate_gaussian_snl.py | 133 - examples/bivariate_gaussian_snp.py | 107 - examples/bivariate_gaussian_snr.py | 71 - examples/mixture_model-cmpe.py | 0 examples/mixture_model-nle.py | 41 + examples/mixture_model-npe.py | 0 examples/mixture_model-nre.py | 0 examples/slcp-fmpe.py | 0 examples/slcp-nass_nle.py | 107 + examples/slcp-nass_smcabc.py | 105 + examples/{slcp_ssnl.py => slcp-snle.py} | 2 +- examples/slcp_snass.py | 161 -- examples/two_moons-fmpe.py | 0 examples/two_moons-slice.py | 73 + pyproject.toml | 3 +- sbijax/__init__.py | 34 +- sbijax/_src/{_sne_base.py => _ne_base.py} | 46 +- sbijax/_src/_sbi_base.py | 31 +- sbijax/_src/abc/smc_abc.py | 91 +- sbijax/_src/{scmpe.py => cmpe.py} | 17 +- sbijax/_src/cmpe_test.py | 36 + sbijax/_src/conftest.py | 26 + sbijax/_src/{sfmpe.py => fmpe.py} | 33 +- sbijax/_src/fmpe_test.py | 37 + sbijax/_src/mcmc/__init__.py | 2 +- sbijax/_src/mcmc/diagnostics.py | 25 - sbijax/_src/mcmc/irmh.py | 2 +- sbijax/_src/mcmc/mala.py | 15 +- sbijax/_src/mcmc/nuts.py | 12 +- sbijax/_src/mcmc/slice.py | 2 +- sbijax/_src/mcmc/util.py | 8 + sbijax/_src/{snass.py => nass.py} | 136 +- sbijax/_src/nass_test.py | 48 + sbijax/_src/{snasss.py => nasss.py} | 8 +- sbijax/_src/nasss_test.py | 51 + sbijax/_src/{snl.py => nle.py} | 53 +- sbijax/_src/nle_test.py | 44 + ...ncy_model.py => make_consistency_model.py} | 6 +- ...lizing_flow.py => make_continuous_flow.py} | 50 +- sbijax/_src/nn/make_flow.py | 280 ++ sbijax/_src/nn/make_flows.py | 180 -- sbijax/_src/nn/make_mdn.py | 60 + sbijax/_src/nn/make_mlp.py | 37 + ...snass_networks.py => make_nass_network.py} | 12 +- sbijax/_src/nn/make_resnet.py | 7 +- sbijax/_src/nn/{snass_net.py => nass_net.py} | 6 +- .../_src/nn/{snasss_net.py => nasss_net.py} | 6 +- sbijax/_src/{snp.py => npe.py} | 26 +- sbijax/_src/npe_test.py | 32 + sbijax/_src/{snr.py => nre.py} | 40 +- sbijax/_src/nre_test.py | 32 + sbijax/_src/scmpe_test.py | 60 - sbijax/_src/sfmpe_test.py | 60 - sbijax/_src/snass_test.py | 62 - sbijax/_src/snasss_test.py | 66 - sbijax/_src/snl_test.py | 106 - sbijax/_src/snp_test.py | 89 - sbijax/_src/snr_test.py | 68 - sbijax/_src/util/data.py | 43 +- sbijax/_src/util/dataloader.py | 35 +- sbijax/_src/util/early_stopping.py | 2 +- sbijax/_src/util/plot.py | 54 + sbijax/_src/util/types.py | 3 + sbijax/nn/__init__.py | 37 +- sbijax/util/__init__.py | 3 + 78 files changed, 5579 insertions(+), 1780 deletions(-) create mode 100644 .DS_Store create mode 100644 docs/appendix.ipynb create mode 100644 docs/example.ipynb create mode 100644 docs/introduction.ipynb create mode 100644 examples/bivariate_gaussian-sabc.py create mode 100644 examples/bivariate_gaussian-smcabc.py delete mode 100644 examples/bivariate_gaussian_cfmpe.py delete mode 100644 examples/bivariate_gaussian_sfmpe.py delete mode 100644 examples/bivariate_gaussian_smcabc.py delete mode 100644 examples/bivariate_gaussian_snl.py delete mode 100644 examples/bivariate_gaussian_snp.py delete mode 100644 examples/bivariate_gaussian_snr.py create mode 100644 examples/mixture_model-cmpe.py create mode 100644 examples/mixture_model-nle.py create mode 100644 examples/mixture_model-npe.py create mode 100644 examples/mixture_model-nre.py create mode 100644 examples/slcp-fmpe.py create mode 100644 examples/slcp-nass_nle.py create mode 100644 examples/slcp-nass_smcabc.py rename examples/{slcp_ssnl.py => slcp-snle.py} (99%) delete mode 100644 examples/slcp_snass.py create mode 100644 examples/two_moons-fmpe.py create mode 100644 examples/two_moons-slice.py rename sbijax/_src/{_sne_base.py => _ne_base.py} (83%) rename sbijax/_src/{scmpe.py => cmpe.py} (95%) create mode 100644 sbijax/_src/cmpe_test.py create mode 100644 sbijax/_src/conftest.py rename sbijax/_src/{sfmpe.py => fmpe.py} (90%) create mode 100644 sbijax/_src/fmpe_test.py delete mode 100644 sbijax/_src/mcmc/diagnostics.py create mode 100644 sbijax/_src/mcmc/util.py rename sbijax/_src/{snass.py => nass.py} (62%) create mode 100644 sbijax/_src/nass_test.py rename sbijax/_src/{snasss.py => nasss.py} (96%) create mode 100644 sbijax/_src/nasss_test.py rename sbijax/_src/{snl.py => nle.py} (88%) create mode 100644 sbijax/_src/nle_test.py rename sbijax/_src/nn/{consistency_model.py => make_consistency_model.py} (97%) rename sbijax/_src/nn/{continuous_normalizing_flow.py => make_continuous_flow.py} (80%) create mode 100644 sbijax/_src/nn/make_flow.py delete mode 100644 sbijax/_src/nn/make_flows.py create mode 100644 sbijax/_src/nn/make_mdn.py create mode 100644 sbijax/_src/nn/make_mlp.py rename sbijax/_src/nn/{make_snass_networks.py => make_nass_network.py} (92%) rename sbijax/_src/nn/{snass_net.py => nass_net.py} (96%) rename sbijax/_src/nn/{snasss_net.py => nasss_net.py} (95%) rename sbijax/_src/{snp.py => npe.py} (93%) create mode 100644 sbijax/_src/npe_test.py rename sbijax/_src/{snr.py => nre.py} (92%) create mode 100644 sbijax/_src/nre_test.py delete mode 100644 sbijax/_src/scmpe_test.py delete mode 100644 sbijax/_src/sfmpe_test.py delete mode 100644 sbijax/_src/snass_test.py delete mode 100644 sbijax/_src/snasss_test.py delete mode 100644 sbijax/_src/snl_test.py delete mode 100644 sbijax/_src/snp_test.py delete mode 100644 sbijax/_src/snr_test.py create mode 100644 sbijax/_src/util/plot.py create mode 100644 sbijax/_src/util/types.py create mode 100644 sbijax/util/__init__.py diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..b0a08ae8bab9d2feb7b964bf43e51a338ca8ade3 GIT binary patch literal 6148 zcmeHK-AcnS6i&A3GKR1V1#g6aw;OK$i#KJ?7qFriDzjxpi(NC;&Ix1CH_#XIHGCe= zNm6l4!7CAW4xD_+`Dw_Pl9MpTcze`qF;-)Y2~fmB1)47e{it(NuogtFzcFAD3s~Zh zlfhgx8U7*zxOW2f?1_1-&pz#+A1NPvul^tkleF1<v8M)e{w`UKj^Moe=f{2)Vut$0)4-<;Ov1V%@7+1hRGO{W#Hwz+kD)_sWjv3fR)a`^eQtXRz91v+z!dvu3! zq~bg9<#~BLAu&J<5CaRsfIa?1bwSok%OnPffuA#g=Ys@AbS!2D_0a(hULVn4LPUW+ zz9kT)MaN=h5Ii8j zKn%<>P&C6D*8kJ*-~Y2oG$ICwfq%sSFLm5b8)hh7)=JP@P!x>I41T0QN0(xV f#ZtTuss-#4JAjVG%ph1m=pvwLpoSRuRR-Pxz7I|- literal 0 HcmV?d00001 diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 6f98705..8ed490f 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -13,17 +13,6 @@ repos: - id: requirements-txt-fixer - id: trailing-whitespace -- repo: https://github.com/pycqa/bandit - rev: 1.7.1 - hooks: - - id: bandit - language: python - language_version: python3 - types: [python] - args: ["-c", "pyproject.toml"] - additional_dependencies: ["toml"] - files: "(sbijax|examples)" - - repo: https://github.com/pre-commit/mirrors-mypy rev: v0.910-1 hooks: diff --git a/Makefile b/Makefile index 841556a..099f5b2 100644 --- a/Makefile +++ b/Makefile @@ -6,8 +6,8 @@ PKG_VERSION=`hatch version` tag: - git tag -a v${PKG_VERSION} -m v${PKG_VERSION} - git push --tag + git tag -a v${PKG_VERSION} -m v${PKG_VERSION} + git push --tag tests: hatch run test:test @@ -16,4 +16,4 @@ lints: hatch run test:lint docs: - cd docs && make html + cd docs && make html diff --git a/README.md b/README.md index 0926110..dc121aa 100644 --- a/README.md +++ b/README.md @@ -8,9 +8,7 @@ ## About -`sbijax` implements several algorithms for simulation-based inference in -[JAX](https://github.com/google/jax) using [Haiku](https://github.com/deepmind/dm-haiku), -[Distrax](https://github.com/deepmind/distrax) and [BlackJAX](https://github.com/blackjax-devs/blackjax). Specifically, `sbijax` implements +`sbijax` implements several algorithms for simulation-based inference in [JAX](https://github.com/google/jax), such as - [Sequential Monte Carlo ABC](https://www.routledge.com/Handbook-of-Approximate-Bayesian-Computation/Sisson-Fan-Beaumont/p/book/9780367733728) (`SMCABC`) - [Neural Likelihood Estimation](https://arxiv.org/abs/1805.07226) (`SNL`) @@ -22,14 +20,44 @@ - [Flow matching posterior estimation](https://arxiv.org/abs/2305.17161) (`SFMPE`) - [Consistency model posterior estimation](https://arxiv.org/abs/2312.05440) (`SCMPE`) -where the acronyms in parentheses denote the names of the methods in `sbijax`. +where the acronyms in parentheses denote the names of the classes in `sbijax`. It builds on the Python packages [Surjectors](https://github.com/dirmeier/surjectors), [Haiku](https://github.com/deepmind/dm-haiku), +[Distrax](https://github.com/deepmind/distrax) and [BlackJAX](https://github.com/blackjax-devs/blackjax). > [!CAUTION] > ⚠️ As per the LICENSE file, there is no warranty whatsoever for this free software tool. If you discover bugs, please report them. ## Examples -You can find several self-contained examples on how to use the algorithms in [examples](https://github.com/dirmeier/sbijax/tree/main/examples). +`sbijax` uses an object-oriented API with functional elements stemming from JAX. You can, for instance, define +a neural likelihood estimation method and generate posterior samples like this: + +```python +import distrax +import optax +from jax import numpy as jnp, random as jr +from sbijax import SNL +from sbijax.nn import make_affine_maf + +def prior_model_fns(): + p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) + return p.sample, p.log_prob + +def simulator_fn(seed, theta): + p = distrax.Normal(jnp.zeros_like(theta), 1.0) + y = theta + p.sample(seed=seed) + return y + +prior_simulator_fn, prior_logdensity_fn = prior_model_fns() +fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn +model = SNL(fns, make_affine_maf(2)) + +y_observed = jnp.array([-1.0, 1.0]) +data, _ = model.simulate_data(jr.PRNGKey(0), n_simulations=5) +params, _ = model.fit(jr.PRNGKey(1), data=data, optimizer=optax.adam(0.001)) +posterior, _ = model.sample_posterior(jr.PRNGKey(2), params, y_observed) +``` + +More self-contained examples can be found in [examples](https://github.com/dirmeier/sbijax/tree/main/examples). ## Documentation @@ -52,11 +80,35 @@ To install the latest GitHub , use: pip install git+https://github.com/dirmeier/sbijax@ ``` +## Contributing + +Contributions in the form of pull requests are more than welcome. A good way to start is to check out issues labelled +[good first issue](https://github.com/dirmeier/sbijax/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22). + +In order to contribute: + +1) Clone `sbijax` and install `hatch` via `pip install hatch`, +2) create a new branch locally `git checkout -b feature/my-new-feature` or `git checkout -b issue/fixes-bug`, +3) implement your contribution and ideally a test case, +4) test it by calling `hatch run test` on the (Unix) command line, +5) submit a PR 🙂 + +## Citing sbijax + +If you find our work relevant to your research, please consider citing: + +``` +@article{dirmeier2024sbijax, + author = {Simon Dirmeier and Antonietta Mira and Carlo Albert}, + title = {Simulation-based inference with the Python Package sbijax}, + year = {2024}, +} +``` + ## Acknowledgements > [!NOTE] -> 📝 The API of the package is heavily inspired by the excellent Pytorch-based [`sbi`](https://github.com/sbi-dev/sbi) package which is substantially more -feature-complete and user-friendly, and better documented. +> 📝 The API of the package is heavily inspired by the excellent Pytorch-based [`sbi`](https://github.com/sbi-dev/sbi) package. ## Author diff --git a/docs/appendix.ipynb b/docs/appendix.ipynb new file mode 100644 index 0000000..295f32e --- /dev/null +++ b/docs/appendix.ipynb @@ -0,0 +1,1527 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7c3f58b8-c517-4cc2-9812-35ca69c96750", + "metadata": {}, + "source": [ + "# Simulation-based inference with the Python package `sbijax`" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d21decd1-bc48-4dd7-bc4c-1c0a686620da", + "metadata": {}, + "outputs": [], + "source": [ + "import arviz as az\n", + "import jax\n", + "import haiku as hk\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import optax\n", + "import seaborn as sns\n", + "import tueplots.bundles\n", + "import tueplots.axes\n", + "\n", + "from functools import partial\n", + "from jax import numpy as jnp\n", + "from jax import random as jr\n", + "\n", + "from sbijax import CMPE, NRE, NPE, FMPE, NLE\n", + "from sbijax.nn import ConsistencyModel, CCNF, make_mdn\n", + "from sbijax.mcmc import sample_with_nuts, as_inference_data\n", + "\n", + "from tensorflow_probability.substrates.jax import distributions as tfd" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ad4a8152-24d1-4d4f-9747-d40e5692604a", + "metadata": {}, + "outputs": [], + "source": [ + "custom_params = {\n", + " 'font.family':'serif', \n", + " 'font.weight':'ultralight', \n", + " 'font.serif':'Computer Modern',\n", + " \"axes.labelweight\": \"light\",\n", + " \"mathtext.fontset\": \"stix\",\n", + " 'text.usetex': True,\n", + "}\n", + "sns.set_theme(style=\"ticks\", context='paper', rc=custom_params)\n", + "plt.rcParams.update(tueplots.bundles.icml2022())\n", + "plt.rcParams.update(tueplots.axes.lines(base_width=0.5))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "82406fdd-4776-4375-b444-beb25ddb8ed8", + "metadata": {}, + "outputs": [], + "source": [ + "def plot(inference_data):\n", + " _, axes = plt.subplots(figsize=(12, 4), nrows=1, ncols=2)\n", + " colors = sns.blend_palette([\"#636363\", \"#b26679\"], n_colors=2)\n", + " with az.style.context([\"arviz-white\"], after_reset=True):\n", + " plt.rcParams[\"font.family\"] = \"Times New Roman\"\n", + " axes = az.plot_posterior(\n", + " inference_data,\n", + " color=colors[1],\n", + " kind='hist',\n", + " hdi_prob=0.9,\n", + " edgecolor='black',\n", + " ax=axes\n", + " )\n", + " for ax in axes.flatten():\n", + " ax.spines[['right', 'top']].set_visible(False)\n", + " ax.spines.left.set_linewidth(.5)\n", + " ax.spines.bottom.set_linewidth(.5)\n", + " ax.xaxis.set_tick_params(width=0.5, length=2)\n", + " ax.yaxis.set_tick_params(width=0.5, length=2)\n", + " ax.grid(which='major', axis='both', alpha=0.25) \n", + " ax.set_title(None)\n", + " plt.tight_layout()\n", + " return axes" + ] + }, + { + "cell_type": "markdown", + "id": "b9a1a8c1-64fa-4c11-8e71-61f68d1e5cf6", + "metadata": {}, + "source": [ + "## Generative model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "35c54f8c-d601-45c4-8cca-f664feca3337", + "metadata": {}, + "outputs": [], + "source": [ + "def prior_fn():\n", + " prior = tfd.JointDistributionNamed(dict(\n", + " theta=tfd.Normal(jnp.zeros(2), 1)\n", + " ), batch_ndims=0)\n", + " return prior\n", + "\n", + "\n", + "def simulator_fn(seed, theta):\n", + " mean = theta[\"theta\"].reshape(-1, 2)\n", + " n = mean.shape[0]\n", + " data_key, cat_key = jr.split(seed)\n", + " categories = tfd.Categorical(logits=jnp.zeros(2)).sample(seed=cat_key, sample_shape=(n,))\n", + " scales = jnp.array([1.0, 0.1])[categories].reshape(-1, 1)\n", + " y = tfd.Normal(mean, scales).sample(seed=data_key)\n", + " return y" + ] + }, + { + "cell_type": "markdown", + "id": "bf5db051-940c-4f07-9d8d-4e1337951957", + "metadata": {}, + "source": [ + "## Observation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b8fa4638-8a65-45c3-a17c-751600bbd220", + "metadata": {}, + "outputs": [], + "source": [ + "y_observed = jnp.array([-1.0, 1.0])" + ] + }, + { + "cell_type": "markdown", + "id": "4b1a1ccb-5f5c-4d76-8cb5-6ac07f03b57a", + "metadata": {}, + "source": [ + "## NUTS " + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "1807e13c-52e3-4e71-95b9-b9d9910239d4", + "metadata": {}, + "outputs": [], + "source": [ + "def likelihood_fn(y, theta):\n", + " mean = theta[\"theta\"].reshape(1, 2)\n", + " mix = tfd.Categorical(logits=jnp.zeros(2))\n", + " likelihood = tfd.MixtureSameFamily(\n", + " mixture_distribution=mix,\n", + " components_distribution=tfd.MultivariateNormalDiag(\n", + " jnp.concatenate([mean, mean], axis=0),\n", + " jnp.concatenate([jnp.full((1, 2), 1.0), jnp.full((1, 2), 0.01)], axis=0),\n", + " )\n", + " )\n", + " ll = likelihood.log_prob(y)\n", + " return ll" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "bb2969f7-73ec-4c81-94b0-cee15744a7d7", + "metadata": {}, + "outputs": [], + "source": [ + "def log_density_fn(theta, y):\n", + " prior_lp = prior_fn().log_prob(theta)\n", + " likelihood_lp = likelihood_fn(y, theta)\n", + " lp = jnp.sum(prior_lp) + jnp.sum(likelihood_lp)\n", + " return lp" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "9997a2d6-760a-43a4-a3fe-ce288e7ef625", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'theta': Array([0.40356722, 1.3396233 ], dtype=float32)}" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prior_fn().sample(seed=jr.PRNGKey(2))" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "abd48b28-e3c3-4c0f-a3de-ae63d3b03859", + "metadata": {}, + "outputs": [], + "source": [ + "log_density_partial = partial(log_density_fn, y=y_observed)\n", + "samples = sample_with_nuts(\n", + " jr.PRNGKey(0),\n", + " log_density_partial,\n", + " prior_fn().sample\n", + ")\n", + "inference_results = as_inference_data(samples, jnp.squeeze(y_observed))" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "aff77af6-eb03-4d64-b803-68181f33cbed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 32B\n",
+       "Dimensions:    (theta_dim: 2)\n",
+       "Coordinates:\n",
+       "  * theta_dim  (theta_dim) int64 16B 0 1\n",
+       "Data variables:\n",
+       "    theta      (theta_dim) float64 16B 1.074 1.089
" + ], + "text/plain": [ + " Size: 32B\n", + "Dimensions: (theta_dim: 2)\n", + "Coordinates:\n", + " * theta_dim (theta_dim) int64 16B 0 1\n", + "Data variables:\n", + " theta (theta_dim) float64 16B 1.074 1.089" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "az.ess(inference_results, relative=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "decb9a49-0801-431b-87c5-ee5c48c8cbba", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 32B\n",
+       "Dimensions:    (theta_dim: 2)\n",
+       "Coordinates:\n",
+       "  * theta_dim  (theta_dim) int64 16B 0 1\n",
+       "Data variables:\n",
+       "    theta      (theta_dim) float64 16B 1.002 1.003
" + ], + "text/plain": [ + " Size: 32B\n", + "Dimensions: (theta_dim: 2)\n", + "Coordinates:\n", + " * theta_dim (theta_dim) int64 16B 0 1\n", + "Data variables:\n", + " theta (theta_dim) float64 16B 1.002 1.003" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "az.rhat(inference_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "3f97f4c0-fad4-4743-8b21-3054351891ba", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(inference_results)\n", + "plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/appendix-mixture_model-nuts.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5daed1f0-d4d7-4416-9b14-dc0c3132e4fb", + "metadata": {}, + "source": [ + "## CMPE" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "97d49dd0-b370-4ae8-8305-b54b917f8102", + "metadata": {}, + "outputs": [], + "source": [ + "def make_model(dim):\n", + " @hk.transform\n", + " def _mlp(method, **kwargs):\n", + " def _c_skip(time):\n", + " return 1 / ((time - 0.001) ** 2 + 1)\n", + "\n", + " def _c_out(time):\n", + " return 1.0 * (time - 0.001) / jnp.sqrt(1 + time**2)\n", + "\n", + " def _nn(theta, time, context, **kwargs):\n", + " ins = jnp.concatenate([theta, time, context], axis=-1)\n", + " outs = hk.nets.MLP([64, 64, dim])(ins)\n", + " out_skip = _c_skip(time) * theta + _c_out(time) * outs\n", + " return out_skip\n", + "\n", + " cm = ConsistencyModel(dim, _nn)\n", + " return cm(method, **kwargs)\n", + "\n", + " return _mlp" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "f15e063b-64aa-4735-8dcb-bae9e107be96", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 12%|████████████████▊ | 122/1000 [00:37<04:30, 3.25it/s]\n" + ] + } + ], + "source": [ + "fns = prior_fn, simulator_fn\n", + "model = CMPE(fns, make_model(2))\n", + "\n", + "data, _ = model.simulate_data(jr.PRNGKey(1), n_simulations=10_000)\n", + "params, info = model.fit(\n", + " jr.PRNGKey(2),\n", + " data=data,\n", + " optimizer=optax.adam(1e-3),\n", + " n_early_stopping_patience=25\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "086619bf-c0ee-497f-8ec1-041bfd5bff60", + "metadata": {}, + "outputs": [], + "source": [ + "inference_results, _ = model.sample_posterior(jr.PRNGKey(3), params, y_observed)" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "e462c9fa-0445-4b1c-8b0b-9671601b6ee9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(inference_results)\n", + "plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/appendix-mixture_model-cmpe.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f18890a1-55d2-477b-ae71-5f17f5bacf0f", + "metadata": {}, + "source": [ + "## NRE" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "38d603b7-d756-42f3-b76e-dc2993d3ae6c", + "metadata": {}, + "outputs": [], + "source": [ + "def make_model():\n", + " @hk.without_apply_rng\n", + " @hk.transform\n", + " def _mlp(inputs, **kwargs):\n", + " return hk.nets.MLP([64, 64, 1])(inputs)\n", + "\n", + " return _mlp" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "id": "c56a9825-205c-4096-8b68-97ba243cc69e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|██████▊ | 49/1000 [00:50<16:15, 1.03s/it]\n" + ] + } + ], + "source": [ + "fns = prior_fn, simulator_fn\n", + "model = NRE(fns, make_model())\n", + "\n", + "data, _ = model.simulate_data(\n", + " jr.PRNGKey(1), n_simulations=10000\n", + ")\n", + "params, info = model.fit(\n", + " jr.PRNGKey(2),\n", + " data=data,\n", + " optimizer=optax.adam(1e-3),\n", + " n_iter=1000,\n", + " n_early_stopping_patience=25\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "id": "e8c52677-dafd-455e-b1d8-267887fb11db", + "metadata": {}, + "outputs": [], + "source": [ + "inference_results, _ = model.sample_posterior(jr.PRNGKey(3), params, y_observed)" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "id": "c0650cd8-a376-470f-af51-1d83a2038fb6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(inference_results)\n", + "plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/appendix-mixture_model-nre.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "23bf7d8c-9306-4cb4-a810-705f444ad491", + "metadata": {}, + "source": [ + "## NPE" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "122c8710-4097-47e9-ae33-a56fa54cd06d", + "metadata": {}, + "outputs": [], + "source": [ + "import distrax\n", + "from surjectors import (\n", + " Chain,\n", + " MaskedAutoregressive,\n", + " Permutation,\n", + " TransformedDistribution,\n", + ")\n", + "from surjectors.nn import MADE\n", + "from surjectors.util import unstack\n", + "\n", + "def make_flow(dim):\n", + " def _bijector_fn(params):\n", + " means, log_scales = unstack(params, -1)\n", + " return distrax.ScalarAffine(means, jnp.exp(log_scales))\n", + "\n", + " def _flow(method, **kwargs):\n", + " layers = []\n", + " order = jnp.arange(dim)\n", + " for i in range(5):\n", + " layer = MaskedAutoregressive(\n", + " bijector_fn=_bijector_fn,\n", + " conditioner=MADE(\n", + " dim, [50, dim * 2], 2,\n", + " w_init=hk.initializers.TruncatedNormal(0.001),\n", + " b_init=jnp.zeros, \n", + " ),\n", + " )\n", + " order = order[::-1]\n", + " layers.append(layer)\n", + " layers.append(Permutation(order, 1))\n", + " chain = Chain(layers)\n", + "\n", + " base_distribution = distrax.Independent(\n", + " distrax.Normal(jnp.zeros(dim), jnp.ones(dim)),\n", + " 1,\n", + " )\n", + " td = TransformedDistribution(base_distribution, chain)\n", + " return td(method, **kwargs)\n", + "\n", + " td = hk.transform(_flow)\n", + " return td" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "1fcd12a0-1323-4ccc-ad8c-e6d2e35c883b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 13%|██████████████████▏ | 132/1000 [00:59<06:31, 2.22it/s]\n" + ] + } + ], + "source": [ + "fns = prior_fn, simulator_fn\n", + "model = NPE(fns, make_flow(2))\n", + "\n", + "data, _ = model.simulate_data(\n", + " jr.PRNGKey(1), n_simulations=10000\n", + ")\n", + "params, info = model.fit(\n", + " jr.PRNGKey(2),\n", + " data=data,\n", + " optimizer=optax.adam(1e-3),\n", + " n_iter=1000,\n", + " n_early_stopping_patience=25\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "id": "2ee4121d-a6fe-43b1-8b45-b5a6ffe519f5", + "metadata": {}, + "outputs": [], + "source": [ + "inference_results, _ = model.sample_posterior(jr.PRNGKey(3), params, y_observed)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "adf9360e-1e0c-4628-88af-4d8581573598", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKoAAAGKCAYAAAAsdKmCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABBnUlEQVR4nO3deXwTdf7H8XfpRY+05Ua5QRQoIIiAgMquPxTEE2QBEUQUvBZwFcQDBQU8VnAXkV11QRcWlRsVFaqCImBBBJVbDuUoBcrVtKVpk/T4/dE2UHrQpknzLX09Hw8fu0xmJp9Mmswn75n5jl92dna2AAAAAAAAAB+r4usCLmS3231dQoXFtnMP2809bDf3se3cw3ZzD9vNfZV521Xm115R8B6Zj/fIfLxH5uM9Mp833iPjgqqsrCxfl1Bhse3cw3ZzD9vNfWw797Dd3MN2c19l3naV+bVXFLxH5uM9Mh/vkfl4j8znjffIuKAKAAAAAAAAlRNBFQAAAAAAAIxAUAUAAAAAAAAjEFQBAAAAAADACARVAAAAAAAAMAJBFQAAAAAAAIxAUAUAAAAAAAAjEFQBAAAAAADACARVAAAAAAAAMAJBFQAAAAAAAIxAUAUAAAAAAAAjEFQBAAAAAADACARVAAAAAAAAMAJBFQAAAAAAAIwQ4OsCUHHYbDbZ7XZfl1Gk4OBghYaG+roMAAAAoEIwsb+npwdAUIUSsdls+mTREtlTU31dSpGCw8LUp38/dmwAAADARZja39PTAyCoQonY7XbZU1PVql4jWcItvi6ngJSzKdoVf0h2u52dGgAAAHARJvb39PQAJIIqlJIl3KKoiAhflwEAAADAA+jvAZiGwdQBAAAAAABgBIIqAAAAAAAAGIGgCgAAAAAAAEYgqAIAAAAAAIARCKoAAAAAAABgBIIqAAAAAAAAGIGgCgAAAAAAAEYgqAIAAAAAAIARCKoAAAAAAABgBIIqAAAAAAAAGCHA1wUAAAAAACBJdodDVqu1XJ4rLS1N6enpJZo3ODhYoaGhXq4IgERQBQAAAAAwQFp6urZt3arMzEyFhoR4/fmcTqcCAwNLNG9wWJj69O9HWAWUA4IqAAAAAIDPOZxOyZmhVvUaqU6t2l5/PqfTocDAoIvOl3I2RbviD8lutxNUAeWAoAoAAAAAYAxLWJiiIiK8/jwOh0NBQRcPqgCULwZTBwAAAAAAgBEIqgAAAAAAAGAEgioAAAAAAAAYgaAKAAAAAAAARiCoAgAAAAAAgBEIqgAAAAAAAGAEgioAAAAAAAAYgaAKAAAAAAAARiCoAgAAAAAAgBEIqgAAAAAAAGAEgioAAAAAAAAYgaAKAAAAAAAARiCoAgAAAAAAgBEIqgAAAAAAAGAEgioAAAAAAAAYgaAKAAAAAAAARiCoAgAAAAAAgBEIqgAAAAAAAGAEgioAAAAAAAAYgaAKAAAAAAAARiCoAgAAAAAAgBEIqgAAAAAAAGAEgioAAAAAAAAYgaAKAAAAAAAARiCoAgAAAAAAgBEIqgAAAAAAAGCEAF8XACC/jz/+WEuXLlVQUJBq1qyp8ePHq27duhddbtasWZo2bVqhj/n5+WnDhg2qVq1aoY9PnDhR69at07ffflum2gEAAABv+2zV14pZ+50CAwNULSJSI4cMU63qNS663IIvPtN/Fn5U6GN+fn5a9q/ZirRYXNMyMjL0Tew6ffTZMt3Zu7fH6gdQPIIqwCBvvfWWPvvsMy1dulTVqlXT7NmzNWjQIC1ZskTVq1cvdtmlS5cqJCREtWrVkr+/v2t6YmKimjVrVmRItXz5ci1YsED16tXz6GsBAAAAPO2/Sxfq6/Vr9e6k1xVpsWjBl8v1xOQJ+vfLrykqIqLYZVeu/U5Vg4JVPSpK/v7+ys7Olp+fn5JSktXo8vr5QqoDcYe1esN6fbb6a6XabN5+WQDOQ1AFGGL37t169913NWnSJFeodP/992v27Nl6/fXX9cYbbxS57ObNm3X99ddr3LhxCgoKyvfYQw89pD//+c+FLrdv3z4tXrxY7dq108mTJz33YgAAAAAP23/ooD76bJmeevARV6h0T8/eWvjlZ3rn4//puUdHFrnstj27dW3rtnrk3iEKCgyUJDkcDgUFBWncG6+oS/sO+eZv0qChhjcYpHS7Xcu+Xum9FwWgAMaoAgwxe/ZsZWVl6frrr3dNCwoK0rXXXqsvv/yy2CApODhY48ePLxBSJSYm6scff1TPnj0LLHP27FlNnDhRb7zxRoHlAAAAANMs+PIzZWVn69o2bV3TAgMC1Oaqlvp24w86Y7UWuWxwYJBGDhnmCqnyJKWkaOvunere8bpClwsLDfVI7QBKjjOqYIzN27fp+00b9NP2X/VA3wGqUa2aNvyyRT9s+UlhIaF6YuhDuqJxYy2NWaHf/tivHXv36IZrO+lvw0a41pGSkqJ33nlHBw8e1N69e1WzZk2NGTNGXbp0cc2ze/duTZs2TZmZmYqPj1fNmjU1btw4tW/fXtnZ2fr++++1bNkyxcbGasmSJVq/fr22bNmi2NhYde/eXVOmTFFQUJDWrl2rWbNmlei1de/eXcOHDy/y8czMTK1fv17h4eG67LLL8j3WokULffPNN9qwYYPuvPPOQpdv06ZNodO//vprtW/fXrVq1Srw2IQJEzRq1KgCzwcAAICK54cfflBMTIzWrVun0aNHq3bt2vruu++0atUqWSwWTZgwQa1atdKcOXO0Y8cObd68WY0bNNQ1zVq41nE2NVVzP1msI8eP6cCRw6oWGaUR/e/TNdGtXfPsP3RQsxZ+pMysLB0/eUI1qlXXwwPuU3TzK5Wdna0ft/6imLXfacvO7Xrn5df00/at2rHnN23ZuU2dr75GY4c/qsCAAG3a9qvmf/5pvteQbrcr4eQJHX3nbQWfdyC1c7tr9Jdbb9fm7VsVFhKi2jVq5luuWYNGWr95k37euV09ut1Q6Pa5qmmzQqev++lHRTe/StWjogp93M/Pr7jNDsALCKpgjGvbtNWJ06f05ZrV2vjrzxp8V1+Nvv9BDbnrHg179ilNeect3fHnm9Wv120KDQnR95s26uW3/6GmDRvp/7pcL6fTqbFjx2rixImKjo6Ww+HQY489phEjRujjjz9W27ZtdfLkSQ0dOlT9+vXTuHHjlJaWprvuukujR4/W2rVr5efnpz/96U9atWqVUlJS9L///U8jR47U4MGDtWLFCj355JOKjo7W0KFDdeONN+rGG2/0yGtPSEiQ1WrVFVdcUeCxiNxr7fft21fq9a5YsUK9Cxn4cc6cOWrZsmW+AA8AAAAVV7du3XT06FEtWrRIa9as0WOPPaYXX3xRjz/+uHr37q0xY8ZowIABeuCBBxQeHq6lS5fq+eef11fr1mjwXX2Vbrdr/D/+rr8OeUBXNm4qh9OpF//5hp6d+opmTJisFk2v0BmrVWNee1m9u/+fHrl3sNLtdj38wji99PabWvTWu/Lz89N17a7R+i2blGqzaelXKzS0z1/U5+Ze+m5jrCb/a7qubNJU9/TsrU5t26lT23b5XsOh+HjNW7JADw4YpMvr5j+YmnDqlJLPnlWjevULvHZLWJgk6cCRuFJvt+9+jNWfOtMTAybh0j8YpU7NnKMjndu11xWNGkuSqkVGqm2LljqdmKghd9+j0JAQSXLt2H7dvVOStOmXnxUdHa3o6GhJOZfN3XfffXI6nXr//fclSdu2bVNSUpJat845KhQSEqKuXbvqxIkTOnPmjKuOmrl1PPDAA65BzPMuydu0aZPHX/fp06clSWG5O9nzheaebpyUlFTqdf78888FLvv7+eeftX37do0YMaKIJQEAAFAR5d0cp3v37mrZsqUkqUaNGurYsaNOnDihv/71rwoPD5ck1wHLHfv2SJIWr/xcLZpdoSsbN5UkBQUG6q4ePZWRmamFXy6XJO3+Y79SUlN1VdOceaoGB6tjm6t1OjFR1uRkVx3VI6MkSf163eYa4Lxjm6slnevdS8uanNMLh1YNKfBYSNWqkqSU1LOlXueOfXt0YxGX/QHwDc6oglHy7lbnp/yn2Ibl7pDOP/U2b4eUdxeOPfv36fDReA0ZMsQ1j91uV7169VwhT+fOnTVmzBjXmVA2m831WHp6eoE6qlQ5l+VacgdsTElJkSSPXvrndDrzPe/5MjMzJUmBF1xPfzExMTG69tpr890t8MyZM3r77bf19ttvl2pdAAAAMJ+rl77gcrW8cCpfL5178NeWliZJ+n7Tj3I4Hdp74A/XPA6nU3Vq1lJKaqokqX3LaA3vP0id2raXJKWlp7vCIbvT4Vour4f2P6+XzhvrKa93L+2lf62bX5X7Gguea5GZmSVJCggo3c/bdZs3qe2VLS56t0AA5YugChVedna2JCnRatXQBx4o9kyh8PBwPfzww4qLi9P06dOVmpqqtNydc956ipK3Y8+br7SX/iUkJGjo0KEFps+dO1eRkZGSpOTzjkTlseXuzPPuBFhSMTExBca0mjlzpvbs2aN+/frlm37s2DFlZGSoV69eatu2bbF3GAQAAMClIzs7J+SJTzimRwYO1t039ypy3tCQEA26424dPZGgD5YskC09TWl2e96Kin2eC3vp0l76d/hovCS5QrPzpdlzDjhHhluKreFCazf/qFuu716qZQB4H0EVLhnZWdklGsdp5syZWr16taZNm6ZmzZrpH//4h7777juv1+d0OnXgwIFCpzdq1EhVq1aVtZA7lZw6dUqS1Lx58xI/14kTJ/Trr78WOHPKZrPp9OnTrksNL3TgwIFCB14HAADApS0rK0u/Hz500fnmLlusH37erPGPjVKjevU1Z9ki/bDlJ6/XV69OXQUHBSn5bEqBxxKTrJKkJg0alHh9p62J+u333zX5b+M8VSIAD2GMKlwyIiMitGrVKiUkJBR4bM6cOZJyzl56++239eabb6pZs8Lv/OEt9evX1549ewr8V79+fQUEBKhr1646deqUjh8/nm+5AwcOuB4vqa+++kqdO3dW1AV3L3n99dcLraFTp06qV6+e9uzZo3nz5nni5QIAAKACqVOzltb8GKtTiWcKPLYk5ktJ0tKvVmjuJ4v1wl+fKHRQc2/y9/dXh9ZtlZiUpJNn8h90jTt2VP7+/romum2J1/f9po26ukVLReReFgnAHARVMEpWVs6pwNkq/NThwi7Py5vWvFlTpaamasSIEa4zqzIzMzV79mzXvOvWrZOUM6jkhcufv+68caGKez5PGzZsmKScWwvncTgc2rJli/r16+caI0uSzp49q7Nnix4ssqi7/QEAAODSlZWVcxlfUf1q4b1tzv9e36GjUtPS9OzU11x3z8vMytKCL5e7lvtp26+SpGrnj+mUnX89+esoWQ0l9Zdet0uSNu/Y5prmcDq1fe9v6t39JoXnjoMlSalpNqWm2Ypc15ofY0s0iPq53wruVg2gtAiqYJSjCTlnEyWcOplv+rGTJ3Kmnz51btqJnGknE88oMytL13Xo6Dor6Pbbb9ef//xnderUSZ9//rnuu+8+SVLjxo0lSVOmTNHWrVs1c+ZMrVq1SpK0ceNGLV68WJIUF5ezcz569Kjr+U7kPt/x48ddQZYnderUSQMGDNCcOXNc41L961//UrVq1fTEE0+45rPZbOrRo4d69Ojhmu98x48f186dO9WjRw+P1wgAAABzHT58WFL+HlaSjhw5UmB63v8/bU1UZlaW7r3jbl1Wu47+iDukh54bo4F/e1x3PzpMq2PXqU/uuFX1c8eNenvef7V7/z7NXbZY32/aIEn6ZdcOfblmdc66T+Rc4ZBw+lxPf9qaKOlc7+6Oq1u20h039dCSlV8oLfdGSPM+XapIS4Qe7DfANV9aeroGjxmlwWNGueY738kzp7X3wB/qek2Hiz7n6cScus+W8o6CANxHUAVjzFm6SP/6aI4k6ePln+i5aa/p5JkzevDZMdq2Z7ck6fEJz+nTb2L05ZrVevyl5yRJx04kaPTkF+VwOvSf//xHd911lyIiImS1WnXDDTfo/fffd90x7/HHH1e3bt20atUqvfLKK2rXrp3GjRun0NBQrVmzRj179tRDDz2kL774QpI0cuRIzZgxQ8uWLVPfvn0l5YRYt912myvM8qSXXnpJt9xyi+677z4NHDhQJ06c0EcffZTvzn0BAQGqXbu2ateuXeidTWJiYtS1a1dFcPcSAACASmPGjBl69dVXJUnvvfeeHn74YSUkJOj222/XTz/ljCHVr18/ffTRR1q8eLEefPBBSTkHiIc986Rsael6+8XJurnbjQoPDVPy2RR1bNtOfx833tVzDr7rHnVo3VbrN2/SzA/nqFXzKzVyyDCFVK2qDb9uUfeO12ncG6/o2w05VwhMmD5Nc5YuUszaNXr0xWcl5fTuDz77lOugc2k9MXS4bujYWU9MmahRk17UaesZTR//siIt53pff39/1YiqrhpR1Qvtl9f8uEHXRLdReGhYkc+z98AfeuTFZ7Rybc5YtkuWf6bx48e7VTOA0vHL9tZ1TG5KS0tz3SoVpePNbZeYmKhPPl6gzle1NvL2rdbkZP24Z4f6DBpY6rvj8TfnHrab+9h27mG7uYft5r7KvO0q82uvKHiPzGf6e2Rif1/cXf+8weFwKCgo6KLzleW3BsrG9M8RvPMecUYVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjBDg6wIAT7E7HLJaraVeLi0tTenp6Z4v6DzBwcEKDQ316nMAAAAAAFDREVThkpCWnq5tW7cqMzNToSEhpVrW6XQqMDDQS5XlCA4LU5/+/QirAAAAAAAoBkEVLgkOp1NyZqhVvUaqU6t2qZZ1Oh0KDAzyUmVSytkU7Yo/JLvdTlAFAAAAAEAxCKpwSbGEhSkqIqJUyzgcDgUFeS+oAgAAAAAAJcNg6gAAAAAAADACQRUAAAAAAACMQFAFAAAAAAAAIxBUAQAAAAAAwAgEVQAAAAAAADACQRUAAAAAAACMQFAFAAAAAAAAIxBUAQAAAAAAwAgEVQAAAAAAADACQRUAAAAAAACMQFAFAAAAAAAAIxBUAQAAAAAAwAgEVQAAAAAAADACQRUAAAAAAACMQFAFAAAAAAAAIxBUAQAAAAAAwAgEVQAAAAAAADBCgK8LAAAAAIBLnc1mk91u93UZLlarVQ6H09dlAEABBFUAAAAA4EU2m02fLFoie2qqr0txSbXZtHfXbnVu0crXpQBAPgRVAAAAAOBFdrtd9tRUtarXSJZwi6/LkSTFHz+qXb9uVYYzw9elAEA+BFUAAAAAUA4s4RZFRUT4ugxJUlJKiq9LAIBCMZg6AAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACMQVAEAAAAAAMAIBFUAAAAAAAAwAkEVAAAAAAAAjEBQBQAAAAAAACME+LoAoLwdPZGg9xfN18nE00pJTVXNatX0+KChatKgYYF5fz90UO8u+FAOh0OZWVm69/a71K1Dx3zz7Pnjd838cI4yMzMlSc88/Lga1atf6HMvW7ZMBw4c0JgxY4qtcf/+/Xrqqae0b98+ZWVlSZJq1aqlgQMHauTIkZKk0aNHa/369UpNTZUkBQUFqWXLlvr3v/+tFStW6KOPPtLBgwclSRaLRXXr1lVGRobsdrvq16+vTp06qX///qpTp06+5x48eLC2bdsmu90uSYqMjNR1112nGTNmFFszAAAAvOvCPrZ29Rp69N4hbvexyaln9fLM6fL395dUfB8bs3aN4o4d1YgBg4qt8WD8EU3511s6eOSwsrKzJUk1oqrpjptu1v19+kmSXprxpjZv3yZbepokKTAwUFc0bKxHBg5RXMJxjX3jFR0/eUKSFBYaqlrVaigzK1N2h0OX166jti1a6rY/9VCt6tXzPfffpkzUb3/sl8PplCRZwsLUvlUbvTT6qWJrBmAWgipUKvEJxzV60ot65N7BuuX67srOztb7i+dr9OQXNWPCFDWp38A1776DB/TUay/r6eGP6saO1yk+4bgenfCsnhr2sP58XVdJ0tnUVD037TXdd1df3dOzt157d6YmzfynZr86TX5+fvme+8iRI/r000/1/vvvX7TOK664QsuXL9e8efM0ZcoURUdHa/Hixa4mQpJmzJihxMREde/eXXa7XQsWLFB0dLQk6f7771fNmjX15JNPqlevXnrrrbdcy506dUrz58/Xe++9pzlz5uiFF15Qnz59XI9/+OGH2rNnj+68804FBAToyy+/VK1atdzb4AAAAPCIwvrYOcsWud3H2tLStHXfHg3ofYce/Mu9xfax8QnH9fX67/XGuPEXrbNxvfqa/epULft6pWbO+6+ubNJU/3rpVflXOXcxz0ujxygpJUUDnnhUDqdTb0+YrCsbN9Wh+Hg1qFNXra5qoZkfzVX3Ttdp4qhzIdOZJKuWr/5a8z//VEtjvtTIIcPU84Y/uR6f/sLL+iPusIY/P1b+/v767+v/VPWoKDe3eH52h0NWq9Uj6/KU4OBghYaG+roMwOMIqlCpvP2/D1S7Zk3dcn13SZKfn5+G3HWP1m3epGmz39W/XnpFkpSdna03P3hPTes31I0dr5Mk1atTVz2v767pc2bpmug2irRYFPvLZllTknVNq9aSpOvaXaNvflirXfv3Kbr5la7nzcrK0uuvv65XXnlFgYGBJa73iiuukCQ1adIkX0iVp1q1aqpevbqOHTum5s2bF3hMUoHnq1mzpkaNGqVOnTrpoYce0vPPP69q1arpT3/6k2uevHVFRUURUgEAABigsD72gb79tebHDW71sb/s2iFnRoarZy2qj83MzNQ//ztLTz34sAICSv7zsXHumVkN6l6eL6TKE2mxKCoiQidOn1aT+vnPCLOEh0uSAi94vuqRUXqgb3+1axmtZ954RVNnvaNIS4Sua3dNgeeNCA/3WEiVlp6ubVu3KjMzU6EhIR5ZpycEh4WpT/9+hFW45BBUodJIS0/X5h3b1D13h53Hz89P13fopPlffKq9B/7QlU2aavOObdp74A8Nu6d/vnnbR7fRsq9XKmbtdxpw2506deaMpJyjGZIUHhYmSTp55pSkczv49T9uVM+ePdW4ceNS1Vwld6d+4VGtwuapckEDcOG/L9S5c2eNHDlS//znPzV+/HitWbPGFWrlLVtYOAYAAIDy5Y0+NjE5SZIUHBgkqeg+ds6yxfq/Lt1Uv+5lpar5XB9b9Dx+frl97AUzFdf7SlK7ltG6v08/vb94gabOfkcLp7/jCtFcfWwVz/WxDqdTcmaoVb1GqlOrtsfWWxYpZ1O0K/6Q7HY7QRUuOQRVqDRS02zKysrSqcQzBR67rHbODmfX/r26sklT/fjrz5Kkxhcc3WnWsJEkafP2rRpw252qm7ujOps7TlRySookqU6Nc2ch7dq/V4lWq+644w4Pv6KyGzx4sGbOnKlTp07pm2++Ue/evX1dEgAAQJnYbDbXWJu+lJaWpvT0dEmS1WqVw+F0e13e6GPzxndKTcsZJ6qwPnbbnt06mnBcD/1loNu1e0ufm2/V/z5ZosSkJK3bvMl1SaM3WcLCFBUR4fXnASo7gipUGtUjoxQRbtG+gwd02pqoGlHVXI+l5TYRyWfPSpL+iDssSQUGaLTkHmk6cCROktSlfQfVrlFTqzesV/PGTbR6w3pd1aSZrmraTFJOgPXhZ8vUs0cP7744N4WHh6t169b65ZdftGXLFoIqAABQodlsNn2yaInsuQcRfcnpdLrOVk+12bR31251btHKrXV5o49t1zJawUFBiv1ls7p26FhoHzt70cd65aln3KrZ20JDQtS8cVPt2r9X2/f+Vi5BFYDyQVCFSqNKlSoadk9/vTX3fU2d9a5eHPmEwkJCdfBInNb+9KMkKaRqVUmSNTlZkhRaNf816CHBOY+npJ51zf/mcxP0nwUfatSkF9Xgssv19PDHXKccT587W4PuuFup2Rk6c+aMXn31VR0+fFht27bVmDFjVDX3+S4mNjZWQ4YMKfSxkydPlnJL5Jd317/4+PgyrQcAAMDX7Ha77KmpalWvkSzhFp/W4nQ6FJh7WV388aPa9etWZTgz3FpXUX3sgbjDbvexwUHBan9lS506c6bIPvbBfgNlCQtXYlKS3pn/Px1NOK4WzZprRP9BCg4KKlHtW3Zs15OvvFToY2eSrKXaDhfKC+MSTpWtHwZgFoIqVCp39eipurVq65OvV+pvUyaqWcNGatcyWsdP5dz+Nm8gx4zMnCbiwjGaMrOyJCnfQJL16tTVy0+MLfBcMWvX6LJatdX6yhba+Nt2jR07Vm3atNH8+fM1fPhwPfPMM/nuxlecrl27atq0aYU+dtNNN5UpZLrYGAAAAAAVjSXc4vNLtBwOh4Jyw5yk3MvqyqKwPvba1leXqY8NrVpVDw4YpMsvGH8qr49t1zJa2dnZGv+Pv6t548aa8eJkPTP1Vb3+3sx8d+MrTofWbfT8Y6MLfezeJ/9appApr4/Nzs52ex0AzENQhUqn89Xt1fnq9q5/79y7R6cTExUeGqa2LVpKkixhOXcayTvilCfv1OrIixyhi084rlWx6/T3p59XSmqq4uLjtWvXLj333HOqUqWKbrvtNj3//POKj49XvXr1PPnySi0hIUGSdPnll/u0DgAAABTvwj5274E/vNrHStK233brtz/265GBg1WlShXd1KWbps56R8dPnVTdmr69O3TemF11fFwHAM8q/rZgQCUw/8vPJEn39OytoNxxBJo0aCDp3LX+eRJzT09uXL9BkevLu4Xvk8NGuI5kHT+REwbVzh3ssm7dupKknTt3euhVuMdms7lq6NKli09rAQAAQOl8uHyZJO/2sXsO/C5JqlEtZ1ysWtVqSMoJyXwpLT3dVcM10W18WgsAzyKoQqW2efs2xf68WS2aXqFBd/ZxTe989TWSpD1//J5v/rhjR3Mfb6+izFm2WD263qB6deq6puWdjpy3wz93u17fXnY3f/582e12NWzYUDfddJNPawEAAEDJbd6+Tes3b/J6H5uVe8lgXv9apUpO/+rrPnb56q/lcDp1ee066nrNtT6tBYBnEVSh0oo7dlRT/j1ddWrW0oRRTyrwvOv1u7bvoHp16mrLjm35ltm8Y5uqRUTq5m43FrrObXt269jJBPW68U/5ptesnnPk6fTp05LODYDesGH+2wZfKDMzU9K5BqEwDoej0HmKW0aStm7dqhkzZigwMFCvv/56vnEMMjIySrQOAAAAlL+8PrZuOfSxeWdgWZOTJElnrFZJyhdmFSavj80spp909ZwXjDF1sTGndu/fpznLFikwIEDPPvJX+Vc597M273kZtwqouAiqUOk4MzL09fq1+utL49W0QSPNeGFSgevr/f39NXb4o9r9+z79ujvn0rj9hw5q9Yb1enLYCIWGhBRY79nUVL2/aL7+NnR4gccaN2yohg0b6rvvvpMkrVq1Sh06dNBVV11VbK379u1z/a/T6Szw+MmTJ5WYmJhv3jx50y9ks9k0d+5cPfDAAwoPD9cHH3ygDh065Jtn//79kiSr1VrmuwoCAADAMy7sY9+Z9JrX+9gOrduqft3LtOGXnyVJ67dsUpsrW6hpg+IPuB6MPyJJOhR/xBVIne+M1SprSs4dCg8cOZzvsZQLLlvMk5aerqVfrdCY1ycpNCREb4x7Qa2vbJH/eY/ESZKSUpJdoRqAioXB1FGpvDh9qvYfOqjLa9fRqPuH6f+6XF/ojlOSrm7RSq8//bxmL5qvAH9/ValSRS+PHqtrolsXOv9bc9/Xg38ZqPCwsAKP+fv7680339S0adPUv39/RUVFafr06UXWuX//fj377LPatWuXJGnv3r3q3r27Bg0apJEjR0qSRo8erY0bN7rqv/fee9WyZUvNnDlTy5cv1/z58yVJn3/+ubZs2aI6depIygmwGjdurLFjx6pv374KuaBZuf/++7Vjxw5JktPp1C233KIbbrhBM2bMKLJeAAAAeFdhfWyVKoWfd+DJPjYwIECvjX1Ob77/nv760nhFhIdrwqgni6zzYPwR/f0//9K+gwckSX/EHdaAJx7TXT166v4+/SRJL834h37Ztd119tPoSS/qikaN9fCAwTp8/Jh2/JFz0HRV7Hpt2/ObalarLj8/PyWlJKt+3cv08ID71OvGP6tqcHC+537q1Zdd41ZlZGZqyNOj1bHN1Xpp9JjiNi0Aw/hlG3ZOZFpaWoEfzigZb267xMREffLxAnW+qrXPb/VbmEPx8Zq3ZEGht9e9mPNvHewN1uRk/bhnh/oMGqhquYNQXgr4rLqPbecetpt72G7uq8zbrjK/9oqC96hwJvWs5/eYZelVvYWaSv47wMRtdan+xrgQ33Xm88Z7xKV/AAAAAAAAMAJBFQAAAAAAAIxAUAUAAAAAAAAjEFQBAAAAAADACARVAAAAAAAAMAJBFQAAAAAAAIxAUAUAAAAAAAAjEFQBAAAAAADACARVAAAAAAAAMAJBFQAAAAAAAIxAUAUAAAAAAAAjEFQBAAAAAADACARVAAAAAAAAMAJBFQAAAAAAAIwQ4OsCgMrA7nDIarX6uowiBQcHKzQ01NdlAAAAAAAqOYIqwMvS0tO1betWZWZmKjQkxNflFCo4LEx9+vcjrAIAAAAA+BRBFeBlDqdTcmaoVb1GqlOrtq/LKSDlbIp2xR+S3W4nqAIAAAAA+BRBFVBOLGFhioqI8HUZAAAAAAAYi8HUAQAAAAAAYASCKgAAAAAAABiBoAoAAAAAAABGIKgCAAAAAACAEQiqAAAAAAAAYASCKgAAAAAAABiBoAoAAAAAAABGIKgCAAAAAACAEQiqAAAAAAAAYASCKgAAAAAAABiBoAoAAAAAAABGIKgCAAAAAACAEQiqAAAAAAAAYASCKgAAAAAAABiBoAoAAAAAAABGIKgCAAAAAACAEQiqAAAAAAAAYIQAXxcAAAAAoGKy2Wyy2+2+LsPFarXK4XD6ugwAQBkQVAEAAAAoNZvNpk8WLZE9NdXXpbik2mzau2u3Ordo5etSAABuIqgCAAAAUGp2u1321FS1qtdIlnCLr8uRJMUfP6pdv25VhjPD16UAANxEUAUAAADAbZZwi6IiInxdhiQpKSXF1yUAAMqIwdQBAAAAAABgBIIqAAAAAAAAGIGgCgAAAAAAAEYgqAIAAAAAAIARCKoAAAAAAABgBIIqAAAAAAAAGIGgCgAAAAAAAEYgqAIAAAAAAIARCKoAAAAAAABgBIIqAAAAAAAAGIGgCgAAAAAAAEYgqAIAAAAAAIARCKoAAAAAAABgBIIqAAAAAAAAGIGgCgAAAAAAAEYgqAIAAAAAAIARCKoAAAAAAABgBIIqAAAAAAAAGIGgCgAAAAAAAEYgqAIAAAAAAIARCKoAAAAAAABgBIIqAAAAAAAAGIGgCgAAAAAAAEYI8HUBAHzP7nDIarWWapm0tDSlp6d7p6DzBAcHKzQ01OvPAwAAAADwPYIqoJJLS0/Xtq1blZmZqdCQkBIv53Q6FRgY6MXKcgSHhalP/36EVQAAAABQCRBUAZWcw+mUnBlqVa+R6tSqXeLlnE6HAgODvFiZlHI2RbviD8lutxNUAQAAAEAlQFAFQJJkCQtTVEREied3OBwKCvJuUAUAAAAAqFwYTB0AAAAAAABGIKgCAAAAAACAEQiqAAAAAAAAYASCKgAAAAAAABiBoAouTqdTS5cuVc+ePXXkyBG315OUkqyBf3tMc5Yt8mB1QH4bN27Ufffdp/vuu0+DBw/Wli1bSrzsDz/8oIEDB6p9+/bq0qWLJk+eLLvd7sVqAQC4dMWs/U6PTXhOoye/qIlvTdPJM6fdWg89JFD+NmzYoKFDh+qTTz5xa9mrrroq339DhgzxQpWobLjrHyRJe/fu1RdffKGPP/5YKSkpbq8nKytLr7zztk6cdq9BAUpi7dq1Gj16tObOnaurr75av/76qx544AHNnj1b1157bbHLfv/991q1apWeeeYZpaena+bMmfrwww9lt9s1ZcqUcnoFAABcGtZt3KB9+/frP1PeUKTFogVfLtcTkyfo3y+/Vqq7CdNDAuXLarVq0aJFWrp0qQ4ePKi77rqr1OuYPXu2mjRpkm/a8OHDPVUiKjHOqIIk6corr9RTTz2lu+++u0zr+d8nS9Twsss9UxRQiLS0NL3wwgu6+eabdfXVV0uS2rVrpy5duui5556T0+ksdvmTJ09q8uTJrrOp3n33XVksFq1cubI8ygcA4JKxd+9ebfhpk/5y6+2KtFgkSff07K00e7re+fh/pVoXPSRQvqKiovTwww9r7Nixbi2/bds2WSwWxcTE5Puve/fuHq4UlRFnVCEfS26T4Y6ftv2qIwnHNPwv92rZ1/zoh3csX75cCQkJ6tatW77pXbp00bfffqvVq1erV69eRS7fr1+/fP+2WCxq0qTJRQMuAAB8yWaz5btMPS0tTenp6T6sSPrggw+UnZ2tdi2jXdMCAwLU5qqW+nbjD3pk4GBVj4q66HroIQHfCQ8Pd2u5d999V7fccosyMjIUEECsAM/iLwr5VKni3kl2CadO6ePPP9WrY55VUkqyh6sCzlmzZo2knLMAz9eiRQtJ0vr164sNqi7kdDp17NgxTZs2zWM1AgDgSTabTZ8sWiJ7aqprmtPpVGBgoM9qysrK0oYNGxTg76+I8LB8jzVr0EjrN2/Szzu3q0e3G4pdDz0k4Fvu/P7bt2+f6wDxq6++qjvvvFOPPfaYatSo4YUKURkRVKHMnBkZmvb+uxrz0CMKqVqVJgNetXfvXklS3bp1802PyB0HY9++fSVeV3Z2tqZNm6ZRo0bpuuuu81yRAAB4kN1ulz01Va3qNZIlPOfsd6fTocDAIJ/VdPLMadntdoVVDVGGMyPfY5awnODqwJG4YtdBDwmUjd3hkNVqLdM68sYnTk1NVWJiYomW2bFjh26++WYdOnRIe/fu1bx58/TFF19o6tSp6tChg0JDQ8tUE0BQhTL790dzdffNvVS/7mW+LgWVwJkzZyRJYWH5j97m/bukO+ulS5dqwYIF2rZtm6pWrarAwED17dvXo7UCAOBJlnCLa4Byh8OhoCDfBVUJp05Kkvz9C56NEVK1qiQpJfVsseughwTcl5aerm1btyozM1OhISFur+dwbqD888Yf5Uwu/jN7vvYtWql9i1ZK7NxFq75foz8OHdSokSP1+MOPavCwoYRVKBOCKpTJ6tj1soSFqds1xd9pDfCUvLGk/P39803PyMg5mlvSpv32229X8+bNNW/ePC1fvlzjx49X69atC1xSCAAACnLm7nf9/PwKPJaZmSVJxY5bQw8JlI3D6ZScGWpVr5Hq1Krt9nrC/HI+p03r1lfnq1q7tY6bO3bVPz54Txt+2aINGzfoL4MGElShTAiqKoGEhAQNHTq0wPS5c+eqTp06ZVr3mx+8p5rVquv7TRtd0zIyMyVJn37zlb7bGKvh/Qfphms7lel5gDyRkZE6deqUkpOTVb16ddd0m80mKecOJiURHBystm3baurUqbr88sv17rvvasWKFQRVAADkOnnmjMa+PqnA9GnPTlBE7gDMGRmZBR5Ps+cM8h4ZXvRNeughAc+whIW5zrR0R3juVQmhISFlWs/Twx/ToKf+quMnEtxeB5CHoKoScDqdOnDgQKHTyyrdbteR48cKfSz5bIqSz6YoNTdAADzhyiuv1KlTp5SYmJgvqDp16pTr8dJ68MEHNWvWLNdlhQAAQMrMzFDcsaOFTq9Xp66CAgNdZ1adLzHJKklq0qBBkeumhwQuLVEREbqqSTOlOe0Xnxm4CIKqSqB+/fras2ePV9b97bxFBaYdP3lCg54aqfv79NMDfft75XlReXXv3l2xsbHasWOHmjVr5pqeF8beeOONpV5nZGSkoqKi1LRpU4/VCQBARVe3Vu1Ce708ra64Sr/u3qHTVqsuP2+cqbhjR+Xv769rotsWuSw9JHDpCQwIUK067l+GCOQp/b0ocUnLysoZUyA7O7vQx21paUpN4+gWfKdv376KiIhQbGxsvuk//PCDmjdvruuvv941zel06vTp0xddZ0JCghwOh+644w6P1wsAwKWq5w3dJUk79v3mmuZwOrV972/q3f0mhZ83Rk1qmo0eEjBQVlbO775sFf77LyMjQ4lJSRddT0rqWaXb7bo62r1xroDzEVQhnxMnTkjK+eF+IYfTqcdfek6Dx4xSWnp6eZcGSJIiIiI0ceJEffXVV/r9998lSevWrdPPP/+sKVOm5Btk/bHHHtMNN9ygn3/+WZKUnJysZ599Vh999JHsdrtr2sSJE/Xmm2+qRo0a5f+CAACooFo0vUKX16qtlWvXuHrDeZ8uVaQlQg/2G+CaLy09XYPHjKKHBAx02poz9MWpIobAeOGfb+gvox/Rjr05V+g4nE69OH2q5n26VHaHQ5KUlJKidz+ep4cH3lfsTRSAkuKvCJKkHTt2aMKECdq1a5ck6dFHH9X111+v6dOnu+ap4uenapFR8q/izxcQfOr222+Xv7+/xo0bp5CQEAUHB2vevHlq1apVvvkuu+wyRUREyGLJGcw1KytL8fHxiomJ0TvvvKOOHTuqbt26evbZZ9W4cWMfvBIAACq2qxo2VlT16npiykQFBwWpwWWXafr4lxVpOTcos7+/v2pE5YwrSQ8JmCEzK0tPTJ6g3w8flCTN+3SJYn/ZrNfGPJdvUPVa1WvIEhamsNwzJAP8/RUZbtGSmC+0/Nuv1SG6jRrXa6BHBw1RZmaW4pMY8xVlx54CkqTWrVtr2bJlxc4TEBCgfz7/0kXvBnGx8QwAT7j11lt16623FjvP5MmTNXnyZNe/o6KiNG/ePG+XBgBApeHn56d7brlVo+5/sMh5ggIDNfvVqRddFz0kUH78q1TRzIlTLjrfmIce0ZiHHnH9u0qVKho7/FGNHf5ogXmtyckerRGVF5f+AQAAAAAAwAicUWUYm83mGjuntNLS0pTupev+rVarHA6nV9YNAAAAAAAgEVQZxWaz6ZNFS2RPTXVreafTqcDAQA9XlSPVZtPeXbvVuUWri88MAAAAAADgBoIqg9jtdtlTU9WqXiNZwi2lXt7pdCgwMMgLlUnxx49q169bleHM8Mr6AQAAAAAACKoMZAm3XHTA8sI4HA4FBXknqEpKSfHKegEAAAAAAPIQVAEwmt3hkNVq9XUZRQoODlZo7u16AQAAAABlQ1AFwFhp6enatnWrMjMzFRoS4utyChUcFqY+/fsRVgEAAACABxBUATCWw+mUnBlqVa+R6tSq7etyCkg5m6Jd8Ydkt9sJqgAAAADAAwiqABjPEhbm1rhtAAAAAICKpYqvCwAAAAAAAAAkgioAAAAAAAAYgqAKAAAAAAAARiCoAgAAAAAAgBEYTB0+k5iU5LF1JaWkyO5wKCklRSEhpbv7msPpUFBgkMdquVBZaisP7tbn7e1WLTLSa+sGAAAVV3E9pEl91/m9kkl15aGmkvezFXVb+aKftjscslqtHltfWlqa0tPTy7ye4OBg7tJdgRBUwWd6PnCvx9f5Vew6j6/TU0yuTTKvvk2frPB1CQCASspms8lut/u6DBer1SqHw+nrMoxRkh7StL4mj4l1UVPJmVhXcTWVdz+dlp6ubVu3KjMzU6EhIR5Zp9PpVGBgYJnXExwWpj79+xFWVRAEVQBQBu4cNfLUkaGL4cgRAJSezWbTJ4uWyJ6a6utSXFJtNu3dtVudW7TydSkAUCSH0yk5M9SqXiPVqVXbI+t0Oh0KLONVHClnU7Qr/pDsdju9cQVBUAUAbnL3qJGnjgxdDEeOAKD07Ha77KmpalWvkSzhFl+XI0mKP35Uu37dqgxnhq9LAYCLsoSFKSoiwiPrcjgcCgry3nAjMFOlC6pMO5X7fJzWDVQs7h418sSRoYvhyBGAisK03iyvH7OEWzz2Q6usklJSfF0CAADlplIFVSaeyn2+ynZa91dz5ntsXXHHjmnx559o0N33qG7tOqVa1tuDgpeltvLgbn3e3m4VSWmPGnFkCABymNibVbZ+rCIqroc0qe86v1cyqa481FTyfpZtBZSvShVUmXgq9/kq22ndnrwLRfLZswoOClKkxVLq9Xo7NChLbeXB3foIWwAAZWVib1bZ+rGKqLh+xaS+6/xeyaS68lBTyftZtlXF5+m7EXoC48kWrVIFVXlMOpX7fJzWDQAAKiOTejP6MQC4tHjjboSewHiyRfNKUFWWsQa8eTcsxoACUJmYeOQoD0eQgPJXmv6svO5OSm8GAPA2b9yNsKwYT7Z4Hg+qyjrWgDfvhsWYAwAqC1OPHLkEBKjn7b1LtWMurx/OktlBWmkPBpXndpPM3naVWWn7s/K6Oym9GQCgvHjyboTwLo8HVXljDTSIqunWjyNvNkYJp05ql8OhRGuSggKDvfIcZXE2NedU85TUVFmTk0u9vDfvJFbW2rytLPV5+w5sl+q2K48717Ht3HfGekZyZqhhVE3VqF7dq89VWmesVq1Y+61sKSml2k+U1w9nSfILDNQtt91qXOBis9n0zYqVyirFGSjlud0kTmM3VWn7s/L6uzGxNzNx31NYTeWxL7mYirKtfOX898ikuvJQU8k/R2yrkvFGTZ74rjNxW6Wc5TLz4vhlZ2dnS9IXX3yhFAOuyU9OTlYEKadb2HbuYbu5h+3mPrade9hu7mG7ua+obWexWHT77beXeD2m9Filwd+N+XiPzMd7ZD7eI/PxHpnP0++RxWI5F1SZYv78+br33nt9XUaFxLZzD9vNPWw397Ht3MN2cw/bzX2VedtV5tdeUfAemY/3yHy8R+bjPTKfN96jKh5dGwAAAAAAAOAm44Kq1q1b+7qECott5x62m3vYbu5j27mH7eYetpv7KvO2q8yvvaLgPTIf75H5eI/Mx3tkPm+8R8Zd+gcAAAAAAIDKybgzqgAAAAAAAFA5EVQBAAAAAADACARVAAAAAAAAMEKArwu4mNjYWO3cuVOSFBcXpwYNGmjEiBE+rqpiiI2N1Q8//KCUlBTFxcWpV69eGjBggK/LqjAWLlyow4cP6+mnn/Z1KUaJi4vTrFmz1KBBA0lSREQEf1clxN9U6fE95j72n54xbNgw/fe///V1GT7HZ7HiYF/jW/RJFQOfE7OxzzGft/tMo4OqnTt3Kjk5Od8L7tGjh+Li4jRp0iQfVma+vD+cvC/f5ORk9e3bVzt37mTbFSOvuZCklStXqn///j6uyCxxcXHq27evVq9erYiICEnS1KlTNWvWLH4AF4G/KffxPeY+9p+eMWvWLMXGxvq6DJ/js2g+9jVmoE8yG5+TioF9jvnKo880+tK/hQsXatq0afmmde3aVQsXLvRRRRXHggUL8v3hREREaMSIEVq4cKHi4uJ8WJnZGjRooEmTJmnSpEmuI2E4Z9asWerfv7+r+ZKkRx55pMDnFOfwN+U+vsfcx/6z7OLi4rR9+3Zfl2EEPovmY19jBvoks/E5qRjY55ivPPpMo4Oqrl27qmvXrr4uo0L66quvNHXq1HzTWrduLUkcHYbbVq5cqYYNG+ablteM8XcFT+N7zH3sP8suJiZGvXv39nUZRuCzCJQMfRJQduxzzFcefabRl/716tVLvXr1yjdt5cqVGjt2rI8qqjh69uxZYEcJlEVycrKSk5MLPQIVERGhnTt38sMYHsX3mPvYf5ZNTEyMevXq5Rp7obLjswhcHH0S4Bnsc8xXHn2m0UFVnpiYGG3fvl27du3SW2+9xZd8CcyYMaPAtB07dkgS2w9uKe5U28jISFmt1vIrBpUC32Nlx/6z9JKTk5WUlKQGDRoQVOXiswhcHH0S4BnscyoOb/aZRl/6l6dXr156+umnNWDAAE2bNo1rU900a9YsjR07lmuy4RUpKSm+LgGVAN9jpcP+s/QWLlzInYVKgM8iUDr0SYD72OeYyZt9ZoUIqvL06tVLXbp0Ud++fZWcnOzrciqU0aNHq2vXrtxxBG47f2DQCyUlJZVjJais+B5zH/vPkomNjeVobQnwWQQKok8CvIN9jvm80Wd6/dK/nTt36sUXXyzx/JMnT1Z0dHSRj3fr1k2zZ8/WwoULL/k/Vk9tu4ULFyoqKqrS3M7T039zyBEZGSlJhX75JCcny2KxlHdJqEQq2/eYN1Sm/ae7du7cecluG3oK89G/VGz0SYDnsc+pODzdZ3o9qIqOjtayZcvcWrZjx456+OGH873QvJ1AZbh8oSzbLk9MTIySk5PzfbiTk5OLPepT0Xliu6GgiIgIRUREFHlUsFu3buVcESqLyvg9VlaVff/pjrzbXp9/p6Fdu3ZJkqZOnaqoqKgKHWLRU5iP/qVio08CPIt9jrnKo880djD1vKMRF16HmvfCOYJ0cTt37lRSUlK+P6Dk5GTFxsYWGKUfKIlbb71Vhw8fzjct7zPJ5TLwBr7HSo/9p3sKG5dq4cKFio2N1dNPP+2DiszCZxG4OPokwDPY55irvPpMY4OqiIgI9e/fv8ALXbhwoaKjoxno9CLi4uL03nvvqXfv3oqJiXFNj42NZduVUHJyMgNfXmDEiBEaNmxYvh9tCxYs4HTcEuJvqnT4HnMP+0/PYTyvHHwWKxb2Nb5Dn1Rx8DkxF/scs5VXn+mXnZ2d7ZE1ecnChQu1c+dOWSwWxcXFqUGDBhzZLIGOHTsW2WDv2bOnnKupOJKTk/Xee+8pJSVFCxcuVEREhG699VY1aNCgQl/y4Uk7d+7UihUr1KZNG1dyzrYpGn9T7uN7rGzYf7ovLi5OCxYs0FdffaW4uDj17NlT3bp1q7QNMp9F87GvMQd9krn4nFQM7HMqBm/3mcYHVQAAAAAAAKgcqvi6AAAAAAAAAEAiqAIAAAAAAIAhCKoAAAAAAABgBIIqAAAAAAAAGOH/AX54fKhO6UaJAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(inference_results)\n", + "plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/appendix-mixture_model-npe.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2c655bcb-b39c-4fbb-916f-76c66cd836fd", + "metadata": {}, + "source": [ + "## FMPE" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "3c0d3765-a00c-46d7-816c-5dc13516bc58", + "metadata": {}, + "outputs": [], + "source": [ + "def make_model(dim):\n", + " @hk.transform\n", + " def _mlp(method, **kwargs):\n", + " def _nn(theta, time, context, **kwargs):\n", + " ins = jnp.concatenate([theta, time, context], axis=-1)\n", + " outs = hk.nets.MLP([64, 64, dim])(ins)\n", + " return outs\n", + "\n", + " ccnf = CCNF(dim, _nn)\n", + " return ccnf(method, **kwargs)\n", + "\n", + " return _mlp" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "ceafcf2c-3979-47b0-bfd3-d8c0abebef80", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|███████▌ | 54/1000 [00:11<03:22, 4.66it/s]\n" + ] + } + ], + "source": [ + "fns = prior_fn, simulator_fn\n", + "model = FMPE(fns, make_model(2))\n", + "\n", + "data, _ = model.simulate_data(\n", + " jr.PRNGKey(1), n_simulations=10000\n", + ")\n", + "params, info = model.fit(\n", + " jr.PRNGKey(2),\n", + " data=data,\n", + " optimizer=optax.adam(1e-3),\n", + " n_iter=1000,\n", + " n_early_stopping_patience=25\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "b836a10f-e3cc-4b9d-9c40-b20cce669cfd", + "metadata": {}, + "outputs": [], + "source": [ + "inference_results, _ = model.sample_posterior(jr.PRNGKey(3), params, y_observed)" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "id": "6abcfeae-1d21-47a7-817d-d3bc1a1cd57c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(inference_results)\n", + "plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/appendix-mixture_model-fmpe.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ab99cf4a-3f19-4d69-bc02-835ff553864b", + "metadata": {}, + "source": [ + "## NLE" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6e406376-e0d4-4c9c-a34b-9c7a74e92494", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 11%|███████████████ | 109/1000 [00:08<01:10, 12.60it/s]\n" + ] + } + ], + "source": [ + "fns = prior_fn, simulator_fn\n", + "model = NLE(fns, make_mdn(2, 10))\n", + "\n", + "data, _ = model.simulate_data(jr.PRNGKey(1))\n", + "params, info = model.fit(jr.PRNGKey(2), data=data, n_early_stopping_patience=25, optimizer=optax.adam(1e-3), n_iter=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8ef7b3d5-c880-4b82-aded-d89dd462f86d", + "metadata": {}, + "outputs": [], + "source": [ + "inference_results, _ = model.sample_posterior(jr.PRNGKey(3), params, y_observed)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8a005c71-cdc3-45e2-8ba0-a94c87d3c8c2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(inference_results)\n", + "plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/appendix-mixture_model-nle.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34aa5bd6-b39f-4b9e-8e33-aaa6f94eeb2e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sbi-dev", + "language": "python", + "name": "sbi-dev" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/example.ipynb b/docs/example.ipynb new file mode 100644 index 0000000..4678756 --- /dev/null +++ b/docs/example.ipynb @@ -0,0 +1,2316 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7c3f58b8-c517-4cc2-9812-35ca69c96750", + "metadata": {}, + "source": [ + "# Simulation-based inference with the Python package `sbijax`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d21decd1-bc48-4dd7-bc4c-1c0a686620da", + "metadata": {}, + "outputs": [], + "source": [ + "import arviz as az\n", + "import fybdthemes\n", + "import jax\n", + "import numpy as np\n", + "import optax\n", + "import sbijax\n", + "import seaborn as sns\n", + "import tueplots.bundles\n", + "import tueplots.axes\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from jax import numpy as jnp, random as jr\n", + "from jax._src.flatten_util import ravel_pytree\n", + "from matplotlib.ticker import AutoLocator, MaxNLocator\n", + "\n", + "from sbijax import NLE\n", + "from sbijax.nn import make_affine_maf\n", + "from tensorflow_probability.substrates.jax import distributions as tfd" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "506d8b25-79ef-41b2-a2c8-c54d94ede3dc", + "metadata": {}, + "outputs": [], + "source": [ + "from flax import linen as nn" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dc5ec40a-9bca-4ef3-9947-18dbdd80bdcb", + "metadata": {}, + "outputs": [], + "source": [ + "custom_params = {\n", + " 'font.family':'serif', \n", + " 'font.weight':'ultralight', \n", + " 'font.serif':'Computer Modern',\n", + " \"axes.labelweight\": \"light\",\n", + " \"mathtext.fontset\": \"stix\",\n", + " 'text.usetex': True,\n", + "}\n", + "sns.set_theme(style=\"ticks\", context='paper', rc=custom_params)\n", + "plt.rcParams.update(tueplots.bundles.icml2022())\n", + "plt.rcParams.update(tueplots.axes.lines(base_width=0.5))" + ] + }, + { + "cell_type": "markdown", + "id": "ab31daa3-17d0-420a-b3cd-139599708886", + "metadata": {}, + "source": [ + "## Example section 3" + ] + }, + { + "cell_type": "markdown", + "id": "0c55c2ec-575a-4ebd-bc03-de368c1b5aea", + "metadata": {}, + "source": [ + "### Model definition" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e27b7eb5-2bc6-4370-a5cf-19b4f10cd4f8", + "metadata": {}, + "outputs": [], + "source": [ + "def prior_fn():\n", + " prior = tfd.JointDistributionNamed(dict(\n", + " mean=tfd.Normal(jnp.zeros(2), 1.0),\n", + " scale=tfd.HalfNormal(jnp.ones(1)),\n", + " ))\n", + " return prior\n", + "\n", + "\n", + "def simulator_fn(seed: jr.PRNGKey, theta: dict[str, jax.Array]):\n", + " p = tfd.Normal(jnp.zeros_like(theta[\"mean\"]), 1.0)\n", + " y = theta[\"mean\"] + theta[\"scale\"] * p.sample(seed=seed)\n", + " return y" + ] + }, + { + "cell_type": "markdown", + "id": "db743ac5-0448-4051-830e-bdcc1534b1a1", + "metadata": {}, + "source": [ + "### Algorithm definition" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "388bb00d-4ecd-4e46-b10a-3cd7dac15711", + "metadata": {}, + "outputs": [], + "source": [ + "n_dim_data = 2\n", + "n_layers, hidden_sizes = 5, (64, 64)\n", + "neural_network = make_affine_maf(n_dim_data, n_layers, hidden_sizes)\n", + "fns = prior_fn, simulator_fn\n", + "model = SNL(fns, neural_network)" + ] + }, + { + "cell_type": "markdown", + "id": "864638ad-258e-4a65-a68e-f9ef5d105c36", + "metadata": {}, + "source": [ + "### Training and inference" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "699c5997-8f17-4165-8fd0-ef07a5cda4b2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 13%|██████████████████▍ | 133/1000 [00:38<04:08, 3.49it/s]\n" + ] + } + ], + "source": [ + "obs = jnp.array([-1.0, 1.0])\n", + "data, _ = model.simulate_data(jr.PRNGKey(0), n_simulations=10_000)\n", + "params, losses = model.fit(\n", + " jr.PRNGKey(1), data=data\n", + ")\n", + "# inference_results, diagnostics = model.sample_posterior(\n", + "# jr.PRNGKey(2), params, obs\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c8d96ad9-27a6-4186-bae5-8612f9860a2b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inference data with groups:\n", + "\t> posterior\n", + "\t> observed_data\n" + ] + } + ], + "source": [ + "print(inference_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d6a4a54e-38ce-4caa-9b44-ad0b233f7a5c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Size: 56kB\n", + "Dimensions: (chain: 4, draw: 1000, mean_dim: 2, scale_dim: 1)\n", + "Coordinates:\n", + " * chain (chain) int64 32B 0 1 2 3\n", + " * draw (draw) int64 8kB 0 1 2 3 4 5 6 7 ... 993 994 995 996 997 998 999\n", + " * mean_dim (mean_dim) int64 16B 0 1\n", + " * scale_dim (scale_dim) int64 8B 0\n", + "Data variables:\n", + " mean (chain, draw, mean_dim) float32 32kB -1.058 0.9226 ... 0.8237\n", + " scale (chain, draw, scale_dim) float32 16kB 0.1377 1.043 ... 0.2873\n", + "Attributes:\n", + " created_at: 2024-06-04T07:30:29.581578\n", + " arviz_version: 0.17.1\n" + ] + } + ], + "source": [ + "print(inference_results.posterior)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "f79a89e9-cc9a-4c90-b479-adecfe5a2873", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_losses(losses): \n", + " max_dim = 2\n", + " colors = sns.blend_palette([ \"#636363\", \"#b26679\"], n_colors=max_dim) \n", + " _, ax = plt.subplots(figsize=(6, 2.5), sharey=False, sharex=False)\n", + "\n", + " with az.style.context([\"arviz-white\"], after_reset=True):\n", + " plt.rcParams[\"font.family\"] = \"Times New Roman\"\n", + " plt.plot(losses[:, 0], label=\"Training loss\", color=\"black\", linestyle=(0, (3, 1, 1, 1)))\n", + " plt.plot(losses[:, 1], label=\"Validation loss\", color=\"dimgrey\", linestyle=(0, (5, 1)))\n", + " ax.spines[['right', 'top']].set_visible(False)\n", + " ax.spines.left.set_linewidth(.5)\n", + " ax.spines.bottom.set_linewidth(.5)\n", + " ax.yaxis.set_major_locator(AutoLocator())\n", + " ax.title.set_fontsize(15)\n", + " ax.yaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(width=0.5, length=2)\n", + " ax.yaxis.set_tick_params(width=0.5, length=2)\n", + " ax.grid(which='major', axis='both', alpha=0.5)\n", + " ax.legend()\n", + " plt.tight_layout()\n", + " plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/bivariate_model-loss-plot.pdf\")\n", + " plt.show()\n", + " \n", + "plot_losses(losses)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e3a2bb2e-2ad1-4406-b848-24909638b187", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot(inference_results):\n", + " var_sizes = inference_results.posterior.sizes\n", + " max_dim = np.max([v for k, v in dict(var_sizes).items() if k not in [\"chain\", \"draw\"]])\n", + " colors = sns.blend_palette([ \"#636363\", \"#b26679\"], n_colors=max_dim) \n", + " _, axes = plt.subplots(figsize=(10, 4.25), nrows=2, ncols=2, sharey=False, sharex=False)\n", + "\n", + " with az.style.context([\"arviz-white\"], after_reset=True):\n", + " plt.rcParams[\"font.family\"] = \"Times New Roman\"\n", + " axes = az.plot_trace(\n", + " inference_results, \n", + " compact_prop={\"color\": colors},\n", + " axes=axes\n", + " )\n", + " for ax in axes.flatten():\n", + " ax.spines[['right', 'top']].set_visible(False)\n", + " ax.spines.left.set_linewidth(.5)\n", + " ax.spines.bottom.set_linewidth(.5)\n", + " ax.yaxis.set_major_locator(AutoLocator())\n", + " ax.title.set_fontsize(15)\n", + " ax.yaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(width=0.5, length=2)\n", + " ax.yaxis.set_tick_params(width=0.5, length=2)\n", + " ax.grid(which='major', axis='both', alpha=0.5)\n", + " plt.tight_layout()\n", + " #plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/trace-plot.pdf\")\n", + " plt.show()\n", + " \n", + "plot(inference_results)" + ] + }, + { + "cell_type": "markdown", + "id": "de01c323-e4bf-435f-854c-da7101cbdde2", + "metadata": {}, + "source": [ + "### Model diagnostics" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "0b93f97a-0c91-47fe-a3d1-c4adaad0bce1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Size: 48B\n", + "Dimensions: (mean_dim: 2, scale_dim: 1)\n", + "Coordinates:\n", + " * mean_dim (mean_dim) int64 16B 0 1\n", + " * scale_dim (scale_dim) int64 8B 0\n", + "Data variables:\n", + " mean (mean_dim) float64 16B 1.004 1.002\n", + " scale (scale_dim) float64 8B 1.017\n" + ] + } + ], + "source": [ + "print(diagnostics.rhat)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "8d1ed66e-2335-4959-87ff-41469086c0e5", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'inference_results' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[27], line 29\u001b[0m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;66;03m#plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/rank-plot.pdf\")\u001b[39;00m\n\u001b[1;32m 27\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n\u001b[0;32m---> 29\u001b[0m plot_ranks(\u001b[43minference_results\u001b[49m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'inference_results' is not defined" + ] + } + ], + "source": [ + "def plot_ranks(inference_results):\n", + " colors = sns.cubehelix_palette(start=.5, rot=-.5,n_colors=4, hue=0.5, dark=0.5, as_cmap=False)\n", + " _, axes = plt.subplots(figsize=(10, 4), nrows=1, ncols=3)\n", + "\n", + " with az.style.context([\"arviz-doc\", \"arviz-viridish\"], after_reset=True):\n", + " plt.rcParams[\"font.family\"] = \"Times New Roman\"\n", + " ax = az.plot_rank(\n", + " inference_results,\n", + " ax=axes, \n", + " colors=colors, \n", + " )\n", + " for i, ax in enumerate(axes):\n", + " ax.spines[['right', 'top', 'left']].set_visible(False)\n", + " ax.spines.left.set_linewidth(.5)\n", + " ax.spines.bottom.set_linewidth(.5)\n", + " ax.yaxis.set_major_locator(AutoLocator())\n", + " ax.title.set_fontsize(15)\n", + " if i > 0:\n", + " ax.set_ylabel(None)\n", + " ax.yaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(width=0.5, length=2)\n", + " ax.yaxis.set_tick_params(width=0.5, length=2)\n", + " ax.grid(which='major', axis='both', alpha=0.5)\n", + " plt.tight_layout()\n", + " #plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/rank-plot.pdf\")\n", + " plt.show()\n", + "\n", + "plot_ranks(inference_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "94a7d149-a641-45f1-9fda-783575c9e411", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 56kB\n",
+       "Dimensions:    (chain: 4, draw: 1000, mean_dim: 2, scale_dim: 1)\n",
+       "Coordinates:\n",
+       "  * chain      (chain) int64 32B 0 1 2 3\n",
+       "  * draw       (draw) int64 8kB 0 1 2 3 4 5 6 7 ... 993 994 995 996 997 998 999\n",
+       "  * mean_dim   (mean_dim) int64 16B 0 1\n",
+       "  * scale_dim  (scale_dim) int64 8B 0\n",
+       "Data variables:\n",
+       "    mean       (chain, draw, mean_dim) float32 32kB -1.058 0.9226 ... 0.8237\n",
+       "    scale      (chain, draw, scale_dim) float32 16kB 0.1377 1.043 ... 0.2873\n",
+       "Attributes:\n",
+       "    created_at:     2024-06-04T07:30:29.581578\n",
+       "    arviz_version:  0.17.1
" + ], + "text/plain": [ + " Size: 56kB\n", + "Dimensions: (chain: 4, draw: 1000, mean_dim: 2, scale_dim: 1)\n", + "Coordinates:\n", + " * chain (chain) int64 32B 0 1 2 3\n", + " * draw (draw) int64 8kB 0 1 2 3 4 5 6 7 ... 993 994 995 996 997 998 999\n", + " * mean_dim (mean_dim) int64 16B 0 1\n", + " * scale_dim (scale_dim) int64 8B 0\n", + "Data variables:\n", + " mean (chain, draw, mean_dim) float32 32kB -1.058 0.9226 ... 0.8237\n", + " scale (chain, draw, scale_dim) float32 16kB 0.1377 1.043 ... 0.2873\n", + "Attributes:\n", + " created_at: 2024-06-04T07:30:29.581578\n", + " arviz_version: 0.17.1" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inference_results.posterior" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "15256a24-a8e8-40a9-b926-cc60fab1eebd", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_ess(inference_results):\n", + " _, axes = plt.subplots(figsize=(10, 3), nrows=1, ncols=3)\n", + "\n", + " colors = sns.cubehelix_palette(start=.5, rot=-.5, n_colors=2, hue=0.5, dark=0.5, as_cmap=False)\n", + "\n", + " with az.style.context([\"arviz-doc\", \"arviz-viridish\"], after_reset=True):\n", + " plt.rcParams[\"font.family\"] = \"Times New Roman\"\n", + " ax = az.plot_ess(\n", + " inference_results,\n", + " ax=axes, \n", + " color=\"#CAE0D8\",\n", + " extra_kwargs={\"color\": \"#6F839B\"},\n", + " kind=\"evolution\"\n", + " )\n", + " for i, ax in enumerate(axes):\n", + " ax.spines[['right', 'top', 'left']].set_visible(False)\n", + " ax.spines.left.set_linewidth(.5)\n", + " ax.spines.bottom.set_linewidth(.5)\n", + " ax.yaxis.set_major_locator(AutoLocator())\n", + " ax.title.set_fontsize(15)\n", + " if i > 0:\n", + " ax.set_ylabel(None)\n", + " if i < 2:\n", + " ax.get_legend().remove()\n", + " else:\n", + " legend = ax.get_legend()\n", + " ax.legend(bbox_to_anchor=(0.95, .7), frameon=False)\n", + " ax.yaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(width=0.5, length=2)\n", + " ax.yaxis.set_tick_params(width=0.5, length=2)\n", + " ax.grid(which='major', axis='both', alpha=0.5)\n", + " plt.tight_layout()\n", + " #plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/ess-plot.pdf\")\n", + " plt.show()\n", + "\n", + "#plot_ess(inference_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 242, + "id": "e438c786-3dea-4b35-9bc9-5ff450f740f1", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_stan_rhat_and_ess(inference_results, path=None):\n", + " rhats = az.rhat(inference_results)\n", + " rhats = np.concatenate([np.array(v) for k, v in rhats.data_vars.items()])\n", + " rhats = np.squeeze(rhats)\n", + " ress = az.ess(inference_results, relative=True)\n", + " ress = np.concatenate([np.array(v) for k, v in ress.data_vars.items()])\n", + " ress = np.squeeze(ress)\n", + " \n", + " _, axes = plt.subplots(figsize=(6, 1.5), ncols=2)\n", + " colors = sns.cubehelix_palette(start=.5, rot=-.5, n_colors=10, hue=0.5, dark=0.5, as_cmap=False)\n", + " \n", + " axes[0].plot(rhats, range(len(rhats)), marker=\"o\", linestyle='None', color=\"black\")\n", + " axes[0].hlines(range(len(rhats)), np.ones(len(rhats)), rhats, color=\"black\")\n", + " axes[0].axvline(1.05, color=\"darkgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[0].axvline(1.1, color=\"darkgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[0].axvline(1.0, color=\"black\", alpha=0.5) \n", + " if np.any(rhats < 1.0):\n", + " axes[0].set_xlim(0.95) \n", + " else:\n", + " axes[0].set_xlim(0.99)\n", + " if np.any(rhats >= 1.3):\n", + " axes[0].axvline(1.3, color=\"dimgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[0].set_xticks([1.0, 1.05, 1.1, 1.3])\n", + " else:\n", + " axes[0].set_xticks([1.0, 1.05, 1.1])\n", + " axes[0].set_yticklabels([])\n", + " axes[0].set_ylabel(rf\"$\\theta$\", fontsize=15) \n", + " axes[0].set_xlabel(r\"Split-$\\hat{R}$\") \n", + " \n", + " axes[1].plot(ress, range(len(ress)), marker=\"o\", linestyle='None', color=\"black\")\n", + " axes[1].hlines(range(len(ress)), np.zeros(len(ress)), ress, color=\"black\")\n", + " axes[1].axvline(0.0, color=\"black\", alpha=0.5)\n", + " axes[1].axvline(0.1, color=\"darkgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[1].axvline(0.5, color=\"darkgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[1].axvline(1.0, color=\"darkgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[1].set_xticks([0.0, 0.1, 0.5, 1.0])\n", + " axes[1].set_yticklabels([])\n", + " axes[1].set_xlabel(r\"Relative ESS\") \n", + " \n", + " for i, ax in enumerate(axes):\n", + " ax.spines[['right', 'top']].set_visible(False)\n", + " ax.spines.left.set_linewidth(.5)\n", + " ax.spines.bottom.set_linewidth(.5)\n", + " ax.title.set_fontsize(15)\n", + " if i > 0:\n", + " ax.set_ylabel(None)\n", + " ax.yaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(width=0.5, length=2)\n", + " ax.yaxis.set_tick_params(width=0.5, length=2)\n", + " ax.grid(which='major', axis='both', alpha=0.5)\n", + " if path is not None:\n", + " plt.savefig(path)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 245, + "id": "bf027886-5942-4626-92b9-1c6c0ddebd7b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_stan_rhat_and_ess(inference_results, \"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/rhat_ress-plot.pdf\")" + ] + }, + { + "cell_type": "markdown", + "id": "7bf7d7a4-a175-4e88-850a-fc17424555e0", + "metadata": {}, + "source": [ + "### Sequential inference" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "afc91302-d55e-4f91-a1a6-2fd1ddb14aed", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 12%|██████████████████████▌ | 120/1000 [00:26<03:17, 4.46it/s]\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Attempt to convert a value (None) with an unsupported type () to a Tensor.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[56], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m data, params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m, {}\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n_rounds): \n\u001b[0;32m----> 4\u001b[0m data, _ \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimulate_data_and_possibly_append\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mjr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfold_in\u001b[49m\u001b[43m(\u001b[49m\u001b[43mjr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mPRNGKey\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43mobservable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 8\u001b[0m \u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[43m \u001b[49m\u001b[43msampler\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmala\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 10\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m params, info \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mfit(jr\u001b[38;5;241m.\u001b[39mfold_in(jr\u001b[38;5;241m.\u001b[39mPRNGKey(\u001b[38;5;241m1\u001b[39m), i), data\u001b[38;5;241m=\u001b[39mdata)\n\u001b[1;32m 12\u001b[0m inference_results, diagnostics \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39msample_posterior(\n\u001b[1;32m 13\u001b[0m jr\u001b[38;5;241m.\u001b[39mPRNGKey(\u001b[38;5;241m2\u001b[39m), params, obs\n\u001b[1;32m 14\u001b[0m )\n", + "File \u001b[0;32m~/PROJECTS/2022-bistom/src/sbijax/sbijax/_src/snl.py:218\u001b[0m, in \u001b[0;36mSNL.simulate_data_and_possibly_append\u001b[0;34m(self, rng_key, params, observable, data, n_simulations, n_chains, n_samples, n_warmup, **kwargs)\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msimulate_data_and_possibly_append\u001b[39m(\n\u001b[1;32m 183\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 184\u001b[0m rng_key,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 192\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m 193\u001b[0m ):\n\u001b[1;32m 194\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Simulate data from the prior or posterior.\u001b[39;00m\n\u001b[1;32m 195\u001b[0m \n\u001b[1;32m 196\u001b[0m \u001b[38;5;124;03m Args:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 216\u001b[0m \u001b[38;5;124;03m returns a NamedTuple with two elements, y and theta\u001b[39;00m\n\u001b[1;32m 217\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 218\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimulate_data_and_possibly_append\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 219\u001b[0m \u001b[43m \u001b[49m\u001b[43mrng_key\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 220\u001b[0m \u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 221\u001b[0m \u001b[43m \u001b[49m\u001b[43mobservable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mobservable\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 222\u001b[0m \u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 223\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_simulations\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_simulations\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 224\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_chains\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_chains\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 225\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 226\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_warmup\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_warmup\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 227\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 228\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/PROJECTS/2022-bistom/src/sbijax/sbijax/_src/_sne_base.py:54\u001b[0m, in \u001b[0;36mSNE.simulate_data_and_possibly_append\u001b[0;34m(self, rng_key, params, observable, data, n_simulations, **kwargs)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Simulate data and paarameters from the prior or posterior and append.\u001b[39;00m\n\u001b[1;32m 41\u001b[0m \n\u001b[1;32m 42\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[38;5;124;03m returns a NamedTuple of two axis, y and theta\u001b[39;00m\n\u001b[1;32m 52\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 53\u001b[0m observable \u001b[38;5;241m=\u001b[39m jnp\u001b[38;5;241m.\u001b[39matleast_2d(observable)\n\u001b[0;32m---> 54\u001b[0m new_data, diagnostics \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimulate_data\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 55\u001b[0m \u001b[43m \u001b[49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 56\u001b[0m \u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 57\u001b[0m \u001b[43m \u001b[49m\u001b[43mobservable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mobservable\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 58\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_simulations\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_simulations\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 59\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 60\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 61\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 62\u001b[0m d_new \u001b[38;5;241m=\u001b[39m new_data\n", + "File \u001b[0;32m~/PROJECTS/2022-bistom/src/sbijax/sbijax/_src/_sne_base.py:156\u001b[0m, in \u001b[0;36mSNE.simulate_data\u001b[0;34m(self, rng_key, params, observable, n_simulations, **kwargs)\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Simulate data from the posterior or prior and append.\u001b[39;00m\n\u001b[1;32m 140\u001b[0m \n\u001b[1;32m 141\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[38;5;124;03m a NamedTuple of two axis, y and theta\u001b[39;00m\n\u001b[1;32m 153\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 154\u001b[0m theta_key, data_key \u001b[38;5;241m=\u001b[39m jr\u001b[38;5;241m.\u001b[39msplit(rng_key)\n\u001b[0;32m--> 156\u001b[0m new_thetas, diagnostics \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimulate_parameters\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 157\u001b[0m \u001b[43m \u001b[49m\u001b[43mtheta_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 158\u001b[0m \u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 159\u001b[0m \u001b[43m \u001b[49m\u001b[43mobservable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mobservable\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 160\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_simulations\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_simulations\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 161\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 162\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 164\u001b[0m new_obs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msimulate_observations(data_key, new_thetas)\n\u001b[1;32m 165\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m v \u001b[38;5;129;01min\u001b[39;00m new_thetas\u001b[38;5;241m.\u001b[39mvalues():\n", + "File \u001b[0;32m~/PROJECTS/2022-bistom/src/sbijax/sbijax/_src/_sne_base.py:118\u001b[0m, in \u001b[0;36mSNE.simulate_parameters\u001b[0;34m(self, rng_key, params, observable, n_simulations, **kwargs)\u001b[0m\n\u001b[1;32m 116\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mn_samples\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m kwargs:\n\u001b[1;32m 117\u001b[0m kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mn_samples\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m n_simulations\n\u001b[0;32m--> 118\u001b[0m new_thetas, diagnostics \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msample_posterior\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 119\u001b[0m \u001b[43m \u001b[49m\u001b[43mrng_key\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 120\u001b[0m \u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 121\u001b[0m \u001b[43m \u001b[49m\u001b[43mobservable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mjnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43matleast_2d\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobservable\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 122\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 123\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 124\u001b[0m perm_key, rng_key \u001b[38;5;241m=\u001b[39m jr\u001b[38;5;241m.\u001b[39msplit(rng_key)\n\u001b[1;32m 125\u001b[0m new_thetas \u001b[38;5;241m=\u001b[39m jr\u001b[38;5;241m.\u001b[39mpermutation(perm_key, new_thetas)\n", + "File \u001b[0;32m~/PROJECTS/2022-bistom/src/sbijax/sbijax/_src/snl.py:265\u001b[0m, in \u001b[0;36mSNL.sample_posterior\u001b[0;34m(self, rng_key, params, observable, n_chains, n_samples, n_warmup, **kwargs)\u001b[0m\n\u001b[1;32m 241\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Sample from the approximate posterior.\u001b[39;00m\n\u001b[1;32m 242\u001b[0m \n\u001b[1;32m 243\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 262\u001b[0m \u001b[38;5;124;03m (n_samples \\times p) and posterior diagnostics\u001b[39;00m\n\u001b[1;32m 263\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 264\u001b[0m observable \u001b[38;5;241m=\u001b[39m jnp\u001b[38;5;241m.\u001b[39matleast_2d(observable)\n\u001b[0;32m--> 265\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sample_posterior\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 266\u001b[0m \u001b[43m \u001b[49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 267\u001b[0m \u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 268\u001b[0m \u001b[43m \u001b[49m\u001b[43mobservable\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 269\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_chains\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_chains\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 270\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 271\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_warmup\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_warmup\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 272\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 273\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/PROJECTS/2022-bistom/src/sbijax/sbijax/_src/snl.py:315\u001b[0m, in \u001b[0;36mSNL._sample_posterior\u001b[0;34m(self, rng_key, params, observable, n_chains, n_samples, n_warmup, **kwargs)\u001b[0m\n\u001b[1;32m 312\u001b[0m sampler \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msampler\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnuts\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 314\u001b[0m sampling_fn \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(mcmc, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msample_with_\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m sampler)\n\u001b[0;32m--> 315\u001b[0m samples \u001b[38;5;241m=\u001b[39m \u001b[43msampling_fn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 316\u001b[0m \u001b[43m \u001b[49m\u001b[43mrng_key\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrng_key\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 317\u001b[0m \u001b[43m \u001b[49m\u001b[43mlp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlp__\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 318\u001b[0m \u001b[43m \u001b[49m\u001b[43mprior\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprior_sampler_fn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 319\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_chains\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_chains\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 320\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 321\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_warmup\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_warmup\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 322\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 323\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 324\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m v \u001b[38;5;129;01min\u001b[39;00m samples\u001b[38;5;241m.\u001b[39mvalues():\n\u001b[1;32m 325\u001b[0m chex\u001b[38;5;241m.\u001b[39massert_shape(v, [n_chains, n_samples \u001b[38;5;241m-\u001b[39m n_warmup, \u001b[38;5;28;01mNone\u001b[39;00m])\n", + "File \u001b[0;32m~/PROJECTS/2022-bistom/src/sbijax/sbijax/_src/mcmc/mala.py:37\u001b[0m, in \u001b[0;36msample_with_mala\u001b[0;34m(rng_key, lp, prior, n_chains, n_samples, n_warmup, **kwargs)\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m states\n\u001b[1;32m 36\u001b[0m init_key, rng_key \u001b[38;5;241m=\u001b[39m jr\u001b[38;5;241m.\u001b[39msplit(rng_key)\n\u001b[0;32m---> 37\u001b[0m initial_states, kernel \u001b[38;5;241m=\u001b[39m \u001b[43m_mala_init\u001b[49m\u001b[43m(\u001b[49m\u001b[43minit_key\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_chains\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprior\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlp\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 39\u001b[0m states \u001b[38;5;241m=\u001b[39m _inference_loop(init_key, kernel, initial_states, n_samples)\n\u001b[1;32m 40\u001b[0m _ \u001b[38;5;241m=\u001b[39m states\u001b[38;5;241m.\u001b[39mposition[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtheta\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mblock_until_ready()\n", + "File \u001b[0;32m~/PROJECTS/2022-bistom/src/sbijax/sbijax/_src/mcmc/mala.py:52\u001b[0m, in \u001b[0;36m_mala_init\u001b[0;34m(rng_key, n_chains, prior, lp)\u001b[0m\n\u001b[1;32m 50\u001b[0m kernel \u001b[38;5;241m=\u001b[39m bj\u001b[38;5;241m.\u001b[39mmala(lp, \u001b[38;5;241m1.0\u001b[39m)\n\u001b[1;32m 51\u001b[0m initial_positions \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtheta\u001b[39m\u001b[38;5;124m\"\u001b[39m: initial_positions}\n\u001b[0;32m---> 52\u001b[0m initial_state \u001b[38;5;241m=\u001b[39m \u001b[43mjax\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvmap\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkernel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minit\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43minitial_positions\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m initial_state, kernel\u001b[38;5;241m.\u001b[39mstep\n", + " \u001b[0;31m[... skipping hidden 3 frame]\u001b[0m\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/blackjax/mcmc/mala.py:183\u001b[0m, in \u001b[0;36mmala.__new__..init_fn\u001b[0;34m(position)\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minit_fn\u001b[39m(position: ArrayLikeTree):\n\u001b[0;32m--> 183\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mposition\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlogdensity_fn\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/blackjax/mcmc/mala.py:64\u001b[0m, in \u001b[0;36minit\u001b[0;34m(position, logdensity_fn)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minit\u001b[39m(position: ArrayLikeTree, logdensity_fn: Callable) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m MALAState:\n\u001b[1;32m 63\u001b[0m grad_fn \u001b[38;5;241m=\u001b[39m jax\u001b[38;5;241m.\u001b[39mvalue_and_grad(logdensity_fn)\n\u001b[0;32m---> 64\u001b[0m logdensity, logdensity_grad \u001b[38;5;241m=\u001b[39m \u001b[43mgrad_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mposition\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 65\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m MALAState(position, logdensity, logdensity_grad)\n", + " \u001b[0;31m[... skipping hidden 8 frame]\u001b[0m\n", + "File \u001b[0;32m~/PROJECTS/2022-bistom/src/sbijax/sbijax/_src/snl.py:309\u001b[0m, in \u001b[0;36mSNL._sample_posterior..lp__\u001b[0;34m(theta)\u001b[0m\n\u001b[1;32m 308\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mlp__\u001b[39m(theta):\n\u001b[0;32m--> 309\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_joint_logdensity_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtheta\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/PROJECTS/2022-bistom/src/sbijax/sbijax/_src/snl.py:296\u001b[0m, in \u001b[0;36mSNL._sample_posterior.._joint_logdensity_fn\u001b[0;34m(theta)\u001b[0m\n\u001b[1;32m 295\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_joint_logdensity_fn\u001b[39m(theta):\n\u001b[0;32m--> 296\u001b[0m lp_prior \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprior_log_density_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtheta\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 297\u001b[0m lp \u001b[38;5;241m=\u001b[39m _log_likelihood_fn(theta)\n\u001b[1;32m 298\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m jnp\u001b[38;5;241m.\u001b[39msum(lp) \u001b[38;5;241m+\u001b[39m jnp\u001b[38;5;241m.\u001b[39msum(lp_prior)\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/substrates/jax/distributions/joint_distribution.py:899\u001b[0m, in \u001b[0;36mJointDistribution.log_prob\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 890\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Log probability density/mass function.\u001b[39;00m\n\u001b[1;32m 891\u001b[0m \n\u001b[1;32m 892\u001b[0m \u001b[38;5;124;03m${calling_convention_description}\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 896\u001b[0m \u001b[38;5;124;03m values of type `self.dtype`.\u001b[39;00m\n\u001b[1;32m 897\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 898\u001b[0m name \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlog_prob\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m--> 899\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_log_prob\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_resolve_value\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/substrates/jax/distributions/distribution.py:1264\u001b[0m, in \u001b[0;36mDistribution._call_log_prob\u001b[0;34m(self, value, name, **kwargs)\u001b[0m\n\u001b[1;32m 1262\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Wrapper around _log_prob.\"\"\"\u001b[39;00m\n\u001b[1;32m 1263\u001b[0m value \u001b[38;5;241m=\u001b[39m nest_util\u001b[38;5;241m.\u001b[39mcast_structure(value, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdtype)\n\u001b[0;32m-> 1264\u001b[0m value \u001b[38;5;241m=\u001b[39m \u001b[43mnest_util\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconvert_to_nested_tensor\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1265\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mvalue\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype_hint\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1266\u001b[0m \u001b[43m \u001b[49m\u001b[43mallow_packing\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 1267\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_name_and_control_scope(name, value, kwargs):\n\u001b[1;32m 1268\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_log_prob\u001b[39m\u001b[38;5;124m'\u001b[39m):\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/substrates/jax/internal/nest_util.py:510\u001b[0m, in \u001b[0;36mconvert_to_nested_tensor\u001b[0;34m(value, dtype, dtype_hint, allow_packing, as_shape_tensor, convert_ref, name)\u001b[0m\n\u001b[1;32m 507\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mname_scope(name):\n\u001b[1;32m 508\u001b[0m convert_with_name \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m path, \u001b[38;5;241m*\u001b[39margs: convert_fn( \u001b[38;5;66;03m# pylint: disable=g-long-lambda\u001b[39;00m\n\u001b[1;32m 509\u001b[0m path, \u001b[38;5;241m*\u001b[39margs, name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(\u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28mstr\u001b[39m, path)))\n\u001b[0;32m--> 510\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mnest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmap_structure_with_tuple_paths_up_to\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 511\u001b[0m \u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconvert_with_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype_hint\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcheck_types\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 512\u001b[0m \u001b[38;5;66;03m# For structured calls without name, skip the scope and don't pass a\u001b[39;00m\n\u001b[1;32m 513\u001b[0m \u001b[38;5;66;03m# struct-path to convert-to-tensor.\u001b[39;00m\n\u001b[1;32m 514\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 515\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m nest\u001b[38;5;241m.\u001b[39mmap_structure_with_tuple_paths_up_to(\n\u001b[1;32m 516\u001b[0m dtype, convert_fn, value, dtype, dtype_hint, check_types\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/nest.py:353\u001b[0m, in \u001b[0;36mmap_structure_with_tuple_paths_up_to\u001b[0;34m(shallow_structure, func, expand_composites, *structures, **kwargs)\u001b[0m\n\u001b[1;32m 350\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m input_tree \u001b[38;5;129;01min\u001b[39;00m structures:\n\u001b[1;32m 351\u001b[0m assert_shallow_structure(\n\u001b[1;32m 352\u001b[0m shallow_structure, input_tree, check_types\u001b[38;5;241m=\u001b[39mcheck_types)\n\u001b[0;32m--> 353\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdm_tree\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmap_structure_with_path_up_to\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 354\u001b[0m \u001b[43m \u001b[49m\u001b[43mshallow_structure\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mstructures\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tree/__init__.py:778\u001b[0m, in \u001b[0;36mmap_structure_with_path_up_to\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m 776\u001b[0m results \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 777\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m path_and_values \u001b[38;5;129;01min\u001b[39;00m _multiyield_flat_up_to(shallow_structure, \u001b[38;5;241m*\u001b[39mstructures):\n\u001b[0;32m--> 778\u001b[0m results\u001b[38;5;241m.\u001b[39mappend(\u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpath_and_values\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 779\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m unflatten_as(shallow_structure, results)\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/substrates/jax/internal/nest_util.py:508\u001b[0m, in \u001b[0;36mconvert_to_nested_tensor..\u001b[0;34m(path, *args)\u001b[0m\n\u001b[1;32m 506\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 507\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mname_scope(name):\n\u001b[0;32m--> 508\u001b[0m convert_with_name \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m path, \u001b[38;5;241m*\u001b[39margs: \u001b[43mconvert_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# pylint: disable=g-long-lambda\u001b[39;49;00m\n\u001b[1;32m 509\u001b[0m \u001b[43m \u001b[49m\u001b[43mpath\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m.\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mmap\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mstr\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpath\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 510\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m nest\u001b[38;5;241m.\u001b[39mmap_structure_with_tuple_paths_up_to(\n\u001b[1;32m 511\u001b[0m dtype, convert_with_name, value, dtype, dtype_hint, check_types\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m 512\u001b[0m \u001b[38;5;66;03m# For structured calls without name, skip the scope and don't pass a\u001b[39;00m\n\u001b[1;32m 513\u001b[0m \u001b[38;5;66;03m# struct-path to convert-to-tensor.\u001b[39;00m\n\u001b[1;32m 514\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/substrates/jax/internal/nest_util.py:495\u001b[0m, in \u001b[0;36mconvert_to_nested_tensor..convert_fn\u001b[0;34m(path, value, dtype, dtype_hint, name)\u001b[0m\n\u001b[1;32m 493\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m value\n\u001b[1;32m 494\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m convert_ref:\n\u001b[0;32m--> 495\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconvert_to_tensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype_hint\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 496\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 497\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m tensor_util\u001b[38;5;241m.\u001b[39mconvert_nonref_to_tensor(\n\u001b[1;32m 498\u001b[0m value, dtype, dtype_hint, name\u001b[38;5;241m=\u001b[39mname)\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/_utils.py:62\u001b[0m, in \u001b[0;36mcopy_docstring..wrap\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m 59\u001b[0m \u001b[38;5;129m@wrapt\u001b[39m\u001b[38;5;241m.\u001b[39mdecorator\n\u001b[1;32m 60\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrap\u001b[39m(wrapped, instance, args, kwargs):\n\u001b[1;32m 61\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m instance, wrapped\n\u001b[0;32m---> 62\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mnew_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:167\u001b[0m, in \u001b[0;36m_convert_to_tensor\u001b[0;34m(value, dtype, dtype_hint, name)\u001b[0m\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[1;32m 166\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ret \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 167\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[43mconversion_func\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 168\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ret\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:231\u001b[0m, in \u001b[0;36m_default_convert_to_tensor\u001b[0;34m(value, dtype)\u001b[0m\n\u001b[1;32m 226\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(value[\u001b[38;5;241m0\u001b[39m], \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdtype\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m jax\u001b[38;5;241m.\u001b[39mdtypes\u001b[38;5;241m.\u001b[39missubdtype(\n\u001b[1;32m 227\u001b[0m value[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mdtype, jax\u001b[38;5;241m.\u001b[39mdtypes\u001b[38;5;241m.\u001b[39mprng_key\n\u001b[1;32m 228\u001b[0m ):\n\u001b[1;32m 229\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m np\u001b[38;5;241m.\u001b[39mstack(value, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[0;32m--> 231\u001b[0m inferred_dtype \u001b[38;5;241m=\u001b[39m \u001b[43m_infer_dtype\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfloat32\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 232\u001b[0m \u001b[38;5;66;03m# When a dtype is provided, we can go ahead and try converting to the dtype\u001b[39;00m\n\u001b[1;32m 233\u001b[0m \u001b[38;5;66;03m# and force overflow/underflow if an int64 is converted to an int32.\u001b[39;00m\n\u001b[1;32m 234\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m dtype \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:195\u001b[0m, in \u001b[0;36m_infer_dtype\u001b[0;34m(value, default_dtype)\u001b[0m\n\u001b[1;32m 193\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mIndexError\u001b[39;00m, \u001b[38;5;167;01mTypeError\u001b[39;00m):\n\u001b[1;32m 194\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m default_dtype\n\u001b[0;32m--> 195\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m((\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mAttempt to convert a value (\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m)\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 196\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m with an unsupported type (\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m) to a Tensor.\u001b[39m\u001b[38;5;124m'\u001b[39m)\u001b[38;5;241m.\u001b[39mformat(\n\u001b[1;32m 197\u001b[0m value, \u001b[38;5;28mtype\u001b[39m(value)))\n", + "\u001b[0;31mValueError\u001b[0m: Attempt to convert a value (None) with an unsupported type () to a Tensor." + ] + } + ], + "source": [ + "n_rounds = 5\n", + "data, params = None, {}\n", + "for i in range(n_rounds): \n", + " data, _ = model.simulate_data_and_possibly_append(\n", + " jr.fold_in(jr.PRNGKey(0), i),\n", + " params=params,\n", + " observable=obs,\n", + " data=data,\n", + " sampler=\"mala\",\n", + " )\n", + " params, info = model.fit(jr.fold_in(jr.PRNGKey(1), i), data=data)\n", + "inference_results, diagnostics = model.sample_posterior(\n", + " jr.PRNGKey(2), params, obs\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8cd09441-af8b-4d8b-9315-f391f79cc778", + "metadata": {}, + "source": [ + "## Examples" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d7ebe12f-4803-4fcf-a6b5-5a23f97dd716", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_posteriors(obj, save_path=None):\n", + " _, axes = plt.subplots(figsize=(12, 10), nrows=5, ncols=5)\n", + " with az.style.context([\"arviz-doc\"], after_reset=True):\n", + " for i in range(0, 5): \n", + " for j in range(0, 5):\n", + " ax = axes[i, j]\n", + " if i < j:\n", + " ax.axis('off')\n", + " else:\n", + " ax.hexbin(obj[..., j], obj[..., i], gridsize=50, bins='log', cmap='viridis') \n", + " ax.spines.left.set_linewidth(.5)\n", + " ax.spines.bottom.set_linewidth(.5)\n", + " ax.spines.right.set_linewidth(.5)\n", + " ax.spines.top.set_linewidth(.5) \n", + " ax.xaxis.set_major_locator(MaxNLocator(2))\n", + " ax.yaxis.set_major_locator(MaxNLocator(2))\n", + " ax.xaxis.set_tick_params(width=1, length=2, labelsize=25)\n", + " ax.yaxis.set_tick_params(width=1, length=2, labelsize=25)\n", + " if i < 4: \n", + " ax.set_xticklabels([])\n", + " ax.xaxis.set_tick_params(width=0., length=0)\n", + " if j != 0: \n", + " ax.set_yticklabels([])\n", + " ax.yaxis.set_tick_params(width=0., length=0)\n", + " ax.grid(which='major', axis='both', alpha=0.5)\n", + " for i in range(5):\n", + " axes[i, i].hist(obj[..., i], color=\"black\")\n", + " plt.tight_layout()\n", + " if save_path is not None:\n", + " plt.savefig(save_path)\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cfc52786-d0f4-4519-90da-f9693773db17", + "metadata": {}, + "outputs": [], + "source": [ + "def prior_fn():\n", + " prior = tfd.JointDistributionNamed(dict(\n", + " theta=tfd.Uniform(jnp.full(5, -3.0), jnp.full(5, 3.0))\n", + " ), batch_ndims=0)\n", + " return prior\n", + "\n", + "\n", + "def simulator_fn(seed, theta):\n", + " theta = theta[\"theta\"]\n", + " orig_shape = theta.shape\n", + " if theta.ndim == 2:\n", + " theta = theta[:, None, :]\n", + " us_key, noise_key = jr.split(seed)\n", + "\n", + " def _unpack_params(ps):\n", + " m0 = ps[..., [0]]\n", + " m1 = ps[..., [1]]\n", + " s0 = ps[..., [2]] ** 2\n", + " s1 = ps[..., [3]] ** 2\n", + " r = jnp.tanh(ps[..., [4]])\n", + " return m0, m1, s0, s1, r\n", + "\n", + " m0, m1, s0, s1, r = _unpack_params(theta)\n", + " us = tfd.Normal(0.0, 1.0).sample(\n", + " seed=us_key, sample_shape=(theta.shape[0], theta.shape[1], 4, 2)\n", + " )\n", + " xs = jnp.empty_like(us)\n", + " xs = xs.at[:, :, :, 0].set(s0 * us[:, :, :, 0] + m0)\n", + " y = xs.at[:, :, :, 1].set(\n", + " s1 * (r * us[:, :, :, 0] + jnp.sqrt(1.0 - r**2) * us[:, :, :, 1]) + m1\n", + " )\n", + " if len(orig_shape) == 2:\n", + " y = y.reshape((*theta.shape[:1], 8))\n", + " else:\n", + " y = y.reshape((*theta.shape[:2], 8))\n", + " return y" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "04c378bf-3c2b-47cc-882d-1f6faca745a5", + "metadata": {}, + "outputs": [], + "source": [ + "y_observed = jnp.array([[\n", + " -0.9707123,\n", + " -2.9461224,\n", + " -0.4494722,\n", + " -3.4231849,\n", + " -0.13285634,\n", + " -3.364017,\n", + " -0.85367596,\n", + " -2.4271638,\n", + "]])" + ] + }, + { + "cell_type": "markdown", + "id": "7b597b91-fb6a-4faa-a99f-f543f5b02e5a", + "metadata": {}, + "source": [ + "### MCMC" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "366d8d42-c36f-4ccc-a301-43b0ffdc7246", + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial\n", + "from jax import scipy as jsp\n", + "from sbijax.mcmc import sample_with_nuts, sample_with_slice" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "922f261d-47ba-4e53-9848-0f1b3d4b464f", + "metadata": {}, + "outputs": [], + "source": [ + "def likelihood_fn(theta, y):\n", + " mu = jnp.tile(theta[:2], 4)\n", + " s1, s2 = theta[2] ** 2, theta[3] ** 2\n", + " corr = s1 * s2 * jnp.tanh(theta[4])\n", + " cov = jnp.array([[s1**2, corr], [corr, s2**2]])\n", + " cov = jsp.linalg.block_diag(*[cov for _ in range(4)])\n", + " p = tfd.MultivariateNormalFullCovariance(mu, cov)\n", + " return p.log_prob(y)\n", + "\n", + "\n", + "def log_density_fn(theta, y):\n", + " prior_lp = tfd.JointDistributionNamed(dict(\n", + " theta=tfd.Uniform(jnp.full(5, -3.0), jnp.full(5, 3.0))\n", + " )).log_prob(theta)\n", + " likelihood_lp = likelihood_fn(theta, y)\n", + " lp = jnp.sum(prior_lp) + jnp.sum(likelihood_lp)\n", + " return lp" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "c1c50cb0-6b52-4e07-a47a-0daab810f802", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/jax/_src/numpy/array_methods.py:66: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype)\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/random_generators.py:149: UserWarning: Explicitly requested dtype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return jaxrand.normal(key=seed, shape=shape, dtype=dtype) * stddev + mean\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/random_generators.py:290: UserWarning: Explicitly requested dtype requested in zeros is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " minval = minval + np.zeros([1] * final_rank, dtype=dtype)\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/random_generators.py:291: UserWarning: Explicitly requested dtype requested in zeros is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " maxval = maxval + np.zeros([1] * final_rank, dtype=dtype)\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/random_generators.py:292: UserWarning: Explicitly requested dtype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return jaxrand.uniform(key=seed, shape=shape, dtype=dtype, minval=minval,\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/random_generators.py:149: UserWarning: Explicitly requested dtype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return jaxrand.normal(key=seed, shape=shape, dtype=dtype) * stddev + mean\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/random_generators.py:290: UserWarning: Explicitly requested dtype requested in zeros is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " minval = minval + np.zeros([1] * final_rank, dtype=dtype)\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/random_generators.py:291: UserWarning: Explicitly requested dtype requested in zeros is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " maxval = maxval + np.zeros([1] * final_rank, dtype=dtype)\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/random_generators.py:292: UserWarning: Explicitly requested dtype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return jaxrand.uniform(key=seed, shape=shape, dtype=dtype, minval=minval,\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/ops.py:339: UserWarning: Explicitly requested dtype requested in array is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return np.array(value, dtype=dtype)\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/random_generators.py:290: UserWarning: Explicitly requested dtype requested in zeros is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " minval = minval + np.zeros([1] * final_rank, dtype=dtype)\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/random_generators.py:291: UserWarning: Explicitly requested dtype requested in zeros is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " maxval = maxval + np.zeros([1] * final_rank, dtype=dtype)\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/random_generators.py:292: UserWarning: Explicitly requested dtype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return jaxrand.uniform(key=seed, shape=shape, dtype=dtype, minval=minval,\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/tensorflow_probability/python/internal/backend/jax/numpy_array.py:450: UserWarning: Explicitly requested dtype requested in ones is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lambda shape, dtype=np.float32, name=None, layout=None: np.ones( # pylint: disable=g-long-lambda\n", + "/Users/simon/miniconda3/envs/sbi-dev/lib/python3.9/site-packages/jax/_src/numpy/array_methods.py:66: UserWarning: Explicitly requested dtype int64 requested in astype is not available, and will be truncated to dtype int32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " return lax_numpy.astype(arr, dtype)\n" + ] + } + ], + "source": [ + "log_density = partial(log_density_fn, y=obs)\n", + "\n", + "def lp(theta):\n", + " return jax.vmap(log_density)(theta)\n", + "\n", + "slice_samples = sample_with_slice(\n", + " jr.PRNGKey(0),\n", + " lp,\n", + " prior_fn().sample,\n", + " n_chains=10, \n", + " n_samples=10_000, \n", + " n_warmup=5_000\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "1e6b00bb-c57b-4538-9d92-9770d7a42587", + "metadata": {}, + "outputs": [], + "source": [ + "slice_inference_data = sbijax._src.mcmc.util.as_inference_data({\"theta\": slice_samples.reshape(10, 5000, 5)}, obs)" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "id": "88e89d44-d6c1-436f-a8e7-04e9d943cf7e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "[[0.7984163628941724, 0.8724455799341356, 0.8792050282657944],\n", + " [0.7520617729419254, 0.8342884483168719, 0.8537813878463909],\n", + " [0.7091127369272029, 0.7942161194379309, 0.8293423334325812],\n", + " [0.6696142579567184, 0.7523687729661137, 0.8050132518744492],\n", + " [0.6334542285581309, 0.7089583341030783, 0.7799631952015313],\n", + " [0.6003734303188428, 0.6642578287850112, 0.7534347039778444],\n", + " [0.5699801441689186, 0.6185889714716917, 0.7247705359582128],\n", + " [0.5417688749339432, 0.5723083763848336, 0.6934365573435132],\n", + " [0.5151425872967144, 0.525792816587703, 0.6590401645076404],\n", + " [0.4919866284217426, 0.4840435270598958, 0.6252652985274559]]" + ] + }, + "execution_count": 206, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sns.cubehelix_palette(start=.75, rot=-.5, n_colors=10, hue=0.5, dark=0.5, as_cmap=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 222, + "id": "6ca4a042-9439-4ca5-a8ac-0bfcd0eb5a65", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_stan_rhat_and_ess(inference_results):\n", + " rhats = az.rhat(inference_results) \n", + " rhats = np.squeeze(np.array(rhats.to_dataarray()))\n", + " ress = az.ess(inference_results, relative=True)\n", + " ress = np.squeeze(np.array(ress.to_dataarray()))\n", + " \n", + " _, axes = plt.subplots(figsize=(6, 1.5), ncols=2)\n", + " colors = sns.cubehelix_palette(start=.5, rot=-.5, n_colors=10, hue=0.5, dark=0.5, as_cmap=False)\n", + " \n", + " axes[0].plot(rhats, range(len(rhats)), marker=\"o\", linestyle='None', color=\"black\")\n", + " axes[0].hlines(range(len(rhats)), np.ones(len(rhats)), rhats, color=\"black\")\n", + " axes[0].axvline(1.05, color=\"darkgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[0].axvline(1.1, color=\"darkgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[0].axvline(1.0, color=\"black\", alpha=0.5) \n", + " if np.any(rhats < 1.0):\n", + " axes[0].set_xlim(0.95) \n", + " else:\n", + " axes[0].set_xlim(0.99)\n", + " if np.any(rhats >= 1.3):\n", + " axes[0].axvline(1.3, color=\"dimgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[0].set_xticks([1.0, 1.05, 1.1, 1.3])\n", + " else:\n", + " axes[0].set_xticks([1.0, 1.05, 1.1])\n", + " axes[0].set_yticklabels([])\n", + " axes[0].set_ylabel(rf\"$\\theta$\", fontsize=15) \n", + " axes[0].set_xlabel(r\"Split-$\\hat{R}$\") \n", + " \n", + " axes[1].plot(ress, range(len(ress)), marker=\"o\", linestyle='None', color=\"black\")\n", + " axes[1].hlines(range(len(ress)), np.zeros(len(ress)), ress, color=\"black\")\n", + " axes[1].axvline(0.0, color=\"black\", alpha=0.5)\n", + " axes[1].axvline(0.1, color=\"darkgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[1].axvline(0.5, color=\"darkgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[1].axvline(1.0, color=\"darkgrey\", alpha=0.5, linestyle=\"dashed\")\n", + " axes[1].set_xticks([0.0, 0.1, 0.5, 1.0])\n", + " axes[1].set_yticklabels([])\n", + " axes[1].set_xlabel(r\"Relative ESS\") \n", + " \n", + " for i, ax in enumerate(axes):\n", + " ax.spines[['right', 'top']].set_visible(False)\n", + " ax.spines.left.set_linewidth(.5)\n", + " ax.spines.bottom.set_linewidth(.5)\n", + " ax.title.set_fontsize(15)\n", + " if i > 0:\n", + " ax.set_ylabel(None)\n", + " ax.yaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(labelsize='large')\n", + " ax.xaxis.set_tick_params(width=0.5, length=2)\n", + " ax.yaxis.set_tick_params(width=0.5, length=2)\n", + " ax.grid(which='major', axis='both', alpha=0.5)\n", + " plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/slcp-slice_rhat_ess.pdf\")\n", + " plt.show()\n", + "\n", + "plot_stan_rhat_and_ess(slice_inference_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "fe14e9c7-9102-4d7b-8d05-837410b5aa22", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 80B\n",
+       "Dimensions:    (theta_dim: 5)\n",
+       "Coordinates:\n",
+       "  * theta_dim  (theta_dim) int64 40B 0 1 2 3 4\n",
+       "Data variables:\n",
+       "    theta      (theta_dim) float64 40B 1.004 1.002 1.025 1.056 1.008
" + ], + "text/plain": [ + " Size: 80B\n", + "Dimensions: (theta_dim: 5)\n", + "Coordinates:\n", + " * theta_dim (theta_dim) int64 40B 0 1 2 3 4\n", + "Data variables:\n", + " theta (theta_dim) float64 40B 1.004 1.002 1.025 1.056 1.008" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 232, + "id": "0263b5aa-e346-46d8-9aae-e9310d5a9f2b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_ess_and_trace(inference_results):\n", + " _, axes = plt.subplots(figsize=(10, 8), nrows=5, ncols=3)\n", + "\n", + " with az.style.context([\"arviz-doc\", \"arviz-viridish\"], after_reset=True):\n", + " plt.rcParams[\"font.family\"] = \"Times New Roman\" \n", + " colors = sns.color_palette(\"ch:s=-.2,r=.6\", as_cmap=False, n_colors=10, desat=.8)\n", + " ax = az.plot_ess(\n", + " inference_results,\n", + " ax=[axes[i, 2] for i in range(5)], \n", + " color=\"#36454F\",\n", + " extra_kwargs={\"color\": list(colors[-5])},\n", + " kind=\"evolution\"\n", + " )\n", + " for ax in [axes[i, 2] for i in range(5)]:\n", + " ax.axline((0, 0), slope=1, color=\"black\", ls=\"--\")\n", + " colors = sns.color_palette(\"mako_r\", as_cmap=False, n_colors=10) \n", + " az.plot_rank(inference_results, ax=[axes[i, 1] for i in range(5)], kind='vlines', colors=colors, vlines_kwargs={\"alpha\":0.15}, marker_vlines_kwargs={\"linestyle\":'None', \"marker\": \"o\", \"ms\":3, \"alpha\": 0.75}) \n", + " for i in range(5):\n", + " for j in range(10):\n", + " axes[i, 0].plot(slice_samples.reshape(10, 5000, 5)[j, :, i], color=colors[j], alpha=0.15) \n", + " axes[i, 0].set_ylabel(rf\"$\\theta_{i}$\", fontsize=15) \n", + " axes[i, 1].set_ylabel(None)\n", + " axes[i, 2].set_ylabel(None) \n", + " for i, ax in enumerate(axes.flatten()):\n", + " ax.set_title(None)\n", + " ax.spines[['right', 'top']].set_visible(False) \n", + " ax.spines.left.set_linewidth(.5)\n", + " ax.spines.bottom.set_linewidth(.5)\n", + " ax.yaxis.set_major_locator(AutoLocator()) \n", + " ax.set_xlabel(None)\n", + " if i in [13, 14]:\n", + " ax.set_xlabel(\"Total number of draws\", fontsize=15)\n", + " if i == 12:\n", + " ax.set_xlabel(\"Number of draws per chain\", fontsize=15)\n", + " if ax.get_legend() is not None:\n", + " ax.get_legend().remove() \n", + " #ax.legend(bbox_to_anchor=(0.95, .7), frameon=False)\n", + " ax.yaxis.set_tick_params(labelsize=12)\n", + " ax.xaxis.set_tick_params(labelsize=12)\n", + " ax.xaxis.set_tick_params(width=0.5, length=2)\n", + " ax.yaxis.set_tick_params(width=0.5, length=2)\n", + " ax.grid(which='major', axis='both', alpha=0.5)\n", + " if i != [12,13,14]: \n", + " ax.set_xticklabels([])\n", + " if i in [2,5,8,11,14]:\n", + " ax.set_yticklabels([])\n", + " axes[4, 2].legend([\"Bulk ESS\", \"Tail ESS\"], fontsize=12)\n", + " plt.tight_layout()\n", + " plt.savefig(\"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/slcp-slice-tre-plot.pdf\")\n", + " plt.show()\n", + "#plot_ess(inference_results)\n", + "\n", + "plot_ess_and_trace(slice_inference_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8528eaf1-0509-478f-93e6-84636b001c39", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_posteriors(\n", + " slice_samples.reshape(-1, 5), \n", + " \"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/posterior_pair_plot-slice.pdf\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0adbe3c6-7262-4755-a489-ae1d0f01f0c2", + "metadata": {}, + "source": [ + "### NLE" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ec815cd3-b8b4-4ddb-a2c6-25e604d5b924", + "metadata": {}, + "outputs": [], + "source": [ + "n_dim_data = obs.shape[-1]\n", + "n_layers, hidden_sizes = 5, (64, 64)\n", + "neural_network = make_affine_maf(n_dim_data, n_layers, hidden_sizes)\n", + "fns = prior_fn, simulator_fn\n", + "snl = SNL(fns, neural_network)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0275509e-b6b9-418c-b1e1-1f02b062aa01", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 5%|██████▌ | 49/1000 [00:11<03:49, 4.15it/s]\n", + " 2%|███▎ | 25/1000 [00:07<05:00, 3.24it/s]\n", + " 2%|██▉ | 22/1000 [00:07<05:27, 2.99it/s]\n", + " 2%|██▍ | 18/1000 [00:06<05:46, 2.83it/s]\n", + " 52%|████████████████████████████████████████████████████████████████████▏ | 517/1000 [02:17<02:08, 3.76it/s]\n", + " 63%|██████████████████████████████████████████████████████████████████████████████████▋ | 626/1000 [02:41<01:36, 3.87it/s]\n", + " 65%|█████████████████████████████████████████████████████████████████████████████████████▊ | 650/1000 [02:50<01:31, 3.81it/s]\n", + " 6%|████████▋ | 65/1000 [00:18<04:28, 3.48it/s]\n", + " 52%|█████████████████████████████████████████████████████████████████████▏ | 524/1000 [02:27<02:14, 3.54it/s]\n", + " 37%|█████████████████████████████████████████████████▏ | 373/1000 [01:50<03:05, 3.38it/s]\n", + " 37%|████████████████████████████████████████████████▍ | 367/1000 [01:51<03:12, 3.29it/s]\n", + " 29%|██████████████████████████████████████▍ | 291/1000 [01:29<03:37, 3.26it/s]\n", + " 51%|███████████████████████████████████████████████████████████████████▊ | 514/1000 [02:46<02:37, 3.08it/s]\n", + " 25%|█████████████████████████████████▏ | 251/1000 [01:23<04:08, 3.01it/s]\n", + " 42%|███████████████████████████████████████████████████████▋ | 422/1000 [02:23<03:16, 2.94it/s]\n" + ] + } + ], + "source": [ + "data, snl_params = None, {}\n", + "for i in range(15):\n", + " data, _ = snl.simulate_data_and_possibly_append(\n", + " jr.fold_in(jr.PRNGKey(1), i),\n", + " params=snl_params,\n", + " observable=obs,\n", + " data=data\n", + " )\n", + " snl_params, info = snl.fit(\n", + " jr.fold_in(jr.PRNGKey(2), i), data=data\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "421d61db-8aab-4f87-b4ce-2d6b0f3c5efb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "snl_inference_results, diagnostics = snl.sample_posterior(\n", + " jr.PRNGKey(1), snl_params, obs, n_samples=10_000, n_warmup=5000, n_chains=5\n", + ")\n", + "plot_posteriors(\n", + " sbijax._src.mcmc.util.flatten(snl_inference_results.posterior)[\"theta\"],\n", + " \"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/posterior_pair_plot-snl.pdf\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "67a5ba72-f870-4b91-8cb3-3aaef3099824", + "metadata": {}, + "source": [ + "### CMPE" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "9682906c-bbeb-44c5-8b7d-96551402f6c1", + "metadata": {}, + "outputs": [], + "source": [ + "from sbijax import SCMPE\n", + "from sbijax.nn import make_consistency_model" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "c37f9b53-1b01-4e3e-8845-02ae404d594d", + "metadata": {}, + "outputs": [], + "source": [ + "n_dim_theta = 5\n", + "n_layers, hidden_size = 5, 64\n", + "neural_network = make_consistency_model(n_dim_theta, n_layers, hidden_size)\n", + "fns = prior_fn, simulator_fn\n", + "cmpe = SCMPE(fns, neural_network)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "5601519f-0dcd-4025-b0c4-65ae15233ccf", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|███▏ | 24/1000 [00:18<12:20, 1.32it/s]\n" + ] + } + ], + "source": [ + "data, cmpe_params = None, {}\n", + "for i in range(1):\n", + " data, _ = cmpe.simulate_data_and_possibly_append(\n", + " jr.fold_in(jr.PRNGKey(1), i),\n", + " params=cmpe_params,\n", + " observable=obs,\n", + " data=data, n_simulations=10000\n", + " )\n", + " cmpe_params, info = cmpe.fit(\n", + " jr.fold_in(jr.PRNGKey(2), i), data=data\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "5e9158e7-8557-4ca0-bd87-31cc15d303e5", + "metadata": {}, + "outputs": [], + "source": [ + "cmpe_inference_results, diagnostics = cmpe.sample_posterior(\n", + " jr.PRNGKey(1), cmpe_params, obs, n_samples=25_000\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "3aa2deac-f0d3-4152-a0c3-4fb4a1c93caf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_posteriors(\n", + " sbijax._src.mcmc.util.flatten(cmpe_inference_results.posterior)[\"theta\"],\n", + " \"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/posterior_pair_plot-cmpe.pdf\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "a9c2baad-481d-4fe2-8248-5c866ea56a8f", + "metadata": {}, + "source": [ + "### FMPE" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8b8d6659-7ef4-4917-8c59-5e0a8ff992db", + "metadata": {}, + "outputs": [], + "source": [ + "from sbijax import SFMPE\n", + "from sbijax.nn import make_ccnf, make_consistency_model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b441c9e4-9d4d-40a0-9d01-064881c8a6b0", + "metadata": {}, + "outputs": [], + "source": [ + "n_dim_theta = 5\n", + "n_layers, hidden_size = 5, 128\n", + "neural_network = make_ccnf(n_dim_theta, n_layers, hidden_size)\n", + "fns = prior_fn, simulator_fn\n", + "fmpe = SFMPE(fns, neural_network)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b1b1a2f7-ea59-49dc-be84-c685ecf1b00a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 12%|███████████████▊ | 120/1000 [02:13<16:15, 1.11s/it]\n" + ] + } + ], + "source": [ + "data, fmpe_params = None, {}\n", + "for i in range(1):\n", + " data, _ = fmpe.simulate_data_and_possibly_append(\n", + " jr.fold_in(jr.PRNGKey(1), i),\n", + " params=fmpe_params,\n", + " observable=obs,\n", + " data=data,\n", + " n_simulations=20_000,\n", + " )\n", + " fmpe_params, info = fmpe.fit(\n", + " jr.fold_in(jr.PRNGKey(2), i), data=data, optimizer=optax.adam(0.001), n_early_stopping_delta=0.00001, n_early_stopping_patience=30\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "179f5bd5-df33-4b4e-a6b0-3ddf98b616f0", + "metadata": {}, + "outputs": [], + "source": [ + "fmpe_inference_results, diagnostics = fmpe.sample_posterior(\n", + " jr.PRNGKey(1), fmpe_params, obs, n_samples=25_000\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c00de2f6-8f01-4b87-b78c-a2a392face35", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_posteriors(\n", + " sbijax._src.mcmc.util.flatten(fmpe_inference_results.posterior)[\"theta\"],\n", + " \"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/posterior_pair_plot-fmpe.pdf\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "727d4188-d8d4-47d5-94b6-50b844b93e58", + "metadata": {}, + "source": [ + "### SMC-ABC" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b22d4dd0-c7cc-4621-9514-3bfbdf63a494", + "metadata": {}, + "outputs": [], + "source": [ + "from sbijax import NASS, SMCABC, inference_data_as_dictionary\n", + "from sbijax.nn import make_nass_net" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b3da5789-f73b-4cd2-9955-fca63a7d8297", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|███████████████████████████ | 196/1000 [02:47<11:25, 1.17it/s]\n" + ] + } + ], + "source": [ + "fns = prior_fn, simulator_fn\n", + "model_nass = NASS(fns, make_nass_net([64, 64, 5], [64, 64, 1]))\n", + "\n", + "data, _ = model_nass.simulate_data(jr.PRNGKey(1), n_simulations=20_000)\n", + "params_nass, _ = model_nass.fit(jr.PRNGKey(2), data=data, n_early_stopping_patience=25)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0d727217-bfed-454c-9890-8881a9f1b56c", + "metadata": {}, + "outputs": [], + "source": [ + "def distance_fn(y_simulated, y_observed):\n", + " diff = y_simulated - y_observed\n", + " dist = jax.vmap(lambda el: jnp.linalg.norm(el))(diff)\n", + " return dist\n", + "\n", + "def summary_fn(y):\n", + " s = model_nass.summarize(params_nass, y)\n", + " return s\n", + "\n", + "model_smc = SMCABC(fns, summary_fn, distance_fn)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "881f8b72-0b6b-43ad-a4a6-66a70e32ea32", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10 [06:31<00:00, 39.14s/it]\n" + ] + } + ], + "source": [ + "smc_inference_results, _ = model_smc.sample_posterior(\n", + " jr.PRNGKey(3), y_observed, n_rounds=10, n_particles=5_000, eps_step=0.825, ess_min=2_000\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2ee05ae7-5b45-4fe9-891c-1b358e46f9ae", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_posteriors(\n", + " sbijax._src.mcmc.util.flatten(smc_inference_results.posterior)[\"theta\"],\n", + " \"/Users/simon/PROJECTS/2022-bistom/docs/manuscript/sbijax/figures/posterior_pair_plot-smc.pdf\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35c54f8c-d601-45c4-8cca-f664feca3337", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sbi-dev", + "language": "python", + "name": "sbi-dev" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/index.rst b/docs/index.rst index b25e991..4f87cdd 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -27,6 +27,38 @@ ⚠️ As per the LICENSE file, there is no warranty whatsoever for this free software tool. If you discover bugs, please report them. +Example +------- + +:code:`sbijax` uses an object-oriented API with functional elements stemming from JAX. You can, for instance, define +a neural likelihood estimation method and generate posterior samples like this: + +.. code-block:: python + + import distrax + import optax + from jax import numpy as jnp, random as jr + from sbijax import SNL + from sbijax.nn import make_affine_maf + + def prior_model_fns(): + p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) + return p.sample, p.log_prob + + def simulator_fn(seed, theta): + p = distrax.Normal(jnp.zeros_like(theta), 1.0) + y = theta + p.sample(seed=seed) + return y + + prior_simulator_fn, prior_logdensity_fn = prior_model_fns() + fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn + model = SNL(fns, make_affine_maf(2)) + + y_observed = jnp.array([-1.0, 1.0]) + data, _ = model.simulate_data(jr.PRNGKey(0), n_simulations=5) + params, _ = model.fit(jr.PRNGKey(1), data=data, optimizer=optax.adam(0.001)) + posterior, _ = model.sample_posterior(jr.PRNGKey(2), params, y_observed) + Installation ------------ @@ -60,13 +92,23 @@ In order to contribute: 4) test it by calling :code:`hatch run test` on the (Unix) command line, 5) submit a PR 🙂 +Citing sbijax +------------- + +.. code-block:: latex + + @article{dirmeier2024sbijax, + author = {Simon Dirmeier and Antonietta Mira and Carlo Albert}, + title = {Simulation-based inference with the Python Package sbijax}, + year = {2024}, + } + Acknowledgements ---------------- .. note:: - 📝 The API of the package is heavily inspired by the excellent Pytorch-based `sbi `_ package which is - substantially more feature-complete and user-friendly. + 📝 The API of the package is heavily inspired by the excellent Pytorch-based `sbi `_ package. License ------- @@ -78,12 +120,14 @@ License :hidden: 🏠 Home + 📰 News .. toctree:: :caption: 🎓 Examples :maxdepth: 1 :hidden: + Introduction Self-contained scripts .. toctree:: @@ -92,4 +136,6 @@ License :hidden: sbijax + sbijax.mcmc sbijax.nn + sbijax.util diff --git a/docs/introduction.ipynb b/docs/introduction.ipynb new file mode 100644 index 0000000..8f57d80 --- /dev/null +++ b/docs/introduction.ipynb @@ -0,0 +1,41 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8901d7f7-06d4-4fd2-ae00-5727de6e5cac", + "metadata": {}, + "source": [ + "# SLCP" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "043fea09-31a7-496f-8431-a541b016ec7e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sbi-dev", + "language": "python", + "name": "sbi-dev" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/bivariate_gaussian-sabc.py b/examples/bivariate_gaussian-sabc.py new file mode 100644 index 0000000..d988088 --- /dev/null +++ b/examples/bivariate_gaussian-sabc.py @@ -0,0 +1,42 @@ +""" +Example using sequential neural likelihood estimation on a bivariate Gaussian +""" + +import matplotlib.pyplot as plt +from jax import numpy as jnp +from jax import random as jr +from tensorflow_probability.substrates.jax import distributions as tfd + +from sbijax import NLE, plot_posterior +from sbijax.nn import make_mdn + + +def prior_fn(): + prior = tfd.JointDistributionNamed(dict( + mean=tfd.Normal(jnp.zeros(2), 1.0), + scale=tfd.HalfNormal(jnp.ones(1)), + ), batch_ndims=0) + return prior + + +def simulator_fn(seed, theta): + p = tfd.Normal(jnp.zeros_like(theta["mean"]), 1.0) + y = theta["mean"] + theta["scale"] * p.sample(seed=seed) + return y + + +def run(): + y_observed = jnp.array([-2.0, 1.0]) + fns = prior_fn, simulator_fn + model = NLE(fns, make_mdn(2, 10)) + + data, _ = model.simulate_data(jr.PRNGKey(11)) + params, info = model.fit(jr.PRNGKey(2), data=data, n_early_stopping_patience=25) + inference_result, _ = model.sample_posterior(jr.PRNGKey(3), params, y_observed) + + plot_posterior(inference_result) + plt.show() + + +if __name__ == "__main__": + run() diff --git a/examples/bivariate_gaussian-smcabc.py b/examples/bivariate_gaussian-smcabc.py new file mode 100644 index 0000000..eac60a7 --- /dev/null +++ b/examples/bivariate_gaussian-smcabc.py @@ -0,0 +1,56 @@ +"""Sequential Monte Carlo ABC example. + +Demonstrates sequential Monte Carlo ABC on a simple bivariate Gaussian example. +""" + + +import distrax +import jax +import matplotlib.pyplot as plt +import seaborn as sns +from jax import numpy as jnp +from jax import random as jr + +from sbijax import SMCABC, plot_trace, plot_posterior + +from tensorflow_probability.substrates.jax import distributions as tfd + + +def prior_fn(): + prior = tfd.JointDistributionNamed(dict( + theta=tfd.Normal(jnp.zeros(2), jnp.ones(2)) + ), batch_ndims=0) + return prior + + +def simulator_fn(seed, theta): + p = tfd.Normal(jnp.zeros_like(theta["theta"]), 0.1) + y = theta["theta"] + p.sample(seed=seed) + return y + + +def summary_fn(y): + return y + + +def distance_fn(y_simulated, y_observed): + diff = y_simulated - y_observed + dist = jax.vmap(lambda el: jnp.linalg.norm(el))(diff) + return dist + + +def run(): + y_observed = jnp.array([-2.0, 1.0]) + + fns = prior_fn, simulator_fn + + smc = SMCABC(fns, summary_fn, distance_fn) + smc_samples, _ = smc.sample_posterior( + jr.PRNGKey(1), y_observed, 10, 1000, 0.85, 500 + ) + plot_posterior(smc_samples) + plt.show() + + +if __name__ == "__main__": + run() diff --git a/examples/bivariate_gaussian_cfmpe.py b/examples/bivariate_gaussian_cfmpe.py deleted file mode 100644 index 01404e4..0000000 --- a/examples/bivariate_gaussian_cfmpe.py +++ /dev/null @@ -1,85 +0,0 @@ -""" -Example using consistency model posterior estimation on a bivariate Gaussian -""" - -import distrax -import haiku as hk -import matplotlib.pyplot as plt -import optax -import seaborn as sns -from jax import numpy as jnp -from jax import random as jr - -from sbijax import SCMPE -from sbijax.nn import ConsistencyModel - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.Normal(jnp.zeros_like(theta), 1.0) - y = theta + p.sample(seed=seed) - return y - - -def make_model(dim): - @hk.transform - def _mlp(method, **kwargs): - def _c_skip(time): - return 1 / ((time - 0.001) ** 2 + 1) - - def _c_out(time): - return 1.0 * (time - 0.001) / jnp.sqrt(1 + time**2) - - def _nn(theta, time, context, **kwargs): - ins = jnp.concatenate([theta, time, context], axis=-1) - outs = hk.nets.MLP([64, 64, dim])(ins) - out_skip = _c_skip(time) * theta + _c_out(time) * outs - return out_skip - - cm = ConsistencyModel(dim, _nn) - return cm(method, **kwargs) - - return _mlp - - -def run(): - y_observed = jnp.array([2.0, -2.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - estim = SCMPE(fns, make_model(2)) - optimizer = optax.adam(1e-3) - - data, params = None, {} - for i in range(2): - data, _ = estim.simulate_data_and_possibly_append( - jr.fold_in(jr.PRNGKey(1), i), - params=params, - observable=y_observed, - data=data, - ) - params, info = estim.fit( - jr.fold_in(jr.PRNGKey(2), i), - data=data, - optimizer=optimizer, - ) - - rng_key = jr.PRNGKey(23) - post_samples, _ = estim.sample_posterior(rng_key, params, y_observed) - print(post_samples) - fig, axes = plt.subplots(2) - for i, ax in enumerate(axes): - sns.histplot(post_samples[:, i], color="darkblue", ax=ax) - ax.set_xlim([-3.0, 3.0]) - sns.despine() - plt.tight_layout() - plt.show() - - -if __name__ == "__main__": - run() diff --git a/examples/bivariate_gaussian_sfmpe.py b/examples/bivariate_gaussian_sfmpe.py deleted file mode 100644 index bdd4f7b..0000000 --- a/examples/bivariate_gaussian_sfmpe.py +++ /dev/null @@ -1,77 +0,0 @@ -""" -Example using flow matching posterior estimation on a bivariate Gaussian -""" - -import distrax -import haiku as hk -import matplotlib.pyplot as plt -import optax -import seaborn as sns -from jax import numpy as jnp -from jax import random as jr - -from sbijax import SFMPE -from sbijax.nn import CCNF - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.Normal(jnp.zeros_like(theta), 1.0) - y = theta + p.sample(seed=seed) - return y - - -def make_model(dim): - @hk.transform - def _mlp(method, **kwargs): - def _nn(theta, time, context, **kwargs): - ins = jnp.concatenate([theta, time, context], axis=-1) - outs = hk.nets.MLP([64, 64, dim])(ins) - return outs - - ccnf = CCNF(dim, _nn) - return ccnf(method, **kwargs) - - return _mlp - - -def run(): - y_observed = jnp.array([2.0, -2.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - estim = SFMPE(fns, make_model(2)) - optimizer = optax.adam(1e-3) - - data, params = None, {} - for i in range(2): - data, _ = estim.simulate_data_and_possibly_append( - jr.fold_in(jr.PRNGKey(1), i), - params=params, - observable=y_observed, - data=data, - ) - params, info = estim.fit( - jr.fold_in(jr.PRNGKey(2), i), - data=data, - optimizer=optimizer, - ) - - rng_key = jr.PRNGKey(23) - post_samples, _ = estim.sample_posterior(rng_key, params, y_observed) - fig, axes = plt.subplots(2) - for i, ax in enumerate(axes): - sns.histplot(post_samples[:, i], color="darkblue", ax=ax) - ax.set_xlim([-3.0, 3.0]) - sns.despine() - plt.tight_layout() - plt.show() - - -if __name__ == "__main__": - run() diff --git a/examples/bivariate_gaussian_smcabc.py b/examples/bivariate_gaussian_smcabc.py deleted file mode 100644 index d90b575..0000000 --- a/examples/bivariate_gaussian_smcabc.py +++ /dev/null @@ -1,60 +0,0 @@ -""" -Example using sequential Monte Carlo ABC on a bivariate Gaussian -""" - -import distrax -import jax -import matplotlib.pyplot as plt -import seaborn as sns -from jax import numpy as jnp -from jax import random as jr - -from sbijax import SMCABC - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.Normal(jnp.zeros_like(theta), 0.1) - y = theta + p.sample(seed=seed) - return y - - -def summary_fn(y): - if y.ndim == 2: - y = y[None, ...] - sumr = jnp.mean(y, axis=1, keepdims=True) - return sumr - - -def distance_fn(y_simulated, y_observed): - diff = y_simulated - y_observed - dist = jax.vmap(lambda el: jnp.linalg.norm(el))(diff) - return dist - - -def run(): - y_observed = jnp.array([-2.0, 1.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - smc = SMCABC(fns, summary_fn, distance_fn) - smc_samples, _ = smc.sample_posterior( - jr.PRNGKey(22), y_observed, 10, 1000, 1000, 0.6, 500 - ) - - fig, axes = plt.subplots(2) - for i in range(2): - sns.histplot(smc_samples[:, i], color="darkblue", ax=axes[i]) - axes[i].set_title(rf"Approximated posterior $\theta_{i}$") - sns.despine() - plt.tight_layout() - plt.show() - - -if __name__ == "__main__": - run() diff --git a/examples/bivariate_gaussian_snl.py b/examples/bivariate_gaussian_snl.py deleted file mode 100644 index 68cca5d..0000000 --- a/examples/bivariate_gaussian_snl.py +++ /dev/null @@ -1,133 +0,0 @@ -""" -Example using sequential neural likelihood estimation on a bivariate Gaussian -""" - -from functools import partial - -import distrax -import haiku as hk -import jax -import matplotlib.pyplot as plt -import optax -import seaborn as sns -from jax import numpy as jnp -from jax import random as jr -from surjectors import ( - Chain, - MaskedAutoregressive, - Permutation, - TransformedDistribution, -) -from surjectors.nn import MADE -from surjectors.util import unstack - -from sbijax import SNL -from sbijax.mcmc import sample_with_nuts - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.Normal(jnp.zeros_like(theta), 1.0) - y = theta + p.sample(seed=seed) - return y - - -def log_density_fn(theta, y): - prior = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - likelihood = distrax.MultivariateNormalDiag(theta, jnp.ones_like(theta)) - - lp = jnp.sum(prior.log_prob(theta)) + jnp.sum(likelihood.log_prob(y)) - return lp - - -def make_model(dim): - def _bijector_fn(params): - means, log_scales = unstack(params, -1) - return distrax.ScalarAffine(means, jnp.exp(log_scales)) - - def _flow(method, **kwargs): - layers = [] - order = jnp.arange(dim) - for i in range(5): - layer = MaskedAutoregressive( - bijector_fn=_bijector_fn, - conditioner=MADE( - dim, - [50, dim * 2], - 2, - w_init=hk.initializers.TruncatedNormal(0.001), - b_init=jnp.zeros, - activation=jax.nn.tanh, - ), - ) - order = order[::-1] - layers.append(layer) - layers.append(Permutation(order, 1)) - chain = Chain(layers) - - base_distribution = distrax.Independent( - distrax.Normal(jnp.zeros(dim), jnp.ones(dim)), - 1, - ) - td = TransformedDistribution(base_distribution, chain) - return td(method, **kwargs) - - td = hk.transform(_flow) - td = hk.without_apply_rng(td) - return td - - -def run(): - y_observed = jnp.array([-2.0, 1.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - snl = SNL(fns, make_model(2)) - optimizer = optax.adam(1e-3) - - data, params = None, {} - for i in range(2): - data, _ = snl.simulate_data_and_possibly_append( - jr.fold_in(jr.PRNGKey(12), i), - params=params, - observable=y_observed, - data=data, - sampler="imh", - ) - params, info = snl.fit( - jr.fold_in(jr.PRNGKey(23), i), data=data, optimizer=optimizer - ) - - sample_key, rng_key = jr.split(jr.PRNGKey(123)) - log_density_partial = partial(log_density_fn, y=y_observed) - log_density = lambda x: log_density_partial(**x) - slice_samples = sample_with_nuts( - sample_key, log_density, prior_simulator_fn - ) - slice_samples = slice_samples.reshape(-1, 2) - - sample_key, rng_key = jr.split(rng_key) - snl_samples, _ = snl.sample_posterior(sample_key, params, y_observed) - - fig, axes = plt.subplots(2, 2) - for i in range(2): - sns.histplot( - slice_samples[:, i], color="darkgrey", ax=axes.flatten()[i] - ) - sns.histplot( - snl_samples[:, i], color="darkblue", ax=axes.flatten()[i + 2] - ) - axes.flatten()[i].set_title(rf"Sampled posterior $\theta_{i}$") - axes.flatten()[i + 2].set_title(rf"Approximated posterior $\theta_{i}$") - sns.despine() - plt.tight_layout() - plt.show() - - -if __name__ == "__main__": - run() diff --git a/examples/bivariate_gaussian_snp.py b/examples/bivariate_gaussian_snp.py deleted file mode 100644 index 2ff6338..0000000 --- a/examples/bivariate_gaussian_snp.py +++ /dev/null @@ -1,107 +0,0 @@ -""" -Example using sequential neural posterior estimation on a bivariate Gaussian -""" - -import distrax -import haiku as hk -import jax.nn -import matplotlib.pyplot as plt -import optax -import seaborn as sns -from jax import numpy as jnp -from jax import random as jr -from surjectors import ( - Chain, - MaskedAutoregressive, - Permutation, - TransformedDistribution, -) -from surjectors.nn import MADE -from surjectors.util import unstack - -from sbijax import SNP - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.Normal(jnp.zeros_like(theta), 1.0) - y = theta + p.sample(seed=seed) - return y - - -def make_model(dim): - def _bijector_fn(params): - means, log_scales = unstack(params, -1) - return distrax.ScalarAffine(means, jnp.exp(log_scales)) - - def _flow(method, **kwargs): - layers = [] - order = jnp.arange(dim) - for i in range(5): - layer = MaskedAutoregressive( - bijector_fn=_bijector_fn, - conditioner=MADE( - dim, - [50, dim * 2], - 2, - w_init=hk.initializers.TruncatedNormal(0.001), - b_init=jnp.zeros, - activation=jax.nn.tanh, - ), - ) - order = order[::-1] - layers.append(layer) - layers.append(Permutation(order, 1)) - chain = Chain(layers) - - base_distribution = distrax.Independent( - distrax.Normal(jnp.zeros(dim), jnp.ones(dim)), - 1, - ) - td = TransformedDistribution(base_distribution, chain) - return td(method, **kwargs) - - td = hk.transform(_flow) - return td - - -def run(): - y_observed = jnp.array([-2.0, 1.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - snp = SNP(fns, make_model(2)) - optimizer = optax.adam(1e-3) - - data, params = None, {} - for i in range(2): - data, _ = snp.simulate_data_and_possibly_append( - jr.fold_in(jr.PRNGKey(1), i), - params=params, - observable=y_observed, - data=data, - ) - params, info = snp.fit( - jr.fold_in(jr.PRNGKey(2), i), - data=data, - optimizer=optimizer, - ) - - rng_key = jr.PRNGKey(23) - snp_samples, _ = snp.sample_posterior(rng_key, params, y_observed) - fig, axes = plt.subplots(2) - for i, ax in enumerate(axes): - sns.histplot(snp_samples[:, i], color="darkblue", ax=ax) - ax.set_xlim([-3.0, 3.0]) - sns.despine() - plt.tight_layout() - plt.show() - - -if __name__ == "__main__": - run() diff --git a/examples/bivariate_gaussian_snr.py b/examples/bivariate_gaussian_snr.py deleted file mode 100644 index 897152f..0000000 --- a/examples/bivariate_gaussian_snr.py +++ /dev/null @@ -1,71 +0,0 @@ -""" -Example using sequential neural ratio estimation on a bivariate Gaussian -""" - -import distrax -import haiku as hk -import matplotlib.pyplot as plt -import optax -import seaborn as sns -from jax import numpy as jnp -from jax import random as jr - -from sbijax import SNR - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.Normal(jnp.zeros_like(theta), 1.0) - y = theta + p.sample(seed=seed) - return y - - -def make_model(): - @hk.without_apply_rng - @hk.transform - def _mlp(inputs, **kwargs): - return hk.nets.MLP([64, 64, 1])(inputs) - - return _mlp - - -def run(): - y_observed = jnp.array([2.0, -2.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - snr = SNR(fns, make_model()) - optimizer = optax.adam(1e-3) - - data, params = None, {} - for i in range(2): - data, _ = snr.simulate_data_and_possibly_append( - jr.fold_in(jr.PRNGKey(1), i), - params=params, - observable=y_observed, - data=data, - ) - params, info = snr.fit( - jr.fold_in(jr.PRNGKey(2), i), - data=data, - optimizer=optimizer, - ) - - rng_key = jr.PRNGKey(23) - snr_samples, _ = snr.sample_posterior(rng_key, params, y_observed) - fig, axes = plt.subplots(2) - for i, ax in enumerate(axes): - sns.histplot(snr_samples[:, i], color="darkblue", ax=ax) - ax.set_xlim([-3.0, 3.0]) - sns.despine() - plt.tight_layout() - plt.show() - - -if __name__ == "__main__": - run() diff --git a/examples/mixture_model-cmpe.py b/examples/mixture_model-cmpe.py new file mode 100644 index 0000000..e69de29 diff --git a/examples/mixture_model-nle.py b/examples/mixture_model-nle.py new file mode 100644 index 0000000..0fb1a6d --- /dev/null +++ b/examples/mixture_model-nle.py @@ -0,0 +1,41 @@ +import matplotlib.pyplot as plt +from jax import numpy as jnp +from jax import random as jr +from tensorflow_probability.substrates.jax import distributions as tfd + +from sbijax import NLE, plot_posterior +from sbijax.nn import make_mdn + + +def prior_fn(): + prior = tfd.JointDistributionNamed(dict( + theta=tfd.Normal(jnp.zeros(2), 1) + ), batch_ndims=0) + return prior + + +def simulator_fn(seed, theta): + mean = theta["theta"].reshape(-1, 2) + n = mean.shape[0] + data_key, cat_key = jr.split(seed) + categories = tfd.Categorical(logits=jnp.zeros(2)).sample(seed=cat_key, sample_shape=(n,)) + scales = jnp.array([1.0, 0.1])[categories].reshape(-1, 1) + y = tfd.Normal(mean, scales).sample(seed=data_key) + return y + + +def run(): + y_observed = jnp.array([-2.0, 1.0]) + fns = prior_fn, simulator_fn + model = NLE(fns, make_mdn(2, 10)) + + data, _ = model.simulate_data(jr.PRNGKey(11)) + params, info = model.fit(jr.PRNGKey(2), data=data, n_early_stopping_patience=25) + inference_result, _ = model.sample_posterior(jr.PRNGKey(3), params, y_observed) + + plot_posterior(inference_result) + plt.show() + + +if __name__ == "__main__": + run() diff --git a/examples/mixture_model-npe.py b/examples/mixture_model-npe.py new file mode 100644 index 0000000..e69de29 diff --git a/examples/mixture_model-nre.py b/examples/mixture_model-nre.py new file mode 100644 index 0000000..e69de29 diff --git a/examples/slcp-fmpe.py b/examples/slcp-fmpe.py new file mode 100644 index 0000000..e69de29 diff --git a/examples/slcp-nass_nle.py b/examples/slcp-nass_nle.py new file mode 100644 index 0000000..4c02b94 --- /dev/null +++ b/examples/slcp-nass_nle.py @@ -0,0 +1,107 @@ +"""NASS+NLE example. + +Demonstrates neural approximate sufficient statistics with sequential +neural likelihood estimation on the simple likelihood complex posterior model. +""" + + +import distrax +import jax +from jax import numpy as jnp +from jax import random as jr +from matplotlib import pyplot as plt +from tensorflow_probability.substrates.jax import distributions as tfd + +from sbijax import NASS, inference_data_as_dictionary, NLE +from sbijax.nn import make_nass_net, make_maf + + +def prior_fn(): + prior = tfd.JointDistributionNamed(dict( + theta=tfd.Uniform(jnp.full(5, -3.0), jnp.full(5, 3.0)) + ), batch_ndims=0) + return prior + + +def simulator_fn(seed, theta): + theta = theta["theta"] + orig_shape = theta.shape + if theta.ndim == 2: + theta = theta[:, None, :] + us_key, noise_key = jr.split(seed) + + def _unpack_params(ps): + m0 = ps[..., [0]] + m1 = ps[..., [1]] + s0 = ps[..., [2]] ** 2 + s1 = ps[..., [3]] ** 2 + r = jnp.tanh(ps[..., [4]]) + return m0, m1, s0, s1, r + + m0, m1, s0, s1, r = _unpack_params(theta) + us = distrax.Normal(0.0, 1.0).sample( + seed=us_key, sample_shape=(theta.shape[0], theta.shape[1], 4, 2) + ) + xs = jnp.empty_like(us) + xs = xs.at[:, :, :, 0].set(s0 * us[:, :, :, 0] + m0) + y = xs.at[:, :, :, 1].set( + s1 * (r * us[:, :, :, 0] + jnp.sqrt(1.0 - r**2) * us[:, :, :, 1]) + m1 + ) + if len(orig_shape) == 2: + y = y.reshape((*theta.shape[:1], 8)) + else: + y = y.reshape((*theta.shape[:2], 8)) + return y + + + + +def run(): + y_observed = jnp.array([[ + -0.9707123, + -2.9461224, + -0.4494722, + -3.4231849, + -0.13285634, + -3.364017, + -0.85367596, + -2.4271638, + ]]) + fns = prior_fn, simulator_fn + model_nass = NASS(fns, make_nass_net([64, 64, 5], [64, 64, 1])) + model_nle = NLE(fns, make_maf(5)) + + data, params_nle, params_nass = None, {}, {} + for i in range(5): + simulate_key, nass_key, nle_key = jr.split(jr.fold_in(jr.PRNGKey(1), i), 3) + s_observed = model_nass.summarize(params_nass, y_observed) + data, _ = model_nle.simulate_data_and_possibly_append( + simulate_key, + params=params_nle, + observable=s_observed, + data=data, + ) + params_nass, _ = model_nass.fit(nass_key, data=data) + summaries = model_nass.summarize(params_nass, data) + params_nle, _ = model_nle.fit(nle_key, data=summaries) + + s_observed = model_nass.summarize(params_nass, y_observed) + inference_results, _ = model_nle.sample_posterior(jr.PRNGKey(3), params_nle, s_observed) + + samples = inference_data_as_dictionary(inference_results.posterior)["theta"] + _, axes = plt.subplots(figsize=(12, 10), nrows=5, ncols=5) + for i in range(0, 5): + for j in range(0, 5): + ax = axes[i, j] + if i < j: + ax.axis('off') + else: + ax.hexbin(samples[..., j], samples[..., i], gridsize=50, bins='log') + for i in range(5): + axes[i, i].hist(samples[..., i], color="black") + plt.show() + + + +if __name__ == "__main__": + run() diff --git a/examples/slcp-nass_smcabc.py b/examples/slcp-nass_smcabc.py new file mode 100644 index 0000000..6a71154 --- /dev/null +++ b/examples/slcp-nass_smcabc.py @@ -0,0 +1,105 @@ +"""NASS+SMCABC example. + +Demonstrates neural approximate sufficient statistics with SMCABC on the +simple likelihood complex posterior model. +""" + + +import distrax +import jax +from jax import numpy as jnp +from jax import random as jr +from matplotlib import pyplot as plt +from tensorflow_probability.substrates.jax import distributions as tfd + +from sbijax import NASS, SMCABC, inference_data_as_dictionary +from sbijax.nn import make_nass_net + + +def prior_fn(): + prior = tfd.JointDistributionNamed(dict( + theta=tfd.Uniform(jnp.full(5, -3.0), jnp.full(5, 3.0)) + ), batch_ndims=0) + return prior + + +def simulator_fn(seed, theta): + theta = theta["theta"] + orig_shape = theta.shape + if theta.ndim == 2: + theta = theta[:, None, :] + us_key, noise_key = jr.split(seed) + + def _unpack_params(ps): + m0 = ps[..., [0]] + m1 = ps[..., [1]] + s0 = ps[..., [2]] ** 2 + s1 = ps[..., [3]] ** 2 + r = jnp.tanh(ps[..., [4]]) + return m0, m1, s0, s1, r + + m0, m1, s0, s1, r = _unpack_params(theta) + us = distrax.Normal(0.0, 1.0).sample( + seed=us_key, sample_shape=(theta.shape[0], theta.shape[1], 4, 2) + ) + xs = jnp.empty_like(us) + xs = xs.at[:, :, :, 0].set(s0 * us[:, :, :, 0] + m0) + y = xs.at[:, :, :, 1].set( + s1 * (r * us[:, :, :, 0] + jnp.sqrt(1.0 - r**2) * us[:, :, :, 1]) + m1 + ) + if len(orig_shape) == 2: + y = y.reshape((*theta.shape[:1], 8)) + else: + y = y.reshape((*theta.shape[:2], 8)) + return y + + +def distance_fn(y_simulated, y_observed): + diff = y_simulated - y_observed + dist = jax.vmap(lambda el: jnp.linalg.norm(el))(diff) + return dist + + +def run(): + y_observed = jnp.array([[ + -0.9707123, + -2.9461224, + -0.4494722, + -3.4231849, + -0.13285634, + -3.364017, + -0.85367596, + -2.4271638, + ]]) + fns = prior_fn, simulator_fn + model_nass = NASS(fns, make_nass_net([64, 64, 5], [64, 64, 1])) + + data, _ = model_nass.simulate_data(jr.PRNGKey(1), n_simulations=20_000) + params_nass, _ = model_nass.fit(jr.PRNGKey(2), data=data, n_early_stopping_patience=25) + + def summary_fn(y): + s = model_nass.summarize(params_nass, y) + return s + + model_smc = SMCABC(fns, summary_fn, distance_fn) + inference_results, _ = model_smc.sample_posterior( + jr.PRNGKey(3), y_observed, n_rounds=10, n_particles=5_000, eps_step=0.825, ess_min=2_000 + ) + + samples = inference_data_as_dictionary(inference_results.posterior)["theta"] + _, axes = plt.subplots(figsize=(12, 10), nrows=5, ncols=5) + for i in range(0, 5): + for j in range(0, 5): + ax = axes[i, j] + if i < j: + ax.axis('off') + else: + ax.hexbin(samples[..., j], samples[..., i], gridsize=50, bins='log') + for i in range(5): + axes[i, i].hist(samples[..., i], color="black") + plt.show() + + + +if __name__ == "__main__": + run() diff --git a/examples/slcp_ssnl.py b/examples/slcp-snle.py similarity index 99% rename from examples/slcp_ssnl.py rename to examples/slcp-snle.py index 74db420..38c703a 100644 --- a/examples/slcp_ssnl.py +++ b/examples/slcp-snle.py @@ -25,7 +25,7 @@ from surjectors.nn import MADE, make_mlp from surjectors.util import unstack -from sbijax import SNL +from sbijax import SNLE from sbijax.mcmc import sample_with_nuts diff --git a/examples/slcp_snass.py b/examples/slcp_snass.py deleted file mode 100644 index 322340b..0000000 --- a/examples/slcp_snass.py +++ /dev/null @@ -1,161 +0,0 @@ -""" -Example SNASS on the SLCP experiment -""" - -import distrax -import haiku as hk -import jax.nn -import matplotlib.pyplot as plt -import optax -import seaborn as sns -from jax import numpy as jnp -from jax import random as jr -from jax import scipy as jsp -from surjectors import ( - Chain, - MaskedAutoregressive, - Permutation, - TransformedDistribution, -) -from surjectors.nn import MADE -from surjectors.util import unstack - -from sbijax import SNASS -from sbijax._src.nn.make_snass_networks import make_snass_net - - -def prior_model_fns(): - p = distrax.Independent( - distrax.Uniform(jnp.full(5, -3.0), jnp.full(5, 3.0)), 1 - ) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - orig_shape = theta.shape - if theta.ndim == 2: - theta = theta[:, None, :] - us_key, noise_key = jr.split(seed) - - def _unpack_params(ps): - m0 = ps[..., [0]] - m1 = ps[..., [1]] - s0 = ps[..., [2]] ** 2 - s1 = ps[..., [3]] ** 2 - r = jnp.tanh(ps[..., [4]]) - return m0, m1, s0, s1, r - - m0, m1, s0, s1, r = _unpack_params(theta) - us = distrax.Normal(0.0, 1.0).sample( - seed=us_key, sample_shape=(theta.shape[0], theta.shape[1], 4, 2) - ) - xs = jnp.empty_like(us) - xs = xs.at[:, :, :, 0].set(s0 * us[:, :, :, 0] + m0) - y = xs.at[:, :, :, 1].set( - s1 * (r * us[:, :, :, 0] + jnp.sqrt(1.0 - r**2) * us[:, :, :, 1]) + m1 - ) - if len(orig_shape) == 2: - y = y.reshape((*theta.shape[:1], 8)) - else: - y = y.reshape((*theta.shape[:2], 8)) - return y - - -def likelihood_fn(theta, y): - mu = jnp.tile(theta[:2], 4) - s1, s2 = theta[2] ** 2, theta[3] ** 2 - corr = s1 * s2 * jnp.tanh(theta[4]) - cov = jnp.array([[s1**2, corr], [corr, s2**2]]) - cov = jsp.linalg.block_diag(*[cov for _ in range(4)]) - p = distrax.MultivariateNormalFullCovariance(mu, cov) - return p.log_prob(y) - - -def log_density_fn(theta, y): - prior_lp = distrax.Independent( - distrax.Uniform(jnp.full(5, -3.0), jnp.full(5, 3.0)), 1 - ).log_prob(theta) - likelihood_lp = likelihood_fn(theta, y) - - lp = jnp.sum(prior_lp) + jnp.sum(likelihood_lp) - return lp - - -def make_model(dim): - def _bijector_fn(params): - means, log_scales = unstack(params, -1) - return distrax.ScalarAffine(means, jnp.exp(log_scales)) - - def _flow(method, **kwargs): - layers = [] - order = jnp.arange(dim) - for i in range(5): - layer = MaskedAutoregressive( - bijector_fn=_bijector_fn, - conditioner=MADE( - dim, - [64, 64, dim * 2], - 2, - w_init=hk.initializers.TruncatedNormal(0.001), - b_init=jnp.zeros, - activation=jax.nn.tanh, - ), - ) - order = order[::-1] - layers.append(layer) - layers.append(Permutation(order, 1)) - chain = Chain(layers) - - base_distribution = distrax.Independent( - distrax.Normal(jnp.zeros(dim), jnp.ones(dim)), - 1, - ) - td = TransformedDistribution(base_distribution, chain) - return td(method, **kwargs) - - td = hk.transform(_flow) - td = hk.without_apply_rng(td) - return td - - -def run(): - thetas = jnp.linspace(-2.0, 2.0, 5) - y_0 = simulator_fn(jr.PRNGKey(0), thetas.reshape(-1, 5)).reshape(-1, 8) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - estim = SNASS( - fns, - make_model(5), - make_snass_net([64, 64, 5], [64, 64, 1]), - ) - optimizer = optax.adam(1e-3) - - data, params = None, {} - for i in range(2): - data, _ = estim.simulate_data_and_possibly_append( - jr.fold_in(jr.PRNGKey(12), i), - params=params, - observable=y_0, - data=data, - ) - params, _ = estim.fit( - jr.fold_in(jr.PRNGKey(23), i), - data=data, - optimizer=optimizer, - ) - - rng_key = jr.PRNGKey(23) - snasss_samples, _ = estim.sample_posterior(rng_key, params, y_0) - fig, axes = plt.subplots(5) - for i, ax in enumerate(axes): - sns.histplot(snasss_samples[:, i], color="darkblue", ax=ax) - ax.set_xlim([-3.0, 3.0]) - sns.despine() - plt.tight_layout() - plt.show() - - -if __name__ == "__main__": - run() diff --git a/examples/two_moons-fmpe.py b/examples/two_moons-fmpe.py new file mode 100644 index 0000000..e69de29 diff --git a/examples/two_moons-slice.py b/examples/two_moons-slice.py new file mode 100644 index 0000000..d5631cf --- /dev/null +++ b/examples/two_moons-slice.py @@ -0,0 +1,73 @@ +""" +Example using consistency model posterior estimation on a bivariate Gaussian +""" +from functools import partial + +import jax +import numpy as np +from jax import numpy as jnp +from jax import random as jr +from matplotlib import pyplot as plt +from tensorflow_probability.substrates.jax import distributions as tfd + +from sbijax.mcmc import sample_with_slice + + +def prior_fn(): + prior = tfd.JointDistributionNamed(dict( + theta=tfd.Normal(jnp.full(2, 0.0), 1.0) + ), batch_ndims=0) + return prior + + +def _map_fun_inv(theta, y): + ang = jnp.array([-jnp.pi / 4.0]) + c = jnp.cos(ang) + s = jnp.sin(ang) + z0 = (c * theta[:, 0] - s * theta[:, 1]).reshape(-1, 1) + z1 = (s * theta[:, 0] + c * theta[:, 1]).reshape(-1, 1) + return y - jnp.concatenate([-jnp.abs(z0), z1], axis=1) + + +def likelihood_fn(y, theta): + theta = theta.reshape(1, 2) + p = _map_fun_inv(theta, y).reshape(1, -1) + + u = p[:, 0] - 0.25 + v = p[:, 1] + + r = jnp.sqrt(u ** 2 + v ** 2) + ll = -0.5 * ((r - 0.1) / 0.01) ** 2 - 0.5 * jnp.log(2 * jnp.array([jnp.pi]) * 0.01 ** 2) + ll = jnp.where( + u < 0.0, + jnp.array(-jnp.inf), + ll + ) + return ll + + +def log_density_fn(theta, y): + prior_lp = prior_fn().log_prob(theta) + likelihood_lp = likelihood_fn(y, theta) + lp = jnp.sum(prior_lp) + jnp.sum(likelihood_lp) + #jax.debug.print("🤯 {x} 🤯", x=lp) + return lp + + +def run(): + y_observed = jnp.array([-0.6396706, 0.16234657]) + + log_density_partial = partial(log_density_fn, y=y_observed) + log_density = lambda x: jax.vmap(log_density_partial)(x) + samples = sample_with_slice( + jr.PRNGKey(0), + log_density, + prior_fn().sample, n_chains=4, n_samples=10000, n_warmup=5000 + ) + samples = np.array(samples.reshape(-1, 2)) + plt.scatter(samples[:, 0], samples[:, 1]) + plt.show() + + +if __name__ == "__main__": + run() diff --git a/pyproject.toml b/pyproject.toml index 8bb1c38..1ec2ff6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -21,11 +21,12 @@ classifiers = [ ] requires-python = ">=3.9" dependencies = [ + "arviz>=0.17.1", "blackjax-nightly>=1.0.0.post17", "distrax>=0.1.2", "dm-haiku>=0.0.9", "optax>=0.1.3", - "surjectors>=0.3.0", + "surjectors>=0.3.1", "tfp-nightly>=0.20.0.dev20230404", "tensorflow==2.15.0", "tensorflow-datasets==4.9.3", diff --git a/sbijax/__init__.py b/sbijax/__init__.py index f667a6b..67dd6a0 100644 --- a/sbijax/__init__.py +++ b/sbijax/__init__.py @@ -1,14 +1,30 @@ """sbijax: Simulation-based inference in JAX.""" -__version__ = "0.2.0.post0" +__version__ = "1.0.0" from sbijax._src.abc.smc_abc import SMCABC -from sbijax._src.scmpe import SCMPE -from sbijax._src.sfmpe import SFMPE -from sbijax._src.snass import SNASS -from sbijax._src.snasss import SNASSS -from sbijax._src.snl import SNL -from sbijax._src.snp import SNP -from sbijax._src.snr import SNR +from sbijax._src.cmpe import CMPE +from sbijax._src.fmpe import FMPE +from sbijax._src.nass import NASS +from sbijax._src.nasss import NASSS +from sbijax._src.nle import NLE +from sbijax._src.npe import NPE +from sbijax._src.nre import NRE +from sbijax._src.util.data import as_inference_data +from sbijax._src.util.data import flatten as inference_data_as_dictionary +from sbijax._src.util.plot import plot_posterior, plot_trace -__all__ = ["SMCABC", "SCMPE", "SFMPE", "SNASS", "SNASSS", "SNL", "SNP", "SNR"] +__all__ = [ + "SMCABC", + "CMPE", + "FMPE", + "NASS", + "NASSS", + "NLE", + "NPE", + "NRE", + "plot_posterior", + "plot_trace", + "as_inference_data", + "inference_data_as_dictionary", +] diff --git a/sbijax/_src/_sne_base.py b/sbijax/_src/_ne_base.py similarity index 83% rename from sbijax/_src/_sne_base.py rename to sbijax/_src/_ne_base.py index d8a1b49..390d37f 100644 --- a/sbijax/_src/_sne_base.py +++ b/sbijax/_src/_ne_base.py @@ -6,12 +6,11 @@ from jax import random as jr from sbijax._src._sbi_base import SBI -from sbijax._src.util.data import stack_data -from sbijax._src.util.dataloader import as_batch_iterators, named_dataset +from sbijax._src.util.data import flatten, stack_data # ruff: noqa: PLR0913 -class SNE(SBI, ABC): +class NE(SBI, ABC): """Sequential neural estimation base class.""" def __init__(self, model_fns, network): @@ -115,15 +114,22 @@ def simulate_parameters( ) if "n_samples" not in kwargs: kwargs["n_samples"] = n_simulations - new_thetas, diagnostics = self.sample_posterior( + inference_data, diagnostics = self.sample_posterior( rng_key=rng_key, params=params, observable=jnp.atleast_2d(observable), **kwargs, ) + new_thetas = flatten(inference_data.posterior) perm_key, rng_key = jr.split(rng_key) - new_thetas = jr.permutation(perm_key, new_thetas) - new_thetas = new_thetas[:n_simulations, :] + first_key = list(new_thetas.keys())[0] + idxs = jr.choice( + perm_key, + new_thetas[first_key].shape[0], + shape=(n_simulations,), + replace=False, + ) + new_thetas = {k: v[idxs] for k, v in new_thetas.items()} return new_thetas, diagnostics @@ -162,35 +168,13 @@ def simulate_data( ) new_obs = self.simulate_observations(data_key, new_thetas) - chex.assert_shape(new_thetas, [n_simulations, None]) + for v in new_thetas.values(): + chex.assert_shape(v, [n_simulations, None]) chex.assert_shape(new_obs, [n_simulations, None]) - new_data = named_dataset(new_obs, new_thetas) + new_data = {"y": new_obs, "theta": new_thetas} return new_data, diagnostics def simulate_observations(self, rng_key, thetas): new_obs = self.simulator_fn(seed=rng_key, theta=thetas) return new_obs - - @staticmethod - def as_iterators( - rng_key, data, batch_size, percentage_data_as_validation_set - ): - """Convert the data set to an iterable for training. - - Args: - rng_key: a jax random key - data: a tuple with 'y' and 'theta' elements - batch_size: the size of each batch - percentage_data_as_validation_set: fraction - - Returns: - two batch iterators - """ - return as_batch_iterators( - rng_key, - data, - batch_size, - 1.0 - percentage_data_as_validation_set, - True, - ) diff --git a/sbijax/_src/_sbi_base.py b/sbijax/_src/_sbi_base.py index 61eddb4..49e5e45 100644 --- a/sbijax/_src/_sbi_base.py +++ b/sbijax/_src/_sbi_base.py @@ -2,6 +2,8 @@ from jax import random as jr +from sbijax._src.util.dataloader import as_batch_iterators + # pylint: disable=too-many-instance-attributes,unused-argument, # pylint: disable=too-few-public-methods @@ -14,6 +16,33 @@ def __init__(self, model_fns): Args: model_fns: tuple """ - self.prior_sampler_fn, self.prior_log_density_fn = model_fns[0] + prior = model_fns[0]() + self.prior_sampler_fn, self.prior_log_density_fn = ( + prior.sample, + prior.log_prob, + ) self.simulator_fn = model_fns[1] self._len_theta = len(self.prior_sampler_fn(seed=jr.PRNGKey(123))) + + @staticmethod + def as_iterators( + rng_key, data, batch_size, percentage_data_as_validation_set + ): + """Convert the data set to an iterable for training. + + Args: + rng_key: a jax random key + data: a tuple with 'y' and 'theta' elements + batch_size: the size of each batch + percentage_data_as_validation_set: fraction + + Returns: + two batch iterators + """ + return as_batch_iterators( + rng_key, + data, + batch_size, + 1.0 - percentage_data_as_validation_set, + True, + ) diff --git a/sbijax/_src/abc/smc_abc.py b/sbijax/_src/abc/smc_abc.py index 74f25fe..1d48d72 100644 --- a/sbijax/_src/abc/smc_abc.py +++ b/sbijax/_src/abc/smc_abc.py @@ -1,26 +1,30 @@ from collections import namedtuple import chex -import distrax import jax from blackjax.smc import resampling from blackjax.smc.ess import ess from jax import numpy as jnp from jax import random as jr from jax import scipy as jsp +from jax import tree_map +from jax._src.flatten_util import ravel_pytree +from tensorflow_probability.substrates.jax import distributions as tfd +from tqdm import tqdm from sbijax._src._sbi_base import SBI +from sbijax._src.util.data import _tree_stack, as_inference_data # ruff: noqa: PLR0913 class SMCABC(SBI): """Sequential Monte Carlo approximate Bayesian computation. - Implements algorithm~4.8 from [1]. + Implements the algorithm from [1]. References: - .. [1] Sisson, Scott A, et al. "Handbook of approximate Bayesian - computation". 2019 + .. [1] Beaumont, Mark A, et al. "Adaptive approximate Bayesian + computation". Biometrika, 2009. """ def __init__(self, model_fns, summary_fn, distance_fn): @@ -43,7 +47,6 @@ def sample_posterior( observable, n_rounds, n_particles, - n_simulations_per_theta, eps_step, ess_min, cov_scale=1.0, @@ -56,8 +59,6 @@ def sample_posterior( observable: the observation to condition on n_rounds: number of rounds of SMC n_particles: number of n_particles to draw for each parameter - n_simulations_per_theta: number of simulations for each paramrter - sample eps_step: decay of initial epsilon per simulation round ess_min: minimal effective sample size cov_scale: scaling of the transition kernel covariance @@ -70,11 +71,11 @@ def sample_posterior( init_key, rng_key = jr.split(rng_key) particles, log_weights, epsilon = self._init_particles( - init_key, observable, n_particles, n_simulations_per_theta + init_key, observable, n_particles ) all_particles, all_n_simulations = [], [] - for n in range(n_rounds): + for n in tqdm(range(n_rounds)): epsilon *= eps_step rng_key = jr.fold_in(rng_key, n) particle_key, rng_key = jr.split(rng_key) @@ -84,45 +85,40 @@ def sample_posterior( n_particles, particles, log_weights, - n_simulations_per_theta, epsilon, cov_scale, ) curr_ess = ess(log_weights) if curr_ess < ess_min: resample_key, rng_key = jr.split(rng_key) + particles[list(particles.keys())[0]] particles, log_weights = self._resample( - resample_key, particles, log_weights, particles.shape[0] + resample_key, + particles, + log_weights, + particles[list(particles.keys())[0]].shape[0], ) all_particles.append(particles.copy()) all_n_simulations.append(self.n_total_simulations) + thetas = jax.tree_map(lambda x: x.reshape(1, *x.shape), particles) + inference_data = as_inference_data(thetas, jnp.squeeze(observable)) smc_info = namedtuple("smc_info", "particles n_simulations") - return particles, smc_info(all_particles, all_n_simulations) + return inference_data, smc_info(all_particles, all_n_simulations) def _chol_factor(self, particles, cov_scale): + particles = jax.vmap(lambda x: ravel_pytree(x)[0])(particles) chol = jnp.linalg.cholesky(jnp.cov(particles.T) * cov_scale) return chol - def _init_particles( - self, rng_key, observable, n_particles, n_simulations_per_theta - ): - self.n_total_simulations += n_particles * 10 - + def _init_particles(self, rng_key, observable, n_particles): + self.n_total_simulations += n_particles init_key, rng_key = jr.split(rng_key) particles = self.prior_sampler_fn( - seed=init_key, sample_shape=(n_particles * 10,) + seed=init_key, sample_shape=(n_particles,) ) - - thetas = jnp.tile(particles, [n_simulations_per_theta, 1, 1]) - chex.assert_axis_dimension(thetas, 0, n_simulations_per_theta) - chex.assert_axis_dimension(thetas, 1, n_particles * 10) - simulator_key, rng_key = jr.split(rng_key) - ys = self.simulator_fn(seed=simulator_key, theta=thetas) - ys = jnp.swapaxes(ys, 1, 0) - chex.assert_axis_dimension(ys, 0, n_particles * 10) - chex.assert_axis_dimension(ys, 1, n_simulations_per_theta) + ys = self.simulator_fn(seed=simulator_key, theta=particles) summary_statistics = self.summary_fn(ys) distances = self.distance_fn( @@ -130,7 +126,7 @@ def _init_particles( ) sort_idx = jnp.argsort(distances) - particles = particles[sort_idx][:n_particles] + particles = jax.tree_map(lambda x: x[sort_idx][:n_particles], particles) log_weights = -jnp.log(jnp.full(n_particles, n_particles)) initial_epsilon = distances[-1] @@ -150,25 +146,19 @@ def _sample_candidates( perturb_key, new_candidate_particles, cov_chol_factor ) cand_lps = self.prior_log_density_fn(new_candidate_particles) - new_candidate_particles = new_candidate_particles[ - jnp.logical_not(jnp.isinf(cand_lps)) - ] + is_finite = jnp.logical_not(jnp.isinf(cand_lps)) + new_candidate_particles = tree_map( + lambda x: x[is_finite], new_candidate_particles + ) return new_candidate_particles def _simulate_and_distance( - self, - rng_key, - observable, - new_candidate_particles, - n_simulations_per_theta, + self, rng_key, observable, new_candidate_particles ): ys = self.simulator_fn( seed=rng_key, - theta=jnp.tile( - new_candidate_particles, [n_simulations_per_theta, 1, 1] - ), + theta=new_candidate_particles, ) - ys = jnp.swapaxes(ys, 1, 0) summary_statistics = self.summary_fn(ys) ds = self.distance_fn(summary_statistics, self.summary_fn(observable)) return ds @@ -181,7 +171,6 @@ def _move( n_particles, particles, log_weights, - n_simulations_per_theta, epsilon, cov_scale, ): @@ -197,20 +186,21 @@ def _move( simulate_key, observable, new_candidate_particles, - n_simulations_per_theta, ) idxs = jnp.where(ds < epsilon)[0] - new_candidate_particles = new_candidate_particles[idxs] + new_candidate_particles = tree_map( + lambda x: x[idxs], new_candidate_particles + ) if new_particles is None: new_particles = new_candidate_particles else: - new_particles = jnp.vstack( + new_particles = _tree_stack( [new_particles, new_candidate_particles] ) n -= len(idxs) - new_particles = new_particles[:n_particles,] + new_particles = tree_map(lambda x: x[:n_particles], new_particles) new_log_weights = self._new_log_weights( new_particles, particles, log_weights, cov_chol_factor ) @@ -219,7 +209,7 @@ def _move( def _resample(self, rng_key, particles, log_weights, n_samples): idxs = resampling.multinomial(rng_key, jnp.exp(log_weights), n_samples) - particles = particles[idxs] + particles = tree_map(lambda x: x[idxs], particles) return particles, -jnp.log(jnp.full(n_samples, n_samples)) def _new_log_weights( @@ -233,6 +223,7 @@ def _particle_weight(partcl): weight = jsp.special.logsumexp(probs) return weight + new_particles = jax.vmap(lambda x: ravel_pytree(x)[0])(new_particles) new_particles = new_particles[:, None, :] log_weighted_sum = jax.vmap(_particle_weight)(new_particles) @@ -241,7 +232,11 @@ def _particle_weight(partcl): return new_log_weights def _kernel(self, mus, cov_chol_factor): - return distrax.MultivariateNormalTri(loc=mus, scale_tri=cov_chol_factor) + mus = jax.vmap(lambda x: ravel_pytree(x)[0])(mus) + return tfd.MultivariateNormalTriL(loc=mus, scale_tril=cov_chol_factor) def _perturb(self, rng_key, mus, cov_chol_factor): - return self._kernel(mus, cov_chol_factor).sample(seed=rng_key) + _, unravel_fn = ravel_pytree(self.prior_sampler_fn(seed=jr.PRNGKey(0))) + samples = self._kernel(mus, cov_chol_factor).sample(seed=rng_key) + samples = jax.vmap(unravel_fn)(samples) + return samples diff --git a/sbijax/_src/scmpe.py b/sbijax/_src/cmpe.py similarity index 95% rename from sbijax/_src/scmpe.py rename to sbijax/_src/cmpe.py index 7df31ce..dc5bbf3 100644 --- a/sbijax/_src/scmpe.py +++ b/sbijax/_src/cmpe.py @@ -8,7 +8,7 @@ from jax import random as jr from tqdm import tqdm -from sbijax._src.sfmpe import SFMPE +from sbijax._src.fmpe import FMPE from sbijax._src.util.early_stopping import EarlyStopping @@ -88,7 +88,7 @@ def _consistency_loss( # ruff: noqa: PLR0913 -class SCMPE(SFMPE): +class CMPE(FMPE): r"""Sequential consistency model posterior estimation. Implements a sequential version of the CMPE algorithm introduced in [1]_. @@ -108,15 +108,15 @@ class SCMPE(SFMPE): Examples: >>> import distrax - >>> from sbijax import SCMPE - >>> from sbijax.nn import make_consistency_model + >>> from sbijax import CMPE + >>> from sbijax.nn import make_cm >>> >>> prior = distrax.Normal(0.0, 1.0) >>> s = lambda seed, theta: distrax.Normal(theta, 1.0).sample(seed=seed) >>> fns = (prior.sample, prior.log_prob), s - >>> net = make_consistency_model(1) + >>> net = make_cm(1) >>> - >>> estim = SCMPE(fns, net) + >>> estim = CMPE(fns, net) References: .. [1] Schmitt, Marvin, et al. "Consistency Models for Scalable and @@ -149,6 +149,7 @@ def _fit_model_single_round( optimizer, n_iter, n_early_stopping_patience, + n_early_stopping_delta, ): init_key, seed = jr.split(seed) params = self._init_params(init_key, **next(iter(train_iter))) @@ -180,7 +181,9 @@ def step(params, ema_params, rng, state, n_iter, **batch): return loss, new_params, new_ema_params, new_state losses = np.zeros([n_iter, 2]) - early_stop = EarlyStopping(1e-3, n_early_stopping_patience * 2) + early_stop = EarlyStopping( + n_early_stopping_delta, n_early_stopping_patience + ) best_params, best_loss = None, np.inf logging.info("training model") for i in tqdm(range(n_iter)): diff --git a/sbijax/_src/cmpe_test.py b/sbijax/_src/cmpe_test.py new file mode 100644 index 0000000..0066a7b --- /dev/null +++ b/sbijax/_src/cmpe_test.py @@ -0,0 +1,36 @@ +# pylint: skip-file + +import distrax +import haiku as hk +from jax import numpy as jnp + +from sbijax import CMPE +from sbijax.nn import make_cm + +from jax import numpy as jnp, random as jr + + +def test_cmpe(prior_simulator_tuple): + y_observed = jnp.array([-1.0, 1.0]) + estim = CMPE(prior_simulator_tuple, make_cm(2)) + data, params = None, {} + for i in range(2): + data, _ = estim.simulate_data_and_possibly_append( + jr.PRNGKey(1), + params=params, + observable=y_observed, + data=data, + n_simulations=100, + n_chains=2, + n_samples=200, + n_warmup=100, + ) + params, info = estim.fit(jr.PRNGKey(2), data=data, n_iter=2) + _ = estim.sample_posterior( + jr.PRNGKey(3), + params, + y_observed, + n_chains=2, + n_samples=200, + n_warmup=100, + ) diff --git a/sbijax/_src/conftest.py b/sbijax/_src/conftest.py new file mode 100644 index 0000000..155907a --- /dev/null +++ b/sbijax/_src/conftest.py @@ -0,0 +1,26 @@ +# pylint: skip-file + +import pytest +from jax import numpy as jnp +from tensorflow_probability.substrates.jax import distributions as tfd + + +def prior_fn(): + prior = tfd.JointDistributionNamed( + dict( + theta=tfd.Normal(jnp.zeros(2), 1.0), + ), + batch_ndims=0, + ) + return prior + + +def simulator_fn(seed, theta): + p = tfd.Normal(jnp.zeros_like(theta["theta"]), 1.0) + y = theta["theta"] + p.sample(seed=seed) + return y + + +@pytest.fixture() +def prior_simulator_tuple(request): + yield prior_fn, simulator_fn diff --git a/sbijax/_src/sfmpe.py b/sbijax/_src/fmpe.py similarity index 90% rename from sbijax/_src/sfmpe.py rename to sbijax/_src/fmpe.py index 56362d3..cf39a91 100644 --- a/sbijax/_src/sfmpe.py +++ b/sbijax/_src/fmpe.py @@ -6,9 +6,11 @@ from absl import logging from jax import numpy as jnp from jax import random as jr +from jax._src.flatten_util import ravel_pytree from tqdm import tqdm -from sbijax._src._sne_base import SNE +from sbijax._src._ne_base import NE +from sbijax._src.util.data import as_inference_data from sbijax._src.util.early_stopping import EarlyStopping @@ -58,7 +60,7 @@ def _cfm_loss( # ruff: noqa: PLR0913 -class SFMPE(SNE): +class FMPE(NE): r"""Sequential flow matching posterior estimation. Implements a sequential version of the FMPE algorithm introduced in [1]_. @@ -77,8 +79,8 @@ class SFMPE(SNE): Examples: >>> import distrax - >>> from sbijax import SFMPE - >>> from sbijax.nn import make_ccnf + >>> from sbijax import FMPE + >>> from sbijax.nn import make_cnf >>> >>> prior = distrax.Normal(0.0, 1.0) >>> s = lambda seed, theta: distrax.Normal(theta, 1.0).sample(seed=seed) @@ -117,6 +119,7 @@ def fit( batch_size=100, percentage_data_as_validation_set=0.1, n_early_stopping_patience=10, + n_early_stopping_delta=0.001, **kwargs, ): """Fit the model. @@ -147,6 +150,7 @@ def fit( optimizer=optimizer, n_iter=n_iter, n_early_stopping_patience=n_early_stopping_patience, + n_early_stopping_delta=n_early_stopping_delta, ) return params, losses @@ -160,6 +164,7 @@ def _fit_model_single_round( optimizer, n_iter, n_early_stopping_patience, + n_early_stopping_delta, ): init_key, seed = jr.split(seed) params = self._init_params(init_key, **next(iter(train_iter))) @@ -177,7 +182,9 @@ def step(params, rng, state, **batch): return loss, new_params, new_state losses = np.zeros([n_iter, 2]) - early_stop = EarlyStopping(1e-3, n_early_stopping_patience) + early_stop = EarlyStopping( + n_early_stopping_delta, n_early_stopping_patience + ) best_params, best_loss = None, np.inf logging.info("training model") for i in tqdm(range(n_iter)): @@ -254,6 +261,7 @@ def sample_posterior( thetas = None n_curr = n_samples n_total_simulations_round = 0 + _, unravel_fn = ravel_pytree(self.prior_sampler_fn(seed=jr.PRNGKey(1))) while n_curr > 0: n_sim = jnp.minimum(200, jnp.maximum(200, n_curr)) n_total_simulations_round += n_sim @@ -265,16 +273,21 @@ def sample_posterior( context=jnp.tile(observable, [n_sim, 1]), is_training=False, ) - proposal_probs = self.prior_log_density_fn(proposal) + proposal_probs = self.prior_log_density_fn( + jax.vmap(unravel_fn)(proposal) + ) proposal_accepted = proposal[jnp.isfinite(proposal_probs)] if thetas is None: thetas = proposal_accepted else: thetas = jnp.vstack([thetas, proposal_accepted]) n_curr -= proposal_accepted.shape[0] - self.n_total_simulations += n_total_simulations_round - return ( - thetas[:n_samples], - thetas.shape[0] / n_total_simulations_round, + + ess = float(thetas.shape[0] / n_total_simulations_round) + thetas = jax.tree_map( + lambda x: x.reshape(1, *x.shape), + jax.vmap(unravel_fn)(thetas[:n_samples]), ) + inference_data = as_inference_data(thetas, jnp.squeeze(observable)) + return inference_data, ess diff --git a/sbijax/_src/fmpe_test.py b/sbijax/_src/fmpe_test.py new file mode 100644 index 0000000..7b31f08 --- /dev/null +++ b/sbijax/_src/fmpe_test.py @@ -0,0 +1,37 @@ +# pylint: skip-file + +import distrax +import haiku as hk +from jax import numpy as jnp + +from sbijax import FMPE +from sbijax.nn import make_cnf + +from jax import numpy as jnp, random as jr + + + +def test_fmpe(prior_simulator_tuple): + y_observed = jnp.array([-1.0, 1.0]) + estim = FMPE(prior_simulator_tuple, make_cnf(2)) + data, params = None, {} + for i in range(2): + data, _ = estim.simulate_data_and_possibly_append( + jr.PRNGKey(1), + params=params, + observable=y_observed, + data=data, + n_simulations=100, + n_chains=2, + n_samples=200, + n_warmup=100, + ) + params, info = estim.fit(jr.PRNGKey(2), data=data, n_iter=2) + _ = estim.sample_posterior( + jr.PRNGKey(3), + params, + y_observed, + n_chains=2, + n_samples=200, + n_warmup=100, + ) diff --git a/sbijax/_src/mcmc/__init__.py b/sbijax/_src/mcmc/__init__.py index 2bca713..0752ddc 100644 --- a/sbijax/_src/mcmc/__init__.py +++ b/sbijax/_src/mcmc/__init__.py @@ -1,9 +1,9 @@ -from sbijax._src.mcmc.diagnostics import mcmc_diagnostics from sbijax._src.mcmc.irmh import sample_with_imh from sbijax._src.mcmc.mala import sample_with_mala from sbijax._src.mcmc.nuts import sample_with_nuts from sbijax._src.mcmc.rmh import sample_with_rmh from sbijax._src.mcmc.slice import sample_with_slice +from sbijax._src.mcmc.util import mcmc_diagnostics __all__ = [ "mcmc_diagnostics", diff --git a/sbijax/_src/mcmc/diagnostics.py b/sbijax/_src/mcmc/diagnostics.py deleted file mode 100644 index f16e403..0000000 --- a/sbijax/_src/mcmc/diagnostics.py +++ /dev/null @@ -1,25 +0,0 @@ -from collections import namedtuple - -import blackjax as bj - - -def mcmc_diagnostics(samples): - r"""Computes MCMC diagnostics. - - Compute effective sample sizes and R-hat for each parameter of a set of - MCMC chains. - - Args: - samples: a JAX array of dimension n_samples \times n_chains \times n_dim - - Returns: - a tuple of jnp.ndarrays with ess and rhat estimates. - """ - n_theta = samples.shape[-1] - esses = [0] * n_theta - rhats = [0] * n_theta - for i in range(n_theta): - posterior = samples[:, :, i].T - esses[i] = bj.diagnostics.effective_sample_size(posterior) - rhats[i] = bj.diagnostics.potential_scale_reduction(posterior) - return namedtuple("diagnostics", "ess rhat")(esses, rhats) diff --git a/sbijax/_src/mcmc/irmh.py b/sbijax/_src/mcmc/irmh.py index 024f21a..1c91977 100644 --- a/sbijax/_src/mcmc/irmh.py +++ b/sbijax/_src/mcmc/irmh.py @@ -8,7 +8,7 @@ def sample_with_imh( rng_key, lp, prior, *, n_chains=4, n_samples=2_000, n_warmup=1_000, **kwargs ): - r"""Draw samples using the indepdendent Metropolis-Hastings sampler. + r"""Draw samples using the independent Metropolis-Hastings sampler. Args: rng_key: a jax random key diff --git a/sbijax/_src/mcmc/mala.py b/sbijax/_src/mcmc/mala.py index 9c10bc9..666f9cc 100644 --- a/sbijax/_src/mcmc/mala.py +++ b/sbijax/_src/mcmc/mala.py @@ -36,18 +36,21 @@ def _step(states, rng_key): init_key, rng_key = jr.split(rng_key) initial_states, kernel = _mala_init(init_key, n_chains, prior, lp) + first_key = list(initial_states.position.keys())[0] states = _inference_loop(init_key, kernel, initial_states, n_samples) - _ = states.position["theta"].block_until_ready() - thetas = states.position["theta"][n_warmup:, :, :] - - return thetas + _ = states.position[first_key].block_until_ready() + theta = jax.tree_util.tree_map( + lambda x: x[n_warmup:, ...].reshape(n_chains, n_samples - n_warmup, -1), + states.position, + ) + return theta # pylint: disable=missing-function-docstring,no-member def _mala_init(rng_key, n_chains, prior: distrax.Distribution, lp): init_key, rng_key = jr.split(rng_key) initial_positions = prior(seed=init_key, sample_shape=(n_chains,)) - kernel = bj.mala(lp, 1.0) - initial_positions = {"theta": initial_positions} + + kernel = bj.mala(lp, 0.1) initial_state = jax.vmap(kernel.init)(initial_positions) return initial_state, kernel.step diff --git a/sbijax/_src/mcmc/nuts.py b/sbijax/_src/mcmc/nuts.py index 54c4331..ce7906a 100644 --- a/sbijax/_src/mcmc/nuts.py +++ b/sbijax/_src/mcmc/nuts.py @@ -42,18 +42,20 @@ def _step(states, rng_key): init_key, rng_key = jr.split(rng_key) initial_states, kernel = _nuts_init(init_key, n_chains, prior, lp) + first_key = list(initial_states.position.keys())[0] states = _inference_loop(init_key, kernel, initial_states, n_samples) - _ = states.position["theta"].block_until_ready() - thetas = states.position["theta"][n_warmup:, :, :] - - return thetas + _ = states.position[first_key].block_until_ready() + theta = jax.tree_util.tree_map( + lambda x: x[n_warmup:, ...].reshape(n_chains, n_samples - n_warmup, -1), + states.position, + ) + return theta # pylint: disable=missing-function-docstring def _nuts_init(rng_key, n_chains, prior: distrax.Distribution, lp): init_key, rng_key = jr.split(rng_key) initial_positions = prior(seed=init_key, sample_shape=(n_chains,)) - initial_positions = {"theta": initial_positions} init_keys = jr.split(rng_key, n_chains) warmup = bj.window_adaptation(bj.nuts, lp) diff --git a/sbijax/_src/mcmc/slice.py b/sbijax/_src/mcmc/slice.py index c0909ce..52307cb 100644 --- a/sbijax/_src/mcmc/slice.py +++ b/sbijax/_src/mcmc/slice.py @@ -31,7 +31,7 @@ def sample_with_slice( a JAX array of dimension n_samples \times n_chains \times len_theta """ init_key, rng_key = jr.split(rng_key) - initial_states = _slice_init(init_key, n_chains, prior) + initial_states = _slice_init(init_key, n_chains, prior)["theta"] sample_key, rng_key = jr.split(rng_key) samples = tfp.mcmc.sample_chain( diff --git a/sbijax/_src/mcmc/util.py b/sbijax/_src/mcmc/util.py new file mode 100644 index 0000000..39b4d3b --- /dev/null +++ b/sbijax/_src/mcmc/util.py @@ -0,0 +1,8 @@ +from collections import namedtuple + +import arviz as az + + +def mcmc_diagnostics(samples: az.InferenceData): + MCMCDiagnostics = namedtuple("MCMCDiagnostics", "rhat ess") + return MCMCDiagnostics(az.rhat(samples), az.ess(samples)) diff --git a/sbijax/_src/snass.py b/sbijax/_src/nass.py similarity index 62% rename from sbijax/_src/snass.py rename to sbijax/_src/nass.py index 42a3949..9d93485 100644 --- a/sbijax/_src/snass.py +++ b/sbijax/_src/nass.py @@ -8,8 +8,8 @@ from jax import random as jr from tqdm import tqdm -from sbijax._src.snl import SNL -from sbijax._src.util.dataloader import as_batch_iterator, named_dataset +from sbijax._src._sbi_base import SBI +from sbijax._src.util.dataloader import as_numpy_iterator_from_slices from sbijax._src.util.early_stopping import EarlyStopping @@ -31,7 +31,7 @@ def _jsd_summary_loss(params, rng, apply_fn, **batch): # ruff: noqa: PLR0913 -class SNASS(SNL): +class NASS(SBI): """Sequential neural approximate summary statistics. Args: @@ -49,7 +49,7 @@ class SNASS(SNL): Implicit Models". ICLR, 2021 """ - def __init__(self, model_fns, density_estimator, summary_net): + def __init__(self, model_fns, summary_net): """Construct a SNASS object. Args: @@ -62,8 +62,8 @@ def __init__(self, model_fns, density_estimator, summary_net): the modelled dimensionality is that of the summaries summary_net: a SNASSNet object """ - super().__init__(model_fns, density_estimator) - self.sc_net = summary_net + super().__init__(model_fns) + self.model = summary_net # pylint: disable=arguments-differ,too-many-locals def fit( @@ -90,15 +90,16 @@ def fit( that is used for validation and early stopping n_early_stopping_patience: number of iterations of no improvement of training the flow before stopping optimisation + **kwargs: additional keyword arguments not used for NASS) - Keyword Args: - sampler (str): either 'nuts', 'slice' or None (defaults to nuts) - n_thin (int): number of thinning steps - (only used if sampler='slice') - n_doubling (int): number of doubling steps of the interval - (only used if sampler='slice') - step_size (float): step size of the initial interval - (only used if sampler='slice') + # Keyword Args: + # sampler (str): either 'nuts', 'slice' or None (defaults to nuts) + # n_thin (int): number of thinning steps + # (only used if sampler='slice') + # n_doubling (int): number of doubling steps of the interval + # (only used if sampler='slice') + # step_size (float): step size of the initial interval + # (only used if sampler='slice') Returns: tuple of parameters and a tuple of the training information @@ -116,40 +117,30 @@ def fit( n_iter=n_iter, n_early_stopping_patience=n_early_stopping_patience, ) + return snet_params, snet_losses - train_key, val_key, rng_key = jr.split(rng_key, 3) - train_iter = self._as_itr_over_summaries( - train_key, train_iter, snet_params, batch_size - ) - val_iter = self._as_itr_over_summaries( - val_key, val_iter, snet_params, batch_size - ) + # TODO(Simon): this is not very nicely solved + def summarize(self, params, data, batch_size=512): + if params is None or len(params) == 0: + return data + y = {"y": data} if isinstance(data, jnp.ndarray) else data + itr = as_numpy_iterator_from_slices(y, batch_size) - nde_params, losses = self._fit_model_single_round( - seed=rng_key, - train_iter=train_iter, - val_iter=val_iter, - optimizer=optimizer, - n_iter=n_iter, - n_early_stopping_patience=n_early_stopping_patience, - ) + @jax.jit + def _summarize(batch): + return self.model.apply(params, method="summary", y=batch["y"]) - return {"params": nde_params, "s_params": snet_params}, ( - losses, - snet_losses, + summaries = jnp.concatenate( + [_summarize(batch) for batch in itr], axis=0 ) - def _as_itr_over_summaries(self, rng_key, iters, params, batch_size): - ys = [] - thetas = [] - for batch in iters: - ys.append(self.sc_net.apply(params, method="summary", y=batch["y"])) - thetas.append(batch["theta"]) - ys = jnp.vstack(ys) - thetas = jnp.vstack(thetas) - return as_batch_iterator( - rng_key, named_dataset(ys, thetas), batch_size, True - ) + if isinstance(data, dict): + ret_summaries = data.copy() + ret_summaries["y"] = summaries + else: + ret_summaries = summaries + + return ret_summaries # pylint: disable=undefined-loop-variable def _fit_summary_net( @@ -166,9 +157,7 @@ def _fit_summary_net( init_key, **next(iter(train_iter)) ) state = optimizer.init(params) - loss_fn = jax.jit( - partial(_jsd_summary_loss, apply_fn=self.sc_net.apply) - ) + loss_fn = jax.jit(partial(_jsd_summary_loss, apply_fn=self.model.apply)) @jax.jit def step(rng, params, state, **batch): @@ -209,13 +198,11 @@ def step(rng, params, state, **batch): return best_params, losses def _init_summary_net_params(self, rng_key, **init_data): - params = self.sc_net.init(rng_key, method="forward", **init_data) + params = self.model.init(rng_key, method="forward", **init_data) return params def _summary_validation_loss(self, params, rng_key, val_iter): - loss_fn = jax.jit( - partial(_jsd_summary_loss, apply_fn=self.sc_net.apply) - ) + loss_fn = jax.jit(partial(_jsd_summary_loss, apply_fn=self.model.apply)) def body_fn(batch_key, **batch): loss = loss_fn(params, batch_key, **batch) @@ -226,52 +213,3 @@ def body_fn(batch_key, **batch): batch_key, rng_key = jr.split(rng_key) losses += body_fn(batch_key, **batch) return losses - - # ruff: noqa: D417 - def sample_posterior( - self, - rng_key, - params, - observable, - *, - n_chains=4, - n_samples=2_000, - n_warmup=1_000, - **kwargs, - ): - r"""Sample from the approximate posterior. - - Args: - rng_key: a jax random key - params: a pytree of neural network parameters - observable: observation to condition on - n_chains: number of MCMC chains - n_samples: number of samples per chain - n_warmup: number of samples to discard - - Keyword Args: - sampler (str): either 'nuts', 'slice' or None (defaults to nuts) - n_thin (int): number of thinning steps - (only used if sampler='slice') - n_doubling (int): number of doubling steps of the interval - (only used if sampler='slice') - step_size (float): step size of the initial interval - (only used if sampler='slice') - - Returns: - an array of samples from the posterior distribution of dimension - (n_samples \times p) and posterior diagnostics - """ - observable = jnp.atleast_2d(observable) - summary = self.sc_net.apply( - params["s_params"], method="summary", y=observable - ) - return super().sample_posterior( - rng_key, - params["params"], - summary, - n_chains=n_chains, - n_samples=n_samples, - n_warmup=n_warmup, - **kwargs, - ) diff --git a/sbijax/_src/nass_test.py b/sbijax/_src/nass_test.py new file mode 100644 index 0000000..1840879 --- /dev/null +++ b/sbijax/_src/nass_test.py @@ -0,0 +1,48 @@ +# pylint: skip-file + +import distrax +from jax import numpy as jnp, random as jr + +from sbijax import NASS, NLE +from sbijax.nn import make_maf, make_nass_net + + +def simulator_fn(seed, theta): + p = distrax.MultivariateNormalDiag(theta, 0.1 * jnp.ones_like(theta)) + y = p.sample(seed=seed) + y = jnp.repeat(y, 5, axis=1) + return y + + +def test_nass(prior_simulator_tuple): + y_observed = jr.normal(jr.PRNGKey(0), (10,)) + fns = prior_simulator_tuple[0], simulator_fn + + model_nass = NASS(fns, make_nass_net([64, 64, 5], [64, 64, 1])) + model_nle = NLE(fns, make_maf(5)) + + data, params_nle, params_nass = None, {}, {} + for i in range(2): + s_observed = model_nass.summarize(params_nass, y_observed) + data, _ = model_nle.simulate_data_and_possibly_append( + jr.PRNGKey(1), + params=params_nle, + observable=s_observed, + data=data, + n_simulations=100, + n_chains=2, + n_samples=200, + n_warmup=100, + ) + params_nass, _ = model_nass.fit(jr.PRNGKey(2), data=data, n_iter=2) + summaries = model_nass.summarize(params_nass, data) + params_nle, _ = model_nle.fit(jr.PRNGKey(3), data=summaries) + s_observed = model_nass.summarize(params_nass, y_observed) + _ = model_nle.sample_posterior( + jr.PRNGKey(3), + params_nle, + s_observed, + n_chains=2, + n_samples=200, + n_warmup=100, + ) diff --git a/sbijax/_src/snasss.py b/sbijax/_src/nasss.py similarity index 96% rename from sbijax/_src/snasss.py rename to sbijax/_src/nasss.py index 8135933..72e2b69 100644 --- a/sbijax/_src/snasss.py +++ b/sbijax/_src/nasss.py @@ -7,7 +7,7 @@ from jax import numpy as jnp from jax import random as jr -from sbijax._src.snass import SNASS +from sbijax._src.nass import NASS from sbijax._src.util.early_stopping import EarlyStopping @@ -53,7 +53,7 @@ def _jsd_summary_loss(params, rng_key, apply_fn, **batch): # ruff: noqa: PLR0913 -class SNASSS(SNASS): +class NASSS(NASS): """Sequential neural approximate slice sufficient statistics. Args: @@ -72,7 +72,7 @@ class SNASSS(SNASS): """ # pylint: disable=useless-parent-delegation - def __init__(self, model_fns, density_estimator, summary_net): + def __init__(self, model_fns, summary_net): """Construct a SNASSS object. Args: @@ -85,7 +85,7 @@ def __init__(self, model_fns, density_estimator, summary_net): the modelled dimensionality is that of the summaries summary_net: a SNASSSNet object """ - super().__init__(model_fns, density_estimator, summary_net) + super().__init__(model_fns, summary_net) # pylint: disable=undefined-loop-variable def _fit_summary_net( diff --git a/sbijax/_src/nasss_test.py b/sbijax/_src/nasss_test.py new file mode 100644 index 0000000..25c5f44 --- /dev/null +++ b/sbijax/_src/nasss_test.py @@ -0,0 +1,51 @@ +# pylint: skip-file + +import distrax +from jax import numpy as jnp, random as jr + +from sbijax import NASSS, NLE +from sbijax.nn import make_nasss_net, make_maf + + +def simulator_fn(seed, theta): + p = distrax.MultivariateNormalDiag(theta, 0.1 * jnp.ones_like(theta)) + y = p.sample(seed=seed) + y = jnp.repeat(y, 5, axis=1) + return y + + +def test_nasss(prior_simulator_tuple): + y_observed = jr.normal(jr.PRNGKey(0), (10,)) + fns = prior_simulator_tuple[0], simulator_fn + + model_nass = NASSS( + fns, + make_nasss_net((32, 5), (32, 1), (32, 1)), + ) + model_nle = NLE(fns, make_maf(5)) + + data, params_nle, params_nass = None, {}, {} + for i in range(2): + s_observed = model_nass.summarize(params_nass, y_observed) + data, _ = model_nle.simulate_data_and_possibly_append( + jr.PRNGKey(1), + params=params_nle, + observable=s_observed, + data=data, + n_simulations=100, + n_chains=2, + n_samples=200, + n_warmup=100, + ) + params_nass, _ = model_nass.fit(jr.PRNGKey(2), data=data, n_iter=2) + summaries = model_nass.summarize(params_nass, data) + params_nle, _ = model_nle.fit(jr.PRNGKey(3), data=summaries) + s_observed = model_nass.summarize(params_nass, y_observed) + _ = model_nle.sample_posterior( + jr.PRNGKey(3), + params_nle, + s_observed, + n_chains=2, + n_samples=200, + n_warmup=100, + ) diff --git a/sbijax/_src/snl.py b/sbijax/_src/nle.py similarity index 88% rename from sbijax/_src/snl.py rename to sbijax/_src/nle.py index f3d63df..abec58b 100644 --- a/sbijax/_src/snl.py +++ b/sbijax/_src/nle.py @@ -1,22 +1,26 @@ from functools import partial +import arviz import chex import jax import numpy as np import optax from absl import logging +from arviz import InferenceData from jax import numpy as jnp from jax import random as jr +from jax._src.flatten_util import ravel_pytree from tqdm import tqdm from sbijax._src import mcmc -from sbijax._src._sne_base import SNE -from sbijax._src.mcmc.diagnostics import mcmc_diagnostics +from sbijax._src._ne_base import NE +from sbijax._src.mcmc.util import mcmc_diagnostics +from sbijax._src.util.data import as_inference_data from sbijax._src.util.early_stopping import EarlyStopping # ruff: noqa: PLR0913 -class SNL(SNE): +class NLE(NE): """Sequential neural likelihood. Implements both SNL and SSNL estimation methods. @@ -78,6 +82,7 @@ def fit( that is used for valitation and early stopping n_early_stopping_patience: number of iterations of no improvement of training the flow before stopping optimisation + **kwargs: additional keyword arguments (not used for NLE) Returns: a tuple of parameters and a tuple of the training @@ -222,6 +227,30 @@ def simulate_data_and_possibly_append( **kwargs, ) + def simulate_data( + self, + rng_key, + params=None, + observable=None, + data=None, + n_simulations=1_000, + n_chains=4, + n_samples=2_000, + n_warmup=1_000, + **kwargs, + ): + return super().simulate_data( + rng_key=rng_key, + params=params, + observable=observable, + data=data, + n_simulations=n_simulations, + n_chains=n_chains, + n_samples=n_samples, + n_warmup=n_warmup, + **kwargs, + ) + def sample_posterior( self, rng_key, @@ -283,6 +312,7 @@ def _sample_posterior( ) def _log_likelihood_fn(theta): + theta, _ = ravel_pytree(theta) theta = jnp.tile(theta, [observable.shape[0], 1]) return part(x=theta) @@ -300,7 +330,7 @@ def lp__(theta): else: def lp__(theta): - return _joint_logdensity_fn(**theta) + return _joint_logdensity_fn(theta) # take whatever sampler is or per default nuts sampler = kwargs.pop("sampler", "nuts") @@ -315,8 +345,15 @@ def lp__(theta): n_warmup=n_warmup, **kwargs, ) - chex.assert_shape(samples, [n_samples - n_warmup, n_chains, None]) - diagnostics = mcmc_diagnostics(samples) - samples = samples.reshape((n_samples - n_warmup) * n_chains, -1) + for v in samples.values(): + chex.assert_shape(v, [n_chains, n_samples - n_warmup, None]) + inference_data = as_inference_data(samples, jnp.squeeze(observable)) + diagnostics = mcmc_diagnostics(inference_data) + return inference_data, diagnostics + + @staticmethod + def plot(inference_data: InferenceData): + arviz.plot_trace(inference_data) + - return samples, diagnostics +SNLE = NLE diff --git a/sbijax/_src/nle_test.py b/sbijax/_src/nle_test.py new file mode 100644 index 0000000..e95644b --- /dev/null +++ b/sbijax/_src/nle_test.py @@ -0,0 +1,44 @@ +# pylint: skip-file + +import pytest +from jax import numpy as jnp +from jax import random as jr + +from sbijax import NLE +from sbijax.nn import make_maf + + +def test_snl(prior_simulator_tuple): + y_observed = jnp.array([-1.0, 1.0]) + snl = NLE(prior_simulator_tuple, make_maf(2)) + data, params = None, {} + for i in range(2): + data, _ = snl.simulate_data_and_possibly_append( + jr.PRNGKey(1), + params=params, + observable=y_observed, + data=data, + n_simulations=100, + n_chains=2, + n_samples=200, + n_warmup=100, + ) + params, info = snl.fit(jr.PRNGKey(2), data=data, n_iter=2) + _ = snl.sample_posterior( + jr.PRNGKey(3), + params, + y_observed, + n_chains=2, + n_samples=200, + n_warmup=100, + ) + + +def test_simulate_data_from_posterior_fail(prior_simulator_tuple): + snl = NLE(prior_simulator_tuple, make_maf(2)) + n = 100 + + data, _ = snl.simulate_data(jr.PRNGKey(1), n_simulations=n) + params, _ = snl.fit(jr.PRNGKey(2), data=data, n_iter=10) + with pytest.raises(ValueError): + snl.simulate_data(jr.PRNGKey(3), n_simulations=n, params=params) diff --git a/sbijax/_src/nn/consistency_model.py b/sbijax/_src/nn/make_consistency_model.py similarity index 97% rename from sbijax/_src/nn/consistency_model.py rename to sbijax/_src/nn/make_consistency_model.py index 4c54296..14d5f10 100644 --- a/sbijax/_src/nn/consistency_model.py +++ b/sbijax/_src/nn/make_consistency_model.py @@ -5,9 +5,9 @@ import jax from jax import numpy as jnp -from sbijax._src.nn.continuous_normalizing_flow import _ResnetBlock +__all__ = ["ConsistencyModel", "make_cm"] -__all__ = ["ConsistencyModel", "make_consistency_model"] +from sbijax._src.nn.make_resnet import _ResnetBlock # ruff: noqa: PLR0913,D417 @@ -163,7 +163,7 @@ def _c_out(self, time): # ruff: noqa: PLR0913 -def make_consistency_model( +def make_cm( n_dimension: int, n_layers: int = 2, hidden_size: int = 64, diff --git a/sbijax/_src/nn/continuous_normalizing_flow.py b/sbijax/_src/nn/make_continuous_flow.py similarity index 80% rename from sbijax/_src/nn/continuous_normalizing_flow.py rename to sbijax/_src/nn/make_continuous_flow.py index 1c4162e..d96389a 100644 --- a/sbijax/_src/nn/continuous_normalizing_flow.py +++ b/sbijax/_src/nn/make_continuous_flow.py @@ -4,14 +4,15 @@ import haiku as hk import jax from jax import numpy as jnp -from jax.nn import glu from scipy import integrate -__all__ = ["CCNF", "make_ccnf"] +__all__ = ["CNF", "make_cnf"] + +from sbijax._src.nn.make_resnet import _ResnetBlock # ruff: noqa: PLR0913,D417 -class CCNF(hk.Module): +class CNF(hk.Module): """Conditional continuous normalizing flow. Args: @@ -94,44 +95,7 @@ def vector_field(self, theta, time, context, **kwargs): # pylint: disable=too-many-arguments -class _ResnetBlock(hk.Module): - """A block for a 1d residual network.""" - - def __init__( - self, - hidden_size: int, - activation: Callable = jax.nn.relu, - dropout_rate: float = 0.2, - do_batch_norm: bool = False, - batch_norm_decay: float = 0.1, - ): - super().__init__() - self.hidden_size = hidden_size - self.activation = activation - self.do_batch_norm = do_batch_norm - self.dropout_rate = dropout_rate - self.batch_norm_decay = batch_norm_decay - - def __call__(self, inputs, context, is_training=False): - outputs = inputs - if self.do_batch_norm: - outputs = hk.BatchNorm(True, True, self.batch_norm_decay)( - outputs, is_training=is_training - ) - outputs = hk.Linear(self.hidden_size)(outputs) - outputs = self.activation(outputs) - if is_training: - outputs = hk.dropout( - rng=hk.next_rng_key(), rate=self.dropout_rate, x=outputs - ) - outputs = hk.Linear(self.hidden_size)(outputs) - context_proj = hk.Linear(inputs.shape[-1])(context) - outputs = glu(jnp.concatenate([outputs, context_proj], axis=-1)) - return outputs + inputs - - -# pylint: disable=too-many-arguments -class _CCNFResnet(hk.Module): +class _CNFResnet(hk.Module): """A simplified 1-d residual network.""" def __init__( @@ -182,7 +146,7 @@ def __call__(self, theta, time, context, is_training=False, **kwargs): # ruff: noqa: PLR0913 -def make_ccnf( +def make_cnf( n_dimension: int, n_layers: int = 2, hidden_size: int = 64, @@ -210,7 +174,7 @@ def make_ccnf( @hk.transform def _flow(method, **kwargs): - nn = _CCNFResnet( + nn = _CNFResnet( n_layers=n_layers, n_dimension=n_dimension, hidden_size=hidden_size, diff --git a/sbijax/_src/nn/make_flow.py b/sbijax/_src/nn/make_flow.py new file mode 100644 index 0000000..257acc7 --- /dev/null +++ b/sbijax/_src/nn/make_flow.py @@ -0,0 +1,280 @@ +from collections.abc import Iterable +from typing import Callable, Optional + +import distrax +import haiku as hk +import jax +from jax import numpy as jnp +from surjectors import ( + AffineMaskedAutoregressiveInferenceFunnel, + Chain, + MaskedAutoregressive, + MaskedCoupling, + MaskedCouplingInferenceFunnel, + Permutation, + TransformedDistribution, +) +from surjectors.nn import MADE +from surjectors.nn import make_mlp as surjectors_mlp +from surjectors.util import make_alternating_binary_mask, unstack + + +# ruff: noqa: PLR0913 +def make_maf( + n_dimension: int, + n_layers: Optional[int] = 5, + n_layer_dimensions: Optional[Iterable[int]] = None, + hidden_sizes: Iterable[int] = (64, 64), + activation: Callable = jax.nn.tanh, +): + """Create an affine (surjective) masked autoregressive flow. + + The MAFs use `n_layers` layers and are parameterized using MADE networks + with `hidden_sizes` neurons per layer. For each dimensionality reducing + layer, a conditional Gaussian density is used that uses the same number of + layer and nodes per layers as `hidden_sizes`. The argument + `n_layer_dimensions` determines which layer is dimensionality-preserving + or -reducing. For example, for `n_layer_dimensions=(5, 5, 3, 3)` and + `n_dimension=5`, the third layer would reduce the dimensionality by two + and use a surjection layer. THe other layers are dimensionality-preserving. + + Args: + n_dimension: a list of integers that determine the dimensionality + of each flow layer + n_layers: number of layers + n_layer_dimensions: list of integers that determine if a layer is + dimensionality-preserving or -reducing + hidden_sizes: sizes of hidden layers for each normalizing flow + activation: a jax activation function + + Examples: + >>> make_maf(10, n_layer_dimensions=(10, 10, 5, 5, 5)) + + Returns: + a (surjective) normalizing flow model + """ + if isinstance(n_layers, int) and n_layer_dimensions is not None: + raise ValueError( + "provide only either of 'n_layers'/'n_layer_dimensions'" + ) + if isinstance(n_layers, int): + n_layer_dimensions = [n_dimension] * n_layers + + return _make_maf( + n_dimension=n_dimension, + n_layer_dimensions=n_layer_dimensions, + hidden_sizes=hidden_sizes, + activation=activation, + ) + + +def _make_maf( + n_dimension, + n_layer_dimensions, + hidden_sizes, + activation, +): + def _bijector_fn(params): + means, log_scales = unstack(params, -1) + return distrax.ScalarAffine(means, jnp.exp(log_scales)) + + def _decoder_fn(n_dim, hidden_sizes): + decoder_net = surjectors_mlp( + hidden_sizes + [n_dim * 2], + w_init=hk.initializers.TruncatedNormal(stddev=0.001), + ) + + def _fn(z): + params = decoder_net(z) + mu, log_scale = jnp.split(params, 2, -1) + return distrax.Independent( + distrax.Normal(mu, jnp.exp(log_scale)), 1 + ) + + return _fn + + @hk.without_apply_rng + @hk.transform + def _flow(method, **kwargs): + layers = [] + order = jnp.arange(n_dimension) + curr_dim = n_dimension + for i, n_dim_curr_layer in enumerate(n_layer_dimensions): + # layer is dimensionality preserving + if n_dim_curr_layer == curr_dim: + layer = MaskedAutoregressive( + bijector_fn=_bijector_fn, + conditioner=MADE( + n_dim_curr_layer, + list(hidden_sizes) + [n_dim_curr_layer * 2], + 2, + w_init=hk.initializers.TruncatedNormal(0.001), + b_init=jnp.zeros, + activation=activation, + ), + ) + order = order[::-1] + elif n_dim_curr_layer < curr_dim: + n_latent = n_dim_curr_layer + layer = AffineMaskedAutoregressiveInferenceFunnel( + n_latent, + _decoder_fn(curr_dim - n_latent, list(hidden_sizes)), + conditioner=MADE( + n_latent, + list(hidden_sizes) + [n_dim_curr_layer * 2], + 2, + w_init=hk.initializers.TruncatedNormal(0.001), + b_init=jnp.zeros, + activation=jax.nn.tanh, + ), + ) + curr_dim = n_latent + order = order[::-1] + order = order[:curr_dim] - jnp.min(order[:curr_dim]) + else: + raise ValueError( + f"n_dimension at layer {i} is layer than the dimension of" + f" the following layer {i + 1}" + ) + layers.append(layer) + layers.append(Permutation(order, 1)) + chain = Chain(layers[:-1]) + + base_distribution = distrax.Independent( + distrax.Normal(jnp.zeros(n_dimension), jnp.ones(n_dimension)), + 1, + ) + td = TransformedDistribution(base_distribution, chain) + return td(method, **kwargs) + + return _flow + + +# ruff: noqa: PLR0913 +def make_spf( + n_dimension: int, + range_min: float, + range_max: float, + n_layers: Optional[int] = 5, + n_layer_dimensions: Optional[Iterable[int]] = None, + hidden_sizes: Iterable[int] = (64, 64), + activation: Callable = jax.nn.tanh, +): + """Create a rational-quadratic (surjective) spline coupling flow. + + The MAFs use `n_layers` layers and are parameterized using MADE networks + with `hidden_sizes` neurons per layer. For each dimensionality reducing + layer, a conditional Gaussian density is used that uses the same number of + layer and nodes per layers as `hidden_sizes`. The argument + `n_layer_dimensions` determines which layer is dimensionality-preserving + or -reducing. For example, for `n_layer_dimensions=(5, 5, 3, 3)` and + `n_dimension=5`, the third layer would reduce the dimensionality by two + and use a surjection layer. THe other layers are dimensionality-preserving. + + Args: + n_dimension: a list of integers that determine the dimensionality + of each flow layer + range_min: minimum range on which the spline is defined + range_max: maximum range on which the spline is defined + n_layers: number of layers + n_layer_dimensions: list of integers that determine if a layer is + dimensionality-preserving or -reducing + hidden_sizes: sizes of hidden layers for each normalizing flow + activation: a jax activation function + + Examples: + >>> make_spf(10, n_layer_dimensions=(10, 10, 5, 5, 5)) + + Returns: + a (surjective) normalizing flow model + """ + if isinstance(n_layers, int) and n_layer_dimensions is not None: + raise ValueError( + "provide only either of 'n_layers'/'n_layer_dimensions'" + ) + if isinstance(n_layers, int): + n_layer_dimensions = [n_dimension] * n_layers + + return _make_spf( + n_dimension=n_dimension, + range_min=range_min, + range_max=range_max, + n_layer_dimensions=n_layer_dimensions, + hidden_sizes=hidden_sizes, + activation=activation, + ) + + +def _make_spf( + n_dimension, + n_layer_dimensions, + range_min, + range_max, + hidden_sizes, + activation, +): + def _bijector_fn(params): + return distrax.RationalQuadraticSpline( + params, range_min=range_min, range_max=range_max + ) + + def _decoder_fn(dims): + def fn(z): + params = surjectors_mlp(dims, activation=activation)(z) + mu, log_scale = jnp.split(params, 2, -1) + return distrax.Independent(distrax.Normal(mu, jnp.exp(log_scale))) + + return fn + + @hk.without_apply_rng + @hk.transform + def _flow(method, **kwargs): + layers = [] + order = jnp.arange(n_dimension) + curr_dim = n_dimension + for i, n_dim_curr_layer in enumerate(n_layer_dimensions): + # layer is dimensionality preserving + if n_dim_curr_layer == curr_dim: + layer = MaskedCoupling( + mask=make_alternating_binary_mask(curr_dim, i % 2 == 0), + conditioner=surjectors_mlp( + list(hidden_sizes) + [2 * curr_dim], + activation=activation, + ), + bijector_fn=_bijector_fn, + ) + order = order[::-1] + # layer is dimensionality reducing + elif n_dim_curr_layer < curr_dim: + n_latent = n_dim_curr_layer + layer = MaskedCouplingInferenceFunnel( + n_keep=n_latent, + decoder=_decoder_fn( + list(hidden_sizes) + [2 * (curr_dim - n_latent)] + ), + conditioner=surjectors_mlp( + list(hidden_sizes) + [2 * curr_dim], + activation=activation, + ), + bijector_fn=_bijector_fn, + ) + curr_dim = n_latent + order = order[::-1] + order = order[:curr_dim] - jnp.min(order[:curr_dim]) + else: + raise ValueError( + f"n_dimension at layer {i} is layer than the dimension of" + f" the following layer {i + 1}" + ) + layers.append(layer) + layers.append(Permutation(order, 1)) + chain = Chain(layers[:-1]) + + base_distribution = distrax.Independent( + distrax.Normal(jnp.zeros(n_dimension), jnp.ones(n_dimension)), + 1, + ) + td = TransformedDistribution(base_distribution, chain) + return td(method, **kwargs) + + return _flow diff --git a/sbijax/_src/nn/make_flows.py b/sbijax/_src/nn/make_flows.py deleted file mode 100644 index 6365fc7..0000000 --- a/sbijax/_src/nn/make_flows.py +++ /dev/null @@ -1,180 +0,0 @@ -from collections.abc import Iterable -from typing import Callable - -import distrax -import haiku as hk -import jax -from jax import numpy as jnp -from surjectors import ( - AffineMaskedAutoregressiveInferenceFunnel, - Chain, - MaskedAutoregressive, - Permutation, - TransformedDistribution, -) -from surjectors.nn import MADE, make_mlp -from surjectors.util import unstack - - -def _bijector_fn(params): - means, log_scales = unstack(params, -1) - return distrax.ScalarAffine(means, jnp.exp(log_scales)) - - -def _decoder_fn(n_dim, hidden_size): - decoder_net = make_mlp( - hidden_size + [n_dim * 2], - w_init=hk.initializers.TruncatedNormal(stddev=0.001), - ) - - def _fn(z): - params = decoder_net(z) - mu, log_scale = jnp.split(params, 2, -1) - return distrax.Independent(distrax.Normal(mu, jnp.exp(log_scale)), 1) - - return _fn - - -# pylint: disable=too-many-arguments -def make_affine_maf( - n_dimension: int, - n_layers: int = 5, - hidden_sizes: Iterable[int] = (64, 64), - activation: Callable = jax.nn.tanh, -): - """Create an affine masked autoregressive flow. - - The MAFs use `n_layers` layers and are parameterized using MADE networks - with `hidden_sizes` neurons per layer. - - Args: - n_dimension: dimensionality of data - n_layers: number of normalizing flow layers - hidden_sizes: sizes of hidden layers for each normalizing flow. E.g., - when the hidden sizes are a tuple (64, 64), then each maf layer - uses a MADE with two layers of size 64 each - activation: a jax activation function - - Returns: - a normalizing flow model - """ - - @hk.without_apply_rng - @hk.transform - def _flow(method, **kwargs): - layers = [] - order = jnp.arange(n_dimension) - for _ in range(n_layers): - layer = MaskedAutoregressive( - bijector_fn=_bijector_fn, - conditioner=MADE( - n_dimension, - list(hidden_sizes) + [n_dimension * 2], - 2, - w_init=hk.initializers.TruncatedNormal(0.001), - b_init=jnp.zeros, - activation=activation, - ), - ) - order = order[::-1] - layers.append(layer) - layers.append(Permutation(order, 1)) - chain = Chain(layers[:-1]) - - base_distribution = distrax.Independent( - distrax.Normal(jnp.zeros(n_dimension), jnp.ones(n_dimension)), - 1, - ) - td = TransformedDistribution(base_distribution, chain) - return td(method, **kwargs) - - return _flow - - -def make_surjective_affine_maf( - n_dimension: int, - n_layer_dimensions: Iterable[int], - hidden_sizes: Iterable[int] = (64, 64), - activation: Callable = jax.nn.tanh, -): - """Create a surjective affine masked autoregressive flow. - - The MAFs use `n_layers` layers and are parameterized using MADE networks - with `hidden_sizes` neurons per layer. For each dimensionality reducing - layer, a conditional Gaussian density is used that uses the same number of - layer and nodes per layers as `hidden_sizes`. The argument - `n_layer_dimensions` determines which layer is dimensionality-preserving - or -reducing. For example, for `n_layer_dimensions=(5, 5, 3, 3)` and - `n_dimension=5`, the third layer would reduce the dimensionality by two - and use a surjection layer. THe other layers are dimensionality-preserving. - - Args: - n_dimension: a list of integers that determine the dimensionality - of each flow layer - n_layer_dimensions: list of integers that determine if a layer is - dimensionality-preserving or -reducing - hidden_sizes: sizes of hidden layers for each normalizing flow - activation: a jax activation function - - Examples: - >>> make_surjective_affine_maf(10, (10, 10, 5, 5, 5)) - - Returns: - a surjective normalizing flow model - """ - - @hk.without_apply_rng - @hk.transform - def _flow(method, **kwargs): - layers = [] - order = jnp.arange(n_dimension) - curr_dim = n_dimension - for i, n_dim_curr_layer in enumerate(n_layer_dimensions): - # layer is dimensionality preserving - if n_dim_curr_layer == curr_dim: - layer = MaskedAutoregressive( - bijector_fn=_bijector_fn, - conditioner=MADE( - n_dim_curr_layer, - list(hidden_sizes) + [n_dim_curr_layer * 2], - 2, - w_init=hk.initializers.TruncatedNormal(0.001), - b_init=jnp.zeros, - activation=activation, - ), - ) - order = order[::-1] - elif n_dim_curr_layer < curr_dim: - n_latent = n_dim_curr_layer - layer = AffineMaskedAutoregressiveInferenceFunnel( - n_latent, - _decoder_fn(curr_dim - n_latent, list(hidden_sizes)), - conditioner=MADE( - n_latent, - list(hidden_sizes) + [n_dim_curr_layer * 2], - 2, - w_init=hk.initializers.TruncatedNormal(0.001), - b_init=jnp.zeros, - activation=jax.nn.tanh, - ), - ) - curr_dim = n_latent - order = order[::-1] - order = order[:curr_dim] - jnp.min(order[:curr_dim]) - else: - raise ValueError( - f"n_dimension at layer {i} is layer than the dimension of" - f" the following layer {i + 1}" - ) - layers.append(layer) - layers.append(Permutation(order, 1)) - chain = Chain(layers[:-1]) - - base_distribution = distrax.Independent( - distrax.Normal(jnp.zeros(n_dimension), jnp.ones(n_dimension)), - 1, - ) - td = TransformedDistribution(base_distribution, chain) - return td(method, **kwargs) - - return _flow diff --git a/sbijax/_src/nn/make_mdn.py b/sbijax/_src/nn/make_mdn.py new file mode 100644 index 0000000..eae9177 --- /dev/null +++ b/sbijax/_src/nn/make_mdn.py @@ -0,0 +1,60 @@ +from collections.abc import Iterable +from typing import Callable + +import haiku as hk +import jax +from jax import numpy as jnp +from tensorflow_probability.substrates.jax import distributions as tfd + + +# pylint: disable=too-many-arguments +def make_mdn( + n_dimension: int, + n_components: int, + hidden_sizes: Iterable[int] = (64, 64), + activation: Callable = jax.nn.relu, +): + """Create an affine masked autoregressive flow. + + The MAFs use `n_layers` layers and are parameterized using MADE networks + with `hidden_sizes` neurons per layer. + + Args: + n_dimension: dimensionality of data + n_components: number of mixture components + hidden_sizes: sizes of hidden layers for each normalizing flow. E.g., + when the hidden sizes are a tuple (64, 64), then each maf layer + uses a MADE with two layers of size 64 each + activation: a jax activation function + + Returns: + a normalizing flow model + """ + + @hk.without_apply_rng + @hk.transform + def mdn(method, **kwargs): + n = kwargs["x"].shape[0] + hidden = hk.nets.MLP( + hidden_sizes, activation=activation, activate_final=True + )(kwargs["x"]) + logits = hk.Linear(n_components)(hidden) + mu_sigma = hk.Linear(n_components * n_dimension * 2)(hidden) + mu, sigma = jnp.split(mu_sigma, 2, axis=-1) + + mixture = tfd.MixtureSameFamily( + tfd.Categorical(logits=logits), + tfd.MultivariateNormalDiag( + mu.reshape(n, n_components, n_dimension), + jnp.exp(sigma.reshape(n, n_components, n_dimension)), + ), + ) + if method == "sample": + return mixture.sample(seed=hk.next_rng_key()) + else: + return mixture.log_prob(kwargs["y"]) + + return mdn + + +make_mdn(2, 2) diff --git a/sbijax/_src/nn/make_mlp.py b/sbijax/_src/nn/make_mlp.py new file mode 100644 index 0000000..1c67892 --- /dev/null +++ b/sbijax/_src/nn/make_mlp.py @@ -0,0 +1,37 @@ +import haiku as hk +import jax +from jax import numpy as jnp + + +def make_mlp( + n_layers: int = 2, + hidden_size: int = 64, + activation=jax.nn.gelu, + w_init=hk.initializers.TruncatedNormal(stddev=0.01), + b_init=jnp.zeros, +): + """Create a MLP-based classifier network. + + Args: + n_layers: the number of hidden layers to be used + hidden_size: the size of each layer + activation: a JAX activation function + w_init: a haiku initializer + b_init: a haiku initializer + + Returns: + a transformable haiku neural network module + """ + + @hk.without_apply_rng + @hk.transform + def _net(inputs, **kwargs): + nn = hk.nets.MLP( + output_sizes=[hidden_size] * n_layers + [1], + w_init=w_init, + b_init=b_init, + activation=activation, + ) + return nn(inputs) + + return _net diff --git a/sbijax/_src/nn/make_snass_networks.py b/sbijax/_src/nn/make_nass_network.py similarity index 92% rename from sbijax/_src/nn/make_snass_networks.py rename to sbijax/_src/nn/make_nass_network.py index 81a6ea2..303e85b 100644 --- a/sbijax/_src/nn/make_snass_networks.py +++ b/sbijax/_src/nn/make_nass_network.py @@ -4,11 +4,11 @@ import haiku as hk import jax -from sbijax._src.nn.snass_net import SNASSNet -from sbijax._src.nn.snasss_net import SNASSSNet +from sbijax._src.nn.nass_net import NASSNet +from sbijax._src.nn.nasss_net import NASSSNet -def make_snass_net( +def make_nass_net( summary_net_dimensions: Iterable[int], critic_net_dimensions: Iterable[int], activation: Callable[[jax.Array], jax.Array] = jax.nn.relu, @@ -37,13 +37,13 @@ def _net(method, **kwargs): critic_net = hk.nets.MLP( output_sizes=critic_net_dimensions, activation=activation ) - net = SNASSNet(summary_net=summary_net, critic_net=critic_net) + net = NASSNet(summary_net=summary_net, critic_net=critic_net) return net(method, **kwargs) return _net -def make_snasss_net( +def make_nasss_net( summary_net_dimensions: Iterable[int], sec_summary_net_dimensions: Iterable[int], critic_net_dimensions: Iterable[int], @@ -81,7 +81,7 @@ def _net(method, **kwargs): critic_net = hk.nets.MLP( output_sizes=critic_net_dimensions, activation=activation ) - net = SNASSSNet( + net = NASSSNet( summary_net=summary_net, sec_summary_net=sec_summary_net, critic_net=critic_net, diff --git a/sbijax/_src/nn/make_resnet.py b/sbijax/_src/nn/make_resnet.py index 8bd2d12..3a3a043 100644 --- a/sbijax/_src/nn/make_resnet.py +++ b/sbijax/_src/nn/make_resnet.py @@ -2,6 +2,8 @@ import haiku as hk import jax +from jax import numpy as jnp +from jax._src.nn.functions import glu # pylint: disable=too-many-arguments @@ -23,7 +25,7 @@ def __init__( self.dropout_rate = dropout_rate self.batch_norm_decay = batch_norm_decay - def __call__(self, inputs, is_training=False): + def __call__(self, inputs, context=None, is_training=False): outputs = inputs if self.do_batch_norm: outputs = hk.BatchNorm(True, True, self.batch_norm_decay)( @@ -36,6 +38,9 @@ def __call__(self, inputs, is_training=False): rng=hk.next_rng_key(), rate=self.dropout_rate, x=outputs ) outputs = hk.Linear(self.hidden_size)(outputs) + if context is not None: + context_proj = hk.Linear(inputs.shape[-1])(context) + outputs = glu(jnp.concatenate([outputs, context_proj], axis=-1)) return outputs + inputs diff --git a/sbijax/_src/nn/snass_net.py b/sbijax/_src/nn/nass_net.py similarity index 96% rename from sbijax/_src/nn/snass_net.py rename to sbijax/_src/nn/nass_net.py index c712a55..d700b5f 100644 --- a/sbijax/_src/nn/snass_net.py +++ b/sbijax/_src/nn/nass_net.py @@ -7,8 +7,8 @@ # ruff: noqa: PLR0913,S101 -class SNASSNet(hk.Module): - """A network for SNASS.""" +class NASSNet(hk.Module): + """A network for NASS.""" def __init__( self, @@ -17,7 +17,7 @@ def __init__( summary_net: Callable = None, critic_net: Callable = None, ): - """Constructs a SNASSNet. + """Constructs a NASSNet. Can be used either by providing network dimensions or haiku modules. diff --git a/sbijax/_src/nn/snasss_net.py b/sbijax/_src/nn/nasss_net.py similarity index 95% rename from sbijax/_src/nn/snasss_net.py rename to sbijax/_src/nn/nasss_net.py index eb41718..13b2141 100644 --- a/sbijax/_src/nn/snasss_net.py +++ b/sbijax/_src/nn/nasss_net.py @@ -5,12 +5,12 @@ import jax from jax import numpy as jnp -from sbijax._src.nn.snass_net import SNASSNet +from sbijax._src.nn.nass_net import NASSNet # ruff: noqa: PLR0913,S101 -class SNASSSNet(SNASSNet): - """A network for SNASSS.""" +class NASSSNet(NASSNet): + """A network for NASSS.""" def __init__( self, diff --git a/sbijax/_src/snp.py b/sbijax/_src/npe.py similarity index 93% rename from sbijax/_src/snp.py rename to sbijax/_src/npe.py index 888f952..b07b778 100644 --- a/sbijax/_src/snp.py +++ b/sbijax/_src/npe.py @@ -7,14 +7,16 @@ from jax import numpy as jnp from jax import random as jr from jax import scipy as jsp +from jax._src.flatten_util import ravel_pytree from tqdm import tqdm -from sbijax._src._sne_base import SNE +from sbijax._src._ne_base import NE +from sbijax._src.util.data import as_inference_data from sbijax._src.util.early_stopping import EarlyStopping # ruff: noqa: PLR0913 -class SNP(SNE): +class NPE(NE): """Sequential neural posterior estimation. Args: @@ -28,8 +30,8 @@ class SNP(SNE): Examples: >>> import distrax - >>> from sbijax import SNP - >>> from sbijax.nn import make_affine_maf + >>> from sbijax import NPE + >>> from sbijax.nn import make_maf >>> >>> prior = distrax.Normal(0.0, 1.0) >>> s = lambda seed, theta: distrax.Normal(theta, 1.0).sample(seed=seed) @@ -277,6 +279,7 @@ def sample_posterior( thetas = None n_curr = n_samples n_total_simulations_round = 0 + _, unravel_fn = ravel_pytree(self.prior_sampler_fn(seed=jr.PRNGKey(1))) while n_curr > 0: n_sim = jnp.minimum(200, jnp.maximum(200, n_curr)) n_total_simulations_round += n_sim @@ -288,16 +291,21 @@ def sample_posterior( sample_shape=(n_sim,), x=jnp.tile(observable, [n_sim, 1]), ) - proposal_probs = self.prior_log_density_fn(proposal) + proposal_probs = self.prior_log_density_fn( + jax.vmap(unravel_fn)(proposal) + ) proposal_accepted = proposal[jnp.isfinite(proposal_probs)] if thetas is None: thetas = proposal_accepted else: thetas = jnp.vstack([thetas, proposal_accepted]) n_curr -= proposal_accepted.shape[0] - self.n_total_simulations += n_total_simulations_round - return ( - thetas[:n_samples], - thetas.shape[0] / n_total_simulations_round, + + ess = float(thetas.shape[0] / n_total_simulations_round) + thetas = jax.tree_map( + lambda x: x.reshape(1, *x.shape), + jax.vmap(unravel_fn)(thetas[:n_samples]), ) + inference_data = as_inference_data(thetas, jnp.squeeze(observable)) + return inference_data, ess diff --git a/sbijax/_src/npe_test.py b/sbijax/_src/npe_test.py new file mode 100644 index 0000000..b82dc09 --- /dev/null +++ b/sbijax/_src/npe_test.py @@ -0,0 +1,32 @@ +# pylint: skip-file + +from jax import numpy as jnp, random as jr + +from sbijax import NPE +from sbijax.nn import make_maf + + +def test_npe(prior_simulator_tuple): + y_observed = jnp.array([-1.0, 1.0]) + snp = NPE(prior_simulator_tuple, make_maf(2)) + data, params = None, {} + for i in range(2): + data, _ = snp.simulate_data_and_possibly_append( + jr.PRNGKey(1), + params=params, + observable=y_observed, + data=data, + n_simulations=100, + n_chains=2, + n_samples=200, + n_warmup=100, + ) + params, info = snp.fit(jr.PRNGKey(3), data=data, n_iter=2) + _ = snp.sample_posterior( + jr.PRNGKey(3), + params, + y_observed, + n_chains=2, + n_samples=200, + n_warmup=100, + ) diff --git a/sbijax/_src/snr.py b/sbijax/_src/nre.py similarity index 92% rename from sbijax/_src/snr.py rename to sbijax/_src/nre.py index ad986b1..dbdee5e 100644 --- a/sbijax/_src/snr.py +++ b/sbijax/_src/nre.py @@ -12,11 +12,13 @@ from jax import numpy as jnp from jax import random as jr from jax import scipy as jsp +from jax._src.flatten_util import ravel_pytree from tqdm import tqdm from sbijax._src import mcmc -from sbijax._src._sne_base import SNE -from sbijax._src.mcmc.diagnostics import mcmc_diagnostics +from sbijax._src._ne_base import NE +from sbijax._src.mcmc.util import mcmc_diagnostics +from sbijax._src.util.data import as_inference_data from sbijax._src.util.early_stopping import EarlyStopping @@ -87,21 +89,21 @@ def _loss(params, rng_key, model, gamma, num_classes, **batch): # ruff: noqa: PLR0913, -class SNR(SNE): +class NRE(NE): r"""Sequential (contrastive) neural ratio estimation. Args: model_fns: a tuple of tuples. The first element is a tuple that - consists of functions to sample and evaluate the - log-probability of a data point. The second element is a - simulator function. + consists of functions to sample and evaluate the + log-probability of a data point. The second element is a + simulator function. classifier: a neural network for classification num_classes: number of classes to classify against gamma: relative weight of classes Examples: >>> import distrax - >>> from sbijax import SNR + >>> from sbijax import NRE >>> from sbijax.nn import make_resnet >>> >>> prior = distrax.Normal(0.0, 1.0) @@ -148,7 +150,8 @@ def fit( n_iter: int = 1000, batch_size: int = 100, percentage_data_as_validation_set: float = 0.1, - n_early_stopping_patience: float = 10, + n_early_stopping_patience: int = 25, + n_early_stopping_delta=0.001, **kwargs, ): """Fit an SNR model. @@ -179,6 +182,7 @@ def fit( optimizer=optimizer, n_iter=n_iter, n_early_stopping_patience=n_early_stopping_patience, + n_early_stopping_delta=n_early_stopping_delta, ) return params, losses @@ -192,6 +196,7 @@ def _fit_model_single_round( optimizer, n_iter, n_early_stopping_patience, + n_early_stopping_delta, ): init_key, rng_key = jr.split(rng_key) params = self._init_params(init_key, **next(iter(train_iter))) @@ -209,7 +214,9 @@ def step(params, rng, state, **batch): return loss, new_params, new_state losses = np.zeros([n_iter, 2]) - early_stop = EarlyStopping(1e-3, n_early_stopping_patience) + early_stop = EarlyStopping( + n_early_stopping_delta, n_early_stopping_patience + ) best_params, best_loss = None, np.inf logging.info("training model") for i in tqdm(range(n_iter)): @@ -373,7 +380,8 @@ def _sample_posterior( def _joint_logdensity_fn(theta): lp_prior = self.prior_log_density_fn(theta) - theta = theta.reshape(observable.shape) + theta, _ = ravel_pytree(theta) + theta = theta.reshape(observable.shape[0], -1) lp = part(jnp.concatenate([observable, theta], axis=-1)) return jnp.sum(lp_prior) + jnp.sum(lp) @@ -386,7 +394,7 @@ def lp__(theta): else: def lp__(theta): - return _joint_logdensity_fn(**theta) + return _joint_logdensity_fn(theta) # take whatever sampler is or per default nuts sampler = kwargs.pop("sampler", "nuts") @@ -401,8 +409,8 @@ def lp__(theta): n_warmup=n_warmup, **kwargs, ) - chex.assert_shape(samples, [n_samples - n_warmup, n_chains, None]) - diagnostics = mcmc_diagnostics(samples) - samples = samples.reshape((n_samples - n_warmup) * n_chains, -1) - - return samples, diagnostics + for v in samples.values(): + chex.assert_shape(v, [n_chains, n_samples - n_warmup, None]) + inference_data = as_inference_data(samples, jnp.squeeze(observable)) + diagnostics = mcmc_diagnostics(inference_data) + return inference_data, diagnostics diff --git a/sbijax/_src/nre_test.py b/sbijax/_src/nre_test.py new file mode 100644 index 0000000..0bcb0d1 --- /dev/null +++ b/sbijax/_src/nre_test.py @@ -0,0 +1,32 @@ +# pylint: skip-file + +from jax import numpy as jnp, random as jr + +from sbijax import NRE +from sbijax.nn import make_mlp + + +def test_nre(prior_simulator_tuple): + y_observed = jnp.array([-1.0, 1.0]) + estim = NRE(prior_simulator_tuple, make_mlp()) + data, params = None, {} + for i in range(2): + data, _ = estim.simulate_data_and_possibly_append( + jr.PRNGKey(1), + params=params, + observable=y_observed, + data=data, + n_simulations=100, + n_chains=2, + n_samples=200, + n_warmup=100, + ) + params, info = estim.fit(jr.PRNGKey(2), data=data, n_iter=2) + _ = estim.sample_posterior( + jr.PRNGKey(3), + params, + y_observed, + n_chains=2, + n_samples=200, + n_warmup=100, + ) diff --git a/sbijax/_src/scmpe_test.py b/sbijax/_src/scmpe_test.py deleted file mode 100644 index 8f6a38e..0000000 --- a/sbijax/_src/scmpe_test.py +++ /dev/null @@ -1,60 +0,0 @@ -# pylint: skip-file - -import distrax -import haiku as hk -from jax import numpy as jnp - -from sbijax import SCMPE -from sbijax.nn import make_consistency_model - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.MultivariateNormalDiag(theta, 0.1 * jnp.ones_like(theta)) - y = p.sample(seed=seed) - return y - - -def log_density_fn(theta, y): - prior = distrax.Uniform(jnp.full(2, -3.0), jnp.full(2, 3.0)) - likelihood = distrax.MultivariateNormalDiag( - theta, 0.1 * jnp.ones_like(theta) - ) - - lp = jnp.sum(prior.log_prob(theta)) + jnp.sum(likelihood.log_prob(y)) - return lp - - -def test_scmpe(): - rng_seq = hk.PRNGSequence(0) - y_observed = jnp.array([-1.0, 1.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - estim = SCMPE(fns, make_consistency_model(2)) - data, params = None, {} - for i in range(2): - data, _ = estim.simulate_data_and_possibly_append( - next(rng_seq), - params=params, - observable=y_observed, - data=data, - n_simulations=100, - n_chains=2, - n_samples=200, - n_warmup=100, - ) - params, info = estim.fit(next(rng_seq), data=data, n_iter=2) - _ = estim.sample_posterior( - next(rng_seq), - params, - y_observed, - n_chains=2, - n_samples=200, - n_warmup=100, - ) diff --git a/sbijax/_src/sfmpe_test.py b/sbijax/_src/sfmpe_test.py deleted file mode 100644 index 102ca07..0000000 --- a/sbijax/_src/sfmpe_test.py +++ /dev/null @@ -1,60 +0,0 @@ -# pylint: skip-file - -import distrax -import haiku as hk -from jax import numpy as jnp - -from sbijax import SFMPE -from sbijax.nn import make_ccnf - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.MultivariateNormalDiag(theta, 0.1 * jnp.ones_like(theta)) - y = p.sample(seed=seed) - return y - - -def log_density_fn(theta, y): - prior = distrax.Uniform(jnp.full(2, -3.0), jnp.full(2, 3.0)) - likelihood = distrax.MultivariateNormalDiag( - theta, 0.1 * jnp.ones_like(theta) - ) - - lp = jnp.sum(prior.log_prob(theta)) + jnp.sum(likelihood.log_prob(y)) - return lp - - -def test_sfmpe(): - rng_seq = hk.PRNGSequence(0) - y_observed = jnp.array([-1.0, 1.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - estim = SFMPE(fns, make_ccnf(2)) - data, params = None, {} - for i in range(2): - data, _ = estim.simulate_data_and_possibly_append( - next(rng_seq), - params=params, - observable=y_observed, - data=data, - n_simulations=100, - n_chains=2, - n_samples=200, - n_warmup=100, - ) - params, info = estim.fit(next(rng_seq), data=data, n_iter=2) - _ = estim.sample_posterior( - next(rng_seq), - params, - y_observed, - n_chains=2, - n_samples=200, - n_warmup=100, - ) diff --git a/sbijax/_src/snass_test.py b/sbijax/_src/snass_test.py deleted file mode 100644 index c4debc6..0000000 --- a/sbijax/_src/snass_test.py +++ /dev/null @@ -1,62 +0,0 @@ -# pylint: skip-file - -import distrax -import haiku as hk -from jax import numpy as jnp - -from sbijax import SNASS -from sbijax.nn import make_affine_maf, make_snass_net - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.MultivariateNormalDiag(theta, 0.1 * jnp.ones_like(theta)) - y = p.sample(seed=seed) - return y - - -def log_density_fn(theta, y): - prior = distrax.Uniform(jnp.full(2, -3.0), jnp.full(2, 3.0)) - likelihood = distrax.MultivariateNormalDiag( - theta, 0.1 * jnp.ones_like(theta) - ) - - lp = jnp.sum(prior.log_prob(theta)) + jnp.sum(likelihood.log_prob(y)) - return lp - - -def test_snass(): - rng_seq = hk.PRNGSequence(0) - y_observed = jnp.array([-1.0, 1.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - estim = SNASS( - fns, make_affine_maf(1, 2, (32, 32)), make_snass_net((32, 1), (32, 1)) - ) - data, params = None, {} - for i in range(2): - data, _ = estim.simulate_data_and_possibly_append( - next(rng_seq), - params=params, - observable=y_observed, - data=data, - n_simulations=100, - n_chains=2, - n_samples=200, - n_warmup=100, - ) - params, info = estim.fit(next(rng_seq), data=data, n_iter=2) - _ = estim.sample_posterior( - next(rng_seq), - params, - y_observed, - n_chains=2, - n_samples=200, - n_warmup=100, - ) diff --git a/sbijax/_src/snasss_test.py b/sbijax/_src/snasss_test.py deleted file mode 100644 index b00e646..0000000 --- a/sbijax/_src/snasss_test.py +++ /dev/null @@ -1,66 +0,0 @@ -# pylint: skip-file - -import distrax -import haiku as hk -from jax import numpy as jnp - -from sbijax import SNASSS -from sbijax._src.nn.make_snass_networks import make_snasss_net -from sbijax.nn import make_affine_maf - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.MultivariateNormalDiag(theta, 0.1 * jnp.ones_like(theta)) - y = p.sample(seed=seed) - y = jnp.repeat(y, 5, axis=1) - return y - - -def log_density_fn(theta, y): - prior = distrax.Uniform(jnp.full(2, -3.0), jnp.full(2, 3.0)) - likelihood = distrax.MultivariateNormalDiag( - theta, 0.1 * jnp.ones_like(theta) - ) - - lp = jnp.sum(prior.log_prob(theta)) + jnp.sum(likelihood.log_prob(y)) - return lp - - -def test_snasss(): - rng_seq = hk.PRNGSequence(0) - y_observed = jnp.repeat(jnp.array([-1.0, 1.0]).reshape(-1, 2), 5, axis=1) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - estim = SNASSS( - fns, - make_affine_maf(5, 2, (32, 32)), - make_snasss_net((32, 5), (32, 1), (32, 1)), - ) - data, params = None, {} - for i in range(2): - data, _ = estim.simulate_data_and_possibly_append( - next(rng_seq), - params=params, - observable=y_observed, - data=data, - n_simulations=100, - n_chains=2, - n_samples=200, - n_warmup=100, - ) - params, info = estim.fit(next(rng_seq), data=data, n_iter=2) - _ = estim.sample_posterior( - next(rng_seq), - params, - y_observed, - n_chains=2, - n_samples=200, - n_warmup=100, - ) diff --git a/sbijax/_src/snl_test.py b/sbijax/_src/snl_test.py deleted file mode 100644 index e8fd056..0000000 --- a/sbijax/_src/snl_test.py +++ /dev/null @@ -1,106 +0,0 @@ -# pylint: skip-file -import distrax -import haiku as hk -import pytest -from jax import numpy as jnp -from jax import random as jr -from surjectors import Chain, MaskedCoupling, TransformedDistribution -from surjectors.nn import make_mlp -from surjectors.util import make_alternating_binary_mask - -from sbijax._src.snl import SNL - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.MultivariateNormalDiag(theta, 0.1 * jnp.ones_like(theta)) - y = p.sample(seed=seed) - return y - - -def log_density_fn(theta, y): - prior = distrax.Uniform(jnp.full(2, -3.0), jnp.full(2, 3.0)) - likelihood = distrax.MultivariateNormalDiag( - theta, 0.1 * jnp.ones_like(theta) - ) - - lp = jnp.sum(prior.log_prob(theta)) + jnp.sum(likelihood.log_prob(y)) - return lp - - -def make_model(dim): - def _bijector_fn(params): - means, log_scales = jnp.split(params, 2, -1) - return distrax.ScalarAffine(means, jnp.exp(log_scales)) - - def _flow(method, **kwargs): - layers = [] - for i in range(2): - mask = make_alternating_binary_mask(dim, i % 2 == 0) - layer = MaskedCoupling( - mask=mask, - bijector_fn=_bijector_fn, - conditioner=make_mlp([8, 8, dim * 2]), - ) - layers.append(layer) - chain = Chain(layers) - base_distribution = distrax.Independent( - distrax.Normal(jnp.zeros(dim), jnp.ones(dim)), - 1, - ) - td = TransformedDistribution(base_distribution, chain) - return td(method, **kwargs) - - td = hk.transform(_flow) - td = hk.without_apply_rng(td) - return td - - -def test_snl(): - rng_seq = hk.PRNGSequence(0) - y_observed = jnp.array([-1.0, 1.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - snl = SNL(fns, make_model(2)) - data, params = None, {} - for i in range(2): - data, _ = snl.simulate_data_and_possibly_append( - next(rng_seq), - params=params, - observable=y_observed, - data=data, - n_simulations=100, - n_chains=2, - n_samples=200, - n_warmup=100, - ) - params, info = snl.fit(next(rng_seq), data=data, n_iter=2) - _ = snl.sample_posterior( - next(rng_seq), - params, - y_observed, - n_chains=2, - n_samples=200, - n_warmup=100, - ) - - -def test_simulate_data_from_posterior_fail(): - rng_seq = hk.PRNGSequence(0) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - snl = SNL(fns, make_model(2)) - n = 100 - - data, _ = snl.simulate_data(jr.PRNGKey(1), n_simulations=n) - params, _ = snl.fit(next(rng_seq), data=data, n_iter=10) - with pytest.raises(ValueError): - snl.simulate_data(jr.PRNGKey(2), n_simulations=n, params=params) diff --git a/sbijax/_src/snp_test.py b/sbijax/_src/snp_test.py deleted file mode 100644 index cf39560..0000000 --- a/sbijax/_src/snp_test.py +++ /dev/null @@ -1,89 +0,0 @@ -# pylint: skip-file - -import distrax -import haiku as hk -from jax import numpy as jnp -from surjectors import Chain, MaskedCoupling, TransformedDistribution -from surjectors.nn import make_mlp -from surjectors.util import make_alternating_binary_mask - -from sbijax._src.snp import SNP - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.MultivariateNormalDiag(theta, 0.1 * jnp.ones_like(theta)) - y = p.sample(seed=seed) - return y - - -def log_density_fn(theta, y): - prior = distrax.Uniform(jnp.full(2, -3.0), jnp.full(2, 3.0)) - likelihood = distrax.MultivariateNormalDiag( - theta, 0.1 * jnp.ones_like(theta) - ) - - lp = jnp.sum(prior.log_prob(theta)) + jnp.sum(likelihood.log_prob(y)) - return lp - - -def make_model(dim): - def _bijector_fn(params): - means, log_scales = jnp.split(params, 2, -1) - return distrax.ScalarAffine(means, jnp.exp(log_scales)) - - def _flow(method, **kwargs): - layers = [] - for i in range(2): - mask = make_alternating_binary_mask(dim, i % 2 == 0) - layer = MaskedCoupling( - mask=mask, - bijector_fn=_bijector_fn, - conditioner=make_mlp([8, 8, dim * 2]), - ) - layers.append(layer) - chain = Chain(layers) - base_distribution = distrax.Independent( - distrax.Normal(jnp.zeros(dim), jnp.ones(dim)), - 1, - ) - td = TransformedDistribution(base_distribution, chain) - return td(method, **kwargs) - - td = hk.transform(_flow) - return td - - -def test_snp(): - rng_seq = hk.PRNGSequence(0) - y_observed = jnp.array([-1.0, 1.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - snp = SNP(fns, make_model(2)) - data, params = None, {} - for i in range(2): - data, _ = snp.simulate_data_and_possibly_append( - next(rng_seq), - params=params, - observable=y_observed, - data=data, - n_simulations=100, - n_chains=2, - n_samples=200, - n_warmup=100, - ) - params, info = snp.fit(next(rng_seq), data=data, n_iter=2) - _ = snp.sample_posterior( - next(rng_seq), - params, - y_observed, - n_chains=2, - n_samples=200, - n_warmup=100, - ) diff --git a/sbijax/_src/snr_test.py b/sbijax/_src/snr_test.py deleted file mode 100644 index d215e3a..0000000 --- a/sbijax/_src/snr_test.py +++ /dev/null @@ -1,68 +0,0 @@ -# pylint: skip-file - -import distrax -import haiku as hk -from jax import numpy as jnp - -from sbijax import SNR - - -def prior_model_fns(): - p = distrax.Independent(distrax.Normal(jnp.zeros(2), jnp.ones(2)), 1) - return p.sample, p.log_prob - - -def simulator_fn(seed, theta): - p = distrax.MultivariateNormalDiag(theta, 0.1 * jnp.ones_like(theta)) - y = p.sample(seed=seed) - return y - - -def log_density_fn(theta, y): - prior = distrax.Uniform(jnp.full(2, -3.0), jnp.full(2, 3.0)) - likelihood = distrax.MultivariateNormalDiag( - theta, 0.1 * jnp.ones_like(theta) - ) - - lp = jnp.sum(prior.log_prob(theta)) + jnp.sum(likelihood.log_prob(y)) - return lp - - -def make_model(): - @hk.without_apply_rng - @hk.transform - def _mlp(inputs, **kwargs): - return hk.nets.MLP([64, 64, 1])(inputs) - - return _mlp - - -def test_snp(): - rng_seq = hk.PRNGSequence(0) - y_observed = jnp.array([-1.0, 1.0]) - - prior_simulator_fn, prior_logdensity_fn = prior_model_fns() - fns = (prior_simulator_fn, prior_logdensity_fn), simulator_fn - - estim = SNR(fns, make_model()) - data, params = None, {} - for i in range(2): - data, _ = estim.simulate_data_and_possibly_append( - next(rng_seq), - params=params, - observable=y_observed, - data=data, - n_simulations=100, - n_chains=2, - n_samples=200, - n_warmup=100, - ) - params, info = estim.fit(next(rng_seq), data=data, n_iter=2) - _ = estim.sample_posterior( - next(rng_seq), - params, - y_observed, - n_chains=2, - n_samples=200, - n_warmup=100, - ) diff --git a/sbijax/_src/util/data.py b/sbijax/_src/util/data.py index 1550ece..baf9216 100644 --- a/sbijax/_src/util/data.py +++ b/sbijax/_src/util/data.py @@ -1,6 +1,21 @@ +import arviz as az +import jax +import numpy as np from jax import numpy as jnp +from jax.tree_util import tree_flatten -from sbijax._src.util.dataloader import named_dataset + +def _tree_stack(trees): + leaves_list = [] + treedef_list = [] + for tree in trees: + leaves, treedef = tree_flatten(tree) + leaves_list.append(leaves) + treedef_list.append(treedef) + + grouped_leaves = zip(*leaves_list) + result_leaves = [jnp.vstack(leave) for leave in grouped_leaves] + return treedef_list[0].unflatten(result_leaves) def stack_data(data, also_data): @@ -17,4 +32,28 @@ def stack_data(data, also_data): return also_data if also_data is None: return data - return named_dataset(*[jnp.vstack([a, b]) for a, b in zip(data, also_data)]) + stacked = _tree_stack([data, also_data]) + return stacked + + +def as_inference_data(samples: dict[str, jax.Array], observed: jax.Array): + inf = az.InferenceData( + posterior=az.dict_to_dataset( + samples, + coords={ + f"{k}_dim": np.arange(v.shape[-1]) for k, v in samples.items() + }, + dims={k: [f"{k}_dim"] for k in samples.keys()}, + ), + observed_data=az.dict_to_dataset({"y": observed}, default_dims=[]), + ) + return inf + + +def flatten(posterior): + posterior = posterior.to_dict() + posterior = { + k: jnp.array(v["data"]) for k, v in posterior["data_vars"].items() + } + posterior = {k: v.reshape(-1, v.shape[-1]) for k, v in posterior.items()} + return posterior diff --git a/sbijax/_src/util/dataloader.py b/sbijax/_src/util/dataloader.py index 70a1973..401e683 100644 --- a/sbijax/_src/util/dataloader.py +++ b/sbijax/_src/util/dataloader.py @@ -1,11 +1,11 @@ -from collections import namedtuple - +import jax.tree_util import tensorflow as tf from jax import Array from jax import numpy as jnp from jax import random as jr +from jax._src.flatten_util import ravel_pytree -named_dataset = namedtuple("named_dataset", "y theta") +from sbijax._src.util.types import PyTree # pylint: disable=missing-class-docstring,too-few-public-methods @@ -22,7 +22,7 @@ def __iter__(self): # pylint: disable=missing-function-docstring def as_batch_iterators( - rng_key: Array, data: named_dataset, batch_size, split, shuffle + rng_key: Array, data: PyTree, batch_size, split, shuffle ): """Create two data batch iterators from a data set. @@ -37,15 +37,16 @@ def as_batch_iterators( Returns: returns two iterators """ - n = data.y.shape[0] + n = data["y"].shape[0] n_train = int(n * split) if shuffle: idxs = jr.permutation(rng_key, jnp.arange(n)) - data = named_dataset(*[el[idxs] for _, el in enumerate(data)]) + data = jax.tree_util.tree_map(lambda x: x[idxs], data) + + y_train = jax.tree_util.tree_map(lambda x: x[:n_train], data) + y_val = jax.tree_util.tree_map(lambda x: x[n_train:], data) - y_train = named_dataset(*[el[:n_train] for el in data]) - y_val = named_dataset(*[el[n_train:] for el in data]) train_rng_key, val_rng_key = jr.split(rng_key) train_itr = as_batch_iterator(train_rng_key, y_train, batch_size, shuffle) @@ -72,6 +73,7 @@ def as_batched_numpy_iterator_from_tf( # hack, cause the tf stuff doesn't support jax keys :) max_int32 = jnp.iinfo(jnp.int32).max seed = jr.randint(rng_key, shape=(), minval=0, maxval=max_int32) + data = ( data.shuffle( 10 * batch_size, @@ -85,7 +87,7 @@ def as_batched_numpy_iterator_from_tf( # pylint: disable=missing-function-docstring -def as_batch_iterator(rng_key: Array, data: named_dataset, batch_size, shuffle): +def as_batch_iterator(rng_key: Array, data: PyTree, batch_size, shuffle): """Create a data batch iterator from a data set. Args: @@ -97,7 +99,18 @@ def as_batch_iterator(rng_key: Array, data: named_dataset, batch_size, shuffle): Returns: a tensorflow iterator """ - itr = tf.data.Dataset.from_tensor_slices(dict(zip(data._fields, data))) + data = { + "y": data["y"], + "theta": jax.vmap(lambda x: ravel_pytree(x)[0])(data["theta"]), + } + itr = tf.data.Dataset.from_tensor_slices(data) return as_batched_numpy_iterator_from_tf( - rng_key, itr, data[0].shape[0], batch_size, shuffle + rng_key, itr, data["y"].shape[0], batch_size, shuffle ) + + +def as_numpy_iterator_from_slices(data: PyTree, batch_size): + itr = tf.data.Dataset.from_tensor_slices(data) + itr = itr.batch(batch_size).prefetch(buffer_size=batch_size) + itr = itr.as_numpy_iterator() + return itr diff --git a/sbijax/_src/util/early_stopping.py b/sbijax/_src/util/early_stopping.py index e6b4a29..2f3dacf 100644 --- a/sbijax/_src/util/early_stopping.py +++ b/sbijax/_src/util/early_stopping.py @@ -28,7 +28,7 @@ def update(self, metric): """Update the stopping criterion. Args: - metric: the tracjed metric as float + metric: the early stopping criterion metric as float Returns: tuple diff --git a/sbijax/_src/util/plot.py b/sbijax/_src/util/plot.py new file mode 100644 index 0000000..3f25515 --- /dev/null +++ b/sbijax/_src/util/plot.py @@ -0,0 +1,54 @@ +import arviz as az +import numpy as np +import seaborn as sns +from matplotlib import pyplot as plt +from matplotlib.ticker import AutoLocator + + +def plot_trace(inference_data): + var_sizes = inference_data.posterior.sizes + max_dim = np.max( + [v for k, v in dict(var_sizes).items() if k not in ["chain", "draw"]] + ) + colors = sns.blend_palette(["#636363", "#b26679"], n_colors=max_dim) + with az.style.context(["arviz-white"], after_reset=True): + plt.rcParams["font.family"] = "Times New Roman" + axes = az.plot_trace( + inference_data, + compact_prop={"color": colors}, + ) + for ax in axes.flatten(): + ax.spines[["right", "top"]].set_visible(False) + ax.spines.left.set_linewidth(0.5) + ax.spines.bottom.set_linewidth(0.5) + ax.yaxis.set_major_locator(AutoLocator()) + ax.title.set_fontsize(15) + ax.yaxis.set_tick_params(labelsize="large") + ax.xaxis.set_tick_params(labelsize="large") + ax.xaxis.set_tick_params(width=0.5, length=2) + ax.yaxis.set_tick_params(width=0.5, length=2) + ax.grid(which="major", axis="both", alpha=0.5) + plt.tight_layout() + return axes + + +def plot_posterior(inference_data): + colors = sns.blend_palette(["#636363", "#b26679"], n_colors=2) + with az.style.context(["arviz-white"], after_reset=True): + plt.rcParams["font.family"] = "Times New Roman" + axes = az.plot_posterior( + inference_data, + color=colors[1], + kind="hist", + hdi_prob=0.9, + edgecolor="black", + ) + for ax in axes.flatten(): + ax.spines[["right", "top"]].set_visible(False) + ax.spines.left.set_linewidth(0.5) + ax.spines.bottom.set_linewidth(0.5) + ax.xaxis.set_tick_params(width=0.5, length=2) + ax.yaxis.set_tick_params(width=0.5, length=2) + ax.grid(which="major", axis="both", alpha=0.25) + plt.tight_layout() + return axes diff --git a/sbijax/_src/util/types.py b/sbijax/_src/util/types.py new file mode 100644 index 0000000..8cbb113 --- /dev/null +++ b/sbijax/_src/util/types.py @@ -0,0 +1,3 @@ +from typing import Any + +PyTree = Any diff --git a/sbijax/nn/__init__.py b/sbijax/nn/__init__.py index 1ceacb2..8bede79 100644 --- a/sbijax/nn/__init__.py +++ b/sbijax/nn/__init__.py @@ -1,25 +1,30 @@ """Neural network module.""" -from sbijax._src.nn.consistency_model import ( - ConsistencyModel, - make_consistency_model, +from sbijax._src.nn.make_consistency_model import ( + make_cm, ) -from sbijax._src.nn.continuous_normalizing_flow import CCNF, make_ccnf -from sbijax._src.nn.make_flows import ( - make_affine_maf, - make_surjective_affine_maf, +from sbijax._src.nn.make_continuous_flow import make_cnf +from sbijax._src.nn.make_flow import ( + make_maf, + make_spf, ) +from sbijax._src.nn.make_mdn import make_mdn +from sbijax._src.nn.make_mlp import make_mlp +from sbijax._src.nn.make_nass_network import make_nass_net, make_nasss_net from sbijax._src.nn.make_resnet import make_resnet -from sbijax._src.nn.make_snass_networks import make_snass_net, make_snasss_net __all__ = [ - "ConsistencyModel", - "CCNF", - "make_consistency_model", - "make_ccnf", - "make_affine_maf", - "make_surjective_affine_maf", + "make_mdn", + "make_maf", + "make_spf", + # + "make_cnf", + # + "make_mlp", "make_resnet", - "make_snass_net", - "make_snasss_net", + # + "make_cm", + # + "make_nass_net", + "make_nasss_net", ] diff --git a/sbijax/util/__init__.py b/sbijax/util/__init__.py new file mode 100644 index 0000000..7571b7f --- /dev/null +++ b/sbijax/util/__init__.py @@ -0,0 +1,3 @@ +from sbijax._src.util.data import stack_data + +__all__ = ["stack_data"]