bayinx 0.2.6__py3-none-any.whl → 0.2.9__py3-none-any.whl

bayinx/core/flow.py

@@ -2,6 +2,7 @@ from abc import abstractmethod
 from typing import Callable, Dict, Self, Tuple
 
 import equinox as eqx
+import jax.tree_util as jtu
 from jaxtyping import Array, Float
 
 from bayinx.core.utils import __MyMeta
@@ -36,33 +37,44 @@ class Flow(eqx.Module, metaclass=__MyMeta):
         """
         pass
 
-    def __init_subclass__(cls):
-        # Add contrain_pars method
-        def constrain_pars(self: Self):
-            """
-            Constrain `params` to the appropriate domain.
+    # Default filter specification
+    def filter_spec(self):
+        """
+        Generates a filter specification to subset relevant parameters for the flow.
+        """
+        # Generate empty specification
+        filter_spec = jtu.tree_map(lambda _: False, self)
 
-            # Returns
-            A dictionary of transformed JAX Arrays representing the constrained parameters.
-            """
-            t_params = self.params
+        # Specify JAX Array parameters
+        filter_spec = eqx.tree_at(
+            lambda flow: flow.params,
+            filter_spec,
+            replace=jtu.tree_map(eqx.is_array, self.params),
+        )
 
-            for par, map in self.constraints.items():
-                t_params[par] = map(t_params[par])
+        return filter_spec
 
-            return t_params
+    @eqx.filter_jit
+    def constrain_pars(self: Self):
+        """
+        Constrain `params` to the appropriate domain.
 
-        cls.constrain_pars = eqx.filter_jit(constrain_pars)
+        # Returns
+        A dictionary of transformed JAX Arrays representing the constrained parameters.
+        """
+        t_params = self.params
 
-        # Add transform_pars method if not present
-        if not callable(getattr(cls, "transform_pars", None)):
-            def transform_pars(self: Self) -> Dict[str, Array]:
-                """
-                Apply a custom transformation to `params` if needed.
+        for par, map in self.constraints.items():
+            t_params[par] = map(t_params[par])
 
-                # Returns
-                A dictionary of transformed JAX Arrays representing the transformed parameters.
-                """
-                return self.constrain_pars()
+        return t_params
 
-            cls.transform_pars = eqx.filter_jit(transform_pars)
+    @eqx.filter_jit
+    def transform_pars(self: Self) -> Dict[str, Array]:
+        """
+        Apply a custom transformation to `params` if needed.
+
+        # Returns
+        A dictionary of transformed JAX Arrays representing the transformed parameters.
+        """
+        return self.constrain_pars()

bayinx/core/model.py

@@ -2,6 +2,7 @@ from abc import abstractmethod
 from typing import Any, Callable, Dict
 
 import equinox as eqx
+import jax.tree_util as jtu
 from jaxtyping import Array, Scalar
 
 from bayinx.core.utils import __MyMeta
@@ -23,6 +24,23 @@ class Model(eqx.Module, metaclass=__MyMeta):
     def eval(self, data: Any) -> Scalar:
         pass
 
+    # Default filter specification
+    def filter_spec(self):
+        """
+        Generates a filter specification to subset relevant parameters for the model.
+        """
+        # Generate empty specification
+        filter_spec = jtu.tree_map(lambda _: False, self)
+
+        # Specify JAX Array parameters
+        filter_spec = eqx.tree_at(
+            lambda model: model.params,
+            filter_spec,
+            replace=jtu.tree_map(eqx.is_array, self.params),
+        )
+
+        return filter_spec
+
     def __init_subclass__(cls):
         # Add constrain method
         def constrain_pars(self: Model) -> Dict[str, Array]:
@@ -43,6 +61,7 @@ class Model(eqx.Module, metaclass=__MyMeta):
 
         # Add transform_pars method if not present
         if not callable(getattr(cls, "transform_pars", None)):
+
             def transform_pars(self: Model) -> Dict[str, Array]:
                 """
                 Apply a custom transformation to `params` if needed.

