bayinx 0.2.33__py3-none-any.whl → 0.3.1__py3-none-any.whl

bayinx/__init__.py

@@ -1 +1,2 @@
-from bayinx.core.model import Model as Model
+from bayinx.core import Model as Model
+from bayinx.core import Parameter as Parameter

bayinx/constraints/lower.py

@@ -1,9 +1,12 @@
 from typing import Tuple
 
+import equinox as eqx
 import jax.numpy as jnp
-from jaxtyping import Array, ArrayLike, Scalar, ScalarLike
+import jax.tree as jt
+from jaxtyping import PyTree, Scalar, ScalarLike
 
 from bayinx.core.constraint import Constraint
+from bayinx.core.parameter import Parameter
 
 
 class Lower(Constraint):
@@ -11,27 +14,38 @@ class Lower(Constraint):
     Enforces a lower bound on the parameter.
     """
 
-    lb: ScalarLike
+    lb: Scalar
 
     def __init__(self, lb: ScalarLike):
-        self.lb = lb
+        self.lb = jnp.array(lb)
 
-    def constrain(self, x: ArrayLike) -> Tuple[Array, Scalar]:
+    @eqx.filter_jit
+    def constrain(self, x: Parameter) -> Tuple[Parameter, Scalar]:
         """
-        Applies the lower bound constraint and adjusts the posterior density.
+        Enforces a lower bound on the parameter and adjusts the posterior density.
 
         # Parameters
-        - `x`: The unconstrained JAX Array-like input.
+        - `x`: The unconstrained `Parameter`.
 
         # Parameters
         A tuple containing:
-            - The constrained JAX Array (x > self.lb).
-            - A scalar JAX Array representing the log-absolute-Jacobian of the transformation.
+            - A modified `Parameter` with relevant leaves satisfying the constraint.
+            - A scalar Array representing the log-absolute-Jacobian of the transformation.
         """
-        # Compute transformation adjustment
-        laj: Scalar = jnp.sum(x)
+        # Extract relevant filter specification
+        filter_spec = x.filter_spec
+
+        # Extract relevant parameters(all Array)
+        dyn_params, static_params = eqx.partition(x, filter_spec)
+
+        # Compute density adjustment
+        laj: PyTree = jt.map(jnp.sum, dyn_params) # pyright: ignore
+        laj: Scalar = jt.reduce(lambda a,b: a + b, laj)
 
         # Compute transformation
-        x = jnp.exp(x) + self.lb
+        dyn_params = jt.map(lambda v: jnp.exp(v) + self.lb, dyn_params)
+
+        # Combine into full parameter object
+        x = eqx.combine(dyn_params, static_params)
 
         return x, laj

bayinx/core/__init__.py

@@ -1,3 +1,4 @@
 from bayinx.core.flow import Flow as Flow
 from bayinx.core.model import Model as Model
+from bayinx.core.parameter import Parameter as Parameter
 from bayinx.core.variational import Variational as Variational

bayinx/core/constraint.py

@@ -2,7 +2,9 @@ from abc import abstractmethod
 from typing import Tuple
 
 import equinox as eqx
-from jaxtyping import Array, ArrayLike, Scalar
+from jaxtyping import Scalar
+
+from bayinx.core.parameter import Parameter
 
 
 class Constraint(eqx.Module):
@@ -11,16 +13,16 @@ class Constraint(eqx.Module):
     """
 
     @abstractmethod
-    def constrain(self, x: ArrayLike) -> Tuple[Array, Scalar]:
+    def constrain(self, x: Parameter) -> Tuple[Parameter, Scalar]:
         """
-        Applies the constraining transformation to an unconstrained input and computes the log-absolute-Jacobian of the transformation.
+        Applies the constraining transformation to a parameter and computes the log-absolute-Jacobian of the transformation.
 
         # Parameters
-        - `x`: The unconstrained JAX Array-like input.
+        - `x`: The unconstrained `Parameter`.
 
         # Returns
         A tuple containing:
-            - The constrained JAX Array.
-            - A scalar JAX Array representing the log-absolute-Jacobian of the transformation.
+            - The constrained `Parameter`.
+            - A scalar Array representing the log-absolute-Jacobian of the transformation.
         """
         pass

