Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
34 changes: 27 additions & 7 deletions essos/augmented_lagrangian.py
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,7 @@
from functools import partial
import optax
import optimistix
from essos.frozen_dofs import FrozenDOFs

class LagrangeMultiplier(NamedTuple):
"""A class containing constrain parameters for Augmented Lagrangian Method"""
Expand Down Expand Up @@ -49,7 +50,7 @@ def __init__(self, init: Callable, loss: Callable):
self.loss = loss


class CompositeConstraint:
class CompositeConstraint(FrozenDOFs):
"""Mutable composite constraint container.

Exposes `init` and `loss` callables (same as `Constraint`) while
Expand All @@ -66,10 +67,16 @@ def __init__(self, init_fn: Callable, loss_fn: Callable, selective_map=None, arg
self._dependencies = {}
self._starting_dofs = None
self._dofs_to_pytree = None
self._init_frozen_dofs()

def clear_cache(self):
self._starting_dofs = None
self._dofs_to_pytree = None
self._init_frozen_dofs()

@property
def _dependency_dof_names(self):
return tuple(self.arg_names)

@property
def dependencies(self):
Expand All @@ -93,7 +100,8 @@ def starting_dofs(self):
if not self._dependencies:
raise RuntimeError("dependencies must be set on composite before accessing starting_dofs")
vals = tuple(self._dependencies[name] for name in self.arg_names)
self._starting_dofs, self._dofs_to_pytree = jax.flatten_util.ravel_pytree(vals)
self._starting_dofs, unraveler = jax.flatten_util.ravel_pytree(vals)
self._dofs_to_pytree = lambda dofs: unraveler(self._project_dofs(dofs))
return self._starting_dofs

@property
Expand All @@ -103,7 +111,7 @@ def dofs_to_pytree(self):
return self._dofs_to_pytree


class SelectiveConstraint:
class SelectiveConstraint(FrozenDOFs):
"""Wraps a constraint with selective named dependencies, similar to custom_loss.

This allows constraints to only depend on a subset of the available degrees of freedom
Expand Down Expand Up @@ -154,10 +162,16 @@ def __init__(self, constraint: BaseConstraint, *arg_names, **kwargs):
self._dependencies = {}
self._starting_dofs = None
self._dofs_to_pytree = None
self._init_frozen_dofs()

def clear_cache(self):
self._starting_dofs = None
self._dofs_to_pytree = None
self._init_frozen_dofs()

@property
def _dependency_dof_names(self):
return tuple(self.arg_names)

@property
def dependencies(self):
Expand Down Expand Up @@ -190,7 +204,8 @@ def starting_dofs(self):
if not self._dependencies:
raise RuntimeError("dependencies must be set before accessing starting_dofs")
vals = tuple(self._dependencies[name] for name in self.arg_names)
self._starting_dofs, self._dofs_to_pytree = jax.flatten_util.ravel_pytree(vals)
self._starting_dofs, unraveler = jax.flatten_util.ravel_pytree(vals)
self._dofs_to_pytree = lambda dofs: unraveler(self._project_dofs(dofs))
return self._starting_dofs