bayinx/core/variational.py

@@ -104,6 +104,9 @@ class Variational(eqx.Module):
             - `var_draws`: Number of variational draws to draw each iteration.
             - `key`: A PRNG key.
             """
+            # Partition variational
+            dyn, static = eqx.partition(self, self.filter_spec())
+
             # Construct scheduler
             schedule: Schedule = opx.cosine_decay_schedule(
                 init_value=learning_rate, decay_steps=max_iters
@@ -113,20 +116,20 @@ class Variational(eqx.Module):
             optim: GradientTransformation = opx.chain(
                 opx.scale(-1.0), opx.nadam(schedule)
             )
-            opt_state: OptState = optim.init(eqx.filter(self, self.filter_spec()))
+            opt_state: OptState = optim.init(dyn)
 
             # Optimization loop helper functions
             @eqx.filter_jit
             def condition(state: Tuple[Self, OptState, Scalar, Key]):
                 # Unpack iteration state
-                self, opt_state, i, key = state
+                dyn, opt_state, i, key = state
 
                 return i < max_iters
 
             @eqx.filter_jit
             def body(state: Tuple[Self, OptState, Scalar, Key]):
                 # Unpack iteration state
-                self, opt_state, i, key = state
+                dyn, opt_state, i, key = state
 
                 # Update iteration
                 i = i + 1
@@ -134,26 +137,30 @@ class Variational(eqx.Module):
                 # Update PRNG key
                 key, _ = jr.split(key)
 
+                # Combine variational
+                vari = eqx.combine(dyn, static)
+
                 # Compute gradient of the ELBO
-                updates: PyTree = self.elbo_grad(var_draws, key, data)
+                updates: PyTree = vari.elbo_grad(var_draws, key, data)
 
                 # Compute updates
                 updates, opt_state = optim.update(
-                    updates, opt_state, eqx.filter(self, self.filter_spec())
+                    updates, opt_state, eqx.filter(dyn, dyn.filter_spec())
                 )
 
                 # Update variational distribution
-                self: Self = eqx.apply_updates(self, updates)
+                dyn = eqx.apply_updates(dyn, updates)
 
-                return self, opt_state, i, key
+                return dyn, opt_state, i, key
 
             # Run optimization loop
-            self = lax.while_loop(
+            dyn = lax.while_loop(
                 cond_fun=condition,
                 body_fun=body,
-                init_val=(self, opt_state, jnp.array(0, jnp.uint32), key),
+                init_val=(dyn, opt_state, jnp.array(0, jnp.uint32), key),
             )[0]
 
-            return self
+            # Return optimized variational
+            return eqx.combine(dyn, static)
 
         cls.fit = eqx.filter_jit(fit)

bayinx/mhx/__init__.py

@@ -0,0 +1 @@
+

bayinx/mhx/vi/__init__.py

@@ -0,0 +1,3 @@
+from bayinx.mhx.vi.meanfield import MeanField as MeanField
+from bayinx.mhx.vi.normalizing_flow import NormalizingFlow as NormalizingFlow
+from bayinx.mhx.vi.standard import Standard as Standard

bayinx/mhx/vi/flows/__init__.py

@@ -0,0 +1,3 @@
+from bayinx.mhx.vi.flows.affine import Affine as Affine
+from bayinx.mhx.vi.flows.planar import Planar as Planar
+from bayinx.mhx.vi.flows.radial import Radial as Radial

bayinx/{machinery/variational → mhx/vi}/flows/affine.py

@@ -19,9 +19,7 @@ class Affine(Flow):
     """
 
     params: Dict[str, Float[Array, "..."]]
-    constraints: Dict[str, Callable[[Float[Array, "..."]], Float[Array, "..."]]] = (
-        eqx.field(static=True)
-    )
+    constraints: Dict[str, Callable[[Float[Array, "..."]], Float[Array, "..."]]]
 
     def __init__(self, dim: int):
         """

bayinx/{machinery/variational → mhx/vi}/flows/planar.py

@@ -20,9 +20,7 @@ class Planar(Flow):
     """
 
     params: Dict[str, Float[Array, "..."]]
