diff --git a/benchmarks/stateful_paths.py b/benchmarks/stateful_paths.py new file mode 100644 index 00000000..9551ce29 --- /dev/null +++ b/benchmarks/stateful_paths.py @@ -0,0 +1,284 @@ +import math +from typing import cast, Optional, Union + +import diffrax +import equinox as eqx +import equinox.internal as eqxi +import jax +import jax.numpy as jnp +import jax.random as jr +import jax.tree_util as jtu +import lineax.internal as lxi +from jaxtyping import PRNGKeyArray, PyTree +from lineax.internal import complex_to_real_dtype + + +class OldBrownianPath(diffrax.AbstractBrownianPath): + shape: PyTree[jax.ShapeDtypeStruct] = eqx.field(static=True) + levy_area: type[ + Union[ + diffrax.BrownianIncrement, + diffrax.SpaceTimeLevyArea, + diffrax.SpaceTimeTimeLevyArea, + ] + ] = eqx.field(static=True) + key: PRNGKeyArray + precompute: Optional[int] = eqx.field(static=True) + + def __init__( + self, + shape, + key, + levy_area=diffrax.BrownianIncrement, + precompute=None, + ): + self.shape = ( + jax.ShapeDtypeStruct(shape, lxi.default_floating_dtype()) + if diffrax._misc.is_tuple_of_ints(shape) + else shape + ) + self.key = key + self.levy_area = levy_area + self.precompute = precompute + + if any( + not jnp.issubdtype(x.dtype, jnp.inexact) + for x in jtu.tree_leaves(self.shape) + ): + raise ValueError("OldBrownianPath dtypes all have to be floating-point.") + + @property + def t0(self): + return -jnp.inf + + @property + def t1(self): + return jnp.inf + + def init( + self, + t0, + t1, + y0, + args, + ): + return None + + def __call__( + self, + t0, + brownian_state, + t1=None, + left=True, + use_levy=False, + ): + return self.evaluate(t0, t1, left, use_levy), brownian_state + + @eqx.filter_jit + def evaluate( + self, + t0, + t1=None, + left=True, + use_levy=False, + ): + del left + if t1 is None: + dtype = jnp.result_type(t0) + t1 = t0 + t0 = jnp.array(0, dtype) + else: + with jax.numpy_dtype_promotion("standard"): + dtype = jnp.result_type(t0, t1) + t0 = jnp.astype(t0, dtype) + t1 = jnp.astype(t1, dtype) + t0 = eqxi.nondifferentiable(t0, name="t0") + t1 = eqxi.nondifferentiable(t1, name="t1") + t1 = cast(diffrax._custom_types.RealScalarLike, t1) + t0_ = diffrax._misc.force_bitcast_convert_type(t0, jnp.int32) + t1_ = diffrax._misc.force_bitcast_convert_type(t1, jnp.int32) + key = jr.fold_in(self.key, t0_) + key = jr.fold_in(key, t1_) + key = diffrax._misc.split_by_tree(key, self.shape) + out = jtu.tree_map( + lambda key, shape: self._evaluate_leaf( + t0, t1, key, shape, self.levy_area, use_levy + ), + key, + self.shape, + ) + if use_levy: + out = diffrax._custom_types.levy_tree_transpose(self.shape, out) + assert isinstance(out, self.levy_area) + return out + + @staticmethod + def _evaluate_leaf( + t0, + t1, + key, + shape, + levy_area, + use_levy, + ): + w_std = jnp.sqrt(t1 - t0).astype(shape.dtype) + dt = jnp.asarray(t1 - t0, dtype=complex_to_real_dtype(shape.dtype)) + + if levy_area is diffrax.SpaceTimeTimeLevyArea: + key_w, key_hh, key_kk = jr.split(key, 3) + w = jr.normal(key_w, shape.shape, shape.dtype) * w_std + hh_std = w_std / math.sqrt(12) + hh = jr.normal(key_hh, shape.shape, shape.dtype) * hh_std + kk_std = w_std / math.sqrt(720) + kk = jr.normal(key_kk, shape.shape, shape.dtype) * kk_std + levy_val = diffrax.SpaceTimeTimeLevyArea(dt=dt, W=w, H=hh, K=kk) + + elif levy_area is diffrax.SpaceTimeLevyArea: + key_w, key_hh = jr.split(key, 2) + w = jr.normal(key_w, shape.shape, shape.dtype) * w_std + hh_std = w_std / math.sqrt(12) + hh = jr.normal(key_hh, shape.shape, shape.dtype) * hh_std + levy_val = diffrax.SpaceTimeLevyArea(dt=dt, W=w, H=hh) + elif levy_area is diffrax.BrownianIncrement: + w = jr.normal(key, shape.shape, shape.dtype) * w_std + levy_val = diffrax.BrownianIncrement(dt=dt, W=w) + else: + assert False + + if use_levy: + return levy_val + return w + + +# https://github.com/patrick-kidger/diffrax/issues/517 +key = jax.random.key(42) +# t0 = 0 +# t1 = 100 +# y0 = 1.0 +# ndt = 4000 +# dt = (t1 - t0) / (ndt - 1) +# drift = lambda t, y, args: -y +# diffusion = lambda t, y, args: 0.2 +t0 = 0 +t1 = 1 +y0 = 1.0 +ndt = 40010 +dt = (t1 - t0) / (ndt - 1) +drift = lambda t, y, args: -y +diffusion = lambda t, y, args: 0.2 +# saveat = diffrax.SaveAt(ts=jnp.linspace(t0, t1, ndt)) +saveat = diffrax.SaveAt(steps=True) + +brownian_motion = diffrax.VirtualBrownianTree(t0, t1, tol=1e-3, shape=(), key=key) +ubp = OldBrownianPath(shape=(), key=key) +new_ubp = diffrax.UnsafeBrownianPath(shape=(), key=key) +new_ubp_pre = diffrax.UnsafeBrownianPath(shape=(), key=key, precompute=ndt + 10) + +solver = diffrax.Euler() + +terms = diffrax.MultiTerm( + diffrax.ODETerm(drift), diffrax.ControlTerm(diffusion, brownian_motion) +) +terms_old = diffrax.MultiTerm( + diffrax.ODETerm(drift), diffrax.ControlTerm(diffusion, ubp) +) +terms_new = diffrax.MultiTerm( + diffrax.ODETerm(drift), diffrax.ControlTerm(diffusion, new_ubp) +) +terms_new_precompute = diffrax.MultiTerm( + diffrax.ODETerm(drift), diffrax.ControlTerm(diffusion, new_ubp_pre) +) + + +@jax.jit +def diffrax_vbt(): + return diffrax.diffeqsolve( + terms, solver, t0, t1, dt0=dt, y0=y0, saveat=saveat, throw=False + ).ys + + +@jax.jit +def diffrax_old(): + return diffrax.diffeqsolve( + terms_old, solver, t0, t1, dt0=dt, y0=y0, saveat=saveat, throw=False + ).ys + + +@jax.jit +def diffrax_new(): + return diffrax.diffeqsolve( + terms_new, solver, t0, t1, dt0=dt, y0=y0, saveat=saveat, throw=False + ).ys + + +@jax.jit +def diffrax_new_pre(): + return diffrax.diffeqsolve( + terms_new_precompute, solver, t0, t1, dt0=dt, y0=y0, saveat=saveat, throw=False + ).ys + + +@jax.jit +def homemade_simu(): + dWs = jnp.sqrt(dt) * jax.random.normal(key, (ndt,)) + + def step(y, dW): + dy = drift(None, y, None) * dt + diffusion(None, y, None) * dW + return y + dy, y + + return jax.lax.scan(step, y0, dWs)[-1] + + +_ = diffrax_vbt().block_until_ready() +_ = diffrax_old().block_until_ready() +_ = diffrax_new().block_until_ready() +_ = diffrax_new_pre().block_until_ready() +_ = homemade_simu().block_until_ready() + +from timeit import Timer + + +num_runs = 10 + +timer = Timer(stmt="_ = diffrax_vbt().block_until_ready()", globals=globals()) +total_time = timer.timeit(number=num_runs) +print(f"VBT: {total_time / num_runs:.6f}") + +timer = Timer(stmt="_ = diffrax_old().block_until_ready()", globals=globals()) +total_time = timer.timeit(number=num_runs) +print(f"Old UBP: {total_time / num_runs:.6f}") + +timer = Timer(stmt="_ = diffrax_new().block_until_ready()", globals=globals()) +total_time = timer.timeit(number=num_runs) +print(f"New UBP: {total_time / num_runs:.6f}") + +timer = Timer(stmt="_ = diffrax_new_pre().block_until_ready()", globals=globals()) +total_time = timer.timeit(number=num_runs) +print(f"New UBP + Precompute: {total_time / num_runs:.6f}") + +timer = Timer(stmt="_ = homemade_simu().block_until_ready()", globals=globals()) +total_time = timer.timeit(number=num_runs) +print(f"Pure Jax: {total_time / num_runs:.6f}") + +""" +Results on Mac M1 CPU: +VBT: 0.184882 +Old UBP: 0.016347 +New UBP: 0.013731 +New UBP + Precompute: 0.002430 +Pure Jax: 0.002799 + +(these are out of date) +Results on A100 GPU: +VBT: 3.881952 +Old UBP: 0.337173 +New UBP: 0.364158 +New UBP + Precompute: 0.325521 + +For small ndt (e.g. 100) the pure jax is faster, but the diffrax overhead +becomes less important as the time increases. + +GPU being much slower isn't unsurprising and is a common trend for +small-medium sized SDEs with VFs that are relatively cheap to evaluate +(i.e. not neural networks). +""" diff --git a/diffrax/_adjoint.py b/diffrax/_adjoint.py index db701bd2..dbda4b92 100644 --- a/diffrax/_adjoint.py +++ b/diffrax/_adjoint.py @@ -37,7 +37,7 @@ def _is_subsaveat(x: Any) -> bool: def _nondiff_solver_controller_state( - adjoint, init_state, passed_solver_state, passed_controller_state + adjoint, init_state, passed_solver_state, passed_controller_state, passed_path_state ): if passed_solver_state: name = ( @@ -60,6 +60,14 @@ def _nondiff_solver_controller_state( ) else: controller_fn = lax.stop_gradient + if passed_path_state: + name = f"When using `adjoint={adjoint.__class__.__name__}()`, then `path_state`" + path_fn = ft.partial( + eqxi.nondifferentiable, + name=name, + ) + else: + path_fn = lax.stop_gradient init_state = eqx.tree_at( lambda s: s.solver_state, init_state, @@ -72,6 +80,12 @@ def _nondiff_solver_controller_state( replace_fn=controller_fn, is_leaf=_is_none, ) + init_state = eqx.tree_at( + lambda s: s.path_state, + init_state, + replace_fn=path_fn, + is_leaf=_is_none, + ) return init_state @@ -136,6 +150,7 @@ def loop( init_state, passed_solver_state, passed_controller_state, + passed_path_state, progress_meter, ) -> Any: """Runs the main solve loop. Subclasses can override this to provide custom @@ -271,15 +286,16 @@ def loop( throw, passed_solver_state, passed_controller_state, + passed_path_state, **kwargs, ): - del throw, passed_solver_state, passed_controller_state - if is_unsafe_sde(terms): - raise ValueError( - "`adjoint=RecursiveCheckpointAdjoint()` does not support " - "`UnsafeBrownianPath`. Consider using `adjoint=ForwardMode()` " - "instead." - ) + del throw, passed_solver_state, passed_controller_state, passed_path_state + # if is_unsafe_sde(terms): + # raise ValueError( + # "`adjoint=RecursiveCheckpointAdjoint()` does not support " + # "`UnsafeBrownianPath`. Consider using `adjoint=DirectAdjoint()` " + # "instead." + # ) if self.checkpoints is None and max_steps is None: inner_while_loop = ft.partial(_inner_loop, kind="lax") outer_while_loop = ft.partial(_outer_loop, kind="lax") @@ -354,18 +370,22 @@ def loop( throw, passed_solver_state, passed_controller_state, + passed_path_state, **kwargs, ): - del throw, passed_solver_state, passed_controller_state + del throw, passed_solver_state, passed_controller_state, passed_path_state # TODO: remove the `is_unsafe_sde` guard. # We need JAX to release bloops, so that we can deprecate `kind="bounded"`. - if is_unsafe_sde(terms): - kind = "lax" - msg = ( - "Cannot reverse-mode autodifferentiate when using " - "`UnsafeBrownianPath`." - ) - elif max_steps is None: + # if is_unsafe_sde(terms): + # kind = "lax" + # msg = ( + # "Cannot reverse-mode autodifferentiate when using " + # "`UnsafeBrownianPath`." + # ) + # if is_unsafe_sde(terms): + # kind = "lax" + # msg = None + if max_steps is None: kind = "lax" msg = ( "Cannot reverse-mode autodifferentiate when using " @@ -491,6 +511,7 @@ def loop( init_state, passed_solver_state, passed_controller_state, + passed_path_state, **kwargs, ): del throw @@ -502,7 +523,11 @@ def loop( "`saveat=SaveAt(t1=True)`." ) init_state = _nondiff_solver_controller_state( - self, init_state, passed_solver_state, passed_controller_state + self, + init_state, + passed_solver_state, + passed_controller_state, + passed_path_state, ) inputs = (args, terms, self, kwargs, solver, saveat, init_state) ys, residual = optxi.implicit_jvp( @@ -803,6 +828,7 @@ def loop( init_state, passed_solver_state, passed_controller_state, + passed_path_state, event, **kwargs, ): @@ -821,6 +847,10 @@ def loop( raise NotImplementedError( "Cannot use `adjoint=BacksolveAdjoint()` with `saveat=SaveAt(fn=...)`." ) + # is this still true with DirectBP? + # it seems to give inaccurate results, so not currently, but seems doable + # might just require more careful thinking about path state management + # and more knowledge about continuous adjoints than I have currently if is_unsafe_sde(terms): raise ValueError( "`adjoint=BacksolveAdjoint()` does not support `UnsafeBrownianPath`. " @@ -853,7 +883,11 @@ def loop( y = init_state.y init_state = eqx.tree_at(lambda s: s.y, init_state, object()) init_state = _nondiff_solver_controller_state( - self, init_state, passed_solver_state, passed_controller_state + self, + init_state, + passed_solver_state, + passed_controller_state, + passed_path_state, ) final_state, aux_stats = _loop_backsolve( @@ -889,9 +923,10 @@ def loop( throw, passed_solver_state, passed_controller_state, + passed_path_state, **kwargs, ): - del throw, passed_solver_state, passed_controller_state + del throw, passed_solver_state, passed_controller_state, passed_path_state inner_while_loop = eqx.Partial(_inner_loop, kind="lax") outer_while_loop = eqx.Partial(_outer_loop, kind="lax") # Support forward-mode autodiff. diff --git a/diffrax/_brownian/base.py b/diffrax/_brownian/base.py index 21618b76..a4f69045 100644 --- a/diffrax/_brownian/base.py +++ b/diffrax/_brownian/base.py @@ -9,17 +9,60 @@ BrownianIncrement, RealScalarLike, SpaceTimeLevyArea, + SpaceTimeTimeLevyArea, ) from .._path import AbstractPath _Control = TypeVar("_Control", bound=Union[PyTree[Array], AbstractBrownianIncrement]) +_BrownianState = TypeVar("_BrownianState") -class AbstractBrownianPath(AbstractPath[_Control]): +class AbstractBrownianPath(AbstractPath[_Control, _BrownianState]): """Abstract base class for all Brownian paths.""" - levy_area: AbstractVar[type[Union[BrownianIncrement, SpaceTimeLevyArea]]] + levy_area: AbstractVar[ + type[Union[BrownianIncrement, SpaceTimeLevyArea, SpaceTimeTimeLevyArea]] + ] + + @abc.abstractmethod + def __call__( + self, + t0: RealScalarLike, + brownian_state: _BrownianState, + t1: Optional[RealScalarLike] = None, + left: bool = True, + use_levy: bool = False, + ) -> tuple[_Control, _BrownianState]: + r"""Samples a Brownian increment $w(t_1) - w(t_0)$. + + Each increment has distribution $\mathcal{N}(0, t_1 - t_0)$. + + This is equivalent to `evaluate` but enables stateful evaluation. + + **Arguments:** + + - `t0`: Any point in $[t_0, t_1]$ to evaluate the path at. + - `brownian_state`: The current state of the path. + - `t1`: If passed, then the increment from `t1` to `t0` is evaluated instead. + - `left`: Ignored. (This determines whether to treat the path as + left-continuous or right-continuous at any jump points, but Brownian + motion has no jump points.) + - `use_levy`: If True, the return type will be a `LevyVal`, which contains + PyTrees of Brownian increments and their Lévy areas. + + **Returns:** + + If `t1` is not passed: + + The value of the Brownian motion at `t0`. + + If `t1` is passed: + + The increment of the Brownian motion between `t0` and `t1`. + + In both cases, the updated state is also returned. + """ @abc.abstractmethod def evaluate( diff --git a/diffrax/_brownian/path.py b/diffrax/_brownian/path.py index 0333caa5..2efbc89f 100644 --- a/diffrax/_brownian/path.py +++ b/diffrax/_brownian/path.py @@ -1,5 +1,5 @@ import math -from typing import cast, Optional, Union +from typing import cast, Optional, TypeAlias, Union import equinox as eqx import equinox.internal as eqxi @@ -8,16 +8,19 @@ import jax.random as jr import jax.tree_util as jtu import lineax.internal as lxi -from jaxtyping import Array, PRNGKeyArray, PyTree +from jaxtyping import Array, Float, PRNGKeyArray, PyTree from lineax.internal import complex_to_real_dtype from .._custom_types import ( AbstractBrownianIncrement, + Args, BrownianIncrement, + IntScalarLike, levy_tree_transpose, RealScalarLike, SpaceTimeLevyArea, SpaceTimeTimeLevyArea, + Y, ) from .._misc import ( force_bitcast_convert_type, @@ -27,13 +30,22 @@ from .base import AbstractBrownianPath -class UnsafeBrownianPath(AbstractBrownianPath): +_Control = Union[PyTree[Array], AbstractBrownianIncrement] +_BrownianState: TypeAlias = Union[ + tuple[None, PyTree[Array], IntScalarLike], tuple[PRNGKeyArray, None, None] +] + + +class DirectBrownianPath(AbstractBrownianPath[_Control, _BrownianState]): """Brownian simulation that is only suitable for certain cases. - This is a very quick way to simulate Brownian motion, but can only be used when all - of the following are true: + This is a very quick way to simulate Brownian motion (faster than VBT), but can + only beused if you are not using an adaptive scheme that rejects steps + (pre-visible adaptive methods are valid). + + If using the stateless `evaluate` method, stricter requirements are imposed, namely: - 1. You are using a fixed step size controller. (Not an adaptive one.) + 1. You are not using an adaptive solver that rejects steps. 2. You do not need to backpropagate through the differential equation. @@ -62,10 +74,11 @@ class UnsafeBrownianPath(AbstractBrownianPath): """ shape: PyTree[jax.ShapeDtypeStruct] = eqx.field(static=True) + key: PRNGKeyArray levy_area: type[ Union[BrownianIncrement, SpaceTimeLevyArea, SpaceTimeTimeLevyArea] ] = eqx.field(static=True) - key: PRNGKeyArray + precompute: Optional[int] = eqx.field(static=True) def __init__( self, @@ -74,6 +87,7 @@ def __init__( levy_area: type[ Union[BrownianIncrement, SpaceTimeLevyArea, SpaceTimeTimeLevyArea] ] = BrownianIncrement, + precompute: Optional[int] = None, ): self.shape = ( jax.ShapeDtypeStruct(shape, lxi.default_floating_dtype()) @@ -82,12 +96,13 @@ def __init__( ) self.key = key self.levy_area = levy_area + self.precompute = precompute if any( not jnp.issubdtype(x.dtype, jnp.inexact) for x in jtu.tree_leaves(self.shape) ): - raise ValueError("UnsafeBrownianPath dtypes all have to be floating-point.") + raise ValueError("DirectBrownianPath dtypes all have to be floating-point.") @property def t0(self): @@ -97,6 +112,101 @@ def t0(self): def t1(self): return jnp.inf + def _generate_noise( + self, + key: PRNGKeyArray, + shape: jax.ShapeDtypeStruct, + max_steps: int, + ) -> Float[Array, "..."]: + if self.levy_area is SpaceTimeTimeLevyArea: + noise = jr.normal(key, (max_steps, 3, *shape.shape), shape.dtype) + elif self.levy_area is SpaceTimeLevyArea: + noise = jr.normal(key, (max_steps, 2, *shape.shape), shape.dtype) + elif self.levy_area is BrownianIncrement: + noise = jr.normal(key, (max_steps, *shape.shape), shape.dtype) + else: + assert False + + return noise + + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> _BrownianState: + if self.precompute is not None: + max_steps = self.precompute + subkey = split_by_tree(self.key, self.shape) + noise = jtu.tree_map( + lambda subkey, shape: self._generate_noise(subkey, shape, max_steps), + subkey, + self.shape, + ) + counter = 0 + key = None + return key, noise, counter + else: + noise = None + counter = None + key = self.key + return key, noise, counter + + def __call__( + self, + t0: RealScalarLike, + brownian_state: _BrownianState, + t1: Optional[RealScalarLike] = None, + left: bool = True, + use_levy: bool = False, + ) -> tuple[_Control, _BrownianState]: + del left + if t1 is None: + dtype = jnp.result_type(t0) + t1 = t0 + t0 = jnp.array(0, dtype) + else: + with jax.numpy_dtype_promotion("standard"): + dtype = jnp.result_type(t0, t1) + t0 = jnp.astype(t0, dtype) + t1 = jnp.astype(t1, dtype) + t0 = eqxi.nondifferentiable(t0, name="t0") + t1 = eqxi.nondifferentiable(t1, name="t1") + t1 = cast(RealScalarLike, t1) + + key, noises, counter = brownian_state + if self.precompute: # precomputed noise + assert noises is not None and counter is not None + out = jtu.tree_map( + lambda shape, noise: self._evaluate_leaf_precomputed( + t0, t1, shape, self.levy_area, use_levy, noise + ), + self.shape, + jax.tree.map(lambda x: x[counter], noises), + ) + if use_levy: + out = levy_tree_transpose(self.shape, out) + assert isinstance(out, self.levy_area) + # if a solver needs to call .evaluate twice, but wants access to the same + # brownian motion, the solver could just use the same original state + return out, (None, noises, counter + 1) + else: + assert noises is None and counter is None and key is not None + new_key, key = jr.split(key) + key = split_by_tree(key, self.shape) + out = jtu.tree_map( + lambda key, shape: self._evaluate_leaf( + t0, t1, key, shape, self.levy_area, use_levy + ), + key, + self.shape, + ) + if use_levy: + out = levy_tree_transpose(self.shape, out) + assert isinstance(out, self.levy_area) + return out, (new_key, None, None) + @eqx.filter_jit def evaluate( self, @@ -135,11 +245,48 @@ def evaluate( assert isinstance(out, self.levy_area) return out + @staticmethod + def _evaluate_leaf_precomputed( + t0: RealScalarLike, + t1: RealScalarLike, + shape: jax.ShapeDtypeStruct, + levy_area: type[ + Union[BrownianIncrement, SpaceTimeLevyArea, SpaceTimeTimeLevyArea] + ], + use_levy: bool, + noises: Float[Array, "..."], + ): + w_std = jnp.sqrt(t1 - t0).astype(shape.dtype) + dt = jnp.asarray(t1 - t0, dtype=complex_to_real_dtype(shape.dtype)) + + if levy_area is SpaceTimeTimeLevyArea: + w = noises[0] * w_std + hh_std = w_std / math.sqrt(12) + hh = noises[1] * hh_std + kk_std = w_std / math.sqrt(720) + kk = noises[2] * kk_std + levy_val = SpaceTimeTimeLevyArea(dt=dt, W=w, H=hh, K=kk) + + elif levy_area is SpaceTimeLevyArea: + w = noises[0] * w_std + hh_std = w_std / math.sqrt(12) + hh = noises[1] * hh_std + levy_val = SpaceTimeLevyArea(dt=dt, W=w, H=hh) + elif levy_area is BrownianIncrement: + w = noises * w_std + levy_val = BrownianIncrement(dt=dt, W=w) + else: + assert False + + if use_levy: + return levy_val + return w + @staticmethod def _evaluate_leaf( t0: RealScalarLike, t1: RealScalarLike, - key, + key: PRNGKeyArray, shape: jax.ShapeDtypeStruct, levy_area: type[ Union[BrownianIncrement, SpaceTimeLevyArea, SpaceTimeTimeLevyArea] @@ -175,7 +322,7 @@ def _evaluate_leaf( return w -UnsafeBrownianPath.__init__.__doc__ = """ +DirectBrownianPath.__init__.__doc__ = """ **Arguments:** - `shape`: Should be a PyTree of `jax.ShapeDtypeStruct`s, representing the shape, @@ -185,4 +332,12 @@ def _evaluate_leaf( - `key`: A random key. - `levy_area`: Whether to additionally generate Lévy area. This is required by some SDE solvers. +- `precompute`: Size of array to precompute the brownian motion (if possible). + Precomputing requires additional memory at initialization time, but can result in + faster integrations. Some thought may be required before enabling this, as solvers + which require multiple brownian increments may result in index out of bounds + causing silent errors as the size of the precomputed brownian motion is derived + from the maximum steps. """ + +UnsafeBrownianPath = DirectBrownianPath diff --git a/diffrax/_brownian/tree.py b/diffrax/_brownian/tree.py index 83259567..d3ef0fd6 100644 --- a/diffrax/_brownian/tree.py +++ b/diffrax/_brownian/tree.py @@ -15,6 +15,7 @@ from .._custom_types import ( AbstractBrownianIncrement, + Args, BoolScalarLike, BrownianIncrement, IntScalarLike, @@ -22,6 +23,7 @@ RealScalarLike, SpaceTimeLevyArea, SpaceTimeTimeLevyArea, + Y, ) from .._misc import ( is_tuple_of_ints, @@ -62,6 +64,8 @@ ] _Spline: TypeAlias = Literal["sqrt", "quad", "zero"] _BrownianReturn = TypeVar("_BrownianReturn", bound=AbstractBrownianIncrement) +_Control = Union[PyTree[Array], AbstractBrownianIncrement] +_BrownianState: TypeAlias = None # An internal dataclass that holds the rescaled Lévy areas @@ -175,7 +179,7 @@ def _split_interval( return x_s, x_u, x_su -class VirtualBrownianTree(AbstractBrownianPath): +class VirtualBrownianTree(AbstractBrownianPath[_Control, _BrownianState]): """Brownian simulation that discretises the interval `[t0, t1]` to tolerance `tol`. !!! info "Lévy Area" @@ -299,6 +303,25 @@ def is_dt(z): other_normalized = jtu.tree_map(sqrt_mult, other) return eqx.combine(dt_normalized, other_normalized) + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> _BrownianState: + return None + + def __call__( + self, + t0: RealScalarLike, + brownian_state: _BrownianState, + t1: Optional[RealScalarLike] = None, + left: bool = True, + use_levy: bool = False, + ) -> tuple[_Control, _BrownianState]: + return self.evaluate(t0, t1, left, use_levy), brownian_state + @eqx.filter_jit def evaluate( self, @@ -306,7 +329,7 @@ def evaluate( t1: Optional[RealScalarLike] = None, left: bool = True, use_levy: bool = False, - ) -> Union[PyTree[Array], AbstractBrownianIncrement]: + ) -> _Control: t0 = eqxi.nondifferentiable(t0, name="t0") # map the interval [self.t0, self.t1] onto [0,1] t0 = linear_rescale(self.t0, t0, self.t1) diff --git a/diffrax/_global_interpolation.py b/diffrax/_global_interpolation.py index 15d13681..2ad4f22a 100644 --- a/diffrax/_global_interpolation.py +++ b/diffrax/_global_interpolation.py @@ -1,6 +1,7 @@ import functools as ft from collections.abc import Callable from typing import cast, Optional, TYPE_CHECKING +from typing_extensions import TypeAlias import equinox as eqx import equinox.internal as eqxi @@ -18,16 +19,17 @@ from equinox.internal import ω from jaxtyping import Array, ArrayLike, PyTree, Real, Shaped -from ._custom_types import DenseInfos, IntScalarLike, RealScalarLike, Y +from ._custom_types import Args, DenseInfos, IntScalarLike, RealScalarLike, Y from ._local_interpolation import AbstractLocalInterpolation from ._misc import fill_forward, left_broadcast_to -from ._path import AbstractPath +from ._path import _Control, AbstractPath ω = cast(Callable, ω) +_PathState: TypeAlias = None -class AbstractGlobalInterpolation(AbstractPath): +class AbstractGlobalInterpolation(AbstractPath[_Control, _PathState]): ts: AbstractVar[Real[Array, " times"]] ts_size: AbstractVar[IntScalarLike] @@ -55,6 +57,24 @@ def t1(self): """The end of the interval over which the interpolation is defined.""" return self.ts[-1] + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> _PathState: + return None + + def __call__( + self, + t0: RealScalarLike, + path_state: _PathState, + t1: Optional[RealScalarLike] = None, + left: bool = True, + ) -> tuple[_Control, _PathState]: + return self.evaluate(t0, t1, left), path_state + class LinearInterpolation(AbstractGlobalInterpolation): """Linearly interpolates some data `ys` over the interval $[t_0, t_1]$ with knots diff --git a/diffrax/_integrate.py b/diffrax/_integrate.py index cacc1070..ec402cb6 100644 --- a/diffrax/_integrate.py +++ b/diffrax/_integrate.py @@ -63,9 +63,15 @@ AbstractAdaptiveStepSizeController, AbstractStepSizeController, ConstantStepSize, + PIDController, StepTo, ) -from ._term import AbstractTerm, MultiTerm, ODETerm, WrapTerm +from ._term import ( + AbstractTerm, + MultiTerm, + ODETerm, + WrapTerm, +) from ._typing import better_isinstance, get_args_of, get_origin_no_specials @@ -86,6 +92,7 @@ class State(eqx.Module): made_jump: BoolScalarLike solver_state: PyTree[ArrayLike] controller_state: PyTree[ArrayLike] + path_state: PyTree progress_meter_state: PyTree[Array] result: RESULTS # @@ -158,14 +165,14 @@ def _check(term_cls, term, term_contr_kwargs, yi): # `term_cls` | `term_args` # --------------------------|-------------- # AbstractTerm | () - # AbstractTerm[VF, Control] | (VF, Control) + # AbstractTerm[VF, Control] | (VF, Control, Path) # ----------------------------------------- term_args = get_args_of(AbstractTerm, term_cls, error_msg) n_term_args = len(term_args) if n_term_args == 0: pass - elif n_term_args == 2: - vf_type_expected, control_type_expected = term_args + elif n_term_args == 3: + vf_type_expected, control_type_expected, path_type_expected = term_args try: vf_type = eqx.filter_eval_shape(term.vf, t, yi, args) except Exception as e: @@ -176,10 +183,11 @@ def _check(term_cls, term, term_contr_kwargs, yi): if not vf_type_compatible: raise ValueError(f"Vector field term {term} is incompatible.") + term_contr_kwargs["control_state"] = term.init(0.0, 0.0, y, args) contr = ft.partial(term.contr, **term_contr_kwargs) # Work around https://github.com/google/jax/issues/21825 try: - control_type = eqx.filter_eval_shape(contr, t, t) + control_type, path_type = eqx.filter_eval_shape(contr, t, t) except Exception as e: raise ValueError(f"Error while tracing {term}.contr: " + str(e)) control_type_compatible = eqx.filter_eval_shape( @@ -191,6 +199,11 @@ def _check(term_cls, term, term_contr_kwargs, yi): f"Brownian motion for an SDE) was {control_type}, but this " f"solver expected {control_type_expected}." ) + path_type_compatible = eqx.filter_eval_shape( + better_isinstance, path_type, path_type_expected + ) + if not path_type_compatible: + raise ValueError(f"Control term {term} path state is incompatible.") else: assert False, "Malformed term structure" # If we've got to this point then the term is compatible @@ -340,13 +353,12 @@ def cond_fun(state): def body_fun_aux(state): state = _handle_static(state) - # # Actually do some differential equation solving! Make numerical steps, adapt # step sizes, all that jazz. # - (y, y_error, dense_info, solver_state, solver_result) = solver.step( + (y, y_error, dense_info, solver_state, path_state, solver_result) = solver.step( terms, state.tprev, state.tnext, @@ -354,6 +366,7 @@ def body_fun_aux(state): args, state.solver_state, state.made_jump, + state.path_state, ) # e.g. if someone has a sqrt(y) in the vector field, and dt0 is so large that @@ -399,6 +412,7 @@ def body_fun_aux(state): y = jtu.tree_map(keep, y, state.y) solver_state = jtu.tree_map(keep, solver_state, state.solver_state) made_jump = static_select(keep_step, made_jump, state.made_jump) + path_state = jtu.tree_map(keep, path_state, state.path_state) solver_result = RESULTS.where(keep_step, solver_result, RESULTS.successful) # TODO: if we ever support non-terminating events, then they should go in here. @@ -592,6 +606,7 @@ def _outer_cond_fn(cond_fn_i, old_event_value_i): made_jump=made_jump, # pyright: ignore solver_state=solver_state, controller_state=controller_state, + path_state=path_state, result=result, num_steps=num_steps, num_accepted_steps=num_accepted_steps, @@ -881,6 +896,7 @@ def diffeqsolve( solver_state: Optional[PyTree[ArrayLike]] = None, controller_state: Optional[PyTree[ArrayLike]] = None, made_jump: Optional[BoolScalarLike] = None, + path_state: Optional[PyTree] = None, # Exists for backward compatibility discrete_terminating_event: Optional[AbstractDiscreteTerminatingEvent] = None, ) -> Solution: @@ -964,6 +980,9 @@ def diffeqsolve( - `controller_state`: Some initial state for the step size controller. Generally obtained by `SaveAt(controller_state=True)` from a previous solve. + - `path_state`: Some initial state for the path. Generally obtained by + `SaveAt(path_state=True)` from a previous solve. + - `made_jump`: Whether a jump has just been made at `t0`. Used to update `solver_state` (if passed). Generally obtained by `SaveAt(made_jump=True)` from a previous solve. @@ -1099,6 +1118,7 @@ def _promote(yi): terms = MultiTerm(*terms) # Error checking for term compatibility + _assert_term_compatible( t0, y0, @@ -1123,9 +1143,10 @@ def _promote(yi): "method, as it may not converge to the correct solution." ) if is_unsafe_sde(terms): - if isinstance(stepsize_controller, AbstractAdaptiveStepSizeController): + if isinstance(stepsize_controller, PIDController): raise ValueError( - "`UnsafeBrownianPath` cannot be used with adaptive step sizes." + "`DirecBrownianPath` cannot be used with PIDController as it " + "may reject steps." ) # Normalises time: if t0 > t1 then flip things around. @@ -1235,9 +1256,21 @@ def _subsaveat_direction_fn(x): else: tnext = t0 + dt0 tnext = jnp.minimum(tnext, t1) + + if path_state is None: + passed_path_state = False + path_state = jax.tree.map( + lambda term: term.init(t0, tnext, y0, args), + terms, + is_leaf=lambda x: isinstance(x, AbstractTerm), + ) + else: + passed_path_state = True + if solver_state is None: passed_solver_state = False - solver_state = solver.init(terms, t0, tnext, y0, args) + # pyright says it can't be PyTree | None, but None is a PyTree, so it can? + solver_state = solver.init(terms, t0, tnext, y0, args, path_state) # pyright: ignore[reportArgumentType] else: passed_solver_state = True @@ -1277,8 +1310,16 @@ def _allocate_output(subsaveat: SubSaveAt) -> SaveState: made_jump = False if made_jump is None else made_jump result = RESULTS.successful if saveat.dense or event is not None: - _, _, dense_info_struct, _, _ = eqx.filter_eval_shape( - solver.step, terms, tprev, tnext, y0, args, solver_state, made_jump + _, _, dense_info_struct, _, _, _ = eqx.filter_eval_shape( + solver.step, + terms, + tprev, + tnext, + y0, + args, + solver_state, + made_jump, + path_state, ) if saveat.dense: if max_steps is None: @@ -1392,6 +1433,7 @@ def _outer_cond_fn(cond_fn_i): made_jump=made_jump, solver_state=solver_state, controller_state=controller_state, + path_state=path_state, result=result, num_steps=num_steps, num_accepted_steps=num_accepted_steps, @@ -1427,6 +1469,7 @@ def _outer_cond_fn(cond_fn_i): throw=throw, passed_solver_state=passed_solver_state, passed_controller_state=passed_controller_state, + passed_path_state=passed_path_state, progress_meter=progress_meter, ) @@ -1453,6 +1496,10 @@ def _outer_cond_fn(cond_fn_i): solver_state = final_state.solver_state else: solver_state = None + if saveat.path_state: + path_state = final_state.path_state + else: + path_state = None if saveat.made_jump: made_jump = final_state.made_jump else: @@ -1493,6 +1540,7 @@ def _outer_cond_fn(cond_fn_i): result=result, solver_state=solver_state, controller_state=controller_state, + path_state=path_state, made_jump=made_jump, event_mask=event_mask, ) diff --git a/diffrax/_local_interpolation.py b/diffrax/_local_interpolation.py index 29a8eb9e..3902e562 100644 --- a/diffrax/_local_interpolation.py +++ b/diffrax/_local_interpolation.py @@ -1,5 +1,6 @@ from collections.abc import Callable from typing import cast, Optional, TYPE_CHECKING +from typing_extensions import TypeAlias import jax import jax.numpy as jnp @@ -14,16 +15,34 @@ from equinox.internal import ω from jaxtyping import Array, ArrayLike, PyTree, Shaped -from ._custom_types import RealScalarLike, Y +from ._custom_types import Args, RealScalarLike, Y from ._misc import linear_rescale -from ._path import AbstractPath +from ._path import _Control, AbstractPath +_PathState: TypeAlias = None + ω = cast(Callable, ω) -class AbstractLocalInterpolation(AbstractPath): - pass +class AbstractLocalInterpolation(AbstractPath[_Control, _PathState]): + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> _PathState: + return None + + def __call__( + self, + t0: RealScalarLike, + path_state: _PathState, + t1: Optional[RealScalarLike] = None, + left: bool = True, + ) -> tuple[_Control, _PathState]: + return self.evaluate(t0, t1, left), path_state class LocalLinearInterpolation(AbstractLocalInterpolation): diff --git a/diffrax/_path.py b/diffrax/_path.py index e78b8d8b..7ac1939b 100644 --- a/diffrax/_path.py +++ b/diffrax/_path.py @@ -11,13 +11,14 @@ else: from equinox import AbstractVar -from ._custom_types import Control, RealScalarLike +from ._custom_types import Args, Control, RealScalarLike, Y _Control = TypeVar("_Control", bound=Control) +_PathState = TypeVar("_PathState") -class AbstractPath(eqx.Module, Generic[_Control]): +class AbstractPath(eqx.Module, Generic[_Control, _PathState]): """Abstract base class for all paths. Every path has a start point `t0` and an end point `t1`. In between these values @@ -47,6 +48,64 @@ def evaluate(self, t0, t1=None, left=True): t0: AbstractVar[RealScalarLike] t1: AbstractVar[RealScalarLike] + @abc.abstractmethod + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> _PathState: + """Initialises any hidden state for the path. + + **Arguments** as [`diffrax.diffeqsolve`][]. + + **Returns:** + + The initial path state. + """ + + @abc.abstractmethod + def __call__( + self, + t0: RealScalarLike, + path_state: _PathState, + t1: Optional[RealScalarLike] = None, + left: bool = True, + ) -> tuple[_Control, _PathState]: + r"""Evaluate the path at any point in the interval $[t_0, t_1]$. + + This is equivalent to `evaluate` but enables stateful evaluation. + + **Arguments:** + + - `t0`: Any point in $[t_0, t_1]$ to evaluate the path at. + - `path_state`: The current state for the path. + - `t1`: If passed, then the increment from `t1` to `t0` is evaluated instead. + - `left`: Across jump points: whether to treat the path as left-continuous + or right-continuous. + + !!! faq "FAQ" + + Note that we use $t_0$ and $t_1$ to refer to the overall interval, as + obtained via `instance.t0` and `instance.t1`. We use `t0` and `t1` to refer + to some subinterval of $[t_0, t_1]$. This is an API that is used for + consistency with the rest of the package, and just happens to be a little + confusing here. + + **Returns:** + + If `t1` is not passed: + + The value of the path at `t0`. + + If `t1` is passed: + + The increment of the path between `t0` and `t1`. + + In both cases, the updated state is also returned. + """ + @abc.abstractmethod def evaluate( self, t0: RealScalarLike, t1: Optional[RealScalarLike] = None, left: bool = True @@ -79,6 +138,8 @@ def evaluate( The increment of the path between `t0` and `t1`. """ + # make a stateful derivative or just make user do this with jvp? + # idk where this is used, hard for me to say def derivative(self, t: RealScalarLike, left: bool = True) -> _Control: r"""Evaluate the derivative of the path. Essentially equivalent to `jax.jvp(self.evaluate, (t,), (jnp.ones_like(t),))` (and indeed this is its diff --git a/diffrax/_saveat.py b/diffrax/_saveat.py index 6ee373de..aee5d75f 100644 --- a/diffrax/_saveat.py +++ b/diffrax/_saveat.py @@ -64,6 +64,7 @@ class SaveAt(eqx.Module): dense: bool = False solver_state: bool = False controller_state: bool = False + path_state: bool = False made_jump: bool = False def __init__( @@ -78,6 +79,7 @@ def __init__( dense: bool = False, solver_state: bool = False, controller_state: bool = False, + path_state: bool = False, made_jump: bool = False, ): if subs is None: @@ -93,6 +95,7 @@ def __init__( self.dense = dense self.solver_state = solver_state self.controller_state = controller_state + self.path_state = path_state self.made_jump = made_jump @@ -131,6 +134,9 @@ def __init__( - `controller_state`: If `True`, save the internal state of the step size controller at `t1`; accessible as `sol.controller_state`. +- `path_state`: If `True`, save the internal state of the path at `t1`; accessible as + `sol.path_state`. + - `made_jump`: If `True`, save the internal state of the jump tracker at `t1`; accessible as `sol.made_jump`. diff --git a/diffrax/_solution.py b/diffrax/_solution.py index f1b8d21b..cf9aa82b 100644 --- a/diffrax/_solution.py +++ b/diffrax/_solution.py @@ -5,7 +5,7 @@ import optimistix as optx from jaxtyping import Array, Bool, PyTree, Real, Shaped -from ._custom_types import BoolScalarLike, RealScalarLike +from ._custom_types import Args, BoolScalarLike, RealScalarLike, Y from ._global_interpolation import DenseInterpolation from ._path import AbstractPath @@ -89,6 +89,7 @@ class Solution(AbstractPath): - `solver_state`: If saved, the final internal state of the numerical solver. - `controller_state`: If saved, the final internal state for the step size controller. + - `path_state`: If saved, the final internal state for the path. - `made_jump`: If saved, the final internal state for the jump tracker. - `event_mask`: If using [events](../events), a boolean mask indicating which event triggered. This is a PyTree of bools, with the same PyTree stucture as the event @@ -119,9 +120,28 @@ class Solution(AbstractPath): result: RESULTS solver_state: Optional[PyTree] controller_state: Optional[PyTree] + path_state: Optional[PyTree] made_jump: Optional[BoolScalarLike] event_mask: Optional[PyTree[BoolScalarLike]] + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> None: + return None + + def __call__( + self, + t0: RealScalarLike, + path_state: None, + t1: Optional[RealScalarLike] = None, + left: bool = True, + ) -> tuple[PyTree[Shaped[Array, "?*shape"], " Y"], None]: + return self.evaluate(t0, t1, left), path_state + def evaluate( self, t0: RealScalarLike, t1: Optional[RealScalarLike] = None, left: bool = True ) -> PyTree[Shaped[Array, "?*shape"], " Y"]: diff --git a/diffrax/_solver/base.py b/diffrax/_solver/base.py index 42f19e4c..38287f06 100644 --- a/diffrax/_solver/base.py +++ b/diffrax/_solver/base.py @@ -9,6 +9,7 @@ Optional, Type, TYPE_CHECKING, + TypeAlias, TypeVar, ) @@ -34,6 +35,12 @@ _SolverState = TypeVar("_SolverState") +# Should pathstate be a TypeVar? Originally I had it as one, but it doesn't seem +# to matter since no solver actually provides a specific type for the typevar +# (thus it was totally general for all solvers, which was like, why is it a type +# var then?) In Term it makes sense because control/ode terms are specific +# parameterizations of the type var +_PathState: TypeAlias = PyTree def vector_tree_dot(a, b): @@ -129,7 +136,11 @@ def init( t1: RealScalarLike, y0: Y, args: Args, + path_state: _PathState, ) -> _SolverState: + # does this need to return a path state as well?, or it is fine just to + # have it consume it? AbstractFosterLangevinSRK is the only one that + # uses rn I think, so can this brownian increment be reused? """Initialises any hidden state for the solver. **Arguments** as [`diffrax.diffeqsolve`][]. @@ -149,7 +160,8 @@ def step( args: Args, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[Y, Optional[Y], DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[Y, Optional[Y], DenseInfo, _SolverState, _PathState, RESULTS]: """Make a single step of the solver. Each step is made over the specified interval $[t_0, t_1]$. @@ -166,6 +178,7 @@ def step( Some solvers (notably FSAL Runge--Kutta solvers) usually assume that there are no jumps and for efficiency re-use information between steps; this indicates that a jump has just occurred and this assumption is not true. + - `path_state`: Any evolving state for any path being used. **Returns:** @@ -179,6 +192,7 @@ def step( routine to calculate dense output. (Used with `SaveAt(ts=...)` or `SaveAt(dense=...)`.) - The value of the solver state at `t1`. + - The value of the path state at `t1`. - An integer (corresponding to `diffrax.RESULTS`) indicating whether the step happened successfully, or if (unusually) it failed for some reason. """ @@ -246,7 +260,8 @@ class if that is not desired behaviour.) class HalfSolver( - AbstractAdaptiveSolver[_SolverState], AbstractWrappedSolver[_SolverState] + AbstractAdaptiveSolver[_SolverState], + AbstractWrappedSolver[_SolverState], ): """Wraps another solver, trading cost in order to provide error estimates. (That is, it means the solver can be used with an adaptive step size controller, @@ -305,8 +320,9 @@ def init( t1: RealScalarLike, y0: Y, args: Args, + path_state: _PathState, ) -> _SolverState: - return self.solver.init(terms, t0, t1, y0, args) + return self.solver.init(terms, t0, t1, y0, args, path_state) def step( self, @@ -317,26 +333,43 @@ def step( args: Args, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[Y, Optional[Y], DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[Y, Optional[Y], DenseInfo, _SolverState, _PathState, RESULTS]: original_solver_state = solver_state + original_path_state = path_state thalf = t0 + 0.5 * (t1 - t0) - yhalf, _, _, solver_state, result1 = self.solver.step( - terms, t0, thalf, y0, args, solver_state, made_jump + yhalf, _, _, solver_state, path_state, result1 = self.solver.step( + terms, t0, thalf, y0, args, solver_state, made_jump, path_state ) - y1, _, _, solver_state, result2 = self.solver.step( - terms, thalf, t1, yhalf, args, solver_state, made_jump=False + y1, _, _, solver_state, path_state, result2 = self.solver.step( + terms, + thalf, + t1, + yhalf, + args, + solver_state, + made_jump=False, + path_state=path_state, ) # TODO: use dense_info from the pair of half-steps instead - y1_alt, _, dense_info, _, result3 = self.solver.step( - terms, t0, t1, y0, args, original_solver_state, made_jump + # this potentially reuses the same brownian increment, is this right? + y1_alt, _, dense_info, _, _, result3 = self.solver.step( + terms, + t0, + t1, + y0, + args, + original_solver_state, + made_jump, + original_path_state, ) y_error = (y1**ω - y1_alt**ω).call(jnp.abs).ω result = update_result(result1, update_result(result2, result3)) - return y1, y_error, dense_info, solver_state, result + return y1, y_error, dense_info, solver_state, path_state, result def func( self, terms: PyTree[AbstractTerm], t0: RealScalarLike, y0: Y, args: Args diff --git a/diffrax/_solver/euler.py b/diffrax/_solver/euler.py index c38642e9..52b333f2 100644 --- a/diffrax/_solver/euler.py +++ b/diffrax/_solver/euler.py @@ -8,7 +8,7 @@ from .._local_interpolation import LocalLinearInterpolation from .._solution import RESULTS from .._term import AbstractTerm -from .base import AbstractItoSolver +from .base import _PathState, AbstractItoSolver _ErrorEstimate: TypeAlias = None @@ -42,6 +42,7 @@ def init( t1: RealScalarLike, y0: Y, args: Args, + path_state: _PathState, ) -> _SolverState: return None @@ -54,12 +55,13 @@ def step( args: Args, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, _PathState, RESULTS]: del solver_state, made_jump - control = terms.contr(t0, t1) + control, path_state = terms.contr(t0, t1, path_state) y1 = (y0**ω + terms.vf_prod(t0, y0, args, control) ** ω).ω dense_info = dict(y0=y0, y1=y1) - return y1, None, dense_info, None, RESULTS.successful + return y1, None, dense_info, None, path_state, RESULTS.successful def func( self, diff --git a/diffrax/_solver/euler_heun.py b/diffrax/_solver/euler_heun.py index c8338c88..70855b62 100644 --- a/diffrax/_solver/euler_heun.py +++ b/diffrax/_solver/euler_heun.py @@ -8,7 +8,7 @@ from .._local_interpolation import LocalLinearInterpolation from .._solution import RESULTS from .._term import AbstractTerm, MultiTerm -from .base import AbstractStratonovichSolver +from .base import _PathState, AbstractStratonovichSolver _ErrorEstimate: TypeAlias = None @@ -27,7 +27,7 @@ class EulerHeun(AbstractStratonovichSolver): """ term_structure: ClassVar = MultiTerm[ - tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm] + tuple[AbstractTerm[Any, RealScalarLike, _PathState], AbstractTerm] ] interpolation_cls: ClassVar[ Callable[..., LocalLinearInterpolation] @@ -41,29 +41,36 @@ def strong_order(self, terms): def init( self, - terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + terms: MultiTerm[ + tuple[AbstractTerm[Any, RealScalarLike, _PathState], AbstractTerm] + ], t0: RealScalarLike, t1: RealScalarLike, y0: Y, args: Args, + path_state: _PathState, ) -> _SolverState: return None def step( self, - terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + terms: MultiTerm[ + tuple[AbstractTerm[Any, RealScalarLike, _PathState], AbstractTerm] + ], t0: RealScalarLike, t1: RealScalarLike, y0: Y, args: Args, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, _PathState, RESULTS]: del solver_state, made_jump drift, diffusion = terms.terms - dt = drift.contr(t0, t1) - dW = diffusion.contr(t0, t1) + drift_path, diffusion_path = path_state + dt, drift_path = drift.contr(t0, t1, drift_path) + dW, diffusion_path = diffusion.contr(t0, t1, diffusion_path) f0 = drift.vf_prod(t0, y0, args, dt) g0 = diffusion.vf_prod(t0, y0, args, dW) @@ -74,7 +81,14 @@ def step( y1 = (y0**ω + f0**ω + 0.5 * (g0**ω + g_prime**ω)).ω dense_info = dict(y0=y0, y1=y1) - return y1, None, dense_info, None, RESULTS.successful + return ( + y1, + None, + dense_info, + None, + (drift_path, diffusion_path), + RESULTS.successful, + ) def func( self, diff --git a/diffrax/_solver/foster_langevin_srk.py b/diffrax/_solver/foster_langevin_srk.py index dbdf3939..39435b33 100644 --- a/diffrax/_solver/foster_langevin_srk.py +++ b/diffrax/_solver/foster_langevin_srk.py @@ -13,6 +13,7 @@ from .._custom_types import ( AbstractBrownianIncrement, + Args, BoolScalarLike, DenseInfo, RealScalarLike, @@ -30,7 +31,7 @@ UnderdampedLangevinX, WrapTerm, ) -from .base import AbstractStratonovichSolver +from .base import _PathState, AbstractStratonovichSolver _ErrorEstimate = TypeVar("_ErrorEstimate", None, UnderdampedLangevinTuple) @@ -42,13 +43,15 @@ def _get_args_from_terms( - terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + terms: MultiTerm[ + tuple[AbstractTerm[Any, RealScalarLike, _PathState], AbstractTerm] + ], ) -> tuple[ PyTree, PyTree, PyTree, PyTree, - Callable[[UnderdampedLangevinX], UnderdampedLangevinX], + Callable[[UnderdampedLangevinX, Args], UnderdampedLangevinX], ]: drift, diffusion = terms.terms if isinstance(drift, WrapTerm): @@ -243,11 +246,14 @@ def _choose(tay_leaf, direct_leaf): def init( self, - terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + terms: MultiTerm[ + tuple[AbstractTerm[Any, RealScalarLike, _PathState], AbstractTerm] + ], t0: RealScalarLike, t1: RealScalarLike, y0: UnderdampedLangevinTuple, args: PyTree, + path_state: _PathState, ) -> SolverState: """Precompute _SolverState which carries the Taylor coefficients and the SRK coefficients (which can be computed from h and the Taylor coefficients). @@ -255,6 +261,7 @@ def init( evaluation of grad_f. """ drift, diffusion = terms.terms + drift_path, diffusion_path = path_state ( gamma_drift, u_drift, @@ -263,7 +270,10 @@ def init( grad_f, ) = _get_args_from_terms(terms) - h = drift.contr(t0, t1) + # is this the only solver class that has `init` depend on the path state? + # feels irksome to change everything for one class, but I'm going to make + # `init` now depend on path state for the sake of generality + h, _ = drift.contr(t0, t1, drift_path) x0, v0 = y0 gamma = broadcast_underdamped_langevin_arg(gamma_drift, x0, "gamma") @@ -287,7 +297,7 @@ def compare_args_fun(arg1, arg2): u = jtu.tree_map(compare_args_fun, u, u_diffusion) try: - grad_f_shape = jax.eval_shape(grad_f, x0) + grad_f_shape = jax.eval_shape(grad_f, x0, args) except ValueError: raise RuntimeError( "The function `grad_f` in the Underdamped Langevin term must be" @@ -311,7 +321,7 @@ def shape_check_fun(_x, _g, _u, _fx): coeffs = self._recompute_coeffs(h, gamma, tay_coeffs) rho = jtu.tree_map(lambda c, _u: jnp.sqrt(2 * c * _u), gamma, u) - prev_f = grad_f(x0) if self._is_fsal else None + prev_f = grad_f(x0, args) if self._is_fsal else None state_out = SolverState( gamma=gamma, @@ -359,21 +369,29 @@ def _compute_step( def step( self, - terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + terms: MultiTerm[ + tuple[AbstractTerm[Any, RealScalarLike, _PathState], AbstractTerm] + ], t0: RealScalarLike, t1: RealScalarLike, y0: UnderdampedLangevinTuple, args: PyTree, solver_state: SolverState, made_jump: BoolScalarLike, + path_state: _PathState, ) -> tuple[ - UnderdampedLangevinTuple, _ErrorEstimate, DenseInfo, SolverState, RESULTS + UnderdampedLangevinTuple, + _ErrorEstimate, + DenseInfo, + SolverState, + _PathState, + RESULTS, ]: - del args st = solver_state drift, diffusion = terms.terms + drift_path, diffusion_path = path_state - h = drift.contr(t0, t1) + h, drift_path = drift.contr(t0, t1, drift_path) h_prev = st.h tay: PyTree[_Coeffs] = st.taylor_coeffs old_coeffs: _Coeffs = st.coeffs @@ -392,7 +410,7 @@ def step( ) # compute the Brownian increment and space-time(-time) Levy area - levy = diffusion.contr(t0, t1, use_levy=True) + levy, diffusion_path = diffusion.contr(t0, t1, diffusion_path, use_levy=True) if not isinstance(levy, self.minimal_levy_area): raise ValueError( f"The Brownian motion must have" @@ -404,12 +422,19 @@ def step( prev_f = st.prev_f else: prev_f = lax.cond( - eqxi.unvmap_any(made_jump), lambda: grad_f(x0), lambda: st.prev_f + eqxi.unvmap_any(made_jump), lambda: grad_f(x0, args), lambda: st.prev_f ) # The actual step computation, handled by the subclass x_out, v_out, f_fsal, error = self._compute_step( - h, levy, x0, v0, (gamma, u, grad_f), coeffs, rho, prev_f + h, + levy, + x0, + v0, + (gamma, u, lambda inp: grad_f(inp, args)), + coeffs, + rho, + prev_f, ) def check_shapes_dtypes(arg, *args): @@ -436,11 +461,20 @@ def check_shapes_dtypes(arg, *args): rho=st.rho, prev_f=f_fsal, ) - return y1, error, dense_info, st, RESULTS.successful + return ( + y1, + error, + dense_info, + st, + (drift_path, diffusion_path), + RESULTS.successful, + ) def func( self, - terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + terms: MultiTerm[ + tuple[AbstractTerm[Any, RealScalarLike, _PathState], AbstractTerm] + ], t0: RealScalarLike, y0: UnderdampedLangevinTuple, args: PyTree, diff --git a/diffrax/_solver/implicit_euler.py b/diffrax/_solver/implicit_euler.py index eb3bdb00..feaa4f3d 100644 --- a/diffrax/_solver/implicit_euler.py +++ b/diffrax/_solver/implicit_euler.py @@ -4,6 +4,7 @@ import optimistix as optx from equinox.internal import ω +from jaxtyping import PyTree from .._custom_types import Args, BoolScalarLike, DenseInfo, RealScalarLike, VF, Y from .._heuristics import is_sde @@ -15,6 +16,7 @@ _SolverState: TypeAlias = None +_PathState: TypeAlias = PyTree def _implicit_relation(z1, nonlinear_solve_args): @@ -59,6 +61,7 @@ def init( t1: RealScalarLike, y0: Y, args: Args, + path_state: _PathState, ) -> _SolverState: return None @@ -71,9 +74,10 @@ def step( args: Args, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[Y, Y, DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[Y, Y, DenseInfo, _SolverState, _PathState, RESULTS]: del made_jump - control = terms.contr(t0, t1) + control, path_state = terms.contr(t0, t1, path_state) # Could use FSAL here but that would mean we'd need to switch to working with # `f0 = terms.vf(t0, y0, args)`, and that gets quite hairy quite quickly. # (C.f. `AbstractRungeKutta.step`.) @@ -96,7 +100,7 @@ def step( dense_info = dict(y0=y0, y1=y1) solver_state = None result = RESULTS.promote(nonlinear_sol.result) - return y1, y_error, dense_info, solver_state, result + return y1, y_error, dense_info, solver_state, path_state, result def func( self, diff --git a/diffrax/_solver/leapfrog_midpoint.py b/diffrax/_solver/leapfrog_midpoint.py index 00ba11da..a1fc6ebc 100644 --- a/diffrax/_solver/leapfrog_midpoint.py +++ b/diffrax/_solver/leapfrog_midpoint.py @@ -14,6 +14,7 @@ _ErrorEstimate: TypeAlias = None _SolverState: TypeAlias = tuple[RealScalarLike, PyTree] +_PathState: TypeAlias = PyTree # TODO: support arbitrary linear multistep methods @@ -59,6 +60,7 @@ def init( t1: RealScalarLike, y0: Y, args: Args, + path_state: _PathState, ) -> _SolverState: del terms, t1, args # Corresponds to making an explicit Euler step on the first step. @@ -73,14 +75,15 @@ def step( args: Args, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, _PathState, RESULTS]: del made_jump tm1, ym1 = solver_state - control = terms.contr(tm1, t1) + control, path_state = terms.contr(tm1, t1, path_state) y1 = (ym1**ω + terms.vf_prod(t0, y0, args, control) ** ω).ω dense_info = dict(y0=y0, y1=y1) solver_state = (t0, y0) - return y1, None, dense_info, solver_state, RESULTS.successful + return y1, None, dense_info, solver_state, path_state, RESULTS.successful def func(self, terms: AbstractTerm, t0: RealScalarLike, y0: Y, args: Args) -> VF: return terms.vf(t0, y0, args) diff --git a/diffrax/_solver/milstein.py b/diffrax/_solver/milstein.py index ce59d83b..cb2a4e00 100644 --- a/diffrax/_solver/milstein.py +++ b/diffrax/_solver/milstein.py @@ -6,6 +6,7 @@ import jax.numpy as jnp import jax.tree_util as jtu from equinox.internal import ω +from jaxtyping import PyTree from .._custom_types import Args, BoolScalarLike, DenseInfo, RealScalarLike, VF, Y from .._local_interpolation import LocalLinearInterpolation @@ -16,7 +17,7 @@ _ErrorEstimate: TypeAlias = None _SolverState: TypeAlias = None - +_PathState: TypeAlias = tuple[None, PyTree] # # The best online reference I've found for commutative-noise Milstein is @@ -43,7 +44,7 @@ class StratonovichMilstein(AbstractStratonovichSolver): """ # noqa: E501 term_structure: ClassVar = MultiTerm[ - tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm] + tuple[AbstractTerm[Any, RealScalarLike, None], AbstractTerm] ] interpolation_cls: ClassVar[ Callable[..., LocalLinearInterpolation] @@ -57,28 +58,32 @@ def strong_order(self, terms): def init( self, - terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike, None], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, y0: Y, args: Args, + path_state: _PathState, ) -> _SolverState: return None def step( self, - terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike, None], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, y0: Y, args: Args, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, _PathState, RESULTS]: del solver_state, made_jump drift, diffusion = terms.terms - dt = drift.contr(t0, t1) - dw = diffusion.contr(t0, t1) + drift_path, diffusion_path = path_state + + dt, drift_path = drift.contr(t0, t1, drift_path) + dw, diffusion_path = diffusion.contr(t0, t1, diffusion_path) f0_prod = drift.vf_prod(t0, y0, args, dt) g0_prod = diffusion.vf_prod(t0, y0, args, dw) @@ -90,7 +95,14 @@ def _to_jvp(_y0): y1 = (y0**ω + f0_prod**ω + g0_prod**ω + 0.5 * v0_prod**ω).ω dense_info = dict(y0=y0, y1=y1) - return y1, None, dense_info, None, RESULTS.successful + return ( + y1, + None, + dense_info, + None, + (drift_path, diffusion_path), + RESULTS.successful, + ) def func( self, @@ -119,7 +131,7 @@ class ItoMilstein(AbstractItoSolver): """ # noqa: E501 term_structure: ClassVar = MultiTerm[ - tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm] + tuple[AbstractTerm[Any, RealScalarLike, None], AbstractTerm] ] interpolation_cls: ClassVar[ Callable[..., LocalLinearInterpolation] @@ -133,28 +145,31 @@ def strong_order(self, terms): def init( self, - terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike, None], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, y0: Y, args: Args, + path_state: _PathState, ) -> _SolverState: return None def step( self, - terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike, None], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, y0: Y, args: Args, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, _PathState, RESULTS]: del solver_state, made_jump drift, diffusion = terms.terms - Δt = drift.contr(t0, t1) - Δw = diffusion.contr(t0, t1) + drift_path, diffusion_path = path_state + Δt, drift_path = drift.contr(t0, t1, drift_path) + Δw, diffusion_path = diffusion.contr(t0, t1, diffusion_path) # # So this is a bit involved, largely because of the generality that the rest of @@ -365,11 +380,18 @@ def _dot(_, _v0): # dense_info = dict(y0=y0, y1=y1) - return y1, None, dense_info, None, RESULTS.successful + return ( + y1, + None, + dense_info, + None, + (drift_path, diffusion_path), + RESULTS.successful, + ) def func( self, - terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike, None], AbstractTerm]], t0: RealScalarLike, y0: Y, args: Args, diff --git a/diffrax/_solver/reversible_heun.py b/diffrax/_solver/reversible_heun.py index 0f0a9fe9..adeb5eb8 100644 --- a/diffrax/_solver/reversible_heun.py +++ b/diffrax/_solver/reversible_heun.py @@ -14,6 +14,7 @@ _SolverState: TypeAlias = tuple[PyTree, PyTree] +_PathState: TypeAlias = PyTree class ReversibleHeun(AbstractAdaptiveSolver, AbstractStratonovichSolver): @@ -54,6 +55,7 @@ def init( t1: RealScalarLike, y0: Y, args: Args, + path_state: _PathState, ) -> _SolverState: del t1 vf0 = terms.vf(t0, y0, args) @@ -68,12 +70,13 @@ def step( args: Args, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[Y, Y, DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[Y, Y, DenseInfo, _SolverState, _PathState, RESULTS]: yhat0, vf0 = solver_state vf0 = lax.cond(made_jump, lambda _: terms.vf(t0, y0, args), lambda _: vf0, None) - control = terms.contr(t0, t1) + control, new_path_state = terms.contr(t0, t1, path_state) yhat1 = (2 * y0**ω - yhat0**ω + terms.prod(vf0, control) ** ω).ω vf1 = terms.vf(t1, yhat1, args) y1 = (y0**ω + 0.5 * terms.prod((vf0**ω + vf1**ω).ω, control) ** ω).ω @@ -81,7 +84,14 @@ def step( dense_info = dict(y0=y0, y1=y1) solver_state = (yhat1, vf1) - return y1, y1_error, dense_info, solver_state, RESULTS.successful + return ( + y1, + y1_error, + dense_info, + solver_state, + new_path_state, + RESULTS.successful, + ) def func(self, terms: AbstractTerm, t0: RealScalarLike, y0: Y, args: Args) -> VF: return terms.vf(t0, y0, args) diff --git a/diffrax/_solver/runge_kutta.py b/diffrax/_solver/runge_kutta.py index 6f56e0a3..704ded30 100644 --- a/diffrax/_solver/runge_kutta.py +++ b/diffrax/_solver/runge_kutta.py @@ -44,7 +44,12 @@ ) from .._solution import is_okay, RESULTS, update_result from .._term import AbstractTerm, MultiTerm, ODETerm, WrapTerm -from .base import AbstractAdaptiveSolver, AbstractImplicitSolver, vector_tree_dot +from .base import ( + _PathState, + AbstractAdaptiveSolver, + AbstractImplicitSolver, + vector_tree_dot, +) # Not a pytree node! @@ -417,6 +422,7 @@ def init( t1: RealScalarLike, y0: Y, args: Args, + path_state: _PathState, ) -> _SolverState: _, fsal = self._common(terms, t0, t1, y0, args) if fsal: @@ -450,7 +456,8 @@ def step( args: Args, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[Y, Y, DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[Y, Y, DenseInfo, _SolverState, _PathState, RESULTS]: # # Alright, settle in for what is probably the most advanced Runge-Kutta # implementation on the planet. @@ -603,6 +610,15 @@ def _fn(tableau, *_trees): return jtu.tree_map(_fn, tableaus, *trees) + def t_map_contr(fn, *trees, control, implicit_val=sentinel): + def _fn(tableau, _control, *_trees): + if tableau.implicit and implicit_val is not sentinel: + return implicit_val + else: + return fn(*_trees, _control) + + return jtu.tree_map(_fn, tableaus, control, *trees) + # Structure of `y` and `k`. def y_map(fn, *trees): def _fn(_, *_trees): @@ -639,7 +655,20 @@ def _get_implicit_impl(term, x): return value dt = t1 - t0 - control = t_map(lambda term_i: term_i.contr(t0, t1), terms) + tableau_mapped = t_map_contr( + lambda term_i, path_i: term_i.contr(t0, t1, path_i), + terms, + control=path_state, + ) + # control, new_path_state = jtu.tree_map(lambda x) + if isinstance(tableaus, ButcherTableau): + control, new_path_state = tableau_mapped + else: # tuple of butchers + control, new_path_state = ( + tuple(i[0] for i in tableau_mapped), + tuple(i[1] for i in tableau_mapped), + ) + if implicit_tableau is None: implicit_control = _unused else: @@ -1198,7 +1227,7 @@ def _increment(tab_i, k_i): new_solver_state = False, f1_for_fsal else: new_solver_state = None - return y1, y_error, dense_info, new_solver_state, result + return y1, y_error, dense_info, new_solver_state, new_path_state, result class AbstractERK(AbstractRungeKutta): diff --git a/diffrax/_solver/semi_implicit_euler.py b/diffrax/_solver/semi_implicit_euler.py index 00b9e1db..8e4c7433 100644 --- a/diffrax/_solver/semi_implicit_euler.py +++ b/diffrax/_solver/semi_implicit_euler.py @@ -14,6 +14,7 @@ _ErrorEstimate: TypeAlias = None _SolverState: TypeAlias = None +_PathState: TypeAlias = PyTree Ya: TypeAlias = PyTree[Float[ArrayLike, "?*y"], " Y"] Yb: TypeAlias = PyTree[Float[ArrayLike, "?*y"], " Y"] @@ -41,6 +42,7 @@ def init( t1: RealScalarLike, y0: tuple[Ya, Yb], args: Args, + path_state: _PathState, ) -> _SolverState: return None @@ -53,20 +55,31 @@ def step( args: Args, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[tuple[Ya, Yb], _ErrorEstimate, DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[ + tuple[Ya, Yb], _ErrorEstimate, DenseInfo, _SolverState, _PathState, RESULTS + ]: del solver_state, made_jump term_1, term_2 = terms + path_state1, path_state2 = path_state y0_1, y0_2 = y0 - control1 = term_1.contr(t0, t1) - control2 = term_2.contr(t0, t1) + control1, path_state1 = term_1.contr(t0, t1, path_state1) + control2, path_state2 = term_2.contr(t0, t1, path_state2) y1_1 = (y0_1**ω + term_1.vf_prod(t0, y0_2, args, control1) ** ω).ω y1_2 = (y0_2**ω + term_2.vf_prod(t0, y1_1, args, control2) ** ω).ω y1 = (y1_1, y1_2) dense_info = dict(y0=y0, y1=y1) - return y1, None, dense_info, None, RESULTS.successful + return ( + y1, + None, + dense_info, + None, + (path_state1, path_state2), + RESULTS.successful, + ) def func( self, diff --git a/diffrax/_solver/srk.py b/diffrax/_solver/srk.py index 56be17ba..34c8efd7 100644 --- a/diffrax/_solver/srk.py +++ b/diffrax/_solver/srk.py @@ -39,6 +39,7 @@ _ErrorEstimate: TypeAlias = Optional[Y] _SolverState: TypeAlias = None +_PathState: TypeAlias = PyTree _CarryType: TypeAlias = tuple[PyTree[Array], PyTree[Array], PyTree[Array]] @@ -280,8 +281,8 @@ def minimal_levy_area(self) -> type[AbstractBrownianIncrement]: def term_structure(self): return MultiTerm[ tuple[ - AbstractTerm[Any, RealScalarLike], - AbstractTerm[Any, self.minimal_levy_area], + AbstractTerm[Any, RealScalarLike, None], + AbstractTerm[Any, self.minimal_levy_area, _PathState], ] ] @@ -289,14 +290,15 @@ def init( self, terms: MultiTerm[ tuple[ - AbstractTerm[Any, RealScalarLike], - AbstractTerm[Any, AbstractBrownianIncrement], + AbstractTerm[Any, RealScalarLike, None], # ODE Term + AbstractTerm[Any, AbstractBrownianIncrement, _PathState], ] ], t0: RealScalarLike, t1: RealScalarLike, y0: Y, args: PyTree, + path_state: _PathState, ) -> _SolverState: del t1 # Check that the diffusion has the correct Lévy area @@ -328,8 +330,8 @@ def step( self, terms: MultiTerm[ tuple[ - AbstractTerm[Any, RealScalarLike], - AbstractTerm[Any, AbstractBrownianIncrement], + AbstractTerm[Any, RealScalarLike, None], + AbstractTerm[Any, AbstractBrownianIncrement, _PathState], ] ], t0: RealScalarLike, @@ -338,11 +340,14 @@ def step( args: PyTree, solver_state: _SolverState, made_jump: BoolScalarLike, - ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, RESULTS]: + path_state: _PathState, + ) -> tuple[Y, _ErrorEstimate, DenseInfo, _SolverState, _PathState, RESULTS]: del solver_state, made_jump dtype = jnp.result_type(*jtu.tree_leaves(y0)) drift, diffusion = terms.terms + drift_path, diffusion_path = path_state + if self.tableau.ignore_stage_f is None: ignore_stage_f = None else: @@ -379,7 +384,7 @@ def make_zeros_aux(leaf): # Now the diffusion related stuff # Brownian increment (and space-time Lévy area) - bm_inc = diffusion.contr(t0, t1, use_levy=True) + bm_inc, diffusion_path = diffusion.contr(t0, t1, diffusion_path, use_levy=True) if not isinstance(bm_inc, self.minimal_levy_area): raise ValueError( f"The Brownian increment {bm_inc} does not have the " @@ -660,14 +665,21 @@ def compute_and_insert_kg_j(_w_kgs_in, _levylist_kgs_in): y1 = (y0**ω + drift_result**ω + diffusion_result**ω).ω dense_info = dict(y0=y0, y1=y1) - return y1, error, dense_info, None, RESULTS.successful + return ( + y1, + error, + dense_info, + None, + (drift_path, diffusion_path), + RESULTS.successful, + ) def func( self, terms: MultiTerm[ tuple[ - AbstractTerm[Any, RealScalarLike], - AbstractTerm[Any, AbstractBrownianIncrement], + AbstractTerm[Any, RealScalarLike, None], + AbstractTerm[Any, AbstractBrownianIncrement, _PathState], ] ], t0: RealScalarLike, diff --git a/diffrax/_term.py b/diffrax/_term.py index d13d430b..009023e0 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -30,9 +30,12 @@ _VF = TypeVar("_VF", bound=VF) _Control = TypeVar("_Control", bound=Control) +_ControlState = TypeVar("_ControlState") +_PathState: TypeAlias = PyTree +# should probably make the typing of this better/more consistent -class AbstractTerm(eqx.Module, Generic[_VF, _Control]): +class AbstractTerm(eqx.Module, Generic[_VF, _Control, _ControlState]): r"""Abstract base class for all terms. Let $y$ solve some differential equation with vector field $f$ and control $x$. @@ -62,7 +65,30 @@ def vf(self, t: RealScalarLike, y: Y, args: Args) -> _VF: pass @abc.abstractmethod - def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> _Control: + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> _PathState: + """Initialises any hidden state for the path. + + **Arguments** as [`diffrax.diffeqsolve`][]. + + **Returns:** + + The initial path state. + """ + + @abc.abstractmethod + def contr( + self, + t0: RealScalarLike, + t1: RealScalarLike, + control_state: _ControlState, + **kwargs, + ) -> tuple[_Control, _ControlState]: r"""The control. Represents the $\mathrm{d}t$ in an ODE, or the $\mathrm{d}w(t)$ in an SDE, etc. @@ -171,7 +197,7 @@ def is_vf_expensive( return False -class ODETerm(AbstractTerm[_VF, RealScalarLike]): +class ODETerm(AbstractTerm[_VF, RealScalarLike, None]): r"""A term representing $f(t, y(t), args) \mathrm{d}t$. That is to say, the term appearing on the right hand side of an ODE, in which the control is time. @@ -190,6 +216,15 @@ class ODETerm(AbstractTerm[_VF, RealScalarLike]): vector_field: Callable[[RealScalarLike, Y, Args], _VF] + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> None: + return None + def vf(self, t: RealScalarLike, y: Y, args: Args) -> _VF: out = self.vector_field(t, y, args) if jtu.tree_structure(out) != jtu.tree_structure(y): @@ -210,8 +245,14 @@ def _broadcast_and_upcast(oi, yi): return jtu.tree_map(_broadcast_and_upcast, out, y) - def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> RealScalarLike: - return t1 - t0 + def contr( + self, + t0: RealScalarLike, + t1: RealScalarLike, + control_state: None = None, + **kwargs, + ) -> tuple[RealScalarLike, None]: + return t1 - t0, None def prod(self, vf: _VF, control: RealScalarLike) -> Y: def _mul(v): @@ -235,7 +276,8 @@ def _mul(v): """ -class _CallableToPath(AbstractPath[_Control]): +# question over stateful custom functions comes up here too +class _CallableToPath(AbstractPath[_Control, None]): fn: Callable @property @@ -246,17 +288,40 @@ def t0(self): def t1(self): return jnp.inf + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> None: + return None + + def __call__( + self, + t0: RealScalarLike, + path_state: None, + t1: Optional[RealScalarLike] = None, + left: bool = True, + ) -> tuple[_Control, None]: + return self.evaluate(t0, t1, left), path_state + def evaluate( self, t0: RealScalarLike, t1: Optional[RealScalarLike] = None, left: bool = True ) -> _Control: return self.fn(t0, t1) +# probably be consistent with path/control naming +_MaybePathState: TypeAlias = Union[PyTree, None] + + def _callable_to_path( x: Union[ - AbstractPath[_Control], Callable[[RealScalarLike, RealScalarLike], _Control] + AbstractPath[_Control, _ControlState], + Callable[[RealScalarLike, RealScalarLike], _Control], ], -) -> AbstractPath[_Control]: +) -> AbstractPath[_Control, _MaybePathState]: if isinstance(x, AbstractPath): return x else: @@ -272,18 +337,44 @@ def _prod(vf, control): # This class exists for backward compatibility with `WeaklyDiagonalControlTerm`. If we # were writing things again today it would be folded into just `ControlTerm`. -class _AbstractControlTerm(AbstractTerm[_VF, _Control]): +class _AbstractControlTerm(AbstractTerm[_VF, _Control, _ControlState]): vector_field: Callable[[RealScalarLike, Y, Args], _VF] control: Union[ - AbstractPath[_Control], Callable[[RealScalarLike, RealScalarLike], _Control] + AbstractPath[_Control, _ControlState], + # can we allow stateful functions? This would have no way to "init" and thus + # the user would have to provide a custom init path state which sounds + # not ideal, probably just be easier to have them make an abstract path? + # Callable[[RealScalarLike, PyTree, RealScalarLike], tuple[_Control, PyTree]], + Callable[[RealScalarLike, RealScalarLike], _Control], ] = eqx.field(converter=_callable_to_path) # pyright: ignore + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> _PathState: + if isinstance(self.control, AbstractPath): + return self.control.init(t0, t1, y0, args) + return None + def vf(self, t: RealScalarLike, y: Y, args: Args) -> VF: return self.vector_field(t, y, args) - def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> _Control: - return self.control.evaluate(t0, t1, **kwargs) # pyright: ignore - + def contr( + self, + t0: RealScalarLike, + t1: RealScalarLike, + control_state: _ControlState, + **kwargs, + ) -> tuple[_Control, _ControlState]: + if isinstance(self.control, AbstractPath): + return self.control(t0, control_state, t1, **kwargs) + return self.control(t0, t1, **kwargs), control_state + + # TODO: support stateful conversion here + # more broadly, add derivative function to path for __call__? def to_ode(self) -> ODETerm: r"""If the control is differentiable then $f(t, y(t), args) \mathrm{d}x(t)$ may be thought of as an ODE as @@ -311,14 +402,14 @@ def to_ode(self) -> ODETerm: - `control`: The control. Should either be - 1. a [`diffrax.AbstractPath`][], in which case its `.evaluate(t0, t1)` method - will be used to give the increment of the control over a time interval + 1. a [`diffrax.AbstractPath`][], in which case its `.__call__(t0, path_state, t1)` + method will be used to give the increment of the control over a time interval `[t0, t1]`, or 2. a callable `(t0, t1) -> increment`, which returns the increment directly. """ -class ControlTerm(_AbstractControlTerm[_VF, _Control]): +class ControlTerm(_AbstractControlTerm[_VF, _Control, _ControlState]): r"""A term representing the general case of $f(t, y(t), args) \mathrm{d}x(t)$, in which the vector field ($f$) - control ($\mathrm{d}x$) interaction is a matrix-vector product. @@ -458,7 +549,7 @@ def prod(self, vf: _VF, control: _Control) -> Y: return jtu.tree_map(_prod, vf, control) -class WeaklyDiagonalControlTerm(_AbstractControlTerm[_VF, _Control]): +class WeaklyDiagonalControlTerm(_AbstractControlTerm[_VF, _Control, _ControlState]): r""" DEPRECATED. Prefer: @@ -572,10 +663,23 @@ def __init__(self, *terms: AbstractTerm): def vf(self, t: RealScalarLike, y: Y, args: Args) -> tuple[PyTree[ArrayLike], ...]: return tuple(term.vf(t, y, args) for term in self.terms) + def init( + self, t0: RealScalarLike, t1: RealScalarLike, y0: Y, args: Args + ) -> tuple[PyTree, ...]: + return tuple(term.init(t0, t1, y0, args) for term in self.terms) + def contr( - self, t0: RealScalarLike, t1: RealScalarLike, **kwargs - ) -> tuple[PyTree[ArrayLike], ...]: - return tuple(term.contr(t0, t1, **kwargs) for term in self.terms) + self, + t0: RealScalarLike, + t1: RealScalarLike, + control_state: PyTree, + **kwargs, + ) -> tuple[tuple[PyTree[ArrayLike], ...], tuple[PyTree, ...]]: + contrs = [ + term.contr(t0, t1, state, **kwargs) + for term, state in zip(self.terms, control_state) + ] + return (tuple(i[0] for i in contrs), tuple(i[1] for i in contrs)) def prod( self, vf: tuple[PyTree[ArrayLike], ...], control: tuple[PyTree[ArrayLike], ...] @@ -609,18 +713,34 @@ def is_vf_expensive( return any(term.is_vf_expensive(t0, t1, y, args) for term in self.terms) -class WrapTerm(AbstractTerm[_VF, _Control]): - term: AbstractTerm[_VF, _Control] +class WrapTerm(AbstractTerm[_VF, _Control, _ControlState]): + term: AbstractTerm[_VF, _Control, _ControlState] direction: IntScalarLike def vf(self, t: RealScalarLike, y: Y, args: Args) -> _VF: t = t * self.direction return self.term.vf(t, y, args) - def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> _Control: + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> _PathState: + return self.term.init(t0, t1, y0, args) + + def contr( + self, + t0: RealScalarLike, + t1: RealScalarLike, + control_state: _ControlState, + **kwargs, + ) -> tuple[_Control, _ControlState]: _t0 = jnp.where(self.direction == 1, t0, -t1) _t1 = jnp.where(self.direction == 1, t1, -t0) - return (self.direction * self.term.contr(_t0, _t1, **kwargs) ** ω).ω + contrs = self.term.contr(_t0, _t1, control_state, **kwargs) + return (self.direction * contrs[0] ** ω).ω, contrs[1] def prod(self, vf: _VF, control: _Control) -> Y: with jax.numpy_dtype_promotion("standard"): @@ -642,8 +762,11 @@ def is_vf_expensive( return self.term.is_vf_expensive(_t0, _t1, y, args) -class AdjointTerm(AbstractTerm[_VF, _Control]): - term: AbstractTerm[_VF, _Control] +_AdjoingControlState: TypeAlias = Union[None, PyTree] + + +class AdjointTerm(AbstractTerm[_VF, _Control, _AdjoingControlState]): + term: AbstractTerm[_VF, _Control, _AdjoingControlState] def is_vf_expensive( self, @@ -654,12 +777,23 @@ def is_vf_expensive( ], args: Args, ) -> bool: - control_struct = eqx.filter_eval_shape(self.contr, t0, t1) + control_struct = eqx.filter_eval_shape( + self.contr, t0, t1, self.term.init(t0, t1, y, args) + ) if sum(c.size for c in jtu.tree_leaves(control_struct)) in (0, 1): return False else: return True + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> _PathState: + return self.term.init(t0, t1, y0, args) + def vf( self, t: RealScalarLike, @@ -687,7 +821,8 @@ def vf( # The value of `control` is never actually used -- just its shape, dtype, and # PyTree structure. (This is because `self.vf_prod` is linear in `control`.) - control = self.contr(t, t) + contr_state_struct = self.init(t, t, y, args) + control, _ = self.contr(t, t, contr_state_struct) y_size = sum(np.size(yi) for yi in jtu.tree_leaves(y)) control_size = sum(np.size(ci) for ci in jtu.tree_leaves(control)) @@ -721,8 +856,14 @@ def _fn(_control): ) return jtu.tree_transpose(vf_prod_tree, control_tree, jac) - def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> _Control: - return self.term.contr(t0, t1, **kwargs) + def contr( + self, + t0: RealScalarLike, + t1: RealScalarLike, + control_state: _AdjoingControlState, + **kwargs, + ) -> tuple[_Control, _AdjoingControlState]: + return self.term.contr(t0, t1, control_state, **kwargs) def prod( self, vf: PyTree[ArrayLike], control: _Control @@ -832,7 +973,9 @@ def broadcast_underdamped_langevin_arg( class UnderdampedLangevinDiffusionTerm( AbstractTerm[ - UnderdampedLangevinX, Union[UnderdampedLangevinX, AbstractBrownianIncrement] + UnderdampedLangevinX, + Union[UnderdampedLangevinX, AbstractBrownianIncrement], + _ControlState, ] ): r"""Represents the diffusion term in the Underdamped Langevin Diffusion (ULD). @@ -874,6 +1017,15 @@ def __init__( self.u = u self.control = bm + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> _PathState: + return self.control.init(t0, t1, y0, args) + def vf( self, t: RealScalarLike, y: UnderdampedLangevinTuple, args: Args ) -> UnderdampedLangevinX: @@ -891,9 +1043,14 @@ def _fun(_gamma, _u): return vf_v def contr( - self, t0: RealScalarLike, t1: RealScalarLike, **kwargs - ) -> Union[UnderdampedLangevinX, AbstractBrownianIncrement]: - return self.control.evaluate(t0, t1, **kwargs) + self, + t0: RealScalarLike, + t1: RealScalarLike, + control_state: _ControlState, + **kwargs, + ) -> tuple[Union[UnderdampedLangevinX, AbstractBrownianIncrement], _ControlState]: + # same stateless function as above + return self.control(t0, control_state, t1, **kwargs) def prod( self, vf: UnderdampedLangevinX, control: UnderdampedLangevinX @@ -948,6 +1105,15 @@ def __init__( self.u = u self.grad_f = grad_f + def init( + self, + t0: RealScalarLike, + t1: RealScalarLike, + y0: Y, + args: Args, + ) -> None: + return None + def vf( self, t: RealScalarLike, y: UnderdampedLangevinTuple, args: Args ) -> UnderdampedLangevinTuple: @@ -974,8 +1140,14 @@ def fun(_gamma, _u, _v, _f_x): vf_y = (vf_x, vf_v) return vf_y - def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> RealScalarLike: - return t1 - t0 + def contr( + self, + t0: RealScalarLike, + t1: RealScalarLike, + control_state: None = None, + **kwargs, + ) -> tuple[RealScalarLike, None]: + return t1 - t0, None def prod( self, vf: UnderdampedLangevinTuple, control: RealScalarLike diff --git a/examples/neural_sde.ipynb b/examples/neural_sde.ipynb index a4624cad..ac641b33 100644 --- a/examples/neural_sde.ipynb +++ b/examples/neural_sde.ipynb @@ -575,83 +575,67 @@ }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Step: 0, Loss: 0.13390611750738962\n", - "Step: 200, Loss: 4.786926678248814\n", - "Step: 400, Loss: 7.736175605228969\n", - "Step: 600, Loss: 10.103722981044225\n", - "Step: 800, Loss: 11.831081799098424\n", - "Step: 1000, Loss: 7.418417045048305\n", - "Step: 1200, Loss: 6.938951356070382\n", - "Step: 1400, Loss: 2.881302390779768\n", - "Step: 1600, Loss: 1.5363099915640694\n", - "Step: 1800, Loss: 1.0079529796327864\n", - "Step: 2000, Loss: 0.936917781829834\n", - "Step: 2200, Loss: 0.9594544768333435\n", - "Step: 2400, Loss: 1.247592806816101\n", - "Step: 2600, Loss: 0.9021680951118469\n", - "Step: 2800, Loss: 0.861811808177403\n", - "Step: 3000, Loss: 1.1381437267575945\n", - "Step: 3200, Loss: 1.5369644505637032\n", - "Step: 3400, Loss: 1.3387839964457922\n", - "Step: 3600, Loss: 1.0477747491427831\n", - "Step: 3800, Loss: 1.7565655538014002\n", - "Step: 4000, Loss: 1.8188678196498327\n", - "Step: 4200, Loss: 1.4719816957201277\n", - "Step: 4400, Loss: 1.4189972026007516\n", - "Step: 4600, Loss: 0.6867345826966422\n", - "Step: 4800, Loss: 0.6138326355389186\n", - "Step: 5000, Loss: 0.5908999613353184\n", - "Step: 5200, Loss: 0.579599814755576\n", - "Step: 5400, Loss: -0.8964726499148777\n", - "Step: 5600, Loss: -4.22784035546439\n", - "Step: 5800, Loss: 1.8623723132269723\n", - "Step: 6000, Loss: -0.17913252328123366\n", - "Step: 6200, Loss: 1.2232166869299752\n", - "Step: 6400, Loss: 1.1680303982325964\n", - "Step: 6600, Loss: -0.5765694592680249\n", - "Step: 6800, Loss: 0.5931433950151715\n", - "Step: 7000, Loss: 0.12497492773192269\n", - "Step: 7200, Loss: 0.5957097922052655\n", - "Step: 7400, Loss: 0.33551327671323505\n", - "Step: 7600, Loss: 0.5243289640971592\n", - "Step: 7800, Loss: 0.797236042363303\n", - "Step: 8000, Loss: 0.5341930559703282\n", - "Step: 8200, Loss: 1.1995042221886771\n", - "Step: 8400, Loss: -0.5231874521289553\n", - "Step: 8600, Loss: -0.42040516648973736\n", - "Step: 8800, Loss: 1.384656548500061\n", - "Step: 9000, Loss: 1.4223246574401855\n", - "Step: 9200, Loss: 0.2646511915538992\n", - "Step: 9400, Loss: -0.046253203813518794\n", - "Step: 9600, Loss: 0.738983656678881\n", - "Step: 9800, Loss: 1.1247712458883012\n", - "Step: 9999, Loss: -0.44179755449295044\n" + "ename": "TracerArrayConversionError", + "evalue": "The numpy.ndarray conversion method __array__() was called on traced array with shape float32[3]\nThe error occurred while tracing the function _fn at /Users/owenlockwood/miniforge3/envs/dev_diffrax/lib/python3.10/site-packages/equinox/_eval_shape.py:31 for jit. This concrete value was not available in Python because it depends on the values of the arguments _dynamic[1][0].tprev and _dynamic[1][0].tnext.\nSee https://jax.readthedocs.io/en/latest/errors.html#jax.errors.TracerArrayConversionError", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/miniforge3/envs/dev_diffrax/lib/python3.10/site-packages/numpy/core/fromnumeric.py:3209\u001b[0m, in \u001b[0;36mndim\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 3208\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 3209\u001b[0m \u001b[39mreturn\u001b[39;00m a\u001b[39m.\u001b[39;49mndim\n\u001b[1;32m 3210\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mAttributeError\u001b[39;00m:\n", + "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'ndim'", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mTracerArrayConversionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m main()\n", + "Cell \u001b[0;32mIn[7], line 54\u001b[0m, in \u001b[0;36mmain\u001b[0;34m(initial_noise_size, noise_size, hidden_size, width_size, depth, generator_lr, discriminator_lr, batch_size, steps, steps_per_print, dataset_size, seed)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[39mfor\u001b[39;00m step, (ts_i, ys_i) \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(\u001b[39mrange\u001b[39m(steps), infinite_dataloader):\n\u001b[1;32m 53\u001b[0m step \u001b[39m=\u001b[39m jnp\u001b[39m.\u001b[39masarray(step)\n\u001b[0;32m---> 54\u001b[0m generator, discriminator, g_opt_state, d_opt_state \u001b[39m=\u001b[39m make_step(\n\u001b[1;32m 55\u001b[0m generator,\n\u001b[1;32m 56\u001b[0m discriminator,\n\u001b[1;32m 57\u001b[0m g_opt_state,\n\u001b[1;32m 58\u001b[0m d_opt_state,\n\u001b[1;32m 59\u001b[0m g_optim,\n\u001b[1;32m 60\u001b[0m d_optim,\n\u001b[1;32m 61\u001b[0m ts_i,\n\u001b[1;32m 62\u001b[0m ys_i,\n\u001b[1;32m 63\u001b[0m key,\n\u001b[1;32m 64\u001b[0m step,\n\u001b[1;32m 65\u001b[0m )\n\u001b[1;32m 66\u001b[0m \u001b[39mif\u001b[39;00m (step \u001b[39m%\u001b[39m steps_per_print) \u001b[39m==\u001b[39m \u001b[39m0\u001b[39m \u001b[39mor\u001b[39;00m step \u001b[39m==\u001b[39m steps \u001b[39m-\u001b[39m \u001b[39m1\u001b[39m:\n\u001b[1;32m 67\u001b[0m total_score \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m\n", + " \u001b[0;31m[... skipping hidden 15 frame]\u001b[0m\n", + "Cell \u001b[0;32mIn[6], line 36\u001b[0m, in \u001b[0;36mmake_step\u001b[0;34m(generator, discriminator, g_opt_state, d_opt_state, g_optim, d_optim, ts_i, ys_i, key, step)\u001b[0m\n\u001b[1;32m 23\u001b[0m \u001b[39m@eqx\u001b[39m\u001b[39m.\u001b[39mfilter_jit\n\u001b[1;32m 24\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mmake_step\u001b[39m(\n\u001b[1;32m 25\u001b[0m generator,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 34\u001b[0m step,\n\u001b[1;32m 35\u001b[0m ):\n\u001b[0;32m---> 36\u001b[0m g_grad, d_grad \u001b[39m=\u001b[39m grad_loss((generator, discriminator), ts_i, ys_i, key, step)\n\u001b[1;32m 37\u001b[0m g_updates, g_opt_state \u001b[39m=\u001b[39m g_optim\u001b[39m.\u001b[39mupdate(g_grad, g_opt_state)\n\u001b[1;32m 38\u001b[0m d_updates, d_opt_state \u001b[39m=\u001b[39m d_optim\u001b[39m.\u001b[39mupdate(d_grad, d_opt_state)\n", + " \u001b[0;31m[... skipping hidden 11 frame]\u001b[0m\n", + "Cell \u001b[0;32mIn[6], line 15\u001b[0m, in \u001b[0;36mgrad_loss\u001b[0;34m(g_d, ts_i, ys_i, key, step)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[39m@eqx\u001b[39m\u001b[39m.\u001b[39mfilter_grad\n\u001b[1;32m 13\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mgrad_loss\u001b[39m(g_d, ts_i, ys_i, key, step):\n\u001b[1;32m 14\u001b[0m generator, discriminator \u001b[39m=\u001b[39m g_d\n\u001b[0;32m---> 15\u001b[0m \u001b[39mreturn\u001b[39;00m loss(generator, discriminator, ts_i, ys_i, key, step)\n", + " \u001b[0;31m[... skipping hidden 15 frame]\u001b[0m\n", + "Cell \u001b[0;32mIn[6], line 6\u001b[0m, in \u001b[0;36mloss\u001b[0;34m(generator, discriminator, ts_i, ys_i, key, step)\u001b[0m\n\u001b[1;32m 4\u001b[0m key \u001b[39m=\u001b[39m jr\u001b[39m.\u001b[39mfold_in(key, step)\n\u001b[1;32m 5\u001b[0m key \u001b[39m=\u001b[39m jr\u001b[39m.\u001b[39msplit(key, batch_size)\n\u001b[0;32m----> 6\u001b[0m fake_ys_i \u001b[39m=\u001b[39m jax\u001b[39m.\u001b[39;49mvmap(generator)(ts_i, key\u001b[39m=\u001b[39;49mkey)\n\u001b[1;32m 7\u001b[0m real_score \u001b[39m=\u001b[39m jax\u001b[39m.\u001b[39mvmap(discriminator)(ts_i, ys_i)\n\u001b[1;32m 8\u001b[0m fake_score \u001b[39m=\u001b[39m jax\u001b[39m.\u001b[39mvmap(discriminator)(ts_i, fake_ys_i)\n", + " \u001b[0;31m[... skipping hidden 3 frame]\u001b[0m\n", + "Cell \u001b[0;32mIn[4], line 53\u001b[0m, in \u001b[0;36mNeuralSDE.__call__\u001b[0;34m(self, ts, key)\u001b[0m\n\u001b[1;32m 51\u001b[0m y0 \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39minitial(init)\n\u001b[1;32m 52\u001b[0m saveat \u001b[39m=\u001b[39m diffrax\u001b[39m.\u001b[39mSaveAt(ts\u001b[39m=\u001b[39mts)\n\u001b[0;32m---> 53\u001b[0m sol \u001b[39m=\u001b[39m diffrax\u001b[39m.\u001b[39;49mdiffeqsolve(terms, solver, t0, t1, dt0, y0, saveat\u001b[39m=\u001b[39;49msaveat)\n\u001b[1;32m 54\u001b[0m \u001b[39mreturn\u001b[39;00m jax\u001b[39m.\u001b[39mvmap(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mreadout)(sol\u001b[39m.\u001b[39mys)\n", + "File \u001b[0;32m~/Documents/diffrax_extensions/diffrax/_integrate.py:1464\u001b[0m, in \u001b[0;36mdiffeqsolve\u001b[0;34m(terms, solver, t0, t1, dt0, y0, args, saveat, stepsize_controller, adjoint, event, max_steps, throw, progress_meter, solver_state, controller_state, made_jump, path_state, discrete_terminating_event)\u001b[0m\n\u001b[1;32m 1436\u001b[0m init_state \u001b[39m=\u001b[39m State(\n\u001b[1;32m 1437\u001b[0m y\u001b[39m=\u001b[39my0,\n\u001b[1;32m 1438\u001b[0m tprev\u001b[39m=\u001b[39mtprev,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1457\u001b[0m event_mask\u001b[39m=\u001b[39mevent_mask,\n\u001b[1;32m 1458\u001b[0m )\n\u001b[1;32m 1460\u001b[0m \u001b[39m#\u001b[39;00m\n\u001b[1;32m 1461\u001b[0m \u001b[39m# Main loop\u001b[39;00m\n\u001b[1;32m 1462\u001b[0m \u001b[39m#\u001b[39;00m\n\u001b[0;32m-> 1464\u001b[0m final_state, aux_stats \u001b[39m=\u001b[39m adjoint\u001b[39m.\u001b[39;49mloop(\n\u001b[1;32m 1465\u001b[0m args\u001b[39m=\u001b[39;49margs,\n\u001b[1;32m 1466\u001b[0m terms\u001b[39m=\u001b[39;49mterms,\n\u001b[1;32m 1467\u001b[0m solver\u001b[39m=\u001b[39;49msolver,\n\u001b[1;32m 1468\u001b[0m stepsize_controller\u001b[39m=\u001b[39;49mstepsize_controller,\n\u001b[1;32m 1469\u001b[0m event\u001b[39m=\u001b[39;49mevent,\n\u001b[1;32m 1470\u001b[0m saveat\u001b[39m=\u001b[39;49msaveat,\n\u001b[1;32m 1471\u001b[0m t0\u001b[39m=\u001b[39;49mt0,\n\u001b[1;32m 1472\u001b[0m t1\u001b[39m=\u001b[39;49mt1,\n\u001b[1;32m 1473\u001b[0m dt0\u001b[39m=\u001b[39;49mdt0,\n\u001b[1;32m 1474\u001b[0m max_steps\u001b[39m=\u001b[39;49mmax_steps,\n\u001b[1;32m 1475\u001b[0m init_state\u001b[39m=\u001b[39;49minit_state,\n\u001b[1;32m 1476\u001b[0m throw\u001b[39m=\u001b[39;49mthrow,\n\u001b[1;32m 1477\u001b[0m passed_solver_state\u001b[39m=\u001b[39;49mpassed_solver_state,\n\u001b[1;32m 1478\u001b[0m passed_controller_state\u001b[39m=\u001b[39;49mpassed_controller_state,\n\u001b[1;32m 1479\u001b[0m passed_path_state\u001b[39m=\u001b[39;49mpassed_path_state,\n\u001b[1;32m 1480\u001b[0m progress_meter\u001b[39m=\u001b[39;49mprogress_meter,\n\u001b[1;32m 1481\u001b[0m )\n\u001b[1;32m 1483\u001b[0m \u001b[39m#\u001b[39;00m\n\u001b[1;32m 1484\u001b[0m \u001b[39m# Finish up\u001b[39;00m\n\u001b[1;32m 1485\u001b[0m \u001b[39m#\u001b[39;00m\n\u001b[1;32m 1487\u001b[0m progress_meter\u001b[39m.\u001b[39mclose(final_state\u001b[39m.\u001b[39mprogress_meter_state)\n", + " \u001b[0;31m[... skipping hidden 1 frame]\u001b[0m\n", + "File \u001b[0;32m~/Documents/diffrax_extensions/diffrax/_adjoint.py:308\u001b[0m, in \u001b[0;36mRecursiveCheckpointAdjoint.loop\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m 304\u001b[0m outer_while_loop \u001b[39m=\u001b[39m ft\u001b[39m.\u001b[39mpartial(\n\u001b[1;32m 305\u001b[0m _outer_loop, kind\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mcheckpointed\u001b[39m\u001b[39m\"\u001b[39m, checkpoints\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcheckpoints\n\u001b[1;32m 306\u001b[0m )\n\u001b[1;32m 307\u001b[0m msg \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m--> 308\u001b[0m final_state \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_loop(\n\u001b[1;32m 309\u001b[0m terms\u001b[39m=\u001b[39;49mterms,\n\u001b[1;32m 310\u001b[0m saveat\u001b[39m=\u001b[39;49msaveat,\n\u001b[1;32m 311\u001b[0m init_state\u001b[39m=\u001b[39;49minit_state,\n\u001b[1;32m 312\u001b[0m max_steps\u001b[39m=\u001b[39;49mmax_steps,\n\u001b[1;32m 313\u001b[0m inner_while_loop\u001b[39m=\u001b[39;49minner_while_loop,\n\u001b[1;32m 314\u001b[0m outer_while_loop\u001b[39m=\u001b[39;49mouter_while_loop,\n\u001b[1;32m 315\u001b[0m \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs,\n\u001b[1;32m 316\u001b[0m )\n\u001b[1;32m 317\u001b[0m \u001b[39mif\u001b[39;00m msg \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 318\u001b[0m final_state \u001b[39m=\u001b[39m eqxi\u001b[39m.\u001b[39mnondifferentiable_backward(\n\u001b[1;32m 319\u001b[0m final_state, msg\u001b[39m=\u001b[39mmsg, symbolic\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m\n\u001b[1;32m 320\u001b[0m )\n", + "File \u001b[0;32m~/Documents/diffrax_extensions/diffrax/_integrate.py:624\u001b[0m, in \u001b[0;36mloop\u001b[0;34m(solver, stepsize_controller, event, saveat, t0, t1, dt0, max_steps, terms, args, init_state, inner_while_loop, outer_while_loop, progress_meter)\u001b[0m\n\u001b[1;32m 622\u001b[0m static_made_jump \u001b[39m=\u001b[39m init_state\u001b[39m.\u001b[39mmade_jump\n\u001b[1;32m 623\u001b[0m static_result \u001b[39m=\u001b[39m init_state\u001b[39m.\u001b[39mresult\n\u001b[0;32m--> 624\u001b[0m _, traced_jump, traced_result \u001b[39m=\u001b[39m eqx\u001b[39m.\u001b[39;49mfilter_eval_shape(body_fun_aux, init_state)\n\u001b[1;32m 625\u001b[0m \u001b[39mif\u001b[39;00m traced_jump:\n\u001b[1;32m 626\u001b[0m static_made_jump \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n", + " \u001b[0;31m[... skipping hidden 14 frame]\u001b[0m\n", + "File \u001b[0;32m~/Documents/diffrax_extensions/diffrax/_integrate.py:351\u001b[0m, in \u001b[0;36mloop..body_fun_aux\u001b[0;34m(state)\u001b[0m\n\u001b[1;32m 344\u001b[0m state \u001b[39m=\u001b[39m _handle_static(state)\n\u001b[1;32m 346\u001b[0m \u001b[39m#\u001b[39;00m\n\u001b[1;32m 347\u001b[0m \u001b[39m# Actually do some differential equation solving! Make numerical steps, adapt\u001b[39;00m\n\u001b[1;32m 348\u001b[0m \u001b[39m# step sizes, all that jazz.\u001b[39;00m\n\u001b[1;32m 349\u001b[0m \u001b[39m#\u001b[39;00m\n\u001b[0;32m--> 351\u001b[0m (y, y_error, dense_info, solver_state, path_state, solver_result) \u001b[39m=\u001b[39m solver\u001b[39m.\u001b[39;49mstep(\n\u001b[1;32m 352\u001b[0m terms,\n\u001b[1;32m 353\u001b[0m state\u001b[39m.\u001b[39;49mtprev,\n\u001b[1;32m 354\u001b[0m state\u001b[39m.\u001b[39;49mtnext,\n\u001b[1;32m 355\u001b[0m state\u001b[39m.\u001b[39;49my,\n\u001b[1;32m 356\u001b[0m args,\n\u001b[1;32m 357\u001b[0m state\u001b[39m.\u001b[39;49msolver_state,\n\u001b[1;32m 358\u001b[0m state\u001b[39m.\u001b[39;49mmade_jump,\n\u001b[1;32m 359\u001b[0m state\u001b[39m.\u001b[39;49mpath_state,\n\u001b[1;32m 360\u001b[0m )\n\u001b[1;32m 362\u001b[0m \u001b[39m# e.g. if someone has a sqrt(y) in the vector field, and dt0 is so large that\u001b[39;00m\n\u001b[1;32m 363\u001b[0m \u001b[39m# we get a negative value for y, and then get a NaN vector field. (And then\u001b[39;00m\n\u001b[1;32m 364\u001b[0m \u001b[39m# everything breaks.) See #143.\u001b[39;00m\n\u001b[1;32m 365\u001b[0m y_error \u001b[39m=\u001b[39m jtu\u001b[39m.\u001b[39mtree_map(\u001b[39mlambda\u001b[39;00m x: jnp\u001b[39m.\u001b[39mwhere(jnp\u001b[39m.\u001b[39misnan(x), jnp\u001b[39m.\u001b[39minf, x), y_error)\n", + " \u001b[0;31m[... skipping hidden 1 frame]\u001b[0m\n", + "File \u001b[0;32m~/Documents/diffrax_extensions/diffrax/_solver/reversible_heun.py:80\u001b[0m, in \u001b[0;36mReversibleHeun.step\u001b[0;34m(self, terms, t0, t1, y0, args, solver_state, made_jump, path_state)\u001b[0m\n\u001b[1;32m 77\u001b[0m vf0 \u001b[39m=\u001b[39m lax\u001b[39m.\u001b[39mcond(made_jump, \u001b[39mlambda\u001b[39;00m _: terms\u001b[39m.\u001b[39mvf(t0, y0, args), \u001b[39mlambda\u001b[39;00m _: vf0, \u001b[39mNone\u001b[39;00m)\n\u001b[1;32m 79\u001b[0m control, new_path_state \u001b[39m=\u001b[39m terms\u001b[39m.\u001b[39mcontr(t0, t1, path_state)\n\u001b[0;32m---> 80\u001b[0m yhat1 \u001b[39m=\u001b[39m (\u001b[39m2\u001b[39m \u001b[39m*\u001b[39m y0\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mω \u001b[39m-\u001b[39m yhat0\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mω \u001b[39m+\u001b[39m terms\u001b[39m.\u001b[39;49mprod(vf0, control) \u001b[39m*\u001b[39m\u001b[39m*\u001b[39m ω)\u001b[39m.\u001b[39mω\n\u001b[1;32m 81\u001b[0m vf1 \u001b[39m=\u001b[39m terms\u001b[39m.\u001b[39mvf(t1, yhat1, args)\n\u001b[1;32m 82\u001b[0m y1 \u001b[39m=\u001b[39m (y0\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mω \u001b[39m+\u001b[39m \u001b[39m0.5\u001b[39m \u001b[39m*\u001b[39m terms\u001b[39m.\u001b[39mprod((vf0\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mω \u001b[39m+\u001b[39m vf1\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mω)\u001b[39m.\u001b[39mω, control) \u001b[39m*\u001b[39m\u001b[39m*\u001b[39m ω)\u001b[39m.\u001b[39mω\n", + " \u001b[0;31m[... skipping hidden 1 frame]\u001b[0m\n", + "File \u001b[0;32m~/Documents/diffrax_extensions/diffrax/_term.py:614\u001b[0m, in \u001b[0;36mMultiTerm.prod\u001b[0;34m(self, vf, control)\u001b[0m\n\u001b[1;32m 611\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mprod\u001b[39m(\n\u001b[1;32m 612\u001b[0m \u001b[39mself\u001b[39m, vf: \u001b[39mtuple\u001b[39m[PyTree[ArrayLike], \u001b[39m.\u001b[39m\u001b[39m.\u001b[39m\u001b[39m.\u001b[39m], control: \u001b[39mtuple\u001b[39m[PyTree[ArrayLike], \u001b[39m.\u001b[39m\u001b[39m.\u001b[39m\u001b[39m.\u001b[39m]\n\u001b[1;32m 613\u001b[0m ) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m Y:\n\u001b[0;32m--> 614\u001b[0m out \u001b[39m=\u001b[39m [\n\u001b[1;32m 615\u001b[0m term\u001b[39m.\u001b[39mprod(vf_, control_)\n\u001b[1;32m 616\u001b[0m \u001b[39mfor\u001b[39;00m term, vf_, control_ \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mterms, vf, control)\n\u001b[1;32m 617\u001b[0m ]\n\u001b[1;32m 618\u001b[0m \u001b[39mreturn\u001b[39;00m jtu\u001b[39m.\u001b[39mtree_map(_sum, \u001b[39m*\u001b[39mout)\n", + "File \u001b[0;32m~/Documents/diffrax_extensions/diffrax/_term.py:615\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 611\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mprod\u001b[39m(\n\u001b[1;32m 612\u001b[0m \u001b[39mself\u001b[39m, vf: \u001b[39mtuple\u001b[39m[PyTree[ArrayLike], \u001b[39m.\u001b[39m\u001b[39m.\u001b[39m\u001b[39m.\u001b[39m], control: \u001b[39mtuple\u001b[39m[PyTree[ArrayLike], \u001b[39m.\u001b[39m\u001b[39m.\u001b[39m\u001b[39m.\u001b[39m]\n\u001b[1;32m 613\u001b[0m ) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m Y:\n\u001b[1;32m 614\u001b[0m out \u001b[39m=\u001b[39m [\n\u001b[0;32m--> 615\u001b[0m term\u001b[39m.\u001b[39;49mprod(vf_, control_)\n\u001b[1;32m 616\u001b[0m \u001b[39mfor\u001b[39;00m term, vf_, control_ \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mterms, vf, control)\n\u001b[1;32m 617\u001b[0m ]\n\u001b[1;32m 618\u001b[0m \u001b[39mreturn\u001b[39;00m jtu\u001b[39m.\u001b[39mtree_map(_sum, \u001b[39m*\u001b[39mout)\n", + " \u001b[0;31m[... skipping hidden 1 frame]\u001b[0m\n", + "File \u001b[0;32m~/Documents/diffrax_extensions/diffrax/_term.py:665\u001b[0m, in \u001b[0;36mWrapTerm.prod\u001b[0;34m(self, vf, control)\u001b[0m\n\u001b[1;32m 663\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mprod\u001b[39m(\u001b[39mself\u001b[39m, vf: _VF, control: _Control) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m Y:\n\u001b[1;32m 664\u001b[0m \u001b[39mwith\u001b[39;00m jax\u001b[39m.\u001b[39mnumpy_dtype_promotion(\u001b[39m\"\u001b[39m\u001b[39mstandard\u001b[39m\u001b[39m\"\u001b[39m):\n\u001b[0;32m--> 665\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mterm\u001b[39m.\u001b[39;49mprod(vf, control)\n", + " \u001b[0;31m[... skipping hidden 1 frame]\u001b[0m\n", + "File \u001b[0;32m~/Documents/diffrax_extensions/diffrax/_term.py:479\u001b[0m, in \u001b[0;36mControlTerm.prod\u001b[0;34m(self, vf, control)\u001b[0m\n\u001b[1;32m 477\u001b[0m \u001b[39mreturn\u001b[39;00m vf\u001b[39m.\u001b[39mmv(control)\n\u001b[1;32m 478\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 479\u001b[0m \u001b[39mreturn\u001b[39;00m jtu\u001b[39m.\u001b[39;49mtree_map(_prod, vf, control)\n", + " \u001b[0;31m[... skipping hidden 2 frame]\u001b[0m\n", + "File \u001b[0;32m~/Documents/diffrax_extensions/diffrax/_term.py:284\u001b[0m, in \u001b[0;36m_prod\u001b[0;34m(vf, control)\u001b[0m\n\u001b[1;32m 283\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_prod\u001b[39m(vf, control):\n\u001b[0;32m--> 284\u001b[0m \u001b[39mreturn\u001b[39;00m jnp\u001b[39m.\u001b[39mtensordot(jnp\u001b[39m.\u001b[39mconj(vf), control, axes\u001b[39m=\u001b[39mjnp\u001b[39m.\u001b[39;49mndim(control))\n", + "File \u001b[0;32m~/miniforge3/envs/dev_diffrax/lib/python3.10/site-packages/numpy/core/fromnumeric.py:3211\u001b[0m, in \u001b[0;36mndim\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 3209\u001b[0m \u001b[39mreturn\u001b[39;00m a\u001b[39m.\u001b[39mndim\n\u001b[1;32m 3210\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mAttributeError\u001b[39;00m:\n\u001b[0;32m-> 3211\u001b[0m \u001b[39mreturn\u001b[39;00m asarray(a)\u001b[39m.\u001b[39mndim\n", + "File \u001b[0;32m~/miniforge3/envs/dev_diffrax/lib/python3.10/site-packages/jax/_src/core.py:714\u001b[0m, in \u001b[0;36mTracer.__array__\u001b[0;34m(self, *args, **kw)\u001b[0m\n\u001b[1;32m 713\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__array__\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkw):\n\u001b[0;32m--> 714\u001b[0m \u001b[39mraise\u001b[39;00m TracerArrayConversionError(\u001b[39mself\u001b[39m)\n", + "\u001b[0;31mTracerArrayConversionError\u001b[0m: The numpy.ndarray conversion method __array__() was called on traced array with shape float32[3]\nThe error occurred while tracing the function _fn at /Users/owenlockwood/miniforge3/envs/dev_diffrax/lib/python3.10/site-packages/equinox/_eval_shape.py:31 for jit. This concrete value was not available in Python because it depends on the values of the arguments _dynamic[1][0].tprev and _dynamic[1][0].tnext.\nSee https://jax.readthedocs.io/en/latest/errors.html#jax.errors.TracerArrayConversionError" ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ "main()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "afd29b2c", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "py38", + "display_name": "Python 3.10.14 ('dev_diffrax')", "language": "python", - "name": "py38" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -663,7 +647,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.10.14" + }, + "vscode": { + "interpreter": { + "hash": "01761703e8e304055600d311574f89f8a646f73edac04b8bff1580ad2d98581f" + } } }, "nbformat": 4, diff --git a/examples/underdamped_langevin_example.ipynb b/examples/underdamped_langevin_example.ipynb index 61309563..85d31ff7 100644 --- a/examples/underdamped_langevin_example.ipynb +++ b/examples/underdamped_langevin_example.ipynb @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "9deba250066ddc39", "metadata": { "ExecuteTime": { @@ -70,11 +70,11 @@ "y0 = (x0, v0)\n", "\n", "# Brownian motion\n", - "bm = diffrax.VirtualBrownianTree(\n", - " t0, t1, tol=0.01, shape=(2,), key=jr.key(0), levy_area=diffrax.SpaceTimeTimeLevyArea\n", + "bm = diffrax.UnsafeBrownianPath(\n", + " shape=(2,), key=jr.key(0), levy_area=diffrax.SpaceTimeTimeLevyArea\n", ")\n", "\n", - "drift_term = diffrax.UnderdampedLangevinDriftTerm(gamma, u, lambda x: 2 * x)\n", + "drift_term = diffrax.UnderdampedLangevinDriftTerm(gamma, u, lambda x, _: 2 * x)\n", "diffusion_term = diffrax.UnderdampedLangevinDiffusionTerm(gamma, u, bm)\n", "terms = diffrax.MultiTerm(drift_term, diffusion_term)\n", "\n", @@ -98,7 +98,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -126,25 +126,38 @@ "\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39d4c111", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.10.14 ('dev_diffrax')", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "vscode": { + "interpreter": { + "hash": "01761703e8e304055600d311574f89f8a646f73edac04b8bff1580ad2d98581f" + } } }, "nbformat": 4, diff --git a/test/test_adjoint.py b/test/test_adjoint.py index c45c6286..5bba08fe 100644 --- a/test/test_adjoint.py +++ b/test/test_adjoint.py @@ -215,6 +215,152 @@ def _convert_float0(x): assert tree_allclose(direct_grads, forward_grads, atol=1e-5) +@pytest.mark.slow +def test_direct_brownian(): + key = jax.random.key(42) + key, subkey = jax.random.split(key) + driftkey, diffusionkey, ykey = jr.split(subkey, 3) + drift_mlp = eqx.nn.MLP( + in_size=2, + out_size=2, + width_size=8, + depth=2, + activation=jax.nn.swish, + final_activation=jnp.tanh, + key=driftkey, + ) + diffusion_mlp = eqx.nn.MLP( + in_size=2, + out_size=2, + width_size=8, + depth=2, + activation=jax.nn.swish, + final_activation=jnp.tanh, + key=diffusionkey, + ) + + class Field(eqx.Module): + force: eqx.nn.MLP + + def __call__(self, t, y, args): + return self.force(y) + + class DiffusionField(eqx.Module): + force: eqx.nn.MLP + + def __call__(self, t, y, args): + return lx.DiagonalLinearOperator(self.force(y)) + + y0 = jr.normal(ykey, (2,)) + + k1, k2, k3 = jax.random.split(key, 3) + + vbt = diffrax.VirtualBrownianTree( + 0.3, 9.5, 1e-4, (2,), k1, levy_area=diffrax.SpaceTimeLevyArea + ) + dbp = diffrax.UnsafeBrownianPath((2,), k2, levy_area=diffrax.SpaceTimeLevyArea) + dbp_pre = diffrax.UnsafeBrownianPath( + (2,), k3, levy_area=diffrax.SpaceTimeLevyArea, precompute=int(9.5 / 0.1) + ) + + vbt_terms = diffrax.MultiTerm( + diffrax.ODETerm(Field(drift_mlp)), + diffrax.ControlTerm(DiffusionField(diffusion_mlp), vbt), + ) + dbp_terms = diffrax.MultiTerm( + diffrax.ODETerm(Field(drift_mlp)), + diffrax.ControlTerm(DiffusionField(diffusion_mlp), dbp), + ) + dbp_pre_terms = diffrax.MultiTerm( + diffrax.ODETerm(Field(drift_mlp)), + diffrax.ControlTerm(DiffusionField(diffusion_mlp), dbp_pre), + ) + + solver = diffrax.Heun() + + y0_args_term0 = (y0, None, vbt_terms) + y0_args_term1 = (y0, None, dbp_terms) + y0_args_term2 = (y0, None, dbp_pre_terms) + + def _run(y0__args__term, saveat, adjoint): + y0, args, term = y0__args__term + ys = diffrax.diffeqsolve( + term, + solver, + 0.3, + 9.5, + 0.1, + y0, + args, + saveat=saveat, + adjoint=adjoint, + max_steps=250, + ).ys + return jnp.sum(cast(Array, ys)) + + # Only does gradients with respect to y0 + def _run_finite_diff(y0__args__term, saveat, adjoint): + y0, args, term = y0__args__term + y0_a = y0 + jnp.array([1e-5, 0]) + y0_b = y0 + jnp.array([0, 1e-5]) + val = _run((y0, args, term), saveat, adjoint) + val_a = _run((y0_a, args, term), saveat, adjoint) + val_b = _run((y0_b, args, term), saveat, adjoint) + out_a = (val_a - val) / 1e-5 + out_b = (val_b - val) / 1e-5 + return jnp.stack([out_a, out_b]) + + for t0 in (True, False): + for t1 in (True, False): + for ts in (None, [0.3], [2.0], [9.5], [1.0, 7.0], [0.3, 7.0, 9.5]): + for i, y0__args__term in enumerate( + (y0_args_term0, y0_args_term1, y0_args_term2) + ): + if t0 is False and t1 is False and ts is None: + continue + + saveat = diffrax.SaveAt(t0=t0, t1=t1, ts=ts) + + inexact, static = eqx.partition( + y0__args__term, eqx.is_inexact_array + ) + + def _run_inexact(inexact, saveat, adjoint): + return _run(eqx.combine(inexact, static), saveat, adjoint) + + _run_grad = eqx.filter_jit(jax.grad(_run_inexact)) + _run_fwd_grad = eqx.filter_jit(jax.jacfwd(_run_inexact)) + + fd_grads = _run_finite_diff( + y0__args__term, saveat, diffrax.RecursiveCheckpointAdjoint() + ) + recursive_grads = _run_grad( + inexact, saveat, diffrax.RecursiveCheckpointAdjoint() + ) + if i == 0: + backsolve_grads = _run_grad( + inexact, saveat, diffrax.BacksolveAdjoint() + ) + assert tree_allclose(fd_grads, backsolve_grads[0], atol=1e-3) + + forward_grads = _run_fwd_grad( + inexact, saveat, diffrax.ForwardMode() + ) + # TODO: fix via https://github.com/patrick-kidger/equinox/issues/923 + # turns out this actually only fails for steps >256. Which is weird, + # because thats means 3 vs 2 calls in the base 16. But idk why that + # matter and yields some opaque assertion error. Maybe something to + # do with shapes? AssertionError + # ... + # assert all(all(map(core.typematch, + # j.out_avals, branches_known[0].out_avals)) + # for j in branches_known[1:]) + direct_grads = _run_grad(inexact, saveat, diffrax.DirectAdjoint()) + assert tree_allclose(fd_grads, direct_grads[0], atol=1e-3) + assert tree_allclose(fd_grads, recursive_grads[0], atol=1e-3) + assert tree_allclose(fd_grads, forward_grads[0], atol=1e-3) + + def test_adjoint_seminorm(): vector_field = lambda t, y, args: -y term = diffrax.ODETerm(vector_field) diff --git a/test/test_brownian.py b/test/test_brownian.py index 3a265019..a534005a 100644 --- a/test/test_brownian.py +++ b/test/test_brownian.py @@ -131,11 +131,13 @@ def test_statistics(ctr, levy_area, use_levy): def _eval(key): if ctr is diffrax.UnsafeBrownianPath: path = ctr(shape=(), key=key, levy_area=levy_area) + state = path.init(t0, t1, None, None) elif ctr is diffrax.VirtualBrownianTree: path = ctr(t0=0, t1=5, tol=2**-5, shape=(), key=key, levy_area=levy_area) + state = path.init(t0, t1, None, None) else: assert False - return path.evaluate(t0, t1, use_levy=use_levy) + return path(t0, state, t1, use_levy=use_levy)[0] values = jax.vmap(_eval)(keys) if use_levy: diff --git a/test/test_integrate.py b/test/test_integrate.py index 555d6ade..a84b78a8 100644 --- a/test/test_integrate.py +++ b/test/test_integrate.py @@ -14,7 +14,7 @@ import scipy.stats from diffrax import ControlTerm, MultiTerm, ODETerm from equinox.internal import ω -from jaxtyping import Array, ArrayLike, Float +from jaxtyping import Array, ArrayLike, Float, PyTree from .helpers import ( all_ode_solvers, @@ -611,7 +611,7 @@ def __mul__(self, other): class TestSolver(diffrax.Euler): term_structure = diffrax.AbstractTerm[ - tuple[Float[Array, "n 3"]], tuple[TestControl] + tuple[Float[Array, "n 3"]], tuple[TestControl], None ] solver = TestSolver() @@ -638,33 +638,47 @@ class TestSolver(diffrax.Euler): def test_term_compatibility_pytree(): + class _TestState(eqx.Module): + y: PyTree + state: PyTree + class TestSolver(diffrax.AbstractSolver): term_structure = { "a": diffrax.ODETerm, "b": diffrax.ODETerm[Any], "c": diffrax.ODETerm[Float[Array, " 3"]], - "d": diffrax.AbstractTerm[Float[Array, " 4"], Any], + "d": diffrax.AbstractTerm[Float[Array, " 4"], Any, Any], "e": diffrax.MultiTerm[ - tuple[diffrax.ODETerm, diffrax.AbstractTerm[Any, Float[Array, " 5"]]] + tuple[ + diffrax.ODETerm, diffrax.AbstractTerm[Any, Float[Array, " 5"], Any] + ] ], "f": diffrax.MultiTerm[ - tuple[diffrax.ODETerm, diffrax.AbstractTerm[Any, Float[Array, " 5"]]] + tuple[ + diffrax.ODETerm, diffrax.AbstractTerm[Any, Float[Array, " 5"], Any] + ] ], } interpolation_cls = diffrax.LocalLinearInterpolation - def init(self, terms, t0, t1, y0, args): + def init(self, terms, t0, t1, y0, args, path_state): return None - def step(self, terms, t0, t1, y0, args, solver_state, made_jump): - def _step(_term, _y): - control = _term.contr(t0, t1) - return _y + _term.vf_prod(t0, _y, args, control) + def step(self, terms, t0, t1, y0, args, solver_state, made_jump, path_state): + def _step(_term, _y, state): + control, new_state = _term.contr(t0, t1, state) + return _TestState(_y + _term.vf_prod(t0, _y, args, control), new_state) _is_term = lambda x: isinstance(x, diffrax.AbstractTerm) - y1 = jtu.tree_map(_step, terms, y0, is_leaf=_is_term) + output = jtu.tree_map(_step, terms, y0, path_state, is_leaf=_is_term) + y1 = jtu.tree_map( + lambda x: x.y, output, is_leaf=lambda x: isinstance(x, _TestState) + ) + path_state = jtu.tree_map( + lambda x: x.state, output, is_leaf=lambda x: isinstance(x, _TestState) + ) dense_info = dict(y0=y0, y1=y1) - return y1, None, dense_info, None, diffrax.RESULTS.successful + return y1, None, dense_info, None, path_state, diffrax.RESULTS.successful def func(self, terms, t0, y0, args): assert False diff --git a/test/test_solver.py b/test/test_solver.py index aa618712..8f0f08ca 100644 --- a/test/test_solver.py +++ b/test/test_solver.py @@ -90,13 +90,27 @@ def test_multiple_tableau_single_step(vf_expensive): solver_state1 = None solver_state2 = None else: - solver_state1 = solver1.init(terms, t0, t1, y0, None) - solver_state2 = solver2.init(terms, t0, t1, y0, None) + solver_state1 = solver1.init(terms, t0, t1, y0, None, None) + solver_state2 = solver2.init(terms, t0, t1, y0, None, None) out1 = solver1.step( - terms, t0, t1, y0, None, solver_state=solver_state1, made_jump=False + terms, + t0, + t1, + y0, + None, + solver_state=solver_state1, + made_jump=False, + path_state=(None, None), ) out2 = solver2.step( - terms, t0, t1, y0, None, solver_state=solver_state2, made_jump=False + terms, + t0, + t1, + y0, + None, + solver_state=solver_state2, + made_jump=False, + path_state=(None, None), ) out2[2]["k"] = out2[2]["k"][0] + out2[2]["k"][1] assert tree_allclose(out1, out2) @@ -191,11 +205,14 @@ def test_everything_pytree(implicit, vf_expensive, adaptive): class Term(diffrax.AbstractTerm): coeff: float + def init(self, t0, t1, y0, args): + return None + def vf(self, t, y, args): return {"f": -self.coeff * y["y"]} - def contr(self, t0, t1, **kwargs): - return {"t": t1 - t0} + def contr(self, t0, t1, control_state, **kwargs): + return {"t": t1 - t0}, control_state def prod(self, vf, control): return {"y": vf["f"] * control["t"]} @@ -288,13 +305,13 @@ class ReferenceSil3(diffrax.AbstractImplicitSolver): def order(self, terms): return 2 - def init(self, terms, t0, t1, y0, args): + def init(self, terms, t0, t1, y0, args, path_state): return None def func(self, terms, t0, y0, args): assert False - def step(self, terms, t0, t1, y0, args, solver_state, made_jump): + def step(self, terms, t0, t1, y0, args, solver_state, made_jump, path_state): del solver_state, made_jump explicit, implicit = terms.terms dt = t1 - t0 @@ -369,7 +386,7 @@ def _fourth_stage(yc, _): dense_info = dict(y0=y0, y1=y1, k=ks) state = (False, (f3 / dt, g3 / dt)) result = jtu.tree_map(jnp.asarray, diffrax.RESULTS.successful) - return y1, y_error, dense_info, state, result + return y1, y_error, dense_info, state, path_state, result reference_solver = ReferenceSil3(root_finder=optx.Newton(rtol=1e-8, atol=1e-8)) solver = diffrax.Sil3(root_finder=diffrax.VeryChord(rtol=1e-8, atol=1e-8)) @@ -396,10 +413,26 @@ def f2(t, y, args): y0 = jr.normal(ykey, (2,), dtype=dtype) args = None - state = solver.init(terms, t0, t1, y0, args) - out = solver.step(terms, t0, t1, y0, args, solver_state=state, made_jump=False) + state = solver.init(terms, t0, t1, y0, args, None) + out = solver.step( + terms, + t0, + t1, + y0, + args, + solver_state=state, + made_jump=False, + path_state=(None, None), + ) reference_out = reference_solver.step( - terms, t0, t1, y0, args, solver_state=None, made_jump=False + terms, + t0, + t1, + y0, + args, + solver_state=None, + made_jump=False, + path_state=(None, None), ) assert tree_allclose(out, reference_out) diff --git a/test/test_term.py b/test/test_term.py index 8e8bf8be..324379b1 100644 --- a/test/test_term.py +++ b/test/test_term.py @@ -15,7 +15,7 @@ def vector_field(t, y, args) -> Array: return -y term = diffrax.ODETerm(vector_field) - dt = term.contr(0, 1) + dt, state = term.contr(0, 1, None) vf = term.vf(0, 1, None) vf_prod = term.vf_prod(0, 1, None, dt) assert tree_allclose(vf_prod, term.prod(vf, dt)) @@ -30,10 +30,16 @@ def test_control_term(getkey): vector_field = lambda t, y, args: jr.normal(args, (3, 2)) derivkey = getkey() - class Control(diffrax.AbstractPath[Shaped[Array, "2"]]): + class Control(diffrax.AbstractPath[Shaped[Array, "2"], None]): t0 = 0 t1 = 1 + def init(self, t0, t1, y0, args): + return None + + def __call__(self, t0, path_state: None, t1=None, left=True): + return self.evaluate(t0, t1, left), path_state + def evaluate(self, t0, t1=None, left=True): return jr.normal(getkey(), (2,)) @@ -43,7 +49,7 @@ def derivative(self, t, left=True): control = Control() term = diffrax.ControlTerm(vector_field, control) args = getkey() - dx = term.contr(0, 1) + dx, state = term.contr(0, 1, None) y = jnp.array([1.0, 2.0, 3.0]) vf = term.vf(0, y, args) vf_prod = term.vf_prod(0, y, args, dx) @@ -57,11 +63,11 @@ def derivative(self, t, left=True): # `# type: ignore` is used for contrapositive static type checking as per: # https://github.com/microsoft/pyright/discussions/2411#discussioncomment-2028001 - _: diffrax.ControlTerm[PyTree[Array], Array] = term - __: diffrax.ControlTerm[PyTree[Array], diffrax.BrownianIncrement] = term # type: ignore + _: diffrax.ControlTerm[PyTree[Array], Array, None] = term + __: diffrax.ControlTerm[PyTree[Array], diffrax.BrownianIncrement, None] = term # type: ignore term = term.to_ode() - dt = term.contr(0, 1) + dt, state = term.contr(0, 1, None) vf = term.vf(0, y, args) vf_prod = term.vf_prod(0, y, args, dt) assert vf.shape == (3,) @@ -77,6 +83,12 @@ class Control(diffrax.AbstractPath): t0 = 0 t1 = 1 + def init(self, t0, t1, y0, args): + return None + + def __call__(self, t0, path_state, t1=None, left=True): + return self.evaluate(t0, t1, left), path_state + def evaluate(self, t0, t1=None, left=True): return jr.normal(getkey(), (3,)) @@ -86,7 +98,7 @@ def derivative(self, t, left=True): control = Control() term = diffrax.WeaklyDiagonalControlTerm(vector_field, control) args = getkey() - dx = term.contr(0, 1) + dx, state = term.contr(0, 1, None) y = jnp.array([1.0, 2.0, 3.0]) vf = term.vf(0, y, args) vf_prod = term.vf_prod(0, y, args, dx) @@ -99,7 +111,7 @@ def derivative(self, t, left=True): assert tree_allclose(vf_prod, term.prod(vf, dx)) term = term.to_ode() - dt = term.contr(0, 1) + dt, state = term.contr(0, 1, None) vf = term.vf(0, y, args) vf_prod = term.vf_prod(0, y, args, dt) assert vf.shape == (3,) @@ -145,7 +157,7 @@ def __call__(self, t, y, args): randlike = lambda a: jr.normal(getkey(), a.shape) a_term = jtu.tree_map(randlike, eqx.filter(term, eqx.is_array)) aug = (y, a_y, a_args, a_term) - dt = adjoint_term.contr(t, t + 1) + dt, state = adjoint_term.contr(t, t + 1, None) vf_prod1 = adjoint_term.vf_prod(t, aug, args, dt) vf = adjoint_term.vf(t, aug, args) diff --git a/test/test_typing.py b/test/test_typing.py index 4c4f3db1..2c3a8b0f 100644 --- a/test/test_typing.py +++ b/test/test_typing.py @@ -277,20 +277,24 @@ class X9(X3, X2[int, str]): def test_abstract_term(): - assert _abstract_args(dfx.AbstractTerm) == (Any, Any) - assert _abstract_args(dfx.AbstractTerm[int, str]) == (int, str) + assert _abstract_args(dfx.AbstractTerm) == (Any, Any, Any) + assert _abstract_args(dfx.AbstractTerm[int, str, int]) == (int, str, int) def test_ode_term(): - assert _abstract_args(dfx.ODETerm) == (Any, RealScalarLike) - assert _abstract_args(dfx.ODETerm[int]) == (int, RealScalarLike) + assert _abstract_args(dfx.ODETerm) == (Any, RealScalarLike, type(None)) + assert _abstract_args(dfx.ODETerm[int]) == (int, RealScalarLike, type(None)) def test_control_term(): - assert _abstract_args(dfx.ControlTerm) == (Any, Any) - assert _abstract_args(dfx.ControlTerm[int, str]) == (int, str) + assert _abstract_args(dfx.ControlTerm) == (Any, Any, Any) + assert _abstract_args(dfx.ControlTerm[int, str, int]) == (int, str, int) def test_weakly_diagonal_control_term(): - assert _abstract_args(dfx.WeaklyDiagonalControlTerm) == (Any, Any) - assert _abstract_args(dfx.WeaklyDiagonalControlTerm[int, str]) == (int, str) + assert _abstract_args(dfx.WeaklyDiagonalControlTerm) == (Any, Any, Any) + assert _abstract_args(dfx.WeaklyDiagonalControlTerm[int, str, int]) == ( + int, + str, + int, + ) diff --git a/test/test_underdamped_langevin.py b/test/test_underdamped_langevin.py index e945cad5..53a43a24 100644 --- a/test/test_underdamped_langevin.py +++ b/test/test_underdamped_langevin.py @@ -59,7 +59,7 @@ def make_pytree(array_factory): "qq": jnp.ones((), dtype), } - def grad_f(x): + def grad_f(x, _): xa = x["rr"] xb = x["qq"] return {"rr": jtu.tree_map(lambda _x: 0.2 * _x, xa), "qq": xb} @@ -242,7 +242,7 @@ def test_different_args(): u1 = (jnp.array([1, 2]), 1) g2 = (jnp.array([1, 2]), jnp.array([1, 3])) u2 = (jnp.array([1, 2]), jnp.ones((2,))) - grad_f = lambda x: x + grad_f = lambda x, _: x w_shape = ( jax.ShapeDtypeStruct((2,), jnp.float64),