├── .gitignore ├── LICENSE ├── README.md ├── models ├── __init__.py ├── autoregressive.py ├── bijectors.py ├── maf.py └── nsf.py └── notebooks ├── example.ipynb └── sbi.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | share/python-wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 27 | MANIFEST 28 | 29 | # PyInstaller 30 | # Usually these files are written by a python script from a template 31 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 32 | *.manifest 33 | *.spec 34 | 35 | # Installer logs 36 | pip-log.txt 37 | pip-delete-this-directory.txt 38 | 39 | # Unit test / coverage reports 40 | htmlcov/ 41 | .tox/ 42 | .nox/ 43 | .coverage 44 | .coverage.* 45 | .cache 46 | nosetests.xml 47 | coverage.xml 48 | *.cover 49 | *.py,cover 50 | .hypothesis/ 51 | .pytest_cache/ 52 | cover/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | .pybuilder/ 76 | target/ 77 | 78 | # Jupyter Notebook 79 | .ipynb_checkpoints 80 | 81 | # IPython 82 | profile_default/ 83 | ipython_config.py 84 | 85 | # pyenv 86 | # For a library or package, you might want to ignore these files since the code is 87 | # intended to run in multiple environments; otherwise, check them in: 88 | # .python-version 89 | 90 | # pipenv 91 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 92 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 93 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 94 | # install all needed dependencies. 95 | #Pipfile.lock 96 | 97 | # poetry 98 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. 99 | # This is especially recommended for binary packages to ensure reproducibility, and is more 100 | # commonly ignored for libraries. 101 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control 102 | #poetry.lock 103 | 104 | # pdm 105 | # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. 106 | #pdm.lock 107 | # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it 108 | # in version control. 109 | # https://pdm.fming.dev/#use-with-ide 110 | .pdm.toml 111 | 112 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm 113 | __pypackages__/ 114 | 115 | # Celery stuff 116 | celerybeat-schedule 117 | celerybeat.pid 118 | 119 | # SageMath parsed files 120 | *.sage.py 121 | 122 | # Environments 123 | .env 124 | .venv 125 | env/ 126 | venv/ 127 | ENV/ 128 | env.bak/ 129 | venv.bak/ 130 | 131 | # Spyder project settings 132 | .spyderproject 133 | .spyproject 134 | 135 | # Rope project settings 136 | .ropeproject 137 | 138 | # mkdocs documentation 139 | /site 140 | 141 | # mypy 142 | .mypy_cache/ 143 | .dmypy.json 144 | dmypy.json 145 | 146 | # Pyre type checker 147 | .pyre/ 148 | 149 | # pytype static type analyzer 150 | .pytype/ 151 | 152 | # Cython debug symbols 153 | cython_debug/ 154 | 155 | # PyCharm 156 | # JetBrains specific template is maintained in a separate JetBrains.gitignore that can 157 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore 158 | # and can be added to the global gitignore or merged into this file. For a more nuclear 159 | # option (not recommended) you can uncomment the following to ignore the entire idea folder. 160 | #.idea/ 161 | 162 | .DS_Store -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2022 Siddharth Mishra-Sharma 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Conditional normalizing flows in Jax 2 | 3 | Implementation of some common normalizing flow models allowing for a conditioning context using [Jax](https://github.com/google/jax), [Flax](https://github.com/google/flax), and [Distrax](https://github.com/deepmind/distrax). The following are currently implemented: 4 | - Masked/Inverse Autoregressive Flows (MAF/IAF; [Papamakarios et al, 2017](https://arxiv.org/abs/1705.07057) and [Kingma et al, 2016](https://arxiv.org/abs/1606.04934)) 5 | - Neural Spline Flows (NSF; [Durkan et al, 2019](https://arxiv.org/abs/1906.04032)) 6 | 7 | ## Examples 8 | - See [notebooks/example.ipynb](notebooks/example.ipynb) for a simple usage example. 9 | - See [notebooks/sbi.ipynb](notebooks/sbi.ipynb) for an example application for neural simulation-based inference (conditional posterior estimation). 10 | 11 | ## Basic usage 12 | 13 | ```python 14 | import jax 15 | from models.maf import MaskedAutoregressiveFlow 16 | from models.nsf import NeuralSplineFlow 17 | 18 | n_dim = 2 # Feature dim 19 | n_context = 1 # Context dim 20 | 21 | ## Define flow model 22 | # model = MaskedAutoregressiveFlow(n_dim=n_dim, n_context=n_context, hidden_dims=[128,128], n_transforms=12, activation="tanh", use_random_permutations=False) 23 | model = NeuralSplineFlow(n_dim=n_dim, n_context=n_context, hidden_dims=[128,128], n_transforms=8, activation="gelu", n_bins=4) 24 | 25 | ## Initialize model and params 26 | key = jax.random.PRNGKey(42) 27 | x_test = jax.random.uniform(key=key, shape=(64, n_dim)) 28 | context = jax.random.uniform(key=key, shape=(64, n_context)) 29 | params = model.init(key, x_test, context) 30 | 31 | ## Log-prob and sampling 32 | log_prob = model.apply(params, x_test, jnp.ones((x_test.shape[0], n_context))) 33 | samples = model.apply(params, n_samples, key, jnp.ones((n_samples, n_context)), method=model.sample) 34 | ``` -------------------------------------------------------------------------------- /models/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smsharma/jax-conditional-flows/f132113ce8d88e9cd75ed121876fc25e6af34caa/models/__init__.py -------------------------------------------------------------------------------- /models/autoregressive.py: -------------------------------------------------------------------------------- 1 | import jax 2 | import jax.numpy as jnp 3 | import numpy as np 4 | from flax.linen.module import compact 5 | import flax.linen as nn 6 | from flax.linen.dtypes import promote_dtype 7 | import distrax 8 | from tensorflow_probability.substrates import jax as tfp 9 | 10 | from typing import Any, List 11 | import dataclasses 12 | 13 | Array = Any 14 | tfb = tfp.bijectors 15 | 16 | 17 | class MaskedDense(nn.Dense): 18 | """A linear transformation applied over the last dimension of the input. 19 | 20 | Attributes: 21 | mask: mask to apply to the weights. 22 | """ 23 | 24 | mask: Array = None 25 | 26 | @compact 27 | def __call__(self, inputs: Array) -> Array: 28 | """Applies a linear transformation to the inputs along the last dimension. 29 | 30 | Args: 31 | inputs: The nd-array to be transformed. 32 | 33 | Returns: 34 | The transformed input. 35 | """ 36 | 37 | kernel = self.param("kernel", self.kernel_init, (jnp.shape(inputs)[-1], self.features), self.param_dtype) 38 | if self.use_bias: 39 | bias = self.param("bias", self.bias_init, (self.features,), self.param_dtype) 40 | else: 41 | bias = None 42 | inputs, kernel, bias = promote_dtype(inputs, kernel, bias, dtype=self.dtype) 43 | 44 | kernel = self.mask * kernel 45 | 46 | y = jax.lax.dot_general(inputs, kernel, (((inputs.ndim - 1,), (0,)), ((), ())), precision=self.precision) 47 | if bias is not None: 48 | y += jnp.reshape(bias, (1,) * (y.ndim - 1) + (-1,)) 49 | return y 50 | 51 | 52 | class MADE(nn.Module): 53 | n_params: Any = 2 54 | n_context: Any = 0 55 | hidden_dims: List[int] = dataclasses.field(default_factory=lambda: [32, 32]) 56 | activation: str = "tanh" 57 | 58 | @compact 59 | def __call__(self, y: Array, context=None): 60 | if context is not None: 61 | # Stack with context on the left so that the parameters are autoregressively conditioned on it with left-to-right ordering 62 | y = jnp.hstack([context, y]) 63 | 64 | broadcast_dims = y.shape[:-1] 65 | 66 | masks = tfb.masked_autoregressive._make_dense_autoregressive_masks(params=2, event_size=self.n_params + self.n_context, hidden_units=self.hidden_dims, input_order="left-to-right") # 2 parameters for scele and shift factors 67 | 68 | for mask in masks[:-1]: 69 | y = MaskedDense(features=mask.shape[-1], mask=mask)(y) 70 | y = getattr(jax.nn, self.activation)(y) 71 | y = MaskedDense(features=masks[-1].shape[-1], mask=masks[-1])(y) 72 | 73 | # Unravel the inputs and parameters 74 | params = y.reshape(broadcast_dims + (self.n_params + self.n_context, 2)) 75 | 76 | # Only take the values corresponding to the parameters of interest for scale and shift; ignore context outputs 77 | params = params[..., self.n_context :, :] 78 | 79 | return params 80 | 81 | 82 | class MAF(distrax.Bijector): 83 | def __init__(self, bijector_fn, unroll_loop=False): 84 | super().__init__(event_ndims_in=1) 85 | 86 | self.autoregressive_fn = bijector_fn 87 | self.unroll_loop = unroll_loop 88 | 89 | def forward_and_log_det(self, x, context): 90 | event_ndims = x.shape[-1] 91 | 92 | if self.unroll_loop: 93 | y = jnp.zeros_like(x) 94 | log_det = None 95 | 96 | for _ in range(event_ndims): 97 | params = self.autoregressive_fn(y, context) 98 | shift, log_scale = params[..., 0], params[..., 1] 99 | y, log_det = distrax.ScalarAffine(shift=shift, log_scale=log_scale).forward_and_log_det(x) 100 | 101 | # TODO: Rewrite with Flax primitives rather than jax.lax; these cannot be mixed 102 | else: 103 | 104 | def update_fn(i, y_and_log_det): 105 | y, log_det = y_and_log_det 106 | params = self.autoregressive_fn(y) 107 | shift, log_scale = params[..., 0], params[..., 1] 108 | y, log_det = distrax.ScalarAffine(shift=shift, log_scale=log_scale).forward_and_log_det(x) 109 | return y, log_det 110 | 111 | y, log_det = jax.lax.fori_loop(0, event_ndims, update_fn, (jnp.zeros_like(x), jnp.zeros_like(x))) 112 | 113 | return y, log_det.sum(-1) 114 | 115 | def inverse_and_log_det(self, y, context): 116 | params = self.autoregressive_fn(y, context) 117 | shift, log_scale = params[..., 0], params[..., 1] 118 | x, log_det = distrax.ScalarAffine(shift=shift, log_scale=log_scale).inverse_and_log_det(y) 119 | 120 | return x, log_det.sum(-1) 121 | -------------------------------------------------------------------------------- /models/bijectors.py: -------------------------------------------------------------------------------- 1 | # Bijectors with base from Distrax, additionally allowing for a conditioning context 2 | 3 | from typing import Any, List, Tuple, Optional 4 | 5 | import math 6 | 7 | import jax 8 | import jax.numpy as jnp 9 | 10 | import distrax 11 | from distrax._src.bijectors.chain import Chain 12 | from distrax._src.bijectors.inverse import Inverse 13 | from distrax._src.distributions.transformed import Transformed 14 | from distrax._src.bijectors.masked_coupling import MaskedCoupling 15 | from distrax._src.utils import math 16 | 17 | Array = Any 18 | PRNGKey = Array 19 | 20 | 21 | class TransformedConditional(Transformed): 22 | def __init__(self, distribution, flow): 23 | super().__init__(distribution, flow) 24 | 25 | def sample(self, seed: PRNGKey, sample_shape: List[int], context: Optional[Array] = None) -> Array: 26 | x = self.distribution.sample(seed=seed, sample_shape=sample_shape) 27 | y, _ = self.bijector.forward_and_log_det(x, context) 28 | return y 29 | 30 | def log_prob(self, x: Array, context: Optional[Array] = None) -> Array: 31 | x, ildj_y = self.bijector.inverse_and_log_det(x, context) 32 | lp_x = self.distribution.log_prob(x) 33 | lp_y = lp_x + ildj_y 34 | return lp_y 35 | 36 | def sample_and_log_prob(self, seed: PRNGKey, sample_shape: List[int], context: Optional[Array] = None) -> Tuple[Array, Array]: 37 | x, lp_x = self.distribution.sample_and_log_prob(seed=seed, sample_shape=sample_shape) 38 | y, fldj = jax.vmap(self.bijector.forward_and_log_det)(x, context) 39 | lp_y = jax.vmap(jnp.subtract)(lp_x, fldj) 40 | return y, lp_y 41 | 42 | 43 | class InverseConditional(Inverse): 44 | def __init__(self, *args, **kwargs): 45 | super().__init__(*args, **kwargs) 46 | 47 | def forward(self, x: Array, context: Optional[Array] = None) -> Array: 48 | return self._bijector.inverse(x, context) 49 | 50 | def inverse(self, y: Array, context: Optional[Array] = None) -> Array: 51 | return self._bijector.forward(y, context) 52 | 53 | def forward_and_log_det(self, x: Array, context: Optional[Array] = None) -> Tuple[Array, Array]: 54 | return self._bijector.inverse_and_log_det(x, context) 55 | 56 | def inverse_and_log_det(self, y: Array, context: Optional[Array] = None) -> Tuple[Array, Array]: 57 | return self._bijector.forward_and_log_det(y, context) 58 | 59 | 60 | class ChainConditional(Chain): 61 | def __init__(self, *args): 62 | super().__init__(*args) 63 | 64 | def forward(self, x: Array, context: Optional[Array] = None) -> Array: 65 | for bijector in reversed(self._bijectors): 66 | x = bijector.forward(x, context) 67 | return x 68 | 69 | def inverse(self, y: Array, context: Optional[Array] = None) -> Array: 70 | for bijector in self._bijectors: 71 | y = bijector.inverse(y, context) 72 | return y 73 | 74 | def forward_and_log_det(self, x: Array, context: Optional[Array] = None) -> Tuple[Array, Array]: 75 | x, log_det = self._bijectors[-1].forward_and_log_det(x, context) 76 | for bijector in reversed(self._bijectors[:-1]): 77 | x, ld = bijector.forward_and_log_det(x, context) 78 | log_det += ld 79 | return x, log_det 80 | 81 | def inverse_and_log_det(self, y: Array, context: Optional[Array] = None) -> Tuple[Array, Array]: 82 | y, log_det = self._bijectors[0].inverse_and_log_det(y, context) 83 | for bijector in self._bijectors[1:]: 84 | y, ld = bijector.inverse_and_log_det(y, context) 85 | log_det += ld 86 | return y, log_det 87 | 88 | 89 | class Permute(distrax.Bijector): 90 | def __init__(self, permutation: Array, axis: int = -1): 91 | 92 | super().__init__(event_ndims_in=1) 93 | 94 | self.permutation = jnp.array(permutation) 95 | self.axis = axis 96 | 97 | def permute_along_axis(self, x: Array, permutation: Array, axis: int = -1) -> Array: 98 | x = jnp.moveaxis(x, axis, 0) 99 | x = x[permutation, ...] 100 | x = jnp.moveaxis(x, 0, axis) 101 | return x 102 | 103 | def forward_and_log_det(self, x: Array, context: Optional[Array] = None) -> Tuple[Array, Array]: 104 | y = self.permute_along_axis(x, self.permutation, axis=self.axis) 105 | return y, jnp.zeros(x.shape[: -self.event_ndims_in]) 106 | 107 | def inverse_and_log_det(self, y: Array, context: Optional[Array] = None) -> Tuple[Array, Array]: 108 | inv_permutation = jnp.zeros_like(self.permutation) 109 | inv_permutation = inv_permutation.at[self.permutation].set(jnp.arange(len(self.permutation))) 110 | x = self.permute_along_axis(y, inv_permutation) 111 | return x, jnp.zeros(y.shape[: -self.event_ndims_in]) 112 | 113 | 114 | class MaskedCouplingConditional(MaskedCoupling): 115 | def __init__(self, *args, **kwargs): 116 | super().__init__(*args, **kwargs) 117 | 118 | def forward_and_log_det(self, x: Array, context: Optional[Array] = None) -> Tuple[Array, Array]: 119 | self._check_forward_input_shape(x) 120 | masked_x = jnp.where(self._event_mask, x, 0.0) 121 | params = self._conditioner(masked_x, context) 122 | y0, log_d = self._inner_bijector(params).forward_and_log_det(x) 123 | y = jnp.where(self._event_mask, x, y0) 124 | logdet = math.sum_last(jnp.where(self._mask, 0.0, log_d), self._event_ndims - self._inner_event_ndims) 125 | return y, logdet 126 | 127 | def inverse_and_log_det(self, y: Array, context: Optional[Array] = None) -> Tuple[Array, Array]: 128 | self._check_inverse_input_shape(y) 129 | masked_y = jnp.where(self._event_mask, y, 0.0) 130 | params = self._conditioner(masked_y, context) 131 | x0, log_d = self._inner_bijector(params).inverse_and_log_det(y) 132 | x = jnp.where(self._event_mask, y, x0) 133 | logdet = math.sum_last(jnp.where(self._mask, 0.0, log_d), self._event_ndims - self._inner_event_ndims) 134 | return x, logdet 135 | -------------------------------------------------------------------------------- /models/maf.py: -------------------------------------------------------------------------------- 1 | from typing import Any, List 2 | import dataclasses 3 | 4 | import jax 5 | import jax.numpy as jnp 6 | import flax.linen as nn 7 | import distrax 8 | 9 | from models.bijectors import InverseConditional, ChainConditional, TransformedConditional, Permute 10 | from models.autoregressive import MAF, MADE 11 | 12 | Array = Any 13 | 14 | 15 | class MaskedAutoregressiveFlow(nn.Module): 16 | # Note: Does not currently allow for general event shapes 17 | 18 | n_dim: int 19 | n_context: int = 0 20 | n_transforms: int = 4 21 | hidden_dims: List[int] = dataclasses.field(default_factory=lambda: [128, 128]) 22 | activation: str = "gelu" 23 | unroll_loop: bool = True 24 | use_random_permutations: bool = True 25 | rng_key: Array = jax.random.PRNGKey(42) 26 | inverse: bool = False 27 | 28 | def setup(self): 29 | self.made = [MADE(n_params=self.n_dim, n_context=self.n_context, activation=self.activation, hidden_dims=self.hidden_dims, name="made_{}".format(i)) for i in range(self.n_transforms)] 30 | 31 | bijectors = [] 32 | key = self.rng_key 33 | for i in range(self.n_transforms): 34 | # Permutation 35 | if self.use_random_permutations: 36 | permutation = jax.random.choice(key, jnp.arange(self.n_dim), shape=(self.n_dim,), replace=False) 37 | key, _ = jax.random.split(key) 38 | else: 39 | permutation = list(reversed(range(self.n_dim))) 40 | bijectors.append(Permute(permutation)) 41 | 42 | bijector_af = MAF(bijector_fn=self.made[i], unroll_loop=self.unroll_loop) 43 | if self.inverse: 44 | bijector_af = InverseConditional(bijector_af) # Flip forward and reverse directions for IAF 45 | bijectors.append(bijector_af) 46 | 47 | self.bijector = InverseConditional(ChainConditional(bijectors)) # Forward direction goes from target to base distribution 48 | self.base_dist = distrax.MultivariateNormalDiag(jnp.zeros(self.n_dim), jnp.ones(self.n_dim)) 49 | 50 | self.flow = TransformedConditional(self.base_dist, self.bijector) 51 | 52 | def __call__(self, x: Array, context: Array = None) -> Array: 53 | return self.flow.log_prob(x, context=context) 54 | 55 | def sample(self, num_samples: int, rng: Array, context: Array = None) -> Array: 56 | return self.flow.sample(seed=rng, sample_shape=(num_samples,), context=context) 57 | -------------------------------------------------------------------------------- /models/nsf.py: -------------------------------------------------------------------------------- 1 | from typing import Any, List, Optional 2 | import dataclasses 3 | 4 | import jax 5 | import jax.numpy as jnp 6 | import numpy as np 7 | import flax.linen as nn 8 | from flax.linen.module import compact 9 | import distrax 10 | 11 | from models.bijectors import InverseConditional, ChainConditional, TransformedConditional, MaskedCouplingConditional 12 | 13 | Array = Any 14 | 15 | 16 | class Conditioner(nn.Module): 17 | event_shape: List[int] 18 | context_shape: List[int] 19 | hidden_dims: List[int] 20 | num_bijector_params: int 21 | activation: str = "tanh" 22 | 23 | @compact 24 | def __call__(self, x: Array, context=None): 25 | # Infer batch dims 26 | batch_shape = x.shape[: -len(self.event_shape)] 27 | batch_shape_context = context.shape[: -len(self.context_shape)] 28 | assert batch_shape == batch_shape_context 29 | 30 | # Flatten event dims 31 | x = x.reshape(*batch_shape, -1) 32 | context = context.reshape(*batch_shape, -1) 33 | 34 | x = jnp.hstack([context, x]) 35 | 36 | for hidden_dim in self.hidden_dims: 37 | x = nn.Dense(hidden_dim)(x) 38 | x = getattr(jax.nn, self.activation)(x) 39 | x = nn.Dense(np.prod(self.event_shape) * self.num_bijector_params, kernel_init=jax.nn.initializers.zeros, bias_init=jax.nn.initializers.zeros)(x) 40 | 41 | x = x.reshape(*batch_shape, *(tuple(self.event_shape) + (self.num_bijector_params,))) 42 | 43 | return x 44 | 45 | 46 | class NeuralSplineFlow(nn.Module): 47 | """Based on the implementation in the Distrax repo, https://github.com/deepmind/distrax/blob/master/examples/flow.py""" 48 | 49 | n_dim: int 50 | n_context: int = 0 51 | n_transforms: int = 4 52 | hidden_dims: List[int] = dataclasses.field(default_factory=lambda: [128, 128]) 53 | activation: str = "gelu" 54 | n_bins: int = 8 55 | range_min: float = -1.0 56 | range_max: float = 1.0 57 | event_shape: Optional[List[int]] = None 58 | context_shape: Optional[List[int]] = None 59 | 60 | def setup(self): 61 | def bijector_fn(params: Array): 62 | return distrax.RationalQuadraticSpline(params, range_min=self.range_min, range_max=self.range_max) 63 | 64 | # If event shapes are not provided, assume single event and context dimensions 65 | event_shape = (self.n_dim,) if self.event_shape is None else self.event_shape 66 | context_shape = (self.n_context,) if self.context_shape is None else self.context_shape 67 | 68 | # Alternating binary mask 69 | mask = jnp.arange(0, np.prod(event_shape)) % 2 70 | mask = jnp.reshape(mask, event_shape) 71 | mask = mask.astype(bool) 72 | 73 | # Number of parameters for the rational-quadratic spline: 74 | # - `num_bins` bin widths 75 | # - `num_bins` bin heights 76 | # - `num_bins + 1` knot slopes 77 | # for a total of `3 * num_bins + 1` parameters 78 | num_bijector_params = 3 * self.n_bins + 1 79 | 80 | self.conditioner = [Conditioner(event_shape=event_shape, context_shape=context_shape, hidden_dims=self.hidden_dims, num_bijector_params=num_bijector_params, activation=self.activation, name="conditioner_{}".format(i)) for i in range(self.n_transforms)] 81 | 82 | bijectors = [] 83 | for i in range(self.n_transforms): 84 | bijectors.append(MaskedCouplingConditional(mask=mask, bijector=bijector_fn, conditioner=self.conditioner[i])) 85 | mask = jnp.logical_not(mask) # Flip the mask after each layer 86 | 87 | self.bijector = InverseConditional(ChainConditional(bijectors)) 88 | self.base_dist = distrax.MultivariateNormalDiag(jnp.zeros(event_shape), jnp.ones(event_shape)) 89 | 90 | self.flow = TransformedConditional(self.base_dist, self.bijector) 91 | 92 | def __call__(self, x: Array, context: Array = None) -> Array: 93 | return self.flow.log_prob(x, context=context) 94 | 95 | def sample(self, num_samples: int, rng: Array, context: Array = None) -> Array: 96 | return self.flow.sample(seed=rng, sample_shape=(num_samples,), context=context) 97 | -------------------------------------------------------------------------------- /notebooks/sbi.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 129, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np\n", 10 | "import matplotlib.pyplot as plt\n", 11 | "from scipy.stats import chi2\n", 12 | "from tqdm import tqdm, trange" 13 | ] 14 | }, 15 | { 16 | "attachments": {}, 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "## Power-law bump simulator" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 130, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "def bump_forward_model(y, amp_s, mu_s, std_s, amp_b, exp_b):\n", 30 | " \"\"\" Forward model for a Gaussian bump (amp_s, mu_s, std_s) on top of a power-law background (amp_b, exp_b).\n", 31 | " \"\"\"\n", 32 | " x_b = amp_b * (y ** exp_b) # Power-law background\n", 33 | " x_s = amp_s * np.exp(-((y - mu_s) ** 2) / (2 * std_s ** 2)) # Gaussian signal\n", 34 | "\n", 35 | " x = x_b + x_s # Total mean signal\n", 36 | "\n", 37 | " return x" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 131, 43 | "metadata": {}, 44 | "outputs": [ 45 | { 46 | "data": { 47 | "text/plain": [ 48 | "" 49 | ] 50 | }, 51 | "execution_count": 131, 52 | "metadata": {}, 53 | "output_type": "execute_result" 54 | }, 55 | { 56 | "data": { 57 | "image/png": "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", 58 | "text/plain": [ 59 | "
" 60 | ] 61 | }, 62 | "metadata": {}, 63 | "output_type": "display_data" 64 | } 65 | ], 66 | "source": [ 67 | "def poisson_interval(k, alpha=0.32): \n", 68 | " \"\"\" Uses chi2 to get the poisson interval.\n", 69 | " \"\"\"\n", 70 | " a = alpha\n", 71 | " low, high = (chi2.ppf(a/2, 2*k) / 2, chi2.ppf(1-a/2, 2*k + 2) / 2)\n", 72 | " if k == 0: \n", 73 | " low = 0.0\n", 74 | " return k - low, high - k\n", 75 | "\n", 76 | "y = np.linspace(0.1, 1, 50) # Dependent variable\n", 77 | "\n", 78 | "# Mean expected counts\n", 79 | "x_mu = bump_forward_model(y, \n", 80 | " amp_s=50, mu_s=0.8, std_s=0.05, # Signal params\n", 81 | " amp_b=50, exp_b=-0.5) # Background params\n", 82 | "\n", 83 | "# Realized counts\n", 84 | "x = np.random.poisson(x_mu)\n", 85 | "x_err = np.array([poisson_interval(k) for k in x.T]).T\n", 86 | "\n", 87 | "# Plot\n", 88 | "plt.plot(y, x_mu, color='k', ls='--', label=\"Mean expected counts\")\n", 89 | "plt.errorbar(y, x, yerr=x_err, fmt='o', color='k', label=\"Realized counts\")\n", 90 | "\n", 91 | "plt.xlabel(\"$y$\")\n", 92 | "plt.ylabel(\"Counts\")\n", 93 | "\n", 94 | "plt.legend()" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 132, 100 | "metadata": {}, 101 | "outputs": [ 102 | { 103 | "data": { 104 | "text/plain": [ 105 | "array([171, 159, 140, 118, 123, 114, 105, 124, 101, 86, 101, 86, 85,\n", 106 | " 81, 110, 101, 75, 80, 82, 68, 70, 63, 79, 71, 57, 75,\n", 107 | " 60, 78, 73, 64, 68, 63, 75, 68, 81, 71, 98, 101, 109,\n", 108 | " 100, 106, 78, 64, 54, 49, 62, 53, 50, 54, 51])" 109 | ] 110 | }, 111 | "execution_count": 132, 112 | "metadata": {}, 113 | "output_type": "execute_result" 114 | } 115 | ], 116 | "source": [ 117 | "def bump_simulator(thetas, y):\n", 118 | " \"\"\" Simulate samples from the bump forward model given theta = (amp_s, mu_s) and abscissa points y.\n", 119 | " \"\"\"\n", 120 | " amp_s, mu_s = thetas\n", 121 | " std_s, amp_b, exp_b = 0.05, 50, -0.5\n", 122 | " x_mu = bump_forward_model(y, amp_s, mu_s, std_s, amp_b, exp_b)\n", 123 | " x = np.random.poisson(x_mu)\n", 124 | " return x\n", 125 | "\n", 126 | "# Test it out\n", 127 | "bump_simulator([50, 0.8], y)" 128 | ] 129 | }, 130 | { 131 | "attachments": {}, 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "## Training data" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 133, 141 | "metadata": {}, 142 | "outputs": [ 143 | { 144 | "name": "stderr", 145 | "output_type": "stream", 146 | "text": [ 147 | "100%|██████████| 50000/50000 [00:00<00:00, 62598.60it/s]\n" 148 | ] 149 | } 150 | ], 151 | "source": [ 152 | "n_train = 50_000\n", 153 | "\n", 154 | "# Simulate training data\n", 155 | "theta_samples = np.random.uniform(low=[0, 0], high=[200, 1], size=(n_train, 2)) # Parameter proposal\n", 156 | "x_samples = np.array([bump_simulator(theta, y) for theta in tqdm(theta_samples)])" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 134, 162 | "metadata": {}, 163 | "outputs": [], 164 | "source": [ 165 | "# Normalize the data\n", 166 | "x_mean = x_samples.mean()\n", 167 | "x_std = x_samples.std()\n", 168 | "x_samples = (x_samples - x_mean) / x_std\n", 169 | "\n", 170 | "theta_mean = theta_samples.mean(axis=0)\n", 171 | "theta_std = theta_samples.std(axis=0)\n", 172 | "theta_samples = (theta_samples - theta_mean) / theta_std" 173 | ] 174 | }, 175 | { 176 | "attachments": {}, 177 | "cell_type": "markdown", 178 | "metadata": {}, 179 | "source": [ 180 | "## Neural posterior estimator model" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": 188, 186 | "metadata": {}, 187 | "outputs": [], 188 | "source": [ 189 | "import sys\n", 190 | "sys.path.append(\"../\")\n", 191 | "\n", 192 | "import jax\n", 193 | "import optax\n", 194 | "import flax.linen as nn\n", 195 | "\n", 196 | "from models.maf import MaskedAutoregressiveFlow\n", 197 | "from models.nsf import NeuralSplineFlow" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": 236, 203 | "metadata": {}, 204 | "outputs": [], 205 | "source": [ 206 | "class MLP(nn.Module):\n", 207 | " \"\"\" A simple MLP in Flax. This will be the feature extractor.\n", 208 | " \"\"\"\n", 209 | " hidden_dim: int = 32\n", 210 | " out_dim: int = 2\n", 211 | " n_layers: int = 2\n", 212 | "\n", 213 | " @nn.compact\n", 214 | " def __call__(self, x):\n", 215 | " for _ in range(self.n_layers):\n", 216 | " x = nn.Dense(features=self.hidden_dim)(x)\n", 217 | " x = nn.gelu(x)\n", 218 | " x = nn.Dense(features=self.out_dim)(x)\n", 219 | " return x" 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": 238, 225 | "metadata": {}, 226 | "outputs": [], 227 | "source": [ 228 | "class NeuralPosteriorEstimator(nn.Module):\n", 229 | " \"\"\" A neural posterior estimator.\n", 230 | " \"\"\"\n", 231 | " d_param: int = 2 # Param dim\n", 232 | " d_hidden: int = 64 # Hidden dim of MLP and flow\n", 233 | " d_summaries: int = 16 # Number of summaries from MLP\n", 234 | " n_layers: int = 4 # Number of layers in MLP\n", 235 | " n_transforms: int = 6 # Number of flow transforms\n", 236 | "\n", 237 | " def setup(self):\n", 238 | " self.featurizer = MLP(hidden_dim=self.d_hidden, out_dim=self.d_summaries, n_layers=self.n_layers)\n", 239 | " self.flow = MaskedAutoregressiveFlow(n_dim=self.d_param, n_context=self.d_summaries, hidden_dims=2 * [self.d_hidden], n_transforms=self.n_transforms, activation=\"tanh\", use_random_permutations=False)\n", 240 | "\n", 241 | " @nn.compact\n", 242 | " def __call__(self, x, theta):\n", 243 | "\n", 244 | " # Pass data through MLP to get summaries\n", 245 | " context =self.featurizer(x)\n", 246 | "\n", 247 | " # Use summaries as context for flow\n", 248 | " log_prob = self.flow(theta, context)\n", 249 | "\n", 250 | " return log_prob" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": 239, 256 | "metadata": {}, 257 | "outputs": [ 258 | { 259 | "data": { 260 | "text/plain": [ 261 | "Array([-1.7746974, -1.9767084, -3.3885179, -3.3411727, -2.5347002,\n", 262 | " -2.8596387, -2.7574067, -2.4476223, -2.9018464, -1.8135326,\n", 263 | " -2.7627273, -2.8596678, -2.3531556, -3.523026 , -2.882647 ,\n", 264 | " -1.8737776], dtype=float32)" 265 | ] 266 | }, 267 | "execution_count": 239, 268 | "metadata": {}, 269 | "output_type": "execute_result" 270 | } 271 | ], 272 | "source": [ 273 | "npe = NeuralPosteriorEstimator()\n", 274 | "\n", 275 | "key = jax.random.PRNGKey(0)\n", 276 | "log_prob, params = npe.init_with_output(rngs=key, x=x_samples[:16], theta=theta_samples[:16])\n", 277 | "\n", 278 | "log_prob" 279 | ] 280 | }, 281 | { 282 | "attachments": {}, 283 | "cell_type": "markdown", 284 | "metadata": {}, 285 | "source": [ 286 | "## Training" 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": 240, 292 | "metadata": {}, 293 | "outputs": [], 294 | "source": [ 295 | "@jax.jit\n", 296 | "def loss_fn(params, x, theta):\n", 297 | " log_prob = npe.apply(params, x, theta)\n", 298 | " return -log_prob.mean()" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": 242, 304 | "metadata": {}, 305 | "outputs": [], 306 | "source": [ 307 | "opt = optax.sgd(learning_rate=1e-4, momentum=0.99, nesterov=True)\n", 308 | "opt_state = opt.init(params)" 309 | ] 310 | }, 311 | { 312 | "cell_type": "code", 313 | "execution_count": 243, 314 | "metadata": {}, 315 | "outputs": [ 316 | { 317 | "name": "stderr", 318 | "output_type": "stream", 319 | "text": [ 320 | "100%|██████████| 3000/3000 [00:51<00:00, 58.13it/s, val=0.6358305] \n" 321 | ] 322 | } 323 | ], 324 | "source": [ 325 | "n_steps = 3000\n", 326 | "n_batch = 128\n", 327 | "\n", 328 | "with trange(n_steps) as steps:\n", 329 | " for step in steps:\n", 330 | "\n", 331 | " # Draw a random batches from x\n", 332 | " key, subkey = jax.random.split(key)\n", 333 | " idx = jax.random.choice(key, x.shape[0], shape=(n_batch,))\n", 334 | "\n", 335 | " x_batch, theta_batch = x_samples[idx], theta_samples[idx]\n", 336 | " \n", 337 | " loss, grads = jax.value_and_grad(loss_fn)(params, x_batch, theta_batch)\n", 338 | " updates, opt_state = opt.update(grads, opt_state, params)\n", 339 | "\n", 340 | " params = optax.apply_updates(params, updates)\n", 341 | "\n", 342 | " steps.set_postfix(val=loss)" 343 | ] 344 | }, 345 | { 346 | "attachments": {}, 347 | "cell_type": "markdown", 348 | "metadata": {}, 349 | "source": [ 350 | "## Test" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": 244, 356 | "metadata": {}, 357 | "outputs": [ 358 | { 359 | "name": "stderr", 360 | "output_type": "stream", 361 | "text": [ 362 | "100%|██████████| 1000/1000 [00:00<00:00, 57510.58it/s]\n" 363 | ] 364 | } 365 | ], 366 | "source": [ 367 | "n_test = 1000\n", 368 | "\n", 369 | "# Simulate training data\n", 370 | "theta_samples_test = np.random.uniform(low=[0, 0], high=[200, 1], size=(n_test, 2)) # Parameter proposal\n", 371 | "x_samples_test = np.array([bump_simulator(theta, y) for theta in tqdm(theta_samples_test)])\n", 372 | "\n", 373 | "# Normalize the data\n", 374 | "x_samples_test = (x_samples_test - x_mean) / x_std\n", 375 | "theta_samples_test = (theta_samples_test - theta_mean) / theta_std" 376 | ] 377 | }, 378 | { 379 | "cell_type": "code", 380 | "execution_count": 247, 381 | "metadata": {}, 382 | "outputs": [ 383 | { 384 | "data": { 385 | "image/png": "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", 386 | "text/plain": [ 387 | "
" 388 | ] 389 | }, 390 | "metadata": {}, 391 | "output_type": "display_data" 392 | } 393 | ], 394 | "source": [ 395 | "from einops import repeat\n", 396 | "\n", 397 | "def sample_posterior(params, x, key, n_samples=100):\n", 398 | " \"\"\" Draw samples from trained flow conditioned on `x`.\n", 399 | " \"\"\"\n", 400 | " def sample(npe):\n", 401 | " enc = npe.featurizer(x)\n", 402 | " enc = repeat(enc, 'n_summary -> n_samples n_summary', n_samples=n_samples) # Repeat enc to match n_samples\n", 403 | " samples = npe.flow.sample(n_samples, key, enc)\n", 404 | " return samples\n", 405 | " return nn.apply(sample, npe)(params)\n", 406 | "\n", 407 | "\n", 408 | "idx = 3\n", 409 | "samples_post = sample_posterior(params, x_samples_test[idx], key, n_samples=100_000)\n", 410 | "\n", 411 | "import corner\n", 412 | "\n", 413 | "corner.corner(np.array(samples_post) * theta_std + theta_mean, truths=theta_samples_test[idx] * theta_std + theta_mean, labels=[\"amp_s\", \"mu_s\"], show_titles=True, title_kwargs={\"fontsize\": 12});" 414 | ] 415 | }, 416 | { 417 | "cell_type": "code", 418 | "execution_count": null, 419 | "metadata": {}, 420 | "outputs": [], 421 | "source": [] 422 | } 423 | ], 424 | "metadata": { 425 | "kernelspec": { 426 | "display_name": "torch-mps", 427 | "language": "python", 428 | "name": "python3" 429 | }, 430 | "language_info": { 431 | "codemirror_mode": { 432 | "name": "ipython", 433 | "version": 3 434 | }, 435 | "file_extension": ".py", 436 | "mimetype": "text/x-python", 437 | "name": "python", 438 | "nbconvert_exporter": "python", 439 | "pygments_lexer": "ipython3", 440 | "version": "3.9.13" 441 | }, 442 | "orig_nbformat": 4 443 | }, 444 | "nbformat": 4, 445 | "nbformat_minor": 2 446 | } 447 | --------------------------------------------------------------------------------