-    constraints: Dict[str, Callable[[Float[Array, "..."]], Float[Array, "..."]]] = (
-        eqx.field(static=True)
-    )
+    constraints: Dict[str, Callable[[Array], Array]]
 
     def __init__(self, dim: int, key=jr.PRNGKey(0)):
         """

bayinx/{machinery/variational → mhx/vi}/flows/radial.py

@@ -21,9 +21,7 @@ class Radial(Flow):
     """
 
     params: Dict[str, Float[Array, "..."]]
-    constraints: Dict[str, Callable[[Float[Array, "..."]], Float[Array, "..."]]] = (
-        eqx.field(static=True)
-    )
+    constraints: Dict[str, Callable[[Float[Array, "..."]], Float[Array, "..."]]]
 
     def __init__(self, dim: int, key=jr.PRNGKey(0)):
         """
@@ -88,7 +86,8 @@ class Radial(Flow):
         # Compute density adjustment
         ladj = jnp.log(
             jnp.abs(
-                (1.0 + alpha * beta / (alpha + r) ** 2.0) * (1.0 + x) ** (center.size - 1.0)
+                (1.0 + alpha * beta / (alpha + r) ** 2.0)
+                * (1.0 + x) ** (center.size - 1.0)
             )
         )
 

bayinx/mhx/vi/flows/sylvester.py

@@ -0,0 +1,19 @@
+from typing import Callable, Dict
+
+from jaxtyping import Array, Float
+
+from bayinx.core import Flow
+
+
+# TODO
+class Sylvester(Flow):
+    """
+    A sylvester flow.
+
+    # Attributes
+    - `params`: A dictionary containing the JAX Arrays representing the flow parameters.
+    - `constraints`: A dictionary of constraining transformations.
+    """
+
+    params: Dict[str, Float[Array, "..."]]
+    constraints: Dict[str, Callable[[Float[Array, "..."]], Float[Array, "..."]]]

bayinx/{machinery/variational → mhx/vi}/meanfield.py

@@ -31,15 +31,15 @@ class MeanField(Variational):
         - `model`: A probabilistic `Model` object.
         """
         # Partition model
-        params, self._constraints = eqx.partition(model, eqx.is_array)
+        params, self._constraints = eqx.partition(model, model.filter_spec())
 
         # Flatten params component
-        flat_params, self._unflatten = ravel_pytree(params)
+        params, self._unflatten = ravel_pytree(params)
 
         # Initialize variational parameters
         self.var_params = {
-            "mean": flat_params,
-            "log_std": jnp.zeros(flat_params.size, dtype=flat_params.dtype),
+            "mean": params,
+            "log_std": jnp.zeros(params.size, dtype=params.dtype),
         }
 
     @eqx.filter_jit

bayinx/{machinery/variational → mhx/vi}/normalizing_flow.py

@@ -23,8 +23,8 @@ class NormalizingFlow(Variational):
 
     flows: list[Flow]
     base: Variational
-    _unflatten: Callable[[Float[Array, "..."]], Model] = eqx.field(static=True)
-    _constraints: Model = eqx.field(static=True)
+    _unflatten: Callable[[Float[Array, "..."]], Model]
+    _constraints: Model
 
     def __init__(self, base: Variational, flows: list[Flow], model: Model):
         """
@@ -39,7 +39,7 @@ class NormalizingFlow(Variational):
         params, self._constraints = eqx.partition(model, eqx.is_array)
 
         # Flatten params component
-        flat_params, self._unflatten = jfu.ravel_pytree(params)
+        _, self._unflatten = jfu.ravel_pytree(params)
 
         self.base = base
         self.flows = flows
@@ -73,7 +73,7 @@ class NormalizingFlow(Variational):
         return variational_evals
 
     @eqx.filter_jit
-    def _eval(self, draws: Array, data=None) -> Tuple[Scalar, Array]:
+    def __eval(self, draws: Array, data=None) -> Tuple[Array, Array]:
         """
         Evaluate the posterior and variational densities at the transformed
         `draws` to avoid extra compute when requiring variational draws for