bayinx/core/flow.py

@@ -31,11 +31,13 @@ class Flow(eqx.Module):
         Computes the log-absolute-Jacobian at `draws` and applies the forward transformation.
 
         # Returns
-        A tuple of JAX Arrays containing the transformed draws and log-absolute-Jacobians.
+            A tuple of JAX Arrays containing the transformed draws and log-absolute-Jacobians.
         """
         pass
 
     # Default filter specification
+    @property
+    @eqx.filter_jit
     def filter_spec(self):
         """
         Generates a filter specification to subset relevant parameters for the flow.
@@ -53,7 +55,7 @@ class Flow(eqx.Module):
         return filter_spec
 
     @eqx.filter_jit
-    def constrain_pars(self: Self):
+    def constrain_params(self: Self):
         """
         Constrain `params` to the appropriate domain.
 
@@ -68,11 +70,11 @@ class Flow(eqx.Module):
         return t_params
 
     @eqx.filter_jit
-    def transform_pars(self: Self) -> Dict[str, Array]:
+    def transform_params(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()
+        return self.constrain_params()

bayinx/core/model.py

@@ -1,24 +1,25 @@
 from abc import abstractmethod
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, Generic, Tuple, TypeVar
 
 import equinox as eqx
 import jax.numpy as jnp
 import jax.tree as jt
-from jaxtyping import Array, PyTree, Scalar
+from jaxtyping import PyTree, Scalar
 
 from bayinx.core.constraint import Constraint
+from bayinx.core.parameter import Parameter
 
-
-class Model(eqx.Module):
+T = TypeVar('T', bound=PyTree)
+class Model(eqx.Module, Generic[T]):
     """
     An abstract base class used to define probabilistic models.
 
     # Attributes
-    - `params`: A dictionary of JAX Arrays representing parameters of the model.
+    - `params`: A dictionary of parameters.
     - `constraints`: A dictionary of constraints.
     """
 
-    params: Dict[str, PyTree]
+    params: Dict[str, Parameter[T]]
     constraints: Dict[str, Constraint]
 
     @abstractmethod
@@ -26,6 +27,8 @@ class Model(eqx.Module):
         pass
 
     # Default filter specification
+    @property
+    @eqx.filter_jit
     def filter_spec(self):
         """
         Generates a filter specification to subset relevant parameters for the model.
@@ -33,25 +36,25 @@ class Model(eqx.Module):
         # Generate empty specification
         filter_spec = jt.map(lambda _: False, self)
 
-        # Specify JAX Array parameters
+        # Specify relevant parameters
         filter_spec = eqx.tree_at(
             lambda model: model.params,
             filter_spec,
-            replace=jt.map(eqx.is_array, self.params),
+            replace={key: param.filter_spec for key, param in self.params.items()}
         )
 
         return filter_spec
 
     # Add constrain method
     @eqx.filter_jit
-    def constrain_pars(self) -> Tuple[Dict[str, Array], Scalar]:
+    def constrain_params(self) -> Tuple[Dict[str, Parameter[T]], Scalar]:
         """
         Constrain `params` to the appropriate domain.
 
         # Returns
-        A dictionary of transformed JAX Arrays representing the constrained parameters and the adjustment to the posterior density.
+        A dictionary of PyTrees representing the constrained parameters and the adjustment to the posterior density.
         """
-        t_params: Dict[str, Array] = self.params
+        t_params: Dict[str, Parameter[T]] = self.params
         target: Scalar = jnp.array(0.0)
 
         for par, map in self.constraints.items():
@@ -64,11 +67,12 @@ class Model(eqx.Module):
         return t_params, target
 
     # Add default transform method
-    def transform_pars(self) -> Tuple[Dict[str, Array], Scalar]:
+    @eqx.filter_jit
+    def transform_params(self) -> Tuple[Dict[str, Parameter[T]], Scalar]:
         """
         Apply a custom transformation to `params` if needed.
 
         # Returns
         A dictionary of transformed JAX Arrays representing the transformed parameters.
         """
-        return self.constrain_pars()
+        return self.constrain_params()

bayinx/core/parameter.py