@property
Expand Down Expand Up @@ -472,6 +487,10 @@ def wrapped_init(*a, **kw):
is_object_like = hasattr(first, 'B') or hasattr(first, 'coils') or hasattr(first, 'dofs') or isinstance(first, dict)
looks_flat = (hasattr(first, 'ndim') or hasattr(first, 'shape') or hasattr(first, 'aval'))
if a and (looks_flat and not is_object_like):
if combined._frozen_dofs_mask is not None:
all_pytrees = combined.dofs_to_pytree(a[0])
pytrees = tuple(all_pytrees[idx] for idx in s._composite_index_map)
return f(*pytrees, **merged_kw)
# Try per-selective unravel first; if it fails, fall back to composite unravel
try:
pytrees = s.dofs_to_pytree(a[0])
Expand Down Expand Up @@ -500,6 +519,10 @@ def wrapped_loss(p, *a, **kw):
is_object_like = hasattr(first, 'B') or hasattr(first, 'coils') or hasattr(first, 'dofs') or isinstance(first, dict)
looks_flat = (hasattr(first, 'ndim') or hasattr(first, 'shape') or hasattr(first, 'aval'))
if a and (looks_flat and not is_object_like):
if combined._frozen_dofs_mask is not None:
all_pytrees = combined.dofs_to_pytree(a[0])
pytrees = tuple(all_pytrees[idx] for idx in s._composite_index_map)
return f(p, *pytrees, **merged_kw)
try:
pytrees = s.dofs_to_pytree(a[0])
return f(p, *pytrees, **merged_kw)
Expand Down Expand Up @@ -883,6 +906,3 @@ def update_fn(params, lag_state,grad,info,beta=beta,mu_max=mu_max,alpha=alpha,ga






131 changes: 131 additions & 0 deletions essos/frozen_dofs.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,131 @@
"""User-facing selectors for freezing ESSOS optimization degrees of freedom."""
import jax.numpy as jnp
from jax.flatten_util import ravel_pytree


class FrozenDOFs:
"""Mixin for losses and constraints whose DOFs are built from dependencies.

Subclasses provide ``dependencies`` and ``_dependency_dof_names`` in the
same order used to construct ``starting_dofs``.
"""
def _init_frozen_dofs(self):
self._frozen_dofs_mask = None
self._frozen_dofs_values = None

def freeze_dofs(self, mask):
"""Freeze a flat boolean mask, or a matching pytree, at initial values."""
if not hasattr(mask, "shape"):
mask, _ = ravel_pytree(mask)
mask = jnp.asarray(mask, dtype=bool).reshape(-1)
if mask.shape != self.starting_dofs.shape:
raise ValueError(
f"freeze mask has shape {mask.shape}; expected {self.starting_dofs.shape}."
)
self._frozen_dofs_mask = mask
self._frozen_dofs_values = self.starting_dofs
return self

def unfreeze_dofs(self):
"""Remove every frozen-DOF selection from this loss or constraint."""
self._init_frozen_dofs()
return self

def _project_dofs(self, dofs):
if self._frozen_dofs_mask is None:
return dofs
return jnp.where(self._frozen_dofs_mask, self._frozen_dofs_values, dofs)

def _mask_gradient(self, gradient):
if self._frozen_dofs_mask is None:
return gradient
return jnp.where(self._frozen_dofs_mask, 0, gradient)

def _dependency_offset(self, dependency):
names = tuple(self._dependency_dof_names)
if dependency not in names:
raise KeyError(
f"{dependency!r} is not an optimizable dependency. Available: {names}."
)
preceding = tuple(self.dependencies[name] for name in names[:names.index(dependency)])
return 0 if not preceding else ravel_pytree(preceding)[0].size

def _add_frozen_indices(self, indices):
mask = (jnp.zeros_like(self.starting_dofs, dtype=bool)
if self._frozen_dofs_mask is None else self._frozen_dofs_mask)
indices = jnp.asarray(indices, dtype=int).reshape(-1)
if jnp.any(indices < 0) or jnp.any(indices >= mask.size):
raise IndexError("selected DOF index is outside starting_dofs.")
return self.freeze_dofs(mask.at[indices].set(True))

@staticmethod
def _indices(values, size, label):
values = [values] if isinstance(values, int) else list(values)
if any(value < 0 or value >= size for value in values):
raise IndexError(f"{label} must be in [0, {size - 1}].")
return values

def freeze_current(self, dependency="field", coil=0):
"""Freeze normalized current DOFs for one or more base coils."""
field = self.dependencies[dependency]
coils = field.coils
current_indices = self._indices(coil, coils.dofs_currents.size, "coil index")
start = self._dependency_offset(dependency) + coils.dofs_curves.size
return self._add_frozen_indices([start + index for index in current_indices])

def freeze_coil(self, dependency="field", coil=0):
"""Freeze every curve coefficient of one or more base coils."""
field = self.dependencies[dependency]
shape = field.coils.dofs_curves.shape
coil_indices = self._indices(coil, shape[0], "coil index")
per_coil = shape[1] * shape[2]
start = self._dependency_offset(dependency)
return self._add_frozen_indices(
[start + coil_index * per_coil + local for coil_index in coil_indices for local in range(per_coil)]
)

def freeze_curve_dofs(self, dependency="field", coil=0, coordinates=None, modes=None):
"""Freeze selected stored curve coefficients of one or more base coils.

``coordinates`` accepts ``"x"``, ``"y"``, ``"z"`` (or 0, 1, 2),
and ``modes`` are indices into ``Curves.dofs[..., mode]``.
"""
field = self.dependencies[dependency]
shape = field.coils.dofs_curves.shape
coil_indices = self._indices(coil, shape[0], "coil index")
if coordinates is None:
coordinates = range(shape[1])
if modes is None:
modes = range(shape[2])
coordinate_map = {"x": 0, "y": 1, "z": 2}
if isinstance(coordinates, (int, str)):
coordinates = [coordinates]
coordinates = [coordinate_map.get(value, value) for value in coordinates]
coordinates = self._indices(coordinates, shape[1], "coordinate index")
modes = self._indices(modes, shape[2], "mode index")
start = self._dependency_offset(dependency)
per_coil = shape[1] * shape[2]
return self._add_frozen_indices([
start + coil_index * per_coil + coordinate * shape[2] + mode
for coil_index in coil_indices for coordinate in coordinates for mode in modes
])

def freeze_surface_modes(self, dependency="surface", rc=(), zs=()):
"""Freeze ``SurfaceRZFourier`` coefficients by physical ``(m, n)`` mode."""
surface = self.dependencies[dependency]
start = self._dependency_offset(dependency)

def mode_indices(modes, coefficients, component):
out = []
for m, n in modes:
matches = jnp.where((surface.xm == m) & (surface.xn == n))[0]
if matches.size != 1:
raise KeyError(f"{component}({n},{m}) is not present on this surface.")
out.append(start + coefficients + int(matches[0]))
return out

indices = mode_indices(rc, 0, "RBC")
indices += mode_indices(zs, surface.rc.size, "ZBS")
if not indices:
raise ValueError("select at least one rc or zs surface mode.")
return self._add_frozen_indices(indices)
48 changes: 39 additions & 9 deletions essos/losses.py
Original file line number Diff line number Diff line change
Expand Up @@ -2,19 +2,22 @@
import jax.numpy as jnp
from jax import tree_util, jit, ensure_compile_time_eval, grad as jax_grad, value_and_grad as jax_value_and_grad
from jax.flatten_util import ravel_pytree
from essos.frozen_dofs import FrozenDOFs

class base_loss:
class base_loss(FrozenDOFs):
def __init__(self):
self.losses = [self]
self._dependencies = {}
self._dependencies_buffer = None
self._starting_dofs = None
self._dofs_to_pytree = None
self._init_frozen_dofs()

def clear_cache(self):
self._dependencies_buffer = None
self._starting_dofs = None
self._dofs_to_pytree = None
self._init_frozen_dofs()

@property
def dependencies(self):
Expand Down Expand Up @@ -77,6 +80,10 @@ def clear_cache(self):
super().clear_cache()
self._dofs_to_args = None

@property
def _dependency_dof_names(self):
return self.args_names

def _ensure_unravelers(self):
if self._starting_dofs is None or self._dofs_to_args is None or self._dofs_to_pytree is None:
# Dependencies are constants of this loss. If the first call is
Expand All @@ -89,6 +96,7 @@ def _ensure_unravelers(self):
self._dofs_to_args = tuple_unraveler

def _named_unraveler(dofs):
dofs = self._project_dofs(dofs)
args = tuple_unraveler(dofs)
return {name: value for name, value in zip(self.args_names, args)}

Expand All @@ -104,51 +112,67 @@ def starting_dofs(self):
def dofs_to_pytree(self):
self._ensure_unravelers()
return self._dofs_to_pytree

def _project_args(self, args):
if self._frozen_dofs_mask is None:
return args
masks = self._dofs_to_args(self._frozen_dofs_mask)
frozen_args = self._dofs_to_args(self._frozen_dofs_values)
return tuple(jnp.where(mask, frozen, arg)
for arg, mask, frozen in zip(args, masks, frozen_args))

@partial(jit, static_argnames=['self'])
def __call__(self, dofs: jnp.ndarray) -> float:
self._ensure_unravelers()
args = self._dofs_to_args(dofs)
args = self._dofs_to_args(self._project_dofs(dofs))
return self.fun(*args, **self.kwargs)

@partial(jit, static_argnames=['self'])
def call_pytree(self, dofs_pytree) -> float:
self._ensure_unravelers()
if isinstance(dofs_pytree, dict):
args = tuple(dofs_pytree[name] for name in self.args_names)
else:
args = tuple(dofs_pytree)
args = self._project_args(args)
return self.fun(*args, **self.kwargs)

@partial(jit, static_argnames=['self'])
def grad(self, dofs: jnp.ndarray) -> jnp.ndarray:
self._ensure_unravelers()
args = self._dofs_to_args(dofs)
args = self._dofs_to_args(self._project_dofs(dofs))
gradient = jax_grad(self.fun, argnums=tuple(range(len(args))))(*args, **self.kwargs)
return ravel_pytree(gradient)[0]
return self._mask_gradient(ravel_pytree(gradient)[0])

@partial(jit, static_argnames=['self'])
def value_and_grad(self, dofs: jnp.ndarray):
self._ensure_unravelers()
args = self._dofs_to_args(dofs)
args = self._dofs_to_args(self._project_dofs(dofs))
value, gradient = jax_value_and_grad(
self.fun,
argnums=tuple(range(len(args))),
)(*args, **self.kwargs)
return value, ravel_pytree(gradient)[0]
return value, self._mask_gradient(ravel_pytree(gradient)[0])

@partial(jit, static_argnames=['self'])
def grad_pytree(self, dofs_pytree) -> dict:
self._ensure_unravelers()
if isinstance(dofs_pytree, dict):
args = tuple(dofs_pytree[name] for name in self.args_names)
else:
args = tuple(dofs_pytree)
args = self._project_args(args)
gradient = jax_grad(self.fun, argnums=tuple(range(len(args))))(*args, **self.kwargs)
# Build a fresh zeros structure locally instead of using the cached
# dependencies_buffer property, which would cache a traced value and
# leak it out of this jit scope (UnexpectedTracerError).
buffer = tree_util.tree_map(jnp.zeros_like, self.dependencies)
for dep, g in zip(self.args_names, gradient):
buffer[dep] = g
if self._frozen_dofs_mask is not None:
masks = self._dofs_to_args(self._frozen_dofs_mask)
for dep, mask in zip(self.args_names, masks):
buffer[dep] = jnp.where(mask, 0, buffer[dep])
return buffer

def __mul__(self, other):
Expand Down Expand Up @@ -177,6 +201,10 @@ def __init__(self, losses: list):
@property
def dependencies(self):
return self._dependencies

@property
def _dependency_dof_names(self):
return tuple(sorted(self.dependencies))

@dependencies.setter
def dependencies(self, value):
Expand All @@ -191,14 +219,16 @@ def dependencies(self, value):
def starting_dofs(self):
if self._starting_dofs is None:
with ensure_compile_time_eval():
self._starting_dofs, self._dofs_to_pytree = ravel_pytree(self.dependencies)
self._starting_dofs, unraveler = ravel_pytree(self.dependencies)
self._dofs_to_pytree = lambda dofs: unraveler(self._project_dofs(dofs))
return self._starting_dofs

@property
def dofs_to_pytree(self):
if self._dofs_to_pytree is None:
with ensure_compile_time_eval():
self._starting_dofs, self._dofs_to_pytree = ravel_pytree(self.dependencies)
self._starting_dofs, unraveler = ravel_pytree(self.dependencies)
self._dofs_to_pytree = lambda dofs: unraveler(self._project_dofs(dofs))
return self._dofs_to_pytree

@partial(jit, static_argnames=['self'])
Expand All @@ -217,4 +247,4 @@ def grad(self, dofs: jnp.ndarray) -> jnp.ndarray:

grad = tree_util.tree_map(lambda *dofs: jnp.sum(jnp.stack(dofs), axis=0), *grads_each_loss)
dofs_grad = ravel_pytree(grad)[0]
return dofs_grad
return self._mask_gradient(dofs_grad)
Loading
Loading