@@ -84,7 +84,7 @@ class NormalizingFlow(Variational):
         - `data`: Any data required to evaluate the posterior density.
 
         # Returns
-        The posterior and variational densities.
+        The posterior and variational densities as JAX Arrays.
         """
         # Evaluate base density
         variational_evals: Array = self.base.eval(draws)
@@ -102,30 +102,30 @@ class NormalizingFlow(Variational):
         return posterior_evals, variational_evals
 
     def filter_spec(self):
-        # Only optimize the parameters of the flows
+        # Generate empty specification
         filter_spec = jtu.tree_map(lambda _: False, self)
+
+        # Specify variational parameters based on each flow's filter spec.
         filter_spec = eqx.tree_at(
-            lambda nf: nf.flows,
+            lambda vari: vari.flows,
             filter_spec,
-            replace=True,
+            replace=[flow.filter_spec() for flow in self.flows],
         )
 
         return filter_spec
 
     @eqx.filter_jit
     def elbo(self, n: int, key: Key, data: Any = None) -> Scalar:
-        # Partition
         dyn, static = eqx.partition(self, self.filter_spec())
 
         @eqx.filter_jit
         def elbo(dyn: Self, n: int, key: Key, data: Any = None):
-            # Combine
             self = eqx.combine(dyn, static)
 
             # Sample draws from variational distribution
             draws: Array = self.base.sample(n, key)
 
-            posterior_evals, variational_evals = self._eval(draws, data)
+            posterior_evals, variational_evals = self.__eval(draws, data)
             # Evaluate ELBO
             return jnp.mean(posterior_evals - variational_evals)
 
@@ -133,19 +133,17 @@ class NormalizingFlow(Variational):
 
     @eqx.filter_jit
     def elbo_grad(self, n: int, key: Key, data: Any = None) -> Self:
-        # Partition
         dyn, static = eqx.partition(self, self.filter_spec())
 
         @eqx.filter_grad
         @eqx.filter_jit
         def elbo_grad(dyn: Self, n: int, key: Key, data: Any = None):
-            # Combine
             self = eqx.combine(dyn, static)
 
             # Sample draws from variational distribution
             draws: Array = self.base.sample(n, key)
 
-            posterior_evals, variational_evals = self._eval(draws, data)
+            posterior_evals, variational_evals = self.__eval(draws, data)
             # Evaluate ELBO
             return jnp.mean(posterior_evals - variational_evals)
 

bayinx/{machinery/variational → mhx/vi}/standard.py

@@ -13,15 +13,15 @@ from bayinx.dists import normal
 
 class Standard(Variational):
     """
-    A standard normal distribution approximation to a posterior distribution.
+    A standard normal approximation to a posterior distribution.
 
     # Attributes
     - `dim`: Dimension of the parameter space.
     """
 
     dim: int = eqx.field(static=True)
-    _unflatten: Callable[[Float[Array, "..."]], Model] = eqx.field(static=True)
-    _constraints: Model = eqx.field(static=True)
+    _unflatten: Callable[[Float[Array, "..."]], Model]
+    _constraints: Model
 
     def __init__(self, model: Model):
         """