@@ -0,0 +1,41 @@
+from typing import Generic, Self, TypeVar
+
+import equinox as eqx
+import jax.tree as jt
+from jaxtyping import PyTree
+
+T = TypeVar('T', bound=PyTree)
+class Parameter(eqx.Module, Generic[T]):
+    """
+    A container for a parameter of a `Model`.
+
+    Subclasses can be constructed for custom filter specifications(`filter_spec`).
+
+    # Attributes
+    - `vals`: The parameter's value(s).
+    """
+    vals: T
+
+
+    def __init__(self, values: T):
+        # Insert parameter values
+        self.vals = values
+
+    # Default filter specification
+    @property
+    @eqx.filter_jit
+    def filter_spec(self) -> Self:
+        """
+        Generates a filter specification to filter out static parameters.
+        """
+        # Generate empty specification
+        filter_spec = jt.map(lambda _: False, self)
+
+        # Specify Array leaves
+        filter_spec = eqx.tree_at(
+            lambda params: params.vals,
+            filter_spec,
+            replace=jt.map(eqx.is_array_like, self.vals),
+        )
+
+        return filter_spec

bayinx/core/variational.py

@@ -103,7 +103,7 @@ class Variational(eqx.Module):
         - `key`: A PRNG key.
         """
         # Partition variational
-        dyn, static = eqx.partition(self, self.filter_spec())
+        dyn, static = eqx.partition(self, self.filter_spec)
 
         # Construct scheduler
         schedule: Schedule = opx.cosine_decay_schedule(
@@ -143,7 +143,7 @@ class Variational(eqx.Module):
 
             # Compute updates
             updates, opt_state = optim.update(
-                updates, opt_state, eqx.filter(dyn, dyn.filter_spec())
+                updates, opt_state, eqx.filter(dyn, dyn.filter_spec)
             )
 
             # Update variational distribution

bayinx/mhx/vi/flows/fullaffine.py

@@ -46,7 +46,7 @@ class FullAffine(Flow):
 
     @eqx.filter_jit
     def forward(self, draws: Array) -> Array:
-        params = self.transform_pars()
+        params = self.transform_params()
 
         # Extract parameters
         shift: Array = params["shift"]
@@ -60,7 +60,7 @@ class FullAffine(Flow):
     @eqx.filter_jit
     @partial(jax.vmap, in_axes=(None, 0))
     def adjust_density(self, draws: Array) -> Tuple[Array, Scalar]:
-        params = self.transform_pars()
+        params = self.transform_params()
 
         # Extract parameters
         shift: Array = params["shift"]

bayinx/mhx/vi/flows/planar.py

@@ -39,7 +39,7 @@ class Planar(Flow):
     @eqx.filter_jit
     @partial(jax.vmap, in_axes=(None, 0))
     def forward(self, draws: Array) -> Array:
-        params = self.transform_pars()
+        params = self.transform_params()
 
         # Extract parameters
         w: Array = params["w"]
@@ -54,7 +54,7 @@ class Planar(Flow):
     @eqx.filter_jit
     @partial(jax.vmap, in_axes=(None, 0))
     def adjust_density(self, draws: Array) -> Tuple[Array, Scalar]:
-        params = self.transform_pars()
+        params = self.transform_params()
 
         # Extract parameters
         w: Array = params["w"]

bayinx/mhx/vi/flows/radial.py

@@ -49,7 +49,7 @@ class Radial(Flow):
         # Returns
         The transformed samples.
         """
-        params = self.transform_pars()
+        params = self.transform_params()
 
         # Extract parameters
         alpha = params["alpha"]
@@ -67,7 +67,7 @@ class Radial(Flow):
     @partial(jax.vmap, in_axes=(None, 0))
     @eqx.filter_jit
     def adjust_density(self, draws: Array) -> Tuple[Array, Scalar]:
-        params = self.transform_pars()
+        params = self.transform_params()
 
         # Extract parameters
         alpha = params["alpha"]

bayinx/mhx/vi/meanfield.py