@@ -31,13 +31,13 @@ class Standard(Variational):
         - `model`: A probabilistic `Model` object.
         """
         # Partition model
-        _, self._constraints = eqx.partition(model, eqx.is_array)
+        params, self._constraints = eqx.partition(model, model.filter_spec())
 
         # Flatten params component
-        _, self._unflatten = ravel_pytree(_)
+        params, self._unflatten = ravel_pytree(params)
 
         # Store dimension of parameter space
-        self.dim = jnp.size(_)
+        self.dim = jnp.size(params)
 
     @eqx.filter_jit
     def sample(self, n: int, key: Key = jr.PRNGKey(0)) -> Array:

{bayinx-0.2.6.dist-info → bayinx-0.2.9.dist-info}/METADATA

@@ -1,14 +1,12 @@
 Metadata-Version: 2.4
 Name: bayinx
-Version: 0.2.6
+Version: 0.2.9
 Summary: Bayesian Inference with JAX
 Requires-Python: >=3.12
 Requires-Dist: equinox>=0.11.12
 Requires-Dist: jax>=0.4.38
 Requires-Dist: jaxtyping>=0.2.36
 Requires-Dist: optax>=0.2.4
-Requires-Dist: pytest-benchmark>=5.1.0
-Requires-Dist: pytest>=8.3.5
 Description-Content-Type: text/markdown
 
 # <ins>Bay</ins>esian <ins>In</ins>ference with JA<ins>X</ins>
@@ -23,7 +21,7 @@ In the short-term, I'm going to focus on:
 In the long-term, I'm going to focus on:
 1) How to get `Stan`-like declarative syntax in Python with minimal syntactic overhead(to get as close as possible to statements like `X ~ Normal(mu, 1)`), while also allowing users to work with `target` directly when needed(same as `Stan` does).
 2) How to make working with the posterior as easy as possible.
-    - That's a vague goal but practically it means how to easily evaluate statements like $P(\theta \in [-1, 1] | \mathcal{M})$, or set up contrasts and evaluate $P(\mu_1 - \mu_2 > 0 | \mathcal{M})$, or simulate the posterior predictive to generate plots, etc.
+    - That's a vague goal but practically it means how to easily evaluate statements like $P(\theta \in [-1, 1] | \mathcal{D}, \mathcal{M})$, or set up contrasts and evaluate $P(\mu_1 - \mu_2 > 0 | \mathcal{D}, \mathcal{M})$, or simulate the posterior predictive to generate plots, etc.
 
 Although this is somewhat separate from the goals of the project, if this does pan out how I'm invisioning it I'd like an R formula-like syntax to shorten model construction in scenarios where the model is just a GLMM or similar(think `brms`).
 

bayinx-0.2.9.dist-info/RECORD

@@ -0,0 +1,26 @@
+bayinx/__init__.py,sha256=l20JdkSsE_XGZlZFNEtySXf4NIlbjrao14vXPB-H6aQ,45
+bayinx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bayinx/core/__init__.py,sha256=7vW2F8t3K4TWlSu5nZrYCdUrz5N9FMIfQQBn3IoeH6o,150
+bayinx/core/flow.py,sha256=oZE0OHCninIHjp-WVLFWd1DaN0-qXxNWFAUAdgIDmRU,2423
+bayinx/core/model.py,sha256=-rT3NHjxqGB0lDBMi0Mr9XNOz1_TUnJWtd4ITj0rsus,2257
+bayinx/core/utils.py,sha256=-YewhqzMFL3GJEjVdm3LgaZyHwDs9IVYllU9wAXZrtw,1859
+bayinx/core/variational.py,sha256=yhraTVlNOJaU1NEYVrWpUXVzzWvY1Mq9ZOZv6V0_Vo0,5183
+bayinx/dists/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bayinx/dists/bernoulli.py,sha256=xMV9BgtVX_1XkPdZ43q0meMIEkgMyuUPx--dyo6_DKs,1006
+bayinx/dists/binomial.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bayinx/dists/gamma.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bayinx/dists/gamma2.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bayinx/dists/normal.py,sha256=e9gXXAHeZQKjBndW2TnMvP3gtmvpfYGG7kehcpGeAoU,2590
+bayinx/mhx/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+bayinx/mhx/vi/__init__.py,sha256=YfkXKsqo9Dk_AmQGjZKm4vfG8eLer2ez92G-cOExphs,193
+bayinx/mhx/vi/meanfield.py,sha256=LNLwfjKO9os7YBmRBpGEiFxlxonuN7DHVFEmXV3hvfI,3876
+bayinx/mhx/vi/normalizing_flow.py,sha256=V0-R2Nc_3Vy5c2rkjDOwIutA0G-_kN6trxjwsT5FgsA,4774
+bayinx/mhx/vi/standard.py,sha256=m5gtcHfrYzV28h-Red3Zn6SxEgJlndeIXiIG5gDPecU,1703
+bayinx/mhx/vi/flows/__init__.py,sha256=V_Ng5cecKlLlFSI9ncmaiyvoy_d2EAfeDhBFcy5aQhA,168
+bayinx/mhx/vi/flows/affine.py,sha256=a205nNx6KRvOwGlnjI6YeDo7OTWPPIxffGZfAcTecNA,1707
+bayinx/mhx/vi/flows/planar.py,sha256=0BGdMm-GpTCJnxq9cOrgLl8IsHgGIL0eSFagWJNVdqQ,1944
+bayinx/mhx/vi/flows/radial.py,sha256=c-SWybGn_jmgBQk9ZMQ5uHKPzcdhowNp8MD8t1-8VZM,2501
+bayinx/mhx/vi/flows/sylvester.py,sha256=ppK0BmS_ThvrCEhJiP_-p-kj67TQHSlU_RUZpDbIhsQ,469
+bayinx-0.2.9.dist-info/METADATA,sha256=xp6L_DdXPC-TMHV4SL5LdIuhzX8GizUlx2muMgSFcy0,3057
+bayinx-0.2.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bayinx-0.2.9.dist-info/RECORD,,

bayinx/machinery/variational/__init__.py

@@ -1,5 +0,0 @@
-from bayinx.machinery.variational.meanfield import MeanField as MeanField
-from bayinx.machinery.variational.normalizing_flow import (
-    NormalizingFlow as NormalizingFlow,
-)
-from bayinx.machinery.variational.standard import Standard as Standard

bayinx/machinery/variational/flows/__init__.py

@@ -1,3 +0,0 @@
-from bayinx.machinery.variational.flows.affine import Affine as Affine
-from bayinx.machinery.variational.flows.planar import Planar as Planar
-from bayinx.machinery.variational.flows.radial import Radial as Radial

bayinx/machinery/variational/flows/sylvester.py

@@ -1,76 +0,0 @@
-from functools import partial
-from typing import Callable, Dict, Tuple
-
-import equinox as eqx
-import jax
-import jax.numpy as jnp
-import jax.random as jr
-from jaxtyping import Array, Float, Scalar
-
-from bayinx.core import Flow
-
-
-class Sylvester(Flow):
-    """
-    A sylvester flow.
-
-    # Attributes
-    - `params`: A dictionary containing the JAX Arrays representing the flow parameters.
-    - `constraints`: A dictionary of constraining transformations.
-    """
-
-    params: Dict[str, Float[Array, "..."]]
-    constraints: Dict[str, Callable[[Float[Array, "..."]], Float[Array, "..."]]] = (
-        eqx.field(static=True)
-    )
-
-    def __init__(self, dim: int, key=jr.PRNGKey(0)):
-        """
-        Initializes a planar flow.
-
-        # Parameters
-        - `dim`: The dimension of the parameter space.
-        """
-        self.params = {
-            "u": jr.normal(key, (dim,)),
-            "w": jr.normal(key, (dim,)),
-            "b": jr.normal(key, (1,)),
-        }
-        self.constraints = {}
-
-    @eqx.filter_jit
-    @partial(jax.vmap, in_axes=(None, 0))
-    def forward(self, draws: Array) -> Array:
-        params = self.constrain_pars()
-
-        # Extract parameters
-        w: Array = params["w"]
-        u: Array = params["u"]
-        b: Array = params["b"]
-
-        # Compute forward transformation
-        draws = draws + u * jnp.tanh(draws.dot(w) + b)
-
-        return draws
-
-    @eqx.filter_jit
-    @partial(jax.vmap, in_axes=(None, 0))
-    def adjust_density(self, draws: Array) -> Tuple[Scalar, Array]:
-        params = self.constrain_pars()
-
-        # Extract parameters
-        w: Array = params["w"]
-        u: Array = params["u"]
-        b: Array = params["b"]
-
-        # Compute shared intermediates
-        x: Array = draws.dot(w) + b
-
-        # Compute forward transformation
-        draws = draws + u * jnp.tanh(x)
-
-        # Compute ladj
-        h_prime: Scalar = 1.0 - jnp.square(jnp.tanh(x))
-        ladj: Scalar = jnp.log(jnp.abs(1.0 + h_prime * u.dot(w)))
-
-        return ladj, draws

bayinx-0.2.6.dist-info/RECORD

@@ -1,26 +0,0 @@
-bayinx/__init__.py,sha256=l20JdkSsE_XGZlZFNEtySXf4NIlbjrao14vXPB-H6aQ,45
-bayinx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bayinx/core/__init__.py,sha256=7vW2F8t3K4TWlSu5nZrYCdUrz5N9FMIfQQBn3IoeH6o,150
-bayinx/core/flow.py,sha256=4vj1t2xNPGp1VPE4xUshY-rHAw__KvSwjGDtKkW2taE,2252
-bayinx/core/model.py,sha256=AI4eHrXAds3K7eWgZ9g5E6Kh76HP6WTn6s6q_0tnhck,1719
-bayinx/core/utils.py,sha256=-YewhqzMFL3GJEjVdm3LgaZyHwDs9IVYllU9wAXZrtw,1859
-bayinx/core/variational.py,sha256=T42uUNkF2tP1HJPyeIv7ISdika_G28wR_OOFXzx_hgo,4978
-bayinx/dists/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bayinx/dists/bernoulli.py,sha256=xMV9BgtVX_1XkPdZ43q0meMIEkgMyuUPx--dyo6_DKs,1006
-bayinx/dists/binomial.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bayinx/dists/gamma.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bayinx/dists/gamma2.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bayinx/dists/normal.py,sha256=e9gXXAHeZQKjBndW2TnMvP3gtmvpfYGG7kehcpGeAoU,2590
-bayinx/machinery/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bayinx/machinery/variational/__init__.py,sha256=5GdhqBOHKsXg2tZGAMNlxyrLPD0-s64wAEy8998cHZ4,247
-bayinx/machinery/variational/meanfield.py,sha256=stI96DNhHNIROnr8rLNEN9SN_0lXqkwit0KNto34Q6A,3889
-bayinx/machinery/variational/normalizing_flow.py,sha256=qypgPq9vIqSIJNOHCDaN-hvwFfttNQ5_yXqvmi5hslI,4796
-bayinx/machinery/variational/standard.py,sha256=IQdNd5QIE8u3zcOw7K4EW69lIQ0ZUGGDvwZVyvrYHxA,1739
-bayinx/machinery/variational/flows/__init__.py,sha256=VGh-ffuUfMso_0JxwGCJQ2yVnFJdOrkFsSnorojQldY,213
-bayinx/machinery/variational/flows/affine.py,sha256=TPyUUPRoSkyDMwGO5wtq-Ei8DAUvlb_N6JCk7uPlbJQ,1748
-bayinx/machinery/variational/flows/planar.py,sha256=rJ1XpqoWzig_5Udq6oCh5JV4ptlTRLRS7tb9DCX22lE,2013
-bayinx/machinery/variational/flows/radial.py,sha256=NF1tCd_PH6m8eqjJkom2c30sRUQ04Vf8zeRx_RQCDcg,2526
-bayinx/machinery/variational/flows/sylvester.py,sha256=DeZl4Fkz9XpCGsfDcjS0eWlrMR0xMO0MPfJvoDhixSA,2019
-bayinx-0.2.6.dist-info/METADATA,sha256=LGWQJPIHXjtLo7f6X_bsNMwnu5DfKpJ9kRTAJ91fxKU,3099
-bayinx-0.2.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bayinx-0.2.6.dist-info/RECORD,,