@@ -29,7 +29,7 @@ class MeanField(Variational):
         - `model`: A probabilistic `Model` object.
         """
         # Partition model
-        params, self._constraints = eqx.partition(model, model.filter_spec())
+        params, self._constraints = eqx.partition(model, model.filter_spec)
 
         # Flatten params component
         params, self._unflatten = ravel_pytree(params)
@@ -40,6 +40,22 @@ class MeanField(Variational):
             "log_std": jnp.zeros(params.size, dtype=params.dtype),
         }
 
+    @property
+    @eqx.filter_jit
+    def filter_spec(self):
+        # Generate empty specification
+        filter_spec = jtu.tree_map(lambda _: False, self)
+
+        # Specify variational parameters
+        filter_spec = eqx.tree_at(
+            lambda mf: mf.var_params,
+            filter_spec,
+            replace=True,
+        )
+
+        return filter_spec
+
+
     @eqx.filter_jit
     def sample(self, n: int, key: Key = jr.PRNGKey(0)) -> Array:
         # Sample variational draws
@@ -59,23 +75,9 @@ class MeanField(Variational):
             sigma=jnp.exp(self.var_params["log_std"]),
         ).sum(axis=1)
 
-    @eqx.filter_jit
-    def filter_spec(self):
-        # Generate empty specification
-        filter_spec = jtu.tree_map(lambda _: False, self)
-
-        # Specify variational parameters
-        filter_spec = eqx.tree_at(
-            lambda mf: mf.var_params,
-            filter_spec,
-            replace=True,
-        )
-
-        return filter_spec
-
     @eqx.filter_jit
     def elbo(self, n: int, key: Key, data: Any = None) -> Scalar:
-        dyn, static = eqx.partition(self, self.filter_spec())
+        dyn, static = eqx.partition(self, self.filter_spec)
 
         @eqx.filter_jit
         def elbo(dyn: Self, n: int, key: Key, data: Any = None) -> Scalar:
@@ -97,7 +99,7 @@ class MeanField(Variational):
 
     @eqx.filter_jit
     def elbo_grad(self, n: int, key: Key, data: Any = None) -> Self:
-        dyn, static = eqx.partition(self, self.filter_spec())
+        dyn, static = eqx.partition(self, self.filter_spec)
 
         @eqx.filter_grad
         @eqx.filter_jit

bayinx/mhx/vi/normalizing_flow.py

@@ -33,7 +33,7 @@ class NormalizingFlow(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
         _, self._unflatten = jfu.ravel_pytree(params)
@@ -41,6 +41,8 @@ class NormalizingFlow(Variational):
         self.base = base
         self.flows = flows
 
+    @property
+    @eqx.filter_jit
     def filter_spec(self):
         # Generate empty specification
         filter_spec = jtu.tree_map(lambda _: False, self)
@@ -49,7 +51,7 @@ class NormalizingFlow(Variational):
         filter_spec = eqx.tree_at(
             lambda vari: vari.flows,
             filter_spec,
-            replace=[flow.filter_spec() for flow in self.flows],
+            replace=[flow.filter_spec for flow in self.flows],
         )
 
         return filter_spec
@@ -112,7 +114,7 @@ class NormalizingFlow(Variational):
 
     @eqx.filter_jit
     def elbo(self, n: int, key: Key = jr.PRNGKey(0), data: Any = None) -> Scalar:
-        dyn, static = eqx.partition(self, self.filter_spec())
+        dyn, static = eqx.partition(self, self.filter_spec)
 
         @eqx.filter_jit
         def elbo(dyn: Self, n: int, key: Key, data: Any = None):
@@ -129,7 +131,7 @@ class NormalizingFlow(Variational):
 
     @eqx.filter_jit
     def elbo_grad(self, n: int, key: Key, data: Any = None) -> Self:
-        dyn, static = eqx.partition(self, self.filter_spec())
+        dyn, static = eqx.partition(self, self.filter_spec)
 
         @eqx.filter_grad
         @eqx.filter_jit

bayinx/mhx/vi/standard.py

@@ -19,7 +19,7 @@ class Standard(Variational):
     - `dim`: Dimension of the parameter space.
     """
 
-    dim: int = eqx.field(static=True)
+    dim: int
     _unflatten: Callable[[Float[Array, "..."]], Model]
     _constraints: Model
 
@@ -31,7 +31,7 @@ class Standard(Variational):
         - `model`: A probabilistic `Model` object.
         """
         # Partition model
-        params, self._constraints = eqx.partition(model, model.filter_spec())
+        params, self._constraints = eqx.partition(model, model.filter_spec)
 
         # Flatten params component
         params, self._unflatten = ravel_pytree(params)
@@ -54,7 +54,7 @@ class Standard(Variational):
             sigma=jnp.array(1.0),
         ).sum(axis=1, keepdims=True)
 
-    @eqx.filter_jit
+    @property
     def filter_spec(self):
         filter_spec = jtu.tree_map(lambda _: False, self)
 

{bayinx-0.2.33.dist-info → bayinx-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bayinx
-Version: 0.2.33
+Version: 0.3.1
 Summary: Bayesian Inference with JAX
 Requires-Python: >=3.12
 Requires-Dist: equinox>=0.11.12

bayinx-0.3.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+bayinx/__init__.py,sha256=htihTsJ54k-ljBLzt4ye8DR7ORwZhxv-bLMcEaDQeqY,86
+bayinx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bayinx/constraints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bayinx/constraints/lower.py,sha256=wkYnWjaAEGQeXKfBo_gY0pcK9ElJUMkzGdAmWI8ykCk,1488
+bayinx/core/__init__.py,sha256=jSwEFdXqi-Bj_X8_H-YuaXp5ebEQpZTG2T18zpquzPo,207
+bayinx/core/constraint.py,sha256=F6-TXQjzt-tcNm8bHkRcGEtyE9bZQf2RbAh_MKDuM20,760
+bayinx/core/flow.py,sha256=lAPJdQnrIxC3JoowTp77Gvm0p0v_xQn8FMjFJWMnWbc,2340
+bayinx/core/model.py,sha256=RKAtsLXc6xDnXWz5upmx6Vz6JOoorw4WTfxTA7B7Lmg,2294
+bayinx/core/parameter.py,sha256=oxCCZcZ-DDBvfWzexfhQkSJPxNQnE1vYXtBhiEZG2bM,1025
+bayinx/core/variational.py,sha256=lqENISRrKY8ODLtl0D-D7TAA2gD7HGh37BnROM7p5hI,4783
+bayinx/dists/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bayinx/dists/bernoulli.py,sha256=xMV9BgtVX_1XkPdZ43q0meMIEkgMyuUPx--dyo6_DKs,1006
+bayinx/dists/gamma2.py,sha256=8XYaOtcYJCrr5q1yHWfZaMJmASpLOrfyhrH_J06ksj8,1333
+bayinx/dists/normal.py,sha256=mvm6EoAlORy-yivuhMcExYCZUo0vJzMKMOWH-9iQBZU,2634
+bayinx/dists/uniform.py,sha256=7XgVvOrzINEFA6HJTYUOFwlWhEtrQQQ1aPJ_ZLOzLEc,2365
+bayinx/dists/censored/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bayinx/dists/censored/gamma2/r.py,sha256=3brRCKhE-74mRXyIyPcnyaWY2OJv8CZyUWPP9T1t09Y,2274
+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=M4QrOuHaIMLTuQSD6JNF9vELnTm370tXV68JPB7B67M,3652
+bayinx/mhx/vi/normalizing_flow.py,sha256=9c5ayMJ_Wgq6pUb1GYHIFIzw3Bf1AsIdOjcerLoYMrA,4655
+bayinx/mhx/vi/standard.py,sha256=DfSV0r9oXzp9UM8OsZBpoJPRUhiDoAq_X2_2z_M83lA,1685
+bayinx/mhx/vi/flows/__init__.py,sha256=Hn0Wqvvyv8Vr-mFmimwgNKCByxj-fjrlIvdR7tUSolg,180
+bayinx/mhx/vi/flows/fullaffine.py,sha256=11y_A0oO3bkKDSz-EQ6Sf4Ec2M7vHZxw94EdvADwVYQ,1954
+bayinx/mhx/vi/flows/planar.py,sha256=2I2WzIskl8MRpJkK13FQE3vSF-077qo8gRed_EL1Pn8,1920
+bayinx/mhx/vi/flows/radial.py,sha256=e0GfuO-CL8SVr3YnEfsxStpyKcJlFpzMyjMp3sa38hg,2503
+bayinx/mhx/vi/flows/sylvester.py,sha256=ppK0BmS_ThvrCEhJiP_-p-kj67TQHSlU_RUZpDbIhsQ,469
+bayinx-0.3.1.dist-info/METADATA,sha256=Slp2nxR8HISCwCqIXY2El3GgqsO1v9_UbVeJq726w7k,3057
+bayinx-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bayinx-0.3.1.dist-info/RECORD,,

bayinx-0.2.33.dist-info/RECORD

@@ -1,29 +0,0 @@
-bayinx/__init__.py,sha256=l20JdkSsE_XGZlZFNEtySXf4NIlbjrao14vXPB-H6aQ,45
-bayinx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bayinx/constraints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bayinx/constraints/lower.py,sha256=MAAsWpZhqu1ySMskQ0fPVkCzW6CVDCU67q2bkCyzbLc,936
-bayinx/core/__init__.py,sha256=7vW2F8t3K4TWlSu5nZrYCdUrz5N9FMIfQQBn3IoeH6o,150
-bayinx/core/constraint.py,sha256=60KzDILVLQTCY3jt4YEnNKJ5gnG8IHTv_nNqrdwt_3c,751
-bayinx/core/flow.py,sha256=A5Vw5t76LPasnMgghjw6ulBkIm5L2jBprusVt-tuwko,2296
-bayinx/core/model.py,sha256=7Gt7HkFLzSUbRY9PxTDp6CrXzmld25NL9aQo34ePeno,2135
-bayinx/core/variational.py,sha256=2stsYKZDri1rLP7mrz7X2GWehBXNESdlWtmF2N9CEas,4787
-bayinx/dists/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bayinx/dists/bernoulli.py,sha256=xMV9BgtVX_1XkPdZ43q0meMIEkgMyuUPx--dyo6_DKs,1006
-bayinx/dists/gamma2.py,sha256=8XYaOtcYJCrr5q1yHWfZaMJmASpLOrfyhrH_J06ksj8,1333
-bayinx/dists/normal.py,sha256=mvm6EoAlORy-yivuhMcExYCZUo0vJzMKMOWH-9iQBZU,2634
-bayinx/dists/uniform.py,sha256=7XgVvOrzINEFA6HJTYUOFwlWhEtrQQQ1aPJ_ZLOzLEc,2365
-bayinx/dists/censored/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bayinx/dists/censored/gamma2/r.py,sha256=3brRCKhE-74mRXyIyPcnyaWY2OJv8CZyUWPP9T1t09Y,2274
-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=BobfTagVGA5R-dclv-E0jSA80KZg1X6GGjiw7XR61vE,3643
-bayinx/mhx/vi/normalizing_flow.py,sha256=DYhvTiu2Fr5x8KpWAMZVUaio7ctG2X2SMUO0l8zfZ5g,4622
-bayinx/mhx/vi/standard.py,sha256=HaJsIz70Qo1Ql2hMQ-GQhcnfWiOGtyxgkOsm_yQaDKI,1718
-bayinx/mhx/vi/flows/__init__.py,sha256=Hn0Wqvvyv8Vr-mFmimwgNKCByxj-fjrlIvdR7tUSolg,180
-bayinx/mhx/vi/flows/fullaffine.py,sha256=Z_G2Cg90Asgvqel8buMx5kEVsiIxDDh8rc-L_nP9OCY,1950
-bayinx/mhx/vi/flows/planar.py,sha256=WVj-oxcRctuoRA6KJjU63ek1ZgKNG2vI-TLN0QqjtKA,1916
-bayinx/mhx/vi/flows/radial.py,sha256=Obj3SraliawIHmP14F9wRpWt34y3kscY--Izy24eCvM,2499
-bayinx/mhx/vi/flows/sylvester.py,sha256=ppK0BmS_ThvrCEhJiP_-p-kj67TQHSlU_RUZpDbIhsQ,469
-bayinx-0.2.33.dist-info/METADATA,sha256=8d-BDtz7NrXSs5kJd-9Yr5zHTzEPtQvhgZGD-3VX7FI,3058
-bayinx-0.2.33.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bayinx-0.2.33.dist-info/RECORD,,